From 5d2654b1bacd3cf7375b8bb67e822fc0969b2044 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Tue, 23 Mar 2021 21:30:54 -0400
Subject: [PATCH 001/399] Implement Unit Test Suite for TorqueScript.

---
 Engine/source/console/test/ScriptTest.cpp  | 395 +++++++++++++++++++++
 Engine/source/console/test/consoleTest.cpp |  34 +-
 Tools/CMake/torque3d.cmake                 |   1 +
 3 files changed, 397 insertions(+), 33 deletions(-)
 create mode 100644 Engine/source/console/test/ScriptTest.cpp

diff --git a/Engine/source/console/test/ScriptTest.cpp b/Engine/source/console/test/ScriptTest.cpp
new file mode 100644
index 000000000..994606783
--- /dev/null
+++ b/Engine/source/console/test/ScriptTest.cpp
@@ -0,0 +1,395 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2012 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+
+#ifdef TORQUE_TESTS_ENABLED
+#include "testing/unitTesting.h"
+#include "platform/platform.h"
+#include "console/simBase.h"
+#include "console/consoleTypes.h"
+#include "console/simBase.h"
+#include "console/engineAPI.h"
+#include "math/mMath.h"
+#include "console/stringStack.h"
+
+template<typename T>
+inline T Convert(ConsoleValueRef);
+
+template<>
+inline U32 Convert(ConsoleValueRef val)
+{
+   return val.getIntValue();
+}
+
+template<>
+inline S32 Convert(ConsoleValueRef val)
+{
+   return val.getSignedIntValue();
+}
+
+template<>
+inline bool Convert(ConsoleValueRef val)
+{
+   return val.getBoolValue();
+}
+
+template<>
+inline F32 Convert(ConsoleValueRef val)
+{
+   return val.getFloatValue();
+}
+
+template<>
+inline const char* Convert(ConsoleValueRef val)
+{
+   return val.getStringValue();
+}
+
+template<>
+inline SimObject* Convert(ConsoleValueRef val)
+{
+   return Sim::findObject(val);
+}
+
+template<typename T>
+inline T RunScript(const char* str)
+{
+   return Convert<T>(Con::evaluate(str, false, NULL));
+}
+
+TEST(Script, Basic_Arithmetic)
+{
+   S32 add = RunScript<S32>(R"(
+         return 1.0 + 1;
+   )");
+
+   EXPECT_EQ(add, 2);
+
+   S32 sub = RunScript<S32>(R"(
+         return 10 - 1.0;
+   )");
+
+   EXPECT_EQ(sub, 9);
+
+   S32 mult = RunScript<S32>(R"(
+         return 10 * 2.5;
+   )");
+
+   EXPECT_EQ(mult, 25);
+
+   S32 div = RunScript<S32>(R"(
+         return 10.0 / 2;
+   )");
+
+   EXPECT_EQ(div, 5);
+}
+
+TEST(Script, Complex_Arithmetic)
+{
+   S32 result = RunScript<S32>(R"(
+         return 1 * 2 - (0.5 * 2);
+   )");
+
+   EXPECT_EQ(result, 1);
+
+   S32 result2 = RunScript<S32>(R"(
+         return 1 * 2 * 3 % 2;
+   )");
+
+   EXPECT_EQ(result2, 0);
+}
+
+TEST(Script, Basic_Concatination)
+{
+   const char* result1 = RunScript<const char*>(R"(
+         return "a" @ "b";
+   )");
+
+   EXPECT_STREQ(result1, "ab");
+
+   const char* result2 = RunScript<const char*>(R"(
+         return "a" SPC "b";
+   )");
+
+   EXPECT_STREQ(result2, "a b");
+
+   const char* result3 = RunScript<const char*>(R"(
+         return "a" TAB "b";
+   )");
+
+   EXPECT_STREQ(result3, "a\tb");
+
+   const char* result4 = RunScript<const char*>(R"(
+         return "a" NL "b";
+   )");
+
+   EXPECT_STREQ(result4, "a\nb");
+
+   const char* complex = RunScript<const char*>(R"(
+         return "a" @ "b" @ "c" @ "d";
+   )");
+
+   EXPECT_STREQ(complex, "abcd");
+}
+
+TEST(Script, Basic_Global_Variable_Tests)
+{
+   S32 value = RunScript<S32>(R"(
+         $a = 1;
+         return $a;
+   )");
+
+   EXPECT_EQ(value, 1);
+}
+
+TEST(Script, Variable_Chaining_And_Usage)
+{
+   S32 value = RunScript<S32>(R"(
+         function t() 
+         {
+            %a = %b = 2;
+            return %a;
+         }
+         return t();
+   )");
+
+   EXPECT_EQ(value, 2);
+
+   S32 valueGlobal = RunScript<S32>(R"(
+         function t() 
+         {
+            $a = %b = 2;
+         }
+         t();
+         return $a;
+   )");
+
+   EXPECT_EQ(valueGlobal, 2);
+
+   S32 value2 = RunScript<S32>(R"(
+         function t(%a) 
+         {
+            if ((%b = 2 * %a) != 5)
+               return %b;
+            return 5;
+         }
+
+         return t(2);
+   )");
+
+   EXPECT_EQ(value2, 4);
+}
+
+TEST(Script, Basic_Function_Call_And_Local_Variable_Testing)
+{
+   S32 value = RunScript<S32>(R"(
+         function t() { %a = 2; return %a; }
+         return t();
+   )");
+
+   EXPECT_EQ(value, 2);
+
+   S32 value2 = RunScript<S32>(R"(
+         function add(%a, %b) { return %a + %b; }
+         return add(2, 4);
+   )");
+
+   EXPECT_EQ(value2, 6);
+
+   S32 value3 = RunScript<S32>(R"(
+         function fib(%a) {
+            if (%a == 0)
+               return 0;
+            if (%a == 1)
+               return 1;
+            return fib(%a - 1) + fib(%a - 2);
+         }
+         return fib(15);
+   )");
+
+   EXPECT_EQ(value3, 610);
+
+   S32 staticCall = RunScript<S32>(R"(
+         function SimObject::bar(%a, %b) {
+            return %a + %b;
+         }
+         return SimObject::bar(1, 2);
+   )");
+
+   EXPECT_EQ(staticCall, 3);
+}
+
+TEST(Script, Basic_Conditional_Statements)
+{
+   S32 value = RunScript<S32>(R"(
+         $a = "hello";
+         if ($a $= "hello")
+            return 1;
+         return 2;
+   )");
+
+   EXPECT_EQ(value, 1);
+
+   const char* ternaryValue = RunScript<const char*>(R"(
+         return $a $= "hello" ? "World" : "No U";
+   )");
+
+   EXPECT_STREQ(ternaryValue, "World");
+}
+
+TEST(Script, Basic_Loop_Statements)
+{
+   S32 whileValue = RunScript<S32>(R"(
+         $count = 0;
+         while ($count < 5)
+            $count++;
+         return $count;
+   )");
+
+   EXPECT_EQ(whileValue, 5);
+
+   const char* forValue = RunScript<const char*>(R"(
+         function t(%times) 
+         { 
+            %result = "";
+            for (%i = 0; %i < %times; %i++)
+               %result = %result @ "a";
+            return %result;
+         }
+
+         return t(3);
+   )");
+
+   EXPECT_STREQ(forValue, "aaa");
+
+   const char* forIfValue = RunScript<const char*>(R"(
+         function t() {
+            %str = "";
+            for (%i = 0; %i < 5; %i++) {
+
+               %loopValue = %i;
+
+               if (%str $= "") 
+                  %str = %loopValue;
+               else 
+                  %str = %str @ "," SPC %loopValue;
+            }
+            return %str;
+         }
+
+         return t();
+   )");
+
+   EXPECT_STREQ(forIfValue, "0, 1, 2, 3, 4");
+}
+
+TEST(Script, TorqueScript_Array_Testing)
+{
+   S32 value = RunScript<S32>(R"(
+         function t(%idx) { %a[idx] = 2; return %a[idx]; }
+         return t(5);
+   )");
+
+   EXPECT_EQ(value, 2);
+
+   S32 value2 = RunScript<S32>(R"(
+         function t(%idx) { %a[idx, 0] = 2; return %a[idx, 0]; }
+         return t(5);
+   )");
+
+   EXPECT_EQ(value2, 2);
+}
+
+TEST(Script, Basic_SimObject)
+{
+   SimObject* object = RunScript<SimObject*>(R"(
+         return new SimObject(FudgeCollector) {
+            fudge = "Chocolate"; 
+         };
+   )");
+
+   EXPECT_NE(object, (SimObject*)NULL);
+
+   const char* propertyValue = RunScript<const char*>(R"(
+         return FudgeCollector.fudge;
+   )");
+
+   EXPECT_STREQ(propertyValue, "Chocolate");
+
+   const char* funcReturn = RunScript<const char*>(R"(
+         function SimObject::fooFunc(%this)
+         {
+            return "Bar";
+         }
+
+         return FudgeCollector.fooFunc();
+   )");
+
+   EXPECT_STREQ(funcReturn, "Bar");
+
+   const char* parentFn = RunScript<const char*>(R"(
+         new SimObject(Hello);
+
+         function SimObject::fooFunc2(%this)
+         {
+            return "Bar";
+         }
+
+         function Hello::fooFunc2(%this)
+         {
+            %bar = Parent::fooFunc2(%this);
+            return "Foo" @ %bar;
+         }
+
+         return Hello.fooFunc2();
+   )");
+
+   EXPECT_STREQ(parentFn, "FooBar");
+}
+
+TEST(Script, Basic_Package)
+{
+   S32 value = RunScript<S32>(R"(
+         function a() { return 3; }
+         package overrides {
+            function a() { return 5; }
+         };
+         return a();
+   )");
+
+   EXPECT_EQ(value, 3);
+
+   S32 overrideValue = RunScript<S32>(R"(
+         activatePackage(overrides);
+         return a();
+   )");
+
+   EXPECT_EQ(overrideValue, 5);
+
+   S32 deactivatedValue = RunScript<S32>(R"(
+         deactivatePackage(overrides);
+         return a();
+   )");
+
+   EXPECT_EQ(deactivatedValue, 3);
+}
+
+#endif
diff --git a/Engine/source/console/test/consoleTest.cpp b/Engine/source/console/test/consoleTest.cpp
index aa0b3970e..adea797a2 100644
--- a/Engine/source/console/test/consoleTest.cpp
+++ b/Engine/source/console/test/consoleTest.cpp
@@ -252,36 +252,4 @@ TEST(Con, execute)
 	STR.popFrame();
 }
 
-static U32 gConsoleStackFrame = 0;
-
-ConsoleFunction(testConsoleStackFrame, S32, 1, 1, "")
-{
-	gConsoleStackFrame = CSTK.mFrame;
-	return (U32)Con::executef("testScriptEvalFunction"); // execute a sub function which manipulates the stack
-}
-
-TEST(Con, evaluate)
-{
-	U32 startStackPos = CSTK.mStackPos;
-	U32 startStringStackPos = STR.mStart;
-	S32 returnValue = Con::evaluate("function testScriptEvalFunction() {return \"1\"@\"2\"@\"3\";}\nreturn testConsoleStackFrame();", false, "testEvaluate");
-	U32 frame = CSTK.mFrame;
-
-	EXPECT_TRUE(returnValue == 123) <<
-		"Evaluate should return 123";
-
-	EXPECT_TRUE(gConsoleStackFrame == (frame+2)) <<
-		"Console stack frame inside function should be +2";
-
-	EXPECT_TRUE(CSTK.mFrame == frame) <<
-		"Console stack frame outside function should be the same as before";
-
-	EXPECT_TRUE(STR.mStart == startStringStackPos) <<
-		"Console string stack should not be changed";
-
-	EXPECT_TRUE(CSTK.mStackPos == startStackPos) <<
-		"Console stack should not be changed";
-
-}
-
-#endif
\ No newline at end of file
+#endif
diff --git a/Tools/CMake/torque3d.cmake b/Tools/CMake/torque3d.cmake
index 0c1791a5d..c64a18986 100644
--- a/Tools/CMake/torque3d.cmake
+++ b/Tools/CMake/torque3d.cmake
@@ -247,6 +247,7 @@ addPath("${srcDir}/sfx/media")
 addPath("${srcDir}/sfx/null")
 addPath("${srcDir}/sfx")
 addPath("${srcDir}/console")
+addPath("${srcDir}/console/test")
 addPath("${srcDir}/core")
 addPath("${srcDir}/core/stream")
 addPath("${srcDir}/core/strings")

From 35500a87c60d84efe8077c9bda064ca02da4b69e Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Tue, 30 Mar 2021 19:33:19 -0400
Subject: [PATCH 002/399] initial port of the new interpreter

---
 Engine/source/T3D/gameBase/gameConnection.cpp |   13 +-
 Engine/source/app/net/net.cpp                 |    4 +-
 Engine/source/app/net/tcpObject.cpp           |    4 +-
 Engine/source/app/net/tcpObject.h             |    2 +-
 Engine/source/console/SimXMLDocument.cpp      |    2 +-
 Engine/source/console/SimXMLDocument.h        |    2 +-
 Engine/source/console/ast.h                   |  278 +-
 Engine/source/console/astAlloc.cpp            |  180 +-
 Engine/source/console/astNodes.cpp            | 1297 +++----
 Engine/source/console/codeBlock.cpp           | 1517 ++++-----
 Engine/source/console/codeInterpreter.cpp     | 3018 -----------------
 Engine/source/console/codeInterpreter.h       |  262 --
 Engine/source/console/compiledEval.cpp        | 1909 ++++++++++-
 Engine/source/console/compiler.h              |   24 +-
 Engine/source/console/console.cpp             |  229 +-
 Engine/source/console/consoleInternal.cpp     |  165 +-
 Engine/source/console/consoleInternal.h       |   83 +-
 Engine/source/console/consoleLogger.cpp       |    8 +-
 Engine/source/console/consoleLogger.h         |    2 +-
 Engine/source/console/consoleValueStack.h     |  121 +
 Engine/source/console/sim.h                   |    9 +-
 Engine/source/console/simManager.cpp          |   23 +-
 Engine/source/console/simSet.cpp              |   12 +-
 Engine/source/console/simSet.h                |    4 +-
 Engine/source/console/stringStack.cpp         |  225 --
 Engine/source/console/stringStack.h           |   44 -
 Engine/source/console/test/ScriptTest.cpp     |    2 +
 Engine/source/console/test/consoleTest.cpp    |    3 +
 Engine/source/console/test/engineAPITest.cpp  |    4 +-
 Engine/source/core/strings/stringFunctions.h  |    5 +
 Engine/source/environment/waterObject.cpp     |    2 +-
 Engine/source/environment/waterObject.h       |    2 +-
 Engine/source/gui/core/guiControl.cpp         |    2 +-
 Engine/source/gui/core/guiControl.h           |    2 +-
 Engine/source/gui/worldEditor/worldEditor.cpp |    6 +-
 Engine/source/gui/worldEditor/worldEditor.h   |    2 +-
 Engine/source/platformWin32/winMath.cpp       |   19 +-
 Engine/source/sfx/sfxSource.cpp               |    2 +-
 Engine/source/sfx/sfxSource.h                 |    2 +-
 Engine/source/sfx/sfxTrack.cpp                |    2 +-
 Engine/source/sfx/sfxTrack.h                  |    2 +-
 .../shaderGen/GLSL/customFeatureGLSL.cpp      |    6 +-
 .../source/shaderGen/GLSL/customFeatureGLSL.h |    2 +-
 .../shaderGen/HLSL/customFeatureHLSL.cpp      |    6 +-
 .../source/shaderGen/HLSL/customFeatureHLSL.h |    2 +-
 .../source/shaderGen/customShaderFeature.cpp  |    2 +-
 Engine/source/shaderGen/customShaderFeature.h |    2 +-
 47 files changed, 3675 insertions(+), 5839 deletions(-)
 delete mode 100644 Engine/source/console/codeInterpreter.cpp
 delete mode 100644 Engine/source/console/codeInterpreter.h
 create mode 100644 Engine/source/console/consoleValueStack.h

diff --git a/Engine/source/T3D/gameBase/gameConnection.cpp b/Engine/source/T3D/gameBase/gameConnection.cpp
index 01ae0ee17..e4a4c9f5e 100644
--- a/Engine/source/T3D/gameBase/gameConnection.cpp
+++ b/Engine/source/T3D/gameBase/gameConnection.cpp
@@ -331,7 +331,7 @@ DefineEngineStringlyVariadicMethod(GameConnection, setConnectArgs, void, 3, 17,
    
    "@see GameConnection::onConnect()\n\n")
 {
-   StringStackWrapper args(argc - 2, argv + 2);
+   ConsoleValueToStringArrayWrapper args(argc - 2, argv + 2);
    object->setConnectArgs(args.count(), args);
 }
 
@@ -494,11 +494,17 @@ bool GameConnection::readConnectRequest(BitStream *stream, const char **errorStr
       *errorString = "CR_INVALID_ARGS";
       return false;
    }
-   ConsoleValueRef connectArgv[MaxConnectArgs + 3];
+   ConsoleValue connectArgv[MaxConnectArgs + 3];
    ConsoleValue connectArgvValue[MaxConnectArgs + 3];
 
+   // TODO(JTH): Fix pls.
+   AssertISV(false, "TODO: FIX CONSOLE VALUE");
+   return false;
+
+   /*
    for(U32 i = 0; i < mConnectArgc+3; i++)
    {
+
       connectArgv[i].value = &connectArgvValue[i];
       connectArgvValue[i].init();
    }
@@ -524,6 +530,7 @@ bool GameConnection::readConnectRequest(BitStream *stream, const char **errorStr
       return false;
    }
    return true;
+   */
 }
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -1088,7 +1095,7 @@ bool GameConnection::readDemoStartBlock(BitStream *stream)
 void GameConnection::demoPlaybackComplete()
 {
    static const char* demoPlaybackArgv[1] = { "demoPlaybackComplete" };
-   static StringStackConsoleWrapper demoPlaybackCmd(1, demoPlaybackArgv);
+   static StringArrayToConsoleValueWrapper demoPlaybackCmd(1, demoPlaybackArgv);
 
    Sim::postCurrentEvent(Sim::getRootGroup(), new SimConsoleEvent(demoPlaybackCmd.argc, demoPlaybackCmd.argv, false));
    Parent::demoPlaybackComplete();
diff --git a/Engine/source/app/net/net.cpp b/Engine/source/app/net/net.cpp
index 3de813e89..1e2255323 100644
--- a/Engine/source/app/net/net.cpp
+++ b/Engine/source/app/net/net.cpp
@@ -251,7 +251,7 @@ DefineEngineStringlyVariadicFunction( commandToServer, void, 2, RemoteCommandEve
    NetConnection *conn = NetConnection::getConnectionToServer();
    if(!conn)
       return;
-   StringStackWrapper args(argc - 1, argv + 1);
+   ConsoleValueToStringArrayWrapper args(argc - 1, argv + 1);
    RemoteCommandEvent::sendRemoteCommand(conn, args.count(), args);
 }
 
@@ -289,7 +289,7 @@ DefineEngineStringlyVariadicFunction( commandToClient, void, 3, RemoteCommandEve
    NetConnection *conn;
    if(!Sim::findObject(argv[1], conn))
       return;
-   StringStackWrapper args(argc - 2, argv + 2);
+   ConsoleValueToStringArrayWrapper args(argc - 2, argv + 2);
    RemoteCommandEvent::sendRemoteCommand(conn, args.count(), args);
 }
 
diff --git a/Engine/source/app/net/tcpObject.cpp b/Engine/source/app/net/tcpObject.cpp
index 07c8908eb..1b77e3bad 100644
--- a/Engine/source/app/net/tcpObject.cpp
+++ b/Engine/source/app/net/tcpObject.cpp
@@ -236,13 +236,13 @@ TCPObject::~TCPObject()
    }
 }
 
-bool TCPObject::processArguments(S32 argc, ConsoleValueRef *argv)
+bool TCPObject::processArguments(S32 argc, ConsoleValue *argv)
 {
    if(argc == 0)
       return true;
    else if(argc == 1)
    {
-      addToTable(NetSocket::fromHandle(dAtoi(argv[0])));
+      addToTable(NetSocket::fromHandle(argv[0].getInt()));
       return true;
    }
    return false;
diff --git a/Engine/source/app/net/tcpObject.h b/Engine/source/app/net/tcpObject.h
index 9a8b5e40d..a869f48be 100644
--- a/Engine/source/app/net/tcpObject.h
+++ b/Engine/source/app/net/tcpObject.h
@@ -83,7 +83,7 @@ public:
    void disconnect();
    State getState() { return mState; }
 
-   bool processArguments(S32 argc, ConsoleValueRef *argv);
+   bool processArguments(S32 argc, ConsoleValue *argv);
    void send(const U8 *buffer, U32 bufferLen);
 
    ///Send an entire file over tcp
diff --git a/Engine/source/console/SimXMLDocument.cpp b/Engine/source/console/SimXMLDocument.cpp
index df45888d1..66a116dfe 100644
--- a/Engine/source/console/SimXMLDocument.cpp
+++ b/Engine/source/console/SimXMLDocument.cpp
@@ -158,7 +158,7 @@ SimXMLDocument::~SimXMLDocument()
 // -----------------------------------------------------------------------------
 // Included for completeness.
 // -----------------------------------------------------------------------------
-bool SimXMLDocument::processArguments(S32 argc, ConsoleValueRef *argv)
+bool SimXMLDocument::processArguments(S32 argc, ConsoleValue *argv)
 {
    return argc == 0;
 }
diff --git a/Engine/source/console/SimXMLDocument.h b/Engine/source/console/SimXMLDocument.h
index 342917cff..d31104a68 100644
--- a/Engine/source/console/SimXMLDocument.h
+++ b/Engine/source/console/SimXMLDocument.h
@@ -57,7 +57,7 @@ class SimXMLDocument: public SimObject
       // tie in to the script language.  The .cc file has more in depth
       // comments on these.
       //-----------------------------------------------------------------------
-      bool processArguments(S32 argc, ConsoleValueRef *argv);
+      bool processArguments(S32 argc, ConsoleValue *argv);
       bool onAdd();
       void onRemove();
       static void initPersistFields();
diff --git a/Engine/source/console/ast.h b/Engine/source/console/ast.h
index f81971413..558446534 100644
--- a/Engine/source/console/ast.h
+++ b/Engine/source/console/ast.h
@@ -39,8 +39,15 @@ enum TypeReq
    TypeReqNone,
    TypeReqUInt,
    TypeReqFloat,
-   TypeReqString,
-   TypeReqVar
+   TypeReqString
+};
+
+enum ExprNodeName
+{
+   NameExprNode,
+   NameFloatNode,
+   NameIntNode,
+   NameVarNode
 };
 
 /// Representation of a node for the scripting language parser.
@@ -52,7 +59,7 @@ enum TypeReq
 /// each representing a different language construct.
 struct StmtNode
 {
-   StmtNode *mNext;   ///< Next entry in parse tree.
+   StmtNode* next;   ///< Next entry in parse tree.
 
    StmtNode();
    virtual ~StmtNode() {}
@@ -61,8 +68,8 @@ struct StmtNode
    /// @{
 
    ///
-   void append(StmtNode *next);
-   StmtNode *getNext() const { return mNext; }
+   void append(StmtNode* next);
+   StmtNode* getNext() const { return next; }
 
    /// @}
 
@@ -79,93 +86,95 @@ struct StmtNode
    /// @name Breaking
    /// @{
 
-   void addBreakLine(CodeStream &codeStream);
+   void addBreakLine(CodeStream& codeStream);
    /// @}
 
    /// @name Compilation
    /// @{
 
-   virtual U32 compileStmt(CodeStream &codeStream, U32 ip) = 0;
+   virtual U32 compileStmt(CodeStream& codeStream, U32 ip) = 0;
    virtual void setPackage(StringTableEntry packageName);
    /// @}
 };
 
 /// Helper macro
 #ifndef DEBUG_AST_NODES
-#  define DBG_STMT_TYPE(s) virtual String dbgStmtType() const { return String(#s); }
+#  define DBG_STMT_TYPE(s) virtual const char* dbgStmtType() const { return "#s"; }
 #else
 #  define DBG_STMT_TYPE(s) 
 #endif
 
 struct BreakStmtNode : StmtNode
 {
-   static BreakStmtNode *alloc(S32 lineNumber);
+   static BreakStmtNode* alloc(S32 lineNumber);
 
 
-   U32 compileStmt(CodeStream &codeStream, U32 ip);
+   U32 compileStmt(CodeStream& codeStream, U32 ip);
    DBG_STMT_TYPE(BreakStmtNode);
 };
 
 struct ContinueStmtNode : StmtNode
 {
-   static ContinueStmtNode *alloc(S32 lineNumber);
+   static ContinueStmtNode* alloc(S32 lineNumber);
 
-   U32 compileStmt(CodeStream &codeStream, U32 ip);
+   U32 compileStmt(CodeStream& codeStream, U32 ip);
    DBG_STMT_TYPE(ContinueStmtNode);
 };
 
 /// A mathematical expression.
 struct ExprNode : StmtNode
 {
+   ExprNode* optimizedNode;
 
-   U32 compileStmt(CodeStream &codeStream, U32 ip);
+   U32 compileStmt(CodeStream& codeStream, U32 ip);
 
-   virtual U32 compile(CodeStream &codeStream, U32 ip, TypeReq type) = 0;
+   virtual U32 compile(CodeStream& codeStream, U32 ip, TypeReq type) = 0;
    virtual TypeReq getPreferredType() = 0;
+   virtual ExprNodeName getExprNodeNameEnum() const { return NameExprNode; }
 };
 
 struct ReturnStmtNode : StmtNode
 {
-   ExprNode *expr;
+   ExprNode* expr;
 
-   static ReturnStmtNode *alloc(S32 lineNumber, ExprNode *expr);
+   static ReturnStmtNode* alloc(S32 lineNumber, ExprNode* expr);
 
-   U32 compileStmt(CodeStream &codeStream, U32 ip);
+   U32 compileStmt(CodeStream& codeStream, U32 ip);
    DBG_STMT_TYPE(ReturnStmtNode);
 };
 
 struct IfStmtNode : StmtNode
 {
-   ExprNode *testExpr;
-   StmtNode *ifBlock, *elseBlock;
+   ExprNode* testExpr;
+   StmtNode* ifBlock, * elseBlock;
    U32 endifOffset;
    U32 elseOffset;
    bool integer;
    bool propagate;
 
-   static IfStmtNode *alloc(S32 lineNumber, ExprNode *testExpr, StmtNode *ifBlock, StmtNode *elseBlock, bool propagateThrough);
-   void propagateSwitchExpr(ExprNode *left, bool string);
-   ExprNode *getSwitchOR(ExprNode *left, ExprNode *list, bool string);
+   static IfStmtNode* alloc(S32 lineNumber, ExprNode* testExpr, StmtNode* ifBlock, StmtNode* elseBlock, bool propagateThrough);
+   void propagateSwitchExpr(ExprNode* left, bool string);
+   ExprNode* getSwitchOR(ExprNode* left, ExprNode* list, bool string);
 
-   U32 compileStmt(CodeStream &codeStream, U32 ip);
+   U32 compileStmt(CodeStream& codeStream, U32 ip);
    DBG_STMT_TYPE(IfStmtNode);
 };
 
 struct LoopStmtNode : StmtNode
 {
-   ExprNode *testExpr;
-   ExprNode *initExpr;
-   ExprNode *endLoopExpr;
-   StmtNode *loopBlock;
+   ExprNode* testExpr;
+   ExprNode* initExpr;
+   ExprNode* endLoopExpr;
+   StmtNode* loopBlock;
    bool isDoLoop;
    U32 breakOffset;
    U32 continueOffset;
    U32 loopBlockStartOffset;
    bool integer;
 
-   static LoopStmtNode *alloc(S32 lineNumber, ExprNode *testExpr, ExprNode *initExpr, ExprNode *endLoopExpr, StmtNode *loopBlock, bool isDoLoop);
+   static LoopStmtNode* alloc(S32 lineNumber, ExprNode* testExpr, ExprNode* initExpr, ExprNode* endLoopExpr, StmtNode* loopBlock, bool isDoLoop);
 
-   U32 compileStmt(CodeStream &codeStream, U32 ip);
+   U32 compileStmt(CodeStream& codeStream, U32 ip);
    DBG_STMT_TYPE(LoopStmtNode);
 };
 
@@ -189,35 +198,38 @@ struct IterStmtNode : StmtNode
 
    static IterStmtNode* alloc(S32 lineNumber, StringTableEntry varName, ExprNode* containerExpr, StmtNode* body, bool isStringIter);
 
-   U32 compileStmt(CodeStream &codeStream, U32 ip);
+   U32 compileStmt(CodeStream& codeStream, U32 ip);
 };
 
 /// A binary mathematical expression (ie, left op right).
 struct BinaryExprNode : ExprNode
 {
    S32 op;
-   ExprNode *left;
-   ExprNode *right;
+   ExprNode* left;
+   ExprNode* right;
 };
 
 struct FloatBinaryExprNode : BinaryExprNode
 {
-   static FloatBinaryExprNode *alloc(S32 lineNumber, S32 op, ExprNode *left, ExprNode *right);
+   static FloatBinaryExprNode* alloc(S32 lineNumber, S32 op, ExprNode* left, ExprNode* right);
+
+   U32 compile(CodeStream& codeStream, U32 ip, TypeReq type);
+
+   bool optimize();
 
-   U32 compile(CodeStream &codeStream, U32 ip, TypeReq type);
    TypeReq getPreferredType();
    DBG_STMT_TYPE(FloatBinaryExprNode);
 };
 
 struct ConditionalExprNode : ExprNode
 {
-   ExprNode *testExpr;
-   ExprNode *trueExpr;
-   ExprNode *falseExpr;
+   ExprNode* testExpr;
+   ExprNode* trueExpr;
+   ExprNode* falseExpr;
    bool integer;
-   static ConditionalExprNode *alloc(S32 lineNumber, ExprNode *testExpr, ExprNode *trueExpr, ExprNode *falseExpr);
+   static ConditionalExprNode* alloc(S32 lineNumber, ExprNode* testExpr, ExprNode* trueExpr, ExprNode* falseExpr);
 
-   virtual U32 compile(CodeStream &codeStream, U32 ip, TypeReq type);
+   virtual U32 compile(CodeStream& codeStream, U32 ip, TypeReq type);
    virtual TypeReq getPreferredType();
    DBG_STMT_TYPE(ConditionalExprNode);
 };
@@ -227,11 +239,13 @@ struct IntBinaryExprNode : BinaryExprNode
    TypeReq subType;
    U32 operand;
 
-   static IntBinaryExprNode *alloc(S32 lineNumber, S32 op, ExprNode *left, ExprNode *right);
+   static IntBinaryExprNode* alloc(S32 lineNumber, S32 op, ExprNode* left, ExprNode* right);
 
    void getSubTypeOperand();
 
-   U32 compile(CodeStream &codeStream, U32 ip, TypeReq type);
+   bool optimize();
+
+   U32 compile(CodeStream& codeStream, U32 ip, TypeReq type);
    TypeReq getPreferredType();
    DBG_STMT_TYPE(IntBinaryExprNode);
 };
@@ -239,9 +253,9 @@ struct IntBinaryExprNode : BinaryExprNode
 struct StreqExprNode : BinaryExprNode
 {
    bool eq;
-   static StreqExprNode *alloc(S32 lineNumber, ExprNode *left, ExprNode *right, bool eq);
+   static StreqExprNode* alloc(S32 lineNumber, ExprNode* left, ExprNode* right, bool eq);
 
-   U32 compile(CodeStream &codeStream, U32 ip, TypeReq type);
+   U32 compile(CodeStream& codeStream, U32 ip, TypeReq type);
    TypeReq getPreferredType();
    DBG_STMT_TYPE(StreqExprNode);
 };
@@ -249,19 +263,19 @@ struct StreqExprNode : BinaryExprNode
 struct StrcatExprNode : BinaryExprNode
 {
    S32 appendChar;
-   static StrcatExprNode *alloc(S32 lineNumber, ExprNode *left, ExprNode *right, S32 appendChar);
+   static StrcatExprNode* alloc(S32 lineNumber, ExprNode* left, ExprNode* right, S32 appendChar);
 
-   U32 compile(CodeStream &codeStream, U32 ip, TypeReq type);
+   U32 compile(CodeStream& codeStream, U32 ip, TypeReq type);
    TypeReq getPreferredType();
    DBG_STMT_TYPE(StrcatExprNode);
 };
 
 struct CommaCatExprNode : BinaryExprNode
 {
-   static CommaCatExprNode *alloc(S32 lineNumber, ExprNode *left, ExprNode *right);
+   static CommaCatExprNode* alloc(S32 lineNumber, ExprNode* left, ExprNode* right);
 
 
-   U32 compile(CodeStream &codeStream, U32 ip, TypeReq type);
+   U32 compile(CodeStream& codeStream, U32 ip, TypeReq type);
    TypeReq getPreferredType();
    DBG_STMT_TYPE(CommaCatExprNode);
 };
@@ -269,12 +283,12 @@ struct CommaCatExprNode : BinaryExprNode
 struct IntUnaryExprNode : ExprNode
 {
    S32 op;
-   ExprNode *expr;
+   ExprNode* expr;
    bool integer;
 
-   static IntUnaryExprNode *alloc(S32 lineNumber, S32 op, ExprNode *expr);
+   static IntUnaryExprNode* alloc(S32 lineNumber, S32 op, ExprNode* expr);
 
-   U32 compile(CodeStream &codeStream, U32 ip, TypeReq type);
+   U32 compile(CodeStream& codeStream, U32 ip, TypeReq type);
    TypeReq getPreferredType();
    DBG_STMT_TYPE(IntUnaryExprNode);
 };
@@ -282,11 +296,11 @@ struct IntUnaryExprNode : ExprNode
 struct FloatUnaryExprNode : ExprNode
 {
    S32 op;
-   ExprNode *expr;
+   ExprNode* expr;
 
-   static FloatUnaryExprNode *alloc(S32 lineNumber, S32 op, ExprNode *expr);
+   static FloatUnaryExprNode* alloc(S32 lineNumber, S32 op, ExprNode* expr);
 
-   U32 compile(CodeStream &codeStream, U32 ip, TypeReq type);
+   U32 compile(CodeStream& codeStream, U32 ip, TypeReq type);
    TypeReq getPreferredType();
    DBG_STMT_TYPE(FloatUnaryExprNode);
 };
@@ -294,12 +308,13 @@ struct FloatUnaryExprNode : ExprNode
 struct VarNode : ExprNode
 {
    StringTableEntry varName;
-   ExprNode *arrayIndex;
+   ExprNode* arrayIndex;
 
-   static VarNode *alloc(S32 lineNumber, StringTableEntry varName, ExprNode *arrayIndex);
+   static VarNode* alloc(S32 lineNumber, StringTableEntry varName, ExprNode* arrayIndex);
 
-   U32 compile(CodeStream &codeStream, U32 ip, TypeReq type);
+   U32 compile(CodeStream& codeStream, U32 ip, TypeReq type);
    TypeReq getPreferredType();
+   virtual ExprNodeName getExprNodeNameEnum() const { return NameVarNode; }
    DBG_STMT_TYPE(VarNode);
 };
 
@@ -308,10 +323,11 @@ struct IntNode : ExprNode
    S32 value;
    U32 index; // if it's converted to float/string
 
-   static IntNode *alloc(S32 lineNumber, S32 value);
+   static IntNode* alloc(S32 lineNumber, S32 value);
 
-   U32 compile(CodeStream &codeStream, U32 ip, TypeReq type);
+   U32 compile(CodeStream& codeStream, U32 ip, TypeReq type);
    TypeReq getPreferredType();
+   virtual ExprNodeName getExprNodeNameEnum() const { return NameIntNode; }
    DBG_STMT_TYPE(IntNode);
 };
 
@@ -320,24 +336,25 @@ struct FloatNode : ExprNode
    F64 value;
    U32 index;
 
-   static FloatNode *alloc(S32 lineNumber, F64 value);
+   static FloatNode* alloc(S32 lineNumber, F64 value);
 
-   U32 compile(CodeStream &codeStream, U32 ip, TypeReq type);
+   U32 compile(CodeStream& codeStream, U32 ip, TypeReq type);
    TypeReq getPreferredType();
+   virtual ExprNodeName getExprNodeNameEnum() const { return NameFloatNode; }
    DBG_STMT_TYPE(FloatNode);
 };
 
 struct StrConstNode : ExprNode
 {
-   char *str;
+   char* str;
    F64 fVal;
    U32 index;
    bool tag;
    bool doc; // Specifies that this string is a documentation block.
 
-   static StrConstNode *alloc(S32 lineNumber, char *str, bool tag, bool doc = false);
+   static StrConstNode* alloc(S32 lineNumber, char* str, bool tag, bool doc = false);
 
-   U32 compile(CodeStream &codeStream, U32 ip, TypeReq type);
+   U32 compile(CodeStream& codeStream, U32 ip, TypeReq type);
    TypeReq getPreferredType();
    DBG_STMT_TYPE(StrConstNode);
 };
@@ -348,9 +365,9 @@ struct ConstantNode : ExprNode
    F64 fVal;
    U32 index;
 
-   static ConstantNode *alloc(S32 lineNumber, StringTableEntry value);
+   static ConstantNode* alloc(S32 lineNumber, StringTableEntry value);
 
-   U32 compile(CodeStream &codeStream, U32 ip, TypeReq type);
+   U32 compile(CodeStream& codeStream, U32 ip, TypeReq type);
    TypeReq getPreferredType();
    DBG_STMT_TYPE(ConstantNode);
 };
@@ -358,13 +375,13 @@ struct ConstantNode : ExprNode
 struct AssignExprNode : ExprNode
 {
    StringTableEntry varName;
-   ExprNode *expr;
-   ExprNode *arrayIndex;
+   ExprNode* expr;
+   ExprNode* arrayIndex;
    TypeReq subType;
 
-   static AssignExprNode *alloc(S32 lineNumber, StringTableEntry varName, ExprNode *arrayIndex, ExprNode *expr);
+   static AssignExprNode* alloc(S32 lineNumber, StringTableEntry varName, ExprNode* arrayIndex, ExprNode* expr);
 
-   U32 compile(CodeStream &codeStream, U32 ip, TypeReq type);
+   U32 compile(CodeStream& codeStream, U32 ip, TypeReq type);
    TypeReq getPreferredType();
    DBG_STMT_TYPE(AssignExprNode);
 };
@@ -373,22 +390,22 @@ struct AssignDecl
 {
    S32 lineNumber;
    S32 token;
-   ExprNode *expr;
+   ExprNode* expr;
    bool integer;
 };
 
 struct AssignOpExprNode : ExprNode
 {
    StringTableEntry varName;
-   ExprNode *expr;
-   ExprNode *arrayIndex;
+   ExprNode* expr;
+   ExprNode* arrayIndex;
    S32 op;
    U32 operand;
    TypeReq subType;
 
-   static AssignOpExprNode *alloc(S32 lineNumber, StringTableEntry varName, ExprNode *arrayIndex, ExprNode *expr, S32 op);
+   static AssignOpExprNode* alloc(S32 lineNumber, StringTableEntry varName, ExprNode* arrayIndex, ExprNode* expr, S32 op);
 
-   U32 compile(CodeStream &codeStream, U32 ip, TypeReq type);
+   U32 compile(CodeStream& codeStream, U32 ip, TypeReq type);
    TypeReq getPreferredType();
    DBG_STMT_TYPE(AssignOpExprNode);
 };
@@ -396,22 +413,22 @@ struct AssignOpExprNode : ExprNode
 struct TTagSetStmtNode : StmtNode
 {
    StringTableEntry tag;
-   ExprNode *valueExpr;
-   ExprNode *stringExpr;
+   ExprNode* valueExpr;
+   ExprNode* stringExpr;
 
-   static TTagSetStmtNode *alloc(S32 lineNumber, StringTableEntry tag, ExprNode *valueExpr, ExprNode *stringExpr);
+   static TTagSetStmtNode* alloc(S32 lineNumber, StringTableEntry tag, ExprNode* valueExpr, ExprNode* stringExpr);
 
-   U32 compileStmt(CodeStream &codeStream, U32 ip);
+   U32 compileStmt(CodeStream& codeStream, U32 ip);
    DBG_STMT_TYPE(TTagSetStmtNode);
 };
 
 struct TTagDerefNode : ExprNode
 {
-   ExprNode *expr;
+   ExprNode* expr;
 
-   static TTagDerefNode *alloc(S32 lineNumber, ExprNode *expr);
+   static TTagDerefNode* alloc(S32 lineNumber, ExprNode* expr);
 
-   U32 compile(CodeStream &codeStream, U32 ip, TypeReq type);
+   U32 compile(CodeStream& codeStream, U32 ip, TypeReq type);
    TypeReq getPreferredType();
    DBG_STMT_TYPE(TTagDerefNode);
 };
@@ -420,9 +437,9 @@ struct TTagExprNode : ExprNode
 {
    StringTableEntry tag;
 
-   static TTagExprNode *alloc(S32 lineNumber, StringTableEntry tag);
+   static TTagExprNode* alloc(S32 lineNumber, StringTableEntry tag);
 
-   U32 compile(CodeStream &codeStream, U32 ip, TypeReq type);
+   U32 compile(CodeStream& codeStream, U32 ip, TypeReq type);
    TypeReq getPreferredType();
    DBG_STMT_TYPE(TTagExprNode);
 };
@@ -431,42 +448,31 @@ struct FuncCallExprNode : ExprNode
 {
    StringTableEntry funcName;
    StringTableEntry nameSpace;
-   ExprNode *args;
+   ExprNode* args;
    U32 callType;
    enum {
       FunctionCall,
+      StaticCall,
       MethodCall,
       ParentCall
    };
 
-   static FuncCallExprNode *alloc(S32 lineNumber, StringTableEntry funcName, StringTableEntry nameSpace, ExprNode *args, bool dot);
+   static FuncCallExprNode* alloc(S32 lineNumber, StringTableEntry funcName, StringTableEntry nameSpace, ExprNode* args, bool dot);
 
-   U32 compile(CodeStream &codeStream, U32 ip, TypeReq type);
+   U32 compile(CodeStream& codeStream, U32 ip, TypeReq type);
    TypeReq getPreferredType();
    DBG_STMT_TYPE(FuncCallExprNode);
 };
 
-struct FuncPointerCallExprNode : ExprNode
-{
-   ExprNode *funcPointer;
-   ExprNode *args;
-
-   static FuncPointerCallExprNode *alloc(S32 lineNumber, ExprNode *stmt, ExprNode *args);
-
-   U32 compile(CodeStream &codeStream, U32 ip, TypeReq type);
-   TypeReq getPreferredType();
-   DBG_STMT_TYPE(FuncPointerCallExprNode);
-};
-
 struct AssertCallExprNode : ExprNode
 {
-   ExprNode *testExpr;
-   const char *message;
+   ExprNode* testExpr;
+   const char* message;
    U32 messageIndex;
 
-   static AssertCallExprNode *alloc(S32 lineNumber, ExprNode *testExpr, const char *message);
+   static AssertCallExprNode* alloc(S32 lineNumber, ExprNode* testExpr, const char* message);
 
-   U32 compile(CodeStream &codeStream, U32 ip, TypeReq type);
+   U32 compile(CodeStream& codeStream, U32 ip, TypeReq type);
    TypeReq getPreferredType();
    DBG_STMT_TYPE(AssertCallExprNode);
 };
@@ -474,19 +480,19 @@ struct AssertCallExprNode : ExprNode
 struct SlotDecl
 {
    S32              lineNumber;
-   ExprNode         *object;
+   ExprNode* object;
    StringTableEntry slotName;
-   ExprNode         *array;
+   ExprNode* array;
 };
 
 struct SlotAccessNode : ExprNode
 {
-   ExprNode *objectExpr, *arrayExpr;
+   ExprNode* objectExpr, * arrayExpr;
    StringTableEntry slotName;
 
-   static SlotAccessNode *alloc(S32 lineNumber, ExprNode *objectExpr, ExprNode *arrayExpr, StringTableEntry slotName);
+   static SlotAccessNode* alloc(S32 lineNumber, ExprNode* objectExpr, ExprNode* arrayExpr, StringTableEntry slotName);
 
-   U32 compile(CodeStream &codeStream, U32 ip, TypeReq type);
+   U32 compile(CodeStream& codeStream, U32 ip, TypeReq type);
    TypeReq getPreferredType();
    DBG_STMT_TYPE(SlotAccessNode);
 };
@@ -494,101 +500,99 @@ struct SlotAccessNode : ExprNode
 struct InternalSlotDecl
 {
    S32              lineNumber;
-   ExprNode         *object;
-   ExprNode         *slotExpr;
+   ExprNode* object;
+   ExprNode* slotExpr;
    bool             recurse;
 };
 
 struct InternalSlotAccessNode : ExprNode
 {
-   ExprNode *objectExpr, *slotExpr;
+   ExprNode* objectExpr, * slotExpr;
    bool recurse;
 
-   static InternalSlotAccessNode *alloc(S32 lineNumber, ExprNode *objectExpr, ExprNode *slotExpr, bool recurse);
+   static InternalSlotAccessNode* alloc(S32 lineNumber, ExprNode* objectExpr, ExprNode* slotExpr, bool recurse);
 
-   U32 compile(CodeStream &codeStream, U32 ip, TypeReq type);
+   U32 compile(CodeStream& codeStream, U32 ip, TypeReq type);
    TypeReq getPreferredType();
    DBG_STMT_TYPE(InternalSlotAccessNode);
 };
 
 struct SlotAssignNode : ExprNode
 {
-   ExprNode *objectExpr, *arrayExpr;
+   ExprNode* objectExpr, * arrayExpr;
    StringTableEntry slotName;
-   ExprNode *valueExpr;
+   ExprNode* valueExpr;
    U32 typeID;
 
-   static SlotAssignNode *alloc(S32 lineNumber, ExprNode *objectExpr, ExprNode *arrayExpr, StringTableEntry slotName, ExprNode *valueExpr, U32 typeID = -1);
+   static SlotAssignNode* alloc(S32 lineNumber, ExprNode* objectExpr, ExprNode* arrayExpr, StringTableEntry slotName, ExprNode* valueExpr, U32 typeID = -1);
 
-   U32 compile(CodeStream &codeStream, U32 ip, TypeReq type);
+   U32 compile(CodeStream& codeStream, U32 ip, TypeReq type);
    TypeReq getPreferredType();
    DBG_STMT_TYPE(SlotAssignNode);
 };
 
 struct SlotAssignOpNode : ExprNode
 {
-   ExprNode *objectExpr, *arrayExpr;
+   ExprNode* objectExpr, * arrayExpr;
    StringTableEntry slotName;
    S32 op;
-   ExprNode *valueExpr;
+   ExprNode* valueExpr;
    U32 operand;
    TypeReq subType;
 
-   static SlotAssignOpNode *alloc(S32 lineNumber, ExprNode *objectExpr, StringTableEntry slotName, ExprNode *arrayExpr, S32 op, ExprNode *valueExpr);
+   static SlotAssignOpNode* alloc(S32 lineNumber, ExprNode* objectExpr, StringTableEntry slotName, ExprNode* arrayExpr, S32 op, ExprNode* valueExpr);
 
-   U32 compile(CodeStream &codeStream, U32 ip, TypeReq type);
+   U32 compile(CodeStream& codeStream, U32 ip, TypeReq type);
    TypeReq getPreferredType();
    DBG_STMT_TYPE(SlotAssignOpNode);
 };
 
 struct ObjectDeclNode : ExprNode
 {
-   ExprNode *classNameExpr;
+   ExprNode* classNameExpr;
    StringTableEntry parentObject;
-   ExprNode *objectNameExpr;
-   ExprNode *argList;
-   SlotAssignNode *slotDecls;
-   ObjectDeclNode *subObjects;
+   ExprNode* objectNameExpr;
+   ExprNode* argList;
+   SlotAssignNode* slotDecls;
+   ObjectDeclNode* subObjects;
    bool isDatablock;
    U32 failOffset;
    bool isClassNameInternal;
    bool isSingleton;
 
-   static ObjectDeclNode *alloc(S32 lineNumber, ExprNode *classNameExpr, ExprNode *objectNameExpr, ExprNode *argList, StringTableEntry parentObject, SlotAssignNode *slotDecls, ObjectDeclNode *subObjects, bool isDatablock, bool classNameInternal, bool isSingleton);
+   static ObjectDeclNode* alloc(S32 lineNumber, ExprNode* classNameExpr, ExprNode* objectNameExpr, ExprNode* argList, StringTableEntry parentObject, SlotAssignNode* slotDecls, ObjectDeclNode* subObjects, bool isDatablock, bool classNameInternal, bool isSingleton);
 
    U32 precompileSubObject(bool);
-   U32 compile(CodeStream &codeStream, U32 ip, TypeReq type);
-   U32 compileSubObject(CodeStream &codeStream, U32 ip, bool);
+   U32 compile(CodeStream& codeStream, U32 ip, TypeReq type);
+   U32 compileSubObject(CodeStream& codeStream, U32 ip, bool);
    TypeReq getPreferredType();
    DBG_STMT_TYPE(ObjectDeclNode);
 };
 
 struct ObjectBlockDecl
 {
-   SlotAssignNode *slots;
-   ObjectDeclNode *decls;
+   SlotAssignNode* slots;
+   ObjectDeclNode* decls;
 };
 
 struct FunctionDeclStmtNode : StmtNode
 {
    StringTableEntry fnName;
-   VarNode *args;
-   StmtNode *stmts;
+   VarNode* args;
+   StmtNode* stmts;
    StringTableEntry nameSpace;
    StringTableEntry package;
    U32 endOffset;
    U32 argc;
 
-   static FunctionDeclStmtNode *alloc(S32 lineNumber, StringTableEntry fnName, StringTableEntry nameSpace, VarNode *args, StmtNode *stmts);
+   static FunctionDeclStmtNode* alloc(S32 lineNumber, StringTableEntry fnName, StringTableEntry nameSpace, VarNode* args, StmtNode* stmts);
 
-   U32 compileStmt(CodeStream &codeStream, U32 ip);
+   U32 compileStmt(CodeStream& codeStream, U32 ip);
    void setPackage(StringTableEntry packageName);
    DBG_STMT_TYPE(FunctionDeclStmtNode);
 };
 
-extern StmtNode *gStatementList;
-extern StmtNode *gAnonFunctionList;
-extern U32 gAnonFunctionID;
+extern StmtNode* gStatementList;
 extern ExprEvalState gEvalState;
 
 #endif
diff --git a/Engine/source/console/astAlloc.cpp b/Engine/source/console/astAlloc.cpp
index 521b6dbcc..58d5a0d7f 100644
--- a/Engine/source/console/astAlloc.cpp
+++ b/Engine/source/console/astAlloc.cpp
@@ -1,5 +1,5 @@
 //-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
+// Copyright (c) 2013 GarageGames, LLC
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to
@@ -20,7 +20,6 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "platform/platform.h"
 #include "console/console.h"
 #include "console/compiler.h"
 #include "console/consoleInternal.h"
@@ -38,25 +37,25 @@ using namespace Compiler;
 
 //------------------------------------------------------------
 
-BreakStmtNode *BreakStmtNode::alloc(S32 lineNumber)
+BreakStmtNode* BreakStmtNode::alloc(S32 lineNumber)
 {
-   BreakStmtNode *ret = (BreakStmtNode *)consoleAlloc(sizeof(BreakStmtNode));
+   BreakStmtNode* ret = (BreakStmtNode*)consoleAlloc(sizeof(BreakStmtNode));
    constructInPlace(ret);
    ret->dbgLineNumber = lineNumber;
    return ret;
 }
 
-ContinueStmtNode *ContinueStmtNode::alloc(S32 lineNumber)
+ContinueStmtNode* ContinueStmtNode::alloc(S32 lineNumber)
 {
-   ContinueStmtNode *ret = (ContinueStmtNode *)consoleAlloc(sizeof(ContinueStmtNode));
+   ContinueStmtNode* ret = (ContinueStmtNode*)consoleAlloc(sizeof(ContinueStmtNode));
    constructInPlace(ret);
    ret->dbgLineNumber = lineNumber;
    return ret;
 }
 
-ReturnStmtNode *ReturnStmtNode::alloc(S32 lineNumber, ExprNode *expr)
+ReturnStmtNode* ReturnStmtNode::alloc(S32 lineNumber, ExprNode* expr)
 {
-   ReturnStmtNode *ret = (ReturnStmtNode *)consoleAlloc(sizeof(ReturnStmtNode));
+   ReturnStmtNode* ret = (ReturnStmtNode*)consoleAlloc(sizeof(ReturnStmtNode));
    constructInPlace(ret);
    ret->expr = expr;
    ret->dbgLineNumber = lineNumber;
@@ -64,9 +63,9 @@ ReturnStmtNode *ReturnStmtNode::alloc(S32 lineNumber, ExprNode *expr)
    return ret;
 }
 
-IfStmtNode *IfStmtNode::alloc(S32 lineNumber, ExprNode *testExpr, StmtNode *ifBlock, StmtNode *elseBlock, bool propagate)
+IfStmtNode* IfStmtNode::alloc(S32 lineNumber, ExprNode* testExpr, StmtNode* ifBlock, StmtNode* elseBlock, bool propagate)
 {
-   IfStmtNode *ret = (IfStmtNode *)consoleAlloc(sizeof(IfStmtNode));
+   IfStmtNode* ret = (IfStmtNode*)consoleAlloc(sizeof(IfStmtNode));
    constructInPlace(ret);
    ret->dbgLineNumber = lineNumber;
 
@@ -78,9 +77,9 @@ IfStmtNode *IfStmtNode::alloc(S32 lineNumber, ExprNode *testExpr, StmtNode *ifBl
    return ret;
 }
 
-LoopStmtNode *LoopStmtNode::alloc(S32 lineNumber, ExprNode *initExpr, ExprNode *testExpr, ExprNode *endLoopExpr, StmtNode *loopBlock, bool isDoLoop)
+LoopStmtNode* LoopStmtNode::alloc(S32 lineNumber, ExprNode* initExpr, ExprNode* testExpr, ExprNode* endLoopExpr, StmtNode* loopBlock, bool isDoLoop)
 {
-   LoopStmtNode *ret = (LoopStmtNode *)consoleAlloc(sizeof(LoopStmtNode));
+   LoopStmtNode* ret = (LoopStmtNode*)consoleAlloc(sizeof(LoopStmtNode));
    constructInPlace(ret);
    ret->dbgLineNumber = lineNumber;
    ret->testExpr = testExpr;
@@ -111,11 +110,12 @@ IterStmtNode* IterStmtNode::alloc(S32 lineNumber, StringTableEntry varName, Expr
    return ret;
 }
 
-FloatBinaryExprNode *FloatBinaryExprNode::alloc(S32 lineNumber, S32 op, ExprNode *left, ExprNode *right)
+FloatBinaryExprNode* FloatBinaryExprNode::alloc(S32 lineNumber, S32 op, ExprNode* left, ExprNode* right)
 {
-   FloatBinaryExprNode *ret = (FloatBinaryExprNode *)consoleAlloc(sizeof(FloatBinaryExprNode));
+   FloatBinaryExprNode* ret = (FloatBinaryExprNode*)consoleAlloc(sizeof(FloatBinaryExprNode));
    constructInPlace(ret);
    ret->dbgLineNumber = lineNumber;
+   ret->optimizedNode = NULL;
 
    ret->op = op;
    ret->left = left;
@@ -124,11 +124,12 @@ FloatBinaryExprNode *FloatBinaryExprNode::alloc(S32 lineNumber, S32 op, ExprNode
    return ret;
 }
 
-IntBinaryExprNode *IntBinaryExprNode::alloc(S32 lineNumber, S32 op, ExprNode *left, ExprNode *right)
+IntBinaryExprNode* IntBinaryExprNode::alloc(S32 lineNumber, S32 op, ExprNode* left, ExprNode* right)
 {
-   IntBinaryExprNode *ret = (IntBinaryExprNode *)consoleAlloc(sizeof(IntBinaryExprNode));
+   IntBinaryExprNode* ret = (IntBinaryExprNode*)consoleAlloc(sizeof(IntBinaryExprNode));
    constructInPlace(ret);
    ret->dbgLineNumber = lineNumber;
+   ret->optimizedNode = NULL;
 
    ret->op = op;
    ret->left = left;
@@ -137,11 +138,12 @@ IntBinaryExprNode *IntBinaryExprNode::alloc(S32 lineNumber, S32 op, ExprNode *le
    return ret;
 }
 
-StreqExprNode *StreqExprNode::alloc(S32 lineNumber, ExprNode *left, ExprNode *right, bool eq)
+StreqExprNode* StreqExprNode::alloc(S32 lineNumber, ExprNode* left, ExprNode* right, bool eq)
 {
-   StreqExprNode *ret = (StreqExprNode *)consoleAlloc(sizeof(StreqExprNode));
+   StreqExprNode* ret = (StreqExprNode*)consoleAlloc(sizeof(StreqExprNode));
    constructInPlace(ret);
    ret->dbgLineNumber = lineNumber;
+   ret->optimizedNode = NULL;
    ret->left = left;
    ret->right = right;
    ret->eq = eq;
@@ -149,11 +151,12 @@ StreqExprNode *StreqExprNode::alloc(S32 lineNumber, ExprNode *left, ExprNode *ri
    return ret;
 }
 
-StrcatExprNode *StrcatExprNode::alloc(S32 lineNumber, ExprNode *left, ExprNode *right, S32 appendChar)
+StrcatExprNode* StrcatExprNode::alloc(S32 lineNumber, ExprNode* left, ExprNode* right, int appendChar)
 {
-   StrcatExprNode *ret = (StrcatExprNode *)consoleAlloc(sizeof(StrcatExprNode));
+   StrcatExprNode* ret = (StrcatExprNode*)consoleAlloc(sizeof(StrcatExprNode));
    constructInPlace(ret);
    ret->dbgLineNumber = lineNumber;
+   ret->optimizedNode = NULL;
    ret->left = left;
    ret->right = right;
    ret->appendChar = appendChar;
@@ -161,61 +164,67 @@ StrcatExprNode *StrcatExprNode::alloc(S32 lineNumber, ExprNode *left, ExprNode *
    return ret;
 }
 
-CommaCatExprNode *CommaCatExprNode::alloc(S32 lineNumber, ExprNode *left, ExprNode *right)
+CommaCatExprNode* CommaCatExprNode::alloc(S32 lineNumber, ExprNode* left, ExprNode* right)
 {
-   CommaCatExprNode *ret = (CommaCatExprNode *)consoleAlloc(sizeof(CommaCatExprNode));
+   CommaCatExprNode* ret = (CommaCatExprNode*)consoleAlloc(sizeof(CommaCatExprNode));
    constructInPlace(ret);
    ret->dbgLineNumber = lineNumber;
+   ret->optimizedNode = NULL;
    ret->left = left;
    ret->right = right;
 
    return ret;
 }
 
-IntUnaryExprNode *IntUnaryExprNode::alloc(S32 lineNumber, S32 op, ExprNode *expr)
+IntUnaryExprNode* IntUnaryExprNode::alloc(S32 lineNumber, S32 op, ExprNode* expr)
 {
-   IntUnaryExprNode *ret = (IntUnaryExprNode *)consoleAlloc(sizeof(IntUnaryExprNode));
+   IntUnaryExprNode* ret = (IntUnaryExprNode*)consoleAlloc(sizeof(IntUnaryExprNode));
    constructInPlace(ret);
    ret->dbgLineNumber = lineNumber;
+   ret->optimizedNode = NULL;
    ret->op = op;
    ret->expr = expr;
    return ret;
 }
 
-FloatUnaryExprNode *FloatUnaryExprNode::alloc(S32 lineNumber, S32 op, ExprNode *expr)
+FloatUnaryExprNode* FloatUnaryExprNode::alloc(S32 lineNumber, S32 op, ExprNode* expr)
 {
-   FloatUnaryExprNode *ret = (FloatUnaryExprNode *)consoleAlloc(sizeof(FloatUnaryExprNode));
+   FloatUnaryExprNode* ret = (FloatUnaryExprNode*)consoleAlloc(sizeof(FloatUnaryExprNode));
    constructInPlace(ret);
    ret->dbgLineNumber = lineNumber;
+   ret->optimizedNode = NULL;
    ret->op = op;
    ret->expr = expr;
    return ret;
 }
 
-VarNode *VarNode::alloc(S32 lineNumber, StringTableEntry varName, ExprNode *arrayIndex)
+VarNode* VarNode::alloc(S32 lineNumber, StringTableEntry varName, ExprNode* arrayIndex)
 {
-   VarNode *ret = (VarNode *)consoleAlloc(sizeof(VarNode));
+   VarNode* ret = (VarNode*)consoleAlloc(sizeof(VarNode));
    constructInPlace(ret);
    ret->dbgLineNumber = lineNumber;
+   ret->optimizedNode = NULL;
    ret->varName = varName;
    ret->arrayIndex = arrayIndex;
    return ret;
 }
 
-IntNode *IntNode::alloc(S32 lineNumber, S32 value)
+IntNode* IntNode::alloc(S32 lineNumber, S32 value)
 {
-   IntNode *ret = (IntNode *)consoleAlloc(sizeof(IntNode));
+   IntNode* ret = (IntNode*)consoleAlloc(sizeof(IntNode));
    constructInPlace(ret);
    ret->dbgLineNumber = lineNumber;
+   ret->optimizedNode = NULL;
    ret->value = value;
    return ret;
 }
 
-ConditionalExprNode *ConditionalExprNode::alloc(S32 lineNumber, ExprNode *testExpr, ExprNode *trueExpr, ExprNode *falseExpr)
+ConditionalExprNode* ConditionalExprNode::alloc(S32 lineNumber, ExprNode* testExpr, ExprNode* trueExpr, ExprNode* falseExpr)
 {
-   ConditionalExprNode *ret = (ConditionalExprNode *)consoleAlloc(sizeof(ConditionalExprNode));
+   ConditionalExprNode* ret = (ConditionalExprNode*)consoleAlloc(sizeof(ConditionalExprNode));
    constructInPlace(ret);
    ret->dbgLineNumber = lineNumber;
+   ret->optimizedNode = NULL;
    ret->testExpr = testExpr;
    ret->trueExpr = trueExpr;
    ret->falseExpr = falseExpr;
@@ -223,44 +232,50 @@ ConditionalExprNode *ConditionalExprNode::alloc(S32 lineNumber, ExprNode *testEx
    return ret;
 }
 
-FloatNode *FloatNode::alloc(S32 lineNumber, F64 value)
+FloatNode* FloatNode::alloc(S32 lineNumber, F64 value)
 {
-   FloatNode *ret = (FloatNode *)consoleAlloc(sizeof(FloatNode));
+   FloatNode* ret = (FloatNode*)consoleAlloc(sizeof(FloatNode));
    constructInPlace(ret);
 
    ret->dbgLineNumber = lineNumber;
+   ret->optimizedNode = NULL;
    ret->value = value;
    return ret;
 }
 
-StrConstNode *StrConstNode::alloc(S32 lineNumber, char *str, bool tag, bool doc)
+StrConstNode* StrConstNode::alloc(S32 lineNumber, char* str, bool tag, bool doc)
 {
-   StrConstNode *ret = (StrConstNode *)consoleAlloc(sizeof(StrConstNode));
+   StrConstNode* ret = (StrConstNode*)consoleAlloc(sizeof(StrConstNode));
    constructInPlace(ret);
+   S32 len = dStrlen(str);
+
    ret->dbgLineNumber = lineNumber;
-   dsize_t retStrLen = dStrlen(str) + 1;
-   ret->str = (char *)consoleAlloc(retStrLen);
+   ret->optimizedNode = NULL;
+   ret->str = (char*)consoleAlloc(len + 1);
    ret->tag = tag;
    ret->doc = doc;
-   dStrcpy(ret->str, str, retStrLen);
+   dStrcpy(ret->str, str, len);
+   ret->str[len] = '\0';
 
    return ret;
 }
 
-ConstantNode *ConstantNode::alloc(S32 lineNumber, StringTableEntry value)
+ConstantNode* ConstantNode::alloc(S32 lineNumber, StringTableEntry value)
 {
-   ConstantNode *ret = (ConstantNode *)consoleAlloc(sizeof(ConstantNode));
+   ConstantNode* ret = (ConstantNode*)consoleAlloc(sizeof(ConstantNode));
    constructInPlace(ret);
    ret->dbgLineNumber = lineNumber;
+   ret->optimizedNode = NULL;
    ret->value = value;
    return ret;
 }
 
-AssignExprNode *AssignExprNode::alloc(S32 lineNumber, StringTableEntry varName, ExprNode *arrayIndex, ExprNode *expr)
+AssignExprNode* AssignExprNode::alloc(S32 lineNumber, StringTableEntry varName, ExprNode* arrayIndex, ExprNode* expr)
 {
-   AssignExprNode *ret = (AssignExprNode *)consoleAlloc(sizeof(AssignExprNode));
+   AssignExprNode* ret = (AssignExprNode*)consoleAlloc(sizeof(AssignExprNode));
    constructInPlace(ret);
    ret->dbgLineNumber = lineNumber;
+   ret->optimizedNode = NULL;
    ret->varName = varName;
    ret->expr = expr;
    ret->arrayIndex = arrayIndex;
@@ -268,11 +283,12 @@ AssignExprNode *AssignExprNode::alloc(S32 lineNumber, StringTableEntry varName,
    return ret;
 }
 
-AssignOpExprNode *AssignOpExprNode::alloc(S32 lineNumber, StringTableEntry varName, ExprNode *arrayIndex, ExprNode *expr, S32 op)
+AssignOpExprNode* AssignOpExprNode::alloc(S32 lineNumber, StringTableEntry varName, ExprNode* arrayIndex, ExprNode* expr, S32 op)
 {
-   AssignOpExprNode *ret = (AssignOpExprNode *)consoleAlloc(sizeof(AssignOpExprNode));
+   AssignOpExprNode* ret = (AssignOpExprNode*)consoleAlloc(sizeof(AssignOpExprNode));
    constructInPlace(ret);
    ret->dbgLineNumber = lineNumber;
+   ret->optimizedNode = NULL;
    ret->varName = varName;
    ret->expr = expr;
    ret->arrayIndex = arrayIndex;
@@ -280,9 +296,9 @@ AssignOpExprNode *AssignOpExprNode::alloc(S32 lineNumber, StringTableEntry varNa
    return ret;
 }
 
-TTagSetStmtNode *TTagSetStmtNode::alloc(S32 lineNumber, StringTableEntry tag, ExprNode *valueExpr, ExprNode *stringExpr)
+TTagSetStmtNode* TTagSetStmtNode::alloc(S32 lineNumber, StringTableEntry tag, ExprNode* valueExpr, ExprNode* stringExpr)
 {
-   TTagSetStmtNode *ret = (TTagSetStmtNode *)consoleAlloc(sizeof(TTagSetStmtNode));
+   TTagSetStmtNode* ret = (TTagSetStmtNode*)consoleAlloc(sizeof(TTagSetStmtNode));
    constructInPlace(ret);
    ret->dbgLineNumber = lineNumber;
    ret->tag = tag;
@@ -291,59 +307,54 @@ TTagSetStmtNode *TTagSetStmtNode::alloc(S32 lineNumber, StringTableEntry tag, Ex
    return ret;
 }
 
-TTagDerefNode *TTagDerefNode::alloc(S32 lineNumber, ExprNode *expr)
+TTagDerefNode* TTagDerefNode::alloc(S32 lineNumber, ExprNode* expr)
 {
-   TTagDerefNode *ret = (TTagDerefNode *)consoleAlloc(sizeof(TTagDerefNode));
+   TTagDerefNode* ret = (TTagDerefNode*)consoleAlloc(sizeof(TTagDerefNode));
    constructInPlace(ret);
    ret->dbgLineNumber = lineNumber;
+   ret->optimizedNode = NULL;
    ret->expr = expr;
    return ret;
 }
 
-TTagExprNode *TTagExprNode::alloc(S32 lineNumber, StringTableEntry tag)
+TTagExprNode* TTagExprNode::alloc(S32 lineNumber, StringTableEntry tag)
 {
-   TTagExprNode *ret = (TTagExprNode *)consoleAlloc(sizeof(TTagExprNode));
+   TTagExprNode* ret = (TTagExprNode*)consoleAlloc(sizeof(TTagExprNode));
    constructInPlace(ret);
    ret->dbgLineNumber = lineNumber;
+   ret->optimizedNode = NULL;
    ret->tag = tag;
    return ret;
 }
 
-FuncCallExprNode *FuncCallExprNode::alloc(S32 lineNumber, StringTableEntry funcName, StringTableEntry nameSpace, ExprNode *args, bool dot)
+FuncCallExprNode* FuncCallExprNode::alloc(S32 lineNumber, StringTableEntry funcName, StringTableEntry nameSpace, ExprNode* args, bool dot)
 {
-   FuncCallExprNode *ret = (FuncCallExprNode *)consoleAlloc(sizeof(FuncCallExprNode));
+   FuncCallExprNode* ret = (FuncCallExprNode*)consoleAlloc(sizeof(FuncCallExprNode));
    constructInPlace(ret);
    ret->dbgLineNumber = lineNumber;
+   ret->optimizedNode = NULL;
    ret->funcName = funcName;
    ret->nameSpace = nameSpace;
    ret->args = args;
    if (dot)
       ret->callType = MethodCall;
-   else
+   else if (nameSpace != NULL)
    {
-      if (nameSpace && !dStricmp(nameSpace, "Parent"))
+      if (dStricmp(nameSpace, "Parent") == 0)
          ret->callType = ParentCall;
       else
-         ret->callType = FunctionCall;
+         ret->callType = StaticCall;
    }
+   else
+      ret->callType = FunctionCall;
    return ret;
 }
 
-FuncPointerCallExprNode *FuncPointerCallExprNode::alloc(S32 lineNumber, ExprNode *funcPointer, ExprNode *args)
+AssertCallExprNode* AssertCallExprNode::alloc(S32 lineNumber, ExprNode* testExpr, const char* message)
 {
-   FuncPointerCallExprNode *ret = (FuncPointerCallExprNode *)consoleAlloc(sizeof(FuncPointerCallExprNode));
-   constructInPlace(ret);
-   ret->dbgLineNumber = lineNumber;
-   ret->funcPointer = funcPointer;
-   ret->args = args;
-   return ret;
-}
+#ifdef TORQUE_ENABLE_SCRIPTASSERTS
 
-AssertCallExprNode *AssertCallExprNode::alloc(S32 lineNumber, ExprNode *testExpr, const char *message)
-{
-#ifdef TORQUE_ENABLE_SCRIPTASSERTS      
-
-   AssertCallExprNode *ret = (AssertCallExprNode *)consoleAlloc(sizeof(FuncCallExprNode));
+   AssertCallExprNode* ret = (AssertCallExprNode*)consoleAlloc(sizeof(FuncCallExprNode));
    constructInPlace(ret);
    ret->dbgLineNumber = lineNumber;
    ret->testExpr = testExpr;
@@ -357,10 +368,11 @@ AssertCallExprNode *AssertCallExprNode::alloc(S32 lineNumber, ExprNode *testExpr
 #endif
 }
 
-SlotAccessNode *SlotAccessNode::alloc(S32 lineNumber, ExprNode *objectExpr, ExprNode *arrayExpr, StringTableEntry slotName)
+SlotAccessNode* SlotAccessNode::alloc(S32 lineNumber, ExprNode* objectExpr, ExprNode* arrayExpr, StringTableEntry slotName)
 {
-   SlotAccessNode *ret = (SlotAccessNode *)consoleAlloc(sizeof(SlotAccessNode));
+   SlotAccessNode* ret = (SlotAccessNode*)consoleAlloc(sizeof(SlotAccessNode));
    constructInPlace(ret);
+   ret->optimizedNode = NULL;
    ret->dbgLineNumber = lineNumber;
    ret->objectExpr = objectExpr;
    ret->arrayExpr = arrayExpr;
@@ -368,22 +380,24 @@ SlotAccessNode *SlotAccessNode::alloc(S32 lineNumber, ExprNode *objectExpr, Expr
    return ret;
 }
 
-InternalSlotAccessNode *InternalSlotAccessNode::alloc(S32 lineNumber, ExprNode *objectExpr, ExprNode *slotExpr, bool recurse)
+InternalSlotAccessNode* InternalSlotAccessNode::alloc(S32 lineNumber, ExprNode* objectExpr, ExprNode* slotExpr, bool recurse)
 {
-   InternalSlotAccessNode *ret = (InternalSlotAccessNode *)consoleAlloc(sizeof(InternalSlotAccessNode));
+   InternalSlotAccessNode* ret = (InternalSlotAccessNode*)consoleAlloc(sizeof(InternalSlotAccessNode));
    constructInPlace(ret);
    ret->dbgLineNumber = lineNumber;
+   ret->optimizedNode = NULL;
    ret->objectExpr = objectExpr;
    ret->slotExpr = slotExpr;
    ret->recurse = recurse;
    return ret;
 }
 
-SlotAssignNode *SlotAssignNode::alloc(S32 lineNumber, ExprNode *objectExpr, ExprNode *arrayExpr, StringTableEntry slotName, ExprNode *valueExpr, U32 typeID /* = -1 */)
+SlotAssignNode* SlotAssignNode::alloc(S32 lineNumber, ExprNode* objectExpr, ExprNode* arrayExpr, StringTableEntry slotName, ExprNode* valueExpr, U32 typeID /* = -1 */)
 {
-   SlotAssignNode *ret = (SlotAssignNode *)consoleAlloc(sizeof(SlotAssignNode));
+   SlotAssignNode* ret = (SlotAssignNode*)consoleAlloc(sizeof(SlotAssignNode));
    constructInPlace(ret);
    ret->dbgLineNumber = lineNumber;
+   ret->optimizedNode = NULL;
    ret->objectExpr = objectExpr;
    ret->arrayExpr = arrayExpr;
    ret->slotName = slotName;
@@ -392,11 +406,12 @@ SlotAssignNode *SlotAssignNode::alloc(S32 lineNumber, ExprNode *objectExpr, Expr
    return ret;
 }
 
-SlotAssignOpNode *SlotAssignOpNode::alloc(S32 lineNumber, ExprNode *objectExpr, StringTableEntry slotName, ExprNode *arrayExpr, S32 op, ExprNode *valueExpr)
+SlotAssignOpNode* SlotAssignOpNode::alloc(S32 lineNumber, ExprNode* objectExpr, StringTableEntry slotName, ExprNode* arrayExpr, S32 op, ExprNode* valueExpr)
 {
-   SlotAssignOpNode *ret = (SlotAssignOpNode *)consoleAlloc(sizeof(SlotAssignOpNode));
+   SlotAssignOpNode* ret = (SlotAssignOpNode*)consoleAlloc(sizeof(SlotAssignOpNode));
    constructInPlace(ret);
    ret->dbgLineNumber = lineNumber;
+   ret->optimizedNode = NULL;
    ret->objectExpr = objectExpr;
    ret->arrayExpr = arrayExpr;
    ret->slotName = slotName;
@@ -405,11 +420,12 @@ SlotAssignOpNode *SlotAssignOpNode::alloc(S32 lineNumber, ExprNode *objectExpr,
    return ret;
 }
 
-ObjectDeclNode *ObjectDeclNode::alloc(S32 lineNumber, ExprNode *classNameExpr, ExprNode *objectNameExpr, ExprNode *argList, StringTableEntry parentObject, SlotAssignNode *slotDecls, ObjectDeclNode *subObjects, bool isDatablock, bool classNameInternal, bool isSingleton)
+ObjectDeclNode* ObjectDeclNode::alloc(S32 lineNumber, ExprNode* classNameExpr, ExprNode* objectNameExpr, ExprNode* argList, StringTableEntry parentObject, SlotAssignNode* slotDecls, ObjectDeclNode* subObjects, bool isDatablock, bool classNameInternal, bool isSingleton)
 {
-   ObjectDeclNode *ret = (ObjectDeclNode *)consoleAlloc(sizeof(ObjectDeclNode));
+   ObjectDeclNode* ret = (ObjectDeclNode*)consoleAlloc(sizeof(ObjectDeclNode));
    constructInPlace(ret);
    ret->dbgLineNumber = lineNumber;
+   ret->optimizedNode = NULL;
    ret->classNameExpr = classNameExpr;
    ret->objectNameExpr = objectNameExpr;
    ret->argList = argList;
@@ -422,13 +438,13 @@ ObjectDeclNode *ObjectDeclNode::alloc(S32 lineNumber, ExprNode *classNameExpr, E
    if (parentObject)
       ret->parentObject = parentObject;
    else
-      ret->parentObject = StringTable->EmptyString();
+      ret->parentObject = StringTable->insert("");
    return ret;
 }
 
-FunctionDeclStmtNode *FunctionDeclStmtNode::alloc(S32 lineNumber, StringTableEntry fnName, StringTableEntry nameSpace, VarNode *args, StmtNode *stmts)
+FunctionDeclStmtNode* FunctionDeclStmtNode::alloc(S32 lineNumber, StringTableEntry fnName, StringTableEntry nameSpace, VarNode* args, StmtNode* stmts)
 {
-   FunctionDeclStmtNode *ret = (FunctionDeclStmtNode *)consoleAlloc(sizeof(FunctionDeclStmtNode));
+   FunctionDeclStmtNode* ret = (FunctionDeclStmtNode*)consoleAlloc(sizeof(FunctionDeclStmtNode));
    constructInPlace(ret);
    ret->dbgLineNumber = lineNumber;
    ret->fnName = fnName;
diff --git a/Engine/source/console/astNodes.cpp b/Engine/source/console/astNodes.cpp
index 51bde9d61..28e6b4960 100644
--- a/Engine/source/console/astNodes.cpp
+++ b/Engine/source/console/astNodes.cpp
@@ -44,94 +44,66 @@ struct Token
 
 namespace Compiler
 {
-   U32 compileBlock(StmtNode *block, CodeStream &codeStream, U32 ip)
+   U32 compileBlock(StmtNode* block, CodeStream& codeStream, U32 ip)
    {
-      for (StmtNode *walk = block; walk; walk = walk->getNext())
+      for (StmtNode* walk = block; walk; walk = walk->getNext())
          ip = walk->compileStmt(codeStream, ip);
       return codeStream.tell();
    }
-
-   inline bool isSimpleVarLookup(ExprNode *arrayExpr, StringTableEntry &varName)
-   {
-      if (arrayExpr == nullptr)
-      {
-         varName = StringTable->insert("");
-         return false;
-      }
-
-      // No double arrays allowed for optimization.
-      VarNode *var = dynamic_cast<VarNode*>(arrayExpr);
-      if (var && !var->arrayIndex)
-      {
-         StringTableEntry arrayVar = StringTable->insert(var->varName);
-         precompileIdent(arrayVar);
-         varName = arrayVar;
-         return true;
-      }
-      return false;
-   }
-
-   // Do not allow 'recursive' %this optimizations. It can lead to weird bytecode
-   // generation since we can only optimize one expression at a time.
-   static bool OnlyOneThisOptimization = false;
-
-   inline bool isThisVar(ExprNode *objectExpr)
-   {
-      // If we are currently optimizing a this var, don't allow extra optimization.
-      if (objectExpr == nullptr || OnlyOneThisOptimization)
-         return false;
-
-      VarNode *thisVar = dynamic_cast<VarNode*>(objectExpr);
-      if (thisVar && thisVar->varName == StringTable->insert("%this"))
-         return true;
-      return false;
-   }
-
-   inline void optimizeThisPointer(CodeStream &codeStream, ExprNode *arrayExpr, U32 &ip, StringTableEntry slotName)
-   {
-      OnlyOneThisOptimization = true;
-
-      // Is the array a simple variable? If so, we can optimize that.
-      StringTableEntry varName = nullptr;
-      bool simple = false;
-
-      if (arrayExpr)
-      {
-         simple = isSimpleVarLookup(arrayExpr, varName);
-         if (!simple)
-         {
-            // Less optimized array setting.
-            codeStream.emit(OP_ADVANCE_STR);
-            ip = arrayExpr->compile(codeStream, ip, TypeReqString);
-         }
-      }
-
-      codeStream.emit(OP_SETCURFIELD_THIS);
-      codeStream.emitSTE(slotName);
-
-      if (arrayExpr)
-      {
-         if (simple)
-         {
-            codeStream.emit(OP_SETCURFIELD_ARRAY_VAR);
-            codeStream.emitSTE(varName);
-         }
-         else
-         {
-            codeStream.emit(OP_SETCURFIELD_ARRAY);
-            codeStream.emit(OP_TERMINATE_REWIND_STR);
-         }
-      }
-
-      OnlyOneThisOptimization = false;
-   }
 }
 
 using namespace Compiler;
 
+class FuncVars
+{
+   struct Var
+   {
+      S32 reg;
+      TypeReq currentType;
+      bool isConstant;
+   };
+
+public:
+   S32 assign(StringTableEntry var, TypeReq currentType, bool isConstant = false)
+   {
+      std::unordered_map<StringTableEntry, Var>::iterator found = vars.find(var);
+      if (found != vars.end())
+      {
+         AssertISV(!found->second.isConstant, avar("Reassigning variable %s when it is a constant", var));
+         return found->second.reg;
+      }
+
+      S32 id = counter++;
+      vars[var] = { id, currentType, isConstant };
+      return id;
+   }
+
+   S32 lookup(StringTableEntry var)
+   {
+      std::unordered_map<StringTableEntry, Var>::iterator found = vars.find(var);
+      AssertISV(found != vars.end(), avar("Variable %s referenced before used when compiling script.", var));
+      return found->second.reg;
+   }
+
+   TypeReq lookupType(StringTableEntry var)
+   {
+      std::unordered_map<StringTableEntry, Var>::iterator found = vars.find(var);
+      AssertISV(found != vars.end(), avar("Variable %s referenced before used when compiling script.", var));
+      return found->second.currentType;
+   }
+
+   inline S32 count() { return counter; }
+
+private:
+   std::unordered_map<StringTableEntry, Var> vars;
+   S32 counter = 0;
+};
+
+FuncVars* gFuncVars = NULL;
+
 //-----------------------------------------------------------------------------
 
-void StmtNode::addBreakLine(CodeStream &code)
+void StmtNode::addBreakLine(CodeStream& code)
 {
    code.addBreakLine(dbgLineNumber, code.tell());
 }
@@ -140,21 +112,20 @@ void StmtNode::addBreakLine(CodeStream &code)
 
 StmtNode::StmtNode()
 {
-   mNext = NULL;
+   next = NULL;
    dbgFileName = CodeBlock::smCurrentParser->getCurrentFile();
-   dbgLineNumber = 0;
 }
 
 void StmtNode::setPackage(StringTableEntry)
 {
 }
 
-void StmtNode::append(StmtNode *next)
+void StmtNode::append(StmtNode* next)
 {
-   StmtNode *walk = this;
-   while (walk->mNext)
-      walk = walk->mNext;
-   walk->mNext = next;
+   StmtNode* walk = this;
+   while (walk->next)
+      walk = walk->next;
+   walk->next = next;
 }
 
 
@@ -175,64 +146,42 @@ static U32 conversionOp(TypeReq src, TypeReq dst)
    {
       switch (dst)
       {
-         case TypeReqUInt:
-            return OP_STR_TO_UINT;
-         case TypeReqFloat:
-            return OP_STR_TO_FLT;
-         case TypeReqNone:
-            return OP_STR_TO_NONE;
-         case TypeReqVar:
-            return OP_SAVEVAR_STR;
-         default:
-            break;
+      case TypeReqUInt:
+         return OP_STR_TO_UINT;
+      case TypeReqFloat:
+         return OP_STR_TO_FLT;
+      case TypeReqNone:
+         return OP_STR_TO_NONE;
+      default:
+         break;
       }
    }
    else if (src == TypeReqFloat)
    {
       switch (dst)
       {
-         case TypeReqUInt:
-            return OP_FLT_TO_UINT;
-         case TypeReqString:
-            return OP_FLT_TO_STR;
-         case TypeReqNone:
-            return OP_FLT_TO_NONE;
-         case TypeReqVar:
-            return OP_SAVEVAR_FLT;
-         default:
-            break;
+      case TypeReqUInt:
+         return OP_FLT_TO_UINT;
+      case TypeReqString:
+         return OP_FLT_TO_STR;
+      case TypeReqNone:
+         return OP_FLT_TO_NONE;
+      default:
+         break;
       }
    }
    else if (src == TypeReqUInt)
    {
       switch (dst)
       {
-         case TypeReqFloat:
-            return OP_UINT_TO_FLT;
-         case TypeReqString:
-            return OP_UINT_TO_STR;
-         case TypeReqNone:
-            return OP_UINT_TO_NONE;
-         case TypeReqVar:
-            return OP_SAVEVAR_UINT;
-         default:
-            break;
-      }
-   }
-   else if (src == TypeReqVar)
-   {
-      switch (dst)
-      {
-         case TypeReqUInt:
-            return OP_LOADVAR_UINT;
-         case TypeReqFloat:
-            return OP_LOADVAR_FLT;
-         case TypeReqString:
-            return OP_LOADVAR_STR;
-         case TypeReqNone:
-            return OP_COPYVAR_TO_NONE;
-         default:
-            break;
+      case TypeReqFloat:
+         return OP_UINT_TO_FLT;
+      case TypeReqString:
+         return OP_UINT_TO_STR;
+      case TypeReqNone:
+         return OP_UINT_TO_NONE;
+      default:
+         break;
       }
    }
    return OP_INVALID;
@@ -240,7 +189,7 @@ static U32 conversionOp(TypeReq src, TypeReq dst)
 
 //------------------------------------------------------------
 
-U32 BreakStmtNode::compileStmt(CodeStream &codeStream, U32 ip)
+U32 BreakStmtNode::compileStmt(CodeStream& codeStream, U32 ip)
 {
    if (codeStream.inLoop())
    {
@@ -257,7 +206,7 @@ U32 BreakStmtNode::compileStmt(CodeStream &codeStream, U32 ip)
 
 //------------------------------------------------------------
 
-U32 ContinueStmtNode::compileStmt(CodeStream &codeStream, U32 ip)
+U32 ContinueStmtNode::compileStmt(CodeStream& codeStream, U32 ip)
 {
    if (codeStream.inLoop())
    {
@@ -274,7 +223,7 @@ U32 ContinueStmtNode::compileStmt(CodeStream &codeStream, U32 ip)
 
 //------------------------------------------------------------
 
-U32 ExprNode::compileStmt(CodeStream &codeStream, U32 ip)
+U32 ExprNode::compileStmt(CodeStream& codeStream, U32 ip)
 {
    addBreakLine(codeStream);
    return compile(codeStream, ip, TypeReqNone);
@@ -282,7 +231,7 @@ U32 ExprNode::compileStmt(CodeStream &codeStream, U32 ip)
 
 //------------------------------------------------------------
 
-U32 ReturnStmtNode::compileStmt(CodeStream &codeStream, U32 ip)
+U32 ReturnStmtNode::compileStmt(CodeStream& codeStream, U32 ip)
 {
    addBreakLine(codeStream);
    if (!expr)
@@ -295,15 +244,15 @@ U32 ReturnStmtNode::compileStmt(CodeStream &codeStream, U32 ip)
 
       // Return the correct type
       switch (walkType) {
-         case TypeReqUInt:
-            codeStream.emit(OP_RETURN_UINT);
-            break;
-         case TypeReqFloat:
-            codeStream.emit(OP_RETURN_FLT);
-            break;
-         default:
-            codeStream.emit(OP_RETURN);
-            break;
+      case TypeReqUInt:
+         codeStream.emit(OP_RETURN_UINT);
+         break;
+      case TypeReqFloat:
+         codeStream.emit(OP_RETURN_FLT);
+         break;
+      default:
+         codeStream.emit(OP_RETURN);
+         break;
       }
    }
    return codeStream.tell();
@@ -311,10 +260,10 @@ U32 ReturnStmtNode::compileStmt(CodeStream &codeStream, U32 ip)
 
 //------------------------------------------------------------
 
-ExprNode *IfStmtNode::getSwitchOR(ExprNode *left, ExprNode *list, bool string)
+ExprNode* IfStmtNode::getSwitchOR(ExprNode* left, ExprNode* list, bool string)
 {
-   ExprNode *nextExpr = (ExprNode *)list->getNext();
-   ExprNode *test;
+   ExprNode* nextExpr = (ExprNode*)list->getNext();
+   ExprNode* test;
    if (string)
       test = StreqExprNode::alloc(left->dbgLineNumber, left, list, true);
    else
@@ -324,14 +273,14 @@ ExprNode *IfStmtNode::getSwitchOR(ExprNode *left, ExprNode *list, bool string)
    return IntBinaryExprNode::alloc(test->dbgLineNumber, opOR, test, getSwitchOR(left, nextExpr, string));
 }
 
-void IfStmtNode::propagateSwitchExpr(ExprNode *left, bool string)
+void IfStmtNode::propagateSwitchExpr(ExprNode* left, bool string)
 {
    testExpr = getSwitchOR(left, testExpr, string);
    if (propagate && elseBlock)
-      ((IfStmtNode *)elseBlock)->propagateSwitchExpr(left, string);
+      ((IfStmtNode*)elseBlock)->propagateSwitchExpr(left, string);
 }
 
-U32 IfStmtNode::compileStmt(CodeStream &codeStream, U32 ip)
+U32 IfStmtNode::compileStmt(CodeStream& codeStream, U32 ip)
 {
    U32 endifIp, elseIp;
    addBreakLine(codeStream);
@@ -373,7 +322,7 @@ U32 IfStmtNode::compileStmt(CodeStream &codeStream, U32 ip)
 
 //------------------------------------------------------------
 
-U32 LoopStmtNode::compileStmt(CodeStream &codeStream, U32 ip)
+U32 LoopStmtNode::compileStmt(CodeStream& codeStream, U32 ip)
 {
    if (testExpr->getPreferredType() == TypeReqUInt)
    {
@@ -446,7 +395,7 @@ U32 LoopStmtNode::compileStmt(CodeStream &codeStream, U32 ip)
 
 //------------------------------------------------------------
 
-U32 IterStmtNode::compileStmt(CodeStream &codeStream, U32 ip)
+U32 IterStmtNode::compileStmt(CodeStream& codeStream, U32 ip)
 {
    // Instruction sequence:
    //
@@ -491,7 +440,7 @@ U32 IterStmtNode::compileStmt(CodeStream &codeStream, U32 ip)
 
 //------------------------------------------------------------
 
-U32 ConditionalExprNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
+U32 ConditionalExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 {
    // code is testExpr
    // JMPIFNOT falseStart
@@ -528,25 +477,31 @@ TypeReq ConditionalExprNode::getPreferredType()
 
 //------------------------------------------------------------
 
-U32 FloatBinaryExprNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
+U32 FloatBinaryExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 {
+   if (optimize())
+   {
+      ip = optimizedNode->compile(codeStream, ip, type);
+      return codeStream.tell();
+   }
+
    ip = right->compile(codeStream, ip, TypeReqFloat);
    ip = left->compile(codeStream, ip, TypeReqFloat);
    U32 operand = OP_INVALID;
    switch (op)
    {
-      case '+':
-         operand = OP_ADD;
-         break;
-      case '-':
-         operand = OP_SUB;
-         break;
-      case '/':
-         operand = OP_DIV;
-         break;
-      case '*':
-         operand = OP_MUL;
-         break;
+   case '+':
+      operand = OP_ADD;
+      break;
+   case '-':
+      operand = OP_SUB;
+      break;
+   case '/':
+      operand = OP_DIV;
+      break;
+   case '*':
+      operand = OP_MUL;
+      break;
    }
    codeStream.emit(operand);
    if (type != TypeReqFloat)
@@ -566,59 +521,64 @@ void IntBinaryExprNode::getSubTypeOperand()
    subType = TypeReqUInt;
    switch (op)
    {
-      case '^':
-         operand = OP_XOR;
-         break;
-      case '%':
-         operand = OP_MOD;
-         break;
-      case '&':
-         operand = OP_BITAND;
-         break;
-      case '|':
-         operand = OP_BITOR;
-         break;
-      case '<':
-         operand = OP_CMPLT;
-         subType = TypeReqFloat;
-         break;
-      case '>':
-         operand = OP_CMPGR;
-         subType = TypeReqFloat;
-         break;
-      case opGE:
-         operand = OP_CMPGE;
-         subType = TypeReqFloat;
-         break;
-      case opLE:
-         operand = OP_CMPLE;
-         subType = TypeReqFloat;
-         break;
-      case opEQ:
-         operand = OP_CMPEQ;
-         subType = TypeReqFloat;
-         break;
-      case opNE:
-         operand = OP_CMPNE;
-         subType = TypeReqFloat;
-         break;
-      case opOR:
-         operand = OP_OR;
-         break;
-      case opAND:
-         operand = OP_AND;
-         break;
-      case opSHR:
-         operand = OP_SHR;
-         break;
-      case opSHL:
-         operand = OP_SHL;
-         break;
+   case '^':
+      operand = OP_XOR;
+      break;
+   case '%':
+      operand = OP_MOD;
+      break;
+   case '&':
+      operand = OP_BITAND;
+      break;
+   case '|':
+      operand = OP_BITOR;
+      break;
+   case '<':
+      operand = OP_CMPLT;
+      subType = TypeReqFloat;
+      break;
+   case '>':
+      operand = OP_CMPGR;
+      subType = TypeReqFloat;
+      break;
+   case opGE:
+      operand = OP_CMPGE;
+      subType = TypeReqFloat;
+      break;
+   case opLE:
+      operand = OP_CMPLE;
+      subType = TypeReqFloat;
+      break;
+   case opEQ:
+      operand = OP_CMPEQ;
+      subType = TypeReqFloat;
+      break;
+   case opNE:
+      operand = OP_CMPNE;
+      subType = TypeReqFloat;
+      break;
+   case opOR:
+      operand = OP_OR;
+      break;
+   case opAND:
+      operand = OP_AND;
+      break;
+   case opSHR:
+      operand = OP_SHR;
+      break;
+   case opSHL:
+      operand = OP_SHL;
+      break;
    }
 }
 
-U32 IntBinaryExprNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
+U32 IntBinaryExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 {
+   // TODO: What if we do other optimizations and this doesn't work for it..this
+   // so far only works for simple MOD optimizations...
+   if (optimize())
+      right = optimizedNode;
+
    getSubTypeOperand();
 
    if (operand == OP_OR || operand == OP_AND)
@@ -647,7 +607,7 @@ TypeReq IntBinaryExprNode::getPreferredType()
 
 //------------------------------------------------------------
 
-U32 StreqExprNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
+U32 StreqExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 {
    // eval str left
    // OP_ADVANCE_STR_NUL
@@ -673,7 +633,7 @@ TypeReq StreqExprNode::getPreferredType()
 
 //------------------------------------------------------------
 
-U32 StrcatExprNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
+U32 StrcatExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 {
    ip = left->compile(codeStream, ip, TypeReqString);
    if (!appendChar)
@@ -699,7 +659,7 @@ TypeReq StrcatExprNode::getPreferredType()
 
 //------------------------------------------------------------
 
-U32 CommaCatExprNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
+U32 CommaCatExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 {
    ip = left->compile(codeStream, ip, TypeReqString);
    codeStream.emit(OP_ADVANCE_STR_COMMA);
@@ -725,7 +685,7 @@ TypeReq CommaCatExprNode::getPreferredType()
 
 //------------------------------------------------------------
 
-U32 IntUnaryExprNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
+U32 IntUnaryExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 {
    integer = true;
    TypeReq prefType = expr->getPreferredType();
@@ -749,7 +709,7 @@ TypeReq IntUnaryExprNode::getPreferredType()
 
 //------------------------------------------------------------
 
-U32 FloatUnaryExprNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
+U32 FloatUnaryExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 {
    ip = expr->compile(codeStream, ip, TypeReqFloat);
    codeStream.emit(OP_NEG);
@@ -765,22 +725,16 @@ TypeReq FloatUnaryExprNode::getPreferredType()
 
 //------------------------------------------------------------
 
-U32 VarNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
+U32 VarNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 {
-   // if this has an arrayIndex and we are not short circuiting from a constant.
-   //    if we are a var node
-   //    OP_SETCURVAR_ARRAY_VARLOOKUP
-   //    varName
-   //    varNodeVarName
-
-   //    else
-   //    OP_LOADIMMED_IDENT
-   //    varName
-   //    OP_ADVANCE_STR
-   //    evaluate arrayIndex TypeReqString
-   //    OP_REWIND_STR
-   //    OP_SETCURVAR_ARRAY
-   //    OP_LOADVAR (type)
+   // if this has an arrayIndex...
+   // OP_LOADIMMED_IDENT
+   // varName
+   // OP_ADVANCE_STR
+   // evaluate arrayIndex TypeReqString
+   // OP_REWIND_STR
+   // OP_SETCURVAR_ARRAY
+   // OP_LOADVAR (type)
 
    // else
    // OP_SETCURVAR
@@ -790,56 +744,24 @@ U32 VarNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
    if (type == TypeReqNone)
       return codeStream.tell();
 
-   bool shortCircuit = false;
-   if (arrayIndex)
-   {
-      // If we have a constant, shortcircuit the array logic.
-
-      IntNode *intNode = dynamic_cast<IntNode*>(arrayIndex);
-      StrConstNode *strNode = dynamic_cast<StrConstNode*>(arrayIndex);
-      if (intNode)
-      {
-         varName = StringTable->insert(avar("%s%d", varName, intNode->value));
-         shortCircuit = true;
-      }
-      else if (strNode)
-      {
-         varName = StringTable->insert(avar("%s%s", varName, strNode->str));
-         shortCircuit = true;
-      }
-   }
-
    precompileIdent(varName);
 
-   if (arrayIndex && !shortCircuit)
+   bool oldVariables = arrayIndex || varName[0] == '$';
+
+   if (oldVariables)
    {
-      // Ok, lets try to optimize %var[%someothervar] as this is
-      // a common case for array usage.
-      StringTableEntry varNodeVarName;
-      if (isSimpleVarLookup(arrayIndex, varNodeVarName))
+      codeStream.emit(arrayIndex ? OP_LOADIMMED_IDENT : OP_SETCURVAR);
+      codeStream.emitSTE(varName);
+
+      if (arrayIndex)
       {
-         codeStream.emit(OP_SETCURVAR_ARRAY_VARLOOKUP);
-         codeStream.emitSTE(varName);
-         codeStream.emitSTE(varNodeVarName);
-      }
-      else
-      {
-         codeStream.emit(OP_LOADIMMED_IDENT);
-         codeStream.emitSTE(varName);
          codeStream.emit(OP_ADVANCE_STR);
          ip = arrayIndex->compile(codeStream, ip, TypeReqString);
          codeStream.emit(OP_REWIND_STR);
          codeStream.emit(OP_SETCURVAR_ARRAY);
       }
-   }
-   else
-   {
-      codeStream.emit(OP_SETCURVAR);
-      codeStream.emitSTE(varName);
-   }
-
-   switch (type)
-   {
+      switch (type)
+      {
       case TypeReqUInt:
          codeStream.emit(OP_LOADVAR_UINT);
          break;
@@ -849,25 +771,36 @@ U32 VarNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
       case TypeReqString:
          codeStream.emit(OP_LOADVAR_STR);
          break;
-      case TypeReqVar:
-         codeStream.emit(OP_LOADVAR_VAR);
-         break;
       case TypeReqNone:
          break;
       default:
          break;
+      }
    }
+   else
+   {
+      switch (type)
+      {
+      case TypeReqUInt:  codeStream.emit(OP_LOAD_LOCAL_VAR_UINT); break;
+      case TypeReqFloat: codeStream.emit(OP_LOAD_LOCAL_VAR_FLT); break;
+      default:           codeStream.emit(OP_LOAD_LOCAL_VAR_STR);
+      }
+
+      codeStream.emit(gFuncVars->lookup(varName));
+   }
+
    return codeStream.tell();
 }
 
 TypeReq VarNode::getPreferredType()
 {
-   return TypeReqNone; // no preferred type
+   bool oldVariables = arrayIndex || varName[0] == '$';
+   return oldVariables ? TypeReqNone : gFuncVars->lookupType(varName);
 }
 
 //------------------------------------------------------------
 
-U32 IntNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
+U32 IntNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 {
    if (type == TypeReqString)
       index = getCurrentStringTable()->addIntString(value);
@@ -876,20 +809,20 @@ U32 IntNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
 
    switch (type)
    {
-      case TypeReqUInt:
-         codeStream.emit(OP_LOADIMMED_UINT);
-         codeStream.emit(value);
-         break;
-      case TypeReqString:
-         codeStream.emit(OP_LOADIMMED_STR);
-         codeStream.emit(index);
-         break;
-      case TypeReqFloat:
-         codeStream.emit(OP_LOADIMMED_FLT);
-         codeStream.emit(index);
-         break;
-      case TypeReqNone:
-         break;
+   case TypeReqUInt:
+      codeStream.emit(OP_LOADIMMED_UINT);
+      codeStream.emit(value);
+      break;
+   case TypeReqString:
+      codeStream.emit(OP_LOADIMMED_STR);
+      codeStream.emit(index);
+      break;
+   case TypeReqFloat:
+      codeStream.emit(OP_LOADIMMED_FLT);
+      codeStream.emit(index);
+      break;
+   case TypeReqNone:
+      break;
    }
    return codeStream.tell();
 }
@@ -901,7 +834,7 @@ TypeReq IntNode::getPreferredType()
 
 //------------------------------------------------------------
 
-U32 FloatNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
+U32 FloatNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 {
    if (type == TypeReqString)
       index = getCurrentStringTable()->addFloatString(value);
@@ -910,20 +843,20 @@ U32 FloatNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
 
    switch (type)
    {
-      case TypeReqUInt:
-         codeStream.emit(OP_LOADIMMED_UINT);
-         codeStream.emit(U32(value));
-         break;
-      case TypeReqString:
-         codeStream.emit(OP_LOADIMMED_STR);
-         codeStream.emit(index);
-         break;
-      case TypeReqFloat:
-         codeStream.emit(OP_LOADIMMED_FLT);
-         codeStream.emit(index);
-         break;
-      case TypeReqNone:
-         break;
+   case TypeReqUInt:
+      codeStream.emit(OP_LOADIMMED_UINT);
+      codeStream.emit(U32(value));
+      break;
+   case TypeReqString:
+      codeStream.emit(OP_LOADIMMED_STR);
+      codeStream.emit(index);
+      break;
+   case TypeReqFloat:
+      codeStream.emit(OP_LOADIMMED_FLT);
+      codeStream.emit(index);
+      break;
+   case TypeReqNone:
+      break;
    }
    return codeStream.tell();
 }
@@ -935,7 +868,7 @@ TypeReq FloatNode::getPreferredType()
 
 //------------------------------------------------------------
 
-U32 StrConstNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
+U32 StrConstNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 {
    // Early out for documentation block.
    if (doc)
@@ -966,20 +899,20 @@ U32 StrConstNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
    // Otherwise, deal with it normally as a string literal case.
    switch (type)
    {
-      case TypeReqString:
-         codeStream.emit(tag ? OP_TAG_TO_STR : OP_LOADIMMED_STR);
-         codeStream.emit(index);
-         break;
-      case TypeReqUInt:
-         codeStream.emit(OP_LOADIMMED_UINT);
-         codeStream.emit(U32(fVal));
-         break;
-      case TypeReqFloat:
-         codeStream.emit(OP_LOADIMMED_FLT);
-         codeStream.emit(index);
-         break;
-      case TypeReqNone:
-         break;
+   case TypeReqString:
+      codeStream.emit(tag ? OP_TAG_TO_STR : OP_LOADIMMED_STR);
+      codeStream.emit(index);
+      break;
+   case TypeReqUInt:
+      codeStream.emit(OP_LOADIMMED_UINT);
+      codeStream.emit(U32(fVal));
+      break;
+   case TypeReqFloat:
+      codeStream.emit(OP_LOADIMMED_FLT);
+      codeStream.emit(index);
+      break;
+   case TypeReqNone:
+      break;
    }
    return codeStream.tell();
 }
@@ -991,7 +924,7 @@ TypeReq StrConstNode::getPreferredType()
 
 //------------------------------------------------------------
 
-U32 ConstantNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
+U32 ConstantNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 {
    if (type == TypeReqString)
    {
@@ -1006,20 +939,20 @@ U32 ConstantNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
 
    switch (type)
    {
-      case TypeReqString:
-         codeStream.emit(OP_LOADIMMED_IDENT);
-         codeStream.emitSTE(value);
-         break;
-      case TypeReqUInt:
-         codeStream.emit(OP_LOADIMMED_UINT);
-         codeStream.emit(U32(fVal));
-         break;
-      case TypeReqFloat:
-         codeStream.emit(OP_LOADIMMED_FLT);
-         codeStream.emit(index);
-         break;
-      case TypeReqNone:
-         break;
+   case TypeReqString:
+      codeStream.emit(OP_LOADIMMED_IDENT);
+      codeStream.emitSTE(value);
+      break;
+   case TypeReqUInt:
+      codeStream.emit(OP_LOADIMMED_UINT);
+      codeStream.emit(U32(fVal));
+      break;
+   case TypeReqFloat:
+      codeStream.emit(OP_LOADIMMED_FLT);
+      codeStream.emit(index);
+      break;
+   case TypeReqNone:
+      break;
    }
    return ip;
 }
@@ -1031,49 +964,23 @@ TypeReq ConstantNode::getPreferredType()
 
 //------------------------------------------------------------
 
-U32 AssignExprNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
+U32 AssignExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 {
    subType = expr->getPreferredType();
    if (subType == TypeReqNone)
       subType = type;
    if (subType == TypeReqNone)
-   {
-      // What we need to do in this case is turn it into a VarNode reference. 
-      // Unfortunately other nodes such as field access (SlotAccessNode) 
-      // cannot be optimized in the same manner as all fields are exposed 
-      // and set as strings.
-      if (dynamic_cast<VarNode*>(expr) != NULL)
-      {
-         subType = TypeReqVar;
-      }
-      else
-      {
-         subType = TypeReqString;
-      }
-   }
+      subType = TypeReqString;
 
-   //if we are an array index and we are gonna short circuit
-   // eval expr
-   // compute new varName
-   // OP_SETCURVAR_CREATE
-   // varName
-   // OP_SAVEVAR
-
-   //else if it's an array expr and we don't short circuit, the formula is:
+   // if it's an array expr, the formula is:
    // eval expr
    // (push and pop if it's TypeReqString) OP_ADVANCE_STR
-   // if array lookup is varnode
-   //    OP_SETCURVAR_ARRAY_CREATE_VARLOOKUP
-   //    varName
-   //    varNodeVarName
-   // else
-   //    OP_LOADIMMED_IDENT
-   //    varName
-   //    OP_ADVANCE_STR
-   //    eval array
-   //    OP_REWIND_STR
-   //    OP_SETCURVAR_ARRAY_CREATE
-   // endif
+   // OP_LOADIMMED_IDENT
+   // varName
+   // OP_ADVANCE_STR
+   // eval array
+   // OP_REWIND_STR
+   // OP_SETCURVAR_ARRAY_CREATE
    // OP_TERMINATE_REWIND_STR
    // OP_SAVEVAR
 
@@ -1083,45 +990,19 @@ U32 AssignExprNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
    // varname
    // OP_SAVEVAR
 
-   ip = expr->compile(codeStream, ip, subType);
-
-   bool shortCircuit = false;
-   if (arrayIndex)
-   {
-      // If we have a constant, shortcircuit the array logic.
-
-      IntNode *intNode = dynamic_cast<IntNode*>(arrayIndex);
-      StrConstNode *strNode = dynamic_cast<StrConstNode*>(arrayIndex);
-      if (intNode)
-      {
-         varName = StringTable->insert(avar("%s%d", varName, intNode->value));
-         shortCircuit = true;
-      }
-      else if (strNode)
-      {
-         varName = StringTable->insert(avar("%s%s", varName, strNode->str));
-         shortCircuit = true;
-      }
-   }
-
    precompileIdent(varName);
 
-   if (arrayIndex && !shortCircuit)
-   {
-      if (subType == TypeReqString)
-         codeStream.emit(OP_ADVANCE_STR);
+   ip = expr->compile(codeStream, ip, subType);
 
-      // Ok, lets try to optimize %var[%someothervar] as this is
-      // a common case for array usage.
-      StringTableEntry varNodeVarName;
-      if (isSimpleVarLookup(arrayIndex, varNodeVarName))
-      {
-         codeStream.emit(OP_SETCURVAR_ARRAY_CREATE_VARLOOKUP);
-         codeStream.emitSTE(varName);
-         codeStream.emitSTE(varNodeVarName);
-      }
-      else
+   bool oldVariables = arrayIndex || varName[0] == '$';
+
+   if (oldVariables)
+   {
+      if (arrayIndex)
       {
+         if (subType == TypeReqString)
+            codeStream.emit(OP_ADVANCE_STR);
+
          codeStream.emit(OP_LOADIMMED_IDENT);
          codeStream.emitSTE(varName);
 
@@ -1129,35 +1010,37 @@ U32 AssignExprNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
          ip = arrayIndex->compile(codeStream, ip, TypeReqString);
          codeStream.emit(OP_REWIND_STR);
          codeStream.emit(OP_SETCURVAR_ARRAY_CREATE);
+         if (subType == TypeReqString)
+            codeStream.emit(OP_TERMINATE_REWIND_STR);
+      }
+      else
+      {
+         codeStream.emit(OP_SETCURVAR_CREATE);
+         codeStream.emitSTE(varName);
+      }
+      switch (subType)
+      {
+      case TypeReqString: codeStream.emit(OP_SAVEVAR_STR);  break;
+      case TypeReqUInt:   codeStream.emit(OP_SAVEVAR_UINT); break;
+      case TypeReqFloat:  codeStream.emit(OP_SAVEVAR_FLT);  break;
       }
-
-      if (subType == TypeReqString)
-         codeStream.emit(OP_TERMINATE_REWIND_STR);
    }
    else
    {
-      codeStream.emit(OP_SETCURVAR_CREATE);
-      codeStream.emitSTE(varName);
-   }
-   switch (subType)
-   {
-      case TypeReqString:
-         codeStream.emit(OP_SAVEVAR_STR);
-         break;
-      case TypeReqUInt:
-         codeStream.emit(OP_SAVEVAR_UINT);
-         break;
-      case TypeReqFloat:
-         codeStream.emit(OP_SAVEVAR_FLT);
-         break;
-      case TypeReqVar:
-         codeStream.emit(OP_SAVEVAR_VAR);
-         break;
-      case TypeReqNone:
-         break;
+      switch (subType)
+      {
+      case TypeReqUInt:  codeStream.emit(OP_SAVE_LOCAL_VAR_UINT); break;
+      case TypeReqFloat: codeStream.emit(OP_SAVE_LOCAL_VAR_FLT); break;
+      default:           codeStream.emit(OP_SAVE_LOCAL_VAR_STR);
+      }
+      codeStream.emit(gFuncVars->assign(varName, subType == TypeReqNone ? TypeReqString : subType));
    }
+
    if (type != subType)
-      codeStream.emit(conversionOp(subType, type));
+   {
+      U32 conOp = conversionOp(subType, type);
+      codeStream.emit(conOp);
+   }
    return ip;
 }
 
@@ -1168,163 +1051,99 @@ TypeReq AssignExprNode::getPreferredType()
 
 //------------------------------------------------------------
 
-static void getAssignOpTypeOp(S32 op, TypeReq &type, U32 &operand)
+static void getAssignOpTypeOp(S32 op, TypeReq& type, U32& operand)
 {
    switch (op)
    {
-      case '+':
-      case opPLUSPLUS:
-         type = TypeReqFloat;
-         operand = OP_ADD;
-         break;
-      case '-':
-      case opMINUSMINUS:
-         type = TypeReqFloat;
-         operand = OP_SUB;
-         break;
-      case '*':
-         type = TypeReqFloat;
-         operand = OP_MUL;
-         break;
-      case '/':
-         type = TypeReqFloat;
-         operand = OP_DIV;
-         break;
-      case '%':
-         type = TypeReqUInt;
-         operand = OP_MOD;
-         break;
-      case '&':
-         type = TypeReqUInt;
-         operand = OP_BITAND;
-         break;
-      case '^':
-         type = TypeReqUInt;
-         operand = OP_XOR;
-         break;
-      case '|':
-         type = TypeReqUInt;
-         operand = OP_BITOR;
-         break;
-      case opSHL:
-         type = TypeReqUInt;
-         operand = OP_SHL;
-         break;
-      case opSHR:
-         type = TypeReqUInt;
-         operand = OP_SHR;
-         break;
+   case '+':
+   case opPLUSPLUS:
+      type = TypeReqFloat;
+      operand = OP_ADD;
+      break;
+   case '-':
+      type = TypeReqFloat;
+      operand = OP_SUB;
+      break;
+   case '*':
+      type = TypeReqFloat;
+      operand = OP_MUL;
+      break;
+   case '/':
+      type = TypeReqFloat;
+      operand = OP_DIV;
+      break;
+   case '%':
+      type = TypeReqUInt;
+      operand = OP_MOD;
+      break;
+   case '&':
+      type = TypeReqUInt;
+      operand = OP_BITAND;
+      break;
+   case '^':
+      type = TypeReqUInt;
+      operand = OP_XOR;
+      break;
+   case '|':
+      type = TypeReqUInt;
+      operand = OP_BITOR;
+      break;
+   case opSHL:
+      type = TypeReqUInt;
+      operand = OP_SHL;
+      break;
+   case opSHR:
+      type = TypeReqUInt;
+      operand = OP_SHR;
+      break;
    }
 }
 
-U32 AssignOpExprNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
+U32 AssignOpExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 {
 
    // goes like this...
-   //
-   // IF no array index && (op == OPPLUSPLUS or op == OPMINUSMINUS)
-   //    if op == OPPLUSPLUS
-   //       OP_INC
-   //       varName
-   //    else if op == OPMINUSMINUS
-   //       OP_DEC
-   //       varName
-   //    else
-   //       OP_INVALID
-   //    endif
-   // ELSE
-   //    eval expr as float or int
-   //    if there's an arrayIndex and we don't short circuit
-   //       if arrayIndex is a var node
-   //          OP_SETCURVAR_ARRAY_CREATE_VARLOOKUP
-   //          varName
-   //          varNodeVarName
-   //       else
-   //          OP_LOADIMMED_IDENT
-   //          varName
-   //          OP_ADVANCE_STR
-   //          eval arrayIndex stringwise
-   //          OP_REWIND_STR
-   //          OP_SETCURVAR_ARRAY_CREATE
-   //       endif
-   //    else
-   //       OP_SETCURVAR_CREATE
-   //       varName
-   //    endif
-   //    OP_LOADVAR_FLT or UINT
-   //    operand
-   //    OP_SAVEVAR_FLT or UINT
-   // ENDIF
-   //
-   // if subtype != type
-   //    convert type
-   // endif
+   // eval expr as float or int
+   // if there's an arrayIndex
+
+   // OP_LOADIMMED_IDENT
+   // varName
+   // OP_ADVANCE_STR
+   // eval arrayIndex stringwise
+   // OP_REWIND_STR
+   // OP_SETCURVAR_ARRAY_CREATE
+
+   // else
+   // OP_SETCURVAR_CREATE
+   // varName
+
+   // OP_LOADVAR_FLT or UINT
+   // operand
+   // OP_SAVEVAR_FLT or UINT
 
    // conversion OP if necessary.
    getAssignOpTypeOp(op, subType, operand);
+   precompileIdent(varName);
 
-   // ++ or -- optimization support for non indexed variables.
-   if ((!arrayIndex) && (op == opPLUSPLUS || op == opMINUSMINUS))
+   bool oldVariables = arrayIndex || varName[0] == '$';
+
+   if (op == opPLUSPLUS && !oldVariables)
    {
-      precompileIdent(varName);
+      const S32 varIdx = gFuncVars->assign(varName, TypeReqFloat);
 
-      if (op == opPLUSPLUS)
-      {
-         codeStream.emit(OP_INC);
-         codeStream.emitSTE(varName);
-      }
-      else if (op == opMINUSMINUS)
-      {
-         codeStream.emit(OP_DEC);
-         codeStream.emitSTE(varName);
-      }
-      else
-      {
-         // This should NEVER happen. This is just for sanity.
-         AssertISV(false, "Tried to use ++ or -- but something weird happened.");
-         codeStream.emit(OP_INVALID);
-      }
+      codeStream.emit(OP_INC);
+      codeStream.emit(varIdx);
    }
    else
    {
       ip = expr->compile(codeStream, ip, subType);
 
-      bool shortCircuit = false;
-      if (arrayIndex)
+      if (oldVariables)
       {
-         // If we have a constant, shortcircuit the array logic.
-
-         IntNode *intNode = dynamic_cast<IntNode*>(arrayIndex);
-         StrConstNode *strNode = dynamic_cast<StrConstNode*>(arrayIndex);
-         if (intNode)
+         if (!arrayIndex)
          {
-            varName = StringTable->insert(avar("%s%d", varName, intNode->value));
-            shortCircuit = true;
-         }
-         else if (strNode)
-         {
-            varName = StringTable->insert(avar("%s%s", varName, strNode->str));
-            shortCircuit = true;
-         }
-      }
-
-      precompileIdent(varName);
-
-      if (!arrayIndex || shortCircuit)
-      {
-         codeStream.emit(OP_SETCURVAR_CREATE);
-         codeStream.emitSTE(varName);
-      }
-      else
-      {
-         // Ok, lets try to optimize %var[%someothervar] as this is
-         // a common case for array usage.
-         StringTableEntry varNodeVarName;
-         if (isSimpleVarLookup(arrayIndex, varNodeVarName))
-         {
-            codeStream.emit(OP_SETCURVAR_ARRAY_CREATE_VARLOOKUP);
+            codeStream.emit(OP_SETCURVAR_CREATE);
             codeStream.emitSTE(varName);
-            codeStream.emitSTE(varNodeVarName);
          }
          else
          {
@@ -1336,13 +1155,27 @@ U32 AssignOpExprNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
             codeStream.emit(OP_REWIND_STR);
             codeStream.emit(OP_SETCURVAR_ARRAY_CREATE);
          }
+         codeStream.emit((subType == TypeReqFloat) ? OP_LOADVAR_FLT : OP_LOADVAR_UINT);
+         codeStream.emit(operand);
+         codeStream.emit((subType == TypeReqFloat) ? OP_SAVEVAR_FLT : OP_SAVEVAR_UINT);
+      }
+      else
+      {
+         const bool isFloat = subType == TypeReqFloat;
+         const S32 varIdx = gFuncVars->assign(varName, subType == TypeReqNone ? TypeReqString : subType);
+
+         codeStream.emit(isFloat ? OP_LOAD_LOCAL_VAR_FLT : OP_LOAD_LOCAL_VAR_UINT);
+         codeStream.emit(varIdx);
+         codeStream.emit(operand);
+         codeStream.emit(isFloat ? OP_SAVE_LOCAL_VAR_FLT : OP_SAVE_LOCAL_VAR_UINT);
+         codeStream.emit(varIdx);
+      }
+
+      if (subType != type)
+      {
+         codeStream.emit(conversionOp(subType, type));
       }
-      codeStream.emit((subType == TypeReqFloat) ? OP_LOADVAR_FLT : OP_LOADVAR_UINT);
-      codeStream.emit(operand);
-      codeStream.emit((subType == TypeReqFloat) ? OP_SAVEVAR_FLT : OP_SAVEVAR_UINT);
    }
-   if (subType != type)
-      codeStream.emit(conversionOp(subType, type));
    return codeStream.tell();
 }
 
@@ -1385,7 +1218,7 @@ TypeReq TTagExprNode::getPreferredType()
 
 //------------------------------------------------------------
 
-U32 FuncCallExprNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
+U32 FuncCallExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 {
    // OP_PUSH_FRAME
    // arg OP_PUSH arg OP_PUSH arg OP_PUSH
@@ -1399,69 +1232,38 @@ U32 FuncCallExprNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
    precompileIdent(funcName);
    precompileIdent(nameSpace);
 
+   S32 count = 0;
+   for (ExprNode* walk = args; walk; walk = static_cast<ExprNode*>(walk->getNext()))
+      count++;
+
    codeStream.emit(OP_PUSH_FRAME);
+   codeStream.emit(count);
 
-   bool isThisCall = false;
-
-   ExprNode *walk = args;
-
-   // Try to optimize the this pointer call if it is a variable
-   // that we are loading.
-   if (callType == MethodCall)
-   {
-      // We cannot optimize array indices because it can have quite
-      // a bit of code to figure out the array index.
-      VarNode *var = dynamic_cast<VarNode*>(args);
-      if (var && !var->arrayIndex)
-      {
-         precompileIdent(var->varName);
-
-         // Are we a %this call?
-         isThisCall = (var->varName == StringTable->insert("%this"));
-
-         codeStream.emit(OP_PUSH_THIS);
-         codeStream.emitSTE(var->varName);
-
-         // inc args since we took care of first arg.
-         walk = (ExprNode*)walk ->getNext();
-      }
-   }
-
-   for (; walk; walk = (ExprNode *)walk->getNext())
+   for (ExprNode* walk = args; walk; walk = static_cast<ExprNode*>(walk->getNext()))
    {
       TypeReq walkType = walk->getPreferredType();
-      if (walkType == TypeReqNone) walkType = TypeReqString;
+      if (walkType == TypeReqNone)
+         walkType = TypeReqString;
+
       ip = walk->compile(codeStream, ip, walkType);
       switch (walk->getPreferredType())
       {
-         case TypeReqFloat:
-            codeStream.emit(OP_PUSH_FLT);
-            break;
-         case TypeReqUInt:
-            codeStream.emit(OP_PUSH_UINT);
-            break;
-         default:
-            codeStream.emit(OP_PUSH);
-            break;
+      case TypeReqFloat:
+         codeStream.emit(OP_PUSH_FLT);
+         break;
+      case TypeReqUInt:
+         codeStream.emit(OP_PUSH_UINT);
+         break;
+      default:
+         codeStream.emit(OP_PUSH);
+         break;
       }
    }
 
-   if (isThisCall)
-   {
-      codeStream.emit(OP_CALLFUNC_THIS);
-      codeStream.emitSTE(funcName);
-   }
-   else
-   {
-      if (callType == MethodCall || callType == ParentCall)
-         codeStream.emit(OP_CALLFUNC);
-      else
-         codeStream.emit(OP_CALLFUNC_RESOLVE);
-
-      codeStream.emitSTE(funcName);
-      codeStream.emitSTE(nameSpace);
-      codeStream.emit(callType);
-   }
+   codeStream.emit(OP_CALLFUNC);
+   codeStream.emitSTE(funcName);
+   codeStream.emitSTE(nameSpace);
+   codeStream.emit(callType);
 
    if (type != TypeReqString)
       codeStream.emit(conversionOp(TypeReqString, type));
@@ -1473,53 +1275,10 @@ TypeReq FuncCallExprNode::getPreferredType()
    return TypeReqString;
 }
 
-//------------------------------------------------------------
-
-U32 FuncPointerCallExprNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
-{
-   // OP_PUSH_FRAME
-   // arg OP_PUSH arg OP_PUSH arg OP_PUSH
-   // eval all the args, then call the function.
-
-   // eval fn pointer
-   // OP_CALLFUNC_POINTER
-
-   codeStream.emit(OP_PUSH_FRAME);
-   for (ExprNode *walk = args; walk; walk = (ExprNode *)walk->getNext())
-   {
-      TypeReq walkType = walk->getPreferredType();
-      if (walkType == TypeReqNone) walkType = TypeReqString;
-      ip = walk->compile(codeStream, ip, walkType);
-      switch (walk->getPreferredType())
-      {
-         case TypeReqFloat:
-            codeStream.emit(OP_PUSH_FLT);
-            break;
-         case TypeReqUInt:
-            codeStream.emit(OP_PUSH_UINT);
-            break;
-         default:
-            codeStream.emit(OP_PUSH);
-            break;
-      }
-   }
-
-   ip = funcPointer->compile(codeStream, ip, TypeReqString);
-   codeStream.emit(OP_CALLFUNC_POINTER);
-
-   if (type != TypeReqString)
-      codeStream.emit(conversionOp(TypeReqString, type));
-   return codeStream.tell();
-}
-
-TypeReq FuncPointerCallExprNode::getPreferredType()
-{
-   return TypeReqString;
-}
 
 //------------------------------------------------------------
 
-U32 AssertCallExprNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
+U32 AssertCallExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 {
 #ifdef TORQUE_ENABLE_SCRIPTASSERTS
 
@@ -1541,59 +1300,51 @@ TypeReq AssertCallExprNode::getPreferredType()
 
 //------------------------------------------------------------
 
-U32 SlotAccessNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
+U32 SlotAccessNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 {
    if (type == TypeReqNone)
       return ip;
 
    precompileIdent(slotName);
 
-   // check if object is %this. If we are, we can do additional optimizations.
-   if (isThisVar(objectExpr))
+   if (arrayExpr)
    {
-      optimizeThisPointer(codeStream, arrayExpr, ip, slotName);
+      // eval array
+      // OP_ADVANCE_STR
+      // evaluate object expression sub (OP_SETCURFIELD)
+      // OP_TERMINATE_REWIND_STR
+      // OP_SETCURFIELDARRAY
+      // total add of 4 + array precomp
+
+      ip = arrayExpr->compile(codeStream, ip, TypeReqString);
+      codeStream.emit(OP_ADVANCE_STR);
    }
-   else
+   ip = objectExpr->compile(codeStream, ip, TypeReqString);
+   codeStream.emit(OP_SETCUROBJECT);
+
+   codeStream.emit(OP_SETCURFIELD);
+
+   codeStream.emitSTE(slotName);
+
+   if (arrayExpr)
    {
-      if (arrayExpr)
-      {
-         // eval array
-         // OP_ADVANCE_STR
-         // evaluate object expression sub (OP_SETCURFIELD)
-         // OP_TERMINATE_REWIND_STR
-         // OP_SETCURFIELDARRAY
-         // total add of 4 + array precomp
-
-         ip = arrayExpr->compile(codeStream, ip, TypeReqString);
-         codeStream.emit(OP_ADVANCE_STR);
-      }
-      ip = objectExpr->compile(codeStream, ip, TypeReqString);
-      codeStream.emit(OP_SETCUROBJECT);
-
-      codeStream.emit(OP_SETCURFIELD);
-
-      codeStream.emitSTE(slotName);
-
-      if (arrayExpr)
-      {
-         codeStream.emit(OP_TERMINATE_REWIND_STR);
-         codeStream.emit(OP_SETCURFIELD_ARRAY);
-      }
+      codeStream.emit(OP_TERMINATE_REWIND_STR);
+      codeStream.emit(OP_SETCURFIELD_ARRAY);
    }
 
    switch (type)
    {
-      case TypeReqUInt:
-         codeStream.emit(OP_LOADFIELD_UINT);
-         break;
-      case TypeReqFloat:
-         codeStream.emit(OP_LOADFIELD_FLT);
-         break;
-      case TypeReqString:
-         codeStream.emit(OP_LOADFIELD_STR);
-         break;
-      case TypeReqNone:
-         break;
+   case TypeReqUInt:
+      codeStream.emit(OP_LOADFIELD_UINT);
+      break;
+   case TypeReqFloat:
+      codeStream.emit(OP_LOADFIELD_FLT);
+      break;
+   case TypeReqString:
+      codeStream.emit(OP_LOADFIELD_STR);
+      break;
+   case TypeReqNone:
+      break;
    }
    return codeStream.tell();
 }
@@ -1605,7 +1356,7 @@ TypeReq SlotAccessNode::getPreferredType()
 
 //-----------------------------------------------------------------------------
 
-U32 InternalSlotAccessNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
+U32 InternalSlotAccessNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 {
    if (type == TypeReqNone)
       return ip;
@@ -1629,7 +1380,7 @@ TypeReq InternalSlotAccessNode::getPreferredType()
 
 //-----------------------------------------------------------------------------
 
-U32 SlotAssignNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
+U32 SlotAssignNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 {
    // first eval the expression TypeReqString
 
@@ -1662,38 +1413,29 @@ U32 SlotAssignNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
    precompileIdent(slotName);
 
    ip = valueExpr->compile(codeStream, ip, TypeReqString);
-
-   if (isThisVar(objectExpr))
+   codeStream.emit(OP_ADVANCE_STR);
+   if (arrayExpr)
    {
-      optimizeThisPointer(codeStream, arrayExpr, ip, slotName);
+      ip = arrayExpr->compile(codeStream, ip, TypeReqString);
+      codeStream.emit(OP_ADVANCE_STR);
+   }
+   if (objectExpr)
+   {
+      ip = objectExpr->compile(codeStream, ip, TypeReqString);
+      codeStream.emit(OP_SETCUROBJECT);
    }
    else
+      codeStream.emit(OP_SETCUROBJECT_NEW);
+   codeStream.emit(OP_SETCURFIELD);
+   codeStream.emitSTE(slotName);
+
+   if (arrayExpr)
    {
-      codeStream.emit(OP_ADVANCE_STR);
-      if (arrayExpr)
-      {
-         ip = arrayExpr->compile(codeStream, ip, TypeReqString);
-         codeStream.emit(OP_ADVANCE_STR);
-      }
-      if (objectExpr)
-      {
-         ip = objectExpr->compile(codeStream, ip, TypeReqString);
-         codeStream.emit(OP_SETCUROBJECT);
-      }
-      else
-         codeStream.emit(OP_SETCUROBJECT_NEW);
-      codeStream.emit(OP_SETCURFIELD);
-      codeStream.emitSTE(slotName);
-
-      if (arrayExpr)
-      {
-         codeStream.emit(OP_TERMINATE_REWIND_STR);
-         codeStream.emit(OP_SETCURFIELD_ARRAY);
-      }
-
       codeStream.emit(OP_TERMINATE_REWIND_STR);
+      codeStream.emit(OP_SETCURFIELD_ARRAY);
    }
 
+   codeStream.emit(OP_TERMINATE_REWIND_STR);
    codeStream.emit(OP_SAVEFIELD_STR);
 
    if (typeID != -1)
@@ -1714,7 +1456,7 @@ TypeReq SlotAssignNode::getPreferredType()
 
 //------------------------------------------------------------
 
-U32 SlotAssignOpNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
+U32 SlotAssignOpNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 {
    // first eval the expression as its type
 
@@ -1743,28 +1485,20 @@ U32 SlotAssignOpNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
    precompileIdent(slotName);
 
    ip = valueExpr->compile(codeStream, ip, subType);
-
-   if (isThisVar(objectExpr))
+   if (arrayExpr)
    {
-      optimizeThisPointer(codeStream, arrayExpr, ip, slotName);
+      ip = arrayExpr->compile(codeStream, ip, TypeReqString);
+      codeStream.emit(OP_ADVANCE_STR);
    }
-   else
-   {
-      if (arrayExpr)
-      {
-         ip = arrayExpr->compile(codeStream, ip, TypeReqString);
-         codeStream.emit(OP_ADVANCE_STR);
-      }
-      ip = objectExpr->compile(codeStream, ip, TypeReqString);
-      codeStream.emit(OP_SETCUROBJECT);
-      codeStream.emit(OP_SETCURFIELD);
-      codeStream.emitSTE(slotName);
+   ip = objectExpr->compile(codeStream, ip, TypeReqString);
+   codeStream.emit(OP_SETCUROBJECT);
+   codeStream.emit(OP_SETCURFIELD);
+   codeStream.emitSTE(slotName);
 
-      if (arrayExpr)
-      {
-         codeStream.emit(OP_TERMINATE_REWIND_STR);
-         codeStream.emit(OP_SETCURFIELD_ARRAY);
-      }
+   if (arrayExpr)
+   {
+      codeStream.emit(OP_TERMINATE_REWIND_STR);
+      codeStream.emit(OP_SETCURFIELD_ARRAY);
    }
    codeStream.emit((subType == TypeReqFloat) ? OP_LOADFIELD_FLT : OP_LOADFIELD_UINT);
    codeStream.emit(operand);
@@ -1782,7 +1516,7 @@ TypeReq SlotAssignOpNode::getPreferredType()
 
 //------------------------------------------------------------
 
-U32 ObjectDeclNode::compileSubObject(CodeStream &codeStream, U32 ip, bool root)
+U32 ObjectDeclNode::compileSubObject(CodeStream& codeStream, U32 ip, bool root)
 {
    // goes
 
@@ -1808,29 +1542,34 @@ U32 ObjectDeclNode::compileSubObject(CodeStream &codeStream, U32 ip, bool root)
    // To fix the stack issue [7/9/2007 Black]
    // OP_FINISH_OBJECT <-- fail point jumps to this opcode
 
+   S32 count = 2; // 2 OP_PUSH's
+   for (ExprNode* exprWalk = argList; exprWalk; exprWalk = (ExprNode*)exprWalk->getNext())
+      count++;
+
    codeStream.emit(OP_PUSH_FRAME);
+   codeStream.emit(count);
 
    ip = classNameExpr->compile(codeStream, ip, TypeReqString);
    codeStream.emit(OP_PUSH);
 
    ip = objectNameExpr->compile(codeStream, ip, TypeReqString);
    codeStream.emit(OP_PUSH);
-   for (ExprNode *exprWalk = argList; exprWalk; exprWalk = (ExprNode *)exprWalk->getNext())
+   for (ExprNode* exprWalk = argList; exprWalk; exprWalk = (ExprNode*)exprWalk->getNext())
    {
       TypeReq walkType = exprWalk->getPreferredType();
       if (walkType == TypeReqNone) walkType = TypeReqString;
       ip = exprWalk->compile(codeStream, ip, walkType);
       switch (exprWalk->getPreferredType())
       {
-         case TypeReqFloat:
-            codeStream.emit(OP_PUSH_FLT);
-            break;
-         case TypeReqUInt:
-            codeStream.emit(OP_PUSH_UINT);
-            break;
-         default:
-            codeStream.emit(OP_PUSH);
-            break;
+      case TypeReqFloat:
+         codeStream.emit(OP_PUSH_FLT);
+         break;
+      case TypeReqUInt:
+         codeStream.emit(OP_PUSH_UINT);
+         break;
+      default:
+         codeStream.emit(OP_PUSH);
+         break;
       }
    }
    codeStream.emit(OP_CREATE_OBJECT);
@@ -1841,11 +1580,11 @@ U32 ObjectDeclNode::compileSubObject(CodeStream &codeStream, U32 ip, bool root)
    codeStream.emit(isSingleton);
    codeStream.emit(dbgLineNumber);
    const U32 failIp = codeStream.emit(0);
-   for (SlotAssignNode *slotWalk = slotDecls; slotWalk; slotWalk = (SlotAssignNode *)slotWalk->getNext())
+   for (SlotAssignNode* slotWalk = slotDecls; slotWalk; slotWalk = (SlotAssignNode*)slotWalk->getNext())
       ip = slotWalk->compile(codeStream, ip, TypeReqNone);
    codeStream.emit(OP_ADD_OBJECT);
    codeStream.emit(root);
-   for (ObjectDeclNode *objectWalk = subObjects; objectWalk; objectWalk = (ObjectDeclNode *)objectWalk->getNext())
+   for (ObjectDeclNode* objectWalk = subObjects; objectWalk; objectWalk = (ObjectDeclNode*)objectWalk->getNext())
       ip = objectWalk->compileSubObject(codeStream, ip, false);
    codeStream.emit(OP_END_OBJECT);
    codeStream.emit(root || isDatablock);
@@ -1857,7 +1596,7 @@ U32 ObjectDeclNode::compileSubObject(CodeStream &codeStream, U32 ip, bool root)
    return codeStream.tell();
 }
 
-U32 ObjectDeclNode::compile(CodeStream &codeStream, U32 ip, TypeReq type)
+U32 ObjectDeclNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 {
    // root object decl does:
 
@@ -1881,7 +1620,7 @@ TypeReq ObjectDeclNode::getPreferredType()
 
 //------------------------------------------------------------
 
-U32 FunctionDeclStmtNode::compileStmt(CodeStream &codeStream, U32 ip)
+U32 FunctionDeclStmtNode::compileStmt(CodeStream& codeStream, U32 ip)
 {
    // OP_FUNC_DECL
    // func name
@@ -1896,10 +1635,14 @@ U32 FunctionDeclStmtNode::compileStmt(CodeStream &codeStream, U32 ip)
    setCurrentStringTable(&getFunctionStringTable());
    setCurrentFloatTable(&getFunctionFloatTable());
 
+   FuncVars vars;
+   gFuncVars = &vars;
+
    argc = 0;
-   for (VarNode *walk = args; walk; walk = (VarNode *)((StmtNode*)walk)->getNext())
+   for (VarNode* walk = args; walk; walk = (VarNode*)((StmtNode*)walk)->getNext())
    {
       precompileIdent(walk->varName);
+      gFuncVars->assign(walk->varName, TypeReqNone);
       argc++;
    }
 
@@ -1919,9 +1662,11 @@ U32 FunctionDeclStmtNode::compileStmt(CodeStream &codeStream, U32 ip)
    codeStream.emit(U32(bool(stmts != NULL) ? 1 : 0) + U32(dbgLineNumber << 1));
    const U32 endIp = codeStream.emit(0);
    codeStream.emit(argc);
-   for (VarNode *walk = args; walk; walk = (VarNode *)((StmtNode*)walk)->getNext())
+   const U32 localNumVarsIP = codeStream.emit(0);
+   for (VarNode* walk = args; walk; walk = (VarNode*)((StmtNode*)walk)->getNext())
    {
-      codeStream.emitSTE(walk->varName);
+      StringTableEntry name = walk->varName;
+      codeStream.emit(gFuncVars->lookup(name));
    }
    CodeBlock::smInFunction = true;
    ip = compileBlock(stmts, codeStream, ip);
@@ -1933,10 +1678,12 @@ U32 FunctionDeclStmtNode::compileStmt(CodeStream &codeStream, U32 ip)
    CodeBlock::smInFunction = false;
    codeStream.emit(OP_RETURN_VOID);
 
+   codeStream.patch(localNumVarsIP, gFuncVars->count());
    codeStream.patch(endIp, codeStream.tell());
 
    setCurrentStringTable(&getGlobalStringTable());
    setCurrentFloatTable(&getGlobalFloatTable());
+   gFuncVars = NULL;
 
    return ip;
 }
diff --git a/Engine/source/console/codeBlock.cpp b/Engine/source/console/codeBlock.cpp
index b4dd6b2c6..997519231 100644
--- a/Engine/source/console/codeBlock.cpp
+++ b/Engine/source/console/codeBlock.cpp
@@ -477,7 +477,6 @@ bool CodeBlock::compile(const char *codeFileName, StringTableEntry fileName, con
    STEtoCode = compileSTEtoCode;
 
    gStatementList = NULL;
-   gAnonFunctionList = NULL;
 
    // Set up the parser.
    smCurrentParser = getParserForFile(fileName);
@@ -487,17 +486,6 @@ bool CodeBlock::compile(const char *codeFileName, StringTableEntry fileName, con
    smCurrentParser->setScanBuffer(script, fileName);
    smCurrentParser->restart(NULL);
    smCurrentParser->parse();
-   if (gStatementList)
-   {
-      if (gAnonFunctionList)
-      {
-         // Prepend anonymous functions to statement list, so they're defined already when
-         // the statements run.
-         gAnonFunctionList->append(gStatementList);
-         gStatementList = gAnonFunctionList;
-      }
-   }
-
 
    if (gSyntaxError)
    {
@@ -575,11 +563,9 @@ bool CodeBlock::compile(const char *codeFileName, StringTableEntry fileName, con
    st.close();
 
    return true;
-
-
 }
 
-ConsoleValueRef CodeBlock::compileExec(StringTableEntry fileName, const char *inString, bool noCalls, S32 setFrame)
+void CodeBlock::compileExec(StringTableEntry fileName, const char *inString, ConsoleValue &returnValue, bool noCalls, S32 setFrame)
 {
    AssertFatal(Con::isMainThread(), "Compiling code on a secondary thread");
 
@@ -620,7 +606,6 @@ ConsoleValueRef CodeBlock::compileExec(StringTableEntry fileName, const char *in
       addToCodeList();
 
    gStatementList = NULL;
-   gAnonFunctionList = NULL;
 
    // Set up the parser.
    smCurrentParser = getParserForFile(fileName);
@@ -630,21 +615,11 @@ ConsoleValueRef CodeBlock::compileExec(StringTableEntry fileName, const char *in
    smCurrentParser->setScanBuffer(string, fileName);
    smCurrentParser->restart(NULL);
    smCurrentParser->parse();
-   if (gStatementList)
-   {
-      if (gAnonFunctionList)
-      {
-         // Prepend anonymous functions to statement list, so they're defined already when
-         // the statements run.
-         gAnonFunctionList->append(gStatementList);
-         gStatementList = gAnonFunctionList;
-      }
-   }
 
    if (!gStatementList)
    {
       delete this;
-      return ConsoleValueRef();
+      return;
    }
 
    resetTables();
@@ -678,7 +653,7 @@ ConsoleValueRef CodeBlock::compileExec(StringTableEntry fileName, const char *in
    if (lastIp + 1 != codeSize)
       Con::warnf(ConsoleLogEntry::General, "precompile size mismatch, precompile: %d compile: %d", codeSize, lastIp);
 
-   return exec(0, fileName, NULL, 0, 0, noCalls, NULL, setFrame);
+   exec(0, fileName, NULL, 0, 0, noCalls, NULL, returnValue, setFrame);
 }
 
 //-------------------------------------------------------------------------
@@ -739,775 +714,723 @@ void CodeBlock::dumpInstructions(U32 startIp, bool upToReturn)
       switch (code[ip++])
       {
 
-         case OP_FUNC_DECL:
-         {
-            StringTableEntry fnName = CodeToSTE(code, ip);
-            StringTableEntry fnNamespace = CodeToSTE(code, ip + 2);
-            StringTableEntry fnPackage = CodeToSTE(code, ip + 4);
-            bool hasBody = bool(code[ip + 6]);
-            U32 newIp = code[ip + 7];
-            U32 argc = code[ip + 8];
-            endFuncIp = newIp;
-
-            Con::printf("%i: OP_FUNC_DECL name=%s nspace=%s package=%s hasbody=%i newip=%i argc=%i",
-               ip - 1, fnName, fnNamespace, fnPackage, hasBody, newIp, argc);
-
-            // Skip args.
-
-            ip += 9 + (argc * 2);
-            smInFunction = true;
-            break;
-         }
-
-         case OP_CREATE_OBJECT:
-         {
-            StringTableEntry objParent = CodeToSTE(code, ip);
-            bool isDataBlock = code[ip + 2];
-            bool isInternal = code[ip + 3];
-            bool isSingleton = code[ip + 4];
-            U32  lineNumber = code[ip + 5];
-            U32 failJump = code[ip + 6];
-
-            Con::printf("%i: OP_CREATE_OBJECT objParent=%s isDataBlock=%i isInternal=%i isSingleton=%i lineNumber=%i failJump=%i",
-               ip - 1, objParent, isDataBlock, isInternal, isSingleton, lineNumber, failJump);
-
-            ip += 7;
-            break;
-         }
-
-         case OP_ADD_OBJECT:
-         {
-            bool placeAtRoot = code[ip++];
-            Con::printf("%i: OP_ADD_OBJECT placeAtRoot=%i", ip - 1, placeAtRoot);
-            break;
-         }
-
-         case OP_END_OBJECT:
-         {
-            bool placeAtRoot = code[ip++];
-            Con::printf("%i: OP_END_OBJECT placeAtRoot=%i", ip - 1, placeAtRoot);
-            break;
-         }
-
-         case OP_FINISH_OBJECT:
-         {
-            Con::printf("%i: OP_FINISH_OBJECT", ip - 1);
-            break;
-         }
-
-         case OP_JMPIFFNOT:
-         {
-            Con::printf("%i: OP_JMPIFFNOT ip=%i", ip - 1, code[ip]);
-            ++ip;
-            break;
-         }
-
-         case OP_JMPIFNOT:
-         {
-            Con::printf("%i: OP_JMPIFNOT ip=%i", ip - 1, code[ip]);
-            ++ip;
-            break;
-         }
-
-         case OP_JMPIFF:
-         {
-            Con::printf("%i: OP_JMPIFF ip=%i", ip - 1, code[ip]);
-            ++ip;
-            break;
-         }
-
-         case OP_JMPIF:
-         {
-            Con::printf("%i: OP_JMPIF ip=%i", ip - 1, code[ip]);
-            ++ip;
-            break;
-         }
-
-         case OP_JMPIFNOT_NP:
-         {
-            Con::printf("%i: OP_JMPIFNOT_NP ip=%i", ip - 1, code[ip]);
-            ++ip;
-            break;
-         }
-
-         case OP_JMPIF_NP:
-         {
-            Con::printf("%i: OP_JMPIF_NP ip=%i", ip - 1, code[ip]);
-            ++ip;
-            break;
-         }
-
-         case OP_JMP:
-         {
-            Con::printf("%i: OP_JMP ip=%i", ip - 1, code[ip]);
-            ++ip;
-            break;
-         }
-
-         case OP_RETURN:
-         {
-            Con::printf("%i: OP_RETURN", ip - 1);
-
-            if (upToReturn)
-               return;
-
-            break;
-         }
-
-         case OP_RETURN_VOID:
-         {
-            Con::printf("%i: OP_RETURNVOID", ip - 1);
-
-            if (upToReturn)
-               return;
-
-            break;
-         }
-
-         case OP_RETURN_UINT:
-         {
-            Con::printf("%i: OP_RETURNUINT", ip - 1);
-
-            if (upToReturn)
-               return;
-
-            break;
-         }
-
-         case OP_RETURN_FLT:
-         {
-            Con::printf("%i: OP_RETURNFLT", ip - 1);
-
-            if (upToReturn)
-               return;
-
-            break;
-         }
-
-         case OP_CMPEQ:
-         {
-            Con::printf("%i: OP_CMPEQ", ip - 1);
-            break;
-         }
-
-         case OP_CMPGR:
-         {
-            Con::printf("%i: OP_CMPGR", ip - 1);
-            break;
-         }
-
-         case OP_CMPGE:
-         {
-            Con::printf("%i: OP_CMPGE", ip - 1);
-            break;
-         }
-
-         case OP_CMPLT:
-         {
-            Con::printf("%i: OP_CMPLT", ip - 1);
-            break;
-         }
-
-         case OP_CMPLE:
-         {
-            Con::printf("%i: OP_CMPLE", ip - 1);
-            break;
-         }
-
-         case OP_CMPNE:
-         {
-            Con::printf("%i: OP_CMPNE", ip - 1);
-            break;
-         }
-
-         case OP_XOR:
-         {
-            Con::printf("%i: OP_XOR", ip - 1);
-            break;
-         }
-
-         case OP_MOD:
-         {
-            Con::printf("%i: OP_MOD", ip - 1);
-            break;
-         }
-
-         case OP_BITAND:
-         {
-            Con::printf("%i: OP_BITAND", ip - 1);
-            break;
-         }
-
-         case OP_BITOR:
-         {
-            Con::printf("%i: OP_BITOR", ip - 1);
-            break;
-         }
-
-         case OP_NOT:
-         {
-            Con::printf("%i: OP_NOT", ip - 1);
-            break;
-         }
-
-         case OP_NOTF:
-         {
-            Con::printf("%i: OP_NOTF", ip - 1);
-            break;
-         }
-
-         case OP_ONESCOMPLEMENT:
-         {
-            Con::printf("%i: OP_ONESCOMPLEMENT", ip - 1);
-            break;
-         }
-
-         case OP_SHR:
-         {
-            Con::printf("%i: OP_SHR", ip - 1);
-            break;
-         }
-
-         case OP_SHL:
-         {
-            Con::printf("%i: OP_SHL", ip - 1);
-            break;
-         }
-
-         case OP_AND:
-         {
-            Con::printf("%i: OP_AND", ip - 1);
-            break;
-         }
-
-         case OP_OR:
-         {
-            Con::printf("%i: OP_OR", ip - 1);
-            break;
-         }
-
-         case OP_ADD:
-         {
-            Con::printf("%i: OP_ADD", ip - 1);
-            break;
-         }
-
-         case OP_SUB:
-         {
-            Con::printf("%i: OP_SUB", ip - 1);
-            break;
-         }
-
-         case OP_MUL:
-         {
-            Con::printf("%i: OP_MUL", ip - 1);
-            break;
-         }
-
-         case OP_DIV:
-         {
-            Con::printf("%i: OP_DIV", ip - 1);
-            break;
-         }
-
-         case OP_NEG:
-         {
-            Con::printf("%i: OP_NEG", ip - 1);
-            break;
-         }
-
-         case OP_INC:
-         {
-            Con::printf("%i: OP_INC varName=%s", ip - 1, CodeToSTE(code, ip));
-            ip += 2;
-            break;
-         }
-
-         case OP_DEC:
-         {
-            Con::printf("%i: OP_DEC varName=%s", ip - 1, CodeToSTE(code, ip));
-            ip += 2;
-            break;
-         }
-
-         case OP_SETCURVAR:
-         {
-            StringTableEntry var = CodeToSTE(code, ip);
-
-            Con::printf("%i: OP_SETCURVAR var=%s", ip - 1, var);
-            ip += 2;
-            break;
-         }
-
-         case OP_SETCURVAR_CREATE:
-         {
-            StringTableEntry var = CodeToSTE(code, ip);
-
-            Con::printf("%i: OP_SETCURVAR_CREATE var=%s", ip - 1, var);
-            ip += 2;
-            break;
-         }
-
-         case OP_SETCURVAR_ARRAY:
-         {
-            Con::printf("%i: OP_SETCURVAR_ARRAY", ip - 1);
-            break;
-         }
-
-         case OP_SETCURVAR_ARRAY_VARLOOKUP:
-         {
-            StringTableEntry arrayName = CodeToSTE(code, ip);
-            StringTableEntry arrayLookup = CodeToSTE(code, ip + 2);
-
-            Con::printf("%i: OP_SETCURVAR_ARRAY_VARLOOKUP arrayName=%s arrayLookup=%s", ip - 1, arrayName, arrayLookup);
-            ip += 4;
-            break;
-         }
-
-         case OP_SETCURVAR_ARRAY_CREATE:
-         {
-            Con::printf("%i: OP_SETCURVAR_ARRAY_CREATE", ip - 1);
-            break;
-         }
-
-         case OP_SETCURVAR_ARRAY_CREATE_VARLOOKUP:
-         {
-            StringTableEntry arrayName = CodeToSTE(code, ip);
-            StringTableEntry arrayLookup = CodeToSTE(code, ip + 2);
-
-            Con::printf("%i: OP_SETCURVAR_ARRAY_CREATE_VARLOOKUP arrayName=%s arrayLookup=%s", ip - 1, arrayName, arrayLookup);
-            ip += 4;
-            break;
-         }
-
-         case OP_LOADVAR_UINT:
-         {
-            Con::printf("%i: OP_LOADVAR_UINT", ip - 1);
-            break;
-         }
-
-         case OP_LOADVAR_FLT:
-         {
-            Con::printf("%i: OP_LOADVAR_FLT", ip - 1);
-            break;
-         }
-
-         case OP_LOADVAR_STR:
-         {
-            Con::printf("%i: OP_LOADVAR_STR", ip - 1);
-            break;
-         }
-
-         case OP_LOADVAR_VAR:
-         {
-            Con::printf("%i: OP_LOADVAR_VAR", ip - 1);
-            break;
-         }
-
-         case OP_SAVEVAR_UINT:
-         {
-            Con::printf("%i: OP_SAVEVAR_UINT", ip - 1);
-            break;
-         }
-
-         case OP_SAVEVAR_FLT:
-         {
-            Con::printf("%i: OP_SAVEVAR_FLT", ip - 1);
-            break;
-         }
-
-         case OP_SAVEVAR_STR:
-         {
-            Con::printf("%i: OP_SAVEVAR_STR", ip - 1);
-            break;
-         }
-
-         case OP_SAVEVAR_VAR:
-         {
-            Con::printf("%i: OP_SAVEVAR_VAR", ip - 1);
-            break;
-         }
-
-         case OP_SETCUROBJECT:
-         {
-            Con::printf("%i: OP_SETCUROBJECT", ip - 1);
-            break;
-         }
-
-         case OP_SETCUROBJECT_NEW:
-         {
-            Con::printf("%i: OP_SETCUROBJECT_NEW", ip - 1);
-            break;
-         }
-
-         case OP_SETCUROBJECT_INTERNAL:
-         {
-            Con::printf("%i: OP_SETCUROBJECT_INTERNAL", ip - 1);
-            ++ip;
-            break;
-         }
-
-         case OP_SETCURFIELD:
-         {
-            StringTableEntry curField = CodeToSTE(code, ip);
-            Con::printf("%i: OP_SETCURFIELD field=%s", ip - 1, curField);
-            ip += 2;
-            break;
-         }
-
-         case OP_SETCURFIELD_ARRAY:
-         {
-            Con::printf("%i: OP_SETCURFIELD_ARRAY", ip - 1);
-            break;
-         }
-
-         case OP_SETCURFIELD_ARRAY_VAR:
-         {
-            StringTableEntry var = CodeToSTE(code, ip);
-            Con::printf("%i: OP_SETCURFIELD_ARRAY_VAR var=%s", ip - 1, var);
-            ip += 2;
-            break;
-         }
-
-         case OP_SETCURFIELD_THIS:
-         {
-            StringTableEntry curField = CodeToSTE(code, ip);
-            Con::printf("%i: OP_SETCURFIELD_THIS field=%s", ip - 1, curField);
-            ip += 2;
-            break;
-         }
-
-         case OP_SETCURFIELD_TYPE:
-         {
-            U32 type = code[ip];
-            Con::printf("%i: OP_SETCURFIELD_TYPE type=%i", ip - 1, type);
-            ++ip;
-            break;
-         }
-
-         case OP_LOADFIELD_UINT:
-         {
-            Con::printf("%i: OP_LOADFIELD_UINT", ip - 1);
-            break;
-         }
-
-         case OP_LOADFIELD_FLT:
-         {
-            Con::printf("%i: OP_LOADFIELD_FLT", ip - 1);
-            break;
-         }
-
-         case OP_LOADFIELD_STR:
-         {
-            Con::printf("%i: OP_LOADFIELD_STR", ip - 1);
-            break;
-         }
-
-         case OP_SAVEFIELD_UINT:
-         {
-            Con::printf("%i: OP_SAVEFIELD_UINT", ip - 1);
-            break;
-         }
-
-         case OP_SAVEFIELD_FLT:
-         {
-            Con::printf("%i: OP_SAVEFIELD_FLT", ip - 1);
-            break;
-         }
-
-         case OP_SAVEFIELD_STR:
-         {
-            Con::printf("%i: OP_SAVEFIELD_STR", ip - 1);
-            break;
-         }
-
-         case OP_STR_TO_UINT:
-         {
-            Con::printf("%i: OP_STR_TO_UINT", ip - 1);
-            break;
-         }
-
-         case OP_STR_TO_FLT:
-         {
-            Con::printf("%i: OP_STR_TO_FLT", ip - 1);
-            break;
-         }
-
-         case OP_STR_TO_NONE:
-         {
-            Con::printf("%i: OP_STR_TO_NONE", ip - 1);
-            break;
-         }
-
-         case OP_FLT_TO_UINT:
-         {
-            Con::printf("%i: OP_FLT_TO_UINT", ip - 1);
-            break;
-         }
-
-         case OP_FLT_TO_STR:
-         {
-            Con::printf("%i: OP_FLT_TO_STR", ip - 1);
-            break;
-         }
-
-         case OP_FLT_TO_NONE:
-         {
-            Con::printf("%i: OP_FLT_TO_NONE", ip - 1);
-            break;
-         }
-
-         case OP_UINT_TO_FLT:
-         {
-            Con::printf("%i: OP_SAVEFIELD_STR", ip - 1);
-            break;
-         }
-
-         case OP_UINT_TO_STR:
-         {
-            Con::printf("%i: OP_UINT_TO_STR", ip - 1);
-            break;
-         }
-
-         case OP_UINT_TO_NONE:
-         {
-            Con::printf("%i: OP_UINT_TO_NONE", ip - 1);
-            break;
-         }
-
-         case OP_COPYVAR_TO_NONE:
-         {
-            Con::printf("%i: OP_COPYVAR_TO_NONE", ip - 1);
-            break;
-         }
-
-         case OP_LOADIMMED_UINT:
-         {
-            U32 val = code[ip];
-            Con::printf("%i: OP_LOADIMMED_UINT val=%i", ip - 1, val);
-            ++ip;
-            break;
-         }
-
-         case OP_LOADIMMED_FLT:
-         {
-            F64 val = (smInFunction ? functionFloats : globalFloats)[code[ip]];
-            Con::printf("%i: OP_LOADIMMED_FLT val=%f", ip - 1, val);
-            ++ip;
-            break;
-         }
-
-         case OP_TAG_TO_STR:
-         {
-            const char* str = (smInFunction ? functionStrings : globalStrings) + code[ip];
-            Con::printf("%i: OP_TAG_TO_STR str=%s", ip - 1, str);
-            ++ip;
-            break;
-         }
-
-         case OP_LOADIMMED_STR:
-         {
-            const char* str = (smInFunction ? functionStrings : globalStrings) + code[ip];
-            Con::printf("%i: OP_LOADIMMED_STR str=%s", ip - 1, str);
-            ++ip;
-            break;
-         }
-
-         case OP_DOCBLOCK_STR:
-         {
-            const char* str = (smInFunction ? functionStrings : globalStrings) + code[ip];
-            Con::printf("%i: OP_DOCBLOCK_STR str=%s", ip - 1, str);
-            ++ip;
-            break;
-         }
-
-         case OP_LOADIMMED_IDENT:
-         {
-            StringTableEntry str = CodeToSTE(code, ip);
-            Con::printf("%i: OP_LOADIMMED_IDENT str=%s", ip - 1, str);
-            ip += 2;
-            break;
-         }
-
-         case OP_CALLFUNC_RESOLVE:
-         {
-            StringTableEntry fnNamespace = CodeToSTE(code, ip + 2);
-            StringTableEntry fnName = CodeToSTE(code, ip);
-            U32 callType = code[ip + 2];
-
-            Con::printf("%i: OP_CALLFUNC_RESOLVE name=%s nspace=%s callType=%s", ip - 1, fnName, fnNamespace,
-               callType == FuncCallExprNode::FunctionCall ? "FunctionCall"
-               : callType == FuncCallExprNode::MethodCall ? "MethodCall" : "ParentCall");
-
-            ip += 5;
-            break;
-         }
-
-         case OP_CALLFUNC:
-         {
-            StringTableEntry fnNamespace = CodeToSTE(code, ip + 2);
-            StringTableEntry fnName = CodeToSTE(code, ip);
-            U32 callType = code[ip + 4];
-
-            Con::printf("%i: OP_CALLFUNC name=%s nspace=%s callType=%s", ip - 1, fnName, fnNamespace,
-               callType == FuncCallExprNode::FunctionCall ? "FunctionCall"
-               : callType == FuncCallExprNode::MethodCall ? "MethodCall" : "ParentCall");
-
-            ip += 5;
-            break;
-         }
-
-         case OP_CALLFUNC_POINTER:
-         {
-            Con::printf("%i: OP_CALLFUNC_POINTER", ip - 1);
-            break;
-         }
-
-         case OP_CALLFUNC_THIS:
-         {
-            StringTableEntry fnName = CodeToSTE(code, ip);
-            Con::printf("%i: OP_CALLFUNC_THIS name=%s ", ip - 1, fnName);
-
-            ip += 2;
-            break;
-         }
-
-         case OP_ADVANCE_STR:
-         {
-            Con::printf("%i: OP_ADVANCE_STR", ip - 1);
-            break;
-         }
-
-         case OP_ADVANCE_STR_APPENDCHAR:
-         {
-            char ch = code[ip];
-            Con::printf("%i: OP_ADVANCE_STR_APPENDCHAR char=%c", ip - 1, ch);
-            ++ip;
-            break;
-         }
-
-         case OP_ADVANCE_STR_COMMA:
-         {
-            Con::printf("%i: OP_ADVANCE_STR_COMMA", ip - 1);
-            break;
-         }
-
-         case OP_ADVANCE_STR_NUL:
-         {
-            Con::printf("%i: OP_ADVANCE_STR_NUL", ip - 1);
-            break;
-         }
-
-         case OP_REWIND_STR:
-         {
-            Con::printf("%i: OP_REWIND_STR", ip - 1);
-            break;
-         }
-
-         case OP_TERMINATE_REWIND_STR:
-         {
-            Con::printf("%i: OP_TERMINATE_REWIND_STR", ip - 1);
-            break;
-         }
-
-         case OP_COMPARE_STR:
-         {
-            Con::printf("%i: OP_COMPARE_STR", ip - 1);
-            break;
-         }
-
-         case OP_PUSH:
-         {
-            Con::printf("%i: OP_PUSH", ip - 1);
-            break;
-         }
-
-         case OP_PUSH_UINT:
-         {
-            Con::printf("%i: OP_PUSH_UINT", ip - 1);
-            break;
-         }
-
-         case OP_PUSH_FLT:
-         {
-            Con::printf("%i: OP_PUSH_FLT", ip - 1);
-            break;
-         }
-
-         case OP_PUSH_VAR:
-         {
-            Con::printf("%i: OP_PUSH_VAR", ip - 1);
-            break;
-         }
-
-         case OP_PUSH_THIS:
-         {
-            Con::printf("%i: OP_PUSH_THIS varName=%s", ip - 1, CodeToSTE(code, ip));
-            ip += 2;
-            break;
-         }
-
-         case OP_PUSH_FRAME:
-         {
-            Con::printf("%i: OP_PUSH_FRAME", ip - 1);
-            break;
-         }
-
-         case OP_ASSERT:
-         {
-            const char* message = (smInFunction ? functionStrings : globalStrings) + code[ip];
-            Con::printf("%i: OP_ASSERT message=%s", ip - 1, message);
-            ++ip;
-            break;
-         }
-
-         case OP_BREAK:
-         {
-            Con::printf("%i: OP_BREAK", ip - 1);
-            break;
-         }
-
-         case OP_ITER_BEGIN:
-         {
-            StringTableEntry varName = CodeToSTE(code, ip);
-            U32 failIp = code[ip + 2];
-
-            Con::printf("%i: OP_ITER_BEGIN varName=%s failIp=%i", ip - 1, varName, failIp);
-
-            ip += 3;
-            break;
-         }
-
-         case OP_ITER_BEGIN_STR:
-         {
-            StringTableEntry varName = CodeToSTE(code, ip);
-            U32 failIp = code[ip + 2];
-
-            Con::printf("%i: OP_ITER_BEGIN varName=%s failIp=%i", ip - 1, varName, failIp);
-
-            ip += 3;
-            break;
-         }
-
-         case OP_ITER:
-         {
-            U32 breakIp = code[ip];
-
-            Con::printf("%i: OP_ITER breakIp=%i", ip - 1, breakIp);
-
-            ++ip;
-            break;
-         }
-
-         case OP_ITER_END:
-         {
-            Con::printf("%i: OP_ITER_END", ip - 1);
-            break;
-         }
-
-         default:
-            Con::printf("%i: !!INVALID!!", ip - 1);
-            break;
+      case OP_FUNC_DECL:
+      {
+         StringTableEntry fnName = CodeToSTE(code, ip);
+         StringTableEntry fnNamespace = CodeToSTE(code, ip + 2);
+         StringTableEntry fnPackage = CodeToSTE(code, ip + 4);
+         bool hasBody = bool(code[ip + 6]);
+         U32 newIp = code[ip + 7];
+         U32 argc = code[ip + 8];
+         U32 regCount = code[ip + 9];
+         endFuncIp = newIp;
+
+         Con::printf("%i: OP_FUNC_DECL name=%s nspace=%s package=%s hasbody=%i newip=%i argc=%i regCount=%i",
+            ip - 1, fnName, fnNamespace, fnPackage, hasBody, newIp, argc, regCount);
+
+         // Skip args.
+
+         ip += 10 + argc;
+         smInFunction = true;
+         break;
+      }
+
+      case OP_CREATE_OBJECT:
+      {
+         StringTableEntry objParent = CodeToSTE(code, ip);
+         bool isDataBlock = code[ip + 2];
+         bool isInternal = code[ip + 3];
+         bool isSingleton = code[ip + 4];
+         U32  lineNumber = code[ip + 5];
+         U32 failJump = code[ip + 6];
+
+         Con::printf("%i: OP_CREATE_OBJECT objParent=%s isDataBlock=%i isInternal=%i isSingleton=%i lineNumber=%i failJump=%i",
+            ip - 1, objParent, isDataBlock, isInternal, isSingleton, lineNumber, failJump);
+
+         ip += 7;
+         break;
+      }
+
+      case OP_ADD_OBJECT:
+      {
+         bool placeAtRoot = code[ip++];
+         Con::printf("%i: OP_ADD_OBJECT placeAtRoot=%i", ip - 1, placeAtRoot);
+         break;
+      }
+
+      case OP_END_OBJECT:
+      {
+         bool placeAtRoot = code[ip++];
+         Con::printf("%i: OP_END_OBJECT placeAtRoot=%i", ip - 1, placeAtRoot);
+         break;
+      }
+
+      case OP_FINISH_OBJECT:
+      {
+         Con::printf("%i: OP_FINISH_OBJECT", ip - 1);
+         break;
+      }
+
+      case OP_JMPIFFNOT:
+      {
+         Con::printf("%i: OP_JMPIFFNOT ip=%i", ip - 1, code[ip]);
+         ++ip;
+         break;
+      }
+
+      case OP_JMPIFNOT:
+      {
+         Con::printf("%i: OP_JMPIFNOT ip=%i", ip - 1, code[ip]);
+         ++ip;
+         break;
+      }
+
+      case OP_JMPIFF:
+      {
+         Con::printf("%i: OP_JMPIFF ip=%i", ip - 1, code[ip]);
+         ++ip;
+         break;
+      }
+
+      case OP_JMPIF:
+      {
+         Con::printf("%i: OP_JMPIF ip=%i", ip - 1, code[ip]);
+         ++ip;
+         break;
+      }
+
+      case OP_JMPIFNOT_NP:
+      {
+         Con::printf("%i: OP_JMPIFNOT_NP ip=%i", ip - 1, code[ip]);
+         ++ip;
+         break;
+      }
+
+      case OP_JMPIF_NP:
+      {
+         Con::printf("%i: OP_JMPIF_NP ip=%i", ip - 1, code[ip]);
+         ++ip;
+         break;
+      }
+
+      case OP_JMP:
+      {
+         Con::printf("%i: OP_JMP ip=%i", ip - 1, code[ip]);
+         ++ip;
+         break;
+      }
+
+      case OP_RETURN:
+      {
+         Con::printf("%i: OP_RETURN", ip - 1);
+
+         if (upToReturn)
+            return;
+
+         break;
+      }
+
+      case OP_RETURN_VOID:
+      {
+         Con::printf("%i: OP_RETURNVOID", ip - 1);
+
+         if (upToReturn)
+            return;
+
+         break;
+      }
+
+      case OP_RETURN_UINT:
+      {
+         Con::printf("%i: OP_RETURNUINT", ip - 1);
+
+         if (upToReturn)
+            return;
+
+         break;
+      }
+
+      case OP_RETURN_FLT:
+      {
+         Con::printf("%i: OP_RETURNFLT", ip - 1);
+
+         if (upToReturn)
+            return;
+
+         break;
+      }
+
+      case OP_CMPEQ:
+      {
+         Con::printf("%i: OP_CMPEQ", ip - 1);
+         break;
+      }
+
+      case OP_CMPGR:
+      {
+         Con::printf("%i: OP_CMPGR", ip - 1);
+         break;
+      }
+
+      case OP_CMPGE:
+      {
+         Con::printf("%i: OP_CMPGE", ip - 1);
+         break;
+      }
+
+      case OP_CMPLT:
+      {
+         Con::printf("%i: OP_CMPLT", ip - 1);
+         break;
+      }
+
+      case OP_CMPLE:
+      {
+         Con::printf("%i: OP_CMPLE", ip - 1);
+         break;
+      }
+
+      case OP_CMPNE:
+      {
+         Con::printf("%i: OP_CMPNE", ip - 1);
+         break;
+      }
+
+      case OP_XOR:
+      {
+         Con::printf("%i: OP_XOR", ip - 1);
+         break;
+      }
+
+      case OP_MOD:
+      {
+         Con::printf("%i: OP_MOD", ip - 1);
+         break;
+      }
+
+      case OP_BITAND:
+      {
+         Con::printf("%i: OP_BITAND", ip - 1);
+         break;
+      }
+
+      case OP_BITOR:
+      {
+         Con::printf("%i: OP_BITOR", ip - 1);
+         break;
+      }
+
+      case OP_NOT:
+      {
+         Con::printf("%i: OP_NOT", ip - 1);
+         break;
+      }
+
+      case OP_NOTF:
+      {
+         Con::printf("%i: OP_NOTF", ip - 1);
+         break;
+      }
+
+      case OP_ONESCOMPLEMENT:
+      {
+         Con::printf("%i: OP_ONESCOMPLEMENT", ip - 1);
+         break;
+      }
+
+      case OP_SHR:
+      {
+         Con::printf("%i: OP_SHR", ip - 1);
+         break;
+      }
+
+      case OP_SHL:
+      {
+         Con::printf("%i: OP_SHL", ip - 1);
+         break;
+      }
+
+      case OP_AND:
+      {
+         Con::printf("%i: OP_AND", ip - 1);
+         break;
+      }
+
+      case OP_OR:
+      {
+         Con::printf("%i: OP_OR", ip - 1);
+         break;
+      }
+
+      case OP_ADD:
+      {
+         Con::printf("%i: OP_ADD", ip - 1);
+         break;
+      }
+
+      case OP_SUB:
+      {
+         Con::printf("%i: OP_SUB", ip - 1);
+         break;
+      }
+
+      case OP_MUL:
+      {
+         Con::printf("%i: OP_MUL", ip - 1);
+         break;
+      }
+
+      case OP_DIV:
+      {
+         Con::printf("%i: OP_DIV", ip - 1);
+         break;
+      }
+
+      case OP_NEG:
+      {
+         Con::printf("%i: OP_NEG", ip - 1);
+         break;
+      }
+
+      case OP_INC:
+      {
+         Con::printf("%i: OP_INC reg=%i", ip - 1, code[ip]);
+         ++ip;
+         break;
+      }
+
+      case OP_SETCURVAR:
+      {
+         StringTableEntry var = CodeToSTE(code, ip);
+
+         Con::printf("%i: OP_SETCURVAR var=%s", ip - 1, var);
+         ip += 2;
+         break;
+      }
+
+      case OP_SETCURVAR_CREATE:
+      {
+         StringTableEntry var = CodeToSTE(code, ip);
+
+         Con::printf("%i: OP_SETCURVAR_CREATE var=%s", ip - 1, var);
+         ip += 2;
+         break;
+      }
+
+      case OP_SETCURVAR_ARRAY:
+      {
+         Con::printf("%i: OP_SETCURVAR_ARRAY", ip - 1);
+         break;
+      }
+
+      case OP_SETCURVAR_ARRAY_CREATE:
+      {
+         Con::printf("%i: OP_SETCURVAR_ARRAY_CREATE", ip - 1);
+         break;
+      }
+
+      case OP_LOADVAR_UINT:
+      {
+         Con::printf("%i: OP_LOADVAR_UINT", ip - 1);
+         break;
+      }
+
+      case OP_LOADVAR_FLT:
+      {
+         Con::printf("%i: OP_LOADVAR_FLT", ip - 1);
+         break;
+      }
+
+      case OP_LOADVAR_STR:
+      {
+         Con::printf("%i: OP_LOADVAR_STR", ip - 1);
+         break;
+      }
+
+      case OP_SAVEVAR_UINT:
+      {
+         Con::printf("%i: OP_SAVEVAR_UINT", ip - 1);
+         break;
+      }
+
+      case OP_SAVEVAR_FLT:
+      {
+         Con::printf("%i: OP_SAVEVAR_FLT", ip - 1);
+         break;
+      }
+
+      case OP_SAVEVAR_STR:
+      {
+         Con::printf("%i: OP_SAVEVAR_STR", ip - 1);
+         break;
+      }
+
+      case OP_LOAD_LOCAL_VAR_UINT:
+      {
+         Con::printf("%i: OP_LOAD_LOCAL_VAR_UINT reg=%i", ip - 1, code[ip]);
+         ++ip;
+         break;
+      }
+
+      case OP_LOAD_LOCAL_VAR_FLT:
+      {
+         Con::printf("%i: OP_LOAD_LOCAL_VAR_FLT reg=%i", ip - 1, code[ip]);
+         ++ip;
+         break;
+      }
+
+      case OP_LOAD_LOCAL_VAR_STR:
+      {
+         Con::printf("%i: OP_LOAD_LOCAL_VAR_STR reg=%i", ip - 1, code[ip]);
+         ++ip;
+         break;
+      }
+
+      case OP_SAVE_LOCAL_VAR_UINT:
+      {
+         Con::printf("%i: OP_SAVE_LOCAL_VAR_UINT reg=%i", ip - 1, code[ip]);
+         ++ip;
+         break;
+      }
+
+      case OP_SAVE_LOCAL_VAR_FLT:
+      {
+         Con::printf("%i: OP_SAVE_LOCAL_VAR_FLT reg=%i", ip - 1, code[ip]);
+         ++ip;
+         break;
+      }
+
+      case OP_SAVE_LOCAL_VAR_STR:
+      {
+         Con::printf("%i: OP_SAVE_LOCAL_VAR_STR reg=%i", ip - 1, code[ip]);
+         ++ip;
+         break;
+      }
+
+      case OP_SETCUROBJECT:
+      {
+         Con::printf("%i: OP_SETCUROBJECT", ip - 1);
+         break;
+      }
+
+      case OP_SETCUROBJECT_NEW:
+      {
+         Con::printf("%i: OP_SETCUROBJECT_NEW", ip - 1);
+         break;
+      }
+
+      case OP_SETCUROBJECT_INTERNAL:
+      {
+         Con::printf("%i: OP_SETCUROBJECT_INTERNAL", ip - 1);
+         ++ip;
+         break;
+      }
+
+      case OP_SETCURFIELD:
+      {
+         StringTableEntry curField = CodeToSTE(code, ip);
+         Con::printf("%i: OP_SETCURFIELD field=%s", ip - 1, curField);
+         ip += 2;
+         break;
+      }
+
+      case OP_SETCURFIELD_ARRAY:
+      {
+         Con::printf("%i: OP_SETCURFIELD_ARRAY", ip - 1);
+         break;
+      }
+
+      case OP_SETCURFIELD_TYPE:
+      {
+         U32 type = code[ip];
+         Con::printf("%i: OP_SETCURFIELD_TYPE type=%i", ip - 1, type);
+         ++ip;
+         break;
+      }
+
+      case OP_LOADFIELD_UINT:
+      {
+         Con::printf("%i: OP_LOADFIELD_UINT", ip - 1);
+         break;
+      }
+
+      case OP_LOADFIELD_FLT:
+      {
+         Con::printf("%i: OP_LOADFIELD_FLT", ip - 1);
+         break;
+      }
+
+      case OP_LOADFIELD_STR:
+      {
+         Con::printf("%i: OP_LOADFIELD_STR", ip - 1);
+         break;
+      }
+
+      case OP_SAVEFIELD_UINT:
+      {
+         Con::printf("%i: OP_SAVEFIELD_UINT", ip - 1);
+         break;
+      }
+
+      case OP_SAVEFIELD_FLT:
+      {
+         Con::printf("%i: OP_SAVEFIELD_FLT", ip - 1);
+         break;
+      }
+
+      case OP_SAVEFIELD_STR:
+      {
+         Con::printf("%i: OP_SAVEFIELD_STR", ip - 1);
+         break;
+      }
+
+      case OP_STR_TO_UINT:
+      {
+         Con::printf("%i: OP_STR_TO_UINT", ip - 1);
+         break;
+      }
+
+      case OP_STR_TO_FLT:
+      {
+         Con::printf("%i: OP_STR_TO_FLT", ip - 1);
+         break;
+      }
+
+      case OP_STR_TO_NONE:
+      {
+         Con::printf("%i: OP_STR_TO_NONE", ip - 1);
+         break;
+      }
+
+      case OP_FLT_TO_UINT:
+      {
+         Con::printf("%i: OP_FLT_TO_UINT", ip - 1);
+         break;
+      }
+
+      case OP_FLT_TO_STR:
+      {
+         Con::printf("%i: OP_FLT_TO_STR", ip - 1);
+         break;
+      }
+
+      case OP_FLT_TO_NONE:
+      {
+         Con::printf("%i: OP_FLT_TO_NONE", ip - 1);
+         break;
+      }
+
+      case OP_UINT_TO_FLT:
+      {
+         Con::printf("%i: OP_UINT_TO_FLT", ip - 1);
+         break;
+      }
+
+      case OP_UINT_TO_STR:
+      {
+         Con::printf("%i: OP_UINT_TO_STR", ip - 1);
+         break;
+      }
+
+      case OP_UINT_TO_NONE:
+      {
+         Con::printf("%i: OP_UINT_TO_NONE", ip - 1);
+         break;
+      }
+
+      case OP_LOADIMMED_UINT:
+      {
+         U32 val = code[ip];
+         Con::printf("%i: OP_LOADIMMED_UINT val=%i", ip - 1, val);
+         ++ip;
+         break;
+      }
+
+      case OP_LOADIMMED_FLT:
+      {
+         F64 val = (smInFunction ? functionFloats : globalFloats)[code[ip]];
+         Con::printf("%i: OP_LOADIMMED_FLT val=%f", ip - 1, val);
+         ++ip;
+         break;
+      }
+
+      case OP_TAG_TO_STR:
+      {
+         const char* str = (smInFunction ? functionStrings : globalStrings) + code[ip];
+         Con::printf("%i: OP_TAG_TO_STR str=%s", ip - 1, str);
+         ++ip;
+         break;
+      }
+
+      case OP_LOADIMMED_STR:
+      {
+         const char* str = (smInFunction ? functionStrings : globalStrings) + code[ip];
+         Con::printf("%i: OP_LOADIMMED_STR str=%s", ip - 1, str);
+         ++ip;
+         break;
+      }
+
+      case OP_DOCBLOCK_STR:
+      {
+         const char* str = (smInFunction ? functionStrings : globalStrings) + code[ip];
+         Con::printf("%i: OP_DOCBLOCK_STR str=%s", ip - 1, str);
+         ++ip;
+         break;
+      }
+
+      case OP_LOADIMMED_IDENT:
+      {
+         StringTableEntry str = CodeToSTE(code, ip);
+         Con::printf("%i: OP_LOADIMMED_IDENT str=%s", ip - 1, str);
+         ip += 2;
+         break;
+      }
+
+      case OP_CALLFUNC:
+      {
+         StringTableEntry fnNamespace = CodeToSTE(code, ip + 2);
+         StringTableEntry fnName = CodeToSTE(code, ip);
+         U32 callType = code[ip + 4];
+
+         StringTableEntry callTypeName;
+         switch (callType)
+         {
+         case FuncCallExprNode::FunctionCall: callTypeName = "FunctionCall"; break;
+         case FuncCallExprNode::MethodCall:   callTypeName = "MethodCall"; break;
+         case FuncCallExprNode::ParentCall:   callTypeName = "ParentCall"; break;
+         case FuncCallExprNode::StaticCall:   callTypeName = "StaticCall"; break;
+         }
+
+         Con::printf("%i: OP_CALLFUNC name=%s nspace=%s callType=%s", ip - 1, fnName, fnNamespace, callTypeName);
+
+         ip += 5;
+         break;
+      }
+
+      case OP_ADVANCE_STR:
+      {
+         Con::printf("%i: OP_ADVANCE_STR", ip - 1);
+         break;
+      }
+
+      case OP_ADVANCE_STR_APPENDCHAR:
+      {
+         char ch = code[ip];
+         Con::printf("%i: OP_ADVANCE_STR_APPENDCHAR char=%c", ip - 1, ch);
+         ++ip;
+         break;
+      }
+
+      case OP_ADVANCE_STR_COMMA:
+      {
+         Con::printf("%i: OP_ADVANCE_STR_COMMA", ip - 1);
+         break;
+      }
+
+      case OP_ADVANCE_STR_NUL:
+      {
+         Con::printf("%i: OP_ADVANCE_STR_NUL", ip - 1);
+         break;
+      }
+
+      case OP_REWIND_STR:
+      {
+         Con::printf("%i: OP_REWIND_STR", ip - 1);
+         break;
+      }
+
+      case OP_TERMINATE_REWIND_STR:
+      {
+         Con::printf("%i: OP_TERMINATE_REWIND_STR", ip - 1);
+         break;
+      }
+
+      case OP_COMPARE_STR:
+      {
+         Con::printf("%i: OP_COMPARE_STR", ip - 1);
+         break;
+      }
+
+      case OP_PUSH:
+      {
+         Con::printf("%i: OP_PUSH", ip - 1);
+         break;
+      }
+
+      case OP_PUSH_UINT:
+      {
+         Con::printf("%i: OP_PUSH_UINT", ip - 1);
+         break;
+      }
+
+      case OP_PUSH_FLT:
+      {
+         Con::printf("%i: OP_PUSH_FLT", ip - 1);
+         break;
+      }
+
+      case OP_PUSH_FRAME:
+      {
+         Con::printf("%i: OP_PUSH_FRAME count=%i", ip - 1, code[ip]);
+         ++ip;
+         break;
+      }
+
+      case OP_ASSERT:
+      {
+         const char* message = (smInFunction ? functionStrings : globalStrings) + code[ip];
+         Con::printf("%i: OP_ASSERT message=%s", ip - 1, message);
+         ++ip;
+         break;
+      }
+
+      case OP_BREAK:
+      {
+         Con::printf("%i: OP_BREAK", ip - 1);
+         break;
+      }
+
+      case OP_ITER_BEGIN:
+      {
+         StringTableEntry varName = CodeToSTE(code, ip);
+         U32 failIp = code[ip + 2];
+
+         Con::printf("%i: OP_ITER_BEGIN varName=%s failIp=%i", ip - 1, varName, failIp);
+
+         ip += 3;
+         break;
+      }
+
+      case OP_ITER_BEGIN_STR:
+      {
+         StringTableEntry varName = CodeToSTE(code, ip);
+         U32 failIp = code[ip + 2];
+
+         Con::printf("%i: OP_ITER_BEGIN varName=%s failIp=%i", ip - 1, varName, failIp);
+
+         ip += 3;
+         break;
+      }
+
+      case OP_ITER:
+      {
+         U32 breakIp = code[ip];
+
+         Con::printf("%i: OP_ITER breakIp=%i", ip - 1, breakIp);
+
+         ++ip;
+         break;
+      }
+
+      case OP_ITER_END:
+      {
+         Con::printf("%i: OP_ITER_END", ip - 1);
+         break;
+      }
+
+      default:
+         Con::printf("%i: !!INVALID!!", ip - 1);
+         break;
       }
    }
 
diff --git a/Engine/source/console/codeInterpreter.cpp b/Engine/source/console/codeInterpreter.cpp
deleted file mode 100644
index 614eb8fec..000000000
--- a/Engine/source/console/codeInterpreter.cpp
+++ /dev/null
@@ -1,3018 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//
-// Arcane-FX for MIT Licensed Open Source version of Torque 3D from GarageGames
-// Copyright (C) 2015 Faust Logic, Inc.
-//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//
-
-#include "console/codeInterpreter.h"
-#include "console/compiler.h"
-#include "console/simBase.h"
-#include "console/telnetDebugger.h"
-#include "sim/netStringTable.h"
-#include "console/ICallMethod.h"
-#include "console/stringStack.h"
-#include "util/messaging/message.h"
-#include "core/strings/findMatch.h"
-#include "core/strings/stringUnit.h"
-#include "console/console.h"
-#include "console/consoleInternal.h"
-#include "cinterface/cinterface.h"
-
-//#define TORQUE_VALIDATE_STACK
-
-using namespace Compiler;
-
-enum EvalConstants
-{
-   MaxStackSize = 1024,
-   FieldBufferSizeString = 2048,
-   FieldBufferSizeNumeric = 128,
-   MethodOnComponent = -2
-};
-
-namespace Con
-{
-   // Current script file name and root, these are registered as
-   // console variables.
-   extern StringTableEntry gCurrentFile;
-   extern StringTableEntry gCurrentRoot;
-   extern S32 gObjectCopyFailures;
-}
-
-// Gets a component of an object's field value or a variable and returns it
-// in val.
-static void getFieldComponent(SimObject* object, StringTableEntry field, const char* array, StringTableEntry subField, char val[])
-{
-   const char* prevVal = NULL;
-
-   // Grab value from object.
-   if (object && field)
-      prevVal = object->getDataField(field, array);
-
-   // Otherwise, grab from the string stack. The value coming in will always
-   // be a string because that is how multicomponent variables are handled.
-   else
-      prevVal = STR.getStringValue();
-
-   // Make sure we got a value.
-   if (prevVal && *prevVal)
-   {
-      static const StringTableEntry xyzw[] =
-      {
-         StringTable->insert("x"),
-         StringTable->insert("y"),
-         StringTable->insert("z"),
-         StringTable->insert("w")
-      };
-
-      static const StringTableEntry rgba[] =
-      {
-         StringTable->insert("r"),
-         StringTable->insert("g"),
-         StringTable->insert("b"),
-         StringTable->insert("a")
-      };
-
-      // Translate xyzw and rgba into the indexed component 
-      // of the variable or field.
-      if (subField == xyzw[0] || subField == rgba[0])
-         dStrcpy(val, StringUnit::getUnit(prevVal, 0, " \t\n"), 128);
-
-      else if (subField == xyzw[1] || subField == rgba[1])
-         dStrcpy(val, StringUnit::getUnit(prevVal, 1, " \t\n"), 128);
-
-      else if (subField == xyzw[2] || subField == rgba[2])
-         dStrcpy(val, StringUnit::getUnit(prevVal, 2, " \t\n"), 128);
-
-      else if (subField == xyzw[3] || subField == rgba[3])
-         dStrcpy(val, StringUnit::getUnit(prevVal, 3, " \t\n"), 128);
-
-      else
-         val[0] = 0;
-   }
-   else
-      val[0] = 0;
-}
-
-// Sets a component of an object's field value based on the sub field. 'x' will
-// set the first field, 'y' the second, and 'z' the third.
-static void setFieldComponent(SimObject* object, StringTableEntry field, const char* array, StringTableEntry subField)
-{
-   // Copy the current string value
-   char strValue[1024];
-   dStrncpy(strValue, STR.getStringValue(), 1024);
-
-   char val[1024] = "";
-   const char* prevVal = NULL;
-
-   // Set the value on an object field.
-   if (object && field)
-      prevVal = object->getDataField(field, array);
-
-   // Set the value on a variable.
-   else if (gEvalState.currentVariable)
-      prevVal = gEvalState.getStringVariable();
-
-   // Ensure that the variable has a value
-   if (!prevVal)
-      return;
-
-   static const StringTableEntry xyzw[] =
-   {
-      StringTable->insert("x"),
-      StringTable->insert("y"),
-      StringTable->insert("z"),
-      StringTable->insert("w")
-   };
-
-   static const StringTableEntry rgba[] =
-   {
-      StringTable->insert("r"),
-      StringTable->insert("g"),
-      StringTable->insert("b"),
-      StringTable->insert("a")
-   };
-
-   // Insert the value into the specified 
-   // component of the string.
-   if (subField == xyzw[0] || subField == rgba[0])
-      dStrcpy(val, StringUnit::setUnit(prevVal, 0, strValue, " \t\n"), 128);
-
-   else if (subField == xyzw[1] || subField == rgba[1])
-      dStrcpy(val, StringUnit::setUnit(prevVal, 1, strValue, " \t\n"), 128);
-
-   else if (subField == xyzw[2] || subField == rgba[2])
-      dStrcpy(val, StringUnit::setUnit(prevVal, 2, strValue, " \t\n"), 128);
-
-   else if (subField == xyzw[3] || subField == rgba[3])
-      dStrcpy(val, StringUnit::setUnit(prevVal, 3, strValue, " \t\n"), 128);
-
-   if (val[0] != 0)
-   {
-      // Update the field or variable.
-      if (object && field)
-         object->setDataField(field, 0, val);
-      else if (gEvalState.currentVariable)
-         gEvalState.setStringVariable(val);
-   }
-}
-extern ExprEvalState gEvalState;
-
-char sTraceBuffer[1024];
-
-StringStack STR;
-ConsoleValueStack CSTK;
-
-U32 _FLT = 0;     ///< Stack pointer for floatStack.
-U32 _UINT = 0;    ///< Stack pointer for intStack.
-U32 _ITER = 0;    ///< Stack pointer for iterStack.
-
-IterStackRecord iterStack[MaxStackSize];
-
-F64 floatStack[MaxStackSize];
-S64 intStack[MaxStackSize];
-
-char curFieldArray[256];
-char prevFieldArray[256];
-
-typedef OPCodeReturn(CodeInterpreter::*OpFn)(U32&);
-
-static OpFn gOpCodeArray[MAX_OP_CODELEN];
-
-CodeInterpreter::CodeInterpreter(CodeBlock *cb) :
-   mCodeBlock(cb),
-   mIterDepth(0),
-   mCurFloatTable(nullptr),
-   mCurStringTable(nullptr),
-   mThisFunctionName(nullptr),
-   mPopFrame(false),
-   mObjectCreationStackIndex(0),
-   mCurrentNewObject(nullptr),
-   mFailJump(0),
-   mPrevField(nullptr),
-   mCurField(nullptr),
-   mPrevObject(nullptr),
-   mCurObject(nullptr),
-   mSaveObject(nullptr),
-   mThisObject(nullptr),
-   mNSEntry(nullptr),
-   mCurFNDocBlock(nullptr),
-   mCurNSDocBlock(nullptr),
-   mCallArgc(0),
-   mCallArgv(nullptr),
-   mSaveCodeBlock(nullptr),
-   mCurrentInstruction(0)
-{
-   dMemset(&mExec, 0, sizeof(mExec));
-   dMemset(&mObjectCreationStack, 0, sizeof(mObjectCreationStack));
-   dMemset(&mNSDocBlockClass, 0, sizeof(mNSDocBlockClass));
-}
-
-CodeInterpreter::~CodeInterpreter()
-{
-}
-
-void CodeInterpreter::init()
-{
-   gOpCodeArray[OP_FUNC_DECL] = &CodeInterpreter::op_func_decl;
-   gOpCodeArray[OP_CREATE_OBJECT] = &CodeInterpreter::op_create_object;
-   gOpCodeArray[OP_ADD_OBJECT] = &CodeInterpreter::op_add_object;
-   gOpCodeArray[OP_END_OBJECT] = &CodeInterpreter::op_end_object;
-   gOpCodeArray[OP_FINISH_OBJECT] = &CodeInterpreter::op_finish_object;
-   gOpCodeArray[OP_JMPIFFNOT] = &CodeInterpreter::op_jmpiffnot;
-   gOpCodeArray[OP_JMPIFNOT] = &CodeInterpreter::op_jmpifnot;
-   gOpCodeArray[OP_JMPIFF] = &CodeInterpreter::op_jmpiff;
-   gOpCodeArray[OP_JMPIF] = &CodeInterpreter::op_jmpif;
-   gOpCodeArray[OP_JMPIFNOT_NP] = &CodeInterpreter::op_jmpifnot_np;
-   gOpCodeArray[OP_JMPIF_NP] = &CodeInterpreter::op_jmpif_np;
-   gOpCodeArray[OP_JMP] = &CodeInterpreter::op_jmp;
-   gOpCodeArray[OP_RETURN] = &CodeInterpreter::op_return;
-   gOpCodeArray[OP_RETURN_VOID] = &CodeInterpreter::op_return_void;
-   gOpCodeArray[OP_RETURN_FLT] = &CodeInterpreter::op_return_flt;
-   gOpCodeArray[OP_RETURN_UINT] = &CodeInterpreter::op_return_uint;
-   gOpCodeArray[OP_CMPEQ] = &CodeInterpreter::op_cmpeq;
-   gOpCodeArray[OP_CMPGR] = &CodeInterpreter::op_cmpgr;
-   gOpCodeArray[OP_CMPGE] = &CodeInterpreter::op_cmpge;
-   gOpCodeArray[OP_CMPLT] = &CodeInterpreter::op_cmplt;
-   gOpCodeArray[OP_CMPLE] = &CodeInterpreter::op_cmple;
-   gOpCodeArray[OP_CMPNE] = &CodeInterpreter::op_cmpne;
-   gOpCodeArray[OP_XOR] = &CodeInterpreter::op_xor;
-   gOpCodeArray[OP_MOD] = &CodeInterpreter::op_mod;
-   gOpCodeArray[OP_BITAND] = &CodeInterpreter::op_bitand;
-   gOpCodeArray[OP_BITOR] = &CodeInterpreter::op_bitor;
-   gOpCodeArray[OP_NOT] = &CodeInterpreter::op_not;
-   gOpCodeArray[OP_NOTF] = &CodeInterpreter::op_notf;
-   gOpCodeArray[OP_ONESCOMPLEMENT] = &CodeInterpreter::op_onescomplement;
-   gOpCodeArray[OP_SHR] = &CodeInterpreter::op_shr;
-   gOpCodeArray[OP_SHL] = &CodeInterpreter::op_shl;
-   gOpCodeArray[OP_AND] = &CodeInterpreter::op_and;
-   gOpCodeArray[OP_OR] = &CodeInterpreter::op_or;
-   gOpCodeArray[OP_ADD] = &CodeInterpreter::op_add;
-   gOpCodeArray[OP_SUB] = &CodeInterpreter::op_sub;
-   gOpCodeArray[OP_MUL] = &CodeInterpreter::op_mul;
-   gOpCodeArray[OP_DIV] = &CodeInterpreter::op_div;
-   gOpCodeArray[OP_NEG] = &CodeInterpreter::op_neg;
-   gOpCodeArray[OP_INC] = &CodeInterpreter::op_inc;
-   gOpCodeArray[OP_DEC] = &CodeInterpreter::op_dec;
-   gOpCodeArray[OP_SETCURVAR] = &CodeInterpreter::op_setcurvar;
-   gOpCodeArray[OP_SETCURVAR_CREATE] = &CodeInterpreter::op_setcurvar_create;
-   gOpCodeArray[OP_SETCURVAR_ARRAY] = &CodeInterpreter::op_setcurvar_array;
-   gOpCodeArray[OP_SETCURVAR_ARRAY_VARLOOKUP] = &CodeInterpreter::op_setcurvar_array_varlookup;
-   gOpCodeArray[OP_SETCURVAR_ARRAY_CREATE] = &CodeInterpreter::op_setcurvar_array_create;
-   gOpCodeArray[OP_SETCURVAR_ARRAY_CREATE_VARLOOKUP] = &CodeInterpreter::op_setcurvar_array_create_varlookup;
-   gOpCodeArray[OP_LOADVAR_UINT] = &CodeInterpreter::op_loadvar_uint;
-   gOpCodeArray[OP_LOADVAR_FLT] = &CodeInterpreter::op_loadvar_flt;
-   gOpCodeArray[OP_LOADVAR_STR] = &CodeInterpreter::op_loadvar_str;
-   gOpCodeArray[OP_LOADVAR_VAR] = &CodeInterpreter::op_loadvar_var;
-   gOpCodeArray[OP_SAVEVAR_UINT] = &CodeInterpreter::op_savevar_uint;
-   gOpCodeArray[OP_SAVEVAR_FLT] = &CodeInterpreter::op_savevar_flt;
-   gOpCodeArray[OP_SAVEVAR_STR] = &CodeInterpreter::op_savevar_str;
-   gOpCodeArray[OP_SAVEVAR_VAR] = &CodeInterpreter::op_savevar_var;
-   gOpCodeArray[OP_SETCUROBJECT] = &CodeInterpreter::op_setcurobject;
-   gOpCodeArray[OP_SETCUROBJECT_INTERNAL] = &CodeInterpreter::op_setcurobject_internal;
-   gOpCodeArray[OP_SETCUROBJECT_NEW] = &CodeInterpreter::op_setcurobject_new;
-   gOpCodeArray[OP_SETCURFIELD] = &CodeInterpreter::op_setcurfield;
-   gOpCodeArray[OP_SETCURFIELD_ARRAY] = &CodeInterpreter::op_setcurfield_array;
-   gOpCodeArray[OP_SETCURFIELD_TYPE] = &CodeInterpreter::op_setcurfield_type;
-   gOpCodeArray[OP_SETCURFIELD_ARRAY_VAR] = &CodeInterpreter::op_setcurfield_array_var;
-   gOpCodeArray[OP_SETCURFIELD_THIS] = &CodeInterpreter::op_setcurfield_this;
-   gOpCodeArray[OP_LOADFIELD_UINT] = &CodeInterpreter::op_loadfield_uint;
-   gOpCodeArray[OP_LOADFIELD_FLT] = &CodeInterpreter::op_loadfield_flt;
-   gOpCodeArray[OP_LOADFIELD_STR] = &CodeInterpreter::op_loadfield_str;
-   gOpCodeArray[OP_SAVEFIELD_UINT] = &CodeInterpreter::op_savefield_uint;
-   gOpCodeArray[OP_SAVEFIELD_FLT] = &CodeInterpreter::op_savefield_flt;
-   gOpCodeArray[OP_SAVEFIELD_STR] = &CodeInterpreter::op_savefield_str;
-   gOpCodeArray[OP_STR_TO_UINT] = &CodeInterpreter::op_str_to_uint;
-   gOpCodeArray[OP_STR_TO_FLT] = &CodeInterpreter::op_str_to_flt;
-   gOpCodeArray[OP_STR_TO_NONE] = &CodeInterpreter::op_str_to_none;
-   gOpCodeArray[OP_FLT_TO_UINT] = &CodeInterpreter::op_flt_to_uint;
-   gOpCodeArray[OP_FLT_TO_STR] = &CodeInterpreter::op_flt_to_str;
-   gOpCodeArray[OP_FLT_TO_NONE] = &CodeInterpreter::op_flt_to_none;
-   gOpCodeArray[OP_UINT_TO_FLT] = &CodeInterpreter::op_uint_to_flt;
-   gOpCodeArray[OP_UINT_TO_STR] = &CodeInterpreter::op_uint_to_str;
-   gOpCodeArray[OP_UINT_TO_NONE] = &CodeInterpreter::op_uint_to_none;
-   gOpCodeArray[OP_COPYVAR_TO_NONE] = &CodeInterpreter::op_copyvar_to_none;
-   gOpCodeArray[OP_LOADIMMED_UINT] = &CodeInterpreter::op_loadimmed_uint;
-   gOpCodeArray[OP_LOADIMMED_FLT] = &CodeInterpreter::op_loadimmed_flt;
-   gOpCodeArray[OP_TAG_TO_STR] = &CodeInterpreter::op_tag_to_str;
-   gOpCodeArray[OP_LOADIMMED_STR] = &CodeInterpreter::op_loadimmed_str;
-   gOpCodeArray[OP_DOCBLOCK_STR] = &CodeInterpreter::op_docblock_str;
-   gOpCodeArray[OP_LOADIMMED_IDENT] = &CodeInterpreter::op_loadimmed_ident;
-   gOpCodeArray[OP_CALLFUNC_RESOLVE] = &CodeInterpreter::op_callfunc_resolve;
-   gOpCodeArray[OP_CALLFUNC] = &CodeInterpreter::op_callfunc;
-   gOpCodeArray[OP_CALLFUNC_POINTER] = &CodeInterpreter::op_callfunc_pointer;
-   gOpCodeArray[OP_CALLFUNC_THIS] = &CodeInterpreter::op_callfunc_this;
-   gOpCodeArray[OP_ADVANCE_STR] = &CodeInterpreter::op_advance_str;
-   gOpCodeArray[OP_ADVANCE_STR_APPENDCHAR] = &CodeInterpreter::op_advance_str_appendchar;
-   gOpCodeArray[OP_ADVANCE_STR_COMMA] = &CodeInterpreter::op_advance_str_comma;
-   gOpCodeArray[OP_ADVANCE_STR_NUL] = &CodeInterpreter::op_advance_str_nul;
-   gOpCodeArray[OP_REWIND_STR] = &CodeInterpreter::op_rewind_str;
-   gOpCodeArray[OP_TERMINATE_REWIND_STR] = &CodeInterpreter::op_terminate_rewind_str;
-   gOpCodeArray[OP_COMPARE_STR] = &CodeInterpreter::op_compare_str;
-   gOpCodeArray[OP_PUSH] = &CodeInterpreter::op_push;
-   gOpCodeArray[OP_PUSH_UINT] = &CodeInterpreter::op_push_uint;
-   gOpCodeArray[OP_PUSH_FLT] = &CodeInterpreter::op_push_flt;
-   gOpCodeArray[OP_PUSH_VAR] = &CodeInterpreter::op_push_var;
-   gOpCodeArray[OP_PUSH_THIS] = &CodeInterpreter::op_push_this;
-   gOpCodeArray[OP_PUSH_FRAME] = &CodeInterpreter::op_push_frame;
-   gOpCodeArray[OP_ASSERT] = &CodeInterpreter::op_assert;
-   gOpCodeArray[OP_BREAK] = &CodeInterpreter::op_break;
-   gOpCodeArray[OP_ITER_BEGIN_STR] = &CodeInterpreter::op_iter_begin_str;
-   gOpCodeArray[OP_ITER_BEGIN] = &CodeInterpreter::op_iter_begin;
-   gOpCodeArray[OP_ITER] = &CodeInterpreter::op_iter;
-   gOpCodeArray[OP_ITER_END] = &CodeInterpreter::op_iter_end;
-   gOpCodeArray[OP_INVALID] = &CodeInterpreter::op_invalid;
-}
-
-ConsoleValueRef CodeInterpreter::exec(U32 ip,
-                                      StringTableEntry functionName,
-                                      Namespace *thisNamespace,
-                                      U32 argc, 
-                                      ConsoleValueRef *argv,
-                                      bool noCalls,
-                                      StringTableEntry packageName,
-                                      S32 setFrame) 
-{
-   mExec.functionName = functionName;
-   mExec.thisNamespace = thisNamespace;
-   mExec.argc = argc;
-   mExec.argv = argv;
-   mExec.noCalls = noCalls;
-   mExec.packageName = packageName;
-   mExec.setFrame = setFrame;
-
-   mCodeBlock->incRefCount();
-
-   mPopFrame = false;
-
-#ifdef TORQUE_VALIDATE_STACK
-   U32 stackStart = STR.mStartStackSize;
-#endif
-
-   STR.clearFunctionOffset(); // ensures arg buffer offset is back to 0
-
-   // Lets load up our function arguments.
-   parseArgs(ip);
-
-   // Grab the state of the telenet debugger here once
-   // so that the push and pop frames are always balanced.
-   const bool telDebuggerOn = TelDebugger && TelDebugger->isConnected();
-   if (telDebuggerOn && setFrame < 0)
-      TelDebugger->pushStackFrame();
-
-   mSaveCodeBlock = CodeBlock::smCurrentCodeBlock;
-   CodeBlock::smCurrentCodeBlock = mCodeBlock;
-   if (mCodeBlock->name)
-   {
-      Con::gCurrentFile = mCodeBlock->name;
-      Con::gCurrentRoot = mCodeBlock->modPath;
-   }
-
-   U32 *code = mCodeBlock->code;
-
-   while (true)
-   {
-      mCurrentInstruction = code[ip++];
-      mNSEntry = nullptr;
-
-#ifdef TORQUE_VALIDATE_STACK
-      // OP Code check.
-      AssertFatal(mCurrentInstruction < MAX_OP_CODELEN, "Invalid OP code in script interpreter");
-#endif
-
-   breakContinueLabel:
-      OPCodeReturn ret = (this->*gOpCodeArray[mCurrentInstruction])(ip);
-      if (ret == OPCodeReturn::exitCode)
-         break;
-      else if (ret == OPCodeReturn::breakContinue)
-         goto breakContinueLabel;
-   }
-
-   if (telDebuggerOn && setFrame < 0)
-      TelDebugger->popStackFrame();
-
-   if (mPopFrame)
-      gEvalState.popFrame();
-
-   if (argv)
-   {
-      if (gEvalState.traceOn)
-      {
-         sTraceBuffer[0] = 0;
-         dStrcat(sTraceBuffer, "Leaving ", 1024);
-
-         if (packageName)
-         {
-            dStrcat(sTraceBuffer, "[", 1024);
-            dStrcat(sTraceBuffer, packageName, 1024);
-            dStrcat(sTraceBuffer, "]", 1024);
-         }
-         if (thisNamespace && thisNamespace->mName)
-         {
-            dSprintf(sTraceBuffer + dStrlen(sTraceBuffer), (U32)(sizeof(sTraceBuffer) - dStrlen(sTraceBuffer)),
-               "%s::%s() - return %s", thisNamespace->mName, mThisFunctionName, STR.getStringValue());
-         }
-         else
-         {
-            dSprintf(sTraceBuffer + dStrlen(sTraceBuffer), (U32)(sizeof(sTraceBuffer) - dStrlen(sTraceBuffer)),
-               "%s() - return %s", mThisFunctionName, STR.getStringValue());
-         }
-         Con::printf("%s", sTraceBuffer);
-      }
-   }
-
-   CodeBlock::smCurrentCodeBlock = mSaveCodeBlock;
-   if (mSaveCodeBlock && mSaveCodeBlock->name)
-   {
-      Con::gCurrentFile = mSaveCodeBlock->name;
-      Con::gCurrentRoot = mSaveCodeBlock->modPath;
-   }
-
-   mCodeBlock->decRefCount();
-
-#ifdef TORQUE_VALIDATE_STACK
-   AssertFatal(!(STR.mStartStackSize > stackStart), "String stack not popped enough in script exec");
-   AssertFatal(!(STR.mStartStackSize < stackStart), "String stack popped too much in script exec");
-#endif
-
-   return mReturnValue;
-}
-
-void CodeInterpreter::parseArgs(U32 &ip)
-{
-   U32 *code = mCodeBlock->code;
-
-   if (mExec.argv)
-   {
-      U32 fnArgc = code[ip + 2 + 6];
-      mThisFunctionName = Compiler::CodeToSTE(code, ip);
-      S32 wantedArgc = getMin(mExec.argc - 1, fnArgc); // argv[0] is func name
-      if (gEvalState.traceOn)
-      {
-         sTraceBuffer[0] = 0;
-         dStrcat(sTraceBuffer, "Entering ", 1024);
-
-         if (mExec.packageName)
-         {
-            dStrcat(sTraceBuffer, "[", 1024);
-            dStrcat(sTraceBuffer, mExec.packageName, 1024);
-            dStrcat(sTraceBuffer, "]", 1024);
-         }
-         if (mExec.thisNamespace && mExec.thisNamespace->mName)
-         {
-            dSprintf(sTraceBuffer + dStrlen(sTraceBuffer), (U32)(sizeof(sTraceBuffer) - dStrlen(sTraceBuffer)),
-               "%s::%s(", mExec.thisNamespace->mName, mThisFunctionName);
-         }
-         else
-         {
-            dSprintf(sTraceBuffer + dStrlen(sTraceBuffer), (U32)(sizeof(sTraceBuffer) - dStrlen(sTraceBuffer)),
-               "%s(", mThisFunctionName);
-         }
-         for (S32 i = 0; i < wantedArgc; i++)
-         {
-            dStrcat(sTraceBuffer, mExec.argv[i + 1], 1024);
-            if (i != wantedArgc - 1)
-               dStrcat(sTraceBuffer, ", ", 1024);
-         }
-         dStrcat(sTraceBuffer, ")", 1024);
-         Con::printf("%s", sTraceBuffer);
-      }
-
-      gEvalState.pushFrame(mThisFunctionName, mExec.thisNamespace);
-      mPopFrame = true;
-
-      StringTableEntry thisPointer = StringTable->insert("%this");
-
-      for (S32 i = 0; i < wantedArgc; i++)
-      {
-         StringTableEntry var = Compiler::CodeToSTE(code, ip + (2 + 6 + 1) + (i * 2));
-         gEvalState.setCurVarNameCreate(var);
-
-         ConsoleValueRef ref = mExec.argv[i + 1];
-
-         switch (ref.getType())
-         {
-         case ConsoleValue::TypeInternalInt:
-            gEvalState.setIntVariable(ref);
-            break;
-         case ConsoleValue::TypeInternalFloat:
-            gEvalState.setFloatVariable(ref);
-            break;
-         case ConsoleValue::TypeInternalStringStackPtr:
-            gEvalState.setStringStackPtrVariable(ref.getStringStackPtrValue());
-            break;
-         case ConsoleValue::TypeInternalStackString:
-         case ConsoleValue::TypeInternalString:
-         default:
-            gEvalState.setStringVariable(ref);
-            break;
-         }
-
-         if (var == thisPointer)
-         {
-            // %this gets optimized as it is flagged as a constant.
-            // Since it is guarenteed to be constant, we can then perform optimizations.
-            gEvalState.currentVariable->mIsConstant = true;
-
-            // Store a reference to the this pointer object.
-            mThisObject = Sim::findObject(gEvalState.getStringVariable());
-         }
-      }
-
-      ip = ip + (fnArgc * 2) + (2 + 6 + 1);
-      mCurFloatTable = mCodeBlock->functionFloats;
-      mCurStringTable = mCodeBlock->functionStrings;
-   }
-   else
-   {
-      mCurFloatTable = mCodeBlock->globalFloats;
-      mCurStringTable = mCodeBlock->globalStrings;
-
-      // If requested stack frame isn't available, request a new one
-      // (this prevents assert failures when creating local
-      //  variables without a stack frame)
-      if (gEvalState.getStackDepth() <= mExec.setFrame)
-         mExec.setFrame = -1;
-
-      // Do we want this code to execute using a new stack frame?
-      if (mExec.setFrame < 0)
-      {
-         gEvalState.pushFrame(NULL, NULL);
-         mPopFrame = true;
-      }
-      else
-      {
-         // We want to copy a reference to an existing stack frame
-         // on to the top of the stack.  Any change that occurs to 
-         // the locals during this new frame will also occur in the 
-         // original frame.
-         S32 stackIndex = gEvalState.getStackDepth() - mExec.setFrame - 1;
-         gEvalState.pushFrameRef(stackIndex);
-         mPopFrame = true;
-      }
-   }
-}
-
-OPCodeReturn CodeInterpreter::op_func_decl(U32 &ip)
-{
-   U32 *code = mCodeBlock->code;
-
-   if (!mExec.noCalls)
-   {
-      StringTableEntry fnName = CodeToSTE(code, ip);
-      StringTableEntry fnNamespace = CodeToSTE(code, ip + 2);
-      StringTableEntry fnPackage = CodeToSTE(code, ip + 4);
-      bool hasBody = (code[ip + 6] & 0x01) != 0;
-      U32 lineNumber = code[ip + 6] >> 1;
-
-      Namespace::unlinkPackages();
-      Namespace *ns = Namespace::find(fnNamespace, fnPackage);
-      ns->addFunction(fnName, mCodeBlock, hasBody ? ip : 0, mCurFNDocBlock ? dStrdup(mCurFNDocBlock) : NULL, lineNumber);// if no body, set the IP to 0
-      if (mCurNSDocBlock)
-      {
-         // If we have a docblock before we declare the function in the script file,
-         // this will attempt to set the doc block to the function.
-         // See OP_DOCBLOCK_STR
-         if (fnNamespace == StringTable->lookup(mNSDocBlockClass))
-         {
-            char *usageStr = dStrdup(mCurNSDocBlock);
-            usageStr[dStrlen(usageStr)] = '\0';
-            ns->mUsage = usageStr;
-            ns->mCleanUpUsage = true;
-            mCurNSDocBlock = NULL;
-         }
-      }
-      Namespace::relinkPackages();
-
-      // If we had a docblock, it's definitely not valid anymore, so clear it out.
-      mCurFNDocBlock = NULL;
-
-      //Con::printf("Adding function %s::%s (%d)", fnNamespace, fnName, ip);
-   }
-   ip = code[ip + 7];
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_create_object(U32 &ip)
-{
-   U32 *code = mCodeBlock->code;
-
-   // Read some useful info.
-   StringTableEntry objParent = CodeToSTE(code, ip);
-   bool isDataBlock = code[ip + 2];
-   bool isInternal = code[ip + 3];
-   bool isSingleton = code[ip + 4];
-   U32  lineNumber = code[ip + 5];
-   mFailJump = code[ip + 6];
-
-   // If we don't allow calls, we certainly don't allow creating objects!
-   // Moved this to after failJump is set. Engine was crashing when
-   // noCalls = true and an object was being created at the beginning of
-   // a file. ADL.
-   if (mExec.noCalls)
-   {
-      ip = mFailJump;
-      return OPCodeReturn::success;
-   }
-
-   // Push the old info to the stack
-   //Assert( objectCreationStackIndex < objectCreationStackSize );
-   mObjectCreationStack[mObjectCreationStackIndex].newObject = mCurrentNewObject;
-   mObjectCreationStack[mObjectCreationStackIndex++].failJump = mFailJump;
-
-   // Get the constructor information off the stack.
-   CSTK.getArgcArgv(NULL, &mCallArgc, &mCallArgv);
-   const char *objectName = mCallArgv[2];
-
-   // Con::printf("Creating object...");
-
-   // objectName = argv[1]...
-   mCurrentNewObject = NULL;
-
-   // Are we creating a datablock? If so, deal with case where we override
-   // an old one.
-   if (isDataBlock)
-   {
-      // Con::printf("  - is a datablock");
-
-      // Find the old one if any.
-      SimObject *db = Sim::getDataBlockGroup()->findObject(objectName);
-
-      // Make sure we're not changing types on ourselves...
-      if (db && dStricmp(db->getClassName(), mCallArgv[1]))
-      {
-         Con::errorf(ConsoleLogEntry::General, "%s: Cannot re-declare data block %s with a different class.", mCodeBlock->getFileLine(ip), objectName);
-         ip = mFailJump;
-         STR.popFrame();
-         CSTK.popFrame();
-         return OPCodeReturn::success;
-      }
-
-      // If there was one, set the currentNewObject and move on.
-      if (db)
-         mCurrentNewObject = db;
-   }
-   else if (!isInternal)
-   {
-      // IF we aren't looking at a local/internal object, then check if 
-      // this object already exists in the global space
-
-      AbstractClassRep* rep = AbstractClassRep::findClassRep(objectName);
-      if (rep != NULL) {
-         Con::errorf(ConsoleLogEntry::General, "%s: Cannot name object [%s] the same name as a script class.",
-            mCodeBlock->getFileLine(ip), objectName);
-         ip = mFailJump;
-         STR.popFrame();
-         CSTK.popFrame();
-         return OPCodeReturn::success;
-      }
-
-      SimObject *obj = Sim::findObject((const char*)objectName);
-      if (obj /*&& !obj->isLocalName()*/)
-      {
-         if (isSingleton)
-         {
-            // Make sure we're not trying to change types
-            if (dStricmp(obj->getClassName(), (const char*)mCallArgv[1]) != 0)
-            {
-               Con::errorf(ConsoleLogEntry::General, "%s: Cannot re-declare object [%s] with a different class [%s] - was [%s].",
-                  mCodeBlock->getFileLine(ip), objectName, (const char*)mCallArgv[1], obj->getClassName());
-               ip = mFailJump;
-               STR.popFrame();
-               CSTK.popFrame();
-               return OPCodeReturn::success;
-            }
-
-            // We're creating a singleton, so use the found object
-            // instead of creating a new object.
-            mCurrentNewObject = obj;
-         }
-         else
-         {
-            const char* redefineBehavior = Con::getVariable("$Con::redefineBehavior");
-
-            if (dStricmp(redefineBehavior, "replaceExisting") == 0)
-            {
-               // Save our constructor args as the argv vector is stored on the
-               // string stack and may get stomped if deleteObject triggers
-               // script execution.
-
-               ConsoleValueRef savedArgv[StringStack::MaxArgs];
-               for (int i = 0; i< mCallArgc; i++) {
-                  savedArgv[i] = mCallArgv[i];
-               }
-               //dMemcpy( savedArgv, callArgv, sizeof( savedArgv[ 0 ] ) * callArgc );
-
-               // Prevent stack value corruption
-               CSTK.pushFrame();
-               STR.pushFrame();
-               // --
-
-               obj->deleteObject();
-               obj = NULL;
-
-               // Prevent stack value corruption
-               CSTK.popFrame();
-               STR.popFrame();
-               // --
-
-               //dMemcpy( callArgv, savedArgv, sizeof( callArgv[ 0 ] ) * callArgc );
-               for (int i = 0; i<mCallArgc; i++) {
-                  mCallArgv[i] = savedArgv[i];
-               }
-            }
-            else if (dStricmp(redefineBehavior, "renameNew") == 0)
-            {
-               for (U32 i = 1;; ++i)
-               {
-                  String newName = String::ToString("%s%i", objectName, i);
-                  if (!Sim::findObject(newName))
-                  {
-                     objectName = StringTable->insert(newName);
-                     break;
-                  }
-               }
-            }
-            else if (dStricmp(redefineBehavior, "unnameNew") == 0)
-            {
-               objectName = StringTable->insert("");
-            }
-            else if (dStricmp(redefineBehavior, "postfixNew") == 0)
-            {
-               const char* postfix = Con::getVariable("$Con::redefineBehaviorPostfix");
-               String newName = String::ToString("%s%s", objectName, postfix);
-
-               if (Sim::findObject(newName))
-               {
-                  Con::errorf(ConsoleLogEntry::General, "%s: Cannot re-declare object with postfix [%s].",
-                     mCodeBlock->getFileLine(ip), newName.c_str());
-                  ip = mFailJump;
-                  STR.popFrame();
-                  CSTK.popFrame();
-                  return OPCodeReturn::success;
-               }
-               else
-                  objectName = StringTable->insert(newName);
-            }
-            else
-            {
-               Con::errorf(ConsoleLogEntry::General, "%s: Cannot re-declare object [%s].",
-                  mCodeBlock->getFileLine(ip), objectName);
-               ip = mFailJump;
-               STR.popFrame();
-               CSTK.popFrame();
-               return OPCodeReturn::success;
-            }
-         }
-      }
-   }
-
-   STR.popFrame();
-   CSTK.popFrame();
-
-   if (!mCurrentNewObject)
-   {
-      // Well, looks like we have to create a new object.
-      ConsoleObject *object = ConsoleObject::create((const char*)mCallArgv[1]);
-
-      // Deal with failure!
-      if (!object)
-      {
-         Con::errorf(ConsoleLogEntry::General, "%s: Unable to instantiate non-conobject class %s.", mCodeBlock->getFileLine(ip), (const char*)mCallArgv[1]);
-         ip = mFailJump;
-         return OPCodeReturn::success;
-      }
-
-      // Do special datablock init if appropros
-      if (isDataBlock)
-      {
-         SimDataBlock *dataBlock = dynamic_cast<SimDataBlock *>(object);
-         if (dataBlock)
-         {
-            dataBlock->assignId();
-         }
-         else
-         {
-            // They tried to make a non-datablock with a datablock keyword!
-            Con::errorf(ConsoleLogEntry::General, "%s: Unable to instantiate non-datablock class %s.", mCodeBlock->getFileLine(ip), (const char*)mCallArgv[1]);
-            // Clean up...
-            delete object;
-            mCurrentNewObject = NULL;
-            ip = mFailJump;
-            return OPCodeReturn::success;
-         }
-      }
-
-      // Finally, set currentNewObject to point to the new one.
-      mCurrentNewObject = dynamic_cast<SimObject *>(object);
-
-      // Deal with the case of a non-SimObject.
-      if (!mCurrentNewObject)
-      {
-         Con::errorf(ConsoleLogEntry::General, "%s: Unable to instantiate non-SimObject class %s.", mCodeBlock->getFileLine(ip), (const char*)mCallArgv[1]);
-         delete object;
-         mCurrentNewObject = NULL;
-         ip = mFailJump;
-         return OPCodeReturn::success;
-      }
-
-      // Set the declaration line
-      mCurrentNewObject->setDeclarationLine(lineNumber);
-
-      // Set the file that this object was created in
-      mCurrentNewObject->setFilename(mCodeBlock->name);
-
-      // Does it have a parent object? (ie, the copy constructor : syntax, not inheriance)
-      if (*objParent)
-      {
-         // Find it!
-         SimObject *parent;
-         if (Sim::findObject(objParent, parent))
-         {
-            // Con::printf(" - Parent object found: %s", parent->getClassName());
-
-            mCurrentNewObject->setCopySource(parent);
-            mCurrentNewObject->assignFieldsFrom(parent);
-
-            // copy any substitution statements
-            SimDataBlock* parent_db = dynamic_cast<SimDataBlock*>(parent);
-            if (parent_db)
-            {
-               SimDataBlock* currentNewObject_db = dynamic_cast<SimDataBlock*>(mCurrentNewObject);
-               if (currentNewObject_db)
-                  currentNewObject_db->copySubstitutionsFrom(parent_db);
-            }
-         }
-         else
-         {
-            if (Con::gObjectCopyFailures == -1)
-               Con::errorf(ConsoleLogEntry::General, "%s: Unable to find parent object %s for %s.", mCodeBlock->getFileLine(ip), objParent, (const char*)mCallArgv[1]);
-            else
-               ++Con::gObjectCopyFailures;
-
-            // Fail to create the object.
-            delete object;
-            mCurrentNewObject = NULL;
-            ip = mFailJump;
-            return OPCodeReturn::success;
-         }
-      }
-
-      // If a name was passed, assign it.
-      if (objectName[0])
-      {
-         if (!isInternal)
-            mCurrentNewObject->assignName(objectName);
-         else
-            mCurrentNewObject->setInternalName(objectName);
-
-         // Set the original name
-         mCurrentNewObject->setOriginalName(objectName);
-      }
-
-      // Prevent stack value corruption
-      CSTK.pushFrame();
-      STR.pushFrame();
-      // --
-
-      // Do the constructor parameters.
-      if (!mCurrentNewObject->processArguments(mCallArgc - 3, mCallArgv + 3))
-      {
-         delete mCurrentNewObject;
-         mCurrentNewObject = NULL;
-         ip = mFailJump;
-
-         // Prevent stack value corruption
-         CSTK.popFrame();
-         STR.popFrame();
-         // --
-         return OPCodeReturn::success;
-      }
-
-      // Prevent stack value corruption
-      CSTK.popFrame();
-      STR.popFrame();
-      // --
-
-      // If it's not a datablock, allow people to modify bits of it.
-      if (!isDataBlock)
-      {
-         mCurrentNewObject->setModStaticFields(true);
-         mCurrentNewObject->setModDynamicFields(true);
-      }
-   }
-   else
-   {
-      mCurrentNewObject->reloadReset(); // AFX (reload-reset)
-                                       // Does it have a parent object? (ie, the copy constructor : syntax, not inheriance)
-      if (*objParent)
-      {
-         // Find it!
-         SimObject *parent;
-         if (Sim::findObject(objParent, parent))
-         {
-            // Con::printf(" - Parent object found: %s", parent->getClassName());
-
-            // temporarily block name change
-            SimObject::preventNameChanging = true;
-            mCurrentNewObject->setCopySource(parent);
-            mCurrentNewObject->assignFieldsFrom(parent);
-            // restore name changing
-            SimObject::preventNameChanging = false;
-
-            // copy any substitution statements
-            SimDataBlock* parent_db = dynamic_cast<SimDataBlock*>(parent);
-            if (parent_db)
-            {
-               SimDataBlock* currentNewObject_db = dynamic_cast<SimDataBlock*>(mCurrentNewObject);
-               if (currentNewObject_db)
-                  currentNewObject_db->copySubstitutionsFrom(parent_db);
-            }
-         }
-         else
-            Con::errorf(ConsoleLogEntry::General, "%d: Unable to find parent object %s for %s.", lineNumber, objParent, (const char*)mCallArgv[1]);
-      }
-   }
-
-   // Advance the IP past the create info...
-   ip += 7;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_add_object(U32 &ip)
-{
-   // See OP_SETCURVAR for why we do this.
-   mCurFNDocBlock = NULL;
-   mCurNSDocBlock = NULL;
-
-   // Do we place this object at the root?
-   bool placeAtRoot = mCodeBlock->code[ip++];
-
-   // Con::printf("Adding object %s", currentNewObject->getName());
-
-   // Prevent stack value corruption
-   CSTK.pushFrame();
-   STR.pushFrame();
-   // --
-
-   // Make sure it wasn't already added, then add it.
-   if (mCurrentNewObject->isProperlyAdded() == false)
-   {
-      bool ret = false;
-
-      Message *msg = dynamic_cast<Message *>(mCurrentNewObject);
-      if (msg)
-      {
-         SimObjectId id = Message::getNextMessageID();
-         if (id != 0xffffffff)
-            ret = mCurrentNewObject->registerObject(id);
-         else
-            Con::errorf("%s: No more object IDs available for messages", mCodeBlock->getFileLine(ip));
-      }
-      else
-         ret = mCurrentNewObject->registerObject();
-
-      if (!ret)
-      {
-         // This error is usually caused by failing to call Parent::initPersistFields in the class' initPersistFields().
-         Con::warnf(ConsoleLogEntry::General, "%s: Register object failed for object %s of class %s.", mCodeBlock->getFileLine(ip), mCurrentNewObject->getName(), mCurrentNewObject->getClassName());
-         delete mCurrentNewObject;
-         mCurrentNewObject = NULL;
-         ip = mFailJump;
-         // Prevent stack value corruption
-         CSTK.popFrame();
-         STR.popFrame();
-         // --
-         return OPCodeReturn::success;
-      }
-   }
-
-   // Are we dealing with a datablock?
-   SimDataBlock *dataBlock = dynamic_cast<SimDataBlock *>(mCurrentNewObject);
-   static String errorStr;
-
-   // If so, preload it.
-   if (dataBlock && !dataBlock->preload(true, errorStr))
-   {
-      Con::errorf(ConsoleLogEntry::General, "%s: preload failed for %s: %s.", mCodeBlock->getFileLine(ip),
-         mCurrentNewObject->getName(), errorStr.c_str());
-      dataBlock->deleteObject();
-      mCurrentNewObject = NULL;
-      ip = mFailJump;
-
-      // Prevent stack value corruption
-      CSTK.popFrame();
-      STR.popFrame();
-      // --
-      return OPCodeReturn::success;
-   }
-
-   // What group will we be added to, if any?
-   U32 groupAddId = intStack[_UINT];
-   SimGroup *grp = NULL;
-   SimSet   *set = NULL;
-   bool isMessage = dynamic_cast<Message *>(mCurrentNewObject) != NULL;
-
-   if (!placeAtRoot || !mCurrentNewObject->getGroup())
-   {
-      if (!isMessage)
-      {
-         if (!placeAtRoot)
-         {
-            // Otherwise just add to the requested group or set.
-            if (!Sim::findObject(groupAddId, grp))
-               Sim::findObject(groupAddId, set);
-         }
-
-         if (placeAtRoot)
-         {
-            // Deal with the instantGroup if we're being put at the root or we're adding to a component.
-            if (Con::gInstantGroup.isEmpty()
-               || !Sim::findObject(Con::gInstantGroup, grp))
-               grp = Sim::getRootGroup();
-         }
-      }
-
-      // If we didn't get a group, then make sure we have a pointer to
-      // the rootgroup.
-      if (!grp)
-         grp = Sim::getRootGroup();
-
-      // add to the parent group
-      grp->addObject(mCurrentNewObject);
-
-      // If for some reason the add failed, add the object to the
-      // root group so it won't leak.
-      if (!mCurrentNewObject->getGroup())
-         Sim::getRootGroup()->addObject(mCurrentNewObject);
-
-      // add to any set we might be in
-      if (set)
-         set->addObject(mCurrentNewObject);
-   }
-
-   // store the new object's ID on the stack (overwriting the group/set
-   // id, if one was given, otherwise getting pushed)
-   if (placeAtRoot)
-      intStack[_UINT] = mCurrentNewObject->getId();
-   else
-      intStack[++_UINT] = mCurrentNewObject->getId();
-
-   // Prevent stack value corruption
-   CSTK.popFrame();
-   STR.popFrame();
-   // --
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_end_object(U32 &ip)
-{
-   // If we're not to be placed at the root, make sure we clean up
-   // our group reference.
-   bool placeAtRoot = mCodeBlock->code[ip++];
-   if (!placeAtRoot)
-      _UINT--;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_finish_object(U32 &ip)
-{
-   if (mCurrentNewObject)
-      mCurrentNewObject->onPostAdd();
-
-   //Assert( objectCreationStackIndex >= 0 );
-   // Restore the object info from the stack [7/9/2007 Black]
-   mCurrentNewObject = mObjectCreationStack[--mObjectCreationStackIndex].newObject;
-   mFailJump = mObjectCreationStack[mObjectCreationStackIndex].failJump;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_jmpiffnot(U32 &ip)
-{
-   if (floatStack[_FLT--])
-   {
-      ip++;
-      return OPCodeReturn::success;
-   }
-   ip = mCodeBlock->code[ip];
-   return OPCodeReturn::success;
-}
-
-
-OPCodeReturn CodeInterpreter::op_jmpifnot(U32 &ip)
-{
-   if (intStack[_UINT--])
-   {
-      ip++;
-      return OPCodeReturn::success;
-   }
-   ip = mCodeBlock->code[ip];
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_jmpiff(U32 &ip)
-{
-   if (!floatStack[_FLT--])
-   {
-      ip++;
-      return OPCodeReturn::success;
-   }
-   ip = mCodeBlock->code[ip];
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_jmpif(U32 &ip)
-{
-   if (!intStack[_UINT--])
-   {
-      ip++;
-      return OPCodeReturn::success;
-   }
-   ip = mCodeBlock->code[ip];
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_jmpifnot_np(U32 &ip)
-{
-   if (intStack[_UINT])
-   {
-      _UINT--;
-      ip++;
-      return OPCodeReturn::success;
-   }
-   ip = mCodeBlock->code[ip];
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_jmpif_np(U32 &ip)
-{
-   if (!intStack[_UINT])
-   {
-      _UINT--;
-      ip++;
-      return OPCodeReturn::success;
-   }
-   ip = mCodeBlock->code[ip];
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_jmp(U32 &ip)
-{
-   ip = mCodeBlock->code[ip];
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_return_void(U32 &ip)
-{
-   STR.setStringValue("");
-   // We're falling thru here on purpose.
-
-   OPCodeReturn ret = op_return(ip);
-
-   return ret;
-}
-
-OPCodeReturn CodeInterpreter::op_return(U32 &ip)
-{
-   StringStackPtr retValue = STR.getStringValuePtr();
-
-   if (mIterDepth > 0)
-   {
-      // Clear iterator state.
-      while (mIterDepth > 0)
-      {
-         iterStack[--_ITER].mIsStringIter = false;
-         --mIterDepth;
-      }
-
-      STR.rewind();
-      STR.setStringValue(StringStackPtrRef(retValue).getPtr(&STR)); // Not nice but works.
-      retValue = STR.getStringValuePtr();
-   }
-
-   // Previously the return value was on the stack and would be returned using STR.getStringValue().
-   // Now though we need to wrap it in a ConsoleValueRef 
-   mReturnValue.value = CSTK.pushStringStackPtr(retValue);
-
-   return OPCodeReturn::exitCode;
-}
-
-OPCodeReturn CodeInterpreter::op_return_flt(U32 &ip)
-{
-   if (mIterDepth > 0)
-   {
-      // Clear iterator state.
-      while (mIterDepth > 0)
-      {
-         iterStack[--_ITER].mIsStringIter = false;
-         --mIterDepth;
-      }
-
-   }
-
-   mReturnValue.value = CSTK.pushFLT(floatStack[_FLT]);
-   _FLT--;
-
-   return OPCodeReturn::exitCode;
-}
-
-OPCodeReturn CodeInterpreter::op_return_uint(U32 &ip)
-{
-   if (mIterDepth > 0)
-   {
-      // Clear iterator state.
-      while (mIterDepth > 0)
-      {
-         iterStack[--_ITER].mIsStringIter = false;
-         --mIterDepth;
-      }
-   }
-
-   mReturnValue.value = CSTK.pushUINT(intStack[_UINT]);
-   _UINT--;
-
-   return OPCodeReturn::exitCode;
-}
-
-OPCodeReturn CodeInterpreter::op_cmpeq(U32 &ip)
-{
-   intStack[_UINT + 1] = bool(floatStack[_FLT] == floatStack[_FLT - 1]);
-   _UINT++;
-   _FLT -= 2;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_cmpgr(U32 &ip)
-{
-   intStack[_UINT + 1] = bool(floatStack[_FLT] > floatStack[_FLT - 1]);
-   _UINT++;
-   _FLT -= 2;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_cmpge(U32 &ip)
-{
-   intStack[_UINT + 1] = bool(floatStack[_FLT] >= floatStack[_FLT - 1]);
-   _UINT++;
-   _FLT -= 2;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_cmplt(U32 &ip)
-{
-   intStack[_UINT + 1] = bool(floatStack[_FLT] < floatStack[_FLT - 1]);
-   _UINT++;
-   _FLT -= 2;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_cmple(U32 &ip)
-{
-   intStack[_UINT + 1] = bool(floatStack[_FLT] <= floatStack[_FLT - 1]);
-   _UINT++;
-   _FLT -= 2;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_cmpne(U32 &ip)
-{
-   intStack[_UINT + 1] = bool(floatStack[_FLT] != floatStack[_FLT - 1]);
-   _UINT++;
-   _FLT -= 2;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_xor(U32 &ip)
-{
-   intStack[_UINT - 1] = intStack[_UINT] ^ intStack[_UINT - 1];
-   _UINT--;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_mod(U32 &ip)
-{
-   if (intStack[_UINT - 1] != 0)
-      intStack[_UINT - 1] = intStack[_UINT] % intStack[_UINT - 1];
-   else
-      intStack[_UINT - 1] = 0;
-   _UINT--;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_bitand(U32 &ip)
-{
-   intStack[_UINT - 1] = intStack[_UINT] & intStack[_UINT - 1];
-   _UINT--;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_bitor(U32 &ip)
-{
-   intStack[_UINT - 1] = intStack[_UINT] | intStack[_UINT - 1];
-   _UINT--;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_not(U32 &ip)
-{
-   intStack[_UINT] = !intStack[_UINT];
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_notf(U32 &ip)
-{
-   intStack[_UINT + 1] = !floatStack[_FLT];
-   _FLT--;
-   _UINT++;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_onescomplement(U32 &ip)
-{
-   intStack[_UINT] = ~intStack[_UINT];
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_shr(U32 &ip)
-{
-   intStack[_UINT - 1] = intStack[_UINT] >> intStack[_UINT - 1];
-   _UINT--;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_shl(U32 &ip)
-{
-   intStack[_UINT - 1] = intStack[_UINT] << intStack[_UINT - 1];
-   _UINT--;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_and(U32 &ip)
-{
-   intStack[_UINT - 1] = intStack[_UINT] && intStack[_UINT - 1];
-   _UINT--;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_or(U32 &ip)
-{
-   intStack[_UINT - 1] = intStack[_UINT] || intStack[_UINT - 1];
-   _UINT--;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_add(U32 &ip)
-{
-   floatStack[_FLT - 1] = floatStack[_FLT] + floatStack[_FLT - 1];
-   _FLT--;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_sub(U32 &ip)
-{
-   floatStack[_FLT - 1] = floatStack[_FLT] - floatStack[_FLT - 1];
-   _FLT--;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_mul(U32 &ip)
-{
-   floatStack[_FLT - 1] = floatStack[_FLT] * floatStack[_FLT - 1];
-   _FLT--;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_div(U32 &ip)
-{
-   floatStack[_FLT - 1] = floatStack[_FLT] / floatStack[_FLT - 1];
-   _FLT--;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_neg(U32 &ip)
-{
-   floatStack[_FLT] = -floatStack[_FLT];
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_inc(U32 &ip)
-{
-   StringTableEntry var = CodeToSTE(mCodeBlock->code, ip);
-   ip += 2;
-
-   // If a variable is set, then these must be NULL. It is necessary
-   // to set this here so that the vector parser can appropriately
-   // identify whether it's dealing with a vector.
-   mPrevField = NULL;
-   mPrevObject = NULL;
-   mCurObject = NULL;
-
-   gEvalState.setCurVarNameCreate(var);
-
-   // In order to let docblocks work properly with variables, we have
-   // clear the current docblock when we do an assign. This way it 
-   // won't inappropriately carry forward to following function decls.
-   mCurFNDocBlock = NULL;
-   mCurNSDocBlock = NULL;
-
-   F64 val = gEvalState.getFloatVariable() + 1.0;
-   gEvalState.setFloatVariable(val);
-
-   // We gotta push val onto the stack. What if we have
-   // more expressions that have to use this.
-   // If we don't, we send out an op code to pop it.
-   floatStack[_FLT + 1] = val;
-   _FLT++;
-
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_dec(U32 &ip)
-{
-   StringTableEntry var = CodeToSTE(mCodeBlock->code, ip);
-   ip += 2;
-
-   // If a variable is set, then these must be NULL. It is necessary
-   // to set this here so that the vector parser can appropriately
-   // identify whether it's dealing with a vector.
-   mPrevField = NULL;
-   mPrevObject = NULL;
-   mCurObject = NULL;
-
-   gEvalState.setCurVarNameCreate(var);
-
-   // In order to let docblocks work properly with variables, we have
-   // clear the current docblock when we do an assign. This way it 
-   // won't inappropriately carry forward to following function decls.
-   mCurFNDocBlock = NULL;
-   mCurNSDocBlock = NULL;
-
-   F64 val = gEvalState.getFloatVariable() - 1.0;
-   gEvalState.setFloatVariable(val);
-
-   // We gotta push val onto the stack. What if we have
-   // more expressions that have to use this.
-   // If we don't, we send out an op code to pop it.
-   floatStack[_FLT + 1] = val;
-   _FLT++;
-
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_setcurvar(U32 &ip)
-{
-   StringTableEntry var = CodeToSTE(mCodeBlock->code, ip);
-   ip += 2;
-
-   // If a variable is set, then these must be NULL. It is necessary
-   // to set this here so that the vector parser can appropriately
-   // identify whether it's dealing with a vector.
-   mPrevField = NULL;
-   mPrevObject = NULL;
-   mCurObject = NULL;
-
-   gEvalState.setCurVarName(var);
-
-   // In order to let docblocks work properly with variables, we have
-   // clear the current docblock when we do an assign. This way it 
-   // won't inappropriately carry forward to following function decls.
-   mCurFNDocBlock = NULL;
-   mCurNSDocBlock = NULL;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_setcurvar_create(U32 &ip)
-{
-   StringTableEntry var = CodeToSTE(mCodeBlock->code, ip);
-   ip += 2;
-
-   // See OP_SETCURVAR
-   mPrevField = NULL;
-   mPrevObject = NULL;
-   mCurObject = NULL;
-
-   gEvalState.setCurVarNameCreate(var);
-
-   // See OP_SETCURVAR for why we do this.
-   mCurFNDocBlock = NULL;
-   mCurNSDocBlock = NULL;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_setcurvar_array(U32 &ip)
-{
-   StringTableEntry var = STR.getSTValue();
-
-   // See OP_SETCURVAR
-   mPrevField = NULL;
-   mPrevObject = NULL;
-   mCurObject = NULL;
-
-   gEvalState.setCurVarName(var);
-
-   // See OP_SETCURVAR for why we do this.
-   mCurFNDocBlock = NULL;
-   mCurNSDocBlock = NULL;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_setcurvar_array_varlookup(U32 &ip)
-{
-   StringTableEntry arrayName = CodeToSTE(mCodeBlock->code, ip);
-   StringTableEntry arrayLookup = CodeToSTE(mCodeBlock->code, ip + 2);
-   ip += 4;
-
-   STR.setStringValue(arrayName);
-   STR.advance();
-
-   // See OP_SETCURVAR
-   mPrevField = NULL;
-   mPrevObject = NULL;
-   mCurObject = NULL;
-
-   // resolve arrayLookup to get the 'value'
-   // Note: we have to setCurVarNameCreate in case the var doesn't exist.
-   // this won't cause much of a performance hit since vars are hashed.
-   gEvalState.setCurVarNameCreate(arrayLookup);
-   StringTableEntry hash = gEvalState.getStringVariable();
-
-   STR.setStringValue(hash);
-   STR.rewind();
-
-   // Generate new array name.
-   StringTableEntry var = STR.getSTValue();
-   gEvalState.setCurVarName(var);
-
-   // See OP_SETCURVAR for why we do this.
-   mCurFNDocBlock = NULL;
-   mCurNSDocBlock = NULL;
-
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_setcurvar_array_create(U32 &ip)
-{
-   StringTableEntry var = STR.getSTValue();
-
-   // See OP_SETCURVAR
-   mPrevField = NULL;
-   mPrevObject = NULL;
-   mCurObject = NULL;
-
-   gEvalState.setCurVarNameCreate(var);
-
-   // See OP_SETCURVAR for why we do this.
-   mCurFNDocBlock = NULL;
-   mCurNSDocBlock = NULL;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_setcurvar_array_create_varlookup(U32 &ip)
-{
-   StringTableEntry arrayName = CodeToSTE(mCodeBlock->code, ip);
-   StringTableEntry arrayLookup = CodeToSTE(mCodeBlock->code, ip + 2);
-   ip += 4;
-
-   // See OP_SETCURVAR
-   mPrevField = NULL;
-   mPrevObject = NULL;
-   mCurObject = NULL;
-
-   STR.setStringValue(arrayName);
-   STR.advance();
-
-   // resolve arrayLookup to get the 'value'
-   // Note: we have to setCurVarNameCreate in case the var doesn't exist.
-   // this won't cause much of a performance hit since vars are hashed.
-   gEvalState.setCurVarNameCreate(arrayLookup);
-   StringTableEntry hash = gEvalState.getStringVariable();
-
-   STR.setStringValue(hash);
-   STR.rewind();
-
-   // Generate new array name.
-   StringTableEntry var = STR.getSTValue();
-   gEvalState.setCurVarNameCreate(var);
-
-   // See OP_SETCURVAR for why we do this.
-   mCurFNDocBlock = NULL;
-   mCurNSDocBlock = NULL;
-
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_loadvar_uint(U32 &ip)
-{
-   intStack[_UINT + 1] = gEvalState.getIntVariable();
-   _UINT++;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_loadvar_flt(U32 &ip)
-{
-   floatStack[_FLT + 1] = gEvalState.getFloatVariable();
-   _FLT++;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_loadvar_str(U32 &ip)
-{
-   StringTableEntry val = gEvalState.getStringVariable();
-   STR.setStringValue(val);
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_loadvar_var(U32 &ip)
-{
-   // Sets current source of OP_SAVEVAR_VAR
-   gEvalState.copyVariable = gEvalState.currentVariable;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_savevar_uint(U32 &ip)
-{
-   gEvalState.setIntVariable(intStack[_UINT]);
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_savevar_flt(U32 &ip)
-{
-   gEvalState.setFloatVariable(floatStack[_FLT]);
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_savevar_str(U32 &ip)
-{
-   gEvalState.setStringVariable(STR.getStringValue());
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_savevar_var(U32 &ip)
-{
-   // this basically handles %var1 = %var2
-   gEvalState.setCopyVariable();
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_setcurobject(U32 &ip)
-{
-   // Save the previous object for parsing vector fields.
-   mPrevObject = mCurObject;
-   StringTableEntry val = STR.getStringValue();
-
-   // Sim::findObject will sometimes find valid objects from
-   // multi-component strings. This makes sure that doesn't
-   // happen.
-   for (const char* check = val; *check; check++)
-   {
-      if (*check == ' ')
-      {
-         val = "";
-         break;
-      }
-   }
-   mCurObject = Sim::findObject(val);
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_setcurobject_internal(U32 &ip)
-{
-   ++ip; // To skip the recurse flag if the object wasn't found
-   if (mCurObject)
-   {
-      SimSet *set = dynamic_cast<SimSet *>(mCurObject);
-      if (set)
-      {
-         StringTableEntry intName = StringTable->insert(STR.getStringValue());
-         bool recurse = mCodeBlock->code[ip - 1];
-         SimObject *obj = set->findObjectByInternalName(intName, recurse);
-         intStack[_UINT + 1] = obj ? obj->getId() : 0;
-         _UINT++;
-      }
-      else
-      {
-         Con::errorf(ConsoleLogEntry::Script, "%s: Attempt to use -> on non-set %s of class %s.", mCodeBlock->getFileLine(ip - 2), mCurObject->getName(), mCurObject->getClassName());
-         intStack[_UINT] = 0;
-      }
-   }
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_setcurobject_new(U32 &ip)
-{
-   mCurObject = mCurrentNewObject;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_setcurfield(U32 &ip)
-{
-   // Save the previous field for parsing vector fields.
-   mPrevField = mCurField;
-   dStrcpy(prevFieldArray, curFieldArray, 256);
-   mCurField = CodeToSTE(mCodeBlock->code, ip);
-   curFieldArray[0] = 0;
-   ip += 2;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_setcurfield_array(U32 &ip)
-{
-   dStrcpy(curFieldArray, STR.getStringValue(), 256);
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_setcurfield_type(U32 &ip)
-{
-   if (mCurObject)
-      mCurObject->setDataFieldType(mCodeBlock->code[ip], mCurField, curFieldArray);
-   ip++;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_setcurfield_array_var(U32 &ip)
-{
-   StringTableEntry var = CodeToSTE(mCodeBlock->code, ip);
-   ip += 2;
-
-   // We set the current var name (create it as well in case if it doesn't exist,
-   // otherwise we will crash).
-   gEvalState.setCurVarNameCreate(var);
-
-   // Then load the var and copy the contents to the current field array
-   dStrncpy(curFieldArray, gEvalState.currentVariable->getStringValue(), sizeof(curFieldArray));
-
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_setcurfield_this(U32 &ip)
-{
-   // set the 'this pointer' as the current object.
-   mCurObject = mThisObject;
-
-   mPrevField = mCurField;
-   dStrcpy(prevFieldArray, curFieldArray, 256);
-   mCurField = CodeToSTE(mCodeBlock->code, ip);
-   curFieldArray[0] = 0;
-   ip += 2;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_loadfield_uint(U32 &ip)
-{
-   if (mCurObject)
-      intStack[_UINT + 1] = U32(dAtoi(mCurObject->getDataField(mCurField, curFieldArray)));
-   else
-   {
-      // The field is not being retrieved from an object. Maybe it's
-      // a special accessor?
-      char buff[FieldBufferSizeNumeric];
-      memset(buff, 0, sizeof(buff));
-      getFieldComponent(mPrevObject, mPrevField, prevFieldArray, mCurField, buff);
-      intStack[_UINT + 1] = dAtoi(buff);
-   }
-   _UINT++;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_loadfield_flt(U32 &ip)
-{
-   if (mCurObject)
-      floatStack[_FLT + 1] = dAtof(mCurObject->getDataField(mCurField, curFieldArray));
-   else
-   {
-      // The field is not being retrieved from an object. Maybe it's
-      // a special accessor?
-      char buff[FieldBufferSizeNumeric];
-      memset(buff, 0, sizeof(buff));
-      getFieldComponent(mPrevObject, mPrevField, prevFieldArray, mCurField, buff);
-      floatStack[_FLT + 1] = dAtof(buff);
-   }
-   _FLT++;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_loadfield_str(U32 &ip)
-{
-   if (mCurObject)
-   {
-      StringTableEntry val = mCurObject->getDataField(mCurField, curFieldArray);
-      STR.setStringValue(val);
-   }
-   else
-   {
-      // The field is not being retrieved from an object. Maybe it's
-      // a special accessor?
-      char buff[FieldBufferSizeString];
-      memset(buff, 0, sizeof(buff));
-      getFieldComponent(mPrevObject, mPrevField, prevFieldArray, mCurField, buff);
-      STR.setStringValue(buff);
-   }
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_savefield_uint(U32 &ip)
-{
-   STR.setIntValue(intStack[_UINT]);
-   if (mCurObject)
-      mCurObject->setDataField(mCurField, curFieldArray, STR.getStringValue());
-   else
-   {
-      // The field is not being set on an object. Maybe it's
-      // a special accessor?
-      setFieldComponent(mPrevObject, mPrevField, prevFieldArray, mCurField);
-      mPrevObject = NULL;
-   }
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_savefield_flt(U32 &ip)
-{
-   STR.setFloatValue(floatStack[_FLT]);
-   if (mCurObject)
-      mCurObject->setDataField(mCurField, curFieldArray, STR.getStringValue());
-   else
-   {
-      // The field is not being set on an object. Maybe it's
-      // a special accessor?
-      setFieldComponent(mPrevObject, mPrevField, prevFieldArray, mCurField);
-      mPrevObject = NULL;
-   }
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_savefield_str(U32 &ip)
-{
-   if (mCurObject)
-      mCurObject->setDataField(mCurField, curFieldArray, STR.getStringValue());
-   else
-   {
-      // The field is not being set on an object. Maybe it's
-      // a special accessor?
-      setFieldComponent(mPrevObject, mPrevField, prevFieldArray, mCurField);
-      mPrevObject = NULL;
-   }
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_str_to_uint(U32 &ip)
-{
-   intStack[_UINT + 1] = STR.getIntValue();
-   _UINT++;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_str_to_flt(U32 &ip)
-{
-   floatStack[_FLT + 1] = STR.getFloatValue();
-   _FLT++;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_str_to_none(U32 &ip)
-{
-   // This exists simply to deal with certain typecast situations.
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_flt_to_uint(U32 &ip)
-{
-   intStack[_UINT + 1] = (S64)floatStack[_FLT];
-   _FLT--;
-   _UINT++;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_flt_to_str(U32 &ip)
-{
-   STR.setFloatValue(floatStack[_FLT]);
-   _FLT--;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_flt_to_none(U32 &ip)
-{
-   _FLT--;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_uint_to_flt(U32 &ip)
-{
-   floatStack[_FLT + 1] = (F32)intStack[_UINT];
-   _UINT--;
-   _FLT++;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_uint_to_str(U32 &ip)
-{
-   STR.setIntValue(intStack[_UINT]);
-   _UINT--;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_uint_to_none(U32 &ip)
-{
-   _UINT--;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_copyvar_to_none(U32 &ip)
-{
-   gEvalState.copyVariable = NULL;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_loadimmed_uint(U32 &ip)
-{
-   intStack[_UINT + 1] = mCodeBlock->code[ip++];
-   _UINT++;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_loadimmed_flt(U32 &ip)
-{
-   floatStack[_FLT + 1] = mCurFloatTable[mCodeBlock->code[ip]];
-   ip++;
-   _FLT++;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_tag_to_str(U32 &ip)
-{
-   mCodeBlock->code[ip - 1] = OP_LOADIMMED_STR;
-   // it's possible the string has already been converted
-   if (U8(mCurStringTable[mCodeBlock->code[ip]]) != StringTagPrefixByte)
-   {
-      U32 id = GameAddTaggedString(mCurStringTable + mCodeBlock->code[ip]);
-      dSprintf(mCurStringTable + mCodeBlock->code[ip] + 1, 7, "%d", id);
-      *(mCurStringTable + mCodeBlock->code[ip]) = StringTagPrefixByte;
-   }
-
-   // Fallthrough
-   OPCodeReturn ret = op_loadimmed_str(ip);
-
-   return ret;
-}
-
-OPCodeReturn CodeInterpreter::op_loadimmed_str(U32 &ip)
-{
-   STR.setStringValue(mCurStringTable + mCodeBlock->code[ip++]);
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_docblock_str(U32 &ip)
-{
-   // If the first word of the doc is '\class' or '@class', then this
-   // is a namespace doc block, otherwise it is a function doc block.
-   const char* docblock = mCurStringTable + mCodeBlock->code[ip++];
-
-   const char* sansClass = dStrstr(docblock, "@class");
-   if (!sansClass)
-      sansClass = dStrstr(docblock, "\\class");
-
-   if (sansClass)
-   {
-      // Don't save the class declaration. Scan past the 'class'
-      // keyword and up to the first whitespace.
-      sansClass += 7;
-      S32 index = 0;
-      while ((*sansClass != ' ') && (*sansClass != '\n') && *sansClass && (index < (nsDocLength - 1)))
-      {
-         mNSDocBlockClass[index++] = *sansClass;
-         sansClass++;
-      }
-      mNSDocBlockClass[index] = '\0';
-
-      mCurNSDocBlock = sansClass + 1;
-   }
-   else
-      mCurFNDocBlock = docblock;
-
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_loadimmed_ident(U32 &ip)
-{
-   STR.setStringValue(CodeToSTE(mCodeBlock->code, ip));
-   ip += 2;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_callfunc_resolve(U32 &ip)
-{
-   // This deals with a function that is potentially living in a namespace.
-   StringTableEntry fnNamespace = CodeToSTE(mCodeBlock->code, ip + 2);
-   StringTableEntry fnName = CodeToSTE(mCodeBlock->code, ip);
-
-   // Try to look it up.
-   mNSEntry = Namespace::find(fnNamespace)->lookup(fnName);
-   if (!CInterface::GetCInterface().isMethod(fnNamespace, fnName) && !mNSEntry)
-   {
-      ip += 5;
-      Con::warnf(ConsoleLogEntry::General,
-         "%s: Unable to find function %s%s%s",
-         mCodeBlock->getFileLine(ip - 7), fnNamespace ? fnNamespace : "",
-         fnNamespace ? "::" : "", fnName);
-      STR.popFrame();
-      CSTK.popFrame();
-      return OPCodeReturn::success;
-   }
-
-   // Fallthrough to op_callfunc_resolve
-   OPCodeReturn ret = op_callfunc(ip);
-
-   return ret;
-}
-
-OPCodeReturn CodeInterpreter::op_callfunc(U32 &ip)
-{
-   // This routingId is set when we query the object as to whether
-   // it handles this method.  It is set to an enum from the table
-   // above indicating whether it handles it on a component it owns
-   // or just on the object.
-   S32 routingId = 0;
-
-   U32 *code = mCodeBlock->code;
-
-   StringTableEntry fnNamespace = CodeToSTE(mCodeBlock->code, ip + 2);
-   StringTableEntry fnName = CodeToSTE(code, ip);
-
-   //if this is called from inside a function, append the ip and codeptr
-   if (gEvalState.getStackDepth() > 0)
-   {
-      gEvalState.getCurrentFrame().code = mCodeBlock;
-      gEvalState.getCurrentFrame().ip = ip - 1;
-   }
-
-   U32 callType = code[ip + 4];
-
-   ip += 5;
-   CSTK.getArgcArgv(fnName, &mCallArgc, &mCallArgv);
-
-   const char *componentReturnValue = "";
-   Namespace *ns = NULL;
-
-   bool cFunctionRes = false;
-   const char* cRetRes = NULL;
-
-   if (callType == FuncCallExprNode::FunctionCall)
-   {
-      if (!mNSEntry)
-         mNSEntry = Namespace::global()->lookup(fnName);
-
-      StringStackWrapper args(mCallArgc, mCallArgv);
-      cRetRes = CInterface::CallFunction(fnNamespace, fnName, args.argv + 1, args.argc - 1, &cFunctionRes);
-   }
-   else if (callType == FuncCallExprNode::MethodCall)
-   {
-      mSaveObject = gEvalState.thisObject;
-      gEvalState.thisObject = Sim::findObject((const char*)mCallArgv[1]);
-      if (!gEvalState.thisObject)
-      {
-         // Go back to the previous saved object.
-         gEvalState.thisObject = mSaveObject;
-
-         Con::warnf(ConsoleLogEntry::General, "%s: Unable to find object: '%s' attempting to call function '%s'", mCodeBlock->getFileLine(ip - 4), (const char*)mCallArgv[1], fnName);
-         STR.popFrame();
-         CSTK.popFrame();
-         STR.setStringValue("");
-         return OPCodeReturn::success;
-      }
-
-      bool handlesMethod = gEvalState.thisObject->handlesConsoleMethod(fnName, &routingId);
-      if (handlesMethod && routingId == MethodOnComponent)
-      {
-         ICallMethod *pComponent = dynamic_cast<ICallMethod *>(gEvalState.thisObject);
-         if (pComponent)
-            componentReturnValue = pComponent->callMethodArgList(mCallArgc, mCallArgv, false);
-      }
-
-      ns = gEvalState.thisObject->getNamespace();
-      if (ns)
-         mNSEntry = ns->lookup(fnName);
-      else
-         mNSEntry = NULL;
-
-      StringStackWrapper args(mCallArgc, mCallArgv);
-      cRetRes = CInterface::CallMethod(gEvalState.thisObject, fnName, args.argv + 2, args.argc - 2, &cFunctionRes);
-   }
-   else // it's a ParentCall
-   {
-      if (mExec.thisNamespace)
-      {
-         ns = mExec.thisNamespace->mParent;
-         if (ns)
-            mNSEntry = ns->lookup(fnName);
-         else
-            mNSEntry = NULL;
-      }
-      else
-      {
-         ns = NULL;
-         mNSEntry = NULL;
-      }
-   }
-
-   Namespace::Entry::CallbackUnion * nsCb = NULL;
-   const char * nsUsage = NULL;
-   if (mNSEntry)
-   {
-      nsCb = &mNSEntry->cb;
-      nsUsage = mNSEntry->mUsage;
-      routingId = 0;
-   }
-   if (!cFunctionRes && (!mNSEntry || mExec.noCalls))
-   {
-      if (!mExec.noCalls && !(routingId == MethodOnComponent))
-      {
-         if (callType == FuncCallExprNode::MethodCall)
-         {
-            if (gEvalState.thisObject != NULL)
-            {
-               // Try to use the name instead of the id
-               StringTableEntry name = gEvalState.thisObject->getName() ? gEvalState.thisObject->getName() : gEvalState.thisObject->getIdString();
-               Con::warnf(ConsoleLogEntry::General, "%s: Unknown method %s.%s Namespace List: %s", mCodeBlock->getFileLine(ip - 6), name, fnName, Con::getNamespaceList(ns));
-            }
-            else
-            {
-               // NULL.
-               Con::warnf(ConsoleLogEntry::General, "%s: Unknown method NULL.%s", mCodeBlock->getFileLine(ip - 6), fnName);
-            }
-         }
-         else if (callType == FuncCallExprNode::ParentCall)
-         {
-            Con::warnf(ConsoleLogEntry::General, "%s: Unknown parent call %s.", mCodeBlock->getFileLine(ip - 6), fnName);
-         }
-         else 
-         {
-            Con::warnf(ConsoleLogEntry::General, "%s: Unknown function %s.", mCodeBlock->getFileLine(ip - 6), fnName);
-         }
-      }
-      STR.popFrame();
-      CSTK.popFrame();
-
-      if (routingId == MethodOnComponent)
-         STR.setStringValue(componentReturnValue);
-      else
-         STR.setStringValue("");
-      return OPCodeReturn::success;
-   }
-
-   // ConsoleFunctionType is for any function defined by script.
-   // Any 'callback' type is an engine function that is exposed to script.
-   if (cFunctionRes || mNSEntry->mType == Namespace::Entry::ConsoleFunctionType)
-   {
-      ConsoleValue retVal;
-      ConsoleValueRef ret;
-      if (cFunctionRes)
-      {
-         retVal.init();
-         ret.value = &retVal;
-         retVal.setStackStringValue(cRetRes);
-      }
-      else if (mNSEntry->mFunctionOffset)
-      {
-         ret = mNSEntry->mCode->exec(mNSEntry->mFunctionOffset, fnName, mNSEntry->mNamespace, mCallArgc, mCallArgv, false, mNSEntry->mPackage);
-      }
-
-      STR.popFrame();
-      // Functions are assumed to return strings, so look ahead to see if we can skip the conversion
-      if (code[ip] == OP_STR_TO_UINT)
-      {
-         ip++;
-         intStack[++_UINT] = (U32)((S32)ret);
-      }
-      else if (code[ip] == OP_STR_TO_FLT)
-      {
-         ip++;
-         floatStack[++_FLT] = (F32)ret;
-      }
-      else if (code[ip] == OP_STR_TO_NONE)
-      {
-         STR.setStringValue(ret.getStringValue());
-         ip++;
-      }
-      else
-         STR.setStringValue((const char*)ret);
-
-      // This will clear everything including returnValue
-      CSTK.popFrame();
-      //STR.clearFunctionOffset();
-   }
-   else
-   {
-      const char* nsName = ns ? ns->mName : "";
-#ifndef TORQUE_DEBUG
-      // [tom, 12/13/2006] This stops tools functions from working in the console,
-      // which is useful behavior when debugging so I'm ifdefing this out for debug builds.
-      if (mNSEntry->mToolOnly && !Con::isCurrentScriptToolScript())
-      {
-         Con::errorf(ConsoleLogEntry::Script, "%s: %s::%s - attempting to call tools only function from outside of tools.", mCodeBlock->getFileLine(ip - 6), nsName, fnName);
-      }
-      else
-#endif
-      if ((mNSEntry->mMinArgs && S32(mCallArgc) < mNSEntry->mMinArgs) || (mNSEntry->mMaxArgs && S32(mCallArgc) > mNSEntry->mMaxArgs))
-      {
-         Con::warnf(ConsoleLogEntry::Script, "%s: %s::%s - wrong number of arguments (got %i, expected min %i and max %i).",
-            mCodeBlock->getFileLine(ip - 6), nsName, fnName,
-            mCallArgc, mNSEntry->mMinArgs, mNSEntry->mMaxArgs);
-         Con::warnf(ConsoleLogEntry::Script, "%s: usage: %s", mCodeBlock->getFileLine(ip - 6), mNSEntry->mUsage);
-         STR.popFrame();
-         CSTK.popFrame();
-      }
-      else
-      {
-         switch (mNSEntry->mType)
-         {
-         case Namespace::Entry::StringCallbackType:
-         {
-            const char *ret = mNSEntry->cb.mStringCallbackFunc(gEvalState.thisObject, mCallArgc, mCallArgv);
-            STR.popFrame();
-            CSTK.popFrame();
-            if (ret != STR.getStringValue())
-               STR.setStringValue(ret);
-            //else
-            //   sSTR.setLen(dStrlen(ret));
-            break;
-         }
-         case Namespace::Entry::IntCallbackType:
-         {
-            S32 result = mNSEntry->cb.mIntCallbackFunc(gEvalState.thisObject, mCallArgc, mCallArgv);
-            STR.popFrame();
-            CSTK.popFrame();
-            if (code[ip] == OP_STR_TO_UINT)
-            {
-               ip++;
-               intStack[++_UINT] = result;
-               break;
-            }
-            else if (code[ip] == OP_STR_TO_FLT)
-            {
-               ip++;
-               floatStack[++_FLT] = result;
-               break;
-            }
-            else if (code[ip] == OP_STR_TO_NONE)
-               ip++;
-            else
-               STR.setIntValue(result);
-            break;
-         }
-         case Namespace::Entry::FloatCallbackType:
-         {
-            F64 result = mNSEntry->cb.mFloatCallbackFunc(gEvalState.thisObject, mCallArgc, mCallArgv);
-            STR.popFrame();
-            CSTK.popFrame();
-            if (code[ip] == OP_STR_TO_UINT)
-            {
-               ip++;
-               intStack[++_UINT] = (S64)result;
-               break;
-            }
-            else if (code[ip] == OP_STR_TO_FLT)
-            {
-               ip++;
-               floatStack[++_FLT] = result;
-               break;
-            }
-            else if (code[ip] == OP_STR_TO_NONE)
-               ip++;
-            else
-               STR.setFloatValue(result);
-            break;
-         }
-         case Namespace::Entry::VoidCallbackType:
-            mNSEntry->cb.mVoidCallbackFunc(gEvalState.thisObject, mCallArgc, mCallArgv);
-            if (code[ip] != OP_STR_TO_NONE && Con::getBoolVariable("$Con::warnVoidAssignment", true))
-               Con::warnf(ConsoleLogEntry::General, "%s: Call to %s in %s uses result of void function call.", mCodeBlock->getFileLine(ip - 6), fnName, mExec.functionName);
-
-            STR.popFrame();
-            CSTK.popFrame();
-            STR.setStringValue("");
-            break;
-         case Namespace::Entry::BoolCallbackType:
-         {
-            bool result = mNSEntry->cb.mBoolCallbackFunc(gEvalState.thisObject, mCallArgc, mCallArgv);
-            STR.popFrame();
-            CSTK.popFrame();
-            if (code[ip] == OP_STR_TO_UINT)
-            {
-               ip++;
-               intStack[++_UINT] = result;
-               break;
-            }
-            else if (code[ip] == OP_STR_TO_FLT)
-            {
-               ip++;
-               floatStack[++_FLT] = result;
-               break;
-            }
-            else if (code[ip] == OP_STR_TO_NONE)
-               ip++;
-            else
-               STR.setIntValue(result);
-            break;
-         }
-         }
-      }
-   }
-
-   if (callType == FuncCallExprNode::MethodCall)
-      gEvalState.thisObject = mSaveObject;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_callfunc_pointer(U32 &ip)
-{
-   // get function name. This is the 'function pointer'.
-   StringTableEntry fnName = StringTable->insert(STR.getStringValue());
-
-   U32 *code = mCodeBlock->code;
-
-   mNSEntry = Namespace::global()->lookup(fnName);
-
-   //if this is called from inside a function, append the ip and codeptr
-   if (gEvalState.getStackDepth() > 0)
-   {
-      gEvalState.getCurrentFrame().code = mCodeBlock;
-      gEvalState.getCurrentFrame().ip = ip - 1;
-   }
-
-   CSTK.getArgcArgv(fnName, &mCallArgc, &mCallArgv);
-
-
-   if (!mNSEntry || mExec.noCalls)
-   {
-      if (!mExec.noCalls)
-      {
-         Con::warnf(ConsoleLogEntry::General, "%s: Unknown function %s.", mCodeBlock->getFileLine(ip - 6), fnName);
-      }
-      STR.popFrame();
-      CSTK.popFrame();
-
-      STR.setStringValue("");
-      return OPCodeReturn::success;
-   }
-
-   // ConsoleFunctionType is for any function defined by script.
-   // Any 'callback' type is an engine function that is exposed to script.
-   if (mNSEntry->mType == Namespace::Entry::ConsoleFunctionType)
-   {
-      ConsoleValueRef ret;
-      if (mNSEntry->mFunctionOffset)
-         ret = mNSEntry->mCode->exec(mNSEntry->mFunctionOffset, fnName, mNSEntry->mNamespace, mCallArgc, mCallArgv, false, mNSEntry->mPackage);
-
-      STR.popFrame();
-      // Functions are assumed to return strings, so look ahead to see if we can skip the conversion
-      if (code[ip] == OP_STR_TO_UINT)
-      {
-         ip++;
-         intStack[++_UINT] = (U32)((S32)ret);
-      }
-      else if (code[ip] == OP_STR_TO_FLT)
-      {
-         ip++;
-         floatStack[++_FLT] = (F32)ret;
-      }
-      else if (code[ip] == OP_STR_TO_NONE)
-      {
-         STR.setStringValue(ret.getStringValue());
-         ip++;
-      }
-      else
-         STR.setStringValue((const char*)ret);
-
-      // This will clear everything including returnValue
-      CSTK.popFrame();
-      //STR.clearFunctionOffset();
-   }
-   else
-   {
-      const char* nsName = "";
-
-#ifndef TORQUE_DEBUG
-      // [tom, 12/13/2006] This stops tools functions from working in the console,
-      // which is useful behavior when debugging so I'm ifdefing this out for debug builds.
-      if (mNSEntry->mToolOnly && !Con::isCurrentScriptToolScript())
-      {
-         Con::errorf(ConsoleLogEntry::Script, "%s: %s::%s - attempting to call tools only function from outside of tools.", mCodeBlock->getFileLine(ip - 6), nsName, fnName);
-      }
-      else
-#endif
-         if ((mNSEntry->mMinArgs && S32(mCallArgc) < mNSEntry->mMinArgs) || (mNSEntry->mMaxArgs && S32(mCallArgc) > mNSEntry->mMaxArgs))
-         {
-            Con::warnf(ConsoleLogEntry::Script, "%s: %s::%s - wrong number of arguments (got %i, expected min %i and max %i).",
-               mCodeBlock->getFileLine(ip - 6), nsName, fnName,
-               mCallArgc, mNSEntry->mMinArgs, mNSEntry->mMaxArgs);
-            Con::warnf(ConsoleLogEntry::Script, "%s: usage: %s", mCodeBlock->getFileLine(ip - 6), mNSEntry->mUsage);
-            STR.popFrame();
-            CSTK.popFrame();
-         }
-         else
-         {
-            switch (mNSEntry->mType)
-            {
-            case Namespace::Entry::StringCallbackType:
-            {
-               const char *ret = mNSEntry->cb.mStringCallbackFunc(gEvalState.thisObject, mCallArgc, mCallArgv);
-               STR.popFrame();
-               CSTK.popFrame();
-               if (ret != STR.getStringValue())
-                  STR.setStringValue(ret);
-               //else
-               //   sSTR.setLen(dStrlen(ret));
-               break;
-            }
-            case Namespace::Entry::IntCallbackType:
-            {
-               S32 result = mNSEntry->cb.mIntCallbackFunc(gEvalState.thisObject, mCallArgc, mCallArgv);
-               STR.popFrame();
-               CSTK.popFrame();
-               if (code[ip] == OP_STR_TO_UINT)
-               {
-                  ip++;
-                  intStack[++_UINT] = result;
-                  break;
-               }
-               else if (code[ip] == OP_STR_TO_FLT)
-               {
-                  ip++;
-                  floatStack[++_FLT] = result;
-                  break;
-               }
-               else if (code[ip] == OP_STR_TO_NONE)
-                  ip++;
-               else
-                  STR.setIntValue(result);
-               break;
-            }
-            case Namespace::Entry::FloatCallbackType:
-            {
-               F64 result = mNSEntry->cb.mFloatCallbackFunc(gEvalState.thisObject, mCallArgc, mCallArgv);
-               STR.popFrame();
-               CSTK.popFrame();
-               if (code[ip] == OP_STR_TO_UINT)
-               {
-                  ip++;
-                  intStack[++_UINT] = (S64)result;
-                  break;
-               }
-               else if (code[ip] == OP_STR_TO_FLT)
-               {
-                  ip++;
-                  floatStack[++_FLT] = result;
-                  break;
-               }
-               else if (code[ip] == OP_STR_TO_NONE)
-                  ip++;
-               else
-                  STR.setFloatValue(result);
-               break;
-            }
-            case Namespace::Entry::VoidCallbackType:
-               mNSEntry->cb.mVoidCallbackFunc(gEvalState.thisObject, mCallArgc, mCallArgv);
-               if (code[ip] != OP_STR_TO_NONE && Con::getBoolVariable("$Con::warnVoidAssignment", true))
-                  Con::warnf(ConsoleLogEntry::General, "%s: Call to %s in %s uses result of void function call.", mCodeBlock->getFileLine(ip - 6), fnName, mExec.functionName);
-
-               STR.popFrame();
-               CSTK.popFrame();
-               STR.setStringValue("");
-               break;
-            case Namespace::Entry::BoolCallbackType:
-            {
-               bool result = mNSEntry->cb.mBoolCallbackFunc(gEvalState.thisObject, mCallArgc, mCallArgv);
-               STR.popFrame();
-               CSTK.popFrame();
-               if (code[ip] == OP_STR_TO_UINT)
-               {
-                  ip++;
-                  intStack[++_UINT] = result;
-                  break;
-               }
-               else if (code[ip] == OP_STR_TO_FLT)
-               {
-                  ip++;
-                  floatStack[++_FLT] = result;
-                  break;
-               }
-               else if (code[ip] == OP_STR_TO_NONE)
-                  ip++;
-               else
-                  STR.setIntValue(result);
-               break;
-            }
-            }
-         }
-   }
-
-
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_callfunc_this(U32 &ip)
-{
-   U32 *code = mCodeBlock->code;
-
-   StringTableEntry fnName = CodeToSTE(code, ip);
-
-   //if this is called from inside a function, append the ip and codeptr
-   if (gEvalState.getStackDepth() > 0)
-   {
-      gEvalState.getCurrentFrame().code = mCodeBlock;
-      gEvalState.getCurrentFrame().ip = ip - 1;
-   }
-
-   ip += 2;
-   CSTK.getArgcArgv(fnName, &mCallArgc, &mCallArgv);
-
-   Namespace *ns = mThisObject ? mThisObject->getNamespace() : NULL;
-   if (ns)
-      mNSEntry = ns->lookup(fnName);
-   else
-      mNSEntry = NULL;
-
-   if (!mNSEntry || mExec.noCalls)
-   {
-      if (!mExec.noCalls)
-      {
-         if (mThisObject)
-         {
-            // Try to use the name instead of the id
-            StringTableEntry name = mThisObject->getName() ? mThisObject->getName() : mThisObject->getIdString();
-            Con::warnf(ConsoleLogEntry::General, "%s: Unknown method %s.%s Namespace List: %s", mCodeBlock->getFileLine(ip - 6), name, fnName, Con::getNamespaceList(ns));
-         }
-         else
-         {
-            // At least let the scripter know that they access the object.
-            Con::warnf(ConsoleLogEntry::General, "%s: Unknown method NULL.%s", mCodeBlock->getFileLine(ip - 6), fnName);
-         }
-      }
-      STR.popFrame();
-      CSTK.popFrame();
-
-      STR.setStringValue("");
-      return OPCodeReturn::success;
-   }
-
-   // ConsoleFunctionType is for any function defined by script.
-   // Any 'callback' type is an engine function that is exposed to script.
-   if (mNSEntry->mType == Namespace::Entry::ConsoleFunctionType)
-   {
-      ConsoleValueRef ret;
-      if (mNSEntry->mFunctionOffset)
-         ret = mNSEntry->mCode->exec(mNSEntry->mFunctionOffset, fnName, mNSEntry->mNamespace, mCallArgc, mCallArgv, false, mNSEntry->mPackage);
-
-      STR.popFrame();
-      // Functions are assumed to return strings, so look ahead to see if we can skip the conversion
-      if (code[ip] == OP_STR_TO_UINT)
-      {
-         ip++;
-         intStack[++_UINT] = (U32)((S32)ret);
-      }
-      else if (code[ip] == OP_STR_TO_FLT)
-      {
-         ip++;
-         floatStack[++_FLT] = (F32)ret;
-      }
-      else if (code[ip] == OP_STR_TO_NONE)
-      {
-         STR.setStringValue(ret.getStringValue());
-         ip++;
-      }
-      else
-         STR.setStringValue((const char*)ret);
-
-      // This will clear everything including returnValue
-      CSTK.popFrame();
-      //STR.clearFunctionOffset();
-   }
-   else
-   {
-      const char* nsName = ns ? ns->mName : "";
-#ifndef TORQUE_DEBUG
-      // [tom, 12/13/2006] This stops tools functions from working in the console,
-      // which is useful behavior when debugging so I'm ifdefing this out for debug builds.
-      if (mNSEntry->mToolOnly && !Con::isCurrentScriptToolScript())
-      {
-         Con::errorf(ConsoleLogEntry::Script, "%s: %s::%s - attempting to call tools only function from outside of tools.", mCodeBlock->getFileLine(ip - 6), nsName, fnName);
-      }
-      else
-#endif
-         if ((mNSEntry->mMinArgs && S32(mCallArgc) < mNSEntry->mMinArgs) || (mNSEntry->mMaxArgs && S32(mCallArgc) > mNSEntry->mMaxArgs))
-         {
-            Con::warnf(ConsoleLogEntry::Script, "%s: %s::%s - wrong number of arguments (got %i, expected min %i and max %i).",
-               mCodeBlock->getFileLine(ip - 6), nsName, fnName,
-               mCallArgc, mNSEntry->mMinArgs, mNSEntry->mMaxArgs);
-            Con::warnf(ConsoleLogEntry::Script, "%s: usage: %s", mCodeBlock->getFileLine(ip - 6), mNSEntry->mUsage);
-            STR.popFrame();
-            CSTK.popFrame();
-         }
-         else
-         {
-            switch (mNSEntry->mType)
-            {
-            case Namespace::Entry::StringCallbackType:
-            {
-               const char *ret = mNSEntry->cb.mStringCallbackFunc(mThisObject, mCallArgc, mCallArgv);
-               STR.popFrame();
-               CSTK.popFrame();
-               if (ret != STR.getStringValue())
-                  STR.setStringValue(ret);
-               //else
-               //   sSTR.setLen(dStrlen(ret));
-               break;
-            }
-            case Namespace::Entry::IntCallbackType:
-            {
-               S32 result = mNSEntry->cb.mIntCallbackFunc(mThisObject, mCallArgc, mCallArgv);
-               STR.popFrame();
-               CSTK.popFrame();
-               if (code[ip] == OP_STR_TO_UINT)
-               {
-                  ip++;
-                  intStack[++_UINT] = result;
-                  break;
-               }
-               else if (code[ip] == OP_STR_TO_FLT)
-               {
-                  ip++;
-                  floatStack[++_FLT] = result;
-                  break;
-               }
-               else if (code[ip] == OP_STR_TO_NONE)
-                  ip++;
-               else
-                  STR.setIntValue(result);
-               break;
-            }
-            case Namespace::Entry::FloatCallbackType:
-            {
-               F64 result = mNSEntry->cb.mFloatCallbackFunc(mThisObject, mCallArgc, mCallArgv);
-               STR.popFrame();
-               CSTK.popFrame();
-               if (code[ip] == OP_STR_TO_UINT)
-               {
-                  ip++;
-                  intStack[++_UINT] = (S64)result;
-                  break;
-               }
-               else if (code[ip] == OP_STR_TO_FLT)
-               {
-                  ip++;
-                  floatStack[++_FLT] = result;
-                  break;
-               }
-               else if (code[ip] == OP_STR_TO_NONE)
-                  ip++;
-               else
-                  STR.setFloatValue(result);
-               break;
-            }
-            case Namespace::Entry::VoidCallbackType:
-               mNSEntry->cb.mVoidCallbackFunc(mThisObject, mCallArgc, mCallArgv);
-               if (code[ip] != OP_STR_TO_NONE && Con::getBoolVariable("$Con::warnVoidAssignment", true))
-                  Con::warnf(ConsoleLogEntry::General, "%s: Call to %s in %s uses result of void function call.", mCodeBlock->getFileLine(ip - 6), fnName, mExec.functionName);
-
-               STR.popFrame();
-               CSTK.popFrame();
-               STR.setStringValue("");
-               break;
-            case Namespace::Entry::BoolCallbackType:
-            {
-               bool result = mNSEntry->cb.mBoolCallbackFunc(mThisObject, mCallArgc, mCallArgv);
-               STR.popFrame();
-               CSTK.popFrame();
-               if (code[ip] == OP_STR_TO_UINT)
-               {
-                  ip++;
-                  intStack[++_UINT] = result;
-                  break;
-               }
-               else if (code[ip] == OP_STR_TO_FLT)
-               {
-                  ip++;
-                  floatStack[++_FLT] = result;
-                  break;
-               }
-               else if (code[ip] == OP_STR_TO_NONE)
-                  ip++;
-               else
-                  STR.setIntValue(result);
-               break;
-            }
-            }
-         }
-   }
-
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_advance_str(U32 &ip)
-{
-   STR.advance();
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_advance_str_appendchar(U32 &ip)
-{
-   STR.advanceChar(mCodeBlock->code[ip++]);
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_advance_str_comma(U32 &ip)
-{
-   STR.advanceChar('_');
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_advance_str_nul(U32 &ip)
-{
-   STR.advanceChar(0);
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_rewind_str(U32 &ip)
-{
-   STR.rewind();
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_terminate_rewind_str(U32 &ip)
-{
-   STR.rewindTerminate();
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_compare_str(U32 &ip)
-{
-   intStack[++_UINT] = STR.compare();
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_push(U32 &ip)
-{
-   STR.push();
-   CSTK.pushStringStackPtr(STR.getPreviousStringValuePtr());
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_push_uint(U32 &ip)
-{
-   CSTK.pushUINT(intStack[_UINT]);
-   _UINT--;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_push_flt(U32 &ip)
-{
-   CSTK.pushFLT(floatStack[_FLT]);
-   _FLT--;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_push_var(U32 &ip)
-{
-   if (gEvalState.currentVariable)
-      CSTK.pushValue(gEvalState.currentVariable->value);
-   else
-      CSTK.pushString("");
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_push_this(U32 &ip)
-{
-   StringTableEntry varName = CodeToSTE(mCodeBlock->code, ip);
-   ip += 2;
-
-   // shorthand OP_SETCURVAR
-
-   // If a variable is set, then these must be NULL. It is necessary
-   // to set this here so that the vector parser can appropriately
-   // identify whether it's dealing with a vector.
-   mPrevField = NULL;
-   mPrevObject = NULL;
-   mCurObject = NULL;
-
-   gEvalState.setCurVarName(varName);
-
-   // In order to let docblocks work properly with variables, we have
-   // clear the current docblock when we do an assign. This way it 
-   // won't inappropriately carry forward to following function decls.
-   mCurFNDocBlock = NULL;
-   mCurNSDocBlock = NULL;
-
-   // shorthand OP_LOADVAR_STR (since objs can be by name we can't assume uint)
-   STR.setStringValue(gEvalState.getStringVariable());
-
-   // shorthand OP_PUSH
-   STR.push();
-   CSTK.pushStringStackPtr(STR.getPreviousStringValuePtr());
-
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_push_frame(U32 &ip)
-{
-   STR.pushFrame();
-   CSTK.pushFrame();
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_assert(U32 &ip)
-{
-   if (!intStack[_UINT--])
-   {
-      const char *message = mCurStringTable + mCodeBlock->code[ip];
-
-      U32 breakLine, inst;
-      mCodeBlock->findBreakLine(ip - 1, breakLine, inst);
-
-      if (PlatformAssert::processAssert(PlatformAssert::Fatal,
-         mCodeBlock->name ? mCodeBlock->name : "eval",
-         breakLine,
-         message))
-      {
-         if (TelDebugger && TelDebugger->isConnected() && breakLine > 0)
-         {
-            TelDebugger->breakProcess();
-         }
-         else
-            Platform::debugBreak();
-      }
-   }
-
-   ip++;
-
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_break(U32 &ip)
-{
-   //append the ip and codeptr before managing the breakpoint!
-   AssertFatal(gEvalState.getStackDepth() > 0, "Empty eval stack on break!");
-   gEvalState.getCurrentFrame().code = mCodeBlock;
-   gEvalState.getCurrentFrame().ip = ip - 1;
-
-   U32 breakLine;
-   mCodeBlock->findBreakLine(ip - 1, breakLine, mCurrentInstruction);
-   if (!breakLine)
-      return OPCodeReturn::breakContinue;
-   TelDebugger->executionStopped(mCodeBlock, breakLine);
-   return OPCodeReturn::breakContinue;
-}
-
-OPCodeReturn CodeInterpreter::op_iter_begin_str(U32 &ip)
-{
-   iterStack[_ITER].mIsStringIter = true;
-
-   // Emulate fallthrough:
-   OPCodeReturn fallthrough = op_iter_begin(ip);
-
-   return fallthrough;
-}
-
-OPCodeReturn CodeInterpreter::op_iter_begin(U32 &ip)
-{
-   StringTableEntry varName = CodeToSTE(mCodeBlock->code, ip);
-   U32 failIp = mCodeBlock->code[ip + 2];
-
-   IterStackRecord& iter = iterStack[_ITER];
-
-   if (varName[0] == '$')
-      iter.mVariable = gEvalState.globalVars.add(varName);
-   else
-      iter.mVariable = gEvalState.getCurrentFrame().add(varName);
-
-   if (iter.mIsStringIter)
-   {
-      iter.mData.mStr.mString = STR.getStringValuePtr();
-      iter.mData.mStr.mIndex = 0;
-   }
-   else
-   {
-      // Look up the object.
-
-      SimSet* set;
-      if (!Sim::findObject(STR.getStringValue(), set))
-      {
-         Con::errorf(ConsoleLogEntry::General, "No SimSet object '%s'", STR.getStringValue());
-         Con::errorf(ConsoleLogEntry::General, "Did you mean to use 'foreach$' instead of 'foreach'?");
-         ip = failIp;
-         return OPCodeReturn::success;
-      }
-
-      // Set up.
-
-      iter.mData.mObj.mSet = set;
-      iter.mData.mObj.mIndex = 0;
-   }
-
-   _ITER++;
-   mIterDepth++;
-
-   STR.push();
-
-   ip += 3;
-
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_iter(U32 &ip)
-{
-   U32 breakIp = mCodeBlock->code[ip];
-   IterStackRecord& iter = iterStack[_ITER - 1];
-
-   if (iter.mIsStringIter)
-   {
-      const char* str = StringStackPtrRef(iter.mData.mStr.mString).getPtr(&STR);
-
-      U32 startIndex = iter.mData.mStr.mIndex;
-      U32 endIndex = startIndex;
-
-      // Break if at end.
-
-      if (!str[startIndex])
-      {
-         ip = breakIp;
-         return OPCodeReturn::success; // continue in old interpreter
-      }
-
-      // Find right end of current component.
-
-      if (!dIsspace(str[endIndex]))
-         do ++endIndex;
-      while (str[endIndex] && !dIsspace(str[endIndex]));
-
-      // Extract component.
-
-      if (endIndex != startIndex)
-      {
-         char savedChar = str[endIndex];
-         const_cast< char* >(str)[endIndex] = '\0'; // We are on the string stack so this is okay.
-         iter.mVariable->setStringValue(&str[startIndex]);
-         const_cast< char* >(str)[endIndex] = savedChar;
-      }
-      else
-         iter.mVariable->setStringValue("");
-
-      // Skip separator.
-      if (str[endIndex] != '\0')
-         ++endIndex;
-
-      iter.mData.mStr.mIndex = endIndex;
-   }
-   else
-   {
-      U32 index = iter.mData.mObj.mIndex;
-      SimSet* set = iter.mData.mObj.mSet;
-
-      if (index >= set->size())
-      {
-         ip = breakIp;
-         return OPCodeReturn::success; // continue in old interpreter
-      }
-
-      iter.mVariable->setIntValue(set->at(index)->getId());
-      iter.mData.mObj.mIndex = index + 1;
-   }
-
-   ++ip;
-
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_iter_end(U32 &ip)
-{
-   --_ITER;
-   --mIterDepth;
-   STR.rewind();
-   iterStack[_ITER].mIsStringIter = false;
-   return OPCodeReturn::success;
-}
-
-OPCodeReturn CodeInterpreter::op_invalid(U32 &ip)
-{
-   // Invalid does nothing.
-   return OPCodeReturn::exitCode;
-}
diff --git a/Engine/source/console/codeInterpreter.h b/Engine/source/console/codeInterpreter.h
deleted file mode 100644
index 133222726..000000000
--- a/Engine/source/console/codeInterpreter.h
+++ /dev/null
@@ -1,262 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#ifndef _CODEINTERPRETER_H_
-#define _CODEINTERPRETER_H_
-
-#include "console/codeBlock.h"
-#include "console/console.h"
-#include "console/consoleInternal.h"
-
-/// Frame data for a foreach/foreach$ loop.
-struct IterStackRecord
-{
-   /// If true, this is a foreach$ loop; if not, it's a foreach loop.
-   bool mIsStringIter;
-
-   /// The iterator variable.
-   Dictionary::Entry* mVariable;
-
-   /// Information for an object iterator loop.
-   struct ObjectPos
-   {
-      /// The set being iterated over.
-      SimSet* mSet;
-
-      /// Current index in the set.
-      U32 mIndex;
-   };
-
-   /// Information for a string iterator loop.
-   struct StringPos
-   {
-      /// The raw string data on the string stack.
-      StringStackPtr mString;
-
-      /// Current parsing position.
-      U32 mIndex;
-   };
-
-   union
-   {
-      ObjectPos mObj;
-      StringPos mStr;
-   } mData;
-};
-
-enum OPCodeReturn
-{
-   exitCode = -1,
-   success = 0,
-   breakContinue = 1
-};
-
-class CodeInterpreter
-{
-public:
-   CodeInterpreter(CodeBlock *cb);
-   ~CodeInterpreter();
-
-   ConsoleValueRef exec(U32 ip, 
-                        StringTableEntry functionName,
-                        Namespace *thisNamespace,
-                        U32 argc, 
-                        ConsoleValueRef *argv, 
-                        bool noCalls, 
-                        StringTableEntry packageName, 
-                        S32 setFrame);
-
-   static void init();
-
-   // Methods
-private:
-   void parseArgs(U32 &ip);
-
-   /// Group op codes
-   /// @{
-
-   OPCodeReturn op_func_decl(U32 &ip);
-   OPCodeReturn op_create_object(U32 &ip);
-   OPCodeReturn op_add_object(U32 &ip);
-   OPCodeReturn op_end_object(U32 &ip);
-   OPCodeReturn op_finish_object(U32 &ip);
-   OPCodeReturn op_jmpiffnot(U32 &ip);
-   OPCodeReturn op_jmpifnot(U32 &ip);
-   OPCodeReturn op_jmpiff(U32 &ip);
-   OPCodeReturn op_jmpif(U32 &ip);
-   OPCodeReturn op_jmpifnot_np(U32 &ip);
-   OPCodeReturn op_jmpif_np(U32 &ip);
-   OPCodeReturn op_jmp(U32 &ip);
-   OPCodeReturn op_return_void(U32 &ip);
-   OPCodeReturn op_return(U32 &ip);
-   OPCodeReturn op_return_flt(U32 &ip);
-   OPCodeReturn op_return_uint(U32 &ip);
-   OPCodeReturn op_cmpeq(U32 &ip);
-   OPCodeReturn op_cmpgr(U32 &ip);
-   OPCodeReturn op_cmpge(U32 &ip);
-   OPCodeReturn op_cmplt(U32 &ip);
-   OPCodeReturn op_cmple(U32 &ip);
-   OPCodeReturn op_cmpne(U32 &ip);
-   OPCodeReturn op_xor(U32 &ip);
-   OPCodeReturn op_mod(U32 &ip);
-   OPCodeReturn op_bitand(U32 &ip);
-   OPCodeReturn op_bitor(U32 &ip);
-   OPCodeReturn op_not(U32 &ip);
-   OPCodeReturn op_notf(U32 &ip);
-   OPCodeReturn op_onescomplement(U32 &ip);
-   OPCodeReturn op_shr(U32 &ip);
-   OPCodeReturn op_shl(U32 &ip);
-   OPCodeReturn op_and(U32 &ip);
-   OPCodeReturn op_or(U32 &ip);
-   OPCodeReturn op_add(U32 &ip);
-   OPCodeReturn op_sub(U32 &ip);
-   OPCodeReturn op_mul(U32 &ip);
-   OPCodeReturn op_div(U32 &ip);
-   OPCodeReturn op_neg(U32 &ip);
-   OPCodeReturn op_inc(U32 &ip);
-   OPCodeReturn op_dec(U32 &ip);
-   OPCodeReturn op_setcurvar(U32 &ip);
-   OPCodeReturn op_setcurvar_create(U32 &ip);
-   OPCodeReturn op_setcurvar_array(U32 &ip);
-   OPCodeReturn op_setcurvar_array_varlookup(U32 &ip);
-   OPCodeReturn op_setcurvar_array_create(U32 &ip);
-   OPCodeReturn op_setcurvar_array_create_varlookup(U32 &ip);
-   OPCodeReturn op_loadvar_uint(U32 &ip);
-   OPCodeReturn op_loadvar_flt(U32 &ip);
-   OPCodeReturn op_loadvar_str(U32 &ip);
-   OPCodeReturn op_loadvar_var(U32 &ip);
-   OPCodeReturn op_savevar_uint(U32 &ip);
-   OPCodeReturn op_savevar_flt(U32 &ip);
-   OPCodeReturn op_savevar_str(U32 &ip);
-   OPCodeReturn op_savevar_var(U32 &ip);
-   OPCodeReturn op_setcurobject(U32 &ip);
-   OPCodeReturn op_setcurobject_internal(U32 &ip);
-   OPCodeReturn op_setcurobject_new(U32 &ip);
-   OPCodeReturn op_setcurfield(U32 &ip);
-   OPCodeReturn op_setcurfield_array(U32 &ip);
-   OPCodeReturn op_setcurfield_type(U32 &ip);
-   OPCodeReturn op_setcurfield_this(U32 &ip);
-   OPCodeReturn op_setcurfield_array_var(U32 &ip);
-   OPCodeReturn op_loadfield_uint(U32 &ip);
-   OPCodeReturn op_loadfield_flt(U32 &ip);
-   OPCodeReturn op_loadfield_str(U32 &ip);
-   OPCodeReturn op_savefield_uint(U32 &ip);
-   OPCodeReturn op_savefield_flt(U32 &ip);
-   OPCodeReturn op_savefield_str(U32 &ip);
-   OPCodeReturn op_str_to_uint(U32 &ip);
-   OPCodeReturn op_str_to_flt(U32 &ip);
-   OPCodeReturn op_str_to_none(U32 &ip);
-   OPCodeReturn op_flt_to_uint(U32 &ip);
-   OPCodeReturn op_flt_to_str(U32 &ip);
-   OPCodeReturn op_flt_to_none(U32 &ip);
-   OPCodeReturn op_uint_to_flt(U32 &ip);
-   OPCodeReturn op_uint_to_str(U32 &ip);
-   OPCodeReturn op_uint_to_none(U32 &ip);
-   OPCodeReturn op_copyvar_to_none(U32 &ip);
-   OPCodeReturn op_loadimmed_uint(U32 &ip);
-   OPCodeReturn op_loadimmed_flt(U32 &ip);
-   OPCodeReturn op_tag_to_str(U32 &ip);
-   OPCodeReturn op_loadimmed_str(U32 &ip);
-   OPCodeReturn op_docblock_str(U32 &ip);
-   OPCodeReturn op_loadimmed_ident(U32 &ip);
-   OPCodeReturn op_callfunc_resolve(U32 &ip);
-   OPCodeReturn op_callfunc(U32 &ip);
-   OPCodeReturn op_callfunc_pointer(U32 &ip);
-   OPCodeReturn op_callfunc_this(U32 &ip);
-   OPCodeReturn op_advance_str(U32 &ip);
-   OPCodeReturn op_advance_str_appendchar(U32 &ip);
-   OPCodeReturn op_advance_str_comma(U32 &ip);
-   OPCodeReturn op_advance_str_nul(U32 &ip);
-   OPCodeReturn op_rewind_str(U32 &ip);
-   OPCodeReturn op_terminate_rewind_str(U32 &ip);
-   OPCodeReturn op_compare_str(U32 &ip);
-   OPCodeReturn op_push(U32 &ip);
-   OPCodeReturn op_push_uint(U32 &ip);
-   OPCodeReturn op_push_flt(U32 &ip);
-   OPCodeReturn op_push_var(U32 &ip);
-   OPCodeReturn op_push_this(U32 &ip);
-   OPCodeReturn op_push_frame(U32 &ip);
-   OPCodeReturn op_assert(U32 &ip);
-   OPCodeReturn op_break(U32 &ip);
-   OPCodeReturn op_iter_begin_str(U32 &ip);
-   OPCodeReturn op_iter_begin(U32 &ip);
-   OPCodeReturn op_iter(U32 &ip);
-   OPCodeReturn op_iter_end(U32 &ip);
-   OPCodeReturn op_invalid(U32 &ip);
-
-   /// @}
-
-private:
-   CodeBlock *mCodeBlock;
-
-   /// Group exec arguments.
-   struct
-   {
-      StringTableEntry functionName;
-      Namespace *thisNamespace;
-      U32 argc;
-      ConsoleValueRef *argv;
-      bool noCalls;
-      StringTableEntry packageName;
-      S32 setFrame;
-   } mExec;
-
-   U32 mIterDepth;
-   F64 *mCurFloatTable;
-   char *mCurStringTable;
-   StringTableEntry mThisFunctionName;
-   bool mPopFrame;
-
-   // Add local object creation stack [7/9/2007 Black]
-   static const U32 objectCreationStackSize = 32;
-   U32 mObjectCreationStackIndex;
-   struct 
-   {
-      SimObject *newObject;
-      U32 failJump;
-   } mObjectCreationStack[objectCreationStackSize];
-
-   SimObject *mCurrentNewObject;
-   U32 mFailJump;
-   StringTableEntry mPrevField;
-   StringTableEntry mCurField;
-   SimObject *mPrevObject;
-   SimObject *mCurObject;
-   SimObject *mSaveObject;
-   SimObject *mThisObject;
-   Namespace::Entry *mNSEntry;
-   StringTableEntry mCurFNDocBlock;
-   StringTableEntry mCurNSDocBlock;
-   U32 mCallArgc;
-   ConsoleValueRef *mCallArgv;
-   CodeBlock *mSaveCodeBlock;
-
-   // note: anything returned is pushed to CSTK and will be invalidated on the next exec()
-   ConsoleValueRef mReturnValue;
-
-   U32 mCurrentInstruction;
-
-   static const S32 nsDocLength = 128;
-   char mNSDocBlockClass[nsDocLength];
-};
-
-#endif
\ No newline at end of file
diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index 47f5717ad..1d9ae968c 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -1,5 +1,7 @@
 //-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
+// Copyright (c) 2013 GarageGames, LLC
+// Copyright (c) 2015 Faust Logic, Inc.
+// Copyright (c) 2021 TGEMIT Authors & Contributors
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to
@@ -40,8 +42,8 @@
 #include "util/messaging/message.h"
 #include "core/frameAllocator.h"
 
-#include "console/codeInterpreter.h"
 #include "console/returnBuffer.h"
+#include "console/consoleValueStack.h"
 
 #ifndef TORQUE_TGB_ONLY
 #include "materials/materialDefinition.h"
@@ -50,13 +52,71 @@
 
 using namespace Compiler;
 
+enum EvalConstants
+{
+   MaxStackSize = 1024,
+   FieldBufferSizeString = 2048,
+   FieldBufferSizeNumeric = 128,
+   MethodOnComponent = -2
+};
+
+/// Frame data for a foreach/foreach$ loop.
+struct IterStackRecord
+{
+   /// If true, this is a foreach$ loop; if not, it's a foreach loop.
+   bool mIsStringIter;
+
+   /// The iterator variable.
+   Dictionary::Entry* mVariable;
+
+   /// Information for an object iterator loop.
+   struct ObjectPos
+   {
+      /// The set being iterated over.
+      SimSet* mSet;
+
+      /// Current index in the set.
+      U32 mIndex;
+   };
+
+   /// Information for a string iterator loop.
+   struct StringPos
+   {
+      /// The raw string data on the string stack.
+      const char* mString;
+
+      /// Current parsing position.
+      U32 mIndex;
+   };
+   union
+   {
+      ObjectPos mObj;
+      StringPos mStr;
+   } mData;
+};
+
+ConsoleValueStack<4096> gCallStack;
+
+StringStack STR;
+
+U32 _FLT = 0;     ///< Stack pointer for floatStack.
+U32 _UINT = 0;    ///< Stack pointer for intStack.
+U32 _ITER = 0;    ///< Stack pointer for iterStack.
+
+IterStackRecord iterStack[MaxStackSize];
+
+F64 floatStack[MaxStackSize];
+S64 intStack[MaxStackSize];
+
+char curFieldArray[256];
+char prevFieldArray[256];
+
 namespace Con
 {
    // Current script file name and root, these are registered as
    // console variables.
    extern StringTableEntry gCurrentFile;
    extern StringTableEntry gCurrentRoot;
-   extern S32 gObjectCopyFailures;
 }
 
 namespace Con
@@ -79,6 +139,124 @@ namespace Con
    }
 }
 
+// Gets a component of an object's field value or a variable and returns it
+// in val.
+static void getFieldComponent(SimObject* object, StringTableEntry field, const char* array, StringTableEntry subField, char val[])
+{
+   const char* prevVal = NULL;
+
+   // Grab value from object.
+   if (object && field)
+      prevVal = object->getDataField(field, array);
+
+   // Otherwise, grab from the string stack. The value coming in will always
+   // be a string because that is how multicomponent variables are handled.
+   else
+      prevVal = STR.getStringValue();
+
+   // Make sure we got a value.
+   if (prevVal && *prevVal)
+   {
+      static const StringTableEntry xyzw[] =
+      {
+         StringTable->insert("x"),
+         StringTable->insert("y"),
+         StringTable->insert("z"),
+         StringTable->insert("w")
+      };
+
+      static const StringTableEntry rgba[] =
+      {
+         StringTable->insert("r"),
+         StringTable->insert("g"),
+         StringTable->insert("b"),
+         StringTable->insert("a")
+      };
+
+      // Translate xyzw and rgba into the indexed component 
+      // of the variable or field.
+      if (subField == xyzw[0] || subField == rgba[0])
+         dStrcpy(val, StringUnit::getUnit(prevVal, 0, " \t\n"), 128);
+
+      else if (subField == xyzw[1] || subField == rgba[1])
+         dStrcpy(val, StringUnit::getUnit(prevVal, 1, " \t\n"), 128);
+
+      else if (subField == xyzw[2] || subField == rgba[2])
+         dStrcpy(val, StringUnit::getUnit(prevVal, 2, " \t\n"), 128);
+
+      else if (subField == xyzw[3] || subField == rgba[3])
+         dStrcpy(val, StringUnit::getUnit(prevVal, 3, " \t\n"), 128);
+
+      else
+         val[0] = 0;
+   }
+   else
+      val[0] = 0;
+}
+
+// Sets a component of an object's field value based on the sub field. 'x' will
+// set the first field, 'y' the second, and 'z' the third.
+static void setFieldComponent(SimObject* object, StringTableEntry field, const char* array, StringTableEntry subField)
+{
+   // Copy the current string value
+   char strValue[1024];
+   dStrncpy(strValue, STR.getStringValue(), 1024);
+
+   char val[1024] = "";
+   const char* prevVal = NULL;
+
+   // Set the value on an object field.
+   if (object && field)
+      prevVal = object->getDataField(field, array);
+
+   // Set the value on a variable.
+   else if (gEvalState.currentVariable)
+      prevVal = gEvalState.getStringVariable();
+
+   // Ensure that the variable has a value
+   if (!prevVal)
+      return;
+
+   static const StringTableEntry xyzw[] =
+   {
+      StringTable->insert("x"),
+      StringTable->insert("y"),
+      StringTable->insert("z"),
+      StringTable->insert("w")
+   };
+
+   static const StringTableEntry rgba[] =
+   {
+      StringTable->insert("r"),
+      StringTable->insert("g"),
+      StringTable->insert("b"),
+      StringTable->insert("a")
+   };
+
+   // Insert the value into the specified 
+   // component of the string.
+   if (subField == xyzw[0] || subField == rgba[0])
+      dStrcpy(val, StringUnit::setUnit(prevVal, 0, strValue, " \t\n"), 128);
+
+   else if (subField == xyzw[1] || subField == rgba[1])
+      dStrcpy(val, StringUnit::setUnit(prevVal, 1, strValue, " \t\n"), 128);
+
+   else if (subField == xyzw[2] || subField == rgba[2])
+      dStrcpy(val, StringUnit::setUnit(prevVal, 2, strValue, " \t\n"), 128);
+
+   else if (subField == xyzw[3] || subField == rgba[3])
+      dStrcpy(val, StringUnit::setUnit(prevVal, 3, strValue, " \t\n"), 128);
+
+   if (val[0] != 0)
+   {
+      // Update the field or variable.
+      if (object && field)
+         object->setDataField(field, 0, val);
+      else if (gEvalState.currentVariable)
+         gEvalState.setStringVariable(val);
+   }
+}
+
 //------------------------------------------------------------
 
 F64 consoleStringToNumber(const char *str, StringTableEntry file, U32 line)
@@ -239,38 +417,1717 @@ void ExprEvalState::setStringVariable(const char *val)
    currentVariable->setStringValue(val);
 }
 
-void ExprEvalState::setStringStackPtrVariable(StringStackPtr str)
-{
-   AssertFatal(currentVariable != NULL, "Invalid evaluator state - trying to set null variable!");
-   currentVariable->setStringStackPtrValue(str);
-}
+//-----------------------------------------------------------------------------
 
-void ExprEvalState::setCopyVariable()
+U32 gExecCount = 0;
+void CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNamespace, U32 argc, ConsoleValue* argv, bool noCalls, StringTableEntry packageName, ConsoleValue& returnValue, S32 setFrame)
 {
-   if (copyVariable)
+#ifdef TORQUE_DEBUG
+   U32 stackStart = STR.mStartStackSize;
+   gExecCount++;
+#endif
+
+   const dsize_t TRACE_BUFFER_SIZE = 1024;
+   static char traceBuffer[TRACE_BUFFER_SIZE];
+   U32 i;
+
+   U32 iterDepth = 0;
+
+   incRefCount();
+   F64* curFloatTable;
+   char* curStringTable;
+   S32 curStringTableLen = 0; //clint to ensure we dont overwrite it
+   STR.clearFunctionOffset();
+   StringTableEntry thisFunctionName = NULL;
+   bool popFrame = false;
+   if (argv)
    {
-      switch (copyVariable->value.type)
+      // assume this points into a function decl:
+      U32 fnArgc = code[ip + 2 + 6];
+      U32 regCount = code[ip + 2 + 7];
+      thisFunctionName = CodeToSTE(code, ip);
+      S32 wantedArgc = getMin(argc - 1, fnArgc); // argv[0] is func name
+      if (gEvalState.traceOn)
       {
-         case ConsoleValue::TypeInternalInt:
-            currentVariable->setIntValue(copyVariable->getIntValue());
+         traceBuffer[0] = 0;
+         dStrcat(traceBuffer, "Entering ", TRACE_BUFFER_SIZE);
+         if (packageName)
+         {
+            dStrcat(traceBuffer, "[", TRACE_BUFFER_SIZE);
+            dStrcat(traceBuffer, packageName, TRACE_BUFFER_SIZE);
+            dStrcat(traceBuffer, "]", TRACE_BUFFER_SIZE);
+         }
+         if (thisNamespace && thisNamespace->mName)
+         {
+            dSprintf(traceBuffer + dStrlen(traceBuffer), sizeof(traceBuffer) - dStrlen(traceBuffer),
+               "%s::%s(", thisNamespace->mName, thisFunctionName);
+         }
+         else
+         {
+            dSprintf(traceBuffer + dStrlen(traceBuffer), sizeof(traceBuffer) - dStrlen(traceBuffer),
+               "%s(", thisFunctionName);
+         }
+         for (i = 0; i < wantedArgc; i++)
+         {
+            dStrcat(traceBuffer, argv[i + 1].getString(), TRACE_BUFFER_SIZE);
+            if (i != wantedArgc - 1)
+               dStrcat(traceBuffer, ", ", TRACE_BUFFER_SIZE);
+         }
+         dStrcat(traceBuffer, ")", TRACE_BUFFER_SIZE);
+         Con::printf("%s", traceBuffer);
+      }
+      gEvalState.pushFrame(thisFunctionName, thisNamespace, regCount);
+      popFrame = true;
+      for (i = 0; i < wantedArgc; i++)
+      {
+         S32 reg = code[ip + (2 + 6 + 1 + 1) + i];
+         ConsoleValue& value = argv[i + 1];
+         switch (value.getType())
+         {
+         case ConsoleValueType::cvString:
+            gEvalState.setLocalStringVariable(reg, value.getString(), dStrlen(value.getString()));
             break;
-         case ConsoleValue::TypeInternalFloat:
-            currentVariable->setFloatValue(copyVariable->getFloatValue());
+         case ConsoleValueType::cvInteger:
+            gEvalState.setLocalIntVariable(reg, value.getInt());
+            break;
+         case ConsoleValueType::cvFloat:
+            gEvalState.setLocalFloatVariable(reg, value.getFloat());
+            break;
+         case ConsoleValueType::cvSTEntry:
+            gEvalState.setLocalStringTableEntryVariable(reg, value.getString());
             break;
          default:
-            currentVariable->setStringValue(copyVariable->getStringValue());
-            break;
+            AssertFatal(false, avar("Invalid local variable type. Type was: %i", value.getType()));
+         }
+      }
+      ip = ip + fnArgc + (2 + 6 + 1 + 1);
+      curFloatTable = functionFloats;
+      curStringTable = functionStrings;
+      curStringTableLen = functionStringsMaxLen;
+   }
+   else
+   {
+      curFloatTable = globalFloats;
+      curStringTable = globalStrings;
+      curStringTableLen = globalStringsMaxLen;
+
+      // Do we want this code to execute using a new stack frame?
+      if (setFrame < 0)
+      {
+         gEvalState.pushFrame(NULL, NULL, 0);
+         gCallStack.pushFrame(0);
+         popFrame = true;
+      }
+      else if (!gEvalState.stack.empty())
+      {
+         // We want to copy a reference to an existing stack frame
+         // on to the top of the stack.  Any change that occurs to
+         // the locals during this new frame will also occur in the
+         // original frame.
+         S32 stackIndex = gEvalState.stack.size() - setFrame - 1;
+         gEvalState.pushFrameRef(stackIndex);
+         popFrame = true;
       }
    }
-}
-
-//------------------------------------------------------------
-
-
-ConsoleValueRef CodeBlock::exec(U32 ip, const char *functionName, Namespace *thisNamespace, U32 argc, ConsoleValueRef *argv, bool noCalls, StringTableEntry packageName, S32 setFrame)
-{
-   CodeInterpreter interpreter(this);
-   return interpreter.exec(ip, functionName, thisNamespace, argc, argv, noCalls, packageName, setFrame);
+
+   // Grab the state of the telenet debugger here once
+   // so that the push and pop frames are always balanced.
+   const bool telDebuggerOn = TelDebugger && TelDebugger->isConnected();
+   if (telDebuggerOn && setFrame < 0)
+      TelDebugger->pushStackFrame();
+
+   StringTableEntry var, objParent;
+   U32 failJump;
+   StringTableEntry fnName;
+   StringTableEntry fnNamespace, fnPackage;
+
+   static const U32 objectCreationStackSize = 32;
+   U32 objectCreationStackIndex = 0;
+   struct {
+      SimObject* newObject;
+      U32 failJump;
+   } objectCreationStack[objectCreationStackSize];
+
+   SimObject* currentNewObject = 0;
+   StringTableEntry prevField = NULL;
+   StringTableEntry curField = NULL;
+   SimObject* prevObject = NULL;
+   SimObject* curObject = NULL;
+   SimObject* saveObject = NULL;
+   Namespace::Entry* nsEntry;
+   Namespace* ns;
+   const char* curFNDocBlock = NULL;
+   const char* curNSDocBlock = NULL;
+   const S32 nsDocLength = 128;
+   char nsDocBlockClass[nsDocLength];
+
+   S32 callArgc;
+   ConsoleValue* callArgv;
+
+   static char curFieldArray[256];
+   static char prevFieldArray[256];
+
+   CodeBlock* saveCodeBlock = smCurrentCodeBlock;
+   smCurrentCodeBlock = this;
+   if (this->name)
+   {
+      Con::gCurrentFile = this->name;
+      Con::gCurrentRoot = this->modPath;
+   }
+   const char* val;
+   S32 reg;
+
+   // The frame temp is used by the variable accessor ops (OP_SAVEFIELD_* and
+   // OP_LOADFIELD_*) to store temporary values for the fields.
+   static S32 VAL_BUFFER_SIZE = 1024;
+   FrameTemp<char> valBuffer(VAL_BUFFER_SIZE);
+
+   for (;;)
+   {
+      U32 instruction = code[ip++];
+   breakContinue:
+      switch (instruction)
+      {
+      case OP_FUNC_DECL:
+         if (!noCalls)
+         {
+            fnName = CodeToSTE(code, ip);
+            fnNamespace = CodeToSTE(code, ip + 2);
+            fnPackage = CodeToSTE(code, ip + 4);
+            bool hasBody = (code[ip + 6] & 0x01) != 0;
+            U32 lineNumber = code[ip + 6] >> 1;
+
+            Namespace::unlinkPackages();
+            if (fnNamespace == NULL && fnPackage == NULL)
+               ns = Namespace::global();
+            else
+               ns = Namespace::find(fnNamespace, fnPackage);
+            ns->addFunction(fnName, this, hasBody ? ip : 0);// if no body, set the IP to 0
+            if (curNSDocBlock)
+            {
+               if (fnNamespace == StringTable->lookup(nsDocBlockClass))
+               {
+                  char* usageStr = dStrdup(curNSDocBlock);
+                  usageStr[dStrlen(usageStr)] = '\0';
+                  ns->mUsage = usageStr;
+                  ns->mCleanUpUsage = true;
+                  curNSDocBlock = NULL;
+               }
+            }
+            Namespace::relinkPackages();
+
+            // If we had a docblock, it's definitely not valid anymore, so clear it out.
+            curFNDocBlock = NULL;
+
+            //Con::printf("Adding function %s::%s (%d)", fnNamespace, fnName, ip);
+         }
+         ip = code[ip + 7];
+         break;
+
+      case OP_CREATE_OBJECT:
+      {
+         // Read some useful info.
+         objParent = CodeToSTE(code, ip);
+         bool isDataBlock = code[ip + 2];
+         bool isInternal = code[ip + 3];
+         bool isSingleton = code[ip + 4];
+         U32  lineNumber = code[ip + 5];
+         failJump = code[ip + 6];
+
+         // If we don't allow calls, we certainly don't allow creating objects!
+         // Moved this to after failJump is set. Engine was crashing when
+         // noCalls = true and an object was being created at the beginning of
+         // a file. ADL.
+         if (noCalls)
+         {
+            ip = failJump;
+            break;
+         }
+
+         // Push the old info to the stack
+         //Assert( objectCreationStackIndex < objectCreationStackSize );
+         objectCreationStack[objectCreationStackIndex].newObject = currentNewObject;
+         objectCreationStack[objectCreationStackIndex++].failJump = failJump;
+
+         // Get the constructor information off the stack.
+         gCallStack.argvc(NULL, callArgc, &callArgv);
+         AssertFatal(callArgc - 3 >= 0, avar("Call Arg needs at least 3, only has %d", callArgc));
+         const char* objectName = callArgv[2].getString();
+
+         // Con::printf("Creating object...");
+
+         // objectName = argv[1]...
+         currentNewObject = NULL;
+
+         // Are we creating a datablock? If so, deal with case where we override
+         // an old one.
+         if (isDataBlock)
+         {
+            // Con::printf("  - is a datablock");
+
+            // Find the old one if any.
+            SimObject* db = Sim::getDataBlockGroup()->findObject(objectName);
+
+            // Make sure we're not changing types on ourselves...
+            if (db && dStricmp(db->getClassName(), callArgv[1].getString()))
+            {
+               Con::errorf(ConsoleLogEntry::General, "Cannot re-declare data block %s with a different class.", objectName);
+               ip = failJump;
+               gCallStack.popFrame();
+               break;
+            }
+
+            // If there was one, set the currentNewObject and move on.
+            if (db)
+               currentNewObject = db;
+         }
+         else if (!isInternal)
+         {
+            AbstractClassRep* rep = AbstractClassRep::findClassRep(objectName);
+            if (rep != NULL)
+            {
+               Con::errorf(ConsoleLogEntry::General, "%s: Cannot name object [%s] the same name as a script class.",
+                  getFileLine(ip), objectName);
+               ip = failJump;
+               gCallStack.popFrame();
+               break;
+            }
+
+            SimObject* obj = Sim::findObject((const char*)objectName);
+            if (obj)
+            {
+               if (isSingleton)
+               {
+                  // Make sure we're not trying to change types
+                  if (dStricmp(obj->getClassName(), callArgv[1].getString()) != 0)
+                  {
+                     Con::errorf(ConsoleLogEntry::General, "%s: Cannot re-declare object [%s] with a different class [%s] - was [%s].",
+                        getFileLine(ip), objectName, callArgv[1].getString(), obj->getClassName());
+                     ip = failJump;
+                     gCallStack.popFrame();
+                     break;
+                  }
+
+                  // We're creating a singleton, so use the found object instead of creating a new object.
+                  currentNewObject = obj;
+                  Con::warnf("%s: Singleton Object was already created with name %s. Using existing object.",
+                     getFileLine(ip), objectName);
+               }
+            }
+         }
+
+         gCallStack.popFrame();
+
+         if (!currentNewObject)
+         {
+            // Well, looks like we have to create a new object.
+            ConsoleObject* object = ConsoleObject::create(callArgv[1].getString());
+
+            // Deal with failure!
+            if (!object)
+            {
+               Con::errorf(ConsoleLogEntry::General, "%s: Unable to instantiate non-conobject class %s.", getFileLine(ip - 1), callArgv[1].getString());
+               ip = failJump;
+               break;
+            }
+
+            // Do special datablock init if appropros
+            if (isDataBlock)
+            {
+               SimDataBlock* dataBlock = dynamic_cast<SimDataBlock*>(object);
+               if (dataBlock)
+               {
+                  dataBlock->assignId();
+               }
+               else
+               {
+                  // They tried to make a non-datablock with a datablock keyword!
+                  Con::errorf(ConsoleLogEntry::General, "%s: Unable to instantiate non-datablock class %s.", getFileLine(ip - 1), callArgv[1].getString());
+
+                  // Clean up...
+                  delete object;
+                  ip = failJump;
+                  break;
+               }
+            }
+
+            // Finally, set currentNewObject to point to the new one.
+            currentNewObject = dynamic_cast<SimObject*>(object);
+
+            // Deal with the case of a non-SimObject.
+            if (!currentNewObject)
+            {
+               Con::errorf(ConsoleLogEntry::General, "%s: Unable to instantiate non-SimObject class %s.", getFileLine(ip - 1), callArgv[1].getString());
+               delete object;
+               ip = failJump;
+               break;
+            }
+
+            // Set the declaration line
+            currentNewObject->setDeclarationLine(lineNumber);
+
+            // Set the file that this object was created in
+            currentNewObject->setFilename(this->name);
+
+            // Does it have a parent object? (ie, the copy constructor : syntax, not inheriance)
+            if (*objParent)
+            {
+               // Find it!
+               SimObject* parent;
+               if (Sim::findObject(objParent, parent))
+               {
+                  // Con::printf(" - Parent object found: %s", parent->getClassName());
+
+                  currentNewObject->setCopySource(parent);
+                  currentNewObject->assignFieldsFrom(parent);
+
+                  // copy any substitution statements
+                  SimDataBlock* parent_db = dynamic_cast<SimDataBlock*>(parent);
+                  if (parent_db)
+                  {
+                     SimDataBlock* currentNewObject_db = dynamic_cast<SimDataBlock*>(currentNewObject);
+                     if (currentNewObject_db)
+                        currentNewObject_db->copySubstitutionsFrom(parent_db);
+                  }
+               }
+               else
+               {
+                  Con::errorf(ConsoleLogEntry::General, "%s: Unable to find parent object %s for %s.", getFileLine(ip - 1), objParent, callArgv[1].getString());
+                  delete object;
+                  currentNewObject = NULL;
+                  ip = failJump;
+                  break;
+               }
+            }
+
+            // If a name was passed, assign it.
+            if (objectName[0])
+            {
+               if (!isInternal)
+                  currentNewObject->assignName(objectName);
+               else
+                  currentNewObject->setInternalName(objectName);
+
+               // Set the original name
+               currentNewObject->setOriginalName( objectName );
+            }
+
+            // Do the constructor parameters.
+            if (!currentNewObject->processArguments(callArgc - 3, callArgv + 3))
+            {
+               delete currentNewObject;
+               currentNewObject = NULL;
+               ip = failJump;
+               break;
+            }
+
+            // If it's not a datablock, allow people to modify bits of it.
+            if (!isDataBlock)
+            {
+               currentNewObject->setModStaticFields(true);
+               currentNewObject->setModDynamicFields(true);
+            }
+         }
+         else
+         {
+            currentNewObject->reloadReset(); // AFX (reload-reset)
+
+            // Does it have a parent object? (ie, the copy constructor : syntax, not inheriance)
+            if (*objParent)
+            {
+               // Find it!
+               SimObject* parent;
+               if (Sim::findObject(objParent, parent))
+               {
+                  // Con::printf(" - Parent object found: %s", parent->getClassName());
+
+                  // temporarily block name change
+                  SimObject::preventNameChanging = true;
+                  currentNewObject->setCopySource(parent);
+                  currentNewObject->assignFieldsFrom(parent);
+                  // restore name changing
+                  SimObject::preventNameChanging = false;
+
+                  // copy any substitution statements
+                  SimDataBlock* parent_db = dynamic_cast<SimDataBlock*>(parent);
+                  if (parent_db)
+                  {
+                     SimDataBlock* currentNewObject_db = dynamic_cast<SimDataBlock*>(currentNewObject);
+                     if (currentNewObject_db)
+                        currentNewObject_db->copySubstitutionsFrom(parent_db);
+                  }
+               }
+               else
+               {
+                  Con::errorf(ConsoleLogEntry::General, "%d: Unable to find parent object %s for %s.", lineNumber, objParent, callArgv[1].getString());
+               }
+            }
+         }
+
+         // Advance the IP past the create info...
+         ip += 7;
+         break;
+      }
+
+      case OP_ADD_OBJECT:
+      {
+         // See OP_SETCURVAR for why we do this.
+         curFNDocBlock = NULL;
+         curNSDocBlock = NULL;
+
+         // Do we place this object at the root?
+         bool placeAtRoot = code[ip++];
+
+         // Con::printf("Adding object %s", currentNewObject->getName());
+
+         // Make sure it wasn't already added, then add it.
+         if (currentNewObject == NULL)
+         {
+            break;
+         }
+
+         bool isMessage = dynamic_cast<Message*>(currentNewObject) != NULL;
+
+         if (currentNewObject->isProperlyAdded() == false)
+         {
+            bool ret = false;
+            if (isMessage)
+            {
+               SimObjectId id = Message::getNextMessageID();
+               if (id != 0xffffffff)
+                  ret = currentNewObject->registerObject(id);
+               else
+                  Con::errorf("%s: No more object IDs available for messages", getFileLine(ip));
+            }
+            else
+               ret = currentNewObject->registerObject();
+
+            if (!ret)
+            {
+               // This error is usually caused by failing to call Parent::initPersistFields in the class' initPersistFields().
+               Con::warnf(ConsoleLogEntry::General, "%s: Register object failed for object %s of class %s.", getFileLine(ip - 2), currentNewObject->getName(), currentNewObject->getClassName());
+               delete currentNewObject;
+               ip = failJump;
+               break;
+            }
+         }
+
+         // Are we dealing with a datablock?
+         SimDataBlock* dataBlock = dynamic_cast<SimDataBlock*>(currentNewObject);
+         String errorStr;
+
+         // If so, preload it.
+         if (dataBlock && !dataBlock->preload(true, errorStr))
+         {
+            Con::errorf(ConsoleLogEntry::General, "%s: preload failed for %s: %s.", getFileLine(ip - 2),
+               currentNewObject->getName(), errorStr.c_str());
+            dataBlock->deleteObject();
+            ip = failJump;
+            break;
+         }
+
+         // What group will we be added to, if any?
+         U32 groupAddId = (U32)intStack[_UINT];
+         SimGroup* grp = NULL;
+         SimSet* set = NULL;
+
+         if (!placeAtRoot || !currentNewObject->getGroup())
+         {
+            if (!isMessage)
+            {
+               if (!placeAtRoot)
+               {
+                  // Otherwise just add to the requested group or set.
+                  if (!Sim::findObject(groupAddId, grp))
+                     Sim::findObject(groupAddId, set);
+               }
+
+               if (placeAtRoot)
+               {
+                  // Deal with the instantGroup if we're being put at the root or we're adding to a component.
+                  if (Con::gInstantGroup.isEmpty() || !Sim::findObject(Con::gInstantGroup, grp))
+                     grp = Sim::getRootGroup();
+               }
+            }
+
+            // If we didn't get a group, then make sure we have a pointer to
+            // the rootgroup.
+            if (!grp)
+               grp = Sim::getRootGroup();
+
+            // add to the parent group
+            grp->addObject(currentNewObject);
+
+            // If for some reason the add failed, add the object to the
+            // root group so it won't leak.
+            if (currentNewObject->getGroup() == NULL)
+               Sim::getRootGroup()->addObject(currentNewObject);
+
+            // add to any set we might be in
+            if (set)
+               set->addObject(currentNewObject);
+         }
+
+         // store the new object's ID on the stack (overwriting the group/set
+         // id, if one was given, otherwise getting pushed)
+         S32 id = currentNewObject->getId();
+         if (placeAtRoot)
+            intStack[_UINT] = id;
+         else
+            intStack[++_UINT] = id;
+
+         break;
+      }
+
+      case OP_END_OBJECT:
+      {
+         // If we're not to be placed at the root, make sure we clean up
+         // our group reference.
+         bool placeAtRoot = code[ip++];
+         if (!placeAtRoot)
+            _UINT--;
+         break;
+      }
+
+      case OP_FINISH_OBJECT:
+      {
+         if (currentNewObject)
+            currentNewObject->onPostAdd();
+
+         //Assert( objectCreationStackIndex >= 0 );
+         // Restore the object info from the stack [7/9/2007 Black]
+         currentNewObject = objectCreationStack[--objectCreationStackIndex].newObject;
+         failJump = objectCreationStack[objectCreationStackIndex].failJump;
+         break;
+      }
+
+      case OP_JMPIFFNOT:
+         if (floatStack[_FLT--])
+         {
+            ip++;
+            break;
+         }
+         ip = code[ip];
+         break;
+      case OP_JMPIFNOT:
+         if (intStack[_UINT--])
+         {
+            ip++;
+            break;
+         }
+         ip = code[ip];
+         break;
+      case OP_JMPIFF:
+         if (!floatStack[_FLT--])
+         {
+            ip++;
+            break;
+         }
+         ip = code[ip];
+         break;
+      case OP_JMPIF:
+         if (!intStack[_UINT--])
+         {
+            ip++;
+            break;
+         }
+         ip = code[ip];
+         break;
+      case OP_JMPIFNOT_NP:
+         if (intStack[_UINT])
+         {
+            _UINT--;
+            ip++;
+            break;
+         }
+         ip = code[ip];
+         break;
+      case OP_JMPIF_NP:
+         if (!intStack[_UINT])
+         {
+            _UINT--;
+            ip++;
+            break;
+         }
+         ip = code[ip];
+         break;
+      case OP_JMP:
+         ip = code[ip];
+         break;
+
+         // This fixes a bug when not explicitly returning a value.
+      case OP_RETURN_VOID:
+         STR.setStringValue("");
+         // We're falling thru here on purpose.
+
+      case OP_RETURN:
+
+         if (iterDepth > 0)
+         {
+            // Clear iterator state.
+            while (iterDepth > 0)
+            {
+               iterStack[--_ITER].mIsStringIter = false;
+               --iterDepth;
+            }
+
+            const char* retVal = STR.getStringValue();
+            STR.rewind();
+
+            returnValue.setString(retVal, STR.mLen);
+            //STR.setStringValue(returnValue); // Not nice but works.
+         }
+
+         goto execFinished;
+
+      case OP_RETURN_FLT:
+
+         if (iterDepth > 0)
+         {
+            // Clear iterator state.
+            while (iterDepth > 0)
+            {
+               iterStack[--_ITER].mIsStringIter = false;
+               --iterDepth;
+            }
+
+         }
+
+         returnValue.setFloat(floatStack[_FLT]);
+         _FLT--;
+
+         goto execFinished;
+
+      case OP_RETURN_UINT:
+
+         if (iterDepth > 0)
+         {
+            // Clear iterator state.
+            while (iterDepth > 0)
+            {
+               iterStack[--_ITER].mIsStringIter = false;
+               --iterDepth;
+            }
+         }
+
+         returnValue.setInt(intStack[_UINT]);
+         _UINT--;
+
+         goto execFinished;
+
+      case OP_CMPEQ:
+         intStack[_UINT + 1] = bool(floatStack[_FLT] == floatStack[_FLT - 1]);
+         _UINT++;
+         _FLT -= 2;
+         break;
+
+      case OP_CMPGR:
+         intStack[_UINT + 1] = bool(floatStack[_FLT] > floatStack[_FLT - 1]);
+         _UINT++;
+         _FLT -= 2;
+         break;
+
+      case OP_CMPGE:
+         intStack[_UINT + 1] = bool(floatStack[_FLT] >= floatStack[_FLT - 1]);
+         _UINT++;
+         _FLT -= 2;
+         break;
+
+      case OP_CMPLT:
+         intStack[_UINT + 1] = bool(floatStack[_FLT] < floatStack[_FLT - 1]);
+         _UINT++;
+         _FLT -= 2;
+         break;
+
+      case OP_CMPLE:
+         intStack[_UINT + 1] = bool(floatStack[_FLT] <= floatStack[_FLT - 1]);
+         _UINT++;
+         _FLT -= 2;
+         break;
+
+      case OP_CMPNE:
+         intStack[_UINT + 1] = bool(floatStack[_FLT] != floatStack[_FLT - 1]);
+         _UINT++;
+         _FLT -= 2;
+         break;
+
+      case OP_XOR:
+         intStack[_UINT - 1] = intStack[_UINT] ^ intStack[_UINT - 1];
+         _UINT--;
+         break;
+
+      case OP_MOD:
+         if (intStack[_UINT - 1] != 0)
+            intStack[_UINT - 1] = intStack[_UINT] % intStack[_UINT - 1];
+         else
+            intStack[_UINT - 1] = 0;
+         _UINT--;
+         break;
+
+      case OP_BITAND:
+         intStack[_UINT - 1] = intStack[_UINT] & intStack[_UINT - 1];
+         _UINT--;
+         break;
+
+      case OP_BITOR:
+         intStack[_UINT - 1] = intStack[_UINT] | intStack[_UINT - 1];
+         _UINT--;
+         break;
+
+      case OP_NOT:
+         intStack[_UINT] = !intStack[_UINT];
+         break;
+
+      case OP_NOTF:
+         intStack[_UINT + 1] = !floatStack[_FLT];
+         _FLT--;
+         _UINT++;
+         break;
+
+      case OP_ONESCOMPLEMENT:
+         intStack[_UINT] = ~intStack[_UINT];
+         break;
+
+      case OP_SHR:
+         intStack[_UINT - 1] = intStack[_UINT] >> intStack[_UINT - 1];
+         _UINT--;
+         break;
+
+      case OP_SHL:
+         intStack[_UINT - 1] = intStack[_UINT] << intStack[_UINT - 1];
+         _UINT--;
+         break;
+
+      case OP_AND:
+         intStack[_UINT - 1] = intStack[_UINT] && intStack[_UINT - 1];
+         _UINT--;
+         break;
+
+      case OP_OR:
+         intStack[_UINT - 1] = intStack[_UINT] || intStack[_UINT - 1];
+         _UINT--;
+         break;
+
+      case OP_ADD:
+         floatStack[_FLT - 1] = floatStack[_FLT] + floatStack[_FLT - 1];
+         _FLT--;
+         break;
+
+      case OP_SUB:
+         floatStack[_FLT - 1] = floatStack[_FLT] - floatStack[_FLT - 1];
+         _FLT--;
+         break;
+
+      case OP_MUL:
+         floatStack[_FLT - 1] = floatStack[_FLT] * floatStack[_FLT - 1];
+         _FLT--;
+         break;
+      case OP_DIV:
+         floatStack[_FLT - 1] = floatStack[_FLT] / floatStack[_FLT - 1];
+         _FLT--;
+         break;
+      case OP_NEG:
+         floatStack[_FLT] = -floatStack[_FLT];
+         break;
+
+      case OP_INC:
+         reg = code[ip++];
+         gEvalState.setLocalFloatVariable(reg, gEvalState.getLocalFloatVariable(reg) + 1.0);
+         break;
+
+      case OP_SETCURVAR:
+         var = CodeToSTE(code, ip);
+         ip += 2;
+
+         // If a variable is set, then these must be NULL. It is necessary
+         // to set this here so that the vector parser can appropriately
+         // identify whether it's dealing with a vector.
+         prevField = NULL;
+         prevObject = NULL;
+         curObject = NULL;
+
+         gEvalState.setCurVarName(var);
+
+         // In order to let docblocks work properly with variables, we have
+         // clear the current docblock when we do an assign. This way it
+         // won't inappropriately carry forward to following function decls.
+         curFNDocBlock = NULL;
+         curNSDocBlock = NULL;
+         break;
+
+      case OP_SETCURVAR_CREATE:
+         var = CodeToSTE(code, ip);
+         ip += 2;
+
+         // See OP_SETCURVAR
+         prevField = NULL;
+         prevObject = NULL;
+         curObject = NULL;
+
+         gEvalState.setCurVarNameCreate(var);
+
+         // See OP_SETCURVAR for why we do this.
+         curFNDocBlock = NULL;
+         curNSDocBlock = NULL;
+         break;
+
+      case OP_SETCURVAR_ARRAY:
+         var = STR.getSTValue();
+
+         // See OP_SETCURVAR
+         prevField = NULL;
+         prevObject = NULL;
+         curObject = NULL;
+
+         gEvalState.setCurVarName(var);
+
+         // See OP_SETCURVAR for why we do this.
+         curFNDocBlock = NULL;
+         curNSDocBlock = NULL;
+         break;
+
+      case OP_SETCURVAR_ARRAY_CREATE:
+         var = STR.getSTValue();
+
+         // See OP_SETCURVAR
+         prevField = NULL;
+         prevObject = NULL;
+         curObject = NULL;
+
+         gEvalState.setCurVarNameCreate(var);
+
+         // See OP_SETCURVAR for why we do this.
+         curFNDocBlock = NULL;
+         curNSDocBlock = NULL;
+         break;
+
+      case OP_LOADVAR_UINT:
+         intStack[_UINT + 1] = gEvalState.getIntVariable();
+         _UINT++;
+         break;
+
+      case OP_LOADVAR_FLT:
+         floatStack[_FLT + 1] = gEvalState.getFloatVariable();
+         _FLT++;
+         break;
+
+      case OP_LOADVAR_STR:
+         val = gEvalState.getStringVariable();
+         STR.setStringValue(val);
+         break;
+
+      case OP_SAVEVAR_UINT:
+         gEvalState.setIntVariable((S32)intStack[_UINT]);
+         break;
+
+      case OP_SAVEVAR_FLT:
+         gEvalState.setFloatVariable(floatStack[_FLT]);
+         break;
+
+      case OP_SAVEVAR_STR:
+         gEvalState.setStringVariable(STR.getStringValue());
+         break;
+
+      case OP_LOAD_LOCAL_VAR_UINT:
+         reg = code[ip++];
+         intStack[_UINT + 1] = gEvalState.getLocalIntVariable(reg);
+         _UINT++;
+         break;
+
+      case OP_LOAD_LOCAL_VAR_FLT:
+         reg = code[ip++];
+         floatStack[_FLT + 1] = gEvalState.getLocalFloatVariable(reg);
+         _FLT++;
+         break;
+
+      case OP_LOAD_LOCAL_VAR_STR:
+         reg = code[ip++];
+         val = gEvalState.getLocalStringVariable(reg);
+         STR.setStringValue(val);
+         break;
+
+      case OP_SAVE_LOCAL_VAR_UINT:
+         reg = code[ip++];
+         gEvalState.setLocalIntVariable(reg, (S32)intStack[_UINT]);
+         break;
+
+      case OP_SAVE_LOCAL_VAR_FLT:
+         reg = code[ip++];
+         gEvalState.setLocalFloatVariable(reg, floatStack[_FLT]);
+         break;
+
+      case OP_SAVE_LOCAL_VAR_STR:
+         reg = code[ip++];
+         gEvalState.setLocalStringVariable(reg, STR.getStringValue(), (S32)STR.mLen);
+         break;
+
+      case OP_SETCUROBJECT:
+         // Save the previous object for parsing vector fields.
+         prevObject = curObject;
+         val = STR.getStringValue();
+
+         // Sim::findObject will sometimes find valid objects from
+         // multi-component strings. This makes sure that doesn't
+         // happen.
+         for (const char* check = val; *check; check++)
+         {
+            if (*check == ' ')
+            {
+               val = "";
+               break;
+            }
+         }
+         curObject = Sim::findObject(val);
+         break;
+
+      case OP_SETCUROBJECT_INTERNAL:
+         ++ip; // To skip the recurse flag if the object wasnt found
+         if (curObject)
+         {
+            SimGroup* group = dynamic_cast<SimGroup*>(curObject);
+            if (group)
+            {
+               StringTableEntry intName = StringTable->insert(STR.getStringValue());
+               bool recurse = code[ip - 1];
+               SimObject* obj = group->findObjectByInternalName(intName, recurse);
+               intStack[_UINT + 1] = obj ? obj->getId() : 0;
+               _UINT++;
+            }
+            else
+            {
+               Con::errorf(ConsoleLogEntry::Script, "%s: Attempt to use -> on non-group %s of class %s.", getFileLine(ip - 2), curObject->getName(), curObject->getClassName());
+               intStack[_UINT] = 0;
+            }
+         }
+         break;
+
+      case OP_SETCUROBJECT_NEW:
+         curObject = currentNewObject;
+         break;
+
+      case OP_SETCURFIELD:
+         // Save the previous field for parsing vector fields.
+         prevField = curField;
+         dStrcpy(prevFieldArray, curFieldArray, 256);
+         curField = CodeToSTE(code, ip);
+         curFieldArray[0] = 0;
+         ip += 2;
+         break;
+
+      case OP_SETCURFIELD_ARRAY:
+         dStrcpy(curFieldArray, STR.getStringValue(), 256);
+         break;
+
+      case OP_SETCURFIELD_TYPE:
+         if(curObject)
+            curObject->setDataFieldType(code[ip], curField, curFieldArray);
+         ip++;
+         break;
+
+      case OP_LOADFIELD_UINT:
+         if (curObject)
+            intStack[_UINT + 1] = U32(dAtoi(curObject->getDataField(curField, curFieldArray)));
+         else
+         {
+            // The field is not being retrieved from an object. Maybe it's
+            // a special accessor?
+            char buff[FieldBufferSizeNumeric];
+            memset(buff, 0, sizeof(buff));
+            getFieldComponent(prevObject, prevField, prevFieldArray, curField, buff);
+            intStack[_UINT + 1] = dAtoi(buff);
+         }
+         _UINT++;
+         break;
+
+      case OP_LOADFIELD_FLT:
+         if (curObject)
+            floatStack[_FLT + 1] = dAtof(curObject->getDataField(curField, curFieldArray));
+         else
+         {
+            // The field is not being retrieved from an object. Maybe it's
+            // a special accessor?
+            char buff[FieldBufferSizeNumeric];
+            memset(buff, 0, sizeof(buff));
+            getFieldComponent(prevObject, prevField, prevFieldArray, curField, buff);
+            floatStack[_FLT + 1] = dAtof(buff);
+         }
+         _FLT++;
+         break;
+
+      case OP_LOADFIELD_STR:
+         if (curObject)
+         {
+            val = curObject->getDataField(curField, curFieldArray);
+            STR.setStringValue(val);
+         }
+         else
+         {
+            // The field is not being retrieved from an object. Maybe it's
+            // a special accessor?
+            char buff[FieldBufferSizeString];
+            memset(buff, 0, sizeof(buff));
+            getFieldComponent(prevObject, prevField, prevFieldArray, curField, buff);
+            STR.setStringValue(buff);
+         }
+
+         break;
+
+      case OP_SAVEFIELD_UINT:
+         STR.setIntValue((U32)intStack[_UINT]);
+         if (curObject)
+            curObject->setDataField(curField, curFieldArray, STR.getStringValue());
+         else
+         {
+            // The field is not being set on an object. Maybe it's
+            // a special accessor?
+            setFieldComponent( prevObject, prevField, prevFieldArray, curField );
+            prevObject = NULL;
+         }
+         break;
+
+      case OP_SAVEFIELD_FLT:
+         STR.setFloatValue(floatStack[_FLT]);
+         if (curObject)
+            curObject->setDataField(curField, curFieldArray, STR.getStringValue());
+         else
+         {
+            // The field is not being set on an object. Maybe it's
+            // a special accessor?
+            setFieldComponent( prevObject, prevField, prevFieldArray, curField );
+            prevObject = NULL;
+         }
+         break;
+
+      case OP_SAVEFIELD_STR:
+         if (curObject)
+            curObject->setDataField(curField, curFieldArray, STR.getStringValue());
+         else
+         {
+            // The field is not being set on an object. Maybe it's
+            // a special accessor?
+            setFieldComponent( prevObject, prevField, prevFieldArray, curField );
+            prevObject = NULL;
+         }
+         break;
+
+      case OP_STR_TO_UINT:
+         intStack[_UINT + 1] = STR.getIntValue();
+         _UINT++;
+         break;
+
+      case OP_STR_TO_FLT:
+         floatStack[_FLT + 1] = STR.getFloatValue();
+         _FLT++;
+         break;
+
+      case OP_STR_TO_NONE:
+         // This exists simply to deal with certain typecast situations.
+         break;
+
+      case OP_FLT_TO_UINT:
+         intStack[_UINT + 1] = (S64)floatStack[_FLT];
+         _FLT--;
+         _UINT++;
+         break;
+
+      case OP_FLT_TO_STR:
+         STR.setFloatValue(floatStack[_FLT]);
+         _FLT--;
+         break;
+
+      case OP_FLT_TO_NONE:
+         _FLT--;
+         break;
+
+      case OP_UINT_TO_FLT:
+         floatStack[_FLT + 1] = (F64)intStack[_UINT];
+         _UINT--;
+         _FLT++;
+         break;
+
+      case OP_UINT_TO_STR:
+         STR.setIntValue((U32)intStack[_UINT]);
+         _UINT--;
+         break;
+
+      case OP_UINT_TO_NONE:
+         _UINT--;
+         break;
+
+      case OP_LOADIMMED_UINT:
+         intStack[_UINT + 1] = code[ip++];
+         _UINT++;
+         break;
+
+      case OP_LOADIMMED_FLT:
+         floatStack[_FLT + 1] = curFloatTable[code[ip]];
+         ip++;
+         _FLT++;
+         break;
+      case OP_TAG_TO_STR:
+         code[ip - 1] = OP_LOADIMMED_STR;
+         // it's possible the string has already been converted
+         if (U8(curStringTable[code[ip]]) != StringTagPrefixByte)
+         {
+            U32 id = GameAddTaggedString(curStringTable + code[ip]);
+            dSprintf(curStringTable + code[ip] + 1, 7, "%d", id);
+            *(curStringTable + code[ip]) = StringTagPrefixByte;
+         }
+      case OP_LOADIMMED_STR:
+         STR.setStringValue(curStringTable + code[ip++]);
+         break;
+
+      case OP_DOCBLOCK_STR:
+      {
+         // If the first word of the doc is '\class' or '@class', then this
+         // is a namespace doc block, otherwise it is a function doc block.
+         const char* docblock = curStringTable + code[ip++];
+
+         const char* sansClass = dStrstr(docblock, "@class");
+         if (!sansClass)
+            sansClass = dStrstr(docblock, "\\class");
+
+         if (sansClass)
+         {
+            // Don't save the class declaration. Scan past the 'class'
+            // keyword and up to the first whitespace.
+            sansClass += 7;
+            S32 index = 0;
+            while ((*sansClass != ' ') && (*sansClass != '\n') && *sansClass && (index < (nsDocLength - 1)))
+            {
+               nsDocBlockClass[index++] = *sansClass;
+               sansClass++;
+            }
+            nsDocBlockClass[index] = '\0';
+
+            curNSDocBlock = sansClass + 1;
+         }
+         else
+            curFNDocBlock = docblock;
+      }
+
+      break;
+
+      case OP_LOADIMMED_IDENT:
+         STR.setStringValue(CodeToSTE(code, ip));
+         ip += 2;
+         break;
+
+      case OP_CALLFUNC:
+      {
+         // This routingId is set when we query the object as to whether
+         // it handles this method.  It is set to an enum from the table
+         // above indicating whether it handles it on a component it owns
+         // or just on the object.
+         S32 routingId = 0;
+
+         fnName = CodeToSTE(code, ip);
+         fnNamespace = CodeToSTE(code, ip + 2);
+         U32 callType = code[ip + 4];
+
+         //if this is called from inside a function, append the ip and codeptr
+         if (!gEvalState.stack.empty())
+         {
+            gEvalState.stack.last()->code = this;
+            gEvalState.stack.last()->ip = ip - 1;
+         }
+
+         ip += 5;
+         gCallStack.argvc(fnName, callArgc, &callArgv);
+
+         if (callType == FuncCallExprNode::FunctionCall)
+         {
+            // Note: This works even if the function was in a package. Reason being is when
+            // activatePackage() is called, it swaps the namespaceEntry into the global namespace
+            // (and reverts it when deactivatePackage is called). Method or Static related ones work
+            // as expected, as the namespace is resolved on the fly.
+            nsEntry = Namespace::global()->lookup(fnName);
+            if (!nsEntry)
+            {
+               Con::warnf(ConsoleLogEntry::General,
+                  "%s: Unable to find function %s",
+                  getFileLine(ip - 4), fnName);
+               //STR.popFrame();
+               gCallStack.popFrame();
+               break;
+            }
+         }
+         else if (callType == FuncCallExprNode::StaticCall)
+         {
+            // Try to look it up.
+            ns = Namespace::find(fnNamespace);
+            nsEntry = ns->lookup(fnName);
+            if (!nsEntry)
+            {
+               Con::warnf(ConsoleLogEntry::General,
+                  "%s: Unable to find function %s%s%s",
+                  getFileLine(ip - 4), fnNamespace ? fnNamespace : "",
+                  fnNamespace ? "::" : "", fnName);
+               //STR.popFrame();
+               gCallStack.popFrame();
+               break;
+            }
+         }
+         else if (callType == FuncCallExprNode::MethodCall)
+         {
+            saveObject = gEvalState.thisObject;
+
+            // Optimization: If we're an integer, we can lookup the value by SimObjectId
+            const ConsoleValue& simObjectLookupValue = callArgv[1];
+            if (simObjectLookupValue.getType() == ConsoleValueType::cvInteger)
+               gEvalState.thisObject = Sim::findObject(static_cast<SimObjectId>(simObjectLookupValue.getInt()));
+            else
+               gEvalState.thisObject = Sim::findObject(simObjectLookupValue.getString());
+
+            if (gEvalState.thisObject == NULL)
+            {
+               Con::warnf(
+                  ConsoleLogEntry::General,
+                  "%s: Unable to find object: '%s' attempting to call function '%s'",
+                  getFileLine(ip - 6),
+                  simObjectLookupValue.getString(),
+                  fnName
+               );
+               //STR.popFrame();
+               gCallStack.popFrame();
+               STR.setStringValue("");
+               break;
+            }
+
+            ns = gEvalState.thisObject->getNamespace();
+            if (ns)
+               nsEntry = ns->lookup(fnName);
+            else
+               nsEntry = NULL;
+         }
+         else // it's a ParentCall
+         {
+            if (thisNamespace)
+            {
+               ns = thisNamespace->mParent;
+               if (ns)
+                  nsEntry = ns->lookup(fnName);
+               else
+                  nsEntry = NULL;
+            }
+            else
+            {
+               ns = NULL;
+               nsEntry = NULL;
+            }
+         }
+
+         if (!nsEntry || noCalls)
+         {
+            if (!noCalls)
+            {
+               Con::warnf(ConsoleLogEntry::General, "%s: Unknown command %s.", getFileLine(ip - 4), fnName);
+               if (callType == FuncCallExprNode::MethodCall)
+               {
+                  Con::warnf(ConsoleLogEntry::General, "  Object %s(%d) %s",
+                     gEvalState.thisObject->getName() ? gEvalState.thisObject->getName() : "",
+                     gEvalState.thisObject->getId(), Con::getNamespaceList(ns));
+               }
+            }
+            gCallStack.popFrame();
+            STR.setStringValue("");
+            STR.setStringValue("");
+            break;
+         }
+         if (nsEntry->mType == Namespace::Entry::ConsoleFunctionType)
+         {
+            if (nsEntry->mFunctionOffset)
+            {
+               ConsoleValue ret;
+               nsEntry->mCode->exec(nsEntry->mFunctionOffset, fnName, nsEntry->mNamespace, callArgc, callArgv, false, nsEntry->mPackage, ret);
+               STR.setStringValue(ret.getString());
+            }
+            else // no body
+               STR.setStringValue("");
+
+            gCallStack.popFrame();
+         }
+         else
+         {
+            if ((nsEntry->mMinArgs && S32(callArgc) < nsEntry->mMinArgs) || (nsEntry->mMaxArgs && S32(callArgc) > nsEntry->mMaxArgs))
+            {
+               const char* nsName = ns ? ns->mName : "";
+               Con::warnf(ConsoleLogEntry::Script, "%s: %s::%s - wrong number of arguments.", getFileLine(ip - 4), nsName, fnName);
+               Con::warnf(ConsoleLogEntry::Script, "%s: usage: %s", getFileLine(ip - 4), nsEntry->mUsage);
+               gCallStack.popFrame();
+               STR.setStringValue("");
+            }
+            else
+            {
+               switch (nsEntry->mType)
+               {
+               case Namespace::Entry::StringCallbackType:
+               {
+                  const char* ret = nsEntry->cb.mStringCallbackFunc(gEvalState.thisObject, callArgc, callArgv);
+                  gCallStack.popFrame();
+                  if (ret != STR.getStringValue())
+                     STR.setStringValue(ret);
+                  else
+                     STR.setLen(dStrlen(ret));
+                  break;
+               }
+               case Namespace::Entry::IntCallbackType:
+               {
+                  S32 result = nsEntry->cb.mIntCallbackFunc(gEvalState.thisObject, callArgc, callArgv);
+                  gCallStack.popFrame();
+                  if (code[ip] == OP_STR_TO_UINT)
+                  {
+                     ip++;
+                     intStack[++_UINT] = result;
+                     break;
+                  }
+                  else if (code[ip] == OP_STR_TO_FLT)
+                  {
+                     ip++;
+                     floatStack[++_FLT] = result;
+                     break;
+                  }
+                  else if (code[ip] == OP_STR_TO_NONE)
+                     ip++;
+                  else
+                     STR.setIntValue(result);
+                  break;
+               }
+               case Namespace::Entry::FloatCallbackType:
+               {
+                  F64 result = nsEntry->cb.mFloatCallbackFunc(gEvalState.thisObject, callArgc, callArgv);
+                  gCallStack.popFrame();
+                  if (code[ip] == OP_STR_TO_UINT)
+                  {
+                     ip++;
+                     intStack[++_UINT] = (S64)result;
+                     break;
+                  }
+                  else if (code[ip] == OP_STR_TO_FLT)
+                  {
+                     ip++;
+                     floatStack[++_FLT] = result;
+                     break;
+                  }
+                  else if (code[ip] == OP_STR_TO_NONE)
+                     ip++;
+                  else
+                     STR.setFloatValue(result);
+                  break;
+               }
+               case Namespace::Entry::VoidCallbackType:
+               {
+                  nsEntry->cb.mVoidCallbackFunc(gEvalState.thisObject, callArgc, callArgv);
+                  if (code[ip] != OP_STR_TO_NONE)
+                     Con::warnf(ConsoleLogEntry::General, "%s: Call to %s in %s uses result of void function call.", getFileLine(ip - 4), fnName, functionName);
+                  gCallStack.popFrame();
+                  STR.setStringValue("");
+                  break;
+               }
+               case Namespace::Entry::BoolCallbackType:
+               {
+                  bool result = nsEntry->cb.mBoolCallbackFunc(gEvalState.thisObject, callArgc, callArgv);
+                  gCallStack.popFrame();
+                  if (code[ip] == OP_STR_TO_UINT)
+                  {
+                     ip++;
+                     intStack[++_UINT] = result;
+                     break;
+                  }
+                  else if (code[ip] == OP_STR_TO_FLT)
+                  {
+                     ip++;
+                     floatStack[++_FLT] = result;
+                     break;
+                  }
+                  else if (code[ip] == OP_STR_TO_NONE)
+                     ip++;
+                  else
+                     STR.setIntValue(result);
+                  break;
+               }
+               }
+            }
+         }
+
+         if (callType == FuncCallExprNode::MethodCall)
+            gEvalState.thisObject = saveObject;
+         break;
+      }
+      case OP_ADVANCE_STR:
+         STR.advance();
+         break;
+      case OP_ADVANCE_STR_APPENDCHAR:
+         STR.advanceChar(code[ip++]);
+         break;
+
+      case OP_ADVANCE_STR_COMMA:
+         STR.advanceChar('_');
+         break;
+
+      case OP_ADVANCE_STR_NUL:
+         STR.advanceChar(0);
+         break;
+
+      case OP_REWIND_STR:
+         STR.rewind();
+         break;
+
+      case OP_TERMINATE_REWIND_STR:
+         STR.rewindTerminate();
+         break;
+
+      case OP_COMPARE_STR:
+         intStack[++_UINT] = STR.compare();
+         break;
+
+      case OP_PUSH:
+         gCallStack.pushString(STR.getStringValue(), STR.mLen);
+         break;
+
+      case OP_PUSH_UINT:
+         gCallStack.pushInt((U32)intStack[_UINT--]);
+         break;
+
+      case OP_PUSH_FLT:
+         gCallStack.pushFloat(floatStack[_FLT--]);
+         break;
+
+      case OP_PUSH_FRAME:
+         gCallStack.pushFrame(code[ip++]);
+         break;
+
+      case OP_ASSERT:
+      {
+         if (!intStack[_UINT--])
+         {
+            const char* message = curStringTable + code[ip];
+
+            U32 breakLine, inst;
+            findBreakLine(ip - 1, breakLine, inst);
+
+            if (PlatformAssert::processAssert(PlatformAssert::Fatal,
+               name ? name : "eval",
+               breakLine,
+               message))
+            {
+               if (TelDebugger && TelDebugger->isConnected() && breakLine > 0)
+               {
+                  TelDebugger->breakProcess();
+               }
+               else
+                  Platform::debugBreak();
+            }
+         }
+
+         ip++;
+         break;
+      }
+
+      case OP_BREAK:
+      {
+         //append the ip and codeptr before managing the breakpoint!
+         AssertFatal(!gEvalState.stack.empty(), "Empty eval stack on break!");
+         gEvalState.stack.last()->code = this;
+         gEvalState.stack.last()->ip = ip - 1;
+
+         U32 breakLine;
+         findBreakLine(ip - 1, breakLine, instruction);
+         if (!breakLine)
+            goto breakContinue;
+         TelDebugger->executionStopped(this, breakLine);
+
+         goto breakContinue;
+      }
+
+      case OP_ITER_BEGIN_STR:
+      {
+         iterStack[_ITER].mIsStringIter = true;
+         /* fallthrough */
+      }
+
+      case OP_ITER_BEGIN:
+      {
+         StringTableEntry varName = CodeToSTE(code, ip);
+         U32 failIp = code[ip + 2];
+
+         IterStackRecord& iter = iterStack[_ITER];
+
+         iter.mVariable = gEvalState.getCurrentFrame().add(varName);
+
+         if (iter.mIsStringIter)
+         {
+            iter.mData.mStr.mString = STR.getStringValue();
+            iter.mData.mStr.mIndex = 0;
+         }
+         else
+         {
+            // Look up the object.
+
+            SimSet* set;
+            if (!Sim::findObject(STR.getStringValue(), set))
+            {
+               Con::errorf(ConsoleLogEntry::General, "No SimSet object '%s'", STR.getStringValue());
+               Con::errorf(ConsoleLogEntry::General, "Did you mean to use 'foreach$' instead of 'foreach'?");
+               ip = failIp;
+               continue;
+            }
+
+            // Set up.
+
+            iter.mData.mObj.mSet = set;
+            iter.mData.mObj.mIndex = 0;
+         }
+
+         _ITER++;
+         iterDepth++;
+
+         STR.push();
+
+         ip += 3;
+         break;
+      }
+
+      case OP_ITER:
+      {
+         U32 breakIp = code[ip];
+         IterStackRecord& iter = iterStack[_ITER - 1];
+
+         if (iter.mIsStringIter)
+         {
+            const char* str = iter.mData.mStr.mString;
+
+            U32 startIndex = iter.mData.mStr.mIndex;
+            U32 endIndex = startIndex;
+
+            // Break if at end.
+
+            if (!str[startIndex])
+            {
+               ip = breakIp;
+               continue;
+            }
+
+            // Find right end of current component.
+
+            if (!dIsspace(str[endIndex]))
+               do ++endIndex;
+            while (str[endIndex] && !dIsspace(str[endIndex]));
+
+            // Extract component.
+
+            if (endIndex != startIndex)
+            {
+               char savedChar = str[endIndex];
+               const_cast<char*>(str)[endIndex] = '\0'; // We are on the string stack so this is okay.
+               iter.mVariable->setStringValue(&str[startIndex]);
+               const_cast<char*>(str)[endIndex] = savedChar;
+            }
+            else
+               iter.mVariable->setStringValue("");
+
+            // Skip separator.
+            if (str[endIndex] != '\0')
+               ++endIndex;
+
+            iter.mData.mStr.mIndex = endIndex;
+         }
+         else
+         {
+            U32 index = iter.mData.mObj.mIndex;
+            SimSet* set = iter.mData.mObj.mSet;
+
+            if (index >= set->size())
+            {
+               ip = breakIp;
+               continue;
+            }
+
+            iter.mVariable->setIntValue(set->at(index)->getId());
+            iter.mData.mObj.mIndex = index + 1;
+         }
+
+         ++ip;
+         break;
+      }
+
+      case OP_ITER_END:
+      {
+         --_ITER;
+         --iterDepth;
+
+         STR.rewind();
+
+         iterStack[_ITER].mIsStringIter = false;
+         break;
+      }
+
+      case OP_INVALID:
+
+      default:
+         // error!
+         goto execFinished;
+      }
+   }
+execFinished:
+#ifdef TORQUE_DEBUG
+   AssertFatal(returnValue.getType() == ConsoleValueType::cvNone, "returnValue was never set during script exec");
+#endif
+
+   if (telDebuggerOn && setFrame < 0)
+      TelDebugger->popStackFrame();
+
+   if (popFrame)
+   {
+      gEvalState.popFrame();
+   }
+
+   if (argv)
+   {
+      if (gEvalState.traceOn)
+      {
+         traceBuffer[0] = 0;
+         dStrcat(traceBuffer, "Leaving ", TRACE_BUFFER_SIZE);
+
+         if (packageName)
+         {
+            dStrcat(traceBuffer, "[", TRACE_BUFFER_SIZE);
+            dStrcat(traceBuffer, packageName, TRACE_BUFFER_SIZE);
+            dStrcat(traceBuffer, "]", TRACE_BUFFER_SIZE);
+         }
+         if (thisNamespace && thisNamespace->mName)
+         {
+            dSprintf(traceBuffer + dStrlen(traceBuffer), sizeof(traceBuffer) - dStrlen(traceBuffer),
+               "%s::%s() - return %s", thisNamespace->mName, thisFunctionName, returnValue.getString());
+         }
+         else
+         {
+            dSprintf(traceBuffer + dStrlen(traceBuffer), sizeof(traceBuffer) - dStrlen(traceBuffer),
+               "%s() - return %s", thisFunctionName, returnValue.getString());
+         }
+         Con::printf("%s", traceBuffer);
+      }
+   }
+   else
+   {
+      delete[] const_cast<char*>(globalStrings);
+      delete[] globalFloats;
+      globalStrings = NULL;
+      globalFloats = NULL;
+   }
+   smCurrentCodeBlock = saveCodeBlock;
+   if (saveCodeBlock && saveCodeBlock->name)
+   {
+      Con::gCurrentFile = saveCodeBlock->name;
+      Con::gCurrentRoot = saveCodeBlock->modPath;
+   }
+
+   decRefCount();
+
+#ifdef TORQUE_DEBUG
+   AssertFatal(!(STR.mStartStackSize > stackStart), "String stack not popped enough in script exec");
+   AssertFatal(!(STR.mStartStackSize < stackStart), "String stack popped too much in script exec");
+#endif
 }
 
 //------------------------------------------------------------
diff --git a/Engine/source/console/compiler.h b/Engine/source/console/compiler.h
index 26dc93c13..c58fff3e6 100644
--- a/Engine/source/console/compiler.h
+++ b/Engine/source/console/compiler.h
@@ -93,26 +93,28 @@ namespace Compiler
       OP_MUL,
       OP_DIV,
       OP_NEG,
-
       OP_INC,
-      OP_DEC,
 
       OP_SETCURVAR,
       OP_SETCURVAR_CREATE,
       OP_SETCURVAR_ARRAY,
-      OP_SETCURVAR_ARRAY_VARLOOKUP,
       OP_SETCURVAR_ARRAY_CREATE,
-      OP_SETCURVAR_ARRAY_CREATE_VARLOOKUP,
 
       OP_LOADVAR_UINT,// 40
       OP_LOADVAR_FLT,
       OP_LOADVAR_STR,
-      OP_LOADVAR_VAR,
 
       OP_SAVEVAR_UINT,
       OP_SAVEVAR_FLT,
       OP_SAVEVAR_STR,
-      OP_SAVEVAR_VAR,
+
+      OP_LOAD_LOCAL_VAR_UINT,
+      OP_LOAD_LOCAL_VAR_FLT,
+      OP_LOAD_LOCAL_VAR_STR,
+
+      OP_SAVE_LOCAL_VAR_UINT,
+      OP_SAVE_LOCAL_VAR_FLT,
+      OP_SAVE_LOCAL_VAR_STR,
 
       OP_SETCUROBJECT,
       OP_SETCUROBJECT_NEW,
@@ -121,8 +123,6 @@ namespace Compiler
       OP_SETCURFIELD,
       OP_SETCURFIELD_ARRAY, // 50
       OP_SETCURFIELD_TYPE,
-      OP_SETCURFIELD_ARRAY_VAR,
-      OP_SETCURFIELD_THIS,
 
       OP_LOADFIELD_UINT,
       OP_LOADFIELD_FLT,
@@ -141,19 +141,15 @@ namespace Compiler
       OP_UINT_TO_FLT,
       OP_UINT_TO_STR,
       OP_UINT_TO_NONE,
-      OP_COPYVAR_TO_NONE,
 
       OP_LOADIMMED_UINT,
       OP_LOADIMMED_FLT,
       OP_TAG_TO_STR,
       OP_LOADIMMED_STR, // 70
-      OP_DOCBLOCK_STR,
+      OP_DOCBLOCK_STR,  // 76
       OP_LOADIMMED_IDENT,
 
-      OP_CALLFUNC_RESOLVE,
       OP_CALLFUNC,
-      OP_CALLFUNC_POINTER,
-      OP_CALLFUNC_THIS,
 
       OP_ADVANCE_STR,
       OP_ADVANCE_STR_APPENDCHAR,
@@ -166,8 +162,6 @@ namespace Compiler
       OP_PUSH,          // String
       OP_PUSH_UINT,     // Integer
       OP_PUSH_FLT,      // Float
-      OP_PUSH_VAR,      // Variable
-      OP_PUSH_THIS,     // This pointer
       OP_PUSH_FRAME,    // Frame
 
       OP_ASSERT,
diff --git a/Engine/source/console/console.cpp b/Engine/source/console/console.cpp
index 39d4b204d..50bdb5391 100644
--- a/Engine/source/console/console.cpp
+++ b/Engine/source/console/console.cpp
@@ -271,8 +271,6 @@ StringTableEntry gCurrentFile;
 StringTableEntry gCurrentRoot;
 /// @}
 
-S32 gObjectCopyFailures = -1;
-
 bool alwaysUseDebugOutput = true;
 bool useTimestamp = false;
 bool useRealTimestamp = false;
@@ -327,6 +325,7 @@ void init()
 
    // Setup the console types.
    ConsoleBaseType::initialize();
+   ConsoleValue::init();
 
    // And finally, the ACR...
    AbstractClassRep::initialize();
@@ -344,10 +343,6 @@ void init()
    addVariable( "instantGroup", TypeRealString, &gInstantGroup, "The group that objects will be added to when they are created.\n"
       "@ingroup Console\n");
 
-   addVariable("Con::objectCopyFailures", TypeS32, &gObjectCopyFailures, "If greater than zero then it counts the number of object creation "
-      "failures based on a missing copy object and does not report an error..\n"
-      "@ingroup Console\n");   
-
    // Current script file name and root
    addVariable( "Con::File", TypeString, &gCurrentFile, "The currently executing script file.\n"
       "@ingroup FileSystem\n");
@@ -1590,11 +1585,9 @@ ConsoleValueRef _internalExecute(SimObject *object, S32 argc, ConsoleValueRef ar
       ICallMethod *com = dynamic_cast<ICallMethod *>(object);
       if(com)
       {
-         STR.pushFrame();
-         CSTK.pushFrame();
+         gCallStack.pushFrame(0);
          com->callMethodArgList(argc, argv, false);
-         STR.popFrame();
-         CSTK.popFrame();
+         gCallStack.popFrame();
       }
    }
 
@@ -2523,70 +2516,20 @@ DefineEngineFunction( logWarning, void, ( const char* message ),,
 
 //------------------------------------------------------------------------------
 
-extern ConsoleValueStack CSTK;
-
-ConsoleValueRef::ConsoleValueRef(const ConsoleValueRef &ref)
-{
-   value = ref.value;
-}
-
-ConsoleValueRef& ConsoleValueRef::operator=(const ConsoleValueRef &newValue)
-{
-   value = newValue.value;
-   return *this;
-}
-
-ConsoleValueRef& ConsoleValueRef::operator=(const char *newValue)
-{
-   AssertFatal(value, "value should not be NULL");
-   value->setStringValue(newValue);
-   return *this;
-}
-
-ConsoleValueRef& ConsoleValueRef::operator=(S32 newValue)
-{
-   AssertFatal(value, "value should not be NULL");
-   value->setIntValue(newValue);
-   return *this;
-}
-
-ConsoleValueRef& ConsoleValueRef::operator=(U32 newValue)
-{
-   AssertFatal(value, "value should not be NULL");
-   value->setIntValue(newValue);
-   return *this;
-}
-
-ConsoleValueRef& ConsoleValueRef::operator=(F32 newValue)
-{
-   AssertFatal(value, "value should not be NULL");
-   value->setFloatValue(newValue);
-   return *this;
-}
-
-ConsoleValueRef& ConsoleValueRef::operator=(F64 newValue)
-{
-   AssertFatal(value, "value should not be NULL");
-   value->setFloatValue(newValue);
-   return *this;
-}
-
-//------------------------------------------------------------------------------
-
-StringStackWrapper::StringStackWrapper(int targc, ConsoleValueRef targv[])
+ConsoleValueToStringArrayWrapper::ConsoleValueToStringArrayWrapper(int targc, ConsoleValue *targv)
 {
    argv = new const char*[targc];
    argc = targc;
 
-   for (int i=0; i<targc; i++)
+   for (S32 i = 0; i < targc; i++)
    {
-      argv[i] = dStrdup(targv[i]);
+      argv[i] = dStrdup(targv[i].getString());
    }
 }
 
-StringStackWrapper::~StringStackWrapper()
+ConsoleValueToStringArrayWrapper::~ConsoleValueToStringArrayWrapper()
 {
-   for (int i=0; i<argc; i++)
+   for (S32 i = 0; i< argc; i++)
    {
       dFree(argv[i]);
    }
@@ -2594,164 +2537,20 @@ StringStackWrapper::~StringStackWrapper()
 }
 
 
-StringStackConsoleWrapper::StringStackConsoleWrapper(int targc, const char** targ)
+StringArrayToConsoleValueWrapper::StringArrayToConsoleValueWrapper(int targc, const char** targv)
 {
-   argv = new ConsoleValueRef[targc];
-   argvValue = new ConsoleValue[targc];
+   argv = new ConsoleValue[targc];
    argc = targc;
 
-   for (int i=0; i<targc; i++) {
-      argvValue[i].init();
-      argv[i].value = &argvValue[i];
-      argvValue[i].setStackStringValue(targ[i]);
+   for (int i=0; i<targc; i++)
+   {
+      argv[i].setString(targv[i], dStrlen(targv[i]));
    }
 }
 
-StringStackConsoleWrapper::~StringStackConsoleWrapper()
+StringArrayToConsoleValueWrapper::~StringArrayToConsoleValueWrapper()
 {
-   for (int i=0; i<argc; i++)
-   {
-      argv[i] = 0;
-   }
    delete[] argv;
-   delete[] argvValue;
-}
-
-//------------------------------------------------------------------------------
-
-S32 ConsoleValue::getSignedIntValue()
-{
-   if(type <= TypeInternalString)
-      return (S32)fval;
-   else
-      return dAtoi(Con::getData(type, dataPtr, 0, enumTable));
-}
-
-U32 ConsoleValue::getIntValue()
-{
-   if(type <= TypeInternalString)
-      return ival;
-   else
-      return dAtoi(Con::getData(type, dataPtr, 0, enumTable));
-}
-
-F32 ConsoleValue::getFloatValue()
-{
-   if(type <= TypeInternalString)
-      return fval;
-   else
-      return dAtof(Con::getData(type, dataPtr, 0, enumTable));
-}
-
-const char *ConsoleValue::getStringValue()
-{
-   if(type == TypeInternalString || type == TypeInternalStackString)
-      return sval;
-   else if (type == TypeInternalStringStackPtr)
-      return STR.mBuffer + (uintptr_t)sval;
-   else
-   {
-      // We need a string representation, so lets create one
-      const char *internalValue = NULL;
-
-      if(type == TypeInternalFloat)
-         internalValue = Con::getData(TypeF32, &fval, 0);
-      else if(type == TypeInternalInt)
-         internalValue = Con::getData(TypeS32, &ival, 0);
-      else
-         return Con::getData(type, dataPtr, 0, enumTable); // We can't save sval here since it is the same as dataPtr
-
-      if (!internalValue)
-         return "";
-
-      U32 stringLen = dStrlen(internalValue);
-      U32 newLen = ((stringLen + 1) + 15) & ~15; // pad upto next cache line
-      
-      if (bufferLen == 0)
-         sval = (char *) dMalloc(newLen);
-      else if(newLen > bufferLen)
-         sval = (char *) dRealloc(sval, newLen);
-
-      dStrcpy(sval, internalValue, newLen);
-      bufferLen = newLen;
-
-      return sval;
-   }
-}
-
-StringStackPtr ConsoleValue::getStringStackPtr()
-{
-   if (type == TypeInternalStringStackPtr)
-      return (uintptr_t)sval;
-   else
-      return (uintptr_t)-1;
-}
-
-bool ConsoleValue::getBoolValue()
-{
-   if(type == TypeInternalString || type == TypeInternalStackString || type == TypeInternalStringStackPtr)
-      return dAtob(getStringValue());
-   if(type == TypeInternalFloat)
-      return fval > 0;
-   else if(type == TypeInternalInt)
-      return ival > 0;
-   else {
-      const char *value = Con::getData(type, dataPtr, 0, enumTable);
-      return dAtob(value);
-   }
-}
-
-void ConsoleValue::setIntValue(S32 val)
-{
-   setFloatValue(val);
-}
-
-void ConsoleValue::setIntValue(U32 val)
-{
-   if(type <= TypeInternalString)
-   {
-      fval = (F32)val;
-      ival = val;
-      if(bufferLen > 0)
-      {
-         dFree(sval);
-         bufferLen = 0;
-      }
-
-      sval = typeValueEmpty;
-      type = TypeInternalInt;
-   }
-   else
-   {
-      const char *dptr = Con::getData(TypeS32, &val, 0);
-      Con::setData(type, dataPtr, 0, 1, &dptr, enumTable);
-   }
-}
-
-void ConsoleValue::setBoolValue(bool val)
-{
-   return setIntValue(val ? 1 : 0);
-}
-
-void ConsoleValue::setFloatValue(F32 val)
-{
-   if(type <= TypeInternalString)
-   {
-      fval = val;
-      ival = static_cast<U32>(val);
-      if(bufferLen > 0)
-      {
-         dFree(sval);
-         bufferLen = 0;
-      }
-      sval = typeValueEmpty;
-      type = TypeInternalFloat;
-   }
-   else
-   {
-      const char *dptr = Con::getData(TypeF32, &val, 0);
-      Con::setData(type, dataPtr, 0, 1, &dptr, enumTable);
-   }
 }
 
 //------------------------------------------------------------------------------
diff --git a/Engine/source/console/consoleInternal.cpp b/Engine/source/console/consoleInternal.cpp
index 420d5a033..a498be154 100644
--- a/Engine/source/console/consoleInternal.cpp
+++ b/Engine/source/console/consoleInternal.cpp
@@ -183,13 +183,13 @@ void Dictionary::exportVariables(const char *varString, const char *fileName, bo
 
    for (s = sortList.begin(); s != sortList.end(); s++)
    {
-      switch ((*s)->value.type)
+      switch ((*s)->value.getType())
       {
-         case ConsoleValue::TypeInternalInt:
-            dSprintf(buffer, sizeof(buffer), "%s = %d;%s", (*s)->name, (*s)->value.ival, cat);
+         case ConsoleValueType::cvInteger:
+            dSprintf(buffer, sizeof(buffer), "%s = %d;%s", (*s)->name, (*s)->value.getInt(), cat);
             break;
-         case ConsoleValue::TypeInternalFloat:
-            dSprintf(buffer, sizeof(buffer), "%s = %g;%s", (*s)->name, (*s)->value.fval, cat);
+         case ConsoleValueType::cvFloat:
+            dSprintf(buffer, sizeof(buffer), "%s = %g;%s", (*s)->name, (*s)->value.getFloat(), cat);
             break;
          default:
             expandEscape(expandBuffer, (*s)->getStringValue());
@@ -243,13 +243,11 @@ void Dictionary::exportVariables(const char *varString, Vector<String> *names, V
 
       if (values)
       {
-         switch ((*s)->value.type)
+         switch ((*s)->value.getType())
          {
-            case ConsoleValue::TypeInternalInt:
-               values->push_back(String::ToString((*s)->value.ival));
-               break;
-            case ConsoleValue::TypeInternalFloat:
-               values->push_back(String::ToString((*s)->value.fval));
+            case ConsoleValueType::cvInteger:
+            case ConsoleValueType::cvFloat:
+               values->push_back(String((*s)->value.getString()));
                break;
             default:
                expandEscape(expandBuffer, (*s)->getStringValue());
@@ -470,7 +468,6 @@ char *typeValueEmpty = "";
 Dictionary::Entry::Entry(StringTableEntry in_name)
 {
    name = in_name;
-   value.type = ConsoleValue::TypeInternalString;
    notify = NULL;
    nextEntry = NULL;
    mUsage = NULL;
@@ -508,150 +505,6 @@ const char *Dictionary::getVariable(StringTableEntry name, bool *entValid)
    return "";
 }
 
-void ConsoleValue::setStringValue(const char * value)
-{
-   if (value == NULL) value = typeValueEmpty;
-
-   if (type <= ConsoleValue::TypeInternalString)
-   {
-      // Let's not remove empty-string-valued global vars from the dict.
-      // If we remove them, then they won't be exported, and sometimes
-      // it could be necessary to export such a global.  There are very
-      // few empty-string global vars so there's no performance-related
-      // need to remove them from the dict.
-      /*
-      if(!value[0] && name[0] == '$')
-      {
-      gEvalState.globalVars.remove(this);
-      return;
-      }
-      */
-      if (value == typeValueEmpty)
-      {
-         if (bufferLen > 0)
-         {
-            dFree(sval);
-            bufferLen = 0;
-         }
-
-         sval = typeValueEmpty;
-         fval = 0.f;
-         ival = 0;
-         type = TypeInternalString;
-         return;
-      }
-
-      U32 stringLen = dStrlen(value);
-
-      // If it's longer than 256 bytes, it's certainly not a number.
-      //
-      // (This decision may come back to haunt you. Shame on you if it
-      // does.)
-      if (stringLen < 256)
-      {
-         fval = dAtof(value);
-         ival = dAtoi(value);
-      }
-      else
-      {
-         fval = 0.f;
-         ival = 0;
-      }
-
-      // may as well pad to the next cache line
-      U32 newLen = ((stringLen + 1) + 15) & ~15;
-
-      if (bufferLen == 0)
-         sval = (char *)dMalloc(newLen);
-      else if (newLen > bufferLen)
-         sval = (char *)dRealloc(sval, newLen);
-
-      type = TypeInternalString;
-
-      bufferLen = newLen;
-      dStrcpy(sval, value, newLen);
-   }
-   else
-      Con::setData(type, dataPtr, 0, 1, &value, enumTable);
-}
-
-
-void ConsoleValue::setStackStringValue(const char *value)
-{
-   if (value == NULL) value = typeValueEmpty;
-
-   if (type <= ConsoleValue::TypeInternalString)
-   {
-      // sval might still be temporarily present so we need to check and free it
-      if (bufferLen > 0)
-      {
-         dFree(sval);
-         bufferLen = 0;
-      }
-
-      if (value == typeValueEmpty)
-      {
-         sval = typeValueEmpty;
-         fval = 0.f;
-         ival = 0;
-         type = TypeInternalString;
-         return;
-      }
-
-      U32 stringLen = dStrlen(value);
-      if (stringLen < 256)
-      {
-         fval = dAtof(value);
-         ival = dAtoi(value);
-      }
-      else
-      {
-         fval = 0.f;
-         ival = 0;
-      }
-
-      type = TypeInternalStackString;
-      sval = (char*)value;
-      bufferLen = 0;
-   }
-   else
-      Con::setData(type, dataPtr, 0, 1, &value, enumTable);
-}
-
-void ConsoleValue::setStringStackPtrValue(StringStackPtr ptrValue)
-{
-   if (type <= ConsoleValue::TypeInternalString)
-   {
-      const char *value = StringStackPtrRef(ptrValue).getPtr(&STR);
-      if (bufferLen > 0)
-      {
-         dFree(sval);
-         bufferLen = 0;
-      }
-
-      U32 stringLen = dStrlen(value);
-      if (stringLen < 256)
-      {
-         fval = dAtof(value);
-         ival = dAtoi(value);
-      }
-      else
-      {
-         fval = 0.f;
-         ival = 0;
-      }
-
-      type = TypeInternalStringStackPtr;
-      sval = (char*)(value - STR.mBuffer);
-      bufferLen = 0;
-   }
-   else
-   {
-      const char *value = StringStackPtrRef(ptrValue).getPtr(&STR);
-      Con::setData(type, dataPtr, 0, 1, &value, enumTable);
-   }
-}
-
 S32 Dictionary::getIntVariable(StringTableEntry name, bool *entValid)
 {
    Entry *ent = lookup(name);
diff --git a/Engine/source/console/consoleInternal.h b/Engine/source/console/consoleInternal.h
index 129da9dfb..151a75ac2 100644
--- a/Engine/source/console/consoleInternal.h
+++ b/Engine/source/console/consoleInternal.h
@@ -324,17 +324,17 @@ public:
 
       inline U32 getIntValue()
       {
-         return value.getIntValue();
+         return value.getInt();
       }
 
       inline F32 getFloatValue()
       {
-         return value.getFloatValue();
+         return value.getFloat();
       }
 
       inline const char *getStringValue()
       {
-         return value.getStringValue();
+         return value.getString();
       }
 
       void setIntValue(U32 val)
@@ -345,7 +345,7 @@ public:
             return;
          }
 
-         value.setIntValue(val);
+         value.setInt(val);
 
          // Fire off the notification if we have one.
          if (notify)
@@ -360,23 +360,7 @@ public:
             return;
          }
 
-         value.setFloatValue(val);
-
-         // Fire off the notification if we have one.
-         if (notify)
-            notify->trigger();
-      }
-
-      void setStringStackPtrValue(StringStackPtr newValue)
-      {
-         if (mIsConstant)
-         {
-            Con::errorf("Cannot assign value to constant '%s'.", name);
-            return;
-         }
-
-         value.setStringStackPtrValue(newValue);
-
+         value.setFloat(val);
 
          // Fire off the notification if we have one.
          if (notify)
@@ -391,8 +375,7 @@ public:
             return;
          }
 
-         value.setStringValue(newValue);
-
+         value.setString(newValue, dStrlen(newValue));
 
          // Fire off the notification if we have one.
          if (notify)
@@ -471,6 +454,18 @@ public:
    void validate();
 };
 
+struct ConsoleValueFrame
+{
+   ConsoleValue* values;
+   bool isReference;
+
+   ConsoleValueFrame(ConsoleValue* vals, bool isRef)
+   {
+      values = vals;
+      isReference = isRef;
+   }
+};
+
 class ExprEvalState
 {
 public:
@@ -499,6 +494,9 @@ public:
    /// an interior pointer that will become invalid when the object changes address.
    Vector< Dictionary* > stack;
 
+   Vector< ConsoleValueFrame > localStack;
+   ConsoleValueFrame* currentRegisterArray; // contains array at to top of localStack
+
    ///
    Dictionary globalVars;
 
@@ -511,10 +509,43 @@ public:
    void setIntVariable(S32 val);
    void setFloatVariable(F64 val);
    void setStringVariable(const char *str);
-   void setStringStackPtrVariable(StringStackPtr str);
-   void setCopyVariable();
 
-   void pushFrame(StringTableEntry frameName, Namespace *ns);
+   TORQUE_FORCEINLINE S32 getLocalIntVariable(S32 reg)
+   {
+      return currentRegisterArray->values[reg].getInt();
+   }
+
+   TORQUE_FORCEINLINE F64 getLocalFloatVariable(S32 reg)
+   {
+      return currentRegisterArray->values[reg].getFloat();
+   }
+
+   TORQUE_FORCEINLINE const char* getLocalStringVariable(S32 reg)
+   {
+      return currentRegisterArray->values[reg].getString();
+   }
+
+   TORQUE_FORCEINLINE void setLocalIntVariable(S32 reg, S64 val)
+   {
+      currentRegisterArray->values[reg].setInt(val);
+   }
+
+   TORQUE_FORCEINLINE void setLocalFloatVariable(S32 reg, F64 val)
+   {
+      currentRegisterArray->values[reg].setFloat(val);
+   }
+
+   TORQUE_FORCEINLINE void setLocalStringVariable(S32 reg, const char* val, S32 len)
+   {
+      currentRegisterArray->values[reg].setString(val, len);
+   }
+
+   TORQUE_FORCEINLINE void setLocalStringTableEntryVariable(S32 reg, StringTableEntry val)
+   {
+      currentRegisterArray->values[reg].setStringTableEntry(val);
+   }
+
+   void pushFrame(StringTableEntry frameName, Namespace *ns, S32 regCount);
    void popFrame();
 
    /// Puts a reference to an existing stack frame
diff --git a/Engine/source/console/consoleLogger.cpp b/Engine/source/console/consoleLogger.cpp
index fc2095eae..d68cdb6c0 100644
--- a/Engine/source/console/consoleLogger.cpp
+++ b/Engine/source/console/consoleLogger.cpp
@@ -79,18 +79,18 @@ void ConsoleLogger::initPersistFields()
 
 //-----------------------------------------------------------------------------
 
-bool ConsoleLogger::processArguments( S32 argc, ConsoleValueRef *argv )
+bool ConsoleLogger::processArguments( S32 argc, ConsoleValue *argv )
 {
    if( argc == 0 )
       return false;
 
    bool append = false;
 
-   if( argc == 2 )
-      append = dAtob( argv[1] );
+   if (argc == 2)
+      append = argv[1].getBool();
 
    mAppend = append;
-   mFilename = StringTable->insert( argv[0] );
+   mFilename = StringTable->insert( argv[0].getString() );
 
    if( init() )
    {
diff --git a/Engine/source/console/consoleLogger.h b/Engine/source/console/consoleLogger.h
index 901f45b17..e969f3ac1 100644
--- a/Engine/source/console/consoleLogger.h
+++ b/Engine/source/console/consoleLogger.h
@@ -81,7 +81,7 @@ class ConsoleLogger : public SimObject
       /// // Example script constructor usage.
       /// %obj = new ConsoleLogger( objName, logFileName, [append = false] );
       /// @endcode
-      bool processArguments( S32 argc, ConsoleValueRef *argv );
+      bool processArguments( S32 argc, ConsoleValue *argv );
 
       /// Default constructor, make sure to initalize
       ConsoleLogger();
diff --git a/Engine/source/console/consoleValueStack.h b/Engine/source/console/consoleValueStack.h
new file mode 100644
index 000000000..b88804dd5
--- /dev/null
+++ b/Engine/source/console/consoleValueStack.h
@@ -0,0 +1,121 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2013 GarageGames, LLC
+// Copyright (c) 2021 TGEMIT Authors & Contributors
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+
+#ifndef _CONSOLE_CONSOLE_VALUE_STACK_H_
+#define _CONSOLE_CONSOLE_VALUE_STACK_H_
+
+template<S32 StackSize>
+class ConsoleValueStack
+{
+   constexpr static S32 allocatorSize = sizeof(ConsoleValue) * StackSize;
+
+   struct Frame
+   {
+      ConsoleValue* values;
+      S32 count;
+      S32 internalCounter;
+   };
+
+   Vector<Frame> stack;
+   char* memory;
+   S32 sp;
+
+   TORQUE_FORCEINLINE Frame alloc(S32 count)
+   {
+      AssertFatal(sp + count * sizeof(ConsoleValue) < allocatorSize, "ConsoleValueStack overflow");
+
+      ConsoleValue* ret = reinterpret_cast<ConsoleValue*>(memory + sp);
+      sp += count * sizeof(ConsoleValue);
+
+      return { ret, count, 1 };
+   }
+
+   TORQUE_FORCEINLINE void deAlloc(S32 count)
+   {
+      sp -= count * sizeof(ConsoleValue);
+      AssertFatal(sp >= 0, "Popped ConsoleValueStack too far, underflow");
+   }
+
+public:
+   ConsoleValueStack()
+   {
+      memory = (char*)dMalloc(allocatorSize);
+      for (S32 i = 0; i < allocatorSize; i += sizeof(ConsoleValue))
+      {
+         constructInPlace<ConsoleValue>(reinterpret_cast<ConsoleValue*>(memory + i));
+      }
+      sp = 0;
+   }
+
+   ~ConsoleValueStack()
+   {
+      dFree(memory);
+   }
+
+   TORQUE_FORCEINLINE void pushFrame(S32 count)
+   {
+      AssertISV(count >= 0, "Must be >= 0 when pushing stack frame");
+
+      // +1 for function name in argv[0]
+      const Frame& frame = alloc(count + 1);
+      stack.push_back(frame);
+   }
+
+   TORQUE_FORCEINLINE void popFrame()
+   {
+      AssertISV(stack.size() > 0, "Stack Underflow");
+
+      deAlloc(stack.last().count);
+      stack.pop_back();
+   }
+
+   TORQUE_FORCEINLINE void pushInt(S64 value)
+   {
+      Frame& frame = stack.last();
+      frame.values[frame.internalCounter++].setInt(value);
+   }
+
+   TORQUE_FORCEINLINE void pushFloat(F64 value)
+   {
+      Frame& frame = stack.last();
+      frame.values[frame.internalCounter++].setFloat(value);
+   }
+
+   TORQUE_FORCEINLINE void pushString(const char* value, S32 len)
+   {
+      Frame& frame = stack.last();
+      frame.values[frame.internalCounter++].setString(value, len);
+   }
+
+   TORQUE_FORCEINLINE void argvc(StringTableEntry fn, S32& argc, ConsoleValue** argv)
+   {
+      Frame& frame = stack.last();
+      argc = frame.count;
+
+      // First param is always function name
+      frame.values[0].setStringTableEntry(fn);
+      *argv = frame.values;
+   }
+};
+
+#endif
diff --git a/Engine/source/console/sim.h b/Engine/source/console/sim.h
index d43c14b1e..61ff469e0 100644
--- a/Engine/source/console/sim.h
+++ b/Engine/source/console/sim.h
@@ -125,15 +125,12 @@ namespace Sim
    SimDataBlockGroup *getDataBlockGroup();
    SimGroup* getRootGroup();
 
-   SimObject* findObject(ConsoleValueRef&);
    SimObject* findObject(SimObjectId);
+   SimObject* findObject(const ConsoleValue&);
+   SimObject* findObject(ConsoleValue*);
    SimObject* findObject(const char* name);
    SimObject* findObject(const char* fileName, S32 declarationLine);
-   template<class T> inline bool findObject(ConsoleValueRef &ref,T*&t)
-   {
-      t = dynamic_cast<T*>(findObject(ref));
-      return t != NULL;
-   }
+
    template<class T> inline bool findObject(SimObjectId iD,T*&t)
    {
       t = dynamic_cast<T*>(findObject(iD));
diff --git a/Engine/source/console/simManager.cpp b/Engine/source/console/simManager.cpp
index fc8a77edd..b874f752e 100644
--- a/Engine/source/console/simManager.cpp
+++ b/Engine/source/console/simManager.cpp
@@ -328,11 +328,6 @@ SimObject* findObject(const char* fileName, S32 declarationLine)
    return gRootGroup->findObjectByLineNumber(fileName, declarationLine, true);
 }
 
-SimObject* findObject(ConsoleValueRef &ref)
-{
-   return findObject((const char*)ref);
-}
-
 SimObject* findObject(const char* name)
 {
    PROFILE_SCOPE(SimFindObject);
@@ -391,6 +386,24 @@ SimObject* findObject(const char* name)
    return obj->findObject(name + len + 1);
 }
 
+SimObject* findObject(const ConsoleValue &val)
+{
+   if (val.getType() == ConsoleValueType::cvNone)
+      return NULL;
+   if (val.getType() == ConsoleValueType::cvInteger)
+      return findObject((SimObjectId)val.getInt());
+   return findObject(val.getString());
+}
+
+SimObject* findObject(ConsoleValue* val)
+{
+   if (val->getType() == ConsoleValueType::cvNone)
+      return NULL;
+   if (val->getType() == ConsoleValueType::cvInteger)
+      return findObject((SimObjectId)val->getInt());
+   return findObject(val->getString());
+}
+
 SimObject* findObject(SimObjectId id)
 {
    return gIdDictionary->find(id);
diff --git a/Engine/source/console/simSet.cpp b/Engine/source/console/simSet.cpp
index 06024c2c6..32f564ff5 100644
--- a/Engine/source/console/simSet.cpp
+++ b/Engine/source/console/simSet.cpp
@@ -229,11 +229,16 @@ void SimSet::scriptSort( const String &scriptCallbackFn )
 
 //-----------------------------------------------------------------------------
 
-void SimSet::callOnChildren( const String &method, S32 argc, ConsoleValueRef argv[], bool executeOnChildGroups )
+void SimSet::callOnChildren( const String &method, S32 argc, ConsoleValue argv[], bool executeOnChildGroups )
 {
+   // TODO(JTH): Implement
+   AssertISV(false, "TODO Implement");
+   return;
+
+   /*
    // Prep the arguments for the console exec...
    // Make sure and leave args[1] empty.
-   ConsoleValueRef args[21] = { };
+   ConsoleValue args[21] = { };
    ConsoleValue name_method;
    name_method.setStackStringValue(method.c_str());
    args[0] = ConsoleValueRef::fromValue(&name_method);
@@ -255,6 +260,7 @@ void SimSet::callOnChildren( const String &method, S32 argc, ConsoleValueRef arg
             childSet->callOnChildren( method, argc, argv, executeOnChildGroups );
       }
    }
+   */
 }
 
 //-----------------------------------------------------------------------------
@@ -838,7 +844,7 @@ SimGroup* SimGroup::deepClone()
 
 //-----------------------------------------------------------------------------
 
-bool SimGroup::processArguments(S32, ConsoleValueRef *argv)
+bool SimGroup::processArguments(S32, ConsoleValue *argv)
 {
    return true;
 }
diff --git a/Engine/source/console/simSet.h b/Engine/source/console/simSet.h
index 01f636662..b1f8c3f24 100644
--- a/Engine/source/console/simSet.h
+++ b/Engine/source/console/simSet.h
@@ -218,7 +218,7 @@ class SimSet : public SimObject, public TamlChildren
       
       /// @}
 
-      void callOnChildren( const String &method, S32 argc, ConsoleValueRef argv[], bool executeOnChildGroups = true );
+      void callOnChildren( const String &method, S32 argc, ConsoleValue argv[], bool executeOnChildGroups = true );
 
       /// Return the number of objects in this set as well as all sets that are contained
       /// in this set and its children.
@@ -464,7 +464,7 @@ class SimGroup: public SimSet
       virtual SimObject* findObject(const char* name);
       virtual void onRemove();
 
-      virtual bool processArguments( S32 argc, ConsoleValueRef *argv );
+      virtual bool processArguments( S32 argc, ConsoleValue *argv );
 
       virtual SimObject* getObject(const S32& index);
 
diff --git a/Engine/source/console/stringStack.cpp b/Engine/source/console/stringStack.cpp
index 96aef1c86..cfe2d83f5 100644
--- a/Engine/source/console/stringStack.cpp
+++ b/Engine/source/console/stringStack.cpp
@@ -207,228 +207,3 @@ void StringStack::clearFrames()
    mStartStackSize = 0;
    mFunctionOffset = 0;
 }
-
-
-void ConsoleValueStack::getArgcArgv(StringTableEntry name, U32 *argc, ConsoleValueRef **in_argv, bool popStackFrame /* = false */)
-{
-   U32 startStack = mStackFrames[mFrame-1];
-   U32 argCount   = getMin(mStackPos - startStack, (U32)MaxArgs - 1);
-
-   *in_argv = mArgv;
-   mArgv[0].value = CSTK.pushStackString(name);
-   
-   for(U32 i = 0; i < argCount; i++) {
-      ConsoleValueRef *ref = &mArgv[i+1];
-      ref->value = &mStack[startStack + i];
-   }
-   argCount++;
-   
-   *argc = argCount;
-
-   if(popStackFrame)
-      popFrame();
-}
-
-ConsoleValueStack::ConsoleValueStack() : 
-mFrame(0),
-mStackPos(0)
-{
-   for (int i=0; i<ConsoleValueStack::MaxStackDepth; i++) {
-      mStack[i].init();
-      mStack[i].type = ConsoleValue::TypeInternalString;
-   }
-   dMemset(mStackFrames, 0, sizeof(mStackFrames));
-}
-
-ConsoleValueStack::~ConsoleValueStack()
-{
-}
-
-void ConsoleValueStack::pushVar(ConsoleValue *variable)
-{
-   if (mStackPos == ConsoleValueStack::MaxStackDepth) {
-      AssertFatal(false, "Console Value Stack is empty");
-      return;
-   }
-
-   switch (variable->type)
-   {
-   case ConsoleValue::TypeInternalInt:
-      mStack[mStackPos++].setIntValue((S32)variable->getIntValue());
-   case ConsoleValue::TypeInternalFloat:
-      mStack[mStackPos++].setFloatValue((F32)variable->getFloatValue());
-   default:
-      mStack[mStackPos++].setStackStringValue(variable->getStringValue());
-   }
-}
-
-void ConsoleValueStack::pushValue(ConsoleValue &variable)
-{
-   if (mStackPos == ConsoleValueStack::MaxStackDepth) {
-      AssertFatal(false, "Console Value Stack is empty");
-      return;
-   }
-
-   switch (variable.type)
-   {
-   case ConsoleValue::TypeInternalInt:
-      mStack[mStackPos++].setIntValue((S32)variable.getIntValue());
-   case ConsoleValue::TypeInternalFloat:
-      mStack[mStackPos++].setFloatValue((F32)variable.getFloatValue());
-   case ConsoleValue::TypeInternalStringStackPtr:
-      mStack[mStackPos++].setStringStackPtrValue(variable.getStringStackPtr());
-   default:
-      mStack[mStackPos++].setStringValue(variable.getStringValue());
-   }
-}
-
-ConsoleValue* ConsoleValueStack::reserveValues(U32 count)
-{
-   U32 startPos = mStackPos;
-   if (startPos+count >= ConsoleValueStack::MaxStackDepth) {
-      AssertFatal(false, "Console Value Stack is empty");
-      return NULL;
-   }
-
-   //Con::printf("[%i]CSTK reserveValues %i", mStackPos, count);
-   mStackPos += count;
-   return &mStack[startPos];
-}
-
-bool ConsoleValueStack::reserveValues(U32 count, ConsoleValueRef *outValues)
-{
-   U32 startPos = mStackPos;
-   if (startPos+count >= ConsoleValueStack::MaxStackDepth) {
-      AssertFatal(false, "Console Value Stack is empty");
-      return false;
-   }
-
-   //Con::printf("[%i]CSTK reserveValues %i", mStackPos, count);
-   for (U32 i=0; i<count; i++)
-   {
-      outValues[i].value = &mStack[mStackPos+i];
-   }
-   mStackPos += count;
-   return true;
-}
-
-ConsoleValue *ConsoleValueStack::pushString(const char *value)
-{
-   if (mStackPos == ConsoleValueStack::MaxStackDepth) {
-      AssertFatal(false, "Console Value Stack is empty");
-      return NULL;
-   }
-
-   //Con::printf("[%i]CSTK pushString %s", mStackPos, value);
-
-   mStack[mStackPos++].setStringValue(value);
-   return &mStack[mStackPos-1];
-}
-
-ConsoleValue *ConsoleValueStack::pushStackString(const char *value)
-{
-   if (mStackPos == ConsoleValueStack::MaxStackDepth) {
-      AssertFatal(false, "Console Value Stack is empty");
-      return NULL;
-   }
-
-   //Con::printf("[%i]CSTK pushString %s", mStackPos, value);
-
-   mStack[mStackPos++].setStackStringValue(value);
-   return &mStack[mStackPos-1];
-}
-
-ConsoleValue *ConsoleValueStack::pushStringStackPtr(StringStackPtr value)
-{
-   if (mStackPos == ConsoleValueStack::MaxStackDepth) {
-      AssertFatal(false, "Console Value Stack is empty");
-      return NULL;
-   }
-
-   //Con::printf("[%i]CSTK pushStringStackPtr %s", mStackPos, StringStackPtrRef(value).getPtr(&STR));
-
-   mStack[mStackPos++].setStringStackPtrValue(value);
-   return &mStack[mStackPos-1];
-}
-
-ConsoleValue *ConsoleValueStack::pushUINT(U32 value)
-{
-   if (mStackPos == ConsoleValueStack::MaxStackDepth) {
-      AssertFatal(false, "Console Value Stack is empty");
-      return NULL;
-   }
-
-   //Con::printf("[%i]CSTK pushUINT %i", mStackPos, value);
-
-   mStack[mStackPos++].setIntValue(value);
-   return &mStack[mStackPos-1];
-}
-
-ConsoleValue *ConsoleValueStack::pushFLT(float value)
-{
-   if (mStackPos == ConsoleValueStack::MaxStackDepth) {
-      AssertFatal(false, "Console Value Stack is empty");
-      return NULL;
-   }
-
-   //Con::printf("[%i]CSTK pushFLT %f", mStackPos, value);
-
-   mStack[mStackPos++].setFloatValue(value);
-   return &mStack[mStackPos-1];
-}
-
-static ConsoleValue gNothing;
-
-ConsoleValue* ConsoleValueStack::pop()
-{
-   if (mStackPos == 0) {
-      AssertFatal(false, "Console Value Stack is empty");
-      return &gNothing;
-   }
-
-   return &mStack[--mStackPos];
-}
-
-void ConsoleValueStack::pushFrame()
-{
-   //Con::printf("CSTK pushFrame[%i] (%i)", mFrame, mStackPos);
-   mStackFrames[mFrame++] = mStackPos;
-}
-
-void ConsoleValueStack::resetFrame()
-{
-   if (mFrame == 0) {
-      mStackPos = 0;
-      return;
-   }
-
-   U32 start = mStackFrames[mFrame-1];
-   //for (U32 i=start; i<mStackPos; i++) {
-      //mStack[i].clear();
-   //}
-   mStackPos = start;
-   //Con::printf("CSTK resetFrame to %i", mStackPos);
-}
-
-void ConsoleValueStack::clearFrames()
-{
-   mStackPos = 0;
-   mFrame = 0;
-}
-
-void ConsoleValueStack::popFrame()
-{
-   //Con::printf("CSTK popFrame");
-   if (mFrame == 0) {
-      // Go back to start
-      mStackPos = 0;
-      return;
-   }
-
-   U32 start = mStackFrames[mFrame-1];
-   //for (U32 i=start; i<mStackPos; i++) {
-      //mStack[i].clear();
-   //}
-   mStackPos = start;
-   mFrame--;
-}
diff --git a/Engine/source/console/stringStack.h b/Engine/source/console/stringStack.h
index f8a300143..1cb8a5bc0 100644
--- a/Engine/source/console/stringStack.h
+++ b/Engine/source/console/stringStack.h
@@ -189,51 +189,7 @@ struct StringStack
    void getArgcArgv(StringTableEntry name, U32 *argc, const char ***in_argv, bool popStackFrame = false);
 };
 
-
-// New console value stack
-class ConsoleValueStack
-{
-   enum {
-      MaxStackDepth = 1024,
-      MaxArgs = 20,
-      ReturnBufferSpace = 512
-   };
-
-public:
-   ConsoleValueStack();
-   ~ConsoleValueStack();
-
-   void pushVar(ConsoleValue *variable);
-   void pushValue(ConsoleValue &value);
-   ConsoleValue* reserveValues(U32 numValues);
-   bool reserveValues(U32 numValues, ConsoleValueRef *values);
-   ConsoleValue* pop();
-
-   ConsoleValue *pushString(const char *value);
-   ConsoleValue *pushStackString(const char *value);
-   ConsoleValue *pushStringStackPtr(StringStackPtr ptr);
-   ConsoleValue *pushUINT(U32 value);
-   ConsoleValue *pushFLT(float value);
-
-   void pushFrame();
-   void popFrame();
-
-   void resetFrame();
-   void clearFrames();
-
-   void getArgcArgv(StringTableEntry name, U32 *argc, ConsoleValueRef **in_argv, bool popStackFrame = false);
-
-   ConsoleValue mStack[MaxStackDepth];
-   U32 mStackFrames[MaxStackDepth];
-
-   U32 mFrame;
-   U32 mStackPos;
-
-   ConsoleValueRef mArgv[MaxArgs];
-};
-
 extern StringStack STR;
-extern ConsoleValueStack CSTK;
 
 inline char* StringStackPtrRef::getPtr(StringStack *stk) { return stk->mBuffer + mOffset; }
 
diff --git a/Engine/source/console/test/ScriptTest.cpp b/Engine/source/console/test/ScriptTest.cpp
index 994606783..b0674765b 100644
--- a/Engine/source/console/test/ScriptTest.cpp
+++ b/Engine/source/console/test/ScriptTest.cpp
@@ -20,6 +20,7 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
+#ifdef 0
 #ifdef TORQUE_TESTS_ENABLED
 #include "testing/unitTesting.h"
 #include "platform/platform.h"
@@ -393,3 +394,4 @@ TEST(Script, Basic_Package)
 }
 
 #endif
+#endif
diff --git a/Engine/source/console/test/consoleTest.cpp b/Engine/source/console/test/consoleTest.cpp
index adea797a2..d1ced9ec9 100644
--- a/Engine/source/console/test/consoleTest.cpp
+++ b/Engine/source/console/test/consoleTest.cpp
@@ -1,3 +1,5 @@
+#ifdef 0
+
 #ifdef TORQUE_TESTS_ENABLED
 #include "testing/unitTesting.h"
 #include "platform/platform.h"
@@ -253,3 +255,4 @@ TEST(Con, execute)
 }
 
 #endif
+#endif
diff --git a/Engine/source/console/test/engineAPITest.cpp b/Engine/source/console/test/engineAPITest.cpp
index 48e780531..32981e260 100644
--- a/Engine/source/console/test/engineAPITest.cpp
+++ b/Engine/source/console/test/engineAPITest.cpp
@@ -1,3 +1,4 @@
+#if 0
 #ifdef TORQUE_TESTS_ENABLED
 #include "testing/unitTesting.h"
 #include "platform/platform.h"
@@ -147,4 +148,5 @@ TEST(EngineAPI, _EngineConsoleExecCallbackHelper)
 		"All values should be printed in the correct order";
 }
 
-#endif
\ No newline at end of file
+#endif
+#endif
diff --git a/Engine/source/core/strings/stringFunctions.h b/Engine/source/core/strings/stringFunctions.h
index 918273423..d0c91b734 100644
--- a/Engine/source/core/strings/stringFunctions.h
+++ b/Engine/source/core/strings/stringFunctions.h
@@ -200,6 +200,11 @@ inline F64 dAtod(const char *str)
    return strtod(str, NULL);
 }
 
+inline S64 dAtol(const char* str)
+{
+   return strtol(str, NULL, 10);
+}
+
 inline char dToupper(const char c)
 {
    return toupper( c );
diff --git a/Engine/source/environment/waterObject.cpp b/Engine/source/environment/waterObject.cpp
index 1d3da4aeb..f03bf0636 100644
--- a/Engine/source/environment/waterObject.cpp
+++ b/Engine/source/environment/waterObject.cpp
@@ -411,7 +411,7 @@ void WaterObject::inspectPostApply()
    setMaskBits( UpdateMask | WaveMask | TextureMask | SoundMask );
 }
 
-bool WaterObject::processArguments( S32 argc, ConsoleValueRef *argv )
+bool WaterObject::processArguments( S32 argc, ConsoleValue *argv )
 {
    if( typeid( *this ) == typeid( WaterObject ) )
    {
diff --git a/Engine/source/environment/waterObject.h b/Engine/source/environment/waterObject.h
index 94862e4c6..15e7b0d40 100644
--- a/Engine/source/environment/waterObject.h
+++ b/Engine/source/environment/waterObject.h
@@ -156,7 +156,7 @@ public:
    virtual bool onAdd();
    virtual void onRemove();
    virtual void inspectPostApply();
-   virtual bool processArguments(S32 argc, ConsoleValueRef *argv);
+   virtual bool processArguments(S32 argc, ConsoleValue *argv);
 
    // NetObject
    virtual U32  packUpdate( NetConnection * conn, U32 mask, BitStream *stream );
diff --git a/Engine/source/gui/core/guiControl.cpp b/Engine/source/gui/core/guiControl.cpp
index 7e0f27791..2011aa68b 100644
--- a/Engine/source/gui/core/guiControl.cpp
+++ b/Engine/source/gui/core/guiControl.cpp
@@ -319,7 +319,7 @@ void GuiControl::initPersistFields()
 
 //-----------------------------------------------------------------------------
 
-bool GuiControl::processArguments(S32 argc, ConsoleValueRef *argv)
+bool GuiControl::processArguments(S32 argc, ConsoleValue *argv)
 {
    // argv[0] - The GuiGroup to add this control to when it's created.  
    //           this is an optional parameter that may be specified at
diff --git a/Engine/source/gui/core/guiControl.h b/Engine/source/gui/core/guiControl.h
index 997213f75..e0b3c0a76 100644
--- a/Engine/source/gui/core/guiControl.h
+++ b/Engine/source/gui/core/guiControl.h
@@ -341,7 +341,7 @@ class GuiControl : public SimGroup
       
       GuiControl();
       virtual ~GuiControl();
-      virtual bool processArguments(S32 argc, ConsoleValueRef *argv);
+      virtual bool processArguments(S32 argc, ConsoleValue *argv);
       
       static void initPersistFields();
       static void consoleInit();
diff --git a/Engine/source/gui/worldEditor/worldEditor.cpp b/Engine/source/gui/worldEditor/worldEditor.cpp
index 1e4a795ce..cb0dffc3c 100644
--- a/Engine/source/gui/worldEditor/worldEditor.cpp
+++ b/Engine/source/gui/worldEditor/worldEditor.cpp
@@ -2858,17 +2858,17 @@ void WorldEditor::initPersistFields()
 //------------------------------------------------------------------------------
 // These methods are needed for the console interfaces.
 
-void WorldEditor::ignoreObjClass( U32 argc, ConsoleValueRef *argv )
+void WorldEditor::ignoreObjClass( U32 argc, ConsoleValue *argv )
 {
    for(S32 i = 2; i < argc; i++)
    {
-      ClassInfo::Entry * entry = getClassEntry(argv[i]);
+      ClassInfo::Entry * entry = getClassEntry(argv[i].getString());
       if(entry)
          entry->mIgnoreCollision = true;
       else
       {
          entry = new ClassInfo::Entry;
-         entry->mName = StringTable->insert(argv[i]);
+         entry->mName = StringTable->insert(argv[i].getString());
          entry->mIgnoreCollision = true;
          if(!addClassEntry(entry))
             delete entry;
diff --git a/Engine/source/gui/worldEditor/worldEditor.h b/Engine/source/gui/worldEditor/worldEditor.h
index 01c7d396c..afcdb599a 100644
--- a/Engine/source/gui/worldEditor/worldEditor.h
+++ b/Engine/source/gui/worldEditor/worldEditor.h
@@ -76,7 +76,7 @@ class WorldEditor : public EditTSCtrl
          Point3F p2;
       };
 
-      void ignoreObjClass(U32 argc, ConsoleValueRef* argv);
+      void ignoreObjClass(U32 argc, ConsoleValue* argv);
       void clearIgnoreList();
 
       static bool setObjectsUseBoxCenter( void *object, const char *index, const char *data ) { static_cast<WorldEditor*>(object)->setObjectsUseBoxCenter( dAtob( data ) ); return false; };
diff --git a/Engine/source/platformWin32/winMath.cpp b/Engine/source/platformWin32/winMath.cpp
index 3b6e3ec15..b273d25f0 100644
--- a/Engine/source/platformWin32/winMath.cpp
+++ b/Engine/source/platformWin32/winMath.cpp
@@ -55,31 +55,36 @@ DefineEngineStringlyVariadicFunction( mathInit, void, 1, 10, "( ... )"
    }
    for (argc--, argv++; argc; argc--, argv++)
    {
-      if (dStricmp(*argv, "DETECT") == 0) {
+      const char* str = (*argv).getString();
+      if (dStricmp(str, "DETECT") == 0) {
          Math::init(0);
          return;
       }
-      if (dStricmp(*argv, "C") == 0) {
+      if (dStricmp(str, "C") == 0) {
          properties |= CPU_PROP_C;
          continue;
       }
-      if (dStricmp(*argv, "FPU") == 0) {
+      if (dStricmp(str, "FPU") == 0) {
          properties |= CPU_PROP_FPU;
          continue;
       }
-      if (dStricmp(*argv, "MMX") == 0) {
+      if (dStricmp(str, "MMX") == 0) {
          properties |= CPU_PROP_MMX;
          continue;
       }
-      if (dStricmp(*argv, "3DNOW") == 0) {
+      if (dStricmp(str, "3DNOW") == 0) {
          properties |= CPU_PROP_3DNOW;
          continue;
       }
-      if (dStricmp(*argv, "SSE") == 0) {
+      if (dStricmp(str, "SSE") == 0) {
          properties |= CPU_PROP_SSE;
          continue;
       }
-      Con::printf("Error: MathInit(): ignoring unknown math extension '%s'", argv->getStringValue());
+      if (dStricmp(str, "SSE2") == 0) {
+         properties |= CPU_PROP_SSE2;
+         continue;
+      }
+      Con::printf("Error: MathInit(): ignoring unknown math extension '%s'", str);
    }
    Math::init(properties);
 }
diff --git a/Engine/source/sfx/sfxSource.cpp b/Engine/source/sfx/sfxSource.cpp
index abc5b35e1..47cab9f15 100644
--- a/Engine/source/sfx/sfxSource.cpp
+++ b/Engine/source/sfx/sfxSource.cpp
@@ -316,7 +316,7 @@ void SFXSource::initPersistFields()
 
 //-----------------------------------------------------------------------------
 
-bool SFXSource::processArguments( S32 argc, ConsoleValueRef *argv )
+bool SFXSource::processArguments( S32 argc, ConsoleValue *argv )
 {
    // Don't allow subclasses of this to be created via script.  Force
    // usage of the SFXSystem functions.
diff --git a/Engine/source/sfx/sfxSource.h b/Engine/source/sfx/sfxSource.h
index 16ab6fd14..8d6bb129f 100644
--- a/Engine/source/sfx/sfxSource.h
+++ b/Engine/source/sfx/sfxSource.h
@@ -382,7 +382,7 @@ class SFXSource : public SimGroup
 
       /// We overload this to disable creation of 
       /// a source via script 'new'.
-      virtual bool processArguments( S32 argc, ConsoleValueRef *argv );
+      virtual bool processArguments( S32 argc, ConsoleValue *argv );
       
       // Console getters/setters.
       static bool _setDescription( void *obj, const char *index, const char *data );
diff --git a/Engine/source/sfx/sfxTrack.cpp b/Engine/source/sfx/sfxTrack.cpp
index 067a202ca..987650c0b 100644
--- a/Engine/source/sfx/sfxTrack.cpp
+++ b/Engine/source/sfx/sfxTrack.cpp
@@ -95,7 +95,7 @@ void SFXTrack::initPersistFields()
 
 //-----------------------------------------------------------------------------
 
-bool SFXTrack::processArguments( S32 argc, ConsoleValueRef *argv )
+bool SFXTrack::processArguments( S32 argc, ConsoleValue *argv )
 {
    if( typeid( *this ) == typeid( SFXTrack ) )
    {
diff --git a/Engine/source/sfx/sfxTrack.h b/Engine/source/sfx/sfxTrack.h
index e30acd007..2beb5e3e6 100644
--- a/Engine/source/sfx/sfxTrack.h
+++ b/Engine/source/sfx/sfxTrack.h
@@ -61,7 +61,7 @@ class SFXTrack : public SimDataBlock
       StringTableEntry mParameters[ MaxNumParameters ];
    
       /// Overload this to disable direct instantiation of this class via script 'new'.
-      virtual bool processArguments( S32 argc, ConsoleValueRef *argv );
+      virtual bool processArguments( S32 argc, ConsoleValue *argv );
 
    public:
          
diff --git a/Engine/source/shaderGen/GLSL/customFeatureGLSL.cpp b/Engine/source/shaderGen/GLSL/customFeatureGLSL.cpp
index 3b0467062..99414d133 100644
--- a/Engine/source/shaderGen/GLSL/customFeatureGLSL.cpp
+++ b/Engine/source/shaderGen/GLSL/customFeatureGLSL.cpp
@@ -238,7 +238,7 @@ void CustomFeatureGLSL::addVertTexCoord(String name)
    mVars.push_back(newVarHolder);
 }
 
-void CustomFeatureGLSL::writeLine(String format, S32 argc, ConsoleValueRef * argv)
+void CustomFeatureGLSL::writeLine(String format, S32 argc, ConsoleValue * argv)
 {
    //do the var/arg fetching here
    Vector<Var*> varList;
@@ -246,7 +246,7 @@ void CustomFeatureGLSL::writeLine(String format, S32 argc, ConsoleValueRef * arg
 
    for (U32 i = 0; i < argc; i++)
    {
-      String varName = argv[i].getStringValue();
+      String varName = argv[i].getString();
       Var* newVar = (Var*)LangElement::find(varName.c_str());
       if (!newVar)
       {
@@ -304,7 +304,7 @@ void CustomFeatureGLSL::writeLine(String format, S32 argc, ConsoleValueRef * arg
          if (!newVar)
          {
             //couldn't find that variable, bail out
-            Con::errorf("CustomShaderFeature::writeLine: unable to find variable %s, meaning it was not declared before being used!", argv[i].getStringValue());
+            Con::errorf("CustomShaderFeature::writeLine: unable to find variable %s, meaning it was not declared before being used!", argv[i].getString());
             return;
          }
       }
diff --git a/Engine/source/shaderGen/GLSL/customFeatureGLSL.h b/Engine/source/shaderGen/GLSL/customFeatureGLSL.h
index c2d0191cc..b8358a835 100644
--- a/Engine/source/shaderGen/GLSL/customFeatureGLSL.h
+++ b/Engine/source/shaderGen/GLSL/customFeatureGLSL.h
@@ -128,5 +128,5 @@ public:
    void addTexture(String name, String type, String samplerState, U32 arraySize);
    void addConnector(String name, String type, String elementName);
    void addVertTexCoord(String name);
-   void writeLine(String format, S32 argc, ConsoleValueRef* argv);
+   void writeLine(String format, S32 argc, ConsoleValue* argv);
 };
diff --git a/Engine/source/shaderGen/HLSL/customFeatureHLSL.cpp b/Engine/source/shaderGen/HLSL/customFeatureHLSL.cpp
index fa0a3934e..91e2329c4 100644
--- a/Engine/source/shaderGen/HLSL/customFeatureHLSL.cpp
+++ b/Engine/source/shaderGen/HLSL/customFeatureHLSL.cpp
@@ -385,7 +385,7 @@ void CustomFeatureHLSL::addVertTexCoord(String name)
    mVars.push_back(newVarHolder);
 }
 
-void CustomFeatureHLSL::writeLine(String format, S32 argc, ConsoleValueRef * argv)
+void CustomFeatureHLSL::writeLine(String format, S32 argc, ConsoleValue *argv)
 {
    //do the var/arg fetching here
    Vector<Var*> varList;
@@ -393,7 +393,7 @@ void CustomFeatureHLSL::writeLine(String format, S32 argc, ConsoleValueRef * arg
 
    for (U32 i = 0; i < argc; i++)
    {
-      String varName = argv[i].getStringValue();
+      String varName = argv[i].getString();
       Var* newVar = (Var*)LangElement::find(varName.c_str());
       if (!newVar)
       {
@@ -451,7 +451,7 @@ void CustomFeatureHLSL::writeLine(String format, S32 argc, ConsoleValueRef * arg
          if (!newVar)
          {
             //couldn't find that variable, bail out
-            Con::errorf("CustomShaderFeature::writeLine: unable to find variable %s, meaning it was not declared before being used!", argv[i].getStringValue());
+            Con::errorf("CustomShaderFeature::writeLine: unable to find variable %s, meaning it was not declared before being used!", argv[i].getString());
             return;
          }
       }
diff --git a/Engine/source/shaderGen/HLSL/customFeatureHLSL.h b/Engine/source/shaderGen/HLSL/customFeatureHLSL.h
index dd1ad0a09..be89aeb50 100644
--- a/Engine/source/shaderGen/HLSL/customFeatureHLSL.h
+++ b/Engine/source/shaderGen/HLSL/customFeatureHLSL.h
@@ -128,5 +128,5 @@ public:
    void addTexture(String name, String type, String samplerState, U32 arraySize);
    void addConnector(String name, String type, String elementName);
    void addVertTexCoord(String name);
-   void writeLine(String format, S32 argc, ConsoleValueRef* argv);
+   void writeLine(String format, S32 argc, ConsoleValue* argv);
 };
diff --git a/Engine/source/shaderGen/customShaderFeature.cpp b/Engine/source/shaderGen/customShaderFeature.cpp
index e17cdc088..c184cb128 100644
--- a/Engine/source/shaderGen/customShaderFeature.cpp
+++ b/Engine/source/shaderGen/customShaderFeature.cpp
@@ -189,7 +189,7 @@ bool CustomShaderFeatureData::hasFeature(String name)
    return false;
 }
 
-void CustomShaderFeatureData::writeLine(String format, S32 argc, ConsoleValueRef* argv)
+void CustomShaderFeatureData::writeLine(String format, S32 argc, ConsoleValue* argv)
 {
 #ifdef TORQUE_D3D11
    if (GFX->getAdapterType() == GFXAdapterType::Direct3D11)
diff --git a/Engine/source/shaderGen/customShaderFeature.h b/Engine/source/shaderGen/customShaderFeature.h
index 57d91e989..fd76380c4 100644
--- a/Engine/source/shaderGen/customShaderFeature.h
+++ b/Engine/source/shaderGen/customShaderFeature.h
@@ -77,7 +77,7 @@ public:
    void addVertTexCoord(String name);
 	bool hasFeature(String name);
 
-	void writeLine(String format, S32 argc, ConsoleValueRef *argv);
+	void writeLine(String format, S32 argc, ConsoleValue *argv);
 };
 
 #endif

From 5e81c021f5c2a3bffa68a2258dedb6b2821a0487 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Tue, 30 Mar 2021 23:58:07 -0400
Subject: [PATCH 003/399] start cleaning up ConsoleValueRef's

---
 Engine/source/console/codeBlock.h          |   9 +-
 Engine/source/console/console.cpp          | 172 ++++++----
 Engine/source/console/console.h            | 358 ++++++++++++---------
 Engine/source/console/engineAPI.h          |   6 +-
 Engine/source/console/simEvents.h          |   2 -
 Engine/source/gui/editor/guiFilterCtrl.cpp |   2 +-
 Engine/source/platform/types.visualc.h     |  11 +-
 Engine/source/sim/actionMap.cpp            |   4 +-
 8 files changed, 331 insertions(+), 233 deletions(-)

diff --git a/Engine/source/console/codeBlock.h b/Engine/source/console/codeBlock.h
index f789f1a92..1daa26bac 100644
--- a/Engine/source/console/codeBlock.h
+++ b/Engine/source/console/codeBlock.h
@@ -28,7 +28,6 @@
 
 class Stream;
 class ConsoleValue;
-class ConsoleValueRef;
 
 /// Core TorqueScript code management class.
 ///
@@ -130,7 +129,7 @@ public:
    /// with, zero being the top of the stack. If the the index is
    /// -1 a new frame is created. If the index is out of range the
    /// top stack frame is used.
-   ConsoleValueRef compileExec(StringTableEntry fileName, const char *script,
+   ConsoleValue compileExec(StringTableEntry fileName, const char *script,
       bool noCalls, S32 setFrame = -1);
 
    /// Executes the existing code in the CodeBlock. The return string is any 
@@ -148,9 +147,9 @@ public:
    /// -1 a new frame is created. If the index is out of range the
    /// top stack frame is used.
    /// @param packageName The code package name or null.
-   ConsoleValueRef exec(U32 offset, const char *fnName, Namespace *ns, U32 argc,
-      ConsoleValueRef *argv, bool noCalls, StringTableEntry packageName,
+   ConsoleValue exec(U32 offset, const char *fnName, Namespace *ns, U32 argc,
+      ConsoleValue *argv, bool noCalls, StringTableEntry packageName,
       S32 setFrame = -1);
 };
 
-#endif
\ No newline at end of file
+#endif
diff --git a/Engine/source/console/console.cpp b/Engine/source/console/console.cpp
index 50bdb5391..efa46f148 100644
--- a/Engine/source/console/console.cpp
+++ b/Engine/source/console/console.cpp
@@ -41,9 +41,37 @@
 #include "platform/threads/mutex.h"
 #include "core/util/journal/journal.h"
 #include "cinterface/cinterface.h"
+#include "console/consoleValueStack.h"
 
 extern StringStack STR;
-extern ConsoleValueStack CSTK;
+extern ConsoleValueStack<4096> gCallStack;
+
+S32 ConsoleValue::sBufferOffset = 0;
+char ConsoleValue::sConversionBuffer[ConversionBufferSize];
+
+void ConsoleValue::init()
+{
+   sBufferOffset = 0;
+   dMemset(sConversionBuffer, '\0', ConversionBufferSize);
+}
+
+char* ConsoleValue::convertToBuffer() const
+{
+   sBufferOffset += StringSize;
+   if (sBufferOffset > ConversionBufferSize)
+   {
+      dMemset(sConversionBuffer, '\0', ConversionBufferSize);
+      sBufferOffset = 0;
+   }
+
+   char* offset = sConversionBuffer + sBufferOffset;
+   if (type == ConsoleValueType::cvFloat)
+      dSprintf(offset, StringSize, "%.9g", f);
+   else
+      dSprintf(offset, StringSize, "%lld", i);
+
+   return offset;
+}
 
 ConsoleDocFragment* ConsoleDocFragment::smFirst;
 ExprEvalState gEvalState;
@@ -1469,7 +1497,7 @@ bool executeFile(const char* fileName, bool noCalls, bool journalScript)
    return ret;
 }
 
-ConsoleValueRef evaluate(const char* string, bool echo, const char *fileName)
+ConsoleValue evaluate(const char* string, bool echo, const char *fileName)
 {
    ConsoleStackFrameSaver stackSaver;
    stackSaver.save();
@@ -1486,11 +1514,11 @@ ConsoleValueRef evaluate(const char* string, bool echo, const char *fileName)
       fileName = StringTable->insert(fileName);
 
    CodeBlock *newCodeBlock = new CodeBlock();
-   return newCodeBlock->compileExec(fileName, string, false, fileName ? -1 : 0);
+   return std::move(newCodeBlock->compileExec(fileName, string, false, fileName ? -1 : 0));
 }
 
 //------------------------------------------------------------------------------
-ConsoleValueRef evaluatef(const char* string, ...)
+ConsoleValue evaluatef(const char* string, ...)
 {
    ConsoleStackFrameSaver stackSaver;
    stackSaver.save();
@@ -1507,36 +1535,41 @@ ConsoleValueRef evaluatef(const char* string, ...)
 //------------------------------------------------------------------------------
 
 // Internal execute for global function which does not save the stack
-ConsoleValueRef _internalExecute(S32 argc, ConsoleValueRef argv[])
+ConsoleValue _internalExecute(S32 argc, ConsoleValue argv[])
 {
+   StringTableEntry funcName = StringTable->insert(argv[0].getString());
+
    const char** argv_str = static_cast<const char**>(malloc((argc - 1) * sizeof(char *)));
    for (int i = 0; i < argc - 1; i++)
    {
-      argv_str[i] = argv[i + 1];
+      argv_str[i] = argv[i + 1].getString();
    }
    bool result;
-   const char* methodRes = CInterface::CallFunction(NULL, argv[0], argv_str, argc - 1, &result);
+   const char* methodRes = CInterface::CallFunction(NULL, funcName, argv_str, argc - 1, &result);
    free(argv_str);
    if (result)
    {
-      return ConsoleValueRef::fromValue(CSTK.pushString(methodRes));
+      ConsoleValue ret;
+      ret.setString(methodRes, dStrlen(methodRes));
+      return std::move(ret);
    }
    
    Namespace::Entry *ent;
-   StringTableEntry funcName = StringTable->insert(argv[0]);
+   
    ent = Namespace::global()->lookup(funcName);
 
    if(!ent)
    {
-      warnf(ConsoleLogEntry::Script, "%s: Unknown command.", (const char*)argv[0]);
+      warnf(ConsoleLogEntry::Script, "%s: Unknown command.", funcName);
 
       STR.clearFunctionOffset();
-      return ConsoleValueRef();
+      return std::move(ConsoleValue());
    }
-   return ent->execute(argc, argv, &gEvalState);
+
+   return std::move(ent->execute(argc, argv, &gEvalState));
 }
 
-ConsoleValueRef execute(S32 argc, ConsoleValueRef argv[])
+ConsoleValue execute(S32 argc, ConsoleValue argv[])
 {
 #ifdef TORQUE_MULTITHREAD
    if(isMainThread())
@@ -1558,23 +1591,23 @@ ConsoleValueRef execute(S32 argc, ConsoleValueRef argv[])
 #endif
 }
 
-ConsoleValueRef execute(S32 argc, const char *argv[])
+ConsoleValue execute(S32 argc, const char *argv[])
 {
    ConsoleStackFrameSaver stackSaver;
    stackSaver.save();
-   StringStackConsoleWrapper args(argc, argv);
-   return execute(args.count(), args);
+   StringArrayToConsoleValueWrapper args(argc, argv);
+   return std::move(execute(args.count(), args));
 }
 
 //------------------------------------------------------------------------------
 
 // Internal execute for object method which does not save the stack
-ConsoleValueRef _internalExecute(SimObject *object, S32 argc, ConsoleValueRef argv[], bool thisCallOnly)
+static ConsoleValue _internalExecute(SimObject *object, S32 argc, ConsoleValue argv[], bool thisCallOnly)
 {
    if(argc < 2)
    {
       STR.clearFunctionOffset();
-      return ConsoleValueRef();
+      return std::move(ConsoleValue());
    }
 
    // [neo, 10/05/2007 - #3010]
@@ -1591,65 +1624,65 @@ ConsoleValueRef _internalExecute(SimObject *object, S32 argc, ConsoleValueRef ar
       }
    }
 
+   StringTableEntry funcName = StringTable->insert(argv[0].getString());
+
    const char** argv_str = static_cast<const char**>(malloc((argc - 2) * sizeof(char *)));
    for (int i = 0; i < argc - 2; i++)
    {
-      argv_str[i] = argv[i + 2];
+      argv_str[i] = argv[i + 2].getString();
    }
    bool result;
-   const char* methodRes = CInterface::CallMethod(object, argv[0], argv_str, argc - 2, &result);
+   const char* methodRes = CInterface::CallMethod(object, funcName, argv_str, argc - 2, &result);
 
    free(argv_str);
 
    if (result)
    {
-      return ConsoleValueRef::fromValue(CSTK.pushString(methodRes));
+      ConsoleValue val;
+      val.setString(methodRes, dStrlen(methodRes));
+      return std::move(val);
    }
 
    if(object->getNamespace())
    {
       U32 ident = object->getId();
-      ConsoleValueRef oldIdent(argv[1]);
-
-      StringTableEntry funcName = StringTable->insert(argv[0]);
+      const char* oldIdent = argv[1].getString();
+      
       Namespace::Entry *ent = object->getNamespace()->lookup(funcName);
 
       if(ent == NULL)
       {
-         //warnf(ConsoleLogEntry::Script, "%s: undefined for object '%s' - id %d", funcName, object->getName(), object->getId());
+         warnf(ConsoleLogEntry::Script, "%s: undefined for object '%s' - id %d", funcName, object->getName(), object->getId());
 
          STR.clearFunctionOffset();
-         return ConsoleValueRef();
+         return std::move(ConsoleValue());
       }
 
       // Twiddle %this argument
-      ConsoleValue func_ident;
-      func_ident.setIntValue((S32)ident);
-      argv[1] = ConsoleValueRef::fromValue(&func_ident);
+      argv[1].setInt(ident);
 
       SimObject *save = gEvalState.thisObject;
       gEvalState.thisObject = object;
-      ConsoleValueRef ret = ent->execute(argc, argv, &gEvalState);
+      ConsoleValue ret = std::move(ent->execute(argc, argv, &gEvalState));
       gEvalState.thisObject = save;
 
       // Twiddle it back
-      argv[1] = oldIdent;
+      argv[1].setString(oldIdent, dStrlen(oldIdent));
 
-      return ret;
+      return std::move(ret);
    }
 
-   warnf(ConsoleLogEntry::Script, "Con::execute - %d has no namespace: %s", object->getId(), (const char*)argv[0]);
+   warnf(ConsoleLogEntry::Script, "Con::execute - %d has no namespace: %s", object->getId(), funcName);
    STR.clearFunctionOffset();
-   return ConsoleValueRef();
+   return std::move(ConsoleValue());
 }
 
-
-ConsoleValueRef execute(SimObject *object, S32 argc, ConsoleValueRef argv[], bool thisCallOnly)
+ConsoleValue execute(SimObject *object, S32 argc, ConsoleValue argv[], bool thisCallOnly)
 {
    if(argc < 2)
    {
       STR.clearFunctionOffset();
-      return ConsoleValueRef();
+      return std::move(ConsoleValue());
    }
 
    ConsoleStackFrameSaver stackSaver;
@@ -1659,7 +1692,7 @@ ConsoleValueRef execute(SimObject *object, S32 argc, ConsoleValueRef argv[], boo
    {
       if (isMainThread())
       {
-         return _internalExecute(object, argc, argv, thisCallOnly);
+         return std::move(_internalExecute(object, argc, argv, thisCallOnly));
       }
       else
       {
@@ -1669,34 +1702,34 @@ ConsoleValueRef execute(SimObject *object, S32 argc, ConsoleValueRef argv[], boo
       }
    }
 
-   warnf(ConsoleLogEntry::Script, "Con::execute - %d has no namespace: %s", object->getId(), (const char*)argv[0]);
+   warnf(ConsoleLogEntry::Script, "Con::execute - %d has no namespace: %s", object->getId(), argv[0].getString());
    STR.clearFunctionOffset();
-   return ConsoleValueRef();
+   return std::move(ConsoleValue());
 }
 
-ConsoleValueRef execute(SimObject *object, S32 argc, const char *argv[], bool thisCallOnly)
+ConsoleValue execute(SimObject *object, S32 argc, const char *argv[], bool thisCallOnly)
 {
    ConsoleStackFrameSaver stackSaver;
    stackSaver.save();
-   StringStackConsoleWrapper args(argc, argv);
-   return execute(object, args.count(), args, thisCallOnly);
+   StringArrayToConsoleValueWrapper args(argc, argv);
+   return std::move(execute(object, args.count(), args, thisCallOnly));
 }
 
-inline ConsoleValueRef _executef(SimObject *obj, S32 checkArgc, S32 argc, ConsoleValueRef *argv)
+inline ConsoleValue _executef(SimObject *obj, S32 checkArgc, S32 argc, ConsoleValue *argv)
 {
    const U32 maxArg = 12;
-   AssertWarn(checkArgc == argc, "Incorrect arg count passed to Con::executef(SimObject*)");
+   AssertFatal(checkArgc == argc, "Incorrect arg count passed to Con::executef(SimObject*)");
    AssertFatal(argc <= maxArg - 1, "Too many args passed to Con::_executef(SimObject*). Please update the function to handle more.");
-   return execute(obj, argc, argv);
+   return std::move(execute(obj, argc, argv));
 }
 
 //------------------------------------------------------------------------------
-inline ConsoleValueRef _executef(S32 checkArgc, S32 argc, ConsoleValueRef *argv)
+inline ConsoleValue _executef(S32 checkArgc, S32 argc, ConsoleValue *argv)
 {
    const U32 maxArg = 10;
    AssertFatal(checkArgc == argc, "Incorrect arg count passed to Con::executef()");
    AssertFatal(argc <= maxArg, "Too many args passed to Con::_executef(). Please update the function to handle more.");
-   return execute(argc, argv);
+   return std::move(execute(argc, argv));
 }
 
 //------------------------------------------------------------------------------
@@ -1893,16 +1926,11 @@ StringTableEntry getModNameFromPath(const char *path)
 
 void postConsoleInput( RawData data )
 {
+   // TODO(JTH): Mem leak
    // Schedule this to happen at the next time event.
-   ConsoleValue values[2];
-   ConsoleValueRef argv[2];
-
-   values[0].init();
-   values[0].setStringValue("eval");
-   values[1].init();
-   values[1].setStringValue((const char*)data.data);
-   argv[0].value = &values[0];
-   argv[1].value = &values[1];
+   ConsoleValue* argv = new ConsoleValue[2];
+   argv[0].setString("eval", 4);
+   argv[1].setString(reinterpret_cast<const char*>(data.data), dStrlen(reinterpret_cast<const char*>(data.data)));
 
    Sim::postCurrentEvent(Sim::getRootGroup(), new SimConsoleEvent(2, argv, false));
 }
@@ -2555,27 +2583,29 @@ StringArrayToConsoleValueWrapper::~StringArrayToConsoleValueWrapper()
 
 //------------------------------------------------------------------------------
 
-ConsoleValueRef _BaseEngineConsoleCallbackHelper::_exec()
+ConsoleValue _BaseEngineConsoleCallbackHelper::_exec()
 {
-   ConsoleValueRef returnValue;
    if( mThis )
    {
       // Cannot invoke callback until object has been registered
-      if (mThis->isProperlyAdded()) {
-         returnValue = Con::_internalExecute( mThis, mArgc, mArgv, false );
-      } else {
-         STR.clearFunctionOffset();
-         returnValue = ConsoleValueRef();
+      if (mThis->isProperlyAdded())
+      {
+         ConsoleValue returnValue = std::move(Con::_internalExecute( mThis, mArgc, mArgv, false ));
+         mArgc = mInitialArgc; // reset
+         return returnValue;
       }
-   }
-   else
-      returnValue = Con::_internalExecute( mArgc, mArgv );
 
+      STR.clearFunctionOffset();
+      mArgc = mInitialArgc; // reset
+      return std::move(ConsoleValue());
+   }
+
+   ConsoleValue returnValue = std::move(Con::_internalExecute( mArgc, mArgv ));
    mArgc = mInitialArgc; // reset args
-   return returnValue;
+   return std::move(returnValue);
 }
 
-ConsoleValueRef _BaseEngineConsoleCallbackHelper::_execLater(SimConsoleThreadExecEvent *evt)
+ConsoleValue _BaseEngineConsoleCallbackHelper::_execLater(SimConsoleThreadExecEvent *evt)
 {
    mArgc = mInitialArgc; // reset args
    Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
@@ -2586,7 +2616,7 @@ ConsoleValueRef _BaseEngineConsoleCallbackHelper::_execLater(SimConsoleThreadExe
 
 void ConsoleStackFrameSaver::save()
 {
-   CSTK.pushFrame();
+   gCallStack.pushFrame(0);
    STR.pushFrame();
    mSaved = true;
 }
@@ -2595,7 +2625,7 @@ void ConsoleStackFrameSaver::restore()
 {
    if (mSaved)
    {
-      CSTK.popFrame();
+      gCallStack.popFrame();
       STR.popFrame();
    }
 }
diff --git a/Engine/source/console/console.h b/Engine/source/console/console.h
index ad4d4f622..ee44aaca8 100644
--- a/Engine/source/console/console.h
+++ b/Engine/source/console/console.h
@@ -117,188 +117,250 @@ struct ConsoleLogEntry
 typedef const char *StringTableEntry;
 extern char *typeValueEmpty;
 
+enum ConsoleValueType
+{
+   cvNone = -5,
+   cvInteger = -4,
+   cvFloat = -3,
+   cvString = -2,
+   cvSTEntry = -1,
+   cvConsoleValueType = 0
+};
+
+struct ConsoleValueConsoleType
+{
+   void* dataPtr;
+   EnumTable* enumTable;
+};
+
+// TODO: replace malloc/free with custom allocator...
 class ConsoleValue
 {
-public:
-
-   enum
+   union
    {
-      TypeInternalInt = -5,
-      TypeInternalFloat = -4,
-      TypeInternalStringStackPtr = -3,
-      TypeInternalStackString = -2,
-      TypeInternalString = -1,
+      F64   f;
+      S64   i;
+      char* s;
+      void* data;
+      ConsoleValueConsoleType* ct;
    };
 
    S32 type;
 
-public:
-
-   // NOTE: This is protected to ensure no one outside
-   // of this structure is messing with it.
-
-#pragma warning( push )
-#pragma warning( disable : 4201 ) // warning C4201: nonstandard extension used : nameless struct/union
-
-   // An variable is either a real dynamic type or
-   // its one exposed from C++ using a data pointer.
-   //
-   // We use this nameless union and struct setup
-   // to optimize the memory usage.
-   union
+   enum Constants
    {
-      struct
-      {
-         char *sval;
-         U32 ival;  // doubles as strlen when type is TypeInternalString
-         F32 fval;
-         U32 bufferLen;
-      };
-
-      struct
-      {
-         /// The real data pointer.
-         void *dataPtr;
-
-         /// The enum lookup table for enumerated types.
-         const EnumTable *enumTable;
-      };
+      ConversionBufferSize = 1024,
+      StringSize = 16
    };
 
-   U32 getIntValue();
-   S32 getSignedIntValue();
-   F32 getFloatValue();
-   const char *getStringValue();
-   StringStackPtr getStringStackPtr();
-   bool getBoolValue();
+   static char sConversionBuffer[ConversionBufferSize];
+   static S32 sBufferOffset;
 
-   void setIntValue(U32 val);
-   void setIntValue(S32 val);
-   void setFloatValue(F32 val);
-   void setStringValue(const char *value);
-   void setStackStringValue(const char *value);
-   void setStringStackPtrValue(StringStackPtr ptr);
-   void setBoolValue(bool val);
+   char* convertToBuffer() const;
 
-   void init()
+   TORQUE_FORCEINLINE bool isStringType() const
    {
-      ival = 0;
-      fval = 0;
-      sval = typeValueEmpty;
-      bufferLen = 0;
-      type = TypeInternalString;
+      return type == ConsoleValueType::cvString || type == ConsoleValueType::cvSTEntry;
    }
 
-   void cleanup()
+   TORQUE_FORCEINLINE bool isNumberType() const
    {
-      if ((type <= TypeInternalString) && (bufferLen > 0))
+      return type == ConsoleValueType::cvFloat || type == ConsoleValueType::cvInteger;
+   }
+
+   TORQUE_FORCEINLINE bool hasAllocatedData() const
+   {
+      return type == ConsoleValueType::cvString || type >= ConsoleValueType::cvConsoleValueType;
+   }
+
+   TORQUE_FORCEINLINE const char* getConsoleData() const
+   {
+      return Con::getData(type, ct->dataPtr, 0, ct->enumTable);
+   }
+
+   TORQUE_FORCEINLINE void cleanupData()
+   {
+      if (hasAllocatedData())
       {
-         dFree(sval);
-         bufferLen = 0;
+         dFree(data);
       }
-      sval = typeValueEmpty;
-      type = ConsoleValue::TypeInternalString;
-      ival = 0;
-      fval = 0;
    }
-   ConsoleValue() { init(); };
-   ~ConsoleValue() { cleanup(); };
-};
 
-// Proxy class for console variables
-// Can point to existing console variables,
-// or act like a free floating value.
-class ConsoleValueRef
-{
 public:
-   ConsoleValue *value;
+   ConsoleValue()
+   {
+      type = ConsoleValueType::cvNone;
+   }
 
-   ConsoleValueRef() : value(0) { ; }
-   ~ConsoleValueRef() { ; }
+   ConsoleValue(ConsoleValue&& ref)
+   {
+      cleanupData();
+      type = ref.type;
 
-   ConsoleValueRef(const ConsoleValueRef &ref);
+      switch (ref.type)
+      {
+      TORQUE_UNLIKELY
+      case cvNone:
+         break;
+      case cvInteger:
+         i = ref.i;
+         break;
+      case cvFloat:
+         f = ref.f;
+         break;
+      case cvSTEntry:
+         TORQUE_CASE_FALLTHROUGH
+      case cvString:
+         s = ref.s;
+         break;
+      default:
+         data = ref.data;
+         break;
+      }
 
-   static ConsoleValueRef fromValue(ConsoleValue *value) { ConsoleValueRef ref; ref.value = value; return ref; }
+      ref.type = cvNone;
+   }
 
-   const char *getStringValue() { return value ? value->getStringValue() : ""; }
-   StringStackPtr getStringStackPtrValue() { return value ? value->getStringStackPtr() : 0; }
+   ConsoleValue(const ConsoleValue&) = delete;
+   ConsoleValue& operator=(const ConsoleValue&) = delete;
 
-   inline U32 getIntValue() { return value ? value->getIntValue() : 0; }
-   inline S32 getSignedIntValue() { return value ? value->getSignedIntValue() : 0; }
-   inline F32 getFloatValue() { return value ? value->getFloatValue() : 0.0f; }
-   inline bool getBoolValue() { return value ? value->getBoolValue() : false; }
+   TORQUE_FORCEINLINE ~ConsoleValue()
+   {
+      cleanupData();
+   }
 
-   inline operator const char*() { return getStringValue(); }
-   inline operator String() { return String(getStringValue()); }
-   inline operator U32() { return getIntValue(); }
-   inline operator S32() { return getSignedIntValue(); }
-   inline operator F32() { return getFloatValue(); }
-   inline operator bool() { return getBoolValue(); }
+   TORQUE_FORCEINLINE F64 getFloat() const
+   {
+      AssertFatal(type == ConsoleValueType::cvNone, "Attempted to access ConsoleValue when it has no value!");
+      if (type == ConsoleValueType::cvFloat)
+         return f;
+      if (type == ConsoleValueType::cvInteger)
+         return i;
+      if (isStringType())
+         return dAtof(s);
+      return dAtof(getConsoleData());
+   }
 
-   inline bool isStringStackPtr() { return value ? value->type == ConsoleValue::TypeInternalStringStackPtr : false; }
-   inline bool isString() { return value ? value->type >= ConsoleValue::TypeInternalStringStackPtr : true; }
-   inline bool isInt() { return value ? value->type == ConsoleValue::TypeInternalInt : false; }
-   inline bool isFloat() { return value ? value->type == ConsoleValue::TypeInternalFloat : false; }
-   inline S32 getType() { return value ? value->type : -1; }
+   TORQUE_FORCEINLINE S64 getInt() const
+   {
+      AssertFatal(type == ConsoleValueType::cvNone, "Attempted to access ConsoleValue when it has no value!");
+      if (type == ConsoleValueType::cvInteger)
+         return i;
+      if (type == ConsoleValueType::cvFloat)
+         return f;
+      if (isStringType())
+         return dAtoi(s);
+      return dAtoi(getConsoleData());
+   }
 
-   // Note: operators replace value
-   ConsoleValueRef& operator=(const ConsoleValueRef &other);
-   ConsoleValueRef& operator=(const char *newValue);
-   ConsoleValueRef& operator=(U32 newValue);
-   ConsoleValueRef& operator=(S32 newValue);
-   ConsoleValueRef& operator=(F32 newValue);
-   ConsoleValueRef& operator=(F64 newValue);
+   TORQUE_FORCEINLINE const char* getString() const
+   {
+      AssertFatal(type == ConsoleValueType::cvNone, "Attempted to access ConsoleValue when it has no value!");
+      if (isStringType())
+         return s;
+      if (isNumberType())
+         return convertToBuffer();
+      return getConsoleData();
+   }
+
+   TORQUE_FORCEINLINE bool getBool() const
+   {
+      AssertFatal(type == ConsoleValueType::cvNone, "Attempted to access ConsoleValue when it has no value!");
+      if (type == ConsoleValueType::cvInteger)
+         return (bool)i;
+      if (type == ConsoleValueType::cvFloat)
+         return (bool)f;
+      if (isStringType())
+         return dAtob(s);
+      return dAtob(getConsoleData());
+   }
+
+   TORQUE_FORCEINLINE void setFloat(const F64 val)
+   {
+      AssertFatal(type == ConsoleValueType::cvNone, "Attempted to access ConsoleValue when it has no value!");
+      cleanupData();
+      type = ConsoleValueType::cvFloat;
+      f = val;
+   }
+
+   TORQUE_FORCEINLINE void setInt(const S64 val)
+   {
+      cleanupData();
+      type = ConsoleValueType::cvInteger;
+      i = val;
+   }
+
+   TORQUE_FORCEINLINE void setString(const char* val, S32 len)
+   {
+      cleanupData();
+
+      type = ConsoleValueType::cvString;
+
+      s = (char*)dMalloc(len + 1);
+      s[len] = 0x0;
+      dStrcpy(s, val, len);
+   }
+
+   TORQUE_FORCEINLINE void setBool(const bool val)
+   {
+      cleanupData();
+      type = ConsoleValueType::cvInteger;
+      i = (int)val;
+   }
+
+   TORQUE_FORCEINLINE void setStringTableEntry(StringTableEntry val)
+   {
+      cleanupData();
+      type = ConsoleValueType::cvSTEntry;
+      s = const_cast<char*>(val);
+   }
+
+   TORQUE_FORCEINLINE void setConsoleData(S32 consoleType, void* dataPtr, EnumTable* enumTable)
+   {
+      cleanupData();
+      type = ConsoleValueType::cvSTEntry;
+      ct = new ConsoleValueConsoleType{ dataPtr, enumTable };
+   }
+
+   TORQUE_FORCEINLINE S32 getType() const
+   {
+      return type;
+   }
+
+   static void init();
+   static S32 getConstantBufferCount() { return (S32)ConversionBufferSize / StringSize; }
 };
 
-// Overrides to allow ConsoleValueRefs to be directly converted to S32&F32
-
-inline S32 dAtoi(ConsoleValueRef &ref)
-{
-   return ref.getSignedIntValue();
-}
-
-inline F32 dAtof(ConsoleValueRef &ref)
-{
-   return ref.getFloatValue();
-}
-
-inline bool dAtob(ConsoleValue &ref)
-{
-   return ref.getBoolValue();
-}
-
-
 // Transparently converts ConsoleValue[] to const char**
-class StringStackWrapper
+class ConsoleValueToStringArrayWrapper
 {
 public:
    const char **argv;
-   int argc;
+   S32 argc;
 
-   StringStackWrapper(int targc, ConsoleValueRef targv[]);
-   ~StringStackWrapper();
+   ConsoleValueToStringArrayWrapper(int targc, ConsoleValue* targv);
+   ~ConsoleValueToStringArrayWrapper();
 
-   const char* operator[](int idx) { return argv[idx]; }
+   const char* operator[](S32 idx) { return argv[idx]; }
    operator const char**() { return argv; }
 
-   int count() { return argc; }
+   S32 count() { return argc; }
 };
 
 // Transparently converts const char** to ConsoleValue
-class StringStackConsoleWrapper
+class StringArrayToConsoleValueWrapper
 {
 public:
-   ConsoleValue *argvValue;
-   ConsoleValueRef *argv;
-   int argc;
+   ConsoleValue *argv;
+   S32 argc;
 
-   StringStackConsoleWrapper(int targc, const char **targv);
-   ~StringStackConsoleWrapper();
+   StringArrayToConsoleValueWrapper(int targc, const char **targv);
+   ~StringArrayToConsoleValueWrapper();
 
-   ConsoleValueRef& operator[](int idx) { return argv[idx]; }
-   operator ConsoleValueRef*() { return argv; }
+   ConsoleValue& operator[](int idx) { return argv[idx]; }
+   operator ConsoleValue*() { return argv; }
 
-   int count() { return argc; }
+   S32 count() { return argc; }
 };
 
 /// @defgroup console_callbacks Scripting Engine Callbacks
@@ -319,11 +381,11 @@ public:
 /// @{
 
 ///
-typedef const char * (*StringCallback)(SimObject *obj, S32 argc, ConsoleValueRef argv[]);
-typedef S32(*IntCallback)(SimObject *obj, S32 argc, ConsoleValueRef argv[]);
-typedef F32(*FloatCallback)(SimObject *obj, S32 argc, ConsoleValueRef argv[]);
-typedef void(*VoidCallback)(SimObject *obj, S32 argc, ConsoleValueRef argv[]); // We have it return a value so things don't break..
-typedef bool(*BoolCallback)(SimObject *obj, S32 argc, ConsoleValueRef argv[]);
+typedef const char * (*StringCallback)(SimObject *obj, S32 argc, ConsoleValue argv[]);
+typedef S32(*IntCallback)(SimObject *obj, S32 argc, ConsoleValue argv[]);
+typedef F32(*FloatCallback)(SimObject *obj, S32 argc, ConsoleValue argv[]);
+typedef void(*VoidCallback)(SimObject *obj, S32 argc, ConsoleValue argv[]); // We have it return a value so things don't break..
+typedef bool(*BoolCallback)(SimObject *obj, S32 argc, ConsoleValue argv[]);
 
 typedef void(*ConsumerCallback)(U32 level, const char *consoleLine);
 /// @}
@@ -786,8 +848,8 @@ namespace Con
    /// char* result = execute(2, argv);
    /// @endcode
    /// NOTE: this function restores the console stack on return.
-   ConsoleValueRef execute(S32 argc, const char* argv[]);
-   ConsoleValueRef execute(S32 argc, ConsoleValueRef argv[]);
+   ConsoleValue execute(S32 argc, const char* argv[]);
+   ConsoleValue execute(S32 argc, ConsoleValue argv[]);
 
    /// Call a Torque Script member function of a SimObject from C/C++ code.
    /// @param object    Object on which to execute the method call.
@@ -802,8 +864,8 @@ namespace Con
    /// char* result = execute(mysimobject, 3, argv);
    /// @endcode
    /// NOTE: this function restores the console stack on return.
-   ConsoleValueRef execute(SimObject *object, S32 argc, const char* argv[], bool thisCallOnly = false);
-   ConsoleValueRef execute(SimObject *object, S32 argc, ConsoleValueRef argv[], bool thisCallOnly = false);
+   ConsoleValue execute(SimObject *object, S32 argc, const char* argv[], bool thisCallOnly = false);
+   ConsoleValue execute(SimObject *object, S32 argc, ConsoleValue argv[], bool thisCallOnly = false);
 
    /// Executes a script file and compiles it for use in script.
    ///
@@ -821,13 +883,13 @@ namespace Con
    /// @param  echo     Should we echo the string to the console?
    /// @param  fileName Indicate what file this code is coming from; used in error reporting and such.
    /// NOTE: This function restores the console stack on return.
-   ConsoleValueRef evaluate(const char* string, bool echo = false, const char *fileName = NULL);
+   ConsoleValue evaluate(const char* string, bool echo = false, const char *fileName = NULL);
 
    /// Evaluate an arbitrary line of script.
    ///
    /// This wraps dVsprintf(), so you can substitute parameters into the code being executed.
    /// NOTE: This function restores the console stack on return.
-   ConsoleValueRef evaluatef(const char* string, ...);
+   ConsoleValue evaluatef(const char* string, ...);
 
    /// @}
 
@@ -915,10 +977,10 @@ namespace Con
    /// @see _EngineConsoleExecCallbackHelper
    ///
    template<typename R, typename ...ArgTs>
-   ConsoleValueRef executef(R r, ArgTs ...argTs)
+   ConsoleValue executef(R r, ArgTs ...argTs)
    {
       _EngineConsoleExecCallbackHelper<R> callback(r);
-      return callback.template call<ConsoleValueRef>(argTs...);
+      return std::move(callback.template call<ConsoleValue>(argTs...));
    }
    /// }
 };
diff --git a/Engine/source/console/engineAPI.h b/Engine/source/console/engineAPI.h
index aa8762f4b..553cc7e71 100644
--- a/Engine/source/console/engineAPI.h
+++ b/Engine/source/console/engineAPI.h
@@ -864,7 +864,7 @@ public:
       (Vector<const char*>* vec)                                                                                                 \
    {                                                                                                                             \
       _CHECK_ENGINE_INITIALIZED( name, returnType );                                                                             \
-      StringStackConsoleWrapper args(vec->size(), vec->address());                                                               \
+      StringArrayToConsoleValueWrapper args(vec->size(), vec->address());                                                               \
       return EngineTypeTraits< returnType >::ReturnValue(                                                                        \
          _fn ## name ## impl(NULL, args.count(), args)                                                                           \
       );                                                                                                                         \
@@ -895,7 +895,7 @@ public:
       (className* object, Vector<const char*>* vec)                                                                              \
    {                                                                                                                             \
       _CHECK_ENGINE_INITIALIZED( name, returnType );                                                                             \
-      StringStackConsoleWrapper args(vec->size(), vec->address());                                                               \
+      StringArrayToConsoleValueWrapper args(vec->size(), vec->address());                                                               \
       _ ## className ## name ## frame frame {};                                                                                  \
       frame.object = static_cast< className* >( object );                                                                        \
       return EngineTypeTraits< returnType >::ReturnValue(                                                                        \
@@ -1226,7 +1226,7 @@ public:
 template<typename P1> struct _EngineConsoleExecCallbackHelper : public _BaseEngineConsoleCallbackHelper
 {
 private:
-   using Helper = engineAPI::detail::MarshallHelpers<ConsoleValueRef>;
+   using Helper = engineAPI::detail::MarshallHelpers<ConsoleValue>;
 public:
 
    _EngineConsoleExecCallbackHelper( SimObject* pThis )
diff --git a/Engine/source/console/simEvents.h b/Engine/source/console/simEvents.h
index 861c7cdde..6fbb6a798 100644
--- a/Engine/source/console/simEvents.h
+++ b/Engine/source/console/simEvents.h
@@ -83,8 +83,6 @@ public:
    virtual void process(SimObject *object)=0;
 };
 
-class ConsoleValueRef;
-
 /// Implementation of schedule() function.
 ///
 /// This allows you to set a console function to be
diff --git a/Engine/source/gui/editor/guiFilterCtrl.cpp b/Engine/source/gui/editor/guiFilterCtrl.cpp
index 6abc3d53c..1be90b8e2 100644
--- a/Engine/source/gui/editor/guiFilterCtrl.cpp
+++ b/Engine/source/gui/editor/guiFilterCtrl.cpp
@@ -83,7 +83,7 @@ DefineEngineStringlyVariadicMethod( GuiFilterCtrl, setValue, void, 3, 20, "(f1,
 {
    Filter filter;
 
-   StringStackWrapper args(argc - 2, argv + 2);
+   ConsoleValueToStringArrayWrapper args(argc - 2, argv + 2);
 
    filter.set(args.count(), args);
 	object->set(filter);
diff --git a/Engine/source/platform/types.visualc.h b/Engine/source/platform/types.visualc.h
index 57dabc4dd..89fd38d4b 100644
--- a/Engine/source/platform/types.visualc.h
+++ b/Engine/source/platform/types.visualc.h
@@ -102,8 +102,17 @@ typedef unsigned _int64 U64;
 
 // disable warning caused by memory layer
 // see msdn.microsoft.com "Compiler Warning (level 1) C4291" for more details
-#pragma warning(disable: 4291) 
+#pragma warning(disable: 4291)
 
+#define TORQUE_FORCEINLINE __forceinline
+
+#if __cplusplus >= 201703L
+#define TORQUE_CASE_FALLTHROUGH [[fallthrough]];
+#define TORQUE_UNLIKELY [[unlikely]]
+#else
+#define TORQUE_CASE_FALLTHROUGH __fallthrough
+#define TORQUE_UNLIKELY
+#endif
 
 #endif // INCLUDED_TYPES_VISUALC_H
 
diff --git a/Engine/source/sim/actionMap.cpp b/Engine/source/sim/actionMap.cpp
index e835273ed..40a41aa06 100644
--- a/Engine/source/sim/actionMap.cpp
+++ b/Engine/source/sim/actionMap.cpp
@@ -2080,7 +2080,7 @@ static ConsoleDocFragment _ActionMapbind2(
 DefineEngineStringlyVariadicMethod( ActionMap, bind, bool, 5, 10, "actionMap.bind( device, action, [modifier, spec, mod...], command )"
            "@hide")
 {
-   StringStackWrapper args(argc - 2, argv + 2);
+   ConsoleValueToStringArrayWrapper args(argc - 2, argv + 2);
    return object->processBind( args.count(), args, NULL );
 }
 
@@ -2136,7 +2136,7 @@ DefineEngineStringlyVariadicMethod( ActionMap, bindObj, bool, 6, 11, "(device, a
       return false;
    }
 
-   StringStackWrapper args(argc - 3, argv + 2);
+   ConsoleValueToStringArrayWrapper args(argc - 3, argv + 2);
    return object->processBind( args.count(), args, simObject );
 }
 

From 50df52ecfc9725604be2e66970e0f6959a957070 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Wed, 31 Mar 2021 21:09:23 -0400
Subject: [PATCH 004/399] more console refactor.

---
 Engine/source/T3D/assets/assetImporter.cpp |   4 +-
 Engine/source/afx/afxSelectron.cpp         |   2 +-
 Engine/source/console/ICallMethod.h        |   4 +-
 Engine/source/console/console.cpp          |   4 +-
 Engine/source/console/console.h            |  18 +--
 Engine/source/console/consoleInternal.cpp  |  30 +++--
 Engine/source/console/consoleInternal.h    |   2 +-
 Engine/source/console/engineAPI.h          | 135 ++++++++++-----------
 Engine/source/console/simEvents.cpp        |  59 +++++----
 Engine/source/console/simEvents.h          |  14 +--
 Engine/source/console/simObject.cpp        |   2 +-
 Engine/source/console/simObject.h          |   2 +-
 Engine/source/console/simPersistSet.cpp    |   2 +-
 Engine/source/console/simPersistSet.h      |   2 +-
 Engine/source/console/test/ScriptTest.cpp  |  28 ++---
 15 files changed, 150 insertions(+), 158 deletions(-)

diff --git a/Engine/source/T3D/assets/assetImporter.cpp b/Engine/source/T3D/assets/assetImporter.cpp
index f399fc108..8c25446b1 100644
--- a/Engine/source/T3D/assets/assetImporter.cpp
+++ b/Engine/source/T3D/assets/assetImporter.cpp
@@ -2546,8 +2546,8 @@ void AssetImporter::importAssets(AssetImportObject* assetItem)
             processCommand += childItem->assetType;
             if (isMethod(processCommand.c_str()))
             {
-               ConsoleValueRef importReturnVal = Con::executef(this, processCommand.c_str(), childItem);
-               assetPath = Torque::Path(importReturnVal.getStringValue());
+               const char* importReturnVal = Con::executef(this, processCommand.c_str(), childItem).getString();
+               assetPath = Torque::Path(importReturnVal);
             }
          }
 
diff --git a/Engine/source/afx/afxSelectron.cpp b/Engine/source/afx/afxSelectron.cpp
index 67cd32849..63157a4f1 100644
--- a/Engine/source/afx/afxSelectron.cpp
+++ b/Engine/source/afx/afxSelectron.cpp
@@ -1070,7 +1070,7 @@ afxSelectron::start_selectron(SceneObject* picked, U8 subcode, SimObject* extra)
   // CALL SCRIPT afxSelectronData::onPreactivate(%params, %extra)
   const char* result = Con::executef(datablock, "onPreactivate",
                                      Con::getIntArg(param_holder->getId()),
-                                     (extra) ? Con::getIntArg(extra->getId()) : "");
+                                     (extra) ? Con::getIntArg(extra->getId()) : "").getString();
   if (result && result[0] != '\0' && !dAtob(result))
   {
 #if defined(TORQUE_DEBUG)
diff --git a/Engine/source/console/ICallMethod.h b/Engine/source/console/ICallMethod.h
index fdda77fa7..0c0d50299 100644
--- a/Engine/source/console/ICallMethod.h
+++ b/Engine/source/console/ICallMethod.h
@@ -27,7 +27,7 @@ class ICallMethod
 {
 public:
    virtual const char* callMethod( S32 argc, const char* methodName, ... ) = 0;
-   virtual const char* callMethodArgList( U32 argc, ConsoleValueRef argv[], bool callThis = true ) = 0;
+   virtual const char* callMethodArgList( U32 argc, ConsoleValue argv[], bool callThis = true ) = 0;
 };
 
-#endif
\ No newline at end of file
+#endif
diff --git a/Engine/source/console/console.cpp b/Engine/source/console/console.cpp
index efa46f148..150b3f823 100644
--- a/Engine/source/console/console.cpp
+++ b/Engine/source/console/console.cpp
@@ -2592,7 +2592,7 @@ ConsoleValue _BaseEngineConsoleCallbackHelper::_exec()
       {
          ConsoleValue returnValue = std::move(Con::_internalExecute( mThis, mArgc, mArgv, false ));
          mArgc = mInitialArgc; // reset
-         return returnValue;
+         return std::move(returnValue);
       }
 
       STR.clearFunctionOffset();
@@ -2609,7 +2609,7 @@ ConsoleValue _BaseEngineConsoleCallbackHelper::_execLater(SimConsoleThreadExecEv
 {
    mArgc = mInitialArgc; // reset args
    Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
-   return evt->getCB().waitForResult();
+   return std::move(evt->getCB().waitForResult());
 }
 
 //------------------------------------------------------------------------------
diff --git a/Engine/source/console/console.h b/Engine/source/console/console.h
index ee44aaca8..cb49911c2 100644
--- a/Engine/source/console/console.h
+++ b/Engine/source/console/console.h
@@ -1254,9 +1254,9 @@ public:
       static ConsoleConstructor cfg_ConsoleFunctionGroup_##groupName##_GroupBegin(NULL,#groupName,usage)
 
 #  define ConsoleToolFunction(name,returnType,minArgs,maxArgs,usage1) \
-   returnType ctf_##name(SimObject *, S32, ConsoleValueRef *argv); \
+   returnType ctf_##name(SimObject *, S32, ConsoleValue *argv); \
    ConsoleConstructor cc_##name##_obj(NULL,#name,ctf_##name,usage1,minArgs,maxArgs, true); \
-   returnType ctf_##name(SimObject *, S32 argc, ConsoleValueRef *argv)
+   returnType ctf_##name(SimObject *, S32 argc, ConsoleValue *argv)
 
 #  define ConsoleFunctionGroupEnd(groupName) \
       static ConsoleConstructor cfg_##groupName##_GroupEnd(NULL,#groupName,NULL)
@@ -1289,23 +1289,23 @@ public:
 
 // These are identical to what's above, we just want to null out the usage strings.
 #  define ConsoleFunction(name,returnType,minArgs,maxArgs,usage1)                   \
-      static returnType c##name(SimObject *, S32, ConsoleValueRef*);                   \
+      static returnType c##name(SimObject *, S32, ConsoleValue*);                   \
       static ConsoleConstructor g##name##obj(NULL,#name,c##name,"",minArgs,maxArgs);\
-      static returnType c##name(SimObject *, S32 argc, ConsoleValueRef *argv)
+      static returnType c##name(SimObject *, S32 argc, ConsoleValue *argv)
 
 #  define ConsoleToolFunction(name,returnType,minArgs,maxArgs,usage1)                   \
-   static returnType c##name(SimObject *, S32, ConsoleValueRef*);                   \
+   static returnType c##name(SimObject *, S32, ConsoleValue*);                   \
    static ConsoleConstructor g##name##obj(NULL,#name,c##name,"",minArgs,maxArgs, true);\
-   static returnType c##name(SimObject *, S32 argc, ConsoleValueRef *argv)
+   static returnType c##name(SimObject *, S32 argc, ConsoleValue *argv)
 
 #  define ConsoleMethod(className,name,returnType,minArgs,maxArgs,usage1)                             \
-      static inline returnType c##className##name(className *, S32, ConsoleValueRef *argv);               \
-      static returnType c##className##name##caster(SimObject *object, S32 argc, ConsoleValueRef *argv) {  \
+      static inline returnType c##className##name(className *, S32, ConsoleValue *argv);               \
+      static returnType c##className##name##caster(SimObject *object, S32 argc, ConsoleValue *argv) {  \
          conmethod_return_##returnType ) c##className##name(static_cast<className*>(object),argc,argv);              \
       };                                                                                              \
       static ConsoleConstructor                                                                       \
          className##name##obj(#className,#name,c##className##name##caster,"",minArgs,maxArgs);        \
-      static inline returnType c##className##name(className *object, S32 argc, ConsoleValueRef *argv)
+      static inline returnType c##className##name(className *object, S32 argc, ConsoleValue *argv)
 
 #define ConsoleDoc( text )
 
diff --git a/Engine/source/console/consoleInternal.cpp b/Engine/source/console/consoleInternal.cpp
index a498be154..4fd2aaa0b 100644
--- a/Engine/source/console/consoleInternal.cpp
+++ b/Engine/source/console/consoleInternal.cpp
@@ -613,7 +613,7 @@ void Dictionary::validate()
       "Dictionary::validate() - Dictionary not owner of own hashtable!");
 }
 
-void ExprEvalState::pushFrame(StringTableEntry frameName, Namespace *ns)
+void ExprEvalState::pushFrame(StringTableEntry frameName, Namespace *ns, S32 registerCount)
 {
 #ifdef DEBUG_SPEW
    validate();
@@ -1266,7 +1266,7 @@ void Namespace::markGroup(const char* name, const char* usage)
 
 extern S32 executeBlock(StmtNode *block, ExprEvalState *state);
 
-ConsoleValueRef Namespace::Entry::execute(S32 argc, ConsoleValueRef *argv, ExprEvalState *state)
+ConsoleValue Namespace::Entry::execute(S32 argc, ConsoleValue *argv, ExprEvalState *state)
 {
    STR.clearFunctionOffset();
 
@@ -1274,11 +1274,11 @@ ConsoleValueRef Namespace::Entry::execute(S32 argc, ConsoleValueRef *argv, ExprE
    {
       if (mFunctionOffset)
       {
-         return mCode->exec(mFunctionOffset, argv[0], mNamespace, argc, argv, false, mPackage);
+         return std::move(mCode->exec(mFunctionOffset, argv[0].getString(), mNamespace, argc, argv, false, mPackage));
       }
       else
       {
-         return ConsoleValueRef();
+         return std::move(ConsoleValue());
       }
    }
 
@@ -1288,7 +1288,7 @@ ConsoleValueRef Namespace::Entry::execute(S32 argc, ConsoleValueRef *argv, ExprE
    if (mToolOnly && !Con::isCurrentScriptToolScript())
    {
       Con::errorf(ConsoleLogEntry::Script, "%s::%s - attempting to call tools only function from outside of tools", mNamespace->mName, mFunctionName);
-      return ConsoleValueRef();
+      return std::move(ConsoleValue());
    }
 #endif
 
@@ -1296,25 +1296,31 @@ ConsoleValueRef Namespace::Entry::execute(S32 argc, ConsoleValueRef *argv, ExprE
    {
       Con::warnf(ConsoleLogEntry::Script, "%s::%s - wrong number of arguments.", mNamespace->mName, mFunctionName);
       Con::warnf(ConsoleLogEntry::Script, "usage: %s", mUsage);
-      return ConsoleValueRef();
+      return std::move(ConsoleValue());
    }
 
+   ConsoleValue result;
    switch (mType)
    {
       case StringCallbackType:
-         return ConsoleValueRef::fromValue(CSTK.pushStackString(cb.mStringCallbackFunc(state->thisObject, argc, argv)));
+         const char* str = cb.mStringCallbackFunc(state->thisObject, argc, argv);
+         result.setString(str, dStrlen(str));
+         break;
       case IntCallbackType:
-         return ConsoleValueRef::fromValue(CSTK.pushUINT((U32)cb.mBoolCallbackFunc(state->thisObject, argc, argv)));
+         result.setInt(cb.mIntCallbackFunc(state->thisObject, argc, argv));
+         break;
       case FloatCallbackType:
-         return ConsoleValueRef::fromValue(CSTK.pushFLT((U32)cb.mBoolCallbackFunc(state->thisObject, argc, argv)));
+         result.setFloat(cb.mBoolCallbackFunc(state->thisObject, argc, argv));
+         break;
       case VoidCallbackType:
          cb.mVoidCallbackFunc(state->thisObject, argc, argv);
-         return ConsoleValueRef();
+         break;
       case BoolCallbackType:
-         return ConsoleValueRef::fromValue(CSTK.pushUINT((U32)cb.mBoolCallbackFunc(state->thisObject, argc, argv)));
+         result.setBool(cb.mBoolCallbackFunc(state->thisObject, argc, argv));
+         break;
    }
 
-   return ConsoleValueRef();
+   return std::move(result);
 }
 
 //-----------------------------------------------------------------------------
diff --git a/Engine/source/console/consoleInternal.h b/Engine/source/console/consoleInternal.h
index 151a75ac2..ac61f5331 100644
--- a/Engine/source/console/consoleInternal.h
+++ b/Engine/source/console/consoleInternal.h
@@ -150,7 +150,7 @@ public:
       void clear();
 
       ///
-      ConsoleValueRef execute(S32 argc, ConsoleValueRef* argv, ExprEvalState* state);
+      ConsoleValue execute(S32 argc, ConsoleValue* argv, ExprEvalState* state);
 
       /// Return a one-line documentation text string for the function.
       String getBriefDescription(String* outRemainingDocText = NULL) const;
diff --git a/Engine/source/console/engineAPI.h b/Engine/source/console/engineAPI.h
index 553cc7e71..8fefd5fdc 100644
--- a/Engine/source/console/engineAPI.h
+++ b/Engine/source/console/engineAPI.h
@@ -148,55 +148,45 @@ inline const char* EngineMarshallData( U32 value )
 /// Marshal data from native into client form stored directly in
 /// client function invocation vector.
 template< typename T >
-inline void EngineMarshallData( const T& arg, S32& argc, ConsoleValueRef *argv )
+inline void EngineMarshallData( const T& arg, S32& argc, ConsoleValue *argv )
 {
-   argv[ argc ] = castConsoleTypeToString( arg );
-   argc ++;
+   const char* str = castConsoleTypeToString(arg);;
+   argv[ argc++ ].setString(str, dStrlen(str));
 }
-inline void EngineMarshallData( bool arg, S32& argc, ConsoleValueRef *argv )
+inline void EngineMarshallData( bool arg, S32& argc, ConsoleValue *argv )
 {
-   if( arg )
-      argv[ argc ] = 1;
-   else
-      argv[ argc ] = 0;
-   argc ++;
+   argv[ argc++ ].setBool(arg);
 }
-inline void EngineMarshallData( S32 arg, S32& argc, ConsoleValueRef *argv )
+inline void EngineMarshallData( S32 arg, S32& argc, ConsoleValue *argv )
 {
-   argv[ argc ] = arg;
-   argc ++;
+   argv[ argc++ ].setInt(arg);
 }
-inline void EngineMarshallData( U32 arg, S32& argc, ConsoleValueRef *argv )
+inline void EngineMarshallData( U32 arg, S32& argc, ConsoleValue *argv )
 {
    EngineMarshallData( S32( arg ), argc, argv );
 }
-inline void EngineMarshallData( F32 arg, S32& argc, ConsoleValueRef *argv )
+inline void EngineMarshallData( F32 arg, S32& argc, ConsoleValue *argv )
 {
-   argv[ argc ] = arg;
-   argc ++;
+   argv[ argc++ ].setFloat(arg);
 }
-inline void EngineMarshallData( const char* arg, S32& argc, ConsoleValueRef *argv )
+inline void EngineMarshallData( const char* arg, S32& argc, ConsoleValue *argv )
 {
-   argv[ argc ] = arg;
-   argc ++;
+   argv[ argc++ ].setString(arg, dStrlen(arg));
 }
-inline void EngineMarshallData( char* arg, S32& argc, ConsoleValueRef *argv )
+inline void EngineMarshallData( char* arg, S32& argc, ConsoleValue *argv )
 {
-   argv[ argc ] = arg;
-   argc ++;
+   argv[ argc++ ].setString(arg, dStrlen(arg));
 }
 
 template< typename T >
-inline void EngineMarshallData( T* object, S32& argc, ConsoleValueRef *argv )
+inline void EngineMarshallData( T* object, S32& argc, ConsoleValue *argv )
 {
-   argv[ argc ] = object ? object->getId() : 0;
-   argc ++;
+   argv[ argc++ ].setInt(object ? object->getId() : 0);
 }
 template< typename T >
-inline void EngineMarshallData( const T* object, S32& argc, ConsoleValueRef *argv )
+inline void EngineMarshallData( const T* object, S32& argc, ConsoleValue *argv )
 {
-   argv[ argc ] = object ? object->getId() : 0;
-   argc ++;
+   argv[ argc++ ].setInt(object ? object->getId() : 0);
 }
 
 /// Unmarshal data from client form to engine form.
@@ -216,9 +206,9 @@ struct EngineUnmarshallData
 template<>
 struct EngineUnmarshallData< S32 >
 {
-   S32 operator()( ConsoleValueRef &ref ) const
+   S32 operator()( ConsoleValue &ref ) const
    {
-      return (S32)ref;
+      return (S32)ref.getInt();
    }
 
    S32 operator()( const char* str ) const
@@ -229,9 +219,9 @@ struct EngineUnmarshallData< S32 >
 template<>
 struct EngineUnmarshallData< U32 >
 {
-   U32 operator()( ConsoleValueRef &ref ) const
+   U32 operator()( ConsoleValue &ref ) const
    {
-      return (U32)((S32)ref);
+      return (U32)ref.getInt();
    }
 
    U32 operator()( const char* str ) const
@@ -242,9 +232,9 @@ struct EngineUnmarshallData< U32 >
 template<>
 struct EngineUnmarshallData< F32 >
 {
-   F32 operator()( ConsoleValueRef &ref ) const
+   F32 operator()( ConsoleValue &ref ) const
    {
-      return (F32)ref;
+      return (F32)ref.getFloat();
    }
 
    F32 operator()( const char* str ) const
@@ -255,9 +245,9 @@ struct EngineUnmarshallData< F32 >
 template<>
 struct EngineUnmarshallData< U8 >
 {
-   U8 operator()( ConsoleValueRef &ref ) const
+   U8 operator()( ConsoleValue &ref ) const
    {
-      return (U8)((S32)ref);
+      return (U8)((S32)ref.getInt());
    }
 
    U8 operator()( const char* str ) const
@@ -268,9 +258,9 @@ struct EngineUnmarshallData< U8 >
 template<>
 struct EngineUnmarshallData< const char* >
 {
-   const char* operator()( ConsoleValueRef &ref ) const
+   const char* operator()( ConsoleValue &ref ) const
    {
-      return ref.getStringValue();
+      return ref.getString();
    }
 
    const char* operator()( const char* str ) const
@@ -281,9 +271,9 @@ struct EngineUnmarshallData< const char* >
 template< typename T >
 struct EngineUnmarshallData< T* >
 {
-   T* operator()( ConsoleValueRef &ref ) const
+   T* operator()( ConsoleValue &ref ) const
    {
-      return dynamic_cast< T* >( Sim::findObject( ref.getStringValue() ) );
+      return dynamic_cast< T* >( Sim::findObject( ref ) );
    }
 
    T* operator()( const char* str ) const
@@ -294,17 +284,17 @@ struct EngineUnmarshallData< T* >
 template<>
 struct EngineUnmarshallData< void >
 {
-   void operator()( ConsoleValueRef& ) const {}
+   void operator()( ConsoleValue& ) const {}
    void operator()( const char* ) const {}
 };
 
 
 template<>
-struct EngineUnmarshallData< ConsoleValueRef >
+struct EngineUnmarshallData< ConsoleValue >
 {
-   ConsoleValueRef operator()( ConsoleValueRef ref ) const
+   ConsoleValue operator()( ConsoleValue &ref ) const
    {
-      return ref;
+      return std::move(ref);
    }
 };
 
@@ -548,7 +538,7 @@ namespace engineAPI{
          static const S32 NUM_ARGS = sizeof...(ArgTs) + startArgc;
          
          template<size_t index, size_t method_offset = 0, typename ...RealArgTs>
-         static IthArgType<index> getRealArgValue(S32 argc, ConsoleValueRef *argv, const _EngineFunctionDefaultArguments< void(RealArgTs...) >& defaultArgs)
+         static IthArgType<index> getRealArgValue(S32 argc, ConsoleValue *argv, const _EngineFunctionDefaultArguments< void(RealArgTs...) >& defaultArgs)
          {
             if((startArgc + index) < argc)
             {
@@ -559,12 +549,12 @@ namespace engineAPI{
          }
          
          template<size_t ...I>
-         static R dispatchHelper(S32 argc, ConsoleValueRef *argv, FunctionType fn, const _EngineFunctionDefaultArguments< void(ArgTs...) >& defaultArgs, Seq<I...>){
+         static R dispatchHelper(S32 argc, ConsoleValue *argv, FunctionType fn, const _EngineFunctionDefaultArguments< void(ArgTs...) >& defaultArgs, Seq<I...>){
             return fn(SelfType::getRealArgValue<I>(argc, argv, defaultArgs) ...);
          }
          
          template<typename Frame, size_t ...I>
-         static R dispatchHelper(S32 argc, ConsoleValueRef *argv, MethodType<Frame> fn, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, ArgTs...) >& defaultArgs, Seq<I...>){
+         static R dispatchHelper(S32 argc, ConsoleValue *argv, MethodType<Frame> fn, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, ArgTs...) >& defaultArgs, Seq<I...>){
             return (frame->*fn)(SelfType::getRealArgValue<I,1>(argc, argv, defaultArgs) ...);
          }
          
@@ -579,9 +569,9 @@ namespace engineAPI{
          }
       };
       
-      template<> struct MarshallHelpers<ConsoleValueRef> {
-         template<typename ...ArgTs> static void marshallEach(S32 &argc, ConsoleValueRef *argv, const ArgTs& ...args){}
-         template<typename H, typename ...Tail> static void marshallEach(S32 &argc, ConsoleValueRef *argv, const H& head, const Tail& ...tail){
+      template<> struct MarshallHelpers<ConsoleValue> {
+         template<typename ...ArgTs> static void marshallEach(S32 &argc, ConsoleValue *argv, const ArgTs& ...args){}
+         template<typename H, typename ...Tail> static void marshallEach(S32 &argc, ConsoleValue *argv, const H& head, const Tail& ...tail){
             EngineMarshallData(head, argc, argv);
             marshallEach(argc, argv, tail...);
          }
@@ -604,12 +594,12 @@ public:
    template<typename Frame> using MethodType = typename Helper::template MethodType<Frame>;
    static const S32 NUM_ARGS = Helper::NUM_ARGS;
    
-   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, FunctionType fn, const _EngineFunctionDefaultArguments< void(ArgTs...) >& defaultArgs)
+   static ReturnType thunk( S32 argc, ConsoleValue *argv, FunctionType fn, const _EngineFunctionDefaultArguments< void(ArgTs...) >& defaultArgs)
    {
       return _EngineConsoleThunkReturnValue( Helper::dispatchHelper(argc, argv, fn, defaultArgs, SeqType()));
    }
    template< typename Frame >
-   static ReturnType thunk( S32 argc, ConsoleValueRef *argv, MethodType<Frame> fn, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, ArgTs...) >& defaultArgs)
+   static ReturnType thunk( S32 argc, ConsoleValue *argv, MethodType<Frame> fn, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, ArgTs...) >& defaultArgs)
    {
       return _EngineConsoleThunkReturnValue( Helper::dispatchHelper(argc, argv, fn, frame, defaultArgs, SeqType()));
    }
@@ -627,12 +617,12 @@ public:
    template<typename Frame> using MethodType = typename Helper::template MethodType<Frame>;
    static const S32 NUM_ARGS = Helper::NUM_ARGS;
    
-   static void thunk( S32 argc, ConsoleValueRef *argv, FunctionType fn, const _EngineFunctionDefaultArguments< void(ArgTs...) >& defaultArgs)
+   static void thunk( S32 argc, ConsoleValue *argv, FunctionType fn, const _EngineFunctionDefaultArguments< void(ArgTs...) >& defaultArgs)
    {
       Helper::dispatchHelper(argc, argv, fn, defaultArgs, SeqType());
    }
    template< typename Frame >
-   static void thunk( S32 argc, ConsoleValueRef *argv, MethodType<Frame> fn, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, ArgTs...) >& defaultArgs)
+   static void thunk( S32 argc, ConsoleValue *argv, MethodType<Frame> fn, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, ArgTs...) >& defaultArgs)
    {
       Helper::dispatchHelper(argc, argv, fn, frame, defaultArgs, SeqType());
    }
@@ -705,7 +695,7 @@ public:
       ( void* ) &fn ## name,                                                                                                     \
       0                                                                                                                          \
    );                                                                                                                            \
-   static _EngineConsoleThunkType< returnType >::ReturnType _ ## name ## caster( SimObject*, S32 argc, ConsoleValueRef *argv )   \
+   static _EngineConsoleThunkType< returnType >::ReturnType _ ## name ## caster( SimObject*, S32 argc, ConsoleValue *argv )      \
    {                                                                                                                             \
       return _EngineConsoleThunkType< returnType >::ReturnType( _EngineConsoleThunk< 1, returnType args >::thunk(                \
          argc, argv, &_fn ## name ## impl, _fn ## name ## DefaultArgs                                                            \
@@ -785,7 +775,7 @@ public:
       ( void* ) &fn ## className ## _ ## name,                                                                                                  \
       0                                                                                                                                         \
    );                                                                                                                                           \
-   static _EngineConsoleThunkType< returnType >::ReturnType _ ## className ## name ## caster( SimObject* object, S32 argc, ConsoleValueRef *argv )  \
+   static _EngineConsoleThunkType< returnType >::ReturnType _ ## className ## name ## caster( SimObject* object, S32 argc, ConsoleValue *argv )  \
    {                                                                                                                                            \
       _ ## className ## name ## frame frame;                                                                                                    \
       frame.object = static_cast< className* >( object );                                                                                       \
@@ -842,7 +832,7 @@ public:
       ( void* ) &fn ## className ## _ ## name,                                                                                         \
       0                                                                                                                                \
    );                                                                                                                                  \
-   static _EngineConsoleThunkType< returnType >::ReturnType _ ## className ## name ## caster( SimObject*, S32 argc, ConsoleValueRef *argv )\
+   static _EngineConsoleThunkType< returnType >::ReturnType _ ## className ## name ## caster( SimObject*, S32 argc, ConsoleValue *argv )\
    {                                                                                                                                   \
       return _EngineConsoleThunkType< returnType >::ReturnType( _EngineConsoleThunk< 1, returnType args >::thunk(                      \
          argc, argv, &_fn ## className ## name ## impl, _fn ## className ## name ## DefaultArgs                                        \
@@ -859,7 +849,7 @@ public:
    static inline returnType _fn ## className ## name ## impl args
 
 #  define DefineEngineStringlyVariadicFunction(name,returnType,minArgs,maxArgs,usage)                                            \
-   static inline returnType _fn ## name ## impl (SimObject *, S32 argc, ConsoleValueRef *argv);                                  \
+   static inline returnType _fn ## name ## impl (SimObject *, S32 argc, ConsoleValue *argv);                                     \
    TORQUE_API EngineTypeTraits< returnType >::ReturnValueType fn ## name                                                         \
       (Vector<const char*>* vec)                                                                                                 \
    {                                                                                                                             \
@@ -882,14 +872,14 @@ public:
       0                                                                                                                          \
    );                                                                                                                            \
    ConsoleConstructor cc_##name##_obj(NULL,#name,_fn ## name ## impl,usage,minArgs,maxArgs); \
-      returnType _fn ## name ## impl(SimObject *, S32 argc, ConsoleValueRef *argv)
+      returnType _fn ## name ## impl(SimObject *, S32 argc, ConsoleValue *argv)
 
 #  define DefineEngineStringlyVariadicMethod(className, name,returnType,minArgs,maxArgs,usage)                                   \
    struct _ ## className ## name ## frame                                                                                        \
    {                                                                                                                             \
       typedef className ObjectType;                                                                                              \
       className* object;                                                                                                         \
-      inline returnType _exec (S32 argc, ConsoleValueRef* argv) const;                                                           \
+      inline returnType _exec (S32 argc, ConsoleValue* argv) const;                                                              \
    };                                                                                                                            \
    TORQUE_API EngineTypeTraits< returnType >::ReturnValueType fn ## className ## _ ## name                                       \
       (className* object, Vector<const char*>* vec)                                                                              \
@@ -915,14 +905,14 @@ public:
       ( void* ) &fn ## className ## _ ## name,                                                                                   \
       0                                                                                                                          \
    );                                                                                                                            \
-   returnType cm_##className##_##name##_caster(SimObject* object, S32 argc, ConsoleValueRef* argv) {                             \
+   returnType cm_##className##_##name##_caster(SimObject* object, S32 argc, ConsoleValue* argv) {                                \
       AssertFatal( dynamic_cast<className*>( object ), "Object passed to " #name " is not a " #className "!" );                  \
       _ ## className ## name ## frame frame {};                                                                                  \
       frame.object = static_cast< className* >( object );                                                                        \
       conmethod_return_##returnType ) frame._exec(argc,argv);                                                                    \
    };                                                                                                                            \
    ConsoleConstructor cc_##className##_##name##_obj(#className,#name,cm_##className##_##name##_caster,usage,minArgs,maxArgs);    \
-   inline returnType _ ## className ## name ## frame::_exec(S32 argc, ConsoleValueRef *argv) const
+   inline returnType _ ## className ## name ## frame::_exec(S32 argc, ConsoleValue *argv) const
 
 
 
@@ -1167,10 +1157,10 @@ public:
    S32 mInitialArgc;
    S32 mArgc;
    StringTableEntry mCallbackName;
-   ConsoleValueRef mArgv[ MAX_ARGUMENTS + 2 ];
+   ConsoleValue mArgv[ MAX_ARGUMENTS + 2 ];
 
-   ConsoleValueRef _exec();
-   ConsoleValueRef _execLater(SimConsoleThreadExecEvent *evt);
+   ConsoleValue _exec();
+   ConsoleValue _execLater(SimConsoleThreadExecEvent *evt);
 
    _BaseEngineConsoleCallbackHelper(): mThis(NULL), mInitialArgc(0), mArgc(0), mCallbackName(StringTable->EmptyString()){;}
 };
@@ -1181,7 +1171,7 @@ public:
 struct _EngineConsoleCallbackHelper : public _BaseEngineConsoleCallbackHelper
 {
 private:
-   using Helper = engineAPI::detail::MarshallHelpers<ConsoleValueRef>;
+   using Helper = engineAPI::detail::MarshallHelpers<ConsoleValue>;
 public:
 
    _EngineConsoleCallbackHelper( StringTableEntry callbackName, SimObject* pThis )
@@ -1244,7 +1234,7 @@ public:
       {
          ConsoleStackFrameSaver sav; sav.save();
          CSTK.reserveValues(mArgc+sizeof...(ArgTs), mArgv);
-         mArgv[ 0 ].value->setStackStringValue(simCB);
+         mArgv[ 0 ].setString(simCB, dStrlen(simCB));
 
         Helper::marshallEach(mArgc, mArgv, args...);
 
@@ -1255,7 +1245,7 @@ public:
          SimConsoleThreadExecCallback cb;
          SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+sizeof...(ArgTs), NULL, true, &cb);
          evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(simCB);
+         mArgv[ 0 ].setString(simCB, dStrlen(simCB));
         
         Helper::marshallEach(mArgc, mArgv, args...);
 
@@ -1270,7 +1260,7 @@ public:
 template<> struct _EngineConsoleExecCallbackHelper<const char*> : public _BaseEngineConsoleCallbackHelper
 {
 private:
-   using Helper = engineAPI::detail::MarshallHelpers<ConsoleValueRef>;
+   using Helper = engineAPI::detail::MarshallHelpers<ConsoleValue>;
 public:
    _EngineConsoleExecCallbackHelper( const char *callbackName )
    {
@@ -1285,10 +1275,9 @@ public:
       if (Con::isMainThread())
       {
          ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+sizeof...(ArgTs), mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
+         mArgv[ 0 ].setStringTableEntry(mCallbackName);
         
-        Helper::marshallEach(mArgc, mArgv, args...);
+         Helper::marshallEach(mArgc, mArgv, args...);
         
          return R( EngineUnmarshallData< R >()( _exec() ) );
       }
@@ -1297,7 +1286,7 @@ public:
          SimConsoleThreadExecCallback cb;
          SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+sizeof...(ArgTs), NULL, false, &cb);
          evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
+         mArgv[ 0 ].setStringTableEntry(mCallbackName);
         
         Helper::marshallEach(mArgc, mArgv, args...);
 
diff --git a/Engine/source/console/simEvents.cpp b/Engine/source/console/simEvents.cpp
index ab87f5f0b..97eb74d40 100644
--- a/Engine/source/console/simEvents.cpp
+++ b/Engine/source/console/simEvents.cpp
@@ -28,30 +28,23 @@
 // Stupid globals not declared in a header
 extern ExprEvalState gEvalState;
 
-SimConsoleEvent::SimConsoleEvent(S32 argc, ConsoleValueRef *argv, bool onObject)
+SimConsoleEvent::SimConsoleEvent(S32 argc, ConsoleValue *argv, bool onObject)
 {
    mOnObject = onObject;
    mArgc = argc;
 
-   mArgv = new ConsoleValueRef[argc];
+   mArgv = new ConsoleValue[argc];
    for (int i=0; i<argc; i++)
    {
-      mArgv[i].value = new ConsoleValue();
-      mArgv[i].value->type = ConsoleValue::TypeInternalString;
-      mArgv[i].value->init();
-     if (argv)
-     {
-      mArgv[i].value->setStringValue((const char*)argv[i]);
-     }
+      if (argv)
+      {
+         mArgv->setString(argv[i].getString(), dStrlen(argv[i].getString()));
+      }
    }
 }
 
 SimConsoleEvent::~SimConsoleEvent()
 {
-   for (int i=0; i<mArgc; i++)
-   {
-      delete mArgv[i].value;
-   }
    delete[] mArgv;
 }
 
@@ -67,7 +60,7 @@ void SimConsoleEvent::process(SimObject* object)
       // Grab the function name. If '::' doesn't exist, then the schedule is
       // on a global function.
       char funcName[256];
-      dStrncpy(funcName, (const char*)mArgv[0], 256);
+      dStrncpy(funcName, mArgv[0].getString(), 256);
       char* func = dStrstr( funcName, (char*)"::" );
       if( func )
       {
@@ -95,11 +88,11 @@ void SimConsoleEvent::process(SimObject* object)
    }
 }
 
-void SimConsoleEvent::populateArgs(ConsoleValueRef *argv)
+void SimConsoleEvent::populateArgs(ConsoleValue *argv)
 {
    for (U32 i=0; i<mArgc; i++)
    {
-      argv[i].value = mArgv[i].value;
+      argv[i].setString(mArgv[i].getString(), dStrlen(mArgv[i].getString()));
    }
 }
 
@@ -107,7 +100,6 @@ void SimConsoleEvent::populateArgs(ConsoleValueRef *argv)
 
 SimConsoleThreadExecCallback::SimConsoleThreadExecCallback()
 {
-   retVal.value = NULL;
    sem = new Semaphore(0);
 }
 
@@ -116,37 +108,44 @@ SimConsoleThreadExecCallback::~SimConsoleThreadExecCallback()
    delete sem;
 }
 
-void SimConsoleThreadExecCallback::handleCallback(ConsoleValueRef ret)
+void SimConsoleThreadExecCallback::handleCallback(ConsoleValue ret)
 {
-   retVal = ret;
+   // can we move this pls?
+   retVal.setString(ret.getString(), dStrlen(ret.getString()));
    sem->release();
 }
 
-ConsoleValueRef SimConsoleThreadExecCallback::waitForResult()
+ConsoleValue SimConsoleThreadExecCallback::waitForResult()
 {
    if(sem->acquire(true))
    {
-      return retVal;
+      return std::move(retVal);
    }
 
-   return ConsoleValueRef();
+   return ConsoleValue();
 }
 
 //-----------------------------------------------------------------------------
 
-SimConsoleThreadExecEvent::SimConsoleThreadExecEvent(S32 argc, ConsoleValueRef *argv, bool onObject, SimConsoleThreadExecCallback *callback) :
+SimConsoleThreadExecEvent::SimConsoleThreadExecEvent(S32 argc, ConsoleValue *argv, bool onObject, SimConsoleThreadExecCallback *callback) :
    SimConsoleEvent(argc, argv, onObject), cb(callback)
 {
 }
 
 void SimConsoleThreadExecEvent::process(SimObject* object)
 {
-   ConsoleValueRef retVal;
-   if(mOnObject)
-      retVal = Con::execute(object, mArgc, mArgv);
+   if (cb)
+   {
+      if (mOnObject)
+         cb->handleCallback(std::move(Con::execute(object, mArgc, mArgv)));
+      else
+         cb->handleCallback(std::move(Con::execute(mArgc, mArgv)));
+   }
    else
-      retVal = Con::execute(mArgc, mArgv);
-
-   if(cb)
-      cb->handleCallback(retVal);
+   {
+      if (mOnObject)
+         Con::execute(object, mArgc, mArgv);
+      else
+         Con::execute(mArgc, mArgv);
+   }
 }
diff --git a/Engine/source/console/simEvents.h b/Engine/source/console/simEvents.h
index 6fbb6a798..20fa53f5b 100644
--- a/Engine/source/console/simEvents.h
+++ b/Engine/source/console/simEvents.h
@@ -91,7 +91,7 @@ class SimConsoleEvent : public SimEvent
 {
 protected:
    S32 mArgc;
-   ConsoleValueRef *mArgv;
+   ConsoleValue *mArgv;
    bool mOnObject;
 public:
 
@@ -108,13 +108,13 @@ public:
    ///
    /// @see Con::execute(S32 argc, const char *argv[])
    /// @see Con::execute(SimObject *object, S32 argc, const char *argv[])
-   SimConsoleEvent(S32 argc, ConsoleValueRef *argv, bool onObject);
+   SimConsoleEvent(S32 argc, ConsoleValue *argv, bool onObject);
 
    ~SimConsoleEvent();
    virtual void process(SimObject *object);
 
    /// Creates a reference to our internal args list in argv
-   void populateArgs(ConsoleValueRef *argv);
+   void populateArgs(ConsoleValue *argv);
 };
 
 
@@ -123,13 +123,13 @@ public:
 struct SimConsoleThreadExecCallback
 {
    Semaphore   *sem;
-   ConsoleValueRef retVal;
+   ConsoleValue retVal;
 
    SimConsoleThreadExecCallback();
    ~SimConsoleThreadExecCallback();
 
-   void handleCallback(ConsoleValueRef ret);
-   ConsoleValueRef waitForResult();
+   void handleCallback(ConsoleValue ret);
+   ConsoleValue waitForResult();
 };
 
 class SimConsoleThreadExecEvent : public SimConsoleEvent
@@ -137,7 +137,7 @@ class SimConsoleThreadExecEvent : public SimConsoleEvent
    SimConsoleThreadExecCallback *cb;
 
 public:
-   SimConsoleThreadExecEvent(S32 argc, ConsoleValueRef *argv, bool onObject, SimConsoleThreadExecCallback *callback);
+   SimConsoleThreadExecEvent(S32 argc, ConsoleValue *argv, bool onObject, SimConsoleThreadExecCallback *callback);
 
    SimConsoleThreadExecCallback& getCB() { return *cb; }
    virtual void process(SimObject *object);
diff --git a/Engine/source/console/simObject.cpp b/Engine/source/console/simObject.cpp
index ea0da309c..008ba9698 100644
--- a/Engine/source/console/simObject.cpp
+++ b/Engine/source/console/simObject.cpp
@@ -141,7 +141,7 @@ SimObject::~SimObject()
 
 //-----------------------------------------------------------------------------
 
-bool SimObject::processArguments(S32 argc, ConsoleValueRef *argv)
+bool SimObject::processArguments(S32 argc, ConsoleValue *argv)
 {
    return argc == 0;
 }
diff --git a/Engine/source/console/simObject.h b/Engine/source/console/simObject.h
index 102689b41..9cef85f0f 100644
--- a/Engine/source/console/simObject.h
+++ b/Engine/source/console/simObject.h
@@ -587,7 +587,7 @@ class SimObject: public ConsoleObject, public TamlCallbacks
       
       virtual ~SimObject();
 
-      virtual bool processArguments(S32 argc, ConsoleValueRef *argv);  ///< Process constructor options. (ie, new SimObject(1,2,3))
+      virtual bool processArguments(S32 argc, ConsoleValue *argv);  ///< Process constructor options. (ie, new SimObject(1,2,3))
 
       /// @}
 
diff --git a/Engine/source/console/simPersistSet.cpp b/Engine/source/console/simPersistSet.cpp
index 00840c649..771e8ce0c 100644
--- a/Engine/source/console/simPersistSet.cpp
+++ b/Engine/source/console/simPersistSet.cpp
@@ -47,7 +47,7 @@ SimPersistSet::SimPersistSet()
 
 //-----------------------------------------------------------------------------
 
-bool SimPersistSet::processArguments( S32 argc, ConsoleValueRef *argv )
+bool SimPersistSet::processArguments( S32 argc, ConsoleValue *argv )
 {
    for( U32 i = 0; i < argc; ++ i )
    {
diff --git a/Engine/source/console/simPersistSet.h b/Engine/source/console/simPersistSet.h
index d1769cff0..e09a828ff 100644
--- a/Engine/source/console/simPersistSet.h
+++ b/Engine/source/console/simPersistSet.h
@@ -58,7 +58,7 @@ class SimPersistSet : public SimSet
       // SimSet.
       virtual void addObject( SimObject* );
       virtual void write( Stream &stream, U32 tabStop, U32 flags = 0 );
-      virtual bool processArguments( S32 argc, ConsoleValueRef *argv );
+      virtual bool processArguments( S32 argc, ConsoleValue *argv );
       
       DECLARE_CONOBJECT( SimPersistSet );
       DECLARE_CATEGORY( "Console" );
diff --git a/Engine/source/console/test/ScriptTest.cpp b/Engine/source/console/test/ScriptTest.cpp
index b0674765b..1b937c755 100644
--- a/Engine/source/console/test/ScriptTest.cpp
+++ b/Engine/source/console/test/ScriptTest.cpp
@@ -20,7 +20,6 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#ifdef 0
 #ifdef TORQUE_TESTS_ENABLED
 #include "testing/unitTesting.h"
 #include "platform/platform.h"
@@ -32,40 +31,40 @@
 #include "console/stringStack.h"
 
 template<typename T>
-inline T Convert(ConsoleValueRef);
+inline T Convert(ConsoleValue&);
 
 template<>
-inline U32 Convert(ConsoleValueRef val)
+inline U32 Convert(ConsoleValue &val)
 {
-   return val.getIntValue();
+   return val.getInt();
 }
 
 template<>
-inline S32 Convert(ConsoleValueRef val)
+inline S32 Convert(ConsoleValue &val)
 {
-   return val.getSignedIntValue();
+   return val.getInt();
 }
 
 template<>
-inline bool Convert(ConsoleValueRef val)
+inline bool Convert(ConsoleValue &val)
 {
-   return val.getBoolValue();
+   return val.getBool();
 }
 
 template<>
-inline F32 Convert(ConsoleValueRef val)
+inline F32 Convert(ConsoleValue &val)
 {
-   return val.getFloatValue();
+   return val.getFloat();
 }
 
 template<>
-inline const char* Convert(ConsoleValueRef val)
+inline const char* Convert(ConsoleValue &val)
 {
-   return val.getStringValue();
+   return val.getString();
 }
 
 template<>
-inline SimObject* Convert(ConsoleValueRef val)
+inline SimObject* Convert(ConsoleValue &val)
 {
    return Sim::findObject(val);
 }
@@ -73,7 +72,7 @@ inline SimObject* Convert(ConsoleValueRef val)
 template<typename T>
 inline T RunScript(const char* str)
 {
-   return Convert<T>(Con::evaluate(str, false, NULL));
+   return Convert<T>(std::move(Con::evaluate(str, false, NULL)));
 }
 
 TEST(Script, Basic_Arithmetic)
@@ -394,4 +393,3 @@ TEST(Script, Basic_Package)
 }
 
 #endif
-#endif

From 02447f0996643bb75e86f100b7ad98bbdfecbec8 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Wed, 31 Mar 2021 22:10:55 -0400
Subject: [PATCH 005/399] compile fixes.

---
 Engine/source/Verve/Core/VDataTable.cpp       |    2 +-
 Engine/source/afx/afxMagicSpell.cpp           |   16 +-
 Engine/source/afx/arcaneFX.cpp                |    6 +-
 Engine/source/app/mainLoop.cpp                |    4 -
 Engine/source/console/CMDgram.y               |    7 +-
 Engine/source/console/CMDscan.cpp             | 2723 ++++++-------
 Engine/source/console/cmdgram.cpp             | 3388 ++++++++---------
 Engine/source/console/codeBlock.cpp           |    6 +-
 Engine/source/console/compiledEval.cpp        |   12 +-
 Engine/source/console/console.cpp             |    5 +
 Engine/source/console/console.h               |   56 +-
 Engine/source/console/consoleInternal.cpp     |   13 +-
 Engine/source/console/consoleInternal.h       |    5 +-
 Engine/source/console/engineAPI.h             |    6 +-
 Engine/source/console/engineDoc.cpp           |    4 +-
 Engine/source/console/optimizer.cpp           |  104 +
 Engine/source/console/simObject.cpp           |    8 +-
 Engine/source/console/test/consoleTest.cpp    |    2 +-
 .../gui/controls/guiGameListMenuCtrl.cpp      |    6 +-
 .../source/shaderGen/customShaderFeature.cpp  |    2 +-
 20 files changed, 3207 insertions(+), 3168 deletions(-)
 create mode 100644 Engine/source/console/optimizer.cpp

diff --git a/Engine/source/Verve/Core/VDataTable.cpp b/Engine/source/Verve/Core/VDataTable.cpp
index f338c5ac4..9bb4b92ff 100644
--- a/Engine/source/Verve/Core/VDataTable.cpp
+++ b/Engine/source/Verve/Core/VDataTable.cpp
@@ -228,7 +228,7 @@ bool VDataTable::getValue( SimObject *pObject, const String &pFieldName, String
         case VDataTable::k_TypeExpression :
             {
                 // Evaluate.
-                pValue = Con::evaluate( fieldValue, false ).getStringValue();
+                pValue = Con::evaluate( fieldValue, false ).getString();
 
             } break;
 
diff --git a/Engine/source/afx/afxMagicSpell.cpp b/Engine/source/afx/afxMagicSpell.cpp
index b45d7c131..9d05f0b80 100644
--- a/Engine/source/afx/afxMagicSpell.cpp
+++ b/Engine/source/afx/afxMagicSpell.cpp
@@ -2638,23 +2638,25 @@ DefineEngineStringlyVariadicMethod(afxMagicSpell, setTimeFactor, void, 3, 4, "(F
    "@ingroup AFX")
 {
    if (argc == 3)
-      object->setTimeFactor(dAtof(argv[2]));
+      object->setTimeFactor(argv[2].getFloat());
    else
    {
+      F32 value = argv[3].getFloat();
+
       if (dStricmp(argv[2], "overall") == 0)
          object->setTimeFactor(dAtof(argv[3]));
       else if (dStricmp(argv[2], "casting") == 0)
-         object->setTimeFactor(afxMagicSpell::CASTING_PHRASE, dAtof(argv[3]));
+         object->setTimeFactor(afxMagicSpell::CASTING_PHRASE, value);
       else if (dStricmp(argv[2], "launch") == 0)
-         object->setTimeFactor(afxMagicSpell::LAUNCH_PHRASE, dAtof(argv[3]));
+         object->setTimeFactor(afxMagicSpell::LAUNCH_PHRASE, value);
       else if (dStricmp(argv[2], "delivery") == 0)
-         object->setTimeFactor(afxMagicSpell::DELIVERY_PHRASE, dAtof(argv[3]));
+         object->setTimeFactor(afxMagicSpell::DELIVERY_PHRASE, value);
       else if (dStricmp(argv[2], "impact") == 0)
-         object->setTimeFactor(afxMagicSpell::IMPACT_PHRASE, dAtof(argv[3]));
+         object->setTimeFactor(afxMagicSpell::IMPACT_PHRASE, value);
       else if (dStricmp(argv[2], "linger") == 0)
-         object->setTimeFactor(afxMagicSpell::LINGER_PHRASE, dAtof(argv[3]));
+         object->setTimeFactor(afxMagicSpell::LINGER_PHRASE, value);
       else
-         Con::errorf("afxMagicSpell::setTimeFactor() -- unknown spell phrase [%s].", argv[2].getStringValue());
+         Con::errorf("afxMagicSpell::setTimeFactor() -- unknown spell phrase [%s].", argv[2].getString());
    }
 }
 
diff --git a/Engine/source/afx/arcaneFX.cpp b/Engine/source/afx/arcaneFX.cpp
index 385c056f6..5c7ea3460 100644
--- a/Engine/source/afx/arcaneFX.cpp
+++ b/Engine/source/afx/arcaneFX.cpp
@@ -874,7 +874,7 @@ DefineEngineStringlyVariadicFunction(echoThru, const char*, 2, 0, "(string passt
    for (i = 2; i < argc; i++)
       dStrcat(ret, argv[i], len + 1);
 
-   Con::printf("%s -- [%s]", ret, argv[1].getStringValue());
+   Con::printf("%s -- [%s]", ret, argv[1].getString());
    ret[0] = 0;
 
    return argv[1];
@@ -894,7 +894,7 @@ DefineEngineStringlyVariadicFunction(warnThru, const char*, 2, 0, "(string passt
    for(i = 2; i < argc; i++)
       dStrcat(ret, argv[i], len + 1);
 
-   Con::warnf("%s -- [%s]", ret, argv[1].getStringValue());
+   Con::warnf("%s -- [%s]", ret, argv[1].getString());
    ret[0] = 0;
 
    return argv[1];
@@ -914,7 +914,7 @@ DefineEngineStringlyVariadicFunction(errorThru, const char*, 2, 0, "(string pass
    for(i = 2; i < argc; i++)
       dStrcat(ret, argv[i], len + 1);
 
-   Con::errorf("%s -- [%s]", ret, argv[1].getStringValue());
+   Con::errorf("%s -- [%s]", ret, argv[1].getString());
    ret[0] = 0;
 
    return argv[1];
diff --git a/Engine/source/app/mainLoop.cpp b/Engine/source/app/mainLoop.cpp
index 13a331075..871a7cc88 100644
--- a/Engine/source/app/mainLoop.cpp
+++ b/Engine/source/app/mainLoop.cpp
@@ -45,7 +45,6 @@
 #include "console/debugOutputConsumer.h"
 #include "console/consoleTypes.h"
 #include "console/engineAPI.h"
-#include "console/codeInterpreter.h"
 
 #include "gfx/bitmap/gBitmap.h"
 #include "gfx/gFont.h"
@@ -229,9 +228,6 @@ void StandardMainLoop::init()
    ManagedSingleton< ThreadManager >::createSingleton();
    FrameAllocator::init(TORQUE_FRAME_SIZE);      // See comments in torqueConfig.h
 
-   // Initialize the TorqueScript interpreter.
-   CodeInterpreter::init();
-
    // Yell if we can't initialize the network.
    if(!Net::init())
    {
diff --git a/Engine/source/console/CMDgram.y b/Engine/source/console/CMDgram.y
index 6cfbf3311..0b15c0e93 100644
--- a/Engine/source/console/CMDgram.y
+++ b/Engine/source/console/CMDgram.y
@@ -456,6 +456,8 @@ expr
       { $$ = (ExprNode*)VarNode::alloc( $1.lineNumber, $1.value, NULL); }
    | VAR '[' aidx_expr ']'
       { $$ = (ExprNode*)VarNode::alloc( $1.lineNumber, $1.value, $3 ); }
+   ;
+/*
    | rwDEFINE '(' var_list_decl ')' '{' statement_list '}'
       {
          const U32 bufLen = 64;
@@ -471,7 +473,7 @@ expr
 
          $$ = StrConstNode::alloc( $1.lineNumber, (UTF8*)fName, false );
       }
-   ;
+*/
 
 slot_acc
    : expr '.' IDENT
@@ -551,9 +553,12 @@ funcall_expr
      { $$ = FuncCallExprNode::alloc( $1.lineNumber, $3.value, $1.value, $5, false); }
    | expr '.' IDENT '(' expr_list_decl ')'
       { $1->append($5); $$ = FuncCallExprNode::alloc( $1->dbgLineNumber, $3.value, NULL, $1, true); }
+   ;
+/*
    | expr '(' expr_list_decl ')'
       { $$ = FuncPointerCallExprNode::alloc( $1->dbgLineNumber, $1, $3); }
    ;
+*/
 
 assert_expr
    : rwASSERT '(' expr ')'
diff --git a/Engine/source/console/CMDscan.cpp b/Engine/source/console/CMDscan.cpp
index c30ac7bc9..43a864570 100644
--- a/Engine/source/console/CMDscan.cpp
+++ b/Engine/source/console/CMDscan.cpp
@@ -20,8 +20,8 @@
 /* A lexical scanner generated by flex */
 
 /* Scanner skeleton version:
-* $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.85 95/04/24 10:48:47 vern Exp $
-*/
+ * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.85 95/04/24 10:48:47 vern Exp $
+ */
 
 #define FLEX_SCANNER
 #define YY_FLEX_MAJOR_VERSION 2
@@ -60,8 +60,8 @@
 #endif	/* ! __cplusplus */
 
 #ifdef __TURBOC__
-#pragma warn -rch
-#pragma warn -use
+ #pragma warn -rch
+ #pragma warn -use
 #include <io.h>
 #include <stdlib.h>
 #define YY_USE_CONST
@@ -85,22 +85,22 @@
 #define YY_NULL 0
 
 /* Promotes a possibly negative, possibly signed char to an unsigned
-* integer for use as an array index.  If the signed char is negative,
-* we want to instead treat it as an 8-bit unsigned char, hence the
-* double cast.
-*/
+ * integer for use as an array index.  If the signed char is negative,
+ * we want to instead treat it as an 8-bit unsigned char, hence the
+ * double cast.
+ */
 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
 
 /* Enter a start condition.  This macro really ought to take a parameter,
-* but we do it the disgusting crufty way forced on us by the ()-less
-* definition of BEGIN.
-*/
+ * but we do it the disgusting crufty way forced on us by the ()-less
+ * definition of BEGIN.
+ */
 #define BEGIN yy_start = 1 + 2 *
 
 /* Translate the current start state into a value that can be later handed
-* to BEGIN to return to the state.  The YYSTATE alias is for lex
-* compatibility.
-*/
+ * to BEGIN to return to the state.  The YYSTATE alias is for lex
+ * compatibility.
+ */
 #define YY_START ((yy_start - 1) / 2)
 #define YYSTATE YY_START
 
@@ -125,18 +125,18 @@ extern FILE *yyin, *yyout;
 #define EOB_ACT_LAST_MATCH 2
 
 /* The funky do-while in the following #define is used to turn the definition
-* int a single C statement (which needs a semi-colon terminator).  This
-* avoids problems with code like:
-*
-* 	if ( condition_holds )
-*		yyless( 5 );
-*	else
-*		do_something_else();
-*
-* Prior to using the do-while the compiler would get upset at the
-* "else" because it interpreted the "if" statement as being all
-* done when it reached the ';' after the yyless() call.
-*/
+ * int a single C statement (which needs a semi-colon terminator).  This
+ * avoids problems with code like:
+ *
+ * 	if ( condition_holds )
+ *		yyless( 5 );
+ *	else
+ *		do_something_else();
+ *
+ * Prior to using the do-while the compiler would get upset at the
+ * "else" because it interpreted the "if" statement as being all
+ * done when it reached the ';' after the yyless() call.
+ */
 
 /* Return all but the first 'n' matched characters back to the input stream. */
 
@@ -153,75 +153,75 @@ extern FILE *yyin, *yyout;
 #define unput(c) yyunput( c, yytext_ptr )
 
 /* The following is because we cannot portably get our hands on size_t
-* (without autoconf's help, which isn't available because we want
-* flex-generated scanners to compile on their own).
-*/
+ * (without autoconf's help, which isn't available because we want
+ * flex-generated scanners to compile on their own).
+ */
 typedef unsigned int yy_size_t;
 
 
 struct yy_buffer_state
-{
-   FILE *yy_input_file;
+	{
+	FILE *yy_input_file;
 
-   char *yy_ch_buf;		/* input buffer */
-   char *yy_buf_pos;		/* current position in input buffer */
+	char *yy_ch_buf;		/* input buffer */
+	char *yy_buf_pos;		/* current position in input buffer */
 
-                        /* Size of input buffer in bytes, not including room for EOB
-                        * characters.
-                        */
-   yy_size_t yy_buf_size;
+	/* Size of input buffer in bytes, not including room for EOB
+	 * characters.
+	 */
+	yy_size_t yy_buf_size;
 
-   /* Number of characters read into yy_ch_buf, not including EOB
-   * characters.
-   */
-   int yy_n_chars;
+	/* Number of characters read into yy_ch_buf, not including EOB
+	 * characters.
+	 */
+	int yy_n_chars;
 
-   /* Whether we "own" the buffer - i.e., we know we created it,
-   * and can realloc() it to grow it, and should free() it to
-   * delete it.
-   */
-   int yy_is_our_buffer;
+	/* Whether we "own" the buffer - i.e., we know we created it,
+	 * and can realloc() it to grow it, and should free() it to
+	 * delete it.
+	 */
+	int yy_is_our_buffer;
 
-   /* Whether this is an "interactive" input source; if so, and
-   * if we're using stdio for input, then we want to use getc()
-   * instead of fread(), to make sure we stop fetching input after
-   * each newline.
-   */
-   int yy_is_interactive;
+	/* Whether this is an "interactive" input source; if so, and
+	 * if we're using stdio for input, then we want to use getc()
+	 * instead of fread(), to make sure we stop fetching input after
+	 * each newline.
+	 */
+	int yy_is_interactive;
 
-   /* Whether we're considered to be at the beginning of a line.
-   * If so, '^' rules will be active on the next match, otherwise
-   * not.
-   */
-   int yy_at_bol;
+	/* Whether we're considered to be at the beginning of a line.
+	 * If so, '^' rules will be active on the next match, otherwise
+	 * not.
+	 */
+	int yy_at_bol;
 
-   /* Whether to try to fill the input buffer when we reach the
-   * end of it.
-   */
-   int yy_fill_buffer;
+	/* Whether to try to fill the input buffer when we reach the
+	 * end of it.
+	 */
+	int yy_fill_buffer;
 
-   int yy_buffer_status;
+	int yy_buffer_status;
 #define YY_BUFFER_NEW 0
 #define YY_BUFFER_NORMAL 1
-   /* When an EOF's been seen but there's still some text to process
-   * then we mark the buffer as YY_EOF_PENDING, to indicate that we
-   * shouldn't try reading from the input source any more.  We might
-   * still have a bunch of tokens to match, though, because of
-   * possible backing-up.
-   *
-   * When we actually see the EOF, we change the status to "new"
-   * (via yyrestart()), so that the user can continue scanning by
-   * just pointing yyin at a new input file.
-   */
+	/* When an EOF's been seen but there's still some text to process
+	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+	 * shouldn't try reading from the input source any more.  We might
+	 * still have a bunch of tokens to match, though, because of
+	 * possible backing-up.
+	 *
+	 * When we actually see the EOF, we change the status to "new"
+	 * (via yyrestart()), so that the user can continue scanning by
+	 * just pointing yyin at a new input file.
+	 */
 #define YY_BUFFER_EOF_PENDING 2
-};
+	};
 
 static YY_BUFFER_STATE yy_current_buffer = 0;
 
 /* We provide macros for accessing buffer states in case in the
-* future we want to put the buffer states in a more general
-* "scanner state".
-*/
+ * future we want to put the buffer states in a more general
+ * "scanner state".
+ */
 #define YY_CURRENT_BUFFER yy_current_buffer
 
 
@@ -234,32 +234,32 @@ static int yy_n_chars;		/* number of characters read into yy_ch_buf */
 int yyleng;
 
 /* Points to current character in buffer. */
-static char *yy_c_buf_p = (char *)0;
+static char *yy_c_buf_p = (char *) 0;
 static int yy_init = 1;		/* whether we need to initialize */
 static int yy_start = 0;	/* start state number */
 
-                           /* Flag which is used to allow yywrap()'s to do buffer switches
-                           * instead of setting up a fresh yyin.  A bit of a hack ...
-                           */
+/* Flag which is used to allow yywrap()'s to do buffer switches
+ * instead of setting up a fresh yyin.  A bit of a hack ...
+ */
 static int yy_did_buffer_switch_on_eof;
 
-void yyrestart YY_PROTO((FILE *input_file));
+void yyrestart YY_PROTO(( FILE *input_file ));
 
-void yy_switch_to_buffer YY_PROTO((YY_BUFFER_STATE new_buffer));
-void yy_load_buffer_state YY_PROTO((void));
-YY_BUFFER_STATE yy_create_buffer YY_PROTO((FILE *file, int size));
-void yy_delete_buffer YY_PROTO((YY_BUFFER_STATE b));
-void yy_init_buffer YY_PROTO((YY_BUFFER_STATE b, FILE *file));
-void yy_flush_buffer YY_PROTO((YY_BUFFER_STATE b));
+void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
+void yy_load_buffer_state YY_PROTO(( void ));
+YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
+void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
+void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
+void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
 
-YY_BUFFER_STATE yy_scan_buffer YY_PROTO((char *base, yy_size_t size));
-YY_BUFFER_STATE yy_scan_string YY_PROTO((yyconst char *str));
-YY_BUFFER_STATE yy_scan_bytes YY_PROTO((yyconst char *bytes, int len));
+YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
+YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *str ));
+YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
 
-static void *yy_flex_alloc YY_PROTO((yy_size_t));
-static void *yy_flex_realloc YY_PROTO((void *, yy_size_t));
-static void yy_flex_free YY_PROTO((void *));
+static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
+static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
+static void yy_flex_free YY_PROTO(( void * ));
 
 #define yy_new_buffer yy_create_buffer
 
@@ -280,19 +280,19 @@ static void yy_flex_free YY_PROTO((void *));
 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
 
 typedef unsigned char YY_CHAR;
-FILE *yyin = (FILE *)0, *yyout = (FILE *)0;
+FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
 typedef int yy_state_type;
 extern char *yytext;
 #define yytext_ptr yytext
 
-static yy_state_type yy_get_previous_state YY_PROTO((void));
-static yy_state_type yy_try_NUL_trans YY_PROTO((yy_state_type current_state));
-static int yy_get_next_buffer YY_PROTO((void));
-static void yy_fatal_error YY_PROTO((yyconst char msg[]));
+static yy_state_type yy_get_previous_state YY_PROTO(( void ));
+static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
+static int yy_get_next_buffer YY_PROTO(( void ));
+static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
 
 /* Done after the current pattern has been matched and before the
-* corresponding action - sets up yytext.
-*/
+ * corresponding action - sets up yytext.
+ */
 #define YY_DO_BEFORE_ACTION \
 	yytext_ptr = yy_bp; \
 	yyleng = (int) (yy_cp - yy_bp); \
@@ -303,241 +303,241 @@ static void yy_fatal_error YY_PROTO((yyconst char msg[]));
 #define YY_NUM_RULES 94
 #define YY_END_OF_BUFFER 95
 static yyconst short int yy_accept[224] =
-{ 0,
-0,    0,   95,   93,    1,    5,    4,   51,   93,   93,
-58,   57,   93,   41,   42,   45,   43,   56,   44,   50,
-46,   90,   90,   52,   53,   47,   61,   48,   38,   36,
-88,   88,   88,   88,   39,   40,   59,   88,   88,   88,
-88,   88,   88,   88,   88,   88,   88,   88,   88,   88,
-88,   54,   49,   55,   60,    1,    0,    9,    0,    6,
-0,    0,   17,   87,   25,   12,   26,    0,    7,    0,
-23,   16,   21,   15,   22,   31,   91,   37,    3,   24,
-0,   90,    0,    0,   14,   19,   11,    8,   10,   20,
-88,   33,   88,   88,   27,   88,   88,   88,   88,   88,
+    {   0,
+        0,    0,   95,   93,    1,    5,    4,   51,   93,   93,
+       58,   57,   93,   41,   42,   45,   43,   56,   44,   50,
+       46,   90,   90,   52,   53,   47,   61,   48,   38,   36,
+       88,   88,   88,   88,   39,   40,   59,   88,   88,   88,
+       88,   88,   88,   88,   88,   88,   88,   88,   88,   88,
+       88,   54,   49,   55,   60,    1,    0,    9,    0,    6,
+        0,    0,   17,   87,   25,   12,   26,    0,    7,    0,
+       23,   16,   21,   15,   22,   31,   91,   37,    3,   24,
+        0,   90,    0,    0,   14,   19,   11,    8,   10,   20,
+       88,   33,   88,   88,   27,   88,   88,   88,   88,   88,
 
-88,   69,   88,   88,   88,   88,   70,   62,   88,   88,
-63,   88,   88,   88,   88,   88,   88,   28,   13,   18,
-92,   87,    0,   32,    3,    3,   91,    0,   91,   89,
-29,   30,   35,   34,   88,   88,   88,   88,   88,   88,
-88,   88,   73,   88,   88,   76,   88,   88,   88,   88,
-88,   88,   92,    0,    3,    2,   88,   88,   79,   88,
-88,   88,   66,   88,   88,   88,   88,   88,   88,   88,
-88,   85,   88,    3,    0,   88,   64,   88,   88,   88,
-86,   88,   88,   88,   88,   88,   88,   88,   68,    0,
-67,   88,   88,   88,   88,   88,   88,   88,   65,   88,
+       88,   69,   88,   88,   88,   88,   70,   62,   88,   88,
+       63,   88,   88,   88,   88,   88,   88,   28,   13,   18,
+       92,   87,    0,   32,    3,    3,   91,    0,   91,   89,
+       29,   30,   35,   34,   88,   88,   88,   88,   88,   88,
+       88,   88,   73,   88,   88,   76,   88,   88,   88,   88,
+       88,   88,   92,    0,    3,    2,   88,   88,   79,   88,
+       88,   88,   66,   88,   88,   88,   88,   88,   88,   88,
+       88,   85,   88,    3,    0,   88,   64,   88,   88,   88,
+       86,   88,   88,   88,   88,   88,   88,   88,   68,    0,
+       67,   88,   88,   88,   88,   88,   88,   88,   65,   88,
 
-81,    0,   88,   88,   82,   72,   88,   88,   83,   88,
-80,    0,   74,   88,   71,   75,   88,   88,    0,   78,
-84,   77,    0
-};
+       81,    0,   88,   88,   82,   72,   88,   88,   83,   88,
+       80,    0,   74,   88,   71,   75,   88,   88,    0,   78,
+       84,   77,    0
+    } ;
 
 static yyconst int yy_ec[256] =
-{ 0,
-1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
-2,    2,    4,    1,    1,    1,    1,    1,    1,    1,
-1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-1,    2,    5,    6,    1,    7,    8,    9,   10,   11,
-12,   13,   14,   15,   16,   17,   18,   19,   20,   20,
-20,   20,   20,   20,   20,   20,   20,   21,   22,   23,
-24,   25,   26,   27,   28,   29,   30,   31,   32,   31,
-33,   33,   33,   33,   33,   34,   33,   35,   33,   36,
-33,   33,   37,   38,   33,   33,   33,   39,   33,   33,
-40,   41,   42,   43,   33,    1,   44,   45,   46,   47,
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
+        2,    2,    4,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    2,    5,    6,    1,    7,    8,    9,   10,   11,
+       12,   13,   14,   15,   16,   17,   18,   19,   20,   20,
+       20,   20,   20,   20,   20,   20,   20,   21,   22,   23,
+       24,   25,   26,   27,   28,   29,   30,   31,   32,   31,
+       33,   33,   33,   33,   33,   34,   33,   35,   33,   36,
+       33,   33,   37,   38,   33,   33,   33,   39,   33,   33,
+       40,   41,   42,   43,   33,    1,   44,   45,   46,   47,
 
-48,   49,   50,   51,   52,   33,   53,   54,   55,   56,
-57,   58,   33,   59,   60,   61,   62,   33,   63,   39,
-33,   33,   64,   65,   66,   67,    1,    1,    1,    1,
-1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+       48,   49,   50,   51,   52,   33,   53,   54,   55,   56,
+       57,   58,   33,   59,   60,   61,   62,   33,   63,   39,
+       33,   33,   64,   65,   66,   67,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
-1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-1,    1,    1,    1,    1
-};
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1
+    } ;
 
 static yyconst int yy_meta[68] =
-{ 0,
-1,    1,    2,    2,    1,    1,    1,    1,    1,    1,
-1,    1,    1,    1,    1,    1,    1,    3,    4,    4,
-5,    1,    1,    6,    1,    1,    1,    4,    4,    4,
-4,    4,    7,    7,    7,    7,    7,    7,    7,    1,
-1,    1,    1,    4,    4,    4,    4,    4,    4,    7,
-7,    7,    7,    7,    7,    7,    7,    7,    7,    7,
-7,    7,    7,    1,    1,    1,    1
-};
+    {   0,
+        1,    1,    2,    2,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    3,    4,    4,
+        5,    1,    1,    6,    1,    1,    1,    4,    4,    4,
+        4,    4,    7,    7,    7,    7,    7,    7,    7,    1,
+        1,    1,    1,    4,    4,    4,    4,    4,    4,    7,
+        7,    7,    7,    7,    7,    7,    7,    7,    7,    7,
+        7,    7,    7,    1,    1,    1,    1
+    } ;
 
 static yyconst short int yy_base[237] =
-{ 0,
-0,    0,  337,  338,  334,  338,  338,   61,   63,   51,
-53,   65,   66,  338,  338,  311,   64,  338,   66,   60,
-68,   76,   80,  313,  338,   60,  309,   77,  338,  338,
-0,  298,  295,  302,  338,  338,  305,  268,  268,   54,
-61,  272,   59,   38,   62,  266,  280,  275,   62,  263,
-270,  338,   89,  338,  338,  318,  295,  338,  111,  338,
-314,  100,  338,  296,  338,  338,  338,  112,  338,  312,
-338,  338,  338,  290,  338,  338,  107,  338,  296,  338,
-110,  114,  121,    0,  338,  289,  338,  338,  338,  288,
-0,    0,  281,  281,  338,  249,  260,  247,  250,  244,
+    {   0,
+        0,    0,  337,  338,  334,  338,  338,   61,   63,   51,
+       53,   65,   66,  338,  338,  311,   64,  338,   66,   60,
+       68,   76,   80,  313,  338,   60,  309,   77,  338,  338,
+        0,  298,  295,  302,  338,  338,  305,  268,  268,   54,
+       61,  272,   59,   38,   62,  266,  280,  275,   62,  263,
+      270,  338,   89,  338,  338,  318,  295,  338,  111,  338,
+      314,  100,  338,  296,  338,  338,  338,  112,  338,  312,
+      338,  338,  338,  290,  338,  338,  107,  338,  296,  338,
+      110,  114,  121,    0,  338,  289,  338,  338,  338,  288,
+        0,    0,  281,  281,  338,  249,  260,  247,  250,  244,
 
-255,    0,  243,  248,  242,  244,    0,    0,  244,  235,
-0,  251,  235,  239,  242,  231,  240,  338,  338,  338,
-270,  269,  268,  338,    0,  139,  119,  125,  128,    0,
-338,  338,    0,    0,  240,  243,  238,  224,  240,  239,
-234,  221,  232,  233,  230,    0,  224,  214,  225,  213,
-225,  218,  250,  249,  146,  152,  210,  215,    0,  215,
-221,  203,    0,  216,  219,  201,  201,  216,  200,  204,
-211,    0,  208,  155,  237,  193,    0,  197,  198,  197,
-0,  204,  197,  190,  197,  190,  197,  193,    0,  225,
-0,  180,  184,  179,  177,  153,  158,  151,    0,  134,
+      255,    0,  243,  248,  242,  244,    0,    0,  244,  235,
+        0,  251,  235,  239,  242,  231,  240,  338,  338,  338,
+      270,  269,  268,  338,    0,  139,  119,  125,  128,    0,
+      338,  338,    0,    0,  240,  243,  238,  224,  240,  239,
+      234,  221,  232,  233,  230,    0,  224,  214,  225,  213,
+      225,  218,  250,  249,  146,  152,  210,  215,    0,  215,
+      221,  203,    0,  216,  219,  201,  201,  216,  200,  204,
+      211,    0,  208,  155,  237,  193,    0,  197,  198,  197,
+        0,  204,  197,  190,  197,  190,  197,  193,    0,  225,
+        0,  180,  184,  179,  177,  153,  158,  151,    0,  134,
 
-187,  157,  143,  144,    0,  176,  123,  126,    0,  112,
-338,  160,    0,  115,  338,    0,   88,   76,  162,    0,
-0,    0,  338,  170,  174,  181,  185,  189,  193,  200,
-119,  204,  211,  218,  225,  232
-};
+      187,  157,  143,  144,    0,  176,  123,  126,    0,  112,
+      338,  160,    0,  115,  338,    0,   88,   76,  162,    0,
+        0,    0,  338,  170,  174,  181,  185,  189,  193,  200,
+      119,  204,  211,  218,  225,  232
+    } ;
 
 static yyconst short int yy_def[237] =
-{ 0,
-223,    1,  223,  223,  223,  223,  223,  223,  224,  225,
-225,  223,  226,  223,  223,  223,  223,  223,  223,  223,
-223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
-227,  227,  227,  227,  223,  223,  223,  227,  227,  227,
-227,  227,  227,  227,  227,  227,  227,  227,  227,  227,
-227,  223,  223,  223,  223,  223,  223,  223,  224,  223,
-224,  228,  223,  229,  223,  223,  223,  226,  223,  226,
-223,  223,  223,  223,  223,  223,  223,  223,  230,  223,
-223,  223,  223,  231,  223,  223,  223,  223,  223,  223,
-227,  227,  227,  227,  223,  227,  227,  227,  227,  227,
+    {   0,
+      223,    1,  223,  223,  223,  223,  223,  223,  224,  225,
+      225,  223,  226,  223,  223,  223,  223,  223,  223,  223,
+      223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
+      227,  227,  227,  227,  223,  223,  223,  227,  227,  227,
+      227,  227,  227,  227,  227,  227,  227,  227,  227,  227,
+      227,  223,  223,  223,  223,  223,  223,  223,  224,  223,
+      224,  228,  223,  229,  223,  223,  223,  226,  223,  226,
+      223,  223,  223,  223,  223,  223,  223,  223,  230,  223,
+      223,  223,  223,  231,  223,  223,  223,  223,  223,  223,
+      227,  227,  227,  227,  223,  227,  227,  227,  227,  227,
 
-227,  227,  227,  227,  227,  227,  227,  227,  227,  227,
-227,  227,  227,  227,  227,  227,  227,  223,  223,  223,
-232,  229,  229,  223,  230,  233,  223,  223,  223,  231,
-223,  223,  227,  227,  227,  227,  227,  227,  227,  227,
-227,  227,  227,  227,  227,  227,  227,  227,  227,  227,
-227,  227,  232,  232,  234,  223,  227,  227,  227,  227,
-227,  227,  227,  227,  227,  227,  227,  227,  227,  227,
-227,  227,  227,  234,  223,  227,  227,  227,  227,  227,
-227,  227,  227,  227,  227,  227,  227,  227,  227,  223,
-227,  227,  227,  227,  227,  227,  227,  227,  227,  227,
+      227,  227,  227,  227,  227,  227,  227,  227,  227,  227,
+      227,  227,  227,  227,  227,  227,  227,  223,  223,  223,
+      232,  229,  229,  223,  230,  233,  223,  223,  223,  231,
+      223,  223,  227,  227,  227,  227,  227,  227,  227,  227,
+      227,  227,  227,  227,  227,  227,  227,  227,  227,  227,
+      227,  227,  232,  232,  234,  223,  227,  227,  227,  227,
+      227,  227,  227,  227,  227,  227,  227,  227,  227,  227,
+      227,  227,  227,  234,  223,  227,  227,  227,  227,  227,
+      227,  227,  227,  227,  227,  227,  227,  227,  227,  223,
+      227,  227,  227,  227,  227,  227,  227,  227,  227,  227,
 
-227,  235,  227,  227,  227,  227,  227,  227,  227,  227,
-223,  236,  227,  227,  223,  227,  227,  227,  236,  227,
-227,  227,    0,  223,  223,  223,  223,  223,  223,  223,
-223,  223,  223,  223,  223,  223
-};
+      227,  235,  227,  227,  227,  227,  227,  227,  227,  227,
+      223,  236,  227,  227,  223,  227,  227,  227,  236,  227,
+      227,  227,    0,  223,  223,  223,  223,  223,  223,  223,
+      223,  223,  223,  223,  223,  223
+    } ;
 
 static yyconst short int yy_nxt[406] =
-{ 0,
-4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
-14,   15,   16,   17,   18,   19,   20,   21,   22,   23,
-24,   25,   26,   27,   28,   29,   30,   31,   31,   31,
-31,   31,   31,   31,   32,   31,   33,   34,   31,   35,
-4,   36,   37,   38,   39,   40,   41,   42,   43,   31,
-31,   44,   31,   31,   31,   45,   46,   47,   48,   49,
-50,   31,   51,   52,   53,   54,   55,   57,   60,   62,
-62,   62,   62,   66,   63,   69,   65,   72,   77,   77,
-78,   74,   86,   87,   58,   79,  107,   73,   67,   75,
-76,   80,   81,  108,   82,   82,   81,   98,   82,   82,
+    {   0,
+        4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
+       14,   15,   16,   17,   18,   19,   20,   21,   22,   23,
+       24,   25,   26,   27,   28,   29,   30,   31,   31,   31,
+       31,   31,   31,   31,   32,   31,   33,   34,   31,   35,
+        4,   36,   37,   38,   39,   40,   41,   42,   43,   31,
+       31,   44,   31,   31,   31,   45,   46,   47,   48,   49,
+       50,   31,   51,   52,   53,   54,   55,   57,   60,   62,
+       62,   62,   62,   66,   63,   69,   65,   72,   77,   77,
+       78,   74,   86,   87,   58,   79,  107,   73,   67,   75,
+       76,   80,   81,  108,   82,   82,   81,   98,   82,   82,
 
-89,   90,  104,   61,  100,  109,   70,   83,  101,  110,
-99,   83,  118,  114,   84,  105,   60,  102,   62,   62,
-106,   69,  130,   83,  115,   77,   77,   83,  127,  127,
-81,  222,   82,   82,  128,  221,  128,  127,  127,  129,
-129,  156,  156,  129,  129,   83,  129,  129,  156,  156,
-83,   61,   70,  119,  156,  156,  125,  156,  156,  156,
-156,   83,  156,  156,  156,  156,   83,  220,  218,  175,
-59,  217,   59,   59,   59,   59,   59,   64,  216,   64,
-64,   68,  215,   68,   68,   68,   68,   68,   91,  214,
-213,   91,  121,  211,  210,  121,  122,  122,  209,  122,
+       89,   90,  104,   61,  100,  109,   70,   83,  101,  110,
+       99,   83,  118,  114,   84,  105,   60,  102,   62,   62,
+      106,   69,  130,   83,  115,   77,   77,   83,  127,  127,
+       81,  222,   82,   82,  128,  221,  128,  127,  127,  129,
+      129,  156,  156,  129,  129,   83,  129,  129,  156,  156,
+       83,   61,   70,  119,  156,  156,  125,  156,  156,  156,
+      156,   83,  156,  156,  156,  156,   83,  220,  218,  175,
+       59,  217,   59,   59,   59,   59,   59,   64,  216,   64,
+       64,   68,  215,   68,   68,   68,   68,   68,   91,  214,
+      213,   91,  121,  211,  210,  121,  122,  122,  209,  122,
 
-125,  208,  125,  125,  125,  125,  125,  153,  153,  207,
-153,  155,  155,  155,  155,  155,  155,  155,  174,  174,
-174,  174,  174,  174,  174,  212,  212,  206,  212,  212,
-212,  212,  219,  219,  219,  219,  219,  219,  219,  205,
-204,  203,  202,  201,  200,  199,  198,  197,  196,  195,
-194,  193,  192,  191,  190,  189,  188,  187,  186,  185,
-184,  183,  182,  181,  180,  179,  178,  177,  176,  154,
-154,  173,  172,  171,  170,  169,  168,  167,  166,  165,
-164,  163,  162,  161,  160,  159,  158,  157,  123,  123,
-154,  152,  151,  150,  149,  148,  147,  146,  145,  144,
+      125,  208,  125,  125,  125,  125,  125,  153,  153,  207,
+      153,  155,  155,  155,  155,  155,  155,  155,  174,  174,
+      174,  174,  174,  174,  174,  212,  212,  206,  212,  212,
+      212,  212,  219,  219,  219,  219,  219,  219,  219,  205,
+      204,  203,  202,  201,  200,  199,  198,  197,  196,  195,
+      194,  193,  192,  191,  190,  189,  188,  187,  186,  185,
+      184,  183,  182,  181,  180,  179,  178,  177,  176,  154,
+      154,  173,  172,  171,  170,  169,  168,  167,  166,  165,
+      164,  163,  162,  161,  160,  159,  158,  157,  123,  123,
+      154,  152,  151,  150,  149,  148,  147,  146,  145,  144,
 
-143,  142,  141,  140,  139,  138,  137,  136,  135,  134,
-133,  132,  131,  126,  124,   68,  123,   59,  120,   56,
-117,  116,  113,  112,  111,  103,   97,   96,   95,   94,
-93,   92,   88,   85,   71,   56,  223,    3,  223,  223,
-223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
-223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
-223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
-223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
-223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
-223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
+      143,  142,  141,  140,  139,  138,  137,  136,  135,  134,
+      133,  132,  131,  126,  124,   68,  123,   59,  120,   56,
+      117,  116,  113,  112,  111,  103,   97,   96,   95,   94,
+       93,   92,   88,   85,   71,   56,  223,    3,  223,  223,
+      223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
+      223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
+      223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
+      223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
+      223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
+      223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
 
-223,  223,  223,  223,  223
-};
+      223,  223,  223,  223,  223
+    } ;
 
 static yyconst short int yy_chk[406] =
-{ 0,
-1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-1,    1,    1,    1,    1,    1,    1,    8,    9,   10,
-10,   11,   11,   12,   10,   13,   11,   17,   20,   20,
-21,   19,   26,   26,    8,   21,   44,   17,   12,   19,
-19,   21,   22,   44,   22,   22,   23,   40,   23,   23,
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    8,    9,   10,
+       10,   11,   11,   12,   10,   13,   11,   17,   20,   20,
+       21,   19,   26,   26,    8,   21,   44,   17,   12,   19,
+       19,   21,   22,   44,   22,   22,   23,   40,   23,   23,
 
-28,   28,   43,    9,   41,   45,   13,   22,   41,   45,
-40,   23,   53,   49,   22,   43,   59,   41,   62,   62,
-43,   68,  231,   22,   49,   77,   77,   23,   81,   81,
-82,  218,   82,   82,   83,  217,   83,  127,  127,   83,
-83,  126,  126,  128,  128,   82,  129,  129,  155,  155,
-127,   59,   68,   53,  156,  156,  126,  174,  174,  202,
-202,   82,  212,  212,  219,  219,  127,  214,  210,  156,
-224,  208,  224,  224,  224,  224,  224,  225,  207,  225,
-225,  226,  206,  226,  226,  226,  226,  226,  227,  204,
-203,  227,  228,  201,  200,  228,  229,  229,  198,  229,
+       28,   28,   43,    9,   41,   45,   13,   22,   41,   45,
+       40,   23,   53,   49,   22,   43,   59,   41,   62,   62,
+       43,   68,  231,   22,   49,   77,   77,   23,   81,   81,
+       82,  218,   82,   82,   83,  217,   83,  127,  127,   83,
+       83,  126,  126,  128,  128,   82,  129,  129,  155,  155,
+      127,   59,   68,   53,  156,  156,  126,  174,  174,  202,
+      202,   82,  212,  212,  219,  219,  127,  214,  210,  156,
+      224,  208,  224,  224,  224,  224,  224,  225,  207,  225,
+      225,  226,  206,  226,  226,  226,  226,  226,  227,  204,
+      203,  227,  228,  201,  200,  228,  229,  229,  198,  229,
 
-230,  197,  230,  230,  230,  230,  230,  232,  232,  196,
-232,  233,  233,  233,  233,  233,  233,  233,  234,  234,
-234,  234,  234,  234,  234,  235,  235,  195,  235,  235,
-235,  235,  236,  236,  236,  236,  236,  236,  236,  194,
-193,  192,  190,  188,  187,  186,  185,  184,  183,  182,
-180,  179,  178,  176,  175,  173,  171,  170,  169,  168,
-167,  166,  165,  164,  162,  161,  160,  158,  157,  154,
-153,  152,  151,  150,  149,  148,  147,  145,  144,  143,
-142,  141,  140,  139,  138,  137,  136,  135,  123,  122,
-121,  117,  116,  115,  114,  113,  112,  110,  109,  106,
+      230,  197,  230,  230,  230,  230,  230,  232,  232,  196,
+      232,  233,  233,  233,  233,  233,  233,  233,  234,  234,
+      234,  234,  234,  234,  234,  235,  235,  195,  235,  235,
+      235,  235,  236,  236,  236,  236,  236,  236,  236,  194,
+      193,  192,  190,  188,  187,  186,  185,  184,  183,  182,
+      180,  179,  178,  176,  175,  173,  171,  170,  169,  168,
+      167,  166,  165,  164,  162,  161,  160,  158,  157,  154,
+      153,  152,  151,  150,  149,  148,  147,  145,  144,  143,
+      142,  141,  140,  139,  138,  137,  136,  135,  123,  122,
+      121,  117,  116,  115,  114,  113,  112,  110,  109,  106,
 
-105,  104,  103,  101,  100,   99,   98,   97,   96,   94,
-93,   90,   86,   79,   74,   70,   64,   61,   57,   56,
-51,   50,   48,   47,   46,   42,   39,   38,   37,   34,
-33,   32,   27,   24,   16,    5,    3,  223,  223,  223,
-223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
-223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
-223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
-223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
-223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
-223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
+      105,  104,  103,  101,  100,   99,   98,   97,   96,   94,
+       93,   90,   86,   79,   74,   70,   64,   61,   57,   56,
+       51,   50,   48,   47,   46,   42,   39,   38,   37,   34,
+       33,   32,   27,   24,   16,    5,    3,  223,  223,  223,
+      223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
+      223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
+      223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
+      223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
+      223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
+      223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
 
-223,  223,  223,  223,  223
-};
+      223,  223,  223,  223,  223
+    } ;
 
 static yy_state_type yy_last_accepting_state;
 static char *yy_last_accepting_cpos;
 
 /* The intent behind this definition is that it'll catch
-* any uses of REJECT which flex missed.
-*/
+ * any uses of REJECT which flex missed.
+ */
 #define REJECT reject_used_but_not_detected
 #define yymore() yymore_used_but_not_detected
 #define YY_MORE_ADJ 0
@@ -568,7 +568,7 @@ struct Token
 
 // Can't have ctors in structs used in unions, so we have this.
 template< typename T >
-inline Token< T > MakeToken(T value, U32 lineNumber)
+inline Token< T > MakeToken( T value, U32 lineNumber )
 {
    Token< T > result;
    result.value = value;
@@ -634,30 +634,30 @@ void CMDrestart(FILE *in);
 #line 635 "CMDscan.cpp"
 
 /* Macros after this point can all be overridden by user definitions in
-* section 1.
-*/
+ * section 1.
+ */
 
 #ifndef YY_SKIP_YYWRAP
 #ifdef __cplusplus
-extern "C" int yywrap YY_PROTO((void));
+extern "C" int yywrap YY_PROTO(( void ));
 #else
-extern int yywrap YY_PROTO((void));
+extern int yywrap YY_PROTO(( void ));
 #endif
 #endif
 
 #ifndef YY_NO_UNPUT
-static void yyunput YY_PROTO((int c, char *buf_ptr));
+static void yyunput YY_PROTO(( int c, char *buf_ptr ));
 #endif
 
 #ifndef yytext_ptr
-static void yy_flex_strncpy YY_PROTO((char *, yyconst char *, int));
+static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
 #endif
 
 #ifndef YY_NO_INPUT
 #ifdef __cplusplus
-static int yyinput YY_PROTO((void));
+static int yyinput YY_PROTO(( void ));
 #else
-static int input YY_PROTO((void));
+static int input YY_PROTO(( void ));
 #endif
 #endif
 
@@ -666,13 +666,13 @@ static int yy_start_stack_ptr = 0;
 static int yy_start_stack_depth = 0;
 static int *yy_start_stack = 0;
 #ifndef YY_NO_PUSH_STATE
-static void yy_push_state YY_PROTO((int new_state));
+static void yy_push_state YY_PROTO(( int new_state ));
 #endif
 #ifndef YY_NO_POP_STATE
-static void yy_pop_state YY_PROTO((void));
+static void yy_pop_state YY_PROTO(( void ));
 #endif
 #ifndef YY_NO_TOP_STATE
-static int yy_top_state YY_PROTO((void));
+static int yy_top_state YY_PROTO(( void ));
 #endif
 
 #else
@@ -690,9 +690,9 @@ YY_MALLOC_DECL
 #endif
 #else
 /* Just try to get by without declaring the routines.  This will fail
-* miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
-* or sizeof(void*) != sizeof(int).
-*/
+ * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
+ * or sizeof(void*) != sizeof(int).
+ */
 #endif
 #endif
 
@@ -705,14 +705,14 @@ YY_MALLOC_DECL
 
 #ifndef ECHO
 /* This used to be an fputs(), but since the string might contain NUL's,
-* we now use fwrite().
-*/
+ * we now use fwrite().
+ */
 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
 #endif
 
 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
-* is returned in "result".
-*/
+ * is returned in "result".
+ */
 #ifndef YY_INPUT
 #define YY_INPUT(buf,result,max_size) \
 	if ( yy_current_buffer->yy_is_interactive ) \
@@ -733,9 +733,9 @@ YY_MALLOC_DECL
 #endif
 
 /* No semi-colon after return; correct usage is to write "yyterminate();" -
-* we don't want an extra ';' after the "return" because that will cause
-* some compilers to complain about unreachable statements.
-*/
+ * we don't want an extra ';' after the "return" because that will cause
+ * some compilers to complain about unreachable statements.
+ */
 #ifndef yyterminate
 #define yyterminate() return YY_NULL
 #endif
@@ -751,15 +751,15 @@ YY_MALLOC_DECL
 #endif
 
 /* Default declaration of generated scanner - a define so the user can
-* easily add parameters.
-*/
+ * easily add parameters.
+ */
 #ifndef YY_DECL
 #define YY_DECL int yylex YY_PROTO(( void ))
 #endif
 
 /* Code executed at the beginning of each rule, after yytext and yyleng
-* have been set up.
-*/
+ * have been set up.
+ */
 #ifndef YY_USER_ACTION
 #define YY_USER_ACTION
 #endif
@@ -773,894 +773,895 @@ YY_MALLOC_DECL
 	YY_USER_ACTION
 
 YY_DECL
-{
-   register yy_state_type yy_current_state;
-register char *yy_cp, *yy_bp;
-register int yy_act;
+	{
+	register yy_state_type yy_current_state;
+	register char *yy_cp, *yy_bp;
+	register int yy_act;
 
 #line 105 "CMDscan.l"
 
-;
+         ;
 #line 785 "CMDscan.cpp"
 
-if (yy_init)
-{
-   yy_init = 0;
+	if ( yy_init )
+		{
+		yy_init = 0;
 
 #ifdef YY_USER_INIT
-   YY_USER_INIT;
+		YY_USER_INIT;
 #endif
 
-   if (!yy_start)
-      yy_start = 1;	/* first start state */
+		if ( ! yy_start )
+			yy_start = 1;	/* first start state */
 
-   if (!yyin)
-      yyin = stdin;
+		if ( ! yyin )
+			yyin = stdin;
 
-   if (!yyout)
-      yyout = stdout;
+		if ( ! yyout )
+			yyout = stdout;
 
-   if (!yy_current_buffer)
-      yy_current_buffer =
-      yy_create_buffer(yyin, YY_BUF_SIZE);
+		if ( ! yy_current_buffer )
+			yy_current_buffer =
+				yy_create_buffer( yyin, YY_BUF_SIZE );
 
-   yy_load_buffer_state();
-}
+		yy_load_buffer_state();
+		}
 
-while (1)		/* loops until end-of-file is reached */
-{
-   yy_cp = yy_c_buf_p;
+	while ( 1 )		/* loops until end-of-file is reached */
+		{
+		yy_cp = yy_c_buf_p;
 
-   /* Support of yytext. */
-   *yy_cp = yy_hold_char;
+		/* Support of yytext. */
+		*yy_cp = yy_hold_char;
 
-   /* yy_bp points to the position in yy_ch_buf of the start of
-   * the current run.
-   */
-   yy_bp = yy_cp;
+		/* yy_bp points to the position in yy_ch_buf of the start of
+		 * the current run.
+		 */
+		yy_bp = yy_cp;
 
-   yy_current_state = yy_start;
+		yy_current_state = yy_start;
 yy_match:
-   do
-   {
-      register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
-      if (yy_accept[yy_current_state])
-      {
-         yy_last_accepting_state = yy_current_state;
-         yy_last_accepting_cpos = yy_cp;
-      }
-      while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state)
-      {
-         yy_current_state = (int)yy_def[yy_current_state];
-         if (yy_current_state >= 224)
-            yy_c = yy_meta[(unsigned int)yy_c];
-      }
-      yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int)yy_c];
-      ++yy_cp;
-   } while (yy_base[yy_current_state] != 338);
+		do
+			{
+			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
+			if ( yy_accept[yy_current_state] )
+				{
+				yy_last_accepting_state = yy_current_state;
+				yy_last_accepting_cpos = yy_cp;
+				}
+			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+				{
+				yy_current_state = (int) yy_def[yy_current_state];
+				if ( yy_current_state >= 224 )
+					yy_c = yy_meta[(unsigned int) yy_c];
+				}
+			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+			++yy_cp;
+			}
+		while ( yy_base[yy_current_state] != 338 );
 
 yy_find_action:
-   yy_act = yy_accept[yy_current_state];
-   if (yy_act == 0)
-   { /* have to back up */
-      yy_cp = yy_last_accepting_cpos;
-      yy_current_state = yy_last_accepting_state;
-      yy_act = yy_accept[yy_current_state];
-   }
+		yy_act = yy_accept[yy_current_state];
+		if ( yy_act == 0 )
+			{ /* have to back up */
+			yy_cp = yy_last_accepting_cpos;
+			yy_current_state = yy_last_accepting_state;
+			yy_act = yy_accept[yy_current_state];
+			}
 
-   YY_DO_BEFORE_ACTION;
+		YY_DO_BEFORE_ACTION;
 
 
 do_action:	/* This label is used only to access EOF actions. */
 
 
-   switch (yy_act)
-   { /* beginning of action switch */
-      case 0: /* must back up */
-              /* undo the effects of YY_DO_BEFORE_ACTION */
-         *yy_cp = yy_hold_char;
-         yy_cp = yy_last_accepting_cpos;
-         yy_current_state = yy_last_accepting_state;
-         goto yy_find_action;
+		switch ( yy_act )
+	{ /* beginning of action switch */
+			case 0: /* must back up */
+			/* undo the effects of YY_DO_BEFORE_ACTION */
+			*yy_cp = yy_hold_char;
+			yy_cp = yy_last_accepting_cpos;
+			yy_current_state = yy_last_accepting_state;
+			goto yy_find_action;
 
-      case 1:
-         YY_RULE_SETUP
+case 1:
+YY_RULE_SETUP
 #line 107 "CMDscan.l"
-         {}
-            YY_BREAK
-      case 2:
-         YY_RULE_SETUP
+{ }
+	YY_BREAK
+case 2:
+YY_RULE_SETUP
 #line 108 "CMDscan.l"
-         { return(Sc_ScanDocBlock()); }
-            YY_BREAK
-      case 3:
-         YY_RULE_SETUP
+{ return(Sc_ScanDocBlock()); }
+	YY_BREAK
+case 3:
+YY_RULE_SETUP
 #line 109 "CMDscan.l"
-            ;
-         YY_BREAK
-      case 4:
-         YY_RULE_SETUP
+;
+	YY_BREAK
+case 4:
+YY_RULE_SETUP
 #line 110 "CMDscan.l"
-            ;
-         YY_BREAK
-      case 5:
-         YY_RULE_SETUP
+;
+	YY_BREAK
+case 5:
+YY_RULE_SETUP
 #line 111 "CMDscan.l"
-         { lineIndex++; }
-            YY_BREAK
-      case 6:
-         YY_RULE_SETUP
+{lineIndex++;}
+	YY_BREAK
+case 6:
+YY_RULE_SETUP
 #line 112 "CMDscan.l"
-         { return(Sc_ScanString(STRATOM)); }
-            YY_BREAK
-      case 7:
-         YY_RULE_SETUP
+{ return(Sc_ScanString(STRATOM)); }
+	YY_BREAK
+case 7:
+YY_RULE_SETUP
 #line 113 "CMDscan.l"
-         { return(Sc_ScanString(TAGATOM)); }
-            YY_BREAK
-      case 8:
-         YY_RULE_SETUP
+{ return(Sc_ScanString(TAGATOM)); }
+	YY_BREAK
+case 8:
+YY_RULE_SETUP
 #line 114 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(opEQ, lineIndex); return opEQ; }
-            YY_BREAK
-      case 9:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( opEQ, lineIndex ); return opEQ; }
+	YY_BREAK
+case 9:
+YY_RULE_SETUP
 #line 115 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(opNE, lineIndex); return opNE; }
-            YY_BREAK
-      case 10:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( opNE, lineIndex ); return opNE; }
+	YY_BREAK
+case 10:
+YY_RULE_SETUP
 #line 116 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(opGE, lineIndex); return opGE; }
-            YY_BREAK
-      case 11:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( opGE, lineIndex ); return opGE; }
+	YY_BREAK
+case 11:
+YY_RULE_SETUP
 #line 117 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(opLE, lineIndex); return opLE; }
-            YY_BREAK
-      case 12:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( opLE, lineIndex ); return opLE; }
+	YY_BREAK
+case 12:
+YY_RULE_SETUP
 #line 118 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(opAND, lineIndex); return opAND; }
-            YY_BREAK
-      case 13:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( opAND, lineIndex ); return opAND; }
+	YY_BREAK
+case 13:
+YY_RULE_SETUP
 #line 119 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(opOR, lineIndex); return opOR; }
-            YY_BREAK
-      case 14:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( opOR, lineIndex ); return opOR; }
+	YY_BREAK
+case 14:
+YY_RULE_SETUP
 #line 120 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(opCOLONCOLON, lineIndex); return opCOLONCOLON; }
-            YY_BREAK
-      case 15:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( opCOLONCOLON, lineIndex ); return opCOLONCOLON; }
+	YY_BREAK
+case 15:
+YY_RULE_SETUP
 #line 121 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(opMINUSMINUS, lineIndex); return opMINUSMINUS; }
-            YY_BREAK
-      case 16:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( opMINUSMINUS, lineIndex ); return opMINUSMINUS; }
+	YY_BREAK
+case 16:
+YY_RULE_SETUP
 #line 122 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(opPLUSPLUS, lineIndex); return opPLUSPLUS; }
-            YY_BREAK
-      case 17:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( opPLUSPLUS, lineIndex ); return opPLUSPLUS; }
+	YY_BREAK
+case 17:
+YY_RULE_SETUP
 #line 123 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(opSTREQ, lineIndex); return opSTREQ; }
-            YY_BREAK
-      case 18:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( opSTREQ, lineIndex ); return opSTREQ; }
+	YY_BREAK
+case 18:
+YY_RULE_SETUP
 #line 124 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(opSTRNE, lineIndex); return opSTRNE; }
-            YY_BREAK
-      case 19:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( opSTRNE, lineIndex ); return opSTRNE; }
+	YY_BREAK
+case 19:
+YY_RULE_SETUP
 #line 125 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(opSHL, lineIndex); return opSHL; }
-            YY_BREAK
-      case 20:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( opSHL, lineIndex ); return opSHL; }
+	YY_BREAK
+case 20:
+YY_RULE_SETUP
 #line 126 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(opSHR, lineIndex); return opSHR; }
-            YY_BREAK
-      case 21:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( opSHR, lineIndex ); return opSHR; }
+	YY_BREAK
+case 21:
+YY_RULE_SETUP
 #line 127 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(opPLASN, lineIndex); return opPLASN; }
-            YY_BREAK
-      case 22:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( opPLASN, lineIndex ); return opPLASN; }
+	YY_BREAK
+case 22:
+YY_RULE_SETUP
 #line 128 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(opMIASN, lineIndex); return opMIASN; }
-            YY_BREAK
-      case 23:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( opMIASN, lineIndex ); return opMIASN; }
+	YY_BREAK
+case 23:
+YY_RULE_SETUP
 #line 129 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(opMLASN, lineIndex); return opMLASN; }
-            YY_BREAK
-      case 24:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( opMLASN, lineIndex ); return opMLASN; }
+	YY_BREAK
+case 24:
+YY_RULE_SETUP
 #line 130 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(opDVASN, lineIndex); return opDVASN; }
-            YY_BREAK
-      case 25:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( opDVASN, lineIndex ); return opDVASN; }
+	YY_BREAK
+case 25:
+YY_RULE_SETUP
 #line 131 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(opMODASN, lineIndex); return opMODASN; }
-            YY_BREAK
-      case 26:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( opMODASN, lineIndex ); return opMODASN; }
+	YY_BREAK
+case 26:
+YY_RULE_SETUP
 #line 132 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(opANDASN, lineIndex); return opANDASN; }
-            YY_BREAK
-      case 27:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( opANDASN, lineIndex ); return opANDASN; }
+	YY_BREAK
+case 27:
+YY_RULE_SETUP
 #line 133 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(opXORASN, lineIndex); return opXORASN; }
-            YY_BREAK
-      case 28:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( opXORASN, lineIndex ); return opXORASN; }
+	YY_BREAK
+case 28:
+YY_RULE_SETUP
 #line 134 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(opORASN, lineIndex); return opORASN; }
-            YY_BREAK
-      case 29:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( opORASN, lineIndex ); return opORASN; }
+	YY_BREAK
+case 29:
+YY_RULE_SETUP
 #line 135 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(opSLASN, lineIndex); return opSLASN; }
-            YY_BREAK
-      case 30:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( opSLASN, lineIndex ); return opSLASN; }
+	YY_BREAK
+case 30:
+YY_RULE_SETUP
 #line 136 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(opSRASN, lineIndex); return opSRASN; }
-            YY_BREAK
-      case 31:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( opSRASN, lineIndex ); return opSRASN; }
+	YY_BREAK
+case 31:
+YY_RULE_SETUP
 #line 137 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(opINTNAME, lineIndex); return opINTNAME; }
-            YY_BREAK
-      case 32:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( opINTNAME, lineIndex ); return opINTNAME; }
+	YY_BREAK
+case 32:
+YY_RULE_SETUP
 #line 138 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(opINTNAMER, lineIndex); return opINTNAMER; }
-            YY_BREAK
-      case 33:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( opINTNAMER, lineIndex ); return opINTNAMER; }
+	YY_BREAK
+case 33:
+YY_RULE_SETUP
 #line 139 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >('\n', lineIndex); return '@'; }
-            YY_BREAK
-      case 34:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( '\n', lineIndex ); return '@'; }
+	YY_BREAK
+case 34:
+YY_RULE_SETUP
 #line 140 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >('\t', lineIndex); return '@'; }
-            YY_BREAK
-      case 35:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( '\t', lineIndex ); return '@'; }
+	YY_BREAK
+case 35:
+YY_RULE_SETUP
 #line 141 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(' ', lineIndex); return '@'; }
-            YY_BREAK
-      case 36:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( ' ', lineIndex ); return '@'; }
+	YY_BREAK
+case 36:
+YY_RULE_SETUP
 #line 142 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(0, lineIndex); return '@'; }
-            YY_BREAK
-      case 37:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( 0, lineIndex ); return '@'; }
+	YY_BREAK
+case 37:
+YY_RULE_SETUP
 #line 143 "CMDscan.l"
-         { /* this comment stops syntax highlighting from getting messed up when editing the lexer in TextPad */
-            int c = 0, l;
-         for (; ; )
+{ /* this comment stops syntax highlighting from getting messed up when editing the lexer in TextPad */
+         int c = 0, l;
+         for ( ; ; )
          {
             l = c;
             c = yyinput();
 
             // Is this an open comment?
-            if (c == EOF)
+            if ( c == EOF )
             {
-               CMDerror("unexpected end of file found in comment");
+               CMDerror( "unexpected end of file found in comment" );
                break;
             }
 
             // Increment line numbers.
-            else if (c == '\n')
+            else if ( c == '\n' )
                lineIndex++;
 
             // Did we find the end of the comment?
-            else if (l == '*' && c == '/')
+            else if ( l == '*' && c == '/' )
                break;
          }
-         }
-            YY_BREAK
-      case 38:
+      }
+	YY_BREAK
+case 38:
 #line 167 "CMDscan.l"
-      case 39:
+case 39:
 #line 168 "CMDscan.l"
-      case 40:
+case 40:
 #line 169 "CMDscan.l"
-      case 41:
+case 41:
 #line 170 "CMDscan.l"
-      case 42:
+case 42:
 #line 171 "CMDscan.l"
-      case 43:
+case 43:
 #line 172 "CMDscan.l"
-      case 44:
+case 44:
 #line 173 "CMDscan.l"
-      case 45:
+case 45:
 #line 174 "CMDscan.l"
-      case 46:
+case 46:
 #line 175 "CMDscan.l"
-      case 47:
+case 47:
 #line 176 "CMDscan.l"
-      case 48:
+case 48:
 #line 177 "CMDscan.l"
-      case 49:
+case 49:
 #line 178 "CMDscan.l"
-      case 50:
+case 50:
 #line 179 "CMDscan.l"
-      case 51:
+case 51:
 #line 180 "CMDscan.l"
-      case 52:
+case 52:
 #line 181 "CMDscan.l"
-      case 53:
+case 53:
 #line 182 "CMDscan.l"
-      case 54:
+case 54:
 #line 183 "CMDscan.l"
-      case 55:
+case 55:
 #line 184 "CMDscan.l"
-      case 56:
+case 56:
 #line 185 "CMDscan.l"
-      case 57:
+case 57:
 #line 186 "CMDscan.l"
-      case 58:
+case 58:
 #line 187 "CMDscan.l"
-      case 59:
+case 59:
 #line 188 "CMDscan.l"
-      case 60:
+case 60:
 #line 189 "CMDscan.l"
-      case 61:
-         YY_RULE_SETUP
+case 61:
+YY_RULE_SETUP
 #line 189 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(CMDtext[0], lineIndex); return CMDtext[0]; }
-            YY_BREAK
-      case 62:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( CMDtext[ 0 ], lineIndex ); return CMDtext[ 0 ]; }
+	YY_BREAK
+case 62:
+YY_RULE_SETUP
 #line 190 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(rwIN, lineIndex); return(rwIN); }
-            YY_BREAK
-      case 63:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( rwIN, lineIndex ); return(rwIN); }
+	YY_BREAK
+case 63:
+YY_RULE_SETUP
 #line 191 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(rwCASEOR, lineIndex); return(rwCASEOR); }
-            YY_BREAK
-      case 64:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( rwCASEOR, lineIndex ); return(rwCASEOR); }
+	YY_BREAK
+case 64:
+YY_RULE_SETUP
 #line 192 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(rwBREAK, lineIndex); return(rwBREAK); }
-            YY_BREAK
-      case 65:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( rwBREAK, lineIndex ); return(rwBREAK); }
+	YY_BREAK
+case 65:
+YY_RULE_SETUP
 #line 193 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(rwRETURN, lineIndex); return(rwRETURN); }
-            YY_BREAK
-      case 66:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( rwRETURN, lineIndex ); return(rwRETURN); }
+	YY_BREAK
+case 66:
+YY_RULE_SETUP
 #line 194 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(rwELSE, lineIndex); return(rwELSE); }
-            YY_BREAK
-      case 67:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( rwELSE, lineIndex ); return(rwELSE); }
+	YY_BREAK
+case 67:
+YY_RULE_SETUP
 #line 195 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(rwASSERT, lineIndex); return(rwASSERT); }
-            YY_BREAK
-      case 68:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( rwASSERT, lineIndex ); return(rwASSERT); }
+	YY_BREAK
+case 68:
+YY_RULE_SETUP
 #line 196 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(rwWHILE, lineIndex); return(rwWHILE); }
-            YY_BREAK
-      case 69:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( rwWHILE, lineIndex ); return(rwWHILE); }
+	YY_BREAK
+case 69:
+YY_RULE_SETUP
 #line 197 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(rwDO, lineIndex); return(rwDO); }
-            YY_BREAK
-      case 70:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( rwDO, lineIndex ); return(rwDO); }
+	YY_BREAK
+case 70:
+YY_RULE_SETUP
 #line 198 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(rwIF, lineIndex); return(rwIF); }
-            YY_BREAK
-      case 71:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( rwIF, lineIndex ); return(rwIF); }
+	YY_BREAK
+case 71:
+YY_RULE_SETUP
 #line 199 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(rwFOREACHSTR, lineIndex); return(rwFOREACHSTR); }
-            YY_BREAK
-      case 72:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( rwFOREACHSTR, lineIndex ); return(rwFOREACHSTR); }
+	YY_BREAK
+case 72:
+YY_RULE_SETUP
 #line 200 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(rwFOREACH, lineIndex); return(rwFOREACH); }
-            YY_BREAK
-      case 73:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( rwFOREACH, lineIndex ); return(rwFOREACH); }
+	YY_BREAK
+case 73:
+YY_RULE_SETUP
 #line 201 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(rwFOR, lineIndex); return(rwFOR); }
-            YY_BREAK
-      case 74:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( rwFOR, lineIndex ); return(rwFOR); }
+	YY_BREAK
+case 74:
+YY_RULE_SETUP
 #line 202 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(rwCONTINUE, lineIndex); return(rwCONTINUE); }
-            YY_BREAK
-      case 75:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( rwCONTINUE, lineIndex ); return(rwCONTINUE); }
+	YY_BREAK
+case 75:
+YY_RULE_SETUP
 #line 203 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(rwDEFINE, lineIndex); return(rwDEFINE); }
-            YY_BREAK
-      case 76:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( rwDEFINE, lineIndex ); return(rwDEFINE); }
+	YY_BREAK
+case 76:
+YY_RULE_SETUP
 #line 204 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(rwDECLARE, lineIndex); return(rwDECLARE); }
-            YY_BREAK
-      case 77:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( rwDECLARE, lineIndex ); return(rwDECLARE); }
+	YY_BREAK
+case 77:
+YY_RULE_SETUP
 #line 205 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(rwDECLARESINGLETON, lineIndex); return(rwDECLARESINGLETON); }
-            YY_BREAK
-      case 78:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( rwDECLARESINGLETON, lineIndex ); return(rwDECLARESINGLETON); }
+	YY_BREAK
+case 78:
+YY_RULE_SETUP
 #line 206 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(rwDATABLOCK, lineIndex); return(rwDATABLOCK); }
-            YY_BREAK
-      case 79:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( rwDATABLOCK, lineIndex ); return(rwDATABLOCK); }
+	YY_BREAK
+case 79:
+YY_RULE_SETUP
 #line 207 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(rwCASE, lineIndex); return(rwCASE); }
-            YY_BREAK
-      case 80:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( rwCASE, lineIndex ); return(rwCASE); }
+	YY_BREAK
+case 80:
+YY_RULE_SETUP
 #line 208 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(rwSWITCHSTR, lineIndex); return(rwSWITCHSTR); }
-            YY_BREAK
-      case 81:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( rwSWITCHSTR, lineIndex ); return(rwSWITCHSTR); }
+	YY_BREAK
+case 81:
+YY_RULE_SETUP
 #line 209 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(rwSWITCH, lineIndex); return(rwSWITCH); }
-            YY_BREAK
-      case 82:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( rwSWITCH, lineIndex ); return(rwSWITCH); }
+	YY_BREAK
+case 82:
+YY_RULE_SETUP
 #line 210 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(rwDEFAULT, lineIndex); return(rwDEFAULT); }
-            YY_BREAK
-      case 83:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( rwDEFAULT, lineIndex ); return(rwDEFAULT); }
+	YY_BREAK
+case 83:
+YY_RULE_SETUP
 #line 211 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(rwPACKAGE, lineIndex); return(rwPACKAGE); }
-            YY_BREAK
-      case 84:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( rwPACKAGE, lineIndex ); return(rwPACKAGE); }
+	YY_BREAK
+case 84:
+YY_RULE_SETUP
 #line 212 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(rwNAMESPACE, lineIndex); return(rwNAMESPACE); }
-            YY_BREAK
-      case 85:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( rwNAMESPACE, lineIndex ); return(rwNAMESPACE); }
+	YY_BREAK
+case 85:
+YY_RULE_SETUP
 #line 213 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(1, lineIndex); return INTCONST; }
-            YY_BREAK
-      case 86:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( 1, lineIndex ); return INTCONST; }
+	YY_BREAK
+case 86:
+YY_RULE_SETUP
 #line 214 "CMDscan.l"
-         { CMDlval.i = MakeToken< int >(0, lineIndex); return INTCONST; }
-            YY_BREAK
-      case 87:
-         YY_RULE_SETUP
+{ CMDlval.i = MakeToken< int >( 0, lineIndex ); return INTCONST; }
+	YY_BREAK
+case 87:
+YY_RULE_SETUP
 #line 215 "CMDscan.l"
-         { return(Sc_ScanVar()); }
-            YY_BREAK
-      case 88:
-         YY_RULE_SETUP
+{ return(Sc_ScanVar()); }
+	YY_BREAK
+case 88:
+YY_RULE_SETUP
 #line 216 "CMDscan.l"
-         { return Sc_ScanIdent(); }
-            YY_BREAK
-      case 89:
-         YY_RULE_SETUP
+{ return Sc_ScanIdent(); }
+	YY_BREAK
+case 89:
+YY_RULE_SETUP
 #line 217 "CMDscan.l"
-            return(Sc_ScanHex());
-         YY_BREAK
-      case 90:
-         YY_RULE_SETUP
+return(Sc_ScanHex());
+	YY_BREAK
+case 90:
+YY_RULE_SETUP
 #line 218 "CMDscan.l"
-         { CMDtext[CMDleng] = 0; CMDlval.i = MakeToken< int >(dAtoi(CMDtext), lineIndex); return INTCONST; }
-            YY_BREAK
-      case 91:
-         YY_RULE_SETUP
+{ CMDtext[CMDleng] = 0; CMDlval.i = MakeToken< int >( dAtoi(CMDtext), lineIndex ); return INTCONST; }
+	YY_BREAK
+case 91:
+YY_RULE_SETUP
 #line 219 "CMDscan.l"
-            return Sc_ScanNum();
-         YY_BREAK
-      case 92:
-         YY_RULE_SETUP
+return Sc_ScanNum();
+	YY_BREAK
+case 92:
+YY_RULE_SETUP
 #line 220 "CMDscan.l"
-            return(ILLEGAL_TOKEN);
-         YY_BREAK
-      case 93:
-         YY_RULE_SETUP
+return(ILLEGAL_TOKEN);
+	YY_BREAK
+case 93:
+YY_RULE_SETUP
 #line 221 "CMDscan.l"
-            return(ILLEGAL_TOKEN);
-         YY_BREAK
-      case 94:
-         YY_RULE_SETUP
+return(ILLEGAL_TOKEN);
+	YY_BREAK
+case 94:
+YY_RULE_SETUP
 #line 222 "CMDscan.l"
-            ECHO;
-         YY_BREAK
+ECHO;
+	YY_BREAK
 #line 1291 "CMDscan.cpp"
-      case YY_STATE_EOF(INITIAL):
-         yyterminate();
+case YY_STATE_EOF(INITIAL):
+	yyterminate();
 
-      case YY_END_OF_BUFFER:
-      {
-         /* Amount of text matched not including the EOB char. */
-         int yy_amount_of_matched_text = (int)(yy_cp - yytext_ptr) - 1;
+	case YY_END_OF_BUFFER:
+		{
+		/* Amount of text matched not including the EOB char. */
+		int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
 
-         /* Undo the effects of YY_DO_BEFORE_ACTION. */
-         *yy_cp = yy_hold_char;
+		/* Undo the effects of YY_DO_BEFORE_ACTION. */
+		*yy_cp = yy_hold_char;
 
-         if (yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW)
-         {
-            /* We're scanning a new file or input source.  It's
-            * possible that this happened because the user
-            * just pointed yyin at a new source and called
-            * yylex().  If so, then we have to assure
-            * consistency between yy_current_buffer and our
-            * globals.  Here is the right place to do so, because
-            * this is the first action (other than possibly a
-            * back-up) that will match for the new input source.
-            */
-            yy_n_chars = yy_current_buffer->yy_n_chars;
-            yy_current_buffer->yy_input_file = yyin;
-            yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
-         }
+		if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
+			{
+			/* We're scanning a new file or input source.  It's
+			 * possible that this happened because the user
+			 * just pointed yyin at a new source and called
+			 * yylex().  If so, then we have to assure
+			 * consistency between yy_current_buffer and our
+			 * globals.  Here is the right place to do so, because
+			 * this is the first action (other than possibly a
+			 * back-up) that will match for the new input source.
+			 */
+			yy_n_chars = yy_current_buffer->yy_n_chars;
+			yy_current_buffer->yy_input_file = yyin;
+			yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
+			}
 
-         /* Note that here we test for yy_c_buf_p "<=" to the position
-         * of the first EOB in the buffer, since yy_c_buf_p will
-         * already have been incremented past the NUL character
-         * (since all states make transitions on EOB to the
-         * end-of-buffer state).  Contrast this with the test
-         * in input().
-         */
-         if (yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars])
-         { /* This was really a NUL. */
-            yy_state_type yy_next_state;
+		/* Note that here we test for yy_c_buf_p "<=" to the position
+		 * of the first EOB in the buffer, since yy_c_buf_p will
+		 * already have been incremented past the NUL character
+		 * (since all states make transitions on EOB to the
+		 * end-of-buffer state).  Contrast this with the test
+		 * in input().
+		 */
+		if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+			{ /* This was really a NUL. */
+			yy_state_type yy_next_state;
 
-            yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
+			yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
 
-            yy_current_state = yy_get_previous_state();
+			yy_current_state = yy_get_previous_state();
 
-            /* Okay, we're now positioned to make the NUL
-            * transition.  We couldn't have
-            * yy_get_previous_state() go ahead and do it
-            * for us because it doesn't know how to deal
-            * with the possibility of jamming (and we don't
-            * want to build jamming into it because then it
-            * will run more slowly).
-            */
+			/* Okay, we're now positioned to make the NUL
+			 * transition.  We couldn't have
+			 * yy_get_previous_state() go ahead and do it
+			 * for us because it doesn't know how to deal
+			 * with the possibility of jamming (and we don't
+			 * want to build jamming into it because then it
+			 * will run more slowly).
+			 */
 
-            yy_next_state = yy_try_NUL_trans(yy_current_state);
+			yy_next_state = yy_try_NUL_trans( yy_current_state );
 
-            yy_bp = yytext_ptr + YY_MORE_ADJ;
+			yy_bp = yytext_ptr + YY_MORE_ADJ;
 
-            if (yy_next_state)
-            {
-               /* Consume the NUL. */
-               yy_cp = ++yy_c_buf_p;
-               yy_current_state = yy_next_state;
-               goto yy_match;
-            }
+			if ( yy_next_state )
+				{
+				/* Consume the NUL. */
+				yy_cp = ++yy_c_buf_p;
+				yy_current_state = yy_next_state;
+				goto yy_match;
+				}
 
-            else
-            {
-               yy_cp = yy_c_buf_p;
-               goto yy_find_action;
-            }
-         }
+			else
+				{
+				yy_cp = yy_c_buf_p;
+				goto yy_find_action;
+				}
+			}
 
-         else switch (yy_get_next_buffer())
-         {
-            case EOB_ACT_END_OF_FILE:
-            {
-               yy_did_buffer_switch_on_eof = 0;
+		else switch ( yy_get_next_buffer() )
+			{
+			case EOB_ACT_END_OF_FILE:
+				{
+				yy_did_buffer_switch_on_eof = 0;
 
-               if (yywrap())
-               {
-                  /* Note: because we've taken care in
-                  * yy_get_next_buffer() to have set up
-                  * yytext, we can now set up
-                  * yy_c_buf_p so that if some total
-                  * hoser (like flex itself) wants to
-                  * call the scanner after we return the
-                  * YY_NULL, it'll still work - another
-                  * YY_NULL will get returned.
-                  */
-                  yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
+				if ( yywrap() )
+					{
+					/* Note: because we've taken care in
+					 * yy_get_next_buffer() to have set up
+					 * yytext, we can now set up
+					 * yy_c_buf_p so that if some total
+					 * hoser (like flex itself) wants to
+					 * call the scanner after we return the
+					 * YY_NULL, it'll still work - another
+					 * YY_NULL will get returned.
+					 */
+					yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
 
-                  yy_act = YY_STATE_EOF(YY_START);
-                  goto do_action;
-               }
+					yy_act = YY_STATE_EOF(YY_START);
+					goto do_action;
+					}
 
-               else
-               {
-                  if (!yy_did_buffer_switch_on_eof)
-                     YY_NEW_FILE;
-               }
-               break;
-            }
+				else
+					{
+					if ( ! yy_did_buffer_switch_on_eof )
+						YY_NEW_FILE;
+					}
+				break;
+				}
 
-            case EOB_ACT_CONTINUE_SCAN:
-               yy_c_buf_p =
-                  yytext_ptr + yy_amount_of_matched_text;
+			case EOB_ACT_CONTINUE_SCAN:
+				yy_c_buf_p =
+					yytext_ptr + yy_amount_of_matched_text;
 
-               yy_current_state = yy_get_previous_state();
+				yy_current_state = yy_get_previous_state();
 
-               yy_cp = yy_c_buf_p;
-               yy_bp = yytext_ptr + YY_MORE_ADJ;
-               goto yy_match;
+				yy_cp = yy_c_buf_p;
+				yy_bp = yytext_ptr + YY_MORE_ADJ;
+				goto yy_match;
 
-            case EOB_ACT_LAST_MATCH:
-               yy_c_buf_p =
-                  &yy_current_buffer->yy_ch_buf[yy_n_chars];
+			case EOB_ACT_LAST_MATCH:
+				yy_c_buf_p =
+				&yy_current_buffer->yy_ch_buf[yy_n_chars];
 
-               yy_current_state = yy_get_previous_state();
+				yy_current_state = yy_get_previous_state();
 
-               yy_cp = yy_c_buf_p;
-               yy_bp = yytext_ptr + YY_MORE_ADJ;
-               goto yy_find_action;
-         }
-         break;
-      }
+				yy_cp = yy_c_buf_p;
+				yy_bp = yytext_ptr + YY_MORE_ADJ;
+				goto yy_find_action;
+			}
+		break;
+		}
 
-      default:
-         YY_FATAL_ERROR(
-            "fatal flex scanner internal error--no action found");
-   } /* end of action switch */
-} /* end of scanning one token */
-} /* end of yylex */
+	default:
+		YY_FATAL_ERROR(
+			"fatal flex scanner internal error--no action found" );
+	} /* end of action switch */
+		} /* end of scanning one token */
+	} /* end of yylex */
 
 
-  /* yy_get_next_buffer - try to read in a new buffer
-  *
-  * Returns a code representing an action:
-  *	EOB_ACT_LAST_MATCH -
-  *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
-  *	EOB_ACT_END_OF_FILE - end of file
-  */
+/* yy_get_next_buffer - try to read in a new buffer
+ *
+ * Returns a code representing an action:
+ *	EOB_ACT_LAST_MATCH -
+ *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
+ *	EOB_ACT_END_OF_FILE - end of file
+ */
 
-   static int yy_get_next_buffer()
-{
-   register char *dest = yy_current_buffer->yy_ch_buf;
-   register char *source = yytext_ptr;
-   register int number_to_move, i;
-   int ret_val;
+static int yy_get_next_buffer()
+	{
+	register char *dest = yy_current_buffer->yy_ch_buf;
+	register char *source = yytext_ptr;
+	register int number_to_move, i;
+	int ret_val;
 
-   if (yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1])
-      YY_FATAL_ERROR(
-         "fatal flex scanner internal error--end of buffer missed");
+	if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
+		YY_FATAL_ERROR(
+		"fatal flex scanner internal error--end of buffer missed" );
 
-   if (yy_current_buffer->yy_fill_buffer == 0)
-   { /* Don't try to fill the buffer, so this is an EOF. */
-      if (yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1)
-      {
-         /* We matched a singled characater, the EOB, so
-         * treat this as a final EOF.
-         */
-         return EOB_ACT_END_OF_FILE;
-      }
+	if ( yy_current_buffer->yy_fill_buffer == 0 )
+		{ /* Don't try to fill the buffer, so this is an EOF. */
+		if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
+			{
+			/* We matched a singled characater, the EOB, so
+			 * treat this as a final EOF.
+			 */
+			return EOB_ACT_END_OF_FILE;
+			}
 
-      else
-      {
-         /* We matched some text prior to the EOB, first
-         * process it.
-         */
-         return EOB_ACT_LAST_MATCH;
-      }
-   }
+		else
+			{
+			/* We matched some text prior to the EOB, first
+			 * process it.
+			 */
+			return EOB_ACT_LAST_MATCH;
+			}
+		}
 
-   /* Try to read more data. */
+	/* Try to read more data. */
 
-   /* First move last chars to start of buffer. */
-   number_to_move = (int)(yy_c_buf_p - yytext_ptr) - 1;
+	/* First move last chars to start of buffer. */
+	number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
 
-   for (i = 0; i < number_to_move; ++i)
-      *(dest++) = *(source++);
+	for ( i = 0; i < number_to_move; ++i )
+		*(dest++) = *(source++);
 
-   if (yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING)
-      /* don't do the read, it's not guaranteed to return an EOF,
-      * just force an EOF
-      */
-      yy_n_chars = 0;
+	if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+		/* don't do the read, it's not guaranteed to return an EOF,
+		 * just force an EOF
+		 */
+		yy_n_chars = 0;
 
-   else
-   {
-      int num_to_read =
-         yy_current_buffer->yy_buf_size - number_to_move - 1;
+	else
+		{
+		int num_to_read =
+			yy_current_buffer->yy_buf_size - number_to_move - 1;
 
-      while (num_to_read <= 0)
-      { /* Not enough room in the buffer - grow it. */
+		while ( num_to_read <= 0 )
+			{ /* Not enough room in the buffer - grow it. */
 #ifdef YY_USES_REJECT
-         YY_FATAL_ERROR(
-            "input buffer overflow, can't enlarge buffer because scanner uses REJECT");
+			YY_FATAL_ERROR(
+"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
 #else
 
-        /* just a shorter name for the current buffer */
-         YY_BUFFER_STATE b = yy_current_buffer;
+			/* just a shorter name for the current buffer */
+			YY_BUFFER_STATE b = yy_current_buffer;
 
-         int yy_c_buf_p_offset =
-            (int)(yy_c_buf_p - b->yy_ch_buf);
+			int yy_c_buf_p_offset =
+				(int) (yy_c_buf_p - b->yy_ch_buf);
 
-         if (b->yy_is_our_buffer)
-         {
-            int new_size = b->yy_buf_size * 2;
+			if ( b->yy_is_our_buffer )
+				{
+				int new_size = b->yy_buf_size * 2;
 
-            if (new_size <= 0)
-               b->yy_buf_size += b->yy_buf_size / 8;
-            else
-               b->yy_buf_size *= 2;
+				if ( new_size <= 0 )
+					b->yy_buf_size += b->yy_buf_size / 8;
+				else
+					b->yy_buf_size *= 2;
 
-            b->yy_ch_buf = (char *)
-               /* Include room in for 2 EOB chars. */
-               yy_flex_realloc((void *)b->yy_ch_buf,
-                  b->yy_buf_size + 2);
-         }
-         else
-            /* Can't grow it, we don't own it. */
-            b->yy_ch_buf = 0;
+				b->yy_ch_buf = (char *)
+					/* Include room in for 2 EOB chars. */
+					yy_flex_realloc( (void *) b->yy_ch_buf,
+							 b->yy_buf_size + 2 );
+				}
+			else
+				/* Can't grow it, we don't own it. */
+				b->yy_ch_buf = 0;
 
-         if (!b->yy_ch_buf)
-            YY_FATAL_ERROR(
-               "fatal error - scanner input buffer overflow");
+			if ( ! b->yy_ch_buf )
+				YY_FATAL_ERROR(
+				"fatal error - scanner input buffer overflow" );
 
-         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
+			yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
 
-         num_to_read = yy_current_buffer->yy_buf_size -
-            number_to_move - 1;
+			num_to_read = yy_current_buffer->yy_buf_size -
+						number_to_move - 1;
 #endif
-      }
+			}
 
-      if (num_to_read > YY_READ_BUF_SIZE)
-         num_to_read = YY_READ_BUF_SIZE;
+		if ( num_to_read > YY_READ_BUF_SIZE )
+			num_to_read = YY_READ_BUF_SIZE;
 
-      /* Read in more data. */
-      YY_INPUT((&yy_current_buffer->yy_ch_buf[number_to_move]),
-         yy_n_chars, num_to_read);
-   }
+		/* Read in more data. */
+		YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
+			yy_n_chars, num_to_read );
+		}
 
-   if (yy_n_chars == 0)
-   {
-      if (number_to_move == YY_MORE_ADJ)
-      {
-         ret_val = EOB_ACT_END_OF_FILE;
-         yyrestart(yyin);
-      }
+	if ( yy_n_chars == 0 )
+		{
+		if ( number_to_move == YY_MORE_ADJ )
+			{
+			ret_val = EOB_ACT_END_OF_FILE;
+			yyrestart( yyin );
+			}
 
-      else
-      {
-         ret_val = EOB_ACT_LAST_MATCH;
-         yy_current_buffer->yy_buffer_status =
-            YY_BUFFER_EOF_PENDING;
-      }
-   }
+		else
+			{
+			ret_val = EOB_ACT_LAST_MATCH;
+			yy_current_buffer->yy_buffer_status =
+				YY_BUFFER_EOF_PENDING;
+			}
+		}
 
-   else
-      ret_val = EOB_ACT_CONTINUE_SCAN;
+	else
+		ret_val = EOB_ACT_CONTINUE_SCAN;
 
-   yy_n_chars += number_to_move;
-   yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
-   yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
+	yy_n_chars += number_to_move;
+	yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
+	yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
 
-   yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
+	yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
 
-   return ret_val;
-}
+	return ret_val;
+	}
 
 
 /* yy_get_previous_state - get the state just before the EOB char was reached */
 
 static yy_state_type yy_get_previous_state()
-{
-   register yy_state_type yy_current_state;
-   register char *yy_cp;
+	{
+	register yy_state_type yy_current_state;
+	register char *yy_cp;
 
-   yy_current_state = yy_start;
+	yy_current_state = yy_start;
 
-   for (yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp)
-   {
-      register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
-      if (yy_accept[yy_current_state])
-      {
-         yy_last_accepting_state = yy_current_state;
-         yy_last_accepting_cpos = yy_cp;
-      }
-      while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state)
-      {
-         yy_current_state = (int)yy_def[yy_current_state];
-         if (yy_current_state >= 224)
-            yy_c = yy_meta[(unsigned int)yy_c];
-      }
-      yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int)yy_c];
-   }
+	for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
+		{
+		register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+		if ( yy_accept[yy_current_state] )
+			{
+			yy_last_accepting_state = yy_current_state;
+			yy_last_accepting_cpos = yy_cp;
+			}
+		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+			{
+			yy_current_state = (int) yy_def[yy_current_state];
+			if ( yy_current_state >= 224 )
+				yy_c = yy_meta[(unsigned int) yy_c];
+			}
+		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+		}
 
-   return yy_current_state;
-}
+	return yy_current_state;
+	}
 
 
 /* yy_try_NUL_trans - try to make a transition on the NUL character
-*
-* synopsis
-*	next_state = yy_try_NUL_trans( current_state );
-*/
+ *
+ * synopsis
+ *	next_state = yy_try_NUL_trans( current_state );
+ */
 
 #ifdef YY_USE_PROTOS
-static yy_state_type yy_try_NUL_trans(yy_state_type yy_current_state)
+static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
 #else
-static yy_state_type yy_try_NUL_trans(yy_current_state)
+static yy_state_type yy_try_NUL_trans( yy_current_state )
 yy_state_type yy_current_state;
 #endif
-{
-   register int yy_is_jam;
-   register char *yy_cp = yy_c_buf_p;
+	{
+	register int yy_is_jam;
+	register char *yy_cp = yy_c_buf_p;
 
-   register YY_CHAR yy_c = 1;
-   if (yy_accept[yy_current_state])
-   {
-      yy_last_accepting_state = yy_current_state;
-      yy_last_accepting_cpos = yy_cp;
-   }
-   while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state)
-   {
-      yy_current_state = (int)yy_def[yy_current_state];
-      if (yy_current_state >= 224)
-         yy_c = yy_meta[(unsigned int)yy_c];
-   }
-   yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int)yy_c];
-   yy_is_jam = (yy_current_state == 223);
+	register YY_CHAR yy_c = 1;
+	if ( yy_accept[yy_current_state] )
+		{
+		yy_last_accepting_state = yy_current_state;
+		yy_last_accepting_cpos = yy_cp;
+		}
+	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+		{
+		yy_current_state = (int) yy_def[yy_current_state];
+		if ( yy_current_state >= 224 )
+			yy_c = yy_meta[(unsigned int) yy_c];
+		}
+	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+	yy_is_jam = (yy_current_state == 223);
 
-   return yy_is_jam ? 0 : yy_current_state;
-}
+	return yy_is_jam ? 0 : yy_current_state;
+	}
 
 
 #ifndef YY_NO_UNPUT
 #ifdef YY_USE_PROTOS
-static void yyunput(int c, register char *yy_bp)
+static void yyunput( int c, register char *yy_bp )
 #else
-static void yyunput(c, yy_bp)
+static void yyunput( c, yy_bp )
 int c;
 register char *yy_bp;
 #endif
-{
-   register char *yy_cp = yy_c_buf_p;
+	{
+	register char *yy_cp = yy_c_buf_p;
 
-   /* undo effects of setting up yytext */
-   *yy_cp = yy_hold_char;
+	/* undo effects of setting up yytext */
+	*yy_cp = yy_hold_char;
 
-   if (yy_cp < yy_current_buffer->yy_ch_buf + 2)
-   { /* need to shift things up to make room */
-     /* +2 for EOB chars. */
-      register int number_to_move = yy_n_chars + 2;
-      register char *dest = &yy_current_buffer->yy_ch_buf[
-         yy_current_buffer->yy_buf_size + 2];
-      register char *source =
-         &yy_current_buffer->yy_ch_buf[number_to_move];
+	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+		{ /* need to shift things up to make room */
+		/* +2 for EOB chars. */
+		register int number_to_move = yy_n_chars + 2;
+		register char *dest = &yy_current_buffer->yy_ch_buf[
+					yy_current_buffer->yy_buf_size + 2];
+		register char *source =
+				&yy_current_buffer->yy_ch_buf[number_to_move];
 
-      while (source > yy_current_buffer->yy_ch_buf)
-         *--dest = *--source;
+		while ( source > yy_current_buffer->yy_ch_buf )
+			*--dest = *--source;
 
-      yy_cp += (int)(dest - source);
-      yy_bp += (int)(dest - source);
-      yy_n_chars = yy_current_buffer->yy_buf_size;
+		yy_cp += (int) (dest - source);
+		yy_bp += (int) (dest - source);
+		yy_n_chars = yy_current_buffer->yy_buf_size;
 
-      if (yy_cp < yy_current_buffer->yy_ch_buf + 2)
-         YY_FATAL_ERROR("flex scanner push-back overflow");
-   }
+		if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+			YY_FATAL_ERROR( "flex scanner push-back overflow" );
+		}
 
-   *--yy_cp = (char)c;
+	*--yy_cp = (char) c;
 
 
-   yytext_ptr = yy_bp;
-   yy_hold_char = *yy_cp;
-   yy_c_buf_p = yy_cp;
-}
+	yytext_ptr = yy_bp;
+	yy_hold_char = *yy_cp;
+	yy_c_buf_p = yy_cp;
+	}
 #endif	/* ifndef YY_NO_UNPUT */
 
 
@@ -1669,384 +1670,384 @@ static int yyinput()
 #else
 static int input()
 #endif
-{
-   int c;
+	{
+	int c;
 
-   *yy_c_buf_p = yy_hold_char;
+	*yy_c_buf_p = yy_hold_char;
 
-   if (*yy_c_buf_p == YY_END_OF_BUFFER_CHAR)
-   {
-      /* yy_c_buf_p now points to the character we want to return.
-      * If this occurs *before* the EOB characters, then it's a
-      * valid NUL; if not, then we've hit the end of the buffer.
-      */
-      if (yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars])
-         /* This was really a NUL. */
-         *yy_c_buf_p = '\0';
+	if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
+		{
+		/* yy_c_buf_p now points to the character we want to return.
+		 * If this occurs *before* the EOB characters, then it's a
+		 * valid NUL; if not, then we've hit the end of the buffer.
+		 */
+		if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+			/* This was really a NUL. */
+			*yy_c_buf_p = '\0';
 
-      else
-      { /* need more input */
-         yytext_ptr = yy_c_buf_p;
-         ++yy_c_buf_p;
+		else
+			{ /* need more input */
+			yytext_ptr = yy_c_buf_p;
+			++yy_c_buf_p;
 
-         switch (yy_get_next_buffer())
-         {
-            case EOB_ACT_END_OF_FILE:
-            {
-               if (yywrap())
-               {
-                  yy_c_buf_p =
-                     yytext_ptr + YY_MORE_ADJ;
-                  return EOF;
-               }
+			switch ( yy_get_next_buffer() )
+				{
+				case EOB_ACT_END_OF_FILE:
+					{
+					if ( yywrap() )
+						{
+						yy_c_buf_p =
+						yytext_ptr + YY_MORE_ADJ;
+						return EOF;
+						}
 
-               if (!yy_did_buffer_switch_on_eof)
-                  YY_NEW_FILE;
+					if ( ! yy_did_buffer_switch_on_eof )
+						YY_NEW_FILE;
 #ifdef __cplusplus
-               return yyinput();
+					return yyinput();
 #else
-               return input();
+					return input();
 #endif
-            }
+					}
 
-            case EOB_ACT_CONTINUE_SCAN:
-               yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
-               break;
+				case EOB_ACT_CONTINUE_SCAN:
+					yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
+					break;
 
-            case EOB_ACT_LAST_MATCH:
+				case EOB_ACT_LAST_MATCH:
 #ifdef __cplusplus
-               YY_FATAL_ERROR(
-                  "unexpected last match in yyinput()");
+					YY_FATAL_ERROR(
+					"unexpected last match in yyinput()" );
 #else
-               YY_FATAL_ERROR(
-                  "unexpected last match in input()");
+					YY_FATAL_ERROR(
+					"unexpected last match in input()" );
 #endif
-         }
-      }
-   }
+				}
+			}
+		}
 
-   c = *(unsigned char *)yy_c_buf_p;	/* cast for 8-bit char's */
-   *yy_c_buf_p = '\0';	/* preserve yytext */
-   yy_hold_char = *++yy_c_buf_p;
+	c = *(unsigned char *) yy_c_buf_p;	/* cast for 8-bit char's */
+	*yy_c_buf_p = '\0';	/* preserve yytext */
+	yy_hold_char = *++yy_c_buf_p;
 
 
-   return c;
-}
+	return c;
+	}
 
 
 #ifdef YY_USE_PROTOS
-void yyrestart(FILE *input_file)
+void yyrestart( FILE *input_file )
 #else
-void yyrestart(input_file)
+void yyrestart( input_file )
 FILE *input_file;
 #endif
-{
-   if (!yy_current_buffer)
-      yy_current_buffer = yy_create_buffer(yyin, YY_BUF_SIZE);
+	{
+	if ( ! yy_current_buffer )
+		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
 
-   yy_init_buffer(yy_current_buffer, input_file);
-   yy_load_buffer_state();
-}
+	yy_init_buffer( yy_current_buffer, input_file );
+	yy_load_buffer_state();
+	}
 
 
 #ifdef YY_USE_PROTOS
-void yy_switch_to_buffer(YY_BUFFER_STATE new_buffer)
+void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
 #else
-void yy_switch_to_buffer(new_buffer)
+void yy_switch_to_buffer( new_buffer )
 YY_BUFFER_STATE new_buffer;
 #endif
-{
-   if (yy_current_buffer == new_buffer)
-      return;
+	{
+	if ( yy_current_buffer == new_buffer )
+		return;
 
-   if (yy_current_buffer)
-   {
-      /* Flush out information for old buffer. */
-      *yy_c_buf_p = yy_hold_char;
-      yy_current_buffer->yy_buf_pos = yy_c_buf_p;
-      yy_current_buffer->yy_n_chars = yy_n_chars;
-   }
+	if ( yy_current_buffer )
+		{
+		/* Flush out information for old buffer. */
+		*yy_c_buf_p = yy_hold_char;
+		yy_current_buffer->yy_buf_pos = yy_c_buf_p;
+		yy_current_buffer->yy_n_chars = yy_n_chars;
+		}
 
-   yy_current_buffer = new_buffer;
-   yy_load_buffer_state();
+	yy_current_buffer = new_buffer;
+	yy_load_buffer_state();
 
-   /* We don't actually know whether we did this switch during
-   * EOF (yywrap()) processing, but the only time this flag
-   * is looked at is after yywrap() is called, so it's safe
-   * to go ahead and always set it.
-   */
-   yy_did_buffer_switch_on_eof = 1;
-}
+	/* We don't actually know whether we did this switch during
+	 * EOF (yywrap()) processing, but the only time this flag
+	 * is looked at is after yywrap() is called, so it's safe
+	 * to go ahead and always set it.
+	 */
+	yy_did_buffer_switch_on_eof = 1;
+	}
 
 
 #ifdef YY_USE_PROTOS
-void yy_load_buffer_state(void)
+void yy_load_buffer_state( void )
 #else
 void yy_load_buffer_state()
 #endif
-{
-   yy_n_chars = yy_current_buffer->yy_n_chars;
-   yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
-   yyin = yy_current_buffer->yy_input_file;
-   yy_hold_char = *yy_c_buf_p;
-}
+	{
+	yy_n_chars = yy_current_buffer->yy_n_chars;
+	yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
+	yyin = yy_current_buffer->yy_input_file;
+	yy_hold_char = *yy_c_buf_p;
+	}
 
 
 #ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_create_buffer(FILE *file, int size)
+YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
 #else
-YY_BUFFER_STATE yy_create_buffer(file, size)
+YY_BUFFER_STATE yy_create_buffer( file, size )
 FILE *file;
 int size;
 #endif
-{
-   YY_BUFFER_STATE b;
+	{
+	YY_BUFFER_STATE b;
 
-   b = (YY_BUFFER_STATE)yy_flex_alloc(sizeof(struct yy_buffer_state));
-   if (!b)
-      YY_FATAL_ERROR("out of dynamic memory in yy_create_buffer()");
+	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
 
-   b->yy_buf_size = size;
+	b->yy_buf_size = size;
 
-   /* yy_ch_buf has to be 2 characters longer than the size given because
-   * we need to put in 2 end-of-buffer characters.
-   */
-   b->yy_ch_buf = (char *)yy_flex_alloc(b->yy_buf_size + 2);
-   if (!b->yy_ch_buf)
-      YY_FATAL_ERROR("out of dynamic memory in yy_create_buffer()");
+	/* yy_ch_buf has to be 2 characters longer than the size given because
+	 * we need to put in 2 end-of-buffer characters.
+	 */
+	b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
+	if ( ! b->yy_ch_buf )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
 
-   b->yy_is_our_buffer = 1;
+	b->yy_is_our_buffer = 1;
 
-   yy_init_buffer(b, file);
+	yy_init_buffer( b, file );
 
-   return b;
-}
+	return b;
+	}
 
 
 #ifdef YY_USE_PROTOS
-void yy_delete_buffer(YY_BUFFER_STATE b)
+void yy_delete_buffer( YY_BUFFER_STATE b )
 #else
-void yy_delete_buffer(b)
+void yy_delete_buffer( b )
 YY_BUFFER_STATE b;
 #endif
-{
-   if (!b)
-      return;
+	{
+	if ( ! b )
+		return;
 
-   if (b == yy_current_buffer)
-      yy_current_buffer = (YY_BUFFER_STATE)0;
+	if ( b == yy_current_buffer )
+		yy_current_buffer = (YY_BUFFER_STATE) 0;
 
-   if (b->yy_is_our_buffer)
-      yy_flex_free((void *)b->yy_ch_buf);
+	if ( b->yy_is_our_buffer )
+		yy_flex_free( (void *) b->yy_ch_buf );
 
-   yy_flex_free((void *)b);
-}
+	yy_flex_free( (void *) b );
+	}
 
 
 #ifndef YY_ALWAYS_INTERACTIVE
 #ifndef YY_NEVER_INTERACTIVE
-extern int isatty YY_PROTO((int));
+extern int isatty YY_PROTO(( int ));
 #endif
 #endif
 
 #ifdef YY_USE_PROTOS
-void yy_init_buffer(YY_BUFFER_STATE b, FILE *file)
+void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
 #else
-void yy_init_buffer(b, file)
+void yy_init_buffer( b, file )
 YY_BUFFER_STATE b;
 FILE *file;
 #endif
 
 
-{
-   yy_flush_buffer(b);
+	{
+	yy_flush_buffer( b );
 
-   b->yy_input_file = file;
-   b->yy_fill_buffer = 1;
+	b->yy_input_file = file;
+	b->yy_fill_buffer = 1;
 
 #if YY_ALWAYS_INTERACTIVE
-   b->yy_is_interactive = 1;
+	b->yy_is_interactive = 1;
 #else
 #if YY_NEVER_INTERACTIVE
-   b->yy_is_interactive = 0;
+	b->yy_is_interactive = 0;
 #else
-   b->yy_is_interactive = file ? (isatty(fileno(file)) > 0) : 0;
+	b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
 #endif
 #endif
-}
+	}
 
 
 #ifdef YY_USE_PROTOS
-void yy_flush_buffer(YY_BUFFER_STATE b)
+void yy_flush_buffer( YY_BUFFER_STATE b )
 #else
-void yy_flush_buffer(b)
+void yy_flush_buffer( b )
 YY_BUFFER_STATE b;
 #endif
 
-{
-   b->yy_n_chars = 0;
+	{
+	b->yy_n_chars = 0;
 
-   /* We always need two end-of-buffer characters.  The first causes
-   * a transition to the end-of-buffer state.  The second causes
-   * a jam in that state.
-   */
-   b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
-   b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
+	/* We always need two end-of-buffer characters.  The first causes
+	 * a transition to the end-of-buffer state.  The second causes
+	 * a jam in that state.
+	 */
+	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
+	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
 
-   b->yy_buf_pos = &b->yy_ch_buf[0];
+	b->yy_buf_pos = &b->yy_ch_buf[0];
 
-   b->yy_at_bol = 1;
-   b->yy_buffer_status = YY_BUFFER_NEW;
+	b->yy_at_bol = 1;
+	b->yy_buffer_status = YY_BUFFER_NEW;
 
-   if (b == yy_current_buffer)
-      yy_load_buffer_state();
-}
+	if ( b == yy_current_buffer )
+		yy_load_buffer_state();
+	}
 
 
 #ifndef YY_NO_SCAN_BUFFER
 #ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_scan_buffer(char *base, yy_size_t size)
+YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
 #else
-YY_BUFFER_STATE yy_scan_buffer(base, size)
+YY_BUFFER_STATE yy_scan_buffer( base, size )
 char *base;
 yy_size_t size;
 #endif
-{
-   YY_BUFFER_STATE b;
+	{
+	YY_BUFFER_STATE b;
 
-   if (size < 2 ||
-      base[size - 2] != YY_END_OF_BUFFER_CHAR ||
-      base[size - 1] != YY_END_OF_BUFFER_CHAR)
-      /* They forgot to leave room for the EOB's. */
-      return 0;
+	if ( size < 2 ||
+	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
+	     base[size-1] != YY_END_OF_BUFFER_CHAR )
+		/* They forgot to leave room for the EOB's. */
+		return 0;
 
-   b = (YY_BUFFER_STATE)yy_flex_alloc(sizeof(struct yy_buffer_state));
-   if (!b)
-      YY_FATAL_ERROR("out of dynamic memory in yy_scan_buffer()");
+	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
 
-   b->yy_buf_size = size - 2;	/* "- 2" to take care of EOB's */
-   b->yy_buf_pos = b->yy_ch_buf = base;
-   b->yy_is_our_buffer = 0;
-   b->yy_input_file = 0;
-   b->yy_n_chars = b->yy_buf_size;
-   b->yy_is_interactive = 0;
-   b->yy_at_bol = 1;
-   b->yy_fill_buffer = 0;
-   b->yy_buffer_status = YY_BUFFER_NEW;
+	b->yy_buf_size = size - 2;	/* "- 2" to take care of EOB's */
+	b->yy_buf_pos = b->yy_ch_buf = base;
+	b->yy_is_our_buffer = 0;
+	b->yy_input_file = 0;
+	b->yy_n_chars = b->yy_buf_size;
+	b->yy_is_interactive = 0;
+	b->yy_at_bol = 1;
+	b->yy_fill_buffer = 0;
+	b->yy_buffer_status = YY_BUFFER_NEW;
 
-   yy_switch_to_buffer(b);
+	yy_switch_to_buffer( b );
 
-   return b;
-}
+	return b;
+	}
 #endif
 
 
 #ifndef YY_NO_SCAN_STRING
 #ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_scan_string(yyconst char *str)
+YY_BUFFER_STATE yy_scan_string( yyconst char *str )
 #else
-YY_BUFFER_STATE yy_scan_string(str)
+YY_BUFFER_STATE yy_scan_string( str )
 yyconst char *str;
 #endif
-{
-   int len;
-   for (len = 0; str[len]; ++len)
-      ;
+	{
+	int len;
+	for ( len = 0; str[len]; ++len )
+		;
 
-   return yy_scan_bytes(str, len);
-}
+	return yy_scan_bytes( str, len );
+	}
 #endif
 
 
 #ifndef YY_NO_SCAN_BYTES
 #ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_scan_bytes(yyconst char *bytes, int len)
+YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
 #else
-YY_BUFFER_STATE yy_scan_bytes(bytes, len)
+YY_BUFFER_STATE yy_scan_bytes( bytes, len )
 yyconst char *bytes;
 int len;
 #endif
-{
-   YY_BUFFER_STATE b;
-   char *buf;
-   yy_size_t n;
-   int i;
+	{
+	YY_BUFFER_STATE b;
+	char *buf;
+	yy_size_t n;
+	int i;
 
-   /* Get memory for full buffer, including space for trailing EOB's. */
-   n = len + 2;
-   buf = (char *)yy_flex_alloc(n);
-   if (!buf)
-      YY_FATAL_ERROR("out of dynamic memory in yy_scan_bytes()");
+	/* Get memory for full buffer, including space for trailing EOB's. */
+	n = len + 2;
+	buf = (char *) yy_flex_alloc( n );
+	if ( ! buf )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
 
-   for (i = 0; i < len; ++i)
-      buf[i] = bytes[i];
+	for ( i = 0; i < len; ++i )
+		buf[i] = bytes[i];
 
-   buf[len] = buf[len + 1] = YY_END_OF_BUFFER_CHAR;
+	buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
 
-   b = yy_scan_buffer(buf, n);
-   if (!b)
-      YY_FATAL_ERROR("bad buffer in yy_scan_bytes()");
+	b = yy_scan_buffer( buf, n );
+	if ( ! b )
+		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
 
-   /* It's okay to grow etc. this buffer, and we should throw it
-   * away when we're done.
-   */
-   b->yy_is_our_buffer = 1;
+	/* It's okay to grow etc. this buffer, and we should throw it
+	 * away when we're done.
+	 */
+	b->yy_is_our_buffer = 1;
 
-   return b;
-}
+	return b;
+	}
 #endif
 
 
 #ifndef YY_NO_PUSH_STATE
 #ifdef YY_USE_PROTOS
-static void yy_push_state(int new_state)
+static void yy_push_state( int new_state )
 #else
-static void yy_push_state(new_state)
+static void yy_push_state( new_state )
 int new_state;
 #endif
-{
-   if (yy_start_stack_ptr >= yy_start_stack_depth)
-   {
-      yy_size_t new_size;
+	{
+	if ( yy_start_stack_ptr >= yy_start_stack_depth )
+		{
+		yy_size_t new_size;
 
-      yy_start_stack_depth += YY_START_STACK_INCR;
-      new_size = yy_start_stack_depth * sizeof(int);
+		yy_start_stack_depth += YY_START_STACK_INCR;
+		new_size = yy_start_stack_depth * sizeof( int );
 
-      if (!yy_start_stack)
-         yy_start_stack = (int *)yy_flex_alloc(new_size);
+		if ( ! yy_start_stack )
+			yy_start_stack = (int *) yy_flex_alloc( new_size );
 
-      else
-         yy_start_stack = (int *)yy_flex_realloc(
-         (void *)yy_start_stack, new_size);
+		else
+			yy_start_stack = (int *) yy_flex_realloc(
+					(void *) yy_start_stack, new_size );
 
-      if (!yy_start_stack)
-         YY_FATAL_ERROR(
-            "out of memory expanding start-condition stack");
-   }
+		if ( ! yy_start_stack )
+			YY_FATAL_ERROR(
+			"out of memory expanding start-condition stack" );
+		}
 
-   yy_start_stack[yy_start_stack_ptr++] = YY_START;
+	yy_start_stack[yy_start_stack_ptr++] = YY_START;
 
-   BEGIN(new_state);
-}
+	BEGIN(new_state);
+	}
 #endif
 
 
 #ifndef YY_NO_POP_STATE
 static void yy_pop_state()
-{
-   if (--yy_start_stack_ptr < 0)
-      YY_FATAL_ERROR("start-condition stack underflow");
+	{
+	if ( --yy_start_stack_ptr < 0 )
+		YY_FATAL_ERROR( "start-condition stack underflow" );
 
-   BEGIN(yy_start_stack[yy_start_stack_ptr]);
-}
+	BEGIN(yy_start_stack[yy_start_stack_ptr]);
+	}
 #endif
 
 
 #ifndef YY_NO_TOP_STATE
 static int yy_top_state()
-{
-   return yy_start_stack[yy_start_stack_ptr - 1];
-}
+	{
+	return yy_start_stack[yy_start_stack_ptr - 1];
+	}
 #endif
 
 #ifndef YY_EXIT_FAILURE
@@ -2054,15 +2055,15 @@ static int yy_top_state()
 #endif
 
 #ifdef YY_USE_PROTOS
-static void yy_fatal_error(yyconst char msg[])
+static void yy_fatal_error( yyconst char msg[] )
 #else
-static void yy_fatal_error(msg)
+static void yy_fatal_error( msg )
 char msg[];
 #endif
-{
-   (void)fprintf(stderr, "%s\n", msg);
-   exit(YY_EXIT_FAILURE);
-}
+	{
+	(void) fprintf( stderr, "%s\n", msg );
+	exit( YY_EXIT_FAILURE );
+	}
 
 
 
@@ -2086,65 +2087,65 @@ char msg[];
 
 #ifndef yytext_ptr
 #ifdef YY_USE_PROTOS
-static void yy_flex_strncpy(char *s1, yyconst char *s2, int n)
+static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
 #else
-static void yy_flex_strncpy(s1, s2, n)
+static void yy_flex_strncpy( s1, s2, n )
 char *s1;
 yyconst char *s2;
 int n;
 #endif
-{
-   register int i;
-   for (i = 0; i < n; ++i)
-      s1[i] = s2[i];
-}
+	{
+	register int i;
+	for ( i = 0; i < n; ++i )
+		s1[i] = s2[i];
+	}
 #endif
 
 
 #ifdef YY_USE_PROTOS
-static void *yy_flex_alloc(yy_size_t size)
+static void *yy_flex_alloc( yy_size_t size )
 #else
-static void *yy_flex_alloc(size)
+static void *yy_flex_alloc( size )
 yy_size_t size;
 #endif
-{
-   return (void *)malloc(size);
-}
+	{
+	return (void *) malloc( size );
+	}
 
 #ifdef YY_USE_PROTOS
-static void *yy_flex_realloc(void *ptr, yy_size_t size)
+static void *yy_flex_realloc( void *ptr, yy_size_t size )
 #else
-static void *yy_flex_realloc(ptr, size)
+static void *yy_flex_realloc( ptr, size )
 void *ptr;
 yy_size_t size;
 #endif
-{
-   /* The cast to (char *) in the following accommodates both
-   * implementations that use char* generic pointers, and those
-   * that use void* generic pointers.  It works with the latter
-   * because both ANSI C and C++ allow castless assignment from
-   * any pointer type to void*, and deal with argument conversions
-   * as though doing an assignment.
-   */
-   return (void *)realloc((char *)ptr, size);
-}
+	{
+	/* The cast to (char *) in the following accommodates both
+	 * implementations that use char* generic pointers, and those
+	 * that use void* generic pointers.  It works with the latter
+	 * because both ANSI C and C++ allow castless assignment from
+	 * any pointer type to void*, and deal with argument conversions
+	 * as though doing an assignment.
+	 */
+	return (void *) realloc( (char *) ptr, size );
+	}
 
 #ifdef YY_USE_PROTOS
-static void yy_flex_free(void *ptr)
+static void yy_flex_free( void *ptr )
 #else
-static void yy_flex_free(ptr)
+static void yy_flex_free( ptr )
 void *ptr;
 #endif
-{
-   free(ptr);
-}
+	{
+	free( ptr );
+	}
 
 #if YY_MAIN
 int main()
-{
-   yylex();
-   return 0;
-}
+	{
+	yylex();
+	return 0;
+	}
 #endif
 #line 222 "CMDscan.l"
 
@@ -2172,59 +2173,59 @@ void CMDerror(char *format, ...)
    const int BUFMAX = 1024;
    char tempBuf[BUFMAX];
    va_list args;
-   va_start(args, format);
+   va_start( args, format );
 #ifdef TORQUE_OS_WIN
-   _vsnprintf(tempBuf, BUFMAX, format, args);
+   _vsnprintf( tempBuf, BUFMAX, format, args );
 #else
-   vsnprintf(tempBuf, BUFMAX, format, args);
+   vsnprintf( tempBuf, BUFMAX, format, args );
 #endif
-   va_end(args);
+    va_end(args);
 
-   if (fileName)
+   if(fileName)
    {
       Con::errorf(ConsoleLogEntry::Script, "%s Line: %d - %s", fileName, lineIndex, tempBuf);
 
 #ifndef NO_ADVANCED_ERROR_REPORT
       // dhc - lineIndex is bogus.  let's try to add some sanity back in.
-      int i, j, n;
+      int i,j,n;
       char c;
       int linediv = 1;
       // first, walk the buffer, trying to detect line ending type.
       // this is imperfect, if inconsistant line endings exist...
-      for (i = 0; i<scanIndex; i++)
+      for (i=0; i<scanIndex; i++)
       {
          c = scanBuffer[i];
-         if (c == '\r' && scanBuffer[i + 1] == '\n') linediv = 2; // crlf detected
-         if (c == '\r' || c == '\n' || c == 0) break; // enough for us to stop.
+         if (c=='\r' && scanBuffer[i+1]=='\n') linediv = 2; // crlf detected
+         if (c=='\r' || c=='\n' || c==0) break; // enough for us to stop.
       }
       // grab some of the chars starting at the error location - lineending.
       i = 1; j = 0; n = 1;
       // find prev lineending
-      while (n<BUFMAX - 8 && i<scanIndex) // cap at file start
+      while (n<BUFMAX-8 && i<scanIndex) // cap at file start
       {
-         c = scanBuffer[scanIndex - i];
-         if ((c == '\r' || c == '\n') && i>BUFMAX >> 2) break; // at least get a little data
+         c = scanBuffer[scanIndex-i];
+         if ((c=='\r' || c=='\n') && i>BUFMAX>>2) break; // at least get a little data
          n++; i++;
       }
       // find next lineending
-      while (n<BUFMAX - 8 && j<BUFMAX>>1) // cap at half-buf-size forward
+      while (n<BUFMAX-8 && j<BUFMAX>>1) // cap at half-buf-size forward
       {
-         c = scanBuffer[scanIndex + j];
-         if (c == 0) break;
-         if ((c == '\r' || c == '\n') && j>BUFMAX >> 2) break; // at least get a little data
+         c = scanBuffer[scanIndex+j];
+         if (c==0) break;
+         if ((c=='\r' || c=='\n') && j>BUFMAX>>2) break; // at least get a little data
          n++; j++;
       }
       if (i) i--; // chop off extra linefeed.
       if (j) j--; // chop off extra linefeed.
-                  // build our little text block
-      if (i) dStrncpy(tempBuf, scanBuffer + scanIndex - i, i);
-      dStrncpy(tempBuf + i, "##", 2); // bracketing.
-      tempBuf[i + 2] = scanBuffer[scanIndex]; // copy the halt character.
-      dStrncpy(tempBuf + i + 3, "##", 2); // bracketing.
-      if (j) dStrncpy(tempBuf + i + 5, scanBuffer + scanIndex + 1, j); // +1 to go past current char.
-      tempBuf[i + j + 5] = 0; // null terminate
-      for (n = 0; n<i + j + 5; n++) // convert CR to LF if alone...
-         if (tempBuf[n] == '\r' && tempBuf[n + 1] != '\n') tempBuf[n] = '\n';
+      // build our little text block
+      if (i) dStrncpy(tempBuf,scanBuffer+scanIndex-i,i);
+      dStrncpy(tempBuf+i,"##", 2); // bracketing.
+      tempBuf[i+2] = scanBuffer[scanIndex]; // copy the halt character.
+      dStrncpy(tempBuf+i+3,"##", 2); // bracketing.
+      if (j) dStrncpy(tempBuf+i+5,scanBuffer+scanIndex+1,j); // +1 to go past current char.
+      tempBuf[i+j+5] = 0; // null terminate
+      for(n=0; n<i+j+5; n++) // convert CR to LF if alone...
+         if (tempBuf[n]=='\r' && tempBuf[n+1]!='\n') tempBuf[n] = '\n';
       // write out to console the advanced error report
       Con::warnf(ConsoleLogEntry::Script, ">>> Advanced script error report.  Line %d.", lineIndex);
       Con::warnf(ConsoleLogEntry::Script, ">>> Some error context, with ## on sides of error halt:");
@@ -2241,7 +2242,7 @@ void CMDerror(char *format, ...)
       Con::setVariable("$ScriptError", tempBuf);
 
       // We also need to mark that we came up with a new error.
-      static S32 sScriptErrorHash = 1000;
+      static S32 sScriptErrorHash=1000;
       Con::setIntVariable("$ScriptErrorHash", sScriptErrorHash++);
    }
    else
@@ -2259,7 +2260,7 @@ void CMDSetScanBuffer(const char *sb, const char *fn)
 int CMDgetc()
 {
    int ret = scanBuffer[scanIndex];
-   if (ret)
+   if(ret)
       scanIndex++;
    else
       ret = -1;
@@ -2277,13 +2278,13 @@ static int Sc_ScanVar()
    CMDtext[CMDleng] = 0;
 
    // Make it a stringtable string!
-   CMDlval.s = MakeToken< StringTableEntry >(StringTable->insert(CMDtext), lineIndex);
+   CMDlval.s = MakeToken< StringTableEntry >( StringTable->insert(CMDtext), lineIndex );
    return(VAR);
 }
 
 static int charConv(int in)
 {
-   switch (in)
+   switch(in)
    {
       case 'r':
          return '\r';
@@ -2298,11 +2299,11 @@ static int charConv(int in)
 
 static int getHexDigit(char c)
 {
-   if (c >= '0' && c <= '9')
+   if(c >= '0' && c <= '9')
       return c - '0';
-   if (c >= 'A' && c <= 'F')
+   if(c >= 'A' && c <= 'F')
       return c - 'A' + 10;
-   if (c >= 'a' && c <= 'f')
+   if(c >= 'a' && c <= 'f')
       return c - 'a' + 10;
    return -1;
 }
@@ -2310,41 +2311,41 @@ static int getHexDigit(char c)
 static int Sc_ScanDocBlock()
 {
    S32 len = dStrlen(CMDtext);
-   char* text = (char *)consoleAlloc(len + 1);
+   char* text = (char *) consoleAlloc(len + 1);
    S32 line = lineIndex;
 
-   for (S32 i = 0, j = 0; j <= len; j++)
+   for( S32 i = 0, j = 0; j <= len; j++ )
    {
-      if ((j <= (len - 2)) && (CMDtext[j] == '/') && (CMDtext[j + 1] == '/') && (CMDtext[j + 2] == '/'))
+      if( ( j <= (len - 2) ) && ( CMDtext[j] == '/' ) && ( CMDtext[j + 1] == '/' ) && ( CMDtext[j + 2] == '/' ) )
       {
          j += 2;
          continue;
       }
 
-      if (CMDtext[j] == '\r')
+      if( CMDtext[j] == '\r' )
          continue;
 
-      if (CMDtext[j] == '\n')
+      if( CMDtext[j] == '\n' )
          lineIndex++;
 
       text[i++] = CMDtext[j];
    }
 
-   CMDlval.str = MakeToken< char* >(text, line);
+   CMDlval.str = MakeToken< char* >( text, line );
    return(DOCBLOCK);
 }
 
 static int Sc_ScanString(int ret)
 {
    CMDtext[CMDleng - 1] = 0;
-   if (!collapseEscape(CMDtext + 1))
+   if(!collapseEscape(CMDtext+1))
       return -1;
 
-   dsize_t bufferLen = dStrlen(CMDtext);
-   char* buffer = (char*)consoleAlloc(bufferLen);
-   dStrcpy(buffer, CMDtext + 1, bufferLen);
+   dsize_t bufferLen = dStrlen( CMDtext );
+   char* buffer = ( char* ) consoleAlloc( bufferLen );
+   dStrcpy( buffer, CMDtext + 1, bufferLen );
 
-   CMDlval.str = MakeToken< char* >(buffer, lineIndex);
+   CMDlval.str = MakeToken< char* >( buffer, lineIndex );
    return ret;
 }
 
@@ -2354,96 +2355,96 @@ static int Sc_ScanIdent()
 
    CMDtext[CMDleng] = 0;
 
-   if ((type = ConsoleBaseType::getTypeByName(CMDtext)) != NULL)
+   if((type = ConsoleBaseType::getTypeByName(CMDtext)) != NULL)
    {
       /* It's a type */
-      CMDlval.i = MakeToken< int >(type->getTypeID(), lineIndex);
+      CMDlval.i = MakeToken< int >( type->getTypeID(), lineIndex );
       return TYPEIDENT;
    }
 
    /* It's an identifier */
-   CMDlval.s = MakeToken< StringTableEntry >(StringTable->insert(CMDtext), lineIndex);
+   CMDlval.s = MakeToken< StringTableEntry >( StringTable->insert(CMDtext), lineIndex );
    return IDENT;
 }
 
 void expandEscape(char *dest, const char *src)
 {
    U8 c;
-   while ((c = (U8)*src++) != 0)
+   while((c = (U8) *src++) != 0)
    {
-      if (c == '\"')
+      if(c == '\"')
       {
          *dest++ = '\\';
          *dest++ = '\"';
       }
-      else if (c == '\\')
+      else if(c == '\\')
       {
          *dest++ = '\\';
          *dest++ = '\\';
       }
-      else if (c == '\r')
+      else if(c == '\r')
       {
          *dest++ = '\\';
          *dest++ = 'r';
       }
-      else if (c == '\n')
+      else if(c == '\n')
       {
          *dest++ = '\\';
          *dest++ = 'n';
       }
-      else if (c == '\t')
+      else if(c == '\t')
       {
          *dest++ = '\\';
          *dest++ = 't';
       }
-      else if (c == '\'')
+      else if(c == '\'')
       {
          *dest++ = '\\';
          *dest++ = '\'';
       }
-      else if ((c >= 1 && c <= 7) ||
-         (c >= 11 && c <= 12) ||
-         (c >= 14 && c <= 15))
+      else if((c >= 1 && c <= 7) ||
+              (c >= 11 && c <= 12) ||
+              (c >= 14 && c <= 15))
       {
-         /*  Remap around: \b = 0x8, \t = 0x9, \n = 0xa, \r = 0xd */
-         static U8 expandRemap[15] = { 0x0,
-            0x0,
-            0x1,
-            0x2,
-            0x3,
-            0x4,
-            0x5,
-            0x6,
-            0x0,
-            0x0,
-            0x0,
-            0x7,
-            0x8,
-            0x0,
-            0x9 };
+        /*  Remap around: \b = 0x8, \t = 0x9, \n = 0xa, \r = 0xd */
+        static U8 expandRemap[15] = { 0x0,
+                                        0x0,
+                                        0x1,
+                                        0x2,
+                                        0x3,
+                                        0x4,
+                                        0x5,
+                                        0x6,
+                                        0x0,
+                                        0x0,
+                                        0x0,
+                                        0x7,
+                                        0x8,
+                                        0x0,
+                                        0x9 };
 
          *dest++ = '\\';
          *dest++ = 'c';
-         if (c == 15)
+         if(c == 15)
             *dest++ = 'r';
-         else if (c == 16)
+         else if(c == 16)
             *dest++ = 'p';
-         else if (c == 17)
+         else if(c == 17)
             *dest++ = 'o';
          else
             *dest++ = expandRemap[c] + '0';
       }
-      else if (c < 32)
+      else if(c < 32)
       {
          *dest++ = '\\';
          *dest++ = 'x';
          S32 dig1 = c >> 4;
          S32 dig2 = c & 0xf;
-         if (dig1 < 10)
+         if(dig1 < 10)
             dig1 += '0';
          else
             dig1 += 'A' - 10;
-         if (dig2 < 10)
+         if(dig2 < 10)
             dig2 += '0';
          else
             dig2 += 'A' - 10;
@@ -2459,56 +2460,56 @@ void expandEscape(char *dest, const char *src)
 bool collapseEscape(char *buf)
 {
    S32 len = dStrlen(buf) + 1;
-   for (S32 i = 0; i < len;)
+   for(S32 i = 0; i < len;)
    {
-      if (buf[i] == '\\')
+      if(buf[i] == '\\')
       {
-         if (buf[i + 1] == 'x')
+         if(buf[i+1] == 'x')
          {
-            S32 dig1 = getHexDigit(buf[i + 2]);
-            if (dig1 == -1)
+            S32 dig1 = getHexDigit(buf[i+2]);
+            if(dig1 == -1)
                return false;
 
-            S32 dig2 = getHexDigit(buf[i + 3]);
-            if (dig2 == -1)
+            S32 dig2 = getHexDigit(buf[i+3]);
+            if(dig2 == -1)
                return false;
             buf[i] = dig1 * 16 + dig2;
             dMemmove(buf + i + 1, buf + i + 4, len - i - 3);
             len -= 3;
             i++;
          }
-         else if (buf[i + 1] == 'c')
+         else if(buf[i+1] == 'c')
          {
             /*  Remap around: \b = 0x8, \t = 0x9, \n = 0xa, \r = 0xd */
             static U8 collapseRemap[10] = { 0x1,
-               0x2,
-               0x3,
-               0x4,
-               0x5,
-               0x6,
-               0x7,
-               0xb,
-               0xc,
-               0xe };
+                                              0x2,
+                                              0x3,
+                                              0x4,
+                                              0x5,
+                                              0x6,
+                                              0x7,
+                                              0xb,
+                                              0xc,
+                                              0xe };
 
-            if (buf[i + 2] == 'r')
-               buf[i] = 15;
-            else if (buf[i + 2] == 'p')
+            if(buf[i+2] == 'r')
+                buf[i] = 15;
+            else if(buf[i+2] == 'p')
                buf[i] = 16;
-            else if (buf[i + 2] == 'o')
+            else if(buf[i+2] == 'o')
                buf[i] = 17;
             else
             {
-               int dig1 = buf[i + 2] - '0';
-               if (dig1 < 0 || dig1 > 9)
-                  return false;
-               buf[i] = collapseRemap[dig1];
+                int dig1 = buf[i+2] - '0';
+                if(dig1 < 0 || dig1 > 9)
+                   return false;
+                buf[i] = collapseRemap[dig1];
             }
             // Make sure we don't put 0x1 at the beginning of the string.
             if ((buf[i] == 0x1) && (i == 0))
             {
                buf[i] = 0x2;
-               buf[i + 1] = 0x1;
+               buf[i+1] = 0x1;
                dMemmove(buf + i + 2, buf + i + 3, len - i - 1);
                len -= 1;
             }
@@ -2521,7 +2522,7 @@ bool collapseEscape(char *buf)
          }
          else
          {
-            buf[i] = charConv(buf[i + 1]);
+            buf[i] = charConv(buf[i+1]);
             dMemmove(buf + i + 1, buf + i + 2, len - i - 1);
             len--;
             i++;
@@ -2536,7 +2537,7 @@ bool collapseEscape(char *buf)
 static int Sc_ScanNum()
 {
    CMDtext[CMDleng] = 0;
-   CMDlval.f = MakeToken< double >(dAtof(CMDtext), lineIndex);
+   CMDlval.f = MakeToken< double >( dAtof(CMDtext), lineIndex );
    return(FLTCONST);
 }
 
@@ -2544,7 +2545,7 @@ static int Sc_ScanHex()
 {
    S32 val = 0;
    dSscanf(CMDtext, "%x", &val);
-   CMDlval.i = MakeToken< int >(val, lineIndex);
+   CMDlval.i = MakeToken< int >( val, lineIndex );
    return INTCONST;
 }
 
diff --git a/Engine/source/console/cmdgram.cpp b/Engine/source/console/cmdgram.cpp
index b5051786b..aab109792 100644
--- a/Engine/source/console/cmdgram.cpp
+++ b/Engine/source/console/cmdgram.cpp
@@ -1,6 +1,6 @@
 
 /*  A Bison parser, made from cmdgram.y with Bison version GNU Bison version 1.24
-*/
+  */
 
 #define YYBISON 1  /* Identify Bison output.  */
 
@@ -129,13 +129,13 @@ struct Token
 
 #line 44 "cmdgram.y"
 
-/* Reserved Word Definitions */
+        /* Reserved Word Definitions */
 #line 55 "cmdgram.y"
 
-/* Constants and Identifier Definitions */
+        /* Constants and Identifier Definitions */
 #line 69 "cmdgram.y"
 
-/* Operator Definitions */
+        /* Operator Definitions */
 
 #line 82 "cmdgram.y"
 typedef union {
@@ -158,16 +158,16 @@ typedef union {
 
 #ifndef YYLTYPE
 typedef
-struct yyltype
-{
-   int timestamp;
-   int first_line;
-   int first_column;
-   int last_line;
-   int last_column;
-   char *text;
-}
-yyltype;
+  struct yyltype
+    {
+      int timestamp;
+      int first_line;
+      int first_column;
+      int last_line;
+      int last_column;
+      char *text;
+   }
+  yyltype;
 
 #define YYLTYPE yyltype
 #endif
@@ -182,165 +182,164 @@ yyltype;
 
 
 
-#define	YYFINAL		391
+#define	YYFINAL		380
 #define	YYFLAG		-32768
 #define	YYNTBASE	100
 
 #define YYTRANSLATE(x) ((unsigned)(x) <= 329 ? yytranslate[x] : 140)
 
-static const char yytranslate[] = { 0,
-2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-2,     2,    64,     2,     2,     2,    54,    53,     2,    55,
-56,    46,    44,    57,    45,    51,    47,     2,     2,     2,
-2,     2,     2,     2,     2,     2,     2,    58,    59,    48,
-50,    49,    96,    65,     2,     2,     2,     2,     2,     2,
-2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-92,     2,    99,    62,     2,     2,     2,     2,     2,     2,
-2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-2,     2,    60,    52,    61,    63,     2,     2,     2,     2,
-2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-2,     2,     2,     2,     2,     1,     2,     3,     4,     5,
-6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
-16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
-36,    37,    38,    39,    40,    41,    42,    43,    66,    67,
-68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
-78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
-88,    89,    90,    91,    93,    94,    95,    97,    98
+static const char yytranslate[] = {     0,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,    64,     2,     2,     2,    54,    53,     2,    55,
+    56,    46,    44,    57,    45,    51,    47,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,    58,    59,    48,
+    50,    49,    96,    65,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+    92,     2,    99,    62,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,    60,    52,    61,    63,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     1,     2,     3,     4,     5,
+     6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+    16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+    26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
+    36,    37,    38,    39,    40,    41,    42,    43,    66,    67,
+    68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
+    78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
+    88,    89,    90,    91,    93,    94,    95,    97,    98
 };
 
 #if YYDEBUG != 0
-static const short yyprhs[] = { 0,
-0,     2,     3,     6,     8,    10,    12,    19,    21,    24,
-25,    28,    30,    32,    34,    36,    38,    40,    43,    46,
-49,    53,    56,    61,    68,    70,    79,    90,    91,    93,
-95,    99,   110,   121,   129,   142,   152,   163,   171,   172,
-175,   176,   178,   179,   182,   183,   185,   187,   190,   193,
-197,   201,   203,   211,   219,   224,   232,   238,   240,   244,
-250,   258,   264,   271,   281,   290,   299,   307,   316,   324,
-332,   339,   347,   355,   357,   359,   363,   367,   371,   375,
-379,   383,   387,   391,   395,   398,   401,   403,   409,   413,
-417,   421,   425,   429,   433,   437,   441,   445,   449,   453,
-457,   461,   464,   467,   469,   471,   473,   475,   477,   479,
-481,   483,   485,   490,   498,   502,   509,   513,   517,   519,
-523,   525,   527,   530,   533,   536,   539,   542,   545,   548,
-551,   554,   557,   559,   561,   563,   567,   574,   577,   583,
-586,   590,   596,   601,   608,   615,   620,   625,   632,   633,
-635,   637,   641,   642,   644,   646,   649,   654,   660,   665,
-673,   682,   684
+static const short yyprhs[] = {     0,
+     0,     2,     3,     6,     8,    10,    12,    19,    21,    24,
+    25,    28,    30,    32,    34,    36,    38,    40,    43,    46,
+    49,    53,    56,    61,    68,    70,    79,    90,    91,    93,
+    95,    99,   110,   121,   129,   142,   152,   163,   171,   172,
+   175,   176,   178,   179,   182,   183,   185,   187,   190,   193,
+   197,   201,   203,   211,   219,   224,   232,   238,   240,   244,
+   250,   258,   264,   271,   281,   290,   299,   307,   316,   324,
+   332,   339,   347,   355,   357,   359,   363,   367,   371,   375,
+   379,   383,   387,   391,   395,   398,   401,   403,   409,   413,
+   417,   421,   425,   429,   433,   437,   441,   445,   449,   453,
+   457,   461,   464,   467,   469,   471,   473,   475,   477,   479,
+   481,   483,   485,   490,   494,   501,   505,   509,   511,   515,
+   517,   519,   522,   525,   528,   531,   534,   537,   540,   543,
+   546,   549,   551,   553,   555,   559,   566,   569,   575,   578,
+   582,   588,   593,   600,   607,   612,   619,   620,   622,   624,
+   628,   629,   631,   633,   636,   641,   647,   652,   660,   669,
+   671
 };
 
-static const short yyrhs[] = { 101,
-0,     0,   101,   102,     0,   106,     0,   107,     0,   103,
-0,    29,    38,    60,   104,    61,    59,     0,   107,     0,
-104,   107,     0,     0,   105,   106,     0,   121,     0,   122,
-0,   123,     0,   124,     0,   110,     0,   118,     0,     7,
-59,     0,     9,    59,     0,    13,    59,     0,    13,   126,
-59,     0,   125,    59,     0,    36,    50,   126,    59,     0,
-36,    50,   126,    57,   126,    59,     0,    40,     0,     3,
-38,    55,   108,    56,    60,   105,    61,     0,     3,    38,
-91,    38,    55,   108,    56,    60,   105,    61,     0,     0,
-109,     0,    37,     0,   109,    57,    37,     0,    24,   129,
-55,   126,   112,    56,    60,   136,    61,    59,     0,     5,
-129,    55,   113,   112,   114,    56,    60,   115,    61,     0,
-5,   129,    55,   113,   112,   114,    56,     0,     5,   129,
-55,    92,   113,    99,   112,   114,    56,    60,   115,    61,
-0,     5,   129,    55,    92,   113,    99,   112,   114,    56,
-0,     6,   129,    55,   113,   112,   114,    56,    60,   115,
-61,     0,     6,   129,    55,   113,   112,   114,    56,     0,
-0,    58,    38,     0,     0,   126,     0,     0,    57,   135,
-0,     0,   137,     0,   116,     0,   137,   116,     0,   111,
-59,     0,   116,   111,    59,     0,    60,   105,    61,     0,
-106,     0,    25,    55,   126,    56,    60,   119,    61,     0,
-27,    55,   126,    56,    60,   119,    61,     0,    26,   120,
-58,   105,     0,    26,   120,    58,   105,    19,    58,   105,
-0,    26,   120,    58,   105,   119,     0,   126,     0,   120,
-28,   126,     0,    11,    55,   126,    56,   117,     0,    11,
-55,   126,    56,   117,     8,   117,     0,    14,    55,   126,
-56,   117,     0,    15,   117,    14,    55,   126,    56,     0,
-20,    55,   126,    59,   126,    59,   126,    56,   117,     0,
-20,    55,   126,    59,   126,    59,    56,   117,     0,    20,
-55,   126,    59,    59,   126,    56,   117,     0,    20,    55,
-126,    59,    59,    56,   117,     0,    20,    55,    59,   126,
-59,   126,    56,   117,     0,    20,    55,    59,   126,    59,
-56,   117,     0,    20,    55,    59,    59,   126,    56,   117,
-0,    20,    55,    59,    59,    56,   117,     0,    21,    55,
-37,    23,   126,    56,   117,     0,    22,    55,    37,    23,
-126,    56,   117,     0,   131,     0,   131,     0,    55,   126,
-56,     0,   126,    62,   126,     0,   126,    54,   126,     0,
-126,    53,   126,     0,   126,    52,   126,     0,   126,    44,
-126,     0,   126,    45,   126,     0,   126,    46,   126,     0,
-126,    47,   126,     0,    45,   126,     0,    46,   126,     0,
-36,     0,   126,    96,   126,    58,   126,     0,   126,    48,
-126,     0,   126,    49,   126,     0,   126,    86,   126,     0,
-126,    87,   126,     0,   126,    84,   126,     0,   126,    85,
-126,     0,   126,    89,   126,     0,   126,    71,   126,     0,
-126,    72,   126,     0,   126,    88,   126,     0,   126,    90,
-126,     0,   126,    97,   126,     0,   126,    65,   126,     0,
-64,   126,     0,    63,   126,     0,    42,     0,    43,     0,
-35,     0,     7,     0,   127,     0,   128,     0,    38,     0,
-41,     0,    37,     0,    37,    92,   139,    99,     0,     3,
-55,   108,    56,    60,   105,    61,     0,   126,    51,    38,
-0,   126,    51,    38,    92,   139,    99,     0,   126,    66,
-129,     0,   126,    67,   129,     0,    38,     0,    55,   126,
-56,     0,    69,     0,    68,     0,    73,   126,     0,    74,
-126,     0,    75,   126,     0,    76,   126,     0,    77,   126,
-0,    78,   126,     0,    79,   126,     0,    80,   126,     0,
-81,   126,     0,    82,   126,     0,   132,     0,   133,     0,
-111,     0,    37,    50,   126,     0,    37,    92,   139,    99,
-50,   126,     0,    37,   130,     0,    37,    92,   139,    99,
-130,     0,   127,   130,     0,   127,    50,   126,     0,   127,
-50,    60,   135,    61,     0,    38,    55,   134,    56,     0,
-38,    91,    38,    55,   134,    56,     0,   126,    51,    38,
-55,   134,    56,     0,   126,    55,   134,    56,     0,    32,
-55,   126,    56,     0,    32,    55,   126,    57,    41,    56,
-0,     0,   135,     0,   126,     0,   135,    57,   126,     0,
-0,   137,     0,   138,     0,   137,   138,     0,    38,    50,
-126,    59,     0,    39,    38,    50,   126,    59,     0,    24,
-50,   126,    59,     0,    38,    92,   139,    99,    50,   126,
-59,     0,    39,    38,    92,   139,    99,    50,   126,    59,
-0,   126,     0,   139,    57,   126,     0
+static const short yyrhs[] = {   101,
+     0,     0,   101,   102,     0,   106,     0,   107,     0,   103,
+     0,    29,    38,    60,   104,    61,    59,     0,   107,     0,
+   104,   107,     0,     0,   105,   106,     0,   121,     0,   122,
+     0,   123,     0,   124,     0,   110,     0,   118,     0,     7,
+    59,     0,     9,    59,     0,    13,    59,     0,    13,   126,
+    59,     0,   125,    59,     0,    36,    50,   126,    59,     0,
+    36,    50,   126,    57,   126,    59,     0,    40,     0,     3,
+    38,    55,   108,    56,    60,   105,    61,     0,     3,    38,
+    91,    38,    55,   108,    56,    60,   105,    61,     0,     0,
+   109,     0,    37,     0,   109,    57,    37,     0,    24,   129,
+    55,   126,   112,    56,    60,   136,    61,    59,     0,     5,
+   129,    55,   113,   112,   114,    56,    60,   115,    61,     0,
+     5,   129,    55,   113,   112,   114,    56,     0,     5,   129,
+    55,    92,   113,    99,   112,   114,    56,    60,   115,    61,
+     0,     5,   129,    55,    92,   113,    99,   112,   114,    56,
+     0,     6,   129,    55,   113,   112,   114,    56,    60,   115,
+    61,     0,     6,   129,    55,   113,   112,   114,    56,     0,
+     0,    58,    38,     0,     0,   126,     0,     0,    57,   135,
+     0,     0,   137,     0,   116,     0,   137,   116,     0,   111,
+    59,     0,   116,   111,    59,     0,    60,   105,    61,     0,
+   106,     0,    25,    55,   126,    56,    60,   119,    61,     0,
+    27,    55,   126,    56,    60,   119,    61,     0,    26,   120,
+    58,   105,     0,    26,   120,    58,   105,    19,    58,   105,
+     0,    26,   120,    58,   105,   119,     0,   126,     0,   120,
+    28,   126,     0,    11,    55,   126,    56,   117,     0,    11,
+    55,   126,    56,   117,     8,   117,     0,    14,    55,   126,
+    56,   117,     0,    15,   117,    14,    55,   126,    56,     0,
+    20,    55,   126,    59,   126,    59,   126,    56,   117,     0,
+    20,    55,   126,    59,   126,    59,    56,   117,     0,    20,
+    55,   126,    59,    59,   126,    56,   117,     0,    20,    55,
+   126,    59,    59,    56,   117,     0,    20,    55,    59,   126,
+    59,   126,    56,   117,     0,    20,    55,    59,   126,    59,
+    56,   117,     0,    20,    55,    59,    59,   126,    56,   117,
+     0,    20,    55,    59,    59,    56,   117,     0,    21,    55,
+    37,    23,   126,    56,   117,     0,    22,    55,    37,    23,
+   126,    56,   117,     0,   131,     0,   131,     0,    55,   126,
+    56,     0,   126,    62,   126,     0,   126,    54,   126,     0,
+   126,    53,   126,     0,   126,    52,   126,     0,   126,    44,
+   126,     0,   126,    45,   126,     0,   126,    46,   126,     0,
+   126,    47,   126,     0,    45,   126,     0,    46,   126,     0,
+    36,     0,   126,    96,   126,    58,   126,     0,   126,    48,
+   126,     0,   126,    49,   126,     0,   126,    86,   126,     0,
+   126,    87,   126,     0,   126,    84,   126,     0,   126,    85,
+   126,     0,   126,    89,   126,     0,   126,    71,   126,     0,
+   126,    72,   126,     0,   126,    88,   126,     0,   126,    90,
+   126,     0,   126,    97,   126,     0,   126,    65,   126,     0,
+    64,   126,     0,    63,   126,     0,    42,     0,    43,     0,
+    35,     0,     7,     0,   127,     0,   128,     0,    38,     0,
+    41,     0,    37,     0,    37,    92,   139,    99,     0,   126,
+    51,    38,     0,   126,    51,    38,    92,   139,    99,     0,
+   126,    66,   129,     0,   126,    67,   129,     0,    38,     0,
+    55,   126,    56,     0,    69,     0,    68,     0,    73,   126,
+     0,    74,   126,     0,    75,   126,     0,    76,   126,     0,
+    77,   126,     0,    78,   126,     0,    79,   126,     0,    80,
+   126,     0,    81,   126,     0,    82,   126,     0,   132,     0,
+   133,     0,   111,     0,    37,    50,   126,     0,    37,    92,
+   139,    99,    50,   126,     0,    37,   130,     0,    37,    92,
+   139,    99,   130,     0,   127,   130,     0,   127,    50,   126,
+     0,   127,    50,    60,   135,    61,     0,    38,    55,   134,
+    56,     0,    38,    91,    38,    55,   134,    56,     0,   126,
+    51,    38,    55,   134,    56,     0,    32,    55,   126,    56,
+     0,    32,    55,   126,    57,    41,    56,     0,     0,   135,
+     0,   126,     0,   135,    57,   126,     0,     0,   137,     0,
+   138,     0,   137,   138,     0,    38,    50,   126,    59,     0,
+    39,    38,    50,   126,    59,     0,    24,    50,   126,    59,
+     0,    38,    92,   139,    99,    50,   126,    59,     0,    39,
+    38,    92,   139,    99,    50,   126,    59,     0,   126,     0,
+   139,    57,   126,     0
 };
 
 #endif
 
 #if YYDEBUG != 0
 static const short yyrline[] = { 0,
-161,   166,   168,   173,   175,   177,   182,   187,   189,   194,
-196,   201,   202,   203,   204,   205,   206,   207,   209,   211,
-213,   215,   217,   219,   221,   226,   228,   233,   235,   240,
-242,   247,   252,   254,   256,   258,   260,   262,   267,   269,
-274,   276,   281,   283,   288,   290,   292,   294,   299,   301,
-306,   308,   313,   315,   320,   322,   324,   329,   331,   336,
-338,   343,   345,   350,   352,   354,   356,   358,   360,   362,
-364,   369,   371,   376,   381,   383,   385,   387,   389,   391,
-393,   395,   397,   399,   401,   403,   405,   407,   409,   411,
-413,   415,   417,   419,   421,   423,   425,   427,   429,   431,
-433,   435,   437,   439,   441,   443,   445,   447,   449,   451,
-453,   455,   457,   459,   477,   479,   484,   486,   491,   493,
-498,   500,   502,   504,   506,   508,   510,   512,   514,   516,
-518,   520,   525,   527,   529,   531,   533,   535,   537,   539,
-541,   543,   548,   550,   552,   554,   559,   561,   566,   568,
-573,   575,   580,   582,   587,   589,   594,   596,   598,   600,
-602,   607,   609
+   161,   166,   168,   173,   175,   177,   182,   187,   189,   194,
+   196,   201,   202,   203,   204,   205,   206,   207,   209,   211,
+   213,   215,   217,   219,   221,   226,   228,   233,   235,   240,
+   242,   247,   252,   254,   256,   258,   260,   262,   267,   269,
+   274,   276,   281,   283,   288,   290,   292,   294,   299,   301,
+   306,   308,   313,   315,   320,   322,   324,   329,   331,   336,
+   338,   343,   345,   350,   352,   354,   356,   358,   360,   362,
+   364,   369,   371,   376,   381,   383,   385,   387,   389,   391,
+   393,   395,   397,   399,   401,   403,   405,   407,   409,   411,
+   413,   415,   417,   419,   421,   423,   425,   427,   429,   431,
+   433,   435,   437,   439,   441,   443,   445,   447,   449,   451,
+   453,   455,   457,   479,   481,   486,   488,   493,   495,   500,
+   502,   504,   506,   508,   510,   512,   514,   516,   518,   520,
+   522,   527,   529,   531,   533,   535,   537,   539,   541,   543,
+   545,   550,   552,   554,   564,   566,   571,   573,   578,   580,
+   585,   587,   592,   594,   599,   601,   603,   605,   607,   612,
+   614
 };
 
-static const char * const yytname[] = { "$","error","$undefined.","rwDEFINE",
+static const char * const yytname[] = {   "$","error","$undefined.","rwDEFINE",
 "rwENDDEF","rwDECLARE","rwDECLARESINGLETON","rwBREAK","rwELSE","rwCONTINUE",
 "rwGLOBAL","rwIF","rwNIL","rwRETURN","rwWHILE","rwDO","rwENDIF","rwENDWHILE",
 "rwENDFOR","rwDEFAULT","rwFOR","rwFOREACH","rwFOREACHSTR","rwIN","rwDATABLOCK",
@@ -363,805 +362,747 @@ static const char * const yytname[] = { "$","error","$undefined.","rwDEFINE",
 };
 #endif
 
-static const short yyr1[] = { 0,
-100,   101,   101,   102,   102,   102,   103,   104,   104,   105,
-105,   106,   106,   106,   106,   106,   106,   106,   106,   106,
-106,   106,   106,   106,   106,   107,   107,   108,   108,   109,
-109,   110,   111,   111,   111,   111,   111,   111,   112,   112,
-113,   113,   114,   114,   115,   115,   115,   115,   116,   116,
-117,   117,   118,   118,   119,   119,   119,   120,   120,   121,
-121,   122,   122,   123,   123,   123,   123,   123,   123,   123,
-123,   124,   124,   125,   126,   126,   126,   126,   126,   126,
-126,   126,   126,   126,   126,   126,   126,   126,   126,   126,
-126,   126,   126,   126,   126,   126,   126,   126,   126,   126,
-126,   126,   126,   126,   126,   126,   126,   126,   126,   126,
-126,   126,   126,   126,   127,   127,   128,   128,   129,   129,
-130,   130,   130,   130,   130,   130,   130,   130,   130,   130,
-130,   130,   131,   131,   131,   131,   131,   131,   131,   131,
-131,   131,   132,   132,   132,   132,   133,   133,   134,   134,
-135,   135,   136,   136,   137,   137,   138,   138,   138,   138,
-138,   139,   139
+static const short yyr1[] = {     0,
+   100,   101,   101,   102,   102,   102,   103,   104,   104,   105,
+   105,   106,   106,   106,   106,   106,   106,   106,   106,   106,
+   106,   106,   106,   106,   106,   107,   107,   108,   108,   109,
+   109,   110,   111,   111,   111,   111,   111,   111,   112,   112,
+   113,   113,   114,   114,   115,   115,   115,   115,   116,   116,
+   117,   117,   118,   118,   119,   119,   119,   120,   120,   121,
+   121,   122,   122,   123,   123,   123,   123,   123,   123,   123,
+   123,   124,   124,   125,   126,   126,   126,   126,   126,   126,
+   126,   126,   126,   126,   126,   126,   126,   126,   126,   126,
+   126,   126,   126,   126,   126,   126,   126,   126,   126,   126,
+   126,   126,   126,   126,   126,   126,   126,   126,   126,   126,
+   126,   126,   126,   127,   127,   128,   128,   129,   129,   130,
+   130,   130,   130,   130,   130,   130,   130,   130,   130,   130,
+   130,   131,   131,   131,   131,   131,   131,   131,   131,   131,
+   131,   132,   132,   132,   133,   133,   134,   134,   135,   135,
+   136,   136,   137,   137,   138,   138,   138,   138,   138,   139,
+   139
 };
 
-static const short yyr2[] = { 0,
-1,     0,     2,     1,     1,     1,     6,     1,     2,     0,
-2,     1,     1,     1,     1,     1,     1,     2,     2,     2,
-3,     2,     4,     6,     1,     8,    10,     0,     1,     1,
-3,    10,    10,     7,    12,     9,    10,     7,     0,     2,
-0,     1,     0,     2,     0,     1,     1,     2,     2,     3,
-3,     1,     7,     7,     4,     7,     5,     1,     3,     5,
-7,     5,     6,     9,     8,     8,     7,     8,     7,     7,
-6,     7,     7,     1,     1,     3,     3,     3,     3,     3,
-3,     3,     3,     3,     2,     2,     1,     5,     3,     3,
-3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
-3,     2,     2,     1,     1,     1,     1,     1,     1,     1,
-1,     1,     4,     7,     3,     6,     3,     3,     1,     3,
-1,     1,     2,     2,     2,     2,     2,     2,     2,     2,
-2,     2,     1,     1,     1,     3,     6,     2,     5,     2,
-3,     5,     4,     6,     6,     4,     4,     6,     0,     1,
-1,     3,     0,     1,     1,     2,     4,     5,     4,     7,
-8,     1,     3
+static const short yyr2[] = {     0,
+     1,     0,     2,     1,     1,     1,     6,     1,     2,     0,
+     2,     1,     1,     1,     1,     1,     1,     2,     2,     2,
+     3,     2,     4,     6,     1,     8,    10,     0,     1,     1,
+     3,    10,    10,     7,    12,     9,    10,     7,     0,     2,
+     0,     1,     0,     2,     0,     1,     1,     2,     2,     3,
+     3,     1,     7,     7,     4,     7,     5,     1,     3,     5,
+     7,     5,     6,     9,     8,     8,     7,     8,     7,     7,
+     6,     7,     7,     1,     1,     3,     3,     3,     3,     3,
+     3,     3,     3,     3,     2,     2,     1,     5,     3,     3,
+     3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
+     3,     2,     2,     1,     1,     1,     1,     1,     1,     1,
+     1,     1,     4,     3,     6,     3,     3,     1,     3,     1,
+     1,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     1,     1,     1,     3,     6,     2,     5,     2,     3,
+     5,     4,     6,     6,     4,     6,     0,     1,     1,     3,
+     0,     1,     1,     2,     4,     5,     4,     7,     8,     1,
+     3
 };
 
-static const short yydefact[] = { 2,
-1,     0,     0,     0,   107,     0,     0,     0,     0,     0,
-0,     0,     0,     0,     0,     0,     0,     0,   106,    87,
-112,   110,    25,   111,   104,   105,     0,     0,     0,     0,
-0,     3,     6,     4,     5,    16,   135,    17,    12,    13,
-14,    15,     0,     0,   108,   109,    75,   133,   134,     0,
-28,   119,     0,     0,     0,    18,    19,     0,     0,   107,
-87,    20,     0,    75,     0,    10,    52,     0,     0,     0,
-0,     0,     0,     0,     0,     0,     0,     0,   122,   121,
-0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-0,   138,   149,     0,    85,    86,     0,   103,   102,    22,
-0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-149,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-0,     0,     0,     0,     0,     0,     0,   140,    28,     0,
-30,     0,    29,     0,    41,    41,     0,    21,     0,     0,
-0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-0,   136,   123,   124,   125,   126,   127,   128,   129,   130,
-131,   132,   162,     0,   151,     0,   150,     0,    76,    81,
-82,    83,    84,    89,    90,   115,    80,    79,    78,     0,
-77,   101,   117,   118,    96,    97,    93,    94,    91,    92,
-98,    95,    99,     0,   100,     0,   141,     0,     0,     0,
-0,   120,    41,    39,    42,    39,     0,     0,    51,    11,
-0,     0,     0,     0,     0,     0,    39,     0,     0,     0,
-0,     8,   147,     0,     0,    23,     0,   113,   143,     0,
-149,   149,     0,   146,     0,     0,     0,    28,    10,    31,
-0,     0,    43,    43,    60,    62,     0,     0,     0,     0,
-0,     0,     0,     0,     0,     0,     0,     0,     9,     0,
-0,   163,     0,   139,   152,     0,     0,     0,    88,   142,
-10,     0,     0,    39,    40,     0,     0,     0,     0,    63,
-71,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-0,     0,     0,     7,   148,    24,   137,   144,   145,   116,
-0,     0,   114,    43,    44,    34,    38,    61,    70,    69,
-0,    67,     0,     0,     0,    72,    73,   153,     0,    58,
-53,    54,    26,    10,     0,    45,    45,    68,    66,    65,
-0,     0,     0,     0,     0,   154,   155,     0,    10,     0,
-36,     0,     0,    47,    46,     0,    64,     0,     0,     0,
-0,     0,   156,    59,    55,    27,    45,    49,    33,     0,
-48,    37,     0,     0,     0,     0,     0,    32,     0,    57,
-0,    50,   159,   157,     0,     0,     0,    10,    35,     0,
-158,     0,    56,     0,     0,   160,     0,   161,     0,     0,
-0
+static const short yydefact[] = {     2,
+     1,     0,     0,     0,   107,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,   106,    87,
+   112,   110,    25,   111,   104,   105,     0,     0,     0,     0,
+     0,     3,     6,     4,     5,    16,   134,    17,    12,    13,
+    14,    15,     0,     0,   108,   109,    75,   132,   133,     0,
+   118,     0,     0,     0,    18,    19,     0,   107,    87,    20,
+     0,    75,     0,    10,    52,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,   121,   120,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,   137,
+   147,     0,    85,    86,     0,   103,   102,    22,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,   139,    28,     0,     0,    41,    41,
+     0,    21,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,   135,   122,   123,   124,   125,
+   126,   127,   128,   129,   130,   131,   160,     0,   149,     0,
+   148,     0,    76,    81,    82,    83,    84,    89,    90,   114,
+    80,    79,    78,    77,   101,   116,   117,    96,    97,    93,
+    94,    91,    92,    98,    95,    99,     0,   100,     0,   140,
+    30,     0,    29,     0,   119,    41,    39,    42,    39,     0,
+     0,    51,    11,     0,     0,     0,     0,     0,     0,    39,
+     0,     0,     0,     8,   145,     0,     0,    23,     0,   113,
+   142,     0,   147,   147,     0,     0,     0,     0,     0,    28,
+     0,     0,    43,    43,    60,    62,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     9,     0,
+     0,   161,     0,   138,   150,     0,     0,     0,    88,   141,
+    10,    31,     0,    39,    40,     0,     0,     0,     0,    63,
+    71,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     7,   146,    24,   136,   143,   144,   115,
+     0,     0,    43,    44,    34,    38,    61,    70,    69,     0,
+    67,     0,     0,     0,    72,    73,   151,     0,    58,    53,
+    54,    26,    10,     0,    45,    45,    68,    66,    65,     0,
+     0,     0,     0,     0,   152,   153,     0,    10,     0,    36,
+     0,     0,    47,    46,     0,    64,     0,     0,     0,     0,
+     0,   154,    59,    55,    27,    45,    49,    33,     0,    48,
+    37,     0,     0,     0,     0,     0,    32,     0,    57,     0,
+    50,   157,   155,     0,     0,     0,    10,    35,     0,   156,
+     0,    56,     0,     0,   158,     0,   159,     0,     0,     0
 };
 
-static const short yydefgoto[] = { 389,
-1,    32,    33,   221,   140,    67,    35,   132,   133,    36,
-37,   243,   204,   277,   343,   344,    68,    38,   292,   319,
-39,    40,    41,    42,    43,    44,    45,    46,    54,    92,
-64,    48,    49,   166,   167,   335,   345,   337,   164
+static const short yydefgoto[] = {   378,
+     1,    32,    33,   213,   134,    65,    35,   192,   193,    36,
+    37,   233,   197,   267,   332,   333,    66,    38,   282,   308,
+    39,    40,    41,    42,    43,    44,    45,    46,    53,    90,
+    62,    48,    49,   160,   161,   324,   334,   326,   158
 };
 
-static const short yypact[] = { -32768,
-213,    -7,    55,    55,   -37,   -25,   -18,   490,   -13,   422,
-5,    14,    41,    55,    47,    49,     9,    51,-32768,    57,
-566,   -23,-32768,-32768,-32768,-32768,  1187,  1187,  1187,  1187,
-1187,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
--32768,-32768,    -5,  2650,  3021,-32768,    35,-32768,-32768,   -12,
-62,-32768,  1187,    67,    68,-32768,-32768,  1187,    69,-32768,
--32768,-32768,  1300,-32768,  1187,-32768,-32768,   103,   835,    88,
-89,    77,  1187,  1187,    73,  1187,  1187,  1187,-32768,-32768,
-1187,  1187,  1187,  1187,  1187,  1187,  1187,  1187,  1187,  1187,
-1187,-32768,  1187,    96,   219,   219,  1354,   219,   219,-32768,
-1187,  1187,  1187,  1187,  1187,  1187,    97,  1187,  1187,  1187,
-1187,  1187,  1187,    55,    55,  1187,  1187,  1187,  1187,  1187,
-1187,  1187,  1187,  1187,  1187,  1187,   879,-32768,    62,    98,
--32768,    81,    91,  1408,    21,  1187,  1462,-32768,  1516,   556,
-95,   923,  1570,   123,   131,  1187,  1624,  1678,   152,  1192,
-1246,  2650,  2650,  2650,  2650,  2650,  2650,  2650,  2650,  2650,
-2650,  2650,  2650,   -38,  2650,   100,   104,   111,-32768,   145,
-145,   219,   219,  3015,  3015,   -40,  2845,  2939,   219,   112,
-2892,   143,-32768,-32768,   277,   277,  2986,  2986,  3015,  3015,
-2798,  2751,   143,  1732,   143,  1187,  2650,   113,   116,   107,
-135,-32768,  1187,   119,  2650,   119,   422,   422,-32768,-32768,
-1187,   967,  1786,  1011,  1187,  1187,  1840,   122,   126,   157,
-13,-32768,-32768,   162,  1187,-32768,  1187,  3041,-32768,  1187,
-1187,  1187,  1187,-32768,  1187,    44,   144,    62,-32768,-32768,
-106,   170,   156,   156,   209,-32768,  1894,   422,  1948,  1055,
-1099,  2002,  2056,  2110,   165,   197,   197,   166,-32768,   173,
-2164,  2650,  1187,-32768,  2650,   174,   175,   -28,  2704,-32768,
--32768,   176,   656,   119,-32768,  1187,   180,   183,   422,-32768,
--32768,   422,   422,  2218,   422,  2272,  1143,   422,   422,   181,
-1187,   182,   185,-32768,-32768,-32768,  2650,-32768,-32768,-32768,
-701,   184,-32768,   156,   104,   192,   200,-32768,-32768,-32768,
-422,-32768,   422,   422,  2326,-32768,-32768,    76,    12,  2650,
--32768,-32768,-32768,-32768,   201,    92,    92,-32768,-32768,-32768,
-422,   211,   -20,   224,   202,    76,-32768,  1187,-32768,   746,
-204,   206,   205,    39,    92,   208,-32768,  1187,  1187,  1187,
--17,   212,-32768,  2650,   138,-32768,    92,-32768,-32768,   216,
-39,-32768,  2380,  2434,   -21,  1187,  1187,-32768,   221,-32768,
-222,-32768,-32768,-32768,   217,  2488,    -8,-32768,-32768,  1187,
--32768,   230,   791,  2542,  1187,-32768,  2596,-32768,   289,   290,
--32768
+static const short yypact[] = {-32768,
+   396,   -30,    -7,    -7,    -5,    29,   -39,   166,   -29,   488,
+   -26,    37,    40,    -7,    46,    74,    97,    82,-32768,    94,
+   -36,   -28,-32768,-32768,-32768,-32768,  1001,  1001,  1001,  1001,
+  1001,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
+-32768,-32768,    92,  2464,  2726,-32768,   105,-32768,-32768,   -27,
+-32768,  1001,   110,   111,-32768,-32768,  1001,-32768,-32768,-32768,
+  1114,-32768,  1001,-32768,-32768,   156,   707,   137,   139,   123,
+  1001,  1001,   120,  1001,  1001,  1001,-32768,-32768,  1001,  1001,
+  1001,  1001,  1001,  1001,  1001,  1001,  1001,  1001,  1001,-32768,
+  1001,   143,    27,    27,  1168,    27,    27,-32768,  1001,  1001,
+  1001,  1001,  1001,  1001,   144,  1001,  1001,  1001,  1001,  1001,
+    -7,    -7,  1001,  1001,  1001,  1001,  1001,  1001,  1001,  1001,
+  1001,  1001,  1001,   749,-32768,   146,   147,  1222,    44,  1001,
+  1276,-32768,  1330,   548,   129,   791,  1384,   163,   167,  1001,
+  1438,  1492,   186,  1006,  1060,  2464,  2464,  2464,  2464,  2464,
+  2464,  2464,  2464,  2464,  2464,  2464,  2464,   -47,  2464,   135,
+   136,   140,-32768,   713,   713,    27,    27,  2721,  2721,   -33,
+  2605,  2663,    27,  2634,  2785,-32768,-32768,   291,   291,  2692,
+  2692,  2721,  2721,  2576,  2547,  2785,  1546,  2785,  1001,  2464,
+-32768,   138,   153,   141,-32768,  1001,   134,  2464,   134,   488,
+   488,-32768,-32768,  1001,   318,  1600,   833,  1001,  1001,  1654,
+   154,   155,    14,-32768,-32768,   172,  1001,-32768,  1001,  2746,
+-32768,  1001,  1001,  1001,  1001,  1001,    48,   157,   160,   146,
+   117,   185,   169,   169,   216,-32768,  1708,   488,  1762,   875,
+   917,  1816,  1870,  1924,   171,   207,   207,   175,-32768,   180,
+  1978,  2464,  1001,-32768,  2464,   183,   184,   -46,  2518,-32768,
+-32768,-32768,   189,   134,-32768,  1001,   193,   194,   488,-32768,
+-32768,   488,   488,  2032,   488,  2086,   959,   488,   488,   181,
+  1001,   190,   196,-32768,-32768,-32768,  2464,-32768,-32768,-32768,
+   593,   182,   169,   136,   195,   199,-32768,-32768,-32768,   488,
+-32768,   488,   488,  2140,-32768,-32768,    59,    -3,  2464,-32768,
+-32768,-32768,-32768,   198,   214,   214,-32768,-32768,-32768,   488,
+   210,   -35,   228,   206,    59,-32768,  1001,-32768,   638,   213,
+   211,   215,    98,   214,   220,-32768,  1001,  1001,  1001,   -32,
+   223,-32768,  2464,   443,-32768,   214,-32768,-32768,   224,    98,
+-32768,  2194,  2248,   -38,  1001,  1001,-32768,   217,-32768,   225,
+-32768,-32768,-32768,   234,  2302,   -37,-32768,-32768,  1001,-32768,
+   235,   683,  2356,  1001,-32768,  2410,-32768,   287,   288,-32768
 };
 
-static const short yypgoto[] = { -32768,
--32768,-32768,-32768,-32768,  -236,     0,  -132,  -118,-32768,-32768,
--306,  -192,  -113,  -231,  -262,   -54,  -202,-32768,  -247,-32768,
--32768,-32768,-32768,-32768,-32768,   288,-32768,-32768,     4,   -43,
--1,-32768,-32768,  -104,  -184,-32768,   -26,  -295,  -229
+static const short yypgoto[] = {-32768,
+-32768,-32768,-32768,-32768,  -255,     0,  -139,    63,-32768,-32768,
+  -128,  -187,  -125,  -221,  -281,   -45,    31,-32768,  -244,-32768,
+-32768,-32768,-32768,-32768,-32768,    39,-32768,-32768,    20,   -43,
+    -1,-32768,-32768,  -107,  -182,-32768,   -13,  -304,  -189
 };
 
 
-#define	YYLAST		3123
+#define	YYLAST		2857
 
 
-static const short yytable[] = { 47,
-34,   128,   273,   268,   245,   246,   180,    55,    47,   293,
-198,   236,   278,   244,   232,   220,   222,    72,   227,   342,
-342,    56,   206,    59,   255,     3,     4,    60,   227,   349,
-50,    93,   366,    57,   301,   227,    58,   360,   342,   338,
-353,    65,   129,     3,     4,   281,    75,    51,   227,   353,
-342,   233,    18,   100,   360,    19,    61,    21,    22,    69,
-228,    24,    25,    26,   346,    27,    28,    94,    70,   339,
-300,   350,   325,   258,   367,    29,   308,   375,   130,   309,
-310,   304,   312,    30,    31,   316,   317,   340,   259,   241,
-382,   305,    52,   -74,   371,    71,     3,     4,   131,   332,
-230,    73,   355,    74,   270,    76,    77,   370,   328,    53,
-329,   330,   203,   333,   334,   332,   141,   183,   184,   272,
-365,   135,   136,    51,   144,   145,   266,   267,   347,   333,
-334,   146,   149,   168,   176,   199,   200,   377,    47,   210,
-59,   383,     3,     4,     5,   215,     6,   201,     7,   211,
-8,     9,    10,   216,   220,   229,   369,    11,    12,    13,
-230,    14,    15,   291,    16,   231,   239,   234,   237,    18,
-238,   240,    19,    20,    21,    22,   242,    23,    24,    25,
-26,   256,    27,    28,   264,   257,   101,   102,   103,   104,
-103,   104,    29,   107,    50,   107,   110,   111,   110,   111,
-30,    31,   260,   271,   274,    47,    47,   275,   114,   115,
-114,   115,   276,   116,   117,     2,   279,     3,     4,     5,
-290,     6,   291,     7,   294,     8,     9,    10,   295,   298,
-299,   302,    11,    12,    13,   306,    14,    15,   307,    16,
-318,    17,   321,   324,    18,   322,    47,    19,    20,    21,
-22,   326,    23,    24,    25,    26,   341,    27,    28,   327,
-348,   351,   352,   357,   358,   359,   380,    29,   362,   107,
-368,    47,   210,   111,   372,    30,    31,    47,   378,   385,
-47,    47,   379,    47,   114,   115,    47,    47,   390,   391,
-361,   336,     0,     0,     0,    63,     0,     0,     0,    47,
-210,     0,     0,     0,     0,     0,     0,     0,     0,    47,
-0,    47,    47,     0,    95,    96,    97,    98,    99,     0,
-101,   102,   103,   104,     0,     0,     0,   107,     0,    47,
-110,   111,     0,     0,     0,     0,     0,     0,    47,   210,
-134,     0,   114,   115,     0,   137,     0,     0,     0,     0,
-0,     0,   139,    47,   210,     0,   143,     0,     0,     0,
-147,   148,     0,   150,   151,   152,     0,     0,   153,   154,
-155,   156,   157,   158,   159,   160,   161,   162,   163,     0,
-165,    47,   210,     0,     0,     0,     0,     0,   170,   171,
-172,   173,   174,   175,     0,   177,   178,   179,   165,   181,
-182,     0,     0,   185,   186,   187,   188,   189,   190,   191,
-192,   193,   194,   195,   197,     0,     0,     0,     0,     0,
-0,     0,   205,   205,    59,     0,     3,     4,     5,   213,
-6,     0,     7,   217,     8,     9,    10,     0,     0,     0,
-0,    11,    12,    13,     0,    14,    15,     0,    16,     0,
-0,     0,     0,    18,     0,     0,    19,    20,    21,    22,
-0,    23,    24,    25,    26,     0,    27,    28,     0,     0,
-0,     0,     0,     0,     0,     0,    29,     0,     0,     0,
-0,    66,     0,   165,    30,    31,     0,     0,     0,     0,
-205,     0,    59,     0,     3,     4,    60,     0,   247,   249,
-0,   252,   253,   254,     0,     0,     0,     0,     0,     0,
-0,     0,   261,     0,   262,     0,     0,   265,   165,   165,
-163,    18,   269,     0,    19,    61,    21,    22,     0,     0,
-24,    25,    26,     0,    27,    28,     0,   284,   286,     0,
-0,     0,     0,     0,    29,     0,     0,     0,    62,     0,
-297,     0,    30,    31,     0,     0,     0,     0,    59,     0,
-3,     4,     5,   165,     6,     0,     7,     0,     8,     9,
-10,     0,     0,     0,   315,    11,    12,    13,   320,    14,
-15,     0,    16,     0,     0,     0,     0,    18,     0,     0,
-19,    20,    21,    22,     0,    23,    24,    25,    26,     0,
-27,    28,     0,     0,     0,     0,     0,     0,     0,     0,
-29,     0,     0,     0,     0,    78,   209,     0,    30,    31,
-0,     0,     0,     0,     0,   354,     0,     0,     0,     0,
-0,     0,     0,    79,    80,   363,   364,   163,    81,    82,
-83,    84,    85,    86,    87,    88,    89,    90,     0,     0,
-0,     0,     0,   376,   163,     0,     0,    91,    59,     0,
-3,     4,     5,     0,     6,     0,     7,   384,     8,     9,
-10,     0,   387,     0,     0,    11,    12,    13,     0,    14,
-15,     0,    16,     0,     0,     0,     0,    18,     0,     0,
-19,    20,    21,    22,     0,    23,    24,    25,    26,     0,
-27,    28,     0,    59,     0,     3,     4,     5,     0,     6,
-29,     7,     0,     8,     9,    10,   303,     0,    30,    31,
-11,    12,    13,     0,    14,    15,     0,    16,     0,     0,
-0,     0,    18,     0,     0,    19,    20,    21,    22,     0,
-23,    24,    25,    26,     0,    27,    28,     0,    59,     0,
-3,     4,     5,     0,     6,    29,     7,     0,     8,     9,
-10,   323,     0,    30,    31,    11,    12,    13,     0,    14,
-15,     0,    16,     0,     0,     0,     0,    18,     0,     0,
-19,    20,    21,    22,     0,    23,    24,    25,    26,     0,
-27,    28,     0,    59,     0,     3,     4,     5,     0,     6,
-29,     7,     0,     8,     9,    10,   356,     0,    30,    31,
-11,    12,    13,     0,    14,    15,     0,    16,     0,     0,
-0,     0,    18,     0,     0,    19,    20,    21,    22,     0,
-23,    24,    25,    26,     0,    27,    28,    59,     0,     3,
-4,    60,     0,     0,     0,    29,     0,     0,     0,     0,
-0,     0,     0,    30,    31,     0,     0,     0,     0,     0,
-0,     0,     0,     0,     0,     0,    18,     0,     0,    19,
-61,    21,    22,     0,     0,    24,    25,    26,     0,    27,
-28,    59,     0,     3,     4,    60,     0,     0,     0,    29,
-0,     0,     0,   142,     0,     0,     0,    30,    31,     0,
-0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-18,     0,     0,    19,    61,    21,    22,     0,     0,    24,
-25,    26,     0,    27,    28,    59,     0,     3,     4,    60,
-0,     0,     0,    29,     0,     0,     0,     0,   196,     0,
-0,    30,    31,     0,     0,     0,     0,     0,     0,     0,
-0,     0,     0,     0,    18,     0,     0,    19,    61,    21,
-22,     0,     0,    24,    25,    26,     0,    27,    28,    59,
-0,     3,     4,    60,     0,     0,     0,    29,     0,     0,
-0,   212,     0,     0,     0,    30,    31,     0,     0,     0,
-0,     0,     0,     0,     0,     0,     0,     0,    18,     0,
-0,    19,    61,    21,    22,     0,     0,    24,    25,    26,
-0,    27,    28,    59,     0,     3,     4,    60,     0,     0,
-0,    29,   248,     0,     0,     0,     0,     0,     0,    30,
-31,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-0,     0,    18,     0,     0,    19,    61,    21,    22,     0,
-0,    24,    25,    26,     0,    27,    28,    59,     0,     3,
-4,    60,     0,     0,     0,    29,     0,     0,     0,   251,
-0,     0,     0,    30,    31,     0,     0,     0,     0,     0,
-0,     0,     0,     0,     0,     0,    18,     0,     0,    19,
-61,    21,    22,     0,     0,    24,    25,    26,     0,    27,
-28,    59,     0,     3,     4,    60,     0,     0,     0,    29,
-283,     0,     0,     0,     0,     0,     0,    30,    31,     0,
-0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-18,     0,     0,    19,    61,    21,    22,     0,     0,    24,
-25,    26,     0,    27,    28,    59,     0,     3,     4,    60,
-0,     0,     0,    29,   285,     0,     0,     0,     0,     0,
-0,    30,    31,     0,     0,     0,     0,     0,     0,     0,
-0,     0,     0,     0,    18,     0,     0,    19,    61,    21,
-22,     0,     0,    24,    25,    26,     0,    27,    28,    59,
-0,     3,     4,    60,     0,     0,     0,    29,   314,     0,
-0,     0,     0,     0,     0,    30,    31,     0,     0,     0,
-0,     0,     0,     0,     0,     0,     0,     0,    18,     0,
-0,    19,    61,    21,    22,     0,     0,    24,    25,    26,
-0,    27,    28,     0,     0,   101,   102,   103,   104,   105,
-106,    29,   107,   108,   109,   110,   111,   223,   224,    30,
-31,     0,     0,   112,     0,     0,   113,   114,   115,     0,
-0,     0,   116,   117,     0,     0,     0,     0,     0,     0,
-0,     0,     0,     0,     0,   118,   119,   120,   121,   122,
-123,   124,     0,     0,     0,     0,     0,   125,   126,   101,
-102,   103,   104,   105,   106,     0,   107,   108,   109,   110,
-111,     0,   225,     0,   226,     0,     0,   112,     0,     0,
-113,   114,   115,     0,     0,     0,   116,   117,     0,     0,
-0,     0,     0,     0,     0,     0,     0,     0,     0,   118,
-119,   120,   121,   122,   123,   124,     0,     0,     0,     0,
-0,   125,   126,   101,   102,   103,   104,   105,   106,     0,
-107,   108,   109,   110,   111,     0,     0,     0,   138,     0,
-0,   112,     0,     0,   113,   114,   115,     0,     0,     0,
-116,   117,     0,     0,     0,     0,     0,     0,     0,     0,
-0,     0,     0,   118,   119,   120,   121,   122,   123,   124,
-0,     0,     0,     0,     0,   125,   126,   101,   102,   103,
-104,   105,   106,     0,   107,   108,   109,   110,   111,   169,
-0,     0,     0,     0,     0,   112,     0,     0,   113,   114,
-115,     0,     0,     0,   116,   117,     0,     0,     0,     0,
-0,     0,     0,     0,     0,     0,     0,   118,   119,   120,
-121,   122,   123,   124,     0,     0,     0,     0,     0,   125,
-126,   101,   102,   103,   104,   105,   106,     0,   107,   108,
-109,   110,   111,   202,     0,     0,     0,     0,     0,   112,
-0,     0,   113,   114,   115,     0,     0,     0,   116,   117,
-0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-0,   118,   119,   120,   121,   122,   123,   124,     0,     0,
-0,     0,     0,   125,   126,   101,   102,   103,   104,   105,
-106,     0,   107,   108,   109,   110,   111,   207,     0,     0,
-0,     0,     0,   112,     0,     0,   113,   114,   115,     0,
-0,     0,   116,   117,     0,     0,     0,     0,     0,     0,
-0,     0,     0,     0,     0,   118,   119,   120,   121,   122,
-123,   124,     0,     0,     0,     0,     0,   125,   126,   101,
-102,   103,   104,   105,   106,     0,   107,   108,   109,   110,
-111,   208,     0,     0,     0,     0,     0,   112,     0,     0,
-113,   114,   115,     0,     0,     0,   116,   117,     0,     0,
-0,     0,     0,     0,     0,     0,     0,     0,     0,   118,
-119,   120,   121,   122,   123,   124,     0,     0,     0,     0,
-0,   125,   126,   101,   102,   103,   104,   105,   106,     0,
-107,   108,   109,   110,   111,     0,     0,     0,   214,     0,
-0,   112,     0,     0,   113,   114,   115,     0,     0,     0,
-116,   117,     0,     0,     0,     0,     0,     0,     0,     0,
-0,     0,     0,   118,   119,   120,   121,   122,   123,   124,
-0,     0,     0,     0,     0,   125,   126,   101,   102,   103,
-104,   105,   106,     0,   107,   108,   109,   110,   111,   218,
-0,     0,     0,     0,     0,   112,     0,     0,   113,   114,
-115,     0,     0,     0,   116,   117,     0,     0,     0,     0,
-0,     0,     0,     0,     0,     0,     0,   118,   119,   120,
-121,   122,   123,   124,     0,     0,     0,     0,     0,   125,
-126,   101,   102,   103,   104,   105,   106,     0,   107,   108,
-109,   110,   111,   219,     0,     0,     0,     0,     0,   112,
-0,     0,   113,   114,   115,     0,     0,     0,   116,   117,
-0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-0,   118,   119,   120,   121,   122,   123,   124,     0,     0,
-0,     0,     0,   125,   126,   101,   102,   103,   104,   105,
-106,     0,   107,   108,   109,   110,   111,     0,     0,   235,
-0,     0,     0,   112,     0,     0,   113,   114,   115,     0,
-0,     0,   116,   117,     0,     0,     0,     0,     0,     0,
-0,     0,     0,     0,     0,   118,   119,   120,   121,   122,
-123,   124,     0,     0,     0,     0,     0,   125,   126,   101,
-102,   103,   104,   105,   106,     0,   107,   108,   109,   110,
-111,     0,     0,     0,   250,     0,     0,   112,     0,     0,
-113,   114,   115,     0,     0,     0,   116,   117,     0,     0,
-0,     0,     0,     0,     0,     0,     0,     0,     0,   118,
-119,   120,   121,   122,   123,   124,     0,     0,     0,     0,
-0,   125,   126,   101,   102,   103,   104,   105,   106,     0,
-107,   108,   109,   110,   111,     0,     0,   242,     0,     0,
-0,   112,     0,     0,   113,   114,   115,     0,     0,     0,
-116,   117,     0,     0,     0,     0,     0,     0,     0,     0,
-0,     0,     0,   118,   119,   120,   121,   122,   123,   124,
-0,     0,     0,     0,     0,   125,   126,   101,   102,   103,
-104,   105,   106,     0,   107,   108,   109,   110,   111,   280,
-0,     0,     0,     0,     0,   112,     0,     0,   113,   114,
-115,     0,     0,     0,   116,   117,     0,     0,     0,     0,
-0,     0,     0,     0,     0,     0,     0,   118,   119,   120,
-121,   122,   123,   124,     0,     0,     0,     0,     0,   125,
-126,   101,   102,   103,   104,   105,   106,     0,   107,   108,
-109,   110,   111,   282,     0,     0,     0,     0,     0,   112,
-0,     0,   113,   114,   115,     0,     0,     0,   116,   117,
-0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-0,   118,   119,   120,   121,   122,   123,   124,     0,     0,
-0,     0,     0,   125,   126,   101,   102,   103,   104,   105,
-106,     0,   107,   108,   109,   110,   111,     0,     0,     0,
-287,     0,     0,   112,     0,     0,   113,   114,   115,     0,
-0,     0,   116,   117,     0,     0,     0,     0,     0,     0,
-0,     0,     0,     0,     0,   118,   119,   120,   121,   122,
-123,   124,     0,     0,     0,     0,     0,   125,   126,   101,
-102,   103,   104,   105,   106,     0,   107,   108,   109,   110,
-111,   288,     0,     0,     0,     0,     0,   112,     0,     0,
-113,   114,   115,     0,     0,     0,   116,   117,     0,     0,
-0,     0,     0,     0,     0,     0,     0,     0,     0,   118,
-119,   120,   121,   122,   123,   124,     0,     0,     0,     0,
-0,   125,   126,   101,   102,   103,   104,   105,   106,     0,
-107,   108,   109,   110,   111,   289,     0,     0,     0,     0,
-0,   112,     0,     0,   113,   114,   115,     0,     0,     0,
-116,   117,     0,     0,     0,     0,     0,     0,     0,     0,
-0,     0,     0,   118,   119,   120,   121,   122,   123,   124,
-0,     0,     0,     0,     0,   125,   126,   101,   102,   103,
-104,   105,   106,     0,   107,   108,   109,   110,   111,     0,
-0,     0,   296,     0,     0,   112,     0,     0,   113,   114,
-115,     0,     0,     0,   116,   117,     0,     0,     0,     0,
-0,     0,     0,     0,     0,     0,     0,   118,   119,   120,
-121,   122,   123,   124,     0,     0,     0,     0,     0,   125,
-126,   101,   102,   103,   104,   105,   106,     0,   107,   108,
-109,   110,   111,   311,     0,     0,     0,     0,     0,   112,
-0,     0,   113,   114,   115,     0,     0,     0,   116,   117,
-0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-0,   118,   119,   120,   121,   122,   123,   124,     0,     0,
-0,     0,     0,   125,   126,   101,   102,   103,   104,   105,
-106,     0,   107,   108,   109,   110,   111,   313,     0,     0,
-0,     0,     0,   112,     0,     0,   113,   114,   115,     0,
-0,     0,   116,   117,     0,     0,     0,     0,     0,     0,
-0,     0,     0,     0,     0,   118,   119,   120,   121,   122,
-123,   124,     0,     0,     0,     0,     0,   125,   126,   101,
-102,   103,   104,   105,   106,     0,   107,   108,   109,   110,
-111,   331,     0,     0,     0,     0,     0,   112,     0,     0,
-113,   114,   115,     0,     0,     0,   116,   117,     0,     0,
-0,     0,     0,     0,     0,     0,     0,     0,     0,   118,
-119,   120,   121,   122,   123,   124,     0,     0,     0,     0,
-0,   125,   126,   101,   102,   103,   104,   105,   106,     0,
-107,   108,   109,   110,   111,     0,     0,     0,   373,     0,
-0,   112,     0,     0,   113,   114,   115,     0,     0,     0,
-116,   117,     0,     0,     0,     0,     0,     0,     0,     0,
-0,     0,     0,   118,   119,   120,   121,   122,   123,   124,
-0,     0,     0,     0,     0,   125,   126,   101,   102,   103,
-104,   105,   106,     0,   107,   108,   109,   110,   111,     0,
-0,     0,   374,     0,     0,   112,     0,     0,   113,   114,
-115,     0,     0,     0,   116,   117,     0,     0,     0,     0,
-0,     0,     0,     0,     0,     0,     0,   118,   119,   120,
-121,   122,   123,   124,     0,     0,     0,     0,     0,   125,
-126,   101,   102,   103,   104,   105,   106,     0,   107,   108,
-109,   110,   111,     0,     0,     0,   381,     0,     0,   112,
-0,     0,   113,   114,   115,     0,     0,     0,   116,   117,
-0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-0,   118,   119,   120,   121,   122,   123,   124,     0,     0,
-0,     0,     0,   125,   126,   101,   102,   103,   104,   105,
-106,     0,   107,   108,   109,   110,   111,     0,     0,     0,
-386,     0,     0,   112,     0,     0,   113,   114,   115,     0,
-0,     0,   116,   117,     0,     0,     0,     0,     0,     0,
-0,     0,     0,     0,     0,   118,   119,   120,   121,   122,
-123,   124,     0,     0,     0,     0,     0,   125,   126,   101,
-102,   103,   104,   105,   106,     0,   107,   108,   109,   110,
-111,     0,     0,     0,   388,     0,     0,   112,     0,     0,
-113,   114,   115,     0,     0,     0,   116,   117,     0,     0,
-0,     0,     0,     0,     0,     0,     0,     0,     0,   118,
-119,   120,   121,   122,   123,   124,     0,     0,     0,     0,
-0,   125,   126,   101,   102,   103,   104,   105,   106,     0,
-107,   108,   109,   110,   111,     0,     0,     0,     0,     0,
-0,   112,     0,     0,   113,   114,   115,     0,     0,     0,
-116,   117,     0,     0,     0,     0,     0,     0,     0,     0,
-0,     0,     0,   118,   119,   120,   121,   122,   123,   124,
-0,     0,     0,     0,     0,   125,   126,   101,   102,   103,
-104,   105,   106,     0,   107,   108,   109,   110,   111,     0,
-0,     0,     0,     0,     0,   112,     0,     0,   113,   114,
-115,     0,     0,     0,   116,   117,     0,     0,     0,     0,
-0,     0,     0,     0,     0,     0,     0,   118,   119,   120,
-121,   122,   123,   124,   101,   102,   103,   104,   105,   106,
-126,   107,   108,   109,   110,   111,     0,     0,     0,     0,
-0,     0,   112,     0,     0,   113,   114,   115,     0,     0,
-0,   116,   117,     0,     0,     0,     0,     0,     0,     0,
-0,     0,     0,     0,   118,   119,   120,   121,   122,     0,
-124,   101,   102,   103,   104,   105,   106,   126,   107,   108,
-109,   110,   111,     0,     0,     0,     0,     0,     0,   112,
-0,     0,   113,   114,   115,     0,     0,     0,   116,   117,
-0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-0,   118,   119,   120,   121,     0,     0,   124,   101,   102,
-103,   104,   105,   106,   126,   107,     0,   109,   110,   111,
-0,     0,     0,     0,     0,     0,   112,     0,     0,   113,
-114,   115,     0,     0,     0,   116,   117,     0,     0,     0,
-0,     0,     0,     0,     0,     0,     0,     0,   118,   119,
-120,   121,     0,     0,   124,   101,   102,   103,   104,   105,
-106,   126,   107,     0,   109,   110,   111,     0,     0,     0,
-0,     0,     0,     0,     0,     0,   113,   114,   115,     0,
-0,     0,   116,   117,     0,     0,     0,     0,     0,     0,
-0,     0,     0,     0,     0,   118,   119,   120,   121,     0,
-0,   124,   101,   102,   103,   104,   105,   106,   126,   107,
-0,     0,   110,   111,     0,     0,     0,     0,     0,     0,
-0,     0,     0,   113,   114,   115,     0,     0,     0,   116,
-117,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-0,     0,   118,   119,   120,   121,     0,     0,   124,   101,
-102,   103,   104,   105,   106,   126,   107,     0,     0,   110,
-111,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-113,   114,   115,     0,     0,     0,   116,   117,   101,   102,
-103,   104,     0,     0,     0,   107,     0,     0,   110,   111,
-127,   120,   121,     0,     0,   124,     0,     0,     0,   113,
-114,   115,   126,     0,     0,   116,   117,     0,    79,    80,
-263,     0,     0,    81,    82,    83,    84,    85,    86,    87,
-88,    89,    90,     0,   124,     0,     0,     0,    79,    80,
-0,   126,     0,    81,    82,    83,    84,    85,    86,    87,
-88,    89,    90
+static const short yytable[] = {    47,
+    34,   125,   283,   214,   199,   291,   227,    50,    47,   219,
+   219,   234,   268,    76,   338,    57,     2,   355,   219,   219,
+   342,   224,   245,    54,   327,    63,    91,   126,    67,   342,
+    51,    77,    78,    70,   335,   258,    79,    80,    81,    82,
+    83,    84,    85,    86,    87,    88,    61,    52,     3,     4,
+    58,   220,   290,    55,   328,    89,   339,   329,   225,   356,
+   364,   371,    92,   127,   360,    93,    94,    95,    96,    97,
+   231,   314,   344,   249,   248,    18,   293,   105,    19,    59,
+    21,    22,   321,   294,    24,    25,    26,    56,    27,    28,
+   128,    68,   111,   112,    69,   131,   322,   323,    29,   359,
+    71,   133,     3,     4,   222,   137,    30,    31,   260,   141,
+   142,   372,   144,   145,   146,   256,   257,   147,   148,   149,
+   150,   151,   152,   153,   154,   155,   156,   157,    72,   159,
+   176,   177,    47,   203,    73,   196,    74,   164,   165,   166,
+   167,   168,   169,    75,   171,   172,   173,   174,   175,   354,
+    98,   178,   179,   180,   181,   182,   183,   184,   185,   186,
+   187,   188,   190,   -74,   129,   130,   366,   198,   198,   135,
+     3,     4,    58,   138,   206,   139,   254,   140,   210,   143,
+   162,   170,   191,   204,   194,   208,   331,   331,     2,   209,
+   221,   232,   222,   228,   223,   230,   262,    18,    47,    47,
+    19,    59,    21,    22,   349,   331,    24,    25,    26,   229,
+    27,    28,   250,   246,   247,   264,   261,   331,     3,     4,
+    29,   349,   265,   269,    60,   266,   280,   159,    30,    31,
+   235,   236,   281,   284,   198,   285,    47,   321,   288,   289,
+   307,   313,   237,   239,   292,   242,   243,   244,   295,   296,
+   310,   322,   323,   330,   315,   251,   311,   252,   316,   337,
+   255,   159,   159,   157,   259,   340,   341,    47,   271,   347,
+    47,    47,   346,    47,   367,   348,    47,    47,   274,   276,
+   351,   357,   361,   369,   374,   368,   379,   380,   350,    47,
+   203,   287,   263,   325,     0,     0,     0,     0,    47,   297,
+    47,    47,   298,   299,   159,   301,     0,     0,   305,   306,
+     0,     0,     0,     0,     0,   304,     0,     0,    47,   309,
+     0,     0,     3,     4,    58,     0,     0,    47,   203,     0,
+   317,     0,   318,   319,    99,   100,   101,   102,     0,     0,
+     0,   105,    47,   203,   108,     0,     0,     0,     0,    18,
+   336,     0,    19,    59,    21,    22,   111,   112,    24,    25,
+    26,     0,    27,    28,     0,   343,     0,     0,     0,     0,
+    47,   203,    29,   238,     0,   352,   353,   157,     0,     0,
+    30,    31,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,   365,   157,     0,     0,     0,     2,     0,
+     3,     4,     5,     0,     6,     0,     7,   373,     8,     9,
+    10,     0,   376,     0,     0,    11,    12,    13,     0,    14,
+    15,     0,    16,     0,    17,     0,     0,    18,     0,     0,
+    19,    20,    21,    22,     0,    23,    24,    25,    26,     0,
+    27,    28,     0,     0,     0,     0,     0,     3,     4,     5,
+    29,     6,     0,     7,     0,     8,     9,    10,    30,    31,
+     0,   358,    11,    12,    13,     0,    14,    15,   281,    16,
+     0,     0,     0,     0,    18,     0,     0,    19,    20,    21,
+    22,     0,    23,    24,    25,    26,     0,    27,    28,     0,
+     0,     0,     3,     4,     5,     0,     6,    29,     7,     0,
+     8,     9,    10,     0,     0,    30,    31,    11,    12,    13,
+     0,    14,    15,     0,    16,     0,     0,     0,     0,    18,
+     0,     0,    19,    20,    21,    22,     0,    23,    24,    25,
+    26,     0,    27,    28,     0,     0,     0,     0,     0,     0,
+     0,     0,    29,     0,     0,     0,     0,    64,     0,     0,
+    30,    31,     3,     4,     5,     0,     6,     0,     7,     0,
+     8,     9,    10,     0,     0,     0,     0,    11,    12,    13,
+     0,    14,    15,     0,    16,     0,     0,     0,     0,    18,
+     0,     0,    19,    20,    21,    22,     0,    23,    24,    25,
+    26,     0,    27,    28,     0,     0,     0,     3,     4,     5,
+     0,     6,    29,     7,     0,     8,     9,    10,   202,     0,
+    30,    31,    11,    12,    13,     0,    14,    15,     0,    16,
+     0,     0,     0,     0,    18,     0,     0,    19,    20,    21,
+    22,     0,    23,    24,    25,    26,     0,    27,    28,     0,
+     0,     0,     3,     4,     5,     0,     6,    29,     7,     0,
+     8,     9,    10,   312,     0,    30,    31,    11,    12,    13,
+     0,    14,    15,     0,    16,     0,     0,     0,     0,    18,
+     0,     0,    19,    20,    21,    22,     0,    23,    24,    25,
+    26,     0,    27,    28,     0,     0,     0,     3,     4,     5,
+     0,     6,    29,     7,     0,     8,     9,    10,   345,     0,
+    30,    31,    11,    12,    13,     0,    14,    15,     0,    16,
+     0,     3,     4,    58,    18,     0,     0,    19,    20,    21,
+    22,     0,    23,    24,    25,    26,     0,    27,    28,     0,
+     0,     0,     0,     0,     0,     0,     0,    29,    18,     0,
+     0,    19,    59,    21,    22,    30,    31,    24,    25,    26,
+     0,    27,    28,     3,     4,    58,     0,     0,   101,   102,
+     0,    29,     0,   105,     0,   136,   108,     0,     0,    30,
+    31,     0,     0,     0,     0,     0,     0,     0,   111,   112,
+    18,     0,     0,    19,    59,    21,    22,     0,     0,    24,
+    25,    26,     0,    27,    28,     3,     4,    58,     0,     0,
+     0,     0,     0,    29,     0,     0,     0,     0,   189,     0,
+     0,    30,    31,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,    18,     0,     0,    19,    59,    21,    22,     0,
+     0,    24,    25,    26,     0,    27,    28,     3,     4,    58,
+     0,     0,     0,     0,     0,    29,     0,     0,     0,   205,
+     0,     0,     0,    30,    31,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,    18,     0,     0,    19,    59,    21,
+    22,     0,     0,    24,    25,    26,     0,    27,    28,     3,
+     4,    58,     0,     0,     0,     0,     0,    29,     0,     0,
+     0,   241,     0,     0,     0,    30,    31,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,    18,     0,     0,    19,
+    59,    21,    22,     0,     0,    24,    25,    26,     0,    27,
+    28,     3,     4,    58,     0,     0,     0,     0,     0,    29,
+   273,     0,     0,     0,     0,     0,     0,    30,    31,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,    18,     0,
+     0,    19,    59,    21,    22,     0,     0,    24,    25,    26,
+     0,    27,    28,     3,     4,    58,     0,     0,     0,     0,
+     0,    29,   275,     0,     0,     0,     0,     0,     0,    30,
+    31,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    18,     0,     0,    19,    59,    21,    22,     0,     0,    24,
+    25,    26,     0,    27,    28,     3,     4,    58,     0,     0,
+     0,     0,     0,    29,   303,     0,     0,     0,     0,     0,
+     0,    30,    31,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,    18,     0,     0,    19,    59,    21,    22,     0,
+     0,    24,    25,    26,     0,    27,    28,     0,     0,    99,
+   100,   101,   102,   103,   104,    29,   105,   106,   107,   108,
+     0,   215,   216,    30,    31,     0,     0,   109,     0,     0,
+   110,   111,   112,     0,     0,     0,   113,   114,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,   115,
+   116,   117,   118,   119,   120,   121,     0,     0,     0,     0,
+     0,   122,   123,    99,   100,   101,   102,   103,   104,     0,
+   105,   106,   107,   108,     0,     0,   217,     0,   218,     0,
+     0,   109,     0,     0,   110,   111,   112,     0,     0,     0,
+   113,   114,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,   115,   116,   117,   118,   119,   120,   121,
+     0,     0,     0,     0,     0,   122,   123,    99,   100,   101,
+   102,   103,   104,     0,   105,   106,   107,   108,     0,     0,
+     0,     0,   132,     0,     0,   109,     0,     0,   110,   111,
+   112,     0,     0,     0,   113,   114,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,   115,   116,   117,
+   118,   119,   120,   121,     0,     0,     0,     0,     0,   122,
+   123,    99,   100,   101,   102,   103,   104,     0,   105,   106,
+   107,   108,     0,   163,     0,     0,     0,     0,     0,   109,
+     0,     0,   110,   111,   112,     0,     0,     0,   113,   114,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,   115,   116,   117,   118,   119,   120,   121,     0,     0,
+     0,     0,     0,   122,   123,    99,   100,   101,   102,   103,
+   104,     0,   105,   106,   107,   108,     0,   195,     0,     0,
+     0,     0,     0,   109,     0,     0,   110,   111,   112,     0,
+     0,     0,   113,   114,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,   115,   116,   117,   118,   119,
+   120,   121,     0,     0,     0,     0,     0,   122,   123,    99,
+   100,   101,   102,   103,   104,     0,   105,   106,   107,   108,
+     0,   200,     0,     0,     0,     0,     0,   109,     0,     0,
+   110,   111,   112,     0,     0,     0,   113,   114,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,   115,
+   116,   117,   118,   119,   120,   121,     0,     0,     0,     0,
+     0,   122,   123,    99,   100,   101,   102,   103,   104,     0,
+   105,   106,   107,   108,     0,   201,     0,     0,     0,     0,
+     0,   109,     0,     0,   110,   111,   112,     0,     0,     0,
+   113,   114,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,   115,   116,   117,   118,   119,   120,   121,
+     0,     0,     0,     0,     0,   122,   123,    99,   100,   101,
+   102,   103,   104,     0,   105,   106,   107,   108,     0,     0,
+     0,     0,   207,     0,     0,   109,     0,     0,   110,   111,
+   112,     0,     0,     0,   113,   114,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,   115,   116,   117,
+   118,   119,   120,   121,     0,     0,     0,     0,     0,   122,
+   123,    99,   100,   101,   102,   103,   104,     0,   105,   106,
+   107,   108,     0,   211,     0,     0,     0,     0,     0,   109,
+     0,     0,   110,   111,   112,     0,     0,     0,   113,   114,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,   115,   116,   117,   118,   119,   120,   121,     0,     0,
+     0,     0,     0,   122,   123,    99,   100,   101,   102,   103,
+   104,     0,   105,   106,   107,   108,     0,   212,     0,     0,
+     0,     0,     0,   109,     0,     0,   110,   111,   112,     0,
+     0,     0,   113,   114,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,   115,   116,   117,   118,   119,
+   120,   121,     0,     0,     0,     0,     0,   122,   123,    99,
+   100,   101,   102,   103,   104,     0,   105,   106,   107,   108,
+     0,     0,     0,   226,     0,     0,     0,   109,     0,     0,
+   110,   111,   112,     0,     0,     0,   113,   114,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,   115,
+   116,   117,   118,   119,   120,   121,     0,     0,     0,     0,
+     0,   122,   123,    99,   100,   101,   102,   103,   104,     0,
+   105,   106,   107,   108,     0,     0,     0,     0,   240,     0,
+     0,   109,     0,     0,   110,   111,   112,     0,     0,     0,
+   113,   114,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,   115,   116,   117,   118,   119,   120,   121,
+     0,     0,     0,     0,     0,   122,   123,    99,   100,   101,
+   102,   103,   104,     0,   105,   106,   107,   108,     0,     0,
+     0,   232,     0,     0,     0,   109,     0,     0,   110,   111,
+   112,     0,     0,     0,   113,   114,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,   115,   116,   117,
+   118,   119,   120,   121,     0,     0,     0,     0,     0,   122,
+   123,    99,   100,   101,   102,   103,   104,     0,   105,   106,
+   107,   108,     0,   270,     0,     0,     0,     0,     0,   109,
+     0,     0,   110,   111,   112,     0,     0,     0,   113,   114,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,   115,   116,   117,   118,   119,   120,   121,     0,     0,
+     0,     0,     0,   122,   123,    99,   100,   101,   102,   103,
+   104,     0,   105,   106,   107,   108,     0,   272,     0,     0,
+     0,     0,     0,   109,     0,     0,   110,   111,   112,     0,
+     0,     0,   113,   114,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,   115,   116,   117,   118,   119,
+   120,   121,     0,     0,     0,     0,     0,   122,   123,    99,
+   100,   101,   102,   103,   104,     0,   105,   106,   107,   108,
+     0,     0,     0,     0,   277,     0,     0,   109,     0,     0,
+   110,   111,   112,     0,     0,     0,   113,   114,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,   115,
+   116,   117,   118,   119,   120,   121,     0,     0,     0,     0,
+     0,   122,   123,    99,   100,   101,   102,   103,   104,     0,
+   105,   106,   107,   108,     0,   278,     0,     0,     0,     0,
+     0,   109,     0,     0,   110,   111,   112,     0,     0,     0,
+   113,   114,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,   115,   116,   117,   118,   119,   120,   121,
+     0,     0,     0,     0,     0,   122,   123,    99,   100,   101,
+   102,   103,   104,     0,   105,   106,   107,   108,     0,   279,
+     0,     0,     0,     0,     0,   109,     0,     0,   110,   111,
+   112,     0,     0,     0,   113,   114,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,   115,   116,   117,
+   118,   119,   120,   121,     0,     0,     0,     0,     0,   122,
+   123,    99,   100,   101,   102,   103,   104,     0,   105,   106,
+   107,   108,     0,     0,     0,     0,   286,     0,     0,   109,
+     0,     0,   110,   111,   112,     0,     0,     0,   113,   114,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,   115,   116,   117,   118,   119,   120,   121,     0,     0,
+     0,     0,     0,   122,   123,    99,   100,   101,   102,   103,
+   104,     0,   105,   106,   107,   108,     0,   300,     0,     0,
+     0,     0,     0,   109,     0,     0,   110,   111,   112,     0,
+     0,     0,   113,   114,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,   115,   116,   117,   118,   119,
+   120,   121,     0,     0,     0,     0,     0,   122,   123,    99,
+   100,   101,   102,   103,   104,     0,   105,   106,   107,   108,
+     0,   302,     0,     0,     0,     0,     0,   109,     0,     0,
+   110,   111,   112,     0,     0,     0,   113,   114,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,   115,
+   116,   117,   118,   119,   120,   121,     0,     0,     0,     0,
+     0,   122,   123,    99,   100,   101,   102,   103,   104,     0,
+   105,   106,   107,   108,     0,   320,     0,     0,     0,     0,
+     0,   109,     0,     0,   110,   111,   112,     0,     0,     0,
+   113,   114,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,   115,   116,   117,   118,   119,   120,   121,
+     0,     0,     0,     0,     0,   122,   123,    99,   100,   101,
+   102,   103,   104,     0,   105,   106,   107,   108,     0,     0,
+     0,     0,   362,     0,     0,   109,     0,     0,   110,   111,
+   112,     0,     0,     0,   113,   114,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,   115,   116,   117,
+   118,   119,   120,   121,     0,     0,     0,     0,     0,   122,
+   123,    99,   100,   101,   102,   103,   104,     0,   105,   106,
+   107,   108,     0,     0,     0,     0,   363,     0,     0,   109,
+     0,     0,   110,   111,   112,     0,     0,     0,   113,   114,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,   115,   116,   117,   118,   119,   120,   121,     0,     0,
+     0,     0,     0,   122,   123,    99,   100,   101,   102,   103,
+   104,     0,   105,   106,   107,   108,     0,     0,     0,     0,
+   370,     0,     0,   109,     0,     0,   110,   111,   112,     0,
+     0,     0,   113,   114,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,   115,   116,   117,   118,   119,
+   120,   121,     0,     0,     0,     0,     0,   122,   123,    99,
+   100,   101,   102,   103,   104,     0,   105,   106,   107,   108,
+     0,     0,     0,     0,   375,     0,     0,   109,     0,     0,
+   110,   111,   112,     0,     0,     0,   113,   114,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,   115,
+   116,   117,   118,   119,   120,   121,     0,     0,     0,     0,
+     0,   122,   123,    99,   100,   101,   102,   103,   104,     0,
+   105,   106,   107,   108,     0,     0,     0,     0,   377,     0,
+     0,   109,     0,     0,   110,   111,   112,     0,     0,     0,
+   113,   114,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,   115,   116,   117,   118,   119,   120,   121,
+     0,     0,     0,     0,     0,   122,   123,    99,   100,   101,
+   102,   103,   104,     0,   105,   106,   107,   108,     0,     0,
+     0,     0,     0,     0,     0,   109,     0,     0,   110,   111,
+   112,     0,     0,     0,   113,   114,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,   115,   116,   117,
+   118,   119,   120,   121,     0,     0,     0,     0,     0,   122,
+   123,    99,   100,   101,   102,   103,   104,     0,   105,   106,
+   107,   108,     0,     0,     0,     0,     0,     0,     0,   109,
+     0,     0,   110,   111,   112,     0,     0,     0,   113,   114,
+    99,   100,   101,   102,   103,   104,     0,   105,   106,   107,
+   108,   115,   116,   117,   118,   119,   120,   121,   109,     0,
+     0,   110,   111,   112,   123,     0,     0,   113,   114,    99,
+   100,   101,   102,   103,   104,     0,   105,   106,   107,   108,
+   115,   116,   117,   118,   119,     0,   121,   109,     0,     0,
+   110,   111,   112,   123,     0,     0,   113,   114,    99,   100,
+   101,   102,   103,   104,     0,   105,     0,   107,   108,   115,
+   116,   117,   118,     0,     0,   121,   109,     0,     0,   110,
+   111,   112,   123,     0,     0,   113,   114,    99,   100,   101,
+   102,   103,   104,     0,   105,     0,   107,   108,   115,   116,
+   117,   118,     0,     0,   121,     0,     0,     0,   110,   111,
+   112,   123,     0,     0,   113,   114,    99,   100,   101,   102,
+   103,   104,     0,   105,     0,     0,   108,   115,   116,   117,
+   118,     0,     0,   121,     0,     0,     0,   110,   111,   112,
+   123,     0,     0,   113,   114,    99,   100,   101,   102,   103,
+   104,     0,   105,     0,     0,   108,   115,   116,   117,   118,
+     0,     0,   121,     0,     0,     0,   110,   111,   112,   123,
+     0,     0,   113,   114,    99,   100,   101,   102,     0,     0,
+     0,   105,     0,     0,   108,   124,     0,   117,   118,     0,
+     0,   121,     0,     0,     0,   110,   111,   112,   123,     0,
+     0,   113,   114,    77,    78,   253,     0,     0,    79,    80,
+    81,    82,    83,    84,    85,    86,    87,    88,     0,     0,
+   121,     0,     0,    77,    78,     0,     0,   123,    79,    80,
+    81,    82,    83,    84,    85,    86,    87,    88,    99,   100,
+   101,   102,     0,     0,     0,   105,     0,     0,   108,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+   111,   112,     0,     0,     0,   113,   114
 };
 
-static const short yycheck[] = { 1,
-1,    45,   239,   233,   207,   208,   111,     4,    10,   257,
-129,   196,   244,   206,    55,     3,   149,    14,    57,   326,
-327,    59,   136,     3,   217,     5,     6,     7,    57,    50,
-38,    55,    50,    59,   271,    57,    55,   344,   345,    28,
-336,    55,    55,     5,     6,   248,    38,    55,    57,   345,
-357,    92,    32,    59,   361,    35,    36,    37,    38,    55,
-99,    41,    42,    43,   327,    45,    46,    91,    55,    58,
-99,    92,   304,    61,    92,    55,   279,    99,    91,   282,
-283,   274,   285,    63,    64,   288,   289,   324,   221,   203,
-99,   276,    38,    59,   357,    55,     5,     6,    37,    24,
-57,    55,   339,    55,    61,    55,    50,   355,   311,    55,
-313,   314,    92,    38,    39,    24,    14,   114,   115,   238,
-350,    55,    55,    55,    37,    37,   231,   232,   331,    38,
-39,    55,    60,    38,    38,    38,    56,   367,   140,   140,
-3,   378,     5,     6,     7,    23,     9,    57,    11,    55,
-13,    14,    15,    23,     3,    56,    19,    20,    21,    22,
-57,    24,    25,    26,    27,    55,    60,    56,    56,    32,
-55,    37,    35,    36,    37,    38,    58,    40,    41,    42,
-43,    60,    45,    46,   228,    60,    44,    45,    46,    47,
-46,    47,    55,    51,    38,    51,    54,    55,    54,    55,
-63,    64,    41,    60,    99,   207,   208,    38,    66,    67,
-66,    67,    57,    71,    72,     3,     8,     5,     6,     7,
-56,     9,    26,    11,    59,    13,    14,    15,    56,    56,
-56,    56,    20,    21,    22,    56,    24,    25,    56,    27,
-60,    29,    61,    60,    32,    61,   248,    35,    36,    37,
-38,    60,    40,    41,    42,    43,    56,    45,    46,    60,
-50,    38,    61,    60,    59,    61,    50,    55,    61,    51,
-59,   273,   273,    55,    59,    63,    64,   279,    58,    50,
-282,   283,    61,   285,    66,    67,   288,   289,     0,     0,
-345,   318,    -1,    -1,    -1,     8,    -1,    -1,    -1,   301,
-301,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   311,
--1,   313,   314,    -1,    27,    28,    29,    30,    31,    -1,
-44,    45,    46,    47,    -1,    -1,    -1,    51,    -1,   331,
-54,    55,    -1,    -1,    -1,    -1,    -1,    -1,   340,   340,
-53,    -1,    66,    67,    -1,    58,    -1,    -1,    -1,    -1,
--1,    -1,    65,   355,   355,    -1,    69,    -1,    -1,    -1,
-73,    74,    -1,    76,    77,    78,    -1,    -1,    81,    82,
-83,    84,    85,    86,    87,    88,    89,    90,    91,    -1,
-93,   383,   383,    -1,    -1,    -1,    -1,    -1,   101,   102,
-103,   104,   105,   106,    -1,   108,   109,   110,   111,   112,
-113,    -1,    -1,   116,   117,   118,   119,   120,   121,   122,
-123,   124,   125,   126,   127,    -1,    -1,    -1,    -1,    -1,
--1,    -1,   135,   136,     3,    -1,     5,     6,     7,   142,
-9,    -1,    11,   146,    13,    14,    15,    -1,    -1,    -1,
--1,    20,    21,    22,    -1,    24,    25,    -1,    27,    -1,
--1,    -1,    -1,    32,    -1,    -1,    35,    36,    37,    38,
--1,    40,    41,    42,    43,    -1,    45,    46,    -1,    -1,
--1,    -1,    -1,    -1,    -1,    -1,    55,    -1,    -1,    -1,
--1,    60,    -1,   196,    63,    64,    -1,    -1,    -1,    -1,
-203,    -1,     3,    -1,     5,     6,     7,    -1,   211,   212,
--1,   214,   215,   216,    -1,    -1,    -1,    -1,    -1,    -1,
--1,    -1,   225,    -1,   227,    -1,    -1,   230,   231,   232,
-233,    32,   235,    -1,    35,    36,    37,    38,    -1,    -1,
-41,    42,    43,    -1,    45,    46,    -1,   250,   251,    -1,
--1,    -1,    -1,    -1,    55,    -1,    -1,    -1,    59,    -1,
-263,    -1,    63,    64,    -1,    -1,    -1,    -1,     3,    -1,
-5,     6,     7,   276,     9,    -1,    11,    -1,    13,    14,
-15,    -1,    -1,    -1,   287,    20,    21,    22,   291,    24,
-25,    -1,    27,    -1,    -1,    -1,    -1,    32,    -1,    -1,
-35,    36,    37,    38,    -1,    40,    41,    42,    43,    -1,
-45,    46,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-55,    -1,    -1,    -1,    -1,    50,    61,    -1,    63,    64,
--1,    -1,    -1,    -1,    -1,   338,    -1,    -1,    -1,    -1,
--1,    -1,    -1,    68,    69,   348,   349,   350,    73,    74,
-75,    76,    77,    78,    79,    80,    81,    82,    -1,    -1,
--1,    -1,    -1,   366,   367,    -1,    -1,    92,     3,    -1,
-5,     6,     7,    -1,     9,    -1,    11,   380,    13,    14,
-15,    -1,   385,    -1,    -1,    20,    21,    22,    -1,    24,
-25,    -1,    27,    -1,    -1,    -1,    -1,    32,    -1,    -1,
-35,    36,    37,    38,    -1,    40,    41,    42,    43,    -1,
-45,    46,    -1,     3,    -1,     5,     6,     7,    -1,     9,
-55,    11,    -1,    13,    14,    15,    61,    -1,    63,    64,
-20,    21,    22,    -1,    24,    25,    -1,    27,    -1,    -1,
--1,    -1,    32,    -1,    -1,    35,    36,    37,    38,    -1,
-40,    41,    42,    43,    -1,    45,    46,    -1,     3,    -1,
-5,     6,     7,    -1,     9,    55,    11,    -1,    13,    14,
-15,    61,    -1,    63,    64,    20,    21,    22,    -1,    24,
-25,    -1,    27,    -1,    -1,    -1,    -1,    32,    -1,    -1,
-35,    36,    37,    38,    -1,    40,    41,    42,    43,    -1,
-45,    46,    -1,     3,    -1,     5,     6,     7,    -1,     9,
-55,    11,    -1,    13,    14,    15,    61,    -1,    63,    64,
-20,    21,    22,    -1,    24,    25,    -1,    27,    -1,    -1,
--1,    -1,    32,    -1,    -1,    35,    36,    37,    38,    -1,
-40,    41,    42,    43,    -1,    45,    46,     3,    -1,     5,
-6,     7,    -1,    -1,    -1,    55,    -1,    -1,    -1,    -1,
--1,    -1,    -1,    63,    64,    -1,    -1,    -1,    -1,    -1,
--1,    -1,    -1,    -1,    -1,    -1,    32,    -1,    -1,    35,
-36,    37,    38,    -1,    -1,    41,    42,    43,    -1,    45,
-46,     3,    -1,     5,     6,     7,    -1,    -1,    -1,    55,
--1,    -1,    -1,    59,    -1,    -1,    -1,    63,    64,    -1,
--1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-32,    -1,    -1,    35,    36,    37,    38,    -1,    -1,    41,
-42,    43,    -1,    45,    46,     3,    -1,     5,     6,     7,
--1,    -1,    -1,    55,    -1,    -1,    -1,    -1,    60,    -1,
--1,    63,    64,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
--1,    -1,    -1,    -1,    32,    -1,    -1,    35,    36,    37,
-38,    -1,    -1,    41,    42,    43,    -1,    45,    46,     3,
--1,     5,     6,     7,    -1,    -1,    -1,    55,    -1,    -1,
--1,    59,    -1,    -1,    -1,    63,    64,    -1,    -1,    -1,
--1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    32,    -1,
--1,    35,    36,    37,    38,    -1,    -1,    41,    42,    43,
--1,    45,    46,     3,    -1,     5,     6,     7,    -1,    -1,
--1,    55,    56,    -1,    -1,    -1,    -1,    -1,    -1,    63,
-64,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
--1,    -1,    32,    -1,    -1,    35,    36,    37,    38,    -1,
--1,    41,    42,    43,    -1,    45,    46,     3,    -1,     5,
-6,     7,    -1,    -1,    -1,    55,    -1,    -1,    -1,    59,
--1,    -1,    -1,    63,    64,    -1,    -1,    -1,    -1,    -1,
--1,    -1,    -1,    -1,    -1,    -1,    32,    -1,    -1,    35,
-36,    37,    38,    -1,    -1,    41,    42,    43,    -1,    45,
-46,     3,    -1,     5,     6,     7,    -1,    -1,    -1,    55,
-56,    -1,    -1,    -1,    -1,    -1,    -1,    63,    64,    -1,
--1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-32,    -1,    -1,    35,    36,    37,    38,    -1,    -1,    41,
-42,    43,    -1,    45,    46,     3,    -1,     5,     6,     7,
--1,    -1,    -1,    55,    56,    -1,    -1,    -1,    -1,    -1,
--1,    63,    64,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
--1,    -1,    -1,    -1,    32,    -1,    -1,    35,    36,    37,
-38,    -1,    -1,    41,    42,    43,    -1,    45,    46,     3,
--1,     5,     6,     7,    -1,    -1,    -1,    55,    56,    -1,
--1,    -1,    -1,    -1,    -1,    63,    64,    -1,    -1,    -1,
--1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    32,    -1,
--1,    35,    36,    37,    38,    -1,    -1,    41,    42,    43,
--1,    45,    46,    -1,    -1,    44,    45,    46,    47,    48,
-49,    55,    51,    52,    53,    54,    55,    56,    57,    63,
-64,    -1,    -1,    62,    -1,    -1,    65,    66,    67,    -1,
--1,    -1,    71,    72,    -1,    -1,    -1,    -1,    -1,    -1,
--1,    -1,    -1,    -1,    -1,    84,    85,    86,    87,    88,
-89,    90,    -1,    -1,    -1,    -1,    -1,    96,    97,    44,
-45,    46,    47,    48,    49,    -1,    51,    52,    53,    54,
-55,    -1,    57,    -1,    59,    -1,    -1,    62,    -1,    -1,
-65,    66,    67,    -1,    -1,    -1,    71,    72,    -1,    -1,
--1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    84,
-85,    86,    87,    88,    89,    90,    -1,    -1,    -1,    -1,
--1,    96,    97,    44,    45,    46,    47,    48,    49,    -1,
-51,    52,    53,    54,    55,    -1,    -1,    -1,    59,    -1,
--1,    62,    -1,    -1,    65,    66,    67,    -1,    -1,    -1,
-71,    72,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
--1,    -1,    -1,    84,    85,    86,    87,    88,    89,    90,
--1,    -1,    -1,    -1,    -1,    96,    97,    44,    45,    46,
-47,    48,    49,    -1,    51,    52,    53,    54,    55,    56,
--1,    -1,    -1,    -1,    -1,    62,    -1,    -1,    65,    66,
-67,    -1,    -1,    -1,    71,    72,    -1,    -1,    -1,    -1,
--1,    -1,    -1,    -1,    -1,    -1,    -1,    84,    85,    86,
-87,    88,    89,    90,    -1,    -1,    -1,    -1,    -1,    96,
-97,    44,    45,    46,    47,    48,    49,    -1,    51,    52,
-53,    54,    55,    56,    -1,    -1,    -1,    -1,    -1,    62,
--1,    -1,    65,    66,    67,    -1,    -1,    -1,    71,    72,
--1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
--1,    84,    85,    86,    87,    88,    89,    90,    -1,    -1,
--1,    -1,    -1,    96,    97,    44,    45,    46,    47,    48,
-49,    -1,    51,    52,    53,    54,    55,    56,    -1,    -1,
--1,    -1,    -1,    62,    -1,    -1,    65,    66,    67,    -1,
--1,    -1,    71,    72,    -1,    -1,    -1,    -1,    -1,    -1,
--1,    -1,    -1,    -1,    -1,    84,    85,    86,    87,    88,
-89,    90,    -1,    -1,    -1,    -1,    -1,    96,    97,    44,
-45,    46,    47,    48,    49,    -1,    51,    52,    53,    54,
-55,    56,    -1,    -1,    -1,    -1,    -1,    62,    -1,    -1,
-65,    66,    67,    -1,    -1,    -1,    71,    72,    -1,    -1,
--1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    84,
-85,    86,    87,    88,    89,    90,    -1,    -1,    -1,    -1,
--1,    96,    97,    44,    45,    46,    47,    48,    49,    -1,
-51,    52,    53,    54,    55,    -1,    -1,    -1,    59,    -1,
--1,    62,    -1,    -1,    65,    66,    67,    -1,    -1,    -1,
-71,    72,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
--1,    -1,    -1,    84,    85,    86,    87,    88,    89,    90,
--1,    -1,    -1,    -1,    -1,    96,    97,    44,    45,    46,
-47,    48,    49,    -1,    51,    52,    53,    54,    55,    56,
--1,    -1,    -1,    -1,    -1,    62,    -1,    -1,    65,    66,
-67,    -1,    -1,    -1,    71,    72,    -1,    -1,    -1,    -1,
--1,    -1,    -1,    -1,    -1,    -1,    -1,    84,    85,    86,
-87,    88,    89,    90,    -1,    -1,    -1,    -1,    -1,    96,
-97,    44,    45,    46,    47,    48,    49,    -1,    51,    52,
-53,    54,    55,    56,    -1,    -1,    -1,    -1,    -1,    62,
--1,    -1,    65,    66,    67,    -1,    -1,    -1,    71,    72,
--1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
--1,    84,    85,    86,    87,    88,    89,    90,    -1,    -1,
--1,    -1,    -1,    96,    97,    44,    45,    46,    47,    48,
-49,    -1,    51,    52,    53,    54,    55,    -1,    -1,    58,
--1,    -1,    -1,    62,    -1,    -1,    65,    66,    67,    -1,
--1,    -1,    71,    72,    -1,    -1,    -1,    -1,    -1,    -1,
--1,    -1,    -1,    -1,    -1,    84,    85,    86,    87,    88,
-89,    90,    -1,    -1,    -1,    -1,    -1,    96,    97,    44,
-45,    46,    47,    48,    49,    -1,    51,    52,    53,    54,
-55,    -1,    -1,    -1,    59,    -1,    -1,    62,    -1,    -1,
-65,    66,    67,    -1,    -1,    -1,    71,    72,    -1,    -1,
--1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    84,
-85,    86,    87,    88,    89,    90,    -1,    -1,    -1,    -1,
--1,    96,    97,    44,    45,    46,    47,    48,    49,    -1,
-51,    52,    53,    54,    55,    -1,    -1,    58,    -1,    -1,
--1,    62,    -1,    -1,    65,    66,    67,    -1,    -1,    -1,
-71,    72,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
--1,    -1,    -1,    84,    85,    86,    87,    88,    89,    90,
--1,    -1,    -1,    -1,    -1,    96,    97,    44,    45,    46,
-47,    48,    49,    -1,    51,    52,    53,    54,    55,    56,
--1,    -1,    -1,    -1,    -1,    62,    -1,    -1,    65,    66,
-67,    -1,    -1,    -1,    71,    72,    -1,    -1,    -1,    -1,
--1,    -1,    -1,    -1,    -1,    -1,    -1,    84,    85,    86,
-87,    88,    89,    90,    -1,    -1,    -1,    -1,    -1,    96,
-97,    44,    45,    46,    47,    48,    49,    -1,    51,    52,
-53,    54,    55,    56,    -1,    -1,    -1,    -1,    -1,    62,
--1,    -1,    65,    66,    67,    -1,    -1,    -1,    71,    72,
--1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
--1,    84,    85,    86,    87,    88,    89,    90,    -1,    -1,
--1,    -1,    -1,    96,    97,    44,    45,    46,    47,    48,
-49,    -1,    51,    52,    53,    54,    55,    -1,    -1,    -1,
-59,    -1,    -1,    62,    -1,    -1,    65,    66,    67,    -1,
--1,    -1,    71,    72,    -1,    -1,    -1,    -1,    -1,    -1,
--1,    -1,    -1,    -1,    -1,    84,    85,    86,    87,    88,
-89,    90,    -1,    -1,    -1,    -1,    -1,    96,    97,    44,
-45,    46,    47,    48,    49,    -1,    51,    52,    53,    54,
-55,    56,    -1,    -1,    -1,    -1,    -1,    62,    -1,    -1,
-65,    66,    67,    -1,    -1,    -1,    71,    72,    -1,    -1,
--1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    84,
-85,    86,    87,    88,    89,    90,    -1,    -1,    -1,    -1,
--1,    96,    97,    44,    45,    46,    47,    48,    49,    -1,
-51,    52,    53,    54,    55,    56,    -1,    -1,    -1,    -1,
--1,    62,    -1,    -1,    65,    66,    67,    -1,    -1,    -1,
-71,    72,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
--1,    -1,    -1,    84,    85,    86,    87,    88,    89,    90,
--1,    -1,    -1,    -1,    -1,    96,    97,    44,    45,    46,
-47,    48,    49,    -1,    51,    52,    53,    54,    55,    -1,
--1,    -1,    59,    -1,    -1,    62,    -1,    -1,    65,    66,
-67,    -1,    -1,    -1,    71,    72,    -1,    -1,    -1,    -1,
--1,    -1,    -1,    -1,    -1,    -1,    -1,    84,    85,    86,
-87,    88,    89,    90,    -1,    -1,    -1,    -1,    -1,    96,
-97,    44,    45,    46,    47,    48,    49,    -1,    51,    52,
-53,    54,    55,    56,    -1,    -1,    -1,    -1,    -1,    62,
--1,    -1,    65,    66,    67,    -1,    -1,    -1,    71,    72,
--1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
--1,    84,    85,    86,    87,    88,    89,    90,    -1,    -1,
--1,    -1,    -1,    96,    97,    44,    45,    46,    47,    48,
-49,    -1,    51,    52,    53,    54,    55,    56,    -1,    -1,
--1,    -1,    -1,    62,    -1,    -1,    65,    66,    67,    -1,
--1,    -1,    71,    72,    -1,    -1,    -1,    -1,    -1,    -1,
--1,    -1,    -1,    -1,    -1,    84,    85,    86,    87,    88,
-89,    90,    -1,    -1,    -1,    -1,    -1,    96,    97,    44,
-45,    46,    47,    48,    49,    -1,    51,    52,    53,    54,
-55,    56,    -1,    -1,    -1,    -1,    -1,    62,    -1,    -1,
-65,    66,    67,    -1,    -1,    -1,    71,    72,    -1,    -1,
--1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    84,
-85,    86,    87,    88,    89,    90,    -1,    -1,    -1,    -1,
--1,    96,    97,    44,    45,    46,    47,    48,    49,    -1,
-51,    52,    53,    54,    55,    -1,    -1,    -1,    59,    -1,
--1,    62,    -1,    -1,    65,    66,    67,    -1,    -1,    -1,
-71,    72,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
--1,    -1,    -1,    84,    85,    86,    87,    88,    89,    90,
--1,    -1,    -1,    -1,    -1,    96,    97,    44,    45,    46,
-47,    48,    49,    -1,    51,    52,    53,    54,    55,    -1,
--1,    -1,    59,    -1,    -1,    62,    -1,    -1,    65,    66,
-67,    -1,    -1,    -1,    71,    72,    -1,    -1,    -1,    -1,
--1,    -1,    -1,    -1,    -1,    -1,    -1,    84,    85,    86,
-87,    88,    89,    90,    -1,    -1,    -1,    -1,    -1,    96,
-97,    44,    45,    46,    47,    48,    49,    -1,    51,    52,
-53,    54,    55,    -1,    -1,    -1,    59,    -1,    -1,    62,
--1,    -1,    65,    66,    67,    -1,    -1,    -1,    71,    72,
--1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
--1,    84,    85,    86,    87,    88,    89,    90,    -1,    -1,
--1,    -1,    -1,    96,    97,    44,    45,    46,    47,    48,
-49,    -1,    51,    52,    53,    54,    55,    -1,    -1,    -1,
-59,    -1,    -1,    62,    -1,    -1,    65,    66,    67,    -1,
--1,    -1,    71,    72,    -1,    -1,    -1,    -1,    -1,    -1,
--1,    -1,    -1,    -1,    -1,    84,    85,    86,    87,    88,
-89,    90,    -1,    -1,    -1,    -1,    -1,    96,    97,    44,
-45,    46,    47,    48,    49,    -1,    51,    52,    53,    54,
-55,    -1,    -1,    -1,    59,    -1,    -1,    62,    -1,    -1,
-65,    66,    67,    -1,    -1,    -1,    71,    72,    -1,    -1,
--1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    84,
-85,    86,    87,    88,    89,    90,    -1,    -1,    -1,    -1,
--1,    96,    97,    44,    45,    46,    47,    48,    49,    -1,
-51,    52,    53,    54,    55,    -1,    -1,    -1,    -1,    -1,
--1,    62,    -1,    -1,    65,    66,    67,    -1,    -1,    -1,
-71,    72,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
--1,    -1,    -1,    84,    85,    86,    87,    88,    89,    90,
--1,    -1,    -1,    -1,    -1,    96,    97,    44,    45,    46,
-47,    48,    49,    -1,    51,    52,    53,    54,    55,    -1,
--1,    -1,    -1,    -1,    -1,    62,    -1,    -1,    65,    66,
-67,    -1,    -1,    -1,    71,    72,    -1,    -1,    -1,    -1,
--1,    -1,    -1,    -1,    -1,    -1,    -1,    84,    85,    86,
-87,    88,    89,    90,    44,    45,    46,    47,    48,    49,
-97,    51,    52,    53,    54,    55,    -1,    -1,    -1,    -1,
--1,    -1,    62,    -1,    -1,    65,    66,    67,    -1,    -1,
--1,    71,    72,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
--1,    -1,    -1,    -1,    84,    85,    86,    87,    88,    -1,
-90,    44,    45,    46,    47,    48,    49,    97,    51,    52,
-53,    54,    55,    -1,    -1,    -1,    -1,    -1,    -1,    62,
--1,    -1,    65,    66,    67,    -1,    -1,    -1,    71,    72,
--1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
--1,    84,    85,    86,    87,    -1,    -1,    90,    44,    45,
-46,    47,    48,    49,    97,    51,    -1,    53,    54,    55,
--1,    -1,    -1,    -1,    -1,    -1,    62,    -1,    -1,    65,
-66,    67,    -1,    -1,    -1,    71,    72,    -1,    -1,    -1,
--1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    84,    85,
-86,    87,    -1,    -1,    90,    44,    45,    46,    47,    48,
-49,    97,    51,    -1,    53,    54,    55,    -1,    -1,    -1,
--1,    -1,    -1,    -1,    -1,    -1,    65,    66,    67,    -1,
--1,    -1,    71,    72,    -1,    -1,    -1,    -1,    -1,    -1,
--1,    -1,    -1,    -1,    -1,    84,    85,    86,    87,    -1,
--1,    90,    44,    45,    46,    47,    48,    49,    97,    51,
--1,    -1,    54,    55,    -1,    -1,    -1,    -1,    -1,    -1,
--1,    -1,    -1,    65,    66,    67,    -1,    -1,    -1,    71,
-72,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
--1,    -1,    84,    85,    86,    87,    -1,    -1,    90,    44,
-45,    46,    47,    48,    49,    97,    51,    -1,    -1,    54,
-55,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-65,    66,    67,    -1,    -1,    -1,    71,    72,    44,    45,
-46,    47,    -1,    -1,    -1,    51,    -1,    -1,    54,    55,
-50,    86,    87,    -1,    -1,    90,    -1,    -1,    -1,    65,
-66,    67,    97,    -1,    -1,    71,    72,    -1,    68,    69,
-50,    -1,    -1,    73,    74,    75,    76,    77,    78,    79,
-80,    81,    82,    -1,    90,    -1,    -1,    -1,    68,    69,
--1,    97,    -1,    73,    74,    75,    76,    77,    78,    79,
-80,    81,    82
+static const short yycheck[] = {     1,
+     1,    45,   247,   143,   130,   261,   189,    38,    10,    57,
+    57,   199,   234,    50,    50,    55,     3,    50,    57,    57,
+   325,    55,   210,     4,    28,    55,    55,    55,    55,   334,
+    38,    68,    69,    14,   316,   225,    73,    74,    75,    76,
+    77,    78,    79,    80,    81,    82,     8,    55,     5,     6,
+     7,    99,    99,    59,    58,    92,    92,   313,    92,    92,
+    99,    99,    91,    91,   346,    27,    28,    29,    30,    31,
+   196,   293,   328,   213,    61,    32,   264,    51,    35,    36,
+    37,    38,    24,   266,    41,    42,    43,    59,    45,    46,
+    52,    55,    66,    67,    55,    57,    38,    39,    55,   344,
+    55,    63,     5,     6,    57,    67,    63,    64,    61,    71,
+    72,   367,    74,    75,    76,   223,   224,    79,    80,    81,
+    82,    83,    84,    85,    86,    87,    88,    89,    55,    91,
+   111,   112,   134,   134,    38,    92,    55,    99,   100,   101,
+   102,   103,   104,    50,   106,   107,   108,   109,   110,   339,
+    59,   113,   114,   115,   116,   117,   118,   119,   120,   121,
+   122,   123,   124,    59,    55,    55,   356,   129,   130,    14,
+     5,     6,     7,    37,   136,    37,   220,    55,   140,    60,
+    38,    38,    37,    55,    38,    23,   315,   316,     3,    23,
+    56,    58,    57,    56,    55,    55,    37,    32,   200,   201,
+    35,    36,    37,    38,   333,   334,    41,    42,    43,    57,
+    45,    46,    41,    60,    60,    99,    60,   346,     5,     6,
+    55,   350,    38,     8,    59,    57,    56,   189,    63,    64,
+   200,   201,    26,    59,   196,    56,   238,    24,    56,    56,
+    60,    60,   204,   205,    56,   207,   208,   209,    56,    56,
+    61,    38,    39,    56,    60,   217,    61,   219,    60,    50,
+   222,   223,   224,   225,   226,    38,    61,   269,   238,    59,
+   272,   273,    60,   275,    58,    61,   278,   279,   240,   241,
+    61,    59,    59,    50,    50,    61,     0,     0,   334,   291,
+   291,   253,   230,   307,    -1,    -1,    -1,    -1,   300,   269,
+   302,   303,   272,   273,   266,   275,    -1,    -1,   278,   279,
+    -1,    -1,    -1,    -1,    -1,   277,    -1,    -1,   320,   281,
+    -1,    -1,     5,     6,     7,    -1,    -1,   329,   329,    -1,
+   300,    -1,   302,   303,    44,    45,    46,    47,    -1,    -1,
+    -1,    51,   344,   344,    54,    -1,    -1,    -1,    -1,    32,
+   320,    -1,    35,    36,    37,    38,    66,    67,    41,    42,
+    43,    -1,    45,    46,    -1,   327,    -1,    -1,    -1,    -1,
+   372,   372,    55,    56,    -1,   337,   338,   339,    -1,    -1,
+    63,    64,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,   355,   356,    -1,    -1,    -1,     3,    -1,
+     5,     6,     7,    -1,     9,    -1,    11,   369,    13,    14,
+    15,    -1,   374,    -1,    -1,    20,    21,    22,    -1,    24,
+    25,    -1,    27,    -1,    29,    -1,    -1,    32,    -1,    -1,
+    35,    36,    37,    38,    -1,    40,    41,    42,    43,    -1,
+    45,    46,    -1,    -1,    -1,    -1,    -1,     5,     6,     7,
+    55,     9,    -1,    11,    -1,    13,    14,    15,    63,    64,
+    -1,    19,    20,    21,    22,    -1,    24,    25,    26,    27,
+    -1,    -1,    -1,    -1,    32,    -1,    -1,    35,    36,    37,
+    38,    -1,    40,    41,    42,    43,    -1,    45,    46,    -1,
+    -1,    -1,     5,     6,     7,    -1,     9,    55,    11,    -1,
+    13,    14,    15,    -1,    -1,    63,    64,    20,    21,    22,
+    -1,    24,    25,    -1,    27,    -1,    -1,    -1,    -1,    32,
+    -1,    -1,    35,    36,    37,    38,    -1,    40,    41,    42,
+    43,    -1,    45,    46,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    55,    -1,    -1,    -1,    -1,    60,    -1,    -1,
+    63,    64,     5,     6,     7,    -1,     9,    -1,    11,    -1,
+    13,    14,    15,    -1,    -1,    -1,    -1,    20,    21,    22,
+    -1,    24,    25,    -1,    27,    -1,    -1,    -1,    -1,    32,
+    -1,    -1,    35,    36,    37,    38,    -1,    40,    41,    42,
+    43,    -1,    45,    46,    -1,    -1,    -1,     5,     6,     7,
+    -1,     9,    55,    11,    -1,    13,    14,    15,    61,    -1,
+    63,    64,    20,    21,    22,    -1,    24,    25,    -1,    27,
+    -1,    -1,    -1,    -1,    32,    -1,    -1,    35,    36,    37,
+    38,    -1,    40,    41,    42,    43,    -1,    45,    46,    -1,
+    -1,    -1,     5,     6,     7,    -1,     9,    55,    11,    -1,
+    13,    14,    15,    61,    -1,    63,    64,    20,    21,    22,
+    -1,    24,    25,    -1,    27,    -1,    -1,    -1,    -1,    32,
+    -1,    -1,    35,    36,    37,    38,    -1,    40,    41,    42,
+    43,    -1,    45,    46,    -1,    -1,    -1,     5,     6,     7,
+    -1,     9,    55,    11,    -1,    13,    14,    15,    61,    -1,
+    63,    64,    20,    21,    22,    -1,    24,    25,    -1,    27,
+    -1,     5,     6,     7,    32,    -1,    -1,    35,    36,    37,
+    38,    -1,    40,    41,    42,    43,    -1,    45,    46,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    55,    32,    -1,
+    -1,    35,    36,    37,    38,    63,    64,    41,    42,    43,
+    -1,    45,    46,     5,     6,     7,    -1,    -1,    46,    47,
+    -1,    55,    -1,    51,    -1,    59,    54,    -1,    -1,    63,
+    64,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,    67,
+    32,    -1,    -1,    35,    36,    37,    38,    -1,    -1,    41,
+    42,    43,    -1,    45,    46,     5,     6,     7,    -1,    -1,
+    -1,    -1,    -1,    55,    -1,    -1,    -1,    -1,    60,    -1,
+    -1,    63,    64,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    32,    -1,    -1,    35,    36,    37,    38,    -1,
+    -1,    41,    42,    43,    -1,    45,    46,     5,     6,     7,
+    -1,    -1,    -1,    -1,    -1,    55,    -1,    -1,    -1,    59,
+    -1,    -1,    -1,    63,    64,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    32,    -1,    -1,    35,    36,    37,
+    38,    -1,    -1,    41,    42,    43,    -1,    45,    46,     5,
+     6,     7,    -1,    -1,    -1,    -1,    -1,    55,    -1,    -1,
+    -1,    59,    -1,    -1,    -1,    63,    64,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    32,    -1,    -1,    35,
+    36,    37,    38,    -1,    -1,    41,    42,    43,    -1,    45,
+    46,     5,     6,     7,    -1,    -1,    -1,    -1,    -1,    55,
+    56,    -1,    -1,    -1,    -1,    -1,    -1,    63,    64,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    32,    -1,
+    -1,    35,    36,    37,    38,    -1,    -1,    41,    42,    43,
+    -1,    45,    46,     5,     6,     7,    -1,    -1,    -1,    -1,
+    -1,    55,    56,    -1,    -1,    -1,    -1,    -1,    -1,    63,
+    64,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    32,    -1,    -1,    35,    36,    37,    38,    -1,    -1,    41,
+    42,    43,    -1,    45,    46,     5,     6,     7,    -1,    -1,
+    -1,    -1,    -1,    55,    56,    -1,    -1,    -1,    -1,    -1,
+    -1,    63,    64,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    32,    -1,    -1,    35,    36,    37,    38,    -1,
+    -1,    41,    42,    43,    -1,    45,    46,    -1,    -1,    44,
+    45,    46,    47,    48,    49,    55,    51,    52,    53,    54,
+    -1,    56,    57,    63,    64,    -1,    -1,    62,    -1,    -1,
+    65,    66,    67,    -1,    -1,    -1,    71,    72,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    84,
+    85,    86,    87,    88,    89,    90,    -1,    -1,    -1,    -1,
+    -1,    96,    97,    44,    45,    46,    47,    48,    49,    -1,
+    51,    52,    53,    54,    -1,    -1,    57,    -1,    59,    -1,
+    -1,    62,    -1,    -1,    65,    66,    67,    -1,    -1,    -1,
+    71,    72,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    84,    85,    86,    87,    88,    89,    90,
+    -1,    -1,    -1,    -1,    -1,    96,    97,    44,    45,    46,
+    47,    48,    49,    -1,    51,    52,    53,    54,    -1,    -1,
+    -1,    -1,    59,    -1,    -1,    62,    -1,    -1,    65,    66,
+    67,    -1,    -1,    -1,    71,    72,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    84,    85,    86,
+    87,    88,    89,    90,    -1,    -1,    -1,    -1,    -1,    96,
+    97,    44,    45,    46,    47,    48,    49,    -1,    51,    52,
+    53,    54,    -1,    56,    -1,    -1,    -1,    -1,    -1,    62,
+    -1,    -1,    65,    66,    67,    -1,    -1,    -1,    71,    72,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    84,    85,    86,    87,    88,    89,    90,    -1,    -1,
+    -1,    -1,    -1,    96,    97,    44,    45,    46,    47,    48,
+    49,    -1,    51,    52,    53,    54,    -1,    56,    -1,    -1,
+    -1,    -1,    -1,    62,    -1,    -1,    65,    66,    67,    -1,
+    -1,    -1,    71,    72,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    84,    85,    86,    87,    88,
+    89,    90,    -1,    -1,    -1,    -1,    -1,    96,    97,    44,
+    45,    46,    47,    48,    49,    -1,    51,    52,    53,    54,
+    -1,    56,    -1,    -1,    -1,    -1,    -1,    62,    -1,    -1,
+    65,    66,    67,    -1,    -1,    -1,    71,    72,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    84,
+    85,    86,    87,    88,    89,    90,    -1,    -1,    -1,    -1,
+    -1,    96,    97,    44,    45,    46,    47,    48,    49,    -1,
+    51,    52,    53,    54,    -1,    56,    -1,    -1,    -1,    -1,
+    -1,    62,    -1,    -1,    65,    66,    67,    -1,    -1,    -1,
+    71,    72,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    84,    85,    86,    87,    88,    89,    90,
+    -1,    -1,    -1,    -1,    -1,    96,    97,    44,    45,    46,
+    47,    48,    49,    -1,    51,    52,    53,    54,    -1,    -1,
+    -1,    -1,    59,    -1,    -1,    62,    -1,    -1,    65,    66,
+    67,    -1,    -1,    -1,    71,    72,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    84,    85,    86,
+    87,    88,    89,    90,    -1,    -1,    -1,    -1,    -1,    96,
+    97,    44,    45,    46,    47,    48,    49,    -1,    51,    52,
+    53,    54,    -1,    56,    -1,    -1,    -1,    -1,    -1,    62,
+    -1,    -1,    65,    66,    67,    -1,    -1,    -1,    71,    72,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    84,    85,    86,    87,    88,    89,    90,    -1,    -1,
+    -1,    -1,    -1,    96,    97,    44,    45,    46,    47,    48,
+    49,    -1,    51,    52,    53,    54,    -1,    56,    -1,    -1,
+    -1,    -1,    -1,    62,    -1,    -1,    65,    66,    67,    -1,
+    -1,    -1,    71,    72,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    84,    85,    86,    87,    88,
+    89,    90,    -1,    -1,    -1,    -1,    -1,    96,    97,    44,
+    45,    46,    47,    48,    49,    -1,    51,    52,    53,    54,
+    -1,    -1,    -1,    58,    -1,    -1,    -1,    62,    -1,    -1,
+    65,    66,    67,    -1,    -1,    -1,    71,    72,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    84,
+    85,    86,    87,    88,    89,    90,    -1,    -1,    -1,    -1,
+    -1,    96,    97,    44,    45,    46,    47,    48,    49,    -1,
+    51,    52,    53,    54,    -1,    -1,    -1,    -1,    59,    -1,
+    -1,    62,    -1,    -1,    65,    66,    67,    -1,    -1,    -1,
+    71,    72,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    84,    85,    86,    87,    88,    89,    90,
+    -1,    -1,    -1,    -1,    -1,    96,    97,    44,    45,    46,
+    47,    48,    49,    -1,    51,    52,    53,    54,    -1,    -1,
+    -1,    58,    -1,    -1,    -1,    62,    -1,    -1,    65,    66,
+    67,    -1,    -1,    -1,    71,    72,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    84,    85,    86,
+    87,    88,    89,    90,    -1,    -1,    -1,    -1,    -1,    96,
+    97,    44,    45,    46,    47,    48,    49,    -1,    51,    52,
+    53,    54,    -1,    56,    -1,    -1,    -1,    -1,    -1,    62,
+    -1,    -1,    65,    66,    67,    -1,    -1,    -1,    71,    72,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    84,    85,    86,    87,    88,    89,    90,    -1,    -1,
+    -1,    -1,    -1,    96,    97,    44,    45,    46,    47,    48,
+    49,    -1,    51,    52,    53,    54,    -1,    56,    -1,    -1,
+    -1,    -1,    -1,    62,    -1,    -1,    65,    66,    67,    -1,
+    -1,    -1,    71,    72,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    84,    85,    86,    87,    88,
+    89,    90,    -1,    -1,    -1,    -1,    -1,    96,    97,    44,
+    45,    46,    47,    48,    49,    -1,    51,    52,    53,    54,
+    -1,    -1,    -1,    -1,    59,    -1,    -1,    62,    -1,    -1,
+    65,    66,    67,    -1,    -1,    -1,    71,    72,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    84,
+    85,    86,    87,    88,    89,    90,    -1,    -1,    -1,    -1,
+    -1,    96,    97,    44,    45,    46,    47,    48,    49,    -1,
+    51,    52,    53,    54,    -1,    56,    -1,    -1,    -1,    -1,
+    -1,    62,    -1,    -1,    65,    66,    67,    -1,    -1,    -1,
+    71,    72,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    84,    85,    86,    87,    88,    89,    90,
+    -1,    -1,    -1,    -1,    -1,    96,    97,    44,    45,    46,
+    47,    48,    49,    -1,    51,    52,    53,    54,    -1,    56,
+    -1,    -1,    -1,    -1,    -1,    62,    -1,    -1,    65,    66,
+    67,    -1,    -1,    -1,    71,    72,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    84,    85,    86,
+    87,    88,    89,    90,    -1,    -1,    -1,    -1,    -1,    96,
+    97,    44,    45,    46,    47,    48,    49,    -1,    51,    52,
+    53,    54,    -1,    -1,    -1,    -1,    59,    -1,    -1,    62,
+    -1,    -1,    65,    66,    67,    -1,    -1,    -1,    71,    72,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    84,    85,    86,    87,    88,    89,    90,    -1,    -1,
+    -1,    -1,    -1,    96,    97,    44,    45,    46,    47,    48,
+    49,    -1,    51,    52,    53,    54,    -1,    56,    -1,    -1,
+    -1,    -1,    -1,    62,    -1,    -1,    65,    66,    67,    -1,
+    -1,    -1,    71,    72,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    84,    85,    86,    87,    88,
+    89,    90,    -1,    -1,    -1,    -1,    -1,    96,    97,    44,
+    45,    46,    47,    48,    49,    -1,    51,    52,    53,    54,
+    -1,    56,    -1,    -1,    -1,    -1,    -1,    62,    -1,    -1,
+    65,    66,    67,    -1,    -1,    -1,    71,    72,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    84,
+    85,    86,    87,    88,    89,    90,    -1,    -1,    -1,    -1,
+    -1,    96,    97,    44,    45,    46,    47,    48,    49,    -1,
+    51,    52,    53,    54,    -1,    56,    -1,    -1,    -1,    -1,
+    -1,    62,    -1,    -1,    65,    66,    67,    -1,    -1,    -1,
+    71,    72,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    84,    85,    86,    87,    88,    89,    90,
+    -1,    -1,    -1,    -1,    -1,    96,    97,    44,    45,    46,
+    47,    48,    49,    -1,    51,    52,    53,    54,    -1,    -1,
+    -1,    -1,    59,    -1,    -1,    62,    -1,    -1,    65,    66,
+    67,    -1,    -1,    -1,    71,    72,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    84,    85,    86,
+    87,    88,    89,    90,    -1,    -1,    -1,    -1,    -1,    96,
+    97,    44,    45,    46,    47,    48,    49,    -1,    51,    52,
+    53,    54,    -1,    -1,    -1,    -1,    59,    -1,    -1,    62,
+    -1,    -1,    65,    66,    67,    -1,    -1,    -1,    71,    72,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    84,    85,    86,    87,    88,    89,    90,    -1,    -1,
+    -1,    -1,    -1,    96,    97,    44,    45,    46,    47,    48,
+    49,    -1,    51,    52,    53,    54,    -1,    -1,    -1,    -1,
+    59,    -1,    -1,    62,    -1,    -1,    65,    66,    67,    -1,
+    -1,    -1,    71,    72,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    84,    85,    86,    87,    88,
+    89,    90,    -1,    -1,    -1,    -1,    -1,    96,    97,    44,
+    45,    46,    47,    48,    49,    -1,    51,    52,    53,    54,
+    -1,    -1,    -1,    -1,    59,    -1,    -1,    62,    -1,    -1,
+    65,    66,    67,    -1,    -1,    -1,    71,    72,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    84,
+    85,    86,    87,    88,    89,    90,    -1,    -1,    -1,    -1,
+    -1,    96,    97,    44,    45,    46,    47,    48,    49,    -1,
+    51,    52,    53,    54,    -1,    -1,    -1,    -1,    59,    -1,
+    -1,    62,    -1,    -1,    65,    66,    67,    -1,    -1,    -1,
+    71,    72,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    84,    85,    86,    87,    88,    89,    90,
+    -1,    -1,    -1,    -1,    -1,    96,    97,    44,    45,    46,
+    47,    48,    49,    -1,    51,    52,    53,    54,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    62,    -1,    -1,    65,    66,
+    67,    -1,    -1,    -1,    71,    72,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    84,    85,    86,
+    87,    88,    89,    90,    -1,    -1,    -1,    -1,    -1,    96,
+    97,    44,    45,    46,    47,    48,    49,    -1,    51,    52,
+    53,    54,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    62,
+    -1,    -1,    65,    66,    67,    -1,    -1,    -1,    71,    72,
+    44,    45,    46,    47,    48,    49,    -1,    51,    52,    53,
+    54,    84,    85,    86,    87,    88,    89,    90,    62,    -1,
+    -1,    65,    66,    67,    97,    -1,    -1,    71,    72,    44,
+    45,    46,    47,    48,    49,    -1,    51,    52,    53,    54,
+    84,    85,    86,    87,    88,    -1,    90,    62,    -1,    -1,
+    65,    66,    67,    97,    -1,    -1,    71,    72,    44,    45,
+    46,    47,    48,    49,    -1,    51,    -1,    53,    54,    84,
+    85,    86,    87,    -1,    -1,    90,    62,    -1,    -1,    65,
+    66,    67,    97,    -1,    -1,    71,    72,    44,    45,    46,
+    47,    48,    49,    -1,    51,    -1,    53,    54,    84,    85,
+    86,    87,    -1,    -1,    90,    -1,    -1,    -1,    65,    66,
+    67,    97,    -1,    -1,    71,    72,    44,    45,    46,    47,
+    48,    49,    -1,    51,    -1,    -1,    54,    84,    85,    86,
+    87,    -1,    -1,    90,    -1,    -1,    -1,    65,    66,    67,
+    97,    -1,    -1,    71,    72,    44,    45,    46,    47,    48,
+    49,    -1,    51,    -1,    -1,    54,    84,    85,    86,    87,
+    -1,    -1,    90,    -1,    -1,    -1,    65,    66,    67,    97,
+    -1,    -1,    71,    72,    44,    45,    46,    47,    -1,    -1,
+    -1,    51,    -1,    -1,    54,    50,    -1,    86,    87,    -1,
+    -1,    90,    -1,    -1,    -1,    65,    66,    67,    97,    -1,
+    -1,    71,    72,    68,    69,    50,    -1,    -1,    73,    74,
+    75,    76,    77,    78,    79,    80,    81,    82,    -1,    -1,
+    90,    -1,    -1,    68,    69,    -1,    -1,    97,    73,    74,
+    75,    76,    77,    78,    79,    80,    81,    82,    44,    45,
+    46,    47,    -1,    -1,    -1,    51,    -1,    -1,    54,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    66,    67,    -1,    -1,    -1,    71,    72
 };
 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
 #line 3 "bison.simple"
 
 /* Skeleton output parser for bison,
-Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
+   Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
-any later version.
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
 
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
 /* As a special exception, when this file is copied by Bison into a
-Bison output file, you may use that output file without restriction.
-This special exception was added by the Free Software Foundation
-in version 1.24 of Bison.  */
+   Bison output file, you may use that output file without restriction.
+   This special exception was added by the Free Software Foundation
+   in version 1.24 of Bison.  */
 
 #ifndef alloca
 #ifdef __GNUC__
@@ -1175,15 +1116,15 @@ in version 1.24 of Bison.  */
 #else /* not MSDOS, or __TURBOC__ */
 #if defined(_AIX)
 #include <malloc.h>
-#pragma alloca
+ #pragma alloca
 #else /* not MSDOS, __TURBOC__, or _AIX */
 #ifdef __hpux
 #ifdef __cplusplus
 extern "C" {
-   void *alloca(unsigned int);
+void *alloca (unsigned int);
 };
 #else /* not __cplusplus */
-void *alloca();
+void *alloca ();
 #endif /* not __cplusplus */
 #endif /* __hpux */
 #endif /* not _AIX */
@@ -1193,13 +1134,13 @@ void *alloca();
 #endif /* alloca not defined.  */
 
 /* This is the parser code that is written into each bison parser
-when the %semantic_parser declaration is not specified in the grammar.
-It was written by Richard Stallman by simplifying the hairy parser
-used when %semantic_parser is specified.  */
+  when the %semantic_parser declaration is not specified in the grammar.
+  It was written by Richard Stallman by simplifying the hairy parser
+  used when %semantic_parser is specified.  */
 
 /* Note: there must be only one dollar sign in this file.
-It is replaced by the list of actions, each action
-as one case of the switch.  */
+   It is replaced by the list of actions, each action
+   as one case of the switch.  */
 
 #define yyerrok		(yyerrstatus = 0)
 #define yyclearin	(yychar = YYEMPTY)
@@ -1209,9 +1150,9 @@ as one case of the switch.  */
 #define YYABORT 	return(1)
 #define YYERROR		goto yyerrlab1
 /* Like YYERROR except do call yyerror.
-This remains here temporarily to ease the
-transition to the new meaning of YYERROR, for GCC.
-Once GCC version 2 has supplanted version 1, this can go.  */
+   This remains here temporarily to ease the
+   transition to the new meaning of YYERROR, for GCC.
+   Once GCC version 2 has supplanted version 1, this can go.  */
 #define YYFAIL		goto yyerrlab
 #define YYRECOVERING()  (!!yyerrstatus)
 #define YYBACKUP(token, value) \
@@ -1255,11 +1196,11 @@ while (0)
 
 int	yychar;			/*  the lookahead symbol		*/
 YYSTYPE	yylval;			/*  the semantic value of the		*/
-                        /*  lookahead symbol			*/
+				/*  lookahead symbol			*/
 
 #ifdef YYLSP_NEEDED
 YYLTYPE yylloc;			/*  location data for the lookahead	*/
-                        /*  symbol				*/
+				/*  symbol				*/
 #endif
 
 int yynerrs;			/*  number of parse errors so far       */
@@ -1267,18 +1208,18 @@ int yynerrs;			/*  number of parse errors so far       */
 
 #if YYDEBUG != 0
 int yydebug;			/*  nonzero means print parse trace	*/
-                     /* Since this is uninitialized, it does not stop multiple parsers
-                     from coexisting.  */
+/* Since this is uninitialized, it does not stop multiple parsers
+   from coexisting.  */
 #endif
 
-                     /*  YYINITDEPTH indicates the initial size of the parser's stacks	*/
+/*  YYINITDEPTH indicates the initial size of the parser's stacks	*/
 
 #ifndef	YYINITDEPTH
 #define YYINITDEPTH 200
 #endif
 
-                     /*  YYMAXDEPTH is the maximum size the stacks can grow to
-                     (effective only if the built-in stack extension method is used).  */
+/*  YYMAXDEPTH is the maximum size the stacks can grow to
+    (effective only if the built-in stack extension method is used).  */
 
 #if YYMAXDEPTH == 0
 #undef YYMAXDEPTH
@@ -1288,57 +1229,57 @@ int yydebug;			/*  nonzero means print parse trace	*/
 #define YYMAXDEPTH 10000
 #endif
 
-                     /* Prevent warning if -Wstrict-prototypes.  */
+/* Prevent warning if -Wstrict-prototypes.  */
 #ifdef __GNUC__
-int yyparse(void);
+int yyparse (void);
 #endif
-
+
 #if __GNUC__ > 1		/* GNU C and GNU C++ define this.  */
 #define __yy_memcpy(FROM,TO,COUNT)	__builtin_memcpy(TO,FROM,COUNT)
 #else				/* not GNU C or C++ */
 #ifndef __cplusplus
 
 /* This is the most reliable way to avoid incompatibilities
-in available built-in functions on various systems.  */
+   in available built-in functions on various systems.  */
 static void
-__yy_memcpy(from, to, count)
-char *from;
-char *to;
-int count;
+__yy_memcpy (from, to, count)
+     char *from;
+     char *to;
+     int count;
 {
-   register char *f = from;
-   register char *t = to;
-   register int i = count;
+  register char *f = from;
+  register char *t = to;
+  register int i = count;
 
-   while (i-- > 0)
-      *t++ = *f++;
+  while (i-- > 0)
+    *t++ = *f++;
 }
 
 #else /* __cplusplus */
 
 /* This is the most reliable way to avoid incompatibilities
-in available built-in functions on various systems.  */
+   in available built-in functions on various systems.  */
 static void
-__yy_memcpy(char *from, char *to, int count)
+__yy_memcpy (char *from, char *to, int count)
 {
-   register char *f = from;
-   register char *t = to;
-   register int i = count;
+  register char *f = from;
+  register char *t = to;
+  register int i = count;
 
-   while (i-- > 0)
-      *t++ = *f++;
+  while (i-- > 0)
+    *t++ = *f++;
 }
 
 #endif
 #endif
-
+
 #line 192 "bison.simple"
 
 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
-into yyparse.  The argument should have type void *.
-It should actually point to an object.
-Grammar actions can access the variable by casting it
-to the proper pointer type.  */
+   into yyparse.  The argument should have type void *.
+   It should actually point to an object.
+   Grammar actions can access the variable by casting it
+   to the proper pointer type.  */
 
 #ifdef YYPARSE_PARAM
 #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
@@ -1349,78 +1290,78 @@ to the proper pointer type.  */
 
 int
 yyparse(YYPARSE_PARAM)
-YYPARSE_PARAM_DECL
+     YYPARSE_PARAM_DECL
 {
-   register int yystate;
-   register int yyn;
-   register short *yyssp;
-   register YYSTYPE *yyvsp;
-   int yyerrstatus;	/*  number of tokens to shift before error messages enabled */
-   int yychar1 = 0;		/*  lookahead token as an internal (translated) token number */
+  register int yystate;
+  register int yyn;
+  register short *yyssp;
+  register YYSTYPE *yyvsp;
+  int yyerrstatus;	/*  number of tokens to shift before error messages enabled */
+  int yychar1 = 0;		/*  lookahead token as an internal (translated) token number */
 
-   short	yyssa[YYINITDEPTH];	/*  the state stack			*/
-   YYSTYPE yyvsa[YYINITDEPTH];	/*  the semantic value stack		*/
+  short	yyssa[YYINITDEPTH];	/*  the state stack			*/
+  YYSTYPE yyvsa[YYINITDEPTH];	/*  the semantic value stack		*/
 
-   short *yyss = yyssa;		/*  refer to the stacks thru separate pointers */
-   YYSTYPE *yyvs = yyvsa;	/*  to allow yyoverflow to reallocate them elsewhere */
+  short *yyss = yyssa;		/*  refer to the stacks thru separate pointers */
+  YYSTYPE *yyvs = yyvsa;	/*  to allow yyoverflow to reallocate them elsewhere */
 
 #ifdef YYLSP_NEEDED
-   YYLTYPE yylsa[YYINITDEPTH];	/*  the location stack			*/
-   YYLTYPE *yyls = yylsa;
-   YYLTYPE *yylsp;
+  YYLTYPE yylsa[YYINITDEPTH];	/*  the location stack			*/
+  YYLTYPE *yyls = yylsa;
+  YYLTYPE *yylsp;
 
 #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
 #else
 #define YYPOPSTACK   (yyvsp--, yyssp--)
 #endif
 
-   int yystacksize = YYINITDEPTH;
+  int yystacksize = YYINITDEPTH;
 
 #ifdef YYPURE
-   int yychar;
-   YYSTYPE yylval;
-   int yynerrs;
+  int yychar;
+  YYSTYPE yylval;
+  int yynerrs;
 #ifdef YYLSP_NEEDED
-   YYLTYPE yylloc;
+  YYLTYPE yylloc;
 #endif
 #endif
 
-   YYSTYPE yyval;		/*  the variable used to return		*/
-                     /*  semantic values from the action	*/
-                     /*  routines				*/
+  YYSTYPE yyval;		/*  the variable used to return		*/
+				/*  semantic values from the action	*/
+				/*  routines				*/
 
-   int yylen;
+  int yylen;
 
 #if YYDEBUG != 0
-   if (yydebug)
-      fprintf(stderr, "Starting parse\n");
+  if (yydebug)
+    fprintf(stderr, "Starting parse\n");
 #endif
 
-   yystate = 0;
-   yyerrstatus = 0;
-   yynerrs = 0;
-   yychar = YYEMPTY;		/* Cause a token to be read.  */
+  yystate = 0;
+  yyerrstatus = 0;
+  yynerrs = 0;
+  yychar = YYEMPTY;		/* Cause a token to be read.  */
 
-                        /* Initialize stack pointers.
-                        Waste one element of value and location stack
-                        so that they stay on the same level as the state stack.
-                        The wasted elements are never initialized.  */
+  /* Initialize stack pointers.
+     Waste one element of value and location stack
+     so that they stay on the same level as the state stack.
+     The wasted elements are never initialized.  */
 
-   yyssp = yyss - 1;
-   yyvsp = yyvs;
+  yyssp = yyss - 1;
+  yyvsp = yyvs;
 #ifdef YYLSP_NEEDED
-   yylsp = yyls;
+  yylsp = yyls;
 #endif
 
-   /* Push a new state, which is found in  yystate  .  */
-   /* In all cases, when you get here, the value and location stacks
+/* Push a new state, which is found in  yystate  .  */
+/* In all cases, when you get here, the value and location stacks
    have just been pushed. so pushing a state here evens the stacks.  */
 yynewstate:
 
-   *++yyssp = yystate;
+  *++yyssp = yystate;
 
-   if (yyssp >= yyss + yystacksize - 1)
-   {
+  if (yyssp >= yyss + yystacksize - 1)
+    {
       /* Give user a chance to reallocate the stack */
       /* Use copies of these so that the &'s don't force the real ones into memory. */
       YYSTYPE *yyvs1 = yyvs;
@@ -1434,20 +1375,20 @@ yynewstate:
 
 #ifdef yyoverflow
       /* Each stack pointer address is followed by the size of
-      the data in use in that stack, in bytes.  */
+	 the data in use in that stack, in bytes.  */
 #ifdef YYLSP_NEEDED
       /* This used to be a conditional around just the two extra args,
-      but that might be undefined if yyoverflow is a macro.  */
+	 but that might be undefined if yyoverflow is a macro.  */
       yyoverflow("parser stack overflow",
-         &yyss1, size * sizeof(*yyssp),
-         &yyvs1, size * sizeof(*yyvsp),
-         &yyls1, size * sizeof(*yylsp),
-         &yystacksize);
+		 &yyss1, size * sizeof (*yyssp),
+		 &yyvs1, size * sizeof (*yyvsp),
+		 &yyls1, size * sizeof (*yylsp),
+		 &yystacksize);
 #else
       yyoverflow("parser stack overflow",
-         &yyss1, size * sizeof(*yyssp),
-         &yyvs1, size * sizeof(*yyvsp),
-         &yystacksize);
+		 &yyss1, size * sizeof (*yyssp),
+		 &yyvs1, size * sizeof (*yyvsp),
+		 &yystacksize);
 #endif
 
       yyss = yyss1; yyvs = yyvs1;
@@ -1457,20 +1398,20 @@ yynewstate:
 #else /* no yyoverflow */
       /* Extend the stack our own way.  */
       if (yystacksize >= YYMAXDEPTH)
-      {
-         yyerror("parser stack overflow");
-         return 2;
-      }
+	{
+	  yyerror("parser stack overflow");
+	  return 2;
+	}
       yystacksize *= 2;
       if (yystacksize > YYMAXDEPTH)
-         yystacksize = YYMAXDEPTH;
-      yyss = (short *)alloca(yystacksize * sizeof(*yyssp));
-      __yy_memcpy((char *)yyss1, (char *)yyss, size * sizeof(*yyssp));
-      yyvs = (YYSTYPE *)alloca(yystacksize * sizeof(*yyvsp));
-      __yy_memcpy((char *)yyvs1, (char *)yyvs, size * sizeof(*yyvsp));
+	yystacksize = YYMAXDEPTH;
+      yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
+      __yy_memcpy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
+      yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
+      __yy_memcpy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
 #ifdef YYLSP_NEEDED
-      yyls = (YYLTYPE *)alloca(yystacksize * sizeof(*yylsp));
-      __yy_memcpy((char *)yyls1, (char *)yyls, size * sizeof(*yylsp));
+      yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
+      __yy_memcpy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
 #endif
 #endif /* no yyoverflow */
 
@@ -1482,995 +1423,972 @@ yynewstate:
 
 #if YYDEBUG != 0
       if (yydebug)
-         fprintf(stderr, "Stack size increased to %d\n", yystacksize);
+	fprintf(stderr, "Stack size increased to %d\n", yystacksize);
 #endif
 
       if (yyssp >= yyss + yystacksize - 1)
-         YYABORT;
-   }
+	YYABORT;
+    }
 
 #if YYDEBUG != 0
-   if (yydebug)
-      fprintf(stderr, "Entering state %d\n", yystate);
+  if (yydebug)
+    fprintf(stderr, "Entering state %d\n", yystate);
 #endif
 
-   goto yybackup;
-yybackup:
+  goto yybackup;
+ yybackup:
 
-   /* Do appropriate processing given the current state.  */
-   /* Read a lookahead token if we need one and don't already have one.  */
-   /* yyresume: */
+/* Do appropriate processing given the current state.  */
+/* Read a lookahead token if we need one and don't already have one.  */
+/* yyresume: */
 
-   /* First try to decide what to do without reference to lookahead token.  */
+  /* First try to decide what to do without reference to lookahead token.  */
 
-   yyn = yypact[yystate];
-   if (yyn == YYFLAG)
-      goto yydefault;
+  yyn = yypact[yystate];
+  if (yyn == YYFLAG)
+    goto yydefault;
 
-   /* Not known => get a lookahead token if don't already have one.  */
+  /* Not known => get a lookahead token if don't already have one.  */
 
-   /* yychar is either YYEMPTY or YYEOF
-   or a valid token in external form.  */
+  /* yychar is either YYEMPTY or YYEOF
+     or a valid token in external form.  */
 
-   if (yychar == YYEMPTY)
-   {
+  if (yychar == YYEMPTY)
+    {
 #if YYDEBUG != 0
       if (yydebug)
-         fprintf(stderr, "Reading a token: ");
+	fprintf(stderr, "Reading a token: ");
 #endif
       yychar = YYLEX;
-   }
+    }
 
-   /* Convert token to internal form (in yychar1) for indexing tables with */
+  /* Convert token to internal form (in yychar1) for indexing tables with */
 
-   if (yychar <= 0)		/* This means end of input. */
-   {
+  if (yychar <= 0)		/* This means end of input. */
+    {
       yychar1 = 0;
       yychar = YYEOF;		/* Don't call YYLEX any more */
 
 #if YYDEBUG != 0
       if (yydebug)
-         fprintf(stderr, "Now at end of input.\n");
+	fprintf(stderr, "Now at end of input.\n");
 #endif
-   }
-   else
-   {
+    }
+  else
+    {
       yychar1 = YYTRANSLATE(yychar);
 
 #if YYDEBUG != 0
       if (yydebug)
-      {
-         fprintf(stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
-         /* Give the individual parser a way to print the precise meaning
-         of a token, for further debugging info.  */
+	{
+	  fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
+	  /* Give the individual parser a way to print the precise meaning
+	     of a token, for further debugging info.  */
 #ifdef YYPRINT
-         YYPRINT(stderr, yychar, yylval);
+	  YYPRINT (stderr, yychar, yylval);
 #endif
-         fprintf(stderr, ")\n");
-      }
+	  fprintf (stderr, ")\n");
+	}
 #endif
-   }
+    }
 
-   yyn += yychar1;
-   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
-      goto yydefault;
+  yyn += yychar1;
+  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
+    goto yydefault;
 
-   yyn = yytable[yyn];
+  yyn = yytable[yyn];
 
-   /* yyn is what to do for this token type in this state.
-   Negative => reduce, -yyn is rule number.
-   Positive => shift, yyn is new state.
-   New state is final state => don't bother to shift,
-   just return success.
-   0, or most negative number => error.  */
+  /* yyn is what to do for this token type in this state.
+     Negative => reduce, -yyn is rule number.
+     Positive => shift, yyn is new state.
+       New state is final state => don't bother to shift,
+       just return success.
+     0, or most negative number => error.  */
 
-   if (yyn < 0)
-   {
+  if (yyn < 0)
+    {
       if (yyn == YYFLAG)
-         goto yyerrlab;
+	goto yyerrlab;
       yyn = -yyn;
       goto yyreduce;
-   }
-   else if (yyn == 0)
-      goto yyerrlab;
+    }
+  else if (yyn == 0)
+    goto yyerrlab;
 
-   if (yyn == YYFINAL)
-      YYACCEPT;
+  if (yyn == YYFINAL)
+    YYACCEPT;
 
-   /* Shift the lookahead token.  */
+  /* Shift the lookahead token.  */
 
 #if YYDEBUG != 0
-   if (yydebug)
-      fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
+  if (yydebug)
+    fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
 #endif
 
-   /* Discard the token being shifted unless it is eof.  */
-   if (yychar != YYEOF)
-      yychar = YYEMPTY;
+  /* Discard the token being shifted unless it is eof.  */
+  if (yychar != YYEOF)
+    yychar = YYEMPTY;
 
-   *++yyvsp = yylval;
+  *++yyvsp = yylval;
 #ifdef YYLSP_NEEDED
-   *++yylsp = yylloc;
+  *++yylsp = yylloc;
 #endif
 
-   /* count tokens shifted since error; after three, turn off error status.  */
-   if (yyerrstatus) yyerrstatus--;
+  /* count tokens shifted since error; after three, turn off error status.  */
+  if (yyerrstatus) yyerrstatus--;
 
-   yystate = yyn;
-   goto yynewstate;
+  yystate = yyn;
+  goto yynewstate;
 
-   /* Do the default action for the current state.  */
+/* Do the default action for the current state.  */
 yydefault:
 
-   yyn = yydefact[yystate];
-   if (yyn == 0)
-      goto yyerrlab;
+  yyn = yydefact[yystate];
+  if (yyn == 0)
+    goto yyerrlab;
 
-   /* Do a reduction.  yyn is the number of a rule to reduce with.  */
+/* Do a reduction.  yyn is the number of a rule to reduce with.  */
 yyreduce:
-   yylen = yyr2[yyn];
-   if (yylen > 0)
-      yyval = yyvsp[1 - yylen]; /* implement default value of the action */
+  yylen = yyr2[yyn];
+  if (yylen > 0)
+    yyval = yyvsp[1-yylen]; /* implement default value of the action */
 
 #if YYDEBUG != 0
-   if (yydebug)
-   {
+  if (yydebug)
+    {
       int i;
 
-      fprintf(stderr, "Reducing via rule %d (line %d), ",
-         yyn, yyrline[yyn]);
+      fprintf (stderr, "Reducing via rule %d (line %d), ",
+	       yyn, yyrline[yyn]);
 
       /* Print the symbols being reduced, and their result.  */
       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
-         fprintf(stderr, "%s ", yytname[yyrhs[i]]);
-      fprintf(stderr, " -> %s\n", yytname[yyr1[yyn]]);
-   }
+	fprintf (stderr, "%s ", yytname[yyrhs[i]]);
+      fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
+    }
 #endif
 
 
-   switch (yyn) {
+  switch (yyn) {
 
-      case 1:
+case 1:
 #line 162 "cmdgram.y"
-      {;
-      break; }
-      case 2:
+{ ;
+    break;}
+case 2:
 #line 167 "cmdgram.y"
-      { yyval.stmt = nil; ;
-      break; }
-      case 3:
+{ yyval.stmt = nil; ;
+    break;}
+case 3:
 #line 169 "cmdgram.y"
-      { if (!gStatementList) { gStatementList = yyvsp[0].stmt; }
-      else { gStatementList->append(yyvsp[0].stmt); };
-      break; }
-      case 4:
+{ if(!gStatementList) { gStatementList = yyvsp[0].stmt; } else { gStatementList->append(yyvsp[0].stmt); } ;
+    break;}
+case 4:
 #line 174 "cmdgram.y"
-      { yyval.stmt = yyvsp[0].stmt; ;
-      break; }
-      case 5:
+{ yyval.stmt = yyvsp[0].stmt; ;
+    break;}
+case 5:
 #line 176 "cmdgram.y"
-      { yyval.stmt = yyvsp[0].stmt; ;
-      break; }
-      case 6:
+{ yyval.stmt = yyvsp[0].stmt; ;
+    break;}
+case 6:
 #line 178 "cmdgram.y"
-      { yyval.stmt = yyvsp[0].stmt; ;
-      break; }
-      case 7:
+{ yyval.stmt = yyvsp[0].stmt; ;
+    break;}
+case 7:
 #line 183 "cmdgram.y"
-      { yyval.stmt = yyvsp[-2].stmt; for (StmtNode *walk = (yyvsp[-2].stmt); walk; walk = walk->getNext()) walk->setPackage(yyvsp[-4].s.value); ;
-      break; }
-      case 8:
+{ yyval.stmt = yyvsp[-2].stmt; for(StmtNode *walk = (yyvsp[-2].stmt);walk;walk = walk->getNext() ) walk->setPackage(yyvsp[-4].s.value); ;
+    break;}
+case 8:
 #line 188 "cmdgram.y"
-      { yyval.stmt = yyvsp[0].stmt; ;
-      break; }
-      case 9:
+{ yyval.stmt = yyvsp[0].stmt; ;
+    break;}
+case 9:
 #line 190 "cmdgram.y"
-      { yyval.stmt = yyvsp[-1].stmt; (yyvsp[-1].stmt)->append(yyvsp[0].stmt); ;
-      break; }
-      case 10:
+{ yyval.stmt = yyvsp[-1].stmt; (yyvsp[-1].stmt)->append(yyvsp[0].stmt);  ;
+    break;}
+case 10:
 #line 195 "cmdgram.y"
-      { yyval.stmt = nil; ;
-      break; }
-      case 11:
+{ yyval.stmt = nil; ;
+    break;}
+case 11:
 #line 197 "cmdgram.y"
-      { if (!yyvsp[-1].stmt) { yyval.stmt = yyvsp[0].stmt; }
-      else { (yyvsp[-1].stmt)->append(yyvsp[0].stmt); yyval.stmt = yyvsp[-1].stmt; };
-      break; }
-      case 18:
+{ if(!yyvsp[-1].stmt) { yyval.stmt = yyvsp[0].stmt; } else { (yyvsp[-1].stmt)->append(yyvsp[0].stmt); yyval.stmt = yyvsp[-1].stmt; } ;
+    break;}
+case 18:
 #line 208 "cmdgram.y"
-      { yyval.stmt = BreakStmtNode::alloc(yyvsp[-1].i.lineNumber); ;
-      break; }
-      case 19:
+{ yyval.stmt = BreakStmtNode::alloc( yyvsp[-1].i.lineNumber ); ;
+    break;}
+case 19:
 #line 210 "cmdgram.y"
-      { yyval.stmt = ContinueStmtNode::alloc(yyvsp[-1].i.lineNumber); ;
-      break; }
-      case 20:
+{ yyval.stmt = ContinueStmtNode::alloc( yyvsp[-1].i.lineNumber ); ;
+    break;}
+case 20:
 #line 212 "cmdgram.y"
-      { yyval.stmt = ReturnStmtNode::alloc(yyvsp[-1].i.lineNumber, NULL); ;
-      break; }
-      case 21:
+{ yyval.stmt = ReturnStmtNode::alloc( yyvsp[-1].i.lineNumber, NULL ); ;
+    break;}
+case 21:
 #line 214 "cmdgram.y"
-      { yyval.stmt = ReturnStmtNode::alloc(yyvsp[-2].i.lineNumber, yyvsp[-1].expr); ;
-      break; }
-      case 22:
+{ yyval.stmt = ReturnStmtNode::alloc( yyvsp[-2].i.lineNumber, yyvsp[-1].expr ); ;
+    break;}
+case 22:
 #line 216 "cmdgram.y"
-      { yyval.stmt = yyvsp[-1].stmt; ;
-      break; }
-      case 23:
+{ yyval.stmt = yyvsp[-1].stmt; ;
+    break;}
+case 23:
 #line 218 "cmdgram.y"
-      { yyval.stmt = TTagSetStmtNode::alloc(yyvsp[-3].s.lineNumber, yyvsp[-3].s.value, yyvsp[-1].expr, NULL); ;
-      break; }
-      case 24:
+{ yyval.stmt = TTagSetStmtNode::alloc( yyvsp[-3].s.lineNumber, yyvsp[-3].s.value, yyvsp[-1].expr, NULL ); ;
+    break;}
+case 24:
 #line 220 "cmdgram.y"
-      { yyval.stmt = TTagSetStmtNode::alloc(yyvsp[-5].s.lineNumber, yyvsp[-5].s.value, yyvsp[-3].expr, yyvsp[-1].expr); ;
-      break; }
-      case 25:
+{ yyval.stmt = TTagSetStmtNode::alloc( yyvsp[-5].s.lineNumber, yyvsp[-5].s.value, yyvsp[-3].expr, yyvsp[-1].expr ); ;
+    break;}
+case 25:
 #line 222 "cmdgram.y"
-      { yyval.stmt = StrConstNode::alloc(yyvsp[0].str.lineNumber, yyvsp[0].str.value, false, true); ;
-      break; }
-      case 26:
+{ yyval.stmt = StrConstNode::alloc( yyvsp[0].str.lineNumber, yyvsp[0].str.value, false, true ); ;
+    break;}
+case 26:
 #line 227 "cmdgram.y"
-      { yyval.stmt = FunctionDeclStmtNode::alloc(yyvsp[-7].i.lineNumber, yyvsp[-6].s.value, NULL, yyvsp[-4].var, yyvsp[-1].stmt); ;
-      break; }
-      case 27:
+{ yyval.stmt = FunctionDeclStmtNode::alloc( yyvsp[-7].i.lineNumber, yyvsp[-6].s.value, NULL, yyvsp[-4].var, yyvsp[-1].stmt ); ;
+    break;}
+case 27:
 #line 229 "cmdgram.y"
-      { yyval.stmt = FunctionDeclStmtNode::alloc(yyvsp[-9].i.lineNumber, yyvsp[-6].s.value, yyvsp[-8].s.value, yyvsp[-4].var, yyvsp[-1].stmt); ;
-      break; }
-      case 28:
+{ yyval.stmt = FunctionDeclStmtNode::alloc( yyvsp[-9].i.lineNumber, yyvsp[-6].s.value, yyvsp[-8].s.value, yyvsp[-4].var, yyvsp[-1].stmt ); ;
+    break;}
+case 28:
 #line 234 "cmdgram.y"
-      { yyval.var = NULL; ;
-      break; }
-      case 29:
+{ yyval.var = NULL; ;
+    break;}
+case 29:
 #line 236 "cmdgram.y"
-      { yyval.var = yyvsp[0].var; ;
-      break; }
-      case 30:
+{ yyval.var = yyvsp[0].var; ;
+    break;}
+case 30:
 #line 241 "cmdgram.y"
-      { yyval.var = VarNode::alloc(yyvsp[0].s.lineNumber, yyvsp[0].s.value, NULL); ;
-      break; }
-      case 31:
+{ yyval.var = VarNode::alloc( yyvsp[0].s.lineNumber, yyvsp[0].s.value, NULL ); ;
+    break;}
+case 31:
 #line 243 "cmdgram.y"
-      { yyval.var = yyvsp[-2].var; ((StmtNode*)(yyvsp[-2].var))->append((StmtNode*)VarNode::alloc(yyvsp[0].s.lineNumber, yyvsp[0].s.value, NULL)); ;
-      break; }
-      case 32:
+{ yyval.var = yyvsp[-2].var; ((StmtNode*)(yyvsp[-2].var))->append((StmtNode*)VarNode::alloc( yyvsp[0].s.lineNumber, yyvsp[0].s.value, NULL ) ); ;
+    break;}
+case 32:
 #line 248 "cmdgram.y"
-      { yyval.stmt = ObjectDeclNode::alloc(yyvsp[-9].i.lineNumber, yyvsp[-8].expr, yyvsp[-6].expr, NULL, yyvsp[-5].s.value, yyvsp[-2].slist, NULL, true, false, false); ;
-      break; }
-      case 33:
+{ yyval.stmt = ObjectDeclNode::alloc( yyvsp[-9].i.lineNumber, yyvsp[-8].expr, yyvsp[-6].expr, NULL, yyvsp[-5].s.value, yyvsp[-2].slist, NULL, true, false, false); ;
+    break;}
+case 33:
 #line 253 "cmdgram.y"
-      { yyval.od = ObjectDeclNode::alloc(yyvsp[-9].i.lineNumber, yyvsp[-8].expr, yyvsp[-6].expr, yyvsp[-4].expr, yyvsp[-5].s.value, yyvsp[-1].odcl.slots, yyvsp[-1].odcl.decls, false, false, false); ;
-      break; }
-      case 34:
+{ yyval.od = ObjectDeclNode::alloc( yyvsp[-9].i.lineNumber, yyvsp[-8].expr, yyvsp[-6].expr, yyvsp[-4].expr, yyvsp[-5].s.value, yyvsp[-1].odcl.slots, yyvsp[-1].odcl.decls, false, false, false); ;
+    break;}
+case 34:
 #line 255 "cmdgram.y"
-      { yyval.od = ObjectDeclNode::alloc(yyvsp[-6].i.lineNumber, yyvsp[-5].expr, yyvsp[-3].expr, yyvsp[-1].expr, yyvsp[-2].s.value, NULL, NULL, false, false, false); ;
-      break; }
-      case 35:
+{ yyval.od = ObjectDeclNode::alloc( yyvsp[-6].i.lineNumber, yyvsp[-5].expr, yyvsp[-3].expr, yyvsp[-1].expr, yyvsp[-2].s.value, NULL, NULL, false, false, false); ;
+    break;}
+case 35:
 #line 257 "cmdgram.y"
-      { yyval.od = ObjectDeclNode::alloc(yyvsp[-11].i.lineNumber, yyvsp[-10].expr, yyvsp[-7].expr, yyvsp[-4].expr, yyvsp[-5].s.value, yyvsp[-1].odcl.slots, yyvsp[-1].odcl.decls, false, true, false); ;
-      break; }
-      case 36:
+{ yyval.od = ObjectDeclNode::alloc( yyvsp[-11].i.lineNumber, yyvsp[-10].expr, yyvsp[-7].expr, yyvsp[-4].expr, yyvsp[-5].s.value, yyvsp[-1].odcl.slots, yyvsp[-1].odcl.decls, false, true, false); ;
+    break;}
+case 36:
 #line 259 "cmdgram.y"
-      { yyval.od = ObjectDeclNode::alloc(yyvsp[-8].i.lineNumber, yyvsp[-7].expr, yyvsp[-4].expr, yyvsp[-1].expr, yyvsp[-2].s.value, NULL, NULL, false, true, false); ;
-      break; }
-      case 37:
+{ yyval.od = ObjectDeclNode::alloc( yyvsp[-8].i.lineNumber, yyvsp[-7].expr, yyvsp[-4].expr, yyvsp[-1].expr, yyvsp[-2].s.value, NULL, NULL, false, true, false); ;
+    break;}
+case 37:
 #line 261 "cmdgram.y"
-      { yyval.od = ObjectDeclNode::alloc(yyvsp[-9].i.lineNumber, yyvsp[-8].expr, yyvsp[-6].expr, yyvsp[-4].expr, yyvsp[-5].s.value, yyvsp[-1].odcl.slots, yyvsp[-1].odcl.decls, false, false, true); ;
-      break; }
-      case 38:
+{ yyval.od = ObjectDeclNode::alloc( yyvsp[-9].i.lineNumber, yyvsp[-8].expr, yyvsp[-6].expr, yyvsp[-4].expr, yyvsp[-5].s.value, yyvsp[-1].odcl.slots, yyvsp[-1].odcl.decls, false, false, true); ;
+    break;}
+case 38:
 #line 263 "cmdgram.y"
-      { yyval.od = ObjectDeclNode::alloc(yyvsp[-6].i.lineNumber, yyvsp[-5].expr, yyvsp[-3].expr, yyvsp[-1].expr, yyvsp[-2].s.value, NULL, NULL, false, false, true); ;
-      break; }
-      case 39:
+{ yyval.od = ObjectDeclNode::alloc( yyvsp[-6].i.lineNumber, yyvsp[-5].expr, yyvsp[-3].expr, yyvsp[-1].expr, yyvsp[-2].s.value, NULL, NULL, false, false, true); ;
+    break;}
+case 39:
 #line 268 "cmdgram.y"
-      { yyval.s.value = NULL; ;
-      break; }
-      case 40:
+{ yyval.s.value = NULL; ;
+    break;}
+case 40:
 #line 270 "cmdgram.y"
-      { yyval.s = yyvsp[0].s; ;
-      break; }
-      case 41:
+{ yyval.s = yyvsp[0].s; ;
+    break;}
+case 41:
 #line 275 "cmdgram.y"
-      { yyval.expr = StrConstNode::alloc(CodeBlock::smCurrentParser->getCurrentLine(), "", false); ;
-      break; }
-      case 42:
+{ yyval.expr = StrConstNode::alloc( CodeBlock::smCurrentParser->getCurrentLine(), "", false); ;
+    break;}
+case 42:
 #line 277 "cmdgram.y"
-      { yyval.expr = yyvsp[0].expr; ;
-      break; }
-      case 43:
+{ yyval.expr = yyvsp[0].expr; ;
+    break;}
+case 43:
 #line 282 "cmdgram.y"
-      { yyval.expr = NULL; ;
-      break; }
-      case 44:
+{ yyval.expr = NULL; ;
+    break;}
+case 44:
 #line 284 "cmdgram.y"
-      { yyval.expr = yyvsp[0].expr; ;
-      break; }
-      case 45:
+{ yyval.expr = yyvsp[0].expr; ;
+    break;}
+case 45:
 #line 289 "cmdgram.y"
-      { yyval.odcl.slots = NULL; yyval.odcl.decls = NULL; ;
-      break; }
-      case 46:
+{ yyval.odcl.slots = NULL; yyval.odcl.decls = NULL; ;
+    break;}
+case 46:
 #line 291 "cmdgram.y"
-      { yyval.odcl.slots = yyvsp[0].slist; yyval.odcl.decls = NULL; ;
-      break; }
-      case 47:
+{ yyval.odcl.slots = yyvsp[0].slist; yyval.odcl.decls = NULL; ;
+    break;}
+case 47:
 #line 293 "cmdgram.y"
-      { yyval.odcl.slots = NULL; yyval.odcl.decls = yyvsp[0].od; ;
-      break; }
-      case 48:
+{ yyval.odcl.slots = NULL; yyval.odcl.decls = yyvsp[0].od; ;
+    break;}
+case 48:
 #line 295 "cmdgram.y"
-      { yyval.odcl.slots = yyvsp[-1].slist; yyval.odcl.decls = yyvsp[0].od; ;
-      break; }
-      case 49:
+{ yyval.odcl.slots = yyvsp[-1].slist; yyval.odcl.decls = yyvsp[0].od; ;
+    break;}
+case 49:
 #line 300 "cmdgram.y"
-      { yyval.od = yyvsp[-1].od; ;
-      break; }
-      case 50:
+{ yyval.od = yyvsp[-1].od; ;
+    break;}
+case 50:
 #line 302 "cmdgram.y"
-      { yyvsp[-2].od->append(yyvsp[-1].od); yyval.od = yyvsp[-2].od; ;
-      break; }
-      case 51:
+{ yyvsp[-2].od->append(yyvsp[-1].od); yyval.od = yyvsp[-2].od; ;
+    break;}
+case 51:
 #line 307 "cmdgram.y"
-      { yyval.stmt = yyvsp[-1].stmt; ;
-      break; }
-      case 52:
+{ yyval.stmt = yyvsp[-1].stmt; ;
+    break;}
+case 52:
 #line 309 "cmdgram.y"
-      { yyval.stmt = yyvsp[0].stmt; ;
-      break; }
-      case 53:
+{ yyval.stmt = yyvsp[0].stmt; ;
+    break;}
+case 53:
 #line 314 "cmdgram.y"
-      { yyval.stmt = yyvsp[-1].ifnode; yyvsp[-1].ifnode->propagateSwitchExpr(yyvsp[-4].expr, false); ;
-      break; }
-      case 54:
+{ yyval.stmt = yyvsp[-1].ifnode; yyvsp[-1].ifnode->propagateSwitchExpr(yyvsp[-4].expr, false); ;
+    break;}
+case 54:
 #line 316 "cmdgram.y"
-      { yyval.stmt = yyvsp[-1].ifnode; yyvsp[-1].ifnode->propagateSwitchExpr(yyvsp[-4].expr, true); ;
-      break; }
-      case 55:
+{ yyval.stmt = yyvsp[-1].ifnode; yyvsp[-1].ifnode->propagateSwitchExpr(yyvsp[-4].expr, true); ;
+    break;}
+case 55:
 #line 321 "cmdgram.y"
-      { yyval.ifnode = IfStmtNode::alloc(yyvsp[-3].i.lineNumber, yyvsp[-2].expr, yyvsp[0].stmt, NULL, false); ;
-      break; }
-      case 56:
+{ yyval.ifnode = IfStmtNode::alloc( yyvsp[-3].i.lineNumber, yyvsp[-2].expr, yyvsp[0].stmt, NULL, false); ;
+    break;}
+case 56:
 #line 323 "cmdgram.y"
-      { yyval.ifnode = IfStmtNode::alloc(yyvsp[-6].i.lineNumber, yyvsp[-5].expr, yyvsp[-3].stmt, yyvsp[0].stmt, false); ;
-      break; }
-      case 57:
+{ yyval.ifnode = IfStmtNode::alloc( yyvsp[-6].i.lineNumber, yyvsp[-5].expr, yyvsp[-3].stmt, yyvsp[0].stmt, false); ;
+    break;}
+case 57:
 #line 325 "cmdgram.y"
-      { yyval.ifnode = IfStmtNode::alloc(yyvsp[-4].i.lineNumber, yyvsp[-3].expr, yyvsp[-1].stmt, yyvsp[0].ifnode, true); ;
-      break; }
-      case 58:
+{ yyval.ifnode = IfStmtNode::alloc( yyvsp[-4].i.lineNumber, yyvsp[-3].expr, yyvsp[-1].stmt, yyvsp[0].ifnode, true); ;
+    break;}
+case 58:
 #line 330 "cmdgram.y"
-      { yyval.expr = yyvsp[0].expr;;
-      break; }
-      case 59:
+{ yyval.expr = yyvsp[0].expr;;
+    break;}
+case 59:
 #line 332 "cmdgram.y"
-      { (yyvsp[-2].expr)->append(yyvsp[0].expr); yyval.expr = yyvsp[-2].expr; ;
-      break; }
-      case 60:
+{ (yyvsp[-2].expr)->append(yyvsp[0].expr); yyval.expr=yyvsp[-2].expr; ;
+    break;}
+case 60:
 #line 337 "cmdgram.y"
-      { yyval.stmt = IfStmtNode::alloc(yyvsp[-4].i.lineNumber, yyvsp[-2].expr, yyvsp[0].stmt, NULL, false); ;
-      break; }
-      case 61:
+{ yyval.stmt = IfStmtNode::alloc(yyvsp[-4].i.lineNumber, yyvsp[-2].expr, yyvsp[0].stmt, NULL, false); ;
+    break;}
+case 61:
 #line 339 "cmdgram.y"
-      { yyval.stmt = IfStmtNode::alloc(yyvsp[-6].i.lineNumber, yyvsp[-4].expr, yyvsp[-2].stmt, yyvsp[0].stmt, false); ;
-      break; }
-      case 62:
+{ yyval.stmt = IfStmtNode::alloc(yyvsp[-6].i.lineNumber, yyvsp[-4].expr, yyvsp[-2].stmt, yyvsp[0].stmt, false); ;
+    break;}
+case 62:
 #line 344 "cmdgram.y"
-      { yyval.stmt = LoopStmtNode::alloc(yyvsp[-4].i.lineNumber, nil, yyvsp[-2].expr, nil, yyvsp[0].stmt, false); ;
-      break; }
-      case 63:
+{ yyval.stmt = LoopStmtNode::alloc(yyvsp[-4].i.lineNumber, nil, yyvsp[-2].expr, nil, yyvsp[0].stmt, false); ;
+    break;}
+case 63:
 #line 346 "cmdgram.y"
-      { yyval.stmt = LoopStmtNode::alloc(yyvsp[-3].i.lineNumber, nil, yyvsp[-1].expr, nil, yyvsp[-4].stmt, true); ;
-      break; }
-      case 64:
+{ yyval.stmt = LoopStmtNode::alloc(yyvsp[-3].i.lineNumber, nil, yyvsp[-1].expr, nil, yyvsp[-4].stmt, true); ;
+    break;}
+case 64:
 #line 351 "cmdgram.y"
-      { yyval.stmt = LoopStmtNode::alloc(yyvsp[-8].i.lineNumber, yyvsp[-6].expr, yyvsp[-4].expr, yyvsp[-2].expr, yyvsp[0].stmt, false); ;
-      break; }
-      case 65:
+{ yyval.stmt = LoopStmtNode::alloc(yyvsp[-8].i.lineNumber, yyvsp[-6].expr, yyvsp[-4].expr, yyvsp[-2].expr, yyvsp[0].stmt, false); ;
+    break;}
+case 65:
 #line 353 "cmdgram.y"
-      { yyval.stmt = LoopStmtNode::alloc(yyvsp[-7].i.lineNumber, yyvsp[-5].expr, yyvsp[-3].expr, NULL, yyvsp[0].stmt, false); ;
-      break; }
-      case 66:
+{ yyval.stmt = LoopStmtNode::alloc(yyvsp[-7].i.lineNumber, yyvsp[-5].expr, yyvsp[-3].expr, NULL, yyvsp[0].stmt, false); ;
+    break;}
+case 66:
 #line 355 "cmdgram.y"
-      { yyval.stmt = LoopStmtNode::alloc(yyvsp[-7].i.lineNumber, yyvsp[-5].expr, NULL, yyvsp[-2].expr, yyvsp[0].stmt, false); ;
-      break; }
-      case 67:
+{ yyval.stmt = LoopStmtNode::alloc(yyvsp[-7].i.lineNumber, yyvsp[-5].expr, NULL, yyvsp[-2].expr, yyvsp[0].stmt, false); ;
+    break;}
+case 67:
 #line 357 "cmdgram.y"
-      { yyval.stmt = LoopStmtNode::alloc(yyvsp[-6].i.lineNumber, yyvsp[-4].expr, NULL, NULL, yyvsp[0].stmt, false); ;
-      break; }
-      case 68:
+{ yyval.stmt = LoopStmtNode::alloc(yyvsp[-6].i.lineNumber, yyvsp[-4].expr, NULL, NULL, yyvsp[0].stmt, false); ;
+    break;}
+case 68:
 #line 359 "cmdgram.y"
-      { yyval.stmt = LoopStmtNode::alloc(yyvsp[-7].i.lineNumber, NULL, yyvsp[-4].expr, yyvsp[-2].expr, yyvsp[0].stmt, false); ;
-      break; }
-      case 69:
+{ yyval.stmt = LoopStmtNode::alloc(yyvsp[-7].i.lineNumber, NULL, yyvsp[-4].expr, yyvsp[-2].expr, yyvsp[0].stmt, false); ;
+    break;}
+case 69:
 #line 361 "cmdgram.y"
-      { yyval.stmt = LoopStmtNode::alloc(yyvsp[-6].i.lineNumber, NULL, yyvsp[-3].expr, NULL, yyvsp[0].stmt, false); ;
-      break; }
-      case 70:
+{ yyval.stmt = LoopStmtNode::alloc(yyvsp[-6].i.lineNumber, NULL, yyvsp[-3].expr, NULL, yyvsp[0].stmt, false); ;
+    break;}
+case 70:
 #line 363 "cmdgram.y"
-      { yyval.stmt = LoopStmtNode::alloc(yyvsp[-6].i.lineNumber, NULL, NULL, yyvsp[-2].expr, yyvsp[0].stmt, false); ;
-      break; }
-      case 71:
+{ yyval.stmt = LoopStmtNode::alloc(yyvsp[-6].i.lineNumber, NULL, NULL, yyvsp[-2].expr, yyvsp[0].stmt, false); ;
+    break;}
+case 71:
 #line 365 "cmdgram.y"
-      { yyval.stmt = LoopStmtNode::alloc(yyvsp[-5].i.lineNumber, NULL, NULL, NULL, yyvsp[0].stmt, false); ;
-      break; }
-      case 72:
+{ yyval.stmt = LoopStmtNode::alloc(yyvsp[-5].i.lineNumber, NULL, NULL, NULL, yyvsp[0].stmt, false); ;
+    break;}
+case 72:
 #line 370 "cmdgram.y"
-      { yyval.stmt = IterStmtNode::alloc(yyvsp[-6].i.lineNumber, yyvsp[-4].s.value, yyvsp[-2].expr, yyvsp[0].stmt, false); ;
-      break; }
-      case 73:
+{ yyval.stmt = IterStmtNode::alloc( yyvsp[-6].i.lineNumber, yyvsp[-4].s.value, yyvsp[-2].expr, yyvsp[0].stmt, false ); ;
+    break;}
+case 73:
 #line 372 "cmdgram.y"
-      { yyval.stmt = IterStmtNode::alloc(yyvsp[-6].i.lineNumber, yyvsp[-4].s.value, yyvsp[-2].expr, yyvsp[0].stmt, true); ;
-      break; }
-      case 74:
+{ yyval.stmt = IterStmtNode::alloc( yyvsp[-6].i.lineNumber, yyvsp[-4].s.value, yyvsp[-2].expr, yyvsp[0].stmt, true ); ;
+    break;}
+case 74:
 #line 377 "cmdgram.y"
-      { yyval.stmt = yyvsp[0].expr; ;
-      break; }
-      case 75:
+{ yyval.stmt = yyvsp[0].expr; ;
+    break;}
+case 75:
 #line 382 "cmdgram.y"
-      { yyval.expr = yyvsp[0].expr; ;
-      break; }
-      case 76:
+{ yyval.expr = yyvsp[0].expr; ;
+    break;}
+case 76:
 #line 384 "cmdgram.y"
-      { yyval.expr = yyvsp[-1].expr; ;
-      break; }
-      case 77:
+{ yyval.expr = yyvsp[-1].expr; ;
+    break;}
+case 77:
 #line 386 "cmdgram.y"
-      { yyval.expr = IntBinaryExprNode::alloc(yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
-      break; }
-      case 78:
+{ yyval.expr = IntBinaryExprNode::alloc( yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
+    break;}
+case 78:
 #line 388 "cmdgram.y"
-      { yyval.expr = IntBinaryExprNode::alloc(yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
-      break; }
-      case 79:
+{ yyval.expr = IntBinaryExprNode::alloc( yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
+    break;}
+case 79:
 #line 390 "cmdgram.y"
-      { yyval.expr = IntBinaryExprNode::alloc(yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
-      break; }
-      case 80:
+{ yyval.expr = IntBinaryExprNode::alloc( yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
+    break;}
+case 80:
 #line 392 "cmdgram.y"
-      { yyval.expr = IntBinaryExprNode::alloc(yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
-      break; }
-      case 81:
+{ yyval.expr = IntBinaryExprNode::alloc( yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
+    break;}
+case 81:
 #line 394 "cmdgram.y"
-      { yyval.expr = FloatBinaryExprNode::alloc(yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
-      break; }
-      case 82:
+{ yyval.expr = FloatBinaryExprNode::alloc( yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
+    break;}
+case 82:
 #line 396 "cmdgram.y"
-      { yyval.expr = FloatBinaryExprNode::alloc(yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
-      break; }
-      case 83:
+{ yyval.expr = FloatBinaryExprNode::alloc( yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
+    break;}
+case 83:
 #line 398 "cmdgram.y"
-      { yyval.expr = FloatBinaryExprNode::alloc(yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
-      break; }
-      case 84:
+{ yyval.expr = FloatBinaryExprNode::alloc( yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
+    break;}
+case 84:
 #line 400 "cmdgram.y"
-      { yyval.expr = FloatBinaryExprNode::alloc(yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
-      break; }
-      case 85:
+{ yyval.expr = FloatBinaryExprNode::alloc( yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
+    break;}
+case 85:
 #line 402 "cmdgram.y"
-      { yyval.expr = FloatUnaryExprNode::alloc(yyvsp[-1].i.lineNumber, yyvsp[-1].i.value, yyvsp[0].expr); ;
-      break; }
-      case 86:
+{ yyval.expr = FloatUnaryExprNode::alloc( yyvsp[-1].i.lineNumber, yyvsp[-1].i.value, yyvsp[0].expr); ;
+    break;}
+case 86:
 #line 404 "cmdgram.y"
-      { yyval.expr = TTagDerefNode::alloc(yyvsp[-1].i.lineNumber, yyvsp[0].expr); ;
-      break; }
-      case 87:
+{ yyval.expr = TTagDerefNode::alloc( yyvsp[-1].i.lineNumber, yyvsp[0].expr ); ;
+    break;}
+case 87:
 #line 406 "cmdgram.y"
-      { yyval.expr = TTagExprNode::alloc(yyvsp[0].s.lineNumber, yyvsp[0].s.value); ;
-      break; }
-      case 88:
+{ yyval.expr = TTagExprNode::alloc( yyvsp[0].s.lineNumber, yyvsp[0].s.value ); ;
+    break;}
+case 88:
 #line 408 "cmdgram.y"
-      { yyval.expr = ConditionalExprNode::alloc(yyvsp[-4].expr->dbgLineNumber, yyvsp[-4].expr, yyvsp[-2].expr, yyvsp[0].expr); ;
-      break; }
-      case 89:
+{ yyval.expr = ConditionalExprNode::alloc( yyvsp[-4].expr->dbgLineNumber, yyvsp[-4].expr, yyvsp[-2].expr, yyvsp[0].expr); ;
+    break;}
+case 89:
 #line 410 "cmdgram.y"
-      { yyval.expr = IntBinaryExprNode::alloc(yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
-      break; }
-      case 90:
+{ yyval.expr = IntBinaryExprNode::alloc( yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
+    break;}
+case 90:
 #line 412 "cmdgram.y"
-      { yyval.expr = IntBinaryExprNode::alloc(yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
-      break; }
-      case 91:
+{ yyval.expr = IntBinaryExprNode::alloc( yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
+    break;}
+case 91:
 #line 414 "cmdgram.y"
-      { yyval.expr = IntBinaryExprNode::alloc(yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
-      break; }
-      case 92:
+{ yyval.expr = IntBinaryExprNode::alloc( yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
+    break;}
+case 92:
 #line 416 "cmdgram.y"
-      { yyval.expr = IntBinaryExprNode::alloc(yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
-      break; }
-      case 93:
+{ yyval.expr = IntBinaryExprNode::alloc( yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
+    break;}
+case 93:
 #line 418 "cmdgram.y"
-      { yyval.expr = IntBinaryExprNode::alloc(yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
-      break; }
-      case 94:
+{ yyval.expr = IntBinaryExprNode::alloc( yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
+    break;}
+case 94:
 #line 420 "cmdgram.y"
-      { yyval.expr = IntBinaryExprNode::alloc(yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
-      break; }
-      case 95:
+{ yyval.expr = IntBinaryExprNode::alloc( yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
+    break;}
+case 95:
 #line 422 "cmdgram.y"
-      { yyval.expr = IntBinaryExprNode::alloc(yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
-      break; }
-      case 96:
+{ yyval.expr = IntBinaryExprNode::alloc( yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
+    break;}
+case 96:
 #line 424 "cmdgram.y"
-      { yyval.expr = IntBinaryExprNode::alloc(yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
-      break; }
-      case 97:
+{ yyval.expr = IntBinaryExprNode::alloc( yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
+    break;}
+case 97:
 #line 426 "cmdgram.y"
-      { yyval.expr = IntBinaryExprNode::alloc(yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
-      break; }
-      case 98:
+{ yyval.expr = IntBinaryExprNode::alloc( yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
+    break;}
+case 98:
 #line 428 "cmdgram.y"
-      { yyval.expr = IntBinaryExprNode::alloc(yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
-      break; }
-      case 99:
+{ yyval.expr = IntBinaryExprNode::alloc( yyvsp[-2].expr->dbgLineNumber, yyvsp[-1].i.value, yyvsp[-2].expr, yyvsp[0].expr); ;
+    break;}
+case 99:
 #line 430 "cmdgram.y"
-      { yyval.expr = StreqExprNode::alloc(yyvsp[-2].expr->dbgLineNumber, yyvsp[-2].expr, yyvsp[0].expr, true); ;
-      break; }
-      case 100:
+{ yyval.expr = StreqExprNode::alloc( yyvsp[-2].expr->dbgLineNumber, yyvsp[-2].expr, yyvsp[0].expr, true); ;
+    break;}
+case 100:
 #line 432 "cmdgram.y"
-      { yyval.expr = StreqExprNode::alloc(yyvsp[-2].expr->dbgLineNumber, yyvsp[-2].expr, yyvsp[0].expr, false); ;
-      break; }
-      case 101:
+{ yyval.expr = StreqExprNode::alloc( yyvsp[-2].expr->dbgLineNumber, yyvsp[-2].expr, yyvsp[0].expr, false); ;
+    break;}
+case 101:
 #line 434 "cmdgram.y"
-      { yyval.expr = StrcatExprNode::alloc(yyvsp[-2].expr->dbgLineNumber, yyvsp[-2].expr, yyvsp[0].expr, yyvsp[-1].i.value); ;
-      break; }
-      case 102:
+{ yyval.expr = StrcatExprNode::alloc( yyvsp[-2].expr->dbgLineNumber, yyvsp[-2].expr, yyvsp[0].expr, yyvsp[-1].i.value); ;
+    break;}
+case 102:
 #line 436 "cmdgram.y"
-      { yyval.expr = IntUnaryExprNode::alloc(yyvsp[-1].i.lineNumber, yyvsp[-1].i.value, yyvsp[0].expr); ;
-      break; }
-      case 103:
+{ yyval.expr = IntUnaryExprNode::alloc(yyvsp[-1].i.lineNumber, yyvsp[-1].i.value, yyvsp[0].expr); ;
+    break;}
+case 103:
 #line 438 "cmdgram.y"
-      { yyval.expr = IntUnaryExprNode::alloc(yyvsp[-1].i.lineNumber, yyvsp[-1].i.value, yyvsp[0].expr); ;
-      break; }
-      case 104:
+{ yyval.expr = IntUnaryExprNode::alloc(yyvsp[-1].i.lineNumber, yyvsp[-1].i.value, yyvsp[0].expr); ;
+    break;}
+case 104:
 #line 440 "cmdgram.y"
-      { yyval.expr = StrConstNode::alloc(yyvsp[0].str.lineNumber, yyvsp[0].str.value, true); ;
-      break; }
-      case 105:
+{ yyval.expr = StrConstNode::alloc( yyvsp[0].str.lineNumber, yyvsp[0].str.value, true); ;
+    break;}
+case 105:
 #line 442 "cmdgram.y"
-      { yyval.expr = FloatNode::alloc(yyvsp[0].f.lineNumber, yyvsp[0].f.value); ;
-      break; }
-      case 106:
+{ yyval.expr = FloatNode::alloc( yyvsp[0].f.lineNumber, yyvsp[0].f.value ); ;
+    break;}
+case 106:
 #line 444 "cmdgram.y"
-      { yyval.expr = IntNode::alloc(yyvsp[0].i.lineNumber, yyvsp[0].i.value); ;
-      break; }
-      case 107:
+{ yyval.expr = IntNode::alloc( yyvsp[0].i.lineNumber, yyvsp[0].i.value ); ;
+    break;}
+case 107:
 #line 446 "cmdgram.y"
-      { yyval.expr = ConstantNode::alloc(yyvsp[0].i.lineNumber, StringTable->insert("break")); ;
-      break; }
-      case 108:
+{ yyval.expr = ConstantNode::alloc( yyvsp[0].i.lineNumber, StringTable->insert("break")); ;
+    break;}
+case 108:
 #line 448 "cmdgram.y"
-      { yyval.expr = SlotAccessNode::alloc(yyvsp[0].slot.lineNumber, yyvsp[0].slot.object, yyvsp[0].slot.array, yyvsp[0].slot.slotName); ;
-      break; }
-      case 109:
+{ yyval.expr = SlotAccessNode::alloc( yyvsp[0].slot.lineNumber, yyvsp[0].slot.object, yyvsp[0].slot.array, yyvsp[0].slot.slotName ); ;
+    break;}
+case 109:
 #line 450 "cmdgram.y"
-      { yyval.expr = InternalSlotAccessNode::alloc(yyvsp[0].intslot.lineNumber, yyvsp[0].intslot.object, yyvsp[0].intslot.slotExpr, yyvsp[0].intslot.recurse); ;
-      break; }
-      case 110:
+{ yyval.expr = InternalSlotAccessNode::alloc( yyvsp[0].intslot.lineNumber, yyvsp[0].intslot.object, yyvsp[0].intslot.slotExpr, yyvsp[0].intslot.recurse); ;
+    break;}
+case 110:
 #line 452 "cmdgram.y"
-      { yyval.expr = ConstantNode::alloc(yyvsp[0].s.lineNumber, yyvsp[0].s.value); ;
-      break; }
-      case 111:
+{ yyval.expr = ConstantNode::alloc( yyvsp[0].s.lineNumber, yyvsp[0].s.value ); ;
+    break;}
+case 111:
 #line 454 "cmdgram.y"
-      { yyval.expr = StrConstNode::alloc(yyvsp[0].str.lineNumber, yyvsp[0].str.value, false); ;
-      break; }
-      case 112:
+{ yyval.expr = StrConstNode::alloc( yyvsp[0].str.lineNumber, yyvsp[0].str.value, false); ;
+    break;}
+case 112:
 #line 456 "cmdgram.y"
-      { yyval.expr = (ExprNode*)VarNode::alloc(yyvsp[0].s.lineNumber, yyvsp[0].s.value, NULL); ;
-      break; }
-      case 113:
+{ yyval.expr = (ExprNode*)VarNode::alloc( yyvsp[0].s.lineNumber, yyvsp[0].s.value, NULL); ;
+    break;}
+case 113:
 #line 458 "cmdgram.y"
-      { yyval.expr = (ExprNode*)VarNode::alloc(yyvsp[-3].s.lineNumber, yyvsp[-3].s.value, yyvsp[-1].expr); ;
-      break; }
-      case 114:
-#line 460 "cmdgram.y"
-      {
-         const U32 bufLen = 64;
-         UTF8 buffer[bufLen];
-         dSprintf(buffer, bufLen, "__anonymous_function%d", gAnonFunctionID++);
-         StringTableEntry fName = StringTable->insert(buffer);
-         StmtNode *fndef = FunctionDeclStmtNode::alloc(yyvsp[-6].i.lineNumber, fName, NULL, yyvsp[-4].var, yyvsp[-1].stmt);
-
-         if (!gAnonFunctionList)
-            gAnonFunctionList = fndef;
-         else
-            gAnonFunctionList->append(fndef);
-
-         yyval.expr = StrConstNode::alloc(yyvsp[-6].i.lineNumber, (UTF8*)fName, false);
-         ;
-         break; }
-      case 115:
-#line 478 "cmdgram.y"
-      { yyval.slot.lineNumber = yyvsp[-2].expr->dbgLineNumber; yyval.slot.object = yyvsp[-2].expr; yyval.slot.slotName = yyvsp[0].s.value; yyval.slot.array = NULL; ;
-      break; }
-      case 116:
+{ yyval.expr = (ExprNode*)VarNode::alloc( yyvsp[-3].s.lineNumber, yyvsp[-3].s.value, yyvsp[-1].expr ); ;
+    break;}
+case 114:
 #line 480 "cmdgram.y"
-      { yyval.slot.lineNumber = yyvsp[-5].expr->dbgLineNumber; yyval.slot.object = yyvsp[-5].expr; yyval.slot.slotName = yyvsp[-3].s.value; yyval.slot.array = yyvsp[-1].expr; ;
-      break; }
-      case 117:
-#line 485 "cmdgram.y"
-      { yyval.intslot.lineNumber = yyvsp[-2].expr->dbgLineNumber; yyval.intslot.object = yyvsp[-2].expr; yyval.intslot.slotExpr = yyvsp[0].expr; yyval.intslot.recurse = false; ;
-      break; }
-      case 118:
+{ yyval.slot.lineNumber = yyvsp[-2].expr->dbgLineNumber; yyval.slot.object = yyvsp[-2].expr; yyval.slot.slotName = yyvsp[0].s.value; yyval.slot.array = NULL; ;
+    break;}
+case 115:
+#line 482 "cmdgram.y"
+{ yyval.slot.lineNumber = yyvsp[-5].expr->dbgLineNumber; yyval.slot.object = yyvsp[-5].expr; yyval.slot.slotName = yyvsp[-3].s.value; yyval.slot.array = yyvsp[-1].expr; ;
+    break;}
+case 116:
 #line 487 "cmdgram.y"
-      { yyval.intslot.lineNumber = yyvsp[-2].expr->dbgLineNumber; yyval.intslot.object = yyvsp[-2].expr; yyval.intslot.slotExpr = yyvsp[0].expr; yyval.intslot.recurse = true; ;
-      break; }
-      case 119:
-#line 492 "cmdgram.y"
-      { yyval.expr = ConstantNode::alloc(yyvsp[0].s.lineNumber, yyvsp[0].s.value); ;
-      break; }
-      case 120:
+{ yyval.intslot.lineNumber = yyvsp[-2].expr->dbgLineNumber; yyval.intslot.object = yyvsp[-2].expr; yyval.intslot.slotExpr = yyvsp[0].expr; yyval.intslot.recurse = false; ;
+    break;}
+case 117:
+#line 489 "cmdgram.y"
+{ yyval.intslot.lineNumber = yyvsp[-2].expr->dbgLineNumber; yyval.intslot.object = yyvsp[-2].expr; yyval.intslot.slotExpr = yyvsp[0].expr; yyval.intslot.recurse = true; ;
+    break;}
+case 118:
 #line 494 "cmdgram.y"
-      { yyval.expr = yyvsp[-1].expr; ;
-      break; }
-      case 121:
-#line 499 "cmdgram.y"
-      { yyval.asn.lineNumber = yyvsp[0].i.lineNumber; yyval.asn.token = opPLUSPLUS; yyval.asn.expr = FloatNode::alloc(yyvsp[0].i.lineNumber, 1); ;
-      break; }
-      case 122:
+{ yyval.expr = ConstantNode::alloc( yyvsp[0].s.lineNumber, yyvsp[0].s.value ); ;
+    break;}
+case 119:
+#line 496 "cmdgram.y"
+{ yyval.expr = yyvsp[-1].expr; ;
+    break;}
+case 120:
 #line 501 "cmdgram.y"
-      { yyval.asn.lineNumber = yyvsp[0].i.lineNumber; yyval.asn.token = opMINUSMINUS; yyval.asn.expr = FloatNode::alloc(yyvsp[0].i.lineNumber, 1); ;
-      break; }
-      case 123:
+{ yyval.asn.lineNumber = yyvsp[0].i.lineNumber; yyval.asn.token = opPLUSPLUS; yyval.asn.expr = FloatNode::alloc( yyvsp[0].i.lineNumber, 1 ); ;
+    break;}
+case 121:
 #line 503 "cmdgram.y"
-      { yyval.asn.lineNumber = yyvsp[-1].i.lineNumber; yyval.asn.token = '+'; yyval.asn.expr = yyvsp[0].expr; ;
-      break; }
-      case 124:
+{ yyval.asn.lineNumber = yyvsp[0].i.lineNumber; yyval.asn.token = opMINUSMINUS; yyval.asn.expr = FloatNode::alloc( yyvsp[0].i.lineNumber, 1 ); ;
+    break;}
+case 122:
 #line 505 "cmdgram.y"
-      { yyval.asn.lineNumber = yyvsp[-1].i.lineNumber; yyval.asn.token = '-'; yyval.asn.expr = yyvsp[0].expr; ;
-      break; }
-      case 125:
+{ yyval.asn.lineNumber = yyvsp[-1].i.lineNumber; yyval.asn.token = '+'; yyval.asn.expr = yyvsp[0].expr; ;
+    break;}
+case 123:
 #line 507 "cmdgram.y"
-      { yyval.asn.lineNumber = yyvsp[-1].i.lineNumber; yyval.asn.token = '*'; yyval.asn.expr = yyvsp[0].expr; ;
-      break; }
-      case 126:
+{ yyval.asn.lineNumber = yyvsp[-1].i.lineNumber; yyval.asn.token = '-'; yyval.asn.expr = yyvsp[0].expr; ;
+    break;}
+case 124:
 #line 509 "cmdgram.y"
-      { yyval.asn.lineNumber = yyvsp[-1].i.lineNumber; yyval.asn.token = '/'; yyval.asn.expr = yyvsp[0].expr; ;
-      break; }
-      case 127:
+{ yyval.asn.lineNumber = yyvsp[-1].i.lineNumber; yyval.asn.token = '*'; yyval.asn.expr = yyvsp[0].expr; ;
+    break;}
+case 125:
 #line 511 "cmdgram.y"
-      { yyval.asn.lineNumber = yyvsp[-1].i.lineNumber; yyval.asn.token = '%'; yyval.asn.expr = yyvsp[0].expr; ;
-      break; }
-      case 128:
+{ yyval.asn.lineNumber = yyvsp[-1].i.lineNumber; yyval.asn.token = '/'; yyval.asn.expr = yyvsp[0].expr; ;
+    break;}
+case 126:
 #line 513 "cmdgram.y"
-      { yyval.asn.lineNumber = yyvsp[-1].i.lineNumber; yyval.asn.token = '&'; yyval.asn.expr = yyvsp[0].expr; ;
-      break; }
-      case 129:
+{ yyval.asn.lineNumber = yyvsp[-1].i.lineNumber; yyval.asn.token = '%'; yyval.asn.expr = yyvsp[0].expr; ;
+    break;}
+case 127:
 #line 515 "cmdgram.y"
-      { yyval.asn.lineNumber = yyvsp[-1].i.lineNumber; yyval.asn.token = '^'; yyval.asn.expr = yyvsp[0].expr; ;
-      break; }
-      case 130:
+{ yyval.asn.lineNumber = yyvsp[-1].i.lineNumber; yyval.asn.token = '&'; yyval.asn.expr = yyvsp[0].expr; ;
+    break;}
+case 128:
 #line 517 "cmdgram.y"
-      { yyval.asn.lineNumber = yyvsp[-1].i.lineNumber; yyval.asn.token = '|'; yyval.asn.expr = yyvsp[0].expr; ;
-      break; }
-      case 131:
+{ yyval.asn.lineNumber = yyvsp[-1].i.lineNumber; yyval.asn.token = '^'; yyval.asn.expr = yyvsp[0].expr; ;
+    break;}
+case 129:
 #line 519 "cmdgram.y"
-      { yyval.asn.lineNumber = yyvsp[-1].i.lineNumber; yyval.asn.token = opSHL; yyval.asn.expr = yyvsp[0].expr; ;
-      break; }
-      case 132:
+{ yyval.asn.lineNumber = yyvsp[-1].i.lineNumber; yyval.asn.token = '|'; yyval.asn.expr = yyvsp[0].expr; ;
+    break;}
+case 130:
 #line 521 "cmdgram.y"
-      { yyval.asn.lineNumber = yyvsp[-1].i.lineNumber; yyval.asn.token = opSHR; yyval.asn.expr = yyvsp[0].expr; ;
-      break; }
-      case 133:
-#line 526 "cmdgram.y"
-      { yyval.expr = yyvsp[0].expr; ;
-      break; }
-      case 134:
+{ yyval.asn.lineNumber = yyvsp[-1].i.lineNumber; yyval.asn.token = opSHL; yyval.asn.expr = yyvsp[0].expr; ;
+    break;}
+case 131:
+#line 523 "cmdgram.y"
+{ yyval.asn.lineNumber = yyvsp[-1].i.lineNumber; yyval.asn.token = opSHR; yyval.asn.expr = yyvsp[0].expr; ;
+    break;}
+case 132:
 #line 528 "cmdgram.y"
-      { yyval.expr = yyvsp[0].expr; ;
-      break; }
-      case 135:
+{ yyval.expr = yyvsp[0].expr; ;
+    break;}
+case 133:
 #line 530 "cmdgram.y"
-      { yyval.expr = yyvsp[0].od; ;
-      break; }
-      case 136:
+{ yyval.expr = yyvsp[0].expr; ;
+    break;}
+case 134:
 #line 532 "cmdgram.y"
-      { yyval.expr = AssignExprNode::alloc(yyvsp[-2].s.lineNumber, yyvsp[-2].s.value, NULL, yyvsp[0].expr); ;
-      break; }
-      case 137:
+{ yyval.expr = yyvsp[0].od; ;
+    break;}
+case 135:
 #line 534 "cmdgram.y"
-      { yyval.expr = AssignExprNode::alloc(yyvsp[-5].s.lineNumber, yyvsp[-5].s.value, yyvsp[-3].expr, yyvsp[0].expr); ;
-      break; }
-      case 138:
+{ yyval.expr = AssignExprNode::alloc( yyvsp[-2].s.lineNumber, yyvsp[-2].s.value, NULL, yyvsp[0].expr); ;
+    break;}
+case 136:
 #line 536 "cmdgram.y"
-      { yyval.expr = AssignOpExprNode::alloc(yyvsp[-1].s.lineNumber, yyvsp[-1].s.value, NULL, yyvsp[0].asn.expr, yyvsp[0].asn.token); ;
-      break; }
-      case 139:
+{ yyval.expr = AssignExprNode::alloc( yyvsp[-5].s.lineNumber, yyvsp[-5].s.value, yyvsp[-3].expr, yyvsp[0].expr); ;
+    break;}
+case 137:
 #line 538 "cmdgram.y"
-      { yyval.expr = AssignOpExprNode::alloc(yyvsp[-4].s.lineNumber, yyvsp[-4].s.value, yyvsp[-2].expr, yyvsp[0].asn.expr, yyvsp[0].asn.token); ;
-      break; }
-      case 140:
+{ yyval.expr = AssignOpExprNode::alloc( yyvsp[-1].s.lineNumber, yyvsp[-1].s.value, NULL, yyvsp[0].asn.expr, yyvsp[0].asn.token); ;
+    break;}
+case 138:
 #line 540 "cmdgram.y"
-      { yyval.expr = SlotAssignOpNode::alloc(yyvsp[-1].slot.lineNumber, yyvsp[-1].slot.object, yyvsp[-1].slot.slotName, yyvsp[-1].slot.array, yyvsp[0].asn.token, yyvsp[0].asn.expr); ;
-      break; }
-      case 141:
+{ yyval.expr = AssignOpExprNode::alloc( yyvsp[-4].s.lineNumber, yyvsp[-4].s.value, yyvsp[-2].expr, yyvsp[0].asn.expr, yyvsp[0].asn.token); ;
+    break;}
+case 139:
 #line 542 "cmdgram.y"
-      { yyval.expr = SlotAssignNode::alloc(yyvsp[-2].slot.lineNumber, yyvsp[-2].slot.object, yyvsp[-2].slot.array, yyvsp[-2].slot.slotName, yyvsp[0].expr); ;
-      break; }
-      case 142:
+{ yyval.expr = SlotAssignOpNode::alloc( yyvsp[-1].slot.lineNumber, yyvsp[-1].slot.object, yyvsp[-1].slot.slotName, yyvsp[-1].slot.array, yyvsp[0].asn.token, yyvsp[0].asn.expr); ;
+    break;}
+case 140:
 #line 544 "cmdgram.y"
-      { yyval.expr = SlotAssignNode::alloc(yyvsp[-4].slot.lineNumber, yyvsp[-4].slot.object, yyvsp[-4].slot.array, yyvsp[-4].slot.slotName, yyvsp[-1].expr); ;
-      break; }
-      case 143:
-#line 549 "cmdgram.y"
-      { yyval.expr = FuncCallExprNode::alloc(yyvsp[-3].s.lineNumber, yyvsp[-3].s.value, NULL, yyvsp[-1].expr, false); ;
-      break; }
-      case 144:
+{ yyval.expr = SlotAssignNode::alloc( yyvsp[-2].slot.lineNumber, yyvsp[-2].slot.object, yyvsp[-2].slot.array, yyvsp[-2].slot.slotName, yyvsp[0].expr); ;
+    break;}
+case 141:
+#line 546 "cmdgram.y"
+{ yyval.expr = SlotAssignNode::alloc( yyvsp[-4].slot.lineNumber, yyvsp[-4].slot.object, yyvsp[-4].slot.array, yyvsp[-4].slot.slotName, yyvsp[-1].expr); ;
+    break;}
+case 142:
 #line 551 "cmdgram.y"
-      { yyval.expr = FuncCallExprNode::alloc(yyvsp[-5].s.lineNumber, yyvsp[-3].s.value, yyvsp[-5].s.value, yyvsp[-1].expr, false); ;
-      break; }
-      case 145:
+{ yyval.expr = FuncCallExprNode::alloc( yyvsp[-3].s.lineNumber, yyvsp[-3].s.value, NULL, yyvsp[-1].expr, false); ;
+    break;}
+case 143:
 #line 553 "cmdgram.y"
-      { yyvsp[-5].expr->append(yyvsp[-1].expr); yyval.expr = FuncCallExprNode::alloc(yyvsp[-5].expr->dbgLineNumber, yyvsp[-3].s.value, NULL, yyvsp[-5].expr, true); ;
-      break; }
-      case 146:
+{ yyval.expr = FuncCallExprNode::alloc( yyvsp[-5].s.lineNumber, yyvsp[-3].s.value, yyvsp[-5].s.value, yyvsp[-1].expr, false); ;
+    break;}
+case 144:
 #line 555 "cmdgram.y"
-      { yyval.expr = FuncPointerCallExprNode::alloc(yyvsp[-3].expr->dbgLineNumber, yyvsp[-3].expr, yyvsp[-1].expr); ;
-      break; }
-      case 147:
-#line 560 "cmdgram.y"
-      { yyval.expr = AssertCallExprNode::alloc(yyvsp[-3].i.lineNumber, yyvsp[-1].expr, NULL); ;
-      break; }
-      case 148:
-#line 562 "cmdgram.y"
-      { yyval.expr = AssertCallExprNode::alloc(yyvsp[-5].i.lineNumber, yyvsp[-3].expr, yyvsp[-1].str.value); ;
-      break; }
-      case 149:
+{ yyvsp[-5].expr->append(yyvsp[-1].expr); yyval.expr = FuncCallExprNode::alloc( yyvsp[-5].expr->dbgLineNumber, yyvsp[-3].s.value, NULL, yyvsp[-5].expr, true); ;
+    break;}
+case 145:
+#line 565 "cmdgram.y"
+{ yyval.expr = AssertCallExprNode::alloc( yyvsp[-3].i.lineNumber, yyvsp[-1].expr, NULL ); ;
+    break;}
+case 146:
 #line 567 "cmdgram.y"
-      { yyval.expr = NULL; ;
-      break; }
-      case 150:
-#line 569 "cmdgram.y"
-      { yyval.expr = yyvsp[0].expr; ;
-      break; }
-      case 151:
+{ yyval.expr = AssertCallExprNode::alloc( yyvsp[-5].i.lineNumber, yyvsp[-3].expr, yyvsp[-1].str.value ); ;
+    break;}
+case 147:
+#line 572 "cmdgram.y"
+{ yyval.expr = NULL; ;
+    break;}
+case 148:
 #line 574 "cmdgram.y"
-      { yyval.expr = yyvsp[0].expr; ;
-      break; }
-      case 152:
-#line 576 "cmdgram.y"
-      { (yyvsp[-2].expr)->append(yyvsp[0].expr); yyval.expr = yyvsp[-2].expr; ;
-      break; }
-      case 153:
+{ yyval.expr = yyvsp[0].expr; ;
+    break;}
+case 149:
+#line 579 "cmdgram.y"
+{ yyval.expr = yyvsp[0].expr; ;
+    break;}
+case 150:
 #line 581 "cmdgram.y"
-      { yyval.slist = NULL; ;
-      break; }
-      case 154:
-#line 583 "cmdgram.y"
-      { yyval.slist = yyvsp[0].slist; ;
-      break; }
-      case 155:
+{ (yyvsp[-2].expr)->append(yyvsp[0].expr); yyval.expr = yyvsp[-2].expr; ;
+    break;}
+case 151:
+#line 586 "cmdgram.y"
+{ yyval.slist = NULL; ;
+    break;}
+case 152:
 #line 588 "cmdgram.y"
-      { yyval.slist = yyvsp[0].slist; ;
-      break; }
-      case 156:
-#line 590 "cmdgram.y"
-      { yyvsp[-1].slist->append(yyvsp[0].slist); yyval.slist = yyvsp[-1].slist; ;
-      break; }
-      case 157:
+{ yyval.slist = yyvsp[0].slist; ;
+    break;}
+case 153:
+#line 593 "cmdgram.y"
+{ yyval.slist = yyvsp[0].slist; ;
+    break;}
+case 154:
 #line 595 "cmdgram.y"
-      { yyval.slist = SlotAssignNode::alloc(yyvsp[-3].s.lineNumber, NULL, NULL, yyvsp[-3].s.value, yyvsp[-1].expr); ;
-      break; }
-      case 158:
-#line 597 "cmdgram.y"
-      { yyval.slist = SlotAssignNode::alloc(yyvsp[-4].i.lineNumber, NULL, NULL, yyvsp[-3].s.value, yyvsp[-1].expr, yyvsp[-4].i.value); ;
-      break; }
-      case 159:
-#line 599 "cmdgram.y"
-      { yyval.slist = SlotAssignNode::alloc(yyvsp[-3].i.lineNumber, NULL, NULL, StringTable->insert("datablock"), yyvsp[-1].expr); ;
-      break; }
-      case 160:
-#line 601 "cmdgram.y"
-      { yyval.slist = SlotAssignNode::alloc(yyvsp[-6].s.lineNumber, NULL, yyvsp[-4].expr, yyvsp[-6].s.value, yyvsp[-1].expr); ;
-      break; }
-      case 161:
-#line 603 "cmdgram.y"
-      { yyval.slist = SlotAssignNode::alloc(yyvsp[-7].i.lineNumber, NULL, yyvsp[-4].expr, yyvsp[-6].s.value, yyvsp[-1].expr, yyvsp[-7].i.value); ;
-      break; }
-      case 162:
+{ yyvsp[-1].slist->append(yyvsp[0].slist); yyval.slist = yyvsp[-1].slist; ;
+    break;}
+case 155:
+#line 600 "cmdgram.y"
+{ yyval.slist = SlotAssignNode::alloc( yyvsp[-3].s.lineNumber, NULL, NULL, yyvsp[-3].s.value, yyvsp[-1].expr); ;
+    break;}
+case 156:
+#line 602 "cmdgram.y"
+{ yyval.slist = SlotAssignNode::alloc( yyvsp[-4].i.lineNumber, NULL, NULL, yyvsp[-3].s.value, yyvsp[-1].expr, yyvsp[-4].i.value); ;
+    break;}
+case 157:
+#line 604 "cmdgram.y"
+{ yyval.slist = SlotAssignNode::alloc( yyvsp[-3].i.lineNumber, NULL, NULL, StringTable->insert("datablock"), yyvsp[-1].expr); ;
+    break;}
+case 158:
+#line 606 "cmdgram.y"
+{ yyval.slist = SlotAssignNode::alloc( yyvsp[-6].s.lineNumber, NULL, yyvsp[-4].expr, yyvsp[-6].s.value, yyvsp[-1].expr); ;
+    break;}
+case 159:
 #line 608 "cmdgram.y"
-      { yyval.expr = yyvsp[0].expr; ;
-      break; }
-      case 163:
-#line 610 "cmdgram.y"
-      { yyval.expr = CommaCatExprNode::alloc(yyvsp[-2].expr->dbgLineNumber, yyvsp[-2].expr, yyvsp[0].expr); ;
-      break; }
-   }
+{ yyval.slist = SlotAssignNode::alloc( yyvsp[-7].i.lineNumber, NULL, yyvsp[-4].expr, yyvsp[-6].s.value, yyvsp[-1].expr, yyvsp[-7].i.value); ;
+    break;}
+case 160:
+#line 613 "cmdgram.y"
+{ yyval.expr = yyvsp[0].expr; ;
+    break;}
+case 161:
+#line 615 "cmdgram.y"
+{ yyval.expr = CommaCatExprNode::alloc( yyvsp[-2].expr->dbgLineNumber, yyvsp[-2].expr, yyvsp[0].expr); ;
+    break;}
+}
    /* the action file gets copied in in place of this dollarsign */
 #line 487 "bison.simple"
-
-   yyvsp -= yylen;
-   yyssp -= yylen;
+
+  yyvsp -= yylen;
+  yyssp -= yylen;
 #ifdef YYLSP_NEEDED
-   yylsp -= yylen;
+  yylsp -= yylen;
 #endif
 
 #if YYDEBUG != 0
-   if (yydebug)
-   {
+  if (yydebug)
+    {
       short *ssp1 = yyss - 1;
-      fprintf(stderr, "state stack now");
+      fprintf (stderr, "state stack now");
       while (ssp1 != yyssp)
-         fprintf(stderr, " %d", *++ssp1);
-      fprintf(stderr, "\n");
-   }
+	fprintf (stderr, " %d", *++ssp1);
+      fprintf (stderr, "\n");
+    }
 #endif
 
-   *++yyvsp = yyval;
+  *++yyvsp = yyval;
 
 #ifdef YYLSP_NEEDED
-   yylsp++;
-   if (yylen == 0)
-   {
+  yylsp++;
+  if (yylen == 0)
+    {
       yylsp->first_line = yylloc.first_line;
       yylsp->first_column = yylloc.first_column;
-      yylsp->last_line = (yylsp - 1)->last_line;
-      yylsp->last_column = (yylsp - 1)->last_column;
+      yylsp->last_line = (yylsp-1)->last_line;
+      yylsp->last_column = (yylsp-1)->last_column;
       yylsp->text = 0;
-   }
-   else
-   {
-      yylsp->last_line = (yylsp + yylen - 1)->last_line;
-      yylsp->last_column = (yylsp + yylen - 1)->last_column;
-   }
+    }
+  else
+    {
+      yylsp->last_line = (yylsp+yylen-1)->last_line;
+      yylsp->last_column = (yylsp+yylen-1)->last_column;
+    }
 #endif
 
-   /* Now "shift" the result of the reduction.
-   Determine what state that goes to,
-   based on the state we popped back to
-   and the rule number reduced by.  */
+  /* Now "shift" the result of the reduction.
+     Determine what state that goes to,
+     based on the state we popped back to
+     and the rule number reduced by.  */
 
-   yyn = yyr1[yyn];
+  yyn = yyr1[yyn];
 
-   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
-   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
-      yystate = yytable[yystate];
-   else
-      yystate = yydefgoto[yyn - YYNTBASE];
+  yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
+  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+    yystate = yytable[yystate];
+  else
+    yystate = yydefgoto[yyn - YYNTBASE];
 
-   goto yynewstate;
+  goto yynewstate;
 
 yyerrlab:   /* here on detecting error */
 
-   if (!yyerrstatus)
-      /* If not already recovering from an error, report this error.  */
-   {
+  if (! yyerrstatus)
+    /* If not already recovering from an error, report this error.  */
+    {
       ++yynerrs;
 
 #ifdef YYERROR_VERBOSE
       yyn = yypact[yystate];
 
       if (yyn > YYFLAG && yyn < YYLAST)
-      {
-         int size = 0;
-         char *msg;
-         int x, count;
+	{
+	  int size = 0;
+	  char *msg;
+	  int x, count;
 
-         count = 0;
-         /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
-         for (x = (yyn < 0 ? -yyn : 0);
-            x < (sizeof(yytname) / sizeof(char *)); x++)
-            if (yycheck[x + yyn] == x)
-               size += strlen(yytname[x]) + 15, count++;
-         msg = (char *)malloc(size + 15);
-         if (msg != 0)
-         {
-            strcpy(msg, "parse error");
+	  count = 0;
+	  /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
+	  for (x = (yyn < 0 ? -yyn : 0);
+	       x < (sizeof(yytname) / sizeof(char *)); x++)
+	    if (yycheck[x + yyn] == x)
+	      size += strlen(yytname[x]) + 15, count++;
+	  msg = (char *) malloc(size + 15);
+	  if (msg != 0)
+	    {
+	      strcpy(msg, "parse error");
 
-            if (count < 5)
-            {
-               count = 0;
-               for (x = (yyn < 0 ? -yyn : 0);
-                  x < (sizeof(yytname) / sizeof(char *)); x++)
-                  if (yycheck[x + yyn] == x)
-                  {
-                     strcat(msg, count == 0 ? ", expecting `" : " or `");
-                     strcat(msg, yytname[x]);
-                     strcat(msg, "'");
-                     count++;
-                  }
-            }
-            yyerror(msg);
-            free(msg);
-         }
-         else
-            yyerror("parse error; also virtual memory exceeded");
-      }
+	      if (count < 5)
+		{
+		  count = 0;
+		  for (x = (yyn < 0 ? -yyn : 0);
+		       x < (sizeof(yytname) / sizeof(char *)); x++)
+		    if (yycheck[x + yyn] == x)
+		      {
+			strcat(msg, count == 0 ? ", expecting `" : " or `");
+			strcat(msg, yytname[x]);
+			strcat(msg, "'");
+			count++;
+		      }
+		}
+	      yyerror(msg);
+	      free(msg);
+	    }
+	  else
+	    yyerror ("parse error; also virtual memory exceeded");
+	}
       else
 #endif /* YYERROR_VERBOSE */
-         yyerror("parse error");
-   }
+	yyerror("parse error");
+    }
 
-   goto yyerrlab1;
+  goto yyerrlab1;
 yyerrlab1:   /* here on error raised explicitly by an action */
 
-   if (yyerrstatus == 3)
-   {
+  if (yyerrstatus == 3)
+    {
       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
 
       /* return failure if at end of input */
       if (yychar == YYEOF)
-         YYABORT;
+	YYABORT;
 
 #if YYDEBUG != 0
       if (yydebug)
-         fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
+	fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
 #endif
 
       yychar = YYEMPTY;
-   }
+    }
 
-   /* Else will try to reuse lookahead token
-   after shifting the error token.  */
+  /* Else will try to reuse lookahead token
+     after shifting the error token.  */
 
-   yyerrstatus = 3;		/* Each real token shifted decrements this */
+  yyerrstatus = 3;		/* Each real token shifted decrements this */
 
-   goto yyerrhandle;
+  goto yyerrhandle;
 
 yyerrdefault:  /* current state does not do anything special for the error token. */
 
 #if 0
-               /* This is wrong; only states that explicitly want error tokens
-               should shift them.  */
-   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
-   if (yyn) goto yydefault;
+  /* This is wrong; only states that explicitly want error tokens
+     should shift them.  */
+  yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
+  if (yyn) goto yydefault;
 #endif
 
 yyerrpop:   /* pop the current state because it cannot handle the error token */
 
-   if (yyssp == yyss) YYABORT;
-   yyvsp--;
-   yystate = *--yyssp;
+  if (yyssp == yyss) YYABORT;
+  yyvsp--;
+  yystate = *--yyssp;
 #ifdef YYLSP_NEEDED
-   yylsp--;
+  yylsp--;
 #endif
 
 #if YYDEBUG != 0
-   if (yydebug)
-   {
+  if (yydebug)
+    {
       short *ssp1 = yyss - 1;
-      fprintf(stderr, "Error: state stack now");
+      fprintf (stderr, "Error: state stack now");
       while (ssp1 != yyssp)
-         fprintf(stderr, " %d", *++ssp1);
-      fprintf(stderr, "\n");
-   }
+	fprintf (stderr, " %d", *++ssp1);
+      fprintf (stderr, "\n");
+    }
 #endif
 
 yyerrhandle:
 
-   yyn = yypact[yystate];
-   if (yyn == YYFLAG)
-      goto yyerrdefault;
+  yyn = yypact[yystate];
+  if (yyn == YYFLAG)
+    goto yyerrdefault;
 
-   yyn += YYTERROR;
-   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
-      goto yyerrdefault;
+  yyn += YYTERROR;
+  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
+    goto yyerrdefault;
 
-   yyn = yytable[yyn];
-   if (yyn < 0)
-   {
+  yyn = yytable[yyn];
+  if (yyn < 0)
+    {
       if (yyn == YYFLAG)
-         goto yyerrpop;
+	goto yyerrpop;
       yyn = -yyn;
       goto yyreduce;
-   }
-   else if (yyn == 0)
-      goto yyerrpop;
+    }
+  else if (yyn == 0)
+    goto yyerrpop;
 
-   if (yyn == YYFINAL)
-      YYACCEPT;
+  if (yyn == YYFINAL)
+    YYACCEPT;
 
 #if YYDEBUG != 0
-   if (yydebug)
-      fprintf(stderr, "Shifting error token, ");
+  if (yydebug)
+    fprintf(stderr, "Shifting error token, ");
 #endif
 
-   *++yyvsp = yylval;
+  *++yyvsp = yylval;
 #ifdef YYLSP_NEEDED
-   *++yylsp = yylloc;
+  *++yylsp = yylloc;
 #endif
 
-   yystate = yyn;
-   goto yynewstate;
+  yystate = yyn;
+  goto yynewstate;
 }
-#line 612 "cmdgram.y"
+#line 617 "cmdgram.y"
 
 
diff --git a/Engine/source/console/codeBlock.cpp b/Engine/source/console/codeBlock.cpp
index 997519231..d3687a2cd 100644
--- a/Engine/source/console/codeBlock.cpp
+++ b/Engine/source/console/codeBlock.cpp
@@ -565,7 +565,7 @@ bool CodeBlock::compile(const char *codeFileName, StringTableEntry fileName, con
    return true;
 }
 
-void CodeBlock::compileExec(StringTableEntry fileName, const char *inString, ConsoleValue &returnValue, bool noCalls, S32 setFrame)
+ConsoleValue CodeBlock::compileExec(StringTableEntry fileName, const char *inString, bool noCalls, S32 setFrame)
 {
    AssertFatal(Con::isMainThread(), "Compiling code on a secondary thread");
 
@@ -619,7 +619,7 @@ void CodeBlock::compileExec(StringTableEntry fileName, const char *inString, Con
    if (!gStatementList)
    {
       delete this;
-      return;
+      return std::move(ConsoleValue());
    }
 
    resetTables();
@@ -653,7 +653,7 @@ void CodeBlock::compileExec(StringTableEntry fileName, const char *inString, Con
    if (lastIp + 1 != codeSize)
       Con::warnf(ConsoleLogEntry::General, "precompile size mismatch, precompile: %d compile: %d", codeSize, lastIp);
 
-   exec(0, fileName, NULL, 0, 0, noCalls, NULL, returnValue, setFrame);
+   return std::move(exec(0, fileName, NULL, 0, 0, noCalls, NULL, setFrame));
 }
 
 //-------------------------------------------------------------------------
diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index 1d9ae968c..e0bfcee7e 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -420,7 +420,7 @@ void ExprEvalState::setStringVariable(const char *val)
 //-----------------------------------------------------------------------------
 
 U32 gExecCount = 0;
-void CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNamespace, U32 argc, ConsoleValue* argv, bool noCalls, StringTableEntry packageName, ConsoleValue& returnValue, S32 setFrame)
+ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNamespace, U32 argc, ConsoleValue* argv, bool noCalls, StringTableEntry packageName, S32 setFrame)
 {
 #ifdef TORQUE_DEBUG
    U32 stackStart = STR.mStartStackSize;
@@ -432,6 +432,7 @@ void CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNamespace,
    U32 i;
 
    U32 iterDepth = 0;
+   ConsoleValue returnValue;
 
    incRefCount();
    F64* curFloatTable;
@@ -1738,9 +1739,8 @@ void CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNamespace,
          {
             if (nsEntry->mFunctionOffset)
             {
-               ConsoleValue ret;
-               nsEntry->mCode->exec(nsEntry->mFunctionOffset, fnName, nsEntry->mNamespace, callArgc, callArgv, false, nsEntry->mPackage, ret);
-               STR.setStringValue(ret.getString());
+               const char* ret = nsEntry->mCode->exec(nsEntry->mFunctionOffset, fnName, nsEntry->mNamespace, callArgc, callArgv, false, nsEntry->mPackage).getString();
+               STR.setStringValue(ret);
             }
             else // no body
                STR.setStringValue("");
@@ -2128,6 +2128,10 @@ execFinished:
    AssertFatal(!(STR.mStartStackSize > stackStart), "String stack not popped enough in script exec");
    AssertFatal(!(STR.mStartStackSize < stackStart), "String stack popped too much in script exec");
 #endif
+
+   if (returnValue.getType() == ConsoleValueType::cvNone)
+      returnValue.setStringTableEntry(StringTable->EmptyString());
+   return std::move(returnValue);
 }
 
 //------------------------------------------------------------
diff --git a/Engine/source/console/console.cpp b/Engine/source/console/console.cpp
index 150b3f823..78b4ba05f 100644
--- a/Engine/source/console/console.cpp
+++ b/Engine/source/console/console.cpp
@@ -73,6 +73,11 @@ char* ConsoleValue::convertToBuffer() const
    return offset;
 }
 
+const char* ConsoleValue::getConsoleData() const
+{
+   return Con::getData(type, ct->dataPtr, 0, ct->enumTable);
+}
+
 ConsoleDocFragment* ConsoleDocFragment::smFirst;
 ExprEvalState gEvalState;
 StmtNode *gStatementList;
diff --git a/Engine/source/console/console.h b/Engine/source/console/console.h
index cb49911c2..4d9c21296 100644
--- a/Engine/source/console/console.h
+++ b/Engine/source/console/console.h
@@ -158,25 +158,12 @@ class ConsoleValue
 
    char* convertToBuffer() const;
 
-   TORQUE_FORCEINLINE bool isStringType() const
-   {
-      return type == ConsoleValueType::cvString || type == ConsoleValueType::cvSTEntry;
-   }
-
-   TORQUE_FORCEINLINE bool isNumberType() const
-   {
-      return type == ConsoleValueType::cvFloat || type == ConsoleValueType::cvInteger;
-   }
-
    TORQUE_FORCEINLINE bool hasAllocatedData() const
    {
-      return type == ConsoleValueType::cvString || type >= ConsoleValueType::cvConsoleValueType;
+      return type == ConsoleValueType::cvString || isConsoleType();
    }
 
-   TORQUE_FORCEINLINE const char* getConsoleData() const
-   {
-      return Con::getData(type, ct->dataPtr, 0, ct->enumTable);
-   }
+   const char* getConsoleData() const;
 
    TORQUE_FORCEINLINE void cleanupData()
    {
@@ -192,7 +179,7 @@ public:
       type = ConsoleValueType::cvNone;
    }
 
-   ConsoleValue(ConsoleValue&& ref)
+   ConsoleValue(ConsoleValue&& ref) noexcept
    {
       cleanupData();
       type = ref.type;
@@ -209,7 +196,7 @@ public:
          f = ref.f;
          break;
       case cvSTEntry:
-         TORQUE_CASE_FALLTHROUGH
+         TORQUE_CASE_FALLTHROUGH;
       case cvString:
          s = ref.s;
          break;
@@ -229,6 +216,12 @@ public:
       cleanupData();
    }
 
+   TORQUE_FORCEINLINE void reset()
+   {
+      cleanupData();
+      type = ConsoleValueType::cvNone;
+   }
+
    TORQUE_FORCEINLINE F64 getFloat() const
    {
       AssertFatal(type == ConsoleValueType::cvNone, "Attempted to access ConsoleValue when it has no value!");
@@ -263,6 +256,11 @@ public:
       return getConsoleData();
    }
 
+   TORQUE_FORCEINLINE operator const char* () const
+   {
+      return getString();
+   }
+
    TORQUE_FORCEINLINE bool getBool() const
    {
       AssertFatal(type == ConsoleValueType::cvNone, "Attempted to access ConsoleValue when it has no value!");
@@ -290,6 +288,11 @@ public:
       i = val;
    }
 
+   TORQUE_FORCEINLINE void setString(const char* val)
+   {
+      setString(val, dStrlen(val));
+   }
+
    TORQUE_FORCEINLINE void setString(const char* val, S32 len)
    {
       cleanupData();
@@ -315,11 +318,11 @@ public:
       s = const_cast<char*>(val);
    }
 
-   TORQUE_FORCEINLINE void setConsoleData(S32 consoleType, void* dataPtr, EnumTable* enumTable)
+   TORQUE_FORCEINLINE void setConsoleData(S32 consoleType, void* dataPtr, const EnumTable* enumTable)
    {
       cleanupData();
       type = ConsoleValueType::cvSTEntry;
-      ct = new ConsoleValueConsoleType{ dataPtr, enumTable };
+      ct = new ConsoleValueConsoleType{ dataPtr, const_cast<EnumTable*>(enumTable) };
    }
 
    TORQUE_FORCEINLINE S32 getType() const
@@ -327,6 +330,21 @@ public:
       return type;
    }
 
+   TORQUE_FORCEINLINE bool isStringType() const
+   {
+      return type == ConsoleValueType::cvString || type == ConsoleValueType::cvSTEntry;
+   }
+
+   TORQUE_FORCEINLINE bool isNumberType() const
+   {
+      return type == ConsoleValueType::cvFloat || type == ConsoleValueType::cvInteger;
+   }
+
+   TORQUE_FORCEINLINE bool isConsoleType() const
+   {
+      return type >= ConsoleValueType::cvConsoleValueType;
+   }
+
    static void init();
    static S32 getConstantBufferCount() { return (S32)ConversionBufferSize / StringSize; }
 };
diff --git a/Engine/source/console/consoleInternal.cpp b/Engine/source/console/consoleInternal.cpp
index 4fd2aaa0b..d224f6154 100644
--- a/Engine/source/console/consoleInternal.cpp
+++ b/Engine/source/console/consoleInternal.cpp
@@ -480,8 +480,6 @@ Dictionary::Entry::Entry(StringTableEntry in_name)
 
 Dictionary::Entry::~Entry()
 {
-   value.cleanup();
-
    if (notify)
       delete notify;
 }
@@ -560,20 +558,13 @@ Dictionary::Entry* Dictionary::addVariable(const char *name,
    }
 
    Entry *ent = add(StringTable->insert(name));
-
-   if (ent->value.type <= ConsoleValue::TypeInternalString &&
-      ent->value.bufferLen > 0)
-      dFree(ent->value.sval);
-
-   ent->value.type = type;
-   ent->value.dataPtr = dataPtr;
    ent->mUsage = usage;
 
    // Fetch enum table, if any.
 
    ConsoleBaseType* conType = ConsoleBaseType::getType(type);
    AssertFatal(conType, "Dictionary::addVariable - invalid console type");
-   ent->value.enumTable = conType->getEnumTable();
+   ent->value.setConsoleData(type, dataPtr, conType->getEnumTable());
 
    return ent;
 }
@@ -1303,9 +1294,11 @@ ConsoleValue Namespace::Entry::execute(S32 argc, ConsoleValue *argv, ExprEvalSta
    switch (mType)
    {
       case StringCallbackType:
+      {
          const char* str = cb.mStringCallbackFunc(state->thisObject, argc, argv);
          result.setString(str, dStrlen(str));
          break;
+      }
       case IntCallbackType:
          result.setInt(cb.mIntCallbackFunc(state->thisObject, argc, argv));
          break;
diff --git a/Engine/source/console/consoleInternal.h b/Engine/source/console/consoleInternal.h
index ac61f5331..cba74715a 100644
--- a/Engine/source/console/consoleInternal.h
+++ b/Engine/source/console/consoleInternal.h
@@ -274,8 +274,6 @@ public:
 
 typedef VectorPtr<Namespace::Entry *>::iterator NamespaceEntryListIterator;
 
-
-
 class Dictionary
 {
 public:
@@ -307,7 +305,6 @@ public:
          mUsage = NULL;
          mIsConstant = false;
          mNext = NULL;
-         value.init();
       }
 
       Entry(StringTableEntry name);
@@ -317,7 +314,7 @@ public:
 
       void reset() {
          name = NULL;
-         value.cleanup();
+         value.reset();
          if (notify)
             delete notify;
       }
diff --git a/Engine/source/console/engineAPI.h b/Engine/source/console/engineAPI.h
index 8fefd5fdc..aa6eb3ce2 100644
--- a/Engine/source/console/engineAPI.h
+++ b/Engine/source/console/engineAPI.h
@@ -1187,8 +1187,7 @@ public:
       if (Con::isMainThread())
       {
          ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc + sizeof...(ArgTs), mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
+         mArgv[ 0 ].setStringTableEntry(mCallbackName);
         
         Helper::marshallEach(mArgc, mArgv, args...);
         
@@ -1199,7 +1198,7 @@ public:
          SimConsoleThreadExecCallback cb;
          SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc + sizeof...(ArgTs), NULL, false, &cb);
          evt->populateArgs(mArgv);
-         mArgv[ 0 ].value->setStackStringValue(mCallbackName);
+         mArgv[ 0 ].setStringTableEntry(mCallbackName);
         
         Helper::marshallEach(mArgc, mArgv, args...);
         
@@ -1233,7 +1232,6 @@ public:
       if (Con::isMainThread())
       {
          ConsoleStackFrameSaver sav; sav.save();
-         CSTK.reserveValues(mArgc+sizeof...(ArgTs), mArgv);
          mArgv[ 0 ].setString(simCB, dStrlen(simCB));
 
         Helper::marshallEach(mArgc, mArgv, args...);
diff --git a/Engine/source/console/engineDoc.cpp b/Engine/source/console/engineDoc.cpp
index cbbc7249d..56563efe0 100644
--- a/Engine/source/console/engineDoc.cpp
+++ b/Engine/source/console/engineDoc.cpp
@@ -114,7 +114,7 @@ static void dumpVariable(  Stream& stream,
 {
    // Skip variables defined in script.
    
-   if( entry->value.type < 0 )
+   if( !entry->value.isConsoleType() )
       return;
          
    // Skip internals... don't export them.
@@ -149,7 +149,7 @@ static void dumpVariable(  Stream& stream,
             
    // Skip variables for which we can't decipher their type.
 
-   ConsoleBaseType* type = ConsoleBaseType::getType( entry->value.type );
+   ConsoleBaseType* type = ConsoleBaseType::getType( entry->value.getType() );
    if( !type )
    {
       Con::errorf( "Can't find type for variable '%s'", entry->name );
diff --git a/Engine/source/console/optimizer.cpp b/Engine/source/console/optimizer.cpp
new file mode 100644
index 000000000..9bfbb09a5
--- /dev/null
+++ b/Engine/source/console/optimizer.cpp
@@ -0,0 +1,104 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2013 GarageGames, LLC
+// Copyright (c) 2021 TGEMIT Authors & Contributors
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+
+#include "console/console.h"
+#include "console/codeBlock.h"
+
+static bool isLiteralNumber(ExprNode* node)
+{
+   ExprNodeName name = node->getExprNodeNameEnum();
+   return name == NameFloatNode || name == NameIntNode;
+}
+
+static F64 getFloatValue(ExprNode* node)
+{
+   if (node->getExprNodeNameEnum() == NameFloatNode)
+      return static_cast<FloatNode*>(node)->value;
+   return (F64)static_cast<IntNode*>(node)->value;
+}
+
+static S32 getIntValue(ExprNode* node)
+{
+   if (node->getExprNodeNameEnum() == NameFloatNode)
+      return (S32)static_cast<FloatNode*>(node)->value;
+   return static_cast<IntNode*>(node)->value;
+}
+
+bool FloatBinaryExprNode::optimize()
+{
+   // Perform constant folding
+   if (isLiteralNumber(right) && isLiteralNumber(left))
+   {
+      F64 rightValue = getFloatValue(right);
+      F64 leftValue = getFloatValue(left);
+      F64 result = 0.0;
+
+      switch (op)
+      {
+      case '+':
+         result = leftValue + rightValue;
+         break;
+      case '-':
+         result = leftValue - rightValue;
+         break;
+      case '*':
+         result = leftValue * rightValue;
+         break;
+      case '/':
+         if (rightValue != 0.0)
+            result = leftValue / rightValue;
+         break;
+      }
+
+      optimizedNode = FloatNode::alloc(dbgLineNumber, result);
+      return true;
+   }
+
+   return false;
+}
+
+bool IntBinaryExprNode::optimize()
+{
+   if (op == '%' && left->getExprNodeNameEnum() == NameVarNode && isLiteralNumber(right))
+   {
+      // %a % intconst
+      S32 val = getIntValue(right);
+      switch (val)
+      {
+      case 2: 
+         op = '&';
+         optimizedNode = IntNode::alloc(dbgLineNumber, 1);
+         return true;
+      case 4:
+         op = '&';
+         optimizedNode = IntNode::alloc(dbgLineNumber, 3);
+         return true;
+      case 8:
+         op = '&';
+         optimizedNode = IntNode::alloc(dbgLineNumber, 7);
+         return true;
+      }
+   }
+
+   return false;
+}
diff --git a/Engine/source/console/simObject.cpp b/Engine/source/console/simObject.cpp
index 008ba9698..56a88cb8d 100644
--- a/Engine/source/console/simObject.cpp
+++ b/Engine/source/console/simObject.cpp
@@ -2962,7 +2962,7 @@ DefineEngineStringlyVariadicMethod( SimObject, call, const char*, 3, 0, "( strin
    "@param args Zero or more arguments for the method.\n"
    "@return The result of the method call." )
 {
-   argv[1] = argv[2];
+   argv[1].setString(argv[2], dStrlen(argv[2]));
    return Con::execute( object, argc - 1, argv + 1 );
 }
 
@@ -3065,9 +3065,9 @@ DefineEngineStringlyVariadicMethod( SimObject,schedule, S32, 4, 0, "( float time
    "@param args The arguments with which to call the method.\n"
    "@return The numeric ID of the created schedule.  Can be used to cancel the call.\n" )
 {
-   U32 timeDelta = U32(dAtof(argv[2]));
-   argv[2] = argv[3];
-   argv[3] = argv[1];
+   U32 timeDelta = U32(argv[2].getFloat());
+   argv[2].setString(argv[3].getString());
+   argv[3].setString(argv[1].getString());
    SimConsoleEvent *evt = new SimConsoleEvent(argc - 2, argv + 2, true);
    S32 ret = Sim::postEvent(object, evt, Sim::getCurrentTime() + timeDelta);
    // #ifdef DEBUG
diff --git a/Engine/source/console/test/consoleTest.cpp b/Engine/source/console/test/consoleTest.cpp
index d1ced9ec9..a143d1835 100644
--- a/Engine/source/console/test/consoleTest.cpp
+++ b/Engine/source/console/test/consoleTest.cpp
@@ -1,4 +1,4 @@
-#ifdef 0
+#if 0
 
 #ifdef TORQUE_TESTS_ENABLED
 #include "testing/unitTesting.h"
diff --git a/Engine/source/gui/controls/guiGameListMenuCtrl.cpp b/Engine/source/gui/controls/guiGameListMenuCtrl.cpp
index ece9535e5..276f4511d 100644
--- a/Engine/source/gui/controls/guiGameListMenuCtrl.cpp
+++ b/Engine/source/gui/controls/guiGameListMenuCtrl.cpp
@@ -361,10 +361,8 @@ void GuiGameListMenuCtrl::onRenderSliderOption(Row* row, Point2I currentOffset)
    // calculate text to be at the center between the arrows
    GFont* font = profile->mFont;
 
-   ConsoleValue val;
-   val.setFloatValue(row->mValue);
-
-   const char* stringVal = val.getStringValue();
+   char stringVal[32];
+   dSprintf(stringVal, 32, "%f", row->mValue);
 
    S32 textWidth = font->getStrWidth(stringVal);
    S32 columnWidth = profile->mHitAreaLowerRight.x * xScale - profile->mRightPad - columnSplit;
diff --git a/Engine/source/shaderGen/customShaderFeature.cpp b/Engine/source/shaderGen/customShaderFeature.cpp
index c184cb128..25e2975b0 100644
--- a/Engine/source/shaderGen/customShaderFeature.cpp
+++ b/Engine/source/shaderGen/customShaderFeature.cpp
@@ -236,7 +236,7 @@ DefineEngineStringlyVariadicMethod(CustomShaderFeatureData, writeLine, void, 3,
    "@param args Zero or more arguments for the method.\n"
    "@return The result of the method call.")
 {
-   object->writeLine(argv[2], argc - 3, argv + 3);
+   object->writeLine(argv[2].getString(), argc - 3, argv + 3);
 }
 
 DefineEngineMethod(CustomShaderFeatureData, hasFeature, bool, (String name), (""), "")

From f776e73b04c67271516aab4c0e543cd693af912c Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Fri, 2 Apr 2021 00:57:49 -0400
Subject: [PATCH 006/399] cleanup

---
 Engine/source/console/compiledEval.cpp    |  7 +----
 Engine/source/console/console.cpp         | 12 ++++-----
 Engine/source/console/console.h           | 32 +++++++++++++----------
 Engine/source/console/consoleInternal.cpp | 13 ++++++++-
 Engine/source/console/consoleInternal.h   |  5 +++-
 Engine/source/console/engineAPI.h         |  8 +++---
 Engine/source/console/simEvents.cpp       |  6 ++---
 Engine/source/console/simManager.cpp      |  4 ---
 Engine/source/console/simObject.cpp       |  2 +-
 Engine/source/console/stringStack.cpp     |  2 +-
 Engine/source/console/stringStack.h       | 13 ---------
 11 files changed, 50 insertions(+), 54 deletions(-)

diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index e0bfcee7e..bffe06980 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -1076,7 +1076,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
             STR.rewind();
 
             returnValue.setString(retVal, STR.mLen);
-            //STR.setStringValue(returnValue); // Not nice but works.
+            STR.setStringValue(retVal); // Not nice but works.
          }
 
          goto execFinished;
@@ -2070,9 +2070,6 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
       }
    }
 execFinished:
-#ifdef TORQUE_DEBUG
-   AssertFatal(returnValue.getType() == ConsoleValueType::cvNone, "returnValue was never set during script exec");
-#endif
 
    if (telDebuggerOn && setFrame < 0)
       TelDebugger->popStackFrame();
@@ -2129,8 +2126,6 @@ execFinished:
    AssertFatal(!(STR.mStartStackSize < stackStart), "String stack popped too much in script exec");
 #endif
 
-   if (returnValue.getType() == ConsoleValueType::cvNone)
-      returnValue.setStringTableEntry(StringTable->EmptyString());
    return std::move(returnValue);
 }
 
diff --git a/Engine/source/console/console.cpp b/Engine/source/console/console.cpp
index 78b4ba05f..a9dd4de40 100644
--- a/Engine/source/console/console.cpp
+++ b/Engine/source/console/console.cpp
@@ -1555,7 +1555,7 @@ ConsoleValue _internalExecute(S32 argc, ConsoleValue argv[])
    if (result)
    {
       ConsoleValue ret;
-      ret.setString(methodRes, dStrlen(methodRes));
+      ret.setString(methodRes);
       return std::move(ret);
    }
    
@@ -1644,7 +1644,7 @@ static ConsoleValue _internalExecute(SimObject *object, S32 argc, ConsoleValue a
    if (result)
    {
       ConsoleValue val;
-      val.setString(methodRes, dStrlen(methodRes));
+      val.setString(methodRes);
       return std::move(val);
    }
 
@@ -1672,7 +1672,7 @@ static ConsoleValue _internalExecute(SimObject *object, S32 argc, ConsoleValue a
       gEvalState.thisObject = save;
 
       // Twiddle it back
-      argv[1].setString(oldIdent, dStrlen(oldIdent));
+      argv[1].setString(oldIdent);
 
       return std::move(ret);
    }
@@ -1934,8 +1934,8 @@ void postConsoleInput( RawData data )
    // TODO(JTH): Mem leak
    // Schedule this to happen at the next time event.
    ConsoleValue* argv = new ConsoleValue[2];
-   argv[0].setString("eval", 4);
-   argv[1].setString(reinterpret_cast<const char*>(data.data), dStrlen(reinterpret_cast<const char*>(data.data)));
+   argv[0].setString("eval");
+   argv[1].setString(reinterpret_cast<const char*>(data.data));
 
    Sim::postCurrentEvent(Sim::getRootGroup(), new SimConsoleEvent(2, argv, false));
 }
@@ -2577,7 +2577,7 @@ StringArrayToConsoleValueWrapper::StringArrayToConsoleValueWrapper(int targc, co
 
    for (int i=0; i<targc; i++)
    {
-      argv[i].setString(targv[i], dStrlen(targv[i]));
+      argv[i].setString(targv[i]);
    }
 }
 
diff --git a/Engine/source/console/console.h b/Engine/source/console/console.h
index 4d9c21296..dfdb90010 100644
--- a/Engine/source/console/console.h
+++ b/Engine/source/console/console.h
@@ -36,6 +36,7 @@
 
 #include "core/util/str.h"
 #include "core/util/journal/journaledSignal.h"
+#include "core/stringTable.h"
 
 class SimObject;
 class Namespace;
@@ -119,7 +120,6 @@ extern char *typeValueEmpty;
 
 enum ConsoleValueType
 {
-   cvNone = -5,
    cvInteger = -4,
    cvFloat = -3,
    cvString = -2,
@@ -160,7 +160,7 @@ class ConsoleValue
 
    TORQUE_FORCEINLINE bool hasAllocatedData() const
    {
-      return type == ConsoleValueType::cvString || isConsoleType();
+      return (type == ConsoleValueType::cvString || isConsoleType()) && data != NULL;
    }
 
    const char* getConsoleData() const;
@@ -170,13 +170,14 @@ class ConsoleValue
       if (hasAllocatedData())
       {
          dFree(data);
+         data = NULL;
       }
    }
 
 public:
    ConsoleValue()
    {
-      type = ConsoleValueType::cvNone;
+      setEmptyString();
    }
 
    ConsoleValue(ConsoleValue&& ref) noexcept
@@ -186,9 +187,6 @@ public:
 
       switch (ref.type)
       {
-      TORQUE_UNLIKELY
-      case cvNone:
-         break;
       case cvInteger:
          i = ref.i;
          break;
@@ -205,7 +203,7 @@ public:
          break;
       }
 
-      ref.type = cvNone;
+      ref.setEmptyString();
    }
 
    ConsoleValue(const ConsoleValue&) = delete;
@@ -219,12 +217,11 @@ public:
    TORQUE_FORCEINLINE void reset()
    {
       cleanupData();
-      type = ConsoleValueType::cvNone;
+      setEmptyString();
    }
 
    TORQUE_FORCEINLINE F64 getFloat() const
    {
-      AssertFatal(type == ConsoleValueType::cvNone, "Attempted to access ConsoleValue when it has no value!");
       if (type == ConsoleValueType::cvFloat)
          return f;
       if (type == ConsoleValueType::cvInteger)
@@ -236,7 +233,6 @@ public:
 
    TORQUE_FORCEINLINE S64 getInt() const
    {
-      AssertFatal(type == ConsoleValueType::cvNone, "Attempted to access ConsoleValue when it has no value!");
       if (type == ConsoleValueType::cvInteger)
          return i;
       if (type == ConsoleValueType::cvFloat)
@@ -248,7 +244,6 @@ public:
 
    TORQUE_FORCEINLINE const char* getString() const
    {
-      AssertFatal(type == ConsoleValueType::cvNone, "Attempted to access ConsoleValue when it has no value!");
       if (isStringType())
          return s;
       if (isNumberType())
@@ -263,7 +258,6 @@ public:
 
    TORQUE_FORCEINLINE bool getBool() const
    {
-      AssertFatal(type == ConsoleValueType::cvNone, "Attempted to access ConsoleValue when it has no value!");
       if (type == ConsoleValueType::cvInteger)
          return (bool)i;
       if (type == ConsoleValueType::cvFloat)
@@ -275,7 +269,6 @@ public:
 
    TORQUE_FORCEINLINE void setFloat(const F64 val)
    {
-      AssertFatal(type == ConsoleValueType::cvNone, "Attempted to access ConsoleValue when it has no value!");
       cleanupData();
       type = ConsoleValueType::cvFloat;
       f = val;
@@ -290,11 +283,17 @@ public:
 
    TORQUE_FORCEINLINE void setString(const char* val)
    {
-      setString(val, dStrlen(val));
+      setString(val, dStrlen(val) + 1);
    }
 
    TORQUE_FORCEINLINE void setString(const char* val, S32 len)
    {
+      if (len == 0)
+      {
+         setEmptyString();
+         return;
+      }
+
       cleanupData();
 
       type = ConsoleValueType::cvString;
@@ -318,6 +317,11 @@ public:
       s = const_cast<char*>(val);
    }
 
+   TORQUE_FORCEINLINE void setEmptyString()
+   {
+      setStringTableEntry(StringTable->EmptyString());
+   }
+
    TORQUE_FORCEINLINE void setConsoleData(S32 consoleType, void* dataPtr, const EnumTable* enumTable)
    {
       cleanupData();
diff --git a/Engine/source/console/consoleInternal.cpp b/Engine/source/console/consoleInternal.cpp
index d224f6154..0444369f2 100644
--- a/Engine/source/console/consoleInternal.cpp
+++ b/Engine/source/console/consoleInternal.cpp
@@ -633,6 +633,10 @@ void ExprEvalState::pushFrame(StringTableEntry frameName, Namespace *ns, S32 reg
 
    AssertFatal(!newFrame.getCount(), "ExprEvalState::pushFrame - Dictionary not empty!");
 
+   ConsoleValue* consoleValArray = new ConsoleValue[registerCount];
+   localStack.push_back(ConsoleValueFrame(consoleValArray, false));
+   currentRegisterArray = &localStack.last();
+
 #ifdef DEBUG_SPEW
    validate();
 #endif
@@ -653,6 +657,13 @@ void ExprEvalState::popFrame()
    stack[mStackDepth]->reset();
    currentVariable = NULL;
 
+   const ConsoleValueFrame& frame = localStack.last();
+   localStack.pop_back();
+   if (!frame.isReference)
+      delete[] frame.values;
+
+   currentRegisterArray = localStack.size() ? &localStack.last() : NULL;
+
 #ifdef DEBUG_SPEW
    validate();
 #endif
@@ -1296,7 +1307,7 @@ ConsoleValue Namespace::Entry::execute(S32 argc, ConsoleValue *argv, ExprEvalSta
       case StringCallbackType:
       {
          const char* str = cb.mStringCallbackFunc(state->thisObject, argc, argv);
-         result.setString(str, dStrlen(str));
+         result.setString(str);
          break;
       }
       case IntCallbackType:
diff --git a/Engine/source/console/consoleInternal.h b/Engine/source/console/consoleInternal.h
index cba74715a..085a7a0e5 100644
--- a/Engine/source/console/consoleInternal.h
+++ b/Engine/source/console/consoleInternal.h
@@ -372,7 +372,7 @@ public:
             return;
          }
 
-         value.setString(newValue, dStrlen(newValue));
+         value.setString(newValue);
 
          // Fire off the notification if we have one.
          if (notify)
@@ -456,6 +456,9 @@ struct ConsoleValueFrame
    ConsoleValue* values;
    bool isReference;
 
+   ConsoleValueFrame() : values(NULL), isReference(false)
+   {}
+
    ConsoleValueFrame(ConsoleValue* vals, bool isRef)
    {
       values = vals;
diff --git a/Engine/source/console/engineAPI.h b/Engine/source/console/engineAPI.h
index aa6eb3ce2..5cfa7cc09 100644
--- a/Engine/source/console/engineAPI.h
+++ b/Engine/source/console/engineAPI.h
@@ -171,11 +171,11 @@ inline void EngineMarshallData( F32 arg, S32& argc, ConsoleValue *argv )
 }
 inline void EngineMarshallData( const char* arg, S32& argc, ConsoleValue *argv )
 {
-   argv[ argc++ ].setString(arg, dStrlen(arg));
+   argv[ argc++ ].setString(arg);
 }
 inline void EngineMarshallData( char* arg, S32& argc, ConsoleValue *argv )
 {
-   argv[ argc++ ].setString(arg, dStrlen(arg));
+   argv[ argc++ ].setString(arg);
 }
 
 template< typename T >
@@ -1232,7 +1232,7 @@ public:
       if (Con::isMainThread())
       {
          ConsoleStackFrameSaver sav; sav.save();
-         mArgv[ 0 ].setString(simCB, dStrlen(simCB));
+         mArgv[ 0 ].setString(simCB);
 
         Helper::marshallEach(mArgc, mArgv, args...);
 
@@ -1243,7 +1243,7 @@ public:
          SimConsoleThreadExecCallback cb;
          SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+sizeof...(ArgTs), NULL, true, &cb);
          evt->populateArgs(mArgv);
-         mArgv[ 0 ].setString(simCB, dStrlen(simCB));
+         mArgv[ 0 ].setString(simCB);
         
         Helper::marshallEach(mArgc, mArgv, args...);
 
diff --git a/Engine/source/console/simEvents.cpp b/Engine/source/console/simEvents.cpp
index 97eb74d40..e375438e9 100644
--- a/Engine/source/console/simEvents.cpp
+++ b/Engine/source/console/simEvents.cpp
@@ -38,7 +38,7 @@ SimConsoleEvent::SimConsoleEvent(S32 argc, ConsoleValue *argv, bool onObject)
    {
       if (argv)
       {
-         mArgv->setString(argv[i].getString(), dStrlen(argv[i].getString()));
+         mArgv->setString(argv[i].getString());
       }
    }
 }
@@ -92,7 +92,7 @@ void SimConsoleEvent::populateArgs(ConsoleValue *argv)
 {
    for (U32 i=0; i<mArgc; i++)
    {
-      argv[i].setString(mArgv[i].getString(), dStrlen(mArgv[i].getString()));
+      argv[i].setString(mArgv[i].getString());
    }
 }
 
@@ -111,7 +111,7 @@ SimConsoleThreadExecCallback::~SimConsoleThreadExecCallback()
 void SimConsoleThreadExecCallback::handleCallback(ConsoleValue ret)
 {
    // can we move this pls?
-   retVal.setString(ret.getString(), dStrlen(ret.getString()));
+   retVal.setString(ret.getString());
    sem->release();
 }
 
diff --git a/Engine/source/console/simManager.cpp b/Engine/source/console/simManager.cpp
index b874f752e..7aaf773e6 100644
--- a/Engine/source/console/simManager.cpp
+++ b/Engine/source/console/simManager.cpp
@@ -388,8 +388,6 @@ SimObject* findObject(const char* name)
 
 SimObject* findObject(const ConsoleValue &val)
 {
-   if (val.getType() == ConsoleValueType::cvNone)
-      return NULL;
    if (val.getType() == ConsoleValueType::cvInteger)
       return findObject((SimObjectId)val.getInt());
    return findObject(val.getString());
@@ -397,8 +395,6 @@ SimObject* findObject(const ConsoleValue &val)
 
 SimObject* findObject(ConsoleValue* val)
 {
-   if (val->getType() == ConsoleValueType::cvNone)
-      return NULL;
    if (val->getType() == ConsoleValueType::cvInteger)
       return findObject((SimObjectId)val->getInt());
    return findObject(val->getString());
diff --git a/Engine/source/console/simObject.cpp b/Engine/source/console/simObject.cpp
index 56a88cb8d..17a4c1c73 100644
--- a/Engine/source/console/simObject.cpp
+++ b/Engine/source/console/simObject.cpp
@@ -2962,7 +2962,7 @@ DefineEngineStringlyVariadicMethod( SimObject, call, const char*, 3, 0, "( strin
    "@param args Zero or more arguments for the method.\n"
    "@return The result of the method call." )
 {
-   argv[1].setString(argv[2], dStrlen(argv[2]));
+   argv[1].setString(argv[2]);
    return Con::execute( object, argc - 1, argv + 1 );
 }
 
diff --git a/Engine/source/console/stringStack.cpp b/Engine/source/console/stringStack.cpp
index cfe2d83f5..78d98f183 100644
--- a/Engine/source/console/stringStack.cpp
+++ b/Engine/source/console/stringStack.cpp
@@ -82,7 +82,7 @@ void StringStack::setIntValue(U32 i)
 void StringStack::setFloatValue(F64 v)
 {
    validateBufferSize(mStart + 32);
-   dSprintf(mBuffer + mStart, 32, "%g", v);
+   dSprintf(mBuffer + mStart, 32, "%.9g", v);
    mLen = dStrlen(mBuffer + mStart);
 }
 
diff --git a/Engine/source/console/stringStack.h b/Engine/source/console/stringStack.h
index 1cb8a5bc0..1b5d5d84e 100644
--- a/Engine/source/console/stringStack.h
+++ b/Engine/source/console/stringStack.h
@@ -138,16 +138,6 @@ struct StringStack
       return mBuffer + mStartOffsets[mStartStackSize-1];
    }
 
-   inline StringStackPtr getStringValuePtr()
-   {
-      return (getStringValue() - mBuffer);
-   }
-
-   inline StringStackPtr getPreviousStringValuePtr()
-   {
-      return (getPreviousStringValue() - mBuffer);
-   }
-
    /// Advance the start stack, placing a zero length string on the top.
    ///
    /// @note You should use StringStack::push, not this, if you want to
@@ -184,9 +174,6 @@ struct StringStack
    void popFrame();
 
    void clearFrames();
-
-   /// Get the arguments for a function call from the stack.
-   void getArgcArgv(StringTableEntry name, U32 *argc, const char ***in_argv, bool popStackFrame = false);
 };
 
 extern StringStack STR;

From 3e04196a5379c8e3cac26d1f87324ea7ec75c94e Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Sat, 3 Apr 2021 01:53:40 -0400
Subject: [PATCH 007/399] make tests pass.

---
 Engine/source/console/astAlloc.cpp            |   2 +-
 Engine/source/console/compiledEval.cpp        |  22 ++-
 Engine/source/console/console.h               |   9 +-
 Engine/source/console/consoleInternal.cpp     |  12 +-
 Engine/source/console/consoleInternal.h       |   2 +
 Engine/source/console/engineAPI.h             |   2 +-
 Engine/source/console/test/ScriptTest.cpp     | 176 +++++++-----------
 .../source/core/strings/stringFunctions.cpp   |   2 +-
 8 files changed, 103 insertions(+), 124 deletions(-)

diff --git a/Engine/source/console/astAlloc.cpp b/Engine/source/console/astAlloc.cpp
index 58d5a0d7f..50d02bcaa 100644
--- a/Engine/source/console/astAlloc.cpp
+++ b/Engine/source/console/astAlloc.cpp
@@ -254,7 +254,7 @@ StrConstNode* StrConstNode::alloc(S32 lineNumber, char* str, bool tag, bool doc)
    ret->str = (char*)consoleAlloc(len + 1);
    ret->tag = tag;
    ret->doc = doc;
-   dStrcpy(ret->str, str, len);
+   dStrcpy(ret->str, str, len + 1);
    ret->str[len] = '\0';
 
    return ret;
diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index bffe06980..0375ab14e 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -512,6 +512,12 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
       curStringTable = globalStrings;
       curStringTableLen = globalStringsMaxLen;
 
+      // If requested stack frame isn't available, request a new one
+      // (this prevents assert failures when creating local
+      //  variables without a stack frame)
+      if (gEvalState.getStackDepth() <= setFrame)
+         setFrame = -1;
+
       // Do we want this code to execute using a new stack frame?
       if (setFrame < 0)
       {
@@ -519,13 +525,13 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          gCallStack.pushFrame(0);
          popFrame = true;
       }
-      else if (!gEvalState.stack.empty())
+      else
       {
          // We want to copy a reference to an existing stack frame
          // on to the top of the stack.  Any change that occurs to
          // the locals during this new frame will also occur in the
          // original frame.
-         S32 stackIndex = gEvalState.stack.size() - setFrame - 1;
+         S32 stackIndex = gEvalState.getTopOfStack() - setFrame - 1;
          gEvalState.pushFrameRef(stackIndex);
          popFrame = true;
       }
@@ -1062,7 +1068,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          // We're falling thru here on purpose.
 
       case OP_RETURN:
-
+      {
          if (iterDepth > 0)
          {
             // Clear iterator state.
@@ -1074,13 +1080,13 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
 
             const char* retVal = STR.getStringValue();
             STR.rewind();
-
-            returnValue.setString(retVal, STR.mLen);
             STR.setStringValue(retVal); // Not nice but works.
          }
 
-         goto execFinished;
+         returnValue.setString(STR.getStringValue(), STR.mLen);
 
+         goto execFinished;
+      }
       case OP_RETURN_FLT:
 
          if (iterDepth > 0)
@@ -1739,8 +1745,8 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          {
             if (nsEntry->mFunctionOffset)
             {
-               const char* ret = nsEntry->mCode->exec(nsEntry->mFunctionOffset, fnName, nsEntry->mNamespace, callArgc, callArgv, false, nsEntry->mPackage).getString();
-               STR.setStringValue(ret);
+               ConsoleValue returnFromFn = nsEntry->mCode->exec(nsEntry->mFunctionOffset, fnName, nsEntry->mNamespace, callArgc, callArgv, false, nsEntry->mPackage);
+               STR.setStringValue(returnFromFn.getString());
             }
             else // no body
                STR.setStringValue("");
diff --git a/Engine/source/console/console.h b/Engine/source/console/console.h
index dfdb90010..763adc564 100644
--- a/Engine/source/console/console.h
+++ b/Engine/source/console/console.h
@@ -203,6 +203,7 @@ public:
          break;
       }
 
+      ref.data = NULL;
       ref.setEmptyString();
    }
 
@@ -283,7 +284,7 @@ public:
 
    TORQUE_FORCEINLINE void setString(const char* val)
    {
-      setString(val, dStrlen(val) + 1);
+      setString(val, dStrlen(val));
    }
 
    TORQUE_FORCEINLINE void setString(const char* val, S32 len)
@@ -298,9 +299,9 @@ public:
 
       type = ConsoleValueType::cvString;
 
-      s = (char*)dMalloc(len + 1);
-      s[len] = 0x0;
-      dStrcpy(s, val, len);
+      s = (char*)dMalloc(static_cast<dsize_t>(len) + 1);
+      s[len] = '\0';
+      dStrcpy(s, val, static_cast<dsize_t>(len) + 1);
    }
 
    TORQUE_FORCEINLINE void setBool(const bool val)
diff --git a/Engine/source/console/consoleInternal.cpp b/Engine/source/console/consoleInternal.cpp
index 0444369f2..336de99fa 100644
--- a/Engine/source/console/consoleInternal.cpp
+++ b/Engine/source/console/consoleInternal.cpp
@@ -637,6 +637,8 @@ void ExprEvalState::pushFrame(StringTableEntry frameName, Namespace *ns, S32 reg
    localStack.push_back(ConsoleValueFrame(consoleValArray, false));
    currentRegisterArray = &localStack.last();
 
+   AssertFatal(mStackDepth == localStack.size(), avar("Stack sizes do not match. mStackDepth = %d, localStack = %d", mStackDepth, localStack.size()));
+
 #ifdef DEBUG_SPEW
    validate();
 #endif
@@ -664,6 +666,8 @@ void ExprEvalState::popFrame()
 
    currentRegisterArray = localStack.size() ? &localStack.last() : NULL;
 
+   AssertFatal(mStackDepth == localStack.size(), avar("Stack sizes do not match. mStackDepth = %d, localStack = %d", mStackDepth, localStack.size()));
+
 #ifdef DEBUG_SPEW
    validate();
 #endif
@@ -671,7 +675,7 @@ void ExprEvalState::popFrame()
 
 void ExprEvalState::pushFrameRef(S32 stackIndex)
 {
-   AssertFatal(stackIndex >= 0 && stackIndex < stack.size(), "You must be asking for a valid frame!");
+   AssertFatal(stackIndex >= 0 && stackIndex < mStackDepth, "You must be asking for a valid frame!");
 
 #ifdef DEBUG_SPEW
    validate();
@@ -695,6 +699,12 @@ void ExprEvalState::pushFrameRef(S32 stackIndex)
    mStackDepth++;
    currentVariable = NULL;
 
+   ConsoleValue* values = localStack[stackIndex].values;
+   localStack.push_back(ConsoleValueFrame(values, true));
+   currentRegisterArray = &localStack.last();
+
+   AssertFatal(mStackDepth == localStack.size(), avar("Stack sizes do not match. mStackDepth = %d, localStack = %d", mStackDepth, localStack.size()));
+
 #ifdef DEBUG_SPEW
    validate();
 #endif
diff --git a/Engine/source/console/consoleInternal.h b/Engine/source/console/consoleInternal.h
index 085a7a0e5..e1d2cd462 100644
--- a/Engine/source/console/consoleInternal.h
+++ b/Engine/source/console/consoleInternal.h
@@ -494,6 +494,8 @@ public:
    /// an interior pointer that will become invalid when the object changes address.
    Vector< Dictionary* > stack;
 
+   S32 getTopOfStack() { return (S32)mStackDepth; }
+
    Vector< ConsoleValueFrame > localStack;
    ConsoleValueFrame* currentRegisterArray; // contains array at to top of localStack
 
diff --git a/Engine/source/console/engineAPI.h b/Engine/source/console/engineAPI.h
index 5cfa7cc09..a8540968a 100644
--- a/Engine/source/console/engineAPI.h
+++ b/Engine/source/console/engineAPI.h
@@ -151,7 +151,7 @@ template< typename T >
 inline void EngineMarshallData( const T& arg, S32& argc, ConsoleValue *argv )
 {
    const char* str = castConsoleTypeToString(arg);;
-   argv[ argc++ ].setString(str, dStrlen(str));
+   argv[ argc++ ].setString(str);
 }
 inline void EngineMarshallData( bool arg, S32& argc, ConsoleValue *argv )
 {
diff --git a/Engine/source/console/test/ScriptTest.cpp b/Engine/source/console/test/ScriptTest.cpp
index 1b937c755..3bd6a1bb4 100644
--- a/Engine/source/console/test/ScriptTest.cpp
+++ b/Engine/source/console/test/ScriptTest.cpp
@@ -30,139 +30,99 @@
 #include "math/mMath.h"
 #include "console/stringStack.h"
 
-template<typename T>
-inline T Convert(ConsoleValue&);
-
-template<>
-inline U32 Convert(ConsoleValue &val)
+inline ConsoleValue RunScript(const char* str)
 {
-   return val.getInt();
-}
-
-template<>
-inline S32 Convert(ConsoleValue &val)
-{
-   return val.getInt();
-}
-
-template<>
-inline bool Convert(ConsoleValue &val)
-{
-   return val.getBool();
-}
-
-template<>
-inline F32 Convert(ConsoleValue &val)
-{
-   return val.getFloat();
-}
-
-template<>
-inline const char* Convert(ConsoleValue &val)
-{
-   return val.getString();
-}
-
-template<>
-inline SimObject* Convert(ConsoleValue &val)
-{
-   return Sim::findObject(val);
-}
-
-template<typename T>
-inline T RunScript(const char* str)
-{
-   return Convert<T>(std::move(Con::evaluate(str, false, NULL)));
+   return std::move(Con::evaluate(str, false, NULL));
 }
 
 TEST(Script, Basic_Arithmetic)
 {
-   S32 add = RunScript<S32>(R"(
+   ConsoleValue add = RunScript(R"(
          return 1.0 + 1;
    )");
 
-   EXPECT_EQ(add, 2);
+   ASSERT_EQ(add.getInt(), 2);
 
-   S32 sub = RunScript<S32>(R"(
+   ConsoleValue sub = RunScript(R"(
          return 10 - 1.0;
    )");
 
-   EXPECT_EQ(sub, 9);
+   ASSERT_EQ(sub.getInt(), 9);
 
-   S32 mult = RunScript<S32>(R"(
+   ConsoleValue mult = RunScript(R"(
          return 10 * 2.5;
    )");
 
-   EXPECT_EQ(mult, 25);
+   ASSERT_EQ(mult.getInt(), 25);
 
-   S32 div = RunScript<S32>(R"(
+   ConsoleValue div = RunScript(R"(
          return 10.0 / 2;
    )");
 
-   EXPECT_EQ(div, 5);
+   ASSERT_EQ(div.getInt(), 5);
 }
 
 TEST(Script, Complex_Arithmetic)
 {
-   S32 result = RunScript<S32>(R"(
+   ConsoleValue result = RunScript(R"(
          return 1 * 2 - (0.5 * 2);
    )");
 
-   EXPECT_EQ(result, 1);
+   ASSERT_EQ(result.getInt(), 1);
 
-   S32 result2 = RunScript<S32>(R"(
+   ConsoleValue result2 = RunScript(R"(
          return 1 * 2 * 3 % 2;
    )");
 
-   EXPECT_EQ(result2, 0);
+   ASSERT_EQ(result2.getInt(), 0);
 }
 
 TEST(Script, Basic_Concatination)
 {
-   const char* result1 = RunScript<const char*>(R"(
+   ConsoleValue result1 = RunScript(R"(
          return "a" @ "b";
    )");
 
-   EXPECT_STREQ(result1, "ab");
+   ASSERT_STREQ(result1.getString(), "ab");
 
-   const char* result2 = RunScript<const char*>(R"(
+   ConsoleValue result2 = RunScript(R"(
          return "a" SPC "b";
    )");
 
-   EXPECT_STREQ(result2, "a b");
+   ASSERT_STREQ(result2.getString(), "a b");
 
-   const char* result3 = RunScript<const char*>(R"(
+   ConsoleValue result3 = RunScript(R"(
          return "a" TAB "b";
    )");
 
-   EXPECT_STREQ(result3, "a\tb");
+   ASSERT_STREQ(result3.getString(), "a\tb");
 
-   const char* result4 = RunScript<const char*>(R"(
+   ConsoleValue result4 = RunScript(R"(
          return "a" NL "b";
    )");
 
-   EXPECT_STREQ(result4, "a\nb");
+   ASSERT_STREQ(result4.getString(), "a\nb");
 
-   const char* complex = RunScript<const char*>(R"(
+   ConsoleValue complex = RunScript(R"(
          return "a" @ "b" @ "c" @ "d";
    )");
 
-   EXPECT_STREQ(complex, "abcd");
+   ASSERT_STREQ(complex.getString(), "abcd");
 }
 
 TEST(Script, Basic_Global_Variable_Tests)
 {
-   S32 value = RunScript<S32>(R"(
+   ConsoleValue value = RunScript(R"(
          $a = 1;
          return $a;
    )");
 
-   EXPECT_EQ(value, 1);
+   ASSERT_EQ(value.getInt(), 1);
 }
 
 TEST(Script, Variable_Chaining_And_Usage)
 {
-   S32 value = RunScript<S32>(R"(
+   ConsoleValue value = RunScript(R"(
          function t() 
          {
             %a = %b = 2;
@@ -171,9 +131,9 @@ TEST(Script, Variable_Chaining_And_Usage)
          return t();
    )");
 
-   EXPECT_EQ(value, 2);
+   ASSERT_EQ(value.getInt(), 2);
 
-   S32 valueGlobal = RunScript<S32>(R"(
+   ConsoleValue valueGlobal = RunScript(R"(
          function t() 
          {
             $a = %b = 2;
@@ -182,9 +142,9 @@ TEST(Script, Variable_Chaining_And_Usage)
          return $a;
    )");
 
-   EXPECT_EQ(valueGlobal, 2);
+   ASSERT_EQ(valueGlobal.getInt(), 2);
 
-   S32 value2 = RunScript<S32>(R"(
+   ConsoleValue value2 = RunScript(R"(
          function t(%a) 
          {
             if ((%b = 2 * %a) != 5)
@@ -195,26 +155,26 @@ TEST(Script, Variable_Chaining_And_Usage)
          return t(2);
    )");
 
-   EXPECT_EQ(value2, 4);
+   ASSERT_EQ(value2.getInt(), 4);
 }
 
 TEST(Script, Basic_Function_Call_And_Local_Variable_Testing)
 {
-   S32 value = RunScript<S32>(R"(
+   ConsoleValue value = RunScript(R"(
          function t() { %a = 2; return %a; }
          return t();
    )");
 
-   EXPECT_EQ(value, 2);
+   ASSERT_EQ(value.getInt(), 2);
 
-   S32 value2 = RunScript<S32>(R"(
+   ConsoleValue value2 = RunScript(R"(
          function add(%a, %b) { return %a + %b; }
          return add(2, 4);
    )");
 
-   EXPECT_EQ(value2, 6);
+   ASSERT_EQ(value2.getInt(), 6);
 
-   S32 value3 = RunScript<S32>(R"(
+   ConsoleValue value3 = RunScript(R"(
          function fib(%a) {
             if (%a == 0)
                return 0;
@@ -225,48 +185,48 @@ TEST(Script, Basic_Function_Call_And_Local_Variable_Testing)
          return fib(15);
    )");
 
-   EXPECT_EQ(value3, 610);
+   ASSERT_EQ(value3.getInt(), 610);
 
-   S32 staticCall = RunScript<S32>(R"(
+   ConsoleValue staticCall = RunScript(R"(
          function SimObject::bar(%a, %b) {
             return %a + %b;
          }
          return SimObject::bar(1, 2);
    )");
 
-   EXPECT_EQ(staticCall, 3);
+   ASSERT_EQ(staticCall.getInt(), 3);
 }
 
 TEST(Script, Basic_Conditional_Statements)
 {
-   S32 value = RunScript<S32>(R"(
+   ConsoleValue value = RunScript(R"(
          $a = "hello";
          if ($a $= "hello")
             return 1;
          return 2;
    )");
 
-   EXPECT_EQ(value, 1);
+   ASSERT_EQ(value.getInt(), 1);
 
-   const char* ternaryValue = RunScript<const char*>(R"(
+   ConsoleValue ternaryValue = RunScript(R"(
          return $a $= "hello" ? "World" : "No U";
    )");
 
-   EXPECT_STREQ(ternaryValue, "World");
+   ASSERT_STREQ(ternaryValue.getString(), "World");
 }
 
 TEST(Script, Basic_Loop_Statements)
 {
-   S32 whileValue = RunScript<S32>(R"(
+   ConsoleValue whileValue = RunScript(R"(
          $count = 0;
          while ($count < 5)
             $count++;
          return $count;
    )");
 
-   EXPECT_EQ(whileValue, 5);
+   ASSERT_EQ(whileValue.getInt(), 5);
 
-   const char* forValue = RunScript<const char*>(R"(
+   ConsoleValue forValue = RunScript(R"(
          function t(%times) 
          { 
             %result = "";
@@ -278,9 +238,9 @@ TEST(Script, Basic_Loop_Statements)
          return t(3);
    )");
 
-   EXPECT_STREQ(forValue, "aaa");
+   ASSERT_STREQ(forValue.getString(), "aaa");
 
-   const char* forIfValue = RunScript<const char*>(R"(
+   ConsoleValue forIfValue = RunScript(R"(
          function t() {
             %str = "";
             for (%i = 0; %i < 5; %i++) {
@@ -298,43 +258,43 @@ TEST(Script, Basic_Loop_Statements)
          return t();
    )");
 
-   EXPECT_STREQ(forIfValue, "0, 1, 2, 3, 4");
+   ASSERT_STREQ(forIfValue.getString(), "0, 1, 2, 3, 4");
 }
 
 TEST(Script, TorqueScript_Array_Testing)
 {
-   S32 value = RunScript<S32>(R"(
+   ConsoleValue value = RunScript(R"(
          function t(%idx) { %a[idx] = 2; return %a[idx]; }
          return t(5);
    )");
 
-   EXPECT_EQ(value, 2);
+   ASSERT_EQ(value.getInt(), 2);
 
-   S32 value2 = RunScript<S32>(R"(
+   ConsoleValue value2 = RunScript(R"(
          function t(%idx) { %a[idx, 0] = 2; return %a[idx, 0]; }
          return t(5);
    )");
 
-   EXPECT_EQ(value2, 2);
+   ASSERT_EQ(value2.getInt(), 2);
 }
 
 TEST(Script, Basic_SimObject)
 {
-   SimObject* object = RunScript<SimObject*>(R"(
+   ConsoleValue object = RunScript(R"(
          return new SimObject(FudgeCollector) {
             fudge = "Chocolate"; 
          };
    )");
 
-   EXPECT_NE(object, (SimObject*)NULL);
+   ASSERT_NE(Sim::findObject(object), (SimObject*)NULL);
 
-   const char* propertyValue = RunScript<const char*>(R"(
+   ConsoleValue propertyValue = RunScript(R"(
          return FudgeCollector.fudge;
    )");
 
-   EXPECT_STREQ(propertyValue, "Chocolate");
+   ASSERT_STREQ(propertyValue.getString(), "Chocolate");
 
-   const char* funcReturn = RunScript<const char*>(R"(
+   ConsoleValue funcReturn = RunScript(R"(
          function SimObject::fooFunc(%this)
          {
             return "Bar";
@@ -343,9 +303,9 @@ TEST(Script, Basic_SimObject)
          return FudgeCollector.fooFunc();
    )");
 
-   EXPECT_STREQ(funcReturn, "Bar");
+   ASSERT_STREQ(funcReturn.getString(), "Bar");
 
-   const char* parentFn = RunScript<const char*>(R"(
+   ConsoleValue parentFn = RunScript(R"(
          new SimObject(Hello);
 
          function SimObject::fooFunc2(%this)
@@ -362,12 +322,12 @@ TEST(Script, Basic_SimObject)
          return Hello.fooFunc2();
    )");
 
-   EXPECT_STREQ(parentFn, "FooBar");
+   ASSERT_STREQ(parentFn.getString(), "FooBar");
 }
 
 TEST(Script, Basic_Package)
 {
-   S32 value = RunScript<S32>(R"(
+   ConsoleValue value = RunScript(R"(
          function a() { return 3; }
          package overrides {
             function a() { return 5; }
@@ -375,21 +335,21 @@ TEST(Script, Basic_Package)
          return a();
    )");
 
-   EXPECT_EQ(value, 3);
+   ASSERT_EQ(value.getInt(), 3);
 
-   S32 overrideValue = RunScript<S32>(R"(
+   ConsoleValue overrideValue = RunScript(R"(
          activatePackage(overrides);
          return a();
    )");
 
-   EXPECT_EQ(overrideValue, 5);
+   ASSERT_EQ(overrideValue.getInt(), 5);
 
-   S32 deactivatedValue = RunScript<S32>(R"(
+   ConsoleValue deactivatedValue = RunScript(R"(
          deactivatePackage(overrides);
          return a();
    )");
 
-   EXPECT_EQ(deactivatedValue, 3);
+   ASSERT_EQ(deactivatedValue.getInt(), 3);
 }
 
 #endif
diff --git a/Engine/source/core/strings/stringFunctions.cpp b/Engine/source/core/strings/stringFunctions.cpp
index ed810ea74..893dc5815 100644
--- a/Engine/source/core/strings/stringFunctions.cpp
+++ b/Engine/source/core/strings/stringFunctions.cpp
@@ -428,7 +428,7 @@ S32 dStrlcpy(char *dst, const char *src, dsize_t dstSize)
    S32 copyLen = srcLen;
 
    //Check for buffer overflow and don't allow it. Warn on debug so we can fix it
-   AssertWarn(copyLen < dstSize, "Buffer too small in call to dStrlcpy!");
+   AssertFatal(copyLen < dstSize, "Buffer too small in call to dStrlcpy!");
    if (srcLen + 1 > dstSize)
    {
       copyLen = dstSize - 1;

From 4e678292e114abf9c1c1d3f81af79af77332997f Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Sun, 4 Apr 2021 00:50:37 -0400
Subject: [PATCH 008/399] fix foreach/foreach$ loops.

---
 Engine/source/console/astNodes.cpp        | 11 ++-
 Engine/source/console/codeBlock.cpp       | 46 +++++++++---
 Engine/source/console/compiledEval.cpp    | 55 +++++++++++---
 Engine/source/console/test/ScriptTest.cpp | 88 +++++++++++++++++++++--
 4 files changed, 176 insertions(+), 24 deletions(-)

diff --git a/Engine/source/console/astNodes.cpp b/Engine/source/console/astNodes.cpp
index 28e6b4960..14f610bd2 100644
--- a/Engine/source/console/astNodes.cpp
+++ b/Engine/source/console/astNodes.cpp
@@ -413,11 +413,18 @@ U32 IterStmtNode::compileStmt(CodeStream& codeStream, U32 ip)
 
    codeStream.pushFixScope(true);
 
+   bool isGlobal = varName[0] == '$';
+   TypeReq varType = isStringIter ? TypeReqString : TypeReqUInt;
+
    const U32 startIp = ip;
-   containerExpr->compile(codeStream, startIp, TypeReqString);
+   containerExpr->compile(codeStream, startIp, TypeReqString); // todo: figure out better way to codegen this so we don't rely on STR
 
    codeStream.emit(isStringIter ? OP_ITER_BEGIN_STR : OP_ITER_BEGIN);
-   codeStream.emitSTE(varName);
+   codeStream.emit(isGlobal);
+   if (isGlobal)
+      codeStream.emitSTE(varName);
+   else
+      codeStream.emit(gFuncVars->assign(varName, varType));
    const U32 finalFix = codeStream.emit(0);
    const U32 continueIp = codeStream.emit(OP_ITER);
    codeStream.emitFix(CodeStream::FIXTYPE_BREAK);
diff --git a/Engine/source/console/codeBlock.cpp b/Engine/source/console/codeBlock.cpp
index d3687a2cd..559e921c3 100644
--- a/Engine/source/console/codeBlock.cpp
+++ b/Engine/source/console/codeBlock.cpp
@@ -643,7 +643,8 @@ ConsoleValue CodeBlock::compileExec(StringTableEntry fileName, const char *inStr
    codeStream.emit(OP_RETURN);
    codeStream.emitCodeStream(&codeSize, &code, &lineBreakPairs);
 
-   //dumpInstructions(0, false);
+   if (Con::getBoolVariable("dump"))
+   dumpInstructions(0, false);
 
    consoleAllocReset();
 
@@ -1392,23 +1393,50 @@ void CodeBlock::dumpInstructions(U32 startIp, bool upToReturn)
 
       case OP_ITER_BEGIN:
       {
-         StringTableEntry varName = CodeToSTE(code, ip);
-         U32 failIp = code[ip + 2];
+         bool isGlobal = code[ip];
+         if (isGlobal)
+         {
+            StringTableEntry varName = CodeToSTE(code, ip + 1);
+            U32 failIp = code[ip + 3];
 
-         Con::printf("%i: OP_ITER_BEGIN varName=%s failIp=%i", ip - 1, varName, failIp);
+            Con::printf("%i: OP_ITER_BEGIN varName=%s failIp=%i isGlobal=%s", ip - 1, varName, failIp, "true");
 
-         ip += 3;
+            ip += 4;
+         }
+         else
+         {
+            S32 reg = code[ip + 1];
+            U32 failIp = code[ip + 2];
+
+            Con::printf("%i: OP_ITER_BEGIN varRegister=%d failIp=%i isGlobal=%s", ip - 1, reg, failIp, "false");
+
+            ip += 3;
+         }
          break;
       }
 
       case OP_ITER_BEGIN_STR:
       {
-         StringTableEntry varName = CodeToSTE(code, ip);
-         U32 failIp = code[ip + 2];
+         bool isGlobal = code[ip];
+         if (isGlobal)
+         {
+            StringTableEntry varName = CodeToSTE(code, ip + 1);
+            U32 failIp = code[ip + 3];
 
-         Con::printf("%i: OP_ITER_BEGIN varName=%s failIp=%i", ip - 1, varName, failIp);
+            Con::printf("%i: OP_ITER_BEGIN_STR varName=%s failIp=%i isGlobal=%s", ip - 1, varName, failIp, "true");
+
+            ip += 4;
+         }
+         else
+         {
+            S32 reg = code[ip + 1];
+            U32 failIp = code[ip + 2];
+
+            Con::printf("%i: OP_ITER_BEGIN_STR varRegister=%d failIp=%i isGlobal=%s", ip - 1, reg, failIp, "false");
+
+            ip += 3;
+         }
 
-         ip += 3;
          break;
       }
 
diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index 0375ab14e..23245b135 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -66,8 +66,18 @@ struct IterStackRecord
    /// If true, this is a foreach$ loop; if not, it's a foreach loop.
    bool mIsStringIter;
 
-   /// The iterator variable.
-   Dictionary::Entry* mVariable;
+   /// True if the variable referenced is a global
+   bool mIsGlobalVariable;
+
+   union
+   {
+
+      /// The iterator variable if we are a global variable
+      Dictionary::Entry* mVariable;
+
+      /// The register variable if we are a local variable
+      S32 mRegister;
+   } mVar;
 
    /// Information for an object iterator loop.
    struct ObjectPos
@@ -1745,6 +1755,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          {
             if (nsEntry->mFunctionOffset)
             {
+               // TODO: not make this strings only for returns.
                ConsoleValue returnFromFn = nsEntry->mCode->exec(nsEntry->mFunctionOffset, fnName, nsEntry->mNamespace, callArgc, callArgv, false, nsEntry->mPackage);
                STR.setStringValue(returnFromFn.getString());
             }
@@ -1954,12 +1965,22 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
 
       case OP_ITER_BEGIN:
       {
-         StringTableEntry varName = CodeToSTE(code, ip);
-         U32 failIp = code[ip + 2];
+         bool isGlobal = code[ip];
+
+         U32 failIp = code[ip + isGlobal ? 3 : 2];
 
          IterStackRecord& iter = iterStack[_ITER];
+         iter.mIsGlobalVariable = isGlobal;
 
-         iter.mVariable = gEvalState.getCurrentFrame().add(varName);
+         if (isGlobal)
+         {
+            StringTableEntry varName = CodeToSTE(code, ip + 1);
+            iter.mVar.mVariable = gEvalState.globalVars.add(varName);
+         }
+         else
+         {
+            iter.mVar.mRegister = code[ip + 1];
+         }
 
          if (iter.mIsStringIter)
          {
@@ -1990,7 +2011,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
 
          STR.push();
 
-         ip += 3;
+         ip += isGlobal ? 4 : 3;
          break;
       }
 
@@ -2026,11 +2047,21 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
             {
                char savedChar = str[endIndex];
                const_cast<char*>(str)[endIndex] = '\0'; // We are on the string stack so this is okay.
-               iter.mVariable->setStringValue(&str[startIndex]);
+
+               if (iter.mIsGlobalVariable)
+                  iter.mVar.mVariable->setStringValue(&str[startIndex]);
+               else
+                  gEvalState.setLocalStringVariable(iter.mVar.mRegister, &str[startIndex], endIndex - startIndex);
+
                const_cast<char*>(str)[endIndex] = savedChar;
             }
             else
-               iter.mVariable->setStringValue("");
+            {
+               if (iter.mIsGlobalVariable)
+                  iter.mVar.mVariable->setStringValue("");
+               else
+                  gEvalState.setLocalStringVariable(iter.mVar.mRegister, "", 0);
+            }
 
             // Skip separator.
             if (str[endIndex] != '\0')
@@ -2049,7 +2080,13 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
                continue;
             }
 
-            iter.mVariable->setIntValue(set->at(index)->getId());
+            SimObjectId id = set->at(index)->getId();
+
+            if (iter.mIsGlobalVariable)
+               iter.mVar.mVariable->setIntValue(id);
+            else
+               gEvalState.setLocalIntVariable(iter.mVar.mRegister, id);
+
             iter.mData.mObj.mIndex = index + 1;
          }
 
diff --git a/Engine/source/console/test/ScriptTest.cpp b/Engine/source/console/test/ScriptTest.cpp
index 3bd6a1bb4..ecf3ae3f9 100644
--- a/Engine/source/console/test/ScriptTest.cpp
+++ b/Engine/source/console/test/ScriptTest.cpp
@@ -241,9 +241,11 @@ TEST(Script, Basic_Loop_Statements)
    ASSERT_STREQ(forValue.getString(), "aaa");
 
    ConsoleValue forIfValue = RunScript(R"(
-         function t() {
+         function t()
+         {
             %str = "";
-            for (%i = 0; %i < 5; %i++) {
+            for (%i = 0; %i < 5; %i++)
+            {
 
                %loopValue = %i;
 
@@ -261,6 +263,82 @@ TEST(Script, Basic_Loop_Statements)
    ASSERT_STREQ(forIfValue.getString(), "0, 1, 2, 3, 4");
 }
 
+TEST(Script, ForEachLoop)
+{
+   ConsoleValue forEach1 = RunScript(R"(
+         $theSimSet = new SimSet();
+         $theSimSet.add(new SimObject());
+         $theSimSet.add(new SimObject());
+
+         $counter = 0;
+         foreach ($obj in $theSimSet)
+         {
+            $counter++;
+         }
+
+         $theSimSet.delete();
+
+         return $counter;
+   )");
+
+   ASSERT_EQ(forEach1.getInt(), 2);
+
+   ConsoleValue forEach2 = RunScript(R"(
+         $counter = 0;
+         foreach$ ($word in "a b c d")
+         {
+            $counter++;
+         }
+
+         return $counter;
+   )");
+
+   ASSERT_EQ(forEach2.getInt(), 4);
+
+   ConsoleValue forEach3 = RunScript(R"(
+         function SimObject::addOne(%this)
+         {
+            return 1;
+         }
+
+         function test()
+         {
+            %set = new SimSet();
+            %set.add(new SimObject());
+            %set.add(new SimObject());
+
+            %count = 0;
+            foreach (%obj in %set)
+               %count += %obj.addOne();
+
+            %set.delete();
+
+            return %count;
+         }
+
+         return test();
+   )");
+
+   ASSERT_EQ(forEach3.getInt(), 2);
+
+   ConsoleValue forEach4 = RunScript(R"(
+         function test()
+         {
+            %string = "a b c d e";
+
+            %count = 0;
+            foreach$ (%word in %string)
+               %count++;
+
+            return %count;
+         }
+
+         return test();
+   )");
+
+   ASSERT_EQ(forEach4.getInt(), 5);
+}
+
 TEST(Script, TorqueScript_Array_Testing)
 {
    ConsoleValue value = RunScript(R"(
@@ -281,7 +359,8 @@ TEST(Script, TorqueScript_Array_Testing)
 TEST(Script, Basic_SimObject)
 {
    ConsoleValue object = RunScript(R"(
-         return new SimObject(FudgeCollector) {
+         return new SimObject(FudgeCollector)
+         {
             fudge = "Chocolate"; 
          };
    )");
@@ -329,7 +408,8 @@ TEST(Script, Basic_Package)
 {
    ConsoleValue value = RunScript(R"(
          function a() { return 3; }
-         package overrides {
+         package overrides
+         {
             function a() { return 5; }
          };
          return a();

From 960db74733d51b7096b75cbdc3d6acc028682893 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Sat, 10 Apr 2021 15:52:53 -0400
Subject: [PATCH 009/399] small fix.

---
 Engine/source/console/compiledEval.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index 23245b135..091a00e95 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -763,6 +763,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
 
                   // Clean up...
                   delete object;
+                  currentNewObject = NULL;
                   ip = failJump;
                   break;
                }
@@ -1011,7 +1012,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          if (currentNewObject)
             currentNewObject->onPostAdd();
 
-         //Assert( objectCreationStackIndex >= 0 );
+         AssertFatal( objectCreationStackIndex >= 0, "Object Stack is empty." );
          // Restore the object info from the stack [7/9/2007 Black]
          currentNewObject = objectCreationStack[--objectCreationStackIndex].newObject;
          failJump = objectCreationStack[objectCreationStackIndex].failJump;

From 93500b6ac45fe1666a3a9f79309249ebb6b39e5f Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Mon, 12 Apr 2021 21:26:26 -0400
Subject: [PATCH 010/399] more changes.

---
 Engine/source/console/console.cpp         |   2 +-
 Engine/source/console/consoleInternal.cpp | 100 +++++++++++++++---
 Engine/source/console/consoleInternal.h   | 119 +++++++++++++++++-----
 Engine/source/console/engineDoc.cpp       |   4 +-
 4 files changed, 185 insertions(+), 40 deletions(-)

diff --git a/Engine/source/console/console.cpp b/Engine/source/console/console.cpp
index a9dd4de40..a544aad0e 100644
--- a/Engine/source/console/console.cpp
+++ b/Engine/source/console/console.cpp
@@ -1657,7 +1657,7 @@ static ConsoleValue _internalExecute(SimObject *object, S32 argc, ConsoleValue a
 
       if(ent == NULL)
       {
-         warnf(ConsoleLogEntry::Script, "%s: undefined for object '%s' - id %d", funcName, object->getName(), object->getId());
+         //warnf(ConsoleLogEntry::Script, "%s: undefined for object '%s' - id %d", funcName, object->getName(), object->getId());
 
          STR.clearFunctionOffset();
          return std::move(ConsoleValue());
diff --git a/Engine/source/console/consoleInternal.cpp b/Engine/source/console/consoleInternal.cpp
index 336de99fa..bb059f9d6 100644
--- a/Engine/source/console/consoleInternal.cpp
+++ b/Engine/source/console/consoleInternal.cpp
@@ -183,13 +183,13 @@ void Dictionary::exportVariables(const char *varString, const char *fileName, bo
 
    for (s = sortList.begin(); s != sortList.end(); s++)
    {
-      switch ((*s)->value.getType())
+      switch ((*s)->type)
       {
-         case ConsoleValueType::cvInteger:
-            dSprintf(buffer, sizeof(buffer), "%s = %d;%s", (*s)->name, (*s)->value.getInt(), cat);
+         case Entry::TypeInternalInt:
+            dSprintf(buffer, sizeof(buffer), "%s = %d;%s", (*s)->name, (*s)->ival, cat);
             break;
-         case ConsoleValueType::cvFloat:
-            dSprintf(buffer, sizeof(buffer), "%s = %g;%s", (*s)->name, (*s)->value.getFloat(), cat);
+         case Entry::TypeInternalFloat:
+            dSprintf(buffer, sizeof(buffer), "%s = %g;%s", (*s)->name, (*s)->fval, cat);
             break;
          default:
             expandEscape(expandBuffer, (*s)->getStringValue());
@@ -243,11 +243,11 @@ void Dictionary::exportVariables(const char *varString, Vector<String> *names, V
 
       if (values)
       {
-         switch ((*s)->value.getType())
+         switch ((*s)->type)
          {
             case ConsoleValueType::cvInteger:
             case ConsoleValueType::cvFloat:
-               values->push_back(String((*s)->value.getString()));
+               values->push_back(String((*s)->getStringValue()));
                break;
             default:
                expandEscape(expandBuffer, (*s)->getStringValue());
@@ -473,17 +473,88 @@ Dictionary::Entry::Entry(StringTableEntry in_name)
    mUsage = NULL;
    mIsConstant = false;
    mNext = NULL;
-   // NOTE: This is data inside a nameless
-   // union, so we don't need to init the rest.
-   value.init();
+
+   ival = 0;
+   fval = 0;
+   sval = typeValueEmpty;
+   bufferLen = 0;
 }
 
 Dictionary::Entry::~Entry()
 {
+   reset();
+}
+
+void Dictionary::Entry::reset()
+{
+   name = NULL;
+   if (type <= TypeInternalString && sval != typeValueEmpty)
+      dFree(sval);
    if (notify)
       delete notify;
 }
 
+void Dictionary::Entry::setStringValue(const char* value)
+{
+   if (mIsConstant)
+   {
+      Con::errorf("Cannot assign value to constant '%s'.", name);
+      return;
+   }
+
+   if (type <= TypeInternalString)
+   {
+      // Let's not remove empty-string-valued global vars from the dict.
+      // If we remove them, then they won't be exported, and sometimes
+      // it could be necessary to export such a global.  There are very
+      // few empty-string global vars so there's no performance-related
+      // need to remove them from the dict.
+      /*
+       if(!value[0] && name[0] == '$')
+       {
+       gEvalState.globalVars.remove(this);
+       return;
+       }
+       */
+
+      U32 stringLen = dStrlen(value);
+
+      // If it's longer than 256 bytes, it's certainly not a number.
+      //
+      // (This decision may come back to haunt you. Shame on you if it
+      // does.)
+      if (stringLen < 256)
+      {
+         fval = dAtof(value);
+         ival = dAtoi(value);
+      }
+      else
+      {
+         fval = 0.f;
+         ival = 0;
+      }
+
+      type = TypeInternalString;
+
+      // may as well pad to the next cache line
+      U32 newLen = ((stringLen + 1) + 15) & ~15;
+
+      if (sval == typeValueEmpty)
+         sval = (char*)dMalloc(newLen);
+      else if (newLen > bufferLen)
+         sval = (char*)dRealloc(sval, newLen);
+
+      bufferLen = newLen;
+      dStrcpy(sval, value, newLen);
+   }
+   else
+      Con::setData(type, dataPtr, 0, 1, &value, enumTable);
+
+   // Fire off the notification if we have one.
+   if (notify)
+      notify->trigger();
+}
+
 const char *Dictionary::getVariable(StringTableEntry name, bool *entValid)
 {
    Entry *ent = lookup(name);
@@ -558,13 +629,18 @@ Dictionary::Entry* Dictionary::addVariable(const char *name,
    }
 
    Entry *ent = add(StringTable->insert(name));
+
+   if (ent->type <= Entry::TypeInternalString && ent->sval != typeValueEmpty)
+      dFree(ent->sval);
+
    ent->mUsage = usage;
+   ent->type = type;
+   ent->dataPtr = dataPtr;
 
    // Fetch enum table, if any.
-
    ConsoleBaseType* conType = ConsoleBaseType::getType(type);
    AssertFatal(conType, "Dictionary::addVariable - invalid console type");
-   ent->value.setConsoleData(type, dataPtr, conType->getEnumTable());
+   ent->enumTable = conType->getEnumTable();
 
    return ent;
 }
diff --git a/Engine/source/console/consoleInternal.h b/Engine/source/console/consoleInternal.h
index e1d2cd462..34f6e1a9b 100644
--- a/Engine/source/console/consoleInternal.h
+++ b/Engine/source/console/consoleInternal.h
@@ -280,9 +280,18 @@ public:
 
    struct Entry
    {
+      friend class Dictionary;
+
+      enum
+      {
+         TypeInternalInt = -3,
+         TypeInternalFloat = -2,
+         TypeInternalString = -1,
+      };
+
       StringTableEntry name;
-      ConsoleValue value;
       Entry *nextEntry;
+      S32 type;
 
       typedef Signal<void()> NotifySignal;
 
@@ -296,6 +305,41 @@ public:
       /// Whether this is a constant that cannot be assigned to.
       bool mIsConstant;
 
+   protected:
+
+      // NOTE: This is protected to ensure no one outside
+      // of this structure is messing with it.
+
+#pragma warning( push )
+#pragma warning( disable : 4201 ) // warning C4201: nonstandard extension used : nameless struct/union
+
+      // An variable is either a real dynamic type or
+      // its one exposed from C++ using a data pointer.
+      //
+      // We use this nameless union and struct setup
+      // to optimize the memory usage.
+      union
+      {
+         struct
+         {
+            char* sval;
+            U32 ival;  // doubles as strlen when type is TypeInternalString
+            F32 fval;
+            U32 bufferLen;
+         };
+
+         struct
+         {
+            /// The real data pointer.
+            void* dataPtr;
+
+            /// The enum lookup table for enumerated types.
+            const EnumTable* enumTable;
+         };
+      };
+
+#pragma warning( pop ) // C4201
+
    public:
 
       Entry() {
@@ -312,26 +356,34 @@ public:
 
       Entry *mNext;
 
-      void reset() {
-         name = NULL;
-         value.reset();
-         if (notify)
-            delete notify;
-      }
+      void reset();
 
       inline U32 getIntValue()
       {
-         return value.getInt();
+         if (type <= TypeInternalString)
+            return ival;
+         else
+            return dAtoi(Con::getData(type, dataPtr, 0, enumTable));
       }
 
       inline F32 getFloatValue()
       {
-         return value.getFloat();
+         if (type <= TypeInternalString)
+            return fval;
+         else
+            return dAtof(Con::getData(type, dataPtr, 0, enumTable));
       }
 
       inline const char *getStringValue()
       {
-         return value.getString();
+         if (type == TypeInternalString)
+            return sval;
+         if (type == TypeInternalFloat)
+            return Con::getData(TypeF32, &fval, 0);
+         else if (type == TypeInternalInt)
+            return Con::getData(TypeS32, &ival, 0);
+         else
+            return Con::getData(type, dataPtr, 0, enumTable);
       }
 
       void setIntValue(U32 val)
@@ -342,7 +394,22 @@ public:
             return;
          }
 
-         value.setInt(val);
+         if (type <= TypeInternalString)
+         {
+            fval = (F32)val;
+            ival = val;
+            if (sval != typeValueEmpty)
+            {
+               dFree(sval);
+               sval = typeValueEmpty;
+            }
+            type = TypeInternalInt;
+         }
+         else
+         {
+            const char* dptr = Con::getData(TypeS32, &val, 0);
+            Con::setData(type, dataPtr, 0, 1, &dptr, enumTable);
+         }
 
          // Fire off the notification if we have one.
          if (notify)
@@ -357,27 +424,29 @@ public:
             return;
          }
 
-         value.setFloat(val);
-
-         // Fire off the notification if we have one.
-         if (notify)
-            notify->trigger();
-      }
-
-      void setStringValue(const char *newValue)
-      {
-         if (mIsConstant)
+         if (type <= TypeInternalString)
          {
-            Con::errorf("Cannot assign value to constant '%s'.", name);
-            return;
+            fval = val;
+            ival = static_cast<U32>(val);
+            if (sval != typeValueEmpty)
+            {
+               dFree(sval);
+               sval = typeValueEmpty;
+            }
+            type = TypeInternalFloat;
+         }
+         else
+         {
+            const char* dptr = Con::getData(TypeF32, &val, 0);
+            Con::setData(type, dataPtr, 0, 1, &dptr, enumTable);
          }
 
-         value.setString(newValue);
-
          // Fire off the notification if we have one.
          if (notify)
             notify->trigger();
       }
+
+      void setStringValue(const char* value);
    };
 
    struct HashTableData
diff --git a/Engine/source/console/engineDoc.cpp b/Engine/source/console/engineDoc.cpp
index 56563efe0..c471fe820 100644
--- a/Engine/source/console/engineDoc.cpp
+++ b/Engine/source/console/engineDoc.cpp
@@ -114,7 +114,7 @@ static void dumpVariable(  Stream& stream,
 {
    // Skip variables defined in script.
    
-   if( !entry->value.isConsoleType() )
+   if( entry->type <= Dictionary::Entry::TypeInternalString )
       return;
          
    // Skip internals... don't export them.
@@ -149,7 +149,7 @@ static void dumpVariable(  Stream& stream,
             
    // Skip variables for which we can't decipher their type.
 
-   ConsoleBaseType* type = ConsoleBaseType::getType( entry->value.getType() );
+   ConsoleBaseType* type = ConsoleBaseType::getType( entry->type );
    if( !type )
    {
       Con::errorf( "Can't find type for variable '%s'", entry->name );

From a2dea07d8b396648e58a3549c4d3a90fcdfe8017 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Mon, 12 Apr 2021 21:42:18 -0400
Subject: [PATCH 011/399] fixed internal types.

---
 Engine/source/console/consoleInternal.cpp | 1 +
 Engine/source/console/consoleInternal.h   | 6 ++++++
 2 files changed, 7 insertions(+)

diff --git a/Engine/source/console/consoleInternal.cpp b/Engine/source/console/consoleInternal.cpp
index bb059f9d6..bd8e230ff 100644
--- a/Engine/source/console/consoleInternal.cpp
+++ b/Engine/source/console/consoleInternal.cpp
@@ -468,6 +468,7 @@ char *typeValueEmpty = "";
 Dictionary::Entry::Entry(StringTableEntry in_name)
 {
    name = in_name;
+   type = TypeInternalString;
    notify = NULL;
    nextEntry = NULL;
    mUsage = NULL;
diff --git a/Engine/source/console/consoleInternal.h b/Engine/source/console/consoleInternal.h
index 34f6e1a9b..392bf0c3f 100644
--- a/Engine/source/console/consoleInternal.h
+++ b/Engine/source/console/consoleInternal.h
@@ -344,11 +344,17 @@ public:
 
       Entry() {
          name = NULL;
+         type = TypeInternalString;
          notify = NULL;
          nextEntry = NULL;
          mUsage = NULL;
          mIsConstant = false;
          mNext = NULL;
+
+         ival = 0;
+         fval = 0;
+         sval = typeValueEmpty;
+         bufferLen = 0;
       }
 
       Entry(StringTableEntry name);

From bc0f5bd3a39205a0de8803340dadb3c6b9c22fb5 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Fri, 16 Apr 2021 19:20:15 -0400
Subject: [PATCH 012/399] combine numeric stacks into one common stack.

---
 Engine/source/console/compiledEval.cpp | 241 ++++++++++++-------------
 Engine/source/console/stringStack.h    |   6 +-
 2 files changed, 119 insertions(+), 128 deletions(-)

diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index 091a00e95..c1db544eb 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -109,14 +109,18 @@ ConsoleValueStack<4096> gCallStack;
 
 StringStack STR;
 
-U32 _FLT = 0;     ///< Stack pointer for floatStack.
-U32 _UINT = 0;    ///< Stack pointer for intStack.
 U32 _ITER = 0;    ///< Stack pointer for iterStack.
 
 IterStackRecord iterStack[MaxStackSize];
 
-F64 floatStack[MaxStackSize];
-S64 intStack[MaxStackSize];
+union StackValue
+{
+   F64 f;
+   S64 i;
+};
+
+StackValue numStack[MaxStackSize];
+U32 _STK = 0;
 
 char curFieldArray[256];
 char prevFieldArray[256];
@@ -945,7 +949,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          }
 
          // What group will we be added to, if any?
-         U32 groupAddId = (U32)intStack[_UINT];
+         U32 groupAddId = (U32)numStack[_STK].i;
          SimGroup* grp = NULL;
          SimSet* set = NULL;
 
@@ -990,9 +994,9 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          // id, if one was given, otherwise getting pushed)
          S32 id = currentNewObject->getId();
          if (placeAtRoot)
-            intStack[_UINT] = id;
+            numStack[_STK].i = id;
          else
-            intStack[++_UINT] = id;
+            numStack[++_STK].i = id;
 
          break;
       }
@@ -1003,7 +1007,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          // our group reference.
          bool placeAtRoot = code[ip++];
          if (!placeAtRoot)
-            _UINT--;
+            _STK--;
          break;
       }
 
@@ -1020,7 +1024,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
       }
 
       case OP_JMPIFFNOT:
-         if (floatStack[_FLT--])
+         if (numStack[_STK--].f)
          {
             ip++;
             break;
@@ -1028,7 +1032,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          ip = code[ip];
          break;
       case OP_JMPIFNOT:
-         if (intStack[_UINT--])
+         if (numStack[_STK--].i)
          {
             ip++;
             break;
@@ -1036,7 +1040,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          ip = code[ip];
          break;
       case OP_JMPIFF:
-         if (!floatStack[_FLT--])
+         if (!numStack[_STK--].f)
          {
             ip++;
             break;
@@ -1044,7 +1048,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          ip = code[ip];
          break;
       case OP_JMPIF:
-         if (!intStack[_UINT--])
+         if (!numStack[_STK--].i)
          {
             ip++;
             break;
@@ -1052,18 +1056,18 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          ip = code[ip];
          break;
       case OP_JMPIFNOT_NP:
-         if (intStack[_UINT])
+         if (numStack[_STK].i)
          {
-            _UINT--;
+            _STK--;
             ip++;
             break;
          }
          ip = code[ip];
          break;
       case OP_JMPIF_NP:
-         if (!intStack[_UINT])
+         if (!numStack[_STK].i)
          {
-            _UINT--;
+            _STK--;
             ip++;
             break;
          }
@@ -1111,8 +1115,8 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
 
          }
 
-         returnValue.setFloat(floatStack[_FLT]);
-         _FLT--;
+         returnValue.setFloat(numStack[_STK].f);
+         _STK--;
 
          goto execFinished;
 
@@ -1128,124 +1132,116 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
             }
          }
 
-         returnValue.setInt(intStack[_UINT]);
-         _UINT--;
+         returnValue.setInt(numStack[_STK].i);
+         _STK--;
 
          goto execFinished;
 
       case OP_CMPEQ:
-         intStack[_UINT + 1] = bool(floatStack[_FLT] == floatStack[_FLT - 1]);
-         _UINT++;
-         _FLT -= 2;
+         numStack[_STK - 1].i = bool(numStack[_STK].f == numStack[_STK - 1].f);
+         _STK--;
          break;
 
       case OP_CMPGR:
-         intStack[_UINT + 1] = bool(floatStack[_FLT] > floatStack[_FLT - 1]);
-         _UINT++;
-         _FLT -= 2;
+         numStack[_STK - 1].i = bool(numStack[_STK].f > numStack[_STK - 1].f);
+         _STK--;
          break;
 
       case OP_CMPGE:
-         intStack[_UINT + 1] = bool(floatStack[_FLT] >= floatStack[_FLT - 1]);
-         _UINT++;
-         _FLT -= 2;
+         numStack[_STK - 1].i = bool(numStack[_STK].f >= numStack[_STK - 1].f);
+         _STK--;
          break;
 
       case OP_CMPLT:
-         intStack[_UINT + 1] = bool(floatStack[_FLT] < floatStack[_FLT - 1]);
-         _UINT++;
-         _FLT -= 2;
+         numStack[_STK - 1].i = bool(numStack[_STK].f < numStack[_STK - 1].f);
+         _STK--;
          break;
 
       case OP_CMPLE:
-         intStack[_UINT + 1] = bool(floatStack[_FLT] <= floatStack[_FLT - 1]);
-         _UINT++;
-         _FLT -= 2;
+         numStack[_STK - 1].i = bool(numStack[_STK].f <= numStack[_STK - 1].f);
+         _STK--;
          break;
 
       case OP_CMPNE:
-         intStack[_UINT + 1] = bool(floatStack[_FLT] != floatStack[_FLT - 1]);
-         _UINT++;
-         _FLT -= 2;
+         numStack[_STK - 1].i = bool(numStack[_STK].f != numStack[_STK - 1].f);
+         _STK--;
          break;
 
       case OP_XOR:
-         intStack[_UINT - 1] = intStack[_UINT] ^ intStack[_UINT - 1];
-         _UINT--;
+         numStack[_STK - 1].i = numStack[_STK].i ^ numStack[_STK - 1].i;
+         _STK--;
          break;
 
       case OP_MOD:
-         if (intStack[_UINT - 1] != 0)
-            intStack[_UINT - 1] = intStack[_UINT] % intStack[_UINT - 1];
+         if (numStack[_STK - 1].i != 0)
+            numStack[_STK - 1].i = numStack[_STK].i % numStack[_STK - 1].i;
          else
-            intStack[_UINT - 1] = 0;
-         _UINT--;
+            numStack[_STK - 1].i = 0;
+         _STK--;
          break;
 
       case OP_BITAND:
-         intStack[_UINT - 1] = intStack[_UINT] & intStack[_UINT - 1];
-         _UINT--;
+         numStack[_STK - 1].i = numStack[_STK].i & numStack[_STK - 1].i;
+         _STK--;
          break;
 
       case OP_BITOR:
-         intStack[_UINT - 1] = intStack[_UINT] | intStack[_UINT - 1];
-         _UINT--;
+         numStack[_STK - 1].i = numStack[_STK].i | numStack[_STK - 1].i;
+         _STK--;
          break;
 
       case OP_NOT:
-         intStack[_UINT] = !intStack[_UINT];
+         numStack[_STK].i = !numStack[_STK].i;
          break;
 
       case OP_NOTF:
-         intStack[_UINT + 1] = !floatStack[_FLT];
-         _FLT--;
-         _UINT++;
+         numStack[_STK].i = !numStack[_STK].f;
          break;
 
       case OP_ONESCOMPLEMENT:
-         intStack[_UINT] = ~intStack[_UINT];
+         numStack[_STK].i = ~numStack[_STK].i;
          break;
 
       case OP_SHR:
-         intStack[_UINT - 1] = intStack[_UINT] >> intStack[_UINT - 1];
-         _UINT--;
+         numStack[_STK - 1].i = numStack[_STK].i >> numStack[_STK - 1].i;
+         _STK--;
          break;
 
       case OP_SHL:
-         intStack[_UINT - 1] = intStack[_UINT] << intStack[_UINT - 1];
-         _UINT--;
+         numStack[_STK - 1].i = numStack[_STK].i << numStack[_STK - 1].i;
+         _STK--;
          break;
 
       case OP_AND:
-         intStack[_UINT - 1] = intStack[_UINT] && intStack[_UINT - 1];
-         _UINT--;
+         numStack[_STK - 1].i = numStack[_STK].i && numStack[_STK - 1].i;
+         _STK--;
          break;
 
       case OP_OR:
-         intStack[_UINT - 1] = intStack[_UINT] || intStack[_UINT - 1];
-         _UINT--;
+         numStack[_STK - 1].i = numStack[_STK].i || numStack[_STK - 1].i;
+         _STK--;
          break;
 
       case OP_ADD:
-         floatStack[_FLT - 1] = floatStack[_FLT] + floatStack[_FLT - 1];
-         _FLT--;
+         numStack[_STK - 1].f = numStack[_STK].f + numStack[_STK - 1].f;
+         _STK--;
          break;
 
       case OP_SUB:
-         floatStack[_FLT - 1] = floatStack[_FLT] - floatStack[_FLT - 1];
-         _FLT--;
+         numStack[_STK - 1].f = numStack[_STK].f - numStack[_STK - 1].f;
+         _STK--;
          break;
 
       case OP_MUL:
-         floatStack[_FLT - 1] = floatStack[_FLT] * floatStack[_FLT - 1];
-         _FLT--;
+         numStack[_STK - 1].f = numStack[_STK].f * numStack[_STK - 1].f;
+         _STK--;
          break;
       case OP_DIV:
-         floatStack[_FLT - 1] = floatStack[_FLT] / floatStack[_FLT - 1];
-         _FLT--;
+         numStack[_STK - 1].f = numStack[_STK].f / numStack[_STK - 1].f;
+         _STK--;
          break;
       case OP_NEG:
-         floatStack[_FLT] = -floatStack[_FLT];
+         numStack[_STK].f = -numStack[_STK].f;
          break;
 
       case OP_INC:
@@ -1320,13 +1316,13 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          break;
 
       case OP_LOADVAR_UINT:
-         intStack[_UINT + 1] = gEvalState.getIntVariable();
-         _UINT++;
+         numStack[_STK + 1].i = gEvalState.getIntVariable();
+         _STK++;
          break;
 
       case OP_LOADVAR_FLT:
-         floatStack[_FLT + 1] = gEvalState.getFloatVariable();
-         _FLT++;
+         numStack[_STK + 1].f = gEvalState.getFloatVariable();
+         _STK++;
          break;
 
       case OP_LOADVAR_STR:
@@ -1335,11 +1331,11 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          break;
 
       case OP_SAVEVAR_UINT:
-         gEvalState.setIntVariable((S32)intStack[_UINT]);
+         gEvalState.setIntVariable(numStack[_STK].i);
          break;
 
       case OP_SAVEVAR_FLT:
-         gEvalState.setFloatVariable(floatStack[_FLT]);
+         gEvalState.setFloatVariable(numStack[_STK].f);
          break;
 
       case OP_SAVEVAR_STR:
@@ -1348,14 +1344,14 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
 
       case OP_LOAD_LOCAL_VAR_UINT:
          reg = code[ip++];
-         intStack[_UINT + 1] = gEvalState.getLocalIntVariable(reg);
-         _UINT++;
+         numStack[_STK + 1].i = gEvalState.getLocalIntVariable(reg);
+         _STK++;
          break;
 
       case OP_LOAD_LOCAL_VAR_FLT:
          reg = code[ip++];
-         floatStack[_FLT + 1] = gEvalState.getLocalFloatVariable(reg);
-         _FLT++;
+         numStack[_STK + 1].f = gEvalState.getLocalFloatVariable(reg);
+         _STK++;
          break;
 
       case OP_LOAD_LOCAL_VAR_STR:
@@ -1366,12 +1362,12 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
 
       case OP_SAVE_LOCAL_VAR_UINT:
          reg = code[ip++];
-         gEvalState.setLocalIntVariable(reg, (S32)intStack[_UINT]);
+         gEvalState.setLocalIntVariable(reg, numStack[_STK].i);
          break;
 
       case OP_SAVE_LOCAL_VAR_FLT:
          reg = code[ip++];
-         gEvalState.setLocalFloatVariable(reg, floatStack[_FLT]);
+         gEvalState.setLocalFloatVariable(reg, numStack[_STK].f);
          break;
 
       case OP_SAVE_LOCAL_VAR_STR:
@@ -1408,13 +1404,13 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
                StringTableEntry intName = StringTable->insert(STR.getStringValue());
                bool recurse = code[ip - 1];
                SimObject* obj = group->findObjectByInternalName(intName, recurse);
-               intStack[_UINT + 1] = obj ? obj->getId() : 0;
-               _UINT++;
+               numStack[_STK + 1].i = obj ? obj->getId() : 0;
+               _STK++;
             }
             else
             {
                Con::errorf(ConsoleLogEntry::Script, "%s: Attempt to use -> on non-group %s of class %s.", getFileLine(ip - 2), curObject->getName(), curObject->getClassName());
-               intStack[_UINT] = 0;
+               numStack[_STK].i = 0;
             }
          }
          break;
@@ -1444,7 +1440,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
 
       case OP_LOADFIELD_UINT:
          if (curObject)
-            intStack[_UINT + 1] = U32(dAtoi(curObject->getDataField(curField, curFieldArray)));
+            numStack[_STK + 1].i = dAtol(curObject->getDataField(curField, curFieldArray));
          else
          {
             // The field is not being retrieved from an object. Maybe it's
@@ -1452,14 +1448,14 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
             char buff[FieldBufferSizeNumeric];
             memset(buff, 0, sizeof(buff));
             getFieldComponent(prevObject, prevField, prevFieldArray, curField, buff);
-            intStack[_UINT + 1] = dAtoi(buff);
+            numStack[_STK + 1].i = dAtol(buff);
          }
-         _UINT++;
+         _STK++;
          break;
 
       case OP_LOADFIELD_FLT:
          if (curObject)
-            floatStack[_FLT + 1] = dAtof(curObject->getDataField(curField, curFieldArray));
+            numStack[_STK + 1].f = dAtod(curObject->getDataField(curField, curFieldArray));
          else
          {
             // The field is not being retrieved from an object. Maybe it's
@@ -1467,9 +1463,9 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
             char buff[FieldBufferSizeNumeric];
             memset(buff, 0, sizeof(buff));
             getFieldComponent(prevObject, prevField, prevFieldArray, curField, buff);
-            floatStack[_FLT + 1] = dAtof(buff);
+            numStack[_STK + 1].f = dAtod(buff);
          }
-         _FLT++;
+         _STK++;
          break;
 
       case OP_LOADFIELD_STR:
@@ -1491,7 +1487,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          break;
 
       case OP_SAVEFIELD_UINT:
-         STR.setIntValue((U32)intStack[_UINT]);
+         STR.setIntValue(numStack[_STK].i);
          if (curObject)
             curObject->setDataField(curField, curFieldArray, STR.getStringValue());
          else
@@ -1504,7 +1500,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          break;
 
       case OP_SAVEFIELD_FLT:
-         STR.setFloatValue(floatStack[_FLT]);
+         STR.setFloatValue(numStack[_STK].f);
          if (curObject)
             curObject->setDataField(curField, curFieldArray, STR.getStringValue());
          else
@@ -1529,13 +1525,13 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          break;
 
       case OP_STR_TO_UINT:
-         intStack[_UINT + 1] = STR.getIntValue();
-         _UINT++;
+         numStack[_STK + 1].i = STR.getIntValue();
+         _STK++;
          break;
 
       case OP_STR_TO_FLT:
-         floatStack[_FLT + 1] = STR.getFloatValue();
-         _FLT++;
+         numStack[_STK + 1].f = STR.getFloatValue();
+         _STK++;
          break;
 
       case OP_STR_TO_NONE:
@@ -1543,44 +1539,39 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          break;
 
       case OP_FLT_TO_UINT:
-         intStack[_UINT + 1] = (S64)floatStack[_FLT];
-         _FLT--;
-         _UINT++;
+         numStack[_STK].i = (S64)numStack[_STK].f;
          break;
 
       case OP_FLT_TO_STR:
-         STR.setFloatValue(floatStack[_FLT]);
-         _FLT--;
+         STR.setFloatValue(numStack[_STK].f);
+         _STK--;
          break;
 
       case OP_FLT_TO_NONE:
-         _FLT--;
+         _STK--;
          break;
 
       case OP_UINT_TO_FLT:
-         floatStack[_FLT + 1] = (F64)intStack[_UINT];
-         _UINT--;
-         _FLT++;
+         numStack[_STK].f = (F64)numStack[_STK].i;
          break;
 
       case OP_UINT_TO_STR:
-         STR.setIntValue((U32)intStack[_UINT]);
-         _UINT--;
+         STR.setIntValue(numStack[_STK].i);
+         _STK--;
          break;
 
       case OP_UINT_TO_NONE:
-         _UINT--;
+         _STK--;
          break;
 
       case OP_LOADIMMED_UINT:
-         intStack[_UINT + 1] = code[ip++];
-         _UINT++;
+         numStack[_STK + 1].i = code[ip++];
+         _STK++;
          break;
 
       case OP_LOADIMMED_FLT:
-         floatStack[_FLT + 1] = curFloatTable[code[ip]];
-         ip++;
-         _FLT++;
+         numStack[_STK + 1].f = curFloatTable[code[ip++]];
+         _STK++;
          break;
       case OP_TAG_TO_STR:
          code[ip - 1] = OP_LOADIMMED_STR;
@@ -1791,18 +1782,18 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
                }
                case Namespace::Entry::IntCallbackType:
                {
-                  S32 result = nsEntry->cb.mIntCallbackFunc(gEvalState.thisObject, callArgc, callArgv);
+                  S64 result = nsEntry->cb.mIntCallbackFunc(gEvalState.thisObject, callArgc, callArgv);
                   gCallStack.popFrame();
                   if (code[ip] == OP_STR_TO_UINT)
                   {
                      ip++;
-                     intStack[++_UINT] = result;
+                     numStack[++_STK].i = result;
                      break;
                   }
                   else if (code[ip] == OP_STR_TO_FLT)
                   {
                      ip++;
-                     floatStack[++_FLT] = result;
+                     numStack[++_STK].f = result;
                      break;
                   }
                   else if (code[ip] == OP_STR_TO_NONE)
@@ -1818,13 +1809,13 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
                   if (code[ip] == OP_STR_TO_UINT)
                   {
                      ip++;
-                     intStack[++_UINT] = (S64)result;
+                     numStack[++_STK].i = (S64)result;
                      break;
                   }
                   else if (code[ip] == OP_STR_TO_FLT)
                   {
                      ip++;
-                     floatStack[++_FLT] = result;
+                     numStack[++_STK].f = result;
                      break;
                   }
                   else if (code[ip] == OP_STR_TO_NONE)
@@ -1849,13 +1840,13 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
                   if (code[ip] == OP_STR_TO_UINT)
                   {
                      ip++;
-                     intStack[++_UINT] = result;
+                     numStack[++_STK].i = result;
                      break;
                   }
                   else if (code[ip] == OP_STR_TO_FLT)
                   {
                      ip++;
-                     floatStack[++_FLT] = result;
+                     numStack[++_STK].f = result;
                      break;
                   }
                   else if (code[ip] == OP_STR_TO_NONE)
@@ -1896,7 +1887,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          break;
 
       case OP_COMPARE_STR:
-         intStack[++_UINT] = STR.compare();
+         numStack[++_STK].i = STR.compare();
          break;
 
       case OP_PUSH:
@@ -1904,11 +1895,11 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          break;
 
       case OP_PUSH_UINT:
-         gCallStack.pushInt((U32)intStack[_UINT--]);
+         gCallStack.pushInt((U32)numStack[_STK--].i);
          break;
 
       case OP_PUSH_FLT:
-         gCallStack.pushFloat(floatStack[_FLT--]);
+         gCallStack.pushFloat(numStack[_STK--].f);
          break;
 
       case OP_PUSH_FRAME:
@@ -1917,7 +1908,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
 
       case OP_ASSERT:
       {
-         if (!intStack[_UINT--])
+         if (!numStack[_STK--].i)
          {
             const char* message = curStringTable + code[ip];
 
diff --git a/Engine/source/console/stringStack.h b/Engine/source/console/stringStack.h
index 1b5d5d84e..6a5dd977f 100644
--- a/Engine/source/console/stringStack.h
+++ b/Engine/source/console/stringStack.h
@@ -114,15 +114,15 @@ struct StringStack
    }
 
    /// Get an integer representation of the top of the stack.
-   inline U32 getIntValue()
+   inline S64 getIntValue()
    {
-      return dAtoi(mBuffer + mStart);
+      return dAtol(mBuffer + mStart);
    }
 
    /// Get a float representation of the top of the stack.
    inline F64 getFloatValue()
    {
-      return dAtof(mBuffer + mStart);
+      return dAtod(mBuffer + mStart);
    }
 
    /// Get a string representation of the top of the stack.

From bfc01094853aaaaae222e01b19db1c658d2ad0ad Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Fri, 16 Apr 2021 23:21:39 -0400
Subject: [PATCH 013/399] fixes and some minor bc adjustment.

---
 Engine/source/console/CMDscan.l        |  1 +
 Engine/source/console/astNodes.cpp     |  4 ++--
 Engine/source/console/codeBlock.cpp    | 10 ++--------
 Engine/source/console/compiledEval.cpp |  6 +-----
 Engine/source/console/compiler.h       |  3 +--
 Engine/source/console/console.cpp      |  2 +-
 Engine/source/console/console.h        |  7 +++----
 7 files changed, 11 insertions(+), 22 deletions(-)

diff --git a/Engine/source/console/CMDscan.l b/Engine/source/console/CMDscan.l
index e9069fe15..ccf933bd7 100644
--- a/Engine/source/console/CMDscan.l
+++ b/Engine/source/console/CMDscan.l
@@ -213,6 +213,7 @@ HEXDIGIT [a-fA-F0-9]
 "true"      { CMDlval.i = MakeToken< int >( 1, lineIndex ); return INTCONST; }
 "false"     { CMDlval.i = MakeToken< int >( 0, lineIndex ); return INTCONST; }
 {VAR}       { return(Sc_ScanVar()); }
+
 {ID}        { return Sc_ScanIdent(); }
 0[xX]{HEXDIGIT}+ return(Sc_ScanHex());
 {INTEGER}   { CMDtext[CMDleng] = 0; CMDlval.i = MakeToken< int >( dAtoi(CMDtext), lineIndex ); return INTCONST; }
diff --git a/Engine/source/console/astNodes.cpp b/Engine/source/console/astNodes.cpp
index 14f610bd2..9fa5c1e11 100644
--- a/Engine/source/console/astNodes.cpp
+++ b/Engine/source/console/astNodes.cpp
@@ -165,7 +165,7 @@ static U32 conversionOp(TypeReq src, TypeReq dst)
       case TypeReqString:
          return OP_FLT_TO_STR;
       case TypeReqNone:
-         return OP_FLT_TO_NONE;
+         return OP_NUM_TO_NONE;
       default:
          break;
       }
@@ -179,7 +179,7 @@ static U32 conversionOp(TypeReq src, TypeReq dst)
       case TypeReqString:
          return OP_UINT_TO_STR;
       case TypeReqNone:
-         return OP_UINT_TO_NONE;
+         return OP_NUM_TO_NONE;
       default:
          break;
       }
diff --git a/Engine/source/console/codeBlock.cpp b/Engine/source/console/codeBlock.cpp
index 559e921c3..47345aae1 100644
--- a/Engine/source/console/codeBlock.cpp
+++ b/Engine/source/console/codeBlock.cpp
@@ -1215,12 +1215,6 @@ void CodeBlock::dumpInstructions(U32 startIp, bool upToReturn)
          break;
       }
 
-      case OP_FLT_TO_NONE:
-      {
-         Con::printf("%i: OP_FLT_TO_NONE", ip - 1);
-         break;
-      }
-
       case OP_UINT_TO_FLT:
       {
          Con::printf("%i: OP_UINT_TO_FLT", ip - 1);
@@ -1233,9 +1227,9 @@ void CodeBlock::dumpInstructions(U32 startIp, bool upToReturn)
          break;
       }
 
-      case OP_UINT_TO_NONE:
+      case OP_NUM_TO_NONE:
       {
-         Con::printf("%i: OP_UINT_TO_NONE", ip - 1);
+         Con::printf("%i: OP_NUM_TO_NONE", ip - 1);
          break;
       }
 
diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index c1db544eb..b39a29133 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -1547,10 +1547,6 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          _STK--;
          break;
 
-      case OP_FLT_TO_NONE:
-         _STK--;
-         break;
-
       case OP_UINT_TO_FLT:
          numStack[_STK].f = (F64)numStack[_STK].i;
          break;
@@ -1560,7 +1556,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          _STK--;
          break;
 
-      case OP_UINT_TO_NONE:
+      case OP_NUM_TO_NONE:
          _STK--;
          break;
 
diff --git a/Engine/source/console/compiler.h b/Engine/source/console/compiler.h
index c58fff3e6..f0633deab 100644
--- a/Engine/source/console/compiler.h
+++ b/Engine/source/console/compiler.h
@@ -137,10 +137,9 @@ namespace Compiler
       OP_STR_TO_NONE,  // 60
       OP_FLT_TO_UINT,
       OP_FLT_TO_STR,
-      OP_FLT_TO_NONE,
       OP_UINT_TO_FLT,
       OP_UINT_TO_STR,
-      OP_UINT_TO_NONE,
+      OP_NUM_TO_NONE,
 
       OP_LOADIMMED_UINT,
       OP_LOADIMMED_FLT,
diff --git a/Engine/source/console/console.cpp b/Engine/source/console/console.cpp
index a544aad0e..4f6971eb8 100644
--- a/Engine/source/console/console.cpp
+++ b/Engine/source/console/console.cpp
@@ -2595,7 +2595,7 @@ ConsoleValue _BaseEngineConsoleCallbackHelper::_exec()
       // Cannot invoke callback until object has been registered
       if (mThis->isProperlyAdded())
       {
-         ConsoleValue returnValue = std::move(Con::_internalExecute( mThis, mArgc, mArgv, false ));
+         ConsoleValue returnValue = Con::_internalExecute( mThis, mArgc, mArgv, false );
          mArgc = mInitialArgc; // reset
          return std::move(returnValue);
       }
diff --git a/Engine/source/console/console.h b/Engine/source/console/console.h
index 763adc564..d42c202a7 100644
--- a/Engine/source/console/console.h
+++ b/Engine/source/console/console.h
@@ -175,14 +175,14 @@ class ConsoleValue
    }
 
 public:
-   ConsoleValue()
+   explicit ConsoleValue()
    {
-      setEmptyString();
+      type = ConsoleValueType::cvSTEntry;
+      s = const_cast<char*>(StringTable->EmptyString());
    }
 
    ConsoleValue(ConsoleValue&& ref) noexcept
    {
-      cleanupData();
       type = ref.type;
 
       switch (ref.type)
@@ -217,7 +217,6 @@ public:
 
    TORQUE_FORCEINLINE void reset()
    {
-      cleanupData();
       setEmptyString();
    }
 

From bb12638ea5cfccf28f19401253bdb2639c6b863c Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Sat, 17 Apr 2021 14:31:27 -0400
Subject: [PATCH 014/399] Added error checking for using a local variable in
 global scope, and added optimization to method object parameter.

---
 Engine/source/console/astNodes.cpp     | 24 +++++++++++++++---------
 Engine/source/console/compiledEval.cpp | 11 ++++++++++-
 2 files changed, 25 insertions(+), 10 deletions(-)

diff --git a/Engine/source/console/astNodes.cpp b/Engine/source/console/astNodes.cpp
index 9fa5c1e11..4d58d91d4 100644
--- a/Engine/source/console/astNodes.cpp
+++ b/Engine/source/console/astNodes.cpp
@@ -101,6 +101,12 @@ private:
 
 FuncVars* gFuncVars = NULL;
 
+inline FuncVars* getFuncVars()
+{
+   AssertISV(gFuncVars, "Attemping to use local variable in global scope.");
+   return gFuncVars;
+}
+
 //-----------------------------------------------------------------------------
 
 void StmtNode::addBreakLine(CodeStream& code)
@@ -424,7 +430,7 @@ U32 IterStmtNode::compileStmt(CodeStream& codeStream, U32 ip)
    if (isGlobal)
       codeStream.emitSTE(varName);
    else
-      codeStream.emit(gFuncVars->assign(varName, varType));
+      codeStream.emit(getFuncVars()->assign(varName, varType));
    const U32 finalFix = codeStream.emit(0);
    const U32 continueIp = codeStream.emit(OP_ITER);
    codeStream.emitFix(CodeStream::FIXTYPE_BREAK);
@@ -793,7 +799,7 @@ U32 VarNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
       default:           codeStream.emit(OP_LOAD_LOCAL_VAR_STR);
       }
 
-      codeStream.emit(gFuncVars->lookup(varName));
+      codeStream.emit(getFuncVars()->lookup(varName));
    }
 
    return codeStream.tell();
@@ -802,7 +808,7 @@ U32 VarNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 TypeReq VarNode::getPreferredType()
 {
    bool oldVariables = arrayIndex || varName[0] == '$';
-   return oldVariables ? TypeReqNone : gFuncVars->lookupType(varName);
+   return oldVariables ? TypeReqNone : getFuncVars()->lookupType(varName);
 }
 
 //------------------------------------------------------------
@@ -1040,7 +1046,7 @@ U32 AssignExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
       case TypeReqFloat: codeStream.emit(OP_SAVE_LOCAL_VAR_FLT); break;
       default:           codeStream.emit(OP_SAVE_LOCAL_VAR_STR);
       }
-      codeStream.emit(gFuncVars->assign(varName, subType == TypeReqNone ? TypeReqString : subType));
+      codeStream.emit(getFuncVars()->assign(varName, subType == TypeReqNone ? TypeReqString : subType));
    }
 
    if (type != subType)
@@ -1136,7 +1142,7 @@ U32 AssignOpExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 
    if (op == opPLUSPLUS && !oldVariables)
    {
-      const S32 varIdx = gFuncVars->assign(varName, TypeReqFloat);
+      const S32 varIdx = getFuncVars()->assign(varName, TypeReqFloat);
 
       codeStream.emit(OP_INC);
       codeStream.emit(varIdx);
@@ -1169,7 +1175,7 @@ U32 AssignOpExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
       else
       {
          const bool isFloat = subType == TypeReqFloat;
-         const S32 varIdx = gFuncVars->assign(varName, subType == TypeReqNone ? TypeReqString : subType);
+         const S32 varIdx = getFuncVars()->assign(varName, subType == TypeReqNone ? TypeReqString : subType);
 
          codeStream.emit(isFloat ? OP_LOAD_LOCAL_VAR_FLT : OP_LOAD_LOCAL_VAR_UINT);
          codeStream.emit(varIdx);
@@ -1649,7 +1655,7 @@ U32 FunctionDeclStmtNode::compileStmt(CodeStream& codeStream, U32 ip)
    for (VarNode* walk = args; walk; walk = (VarNode*)((StmtNode*)walk)->getNext())
    {
       precompileIdent(walk->varName);
-      gFuncVars->assign(walk->varName, TypeReqNone);
+      getFuncVars()->assign(walk->varName, TypeReqNone);
       argc++;
    }
 
@@ -1673,7 +1679,7 @@ U32 FunctionDeclStmtNode::compileStmt(CodeStream& codeStream, U32 ip)
    for (VarNode* walk = args; walk; walk = (VarNode*)((StmtNode*)walk)->getNext())
    {
       StringTableEntry name = walk->varName;
-      codeStream.emit(gFuncVars->lookup(name));
+      codeStream.emit(getFuncVars()->lookup(name));
    }
    CodeBlock::smInFunction = true;
    ip = compileBlock(stmts, codeStream, ip);
@@ -1685,7 +1691,7 @@ U32 FunctionDeclStmtNode::compileStmt(CodeStream& codeStream, U32 ip)
    CodeBlock::smInFunction = false;
    codeStream.emit(OP_RETURN_VOID);
 
-   codeStream.patch(localNumVarsIP, gFuncVars->count());
+   codeStream.patch(localNumVarsIP, getFuncVars()->count());
    codeStream.patch(endIp, codeStream.tell());
 
    setCurrentStringTable(&getGlobalStringTable());
diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index b39a29133..5a6785ed2 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -1682,7 +1682,16 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
             if (simObjectLookupValue.getType() == ConsoleValueType::cvInteger)
                gEvalState.thisObject = Sim::findObject(static_cast<SimObjectId>(simObjectLookupValue.getInt()));
             else
-               gEvalState.thisObject = Sim::findObject(simObjectLookupValue.getString());
+            {
+               SimObject *foundObject = Sim::findObject(simObjectLookupValue.getString());
+
+               // Optimization: If we're not an integer, let's make it so that the fast path exists
+               // on the first argument of the method call (speeds up future usage of %this, for example)
+               if (foundObject != NULL)
+                  callArgv[1].setInt(static_cast<S64>(foundObject->getId()));
+
+               gEvalState.thisObject = foundObject;
+            }
 
             if (gEvalState.thisObject == NULL)
             {

From f056e181b743d695ceabef69e724d6b7034ad17d Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Tue, 20 Apr 2021 19:55:35 -0400
Subject: [PATCH 015/399] remove unused code.

---
 Engine/source/console/console.cpp     |  2 --
 Engine/source/console/stringStack.cpp | 28 ---------------------------
 Engine/source/console/stringStack.h   |  4 ----
 3 files changed, 34 deletions(-)

diff --git a/Engine/source/console/console.cpp b/Engine/source/console/console.cpp
index 4f6971eb8..a7d2dafc6 100644
--- a/Engine/source/console/console.cpp
+++ b/Engine/source/console/console.cpp
@@ -2622,7 +2622,6 @@ ConsoleValue _BaseEngineConsoleCallbackHelper::_execLater(SimConsoleThreadExecEv
 void ConsoleStackFrameSaver::save()
 {
    gCallStack.pushFrame(0);
-   STR.pushFrame();
    mSaved = true;
 }
 
@@ -2631,6 +2630,5 @@ void ConsoleStackFrameSaver::restore()
    if (mSaved)
    {
       gCallStack.popFrame();
-      STR.popFrame();
    }
 }
diff --git a/Engine/source/console/stringStack.cpp b/Engine/source/console/stringStack.cpp
index 78d98f183..f1ee26702 100644
--- a/Engine/source/console/stringStack.cpp
+++ b/Engine/source/console/stringStack.cpp
@@ -39,7 +39,6 @@ StringStack::StringStack()
    mStart = 0;
    mLen = 0;
    mStartStackSize = 0;
-   mFunctionOffset = 0;
    validateBufferSize(8192);
    validateArgBufferSize(2048);
    dMemset(mBuffer, '\0', mBufferSize);
@@ -180,30 +179,3 @@ U32 StringStack::compare()
 
    return ret;
 }
-
-void StringStack::pushFrame()
-{
-   //Con::printf("StringStack pushFrame [frame=%i, start=%i]", mNumFrames, mStartStackSize);
-   mFrameOffsets[mNumFrames++] = mStartStackSize;
-   mStartOffsets[mStartStackSize++] = mStart;
-   mStart += ReturnBufferSpace;
-   validateBufferSize(0);
-}
-
-void StringStack::popFrame()
-{
-   //Con::printf("StringStack popFrame [frame=%i, start=%i]", mNumFrames, mStartStackSize);
-   mStartStackSize = mFrameOffsets[--mNumFrames];
-   mStart = mStartOffsets[mStartStackSize];
-   mLen = 0;
-}
-
-void StringStack::clearFrames()
-{
-   //Con::printf("StringStack clearFrames");
-   mNumFrames = 0;
-   mStart = 0;
-   mLen = 0;
-   mStartStackSize = 0;
-   mFunctionOffset = 0;
-}
diff --git a/Engine/source/console/stringStack.h b/Engine/source/console/stringStack.h
index 6a5dd977f..1ebac1fc7 100644
--- a/Engine/source/console/stringStack.h
+++ b/Engine/source/console/stringStack.h
@@ -169,10 +169,6 @@ struct StringStack
    /// and returning true if they matched, false if they didn't.
    U32 compare();
 
-   void pushFrame();
-
-   void popFrame();
-
    void clearFrames();
 };
 

From 964fde8f091a254286797e1ed57a8218a160bfab Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Mon, 26 Apr 2021 22:52:58 -0400
Subject: [PATCH 016/399] Goodbye String Stack!

---
 Engine/source/console/astNodes.cpp        | 185 +++-------
 Engine/source/console/codeBlock.cpp       | 268 ++++++--------
 Engine/source/console/compiledEval.cpp    | 408 ++++++++++------------
 Engine/source/console/compiler.h          |  22 +-
 Engine/source/console/console.h           |  27 +-
 Engine/source/console/consoleValueStack.h |  16 +-
 Engine/source/console/test/ScriptTest.cpp | 139 ++++++++
 7 files changed, 507 insertions(+), 558 deletions(-)

diff --git a/Engine/source/console/astNodes.cpp b/Engine/source/console/astNodes.cpp
index 4d58d91d4..1f8fea367 100644
--- a/Engine/source/console/astNodes.cpp
+++ b/Engine/source/console/astNodes.cpp
@@ -47,7 +47,9 @@ namespace Compiler
    U32 compileBlock(StmtNode* block, CodeStream& codeStream, U32 ip)
    {
       for (StmtNode* walk = block; walk; walk = walk->getNext())
+      {
          ip = walk->compileStmt(codeStream, ip);
+      }
       return codeStream.tell();
    }
 }
@@ -146,55 +148,6 @@ void FunctionDeclStmtNode::setPackage(StringTableEntry packageName)
 //
 //------------------------------------------------------------
 
-static U32 conversionOp(TypeReq src, TypeReq dst)
-{
-   if (src == TypeReqString)
-   {
-      switch (dst)
-      {
-      case TypeReqUInt:
-         return OP_STR_TO_UINT;
-      case TypeReqFloat:
-         return OP_STR_TO_FLT;
-      case TypeReqNone:
-         return OP_STR_TO_NONE;
-      default:
-         break;
-      }
-   }
-   else if (src == TypeReqFloat)
-   {
-      switch (dst)
-      {
-      case TypeReqUInt:
-         return OP_FLT_TO_UINT;
-      case TypeReqString:
-         return OP_FLT_TO_STR;
-      case TypeReqNone:
-         return OP_NUM_TO_NONE;
-      default:
-         break;
-      }
-   }
-   else if (src == TypeReqUInt)
-   {
-      switch (dst)
-      {
-      case TypeReqFloat:
-         return OP_UINT_TO_FLT;
-      case TypeReqString:
-         return OP_UINT_TO_STR;
-      case TypeReqNone:
-         return OP_NUM_TO_NONE;
-      default:
-         break;
-      }
-   }
-   return OP_INVALID;
-}
-
-//------------------------------------------------------------
-
 U32 BreakStmtNode::compileStmt(CodeStream& codeStream, U32 ip)
 {
    if (codeStream.inLoop())
@@ -517,8 +470,6 @@ U32 FloatBinaryExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
       break;
    }
    codeStream.emit(operand);
-   if (type != TypeReqFloat)
-      codeStream.emit(conversionOp(TypeReqFloat, type));
    return codeStream.tell();
 }
 
@@ -608,8 +559,6 @@ U32 IntBinaryExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
       ip = left->compile(codeStream, ip, subType);
       codeStream.emit(operand);
    }
-   if (type != TypeReqUInt)
-      codeStream.emit(conversionOp(TypeReqUInt, type));
    return codeStream.tell();
 }
 
@@ -629,13 +578,10 @@ U32 StreqExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
    // optional conversion
 
    ip = left->compile(codeStream, ip, TypeReqString);
-   codeStream.emit(OP_ADVANCE_STR_NUL);
    ip = right->compile(codeStream, ip, TypeReqString);
    codeStream.emit(OP_COMPARE_STR);
    if (!eq)
       codeStream.emit(OP_NOT);
-   if (type != TypeReqUInt)
-      codeStream.emit(conversionOp(TypeReqUInt, type));
    return codeStream.tell();
 }
 
@@ -649,19 +595,13 @@ TypeReq StreqExprNode::getPreferredType()
 U32 StrcatExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 {
    ip = left->compile(codeStream, ip, TypeReqString);
-   if (!appendChar)
-      codeStream.emit(OP_ADVANCE_STR);
-   else
+   if (appendChar)
    {
       codeStream.emit(OP_ADVANCE_STR_APPENDCHAR);
       codeStream.emit(appendChar);
    }
    ip = right->compile(codeStream, ip, TypeReqString);
    codeStream.emit(OP_REWIND_STR);
-   if (type == TypeReqUInt)
-      codeStream.emit(OP_STR_TO_UINT);
-   else if (type == TypeReqFloat)
-      codeStream.emit(OP_STR_TO_FLT);
    return codeStream.tell();
 }
 
@@ -675,7 +615,8 @@ TypeReq StrcatExprNode::getPreferredType()
 U32 CommaCatExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 {
    ip = left->compile(codeStream, ip, TypeReqString);
-   codeStream.emit(OP_ADVANCE_STR_COMMA);
+   codeStream.emit(OP_ADVANCE_STR_APPENDCHAR);
+   codeStream.emit('_');
    ip = right->compile(codeStream, ip, TypeReqString);
    codeStream.emit(OP_REWIND_STR);
 
@@ -684,10 +625,7 @@ U32 CommaCatExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
    // But we're paranoid, so accept (but whine) if we get an oddity...
    if (type == TypeReqUInt || type == TypeReqFloat)
       Con::warnf(ConsoleLogEntry::General, "%s (%d): converting comma string to a number... probably wrong.", dbgFileName, dbgLineNumber);
-   if (type == TypeReqUInt)
-      codeStream.emit(OP_STR_TO_UINT);
-   else if (type == TypeReqFloat)
-      codeStream.emit(OP_STR_TO_FLT);
+
    return codeStream.tell();
 }
 
@@ -710,8 +648,7 @@ U32 IntUnaryExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
       codeStream.emit(integer ? OP_NOT : OP_NOTF);
    else if (op == '~')
       codeStream.emit(OP_ONESCOMPLEMENT);
-   if (type != TypeReqUInt)
-      codeStream.emit(conversionOp(TypeReqUInt, type));
+
    return codeStream.tell();
 }
 
@@ -726,8 +663,7 @@ U32 FloatUnaryExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 {
    ip = expr->compile(codeStream, ip, TypeReqFloat);
    codeStream.emit(OP_NEG);
-   if (type != TypeReqFloat)
-      codeStream.emit(conversionOp(TypeReqFloat, type));
+
    return codeStream.tell();
 }
 
@@ -768,10 +704,11 @@ U32 VarNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 
       if (arrayIndex)
       {
-         codeStream.emit(OP_ADVANCE_STR);
+         //codeStream.emit(OP_ADVANCE_STR);
          ip = arrayIndex->compile(codeStream, ip, TypeReqString);
          codeStream.emit(OP_REWIND_STR);
          codeStream.emit(OP_SETCURVAR_ARRAY);
+         codeStream.emit(OP_POP_STK);
       }
       switch (type)
       {
@@ -1013,18 +950,18 @@ U32 AssignExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
    {
       if (arrayIndex)
       {
-         if (subType == TypeReqString)
-            codeStream.emit(OP_ADVANCE_STR);
+         //if (subType == TypeReqString)
+         //   codeStream.emit(OP_ADVANCE_STR);
 
          codeStream.emit(OP_LOADIMMED_IDENT);
          codeStream.emitSTE(varName);
 
-         codeStream.emit(OP_ADVANCE_STR);
+         //codeStream.emit(OP_ADVANCE_STR);
          ip = arrayIndex->compile(codeStream, ip, TypeReqString);
          codeStream.emit(OP_REWIND_STR);
          codeStream.emit(OP_SETCURVAR_ARRAY_CREATE);
-         if (subType == TypeReqString)
-            codeStream.emit(OP_TERMINATE_REWIND_STR);
+         if (type == TypeReqNone)
+            codeStream.emit(OP_POP_STK);
       }
       else
       {
@@ -1049,11 +986,8 @@ U32 AssignExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
       codeStream.emit(getFuncVars()->assign(varName, subType == TypeReqNone ? TypeReqString : subType));
    }
 
-   if (type != subType)
-   {
-      U32 conOp = conversionOp(subType, type);
-      codeStream.emit(conOp);
-   }
+   if (type == TypeReqNone)
+      codeStream.emit(OP_POP_STK);
    return ip;
 }
 
@@ -1068,11 +1002,14 @@ static void getAssignOpTypeOp(S32 op, TypeReq& type, U32& operand)
 {
    switch (op)
    {
-   case '+':
    case opPLUSPLUS:
+      TORQUE_CASE_FALLTHROUGH;
+   case '+':
       type = TypeReqFloat;
       operand = OP_ADD;
       break;
+   case opMINUSMINUS:
+      TORQUE_CASE_FALLTHROUGH;
    case '-':
       type = TypeReqFloat;
       operand = OP_SUB;
@@ -1109,6 +1046,8 @@ static void getAssignOpTypeOp(S32 op, TypeReq& type, U32& operand)
       type = TypeReqUInt;
       operand = OP_SHR;
       break;
+   default:
+      AssertFatal(false, "Invalid opcode on operation expression");
    }
 }
 
@@ -1163,10 +1102,12 @@ U32 AssignOpExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
             codeStream.emit(OP_LOADIMMED_IDENT);
             codeStream.emitSTE(varName);
 
-            codeStream.emit(OP_ADVANCE_STR);
+            //codeStream.emit(OP_ADVANCE_STR);
             ip = arrayIndex->compile(codeStream, ip, TypeReqString);
             codeStream.emit(OP_REWIND_STR);
             codeStream.emit(OP_SETCURVAR_ARRAY_CREATE);
+            if (type == TypeReqNone)
+               codeStream.emit(OP_POP_STK);
          }
          codeStream.emit((subType == TypeReqFloat) ? OP_LOADVAR_FLT : OP_LOADVAR_UINT);
          codeStream.emit(operand);
@@ -1184,10 +1125,8 @@ U32 AssignOpExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
          codeStream.emit(varIdx);
       }
 
-      if (subType != type)
-      {
-         codeStream.emit(conversionOp(subType, type));
-      }
+      if (type == TypeReqNone)
+         codeStream.emit(OP_POP_STK);
    }
    return codeStream.tell();
 }
@@ -1259,18 +1198,7 @@ U32 FuncCallExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
          walkType = TypeReqString;
 
       ip = walk->compile(codeStream, ip, walkType);
-      switch (walk->getPreferredType())
-      {
-      case TypeReqFloat:
-         codeStream.emit(OP_PUSH_FLT);
-         break;
-      case TypeReqUInt:
-         codeStream.emit(OP_PUSH_UINT);
-         break;
-      default:
-         codeStream.emit(OP_PUSH);
-         break;
-      }
+      codeStream.emit(OP_PUSH);
    }
 
    codeStream.emit(OP_CALLFUNC);
@@ -1278,8 +1206,9 @@ U32 FuncCallExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
    codeStream.emitSTE(nameSpace);
    codeStream.emit(callType);
 
-   if (type != TypeReqString)
-      codeStream.emit(conversionOp(TypeReqString, type));
+   if (type == TypeReqNone)
+      codeStream.emit(OP_POP_STK);
+
    return codeStream.tell();
 }
 
@@ -1288,7 +1217,6 @@ TypeReq FuncCallExprNode::getPreferredType()
    return TypeReqString;
 }
 
-
 //------------------------------------------------------------
 
 U32 AssertCallExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
@@ -1322,15 +1250,7 @@ U32 SlotAccessNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 
    if (arrayExpr)
    {
-      // eval array
-      // OP_ADVANCE_STR
-      // evaluate object expression sub (OP_SETCURFIELD)
-      // OP_TERMINATE_REWIND_STR
-      // OP_SETCURFIELDARRAY
-      // total add of 4 + array precomp
-
       ip = arrayExpr->compile(codeStream, ip, TypeReqString);
-      codeStream.emit(OP_ADVANCE_STR);
    }
    ip = objectExpr->compile(codeStream, ip, TypeReqString);
    codeStream.emit(OP_SETCUROBJECT);
@@ -1341,8 +1261,8 @@ U32 SlotAccessNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 
    if (arrayExpr)
    {
-      codeStream.emit(OP_TERMINATE_REWIND_STR);
       codeStream.emit(OP_SETCURFIELD_ARRAY);
+      codeStream.emit(OP_POP_STK);
    }
 
    switch (type)
@@ -1381,8 +1301,6 @@ U32 InternalSlotAccessNode::compile(CodeStream& codeStream, U32 ip, TypeReq type
    codeStream.emit(OP_SETCUROBJECT_INTERNAL);
    codeStream.emit(recurse);
 
-   if (type != TypeReqUInt)
-      codeStream.emit(conversionOp(TypeReqUInt, type));
    return codeStream.tell();
 }
 
@@ -1426,11 +1344,9 @@ U32 SlotAssignNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
    precompileIdent(slotName);
 
    ip = valueExpr->compile(codeStream, ip, TypeReqString);
-   codeStream.emit(OP_ADVANCE_STR);
    if (arrayExpr)
    {
       ip = arrayExpr->compile(codeStream, ip, TypeReqString);
-      codeStream.emit(OP_ADVANCE_STR);
    }
    if (objectExpr)
    {
@@ -1444,11 +1360,10 @@ U32 SlotAssignNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 
    if (arrayExpr)
    {
-      codeStream.emit(OP_TERMINATE_REWIND_STR);
       codeStream.emit(OP_SETCURFIELD_ARRAY);
+      codeStream.emit(OP_POP_STK);
    }
 
-   codeStream.emit(OP_TERMINATE_REWIND_STR);
    codeStream.emit(OP_SAVEFIELD_STR);
 
    if (typeID != -1)
@@ -1457,8 +1372,9 @@ U32 SlotAssignNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
       codeStream.emit(typeID);
    }
 
-   if (type != TypeReqString)
-      codeStream.emit(conversionOp(TypeReqString, type));
+   if (type == TypeReqNone)
+      codeStream.emit(OP_POP_STK);
+
    return codeStream.tell();
 }
 
@@ -1501,7 +1417,6 @@ U32 SlotAssignOpNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
    if (arrayExpr)
    {
       ip = arrayExpr->compile(codeStream, ip, TypeReqString);
-      codeStream.emit(OP_ADVANCE_STR);
    }
    ip = objectExpr->compile(codeStream, ip, TypeReqString);
    codeStream.emit(OP_SETCUROBJECT);
@@ -1510,14 +1425,15 @@ U32 SlotAssignOpNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 
    if (arrayExpr)
    {
-      codeStream.emit(OP_TERMINATE_REWIND_STR);
       codeStream.emit(OP_SETCURFIELD_ARRAY);
+      if (subType == TypeReqNone)
+         codeStream.emit(OP_POP_STK);
    }
    codeStream.emit((subType == TypeReqFloat) ? OP_LOADFIELD_FLT : OP_LOADFIELD_UINT);
    codeStream.emit(operand);
    codeStream.emit((subType == TypeReqFloat) ? OP_SAVEFIELD_FLT : OP_SAVEFIELD_UINT);
-   if (subType != type)
-      codeStream.emit(conversionOp(subType, type));
+   if (subType == TypeReqNone)
+      codeStream.emit(OP_POP_STK);
    return codeStream.tell();
 }
 
@@ -1572,18 +1488,7 @@ U32 ObjectDeclNode::compileSubObject(CodeStream& codeStream, U32 ip, bool root)
       TypeReq walkType = exprWalk->getPreferredType();
       if (walkType == TypeReqNone) walkType = TypeReqString;
       ip = exprWalk->compile(codeStream, ip, walkType);
-      switch (exprWalk->getPreferredType())
-      {
-      case TypeReqFloat:
-         codeStream.emit(OP_PUSH_FLT);
-         break;
-      case TypeReqUInt:
-         codeStream.emit(OP_PUSH_UINT);
-         break;
-      default:
-         codeStream.emit(OP_PUSH);
-         break;
-      }
+      codeStream.emit(OP_PUSH);
    }
    codeStream.emit(OP_CREATE_OBJECT);
    codeStream.emitSTE(parentObject);
@@ -1621,8 +1526,10 @@ U32 ObjectDeclNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
    codeStream.emit(OP_LOADIMMED_UINT);
    codeStream.emit(0);
    ip = compileSubObject(codeStream, ip, true);
-   if (type != TypeReqUInt)
-      codeStream.emit(conversionOp(TypeReqUInt, type));
+
+   if (type == TypeReqNone)
+      codeStream.emit(OP_POP_STK);
+
    return codeStream.tell();
 }
 
diff --git a/Engine/source/console/codeBlock.cpp b/Engine/source/console/codeBlock.cpp
index 47345aae1..9c1ddda17 100644
--- a/Engine/source/console/codeBlock.cpp
+++ b/Engine/source/console/codeBlock.cpp
@@ -520,7 +520,7 @@ bool CodeBlock::compile(const char *codeFileName, StringTableEntry fileName, con
       lastIp = 0;
    }
 
-   codeStream.emit(OP_RETURN);
+   codeStream.emit(OP_RETURN_VOID);
    codeStream.emitCodeStream(&codeSize, &code, &lineBreakPairs);
 
    lineBreakPairCount = codeStream.getNumLineBreaks();
@@ -640,11 +640,11 @@ ConsoleValue CodeBlock::compileExec(StringTableEntry fileName, const char *inStr
    globalFloats = getGlobalFloatTable().build();
    functionFloats = getFunctionFloatTable().build();
 
-   codeStream.emit(OP_RETURN);
+   codeStream.emit(OP_RETURN_VOID);
    codeStream.emitCodeStream(&codeSize, &code, &lineBreakPairs);
 
-   if (Con::getBoolVariable("dump"))
-   dumpInstructions(0, false);
+   //if (Con::getBoolVariable("dump"))
+   //dumpInstructions(0, false);
 
    consoleAllocReset();
 
@@ -726,7 +726,7 @@ void CodeBlock::dumpInstructions(U32 startIp, bool upToReturn)
          U32 regCount = code[ip + 9];
          endFuncIp = newIp;
 
-         Con::printf("%i: OP_FUNC_DECL name=%s nspace=%s package=%s hasbody=%i newip=%i argc=%i regCount=%i",
+         Con::printf("%i: OP_FUNC_DECL stk=+0 name=%s nspace=%s package=%s hasbody=%i newip=%i argc=%i regCount=%i",
             ip - 1, fnName, fnNamespace, fnPackage, hasBody, newIp, argc, regCount);
 
          // Skip args.
@@ -745,7 +745,7 @@ void CodeBlock::dumpInstructions(U32 startIp, bool upToReturn)
          U32  lineNumber = code[ip + 5];
          U32 failJump = code[ip + 6];
 
-         Con::printf("%i: OP_CREATE_OBJECT objParent=%s isDataBlock=%i isInternal=%i isSingleton=%i lineNumber=%i failJump=%i",
+         Con::printf("%i: OP_CREATE_OBJECT stk=+0 objParent=%s isDataBlock=%i isInternal=%i isSingleton=%i lineNumber=%i failJump=%i",
             ip - 1, objParent, isDataBlock, isInternal, isSingleton, lineNumber, failJump);
 
          ip += 7;
@@ -755,14 +755,16 @@ void CodeBlock::dumpInstructions(U32 startIp, bool upToReturn)
       case OP_ADD_OBJECT:
       {
          bool placeAtRoot = code[ip++];
-         Con::printf("%i: OP_ADD_OBJECT placeAtRoot=%i", ip - 1, placeAtRoot);
+         const char* stk = placeAtRoot ? "+1" : "0";
+         Con::printf("%i: OP_ADD_OBJECT stk=%s placeAtRoot=%i", ip - 1, stk, placeAtRoot);
          break;
       }
 
       case OP_END_OBJECT:
       {
          bool placeAtRoot = code[ip++];
-         Con::printf("%i: OP_END_OBJECT placeAtRoot=%i", ip - 1, placeAtRoot);
+         const char* stk = placeAtRoot ? "-1" : "0";
+         Con::printf("%i: OP_END_OBJECT stk=%s placeAtRoot=%i", ip - 1, stk, placeAtRoot);
          break;
       }
 
@@ -774,56 +776,56 @@ void CodeBlock::dumpInstructions(U32 startIp, bool upToReturn)
 
       case OP_JMPIFFNOT:
       {
-         Con::printf("%i: OP_JMPIFFNOT ip=%i", ip - 1, code[ip]);
+         Con::printf("%i: OP_JMPIFFNOT stk=-1 ip=%i", ip - 1, code[ip]);
          ++ip;
          break;
       }
 
       case OP_JMPIFNOT:
       {
-         Con::printf("%i: OP_JMPIFNOT ip=%i", ip - 1, code[ip]);
+         Con::printf("%i: OP_JMPIFNOT stk=-1 ip=%i", ip - 1, code[ip]);
          ++ip;
          break;
       }
 
       case OP_JMPIFF:
       {
-         Con::printf("%i: OP_JMPIFF ip=%i", ip - 1, code[ip]);
+         Con::printf("%i: OP_JMPIFF stk=-1 ip=%i", ip - 1, code[ip]);
          ++ip;
          break;
       }
 
       case OP_JMPIF:
       {
-         Con::printf("%i: OP_JMPIF ip=%i", ip - 1, code[ip]);
+         Con::printf("%i: OP_JMPIF stk=-1 ip=%i", ip - 1, code[ip]);
          ++ip;
          break;
       }
 
       case OP_JMPIFNOT_NP:
       {
-         Con::printf("%i: OP_JMPIFNOT_NP ip=%i", ip - 1, code[ip]);
+         Con::printf("%i: OP_JMPIFNOT_NP stk=-1 or 0 ip=%i", ip - 1, code[ip]);
          ++ip;
          break;
       }
 
       case OP_JMPIF_NP:
       {
-         Con::printf("%i: OP_JMPIF_NP ip=%i", ip - 1, code[ip]);
+         Con::printf("%i: OP_JMPIF_NP stk=-1 or 0 ip=%i", ip - 1, code[ip]);
          ++ip;
          break;
       }
 
       case OP_JMP:
       {
-         Con::printf("%i: OP_JMP ip=%i", ip - 1, code[ip]);
+         Con::printf("%i: OP_JMP stk=0 ip=%i", ip - 1, code[ip]);
          ++ip;
          break;
       }
 
-      case OP_RETURN:
+      case OP_RETURN_VOID:
       {
-         Con::printf("%i: OP_RETURN", ip - 1);
+         Con::printf("%i: OP_RETURN_VOID stk=0", ip - 1);
 
          if (upToReturn)
             return;
@@ -831,9 +833,9 @@ void CodeBlock::dumpInstructions(U32 startIp, bool upToReturn)
          break;
       }
 
-      case OP_RETURN_VOID:
+      case OP_RETURN:
       {
-         Con::printf("%i: OP_RETURNVOID", ip - 1);
+         Con::printf("%i: OP_RETURN stk=-1", ip - 1);
 
          if (upToReturn)
             return;
@@ -843,7 +845,7 @@ void CodeBlock::dumpInstructions(U32 startIp, bool upToReturn)
 
       case OP_RETURN_UINT:
       {
-         Con::printf("%i: OP_RETURNUINT", ip - 1);
+         Con::printf("%i: OP_RETURNUINT stk=-1", ip - 1);
 
          if (upToReturn)
             return;
@@ -853,7 +855,7 @@ void CodeBlock::dumpInstructions(U32 startIp, bool upToReturn)
 
       case OP_RETURN_FLT:
       {
-         Con::printf("%i: OP_RETURNFLT", ip - 1);
+         Con::printf("%i: OP_RETURNFLT stk=-1", ip - 1);
 
          if (upToReturn)
             return;
@@ -863,139 +865,139 @@ void CodeBlock::dumpInstructions(U32 startIp, bool upToReturn)
 
       case OP_CMPEQ:
       {
-         Con::printf("%i: OP_CMPEQ", ip - 1);
+         Con::printf("%i: OP_CMPEQ stk=-1", ip - 1);
          break;
       }
 
       case OP_CMPGR:
       {
-         Con::printf("%i: OP_CMPGR", ip - 1);
+         Con::printf("%i: OP_CMPGR stk=-1", ip - 1);
          break;
       }
 
       case OP_CMPGE:
       {
-         Con::printf("%i: OP_CMPGE", ip - 1);
+         Con::printf("%i: OP_CMPGE stk=-1", ip - 1);
          break;
       }
 
       case OP_CMPLT:
       {
-         Con::printf("%i: OP_CMPLT", ip - 1);
+         Con::printf("%i: OP_CMPLT stk=-1", ip - 1);
          break;
       }
 
       case OP_CMPLE:
       {
-         Con::printf("%i: OP_CMPLE", ip - 1);
+         Con::printf("%i: OP_CMPLE stk=-1", ip - 1);
          break;
       }
 
       case OP_CMPNE:
       {
-         Con::printf("%i: OP_CMPNE", ip - 1);
+         Con::printf("%i: OP_CMPNE stk=-1", ip - 1);
          break;
       }
 
       case OP_XOR:
       {
-         Con::printf("%i: OP_XOR", ip - 1);
+         Con::printf("%i: OP_XOR stk=-1", ip - 1);
          break;
       }
 
       case OP_MOD:
       {
-         Con::printf("%i: OP_MOD", ip - 1);
+         Con::printf("%i: OP_MOD stk=-1", ip - 1);
          break;
       }
 
       case OP_BITAND:
       {
-         Con::printf("%i: OP_BITAND", ip - 1);
+         Con::printf("%i: OP_BITAND stk=-1", ip - 1);
          break;
       }
 
       case OP_BITOR:
       {
-         Con::printf("%i: OP_BITOR", ip - 1);
+         Con::printf("%i: OP_BITOR stk=-1", ip - 1);
          break;
       }
 
       case OP_NOT:
       {
-         Con::printf("%i: OP_NOT", ip - 1);
+         Con::printf("%i: OP_NOT stk=0", ip - 1);
          break;
       }
 
       case OP_NOTF:
       {
-         Con::printf("%i: OP_NOTF", ip - 1);
+         Con::printf("%i: OP_NOTF stk=0", ip - 1);
          break;
       }
 
       case OP_ONESCOMPLEMENT:
       {
-         Con::printf("%i: OP_ONESCOMPLEMENT", ip - 1);
+         Con::printf("%i: OP_ONESCOMPLEMENT stk=0", ip - 1);
          break;
       }
 
       case OP_SHR:
       {
-         Con::printf("%i: OP_SHR", ip - 1);
+         Con::printf("%i: OP_SHR stk=-1", ip - 1);
          break;
       }
 
       case OP_SHL:
       {
-         Con::printf("%i: OP_SHL", ip - 1);
+         Con::printf("%i: OP_SHL stk=-1", ip - 1);
          break;
       }
 
       case OP_AND:
       {
-         Con::printf("%i: OP_AND", ip - 1);
+         Con::printf("%i: OP_AND stk=-1", ip - 1);
          break;
       }
 
       case OP_OR:
       {
-         Con::printf("%i: OP_OR", ip - 1);
+         Con::printf("%i: OP_OR stk=-1", ip - 1);
          break;
       }
 
       case OP_ADD:
       {
-         Con::printf("%i: OP_ADD", ip - 1);
+         Con::printf("%i: OP_ADD stk=-1", ip - 1);
          break;
       }
 
       case OP_SUB:
       {
-         Con::printf("%i: OP_SUB", ip - 1);
+         Con::printf("%i: OP_SUB stk=-1", ip - 1);
          break;
       }
 
       case OP_MUL:
       {
-         Con::printf("%i: OP_MUL", ip - 1);
+         Con::printf("%i: OP_MUL stk=-1", ip - 1);
          break;
       }
 
       case OP_DIV:
       {
-         Con::printf("%i: OP_DIV", ip - 1);
+         Con::printf("%i: OP_DIV stk=-1", ip - 1);
          break;
       }
 
       case OP_NEG:
       {
-         Con::printf("%i: OP_NEG", ip - 1);
+         Con::printf("%i: OP_NEG stk=0", ip - 1);
          break;
       }
 
       case OP_INC:
       {
-         Con::printf("%i: OP_INC reg=%i", ip - 1, code[ip]);
+         Con::printf("%i: OP_INC stk=0 reg=%i", ip - 1, code[ip]);
          ++ip;
          break;
       }
@@ -1004,7 +1006,7 @@ void CodeBlock::dumpInstructions(U32 startIp, bool upToReturn)
       {
          StringTableEntry var = CodeToSTE(code, ip);
 
-         Con::printf("%i: OP_SETCURVAR var=%s", ip - 1, var);
+         Con::printf("%i: OP_SETCURVAR stk=0 var=%s", ip - 1, var);
          ip += 2;
          break;
       }
@@ -1013,116 +1015,116 @@ void CodeBlock::dumpInstructions(U32 startIp, bool upToReturn)
       {
          StringTableEntry var = CodeToSTE(code, ip);
 
-         Con::printf("%i: OP_SETCURVAR_CREATE var=%s", ip - 1, var);
+         Con::printf("%i: OP_SETCURVAR_CREATE stk=0 var=%s", ip - 1, var);
          ip += 2;
          break;
       }
 
       case OP_SETCURVAR_ARRAY:
       {
-         Con::printf("%i: OP_SETCURVAR_ARRAY", ip - 1);
+         Con::printf("%i: OP_SETCURVAR_ARRAY stk=0", ip - 1);
          break;
       }
 
       case OP_SETCURVAR_ARRAY_CREATE:
       {
-         Con::printf("%i: OP_SETCURVAR_ARRAY_CREATE", ip - 1);
+         Con::printf("%i: OP_SETCURVAR_ARRAY_CREATE stk=0", ip - 1);
          break;
       }
 
       case OP_LOADVAR_UINT:
       {
-         Con::printf("%i: OP_LOADVAR_UINT", ip - 1);
+         Con::printf("%i: OP_LOADVAR_UINT stk=+1", ip - 1);
          break;
       }
 
       case OP_LOADVAR_FLT:
       {
-         Con::printf("%i: OP_LOADVAR_FLT", ip - 1);
+         Con::printf("%i: OP_LOADVAR_FLT stk=+1", ip - 1);
          break;
       }
 
       case OP_LOADVAR_STR:
       {
-         Con::printf("%i: OP_LOADVAR_STR", ip - 1);
+         Con::printf("%i: OP_LOADVAR_STR stk=+1", ip - 1);
          break;
       }
 
       case OP_SAVEVAR_UINT:
       {
-         Con::printf("%i: OP_SAVEVAR_UINT", ip - 1);
+         Con::printf("%i: OP_SAVEVAR_UINT stk=0", ip - 1);
          break;
       }
 
       case OP_SAVEVAR_FLT:
       {
-         Con::printf("%i: OP_SAVEVAR_FLT", ip - 1);
+         Con::printf("%i: OP_SAVEVAR_FLT stk=0", ip - 1);
          break;
       }
 
       case OP_SAVEVAR_STR:
       {
-         Con::printf("%i: OP_SAVEVAR_STR", ip - 1);
+         Con::printf("%i: OP_SAVEVAR_STR stk=0", ip - 1);
          break;
       }
 
       case OP_LOAD_LOCAL_VAR_UINT:
       {
-         Con::printf("%i: OP_LOAD_LOCAL_VAR_UINT reg=%i", ip - 1, code[ip]);
+         Con::printf("%i: OP_LOAD_LOCAL_VAR_UINT stk=+1 reg=%i", ip - 1, code[ip]);
          ++ip;
          break;
       }
 
       case OP_LOAD_LOCAL_VAR_FLT:
       {
-         Con::printf("%i: OP_LOAD_LOCAL_VAR_FLT reg=%i", ip - 1, code[ip]);
+         Con::printf("%i: OP_LOAD_LOCAL_VAR_FLT stk=+1 reg=%i", ip - 1, code[ip]);
          ++ip;
          break;
       }
 
       case OP_LOAD_LOCAL_VAR_STR:
       {
-         Con::printf("%i: OP_LOAD_LOCAL_VAR_STR reg=%i", ip - 1, code[ip]);
+         Con::printf("%i: OP_LOAD_LOCAL_VAR_STR stk=+1 reg=%i", ip - 1, code[ip]);
          ++ip;
          break;
       }
 
       case OP_SAVE_LOCAL_VAR_UINT:
       {
-         Con::printf("%i: OP_SAVE_LOCAL_VAR_UINT reg=%i", ip - 1, code[ip]);
+         Con::printf("%i: OP_SAVE_LOCAL_VAR_UINT stk=0 reg=%i", ip - 1, code[ip]);
          ++ip;
          break;
       }
 
       case OP_SAVE_LOCAL_VAR_FLT:
       {
-         Con::printf("%i: OP_SAVE_LOCAL_VAR_FLT reg=%i", ip - 1, code[ip]);
+         Con::printf("%i: OP_SAVE_LOCAL_VAR_FLT stk=0 reg=%i", ip - 1, code[ip]);
          ++ip;
          break;
       }
 
       case OP_SAVE_LOCAL_VAR_STR:
       {
-         Con::printf("%i: OP_SAVE_LOCAL_VAR_STR reg=%i", ip - 1, code[ip]);
+         Con::printf("%i: OP_SAVE_LOCAL_VAR_STR stk=0 reg=%i", ip - 1, code[ip]);
          ++ip;
          break;
       }
 
       case OP_SETCUROBJECT:
       {
-         Con::printf("%i: OP_SETCUROBJECT", ip - 1);
+         Con::printf("%i: OP_SETCUROBJECT stk=-1", ip - 1);
          break;
       }
 
       case OP_SETCUROBJECT_NEW:
       {
-         Con::printf("%i: OP_SETCUROBJECT_NEW", ip - 1);
+         Con::printf("%i: OP_SETCUROBJECT_NEW stk=0", ip - 1);
          break;
       }
 
       case OP_SETCUROBJECT_INTERNAL:
       {
-         Con::printf("%i: OP_SETCUROBJECT_INTERNAL", ip - 1);
+         Con::printf("%i: OP_SETCUROBJECT_INTERNAL stk=0", ip - 1);
          ++ip;
          break;
       }
@@ -1130,113 +1132,71 @@ void CodeBlock::dumpInstructions(U32 startIp, bool upToReturn)
       case OP_SETCURFIELD:
       {
          StringTableEntry curField = CodeToSTE(code, ip);
-         Con::printf("%i: OP_SETCURFIELD field=%s", ip - 1, curField);
+         Con::printf("%i: OP_SETCURFIELD stk=0 field=%s", ip - 1, curField);
          ip += 2;
          break;
       }
 
       case OP_SETCURFIELD_ARRAY:
       {
-         Con::printf("%i: OP_SETCURFIELD_ARRAY", ip - 1);
+         Con::printf("%i: OP_SETCURFIELD_ARRAY stk=0", ip - 1);
          break;
       }
 
       case OP_SETCURFIELD_TYPE:
       {
          U32 type = code[ip];
-         Con::printf("%i: OP_SETCURFIELD_TYPE type=%i", ip - 1, type);
+         Con::printf("%i: OP_SETCURFIELD_TYPE stk=0 type=%i", ip - 1, type);
          ++ip;
          break;
       }
 
       case OP_LOADFIELD_UINT:
       {
-         Con::printf("%i: OP_LOADFIELD_UINT", ip - 1);
+         Con::printf("%i: OP_LOADFIELD_UINT stk=+1", ip - 1);
          break;
       }
 
       case OP_LOADFIELD_FLT:
       {
-         Con::printf("%i: OP_LOADFIELD_FLT", ip - 1);
+         Con::printf("%i: OP_LOADFIELD_FLT stk=+1", ip - 1);
          break;
       }
 
       case OP_LOADFIELD_STR:
       {
-         Con::printf("%i: OP_LOADFIELD_STR", ip - 1);
+         Con::printf("%i: OP_LOADFIELD_STR stk=+1", ip - 1);
          break;
       }
 
       case OP_SAVEFIELD_UINT:
       {
-         Con::printf("%i: OP_SAVEFIELD_UINT", ip - 1);
+         Con::printf("%i: OP_SAVEFIELD_UINT stk=0", ip - 1);
          break;
       }
 
       case OP_SAVEFIELD_FLT:
       {
-         Con::printf("%i: OP_SAVEFIELD_FLT", ip - 1);
+         Con::printf("%i: OP_SAVEFIELD_FLT stk=0", ip - 1);
          break;
       }
 
       case OP_SAVEFIELD_STR:
       {
-         Con::printf("%i: OP_SAVEFIELD_STR", ip - 1);
+         Con::printf("%i: OP_SAVEFIELD_STR stk=0", ip - 1);
          break;
       }
 
-      case OP_STR_TO_UINT:
+      case OP_POP_STK:
       {
-         Con::printf("%i: OP_STR_TO_UINT", ip - 1);
-         break;
-      }
-
-      case OP_STR_TO_FLT:
-      {
-         Con::printf("%i: OP_STR_TO_FLT", ip - 1);
-         break;
-      }
-
-      case OP_STR_TO_NONE:
-      {
-         Con::printf("%i: OP_STR_TO_NONE", ip - 1);
-         break;
-      }
-
-      case OP_FLT_TO_UINT:
-      {
-         Con::printf("%i: OP_FLT_TO_UINT", ip - 1);
-         break;
-      }
-
-      case OP_FLT_TO_STR:
-      {
-         Con::printf("%i: OP_FLT_TO_STR", ip - 1);
-         break;
-      }
-
-      case OP_UINT_TO_FLT:
-      {
-         Con::printf("%i: OP_UINT_TO_FLT", ip - 1);
-         break;
-      }
-
-      case OP_UINT_TO_STR:
-      {
-         Con::printf("%i: OP_UINT_TO_STR", ip - 1);
-         break;
-      }
-
-      case OP_NUM_TO_NONE:
-      {
-         Con::printf("%i: OP_NUM_TO_NONE", ip - 1);
+         Con::printf("%i: OP_POP_STK stk=-1", ip - 1);
          break;
       }
 
       case OP_LOADIMMED_UINT:
       {
          U32 val = code[ip];
-         Con::printf("%i: OP_LOADIMMED_UINT val=%i", ip - 1, val);
+         Con::printf("%i: OP_LOADIMMED_UINT stk=+1 val=%i", ip - 1, val);
          ++ip;
          break;
       }
@@ -1244,7 +1204,7 @@ void CodeBlock::dumpInstructions(U32 startIp, bool upToReturn)
       case OP_LOADIMMED_FLT:
       {
          F64 val = (smInFunction ? functionFloats : globalFloats)[code[ip]];
-         Con::printf("%i: OP_LOADIMMED_FLT val=%f", ip - 1, val);
+         Con::printf("%i: OP_LOADIMMED_FLT stk=+1 val=%f", ip - 1, val);
          ++ip;
          break;
       }
@@ -1252,7 +1212,8 @@ void CodeBlock::dumpInstructions(U32 startIp, bool upToReturn)
       case OP_TAG_TO_STR:
       {
          const char* str = (smInFunction ? functionStrings : globalStrings) + code[ip];
-         Con::printf("%i: OP_TAG_TO_STR str=%s", ip - 1, str);
+         Con::printf("%i: OP_TAG_TO_STR stk=0 str=%s", ip - 1, str);
+         Con::printf("    OP_LOADIMMED_STR stk=+1 (fallthrough)");
          ++ip;
          break;
       }
@@ -1260,7 +1221,7 @@ void CodeBlock::dumpInstructions(U32 startIp, bool upToReturn)
       case OP_LOADIMMED_STR:
       {
          const char* str = (smInFunction ? functionStrings : globalStrings) + code[ip];
-         Con::printf("%i: OP_LOADIMMED_STR str=%s", ip - 1, str);
+         Con::printf("%i: OP_LOADIMMED_STR stk=+1 str=%s", ip - 1, str);
          ++ip;
          break;
       }
@@ -1268,7 +1229,7 @@ void CodeBlock::dumpInstructions(U32 startIp, bool upToReturn)
       case OP_DOCBLOCK_STR:
       {
          const char* str = (smInFunction ? functionStrings : globalStrings) + code[ip];
-         Con::printf("%i: OP_DOCBLOCK_STR str=%s", ip - 1, str);
+         Con::printf("%i: OP_DOCBLOCK_STR stk=0 str=%s", ip - 1, str);
          ++ip;
          break;
       }
@@ -1276,7 +1237,7 @@ void CodeBlock::dumpInstructions(U32 startIp, bool upToReturn)
       case OP_LOADIMMED_IDENT:
       {
          StringTableEntry str = CodeToSTE(code, ip);
-         Con::printf("%i: OP_LOADIMMED_IDENT str=%s", ip - 1, str);
+         Con::printf("%i: OP_LOADIMMED_IDENT stk=+1 str=%s", ip - 1, str);
          ip += 2;
          break;
       }
@@ -1296,77 +1257,48 @@ void CodeBlock::dumpInstructions(U32 startIp, bool upToReturn)
          case FuncCallExprNode::StaticCall:   callTypeName = "StaticCall"; break;
          }
 
-         Con::printf("%i: OP_CALLFUNC name=%s nspace=%s callType=%s", ip - 1, fnName, fnNamespace, callTypeName);
+         Con::printf("%i: OP_CALLFUNC stk=+1 name=%s nspace=%s callType=%s", ip - 1, fnName, fnNamespace, callTypeName);
 
          ip += 5;
          break;
       }
 
-      case OP_ADVANCE_STR:
-      {
-         Con::printf("%i: OP_ADVANCE_STR", ip - 1);
-         break;
-      }
-
       case OP_ADVANCE_STR_APPENDCHAR:
       {
          char ch = code[ip];
-         Con::printf("%i: OP_ADVANCE_STR_APPENDCHAR char=%c", ip - 1, ch);
+         Con::printf("%i: OP_ADVANCE_STR_APPENDCHAR stk=0 char=%c", ip - 1, ch);
          ++ip;
          break;
       }
 
-      case OP_ADVANCE_STR_COMMA:
-      {
-         Con::printf("%i: OP_ADVANCE_STR_COMMA", ip - 1);
-         break;
-      }
-
-      case OP_ADVANCE_STR_NUL:
-      {
-         Con::printf("%i: OP_ADVANCE_STR_NUL", ip - 1);
-         break;
-      }
-
       case OP_REWIND_STR:
       {
-         Con::printf("%i: OP_REWIND_STR", ip - 1);
+         Con::printf("%i: OP_REWIND_STR stk=0", ip - 1);
+         Con::printf("    OP_TERMINATE_REWIND_STR stk=-1 (fallthrough)");
          break;
       }
 
       case OP_TERMINATE_REWIND_STR:
       {
-         Con::printf("%i: OP_TERMINATE_REWIND_STR", ip - 1);
+         Con::printf("%i: OP_TERMINATE_REWIND_STR stk=-1", ip - 1);
          break;
       }
 
       case OP_COMPARE_STR:
       {
-         Con::printf("%i: OP_COMPARE_STR", ip - 1);
+         Con::printf("%i: OP_COMPARE_STR stk=-1", ip - 1);
          break;
       }
 
       case OP_PUSH:
       {
-         Con::printf("%i: OP_PUSH", ip - 1);
-         break;
-      }
-
-      case OP_PUSH_UINT:
-      {
-         Con::printf("%i: OP_PUSH_UINT", ip - 1);
-         break;
-      }
-
-      case OP_PUSH_FLT:
-      {
-         Con::printf("%i: OP_PUSH_FLT", ip - 1);
+         Con::printf("%i: OP_PUSH stk=-1", ip - 1);
          break;
       }
 
       case OP_PUSH_FRAME:
       {
-         Con::printf("%i: OP_PUSH_FRAME count=%i", ip - 1, code[ip]);
+         Con::printf("%i: OP_PUSH_FRAME stk=0 count=%i", ip - 1, code[ip]);
          ++ip;
          break;
       }
@@ -1374,14 +1306,14 @@ void CodeBlock::dumpInstructions(U32 startIp, bool upToReturn)
       case OP_ASSERT:
       {
          const char* message = (smInFunction ? functionStrings : globalStrings) + code[ip];
-         Con::printf("%i: OP_ASSERT message=%s", ip - 1, message);
+         Con::printf("%i: OP_ASSERT stk=-1 message=%s", ip - 1, message);
          ++ip;
          break;
       }
 
       case OP_BREAK:
       {
-         Con::printf("%i: OP_BREAK", ip - 1);
+         Con::printf("%i: OP_BREAK stk=0", ip - 1);
          break;
       }
 
@@ -1393,7 +1325,7 @@ void CodeBlock::dumpInstructions(U32 startIp, bool upToReturn)
             StringTableEntry varName = CodeToSTE(code, ip + 1);
             U32 failIp = code[ip + 3];
 
-            Con::printf("%i: OP_ITER_BEGIN varName=%s failIp=%i isGlobal=%s", ip - 1, varName, failIp, "true");
+            Con::printf("%i: OP_ITER_BEGIN stk=0 varName=%s failIp=%i isGlobal=%s", ip - 1, varName, failIp, "true");
 
             ip += 4;
          }
@@ -1402,7 +1334,7 @@ void CodeBlock::dumpInstructions(U32 startIp, bool upToReturn)
             S32 reg = code[ip + 1];
             U32 failIp = code[ip + 2];
 
-            Con::printf("%i: OP_ITER_BEGIN varRegister=%d failIp=%i isGlobal=%s", ip - 1, reg, failIp, "false");
+            Con::printf("%i: OP_ITER_BEGIN stk=0 varRegister=%d failIp=%i isGlobal=%s", ip - 1, reg, failIp, "false");
 
             ip += 3;
          }
@@ -1417,7 +1349,8 @@ void CodeBlock::dumpInstructions(U32 startIp, bool upToReturn)
             StringTableEntry varName = CodeToSTE(code, ip + 1);
             U32 failIp = code[ip + 3];
 
-            Con::printf("%i: OP_ITER_BEGIN_STR varName=%s failIp=%i isGlobal=%s", ip - 1, varName, failIp, "true");
+            Con::printf("%i: OP_ITER_BEGIN_STR stk=0 varName=%s failIp=%i isGlobal=%s", ip - 1, varName, failIp, "true");
+            Con::printf("    OP_ITER_BEGIN stk=0 (fallthrough)");
 
             ip += 4;
          }
@@ -1426,7 +1359,8 @@ void CodeBlock::dumpInstructions(U32 startIp, bool upToReturn)
             S32 reg = code[ip + 1];
             U32 failIp = code[ip + 2];
 
-            Con::printf("%i: OP_ITER_BEGIN_STR varRegister=%d failIp=%i isGlobal=%s", ip - 1, reg, failIp, "false");
+            Con::printf("%i: OP_ITER_BEGIN_STR stk=0 varRegister=%d failIp=%i isGlobal=%s", ip - 1, reg, failIp, "false");
+            Con::printf("    OP_ITER_BEGIN stk=0 (fallthrough)");
 
             ip += 3;
          }
@@ -1438,7 +1372,7 @@ void CodeBlock::dumpInstructions(U32 startIp, bool upToReturn)
       {
          U32 breakIp = code[ip];
 
-         Con::printf("%i: OP_ITER breakIp=%i", ip - 1, breakIp);
+         Con::printf("%i: OP_ITER stk=0 breakIp=%i", ip - 1, breakIp);
 
          ++ip;
          break;
@@ -1446,7 +1380,7 @@ void CodeBlock::dumpInstructions(U32 startIp, bool upToReturn)
 
       case OP_ITER_END:
       {
-         Con::printf("%i: OP_ITER_END", ip - 1);
+         Con::printf("%i: OP_ITER_END stk=-1", ip - 1);
          break;
       }
 
diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index 5a6785ed2..228dc85f3 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -109,18 +109,11 @@ ConsoleValueStack<4096> gCallStack;
 
 StringStack STR;
 
+IterStackRecord iterStack[MaxStackSize];
 U32 _ITER = 0;    ///< Stack pointer for iterStack.
 
-IterStackRecord iterStack[MaxStackSize];
-
-union StackValue
-{
-   F64 f;
-   S64 i;
-};
-
-StackValue numStack[MaxStackSize];
-U32 _STK = 0;
+ConsoleValue stack[MaxStackSize];
+S32 _STK = 0;
 
 char curFieldArray[256];
 char prevFieldArray[256];
@@ -166,7 +159,7 @@ static void getFieldComponent(SimObject* object, StringTableEntry field, const c
    // Otherwise, grab from the string stack. The value coming in will always
    // be a string because that is how multicomponent variables are handled.
    else
-      prevVal = STR.getStringValue();
+      prevVal = stack[_STK].getString();
 
    // Make sure we got a value.
    if (prevVal && *prevVal)
@@ -214,7 +207,7 @@ static void setFieldComponent(SimObject* object, StringTableEntry field, const c
 {
    // Copy the current string value
    char strValue[1024];
-   dStrncpy(strValue, STR.getStringValue(), 1024);
+   dStrncpy(strValue, stack[_STK].getString(), 1024);
 
    char val[1024] = "";
    const char* prevVal = NULL;
@@ -437,7 +430,7 @@ U32 gExecCount = 0;
 ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNamespace, U32 argc, ConsoleValue* argv, bool noCalls, StringTableEntry packageName, S32 setFrame)
 {
 #ifdef TORQUE_DEBUG
-   U32 stackStart = STR.mStartStackSize;
+   U32 stackStart = _STK;
    gExecCount++;
 #endif
 
@@ -452,7 +445,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
    F64* curFloatTable;
    char* curStringTable;
    S32 curStringTableLen = 0; //clint to ensure we dont overwrite it
-   STR.clearFunctionOffset();
+
    StringTableEntry thisFunctionName = NULL;
    bool popFrame = false;
    if (argv)
@@ -949,7 +942,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          }
 
          // What group will we be added to, if any?
-         U32 groupAddId = (U32)numStack[_STK].i;
+         U32 groupAddId = (U32)stack[_STK].getInt();
          SimGroup* grp = NULL;
          SimSet* set = NULL;
 
@@ -994,9 +987,9 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          // id, if one was given, otherwise getting pushed)
          S32 id = currentNewObject->getId();
          if (placeAtRoot)
-            numStack[_STK].i = id;
+            stack[_STK].setInt(id);
          else
-            numStack[++_STK].i = id;
+            stack[++_STK].setInt(id);
 
          break;
       }
@@ -1024,7 +1017,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
       }
 
       case OP_JMPIFFNOT:
-         if (numStack[_STK--].f)
+         if (stack[_STK--].getFloat())
          {
             ip++;
             break;
@@ -1032,7 +1025,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          ip = code[ip];
          break;
       case OP_JMPIFNOT:
-         if (numStack[_STK--].i)
+         if (stack[_STK--].getInt())
          {
             ip++;
             break;
@@ -1040,7 +1033,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          ip = code[ip];
          break;
       case OP_JMPIFF:
-         if (!numStack[_STK--].f)
+         if (!stack[_STK--].getFloat())
          {
             ip++;
             break;
@@ -1048,7 +1041,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          ip = code[ip];
          break;
       case OP_JMPIF:
-         if (!numStack[_STK--].i)
+         if (!stack[_STK--].getFloat())
          {
             ip++;
             break;
@@ -1056,7 +1049,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          ip = code[ip];
          break;
       case OP_JMPIFNOT_NP:
-         if (numStack[_STK].i)
+         if (stack[_STK].getInt())
          {
             _STK--;
             ip++;
@@ -1065,7 +1058,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          ip = code[ip];
          break;
       case OP_JMPIF_NP:
-         if (!numStack[_STK].i)
+         if (!stack[_STK].getInt())
          {
             _STK--;
             ip++;
@@ -1077,10 +1070,24 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          ip = code[ip];
          break;
 
-         // This fixes a bug when not explicitly returning a value.
       case OP_RETURN_VOID:
-         STR.setStringValue("");
-         // We're falling thru here on purpose.
+      {
+         if (iterDepth > 0)
+         {
+            // Clear iterator state.
+            while (iterDepth > 0)
+            {
+               iterStack[--_ITER].mIsStringIter = false;
+               --iterDepth;
+            }
+
+            _STK--; // this is a pop from foreach()
+         }
+
+         returnValue.setEmptyString();
+
+         goto execFinished;
+      }
 
       case OP_RETURN:
       {
@@ -1093,12 +1100,16 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
                --iterDepth;
             }
 
-            const char* retVal = STR.getStringValue();
-            STR.rewind();
-            STR.setStringValue(retVal); // Not nice but works.
+            
+            const char* retVal = stack[_STK].getString();
+            _STK--;
+            _STK--;
+            stack[_STK + 1].setString(retVal);
+            _STK++; // Not nice but works.
          }
 
-         returnValue.setString(STR.getStringValue(), STR.mLen);
+         returnValue.setString(stack[_STK].getString());
+         _STK--;
 
          goto execFinished;
       }
@@ -1115,7 +1126,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
 
          }
 
-         returnValue.setFloat(numStack[_STK].f);
+         returnValue.setFloat(stack[_STK].getFloat());
          _STK--;
 
          goto execFinished;
@@ -1132,116 +1143,118 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
             }
          }
 
-         returnValue.setInt(numStack[_STK].i);
+         returnValue.setInt(stack[_STK].getInt());
          _STK--;
 
          goto execFinished;
 
       case OP_CMPEQ:
-         numStack[_STK - 1].i = bool(numStack[_STK].f == numStack[_STK - 1].f);
+         stack[_STK - 1].setInt(stack[_STK].getFloat() == stack[_STK - 1].getFloat());
          _STK--;
          break;
 
       case OP_CMPGR:
-         numStack[_STK - 1].i = bool(numStack[_STK].f > numStack[_STK - 1].f);
+         stack[_STK - 1].setInt(stack[_STK].getFloat() > stack[_STK - 1].getFloat());
          _STK--;
          break;
 
       case OP_CMPGE:
-         numStack[_STK - 1].i = bool(numStack[_STK].f >= numStack[_STK - 1].f);
+         stack[_STK - 1].setInt(stack[_STK].getFloat() >= stack[_STK - 1].getFloat());
          _STK--;
          break;
 
       case OP_CMPLT:
-         numStack[_STK - 1].i = bool(numStack[_STK].f < numStack[_STK - 1].f);
+         stack[_STK - 1].setInt(stack[_STK].getFloat() < stack[_STK - 1].getFloat());
          _STK--;
          break;
 
       case OP_CMPLE:
-         numStack[_STK - 1].i = bool(numStack[_STK].f <= numStack[_STK - 1].f);
+         stack[_STK - 1].setInt(stack[_STK].getFloat() <= stack[_STK - 1].getFloat());
          _STK--;
          break;
 
       case OP_CMPNE:
-         numStack[_STK - 1].i = bool(numStack[_STK].f != numStack[_STK - 1].f);
+         stack[_STK - 1].setInt(stack[_STK].getFloat() != stack[_STK - 1].getFloat());
          _STK--;
          break;
 
       case OP_XOR:
-         numStack[_STK - 1].i = numStack[_STK].i ^ numStack[_STK - 1].i;
+         stack[_STK - 1].setInt(stack[_STK].getInt() ^ stack[_STK - 1].getInt());
          _STK--;
          break;
 
       case OP_MOD:
-         if (numStack[_STK - 1].i != 0)
-            numStack[_STK - 1].i = numStack[_STK].i % numStack[_STK - 1].i;
+         if (stack[_STK - 1].getInt() != 0)
+            stack[_STK - 1].setInt(stack[_STK].getInt() % stack[_STK - 1].getInt());
          else
-            numStack[_STK - 1].i = 0;
+            stack[_STK - 1].setInt(0);
          _STK--;
          break;
 
       case OP_BITAND:
-         numStack[_STK - 1].i = numStack[_STK].i & numStack[_STK - 1].i;
+         stack[_STK - 1].setInt(stack[_STK].getInt() & stack[_STK - 1].getInt());
          _STK--;
          break;
 
       case OP_BITOR:
-         numStack[_STK - 1].i = numStack[_STK].i | numStack[_STK - 1].i;
+         stack[_STK - 1].setInt(stack[_STK].getInt() | stack[_STK - 1].getInt());
          _STK--;
          break;
 
       case OP_NOT:
-         numStack[_STK].i = !numStack[_STK].i;
+         stack[_STK].setInt(!stack[_STK].getInt());
          break;
 
       case OP_NOTF:
-         numStack[_STK].i = !numStack[_STK].f;
+         stack[_STK].setInt(!stack[_STK].getFloat());
          break;
 
       case OP_ONESCOMPLEMENT:
-         numStack[_STK].i = ~numStack[_STK].i;
+         stack[_STK].setInt(~stack[_STK].getInt());
          break;
 
       case OP_SHR:
-         numStack[_STK - 1].i = numStack[_STK].i >> numStack[_STK - 1].i;
+         stack[_STK - 1].setInt(stack[_STK].getInt() >> stack[_STK - 1].getInt());
          _STK--;
          break;
 
       case OP_SHL:
-         numStack[_STK - 1].i = numStack[_STK].i << numStack[_STK - 1].i;
+         stack[_STK - 1].setInt(stack[_STK].getInt() << stack[_STK - 1].getInt());
          _STK--;
          break;
 
       case OP_AND:
-         numStack[_STK - 1].i = numStack[_STK].i && numStack[_STK - 1].i;
+         stack[_STK - 1].setInt(stack[_STK].getInt() && stack[_STK - 1].getInt());
          _STK--;
          break;
 
       case OP_OR:
-         numStack[_STK - 1].i = numStack[_STK].i || numStack[_STK - 1].i;
+         stack[_STK - 1].setInt(stack[_STK].getInt() || stack[_STK - 1].getInt());
          _STK--;
          break;
 
       case OP_ADD:
-         numStack[_STK - 1].f = numStack[_STK].f + numStack[_STK - 1].f;
+         stack[_STK - 1].setFloat(stack[_STK].getFloat() + stack[_STK - 1].getFloat());
          _STK--;
          break;
 
       case OP_SUB:
-         numStack[_STK - 1].f = numStack[_STK].f - numStack[_STK - 1].f;
+         stack[_STK - 1].setFloat(stack[_STK].getFloat() - stack[_STK - 1].getFloat());
          _STK--;
          break;
 
       case OP_MUL:
-         numStack[_STK - 1].f = numStack[_STK].f * numStack[_STK - 1].f;
+         stack[_STK - 1].setFloat(stack[_STK].getFloat() * stack[_STK - 1].getFloat());
          _STK--;
          break;
+
       case OP_DIV:
-         numStack[_STK - 1].f = numStack[_STK].f / numStack[_STK - 1].f;
+         stack[_STK - 1].setFloat(stack[_STK].getFloat() / stack[_STK - 1].getFloat());
          _STK--;
          break;
+
       case OP_NEG:
-         numStack[_STK].f = -numStack[_STK].f;
+         stack[_STK].setFloat(-stack[_STK].getFloat());
          break;
 
       case OP_INC:
@@ -1286,7 +1299,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          break;
 
       case OP_SETCURVAR_ARRAY:
-         var = STR.getSTValue();
+         var = StringTable->insert(stack[_STK].getString());
 
          // See OP_SETCURVAR
          prevField = NULL;
@@ -1301,7 +1314,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          break;
 
       case OP_SETCURVAR_ARRAY_CREATE:
-         var = STR.getSTValue();
+         var = StringTable->insert(stack[_STK].getString());
 
          // See OP_SETCURVAR
          prevField = NULL;
@@ -1316,69 +1329,72 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          break;
 
       case OP_LOADVAR_UINT:
-         numStack[_STK + 1].i = gEvalState.getIntVariable();
+         stack[_STK + 1].setInt(gEvalState.getIntVariable());
          _STK++;
          break;
 
       case OP_LOADVAR_FLT:
-         numStack[_STK + 1].f = gEvalState.getFloatVariable();
+         stack[_STK + 1].setFloat(gEvalState.getFloatVariable());
          _STK++;
          break;
 
       case OP_LOADVAR_STR:
-         val = gEvalState.getStringVariable();
-         STR.setStringValue(val);
+         stack[_STK + 1].setString(gEvalState.getStringVariable());
+         _STK++;
          break;
 
       case OP_SAVEVAR_UINT:
-         gEvalState.setIntVariable(numStack[_STK].i);
+         gEvalState.setIntVariable(stack[_STK].getInt());
          break;
 
       case OP_SAVEVAR_FLT:
-         gEvalState.setFloatVariable(numStack[_STK].f);
+         gEvalState.setFloatVariable(stack[_STK].getFloat());
          break;
 
       case OP_SAVEVAR_STR:
-         gEvalState.setStringVariable(STR.getStringValue());
+         gEvalState.setStringVariable(stack[_STK].getString());
          break;
 
       case OP_LOAD_LOCAL_VAR_UINT:
          reg = code[ip++];
-         numStack[_STK + 1].i = gEvalState.getLocalIntVariable(reg);
+         stack[_STK + 1].setInt(gEvalState.getLocalIntVariable(reg));
          _STK++;
          break;
 
       case OP_LOAD_LOCAL_VAR_FLT:
          reg = code[ip++];
-         numStack[_STK + 1].f = gEvalState.getLocalFloatVariable(reg);
+         stack[_STK + 1].setFloat(gEvalState.getLocalFloatVariable(reg));
          _STK++;
          break;
 
       case OP_LOAD_LOCAL_VAR_STR:
          reg = code[ip++];
          val = gEvalState.getLocalStringVariable(reg);
-         STR.setStringValue(val);
+         stack[_STK + 1].setString(val);
+         _STK++;
          break;
 
       case OP_SAVE_LOCAL_VAR_UINT:
          reg = code[ip++];
-         gEvalState.setLocalIntVariable(reg, numStack[_STK].i);
+         gEvalState.setLocalIntVariable(reg, stack[_STK].getInt());
          break;
 
       case OP_SAVE_LOCAL_VAR_FLT:
          reg = code[ip++];
-         gEvalState.setLocalFloatVariable(reg, numStack[_STK].f);
+         gEvalState.setLocalFloatVariable(reg, stack[_STK].getFloat());
          break;
 
       case OP_SAVE_LOCAL_VAR_STR:
          reg = code[ip++];
-         gEvalState.setLocalStringVariable(reg, STR.getStringValue(), (S32)STR.mLen);
+         val = stack[_STK].getString();
+         gEvalState.setLocalStringVariable(reg, val, (S32)dStrlen(val));
          break;
 
       case OP_SETCUROBJECT:
          // Save the previous object for parsing vector fields.
          prevObject = curObject;
-         val = STR.getStringValue();
+         val = stack[_STK].getString();
+         _STK--;
 
          // Sim::findObject will sometimes find valid objects from
          // multi-component strings. This makes sure that doesn't
@@ -1401,16 +1417,15 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
             SimGroup* group = dynamic_cast<SimGroup*>(curObject);
             if (group)
             {
-               StringTableEntry intName = StringTable->insert(STR.getStringValue());
+               StringTableEntry intName = StringTable->insert(stack[_STK].getString());
                bool recurse = code[ip - 1];
                SimObject* obj = group->findObjectByInternalName(intName, recurse);
-               numStack[_STK + 1].i = obj ? obj->getId() : 0;
-               _STK++;
+               stack[_STK].setInt(obj ? obj->getId() : 0);
             }
             else
             {
                Con::errorf(ConsoleLogEntry::Script, "%s: Attempt to use -> on non-group %s of class %s.", getFileLine(ip - 2), curObject->getName(), curObject->getClassName());
-               numStack[_STK].i = 0;
+               stack[_STK].setInt(0);
             }
          }
          break;
@@ -1429,7 +1444,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          break;
 
       case OP_SETCURFIELD_ARRAY:
-         dStrcpy(curFieldArray, STR.getStringValue(), 256);
+         dStrcpy(curFieldArray, stack[_STK].getString(), 256);
          break;
 
       case OP_SETCURFIELD_TYPE:
@@ -1440,7 +1455,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
 
       case OP_LOADFIELD_UINT:
          if (curObject)
-            numStack[_STK + 1].i = dAtol(curObject->getDataField(curField, curFieldArray));
+            stack[_STK + 1].setInt(dAtol(curObject->getDataField(curField, curFieldArray)));
          else
          {
             // The field is not being retrieved from an object. Maybe it's
@@ -1448,14 +1463,14 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
             char buff[FieldBufferSizeNumeric];
             memset(buff, 0, sizeof(buff));
             getFieldComponent(prevObject, prevField, prevFieldArray, curField, buff);
-            numStack[_STK + 1].i = dAtol(buff);
+            stack[_STK + 1].setInt(dAtol(buff));
          }
          _STK++;
          break;
 
       case OP_LOADFIELD_FLT:
          if (curObject)
-            numStack[_STK + 1].f = dAtod(curObject->getDataField(curField, curFieldArray));
+            stack[_STK + 1].setFloat(dAtod(curObject->getDataField(curField, curFieldArray)));
          else
          {
             // The field is not being retrieved from an object. Maybe it's
@@ -1463,7 +1478,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
             char buff[FieldBufferSizeNumeric];
             memset(buff, 0, sizeof(buff));
             getFieldComponent(prevObject, prevField, prevFieldArray, curField, buff);
-            numStack[_STK + 1].f = dAtod(buff);
+            stack[_STK + 1].setFloat(dAtod(buff));
          }
          _STK++;
          break;
@@ -1472,7 +1487,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          if (curObject)
          {
             val = curObject->getDataField(curField, curFieldArray);
-            STR.setStringValue(val);
+            stack[_STK + 1].setString(val);
          }
          else
          {
@@ -1481,15 +1496,14 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
             char buff[FieldBufferSizeString];
             memset(buff, 0, sizeof(buff));
             getFieldComponent(prevObject, prevField, prevFieldArray, curField, buff);
-            STR.setStringValue(buff);
+            stack[_STK + 1].setString(buff);
          }
-
+         _STK++;
          break;
 
       case OP_SAVEFIELD_UINT:
-         STR.setIntValue(numStack[_STK].i);
          if (curObject)
-            curObject->setDataField(curField, curFieldArray, STR.getStringValue());
+            curObject->setDataField(curField, curFieldArray, stack[_STK].getString());
          else
          {
             // The field is not being set on an object. Maybe it's
@@ -1500,9 +1514,8 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          break;
 
       case OP_SAVEFIELD_FLT:
-         STR.setFloatValue(numStack[_STK].f);
          if (curObject)
-            curObject->setDataField(curField, curFieldArray, STR.getStringValue());
+            curObject->setDataField(curField, curFieldArray, stack[_STK].getString());
          else
          {
             // The field is not being set on an object. Maybe it's
@@ -1514,7 +1527,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
 
       case OP_SAVEFIELD_STR:
          if (curObject)
-            curObject->setDataField(curField, curFieldArray, STR.getStringValue());
+            curObject->setDataField(curField, curFieldArray, stack[_STK].getString());
          else
          {
             // The field is not being set on an object. Maybe it's
@@ -1524,51 +1537,20 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          }
          break;
 
-      case OP_STR_TO_UINT:
-         numStack[_STK + 1].i = STR.getIntValue();
-         _STK++;
-         break;
-
-      case OP_STR_TO_FLT:
-         numStack[_STK + 1].f = STR.getFloatValue();
-         _STK++;
-         break;
-
-      case OP_STR_TO_NONE:
-         // This exists simply to deal with certain typecast situations.
-         break;
-
-      case OP_FLT_TO_UINT:
-         numStack[_STK].i = (S64)numStack[_STK].f;
-         break;
-
-      case OP_FLT_TO_STR:
-         STR.setFloatValue(numStack[_STK].f);
-         _STK--;
-         break;
-
-      case OP_UINT_TO_FLT:
-         numStack[_STK].f = (F64)numStack[_STK].i;
-         break;
-
-      case OP_UINT_TO_STR:
-         STR.setIntValue(numStack[_STK].i);
-         _STK--;
-         break;
-
-      case OP_NUM_TO_NONE:
+      case OP_POP_STK:
          _STK--;
          break;
 
       case OP_LOADIMMED_UINT:
-         numStack[_STK + 1].i = code[ip++];
+         stack[_STK + 1].setInt(code[ip++]);
          _STK++;
          break;
 
       case OP_LOADIMMED_FLT:
-         numStack[_STK + 1].f = curFloatTable[code[ip++]];
+         stack[_STK + 1].setFloat(curFloatTable[code[ip++]]);
          _STK++;
          break;
+
       case OP_TAG_TO_STR:
          code[ip - 1] = OP_LOADIMMED_STR;
          // it's possible the string has already been converted
@@ -1578,8 +1560,11 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
             dSprintf(curStringTable + code[ip] + 1, 7, "%d", id);
             *(curStringTable + code[ip]) = StringTagPrefixByte;
          }
+         TORQUE_CASE_FALLTHROUGH;
+
       case OP_LOADIMMED_STR:
-         STR.setStringValue(curStringTable + code[ip++]);
+         stack[_STK + 1].setString(curStringTable + code[ip++]);
+         _STK ++;
          break;
 
       case OP_DOCBLOCK_STR:
@@ -1614,7 +1599,8 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
       break;
 
       case OP_LOADIMMED_IDENT:
-         STR.setStringValue(CodeToSTE(code, ip));
+         stack[_STK + 1].setString(CodeToSTE(code, ip));
+         _STK++;
          ip += 2;
          break;
 
@@ -1652,8 +1638,10 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
                Con::warnf(ConsoleLogEntry::General,
                   "%s: Unable to find function %s",
                   getFileLine(ip - 4), fnName);
-               //STR.popFrame();
+
                gCallStack.popFrame();
+               stack[_STK + 1].setEmptyString();
+               _STK++;
                break;
             }
          }
@@ -1668,8 +1656,10 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
                   "%s: Unable to find function %s%s%s",
                   getFileLine(ip - 4), fnNamespace ? fnNamespace : "",
                   fnNamespace ? "::" : "", fnName);
-               //STR.popFrame();
+
                gCallStack.popFrame();
+               stack[_STK + 1].setEmptyString();
+               _STK++;
                break;
             }
          }
@@ -1702,9 +1692,10 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
                   simObjectLookupValue.getString(),
                   fnName
                );
-               //STR.popFrame();
+
                gCallStack.popFrame();
-               STR.setStringValue("");
+               stack[_STK + 1].setEmptyString();
+               _STK++;
                break;
             }
 
@@ -1744,8 +1735,8 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
                }
             }
             gCallStack.popFrame();
-            STR.setStringValue("");
-            STR.setStringValue("");
+            stack[_STK + 1].setEmptyString();
+            _STK++;
             break;
          }
          if (nsEntry->mType == Namespace::Entry::ConsoleFunctionType)
@@ -1754,10 +1745,11 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
             {
                // TODO: not make this strings only for returns.
                ConsoleValue returnFromFn = nsEntry->mCode->exec(nsEntry->mFunctionOffset, fnName, nsEntry->mNamespace, callArgc, callArgv, false, nsEntry->mPackage);
-               STR.setStringValue(returnFromFn.getString());
+               stack[_STK + 1] = std::move(returnFromFn);
             }
             else // no body
-               STR.setStringValue("");
+               stack[_STK + 1].setEmptyString();
+            _STK++;
 
             gCallStack.popFrame();
          }
@@ -1769,7 +1761,8 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
                Con::warnf(ConsoleLogEntry::Script, "%s: %s::%s - wrong number of arguments.", getFileLine(ip - 4), nsName, fnName);
                Con::warnf(ConsoleLogEntry::Script, "%s: usage: %s", getFileLine(ip - 4), nsEntry->mUsage);
                gCallStack.popFrame();
-               STR.setStringValue("");
+               stack[_STK + 1].setEmptyString();
+               _STK++;
             }
             else
             {
@@ -1777,87 +1770,73 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
                {
                case Namespace::Entry::StringCallbackType:
                {
-                  const char* ret = nsEntry->cb.mStringCallbackFunc(gEvalState.thisObject, callArgc, callArgv);
+                  const char* result = nsEntry->cb.mStringCallbackFunc(gEvalState.thisObject, callArgc, callArgv);
                   gCallStack.popFrame();
-                  if (ret != STR.getStringValue())
-                     STR.setStringValue(ret);
-                  else
-                     STR.setLen(dStrlen(ret));
+                  stack[_STK + 1].setString(result);
+                  _STK++;
                   break;
                }
                case Namespace::Entry::IntCallbackType:
                {
                   S64 result = nsEntry->cb.mIntCallbackFunc(gEvalState.thisObject, callArgc, callArgv);
                   gCallStack.popFrame();
-                  if (code[ip] == OP_STR_TO_UINT)
+
+                  if (code[ip] == OP_POP_STK)
                   {
                      ip++;
-                     numStack[++_STK].i = result;
                      break;
                   }
-                  else if (code[ip] == OP_STR_TO_FLT)
-                  {
-                     ip++;
-                     numStack[++_STK].f = result;
-                     break;
-                  }
-                  else if (code[ip] == OP_STR_TO_NONE)
-                     ip++;
-                  else
-                     STR.setIntValue(result);
+
+                  stack[_STK + 1].setInt(result);
+                  _STK++;
                   break;
                }
                case Namespace::Entry::FloatCallbackType:
                {
                   F64 result = nsEntry->cb.mFloatCallbackFunc(gEvalState.thisObject, callArgc, callArgv);
                   gCallStack.popFrame();
-                  if (code[ip] == OP_STR_TO_UINT)
+
+                  if (code[ip] == OP_POP_STK)
                   {
                      ip++;
-                     numStack[++_STK].i = (S64)result;
                      break;
                   }
-                  else if (code[ip] == OP_STR_TO_FLT)
-                  {
-                     ip++;
-                     numStack[++_STK].f = result;
-                     break;
-                  }
-                  else if (code[ip] == OP_STR_TO_NONE)
-                     ip++;
-                  else
-                     STR.setFloatValue(result);
+
+                  stack[_STK + 1].setInt(result);
+                  _STK++;
                   break;
                }
                case Namespace::Entry::VoidCallbackType:
                {
                   nsEntry->cb.mVoidCallbackFunc(gEvalState.thisObject, callArgc, callArgv);
-                  if (code[ip] != OP_STR_TO_NONE)
-                     Con::warnf(ConsoleLogEntry::General, "%s: Call to %s in %s uses result of void function call.", getFileLine(ip - 4), fnName, functionName);
                   gCallStack.popFrame();
-                  STR.setStringValue("");
+
+                  if (code[ip] == OP_POP_STK)
+                  {
+                     ip++;
+                     break;
+                  }
+
+                  Con::warnf(ConsoleLogEntry::General, "%s: Call to %s in %s uses result of void function call.", getFileLine(ip - 4), fnName, functionName);
+                  stack[_STK + 1].setEmptyString();
+                  _STK++;
+
                   break;
                }
                case Namespace::Entry::BoolCallbackType:
                {
                   bool result = nsEntry->cb.mBoolCallbackFunc(gEvalState.thisObject, callArgc, callArgv);
                   gCallStack.popFrame();
-                  if (code[ip] == OP_STR_TO_UINT)
+
+                  if (code[ip] == OP_POP_STK)
                   {
                      ip++;
-                     numStack[++_STK].i = result;
                      break;
                   }
-                  else if (code[ip] == OP_STR_TO_FLT)
-                  {
-                     ip++;
-                     numStack[++_STK].f = result;
-                     break;
-                  }
-                  else if (code[ip] == OP_STR_TO_NONE)
-                     ip++;
-                  else
-                     STR.setIntValue(result);
+
+                  stack[_STK + 1].setBool(result);
+                  _STK++;
+
                   break;
                }
                }
@@ -1868,43 +1847,45 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
             gEvalState.thisObject = saveObject;
          break;
       }
-      case OP_ADVANCE_STR:
-         STR.advance();
-         break;
+
       case OP_ADVANCE_STR_APPENDCHAR:
-         STR.advanceChar(code[ip++]);
-         break;
+      {
+         // TODO: Create a better way to handle string concatination without
+         // heap allocating every time.
 
-      case OP_ADVANCE_STR_COMMA:
-         STR.advanceChar('_');
-         break;
+         val = stack[_STK].getString();
+         dsize_t len = dStrlen(val) + 2;
+
+         char buff[2];
+         buff[0] = (char)code[ip++];
+         buff[1] = '\0';
+
+         char* concat = new char[len];
+         dMemset(concat, 0, len);
+         dStrcat(concat, val, len);
+         dStrcat(concat, buff, len);
+
+         stack[_STK].setString(concat);
+
+         delete[] concat;
 
-      case OP_ADVANCE_STR_NUL:
-         STR.advanceChar(0);
          break;
+      }
 
       case OP_REWIND_STR:
-         STR.rewind();
-         break;
-
+         TORQUE_CASE_FALLTHROUGH;
       case OP_TERMINATE_REWIND_STR:
-         STR.rewindTerminate();
+         stack[_STK - 1].setString((String(stack[_STK - 1] + String(stack[_STK]))));
+         _STK--;
          break;
 
       case OP_COMPARE_STR:
-         numStack[++_STK].i = STR.compare();
+         stack[_STK - 1].setBool(!dStricmp(stack[_STK].getString(), stack[_STK - 1].getString()));
+         _STK--;
          break;
 
       case OP_PUSH:
-         gCallStack.pushString(STR.getStringValue(), STR.mLen);
-         break;
-
-      case OP_PUSH_UINT:
-         gCallStack.pushInt((U32)numStack[_STK--].i);
-         break;
-
-      case OP_PUSH_FLT:
-         gCallStack.pushFloat(numStack[_STK--].f);
+         gCallStack.push(std::move(stack[_STK--]));
          break;
 
       case OP_PUSH_FRAME:
@@ -1913,7 +1894,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
 
       case OP_ASSERT:
       {
-         if (!numStack[_STK--].i)
+         if (!stack[_STK--].getBool())
          {
             const char* message = curStringTable + code[ip];
 
@@ -1957,7 +1938,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
       case OP_ITER_BEGIN_STR:
       {
          iterStack[_ITER].mIsStringIter = true;
-         /* fallthrough */
+         TORQUE_CASE_FALLTHROUGH;
       }
 
       case OP_ITER_BEGIN:
@@ -1981,7 +1962,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
 
          if (iter.mIsStringIter)
          {
-            iter.mData.mStr.mString = STR.getStringValue();
+            iter.mData.mStr.mString = stack[_STK].getString();
             iter.mData.mStr.mIndex = 0;
          }
          else
@@ -1989,9 +1970,9 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
             // Look up the object.
 
             SimSet* set;
-            if (!Sim::findObject(STR.getStringValue(), set))
+            if (!Sim::findObject(stack[_STK].getString(), set))
             {
-               Con::errorf(ConsoleLogEntry::General, "No SimSet object '%s'", STR.getStringValue());
+               Con::errorf(ConsoleLogEntry::General, "No SimSet object '%s'", stack[_STK].getString());
                Con::errorf(ConsoleLogEntry::General, "Did you mean to use 'foreach$' instead of 'foreach'?");
                ip = failIp;
                continue;
@@ -2006,8 +1987,6 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          _ITER++;
          iterDepth++;
 
-         STR.push();
-
          ip += isGlobal ? 4 : 3;
          break;
       }
@@ -2096,16 +2075,17 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          --_ITER;
          --iterDepth;
 
-         STR.rewind();
+         _STK--;
 
          iterStack[_ITER].mIsStringIter = false;
          break;
       }
 
       case OP_INVALID:
-
+         TORQUE_CASE_FALLTHROUGH;
       default:
          // error!
+         AssertISV(false, "Invalid OPCode Processed!");
          goto execFinished;
       }
    }
@@ -2162,8 +2142,8 @@ execFinished:
    decRefCount();
 
 #ifdef TORQUE_DEBUG
-   AssertFatal(!(STR.mStartStackSize > stackStart), "String stack not popped enough in script exec");
-   AssertFatal(!(STR.mStartStackSize < stackStart), "String stack popped too much in script exec");
+   AssertFatal(!(_STK > stackStart), "String stack not popped enough in script exec");
+   AssertFatal(!(_STK < stackStart), "String stack popped too much in script exec");
 #endif
 
    return std::move(returnValue);
diff --git a/Engine/source/console/compiler.h b/Engine/source/console/compiler.h
index f0633deab..128088827 100644
--- a/Engine/source/console/compiler.h
+++ b/Engine/source/console/compiler.h
@@ -69,6 +69,7 @@ namespace Compiler
       OP_RETURN_FLT,
       OP_RETURN_UINT,
 
+
       OP_CMPEQ,
       OP_CMPGR,
       OP_CMPGE,
@@ -132,14 +133,7 @@ namespace Compiler
       OP_SAVEFIELD_FLT,
       OP_SAVEFIELD_STR,
 
-      OP_STR_TO_UINT,
-      OP_STR_TO_FLT,
-      OP_STR_TO_NONE,  // 60
-      OP_FLT_TO_UINT,
-      OP_FLT_TO_STR,
-      OP_UINT_TO_FLT,
-      OP_UINT_TO_STR,
-      OP_NUM_TO_NONE,
+      OP_POP_STK,
 
       OP_LOADIMMED_UINT,
       OP_LOADIMMED_FLT,
@@ -150,18 +144,14 @@ namespace Compiler
 
       OP_CALLFUNC,
 
-      OP_ADVANCE_STR,
       OP_ADVANCE_STR_APPENDCHAR,
-      OP_ADVANCE_STR_COMMA,
-      OP_ADVANCE_STR_NUL,
       OP_REWIND_STR,
-      OP_TERMINATE_REWIND_STR,  // 80
+      OP_TERMINATE_REWIND_STR,
+
       OP_COMPARE_STR,
 
-      OP_PUSH,          // String
-      OP_PUSH_UINT,     // Integer
-      OP_PUSH_FLT,      // Float
-      OP_PUSH_FRAME,    // Frame
+      OP_PUSH,
+      OP_PUSH_FRAME,
 
       OP_ASSERT,
       OP_BREAK,
diff --git a/Engine/source/console/console.h b/Engine/source/console/console.h
index d42c202a7..b36a7c233 100644
--- a/Engine/source/console/console.h
+++ b/Engine/source/console/console.h
@@ -174,14 +174,7 @@ class ConsoleValue
       }
    }
 
-public:
-   explicit ConsoleValue()
-   {
-      type = ConsoleValueType::cvSTEntry;
-      s = const_cast<char*>(StringTable->EmptyString());
-   }
-
-   ConsoleValue(ConsoleValue&& ref) noexcept
+   TORQUE_FORCEINLINE void _move(ConsoleValue&& ref) noexcept
    {
       type = ref.type;
 
@@ -207,6 +200,24 @@ public:
       ref.setEmptyString();
    }
 
+public:
+   ConsoleValue()
+   {
+      type = ConsoleValueType::cvSTEntry;
+      s = const_cast<char*>(StringTable->EmptyString());
+   }
+
+   ConsoleValue(ConsoleValue&& ref) noexcept
+   {
+      _move(std::move(ref));
+   }
+
+   TORQUE_FORCEINLINE ConsoleValue& operator=(ConsoleValue&& ref) noexcept
+   {
+      _move(std::move(ref));
+      return *this;
+   }
+
    ConsoleValue(const ConsoleValue&) = delete;
    ConsoleValue& operator=(const ConsoleValue&) = delete;
 
diff --git a/Engine/source/console/consoleValueStack.h b/Engine/source/console/consoleValueStack.h
index b88804dd5..8b44a652c 100644
--- a/Engine/source/console/consoleValueStack.h
+++ b/Engine/source/console/consoleValueStack.h
@@ -89,22 +89,10 @@ public:
       stack.pop_back();
    }
 
-   TORQUE_FORCEINLINE void pushInt(S64 value)
+   TORQUE_FORCEINLINE void push(ConsoleValue&& val)
    {
       Frame& frame = stack.last();
-      frame.values[frame.internalCounter++].setInt(value);
-   }
-
-   TORQUE_FORCEINLINE void pushFloat(F64 value)
-   {
-      Frame& frame = stack.last();
-      frame.values[frame.internalCounter++].setFloat(value);
-   }
-
-   TORQUE_FORCEINLINE void pushString(const char* value, S32 len)
-   {
-      Frame& frame = stack.last();
-      frame.values[frame.internalCounter++].setString(value, len);
+      frame.values[frame.internalCounter++] = std::move(val);
    }
 
    TORQUE_FORCEINLINE void argvc(StringTableEntry fn, S32& argc, ConsoleValue** argv)
diff --git a/Engine/source/console/test/ScriptTest.cpp b/Engine/source/console/test/ScriptTest.cpp
index ecf3ae3f9..ecc974d2f 100644
--- a/Engine/source/console/test/ScriptTest.cpp
+++ b/Engine/source/console/test/ScriptTest.cpp
@@ -60,6 +60,60 @@ TEST(Script, Basic_Arithmetic)
    )");
 
    ASSERT_EQ(div.getInt(), 5);
+
+   ConsoleValue mod = RunScript(R"(
+         return 4 % 5;
+   )");
+
+   ASSERT_EQ(mod.getInt(), 4);
+
+   ConsoleValue add2 = RunScript(R"(
+         $a = 0;
+         $a += 2;
+         return $a;
+   )");
+
+   ASSERT_EQ(add2.getInt(), 2);
+
+   ConsoleValue sub2 = RunScript(R"(
+         $a = 0;
+         $a -= 2;
+         return $a;
+   )");
+
+   ASSERT_EQ(sub2.getInt(), -2);
+
+   ConsoleValue mult2 = RunScript(R"(
+         $a = 2;
+         $a *= 3;
+         return $a;
+   )");
+
+   ASSERT_EQ(mult2.getInt(), 6);
+
+   ConsoleValue div2 = RunScript(R"(
+         $a = 10;
+         $a /= 2;
+         return $a;
+   )");
+
+   ASSERT_EQ(div2.getInt(), 5);
+
+   ConsoleValue pp = RunScript(R"(
+         $a = 0;
+         $a++;
+         return $a;
+   )");
+
+   ASSERT_EQ(pp.getInt(), 1);
+
+   ConsoleValue mm = RunScript(R"(
+         $a = 2;
+         $a--;
+         return $a;
+   )");
+
+   ASSERT_EQ(mm.getInt(), 1);
 }
 
 TEST(Script, Complex_Arithmetic)
@@ -240,6 +294,20 @@ TEST(Script, Basic_Loop_Statements)
 
    ASSERT_STREQ(forValue.getString(), "aaa");
 
+   ConsoleValue forReverseLoop = RunScript(R"(
+         function t(%times) 
+         { 
+            %result = "";
+            for (%i = %times - 1; %i >= 0; %i--)
+               %result = %result @ "b";
+            return %result;
+         }
+
+         return t(3);
+   )");
+
+   ASSERT_STREQ(forReverseLoop.getString(), "bbb");
+
    ConsoleValue forIfValue = RunScript(R"(
          function t()
          {
@@ -402,6 +470,77 @@ TEST(Script, Basic_SimObject)
    )");
 
    ASSERT_STREQ(parentFn.getString(), "FooBar");
+
+   ConsoleValue grp = RunScript(R"(
+         new SimGroup(FudgeCollectorGroup)
+         {
+            theName = "fudge";
+
+            new SimObject(ChocolateFudge)
+            {
+               type = "Chocolate";
+            };
+            new SimObject(PeanutButterFudge)
+            {
+               type = "Peanut Butter";
+
+               field["a"] = "Yes";
+            };
+         };
+
+         return FudgeCollectorGroup.getId();
+   )");
+
+   SimGroup* simGroup = dynamic_cast<SimGroup*>(Sim::findObject(grp));
+   ASSERT_NE(simGroup, (SimGroup*)NULL);
+   ASSERT_EQ(simGroup->size(), 2);
+
+   simGroup->deleteObject();
+
+   ConsoleValue fieldTest = RunScript(R"(
+         function a()
+         {
+            %obj = new SimObject();
+            %obj.field = "A";
+            %obj.val[%obj.field] = "B";
+
+            %value = %obj.val["A"];
+            %obj.delete();
+            return %value;
+         }
+         return a();
+   )");
+
+   ASSERT_STREQ(fieldTest.getString(), "B");
+}
+
+TEST(Script, Internal_Name)
+{
+   ConsoleValue value = RunScript(R"(
+         function SimObject::_internalCall(%this)
+         {
+            return 5;
+         }
+
+         function a()
+         {
+            %grp = new SimGroup();
+            %obj = new SimObject()
+            {
+               internalName = "Yay";
+            };
+            %grp.add(%obj);
+
+            %val = %grp->Yay._internalCall();
+
+            %grp.delete();
+
+            return %val;
+         }
+         return a();
+   )");
+
+   ASSERT_EQ(value.getInt(), 5);
 }
 
 TEST(Script, Basic_Package)

From dcd01e1231044b6098c73dd391ea376c782c19fc Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Fri, 30 Apr 2021 00:24:03 -0400
Subject: [PATCH 017/399] move parameters instead of copying.

---
 Engine/source/console/compiledEval.cpp  | 18 +-----------------
 Engine/source/console/consoleInternal.h |  5 +++++
 2 files changed, 6 insertions(+), 17 deletions(-)

diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index 228dc85f3..4063aa3eb 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -490,23 +490,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
       {
          S32 reg = code[ip + (2 + 6 + 1 + 1) + i];
          ConsoleValue& value = argv[i + 1];
-         switch (value.getType())
-         {
-         case ConsoleValueType::cvString:
-            gEvalState.setLocalStringVariable(reg, value.getString(), dStrlen(value.getString()));
-            break;
-         case ConsoleValueType::cvInteger:
-            gEvalState.setLocalIntVariable(reg, value.getInt());
-            break;
-         case ConsoleValueType::cvFloat:
-            gEvalState.setLocalFloatVariable(reg, value.getFloat());
-            break;
-         case ConsoleValueType::cvSTEntry:
-            gEvalState.setLocalStringTableEntryVariable(reg, value.getString());
-            break;
-         default:
-            AssertFatal(false, avar("Invalid local variable type. Type was: %i", value.getType()));
-         }
+         gEvalState.moveConsoleValue(reg, std::move(value));
       }
       ip = ip + fnArgc + (2 + 6 + 1 + 1);
       curFloatTable = functionFloats;
diff --git a/Engine/source/console/consoleInternal.h b/Engine/source/console/consoleInternal.h
index 392bf0c3f..f947057e5 100644
--- a/Engine/source/console/consoleInternal.h
+++ b/Engine/source/console/consoleInternal.h
@@ -622,6 +622,11 @@ public:
       currentRegisterArray->values[reg].setStringTableEntry(val);
    }
 
+   TORQUE_FORCEINLINE void moveConsoleValue(S32 reg, ConsoleValue val)
+   {
+      currentRegisterArray->values[reg] = std::move(val);
+   }
+
    void pushFrame(StringTableEntry frameName, Namespace *ns, S32 regCount);
    void popFrame();
 

From 55b0ecb4878e80a3cacc89437ba6c531a95ede02 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Fri, 30 Apr 2021 01:20:01 -0400
Subject: [PATCH 018/399] optimizations

---
 Engine/source/console/compiledEval.cpp | 43 ++++++++++++++++----------
 Engine/source/console/console.cpp      | 16 ++--------
 Engine/source/console/console.h        | 12 ++++---
 3 files changed, 38 insertions(+), 33 deletions(-)

diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index 4063aa3eb..4f1a197d9 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -57,6 +57,7 @@ enum EvalConstants
    MaxStackSize = 1024,
    FieldBufferSizeString = 2048,
    FieldBufferSizeNumeric = 128,
+   ConcatBufferInitialSize = 8192,
    MethodOnComponent = -2
 };
 
@@ -118,6 +119,23 @@ S32 _STK = 0;
 char curFieldArray[256];
 char prevFieldArray[256];
 
+const char* tsconcat(const char* strA, const char* strB, S32& outputLen)
+{
+   S32 lenA = dStrlen(strA);
+   S32 lenB = dStrlen(strB);
+
+   S32 len = lenA + lenB + 1;
+
+   char* concatBuffer = (char*)dMalloc(len);
+
+   concatBuffer[len - 1] = '\0';
+   memcpy(concatBuffer, strA, lenA);
+   memcpy(concatBuffer + lenA, strB, lenB);
+
+   outputLen = lenA + lenB;
+   return concatBuffer;
+}
+
 namespace Con
 {
    // Current script file name and root, these are registered as
@@ -1727,7 +1745,6 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          {
             if (nsEntry->mFunctionOffset)
             {
-               // TODO: not make this strings only for returns.
                ConsoleValue returnFromFn = nsEntry->mCode->exec(nsEntry->mFunctionOffset, fnName, nsEntry->mNamespace, callArgc, callArgv, false, nsEntry->mPackage);
                stack[_STK + 1] = std::move(returnFromFn);
             }
@@ -1834,34 +1851,28 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
 
       case OP_ADVANCE_STR_APPENDCHAR:
       {
-         // TODO: Create a better way to handle string concatination without
-         // heap allocating every time.
-
-         val = stack[_STK].getString();
-         dsize_t len = dStrlen(val) + 2;
-
          char buff[2];
          buff[0] = (char)code[ip++];
          buff[1] = '\0';
 
-         char* concat = new char[len];
-         dMemset(concat, 0, len);
-         dStrcat(concat, val, len);
-         dStrcat(concat, buff, len);
-
-         stack[_STK].setString(concat);
-
-         delete[] concat;
+         S32 len;
+         const char* concat = tsconcat(stack[_STK].getString(), buff, len);
 
+         stack[_STK].setStringRef(concat, len);
          break;
       }
 
       case OP_REWIND_STR:
          TORQUE_CASE_FALLTHROUGH;
       case OP_TERMINATE_REWIND_STR:
-         stack[_STK - 1].setString((String(stack[_STK - 1] + String(stack[_STK]))));
+      {
+         S32 len;
+         const char* concat = tsconcat(stack[_STK - 1].getString(), stack[_STK].getString(), len);
+
+         stack[_STK - 1].setStringRef(concat, len);
          _STK--;
          break;
+      }
 
       case OP_COMPARE_STR:
          stack[_STK - 1].setBool(!dStricmp(stack[_STK].getString(), stack[_STK - 1].getString()));
diff --git a/Engine/source/console/console.cpp b/Engine/source/console/console.cpp
index a7d2dafc6..f75285f2f 100644
--- a/Engine/source/console/console.cpp
+++ b/Engine/source/console/console.cpp
@@ -46,31 +46,21 @@
 extern StringStack STR;
 extern ConsoleValueStack<4096> gCallStack;
 
-S32 ConsoleValue::sBufferOffset = 0;
 char ConsoleValue::sConversionBuffer[ConversionBufferSize];
 
 void ConsoleValue::init()
 {
-   sBufferOffset = 0;
    dMemset(sConversionBuffer, '\0', ConversionBufferSize);
 }
 
 char* ConsoleValue::convertToBuffer() const
 {
-   sBufferOffset += StringSize;
-   if (sBufferOffset > ConversionBufferSize)
-   {
-      dMemset(sConversionBuffer, '\0', ConversionBufferSize);
-      sBufferOffset = 0;
-   }
-
-   char* offset = sConversionBuffer + sBufferOffset;
    if (type == ConsoleValueType::cvFloat)
-      dSprintf(offset, StringSize, "%.9g", f);
+      dSprintf(sConversionBuffer, ConversionBufferSize, "%.9g", f);
    else
-      dSprintf(offset, StringSize, "%lld", i);
+      dSprintf(sConversionBuffer, ConversionBufferSize, "%lld", i);
 
-   return offset;
+   return sConversionBuffer;
 }
 
 const char* ConsoleValue::getConsoleData() const
diff --git a/Engine/source/console/console.h b/Engine/source/console/console.h
index b36a7c233..f7d077ae0 100644
--- a/Engine/source/console/console.h
+++ b/Engine/source/console/console.h
@@ -149,12 +149,10 @@ class ConsoleValue
 
    enum Constants
    {
-      ConversionBufferSize = 1024,
-      StringSize = 16
+      ConversionBufferSize = 32
    };
 
    static char sConversionBuffer[ConversionBufferSize];
-   static S32 sBufferOffset;
 
    char* convertToBuffer() const;
 
@@ -314,6 +312,13 @@ public:
       dStrcpy(s, val, static_cast<dsize_t>(len) + 1);
    }
 
+   TORQUE_FORCEINLINE void setStringRef(const char* ref, S32 len)
+   {
+      cleanupData();
+      type = ConsoleValueType::cvString;
+      s = const_cast<char*>(ref);
+   }
+
    TORQUE_FORCEINLINE void setBool(const bool val)
    {
       cleanupData();
@@ -361,7 +366,6 @@ public:
    }
 
    static void init();
-   static S32 getConstantBufferCount() { return (S32)ConversionBufferSize / StringSize; }
 };
 
 // Transparently converts ConsoleValue[] to const char**

From ab4c0f036109c478bd4b04d204c7e3df24baa613 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Sat, 1 May 2021 02:07:54 -0400
Subject: [PATCH 019/399] Add fast math optimization

---
 Engine/source/console/compiledEval.cpp | 234 ++++++++++++++++++++-----
 Engine/source/console/console.h        |  22 +++
 Engine/source/platform/types.visualc.h |   1 +
 3 files changed, 216 insertions(+), 41 deletions(-)

diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index 4f1a197d9..018a82b21 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -444,6 +444,172 @@ void ExprEvalState::setStringVariable(const char *val)
 
 //-----------------------------------------------------------------------------
 
+enum class FloatOperation
+{
+   Add,
+   Sub,
+   Mul,
+   Div,
+
+   LT,
+   LE,
+   GR,
+   GE,
+   EQ,
+   NE
+};
+
+template<FloatOperation Op>
+TORQUE_FORCEINLINE void doFloatMathOperation()
+{
+   ConsoleValue& a = stack[_STK];
+   ConsoleValue& b = stack[_STK - 1];
+
+   S32 fastIf = (a.getType() == ConsoleValueType::cvFloat) & (b.getType() == ConsoleValueType::cvFloat);
+   if (fastIf)
+   {
+      // Arithmetic
+      if constexpr (Op == FloatOperation::Add)
+         stack[_STK - 1].setFastFloat(a.getFastFloat() + b.getFastFloat());
+      if constexpr (Op == FloatOperation::Sub)
+         stack[_STK - 1].setFastFloat(a.getFastFloat() - b.getFastFloat());
+      if constexpr (Op == FloatOperation::Mul)
+         stack[_STK - 1].setFastFloat(a.getFastFloat() * b.getFastFloat());
+      if constexpr (Op == FloatOperation::Div)
+         stack[_STK - 1].setFastFloat(a.getFastFloat() / b.getFastFloat());
+
+      // Logical
+      if constexpr (Op == FloatOperation::LT)
+         stack[_STK - 1].setFastInt(a.getFastFloat() < b.getFastFloat());
+      if constexpr (Op == FloatOperation::LE)
+         stack[_STK - 1].setFastInt(a.getFastFloat() <= b.getFastFloat());
+      if constexpr (Op == FloatOperation::GR)
+         stack[_STK - 1].setFastInt(a.getFastFloat() > b.getFastFloat());
+      if constexpr (Op == FloatOperation::GE)
+         stack[_STK - 1].setFastInt(a.getFastFloat() >= b.getFastFloat());
+      if constexpr (Op == FloatOperation::EQ)
+         stack[_STK - 1].setFastInt(a.getFastFloat() == b.getFastFloat());
+      if constexpr (Op == FloatOperation::NE)
+         stack[_STK - 1].setFastInt(a.getFastFloat() != b.getFastFloat());
+
+      _STK--;
+   }
+   else
+   {
+      doSlowMathOp<Op>();
+   }
+}
+
+template<FloatOperation Op>
+TORQUE_NOINLINE void doSlowMathOp()
+{
+   ConsoleValue& a = stack[_STK];
+   ConsoleValue& b = stack[_STK - 1];
+
+   // Arithmetic
+   if constexpr (Op == FloatOperation::Add)
+      stack[_STK - 1].setFloat(a.getFloat() + b.getFloat());
+   else if constexpr (Op == FloatOperation::Sub)
+      stack[_STK - 1].setFloat(a.getFloat() - b.getFloat());
+   else if constexpr (Op == FloatOperation::Mul)
+      stack[_STK - 1].setFloat(a.getFloat() * b.getFloat());
+   else if constexpr (Op == FloatOperation::Div)
+      stack[_STK - 1].setFloat(a.getFloat() / b.getFloat());
+
+   // Logical
+   if constexpr (Op == FloatOperation::LT)
+      stack[_STK - 1].setFastInt(a.getFloat() < b.getFloat());
+   if constexpr (Op == FloatOperation::LE)
+      stack[_STK - 1].setFastInt(a.getFloat() <= b.getFloat());
+   if constexpr (Op == FloatOperation::GR)
+      stack[_STK - 1].setFastInt(a.getFloat() > b.getFloat());
+   if constexpr (Op == FloatOperation::GE)
+      stack[_STK - 1].setFastInt(a.getFloat() >= b.getFloat());
+   if constexpr (Op == FloatOperation::EQ)
+      stack[_STK - 1].setFastInt(a.getFloat() == b.getFloat());
+   if constexpr (Op == FloatOperation::NE)
+      stack[_STK - 1].setFastInt(a.getFloat() != b.getFloat());
+
+   _STK--;
+}
+
+//-----------------------------------------------------------------------------
+
+enum class IntegerOperation
+{
+   BitAnd,
+   BitOr,
+   Xor,
+   LShift,
+   RShift,
+
+   LogicalAnd,
+   LogicalOr
+};
+
+template<IntegerOperation Op>
+TORQUE_FORCEINLINE void doIntOperation()
+{
+   ConsoleValue& a = stack[_STK];
+   ConsoleValue& b = stack[_STK - 1];
+
+   if (a.isNumberType() && b.isNumberType())
+   {
+      // Bitwise Op
+      if constexpr (Op == IntegerOperation::BitAnd)
+         stack[_STK - 1].setFastInt(a.getFastInt() & b.getFastInt());
+      if constexpr (Op == IntegerOperation::BitOr)
+         stack[_STK - 1].setFastInt(a.getFastInt() | b.getFastInt());
+      if constexpr (Op == IntegerOperation::Xor)
+         stack[_STK - 1].setFastInt(a.getFastInt() ^ b.getFastInt());
+      if constexpr (Op == IntegerOperation::LShift)
+         stack[_STK - 1].setFastInt(a.getFastInt() << b.getFastInt());
+      if constexpr (Op == IntegerOperation::RShift)
+         stack[_STK - 1].setFastInt(a.getFastInt() >> b.getFastInt());
+
+      // Logical Op
+      if constexpr (Op == IntegerOperation::LogicalAnd)
+         stack[_STK - 1].setFastInt(a.getFastInt() && b.getFastInt());
+      if constexpr (Op == IntegerOperation::LogicalOr)
+         stack[_STK - 1].setFastInt(a.getFastInt() || b.getFastInt());
+
+      _STK--;
+   }
+   else
+   {
+      doSlowIntegerOp<Op>();
+   }
+}
+
+template<IntegerOperation Op>
+TORQUE_NOINLINE void doSlowIntegerOp()
+{
+   ConsoleValue& a = stack[_STK];
+   ConsoleValue& b = stack[_STK - 1];
+
+   // Bitwise Op
+   if constexpr (Op == IntegerOperation::BitAnd)
+      stack[_STK - 1].setInt(a.getInt() & b.getInt());
+   if constexpr (Op == IntegerOperation::BitOr)
+      stack[_STK - 1].setInt(a.getInt() | b.getInt());
+   if constexpr (Op == IntegerOperation::Xor)
+      stack[_STK - 1].setInt(a.getInt() ^ b.getInt());
+   if constexpr (Op == IntegerOperation::LShift)
+      stack[_STK - 1].setInt(a.getInt() << b.getInt());
+   if constexpr (Op == IntegerOperation::RShift)
+      stack[_STK - 1].setInt(a.getInt() >> b.getInt());
+
+   // Logical Op
+   if constexpr (Op == IntegerOperation::LogicalAnd)
+      stack[_STK - 1].setInt(a.getInt() && b.getInt());
+   if constexpr (Op == IntegerOperation::LogicalOr)
+      stack[_STK - 1].setInt(a.getInt() || b.getInt());
+
+   _STK--;
+}
+
+//-----------------------------------------------------------------------------
+
 U32 gExecCount = 0;
 ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNamespace, U32 argc, ConsoleValue* argv, bool noCalls, StringTableEntry packageName, S32 setFrame)
 {
@@ -1151,56 +1317,39 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          goto execFinished;
 
       case OP_CMPEQ:
-         stack[_STK - 1].setInt(stack[_STK].getFloat() == stack[_STK - 1].getFloat());
-         _STK--;
+         doFloatMathOperation<FloatOperation::EQ>();
          break;
 
       case OP_CMPGR:
-         stack[_STK - 1].setInt(stack[_STK].getFloat() > stack[_STK - 1].getFloat());
-         _STK--;
+         doFloatMathOperation<FloatOperation::GR>();
          break;
 
       case OP_CMPGE:
-         stack[_STK - 1].setInt(stack[_STK].getFloat() >= stack[_STK - 1].getFloat());
-         _STK--;
+         doFloatMathOperation<FloatOperation::GE>();
          break;
 
       case OP_CMPLT:
-         stack[_STK - 1].setInt(stack[_STK].getFloat() < stack[_STK - 1].getFloat());
-         _STK--;
+         doFloatMathOperation<FloatOperation::LT>();
          break;
 
       case OP_CMPLE:
-         stack[_STK - 1].setInt(stack[_STK].getFloat() <= stack[_STK - 1].getFloat());
-         _STK--;
+         doFloatMathOperation<FloatOperation::LE>();
          break;
 
       case OP_CMPNE:
-         stack[_STK - 1].setInt(stack[_STK].getFloat() != stack[_STK - 1].getFloat());
-         _STK--;
+         doFloatMathOperation<FloatOperation::NE>();
          break;
 
       case OP_XOR:
-         stack[_STK - 1].setInt(stack[_STK].getInt() ^ stack[_STK - 1].getInt());
-         _STK--;
-         break;
-
-      case OP_MOD:
-         if (stack[_STK - 1].getInt() != 0)
-            stack[_STK - 1].setInt(stack[_STK].getInt() % stack[_STK - 1].getInt());
-         else
-            stack[_STK - 1].setInt(0);
-         _STK--;
+         doIntOperation<IntegerOperation::Xor>();
          break;
 
       case OP_BITAND:
-         stack[_STK - 1].setInt(stack[_STK].getInt() & stack[_STK - 1].getInt());
-         _STK--;
+         doIntOperation<IntegerOperation::BitAnd>();
          break;
 
       case OP_BITOR:
-         stack[_STK - 1].setInt(stack[_STK].getInt() | stack[_STK - 1].getInt());
-         _STK--;
+         doIntOperation<IntegerOperation::BitOr>();
          break;
 
       case OP_NOT:
@@ -1216,44 +1365,47 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          break;
 
       case OP_SHR:
-         stack[_STK - 1].setInt(stack[_STK].getInt() >> stack[_STK - 1].getInt());
-         _STK--;
+         doIntOperation<IntegerOperation::RShift>();
          break;
 
       case OP_SHL:
-         stack[_STK - 1].setInt(stack[_STK].getInt() << stack[_STK - 1].getInt());
-         _STK--;
+         doIntOperation<IntegerOperation::LShift>();
          break;
 
       case OP_AND:
-         stack[_STK - 1].setInt(stack[_STK].getInt() && stack[_STK - 1].getInt());
-         _STK--;
+         doIntOperation<IntegerOperation::LogicalAnd>();
          break;
 
       case OP_OR:
-         stack[_STK - 1].setInt(stack[_STK].getInt() || stack[_STK - 1].getInt());
-         _STK--;
+         doIntOperation<IntegerOperation::LogicalOr>();
          break;
 
       case OP_ADD:
-         stack[_STK - 1].setFloat(stack[_STK].getFloat() + stack[_STK - 1].getFloat());
-         _STK--;
+         doFloatMathOperation<FloatOperation::Add>();
          break;
 
       case OP_SUB:
-         stack[_STK - 1].setFloat(stack[_STK].getFloat() - stack[_STK - 1].getFloat());
-         _STK--;
+         doFloatMathOperation<FloatOperation::Sub>();
          break;
 
       case OP_MUL:
-         stack[_STK - 1].setFloat(stack[_STK].getFloat() * stack[_STK - 1].getFloat());
-         _STK--;
+         doFloatMathOperation<FloatOperation::Mul>();
          break;
 
       case OP_DIV:
-         stack[_STK - 1].setFloat(stack[_STK].getFloat() / stack[_STK - 1].getFloat());
+         doFloatMathOperation<FloatOperation::Div>();
+         break;
+
+      case OP_MOD:
+      {
+         S64 divisor = stack[_STK - 1].getInt();
+         if (divisor != 0)
+            stack[_STK - 1].setInt(stack[_STK].getInt() % divisor);
+         else
+            stack[_STK - 1].setInt(0);
          _STK--;
          break;
+      }
 
       case OP_NEG:
          stack[_STK].setFloat(-stack[_STK].getFloat());
diff --git a/Engine/source/console/console.h b/Engine/source/console/console.h
index f7d077ae0..db9af8a23 100644
--- a/Engine/source/console/console.h
+++ b/Engine/source/console/console.h
@@ -365,6 +365,28 @@ public:
       return type >= ConsoleValueType::cvConsoleValueType;
    }
 
+   TORQUE_FORCEINLINE void setFastFloat(F64 flt)
+   {
+      type = ConsoleValueType::cvFloat;
+      f = flt;
+   }
+
+   TORQUE_FORCEINLINE F64 getFastFloat() const
+   {
+      return f;
+   }
+
+   TORQUE_FORCEINLINE void setFastInt(S64 flt)
+   {
+      type = ConsoleValueType::cvInteger;
+      i = flt;
+   }
+
+   TORQUE_FORCEINLINE S64 getFastInt() const
+   {
+      return i;
+   }
+
    static void init();
 };
 
diff --git a/Engine/source/platform/types.visualc.h b/Engine/source/platform/types.visualc.h
index 89fd38d4b..4ccc6ce42 100644
--- a/Engine/source/platform/types.visualc.h
+++ b/Engine/source/platform/types.visualc.h
@@ -105,6 +105,7 @@ typedef unsigned _int64 U64;
 #pragma warning(disable: 4291)
 
 #define TORQUE_FORCEINLINE __forceinline
+#define TORQUE_NOINLINE __declspec(noinline)
 
 #if __cplusplus >= 201703L
 #define TORQUE_CASE_FALLTHROUGH [[fallthrough]];

From db047275f1b107942b7013ad53c7b2e24101d25b Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Sat, 1 May 2021 02:55:24 -0400
Subject: [PATCH 020/399] add fast int to object lookup.

---
 Engine/source/console/compiledEval.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index 018a82b21..b02f2f8fd 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -1824,7 +1824,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
             // Optimization: If we're an integer, we can lookup the value by SimObjectId
             const ConsoleValue& simObjectLookupValue = callArgv[1];
             if (simObjectLookupValue.getType() == ConsoleValueType::cvInteger)
-               gEvalState.thisObject = Sim::findObject(static_cast<SimObjectId>(simObjectLookupValue.getInt()));
+               gEvalState.thisObject = Sim::findObject(static_cast<SimObjectId>(simObjectLookupValue.getFastInt()));
             else
             {
                SimObject *foundObject = Sim::findObject(simObjectLookupValue.getString());

From 6f7fdca87d10e9a5b6dcebcd2ce597a4377d7dc2 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Tue, 4 May 2021 21:18:15 -0400
Subject: [PATCH 021/399] lotsa fixes.

---
 Engine/source/T3D/gameBase/gameConnection.cpp | 31 ++++++-----------
 Engine/source/console/console.h               |  2 +-
 Engine/source/console/simEvents.cpp           |  2 +-
 .../scripts/server/levelInfo.tscript          |  1 +
 .../scripts/server/levelLoad.tscript          |  3 ++
 .../game/core/console/guis/console.gui        |  2 +-
 .../game/core/console/scripts/console.tscript |  2 +-
 .../core/postFX/scripts/postFxManager.tscript |  2 +-
 .../scripts/gameObjectManagement.tscript      |  4 +--
 .../utility/scripts/helperFunctions.tscript   |  4 ++-
 .../core/utility/scripts/parseArgs.tscript    | 34 +++++++++----------
 .../game/core/utility/scripts/scene.tscript   |  3 --
 .../data/ExampleModule/GUIs/ExampleGUI.gui    |  2 +-
 Templates/BaseGame/game/data/defaults.tscript |  2 +-
 .../game/data/gameUI/GUIs/playGui.gui         |  2 +-
 .../game/data/ui/guis/IODropdownDlg.ed.gui    |  2 +-
 .../game/data/ui/guis/RecordingsDlg.gui       |  2 +-
 .../game/data/ui/guis/chooseLevelDlg.gui      |  2 +-
 .../game/data/ui/guis/guiMusicPlayer.gui      |  2 +-
 .../game/data/ui/guis/joinServerMenu.gui      |  2 +-
 .../BaseGame/game/data/ui/guis/loadingGui.gui |  2 +-
 .../BaseGame/game/data/ui/guis/mainMenu.gui   |  2 +-
 .../game/data/ui/guis/messageBoxDlg.gui       |  2 +-
 .../game/data/ui/guis/netGraphGui.gui         |  2 +-
 .../BaseGame/game/data/ui/guis/optionsDlg.gui |  2 +-
 .../game/data/ui/guis/optionsMenu.gui         |  2 +-
 .../game/data/ui/guis/optionsMenu.tscript     | 17 +++-------
 .../BaseGame/game/data/ui/guis/pauseMenu.gui  |  2 +-
 .../BaseGame/game/data/ui/guis/profiler.gui   |  2 +-
 .../game/data/ui/guis/profiler.tscript        |  2 +-
 .../game/data/ui/guis/remapConfirmDlg.gui     |  2 +-
 .../BaseGame/game/data/ui/guis/remapDlg.gui   |  2 +-
 .../BaseGame/game/data/ui/guis/startupGui.gui |  2 +-
 Templates/BaseGame/game/main.tscript.in       |  5 ++-
 .../MainEditor/guis/MainEditorWindow.gui      |  2 +-
 .../VPathEditor/GUI/VPathEditorToolbar.gui    |  2 +-
 .../tools/VerveEditor/GUI/VerveEditor.gui     |  2 +-
 .../GUI/VerveEditorGroupBuilder.gui           |  2 +-
 .../GUI/VerveEditorImportPathNodes.gui        |  2 +-
 .../GUI/VerveEditorPreferences.gui            |  2 +-
 .../guis/AssetImportConfigEditor.gui          |  2 +-
 .../assetBrowser/guis/GameObjectCreator.gui   |  2 +-
 .../assetBrowser/guis/addModuleWindow.gui     |  2 +-
 .../assetBrowser/guis/addPackageWindow.gui    |  2 +-
 .../tools/assetBrowser/guis/assetBrowser.gui  |  2 +-
 .../tools/assetBrowser/guis/assetImport.gui   |  2 +-
 .../assetBrowser/guis/assetImportLog.gui      |  2 +-
 .../tools/assetBrowser/guis/assetNameEdit.gui |  2 +-
 .../guis/assetPreviewButtonsTemplate.gui      |  2 +-
 .../guis/createNewCollectionSet.gui           |  2 +-
 .../tools/assetBrowser/guis/editAsset.gui     |  2 +-
 .../tools/assetBrowser/guis/editModule.gui    |  2 +-
 .../assetBrowser/guis/looseFileAudit.gui      |  2 +-
 .../game/tools/assetBrowser/guis/newAsset.gui |  2 +-
 .../assetBrowser/guis/newComponentAsset.gui   |  2 +-
 .../tools/assetBrowser/guis/newFolder.gui     |  2 +-
 .../tools/assetBrowser/guis/selectModule.gui  |  2 +-
 .../tools/assetBrowser/guis/selectPackage.gui |  2 +-
 .../tools/assetBrowser/guis/selectPath.gui    |  2 +-
 .../templateFiles/guiFile.gui.template        |  2 +-
 .../componentEditor/gui/TypeMaskFieldGui.gui  |  2 +-
 .../gui/superToolTipDlg.ed.gui                |  2 +-
 .../tools/convexEditor/convexEditorGui.gui    |  2 +-
 .../convexEditorSettingsTab.ed.gui            |  2 +-
 .../convexEditor/convexEditorToolbar.ed.gui   |  2 +-
 .../DatablockEditorCreatePrompt.ed.gui        |  2 +-
 .../DatablockEditorInspectorWindow.ed.gui     |  2 +-
 .../DatablockEditorTreeWindow.ed.gui          |  2 +-
 .../debugger/gui/breakConditionDlg.ed.gui     |  2 +-
 .../game/tools/debugger/gui/connectDlg.ed.gui |  2 +-
 .../game/tools/debugger/gui/debugger.ed.gui   |  2 +-
 .../tools/debugger/gui/editWatchDlg.ed.gui    |  2 +-
 .../game/tools/debugger/gui/findDlg.ed.gui    |  2 +-
 .../game/tools/debugger/gui/watchDlg.ed.gui   |  2 +-
 .../game/tools/decalEditor/decalEditorGui.gui |  2 +-
 .../forestEditor/forestEditToolbar.ed.gui     |  2 +-
 .../tools/forestEditor/forestEditorGui.gui    |  2 +-
 .../game/tools/gui/EditorLoadingGui.gui       |  2 +-
 .../tools/gui/EditorSettingsWindow.ed.gui     |  2 +-
 .../game/tools/gui/GuiEaseEditDlg.ed.gui      |  2 +-
 .../game/tools/gui/assimpImport.ed.gui        |  2 +-
 .../game/tools/gui/colladaImport.ed.gui       |  6 ++--
 .../game/tools/gui/colorPicker.ed.gui         |  2 +-
 .../BaseGame/game/tools/gui/cubemapEditor.gui |  2 +-
 .../game/tools/gui/fileDialogBase.ed.tscript  |  3 +-
 .../game/tools/gui/guiObjectInspector.ed.gui  |  2 +-
 .../tools/gui/guiObjectInspector.ed.tscript   |  6 ++--
 .../game/tools/gui/materialSelector.ed.gui    |  4 ++-
 .../gui/messageBoxes/IODropdownDlg.ed.gui     |  2 +-
 .../gui/messageBoxes/messageBoxOK.ed.gui      |  2 +-
 .../gui/messageBoxes/messageBoxOKBuy.ed.gui   |  2 +-
 .../messageBoxes/messageBoxOKCancel.ed.gui    |  2 +-
 .../messageBoxOKCancelDetailsDlg.ed.gui       |  2 +-
 .../gui/messageBoxes/messageBoxYesNo.ed.gui   |  2 +-
 .../messageBoxes/messageBoxYesNoCancel.ed.gui |  2 +-
 .../gui/messageBoxes/messagePopup.ed.gui      |  2 +-
 .../BaseGame/game/tools/gui/postFxEditor.gui  |  2 +-
 .../BaseGame/game/tools/gui/profilerGraph.gui |  2 +-
 .../tools/gui/renderTargetVisualizer.ed.gui   |  2 +-
 .../game/tools/gui/saveChangesMBDlg.ed.gui    |  2 +-
 .../game/tools/gui/scriptEditorDlg.ed.gui     |  2 +-
 .../BaseGame/game/tools/gui/simViewDlg.ed.gui |  2 +-
 .../guiEditor/gui/EditorChooseGUI.ed.gui      |  2 +-
 .../game/tools/guiEditor/gui/guiEditor.ed.gui |  2 +-
 .../gui/guiEditorNewGuiDialog.ed.gui          |  2 +-
 .../guiEditor/gui/guiEditorPrefsDlg.ed.gui    |  2 +-
 .../guiEditor/gui/guiEditorSelectDlg.ed.gui   |  2 +-
 .../scripts/EditorChooseGUI.ed.tscript        |  4 +--
 .../scripts/guiEditorCanvas.ed.tscript        | 16 ++++-----
 Templates/BaseGame/game/tools/main.tscript    |  2 +-
 .../materialEditor/gui/MaterialToolbar.ed.gui |  2 +-
 .../gui/guiMaterialPreviewWindow.ed.gui       |  2 +-
 .../gui/guiMaterialPropertiesWindow.ed.gui    |  2 +-
 .../gui/materialInstancesView.ed.gui          |  2 +-
 .../meshRoadEditor/meshRoadEditorGui.gui      |  2 +-
 .../meshRoadEditorSettingsTab.gui             |  2 +-
 .../meshRoadEditor/meshRoadEditorToolbar.gui  |  2 +-
 .../missionAreaEditorGui.ed.gui               |  2 +-
 .../tools/navEditor/CreateNewNavMeshDlg.gui   |  2 +-
 .../tools/navEditor/NavEditorConsoleDlg.gui   |  2 +-
 .../game/tools/navEditor/NavEditorGui.gui     |  2 +-
 .../tools/navEditor/NavEditorSettingsTab.gui  |  2 +-
 .../game/tools/navEditor/NavEditorToolbar.gui |  2 +-
 .../particleEditor/ParticleEditor.ed.gui      |  2 +-
 .../game/tools/riverEditor/RiverEditorGui.gui |  2 +-
 .../riverEditor/RiverEditorSettingsTab.gui    |  2 +-
 .../tools/riverEditor/RiverEditorToolbar.gui  |  2 +-
 .../game/tools/roadEditor/RoadEditorGui.gui   |  2 +-
 .../roadEditor/RoadEditorSettingsTab.gui      |  2 +-
 .../tools/roadEditor/RoadEditorToolbar.gui    |  2 +-
 .../gui/ShapeEditorSettingsTab.gui            |  2 +-
 .../shapeEditor/gui/ShapeEditorToolbar.ed.gui |  2 +-
 .../gui/shapeEdAdvancedWindow.ed.gui          |  2 +-
 .../shapeEditor/gui/shapeEdAnimWindow.ed.gui  |  2 +-
 .../gui/shapeEdPreviewWindow.ed.gui           |  2 +-
 .../shapeEditor/gui/shapeEdPropWindow.ed.gui  |  2 +-
 .../gui/shapeEdSelectWindow.ed.gui            |  2 +-
 .../worldEditor/gui/AddFMODProjectDlg.ed.gui  |  2 +-
 .../gui/AxisGizmoSettingsTab.ed.gui           |  2 +-
 .../worldEditor/gui/CameraSettingsTab.ed.gui  |  2 +-
 .../gui/EditorChooseLevelGui.ed.gui           |  4 +--
 .../tools/worldEditor/gui/EditorGui.ed.gui    |  2 +-
 .../gui/EditorSettingsWindow.ed.gui           |  2 +-
 .../worldEditor/gui/GeneralSettingsTab.ed.gui |  2 +-
 .../gui/GenericPromptDialog.ed.gui            |  2 +-
 .../gui/ManageBookmarksWindow.ed.gui          |  2 +-
 .../gui/ManageSFXParametersWindow.ed.gui      |  2 +-
 .../gui/ObjectEditorSettingsTab.ed.gui        |  2 +-
 .../gui/ObjectSnapOptionsWindow.ed.gui        |  4 +--
 .../gui/ProceduralTerrainPainterGui.gui       |  2 +-
 .../gui/SelectObjectsWindow.ed.gui            |  2 +-
 .../gui/TerrainBrushSoftnessCurveDlg.ed.gui   |  2 +-
 .../worldEditor/gui/TerrainEditToolbar.ed.gui |  2 +-
 .../gui/TerrainEditorSettingsTab.ed.gui       |  2 +-
 .../gui/TerrainPainterToolbar.ed.gui          |  2 +-
 .../gui/TerrainPainterWindow.ed.gui           |  2 +-
 .../worldEditor/gui/TimeAdjustGui.ed.gui      |  2 +-
 .../worldEditor/gui/ToolsPaletteWindow.ed.gui |  2 +-
 .../tools/worldEditor/gui/ToolsToolbar.ed.gui |  2 +-
 .../gui/TransformSelectionWindow.ed.gui       |  2 +-
 .../gui/VisibilityLayerWindow.ed.gui          |  2 +-
 .../gui/WorldEditorInspectorWindow.ed.gui     |  2 +-
 .../worldEditor/gui/WorldEditorToolbar.ed.gui |  2 +-
 .../gui/WorldEditorTreeWindow.ed.gui          |  2 +-
 .../gui/guiCreateNewTerrainGui.gui            |  2 +-
 .../worldEditor/gui/guiTerrainExportGui.gui   |  2 +-
 .../worldEditor/gui/guiTerrainImportGui.gui   |  2 +-
 .../gui/guiTerrainMaterialDlg.ed.gui          |  2 +-
 .../gui/guiTerrainTextureSettingsDlg.ed.gui   |  2 +-
 .../gui/guiWorldEditorMissionInspector.ed.gui |  2 +-
 .../worldEditor/gui/objectBuilderGui.ed.gui   |  2 +-
 .../tools/worldEditor/gui/probeBakeDlg.gui    |  2 +-
 .../game/tools/worldEditor/gui/shadowViz.gui  |  2 +-
 .../worldEditor/scripts/EditorGui.ed.tscript  |  6 ++--
 .../Modules/Verve/gui/VerveCinematic.gui      |  2 +-
 .../inputTest/scripts/gui/inputMonitor.gui    |  2 +-
 .../scripts/gui/joystickSettings.gui          |  2 +-
 Templates/Modules/vr/guis/oculusVROverlay.gui |  2 +-
 178 files changed, 230 insertions(+), 245 deletions(-)

diff --git a/Engine/source/T3D/gameBase/gameConnection.cpp b/Engine/source/T3D/gameBase/gameConnection.cpp
index e4a4c9f5e..3c58c62b9 100644
--- a/Engine/source/T3D/gameBase/gameConnection.cpp
+++ b/Engine/source/T3D/gameBase/gameConnection.cpp
@@ -374,7 +374,7 @@ void GameConnection::onConnectionEstablished(bool isInitiator)
 
       const char *argv[MaxConnectArgs + 2];
       argv[0] = "onConnect";
-      argv[1] = NULL; // Filled in later
+      argv[1] = getIdString();
       for(U32 i = 0; i < mConnectArgc; i++)
          argv[i + 2] = mConnectArgv[i];
       // NOTE: Need to fallback to Con::execute() as IMPLEMENT_CALLBACK does not 
@@ -494,33 +494,23 @@ bool GameConnection::readConnectRequest(BitStream *stream, const char **errorStr
       *errorString = "CR_INVALID_ARGS";
       return false;
    }
+
+   char buffer[256];
+   Net::addressToString(getNetAddress(), buffer);
+
    ConsoleValue connectArgv[MaxConnectArgs + 3];
-   ConsoleValue connectArgvValue[MaxConnectArgs + 3];
-
-   // TODO(JTH): Fix pls.
-   AssertISV(false, "TODO: FIX CONSOLE VALUE");
-   return false;
-
-   /*
-   for(U32 i = 0; i < mConnectArgc+3; i++)
-   {
-
-      connectArgv[i].value = &connectArgvValue[i];
-      connectArgvValue[i].init();
-   }
 
    for(U32 i = 0; i < mConnectArgc; i++)
    {
       char argString[256];
       stream->readString(argString);
       mConnectArgv[i] = dStrdup(argString);
-      connectArgv[i + 3] = mConnectArgv[i];
+      connectArgv[i + 3].setString(argString);
    }
-   connectArgvValue[0].setStackStringValue("onConnectRequest");
-   connectArgvValue[1].setIntValue(0);
-   char buffer[256];
-   Net::addressToString(getNetAddress(), buffer);
-   connectArgvValue[2].setStackStringValue(buffer);
+
+   connectArgv[0].setStringTableEntry("onConnectRequest");
+   connectArgv[1].setInt(0);
+   connectArgv[2].setString(buffer);
 
    // NOTE: Cannot convert over to IMPLEMENT_CALLBACK as it has variable args.
    const char *ret = Con::execute(this, mConnectArgc + 3, connectArgv);
@@ -530,7 +520,6 @@ bool GameConnection::readConnectRequest(BitStream *stream, const char **errorStr
       return false;
    }
    return true;
-   */
 }
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
diff --git a/Engine/source/console/console.h b/Engine/source/console/console.h
index db9af8a23..4a9f3be9d 100644
--- a/Engine/source/console/console.h
+++ b/Engine/source/console/console.h
@@ -292,7 +292,7 @@ public:
 
    TORQUE_FORCEINLINE void setString(const char* val)
    {
-      setString(val, dStrlen(val));
+      setString(val, val != NULL ? dStrlen(val) : 0);
    }
 
    TORQUE_FORCEINLINE void setString(const char* val, S32 len)
diff --git a/Engine/source/console/simEvents.cpp b/Engine/source/console/simEvents.cpp
index e375438e9..6c943f054 100644
--- a/Engine/source/console/simEvents.cpp
+++ b/Engine/source/console/simEvents.cpp
@@ -38,7 +38,7 @@ SimConsoleEvent::SimConsoleEvent(S32 argc, ConsoleValue *argv, bool onObject)
    {
       if (argv)
       {
-         mArgv->setString(argv[i].getString());
+         mArgv[i].setString(argv[i].getString());
       }
    }
 }
diff --git a/Templates/BaseGame/game/core/clientServer/scripts/server/levelInfo.tscript b/Templates/BaseGame/game/core/clientServer/scripts/server/levelInfo.tscript
index 269362638..dbfa7237d 100644
--- a/Templates/BaseGame/game/core/clientServer/scripts/server/levelInfo.tscript
+++ b/Templates/BaseGame/game/core/clientServer/scripts/server/levelInfo.tscript
@@ -143,6 +143,7 @@ function parseMissionGroupForIds( %className, %childGroup )
    if(!isObject(%currentGroup))
       return "";
       
+   %classIds = "";	  
    for(%i = 0; %i < (%currentGroup).getCount(); %i++)
    {      
       if( (%currentGroup).getObject(%i).getClassName() $= %className )
diff --git a/Templates/BaseGame/game/core/clientServer/scripts/server/levelLoad.tscript b/Templates/BaseGame/game/core/clientServer/scripts/server/levelLoad.tscript
index 64e2aa268..9bb2457ac 100644
--- a/Templates/BaseGame/game/core/clientServer/scripts/server/levelLoad.tscript
+++ b/Templates/BaseGame/game/core/clientServer/scripts/server/levelLoad.tscript
@@ -193,6 +193,9 @@ function resetMission()
    
    clearServerPaths();
    
+   // TODO: Is this right?
+   %client = ClientGroup.getObject(0);
+
    // Inform the game code we're resetting.
    %hasGameMode = callGamemodeFunction("onMissionReset", %client);
 }
\ No newline at end of file
diff --git a/Templates/BaseGame/game/core/console/guis/console.gui b/Templates/BaseGame/game/core/console/guis/console.gui
index 1d6153ce2..3c5c217a6 100644
--- a/Templates/BaseGame/game/core/console/guis/console.gui
+++ b/Templates/BaseGame/game/core/console/guis/console.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(ConsoleDlg) {
+$guiContent = new GuiControl(ConsoleDlg) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 8";
diff --git a/Templates/BaseGame/game/core/console/scripts/console.tscript b/Templates/BaseGame/game/core/console/scripts/console.tscript
index 201bcfb92..9a024050d 100644
--- a/Templates/BaseGame/game/core/console/scripts/console.tscript
+++ b/Templates/BaseGame/game/core/console/scripts/console.tscript
@@ -62,7 +62,7 @@ function ConsoleEntry::eval()
        && !startsWith(%text, "for(")
        && !startsWith(%text, "switch(")
        && !startsWith(%text, "switch$("))
-      eval("%result = " @ %text);
+      %result = eval("return" SPC %text);
    else
       eval(%text);
    $Con::warnVoidAssignment = %oldWarnVoidAssignment;
diff --git a/Templates/BaseGame/game/core/postFX/scripts/postFxManager.tscript b/Templates/BaseGame/game/core/postFX/scripts/postFxManager.tscript
index cf0080923..055411423 100644
--- a/Templates/BaseGame/game/core/postFX/scripts/postFxManager.tscript
+++ b/Templates/BaseGame/game/core/postFX/scripts/postFxManager.tscript
@@ -59,7 +59,7 @@ function PostFXManager::loadPresetFile()
 {
    //Show the dialog and set the flag
    getLoadFilename($PostFXManager::fileFilter, "PostFXManager::loadPresetHandler");
-   $PostFXManager::currentPreset = $Tools::FileDialogs::LastFilePath();
+   $PostFXManager::currentPreset = $Tools::FileDialogs::LastFilePath;
 }
 
 function PostFXManager::loadPresetHandler( %filename )
diff --git a/Templates/BaseGame/game/core/utility/scripts/gameObjectManagement.tscript b/Templates/BaseGame/game/core/utility/scripts/gameObjectManagement.tscript
index f496111eb..44ec46555 100644
--- a/Templates/BaseGame/game/core/utility/scripts/gameObjectManagement.tscript
+++ b/Templates/BaseGame/game/core/utility/scripts/gameObjectManagement.tscript
@@ -15,7 +15,7 @@ function findGameObject(%name)
 	   
 	   //%assetName = AssetDatabase.getAssetName(%assetId);
       
-        if(%assetId $= %name)
+      if(%assetId $= %name)
 		{
 		   %gameObjectAsset = AssetDatabase.acquireAsset(%assetId);
 
@@ -47,7 +47,7 @@ function spawnGameObject(%name, %addToScene)
          %go.setHidden(false);
          %go.setScopeAlways();
          
-         if(%addToMissionGroup == true) //save instance when saving level
+         if(%addToScene == true) //save instance when saving level
             getScene(0).add(%go);
          else // clear instance on level exit
             MissionCleanup.add(%go);
diff --git a/Templates/BaseGame/game/core/utility/scripts/helperFunctions.tscript b/Templates/BaseGame/game/core/utility/scripts/helperFunctions.tscript
index 29d2f5df6..ee7378bf8 100644
--- a/Templates/BaseGame/game/core/utility/scripts/helperFunctions.tscript
+++ b/Templates/BaseGame/game/core/utility/scripts/helperFunctions.tscript
@@ -524,7 +524,9 @@ function loadDir(%dir)
 
 function loadDirs(%dirPath)
 {
-   %dirPath = nextToken(%dirPath, token, ";");
+   %dirPath = nextToken(%dirPath, "$token", ";");
+   %token = $token;
+
    if (%dirPath !$= "")
       loadDirs(%dirPath);
 
diff --git a/Templates/BaseGame/game/core/utility/scripts/parseArgs.tscript b/Templates/BaseGame/game/core/utility/scripts/parseArgs.tscript
index 51975d635..d5a098c90 100644
--- a/Templates/BaseGame/game/core/utility/scripts/parseArgs.tscript
+++ b/Templates/BaseGame/game/core/utility/scripts/parseArgs.tscript
@@ -67,28 +67,28 @@ function parseArgs()
             $isDedicated = true;
             $Server::Dedicated = true;
             enableWinConsole(true);
-            $argUsed[%i]++;
+            $argUsed[$i]++;
             
                   //--------------------
          case "-mission":
-            $argUsed[%i]++;
+            $argUsed[$i]++;
             if ($hasNextArg) 
             {
                $missionArg = $nextArg;
-               $argUsed[%i+1]++;
-               %i++;
+               $argUsed[$i+1]++;
+               $i++;
             }
             else
                error("Error: Missing Command Line argument. Usage: -mission <filename>");
 
          //--------------------
          case "-connect":
-            $argUsed[%i]++;
+            $argUsed[$i]++;
             if ($hasNextArg) 
             {
                $JoinGameAddress = $nextArg;
-               $argUsed[%i+1]++;
-               %i++;
+               $argUsed[$i+1]++;
+               $i++;
             }
             else
                error("Error: Missing Command Line argument. Usage: -connect <ip_address>");
@@ -271,9 +271,9 @@ function parseArgs()
                {
                   $levelToLoad = $nextArg @ " ";
                   
-                  for(%i = $i + 2; %i < $Game::argc; %i++)
+                  for(%j = $i + 2; %j < $Game::argc; %j++)
                   {
-                     $arg = $Game::argv[%i];
+                     $arg = $Game::argv[%j];
                      %hasExt = strpos($arg, ".mis");
                      
                      if(%hasExt == -1)
@@ -329,30 +329,30 @@ function parseArgs()
             
          case "-fullscreen":
             $cliFullscreen = true;
-            $argUsed[%i]++;
+            $argUsed[$i]++;
 
          case "-windowed":
             $cliFullscreen = false;
-            $argUsed[%i]++;
+            $argUsed[$i]++;
 
          case "-openGL":
             $pref::Video::displayDevice = "OpenGL";
-            $argUsed[%i]++;
+            $argUsed[$i]++;
 
          case "-directX":
             $pref::Video::displayDevice = "D3D";
-            $argUsed[%i]++;
+            $argUsed[$i]++;
 
          case "-autoVideo":
             $pref::Video::displayDevice = "";
-            $argUsed[%i]++;
+            $argUsed[$i]++;
 
          case "-prefs":
-            $argUsed[%i]++;
+            $argUsed[$i]++;
             if ($hasNextArg) {
                exec($nextArg, true, true);
-               $argUsed[%i+1]++;
-               %i++;
+               $argUsed[$i+1]++;
+               $i++;
             }
             else
                error("Error: Missing Command Line argument. Usage: -prefs <path/script." @ $TorqueScriptFileExtension @ ">");
diff --git a/Templates/BaseGame/game/core/utility/scripts/scene.tscript b/Templates/BaseGame/game/core/utility/scripts/scene.tscript
index 795d541f3..4062c4749 100644
--- a/Templates/BaseGame/game/core/utility/scripts/scene.tscript
+++ b/Templates/BaseGame/game/core/utility/scripts/scene.tscript
@@ -1,8 +1,5 @@
 function callGamemodeFunction(%gameModeFuncName, %arg0, %arg1, %arg2, %arg3, %arg4, %arg5, %arg6)
 {
-   if(%data !$= "")
-      %data = "\""@%data@"\"";
-      
    %activeSceneCount = getSceneCount();
       
    %hasGameMode = 0;
diff --git a/Templates/BaseGame/game/data/ExampleModule/GUIs/ExampleGUI.gui b/Templates/BaseGame/game/data/ExampleModule/GUIs/ExampleGUI.gui
index 48bf13f92..396b5b291 100644
--- a/Templates/BaseGame/game/data/ExampleModule/GUIs/ExampleGUI.gui
+++ b/Templates/BaseGame/game/data/ExampleModule/GUIs/ExampleGUI.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(ExampleGUI) 
+$guiContent = new GuiControl(ExampleGUI) 
 {
     position = "0 0";
 	extent = "100 100";
diff --git a/Templates/BaseGame/game/data/defaults.tscript b/Templates/BaseGame/game/data/defaults.tscript
index eaea83a8d..c4512418e 100644
--- a/Templates/BaseGame/game/data/defaults.tscript
+++ b/Templates/BaseGame/game/data/defaults.tscript
@@ -25,7 +25,7 @@ $sceneLighting::cacheSize = 20000;
 $sceneLighting::purgeMethod = "lastCreated";
 $sceneLighting::cacheLighting = 1;
 
-$pref::Video::displayDevice = "D3D11";
+$pref::Video::displayDevice = ($platform $= "windows") ? "D3D11" : "OpenGL";
 $pref::Video::disableVerticalSync = 1;
 $pref::Video::defaultFenceCount = 0;
 $pref::Video::screenShotSession = 0;
diff --git a/Templates/BaseGame/game/data/gameUI/GUIs/playGui.gui b/Templates/BaseGame/game/data/gameUI/GUIs/playGui.gui
index e9522b42f..4783b51a7 100644
--- a/Templates/BaseGame/game/data/gameUI/GUIs/playGui.gui
+++ b/Templates/BaseGame/game/data/gameUI/GUIs/playGui.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GameTSCtrl(PlayGui) {
+$guiContent = new GameTSCtrl(PlayGui) {
       cameraZRot = "0";
       forceFOV = "0";
       reflectPriority = "1";
diff --git a/Templates/BaseGame/game/data/ui/guis/IODropdownDlg.ed.gui b/Templates/BaseGame/game/data/ui/guis/IODropdownDlg.ed.gui
index 5fa0093da..6a98fe6d7 100644
--- a/Templates/BaseGame/game/data/ui/guis/IODropdownDlg.ed.gui
+++ b/Templates/BaseGame/game/data/ui/guis/IODropdownDlg.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(IODropdownDlg) {
+$guiContent = new GuiControl(IODropdownDlg) {
 	profile = "GuiDefaultProfile";
 	horizSizing = "width";
 	vertSizing = "height";
diff --git a/Templates/BaseGame/game/data/ui/guis/RecordingsDlg.gui b/Templates/BaseGame/game/data/ui/guis/RecordingsDlg.gui
index 0e863fff5..c13008f11 100644
--- a/Templates/BaseGame/game/data/ui/guis/RecordingsDlg.gui
+++ b/Templates/BaseGame/game/data/ui/guis/RecordingsDlg.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(recordingsDlg) {
+$guiContent = new GuiControl(recordingsDlg) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 8";
diff --git a/Templates/BaseGame/game/data/ui/guis/chooseLevelDlg.gui b/Templates/BaseGame/game/data/ui/guis/chooseLevelDlg.gui
index 9b4771717..8d92639fb 100644
--- a/Templates/BaseGame/game/data/ui/guis/chooseLevelDlg.gui
+++ b/Templates/BaseGame/game/data/ui/guis/chooseLevelDlg.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(ChooseLevelDlg) {
+$guiContent = new GuiControl(ChooseLevelDlg) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 8";
diff --git a/Templates/BaseGame/game/data/ui/guis/guiMusicPlayer.gui b/Templates/BaseGame/game/data/ui/guis/guiMusicPlayer.gui
index 291f3a356..cfd2c3e96 100644
--- a/Templates/BaseGame/game/data/ui/guis/guiMusicPlayer.gui
+++ b/Templates/BaseGame/game/data/ui/guis/guiMusicPlayer.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(GuiMusicPlayer) {
+$guiContent = new GuiControl(GuiMusicPlayer) {
    isContainer = "1";
    Profile = "GuiWindowProfile";
    HorizSizing = "right";
diff --git a/Templates/BaseGame/game/data/ui/guis/joinServerMenu.gui b/Templates/BaseGame/game/data/ui/guis/joinServerMenu.gui
index a45d5d3ce..d84a381b2 100644
--- a/Templates/BaseGame/game/data/ui/guis/joinServerMenu.gui
+++ b/Templates/BaseGame/game/data/ui/guis/joinServerMenu.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(JoinServerMenu) {
+$guiContent = new GuiControl(JoinServerMenu) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/data/ui/guis/loadingGui.gui b/Templates/BaseGame/game/data/ui/guis/loadingGui.gui
index b0af3e66e..d525e5931 100644
--- a/Templates/BaseGame/game/data/ui/guis/loadingGui.gui
+++ b/Templates/BaseGame/game/data/ui/guis/loadingGui.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiChunkedBitmapCtrl(LoadingGui) {
+$guiContent = new GuiChunkedBitmapCtrl(LoadingGui) {
    bitmap = "data/ui/images/background-dark.png";
    useVariable = "0";
    tile = "0";
diff --git a/Templates/BaseGame/game/data/ui/guis/mainMenu.gui b/Templates/BaseGame/game/data/ui/guis/mainMenu.gui
index 9f4b8ec3b..d7f7fc3a3 100644
--- a/Templates/BaseGame/game/data/ui/guis/mainMenu.gui
+++ b/Templates/BaseGame/game/data/ui/guis/mainMenu.gui
@@ -1,7 +1,7 @@
 exec( "tools/gui/profiles.ed.tscript" );
 
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiChunkedBitmapCtrl(MainMenuGui) {
+$guiContent = new GuiChunkedBitmapCtrl(MainMenuGui) {
    bitmap = "data/ui/images/background-dark.png";
    useVariable = "0";
    tile = "0";
diff --git a/Templates/BaseGame/game/data/ui/guis/messageBoxDlg.gui b/Templates/BaseGame/game/data/ui/guis/messageBoxDlg.gui
index 8dd356d97..a78ae98d5 100644
--- a/Templates/BaseGame/game/data/ui/guis/messageBoxDlg.gui
+++ b/Templates/BaseGame/game/data/ui/guis/messageBoxDlg.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(MessageBoxDlg) {
+$guiContent = new GuiControl(MessageBoxDlg) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 8";
diff --git a/Templates/BaseGame/game/data/ui/guis/netGraphGui.gui b/Templates/BaseGame/game/data/ui/guis/netGraphGui.gui
index b034a447e..be8ba1233 100644
--- a/Templates/BaseGame/game/data/ui/guis/netGraphGui.gui
+++ b/Templates/BaseGame/game/data/ui/guis/netGraphGui.gui
@@ -73,7 +73,7 @@ new GuiControlProfile (NetGraphPacketLossProfile)
 };
 
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(NetGraphGui) {
+$guiContent = new GuiControl(NetGraphGui) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/data/ui/guis/optionsDlg.gui b/Templates/BaseGame/game/data/ui/guis/optionsDlg.gui
index 3c78ac116..b2758c32c 100644
--- a/Templates/BaseGame/game/data/ui/guis/optionsDlg.gui
+++ b/Templates/BaseGame/game/data/ui/guis/optionsDlg.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(OptionsDlg) {
+$guiContent = new GuiControl(OptionsDlg) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 8";
diff --git a/Templates/BaseGame/game/data/ui/guis/optionsMenu.gui b/Templates/BaseGame/game/data/ui/guis/optionsMenu.gui
index 5d357e9fd..9b76cb979 100644
--- a/Templates/BaseGame/game/data/ui/guis/optionsMenu.gui
+++ b/Templates/BaseGame/game/data/ui/guis/optionsMenu.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(OptionsMenu) {
+$guiContent = new GuiControl(OptionsMenu) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/data/ui/guis/optionsMenu.tscript b/Templates/BaseGame/game/data/ui/guis/optionsMenu.tscript
index eba6e173b..d22d847c3 100644
--- a/Templates/BaseGame/game/data/ui/guis/optionsMenu.tscript
+++ b/Templates/BaseGame/game/data/ui/guis/optionsMenu.tscript
@@ -276,11 +276,8 @@ function OptionsMenu::applyDisplaySettings(%this)
    // Change the device.
    if ( %newDevice !$= $pref::Video::displayDevice )
    {
-      if ( %testNeedApply )
-         return true;
-         
       $pref::Video::displayDevice = %newDevice;
-      if( %newAdapter !$= getDisplayDeviceInformation() )
+      if( %newDevice !$= getDisplayDeviceInformation() )
          MessageBoxOK( "Change requires restart", "Please restart the game for a display device change to take effect." );
          
       $changingDisplayDevice = %newDevice;
@@ -368,10 +365,7 @@ function OptionsMenu::applyGraphicsSettings(%this)
    // Check the anisotropic filtering.   
    %level = OptionsMenuSettingsList.getCurrentOption(10);
    if ( %level != $pref::Video::defaultAnisotropy )
-   {
-      if ( %testNeedApply )
-         return true;
-                                 
+   {                     
       $pref::Video::defaultAnisotropy = %level;
    }
 
@@ -418,9 +412,6 @@ function updateDisplaySettings()
    if (  %newMode !$= $pref::Video::mode || %newDeviceID != $pref::Video::deviceId ||
          %newVsync != $pref::Video::disableVerticalSync || %newDeviceMode != $pref::Video::deviceMode)
    {
-      if ( %testNeedApply )
-         return true;
-
       //****Edge Case Hack
       // If we're in fullscreen mode and switching to a different monitor at the
       // same resolution and maintaining fullscreen, GFX...WindowTarget::resetMode()
@@ -433,7 +424,7 @@ function updateDisplaySettings()
          $pref::Video::deviceId = %newDeviceID;
          $pref::Video::deviceMode = $Video::ModeBorderless;
          %tmpModeStr = Canvas.getMonitorMode(%newDeviceID, 0);
-         Canvas.setVideoMode(%tmpModeStr.x, %tmpModeStr.y, false, 32, getWord(%tmpModeStr, $WORD::REFRESH), %aa);
+         Canvas.setVideoMode(%tmpModeStr.x, %tmpModeStr.y, false, 32, getWord(%tmpModeStr, $WORD::REFRESH), %newFSAA);
       }
 
       $pref::Video::mode = %newMode;
@@ -459,6 +450,8 @@ function OptionsMenu::populateAudioSettingsList(%this)
    %buffer = sfxGetAvailableDevices();
    %count = getRecordCount( %buffer );  
    %audioDriverList = "";
+   %audioProviderList = "";
+   %audioDeviceList = "";
     
    $currentAudioProvider = $currentAudioProvider $= "" ? $pref::SFX::provider : $currentAudioProvider;
    
diff --git a/Templates/BaseGame/game/data/ui/guis/pauseMenu.gui b/Templates/BaseGame/game/data/ui/guis/pauseMenu.gui
index 987493ba9..80d6eb74d 100644
--- a/Templates/BaseGame/game/data/ui/guis/pauseMenu.gui
+++ b/Templates/BaseGame/game/data/ui/guis/pauseMenu.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(PauseMenu) {
+$guiContent = new GuiControl(PauseMenu) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/data/ui/guis/profiler.gui b/Templates/BaseGame/game/data/ui/guis/profiler.gui
index 46628c6df..c6d97a26f 100644
--- a/Templates/BaseGame/game/data/ui/guis/profiler.gui
+++ b/Templates/BaseGame/game/data/ui/guis/profiler.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(ProfilerGui) {
+$guiContent = new GuiControl(ProfilerGui) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/data/ui/guis/profiler.tscript b/Templates/BaseGame/game/data/ui/guis/profiler.tscript
index bc73338bf..402f7b1f1 100644
--- a/Templates/BaseGame/game/data/ui/guis/profiler.tscript
+++ b/Templates/BaseGame/game/data/ui/guis/profiler.tscript
@@ -101,7 +101,7 @@ function showMetics(%var)
 
 GlobalActionMap.bind(keyboard, "ctrl F2", showMetics);
 
-%guiContent = new GuiControl(FrameOverlayGui) {
+$guiContent = new GuiControl(FrameOverlayGui) {
 	profile = "GuiModelessDialogProfile";
 	horizSizing = "right";
 	vertSizing = "bottom";
diff --git a/Templates/BaseGame/game/data/ui/guis/remapConfirmDlg.gui b/Templates/BaseGame/game/data/ui/guis/remapConfirmDlg.gui
index 6e32fd1ec..97f5a55c9 100644
--- a/Templates/BaseGame/game/data/ui/guis/remapConfirmDlg.gui
+++ b/Templates/BaseGame/game/data/ui/guis/remapConfirmDlg.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(RemapConfirmDlg) {
+$guiContent = new GuiControl(RemapConfirmDlg) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 8";
diff --git a/Templates/BaseGame/game/data/ui/guis/remapDlg.gui b/Templates/BaseGame/game/data/ui/guis/remapDlg.gui
index 71832d81c..900ae8e95 100644
--- a/Templates/BaseGame/game/data/ui/guis/remapDlg.gui
+++ b/Templates/BaseGame/game/data/ui/guis/remapDlg.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(RemapDlg) {
+$guiContent = new GuiControl(RemapDlg) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 8";
diff --git a/Templates/BaseGame/game/data/ui/guis/startupGui.gui b/Templates/BaseGame/game/data/ui/guis/startupGui.gui
index ad7afcf63..fd42c23bd 100644
--- a/Templates/BaseGame/game/data/ui/guis/startupGui.gui
+++ b/Templates/BaseGame/game/data/ui/guis/startupGui.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiFadeinBitmapCtrl(StartupGui) {
+$guiContent = new GuiFadeinBitmapCtrl(StartupGui) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/main.tscript.in b/Templates/BaseGame/game/main.tscript.in
index f2cae0249..5d5569e7d 100644
--- a/Templates/BaseGame/game/main.tscript.in
+++ b/Templates/BaseGame/game/main.tscript.in
@@ -37,9 +37,8 @@ else
    //If nothing else set a main menu, try to do so now
    if(!isObject(Canvas.getContent()))
    {
-      %mainMenuGUI = ProjectSettings.value("UI/mainMenuName");
-      if (isObject( %mainMenuGUI ))
-         Canvas.setContent( %mainMenuGUI );
+      if (isObject( ProjectSettings.value("UI/mainMenuName") ))
+         Canvas.setContent( ProjectSettings.value("UI/mainMenuName") );
    }
 }
 
diff --git a/Templates/BaseGame/game/tools/MainEditor/guis/MainEditorWindow.gui b/Templates/BaseGame/game/tools/MainEditor/guis/MainEditorWindow.gui
index 42c5eca6e..6d40a9164 100644
--- a/Templates/BaseGame/game/tools/MainEditor/guis/MainEditorWindow.gui
+++ b/Templates/BaseGame/game/tools/MainEditor/guis/MainEditorWindow.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiContainer(NewEditorGui) {
+$guiContent = new GuiContainer(NewEditorGui) {
    margin = "0 0 0 0";
    padding = "0 0 0 0";
    anchorTop = "1";
diff --git a/Templates/BaseGame/game/tools/VPathEditor/GUI/VPathEditorToolbar.gui b/Templates/BaseGame/game/tools/VPathEditor/GUI/VPathEditorToolbar.gui
index 76fa8aff7..57651df52 100644
--- a/Templates/BaseGame/game/tools/VPathEditor/GUI/VPathEditorToolbar.gui
+++ b/Templates/BaseGame/game/tools/VPathEditor/GUI/VPathEditorToolbar.gui
@@ -3,7 +3,7 @@
 // Copyright (C) - Violent Tulip
 //-----------------------------------------------------------------------------
 
-%guiContent = new GuiControl(VPathEditorToolbar)
+$guiContent = new GuiControl(VPathEditorToolbar)
 {
     canSaveDynamicFields = "0";
     internalName = "VPathEditorToolbar";
diff --git a/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditor.gui b/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditor.gui
index 091288fe0..bb6f76885 100644
--- a/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditor.gui
+++ b/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditor.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(VerveEditorGui) {
+$guiContent = new GuiControl(VerveEditorGui) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditorGroupBuilder.gui b/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditorGroupBuilder.gui
index 7b041f7f6..19076f551 100644
--- a/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditorGroupBuilder.gui
+++ b/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditorGroupBuilder.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(VerveEditorGroupBuilderGUI) {
+$guiContent = new GuiControl(VerveEditorGroupBuilderGUI) {
    isContainer = "1";
    Profile = "GuiDefaultProfile";
    HorizSizing = "right";
diff --git a/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditorImportPathNodes.gui b/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditorImportPathNodes.gui
index 6ec7b430c..9309ee64f 100644
--- a/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditorImportPathNodes.gui
+++ b/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditorImportPathNodes.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(VerveEditorImportPathNodesGUI) {
+$guiContent = new GuiControl(VerveEditorImportPathNodesGUI) {
    isContainer = "1";
    Profile = "GuiDefaultProfile";
    HorizSizing = "right";
diff --git a/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditorPreferences.gui b/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditorPreferences.gui
index 31579a5fb..417f15908 100644
--- a/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditorPreferences.gui
+++ b/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditorPreferences.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(VerveEditorPreferenceGui) {
+$guiContent = new GuiControl(VerveEditorPreferenceGui) {
    canSaveDynamicFields = "0";
    isContainer = "1";
    Profile = "GuiDefaultProfile";
diff --git a/Templates/BaseGame/game/tools/assetBrowser/guis/AssetImportConfigEditor.gui b/Templates/BaseGame/game/tools/assetBrowser/guis/AssetImportConfigEditor.gui
index 4bffe1234..d7844261c 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/guis/AssetImportConfigEditor.gui
+++ b/Templates/BaseGame/game/tools/assetBrowser/guis/AssetImportConfigEditor.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(AssetImportConfigEditor) {
+$guiContent = new GuiControl(AssetImportConfigEditor) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/assetBrowser/guis/GameObjectCreator.gui b/Templates/BaseGame/game/tools/assetBrowser/guis/GameObjectCreator.gui
index 6ade66e95..4b1894812 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/guis/GameObjectCreator.gui
+++ b/Templates/BaseGame/game/tools/assetBrowser/guis/GameObjectCreator.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(GameObjectCreator) {
+$guiContent = new GuiControl(GameObjectCreator) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/assetBrowser/guis/addModuleWindow.gui b/Templates/BaseGame/game/tools/assetBrowser/guis/addModuleWindow.gui
index e8f35a13a..d6f2acc1f 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/guis/addModuleWindow.gui
+++ b/Templates/BaseGame/game/tools/assetBrowser/guis/addModuleWindow.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(AssetBrowser_AddModule) {
+$guiContent = new GuiControl(AssetBrowser_AddModule) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/assetBrowser/guis/addPackageWindow.gui b/Templates/BaseGame/game/tools/assetBrowser/guis/addPackageWindow.gui
index 48a48f5be..1bf51e529 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/guis/addPackageWindow.gui
+++ b/Templates/BaseGame/game/tools/assetBrowser/guis/addPackageWindow.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(AssetBrowser_AddPackage) {
+$guiContent = new GuiControl(AssetBrowser_AddPackage) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/assetBrowser/guis/assetBrowser.gui b/Templates/BaseGame/game/tools/assetBrowser/guis/assetBrowser.gui
index 40d772206..8a831a68d 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/guis/assetBrowser.gui
+++ b/Templates/BaseGame/game/tools/assetBrowser/guis/assetBrowser.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(AssetBrowser) {
+$guiContent = new GuiControl(AssetBrowser) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/assetBrowser/guis/assetImport.gui b/Templates/BaseGame/game/tools/assetBrowser/guis/assetImport.gui
index 1e4913025..5e8ab8dec 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/guis/assetImport.gui
+++ b/Templates/BaseGame/game/tools/assetBrowser/guis/assetImport.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(AssetImportCtrl) {
+$guiContent = new GuiControl(AssetImportCtrl) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/assetBrowser/guis/assetImportLog.gui b/Templates/BaseGame/game/tools/assetBrowser/guis/assetImportLog.gui
index 14935f2b1..81aca8284 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/guis/assetImportLog.gui
+++ b/Templates/BaseGame/game/tools/assetBrowser/guis/assetImportLog.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(AssetBrowserImportLog) {
+$guiContent = new GuiControl(AssetBrowserImportLog) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/assetBrowser/guis/assetNameEdit.gui b/Templates/BaseGame/game/tools/assetBrowser/guis/assetNameEdit.gui
index e99e12118..4e6ddfe69 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/guis/assetNameEdit.gui
+++ b/Templates/BaseGame/game/tools/assetBrowser/guis/assetNameEdit.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(AssetBrowser_assetNameEdit) {
+$guiContent = new GuiControl(AssetBrowser_assetNameEdit) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/assetBrowser/guis/assetPreviewButtonsTemplate.gui b/Templates/BaseGame/game/tools/assetBrowser/guis/assetPreviewButtonsTemplate.gui
index 2ee3b1cdc..803f71ba5 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/guis/assetPreviewButtonsTemplate.gui
+++ b/Templates/BaseGame/game/tools/assetBrowser/guis/assetPreviewButtonsTemplate.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(AssetPreviewButtonsTemplate) {
+$guiContent = new GuiControl(AssetPreviewButtonsTemplate) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/assetBrowser/guis/createNewCollectionSet.gui b/Templates/BaseGame/game/tools/assetBrowser/guis/createNewCollectionSet.gui
index faa48bd6e..9317d8bec 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/guis/createNewCollectionSet.gui
+++ b/Templates/BaseGame/game/tools/assetBrowser/guis/createNewCollectionSet.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(CreateNewCollectionSetCtrl) {
+$guiContent = new GuiControl(CreateNewCollectionSetCtrl) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/assetBrowser/guis/editAsset.gui b/Templates/BaseGame/game/tools/assetBrowser/guis/editAsset.gui
index 180b4b5d7..9ac2e2ef2 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/guis/editAsset.gui
+++ b/Templates/BaseGame/game/tools/assetBrowser/guis/editAsset.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(AssetBrowser_editAsset) {
+$guiContent = new GuiControl(AssetBrowser_editAsset) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/assetBrowser/guis/editModule.gui b/Templates/BaseGame/game/tools/assetBrowser/guis/editModule.gui
index 18927399f..c2a59f6ef 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/guis/editModule.gui
+++ b/Templates/BaseGame/game/tools/assetBrowser/guis/editModule.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(AssetBrowser_editModule) {
+$guiContent = new GuiControl(AssetBrowser_editModule) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/assetBrowser/guis/looseFileAudit.gui b/Templates/BaseGame/game/tools/assetBrowser/guis/looseFileAudit.gui
index b4d6d1cce..2bc3d46ee 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/guis/looseFileAudit.gui
+++ b/Templates/BaseGame/game/tools/assetBrowser/guis/looseFileAudit.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(LooseFileAudit) {
+$guiContent = new GuiControl(LooseFileAudit) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/assetBrowser/guis/newAsset.gui b/Templates/BaseGame/game/tools/assetBrowser/guis/newAsset.gui
index e7efb40d4..38d7b2449 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/guis/newAsset.gui
+++ b/Templates/BaseGame/game/tools/assetBrowser/guis/newAsset.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(AssetBrowser_newAsset) {
+$guiContent = new GuiControl(AssetBrowser_newAsset) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/assetBrowser/guis/newComponentAsset.gui b/Templates/BaseGame/game/tools/assetBrowser/guis/newComponentAsset.gui
index 37e6fc4a1..9fc756fd1 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/guis/newComponentAsset.gui
+++ b/Templates/BaseGame/game/tools/assetBrowser/guis/newComponentAsset.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(AssetBrowser_newComponentAsset) {
+$guiContent = new GuiControl(AssetBrowser_newComponentAsset) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/assetBrowser/guis/newFolder.gui b/Templates/BaseGame/game/tools/assetBrowser/guis/newFolder.gui
index ff1509cb4..7030b5e40 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/guis/newFolder.gui
+++ b/Templates/BaseGame/game/tools/assetBrowser/guis/newFolder.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(AssetBrowser_newFolder) {
+$guiContent = new GuiControl(AssetBrowser_newFolder) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/assetBrowser/guis/selectModule.gui b/Templates/BaseGame/game/tools/assetBrowser/guis/selectModule.gui
index ed907fbd9..9795c8a74 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/guis/selectModule.gui
+++ b/Templates/BaseGame/game/tools/assetBrowser/guis/selectModule.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(AssetBrowser_SelectModule) {
+$guiContent = new GuiControl(AssetBrowser_SelectModule) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/assetBrowser/guis/selectPackage.gui b/Templates/BaseGame/game/tools/assetBrowser/guis/selectPackage.gui
index c31dbf53e..a74dbf594 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/guis/selectPackage.gui
+++ b/Templates/BaseGame/game/tools/assetBrowser/guis/selectPackage.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(AssetBrowser_SelectPackage) {
+$guiContent = new GuiControl(AssetBrowser_SelectPackage) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/assetBrowser/guis/selectPath.gui b/Templates/BaseGame/game/tools/assetBrowser/guis/selectPath.gui
index 21949c518..5bdb39b21 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/guis/selectPath.gui
+++ b/Templates/BaseGame/game/tools/assetBrowser/guis/selectPath.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(SelectAssetPath) {
+$guiContent = new GuiControl(SelectAssetPath) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/templateFiles/guiFile.gui.template b/Templates/BaseGame/game/tools/assetBrowser/scripts/templateFiles/guiFile.gui.template
index 63dc722d2..5224885a7 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/templateFiles/guiFile.gui.template
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/templateFiles/guiFile.gui.template
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(@@) 
+$guiContent = new GuiControl(@@) 
 {
     position = "0 0";
 	extent = "100 100";
diff --git a/Templates/BaseGame/game/tools/componentEditor/gui/TypeMaskFieldGui.gui b/Templates/BaseGame/game/tools/componentEditor/gui/TypeMaskFieldGui.gui
index a18277419..a5ce9d51b 100644
--- a/Templates/BaseGame/game/tools/componentEditor/gui/TypeMaskFieldGui.gui
+++ b/Templates/BaseGame/game/tools/componentEditor/gui/TypeMaskFieldGui.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(TypeMaskFieldGui) {
+$guiContent = new GuiControl(TypeMaskFieldGui) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/componentEditor/gui/superToolTipDlg.ed.gui b/Templates/BaseGame/game/tools/componentEditor/gui/superToolTipDlg.ed.gui
index ef506941a..a0a79e60b 100644
--- a/Templates/BaseGame/game/tools/componentEditor/gui/superToolTipDlg.ed.gui
+++ b/Templates/BaseGame/game/tools/componentEditor/gui/superToolTipDlg.ed.gui
@@ -1,4 +1,4 @@
-%guiContent = new GuiControl(SuperTooltipDlg) {
+$guiContent = new GuiControl(SuperTooltipDlg) {
    canSaveDynamicFields = "0";
    Profile = "GuiTransparentProfileModeless";
    class = "SuperTooltip";
diff --git a/Templates/BaseGame/game/tools/convexEditor/convexEditorGui.gui b/Templates/BaseGame/game/tools/convexEditor/convexEditorGui.gui
index f28b3b5b4..07ecfc7be 100644
--- a/Templates/BaseGame/game/tools/convexEditor/convexEditorGui.gui
+++ b/Templates/BaseGame/game/tools/convexEditor/convexEditorGui.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiConvexEditorCtrl(ConvexEditorGui) {
+$guiContent = new GuiConvexEditorCtrl(ConvexEditorGui) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/convexEditor/convexEditorSettingsTab.ed.gui b/Templates/BaseGame/game/tools/convexEditor/convexEditorSettingsTab.ed.gui
index 3cd3a1ebd..b77d68f85 100644
--- a/Templates/BaseGame/game/tools/convexEditor/convexEditorSettingsTab.ed.gui
+++ b/Templates/BaseGame/game/tools/convexEditor/convexEditorSettingsTab.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(ConvexEditorSettingsTab,EditorGuiGroup) {
+$guiContent = new GuiControl(ConvexEditorSettingsTab,EditorGuiGroup) {
    isContainer = "1";
    Profile = "ToolsGuiDefaultProfile";
    HorizSizing = "right";
diff --git a/Templates/BaseGame/game/tools/convexEditor/convexEditorToolbar.ed.gui b/Templates/BaseGame/game/tools/convexEditor/convexEditorToolbar.ed.gui
index 2e737c942..aad716277 100644
--- a/Templates/BaseGame/game/tools/convexEditor/convexEditorToolbar.ed.gui
+++ b/Templates/BaseGame/game/tools/convexEditor/convexEditorToolbar.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(convexEditorToolbar, EditorGuiGroup) {
+$guiContent = new GuiControl(convexEditorToolbar, EditorGuiGroup) {
    canSaveDynamicFields = "0";
    internalName = "";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/datablockEditor/DatablockEditorCreatePrompt.ed.gui b/Templates/BaseGame/game/tools/datablockEditor/DatablockEditorCreatePrompt.ed.gui
index e8c3b5adb..5f1783390 100644
--- a/Templates/BaseGame/game/tools/datablockEditor/DatablockEditorCreatePrompt.ed.gui
+++ b/Templates/BaseGame/game/tools/datablockEditor/DatablockEditorCreatePrompt.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(DatablockEditorCreatePrompt,EditorGuiGroup) {
+$guiContent = new GuiControl(DatablockEditorCreatePrompt,EditorGuiGroup) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/datablockEditor/DatablockEditorInspectorWindow.ed.gui b/Templates/BaseGame/game/tools/datablockEditor/DatablockEditorInspectorWindow.ed.gui
index 5a68c4df2..2fce2fb25 100644
--- a/Templates/BaseGame/game/tools/datablockEditor/DatablockEditorInspectorWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/datablockEditor/DatablockEditorInspectorWindow.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl() {
+$guiContent = new GuiControl() {
    isContainer = "1";
    Profile = "ToolsGuiDefaultProfile";
    HorizSizing = "right";
diff --git a/Templates/BaseGame/game/tools/datablockEditor/DatablockEditorTreeWindow.ed.gui b/Templates/BaseGame/game/tools/datablockEditor/DatablockEditorTreeWindow.ed.gui
index d07a4158d..67d71544d 100644
--- a/Templates/BaseGame/game/tools/datablockEditor/DatablockEditorTreeWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/datablockEditor/DatablockEditorTreeWindow.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl() {
+$guiContent = new GuiControl() {
    isContainer = "1";
    Profile = "ToolsGuiDefaultProfile";
    HorizSizing = "right";
diff --git a/Templates/BaseGame/game/tools/debugger/gui/breakConditionDlg.ed.gui b/Templates/BaseGame/game/tools/debugger/gui/breakConditionDlg.ed.gui
index d6355e58f..9a5c53881 100644
--- a/Templates/BaseGame/game/tools/debugger/gui/breakConditionDlg.ed.gui
+++ b/Templates/BaseGame/game/tools/debugger/gui/breakConditionDlg.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(DebuggerBreakConditionDlg, EditorGuiGroup) {
+$guiContent = new GuiControl(DebuggerBreakConditionDlg, EditorGuiGroup) {
    profile = "ToolsGuiDefaultProfile";
    horizSizing = "right";
    vertSizing = "bottom";
diff --git a/Templates/BaseGame/game/tools/debugger/gui/connectDlg.ed.gui b/Templates/BaseGame/game/tools/debugger/gui/connectDlg.ed.gui
index 927312fed..5d72d44ee 100644
--- a/Templates/BaseGame/game/tools/debugger/gui/connectDlg.ed.gui
+++ b/Templates/BaseGame/game/tools/debugger/gui/connectDlg.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(DebuggerConnectDlg, EditorGuiGroup) {
+$guiContent = new GuiControl(DebuggerConnectDlg, EditorGuiGroup) {
    profile = "ToolsGuiDefaultProfile";
    horizSizing = "right";
    vertSizing = "bottom";
diff --git a/Templates/BaseGame/game/tools/debugger/gui/debugger.ed.gui b/Templates/BaseGame/game/tools/debugger/gui/debugger.ed.gui
index 616a8f0fb..6efe6786c 100644
--- a/Templates/BaseGame/game/tools/debugger/gui/debugger.ed.gui
+++ b/Templates/BaseGame/game/tools/debugger/gui/debugger.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(DebuggerGui, EditorGuiGroup) {
+$guiContent = new GuiControl(DebuggerGui, EditorGuiGroup) {
    profile = "ToolsGuiWindowProfile";
    horizSizing = "right";
    vertSizing = "bottom";
diff --git a/Templates/BaseGame/game/tools/debugger/gui/editWatchDlg.ed.gui b/Templates/BaseGame/game/tools/debugger/gui/editWatchDlg.ed.gui
index d1d5ebe4e..e53a8c7c8 100644
--- a/Templates/BaseGame/game/tools/debugger/gui/editWatchDlg.ed.gui
+++ b/Templates/BaseGame/game/tools/debugger/gui/editWatchDlg.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(DebuggerEditWatchDlg, EditorGuiGroup) {
+$guiContent = new GuiControl(DebuggerEditWatchDlg, EditorGuiGroup) {
    profile = "ToolsGuiDefaultProfile";
    horizSizing = "right";
    vertSizing = "bottom";
diff --git a/Templates/BaseGame/game/tools/debugger/gui/findDlg.ed.gui b/Templates/BaseGame/game/tools/debugger/gui/findDlg.ed.gui
index 5a74273d5..a16b9784b 100644
--- a/Templates/BaseGame/game/tools/debugger/gui/findDlg.ed.gui
+++ b/Templates/BaseGame/game/tools/debugger/gui/findDlg.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(DebuggerFindDlg, EditorGuiGroup) {
+$guiContent = new GuiControl(DebuggerFindDlg, EditorGuiGroup) {
    profile = "ToolsGuiDefaultProfile";
    horizSizing = "right";
    vertSizing = "bottom";
diff --git a/Templates/BaseGame/game/tools/debugger/gui/watchDlg.ed.gui b/Templates/BaseGame/game/tools/debugger/gui/watchDlg.ed.gui
index 898563807..2bd913b85 100644
--- a/Templates/BaseGame/game/tools/debugger/gui/watchDlg.ed.gui
+++ b/Templates/BaseGame/game/tools/debugger/gui/watchDlg.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(DebuggerWatchDlg, EditorGuiGroup) {
+$guiContent = new GuiControl(DebuggerWatchDlg, EditorGuiGroup) {
    profile = "ToolsGuiDefaultProfile";
    horizSizing = "right";
    vertSizing = "bottom";
diff --git a/Templates/BaseGame/game/tools/decalEditor/decalEditorGui.gui b/Templates/BaseGame/game/tools/decalEditor/decalEditorGui.gui
index 919291d2c..816bb0cc2 100644
--- a/Templates/BaseGame/game/tools/decalEditor/decalEditorGui.gui
+++ b/Templates/BaseGame/game/tools/decalEditor/decalEditorGui.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiDecalEditorCtrl(DecalEditorGui) {
+$guiContent = new GuiDecalEditorCtrl(DecalEditorGui) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/forestEditor/forestEditToolbar.ed.gui b/Templates/BaseGame/game/tools/forestEditor/forestEditToolbar.ed.gui
index 782383121..5b6911a9b 100644
--- a/Templates/BaseGame/game/tools/forestEditor/forestEditToolbar.ed.gui
+++ b/Templates/BaseGame/game/tools/forestEditor/forestEditToolbar.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(ForestEditToolbar,EditorGuiGroup) {
+$guiContent = new GuiControl(ForestEditToolbar,EditorGuiGroup) {
    isContainer = "1";
    Profile = "ToolsGuiDefaultProfile";
    HorizSizing = "right";
diff --git a/Templates/BaseGame/game/tools/forestEditor/forestEditorGui.gui b/Templates/BaseGame/game/tools/forestEditor/forestEditorGui.gui
index e46a09f3d..a663c9d0b 100644
--- a/Templates/BaseGame/game/tools/forestEditor/forestEditorGui.gui
+++ b/Templates/BaseGame/game/tools/forestEditor/forestEditorGui.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new ForestEditorCtrl(ForestEditorGui,EditorGuiGroup) {
+$guiContent = new ForestEditorCtrl(ForestEditorGui,EditorGuiGroup) {
    renderMissionArea = "0";
    missionAreaFillColor = "255 0 0 20";
    missionAreaFrameColor = "255 0 0 128";
diff --git a/Templates/BaseGame/game/tools/gui/EditorLoadingGui.gui b/Templates/BaseGame/game/tools/gui/EditorLoadingGui.gui
index 5d7152e44..e5950b677 100644
--- a/Templates/BaseGame/game/tools/gui/EditorLoadingGui.gui
+++ b/Templates/BaseGame/game/tools/gui/EditorLoadingGui.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(EditorLoadingGui,EditorGuiGroup) {
+$guiContent = new GuiControl(EditorLoadingGui,EditorGuiGroup) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/gui/EditorSettingsWindow.ed.gui b/Templates/BaseGame/game/tools/gui/EditorSettingsWindow.ed.gui
index 3d5d939ad..93010d0e1 100644
--- a/Templates/BaseGame/game/tools/gui/EditorSettingsWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/gui/EditorSettingsWindow.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(EditorSettingsWindow,EditorGuiGroup) {
+$guiContent = new GuiControl(EditorSettingsWindow,EditorGuiGroup) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/gui/GuiEaseEditDlg.ed.gui b/Templates/BaseGame/game/tools/gui/GuiEaseEditDlg.ed.gui
index 4c76d8388..abe4422e1 100644
--- a/Templates/BaseGame/game/tools/gui/GuiEaseEditDlg.ed.gui
+++ b/Templates/BaseGame/game/tools/gui/GuiEaseEditDlg.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(GuiEaseEditDlg,EditorGuiGroup) {
+$guiContent = new GuiControl(GuiEaseEditDlg,EditorGuiGroup) {
    isContainer = "1";
    Profile = "ToolsGuiDefaultProfile";
    HorizSizing = "right";
diff --git a/Templates/BaseGame/game/tools/gui/assimpImport.ed.gui b/Templates/BaseGame/game/tools/gui/assimpImport.ed.gui
index a9ba1f768..dcee11033 100644
--- a/Templates/BaseGame/game/tools/gui/assimpImport.ed.gui
+++ b/Templates/BaseGame/game/tools/gui/assimpImport.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(AssimpImportDlg,EditorGuiGroup) {
+$guiContent = new GuiControl(AssimpImportDlg,EditorGuiGroup) {
    isContainer = "1";
    Profile = "ToolsGuiDefaultProfile";
    HorizSizing = "width";
diff --git a/Templates/BaseGame/game/tools/gui/colladaImport.ed.gui b/Templates/BaseGame/game/tools/gui/colladaImport.ed.gui
index d098bffe6..4eb34b486 100644
--- a/Templates/BaseGame/game/tools/gui/colladaImport.ed.gui
+++ b/Templates/BaseGame/game/tools/gui/colladaImport.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(ColladaImportDlg,EditorGuiGroup) {
+$guiContent = new GuiControl(ColladaImportDlg,EditorGuiGroup) {
    isContainer = "1";
    Profile = "ToolsGuiDefaultProfile";
    HorizSizing = "width";
@@ -1754,8 +1754,8 @@ function convertColladaModels(%pattern)
 
 function showImportDialog(%shapePath, %cmd)
 {
-   %this.path = %shapePath;
-   %this.cmd = %cmd;
+   ColladaImportDlg.path = %shapePath;
+   ColladaImportDlg.cmd = %cmd;
 
    if ( fileExt(%shapePath) $= ".dts" || fileExt(%shapePath) $= ".dsq" 
       || fileExt(%shapePath) $= ".dae" || fileExt(%shapePath) $= ".kmz" )
diff --git a/Templates/BaseGame/game/tools/gui/colorPicker.ed.gui b/Templates/BaseGame/game/tools/gui/colorPicker.ed.gui
index 0d4f7a975..f390cf95e 100644
--- a/Templates/BaseGame/game/tools/gui/colorPicker.ed.gui
+++ b/Templates/BaseGame/game/tools/gui/colorPicker.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiColorPickerCtrl(ColorPickerDlg,EditorGuiGroup) {
+$guiContent = new GuiColorPickerCtrl(ColorPickerDlg,EditorGuiGroup) {
    displayMode = "Dropper"; // this makes the background visible
    actionOnMove = "1";
    position = "0 0";
diff --git a/Templates/BaseGame/game/tools/gui/cubemapEditor.gui b/Templates/BaseGame/game/tools/gui/cubemapEditor.gui
index 26ae7877d..d273e13e9 100644
--- a/Templates/BaseGame/game/tools/gui/cubemapEditor.gui
+++ b/Templates/BaseGame/game/tools/gui/cubemapEditor.gui
@@ -1,4 +1,4 @@
-%guiContent = new GuiControl(CubemapEditor) {
+$guiContent = new GuiControl(CubemapEditor) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/gui/fileDialogBase.ed.tscript b/Templates/BaseGame/game/tools/gui/fileDialogBase.ed.tscript
index 9d40e0434..7d36db457 100644
--- a/Templates/BaseGame/game/tools/gui/fileDialogBase.ed.tscript
+++ b/Templates/BaseGame/game/tools/gui/fileDialogBase.ed.tscript
@@ -255,8 +255,7 @@ function FileDialogOkButton::onClick( %this )
 
    // Callback      
    eval( %this.parent.SuccessCallback @ "(\"" @ %fullPath @"\");" );
-   
-   %parent.SuccessCallback = 0;
+   %this.parent.SuccessCallback = 0;
    
    //error("Ok");
    
diff --git a/Templates/BaseGame/game/tools/gui/guiObjectInspector.ed.gui b/Templates/BaseGame/game/tools/gui/guiObjectInspector.ed.gui
index 596e8e216..653fedee3 100644
--- a/Templates/BaseGame/game/tools/gui/guiObjectInspector.ed.gui
+++ b/Templates/BaseGame/game/tools/gui/guiObjectInspector.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiWindowCollapseCtrl() {
+$guiContent = new GuiWindowCollapseCtrl() {
    collapseGroup = "-1";
    collapseGroupNum = "-1";
    resizeWidth = "1";
diff --git a/Templates/BaseGame/game/tools/gui/guiObjectInspector.ed.tscript b/Templates/BaseGame/game/tools/gui/guiObjectInspector.ed.tscript
index 33b65f6bd..28b2d0d68 100644
--- a/Templates/BaseGame/game/tools/gui/guiObjectInspector.ed.tscript
+++ b/Templates/BaseGame/game/tools/gui/guiObjectInspector.ed.tscript
@@ -37,7 +37,7 @@ function inspectObject( %object )
    // Create a new object inspector window.
    exec( "./guiObjectInspector.ed.gui" );
    
-   if( !isObject( %guiContent) )
+   if( !isObject( $guiContent) )
    {
       error( "InspectObject: failed to create GUI from 'guiObjectInspector.ed.gui'" );
       return;
@@ -45,9 +45,9 @@ function inspectObject( %object )
    
    // Initialize the inspector.
    
-   %guiContent.init( %object );
+   $guiContent.init( %object );
       
-   Canvas.getContent().add( %guiContent );
+   Canvas.getContent().add( $guiContent );
 }
 
 //=============================================================================================
diff --git a/Templates/BaseGame/game/tools/gui/materialSelector.ed.gui b/Templates/BaseGame/game/tools/gui/materialSelector.ed.gui
index b3ad85549..a7c36de34 100644
--- a/Templates/BaseGame/game/tools/gui/materialSelector.ed.gui
+++ b/Templates/BaseGame/game/tools/gui/materialSelector.ed.gui
@@ -778,6 +778,8 @@ function MaterialSelector::buildStaticFilters( %this )
    // if you want to add any more containers to staticFilterObjects, here's
    // where to do it
    
+   %filterArray = MaterialSelector-->filterArray;
+
    %staticFilterContainer = new GuiControl (){
       new GuiContainer(){
          profile = "ToolsGuiDefaultProfile";
@@ -1366,7 +1368,7 @@ function MaterialSelector::loadMaterialFilters( %this )
 // create category and update current material if there is one
 function MaterialSelector::createFilter( %this, %filter )
 {
-   if( %filter $= %existingFilters )
+   if( %filter $= "" )
    {
       toolsMessageBoxOK( "Error", "Can not create blank filter.");
       return;
diff --git a/Templates/BaseGame/game/tools/gui/messageBoxes/IODropdownDlg.ed.gui b/Templates/BaseGame/game/tools/gui/messageBoxes/IODropdownDlg.ed.gui
index a65acf0b0..e62771773 100644
--- a/Templates/BaseGame/game/tools/gui/messageBoxes/IODropdownDlg.ed.gui
+++ b/Templates/BaseGame/game/tools/gui/messageBoxes/IODropdownDlg.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(IODropdownDlg) {
+$guiContent = new GuiControl(IODropdownDlg) {
 	profile = "GuiDefaultProfile";
 	horizSizing = "width";
 	vertSizing = "height";
diff --git a/Templates/BaseGame/game/tools/gui/messageBoxes/messageBoxOK.ed.gui b/Templates/BaseGame/game/tools/gui/messageBoxes/messageBoxOK.ed.gui
index f1f2beb76..9ec300d92 100644
--- a/Templates/BaseGame/game/tools/gui/messageBoxes/messageBoxOK.ed.gui
+++ b/Templates/BaseGame/game/tools/gui/messageBoxes/messageBoxOK.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(toolsMessageBoxOKDlg) {
+$guiContent = new GuiControl(toolsMessageBoxOKDlg) {
    profile = "GuiOverlayProfile";
    horizSizing = "width";
    vertSizing = "height";
diff --git a/Templates/BaseGame/game/tools/gui/messageBoxes/messageBoxOKBuy.ed.gui b/Templates/BaseGame/game/tools/gui/messageBoxes/messageBoxOKBuy.ed.gui
index 176f47a1e..befe7e2fe 100644
--- a/Templates/BaseGame/game/tools/gui/messageBoxes/messageBoxOKBuy.ed.gui
+++ b/Templates/BaseGame/game/tools/gui/messageBoxes/messageBoxOKBuy.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(toolsMessageBoxOKBuyDlg) {
+$guiContent = new GuiControl(toolsMessageBoxOKBuyDlg) {
 	profile = "ToolsGuiDefaultProfile";
 	horizSizing = "width";
 	vertSizing = "height";
diff --git a/Templates/BaseGame/game/tools/gui/messageBoxes/messageBoxOKCancel.ed.gui b/Templates/BaseGame/game/tools/gui/messageBoxes/messageBoxOKCancel.ed.gui
index 2fc84fa07..9fb96b373 100644
--- a/Templates/BaseGame/game/tools/gui/messageBoxes/messageBoxOKCancel.ed.gui
+++ b/Templates/BaseGame/game/tools/gui/messageBoxes/messageBoxOKCancel.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(toolsMessageBoxOKCancelDlg) {
+$guiContent = new GuiControl(toolsMessageBoxOKCancelDlg) {
    profile = "GuiOverlayProfile";
    horizSizing = "width";
    vertSizing = "height";
diff --git a/Templates/BaseGame/game/tools/gui/messageBoxes/messageBoxOKCancelDetailsDlg.ed.gui b/Templates/BaseGame/game/tools/gui/messageBoxes/messageBoxOKCancelDetailsDlg.ed.gui
index 83d810b4a..0e38c2e4f 100644
--- a/Templates/BaseGame/game/tools/gui/messageBoxes/messageBoxOKCancelDetailsDlg.ed.gui
+++ b/Templates/BaseGame/game/tools/gui/messageBoxes/messageBoxOKCancelDetailsDlg.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(toolsMessageBoxOKCancelDetailsDlg) {
+$guiContent = new GuiControl(toolsMessageBoxOKCancelDetailsDlg) {
    canSaveDynamicFields = "0";
    Profile = "GuiOverlayProfile";
    HorizSizing = "width";
diff --git a/Templates/BaseGame/game/tools/gui/messageBoxes/messageBoxYesNo.ed.gui b/Templates/BaseGame/game/tools/gui/messageBoxes/messageBoxYesNo.ed.gui
index 83cc0f1b5..d9d5b45bd 100644
--- a/Templates/BaseGame/game/tools/gui/messageBoxes/messageBoxYesNo.ed.gui
+++ b/Templates/BaseGame/game/tools/gui/messageBoxes/messageBoxYesNo.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(toolsMessageBoxYesNoDlg) {
+$guiContent = new GuiControl(toolsMessageBoxYesNoDlg) {
 	profile = "GuiOverlayProfile";
 	horizSizing = "width";
 	vertSizing = "height";
diff --git a/Templates/BaseGame/game/tools/gui/messageBoxes/messageBoxYesNoCancel.ed.gui b/Templates/BaseGame/game/tools/gui/messageBoxes/messageBoxYesNoCancel.ed.gui
index 9a707cdca..89e63cb87 100644
--- a/Templates/BaseGame/game/tools/gui/messageBoxes/messageBoxYesNoCancel.ed.gui
+++ b/Templates/BaseGame/game/tools/gui/messageBoxes/messageBoxYesNoCancel.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(toolsMessageBoxYesNoCancelDlg) {
+$guiContent = new GuiControl(toolsMessageBoxYesNoCancelDlg) {
    canSaveDynamicFields = "0";
    Profile = "GuiOverlayProfile";
    HorizSizing = "width";
diff --git a/Templates/BaseGame/game/tools/gui/messageBoxes/messagePopup.ed.gui b/Templates/BaseGame/game/tools/gui/messageBoxes/messagePopup.ed.gui
index 317bbc7d1..475bb928a 100644
--- a/Templates/BaseGame/game/tools/gui/messageBoxes/messagePopup.ed.gui
+++ b/Templates/BaseGame/game/tools/gui/messageBoxes/messagePopup.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(MessagePopupDlg) {
+$guiContent = new GuiControl(MessagePopupDlg) {
    profile = "GuiDefaultProfile";
    horizSizing = "width";
    vertSizing = "height";
diff --git a/Templates/BaseGame/game/tools/gui/postFxEditor.gui b/Templates/BaseGame/game/tools/gui/postFxEditor.gui
index 4827435da..7d53b9869 100644
--- a/Templates/BaseGame/game/tools/gui/postFxEditor.gui
+++ b/Templates/BaseGame/game/tools/gui/postFxEditor.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(postFXEditor) {
+$guiContent = new GuiControl(postFXEditor) {
    position = "0 0";
    extent = "1920 1200";
    minExtent = "8 8";
diff --git a/Templates/BaseGame/game/tools/gui/profilerGraph.gui b/Templates/BaseGame/game/tools/gui/profilerGraph.gui
index 8e2e2b68f..0a2fc44ab 100644
--- a/Templates/BaseGame/game/tools/gui/profilerGraph.gui
+++ b/Templates/BaseGame/game/tools/gui/profilerGraph.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(ProfilerGraphGui) {
+$guiContent = new GuiControl(ProfilerGraphGui) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/gui/renderTargetVisualizer.ed.gui b/Templates/BaseGame/game/tools/gui/renderTargetVisualizer.ed.gui
index f0f829253..79007fda4 100644
--- a/Templates/BaseGame/game/tools/gui/renderTargetVisualizer.ed.gui
+++ b/Templates/BaseGame/game/tools/gui/renderTargetVisualizer.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(RenderTargetVisualizer) {
+$guiContent = new GuiControl(RenderTargetVisualizer) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/gui/saveChangesMBDlg.ed.gui b/Templates/BaseGame/game/tools/gui/saveChangesMBDlg.ed.gui
index b6bd3641d..3c7e26fd3 100644
--- a/Templates/BaseGame/game/tools/gui/saveChangesMBDlg.ed.gui
+++ b/Templates/BaseGame/game/tools/gui/saveChangesMBDlg.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(toolsMessageBoxSaveChangesDlg, EditorGuiGroup) {
+$guiContent = new GuiControl(toolsMessageBoxSaveChangesDlg, EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Profile = "ToolsGuiDefaultProfile";
    HorizSizing = "width";
diff --git a/Templates/BaseGame/game/tools/gui/scriptEditorDlg.ed.gui b/Templates/BaseGame/game/tools/gui/scriptEditorDlg.ed.gui
index 2eca2d3ba..119e812ea 100644
--- a/Templates/BaseGame/game/tools/gui/scriptEditorDlg.ed.gui
+++ b/Templates/BaseGame/game/tools/gui/scriptEditorDlg.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(ScriptEditorDlg,EditorGuiGroup) {
+$guiContent = new GuiControl(ScriptEditorDlg,EditorGuiGroup) {
    isContainer = "1";
    Profile = "ToolsGuiDefaultNonModalProfile";
    HorizSizing = "width";
diff --git a/Templates/BaseGame/game/tools/gui/simViewDlg.ed.gui b/Templates/BaseGame/game/tools/gui/simViewDlg.ed.gui
index 14bc25b57..2ec6b5a71 100644
--- a/Templates/BaseGame/game/tools/gui/simViewDlg.ed.gui
+++ b/Templates/BaseGame/game/tools/gui/simViewDlg.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(simViewDlg, EditorGuiGroup) {
+$guiContent = new GuiControl(simViewDlg, EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Profile = "ToolsGuiDefaultProfile";
    HorizSizing = "right";
diff --git a/Templates/BaseGame/game/tools/guiEditor/gui/EditorChooseGUI.ed.gui b/Templates/BaseGame/game/tools/guiEditor/gui/EditorChooseGUI.ed.gui
index 02d9e04b3..0187020e5 100644
--- a/Templates/BaseGame/game/tools/guiEditor/gui/EditorChooseGUI.ed.gui
+++ b/Templates/BaseGame/game/tools/guiEditor/gui/EditorChooseGUI.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiChunkedBitmapCtrl(EditorChooseGUI, EditorGuiGroup) {
+$guiContent = new GuiChunkedBitmapCtrl(EditorChooseGUI, EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/guiEditor/gui/guiEditor.ed.gui b/Templates/BaseGame/game/tools/guiEditor/gui/guiEditor.ed.gui
index 9426a7fdd..3c24eb885 100644
--- a/Templates/BaseGame/game/tools/guiEditor/gui/guiEditor.ed.gui
+++ b/Templates/BaseGame/game/tools/guiEditor/gui/guiEditor.ed.gui
@@ -3,7 +3,7 @@
 // Copyright (C) GarageGames.com, Inc.
 //---------------------------------------------------------------------------------------------
 
-%guiContent = new GuiControl(GuiEditorGui, EditorGuiGroup) {
+$guiContent = new GuiControl(GuiEditorGui, EditorGuiGroup) {
    canSaveDynamicFields = "0";
    isContainer = "1";
    Profile = "ToolsGuiDefaultProfile";
diff --git a/Templates/BaseGame/game/tools/guiEditor/gui/guiEditorNewGuiDialog.ed.gui b/Templates/BaseGame/game/tools/guiEditor/gui/guiEditorNewGuiDialog.ed.gui
index 98252410a..1e224911d 100644
--- a/Templates/BaseGame/game/tools/guiEditor/gui/guiEditorNewGuiDialog.ed.gui
+++ b/Templates/BaseGame/game/tools/guiEditor/gui/guiEditorNewGuiDialog.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(GuiEditorNewGuiDialog,EditorGuiGroup) {
+$guiContent = new GuiControl(GuiEditorNewGuiDialog,EditorGuiGroup) {
    isContainer = "1";
    profile = "ToolsGuiOverlayProfile";
    horizSizing = "right";
diff --git a/Templates/BaseGame/game/tools/guiEditor/gui/guiEditorPrefsDlg.ed.gui b/Templates/BaseGame/game/tools/guiEditor/gui/guiEditorPrefsDlg.ed.gui
index 6f901d1a8..5ddf53f6d 100644
--- a/Templates/BaseGame/game/tools/guiEditor/gui/guiEditorPrefsDlg.ed.gui
+++ b/Templates/BaseGame/game/tools/guiEditor/gui/guiEditorPrefsDlg.ed.gui
@@ -1,4 +1,4 @@
-%guiContent = new GuiControl(GuiEditorPrefsDlg, EditorGuiGroup) {
+$guiContent = new GuiControl(GuiEditorPrefsDlg, EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Profile = "ToolsGuiDefaultProfile";
    HorizSizing = "right";
diff --git a/Templates/BaseGame/game/tools/guiEditor/gui/guiEditorSelectDlg.ed.gui b/Templates/BaseGame/game/tools/guiEditor/gui/guiEditorSelectDlg.ed.gui
index 1794a238d..148b77554 100644
--- a/Templates/BaseGame/game/tools/guiEditor/gui/guiEditorSelectDlg.ed.gui
+++ b/Templates/BaseGame/game/tools/guiEditor/gui/guiEditorSelectDlg.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(GuiEditorSelectDlgContainer,EditorGuiGroup) {
+$guiContent = new GuiControl(GuiEditorSelectDlgContainer,EditorGuiGroup) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/guiEditor/scripts/EditorChooseGUI.ed.tscript b/Templates/BaseGame/game/tools/guiEditor/scripts/EditorChooseGUI.ed.tscript
index 698d38bbf..00ec3e024 100644
--- a/Templates/BaseGame/game/tools/guiEditor/scripts/EditorChooseGUI.ed.tscript
+++ b/Templates/BaseGame/game/tools/guiEditor/scripts/EditorChooseGUI.ed.tscript
@@ -49,7 +49,7 @@ function GE_OpenGUIFile()
    
    // The level file should have contained a scenegraph, which should now be in the instant
    // group. And, it should be the only thing in the group.
-   if( !isObject( %guiContent ) )
+   if( !isObject( $guiContent ) )
    {
       toolsMessageBox( getEngineName(),
          "You have loaded a Gui file that was created before this version.  It has been loaded but you must open it manually from the content list dropdown",
@@ -58,7 +58,7 @@ function GE_OpenGUIFile()
       return 0;
    }
 
-   GuiEditContent( %guiContent );
+   GuiEditContent( $guiContent );
 }
 
 function GE_GUIList::onURL(%this, %url)
diff --git a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorCanvas.ed.tscript b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorCanvas.ed.tscript
index 450920e6f..1fbe50c12 100644
--- a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorCanvas.ed.tscript
+++ b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorCanvas.ed.tscript
@@ -281,7 +281,7 @@ function GuiEditCanvas::load( %this, %filename )
    
    // The GUI file should have contained a GUIControl which should now be in the instant
    // group. And, it should be the only thing in the group.
-   if( !isObject( %guiContent ) )
+   if( !isObject( $guiContent ) )
    {
       toolsMessageBox( getEngineName(),
          "You have loaded a Gui file that was created before this version.  It has been loaded but you must open it manually from the content list dropdown",
@@ -289,7 +289,7 @@ function GuiEditCanvas::load( %this, %filename )
       return 0;
    }
 
-   GuiEditor.openForEditing( %guiContent );
+   GuiEditor.openForEditing( $guiContent );
    
    GuiEditorStatusBar.print( "Loaded '" @ %filename @ "'" );
 }
@@ -449,7 +449,7 @@ function GuiEditCanvas::save( %this, %selectedOnly, %noPrompt )
          %fo.writeLine( %beforeNewFileLines[ %i ] );
          
       %fo.writeLine("//--- OBJECT WRITE BEGIN ---");
-      %fo.writeObject(%currentObject, "%guiContent = ");
+      %fo.writeObject(%currentObject, "$guiContent = ");
       %fo.writeLine("//--- OBJECT WRITE END ---");
       
       // Write out captured TorqueScript below Gui object
@@ -488,19 +488,19 @@ function GuiEditCanvas::append( %this )
    
    // Find guiContent.
    
-   if( !isObject( %guiContent ) )
+   if( !isObject( $guiContent ) )
    {
       toolsMessageBox( "Error loading GUI file", "The GUI content controls could not be found.  This function can only be used with files saved by the GUI editor.", "Ok", "Error" );
       return;
    }
    
    if( !GuiEditorContent.getCount() )
-      GuiEditor.openForEditing( %guiContent );
+      GuiEditor.openForEditing( $guiContent );
    else
    {
-      GuiEditor.getCurrentAddSet().add( %guiContent );
-      GuiEditor.readGuides( %guiContent );
-      GuiEditor.onAddNewCtrl( %guiContent );
+      GuiEditor.getCurrentAddSet().add( $guiContent );
+      GuiEditor.readGuides( $guiContent );
+      GuiEditor.onAddNewCtrl( $guiContent );
       GuiEditor.onHierarchyChanged();
    }
    
diff --git a/Templates/BaseGame/game/tools/main.tscript b/Templates/BaseGame/game/tools/main.tscript
index 36c7844c4..e2cfad1b2 100644
--- a/Templates/BaseGame/game/tools/main.tscript
+++ b/Templates/BaseGame/game/tools/main.tscript
@@ -252,7 +252,7 @@ function EditorCreateFakeGameSession(%fileName)
    
    $Game::MissionGroup = "MissionGroup";
 
-   exec(%file);
+   exec(%fileName);
 }
 
 function fastLoadWorldEdit(%val)
diff --git a/Templates/BaseGame/game/tools/materialEditor/gui/MaterialToolbar.ed.gui b/Templates/BaseGame/game/tools/materialEditor/gui/MaterialToolbar.ed.gui
index efc140578..64bf201d7 100644
--- a/Templates/BaseGame/game/tools/materialEditor/gui/MaterialToolbar.ed.gui
+++ b/Templates/BaseGame/game/tools/materialEditor/gui/MaterialToolbar.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(MaterialEditorToolbar) {
+$guiContent = new GuiControl(MaterialEditorToolbar) {
    canSaveDynamicFields = "0";
    internalName = "ShapeEditorToolbar";
    Enabled = "1";
diff --git a/Templates/BaseGame/game/tools/materialEditor/gui/guiMaterialPreviewWindow.ed.gui b/Templates/BaseGame/game/tools/materialEditor/gui/guiMaterialPreviewWindow.ed.gui
index 8b6dedb44..e7606081e 100644
--- a/Templates/BaseGame/game/tools/materialEditor/gui/guiMaterialPreviewWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/materialEditor/gui/guiMaterialPreviewWindow.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl() {
+$guiContent = new GuiControl() {
    canSaveDynamicFields = "0";
    internalName = "MatEdPreviewWindowContainer";
    Enabled = "1";
diff --git a/Templates/BaseGame/game/tools/materialEditor/gui/guiMaterialPropertiesWindow.ed.gui b/Templates/BaseGame/game/tools/materialEditor/gui/guiMaterialPropertiesWindow.ed.gui
index 8882e1728..93a1f190f 100644
--- a/Templates/BaseGame/game/tools/materialEditor/gui/guiMaterialPropertiesWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/materialEditor/gui/guiMaterialPropertiesWindow.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(MaterialEditorGui,EditorGuiGroup) {
+$guiContent = new GuiControl(MaterialEditorGui,EditorGuiGroup) {
    canSaveDynamicFields = "0";
    internalName = "MatEdPropertiesWindowContainer";
    Enabled = "1";
diff --git a/Templates/BaseGame/game/tools/materialEditor/gui/materialInstancesView.ed.gui b/Templates/BaseGame/game/tools/materialEditor/gui/materialInstancesView.ed.gui
index ce5c683de..9e34544b5 100644
--- a/Templates/BaseGame/game/tools/materialEditor/gui/materialInstancesView.ed.gui
+++ b/Templates/BaseGame/game/tools/materialEditor/gui/materialInstancesView.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(MaterialInstanceViewCtrl) {
+$guiContent = new GuiControl(MaterialInstanceViewCtrl) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/meshRoadEditor/meshRoadEditorGui.gui b/Templates/BaseGame/game/tools/meshRoadEditor/meshRoadEditorGui.gui
index 14bc92d2a..6d50e7fbc 100644
--- a/Templates/BaseGame/game/tools/meshRoadEditor/meshRoadEditorGui.gui
+++ b/Templates/BaseGame/game/tools/meshRoadEditor/meshRoadEditorGui.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiMeshRoadEditorCtrl(MeshRoadEditorGui,EditorGuiGroup) {
+$guiContent = new GuiMeshRoadEditorCtrl(MeshRoadEditorGui,EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/meshRoadEditor/meshRoadEditorSettingsTab.gui b/Templates/BaseGame/game/tools/meshRoadEditor/meshRoadEditorSettingsTab.gui
index 81485d307..9b01c4c33 100644
--- a/Templates/BaseGame/game/tools/meshRoadEditor/meshRoadEditorSettingsTab.gui
+++ b/Templates/BaseGame/game/tools/meshRoadEditor/meshRoadEditorSettingsTab.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(MeshRoadEditorSettingsTab,EditorGuiGroup) {
+$guiContent = new GuiControl(MeshRoadEditorSettingsTab,EditorGuiGroup) {
    isContainer = "1";
    Profile = "ToolsGuiDefaultProfile";
    HorizSizing = "right";
diff --git a/Templates/BaseGame/game/tools/meshRoadEditor/meshRoadEditorToolbar.gui b/Templates/BaseGame/game/tools/meshRoadEditor/meshRoadEditorToolbar.gui
index 14444b62d..5266570ae 100644
--- a/Templates/BaseGame/game/tools/meshRoadEditor/meshRoadEditorToolbar.gui
+++ b/Templates/BaseGame/game/tools/meshRoadEditor/meshRoadEditorToolbar.gui
@@ -1,4 +1,4 @@
-%guiContent = new GuiControl(MeshRoadEditorToolbar,EditorGuiGroup) {
+$guiContent = new GuiControl(MeshRoadEditorToolbar,EditorGuiGroup) {
    canSaveDynamicFields = "0";
    internalName = "MeshRoadEditorToolbar";
    Enabled = "1";
diff --git a/Templates/BaseGame/game/tools/missionAreaEditor/missionAreaEditorGui.ed.gui b/Templates/BaseGame/game/tools/missionAreaEditor/missionAreaEditorGui.ed.gui
index 03e8fdfe5..754ec57f6 100644
--- a/Templates/BaseGame/game/tools/missionAreaEditor/missionAreaEditorGui.ed.gui
+++ b/Templates/BaseGame/game/tools/missionAreaEditor/missionAreaEditorGui.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiMissionAreaEditorCtrl(MissionAreaEditorGui, EditorGuiGroup) {
+$guiContent = new GuiMissionAreaEditorCtrl(MissionAreaEditorGui, EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/navEditor/CreateNewNavMeshDlg.gui b/Templates/BaseGame/game/tools/navEditor/CreateNewNavMeshDlg.gui
index 906990409..412eacaa3 100644
--- a/Templates/BaseGame/game/tools/navEditor/CreateNewNavMeshDlg.gui
+++ b/Templates/BaseGame/game/tools/navEditor/CreateNewNavMeshDlg.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(CreateNewNavMeshDlg) {
+$guiContent = new GuiControl(CreateNewNavMeshDlg) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/navEditor/NavEditorConsoleDlg.gui b/Templates/BaseGame/game/tools/navEditor/NavEditorConsoleDlg.gui
index 19c063d7a..4fbdfc100 100644
--- a/Templates/BaseGame/game/tools/navEditor/NavEditorConsoleDlg.gui
+++ b/Templates/BaseGame/game/tools/navEditor/NavEditorConsoleDlg.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiWindowCtrl(NavEditorConsoleDlg) {
+$guiContent = new GuiWindowCtrl(NavEditorConsoleDlg) {
    text = "Nav Console";
    resizeWidth = "1";
    resizeHeight = "1";
diff --git a/Templates/BaseGame/game/tools/navEditor/NavEditorGui.gui b/Templates/BaseGame/game/tools/navEditor/NavEditorGui.gui
index e00dbf991..f415a43fa 100644
--- a/Templates/BaseGame/game/tools/navEditor/NavEditorGui.gui
+++ b/Templates/BaseGame/game/tools/navEditor/NavEditorGui.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiNavEditorCtrl(NavEditorGui, EditorGuiGroup) {
+$guiContent = new GuiNavEditorCtrl(NavEditorGui, EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/navEditor/NavEditorSettingsTab.gui b/Templates/BaseGame/game/tools/navEditor/NavEditorSettingsTab.gui
index 1cbe2a81e..9aafcd0b9 100644
--- a/Templates/BaseGame/game/tools/navEditor/NavEditorSettingsTab.gui
+++ b/Templates/BaseGame/game/tools/navEditor/NavEditorSettingsTab.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiTabPageCtrl(ENavEditorSettingsPage) {
+$guiContent = new GuiTabPageCtrl(ENavEditorSettingsPage) {
    fitBook = "1";
    text = "Navigation Editor";
    maxLength = "1024";
diff --git a/Templates/BaseGame/game/tools/navEditor/NavEditorToolbar.gui b/Templates/BaseGame/game/tools/navEditor/NavEditorToolbar.gui
index b38fd953a..cdee55fb9 100644
--- a/Templates/BaseGame/game/tools/navEditor/NavEditorToolbar.gui
+++ b/Templates/BaseGame/game/tools/navEditor/NavEditorToolbar.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(NavEditorToolbar,EditorGuiGroup) {
+$guiContent = new GuiControl(NavEditorToolbar,EditorGuiGroup) {
    position = "306 0";
    extent = "800 32";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/particleEditor/ParticleEditor.ed.gui b/Templates/BaseGame/game/tools/particleEditor/ParticleEditor.ed.gui
index e24bc379a..9cd6f594c 100644
--- a/Templates/BaseGame/game/tools/particleEditor/ParticleEditor.ed.gui
+++ b/Templates/BaseGame/game/tools/particleEditor/ParticleEditor.ed.gui
@@ -20,7 +20,7 @@ $PE_guielement_pos_colorpicker = "158 0";
 $PE_guielement_ext_colorpicker = "18 18";
 
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiWindowCollapseCtrl(PE_Window) {
+$guiContent = new GuiWindowCollapseCtrl(PE_Window) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/riverEditor/RiverEditorGui.gui b/Templates/BaseGame/game/tools/riverEditor/RiverEditorGui.gui
index 1a6831489..7645b8855 100644
--- a/Templates/BaseGame/game/tools/riverEditor/RiverEditorGui.gui
+++ b/Templates/BaseGame/game/tools/riverEditor/RiverEditorGui.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiRiverEditorCtrl(RiverEditorGui, EditorGuiGroup) {
+$guiContent = new GuiRiverEditorCtrl(RiverEditorGui, EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/riverEditor/RiverEditorSettingsTab.gui b/Templates/BaseGame/game/tools/riverEditor/RiverEditorSettingsTab.gui
index 553e2d7c6..c1c6d37ed 100644
--- a/Templates/BaseGame/game/tools/riverEditor/RiverEditorSettingsTab.gui
+++ b/Templates/BaseGame/game/tools/riverEditor/RiverEditorSettingsTab.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(RiverEditorSettingsTab,EditorGuiGroup) {
+$guiContent = new GuiControl(RiverEditorSettingsTab,EditorGuiGroup) {
    isContainer = "1";
    Profile = "ToolsGuiDefaultProfile";
    HorizSizing = "right";
diff --git a/Templates/BaseGame/game/tools/riverEditor/RiverEditorToolbar.gui b/Templates/BaseGame/game/tools/riverEditor/RiverEditorToolbar.gui
index 141e577d1..f938acfdf 100644
--- a/Templates/BaseGame/game/tools/riverEditor/RiverEditorToolbar.gui
+++ b/Templates/BaseGame/game/tools/riverEditor/RiverEditorToolbar.gui
@@ -1,4 +1,4 @@
-%guiContent = new GuiControl(RiverEditorToolbar, EditorGuiGroup) {
+$guiContent = new GuiControl(RiverEditorToolbar, EditorGuiGroup) {
    canSaveDynamicFields = "0";
    internalName = "MeshRoadEditorToolbar";
    Enabled = "1";
diff --git a/Templates/BaseGame/game/tools/roadEditor/RoadEditorGui.gui b/Templates/BaseGame/game/tools/roadEditor/RoadEditorGui.gui
index 7f9eba0f6..93767d251 100644
--- a/Templates/BaseGame/game/tools/roadEditor/RoadEditorGui.gui
+++ b/Templates/BaseGame/game/tools/roadEditor/RoadEditorGui.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiRoadEditorCtrl(RoadEditorGui) {
+$guiContent = new GuiRoadEditorCtrl(RoadEditorGui) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/roadEditor/RoadEditorSettingsTab.gui b/Templates/BaseGame/game/tools/roadEditor/RoadEditorSettingsTab.gui
index b37485cda..b2d2ae39a 100644
--- a/Templates/BaseGame/game/tools/roadEditor/RoadEditorSettingsTab.gui
+++ b/Templates/BaseGame/game/tools/roadEditor/RoadEditorSettingsTab.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(RoadEditorSettingsTab,EditorGuiGroup) {
+$guiContent = new GuiControl(RoadEditorSettingsTab,EditorGuiGroup) {
    isContainer = "1";
    Profile = "ToolsGuiDefaultProfile";
    HorizSizing = "right";
diff --git a/Templates/BaseGame/game/tools/roadEditor/RoadEditorToolbar.gui b/Templates/BaseGame/game/tools/roadEditor/RoadEditorToolbar.gui
index bfa2e0513..dbe3fdc8e 100644
--- a/Templates/BaseGame/game/tools/roadEditor/RoadEditorToolbar.gui
+++ b/Templates/BaseGame/game/tools/roadEditor/RoadEditorToolbar.gui
@@ -1,4 +1,4 @@
-%guiContent = new GuiControl(RoadEditorToolbar) {
+$guiContent = new GuiControl(RoadEditorToolbar) {
    canSaveDynamicFields = "0";
    internalName = "RoadEditorToolbar";
    Enabled = "1";
diff --git a/Templates/BaseGame/game/tools/shapeEditor/gui/ShapeEditorSettingsTab.gui b/Templates/BaseGame/game/tools/shapeEditor/gui/ShapeEditorSettingsTab.gui
index 1a455e9a6..e19052bc2 100644
--- a/Templates/BaseGame/game/tools/shapeEditor/gui/ShapeEditorSettingsTab.gui
+++ b/Templates/BaseGame/game/tools/shapeEditor/gui/ShapeEditorSettingsTab.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(ShapeEditorSettingsTab,EditorGuiGroup) {
+$guiContent = new GuiControl(ShapeEditorSettingsTab,EditorGuiGroup) {
    isContainer = "1";
    Profile = "ToolsGuiDefaultProfile";
    HorizSizing = "right";
diff --git a/Templates/BaseGame/game/tools/shapeEditor/gui/ShapeEditorToolbar.ed.gui b/Templates/BaseGame/game/tools/shapeEditor/gui/ShapeEditorToolbar.ed.gui
index ccaaf03fb..cdb2c080c 100644
--- a/Templates/BaseGame/game/tools/shapeEditor/gui/ShapeEditorToolbar.ed.gui
+++ b/Templates/BaseGame/game/tools/shapeEditor/gui/ShapeEditorToolbar.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(ShapeEditorToolbar, EditorGuiGroup) {
+$guiContent = new GuiControl(ShapeEditorToolbar, EditorGuiGroup) {
    canSaveDynamicFields = "0";
    internalName = "";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/shapeEditor/gui/shapeEdAdvancedWindow.ed.gui b/Templates/BaseGame/game/tools/shapeEditor/gui/shapeEdAdvancedWindow.ed.gui
index 405ce3ebc..ea2197bd3 100644
--- a/Templates/BaseGame/game/tools/shapeEditor/gui/shapeEdAdvancedWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/shapeEditor/gui/shapeEdAdvancedWindow.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiWindowCollapseCtrl(ShapeEdAdvancedWindow, EditorGuiGroup) {
+$guiContent = new GuiWindowCollapseCtrl(ShapeEdAdvancedWindow, EditorGuiGroup) {
    text = "Advanced Properties";
    resizeWidth = "0";
    resizeHeight = "0";
diff --git a/Templates/BaseGame/game/tools/shapeEditor/gui/shapeEdAnimWindow.ed.gui b/Templates/BaseGame/game/tools/shapeEditor/gui/shapeEdAnimWindow.ed.gui
index 8785db315..a379cc533 100644
--- a/Templates/BaseGame/game/tools/shapeEditor/gui/shapeEdAnimWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/shapeEditor/gui/shapeEdAnimWindow.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiWindowCtrl(ShapeEdAnimWindow) {
+$guiContent = new GuiWindowCtrl(ShapeEdAnimWindow) {
    canSaveDynamicFields = "0";
    isContainer = "1";
    Profile = "ToolsGuiToolbarWindowProfile";
diff --git a/Templates/BaseGame/game/tools/shapeEditor/gui/shapeEdPreviewWindow.ed.gui b/Templates/BaseGame/game/tools/shapeEditor/gui/shapeEdPreviewWindow.ed.gui
index 81b815d5c..65035d565 100644
--- a/Templates/BaseGame/game/tools/shapeEditor/gui/shapeEdPreviewWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/shapeEditor/gui/shapeEdPreviewWindow.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl() {
+$guiContent = new GuiControl() {
    canSaveDynamicFields = "0";
    isContainer = "1";
    Profile = "ToolsGuiDefaultProfile";
diff --git a/Templates/BaseGame/game/tools/shapeEditor/gui/shapeEdPropWindow.ed.gui b/Templates/BaseGame/game/tools/shapeEditor/gui/shapeEdPropWindow.ed.gui
index 52d581366..32e4da230 100644
--- a/Templates/BaseGame/game/tools/shapeEditor/gui/shapeEdPropWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/shapeEditor/gui/shapeEdPropWindow.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiWindowCollapseCtrl(ShapeEdPropWindow) {
+$guiContent = new GuiWindowCollapseCtrl(ShapeEdPropWindow) {
    canSaveDynamicFields = "0";
    isContainer = "1";
    Profile = "ToolsGuiWindowProfile";
diff --git a/Templates/BaseGame/game/tools/shapeEditor/gui/shapeEdSelectWindow.ed.gui b/Templates/BaseGame/game/tools/shapeEditor/gui/shapeEdSelectWindow.ed.gui
index eb7a3225a..7b2fe0875 100644
--- a/Templates/BaseGame/game/tools/shapeEditor/gui/shapeEdSelectWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/shapeEditor/gui/shapeEdSelectWindow.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl() {
+$guiContent = new GuiControl() {
    canSaveDynamicFields = "0";
    isContainer = "1";
    Profile = "ToolsGuiDefaultProfile";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/AddFMODProjectDlg.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/AddFMODProjectDlg.ed.gui
index 56c892fa9..b7bc1d86b 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/AddFMODProjectDlg.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/AddFMODProjectDlg.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(AddFMODProjectDlg,EditorGuiGroup) {
+$guiContent = new GuiControl(AddFMODProjectDlg,EditorGuiGroup) {
    isContainer = "1";
    Profile = "ToolsGuiOverlayProfile";
    HorizSizing = "right";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/AxisGizmoSettingsTab.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/AxisGizmoSettingsTab.ed.gui
index e5eba667e..08165a2ba 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/AxisGizmoSettingsTab.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/AxisGizmoSettingsTab.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(AxisGizmoSettingsTab,EditorGuiGroup) {
+$guiContent = new GuiControl(AxisGizmoSettingsTab,EditorGuiGroup) {
    isContainer = "1";
    profile = "ToolsGuiDefaultProfile";
    horizSizing = "right";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/CameraSettingsTab.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/CameraSettingsTab.ed.gui
index b267b25a6..969109a3b 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/CameraSettingsTab.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/CameraSettingsTab.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(CameraSettingsTab,EditorGuiGroup) {
+$guiContent = new GuiControl(CameraSettingsTab,EditorGuiGroup) {
    isContainer = "1";
    Profile = "ToolsGuiDefaultProfile";
    HorizSizing = "right";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/EditorChooseLevelGui.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/EditorChooseLevelGui.ed.gui
index a384f59e7..a3eecd66b 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/EditorChooseLevelGui.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/EditorChooseLevelGui.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiContainer(EditorChooseLevelGui, EditorGuiGroup) {
+$guiContent = new GuiContainer(EditorChooseLevelGui, EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
@@ -34,7 +34,7 @@
    };
 };
 
-%guiContent = new GuiContainer(EditorChooseLevelContainer, EditorGuiGroup) {
+$guiContent = new GuiContainer(EditorChooseLevelContainer, EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/EditorGui.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/EditorGui.ed.gui
index c2330f6de..2223182c7 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/EditorGui.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/EditorGui.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiContainer(EditorGui,EditorGuiGroup) {
+$guiContent = new GuiContainer(EditorGui,EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/EditorSettingsWindow.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/EditorSettingsWindow.ed.gui
index 7662ecf00..97c607324 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/EditorSettingsWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/EditorSettingsWindow.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(EditorSettingsWindow,EditorGuiGroup) {
+$guiContent = new GuiControl(EditorSettingsWindow,EditorGuiGroup) {
    isContainer = "1";
    Profile = "ToolsGuiDefaultProfile";
    HorizSizing = "right";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/GeneralSettingsTab.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/GeneralSettingsTab.ed.gui
index a49ab4064..933e42e8b 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/GeneralSettingsTab.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/GeneralSettingsTab.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(GeneralSettingsTab,EditorGuiGroup) {
+$guiContent = new GuiControl(GeneralSettingsTab,EditorGuiGroup) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/GenericPromptDialog.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/GenericPromptDialog.ed.gui
index ade528157..8ab2debf3 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/GenericPromptDialog.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/GenericPromptDialog.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(GenericPromptDialog) {
+$guiContent = new GuiControl(GenericPromptDialog) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/ManageBookmarksWindow.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/ManageBookmarksWindow.ed.gui
index c5f4ff469..d8cd38297 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/ManageBookmarksWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/ManageBookmarksWindow.ed.gui
@@ -1,4 +1,4 @@
-%guiContent = new GuiControl(ManageBookmarksContainer, EditorGuiGroup) {
+$guiContent = new GuiControl(ManageBookmarksContainer, EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/ManageSFXParametersWindow.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/ManageSFXParametersWindow.ed.gui
index 29c55dc74..d24407c8b 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/ManageSFXParametersWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/ManageSFXParametersWindow.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(ManageSFXParametersContainer,EditorGuiGroup) {
+$guiContent = new GuiControl(ManageSFXParametersContainer,EditorGuiGroup) {
    isContainer = "1";
    Profile = "ToolsGuiModelessDialogProfile";
    HorizSizing = "right";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/ObjectEditorSettingsTab.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/ObjectEditorSettingsTab.ed.gui
index b8928eb7d..97382bb99 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/ObjectEditorSettingsTab.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/ObjectEditorSettingsTab.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(ObjectEditorSettingsTab,EditorGuiGroup) {
+$guiContent = new GuiControl(ObjectEditorSettingsTab,EditorGuiGroup) {
    isContainer = "1";
    profile = "ToolsGuiDefaultProfile";
    horizSizing = "right";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/ObjectSnapOptionsWindow.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/ObjectSnapOptionsWindow.ed.gui
index 9805d31dd..ec5165c1d 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/ObjectSnapOptionsWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/ObjectSnapOptionsWindow.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(ObjectSnapOptionsContainer, EditorGuiGroup) {
+$guiContent = new GuiControl(ObjectSnapOptionsContainer, EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
@@ -843,7 +843,7 @@
          password = "0";
          tabComplete = "0";
          sinkAllKeyEvents = "0";
-         passwordMask = "•";
+         passwordMask = "�";
          text = "2.0";
          maxLength = "6";
          margin = "0 0 0 0";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/ProceduralTerrainPainterGui.gui b/Templates/BaseGame/game/tools/worldEditor/gui/ProceduralTerrainPainterGui.gui
index 452c23bf6..690d653fa 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/ProceduralTerrainPainterGui.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/ProceduralTerrainPainterGui.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---  
-%guiContent = new GuiControl(ProceduralTerrainPainterGui) {  
+$guiContent = new GuiControl(ProceduralTerrainPainterGui) {  
    canSaveDynamicFields = "0";  
    isContainer = "1";  
    Profile = "ToolsGuiDefaultProfile";  
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/SelectObjectsWindow.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/SelectObjectsWindow.ed.gui
index 3e95e91d4..c7955d868 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/SelectObjectsWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/SelectObjectsWindow.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(ESelectObjectsWindowContainer,EditorGuiGroup) {
+$guiContent = new GuiControl(ESelectObjectsWindowContainer,EditorGuiGroup) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/TerrainBrushSoftnessCurveDlg.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/TerrainBrushSoftnessCurveDlg.ed.gui
index 6fb188adf..f58b8fb6c 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/TerrainBrushSoftnessCurveDlg.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/TerrainBrushSoftnessCurveDlg.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(TerrainBrushSoftnessCurveDlg, EditorGuiGroup) {
+$guiContent = new GuiControl(TerrainBrushSoftnessCurveDlg, EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/TerrainEditToolbar.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/TerrainEditToolbar.ed.gui
index cc9d6983b..2cf1d3ce5 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/TerrainEditToolbar.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/TerrainEditToolbar.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(EWTerrainEditToolbar,EditorGuiGroup) {
+$guiContent = new GuiControl(EWTerrainEditToolbar,EditorGuiGroup) {
    canSaveDynamicFields = "0";
    internalName = "TerrainEditToolbar";
    Enabled = "1";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/TerrainEditorSettingsTab.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/TerrainEditorSettingsTab.ed.gui
index 8f219ec67..87cc92ff7 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/TerrainEditorSettingsTab.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/TerrainEditorSettingsTab.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(TerrainEditorSettingsTab,EditorGuiGroup) {
+$guiContent = new GuiControl(TerrainEditorSettingsTab,EditorGuiGroup) {
    isContainer = "1";
    Profile = "ToolsGuiDefaultProfile";
    HorizSizing = "right";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/TerrainPainterToolbar.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/TerrainPainterToolbar.ed.gui
index ca4126330..5e25e475c 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/TerrainPainterToolbar.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/TerrainPainterToolbar.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(EWTerrainPainterToolbar,EditorGuiGroup) {
+$guiContent = new GuiControl(EWTerrainPainterToolbar,EditorGuiGroup) {
    canSaveDynamicFields = "0";
    internalName = "TerrainPainterToolbar";
    Enabled = "1";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/TerrainPainterWindow.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/TerrainPainterWindow.ed.gui
index a08c05841..cb7f299d7 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/TerrainPainterWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/TerrainPainterWindow.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(TerrainPainterContainer,EditorGuiGroup) {
+$guiContent = new GuiControl(TerrainPainterContainer,EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/TimeAdjustGui.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/TimeAdjustGui.ed.gui
index 4b7b8a26e..96f64c447 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/TimeAdjustGui.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/TimeAdjustGui.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(TimeAdjustGui, EditorGuiGroup) {
+$guiContent = new GuiControl(TimeAdjustGui, EditorGuiGroup) {
    isContainer = "1";
    Profile = "ToolsGuiModelessDialogProfile";
    HorizSizing = "right";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteWindow.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteWindow.ed.gui
index b6b9c5507..491f7ad1b 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteWindow.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl() {
+$guiContent = new GuiControl() {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsToolbar.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsToolbar.ed.gui
index 1f15e5310..614db16e0 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsToolbar.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsToolbar.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiContainer(EWToolsToolbar) {
+$guiContent = new GuiContainer(EWToolsToolbar) {
    canSaveDynamicFields = "0";
    Enabled = "0";
    internalName = "ToolsToolbar";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/TransformSelectionWindow.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/TransformSelectionWindow.ed.gui
index 26324ea74..1d368b39b 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/TransformSelectionWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/TransformSelectionWindow.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(TransformSelectionContainer, EditorGuiGroup) {
+$guiContent = new GuiControl(TransformSelectionContainer, EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/VisibilityLayerWindow.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/VisibilityLayerWindow.ed.gui
index 6e65a2749..cff92d9ab 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/VisibilityLayerWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/VisibilityLayerWindow.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(VisibilityLayerContainer, EditorGuiGroup) {
+$guiContent = new GuiControl(VisibilityLayerContainer, EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/WorldEditorInspectorWindow.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/WorldEditorInspectorWindow.ed.gui
index 9abe8f9e3..bdfff71fb 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/WorldEditorInspectorWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/WorldEditorInspectorWindow.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl() {
+$guiContent = new GuiControl() {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/WorldEditorToolbar.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/WorldEditorToolbar.ed.gui
index f736e8555..aeb37db79 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/WorldEditorToolbar.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/WorldEditorToolbar.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(EWorldEditorToolbar, EditorGuiGroup) {
+$guiContent = new GuiControl(EWorldEditorToolbar, EditorGuiGroup) {
    canSaveDynamicFields = "0";
    internalName = "WorldEditorToolbar";
    Enabled = "1";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/WorldEditorTreeWindow.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/WorldEditorTreeWindow.ed.gui
index 297336551..c74135219 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/WorldEditorTreeWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/WorldEditorTreeWindow.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl() {
+$guiContent = new GuiControl() {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/guiCreateNewTerrainGui.gui b/Templates/BaseGame/game/tools/worldEditor/gui/guiCreateNewTerrainGui.gui
index 943e85185..41c9ed965 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/guiCreateNewTerrainGui.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/guiCreateNewTerrainGui.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(CreateNewTerrainGui, EditorGuiGroup) {
+$guiContent = new GuiControl(CreateNewTerrainGui, EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainExportGui.gui b/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainExportGui.gui
index 411e74676..fd62d885a 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainExportGui.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainExportGui.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(TerrainExportGui, EditorGuiGroup) {
+$guiContent = new GuiControl(TerrainExportGui, EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Profile = "ToolsGuiOverlayProfile";
    Enabled = "1";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainImportGui.gui b/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainImportGui.gui
index c013cba61..9055f4fdc 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainImportGui.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainImportGui.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(TerrainImportGui, EditorGuiGroup) {
+$guiContent = new GuiControl(TerrainImportGui, EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainMaterialDlg.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainMaterialDlg.ed.gui
index 0d4339eae..57c9677e6 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainMaterialDlg.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainMaterialDlg.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(TerrainMaterialDlg,EditorGuiGroup) {
+$guiContent = new GuiControl(TerrainMaterialDlg,EditorGuiGroup) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainTextureSettingsDlg.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainTextureSettingsDlg.ed.gui
index 47c3549a2..f63f53614 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainTextureSettingsDlg.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainTextureSettingsDlg.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(TerrainTextureSettingsDlg, EditorGuiGroup) {
+$guiContent = new GuiControl(TerrainTextureSettingsDlg, EditorGuiGroup) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/guiWorldEditorMissionInspector.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/guiWorldEditorMissionInspector.ed.gui
index ab7bfe2f5..166db3024 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/guiWorldEditorMissionInspector.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/guiWorldEditorMissionInspector.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(WorldEditorMissionInspector,EditorGuiGroup) {
+$guiContent = new GuiControl(WorldEditorMissionInspector,EditorGuiGroup) {
    canSaveDynamicFields = "0";
    isContainer = "1";
    Profile = "ToolsGuiDefaultProfile";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/objectBuilderGui.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/objectBuilderGui.ed.gui
index b486ca467..da4b05df3 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/objectBuilderGui.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/objectBuilderGui.ed.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(ObjectBuilderGui, EditorGuiGroup) {
+$guiContent = new GuiControl(ObjectBuilderGui, EditorGuiGroup) {
 	profile = "ToolsGuiDefaultProfile";
 	horizSizing = "right";
 	vertSizing = "bottom";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/probeBakeDlg.gui b/Templates/BaseGame/game/tools/worldEditor/gui/probeBakeDlg.gui
index ae952c9b8..cf4f2ad4b 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/probeBakeDlg.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/probeBakeDlg.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(ProbeBakeDlg) {
+$guiContent = new GuiControl(ProbeBakeDlg) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/shadowViz.gui b/Templates/BaseGame/game/tools/worldEditor/gui/shadowViz.gui
index e130850bd..997d05417 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/shadowViz.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/shadowViz.gui
@@ -4,7 +4,7 @@
 //---------------------------------------------------------------------------------------------
 
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(AL_ShadowVizOverlayCtrl) {
+$guiContent = new GuiControl(AL_ShadowVizOverlayCtrl) {
    canSaveDynamicFields = "0";
    isContainer = "1";
    Profile = "GuiModelessDialogProfile";
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
index ee4e7bfb2..1f5dc01f3 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
@@ -113,9 +113,9 @@ function EditorGui::init(%this)
    {
       // Load Terrain Painter GUI
       exec("~/worldEditor/gui/TerrainPainterWindow.ed.gui");
-      if( isObject( %guiContent ) ){
-         %this.add( %guiContent->TerrainPainter );
-         %this.add( %guiContent->TerrainPainterPreview );
+      if( isObject( $guiContent ) ){
+         %this.add( $guiContent->TerrainPainter );
+         %this.add( $guiContent->TerrainPainterPreview );
       }
          
       exec("~/worldEditor/gui/guiTerrainMaterialDlg.ed.gui"); 
diff --git a/Templates/Modules/Verve/gui/VerveCinematic.gui b/Templates/Modules/Verve/gui/VerveCinematic.gui
index f71a3171c..d12463244 100644
--- a/Templates/Modules/Verve/gui/VerveCinematic.gui
+++ b/Templates/Modules/Verve/gui/VerveCinematic.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GameTSCtrl(VerveCinematicGui) {
+$guiContent = new GameTSCtrl(VerveCinematicGui) {
    canSaveDynamicFields = "1";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/Modules/inputTest/scripts/gui/inputMonitor.gui b/Templates/Modules/inputTest/scripts/gui/inputMonitor.gui
index e1549f06f..67708cf2e 100644
--- a/Templates/Modules/inputTest/scripts/gui/inputMonitor.gui
+++ b/Templates/Modules/inputTest/scripts/gui/inputMonitor.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(InputMonitorDlg) {
+$guiContent = new GuiControl(InputMonitorDlg) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 8";
diff --git a/Templates/Modules/inputTest/scripts/gui/joystickSettings.gui b/Templates/Modules/inputTest/scripts/gui/joystickSettings.gui
index d9b4d19a9..ca30235d4 100644
--- a/Templates/Modules/inputTest/scripts/gui/joystickSettings.gui
+++ b/Templates/Modules/inputTest/scripts/gui/joystickSettings.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(JoystickSettingsDlg) {
+$guiContent = new GuiControl(JoystickSettingsDlg) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 8";
diff --git a/Templates/Modules/vr/guis/oculusVROverlay.gui b/Templates/Modules/vr/guis/oculusVROverlay.gui
index 62a9f719c..d05852cbd 100644
--- a/Templates/Modules/vr/guis/oculusVROverlay.gui
+++ b/Templates/Modules/vr/guis/oculusVROverlay.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = singleton GuiControl(OculusVROverlay) {
+$guiContent = singleton GuiControl(OculusVROverlay) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";

From b2bbd771f6ff751209ee753406692621f0a31641 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Tue, 4 May 2021 22:49:19 -0400
Subject: [PATCH 022/399] more torquescript template fixes.

---
 .../VPathEditor/GUI/VPathEditorPalette.gui    |  2 +-
 .../Controller/VControllerProperties.tscript  |  1 +
 .../Scripts/Groups/VDirectorGroup.tscript     |  2 +-
 .../Scripts/Groups/VSceneObjectGroup.tscript  |  2 +-
 .../Scripts/Groups/VSpawnSphereGroup.tscript  |  2 +-
 .../assetBrowser/scripts/assetBrowser.tscript | 18 ++++++++++++
 .../assetBrowser/scripts/assetImport.tscript  |  3 ++
 .../scripts/assetImportConfig.tscript         |  2 ++
 .../scripts/assetTypes/component.tscript      |  2 +-
 .../scripts/assetTypes/cpp.tscript            |  2 ++
 .../scripts/assetTypes/level.tscript          |  2 +-
 .../scripts/assetTypes/script.tscript         |  3 +-
 .../scripts/assetTypes/stateMachine.tscript   |  3 ++
 .../scripts/directoryHandling.tscript         |  2 +-
 .../assetBrowser/scripts/editAsset.tscript    |  8 ++++--
 .../interface/materialFieldType.tscript       | 17 +++++++----
 .../interface/stateMachineField.tscript       |  2 +-
 .../interface/typeMaskFieldType.tscript       |  4 +--
 .../scripts/componentEditor.ed.tscript        |  3 ++
 .../convexEditor/convexEditorSidebarGui.gui   |  2 +-
 .../datablockEditorUndo.tscript               |  6 ++--
 .../debugger/scripts/debugger.ed.tscript      |  2 +-
 .../game/tools/decalEditor/decalEditorGui.gui |  8 ------
 .../game/tools/forestEditor/brushes.tscript   |  2 +-
 .../tools/gui/editorSettingsWindow.ed.tscript |  5 ++--
 .../gui/fieldTypes/assetDependencies.tscript  |  2 +-
 .../tools/gui/fieldTypes/buttonField.tscript  |  2 +-
 .../tools/gui/fieldTypes/listField.tscript    |  6 ++--
 .../game/tools/gui/fieldTypes/range.tscript   |  2 +-
 .../scripts/guiEditorProfiles.ed.tscript      |  2 ++
 .../scripts/guiEditorUndo.ed.tscript          |  4 +++
 .../gui/guiMaterialPropertiesWindow.ed.gui    | 15 ----------
 .../scripts/materialEditor.ed.tscript         |  3 +-
 .../meshRoadEditor/meshRoadEditorGui.tscript  |  2 +-
 .../particleEditor/ParticleEditor.ed.gui      | 28 +++----------------
 .../tools/roadEditor/roadEditorGui.tscript    |  2 +-
 .../scripts/shapeEditor.ed.tscript            |  4 ++-
 .../ConvexEditorPalette.ed.gui                |  2 +-
 .../DecalEditorPalette.ed.gui                 |  2 +-
 .../ForestEditorPalette.ed.gui                |  2 +-
 .../MeshRoadEditorPalette.ed.gui              |  2 +-
 .../NavEditorPalette.ed.gui                   |  2 +-
 .../RiverEditorPalette.ed.gui                 |  2 +-
 .../RoadEditorPalette.ed.gui                  |  2 +-
 .../ShapeEditorPalette.ed.gui                 |  2 +-
 .../TerrainEditPalette.ed.gui                 |  2 +-
 .../TerrainPainterPalette.ed.gui              |  2 +-
 .../WorldEditorPalette.ed.gui                 |  2 +-
 .../gui/ToolsPaletteGroups/init.tscript       |  6 ++++
 .../worldEditor/gui/guiTerrainExportGui.gui   |  3 ++
 .../worldEditor/gui/guiTerrainImportGui.gui   |  5 ++++
 .../worldEditor/scripts/EditorGui.ed.tscript  |  2 +-
 .../ManageSFXParametersWindow.ed.tscript      |  5 ++--
 .../scripts/menuHandlers.ed.tscript           |  1 +
 54 files changed, 122 insertions(+), 99 deletions(-)

diff --git a/Templates/BaseGame/game/tools/VPathEditor/GUI/VPathEditorPalette.gui b/Templates/BaseGame/game/tools/VPathEditor/GUI/VPathEditorPalette.gui
index 94f8102dc..051bad2c5 100644
--- a/Templates/BaseGame/game/tools/VPathEditor/GUI/VPathEditorPalette.gui
+++ b/Templates/BaseGame/game/tools/VPathEditor/GUI/VPathEditorPalette.gui
@@ -3,7 +3,7 @@
 // Copyright (C) - Violent Tulip
 //-----------------------------------------------------------------------------
 
-%paletteId = new GuiControl(VPathEditorPalette) {
+$paletteId = new GuiControl(VPathEditorPalette) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/VerveEditor/Scripts/Controller/VControllerProperties.tscript b/Templates/BaseGame/game/tools/VerveEditor/Scripts/Controller/VControllerProperties.tscript
index b3bd39d5c..3fd8b8046 100644
--- a/Templates/BaseGame/game/tools/VerveEditor/Scripts/Controller/VControllerProperties.tscript
+++ b/Templates/BaseGame/game/tools/VerveEditor/Scripts/Controller/VControllerProperties.tscript
@@ -59,6 +59,7 @@ function VControllerPropertyList::InspectObject( %this, %object )
     }
     
     %dataFieldCount = %object.getDataFieldCount();
+    %dataFieldList = "";
     for ( %i = 0; %i < %dataFieldCount; %i++ )
     {
         // Add To List.
diff --git a/Templates/BaseGame/game/tools/VerveEditor/Scripts/Groups/VDirectorGroup.tscript b/Templates/BaseGame/game/tools/VerveEditor/Scripts/Groups/VDirectorGroup.tscript
index 9360f22d0..c47103b8f 100644
--- a/Templates/BaseGame/game/tools/VerveEditor/Scripts/Groups/VDirectorGroup.tscript
+++ b/Templates/BaseGame/game/tools/VerveEditor/Scripts/Groups/VDirectorGroup.tscript
@@ -22,7 +22,7 @@ function VDirectorGroup::PopulateBuildStack( %this, %stack )
 
 function VDirectorGroup::ResolveBuildStack( %this, %stack )
 {
-    Parent::ResolveBuildStack( %this, %stack, %groupObject );
+    Parent::ResolveBuildStack( %this, %stack );
     
     // Find the Track Toggle.
     %directorTrackCheckBox = %stack.findObjectByInternalName( "DirectorTrackToggle", true );
diff --git a/Templates/BaseGame/game/tools/VerveEditor/Scripts/Groups/VSceneObjectGroup.tscript b/Templates/BaseGame/game/tools/VerveEditor/Scripts/Groups/VSceneObjectGroup.tscript
index 7483ea209..209c329fc 100644
--- a/Templates/BaseGame/game/tools/VerveEditor/Scripts/Groups/VSceneObjectGroup.tscript
+++ b/Templates/BaseGame/game/tools/VerveEditor/Scripts/Groups/VSceneObjectGroup.tscript
@@ -62,7 +62,7 @@ function VSceneObjectGroup::PopulateBuildStack( %this, %stack )
 
 function VSceneObjectGroup::ResolveBuildStack( %this, %stack )
 {
-    Parent::ResolveBuildStack( %this, %stack, %groupObject );
+    Parent::ResolveBuildStack( %this, %stack );
     
     // Fetch the Controller.
     %controller = %this.getRoot();
diff --git a/Templates/BaseGame/game/tools/VerveEditor/Scripts/Groups/VSpawnSphereGroup.tscript b/Templates/BaseGame/game/tools/VerveEditor/Scripts/Groups/VSpawnSphereGroup.tscript
index cd2913ad9..de8280d60 100644
--- a/Templates/BaseGame/game/tools/VerveEditor/Scripts/Groups/VSpawnSphereGroup.tscript
+++ b/Templates/BaseGame/game/tools/VerveEditor/Scripts/Groups/VSpawnSphereGroup.tscript
@@ -31,7 +31,7 @@ function VSceneObjectGroup::PopulateBuildStack( %this, %stack )
 
 function VSceneObjectGroup::ResolveBuildStack( %this, %stack )
 {
-    VGroup::ResolveBuildStack( %this, %stack, %groupObject );
+    VGroup::ResolveBuildStack( %this, %stack );
     
     // Fetch the Controller.
     %controller = %this.getRoot();
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
index 3831adf2e..8596d4b0f 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
@@ -242,6 +242,8 @@ function AssetBrowser::selectAsset( %this, %asset )
       //eval("materialEd_previewMaterial." @ %propertyField @ " = " @ %value @ ";");
       if( AssetBrowser.returnType $= "name" )
       {
+         // TODO!
+         %name = "";
          eval( "" @ AssetBrowser.selectCallback @ "(" @ %name  @ ");");
       }
       else
@@ -663,6 +665,7 @@ function AssetBrowser::loadDirectories( %this )
    //Remove any modules that have no assets if we have that filter on
    if(%this.onlyShowModulesWithAssets)
    {
+      %modulesList = ModuleDatabase.findModules();
       for(%i=0; %i < getWordCount(%modulesList); %i++)
       {
          %moduleName = getWord(%modulesList, %i).ModuleId;
@@ -905,6 +908,8 @@ function AssetBrowser::addCreatorClass(%this, %class, %name, %buildfunc)
    if ( %name $= "" )
       %name = %class;
       
+   // TODO
+   %group = "";   
    if ( %this.currentCreatorGroup !$= "" && %group $= "" )
       %group = %this.currentCreatorGroup;
    
@@ -1048,6 +1053,13 @@ function AssetBrowser::toggleTagFilterPopup(%this)
 		//now, add the asset's category
 		%assetType = AssetDatabase.getAssetCategory(%assetId);
 		
+      // TODO?
+      %text = "";
+      %var = "";
+      %cmd = "";
+      %textLength = strlen(%text);
+      // end todo
+
 		%checkBox = new GuiCheckBoxCtrl()
 		{
 			canSaveDynamicFields = "0";
@@ -1108,6 +1120,9 @@ function AssetBrowser::reImportAsset(%this)
          //if(%assetType $= "ImageAsset")
          //   %filters = "";
             
+         //TODO
+         %currentFile = "";
+
          %dlg = new OpenFileDialog()
          {
             Filters = "(All Files (*.*)|*.*|";
@@ -1412,10 +1427,13 @@ function AssetBrowser::doRebuildAssetArray(%this)
    AssetBrowser-->assetList.deleteAllObjects();
    AssetPreviewArray.empty();
 
+   // uhh?? I just added global schenanagins here to make this work
+   %assetArray = $AssetBrowser::AssetArray;
    if(isObject(%assetArray))
       %assetArray.delete();
       
    %assetArray = new ArrayObject();
+   $AssetBrowser::AssetArray = %assetArray;
    
    //First, Query for our assets
    %assetQuery = new AssetQuery();
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImport.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImport.tscript
index 152a4c78c..50ab94c6b 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImport.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImport.tscript
@@ -277,6 +277,9 @@ function AssetBrowser::onDropFolder(%this, %filePath)
       //First, we wanna scan to see if we have modules to contend with. If we do, we'll just plunk them in wholesale
       //and not process their contents.
       
+      // TODO
+      %fileExt = "";
+
       //If not modules, it's likely an art pack or other mixed files, so we'll import them as normal
       if( (%fileExt $= ".png") || (%fileExt $= ".jpg") || (%fileExt $= ".bmp") || (%fileExt $= ".dds") )
          %this.importAssetListArray.add("ImageAsset", %filePath);
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfig.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfig.tscript
index 97bd9b8db..6b52e7199 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfig.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfig.tscript
@@ -142,6 +142,7 @@ function ImportAssetOptionsWindow::editImportSettings(%this, %assetItem)
    %filePath = %assetItem.filePath;
    %assetName = %assetItem.assetName;
    %assetConfigObj = %assetItem.importConfig;
+   %optionsObj = %assetItem.optionsObj; // TODO IS THIS RIGHT
    
    ImportOptionsList.startGroup("Asset");
    ImportOptionsList.addField("AssetName", "Asset Name", "string", "", "NewAsset", "", %assetItem);
@@ -405,6 +406,7 @@ function ImportAssetConfigEditorWindow::editConfig(%this)
 
 function ImportAssetConfigEditorWindow::deleteConfig(%this)
 {
+   %configList = ImportAssetConfigSettingsList;
    for(%i=0; %i < %configList.count(); %i++)
    {
       
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/component.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/component.tscript
index 8d0b6eaee..c34eef551 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/component.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/component.tscript
@@ -110,7 +110,7 @@ function AssetBrowser::renameComponentAsset(%this, %assetDef, %newAssetId, %orig
          %line = %file.readLine();
          %line = trim( %line );
          
-         %editedFileContents = %editedFileContents @ strreplace(%line, %originalAssetName, %newName) @ "\n";
+         %editedFileContents = %editedFileContents @ strreplace(%line, %originalName, %newName) @ "\n";
       }
       
       %file.close();
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/cpp.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/cpp.tscript
index 4ae71361b..9d00caa05 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/cpp.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/cpp.tscript
@@ -37,6 +37,8 @@ function AssetBrowser::createCpp(%this)
    
    TamlWrite(%asset, %tamlpath);*/
    
+   %tamlpath = %assetPath @ %assetName @ ".asset.taml";
+
    %moduleDef = ModuleDatabase.findModule(%moduleName, 1);
 	AssetDatabase.addDeclaredAsset(%moduleDef, %tamlpath);
 
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/level.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/level.tscript
index d57f1594c..9a8f05783 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/level.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/level.tscript
@@ -137,7 +137,7 @@ function AssetBrowser::buildLevelAssetPreview(%this, %assetDef, %previewData)
    %previewData.assetPath = %assetDef.getLevelPath();
    %previewData.doubleClickCommand = "schedule( 1, 0, \"EditorOpenMission\", "@%assetDef@");";
    
-   %levelPreviewImage = %assetDesc.PreviewImage;
+   %levelPreviewImage = %assetDef.PreviewImage;
          
    if(isFile(%levelPreviewImage))
       %previewData.previewImage = %levelPreviewImage;
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/script.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/script.tscript
index c7a226d49..0ddd29944 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/script.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/script.tscript
@@ -49,8 +49,7 @@ function AssetBrowser::importScriptAsset(%this, %assetId)
 
 function AssetBrowser::onScriptAssetEditorDropped(%this, %assetDef, %position)
 {
-   if(!isObject(%dropTarget))
-      return;
+
 }
 
 //Renames the asset
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/stateMachine.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/stateMachine.tscript
index d55b926df..1e444bcf1 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/stateMachine.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/stateMachine.tscript
@@ -86,6 +86,9 @@ function AssetBrowser::editStateMachineAsset(%this, %assetDef)
 
 function AssetBrowser::duplicateStateMachineAsset(%this, %assetDef)
 {
+   // TODO:
+   %targetModule = "";
+
    //Check if we have a target module, if not we need to select one
    if(%targetModule $= "")
    {
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/directoryHandling.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/directoryHandling.tscript
index f40904ea8..10c75951f 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/directoryHandling.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/directoryHandling.tscript
@@ -325,7 +325,7 @@ function directoryHandler::copyFolder(%this, %fromFolder, %toFolder)
       if(!%success)
          error("copyProjectFolder() - failed to copy file: " @ %file);
       
-      %file = findNextFileMultiExpr( %fullPath @ "/*.*" );
+      %file = findNextFileMultiExpr( %fromFolder @ "/*.*" );
    }
    
    //do sub directories
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/editAsset.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/editAsset.tscript
index 82385f25f..09117e16a 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/editAsset.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/editAsset.tscript
@@ -143,6 +143,10 @@ function AssetBrowser::performRenameAsset(%this, %originalAssetName, %newName)
    //Update the selection to immediately jump to the new asset
    AssetBrowser-->filterTree.clearSelection();
    %ModuleItem = AssetBrowser-->filterTree.findItemByName(%moduleName);
+
+   // TODO is this correct?
+   %assetType = %ModuleItem.getClassName();
+
    %assetTypeId = AssetBrowser-->filterTree.findChildItemByName(%ModuleItem, %assetType);
    
    AssetBrowser-->filterTree.selectItem(%assetTypeId);
@@ -236,9 +240,9 @@ function moveAssetFile(%assetDef, %destinationPath)
    %assetPath = makeFullPath(AssetDatabase.getAssetFilePath(%assetDef.getAssetId()));
    %assetFilename = fileName(%assetPath);
    
-   %newAssetPath = %destination @ "/" @ %assetFilename;
+   %newAssetPath = %destinationPath @ "/" @ %assetFilename;
    
-   %copiedSuccess = pathCopy(%assetPath, %destination @ "/" @ %assetFilename);
+   %copiedSuccess = pathCopy(%assetPath, %destinationPath @ "/" @ %assetFilename);
    
    if(!%copiedSuccess)
       return "";
diff --git a/Templates/BaseGame/game/tools/componentEditor/interface/materialFieldType.tscript b/Templates/BaseGame/game/tools/componentEditor/interface/materialFieldType.tscript
index aff83f5de..d2139d399 100644
--- a/Templates/BaseGame/game/tools/componentEditor/interface/materialFieldType.tscript
+++ b/Templates/BaseGame/game/tools/componentEditor/interface/materialFieldType.tscript
@@ -9,6 +9,13 @@ function GuiInspectorGroup::buildMaterialField(%this, %fieldName, %fieldLabel, %
    if(%currentMaterial $= "" || %currentMaterial == 0)
 	  %currentMaterial = %fieldDefaultVal;
       
+   // TODO?
+   %matName = "";
+   %component = "";
+   %material = "";
+   %accessor = "";
+   %precision = "";
+
    %container = new GuiControl() {
       canSaveDynamicFields = "0";
       Profile = "EditorContainerProfile";
@@ -20,7 +27,7 @@ function GuiInspectorGroup::buildMaterialField(%this, %fieldName, %fieldLabel, %
       canSave = "0";
       Visible = "1";
       hovertime = "100";
-      tooltip = %tooltip;
+      tooltip = "";// %tooltip;
       tooltipProfile = "EditorToolTipProfile";
    };
 
@@ -35,7 +42,7 @@ function GuiInspectorGroup::buildMaterialField(%this, %fieldName, %fieldLabel, %
       canSave = "0";
       Visible = "1";
       hovertime = "100";
-      tooltip = %tooltip;
+      tooltip = ""; //%tooltip;
       tooltipProfile = "EditorToolTipProfile";
       text = %fieldName;
       maxLength = "1024";
@@ -57,7 +64,7 @@ function GuiInspectorGroup::buildMaterialField(%this, %fieldName, %fieldLabel, %
          text = %currentMaterial;
       };
    };
-   
+
    %previewButton = new GuiBitmapButtonCtrl(){
       internalName = %matName;
       HorizSizing = "right";
@@ -121,7 +128,7 @@ function GuiInspectorGroup::buildMaterialField(%this, %fieldName, %fieldLabel, %
       canSave = "0";
       Visible = "1";
       hovertime = "100";
-      tooltip = %tooltip;
+      tooltip = ""; //%tooltip;
       tooltipProfile = "EditorToolTipProfile";
       text = "Mapped to:" SPC %material.mapTo;
       maxLength = "1024";
@@ -140,7 +147,7 @@ function GuiInspectorGroup::buildMaterialField(%this, %fieldName, %fieldLabel, %
       canSave = "0";
       Visible = "1";
       hovertime = "100";
-      tooltip = %tooltip;
+      tooltip = "";// %tooltip;
       tooltipProfile = "EditorToolTipProfile";
       maxLength = "1024";
       historySize = "0";
diff --git a/Templates/BaseGame/game/tools/componentEditor/interface/stateMachineField.tscript b/Templates/BaseGame/game/tools/componentEditor/interface/stateMachineField.tscript
index 796c2486b..80c5723ed 100644
--- a/Templates/BaseGame/game/tools/componentEditor/interface/stateMachineField.tscript
+++ b/Templates/BaseGame/game/tools/componentEditor/interface/stateMachineField.tscript
@@ -201,7 +201,7 @@ function stateMachineFieldList::onSelect(%this)
    %index = %this.getParent().fieldID;
    
    %oldValue = %this.behavior.stateMachine.getValue(%index);
-   %this.behavior.stateMachine.setValue(%fieldType SPC %oldValue.y);
+   %this.behavior.stateMachine.setValue(%this.fieldType SPC %oldValue.y);
    
    %this.getParent().add(%fieldCtrl);
 }
diff --git a/Templates/BaseGame/game/tools/componentEditor/interface/typeMaskFieldType.tscript b/Templates/BaseGame/game/tools/componentEditor/interface/typeMaskFieldType.tscript
index 83cb55a6f..3b7710ad7 100644
--- a/Templates/BaseGame/game/tools/componentEditor/interface/typeMaskFieldType.tscript
+++ b/Templates/BaseGame/game/tools/componentEditor/interface/typeMaskFieldType.tscript
@@ -13,7 +13,7 @@ function GuiInspectorComponentGroup::buildTypeMaskField(%this, %component, %fiel
       canSave = "0";
       Visible = "1";
       hovertime = "100";
-      tooltip = %tooltip;
+      tooltip = "";//%tooltip;
       tooltipProfile = "EditorToolTipProfile";
    };
 
@@ -28,7 +28,7 @@ function GuiInspectorComponentGroup::buildTypeMaskField(%this, %component, %fiel
       canSave = "0";
       Visible = "1";
       hovertime = "100";
-      tooltip = %tooltip;
+      tooltip = "";//%tooltip;
       tooltipProfile = "EditorToolTipProfile";
       text = %fieldName;
       maxLength = "1024";
diff --git a/Templates/BaseGame/game/tools/componentEditor/scripts/componentEditor.ed.tscript b/Templates/BaseGame/game/tools/componentEditor/scripts/componentEditor.ed.tscript
index c136bb4bf..b9b7d2850 100644
--- a/Templates/BaseGame/game/tools/componentEditor/scripts/componentEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/componentEditor/scripts/componentEditor.ed.tscript
@@ -159,6 +159,9 @@ function QuickEditComponentList::onHotTrackItem( %this, %itemID )
       {
          %name = getField(%componentObj.getComponentField(%i), 0);
 
+         // TODO:
+         %description = "";
+
          SuperTooltipDlg.addParam(%name, %description @ "\n");
       }
       %position = %this.getGlobalPosition();
diff --git a/Templates/BaseGame/game/tools/convexEditor/convexEditorSidebarGui.gui b/Templates/BaseGame/game/tools/convexEditor/convexEditorSidebarGui.gui
index 8fbc97464..99d9b1852 100644
--- a/Templates/BaseGame/game/tools/convexEditor/convexEditorSidebarGui.gui
+++ b/Templates/BaseGame/game/tools/convexEditor/convexEditorSidebarGui.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContnt = new GuiControl(ConvexEditorOptions)
+$guiContnt = new GuiControl(ConvexEditorOptions)
 {
    position = "0 0";
    extent = "800 600";
diff --git a/Templates/BaseGame/game/tools/datablockEditor/datablockEditorUndo.tscript b/Templates/BaseGame/game/tools/datablockEditor/datablockEditorUndo.tscript
index f9a8d30b4..d3630c9e8 100644
--- a/Templates/BaseGame/game/tools/datablockEditor/datablockEditorUndo.tscript
+++ b/Templates/BaseGame/game/tools/datablockEditor/datablockEditorUndo.tscript
@@ -79,7 +79,7 @@ function ActionCreateDatablock::redo( %this )
    %this.editor.selectDatablock( %db );
    %this.editor.flagInspectorAsDirty( true );
    
-   UnlistedDatablocks.remove( %id );
+   UnlistedDatablocks.remove( %db );
 }
 
 //---------------------------------------------------------------------------------------------
@@ -99,7 +99,7 @@ function ActionCreateDatablock::undo( %this )
    %this.dbName = %db.name;
    %db.name = "";
    
-   UnlistedDatablocks.add( %this.db );
+   UnlistedDatablocks.add( %db );
 }
 
 //=============================================================================================
@@ -155,5 +155,5 @@ function ActionDeleteDatablock::undo( %this )
    
    // Remove from unlisted.
    
-   UnlistedDatablocks.remove( %id );
+   UnlistedDatablocks.remove( %db );
 }
diff --git a/Templates/BaseGame/game/tools/debugger/scripts/debugger.ed.tscript b/Templates/BaseGame/game/tools/debugger/scripts/debugger.ed.tscript
index 408de29eb..0c17b8ccb 100644
--- a/Templates/BaseGame/game/tools/debugger/scripts/debugger.ed.tscript
+++ b/Templates/BaseGame/game/tools/debugger/scripts/debugger.ed.tscript
@@ -430,7 +430,7 @@ function DbgRemoveBreakPoint(%file, %line)
 function DbgDeleteSelectedBreak()
 {
    %selectedBreak = DebuggerBreakPoints.getSelectedId();
-   %rowNum = DebuggerBreakPoints.getRowNumById(%selectedWatch);
+   %rowNum = DebuggerBreakPoints.getRowNumById(%selectedBreak);
    if (%rowNum >= 0) {
       %breakText = DebuggerBreakPoints.getRowText(%rowNum);
       %breakLine = getField(%breakText, 0);
diff --git a/Templates/BaseGame/game/tools/decalEditor/decalEditorGui.gui b/Templates/BaseGame/game/tools/decalEditor/decalEditorGui.gui
index 816bb0cc2..46291615a 100644
--- a/Templates/BaseGame/game/tools/decalEditor/decalEditorGui.gui
+++ b/Templates/BaseGame/game/tools/decalEditor/decalEditorGui.gui
@@ -472,8 +472,6 @@ $guiContent = new GuiDecalEditorCtrl(DecalEditorGui) {
                Margin = "0 0 0 -3";
                DragSizable = false;
                container = true;
-               parentRollout = %this.rollout;
-               object = %behavior;  
                
                new GuiStackControl() {
                   StackingType = "Vertical";
@@ -552,8 +550,6 @@ $guiContent = new GuiDecalEditorCtrl(DecalEditorGui) {
                Margin = "0 0 0 0";
                DragSizable = false;
                container = true;
-               parentRollout = %this.rollout;
-               object = %behavior;
                
                new GuiStackControl() {
                   StackingType = "Vertical";
@@ -716,8 +712,6 @@ $guiContent = new GuiDecalEditorCtrl(DecalEditorGui) {
                Margin = "0 0 0 -3";
                DragSizable = false;
                container = true;
-               parentRollout = %this.rollout;
-               object = %behavior;  
                
                new GuiStackControl() {
                   StackingType = "Vertical";
@@ -796,8 +790,6 @@ $guiContent = new GuiDecalEditorCtrl(DecalEditorGui) {
                Margin = "0 0 0 0";
                DragSizable = false;
                container = true;
-               parentRollout = %this.rollout;
-               object = %behavior; 
                
                new GuiInspector(DecalInspector) {
                   StackingType = "Vertical";
diff --git a/Templates/BaseGame/game/tools/forestEditor/brushes.tscript b/Templates/BaseGame/game/tools/forestEditor/brushes.tscript
index 2146c2e34..8b2735ccf 100644
--- a/Templates/BaseGame/game/tools/forestEditor/brushes.tscript
+++ b/Templates/BaseGame/game/tools/forestEditor/brushes.tscript
@@ -20,6 +20,6 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-%forestBrushesGroup = new SimGroup( ForestBrushGroup )
+$forestBrushesGroup = new SimGroup( ForestBrushGroup )
 {
 };
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/gui/editorSettingsWindow.ed.tscript b/Templates/BaseGame/game/tools/gui/editorSettingsWindow.ed.tscript
index 55842264c..a1604b005 100644
--- a/Templates/BaseGame/game/tools/gui/editorSettingsWindow.ed.tscript
+++ b/Templates/BaseGame/game/tools/gui/editorSettingsWindow.ed.tscript
@@ -233,7 +233,7 @@ function GuiInspectorVariableGroup::buildOptionsSettingField(%this, %fieldName,
       canSave = "1";
       Visible = "1";
       tooltipprofile = "ToolsGuiToolTipProfile";
-      tooltip = %tooltip;
+      tooltip = "";//%tooltip;
       text = %fieldDefaultVal;
       hovertime = "1000";
       ownerObject = %ownerObj;
@@ -492,7 +492,8 @@ function ESettingsWindow::getAssetManagementSettings(%this)
 function ESettingsWindow::getAssetEditingSettings(%this)
 {
    ImportAssetWindow::reloadImportOptionConfigs();
-   
+   %formattedConfigList = "";
+
    for(%i=0; %i < ImportAssetWindow.importConfigsList.Count(); %i++)
    {
       %configName = ImportAssetWindow.importConfigsList.getKey(%i);
diff --git a/Templates/BaseGame/game/tools/gui/fieldTypes/assetDependencies.tscript b/Templates/BaseGame/game/tools/gui/fieldTypes/assetDependencies.tscript
index 3aaf4f73a..b0f8e5a45 100644
--- a/Templates/BaseGame/game/tools/gui/fieldTypes/assetDependencies.tscript
+++ b/Templates/BaseGame/game/tools/gui/fieldTypes/assetDependencies.tscript
@@ -34,7 +34,7 @@ function GuiInspectorVariableGroup::buildAssetDependenciesField(%this, %fieldNam
       canSave = "1";
       Visible = "1";
       tooltipprofile = "ToolsGuiToolTipProfile";
-      tooltip = %tooltip;
+      tooltip = "";// %tooltip;
       text = %fieldDefaultVal;
       hovertime = "1000";
       ownerObject = %ownerObj;
diff --git a/Templates/BaseGame/game/tools/gui/fieldTypes/buttonField.tscript b/Templates/BaseGame/game/tools/gui/fieldTypes/buttonField.tscript
index c0a2392a2..e2f680d05 100644
--- a/Templates/BaseGame/game/tools/gui/fieldTypes/buttonField.tscript
+++ b/Templates/BaseGame/game/tools/gui/fieldTypes/buttonField.tscript
@@ -33,7 +33,7 @@ function GuiInspectorVariableGroup::buildButtonField(%this, %fieldName, %fieldLa
       canSave = "1";
       Visible = "1";
       tooltipprofile = "ToolsGuiToolTipProfile";
-      tooltip = %tooltip;
+      tooltip = "";// %tooltip;
       text = %fieldName;
       hovertime = "1000";
       command = %fieldDataVals;
diff --git a/Templates/BaseGame/game/tools/gui/fieldTypes/listField.tscript b/Templates/BaseGame/game/tools/gui/fieldTypes/listField.tscript
index d636641af..c26f3638d 100644
--- a/Templates/BaseGame/game/tools/gui/fieldTypes/listField.tscript
+++ b/Templates/BaseGame/game/tools/gui/fieldTypes/listField.tscript
@@ -22,7 +22,7 @@ function GuiInspectorVariableGroup::buildListField(%this, %fieldName, %fieldLabe
       canSave = "0";
       Visible = "1";
       hovertime = "100";
-      tooltip = %tooltip;
+      tooltip = ""; ///%tooltip;
       tooltipProfile = "EditorToolTipProfile";
    };
 
@@ -37,7 +37,7 @@ function GuiInspectorVariableGroup::buildListField(%this, %fieldName, %fieldLabe
       canSave = "0";
       Visible = "1";
       hovertime = "100";
-      tooltip = %tooltip;
+      tooltip = ""; //%tooltip;
       tooltipProfile = "EditorToolTipProfile";
       text = %fieldLabel;
       maxLength = "1024";
@@ -66,7 +66,7 @@ function GuiInspectorVariableGroup::buildListField(%this, %fieldName, %fieldLabe
       canSave = "1";
       Visible = "1";
       tooltipprofile = "ToolsGuiToolTipProfile";
-      tooltip = %tooltip;
+      tooltip = ""; //%tooltip;
       text = %fieldDefaultVal;
       hovertime = "1000";
       ownerObject = %ownerObj;
diff --git a/Templates/BaseGame/game/tools/gui/fieldTypes/range.tscript b/Templates/BaseGame/game/tools/gui/fieldTypes/range.tscript
index 35e55bfe7..efa78ca46 100644
--- a/Templates/BaseGame/game/tools/gui/fieldTypes/range.tscript
+++ b/Templates/BaseGame/game/tools/gui/fieldTypes/range.tscript
@@ -76,7 +76,7 @@ function GuiInspectorVariableGroup::buildRangeField(%this, %fieldName, %fieldLab
       Visible = "1";
       Command = "$thisControl.onDragComplete();";
       tooltipprofile = "GuiToolTipProfile";
-      tooltip = %tooltip;
+      tooltip = ""; //%tooltip;
       hovertime = "1000";
       canSaveDynamicFields = "0";
       ownerObject = %ownerObj;
diff --git a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorProfiles.ed.tscript b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorProfiles.ed.tscript
index 433f103ae..e2a16756d 100644
--- a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorProfiles.ed.tscript
+++ b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorProfiles.ed.tscript
@@ -69,6 +69,8 @@ function GuiEditor::createNewProfile( %this, %name, %copySource )
 
 function GuiEditor::getProfileCategory( %this, %profile )
 {
+   // TODO
+   %name = "";
    if( %this.isDefaultProfile( %name ) )
       return "Default";
    else if( %profile.category !$= "" )
diff --git a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorUndo.ed.tscript b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorUndo.ed.tscript
index fad91557e..f28a26109 100644
--- a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorUndo.ed.tscript
+++ b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorUndo.ed.tscript
@@ -364,6 +364,10 @@ function GenericUndoAction::learn(%this, %object)
    %oldFieldNames = %this.fieldNames[%object];
    %numNewFields = getWordCount(%newFieldNames);
    %numOldFields = getWordCount(%oldFieldNames);
+
+   %newNullFields = "";
+   %oldNullFields = "";
+
    // compare the old field list to the new field list.
    // if a field is on the old list that isn't on the new list, 
    // add it to the newNullFields list.
diff --git a/Templates/BaseGame/game/tools/materialEditor/gui/guiMaterialPropertiesWindow.ed.gui b/Templates/BaseGame/game/tools/materialEditor/gui/guiMaterialPropertiesWindow.ed.gui
index 93a1f190f..068ca15ee 100644
--- a/Templates/BaseGame/game/tools/materialEditor/gui/guiMaterialPropertiesWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/materialEditor/gui/guiMaterialPropertiesWindow.ed.gui
@@ -233,8 +233,6 @@ $guiContent = new GuiControl(MaterialEditorGui,EditorGuiGroup) {
                   Margin = "4 4 4 0";
                   DragSizable = false;
                   container = true;
-                  parentRollout = %this.rollout;
-                  object = %behavior;
                   
                   new GuiStackControl() {
                      StackingType = "Vertical";
@@ -543,9 +541,6 @@ $guiContent = new GuiControl(MaterialEditorGui,EditorGuiGroup) {
                   Margin = "4 4 4 0";
                   DragSizable = false;
                   container = true;
-                  parentRollout = %this.rollout;
-                  object = %behavior;
-                  object = %behavior;
                   
                   new GuiStackControl() {
                      StackingType = "Vertical";
@@ -1923,8 +1918,6 @@ $guiContent = new GuiControl(MaterialEditorGui,EditorGuiGroup) {
                   Margin = "4 4 4 0";
                   DragSizable = false;
                   container = true;
-                  parentRollout = %this.rollout;
-                  object = %behavior;
                   
                   new GuiStackControl() {
                      StackingType = "Vertical";
@@ -2623,8 +2616,6 @@ $guiContent = new GuiControl(MaterialEditorGui,EditorGuiGroup) {
                   Margin = "-1 0 0 0";
                   DragSizable = false;
                   container = true;
-                  parentRollout = %this.rollout;
-                  object = %behavior;
                   
                   new GuiStackControl() {
                      StackingType = "Vertical";
@@ -3100,8 +3091,6 @@ $guiContent = new GuiControl(MaterialEditorGui,EditorGuiGroup) {
                   Margin = "-1 0 0 0";
                   DragSizable = false;
                   container = true;
-                  parentRollout = %this.rollout;
-                  object = %behavior;
                   
                   new GuiStackControl() {
                      StackingType = "Vertical";
@@ -3373,8 +3362,6 @@ $guiContent = new GuiControl(MaterialEditorGui,EditorGuiGroup) {
                   Margin = "-1 0 0 0";
                   DragSizable = false;
                   container = true;
-                  parentRollout = %this.rollout;
-                  object = %behavior;
                   
                   new GuiStackControl() {
                      StackingType = "Vertical";
@@ -4191,8 +4178,6 @@ $guiContent = new GuiControl(MaterialEditorGui,EditorGuiGroup) {
                   Margin = "4 4 4 0";
                   DragSizable = false;
                   container = true;
-                  parentRollout = %this.rollout;
-                  object = %behavior;
                            
                   new GuiStackControl() {
                      StackingType = "Vertical";
diff --git a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
index bcb2b2c29..84b345299 100644
--- a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
@@ -1496,7 +1496,8 @@ function MaterialEditorGui::updateAnimationFlags(%this)
 {
    MaterialEditorGui.setMaterialDirty();
    %single = true;
-   
+   %flags = "";
+
    if(MaterialEditorPropertiesWindow-->RotationAnimation.getValue() == true)
    {
       if(%single == true)
diff --git a/Templates/BaseGame/game/tools/meshRoadEditor/meshRoadEditorGui.tscript b/Templates/BaseGame/game/tools/meshRoadEditor/meshRoadEditorGui.tscript
index 3fcfd528f..0c8533875 100644
--- a/Templates/BaseGame/game/tools/meshRoadEditor/meshRoadEditorGui.tscript
+++ b/Templates/BaseGame/game/tools/meshRoadEditor/meshRoadEditorGui.tscript
@@ -136,7 +136,7 @@ function MeshRoadEditorGui::editNodeDetails( %this )
 
 function MeshRoadEditorGui::onBrowseClicked( %this )
 {
-   //%filename = RETextureFileCtrl.getText();
+   %filename = RETextureFileCtrl.getText();
 
    %dlg = new OpenFileDialog()
    {
diff --git a/Templates/BaseGame/game/tools/particleEditor/ParticleEditor.ed.gui b/Templates/BaseGame/game/tools/particleEditor/ParticleEditor.ed.gui
index 9cd6f594c..6b7ab94a5 100644
--- a/Templates/BaseGame/game/tools/particleEditor/ParticleEditor.ed.gui
+++ b/Templates/BaseGame/game/tools/particleEditor/ParticleEditor.ed.gui
@@ -271,8 +271,6 @@ $guiContent = new GuiWindowCollapseCtrl(PE_Window) {
                   Margin = "4 4 4 0";
                   DragSizable = false;
                   container = true;
-                  parentRollout = %this.rollout;
-                  object = %behavior;
                   
                   new GuiStackControl() {
                      StackingType = "Vertical";
@@ -584,8 +582,6 @@ $guiContent = new GuiWindowCollapseCtrl(PE_Window) {
                   Margin = "4 4 4 0";
                   DragSizable = false;
                   container = true;
-                  parentRollout = %this.rollout;
-                  object = %behavior;
                   
                   new GuiStackControl() {
                      StackingType = "Vertical";
@@ -826,9 +822,7 @@ $guiContent = new GuiWindowCollapseCtrl(PE_Window) {
                   Margin = "4 4 4 0";
                   DragSizable = false;
                   container = true;
-                  parentRollout = %this.rollout;
-                  object = %behavior;
-                  
+
                   new GuiStackControl() {
                      StackingType = "Vertical";
                      HorizStacking = "Left to Right";
@@ -1272,8 +1266,6 @@ $guiContent = new GuiWindowCollapseCtrl(PE_Window) {
                   Margin = "4 4 4 0";
                   DragSizable = false;
                   container = true;
-                  parentRollout = %this.rollout;
-                  object = %behavior;
                   
                   new GuiStackControl() {
                      StackingType = "Vertical";
@@ -1359,7 +1351,7 @@ $guiContent = new GuiWindowCollapseCtrl(PE_Window) {
                            MinExtent = "8 2";
                            canSave = "1";
                            Visible = "1";
-                           Command = "%particleId = PEE_EmitterParticle2-->PopUpMenu.findText( \"None\" ); PEE_EmitterParticle2-->PopUpMenu.setSelected( %particleId );PE_EmitterEditor.updateParticlesFields();"; 
+                           Command = "$_particleId = PEE_EmitterParticle2-->PopUpMenu.findText( \"None\" ); PEE_EmitterParticle2-->PopUpMenu.setSelected( $_particleId );PE_EmitterEditor.updateParticlesFields();"; 
                            hovertime = "1000";
                            tooltip = "Clear Particle 2 from Emitter";
                            text = "";
@@ -1407,7 +1399,7 @@ $guiContent = new GuiWindowCollapseCtrl(PE_Window) {
                            MinExtent = "8 2";
                            canSave = "1";
                            Visible = "1";
-                           Command = "%particleId = PEE_EmitterParticle3-->PopUpMenu.findText( \"None\" ); PEE_EmitterParticle3-->PopUpMenu.setSelected( %particleId );PE_EmitterEditor.updateParticlesFields();"; 
+                           Command = "$_particleId = PEE_EmitterParticle3-->PopUpMenu.findText( \"None\" ); PEE_EmitterParticle3-->PopUpMenu.setSelected( $_particleId );PE_EmitterEditor.updateParticlesFields();"; 
                            hovertime = "1000";
                            tooltip = "Clear Particle 3 from Emitter";
                            text = "";
@@ -1455,7 +1447,7 @@ $guiContent = new GuiWindowCollapseCtrl(PE_Window) {
                            MinExtent = "8 2";
                            canSave = "1";
                            Visible = "1";
-                           Command = "%particleId = PEE_EmitterParticle4-->PopUpMenu.findText( \"None\" ); PEE_EmitterParticle4-->PopUpMenu.setSelected( %particleId );PE_EmitterEditor.updateParticlesFields();"; 
+                           Command = "$_particleId = PEE_EmitterParticle4-->PopUpMenu.findText( \"None\" ); PEE_EmitterParticle4-->PopUpMenu.setSelected( $_particleId );PE_EmitterEditor.updateParticlesFields();"; 
                            hovertime = "1000";
                            tooltip = "Clear Particle 4 from Emitter";
                            text = "";
@@ -1479,8 +1471,6 @@ $guiContent = new GuiWindowCollapseCtrl(PE_Window) {
                   Margin = "4 4 4 0";
                   DragSizable = false;
                   container = true;
-                  parentRollout = %this.rollout;
-                  object = %behavior;
                   
                   new GuiStackControl() {
                      StackingType = "Vertical";
@@ -1933,8 +1923,6 @@ $guiContent = new GuiWindowCollapseCtrl(PE_Window) {
                   Margin = "4 4 4 0";
                   DragSizable = false;
                   container = true;
-                  parentRollout = %this.rollout;
-                  object = %behavior;
                   
                   new GuiStackControl() {
                      StackingType = "Vertical";
@@ -2233,8 +2221,6 @@ $guiContent = new GuiWindowCollapseCtrl(PE_Window) {
                   Margin = "4 4 4 0";
                   DragSizable = false;
                   container = true;
-                  parentRollout = %this.rollout;
-                  object = %behavior;
                   
                   new GuiStackControl() {
                      StackingType = "Vertical";
@@ -2518,8 +2504,6 @@ $guiContent = new GuiWindowCollapseCtrl(PE_Window) {
                   Margin = "4 4 4 0";
                   DragSizable = false;
                   container = true;
-                  parentRollout = %this.rollout;
-                  object = %behavior;
                   
                   new GuiStackControl() {
                      StackingType = "Vertical";
@@ -2720,8 +2704,6 @@ $guiContent = new GuiWindowCollapseCtrl(PE_Window) {
                   Margin = "4 4 4 0";
                   DragSizable = false;
                   container = true;
-                  parentRollout = %this.rollout;
-                  object = %behavior;
                   
                   new GuiStackControl() {
                      StackingType = "Vertical";
@@ -2865,8 +2847,6 @@ $guiContent = new GuiWindowCollapseCtrl(PE_Window) {
                   Margin = "4 4 4 0";
                   DragSizable = false;
                   container = true;
-                  parentRollout = %this.rollout;
-                  object = %behavior;
                   
                   new GuiStackControl() {
                      StackingType = "Vertical";
diff --git a/Templates/BaseGame/game/tools/roadEditor/roadEditorGui.tscript b/Templates/BaseGame/game/tools/roadEditor/roadEditorGui.tscript
index acaad89b8..115da9d5c 100644
--- a/Templates/BaseGame/game/tools/roadEditor/roadEditorGui.tscript
+++ b/Templates/BaseGame/game/tools/roadEditor/roadEditorGui.tscript
@@ -138,7 +138,7 @@ function RoadEditorGui::editNodeDetails( %this )
 
 function RoadEditorGui::onBrowseClicked( %this )
 {
-   //%filename = RETextureFileCtrl.getText();
+   %filename = RETextureFileCtrl.getText();
          
    %dlg = new OpenFileDialog()
    {
diff --git a/Templates/BaseGame/game/tools/shapeEditor/scripts/shapeEditor.ed.tscript b/Templates/BaseGame/game/tools/shapeEditor/scripts/shapeEditor.ed.tscript
index 6959226c0..9067b5bcd 100644
--- a/Templates/BaseGame/game/tools/shapeEditor/scripts/shapeEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/shapeEditor/scripts/shapeEditor.ed.tscript
@@ -1439,6 +1439,8 @@ function ShapeEdPropWindow::update_onSequenceBlendChanged( %this, %seqName, %ble
    %proxyName = ShapeEditor.getProxyName( %seqName );
    if ( ShapeEditor.shape.getSequenceIndex( %proxyName ) != -1 )
    {
+      //TODO
+      %oldBlend = false;
       if ( %blend && %oldBlend )
          ShapeEditor.shape.setSequenceBlend( %proxyName, false, %oldBlendSeq, %oldBlendFrame );
       ShapeEditor.shape.setSequenceBlend( %proxyName, %blend, %blendSeq, %blendFrame );
@@ -2217,7 +2219,7 @@ function ShapeEdTriggerList::updateItem( %this, %oldFrame, %oldState, %frame, %s
       if ( %frame != %oldFrame )
       {
          %pos = ShapeEdAnimWindow.getTimelineBitmapPos( ShapeEdAnimWindow-->seqIn.getText() + %frame, 2 );
-         eval( "%ctrl = ShapeEdAnimWindow-->trigger" @ %updatedId @ ";" );
+         %ctrl = eval( "return ShapeEdAnimWindow-->trigger" @ %updatedId @ ";" );
          %ctrl.position = %pos SPC "0";
       }
    }
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/ConvexEditorPalette.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/ConvexEditorPalette.ed.gui
index e32cdfb4a..9453ae0e9 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/ConvexEditorPalette.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/ConvexEditorPalette.ed.gui
@@ -1,4 +1,4 @@
-%paletteId = new GuiControl(ConvexEditorPalette, EditorGuiGroup) {
+$paletteId = new GuiControl(ConvexEditorPalette, EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/DecalEditorPalette.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/DecalEditorPalette.ed.gui
index 1e4053c8e..863eb1e68 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/DecalEditorPalette.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/DecalEditorPalette.ed.gui
@@ -1,4 +1,4 @@
-%paletteId = new GuiControl(DecalEditorPalette,EditorGuiGroup) {
+$paletteId = new GuiControl(DecalEditorPalette,EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/ForestEditorPalette.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/ForestEditorPalette.ed.gui
index a1cc96ef5..4e5976fb3 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/ForestEditorPalette.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/ForestEditorPalette.ed.gui
@@ -1,4 +1,4 @@
-%paletteId = new GuiControl(ForestEditorPalette,EditorGuiGroup) {
+$paletteId = new GuiControl(ForestEditorPalette,EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/MeshRoadEditorPalette.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/MeshRoadEditorPalette.ed.gui
index b005ac958..63a1e7acb 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/MeshRoadEditorPalette.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/MeshRoadEditorPalette.ed.gui
@@ -1,4 +1,4 @@
-%paletteId = new GuiControl(MeshRoadEditorPalette,EditorGuiGroup) {
+$paletteId = new GuiControl(MeshRoadEditorPalette,EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/NavEditorPalette.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/NavEditorPalette.ed.gui
index a18e3f4ba..c275e30f1 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/NavEditorPalette.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/NavEditorPalette.ed.gui
@@ -1,4 +1,4 @@
-%paletteId = new GuiControl(NavEditorPalette,EditorGuiGroup) {
+$paletteId = new GuiControl(NavEditorPalette,EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/RiverEditorPalette.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/RiverEditorPalette.ed.gui
index 5fea48b1b..1b86bc1bd 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/RiverEditorPalette.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/RiverEditorPalette.ed.gui
@@ -1,4 +1,4 @@
-%paletteId = new GuiControl(RiverEditorPalette,EditorGuiGroup) {
+$paletteId = new GuiControl(RiverEditorPalette,EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/RoadEditorPalette.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/RoadEditorPalette.ed.gui
index 712ea774f..787f93050 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/RoadEditorPalette.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/RoadEditorPalette.ed.gui
@@ -1,4 +1,4 @@
-%paletteId = new GuiControl(RoadEditorPalette,EditorGuiGroup) {
+$paletteId = new GuiControl(RoadEditorPalette,EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/ShapeEditorPalette.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/ShapeEditorPalette.ed.gui
index e8dfaf0e9..6c93bfa63 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/ShapeEditorPalette.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/ShapeEditorPalette.ed.gui
@@ -1,4 +1,4 @@
-%paletteId = new GuiControl(ShapeEditorPalette,EditorGuiGroup) {
+$paletteId = new GuiControl(ShapeEditorPalette,EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/TerrainEditPalette.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/TerrainEditPalette.ed.gui
index 0ab8f2b1e..1b9e241a4 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/TerrainEditPalette.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/TerrainEditPalette.ed.gui
@@ -1,4 +1,4 @@
-%paletteId = new GuiControl(TerrainEditorPalette,EditorGuiGroup) {
+$paletteId = new GuiControl(TerrainEditorPalette,EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/TerrainPainterPalette.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/TerrainPainterPalette.ed.gui
index 091f7a1c0..9e48b7fd2 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/TerrainPainterPalette.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/TerrainPainterPalette.ed.gui
@@ -1,4 +1,4 @@
-%paletteId = new GuiControl(TerrainPainterPalette,EditorGuiGroup) {
+$paletteId = new GuiControl(TerrainPainterPalette,EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/WorldEditorPalette.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/WorldEditorPalette.ed.gui
index 421b52fe4..9c0b9ef6a 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/WorldEditorPalette.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/WorldEditorPalette.ed.gui
@@ -1,4 +1,4 @@
-%paletteId = new GuiControl(WorldEditorInspectorPalette, EditorGuiGroup) {
+$paletteId = new GuiControl(WorldEditorInspectorPalette, EditorGuiGroup) {
    canSaveDynamicFields = "0";
    Enabled = "1";
    isContainer = "1";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/init.tscript b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/init.tscript
index 637739745..86bc5b551 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/init.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/init.tscript
@@ -30,6 +30,9 @@ function EWToolsPaletteWindow::loadToolsPalettes()
       exec( %file );
       %paletteGroup = 0;      
       
+      // TODO
+      %paletteId = 0;
+
       %i = %paletteId.getCount();
       for( ; %i != 0; %i--)
       {
@@ -49,6 +52,9 @@ function EWToolsPaletteWindow::loadToolsPalettes()
       exec( %file );
       %paletteGroup = 0;      
       
+      // TODO
+      %paletteId = 0;
+
       %i = %paletteId.getCount();
       for( ; %i != 0; %i--)
       {
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainExportGui.gui b/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainExportGui.gui
index fd62d885a..0953e8620 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainExportGui.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainExportGui.gui
@@ -288,6 +288,9 @@ function TerrainExportGui::selectFolder( %this )
 
 function TerrainExportGui::doOpenDialog( %this, %filter, %callback )
 {
+   // TODO
+   %currentFile = "";
+
    %dlg = new OpenFolderDialog()
    {
       Title = "Select Export Folder";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainImportGui.gui b/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainImportGui.gui
index 9055f4fdc..d1bfe1ded 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainImportGui.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainImportGui.gui
@@ -508,6 +508,8 @@ function TerrainImportGui::acceptSettings( %this )
    
    AssetBrowser.newAssetSettings.opacityList = %this-->OpacityLayerTextList;
    
+   %opacityList = %this-->OpacityLayerTextList;
+
    for( %i = 0; %i < %opacityList.rowCount(); %i++ )
    {
       %itemText = %opacityList.getRowTextById( %i );
@@ -535,6 +537,9 @@ function TerrainImportGui::cancel( %this )
 
 function TerrainImportGui::doOpenDialog( %this, %filter, %callback )
 {
+   // TODO
+   %currentFile = "";
+
    %dlg = new OpenFileDialog()
    {
       Filters = %filter;
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
index 1f5dc01f3..e1f73155c 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
@@ -399,7 +399,7 @@ function EditorGui::addToToolsToolbar( %this, %pluginName, %internalName, %bitma
          Visible = "1";
          Command = "EditorGui.setEditor(" @ %pluginName @ ");";
          tooltipprofile = "ToolsGuiToolTipProfile";
-         ToolTip = %tooltip;
+         ToolTip = "";// %tooltip;
          hovertime = "750";
          bitmap = %bitmap;
          buttonType = "RadioButton";
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/ManageSFXParametersWindow.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/ManageSFXParametersWindow.ed.tscript
index f788c7edb..e005c4c3e 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/ManageSFXParametersWindow.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/ManageSFXParametersWindow.ed.tscript
@@ -137,8 +137,7 @@ function EManageSFXParameters::onVisible( %this, %value )
    if( %value )
    {
       // Schedule an update.
-
-      %this.schedule( %SFX_PARAMETERS_UPDATE_INTERVAL, "update" );      
+      %this.schedule( $SFX_PARAMETERS_UPDATE_INTERVAL, "update" );      
    }
 }
 
@@ -770,7 +769,7 @@ function EManageSFXParameters::addParameter( %this, %parameter )
    
    // Set the fields to reflect the parameter's current settings.
    
-   %ctrl-->valueField.setValue( %paramter.value );
+   %ctrl-->valueField.setValue( %parameter.value );
    %ctrl-->rangeMinField.setText( %parameter.range.x );
    %ctrl-->rangeMaxField.setText( %parameter.range.y );
    %ctrl-->defaultField.setValue( %parameter.defaultValue );
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/menuHandlers.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/menuHandlers.ed.tscript
index 3fb4b1652..8a874e613 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/menuHandlers.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/menuHandlers.ed.tscript
@@ -871,6 +871,7 @@ function EditorToolsMenu::onSelectItem(%this, %id)
 {
    %toolName = getField( %this.item[%id], 2 );  
 
+   %paletteName = "";
    EditorGui.setEditor(%toolName, %paletteName  );
    
    %this.checkRadioItem(0, %this.getItemCount(), %id);

From 8fc0db21c14c76d36ded517278126460230d7bdc Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Fri, 18 Jun 2021 18:52:41 -0400
Subject: [PATCH 023/399] Small fixes for the script interpreter.

---
 Engine/source/console/compiledEval.cpp    | 14 +++++++-------
 Engine/source/console/simManager.cpp      |  4 ++--
 Engine/source/console/test/ScriptTest.cpp |  4 ++--
 3 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index b02f2f8fd..061484659 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -518,17 +518,17 @@ TORQUE_NOINLINE void doSlowMathOp()
 
    // Logical
    if constexpr (Op == FloatOperation::LT)
-      stack[_STK - 1].setFastInt(a.getFloat() < b.getFloat());
+      stack[_STK - 1].setInt(a.getFloat() < b.getFloat());
    if constexpr (Op == FloatOperation::LE)
-      stack[_STK - 1].setFastInt(a.getFloat() <= b.getFloat());
+      stack[_STK - 1].setInt(a.getFloat() <= b.getFloat());
    if constexpr (Op == FloatOperation::GR)
-      stack[_STK - 1].setFastInt(a.getFloat() > b.getFloat());
+      stack[_STK - 1].setInt(a.getFloat() > b.getFloat());
    if constexpr (Op == FloatOperation::GE)
-      stack[_STK - 1].setFastInt(a.getFloat() >= b.getFloat());
+      stack[_STK - 1].setInt(a.getFloat() >= b.getFloat());
    if constexpr (Op == FloatOperation::EQ)
-      stack[_STK - 1].setFastInt(a.getFloat() == b.getFloat());
+      stack[_STK - 1].setInt(a.getFloat() == b.getFloat());
    if constexpr (Op == FloatOperation::NE)
-      stack[_STK - 1].setFastInt(a.getFloat() != b.getFloat());
+      stack[_STK - 1].setInt(a.getFloat() != b.getFloat());
 
    _STK--;
 }
@@ -1276,7 +1276,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
             _STK++; // Not nice but works.
          }
 
-         returnValue.setString(stack[_STK].getString());
+         returnValue = std::move(stack[_STK]);
          _STK--;
 
          goto execFinished;
diff --git a/Engine/source/console/simManager.cpp b/Engine/source/console/simManager.cpp
index 7aaf773e6..c8fb60c7f 100644
--- a/Engine/source/console/simManager.cpp
+++ b/Engine/source/console/simManager.cpp
@@ -389,14 +389,14 @@ SimObject* findObject(const char* name)
 SimObject* findObject(const ConsoleValue &val)
 {
    if (val.getType() == ConsoleValueType::cvInteger)
-      return findObject((SimObjectId)val.getInt());
+      return findObject((SimObjectId)val.getFastInt());
    return findObject(val.getString());
 }
 
 SimObject* findObject(ConsoleValue* val)
 {
    if (val->getType() == ConsoleValueType::cvInteger)
-      return findObject((SimObjectId)val->getInt());
+      return findObject((SimObjectId)val->getFastInt());
    return findObject(val->getString());
 }
 
diff --git a/Engine/source/console/test/ScriptTest.cpp b/Engine/source/console/test/ScriptTest.cpp
index ecc974d2f..ccde5439f 100644
--- a/Engine/source/console/test/ScriptTest.cpp
+++ b/Engine/source/console/test/ScriptTest.cpp
@@ -410,14 +410,14 @@ TEST(Script, ForEachLoop)
 TEST(Script, TorqueScript_Array_Testing)
 {
    ConsoleValue value = RunScript(R"(
-         function t(%idx) { %a[idx] = 2; return %a[idx]; }
+         function t(%idx) { %a[%idx] = 2; return %a[%idx]; }
          return t(5);
    )");
 
    ASSERT_EQ(value.getInt(), 2);
 
    ConsoleValue value2 = RunScript(R"(
-         function t(%idx) { %a[idx, 0] = 2; return %a[idx, 0]; }
+         function t(%idx) { %a[%idx, 0] = 2; return %a[%idx, 0]; }
          return t(5);
    )");
 

From 085af8e7625a27fea668e557b2705ed083debeda Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Sat, 19 Jun 2021 12:28:32 -0400
Subject: [PATCH 024/399] fix %obj.field op assign.

---
 Engine/source/console/astNodes.cpp        |  2 +-
 Engine/source/console/test/ScriptTest.cpp | 16 ++++++++++++++++
 2 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/Engine/source/console/astNodes.cpp b/Engine/source/console/astNodes.cpp
index 1f8fea367..99a9ddad1 100644
--- a/Engine/source/console/astNodes.cpp
+++ b/Engine/source/console/astNodes.cpp
@@ -1432,7 +1432,7 @@ U32 SlotAssignOpNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
    codeStream.emit((subType == TypeReqFloat) ? OP_LOADFIELD_FLT : OP_LOADFIELD_UINT);
    codeStream.emit(operand);
    codeStream.emit((subType == TypeReqFloat) ? OP_SAVEFIELD_FLT : OP_SAVEFIELD_UINT);
-   if (subType == TypeReqNone)
+   if (type == TypeReqNone)
       codeStream.emit(OP_POP_STK);
    return codeStream.tell();
 }
diff --git a/Engine/source/console/test/ScriptTest.cpp b/Engine/source/console/test/ScriptTest.cpp
index ccde5439f..58441c3d2 100644
--- a/Engine/source/console/test/ScriptTest.cpp
+++ b/Engine/source/console/test/ScriptTest.cpp
@@ -512,6 +512,22 @@ TEST(Script, Basic_SimObject)
    )");
 
    ASSERT_STREQ(fieldTest.getString(), "B");
+
+   ConsoleValue fieldOpTest = RunScript(R"(
+         function a()
+         {
+            %obj = new SimObject();
+            %obj.field = 1;
+            %obj.field += 2;
+
+            %value = %obj.field;
+            %obj.delete();
+            return %value;
+         }
+         return a();
+   )");
+
+   ASSERT_EQ(fieldOpTest.getInt(), 3);
 }
 
 TEST(Script, Internal_Name)

From 464cb7ae299d05d5fe2ed02af342d91f25b49de9 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Sat, 19 Jun 2021 13:48:32 -0400
Subject: [PATCH 025/399] Better error messages when compiling script.

---
 Engine/source/console/astNodes.cpp | 35 +++++++++++++++---------------
 1 file changed, 18 insertions(+), 17 deletions(-)

diff --git a/Engine/source/console/astNodes.cpp b/Engine/source/console/astNodes.cpp
index 99a9ddad1..65cafe70d 100644
--- a/Engine/source/console/astNodes.cpp
+++ b/Engine/source/console/astNodes.cpp
@@ -66,12 +66,12 @@ class FuncVars
    };
 
 public:
-   S32 assign(StringTableEntry var, TypeReq currentType, bool isConstant = false)
+   S32 assign(StringTableEntry var, TypeReq currentType, S32 lineNumber, bool isConstant = false)
    {
       std::unordered_map<StringTableEntry, Var>::iterator found = vars.find(var);
       if (found != vars.end())
       {
-         AssertISV(!found->second.isConstant, avar("Reassigning variable %s when it is a constant", var));
+         AssertISV(!found->second.isConstant, avar("Reassigning variable %s when it is a constant. File: %s Line : %d", var, CodeBlock::smCurrentParser->getCurrentFile(), lineNumber));
          return found->second.reg;
       }
 
@@ -80,17 +80,18 @@ public:
       return id;
    }
 
-   S32 lookup(StringTableEntry var)
+   S32 lookup(StringTableEntry var, S32 lineNumber)
    {
       std::unordered_map<StringTableEntry, Var>::iterator found = vars.find(var);
-      AssertISV(found != vars.end(), avar("Variable %s referenced before used when compiling script.", var));
+      AssertISV(found != vars.end(), avar("Variable %s referenced before used when compiling script. File: %s Line: %d", var, CodeBlock::smCurrentParser->getCurrentFile(), lineNumber));
       return found->second.reg;
    }
 
-   TypeReq lookupType(StringTableEntry var)
+   TypeReq lookupType(StringTableEntry var, S32 lineNumber)
    {
       std::unordered_map<StringTableEntry, Var>::iterator found = vars.find(var);
-      AssertISV(found != vars.end(), avar("Variable %s referenced before used when compiling script.", var));
+
+      AssertISV(found != vars.end(), avar("Variable %s referenced before used when compiling script. File: %s Line: %d", var, CodeBlock::smCurrentParser->getCurrentFile(), lineNumber));
       return found->second.currentType;
    }
 
@@ -103,9 +104,9 @@ private:
 
 FuncVars* gFuncVars = NULL;
 
-inline FuncVars* getFuncVars()
+inline FuncVars* getFuncVars(S32 lineNumber)
 {
-   AssertISV(gFuncVars, "Attemping to use local variable in global scope.");
+   AssertISV(gFuncVars, avar("Attemping to use local variable in global scope. File: %s Line: %d", CodeBlock::smCurrentParser->getCurrentFile(), lineNumber));
    return gFuncVars;
 }
 
@@ -383,7 +384,7 @@ U32 IterStmtNode::compileStmt(CodeStream& codeStream, U32 ip)
    if (isGlobal)
       codeStream.emitSTE(varName);
    else
-      codeStream.emit(getFuncVars()->assign(varName, varType));
+      codeStream.emit(getFuncVars(dbgLineNumber)->assign(varName, varType, dbgLineNumber));
    const U32 finalFix = codeStream.emit(0);
    const U32 continueIp = codeStream.emit(OP_ITER);
    codeStream.emitFix(CodeStream::FIXTYPE_BREAK);
@@ -736,7 +737,7 @@ U32 VarNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
       default:           codeStream.emit(OP_LOAD_LOCAL_VAR_STR);
       }
 
-      codeStream.emit(getFuncVars()->lookup(varName));
+      codeStream.emit(getFuncVars(dbgLineNumber)->lookup(varName, dbgLineNumber));
    }
 
    return codeStream.tell();
@@ -745,7 +746,7 @@ U32 VarNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 TypeReq VarNode::getPreferredType()
 {
    bool oldVariables = arrayIndex || varName[0] == '$';
-   return oldVariables ? TypeReqNone : getFuncVars()->lookupType(varName);
+   return oldVariables ? TypeReqNone : getFuncVars(dbgLineNumber)->lookupType(varName, dbgLineNumber);
 }
 
 //------------------------------------------------------------
@@ -983,7 +984,7 @@ U32 AssignExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
       case TypeReqFloat: codeStream.emit(OP_SAVE_LOCAL_VAR_FLT); break;
       default:           codeStream.emit(OP_SAVE_LOCAL_VAR_STR);
       }
-      codeStream.emit(getFuncVars()->assign(varName, subType == TypeReqNone ? TypeReqString : subType));
+      codeStream.emit(getFuncVars(dbgLineNumber)->assign(varName, subType == TypeReqNone ? TypeReqString : subType, dbgLineNumber));
    }
 
    if (type == TypeReqNone)
@@ -1081,7 +1082,7 @@ U32 AssignOpExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 
    if (op == opPLUSPLUS && !oldVariables)
    {
-      const S32 varIdx = getFuncVars()->assign(varName, TypeReqFloat);
+      const S32 varIdx = getFuncVars(dbgLineNumber)->assign(varName, TypeReqFloat, dbgLineNumber);
 
       codeStream.emit(OP_INC);
       codeStream.emit(varIdx);
@@ -1116,7 +1117,7 @@ U32 AssignOpExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
       else
       {
          const bool isFloat = subType == TypeReqFloat;
-         const S32 varIdx = getFuncVars()->assign(varName, subType == TypeReqNone ? TypeReqString : subType);
+         const S32 varIdx = getFuncVars(dbgLineNumber)->assign(varName, subType == TypeReqNone ? TypeReqString : subType, dbgLineNumber);
 
          codeStream.emit(isFloat ? OP_LOAD_LOCAL_VAR_FLT : OP_LOAD_LOCAL_VAR_UINT);
          codeStream.emit(varIdx);
@@ -1562,7 +1563,7 @@ U32 FunctionDeclStmtNode::compileStmt(CodeStream& codeStream, U32 ip)
    for (VarNode* walk = args; walk; walk = (VarNode*)((StmtNode*)walk)->getNext())
    {
       precompileIdent(walk->varName);
-      getFuncVars()->assign(walk->varName, TypeReqNone);
+      getFuncVars(dbgLineNumber)->assign(walk->varName, TypeReqNone, dbgLineNumber);
       argc++;
    }
 
@@ -1586,7 +1587,7 @@ U32 FunctionDeclStmtNode::compileStmt(CodeStream& codeStream, U32 ip)
    for (VarNode* walk = args; walk; walk = (VarNode*)((StmtNode*)walk)->getNext())
    {
       StringTableEntry name = walk->varName;
-      codeStream.emit(getFuncVars()->lookup(name));
+      codeStream.emit(getFuncVars(dbgLineNumber)->lookup(name, dbgLineNumber));
    }
    CodeBlock::smInFunction = true;
    ip = compileBlock(stmts, codeStream, ip);
@@ -1598,7 +1599,7 @@ U32 FunctionDeclStmtNode::compileStmt(CodeStream& codeStream, U32 ip)
    CodeBlock::smInFunction = false;
    codeStream.emit(OP_RETURN_VOID);
 
-   codeStream.patch(localNumVarsIP, getFuncVars()->count());
+   codeStream.patch(localNumVarsIP, getFuncVars(dbgLineNumber)->count());
    codeStream.patch(endIp, codeStream.tell());
 
    setCurrentStringTable(&getGlobalStringTable());

From 6ad287650440aeb3c78929a8d09a80035f33b3fe Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Fri, 9 Jul 2021 21:05:55 -0400
Subject: [PATCH 026/399] * BugFix: Correct 3 missing defines in the GCC types
 include file. * BugFix: Move several compiledEval declarations around to
 resolve ordering issues. * BugFix: Experimentally remove the reference on an
 engineAPI template function to allow parameter types to match.

---
 Engine/source/console/compiledEval.cpp | 120 ++++++++++++-------------
 Engine/source/console/engineAPI.h      |   2 +-
 Engine/source/platform/types.gcc.h     |   3 +
 3 files changed, 64 insertions(+), 61 deletions(-)

diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index 061484659..10d201874 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -459,6 +459,39 @@ enum class FloatOperation
    NE
 };
 
+template<FloatOperation Op>
+TORQUE_NOINLINE void doSlowMathOp()
+{
+   ConsoleValue& a = stack[_STK];
+   ConsoleValue& b = stack[_STK - 1];
+
+   // Arithmetic
+   if constexpr (Op == FloatOperation::Add)
+      stack[_STK - 1].setFloat(a.getFloat() + b.getFloat());
+   else if constexpr (Op == FloatOperation::Sub)
+      stack[_STK - 1].setFloat(a.getFloat() - b.getFloat());
+   else if constexpr (Op == FloatOperation::Mul)
+      stack[_STK - 1].setFloat(a.getFloat() * b.getFloat());
+   else if constexpr (Op == FloatOperation::Div)
+      stack[_STK - 1].setFloat(a.getFloat() / b.getFloat());
+
+   // Logical
+   if constexpr (Op == FloatOperation::LT)
+      stack[_STK - 1].setInt(a.getFloat() < b.getFloat());
+   if constexpr (Op == FloatOperation::LE)
+      stack[_STK - 1].setInt(a.getFloat() <= b.getFloat());
+   if constexpr (Op == FloatOperation::GR)
+      stack[_STK - 1].setInt(a.getFloat() > b.getFloat());
+   if constexpr (Op == FloatOperation::GE)
+      stack[_STK - 1].setInt(a.getFloat() >= b.getFloat());
+   if constexpr (Op == FloatOperation::EQ)
+      stack[_STK - 1].setInt(a.getFloat() == b.getFloat());
+   if constexpr (Op == FloatOperation::NE)
+      stack[_STK - 1].setInt(a.getFloat() != b.getFloat());
+
+   _STK--;
+}
+
 template<FloatOperation Op>
 TORQUE_FORCEINLINE void doFloatMathOperation()
 {
@@ -500,39 +533,6 @@ TORQUE_FORCEINLINE void doFloatMathOperation()
    }
 }
 
-template<FloatOperation Op>
-TORQUE_NOINLINE void doSlowMathOp()
-{
-   ConsoleValue& a = stack[_STK];
-   ConsoleValue& b = stack[_STK - 1];
-
-   // Arithmetic
-   if constexpr (Op == FloatOperation::Add)
-      stack[_STK - 1].setFloat(a.getFloat() + b.getFloat());
-   else if constexpr (Op == FloatOperation::Sub)
-      stack[_STK - 1].setFloat(a.getFloat() - b.getFloat());
-   else if constexpr (Op == FloatOperation::Mul)
-      stack[_STK - 1].setFloat(a.getFloat() * b.getFloat());
-   else if constexpr (Op == FloatOperation::Div)
-      stack[_STK - 1].setFloat(a.getFloat() / b.getFloat());
-
-   // Logical
-   if constexpr (Op == FloatOperation::LT)
-      stack[_STK - 1].setInt(a.getFloat() < b.getFloat());
-   if constexpr (Op == FloatOperation::LE)
-      stack[_STK - 1].setInt(a.getFloat() <= b.getFloat());
-   if constexpr (Op == FloatOperation::GR)
-      stack[_STK - 1].setInt(a.getFloat() > b.getFloat());
-   if constexpr (Op == FloatOperation::GE)
-      stack[_STK - 1].setInt(a.getFloat() >= b.getFloat());
-   if constexpr (Op == FloatOperation::EQ)
-      stack[_STK - 1].setInt(a.getFloat() == b.getFloat());
-   if constexpr (Op == FloatOperation::NE)
-      stack[_STK - 1].setInt(a.getFloat() != b.getFloat());
-
-   _STK--;
-}
-
 //-----------------------------------------------------------------------------
 
 enum class IntegerOperation
@@ -547,6 +547,33 @@ enum class IntegerOperation
    LogicalOr
 };
 
+template<IntegerOperation Op>
+TORQUE_NOINLINE void doSlowIntegerOp()
+{
+   ConsoleValue& a = stack[_STK];
+   ConsoleValue& b = stack[_STK - 1];
+
+   // Bitwise Op
+   if constexpr (Op == IntegerOperation::BitAnd)
+      stack[_STK - 1].setInt(a.getInt() & b.getInt());
+   if constexpr (Op == IntegerOperation::BitOr)
+      stack[_STK - 1].setInt(a.getInt() | b.getInt());
+   if constexpr (Op == IntegerOperation::Xor)
+      stack[_STK - 1].setInt(a.getInt() ^ b.getInt());
+   if constexpr (Op == IntegerOperation::LShift)
+      stack[_STK - 1].setInt(a.getInt() << b.getInt());
+   if constexpr (Op == IntegerOperation::RShift)
+      stack[_STK - 1].setInt(a.getInt() >> b.getInt());
+
+   // Logical Op
+   if constexpr (Op == IntegerOperation::LogicalAnd)
+      stack[_STK - 1].setInt(a.getInt() && b.getInt());
+   if constexpr (Op == IntegerOperation::LogicalOr)
+      stack[_STK - 1].setInt(a.getInt() || b.getInt());
+
+   _STK--;
+}
+
 template<IntegerOperation Op>
 TORQUE_FORCEINLINE void doIntOperation()
 {
@@ -581,33 +608,6 @@ TORQUE_FORCEINLINE void doIntOperation()
    }
 }
 
-template<IntegerOperation Op>
-TORQUE_NOINLINE void doSlowIntegerOp()
-{
-   ConsoleValue& a = stack[_STK];
-   ConsoleValue& b = stack[_STK - 1];
-
-   // Bitwise Op
-   if constexpr (Op == IntegerOperation::BitAnd)
-      stack[_STK - 1].setInt(a.getInt() & b.getInt());
-   if constexpr (Op == IntegerOperation::BitOr)
-      stack[_STK - 1].setInt(a.getInt() | b.getInt());
-   if constexpr (Op == IntegerOperation::Xor)
-      stack[_STK - 1].setInt(a.getInt() ^ b.getInt());
-   if constexpr (Op == IntegerOperation::LShift)
-      stack[_STK - 1].setInt(a.getInt() << b.getInt());
-   if constexpr (Op == IntegerOperation::RShift)
-      stack[_STK - 1].setInt(a.getInt() >> b.getInt());
-
-   // Logical Op
-   if constexpr (Op == IntegerOperation::LogicalAnd)
-      stack[_STK - 1].setInt(a.getInt() && b.getInt());
-   if constexpr (Op == IntegerOperation::LogicalOr)
-      stack[_STK - 1].setInt(a.getInt() || b.getInt());
-
-   _STK--;
-}
-
 //-----------------------------------------------------------------------------
 
 U32 gExecCount = 0;
diff --git a/Engine/source/console/engineAPI.h b/Engine/source/console/engineAPI.h
index a8540968a..0a6af3dcd 100644
--- a/Engine/source/console/engineAPI.h
+++ b/Engine/source/console/engineAPI.h
@@ -292,7 +292,7 @@ struct EngineUnmarshallData< void >
 template<>
 struct EngineUnmarshallData< ConsoleValue >
 {
-   ConsoleValue operator()( ConsoleValue &ref ) const
+   ConsoleValue operator()( ConsoleValue ref ) const
    {
       return std::move(ref);
    }
diff --git a/Engine/source/platform/types.gcc.h b/Engine/source/platform/types.gcc.h
index 53538dd8d..4e65b23dc 100644
--- a/Engine/source/platform/types.gcc.h
+++ b/Engine/source/platform/types.gcc.h
@@ -43,6 +43,9 @@ typedef unsigned long  U64;
 // Compiler Version
 #define TORQUE_COMPILER_GCC (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
 
+#define TORQUE_FORCEINLINE __attribute__((always_inline))
+#define TORQUE_CASE_FALLTHROUGH __attribute__((fallthrough))
+#define TORQUE_NOINLINE __attribute__ ((noinline))
 
 //--------------------------------------
 // Identify the compiler string

From a449fadde2e025507fe29bb576738f7c74a3b198 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Sat, 14 Aug 2021 01:37:01 -0400
Subject: [PATCH 027/399] hacks to make thedebugger work again.

---
 Engine/source/console/astNodes.cpp       | 15 ++++++++-
 Engine/source/console/codeBlock.cpp      |  2 ++
 Engine/source/console/codeBlock.h        | 21 +++++++++++-
 Engine/source/console/compiledEval.cpp   |  8 ++---
 Engine/source/console/compiler.cpp       | 41 ++++++++++++++++++++++++
 Engine/source/console/compiler.h         |  3 ++
 Engine/source/console/consoleInternal.h  |  5 +++
 Engine/source/console/telnetDebugger.cpp | 37 +++++++++++++++++++--
 8 files changed, 123 insertions(+), 9 deletions(-)

diff --git a/Engine/source/console/astNodes.cpp b/Engine/source/console/astNodes.cpp
index 65cafe70d..104671b1f 100644
--- a/Engine/source/console/astNodes.cpp
+++ b/Engine/source/console/astNodes.cpp
@@ -62,6 +62,7 @@ class FuncVars
    {
       S32 reg;
       TypeReq currentType;
+      StringTableEntry name;
       bool isConstant;
    };
 
@@ -76,7 +77,9 @@ public:
       }
 
       S32 id = counter++;
-      vars[var] = { id, currentType, isConstant };
+      vars[var] = { id, currentType, var, isConstant };
+      variableNameMap[id] = var;
+
       return id;
    }
 
@@ -97,6 +100,8 @@ public:
 
    inline S32 count() { return counter; }
 
+   std::unordered_map<S32, StringTableEntry> variableNameMap;
+
 private:
    std::unordered_map<StringTableEntry, Var> vars;
    S32 counter = 0;
@@ -1604,6 +1609,14 @@ U32 FunctionDeclStmtNode::compileStmt(CodeStream& codeStream, U32 ip)
 
    setCurrentStringTable(&getGlobalStringTable());
    setCurrentFloatTable(&getGlobalFloatTable());
+
+   // map local variables to registers for this function.
+   CompilerLocalVariableToRegisterMappingTable* tbl = &getFunctionVariableMappingTable();
+   for (const auto& pair : gFuncVars->variableNameMap)
+   {
+      tbl->add(fnName, pair.second, pair.first);
+   }
+
    gFuncVars = NULL;
 
    return ip;
diff --git a/Engine/source/console/codeBlock.cpp b/Engine/source/console/codeBlock.cpp
index e7c3d4adb..b58156c4a 100644
--- a/Engine/source/console/codeBlock.cpp
+++ b/Engine/source/console/codeBlock.cpp
@@ -640,6 +640,8 @@ ConsoleValue CodeBlock::compileExec(StringTableEntry fileName, const char *inStr
    globalFloats = getGlobalFloatTable().build();
    functionFloats = getFunctionFloatTable().build();
 
+   variableRegisterTable = getFunctionVariableMappingTable().copy();
+
    codeStream.emit(OP_RETURN_VOID);
    codeStream.emitCodeStream(&codeSize, &code, &lineBreakPairs);
 
diff --git a/Engine/source/console/codeBlock.h b/Engine/source/console/codeBlock.h
index 1daa26bac..be6e48a46 100644
--- a/Engine/source/console/codeBlock.h
+++ b/Engine/source/console/codeBlock.h
@@ -23,6 +23,24 @@
 #ifndef _CODEBLOCK_H_
 #define _CODEBLOCK_H_
 
+#include <unordered_map>
+
+struct CompilerLocalVariableToRegisterMappingTable
+{
+   // First key: function name
+   struct RemappingTable
+   {
+      std::unordered_map<StringTableEntry, S32> table;
+   };
+
+   std::unordered_map<StringTableEntry, RemappingTable> localVarToRegister;
+
+   void add(StringTableEntry functionName, StringTableEntry varName, S32 reg);
+   S32 lookup(StringTableEntry functionName, StringTableEntry varName);
+   CompilerLocalVariableToRegisterMappingTable copy();
+   void reset();
+};
+
 #include "console/compiler.h"
 #include "console/consoleParser.h"
 
@@ -34,7 +52,6 @@ class ConsoleValue;
 /// This class represents a block of code, usually mapped directly to a file.
 class CodeBlock
 {
-   friend class CodeInterpreter;
 private:
    static CodeBlock* smCodeBlockList;
    static CodeBlock* smCurrentCodeBlock;
@@ -77,6 +94,8 @@ public:
    U32 codeSize;
    U32 *code;
 
+   CompilerLocalVariableToRegisterMappingTable variableRegisterTable;
+
    U32 refCount;
    U32 lineBreakPairCount;
    U32 *lineBreakPairs;
diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index 10d201874..b80530162 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -1773,8 +1773,8 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          //if this is called from inside a function, append the ip and codeptr
          if (!gEvalState.stack.empty())
          {
-            gEvalState.stack.last()->code = this;
-            gEvalState.stack.last()->ip = ip - 1;
+            gEvalState.getCurrentFrame().code = this;
+            gEvalState.getCurrentFrame().ip = ip - 1;
          }
 
          ip += 5;
@@ -2070,8 +2070,8 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
       {
          //append the ip and codeptr before managing the breakpoint!
          AssertFatal(!gEvalState.stack.empty(), "Empty eval stack on break!");
-         gEvalState.stack.last()->code = this;
-         gEvalState.stack.last()->ip = ip - 1;
+         gEvalState.getCurrentFrame().code = this;
+         gEvalState.getCurrentFrame().ip = ip - 1;
 
          U32 breakLine;
          findBreakLine(ip - 1, breakLine, instruction);
diff --git a/Engine/source/console/compiler.cpp b/Engine/source/console/compiler.cpp
index 8b1e15a8f..969770d54 100644
--- a/Engine/source/console/compiler.cpp
+++ b/Engine/source/console/compiler.cpp
@@ -60,6 +60,7 @@ namespace Compiler
    CompilerFloatTable  *gCurrentFloatTable, gGlobalFloatTable, gFunctionFloatTable;
    DataChunker          gConsoleAllocator;
    CompilerIdentTable   gIdentTable;
+   CompilerLocalVariableToRegisterMappingTable gFunctionVariableMappingTable;
 
    //------------------------------------------------------------
 
@@ -92,6 +93,8 @@ namespace Compiler
    CompilerStringTable &getGlobalStringTable() { return gGlobalStringTable; }
    CompilerStringTable &getFunctionStringTable() { return gFunctionStringTable; }
 
+   CompilerLocalVariableToRegisterMappingTable& getFunctionVariableMappingTable() { return gFunctionVariableMappingTable; }
+
    void setCurrentStringTable(CompilerStringTable* cst) { gCurrentStringTable = cst; }
 
    CompilerFloatTable *getCurrentFloatTable() { return gCurrentFloatTable; }
@@ -117,6 +120,7 @@ namespace Compiler
       getFunctionFloatTable().reset();
       getFunctionStringTable().reset();
       getIdentTable().reset();
+      getFunctionVariableMappingTable().reset();
    }
 
    void *consoleAlloc(U32 size) { return gConsoleAllocator.alloc(size); }
@@ -208,6 +212,43 @@ void CompilerStringTable::write(Stream &st)
 
 //------------------------------------------------------------
 
+void CompilerLocalVariableToRegisterMappingTable::add(StringTableEntry functionName, StringTableEntry varName, S32 reg)
+{
+   localVarToRegister[functionName].table[varName] = reg;
+}
+
+S32 CompilerLocalVariableToRegisterMappingTable::lookup(StringTableEntry functionName, StringTableEntry varName)
+{
+   auto functionPosition = localVarToRegister.find(functionName);
+   if (functionPosition != localVarToRegister.end())
+   {
+      const auto& table = localVarToRegister[functionName].table;
+      auto varPosition = table.find(varName);
+      if (varPosition != table.end())
+      {
+         return varPosition->second;
+      }
+   }
+
+   Con::errorf("Unable to find local variable %s in function name %s", varName, functionName);
+   return -1;
+}
+
+CompilerLocalVariableToRegisterMappingTable CompilerLocalVariableToRegisterMappingTable::copy()
+{
+   // Trivilly copyable as its all plain old data and using STL containers... (We want a deep copy though!)
+   CompilerLocalVariableToRegisterMappingTable table;
+   table.localVarToRegister = localVarToRegister;
+   return std::move(table);
+}
+
+void CompilerLocalVariableToRegisterMappingTable::reset()
+{
+   localVarToRegister.clear();
+}
+
+//------------------------------------------------------------
+
 U32 CompilerFloatTable::add(F64 value)
 {
    Entry **walk;
diff --git a/Engine/source/console/compiler.h b/Engine/source/console/compiler.h
index 4e6676d4c..117576a61 100644
--- a/Engine/source/console/compiler.h
+++ b/Engine/source/console/compiler.h
@@ -44,6 +44,8 @@ class DataChunker;
 #include "core/util/tVector.h"
 #endif
 
+//------------------------------------------------------------
+
 namespace Compiler
 {
    /// The opcodes for the TorqueScript VM.
@@ -252,6 +254,7 @@ namespace Compiler
    CompilerStringTable *getCurrentStringTable();
    CompilerStringTable &getGlobalStringTable();
    CompilerStringTable &getFunctionStringTable();
+   CompilerLocalVariableToRegisterMappingTable& getFunctionVariableMappingTable();
 
    void setCurrentStringTable(CompilerStringTable* cst);
 
diff --git a/Engine/source/console/consoleInternal.h b/Engine/source/console/consoleInternal.h
index f947057e5..6b7cc2294 100644
--- a/Engine/source/console/consoleInternal.h
+++ b/Engine/source/console/consoleInternal.h
@@ -644,6 +644,11 @@ public:
       return *(stack[mStackDepth - 1]);
    }
 
+   Dictionary& getFrameAt(S32 depth)
+   {
+      return *(stack[depth]);
+   }
+
    /// @}
 
    /// Run integrity checks for debugging.
diff --git a/Engine/source/console/telnetDebugger.cpp b/Engine/source/console/telnetDebugger.cpp
index 719ed7d32..306611b0a 100644
--- a/Engine/source/console/telnetDebugger.cpp
+++ b/Engine/source/console/telnetDebugger.cpp
@@ -864,6 +864,37 @@ void TelnetDebugger::evaluateExpression(const char *tag, S32 frame, const char *
    if ( frame < 0 )
       frame = 0;
 
+   // Local variables use their own memory management and can't be queried by just executing
+   // TorqueScript, we have to go digging into the interpreter.
+   S32 evalBufferLen = dStrlen(evalBuffer);
+   bool isEvaluatingLocalVariable = evalBufferLen > 0 && evalBuffer[0] == '%';
+   if (isEvaluatingLocalVariable)
+   {
+      const char* format = "EVALOUT %s %s\r\n";
+
+      Dictionary &stackFrame = gEvalState.getFrameAt(frame);
+      StringTableEntry functionName = stackFrame.scopeName;
+      S32 registerId = stackFrame.code->variableRegisterTable.lookup(functionName, StringTable->insert(evalBuffer));
+
+      if (registerId == -1)
+      {
+         // ERROR, can't read the variable!
+         send("EVALOUT \"\" \"\"");
+         return;
+      }
+
+      const char* varResult = gEvalState.getLocalStringVariable(registerId);
+
+      S32 len = dStrlen(format) + dStrlen(tag) + dStrlen(varResult);
+      char* buffer = new char[len];
+      dSprintf(buffer, len, format, tag, varResult[0] ? varResult : "\"\"");
+
+      send(buffer);
+      delete[] buffer;
+
+      return;
+   }
+
    // Build a buffer just big enough for this eval.
    const char* format = "return %s;";
    dsize_t len = dStrlen( format ) + dStrlen( evalBuffer );
@@ -872,14 +903,14 @@ void TelnetDebugger::evaluateExpression(const char *tag, S32 frame, const char *
 
    // Execute the eval.
    CodeBlock *newCodeBlock = new CodeBlock();
-   const char* result = newCodeBlock->compileExec( NULL, buffer, false, frame );
+   ConsoleValue result = newCodeBlock->compileExec( NULL, buffer, false, frame );
    delete [] buffer;
    
    // Create a new buffer that fits the result.
    format = "EVALOUT %s %s\r\n";
-   len = dStrlen( format ) + dStrlen( tag ) + dStrlen( result );
+   len = dStrlen( format ) + dStrlen( tag ) + dStrlen( result.getString() );
    buffer = new char[ len ];
-   dSprintf( buffer, len, format, tag, result[0] ? result : "\"\"" );
+   dSprintf( buffer, len, format, tag, result.getString()[0] ? result.getString() : "\"\"" );
 
    send( buffer );
    delete [] buffer;

From 6ec40e86dab7aef353f928d1f4f749f4193b9192 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Mon, 16 Aug 2021 22:02:24 -0400
Subject: [PATCH 028/399] Fix bugs with certain properties (and .x .y .z
 accessors) and add tests.

---
 Engine/source/console/astNodes.cpp        | 42 +++++---------
 Engine/source/console/codeBlock.cpp       |  2 +-
 Engine/source/console/compiledEval.cpp    | 68 +++++++++++++++++------
 Engine/source/console/test/ScriptTest.cpp | 61 ++++++++++++++++++++
 4 files changed, 125 insertions(+), 48 deletions(-)

diff --git a/Engine/source/console/astNodes.cpp b/Engine/source/console/astNodes.cpp
index 104671b1f..c95a45cae 100644
--- a/Engine/source/console/astNodes.cpp
+++ b/Engine/source/console/astNodes.cpp
@@ -1262,9 +1262,10 @@ U32 SlotAccessNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
    codeStream.emit(OP_SETCUROBJECT);
 
    codeStream.emit(OP_SETCURFIELD);
-
    codeStream.emitSTE(slotName);
 
+   codeStream.emit(OP_POP_STK);
+
    if (arrayExpr)
    {
       codeStream.emit(OP_SETCURFIELD_ARRAY);
@@ -1307,6 +1308,8 @@ U32 InternalSlotAccessNode::compile(CodeStream& codeStream, U32 ip, TypeReq type
    codeStream.emit(OP_SETCUROBJECT_INTERNAL);
    codeStream.emit(recurse);
 
+   codeStream.emit(OP_POP_STK);
+
    return codeStream.tell();
 }
 
@@ -1319,34 +1322,6 @@ TypeReq InternalSlotAccessNode::getPreferredType()
 
 U32 SlotAssignNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 {
-   // first eval the expression TypeReqString
-
-   // if it's an array:
-
-   // if OP_ADVANCE_STR 1
-   // eval array
-
-   // OP_ADVANCE_STR 1
-   // evaluate object expr
-   // OP_SETCUROBJECT 1
-   // OP_SETCURFIELD 1
-   // fieldName 1
-   // OP_TERMINATE_REWIND_STR 1
-
-   // OP_SETCURFIELDARRAY 1
-   // OP_TERMINATE_REWIND_STR 1
-
-   // else
-   // OP_ADVANCE_STR
-   // evaluate object expr
-   // OP_SETCUROBJECT
-   // OP_SETCURFIELD
-   // fieldName
-   // OP_TERMINATE_REWIND_STR
-
-   // OP_SAVEFIELD
-   // convert to return type if necessary.
-
    precompileIdent(slotName);
 
    ip = valueExpr->compile(codeStream, ip, TypeReqString);
@@ -1364,6 +1339,13 @@ U32 SlotAssignNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
    codeStream.emit(OP_SETCURFIELD);
    codeStream.emitSTE(slotName);
 
+   if (objectExpr)
+   {
+      // Don't pop unless we are assigning a field to an object
+      // (For initializer fields, we don't wanna pop)
+      codeStream.emit(OP_POP_STK);
+   }
+
    if (arrayExpr)
    {
       codeStream.emit(OP_SETCURFIELD_ARRAY);
@@ -1429,6 +1411,8 @@ U32 SlotAssignOpNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
    codeStream.emit(OP_SETCURFIELD);
    codeStream.emitSTE(slotName);
 
+   codeStream.emit(OP_POP_STK);
+
    if (arrayExpr)
    {
       codeStream.emit(OP_SETCURFIELD_ARRAY);
diff --git a/Engine/source/console/codeBlock.cpp b/Engine/source/console/codeBlock.cpp
index b58156c4a..8d0cde4d5 100644
--- a/Engine/source/console/codeBlock.cpp
+++ b/Engine/source/console/codeBlock.cpp
@@ -1114,7 +1114,7 @@ void CodeBlock::dumpInstructions(U32 startIp, bool upToReturn)
 
       case OP_SETCUROBJECT:
       {
-         Con::printf("%i: OP_SETCUROBJECT stk=-1", ip - 1);
+         Con::printf("%i: OP_SETCUROBJECT stk=0", ip - 1);
          break;
       }
 
diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index b80530162..f3c432fcb 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -166,18 +166,17 @@ namespace Con
 
 // Gets a component of an object's field value or a variable and returns it
 // in val.
-static void getFieldComponent(SimObject* object, StringTableEntry field, const char* array, StringTableEntry subField, char val[])
+static void getFieldComponent(SimObject* object, StringTableEntry field, const char* array, StringTableEntry subField, char val[], S32 currentLocalRegister)
 {
    const char* prevVal = NULL;
 
    // Grab value from object.
    if (object && field)
       prevVal = object->getDataField(field, array);
-
-   // Otherwise, grab from the string stack. The value coming in will always
-   // be a string because that is how multicomponent variables are handled.
-   else
-      prevVal = stack[_STK].getString();
+   else if (currentLocalRegister != -1)
+      prevVal = gEvalState.getLocalStringVariable(currentLocalRegister);
+   else if (gEvalState.currentVariable)
+      prevVal = gEvalState.getStringVariable();
 
    // Make sure we got a value.
    if (prevVal && *prevVal)
@@ -198,15 +197,22 @@ static void getFieldComponent(SimObject* object, StringTableEntry field, const c
          StringTable->insert("a")
       };
 
+      static const StringTableEntry uvw[] =
+      {
+         StringTable->insert("u"),
+         StringTable->insert("v"),
+         StringTable->insert("w")
+      };
+
       // Translate xyzw and rgba into the indexed component 
       // of the variable or field.
-      if (subField == xyzw[0] || subField == rgba[0])
+      if (subField == xyzw[0] || subField == rgba[0] || subField == uvw[0])
          dStrcpy(val, StringUnit::getUnit(prevVal, 0, " \t\n"), 128);
 
-      else if (subField == xyzw[1] || subField == rgba[1])
+      else if (subField == xyzw[1] || subField == rgba[1] || subField == uvw[1])
          dStrcpy(val, StringUnit::getUnit(prevVal, 1, " \t\n"), 128);
 
-      else if (subField == xyzw[2] || subField == rgba[2])
+      else if (subField == xyzw[2] || subField == rgba[2] || subField == uvw[2])
          dStrcpy(val, StringUnit::getUnit(prevVal, 2, " \t\n"), 128);
 
       else if (subField == xyzw[3] || subField == rgba[3])
@@ -221,7 +227,7 @@ static void getFieldComponent(SimObject* object, StringTableEntry field, const c
 
 // Sets a component of an object's field value based on the sub field. 'x' will
 // set the first field, 'y' the second, and 'z' the third.
-static void setFieldComponent(SimObject* object, StringTableEntry field, const char* array, StringTableEntry subField)
+static void setFieldComponent(SimObject* object, StringTableEntry field, const char* array, StringTableEntry subField, S32 currentLocalRegister)
 {
    // Copy the current string value
    char strValue[1024];
@@ -233,7 +239,8 @@ static void setFieldComponent(SimObject* object, StringTableEntry field, const c
    // Set the value on an object field.
    if (object && field)
       prevVal = object->getDataField(field, array);
-
+   else if (currentLocalRegister != -1)
+      prevVal = gEvalState.getLocalStringVariable(currentLocalRegister);
    // Set the value on a variable.
    else if (gEvalState.currentVariable)
       prevVal = gEvalState.getStringVariable();
@@ -277,6 +284,8 @@ static void setFieldComponent(SimObject* object, StringTableEntry field, const c
       // Update the field or variable.
       if (object && field)
          object->setDataField(field, 0, val);
+      else if (currentLocalRegister != -1)
+         gEvalState.setLocalStringVariable(currentLocalRegister, val, dStrlen(val));
       else if (gEvalState.currentVariable)
          gEvalState.setStringVariable(val);
    }
@@ -758,6 +767,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
    }
    const char* val;
    S32 reg;
+   S32 currentRegister = -1;
 
    // The frame temp is used by the variable accessor ops (OP_SAVEFIELD_* and
    // OP_LOADFIELD_*) to store temporary values for the fields.
@@ -1427,6 +1437,10 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          prevObject = NULL;
          curObject = NULL;
 
+         // Used for local variable caching of what is active...when we
+         // set a global, we aren't active
+         currentRegister = -1;
+
          gEvalState.setCurVarName(var);
 
          // In order to let docblocks work properly with variables, we have
@@ -1445,6 +1459,10 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          prevObject = NULL;
          curObject = NULL;
 
+         // Used for local variable caching of what is active...when we
+         // set a global, we aren't active
+         currentRegister = -1;
+
          gEvalState.setCurVarNameCreate(var);
 
          // See OP_SETCURVAR for why we do this.
@@ -1460,6 +1478,10 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          prevObject = NULL;
          curObject = NULL;
 
+         // Used for local variable caching of what is active...when we
+         // set a global, we aren't active
+         currentRegister = -1;
+
          gEvalState.setCurVarName(var);
 
          // See OP_SETCURVAR for why we do this.
@@ -1475,6 +1497,10 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          prevObject = NULL;
          curObject = NULL;
 
+         // Used for local variable caching of what is active...when we
+         // set a global, we aren't active
+         currentRegister = -1;
+
          gEvalState.setCurVarNameCreate(var);
 
          // See OP_SETCURVAR for why we do this.
@@ -1483,16 +1509,19 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          break;
 
       case OP_LOADVAR_UINT:
+         currentRegister = -1;
          stack[_STK + 1].setInt(gEvalState.getIntVariable());
          _STK++;
          break;
 
       case OP_LOADVAR_FLT:
+         currentRegister = -1;
          stack[_STK + 1].setFloat(gEvalState.getFloatVariable());
          _STK++;
          break;
 
       case OP_LOADVAR_STR:
+         currentRegister = -1;
          stack[_STK + 1].setString(gEvalState.getStringVariable());
          _STK++;
          break;
@@ -1511,18 +1540,21 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
 
       case OP_LOAD_LOCAL_VAR_UINT:
          reg = code[ip++];
+         currentRegister = reg;
          stack[_STK + 1].setInt(gEvalState.getLocalIntVariable(reg));
          _STK++;
          break;
 
       case OP_LOAD_LOCAL_VAR_FLT:
          reg = code[ip++];
+         currentRegister = reg;
          stack[_STK + 1].setFloat(gEvalState.getLocalFloatVariable(reg));
          _STK++;
          break;
 
       case OP_LOAD_LOCAL_VAR_STR:
          reg = code[ip++];
+         currentRegister = reg;
          val = gEvalState.getLocalStringVariable(reg);
          stack[_STK + 1].setString(val);
          _STK++;
@@ -1548,7 +1580,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          // Save the previous object for parsing vector fields.
          prevObject = curObject;
          val = stack[_STK].getString();
-         _STK--;
+         //_STK--;
 
          // Sim::findObject will sometimes find valid objects from
          // multi-component strings. This makes sure that doesn't
@@ -1616,7 +1648,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
             // a special accessor?
             char buff[FieldBufferSizeNumeric];
             memset(buff, 0, sizeof(buff));
-            getFieldComponent(prevObject, prevField, prevFieldArray, curField, buff);
+            getFieldComponent(prevObject, prevField, prevFieldArray, curField, buff, currentRegister);
             stack[_STK + 1].setInt(dAtol(buff));
          }
          _STK++;
@@ -1631,7 +1663,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
             // a special accessor?
             char buff[FieldBufferSizeNumeric];
             memset(buff, 0, sizeof(buff));
-            getFieldComponent(prevObject, prevField, prevFieldArray, curField, buff);
+            getFieldComponent(prevObject, prevField, prevFieldArray, curField, buff, currentRegister);
             stack[_STK + 1].setFloat(dAtod(buff));
          }
          _STK++;
@@ -1649,7 +1681,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
             // a special accessor?
             char buff[FieldBufferSizeString];
             memset(buff, 0, sizeof(buff));
-            getFieldComponent(prevObject, prevField, prevFieldArray, curField, buff);
+            getFieldComponent(prevObject, prevField, prevFieldArray, curField, buff, currentRegister);
             stack[_STK + 1].setString(buff);
          }
          _STK++;
@@ -1662,7 +1694,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          {
             // The field is not being set on an object. Maybe it's
             // a special accessor?
-            setFieldComponent( prevObject, prevField, prevFieldArray, curField );
+            setFieldComponent( prevObject, prevField, prevFieldArray, curField, currentRegister );
             prevObject = NULL;
          }
          break;
@@ -1674,7 +1706,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          {
             // The field is not being set on an object. Maybe it's
             // a special accessor?
-            setFieldComponent( prevObject, prevField, prevFieldArray, curField );
+            setFieldComponent( prevObject, prevField, prevFieldArray, curField, currentRegister );
             prevObject = NULL;
          }
          break;
@@ -1686,7 +1718,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          {
             // The field is not being set on an object. Maybe it's
             // a special accessor?
-            setFieldComponent( prevObject, prevField, prevFieldArray, curField );
+            setFieldComponent( prevObject, prevField, prevFieldArray, curField, currentRegister );
             prevObject = NULL;
          }
          break;
diff --git a/Engine/source/console/test/ScriptTest.cpp b/Engine/source/console/test/ScriptTest.cpp
index 58441c3d2..28d291528 100644
--- a/Engine/source/console/test/ScriptTest.cpp
+++ b/Engine/source/console/test/ScriptTest.cpp
@@ -471,6 +471,17 @@ TEST(Script, Basic_SimObject)
 
    ASSERT_STREQ(parentFn.getString(), "FooBar");
 
+   ConsoleValue simpleFieldTest = RunScript(R"(
+         function a()
+         {
+            FudgeCollector.field = "A";
+            return FudgeCollector.field;
+         }
+         return a();
+   )");
+
+   ASSERT_STREQ(simpleFieldTest.getString(), "A");
+
    ConsoleValue grp = RunScript(R"(
          new SimGroup(FudgeCollectorGroup)
          {
@@ -587,4 +598,54 @@ TEST(Script, Basic_Package)
    ASSERT_EQ(deactivatedValue.getInt(), 3);
 }
 
+TEST(Script, Sugar_Syntax)
+{
+   ConsoleValue value = RunScript(R"(
+         function a()
+         {
+            %vector = "1 2 3";
+            return %vector.y;
+         }
+         return a();
+   )");
+
+   ASSERT_EQ(value.getInt(), 2);
+
+   ConsoleValue setValue = RunScript(R"(
+         function a()
+         {
+            %vector = "1 2 3";
+            %vector.y = 4;
+            return %vector.y;
+         }
+         return a();
+   )");
+
+   ASSERT_EQ(setValue.getInt(), 4);
+
+   ConsoleValue valueArray = RunScript(R"(
+         function a()
+         {
+            %vector[0] = "1 2 3";
+            return %vector[0].y;
+         }
+         return a();
+   )");
+
+   ASSERT_EQ(valueArray.getInt(), 2);
+
+   ConsoleValue valueSetArray = RunScript(R"(
+         function a()
+         {
+            %vector[0] = "1 2 3";
+            %vector[0].z = 5;
+            return %vector[0].z;
+         }
+         return a();
+   )");
+
+   ASSERT_EQ(valueSetArray.getInt(), 5);
+}
+
+
 #endif

From 838395840dc377c5b74c9c6c1fc4c8538d0c72be Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Tue, 17 Aug 2021 20:04:45 -0400
Subject: [PATCH 029/399] script fixes from latest merge and more tests

---
 Engine/source/console/test/ScriptTest.cpp     | 53 +++++++++++++++++++
 .../projectImporter/guis/projectImporter.gui  |  2 +-
 .../scripts/projectImporter.tscript           |  7 +--
 3 files changed, 58 insertions(+), 4 deletions(-)

diff --git a/Engine/source/console/test/ScriptTest.cpp b/Engine/source/console/test/ScriptTest.cpp
index 28d291528..6a8d2ae12 100644
--- a/Engine/source/console/test/ScriptTest.cpp
+++ b/Engine/source/console/test/ScriptTest.cpp
@@ -647,5 +647,58 @@ TEST(Script, Sugar_Syntax)
    ASSERT_EQ(valueSetArray.getInt(), 5);
 }
 
+TEST(Script, InnerObjectTests)
+{
+   ConsoleValue theObject = RunScript(R"(
+      function a()
+      {
+         %obj = new SimObject(TheOuterObject)
+         {
+            innerObject = new SimObject(TheInnerObject)
+            {
+               testField = 123;
+               position = "1 2 3";
+            };
+         };
+         return %obj;
+      }
+      return a();
+   )");
+
+   SimObject* outerObject = Sim::findObject("TheOuterObject");
+   ASSERT_NE(outerObject, (SimObject*)NULL);
+   if (outerObject)
+   {
+      ASSERT_EQ(theObject.getInt(), Sim::findObject("TheOuterObject")->getId());
+   }
+   ASSERT_NE(Sim::findObject("TheInnerObject"), (SimObject*)NULL);
+
+   ConsoleValue positionValue = RunScript(R"(
+      function TheOuterObject::getInnerPosition(%this)
+      {
+         return %this.innerObject.position;
+      }
+
+      function a()
+      {
+         %position = TheOuterObject.getInnerPosition();
+         return %position.y;
+      }
+      return a();
+   )");
+
+   ASSERT_EQ(positionValue.getInt(), 2);
+
+   ConsoleValue nestedFuncCall = RunScript(R"(
+      function TheInnerObject::test(%this)
+      {
+         return %this.testField;
+      }
+
+      return TheOuterObject.innerObject.test();
+   )");
+
+   ASSERT_EQ(nestedFuncCall.getInt(), 123);
+}
 
 #endif
diff --git a/Templates/BaseGame/game/tools/projectImporter/guis/projectImporter.gui b/Templates/BaseGame/game/tools/projectImporter/guis/projectImporter.gui
index b308feed3..480e71704 100644
--- a/Templates/BaseGame/game/tools/projectImporter/guis/projectImporter.gui
+++ b/Templates/BaseGame/game/tools/projectImporter/guis/projectImporter.gui
@@ -1,5 +1,5 @@
 //--- OBJECT WRITE BEGIN ---
-%guiContent = new GuiControl(ProjectImportCtrl) {
+$guiContent = new GuiControl(ProjectImportCtrl) {
    position = "0 0";
    extent = "1024 768";
    minExtent = "8 2";
diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
index 05a0847f4..d73f414b2 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
@@ -70,7 +70,7 @@ function ProjectImportWindow::selectOGFolder(%this)
    %dlg = new OpenFolderDialog()
    {
       Title = "Select Export Folder";
-      Filters = %filter;
+      Filters = "";
       DefaultFile = "data/";
       ChangePath = false;
       MustExist = true;
@@ -588,7 +588,7 @@ function processLegacyShapeConstructorField(%line)
    if(%foundAssets != 0)
    {
       %assetId = $ProjectImporter::assetQuery.getAsset(0);
-      echo("Legacy Project Importer - processing of legacy shape constructor addSequence line's value: " @ %value @ " has found a matching AssetId: " @ %assetId);
+      echo("Legacy Project Importer - processing of legacy shape constructor addSequence line's value: " @ %animSourcePath @ " has found a matching AssetId: " @ %assetId);
    }
   
    if(%assetId !$= "" && AssetDatabase.isDeclaredAsset(%assetId))
@@ -981,6 +981,7 @@ function processGUIntoAsset(%guiName, %file)
    warn("Processing GUI into asset: " @ %guiName @ ", file: " @ %file);
    
    %filePath = filePath(%file);
+   %fileName = fileBase(%file);
    %moduleDef = AssetBrowser.dirHandler.getModuleFromAddress(%file);
    %moduleName = %moduleDef.ModuleId;
    %modulePath = %moduleDef.ModulePath;
@@ -1182,7 +1183,7 @@ function deleteAssetDefinitions()
    %dlg = new OpenFolderDialog()
    {
       Title = "Select Folder";
-      Filters = %filter;
+      Filters = "";
       DefaultFile = "data/";
       ChangePath = false;
       MustExist = true;

From 98a2fa0f337aba89145329ac801208fffc800d5a Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Tue, 17 Aug 2021 20:52:59 -0400
Subject: [PATCH 030/399] Fix bugs with internalName accessor

---
 Engine/source/console/astNodes.cpp        |  5 +--
 Engine/source/console/compiledEval.cpp    |  5 +++
 Engine/source/console/test/ScriptTest.cpp | 41 +++++++++++++++++++++--
 3 files changed, 47 insertions(+), 4 deletions(-)

diff --git a/Engine/source/console/astNodes.cpp b/Engine/source/console/astNodes.cpp
index c95a45cae..c45d13667 100644
--- a/Engine/source/console/astNodes.cpp
+++ b/Engine/source/console/astNodes.cpp
@@ -1304,12 +1304,13 @@ U32 InternalSlotAccessNode::compile(CodeStream& codeStream, U32 ip, TypeReq type
    ip = objectExpr->compile(codeStream, ip, TypeReqString);
    codeStream.emit(OP_SETCUROBJECT);
 
+   // we pop the stack as we will override the current object with the internal object
+   codeStream.emit(OP_POP_STK);
+
    ip = slotExpr->compile(codeStream, ip, TypeReqString);
    codeStream.emit(OP_SETCUROBJECT_INTERNAL);
    codeStream.emit(recurse);
 
-   codeStream.emit(OP_POP_STK);
-
    return codeStream.tell();
 }
 
diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index f3c432fcb..e9b4d2f61 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -1614,6 +1614,11 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
                stack[_STK].setInt(0);
             }
          }
+         else
+         {
+            Con::errorf(ConsoleLogEntry::Script, "%s: Attempt to use ->, but the group object wasn't found.", getFileLine(ip - 2));
+            stack[_STK].setInt(0);
+         }
          break;
 
       case OP_SETCUROBJECT_NEW:
diff --git a/Engine/source/console/test/ScriptTest.cpp b/Engine/source/console/test/ScriptTest.cpp
index 6a8d2ae12..f0aeb57bd 100644
--- a/Engine/source/console/test/ScriptTest.cpp
+++ b/Engine/source/console/test/ScriptTest.cpp
@@ -544,7 +544,7 @@ TEST(Script, Basic_SimObject)
 TEST(Script, Internal_Name)
 {
    ConsoleValue value = RunScript(R"(
-         function SimObject::_internalCall(%this)
+         function TheFirstInner::_internalCall(%this)
          {
             return 5;
          }
@@ -552,7 +552,7 @@ TEST(Script, Internal_Name)
          function a()
          {
             %grp = new SimGroup();
-            %obj = new SimObject()
+            %obj = new SimObject(TheFirstInner)
             {
                internalName = "Yay";
             };
@@ -568,6 +568,43 @@ TEST(Script, Internal_Name)
    )");
 
    ASSERT_EQ(value.getInt(), 5);
+
+   ConsoleValue recursiveValue = RunScript(R"(
+         function SimGroup::doTheInternalCall(%this)
+         {
+            return %this-->Yeah._internalCall2();
+         }
+
+         function TheAnotherObject::_internalCall2(%this)
+         {
+            return %this.property;
+         }
+
+         function a()
+         {
+            %grp = new SimGroup();
+            %obj = new SimGroup()
+            {
+               internalName = "Yay2";
+
+               new SimObject(TheAnotherObject)
+               {
+                  internalName = "Yeah";
+                  property = 12;
+               };
+            };
+            %grp.add(%obj);
+
+            %val = %grp.doTheInternalCall();
+
+            %grp.delete();
+
+            return %val;
+         }
+         return a();      
+   )");
+
+   ASSERT_EQ(recursiveValue.getInt(), 12);
 }
 
 TEST(Script, Basic_Package)

From 59312d7d529b405767570d30c7d8b32069605e8d Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Thu, 19 Aug 2021 22:05:43 -0400
Subject: [PATCH 031/399] debugger support

---
 Engine/source/console/astNodes.cpp        |  2 +-
 Engine/source/console/codeBlock.h         |  4 ++--
 Engine/source/console/compiler.cpp        | 16 ++++++++++------
 Engine/source/console/console.cpp         |  4 ++--
 Engine/source/console/consoleInternal.cpp | 15 ++++++++++++++-
 Engine/source/console/consoleInternal.h   |  2 ++
 Engine/source/console/simEvents.cpp       |  2 +-
 Engine/source/console/telnetDebugger.cpp  | 16 ++++++++++++++--
 8 files changed, 46 insertions(+), 15 deletions(-)

diff --git a/Engine/source/console/astNodes.cpp b/Engine/source/console/astNodes.cpp
index c45d13667..7b60ca22c 100644
--- a/Engine/source/console/astNodes.cpp
+++ b/Engine/source/console/astNodes.cpp
@@ -1599,7 +1599,7 @@ U32 FunctionDeclStmtNode::compileStmt(CodeStream& codeStream, U32 ip)
    CompilerLocalVariableToRegisterMappingTable* tbl = &getFunctionVariableMappingTable();
    for (const auto& pair : gFuncVars->variableNameMap)
    {
-      tbl->add(fnName, pair.second, pair.first);
+      tbl->add(fnName, nameSpace, pair.second, pair.first);
    }
 
    gFuncVars = NULL;
diff --git a/Engine/source/console/codeBlock.h b/Engine/source/console/codeBlock.h
index be6e48a46..be9de012f 100644
--- a/Engine/source/console/codeBlock.h
+++ b/Engine/source/console/codeBlock.h
@@ -35,8 +35,8 @@ struct CompilerLocalVariableToRegisterMappingTable
 
    std::unordered_map<StringTableEntry, RemappingTable> localVarToRegister;
 
-   void add(StringTableEntry functionName, StringTableEntry varName, S32 reg);
-   S32 lookup(StringTableEntry functionName, StringTableEntry varName);
+   void add(StringTableEntry functionName, StringTableEntry namespaceName, StringTableEntry varName, S32 reg);
+   S32 lookup(StringTableEntry namespaceName, StringTableEntry functionName, StringTableEntry varName);
    CompilerLocalVariableToRegisterMappingTable copy();
    void reset();
 };
diff --git a/Engine/source/console/compiler.cpp b/Engine/source/console/compiler.cpp
index 969770d54..7a091c202 100644
--- a/Engine/source/console/compiler.cpp
+++ b/Engine/source/console/compiler.cpp
@@ -212,17 +212,21 @@ void CompilerStringTable::write(Stream &st)
 
 //------------------------------------------------------------
 
-void CompilerLocalVariableToRegisterMappingTable::add(StringTableEntry functionName, StringTableEntry varName, S32 reg)
+void CompilerLocalVariableToRegisterMappingTable::add(StringTableEntry functionName, StringTableEntry namespaceName, StringTableEntry varName, S32 reg)
 {
-   localVarToRegister[functionName].table[varName] = reg;
+   StringTableEntry funcLookupTableName = StringTable->insert(avar("%s::%s", namespaceName, functionName));
+
+   localVarToRegister[funcLookupTableName].table[varName] = reg;
 }
 
-S32 CompilerLocalVariableToRegisterMappingTable::lookup(StringTableEntry functionName, StringTableEntry varName)
+S32 CompilerLocalVariableToRegisterMappingTable::lookup(StringTableEntry namespaceName, StringTableEntry functionName, StringTableEntry varName)
 {
-   auto functionPosition = localVarToRegister.find(functionName);
+   StringTableEntry funcLookupTableName = StringTable->insert(avar("%s::%s", namespaceName, functionName));
+
+   auto functionPosition = localVarToRegister.find(funcLookupTableName);
    if (functionPosition != localVarToRegister.end())
    {
-      const auto& table = localVarToRegister[functionName].table;
+      const auto& table = localVarToRegister[funcLookupTableName].table;
       auto varPosition = table.find(varName);
       if (varPosition != table.end())
       {
@@ -230,7 +234,7 @@ S32 CompilerLocalVariableToRegisterMappingTable::lookup(StringTableEntry functio
       }
    }
 
-   Con::errorf("Unable to find local variable %s in function name %s", varName, functionName);
+   Con::errorf("Unable to find local variable %s in function name %s", varName, funcLookupTableName);
    return -1;
 }
 
diff --git a/Engine/source/console/console.cpp b/Engine/source/console/console.cpp
index 8195eee85..d49454a07 100644
--- a/Engine/source/console/console.cpp
+++ b/Engine/source/console/console.cpp
@@ -1923,7 +1923,7 @@ void postConsoleInput( RawData data )
 {
    // TODO(JTH): Mem leak
    // Schedule this to happen at the next time event.
-   ConsoleValue* argv = new ConsoleValue[2];
+   ConsoleValue* argv = new ConsoleValue[2]();
    argv[0].setString("eval");
    argv[1].setString(reinterpret_cast<const char*>(data.data));
 
@@ -2563,7 +2563,7 @@ ConsoleValueToStringArrayWrapper::~ConsoleValueToStringArrayWrapper()
 
 StringArrayToConsoleValueWrapper::StringArrayToConsoleValueWrapper(int targc, const char** targv)
 {
-   argv = new ConsoleValue[targc];
+   argv = new ConsoleValue[targc]();
    argc = targc;
 
    for (int i=0; i<targc; i++)
diff --git a/Engine/source/console/consoleInternal.cpp b/Engine/source/console/consoleInternal.cpp
index 05118787b..82f92ca3b 100644
--- a/Engine/source/console/consoleInternal.cpp
+++ b/Engine/source/console/consoleInternal.cpp
@@ -710,7 +710,7 @@ void ExprEvalState::pushFrame(StringTableEntry frameName, Namespace *ns, S32 reg
 
    AssertFatal(!newFrame.getCount(), "ExprEvalState::pushFrame - Dictionary not empty!");
 
-   ConsoleValue* consoleValArray = new ConsoleValue[registerCount];
+   ConsoleValue* consoleValArray = new ConsoleValue[registerCount]();
    localStack.push_back(ConsoleValueFrame(consoleValArray, false));
    currentRegisterArray = &localStack.last();
 
@@ -787,6 +787,19 @@ void ExprEvalState::pushFrameRef(S32 stackIndex)
 #endif
 }
 
+void ExprEvalState::pushDebugFrame(S32 stackIndex)
+{
+   pushFrameRef(stackIndex);
+
+   Dictionary& newFrame = *(stack[mStackDepth - 1]);
+
+   // debugger needs to know this info...
+   newFrame.scopeName = stack[stackIndex]->scopeName;
+   newFrame.scopeNamespace = stack[stackIndex]->scopeNamespace;
+   newFrame.code = stack[stackIndex]->code;
+   newFrame.ip = stack[stackIndex]->ip;
+}
+
 ExprEvalState::ExprEvalState()
 {
    VECTOR_SET_ASSOCIATION(stack);
diff --git a/Engine/source/console/consoleInternal.h b/Engine/source/console/consoleInternal.h
index 6b7cc2294..758fd1327 100644
--- a/Engine/source/console/consoleInternal.h
+++ b/Engine/source/console/consoleInternal.h
@@ -634,6 +634,8 @@ public:
    /// on the top of the stack.
    void pushFrameRef(S32 stackIndex);
 
+   void pushDebugFrame(S32 stackIndex);
+
    U32 getStackDepth() const
    {
       return mStackDepth;
diff --git a/Engine/source/console/simEvents.cpp b/Engine/source/console/simEvents.cpp
index 6c943f054..f6a044c11 100644
--- a/Engine/source/console/simEvents.cpp
+++ b/Engine/source/console/simEvents.cpp
@@ -33,7 +33,7 @@ SimConsoleEvent::SimConsoleEvent(S32 argc, ConsoleValue *argv, bool onObject)
    mOnObject = onObject;
    mArgc = argc;
 
-   mArgv = new ConsoleValue[argc];
+   mArgv = new ConsoleValue[argc]();
    for (int i=0; i<argc; i++)
    {
       if (argv)
diff --git a/Engine/source/console/telnetDebugger.cpp b/Engine/source/console/telnetDebugger.cpp
index 306611b0a..d3b163f1f 100644
--- a/Engine/source/console/telnetDebugger.cpp
+++ b/Engine/source/console/telnetDebugger.cpp
@@ -870,11 +870,21 @@ void TelnetDebugger::evaluateExpression(const char *tag, S32 frame, const char *
    bool isEvaluatingLocalVariable = evalBufferLen > 0 && evalBuffer[0] == '%';
    if (isEvaluatingLocalVariable)
    {
+      // See calculation of current frame in pushing a reference frame for console exec, we need access
+      // to the proper scope.
+      //frame = gEvalState.getTopOfStack() - frame - 1;
+      S32 stackIndex = gEvalState.getTopOfStack() - frame - 1;
+
       const char* format = "EVALOUT %s %s\r\n";
 
-      Dictionary &stackFrame = gEvalState.getFrameAt(frame);
+      gEvalState.pushDebugFrame(stackIndex);
+
+      Dictionary& stackFrame = gEvalState.getCurrentFrame();
       StringTableEntry functionName = stackFrame.scopeName;
-      S32 registerId = stackFrame.code->variableRegisterTable.lookup(functionName, StringTable->insert(evalBuffer));
+      StringTableEntry namespaceName = stackFrame.scopeNamespace->mName;
+      StringTableEntry varToLookup = StringTable->insert(evalBuffer);
+
+      S32 registerId = stackFrame.code->variableRegisterTable.lookup(namespaceName, functionName, varToLookup);
 
       if (registerId == -1)
       {
@@ -885,6 +895,8 @@ void TelnetDebugger::evaluateExpression(const char *tag, S32 frame, const char *
 
       const char* varResult = gEvalState.getLocalStringVariable(registerId);
 
+      gEvalState.popFrame();
+
       S32 len = dStrlen(format) + dStrlen(tag) + dStrlen(varResult);
       char* buffer = new char[len];
       dSprintf(buffer, len, format, tag, varResult[0] ? varResult : "\"\"");

From 1b54162580347187e37482f0c00077775d724444 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Thu, 19 Aug 2021 22:25:11 -0400
Subject: [PATCH 032/399] cleanup todos

---
 Engine/source/console/astNodes.cpp |  4 +---
 Engine/source/console/console.cpp  |  3 +--
 Engine/source/console/console.h    |  1 -
 Engine/source/console/simSet.cpp   | 12 ++----------
 4 files changed, 4 insertions(+), 16 deletions(-)

diff --git a/Engine/source/console/astNodes.cpp b/Engine/source/console/astNodes.cpp
index 7b60ca22c..c85c32ebe 100644
--- a/Engine/source/console/astNodes.cpp
+++ b/Engine/source/console/astNodes.cpp
@@ -382,7 +382,7 @@ U32 IterStmtNode::compileStmt(CodeStream& codeStream, U32 ip)
    TypeReq varType = isStringIter ? TypeReqString : TypeReqUInt;
 
    const U32 startIp = ip;
-   containerExpr->compile(codeStream, startIp, TypeReqString); // todo: figure out better way to codegen this so we don't rely on STR
+   containerExpr->compile(codeStream, startIp, TypeReqString);
 
    codeStream.emit(isStringIter ? OP_ITER_BEGIN_STR : OP_ITER_BEGIN);
    codeStream.emit(isGlobal);
@@ -544,8 +544,6 @@ void IntBinaryExprNode::getSubTypeOperand()
 
 U32 IntBinaryExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 {
-   // TODO: What if we do other optimizations and this doesn't work for it..this
-   // so far only works for simple MOD optimizations...
    if (optimize())
       right = optimizedNode;
 
diff --git a/Engine/source/console/console.cpp b/Engine/source/console/console.cpp
index d49454a07..36b0aa4d8 100644
--- a/Engine/source/console/console.cpp
+++ b/Engine/source/console/console.cpp
@@ -1921,9 +1921,8 @@ StringTableEntry getModNameFromPath(const char *path)
 
 void postConsoleInput( RawData data )
 {
-   // TODO(JTH): Mem leak
    // Schedule this to happen at the next time event.
-   ConsoleValue* argv = new ConsoleValue[2]();
+   ConsoleValue argv[2];
    argv[0].setString("eval");
    argv[1].setString(reinterpret_cast<const char*>(data.data));
 
diff --git a/Engine/source/console/console.h b/Engine/source/console/console.h
index 4a9f3be9d..d975ccd4d 100644
--- a/Engine/source/console/console.h
+++ b/Engine/source/console/console.h
@@ -133,7 +133,6 @@ struct ConsoleValueConsoleType
    EnumTable* enumTable;
 };
 
-// TODO: replace malloc/free with custom allocator...
 class ConsoleValue
 {
    union
diff --git a/Engine/source/console/simSet.cpp b/Engine/source/console/simSet.cpp
index 7daa515d7..bce5cd47d 100644
--- a/Engine/source/console/simSet.cpp
+++ b/Engine/source/console/simSet.cpp
@@ -231,20 +231,13 @@ void SimSet::scriptSort( const String &scriptCallbackFn )
 
 void SimSet::callOnChildren( const String &method, S32 argc, ConsoleValue argv[], bool executeOnChildGroups )
 {
-   // TODO(JTH): Implement
-   AssertISV(false, "TODO Implement");
-   return;
-
-   /*
    // Prep the arguments for the console exec...
    // Make sure and leave args[1] empty.
    ConsoleValue args[21] = { };
-   ConsoleValue name_method;
-   name_method.setStackStringValue(method.c_str());
-   args[0] = ConsoleValueRef::fromValue(&name_method);
+   args[0].setString(method.c_str());
 
    for (S32 i = 0; i < argc; i++)
-      args[i + 2] = argv[i];
+      args[i + 2].setString(argv[i].getString());
 
    for( iterator i = begin(); i != end(); i++ )
    {
@@ -260,7 +253,6 @@ void SimSet::callOnChildren( const String &method, S32 argc, ConsoleValue argv[]
             childSet->callOnChildren( method, argc, argv, executeOnChildGroups );
       }
    }
-   */
 }
 
 //-----------------------------------------------------------------------------

From 452ef71274cc4e8ce761136e1b21fec858a6a4fc Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Fri, 20 Aug 2021 20:38:24 -0400
Subject: [PATCH 033/399] * BugFix: Correct $i and %i interchangeably being
 used in parseArgs.tscript.

---
 .../core/utility/scripts/parseArgs.tscript    | 194 +++++++++---------
 1 file changed, 97 insertions(+), 97 deletions(-)

diff --git a/Templates/BaseGame/game/core/utility/scripts/parseArgs.tscript b/Templates/BaseGame/game/core/utility/scripts/parseArgs.tscript
index d5a098c90..fcff3efb9 100644
--- a/Templates/BaseGame/game/core/utility/scripts/parseArgs.tscript
+++ b/Templates/BaseGame/game/core/utility/scripts/parseArgs.tscript
@@ -43,11 +43,11 @@ function popFront(%list, %delim)
 
 function parseArgs()
 {
-   for ($i = 1; $i < $Game::argc ; $i++)
+   for (%i = 1; %i < $Game::argc ; %i++)
    {
-      $arg = $Game::argv[$i];
-      $nextArg = $Game::argv[$i+1];
-      $hasNextArg = $Game::argc - $i > 1;
+      $arg = $Game::argv[%i];
+      $nextArg = $Game::argv[%i+1];
+      $hasNextArg = $Game::argc - %i > 1;
       $logModeSpecified = false;
 
       // Check for dedicated run
@@ -55,7 +55,7 @@ function parseArgs()
       {
          $userDirs = $defaultGame;
          $dirCount = 1;
-         $isDedicated = true;
+         %isDedicated = true;
       }*/
 
       switch$ ($arg)
@@ -64,39 +64,39 @@ function parseArgs()
          case "-dedicated":
             $userDirs = $defaultGame;
             $dirCount = 1;
-            $isDedicated = true;
+            %isDedicated = true;
             $Server::Dedicated = true;
             enableWinConsole(true);
-            $argUsed[$i]++;
-            
+            $argUsed[%i]++;
+
                   //--------------------
          case "-mission":
-            $argUsed[$i]++;
-            if ($hasNextArg) 
+            $argUsed[%i]++;
+            if ($hasNextArg)
             {
                $missionArg = $nextArg;
-               $argUsed[$i+1]++;
-               $i++;
+               $argUsed[%i+1]++;
+               %i++;
             }
             else
                error("Error: Missing Command Line argument. Usage: -mission <filename>");
 
          //--------------------
          case "-connect":
-            $argUsed[$i]++;
-            if ($hasNextArg) 
+            $argUsed[%i]++;
+            if ($hasNextArg)
             {
                $JoinGameAddress = $nextArg;
-               $argUsed[$i+1]++;
-               $i++;
+               $argUsed[%i+1]++;
+               %i++;
             }
             else
                error("Error: Missing Command Line argument. Usage: -connect <ip_address>");
 
-            
+
          //--------------------
          case "-log":
-            $argUsed[$i]++;
+            $argUsed[%i]++;
             if ($hasNextArg)
             {
                // Turn on console logging
@@ -107,22 +107,22 @@ function parseArgs()
                }
                setLogMode($nextArg);
                $logModeSpecified = true;
-               $argUsed[$i+1]++;
-               $i++;
+               $argUsed[%i+1]++;
+               %i++;
             }
             else
                error("Error: Missing Command Line argument. Usage: -log <Mode: 0,1,2>");
 
          //--------------------
          case "-dir":
-            $argUsed[$i]++;
+            $argUsed[%i]++;
             if ($hasNextArg)
             {
                // Append the mod to the end of the current list
                $userDirs = strreplace($userDirs, $nextArg, "");
                $userDirs = pushFront($userDirs, $nextArg, ";");
-               $argUsed[$i+1]++;
-               $i++;
+               $argUsed[%i+1]++;
+               %i++;
                $dirCount++;
             }
             else
@@ -130,15 +130,15 @@ function parseArgs()
 
          //--------------------
          // changed the default behavior of this command line arg. It now
-         // defaults to ONLY loading the game, not tools 
+         // defaults to ONLY loading the game, not tools
          // default auto-run already loads in tools --SRZ 11/29/07
          case "-game":
-            $argUsed[$i]++;
+            $argUsed[%i]++;
             if ($hasNextArg)
             {
                // Set the selected dir --NOTE: we no longer allow tools with this argument
-               /* 
-               if( $isDedicated )
+               /*
+               if( %isDedicated )
                {
                   $userDirs = $nextArg;
                   $dirCount = 1;
@@ -151,8 +151,8 @@ function parseArgs()
                */
                $userDirs = $nextArg;
                $dirCount = 1;
-               $argUsed[$i+1]++;
-               $i++;
+               $argUsed[%i+1]++;
+               %i++;
                error($userDirs);
             }
             else
@@ -161,121 +161,121 @@ function parseArgs()
          //--------------------
          case "-console":
             enableWinConsole(true);
-            $argUsed[$i]++;
+            $argUsed[%i]++;
 
          //--------------------
          case "-jSave":
-            $argUsed[$i]++;
+            $argUsed[%i]++;
             if ($hasNextArg)
             {
                echo("Saving event log to journal: " @ $nextArg);
                saveJournal($nextArg);
-               $argUsed[$i+1]++;
-               $i++;
+               $argUsed[%i+1]++;
+               %i++;
             }
             else
                error("Error: Missing Command Line argument. Usage: -jSave <journal_name>");
 
          //--------------------
          case "-jPlay":
-            $argUsed[$i]++;
+            $argUsed[%i]++;
             if ($hasNextArg)
             {
                playJournal($nextArg);
-               $argUsed[$i+1]++;
-               $i++;
+               $argUsed[%i+1]++;
+               %i++;
             }
             else
                error("Error: Missing Command Line argument. Usage: -jPlay <journal_name>");
-               
+
          //--------------------
          case "-jPlayToVideo":
-            $argUsed[$i]++;
+            $argUsed[%i]++;
             if ($hasNextArg)
             {
                $VideoCapture::journalName = $nextArg;
                $VideoCapture::captureFromJournal = true;
-               $argUsed[$i+1]++;
-               $i++;
+               $argUsed[%i+1]++;
+               %i++;
             }
             else
                error("Error: Missing Command Line argument. Usage: -jPlayToVideo <journal_name>");
-               
+
          //--------------------
          case "-vidCapFile":
-            $argUsed[$i]++;
+            $argUsed[%i]++;
             if ($hasNextArg)
             {
                $VideoCapture::fileName = $nextArg;
-               $argUsed[$i+1]++;
-               $i++;
+               $argUsed[%i+1]++;
+               %i++;
             }
             else
                error("Error: Missing Command Line argument. Usage: -vidCapFile <ouput_video_name>");
-               
+
          //--------------------
          case "-vidCapFPS":
-            $argUsed[$i]++;
+            $argUsed[%i]++;
             if ($hasNextArg)
             {
                $VideoCapture::fps = $nextArg;
-               $argUsed[$i+1]++;
-               $i++;
+               $argUsed[%i+1]++;
+               %i++;
             }
             else
                error("Error: Missing Command Line argument. Usage: -vidCapFPS <ouput_video_framerate>");
-               
+
          //--------------------
          case "-vidCapEncoder":
-            $argUsed[$i]++;
+            $argUsed[%i]++;
             if ($hasNextArg)
             {
                $VideoCapture::encoder = $nextArg;
-               $argUsed[$i+1]++;
-               $i++;
+               $argUsed[%i+1]++;
+               %i++;
             }
             else
                error("Error: Missing Command Line argument. Usage: -vidCapEncoder <ouput_video_encoder>");
-               
+
          //--------------------
          case "-vidCapWidth":
-            $argUsed[$i]++;
+            $argUsed[%i]++;
             if ($hasNextArg)
             {
                $videoCapture::width = $nextArg;
-               $argUsed[$i+1]++;
-               $i++;
+               $argUsed[%i+1]++;
+               %i++;
             }
             else
                error("Error: Missing Command Line argument. Usage: -vidCapWidth <ouput_video_width>");
-               
+
          //--------------------
          case "-vidCapHeight":
-            $argUsed[$i]++;
+            $argUsed[%i]++;
             if ($hasNextArg)
             {
                $videoCapture::height = $nextArg;
-               $argUsed[$i+1]++;
-               $i++;
+               $argUsed[%i+1]++;
+               %i++;
             }
             else
                error("Error: Missing Command Line argument. Usage: -vidCapHeight <ouput_video_height>");
 
          //--------------------
          case "-level":
-            $argUsed[$i]++;
+            $argUsed[%i]++;
             if ($hasNextArg)
             {
                %hasExt = strpos($nextArg, ".mis");
                if(%hasExt == -1)
                {
                   $levelToLoad = $nextArg @ " ";
-                  
-                  for(%j = $i + 2; %j < $Game::argc; %j++)
+
+                  for(%j = %i + 2; %j < $Game::argc; %j++)
                   {
                      $arg = $Game::argv[%j];
                      %hasExt = strpos($arg, ".mis");
-                     
+
                      if(%hasExt == -1)
                      {
                         $levelToLoad = $levelToLoad @ $arg @ " ";
@@ -285,14 +285,14 @@ function parseArgs()
                         break;
                      }
                   }
-               } 
+               }
                else
                {
                   $levelToLoad = $nextArg;
                }
-               
-               $argUsed[$i+1]++;
-               $i++;
+
+               $argUsed[%i+1]++;
+               %i++;
             }
             else
                error("Error: Missing Command Line argument. Usage: -level <level file name (no path), with or without extension>");
@@ -300,93 +300,93 @@ function parseArgs()
          //-------------------
          case "-worldeditor":
             $startWorldEditor = true;
-            $argUsed[$i]++;
+            $argUsed[%i]++;
 
          //-------------------
          case "-guieditor":
             $startGUIEditor = true;
-            $argUsed[$i]++;
+            $argUsed[%i]++;
 
          //-------------------
          case "-help":
             $displayHelp = true;
-            $argUsed[$i]++;
+            $argUsed[%i]++;
 
          //-------------------
          case "-compileAll":
             $compileAll = true;
-            $argUsed[$i]++;
-            
+            $argUsed[%i]++;
+
          //-------------------
          case "-compileTools":
             $compileTools = true;
-            $argUsed[$i]++;
+            $argUsed[%i]++;
 
          //-------------------
          case "-genScript":
             $genScript = true;
-            $argUsed[$i]++;
-            
+            $argUsed[%i]++;
+
          case "-fullscreen":
             $cliFullscreen = true;
-            $argUsed[$i]++;
+            $argUsed[%i]++;
 
          case "-windowed":
             $cliFullscreen = false;
-            $argUsed[$i]++;
+            $argUsed[%i]++;
 
          case "-openGL":
             $pref::Video::displayDevice = "OpenGL";
-            $argUsed[$i]++;
+            $argUsed[%i]++;
 
          case "-directX":
             $pref::Video::displayDevice = "D3D";
-            $argUsed[$i]++;
+            $argUsed[%i]++;
 
          case "-autoVideo":
             $pref::Video::displayDevice = "";
-            $argUsed[$i]++;
+            $argUsed[%i]++;
 
          case "-prefs":
-            $argUsed[$i]++;
+            $argUsed[%i]++;
             if ($hasNextArg) {
                exec($nextArg, true, true);
-               $argUsed[$i+1]++;
-               $i++;
+               $argUsed[%i+1]++;
+               %i++;
             }
             else
                error("Error: Missing Command Line argument. Usage: -prefs <path/script." @ $TorqueScriptFileExtension @ ">");
 
-            
+
          //-------------------
          default:
-            $argUsed[$i]++;
+            $argUsed[%i]++;
             if($userDirs $= "")
                $userDirs = $arg;
       }
    }
-   
+
    //-----------------------------------------------
    // Play journal to video file?
    if ($VideoCapture::captureFromJournal && $VideoCapture::journalName !$= "")
-   {         
+   {
       if ($VideoCapture::fileName $= "")
-         $VideoCapture::fileName = $VideoCapture::journalName;     
-      
+         $VideoCapture::fileName = $VideoCapture::journalName;
+
       if ($VideoCapture::encoder $= "")
          $VideoCapture::encoder = "THEORA";
-            
+
       if ($VideoCapture::fps $= "")
          $VideoCapture::fps = 30;
-               
+
       if ($videoCapture::width $= "")
          $videoCapture::width = 0;
-         
+
       if ($videoCapture::height $= "")
          $videoCapture::height = 0;
-         
-      playJournalToVideo(  $VideoCapture::journalName, $VideoCapture::fileName, 
-                           $VideoCapture::encoder, $VideoCapture::fps, 
+
+      playJournalToVideo(  $VideoCapture::journalName, $VideoCapture::fileName,
+                           $VideoCapture::encoder, $VideoCapture::fps,
                            $videoCapture::width SPC $videoCapture::height );
    }
-}
\ No newline at end of file
+}

From a2d5e475fb41fda7af806c5ca4d180d2a48b96b8 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Sun, 29 Aug 2021 22:41:48 -0400
Subject: [PATCH 034/399] fix script issue.

---
 .../game/tools/assetBrowser/scripts/assetTypes/terrain.tscript  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrain.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrain.tscript
index 85a9cd9c2..1c51a7d42 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrain.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrain.tscript
@@ -169,7 +169,7 @@ function AssetBrowser::buildTerrainAssetPreview(%this, %assetDef, %previewData)
    %previewData.tooltip = "Asset Name: " @ %assetDef.assetName @
       "\nAsset Type: Terrain Asset" @ 
       "\nAsset Definition ID: " @ %assetDef @
-      "\nDefinition Path: " @ %assetPath @ %assetDef.getTerrainFilePath(); 
+      "\nDefinition Path: " @ %assetDef.getTerrainFilePath(); 
 }
 
 function GuiInspectorTypeTerrainAssetPtr::onClick( %this, %fieldName )

From 56b0a0cb8598cf31997fd024c28ca4b5590987ab Mon Sep 17 00:00:00 2001
From: JeffR <Areloch@gmail.com>
Date: Tue, 31 Aug 2021 00:54:05 -0500
Subject: [PATCH 035/399] Initial hook-in of the sound asset's integration into
 sfxEmitter, as well as some fixups for editor/workflow usage.

---
 Engine/source/T3D/assets/SoundAsset.cpp       | 157 ++++++++++++++++--
 Engine/source/T3D/assets/SoundAsset.h         |  17 +-
 Engine/source/T3D/assets/assetImporter.cpp    |  97 ++---------
 Engine/source/T3D/sfx/sfxEmitter.cpp          |  65 +++++---
 Engine/source/T3D/sfx/sfxEmitter.h            |   9 +-
 .../scripts/assetTypes/sound.tscript          |   7 +-
 6 files changed, 214 insertions(+), 138 deletions(-)

diff --git a/Engine/source/T3D/assets/SoundAsset.cpp b/Engine/source/T3D/assets/SoundAsset.cpp
index 14cb00744..d4e9a745a 100644
--- a/Engine/source/T3D/assets/SoundAsset.cpp
+++ b/Engine/source/T3D/assets/SoundAsset.cpp
@@ -40,6 +40,10 @@
 #include "assets/assetPtr.h"
 #endif
 
+#ifndef _SFXSOURCE_H_
+#include "sfx/sfxSource.h"
+#endif
+
 // Debug Profiling.
 #include "platform/profiler.h"
 #include "sfx/sfxTypes.h"
@@ -159,7 +163,7 @@ void SoundAsset::initPersistFields()
    addField("maxDistance", TypeF32, Offset(mProfileDesc.mMaxDistance, SoundAsset), "Max distance for sound.");
    addField("coneInsideAngle", TypeS32, Offset(mProfileDesc.mConeInsideAngle, SoundAsset), "Cone inside angle.");
    addField("coneOutsideAngle", TypeS32, Offset(mProfileDesc.mConeOutsideAngle, SoundAsset), "Cone outside angle.");
-   addField("coneOutsideVolume", TypeS32, Offset(mProfileDesc.mConeOutsideVolume, SoundAsset), "Cone outside volume.");
+   addField("coneOutsideVolume", TypeF32, Offset(mProfileDesc.mConeOutsideVolume, SoundAsset), "Cone outside volume.");
    addField("rolloffFactor", TypeF32, Offset(mProfileDesc.mRolloffFactor, SoundAsset), "Rolloff factor.");
    addField("scatterDistance", TypePoint3F, Offset(mProfileDesc.mScatterDistance, SoundAsset), "Randomization to the spacial position of the sound.");
    addField("sourceGroup", TypeSFXSourceName, Offset(mProfileDesc.mSourceGroup, SoundAsset), "Group that sources playing with this description should be put into.");
@@ -181,13 +185,7 @@ void SoundAsset::initializeAsset(void)
    if (mSoundFile == StringTable->EmptyString())
       return;
 
-   //ResourceManager::get().getChangedSignal.notify(this, &SoundAsset::_onResourceChanged);
-
-   //Ensure our path is expando'd if it isn't already
    mSoundPath = getOwned() ? expandAssetFilePath(mSoundFile) : mSoundPath;
-
-   mSoundPath = expandAssetFilePath(mSoundPath);
-
    loadSound();
 }
 
@@ -208,7 +206,6 @@ void SoundAsset::onAssetRefresh(void)
 
    //Update
    mSoundPath = getOwned() ? expandAssetFilePath(mSoundFile) : mSoundPath;
-
    loadSound();
 }
 
@@ -225,7 +222,7 @@ bool SoundAsset::loadSound()
       else
       {// = new SFXProfile(mProfileDesc, mSoundFile, mPreload);
          mSFXProfile.setDescription(&mProfileDesc);
-         mSFXProfile.setSoundFileName(mSoundFile);
+         mSFXProfile.setSoundFileName(mSoundPath);
          mSFXProfile.setPreload(mPreload);
       }
 
@@ -254,11 +251,98 @@ void SoundAsset::setSoundFile(const char* pSoundFile)
    refreshAsset();
 }
 
+StringTableEntry SoundAsset::getAssetIdByFileName(StringTableEntry fileName)
+{
+   if (fileName == StringTable->EmptyString())
+      return StringTable->EmptyString();
+
+   StringTableEntry materialAssetId = "";
+
+   AssetQuery query;
+   U32 foundCount = AssetDatabase.findAssetType(&query, "SoundAsset");
+   if (foundCount != 0)
+   {
+      for (U32 i = 0; i < foundCount; i++)
+      {
+         SoundAsset* soundAsset = AssetDatabase.acquireAsset<SoundAsset>(query.mAssetList[i]);
+         if (soundAsset && soundAsset->getSoundPath() == fileName)
+         {
+            materialAssetId = soundAsset->getAssetId();
+            AssetDatabase.releaseAsset(query.mAssetList[i]);
+            break;
+         }
+         AssetDatabase.releaseAsset(query.mAssetList[i]);
+      }
+   }
+
+   return materialAssetId;
+}
+
+U32 SoundAsset::getAssetById(StringTableEntry assetId, AssetPtr<SoundAsset>* materialAsset)
+{
+   (*materialAsset) = assetId;
+
+   if (materialAsset->notNull())
+   {
+      return (*materialAsset)->mLoadedState;
+   }
+   else
+   {
+      //Well that's bad, loading the fallback failed.
+      Con::warnf("MaterialAsset::getAssetById - Finding of asset with id %s failed with no fallback asset", assetId);
+      return AssetErrCode::Failed;
+   }
+}
+
+U32 SoundAsset::getAssetByFileName(StringTableEntry fileName, AssetPtr<SoundAsset>* soundAsset)
+{
+   AssetQuery query;
+   U32 foundAssetcount = AssetDatabase.findAssetType(&query, "SoundAsset");
+   if (foundAssetcount == 0)
+   {
+      //Well that's bad, loading the fallback failed.
+      Con::warnf("MaterialAsset::getAssetByMaterialName - Finding of asset associated with filename %s failed with no fallback asset", fileName);
+      return AssetErrCode::Failed;
+   }
+   else
+   {
+      for (U32 i = 0; i < foundAssetcount; i++)
+      {
+         SoundAsset* tSoundAsset = AssetDatabase.acquireAsset<SoundAsset>(query.mAssetList[i]);
+         if (tSoundAsset && tSoundAsset->getSoundPath() == fileName)
+         {
+            soundAsset->setAssetId(query.mAssetList[i]);
+            AssetDatabase.releaseAsset(query.mAssetList[i]);
+            return (*soundAsset)->mLoadedState;
+         }
+         AssetDatabase.releaseAsset(query.mAssetList[i]); //cleanup if that's not the one we needed
+      }
+   }
+
+   //No good match
+   return AssetErrCode::Failed;
+}
+
 DefineEngineMethod(SoundAsset, getSoundPath, const char*, (), , "")
 {
    return object->getSoundPath();
 }
 
+DefineEngineMethod(SoundAsset, playSound, S32, (Point3F position), (Point3F::Zero),
+   "Gets the number of materials for this shape asset.\n"
+   "@return Material count.\n")
+{
+   if (object->getSfxProfile())
+   {
+      MatrixF transform;
+      transform.setPosition(position);
+      SFXSource* source = SFX->playOnce(object->getSfxProfile(), &transform, NULL, -1);
+      return source->getId();
+   }
+   else
+      return 0;
+}
+
 IMPLEMENT_CONOBJECT(GuiInspectorTypeSoundAssetPtr);
 
 ConsoleDocClass(GuiInspectorTypeSoundAssetPtr,
@@ -276,12 +360,63 @@ void GuiInspectorTypeSoundAssetPtr::consoleInit()
 
 GuiControl * GuiInspectorTypeSoundAssetPtr::constructEditControl()
 {
-   return nullptr;
+   // Create base filename edit controls
+   GuiControl* retCtrl = Parent::constructEditControl();
+   if (retCtrl == NULL)
+      return retCtrl;
+
+   // Change filespec
+   char szBuffer[512];
+   dSprintf(szBuffer, sizeof(szBuffer), "AssetBrowser.showDialog(\"SoundAsset\", \"AssetBrowser.changeAsset\", %s, \"\");",
+      getIdString());
+   mBrowseButton->setField("Command", szBuffer);
+
+   setDataField(StringTable->insert("targetObject"), NULL, mInspector->getInspectObject()->getIdString());
+
+   // Create "Open in Editor" button
+   mEditButton = new GuiBitmapButtonCtrl();
+
+   dSprintf(szBuffer, sizeof(szBuffer), "AssetBrowser.editAsset(%d.getText());", retCtrl->getId());
+   mEditButton->setField("Command", szBuffer);
+
+   char bitmapName[512] = "ToolsModule:SFXEmitter_image";
+   mEditButton->setBitmap(StringTable->insert(bitmapName));
+
+   mEditButton->setDataField(StringTable->insert("Profile"), NULL, "GuiButtonProfile");
+   mEditButton->setDataField(StringTable->insert("tooltipprofile"), NULL, "GuiToolTipProfile");
+   mEditButton->setDataField(StringTable->insert("hovertime"), NULL, "1000");
+   mEditButton->setDataField(StringTable->insert("tooltip"), NULL, "Test play this sound");
+
+   mEditButton->registerObject();
+   addObject(mEditButton);
+
+   return retCtrl;
 }
 
 bool GuiInspectorTypeSoundAssetPtr::updateRects()
 {
-   return false;
+   S32 dividerPos, dividerMargin;
+   mInspector->getDivider(dividerPos, dividerMargin);
+   Point2I fieldExtent = getExtent();
+   Point2I fieldPos = getPosition();
+
+   mCaptionRect.set(0, 0, fieldExtent.x - dividerPos - dividerMargin, fieldExtent.y);
+   mEditCtrlRect.set(fieldExtent.x - dividerPos + dividerMargin, 1, dividerPos - dividerMargin - 34, fieldExtent.y);
+
+   bool resized = mEdit->resize(mEditCtrlRect.point, mEditCtrlRect.extent);
+   if (mBrowseButton != NULL)
+   {
+      mBrowseRect.set(fieldExtent.x - 32, 2, 14, fieldExtent.y - 4);
+      resized |= mBrowseButton->resize(mBrowseRect.point, mBrowseRect.extent);
+   }
+
+   if (mEditButton != NULL)
+   {
+      RectI shapeEdRect(fieldExtent.x - 16, 2, 14, fieldExtent.y - 4);
+      resized |= mEditButton->resize(shapeEdRect.point, shapeEdRect.extent);
+   }
+
+   return resized;
 }
 
 IMPLEMENT_CONOBJECT(GuiInspectorTypeSoundAssetId);
diff --git a/Engine/source/T3D/assets/SoundAsset.h b/Engine/source/T3D/assets/SoundAsset.h
index eb273291c..b70c4ca80 100644
--- a/Engine/source/T3D/assets/SoundAsset.h
+++ b/Engine/source/T3D/assets/SoundAsset.h
@@ -122,6 +122,9 @@ public:
    bool isLoop() { return mProfileDesc.mIsLooping; }
    bool is3D() { return mProfileDesc.mIs3D; }
 
+   static StringTableEntry getAssetIdByFileName(StringTableEntry fileName);
+   static U32 getAssetById(StringTableEntry assetId, AssetPtr<SoundAsset>* materialAsset);
+   static U32 getAssetByFileName(StringTableEntry fileName, AssetPtr<SoundAsset>* matAsset);
 
 protected:
    virtual void            initializeAsset(void);
@@ -143,7 +146,7 @@ class GuiInspectorTypeSoundAssetPtr : public GuiInspectorTypeFileName
    typedef GuiInspectorTypeFileName Parent;
 public:
 
-   GuiBitmapButtonCtrl* mSoundButton;
+   GuiBitmapButtonCtrl* mEditButton;
 
    DECLARE_CONOBJECT(GuiInspectorTypeSoundAssetPtr);
    static void consoleInit();
@@ -168,14 +171,14 @@ public:
 /// Declares a sound asset
 /// This establishes the assetId, asset and legacy filepath fields, along with supplemental getter and setter functions
 /// </Summary>
-#define DECLARE_SOUNDASSET(className, name, profile) public: \
+#define DECLARE_SOUNDASSET(className, name) public: \
    Resource<SFXResource> m##name;\
    StringTableEntry m##name##Name; \
    StringTableEntry m##name##AssetId;\
    AssetPtr<SoundAsset> m##name##Asset = NULL;\
-   SFXProfile* m##name##Profile = &profile;\
+   SFXProfile* m##name##Profile = NULL;\
 public: \
-   const StringTableEntry get##name##File() const { return m##name##Name); }\
+   const StringTableEntry get##name##File() const { return m##name##Name; }\
    void set##name##File(const FileName &_in) { m##name##Name = StringTable->insert(_in.c_str());}\
    const AssetPtr<SoundAsset> & get##name##Asset() const { return m##name##Asset; }\
    void set##name##Asset(const AssetPtr<SoundAsset> &_in) { m##name##Asset = _in;}\
@@ -206,7 +209,7 @@ public: \
          }\
          else\
          {\
-            StringTableEntry assetId = SoundAsset::getAssetIdByFilename(_in);\
+            StringTableEntry assetId = SoundAsset::getAssetIdByFileName(_in);\
             if (assetId != StringTable->EmptyString())\
             {\
                m##name##AssetId = assetId;\
@@ -232,9 +235,9 @@ public: \
          m##name = NULL;\
       }\
       \
-      if (m##name##Asset.notNull() && m##name##Asset->getStatus() != ShapeAsset::Ok)\
+      if (m##name##Asset.notNull() && m##name##Asset->getStatus() != SoundAsset::Ok)\
       {\
-         Con::errorf("%s(%s)::_set%s() - sound asset failure\"%s\" due to [%s]", macroText(className), getName(), macroText(name), _in, ShapeAsset::getAssetErrstrn(m##name##Asset->getStatus()).c_str());\
+         Con::errorf("%s(%s)::_set%s() - sound asset failure\"%s\" due to [%s]", macroText(className), getName(), macroText(name), _in, SoundAsset::getAssetErrstrn(m##name##Asset->getStatus()).c_str());\
          return false; \
       }\
       else if (bool(m##name) == NULL)\
diff --git a/Engine/source/T3D/assets/assetImporter.cpp b/Engine/source/T3D/assets/assetImporter.cpp
index b0497631e..c6095726e 100644
--- a/Engine/source/T3D/assets/assetImporter.cpp
+++ b/Engine/source/T3D/assets/assetImporter.cpp
@@ -1412,8 +1412,10 @@ void AssetImporter::processImportAssets(AssetImportObject* assetItem)
             {
                processShapeAsset(item);
             }
-            /*else if (item->assetType == String("SoundAsset"))
-               SoundAsset::prepareAssetForImport(this, item);*/
+            else if (item->assetType == String("SoundAsset"))
+            {
+               processSoundAsset(item);
+            }
             else if (item->assetType == String("MaterialAsset"))
             {
                processMaterialAsset(item);
@@ -1462,8 +1464,10 @@ void AssetImporter::processImportAssets(AssetImportObject* assetItem)
             {
                processShapeAsset(childItem);
             }
-            /*else if (item->assetType == String("SoundAsset"))
-               SoundAsset::prepareAssetForImport(this, item);*/
+            else if (childItem->assetType == String("SoundAsset"))
+            {
+               processSoundAsset(childItem);
+            }
             else if (childItem->assetType == String("MaterialAsset"))
             {
                processMaterialAsset(childItem);
@@ -2046,93 +2050,12 @@ void AssetImporter::processShapeMaterialInfo(AssetImportObject* assetItem, S32 m
 
 void AssetImporter::processSoundAsset(AssetImportObject* assetItem)
 {
-   dSprintf(importLogBuffer, sizeof(importLogBuffer), "Preparing Image for Import: %s", assetItem->assetName.c_str());
+   dSprintf(importLogBuffer, sizeof(importLogBuffer), "Preparing Sound for Import: %s", assetItem->assetName.c_str());
    activityLog.push_back(importLogBuffer);
 
-   if ((activeImportConfig->GenerateMaterialOnImport && assetItem->parentAssetItem == nullptr)/* || assetItem->parentAssetItem != nullptr*/)
-   {
-      //find our suffix match, if any
-      String noSuffixName = assetItem->assetName;
-      String suffixType;
-      String suffix = parseImageSuffixes(assetItem->assetName, &suffixType);
-      if (suffix.isNotEmpty())
-      {
-         assetItem->imageSuffixType = suffixType;
-         S32 suffixPos = assetItem->assetName.find(suffix, 0, String::NoCase | String::Left);
-         noSuffixName = assetItem->assetName.substr(0, suffixPos);
-      }
-
-      //We try to automatically populate materials under the naming convention: materialName: Rock, image maps: Rock_Albedo, Rock_Normal, etc
-
-      AssetImportObject* materialAsset = findImportingAssetByName(noSuffixName);
-      if (materialAsset != nullptr && materialAsset->assetType != String("MaterialAsset"))
-      {
-         //We may have a situation where an asset matches the no-suffix name, but it's not a material asset. Ignore this
-         //asset item for now
-
-         materialAsset = nullptr;
-      }
-
-      //If we didn't find a matching material asset in our current items, we'll make one now
-      if (materialAsset == nullptr)
-      {
-         if (!assetItem->filePath.isEmpty())
-         {
-            materialAsset = addImportingAsset("MaterialAsset", assetItem->filePath, nullptr, noSuffixName);
-         }
-      }
-
-      //Not that, one way or another, we have the generated material asset, lets move on to associating our image with it
-      if (materialAsset != nullptr && materialAsset != assetItem->parentAssetItem)
-      {
-         if (assetItem->parentAssetItem != nullptr)
-         {
-            //If the image had an existing parent, it gets removed from that parent's child item list
-            assetItem->parentAssetItem->childAssetItems.remove(assetItem);
-         }
-         else
-         {
-            //If it didn't have one, we're going to pull it from the importingAssets list
-            importingAssets.remove(assetItem);
-         }
-
-         //Now we can add it to the correct material asset
-         materialAsset->childAssetItems.push_back(assetItem);
-         assetItem->parentAssetItem = materialAsset;
-
-         assetHeirarchyChanged = true;
-      }
-
-      //Now to do some cleverness. If we're generating a material, we can parse like assets being imported(similar filenames) but different suffixes
-      //If we find these, we'll just populate into the original's material
-
-      //if we need to append the diffuse suffix and indeed didn't find a suffix on the name, do that here
-      if (suffixType.isEmpty())
-      {
-         if (activeImportConfig->UseDiffuseSuffixOnOriginImage)
-         {
-            String diffuseToken = StringUnit::getUnit(activeImportConfig->DiffuseTypeSuffixes, 0, ",;\t");
-            assetItem->assetName = assetItem->assetName + diffuseToken;
-            assetItem->cleanAssetName = assetItem->assetName;
-         }
-         else
-         {
-            //We need to ensure that our image asset doesn't match the same name as the material asset, so if we're not trying to force the diffuse suffix
-            //we'll give it a generic one
-            if ((materialAsset && materialAsset->assetName.compare(assetItem->assetName) == 0) || activeImportConfig->AlwaysAddImageSuffix)
-            {
-               assetItem->assetName = assetItem->assetName + activeImportConfig->AddedImageSuffix;
-               assetItem->cleanAssetName = assetItem->assetName;
-            }
-         }
-
-         //Assume for abledo if it has no suffix matches
-         assetItem->imageSuffixType = "Albedo";
-      }
-   }
-
    assetItem->processed = true;
 }
+
 //
 // Validation
 //
diff --git a/Engine/source/T3D/sfx/sfxEmitter.cpp b/Engine/source/T3D/sfx/sfxEmitter.cpp
index e48ca8fee..655e0071a 100644
--- a/Engine/source/T3D/sfx/sfxEmitter.cpp
+++ b/Engine/source/T3D/sfx/sfxEmitter.cpp
@@ -94,22 +94,23 @@ ColorI SFXEmitter::smRenderColorRangeSphere( 200, 0, 0, 90 );
 SFXEmitter::SFXEmitter()
    :  SceneObject(),
       mSource( NULL ),
-      mTrack( NULL ),
       mUseTrackDescriptionOnly( false ),
-      mLocalProfile( &mDescription ),
       mPlayOnAdd( true )
 {
    mTypeMask |= MarkerObjectType;
    mNetFlags.set( Ghostable | ScopeAlways );
-
+   
    mDescription.mIs3D = true;
    mDescription.mIsLooping = true;
    mDescription.mIsStreaming = false;
    mDescription.mFadeInTime = -1.f;
    mDescription.mFadeOutTime = -1.f;
-   
+
+   mLocalProfile.mFilename = StringTable->EmptyString();
    mLocalProfile._registerSignals();
 
+   INIT_SOUNDASSET(Sound);
+
    mObjBox.minExtents.set( -1.f, -1.f, -1.f );
    mObjBox.maxExtents.set( 1.f, 1.f, 1.f );
 }
@@ -174,15 +175,17 @@ void SFXEmitter::consoleInit()
 void SFXEmitter::initPersistFields()
 {
    addGroup( "Media" );
-   
-      addField( "track",               TypeSFXTrackName,          Offset( mTrack, SFXEmitter),
+
+   INITPERSISTFIELD_SOUNDASSET(Sound, SFXEmitter, "");
+
+      /*addField("track", TypeSFXTrackName, Offset(mTrack, SFXEmitter),
          "The track which the emitter should play.\n"
          "@note If assigned, this field will take precedence over a #fileName that may also be assigned to the "
             "emitter." );
       addField( "fileName",            TypeStringFilename,        Offset( mLocalProfile.mFilename, SFXEmitter),
          "The sound file to play.\n"
          "Use @b either this property @b or #track.  If both are assigned, #track takes precendence.  The primary purpose of this "
-         "field is to avoid the need for the user to define SFXTrack datablocks for all sounds used in a level." );
+         "field is to avoid the need for the user to define SFXTrack datablocks for all sounds used in a level." );*/
    
    endGroup( "Media");
 
@@ -287,12 +290,13 @@ U32 SFXEmitter::packUpdate( NetConnection *con, U32 mask, BitStream *stream )
       stream->writeAffineTransform( mObjToWorld );
 
    // track
-   if( stream->writeFlag( mDirty.test( Track ) ) )
-      sfxWrite( stream, mTrack );
+   PACK_SOUNDASSET(con, Sound);
+   //if (stream->writeFlag(mDirty.test(Track)))
+   //   sfxWrite( stream, mTrack );
 
    // filename
-   if( stream->writeFlag( mDirty.test( Filename ) ) )
-      stream->writeString( mLocalProfile.mFilename );
+   //if( stream->writeFlag( mDirty.test( Filename ) ) )
+   //   stream->writeString( mLocalProfile.mFilename );
 
    // volume
    if( stream->writeFlag( mDirty.test( Volume ) ) )
@@ -397,7 +401,8 @@ void SFXEmitter::unpackUpdate( NetConnection *conn, BitStream *stream )
    }
 
    // track
-   if ( _readDirtyFlag( stream, Track ) )
+   UNPACK_SOUNDASSET(conn, Sound);
+   /*if (_readDirtyFlag(stream, Track))
    {
       String errorStr;
       if( !sfxReadAndResolve( stream, &mTrack, errorStr ) )
@@ -406,7 +411,7 @@ void SFXEmitter::unpackUpdate( NetConnection *conn, BitStream *stream )
 
    // filename
    if ( _readDirtyFlag( stream, Filename ) )
-      mLocalProfile.mFilename = stream->readSTString();
+      mLocalProfile.mFilename = stream->readSTString();*/
 
    // volume
    if ( _readDirtyFlag( stream, Volume ) )
@@ -586,8 +591,8 @@ void SFXEmitter::inspectPostApply()
    // Parent will call setScale so sync up scale with distance.
    
    F32 maxDistance = mDescription.mMaxDistance;
-   if( mUseTrackDescriptionOnly && mTrack )
-      maxDistance = mTrack->getDescription()->mMaxDistance;
+   if( mUseTrackDescriptionOnly && mSoundAsset )
+      maxDistance = mSoundAsset->getSfxDescription()->mMaxDistance;
       
    mObjScale.set( maxDistance, maxDistance, maxDistance );
    
@@ -608,8 +613,8 @@ bool SFXEmitter::onAdd()
       mDescription.validate();
       
       // Read an old 'profile' field for backwards-compatibility.
-      
-      if( !mTrack )
+      /*
+      if(mSoundAsset.isNull() || !mSoundAsset->getSfxProfile())
       {
          static const char* sProfile = StringTable->insert( "profile" );
          const char* profileName = getDataField( sProfile, NULL );
@@ -643,7 +648,7 @@ bool SFXEmitter::onAdd()
             // Remove the old 'channel' field.
             setDataField( sChannel, NULL, "" );
          }
-      }
+      }*/
    }
    else
    {
@@ -683,6 +688,12 @@ void SFXEmitter::_update()
    // we can restore it.
    SFXStatus prevState = mSource ? mSource->getStatus() : SFXStatusNull;
 
+   if (mSoundAsset.notNull() )
+   {
+      mLocalProfile = *mSoundAsset->getSfxProfile();
+      mDescription = *mSoundAsset->getSfxDescription();
+   }
+
    // Make sure all the settings are valid.
    mDescription.validate();
 
@@ -695,12 +706,12 @@ void SFXEmitter::_update()
       SFX_DELETE( mSource );
 
       // Do we have a track?
-      if( mTrack )
+      if( mSoundAsset && mSoundAsset->getSfxProfile() )
       {
-         mSource = SFX->createSource( mTrack, &transform, &velocity );
+         mSource = SFX->createSource(mSoundAsset->getSfxProfile(), &transform, &velocity );
          if( !mSource )
             Con::errorf( "SFXEmitter::_update() - failed to create sound for track %i (%s)",
-               mTrack->getId(), mTrack->getName() );
+               mSoundAsset->getSfxProfile()->getId(), mSoundAsset->getSfxProfile()->getName() );
 
          // If we're supposed to play when the emitter is 
          // added to the scene then also restart playback 
@@ -739,12 +750,12 @@ void SFXEmitter::_update()
    // is toggled on a local profile sound.  It makes the
    // editor feel responsive and that things are working.
    if(  gEditingMission &&
-        !mTrack && 
+        (mSoundAsset.isNull() || !mSoundAsset->getSfxProfile()) &&
         mPlayOnAdd && 
         mDirty.test( IsLooping ) )
       prevState = SFXStatusPlaying;
       
-   bool useTrackDescriptionOnly = ( mUseTrackDescriptionOnly && mTrack );
+   bool useTrackDescriptionOnly = ( mUseTrackDescriptionOnly && mSoundAsset.notNull() && mSoundAsset->getSfxProfile());
 
    // The rest only applies if we have a source.
    if( mSource )
@@ -1087,8 +1098,8 @@ SFXStatus SFXEmitter::_getPlaybackStatus() const
 
 bool SFXEmitter::is3D() const
 {
-   if( mTrack != NULL )
-      return mTrack->getDescription()->mIs3D;
+   if( mSoundAsset.notNull() && mSoundAsset->getSfxProfile() != NULL )
+      return mSoundAsset->getSfxProfile()->getDescription()->mIs3D;
    else
       return mDescription.mIs3D;
 }
@@ -1124,8 +1135,8 @@ void SFXEmitter::setScale( const VectorF &scale )
 {
    F32 maxDistance;
    
-   if( mUseTrackDescriptionOnly && mTrack )
-      maxDistance = mTrack->getDescription()->mMaxDistance;
+   if( mUseTrackDescriptionOnly && mSoundAsset.notNull() && mSoundAsset->getSfxProfile())
+      maxDistance = mSoundAsset->getSfxProfile()->getDescription()->mMaxDistance;
    else
    {
       // Use the average of the three coords.
diff --git a/Engine/source/T3D/sfx/sfxEmitter.h b/Engine/source/T3D/sfx/sfxEmitter.h
index 226cf5ce5..aeecd13bf 100644
--- a/Engine/source/T3D/sfx/sfxEmitter.h
+++ b/Engine/source/T3D/sfx/sfxEmitter.h
@@ -36,6 +36,7 @@
    #include "gfx/gfxStateBlock.h"
 #endif
 
+#include "T3D/assets/SoundAsset.h"
 
 class SFXSource;
 class SFXTrack;
@@ -103,13 +104,11 @@ class SFXEmitter : public SceneObject
       /// The current dirty flags.
       BitSet32 mDirty;
 
+      DECLARE_SOUNDASSET(SFXEmitter, Sound);
+      DECLARE_SOUNDASSET_NET_SETGET(SFXEmitter, Sound, DirtyUpdateMask);
+
       /// The sound source for the emitter.
       SFXSource *mSource;
-
-      /// The selected track or null if the local
-      /// profile should be used.
-      SFXTrack *mTrack;
-      
       /// Whether to leave sound setup exclusively to the assigned mTrack and not
       /// override part of the track's description with emitter properties.
       bool mUseTrackDescriptionOnly;
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/sound.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/sound.tscript
index c32222568..304d21532 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/sound.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/sound.tscript
@@ -38,7 +38,7 @@ function AssetBrowser::onSoundAssetEditorDropped(%this, %assetDef, %position)
    %newSFXEmitter = new SFXEmitter()
    {
       position = %pos;
-      fileName = %assetDef.getSoundPath();
+      soundAsset = %assetDef.getAssetId();
       pitch = %assetDef.pitchAdjust;
       volume = %assetDef.volumeAdjust;
    };
@@ -50,4 +50,9 @@ function AssetBrowser::onSoundAssetEditorDropped(%this, %assetDef, %position)
       
    EWorldEditor.isDirty = true;
    
+}
+
+function AssetBrowser::editSoundAsset(%this, %assetDef)
+{
+   %soundSource = %assetDef.playSound();
 }
\ No newline at end of file

From f04aca9def3a15727d8a7f4bac77c190b41d0100 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Tue, 31 Aug 2021 22:18:08 -0400
Subject: [PATCH 036/399] Fix string stack issue returning from a foreach
 statement.

---
 Engine/source/console/compiledEval.cpp    |  71 +++++-------
 Engine/source/console/test/ScriptTest.cpp | 133 ++++++++++++++++++++++
 2 files changed, 162 insertions(+), 42 deletions(-)

diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index e9b4d2f61..99e5a633a 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -1257,9 +1257,9 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
             {
                iterStack[--_ITER].mIsStringIter = false;
                --iterDepth;
-            }
 
-            _STK--; // this is a pop from foreach()
+               _STK--; // this is a pop from foreach()
+            }
          }
 
          returnValue.setEmptyString();
@@ -1269,61 +1269,48 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
 
       case OP_RETURN:
       {
-         if (iterDepth > 0)
-         {
-            // Clear iterator state.
-            while (iterDepth > 0)
-            {
-               iterStack[--_ITER].mIsStringIter = false;
-               --iterDepth;
-            }
-
-            
-            const char* retVal = stack[_STK].getString();
-            _STK--;
-            _STK--;
-            stack[_STK + 1].setString(retVal);
-            _STK++; // Not nice but works.
-         }
-
          returnValue = std::move(stack[_STK]);
          _STK--;
 
+         // Clear iterator state.
+         while (iterDepth > 0)
+         {
+            iterStack[--_ITER].mIsStringIter = false;
+            --iterDepth;
+
+            _STK--;
+         }
+
          goto execFinished;
       }
       case OP_RETURN_FLT:
-
-         if (iterDepth > 0)
-         {
-            // Clear iterator state.
-            while (iterDepth > 0)
-            {
-               iterStack[--_ITER].mIsStringIter = false;
-               --iterDepth;
-            }
-
-         }
-
          returnValue.setFloat(stack[_STK].getFloat());
          _STK--;
 
+         // Clear iterator state.
+         while (iterDepth > 0)
+         {
+            iterStack[--_ITER].mIsStringIter = false;
+            --iterDepth;
+
+            _STK--;
+         }
+
          goto execFinished;
 
       case OP_RETURN_UINT:
-
-         if (iterDepth > 0)
-         {
-            // Clear iterator state.
-            while (iterDepth > 0)
-            {
-               iterStack[--_ITER].mIsStringIter = false;
-               --iterDepth;
-            }
-         }
-
          returnValue.setInt(stack[_STK].getInt());
          _STK--;
 
+         // Clear iterator state.
+         while (iterDepth > 0)
+         {
+            iterStack[--_ITER].mIsStringIter = false;
+            --iterDepth;
+
+            _STK--;
+         }
+
          goto execFinished;
 
       case OP_CMPEQ:
diff --git a/Engine/source/console/test/ScriptTest.cpp b/Engine/source/console/test/ScriptTest.cpp
index f0aeb57bd..fefdf446d 100644
--- a/Engine/source/console/test/ScriptTest.cpp
+++ b/Engine/source/console/test/ScriptTest.cpp
@@ -405,6 +405,124 @@ TEST(Script, ForEachLoop)
    )");
 
    ASSERT_EQ(forEach4.getInt(), 5);
+
+   ConsoleValue forEach5 = RunScript(R"(
+      function SimObject::ret1(%this)
+      {
+         return 1;
+      }
+
+      function SimSet::doForeach5(%this)
+      {
+         %count = 0;
+         foreach (%obj in %this)
+         {
+            %count += %obj.ret1();
+         }
+         return %count;
+      }
+
+      function a()
+      {
+         %set = new SimSet();
+         %set.add(new SimObject());
+         %set.add(new SimObject());
+         %set.add(new SimObject());
+
+         return %set.doForeach5();
+      }
+
+      return a();
+   )");
+
+   ASSERT_EQ(forEach5.getInt(), 3);
+
+   ConsoleValue forEachContinue = RunScript(R"(
+      function SimSet::foreach6(%this)
+      {
+         %count = 0;
+         foreach (%obj in %this)
+         {
+            if (%obj.getName() $= "A")
+               continue;
+
+             %count++;
+         }
+         return %count;
+      }
+
+      function a()
+      {
+         %set = new SimSet();
+         %set.add(new SimObject(A));
+         %set.add(new SimObject());
+         %set.add(new SimObject());
+
+         return %set.foreach6();
+      }
+
+      return a();
+   )");
+
+   ASSERT_EQ(forEachContinue.getInt(), 2);
+
+   ConsoleValue forEachReturn = RunScript(R"(
+      function SimSet::findA(%this)
+      {
+         foreach (%obj in %this)
+         {
+            if (%obj.getName() $= "A")
+               return 76;
+         }
+         return 0;
+      }
+
+      function a()
+      {
+         %set = new SimSet();
+         %set.add(new SimObject(A));
+         %set.add(new SimObject());
+         %set.add(new SimObject());
+
+         return %set.findA();
+      }
+
+      return a();
+   )");
+
+   ASSERT_EQ(forEachReturn.getInt(), 76);
+
+   ConsoleValue forEachNestedReturn = RunScript(R"(
+      function SimSet::findA(%this)
+      {
+         foreach (%obj in %this)
+         {
+            foreach (%innerObj in %this)
+            {
+               if (%innerObj.getName() $= "A")
+                  return 42;
+            }
+         }
+         return 0;
+      }
+
+      function a()
+      {
+         %set = new SimSet();
+         %set.add(new SimObject(A));
+         %set.add(new SimObject());
+         %set.add(new SimObject());
+
+         %group = new SimGroup();
+         %group.add(%set);
+
+         return %set.findA();
+      }
+
+      return a();
+   )");
+
+   ASSERT_EQ(forEachNestedReturn.getInt(), 42);
 }
 
 TEST(Script, TorqueScript_Array_Testing)
@@ -682,6 +800,21 @@ TEST(Script, Sugar_Syntax)
    )");
 
    ASSERT_EQ(valueSetArray.getInt(), 5);
+
+   ConsoleValue valueStoreCalculated = RunScript(R"(
+      function a()
+      {
+         %extent = 10 SPC 20;
+         %scaling = 1;
+         %size = %extent.x * %scaling;
+         echo("%size = " @ %size @ " calculated = " @ (%extent.x * %scaling)); 
+         return %size;
+      }
+
+      return a();
+   )");
+
+   ASSERT_EQ(valueStoreCalculated.getInt(), 10);
 }
 
 TEST(Script, InnerObjectTests)

From 94482564227c847041fc7eb3bdc1c35d0e9ac993 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Wed, 1 Sep 2021 20:16:08 -0400
Subject: [PATCH 037/399] Fix console garbage error when evaluating strings.

---
 Engine/source/console/consoleFunctions.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Engine/source/console/consoleFunctions.cpp b/Engine/source/console/consoleFunctions.cpp
index 88bbc14e3..d0eccde40 100644
--- a/Engine/source/console/consoleFunctions.cpp
+++ b/Engine/source/console/consoleFunctions.cpp
@@ -2410,7 +2410,9 @@ DefineEngineFunction( exec, bool, ( const char* fileName, bool noCalls, bool jou
 
 DefineEngineFunction( eval, const char*, ( const char* consoleString ), , "eval(consoleString)" )
 {
-   return Con::evaluate(consoleString, false, NULL);
+   ConsoleValue returnValue = Con::evaluate(consoleString, false, NULL);
+
+   return Con::getReturnBuffer(returnValue.getString());
 }
 
 DefineEngineFunction( getVariable, const char*, ( const char* varName ), , "(string varName)\n" 

From 1b55dce613dab6122aa7660d546328e83b103534 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Wed, 1 Sep 2021 21:12:12 -0400
Subject: [PATCH 038/399] * Workaround: Implement noinline attributes for
 problematic functions in str.cpp due to what appears to be GCC compiler bugs.

---
 Engine/source/core/util/str.cpp        | 4 ++--
 Engine/source/platform/types.gcc.h     | 3 +++
 Engine/source/platform/types.visualc.h | 2 ++
 3 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/Engine/source/core/util/str.cpp b/Engine/source/core/util/str.cpp
index c93a95aba..bec26609b 100644
--- a/Engine/source/core/util/str.cpp
+++ b/Engine/source/core/util/str.cpp
@@ -284,8 +284,8 @@ class String::StringData : protected StringDataImpl
             delete [] mUTF16;
       }
 
-      void* operator new(size_t size, U32 len);
-      void* operator new( size_t size, U32 len, DataChunker& chunker );
+      void* TORQUE_NOINLINE operator new(size_t size, U32 len);
+      void* TORQUE_NOINLINE operator new( size_t size, U32 len, DataChunker& chunker );
       void operator delete(void *);
 
       bool isShared() const
diff --git a/Engine/source/platform/types.gcc.h b/Engine/source/platform/types.gcc.h
index 53538dd8d..a36759bc0 100644
--- a/Engine/source/platform/types.gcc.h
+++ b/Engine/source/platform/types.gcc.h
@@ -165,5 +165,8 @@ typedef unsigned long  U64;
 #endif
 #endif
 
+// Set GCC noinline
+#define TORQUE_NOINLINE __attribute__ ((noinline))
+
 #endif // INCLUDED_TYPES_GCC_H
 
diff --git a/Engine/source/platform/types.visualc.h b/Engine/source/platform/types.visualc.h
index 57dabc4dd..4b937ddf8 100644
--- a/Engine/source/platform/types.visualc.h
+++ b/Engine/source/platform/types.visualc.h
@@ -104,6 +104,8 @@ typedef unsigned _int64 U64;
 // see msdn.microsoft.com "Compiler Warning (level 1) C4291" for more details
 #pragma warning(disable: 4291) 
 
+// Set MSVC noline attribute
+#define TORQUE_NOINLINE __declspec(noinline)
 
 #endif // INCLUDED_TYPES_VISUALC_H
 

From 8d75d60f9159722fbb137014d303b50fbff08225 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Wed, 1 Sep 2021 22:15:37 -0400
Subject: [PATCH 039/399] Write out variable mapping table to DSO stream, and
 fix .dump()

---
 Engine/source/console/astNodes.cpp  |  6 +++--
 Engine/source/console/codeBlock.cpp | 36 +++++++++++++++++++++++++----
 Engine/source/console/codeBlock.h   |  6 ++---
 Engine/source/console/compiler.cpp  | 27 +++++++++++++++++-----
 4 files changed, 60 insertions(+), 15 deletions(-)

diff --git a/Engine/source/console/astNodes.cpp b/Engine/source/console/astNodes.cpp
index c85c32ebe..1ee165272 100644
--- a/Engine/source/console/astNodes.cpp
+++ b/Engine/source/console/astNodes.cpp
@@ -1594,10 +1594,12 @@ U32 FunctionDeclStmtNode::compileStmt(CodeStream& codeStream, U32 ip)
    setCurrentFloatTable(&getGlobalFloatTable());
 
    // map local variables to registers for this function.
+   // Note we have to map these in order because the table itself is ordered by the register id.
    CompilerLocalVariableToRegisterMappingTable* tbl = &getFunctionVariableMappingTable();
-   for (const auto& pair : gFuncVars->variableNameMap)
+   for (size_t i = 0; i < gFuncVars->variableNameMap.size(); ++i)
    {
-      tbl->add(fnName, nameSpace, pair.second, pair.first);
+      StringTableEntry varName = gFuncVars->variableNameMap[i];
+      tbl->add(fnName, nameSpace, varName);
    }
 
    gFuncVars = NULL;
diff --git a/Engine/source/console/codeBlock.cpp b/Engine/source/console/codeBlock.cpp
index 8d0cde4d5..14c447ba0 100644
--- a/Engine/source/console/codeBlock.cpp
+++ b/Engine/source/console/codeBlock.cpp
@@ -405,6 +405,30 @@ bool CodeBlock::read(StringTableEntry fileName, Stream &st)
       for (i = 0; i < size; i++)
          st.read(&functionFloats[i]);
    }
+
+   // Variable register mapping table
+   st.read(&size);
+   if (size)
+   {
+      for (i = 0; i < size; i++)
+      {
+         char functionNameBuffer[256];
+         st.readString(functionNameBuffer);
+         StringTableEntry fnName = StringTable->insert(functionNameBuffer);
+
+         U32 count;
+         st.read(&count);
+         for (U32 j = 0; j < count; j++)
+         {
+            char varNameBuffer[256];
+            st.readString(varNameBuffer);
+            StringTableEntry varName = StringTable->insert(varNameBuffer);
+
+            variableRegisterTable.localVarToRegister[fnName].varList.push_back(varName);
+         }
+      }
+   }
+
    U32 codeLength;
    st.read(&codeLength);
    st.read(&lineBreakPairCount);
@@ -533,6 +557,9 @@ bool CodeBlock::compile(const char *codeFileName, StringTableEntry fileName, con
    getGlobalFloatTable().write(st);
    getFunctionFloatTable().write(st);
 
+   // write variable mapping table
+   getFunctionVariableMappingTable().write(st);
+
    if (lastIp != codeSize)
       Con::errorf(ConsoleLogEntry::General, "CodeBlock::compile - precompile size mismatch, a precompile/compile function pair is probably mismatched.");
 
@@ -645,9 +672,6 @@ ConsoleValue CodeBlock::compileExec(StringTableEntry fileName, const char *inStr
    codeStream.emit(OP_RETURN_VOID);
    codeStream.emitCodeStream(&codeSize, &code, &lineBreakPairs);
 
-   //if (Con::getBoolVariable("dump"))
-   //dumpInstructions(0, false);
-
    consoleAllocReset();
 
    if (lineBreakPairCount && fileName)
@@ -679,10 +703,14 @@ String CodeBlock::getFunctionArgs(U32 ip)
 {
    StringBuilder str;
 
+   StringTableEntry fnName = CodeToSTE(code, ip);
+   StringTableEntry fnNamespace = CodeToSTE(code, ip + 2);
+   StringTableEntry fnNsName = StringTable->insert(avar("%s::%s", fnNamespace, fnName));
+
    U32 fnArgc = code[ip + 8];
    for (U32 i = 0; i < fnArgc; ++i)
    {
-      StringTableEntry var = CodeToSTE(code, ip + (i * 2) + 9);
+      StringTableEntry var = variableRegisterTable.localVarToRegister[fnNsName].varList[i];
 
       if (i != 0)
          str.append(", ");
diff --git a/Engine/source/console/codeBlock.h b/Engine/source/console/codeBlock.h
index be9de012f..a3c1015e9 100644
--- a/Engine/source/console/codeBlock.h
+++ b/Engine/source/console/codeBlock.h
@@ -27,18 +27,18 @@
 
 struct CompilerLocalVariableToRegisterMappingTable
 {
-   // First key: function name
    struct RemappingTable
    {
-      std::unordered_map<StringTableEntry, S32> table;
+      std::vector<StringTableEntry> varList;
    };
 
    std::unordered_map<StringTableEntry, RemappingTable> localVarToRegister;
 
-   void add(StringTableEntry functionName, StringTableEntry namespaceName, StringTableEntry varName, S32 reg);
+   void add(StringTableEntry functionName, StringTableEntry namespaceName, StringTableEntry varName);
    S32 lookup(StringTableEntry namespaceName, StringTableEntry functionName, StringTableEntry varName);
    CompilerLocalVariableToRegisterMappingTable copy();
    void reset();
+   void write(Stream& stream);
 };
 
 #include "console/compiler.h"
diff --git a/Engine/source/console/compiler.cpp b/Engine/source/console/compiler.cpp
index 7a091c202..9af61bef2 100644
--- a/Engine/source/console/compiler.cpp
+++ b/Engine/source/console/compiler.cpp
@@ -212,11 +212,11 @@ void CompilerStringTable::write(Stream &st)
 
 //------------------------------------------------------------
 
-void CompilerLocalVariableToRegisterMappingTable::add(StringTableEntry functionName, StringTableEntry namespaceName, StringTableEntry varName, S32 reg)
+void CompilerLocalVariableToRegisterMappingTable::add(StringTableEntry functionName, StringTableEntry namespaceName, StringTableEntry varName)
 {
    StringTableEntry funcLookupTableName = StringTable->insert(avar("%s::%s", namespaceName, functionName));
 
-   localVarToRegister[funcLookupTableName].table[varName] = reg;
+   localVarToRegister[funcLookupTableName].varList.push_back(varName);;
 }
 
 S32 CompilerLocalVariableToRegisterMappingTable::lookup(StringTableEntry namespaceName, StringTableEntry functionName, StringTableEntry varName)
@@ -226,11 +226,11 @@ S32 CompilerLocalVariableToRegisterMappingTable::lookup(StringTableEntry namespa
    auto functionPosition = localVarToRegister.find(funcLookupTableName);
    if (functionPosition != localVarToRegister.end())
    {
-      const auto& table = localVarToRegister[funcLookupTableName].table;
-      auto varPosition = table.find(varName);
+      const auto& table = localVarToRegister[funcLookupTableName].varList;
+      auto varPosition = std::find(table.begin(), table.end(), varName);
       if (varPosition != table.end())
       {
-         return varPosition->second;
+         return std::distance(table.begin(), varPosition);
       }
    }
 
@@ -243,7 +243,7 @@ CompilerLocalVariableToRegisterMappingTable CompilerLocalVariableToRegisterMappi
    // Trivilly copyable as its all plain old data and using STL containers... (We want a deep copy though!)
    CompilerLocalVariableToRegisterMappingTable table;
    table.localVarToRegister = localVarToRegister;
-   return std::move(table);
+   return table;
 }
 
 void CompilerLocalVariableToRegisterMappingTable::reset()
@@ -251,6 +251,21 @@ void CompilerLocalVariableToRegisterMappingTable::reset()
    localVarToRegister.clear();
 }
 
+void CompilerLocalVariableToRegisterMappingTable::write(Stream& stream)
+{
+   stream.write(localVarToRegister.size());
+   for (const auto& pair : localVarToRegister)
+   {
+      StringTableEntry functionName = pair.first;
+      stream.writeString(functionName);
+
+      const auto& localVariableTableForFunction = localVarToRegister[functionName].varList;
+      stream.write(localVariableTableForFunction.size());
+      for (const StringTableEntry& varName : localVariableTableForFunction)
+         stream.writeString(varName);
+   }
+}
+
 //------------------------------------------------------------
 
 U32 CompilerFloatTable::add(F64 value)

From b0549118b64629ad489fa0f2b5cd9bc297c42dda Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Wed, 1 Sep 2021 22:36:59 -0400
Subject: [PATCH 040/399] various misc fixes from merge.

---
 Engine/source/core/util/str.cpp                               | 4 ++--
 .../game/tools/assetBrowser/scripts/assetTypes/shape.tscript  | 2 +-
 .../BaseGame/game/tools/gui/editorSettingsWindow.ed.tscript   | 1 +
 .../scripts/interfaces/terrainMaterialDlg.ed.tscript          | 2 +-
 4 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/Engine/source/core/util/str.cpp b/Engine/source/core/util/str.cpp
index bec26609b..4feb5c20a 100644
--- a/Engine/source/core/util/str.cpp
+++ b/Engine/source/core/util/str.cpp
@@ -284,8 +284,8 @@ class String::StringData : protected StringDataImpl
             delete [] mUTF16;
       }
 
-      void* TORQUE_NOINLINE operator new(size_t size, U32 len);
-      void* TORQUE_NOINLINE operator new( size_t size, U32 len, DataChunker& chunker );
+      TORQUE_NOINLINE void* operator new(size_t size, U32 len);
+      TORQUE_NOINLINE void* operator new( size_t size, U32 len, DataChunker& chunker );
       void operator delete(void *);
 
       bool isShared() const
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
index 4bf17453a..422d7238b 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
@@ -340,7 +340,7 @@ function AssetBrowser::onShapeAssetEditorDropped(%this, %assetDef, %position)
    
    %newStatic = new TSStatic()
    {
-      position = %pos;
+      position = %position;
       shapeAsset = %assetId;
    };
    
diff --git a/Templates/BaseGame/game/tools/gui/editorSettingsWindow.ed.tscript b/Templates/BaseGame/game/tools/gui/editorSettingsWindow.ed.tscript
index f9a025b59..c4ed141b3 100644
--- a/Templates/BaseGame/game/tools/gui/editorSettingsWindow.ed.tscript
+++ b/Templates/BaseGame/game/tools/gui/editorSettingsWindow.ed.tscript
@@ -515,6 +515,7 @@ function ESettingsWindow::getAssetEditingSettings(%this)
    SettingsInspector.addSettingsField("Assets/New/alwaysPromptModuleTarget", "Always Prompt Target Module", "bool", "If off, use the default module"); 
    SettingsInspector.endGroup();
    
+   %formattedConfigList = "";
    for(%i=0; %i < ImportAssetWindow.importConfigsList.Count(); %i++)
    {
       %configName = ImportAssetWindow.importConfigsList.getKey(%i);
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript
index 296fea200..0a47f96ee 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript
@@ -298,7 +298,7 @@ function TerrainMaterialDlg::changeTerrainMatMapAsset(%this)
 
    %targetMap.setBitmap( %image );  
 
-   %targetMapName = %mapName @ "AssetId";
+   %targetMapName = %targetMap @ "AssetId";
    %targetMapName.setText(%imgAsset);
 
    TerrainMaterialDlg.matDirty = true;

From d7ed88494e3e4c7374c367abe9f3ca3b59069468 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Wed, 1 Sep 2021 22:38:55 -0400
Subject: [PATCH 041/399] * BugFix: Correct placement of the TORQUE_NOINLINE
 statements for MSVC compat.

---
 Engine/source/core/util/str.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Engine/source/core/util/str.cpp b/Engine/source/core/util/str.cpp
index bec26609b..4feb5c20a 100644
--- a/Engine/source/core/util/str.cpp
+++ b/Engine/source/core/util/str.cpp
@@ -284,8 +284,8 @@ class String::StringData : protected StringDataImpl
             delete [] mUTF16;
       }
 
-      void* TORQUE_NOINLINE operator new(size_t size, U32 len);
-      void* TORQUE_NOINLINE operator new( size_t size, U32 len, DataChunker& chunker );
+      TORQUE_NOINLINE void* operator new(size_t size, U32 len);
+      TORQUE_NOINLINE void* operator new( size_t size, U32 len, DataChunker& chunker );
       void operator delete(void *);
 
       bool isShared() const

From 7efe72aced60fa1bc30a281390d1dfab5abb32a7 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Thu, 2 Sep 2021 22:21:00 -0400
Subject: [PATCH 042/399] More fixes with xyz lookup, and some cleanup and test
 cases.

---
 Engine/source/console/compiledEval.cpp    | 81 +++++------------------
 Engine/source/console/test/ScriptTest.cpp | 42 +++++++++++-
 2 files changed, 59 insertions(+), 64 deletions(-)

diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index 99e5a633a..b3f8bebc7 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -164,16 +164,11 @@ namespace Con
    }
 }
 
-// Gets a component of an object's field value or a variable and returns it
-// in val.
-static void getFieldComponent(SimObject* object, StringTableEntry field, const char* array, StringTableEntry subField, char val[], S32 currentLocalRegister)
+static void getFieldComponent(StringTableEntry subField, char val[], S32 currentLocalRegister)
 {
    const char* prevVal = NULL;
 
-   // Grab value from object.
-   if (object && field)
-      prevVal = object->getDataField(field, array);
-   else if (currentLocalRegister != -1)
+   if (currentLocalRegister != -1)
       prevVal = gEvalState.getLocalStringVariable(currentLocalRegister);
    else if (gEvalState.currentVariable)
       prevVal = gEvalState.getStringVariable();
@@ -197,22 +192,15 @@ static void getFieldComponent(SimObject* object, StringTableEntry field, const c
          StringTable->insert("a")
       };
 
-      static const StringTableEntry uvw[] =
-      {
-         StringTable->insert("u"),
-         StringTable->insert("v"),
-         StringTable->insert("w")
-      };
-
       // Translate xyzw and rgba into the indexed component 
       // of the variable or field.
-      if (subField == xyzw[0] || subField == rgba[0] || subField == uvw[0])
+      if (subField == xyzw[0] || subField == rgba[0])
          dStrcpy(val, StringUnit::getUnit(prevVal, 0, " \t\n"), 128);
 
-      else if (subField == xyzw[1] || subField == rgba[1] || subField == uvw[1])
+      else if (subField == xyzw[1] || subField == rgba[1])
          dStrcpy(val, StringUnit::getUnit(prevVal, 1, " \t\n"), 128);
 
-      else if (subField == xyzw[2] || subField == rgba[2] || subField == uvw[2])
+      else if (subField == xyzw[2] || subField == rgba[2])
          dStrcpy(val, StringUnit::getUnit(prevVal, 2, " \t\n"), 128);
 
       else if (subField == xyzw[3] || subField == rgba[3])
@@ -225,9 +213,7 @@ static void getFieldComponent(SimObject* object, StringTableEntry field, const c
       val[0] = 0;
 }
 
-// Sets a component of an object's field value based on the sub field. 'x' will
-// set the first field, 'y' the second, and 'z' the third.
-static void setFieldComponent(SimObject* object, StringTableEntry field, const char* array, StringTableEntry subField, S32 currentLocalRegister)
+static void setFieldComponent(StringTableEntry subField, S32 currentLocalRegister)
 {
    // Copy the current string value
    char strValue[1024];
@@ -236,10 +222,7 @@ static void setFieldComponent(SimObject* object, StringTableEntry field, const c
    char val[1024] = "";
    const char* prevVal = NULL;
 
-   // Set the value on an object field.
-   if (object && field)
-      prevVal = object->getDataField(field, array);
-   else if (currentLocalRegister != -1)
+   if (currentLocalRegister != -1)
       prevVal = gEvalState.getLocalStringVariable(currentLocalRegister);
    // Set the value on a variable.
    else if (gEvalState.currentVariable)
@@ -282,9 +265,7 @@ static void setFieldComponent(SimObject* object, StringTableEntry field, const c
    if (val[0] != 0)
    {
       // Update the field or variable.
-      if (object && field)
-         object->setDataField(field, 0, val);
-      else if (currentLocalRegister != -1)
+      if (currentLocalRegister != -1)
          gEvalState.setLocalStringVariable(currentLocalRegister, val, dStrlen(val));
       else if (gEvalState.currentVariable)
          gEvalState.setStringVariable(val);
@@ -740,9 +721,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
    } objectCreationStack[objectCreationStackSize];
 
    SimObject* currentNewObject = 0;
-   StringTableEntry prevField = NULL;
    StringTableEntry curField = NULL;
-   SimObject* prevObject = NULL;
    SimObject* curObject = NULL;
    SimObject* saveObject = NULL;
    Namespace::Entry* nsEntry;
@@ -1410,6 +1389,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
 
       case OP_INC:
          reg = code[ip++];
+         currentRegister = reg;
          gEvalState.setLocalFloatVariable(reg, gEvalState.getLocalFloatVariable(reg) + 1.0);
          break;
 
@@ -1420,8 +1400,6 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          // If a variable is set, then these must be NULL. It is necessary
          // to set this here so that the vector parser can appropriately
          // identify whether it's dealing with a vector.
-         prevField = NULL;
-         prevObject = NULL;
          curObject = NULL;
 
          // Used for local variable caching of what is active...when we
@@ -1442,8 +1420,6 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          ip += 2;
 
          // See OP_SETCURVAR
-         prevField = NULL;
-         prevObject = NULL;
          curObject = NULL;
 
          // Used for local variable caching of what is active...when we
@@ -1461,8 +1437,6 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          var = StringTable->insert(stack[_STK].getString());
 
          // See OP_SETCURVAR
-         prevField = NULL;
-         prevObject = NULL;
          curObject = NULL;
 
          // Used for local variable caching of what is active...when we
@@ -1480,8 +1454,6 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          var = StringTable->insert(stack[_STK].getString());
 
          // See OP_SETCURVAR
-         prevField = NULL;
-         prevObject = NULL;
          curObject = NULL;
 
          // Used for local variable caching of what is active...when we
@@ -1549,25 +1521,25 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
 
       case OP_SAVE_LOCAL_VAR_UINT:
          reg = code[ip++];
+         currentRegister = reg;
          gEvalState.setLocalIntVariable(reg, stack[_STK].getInt());
          break;
 
       case OP_SAVE_LOCAL_VAR_FLT:
          reg = code[ip++];
+         currentRegister = reg;
          gEvalState.setLocalFloatVariable(reg, stack[_STK].getFloat());
          break;
 
       case OP_SAVE_LOCAL_VAR_STR:
          reg = code[ip++];
          val = stack[_STK].getString();
+         currentRegister = reg;
          gEvalState.setLocalStringVariable(reg, val, (S32)dStrlen(val));
          break;
 
       case OP_SETCUROBJECT:
-         // Save the previous object for parsing vector fields.
-         prevObject = curObject;
          val = stack[_STK].getString();
-         //_STK--;
 
          // Sim::findObject will sometimes find valid objects from
          // multi-component strings. This makes sure that doesn't
@@ -1613,8 +1585,6 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          break;
 
       case OP_SETCURFIELD:
-         // Save the previous field for parsing vector fields.
-         prevField = curField;
          dStrcpy(prevFieldArray, curFieldArray, 256);
          curField = CodeToSTE(code, ip);
          curFieldArray[0] = 0;
@@ -1640,7 +1610,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
             // a special accessor?
             char buff[FieldBufferSizeNumeric];
             memset(buff, 0, sizeof(buff));
-            getFieldComponent(prevObject, prevField, prevFieldArray, curField, buff, currentRegister);
+            getFieldComponent(curField, buff, currentRegister);
             stack[_STK + 1].setInt(dAtol(buff));
          }
          _STK++;
@@ -1655,7 +1625,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
             // a special accessor?
             char buff[FieldBufferSizeNumeric];
             memset(buff, 0, sizeof(buff));
-            getFieldComponent(prevObject, prevField, prevFieldArray, curField, buff, currentRegister);
+            getFieldComponent(curField, buff, currentRegister);
             stack[_STK + 1].setFloat(dAtod(buff));
          }
          _STK++;
@@ -1673,7 +1643,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
             // a special accessor?
             char buff[FieldBufferSizeString];
             memset(buff, 0, sizeof(buff));
-            getFieldComponent(prevObject, prevField, prevFieldArray, curField, buff, currentRegister);
+            getFieldComponent(curField, buff, currentRegister);
             stack[_STK + 1].setString(buff);
          }
          _STK++;
@@ -1683,36 +1653,21 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          if (curObject)
             curObject->setDataField(curField, curFieldArray, stack[_STK].getString());
          else
-         {
-            // The field is not being set on an object. Maybe it's
-            // a special accessor?
-            setFieldComponent( prevObject, prevField, prevFieldArray, curField, currentRegister );
-            prevObject = NULL;
-         }
+            setFieldComponent( curField, currentRegister );
          break;
 
       case OP_SAVEFIELD_FLT:
          if (curObject)
             curObject->setDataField(curField, curFieldArray, stack[_STK].getString());
          else
-         {
-            // The field is not being set on an object. Maybe it's
-            // a special accessor?
-            setFieldComponent( prevObject, prevField, prevFieldArray, curField, currentRegister );
-            prevObject = NULL;
-         }
+            setFieldComponent( curField, currentRegister );
          break;
 
       case OP_SAVEFIELD_STR:
          if (curObject)
             curObject->setDataField(curField, curFieldArray, stack[_STK].getString());
          else
-         {
-            // The field is not being set on an object. Maybe it's
-            // a special accessor?
-            setFieldComponent( prevObject, prevField, prevFieldArray, curField, currentRegister );
-            prevObject = NULL;
-         }
+            setFieldComponent( curField, currentRegister );
          break;
 
       case OP_POP_STK:
diff --git a/Engine/source/console/test/ScriptTest.cpp b/Engine/source/console/test/ScriptTest.cpp
index fefdf446d..cce1e6824 100644
--- a/Engine/source/console/test/ScriptTest.cpp
+++ b/Engine/source/console/test/ScriptTest.cpp
@@ -807,7 +807,6 @@ TEST(Script, Sugar_Syntax)
          %extent = 10 SPC 20;
          %scaling = 1;
          %size = %extent.x * %scaling;
-         echo("%size = " @ %size @ " calculated = " @ (%extent.x * %scaling)); 
          return %size;
       }
 
@@ -815,6 +814,25 @@ TEST(Script, Sugar_Syntax)
    )");
 
    ASSERT_EQ(valueStoreCalculated.getInt(), 10);
+
+   ConsoleValue globalValueGet = RunScript(R"(
+      new SimObject(AAAA);
+      AAAA.doSomething = false;
+      $vec = "1 2 3";
+      return $vec.x * 4;
+   )");
+
+   ASSERT_EQ(globalValueGet.getFloat(), 4);
+
+   ConsoleValue globalValueSet = RunScript(R"(
+      new SimObject(AAAAB);
+      AAAAB.doSomething = false;
+      $vec2 = "1 2 3";
+      $vec2.x *= 4;
+      return $vec2.x;
+   )");
+
+   ASSERT_EQ(globalValueSet.getFloat(), 4);
 }
 
 TEST(Script, InnerObjectTests)
@@ -871,4 +889,26 @@ TEST(Script, InnerObjectTests)
    ASSERT_EQ(nestedFuncCall.getInt(), 123);
 }
 
+TEST(Script, MiscRegressions)
+{
+   ConsoleValue regression1 = RunScript(R"(
+      new SimObject(TheRegressionObject);
+
+      function doTest()
+      {
+          TheRegressionObject.hidden = false;
+
+          %previewSize = 100 SPC 100;
+          %previewScaleSize = 2;
+          %size = %previewSize.x * %previewScaleSize;
+
+          return %size;
+      }
+
+      return doTest();
+   )");
+
+   ASSERT_EQ(regression1.getInt(), 200);
+}
+
 #endif

From 5cce344bb1690598436556597fc564dfb01ccc15 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Fri, 3 Sep 2021 00:26:48 -0400
Subject: [PATCH 043/399] * BugFix: Fix a missing <vector> include for GCC. *
 BugFix: Correct some globally used local variables in the editor code.

---
 Engine/source/console/codeBlock.h            | 1 +
 Engine/source/gui/editor/inspector/field.cpp | 8 +++++---
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/Engine/source/console/codeBlock.h b/Engine/source/console/codeBlock.h
index a3c1015e9..57370f683 100644
--- a/Engine/source/console/codeBlock.h
+++ b/Engine/source/console/codeBlock.h
@@ -23,6 +23,7 @@
 #ifndef _CODEBLOCK_H_
 #define _CODEBLOCK_H_
 
+#include <vector>
 #include <unordered_map>
 
 struct CompilerLocalVariableToRegisterMappingTable
diff --git a/Engine/source/gui/editor/inspector/field.cpp b/Engine/source/gui/editor/inspector/field.cpp
index 617287e68..6ee578512 100644
--- a/Engine/source/gui/editor/inspector/field.cpp
+++ b/Engine/source/gui/editor/inspector/field.cpp
@@ -318,7 +318,8 @@ void GuiInspectorField::setData( const char* data, bool callbacks )
          {
             char buffer[ 2048 ];
             expandEscape( buffer, newValue );
-            newValue = (const char*)Con::evaluatef( "%%f = \"%s\"; return ( %s );", oldValue.c_str(), buffer );
+            newValue = (const char*)Con::evaluatef( "$f = \"%s\"; return ( %s );", oldValue.c_str(), buffer );
+            Con::evaluatef("$f=0;");
          }
          else if(    type == TypeS32Vector
                   || type == TypeF32Vector
@@ -353,9 +354,10 @@ void GuiInspectorField::setData( const char* data, bool callbacks )
                char buffer[ 2048 ];
                expandEscape( buffer, newComponentExpr );
 
-               const char* newComponentVal = Con::evaluatef( "%%f = \"%s\"; %%v = \"%s\"; return ( %s );",
+               const char* newComponentVal = Con::evaluatef( "$f = \"%s\"; $v = \"%s\"; return ( %s );",
                   oldComponentVal, oldValue.c_str(), buffer );
-               
+               Con::evaluatef("$f=0;$v=0;");
+
                if( !isFirst )
                   strNew.append( ' ' );
                strNew.append( newComponentVal );

From 313c069ecb4be14b3f3532a06f56c661644ac4d7 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Fri, 3 Sep 2021 23:27:39 -0400
Subject: [PATCH 044/399] Fix xyz again by reverting previous commit and fixing
 the local variables from not resetting the object states.

---
 Engine/source/console/codeBlock.cpp       |  7 ++
 Engine/source/console/compiledEval.cpp    | 88 ++++++++++++++++++++---
 Engine/source/console/test/ScriptTest.cpp | 18 +++++
 3 files changed, 103 insertions(+), 10 deletions(-)

diff --git a/Engine/source/console/codeBlock.cpp b/Engine/source/console/codeBlock.cpp
index 14c447ba0..91b91aa55 100644
--- a/Engine/source/console/codeBlock.cpp
+++ b/Engine/source/console/codeBlock.cpp
@@ -674,6 +674,13 @@ ConsoleValue CodeBlock::compileExec(StringTableEntry fileName, const char *inStr
 
    consoleAllocReset();
 
+#ifndef TORQUE_SHIPPING
+   if (Con::getBoolVariable("$Debug::DumpByteCode"))
+   {
+      dumpInstructions();
+   }
+#endif
+
    if (lineBreakPairCount && fileName)
       calcBreakList();
 
diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index b3f8bebc7..e96999dfd 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -164,11 +164,13 @@ namespace Con
    }
 }
 
-static void getFieldComponent(StringTableEntry subField, char val[], S32 currentLocalRegister)
+static void getFieldComponent(SimObject* object, StringTableEntry field, const char* array, StringTableEntry subField, char val[], S32 currentLocalRegister)
 {
    const char* prevVal = NULL;
 
-   if (currentLocalRegister != -1)
+   if (object && field)
+      prevVal = object->getDataField(field, array);
+   else if (currentLocalRegister != -1)
       prevVal = gEvalState.getLocalStringVariable(currentLocalRegister);
    else if (gEvalState.currentVariable)
       prevVal = gEvalState.getStringVariable();
@@ -213,7 +215,7 @@ static void getFieldComponent(StringTableEntry subField, char val[], S32 current
       val[0] = 0;
 }
 
-static void setFieldComponent(StringTableEntry subField, S32 currentLocalRegister)
+static void setFieldComponent(SimObject* object, StringTableEntry field, const char* array, StringTableEntry subField, S32 currentLocalRegister)
 {
    // Copy the current string value
    char strValue[1024];
@@ -222,6 +224,8 @@ static void setFieldComponent(StringTableEntry subField, S32 currentLocalRegiste
    char val[1024] = "";
    const char* prevVal = NULL;
 
+   if (object && field)
+      prevVal = object->getDataField(field, array);
    if (currentLocalRegister != -1)
       prevVal = gEvalState.getLocalStringVariable(currentLocalRegister);
    // Set the value on a variable.
@@ -265,7 +269,9 @@ static void setFieldComponent(StringTableEntry subField, S32 currentLocalRegiste
    if (val[0] != 0)
    {
       // Update the field or variable.
-      if (currentLocalRegister != -1)
+      if (object && field)
+         object->setDataField(field, 0, val);
+      else if (currentLocalRegister != -1)
          gEvalState.setLocalStringVariable(currentLocalRegister, val, dStrlen(val));
       else if (gEvalState.currentVariable)
          gEvalState.setStringVariable(val);
@@ -721,7 +727,9 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
    } objectCreationStack[objectCreationStackSize];
 
    SimObject* currentNewObject = 0;
+   StringTableEntry prevField = NULL;
    StringTableEntry curField = NULL;
+   SimObject* prevObject = NULL;
    SimObject* curObject = NULL;
    SimObject* saveObject = NULL;
    Namespace::Entry* nsEntry;
@@ -1400,6 +1408,8 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          // If a variable is set, then these must be NULL. It is necessary
          // to set this here so that the vector parser can appropriately
          // identify whether it's dealing with a vector.
+         prevField = NULL;
+         prevObject = NULL;
          curObject = NULL;
 
          // Used for local variable caching of what is active...when we
@@ -1420,6 +1430,8 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          ip += 2;
 
          // See OP_SETCURVAR
+         prevField = NULL;
+         prevObject = NULL;
          curObject = NULL;
 
          // Used for local variable caching of what is active...when we
@@ -1437,6 +1449,8 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          var = StringTable->insert(stack[_STK].getString());
 
          // See OP_SETCURVAR
+         prevField = NULL;
+         prevObject = NULL;
          curObject = NULL;
 
          // Used for local variable caching of what is active...when we
@@ -1454,6 +1468,8 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          var = StringTable->insert(stack[_STK].getString());
 
          // See OP_SETCURVAR
+         prevField = NULL;
+         prevObject = NULL;
          curObject = NULL;
 
          // Used for local variable caching of what is active...when we
@@ -1500,6 +1516,12 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
       case OP_LOAD_LOCAL_VAR_UINT:
          reg = code[ip++];
          currentRegister = reg;
+
+         // See OP_SETCURVAR
+         prevField = NULL;
+         prevObject = NULL;
+         curObject = NULL;
+
          stack[_STK + 1].setInt(gEvalState.getLocalIntVariable(reg));
          _STK++;
          break;
@@ -1507,6 +1529,12 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
       case OP_LOAD_LOCAL_VAR_FLT:
          reg = code[ip++];
          currentRegister = reg;
+
+         // See OP_SETCURVAR
+         prevField = NULL;
+         prevObject = NULL;
+         curObject = NULL;
+
          stack[_STK + 1].setFloat(gEvalState.getLocalFloatVariable(reg));
          _STK++;
          break;
@@ -1514,6 +1542,12 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
       case OP_LOAD_LOCAL_VAR_STR:
          reg = code[ip++];
          currentRegister = reg;
+
+         // See OP_SETCURVAR
+         prevField = NULL;
+         prevObject = NULL;
+         curObject = NULL;
+
          val = gEvalState.getLocalStringVariable(reg);
          stack[_STK + 1].setString(val);
          _STK++;
@@ -1522,12 +1556,24 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
       case OP_SAVE_LOCAL_VAR_UINT:
          reg = code[ip++];
          currentRegister = reg;
+
+         // See OP_SETCURVAR
+         prevField = NULL;
+         prevObject = NULL;
+         curObject = NULL;
+
          gEvalState.setLocalIntVariable(reg, stack[_STK].getInt());
          break;
 
       case OP_SAVE_LOCAL_VAR_FLT:
          reg = code[ip++];
          currentRegister = reg;
+
+         // See OP_SETCURVAR
+         prevField = NULL;
+         prevObject = NULL;
+         curObject = NULL;
+
          gEvalState.setLocalFloatVariable(reg, stack[_STK].getFloat());
          break;
 
@@ -1535,10 +1581,18 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          reg = code[ip++];
          val = stack[_STK].getString();
          currentRegister = reg;
+
+         // See OP_SETCURVAR
+         prevField = NULL;
+         prevObject = NULL;
+         curObject = NULL;
+
          gEvalState.setLocalStringVariable(reg, val, (S32)dStrlen(val));
          break;
 
       case OP_SETCUROBJECT:
+         // Save the previous object for parsing vector fields.
+         prevObject = curObject;
          val = stack[_STK].getString();
 
          // Sim::findObject will sometimes find valid objects from
@@ -1585,6 +1639,8 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          break;
 
       case OP_SETCURFIELD:
+         // Save the previous field for parsing vector fields.
+         prevField = curField;
          dStrcpy(prevFieldArray, curFieldArray, 256);
          curField = CodeToSTE(code, ip);
          curFieldArray[0] = 0;
@@ -1610,7 +1666,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
             // a special accessor?
             char buff[FieldBufferSizeNumeric];
             memset(buff, 0, sizeof(buff));
-            getFieldComponent(curField, buff, currentRegister);
+            getFieldComponent(prevObject, prevField, prevFieldArray, curField, buff, currentRegister);
             stack[_STK + 1].setInt(dAtol(buff));
          }
          _STK++;
@@ -1625,7 +1681,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
             // a special accessor?
             char buff[FieldBufferSizeNumeric];
             memset(buff, 0, sizeof(buff));
-            getFieldComponent(curField, buff, currentRegister);
+            getFieldComponent(prevObject, prevField, prevFieldArray, curField, buff, currentRegister);
             stack[_STK + 1].setFloat(dAtod(buff));
          }
          _STK++;
@@ -1643,7 +1699,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
             // a special accessor?
             char buff[FieldBufferSizeString];
             memset(buff, 0, sizeof(buff));
-            getFieldComponent(curField, buff, currentRegister);
+            getFieldComponent(prevObject, prevField, prevFieldArray, curField, buff, currentRegister);
             stack[_STK + 1].setString(buff);
          }
          _STK++;
@@ -1653,21 +1709,33 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          if (curObject)
             curObject->setDataField(curField, curFieldArray, stack[_STK].getString());
          else
-            setFieldComponent( curField, currentRegister );
+         {
+            // The field is not being set on an object. Maybe it's a special accessor?
+            setFieldComponent(prevObject, prevField, prevFieldArray, curField, currentRegister);
+            prevObject = NULL;
+         }
          break;
 
       case OP_SAVEFIELD_FLT:
          if (curObject)
             curObject->setDataField(curField, curFieldArray, stack[_STK].getString());
          else
-            setFieldComponent( curField, currentRegister );
+         {
+            // The field is not being set on an object. Maybe it's a special accessor?
+            setFieldComponent(prevObject, prevField, prevFieldArray, curField, currentRegister);
+            prevObject = NULL;
+         }
          break;
 
       case OP_SAVEFIELD_STR:
          if (curObject)
             curObject->setDataField(curField, curFieldArray, stack[_STK].getString());
          else
-            setFieldComponent( curField, currentRegister );
+         {
+            // The field is not being set on an object. Maybe it's a special accessor?
+            setFieldComponent(prevObject, prevField, prevFieldArray, curField, currentRegister);
+            prevObject = NULL;
+         }
          break;
 
       case OP_POP_STK:
diff --git a/Engine/source/console/test/ScriptTest.cpp b/Engine/source/console/test/ScriptTest.cpp
index cce1e6824..73b9b1e47 100644
--- a/Engine/source/console/test/ScriptTest.cpp
+++ b/Engine/source/console/test/ScriptTest.cpp
@@ -909,6 +909,24 @@ TEST(Script, MiscRegressions)
    )");
 
    ASSERT_EQ(regression1.getInt(), 200);
+
+   ConsoleValue regression2 = RunScript(R"(
+      new SimObject(TheRegressionObject2) 
+      {
+         extent = "100 200";
+      };
+
+      function doTest()
+      {
+          %scale = 2;
+          %position = TheRegressionObject2.extent.x SPC TheRegressionObject2.extent.y * %scale;
+          return %position.y;
+      }
+
+      return doTest();
+   )");
+
+   ASSERT_EQ(regression2.getInt(), 400);
 }
 
 #endif

From df0f8dafa6db89fcae52d1e002771aa5a0f2409a Mon Sep 17 00:00:00 2001
From: Areloch <Areloch@gmail.com>
Date: Sat, 4 Sep 2021 02:27:21 -0500
Subject: [PATCH 045/399] Imported in UI sounds Fixed asset properties editing
 so it applies after saving Added fix for making sound asset preview playback
 properly

---
 .../data/UI/sounds/buttonClick.asset.taml     |  1 +
 .../data/UI/sounds/buttonHover.asset.taml     |  1 +
 .../assetBrowser/scripts/assetBrowser.tscript |  2 +-
 .../scripts/assetTypes/sound.tscript          | 42 +++++++++++++++++--
 .../assetBrowser/scripts/editAsset.tscript    | 15 ++++++-
 5 files changed, 56 insertions(+), 5 deletions(-)
 create mode 100644 Templates/BaseGame/game/data/UI/sounds/buttonClick.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/sounds/buttonHover.asset.taml

diff --git a/Templates/BaseGame/game/data/UI/sounds/buttonClick.asset.taml b/Templates/BaseGame/game/data/UI/sounds/buttonClick.asset.taml
new file mode 100644
index 000000000..99773fd2d
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/sounds/buttonClick.asset.taml
@@ -0,0 +1 @@
+<SoundAsset canSave="true" canSaveDynamicFields="true" AssetName="buttonClick" soundFile="@assetFile=buttonClick.wav" PitchAdjust="1" VolumeAdjust="1" is3D="false" isLooping="false" isStreaming="false" useHardware="false" minDistance="1" maxDistance="100" coneInsideAngle="360" coneOutsideAngle="360" coneOutsideVolume="1" rolloffFactor="-1" scatterDistance="0 0 0"/>
diff --git a/Templates/BaseGame/game/data/UI/sounds/buttonHover.asset.taml b/Templates/BaseGame/game/data/UI/sounds/buttonHover.asset.taml
new file mode 100644
index 000000000..00b1af405
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/sounds/buttonHover.asset.taml
@@ -0,0 +1 @@
+<SoundAsset canSave="true" canSaveDynamicFields="true" AssetName="buttonHover" soundFile="@assetFile=buttonHover.wav" PitchAdjust="1" VolumeAdjust="1" is3D="false" isLooping="false" isStreaming="false" useHardware="true" minDistance="1" maxDistance="120" coneInsideAngle="360" coneOutsideAngle="360" coneOutsideVolume="1" rolloffFactor="-1" scatterDistance="0 0 0"/>
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
index e95ec0572..bf21750ff 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
@@ -1178,7 +1178,7 @@ function AssetBrowserPreviewButton::onRightClick(%this)
    EditAssetPopup.enableItem(7, true);
    
    //Is it an editable type?
-   if(%assetType $= "ImageAsset" /*|| %assetType $= "GameObjectAsset"*/ || %assetType $= "CppAsset" || %assetType $= "SoundAsset")
+   if(%assetType $= "ImageAsset" /*|| %assetType $= "GameObjectAsset"*/ || %assetType $= "CppAsset")
    {
       EditAssetPopup.enableItem(0, false);
    }
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/sound.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/sound.tscript
index 304d21532..77eb1a7cd 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/sound.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/sound.tscript
@@ -1,13 +1,30 @@
+function AssetBrowser::editSoundAsset(%this, %assetDef)
+{
+   if (isObject($PreviewSoundSource))
+        sfxStop($PreviewSoundSource);
+   $PreviewSoundSource = %assetDef.playSound();
+}
+
 function AssetBrowser::buildSoundAssetPreview(%this, %assetDef, %previewData)
 {
    %previewData.assetName = %assetDef.assetName;
    %previewData.assetPath = %assetDef.soundFilePath;
-   //%previewData.doubleClickCommand = "EditorOpenFileInTorsion( "@%previewData.assetPath@", 0 );";
    
    if(%this.selectMode)
+   {
       %previewData.doubleClickCommand = "AssetBrowser.selectAsset( AssetBrowser.selectedAsset );";
+   }
    else
+   {
+      if(EditorSettings.value("Assets/Browser/doubleClickAction", "Edit Asset") $= "Edit Asset")
+      {
       %previewData.doubleClickCommand = "AssetBrowser.editAsset( "@%assetDef@" );";
+      }
+      else
+      {
+         %previewData.doubleClickCommand = "AssetBrowser.onSoundAssetEditorDropped( "@%assetDef@" );";
+      }
+   }
    
    %previewData.previewImage = "ToolsModule:soundIcon_image";   
    
@@ -52,7 +69,26 @@ function AssetBrowser::onSoundAssetEditorDropped(%this, %assetDef, %position)
    
 }
 
-function AssetBrowser::editSoundAsset(%this, %assetDef)
+function GuiInspectorTypeShapeAssetPtr::onControlDropped( %this, %payload, %position )
 {
-   %soundSource = %assetDef.playSound();
+   Canvas.popDialog(EditorDragAndDropLayer);
+   
+   // Make sure this is a color swatch drag operation.
+   if( !%payload.parentGroup.isInNamespaceHierarchy( "AssetPreviewControlType_AssetDrop" ) )
+      return;
+
+   %assetType = %payload.assetType;
+   
+   if(%assetType $= "SoundAsset")
+{
+      %module = %payload.moduleName;
+      %asset = %payload.assetName;
+      
+      %targetComponent = %this.targetObject;
+      %targetComponent.soundAsset = %module @ ":" @ %asset;
+      
+      //Inspector.refresh();
+   }
+   
+   EWorldEditor.isDirty = true;
 }
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/editAsset.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/editAsset.tscript
index 856ba7d11..b031c6124 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/editAsset.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/editAsset.tscript
@@ -3,7 +3,9 @@ function AssetBrowser_editAsset::saveAsset(%this)
    %file = AssetDatabase.getAssetFilePath(%this.editedAssetId);
    %success = TamlWrite(AssetBrowser_editAsset.editedAsset, %file);
    
-   AssetBrowser.loadFilters();
+   AssetBrowser.reloadAsset(%this.editedAssetId);
+
+   AssetBrowser.refresh();
 
    Canvas.popDialog(AssetBrowser_editAsset);
 }
@@ -79,6 +81,17 @@ function AssetBrowser::editAssetInfo(%this)
 }
 
 //------------------------------------------------------------
+function AssetBrowser::reloadAsset(%this, %assetId)
+{
+   %moduleName = getToken(%assetId, ":", 0);
+   %moduleDef = ModuleDatabase.findModule(%moduleName);
+   
+   %assetName = getToken(%assetId, ":", 1);
+   %assetFilePath = AssetDatabase.getAssetFilePath(%assetId);
+   
+   AssetDatabase.removeDeclaredAsset(%assetId);
+   AssetDatabase.addDeclaredAsset(%moduleDef, %assetFilePath);  
+}
 
 function AssetBrowser::refreshAsset(%this, %assetId)
 {

From 278bef8d1a8aacddf5545ab0f18d2be056e79920 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Sat, 4 Sep 2021 16:23:20 -0400
Subject: [PATCH 046/399] Fix if to else if regression.

---
 Engine/source/console/compiledEval.cpp    |  2 +-
 Engine/source/console/test/ScriptTest.cpp | 23 +++++++++++++++++++++++
 2 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index e96999dfd..c8b1547a1 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -226,7 +226,7 @@ static void setFieldComponent(SimObject* object, StringTableEntry field, const c
 
    if (object && field)
       prevVal = object->getDataField(field, array);
-   if (currentLocalRegister != -1)
+   else if (currentLocalRegister != -1)
       prevVal = gEvalState.getLocalStringVariable(currentLocalRegister);
    // Set the value on a variable.
    else if (gEvalState.currentVariable)
diff --git a/Engine/source/console/test/ScriptTest.cpp b/Engine/source/console/test/ScriptTest.cpp
index 73b9b1e47..d42c4fe73 100644
--- a/Engine/source/console/test/ScriptTest.cpp
+++ b/Engine/source/console/test/ScriptTest.cpp
@@ -927,6 +927,29 @@ TEST(Script, MiscRegressions)
    )");
 
    ASSERT_EQ(regression2.getInt(), 400);
+
+   ConsoleValue regression3 = RunScript(R"(
+      function doTest()
+      {
+          %button = new GuiIconButtonCtrl()
+          {
+              active = true;
+          };
+
+          %button.setExtent(120, 20);
+
+          %button.setExtent("120 20");
+
+          %button.extent = "120 20";
+
+          %button.extent.x = 120;
+          %button.extent.y = 20;
+          return %button.extent;
+      }
+      return doTest();
+   )");
+
+   ASSERT_STREQ(regression3.getString(), "120 20");
 }
 
 #endif

From 478a04bea82b6b9a38752bf45d86c52f1038c3d3 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Sat, 4 Sep 2021 16:37:59 -0400
Subject: [PATCH 047/399] Fix DSOs and bump version!

---
 Engine/source/console/codeBlock.cpp | 8 ++------
 Engine/source/console/compiler.cpp  | 8 ++++++--
 Engine/source/console/console.h     | 3 ++-
 3 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/Engine/source/console/codeBlock.cpp b/Engine/source/console/codeBlock.cpp
index 91b91aa55..1d1ad7593 100644
--- a/Engine/source/console/codeBlock.cpp
+++ b/Engine/source/console/codeBlock.cpp
@@ -412,17 +412,13 @@ bool CodeBlock::read(StringTableEntry fileName, Stream &st)
    {
       for (i = 0; i < size; i++)
       {
-         char functionNameBuffer[256];
-         st.readString(functionNameBuffer);
-         StringTableEntry fnName = StringTable->insert(functionNameBuffer);
+         StringTableEntry fnName = st.readSTString();
 
          U32 count;
          st.read(&count);
          for (U32 j = 0; j < count; j++)
          {
-            char varNameBuffer[256];
-            st.readString(varNameBuffer);
-            StringTableEntry varName = StringTable->insert(varNameBuffer);
+            StringTableEntry varName = st.readSTString();
 
             variableRegisterTable.localVarToRegister[fnName].varList.push_back(varName);
          }
diff --git a/Engine/source/console/compiler.cpp b/Engine/source/console/compiler.cpp
index 9af61bef2..1ab6e7b22 100644
--- a/Engine/source/console/compiler.cpp
+++ b/Engine/source/console/compiler.cpp
@@ -253,16 +253,20 @@ void CompilerLocalVariableToRegisterMappingTable::reset()
 
 void CompilerLocalVariableToRegisterMappingTable::write(Stream& stream)
 {
-   stream.write(localVarToRegister.size());
+   stream.write((U32)localVarToRegister.size());
+
    for (const auto& pair : localVarToRegister)
    {
       StringTableEntry functionName = pair.first;
       stream.writeString(functionName);
 
       const auto& localVariableTableForFunction = localVarToRegister[functionName].varList;
-      stream.write(localVariableTableForFunction.size());
+      stream.write((U32)localVariableTableForFunction.size());
+
       for (const StringTableEntry& varName : localVariableTableForFunction)
+      {
          stream.writeString(varName);
+      }
    }
 }
 
diff --git a/Engine/source/console/console.h b/Engine/source/console/console.h
index d975ccd4d..a5086488c 100644
--- a/Engine/source/console/console.h
+++ b/Engine/source/console/console.h
@@ -496,7 +496,8 @@ namespace Con
       /// 10/14/14 - jamesu - 47->48 Added opcodes to reduce reliance on strings in function calls
       /// 10/07/17 - JTH - 48->49 Added opcode for function pointers and revamp of interpreter 
       ///                         from switch to function calls.
-      DSOVersion = 49,
+      /// 09/04/21 - JTH - 49->50 Rewrite of interpreter
+      DSOVersion = 50,
 
       MaxLineLength = 512,  ///< Maximum length of a line of console input.
       MaxDataTypes = 256    ///< Maximum number of registered data types.

From c16b88d709a31a1268a4b48eb0222592f786fb87 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Sat, 4 Sep 2021 21:25:11 -0400
Subject: [PATCH 048/399] Fix temporary buffer for scripting conversions.

---
 Engine/source/app/mainLoop.cpp    |  1 +
 Engine/source/console/console.cpp | 18 +++++++++++++-----
 Engine/source/console/console.h   | 10 ++++++++--
 Engine/source/core/util/tVector.h | 10 ++++++++++
 4 files changed, 32 insertions(+), 7 deletions(-)

diff --git a/Engine/source/app/mainLoop.cpp b/Engine/source/app/mainLoop.cpp
index 871a7cc88..97f25e4f3 100644
--- a/Engine/source/app/mainLoop.cpp
+++ b/Engine/source/app/mainLoop.cpp
@@ -633,6 +633,7 @@ bool StandardMainLoop::doMainLoop()
 
       ThreadPool::processMainThreadWorkItems();
       Sampler::endFrame();
+      ConsoleValue::resetConversionBuffer();
       PROFILE_END_NAMED(MainLoop);
    }
    
diff --git a/Engine/source/console/console.cpp b/Engine/source/console/console.cpp
index 36b0aa4d8..399298864 100644
--- a/Engine/source/console/console.cpp
+++ b/Engine/source/console/console.cpp
@@ -46,21 +46,29 @@
 extern StringStack STR;
 extern ConsoleValueStack<4096> gCallStack;
 
-char ConsoleValue::sConversionBuffer[ConversionBufferSize];
+Vector<ConsoleValue::ConversionBuffer> ConsoleValue::sConversionBuffer;
 
 void ConsoleValue::init()
 {
-   dMemset(sConversionBuffer, '\0', ConversionBufferSize);
+   sConversionBuffer.reserve(8192);
+}
+
+void ConsoleValue::resetConversionBuffer()
+{
+   sConversionBuffer.resetAndTreatAsScratchBuffer();
 }
 
 char* ConsoleValue::convertToBuffer() const
 {
+   ConversionBuffer conversion;
+   
    if (type == ConsoleValueType::cvFloat)
-      dSprintf(sConversionBuffer, ConversionBufferSize, "%.9g", f);
+      dSprintf(conversion.buffer, ConversionBufferStride, "%.9g", f);
    else
-      dSprintf(sConversionBuffer, ConversionBufferSize, "%lld", i);
+      dSprintf(conversion.buffer, ConversionBufferStride, "%lld", i);
 
-   return sConversionBuffer;
+   sConversionBuffer.push_back(std::move(conversion));
+   return sConversionBuffer.last().buffer;
 }
 
 const char* ConsoleValue::getConsoleData() const
diff --git a/Engine/source/console/console.h b/Engine/source/console/console.h
index a5086488c..5c72f34e1 100644
--- a/Engine/source/console/console.h
+++ b/Engine/source/console/console.h
@@ -148,10 +148,15 @@ class ConsoleValue
 
    enum Constants
    {
-      ConversionBufferSize = 32
+      ConversionBufferStride = 32
    };
 
-   static char sConversionBuffer[ConversionBufferSize];
+   struct ConversionBuffer
+   {
+      char buffer[ConversionBufferStride];
+   };
+   
+   static Vector<ConversionBuffer> sConversionBuffer;
 
    char* convertToBuffer() const;
 
@@ -387,6 +392,7 @@ public:
    }
 
    static void init();
+   static void resetConversionBuffer();
 };
 
 // Transparently converts ConsoleValue[] to const char**
diff --git a/Engine/source/core/util/tVector.h b/Engine/source/core/util/tVector.h
index 0700a5554..57cb84e24 100644
--- a/Engine/source/core/util/tVector.h
+++ b/Engine/source/core/util/tVector.h
@@ -160,6 +160,7 @@ class Vector
    void erase(U32 index, U32 count);
    void erase_fast(iterator);
    void clear();
+   void resetAndTreatAsScratchBuffer();
    void compact();
    void sort(compare_func f);
    void fill( const T& value );
@@ -529,6 +530,15 @@ template<class T> inline void Vector<T>::clear()
    mElementCount = 0;
 }
 
+/// This method sets the vector as its 0 and will overwrite memory on subsequent usage.
+/// Note that the current memory in use is never freed or deallocated, so only use this if the vector
+/// is being used as a scratch buffer only.
+template<class T> inline
+void Vector<T>::resetAndTreatAsScratchBuffer()
+{
+   mElementCount = 0;
+}
+
 template<class T> inline void Vector<T>::compact()
 {
    resize(mElementCount);

From 9b2f4976c980621142bbddaac97818cc2e0560ca Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Sat, 4 Sep 2021 22:00:32 -0400
Subject: [PATCH 049/399] small regression fix.

---
 Engine/source/console/compiledEval.cpp    |  4 ++--
 Engine/source/console/test/ScriptTest.cpp | 18 ++++++++++++++++++
 2 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index c8b1547a1..378afd290 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -2002,7 +2002,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
                      break;
                   }
 
-                  stack[_STK + 1].setInt(result);
+                  stack[_STK + 1].setFloat(result);
                   _STK++;
                   break;
                }
@@ -2139,7 +2139,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
       {
          bool isGlobal = code[ip];
 
-         U32 failIp = code[ip + isGlobal ? 3 : 2];
+         U32 failIp = code[ip + (isGlobal ? 3 : 2)];
 
          IterStackRecord& iter = iterStack[_ITER];
          iter.mIsGlobalVariable = isGlobal;
diff --git a/Engine/source/console/test/ScriptTest.cpp b/Engine/source/console/test/ScriptTest.cpp
index d42c4fe73..a2295f774 100644
--- a/Engine/source/console/test/ScriptTest.cpp
+++ b/Engine/source/console/test/ScriptTest.cpp
@@ -950,6 +950,24 @@ TEST(Script, MiscRegressions)
    )");
 
    ASSERT_STREQ(regression3.getString(), "120 20");
+   
+   ConsoleValue regression4 = RunScript(R"(
+    function doTest()
+    {
+        %slider = new GuiSliderCtrl()
+        {
+            range = "0 2";
+            ticks = 5;
+            active = true;
+        };
+
+        %slider.setValue(0.5);
+        return %slider.getValue();
+    }
+    return doTest();
+   )");
+   
+   ASSERT_EQ(regression4.getFloat(), 0.5);
 }
 
 #endif

From 0ca66b99db81a3363dde1ea6dbc4d84e5a764467 Mon Sep 17 00:00:00 2001
From: Areloch <Areloch@gmail.com>
Date: Sun, 5 Sep 2021 03:43:41 -0500
Subject: [PATCH 050/399] Added fix so if a looping sound is preview-playing in
 the AB and you edit the properties, it doesn't try to reload the asset while
 it's playing, causing a crash Added console method for looking up a
 soundAsset by filename Added initial pass of project importer for sound
 assets content

---
 Engine/source/T3D/assets/SoundAsset.cpp       |   8 +
 Engine/source/sfx/sfxSource.cpp               |  11 +-
 .../scripts/assetTypes/shape.tscript          |   4 +
 .../scripts/assetTypes/sound.tscript          |   6 +
 .../assetBrowser/scripts/editAsset.tscript    |   5 +
 .../pre40/T3Dpre4ProjectImporter.tscript      | 168 ++++++++++++++++++
 .../scripts/projectImporter.tscript           | 115 +++++++++++-
 7 files changed, 309 insertions(+), 8 deletions(-)

diff --git a/Engine/source/T3D/assets/SoundAsset.cpp b/Engine/source/T3D/assets/SoundAsset.cpp
index d4e9a745a..d00c0dbe2 100644
--- a/Engine/source/T3D/assets/SoundAsset.cpp
+++ b/Engine/source/T3D/assets/SoundAsset.cpp
@@ -343,6 +343,14 @@ DefineEngineMethod(SoundAsset, playSound, S32, (Point3F position), (Point3F::Zer
       return 0;
 }
 
+#ifdef TORQUE_TOOLS
+DefineEngineStaticMethod(SoundAsset, getAssetIdByFilename, const char*, (const char* filePath), (""),
+   "Queries the Asset Database to see if any asset exists that is associated with the provided file path.\n"
+   "@return The AssetId of the associated asset, if any.")
+{
+   return SoundAsset::getAssetIdByFileName(StringTable->insert(filePath));
+}
+#endif
 IMPLEMENT_CONOBJECT(GuiInspectorTypeSoundAssetPtr);
 
 ConsoleDocClass(GuiInspectorTypeSoundAssetPtr,
diff --git a/Engine/source/sfx/sfxSource.cpp b/Engine/source/sfx/sfxSource.cpp
index abc5b35e1..9b776af94 100644
--- a/Engine/source/sfx/sfxSource.cpp
+++ b/Engine/source/sfx/sfxSource.cpp
@@ -791,6 +791,9 @@ void SFXSource::_setStatus( SFXStatus status )
 
 void SFXSource::_updateVolume( const MatrixF& listener )
 {
+   if (!mDescription)
+      return;
+
    // Handle fades (compute mFadedVolume).
       
    mFadedVolume = mPreFadeVolume;
@@ -919,13 +922,19 @@ void SFXSource::_updateVolume( const MatrixF& listener )
 
 void SFXSource::_updatePitch()
 {
+   if (!mDescription)
+      return;
+
    mEffectivePitch = mModulativePitch * mPitch;
 }
 
 //-----------------------------------------------------------------------------
 
 void SFXSource::_updatePriority()
-{      
+{
+   if (!mDescription)
+      return;
+
    mEffectivePriority = mPriority * mModulativePriority;
 
    SFXSource* group = getSourceGroup();
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
index 4bf17453a..8ca2a21ed 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
@@ -42,6 +42,10 @@ function AssetBrowser::editShapeAsset(%this, %assetDef)
    ShapeEditorPlugin.openShapeAsset(%assetDef);    
 }
 
+function AssetBrowser::onShapeAssetChanged(%this, %assetDef)
+{
+}
+
 function AssetBrowser::deleteShapeAsset(%this, %assetDef)
 {
    
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/sound.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/sound.tscript
index 77eb1a7cd..3322964bc 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/sound.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/sound.tscript
@@ -5,6 +5,12 @@ function AssetBrowser::editSoundAsset(%this, %assetDef)
    $PreviewSoundSource = %assetDef.playSound();
 }
 
+function AssetBrowser::onSoundAssetChanged(%this, %assetDef)
+{
+   if (isObject($PreviewSoundSource))
+        sfxStop($PreviewSoundSource);
+}
+
 function AssetBrowser::buildSoundAssetPreview(%this, %assetDef, %previewData)
 {
    %previewData.assetName = %assetDef.assetName;
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/editAsset.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/editAsset.tscript
index b031c6124..13269cb25 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/editAsset.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/editAsset.tscript
@@ -6,6 +6,11 @@ function AssetBrowser_editAsset::saveAsset(%this)
    AssetBrowser.reloadAsset(%this.editedAssetId);
 
    AssetBrowser.refresh();
+   
+   %assetType = AssetDatabase.getAssetType(%this.editedAssetId);
+   %assetDef = AssetDatabase.acquireAsset(%this.editedAssetId);
+   AssetBrowser.call("on" @ %assetType @ "Changed", %assetDef);
+   AssetDatabase.releaseAsset(%this.editedAssetId);
 
    Canvas.popDialog(AssetBrowser_editAsset);
 }
diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
index 735e8dd66..4c6ede9fb 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
@@ -838,6 +838,7 @@ T3Dpre4ProjectImporter::genProcessor("afxBillboardData", "texture textureAsset")
 T3Dpre4ProjectImporter::genProcessor("afxModelData", "shapeName shapeAsset shapeFile shapeAsset");
 T3Dpre4ProjectImporter::genProcessor("afxZodiacData", "texture textureAsset");
 T3Dpre4ProjectImporter::genProcessor("afxZodiacPlaneData", "texture textureAsset");
+T3Dpre4ProjectImporter::genProcessor("sfxEmitter", "track soundAsset filename soundAsset");
 //==============================================================================
 // Levels
 //==============================================================================
@@ -1064,6 +1065,173 @@ function T3Dpre4ProjectImporter::processTerrainMaterialObject(%this, %file, %obj
 //==============================================================================
 T3Dpre4ProjectImporter::genProcessor("PostEffect", "texture textureAsset");
 
+//==============================================================================
+// Sounds
+// Sounds are a little weird because there's so much data tied up in a given sound
+// source. So our approach is find old SFXProfiles and process those into sound assets
+// by cross-referencing the filename for existing asset definitions.
+// Using existing SFXProfiles allows us to also injest the descriptions, giving us
+// our meta-properties on the sound asset itself.
+//==============================================================================
+function T3Dpre4ProjectImporter::processSFXProfileLine(%this, %line)
+{
+   return %line;
+}
+
+function T3Dpre4ProjectImporter::processSFXProfileObject(%this, %file, %objectName)
+{
+   %soundFilename = findObjectField("filename");
+   
+   %soundFilename = sanitizeFilename(%soundFilename);
+
+   %soundAsset = SoundAsset::getAssetIdByFilename(%soundFilename);
+   
+   //Throw a warn that this file's already been claimed and move on
+   if(%soundAsset !$= "")
+   {
+      error("T3Dpre4ProjectImporter::processSFXProfileObject() - attempting to process SFXProfile " @ %objectName 
+               @ " but its filename is already associated to another sound asset.");
+      return false;
+   }  
+   //Otherwise, process it into an asset
+   else
+   {
+      %assetName = %objectName;
+   
+      %moduleName = AssetBrowser.dirHandler.getModuleFromAddress(%soundFilename).ModuleId;
+      
+      %assetPath = filePath(%soundFilename) @ "/";   
+      
+      %tamlpath = %assetPath @ %assetName @ ".asset.taml";
+      
+      if(isFile(%tamlpath))
+      {
+         error("T3Dpre4ProjectImporter::processSFXProfileObject() - Failed to create as taml file already exists: " @ %soundFilename);
+         return false;
+      }
+      
+      %asset = new SoundAsset()
+      {
+         AssetName = %assetName;
+         versionId = 1;
+         shaderData = "";
+         soundFile = fileBase(%soundFilename) @ fileExt(%soundFilename);
+      };
+      
+      %descriptionName = findObjectField("description");
+      
+      if(%descriptionName !$= "")
+      {
+         //Optimization, see if we already have this description by happenstance
+         if(isObject(%descriptionName))
+         {
+            %asset.sourceGroup = %descriptionName.sourceGroup;
+            %asset.volume = %descriptionName.volume;
+            %asset.pitch = %descriptionName.pitch;
+            %asset.isLooping = %descriptionName.isLooping;
+            %asset.priority = %descriptionName.priority;
+            %asset.useHardware = %descriptionName.useHardware;
+            %asset.is3D = %descriptionName.is3D;
+            %asset.minDistance = %descriptionName.minDistance;
+            %asset.maxDistance = %descriptionName.maxDistance;
+            %asset.scatterDistance = %descriptionName.scatterDistance;
+            %asset.coneInsideAngle = %descriptionName.coneInsideAngle;            
+            %asset.coneOutsideAngle = %descriptionName.coneOutsideAngle;         
+            %asset.coneOutsideVolume = %descriptionName.coneOutsideVolume;
+            %asset.rolloffFactor = %descriptionName.rolloffFactor;
+            %asset.isStreaming = %descriptionName.isStreaming;
+         }
+         else
+         {
+            %objFileFinder = findObjectInFiles(%descriptionName);
+            if(%objFileFinder !$= "")
+            {
+               %valueArray = new ArrayObject();
+               
+               %valueArray.add("sourceGroup" SPC findObjectField("sourceGroup", %objFileFinder));
+               %valueArray.add("volume" SPC findObjectField("volume", %objFileFinder));
+               %valueArray.add("pitch" SPC findObjectField("pitch", %objFileFinder));
+               %valueArray.add("isLooping" SPC findObjectField("isLooping", %objFileFinder));
+               %valueArray.add("priority" SPC findObjectField("priority", %objFileFinder));
+               %valueArray.add("useHardware" SPC findObjectField("useHardware", %objFileFinder));
+               %valueArray.add("is3D" SPC findObjectField("is3D", %objFileFinder));
+               %valueArray.add("minDistance" SPC findObjectField("minDistance", %objFileFinder));
+               %valueArray.add("maxDistance" SPC findObjectField("maxDistance", %objFileFinder));
+               %valueArray.add("scatterDistance" SPC findObjectField("scatterDistance", %objFileFinder));
+               %valueArray.add("coneInsideAngle" SPC findObjectField("coneInsideAngle", %objFileFinder));
+               %valueArray.add("coneOutsideAngle" SPC findObjectField("coneOutsideAngle", %objFileFinder));
+               %valueArray.add("coneOutsideVolume" SPC findObjectField("coneOutsideVolume", %objFileFinder));
+               %valueArray.add("rolloffFactor" SPC findObjectField("rolloffFactor", %objFileFinder));
+               %valueArray.add("isStreaming" SPC findObjectField("isStreaming", %objFileFinder));
+               
+               %objFileFinder.delete();
+               
+               for(%v=0; %v < %valueArray.Count(); %v++)
+               {
+                  %varSet = %valueArray.getKey(%v);
+                  %var = getWord(%varSet, 0);
+                  %varVal = getWord(%varSet, 1);
+
+                  if(%varVal !$= "")
+                     %asset.setFieldValue(%var, %varVal);
+               }
+            }
+         }
+      }
+      
+      TamlWrite(%asset, %tamlpath);
+      
+      %moduleDef = ModuleDatabase.findModule(%moduleName, 1);
+      %success = AssetDatabase.addDeclaredAsset(%moduleDef, %tamlpath);
+      
+      if(!%success)
+         return false;
+   }
+   
+   //Now mark the original SFXProfile for removal from the file as it's redundant
+   //now that we have the asset def
+   
+   /*if(%matAsset $= "" || %matAsset $= "Core_Rendering:NoMaterial")
+   {
+      %assetName = %objectName;
+   
+      %moduleName = AssetBrowser.dirHandler.getModuleFromAddress(%file).ModuleId;
+      
+      %assetPath = filePath(%file) @ "/";   
+      
+      %tamlpath = %assetPath @ %assetName @ ".asset.taml";
+      
+      if(isFile(%tamlpath))
+      {
+         error("T3Dpre4ProjectImporter::processMaterialObject() - Failed to create as taml file already exists: " @ %file);
+         return false;
+      }
+      
+      %asset = new MaterialAsset()
+      {
+         AssetName = %assetName;
+         versionId = 1;
+         shaderData = "";
+         materialDefinitionName = %assetName;
+         scriptFile = fileBase(%file);
+      };
+      
+      TamlWrite(%asset, %tamlpath);
+      
+      %moduleDef = ModuleDatabase.findModule(%moduleName, 1);
+      %success = AssetDatabase.addDeclaredAsset(%moduleDef, %tamlpath);
+      
+      if(!%success)
+         return false;
+   }*/
+   
+   return true;
+}
+
+function T3Dpre4ProjectImporter::processAudioProfileObject(%this, %file, %objectName)
+{
+   return %this.processSFXProfileObject(%file, %objectName);
+}
 
 //==============================================================================
 // Misc Utility functions
diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
index 05a0847f4..d49e4eac4 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
@@ -416,7 +416,7 @@ function sanitizeFilename(%file)
    %sanitizedName = sanitizeString(%targetName);
    if(startsWith(%sanitizedName, "_"))
    {
-      %sanitizedName = substr(%sanitizedName, 1, -1);
+      %sanitizedName = getSubStr(%sanitizedName, 1, -1);
    }
    if(%sanitizedName !$= %targetName)
    {
@@ -472,6 +472,12 @@ function testFilenameExtensions(%filename)
       return %filename @ ".dae";
    else if(isFile(%filename @ ".dds"))
       return %filename @ ".dds";
+   else if(isFile(%filename @ ".ogg"))
+      return %filename @ ".ogg";
+   else if(isFile(%filename @ ".wav"))
+      return %filename @ ".wav";
+   else if(isFile(%filename @ ".mp3"))
+      return %filename @ ".dds";
       
    return %filename;
 }
@@ -659,11 +665,14 @@ function findObjectName(%line, %createWord)
    return %objectName; 
 }
 
-function findObjectField(%fieldName)
+function findObjectField(%fieldName, %fileObj)
 {
+   if(%fileObj $= "")
+      %fileObj = $ProjectImporter::fileObject;
+      
    %value = "";
    %peekLineOffset = 0;
-   %peekLine = $ProjectImporter::fileObject.peekLine(%peekLineOffset);
+   %peekLine = %fileObj.peekLine(%peekLineOffset);
    while(!strIsMatchExpr("*};*", %peekLine) && 
          !strIsMatchExpr("*singleton*(*)*", %peekLine) && 
          !strIsMatchExpr("*new*(*)*", %peekLine) && 
@@ -671,7 +680,7 @@ function findObjectField(%fieldName)
          !strIsMatchExpr("\n", %peekLine) && 
          !strIsMatchExpr("\r", %peekLine))
    {
-      if(strpos(%peekLine, %fieldName) != -1)
+      if(strpos(strlwr(%peekLine), strlwr(%fieldName)) != -1)
       {
          %value = "";
          %pos = strpos(%peekLine, "= \"");
@@ -682,8 +691,7 @@ function findObjectField(%fieldName)
            %value = getSubStr(%peekLine, %pos+3, %endPos-%pos-3);
            break;
          }
-         else
-         {
+         
             %pos = strpos(%peekLine, "=\"");
             if(%pos != -1)
             {
@@ -692,16 +700,109 @@ function findObjectField(%fieldName)
               %value = getSubStr(%peekLine, %pos+2, %endPos-%pos-2);
               break;
             }
+         
+         %pos = strpos(%peekLine, "= ");
+         if(%pos != -1)
+         {
+           %endPos = strpos(%peekLine, ";", %pos); 
+           
+           %value = getSubStr(%peekLine, %pos+2, %endPos-%pos-2);
+           break;
+         }
+
+         %pos = strpos(%peekLine, "=");
+         if(%pos != -1)
+         {
+           %endPos = strpos(%peekLine, ";", %pos); 
+           
+           %value = getSubStr(%peekLine, %pos+2, %endPos-%pos-2);
+           break;
          }  
       }
       
       %peekLineOffset++;
-      %peekLine = $ProjectImporter::fileObject.peekLine(%peekLineOffset);
+      %peekLine = %fileObj.peekLine(%peekLineOffset);
    }  
    
    return %value;
 }
 
+function findObjectInFiles(%objectName)
+{
+   //First, wipe out any files inside the folder first
+   %file = findFirstFileMultiExpr( "*.*", true);
+   
+   %fileObj = new FileObject();
+   
+   while( %file !$= "" )
+   {      
+      %filename = fileName(%file);
+      %fileBase = fileBase(%file);
+      %fileExt = fileExt(%file);
+      %filePath = filePath(%file);
+      
+      if ( %fileObj.openForRead( %file ) ) 
+      {
+         %lineNum = 0;
+         while ( !%fileObj.isEOF() ) 
+         {
+            %line = %fileObj.readLine();
+            %trimmedLine = trim(%line);
+            
+            if(strIsMatchExpr("*new*(*)*", %line) && strpos(%line, "::") == -1)
+            {
+               %className = findObjectClass(%line, "new");
+               if (%className $= "") continue;
+
+               %objName = findObjectName(%line, "new");
+               
+               if(%objectName $= %objName)
+               {
+                  return %fileObj;
+               }
+            }
+            else if(strIsMatchExpr("*datablock*(*)*", %line) && strpos(%line, "::") == -1)
+            {
+               %className = findObjectClass(%line, "datablock");
+               if (%className $= "") continue;
+
+               %objName = findObjectName(%line, "datablock");
+               
+               if(%objectName $= %objName)
+               {
+                  return %fileObj;
+               }
+            }
+            else if(strIsMatchExpr("*singleton*(*)*", %line) && strpos(%line, "::") == -1)
+            {
+               %className = findObjectClass(%line, "singleton");
+               if (%className $= "") continue;
+
+               %objName = findObjectName(%line, "singleton");
+               
+               if(%objectName $= %objName)
+               {
+                  return %fileObj;
+               }
+            }
+            
+            %lineNum++;
+         }
+         
+         %fileObj.close();
+      }
+      else
+      {
+         error("findObjectInFiles() - File not able to be opened: " @ %file);  
+      }
+      
+      %file = findNextFileMultiExpr( "*.*" );
+   }
+
+   %fileObj.delete();
+   
+   return "";
+}
 //==============================================================================
 //Shape Importing
 //==============================================================================

From 252f1b65f37226c933297b6227faad4d9e480365 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Sun, 5 Sep 2021 14:54:41 -0500
Subject: [PATCH 051/399] followup to #531. fixes the same issue on mac

---
 Engine/source/platformMac/macFileIO.mm | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Engine/source/platformMac/macFileIO.mm b/Engine/source/platformMac/macFileIO.mm
index b2549e0f7..dae844163 100644
--- a/Engine/source/platformMac/macFileIO.mm
+++ b/Engine/source/platformMac/macFileIO.mm
@@ -911,7 +911,7 @@ static bool recurseDumpDirectories(const char *basePath, const char *subPath, Ve
 //-----------------------------------------------------------------------------
 bool Platform::dumpDirectories(const char *path, Vector<StringTableEntry> &directoryVector, S32 depth, bool noBasePath)
 {
-   bool retVal = recurseDumpDirectories(path, "", directoryVector, 0, depth, noBasePath);
+   bool retVal = recurseDumpDirectories(path, "", directoryVector, -1, depth, noBasePath);
    clearExcludedDirectories();
    return retVal;
 }

From 6439cb84d45aa953c4b1b0b6b0fbeb3eb804b040 Mon Sep 17 00:00:00 2001
From: Areloch <Areloch@gmail.com>
Date: Sun, 5 Sep 2021 23:47:11 -0500
Subject: [PATCH 052/399] Adds handling in project import to process
 SFXDescriptions and Profiles into assets and remove the redundant OG
 declarations

---
 .../pre40/T3Dpre4ProjectImporter.tscript      | 112 +++++++++---------
 .../scripts/projectImporter.tscript           |  38 +++++-
 2 files changed, 89 insertions(+), 61 deletions(-)

diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
index 4c6ede9fb..99099085e 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
@@ -1089,13 +1089,10 @@ function T3Dpre4ProjectImporter::processSFXProfileObject(%this, %file, %objectNa
    //Throw a warn that this file's already been claimed and move on
    if(%soundAsset !$= "")
    {
-      error("T3Dpre4ProjectImporter::processSFXProfileObject() - attempting to process SFXProfile " @ %objectName 
-               @ " but its filename is already associated to another sound asset.");
-      return false;
+      warn("T3Dpre4ProjectImporter::processSFXProfileObject() - attempting to process SFXProfile " @ %objectName 
+               @ " but its filename is already associated to another sound asset. Continuing, but be aware.");
    }  
-   //Otherwise, process it into an asset
-   else
-   {
+
       %assetName = %objectName;
    
       %moduleName = AssetBrowser.dirHandler.getModuleFromAddress(%soundFilename).ModuleId;
@@ -1142,29 +1139,46 @@ function T3Dpre4ProjectImporter::processSFXProfileObject(%this, %file, %objectNa
             %asset.isStreaming = %descriptionName.isStreaming;
          }
          else
+         {
+         %objFileFinder = "";
+         //first check our cache
+         if(isObject($ProjectImporter::SFXDescriptionCache) && 
+            $ProjectImporter::SFXDescriptionCache.getIndexFromKey(%descriptionName) !$= "")
+         {
+            %key = $ProjectImporter::SFXDescriptionCache.getIndexFromKey(%descriptionName);
+            %objFileFinder = $ProjectImporter::SFXDescriptionCache.getValue(%key);
+         }
+         else
          {
             %objFileFinder = findObjectInFiles(%descriptionName);
+         }
+         
             if(%objFileFinder !$= "")
             {
                %valueArray = new ArrayObject();
                
-               %valueArray.add("sourceGroup" SPC findObjectField("sourceGroup", %objFileFinder));
-               %valueArray.add("volume" SPC findObjectField("volume", %objFileFinder));
-               %valueArray.add("pitch" SPC findObjectField("pitch", %objFileFinder));
-               %valueArray.add("isLooping" SPC findObjectField("isLooping", %objFileFinder));
-               %valueArray.add("priority" SPC findObjectField("priority", %objFileFinder));
-               %valueArray.add("useHardware" SPC findObjectField("useHardware", %objFileFinder));
-               %valueArray.add("is3D" SPC findObjectField("is3D", %objFileFinder));
-               %valueArray.add("minDistance" SPC findObjectField("minDistance", %objFileFinder));
-               %valueArray.add("maxDistance" SPC findObjectField("maxDistance", %objFileFinder));
-               %valueArray.add("scatterDistance" SPC findObjectField("scatterDistance", %objFileFinder));
-               %valueArray.add("coneInsideAngle" SPC findObjectField("coneInsideAngle", %objFileFinder));
-               %valueArray.add("coneOutsideAngle" SPC findObjectField("coneOutsideAngle", %objFileFinder));
-               %valueArray.add("coneOutsideVolume" SPC findObjectField("coneOutsideVolume", %objFileFinder));
-               %valueArray.add("rolloffFactor" SPC findObjectField("rolloffFactor", %objFileFinder));
-               %valueArray.add("isStreaming" SPC findObjectField("isStreaming", %objFileFinder));
+            %fileObj = getField(%objFileFinder, 0);
                
-               %objFileFinder.delete();
+            %valueArray.add("sourceGroup" SPC findObjectField("sourceGroup", %fileObj));
+            %valueArray.add("volume" SPC findObjectField("volume", %fileObj));
+            %valueArray.add("pitch" SPC findObjectField("pitch", %fileObj));
+            %valueArray.add("isLooping" SPC findObjectField("isLooping", %fileObj));
+            %valueArray.add("priority" SPC findObjectField("priority", %fileObj));
+            %valueArray.add("useHardware" SPC findObjectField("useHardware", %fileObj));
+            %valueArray.add("is3D" SPC findObjectField("is3D", %fileObj));
+            %valueArray.add("minDistance" SPC findObjectField("minDistance", %fileObj));
+            %valueArray.add("maxDistance" SPC findObjectField("maxDistance", %fileObj));
+            %valueArray.add("scatterDistance" SPC findObjectField("scatterDistance", %fileObj));
+            %valueArray.add("coneInsideAngle" SPC findObjectField("coneInsideAngle", %fileObj));
+            %valueArray.add("coneOutsideAngle" SPC findObjectField("coneOutsideAngle", %fileObj));
+            %valueArray.add("coneOutsideVolume" SPC findObjectField("coneOutsideVolume", %fileObj));
+            %valueArray.add("rolloffFactor" SPC findObjectField("rolloffFactor", %fileObj));
+            %valueArray.add("isStreaming" SPC findObjectField("isStreaming", %fileObj));
+            
+            if(isObject($ProjectImporter::SFXDescriptionCache))
+            {
+               $ProjectImporter::SFXDescriptionCache.add(%descriptionName, %objFileFinder);
+            }
                
                for(%v=0; %v < %valueArray.Count(); %v++)
                {
@@ -1175,6 +1189,8 @@ function T3Dpre4ProjectImporter::processSFXProfileObject(%this, %file, %objectNa
                   if(%varVal !$= "")
                      %asset.setFieldValue(%var, %varVal);
                }
+            
+            %valueArray.delete();
             }
          }
       }
@@ -1186,51 +1202,31 @@ function T3Dpre4ProjectImporter::processSFXProfileObject(%this, %file, %objectNa
       
       if(!%success)
          return false;
-   }
    
    //Now mark the original SFXProfile for removal from the file as it's redundant
    //now that we have the asset def
-   
-   /*if(%matAsset $= "" || %matAsset $= "Core_Rendering:NoMaterial")
-   {
-      %assetName = %objectName;
-   
-      %moduleName = AssetBrowser.dirHandler.getModuleFromAddress(%file).ModuleId;
-      
-      %assetPath = filePath(%file) @ "/";   
-      
-      %tamlpath = %assetPath @ %assetName @ ".asset.taml";
-      
-      if(isFile(%tamlpath))
-      {
-         error("T3Dpre4ProjectImporter::processMaterialObject() - Failed to create as taml file already exists: " @ %file);
-         return false;
-      }
-      
-      %asset = new MaterialAsset()
-      {
-         AssetName = %assetName;
-         versionId = 1;
-         shaderData = "";
-         materialDefinitionName = %assetName;
-         scriptFile = fileBase(%file);
-      };
-      
-      TamlWrite(%asset, %tamlpath);
-      
-      %moduleDef = ModuleDatabase.findModule(%moduleName, 1);
-      %success = AssetDatabase.addDeclaredAsset(%moduleDef, %tamlpath);
-      
-      if(!%success)
-         return false;
-   }*/
+   $ProjectImporter::ToRemoveObjectList.add(%objectName, %file TAB 0);
    
    return true;
 }
 
 function T3Dpre4ProjectImporter::processAudioProfileObject(%this, %file, %objectName)
-{
+   {
    return %this.processSFXProfileObject(%file, %objectName);
+      }
+      
+function T3Dpre4ProjectImporter::processSFXDescriptionObject(%this, %file, %objectName)
+      {
+   $ProjectImporter::ToRemoveObjectList.add(%objectName, %file TAB 0);
+   
+   return true;
+}
+
+function T3Dpre4ProjectImporter::processAudioDescriptionObject(%this, %file, %objectName)
+{
+   $ProjectImporter::ToRemoveObjectList.add(%objectName, %file TAB 0);
+   
+   return true;
 }
 
 //==============================================================================
diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
index d49e4eac4..a28233596 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
@@ -166,6 +166,16 @@ function ProjectImportWizardPage2::openPage(%this)
       $ProjectImporter::importTool.delete();
       
    $ProjectImporter::importTool = new ScriptObject($ProjectImporter::versionMode @ "Importer");
+   
+   if(isObject($ProjectImporter::SFXDescriptionCache))
+      $ProjectImporter::SFXDescriptionCache.delete();
+      
+   $ProjectImporter::SFXDescriptionCache = new ArrayObject();
+   
+   if(isObject($ProjectImporter::ToRemoveObjectList))
+      $ProjectImporter::ToRemoveObjectList.delete();
+      
+   $ProjectImporter::ToRemoveObjectList = new ArrayObject();
 }
 
 function ProjectImportWizardPage2::processPage(%this)
@@ -312,6 +322,28 @@ function ProjectImportWizardPage6::openPage(%this)
    {
       $ProjectImporter::importTool.processScriptExtensions();
    }
+   
+   //All good? now go through and wipe any objects flagged in our files for deletion
+   %objRemovePM = new PersistenceManager();
+   
+   for(%o = 0; %o < $ProjectImporter::ToRemoveObjectList.count(); %o++)
+   {
+      %name = $ProjectImporter::ToRemoveObjectList.getKey(%o);
+      %file = getField($ProjectImporter::ToRemoveObjectList.getValue(%o),0);
+      
+      if(%name !$= "" && isFile(%file))
+      {
+         if(!isObject(%name))
+         {
+            //spoof it
+            %tmpObj = new SimObject(%name); 
+            %objRemovePM.setDirty(%name, %file);
+         }
+         %objRemovePM.removeObjectFromFile(%name, %file);
+         
+         %tmpObj.delete();
+      }      
+   }
 }
 
 function ProjectImportWizardPage6::processPage(%this)
@@ -758,7 +790,7 @@ function findObjectInFiles(%objectName)
                
                if(%objectName $= %objName)
                {
-                  return %fileObj;
+                  return %fileObj TAB %file TAB %lineNum;
                }
             }
             else if(strIsMatchExpr("*datablock*(*)*", %line) && strpos(%line, "::") == -1)
@@ -770,7 +802,7 @@ function findObjectInFiles(%objectName)
                
                if(%objectName $= %objName)
                {
-                  return %fileObj;
+                  return %fileObj TAB %file TAB %lineNum;
                }
             }
             else if(strIsMatchExpr("*singleton*(*)*", %line) && strpos(%line, "::") == -1)
@@ -782,7 +814,7 @@ function findObjectInFiles(%objectName)
                
                if(%objectName $= %objName)
                {
-                  return %fileObj;
+                  return %fileObj TAB %file TAB %lineNum;
                }
             }
             

From 55c0a748b4b7db093c50e0599dd104bee71fca85 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Tue, 7 Sep 2021 19:43:39 -0400
Subject: [PATCH 053/399] Don't generate op_inc whenever its used as an
 expression.

---
 Engine/source/console/astNodes.cpp        |  2 +-
 Engine/source/console/test/ScriptTest.cpp | 14 ++++++++++++++
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/Engine/source/console/astNodes.cpp b/Engine/source/console/astNodes.cpp
index 1ee165272..091f6cf1c 100644
--- a/Engine/source/console/astNodes.cpp
+++ b/Engine/source/console/astNodes.cpp
@@ -1083,7 +1083,7 @@ U32 AssignOpExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 
    bool oldVariables = arrayIndex || varName[0] == '$';
 
-   if (op == opPLUSPLUS && !oldVariables)
+   if (op == opPLUSPLUS && !oldVariables && type == TypeReqNone)
    {
       const S32 varIdx = getFuncVars(dbgLineNumber)->assign(varName, TypeReqFloat, dbgLineNumber);
 
diff --git a/Engine/source/console/test/ScriptTest.cpp b/Engine/source/console/test/ScriptTest.cpp
index a2295f774..24905aba3 100644
--- a/Engine/source/console/test/ScriptTest.cpp
+++ b/Engine/source/console/test/ScriptTest.cpp
@@ -968,6 +968,20 @@ TEST(Script, MiscRegressions)
    )");
    
    ASSERT_EQ(regression4.getFloat(), 0.5);
+
+   Con::setBoolVariable("$Debug::DumpByteCode", true);
+
+   ConsoleValue regression5 = RunScript(R"(
+      function noOpInc()
+      {
+         %count = 0;
+         %var[%count++] = 2;
+         return %var[1];
+      }
+      return noOpInc();
+   )");
+
+   ASSERT_EQ(regression5.getInt(), 2);
 }
 
 #endif

From 6d93e96dc3dbd31458cf90db0f35a5dea82e08bd Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Tue, 7 Sep 2021 21:03:57 -0400
Subject: [PATCH 054/399] NULL out an object variable if it fails to register.

---
 Engine/source/console/compiledEval.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index 378afd290..a18729fd4 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -1087,6 +1087,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
                // This error is usually caused by failing to call Parent::initPersistFields in the class' initPersistFields().
                Con::warnf(ConsoleLogEntry::General, "%s: Register object failed for object %s of class %s.", getFileLine(ip - 2), currentNewObject->getName(), currentNewObject->getClassName());
                delete currentNewObject;
+               currentNewObject = NULL;
                ip = failJump;
                break;
             }

From 27a4868b6ed203a4e5d0489262056e7fc5d08370 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Tue, 7 Sep 2021 21:52:36 -0400
Subject: [PATCH 055/399] Fix buffer corruption.

---
 Engine/source/T3D/gameBase/gameConnection.cpp | 9 ++++++---
 Engine/source/console/consoleFunctions.cpp    | 3 ++-
 Engine/source/console/simObject.cpp           | 3 ++-
 Engine/source/gui/editor/popupMenu.cpp        | 6 ++++--
 4 files changed, 14 insertions(+), 7 deletions(-)

diff --git a/Engine/source/T3D/gameBase/gameConnection.cpp b/Engine/source/T3D/gameBase/gameConnection.cpp
index ed5c691e5..09cfa13cf 100644
--- a/Engine/source/T3D/gameBase/gameConnection.cpp
+++ b/Engine/source/T3D/gameBase/gameConnection.cpp
@@ -512,10 +512,13 @@ bool GameConnection::readConnectRequest(BitStream *stream, const char **errorStr
    connectArgv[2].setString(buffer);
 
    // NOTE: Cannot convert over to IMPLEMENT_CALLBACK as it has variable args.
-   const char *ret = Con::execute(this, mConnectArgc + 3, connectArgv);
-   if(ret[0])
+   ConsoleValue returnValue = Con::execute(this, mConnectArgc + 3, connectArgv);
+
+   StringTableEntry returnStr = StringTable->insert(returnValue.getString());
+
+   if(returnStr[0])
    {
-      *errorString = ret;
+      *errorString = returnStr;
       return false;
    }
    return true;
diff --git a/Engine/source/console/consoleFunctions.cpp b/Engine/source/console/consoleFunctions.cpp
index d0eccde40..9a57c31c1 100644
--- a/Engine/source/console/consoleFunctions.cpp
+++ b/Engine/source/console/consoleFunctions.cpp
@@ -2286,7 +2286,8 @@ DefineEngineStringlyVariadicFunction( call, const char *, 2, 0, "( string functi
    "@endtsexample\n\n"
    "@ingroup Scripting" )
 {
-   return Con::execute( argc - 1, argv + 1 );
+   ConsoleValue returnValue = Con::execute(argc - 1, argv + 1);
+   return Con::getReturnBuffer(returnValue.getString());
 }
 
 //-----------------------------------------------------------------------------
diff --git a/Engine/source/console/simObject.cpp b/Engine/source/console/simObject.cpp
index d727e2403..e9cae8130 100644
--- a/Engine/source/console/simObject.cpp
+++ b/Engine/source/console/simObject.cpp
@@ -2972,7 +2972,8 @@ DefineEngineStringlyVariadicMethod( SimObject, call, const char*, 3, 0, "( strin
    "@return The result of the method call." )
 {
    argv[1].setString(argv[2]);
-   return Con::execute( object, argc - 1, argv + 1 );
+   ConsoleValue returnValue = Con::execute(object, argc - 1, argv + 1);
+   return Con::getReturnBuffer(returnValue.getString());
 }
 
 //-----------------------------------------------------------------------------
diff --git a/Engine/source/gui/editor/popupMenu.cpp b/Engine/source/gui/editor/popupMenu.cpp
index 2f250ece7..14fff6844 100644
--- a/Engine/source/gui/editor/popupMenu.cpp
+++ b/Engine/source/gui/editor/popupMenu.cpp
@@ -120,12 +120,14 @@ void PopupMenu::handleSelectEvent(U32 popID, U32 command)
 //-----------------------------------------------------------------------------
 bool PopupMenu::onMessageReceived(StringTableEntry queue, const char* event, const char* data)
 {
-   return Con::executef(this, "onMessageReceived", queue, event, data);
+   ConsoleValue returnValue = Con::executef(this, "onMessageReceived", queue, event, data);
+   return returnValue.getBool();
 }
 
 bool PopupMenu::onMessageObjectReceived(StringTableEntry queue, Message *msg )
 {
-   return Con::executef(this, "onMessageReceived", queue, Con::getIntArg(msg->getId()));
+   ConsoleValue returnValue = Con::executef(this, "onMessageReceived", queue, Con::getIntArg(msg->getId()));
+   return returnValue.getBool();
 }
 
 //////////////////////////////////////////////////////////////////////////

From c285813540da06896685263b4cdb4af691b3c380 Mon Sep 17 00:00:00 2001
From: Marc <blood.bks@gmail.com>
Date: Wed, 8 Sep 2021 15:18:04 +0100
Subject: [PATCH 056/399] replace new with singletone to fix cannot re-declare
 object lof file spam

---
 .../scripts/advancedLighting_Shaders.tscript         | 12 ++++++------
 .../scripts/gfxData/warningTerrainMat.tscript        |  2 +-
 .../templateFiles/terrainMaterial.tscript.template   |  2 +-
 .../worldEditor/scripts/visibility/shadowViz.tscript |  2 +-
 4 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/Templates/BaseGame/game/core/lighting/scripts/advancedLighting_Shaders.tscript b/Templates/BaseGame/game/core/lighting/scripts/advancedLighting_Shaders.tscript
index f7bdf56f9..55100d729 100644
--- a/Templates/BaseGame/game/core/lighting/scripts/advancedLighting_Shaders.tscript
+++ b/Templates/BaseGame/game/core/lighting/scripts/advancedLighting_Shaders.tscript
@@ -75,7 +75,7 @@ singleton shaderData( AL_VectorLightShader )
    pixVersion = 3.0;
 };
 
-new CustomMaterial( AL_VectorLightMaterial )
+singleton CustomMaterial( AL_VectorLightMaterial )
 {
    shader = AL_VectorLightShader;
    stateBlock = AL_VectorLightState;
@@ -149,7 +149,7 @@ singleton shaderData( AL_PointLightShader )
    pixVersion = 3.0;
 };
 
-new CustomMaterial( AL_PointLightMaterial )
+singleton CustomMaterial( AL_PointLightMaterial )
 {
    shader = AL_PointLightShader;
    stateBlock = AL_ConvexLightState;
@@ -186,7 +186,7 @@ singleton shaderData( AL_SpotLightShader )
    pixVersion = 3.0;
 };
 
-new CustomMaterial( AL_SpotLightMaterial )
+singleton CustomMaterial( AL_SpotLightMaterial )
 {
    shader = AL_SpotLightShader;
    stateBlock = AL_ConvexLightState;
@@ -205,7 +205,7 @@ new CustomMaterial( AL_SpotLightMaterial )
 
 /// This material is used for generating deferred 
 /// materials for objects that do not have materials.
-new Material( AL_DefaultDeferredMaterial )
+singleton Material( AL_DefaultDeferredMaterial )
 {
    // We need something in the first pass else it 
    // won't create a proper material instance.  
@@ -219,7 +219,7 @@ new Material( AL_DefaultDeferredMaterial )
 
 /// This material is used for generating shadow 
 /// materials for objects that do not have materials.
-new Material( AL_DefaultShadowMaterial )
+singleton Material( AL_DefaultShadowMaterial )
 {
    // We need something in the first pass else it 
    // won't create a proper material instance.  
@@ -255,7 +255,7 @@ singleton shaderData( AL_ParticlePointLightShader )
    pixVersion = 3.0;
 };
 
-new CustomMaterial( AL_ParticlePointLightMaterial )
+singleton CustomMaterial( AL_ParticlePointLightMaterial )
 {
    shader = AL_ParticlePointLightShader;
    stateBlock = AL_ConvexLightState;
diff --git a/Templates/BaseGame/game/core/rendering/scripts/gfxData/warningTerrainMat.tscript b/Templates/BaseGame/game/core/rendering/scripts/gfxData/warningTerrainMat.tscript
index 55b8562ac..f528e285a 100644
--- a/Templates/BaseGame/game/core/rendering/scripts/gfxData/warningTerrainMat.tscript
+++ b/Templates/BaseGame/game/core/rendering/scripts/gfxData/warningTerrainMat.tscript
@@ -1,4 +1,4 @@
-new TerrainMaterial()
+singleton TerrainMaterial()
 {
    diffuseSize = "200";
    detailSize = "10";
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/templateFiles/terrainMaterial.tscript.template b/Templates/BaseGame/game/tools/assetBrowser/scripts/templateFiles/terrainMaterial.tscript.template
index ef614edaf..ee54d964a 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/templateFiles/terrainMaterial.tscript.template
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/templateFiles/terrainMaterial.tscript.template
@@ -11,7 +11,7 @@ singleton Material(TerrainFX_@)
    impactSoundId = "0";
 };
 
-new TerrainMaterial(@)
+singleton TerrainMaterial(@)
 {
    internalName = "@";
    diffuseMap = "";
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/visibility/shadowViz.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/visibility/shadowViz.tscript
index bb07ba596..92cd4a6e5 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/visibility/shadowViz.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/visibility/shadowViz.tscript
@@ -34,7 +34,7 @@ singleton shaderData( AL_ShadowVisualizeShader )
    pixVersion = 2.0;
 };
 
-new CustomMaterial( AL_ShadowVisualizeMaterial )
+singleton CustomMaterial( AL_ShadowVisualizeMaterial )
 {
    shader = AL_ShadowVisualizeShader;
    stateBlock = AL_DepthVisualizeState;

From 3d488bbbf0eae8954999e8631f4376eb81ca9566 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Thu, 9 Sep 2021 13:29:31 -0500
Subject: [PATCH 057/399] macro cleanup

---
 Engine/source/T3D/assets/ImageAsset.h    | 4 ++--
 Engine/source/T3D/assets/MaterialAsset.h | 2 +-
 Engine/source/T3D/assets/ShapeAsset.h    | 4 ++--
 Engine/source/T3D/assets/SoundAsset.h    | 2 +-
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/Engine/source/T3D/assets/ImageAsset.h b/Engine/source/T3D/assets/ImageAsset.h
index 241cae7b6..ff50ef655 100644
--- a/Engine/source/T3D/assets/ImageAsset.h
+++ b/Engine/source/T3D/assets/ImageAsset.h
@@ -248,7 +248,7 @@ public: \
          Con::errorf("%s(%s)::_set%s() - image asset failure\"%s\" due to [%s]", macroText(className), getName(), macroText(name), _in, ImageAsset::getAssetErrstrn(m##name##Asset->getStatus()).c_str());\
          return false; \
       }\
-      else if (m##name)\
+      else if (!m##name)\
       {\
          Con::errorf("%s(%s)::_set%s() - Couldn't load image \"%s\"", macroText(className), getName(), macroText(name), _in);\
          return false;\
@@ -467,7 +467,7 @@ public: \
          Con::errorf("%s(%s)::_set%s(%i) - image asset failure\"%s\" due to [%s]", macroText(className), getName(), macroText(name), index, _in, ImageAsset::getAssetErrstrn(m##name##Asset[index]->getStatus()).c_str());\
          return false; \
       }\
-      else if (bool(m##name[index]) == NULL)\
+      else if (!m##name[index])\
       {\
          Con::errorf("%s(%s)::_set%s(%i) - Couldn't load image \"%s\"", macroText(className), getName(), macroText(name), index, _in);\
          return false; \
diff --git a/Engine/source/T3D/assets/MaterialAsset.h b/Engine/source/T3D/assets/MaterialAsset.h
index e046b31bd..018e2a989 100644
--- a/Engine/source/T3D/assets/MaterialAsset.h
+++ b/Engine/source/T3D/assets/MaterialAsset.h
@@ -231,7 +231,7 @@ public: \
          Con::errorf("%s::_set%s() - material asset failure\"%s\" due to [%s]", macroText(className), macroText(name), _in, MaterialAsset::getAssetErrstrn(m##name##Asset->getStatus()).c_str());\
          return false; \
       }\
-      else if (m##name)\
+      else if (!m##name)\
       {\
          Con::errorf("%s::_set%s() - Couldn't load material \"%s\"", macroText(className), macroText(name), _in);\
          return false;\
diff --git a/Engine/source/T3D/assets/ShapeAsset.h b/Engine/source/T3D/assets/ShapeAsset.h
index b5bc0a97a..d5c899564 100644
--- a/Engine/source/T3D/assets/ShapeAsset.h
+++ b/Engine/source/T3D/assets/ShapeAsset.h
@@ -299,7 +299,7 @@ public: \
          Con::errorf("%s(%s)::_set%s() - shape asset failure \"%s\" due to [%s]", macroText(className), getName(), macroText(name), _in, ShapeAsset::getAssetErrstrn(m##name##Asset->getStatus()).c_str());\
          return false; \
       }\
-      else if (m##name)\
+      else if (!m##name)\
       {\
          Con::errorf("%s(%s)::_set%s() - Couldn't load shape \"%s\"", macroText(className), getName(), macroText(name), _in);\
          return false;\
@@ -495,7 +495,7 @@ public: \
          Con::errorf("%s(%s)::_set%s(%i) - shape asset failure \"%s\" due to [%s]", macroText(className), getName(), macroText(name), index, _in, ShapeAsset::getAssetErrstrn(m##name##Asset[index]->getStatus()).c_str());\
          return false; \
       }\
-      else if (bool(m##name[index]) == NULL)\
+      else if (!m##name[index])\
       {\
          Con::errorf("%s(%s)::_set%s(%i) - Couldn't load shape \"%s\"", macroText(className), getName(), macroText(name), index, _in);\
          return false; \
diff --git a/Engine/source/T3D/assets/SoundAsset.h b/Engine/source/T3D/assets/SoundAsset.h
index 321c461b4..710652830 100644
--- a/Engine/source/T3D/assets/SoundAsset.h
+++ b/Engine/source/T3D/assets/SoundAsset.h
@@ -240,7 +240,7 @@ public: \
          Con::errorf("%s(%s)::_set%s() - sound asset failure\"%s\" due to [%s]", macroText(className), getName(), macroText(name), _in, SoundAsset::getAssetErrstrn(m##name##Asset->getStatus()).c_str());\
          return false; \
       }\
-      else if (m##name)\
+      else if (!m##name)\
       {\
          Con::errorf("%s(%s)::_set%s() - Couldn't load sound \"%s\"", macroText(className), getName(), macroText(name), _in);\
          return false;\

From 35b33f186429ad9f39358531e0361a9ead44e7e2 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Thu, 9 Sep 2021 19:30:32 -0400
Subject: [PATCH 058/399] various fixes and memory corruption bug.

---
 Engine/source/cinterface/cinterface.cpp   |  4 ++--
 Engine/source/console/console.cpp         |  7 +++---
 Engine/source/console/simObject.cpp       |  3 ++-
 Engine/source/console/test/ScriptTest.cpp | 29 +++++++++++++++++++++--
 4 files changed, 35 insertions(+), 8 deletions(-)

diff --git a/Engine/source/cinterface/cinterface.cpp b/Engine/source/cinterface/cinterface.cpp
index e62db2c91..3cd717c13 100644
--- a/Engine/source/cinterface/cinterface.cpp
+++ b/Engine/source/cinterface/cinterface.cpp
@@ -55,7 +55,7 @@ bool CInterface::_isMethod(const char* className, const char* methodName) const
    if (mIsMethodCallback)
       return mIsMethodCallback(className, methodName);
 
-   return NULL;
+   return false;
 }
 
 const char* CInterface::_CallFunction(const char* nameSpace, const char* name, const char **argv, int argc, bool *result) const
@@ -93,4 +93,4 @@ TORQUE_API void SetCallbacks(void* ptr, void* methodPtr, void* isMethodPtr, void
    CInterface::GetCInterface().SetCallMethodCallback(methodPtr);
    CInterface::GetCInterface().SetCallIsMethodCallback(isMethodPtr);
    CInterface::GetCInterface().SetMainCallback(mainPtr);
-}
\ No newline at end of file
+}
diff --git a/Engine/source/console/console.cpp b/Engine/source/console/console.cpp
index 399298864..ab93d554e 100644
--- a/Engine/source/console/console.cpp
+++ b/Engine/source/console/console.cpp
@@ -1643,13 +1643,13 @@ static ConsoleValue _internalExecute(SimObject *object, S32 argc, ConsoleValue a
    {
       ConsoleValue val;
       val.setString(methodRes);
-      return std::move(val);
+      return val;
    }
 
    if(object->getNamespace())
    {
       U32 ident = object->getId();
-      const char* oldIdent = argv[1].getString();
+      const char* oldIdent = dStrdup(argv[1].getString());
       
       Namespace::Entry *ent = object->getNamespace()->lookup(funcName);
 
@@ -1671,8 +1671,9 @@ static ConsoleValue _internalExecute(SimObject *object, S32 argc, ConsoleValue a
 
       // Twiddle it back
       argv[1].setString(oldIdent);
+      dFree(oldIdent);
 
-      return std::move(ret);
+      return ret;
    }
 
    warnf(ConsoleLogEntry::Script, "Con::execute - %d has no namespace: %s", object->getId(), funcName);
diff --git a/Engine/source/console/simObject.cpp b/Engine/source/console/simObject.cpp
index e9cae8130..6b54bdd1d 100644
--- a/Engine/source/console/simObject.cpp
+++ b/Engine/source/console/simObject.cpp
@@ -2971,7 +2971,8 @@ DefineEngineStringlyVariadicMethod( SimObject, call, const char*, 3, 0, "( strin
    "@param args Zero or more arguments for the method.\n"
    "@return The result of the method call." )
 {
-   argv[1].setString(argv[2]);
+   argv[1].setString(argv[2].getString());
+
    ConsoleValue returnValue = Con::execute(object, argc - 1, argv + 1);
    return Con::getReturnBuffer(returnValue.getString());
 }
diff --git a/Engine/source/console/test/ScriptTest.cpp b/Engine/source/console/test/ScriptTest.cpp
index 24905aba3..05775694f 100644
--- a/Engine/source/console/test/ScriptTest.cpp
+++ b/Engine/source/console/test/ScriptTest.cpp
@@ -969,8 +969,6 @@ TEST(Script, MiscRegressions)
    
    ASSERT_EQ(regression4.getFloat(), 0.5);
 
-   Con::setBoolVariable("$Debug::DumpByteCode", true);
-
    ConsoleValue regression5 = RunScript(R"(
       function noOpInc()
       {
@@ -982,6 +980,33 @@ TEST(Script, MiscRegressions)
    )");
 
    ASSERT_EQ(regression5.getInt(), 2);
+
+   ConsoleValue regression6 = RunScript(R"(
+      function SimObject::crashMe(%this, %line)
+      {
+         return %line @ "1";
+      }
+
+      function doTest()
+      {
+         %obj = new SimObject();
+         for (%i = 0; %i < 99999; %i++)
+         {
+            %function = "crashMe";
+            if (%obj.isMethod(%function))
+            {
+               %line = "abcdefg";
+               %output = %obj.call(%function, %line); 
+            }
+         }
+
+         return true;
+      }
+
+      return doTest();
+   )");
+
+   ASSERT_EQ(regression6.getBool(), true);
 }
 
 #endif

From e4d16a8c61bdad523d3ce888c582e9a7e1eac1ac Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Thu, 9 Sep 2021 18:33:03 -0500
Subject: [PATCH 059/399] (re) add collision yo noshape.dts set all
 rigidshapedatas to default to noshape instead of blank to fix the lack of a
 basic collision mesh blocking datablock creation

---
 Engine/source/T3D/rigidShape.cpp              |   1 +
 .../game/core/rendering/shapes/noshape.dts    | Bin 18389 -> 14146 bytes
 2 files changed, 1 insertion(+)

diff --git a/Engine/source/T3D/rigidShape.cpp b/Engine/source/T3D/rigidShape.cpp
index 8eeaffb3f..cf26f8ea9 100644
--- a/Engine/source/T3D/rigidShape.cpp
+++ b/Engine/source/T3D/rigidShape.cpp
@@ -263,6 +263,7 @@ RigidShapeData::RigidShapeData()
 
    dustTrailEmitter = NULL;
    dustTrailID = 0;
+   _setShape(ShapeAsset::smNoShapeAssetFallback);
 }
 
 RigidShapeData::~RigidShapeData()
diff --git a/Templates/BaseGame/game/core/rendering/shapes/noshape.dts b/Templates/BaseGame/game/core/rendering/shapes/noshape.dts
index a7a64cf1099e4247aecded23bec3923eb6e3a198..81720460ca6d1a7a09297d14fb557284448412fe 100644
GIT binary patch
literal 14146
zcma)DX_OSz6)v`6*f$*|1Bjv^2^w&~EKFCmxJFS3DxyggWKm>bP!L6lG%hh{j0lPX
zqDGS#h!Ml0QM<b)8cmoC=t+>oW6Y)@o~SvAnm_81eBXWdy?IsDJz9r5x9iqdx9+>k
zd$(RULxL5-(|v+qSLYyj5rlt2U_mGT>EIyN9{k(|R0Hzm;||%IBUv2zy$9Endj4TV
zksOr6=SFh-yn{ISnVg6H%zKUG;6ZDry~koG?+PNf*Q^fO$7|g{{$Xvlc6awLrasr=
zya%YK$O}>X<@V3LAnXl-Tg4~sm>?eng_!h^Crp2|_8I#Pp7&5^wWBXC6uw}t_5<U+
z)+h9H;Q1S$#oq><{QELa$0kK`W_|fr^I<r-?_+}KU&_dN(AU=Al+kzeE&WZRAFV%m
zPM?zKKVBo}Imd1NNg4ghbB>wB@lr<4^ZrT$R7OtOK&3(8l#x?*h|-}dBd4rR=`e80
zJ_i~MI$Wt<W#p6%Q5p(P898Ocl#WmtIc39@js&NSd^qSRr4itikyCcG(lIJK7JL+F
zq|#_`%E&4Eyb{xbvg1L=fyRIs<1d1EjhyG>K;uCTpc6nRf+(Ay^d*&%Q}$)0uYglV
zPT5zLCaR2_vPLCN29%Lg7Ai$5Bd08{bP_ma<ay8}rIW!aBd6>XrBhXQ2Kecq(?Dl}
zz6Rnoa-N?BItO$%XfkLjh_We4UsoA9Wz&?-1*eRhvh$SAR~b2F)0Hj&r;MDk8A=zb
zjGVHIl)eE@*~Or5fxfA9iOR?+o2fJloHFv6pi7lzgHuLM*&L<0DkG<Cp3-IDl#x?*
zxzc=<kyCbs(gJYG$SG@5TBtH|$`&a#gHuLM*<z(DRYp$PRZ2_1DI=$BsnXRdBd2Vc
z(ly|ekyCc9(sGrNQ+A!w_286|Q?^3s+bScc>;|Qk;FOV5R!~|6P8oRtbfeNu;FOV5
zcC*qgD*G<@t)TBHtp=xzoU+@LZdVyOW#3b}1DrB)%D%63r^?7FTcdOrIA!FNtyNm5
zvi0EifbIru0Nn?=7j!>p6KJE-W|fgs_JGoZ;FOV5_K?yKz$qht2=uVhBjA*gQ}#op
zAE}I-vL7ow3Qie0Wj|5cqB3&IwkrJ;oHBCC9#i_6%ANq<26`N{1GF9VbI_BZU7(#x
zPpOQYvR^1Y4Ne(3WzQ%*tFkh92~-6A64U~ULB9e$4|)#tYtW0J7eK9`-Jstn{Z?gr
z!S{gLlwJa-jK|A{$@<n+KMw%!q{QBb>wl$wOX2Nolv&5dwoBY6>f>=V2%m?OcQ&8#
z*Ys3;eiu+Js5__z)C<%T)C1HP)CbfXL>v2q`hlo>AczNb3<6OPbsPes9_lz0L_O3|
z2cjP8I1EHRJPtQZ^idD*=My?ZV^?&3HKLWWgDd%$ycSw}!qVQ*+*dnHu894heE>8K
zqLxmbyL9bV)4jGw&tARz^j$P^lC)I0sVf>$^zozXkBWxg8^%kXpH{x?qC3Op9e*tT
zd+XIv+%`GKhkWwkS%T+h;)jp_LiEk^LS{p-F4~rx^2p}g^2s+uJm;Z!=;q<@a$WJI
zc6=dJdm2;rM6~C<QICad%dZyiKe$-!DTH?pI7aNbq2@ng|LZrlG(OQ|X*~VJjphEi
z55f!UZY*Ct`-14#ZEa$|;u|ggFIV22>vdh<xL2?9;`ojUQT@Ap<JJX#3JtyxirHv6
zF%I0%78Xku#*1;s$G@~PTC?c)#nbz|&1VZ1b{E;AVjP11-NNsOL+h8uwQsyr+TM0m
zbmX5_g>P(~6u#It*~d3p{QJO9uU{JFfB#NtEATb1uPXQ0V)4$N#*{q~?HL1m_QRgF
zecmn_dkUfW(X)qsWPB0l_+7+xD&jl;qC3kQH*B!>G_tL>_9#9gelz_34E+DUQI9FU
z5Q-n6AAXhb7NXtdsY}B6@)<qj|DJko^p`PzDAv#KA2&4Y5dDg8OyMKqJKc0<G;QcB
z#T%CmQM|-AM}OLQ5l8)e4se3Uees^QHqkG7VSfrA5f3}W9@wRL$v4sO<y&m?AL9)7
zV!Rl4Ja66s(Jy|1{uEyF6MhWoPxw{wg;3%I`z4P|{>QdnnvgfU5HI8r^Ga$$@yI70
zQZK~IHQ<X$e8PUlT;i(shnFL+7pgsb+Iou)&wd|I`@;_q*PS|EgHQNh@Tjk%)>nx7
zDr<ek8#fFV{ht2?kNPTUeMP9RSnCV<L%hpp)>n!4bJSX25&gpPa@=T`MZcHNf=7Lo
zwZ3wwuXs4>>&>l`$_)(-KA!n3c+^)}>npbf_-?4Lo?9&5*~9ws?O}cS_B0xMq`qvu
z3!Z+|`ihtb^grSd?rEEB?IGUTqj=U=#5|+_5eLOfeTjbfRrDi|L#?lfdHjN@uV~|j
z3q?QjUi7E%tgk3Qovb$XrTE1BDe)ps>nmJ^I$R7q?u+Kln<x53uc<E|&-w~k=d_1)
zZ}4tDFCuP&_tuw?^9bh?&MOTKOGLlK$<&vRm;ChdS@BX|RoA1n(YDgmM>gyFVzxCT
zuF%gs)B582CC^s8u3yAE`(3^3eS+`TX@$%QR}H_`tw(A7K7QciLj`}ydn@FA>enp|
zXOE8`_3;scAOD)g2ho~+t2y4r>o41ZdrZB6i@x2Xw+lWB?D`l)Uc55+K3{!H@Iyw;
z(e<$q&fIZ@=>OTA&*#$m|2DTyp0j=Q6uX|9ad`ez`(yGh{iewEO}Eu?e!#O_zPb6i
z8s4tIRqV;=*Y!Pu-C{rP%h=zwZPP?PZ_>e)$bZ@sRI^{?S-h)vw?3-<g5USVW9+tZ
z6e6>}7s6`xJkwG;{)p4&L?7ID&5q73{|v1?h^y2u;+(KQjo1DmlDdNbWnTC4p)x)(
zza{k3>i;&clyN-y)UCWG@v3GI@h56t9*aD+_E66J<ThwJf4<ae^uPWunajlgI-h6k
zr<%p6EAm4-t#JK@<URDK{X<+Hc~8D~^mfGuQM%vYb;gH(XWTbK_}j~BUB4lD5B-($
zXWZ^H1i$U2VTzaf%5l85-=JQr{}-(z1izwuit9H-FYuM>tGuU=;7=cMzU^lsZ@tdc
z@2yiy^kJ~zwS}(V5WhfwrTL-duGNC?wtku7g9!7L*iSv_c)cijAbAnvB5afSsw)0z
zi7U3yT3tWm+h0uUAB4E_sfaVi%l@PgdiH1Vdk|ORF~2E3;r|RC^PAu?zj6K%{ht3z
zX?xz7TgPz*PmG?T_^R`R;JWskBK-c_>agC86#bZQZ9e$+WbmJ2PZfN?`Azg=92xsR
z+_#Bu?3~{aU)odEeqIZ*c=x{G`V->dC&8P~a*q6Ge<kx<MSC#+?8N*QbAId6^3Srh
z$E)9j{b{`RZ=By6{eH>VP>3qy6Z2a_Kkvi*7Ly~daV;<QSF?w>39qdX{K$`wu>B<N
z!GZdcb=#Y7Db~CXPzO2fSN-`pV-NG5_n{74zXyBl{GY)y?}<kp*nX1pTcY3NbsMh>
z?wcX_cbC;-y<>lvSdTLL$L>Bu@Y`P+ruanv;O8@RVXLThgy5H#PeJ~(KTPxw8T~DL
z`Uw8C5$7vD;QUacKW%?Vz1IF)rk13BuXt^t>-R7}2wwb@@_&5SYQbZEQ@qS?f>*ur
ze5;>vr5tgl?P7mN{n%3*j}-i~trnl{$C?f_#M266qT$ca4-Z+sHf#>}7w?|n_D`a;
z{wZhX;`)om;Mv#$TeU9te(-Saz^!io#Ny$59)(!(G7iO;+VOeY9~LFAfmeHC+S6_Q
zmhe|~`--!#zEb<ud?fRTw;uiOgu(G~v&Ter`9FuVP8|^KiuV^^d3>7d_Y_~W>zCqV
z;%}c=AHBTu)#3w7&Qg3n(~kjHrheQPJqX-7;BUiyw*P@%#;YjvH0)P=O#FV>@mJV0
z6LuMVKJw}%NB>})W%?iEjxNPGM;^AX*c0Qn{fXj>wtrAO{S>W3oO&Q$gAq4_=Ny5<
z)Vt{CDdUAWL~p*bGFm(2)ne_o7aH;G5SJ{z==VRsGj7q}f!_!GDcfFPEdej~%lziq
z6I%Oe&t%wBw|uSZXC$uhPYN&g&%$`$M0~ri-=cW&e~$Kh{tT`E8P}cgC*th-8C_p|
z{}V6%-;8+eHStos<d5k0@*%SM!?+fK$9=A!5j$Xi3NQJ?e4{<EOYxG=qTkEs$krFe
z8FIWBH`Y7ZpJDzJ@8>`9lK=2ycozH#zbZb@`V#$&tJYU!>v0s~x(o3_oLO&-t;PHG
zNIb6xz!#JFg#C=U#7XThGp-ky`N8!wp8Y;v^123beO1S6`lW>bWxi#dsQ=5CBCa>7
zKTW?8u-?T#QfIJ7@lt2sn^+(J1M#{a@iO>C{)m3ox#mwy9Pzx*uJ2y{_;@}iW?b)v
zJ+#Z<6ZtQA&QqHIG2_bda@@8b@bcfs)2}h++4y3u7lTjKuizOct>2h&WxN<SyI%7;
z^GD`s_=l%jzdpXv;1lzYwa3msVh`iXywm+3J72MWeZ1K3jaTuB`BU)T{3-rqeBn>G
zUQ1kIKjQ4;#s6Ns6rY&?1<yFy{PFT3()}O1Ua)?ByyOq#%J_0#F?hEg@qNVRvt1v{
zUOv0^TKr<_*T+l#vtAfquBT?dNb0x5`HgYX`gQB+o>l8g?*$K+{vqpW!PYPF(4D|b
zoE4vI$2<God}8k-FX{VK4f+l9{fM*2>G$zZZ#<G~L{OCefuHhx|4P_HDaXOT+5Mk_
z?U%TphB3SSAHm<G?}H1`FBy9Ze!OyNd{N&wPengw_D}M5zsT*k(++#zN!T~x*_Zci
znyC9Tc71p21+QCtw<isL>6%F;yI#v>&;N3+<H+m#_@HapugZRrUoRQ^S5I#hf1Wvd
zf$q2DZNFVi?T3hep1S8b!Eb79vimbK9<BF`e!E|BkM#3qy|(ttdvnVFcK>9*yk8Js
zp#5Cm-Foeh*YutEi3|Er^Zkq1FZfFKU#$Cv*hf@+!M+b>{LlTLVc1`K-|R18{^a*B
zZobXflg59VJ(ckV`@WX(|0lyv+FAe6>}c@zZ4Ey?@RqY*_h;PqN7g@Sys^Lfcq`-G
z`sn%%tDhYEI1+#C>$rZyTfZ{-@P5|`f(Li~Pc{3gKZ`H0zGVGP?H5UYVjoKM^S#Y{
zpH;~8Gt_JA3;SG>&)E0EddmJMZ}(d&&JWl}6FlEL4Ze`+XMFwUJ=VR~!Zw+&#C{)V
z?J@7w?mZj$g#DNklk*k!qsr97{V3bd=zbUN&*1I*Aosg;zbMns_;z7GP5g@a&Gj>$
z|1<izZ^HZUeR<QfrvFLgTPbaS&65T{_^wGg+t0}JtITh+^nLtw>^B;GVt&Zze|&nY
z_~+!&3y^QzZ%ND#8GNVp&k6pH)+WWvnwRNk>^Qvr3g}|5<ocz=_i+~Q?VscfR_y2g
zgX?E}|9kr<uAh;(0x$3VseHivCjRI5B&J^y|I7Ml`x&c0wf_^E{SBGlD%z9A8~us(
zBH_=<c$wcsf7*V`KjQ~~G&?>V^V^mKZ#nyQe}?m0LVp^s`!oJ}`Wf)9e{=nq^$+>a
zu}@9@MeJMKek|P|^16-hdzjaF2JZU9YW5Syc~H6HWqy-*$$hE#zJt6c9`l>pBlCmc
zZGXt?)*f%a*Y$hicjQl{`N7*yR=mt_qTknR^=J2gI_}4~?oy9ghgn<g^;Jp#>Val|
zxaAhJuMA9w{Z$fg^h=*trCzdl{1i3y`xD=;+tr?uv!`SGlX$`U>sMy}OybRxCGXLn
zr`9|84nGeZXucnWf8^ZrXQOYol_&AW9`#Sf{puv%Xq3O+`+`14o)7zl!#`?IVEakx
z$DHTZuL^h*FI`_aUf(}e@c0>H>i0|0(I#i+EwnkKF%m;veK~(t#~XXn{^=Mm`D6P}
znSZL|jpsDqoPU6qvBG}!q4gQ@iTP9fSskD7C*McJpB>}HpE;~Y&i~c%#(uu%+yA!F
z9$#bYLG1^4);XBT@kqa<KSA{JA&bW^3xPM^mwguf2479T??dw}Prv&~WV`*9@GT+l
z<bId^3FW8b&F>SE<4x;M*hBwVe@gzeKZ7`XFt)TOZ}HxKOEvw(%Y07zQ{TT(FYlvX
zd&qbz=(pF?_<;K5_ZXi|Kk+VJv`6#7x4}INb}=6u-XE`LvyYeY(w@|KtLaaS*RzK@
z)A#V4_K5#e`m5nH`Zc~C;YC05f#dD4UQB&C|EKWjoUr!0|AOU>H;uLSCB{qrp8bM}
zlYUD0-?N9$P9N5uYW1GJ$Kr#iU;hCE2hDD7n$&#lCF6oc%}XwywRr9c_Cqjd?$TNF
zn@$J}A~?CZscHU_`OS-t8>c@A#?N_SO!sq|&*hE1&z`k(?p5<=H61^8>^T1Nn8bs>
POt$~y%yKhanquhxwppnO

literal 18389
zcmeI43Aj~N6~`|EB8Z4)l3IwMQi?e|3#|+9na!G7QVtbG!4n)Iu|O>^R+f!4r<hqZ
z*o>J)c^|L2G&Gu%CY#LW$+9f9-+!OI?)~rAJNoSV$i6Sn=a0S4UjMbu-us-r?s*R{
zyEblK@rxZAjpJYuY}IHqMuCoKtFwRq)BUo=Xi$zgF5mI`IfC<ps=n40d)>Ku;3s4D
zY)`m-^}x(KSI@z2j=z2NoXB@)K6EZK`V}9(7-#rG+i0`~HHI-TRsnWwjU9379%sIx
z<~DSUhY88i>J9(47!zST@Og6Dr)!JLIH@}(Wykik8gq<WYqB@|<IgkNS`&fYM8dkY
z4$NVV8wpr`$6*79>~U^e+JkO8VnDtjcGLQsrgyu2(%8KQW?lRHl*cq}vt8dbz1wYF
z|6s<UF&xgg6hFjnTEFHLdbbsuuBTYjxb1r7487ZJ=F~iex#cm0#`C+rX?nNY<d_rd
zV;axzdR;U0Znsz5ao8NqU*j>2+pce#-tG46+m6saO843{p5OIN)4Lt|rp99$w_P7O
zrFT1xzlXI}o;;qRw(HXzv)=7=e>D!}(LGhJA$Gc7xj#JvS?{)D+vnt1tyAPQ+x5yB
zdbit*v3)xCGLIoNp5OIN)4Q!41F=4)@%*lDn%-?)e?aS^@tDSK*Edb?c2O%#<M~}*
z)DWvDX@BSXQ)pDfwAPHX>GnxCT{v*fp;xxm@3qD2Nzre5kKOi?lLz)&zK`~`*PnDx
z<GP;H^=>PN&Xq@TI%Mm4$hE8JcfH%1(_+RtTx_m~MNZedt?TF7pRQ}MQM-!%q56m=
zXVb>hiM86L@pSrK?>2LsGbyi+$6D<w>YnS}CdVADm)6H)t#%dtu6KLMO&8A5dMS^`
zTJ0+OUGKI&Q?+)=Gfb@ZSJCf!x0UmH*4oCCY|Sz6_ZUy=cfH%1<NmC*@_4MqsAFiq
z>)lokol9RucAn>`rA5E%-PW8mKIPGKGF-j&e%HILG1&V{)Zw%ja(zzY@fz;>u*umz
zr8^$gsWdjLrA1EHyUiR2Cg=6>SgWN)9d^Cj<QUL;X?;A_YH88$dbgR=fYwWSJl1M#
z(eHY<y~cX1*G$)#-FDmbZL^zRGriwz*SAgYc2hMV>aA%!zw6tkce|+?5cSP8p5OIt
z)4QFXJ*%0WoHhEkp67TsH(TTB)LZX2yNETt#?y&qE}eSo{bsvfa}2%PP1OLci=Hdf
zxb6D3>D^8>fNQsv$24xczO9;(^=>zZ*38IRqfbBgXzjSJ+i5(pUp%MTu1{mgdbiW~
zWB+;`Hrw@Sj#=+^Q+-iy)kaRUUEemn+f9v8*Va0l#%<TPP49Mko~>qfa@Oe6Gnw^n
zYdoELtNRc+&33)U5PG*Y{!YC$jpuj0<`{ann_e?b<N00RHoe<TubHOt{I1uWqCUG_
zywjS-^Si#Nu~u)JUO%nBct5v#p5960=Y5a0T3Xa$dzUU_?dN@uRn5rtxv0bTE?xYt
zK+l5??Ng7{{?7He=&#h3-fer|_WGQjv8cD6)AepEXZ-#_w#7z`EpiUkN37m$^80^n
zy=6R|oUV7<-kEFbt<`7$eL`W|J9DZhT5GMj*H5d@ZP&YP@61K4*H6#sdbjPJxwhVV
zPS?AgbL#ykjYoA#w%1Ru$*y<X-kFP7tEEN1>)qD#phIKuSdA;!=c2z-5BogFJG1Ir
zCsz8Xx8AR3M)T2i-IhMT8`sub&pA{dvE+<*=GuD8cvQ1u3?044+B<V?y|w!6zuzcq
zduOh#w^pD1_Zx+6@65IJ*6Oq7)cO61+g@Y64r@Ji=)QOj^n0ZBiCR&qE4@Eg7TYw<
zzx`~Lua$n5iQhk19{*j3kEh6EWAlF3w{6URtyDMi&#iT~>zn!=^mQALOg~G<ysEY}
zH`>bInj5<7Hf~J%?z!T_uU7tOm8HssKIN?1q~}~dr_s3hqKi7$jxo5V^0(%OuBYe9
zq>uB`-<n(bqt$#jCVj+}{xt41rqK2G-<0%mUbS6a<!{Xm9b-;^#}MbGKdlA+Xf>XR
z@plr|hF{l_KU%HNE=d=0rC;kJf3#Y`zNGKz>9JPpp>thF{%F(lkaQ7O`ZbOtlfG&-
zo)eNj&P%_>A%C=uMt^^Q(nnnB*E-4{ZKKiCb7s;<T<O<5<d0VKt^STD;!3~fDSx!_
z{Odf$=C+ZpNl!2H(es|$bl-<O@9vjQ&wsS(KIoc5_eDp?{n9mit2V7~(#Lt}Pvb~>
z#+7t=F1j!2ylT6;%CGsPIp=*-+0m!#hc53U#-n{0`$qGq&P#uzH}9j|rg;`|r9Z6;
z{%B+0bmQ_q)A}S`-bcN$k7BHGUi#C0)4j_mZ?%6SuIsBbc^`4TO2>MqwTSc5pYBu2
z9lHMhy^}u9tG27F{0+um>0;l-dFj`BrhS@Q-KV~kKjKQi<{*Ex>G?_eh%5c+xk!4R
zlcbCN7w1*m)#ZK4^HA;M*ne?e`ZdqAzjGV=GWK({U0vR%%(vRdJacJWabEg0Px+%w
z^G*AWJ{|IL^mSV1gTIga8~Zf&XPmoVI{BlGeW~?`IQRGEeH*QG+K1gZo`-Y~qpkeP
zU+H4s#d+!1Ji5<7l~?;P&EMLtuG*g(Po<0f7w4tFFYnuE(>zn&h^yN0YuwtG(ds^?
z&&S*!@!{{w{%AGsiioS)@M|9ON2`3=msL!+4Zp4<f3#`clRn}~f4WaeANw@+Uz}HM
zS6BHpKJDM`{*3d|uXWP?jkY_Na^Hqu^Kdj@?aOXl>DN5vk5=<dpTC{B(yw{QA8jM=
z%Whoh*F3d<qt$%1FS~K2U-OVZT8+Dv^buG3HCOqgP4i9rjcahIUxzeR%Y5*+G(X#y
zY5w`#{nBZFMyq*O`>)*B;csPsv?*_Tz9X(`!>>5)+i24~@_tZ%#D`z=NT0R2)p)co
zyK$vo*O5P3t*hQ|yK$wzmHpA``qlo7xT+1m#wCBWy3g9b-MG@<%Km6I?gn(@s`&70
zzVb(_yw(1UxYDn2$RDldsn6eTT<O=k$RDl7p?%qnEBzXm{LyMXtNj^qrC;kLf3$rm
zxAI3^>DN4^iB{vT_Gi@}@!{7z<&Re5uJ&idm43}r{%AGdYJWyt>DN5vk5=QZ_GiSE
ze$7+<XuETXxYDnAIMSzMNPq6_Xd9u+j>s{zU+3Xd8;AErf3%@d8-4dw-)O8{ac1w?
zvoB>YRCxwwU+}QIvR&`?_+1wEE?9PR%H#cYw(H&I+O3#R^MGk{cfaA>v>tV~>)mEf
z8x}J+`gF7+XPxbOw|82(^Wea4N2fgAUuV1CZE_59p7MBqo$Y$JnbRQGPV4Obb++r>
zW<3VAFgm=y&UU@qS-+vm)XnJ{w_Wcx&%hwhPs-!{b++r>W*n`!-gyU1+raaa=2>UE
z-fgY1u1%kgR^+U+UGKK;x$cdUcz>Pkdbi2Zt7k=dyuZ$Nz1!N4$Fnz-$NTGS*SpPn
z^hT}l{yN+BrLDEqk!n~gng6*>{5{I!`ul7auaW4i;eBgz@2-h%M{jjcQVqI0+x1(*
zZrON7lHc`P!uBzYB){wLv#V$OF4uv2uJ?`3=Q}n3Dh2T0;BdC<-RAQ}??37D%lqqW
z*SoD8I%f>}{OaVavt94D<`kdr-d|_C-ffLTYoR~Azs{B}^lqc~_l;pSb$X9w{Qpz$
z8?3Q@z8LZQhU?vC&7$_{eYKOb&UU@qSwA<gWhbX=+;+X&Ja2j*Q+$jk<#dhPu6H}%
zuaw98>ulG%ou7e}$NTGS*Sl@&67Q=ir)%7Hz1wK~=Pz98{#BA;Y}dQZ`2VMV{!+c-
z{aN?A#XVB}iF-G!?RvKf@6=E4ud`iW+MW03L5-<e;8c(P8#dP%_F5z9cg>cz8#d07
zT+8)a!uBzYB){w3_E_()vt94D>%G6ucK!c@?dvd-`MQ2f*gl4l<ahm+uzd_8$?tl%
zJ=Xi{Y}dQ(dhf5ZUB4yly6cXl-^U}pK5uB#JNP}Z6_VZ!@9r~eB%f>f{Y0NRBl<m3
zonGG`)}j9=i({Hv|Bkc113d=xooIchS>Jiq_n`GXW_`C=-*MJ=lJ$LNeXp6XfHx+C
zzMs4k+z)nyDX=r#A9jUZ-~sR;cp&Ts(_nX)3Nv6j>;ZejUa%)T1Re}CVHWHQ`@sJ2
zP}mRjMR9%M`2f%_(+`FoI0R<H!{L$e2sjk<GQnToHS|B(9R_`%8~bQD93BOagU7;S
z;EC`Acsx7_j)WuN7&sb^f@9$+@ML%zJQe1_32;0d2hV_~!-?=Lm=Di{=fDDZHY|dL
z@LX67CqX})0w==~I2}%dQ(+k_g)?9|oC(i^7r^u3EI1oh!U}jHoD1hb3(kWV!HeO1
zSOpirOW`GOA-o)32Csrw!Ykml@EUkEydGW$tKm)XMtB3f72X1GhBa_8Tm+ZG+u#y-
z2V4ekhj+nRcqhCU-UIK3_rv?(a`+H@5Iz9w;3M#1xDq}JSHQ>ND)<<D64t{fpbb~U
zr(h5^zyN#}J_DbIFTm&FbMR&O5_}Q90@uPda6McH8{uoP3BC&7gm1vt;XCkc_!ex2
z8{oU}1Nc6C4{n4X!4Ki5@Dunk+yp;|pTRHTX7~mC27V2{g5SgM;J5H6_#^xQ{sOna
zpW$zCEBqDy0k^^5;SRVR{t2T-=@0&$1e!6lqhTu;2V28fm;mEp8`use!nQCOwueb@
zKiCm=fSuv~uoLV84}dA~K-dj-h23E)JP4-49xx5|f<0jdJQ!xe-mow10}p|R!hSFd
z4uk_>e>fO=;2@X{4~K`rBj8Xt1oV$aG~toZ2fZ*C4u?m<VenXZ3_Kd10FQ^q!I5wT
zJQ0qDqu@#K6nHWm15br{a4Z}T$HCL!>2M;P0Q2FQ@C;Z0&xU8gLU=Ab2Tp>1SOh1-
z5?BnU!KrWxEQK@RbT|{92g~63a270wm9PR{0O!Iva5kI=FM=1s`LGIF@KSgQyck{%
zFM|u<mGBC<5MBeXhF8JsU^ToJ-Ux4i*TY-j&G06;7%qah!rR~ySOb^A+u>4J3-5$?
zz<c1`@Gf{CTn_Jr55foF{qPa^FnkC;3Rl27xC%Z7SHgPu1biH>hEKsKVFL_68$JV{
zhC%o|d=5SfUxF{f7vNgB2EGi}!AAHBY=W=C_3#b&I(!Yj4c~%q!VU0U_zrv@z6YD(
zNAN@V0qD3fx0A7VfF0G@7{zDvXg-g}@)<lX^{`XVTXmw$RVQx4r||?nnJ4mTJc&=>
z$wa2OQCp23Gj{87+l-&E?ZoXSZ9jG1ym?cnuA2($TIra{pEGAJn+ePMmO<azK3F?{
zEzG}VKHPHkEpYX$_3PKqnzd>ctm<6_y|?zlt($IzP4hOvyi@O`qZ;RC#<_X(l+7?@
z%@kNOYYp7Zn0-yAuUofn`t%voVMc2PwC;L+_Ptk+YO%Rp9NYws$vZ4O>$KBWHkKZ<
qWa**<8w(dLU$ErVgYu)G=W5(hXB@kD!O}&e;}OdLDh^w|SNsbiRi_95


From 8781f2ab55720151c3a3449d4fda3fe5177a8c4d Mon Sep 17 00:00:00 2001
From: Areloch <Areloch@gmail.com>
Date: Fri, 10 Sep 2021 02:13:56 -0500
Subject: [PATCH 060/399] Add getScriptPath console function to GUIAsset
 Shifted tracking of importing asset status to an enum for more robust
 handling Added logic to properly init freshly created shapeConstructors with
 the newly imported shapeAsset Fixed handling of assets that have been marked
 to be skipped, but needed to fill in the parent's
 dependencies(UseForDependencies enum value) Cleaned up redundant recursive
 logic for importing assets Disable Create Game Objects button in inspector
 Fixed material assignment for convex proxies Updated asset icons for AB with
 WIP images to be more clear Fixed issue where type-generic icons in the
 creator items in the AB weren't showing correctly. Force AB to show creator
 entries in list mode for efficiency and avoid icon scaling issues Moved
 creator functions for AB to separate file for convenience Filled out
 GUIControls in the AB's creator mode, and context world editor and GUI
 creator entries based on active editor Added drag-n-drop handling for
 guiControls via AB creator in guiEditor mode Added more types' profiles in
 the AB gui profiles to give more unique border colors for better visual
 clarity of asset type Added editor setting to indicate if the editor should
 load into the last edited level, or the editor default scene Fixed setting of
 highlight material overlay in shapeEditor Added global keybind for GUIEditor
 so space also toggles assetbrowser Fixed up binding/finding of
 shapeConstructor by assetId, which also fixed displaying of shape's material
 listing

---
 Engine/source/T3D/assets/GUIAsset.cpp         |   7 +
 Engine/source/T3D/assets/assetImporter.cpp    | 550 ++++++------------
 Engine/source/T3D/assets/assetImporter.h      |  21 +-
 Engine/source/T3D/tsStatic.cpp                |  76 ++-
 .../worldEditor/guiConvexShapeEditorCtrl.cpp  |  17 +-
 Engine/source/scene/sceneObject.cpp           |   5 +-
 Engine/source/ts/tsShapeConstruct.cpp         |  18 +
 Engine/source/ts/tsShapeConstruct.h           |   2 +
 .../tools/assetBrowser/art/animationIcon.png  | Bin 8177 -> 12242 bytes
 .../assetBrowser/art/clientScriptIcon.png     | Bin 14572 -> 9016 bytes
 .../game/tools/assetBrowser/art/cppIcon.png   | Bin 4894 -> 6954 bytes
 .../tools/assetBrowser/art/datablockIcon.png  | Bin 6937 -> 8646 bytes
 .../tools/assetBrowser/art/folderIcon.png     | Bin 11562 -> 7824 bytes
 .../game/tools/assetBrowser/art/guiIcon.png   | Bin 5789 -> 10181 bytes
 .../game/tools/assetBrowser/art/levelIcon.png | Bin 6797 -> 20009 bytes
 .../tools/assetBrowser/art/materialIcon.png   | Bin 7889 -> 40426 bytes
 .../tools/assetBrowser/art/postEffectIcon.png | Bin 8615 -> 10506 bytes
 .../tools/assetBrowser/art/prefabIcon.png     | Bin 0 -> 12431 bytes
 .../art/prefabIcon_image.asset.taml           |   8 +
 .../tools/assetBrowser/art/scriptIcon.png     | Bin 10044 -> 7772 bytes
 .../assetBrowser/art/serverScriptIcon.png     | Bin 14897 -> 9224 bytes
 .../game/tools/assetBrowser/art/soundIcon.png | Bin 10582 -> 11705 bytes
 .../assetBrowser/art/stateMachineIcon.png     | Bin 13506 -> 20797 bytes
 .../tools/assetBrowser/art/terrainIcon.png    | Bin 0 -> 13631 bytes
 .../art/terrainIcon_image.asset.taml          |   8 +
 .../assetBrowser/art/terrainMaterialIcon.png  | Bin 7889 -> 14057 bytes
 .../game/tools/assetBrowser/main.tscript      |   4 +
 .../assetBrowser/scripts/assetBrowser.tscript | 199 +------
 .../assetBrowser/scripts/assetImport.tscript  | 142 -----
 .../scripts/assetTypes/cpp.tscript            |  13 +
 .../scripts/assetTypes/creatorObj.tscript     |  15 +
 .../scripts/assetTypes/material.tscript       |  14 +-
 .../scripts/assetTypes/prefab.tscript         |   2 +-
 .../scripts/assetTypes/script.tscript         |  16 +
 .../scripts/assetTypes/shape.tscript          |  11 +-
 .../scripts/assetTypes/terrain.tscript        |   2 +-
 .../assetBrowser/scripts/creator.tscript      | 194 ++++++
 .../assetBrowser/scripts/profiles.tscript     |  63 ++
 .../tools/gui/editorSettingsWindow.ed.tscript |   5 +
 .../images/{tab-border.png => tab_border.png} | Bin
 .../gui/images/tab_border_image.asset.taml    |   2 +-
 .../guiEditor/scripts/guiEditor.ed.tscript    |  15 +-
 Templates/BaseGame/game/tools/main.tscript    |  28 +
 .../scripts/shapeEditor.ed.tscript            |   6 +-
 44 files changed, 695 insertions(+), 748 deletions(-)
 create mode 100644 Templates/BaseGame/game/tools/assetBrowser/art/prefabIcon.png
 create mode 100644 Templates/BaseGame/game/tools/assetBrowser/art/prefabIcon_image.asset.taml
 create mode 100644 Templates/BaseGame/game/tools/assetBrowser/art/terrainIcon.png
 create mode 100644 Templates/BaseGame/game/tools/assetBrowser/art/terrainIcon_image.asset.taml
 create mode 100644 Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript
 rename Templates/BaseGame/game/tools/gui/images/{tab-border.png => tab_border.png} (100%)

diff --git a/Engine/source/T3D/assets/GUIAsset.cpp b/Engine/source/T3D/assets/GUIAsset.cpp
index 781cabc9e..f9a2b500c 100644
--- a/Engine/source/T3D/assets/GUIAsset.cpp
+++ b/Engine/source/T3D/assets/GUIAsset.cpp
@@ -221,6 +221,13 @@ DefineEngineStaticMethod(GUIAsset, getAssetIdByGUIName, const char*, (const char
 {
    return GUIAsset::getAssetIdByGUIName(StringTable->insert(guiName));
 }
+
+DefineEngineMethod(GUIAsset, getScriptPath, const char*, (), ,
+   "Gets the script file path associated to this asset.\n"
+   "@return The full script file path.")
+{
+   return object->getScriptPath();
+}
 #endif
 
 //-----------------------------------------------------------------------------
diff --git a/Engine/source/T3D/assets/assetImporter.cpp b/Engine/source/T3D/assets/assetImporter.cpp
index b0497631e..5dadee79c 100644
--- a/Engine/source/T3D/assets/assetImporter.cpp
+++ b/Engine/source/T3D/assets/assetImporter.cpp
@@ -420,8 +420,7 @@ IMPLEMENT_CONOBJECT(AssetImportObject);
 
 AssetImportObject::AssetImportObject() :
    dirty(false),
-   skip(false),
-   processed(false),
+   importStatus(AssetImportObject::NotProcessed),
    generatedAsset(false),
    parentAssetItem(nullptr),
    tamlFilePath(""),
@@ -463,8 +462,6 @@ void AssetImportObject::initPersistFields()
    addField("statusInfo", TypeRealString, Offset(statusInfo, AssetImportObject), "What is the articulated information of the status of the asset. Contains the error or warning log data");
 
    addField("dirty", TypeBool, Offset(dirty, AssetImportObject), "Is the asset item currently flagged as dirty");
-   addField("skip", TypeBool, Offset(skip, AssetImportObject), "Is this asset item marked to be skipped. If it is, it's usually due to being marked as deleted");
-   addField("processed", TypeBool, Offset(processed, AssetImportObject), "Has the asset item been processed");
    addField("generatedAsset", TypeBool, Offset(generatedAsset, AssetImportObject), "Is this specific asset item generated as part of the import process of another item");
 
    addField("tamlFilePath", TypeRealString, Offset(tamlFilePath, AssetImportObject), "What is the ultimate asset taml file path for this import item");
@@ -622,8 +619,7 @@ AssetImportObject* AssetImporter::addImportingAsset(String assetType, Torque::Pa
    assetImportObj->statusInfo = "";
 
    assetImportObj->dirty = false;
-   assetImportObj->skip = false;
-   assetImportObj->processed = false;
+   assetImportObj->importStatus = AssetImportObject::NotProcessed;
    assetImportObj->generatedAsset = false;
 
    if (parentItem != nullptr)
@@ -656,7 +652,7 @@ AssetImportObject* AssetImporter::addImportingAsset(String assetType, Torque::Pa
 
 void AssetImporter::deleteImportingAsset(AssetImportObject* assetItem)
 {
-   assetItem->skip = true;
+   assetItem->importStatus = AssetImportObject::Skipped;
 
    //log it
    dSprintf(importLogBuffer, sizeof(importLogBuffer), "Deleting Importing Asset %s and all it's child items", assetItem->assetName.c_str());
@@ -665,36 +661,21 @@ void AssetImporter::deleteImportingAsset(AssetImportObject* assetItem)
 
 AssetImportObject* AssetImporter::findImportingAssetByName(String assetName, AssetImportObject* assetItem)
 {
-   if (assetItem == nullptr)
-   {
-      for (U32 i = 0; i < importingAssets.size(); i++)
-      {
-         if (importingAssets[i]->cleanAssetName == assetName)
-         {
-            return importingAssets[i];
-         }
+   Vector<AssetImportObject*> itemList = importingAssets;
+   if (assetItem != nullptr)
+      itemList = assetItem->childAssetItems;
 
-         //If it wasn't a match, try recusing on the children(if any)
-         AssetImportObject* retItem = findImportingAssetByName(assetName, importingAssets[i]);
-         if (retItem != nullptr)
-            return retItem;
-      }
-   }
-   else
+   for (U32 i = 0; i < itemList.size(); i++)
    {
-      //this is the child recursing section
-      for (U32 i = 0; i < assetItem->childAssetItems.size(); i++)
+      if (itemList[i]->cleanAssetName == assetName)
       {
-         if (assetItem->childAssetItems[i]->cleanAssetName == assetName)
-         {
-            return assetItem->childAssetItems[i];
-         }
-
-         //If it wasn't a match, try recusing on the children(if any)
-         AssetImportObject* retItem = findImportingAssetByName(assetName, assetItem->childAssetItems[i]);
-         if (retItem != nullptr)
-            return retItem;
+         return itemList[i];
       }
+
+      //If it wasn't a match, try recusing on the children(if any)
+      AssetImportObject* retItem = findImportingAssetByName(assetName, itemList[i]);
+      if (retItem != nullptr)
+         return retItem;
    }
 
    return nullptr;
@@ -1385,105 +1366,53 @@ void AssetImportConfig::loadSISFile(Torque::Path filePath)
 
 void AssetImporter::processImportAssets(AssetImportObject* assetItem)
 {
-   if (assetItem == nullptr)
+   Vector<AssetImportObject*> itemList = importingAssets;
+   if (assetItem != nullptr)
+      itemList = assetItem->childAssetItems;
+
+   assetHeirarchyChanged = false;
+
+   for (U32 i = 0; i < itemList.size(); i++)
    {
-      assetHeirarchyChanged = false;
+      AssetImportObject* item = itemList[i];
+      if (item->importStatus != AssetImportObject::NotProcessed)
+         continue;
 
-      for (U32 i = 0; i < importingAssets.size(); i++)
+      //Sanitize before modifying our asset name(suffix additions, etc)
+      if (item->assetName != item->cleanAssetName)
+         item->assetName = item->cleanAssetName;
+
+      //handle special pre-processing here for any types that need it
+
+      //process the asset items
+      if (item->assetType == String("ImageAsset"))
       {
-         AssetImportObject* item = importingAssets[i];
-         if (item->skip)
-            continue;
-
-         if (!item->processed)
-         {
-            //Sanitize before modifying our asset name(suffix additions, etc)
-            if (item->assetName != item->cleanAssetName)
-               item->assetName = item->cleanAssetName;
-
-            //handle special pre-processing here for any types that need it
-
-            //process the asset items
-            if (item->assetType == String("ImageAsset"))
-            {
-               processImageAsset(item);
-            }
-            else if (item->assetType == String("ShapeAsset"))
-            {
-               processShapeAsset(item);
-            }
-            /*else if (item->assetType == String("SoundAsset"))
-               SoundAsset::prepareAssetForImport(this, item);*/
-            else if (item->assetType == String("MaterialAsset"))
-            {
-               processMaterialAsset(item);
-            }
-            /*else if (item->assetType == String("ShapeAnimationAsset"))
-               ShapeAnimationAsset::prepareAssetForImport(this, item);*/
-            else
-            {
-               String processCommand = "process";
-               processCommand += item->assetType;
-               if(isMethod(processCommand.c_str()))
-                  Con::executef(this, processCommand.c_str(), item);
-            }
-
-            item->processed = true;
-         }
-
-         //try recusing on the children(if any)
-         processImportAssets(item);
+         processImageAsset(item);
       }
-   }
-   else
-   {
-      //this is the child recursing section
-      for (U32 i = 0; i < assetItem->childAssetItems.size(); i++)
+      else if (item->assetType == String("ShapeAsset"))
       {
-         AssetImportObject* childItem = assetItem->childAssetItems[i];
-
-         if (childItem->skip)
-            continue;
-
-         if (!childItem->processed)
-         {
-            //Sanitize before modifying our asset name(suffix additions, etc)
-            //if (childItem->assetName != childItem->cleanAssetName)
-            //   childItem->assetName = childItem->cleanAssetName;
-
-            //handle special pre-processing here for any types that need it
-
-            //process the asset items
-            if (childItem->assetType == String("ImageAsset"))
-            {
-               processImageAsset(childItem);
-            }
-            else if (childItem->assetType == String("ShapeAsset"))
-            {
-               processShapeAsset(childItem);
-            }
-            /*else if (item->assetType == String("SoundAsset"))
-               SoundAsset::prepareAssetForImport(this, item);*/
-            else if (childItem->assetType == String("MaterialAsset"))
-            {
-               processMaterialAsset(childItem);
-            }
-            /*else if (item->assetType == String("ShapeAnimationAsset"))
-               ShapeAnimationAsset::prepareAssetForImport(this, item);*/
-            else
-            {
-               String processCommand = "process";
-               processCommand += childItem->assetType;
-               if (isMethod(processCommand.c_str()))
-                  Con::executef(this, processCommand.c_str(), childItem);
-            }
-
-            childItem->processed = true;
-         }
-
-         //try recusing on the children(if any)
-         processImportAssets(childItem);
+         processShapeAsset(item);
       }
+      /*else if (item->assetType == String("SoundAsset"))
+         SoundAsset::prepareAssetForImport(this, item);*/
+      else if (item->assetType == String("MaterialAsset"))
+      {
+         processMaterialAsset(item);
+      }
+      /*else if (item->assetType == String("ShapeAnimationAsset"))
+         ShapeAnimationAsset::prepareAssetForImport(this, item);*/
+      else
+      {
+         String processCommand = "process";
+         processCommand += item->assetType;
+         if(isMethod(processCommand.c_str()))
+            Con::executef(this, processCommand.c_str(), item);
+      }
+
+      item->importStatus == AssetImportObject::Processed;
+
+      //try recusing on the children(if any)
+      processImportAssets(item);
    }
 
    //If our hierarchy changed, it's because we did so during processing
@@ -1606,7 +1535,7 @@ void AssetImporter::processImageAsset(AssetImportObject* assetItem)
       assetItem->cleanAssetName = assetItem->assetName;
    }
 
-   assetItem->processed = true;
+   assetItem->importStatus = AssetImportObject::Processed;
 }
 
 void AssetImporter::processMaterialAsset(AssetImportObject* assetItem)
@@ -1629,7 +1558,7 @@ void AssetImporter::processMaterialAsset(AssetImportObject* assetItem)
          String ignoredName = StringUnit::getUnit(activeImportConfig->IgnoreMaterials, i, ",;\t");
          if (FindMatch::isMatch(ignoredName.c_str(), assetName, false))
          {
-            assetItem->skip = true;
+            assetItem->importStatus = AssetImportObject::Skipped;
 
             dSprintf(importLogBuffer, sizeof(importLogBuffer), "Material %s has been ignored due to it's name being listed in the IgnoreMaterials list in the Import Config.", assetItem->assetName.c_str());
             activityLog.push_back(importLogBuffer);
@@ -1645,9 +1574,9 @@ void AssetImporter::processMaterialAsset(AssetImportObject* assetItem)
       //check to see if the definition for this already exists
       StringTableEntry existingMatAsset = MaterialAsset::getAssetIdByMaterialName(StringTable->insert(assetName));
 
-      if (existingMatAsset != StringTable->EmptyString())
+      if (existingMatAsset != StringTable->EmptyString() && existingMatAsset != StringTable->insert("Core_Rendering:NoMaterial"))
       {
-         assetItem->skip = true;
+         assetItem->importStatus = AssetImportObject::UseForDependencies;
          dSprintf(importLogBuffer, sizeof(importLogBuffer), "Material %s has been skipped because we already found an asset Id that uses that material definition. The found assetId is: %s", assetItem->assetName.c_str(), existingMatAsset);
          activityLog.push_back(importLogBuffer);
          return;
@@ -1696,7 +1625,7 @@ void AssetImporter::processMaterialAsset(AssetImportObject* assetItem)
          {
             AssetImportObject* childAssetItem = assetItem->childAssetItems[i];
 
-            if (childAssetItem->skip || childAssetItem->assetType != String("ImageAsset"))
+            if (childAssetItem->importStatus == AssetImportObject::Skipped || childAssetItem->assetType != String("ImageAsset"))
                continue;
 
             for (S32 t = 0; t < ImageAsset::ImageTypeCount; t++)
@@ -1848,7 +1777,7 @@ void AssetImporter::processMaterialAsset(AssetImportObject* assetItem)
       }
    }
    
-   assetItem->processed = true;
+   assetItem->importStatus = AssetImportObject::Processed;
 }
 
 void AssetImporter::processShapeAsset(AssetImportObject* assetItem)
@@ -1944,7 +1873,7 @@ void AssetImporter::processShapeAsset(AssetImportObject* assetItem)
    cachedConfig->CopyTo(activeImportConfig);
    cachedConfig->deleteObject();
 
-   assetItem->processed = true;
+   assetItem->importStatus = AssetImportObject::Processed;
 }
 
 void AssetImporter::processShapeMaterialInfo(AssetImportObject* assetItem, S32 materialItemId)
@@ -2131,7 +2060,7 @@ void AssetImporter::processSoundAsset(AssetImportObject* assetItem)
       }
    }
 
-   assetItem->processed = true;
+   assetItem->importStatus = AssetImportObject::Processed;
 }
 //
 // Validation
@@ -2154,7 +2083,7 @@ bool AssetImporter::validateAssets()
 
 void AssetImporter::validateAsset(AssetImportObject* assetItem)
 {
-   if (assetItem->skip)
+   if (assetItem->importStatus == AssetImportObject::Skipped || assetItem->importStatus == AssetImportObject::NotProcessed)
       return;
 
    bool hasCollision = checkAssetForCollision(assetItem);
@@ -2234,36 +2163,21 @@ void AssetImporter::validateAsset(AssetImportObject* assetItem)
 
 void AssetImporter::resetAssetValidationStatus(AssetImportObject* assetItem)
 {
-   if (assetItem == nullptr)
+   Vector<AssetImportObject*> itemList = importingAssets;
+   if (assetItem != nullptr)
+      itemList = assetItem->childAssetItems;
+
+   for (U32 i = 0; i < itemList.size(); i++)
    {
-      for (U32 i = 0; i < importingAssets.size(); i++)
-      {
-         if (importingAssets[i]->skip)
-            continue;
+      if (itemList[i]->importStatus == AssetImportObject::Skipped)
+         continue;
 
-         importingAssets[i]->status = "";
-         importingAssets[i]->statusType = "";
-         importingAssets[i]->statusInfo = "";
+      itemList[i]->status = "";
+      itemList[i]->statusType = "";
+      itemList[i]->statusInfo = "";
 
-         //If it wasn't a match, try recusing on the children(if any)
-         resetAssetValidationStatus(importingAssets[i]);
-      }
-   }
-   else
-   {
-      //this is the child recursing section
-      for (U32 i = 0; i < assetItem->childAssetItems.size(); i++)
-      {
-         if (assetItem->childAssetItems[i]->skip)
-            continue;
-
-         assetItem->childAssetItems[i]->status = "";
-         assetItem->childAssetItems[i]->statusType = "";
-         assetItem->childAssetItems[i]->statusInfo = "";
-
-         //If it wasn't a match, try recusing on the children(if any)
-         resetAssetValidationStatus(assetItem->childAssetItems[i]);
-      }
+      //If it wasn't a match, try recusing on the children(if any)
+      resetAssetValidationStatus(itemList[i]);
    }
 }
 
@@ -2271,68 +2185,37 @@ bool AssetImporter::checkAssetForCollision(AssetImportObject* assetItemToCheck,
 {
    bool results = false;
 
-   if (assetItem == nullptr)
+   Vector<AssetImportObject*> itemList = importingAssets;
+   if (assetItem != nullptr)
+      itemList = assetItem->childAssetItems;
+
+   for (U32 i = 0; i < itemList.size(); i++)
    {
-      for (U32 i = 0; i < importingAssets.size(); i++)
+      AssetImportObject* importingAsset = itemList[i];
+
+      if (importingAsset->importStatus == AssetImportObject::Skipped)
+         continue;
+
+      if ((assetItemToCheck->assetName.compare(importingAsset->assetName) == 0) && (assetItemToCheck->getId() != importingAsset->getId()))
       {
-         AssetImportObject* importingAsset = importingAssets[i];
-
-         if (importingAsset->skip)
-            continue;
-
-         if ((assetItemToCheck->assetName.compare(importingAsset->assetName) == 0) && (assetItemToCheck->getId() != importingAsset->getId()))
-         {
-            //we do have a collision, note the collsion and bail out
-            assetItemToCheck->status = "Warning";
-            assetItemToCheck->statusType = "DuplicateImportAsset";
-            assetItemToCheck->statusInfo = "Duplicate asset names found with importing assets!\nAsset \"" + importingAsset->assetName + "\" of the type \"" + importingAsset->assetType + "\" and \"" +
-                                             assetItemToCheck->assetName + "\" of the type \"" + assetItemToCheck->assetType + "\" have matching names.\nPlease rename one of them.";
-
-             dSprintf(importLogBuffer, sizeof(importLogBuffer), "Warning! Asset %s, type %s has a naming collision with another importing asset: %s, type %s",
-                assetItemToCheck->assetName.c_str(), assetItemToCheck->assetType.c_str(),
-                importingAsset->assetName.c_str(), importingAsset->assetType.c_str());
-             activityLog.push_back(importLogBuffer);
-
-            return true;
-         }
-
-         //If it wasn't a match, try recusing on the children(if any)
-         results = checkAssetForCollision(assetItemToCheck, importingAsset);
-         if (results)
-            return results;
-      }
-   }
-   else
-   {
-      //this is the child recursing section
-      for (U32 i = 0; i < assetItem->childAssetItems.size(); i++)
-      {
-         AssetImportObject* childAsset = assetItem->childAssetItems[i];
-
-         if (childAsset->skip)
-            continue;
-
-         if ((assetItemToCheck->assetName.compare(childAsset->assetName) == 0) && (assetItemToCheck->getId() != childAsset->getId()))
-         {
-            //we do have a collision, note the collsion and bail out
-            assetItemToCheck->status = "Warning";
-            assetItemToCheck->statusType = "DuplicateImportAsset";
-            assetItemToCheck->statusInfo = "Duplicate asset names found with importing assets!\nAsset \"" + assetItem->assetName + "\" of the type \"" + assetItem->assetType + "\" and \"" +
-               assetItemToCheck->assetName + "\" of the type \"" + assetItemToCheck->assetType + "\" have matching names.\nPlease rename one of them.";
+         //we do have a collision, note the collsion and bail out
+         assetItemToCheck->status = "Warning";
+         assetItemToCheck->statusType = "DuplicateImportAsset";
+         assetItemToCheck->statusInfo = "Duplicate asset names found with importing assets!\nAsset \"" + importingAsset->assetName + "\" of the type \"" + importingAsset->assetType + "\" and \"" +
+                                          assetItemToCheck->assetName + "\" of the type \"" + assetItemToCheck->assetType + "\" have matching names.\nPlease rename one of them.";
 
             dSprintf(importLogBuffer, sizeof(importLogBuffer), "Warning! Asset %s, type %s has a naming collision with another importing asset: %s, type %s",
                assetItemToCheck->assetName.c_str(), assetItemToCheck->assetType.c_str(),
-               childAsset->assetName.c_str(), childAsset->assetType.c_str());
+               importingAsset->assetName.c_str(), importingAsset->assetType.c_str());
             activityLog.push_back(importLogBuffer);
 
-            return true;
-         }
-
-         //If it wasn't a match, try recusing on the children(if any)
-         results = checkAssetForCollision(assetItemToCheck, childAsset);
-         if (results)
-            return results;
+         return true;
       }
+
+      //If it wasn't a match, try recusing on the children(if any)
+      results = checkAssetForCollision(assetItemToCheck, importingAsset);
+      if (results)
+         return results;
    }
 
    return results;
@@ -2348,7 +2231,16 @@ void AssetImporter::resolveAssetItemIssues(AssetImportObject* assetItem)
       if (activeImportConfig->DuplicateAutoResolution == String("AutoPrune"))
       {
          //delete the item
-         deleteImportingAsset(assetItem);
+         if (assetItem->parentAssetItem == nullptr)
+         {
+            //if there's no parent, just delete
+            deleteImportingAsset(assetItem);
+         }
+         else
+         {
+            //otherwise, we'll likely want to retain our dependency for our parent
+            assetItem->importStatus = AssetImportObject::UseForDependencies;
+         }
 
          //log it's deletion
          dSprintf(importLogBuffer, sizeof(importLogBuffer), "Asset %s was autopruned due to %s as part of the Import Configuration", assetItem->assetName.c_str(), humanReadableReason.c_str());
@@ -2537,161 +2429,102 @@ void AssetImporter::importAssets(AssetImportObject* assetItem)
       return;
    }
 
-   if (assetItem == nullptr)
+   Vector<AssetImportObject*> itemList = importingAssets;
+   if (assetItem != nullptr)
+      itemList = assetItem->childAssetItems;
+
+   for (U32 i = 0; i < itemList.size(); i++)
    {
-      for (U32 i = 0; i < importingAssets.size(); i++)
+      AssetImportObject* item = itemList[i];
+      if (!item->canImport())
+         continue;
+
+      Torque::Path assetPath;
+      if (item->assetType == String("ImageAsset"))
       {
-         if (importingAssets[i]->skip)
-            continue;
+         assetPath = importImageAsset(item);
+      }
+      else if (item->assetType == String("ShapeAsset"))
+      {
+         assetPath = importShapeAsset(item);
+      }
+      else if (item->assetType == String("SoundAsset"))
+      {
+         assetPath = importSoundAsset(item);
+      }
+      else if (item->assetType == String("MaterialAsset"))
+      {
+         assetPath = importMaterialAsset(item);
+      }
+      else
+      {
+         finalImportedAssetPath = String::EmptyString;
 
-         Torque::Path assetPath;
-         if (importingAssets[i]->assetType == String("ImageAsset"))
+         String processCommand = "import";
+         processCommand += item->assetType;
+         if (isMethod(processCommand.c_str()))
          {
-            assetPath = importImageAsset(importingAssets[i]);
-         }
-         else if (importingAssets[i]->assetType == String("ShapeAsset"))
-         {
-            assetPath = importShapeAsset(importingAssets[i]);
-         }
-         else if (importingAssets[i]->assetType == String("SoundAsset"))
-         {
-            assetPath = importSoundAsset(importingAssets[i]);
-         }
-         else if (importingAssets[i]->assetType == String("MaterialAsset"))
-         {
-            assetPath = importMaterialAsset(importingAssets[i]);
-         }
-         else
-         {
-            finalImportedAssetPath = String::EmptyString;
+            Con::executef(this, processCommand.c_str(), item);
 
-            String processCommand = "import";
-            processCommand += importingAssets[i]->assetType;
-            if (isMethod(processCommand.c_str()))
+            assetPath = finalImportedAssetPath;
+         }
+      }
+      /*else if (importingAssets[i]->assetType == String("ShapeAnimationAsset"))
+         assetPath = ShapeAnimationAsset::importAsset(importingAssets[i]);*/
+
+      if (assetPath.isEmpty() && item->assetType != String("MaterialAsset"))
+      {
+         dSprintf(importLogBuffer, sizeof(importLogBuffer), "AssetImporter::importAssets - Import attempt of %s failed, so skipping asset.", item->assetName.c_str());
+         activityLog.push_back(importLogBuffer);
+
+         continue;
+      }
+      else
+      {
+         //If we got a valid filepath back from the import action, then we know we're good to go and we can go ahead and register the asset!
+         if (!isReimport)
+         {
+            bool registerSuccess = AssetDatabase.addDeclaredAsset(moduleDef, assetPath.getFullPath().c_str());
+
+            if (!registerSuccess)
             {
-               Con::executef(this, processCommand.c_str(), importingAssets[i]);
-
-               assetPath = finalImportedAssetPath;
-            }
-         }
-         /*else if (importingAssets[i]->assetType == String("ShapeAnimationAsset"))
-            assetPath = ShapeAnimationAsset::importAsset(importingAssets[i]);*/
-
-         if (assetPath.isEmpty() && importingAssets[i]->assetType != String("MaterialAsset"))
-         {
-            dSprintf(importLogBuffer, sizeof(importLogBuffer), "AssetImporter::importAssets - Import attempt of %s failed, so skipping asset.", importingAssets[i]->assetName.c_str());
-            activityLog.push_back(importLogBuffer);
-
-            continue;
-         }
-         else
-         {
-            //If we got a valid filepath back from the import action, then we know we're good to go and we can go ahead and register the asset!
-            if (!isReimport)
-            {
-               bool registerSuccess = AssetDatabase.addDeclaredAsset(moduleDef, assetPath.getFullPath().c_str());
-
-               if (!registerSuccess)
-               {
-                  dSprintf(importLogBuffer, sizeof(importLogBuffer), "AssetImporter::importAssets - Failed to successfully register new asset at path %s to moduleId %s", assetPath.getFullPath().c_str(), targetModuleId.c_str());
-                  activityLog.push_back(importLogBuffer);
-               }
+               dSprintf(importLogBuffer, sizeof(importLogBuffer), "AssetImporter::importAssets - Failed to successfully register new asset at path %s to moduleId %s", assetPath.getFullPath().c_str(), targetModuleId.c_str());
+               activityLog.push_back(importLogBuffer);
             }
             else
             {
-               String assetId = importingAssets[i]->moduleName + ":" + importingAssets[i]->assetName;
-               bool refreshSuccess = AssetDatabase.refreshAsset(assetId.c_str());
-
-               if (!refreshSuccess)
+               //Any special-case post-reg stuff here
+               if (item->assetType == String("ShapeAsset"))
                {
-                  dSprintf(importLogBuffer, sizeof(importLogBuffer), "AssetImporter::importAssets - Failed to refresh reimporting asset %s.", importingAssets[i]->assetName.c_str());
-                  activityLog.push_back(importLogBuffer);
+                  String assetIdStr = item->moduleName + ":" + item->assetName;
+                  StringTableEntry assetId = StringTable->insert(assetIdStr.c_str());
+
+                  //forcefully update it's shape constructor
+                  TSShapeConstructor* tss = TSShapeConstructor::findShapeConstructorByAssetId(assetId);
+
+                  if(tss)
+                     tss->setShapeAssetId(assetId);
                }
             }
          }
-
-         //recurse if needed
-         importAssets(importingAssets[i]);
-      }
-   }
-   else
-   {
-      //this is the child recursing section
-      for (U32 i = 0; i < assetItem->childAssetItems.size(); i++)
-      {
-         AssetImportObject* childItem = assetItem->childAssetItems[i];
-
-         if (childItem->skip)
-            continue;
-
-         Torque::Path assetPath;
-         if (childItem->assetType == String("ImageAsset"))
-         {
-            assetPath = importImageAsset(childItem);
-         }
-         else if (childItem->assetType == String("ShapeAsset"))
-         {
-            assetPath = importShapeAsset(childItem);
-         }
-         else if (childItem->assetType == String("SoundAsset"))
-         {
-            assetPath = importSoundAsset(childItem);
-         }
-         else if (childItem->assetType == String("MaterialAsset"))
-         {
-            assetPath = importMaterialAsset(childItem);
-         }
-         /*else if (childItem->assetType == String("ShapeAnimationAsset"))
-            assetPath = ShapeAnimationAsset::importAsset(childItem);*/
-         else
-         {
-            finalImportedAssetPath = String::EmptyString;
-
-            String processCommand = "import";
-            processCommand += childItem->assetType;
-            if (isMethod(processCommand.c_str()))
-            {
-               ConsoleValueRef importReturnVal = Con::executef(this, processCommand.c_str(), childItem);
-               assetPath = Torque::Path(importReturnVal.getStringValue());
-            }
-         }
-
-         if (assetPath.isEmpty() && childItem->assetType != String("MaterialAsset"))
-         {
-            dSprintf(importLogBuffer, sizeof(importLogBuffer), "AssetImporter::importAssets - Import attempt of %s failed, so skipping asset.", childItem->assetName.c_str());
-            activityLog.push_back(importLogBuffer);
-
-            continue;
-         }
          else
          {
-            //If we got a valid filepath back from the import action, then we know we're good to go and we can go ahead and register the asset!
-            if (!isReimport)
-            {
-               bool registerSuccess = AssetDatabase.addDeclaredAsset(moduleDef, assetPath.getFullPath().c_str());
+            String assetId = item->moduleName + ":" + item->assetName;
+            bool refreshSuccess = AssetDatabase.refreshAsset(assetId.c_str());
 
-               if (!registerSuccess)
-               {
-                  dSprintf(importLogBuffer, sizeof(importLogBuffer), "AssetImporter::importAssets - Failed to successfully register new asset at path %s to moduleId %s", assetPath.getFullPath().c_str(), targetModuleId.c_str());
-                  activityLog.push_back(importLogBuffer);
-               }
-            }
-            else
+            if (!refreshSuccess)
             {
-               String assetId = childItem->moduleName + ":" + childItem->assetName;
-               bool refreshSuccess = AssetDatabase.refreshAsset(assetId.c_str());
-
-               if (!refreshSuccess)
-               {
-                  dSprintf(importLogBuffer, sizeof(importLogBuffer), "AssetImporter::importAssets - Failed to refresh reimporting asset %s.", childItem->assetName.c_str());
-                  activityLog.push_back(importLogBuffer);
-               }
+               dSprintf(importLogBuffer, sizeof(importLogBuffer), "AssetImporter::importAssets - Failed to refresh reimporting asset %s.", item->assetName.c_str());
+               activityLog.push_back(importLogBuffer);
             }
          }
-
-         //recurse if needed
-         importAssets(childItem);
       }
+
+      //Mark us as successfully imported
+      item->importStatus = AssetImportObject::Imported;
+
+      //recurse if needed
+      importAssets(item);
    }
 }
 
@@ -2796,7 +2629,7 @@ Torque::Path AssetImporter::importMaterialAsset(AssetImportObject* assetItem)
    {
       AssetImportObject* childItem = assetItem->childAssetItems[i];
 
-      if (childItem->skip || !childItem->processed || childItem->assetType.compare("ImageAsset") != 0)
+      if ((!childItem->canImport() && childItem->importStatus != AssetImportObject::UseForDependencies) || childItem->assetType.compare("ImageAsset") != 0)
          continue;
 
       char dependencyFieldName[64];
@@ -2833,7 +2666,7 @@ Torque::Path AssetImporter::importMaterialAsset(AssetImportObject* assetItem)
       {
          AssetImportObject* childItem = assetItem->childAssetItems[i];
 
-         if (childItem->skip || childItem->assetType.compare("ImageAsset") != 0)
+         if (childItem->canImport() || childItem->assetType.compare("ImageAsset") != 0)
             continue;
 
          if (childItem->imageSuffixType.compare("ORMConfig") == 0)
@@ -2890,7 +2723,7 @@ Torque::Path AssetImporter::importMaterialAsset(AssetImportObject* assetItem)
             {
                AssetImportObject* childItem = assetItem->childAssetItems[i];
 
-               if (childItem->skip || !childItem->processed || childItem->assetType.compare("ImageAsset") != 0)
+               if (childItem->canImport() || childItem->assetType.compare("ImageAsset") != 0)
                   continue;
 
                String path = childItem->filePath.getFullFileName();
@@ -2967,7 +2800,7 @@ Torque::Path AssetImporter::importMaterialAsset(AssetImportObject* assetItem)
       {
          AssetImportObject* childItem = assetItem->childAssetItems[i];
 
-         if (childItem->skip || !childItem->processed || childItem->assetType.compare("ImageAsset") != 0)
+         if ((!childItem->canImport() && childItem->importStatus != AssetImportObject::UseForDependencies) || childItem->assetType.compare("ImageAsset") != 0)
             continue;
 
          String mapFieldName = "";
@@ -3090,7 +2923,7 @@ Torque::Path AssetImporter::importShapeAsset(AssetImportObject* assetItem)
    {
       AssetImportObject* childItem = assetItem->childAssetItems[i];
 
-      if (childItem->skip || !childItem->processed)
+      if (!childItem->canImport() && childItem->importStatus != AssetImportObject::UseForDependencies)
          continue;
 
       if (childItem->assetType.compare("MaterialAsset") == 0)
@@ -3195,7 +3028,8 @@ Torque::Path AssetImporter::importShapeAsset(AssetImportObject* assetItem)
       TSShapeConstructor* constructor = TSShapeConstructor::findShapeConstructorByFilename(Torque::Path(qualifiedToFile).getFullPath());
       if (constructor == nullptr)
       {
-         constructor = new TSShapeConstructor(StringTable->insert(qualifiedToFile));
+         String fullAssetName = assetItem->moduleName + ":" + assetItem->assetName;
+         constructor = new TSShapeConstructor(StringTable->insert(fullAssetName.c_str()));
 
          String constructorName = assetItem->filePath.getFileName() + assetItem->filePath.getExtension().substr(0, 3);
          constructorName.replace(" ", "_");
diff --git a/Engine/source/T3D/assets/assetImporter.h b/Engine/source/T3D/assets/assetImporter.h
index af4fac28b..0c176840a 100644
--- a/Engine/source/T3D/assets/assetImporter.h
+++ b/Engine/source/T3D/assets/assetImporter.h
@@ -492,15 +492,20 @@ public:
    /// </summary>
    bool dirty;
 
+   enum
+   {
+      NotProcessed=0,
+      Processed,
+      Skipped,
+      UseForDependencies,
+      Error,
+      Imported
+   };
+
    /// <summary>
    /// Is this asset item marked to be skipped. If it is, it's usually due to being marked as deleted
    /// </summary>
-   bool skip;
-
-   /// <summary>
-   /// Has the asset item been processed
-   /// </summary>
-   bool processed;
+   U32 importStatus;
 
    /// <summary>
    /// Is this specific asset item generated as part of the import process of another item
@@ -564,6 +569,10 @@ public:
    {
       return o.getId() == this->getId();
    }
+
+   bool canImport() {
+      return (importStatus == AssetImportObject::Processed);
+   }
 };
 
 /// <summary>
diff --git a/Engine/source/T3D/tsStatic.cpp b/Engine/source/T3D/tsStatic.cpp
index 2ed98a265..9b093f476 100644
--- a/Engine/source/T3D/tsStatic.cpp
+++ b/Engine/source/T3D/tsStatic.cpp
@@ -1015,7 +1015,7 @@ U32 TSStatic::packUpdate(NetConnection* con, U32 mask, BitStream* stream)
          con->packNetStringHandleU(stream, matNameStr);
       }
 
-      mChangingMaterials.clear();
+      //mChangingMaterials.clear();
    }
 
    return retMask;
@@ -1670,53 +1670,49 @@ void TSStatic::onInspect(GuiInspector* inspector)
       {
          StringTableEntry materialname = StringTable->insert(mShapeAsset->getShape()->materialList->getMaterialName(i).c_str());
 
-         //Iterate through our assetList to find the compliant entry in our matList
-         for (U32 m = 0; m < mShapeAsset->getMaterialCount(); m++)
+         AssetPtr<MaterialAsset> matAsset;
+         if(MaterialAsset::getAssetByMaterialName(materialname, &matAsset) == MaterialAsset::Ok)
          {
-            AssetPtr<MaterialAsset> matAsset = mShapeAsset->getMaterialAsset(m);
+            dSprintf(matFieldName, 128, "MaterialSlot%d", i);
 
-            if (matAsset->getMaterialDefinitionName() == materialname)
+            //addComponentField(matFieldName, "A material used in the shape file", "Material", matAsset->getAssetId(), "");
+            //Con::executef(this, "onConstructComponentField", mTargetComponent, field->mFieldName);
+            Con::printf("Added material field for MaterialSlot %d", i);
+
+            GuiInspectorField* fieldGui = materialGroup->constructField(TypeMaterialAssetPtr);
+            fieldGui->init(inspector, materialGroup);
+
+            fieldGui->setSpecialEditField(true);
+            fieldGui->setTargetObject(this);
+
+            StringTableEntry fldnm = StringTable->insert(matFieldName);
+
+            fieldGui->setSpecialEditVariableName(fldnm);
+
+            fieldGui->setInspectorField(NULL, fldnm);
+            fieldGui->setDocs("");
+
+            if (fieldGui->registerObject())
             {
-               dSprintf(matFieldName, 128, "MaterialSlot%d", i);
+               StringTableEntry fieldValue = matAsset->getAssetId();
 
-               //addComponentField(matFieldName, "A material used in the shape file", "Material", matAsset->getAssetId(), "");
-               //Con::executef(this, "onConstructComponentField", mTargetComponent, field->mFieldName);
-               Con::printf("Added material field for MaterialSlot %d", i);
-
-               GuiInspectorField* fieldGui = materialGroup->constructField(TypeMaterialAssetPtr);
-               fieldGui->init(inspector, materialGroup);
-
-               fieldGui->setSpecialEditField(true);
-               fieldGui->setTargetObject(this);
-
-               StringTableEntry fldnm = StringTable->insert(matFieldName);
-
-               fieldGui->setSpecialEditVariableName(fldnm);
-
-               fieldGui->setInspectorField(NULL, fldnm);
-               fieldGui->setDocs("");
-
-               if (fieldGui->registerObject())
+               //Check if we'd already actually changed it, and display the modified value
+               for (U32 c = 0; c < mChangingMaterials.size(); c++)
                {
-                  fieldGui->setValue(materialname);
-
-                  stack->addObject(fieldGui);
-               }
-               else
-               {
-                  SAFE_DELETE(fieldGui);
+                  if (mChangingMaterials[c].slot == i)
+                  {
+                     fieldValue = StringTable->insert(mChangingMaterials[i].assetId.c_str());
+                     break;
+                  }
                }
 
-               /*if (materialGroup->isMethod("onConstructField"))
-               {
-                  //ensure our stack variable is bound if we need it
-                  //Con::evaluatef("%d.stack = %d;", materialGroup->getId(), materialGroup->at(0)->getId());
+               fieldGui->setValue(fieldValue);
 
-                  Con::executef(materialGroup, "onConstructField", matFieldName,
-                     matFieldName, "material", matFieldName,
-                     materialname, "", "", this);
-               }*/
-               break;
+               stack->addObject(fieldGui);
+            }
+            else
+            {
+               SAFE_DELETE(fieldGui);
             }
          }
       }
diff --git a/Engine/source/gui/worldEditor/guiConvexShapeEditorCtrl.cpp b/Engine/source/gui/worldEditor/guiConvexShapeEditorCtrl.cpp
index 0e494602a..9350f39e0 100644
--- a/Engine/source/gui/worldEditor/guiConvexShapeEditorCtrl.cpp
+++ b/Engine/source/gui/worldEditor/guiConvexShapeEditorCtrl.cpp
@@ -236,7 +236,7 @@ void GuiConvexEditorCtrl::setVisible( bool val )
                bool isPortal = (scene->at(c)->getClassName() == StringTable->insert("Portal"));
                bool isOccluder = (scene->at(c)->getClassName() == StringTable->insert("OcclusionVolume"));
 
-               if (isZone || isPortal || isOccluder)
+               if (isTrigger || isZone || isPortal || isOccluder)
                {
                   SceneObject* sceneObj = static_cast<SceneObject*>(scene->at(c));
                   if (!sceneObj)
@@ -247,15 +247,18 @@ void GuiConvexEditorCtrl::setVisible( bool val )
 
                   ConvexShape* proxyShape = createConvexShapeFrom(sceneObj);
 
+                  if (proxyShape == NULL)
+                     continue;
+
                   //Set the texture to a representatory one so we know what's what
                   if (isTrigger)
-                     proxyShape->mMaterialName = "ToolsModule:TriggerProxyMaterial";
+                     proxyShape->_setMaterial(StringTable->insert("ToolsModule:TriggerProxyMaterial"));
                   else if (isPortal)
-                     proxyShape->mMaterialName = "ToolsModule:PortalProxyMaterial";
+                     proxyShape->_setMaterial(StringTable->insert("ToolsModule:PortalProxyMaterial"));
                   else if (isZone)
-                     proxyShape->mMaterialName = "ToolsModule:ZoneProxyMaterial";
+                     proxyShape->_setMaterial(StringTable->insert("ToolsModule:ZoneProxyMaterial"));
                   else if (isOccluder)
-                     proxyShape->mMaterialName = "ToolsModule:OccluderProxyMaterial";
+                     proxyShape->_setMaterial(StringTable->insert("ToolsModule:OccluderProxyMaterial"));
 
                   proxyShape->_updateMaterial();
 
@@ -707,8 +710,6 @@ void GuiConvexEditorCtrl::on3DMouseDragged(const Gui3DMouseEvent & event)
 
                float zRot = mRadToDeg(newSufRot.z - curSufRot.z);
 
-               float curZRot = mConvexSEL->mSurfaceUVs[mFaceSEL].zRot;
-
                mConvexSEL->mSurfaceUVs[mFaceSEL].zRot += zRot;
             }
 
@@ -2005,8 +2006,6 @@ void GuiConvexEditorCtrl::setSelectedFaceMaterial(const char* materialName)
    //run through and find out if there are any other faces still using the old mat texture
    if (oldmatID != 0)
    {
-      S32 curMatCount = mConvexSEL->mSurfaceTextures.size();
-
       bool used = false;
       for (U32 i = 0; i < mConvexSEL->mSurfaceUVs.size(); i++)
       {
diff --git a/Engine/source/scene/sceneObject.cpp b/Engine/source/scene/sceneObject.cpp
index f60321097..233030331 100644
--- a/Engine/source/scene/sceneObject.cpp
+++ b/Engine/source/scene/sceneObject.cpp
@@ -631,12 +631,13 @@ void SceneObject::setHidden( bool hidden )
 
 void SceneObject::initPersistFields()
 {
-   addGroup("GameObject");
+   //Disabled temporarily
+   /*addGroup("GameObject");
    addField("GameObject", TypeGameObjectAssetPtr, Offset(mGameObjectAsset, SceneObject), "The asset Id used for the game object this entity is based on.");
 
    addField("dirtyGameObject", TypeBool, Offset(mDirtyGameObject, SceneObject), "If this entity is a GameObject, it flags if this instance delinates from the template.",
       AbstractClassRep::FieldFlags::FIELD_HideInInspectors);
-   endGroup("GameObject");
+   endGroup("GameObject");*/
 
    addGroup( "Transform" );
 
diff --git a/Engine/source/ts/tsShapeConstruct.cpp b/Engine/source/ts/tsShapeConstruct.cpp
index 4fcc54ba2..08dbc21c2 100644
--- a/Engine/source/ts/tsShapeConstruct.cpp
+++ b/Engine/source/ts/tsShapeConstruct.cpp
@@ -556,6 +556,24 @@ void TSShapeConstructor::_onUnload()
    mShape = NULL;
 }
 
+//-----------------------------------------------------------------------------
+void TSShapeConstructor::setShapeAssetId(StringTableEntry assetId)
+{
+   mShapeAssetId = assetId;
+   mShapeAsset = mShapeAssetId;
+   if (mShapeAsset.notNull())
+   {
+      Resource<TSShape> shape = mShapeAsset->getShapeResource();
+
+      if (shape)
+         _onLoad(shape);
+   }
+
+   if (mShape && mShape->needsReinit())
+   {
+      mShape->init();
+   }
+}
 //-----------------------------------------------------------------------------
 // Storage
 
diff --git a/Engine/source/ts/tsShapeConstruct.h b/Engine/source/ts/tsShapeConstruct.h
index caaf6ceff..465861599 100644
--- a/Engine/source/ts/tsShapeConstruct.h
+++ b/Engine/source/ts/tsShapeConstruct.h
@@ -222,6 +222,8 @@ public:
 
    void notifyShapeChanged();
 
+   void setShapeAssetId(StringTableEntry assetId);
+
    /// @name Shape paths for MeshFit
    ///@{
    static const String& getCapsuleShapePath() { return smCapsuleShapePath; }
diff --git a/Templates/BaseGame/game/tools/assetBrowser/art/animationIcon.png b/Templates/BaseGame/game/tools/assetBrowser/art/animationIcon.png
index 381dcee849583825fed664f50d9314fda2d8eb3d..d8f3e35b9fba11279a49bd465d3b367e2d62933a 100644
GIT binary patch
literal 12242
zcmeHtWl&v9*XG6{xH}vO?iSqL-Cc6f;O-D0xCIaH2~M!!?j$%QxCJM;+jnyBow+qt
z?>Fy#YpSMds^-V8K6~}ktDj!I`{}iJpGZ|@8Ppd<F8}~Qm6MfJ2LNcuPiO!U9#UL*
z&D;S1VT_NauA91<C&<ag(bDD(806;d1O|b<Y%Br5YvJgFPAaiLs?;-k6d80IA=+5K
zzEB8Rz%h2WrksyY<3YI&bum>EiZn1!0ux&Ie0zNG6rH;u@6lXuEK`}2D|i->gumP=
za(+wd7Z4Em*f-uP(stb8kKxUDnze%N^XT{0EBB@NLtE$S4x4wUpJ#ztF8W+N`Pg`*
z`Lp4gon$U@@riL)?s(+(jwF3RRn}_f{LYB`#nmH@@ap;X`7QRls!ykkrFeFq^1%T+
zy9VVU^Fnt^5sQ<e8om-I?)kaT9wy<^131iKTe+*Jq~NLN1e)>9TO+=2BFD+eH`!CP
zByq{?u*UH!ZwjA#b61Jm?*ndf>z}iJos_!;`d$t<-j9gK=Auuj=#{PJ1l|VFnb6+R
zSE~H#XmvSSt$OIa=LvgyOkUQxyLeuiK5p>z;M6HG6iK@KFmfKXnObn^SAJ&Q!5>v~
zE*{@qIE|N?OxF3hQQM1{sJW8Ri^REPI)09pNwIBRdrGqD@mj~x<30OEfO_U7A`iEE
zfO;vwO`Yh)6F{us#UhY1YER>xB@!%QvG!VXTqN*Ir_Y+d4<+nsXMdEllon~>N$|x%
zWbcsdm)yKm+Afp$+`!~{N%&Fh?QgK9CclLG8P-kuQ*tC}(U=4~+i@0dvw|?3_j*jl
zDPcO^X^Mj-nFsKogAb{!IWE#&3}1tivCu<e_$JMnr+N)DkLyoJh!p%*;ZZa^xJ;B{
zmnM>_7<a@U>z6*|>!}YHC+q9)fs^$#w8Cc>%2eGOXIvO78|PZ=3cu#~{3@Pb@i{IW
z$CQC~AI&3|A-5PCmZG)F@$+@*%3`dlKVvAbYP=(I_^Nb!*fv_#dekwPL!0BayQ!ff
z@EF6%Oi=v#N0gS`oc;H<<OL<3RhI+%UsnRZ9#R`r^aIati1m<jEBa|Q_-p(}iH;ku
z+@nCe^dp3X(R>Lf(sM%uVU=08WG-<dSuWc$I1f_rddXSX$?P2I%zZAsO-ue9I~xzz
zTVETVwwRwxICqj;I@6n1w~uu61PXQ@Umw~_z|GRO9KYkY$aP-kAZRqcqTha4|8cu|
zyLK%6yd(MSsO)zBMaYEWCi~ujKMycAi%W*?H}oJOy~>c4MzjkxpU&21ac_bt7Q8~V
zBJDV6!X@BTFKyEpWEP;R0+3Uk8P0wsyKL}U+DRErUCNp`y=xwTJC@KJr86&DRlK;R
zPc>Uw<iX)<!Og8e`3QPxFQ566cuCmR`A6Fi0>k{yq!2k9goC5I0nvlYdThb3$=hZO
zg;Q_pes+27F5Do_kS(FPqA8qn)DuB}E?-#gN+@YoQ)jdvPo5$b%0`QvZ%`mi3qe1U
zKS3N2Vlk4<?tDo>rOO#d><QJiF#@+1(Of8fEs3|qcDpjt@Xqjt7V7rs$K%6*h>ycT
zizPAt7sYi=sa&QlkK+rA75@Av7j%uzREbO(8IlRLah~2<=_?lRH&uqMr3q2UvMR)V
zrNnA1gNWjkWcYw^;dl51IisQJruKXGpGB{Y%J7w85uiGxPZm%^HYC{gCU7_5)Q+R1
z!G@E82j1Y;{2wPT&R;yL5`-pK7;!~|Zt8ijKf$3{W8NI%*enc=Z&%W6rhn0YX@Yk)
zY(K~`Pqtd690S6pbG<IkziTE~<ZV88MB9H<4fmtPs99X4+n!SK+w?Aw%qrz44K7oX
z@$-MW)vO8`AGFbQnN0ZD!>?A(zAQ{XFIABtUs7{ZrXPxP)Gpp9hRQLgvgon#4d<s|
zAD*@tiai5z^X>r$<N3}s?sbl%=%+y);#YVCT<=%e<mSm3)%sAVlU?V<S+#Z%EVa{?
z<wP2rBC^YPB|kruGYE6xkr?LmoIl0qEa#G*EW74yuvE&VTzZWbyoseSKB#5!G+i+w
z>b2tU#W$F7=i?Om!E2u~RRJY_)RS-<XW6`{?o|>Pne={f`>8ELMVFyo;n$Y}%!;NM
z53*I<+R;vve$@KnC^@fN{$?3t#Kj3Jd<?Fj`k3Z4M;3juf#_(4Zj89>0e-@Cls?nY
z51-AQT}@hmkuQpd!XK3#VZL-1@dPn9(Z!}8Y~Lk*89>qvIgK^J4GM%|E+Pm9sR{y>
z6eni@>%Dk8v#BWx!dbuz8DlcZbj=jF1<E)q=`lWcJrzyvJ4;r!tS^XujLmoRNXxzh
z#nl$yIDRb5u;6Mpy&9$j6=W<gq3w11YrQ7%k0e@<wx7l#OyXL8oP(K|xGpAWd?d|t
z3w)bL4y3I4gDzn5^to>_#g}<d{4p<v$2<}57y*A9<Xycdf2boRU8=1Y_utWKDLpxd
za1t}wd%&5rnip_aXA0GF#viG6r`Jlt^ufG!zOJ%n!h|!iP>S>9#5MaY3HM9iEi~O|
zwi2*s_zF_wyH?r3-j{FrnGf7_EXibHKLn=HQg3ECsALI;Km5XkOCR7ljP{|C_J@)v
zVl-KJTYFX4BGXao6#11xUz&pSTZ*U9kVSGW4m5YX9s`rWCTv!<1%VSjNdLo@4XN8H
zskgg=Y`AZ_b+i=bmoM#Xw`r<tpBAOHG&gBqmr52Enn><G<qFdxXg*TlC9a69Z`dQF
zZqPN$Nf<`Pm*9=4q)oNVNO2NC(Y)Nac#eGSwH6Hjw9g#t#GHbPY%gfP!e%@y=~t=G
z!53xcZCml6YEJOsAz8N}v`GBKTNdY6jZgS1+GSWvT@CiQ&#@wE8tl0VSFu)(t!ylF
zzFh_PU)x9QVv)9{PJG$(BfmzeAd|~)FAdOtn5$UGU~Tk%4s(FL>Tg1CNjy648h?a;
z3<^&&8y47W&=N9^W0Z~pL5JB@@zo@^Z?F(PrAlP`{R;4opt&G(L8$Kr=uL?lna<cx
z9X|@b$bqIl<&0VRnn6>mU*BGmMRU}0ntx6Lq_HVhqkSPT8L5lWo)nqwwF)JNJ~dHV
z6E>RYF=$@5aj`b}rKY5;2OQTY`s?F{-8BUtT|<p)7U#6|(N=#LV*N}bh;frgnEwvd
zSFcq(sFHSzkUEK0ylo}OS^9zGHF=TrPQhqRSFH3A9A@yz*~r4TQLGV+8rq5O<4{`!
zkqK}E%I!VqUQO2C2t%8dunOq2q(Nm-?V&eaC?}V*$B144csj8kbJvCM;t!c^@%)Hx
z(2ZXw``gF`mI-TkWV9GDcR#f4GQh+rJZfHRwC%Jt+`H~czi^1xImdBLcnK$(2u&R!
z8O2qAm0x&c4$vS9Z|dt3YlbLo8`Hh8#_;_7R(mD=$;BSNe!sV_*hAH>iJpa|k3s{~
zp)<|Dd1bGS8yJu-KxLb(-hewQPb(8nFJJBrVk7ITp_5=tkn-#Q`DwpLv!Y5(tg71`
z6D>gtA*-WWbDlxifxBz})9qEo*>NmIt0IC}Ep90M!DFMkZ<$qP+A;};;DgrDb+pyi
zb4pDm+Y!8?v++Ag;fH{jQB$J6vpBcKGFh3|smt&YQH3eKWGP+k_8RT_Th$)nH}b;O
zSi9XKpVjaTUD@6@v?@85O#4actMjNjKhJ|Z1c;r*0CnD!wsb10Z{V;soiUtwr`l^2
zMBfCOJdR4a8D@KSK}pU#R+wbPWTA=oE!*qGjNxx%F_9HGZGuTA;45Fp!R+EN#1Z2Y
zr!k-e0~i$QL$fbp;N-LkreE}X)5Bb7VY=(^qAsHF+joj7@FEP?YH8ts7OFMgHGqeJ
zJl$CB{9LdR2BwU{&l_u%d$k5G5f4AWO6bBL^9SCZ2mG|k+iwrhJfe@Yd&KcYWxT;H
zt>=&wqjIGCcxf6|S`8iij*m#$VG#JT_BLwyTN+GZyMA^h^ta*RPo(?bzt&(hdiioe
zAzB~}^jPI9-dB;vV&!d%abBSnQ{!SSz!JLe$p(|vcv2=aw+2e8(Kh(u)vbNjr$Qp0
zx;%A@F)exg5|?&nka+-l{h%1nPO2+_0mZ0)>RPHi1fmujSRl6dk94+5{*EDqtf0D}
zSei66S3+c#&-Wo!eDC=)X#pC&bZf$FK^vP86IT_CE=AcBU_t|5Jj^Mhlpb~6HKcGy
zNR^^*=Oz}h-8v34D`^(uOy?trQ6|?xC#{NQAhrJ5F_Bg7K4~1yPW<csSO-@FrG+>+
zREf;V_#t#?=DiZL4<5q{PJS_r8n?kmCW4uvbf;p>Pb%Z<!=wx$LtAJ#*x>{8`^(I9
zyrvi&^Bb5n(D-8nABs`-X3INU(EZ+NBI1#J_{@Pr)SJ7m(Pe?rlj?D)$;N?+v-94y
zu=_+>lUOeW^>RV9nAtgS11X%n4f(s6N;wt<DqQGz1U#FHh<+J?HM6+0H_o8wuq0CF
zg%@W`&YaI)gYc9xtsGM7Awm#6t^$<(R3tXo%P+J?nM^yhFh@uX`fUV4qC=_srpF*H
zbpu;7HpNJKluU%h`lsa_DMtf^Qw(=M3@q~?%7!ebxh|wknNj7vmwq;3u80;UtgVY#
z^|~fC`pWY%+fJw0oVqxc6k{k46U8vp9L)E#M$>3Xl6Ym<Mf*-aN{T-fe$I1M7S@T(
z*U#8GoG73|elLQ<I}`JRFNda+#R~?(ic^pYBtJ{jsiph1*Ef`vLpnwY{eqyD*0w%y
z7Z|Fjk)k9O^T_7XkSZkWhXwUxm{DM5NZ)2r9Y<X!Y<={)q6!;wM<+G$Wi*2t(-cmL
zEiL5|b=3vs-HrJyWsPBxDp;%Hi&fahApX#HOq$IBW64F7c`ITRunH&&>rp7|=7)|Z
zrBXnrSPnNB@A_D_&8cl_1#dMY+;1a?wt|AUKk>gVW(4_V@SmLOtlbg7HXQ@sD0KX>
zjJc20oGAG}jG&~zkF7Bdm@7<kqRFHtTmc`bL5X<zM8p&FAthEu3I`?cjllq6ZFfY3
z1ibS74N?@;!%RwZWJ`Y9KwZ!b5?v`${Fs<=SZEXW`S&|OTEd!~f>YChERt(vqO8k3
ze1DKnJ}j@&iCW%Z+LG*TbO&{g`jOmX{VW~`xkd?B;q}93V!&ZxahCMc7-FWK-kCLw
zG4d+|VsZSJ&oQX0@I$MuCvI7@j`m31(`1SzC&S8~PKIMHGBS91tg4UPY{C?>szomc
z<4Pn&sGKMU``Wri$FgN^ueQXb<T?**^)%sxq*u8qoO%pJ>`;-ddqF)!bzyMRZ$@Rs
zI<({jB;}(AG|=;0Bonk2<*BC6ih6bfPq`*R;j+>RehxKom4c|2YfLI4q!aOpDSXzt
zWj(DNfQs^T{VrU->H=&w6R8(jy;`V>KMve-oO51AGiVzdNx9u7%o=AO(c3)U^#TS}
zaMl4e5%x2*JT6XXk|0Z?T!O9oO$Xfyr%z&I-Aw&eE-8q84YWZYD~@gWz2L;1UBJRh
zSBu`1MOy6Rjtv~FkZ`$NU_l?RivUHwcIq0V$v}xFeM3EUD`dUB#rI!kvo^&sfI1m1
zBV@)CYF~vfv+st9BV!~YlLxD#C&Sl-enpFq>KGDKzF<N~#9b0r|BNEeL;ZbEV4wBI
z2dzzdSjCJyD<p%=T*gp$GGg#;Mavc6o_cy*s?rG7PQ-YR^isP0*da;WKBKX6_}lOM
zA4y+g)9aharr709nw3^CKTD_6@?*wuRlqd_HwqY+zxy$JNDE>n8_1Zt!Uajekn9ce
z5^XZSCc2oyW12&ISKQ(LQmQjUQJp5$!M(^&+uL|qGdR0BoMDtp@?8!;7oNbHcM63*
zy?d~o712aUmTb%viR_D+2sketCrkH_x<o9(A^05Q?3O=Tm<2aNBcSz3fsqhE9jyC4
z(rsG4?-jXu8gsO)d5Zv3Wq|EVh9Vf}MZ)wZrnv4`AeJvBwAJ{E2!-RgT*uolNV!XW
zBAq{gbQH982d4zWoR!LL-B?p%-xC#l#j2uXRCCQ#g;U+c;W_%TAHi)C=4;;U6tO0f
zC{pGY_HHtmIHiRteZL2GpFv3-KLLmEh2gKNh=+`z0Pih87lt*hpdhGUWnP)sR($`J
z6@?Yv9szVBWgg<eP~`a96a8XbR!?X$;oc%c7+A>@F7N3yQ6ZDhxy#-*o}B@|q>t_?
z?pvr)zEV0j1&<`GzQ$^VgpWv96c?3|e46hq;?b*(Lr_jqeU9uv!#1qU%T7~6SNx9P
zJ~|wmwTaET-S^}&AuAf8RSrQtB?c6>Rzvv%FJ7coWkTEjpu1hKxnH35nWL=wdH(is
zvcSlnLWhE-^|ha39ld~tgRMLUpKkmJOrTSO<USSw9o$dtvE0J1CDZ09`R|+=X~oW{
z;2WS}Lt<92hEy2i2UT<TOJb74N>E82psrBXHj!tjQr%hmQMe?HNu-0})z`OJ9tAM?
zMR#q)DR#h8^&JW}2rxCOGkF9x1{0h@9`ut|7Wf9gI8)KFCVI$s^3K>mQU_%3OigOc
zDOi=tls9hk>u05D_esN2*@<Bsts~e9XX_2QoHgCx9S~|{otgv|B$J%P@f3n5OP!$E
zV!aYlYOHc$j7F$r-9BUvy)ASbS-_4Zg;q+>lvovwiC`*;m@hD6X_ut#qBIoH$jOj4
zi=xx`j0BO^ff?<bG;L*7Nht|+q@pqe-cs|yT_Y+4CPcqV=U`f96N<(W--c#|T{4^0
znS~SSt^*n;qI`F2{nwW8T6J^D@grnYte^R7ZRL=3(5Skb6-~ac1joGH5sd;RG?2-G
zMHqWp9+9GXO=*NFM?4F{n@9{UWGtuCta{PA3)!WPTGr7C2t(zvnXR%d8P)jv>qV1`
zxh6|t#CK(XI8f`jjfMCi>h{qbaoDXN7$eUb3^lfg%t8^ZbYBGFM^yXEOD1bAZ}iZ=
zfC7(P=qksybZ2Zl(m?^qs*OPPX}H5B3BIMw1o=KPsDDmfG@WIgH!-Yt%VM%exIa9=
z)a?{F`GotxUEjX}9T8>(`wT-Ejn#SmHm)xxdXyx{lUG70#2q%-m>+h1A-^=dk)bHV
z-SKO3OADR2+mH0AHxpFV4|VmC-*P$TFBG@V^7B<E>0G_J-W1te3oS(;do34aFV}zK
zAK_N8?y-Rp?wMxU2*m`CoP`>0=<&~@is(X#ii*Z!OWeJh;Ry|)JSHASL!+wJdY#v5
zmnHzM0h5ScaSgX1E|;~HckfB*+eHdRIGAxIKSdD&NQ}(j*>n>@nZuRq-Y^)w(HGfO
zFMt_ke|7P;s8qMMEG=kV3N%s$=JZN`4?6kCJ?1{EWSYkkz%&>9ZeW~=Diq3#cZ~?$
zxM4Vb(=Rc}0ZFHwTAC4guAy+UzQ#GB(q?Z(TeOJ$w1hj8u|XhYD|gI)Iv}u+y|uAl
zFriAoGZEYTphRd~4tZ)Lg$VY?S|f6~$vU=rb8#Ux=@60)Ib85LZxwQGaO8PLS#sDF
zF$cVDcfFSld}{_R1r|u`6f9~@nTq-iM7x>4VI<Y0MAT(RdS?3xq03&s(m+3|Ih%h(
z519mx%g#Qo=qPZ;b&fIsN!4NX>5EdSMskbmj9c|pJ~4YW06UPy0yXwBK@yGl<(#-f
zgaxx%oz11J9zlc%!kRoev<oSIKm&u9(6=bqUi`N#*g6^!i@X4#k|9mN8}^mCoLFTM
z0!;h4>w#{2Dh_j2uZt#`tzd~YY7VjG8G<*`XL~tX%Rcz@?qwU41M_t~iOZi_S(dpM
zTO1gv7rFxQv8GQ?n`@zrGxL;+j)~feaYd^QsI^PUyJy{0(`#f;u(YDkJ2DSfG#eb0
z(aB-B-<YafOUIc_WTok4vo)-xePWSk%FVzyEP9Wb^TdS4U5kOB#r#~zU)4BNZWdBZ
zl$g^s?=L_0(M)&u2h3`H`t;RHuSBpSn5ami&Y7VjHx1{O!TVE;=$BB6H<~1h1hrnt
znI5s^kJ|)$l139OsDdk^gu8BM%NOoGb3z2?eskzJAQ<A}WIP`X*GcEb8fbViwt}el
zIH3+B=hXT%LeVh^(O!l;?3A<ODbX96G4I~a#!@Rab-FEU?w;(DmA>V9I~)Z4;GfxI
z(XQSXgFM_2D%!Wwm`dI-h*e%hd#QEw<EVd1AQX87wL@4xxTnc(5z!JF>rM+NWbTj<
z`mmY8HjC9gtwC1Boe}=KZZ)wgUHs#clbnyN-Snf-mb;Hcg|*sS=@5hiy`#hM_YF|M
zS;Zh?RYpUzaDP2-C74ls<f%Ct=`_<#0=WboM#1z=^bG?Pmof*LS}EyBg|A9D%8r?B
zsj%k}_ScJ#u!@-S<<PT|Xe4i@>h$@iD($`tx3Gg-J|X$kS5f~Ys9xli7>m48_wlW^
z8h25HLfaC%)t!Lbd8x3j+izLSo2D1n^(JUEDOWimo`23f?pKzNL~N(#M=>7pb|iP2
z8Gsxt`U&L9sTk5Ho#C+ji<max2<dX_GY8Cc2|LDkQMVti&QTYF)<QkTMTL?GG|_Xq
zS#yZZ&}90)hvdzgFbom?0evN_*RUK9Okta|UMRVvKe$uery=jko|TA}Y*`k#Av;cJ
zAEUM<Oo9Fmdfzw`-Hk)mtsD}>?Tqssg;^ACDlr;u8wcOc3B3S!Xsk-fY(*p<^&`|n
z@vbbWHq|RA#MG6@Z%>>1fp9n29vpQ8zH7D#uMy_YFZvkUNnpx=da`y;E_jMyl1$-(
z*e>$<*jnW%#osc==d5i1qftS+)47&5-%{3y>j7)~yASy|vRQjH+g7dg&q<jG&qAK$
zPdkz;h5Tv=E03%X@K+wj-uWB=02O8<A)zWKA@M)XWgw?9S^kMavb~}t{U!!>S`26&
z7|uhg*-R1S{c2^pu*k)g6J;U8#U>L)6mrhaIEKh*0ZiJYhFR|JPPnk$=omaav{Lx=
zr-5?$QZWdFk6xa~&ev!s+zg8BEi{1Ct4mEmn%A!7;%m6=yYI+3BcjG8u=e^<3<u|h
z1pV5hPnfP<1LFet9ND^FVvMsZ@kH`O6lRtTc<1u=$rmX4DGOFj!$p!ev+z9(G+WoD
zS-rbZw9Vm_WWo{9-8a>q!ridhsHymveEgN4$#rF;LesXwUFE6A)YwSQHG3OzLsuMH
z4lzMhf)F=7VxsK5IY{cB9sjxJNaei(r4C^X3GzqrVC(zt=QYnJX*1g?xfcV#b2QjL
z20GX%Pp_%s*kaT+2k5X`lefPwM>V}ly6`bTCWnGq?CN(nNV*CdB{kiZ!*-uc_2X&}
zgFXq6UQLF9cMR@$RoXNstV|w+;@;o~LqY;=AvI#`>Fudv<@lUqb9oIjT;wtWMRqp`
zIWL1ZSCEl}lmIaF=Hc`aQX)CY>bU{{GWPEa3iyyk05KxC$tg)8{6vC>fAzBDaY`Oy
zB6O3|b(3(kw+B180TM1?GdJ*Skf)8CHAqHINmVBp4Icn-Fy$o0G$99W%La}lp37aQ
ztA|zBYZ7s(jMSJ?niClGdB$2BQYSQC#zW`Y3=ToWee3UtLpAeh#Kmn3#fg=vH|So-
zSqz?5d3xp`Cl#rD;BEA@ycRis_M>vh`+l(c?U$d`-FZvI7cF=oAteqI2!arU1ppAF
zfC2zS01$=zf*cQG0ROJ)KZO6?$v^V`H~eo-|H}67c|uzK?cyK7{|*KQApH-c@vpf3
zE89OJ@PEJ;2!hPtf75Xn!$nLG&G#Sl8w(AT#)0j`I@MR^cICuiLbX)P#{kSiHQKvJ
zO3JvW*6{<6Xu44j4^OMp`A)KdcHiln>0C?aYX_T}Z4_ug-Q!3fbH2K||7&LN&D}hY
zxvwt<CRni)Tv6@0xzrqh6243q6><CU1F4iQYWFfKeSGxhV%pj7V$xx$`J9eFJLHS6
zr|qAvE@K_tHY%I$oHqy9R{UIFu6S8+vKSFbO7^|c9&qw<GvD`!w&?uUA01MvQw1ih
zZMx=N@%Oas`h!PZ1FrL?G;7CYW#t#|bHlc)g_Aw4-ATEU7~|^mktB7=z5!`g<3RtH
zcaO>_;W7uT2L}kJb-B&rudFbDgqUi-;t1BjW@3~31yGgAY78;Yx50sdg=y?5&i=>_
zV>KM-y(u>7LSr1MzV2>8O3H!F!P97yv9TXnVu0w26|X{K$M#ndJgbKB+1cyUNmEHl
zV|uaD?OsO>YKEP{@eK`>aUGf+w6w19P=MU+RGN?T`L?v*WqGFauO<Crllz`9v5WiV
z@85SHujP5n*@n)!8~8$ipd!PLrPy*E8RwrPblg1i=EAIn)AS6t3(F3e1_pKztB;@$
zS8Q)@p~3R~{Vj7v1}7pQJF;!b!(#Gluvj640L@noXEreY^0F|jVV!L??A0Fx2vPWJ
z8yfHm)%?S4nhg4Wj`r%Bh}@C!vHa;kzKMA909WDGn2+^O!#BT<w&RrZo)5n{K@Mcz
zFP#a?2+#lNE%eVq?{kgiHxK}_z?&N*gauxY{E0@<)8+gfVRmG@-}A)LF5d7bPUHXM
z{_n(vRbMyrYtC{>j<SM8nawvm7)+o`UZ}H%J6ERd{+F?&q#_M?Y{yb_FpC+U5(rB1
z2{5zgpx+c&%@{xraKd<eN-EbX%c<)Zg#{8qX_4(h#Ar*Vy;0z$-Z)lERhI($>3`OZ
z;qE7eH4MgEv1dvh9$pl#9up`lxyIEHL;wI5JJIFFNQ&B+B{)WUnE<UFcjlE<bTA?S
zqQ_@NGw0fuD%B8dS1<PY%}&%sr?fD!DX2vcMG^pBkC}s@0noGn)bBbV<MVHSL&?AC
zh`wWjFa|iTZu`3~FC8G14i95CJv%c85Xf&}P!WNkxfLX@MgrYFFTwa*LG!>s7T{y{
z_%p0-?c_)NG}i0QkrXq-*17o6wAOcTAzr(kzDFM&i5(uIY%K9Pe*Nu0Krn0YHAnQG
z8(EzmA=rjyW*iOZdO=Duwz1wTx72z~C;a5a3b{mtZ?`5)A)0RgDr0Q3Zk*<{sq<(M
zfm|>q_vu3H;Urx7i77k~4yY+edVah|cy2#ijTP`D^IzZUYyc~NfdM9nHcy$z1k?N4
zeeX{XOhh8CR~Dm99`~blo?2Ti!vMfKthd)&(96kf@fkhvd-U&W&lN&q$fC+S(s|1D
z`;1Q>;039?Wqht=)_M9(K3y@#=r-_X-QnS85Pd^N#APvewiXsK<Ad_f>CGwEz^2}q
zWx#3MucYU5<iPRV2j+)$G@u6O{(k!VvJgZ#v3JI=3l}d>>)dNj!XdNRN}1g!@^s3}
z&F#ZZ;$gvy18CL#RY5vP{``fw^Y*K;VLN{eB#2oet2|jmRS=&PKoC{cLwuDi`QZKW
z@xXQGGh4^wk)GdqCO%4ODxbm4OQTePq7WjQQuXn|3$cq$<o%TfbzV14c<0U3UHsc`
z*3muxcrY=K(mI!-kNq97FflVTvv=KINR*j<!+XL2x<=ZpF^^hT{Tm~=3ET>to~prr
z+U2Wd;|(MkqawtiW`wPf0}%mJdgYb~?Nm&#4MN^8K7rdLB88xdsidiLyh+_}S$~Cq
z)=1KV&(-5+JOJ2QVSfFs@+CS&c$0rfTMy+2zFr$W=uo_@WTt`)PRQ&L)<*oHew=?n
ze57puY(?`MpxKQD;yNsP4Ka0-0z(l}T)$;F<F7W;jOx+We~6<Q1dz`H3C4QT``;K(
z0QB-NhXas4A>yl8Ez1mXhzJaYLICf;pJ5Rr{~?Kr57eT%-Ezaf9SHyln1A(Y@vlZF
z5yb>0{*{*cH|7^0D*by9kUnGnB5s_hFZqY6BmD*_nIT~?2-538Oil;@hxwllE&pnB
z5jFD{bzKO+nnNMTY2Y7@t`YLA((?W@$3wx?qVKhF`lnRn`B?s(6Qu0qxTiX%=HIu!
zw?#iP_RN$&cD26@Zu$eSIpTj*#5go{D9kM3|1rB%V8NWhLYZl=i(NKu?zsZUe%q;K
z4;d4MPAVWb_w+O=x4GWiOAv3>@IM0|>3w2~_x!NK%VNkIG5L}B;9!=t>d%Rz+Miaj
zaz0)Wd*kps!@?&fwu3Ak{HK=R)ffQP;do$9zqK1iot~hP^5P2Fz?`;-PkY^RX^x_$
z^K-}VfVW^ipLY(3Mm;@UbNpJ$km_T4*X!-p3U+IS<Y_$bdZ(KX-1y_~uOTaJHSoFa
zW>`h|w=xWNK4}Sio^e?HevVA{aymI4ZpTY&>s&F~jWLtt2oVs@zj!%6T<l*Amwr$A
zi65BO4oT76C`ULTLP_-ebj|y8mKJhz<VfD>gvngWsQyRl;5|9K{%hGLX7C;|D5}P$
zYjcZ2*Ns)ZKo@hO_|fmn+5Le}oUyCV0X_xCcHg#9?6oA97-Aux95!45S^ecs@?Y2E
zUkR5WuMEGh|0X^C-(;?TXXK)g^!7h^f%sqHAF8cjpH1{S{12avahgz(Ag?^CV5jIe
z<IK=&GdeqHYztTKer#{vfkhnkI*!~Ao27uP!=mTUfh)n%nJcQK<Dx0=ji8xEn^gSI
zsyFR`y>O8n1AQliytt6wS!{bR4L6dy5sQi19W+skQB`+wSKc394#RXns`FbsD8Q-6
zxf9;YP^cwV9y^;xanbDouiw6tVQ!<`Z@d!tc!+vJh43vYa9hhn1y=M<EPf}|$9=&I
z#CKx7IV&Qn4dpbK)Ql*~1yGRy<vyI}H1fo~_-jQE%t0S43aWU{S^}-E!6wgO6VDWK
zi^Z8$6XD^_s?C>L<7bAmrw=S=uXNn~s`hou@9uMcLho`Z_`7$KSL{Es&R&Z`CF~l7
z(ms!IpxvcC)|LBclv%(>kM(G|yXLIUkUcY4CN3Pb(~s|P>`Y$F%a+5K&eC?2p#?Dr
zV|l00t}#^Um#52Uh=algn+`1mX9qinYPAQm6AeQ=6EkKm4NQ~*V<o9-V4UU*{FMYT
zbRHkeZuFy{{KKT4JGCBBl=$MxzA)Ht_^Eq6Xk|xaKKQ7tH!H6Dm&evAQ35WmbBnt6
z{7yQL1K&&VouUQ@8LToFHm`kD4r)tX{EE)n+&;K~>i1CZxmsbAxsH5MN{#SrH!2N1
zF=0P>7d>;*)WSF|HJ(Sqr;ZSB=rxKRJUxv*@oq_3I!z5a&#6R>{ZuOYHs4zof2!3k
zU6v)KHLjLYeO>2QIV0{iJ1#?P{4#qccWm<)Vufv&l=J=fL4%#@yte)O&iz{E1HSTo
zcE~?iCTTOm7^`PVHp~4UO8sNK+DkpbZM)}c{RbU;)rm#WYZWjC9w=EC>{WNe)%W+g
z+m4)DC%k1|t^x;{a<hX08gZw|WPyt&$4b5d8eY$KJ?B$4`_b252!<ZlRQA}JT;Nt_
z&~LgAzDBm^ls|*pueS=)_M@w!OkOG6_PZ{1hP#-TKgHHosm!|e2rRP4&EIou*Y7qL
z9aSePkEnRyK07G=^bWD>nf+SO^on#x)DBt{5fJq!I#=r|fAac9W2AI<`yl8gbVGQ~
zPg~Cqltl%X2(K%Hj<N@B@G}oNcspF{hMbKC$$|ju$!sV`*z#w>>@QuB<WMzEC`|WB
zd2NI>L+84eR^!q1w1K>l+E46x+-*=koB(a06T(^y=1CcPhK&zh{m&2<!&-6SYENfs
z!1%Ur%TN6T$?GT*KJ%+ryFiJ?EM(L@k>le?#s~r0=k{iR=wkIDp#8}TR+%WE#M1b*
z-hZ(FfK=ZPp^F%&+-p;DU8yO`V)X!_+B<mmJ79gE*@nMij;!qNAT;mqSLF2IjXJ@l
z)v?X2!wmwI&q8y5ZU$ufTx#}j>JN~M@DI<M3?S{+J0j*j@94O{y%>;)s=nqXP1|UK
z^8}QA6LwB?p5yKb(;m+|_gBSO4^YpvM6Sy%Q}2;rtFM!l%c6~OxNo7Ie!SO(7W_(X
zr`j?*mS09)D@7(VJ1)TxNX=3Fu?A%~s`1<WJwrUR&Mk8bOicyMCnU#rd~IgASFCFd
z;1%ToUK(uy>~m!{VBtzSx5vVMI!D4tM1jGRqAj0q-Fy7wbFEh;WXY@KfK(nf;`wIZ
z8ecpc%#Lf#JEu}M$+xe#c48+?AGA+Gsa|5wUC?%XEB^_8zQ1QM8B>Z8YkFnVb0E}U
zVKaH{R2^$!iS1neW-&$4Aom3PWPD)rq&i&|xH>n-YJ7a;kD}yb2pu%ndF$m2#g!`p
z5BqO~R+okx4h8u2p9%8cUzvg+4gd3<;CHM4hrT?406-MN_&?aO{vKTrq#?&?AWy3<
Uj()O6D&!83lTwzf5;uMOUx(WyrT_o{

literal 8177
zcmeHMXH=70myTW)J0K!T^`e4?5<1eoDxy*~1W<Z22%!fEBmukhTvR|xKtxK2gd0le
zpb`=h0TGZAisYpuU}y<7^WM8=*8MRv-}lX$U$fTyc-J}a$vHdwoU`A(pJ(qFD+`lD
z`^EP|Ado}Xu3o+gf$RjkJ0W}bfXy<ddmU`{xS5(<2HP)?8t2IFA+WbE;Oebl2;_js
zpU)0RdggI(Pyl_++*n|AkNED>5Ss(PB!NRxcdhNvm;8NwJ^j$&D+F>W$kP?=>2Wgb
zF52s)$u)B;4`ojQ2t)>P?ecHdn1Q(=EIKm`|9y1f^HuR7{}j))NanRny2VNEBgNh)
z_OADj?LEDFpmfN$R?)N8e(L7H*Kz}c<x-T+P}b3!%+seYwB{-OvFrM^bo%I#pfV{I
zRZ1_#w?8GMF<#@V7yqm)T)f`hUi{iAqYj<S%%=Fso;vlVcH}UZyFF~JAG%--flMZs
zBmO!AAqeCisPHZb<RsYafI#*_AQ!+Mcs&2$r~l#fza{-k(*K_Rw@&}n*gw}3T=lnz
ze`)$X$bTHh1&H15|IO-uc834Wj{a8QU%rihm-Me*-hcYze|*>fY5L!Hxa;2kVI#Vy
zX6q`t`G`b1A27N?{ng%nnIaI>M7`VbP?+>$C6q$OvdH=MN-I3=;*)i$zd=4HNX(>n
zOtl)xy19oqIym=A3dS$n2Yx?r{8Q{Dh|%b`Z=%RBeu}7#IArImOwUuI{=T<EZTJ(&
z^i*Rl$(`U=^`cl?v%)0Uc>LB@#zgEVjC<Ej1wqITD~g}*t;j@vyDMmV7jAiXSTo2H
zDVbf3_>fCJ<w$7pWpKDU9BFD|{iee=#5!L+FgW;W^4<&m0pi~YM_CC`*f8X#8>?uV
zkDra@m35iC{a7}(tXP-&Uiw~ma3D>Y)~jWK#r9&9hojJz%VW%f`VP;E1gfSz(sSoY
z$fxEGQ5`Nnt3gCn9L`zW7EzCo1V8=*p1aMAI{|LkvNRz&S}$sOWO{ILP<Z;BKNPa-
z-2-mXlW%r65C(H|wI)y5PpjWYM`Hr2V22YE%&;TLh#t<TCpHUE$g#SmNFf*M`=~Gj
zzHJm#G;BqhKtQ9+aCO+H5yzH;8~!NLa_amd-rKFk+}%?_Eh^O&|C&~KHP5ZeDq2Lu
zJum>L5vigkG$Q^ZM&QZD>wqk?&?<ensJ5nZjKr)x`!x#xwzw#ffi`|4>-I`T*ii(a
zDrg@SJj88IUAMe4N$16<R4Uoalz4e1ki9e9Olev+)^~D$brepsrU&E*F&EuA%Y9dW
z9G{MBlsPY2E3&ivs5gAN@3y0un8&P}Bf|VGxhQ4@(bIV&DWL{E!Q_+8^4xGmLe->;
z%N7=wxpa)AbVu`jPA3M3Rtb$?ZXVryspJ=9eTA-B(H4kz40f<#2}u-ryLozsbmytx
zcz&HZW&P`u1J46Bvf~~CxtytwE}KgM{-6egnBCihsFLgQqJ$yr@O-)7)x2Dv*@PPz
z;iHG4NB2{=NdoNt7=GjEfCEBgL%A+;fGL@k8J+0JZT@1N;}ONJc36IMju_+Y<#=Mj
z&rw*cS0l4$F)?wHEi%->khd_9sD7EwoxB;##D(B}HYaJCf$*khA2XY$Uqy{XsYTY#
zekX8`5MvnDa*-roL|tWwF^WVnB2TXV3~<Jk&t7PeT}n@9RM99pltSOwR&Q}PIKuo*
zS6NwZK*y97j#i>z*b}Ug*rt;C%n5jgI@|HR{=AIXsTvJ?vBs}7x#6$f(#6RL<ko`a
zBopvox1{rD43E?@p7@sRdbbADD=DzyJ~RvL#@0iFK;XT}b{n5RWNu4O4r%K$nlIA>
zO5)<hUXlf^-Jv3Ue18pZ{0upl<aXz|sFb)wOqfi+DEAOoDIHRkpRc-&X-=uiZ&=IB
zZt}<xibBr>;Kq2{FU@%4NeR}Qy?H*s!#SVayw~1WX6MumOaLRva42I!<>MVwzaX`3
zHX6BU)4LsfcznqKqGe;l%zis~#AvA7P=R23_9)x*mjd=f=4$(TR(f-J{cTkHtSY2A
zf4km29mdg%#Z|+iN%sr#*<!bC=-UTM;sjwV6+jSvnO=kP#rZVF0rhb%Gr$B|&ai&w
zHO8e&RDFGs5dHB@7bnMa7KodzG{?FYX3W^Tb9eVL7K;1y0T@3zI@`zb1lO-hzo_-+
zMeCk4Gu$h@?~j2XUk5~&mjW&&ve?&Lzj{3V)&?l+YC#t#Wx|u{(^|o4HMQw?+IO!R
zL?>E)S9zk@8JY1gv*3XdgL=m#n3=_fzw_;0NgrtG((2$hYY)I)!dbGiq+i@r0m)q`
zyjlRPBE%RO;sc*nE24}YO@9mq`PLy@KHXx~O9^wj%;z}MJ^Tp5O<$-~RQ2Kq-a12!
z`2;oh){u~@Rn91|@mFH?x|-AEw(kOQfaZ$n1NFTHSDPolIUI?q3o`BYxUP;PE5n7O
z8fHH5KF<`Z+CI-<f$HjnnYJ#{6Zl34vtqaJHjLFC5aA@e&!VR{j7!24HQ@eUUU4SQ
z=#aYCIcSL<w60WTNyFI`WYMSj5dPJTbspnMtGnliG#SuW&Msm)2u>TtpuvpBQDV6j
z$@5}8ZN;sv>j%o^;KI&!VRunRtyG~&AeBE-JR)txQqzVfjttbuHdOgxTTZ=O^^PP~
zB6kel^r-woG-#<^TbMF9R$^Io@TXF7D?o!ko!AV=hY!){e}ubvs5EHxNeLe0GUf*Z
zGBb}8Ixqg}{dIb(urT%jd6w<DQVcq86ZC1^H5%d$0QXUj?KNDoyH!8mSc~f_uauJL
z_|tDOv;{1gBGozPRaK>{K>=OUcDK?J<}?#HjQl*#xBS&YGh{wKb7X;+>WOn3-+d$d
zr|DevINs+cT7SE4yeF@VT3V{BOuieftyRIy$Vib>UU*Jcjy}NE*O&!%M1E};4A=}n
zpA1br+}u8BC3##Xp`ir_`m;@*fpuy-{nIDZTgux+v0g34N=O^$YfTD$7S-(uWm7a$
z>8p4>S^tbpe{=I@gIQWLSv-y(JJ(KVp4_lx7#+?^B!YUU%fx{jF9P*Oq$R|WXMyBH
zrfg(JO7k<>hkKky$~ER4g0I!h^~?K~93w3S34QO;OrQeBw&vK4=}nB{2;P~^DAc{#
zS+T;PyCZBDHvDj5XqVMW0i+JZyH4dq_Oy<4_7B4&1i~R=XCuin4{(>tVB4~6<P&2X
zaSMqU4Q=aZpr`xo9&C)%nZqNB2!Ia9;`CuQwjH6F5ZId@=kC5zZN629MV~bcWxL=;
z52l8ho4eye=gv@-M}<DLJ<W=)jr(jJPMe*#j#O;W{US9YJrffpIioX~v>^c{1D9IA
zF=0n_XqyT|%Vv4YFy%t-*Nb-B3yLhE#^ivRz{~V^mklE~==XUZVaWLG-}c@)CE7SZ
z(={BRs;b^RC2NRAId6`VnrOChU&6!pe*Y#5UyW?wU+#34t$rEXIA^4jJN{zea*hyx
za=EjwbTS7s(pk{XYdR{ds)2|WlpGOj4BVWiZ)|z9(o69&U|a{bh*<WsdOddV7IM{7
zQkXN;c^}h%-{eTiA<o4Jc?Qsko{ur*&PQY0-NN-E%j+6qrbm(&((<^s7wDMHmFe8T
zuKOl#Ym^PZfLIG8Hc(CwX<;haan3(*P(OoBk9hfb;@bDG6~b@}Rz!n>w>Vpy)hj=Y
z?45E!jc@}t?{bs=@@2>4NIVR;EO4#isk?s?j6O2gcbrwaLbKiZY7=pV&Pq=?GhEO&
z&z~IZ#42)DD>aoe%I<3zO>e)?s=_Q>;$*cC1)j~;n`EwmQaF!?DR=#&uuG+dmdPWm
zsrg}m8s71c6VqkV&Wq!%C7Q)IZxH4TfQ^y<U_~vX6_?G9V29xxoU-BXf7GS+R<?gq
zZT|)aNvvKNQ~OCo`}Bg@X5Df~Gt)vcb9Hs4f1rv&(cyJEJtUE;@IA&cjb331hZ%=9
z8f7{%0p#X1r?bkHFX-m%x2^+$cBS#iJz~ik?I<v4WnwM?U+MeQ505<oayqxwBi=3?
zTwx?pJMa2C-@GMS;_ska(BY2>k{uqYmiN>D`LIvVP*;JlX74DFUtbJ5AKPxN<hEHO
zl_Y|_pwS6!qgwTd{puON%*_u|&fgfzoW37}8w}#LRE>Y6oHuA1AL_^ITbP&CndwT|
z_9|`mjtW{x#ukV)pq!lip>vaUxp}8(XB_g-F0wKuQ4`cD^FDHroQ3%WaHvCHyy<yY
zqmlE?-lP6$&0UB8jJb7ZbyxhIdvBeND4N>xCjw<VXmdlt+2`@6Wi_!zBdhTQdhV$%
zf@f6`4c9(C+^{fO1)!XOUC&9;{s*(NR#%bCD?lk;kVz~nuZxMU(jNWsytVav=6Z`Y
z-C*A=5PN%Rr~afiOZ)Wj_9$gbeZ686x4|$GX*>^Fe<|wWTr%XWv*}k+PCDa^ag--<
zuB7yIi7zVd+wve073h+pwHGvr(cwpe)@w&s)XVB3rLXmUS+<w}zAM5O1Wt7=5Nm!Y
z7MKxX&Jt5utF%K1P1+~nK)f&9!CHMQkc(toVZ)FrE{l&h!?{UxgLIa+1QO4dV=3%V
zK@N9*6-MkUfaAleU|EK(LslRT5%DR55@W(XcUITtl?S8Ocj%B6$Q>-fFZVgqu=XyS
z8;A$v=KO63M4D1uNT|l>A1#ZqD6374aX!8#_#2F^E)6%%We*jPtCF+8z45eT=e8S{
zBqtXd%ci>DwYEkMg~+{#2%gxiFC1%m)X7=dM-8V~oK`F$nK?auGihc2AjBro$#yK0
zUyH51UOHGCCrOF$P5WGk#GZj{Cm$&C24Wxmc6056$6#=xOi{<GG$H20vY2LdDMg3&
zVvW+~zOQlMwp#M!oIs)cXm{Prk$5eO+fLQHE_@|<_ng@Aho*h%dH8sH=lk<&H_}ZN
zWIj)_NspX6d`dMvsY+$_y6ThW`$hHS`4SHeI`N6Q<+XB49Kt074t!tFc5tx*(B!z$
z8oH(Q#5pVPONL62uKfd8Sys#RFRxS`RsAKB#zp(53g5;iPHu(WGDawp3gaitJT;Ke
z*E)_I7{6kN1==&|H*XM|r=r&c6PBAF?*jxWZ++7%gg5?l4P!Uqa1Lc+4EWjHJ`I~_
z9|mG}{A`~{<h22oOlv42WmY9Mp#PiM`ldli=nqL4(mr;)t$FqjkPh^AYc`8km{aTX
zf7P<>p$`<L(@Bv!daT%k6S(qSWpUfHOc}E}Jl4GFE%BN=c$(Me$5)D}x_VoF<n0*T
zrX!zpLJ5f5k_TXN^7%xYU=Xo5*^G#fSR5zTyfU(S{J^sH!0~JV@^W_E_%e!A6k`v9
zyIFCTTP?isx?eD25pjx3NO*x>vlI*8Y%9YdOhGHNy4f7c=lk+oKDPb52t5UV%nRbT
zU~E5>`uRFK(RNtP9B6w%-jsD3_L)tkKTRzr%+A=?eF^sROe)jSU2;F;7>P`RFWDr&
zKO4a!tCvl2A9v?}<xI$`+Yx7{_}OTaBxZQ9JGMLh$+O*j5X{Vv@SgEz7_IoVj)#e|
zJH8k^oK?$=fs3@H_1_pRt=aj?tS*ma!11;<VO#<9E*X@SzV$z}O6PE<XRC8wmwLs&
z!`0+fpOVIR_5?nJZHI4lKJ)N;0_Pu7*GSVpUeiuWk7K+x+GX`)kl)jveijwABDrnQ
ziuCoiducA?WiJ&~y7(Y?n=8NQ9_WSBNSt7@?IIN|%;T9YF`V<7s?r5=i-8epG6o`R
zQ^e2ADVpu=(XPUCi@Ws<HAQcHpwa<j<#o8P5D{`#KtZ91?Rnrw>gU#3dv{~wo_OVw
z{bh5=^ns3<)+o@uaSsy{H=aZQNlEwn(j;QvpZld`;-Z}BjZd16Kc>PznS!+TeeLZO
zSQXq*Z5mxi_6*<bBsC4=756GYi`ZS{%B)U&wxm?Nk^Y()j_N=03o_glq;%c#l0@ID
zwx4;|Q?8X7TOg!0KSXxgb#Dau-FgN8Ib6Cof6pCGRk1sqeLgKZdT`7G_bS*D#i~7J
z$O`+A8ny3`m=0sairs%iBDPNK%60ucJ9enJ!zg~y#RryWyg))mAMZIdjQ?Dlf|m1B
z4x$!;##gua{S*gTKzK2C*=Bs~vf<iKmrF57oWpI87g4EAsXJYAYAZsj8wF!A!Cj?v
z1&=G2>o)p{obOi~lQm5eEly`YZKM>HPmY$H3(Dem9_hGr5Arf8HX4In`p~dzK`&iT
z)*S|2`cYFeL1#4@V00Vw`+SYta<<%CmVWpvaE6=2MAN1hrjK-7{x}$EtE^jc*DG%I
zQH#bN`9&(K7q5Ez1Mo6|WQO*|-|aRF)-SGClPJ0CaD=ad8L0g|ysZACYiY-_r2Wwj
zbxlo#)>D`?OihfRcgC<hJUnSSOGaUl>nixJ4obsrDg07!eSKU;SXD*ygtO9OE2&R%
zx0QEmoa6#NpvwP-en*j7`u!!W@!?7b1k3vCxU=mTr_pF8;CG1KtMslk%%!HU^o>DH
zQ_v!VZ7mmrhQCy4q_-6{>qA5Db_1Ro-+lC5(Gfc4PD>tsX9KTvR`jP=)#Pi4dDfh@
zmyjUO=GWH;<1|9`cAbPAE2`8EJMHvz%LBxAI(_Q$QLVjuEKU4B>?zlM9#g6Gle%Bg
zFWETqgr!+>$A#oKOI;G5&XvPSyojVr54BULtl4hZGmVDdf6s&1y^F2CZ!{7nD>pf1
z^&Ml@JhGatxX9I&xVHvJIjx;Z`&1gPTyVs#R+8ev#f2@)5$Z7}OQl}v<Ao&CJfPl~
zlDVEX>~5&B)5Ueb`j$v<w>-gn`-kM*c9aFR=}_;tN;*T0b)JgR*UQ3v>OZ5oQr7VK
z+Yur&3mq{qerCYa2|99OCZQm>scU%HCM|)btJOB6#<$<7u}fFML~y5m@A_@`yPexB
z&K^HU-cytMRCQGfqPp;x>N|A|Z;vf#9shleW2YQ`nd>9Lx)Tx(Bm2ZKD;*r4O_m~2
z>#)zgZHr51tF57t{4w>Iu(iB1WcHad^!4waJu4iEx!EHNOIZ2C>+km7+wJWQ9Y%PB
ztq;`)M~OC&tfBMsdP$h<unI-OOSN;5;02a3qiGX2`^hW&aTBEfYO@R)73&XjS{p>q
zi?M24l*f8iBgyp|O1U%0bUZN&pkmQp11$AvG%j$6W``IvOLVhASU1~#^R>(rn&Bkf
zuVNz1cE7v00x}dkXOEq6wG$XFKR8w@wD0%g1c_L)k2~{z=50S$eHO6AT{klxEL(kc
zesb5#^w>&mrMP-A2eC#f3V#jOzEYesEl`-(HO=duDfZOlw0J<-cw%kt?<!S+Av8JZ
zKD4JpX0cv@r^B=2H~}rk6XdckW+#Zv8~dtR8eew0j6!J}d}`8tj5jXQ!Z}<~`-R;i
zf03(q@ZF%q%k=oh8J%=YcB-ag%!W3Yn6d83;sE*i`Rqf7e5vkB$${J&Q+Hq5a$|$w
zB$JKZw{&dKYUD^*N&TC*7WMdmH%5j|W1n(-$}~CkZMF=)m$O&}^8CneAm^63>nt<E
z!XY|)Cuq+*=v?#dva?FDX%O;X`A6Exs4b(YwaOk82-YgKl;WJH2SwZ|r3}dpyWaO0
z<kF(uO`R>u7<o3`eKN&|odL%B@$KiFj~_2cwokgb1j)+f=f75c9)n2kp;puw`n~m!
z>D8tsqimy|S%%8QD2S})*H=`Zq7?fkvapGauqP32{JyJb%Q1IUkx&l_t#JqH=8G^#
zwSQyef#&jTfKgRSJ0~8x-Bnj_D5Kk8q+EPAI^zgKwHrKe_f~DDKq@7!gG-FY3e*BI
zATw<xG+%X9^ZuIlCjmAEiDb_qUrt$D>+9;*yhvinGBJK+URP+ew-I7jINaSWZNATc
z;$n_aSjQ5F+_4(c?5mJ3c<;|-D;$o+QTUI-&IA|Lst6lJdD!B@n>=H<t#7&l;qLZq
zu^Xzu;}+f!<sk>VFZ*%Y<4{{%z;sPjdFcB4K!u_rAXiEP$fZ&how6@N*-B5P2_=+9
z#cjt+K5Tr30u;delG)&Mr*6>yAezZKY&6;$C2W86DdbNK7*z#JY+s7M^K`Kq<5j4=
z7XDJ?Uif12`+43<F4nXr-XQl<U|ZJ+fn^~D?N<YN!Gd9_dZ5E49q}|MeKspxqhU~6
z+em1B+CbVLH=&9>z5Cq<nj-u}Ns;r-v0g4`H>YwKF{b#)R$DPGS-3Yq*>HFZRk!ew
z^3mL)eFm^Nx}U>&{*?VER2K}+GfLU?@;f^mF%@(C<wsb}ULF_Rji3}u%)M+=+yIFV
zl8v03%EB<q^zds3?mb>0Dz)ayx_WT>z;Ku2@A|`rj{`lk$Q>s#m>nW2fgy2wa5z}e
zuaCcV{``TZda?bFd2S;yeIQ@ptpJuLeuo>a8Vu38l*n}~73Qi&EPZjkStd(YGIgFM
z>^y6vNfz7+1ECiiWUiLA1m4NL_ZF>Cm1}${eJT9o7I1T+Vsh+Z*-6LRizk=n1ghUx
zxq$pHJMl;2DPxK`|DrC_1OVg(o8wmXkNfLvUj8ATkqsLyV3_<xhK;2A4RT+#m|G}U
z^?Hr)yz1t^xCgEcOL0hD#LloptX{+-5D2EwQLH7aI?fj$P$he5$9cjVHWfQJxx>lo
z4wOAmlg}ePp;hHjbW&{Z<kr82f+?BfP&3AtF^|lb#|dD{1EZ#Wl&{e(LYR1RY#2r)
zMU%ZH0LFR>xaQ0^YXtL|nP<5N^wjg%<L8dP4pWn1E&+k3v*WgaQ&gDt5yIpicckCh
zW9!imimo<?g#48`MuGX81cWB_wVK4rw3!Ed`gjJEZsn?$IL>6h<9X?8=?d}n2gN`<
zZ9L3!01H=>g#WMV{gaa2|5x=uJNd^2zyDKJJ^e}k4&c$wb1xnTtbjX%Tr;+~Ou6Xt
G;NJk(1STH<

diff --git a/Templates/BaseGame/game/tools/assetBrowser/art/clientScriptIcon.png b/Templates/BaseGame/game/tools/assetBrowser/art/clientScriptIcon.png
index 3f83a2ff3189fae48971c2975fb3e26b2696da03..698c688527418a5c4f36fbf9de19bcf0626a32a7 100644
GIT binary patch
literal 9016
zcmbt(WmsKHvi8C^!QI^*LU5Oj2Ty{#ySr>GxVtB4g1aS1f=h4-4#6Qnkl=E6?#zAW
z%QxrDoVoYMepaul?zgI|tKRO_J5p6y7VQb~6953v<mIH*0RR@-gatr|(8syg^bG)D
zP5WqSxv3j_QaZUfT3FkeQ@VLOnNym3Sz7>r*TP|zb`ouQlJuiCm;(ki##kVRx;?}o
zfTEkGuB@)^wWncV<Hs1?y~HDULf&^}SaXMu*T)+V(G+-C=?&9ME*E!2X<2S7nvZwq
zw?bELft`Vy?w8@WM;k#-EH1HQAz6kLi%XW$33K<?dQv+b0eotU)kqutNcTL6({r$n
z(FQ2JKUml1YzrQ;7>8`P&hJDFSax0xU+Q}KkLJ&v9lW;D-FOuRuG?0{?o7T?ciHgA
z%YPD}YhlG2kFtW||FGB|{)Bfhj_T%Cmz<^W9;MdR{?gMTXZc_$_Ac#ep^3&UqwDtK
zwDM~8;cm$1vi-WcCJ^28ig}6R*kHorn9<BzBqF~cMXbtj1>+`fS3}G3dxx&TTzqO^
zOQ6ElC*&hC(Ob{avYqdio+9Q=IfmIjj$0k3OPr3&D&_{gma^C{SH6~?l%@3277eS2
zd3_lV#vH;?*LoX{bJ0G^$;CC8_W6aGV1X?k%O|U+$o3I~2J3QEn=CISh2<j$^sj5^
zmdqFR9bWIJpRsUi!X_t*Jl<_Rc&xSZU<FrGbbMy#3O5bI2wi1IrJ-K`m{T_Q>3D93
zBHETV*k@U9-srMhL<1FVHHl?KTo#det~5<jyBgUEOOd57R1V$`T}`U5fLdL$D=`&t
zS4z(?!wh=Ej6y>PR;U2+j4b$-gbHbD<}E^umDp`YYB5Qol8lOrHdW+PN%x6)-rLL;
zyvV*Ft$(34N=H(5fvw1_<HA(jHmOiuTT;d|r*3QC$Y+f;JtHI1w4ig43l`$`6kR47
zzfHiBB^EqoER5Th$uAmH(y+`kpPjcbtov3F_sYP0X6EIpak7Gt{jztuzUSh7f(=8S
z+xe!(()-ff2du_dT7f?IC~7Fx?*?O2&{!$dHXN9anSwt>>WoBW6p44CsL`0vHua9o
zB_wHWvRZV&1gIg<%mmj5gJVD?WYQ{E5z8zt=o}CEJzr9NHs~K6Hgm#`IA|_impY;r
zp8DkRnWzwDY4{i2Y#*tAK#icC&t8b-6*F9}Cci76dsI4qG%N7<tSNtniZ$F*3(Hfl
zlrt?lr2P_kYed8SWX}4U)O3OT8h$2FPD!k7nN)Umeta`8>s^dHIzpd#UN2cxo<>s~
z99iCTtRj~tmV{OQTcz2u8rig}>09ryqkG$j%kNtU@?`ZlSm*YQ7dBD>4Y%17V$Tm!
zPZ2l}*Tg0Vg}gPbLwXd)knjaw8k23y4+WO|cyMwL6jJs4&^L0(Jzm>4fENaH@dm?^
znLSMKm9>59%8!+g+qXsGv8kUO+N#^<+THuuoHh9iqc(YHsT582N~pP6T~0}FzLV3%
zEH)oAB*CGKz}=?>YYI4K`WIxV@)qcfvumjiCcY@}Cg*xWi`_*0EG^fY053iFlMUOq
zjux4v@{^u#ZV3u{a}v^c71Y#Sdg%S@kIbg@z8~S%VQ0rqgU9AiGp}W8B^Q(L^EQ1+
z7*5&UatSwOb(^wowT`sE?-V-(cg)_*C{%3Zg(VPDC~9|OBdc9}0OqcK#8mXXwH(ck
z*y^(NXXA~vm@sx*?}?~}r>~B^rfXm`shyM-JUwYUuYlZ`vTsDsC<<~lQ{_%;u@tvk
zmN{gbDBH(}Uh=uPZ0zXc<<~zxMI5ZZkT$d+&Lz}Ak$GbVWSi^wy*(s#hOJC-b$cyZ
zBBvOR|90oz%!GRDyyNG?<*Un57`?#svhZ_3Vik9b^!MR{yzv)(*@Hb<hRLk-m%~Qc
zuf^RL^F=+cvImk5ufmhYHNRHbM$Bk-XR4jRyVrn}v#uE8R}y}vG0A~UWmEc#oWDA6
zp>JF)Q9mFdMl!1D>azE_M{NRdn_<O9aKauDx1m<v$)lzMUS^!hX;g{tjk;)Ri7ata
z8VzO=S>Y(}y`r}{Tl7aNSQ4dKxxO0Te1u(&Z216>qV=R%>ghc0=k{%cK;uKWPD(QB
zqOY<WE33uq$=glYx-Z4TKOOt=fwWBVuYXS8Z?<`iFkCfWSmkE9?44(+917~t3Hs0`
zyE7+yyuGf?uF^d={GO3hO_Q@gy|7qm;BIxGGxwce`3C*~luyvJC4C3z3(2BPvb)!$
z7BQAa;}^=X@h~AkL~oAf`;*1-8G)_pX9Z!|fdz7xb9#bW$erKh_EB*cO)<d*CB<*K
zmK_rXI}?f5!@miKwrnfYhkW#|P0j&JBzqG-N6WSmuV(Lh30kC;iA2L8ETj5NF7aV-
zAdf!A3o(I|wTFS|s|tj5CDd&1>iYfQ;B8L${ma5;wGX;C&swiySwX9LEh_P-CX{dq
z$iyqIxi-a^=@Qlcpl2UWk_<XUUgM_u$}H^&A1>Q$zCAQRYo1D;Yb`PqtL-I=BVWfq
zob&C}wS<>%_E%y-9?i0?hKT~2aU~hmf@!qF%r4C?*d?+BHnW8yiVw3yY-y@Jtt=C5
zN-lTiD{OxF6;M)-kcFC|RT@ufbkz)$KNXHhr^z`hQs&E`<>_iP?XrUF^c9y35T<Fi
z3`ru7DIpjRtdwTAcr*xF^9@u4y@Y3Q`(mOBgv6-4KU!&ZD7AFc^cZb`vs-|)itbv~
z@mR(R9~sjv8xitwsS=nN#M(`6qAEo*<Q;x4-FVW9hL;ACFayD0AL17%+gW*Jv>~`5
zi{L%NVATLWR@WLwkBezu*ICZL^ziZ~`avE+OJr^MM4INj98s3L*!+V+iD-YJhTb~H
zLPfSi{rrI4yholAF9+R~vHkwp$DL<HH}<nWsLMI6*hSMUoYwlTw=*dvf+-$9w=e4O
zkI#`-R2{UQ^=0A4e!1~h*TA5xm>}g`{=vjEjzuBA-j}mmra>al8@W$^B~Y&yg4`$!
zez$$$eB?V#ca>LBY3L32)gHb}pi+X56z>Afbi)o_ZouQpVlBpDltg>_0_D5pQ;X&=
zcAaig+a#&pQl~!WK5LQ-yVLg==l$`oE`{!?O0L$+^cEslcN+T4iqd>J4YUf}+xA;u
zaFf`VC_kI!DsY=mW{ayNs;R`ZDO(Z{QM==MJ>Qk8tr6WbLN7ZLpim*UJp<G2OO>)?
ze4jNW7a1uy|Ffs!W<KvB{COpN-`P5k-;JH)jiO~I_I^q7`y&VZ*y#06knrhjXL_g4
zEqfq%Tz~aw`R6hLq8@rH;#E3w=g6)sRVLceu9VnZgbKaiSr-BN8?&zCn&-}x^m?%K
zIK(wFME<c3p^~`;$6ec%2a8!^Y}ZmbORdIrB9sl+!ai2bHRh4B&l5h>2eIE`jqN&A
zrm>NURi}??0=3WQ#<_dZT?k=C<Z4~zi8hL*)cv8yt?=^OeTgx|w8FUgCk685R*T4S
zgM;Yhyi5wI1PyPF!W2ZM(rrO+YcCN4HL}JRa@Ius8)9&$q^l;JHcQ=$ir>(U*xoRr
zMRLg$Y(=zBbhYRRMhR6{`8csZ&w%|{KILDO;28t!3Et0ez!G5KMvwlA_k6W^^e6<f
zhG-Y8_8}LJ+G4jEY(lDqDl!IJK_|1FpZXO@UurBe#*9UuHA2496b{SWkKyTLg=u?4
zjuD=#S?rqe2v#EBMnggKnCa5hc{Y-Fj$9knjO*?}zD^SwzWo(Oz|dlk|6@(Py6-5@
zc===iM9M2Vo*)vQ{S6sr^qoZFbF^JMVweyPS0q-sM;vDF=g#7y+@xzIIw+ZIR)VqZ
zIIUD2Xtpd8zSv#Fp5fFw#Y6(0lki|MO~eW1h*}(a*i5}KuV)DBTxf)3lNM~aXqCxY
z$Jic*N3+<vfau_f6so&h<gD`rf4IK@6<vJNJjQ#lznW{2Y;dZzGl@&ZH1pKfd*oWG
z4EYx2{Y}@F83t^^Q$R-XbvB4WMY}r5gyk6@_cwf>y{0sNL9b7*vLlI8Ue%H|rj6?^
z$FLFrY<}jfc0o!sOnJL0d+!>@V|=YdSi?2V2<u3%m3ubLvPweIl5P5XtdI^i_VnIU
zMCBhz4}5|P)MO=Y;wr%ZfD-|0&f=HjQy0<@S|tY0uMBu?G;Wg&A>S^TqdrT|eV8`G
zG-=|Sjbrx}@}pnCtDM?hmctb%k5ue;tZ0+TLik)8NL2R3Z9G<!I4KUT2`!^yFN+ED
z8MhLaxEwa*8*=ZPT}m9EFnTPM2&V1)@vRAkqy}8)iH0g{W73HPHWf$v2LGKf*f-iz
z*F`gOYI)vuSl&syCX}FfB^1Wq2*N_TrRnZksk9d)%Zb)??c!uNZU>8dLE2$&U?ygi
zcQIWF%AElbl)dQkp@am%c4~Mfhs1>3QOj>s#BbFSjgtx(uthA|XW%pRGY#-TfO>5!
zoAtc2dJz+W@X~y!Ao9SlefS<GsLBDyf)Qo6u(u%QePf|Nt45r^HcO(e;mXpxbHhkc
zI1jBwwer|+LD5Mw1i5O~1J7)>&vOV5ncQgMkulJLsuT&@Hfkp&Nd$-)k^Z_x+%zki
z^7m=FGA-07l?J<MBSQ#}O-5E!;c_*0x|@>l885%JmLoiXhGhIqD4RPexE{Z<!vqCv
zcTHXg%Qn?9U?#<rtO-{sjoz2U;6ofXCTkT=x{P6@(?$pW6jnr;^I<}EN`-d3#*wF)
zSWA`?hqsa?3u}OtnxzC48^4X6K^#rLqO{Tro1etvv;bS=s9-smKhmDfi4M;+3N2NL
z_?D?`Cfv^d4ULOkzTie4!aMfju^L!dNvG_Epv~fBdj$_4o77p{{5WlTlfo*c=Mf>v
zhr?H4H6`4;$qnciY>9hFKkyjCZ|-YHN>A(jGZp#1Nsx2Bom_|6&gzXl+&e38{Qe4q
z3WA73Var1`gAg$PqXd_h?hpk{4GyJdp130FX`af2gAu5GVSP+PcOkna$!VgS|1E+7
zp)~ai9MF@GI+vLlDKP{1n7qgs_^uaOwwj<e2O;|)dgJ{y3Auxhifq&Hn;uGEk*`M(
zBF$FwEEz+r58;2By_y*F81UvX<#nDK&`T=rqterTSGt7_OJcxnKEatJrhAFY+idJ)
zJMx`2c+BnY;QcEz<jjU<c$PB(r19;+P~(%ROQD}RzRxCQ*Y7DKmK<qu+u+)GwWURH
z>mYU`s@5_Tv{bqiawy-cv3lIb3%qnfM2*Ab=z68YJB{n4EZ}Z;qwqvD)B-!0)Dzz}
zR9a8jcrEB5F4o51tB}kpWP6|vTavRGJ5massM-`_A@-cxxS1h&r&2a&%1KdHOj^Py
zOAjT!jAcevwBFti)ueu_s)I*6XhMlHV=B8)Xfd#e9;d=Zrdavu1wTFlV>ec+7FLZW
zg;ohXWM;fQ1(FdzU&iMlrF}`5K=e+_k%0kEIAmL4->Fi-S0#eHnJ{yMh+pQNJT0;t
z4$1X~Zo^cv`y0KUQib<eRNZXdM(UAOFrn}sye`35NcZ(LXtbJvx3tW9k>sk4u0*j(
zO+-f08v2;hB_G<qhzibr05+03gO<VN@Iv>Cv&|m6F#7x_4u~cfLmnMflZQWolp(Zv
zB|F1$3&bDshYDViIt6M1xJqYQp;&&@p0_$}vjS@~3lRpPZOm2($*|`({b0F7_W~&u
z<1PSXY9Kz<Fy+~uyK{?#T}B;c`#F`lb#h2t<82wjmxYK}(8YAnh6<sD{Te16vNP}l
zNevuIlViJJc*5*OF#f}Jua;vJ0}Zr3;0*ie&32{(cG8QJ`1Php3zI9e_*`Omp*d!E
zvn2@(jQWLZ$@*juW(@T6#T%WB%y$T;%3rz|?j)RI>S{O}6I~%{1L_{IGkjnk4K*kE
z?`~~dgU4~6m{=k3%}#XP<G>T6l^B7qRQ0f3ayVu%5+PLT+~iudiPR{7wsdq>iJhe<
zjQ(dOtRQ)AMEmiv??I_ScLiIpZ!T&vYuX(=G?+=QNf&WYqh22BV)7}BSZp-8X?zlG
z1#udw>X%UCGlsU5=9gie2Ok+>*`Tha=vT@X4W*N)XsxR)bZJ1eIkBtQHBFfKr_M=>
zDX{Q>peVBQq`jiHH!X)BQ9P;{A4OXyj)IziGnlwH?~4iEA97^(`$E3}e~97S`{Gck
z$LpF!-5Od{e@nM4#0&)hm@sQ8DOGtXssFj(f!^xm_$P|Ub&Hes8tU4<U`F@AbRJO6
zWsRWdRV&kiM=7oxFAEtgHXJXal6Q8-)k8rKV0}rZm*ej4ga`i#1Cx)B0ZhPj5-9%`
z9D~$<@8x;ye2M;pmsyFcjUE8={L~btH*+nQT*GVMeNDj~5j8T7z1NGX*FPsB?AIRs
zgZ0uiFfKsAk+X{ibByabUnE~dVRlKMcRqiQLV=Q>vT)TDLL@~iyTDyvt5tov<?C}L
zn>>DLR$L*ieWRC?c;BqQ)l|GoIsPKZ>bml+Ler+gUFG4kk%7LvYwkAao0cT3JSag`
ziU=<wV!SNLgc5wqMeta2sFI{e{fa1t6y=>{kk##{$2HGp8DpDC`6qqAW3;({3~Z48
z8|~(bW7A=qJfOpJO~L-Q9L?w=`P@erg#rd{v8&fzH~9iGOlGtzkK;a(=J%{U4E9HW
z%xVf8qGM18Pigb4s4@iv)xFUVj+7ME6g*_$>Fudv>G+su{qquTu*hWyhWw@<dhdp4
zq9`j37y>?kG3AsY8&rbqB&Y2P04O-WelS2*4k1*C<R<?djI@P}h=fK6Q+`+g6%o0C
zwcMl}?d{DS+yE&Tb7MDiGfGcuH!Dh6`RA&yg3t*70E0tbT0#?gaksqav8YMjwccsR
zpiH_0?Cl3lDj6H$j|k&Z#Y<Fqqv6LtbL}5twGy(oR>W!k@~QOeq@MT(%7*7A!%eJ#
zt7NKrzP`2x4BBbQ)g9M@D1gyhO;i{F1OVbtPoUR`m;eBQw%`GP68eAv{*CHC>@E()
z{F{-#g#M525a__a`SeG!fA1%B)IT8pQuqHS7%)bl|7CdoZ)X2p@c%3n|M@ch9qDfo
zhSZf4!46gFyqEERPo8Z{QaiI0HIq6M!5YmP{cgra&9F?i^5UQ*!8{X2mr_1STDr%G
zGh#)XV-(R63oEh2y5Ym2*TX5LL8BoNBRnutc%v>-WpCF%TA6#bd9nO;;cHYxgt1^u
z>Q<^1?_6QWM^bs(#3zt2b@`+L>S%*b3Wn1Di9>gqVd_aY!ZBT>lkRqkg8P<xdQ@?s
zD@RM;AU3|qu{W2*(`2VG_v`hpvYovHIL#btc=~{)wqrI%p|{jHn)Ue<zko=ja`V}C
z{v5IGgxEnZCs|+pEQj-?NaQCcqZ&*=)lELBr}4|-)#((+#@UDb-bRcnaQ%GDjf)61
zb=|XQol1)x6;0+;s|sEdYwNvcZVBsYn?@}Iow&ow!>h~o#~!iATMifq04dNdV*|Su
z6E!zE_AyYb#*Q5Y;K$DNRSN}_UVBH|G!oC)@FdYjvJRVgdkf5FAJn#X5Lt#u2z%X7
z<~8IIL!*Q{f3xrNeW?Y<)8Vk^0%_6F<Dq&CwadFRp8y)+N}Xt(Mtt3DUFWlf*sI0S
z9W{C83BdrY+<<-v*JaLaQHrSEBc<s5Rr1yFVXjpb4;qLD>Qe7T_~J=#sbP=U!_8$&
zQ>(oybkdq%WVovwS0fG<=L%~VBAzLtJ)wF3viz4z&5kQ^@s2BzUmBl>NHSf4AnH1m
z)qS&l7IyY_;C2Jgh5ST1dF<F38CrSl{?h)yD}H3C=OgO&OtZwcwRLqSoP@f?>XD6o
zI(8NIJwtT@VEOGvsy7uV9+hQ|gVz!7Uq;&$+fYKCFcZCGaMVr%<9EnJ0T2_8=~-)+
z_@NPh+TZvDB6%Xh#Bb>tI7XSWbh#Q}iRpych56SDIi|lF=CeQm6S@=hkCESye=z`V
zI8>YAae0aQIp^es%CA0u%m05t4-n)tU4WDRG8HKYits1hyZDztpuUC=otBu}G1+`U
z+`zx#QplbQixFY+;t=d8@IU+rfwq3bHzIX_hv%;Qg=*3BCA*9052o}Rjd!`V;&F~d
zEKd9@RLak>kTsQGL6975MaJQW`&0XWr-;9Y@pQW%vPLR~3-@cpZ)Sfv9@RYu7%P3a
z^+hxuy((k)k5G-20<;kSaKZlDOjj?q6hr_47J{JrE}1r|$0gPq`Vy98ZjCxMEuK(r
zoF$W%`3eLu9!ZKQZG5kw=ytQ>8~|q(a}nnBIx#}iKvnBrLQHU3*-bE)u%vsSZsZMT
z66-Ma^Qm1o!HJ`$La|*ETxeRqs9udOOy1xZ6^IMyJa*NUNu!l-5IW?yBJ26IF3})l
z9})~Ld>hY2=c`jr9S&V6Wubvg1q216ZZVGgRpJApx(lV?pk*Xrq_9`yiamy&2R1e5
zfmX_dmc6uptAkNX3hVGn4$r=ukn^};gm3(>QOCXIQ#5d)P-Gu>A6$$)VQ7ICLYWv}
z+pndO>`R}HX88-ao-mm4qlS$Jf8uZs^o@r?q?4=k{*${ciE~7e{~l{|xp30CbI5;`
zBb`;kMTlOwdfZ=m&}?Gr-wm87TW86XE=JA{zZ4F*;U^dM#>EH-z*Ircm%be7mxo5K
zh*ti=srNBDnc!qMT~@8~<%XRTetQ51?;KyD&b|A7XUDT~Pk4O4l{;R~*Ve?AA@#d%
zixWN*QQ;~Sech$;->eU`bKF$WaAAR{eS5=8Az_<dBmRgTj=cVOjKE*K|4viyacJ=y
zSL`~c{~6C@Is?bX?m7R0|EmWY!04#K_s|MDfuf(&M!;R4F=nx70h~BcW3+US@%JSB
ztuTI1%zv!{0aAZ4!GFV9Q?Ypsxx9W@JYKn8{Z%ZOP|_bp2z3G$pTI(L;)kLeoIW0S
z2Rt5n;`6%V{1Se|pY^==MgeWpJLN?KJ4Vj!`>;Zh{TV-%;aoM0pq#*a$3;Gd^{REd
zi*;p8{(Hj6^D{h4Aj9b=!Isr$Nh1Tn$;L`bAmdch>TU76v%aO!y%Vgi9QL|nA?B75
zQ>BfRgQJJMYF+^ow#_BhZyED1F#(SU8jh-+#}RNmUnQsuDqYGcbqbdMfh8VE077}P
zO-~7I-+^qW5zY!8$1JNx_6J_TLx3*HLDGKf`3D0n+$tC?2*QOv0pXWZ_bn`*WI@}f
zLuaEKjd7>stxk65wIjX(9}iF1Zy#c~1FKH`PM6rfyn=xgK7Q_-JP;Fl&-L-UYv%dc
z8?Q4{gX53ZRZjqXr-__!w18=_J9hK}zpNPk+#Q@}4w=Ksu_BSfhr`jB=ubR=Ynz5{
z1J{sg&MEN$*mo={fXZ5JWv<}9>Ql>D|H39J5Z9o9C$~X9zlld3S2ZLcHpJi2*G&Y}
zOfk;8GEPodB=(IbR-ZsQL-x?M=7-+TsD0~p*+SuPHG|=X?E&*n`KOf!q<yXC7Y*C8
z6HTkm+xv^7@VMR`-%tURmb1Y7V}|?IpWr}QB7(N^0I*$Jeq`tIedhUH%g6@7UVFU;
zKA_r`J5hw+G%R{lAlp@BLRnonBL7hg>^ElF3SA^4dKBT_NXQwNYR^v7?s4kkYZQQS
zX4G;iza)1P-6D@*+PVKNqhTfvDhPmJdE`x@!^pl3j<~zR2NH&r3*|gF>ZjnKYtJ3`
zWBW0ttHPndOcs3<pu}Vx&<;{t;r7gjY5_|`%ry`|LXtv<IO2~9bOpZ#ICY^bhUrix
zg+;UGe>T|&d`5$*8IPvKe^c<f@Dg@AJ07SBVYuXn?j)`?0}FfVuf=g`op?lH83zh@
z2YZJ<gI=wQ;&a7R;*A1Eg{)gzg#CW;E%v&U0OJoyp7>XfDyNq6Y*$<8PmhmxH`cQy
zVIi;-*0C;%FHjcq1Dzf6`ieo(N9MtH*sf>#fsO`2EsV8JnRA(QS`qLtU7<8<1+hQt
zP+SuEW`+B{`9HR^Mh7Mu$mY4aCXH=99eZmhR2SWp49=-;0o5c3by(y2X5zOvi;^>S
z^XCNKCwo1A)vC%94}K_^<E%V1n;3;xGHuW3^Xnx7w*7X*_I9k-nYO+3FOD;(&$u{Z
z!U3ZalAPWz)P_AfIt`4&x7T0iW5vk(Q~}klUMmB>5#f-5u}OSSR9XKK;hon!J#l(~
zYFTd+t5Caep9CsC2fT$y|1f!2J%1Dd#u?T1es(o?H>ctD{gc2A&iOf!;W@u~lrQx6
zqy&4+kL7npQ>=Zx_Xtp);6?|oL?~bY2=M=H*}pSW$zUY}=GV6UyZASv`4_5xI=}qW
zuKOoQl)zv3j{76Se<b@CXQO|pAW(~c;>^ES{ncsx6Vg8dq)PmV1W#C*G*R+#80rcj
M4_210k~9kbFPx{d>i_@%

literal 14572
zcmeHu^;=X?*Y;rqr9%k?q(eX$N>N|{>FyK;kQ9_IVJJ~T=@x;ZyQDi5q@@R?L3)50
zY8aYteBSpj_^$7|zF(dn=A3=@>}#JLYp->$d#&?HTT_XQn4TB_05TP2d0hYi;ff%D
z@HXyt{BG(Tcf<40RgwiNM;Nzp5BT;kG+qEebu7u{D+1gzk*l(a2LO=w{QKc0^N};)
zDsNk<DaqsRV?c{V;M4-HbjMRgL*dTKZF&M$?ig>`PF&SP2Yq8tITt4<TW3$)BLK*`
z+rIL&wPEpb@O;gpq@tm1BVc<60G^4c$iL8kXTG;U_Rhd46MYc0sI_<xq>?Qot4yf9
z_;U88>>E>laq2f^F&Nv881dCH9s9>e?_d?y_Kavm+5s~2z1y+*n2rS4P$Dl^GpFGM
zD(jR(07{CZysOH(@`Tle`+Z#N^hhBA{c?H0h?IR+ZAX^W=D;F1@yc38d*GYB`fEOo
z28a|d0Ce$gql^H+lIq_o(X!z#maP9R{&yYzFNGjSbmru=7)FY3{Jy-rJpLk*B>!m=
zTFR#*(19$n?znEiNL->|Jb)GulmY<>GVjYPE!eQ3^OJnr4heN9npk{5kjWX3g^0Sp
zT$v$=pWA|dUJmFwCB(_4aRlxX97+htP}9p2Y(nO_aqR?&1b;sH$ZKo<$YLX9ZKym0
zR5Gbmdh~L$)dfM1^66+G#SAQ>*lQ%_xp$`6t9fm^f1K6KLt1lP(;qu6ZceHOgG@}?
zWl-Rb<2R3xPv-j_@c}#~Kv}5eduLINnc<qgveRQ&ev1wRG6Ayyt*Mk)e9!U-k45<f
zK9DO1C=-;9TR=_Nu_fjXZFOO-YvYwqO=waDDWk%CY%#(nrn_+Y;`%qWQ(jzt_yoY>
z=jVV*d5+Edx+!qt`1zTe(`EgvcIdoOy}TlwKw=6qtwwkq9b`1P5Ek8OXlnL7K^}N7
z4=BrOc306aY8VJHZD5NVniQu?SrR5*WampBQbinv9@@fTgun|~K$$B?btaqsWzmXH
z7IA{u2N}-xMKS7rGs8OoAqz-GcT8lIAtUE{U1jXc6zyoL1_^_Wm&*GK^~1@bOMoSr
z5(pXD#(?AN-8%Z1+x_ihWYjpxxB+}BJeK|pmB4}VozA4$&r^hW(L`0DK#z$sx~rt>
z1=)zrQlsS55kH1R*D-(eDSmLUW3fJSOYq{3n1N}Iz}@M^JLtrPS6E7AdQ`u4DEzhm
zr*S2y_Ar#JE~h7eTqP8slxaCw(qB1>3o=G$1&w!K8SbtR1tce<+!BydYzzx>><}fJ
zOc)^t8KOzTK#skxjblK1DJ7RuyX$n~G`!U&&oN@!2Rkt0Y9UYHew^Rv%eyejUlK=?
z$_Ha8DgJ!K;li37{ZOm_;R1>%?y;;$K|u%C;b?$XVt&0(3%4?D6o9WX5c22AHEuU2
zt4&gzgJdVZ`t(1{%+%DlQD#sG7==NxQYMJSM_waY;~a1Na_@60zsKzF%%<DqeRmBk
zYk4$rdW(=3B%{6612tHI%fEPXiGAwgO&<U)6tinzcHLxnW$B=lt|RwFTzoxd!{a6}
zV6G?NT=LxT^CIDvIi|BLPYIu;tBHV;FidWKRhLXF9J$@+mIn_@NISGt(D+zJtuHv!
z(Y<=LZ#fSF%D?jie1f1jSAv?CV2sD8<T%;lNpI8B>zCG8sYa#w^;LXXAefmDAez>0
zmO({Yeah$<%}7~ZbhgHlm&|pTp!T+XvK}ZkS$MaE1HnD)0Eh1DLP_eM`O@}fGhL*u
zn1PlP#m(!}raU~kE7E~mGQpI<-Pg7S-ysc=_+DAQ0j4ssx67Mfhs^gnqbNW!ak#$=
zY~CMyJrp|@C8#+F(#t9r7ZZ~iO)-*28yS<|0p8=}GXi7+U2z-8g72qt)H-E0<Nb;r
zaUu@8!DBHd1U_l&uDboT=q%s1^ko28{P2UDjutOm_GVej{uti|C~x5hzdM?}plBTE
z0|hKG199qvfLlXNk10CHnojNp2>z2p?JAj;@>{a+e4-%<bfWeB&qyrix_jgK%hbHA
z$%{6LC4Z9kQn@z|kcsUJN;Zv)qN<Qx!)5%7R)kz<;3_Js%BZ^-ylLL3^docP{@R>x
z5~u-$#}d=#j2TL)!6ODr<IPNT*|BtVQ9(JW)fyo${btwrGV!2S`@Nkxe-p^sh1xG{
zVjcg49J`Pk3?c{VP2xoYv&UccUZ7Rl!;qsLowDs=C=v6z($1Tm%nSVp_pJRi@LY7C
zw)ReXK2Ch*x4zz}NzUKI+TF|4r%D1WPbEl=tBP?NLo%PC-1y0PDkWOc$v?i+K8pUK
znEt#G<Eo-Q`tQv62Kx2q-&Flg$kZplqSd`)?ri`)YQ?gK@0#`-yh|cOU{UgXaVA`y
za)_h1t`zrF#4h<sQU?loZy16q{wb7c@c(EZ@*s;kM>zu2_<Au@kk^N(>CxDL)vA)6
z?w2$IrlovWu+fi)w-!&|oY`dw$>UBgHyNjS81cpW_%rl=ICZX{KZCy9uIMF7??99m
zpWa5UAU66XV-!I#XU%kM*bQ6#&m-H(AGb~R<k*Wh{Ww0faGX8Y!^2|{AYNkv)5W@`
zO8(HkAC<XNG2MUo5nFg@>l^Agg{0&7`MN8#*SzoaPO*Qp)}5leSW(4|XbF3Qr|dva
z=*n1iS$z@Tm&ATbOY0-*zvHG){*t;~Ox9u)igllI9DC`1FL5*(mIGX+Kr)g^NlH@h
z_sB?Zy5pSdX#LV&(}S%cb6w$pea-wO5CxAQ#;b<4d$*`Pd+&i0u;sl))2v;)Q|5Sg
zzw+CBoOijFS!I^c6jSQHSAP6)$tV+1`ow&5xk!u`=ihLE@(vu;j$wRtBF#pf-rM<P
zo|B>V>)K)rm&t6~*^h8PO|YKnWM1Pt?;8sE&q|$0o`qBH*FV<Q4f<!1s@P}5II+xw
z-8X~Qz$>~}!^DA(qlW9Oko%jF{u+(ljpD$Iv*#n5^&KD8==QfA6AgMB(~0wQ^0``C
zKph=Yw>$ZuRXMHm9;;O!Ci8f|p$)56G_lW}%!_3<Qj&&<p{@e~Bdzx<V!>%V{8Ubg
z-rJ6GsqU4k`91-MukSFxf8N9Ea$$;e(Y`|a;|HtZ45RuqZ7VmIq}Zj)I`#d-*>~r(
zo@9YWE$UU<^uCyznLqV%9l7S65rLi6k65Tjf9U=@FpU7H#Ns3&#Er9b1v7ElSQ?3$
zutQ9K9_N_sMLpDQ45%$X*oRkC6sufT0C~L@Pc9#xHz?;3Z&BgYSCgJ$z1ZMH%u{<U
zK<o3H1bZ5S1Q2di@KP5cJW8WnzoydPPJ`QSW$>4~N}T6521j<yjeU@4<Is7FG>%Y<
zA5QL74&6cVy{G`)-}7q+=KdY!k8+gBt-^t25iLI8#}(bY8ot1^w#mJ-3c}QzBh_;o
zXzQ7>42vROrA(){!!M!PC6;*}A5j<sQ89m|GP3kDAuT9)RI&oNkHlg+gc6_ylCPWc
zOfR{Tk@3JJlk+zvyyLi_VT;y%sgj*7cP-M7ylYI(w^$T$NF_lCbrn9hX6**m!3{ku
z+EftMa30tRkJ_1h^Lt_A)gpc)9;F06U_sMA&xjq9;R_XXRVi%02{f5p!Rq$7eR=Af
zL+>l7ZR^sPvT)XVw@Ay-D=iiz-vDEEwZ#WmKHbM&!)EW+RnE4#k&FnqwrnyNLAKkY
zK=?N44jj^;;How!kUWoi)TpPC3L<h(eR=k6_n^m%X0mLCn^VN{R-%$0DaqEy|3C=&
z4*<XssU2D_NR&jhq}if3o&K1FRHnO-TdlVhFtYYZUHKdgN*j`w=>hNn<-25@c8HUw
z-ki&eHwwev*=2F9_nuQ^7x4(KHzM9l{bf?*TAJ)<a}@#san!@%Hy^Y$ChC0Bzxe_!
zZ#{mf&d|ps0Yb6>kPx!spYW05rj-=dIP4m$?#iXkmPQ2x+fWXsiem-Y241QUPCP)_
zHL3>xVF3V@uH)+<S4WlO>S_agdXuvc`2VS_%lDiR;I#c@D&J%fV$1^IQ)02MtdpM;
z-g1*I4^G(3t>&SGtSV&;e}m&MNK<!vTvk(Tba)tOM`GJRaQOJbZr|M|`76e-psI=4
zN!zBnVQH_QT#evf)qO>aQ1Byk8eyoNs#<`?T9qCSH=H#)vc8t4@P7g9CpQ9J;oDaD
zz$6gYMhH-`0xY+i2mt)dZJZAp0pN8R1=PU$A)?>ym;oS*3h>`>2mp)ZxJh9GBQBZ5
z0r@b1Qu*x(o+)O)*-#L0!*!X~2x7+7s9_l6y-=(`5EXDqixQhhdXUxwmRSPLscCC6
z^OV4)T^nNaK5xKxCSDG#=)lCD#Mad<H~ELal5aUdHcZZp5}NWG?~w^ho&gO?g~O^o
zMJi3_4h!!T-Zv0CPPH^q$9)P00A?!SuO-wc6=uU`VVLB~0DSKA<p5lt<LvGJJG?6X
z%4`-&NlO}{U_P9-m1|OC!njL6)n~;mZ+PFQ{Qop;+83t?o&)y7Z1aK2k2tfixPccj
zWjNKZioM@}6j@x#`rkjm|50$S3uRGNYgW!;6zs}x9}z4Q;}q>A&kk%}PA&@6^-hoH
zX%fhl06+NIp&vuA4)6ud^Wq^9kg5bk6rrA)tX7LN<N+xn9ict=y8o#ylk&~)bA5y*
zqp4|VnSg`^NUG!K$KVGKvEX2;wS9WuK(Ok8zr%`QaDn7UC8RRYM2fSuUV}z0Z84xN
zQ#=wIuNt!{x#XIhz_cg<GcNupbNPzu)}e2?HXZXu13NL#ED<WYYygLhejae1YraIe
zPpQqqSH@sd7ufOGCun5$ult6e{E(W$z~8THL{ZA-<>D%;_`x5yk|f02DhbCxjGzqj
zo4Y2a8E7dt^4f{KO<QuJJYc`8=~6TcZG(gONskQiqljJ-YPVkxlEAL$tUi1-7VIR;
zrXEct<3tH9lSnNML;!Ju0X3z0{DV&BUWCS6{H5Wk{TD7|oFaXGS2T3kb1ILOfI}||
zf`Swyf~y9qke~jDfy29sUlYjiSmLLCURvv@6G|2}SarNDwO}b*Z9}zw&s=LPDc!i+
z9(ei+T9mqczlVyQhOx|kP<2rPZ!PCi^hhIt9FOHYy#&L$c`RoLn6fnPqBNzym>9$t
zus~QSgE^&Bj&wc+KcA<t@MR=;MhAMzQ6m#a99@RN9}o5GQ6^AAye>zeO|Wx><g161
z=T|@d6Z2&O!eFnx^t=oTS0)<#>FF|-Z`#l;OvU^APsUmrgHS)(OG;%O9Zv5#LSc!0
z$sA`jW&}S|noio5NTdB?`UBJ{HHbIXi)idSKJ^8chzmUCi~@sXSdIru?W*XG)pY3m
zHm8Hl!<VuJPDyO)iShkBvsc`iMX?urYMvjez_Tsm%sYFXm>*8LOQ&!)0q&M$j(W{e
z)8F>{e1uzy7NcaJI7EftKaP_`St9X=BQ`m=u>;Mn#f#h|56C_j{g00uB~S88pZOzw
ziI<k1YLiCFQ*@#tc1peAt?@I9lvaBqYQ&P)bDX_itgG=$E9dvt%B4c3MnjxxI$E`+
zeYelH$L^QLHFMI`$Py?_V)uJvxYuHwu^e0>*w&WElcRzE>z!PGLR}%i6%gnl1{FBt
zdks@<H`)jtTu1%=?B>GSd)*$a#tPs^i&T#+|48P@z0ke~2vo=zmcb_jgwQX_A{&{i
zA0QcmAn!EaPi<GR9`y!F;s;ya26Wnw#!HE@98xb^pQ=HN!YPTZ=Rt&DU5n;(T<+wL
zxt{gL{NnIi+L}`m%8)y}jrg|H3&l?K!nV*qiw~576`)o4FBAbnHg5d4DKH3{@jm5>
zfXQSz%sbyV=!^#RH}s74d%>b9bX=cbA&v?Fm1#}?v+U#)$xEQ@`XUwFdc_%-{aLkn
zjL%{FTK~lX)gt%zpO0h)*#LaAe_qNP=Y%H%?yrpKj$j5=ot5n(ZdkpF<fxo#i)l}e
z{Y443<vw0cd>nXu@KM4x+2fT932GjI%r8}&Oz2kyJ!}vCsG2gi6?NCi#U|+yPm@RD
zyohxDJCjh579pULUk%GTr<9^9W*I{spZ3vT8_e%ekc){H5;)5`biUo4Ad}9MSK$`8
zm(*$lxfiw?2E=_FA$Tu}g}cm$!!TbDJm}nt`p`bzE=@uM+MQZtYTAM1w?-69JB{u>
zV{=7a<pz->Ry*@Vn8<?eURRRVah0a}JBPTZGB>83+eUZ5o9y?Qy#U=%z4j_a6!;`h
z9c}y~R;jghjS4ZO)gO8o9c1yo_Hwu4xCJBSu>G9P;-L2Zr>#v&j7Qzsg@^o$RIiSr
znqIx{aOFB=`x@fHHlRsun$unX(F_is%{N@Pul1iwSNTCr4Ziu-mGQIWIkkMYh?dl+
z+IymOr)N3PT=xMUi@|nemftX0^3Y>Uy(Uz@?g0GJ`Z(0|&4Y>dBK8_nsEsE9SSqRH
zZTaz$B&MUORlZ$}jdx#U+SSpe&1mYP$G7UsaZ9|c=l$Y1*c9w_s2@c%BL4ox$XRct
z5N|OBX2=hb^CzvCoPZG@0D#9mjQ_6xXw)v*|5W_9`2S-alDOuWn7v}DWK57cS&85y
zIRarLNTJ<&KQ-n{Ia9%dw1o5&)|_KcqJn~<h^WE+V!sRspIn|jXE_u1NJh#kd(rxr
zbHBGX#^jky2@NYRX2e8`JIIx>Gx61(gn%UtNT$oC%wj;}jPo!iglNRt%{<4Z$i8VQ
zy4{+WvQ798AGoY<`nz6@*K$%_CVA@;0r1cD1@cSGFPuuNZ(chTv~@O_sfyGtpgDSX
zx?lM=pz|dsgJj_-2v0@Podq;-O%H7vh6pD%ToGXjW%6+}M^b8vK-L#Qg=_!6o@oyT
zeX_{lDXyK8e#kF=jLG&FT7wQ)UzTYcBEQ5D6*3e@LEe8weY5?;l59B}8eNcUX|K*q
zMs?0~e2OGzV6r2H%}an)FaY#W;IWLL1Tr2ieG%pxgIp_n;iep}$(T^zM<MJ22)zK5
zA%&fKfvE@G!d=gJR7T^NHM6*-%bK}3>4PfR_>``dev&$*wd*rwxkX<*23Q_Y0)Lka
z+pHW)E!dcOGIymCUrtO;+M0~ZV@ZKHQbIuL!g#>u%<Gp`+Skk-sat@|UmRjQF8EA;
z_5vX}FtG3PP#OTtDFOe(pDKvM-^n5iA^;E)Y5+)`s?X@36_t3**Zz6-O!5(!^jLY)
zGHdrCeVn&f;PLP`y$!M5l<QxbYN>6<o&#E=+7=@D9PDa^_Tl-wYLFU_f|n1$#599-
zj6u#yf-t&qD;gQ(D;gPBD!{6owb2+}0)1>E^l0f~?%Mfmd_ePTy(F&&95%E&Xdu`m
zRi#`x#Fx^znfk0C+*-%^3xz<g0&Z>agO}NW9&Ho9!nb9eLZw7O_WCa7bTenO@!m7f
zr_fS6RX^%HO$?2>h9bEJKmYh7{9Ix!u#c44Og<8b^CJYlD*zEWX!T6?tjFm{cp9t)
z+vI<~%rqk+xh!=rXdAh(U-^UR@PNo@0A|3_|Eu4#)5F%^70)aRpfpnlMaA#Ph8~6&
z=*^3W$g#5@&U~mEl$bTwe7#z=J<$=1$&905ew{GTnw2=(c2ZgwwkmQL4~Sp}$wc|v
zx>x8?_UU8OCf#9khG!cGA5bFS$348|I|BY@PoW)>DC%8O`L7@-9{?DL!I4uQHAia;
zOuQ?Y=#2O|tW)w5DSqoKL>?&im@$6G)FKI6-_GVF_vv8)0LaJU+GoL^{elP|9o&+z
zebe+CqDH<0iyg>-L?6<Hzs$#yGTgc)Q-fQ&u7#h8^LhOc|HE&WYg0Pd$IYZe#g}{I
z-X?We0^jP+IUJS#j|kIwNzE&0eo~Zr9&q4V21{u>rtMNQwMeM)+DolPF5v^pO!&c%
z77{FwObV###nl>Vg_BX~JSGay235t$L~AXaABLm4RFB+AaIdRCKmW^w2gKc{27T6D
z9p153dGQHGn-&VAw^hn0y<C|nwB1ma3;Z-ZIFR^t*KAYhIp1b<JN4n@<a+tJCus~k
z`F$<>$Rf!dEs7E)WAE?_TUe7(1KElA5a)a2;^F=TQ(~@uM2>%29#d`2Q2__L9<hjU
zzDzrJxRO$V&stQ5F1i_~SbPoIDSSdN)&@H6O)!n=C=lZj(Ba0oSL>3%+x^SyvyUWa
zk)ng>Uw$w@6!rKkhYyWbLi(YqRSi!9{9-I$pi2vrnZ)fEJ5+TML-K~*QWng9{pTak
zp+u-{jbK%Oz_eMdAM<toW<)u}Tbn%NfqRyQB<P>O=X(A{n&yj&%t0d6dmFej>M;?q
zjb**&V1&Qcxcq?FBd6V;pC-ExYxR^eG%`FN?eAb2(UFciFT>^ywRs~AZWX`^G0)F*
z3;oJMN0e2<wj%o-5E2jdzc-j-v@ICOholg4PE5#DNNMW%(W13=kT!nEwB_l+(N@A7
zGjB<pRta|f7t$-56Ea}z!cxdh-$@@nm|Iw-#YQC{AP+=L>|graM_=|4%J{c6y5>r1
zOLd>pYLqiRhj84K_}T2}$G*ML&boN}wkIz>BM#2fX(4Wc(ji049e(DVlq(qWP`|#`
zCkGsOIRf(QbUXBg^z2Gl){7?XmDWs=?by`JiU~2~67NHh%%Rm?%cNt7m0m&G^@*&L
zm>9Pfyu{?ObX7CgD_n>Ip1c|*`8K^>9{$CxqOH|3<Ra73^ot$~g;o}K_(lhGT0N6r
z&4A*`*Is68=K*m19!70#sf_j%#~`*?*Oa!YHjK3BY^<N&U|G-hOJWk>EOw5nb}_Jz
z#uL>@7rr;^G+y6Z3j~d$_x2QQ5C07RoX8Jsh%GbsqTCJ(3P8wmfAcrKihBOQj@|UW
zg@R(rr8YsSy<=7CS#v0=_8_mj*JZ~!4ojCt_gK!69gr`vm#_LL=3yOJjeA2guZSr;
z-M3v*TS%^k%w?cwQW639TRge_Lbues$_4tw6hpnl<&&J$I?6`tnb)d^IhRgY9!pJ)
z=aH^_$->NA>6(RyJ9(38Khzi2a^6u2XlNZywqMJWW4X&>lhso;X4EoGX&#Us^{FdQ
ztikj)2es@TCwwybe*a*y(d}9zbQCLe7of{JeN<18ekXW6)K)iTL^9a;G&6+g(D>IA
zVICH`85<pVJg0P(`6KD#uYGUmtS3c0Z1ff|ho5T7=Iuk|!h?f!SeG3)@MTy5d54Sa
zGv~nO2Wf}gwt5R9@4S3g<V`Hv`+Xr)&lhe@bx)xA?V6S-Ozqk=Du0onoH{@l-|-bK
z@ZQG-+&ugo#^%hgv8hICUWWaU4<+dcf)gbJl3aN4w3xdhleCw5$Gc*M#os5Nhvz0A
ztxIIZx9xR$BcCKag>V|Q!V?*=*M?GVmPNG(<1Xi#gRXZCZzhEtFi9qdlMf=dFc*&=
zn9rr<_@A}-fxDci@FEgAe*3&#tbh{_i<XA1O$V43Gujs`5^zJxo_~dvbxL`eU7z*r
zjC7E`DvF9uyR7pp5*$%d<&sDy&<MI2uT**pg+ZKt*B&yL{`RpBwAxVlqkpF>@^{$n
z^@EO8O^0phN}vM+Q=DGQ8oEEirl{a~`^h#kplZkvY|z>5LzAKcO;RKBq8XYyaZ292
zojW&?E)EPt;#9M=9%Q^#t?gIkRe@u$)ciQdEh$>0GG{ZAzwGyu(SvV9iG?t9mQnka
zVl2DZ>i8=ex}mfAeBNg9AGYQP<UpS$1*fMlJ>GJKXWq@&K=+{>W?#43#lgI~{HrK5
zurYrkpm$z?=GlgrONtJS@a5gQCGN!@{^0wkuY8JNHmH%m?nPoSr$^U29}>rxG)j)9
zPAQ5Pr%FG-);6Y7t!7W(T=BLASU`I=OGvgeoxnpRSL2xCOUk6Qt@{jTFqb(#T@3Q*
zFco?snYyzeI>yedpBbKRYMwOxt?}1SPfJ8H(JO96z)FVVn(2#2t@_AGpq9mNbl}z+
z>zU*4z!~N-X!~6aFc#*wVWlEwRyqBgF+~FFlF0w+h$!8B8#5gw(roDHemHM0K#isX
zz{ir|8oa}Ak!UyXjJXP?K1EFlxydUe>_O@8F9iauGf1pX2Arqhfr+q?h+1il2ZEi$
zL+(siTA!tU#y4T+IRB!^+@v%H*s?qg?dCs>qQKM9+JZGXcFgO%?dWl-BBt;-5iK0<
zpow6_V^O@m=-EERlpz;H(2DcXl7X&&<KFH<1iG0}T19LRYrGL+_fxeI-Q_Mzjhw8e
z1$Jezzv=kw`soJCmTD~IwQmJ?fG^)I5uKq9J{&gr-C($ur}aw-f=_bre3xCzE}M#m
z0(zNEkO#F$g_<97gk$$Ce>1%OV-tb{6!V~nco!y^26=HW*UOgsk#MbV9UJt|{V@E8
z{l{lD?mrB4tNaXv9bN99vSaAKJiR{ez}7TW5Y2Hz!yCa~^#d4~MUv5N&F0bDli5f_
z)$>`_df3x}!>g)(Eqy`_`PD2{&o34M`Er%ci@Pu!Mj7Z~M*d-~BLC_liRpW+)^Ha$
z|FEf_*IE`!tMH$SI(8}k-|BRyHPiWE8}l688w<RhU)`ep>)i|evtK6+j|~y>6B0Zx
z<-W>Bs-%xWW@4HC@cil?53hN>oe3;WADW&iA-ZlyFAAaNc-xR+L5Q68`M}TdPZ2wv
zB^b`Lqi)!$_;;gGrDmm2;0pHS0QEySt(S>&nic371LNQdHntN5|7q@E*U(n>I`>jR
zA^LJNN@3zD)@~c_lP)QCB!0G$<Y%96sp1?@onJ6rg-NtE8qkM;td<!{s{?Y;A7Lr)
zT70~-94)2)bU-yTiF$vGa>HVWa@)cE_WG_6PrE+>wBzRo1Def+X9T{l1cmaXB*M?v
zvtk~4j<V$`F=13`|AamVgbH^+lBTfC`M7M%^jFlCcQM>duSv_B^km?~wW>|hRdv?W
z<xk(bRN#!zj$$5k>bT;|OsSH@mmf#mxy|5!zsKMFPqb?<Vbo<tmr1)GK!_^^OxCZE
zQTri&;yLvw1|DZR+t6ZP-OU)hY=zI#>#385MJ;U%mupZ%)B+VX;d)5S_d)t1U|7ma
z=-G4hQ{U2!m-a*Rt;F1_wqfw6)NlRdyFEz|V9$np&sFAVC0NWL;#c&0r%NgZ?h$xA
zI`i2YT%quV*URIPxNmpxy6!-6URKI<s!e0~z_UQ!f#HNX;-L(F4-7|l_mOjQJBI9V
zp~Pb?kCR5TiuLt%zpGqw0Pj19e?sq`)j51WD5%|Jak4{09C2~41TE3`%lXz;bjV^!
zCB?taxzE{J>o5v4?~uh8>Vn(uxk36*4X)cA-+Mv>A|<79+a}^w=@Y3|S2wQHJn6bK
z5hQu?waVaE0-~bAbp3`=Vj2GZwuanQ&7^B>4JY1W4`H<uu&>jI^s0CbQ(%&uVv}S4
zz9gxL1)O;wB?o1QE173qc-!}V^Py2!{-gR~2l2CbK0726wSK*$Qu|8Fw5R2qHK7|!
zD#0Rl7bus-5#XrkK+Nmb$IfRJdLU7gEy3(f%1g%$EBl>46m&+<AcyZ>>WGd*J`dy8
z9pcb*Nu+G6h51_Xv6-t;TlkBVH5o`IW0xM8T5!?Of9J#{5rUV_;L6!ze%g&7v6(C9
zbXQ|E5}W_}4-G4#cke7~v?SFEh%lARN2!+#2${M^uHhVy+AO#@uSYsV=0v)meTz*E
zOO-afq}{wj%&U_69Qwx6Q=j(1$aN6cfVozei=V;7B5UohFl0^NQYWY+9EbzX8-goa
z1CBcQg*Oozhd$5?YhA@>=2AM|$-BiCe|N~kyq^1Na`q@cgg`i8VRsvk?-G_eh26um
zhg#j@%Vz?~gzP<Fio=PFDgwULU;it8T`k-+vl-;a-M~_2NcU;;O;sY6VPqmUse{hp
zuWdlQ^@;R8ZAI7|nT6vWwSOH1x7|f0-uT*diWp_*Z#(!Z?a-e6&7nPW@JX%BGag&B
zwHb^pqwPm0_XJA2O_~$72U+^>g<ZT#vbSqhQue~7a!e%e!co#ZK^}Ebsj+G~yWJU%
z0u8MJ34=#XHyFFK-}l1T*55O2Ge2LwmcA=jMSJ?au58`An+Rs)p1io#-v!4vG{+Cw
z?fN!zTPu;&xt+C{3P^~k<l9doCRlprEpxqG53OlhSK!glvD`pyu8%aNt{;V;h<~@d
z=qhQNemKUu9FHUrhJ>|#(s)7&R8>bl6s)`#mdwm81hT~Ka>C?2;yL|QtVMg@dJyxT
zYsmN9lqJ;;;@d{(84hOWCDx#ze5g4REwsos^>MLeUt)5j#eTeXFdK-Q_WHW88+`EP
zcChXTvX61|gaD5thlUMyEEs16)TDfx6r5iN=%{*2u{Sn4$Af)PiTu2jJzp0~Pf@b9
ze<7(>epE;+2~$fmNLVA0hwfVmH#7Q9he*;WcrrJRaIo;fDSTc^^#x4%<;-`Zf&tgG
zv339EnrX;q&B~QZn|Awq5_BNK(pTNYaC`u^pWg6ir}X!wRv*P+2u}SuRe%Sov>y6&
zu4W3*Qb#(zZw{l&Vg2A}AFL5(urKxk_;#n$;Te1zonm`o;jK!eWSX=^!TrT)MFKwW
z*$u>HlSKw+OIV-I^ykCFo)7{}!2$+t@6aTN<ttolo2_}@9wVbaOiTrFDI$V^Mc%n@
zO3Y6gg=7xdfMx!eObBkyPRT{E_JzA&z9h3pdPL5PxTu3=NlihkLqfab6g7E;PnsO9
z%=}ar!o|O?Wxt}S_Hd4Hw>bE=qVTA1KLyV+GH&JL?2C;_;}2zA0^3{t4*$Rfb~tKV
zGmuWCop7DOd<`&7vi)LkvSW|mMUM}dO;czxx_i%xJP{d${Jf+1OF(uCe5cp`d}b@Z
z@IO;{+@5tBwrGtqSySgbgO*QztFa)!1MV9sq|DfVsF^)s0hT{Mg%#636Jl?<eU`ma
z{9$_$FPPu4_LuiG2k_?u5X?6#>^cbfoUtu_9r;kSjqn%wdaDvJV#F*=3WT-ZVe_Q|
zTosfc^Y@~>P2dh-8*g%4|D*F6AnYSyiQ5<R?D^s#pmHmJ#o6kmMUu!T9|jaU$SJ9e
zJXoJPLDVFP!56sy9A?-MYTYOn!L5&pV!$<j-PPS<Ir*?(;N&oS#wna<hPC7s6X1#m
zjb$IQ{It86gJ(baO@2_Y97K%9ZB*_L(xWFQO1WmLQ#ih1cIsz;4?jTxiVE0UP_RYm
z*q95GE(Z2nfkT>Daq}(o-7-OwDg`l*dmgSV{9OOn?n=Qf>yw4A@gc*TLKt0_gt>!R
zd}?W+h7cjpi4vKMT!s?Z>URCS<@$J-CvGMTdlN+Sf&V-B>Dy<_k7jA)BN(eZsTDUm
z^{y*x425<5M+OgbKcRHio??7jl@=j>gXLm(2m9le_%e6lc-|MoJr1~09q->9)Q<mJ
zcrY5b!kB9|=+}pfIT3I3mIQWKg-Ke#+VvGo&IF1-Bf<|Lp>}xLJI8Tt&n(R)x2(cP
zNQZ{Pf=2AQHGN_Mn1=eO{;Q@5NaV0qOY3~zAK`_WTH~wT2nvu4>0_Qp@kVwFkC@fJ
z!^T=(@DGd5soQ)&Hplk9W*gONjcrnjPfIst@nN`4%YyLtb+1^nm0yfQzB&(j?)wK4
zS+QzAoI<4~+_u;yfg^d6?Cgfv5hUy5NClo+MvWT@DGT#GxB@Cms}04ZfQE6C4>)wg
zA}rE{)wbli42?F|hM2X!{DmuQbn3sB{+qL?#L+@(gl}N4)EIxC4HulOmiWv)P<ej)
z%v~W`?<2d(cGlHO=~;rySmam(MMi>#(EV%a&HeswmlLi6UFF&xlFO`3J>AgIdj%Ir
z(*+Thh8o1?N%-U@L&eqa4v))h7&R<>^vm8(^|PveNXQb792`p=zb<tz6dg6^&HCz^
ze3YZkb-sC}g8((NcJ>5txxa~d=o)LaIoD_I5zB@(;tgJiW5^)+#58r;yC#0-fRW{~
zi?}CsHa#^{!!r67F*1G4<Xet|VYD#*FpQ*g9$X0*R`wT#a2s_%oGN#-JQB-!)47^e
zDDhSGM_0xl{O*TxZX7-ErZ^dp<F*Q7J{Y)8JWTIMM48xlQfx^ZL^SgPbNHh}1F3X7
zi(FZJRo+}Npun-bnE&v13aBBd6DnTX{K?}TC^N5Xir|kRv*^DvsU=r;l7}TW7I%+9
zn;T#DMrgolN1tu~+3D6-m~S3T&*s_e0|uX+k3M~(LGZ25u`;;^{}=BxJI{G;o7eQ5
z4OREo{h_U559oMaOkqRu;te=J;JVgn%-`kxsHW8uElC{f`dZg8W|Cz739RI8W&2`U
zv0hTj>60oweel^o&)h?#Dv=lQ+V5ZzC13&O@H78DN@j%r8b^oOdMuC$i;Ub8S<*A+
zl0dq63JlJaziAi*m(mSZFga)W{&UbfGu)y*ph5*CH~!}sqXm(hHt{L2l2-b!Tc=kO
zswMWq*|?KU<et|eQ=aZ!&zR{GdHE8fi{?wG#UgI~{z$wgp|`0#x0}9p&(_G72`(kc
zn37zz=RJCPRD`rbI5p)fmytx1eGh7C`Vr78t%k!VZeB003(hl<IqH8laUP@ZOM=Ti
zFR?-U!9wwRQ7a8P<_nu`>KT(x`9(d+fq?1Z#+Xhnu<uqTgPK~RJ*mse_ShxVE5PPS
zZ0En+h~4(B@vR>??Xue@{)c-Mla=)A3Uc^Ercrc<NL1*hUX`@E3y$CQDO=pWm{L&1
z#^e>GZt=Uoel}|{Qv_-2@=zH3@);ez%H52({JCN{Q{cy0o$yqg7tQ~b16yYPXM&Jh
zu)rzk2jsB#xSeiqiB9XqMWe#SbBfrg{@z9FL*@nO;XCv}ap|6hE+lY4;<^qgI8|!7
zg9!A3nvAuXod2ym$|7H)Fao=dvSITQ!`C|>{^6;v(jtroC<&xNT|YH5n7mImogdOC
z1$5u4(F$;#Gl(^HX`Cw(zy&d{0x|vCtS?-0sdQtBkZd|BX`FgB?)h92MvfkbYxIae
zU{V@!K5DD&)rS)6InF`E5oUw2g`=qy4-B76WHFszo|WVsw%@B7vM!1liU{{F=$?|m
zF_?FzLiYp^x5@;|@l}API(-sga}o_{*9u#Ftfmz+*}ZxZey8B~nPlv<SUk*F)@n$U
zdb4VK6>@6R2;JxQCa}aT%gCm!2W|BMiGDeIp3rvp!<9H&a@92iYP4k4R&ET-=`@w{
z+BfieD0<_I+0$598OOWw!TA)Zk)nCD435!aWx^%rGCiv^>hP}XhD0($^OgtFA`4h=
z4~2Sm`I$p4;b>_d*woJ^1A_8AdrgTPWE66Su8bswT)!YKO_-0{f_9U(L@DQ9u{s|I
zJQi?uC}9LbmML&H-J(@uq4xA_+MsrQGVJ1BhE^5+L@P~)sH>`1$nAoo;cuj+G6m8_
z3Z>S1rBX%Wg4?4T^+*ptYx4usr*f)=qc3o$F4yu6a6etLPHFn*x4&6DklM~_)a{}z
zEnzmmj2^E`+G6i*;+@u$X8VID?0g(BdvNkFzCb7^U>2bgESSr^(%u;WlVu3fSW;?t
zTB4nK5UZjtLu?$7&yFJ>8*V&}JGOI*=`Q7fh#wy9*9N1+xxF2UHLuZjXQ87zVeADy
zByG(Y&Ka9$-S@x!T4Hucm6mS9aqStM$hXPf-GjmVxbO~fW1Um-8H|4YrbK^EETQE{
z|ISqB-gi0v!;@+LiC0bV-!2O{Ui2gY=lM+30*kU$6K9FPy@xg>sV5FUn0xJaoa{|x
z{rEj(Ba0(uM{)wsrgmU9gO&D~6tf#0&RB_(7j&m-d9ou$u??`V{LB=u9(ZkV%p*=d
zGm;p~H2=Yg)IdcAxY<59h@6ycuyxivrJkq*>LUb6zk#1T9640xpvC$9eg-uN=DM%|
zu*x0|CJ$v^<p2D3+dJ;<)^lDmSP&oc)*se8q&`Qg)B$g-rr{bj8?VD_JAJjcNERq!
zIt54!;$C*#(D*h;*UPdA9JgLHKF3Jj-M&CxJ?-?ZmAp5Goek?)t&t6&J?3TPATI;_
z3&ld3Ti+$<z1y5^v%=0;PRLzJ<HFE4+4N)YDydH7oD3^3ZEd6H^~|V_X79vL;O%D_
zJi4rGxv!*mX)9R{dZ#yLh_{u+4TTy=zkJDq)hd0um<gu$E19PwZ|rxmYT|6n!bK7K
zJ2kSnUBDU3QmbG?JhKRZQVHj4`OvDz`Ou~eND!;qIs%T+EF7jX*QSdMlJGTVlA7Tu
zQq+56>}=&%SpGPjmpM!DClArC81(4U9-_2vp~>Wa0^TRVTh@3%3T(DQI`yxO+wY)x
zzj8d6`Z!*T6uGonA~Fd$4xX&lRAkn9aTR1Rl9VPDq(}tN;Zl6!7PB{6+N?}6j5vNH
z{|e{Grp2wJPwM^1Iv2BGwT>A~JCKbeF2ud<x7j|g+RBQ}Qs^{1KcB7n7OQ#-1souf
z7mf+ub(dHl)*;`Y)w8qRWjB1EFA9-E@e25abUBr>Ycnda@;F^|@tlD%@JSl}InD3|
z`@~d%l7J#VCr{&`R3wLQ3H>{%tC?Nxs-Z}vm*Xzlo5}RYV+JW^JQho?Vx}^ICDX)2
zK9MOS=!lP%VuRjn<70L;uHq_Rhi%Q7rCrafCmO<ts)M@o{f|ncF_0;SPS{!<qm;<w
zaQ#?)Y0vfYhsa+`qJK8kzt(0hs@vl7LkYgI6-_xBcq<o{$rzTHqy4>drmNg4&&5lx
zClS535j%eR?eMCy--l1UbjEGXd`M3QhmdY;z1<gtw9<+kp4N>r1c6uA>3M$bwNo%x
zce@yU8#}dl$5T(9Wp&KVwC#HsVm1F<a>sqS#nUzMoKYG9lNCpJl&BhAyzK|OsWOB0
zU$v_SJS{2>uN+P*tAuSMFV5@7W0^2#lfRpOA6q}$O;TSfkjiS+7epInnc~z300^)r
zyEJw=mxKPlW)wKo>>cP}@8iBu38DILg2R8aJN}=iwv@9U-rzm>x%ZCRfDrd(A}$A3
MK~ug`)-vS(0P0TN6#xJL

diff --git a/Templates/BaseGame/game/tools/assetBrowser/art/cppIcon.png b/Templates/BaseGame/game/tools/assetBrowser/art/cppIcon.png
index 8b027957b0fbe3594c73d1abfc84390b48ee152a..3f7e4efd502bb2bd8416e9b1e2e19356c3f7d5b0 100644
GIT binary patch
literal 6954
zcmc&(byQVbx8H<xa{xiQr6fc^q@|HA$wP^7r2Ej)EiDa_f`l}Zazq-DZV;s7fTZNx
z_q*R4_uldD_wK##pEt%n<E*h_uHXFaIe&Alu_M$~<?(T-Z~y?nS5$bc2>_^I6BWS1
z0RN6W$Ibx&&k(My@2Y9$LGS47@XY3g6}_vMqZPfCr_D0}@SNFAGjzWrN+5e95=o0{
zx?~~jQ{iSkj6mY+D!M~vokkk`;l`XAy|U!k%K#>3_0yYcScd-rX;vMp63^Qr%byW~
zx{GJ(JIA9#%{2!t5`LGyr(qXsB1=tVjiIpIf{XWEzR!gH7wIO)1^4=!L$*F(p2wl>
zn)IZ42ZhO=%6&AxGv#$}Y%k<xyGQIK@@he3JYkXUo8Qo$_hn<=##hfMh70E2)gJGo
z2kY8Djap(T+n)&D|K5KqF2=-PDDEw7#w8BV)ZyMe&Y)|LJg4$?F+Me<;2y?;Ok=sA
zWGJ>zMT0}@)sJ<7?LqHDhbhx<?sOloE?x8OXxW+l34<w;Mh?%v`Le}@m_Ws*T4zO)
z*M}tLD$OS^m@+VZ&i#>3PfR8^4OFN_=ELCBt3Ku?dJb8|B$Y1`8L)8aj&!`pM$CcD
zT7<g^LT5eDxp|`qX5Z{qfxuUZ_WL<7eqko5=Rn?3;s=!DYM9zz;C&Z>bkGK)OJd&C
zc4gUZPun+|7r!6n8y6*Kf?r=+wTU|AWI7I|6jxUD!^X@)+&U^LiUPxD8?;u1&ko>M
z8b)YXeNHal0tVe(xW9I_-qI76#AL;p<V-cnK1FQ|FTZ7B1fXOX5v5kKd*@^!;%@~|
z6<rYdVxq7uv&o&`R(QYDYj(1hwlk!C@A?BiW$5#l!4UqbS4jb6`9u;T<mM%cuh<zC
zt08YkG!@d#?yeTRn{n>pQ&tsOH+LQ^4<?C9(ssUEn4;^8Usa*~<9&(&4EAD1zv;l$
zLK-%II&6`e4c{x&8=a;1k)!4x>B*0NICCVR^24(z%{tAkew940b~zzg*Tiak{6Stl
zBG%A-W_qW3+g@$VUf&;ng<-oVH%M3DYVP;u^L!?qvTz}(#(?C2JmwPRm}GQ^?!XHt
zKDewZU(I+T*)pFdBy$tOM-<)fHN6)xACvhp${*LBH8m*X#vxt+XI?1&g0dk_J;NZo
zTWUv1#;p|Ja#4RUbxkycc`IzB_C=e?pfy^%_my?tO=8HFyNnNYvv+0uR56ovQDou>
zd_hZq0r@^k#cx({w>-K2RyO^GP@s+XXol}a6NQyCeuU-cxeRm*MhmkhF7I^~UoC=D
zMr`wie#=PHMHt};hj!fej918u_YZZh4Q}4UuRS#orS+m-`rPFkNp!n@0_Vk6<*(ZI
zWy3DL=WJx7ILaXhb0bBOF9xgRRwFtkbUfP|(~+u4I&pj!)97vk3tCcU9by{@;+lwx
z=rmYXlTM3J?9T^%YfurF^k>R2D{e}&pToF<`JOq?PKlqA@ITb7tK1Zg;hEgj=xp?z
zu1DkJ{q|_e0Y@cy<VQX}gtYH-lw~b0ImFy@EjL>}S~{XbH#4|}B<JN)_55@>#vH{n
zLYS@`q&P-<`JoUahXq-<q)V?|&`lJQX=~rP<5oG+MofIY$GafNJnseJP;<Ur9kPRM
z(h~Y=*KNywt!ch)`io%}(0Y3Qg6)KFQcfXyU3aDmonFb^YJ-YyFZ(fUgLVbod||Ba
z0b7_{jl!g}SqpjFj(&^w#AyW&l8iGVm?<vxuJ^++I+#uCYwm6u&D}O)DwofV6X9K4
zIs@-3Xb-NXRe3I3B9~l-a=h6**Qhr7ALo-Am8;^i6L*+BB{x-=pS`2@wAZ`ev78VI
zo2$j*F6Sg+Vqja(uQN3rtYme(;?NfQR>!hqKE|U%Sa>gVqBBFID?KZSo%O_J{dJ$D
z)n?@b!7ZU4lHIegq*t#+D&B^V>(9|j?W23~qOcKMCc?{l;4u*9U|sp7?pzjQvm&`J
zySEsZg!nJnO9od7y9E<0Wzar_ghE3erQpJvbDc;}twekZ?vobt$CpBTn4E9t<9-)G
z?u1jJK&~7Uo(VM34si*PJbv+2#LQ<taPLz_&8<7nu_mAJZjxkskHarR>L{){UBh3!
ziwmt=2;qq;`cRsdE|Jk2=c$MD+Sl^t=ZIY~zn;SEw1{41OeVimLxQ`_2n>a0TAbKz
z8FN><&Q~XmZBas)kI(eOY#~N%Lt42)>P*4FSI0~Tv<fuwZQ@k412ngC2&5ocd7WKD
zT{Vmwj-8+kApv}k>~}<#!%+iscjD!09ar>NMtqu6+}%4Xg%chHb?G8=v1}7KsYZQz
z$2LEXVM##NF_sgk;_(iPdKEQ)pk_oH+t><ghrq3*>uIMjZp#wj@mk8{!i8-(m<*}4
zKh5V^784;$EG6ix9Z?g?5!)qwy#hl}(dp-I6Sh?1<8;?@<c$r)hx`Q)8NPrtb_8s|
z_&!;u_SSe9v?eIkVb$*S8{R>|m1u#P^tB$HdP9wcSUsa+Y6-fpgZQy~d(6At))Mm8
z7*Y){!Uf=&f@|qC<bn2z=&3;-q0nRWW|nF_cg=AIhdn@9Owc+-$>^TmDf5^%GOl$>
zXVVKaE?nIM=-ttr%Pr3BWUO><;5ES+%j9%TA7RczskCE}%Q~|U2=Iv|p3T=x;E64w
zP+rt!46A9^r9WH9hP>hEB;}Xa<;Z<`l&UTir$6cNWuxTCyJ)qfh%6nJ70YVlq8qWY
z_AKdESUf3>+qdzuK$+6aypiRI?Z&ZDzu>tykTuCb1qgcNbFFZyso|X}SGNrkILEaV
zu{O#^yXGVnQVZ_r71MHmcmId>@;oG=MD`*{^1igFZIzym0lc(itH$(Um!)6c;KOeZ
zN{3Xa>@FfLk2MR#2W0*By3;vi7InD|rw2<o&6Gq?6DI`6zocl7Gt`!`)fd-$HX9#>
zIwRgJtkc`Lj!(+!h;>vMtmSS-s`Unjo`p->sl-=2oS?m8R38kGkpIyQ%{|d0iTu!t
zJfw8PZkM;)wl*Mg-z9L4tr^9~%sc<k=J){h6AO8-($L0Q?JHTgdCT=Ty6$2F)mr3T
zK6(6v%%{U*P$Q#_v182hmF}{iO8%ZYmt&<#+XP4p1L?6hDe0phcw3XqB3E@4scTCg
z#;d~#+kOfPo0}%k&q_<hgorlFCP<(QakTI&y+avrb<*BdhF<YkJfL3SSKlk!N`37e
z%{3NYfm>rP-+E3*Aeb@v5V^OBV7(f)&+^3_!)DW&f5N>LhLAv^^@7pO(zW{5OE7Ni
zRGto9uc4u-;)`HR%?7J6oog!C22DFB=U9A-!gioN>p&^MyWCCTAovs<!R!4PEoI3&
zqt!-=LG7!D<6*+j`gJwK>wv^*Oja>8>5TQSGG!lDiyKO?%{{cItc;f_=ecF`3%{*<
zZL0(lZS#_eB_2mn7pc?wOdwf&kqrb9tLN%F_bNX7xh%Vt?-Rx2P<&cq-Qv<LP^ePn
zOy_l%eFiV8XXvSF+F#f-n8{tFA$^!b;HyFdJ6p<sA<&+az2`wL9pc%@+%@ttzb+%B
zT7sO#t?c_qC~NIYU3W@bw6u5r(7Q&Q<rf=y-nGQ@rHEN|;6>JfDr2aw9BrI#U5LVb
zT!PkNe1-d~J((NLm6yXW@egk4H~S@Gy-rGboRPNK9qhT0THv&kk`PVJWNa<h=mHFI
zFc6G(<8hHD#fm;z%C+PC4q+XTq-%YdKZcOwXCSe)Q5X$UFF3c4hP^Eb|5~a4h3=j$
z{g5(4O=RIFH>sjj3RgVqz917Z>S2C<NA*S`Z3t7T_;8!W{X_xA>am_|Wv@z#t3?}n
zq3Slq-pkI=VYIN`^V1L_XPO}D5ef3VZ7WyyaU*WrP!DB{AJK=RpCoN!8>@5c4bz{O
zSoT+Eh9?x5W8Sww_E@F^&K2&#<h1(dzShhHcUg#UiMG(-hZHT+5(TK&STa*M+<6*h
zyEer<qaDIxYXkThg`4b=f9Wi!)4%P{tmHJxB~N^mtsjojOdd&<j?Re_>3-j6V%h-5
zuEq?u#Ijfxns!o5Kgyd{;q_HNs4<D06z9_f{~aUA%1(P7Y6c3fx|)$>gnWDIs(->2
z3?p47R<<&U!*DykWI&q*vtq+SnmsO9YlB|K?F>(0!zI-;B-SG(_<m2sC@Jy&<2lj{
z(HZDF96C!o6@DijnyfRtWP$W?d3^LV(M>A;nWWoH8=)s*_g{rnDHHFmN!?#QR+$^_
zZhVkV6<7P(A~FrTh%oJhEg{;ThdFesc}i}NXM1sgy}sD>O-Q9RH*A5{k+753AC2s)
zX7~oq&?o+c6mmhQa#!o#+>rPH0HB1}$jGQG%E<ipH3Pg{WctR7DIg@NyG#vXIvfP<
zL{2^GSzO_CT^gnO=(vUD!=*vJg{H#=42n)p5F=ayKQ3Jwqf9q9M>6z}ghWC@Y_b%0
z5BwGLWTP>=uRJ}FPNxL>4>(l#KCl9^g2&pASS?-3q?gEAH$v$I!XpQUNjAIijJhYq
z9{IFJ?Q@;F_{aK*IPi8b5q;r%A`~GMo}W?l*(*o*lhPX%AJs<{qqidHns`JmKQ}$E
zNwp3=QnAeze#`|C)!%~Zj*u<eELXiNNkR@j<Z@Y9ey45w&Q0yQ6KZ0t=#sUDwX83V
zs)+SUU51kEb@*^;f;qkH1s}yt)vj8CGNT@4G&OFCbl~%gk2gym4RU6-BZ@emftx5R
z-)Pi8<J_kW?~oS#w%I_N^^%g^MHxQyB=HDth)aipHrvtVW|(*q&`$&1P$YHxn&NZ6
zH3W6vPi`>@4Z|U@O|ZCOLR^(D0MD(?2aTE<)k3z<#KX%&&D!B6+vfNbt+&9r4~6!;
z8@&Eum@CUa2224sU`9V`$_@5lJ1RVN0RUXmUw$Y+dgg7g6Vp}ki7e(SHU=g>GtZ}Z
z7O;!bRaW0s#=*|c%H9=_akesZwX&r5uyK7(FR%DST`!P;0=!nHD?XOe2Jesav(ARA
zG@rkDC{|nb|G>!X4J8s%-;ngyxNV9dzV_fY&s(wl-6ZBGbHbl=sU2!-YIO+%R1^bW
zaEVr5KC({3j$N0)^=&^ckBPk3c3zDGI2MjY0{}Vz(1S=&000XBB*7MVuO$M20I>DH
z5B<aG^q|3CH~CxEf154|F8meKpY;WRqyIZjaFrxD>F>G)PXCRJ0Du?u@3HZRW&e+O
z{{|bsx%WF#etk923Bl-qr+Ss+qnWU0ZZ<5i-8wEFE>@l7QYESwxpbGo`&1IwmFhal
zfyNB78qA7v`5G9-L7B0tiOg0{i)N8)n;%WGJ#y|qPywF&H6wvZ-H93}7!%!mTSi@S
z9dmCZwY8Za!|sW5`r+YS%>oFZr&P|aS=a{^9ysXLI1lnG<+$7Ll<j`<W4;wRGQZh|
zg+>H8Dsm0oTMIfiY;svqeIP#7^BL2ly8c5-X{lz4Rr+8E*S$KevL-6`<YcR~mBf{!
z^HvIf6I*U8&xbvY)a#1tVbrH_0#tE$xG2DA1$(5Cq4Ae>I{$1nq+bFIX{_8luj<m4
z#{9OABSsFftY%whU=US4FgSQsOR8P;^|_^=z4$h4`{zZg|M$w9%M37>I%+du1BI=_
zL*>UAKQ|D~Kfmv>*>KnU8J*c39&&CS!@(!=je?F&T29UvXK#_R{xT7om><wnDOwMA
zd>jzQ3oj>;J3@QkhstB#wKrUwAKZ9Z112Z!-Le`Go3T6K^VHC|e-I}0qc}!Qi_><K
zT1?qtN`RL~%sXeG;52oyznji4Nn&n6!TYTpeM?=_XQPQl(=XO^{weL32Va`%KiIQl
z0k3s;bwwv99loERAJ>u_-YpwZ_vAc=i-CBWd=K5lTfErHl*>XpRUEMc(rTxS24?zf
zCv+!9UOce7IGg}IfW1$C!|v?rd=%BMNDn~!1_alt#|-*9J71bPKC3g}RxU4m$5n1=
zw!qgFO+6{s@y-t_v~`|>ox>+c^>%U#BM=C%S^FT7sH>w>>KP3I9lw&=bxDtqw^|h=
z`GbCRXdh%kS}a|>`-z^-HJJKaU`?U?gVYPCIj{@ZCs~AGPJw~^KlES}VG-acmoaM?
z>e%Z!M!NHN<jrx&hXTlqKkY+v|GgsoE@i-N9LY`4(XDHnTCK2Bqf><fY5qz(JGy>w
zK!uqqlW&0_{%Gqr1zF;1!NOXIAKc}Z@sw|A!TxK!JSlo82+?J?+5ixN<bSZt3}U^p
z{ujlWsl0!UH2|~&`p9e3hKFUc9AyrO{t0hTxF;Ub(DPrc@=(UXU;ZTnzqdNnL(vcX
zXL?%<%+Q64Bmu`R@scP;*>5XU-DFrmMN%n;0FQDI^v!3hv{Gjy1^^0|DCxFRRSTm`
zwLm}_`$`9%yQUxL17OJ7;>#mIK{$f9M)y0FmhwXulyr3N_Vc%z+?)3kLVO)oCjxlO
zF%VJ&adFPBK1tskH$HGXl(R>=de85;om4lpr`lJ-{*_DM{0q#BO={N>x+DBx0g*@I
z16N_EhgbQ?8vjNI`T=xP%mI~$do=643yHPl<TYakN?`u1`HVt6xpj0}rv$f-y{ET#
zRu_h@eA->^eNiL8#{x5A>u0YS?IXWe)f`%t<64D%7qD%ch7`@pN&Ij<49SMcLB&(%
zi!UcGH(!HxE~^rYF}*3HF))I`%o?Y0Jwz7IQy<4_rC7<WIE5n2?2X%#lUK>mmW4nq
zG-*#Al428W7WFzi)1bXvm!d^VsNRgNGNS`3g>TsXoVssnR;;~_5cy-<$DoD_+$O00
z(2@?n>Xx}#H$)R-a_oxB$cfEzdb;N7nr_mbF;t^UyC*(?n3td4ebno8^C|Zi^89w4
z+OH6*aw{6y;@;{0VwZa4YZRJgO*hG=QQiD2PCu9VMuJv?sI#dHMP1h=z{-%dmzx1T
z-C4#6;4EU4{@Hmn0f5p$wzBL0@06eiL+{s$Bnh_uLFtwRZlnCugUoN6H6~EW0Tk=A
zmF-@ui_>!p{On6}WTrmHR#tfX_7uK+pyjH4T$H7`CQP8n=RhJZ2lE$Mr0^#OM;hNm
zwPOLSgJOW=$EZW3@t2%WU%;~iuWZy!2G<NN1^Q6NDbR7tbF>TY;=L_hf8mc@Y%J+`
z9lD58!3d6s<XpAyGM<#)3|#>MKmeu4AttyQ&H4rvl?Yhcp#zz)UKa<mJD`hVsm=?J
zs3=nz``3IAsB!-{T}us(*hJ3;3bIu_6LSuKu*BJ%(flrN|E;+Ky;=aT#lm;{v&H8A
zYc7v*H3SlvLJ7cKk9zrwAr+cb(5+Tmp^pzlpqK#9s}PD`4{bbaa+1wNAUcnw77C~u
zDfnu3z;7VH>tig(QwflZ$krk0%OYav`Y)c#5bu|UT)ADx*7!q7KuKf0jZ#_TnRC3e
zuuP~TebA+6s{0v8bXqVxCHDubDj6<HlmxHh9!h|+W0Cy<<__33gI~3eh6+?D;OQTs
zfXFg&Pya-O{&tZ3pJM74M*cwv{xNVt0sSq${x(i<)gQ`Z0PrVO?LTAshtq%O-9I3x
b!|?20FNJRfwJ(hp2oF${Ref9`4So4vX6Ceg

delta 3625
zcmYjUcT`i^_CA3qzEP?mDiC<!Lj`G4A`r?T3?NMrM5Q^j&_d_|fdt1VQiP}xBO*a`
zPyq>p5_-`g1*M5dmtrC$p+{6&B=6#^-&(&v?ppWUeb3(C-sjujIj7u&qIpw82J8%Q
zvbO~QyaSE?_z&YGZ7BqSy+>X`Qo1tNp#d_egn68gKZ(U)f}`T0Apj?1gMW_?4pPH~
z#fPfdJGz_>(hZgXK<*Dm+h0ABMi<7DZ#=*yzY?HB5<_qydP}2C0+q?0U$b4L3jce0
zRPLF(ntND#S$Y1Ehc$A~U?q=gcWoW<x_HXt7rWDNop<S%ZBMGZIJp0!VB}Z?=cXS@
zRQ9iKndqDdOhls-LpJPfp20E4Uq-xG>fvf!$deaon)hxpSBh{G$&()QZ7&hP+R0G~
zMv|50lBy1xid}+}+7vZO`qJ_wj7&0V;oyHr%TiJ#(E&5DbXn3B$TW38fixwvbK69)
z=8WD*k1M@-isfY17;u)VVKV)t+LTOmX-M5u8~oU?D9c7`@3nZ%U-<E#-TC(_h8}rT
z*p>O^yqQgXK+$9I*JJl|_cHook5cYwGdZOJ%DUu7caQr6*sI%r=@b&R%~LqjMcM(_
z5~SbzJ_QV45r4BxhJPf8vd*Q+#=Ito1l*bOfuui;R93s4QLA&-$%8vVsI}Jj$qUGx
z_h}W6wI_yC{F<wA`np}XmQX8J|MW<GTI{jKdk1ryo-zYp_|akj9OQ(lk#ccWKB{eF
zZ6>ufig!QudX;%{#?EpCG{dLt!8f<=l?_E20hskmd|8X(gn2Z+IhZlaBXk7G2@Ku5
zxE%k(8Jyjm!|W8sOB3~UFm<g_%`3BTa4~a|r{eH+B`H2p%hK>NYHO>j?1-5b*ac<S
zJ4EiGU-!c1K!FuU;zLGIRaxt&Qe%X+LPkg52~+>t5*Q3v3Cy+6v7Qbt-q?za8nI+G
zgd4Y}&UmDzu0^9f2}ehG>EK~P!qfMHhHr`t@6Dl_t~g570Q>ICr<?_rDoq^dwC985
z9))$vaNEkX&NsHIY~Nj1*4V{)Q}KEk8Ch8YlX7Kkmg)4!f@H7<%1}GWOVqg5)wo-o
z<R=uji5mz<>6;(e3^~jxYZy7<gP$3)O|Z<Sh08|_JR^LV>nm`zN1N^S<=67w1_hj~
z)u^5MQcY`-@s3>|&R@!-HApG#wg!Lg--?fpOAYF-wM*+dSsIWU7;qx0P&q5jkaQ-G
zYubHC!N9YM;X&JXrqb3!{X6*yVTOo#lStP#^MamD_Wi}J;TpJ}4g99Ot61dkNb2Z*
zWaU@`A#~|$+vUU~mgbjHi+V0UZ17ta>y)Ja>;b`;_RhdG-L_@X0Yqb`D{L3ITQ@nY
za>LuiPmaF>@m<feLVyfp`F~vcFf=E)znCv*y|Ti&Pw^B3Q#+Prt#>ybpH%W6i5C3f
zFI=K1=P0?N_DT59n+r<aW4K?FKAKt}$Tc_uGxut*5A_5&(MBU(1K8Tq?>p-vCK{0E
zg2xK+H~6!u!q@#ohF6c2&Iq@`f=t|I1oEp?txz_7!>KB4{lKu_@=G6yhoxH~Wh}CZ
zU-Lsnk$7pqyv5q2(+0yzoqZ|Uglhifv~ZTR%GxS$979-x8miK{sLUbVDZ?*>ro$}u
z7x7gFaV9$}xkq#cwO7wP8r#g}vjU%(VGjctP#NrPqFQ{usfGWo&Ml8VCneI?oExB9
ztX|eqKoV7m;}VOxDdTecA-}hKscrgZhTTOg>y=rz>KB){?&Sm(>&8ArDS4@UR8&PJ
z>%XOy7m3M$W7sPGEYWL~@H{en;iMr+@Z_<yeQ-h7qr2H_ypCII`G-|ANx?V(hl5Vf
z7KEyI|Hl&1t+zftxFAB;hltLoV<Ka7Su&y?iPukKT8crdQ(X70GHd)A<;h^{H=agJ
z&GEWOw4p~Oy+UeSwfKN(h&>GQH8(E0-ZS?8!}~TRb6K1snILN7tY@yZlib!Ujn%+;
zOMFX8aO4s%QdktzAdjS^{tcjMj`8i~k}j2-ugb2*3|{yG#L_>H3=blP5|Q}6VyN1}
z_JV(l!)3ssK65WB(RnX&bG?KA6w)Cps2$XO+t|$+L&{nToVke~;=90Y{@*?&Wh7Cn
zKK^e)69M|gy`>fR@RRWh?P6-O@XjZQYqw`5EpjDZwYlUn%fd&NA%$`LP#l%ha&01G
zD2+28)-Dc38=%-=+tH$-aN64U&(Hpu_Ck}oDS9>Uabs{sQra54I|Ym0yn_=#kb@+w
zTLqy0Y0}`-wmX^`DVNqj$jca7C@wmV+D3uF>KQeMJoCve31|EaNh>M9iAuw+ZU-A-
zMsi@$m#Cr9+rCs`9mwVx+u)vUUzLe)YXB*dTvUQLH47X$pqviW-u%LMZjZ>&iUM#o
z;82s=DCoZM+*4A@8r<Xo2jf;#r*HRP!w68S&kKkkL<I&>?T~Pn^{6ZWaO+M-yYf%Q
zw8jQl%_9?y^OhkI1H7o^Bi8n2Du#Jt#~LB-3*z*QLRA|(zrSdShNmma1DEET$T+qd
z1n)ly@P}EzVQdEk?qAaB%wAqEQqT>9Mot~hEds#n4f+Wr2u-M1k*pfIIj4UDD!^@v
zaeC1Ylc2GGjI6i0lOx!ZCfMza51CKUE7N*cWdW2M-yVc0`MuPh#6$y~j(k8q3yfmm
zmz+}mz0r>`@GC^Vva7j6%^vI+U|;+e9#yND2X2PC^>j0RXo4y+zjHi;pY_gvj35y2
zJW=w)CHwuX-@?|&n~b66T6F&FZ4N|EIzuH7E<x_}k(Gh!Hl+a!_exg1`LjR9w>SNt
z_3m>wU}{fi4E>nN{`Ds*JarUe#y*6$&-wM!j+@jr9MgvYS4S1?k4kdUEXq?lhtdBT
zeB8izU#TX6DzTimmC%Pc`jfwBs{L{Z#RzQD_}fU`iR#!Q7}Qy}XXnt@?_XR!e6{fL
z%@^L=3(YS?yRo8!sh<)m;#36o;!2X+_-v=2vA8T(Bii>L;)Mae-aRtgz4Nu9nscVi
z7=Qedo41K&+m`x2oszX4E9|5b9L`2mEvRHp&UyFC#cjNN-7Pu(hXN$`pVLBlr@My2
zT`GT6(9AjP?>)ihh2I?*L&(-cmdzoBDmx$%(Ib-4>>N&a(e8KscXP3r3EDBNywSZk
zOkADsK5W#j$I3wLp&e1o*^66vv8k*@rY>q!p{SEraiwZ;K1TvKpG#;d(w>LtdTHIv
zw~~JNI?<?QYuZ<vP1Pa)hBYJcOl$15ENLP3sVSYE0lw7syzPCUjVP&_bv;B=Q64rq
ze)+;4&99vFaTVWcEQ^w~G_`)qb!-79bQxBEdxlu2no?7i0vFP$Hg2f;K&+21&!uYx
z(GkSK4*BlitR*aEIei&Vgag>S%ZMUvro?qAU7o?<v>DsnTQA27F)YvDc%Mcc$*hkV
zV4g^N?J4N-oYUa=TBU=~;NpX(`yfd^#xodw&tF@ijd5P9q_Fd^l_seBx@qlQ@=w4k
zw=U1thmH5}FrA}3h{g`3><tZRmN+A8ht&tC-4+Bv%L19DqokJwC7?IkKl)%H(~UZU
zVCglQSyo3~CkX*%sr!L!4TXPMhiV~guSahxRF}5=HN|Rb#U}Vn)|s`M8zYcJM9!F|
z{bObB*2)zcrlG!dwK*wna(0-bod!kaB7G|95z-d>CnxdA56Bq*JFHYs9HF_qiD0G4
z)!yc-aD^T%<bEyKPd&G9TCn-PpuRlL&S!i?v1)!cNBfIK4^Kh{7|p(U8`;dBYON3K
zTpS*)P9h5z!aAAW8-sLjO3T}c5_f~ef`UxeDMnH`O6mGrLj#YaEa%FDjElxIv$P|B
z8uqQvS5f0Ndm=g+gWqi;F?s}gt&e45EsnWkVTaxt1eKAUu3h|5u?{n#LQbF*R;^+d
zcs?IqflHs7i_|kJ^4F$MuCnShf7>IzEv_N6w4@)ORGBHocvMJXGuGPuM^d60UNlUc
zhg&-dWPw%wDaKP)9?Q2sP%w~7hG@|H0^f*p%VYTGDd&zoCH$u0esoM#2GrE5_IA@1
zB$jekB_p$?_e5Phr`TUM7%p(z+b$4%(hyt<n{8Nzg&JFmO>xU@>Gt+{^jcP{Dw3$2
z8(Vpw$2Bze&uT-M?lVV-er@ItYgnZTB%<K}KNyO!oQV5koqGB6`DSeN*=7uM>~wr5
zdnF|Y&2b`d4s#;Vu8jDWkgH-SZH3LH=St#w9%wBU?1Hz-(yYHKIZ?N}Nz4*us4)3p
ze>MRXXGVG6H5$5Is`%fjGF5X2G9yyXF+7V}Zn>cS?i2@xx5`ZxSnkC+=Q35!2FCp9
z{$l%p+_uZ2%vpF5N0>kQm01d%C5x8w@<%=rOxLj%zLeY)v?iOvw*7b(rL@}X`Wr(N
z+6|6L7QRr4iLpmVb|lg>d{~BUX!8J1Zxd)^`Fxh&VYQi}nV&s^){{h?t+J~=ms>WQ
zs$6l0{qEy@99ahc$m2#yIXNZ$TCAKJx9iraFh|uqH@jmS7Q1^HfnpDKx9)W4EEg$N
zDK0SZ&I*vIoo6dVyZTl5dhe0}fBiSPWGAWmpouYMAOsG2^}dOOO^pII0O(iL)c%zU
z2hn*~p{xM(1;Dno8%+5KbU?b|tAZaV#7Li{bpP*$16_V(Nlwz0(A_BT|GjG*NROK)
YfH@rOb*sbJ2IK}f+PT_NZ7%)sKae%rivR!s

diff --git a/Templates/BaseGame/game/tools/assetBrowser/art/datablockIcon.png b/Templates/BaseGame/game/tools/assetBrowser/art/datablockIcon.png
index 5a691045347bfe7965935c2a368b9a42ecfd81e4..e1fa5917a48bb943d9f5160460040688a337f87c 100644
GIT binary patch
delta 7317
zcmY*dbyQSew7xT>gfN6OLrIIEbhk7jNGc#9-JQcw(lvlcBi%5_&|L}$(hU;Q10o12
zF>ii<ytUr@>z;ehKKr}-+xvWbt^GlCSSf`aMm`j1VC?<kjUS7<r`uZxXImEU0C!s!
zTYrbQ0N}rj&NlI6lt_!-@Q9NDi~0d0eU74HS=*C)F<Nm}db}@n<q}0qGEx&_2Dip~
zlt<B+zo*-G@zArS4*pU{{ogk`nP$hGm3My+u0-4my1HRoN5{H*Ya>ygD+h&SXsWtl
zvM7m3Cf4qW$vs-hy&p63E<FMX1&=Ql<Quy={p<Hd^oS;LL%Z+~>)|hgzvdS7j5xh@
zX%1fRKk~ZktlJPYSfPI`kx}un$j033qSSsnBvF=T3*}r?Db4Dyd-2=ts#^qE)~c^|
z*F9{P@#T)J(#!ekW!vP0&%~k3xoIss%$6U1g{EHFhh3jn&vi_W!AftP+6Vj&?)<Mt
zQ9*VJ+eeE3(jMN5hX%=h4k~=?(A9P=+%%v30VY{s{fCF}Bv1AlllyXVY4Rk{5LHvJ
z-PPi`;jz(RzoyI6GgMtn$me$4a%ScbudeaFAoQn{5^<_Qe#!umOm4%eNAwp8nAd8f
zdxD1~(us@ji@itML<;gYnv$5uqB8ARU7cfMIJr4e%B5rG>+@UBP(0T}cwa?6>~`Vy
zAaU<fnXo%_FwRGXSiJft{9*;Z@>xy1zHpTE=k?W5@(+<zg|;_!&JEX_`K-~A(4h?1
zkCbBcRx({wqk*LIF<GX@T52}EFef#Nbm|ORO+s8`TH(aB^{7V*oP~lWK0#v2>f!Xj
z_*XlP))v*+NrzrR+xL;Xd^^!)93~RPzx6#!quV*Yuzh?{qJgMWuN^Rmr?0w9(-3&^
zDgDK3htdTDuZ*hZSyMCgBNXnTMlsaPrS|tkNnWZ{!O7~k>lpS#X`6lSVp!6yYC-zs
zxPIBhlOyM*`qt@>$?xlshmO^!4LqfJEzWDU3v0e|>C5U|P>H}eso$Sw<dBydM;4(N
zh53Fyr?a=CuKZAwZD*cS*6_Yq<B8A4<M2otr0OuY^Vo-a);;?VO}T#`91z9wzu=eP
zGamkIxz0Lz584)FI{_JjX~NcDRf@TtVX`IcDz68|Z$;cTY+dMNCUY9gNgq|nPK9_~
z83!?vtE0r48C*hT+AUuHDIdX*TwrVpef!h1_UMF6A0|=nf3V#uxzw9L>TuiT^Tzk+
z%y=a@1Z`1zV~PZC_kBHcTPLD9uhO;bYP{?PU3W~Ei#|)(j){NUT!INJ2-tOi|0Xs~
z+SCyR*&i$R6kP4E_YA|5&AXwqLRC<O_3BJ>bY{WAt@RX)Zk`xTY);Y(+bNa`GH{3(
z)Lg)cXFO`Se{QoWr|%E*@`eQ#AN$fgZ80jePAsC10$mo8*$D`|lQeR0$ykqB?;N`_
zxzE5CwdQRRR39{^1(Pb%+f1M@u7f;9a%AMEIar7#O|VX$==Dd2T!&JKH1tY;bGxTj
z+P-~EITVSEWy3@F6Y+{5HISd#RpH9hh7l#m3_o?kCA#r>icL+Yk}i59eqDmfK@TQn
zgEud2aI<FI8PDoH#+~2$vApj6XCh1Cg$gcP=Qp$uLT(^JU~bzS>rny-yuVYKUw388
zf;g{_3|izZylx#icRePR)e@2`#~V0al!VfJ&!){UvSJL}?Tj+M-#NcvHDmvPPL)Q0
z{w$;Sd$Uj|iOYz6Tbh={ue0`@ny`P?{M+$!nzHIEF?rL*e0yDXb*?#96E4YG7h;~C
zlzXqEvYIeY@L@wum&z8rs$5a?;Sg@>-nVp_#%fYr?S!@IUN+IPZxbFt`4ty#4Xny`
zcDjGxT|K+<6LY_LUCBIpq$WAH)UG8n+t~I=Y-*fy{wCW%sM!L4MHshg<?dp6)9s07
zGbPki(eq759jl=isU0UP#YG>RL;wYpsf+cf_C*T$a1x9=Io4y*!Qq`p2TJ({uJA--
zem;q2TT<II40PD9(EwtWDhW|Uwtv|(k?^+>M7(EBt+ecAZ=$oqNpCh^ORWX7+<NEi
zx_fnGnHZJDWLY%~-1y+Hs(bqpaW+u6zOzEIvh8Ij55~{Q{v@7eRg4P}M&DL?(;2L|
zx|(1ZU16aM9SXhlO@kI>YsvG?i2Uyh%f&u{qd#V<^OtQuY549ammYHH94nq%i<z`+
z^ehR9SUeMNe)y@ytZOu7zO-)X-m7EE8uk!bHUX|Jg8k)ee)W#oK0{<-u7GJmcF8Qi
zFz|1Gra74p&PxuAS~x^T<-ne$o+P(<3sQPKOo3g{aid09;%&4wl&sq~*qXaj={MhP
zNtd)bmZvG0zdlwLA+mp>J22Z&iGMK)c4l|T+2L+_L!l(bvB<6_Mz?ex37G`aB1-?*
z;9TEJDK$&c%Ih{4kqD^wYTR(W@Lf1Dlzn7=qxv8cYP9-Z6JIC=^ck1*v`wekP;IPm
zK^BIay%s!V4to_%l^Jx>y3n@V@%yvVN*BHBUU^;fj)g_z7bZCKrYQO<sK;#Yew^!d
zx=|9YQ(YH6H+XfLu&9KVafqJBSJ(EGqQpc#G&17Va@|ss@L}LP-v^~{17Z1JYw#zz
zRFos5BGPMEMYN>xNa8zr2O|8lzvq^FxA(y~N<no@II10IGk8S5w&|N?7}75+h0V1v
z#<8!)@4CROmv<=g8bY1V*+Yc@KAnZeT9?yWe*R{~vBb>%1_zwof4x%`ADUE|t{RZe
zf(iMw74i0Z+RoEEBwCsr`RM-gZK5_(>P%b(?nofkS5uEmEQ=}H74$m1d`pf6`~U{r
zF?7xcyngb6J1En|<yrcB&?#IEnR;0&FRa+(=q{{pimG-#^pchwqQ2{WyXKkm^~9hW
zb#8!E;Ta%vnkm?mDf{vbT0C#PzssM_Qu+!W>oa#*&8qD~==*#A@=3hkKO8r1F+<_u
zY~jSje?HIk$yjQp7zNj2cx1jopeC^Is$W|VS5=d86n!Xfa_LXQ)qR4qpYtDYuU=JX
z{*=k7wP*(&i-N!BF7%Re!9xZXaT!1q=?Zc1r|l+U$O<&gVwCf^YtB;Wm*{aZ-t)2@
zp97!1sLrX%Ym0ACIq2Hy#WUd{G9w2Eu8=wh^(8g!AVG6uy+iLguPR;!mok_R$DGiM
zV-H=FIEvfSjCJ;vgjZnMUwxt`IA7Cl=I0NjNmaKmjA3R*1SF?X2Kn!PI|;Dc;U5|-
zAes*Cf^NuiOl9aN-z}hLs=E#z=iTyFnCX<YchuUyBEhI^rMBG3+|I4|{o@Nix$!-j
zIPEs+{gKiEU`+cT^ZnCPL*c{xc8Ur*VjgS$fxz9s@?&8eZ*sQewOUD#cEXn09v33*
z5TcN{Zk(K!8mQNu?P$TToe6CO8dUUkZ%U~nipl7r;+~_Q=r>!rExNTwb5*63d%veY
zfLTxn^nqoI5sa>IW~;`%G>?S$_rLrO(7)YaT)U!)^I?1FB*1EwP@xLrXj;02Z-FKj
zgfVr^^)V{znt4M>`z!3Q>CEUenIF;&IO-&7x<SuXSua13v+uquuPc9l$c5hC`po0E
z!-S7Fu%O5mN^WtK+M3NqH&@nsXh6oa94eMsHntr2S6k>&bJ#N%ZVph!;CAB5v046S
z-Y>iwR-PIBHGO{~q+29l)VBx3%_teyi!6eQOO7pe;f;xlHD#vfw~|rUq4$Ykn5I4c
z6NH*FZHZafj{3?>K+Ms~{g>Nn|GIyK40tUG7`_+sC%rZlD<na>5vJ0ct1(mgq7~lE
zMepP<8)^Quf()CKr6mng5>HzP`P4p-(Lgoo@_u!@&|+bpBmTSyo4RtD2Z~L;umy%o
zq}E6>vtJ-7h((av1H~^8vCZC0RLmOfwdtky;C&nrA*+$0RtQ-0xws8Jguk7!<zI}R
z7R@&$f}~7psTL!a!&#qV4?Z^88l0n|@9s4=6NQqgC5`C5L0a}P13MIpqNwe+Dl|D#
zHjs0Z`^h4q5Znc}SvXEA^N~_=E4E+647^R9XUjsp8qQ_<gkb4?h?8$YhnTmIL+!&)
zL9CIQF_c58;A7qQMFb&AxN{1ng`0hNToocqJ4&3TBD!BfCS&fYvmU?x>%Ejnw|4;l
z{uy%loShl6=O!x#swRABI@k?WzBvUCQ^AFA*%dP+{c9LtIrh^Mfh#gw{<@h+k_6A0
zLh8*U7CF^lKWA4j)%bO9L=+Qv;NkElr?F2DzU(iv3*dfH?M@Nlqr9`)NLE{)=!Q4G
zd&$(61WmRa>HYe%=$@AHtUSJJN~J$7S<zEwV3Gc<7uD?JIe7o86%|sEh#1oI(2wZ9
z!}>%g-y6F=!3OZQL$p|ea;-$o=<adqNLwLXY6X~ghb@W*AD9`UqTw8+EUdl}!sxWG
zUi>m8-3Bq%AE^3&>-_7yOw^bJy?<1dxi!rzAfhv)i|WqGDBR6^w;LA6hPw2Yvwq{Z
z>di$ITLrdkmnrw!pO_<HAtu3hbV(0mZ6JE4{WpWK4#x77eqB3tl>0}8t(MpHJu3YM
z;oaiCGj)3LH|pU8pZ7ES9*+COI+96g$rR2Nc5cT{oh5{m9Mu+mu^sNL4b^a;>9+p#
zSl^jY!2aO`o=y747(d>yrgUvlLdzH4{A$OwAF?;`d>u?>K<sMTD6U;L6&mTLdo;YV
z;nGgBxn!`FD{uw5^j6O}ujx5wHE31HbgJ~P^n*zM(wMC{{F`-?#^mz3D9%B7aM0L|
zv*Nic^?rsSJXhYCJ8OSarAA9XuJHAJDiH)ubSzsQxY=m-fpqT7r91mY`l#?Afq_Dc
z@+V$ZX*Q?lBC|?qorG;!x!S5HIE?3X$-*XnNCQ~qWS4c{SSf`h+W*Ce8sg>Q8Ri#j
z4_Q9INt*Xr8O`vc&^eY>q=MCNA0%cC?F2bS?Jn7SZMC_JjF6AamEo=81oz#OsF+B_
zQ7vazqKKW16I6)wT+DgxiKCq!CQZgnG7pY?lzKg0K=eoH>)C;tyGbYqnR64>h+g);
zXk!$tzKi}mEb^T{iC1bgMV6>L99hXp47UCLRpR>+J_l<){>5yngQQg~(;$zP^CdIo
z-UpDiGKCoG74J9t0o;3zVUTbcjVG@Qdd;rONt<XaZLC^TV`=3+(TiRj^Kf@8MbSep
z*k8L075ol;M0h;@aSH0*Q;hD5zzvq#j~(2EH5e+ZD2zsa_yuBmG38u;kae??a*TJH
z9Rm>+9G6()seQJWI4Cd4p3(!F7?Qn=`$S0ilKr`zF3$d|nFkjswPvvb!oqmo;eksA
z_#M`sePTq#{XwAU^7fX$5!R0tZHvZ7^KNzo+1$Z=WY^qQ3{lRL;YCBAGEU^?BUk+C
zVSSR1H;gQCJ&9AwO>r})CoibtVnXSaAd3)&^n+nl&GHaNpLjNYo`6f2UvYtAd~Ng`
z1kzcl^!)neAss14RYitR<IltBKhyh?-Gdrk3v--Amo9RHt)t4szX%_gUz=XpT-!Yy
z?veZW$_IIc3kHKoEshh4wiJcJ%{e3CFzcWcLiGKgKFjCuG?}uwPKXW4!8pm3cuf<c
z5I%HwFSXd{-s2&)!D9!Ut47;h)h1&9Hcrt(1xh?N;DB3+h|)T#JyKd|K9Y&nTe(ZK
z-QxgpL5l0cE<o%%y<>z!&hY6qiG1A@Tr-SG(c|eM8nPZUQ?#0{&P_Zp1y3J_nSf0c
z-O7~girC*i9a#E8XLfA+kS~#KKJm>bC$(&|weGw1wrv9*iR%X=9Fa0%4p5a(VKU@m
z1$bU+@s}vJb|nKo|L6L7x{F!3O8oL5J4?*n4|v>9w}vB(=mw?$Za!j3#=C|AM;JKe
zIlW$E0RT{xgObv7btR?$CLV~V_aTgCPA_@y`;vQnexAo410B+<GR7q?t^HON@uk!P
zVR@exCML$ELc?<gQ!i3UAQ-vz_dE5ty8ly@S4*g!6HpQPZ6M8Q<5jKrow{p38u~OQ
zZu}d?!4S!-kp&s);I8<e{8wJEq)-Vr!CrRqNg-{qSh1MmoU-A70`WnOk6OVx(seU<
zvCuXFiJRdz`=<AH(HB~d`Qpm_R8q!=mWI>Ruq}tJhMJ1>)31{JUh7*m297m8x_AAS
z=C9Sg@^%Tgj1|G^gelLJ=%}+|zE!1Jv8Y@N(O??Tx@nqhMsx{`#1)Eg`|Cc;cfS_Z
zH;&WlM8g0k-Zmrw41Zl{(o%D3J?5AXblZK`aJjA~wY)@J1ey^;K{zYDLq2AR%djy$
zCd++wN}s9BVBxMP@Xt`yjdUD*H+Z*5dCR=44m6C!r#Tphkr8aIGHUJ@;HPWnhRJvM
zeTDO-#B&tH{BHyR0DLRWXUf>;H=x}jbao9fLdHz=;~qW%IX>>^&Naj-8JFe#adl+{
z1MJ9YZN-;ij;VJOqlUB{`vuC)z+rVQ{Dy~Cg8ZW0$zHHLQ$sVk7^zPWYAZTFJX7G(
zeA*Reqo5YUmRR!W;Cg;59Iw$1mA=%o^pxJ#BIMi$0`zKB(t;6v^kRq_$RUUvp#Tv?
zJf~1W^wKLLdTB*rV|8x{jeX}dL=K&PFRm@ecI}!wyE>~<sZgmX*BZwEGnH{{F2L|o
zsl4emRLiu5K!j*XKKf0?$M>lyEAIp_qg|!)W#!^%&@}i&ARxY?+b~&E>e|B{%_7?t
z`t;KGl8wzOi_F?OggyH!x}v`R*#nauuw|(Ml0T07<H9LyWa+PichDMlT#PhycxGPj
z#{KG@JrrdT1tJ8D$#af!&Zh2~TRncLG6s8-6F}Euy4Je5<Jf*lCkKYGqgt}{DqHDM
zquAG`^QL`osrtK+>PG6@cyp5TH_{HbRCa4kv?K)h#2}z@49PEmJ{iHzqUZ`XZukX4
z+<CIU!rsm<96=y@J1Vn|A_zIXN`sG$OEJyO%@&5?zbfV&8@o}=*Fo23lO3429?Ufq
z3}8K(RoAL`71J$T)(>+*HxedYLmwo59iF7@u?<}>G_6%_HcjLo`^X(<Y+;d%-t|3p
zJslphB)@`gBtNSi`Hv=^mG#x62tKi`VOVp-BE}Lkw}bJt1<bFGu2eE@^{VGT8rBZ2
zpP0Yu@_u;d`7^)(sqsmtK&5;`$dX^$ser$ftVJ$HSMHAE&ij@n+e{m$e{tT?sS&do
z8hmy@bJik<5y6JaK!ppGR4v&L|G4Gz2*7v>i!!9rv?;vdpK}!PZSmXwH+OUfJDX!@
z>}Ym+ZcHQqYDgD7%4uwAVhEB7(yL#1bo~^CjRVUE|Jc^W&4t)|gghW`^&isQVq9V(
zX++;3Z-$1m2+GRNiA!|8tK2y4s+rZ&glw_7s=IXOX_@Jxs*EZ)_R#37t8!-*J!Ocj
zY8(*uiEK7$CY?DWYEO*=t4df(0YU(f$F9`RBzXM4)=IUI_NQInt(=m84FM7mqLGgC
zJ~;sN+5|JObPkIRfeaB-<dhJ3$zT$4PVb`$mxu<-;91HV1O&oCENI(J3~=tW{R*Q-
z=t1ZqTKy4WmWnMWtD=O&!vi_JM2IPR7Gg`3G!ZT5P9yUFTIsm1wYiY*4*q|u-N9{p
z5FgezJtXEQ3(KE8Ge1{`$cKBZT9$Z-KDq}8atMSt{p)*BpHr|N3HBSDf)Y|PFao^!
zU({zZegC0y5p(A}#tFao*NP7N7YY=#urR+d641In3t-%c<CCe9De-DM1P>gR@q#LV
z<a|~BdDWZzXL|k?tN_az&Tqlw`1nwg^P;{&s({oHOLxdX5tcN0<iChe@AkZXZ%Lu?
zcY0J&*aTyl&fl9l@cy{w@(lJ(jGGWpds)8`k7$|^myt>g?Ky3KWR1NJ%dk9O#^$80
z{Xg8xc_;-1K)z~u&6iP5E@}SU&^zcgPQS9wgwED_M9|sx0CfA$&SF>tRWOsF=0T0u
z1Kp&2WozrFD0;K0MQ7!ZE>}xhbv>$j!$iq7o&TJkY<B%Q`{~*#E+-_9#h;5mN3>%0
zLw8h|v0@X)y*1EvYY!7eeKf75XIZBM&^l5RD|;R{$Koe4ozQo3Ov5vK&!!kINXWs!
zi@B5L?H=6~k7bE?=}BurM%A8;WT*G_Llc)tpsiZ$<=1JUtlg^>4-Td!W0py{#&kfF
zlb|YB{XaNx0S=xq<i_e5=J?n|`sUz`LG@fK?JH$09cyUVT7@Aj^r)v(<eMF?;Z4Z-
zSdd-To`+Ctj7|$vtzE7E&p!&%{x^cmE%}2cSF7^aJiK)K*Sc}0&WAssARTfke0Tm`
zuCcKjk`Z@p5uh)<E5x{4FRS|R<~SfXw?MVybOMG8@aOv0Goj6;n46gyNWv_{Nv$d;
z_W^RCh89N`gM)z4D}a0dSD0~OfAX?f!+u=ewrq6$?pbU13i^Q>I3hH}RzDFi!MXmv
z={^7oiy_AahzB168l>S*3?Bdu;NI})-jDV8oqRSmzJMXn>j;DaVOJ6ed`sC^;O~j5
zCR@xto)*!XVC?31qf|>P0xZ5eVFHo}YbcKkU@I_#5MUv7g@H>h2(vCfgf10KLG6Mz
zF6@R$3up5s8Y(O#5&hyxzs$4uXv?}o2!YJS)&fHR0`-3j7`G~drrFEA5ZS5J>DIC*
zN!!lPG~U?#q5)D?d3#Ib>{7XEOwf}Yd@Pj(Uo)9L+PW!eoN6O5haO~rdi{fvKTVkq
zuu-BklVoc;SdZUy0b<nY`S7XWUt&P*EnDuef=522!TGxBaNGFOSL?i4_%AzPd=Sxj
zYjSg|Y0FsN%yb^ZfWSC<kpaX9+5~laMi0y}P1`p$NU~hp6WtFhg30Kt5!r<H+hU#R
z?e6@3N<M)92kz^6y0Mi|-?(H>^Yq)l#T$tJR-Hf?!F3I@fylv;#Mm`a?kzh&4(02X
zE55r)AMr_d$??7(Go{YH6wkha09lLZNv)PQ<_p6ccF-~({BAYqQ<1;tX+eM>&vL=l
zazT3CqvWUEJjVl_sJ@+KY9K6avPOSH6(NVsCWYYG*kev?bxaH&CpXe<`eg=KU|Sv|
ztW`TjQ*LweR{(&x$)7#3#i}D`sPVp_wMXkcazyEE-v$pZptVtxAHCa4{L@ze#KLx*
z+_Xu(?Dihq0G3Z9SWwT;>xr>$w7-7p@HuO+T<*?_0@ORLO`cD&f4k+wW7nYqfB`#O
z!OflQ{-DtG`qt=$Hi9r4PM8>G^Ax5TfVk?&_xT<Q)Bu7_UncrgXG<DnutC(I`fjm0
zt#yZ;17yuRz1rmvt+m_DQG)<Avx8^93eq`Kkf_Q87j<kdvpOGyr2R)0QL0ID@k?NR
zSO(x9|FAjc5;!xN^IM@N;i$Y4t;@Ue3w8Caqs|U9735-AZGcGHh6x+#t&)WSER{{k
z0fXu$1RV=4*5+d)w#=O)YncX|$qpl<6&7qeHQ6fPDFA(`=Sfd_{?zn@<c^%GZyv$Q
zWs(H&SOB#<`MlBJS5M@UGPZUaVm#7D#nZc(DwWd-$pOKcraL5A43Ca;<%up)qv)id
z=BAH2`j!`r3nT=q0eSQ1$K?TUMGqC~#&0#=z(!Z=0(4&SXs>VI)dVDNa`))t)<hpy
zyLAhY;8f<!@3rhTlkyx-imzn;vW>6}N)E&JF^xTn|MVW)8K@A$<h2MLdT|6Py)<^s
cPm{2T8S^o<i=Hy>#aaUDDmuz_ik9L30~Cb@Q~&?~

delta 5506
zcmV-|6@BW)Lzy;^BYzF|dQ@0+Qek%>aB^>EX>4U6ba`-PAZ2)IW&i+q+U=QZk{mY<
zg#Ystdj!5g9tR}B2;X3jzaOf5W=FE@u<ZS_5t`Oi^;B2$0VFaLrC|U5?S_BxQ%kI&
zHW_{P9{H)W&aAu{@%5w6F~#~EKYsH2>NnTJ=LeZfg>!j*Fn{{{YsPi%Ncnwzzs^ay
z-o6Yp?ft>}_5*znl*fC5j}^TqD(N*rJnw<@Jy6N-nd|HC^`5!UAz!!f{$9NA&z~?1
z-x`NnB=^>nRE{-Akv@4pa;!q!jxV&xD+C`CegAj(xHYq;Y$cWW9P?|H<@Kxl3dd9k
z701f^TpGvr+<(bx11Vz(yr1vb=J=;Sf3*7Wb@}hKf1mF3qjZ11duKa*WTEHx2j#mg
z_0RJUuc!7g(06Hla`$ECK0asu_Ii%@>z2bu`uz9aGw!w5?zDEc+~1q}*vj*c`<6%R
z`Bvv8u?Ijnc;m0hYfu)Ol%BZb;<eLEnN;3X(@C0cvVZ5i(`Jb^TNcha?~u!LagdCe
zcX=h3SGrlsET;?-y@5pGYW`eHdZwMvbUTfBLOh9Eb7C;i^Y>rjuiki{nn)>*&sedp
z?5JZEF_C^haT^&)_Z`&s1o-3i{g3Ar2I4Lc^I(G-S9lGvTKX@z%9H5Ajg9lGmXe(J
z0ECFC8-I(TU}}mzm6kdylAI+a0y#*Kvh-YPUSuG(mJf@}wUkbBsA1;jJCdGTbIY&G
zkYTBTvg;J&AVW&BYHi?0>HtI9N~^84-lUB-oA%PZ!g`nPtg2F^N|P=kBghmTWz^9|
zA2P<6LuZ}^)@_q|oMX<Z%B0H3%D0spR99YQ)qmAiU$VxUVd(}wyY9C8mOb{|dh#iU
zIzIi#8D}1~WI)NPHR~oeY?@x6cFV1|-F_w9ap%>~ti99vyVp--ExogrpG^6U@|iWR
zihK-_oKBkOjEv=)NVt$SG6t|cXK|!jvuDn87H6g^T4s^WlXH@1j0{#wx!v@cyLaY7
z)_?y^-hzxLZ~32QE_mwxV&;CIw;yHgxIFJCW3MvwpvFS=ty^0{*;U0Var8f2hQ2+A
zKl<Qj&%XxxHPHXvKy{_2XIG<O)5r}cRXD*kTddXF(e{l!&iiy2M3rLA-5prEv*m>}
zw5pxD&C>Ha&(M1#@5(>7sbA0G^=8#ed4F0;_q1{$2RrxncB$7ht#|*lBr&^+3z%Au
zwl$$EMYFWsnL|DY8ORI9c{T$r#-AT}@1S+6tfcIM!RJ}i@_}KNuGoIG8=vF58L(X~
z_~~<+KVSWi7w>c6@59HNZ_njKvE-B7J+j%lww7Gm@NHiErc+mkaL;awo&ny*9)Gt!
zZn2KYSe(g7*xlv&ATzde<Q{oqa#)9?sa)AZq~QSd&RL#4;g8x@O=&iWeqUXB#@0L9
zUVT&$q5GV>#FVcJa-&@a<g0zHg}@B6?P4dPW@XmCxMf`C(zUJEag4F8%v2e>AZ?M1
zq{G+C9inzj+O4R*?ZXbo4Pt#2RDWyaJ<FEFFZX3+258DeqKKD{p35+qIG{UDYefLB
zL>t38Nd@8|$!J=}UYTuFAnj0L7Z)X+{UV(-32`D_jm&y&biccoo3*#?wbOKshOSXI
zDC4c}!N3N=l%$i1^XZ%7>iAW@3<|*Dbfs-rWvt|GecHSNXvPY%%gS-h5q~ktF63J(
zU1Kb33g#F|?WXJloUNLBnrMIL0%p57&N_SO7`w2y(doof;<;T<*HzA<wPn96MH5`K
zXfi9uRx7(5O>MD`%qYx5PO0;;PhdNFTkHjl&243!`cy!Qd!~X=4@%~cI{;~yh+$Ij
z@tG*?p7b#20%jc?jYP~2=6{|@@o~4>JyLa39xQUwG7RD4I1MDtHK{{@x?rMuk~9!M
zr-e=zO|!0wAp+Vl9aFFL+9|anypwi-4J+Cci$Su?$0e_Lqe;IzCCMs5^-!Y;tFTt@
zS=SwL(--Yav2;6*t8#Y7GH%FlrU4G<H{4D8H^Fr!lDH9&om-jb9DkpXw99rPqMIQw
zja0FZ1oCgQEs^7thm9(h#?D?>X-V%0SE_+qH@QHkf^T3jtnPRh3!zI=3=qLpGW&x3
zjRfZGt#h4B)FZJwLFl2eb`1a#R5E31ZP9g6xAl;D;)JuK=^~wlJfQ*J5X`}vmO_Qt
z)X`Spl4bQj3k6Oww|{wC9+sfUHt4`-!xz#|lXwarGk2SdLro49OdK^cN~2w;<-hQu
z*5QuLF_RvSyx8ZHU>6K08>Wb|t={<9Am%Z4KGk|l=akm(3=>|sUn3{bt3a&;bdxhb
zFUg+6F)a##PhfM>5-n#su7Z`S^dekOU})Tq4Sg~~IkQjJ%YROmnP{2pHB*|<9)Cq!
zsq(qgDcrZ<2^bQYRQArRI}6Zd*&4_t+&Fe?nC%7MK*T)~3jl5SSN3N2O!(nY=L`7K
z91D2dYux6~BravkozR@Jca~@Hm>pDlf(vA(Eln71yIyUSy3hnP1T8dV8iDCv=PU1B
zP8*ahDf3{(<A44fqO&Ss){8PrgD$8Um4l2^JEP_UAgz%J8FcAmbfLbH$q`{IBI*p6
zFyDiU0+>Mc;k(V|p0C9LjvE9IjZmoF=vAmSqUthse5{Jc_kGZ$u58GR|GUI)?zPX#
z6^~!afD?7OG}J(kM7L`MVz%GakX(n0?MK&Gw%4BbLVpdu&!{3n2A-z$R{?QiF6t+u
zp?T8wtg`dV<48KO_2T72UEB?*X)(NfsuDb^-zG!_ZPy(x%!Ymee`Hn*RBdda<a$uw
z1-qY{OwcAoY$*%K4tg&_$O!kue*FQ|4E=hx`vOHwrcc=pwAA3e25snq=ztdX;sBIO
zjb|WbHGk);6p_(E?qf8^6kpFYOpaX;c-n-UaV^sbD{}N058Ald|HvIaISM~-7l3yp
zN=WvhTN~7u<+Z{@<B!#|{T@msVh~Q6()5Co>O>CMCrICQO)_tIQ(K1}2&kOiXLiLz
z^g==!jqlKnMWeYxsOWsj2u&r+mW_2&FwG2T#D6{%<W6uPq`iTu6bDMe`XORt%I-6J
zAukap_>z~<7bnL!*?`I@9ik2S;#oRIm=-<G0e?NBSAtQrY$y7&NKEjAo+)4PBgn%<
zv}h-#jh-A|2$h?22Ox14FwVM7cI`Rb2*j&DV1u-&7jt&Lq`z--jDZ;FjkH!lJlUxx
zuz$@akm!mOUFz#n|DhRViScdFA#t3Len%Q8+)Hb}eXT&M=?0JNXJ?@$&lUZSFf<GE
zhp;%70H@>y^buH!<0kL?A+bYgB|7>F3t+NX_Ki@?OLNdY%rC`Zj7|~>ss#$rseIsj
zZBoaVsmUwO4Eu5~=y07rR5HBKJs$ZwMSrfx^U8CaL(zVvwjm?(fbrEKR8@oH7{MZg
z%cEDM1zAI>q8b20RnXOaGg5wx@@<puXk?*?#V>(kP)|IDa1|-^;6a@X=Q=>yQ8!8z
zrbw;Q^sG`3u1K#00S#@NkqMVUw9*t98XN_(@JZONgQIP0qbvZj-b|~Ik3SMk*ndeJ
z43N>_X<EAx59b7Uv$21n_QtHlOv=KH09sfF3C1f!XBVqP=ul^P8={BPPrzB`1?Dk=
zm@OjQCVc`WdOe$+aoEM6Mk8GVdw}TJ4V6aU0|uV`(&qRB&C536#d{I0SEqvplT!@N
zB4PXDW2$cnL+0GZXew0CQ5q+-(0?BL7G`vDOrGtA#<NTAJ#3ij#Y6k!CagsP{A2h-
z<1`~$Z5Yu4d~w=P1WB;~yiuXSmma}ln-B<n5K>({cgY_PV(^)-qi)EpQgm}i1@sUg
zh`|n=6N<~{Lb&3^NghfkBbR{xjzU59ivw9C3sZ-a<Vbf*2U7gek{Z^Q#($CZNg%G+
zR$RofOf{6+jeZQ_KnC3hLH`%~GLJf&cT9u%<3Je5TxT10|B|#Ds#o>5#)gi?|6^o=
z93q^Fs-gQjiy8GE*|t;J%lJSF`p|Qrl%44h+H(*52*qF;a4+t5F#BvUIhRA!EDc(e
zO;3r%oGfNi!^zu%+yfl}PJbQ^H8^j>jOd0yH82JtrLo$cJvt{AC1@5Y1lM?NEYC=`
ztFwE>jHZ#6KeZ%EhVk@}QIhykp(T_|4ispt*65b$MbZ&?hgAb1rAW0p>mkbFdE7@s
zhHvaEdlK-b6&|J!bDHmfyFyTONAN6&#%dx914EC+QB3ah*c*T3J%3<vD^8n-JEz0N
zKa+nNG+mS{Wr6_G^#CV$nO<vdND;q93p`;@<c~rLu&TGLY<sKw5~hv*5EEkBbYGgt
zBvCH3RdwNn7&J%Lg@o2wXjm*B`ji;}+{QL^zBg$Vi*r9JIo(-d{-|&IrGwo-vR1;;
zMO<aEll={-V{eD<kADvGY+5j^S)?P!e&D)sgj5^tR-O?v;Ln4P6OTOZnNeoK&>gDU
zRhZyqz!+ex(ff{GKHj(?mUrXUh_pY>^(V=GI0!a?-nW}~eU)lVneqJ$UD^&VUO<`_
zuVYENCj>Y`VIFQ4<843qf@BjG76w=tI8mC60eR4sVMIyE34eoblAaQEgUL|H++T=A
zurUC1iEc?EiSb&aXfhl{T@z}WJA#Q;(FxP{<FN<>OmI;X+AVM12KUj9cni87|5~m$
z+qcdGpj!6IoXsCufEgH;D5P-llX@9Om9CW*b1$k2U^RcPz)s=D<H%bTenecoW;2}f
zJlBEHcYYr6gjpXv^Z8rnUjzLb=+{91cp!xM%<v!3<(sk@KZIcb00D(*LqkwWLqi~N
za&Km7Y-Iodc$|HaJxIeq9K~N#rJ@yw78G&FP@P&36>*d*7QsSkE41oha_NVYE)f`i
zCr2km7b)?7NufoI2gm(*ckglc4iFj@rkY*jfT~$WIuRFh`4utniU9f$!XTm&GxcO<
zAq&s(bq^n3?_xa5``n+SUn!Uj@QK8;OgAjzb>itwOXs{#9A;%nAwDOL8gxP8N3P2*
zzi}=(Ebz>*kxkDLhl#~f2g@DI%7#jRJVhK)RE_e5oXZO5EzWAC##;B}FANs6<qX$p
zjv#?WB$0v$88vL60t+!(HBwBZX+Q4aA9nmHa>?Y{03*jds!$<0e(*o|-K|-ioN$wZ
zaiIIfwm(LJz%J0N+xGXdZ8uK<|1)r<wf)rwF!M=zy{$!#fPrn`;<~NLd%)#?4lwkj
zONQh~ewsqD2)v)sH|2rQEzrB__SV|R=>w3Zu9j|qgF|4fMA>T|@9ydB?cX!4{(b<B
z>~ga91R;<B000JJOGiWi000000Qp0^e*gdg32;bRa{vGf6951U69E94oEQKA00(qQ
zO+^Rf2MZG!HTUz_Hvj+t8FWRH!xAAp3hhZmK~#9!?cH5Y+dve6QK-5fR>7uW6R@K6
zsZv2D@r>_`=iWI->RUye>%Y&A1J6$%Z?`7^U@O0jlMxj{lX@T_lYk%*lQSSMlOPoe
zlYSF)0x$xTVIby{Dik{b2$RthACq7h4w4~9lPVM_e~9qg2%v`B%j=>4_x$;8`LX_R
z2LJ#B006KB9|7EP^p;i+x4{4q0OCRr03ZN%4+1d&z-XQUSTqJke*6Fc0wBp<0RV{P
zBY-3k;A4UIFfua$cL3ZC0003X0sz>Xj{t(S+-^Q|BEP-7y0r~}I{;Z@;qO0p0ss&I
z8^-_ue+Yn0L%>}C00e*t5CH%P01*HH0zd?~3jn|gz6Q8(1gvy&_uKdOn9-5<P<<U|
zUys%y0${TfPxKDm8y^vW)i5f2?){vId0jc9E7x_!zg*d~E?1dD=4BuKUWJYT;DVFy
zzdx(mPFQJ1XWvWqUrZGpn=@yTdD)%(1po&&f8bdk1B`r~Dj`s5M!SdJsC7AG7MYjb
z$$u>#0(4bcA~LEh`;6BaeFCvAbI*9S_2}d;04TDvXN&+ds<Z4fmoNIYGB3N6zW|^^
z##@O3$;>QQ>}zITb_4(phUpG0W@LNceO+dno2&nJ9s(p}2kZGNS;ZYT^NfCat=_Mh
zf3329drxAk%%kV^BA4CCUjVT2)zFchEAkr)k6v%aFKStRMl*ut`~TVHuEe96%$!H`
zcG$D*vt!Q5e;ywJY<yym-nn+&5wp&yby+h0v8tA3X#LaNtIeZz*?rv)0YK=^wcFn@
z$U39m183C(?uzqhjhAc}7f${HfC6_3f2!@6W>jO@X9ecfL3d_-WPMJ<$zK5AAa6#C
zFL#E!JQ4F)<!^Ch+>V|6uj3&=CoRmVYep-d+&!?EgOk5I008Mvphtg}-|-;K1pokL
zuhxao`g{ZcbYGDjIfz&NrBAM|=bij*KLUUv<!?rCep||VQgrec063YM5!MY(fBqNp
z41k^G%YoCu(~Rsd<A0`YNX)qdfSt^YfCu}YI|1$h;KXJ|00ICfHZubIAp*dLZ-+7?
zus?E`X8`O-O?G+6$&3I2Knf!tlJNkJ84(+fwwJH7I65~E1jh0aK+&tvh@biV`M%}O
zW=4C&m^&~z!`XTh0Jx$xBLqy5fA?u$5&)dI3WZg-QQId+wuzSQ#9e?Go&f+5bJJq(
z-p}wnfI9$o#z9yAuGq|oaaWSnx1AN2+noRb;D7|S(=7w7;_*UU3jhbz3wIO|QhP=-
zmp#M5JYpWvGo3lN6}M&20|)>ol;8uztb<DC9ny^IEc=S_F=CmV0L?%Ee<a>;D{Z`X
z#2ho~U52Xb_sshmHIo@v!7D$v;G+NmQ2M0byVK6tF<O_cTFC4$qn_o@b^vcZiMG7Q
z*8e|x9;4T1hV@4qUjs~bRd>Z_gZEx@<(+QE*Mus}=+U;dYuK$YkCv~+joKbFU5Wc@
zpa3W<>N~g<uM~Qg{ik{Ee>S5L?_s5baL@Y8K95S#))PS@;20kPY;^KB3v4s_UOV%$
z+vf!UCpY})jo;3+?~G==uT^K4`9U@h;dvfF05}Pi+qqZXQO&4cIL%zX%;8=kfJJ}+
zaMgdoPCjG#XC0t2&*+NxBvSIvc;)rz?qw_w0dBrw_dX!C!h48ZVD_prdbAwX-q%&{
z|B4fI=HEUzYk%}Wpa5{fpKw4q^M20kq%$KR>x@RuFZ;nY>STK5XY?7DeI^lbXWc)2
zyxoj}|Lrsx4;(X>JL`;gdru=~u<{(NLj(W-@FNca0+YcLFOy&x3zI4oI+NQJc$0b{
zA(Mb06qE21bd%c@c$0b{A(Mb06qE21bd%c@LKhVC2ed?Hf6@x5#{d8T07*qoM6N<$
Ef|Fx_KL7v#

diff --git a/Templates/BaseGame/game/tools/assetBrowser/art/folderIcon.png b/Templates/BaseGame/game/tools/assetBrowser/art/folderIcon.png
index 2a528419e2839468f7ebc9a6cd1b125afc4d798a..bb425c1b245a6d0a2a5a3ee41165dafc1aa3a8b0 100644
GIT binary patch
literal 7824
zcmbVwXH*kRuxJtpB1j1!O%S9bMHH3Z0~kR-y7b<WE?|TNklv&yMVj>9q)Qc$-a7;d
zMWi<=A&}(p{do7>-*?aMnc3N$vpci1vpW;1rJ+he#!LnP04QKDpxOWc@CF3}NJ(yh
ziD$7L06+zJuWRV7ZRyMI?&)Ud=wi$6?eA{OZtLfGGw8Rtoc_iWB~9~j#Un}rL}m=^
z>tcQ^mbyM>VB=gP_$Kj8PCaIkX2B#%UMTHN&N6<iBmRm(P9lFzd)CN^KP!7$n>;gf
z=P(;CAZv=q4%|4tNLfGd7psnSSr5qF>od(<zx+e;Dt>)^Ze8PV8|_Z__*4=bNuG>E
z_4oTB9~h%nWrgDpD?{N$DF##i*P{VxM<*iKbGUX!&68W!?v|=?=7?@wzC#C%)Y3bg
zkcmSdcHOPD^255^1@EoE4LLcszV&FSw@R8*58bX$#f2{e2&QK5WjJn+X;N0H>YgNt
z1zxO3lx2NCT<{sn`!Z;)t*O&|-sFxR^;_1*@O7jGw8_S5o-J$UHl*&j2Obr`&<m=G
zg4>=p=1crZ4+^V8YAGyfh@|xM!svM_Q&RUhd5bxp2<YcNjx^bD_q!i$GUj?NeP7@I
zgr@RN@MEj%-M%)NqsDCWJDJvw!fU(Vs~8Qc%Pkq{C9a0_h@qq1MVBX4P4M*<yrBgr
zWH{xk0PS8Nibv&33M$GVBX2BDEvaKy*<0ognj<TdDF(`cj_wguZVk)fz|_!WkM=96
zTT%lDgu{FJl%jNl!<hFLP<fuF_dJ`Zh#nDh^wE4C*ODX_D99i?(}#UK@Eqp<Yf`(J
zZhXM~Mc0#GIeJxht{C>6Uaw-YZq86=q+Yk8zG2bW0m3*``MI#7VfOvsZ!$hEK9z?o
zjFvqKD)()-it}P+VcBVRS++an-$&YiMv;@cmkFBs)Xy}!Xgd~V`YyEWzWu@Gx!;qd
zA^T^mq$m^5Qm?9uh+SOj$4NMyL>M)JZ0EMsrp3##Hi~yNYI|cMLb;$OLLe^h>eS1J
z{NU(}-r+`S(-;YnL6@#KRuIl$N40*{Eb9xJW~%kgqXXY{`rpwR-^X#Z310Lq1_@U(
zZx5laXXJ0!@3NOEejrm+8H^`?xBu<kdO^oxOGn!=Vro36Wq@QGGuc~<DfBer{3Y?}
ze)Yk*%@F%CEQv^{utinYKQn!d9^n)v`aJh*pNUL`nTZ?OZoaq3_YbL=T!{^^a>yMd
zrf>_~Df?MF0OfHmaxO`qo6e=do)nOx$Xnym80IQff99ZR%k{xH%Z7%t+Vb9^Z__ZC
z@GIlTJ`R-umubyT^@3;Vd8<i0(;^jUknxqpZ@kQP&e;l^Hks8Z(b{UKM{>?K&s2Tk
z)!WxQ@vwXd2_k~e4epDsnM${WH89fO)!!+OMAR1My6{y64oZ_LAYopDFlaQ*z}%>2
z<D)Pe|B7HW8p>kZ3>hMBw{}2S)MZ_^(fa8~T<G3d%w+~g8l4oQ;-fnPZ=oEL)?T%7
z^N|l}UG=66wdjxLS{iEg7ZR@?LWWOdl75*zJKsDi?|ZrPgPLmFV_1OWR&#AKFn9`5
zJ^Q4(RU8rP-zYHJd-2|Ue~`sLM0{Mag>obn`O`17agg0Je6T6e@)7)3Vm;2bkTbXM
z+3RIt6cZ%P^faXkKbixt#l&^}jD4&jP2I%QswXWhCHAO3Gf`in1{(yJdY;LD&Ep=Z
zAjlQ0?JE{!(3rbHro8Cy$I(0Yt?PyRoy+!y!c3lFV%N`arlsgmJs%T73K)N`eT3e>
zGy2dv{B!?;tXJkkub&3>T68S|Mv5wlD5<c@I35y@V5maqT%=}{E##?3%bzX_0Ex&}
z8f}F}L!C7G+w*6<pJ(`(mV19NSMvL3f)D1_?SV(oFJZNc`Mw~eN~oMgd!~{G<PjWA
zo-RGYm<D;_Lrt;T&li=j7?r*>E}hJ|jW!3VT%MJ@#EwuZ!{w8%VHoZif0bPl*aWc6
z-emmPzNxA6PmuT*Bvp?;n!-=lE&8m8WI3rfo7vkf9Med$tm=iYRJcf^?Qj~G5sYK1
zazdW>-={8PndBKqxP-(-tOEMo$rpgWI~k#~b(-#}&+SRXc4o?f)5&l1^#@)m4Z8#!
zUKzhq49b{N41Lx@Ve2=?0RK_x!nqQnz`k-eOp<Y_T*(|_qVuwVGw&DJG{K6qYwU5)
zE3qmH%@I_;N$s|!_!<S>TK+w<M_!sQFalVqrEj~x1MjEtfp-FI7m{z0#)geJ)<@`e
z=JBg`=pj*Pv17;IgSr(PM4XCFi>-ZU(iRhiN!ZXBiZ1whEu=%%gOvv=@Xyd6wIBHI
zYH0ajf8YP9mrYJp=x}FdyLE8jOK3aDC?{*U4sPxf0<sLLa@BF3r2L8RIU+)fp?ui@
zghq;%In*g_$bn2PypKJ@7#2MJN#2sJ!;w-&!23W|KfIr{L@h+Sx#EuQ`bTs2{7UPR
zEr^5tj3-H@xs)b~GUN_bL^n5Ix$bp!Wr_HSb7K%FHmNhGqY0$)Ly;mj!A0F#UFHY(
zdjoN+H=jMMmR@!j=<g-#-1Ebz69*LgXWfm5e~}&w?#n?ZN>`nY5?2+c|45(PKZnWr
z-Tgom%5t|OhJLr5SEt^byVa>$-So-NNvB^fF8RAW%`(u8u19Yy4Xaf1cK9Zkuq^k2
zG`zwX7r{d8V2%d7WA<GNqB|vfZ|-)em8j&J1hT`&y(XjLWJV3QdtwviwH!j1@0sq3
zf6Ld1aCE(eGj?t;d=ag{KfD55#D$IjFq0X=^Kds)0SHT*D7MS>dz<Zws^(Arw(~$_
z#s0SEiJJ{ih(oypq#UXpUh0~Ref?)UQ81idU>u#DBt-5)8%!#hHv3CA3DXu}_~M{6
zzcs#sJmXH$q`+GdG0bC?w+Squmw6wlqa&dkR<SCj;Z8&@3E|^^?o-yJAbHdIk1Ue%
za+JbSy~w1x-<HfXM?b6gV%A71f{)NA*9v;1SxJNVn!G=kxFzTZd0INuyw2q`XlVfE
z-L`U1!~*s6Ei6NS4Md%ODe-p2+3YrCR33tUUHPrHQ!yT{hr$^|QZ22`X0tUd*c*w&
z=O7;jVNn&b^w+n7;UbX1-z81dJZAPR>J2RMQ07^xB_qhuLv5<yHr|g2TG!$Yq=8z9
z3S>zr(-axPxA5Ti%$G8*$#fRO=leSWEbZpb4EQqRiv{rU=!J&C{e$76i3C0D1NE@*
z=r~nx3CYYwUR@>kfw%?74o$No={NGWuK&arNqxj-pR#?GSe>o(7hbGxDo)*eQOBCA
zaz-;)7rMVLH7W8gaek1?Q}%G1LTRk;daeEIBesI*tGDf~DZ+&q!T8oK=zi~j1hKhr
z%{Vys$emJ;rCe&A*@XF5IS^ZOn%iRCy&DraZqwqYf3JT{5KL?#x#Ve=Q+_KSs%hL%
z6K?gA-s(A-_A|b&H~lj;**4#=LbC8D&+}j`s{(l$)jUSlq(X0BK6Bd*N$6n}7i@4N
z4cZZs@!8ldaZan2d%>}&s3iQeioJ*FGAfD*R+mFRsAP-Yb9}oqTh5VD&p^Q?`)Uue
zsGF~r!8D)?$=jIO@~^jWBt<a5EfodrEaudVpXNNxvRbZt-ZDw`h3ew(0%$mob)4#_
zuTv6Kz5!fKl};tFuZ%IzP%t4{ng0F6RY`m2au>593u}r_MFXYJm=l57i93E_8+E8U
z+iiRGN}P7EMXj3<GY^s0fOv=n0Q}-KM5E-BS&eNXD&K*7V*)4#KTlKAcM|;r`{L=(
z@4(5TbfI|q?usrM)i^$MF*QB-$oQ|y)C1|3q!%TxaiKek)b@@{?a}lnGtAI0PSrH?
zlJAMqI|~b={nlQ6Wz5N#Djtrb{H(8gFQE>5Vrl0YIR9R))}W-pFkYSNR&5Ay?WHY4
z`=`H;_uAn+6=bC0vj(>kv>5}9xqEt#x((T2wr%t}|NQsxlSwV`2O^n2dfQqi%Xr(2
z$8+nNX#KV88g-TmpF23KWj3#8H1z)=<|6i(9w{{V-a92u73-Ui<=8tdybM^ndbfiV
z?g=kbO$aSl*nL;6IwAVfYKw(fjzQeHl3E64^(V*z(2+R5mxpgh9RxO@5tYN{rePtz
zT`$T8z72_ftXHgQeBkxglP<V2AO6)MrGtKP=lt${)t-TwP$0?dw)hjZZ`ef=FPe?<
zlY*{)U|$8bt$$DxXNAy-v0$EAdfmKt?@4ET=>rh4Ctfi?sq}EtcOzwBSQvO*;f;}<
zD6)u`T~PRyan6ARcfnU4m5ofTDk37|*IwS!km-ALXNl~$ZHB$5IR7fx*>x5qlT1BX
zadM`L<b{qW8io4iTmzS~6r~8<D?h5hj-Q@^f8Y|HeY$*cgwA}r#h3g1pU&)^?Gf`b
zcA;q7SI_aH`mMp&pQsu%Ok;?hZj(kzjWN9DlwymFD-FIpkXF@yla&|Rh!cw<GPrJj
z<8zq2W?q5)A!ml<k(W($Ux<$#rD1%MWEy;6rVI;nc<4U!-ozn`1!}DwJDh$mb&D=G
zn$nXR`>)wZv}Uutcvd#l(q24fkol_SA1eUS=EIg@aT>!`pfoG|aTS>Gx^IhuY%-tI
zHJ-lmY5N&-GGw_;9Qa&NYBMh3T;yrk6YwmOys+!+{DF{3x_9&$Rtu0zzFm;vJ6_?^
z9}urtx$(-)jGx!bqhZD)mFTHzlvt>!<&ov1DuEwp_w71ASEur+`Votc4JKo~{Hwa4
zzq`E;7CKxD!jmt+#b7jzX)lP?2)ed!=1ASCLuweNs>O`o3s{>eSYY0$*Pa{TH~wf(
zJL{foZavx^S4R}D3BSig3Lly+_-M9@cRhK*B#GtuU51!j`o<w<_1ZZ?3@+pSIkJu2
zYJ-7MluAuu>fy9Fhj?k560_=BFE_iq^rKn%{`yMe`?J3nu_H8lzDw_|2bPJhE}Kv?
z)!FewZSUqafBi9&+M`+r8BEEOWt06m6XIU_A;iV@O8-b=lI3DXsg9sbv(2Z;m9!Z|
z2>(o7!aBw3B6LwE=T`Nt(u4gMn_Jx6<R*2dipk98tp!<n(d|D61?W#hZO_T(&}Da^
zLoz$>f7txgb&3`gp<W~m&b$RvpIaY4?Y#<{K50V<uAl5qjUNOpcej{b&NrD+4argM
z-Jg}=gTGr)66UlDU>bSBHbH8u_-tZCM=MF*!cFlWb87G2w1Yx2ypt#>hLZ6W!BX!E
z;oNUTmotcCs2-ov+gsH4xCx9y9hH={U`k5=KNh};fHMLTWL|X3v-Fx9JL^59d`Iok
zuazkn!Pfh_)R36Gpkll<WT3!&JpTdA!-LL*oH9^QpVcJ8$H)CHaTgV}m>91z1OG7s
z_DwnFRv*sK_t4{l^62?P^~Wtd0Oe<Ay3#y0US*2tyKP%xY@!iS!{apDy?0Fd=47Nl
zv_&5YUU(tm0wvr;IytGw9={Tc6pP6FTKLO9TfFCGuKEWJ>B=c^BwMqv#PzRchwmx&
zVW;X&S>jMZIw`{)3;oHvYmRHx<;BT|Ba(t%zt_rjoyvVQ@jorhOkrM`o1|-oiXa&2
zCoLtWyQvZ5rHNMT%2$sW2-W+ViE11MOff9v#fm`=S6u|OZ=;H((<F@S7l06L8xR8u
zGR=9@Sbk_d<dg+yw@1Hpy(*)yI8Qo#Z%obxBwFh1^)XI5M-H)CY{6)KCcb=l+7=2r
z3RGE1CL(bQYJXPLI4i5chP>lb|AB~w1!S!}Xy)tht7-2>$Z|ZpAR5T`90cCS_TA(t
zNUYRUp*Ii!=y$n3#@)c%?l0bW0RWWU|21HrTd~az@s>C2mGZ4Ww@Ge+*ef5y{@tWI
zkT9r%uHWMRvRZ_V0c+nep`-MNXoANyF%&XMNmEPBAWG)(U{tYh#3jQN`UKOd%*$@W
z$@=uuH!&g7?_``2Umc;Q6r}q<CzN|e1oz^|yU-ktVAI%QraCsgGvA3BZy$fR8JU3H
z4EX&OD!PHwvV%6CQNm4%BI>{0{+|nYeB8~!t}3ekFLWb~a_)*B;;#tBl4IcvzYv;G
z8%@1OQ+4t{@ulMq0gkHZ{z;5l$gzN}8tty=epM;<&Z|4U3;@xq`iKwTHkZ1O1)kwZ
zZm*e_VinSvtY*l^FFVBY{%OABdbKxWgFOO@!sSJkYHoK9lTb(vy|xPdzKtiMO;{=3
z@kzfI^%Ah|kB|$q-EQhP6a6mc@RrY&?C3JJkdyW5OIn+Jk`fGTp*M-@5*zDZwdalZ
zMu~nGcq)~w4d9vrp=-^apB;wZbaerqLZG~;Q5ok`xe8Ld@TW32B$YJ!Aca>D#!<{~
z7zD#RLS<@9CT$h>OS#BkD(xI3G?aG?-xuCG4A6lJYeEB^kE9Moznhorq&S52C#K;B
zhAD^ls=Ic_BCB@Iy3aBK1H!)qqly3vIx~8Z%Q1<-GXWPFEx-vM=&!^fA<3@6*=~@Y
z7|f32s9wVgaGdZ%B%XZFPF<LUJr)to46F&Q89(2FvmsdyS)5N~;iXs?%6mQ^YR9@s
zmfCl6bJJ9*B%kk~Wx_c;+52viNpJ&bU|H!sIsh4Rx21!f<HFA6;*F|B9I@#|bkbPg
zFJ*tuKE+PD&J|s>J;zC2y4#r4b;~gQUitbX%>Y?m^B=BuRSAF>fXXFwP=tvWBMt^!
zj>p!s6_wgOb4UbS^9Jp5oD_C%X_7_wicF)l0pOgk97v2LV(LmCRR}=0Dx(i+4(|s-
zMO-OeBgaG?Acm~wx97Qj&+QY5NGcSC(E;lCK>~KqJ@=sc#{_y<-`F?CCYK=y7~mQ$
z@1_9}FWoxjDKgMC3J1&oIgQc~5@fRRg-L;Px;fZ6p6HQM7OG&9G~_b;Sas<lK7lRX
z#AOH92^KYaXA6_0JN{*hmHRGG+M)*R{7I%TeL25Z8}UIMD*NOBqZ!p7l_ASiveQf%
z{gBvT1M@pk6K*!5IUI34RYQ<?gKFdA14OjHXyfEK+-QxnYj`vg9~B^-a<(bLt|dYS
zaF^`!P5Yt+K*q3$U++Bx1Nx(fa3ooU06@<Fs@s;lH?vdvCS?+aUV1$g$rWv{z<SY~
zCoied60L2V-T93Bb^Q7rFN5Z@W~!bQ=!S18Ry*SJW?|0R5Z)ScSsT%cXuTFTSb1gE
zB9;8lwEZeS!^|d0lwyLO_9;yQTj|aa7xIXeuuJap2?Z)&58_+hzErb2chtiPUIBi3
z<5!~l#pqG&pXX2vJ2Gx|RoZ}SU;G?&<DoGK@;(#v=}3jd$msERHyyxrES_qfJ^~fa
z55SvP)3R?qj^anIG<UqPYlN%l|E5jIzTx$=y<U0n6;u<4FU6{oA=wy|phD=3OoBW#
zaCMg=N*3a<1FPcB@Co;p#9LU&V}amKw`<>5O7u;Sz3F9$+UK-aGuuYLmEwayXfgZ+
zv-ih@3|U1<8*TQ_8@3`dhnoTI9jDDA?H52OJhncqZMB+pUJR+cEk)V0qS*|%?p?K4
zGPlNAg;2hwt&(+R$f7YdB@@@0Y19@52#;x!&vyNq`)cmaxC#Rp63;1(7`HPNPj@4C
zbqM!IwobVZbAkyNbGEzEE95yFAon~+!<>;^PN@gK^P4~-aRdS34n^Z0(6Ho8>y8MT
z8O*MJUA42-gZQ}TtPdgh@&kGh8<yz#(Sts%&o841FCp@`aOI`qF4}+y0$(0LeTnKW
zK}`_gbBu^gU}Nne<V97vhMF{4k#%NZRygt9N$uSzx&9i0Hf`toBuRzqzTgt2Cw?sd
zP+UG@&h72P{ZyJJnz%M4;1L5MGcdG)JpPza%!7B+0$evOp@}%~d1_Lot&aR)v{Uz)
z{YGDIjEM^3w)c*k2iRh#9br$yaLiV7TJfn5uciiQWTpeG$<db_%p;aHx~@!x9BzXx
z>I?r}2&e?AATWCdK2yQ3$mHiSR38rvd@>OoWf*fs5Idgp9MduL=jWywK;OAt<2wA&
z#PWGrKS=&sRkbuuc!m`VN1grL%mA1<YV$@A4B6*+)mOd&FkT6m_|z*Mh9W%uYd~QZ
zcFHD`2{$p@`S|W$PxW{+50Zg((;hk2uG@Hlhy|hTPqPDeG?%f95`SIgm)gDO|I`pr
zw4E*8*!1KpcREZw!KXo|+^D2!wW*R0fZ0*?kxCJ}vCK8OMx2TuuJ|F-ULOs?iv>5!
zI`<ib96v?~6o!sf08sAN{*;7o6)idlfeXBEz>Zr37#SXz%jpyTr7TWZCeC%$>m^_}
zj*TXqFh1Mw;ohtS+~UDsL=s5n5hTx!5h0-QSJwtA2*K3d(T+?;1CA8p>I2L_Ish>%
zjyq8Y;UxqRizGzkAL@<}sH`Q=v-N-uN7LE&^W;FigqA9|z7`G%F60?#j%hmv&jHEA
zezmqwy-P@OEF+zE%Wd6tn+2m;sBkQk?^gNos{V5;H&QP%t&}ZJ%oX8s3)+=V;}51+
zP-LAmOe^aLaz_fR+Fk4O20RNOk-rTqYCQ-)5l<!@_fH*!5(82ue#q1L*UIZPInY^3
zR}7}(^?RV-()!9<>~yxj9<zfLdcN|VwjqBNSYB_1jD>JTIYHsDWMEfcR!^rtcop|V
zRLTJ>TiP;t<c3!&WxMY3Kz!7_=&w@JYcu=+I_fX@M@v}c#E;cx4n}bs07j3;HP7*R
z746oq=hba{6TgC{dl0#DR*{6O()W?X)X(vAmVen6nI$y@8num@^U35#l;l$Q0Hi2Y
z6;bWIA^r*zZJnDZzcC}=Ae&6=LSFh9p{bY64aD$s=~3ZyRS<p~i(v-^4Z#CkH`AIk
z+RhQbx8&GaJEvrWCj4mxZ|AUPVM9KV#Fbd^_I_5+1x%yPzh)vxm&Fq0&ctSjJ6$^<
zN-M=uC3_;9OM!p10B^;G#g5sc;|Sm5aBf8{xf2Y?bj*tVX}D@-O0wI3_qIP=vWI}v
zT}M0wqr<FQdGUD^bJ2Yb+GY#IV?>O7gm4|X25I}#zg=t&Gd2ZS%i3-p*Du63w?X0<
z@#ySxY#RXO&4`O6I0#(nAd=ER)C9;xvc)Is>v$O;%7<ln``V%VEWun#qTGA<HhTOq
zp2&3_F~hFyyM6eNpA8@Ve!9HraHTc;z59wBW{ceCikQ-C>-ururg7ZRfDVHC3Eu5*
z?b>S%Aj^8kZ7PuRke$&~SZy5PH4ichBj<K7R)hG+LVDq~eO;pgd@F&MK4x>h!&(G3
zmZ<pPt%EGVbUgj*dt=?q1TXP(Hdjz_1mU0LjZPli>S{yj%Qo<L3d9YmT&v#e&BWe2
zqq7)n%|!GdFi$>3-9v8B6Rgz$m3b1pgdA7i>}O5tO9LL9ryQnVczTfn1a#j1+$-`~
zPZVj5I#A>OiN~}E-s=zBhmyrBL~$vDm&t<J$DxUQzM2cR_BF)keG@Tg3^)f?ccbIj
z7Jj?sz=Dw*(j6V-fc-TqgaCPSy<#w<#)T9a8n^k&b|c4h?1|3>Ze`Hly5|$1Y2ub*
zsT3mrWVA!#{#86bu!)}i#*aC9=?z#sx`>@n+r#k#9P%(a2<xx^ox)I^g_hCvp(OAI
zpX@w_OL4m-n<*Z?0?PNFH|YOV+4dy6ImPm0xuqKp*o|xNp&^tl&c5TnSD4a&<+;hW
zxFto89MOKR9>L#<5RkobrdF|pH`&;G-Tga8-c85178xbu@W$M(8NxK3iS7cAdR7U-
zc>dLSgwt&Rscli+-2-KOU=N~h_5G<sMI8m*`~MbHA4TCB>o6<IAouNSl`H7bsLa?#
zX2C&9Q-b1eqh0AD{0Tb#snqXW?W_ijaiuH#dk>Ys2AxIocv$M5y+H&g|JL-1FfCv=
zj8UrNg+dYjT|E_2#~<>2MB6}mnhqU&*jVDX`a$RG@98<guy-3>T5%VmcYSu;9zI@R
zk(63w7=^i3w(boqur|_rbZy1Y`IK#tP;&rdSXS)i`-I<#OqTpy{Sk2gv)`VaH^?1F
zy?t%VEVy;3Ui9gW4pJ<Q2&)O$oWHzv3a*>p_~dn*M}XCz?!Uj42N-<ra)hIJu9K7b
zm_i4TCr2;SbmlBcaMddSylBb;%qedGGduXAo8s5Cpp?*!*U=rv4<P<dt<v7tHwqL7
ze|QaT=ixBV+`%Xv|5$(YC9KIIegiY1_k$c`d>GZgbn}f%$pL)iBhH2-#7FhR*XJT-
im^uE>(aZlZj_x8FsF*@N-iC7iM}sMAKr0n3g8v`rcK@gV

literal 11562
zcmYj%2T&7T)b{R%&`Ur-qy`kFgMbJK5}Nc5(jj7@3rG<~NC1_hC?G|tk=~0mr6m?#
z5u}P#siK4?AVF%_FW)!w&-}Zyb9eUMnZ4(p=bm%!c}{|*xd9t9KQjOTY(|E9)&Ky~
zUO|A7p4PbBDZ2##(9C^XhY;&)chP}&0&aQx-9(4n3%rTG8SYK%44+)jbiE@e&H8B8
zvC9=oMaBHubWRt#vA>H^Qp&4;QStU~a$K|z;iePU62h--Yx{Eu{MwQ?Ok1`~u+V@>
z?S>rR8C-hhIgzjk>5$2DZEYN<ItZDo3_&@y%xedGq!0CDo^1_bY^p*AE#04AS9L$t
z)-n<{_>h^~-`4wp&G@J;XS=c9HC)}?eKuD6X^n!;X<_K__I~1-F`G@jMls(41ENf#
zN_^z#0M(r2zPvP5->dtqcgWvyOTYB`IjR$}die9x_>GkP>sQY1qVg%(4W(+In_9UF
zVqLamR+`f^KYU_VyNTnqVtel4*LG`U@ksz-w0>meL6^zd#|tl@P$^~awN5MD#ApVA
z`@jEt<8Sm->7t<pN;v&&_6r$TF4YUkCtmL7v8=zn*QHzcusc`b1yet1?_I0?$GfX9
z3f0C`&i!4k;rYAJL`?oqti|aogvv6onLbEuQ-__rHa_6JO@2Q_^192Pv|Fxkxe?4;
z%We}(>}PS*Vn=g&NT-T|pomeL*uCp2V&s>kQgm<ziHFWG_l`k^pq|*=8Mpeaq@ldt
zp3GBYEEoy)B+x7aauD^3R}EltE>q=UtKk2x>^;gQ{<!S?l_#rtQfGNhWwRXL_=y`a
z8`+p<Sof6Q=#TL=b$vE*r$;R_h9J(pC-u@DTjo;yxZ=Xq%JSb%{LL0DX3l=2*1gps
ze};pQZ-v`-MuO#I>6?ccbqxenhPw+**P0}iOml-KO_c`jl!ldEwuunmjqnL6+oEs!
zJrT?Q_149cjWs7+zha&uqTk9w<Ad!l_w__K#adqOe_hZ^ODUF9&E-9hVvTh;H$9=*
zO-;>?ZN>E@5yh5xTZ!8JvLPbfk-z^To810|N(&6CKN{q|STwhH?StVX8%JVh=l8aa
zsJ$@C|9=OlXYKtI{W)6>gI(jPmd%Ued^FfU^48V0G}6`me@Lg{J0~(l)9@oku*?0M
z&l6k0HMCgjYxQ`f6{kVD2d7M0vrZ-Z*~}>I7mv?$by)?<s_xZ0ga!tUet&O=qSM0U
z2<CFT7JY)nAMw@;3-11$?)W@?2~(E&%IDxLVAt^UhK$s$H<bl2&oti^;PO+WuOmOp
zyOh<R)kcKx-9I_+m^(mKyPux(1$b_#@j2w9*bF*vqA{fZ@RR7(H137qg`ikD!=vud
ziC-7{k#WepQ;Nf1?k%9|9lWl;OL82tOejtGm{?)enH=Oe-`?dYYwx(7cl79ePIKyl
zdY|a0x`(P<DAB@1uAVy7YrE53da3^kg^psMX=%&7auHX!BSV0AQhzeQv9r@z`{hO#
zCHau8ZhnW?={7f@q%41&$W+)*y3NZ7d#7IaazsOZ(U_Cd9wT{*UarPDtDV8+4}h>}
zy<zxlu~>3(n{;?8(uS8zMBX3$F_U$u8VL-KeE-W97|8gPS0bY0V;f?<gBnpXG0WjA
zcc*A_u=ESf0?~Vz80gVj+O@CShNCr1frgI30Koq7e;@F3K-mr2M}`n1Gku0ddSOPS
ze2HRb4gjD5BRy?fnsv(c{Yn%2Gp=Faa<QhSf3z-P&`F<8`ypL&Wm9A09r+Hh*d?iK
z$ZIp!%ha^}fdYTPd9I%frcdij*VQ_#3EjoN#JKCqxkVWz(3Z^Ok7q1umxQ#|sQ=dP
z=4&bq_*cK0*tnm1abqUp*1*?1#{qa>3*M<}lA0UCs}G6v_&2s^`uQH3zVY88hGkQl
z7CU|`_5CxfWStVvZ|c~%KmG63jj09Pdh@TbEPwxeqvls|2~#eSg{~18q-WG+0A$gP
zYTGCbVMWz~Cq&5ZmgSR1Cm=Oa(D%s>6W|mlA_W*W-}QeH6EpIDRXA5`xBfp?F2|hq
z0AR2VUyr~%QzlrTl2x6*UC!H(3vfPJx*^2J3@r9iPlK4Bb5^#3rHCbE$z;EX7XayT
z^d!eAAnRZKn-~cpG?HZ#(&nKPtIUzhe3l$j&YCML1DjO=b@SaD!62TSTLZ4fqTWMd
z+Jx1%^q+ffaeuG)vvkY+u~Eak5l-H&eUo$+^-?_t*A1Z9=*r9B!B+TAJ)H$*!-j=V
z>5>BzWD~dTi$Ozxa%~}i4&_(SL!s+WJD(2i2|3+G?PlV&e!Z!HibsKQtiV-t@@?PA
zKgj6UVW3YzXZk@)hsCQ~RlbV>{vzL4`}0`<F+Ab9GKp*JaE(4q_3|mY<}&4&PoMdm
zd=&Wr@_{J}eK{S*cgsR=q&8NtojvgWm!L-W!h~Z<v7I*nnTO5>97UhPZ~{M16CWLn
zsR=wizj9*k$gCW5`*Y$jU%@xt<)}hBd_6PX3A4EfM<(F;yzbO=cji7MS<++Tbbrz@
zr{OLC!aJOxY&rhZ`$kRn$?hzKZTn{%#9!NaveRdIB!;>KheD;#dBM~7L5(3TV}?2x
z=ZcvpzdQ%`OiOgmjjBg2D$Lan!>^a%RAWrvyE|lnzam%B!#5;O0$sntT0J253rk2F
z!nF;-=j|aCH8CbV()l8AChwVL_P@0w-KWR8C9v){pjA-BFXbMqH)c%j@dxM)0!Z|i
zEQHm+!Gfp3sbS~|eVv>)W>yBxO;@6+j=Mn_usUk^LzxXelDnetSQ&HR{*xf-fRSJ{
zWmq|S=L_4Y9jnu3RSdeJH|v0btur!cHAX!)`jv0{vM+EB=Rl*^po18$MiFbmKS<AN
zW+gK04P=owg2GuO^zr!BQx=zU#+=zCco5fA#Yvn`3BJw`*^`x4#+dP&VTgjjD6>yv
zs`WSBpJSH$4*UGDiJi3~^T)hP?xoD6RESLXUQS{2DI2*^+LD>oTH6wWe5P+rF8uIM
zsv3cJrH^-}Sq43s3B^;^yvYsHgOl5@L20Y(?g=)=eHMJyKO<SX8XIQRcNSDSggM9q
zOngw&JTHrR(XA%|KOO9fGPZ08$9f&8iXl8=(klg=c(Fzt8c6NYAD4Zae{27PDDy|x
z1*uDsdz1A*>b7yt<-5$-n_yNeUQT<kg2C|L-KIz09-ntr;jpUXRcD})U4^DYIfdkQ
zi!Mk;+0A&UsS2Yw^I?R(gg(gPjg}5(vj`j-a&PT>akwiAlyHHE+|cPpyb7ky7U>fK
zwKiV^PKH{L(#C}W?~#p$L-`iqrTPJf8QoI?JY2SM4RjK<d_z3TQ}>3cPtiYjK*gAj
z!ibMFhc!Pf6Cc}x68^SUVpwC|<N^u99!8A<thH!h*7#OX5vXejo|!u20)zE%mB7mv
zNM(QLBNrCNJZ{pZTiVReL@^4Xs*#z1M8bhW)d7xUM`Rc^_hTCG#EV8Eq*3AH_;bj*
zD>$aZlp@s1lGcSQ(T2Z>7QD&outf(HD5CUbgc)0wgiS6$OH?RYLd;f@csoRyGLUSI
zz>@mi|H4~j!08|$^!Tz5cm@rGov*WJ!^)h%J7^OIj&Odg1P&o|+_ph6&=DVPv$l_O
zUziQcJqli9#pqHCLx5UFiFYSmpQ2m%%6t$`Y-lNX<Kw=`&g{W?d}jzC8D7MV&<(+-
zT?a?iU=ekMA(DNvg5<)AwHp~oXI|t&ydVQMrQdu7abEpeX*EPqIfO7LbxQCu10voO
zdBBCRf}&eB4NK@=lt7c*SdKu&K(Wm-dd~@P?RHSn^mgP`>Rv9XCSz5rrg&ahjaXvW
zj8HB4mG{TZxcU$BHr)*3LAMcg75jPT3N@ZA@&zcO<kR(wAfXv<%!Q-~WDb8a<i$YO
zabmCfU7`QEL*F?LgMLT`usYRj_iQ(7%s>Cax((C6jf1N7or+zv{HDm6{T9UD)>lbV
zEwJ(5)rZPq5ln$fn_ZlVI5psP4=WwlQl^`Gv4({}UDf?r%7oOMrDm1QQ_h*;4I;za
zFo7$_`fVKH6M}TsmhgSFx$r5fjUrHe!lba{F;j^DH$`YG>cq9!H;U1}c8PU;xgv8C
z*bSH1<WUE&JTtlTbt*1}A=!%!b{qEot6XXC<rSTm3jNwHb4xbqe@0+a<Bu;=U;dP&
z-+V!e5cs5!w6_vEIXM~lbnGmM;6Q~$L(EI!oQxyPpEG|j$nyE^XY&bnmNH<iAHbXu
zvYVI4QnH%t!aU2>V}(h_Tntz=D~9E4)<m7Ml3#h`T`tO|?|kf(L=>^>m`*iPZ$v9p
zYH;V>uShxi!Lat`0fpl$CX08A0se;ptz-y@n}u;u9yx@-P0?C#aXl=egL+rXbd-{K
z(bo_e${5Ozb6}F8&h*L$fPa09M6*Ht545t54FoSLvf<mkflpU6?>7Q{o)t@faybnn
zQWzd3{Rt+8Zg2dU_>1QNI8>A$$KfNKguhO2uR1oZN8OqZRn{21<itPUL1H59kP06W
zcOQ}RA!6^_6`;|VWkmK+*}pPD=rp06?%`V>%<@hnwWMZXWc|8vt0Gn%)za4q97QU~
zzCd^UqUm}TiaPaH@Lv9Y8-Adl_@ZaI$;AHN!2GGxsPhipfA34Yc<6u!K$37q?3F<+
zqyB;+;Or}}R}Txkb8*{kV*su^BySh8xVuP|Y}@f!+R-C}88d*9F$tK;wq*<{_O<4;
z+zy<Qb3*_rD^+o94&R;dS{_&TC7Py5H>-q!;%gr7$iyaR1%5`K&q}5sWF3Th&>@Ju
zzUIR@_z_rn#_;2cR-E!y+#{qPumRk*QXTz<#|7$*bY1}E`MjcmxSypEXrYPurXr0%
z=}&gwCN&SJa096KfQF%;_l?SbL>^U~c2(N=KB<;LEpoA_R`NY&TTRCxE@}l5<HPGy
z?X@BTE)p^-yaC|nN6g#jze20M;-BP43hyC`5mdI#1;D^Ue|HtD5I+K0k02c;ucrMj
z^7b`q1I0O-*Ok04&awach>0Ga8B5)*ynJ|RPM>t|Lqy$)x5<u4B)+xr;-#}qJwg3F
z^|KEr@G^b7?2y*WRrP!?Z``n)ezMuk<{x<<TA|WCp9Gupc&78yQ5nUZ)_uF~2qLqF
zZ{Cv0+L^gs2^Hl-vs<B38+3m@jLI@LXW?rGT1oY8Vago8z9|4E%&1=!wH)`<h8ec@
z6vukY`k<*^JT8O`joM<w=o2FyF7eY=voRESci>UI->JMJKb09hD{<Vw8>YT#J<Lt`
zZqA0`9&aiHFR<dDiOeE_LHAjrt;=u`_$1$5FWBC_K4{_;xNi9YV8jB8H-J22jAZ)Q
z+KKrir@q4V?YoGJ-0-Omq5LwTE9R)w9MCWtU4Sw~@V{fmHF^Ui1W5otmB^7a8FuS-
z+$7<;2f$@HSOR6;CK+LlYaL74p4&zF%(aoSd3KA(H`n3`X(JHb<Qr@eD=7=Ut3Ti(
zhRrNAsG$^o2Qpe*d;Pv*>bD?Ff3z2W>BSw$&;~M+s%v-c1s<ouzAy1NJ7Fz`sQiyh
zXbBZJ`eYpj3`j5Lp63+IK=ZjHUKrnF3y-BS_2Y%eeU`cWX!|>RYhQL41?O+i&GV?6
zKePi6?WF(gyUI@G|F>e7bB3SvTWQ;t&iI^$_d!+ly2hLQkWk?OB({-}YzCgeq<-Ab
zY=HyWA$|c!)%Mi0lnBn0C20VoZWZ6PZ(~QNQUX{F;nKH@tLW0KYh3v8H|L)Gw;ZP|
z^OpU{Y;v75n4#vrtWd{0o1x3a>i8np(Zs_gel|WH>V+X64=+<*UQ{l<L&32_?&a^H
zP8;sZjE3MGqru@?mgHOCY<m_`gF?K@fioXQBp5Ef6Sbi{b-mG+sK&skK>+Z!>q@Ce
zd;_W*q7&v+5JO@y{lr{BEiT3bD4JUm-xPU;2a&*s&zSVSqtN>llgEvYI}lkvT3y`Z
zBv#9#$V$jfFH0%+JO|5I%60H8`%1ufVQb3aSl8BzS%JQhYy8+z0P~Fddk^Fk=_Cyq
zM-!Gi#F3b}wV8IUH>=MV_Kc!24Sj{6!zoNp7_-X3?21=;Db!K~oOqu^sl$t^;p(r&
z&>Xelg!#u(#>_-~mNH>Iu6PAm$1FoxJPHkp8q-XmkG7i<=5iY_*N^DygVd?vV(nY5
z-n8EWOS%?9(W`S*W&!f<#P?v-U>&f0@6J<mp8cK1Bw>luxD{>!hi$q_>%!3%+OnxJ
z=_fzm^%E~#^6KAKKG>6(GrV<O;EWW!t*V?{=@is1H3w_YMF{c}QHp1=QsJl+=_ZHY
z2(o~kJIQZnW}0-~m;tBUs=hy+=ml*`U^6{np<vI!@t~fiAmzU`=YJmxYu+Ip7?x}c
z(p^R#o!>Nz{&`n!ME(2VBVlX21RLgOWA;Y=CqK7i8)J-|3Tg_>p+6FA*b(oXBxS6y
z-=cJ1evuI`B7W>>jqh3hltrH9PSCQ>A&z6#`Q`$6v|EQ-ihE;CPJ3n+{u%~~o)VbK
zX1Ydiwm#tz$fB}t`e|RXm*uGW4xNd`>z(AP0u3>h>#eg^llJwT<2FGV2#crgBV<65
zm!YZb&+sfoV@|TzpGP2i+7sLEd=%jmf50n58fN1Yq849VW-E53b@|tYx-!{Vko4vi
zIB#a8@Z--en3UrlJ=mG?=sIXzePt%f(Ck>=tN`>SV`Uk!hG0=_n({LKQyz!LyT)pd
z({)sqb)4PE$!c~DyDJYksLw}$s&}}tP-16e<$GtgAFq%4|32+<UH@}=?pR#wo?yeD
z`Rt{sM%VAD)cpP`sJ{0PSmQWPPBkVOLx44UFa{$O(qPREc$48Jd?nrC^y~JTh?M6#
z*E?%(m2a`lng5DxWtr~LXGpdvMK;_&jL0EiUs=6fRqFE%m<T{>(C;N~?nYsw@};#$
z0%Vy}uR=~2@M)5GI!5J%IhJUVlX<(fcxj0ys;&nz{Z8BOOJ=pjpHp4ncVCU$#KX!r
zcZbrMz1l!cSG=S?Dc-xJhyuIKee7Bq<uz<SboQ)o#f0}~FR_k%cx;!BA9BSHv7%d#
zc3tM1Ts0Y@xu~CiwKr{FYT9=2U)qzLd-s95E5DZ#k(-$C^S{x@0&_yFY0ORTP)-rS
zy=#B$bWEv_g{vQMox<?eWf`|1`Mx!(DD&9&_McDtfyzU~D{e=@cVEN445(17^RRG3
zUdzt*qtDd4a{_zksv>XXCy2o<KS=S#?+b))2#kA?;phbe-vP)v`is;hq^kDYjZSp_
zgHHqJdg256ni?fB=?TYUq%VmKf!<rS{_mkXC7|^IOws`EWtdks@ndeV0eiRT5?}6n
zrW<{Sb>J3xmb&<8E(1;e@aj$en)ywB_7--6<4H7h!N!c)C+YaaoZ$R!t%q-@L;VM+
zJ&gVD^5DNyHTE5Hm>c~k&hsl+Klkb(=AHR*7q^vNfK-iqZwv<@FP~atson-10(>fr
zN%1@L8Wfm)uCS}L`2t3-hQ$$~^<UMYBR^Gy{jaW-XtHN<Mwv0m&^Dj|_LL^Wh%V3O
z+!td^1BbWtE84Wk{B~jl<=rtCy)=51_J%n!PvS>Q8QfI>8cgoO`dJK2-bYG}TncX<
zzA?)ld|+^in)&z`SJk-Q6w<@!YI6U$3zoli^;o*zBxi(}p`Nu%O6dUXK0WuH@MO5N
z12c!{hCJ~nmeu%Y2XN*czP@+ZP$Hc>c6qsg@%^ah#kqo9dX3IO*h6zXrMs#0In*Lf
z*F0I-?E4wgOM@b=!um#V07H$mf7nzpm}lFt8t!>#Z}PEOSp8=EZ`)f1oUD+8&Taa-
zl`Ce^4G(9D?SnAH_kPX67{)zxjo`{eSg<l|;dNGY&<VM2WL$lo!+%@b6dR9B(bfB5
z`^#tc;=+nSN#^Lrv&C==&jHb2P<c#E9=odei<2_DbE)uPs&F^^%>DRFJQSGuhSC>a
z={dCKO!mWBm_N{looHgmkZgk(q`>*$nk0qjfGQr_`w$%M$-Fx)5Z)&m3gofW|EQ80
zLZl7D&e0a!A`-maTty4B^l>HBHwVwvk?~~;e`U^>Ac5Ybai(_jw;MMf9iKeMu5rxS
zU7CBS8u(=1r6h6M=)dfSd(S!(qutmwn*VRHq<PAhx=ux&zcKFbBZOXQr-4v+&ZfAJ
zHw+c-B1t6*>|xE>t`C1STa5+RZd{EPFNPVOXmPW=(G314Sug#n+T<l$`&p)xL1!~Q
zCZHDE{Lkq%+;yiRW;;cGKh%o;v2{dF6)goL4TLkJY5SLf<Z0X{&r4<r;1S-K@^k&$
zdqS@Zn^G}%Rt#AN2}8k@^kLY9g(}a>NIwANo!0oz?LN8qB_*)oju)`QMb$C~ftwSx
zI;(}9hbmn`yE{QjqdWkw*(7`rId`xi(gj7XCVhz1LOiGhFh@;7Ozl_RZbWr8@ko!}
z^hCP{trT3g>M^;yq6eU?*pH;<9OgSS(^Z^h25EBx8XQZjkJBPmH(&DMZK=dldw$*x
zT`_A8$nAFix1RB=*fpTeWD6xHOVbdcBWmWD-V8p3@Gg%qwNRKeKyax4L4kSi%UyE!
z1d@m04JcpUzu6&K6B(WoIQwMz-JhbqFGXTGSF3tOp+AtD?2o%5#T!J2oDTh=FnMOL
zT{$gRd$zd?-I=a(E4X@z%H-O;2*l=2r+m08h%ttVN;p(kqW-uf>4ne`5x|g|);(0f
z*z{xjVxii|H1i$TWl}!Fg!=l}96;b_0;*d3m3Sz`|J{R_UtWu=W^Nz-=AX~J4_MH|
z2S)G!z;JN>IgR5MynxA+EbpSJC*m_BvCW=*$*xW$vA{2#O#jOe45RJzsKf(z89CSF
zf7IDT|1Y&?qSU^G$EwKQ6e7JMS<!IT>u2F{7BKb`X}C!|grt=Ep6Q_1CxNVO<L__)
z<Swz^>|l8qCGc0A`0wmrX_-!qFM*=H=giZgwJVqR7dnS$o*=VAMrUgQ_Z~jKOQ6RB
zibv|Fz5zh02+r;DJHpXX<z1u2dra0Jkt|qtshJOn#fnEWKB?pqTiKH-iJ;+kxEA3q
z(`hNgs8JLNa|pchOy?q1MXu+uB+%m%C-zpAVhV8e9@dFbba$qguYcvuHTq&X(y7kW
zN{~7MDCd4QhFQML|Mq6^6m$RU8}NM0Re#8@+O2M-2?@0JOX|<p1{pqFKJ6~k?6yyA
z+<@igbf0y*o}v!uH`uT-jE;bYUgJTe<qy|+cZd#Yn!<bf^PPvUWcQnXGzo#m^B<$7
z*Tmyf0JP@V#I}p6$4zp;d6OyU@4WKZ=HEAzsTNGkar@0Js4~St-de`D56sICV7pt?
zI#pb7{Z0Wq%A`s|C$5e|Ewcnn-??Z(XQeeM76A$)a<0-$(bs>ba}ysT<+<O?{CHoY
zW5s~7V_Yn!t74|gtDydEnj~WH2H^u7zoi+k-mp5!=g2q`CMQXS6*t}8T5bKD2jLoO
z>DP>-jPY}?s@3YlU8(`{I;b!P+9o1?S0EfTW`E*sOepdh6K?E+@;~gSc16yMdKGW}
zN<J0cs6+5n-CWq}*Qxp7mN$3hq`+ND%kWAI%kxnA20NUXprbU9IG~gw_9!++CL0Mz
zF;HQPTbe-EmnZk$&!6wM&u;Z#hy0hG^}tQuUo+hB%#QN-b9b9V5Y4XNgcnaJxQyDw
zN~*{)WR43&8=Rt@TsKP<_p<2ER3v=lJQQSqAg6Tx3IY(V@UCw{G8i4w5Q<~iqX5I{
z{iNGMthSOf^2C2(h^xUs^0*lZ$DvWdEf7Vi#g{?@_Ij{Wcv8wfu{Gwd2VvGth&08v
zr#g3I{=D3Uf?M@m)Xequ#OC_iuAvUs{=8T3ob@pYyr|cR@N>xTgRu0KRA*j+f7`Fn
z`TtfM$eBmOb$G`A^Y7hAlIT<9;2<mz9gs{2FBo?+fbFI%5a!%@KXvr88;0TJBaugp
zUOb}hlBB;$_o2=04;$`z3Od|)hgtFlC;W$@#?%nj-G)`Nrg?S_QQ);^N@~c#FX`NS
zHg*_nb<XU;)4Pb;6K)?5qc3p{;}T}yNr7!4_;_VZB`8x+8nWIb@UoBUp40Mj?9@PZ
zEdG<6Pr?D03d#t+v<=^6!?<WJnj)%B#Atxw^{L0_gbc0lH`WV@kB?!IK>v~vaUBGT
z2l5`rr!hI$;DaAgh;9Y&Otu>aOU-d_oi*xi%aMoJr3TU~>Cx@%=uG;$@WP@d_#!aN
z-kHFS;w#>EK27$ZWSZwh1U-rM)hBte5rU>}=-)=E$&O1kDBw@vPf9G~ZWLB9Gd>;O
z?{IBD$++8=Fp+a2W3@Ji_{D~Skj2@(aAYMmr>1kptq30aDETC|_S_{e9}ami@2tju
zj}plNudWv=#^8Og5E7MLqj~AkcCZ%5gNxT@94PppC2H1&Q5P|;u2v<zfkmN6U@(<F
z`~v<&3de`HI?)9ww)J?@-rwWq>p}@G!3PR~*@_3dL&&$o#HMLH*GNJQLY3j(?t)z+
zW3nQT1X`i0-96hRAF1IKp3~7kYmLNXZn7@UPvcYLeL*0>b>KA<--Y;ikeen>?|##O
zBQ3DXSHgFb<@f!05?Vp=4lsTGF)i>t5xs=`2AAyvER0XT?YFHlk$N8<{y_*cK06lP
zvRG)Tk$f+9A5sPa^EScTjAUXuQV)*-p|+m}mvCd-QPO|se@C3qhXpl(3U2h9a~K5R
zNi&A5n~1`?R0JKffZ>Uq!d#-x<v(yG38xB~Z)gI&l9*qnpww$&^mpJNFu?gIqS(ek
z5^b47gz{L9sy2U|3{!1Bdtfr<TTIbyJ#xMzYS_;`H^F=WAA^fzB;9`zB25UK%1haO
z%`|fDv!m=oN0#V2MS%60W97|A19P4(s4=Mph^FQhN!ZVR@tX`taAkNPA55VgIdh{l
zyb1J^vEJ4|xlyKj>u^Gaodw!*9CM_(tuSJLK0ENLM??w-B|!#CEddskF%5E<G}K$p
zaS8S}q5H+%3yC>sOaJSiMPjyn$?!CZ;i<BgC*@=@cmg!`A`>4X{peH(xa%sMv2p(l
z7M-k;+N7S<&S>dmPa@iN!euiNyOQO^;#sX?U_1-*dWFwGjzqI9OLeg&#UIfujZ}Sb
zRl`r`jp~1DolMkJcTR{vPltZX%J+z|>^1D#&C><2E84&vT|ByU(V>W#o*)kEOSrD8
zJp&Jz<$?Ljp9VZ|cmd8caEx|}X7OqzOVDphW*J;7?rspnVB0|Lidn(sqXFzFET44T
z6no%1RT_#)RxYd5$MovU5T8MKX`Y2%OAPSfqvL0QerEM4|7z{4e<mIm0-27}qr}l@
zB+`g~@P4k%dyaDFC{x+JD!2PWDUb%M%Qr~sJ7hg3J2w2!=^*d%c1yjGynu0Wd2+XR
zuzKfz`{zjeA6DC<@}Lm4<_jx#)jH1|T&zFxDF|1!lA%#>m(Q2Nd6%zx>zX)<333i~
zdF4y=7`WnYFEOabPCR&FeNY>E&^@B8aS)&gd@*Z!gSXo_EjD_{UsKAfhl>%zO>H#}
zUA7h}PxF(zX}c?|b(5&o-9<d)oy<{2^7)*^eou!+J_ytl!`V|ENk^h{v24%ej6g9O
zUvXeUl6R8mTOUaovsBaCxQ~<BbeeB+Vf*o@s>t5?U$zci$X$f-eWdcu_x$IQ2jNSs
z7u}z<5AS9azY_D>8kbpUF|aMX-HFqzGYMZmd1^b#<T!u_lzt*&Q5Omt%Zb^E&m9V0
zbT44j^9Jk)N>4ik6d+2~ZpU&*+VL#(AoYPOE=!qYNB8gzN}__V`y(I>9XFM>_fGN^
z`XEM|1QdK+duo;%!*lX6o&AgAEZV-N`$UPlmQci~xezVY5(hrWnb3RcALA}1gc(M@
ztaP@lm|~SI9g7+$Ji1%o+9FwV=%If*UlATFf<z0!YITgg`ET#44VM14MoD~#%IJ^j
zm@H*Esn*geKT6nPljZ;uEhxH8*Eu>Ab>|nHWs60zV)vEg5#fQ+#~057{v!d`A?$|e
zW?i%dNzl4Nf$kS>d*=)31<ykM=l#=VxEnC>C207W!B)pM(Q9z5zDfG5&rZ7W1ipwY
z<K4bGb6SD>7jCP`_9!B`+NRIo34T-<;6RiWv7+Db5@b_-)~Jcy^0Leo8RJINL4B_3
zaaRQf@jsLQ9y5+!GeWd?X|*NGD{qU=8EE&rpU+_?$sU@eb5!#x&omEIT?d74tTM~E
zKJx&<WnVMqWNTJI2yM&M`J!U2#iMy~>~`T^W+el`dhw8#K9COx7j}`O50q^ve>wR#
z+{gldlCCub^j^$_qW`P!FsUydIbkjTN7QVL7VBJ{yG|aV_SE$`9~JUamBk2W4@z$V
z_AI&XVtcaRB5Ay`RJ3pmdOR~qAuV;bZ}%J^&*R3Y8bYfcU{v_uT7YlGU$5jC3pq1G
zlBe(qNK+w>@~b7#sQNC$Z!go>?UFU7O$sv>h&jE4>kZ?sEUi+nxCS@>^t#;gz;oNF
zGGo><)W!Ga9-IHvGaG2Wi+!m!h7WU-aO}g2z6tPeRhUS8Q^eOI0z5}?&hok2URR%c
zX)vpLbnR68*zP=-b!FT2wCh*Brt<Pe`UP3(NSV4=58W18d@I(u;ob|J*?2#=Q+f>;
zeqHR^=q?>7JK69X*OmCIu48feFjEomRv-Mec9!0fMf>$tK-+cFp+0)@Bk893!E6S-
z1C4c1$0st;@*-`YFl;DpX<DvYHLg~P^VgAt`?(G13_-whh0?Y4B<a0%#_@eV{39e~
zlx;i%4j8WT=z4ssr6IJ+$oSwnin0AP;L3_oat^dNBP|?G89Pg>U?Mmg<dy{cYbB3{
zDAc=ZN7sHk^65FftUEgH6|AV2yXwan_FWJ-bMHaLF>JgwBL>y{xXaKmVO3S~>Vx+-
zReR2SjxziwaR<8#F}zIAn58?KII0aB#w|B{p_BcB6Yv>M_&$HL4|Bz&>(R5fLPZC{
z-XOlxUy_}o3OYRs8xqdBxNtLq@2zLol0Y!YzbC?eVmg@M)*SKDthf27o#X5B_8ZN?
zO#xx2ErAM}n&gij{|XE9)XkngV&g}4(qe+U+yq;?#$ovCQj}y|$!f;&>mOG>9=^ca
z4>)$GY{xa%L&|?%X?^`=OhRn`*LbvF@z}oBD|{z)TZSc<;Z>h@9rNbx0N`WWZ{q9Q
zLBd{tcv2`CtnUoOcSs_u8o=bMf+94^k%jOY7BwY6<`)1w9jh`1eQ)}o<G0I<G)m9(
zVDhiq!k{k0LvEG_MPUzo8^_3qJX_4_-r0iz9Z}2ma8jrVGtd_slQDa@<MyH7_sgl&
z*0c2WtX!$>0Verp9$g*vOzU}XqZY}G9xMUhRRYDa_%oqEL6`Q0dr?!d6>LrzV^s37
z0mxYC=8PvSE3xr;<wRVP*-noI7v;cbD<Js>;Ph<-FdWCYqk-mkP&)>F4LL)0-(4i9
zm~R9<c=B;~{b;mDtDKLI9*8Ug8Z9Ha)Nms%(Ub2Grwed@5-_9sM^6F|7?+-#f;#`v
zGX9U!Bmv{NQQ+~&e(-tVOAb!0kcf0RxB=*{fZea4vRf(7a=4Z4nel_~vukjS<rp9O
z!OzOrNJV^SIWBEGf*y|FKJMlw{PD`+Qo$lY=^cv{X0K?10{-pJv9ceQW@t-T26O23
zya3%n@E|aX1?6>l6?#~I9xvE%{0|8geuZWEF-7dj#;j?BR2Ox8hzGYxB<bZT5?>-t
z<{plD$sz-GRtAi0hX--b`O1PQj6wvX6Y<=17bM?@c>o#8Sl2^X+&o_vS%yqfGSI}^
za||Zpb%(%4q>DIgVL?6Qg6Ye_A}&M_KKdb#-U`6=Pbo}@P)p8_If$^v|JZ>=`SG5b
z>Xr2PK~YVJAdV!Fk6fP+C|!`)IEHe7i`2tCDJ(SyTbu7G16viQHU_$>s;|z7C#$E@
z+ZI>@vbxJpkRfXKq*Ur$E8!yZfY2ybe!M;d=>^SU(t8)fPJvrKr*tcs(|lyEo~u0p
z=!={N4h8p4hy(WvJJo~?)p*f7)UgtXpBLS6%S4@U6TEsBmEM1kc(G^*rz;D*DFI(!
z2MfrruQE~+W3tHkCX8u5ptV9BO-=#E8|%9kDTmH<Btd@sEp`$LRN$vok5~%`$u6ZZ
z$CNu_GI{ZHEhfwGpdRTp8^G_oACSFmZ-uj=RPNfo!k`n8lnXk6hB{d0E0({HO<vIJ
zsS+vsLMq}8D|vwb;&U=n9V6b2H<^~m$r-qQsRW3;g7clB37J+7qO-ZaaxGUkx@CWJ
z-j1lG6&aM)_^a9A)nj9qOu;H$oa{TI9im%}C9u1QQ2t5Fd-0huvQY+8iF9~hKERC?
z@&yk5&_4xY$|OmyS(p%c%o#?9e%BNBlWXhrjq!O-XBB?aMjgPKLs}p98OB%$NYLcW
zPXDn|#(lh;kiK-!Zvs47He0%vd1-g-3cT2F@%uLBOJ|B}ba??$<wBhz_yqk@noZ&x
zZs!uh^1=;(oaj>SfU&hFoOEe+=C5O?Xh|(u2vK!&wZwsNl9;}BvVkt24?p@Q-Mg0`
z1~Xu%v3>Xr0^gKUd<*1M|H$_Z=u=7%6jgnA9=QIBdRJm7zh=XXXQ+$DvoZP=PiFa^
z^5w@40nHI7=f<Ug>QKP-*(@WSjc!^Eg5TckU?%RhEgcv6D1*r{j)rSmL}?1ICmp+T
zibw*KYL@U}ydWW!nJm-q&N26@y7%v_nhD+p#KhBEB31s7sRg+s5w0m>SY{!D2}^tr
z)n*C4>iN9?u-cTQgmmCq+Q<eMxhU=Gn8fZsMo49KJ<9f4#Hme1C=d%IKY12WD<1P`
zk*<o7Q{h)|0yh|311eB>@YT=!?;M}^2HtgDk;jHdfK`ApJ!hRMpa=mk0f7(nmb-Ib
zuX91CpUoPyj+|rU1{KVh6|}7w(8%b}#G~@}l9MT)Et&XInA0G%7GSDi3pGb$`pNmJ
zze{rxHHzh~A)iQS53oQtp}{?7jB@|;I__}A0FBDy(FCEQTWlF*ksve9Nzz~sz84@|
z;Ad4Xp<I*b5T?<Z-K#>|GMLE_0)W95mbZw8>rsB%zn>N2XVfbKSJ?q0ZGr`@5{iV<
r|5gdQK0itKSd|`21_oJJ_HdFM40I1HHF{~Kg@BR1xn7M9Hs*f-DyO1S

diff --git a/Templates/BaseGame/game/tools/assetBrowser/art/guiIcon.png b/Templates/BaseGame/game/tools/assetBrowser/art/guiIcon.png
index ffeb015f1fa198083840d9870738f5f59766abd5..3d25b953abf46e5a3bb98eb931ec0da0ba0e7935 100644
GIT binary patch
literal 10181
zcmcI|2Q=L6*6%1mB1#fbf{=)akf<>_Nf1Quy#%8hEqaZJL=B?X5Jc}rFA=>=^f03b
zQN|EuFvi@!oO5ozbJzEN=bU@jU6z?yPuYF{_TJAsHI-)+mu_4Ffj|@r@-iAA5FzlB
z5JW}-eC>OUpMXG=u|8UQ?i%Kvtj?}bh^>PatGl<e6|0q(Ed&Jenn9)L$Ndndl)-z4
zix75D{BWsH9imu0+LPw2PAuCfGimL<n{%IrQ=R65Fp~Ka48Mn7KI`I=rFdvnnwPNT
zotJ3v)35N%`vA)+ISY@`^}+;H&->pb+X{DBcFRu0)C>j4$$Meo)?695<KlNS0aTGt
zs(sHKwRv*ClAkSVAJzy1TCN><=Frb^6|A9mO&V&7Oy|G&W=f%V8Q<8!y2CCM|G1rc
zq|{NI*p0d2r?FJ$@KHUB+Rx}Gwr#fOTYKu4=&Lx~W%&JET+;XHI;=kZ8ai{Zu7_rz
z+TdBg9^pKK5wQ@6IjEj!Do?`a<FM`nF{8L+)KDF^_sK<c@R4z1|Jq>~mOW5u-`D`U
z-P-6{n5BCL351{d`44Qf`5)rbwc*q7*#oWmm0xq?J*7x!BqMF9ug+p=tFW}*@e6c!
zlLl@4hlf(Q1&KTb)`Vwq-0QBE^QaGfS2e#so_@p2JYAcSU|GWpwTo|AA!c9U(gE=X
z%UD8>j3ST&b-oRp6Fh54yn<x$!I^Dm9&MsK$W-dx0|A{9F8U3<P`Xhl<D1wkB2cwG
zik%)THfiNiT!&w$QA5Xem~TG4erpidoXj&4NS*3~cV(W0Prl{}M8wLI_{ApYRotd{
zEK6p|{x~BqEcpv7QJk9|H~%O3cedGY8idw9BR}2>vj$tz$LAg?YPmjDk1P4We>9@i
zp$6wGNO$W?wRdVr(kuC*IP#)o=8@fKiL7?<Sbj@)s$E&0U1{ya+>?k3C#P|X;?ml=
z1{>?u;pq&5mKfe8dA1mS_wf<r&ud46f_vPW))|h6*L94>cke&fHFi9Bz<3W;v-i-@
zbJh_<G_E4P{zEgmQBze6CtwdX2;4inrXLTsUxf6NY*<fzFFxT5rO&V&U|=9ukgtz>
z#7|Q3z`9jYv4h`QWbc96b&-l*hd%um3~V8`&wHOqx?v#0p=a<PL$)p6<bhzfVGT?~
z3f6Hh;6ts|FL7vhCVx%#iTnYxl<#MW$WVisq#0#!8=^6b`KTI!SKXK5SKoBgR8$X3
z*y^T!^NoFb@&(GeSN`J6r`z{(ub<3t^^DK<K2W~&Ew}h5K3($}x$X6+7G*CwS)xea
zq58asS!PIM-N#>t6?|i=*`f2u*y{x)CW_Y`*$+)--t$VllzPHn_V}hi9;b++soS>p
zsZAPT&IhV`7J<yAZXpf5h$WF3e?}hz*cI#tc1MV@zN~%pW$VcgYFmYp{KnDNp+coU
z-!MwTH4Q5fx>gyZiPjO9=zf&>Jgi_}PubA~<AXk0sd(ARdK}hw+e(T-3UM6O$<s#x
zH>-2eN@p3x8aM>|uWAMI-E>rY>V(_15KBS%iVtJYZ}!2BHIs=b6OgBzUR1ZM_EK+^
z1cZxz@~gTl?{c%`7bQ`^b4K`mD(^dm`Wix*6JJBjGotT`B87-jK`EWF>TjJEfd%bV
zg6<Oj^?r@$g8UYt*M2k-^AcYUh;nawP9&?|&I^x>UCXfz&W;U_)W>!^EfRuq5NRd1
z7-hhi3fdCG8uSHMI7GCGU)cDocT8+5Zq^^QSys6El&VUV-#A36r$NNv((Tbo_1hPk
zz*EDPpJk+c%D#EX1(Dt0zuG`kI}Yh}i=$XmZHZ5RZ;^HA7$d4LZ#@@E%slcmkCoyQ
zvBys$1>x$f<mc)B`=vIXZfUzjBFT->Q*Y|3Zr0dxI2r}Z-WJpF$d|dWBE9yFr*k4D
zJzHYlid!?bDg5QsN>62f_4gU`SvoJ=kNjIvi<^DfF9ywPiwy0VxR5ptLk3&V=LV11
zJunLt%=Y0AerQWv?fzyosqpFQ4u<1;js-L6CB83OviCzQ%L$=O8gFiM4RCtP$sTiF
zV<IfcX4AYR;rNCNV{qx}^U}tgYBdVCnnLD;e4&j&{}O$>*`)0wpV*XAG3@jtZY0Pv
zt><19PW-AO)T+v;J|f{uq9uc+XVvnx03!MED;@>-INy80NXxSq8s8A7gp`&}US9XS
zdS8;#3+$U%8EAGgG3XQ`)UJ|l)%MinbKT?4rh~lm{-~s;dV8|{(Q4(JQU1E?)1d++
z&*bFHtTZUUF_MxA3)Y)UG5xZk5SB?qd2ZCGDIs-VjmS;Mr_>tU$Y+H8sCRr&xvE5!
zX3$gn_30%SerZ9Ku1MDurX&uc@3(S7#~8?W?$8=y^2KrjoZqJ<t850^Ixz?@-AUF`
z9`IhBczCNbOrFFve~}$dRdb7?=ZeDH${Tbss^XqMU4zWV7m1-njn}(k<V@&8xapv_
z?jz1rR~XzwT1Ch&AM7|AE0j7tG1|EgE=yT0fs#l&SbU)u4pf~tUw2%7Z?@riBv%hE
zmE(Hy`ZM~cy5jRoOtPI9UzU!4lp<r#o1}$JGQV!<=hbnr3JDGSyjOnZK-UoCE2GTY
z_RZbr)7v2KapKk+EZiAaHh#)a|1vbV&8joe3n@6;kGmtJt;x-{VDD>^?EFe$$<~tm
zj4oH~^%fUwp{S3V{Z!thl7_|CfcSa*kL%9`s-^cJ`N8x(lu6mKY1f3N8gfVYp6#wN
zb2X$|sp~OtVp2%>E`4W1_!3zfL@2OT6ol;;(>L{7ttKU*jz{t!+f!)cTd~bhr-fD~
zd9&A-?T6To#yWV?4M-$S3iB`F!ZtpdZSaaH(rnJtOWzP1l9~!l=lps>eu;fa!I{;<
zX=J(eVQM8YX?J6smYrb@HH2Z<f?=GHSjio(G9RR<=DvDq+^>%rZ&fcjQj)ZlRL?@n
zQ<fM6DI=X|d52Fe(jR&{u5-;->c_mS=-bCdb+#tVAG|JG$;3;EGTyjyhwR6<5@nx3
zLAo4SF1lx2`%t!ihsR-Ttu5>+y^;^+mlbqz7vj#GHUnHiB((+U%mVbzb$a)6GUN$v
zZZ8xBkvrX1D<^sz<8I_2Nti5d`0;3rxWp|=u(g)2uXnjLdgE#KdTCA0Q7}^O(VDsI
zYf*~^n;rVNONRp-?X8#GKJJi(rRG5PbM&&G>m?g^@Ql5A5k0AKk2FxrAV5N?M=G((
zzJsBwv~Z}pLE&>6A~!xX!wfcFv5u9-iyU2O-3=xXNIiVLtWUG{YBTyJvg8FRZ$xx#
z^-Sm!+W^{c^(cna?d)&b_rnE3u6Rb3kiC{6q^+{4)J)^!KlD(0K;1RS?a9m-F#Eup
zhi*kfN-g?U3MJBH{|THem9ox|E^8UZ371%oE--pkxld8}QM_OF*pDeKkLXY^_2C_o
z(o`Z}kNo2+)7`Rr-{0E~)GUg|`S44(j?l0cQGUEdsv!RCDl3b{(|DO-UAB!-<mwzj
z@w@M}VMRQ;qkRQVw3k6|2LhP~=N)E~m>C*|uUGSBtIs6f6qL9i#=?CyDfz=3+e%O#
z4SCp)C)Lz8c6FdjOg+-|%3ofX66{ml7nY`*NFKe>EHhj-AJiOvOwsNxE>0rRURa|q
zsA)A#ol2X2oJljb2cl>1J$6Z~-+O^%UfG?BxOkU2ZB<@1dC?5EKsUlvlAAViBF}&{
zp>BR{7fX1#qQ@)P=%H>`(8mG0%#4R`a-zx0xk==EJxO9^I(sVw@BAvAr0ERWdyqw@
zx+i)qzv)f1hX%g$-o!HaSsi2k$$FulSbmrMi3@o}{5VJ7Se4^ideX;+ZK2L@d6LNb
zm=3u4_|?roWKZ<^T1Zry)GI5h04oWd*`=1ETzfekE{adG=GkEvH$K;hAdQ_$wR3Cj
zS*h<SK7yo+wePI*$6D{0cnp?VTm$10zP_T$EB+e0|8mx@<R>+Wf{V%N(~_%Z8f17<
zxlSBI&#tdw(xRe|QFtUfnDxR+Z79NGnmzdOWa`FO0+)!7(mCAhMB?)OJhw?`-&1K>
zg1$ZF(5M`E^-kWFn)cJ&l%-$vo?J@ym$&zVMR|1>oss1{j%a0AycXev>U~JC(bp5_
zuLPR3qPp6lzX)F^vaTy<Fhowg5H3y(ag07>>>TDC9dEL|=w&3+bM%7zaU5A|as<1Y
zK6yuv;+@eDB2GIA)r9N!k0L6r4|eozt7b}A!a})@t%6TC70Jg8HAxyyO21xV&v_oC
zaZ!u2!ii5~=g=mhrvIJwB8=;<Izj3~a6SXhZg)_Z=8B!YuFb2TORRjGheZ-5MdL5&
zG$&h%A}fnt2-VMAb)3+rQ$lH$)?A--yr9R=yzBn%y{O73o*6oYG0lh9LL(MP7+*iH
zs?*&3#Qoe|AqA0Xt?8RXFL2)lE|*Rfb>$m_WGLZ4q>f=N%Pq<qq6-{8nVR1&M05>C
zw|^(1P%1DJwXM7mgUFqEDzwji19ePYNme*r&RHYwJZaKw<1tXz^F{d8wqn_8(6bzt
zNo6HkEptioOWBfyhn(~W7o2>Beq1r+jRL(A@llj3PaEfYPjMHOWSnTbakZX+%;J!;
zq*&;K2Xms0T$SM4QD2+jL`qMnr#_@DibaBa^VdkG{rj6I-?8=Zbb*;>F_jymp^w)c
z#NXGk#Q!X3O`I9v6Odew)|)rh{uH-r!ISkc$lbhg35BE+&5|bD=}<uwRf4s!+cJ!~
zDw=zjO7Uq=?Ason)l673y!IfiBAi@T+;(HTOn#9|5fQ@0d)vl-LSeE>M6e5GXy&(d
zS29>TU-r`)v6op<Duub~(+et8hkAU;3B!nh4r=GutfZ*#e4i+dc?V}Sm2N1CgKtLp
zRP#&+7_m0_YfxdrEVz}mgK;l9Q{`ZK$_S;G5Ee%d;RhF`<q!&PY%`^XX;!XbcE_9V
zz>n5^tIviqY3@^d5_gPYYV_|t@VZ22*dX?#`W<m}E-O2uD=HE9D*ww8p_E2YUw|?}
zF2gIgLj?yPB4utzg)h5`ubQ+(%=2IS*Q6RFGE<feREi-zv~trocQj53;LEg4!qNm+
zN%9}}Tx(^QT$<RJcZ$YIO<3Urb4<Oi2J;y7R$zIQQv2@F6_`1KKm?(-PoJtOJbn6)
z;S?B2)BR&5<U6IAx=ao2weM4UP`mW1WpKY`=~6G!BPP!){Z<sxmuLFz(=7!T7aAjS
z$^dR1W~20%FP*OwcTiD-!5p%5oV$SvA7vv+dvIQ!Xcr9Sj?jH2zQ(&C*+&Oj;&(0G
zik~c8Z~6I#Mc{4t;J2&mU6+k|rX<AuS|WD1F>Zm;0U}V|b~b7_pECFz_-$@lez$j)
z@K?ngB|jDMvat*ASQ;LRoOU<ZR3}-#*;lg56qezp5!2f+(;2<KWV=*R^7#XLNR-=c
zZmC4euH>ca*%vbtV+FU2Rk9_$Cxi-Q@710%Tu*-cttjpVt1Om}4qt&%jeCAumm!jg
z{PUAw8*B%D!4oEDZa1oMsT+iku=0;23^vZzhn1i$05Ao$S}!O%Vv8xv4&(QI49Qst
zh!E{vFAd`lg9ez*ekxphIg;on*b+*(6CgMLfrtbe-1?{hHYusX5_I`xtsfB+6QPA{
zzlo=}r>Zp+pJ{u5A?o|&+D~xvqz8C3AbIipnG6Vj{+HcS5D%<ebe7k51A)k|o&OVn
zQq$>yMN)SKWm(ddizFoc50fZ_d4VMccUe96r%*>nD<^l*Q&%f<cPmR)Pg{2z)@KUJ
zYP!LcbRZBdUP0!u7VzqT)OTZAnZ++c;kRu|MqW(IM+YZMHwP;a7BcN@d&!CnyQsK6
z2`A<4j@Sx!G%|3AWY3L-d|E$asdzmu1@8nI$c;^DcU{R|H=Q?j3(U9X9Ik_E5rFLS
z7HL31fH1@$5G(LS00NPLK+?c3;9Z0o^sl!5!{dLL{9Dxj9RDNJf4BCp<pgg1A@Oe=
z|6>elkP5;7%WY5)V9ozr>^}lX1NZ*}d;NFEgDR(7FC`Q2t>st$+IV5o=6;Kg$E5ev
z4{W8MS5%~=TstN*)~DrrUqM5Ag2yK^=U&{M5Zq%A-==j8sX|;8_uf*Mjt=^a3%?f=
zc1-{}8##9J3KVpuw7D^vOLx9EO3Da+V6W?TcG{p-$S+Qx@0K4Q8X7t{sKmjkk+8yp
zV7(D_NBi*bWO{B!rF`mnf~7DM#L-d0S~R0X!aFnS84t&cxtR;?^rbvxAo`9pXcnAh
zzA15Ys{BX)#DMo^DY&|(=EJ9cXJIAl{P>3B2EnwUr{2v~+|?~D875Hhu~SHLR@%Va
zoCzf*r7QLjC*Ir^TR!P?jSo7TzW-a)L3hK3lSA~c4${EBCiGnIuYOnB)inVLf%qQ?
z!=+N4O*L?*TyCrrEUmDxkVZDPihIlnCh$lift+hVzo8<%O%jKQb)e=rr}*PH#gbEx
zhvjXR=>tjggSCM2IFx-#MuxKMKH3+YHsmgv0Z=I_;+K%f2n{{vevmO_R*|JDc`Qza
z7SBrd-dw#iNf(V1MGGcLx!(|ua%%SEM7IR8p_|<#lFE&SL&>?MPMdP>oh@f|9xk^T
z(#YP3lAA$!7?kRq-~!%|lCBTZ72d!epV*?u;f7$2%GL!+P~^{p=X7q%voN>gUuXd-
zDJj~XaVJ=HRaH6$e_G%^>^|!7Xm4S%`dtRhDcaTlF{u4*V&d>>?bO3nFdfe)M250{
zqOG9HVZj4{4J{p=+xjT9T8jS1*+$5_Oqhpi^0WF@R*;#@?6$-3gN%XEQ4I(L(!Dh4
zsZO)*(Zm@pR|kVtSMW-W>`e}-m!11^WPjhi(QOv6Mx|&OVBdxYCt5mM*VVz4cUgc8
zcK(as%dHB6#)_sL@+WT0zj0Kp9kY964}=)g;klKwJ{EOjbhle^wsR+ghTvzF=lnkn
zRVZplqXnF`6T?n$r!HAAkE!`v<p96GM6Q38KRW`~Wm}>h)7M_2f<Zyc-e(UqB6s6=
z%vt8^;hQH!1fZTA?tu@Ti$^!-os+A$0Rd5EZBI>1sX@FsA&ZYsLLR@dsOL<yO6fQY
zpnOAGn+%KI_5Qv|P6(14pWiHijSUQ|@N_QnYHMd4@o8%(EIKD=WSDq(c#O_(s_r+x
zbo=nPvzw^Zt_Zs6xjDtQd6o!_MMO?7aFLObQQy=MJ~??P1Niz`!*3@T^3+weR;CoB
z!K<2@#3Xxa4{l?&=LXiY=7)2isoo8kn=$r$R@3T?G*BTZn5Zsq9bWD+%?Et!S(Y|E
zJv}%$$b@y#(mv=c-Zd#tiaHqb+wGe5JKZhtK6UnAS}jdmHu$Yx57pFIN<+e82X84v
zK;c*a@!tCIP~L>yO@zw_tCZQ<*=E0E{<Jhzx3%pSWQ!XQOtL8}iUV;C4ES*B<co{F
zN9q8JC`Gy)9PHtWo{YcT59ODbRmq)}ubv)MvOf84!jNQ@0%S2fQ(|CaBLvy(&6O44
zDu6%z3E7_aOAUD}qP{ojvL{t`aKRI_zyW0PG<J2~wC&_48nf5`OTz%Ab4ZGvMj!^3
zrn_nk=Z)v)1NF8mBp=~tsoFnunv-C$fWCdJt79c)lD!!Sj4L)`0(s`;=n5!l@i!l`
zK;O(8wqWn!&RAnu0#e-8lK25jRlB&ux*~Gq^%Lg<z=7piC{&WZ>HOeK{15<Jk}i9b
z<pj}C|HZFmd(|jLle-}4p`#nD1v5%8D-#fb^z11NvAlZWPr3OY;`5)j+Hcv2Tu^#-
z>^7$F{gSWTwDEle9gk%|Yg$!_hPHNo{>*y%x@D0>!kxmR4LS)qbsB}Zjx*M#mf3x5
z$Q=d!MDN`fT*aRF1pIMN=erb`Q@8E!RM#;v9!w~P{^({YTRW*O7708vD$-)OdHEds
zzkGQDf#k>26!!m0a-@!ui@WdZi*tZF7EEpCDe^N>R@c>K3S_8EW{ShRbCUpEMG=}s
zPSO#BA{T~W@U<AU@xZ~RuItLiO7p>Fn!bU7qK1_)Q@+4hAM(^Fb!hdYxQTuu5Y{T?
zurxo|<3ae46%@)tN=n+`j}5pvH{Yvk-|{XQ=A`0tE-D$MvDC;P>v_Bo()MH46Kd&g
zB|^Tpmy(&H@C)@|SEu;p=QQ)&5qTJ5Xnb5N{M<pdFhojfW`AhHN{Nx)uxZvAN?zz~
z{5i$nI7g-vAeJ;WuQ$9h09~D_Ep9kFtQ{O4zAJKqX-OM`h-Rn&RJ65IGBbz2eDMQ7
z5yJZ&&XMJp8RnU(Itb+F)lKrAfDF&ShcbAs=>ul2E!K0cA#*_Y;o6tb1eP;nbsGFG
z+#I_*{~-K!lpGt%L#$MX3l|{O84}{Y8le@1^TXA6ZmgB2#p{_mlY->-Px2xfcDE4?
ze#e-UtSpuY3p*G>UtfP18+fKEYAtG8m+I}jIsJ9`f9L%3=hk~O_H=t`5p<)d;e74^
z!5bXdF<O94L_|b``#Nlz<+5wwK?eX6O&o)4M!yr-$x~=8aoEb%mQz4Lz`|v->0Y>d
z(=3fF8v=pQ*Gta&2^6DyQ|G?4@$nIzZEzCJ7}jIf%^m4Q8i6Co$wk~&2fv=<PHn66
z)>M^dyX}O7(3o8mw6m^Y#<n)K76>s)-*dmg)wGwfT%Pl1f>3`Tw{rE)`Hw>M^6vLw
z80zm2JjDf^)dQk!qTiqM`^%2=U$vD-Dd9OLJwn5Kjfc{p_FZv2Eob+U!cj#G6uI^i
z2LQN*dZJbTqO)HNR9Hzr5fJbn1%iI0V}}*j!P?1(q#39hGz*j>?F=y(H0(JN-#WNJ
z0AkxfAB-W^t*i@@0EjLsQaJ@afWBi8Kw&X4v32wThtFK2NdMo?9(VwaQG^2&nm3P*
z>B3gZs#^jVqoSfp%1f>7?R|3qU+4bK38i#~`t#oh$A+w@XJ?tSmS=ooeLc}DdvNI5
zNG``UDWIM-u^E^OJ3RoZ;l{MC>Dulx&luoiv8kc0EeD{^M&pEwicS_MyvnBrx=$dj
zM@vqUXGde=0rlrdH01KTcN$p^+gu++_V1V_>r|)Q@m@JSc3)c^wR;qU67H`W+}?IF
zY4uAP8Y*aT!<cN(H6$5k&BD9mQSZ`#YHaVnSpP_DXoV_+L?w5PQLMppQ-Nd!oRaBO
zFyioO+5wU;;O|f#IZ&kpWU)0o)9U5HW2d?11XZbql)wOY0Sr`fs3SZ5v-f8GG0W7+
zD>2Z{H6W9>{P)o1rvCdFthbdnXQ>AlHUzhYLRsx@y_hLQKSZOYxIOi<Qt{iQX8nu2
zAvoOD)|RE)o~@29%a37{Zv(E&&MB~2NCZ%l@4U#<kHmmG(WP_#9|8j3_fWMBHtao5
z0W38w+=y6`RsY020BuWan}Q!64wRHbA*enG09#r0-kVdP9$2gMi>c%3Lkga2plpaA
z#d}T1d;~vF5GdQ}41sdlBm4uz|3iHK)7AoYO*-M-j?;$q5}+NP;xX<8DmcH?yt2Md
zVbOg}O%%{~@lRwb#sRf9;%4r>@H>5Gf$wMMoKA3$;{aisy($wXn(+Pj)8)mlK##Lr
z^Siurl|NkVp8&fqQ%$+yW+u|50v~D@U8Z_-j{WB5w*&;n6vDNvjt7L^%CRXVw6p}&
z!Rp2~4>Z^rD8uv(4dE#&9QLZ2*2^OU0Iqrv@XGyeFm_fEYkNJIvXzqqt_Ifw*Eyff
zA?^nc*b4!SA4^%cbP9Ml1ld!&S<XEGgmu9bLb(;ey1KSn1%oApgoGel{iUeT&>zLM
zb25Oa94+Uf5(~`gl(piT{B}A_e{DB`tD39QLywP@;DdLL4->tLCq&1GDn@KRAy5!I
zyZgT#RD(b%DXXr0>37w6$h}ssiubs~_*LPY;_u#un5!*gU=zx{_G<;~hMJi$3d9;f
ztgYjjaM-ya2vCPO04l)TqN-|bZY~Lcq5%EYTD+<xyi*L$0Ri&!-9e~D+wea^nGtQ=
z?~9)A6+;`rSGbbg7QggU;mhuY<B!%Va7Sob*;t@6^=Qh_DNYDz%UbMsEV?IK)E&?o
zFe7#V1f4<&PdyQc%?CHyh4jLpj9O2zgK&6E7hf#`RZ_yehLgf`W(Z^m8V-rqA2_`D
zlk<6b)!wMuh~uFy@^ueu%|xpkQSmt22!KsjSC>)aK4OcCq@nG^41kH*YpYj&H_YlV
zu{5{mYgNF!lai8BS$|+mBilIZ6rK}{LZP_12med6C<u%e+eY9F73-4d;t?B5r?RxJ
z(9m=dH^|bt3;>uM+D~&X)Yu87+17T$%n_QX8iS!3z{+9gep|5qT(pZzXo3c&!X(cd
z_LB45vK1)NNLa>RHcD9e7$6mh1VlUV>^+a2zj_V`0>;ySN{Ih+06kTbRWG+-T=O>e
z1-N=;21d|WoZj*K-UHs=Ydix0yz<@v|BAD4YY&(SC~1Iz|0ocVKh3<}pP9X1q<0Fp
z(uY*EWdXhRgVj<Cznj0OgDVG^lXcX7RrS~aFdAxWa|8e%K;HoYP&gwaV;^&JO#<jb
zSANfH2R=>SyGydbh%$=C^eo}N=iEEL*xfBRIW<{bTPyKjrk2Tw(h{h{>iTN+*7kNZ
z+{Lk_x1|a5>v#>e_j4p37+pN3X0Md;Fu@XmYIv|!T)ua-n*{iHEMpVm;UNUn*`5F<
zZEf6+UGvnYm4&~6sh<m&CGgbtrj*e+60O$%?wx+_b{@DxoUFWfm5Qg8;+kF0{2JZd
zfRftd!35~*=?UgBZ5;#}S7d`Pk0%;APzv9+UhX^mI%Ej$0je=FHDmQxm<mzB$X-+i
zvgzPX$geadRoIw~(5Qouz*vf8oo=_4e*P3<sM;D{)p)`RhR*dDWFZHoq#9GO;H*_M
zHI?z^m&nr?d;bn*(9uO8lMh>uF;nG|Cs<r_Rr3d(rUYC^z~SLxm6rz}YSJ?agJDS&
zD^VQ^#1QeWI41++4lu-2H5>~T7gM>e9kw9PUOa+HnWUuyN+$nqDt`8)En;-gl8S9o
zy~|;ytH|TLLBLWDOtX%=IrlUYS77r)^PASbSgXk?aP^_3003L6$mRq4pk+f-;mXZZ
z2ke`qiy$?DR+8RAp)to4I%$v^7>_!v_a^ugcYht9|KjcB4~aj}|EFbV1%mr8x{<#h
zzgD(F)86MTdF1d3?_|3%YvDcE>6LDZ#l)N(0aq<r*6~n$j50OQ2`w_>@duu-K|A(G
zmqF<{L-^15yR4uf%?kAhU~rWl5(>NmI=vxD1hS~$!$Z+)F(=?mD#^VRV6)x!`{}dk
ziZ(p7xu29W4F*~uK1J$owjE;k0R2>sCh$Bh+GtuSR#0}n4A56)%axx|ZSDdFswW2?
zuiCpQ#^03_yh;Wk0d0suy!<TfME|7uLjCa#*2ol7toakuE5v_01<(Ol|9*T*Hfy~A
zvVeS0-NjCuw=;u;Wf{Riz!ot`Nfd@6_-&$O8c9-s*8*N(8%lIKv%Dun3UI!Akqq=X
z#sz;9ugW~nBT<)if^U`}Bm~K{^B`@qs3gS_y^b1U7RyM|B?B%}t9-*SuBo@&$F~u#
z6r8Qz>k-;;@jjp;1lhf$GaIM)RUveg``xCcF|6;$1Ca0%*=KC!?`@g(E0Wzj-s!oL
zLTOTwJWzsmKDl;vqzb+^ZA+agEsBL0<V>7~Qg^5bb8!#~5S9oBCbonz5QlZTl!8=$
z<@EkzK%0WsR0M>7Q|ny!zw-QFZT+^wKP>id#n9g=5&k8({(lbM|0~8pfMxzEcBFxY
ie~Z$8Xdt;=JP3;2X!7`I5(BURDafkGlsz$f^}hiA;Ukm)

delta 4495
zcmZu#c|4Ts+ka40D$5iibdC-oRJQDnNQp>_tYvBJ!eB5w&ab2F(uB}Z3K266vW}(9
zSh6*tF^0j+$u^e8KF0Ds-t+nW^M2kx@B4nP>%Nxn_1xd<B3WZpp2-OV{O&i*O#uM-
z1~j<E4vwK82+M$z{E`P1PWvbvm4*(aee4_%SAqfpyaEx>5&*7*cs)RPd7g>zL3p1r
zziwsYsp=&F0Af7XP5-n*jx3BtK6@A8(mELwVO>zAUZt*AMVXIzBGD!PAS2<{iMQ=%
z59nJEKJ%T-R63_tcH(^XyYofDf`x_TxLhSgyR)}?;tj=~8+ZPhWn9^PsWERX$6&fS
zssY|WGjhN8;?7)iRVbq0u;0iga|07O?$%PZGg~{pu~E#RK9%GFobP;pf}WJSi2fyF
zhW;rphrV$31iDPr3jIr70{v0s*nv3U!T~f{UK>3jD*oS1w5fs*I#$G#H|{s|q{t~q
zMhf~?08N#PL<=dL10PXGj`CEzQ^q8+1f}uH_6gGUCi9(Q9_Co#JX**t3wYtno92pZ
z-}k0$XWwhgU9`t_IKP#FeTuL9Xp<@^ICQziCJ~kyg8Fm`)}d4tT;`Z|Rmm%khX?4L
zc=Dy8uBb`xc(yL{QK|a+v_-~Ex81}Kw(s7)h@9OEN=?Y#Q3Ja({RG+mk-GWkt%>3f
z6__jP%!?O{rVj!?%I);IHf<NaS(<I-t}oVo@befQqKea2NOx#iw==0oZ(j|We3?Y^
z;;ZfiSEo+_KF*+DrO~{cQ0*YA*^!&Qx}i!lBC4!MO&$f#=ST-|kbX<+n>qQr!_Rs(
zNm>hEvl%KJ(3VgX;bh19ghcvk7;42D8eR-ml$X*}lRN|5#|J8gk!alTb_^zloE1p-
zvkjfK9HkG5*G8<F72Qn+b0pJ*(vP-3zAcB91`YtuSig{>&Bql2j5KU>7Hu6R4-0Z=
zQKWy2z5S}Zr@bKkD9J7DI4ORFATH*8Dv;09EC9S#OA@G+Nl}wV-MP`s*|Tn3DcWqR
z;4)V~)e_wT8nv*!*@VtGAP%?T!ir+lKi2M0TVF`<*R3jESIO=p=4q{VgbD<vaU-OY
zoGe^i9~lFW!n)0r=(S!T%6H=!{ttTx8fY_%7$pyh7f|;s)bzg%I`g$wjy&%o@kJj8
zNvVb+e1`z+ae+`0@=?DPKJ@U?PaK8CHt~`-)YcQ}P_7CtbWHo}tAEP*o({_<v8px4
z9?iK7t0K7q3p2yav||C(nSgFHH+iY(<)Yy{HPUC4VxUrZ`&Lc4_z_{?qg`|9@F}5r
z!xK%^?UQ@uUGbbv;y*>3o15{Q^F0n=$_@xyerJ0t^{Smz>Pz22kGcloj<TQGyR<=y
z3dNha3u*INN?V$rNu*#|iK#a}HdUvch5agD>v{=kKO3~0zSyKVqHZ6KG|*8O0g<zI
z+XKX+_ryz<4mlPiwy#c_eK$MX11>k@P3$dNV{ffVF;iXg?uLn(06fOv4V`Do?R<?w
zF66wu>EaG%t=duIm4Ua)4GXDuN-}EJMCQ-L&9y4G)FlTB%xJt(#dW+MU#g(UD-4vE
zS>^a|v+||HV@5##H<B&Ei+=3MjL!*o@?CHl7Noc89_*PO2Y<hA5-wm=I%sw_9VO3<
z=l^j)*3Utdnt;5&aSX&qXTT=)FX@P?>1`oVNQC#$`1W4O=XhVj!aV*mavs0gIb$<8
z7p8Xk3~=UmMw8Qehw_Mc#D{UNYJSp^A=`4mx`@j_{Xs`eaq4D2SQF9eFjvGr3Zes|
zBM40q=8UzuwW#g+SsW4fN>64@EGoY*<12zNw<*q8cnq3*G}KH05P0ni77_A>4a|mX
z3WRG|S6qh^zgt3!gdXiV*Tvdwo7|aGw?4yU&z6b^@SXwc8VK-}=HZ5f*%&Z##$j}z
zFlg6psmJ6GSG`{dg2#-vov)_Afir*u_xL|a>`<vK7;dAa4bE63fBvK{Txv%EH!TUv
zn=mlAT7RJxy55f_>u>OEvoto{DxE}ol7{VKZ`yjv2kP#cj%r8sedaj?{3s5B>XFr;
zCGQ9?t`Rm0-|D{D@}$G7=2p6_!HU;FD=%-{r&;M3Js55UyTTXj8{0Pli8+$jYfz(9
zYPL59{!oFDu8Pq@0=#i|*M86!62a;Az1~nhl`x#qevu7`i5QJlX_9rVdr~?|ipP|N
z&H&!`a1a2S{}$qM#sn3Po{j@vXO3n5`nvboS7$deWVm(z4k}C3b$cU&97?{%S(Y^h
zzEuXED^Hf@xK{!Wd;>eYP=)!9kI*sR99&;7k?l+US85WpwJ-d+7xpz`4>Czp7{GM#
z-v3?!LW`^)nSI1&=gOr$BW=CF2`EGr^EP<7?}s1mMdNML*ipUzs=)eJTJM=p6(5y^
z3>#YLJSnQO=Nvim8nOyo16*d}TmIEd_2jv5c0bV-L7`5S0>H68dq@O?WHP^Z9nYMM
zFZ+{E7^rS=*F}4C>Z8W~RiF<1d;$Q_{_d%`7wQ1ucRla7i4f1*rKa85cYXAvDB~j<
z9$C7}ANd3x@yGqRdmU-f@+{nYKO}VjFOfTficiHLyMAWEVoTf*{D3j=k-rbnc#h$j
zv1}w9Fb07~Ll~an++HaSs2V>szIgPoC6)((q8?KMGaM~3nrwRvU9aH**r5-$(oy99
znne-UJvt&<mUEBn&?*{Qs?{CBKOuEwAtTUq@V0Uzrdx+g_wBpn5HR@m<!g$)$GrGX
zuIBSzDV=E@*u+sldD`1cp1e%51f863pF36ehwb%Ed1{u$r=I4YqBkY)1oK0IQl6eS
z(d?7g7yOmGF2h&r$@6U9N{wd1^9<pn+y}$~_q}2sg#S)n9v`Ux{95G>a2At@k1uvt
zErJ>P*#7UifsS5|Hz&xA0=w5%bGF@2Ffq%mzz37D)OWV=gpcO~IuFRh8<)9i`b8aJ
zT?$}hSg#H`9GMnZI?VSv47+3{sXPt4X>kzB<TobtE~0;-XRHH;eJ8S7<NpqdiV3LC
zqSmS$u3a<vBEbt)@cYxL$Va|s$+{8Yt0aCQen&PioZ*Mbk%*XjZY3EOOFspLvb+v_
zRrk`Hv;R0P27_V~7MSZufvd^~TNnSXx|&~>B`pk<t<Q$FYm%=4_3dAv7ZZD~=(Mjr
zBmVD|3n-5VF5UCAZdf2|B~<<RAxK|!Vw8$ZuB26UU$MVoY;arn<A{U#1$j5Cx8K~&
zNvbDb(+^l($@CF8a0s~DCh*i+!F8IVwU{D9;XOa{4K&e|7aiTLF>p&6Q~71u4v`Qt
zx@kKZ=)XJdu0MI|90V9snOBmD)7@Q$@oNuP*njOl=3hFZ@04#*y&WLkWYuClK9n)9
zMK1Y@K7If)C)ZAC7bybgi7kiwjXrdZGvn6g;7z+*@X?_IO9Mg`<1f59V1Z2787P68
zF(6{q-}$9=tkJpw4VStr)?nV0gVLQ;d0AV|O5-~mgm=15`AK6IuVeq_xiDo6@U;3W
znak0`V$ZOnoI>I^iP$T*5?=giIkQp)OH^>*8cJ=<4F{hG(q>SaY|8!}r?yF*HYgu0
zj!`GhdnqY>u}<~-F^`u-lqo7?*%mAei!F@4G4JywnP<Z*nJvdc$C$C%iOJ+^hs_~x
z8lsdK3-ELm-!a*F`ss~@?e@-uIMYRGgFJ7Jvo1__G~8-np+lh71r{*txwpODJA6+7
zI0WR9O5p8`AoKox!8!VAS=!oiCr5Xp(%_P&<dwtlgM^AIwb+oIEU=jRR68svacR*q
z{OOm{um0N|J#~B#_<R2m=PyWyWm3&5xG^kkk_Y#AN1s34*!2ly(Ums1C@x~7#*bkG
z>p70R^1x+utYABZ`1DD?>E#_E-ngktL+?9;S~i_~)I$D~WnUdZ8sNH}j6l?x{R%<d
z-$XcDLXcA&5ZeHk3{MEyv$1iH>)l6NxKGZ>qwLt6xzWNx0m%C}wHFFZ%ye_j%$l}m
zXz*UX6qBjvCPT|*Ykj`D;#_`#_P!%p?Uf~gUgLbxuxjbiX;tjD#%J6)1QEV2owjSH
z|88bOEk7xw&f&lTz={>qR>I`Vb|n-Ruy-Jz1SteiHx@oXpXv6rk143B`N_b<G`dfC
zjeocEh}r18kMa_!B?k0NF{>c&^|;|?z6T5CAs&I-SV-wumrYAe-prkjUq)<qb-p%I
zbx3RJN3Q?o)B8NuwmG6hn`phh>c&o2qKGl*_)s>y?QyW@L0KU5jC~4CH;O6nBPb~d
zR1GuJZK}I@Q#ulPuXd%~#2gj7H`!UNp6s|+zida~Znxe@N4h>)qCgBNb;F-7_0$5B
z><BiyCI=brdg^OZPH*gLV_QCzx`NPe5@RXHSPE~_Z#J6L!0lywgbuLrY(cgfx{Zy9
zyfl?PGhHktBCt|aS058YXo!hHf!v10VT_teuPo&VfoJ<i`xrZ4g^QhmpH{K%a7)J|
zbKCnnN;&n)Tle%vmf7u#y=>-~6Qe<SyKK^6T7WSoepADmb_4>9GhK?s<q8pLTj8pl
z{`?O^jM-&ReV6={zbtfa-tFG+4DchUo*%4>PB;?OLQw6LmP-*}b%{EemX%De@n40n
z;PsqR3^=yV_TK5NBdo#~_wq|lV2M)3W#ojG@vs=egG6_hsh5^a-l_BwxB}C3tq9*#
zZIeokQhCT)yH@nOMXBYB@3S)y;les!44+O4_9&Heb#avC9$C0iDP8cYP9o@X<k`7y
z)Fk*_d(A6angs51hN%hz8iQ{~0A{^aDZg8HcSd&2<Q*fUNt^V65{63*jz&eD-{&<w
z6|M0gZ`_Bi$GN}V*BLX=l^73Y<Vcif;mUUMonN})$2G-M>sI~|XXa27vt(;a;PQ+#
zw3~B=Hk6x>Ju;Y6$*i;()kW!3jw{@#vP)7+5}>XmEq|{kX_t<VQfXfBvnE|Zx2fob
z3t2iR1xX{7+QoDVAR6Uu0$Xz=ME>H`#Z2Uw^-B(yL!54(H5xryrVewzc(8XT)h`ac
z$8CmNYR?68yVTmBs$v4`+0lC>aV8es-#)LDBIR5GG5;jL<b;BS+4S+zYK599@Q6yI
z?3JPVx`<W(QFYxD3b<c$oT6}A!?EE0bw7_A==7x=3mrOYN*SWE!)4pC6zFZffAYld
zCxaHoWLgFrW4Z#HoC2AGD{LW{II|hT`RpvYI95L(LKn6)Qmq~Ppsl78e#z=nK&GS0
zuBYdPSnd~N%W{Sy$P)*|4S|E+#0qIC20UtuiS27Hj;@l-#}WA;ye1|lvr9`e-q#Et
z^lhw+M{X1wu-n)2-hTY*;Z#9kG~-v;ixA0+dQ-XeG#}y>#-YQ{0+aQ0xr}JNXy%W!
z{2AByY2HEB8Zt0Y7itt!xeBTzIJ`Z3Cw4VclBT`kpIWdu3#R)eDRVtrp-Ktv@1)j6
z%=<f+^=kLNJOn{n;|)TNF}03GT17{U+Rdd%C1ddFEvwd5d8I1E?CD}=DYa{JBL}}(
zTS}HFRV$yx8$iv(0;Vb0$vlWqIe5|~;0AXze!u0}o;TIMtSMTMdpb?Ltm?Qoga@R-
zY|UlRZa!hG-rc|dq`Q-rEUhYj_<66nVrH7VF02S4pHzydF0#EydB3-DKAic9Bk>AH
z%;D5ucEKdWhC)s&T9fc!EpLO_E!(n>rSRJJDN+^~b|os>zhBJVNmX_yAbzH=+U&QT
z?{#9fYGWE2l=mIZO=3Tz46gdET-0z&e6uGmNx}74b!05t9kuK3UPkd4LqibzR(<pv
yc~xl6aOD3PC0s$5h}!(0@xuO|jKs&JU6`PN;pf)$wk${uaNX>tDc0ovfBpwA#Ot>J

diff --git a/Templates/BaseGame/game/tools/assetBrowser/art/levelIcon.png b/Templates/BaseGame/game/tools/assetBrowser/art/levelIcon.png
index 7fdb61d1b1cfd9e2af585bcded85a68824021509..d3a2f55e8486cdfbef4f7b1ffc0958c6bbf7ba4a 100644
GIT binary patch
literal 20009
zcmb@sby$>9*Ec#till)wC<;hOBQSIbf^;`Xm(n0PpoFxPh;&JJNuzW~4@eHu48l-D
z3=DH_e4h6`=lZVe{P+Da%;uhb@4aHLwSH@@9jT$FNP3(0HV6bFReC9}1p?s!Lmbd8
z0^sZ9-832mx*OuBW8kUv+UKFGyNj)Zv&}<KUss!lHt!s4L7;c@dtVI`>4g)+;cii)
zIP~eb{UKI-yL2Omm&XI;c`qNZC<~BVy-8xxwS6Ja3^KpQ|KWOlX)b(4RmD*eq1Dhd
zVYIHRK;v+f+du0h*~#*G>#U!%JwC`sJRs{O{ZQN1Y~=E?xfuP{Z6)N|E{Z#84MmO{
zdo1}Hp8W+Gq6LMoSScXsY<!m<?w?5?OK7Me#ZqVCryU-2rr7VHXJ@N{+0dWkfeu$3
zhT3JS^#`p5#q$K&{!uR?7fvH>1H)F<6r`>hB)L^b*fY6AB|E2_KF?uO#eJE^kbPc3
zBT~D&15S-0$$a>d@jlMlS5vc9woKO|7@v8lN>f0}{+K$_IU=5`{zNhXI-qqKfIa#?
z9Ul_(ayO|}YOxtLCI<Bhhzy_#JxGwmVwabY5>>EYlLqeoJP0fHF}6y9_?hF1zWBZe
zPk)XQVri~C=PeT^8T18%K9eXF94RL})2__e3LLbIV#zFME2_ttLw(4!j;ViHw7x3k
zo|Jf$DK==9EWc@w&WILoVi?=|eDYmx@n@kDbqwNSOX`mgPn){>$DV5%&dn6@l@aFK
zJ7>b&j~~0kWh&HzrGkP2e9Z)C%GJM!5ob*Nbh=e`RPp^NX?r9r<xHO^a{mkz`q5aQ
z^>G?W4=as@mBQD=D2f5K_pI9L%}*ZVYB|lT@TaImJLE+)3&S;ixmAVQ$#BD)LrpyL
zF)hL@gB*ogQbrIVL8r>XnfcNgGsVnj!pQ2GdeKs~Uq<zg+Av1X?Z3^bX8ybL{!D>!
zg8aqCgcuPtwUydi2#xR2-XOk*QLS@tsgU;W^Y_1AT$I-$9AD|1Tm8!PUOqW|YwQEJ
z8had}1=*OMipvV>OH0*iz4&bG(n|Zbb8U32ynPBiH3lE}+E({DOXVUAohB4l8btDl
zj1A_Y(5H3hZl!f>jOOpGy5EJ#>uJXsy$Rb<U%yzR)}0Sy5`MTpfpKOx``d9-^kP%m
z@b}c0C$WMaKeW%%(=J6_%x&I?NmQ{}RXsn+=~FqId!}n~DvG+lx(yW}4a71Ad95Nl
zun{CWTLjHMMiGlNg!0_&dUcvoXI#{w2d9SMaLHfp#=iYBUsP>l{o`d~Q39eat)Fbu
zb&BKCl(0FLTe4Pvh006I2f`X3$i934`?6{9#J|dGiqTa)-2s`|T-ssFRutm#!;XH<
z<L~fUY18&-WMYdDA9JP^H)yoOUq5%o^Rx2QX%qqPo_+9wJI$fBqiB4Ak7>S`W9_8%
zX4`J<aGncX=g_iQ%ZFjBq_!)<TDVenXR5BLA}fR-Kd1fYnDXswgqi}U5s!MqFzu3F
zsZHT8@lElq%mxmp>!qt^>r%Vlk>#^L583-_ntl=p&VPGka6QNsET{f;5XZ^Bxk|M5
z3AdViy6c_Ce_0y}X#4`7+JePKn&Mjtf8h6>Mt&3I2fy-3{pzq;ns3IDuTpAL)3;y&
zrSTKIZ<Ly&Y1FW*<k_x&Z$$$VY||C72&OnUShqyri1!&5EoC9CB|jYM6X_8*&8_ki
zENvCCUf8;Rxe|GMoyTv@w&$*fb4ULUaV4&epi0+FfU|tN_U1F<&mS!wbyqbz?$ufh
z-1D!b%aLqG`W2*38f3@aZ8-_dg}2iLi|j!RDNK`;UOIB+GVT9_Qzm$jVR-vfn)Nlo
zX4<<}eDVXLzi3=u&}zPS{prB+q2Sv+6~^0Hdxakkiah8d)2gHI3qhjAZD~dLOo(Dx
zanOU}KD@Ov1oeL`DlF`S!lJSaPUDQO&=Oa!7K&dZFHx$NnQ8Y)vQ)S$R3q;zN1Zyw
zR_^Rl+hjfZP^TyzbUHmhs!BpL0C^zMq|o4Lk-Ug+ZJ<)Q40Faoy8q47>Po4vvVXgE
z;{51Ldsrg!HpI&Rk*<iVoTT4z!TS;pigHFh1W16EkGfG^n68O-P>MR_!FXO;75Of#
zn5Wf=@l(0G+{bTps8vvbG6vVN()3w=OEC9u)yqTud1CD;ir#O}Hm2@JrM7-Y_MOwb
z69B8N_Gb2*6-nFrIVf9FRK;~Sb9x=5NKY+_tb=4!bdbC_0SP}B-L@?EhAfyDi}m`z
zPd`4(Xj%P5ylJ{TZ*#kkTw|vGwvCsAB;7sQ09U;o$3jH2s=i*vv&orzqzPMTp|+=o
zIJq?$FL;ZHs1#ET+dOX(7daRGQWJREK#vq{J#iv75Xt<a=`&F%=MhriEAuy(S-W^Z
zB9w@|u<n&HRg`c}mg87+(d0>e3pakJ=d$fgLU}oP=p(M2o-~qa7df(Z(w7-BI@Cmg
ze>R`^*{F0VW$S`9h@X0L&RG6hN7x9trn9)_gTy;pf(2K;W9vyf{0Xri$DX=LMEsP8
zcFO!td46?k)N~O|(dDkP5*Nk$gm}EIS{6ZF)=HzVpiU_p{*(A#unA{$<%h;cp~3PA
zqx^cg%!c$w+mM4%Qs<ZidKeKENNs<B+9(^e<{*YA|3vg%j?LfbN7PBw81==`?<>+S
z<)&?N8g8!wPwMG<1e92Ypt{LY_|GQ4Kv2#4`GkYaT2##VLRN0IIn><z@e_}n1m#|=
z{kfHrZd<k9hMV#tRP6=tB%8GE2aLo^Gs5N{jaz-f9|SR9WxmgnRC1D~+~OMZ3lTCR
zzpE!4Q{VYje@woXUKz9!cK+1JHd%s);r?E#O%d<V6dC2v>y|fEJakS^ak@Sbh;rVA
z{+1^By(k|u_c%INd69RO&@lLR_V`5L(@yI-g?HPR-!n>sB?dZU<=MbqpW=66^syxj
zwR9yKd+Z?+II#p20uyRxJ$G=vb4opNev;+IUj<pSFD#<nxi?o%RoPtb^!DegisF05
z_*Y=taE0O@(n+7F=Y9JZO3yBF#=qQ6G?`)k-O7MRrqJh?AIi=6%9Ldt^atchhT0}j
zJb#70MJHQ4aTPb-Q+4NdLu84x_OnL;MXp}X(p0>P{h>+wUj!dJ66+l`|G_mC8}-(3
z>OXii$dW<}OMKYGuTXeaA<s+nFnEVp^;L>2nP>ZMQM$q#T#BduV6o5ez>n(avgc${
z+0t8}nDzPngw<hzuVfz?o=$wU)@&agTyEjTdl|PR`Z`nQVxT1Olj01hO<1g0?u0ZT
zWJ#HDyQrCPzHi%UhGb4iKdJd^=S%WuIG)E$l}a}8O^!QalJ_#mxYa+1OCRUf{oUdY
zdGQgyn%GsJqKEgG#663`%!@`rRP8?7>38S3-{N1$d<-%nOkZ=nxsRxi*KY-*r6}a(
zT32y3N~c-*4gMf*<I;MQ;vIh$^VFBhNdXO7Nv{WB@xCd+F1P2o>#gkX;HT%zE^ClK
zeJuV}G?t?<o}V8#T*0hEbvgj*AXbk*H(+GX`fGCtRHHo~x?~Jin3(e)*O(@Imd-vn
zvSII{(XaZb!gJ>x9C|zPu3B$XSt;@Z-?#hKj)E^K4W-4Ie}b8<>$yB(nY~-&@VNIh
z{cJv=!?#wN_m6r?CVf8k65+5}48>Js>VHTLdE>JmZaG3_x0iRX{qeL=gF1`P;vEV(
zB5j*?I*oUaDPe8|>OG4Uty96G1=teGTjm+(1%=^?qS8`s%zxf+^NifCr|f4Nb9(PF
z@o+`;VbL6^_=Qc&2+3|{lkoc@CZbRZ+3*tP$4{wpviAukM1NObK_X29ZrzRASvjgo
zKl-Ursl+dUTcJ_Duf+^9lL)R61*vje)`)xxQ2j)k5<MO&(Ka~#cASypy~%?Je3Bkl
z+}teAlHv!!5u*j{IJpBK0=~&T3fVE4cRUK38&<TSrIGnqBx_z+6zwCQLFta8lxSn*
zZBF`<xTmi?%&nNo=dL`1^tX?<<4W08&?mZ!O`U$U=Y4&XpiMfK6@e^11LJ_C>#W4H
zZNa(IgYVT0!2**n+nhfMPzybIU_^^wZTc~?%KyV@@Kf30J*6Q7$j`?NFLS6Y=zkO4
ziP`+^N~@M$fZO}=)qTY$P9=rwd3PHQq}5y_#$r2j0i?QL;N%W{xiniJp#Co8*W1wp
z=g~i#ve7$v%kH5fAJN)!A0M%TiAdQ(Bi|jH7EL=Rh`vi*$^RPV!kKeepi$1=b>FNc
zNojR4U4j9OKu6bVZrQE;@F`1Jtcpym$^L8csdHZD-9@h-_xgvLCP7+|V(w?PVKwQn
zv{S|EY|9BDuC3mNn%BojNqQWV#Gz$BOJHFvYl0U4yP8G{x3kyDq1nL(KhlGJb~z02
zqi#KyY<6lcT2*|CRV?RcB|FoPee$}=C+O-ALAbgB(bCg>c>LKmz97TkZVzD(!IQ3$
z%5QICS6h$2h|5dA<L=KBDSA8;;8CMz%h#4di~08QPGV#`eu{xm%el1a?J%EDeNEn*
z?S#b=BxFuz(C?r-BJDVjO7@!rv%^G9Z)r14;rZs$^7>I_D*qq}-JFs<pfx?Ey&rqB
zRJ?3r9#6OCZ(VDv(-KeHL2BF)JNWTZ!t&y|y8k}uv)@xaG&JNtB*dsPAwP{{*aqzj
z!g%B!xe7qO)31ECUM8#14c`h6TADm_4hTMDhpukfNsR@LoHRv@Fv*3xSOt-!VJANQ
zDRa2K=GyZZSh3pl_iF#JsYLVi$*Pi2F2;U?ZGc->v;JjLSlmWILdZvB#^sIi1ogkh
z?)^T4fxo6Cx6+tu{+ykN`F)n`CzT=z=;ZFb=K5i#X$Y@c5i&dX%^QD-BR8QAQa52J
zB1lDU^NDuS^9E2QU2Cgk-7YGT{_L_BY_&-0-F@=-U?l7X=>}id(i!sHwi~i0RfU{>
zI*?Y0d>#CqPIPM@FZ%0{?90m9fMYLa3yqmu-mY76ulhS*$9A^k4!>!7FfQ|sz@pNb
zqk<DG6H_z9w<iCq@=xb(W9Yri??P>?UQ@h751%3u=aLvg9*#vaA`@$ZDApRb<0T=>
zlow5>bd7G!(8US8f)#Jo@yTC=Q}^PAUv*JBF-Az4h)FPSv)#7*qjKxDs!bHqg6rfR
z3i39>mz`rod8=!P{gRQ6mhdRd^)TZ%|8K&Y!;V1oo@-cV+o$=M%~B`dteP)p79VmV
z5S3SnGwbR;AB6Gf*?BqH#Iuv*-dNDVTxa{f{W;Dit-TW8NkO1J4kJ@&e(y1Q7q0wW
z;s5Lf?j7@)EF+QXkc*T%AA2BW8=7%35}wM9{IbW9H~fC#Ja0bW$vc~t;s}vA<N>;p
z=|S1nCL@)0{7@%;u3@yNuoXA)0m#!M{GrPNAsNT4&x5aGi6j?`iO=)aLj0Pk*|47<
zo)j|2Y7i@$1c=o*>s$Q^-k{xihuxxPTm8Gg-La(@5N)|YVSR20*AFhy46%ogzDWRm
zNy_VONWE-`iKx8)_a~D3YBlQQPsmzIqH`d1B8akj%tq}y59n?dear=QWWcspMg`TA
zxJ7=P&r%ZtA12Lw+e;Lg_3HnI3>5etX^&}{bh3&tdIel;&eR=XvL>lqNeaa8baxNE
z{`2X~kK)dppMCJWA>=3H+s?a0h01<lsh8t&HnL*M-6Uv*<mJ$mul1#Og*Bge*3_H)
zI-gRy4ZQ=~BAAH{z8?W`r+dB<ma_Czdr_TL=7esQZopdh`^2tTiP}S<sdGX_m^b9w
z#X6%UPpUOW(D32GcP^D_X7#Q#K30V7c&(slsr^qm*j>#x9ZQPL3c5Xe3L=xBXo}5^
zvACGg=WW7wNeHL%keOs|FvquD(&1Zw<R*Tr7MvfmfpXoQNqfFpu7)Th1|IJjUte2~
zsCi6KTvm?ky<pv*Mc0qC;abV%ZrUB^+4!GE;?oR#?LPU~-s9-BlPz^dEJZIpmtw=F
z4quM!&}4LQIWa|H;7J%J@I!%}yTiQljQGFvL%i+n#X5q0SdtMJIYu>+)qy`rVami0
zxGr(-9}n%Fv(73!%VWL#8Id9fcP8#YZla^Y)S(YjTrFk}9u5ohu4&^GzEv?rda^|J
z%4BXDv!D6$Mo9FY8wNAb&Y!g4v7KAf7)t4Xpdb7&UkGn}_oH6a4zKR2`HB8(0gj-j
z-F!ip(uWsh5X;nSw*lcQI|}<mydu5OHxS8t)dNiLzU5kOryq(8=EoF}5T4PsFhzDA
zW><N!KT-G-JlWwy8ux~cgNxCiKpKbG|MVwe<_7}>R@_=J{?GYGug7D@_U4jgqR<Ms
zq}yYInAe+!OD6D+Kzgog5xGp>T;vmaACpJI{C;lgdn^p%N98pN5s=m2;Zi|o5(d&c
z@0;}*o`p+2FMl;MK&=nDmR*o`<;^U|B@^pxuE_b-+Y}Y~f<U`tbpZ=)xrTZ@YzIxR
z{Dk6;uEjKDAFl0!K;SS3IXMj_Il2ESMgb+LjKBnmm)+9zz2?SFx*TNQ6mA0=nOq;4
zdNoT8@Q4d5#!Ej87MhP2JW_IVyKh2F7R05;V3OhG<w}Y7gPcNGnC%4>`yo^*_eBh0
zKjxhe((R1w;5mm1UkfYfg%C<doYmT+Om>B`eLI{<;A7Ot_}!ge5|jQ}3GsmT=mV}Z
z4`^JFs0(k`V~R08RpChCkNN4}`h2rRdX)220@TDSr|=`0nz==<`kL+QQtiS|R2;KJ
z<hkyP86Yh5CMj1PR;$a4laaq5Tpr7-<vNb#Uh3CBEzC@nJTf<Lts2PUDBb#`AxA^`
z<>Pp1qUFOEmwZ&%>OJ+uSIqh}G4#a6vLW`DKd>u4O$x6aCzWpZfw0jwfiXBCra6X9
z<w&bx$1G5X-HP&?%Q8}n)1(tWV`3&S?m}0umvPc*@GyhLw$eSXiO&Io?O`|vK??9>
zTmqMn4xyr^8A&y!U=pu}09<-{9IF>YW<I_?>UJ*JEC<vX?qGrY5SS6&4-^RrEMF<g
z1K;DI7W1I#C16D4`qIz?1R}n7^8tgtW>5nU2|blmUl48(5fBm*fM1Ec0v^$LzA*5V
zb9wW|=B+14&fVs<r;YVP9|uqShl)z78u}q*R3OkpkdnNN4p3!W^8G}=6}Wk^6(~@*
zU)e$KxhDCP;>oSVRd(ekU<!~!;^aW0LIg{6vdW<Qh+0g49MM9}ZcTswL3nrF>As^-
zO|8UZUt2+=;ab@y6|I67%1^uuR!Oz)%TTbn385>+;F$bUI@0P1`<$}UveHf_{Nh`Y
z#g#)Nm1h^2qd>TzA6kYD1gb7KAOnLycmVa%z~}$Q;1;k<@XcEP7X}nJ>j3nD{x1w3
z-mG;~4F10`kOr0k;RSErbp@oCgA4rgzsx=v+@b*4)NLi*7oi89b{$cl2MX^(1@XXu
zaB~U?ufKR4abn+O-lt{f%+Gs5BS&!~c_W8|v&>{qHMgx~61m=2YFQo}H2E=hf({k@
z3SR{k_(MTCx<O|brmP?f8Ys9YLwiWHAywAvzOwRGw6Y!X(JQqVWA<DR?73E*o*dkN
zr+1G(kuSjQhSgu<=S6ZwS(ZwHY482mY7x}K+qkX!8Y6x~;VgkWxe-E%al7&y-|WRd
zq1unW(#V2>AG|&}`A|96IesDACtF1cS7PASG0!c?9n1(<Q{C>^6Psp;WZzTVFfOyC
zb}augRT7|=4L!NTu&=h`%3rz`Qgp{kcikH_J`KmUT>R7{2{N!v94*PGF6Gf4A1@&a
zwCravx~E<y^;JjlNohTkCh+&#Udw6K;pP`wh)`~aiVQ=qhSHYEN01Rt6R6r*3pygo
zB3Cpjs}#6Kv(ywAq1U737%xv*lO=9tZN0v}PQwZRe0&(V;Imz)E?GI)HI>{jMB~N@
z5{W0rcUxLmE^B%sR?qxd$Dcxbgp*uoPD?XCtUS(^4Ry5sv4hV~)||^4A$1^HVj-fB
z2jYq+UQ*IzEBvXk*ZdyRSBr@3Nx6;lqMQwGkT#UqxkLSsv+%vNMB#VfH%D~^A=-Ce
z>$9R(iSfSdjZL-BF9{WMF8JFBp7AIy9#fua(S9uSR8{O;mhwysaybcQq?gQtGl>0=
zDHnJPwlLJeb_~Iw{<#JFgBg<UTW`JaG+$KkRPmqF?Tj#4t<#hhqhNRBQBJMirT+Xy
zr?N_e<AbSdO3A?m@VFvW9ZY}6XU4RmVlQxu;cCm$y1t=Zy|ZrL5#x-~Men`)imOZr
zDz-soYw8z1+o9uhI{8+`^>~nWP*{&|OkbU=B(8?U6lC#v%%@^nBG3uO5X*yZsNDHG
zi;y>3h(pc>c1MVO_XGta^s!7G9`W-Zjsmgn3-F9iNj`-;yCo7I5#2ufxx^ryfC`s(
zNfA#&T>`Ab(!_UQnAS1Vl!dDT0wK&X*;T~jls!YH!6q^#ygJjF$5$YWv~x!|WC_-(
zcV|}@)9`p^$`s>-f^~S&+v9*V(h=}cV@!4=*jtZkMXq%}hd9_~uL?rwWd}FH7oxth
z3-YNb61$v10MA5M0J}oNI{Aocu7}5P{iaMnEg*w%Nm`}t<qjc%VYDOr=0!`BODyn2
z2iq!hHF*~#jp}@8=L7yi9K3<J2k_1G3bwa}>eoWc!;Q$q!JuLn6tsgI<N>ax#{}ic
z346ghS)kgpIYCkrKZpRMLRDUG?c?xLfrfvHwT5$aig_^>#7qD~5imeZ2Ml}B0vf^Z
za(7RwX(?^@84SAC-D__d(ee4tTzwDN9Xe<V+QhMFJ{R5#R6c*@<HdF*js4ahe@_OG
z7r=NGahC~*i%OqG%$FPwWYMgL_3!~N`z*Zi1dktuufBP9#&~NN52S(NDJ8CEUXq~#
zJ*(op>(qSKWd?W|;Bm{%0`)D0ZCLZNGYXq4Hb95anww2?HlUp`Z<^0m+>D3-xm77p
z1qXu1hoZQho6jto@c~~1g9^2P{t^f4J=f)`U-Vx&O9FvPv87%&;?fh!7&~GFoZWv}
zlrDp0&}>Nn?z!|oJWF%>c^?TPLqGr(W3%`c+#sU~^EgKHNnen5@B3@_6A`xeAlF8m
ztxpK(U@5k_6_As3*+m#J>hE@BVcE5!`Zg75_1*uxzwn>;XCuftJyD&X<hD*wf4VaO
zCq8Zu!!G{g26nYG{V|JHQtK@Ha{Ay7W@q{qTQCSDsP|t5jz>xQ1a!vPupv&5fxjos
zYnP%2fQ~fF{&#QLAZ577bxUob<u9mSqt3K&TxTWEdXdP@G`=$I@qZXU>DqaW-ao`}
zgcg3q#K;;<`otq=af{+zyNE#2`TAH-aCJc2<+&4jv<5RY`w(xvJF&yVxpO)2N{CDl
z46?sMWOIW)r~5F#i?F`uRFITmojoD-4SsZX1T+_T+7D(0oV5;S3cu^f9e(gA5RI}!
z9Z&T?z!*tM1*&8RVGNgq13uy!SLH>?0n$eJfCcrb9@4<<R~#n&IFvc4M>)U3&8_=R
zs0g!Q+3_ciKC?NM&d3zQ6_@;^spEXMlNCTd`@f0ESOIc25m0X`X*(~l<Z+J`Z7jjp
zYCTc)+t$Aa?><}e=~sJc#debWu+o3QANAQ9aJPw$Rd`+{;&ssaPq2x<1!h_F6T%AW
z+tFbpgz<p1p(u607M7@pX#x+|!8_|A;X&Di68pg(c+x2IsT)HAB6zTkCT46Or<(aD
zq#NkLq)Y)dQ1-S9<A7*8(CQ*36+~sw7LfGX5byOp(D-i{R7DMN7j_-R`;oTg*E={M
z!1Abs&M(!JL)CUHiz`*kOdo3_;(F3c(M7~Jn8T!?z(YAz7G+J0kdi35M7A3<$mmQc
zqg=l3Gcuaqpc{*2gw*EHJuHNn1r=*|GQl7Qqf&kP2mh!%h3}USZag<=oceb_G$@$B
zYrnR0v?j*yu^S6UI;5di)!=dp|0Yy(Yhbcn=FF$jwckW<=)DQ@FLbb5+?RE#f``Bg
z!1=5mKy+Sw#!UQsp;QZ#{<-+ZVFcLEGI-vILK+1x{bxZEH3g79e&www0f4-RfRT0<
zmSP3?x^!AVI}c0E7wQz3k_-!pS$Z?IM<(zMhNK}FLO=>SSQrxL<x!00$no?Y`IM{y
zcHO7!N>mm~ghBAk3jk68s03ZbA<TLET_4B(Ma$M^dh+N49bN^tir3wV5b`U&tz>sK
zAg=3Emv)CK|3dUp;ElV(JLz!*Wl`DO$<w+e*HbA7c)bM*$$=%wybmeL<8-jL*5Q#n
zZo4)Y$g3i+_jo;hN$a^$QM5M7P7@xLnjyZW!>>RyW<P0U17x^L`FH|=&N)6p*!N`{
zD5D&i#!4T5<k<8*ig75(g`RdHGqfkdI6_$@F4uvs^riWvxwCQMdo2?RFUG5)vg=c=
z;?V%5H(_~`bMLPbwI>8<qw#5@&uNLo@v~r|G1l9ofWo<2j-nt%)_gh;<8l8+xZW}n
z{yR-(YGAOWxjR_QZiR`CZYtq};z?#dG-qtNO)a9aV)ea2-jB}5o(O=;^k>CB%w=&k
zF_P80WWD7@&IXgIjD7}>cfP9?SVr~X8p1i@A}n}0_|y`Zhf}fD*5HRb8QjC`4R7Dc
z>Z^vf1TMhl>tDC$H7?>Ga4cYrv^z}F*>8!Y5Mo^QdONWxfqtvI@F^;IjY52(rOB;V
z;^$`%qKx>`W>*eE_ZK?kmJ+^92I+J(aD?afMTuq(*`Y2JnI``1CzG+|Lm1!D^69;J
zO9-&3GpiUMv)%pe6<y<7Jr`(IfEDLGob<=HRLHN?)L6EXIVpu8l9h_s>jgA2eF0_R
z|30a$=SN+47-B3{P%v$3C~3{lV)iX*PolD4NM05jXTFA7vzAg)?|T3Poir;l&Rj3o
zld&*E{`k|{<gwlYNxxZqo&Zw}@-%R1U)!TK5i0hCJagGh11Ws_@v|%A-j!NBqPHk}
zD*Htr^*NpOfx6fY!u+7^TOq;sO?`i{@P~o&&cnPewJ|9^0WdeyXTh&yJE)N_l9%gi
zeifXB-4oK?S(=}X!S<FTVCimj5XUzpaxura-+U?yd;R6@{JXTq<tsfFZT5>gM$)!v
z(~x7;1ONR&=*$)?*$%N>W+L?!oy`BZhwH<b8)@R!6imt#9Q7y(9QO?V|Dd$Q+u>_b
zo9jEmQb&sP1cJ4*k2@F*rz((7GR^!C@llN8g$9c0SN8ID;n&KK%SK;!W$GSA(9+Ps
zoH_$kvoDuFpqt9_{Wuu5@SeX!F?p!%jF%K?Om<nT;TEyhW1=b$G0A6{U$R{I+t2F*
z*l98^;_Ll>DNA&^Wb;o*8;)_<vDn4PlJRYWKn)&0X)$|4+?a}}`Qz1l=z(FYmebSp
zddrQRyo8VCHAjePN)b3-C-QnF0=)|R;D;`Kq-KCidfkzvRVlvK3FRmX`9l==H_LyT
zCQ_FJEARp9JT*I+p0)fEKm);|AbZCqHS31mt%#GEAG-7J_Vg+Ynq@m`gwi>Afn_^8
z@{-apq>%G$e>hgyXMfT{T*ztI!GC$TyJYbXdnijRrMur7N1bfnRlYr-4G&QKYO6*^
zCBEG%pP*X<>A$LJ8VH$2iMdRyd`*ect>JY2K@=ohxneC??18+5cLqkFt&|!rHk6>J
zIO%G?X7Q<s#cg(Qa+LT8L0)A&j=tHRi`1B6o(h+$x3hzCRZfUj^^*ILi^wnKLi{tM
zBp9lxJMWIWm>dHvWu*d7BGBp)X4A;>j|iASpig9c>yh0`$8lIybMyWsJg8UCOJP;u
z3{zn^km9=OmzG9+fRNl^?r_i2{Xv`Zg%|_@bzO9Ra#~`2_7XiAMHcArBEmb4VYad}
zNQ-W^VuEtkWojIel44_~H}l=sg?vP)4(jZzQYDG4?PzqVx<<Y!6SQeT_+8CVzB<bE
zoUC$IiuSE)xIkX|1G`e?xu=bIf?FQDdBv(Yh%?&%JWCc*FdVMKktPIvIUfGr-F$?r
zi&$^4&xsI5?YPR)VkQJ22LtgNz06Upt4H}VzMp)yf`(sJ9(AhfUo}@3r)Dpd@j!Q5
z(LQu{(W4fMrVH)*o6&w_A+H;#qB!t2qU!9w1P0~qKHJM^iOwb9$FBg=CiVUK3d+NR
z`S%0($jh-=+^6unyz|vTv8Nr?`WN;&8Rq*q>mqDG^stlXG`{x!Ec<4J(o5t3fj%Zz
z2$1Ng)s|ZPU9rXnAK!*cl{#}5>9`cdAhU%I#Mr_($ghB$se8=|Jww$|j%{x(#@3do
zTQvqfhC;VbO19#+o96Yl8|f-%m$%M1=*W|gC2T5ml@wmkf;|FCl!!zdB6890FGyq6
zcJ3j+o5~$F9u-K9WzYTH%G1rdWpA@ili$D@ak5%g#bIptz~JE*0RLr_^f9|Tl4tq>
zp<3M*<<8&o1j*tQWA?K5WNDbtv&Tm85C)x`FyBv&J->aIPjsw!MRub*Q7txRJ1zT4
zrPBwYi(yJdZKGad_CK>^oEY;k&LHQwmyS=HoR-jDQ3ho~Wf2A+I)ZnfZDv4}H)gOm
zX3WNe>cE<q1{;dz)M9$-#w4mr-pQv0TZC`^<d>d48UF2~1;orMjmdFqJ-H$QW!24-
zY}$3Acf#r$sMA#VcvOjo{<3F73n3bXi00X?%A=9c*-{O_QOfo^{8&jRJb%4xuIX=_
z&ODQpluR5A$;zC>qGGFdV3Z7yPf<HxkPeg7Hq_3ej8~lG7c^f795y1|0*^*p1@Eh~
zH*^_dseaZ<17Q_E;89bAT6=Gzp5Bakr_-=5<X~L@5{Ryk3Mqm@FO6w8+bf@j(Kaa*
zsbUnT$>|v;_SBiC7M7c}orEj&E!xuvABr{~CGAi<b5lPb6JKX5(`92l>Dpf+HbX+)
z9(4hhsG4#c@;Nhu$d*u>FY`bm_Rh#So&kRFS3Rr2@sc_XEpr<<O84;j()ZU%Y77#U
z`q0z1>oMp%g(M<#!sjR3H9|{%e6@n9)-sdeu^G(PK4a#j7*n8bQ=5Mify-ivCj|42
zjS14P=1EL*H8omNMqMgwJic;J5M*`sw&G)9@@c+q$<<gzW_behjJ7`oECRWhKX!G%
zrz#&{Q?9vO#}Q>gfCKux7Pc{zgw=Xod}<=YU}cDsUv)fw9Oc)cRi@_%8+x=9Fzd}A
z;VCZ_cur_^IrNH_(SC~jIr(;^e0^d37=snf(&fQ$%iFDI^Jqe!EZxIShwi+gE+K*6
zf9LYY#4o-m<cF}9>y9S9w~_oka`q{Epq%YW*X5jQ7)J&K+AJT?sk~kwX7N(rJV_Aq
zDFXlw;^MaL^9{G#&L+FFRZ|GUneCIEJD8&#D#7!;?CmTad2)EIS$uuNOt+_Zj9oo&
zH^plSrSCM1b?<~g7B<q|z5F^dZ^P^FnTB$AHD`X)DV&-XNYS4iNCu#2;Z@G$sj!eQ
zM`(#BIB!N<kphM}Tdu%fjY~Ol9Hdlm5zz}R5=yUGQi4jk5ksvouM}C7-4U(0Q0@Xx
zrxruP7t0jIN;N5O80{b}C)|i-)s3{$wB*<98(od3C70P*Qx$~au!OiBSLQsEd(gCH
z{<J9<iKE)LnY?~mRh{~D+zZ8x)><JAc5(e}-P8196VHw*!F9&i_OL`fl?_2pM_KZ#
zp(R8#OY#BEg{})G+uz9G!7af1`j%nI;mvlocR!bqT-nZaJ#VjH9vV1{dGFb}+<572
z>O0i{IT&(6To)C22JQrtz1^O$+VwjzDe&c9sJO`6$6SCb7`eCKAQwGm@T4xkS@D@S
zl++oG4hM2~UF=^<Rr|-It%z7K7OW<)qfcLkyyy(d3Ydz8@9J+ED0F+;0iIX~YgdXb
zMs3Uq&o(Pesqcxka#F<iP1og_>n{dW%)Buv3Yo~z!%lg$*g9*yR+J^A6S;K~p~eLF
z*YVGS<cRsanI#ol{`MpH#}HrjQF(Ldk4WyWG@eS@x2GQLrl8E7mGMk41CaM-YhxCM
zs5bC9mv$<H6Jn0nhaFveg9!-Go|w_5-IcP-h8=&YX^DGQe#JjFiJoMf9Hz$EuMziq
zEma!VquQCiK;Oe(=%sstZ6(%=bUKi52|)il?7-1hzDRi!q+9gE{8;MQr<<T0jDVvz
zijExqkejFN-~MfQW)Qeml3%7xS2bTwiHkw_uCgp${gm<gmJdme;hqx@k)CvE_tfb`
zpO?+oT(~ct?n@Z?&k?*R2TsRfI`Q&W5pnhSKX}akKu9EQYJ8AL!qtZXdFf#$O_<}>
zL1AD!MGM0QFo3O|uswFlC_i3TT$`_U_%P#aQj{MN=eQuigJ3X+nsqKtS11af!o0G&
zF5_YmeQah^HmNR?q@98B^IGiq0!a)!?W;w^y!}GYcZr~!93QYQe@l>o*k}nJtB@it
zQ_wiLxR-FHdAmXn!}Fa}!%*VWTXm;jHoKm^s<ZYUrE+vx=&(k55!Tt1=@43iki9j-
zz@voJ`p0u+49NL>&Z<s@L4yF>DH`LHsBA}%(-r9cy=%!DrzQfcl+0`Ksvsb2`<a<7
z6`2%V;q|{4;sA2B8{P5L&O_`_!2$|0f|XvovktHpp_Vt+I$}ZBZCRL6^^*$Ibd-ia
zYLlofkiSSmeNWqEa4IVv`ZBX5*>d8GxYf{E)-LaHfT%YZ(LOh3IYyk08$u=>OUO6@
zw*QEb+9(*+D(;}w#Zn<|jkFhaalGkxTUH5qUP#x0eV@p#PDsV4zVg*X=1d|`W47ZU
zd^zYC)w0%pRxFXAGZH_-wOeL>>3ad33|35-n#7d)xtLJyp1!lL-IK;`wkz0bc`_RT
z?Hhwm1%LD3WdVX3qdY!fcTX^&yW1|yk^OI<|4cnDA1e3HYlLBYJ@MOyvT$aX-9I#%
zbgGJ}XHB*;2Fj`{xTE*K1+}mG6Z`E6^=fn;4O=0k_$ujm;CU6u7A@0E2CBs$Rar3G
zGH>u`I}$FHGSzhuD(O8Yfyf~Hl0x|)_9yk@F(Z~X>A;Cl$rh`k8`S@mL|oOdEF+-@
zH$xgE%^4udCR^mmr=$O^jnv6!qj`6u(4`dH^)5^4L(LBv6!bvfYwhq}%jHGt$;!YT
zjH_yD(Ea$43!~jA7E=#LSvvCg?XMw^mOT4S5spsUBjmR8zxue|OkJpw7x?C(vhIBH
zRNE_@Bfpr-zqa?C%<hy=y5{yItrexX1+w>5+DhgQLkvEchWcrp!To)F$FQ{fKZ2A@
zLv|$aV_@Ubo#@L;PdS6hKi!Ha`GHm2JBP0sloSLXpeQ-R9mm$aHfoeiYuxgm!;igD
z^-Y|c7q>ZdI~{^$ieRlEI|)sGbFDFJz0ROZZ<OLaW&DJrW(_OS>$+Buo}T7zlcxwS
z*n$Y&rmfkt&4P8W6yHC~7xOOVF*1wZo9lBJ&Z5HutZI<GT8~bzYO*v%&d<(ZQl}>8
zJtsVqG)DL5G38+Zeu^*ta(NmiR>!5$k*dpQBQ^zyfQ_=6JCPZX_r<GbuHRaxb2_i5
z(s6z3ei~jH=<QfLvu4;_Ab#GhqsK8pq#pn6$9TutOw&bX8%8e$r_7xc$T-D_TW!#l
zeMBXn;1qr+_RA*%GDg~uEHFCNrwsBbCpa(KciJ!MklMO$**cqvKXE>#43BC#YIf`k
z-Wg_p05RNJx4yr#uko5A-?AoWyg5y311o4tQr-8oI%`r!zO&IT6;kBx$ocucj~d^W
zEh|6ntK1TOusjQ8nr7=0^U*s1OjK*X$P4e|N5}4o2~oV_*irm!&(`>gMr3TxVVw42
zX7uVX=2?{mZ{rUs_1%hFKyiVY-7ePbOkyt@AMM6GE|u*kmw$QcR7jNkvPr4V+lcoS
zFU@g)$wszXqK6ubDCN(@te_nm)xO7Hj{u0OnT6!xvU$}1sLQep3)BHx-v1uykuu(j
zghrF%)UlCvTwt9N$Hpx^!2AkBBW?siw8SS<Urq|AI;St8N6E|W8;+!vv^tQ?tmbDH
zsl2yFNUkcyuOdcE)-!I0y;oQk$%PF*-}6yh%bIZLmH>R(_jQixBHVEe7&MQcb3yPO
zO3FpwVkX<x|7_U7r%O8vcIL0`CoYwD$Rw3d8KhD&dRiAJ-wwfXVLU0!%ZTEh?wL+D
zo4X{IK*NyRQ2C-0IDwWQAL9hx2dQn4NlO;*dTKGa3~JR=uhIhYI=1YYjW#AYAy2wQ
zbwJP4t~VNl?Oiu=EEDX1iQ!D)LJernUyZVR=DJ_Bg{zY~A+@Duh4;R9G&d?nG`g%X
zzrYQ05y#{>^$B;B-goSwwVBh%uY>{37_XF!aCiI)rmXQ!zl92;RD1oF+C%j^J#2*q
zI><wk%c1<!l#_NodgNZbgSozPM1Dwk`wTX4E|CW@3m@2SpEarKxb7&Gi1O`l>|B@K
zI1-IjRY7cIOO{n_sUZkIIAFww?n{k>K`^Opoau_k2mWOXCrygkvxGr{rDrCnnNm-@
z(TdaIvr{=$HI*Hd`TkVAnXe(ViK7Hb-uJ}IgYP{V;Lb~-<M;-MxGq97CYXO!vl^#<
zRZDSPS2L``Lkp-qwP;x7uc3E_{ZYLoYkt*iy`hr--BQp<afMviYxh-m)i$maHgdUc
zuO%%``T{IlSzCBq9s*Y-3_i*+pG@<=9Ao%hHOAzxYObp232`W}rlVrm1{9rxW&@4m
zfB(HZ<g>v7Mg6_i<^r$YU-Ar_d23W9&&*v_`y**0Ekw#wEjJ_Tb+Is6XD-&=zDhE?
z-mlv|<pUY0___ord2;#P)K*j&7Pfd40x*Z0l7XU79qelQ*p6wcX|7kgFvl%s0b~7$
zQHS#$r9d0(D|A%$Y`j&-^rqYEkpGCF6sS?czJJsD2eI=tCdrc~SVYw@xl^T<N~Q@P
z0dW0@1Xa(8pgud1xdBN!Kq<Ra>f9$(Z7D1fUF(aAv-3jbPC+I!r}h02{_2=7LXZcC
zEMZy(bF7g+n1=Dlaeua%&vXo_Upet4PfMgt-5~W-<qa2AkNvc!49j4l&2lz;Z}rV-
zv#0Ddkc(1ex4kX-b$eJ|IBT7ehouR58;Z5vX>DWvVv-%xA93b*`R=ne;XhRv<r4D-
zj!A6{rC_55+w`(B#&KJ{ogRMG$!j&AZQFPT@m?=RcU}~GZwdHqe@6KgJnP^ZGi`IX
zYP9cprZ%lIB}tsKBx)1;#}FiR_46%E0-I_~Vt}y28_7DDH6;=H#BL8OaSL3HTcV9A
zOpcSMJjUsLFU^pdIq!~nPD(~vyn9IHIknvFj(OwvhURZ+s<)bP9sZjE%5}s1M82Uz
z3;_hFv?>btfGypX!*U_VFHrGzp72u!z-^|GF-IAgn{9No>ibsh&Q!vp;O9AU^pL#$
zs{WJpOW?kM-OXJ9sCsME+~>Vpi;x6Z+*Z8(f=&AUxoSP^-bIn_U*4e?xEn)b72k+~
zsxm?!<ALmK00atg;_kA`dZ&^<A$@O#V@oN-QD9(X<eWV7rmn5B0TbdcTz+Z7E~U}q
zcNCMh!z!B6glHH|Vv2RbpuLPxRmj<E{nL_Tpg75`JuM8caU0Yl)p_Nz?b%<WxpXlf
z%H0{1u6I3byxyA+Nf|5lw^q(Slm<GxfB6@_6WuhJ^6^_hTgzw2>>&q>cd|^aTZ~=`
zmQhCLGZ}%LgCn=O_!HeWD*T1pZIaMZb5)NC<BQjf<F_04i#yzYIZ9ADWK~tGZF%mN
z5VfOvg+2G8Qd+LQrB8bqr{*OTm-BIi<!1crh6Zj%#5*vra$3b6W$9`HI0k4uNqx;B
z=DqBI>hl4?FXzV}C5ivR{x@a%tu#e`eTr>Iqy{8&CVW_UCuPfgvJ@F)?myeOo2!bM
zrxV;)kZ{Q!*=gJ&+Z{4!t^EEroxtV0T%^3ojDfGf0tKBRXK%aoQo{EZg(5*la=}0T
zL$vwj&x+p40+oJ1*WErhs0WHYWkAHUz%~`{>-;P*9JtKNe_Xv$%31He$H5@_PG0|d
z&B`yxrZ)Gzw99t=@$X{qHdifucu>Ax2lhcjVd7D2h4=^Qx-1#qV|L1hEFfs_cW%AK
zY(-paYKK&nKT{{5w}Il^bPD1X_Hi<h9Z>ZrmC5GIZpgn&XH?V{n>)AYA+8$264&=6
zD1Y%dP<;1dF58omD*iR`+%)h~mG=7^jfs~9CVS~ec9KZ#Td@gt6?e^YI_zbcmTI)K
z1CQKP39`PG+sHor$JClPm^%OtPj5y-2eV(t#dWnbI5k+hhE<BWDbEHSzs8hLO<|jS
z!{T6n{zy#SLpMtKn=CZK3t&twFLpfB0o+SY3n`ixJ`Q-!ncrmuv`pF)zC-%?Y0bW=
zyUR;--1~ZB2%6F*7{e*vKeQgh&gcyTHVC9P+FTB<990c$eJAN+J`TKDUtvnMx~*|Q
zz|Q4_R^}1w-g*V`T*=A0_@R!nep1xg5ul+h^xf4ZeZcWdAi`@6t!mWiRp*EH+c4(r
ztS$Y)Z84s`dmK7iGQOhjj>izpqWkIo+Lb0IKeq)`hrB$~ow+ps8;C9S##76hL}Aar
z1Z8mSxIE{Pymb<;=EJ}+aal+7rsb4_bg^2oL#U4RBt;5d7;ck)#6O@Al=#?4acUp$
zsgkeNy3*fd-7rM9DfY8IN%84^@DxLVr${@@MU7KU)&7#w7)BEb0K=3)mv0K$_AS56
z$Z%&2UWl8QG$ucP(`w?P)Ub<&E&~~-ro>Wa%QiBmNp<67p(<l0yL>6{%+#ymx#{5p
zFVA{TONom{{+cm0>{ah|B^PEt7PxLw3cYda#I#pM$V(r}SBSB7Azty4_$3b?-Th0R
z#>Xo(WerZVjuySa%YKODW%K|!YNJ6Zu<0=$(y8K>+>)E84l){LKb$gKvehzr6fD)x
z6{KBsEYP<porBAJiF*^i`nB}ZUT;7UJSl>JliWBcVEpZSbMInfrc<9WRMk{!DP0UF
zgsHgVS>bTy?{Yd59T)$dPs-d?p?3HA6!?^I3pLW~@G-6W{U;@HkJ^29h5Uy5ND(ht
zDI0>C=bIGzRFJPV%HXl0qhn>4$<gOSzItIpbvWny-L?B5UYc+O(<?as0QF8`S8C)d
zpFS<%76xZJMuq3X_~%&34u!^?<!^&GCarpMA8=cIEw!wY?hS1W!=K3X=<_G&%+4g=
zohW{<+$+WKM5k!Xeg9%7t_LRc^M*e_dV&U27V}DDj^eH@oc8+q#_0k6-?YpST~@ZN
zJ2bvCPge<*d)E-kO=VSeuL3hO5pR$hcFZO6Pf9=PJDe>DK*zX#%(1JJ2>u_{)q{Fz
zuJ8>C4U9I12hJUwR`$OTS;)O6D@yTX-D8YBdu&*Au(=OCGNWU=cLTO5j{|xG&E2Fl
zMvf^_;`k}C{(tY1T-mk5MV}KQ=*EhHQX9W#lxR`#D;hkIi8E@f68f~M|JTTV@Y%9!
zehZt2V-*Q+2lt!cixcUbi9sbwQ-fvy9B_Ah1<8RK3&}fyg_GwBvzD8Iqcx)AmU6Vx
zfD<bM8m6v#R2HUKY26mkr9@fh<-|RXa2C<ok9RC)wzAjM<=Xp|`<WdvY0oms?o0x~
z2POrR;#(;PYErl(g=kr*N(33b&P3QoCR$`XdRuQKu<YA2l9ZgAI8}VD84Jt<Ky&Il
zzBcMZRHptZNBWqMCsmGv+`PP6=0zTmtx%i(YlOx-dV`gt+wNbNOO+->619MI$sDGJ
zaa#F(3!`)I<|ZNKZvov*9c-~0)k8y*MdmuInQdgyN$71-Nva&tQBBc;7ZpWu4@+;l
zy_h04Skkknrngf(>5c#SP7W{dWY}b$IVxWN+ZSSu3W1)R@+sg{{XD^yBCd`TRbn;;
zE`I~#nnAh{MJ{6CmKLy;FV)IppQVyF&Al$qFZ(&QA-+fVO@o28fLay~h`aQrSsjaD
zBL0ihBVi6S@x0sK6>yja^I-q>kKh;UQRNVbiM$6cQdL}A{TCH@scT@YI>6s1@ecyL
z2>2up%CNG?F9Y0YFYMY^?@b(?L#|&<KDaj`;XN)tmETV04o3{F-vsjgml+7AEhe*=
z1efx=K{+7?TF|<SzEV%%I)+9&ckpYEhZG>!NB>7o+XMuZyc9(C7Up#&xQ{l!%TM`T
z2zqJ{oopPSI%pD1>jVBxe+v(!qL1a%&pMwqd|Kinu5I@G{=a58NBkxJCNa1Jb^kaZ
z5M8@lI*ETite<7eElt`2awfyW0oi7>{;l%h$_G$}l9Yx;1y_UAgZns7#;AMq_%J2W
zJZK?o_P&S*xYRr7-##On|I;)F44atAI%dcNhw-;-N}?{c_H}oSIWJX?(N@H-5NS|X
z01Vqae9d(a>zeQ(Mo3{$UKV<<@fjM`kxT+`+z<>nsfQp7FidLr+I8@Q%0|#})^L-f
z&G+*=8)xL={U*Vs1cJ{AalpZd>}OETd}@mrO|HAJ?6Sa#s?)QQk7R8v+1%18xU@iF
z1~>@nsQ9m>{65ZYCc^7c(LukU&?Cwlb&%BD)Cz9UaIpi`!?c&%>Q`AWI_LH0^B`B~
zN5Cn)ZU0XYH)i3ujQ{=5(X)Ah1mhE@>pzh<+<Z0#{g(&?6AU;f%$k9a4tIbA@*Qdq
zu;Vno#f{!>K)z-Ych|h?E~;{3B+onvIES%z|L@8R_%B)SqVwatqJxA0vM&Bs|1Viy
zR2JPEsXI$n(NL2EY@bOmB8%yNw`}-}gEupkePY(Qt$*nV`KEt%{hnKzvh_dOgGmwI
z7TUuhsW2=#i{S}+(Zv+o_HD3)9bijR>c5+7Bymdva$`DkHaaN_tdOY0RQ=5-*62O%
zzLCEM23M$pU*E-`%)H{KNwB&)qxB1E$}#f)2$g)go|wWw9h<A{0R{lC?Egm`OvScT
z7WTiCF`JQtFFH4w82!^I!9oa}|MDdbR8VSO>R=r=Hk7&CN3NBPbt1^Cd4Q$K{%7e%
z;%dKcBg~JEDL`FV)V3LrJ&I1?7Y~VA{zs%CM&4kY-5ty<yx`i^?ZYXcGrzTQ&9Ko(
zoCf7bu{Vb-2TkZWhrhkEGt(*2cHRtvLwuzl<wJG<S3Vkb|F~~Yb%A{jaMP?h4Hd0x
zrr^tIc@%3C@*nnTEc7bP3dtGiji+}5S@u0NoLoQu^A9koo3||_+OaL^US5@5j~uE$
z_1(Cg;_HyF-e5ofR@C4u4^X$>;1|#r()ZDQOgoG-aRs($F3<sDlNHs&2a$+Vrz#j>
ze4NQ-SwO2#bj+Wj%0U`S!-wEtIcXI6bUCp_g<hp$p?X6_+cr^%vGw%AET<F6qa3}h
zk2WDU03BCo8$3|DXuIs)-GHvkfBWN+MMYB9;t|=4@{~+3IuLMwq?+p!aBT~k!-^ZD
zpXPiT*XoUMQOTC<z^=E=UN&{BNqF>D013LdRmru}628b-t#r%3%VoIHv=%XZN3pt#
z$6gySV-(@+QmG3=g5>o)k!dEU{i}}R1-4o=6I)@bU*k4|ag|oUCi)w?s^8FW>Sl>y
ztAIa1jKpmq1BxnH<(63!D?q^w?eFDbpjE=Zuvo@LcM_W-wRCECP_=fEmQVaC#*ynF
zxgjem@pcBuO}a(MZS$$7Z-nFoxWhOZUtDp-wxbAmD*TxwyCF*U+0(l>&h6t(3LSzV
z6;PN_(Py$_GqC!GCFKH)#?K??@LdiOTziJv=FLSwO~pNi;BcBJCD$RFbk5&|^U^T=
zyywEwB32#`ais5&ChA~88if>Ho6>l}--tlZ&;h)qP|&NX8w0)xbzrUqZcsYz9Z<DA
z4Ej^)4KV$4De=v8&~zs{evq9q95F%#laN7?TR2$$o2k+N1MZ{6?5Rv8=Vfz*piR^A
zd7_3Q&)GKxd1P@*8&h-0Pz8gkr*Un|lpsZ(>^ka=IoDH3E!gE&;4Ua-g$|Z05vRJq
zH249)=4daCGv4$=D(jIHwrj5k$^c|YPKC?g1N^=CFs>#*#0@c?AX<UudX3ASMH^_Q
z6%9&ZRT&+E!x(YfVo>%UO|)*~&IuBrP2*Flh7PWHIsEG6N5Q{BZh>N1=b3*T%cfr&
zuwH`=CjY}L?T9t8POmc>H^=ZMAjpI4snZ@%Q_USwNl$qKQS#+Yo))}8gKOkwxZ*xD
zJq(Ig6_?h+;MzBGgNAW-fW8G&S1k#ci}=aE;n9DFf<4mnq5fdtaM<tP%)7auNLcOM
z3i_XU?tgJI><lgPfvcN2FK>Pfe$f{!{EWDO_+MriJcGoceon}IvnJ@q0Xx>ZMcx<;
zD0TiuU;hqIHJ98!j)BJ(zTv>6f782wr2!uV&KXS+f=Ph{)u{e)@0H;A{!;lyr@B-*
zO2WWg!8C&pgn-$AhWQ9?Ua*+U2WX_f@f`A?;$hG$U^mrqV7Ht;dPPyZo73~_Mrae@
zVuvtQ;Kx{696)XVLeKvaFzxuM5MTz#^#0L65Jd_J2c*?Ccf$lTNJsav8htJ>LA2$c
zDC!}={$Iohs=2CV`k#>ju@E#}OWai}4FT!GULN0^N{bE(;C~!x$}m#?f}5pqWd8{i
z#t(aF#qs~NZ}!npXJH(_^J4PasBPC`Y068n-i->q45btDHVq*%u^4GJQQiuJjXlMo
zK~&Rtr(}eb*veSRk%S_JN(q%}GBq>}W}j*I|Lu?d*gy7<-}(K{`Tg$i`QGQ=bI-lc
z^Le0wQJJg(mXfzjlkP1uethc7icrfqrKi0!)k##yq-x5(t5#xigOd+p<dKV>ekJY4
zD$4-cEME3TmvAl2hvbj2luPou?VKHk2VWaO0O(7y5?~0>c$K2Y@0BAV^3<rn)?l2|
zEX(DOlg-u_XFWcg_4gj-so5M31`A6Ghsh4q*OPsAsckv&^jU3D$5NQ3N5X@ZQ^A@n
z1VU-^l$uXM`1q`t4KRE2e#v4{2OAQ;iXmW)-yV%=){k;hb2?@_16KX`R3o{MdU|c{
zfRO=a2dH4~#}whHsjn0<&-=4xrmKe(9rW6=6J9HzOwV~q%{|O&>+(x-3G_iNCy9r{
z1~;yG!vbb>Wf04JYqBU;s536;-)A>XZNiP(_JIXXC9W1f#yiBG<N%{~Ctk=a7s8x8
zh^;Q;4+&%Tc6LU&o{U3yme{C0r_^32FT<nH62SZK+uVye_STMmb*Pr<S|gnIk#7^m
zRD}XSx5CP^`@os;z(3PY)LYz+-5OL!35b8WXMXDNJ6LeL{84!5yKoGeQ2*>7_sKM^
zII^4#?ARBQf6c?<j8Gs?9JH5gM+{vD$D9XyWd#9RgPljb6fPdgH#7|3n%CE`5$s}_
z5q+kPisQ6MAi+Gw+ON4zT+(ptu=-)zDvWpRCj%@$#qdLOG$zAhD<F4T`;WhBNtAj#
zP8yCDZ3)~<EIH;|Sk6MsWMx&GN<Z&@#)`@uarMH~?DBzW?wU+I*P>zs4v`m)ODmVZ
zxFvEZ*sYQsE#nmk7I6Sx4w#?pOOF;%Z!0aMUBQ|xr<Wj<yJ$hk9OKZK#rjTi3Dd3V
zWT;Gt-L-xHO&uARRyyy77-_1#K8EK@-KjPKw8Irej5=LS8}*JoaxCjqmboI&<L)e3
zgLu1<hI6ajK#;}<F6QeMa8=jom$E0r?)ieOrFE1Oy`AeKq&U9V7Q?orKGATA^U8T(
z7?h!}KBs`XmtnVNdfatXA2WDgT^$sohpuM3j|UIPsgGym@<!GMzh8yOZt~f>LAh3J
z!R;P2^N0u>fYtRp$;Y$^<vBb{pNI_&cnE|>Vp0m?A61sYuFm_4iO*O2y=Wm8Su3Tp
zf`Ez-a8>&ta5FvoOCsKPps8`eSM(%WCyD!t`TUPpn7d(|>yH$W_h-}0loJ!XNY;}4
z!TcQ!LgzP*^^uk>{ftq&-fhJhPRC<2IR?ZErMRJ0d0G?A+KQHgi&HmYkjtm8aB|`U
zK}7ic%0+CdOM_28ez+cshgDg@wld5G>uvwW2lve?YoLc;Us-d`vT!q^TQi5F&(2CM
zd)D8?V6~t*<mbJ;@<;<DK(!EJ!3EK_e}AaT;<1tmw6|}Mg-??>@hua9yVXDrW5_P4
zCaF;aS2BF%LRE5!&&IX2BL|caqrO!-($bjSva1L4Au!R4w`nZ`n!Fa5WJRbC(NxZ#
znk0bPs*SP66C#sxm8Xh@nk0l6Vt0?MVdQ*hKUWp`t=Gq3Rcz?pRt0M$lt#ZzYe74|
zME~unQ0-=Vo_|+sq`6jF$ifKdpmZCTWhS2I&4?GCP>DsC=SHAcl+8P(JR5#pE0F?}
ze7Rlii7Iis@@V&569$V|C*?Ihs1zyJd~qsp^+sDRc=g`7yXf?H5HapDBNc>d+X#Bj
zOg*DGUv5x^BnS8oev@fJ(YZ!|&LBiW$lLIeperg%o8ht@i`TeGZMZ*qM%nw~Y}c=N
z)?&m*J(C2PXljXw2w`^0QCCkQm?HbOKfW{YIdWbmy=W*x+{$c9j9?)ITg21gNJHlt
zlZx_y3o}yckqEkvnl99kb?ia7eF;B5J$fVEd0vulvCVX5!@yXm(L_|wY|N?qtnuGH
z5k)C2uSxr5+a$qEvk|fM+^6iSyeuVZk{g=SQ8<{D#!Ijo395cIg_;cV2+-hkv+7&d
zehbk+vhe`&@Z4*XS5|^J+`M<qXJfgd@|GBHIYj0jrQPDK`(!-WqXOa)#h<AJw|_kF
tO&&m+%(?%U#mRi|wT}IdIgRcr-4v@@<|~MO2FD$Q935P@)Y#Kg{sO-c?}z{Z

literal 6797
zcmd^DXIPWjwvOe9=%7-hD~bpRii5N$O+iGYN|7Fv-Z9c45S$ql5QxecK$?ia(1LUV
zfuNFLsDiXmC7~07p(YTL`(<YC@j3UN=gjf^xj*iY@7X&$d$0X{?|#=>?_Tj{Ci*;w
zL=S;LARdF8*Udqoy+C&_=->gMSr6;q2ATuThWgim_7kYVDY}0g=yBh_X&VRv9p>je
zdq6KUg@Hk?AOmAPuBii}f0I1!mw1&444v?@v<cD;@bh!?4+4IIK)Mgy?ghEIo(lB}
z@;s$)U~J~9;Kl_4iO>wLU$YDwSsssk`zAR23$3uRXE!=aOsTWw$FcrBB=FmVP~0o2
z)1vvOAl%1feL_`=+F#ofZw*if?<iPh)W{JjmtOtqP^qJQNcilH(%he9Pkq$W6G45r
zKbx6;d26SpaqDPaiR7gf_3@~N9+;LD>z?9DI<+omVQsl?a%;<-L?{>92Lhv9m-m8>
zfj}|9tL_JZP65px5a=KXbQS0U!2IjKzH@pEVDpbnt^&QkwEk`Sw|DwyWB;C|@A#~L
z++=Ty!gqo4KUV)0hW|MI8}i?O8h={)X5wET-v8S8JEva-{r4H30#W{NNz@{0?jZy+
z<Hl7fm|%=&i*_hrec<i>IPx#^m$_ag_Q58PPpMx7i35ZG4BCG-_Sb+!-^g-ou}eKC
zNKP{LgPH_JW{wT>$*3u}Z9bZvFY$>(`l{Mhp*_21B_*9vW^rg8E%(C=VFyTJYN`-v
zCZ91}2Nptfn&8(u)<R_6`SySYyd$G590qH&CI&}N%+-bHSv&6D_8WTIrDx5g_fS2(
zqXys-j*x_aF5_0sln>CJ>1V<hN{5MQ2Hr~7$$(EUKU$T|4u&=e%>XE11hy-KY0t8g
zXb(|IG~{4+B|Az!R)>-$@&qe#`Iu9dX#7W4xlIQNO}9|WEt+@_eDhhDXLRu_Wc0Az
z6>^4ph|HvERZ7JUV<n9s8g05BJ%12{Dd-C3f$lc=LH&BTdta7}-5heOqID-Xhk58b
zX((y)!^2(SV^_3no~ey%=Ix`U3t-Jq%j4old6;i!A!MHjlbbc;JbC45ghO3YHEjkl
z{iVr93M}`}UbOcjLah=T0cG=I%NMUSp)dFoxA9?NZPej`e#j<vB{^PK5nY)X)+paF
zs2^ES%OcjfS3<*wwp&M&%FpAn$d5Z+V>u`ur$uHhk<&l-AP`$Q!aVGVN=p@RU5)(7
zi3)X=?}yEgNLoh?+WEA<gv2e3qdiJNYq+VR7P5rm=|z%+7W~M%iV}KCwz=uoL04^q
z-2<UpgH@z%KXn%uT?;EMyo0J3JA9WwOIpSXE<M<A+lkyvJo09Q+VJb+&(<9(ni+k|
zInVYe*-rhw9#d4Ia&i>vk16zVG}f4?tJ}iss)w`<ZsRMN%t9d#^1F0e>u3|YMycE1
zyCgoUJ}>w3#K>S)SmREiJ~=)A@}GtXO@&PtPmWZmn=sC%UbCu75wj;fTn>m|-k4#y
zrfth!U6~bStmkY_WA`YbZz;utVxFThfsU|yquo}Txr;WL!^7f{bt?(1OX3l`?^~yY
zZ6QXOajr(y>w%VA=~G1K))(ixt-;mR$3l%yDyEbur}Q65-D5tW)n9YkpSb$yw~mwc
zB?_}^w0WkbhO(N7X{Rx+!|*WlZn#zfJ2<u`E)Hp=F!BIBY(6PqFZPm@Ih#B@-p3o@
zw~&AztH|mPc6JGbK}T(&y@wHc=Tg0F6P(8`X$cIKk0L!AQ4QPmuYGjKt|(g8l<x+F
ztm6v=CW|IDRE6c;9}KuZAGvq>)uqZ~pDMzw?M-1bZvvASl0sJ2J;yGo3U3)5X|q(!
zS@fv(sDygy!<jqH7ogV?R`TG3?2}r@B*ez7`*wqFMFmpScbOlh$4n<*iXaX{!b-iJ
z*cbiBMOF;M7*5S*aVhZiyW%#s$|)t_lzbRKb{nncy|3i5dOz{OvB4gTY9r+)N7~Al
zBV{LOBr<fTHMc*YnwR%8PG?Lp9IODFssOWz`lJdXp<jDxa>GBlt|sI~kdr1>Ln6{5
z^9TB1Efw69n=j|YZuWI_80k$7Ym6+^Z{O^gG?E0p>TIY&(^m~V^gSF`S7f+S1xcY0
zn1;eQ+f}3DM~l_A%}-2AN;LHuJ>{Lp87EmOHdksFzECYk#P}?W6=m9fd<C^s)@`^~
zd#p)upk{rhVZDcAcCY_1%)MBt1goeb>Y=@JALbTOU5Wsluhr=YRvf$A$FG=b%35AX
zE*PYfS!HLVj6zM1w0-K+AuXdQ6T&=JbUZvbp^CkAu^Xptj7THMr5o%ANv$>~v*=A!
zp7^>(7nrO<IE^OUebJgy!CLFIVNzLz&P7j|W>kr-fTUVJ1wuv-lRjPdW_wYL+>|vC
z%(H_k*c>K4hb@eV>2tldd8D$^CAAmSUMgcR#P(PdiLcwiy6Dn!Q?U{ZEBdL($xa&w
zZMrXMIbunSbacn${DKSGE9lg~=`Y?pqF-JLAUqUvOpjl6uf%XzpSL=x>WkRmww7&#
zM<}DBXSm!L)1lR@q4}#Yw+CQah{Vz;ADR#H^IChmGt(kLw<{oEIXR`+^>!NmW9yE^
z7<~>^bjFSG#!s3TWae(aB*tHUTf4scm^FnBIdA=r%%;Ed;Dc{9ROFshSeU=CK)xAx
z>8@%<l26IBY|GA-A-zyXUDC3@><0q;_h9tZX(+(7`mI5(SsX%~el1a;*o8Y~x8pEv
zq2gx%zlK(|S#+qk6a<oK$^tj2S>a@`%7$z$P3;p$JB<OrvjD)E?WT4TCiT-x%lx_(
zp&^*!>^7$pM2QY=)8>Zirt&w2tAa}D_2+O`=wf0o%^gFXZpjR);PuW4)}Wz5Ek<`}
z02jWfI1W`^?j^~6mhYg&znd$jhW}7{9vAi5CBD|HbB5&CR{wnTVnaCPZgEvhx#Nu3
ze#h}h9n!!L9&7T@QTo&L(p4a!wUkUJ@LJ1YCU<!9_8o7kmW#(4(mLizn|;x95n!zN
z)*J91%Ja<$@M+xEO8(`b+leLS0HmDQZTm5UAeRGt4W>Q+L{z*#z0&eyTj3)o)X3c0
z#zL>G6h>g>grDYFxVV=;ze8$QLGv!PqT#nPnOYTTCuF_23_G2$+6gcvx_icvAZWvA
z@4qRI>NB<D<;{zIL5IAbf%N!#Cz((F8obhJLouwNP=H`8X;I1~#(2Fa_Yw(VuzMp$
zgC99y6kftPV@foMGD)NDZ-)(wG*z`<%=Zj=1VY_i?BhfIrTs;XqYuz)@yIZb*rV(a
z*9WwTZq{@T%VL7vVub4B*pTV=Sx9W&|D^Q%>>3nc>40|mN{<YCI_gf~!lZA2h*%;+
zVClVegmKK#kbpR(gX3#Iyfu>4P1AL+#B;d8%S+4PzNj8~-(PYzA+{I}>ABE-c4D?4
zKlofbx#ImT=7;HLKyGNv)7}nzp$^KN{mL$L`6D^GaJU{9M_0Q*pk8Br9CJ0+D9;tx
z%A5T4KAM>KVs^8hhv?ui&{QP3v&fTF#>xKEJtaRpW_P)|akd83N~L;pRH%QkboNm0
z%wl-e?k3X}7NEe0fAC@(aI5U;Tqt|plVbl;Ek)%@%0W<aAm9smby`G~Ij<uws7FMB
zq5RafF4eAE;f1O-_))vY_J*8ANxt%0AsX3-+U4rkBege%JWMnutZcDX`*e&o>KFo(
z+@bDE?VDjh?oCWrmf434H;$QHm`4P2!wKScc5#j7nL~G_OMIk@jzI3+!EFjWX*Qx_
zJiDlfSzm@7tidKu9e)%T97RBGH<beEjrm1M@iytjX0&7%0j`GN!6&4bGSXXlLCG%m
z#nY^{f!F6OCg2HPcMkY=58(98#b0ZSiapqX8ob{)uo|mVEOsKDu$T#uvaP6#r`d^#
zRvWzpABlk7yK*wiI2ylQqd9}V_UVOY2H&`^j3jAd;TiZT$u~sFHVZg_FJU~OoZ4uU
zC{^oC?3u3HF<BRuD;m*x(}<Zxfm9Ks%Q##K-N2a$?oX}i3(Fr@)DqyACk&NhQLU-_
zvnR(y3S}JJsQEZFePlf@egB@TWj>n=uSv6c!gYo9DwG`{J==3*k2V*mF$&okH@IG>
z5z-8ff%;(}@H<bdH@4TxFIWpn%ukp-$70W>B*|YHk{NMV%t2(x-~VueLy<%Gf9hSN
zPmvrne#~OdstmoDcWvoVAJUI>tkhi&H9iqPb!g0g==W418Z}~v%L5Ti3nC4DJSgYi
zb=~VbziUrTVRM{L&J%4@&3}iWZFDkuO2FrX(@><Z{+`+)HC%b!mek1X0%IZUuK#-@
z9T6Mur&fwio%$A1>I=oJqMi2ILu1h6PP{Z?#XI`+b_$>0RxXtX2tgh$r)T`a$_=0@
z@3MRMC~+r)-WKeA^%Ul}icGAkHk`rtK9rS$@iZ)nl2%b0MXY9DMN<1OC5O6atx2^N
zr<J((#?-hf;I>yUnDoh|3jvy1OzE7-0V9S=i~4A!bD(bEYd>llSik~@0ibQMyY!4i
z4LWgo(&mNv%MVLJwZUy(-0)}mZyIT)`6etSfaAZtvPPy%-U#+daMHlkUIbF%JAt~Y
zCe^9iG1<P37{C#GRVUN4;@X4?x}*+*_Fru^nD8}}%ZaZC!X{}s8XM^%g?`TdFfNv-
zm`Z6}y_L=M;G~gjT;{M<jkCDj5ypU)=9Ode+@{e><pGJ4%MPLaaMt24LoCFf5*9E!
z_*y7+mOmiSUxa!q6eDJ1n-FO+<~lc$$24JQ7Sw_p&k~nHmWItb^?Qwe0^Pk3;jG2j
zYHYN-a^B(gfk^XA-z_me&5C7N|D253X{_>={EsQ8K)><sqzXApO?d}hKsSKv@;`UW
zSCktgS`D8B5+=ZvMEcJ|jG2jJ>GZqSl^F-ewKYX|%wc?LoRy~$`SjLcz4lnoFh87;
zw3g;erfW+{q^jPgwRjOcV6I`lDB$M0Qh-hDpH!htp$V;{4ijjtOM|`_(HU(=@aFGh
z@0)mfCQMT2BfHqy>v-+QNI?>caK@c)Kgeg?TIMl-KoyWuX(}_A<}-|$dUf0qblInL
z1&c<Vp6EqV@Y*>dVh$U@8yu}5_oaeSBz%(=wUQ%+iRaOm>8jbn4onDTEJC8v*u~k#
z&kWxh`2(UZ;|}91mZQV-T`$pQil$RvWsQy;7m{HH5tbU^AsU+(I;BPm6f%-Z8sSrB
z@Csq;U>S8Ld}aM6rn1sg`WomyhR(d+@HZz`#AmPgJ9*^!u{4qeU1B}^7)@#NA$zoz
zIy}+;a^Ax-0`PT!kXD-)tN3ZV0v?c@-Z8<P`AK&!<nRTTpA~by7Jy|`YFly3P1?I`
zgYsRt7gV7c>8vQpSthzwcV<B_nsHIgBzY~v@n^?d<X9Lidi6d)s>(}uBc;Vs&)P_X
zB}oN<Pq<&=fYz2V+IGOjH~bte1PJvUoj?4vWPD$_#Jq!qQUEN{O0z&&eqVDTkUW4}
zAdAY=`}~U_`UwLzrlIO74WJl9?u7}EFD7Gt^&U0mF|G*RLD@LD1k`I18|s5Q#7Kdo
zAvb(pj9aj#7)4>;{&KylNoWUVbWcI+V>VVfSnAPQhdU<^f+4#bA0LKA-%}l^^-!+E
z?T&`xkPY}^csAO(6+S;MzGI@TjWVh?GtooreFGNxy3HzsLVT==2-P$KIS}xV(%T)p
zG(zs2c>w%IpuI-OA{u(_1*!ug#A_WKkQh~%BLQz@B+i$VQ=NW*t7!>*mM3VX2Y7nk
zTA$0w&PnE)mF|249P)ikqmMVZSs4o6*j!o^b6MF`YlAysHAP=vF_BwppCxTK^OJF(
zFUIv`)A6mTZDq)G=hIrLs}JfQoOJs!rELZH7#lJwYGwiaHjU+fe}m}2TzHg1F0$x(
zvQ@oRHnIk;L!Z&AVk8QK*M`XO%=>n}UcM;w(CbX>tKU`9@Y8hVlu}8L2+LfOtx$RV
z+_Uh-=GM_fp;cP$zDdLmaQ|xX-PY0sF1J)IMkbv~ab@;QrIHO(^qm#kBR?RslFFcZ
zLyv&VP!z>xUruqhLt4DPy9{aUm&qlGBz5T{I7>w*{+)N6fUR>fGb0gk0w%rbdwDGl
zKA2&zP7W+ncY(Q`)6#~5slfHVNy$ag;=K4;4<xk&aoE0*^uCr_|E5XJ#K+q{upF1&
z`>=9<3(uK-zn|lm0e^9IVNLWlea%??*6JE3?&d|=a~?p?BUZY4T2l^xru8#}C{8aC
z4`*<~c92A%rXiRR`%&nOT@}%@XF$(hRVWJmXt;NH^)owbU@XJ|gPyn?Evr?t&_B;Q
ztHv}~QV0Bl{=OOj>L7?d!*ULT2hA*!QqDGiw$oJ=YP3^#u`W423hB`iAlK4z>3OWO
z{GD~}D|Z3PTD2I&Sk|zE<{5MZ*Op$h*;}PM2ItBLB%Ev$)Z31x1DWybwwB6+QwpPO
z%T8&G0Z%@yv(JIqv2J4!JqSpr3bR@M$xcp)eHvMyPr}SK^P5ULyhie!_?v9+y&X-U
zECJYf+Idva!(}TF(VBB2Lh;Vvr>UWb`HW(CqEn`ZxIR({vEV_;I++xu^3?%QIY4rZ
zA$LBw&Rm!ha^@^jE4bma8QwW(O-iQa)=$T-;N!KK?#7g@o|9z9oz4EQz{TKs%||Ox
z{~H-WcM>V}B;tu(Be_Q{+Z^dL&@nZtM22?I?=pAkQ*7)p6KM;6#4eBu>DSqV9}8@L
zm;-KSV=CdTMlS)?@+*FVNCU4h^vUm$-E_|tWIZ5?lxH4Tt<mosilq-yt~1H~_s2BD
zr64wt--uDWeXBZSYD$7Di#MAymp$+YTyTHb8Bv>)CT9eu&>nLwk%0U~9?#l^UNf{-
zM!gqXnQngo^NUbsLA^PwN~Y;VcTwiVZa@sgK@6SK{&snQtdy!b&u<#t<f-;nu*R(t
z3XKe4-iQpKc>5#NRBH4BQR`jmwHSe;J;wMtfY0xU@$}8H>-FFtI3h*vnf#4RV!vpB
zxBru}jjoFP+;gf!YIyFAq~7$hC$qi^F9C9OPrp8$5})s^DEK7SMpn>S4$Jr08tLpA
zuK4JVAUPJtp!bq|nV$Eg58Odg95|8%^joyTzWv{-$NyfX_**IPKPpjkHu+}aJFBtZ
zIsMe%tDJvbtNa)5^q<$p{~uJhWB!iuRiO8sl=x$Mi`@nrRCJXjvtVg-2QUIM&@;J?
J(z*N7e*q&EOz;2z

diff --git a/Templates/BaseGame/game/tools/assetBrowser/art/materialIcon.png b/Templates/BaseGame/game/tools/assetBrowser/art/materialIcon.png
index 0e6c456a644cf50a23d8fd1abf5609681bcda256..2b805f6d84f65c026bfff629832423591984464f 100644
GIT binary patch
literal 40426
zcmce-WmKD86fT(H?(R}3uEkx7TX8E|Tmr>CI24x_DB4n5w76Sv*A|!H4#6EV^t<c+
znIE%e?%bJ`m6i9L$lC9gXYc*&lUOYcMQjWT3;+Ott*j)k4FDj#Tp|F_P+ndxegEDA
z0QfHcx`v+GmOgZDA3?Sb&Ng(Oer`5&HogwF0D$k}@mHfS%T4%i;nf)2Kpi@SkuKjv
zpSA4=6#laESqs$~$=1@(qgJU%cs-QK)Z?AcemzpRC62th@0{A}2Q`oDce^O#D)Z0U
zej4V_CFMU#K4e_1UxbgAbXT`YR$X@-yXCQK2j`ntT2tg?aMS#qcnH6n!|i{NSy)93
z9Nm-9QmzDU1WVbs(dwQDY~9}nbSS#6T#hic!QyV7?g&vXiq5p-c9=OGw(EC_7e!&5
z1Esw#5AtyxvZuV0b0N`5s{9_qzkU$p&pm#%ISVPlN__HjF(u9CkAD`0e|4d=Q476!
zqF$ncA5J9M(stxLiyfQ)5)0y9$%m~j;LsY`-#y9Pv8f(k+^$?GOVV8G8Rstt@qVnG
zNP&OsI7;s@{dlXC4{!BZYTvDIc}J=03VR#GvF$hD^{4P^dFFOz9^tKh+ZlAca*8A_
z{iJDQ%cm%hucWQyXRboazWBgr5}oq958Ig+7$4>|DTem^BuXltvt9MIJL28};!;_1
z#_~OsC#s&vU76y<dUKoJyrxmOdVB`mE?~m`5F*V>TKBcp7*N;7#9lsxjtnZbzzT*5
z*OH)>A>x&hSi^+2)}f5!r~bX^m-!oPn%^-=F$N5{nO0z^cnnb_%xM_pF`UH83FHpr
zUkO6r5WLCs=MvE5OO`*kO>HJIR^yi#onJ28Z+@d1oQr~`iv3ol@M$zV^}`I?-z5FQ
zs3@WmhH3e}A0zffe$n+m$KH9_PnCXG*W<LGv+OI470}^76!bqq{`*-&%KNZAsjDFT
zHSP(GDNp}s?Wm|tL&+aoTn~<6yBVf3&i4)X6k@QN{mqpI*QKDOG@K&OgOopsG-6Nj
zswFEQ4?i#cj&f>*o@Leh7<b-1MV1%&%$}#Qc4|r0_8ZM4DZYv(Jj+R`HYG$is8Q%=
zah@=$({;KY^&7XE@QnPx%$k>zD{lRvDldKe=frY5KWWSc?U0F9!1)(AbQD>0Mbq|V
zsV#`xX=&e2f;^!98>#?F3yg%>nsMUuNNC|G{Nv8!2yZWK;Az=FC+%f4?O)VBfcx@K
z))S+Pu@O&O;c_HOyK(=$2=x0E%PZaXR-!**%w$xoCF3E7dAdvG!F^i3(JeLZk*y%p
z*Pbqn+RF(oLq#yJPuH!p>v^jz)W-1*-*D^czsesPmgH2A*Dwm@qnn&v@^JNuGpZLX
z8@r5IBe1C&9KRkK-!xooRHk5BNlQ53_EBn+hEy|UnS6*gC8pRyagx&@a!r(7xoH-R
z4Ej-t1Ang?-8U<fR&28vcQW#nZu{#a6ip*td6vVoWxv#W7<^vO=ZlQ=Dioz8oA!O~
z(;nIL95R%OQuR2zdWmR^;SHamcTe-Aisi<kgZBd6=rNm(8Kb#9%K7KU6u!4*V--c?
z?<v@P`GWl0Ph$0P=v<_Jnf(Sl#Pn>T<T{iMu?-hv%I~vMyHx;~gBsHQIHTZHJ?f*W
zwh+{euk1{FPmmxfZkc_P-f-ER&81$-Jb@67=2-Um{n8x?IN>e((D{4rYxjbez^fVO
zoa$h~!8c2b6IXPC6JA-3_xuD?Mq?`3;f@UZ?Cg;PpEyQU1y<i$vTXPLq8!{YwlBM;
zCkKz`_VV(wg<FB1ruqVWMqW1zUlgQL6KogH$uksXdAH7}6={6I(r@%FItY7xo%NAT
zZ;_ck?Y-TSO%C=#9ky<C^A1CGW4#A+N?K%02PMk-1WK9j>XfUK_#NroJya};Ht2Nb
z%y^_i=WqIc?i-4kDkpQ6l7*zt;iW4JA7n9(hi6AVP3v*CDq=Wt`hJgdbQJRIG#f@8
zADL44ez@mh#Rp3G_9|-{M_NWQy0%WncpDN@<?g3s9YBbQ{56U?;^ODPMFA;gJR8&3
z6MU2jDa3;TsdpPwwKxzrdx<k;D}kLT#m93a!xhg!lfTZ4H$ja1Q@-nKv4hbkIy>Xi
z5%et1hYp@8lXs1I$o;IOAG<_^85g$_IahXm8fh%qvf_!DaG{C{^ipqCu*RB@-c+Hu
zco}V(UH!b<8S1Z_ol~L;CO?$XzZb(^;~0q56@d_jJy8t)h)z+-)7C$8@HMFUkYH2M
z_Z_ctdpJ`Lgz)p?8@W<uo;4}JwJuz)!pGnzW-KffJql{;lWgcoN}a@GJcp4_aTTkD
zB73-Ij;y;hBAGxv+2;=U#ge^S<4@r$5to7>twWp%17qc?{@@B>Fn43-<LdLyi+%XD
zSLm)#msJd83#Iv~ZuDor9sF7xWv}4xaE_lnO<-nj{k0=v6<^)*Nu&MXoFri3K+|jF
zCNUK;SCxLU+Tpw{k=^1Gevcak0cTGXySFDv8G?zJA=V~cWA6rkZM92j9?b_P26VSq
z$Awngv&;;1BmG$^Xc%~CyA<i)->8`~k^WZ9?S5z0#zm9UQ|#gSU5~}fU(Q(pB9Vl7
z;j)ZjfyN&1X}fPkrFYYu*D5T8a<1a(mqj$ZdZ~TX{W)BOKwoQY2`!REcP*2GyDE{y
zPOV!qmoxQSvSO%=yYv-L;cx|ArCqD3vFP^9AMwRG;I7d1o-5tCE-tzJ+m^DM<UB8i
zA~gr1om|Avm^$TV$up^2A3in*GX|`;(t;zI6UlXbC$5MtgIe2Te_-Eo%HK2E4@dk&
zA+%IL0{0FG=#vlG>3&cIe=Zw9ZUn=^r$Z^KH%YPB?7yB@EjGE29BZ(+Alm~2v~i3k
zc;pt==rGLUSR6N}k*HY()}4__s!=*JqCD~Um1^Gb>|@nw(#;?jXb-K`+ufvU*L5-{
zu0^;D^6{ZFK(Fq<IfRUxgyhLMoKXA>k>!o|){=Lt;&^?=oIy;N0YLsFnxYwmC(k+&
zOOeF|)Jm`7?p6WCRIQw%r~92!UHW!TVyb?etRTwep;q`Fho@UBRzhS<nS~mR;7SS?
zR4iyCd<vCL@jZ2u-1ByyK93ru4-l5ZcRc+@XP=fPy8QciWkZF)xO81;=_z~jLB@5H
z$V&LvucPG^e5)i7hXo#nHunq$idRNLoobTluQn$8y8b;hP7F0xx~=dxBp9?hi9}&I
z2E6Uxy+B1D0d~UL>>s~S^49}18`0K$V&33M6xFzWoc3^ZM^wTi62O$AFZx7=!AAI6
z%e}Q>EQU`Qyo7D8R6(h2jv%9lx8X;VU=~$@q$-=m(cN+gL5cKa$j4{{?DY0!%hr8f
ze47GnDU8@hQf^)|PKclCc6A~jP8(JdvtuLp<3?6-A56^8UGv4@DYu7i<;3iR3zpcT
zMZvd857K4i0VGlc$AiK*EV$rPu;ZxCaxyKJE6s0qv|STg%TBoTIa6ekkTkT|F%tw1
z)Bk~Dsu|w9qHSD^S?nOblvMooli(s#XZWKP=neAT@6n^H1@XoLMvM2Q_a{gnYg(EI
zY}{}#yf!MaFCnD?9z>>w5wI^gYZCRl4#K5MzTV~l8DJ{T0ogk#{*zGL7`JPeaPNK^
zY^7{hM0aV`Ae~7)PPQ+-ioHh7dqOChP%nn%irGL=c#T{sO=+*)-wzDVh?(A&$+6_i
zO&y57uO2tRUSB|YD=6cVsXrMA&gCJ$D90KFl#Jz8+!~3SXqDPZFvldNw*@>vgIp05
zYnI6C0O=Y1f+(hkfg_sWywxtopJDXl#lmXfLsd@xFz3YNA-eE7h99eh#VGz6CsjE7
zfAUy+JTf(6NVB%gu}0T>wF=v}$az}Ex%ij!q*X<ur#r~U!bl3&RVns}Og~d0k<O11
z;q}zfer!++(}<RD%u>>|5Q$tBol#8d9zlj{(*R$)#c!M_OVgP7uLNb{^5MLX?jNZC
zZoq2!_Qz6YsI0;p>==yWFyDO)+Z7p4esLjC%ZUg&W=>L?OqmxcTxH7PJ-_z>*6*RN
zZRRrL7EENm$;r<?;8+klF}EHvu$%#nURhgJV*jHLMl1N#Oc|x$a_&6`U%Nm#z17JP
z)n2+1H6y#Fb^qQFeu--*=XXFYVkl-BCV;UgI`Z>t`Rz8msTjO4J5Fn=vvvp>HH%@i
z-0WY!=sR$_^n-V8{Mc%w3S|-MV%q-A=Y7gG_U}4P@keXJUhC?Up(j|_?@nUBiAh(T
z#bgSAmeNM(${+_qDlzEvV!mYav8yaS2{dm|s7?~_H0ThcjP`V&+X@^DWwx4jyF?o(
z#5vqh&#8@Hnau)4-ym^pI1-#B|HkrAkykL1r@|~l3Q8X9agjNDkANBD;MBn+k4koL
z^N=AUokDhmU#oDW##@XKn~9X`{Vrgz+HWG_fO{JCfcRkWhOr&Zn*9=oT0WC_*YhVg
zkZ7-N_UELy&|aI)FG?ZF!qNB|%WmPxs&}7Wd#j<&vI<48yeSL&`F(}XG<DjV%g`12
zHNwW?y=Nq5F!SQTrUi)O+qb|J*$&HIL{EaVDC8puV_?cM`&-$FvI4;zQEYb=Nr3ON
z2qEJ9m#@ff@xIL;9ioC58VbO4D3oTz^rqSJbyVUZXZ_NoJPY;Tfssu1>~f}34lG%8
zbY!MqeGt9R66TpR#(#h2Gp3*@!--$s%x<g$#dZw*1>!qSIX(WiX#3Ub0mM#u6_)<%
zC}<>0yUc0ZWUn@YMNAmqc+7`O<>n5%;QIp?lDndOaqZkb7Am7otqKj&Y+DfLbYz9B
zhIXlHsgE%O$KEBMxh@g0f!|~fuylAJ7t$Y2%8la~?j53qrC^DU_CudnHb{Vi#Ga5e
zj?{cNH)ha*$m10BJGsR3r;~(LivL@mE5srKe<W1ETIQHFY0r9cs*t4*QI^$A0!|p;
zt8-X38vDK|5x)vOKbxMGjIp}XZiU;hY>f>OqHiyYp>Pg<X7qQId|zxoEGFqozNs<t
z^Zujm<u3yfo`fH9CnAr)-n`#46q`MMqYrcoqZOZ!7F8v$QaXWke35JMgP@qIYn3-i
zrn;`O{4A*!f1c&LLU}V}=X^R}&x!W1k+Cj}bsD~E_`ZhXh*YsnUT|G5!D`syLb>9Y
zaOfhX(|r%c@ae8<Kul!pXkfG2zg`NM;-?$iKwR6^BlVbyMf?J65B(8PLdj!&{|mVa
z_#>5mFKEQb;cdnk%?O=qg{29z`ge4cBjoe9iUxtzpL41d^hD*F;0oOIGBY;SA$PcE
zpK)|8YA0#_(&51#bS&iEUlqa%7*<X_V42AFg`{-EPjLz^pZMDX_%e{u!A?OD3p;9i
zH3zJ+pTlRx{5E)F4OjX;MQ*DbtUc&M+gDwj3kd7o_JdIYYFdE!DfQ%doxVK))29H!
zc=gDg=VXnjlWNU9Or-@3CDJFe(I62wV8L$Q7dmXMta_nK9zgWz`}T)tZUH=pQlb*c
zDM8AWxR_|d_0%cB^kiXbAz>=K50L#!ZWIV^mFr3=j`@j=5l;oc$mKpo2{5i@_?AfK
z=2?oK$WB_NJf%JoSr#ok*xsiAXK+>e>|4keI(JtaZ(V;uI}@m^gHO{BCR*YPt+UZn
zlg!<MV_qH+Z(nSLUs}`kh=>J&cuP+_9$RlzNW!9uA49&J!VeK6RG#Y#-j*Wk9h!@h
z+~i5K1-^wOXM#=4_Q=-i-gt@h_`fsI5}P+t{@X`Pjh3qWpz#sX)H)o6*6im;&t@AW
zn@xnXQ5q^S`0#n#br@U3W5y2~sMd~Ht1I3XX!I4vZd*cE0>h=Bns6`oS%{>{is8n+
z>(zPSA|3N6ehn?^_h!JPo{X>vkKTxlAL(?`@AV82EZOJLj%*nkmQDP6s+|Rno5Xsv
zAqAS?^o}T>p(^OazcBiMZlxPK_$`A?8;yh@ek-7SFDq)`D=tL*ctyJ54Fx|(-3>Mo
z6=xECZ%UyDZ$wj%8uz^|+Sxh6b)}wZr#jr<qk3o6A&5YZwiEng)}r&VZ}29G{`sju
z>X~jZf?z=ZiL%SPMA`99h5!HnMmosJX(`Le{ZHcMg>K0SN|8|Nk*4Z1H*wNq!|}#*
zAJod_h@tI!S89laSyVAu8a`BHKKX-Q+1;JU6cZ<yL!a6-$IHu&7^w>vPe|zXTT<4u
z5an-g<535me0^Z<H#nz)Y-+qM%z(E7SGwZNA3Vxr*NEHqqG<VJK8;Qi?Dt`r4$Mi2
z2e!wZa@=@?BnFFscp!{;6TIp|u|hG0*+2XJ@`Za<zN-ali2weB9825GCGyzcY+svU
z7j>!Tm?tdHK_q5)V4*)vyy37>RbHG98x!U5SluYsbu9PNeD1a|d#~(~yMwl2D2t$s
zmaHX5PMjGtS(<7^_x6F86kc_#nX1ZQKpszpSu7iB|Ih_r^J!GDbevYk=m)^#Y=Ytu
zLf;n{HI~DyM;!A29d>IfE)Qkc7T0N){wA2TK*S|TpO;D6HF$*DVo#aSYwAnjoAyYA
z(_jT?IwA@vv_s%m<E*3xEf~wIJ`j<L3c>pAu$hmakER_6p676NgE;i#<1mose&B@=
zL$Oj-ln3Phdx#(S|9sg&cT+O*001xv|2=_#uQ_Bdo2Z`3>TglE(NR#i(Z`(D6<@Z<
zJ>MF7%7I*5Y+OA7avyChJ#9YF`8asm(<v&eYZ-*%kOBa70A+a@UEjr{cBjeT`$oh~
zzaJj1OIm&Mr=x#lds=m~t|#-$A%r1>BeIg|&@jryM&5^iXBnvJtwEY1*Ae})spKG%
zC|W@B=%!NklZA*_m3lKXA|-Xc3y()0K|NK2)(5tE(|#i$mG@Bf`!Lv>5l_trR<E7g
zesj|vy&JT86ZHE}%Pilcj4+Z69+FH`k(MXMe^=;WI<zo4G!?*qD=mcoR$&Byf1koj
z2mE_4tN=;+-wKHd@NY%O0{m|!^Z)v*|J#1(e?|QN-8b|9M27#b6#9QlhX0R^`hP70
z0U#IQpKJa9>uCQcnf@1?eLXV5`bBczvrUggDO7Xc0n&}%9zN^cXUJ3w_@9U&p~mcv
z5^HN-53L5eK4et3$hIi_J?<h3tjI-AqwB)Az}Htu8Jb+1X$DfUxTeowjfVfiXuUQR
zdUg&CjfMr1HRd-{pClg6Rc>xH$NBE9M!TIg#0iI7BP1pzYH7I%Q#HUfaE1RO9;}1q
zD%?=Pq6FZNx^B9O?w+0zn}v*2)U-epU8%ME1j?qsC%(L<OQep2{mLk6^2DShH)GAS
zt(n(nT?0}v`Av_6{?<tAZ&7+^BM#r7bz>6ZQb~Y8PmiF!a39GSYpTur`opH(!~nOs
zW1scqGm*c>?wkGCIe9q{OUUZn0@mp<E@Y7ux_-Q~ZieIQi-o$pxI$G#wSKhVAsldx
zrE$pm+q5-IQ|iHCxmd{U<Wa=5B^aGH@F@HiHUAdX{{rbh=;)+){06;@KHV{BC$}3h
zGHnkeCgnEmZRX##;K^BT3N=0?8N_DvH{mtJJbAo|st1hkhmx;}oSQsU-vltg$JUo%
zKEKHZ1_p#BCA){#i6%^gQ3mXi+&!<+@_ly*Z<pZDpv}V9v@?|K|Ji@=c2y{d+w5lY
z5UkU)tva#(*n9!Nx^lAz&I6Xh0=c&Ws9+%r>Ii{EPn~SHP13iwAx(`_GO9Ed$99}D
zr+yRKSW#i&v@fc3Kl>ebd%3N-8U4J1yWT$0VE}6SXU+%{Qs|u@G`2GM$zXHOEkbp|
zRF)Mvv7)8%3~mB$G>cgxiH}>LSaWH`CA}pJ0exHc$IHKoH30wRL=#fE={q75wzY%Y
zDY*QwuzfM~c)nE964z>!dEhze88!S|?2`UJ3_hLi9~mAwJ?G~hK-{H)G(HPKKcR9<
z#{A0nr+EGPH6>=J9&8pd0CUIMn|9|$0e(^usEQ6D@w6+0uI-pGti3_5qG{T_2rCVC
z3T?kYw*4#>vc}73{~lcf#dbq$WxXQ>57u$WHE+~|8hnCy8;bjs-{j_*t$_SrA~2)4
zoxU*tWUzXz(suGZx6a;q%D#@eR`NPuUPM&3n*6jv?|zAv7k@q#aA+z?fmr???A~b(
z|4i?R@=-5oRoM+P2J&Aj;-3^nz=@`9keZ;P-8>0^bxnjE6#7CHp-GyicSymH`?Pb>
zivJQ&cO0&{_d~|I`b{T(K75UI?ZWKL&-Z%Y&fVW1BXhkty=xs&@5xrT&jSoaKe~XX
z5w0y$+dp>Bg7e=1<X+=A>jiE9vh0_Vg;csAS!5w*5&{+(PVp}p6(Iq;;6;pRV<6yW
zHGn&>`5tQ(K83qBonUw7Bl+xeX-V)e<DGU77_8js-7d}rbDl{02+=gd@J*Wo$zL?h
zqBy`)dTAF4D%6uw3gq<7Uf?)U4Q(FyK^KqEP`WI9FV+{B4P2CcZ0N--m=2NTSkBmn
zxQJ_Uz5<-AKD#hZdYtA{hj9YkDmTy8BqKhZv|VVJO0_5EKW$BHoUtcuRz4q@&qS;K
zrv^-1^WcGu&6|$(n~kvdkoHDs9Ho$ko4-Hb;+-wn2z@3%31PAGg2e)9%?eE*1owKD
z{GMOPw}V%D18db(j1J0O4flscd5GeP0NbCW*h6~N5!|eJ4X_%2b^*cb%gr9bC9j)2
zHwkE-wiVCjf=?><dzk+P&U$1h{Fwcj&&>PTM!1{zz%p%Vh3L9z3>Sh?e#zDbcW!uU
zl!pM*n-3JX+VJLGBv16glpB?H?D^pxNyot^`cJN3IOEsy--b1@TR`+j0}9c!7}jw9
zs{69IApi=l*AbX-gXGr}4~S3I?Fx(|^MS!zzn(#lPv*~^mtBPa*<hiIHsFc2C!=#`
z#Qo{~ig{daCJ?lp9f{G23s)p|6%3OaeYfZw?EFaS^W@N1DM2y;Yb@xfzigezNVs40
zPmsKbraMRcO6+?Z040g}+#1Q&u~M^Q%ShU!^WEabQ~l$ImF52sW}-{OaO$?cN$5sy
zc1L0gvkIMZ!uL!r>52Z6!W?z?SbWucVCht`V<!nxDaK{q5wAUrc5X82Is>=gzF8Zq
z2nzp9%|OS5&oUeF$l*<}#*^NEzF7n9Co$i}jfj%Lop1lM<}oPsfbfpQw;1u7E)OBZ
zmE1S?Jz~BKA_1n=3V;Ej`(68MBo7md=l$aLo=IUOA7}t>@QIF8wA4NP`CSkX@;~@|
z>|gu-zW0!;4F`JN0O~1&1qeu<jpRelviNIjU~EAZ6`+!XMjG`Bfm@e`JHHUx0Am3C
zZR1c7Zhz4QQYPIXd$>vR$}eR3TzIxJ3Ku*0$xaY{#MBOZg(`WCylV?cLJ;MKur_J>
zhb9%kSW}9lKh@ezY%Ejno=r$yZr)D89}92i_XjR5iT~40R+rd`FY4;^>C%~AC7ezC
z>GqGCaAIQOPKV^gX~NR|F-%enanmkqZ;t&U8!5;M*Gh-LP5+UqrR0!j4z4ubh^kj>
zNoaxgro)dL8mw<pWu_j^!nh|B5RZA@x$7eP8q!><NQlmdq)qqK;epVWfK@7n6OCx*
z4Qs!hC#3CpksA0oX)W~wx8gr2Hm41Svxi8no_+OM3l*b*)J{l-f7Au!b3T)gnpAN~
z?}yUxim*rw_GsOIq9sJeL_W<0z=E8UeXbI+Z)zW^`t%XY5m?mm0qgh=ypRBd<aQ+A
zGAIJ?WOlN&9ccs-BWl1+wL1@d<qd|hG|W@ltzMH7Nn#JwS@!n@`oNf^Tz~;cCp<DF
z=_dHG{dR8R*(s;-qG@ODQikMzI8#)dH$L=c8yX!A^CycwM9s;|`<`CoaH<oDTYFtw
z<FzR#M92Pcm;4}b00%uvE%^p0XaMSFh4ilxLh%?avenJt!VQ9(v;+{&#0%kq*n4`4
z$I*xQEOF5@kp7c~tlU~|h%2mTUEnv0|5c`GvM5~)Dg?NyID_jMW?7NW12{Ey_ZMC}
zX@zxfW=JI{(gqMg;VH1WXruq|=AzIbuJeJolM?p0;j^J85#IBy`|xL(`65?Gf|Atk
zv%bm%Du5Yy&DC|ZIDr&q^4Ol*$ajYTV8WEJgnTDx8o_PKLbixs|3;Y%UxXjeEa2K>
z{_Xjc{5F`S;9{cq3AV=|<7H1QB7%W3O`Cv<LSJ<+n64BEJ|n|<sbWU6YK8k)gZHPo
z*EIvzH1~Qq|AQjiE;!ZiJFmySM)=#d>yEjN;aUT?V$^hPtFlhLN13S!XU6L*q;IHR
zg16NREsY82Xx1M2sR}4hm=u43oc`CZ^rRcfHf!m$lB!9H01nx7X$Zv$6Fvp<kkRgP
zN!@GuJx0A-v@S6vv|sArRbDq^;!9%_A4?s=98rX0k?ao09p<h(_S|WY)LGAM_3IEd
zTF?JVS@z)5#wWn|9A=aIlLFn%*;lC6rPGfN1n1BYyjvBk>j@+a%#Nkt;C=p(QBGj3
z;4f~Jrf)<iIBKMw4##5QQr~^FUXh*<U5{u^e=;}O)|8i0LGk7Ykzhi-Xb3WaL>p@1
z?uAb(BFM_of&~!RjJKgJh?`^$SJJR8Y2P&r0P#!p)gT7yf!>BZqXZwZG6Da~)fB5&
zkk-=^?f@ZIai7AH+ban5P;h%`UM`pgM%jp<gg$962ifh6Q(t+u+>D!5=b6Qou6js#
z4>r1>w8FGlt~flud55$Z4=q##_z=X;UN_ZC4Lt4Fq<n@eXiw6%x>mp;tb^TB1&(?B
zXvdQE%+++pwB;rXQq2gNLkbndzkdDlJtfB7fIf}}oQ1>BU~APq*7s|eDu9>7-pKbn
zz<tYjJ7#{W*L1zCmy<^$OUG^6?!gB+4l=tzWI~NZ3;wY9C*0qX3jpT=;Z`l0Kh$1P
z7kfc{Z*489C;bbS@quKYz^h^?Ljrh)K36(5YhowhRpUqEj$z=<q`AX*ehYfaJ{0z+
zA8-<vC=I&e$F*3l>`#R353!zvtOW-?mLzSW!aHeuAGkZsUuGKUV2yA$_6^O>b<NF$
zq&A>IUTav-H`j`1voWE5sil)IeC#1w5M05IbaBt1;3f3S5fXq8S#b@F2Ek+vHq+YY
z)lo-YRR`GchR;7xy3aXd&emxNlfmCFPRvq2PZ8~fHcM?!17nte9@u!_K7n+it2d&l
zQ_WqbAy2nX#}gYSR_iIR$et11geCg=#7-ce{fR^1ui=uxTYsd!bN^>lSEfg9&;zFL
z*i(Mo$i(|7VA@f1!W1+%NMGA+z;=%iAt0;#*=n{9;N0+xZ-5x?M5}iX=wA+bq!DX@
zONi{{w3F;H-gPFB1UBIoaX+tZ3WR^xL!YGXl7a+{1B9z?HZ!RaKVFR-hDxK2Usx7*
zzh*Eu1gd=kOQg)7r!ThPP#P3me<+w9{Py(ZCj1hq{KW&PkAL8|nrA*z&o`Hm|G|eU
zHK=p*_!bfLfY`KqB+>M^ysbV}**i?#)!pa;bk=*Y=9131IiB%Vrbc)bDeaAj1R~bb
zb4{l(%!3KN%d1ic7wqE_kW=`>H6+2|hQjTDetp2py)_mj5Po0NoS<%M83^q71et_!
zg-CoWmKZ`Ch0l@~UtUl>R;SU$57@7S4QB(-ymJrTce=^j;JZ@b&PRTDSqD`&XY@-e
zx31p>3R!F1ylK1gL7c-js5I+4J3GsPlFC&R=%0&jhMXcS!c-2C=!${kfQ}kCXFQ>=
zL{e<jozEX0`vFQw7#pC))GZnRWLt#e6|(8R&q~<z;fKwLZ*J@s^eElKN_2p5kBzko
zxp#mI3|QsJriSeP3g*%)u+X%X*cXIk;k9&`6UI1gt@fWk2Y&Kaxx91s?iNhVQpx>N
zlY&^8yT&dBqi))Kbh*tBJ_wo3kk>+$#xryDy^(|Ux2~RZ<%s+6m3BIe)*{0>n=&Rp
z?&3&i1%TzoNuv~Q*+YBh6w%{OLcFgr3A)Niz@Ld87ceZu31>;9lrbj239ruogkND5
zY++(eKW&c(Q*zQ3-;Qa>kls7MapIpTV4Fu6F$L!X)S<5RN9Al}5g}|wsEEW<+!l`p
zC6v-h$0tpPtF33WlFu@aB_TJzE^YAt73!+U(0dU$V#j_0H2x3!FJUU2Z$TjS))1sk
ztrQ__@c1IFW5_7#Da(_pa^F0O1$_aZ-Lv0BNDIJ~_+*QOE*`A`Cm;<+!Rk3}71W3%
z$ovSL(uzS2`Pu@#9{BON`vrbI_aq=a@e#6`RG@b|if)m;zL*dkxS9}F|Df>fF-=95
z4P-=@E_;?>!mpFvTky44eQ7ZePg>!U;`gdaDk56{SO;$8$ByU_+K#&fC|0XwQ}D6q
z@VnTHhaa;-qJX;H&W5W$&`^cv!mrD=r$X{Z=5m*WXsu5R_>-C26MS8N=<&jlgtH#Y
zsV6A`aiVVK`0<ibx?>kEyDoS~fp(<yM>k?#xL8D&hlz}IhfhA7V9Cv2A9@<U1RqcL
z3VcPH;ru!w{{w`5ON5Dm{`P<%Cnsku6qN>2m?ZHD77X_}9AW&|N0PD!?}m30!u&5<
z-FDniUYwH&(;RYSkNNzU&5p0&IQdq^1Q!V}BuQe!0{7nL6_Q^BUIP%q4sK9+iW;Dj
z2<<~53xwZsCUuFTJqzedC86%Y$_~tDQI?HxsfMHp2vsVcT#T#6_9R%~GgAk+!~s`p
zgjG-NT(6`n1(*rr48V;Vz%Te+`|Cv9tuUM0No(5f{D)YnXw_h4^H=}M&$i6d1nvig
zwucH>KXT5%HoF1KEvVwb=2w19Fg-pG1?~^1yG0%&B9Z_E!UR|(>*{X+qy7v@yCvU{
z`#}|x(6nRu3mWFGb&Z)h^fD;W-3MXc)g0g3ky`wCRS@u;QmqMH8Zhj%CXuRz+nr37
z1srO(e<6RgFAbhzq%%Zo{FGM_$&QISGmC9M-6ar@YrK@77cPco#_m|rba5hfwr8ER
z5%9cnvp4dp?Sp%S(B^|DMMMU{s@ppDZIAhLw0jrVnhMUdt;cSsvy9h6r3*sAD4jVo
zZNcTzg}$^B(V}pdiXkNj2kWvR_ONdoA5B2ObD_J~sw7K;11{uc=eH1mU8jzPiL2;x
z7Zn`bTGwr;jgXF%7%zywvw5^k;^fmKs2ZMNF_epCG0Za1k4zCBwx6&SACuC8^d8BA
zNvmN=w4CX!#N9$_hu%#U6W_56$h0%mVEF-~ZRZHo9Y6~gy4Obkum6ho@Ww%<IwkGc
z;a+RYAE=+ahRL|2RB={~Uq4};*kJw*5~xC5-NKrONg;0N;&O1VF)*QuXx;3R%XAvL
z(NRsvO!vC$^5)mRrg#+n$?1-MgB|K`5~6fI;P9i%8pm50t5MS!^@|8zEoSIt>*@qq
zuL4B|ogoV&${pR@a%_@^8h!(f(AWMwvtDyi7dvOh*q$L^z6YG${bblE@N_z4l2pxi
zNJbRUt%~r{A^pA+c%(JI5OTl1<oKO$rijiT;y96{FX^2S@{?{tBU#S*VHaN-E0Cz^
z8Y|MjD7yhD%^0Tj^tF#9gaPxs$)djz0mtLa=aS+N_rQ4P=aSoK5#`f&W&B1}`1qKr
z7@&bVhienex+O&4h1u&Ud~KJccP&I`4Zn??a{W<ks}9`C+=%{4qExAm6tsY1GYryI
z>QLl1vB^G-sfRn(_l0CTrDTc%=eW%WggVbU2e{4dnI1>%;6)ww|9EfTZ|h&pd(7{K
zJHwU^{Bmah%$nut9SL4=k1W&98eH)7BLb$`3XYqeRz5J&y+YT0|7SuWJew(;wZMcK
z?#`gK0rN!!M5Y2y%cUxA{ygPIKMe}ibm?S<$<m}pM!!8Xr1s=-Dwx~M?sE@G33@vT
z)_&LKEYqf@9>QPHfE}r=qKm|VQkJcv1zg*<cf-W^x(L>3hAm-y|K^Gr%ej8RMW73;
z+a)_6o)=}U*EjXs!RXi&3PGiLuuEEJ6q5YToqd`bssw&91@s~c)|Jt=q3Zs0P>;Xt
zztj=0FRon{(y-Kp6H<6#`b7l3_{`ON0=hUM85GG{Yw#|l$MMN8M-WcMZ2+9S57R$h
zl)V@*r1i|!6O6wKwxy%}DWTi!fuJ=N<8PaSKOa`Mw0z-1fO8&+rIZcKt%fc{g#Q&n
z4=YE6s0Cq-Kz~0-(H5pXvWdGOe&GMMI2h(tj;CLl?PM`eV&7PnD{tt&bBm=hk+aeI
zyzjGKa-ZJe_9FJ%U(&wSn@eVQF1H)e9b~WPKw2}-lsz2=XM0F(vcR@F`@dHJ>GRG=
zr66|+w>{)^g=D7>t$b+COHTvUJgC3~RW~BSWLeYDlme>0lb$b=RGieY38V9=C>>Jn
zgo3UzsuBu~Rs?A8GADRMaBY;o4im{x5Db&}q9Ciea->nsCl&f2sl3v1eT=WsY>L3{
z`Z-h&xh5+DDB5h>Bh^?fB;w`<3SUuUybco-qaE#Oa^FNb5pF?*K3v0QNHu(iq+dy|
zzfEXdy(VcpRE0)*2q&eb5nA1XNWE;^GYH7f8I?$^j&1<P!^;RPDSNYh5g00Ict6*4
zm>(oj#t4)Hl)fT*QeK7>_O9iJQ*`1mqffg`WnG7Ff`b}D4n7vl>%MvQkv4z^kfJ5*
z=SRYn;)510L(q(k5g$xahb7wHeSdB>EsOS3@iOy{*T2vD;e2RKLGeD?sB5Oo;OsOA
zcT+|@=0@U7GUzUXRH7G%XI9tLxts*OVCp3G$#1uNe?$4%6+`z6V(_=M)L5_raggqQ
z9J6%H2RS|rjIU3~$4z*H!AGcC9F$i)=vB*}a9SD>l+{;3jl({r=g9bUhsVCxWSOgg
zBK%#2$>Rx^Ka_NC7(5`%i-dAi$=++YZFaGySa38bmZ$`U0%Nfzgdg*(Ygm!9%e_1E
z;y7G^pM_Fp61+jOao11EQgz^IqDaXCa3iWctK3u2b@vR6f1U430P`IaJMG<meR>o8
zPO$r5+}@V2Et%gO-!4B$k!ngky?J5HmoRc%Nbg8!RDL`6P~}JZ`$potLd{uu=Fr{w
zvA`cp(--nH2KU@nrYun+1+`iDxRW~%JA69tagB5|pV%|i%t7zMG$q>vG2Iy{4nPU4
z#=MC@yvTa=JtYL7{OL?NZ6WP?MV)BBtQ3`tIVp_emcDb{$org@0c_a%76;_q4qSMZ
z=G2bfULveza-Kp(Bot=(J{w^ye|>KcZLacV^xFA+cvixm-!0{Lp1&8z@-Ownzxr<7
z;<s&HbRuX<o#|pen;<7y2|I2(nJpZ)z-ud3kQ}P!aLnhP`j7GvY_)KE)f<o&VZa~M
zcbo)YsKqQK$7Pje=JBM>(AB8JXIZP93B+sTW|a#Fo$5$oe_dfSo=N9|LqWDUH`C8Y
zHx~{%JYOHTBzP7{XvEOvfK!4W&Aml>P1SR}JF6)z8w7C6=Z_d7283lfDeorcF}p_Q
ze^xmb@=vyMTH|(8?;cTgoLqF^z_*@M01>3z|C}lPHXHVs?R!$P>utN5)=TpDI;<ss
zO#ksVh@RX+ZAOB}ui}UT!AllOvbCE-`{Nw-3qDumG8!g6P{;0D)gbotC;CImQDQ}A
z_-Av6S!h~Z+ctOzk*qXu`5TKT`yzPnQ-DWYx6*)xw}Lnm|ET)l5a#G&M0cUJRq+F-
zCm=qXp=@M|<1pY?;Woc*o*?TYc2H2vO8_qW><0PX?pdAz{|Eho3592O((Y<ZxEycO
zZ>t_%rq0|etyhlf2jSjxAdAl*x$px<d%0Z_^Zx>RjOo*GZo;a^T*9Xt5xi3|^Z}z7
zL6m2cVfvv0lp9?#0Q(|$=$gHshV9PH@353Np#5i*nAtx0bHplNrY)&(Uwq+rnfx)V
zobhLlzVf`tDHz{3fKCLSJNZTPFl&M7rnB`A5S|8_*R`S1$T$Np?WvhNj2*lS#x;Mg
z>d5Sl!!brAGSj_nY3;<RY}v(s;fk~;_hj7oPVuj=O0@g`UNzF6hvV}o7QMHP9F?iH
z_>D@kinG@xP;r&;(C`qC^H$_jx9r~{mZGum)xVdGSUJ(V(r=C_5ubc96nJRM{CY-<
zN9*6lIfVtiPZh#fS=D6;q)`>-?q`n?LzkhqX43d#!D_@hr5QRPwE4uj+{dz6Jy1=Y
zOwG@P*IpQ&W9p8RBL98Zbp41r$|~D!lG+Xi$q>I~dI6S7?q3BsFMOrKhD7Jp#QJbi
zS*?rNutwhsTM&Dz|NY=kX`(F^7#f`e+=H}0Lh^bGJQCQ^R%!09MxO-0`9NQgQT!o>
z27G@a8dEo@5{0Q;Ev2c9q=XgSqt`UJu?TgY1N5A^p<l;3FEGU_QiiOvjsn^p`03&?
z`YTygOrC9^T&Jtu&=w@;O6M)VHdg?%Q^9Yy`F@I^TKeT4EQ8->UAvNx&B8$^L{e8r
zn){e+#fWrho%pvG=GVLLDz8X*C&~k^%<S6}m+sM~J6pT*hy3H#6OVP{#lrZR8lI}l
zF}0%swHVx?jatPu$O+`k<^>Un2;ZY1iK^eS){E<>TP?I?=mR$Sh_MJY1B(9VS%9=D
zJa6^n9TtX{+Zod0!B`aA<&Y&Bf8A~UIURiYPK_R)-fb7foxeMEo$zRf0&R+*#o#do
zaXPJdv(Q@n<-E&nlu%%JN5OyCmjHqJ-@&@&d?X``ajU+8(iZNQXJLBw=)>+ZW3EY)
zb4zQ3`~mvyhbkXA-Oii7rEmLL2>M~LC}X{D*sh@aNct(I0z}2{=2Mtl?`~*Br9Bup
zdZaN}8nTk>_KD6$uZy4wcWlt!@NpdJgLvYZNNoWgS=dpkefs?KZU`({RHiie%pFfr
zX2@k~C*GbJukZRjj>8Xv!4wp#T$=TXw*85{IJSTAHt~vU@on3tP&?wTo3}>*<F3TK
z$}nQG;lUpxZqZR~2*@=QZMr^_pusW^cabj!2#Sj?N<g=r2An##C0|w~=s)tg7Kn(c
z7^P+qv=H+8e(7UtG8p#D=^Bq=a-@tXFxN)4@do;LgS&HM^hI>E3GVPlDXX$$IO^x1
z{a7-hWHzs8>6Aaj?`pyps)7~NzT5wypBF=PA0w0)a-dbo?(NgY$O|~(TfHq6+Bk&W
z`3G4d{~H2jb+?*7J)8~)&~#l<3fU)c4-MNoK~uS&!&wxJ?}KJ4ERgm|<ig%oa(;n0
z!&QI0>1Fe2NK-9lu=Wx)xkn2nX=Rol5iXopFA5q-%<ID2+hz+Uchb5tJ1@2ZSzAVP
zC=VgUNRzF$PD9gVXM~yT6syw+w~|MeJ6JLqKjY^c9r%gclEdCvTL0`K?>d545qSiF
z#9uLyh-wWCDEeNP*qyq7;DY~CT8M$^BSzc$I(OgaT`tg!KE{vskJrEJ1}JU5^-&dl
z<TZUT^o%ZbuaXQg+Ig~XYmrR^_aqN6Q-)+hUoi(dgO(Vm-XK`x&VEqS)lPjkJWdrP
zuIX4tI6_lWx&v4#iIP^nIIk%e?w=JwK3zqZQQ;ddb-?RK{!5=}Layr>UQe+jGO#+&
z%;X$-Nr90iHbxHgk+Q7^t+bHq6w<$vpWlm&W=9RYAq{ElXzGqb&_*CKoAkZvGuYI-
z>BP_!e|C78X4B&VDn>S4wVN%+u-L_<oNg;aQ<kpCoNPp5KJb}h(J17G_v6~HAc5O~
z7!^6y-R3zawfxku){GO9<?Fw#8Q^A+%vb=sbt|sZ-HlWfdevLm_H3d3_2+cK=Oc{{
z%r;hdm@93b*U3~;zMv-fct<@N%4`B%XHl<&9{xOo(so4))ByV|>jA~B`Sje#MYAs>
z$ZH)w5qO`9&XWfbV5VW<AXd3z?90438*!br*Q&JJntG)_;c0P4YnbSZ(>V1Xj(6Zd
zZ;PNYnnC9}EQ*Tmk=U898m4zUmlXYVm)DHo4N^(scCH(eZD`}{UWEvze{b=2)=esw
z(JY-AO>Mm#LW_5J@w<++)MRK$NDhcW<}yD>eD{wp`<G$I=#J4J6oOt-5rcfz1Gt@c
zFt2-!j^2t~mFQX<jNEN&w@OMRYTmmwk&T@>J7%bq9WY_i{Q#a6pzHZrtxw)csRO`}
zSL$V$)m?Fan)Yhjb%9Nh8vf&%f-8I<MxcpHNuYuKDTgNe2}de=a80XO=8822JifEm
z$$~pLfhoX_4lPNH{No6lk*12UB}*M)l5D_!oUvKimXY3s?PoE&dDHf5q{5Ux+BQoj
zD-I4cx<^o|&9kr5c@yU8^ow(&!HdoAH}3gk%9EBm#jd&!jpJY=N2WTA7GV`8MadQu
znJim{!Zy&4$=RBDjnIh!#@g>;t_pQ`BoJyA@SHczip5N{*!O@m#Ou3`M#a#yo(&!&
z$0$X`Z8YxA&F$OA+We%X<=dE!!T-!r)+f|{mwmdGrm2w|OfeT$6p)gB$zyj@c<#OY
zLw4)41V_Mwk~Q+Bij)!7gf-o^Ou5+3$WcyFVC+6_+|hFi(vK6_5VdQ%OefED$kvPu
z0X5r%Q$)l!Y5St&rgxjtM55eTj8mm22q(ev`yV)ViziuZEB|P9Q_$9MBjC$nicpVx
zsZnagE<hYS(J+{7{oWG>42ZW1qV(+VvvN_rhqRjCxCX@{d%etD4dP(W-(md;BSLP0
zfkbs1;o_jl_@wjBHX4*gc36Cn#mW`e&<uBZ*k@&xxGpBv{RPK7>l~#^i#?JYxa=fw
zaItapQ+CMe9Cd|3qmAxpyRg7H(q5&{-r5b+Gkg7=gAcspc}@@n`Vycq9Q2-gVtx$t
zchE$!ARPhL&_)u2d`nD;C$|HQW|nGkaZAPU)J8p;Fsf}auk^>zI&5o4Wa;pt{$x3N
zIZ#%&`pqrfs(2=LLpn;)&G#XPN(0yTt}kQL3HEIKc<~F~+%fr|{@K^ta!~<oo0zMi
zWd@ZB4IR~sv`YI4w#^P#m>ftt(i{OCPEHa^6SE=cPWA=w{k9G&hxWd-ubFSK(W5>R
zm?904LVgO$P#GOnEi1<t`(R_Zx<2yT#~hm~bma*jP6Q(seq22xsH!4pt~dksX4>h)
zU4^X17kj=kpmZ_1dZsIPaQKZ?8}b>;);Zxw4d{|0y-pRoQM}}`=op$O<mp*=gM|A?
z#LTrHdEIMcavKg}O8d&J6aBi)6AH#XDfXE(p8xyA%~X3ml2`|FjHHYjrdBF{t$K5=
zVw~Q`Dcln4$uZm^?v^pd>3q-=T557ef^q5GZ_P`OmW}EcSlxJF$Lo&PFXsGC{9}pi
zdlU@s1TplQn}pni!8D#=Ja9~UkO(Bo1iIz1Sl$~=TzPg5^g?ldgII2`Cz+3%P}2F1
zh~tu|eC*1u(yCjCFw}x$*`I3UI5WmSEfOsgajw#Q;C&-BQdQHun|t{dIjA|3^aaK7
z%-no?7(tNFzbZN6J>vZXDC*zXEsJb&GaX-Bv$SD{1T4Nqjcp<NTHnLW*v?@kN0i<^
zsv<Nv^0Cjp%%2{s&^<r!gt3G-0fnc2e@Y$15`)6`;dOfvfZ{HUS803>is(cx<7G1A
zq~99EIqnxd`EY7+%B28tE{xicY>uqIIBp2%IB}`3t{adwsq`q&HFTLUYP2qQIqdm_
zSl<9qMVD=L!MzvASIlROb#c~e9JqAFU5+AOB5d4bb*p?rXDO*_IEa}Fg#dlGo)u3g
zk8yz+m+d5GzLRMG%p)cR6La4m+O>@wkbjeX=<|W7Q_r6sGGT5Pnq5va=wz$Z`-Y4a
zvG$(U34th?>v8ZMiDf=M(E?hrTNP-%S&g5uHb}DDlki6hq8?P|C}tuXna}h~Gja+M
zJ^|?oReEtYuG!FX3IR%#D3tE)xf54TT{RStstHJKKR;r*yc(HKN9Y<dfA}NR_fuM&
zYKg`s5!AhF)j+l*>af1aU2+k|A|9C#ciQ_azt_a<j->5+)ah!Q<nK!{wA*81_C!LJ
zPgMwWs~$E%cLKlp1%rEVeD>jRbKwnTCGj=wq6Ns)EpN!o{QzA&cgsq@<h!GzfeFV|
z?Tk<f49E=Q2JhG$aoIfHX&0v-mTW;I#&QhH{K%Hyt>oebyZS^)%_>?bC2XR28&<Ih
z%^PS($ORZSc=apMBe6N_{+Z=R_$#w_*ewQr*9ZtD+j~N_IiyOT?hT$a00w=+$(lHz
zi8%~DrXm)0<Td0zU!ra!GCa-&tJm#KiemN&p3z;X+YCnAry>^LepfV0ii58+xP5;)
zdht^5A8mBD-yE(B1s>^FQrxD@H;y+{i#8R_N~Cr9(!iEoxzV~Ms3KBC(VI(GJSazv
zfsq3UOk*c0gI<=@IIU$K*75Itt_D>bF5KV`R!wm>%e}MOrSqi4NC9%5zQ(A!XyGkA
z;K&ja5=z#m{o};!D)ZXy%ZK~$K7RUOR|Q!`<@bj4TOPw7)Kqjf8ipQ^L>2^ua@Y20
zWs=N?@$-UqL;|lEJKvhS{UfuNvEVDDff8If?L4nbNX9G?{z&m$-Vh%!$hfH8zYd^!
zkH*sQHME8e<%Eey`a=Xan-@uMBt{Bi_yhHK1;}^KWSdyd!<!pvF@aCg*Y!O+b6+*A
zKB6ME0#QJKqmE#$$s>O(ULbo{7QQrE-Jbry-}bKYon9+lBpLy%cOMAEe~e+zYp8~J
z)B3B1;M=g3u*=DW9H?6C@5E2&Yin@myImdV1s-PvR&=cWtM=!64ky}a><)}_R)t+i
zwQyTuwJ#xW2yoz-#P%hT0(<Yn9v<FH3+i4u<l=oP9o&6LLVTzyIgU2>PK&LwH58U!
z(9jd_3&k+_>P)_zmVGLwRb=X4twJzV!K<Z$X53~LQv?4RckIdTTaid3gmil}qQ#L5
z%Pa<<8RNALS#*V1ent6g)w^d-P1f~cD!G8}T+k4?W>Oe+o_2kb;zP)FVIkuSG0E4l
zy$+fpegALjLJmFs3W5artU$M{tw+S{?{)eluCK<TPt{#l5e#j@V$lX<aQj@R4;0l<
z!0BWbX>pMiZAhhL(FnPHLGbR1U2T0#XxqT}{Z-ex+c{CqmYd-Ozv^c$5uER1tIE*@
zhQYMMe2FYn5w$92&~7qiwMo~-Y7VZFr8MKGs$}Vf)fixz<C>D=r@k?C6-ktmn&ffm
z0I#53&?^O{lUPeN0V(r7thwLsd&Hop8bMQ$q(t&BH7TBOh$nEsJ6<P8o~hF>_ve))
zl7jCSk7LfQcPT}Jpz<|eQ=Z*58>8Ip4GGgM|M>|RaI6r^-SES1sdo!`O*D{l7R$<-
zL8jMB3Zwt@ER)R1KVUdOaP~o1`J?u^b#t(FpM)o$sb=uv{i-2J4p(Ga)9%_+k2)#@
zmAuMiKhkDE;k@=6^PXI_n=cg(yV*IrJ(4*8nwHF)xBeAl$t9pm7cTH0f$Gkv0whC#
zQ$U#hqQ7OI>7l1eL7*xnTM74SaA0)D-oNY%@!cI+jWt-kP<c7L=2r$@imZG81WZpD
z()fIerB;?9&Qs*=!UAAO0m^MQNo2mZk->CwcK_`hbiw0^1eopD<h0+Qh`0-yC0*++
z+$xpwmc#2O3DQp}am;8y)z9c{A{hD<vq{zu{JgG0X15g?h^JyaL)nuN$ud|NT2p))
z`YNOOPiQ|bV1WZf32>^Ji~P(0v&yUAQB97FpEjj+P_wvvXmYUnq1$!PXA-@?|0}OM
zKWHR>hScnz|4>&pZPK@G<e|nI4z$7~$=ALiN*{v0oyWDpq*Yn^znYx`E$SuIf}W08
zc@P15=?dTF_YQ*5S`hp)XbM{r`{lp=rj3%8UVCMcdf)U!o0?9YmU~N~&E9c|XE5Eo
z62K8*^z3}6<C4qd7i%en9nZ7%`7Vfq-g4d}P>s`P6~a<&!q5Jc)p(`4+P|^;V}OLW
z=y#a?t4%6O7Lu_qi|(Q>>G36sS^4|ifqR%&k)&okFWKp~d^3^1adUCTDP>=Rt48qe
zPWNz7>!Pjqy)!K1uQurTQg(B})CE;g#M|_|!J5@m#*Qf`r_Hd`)McO9Lh<F_J&!Vl
z$auS!j~vXnB1WN0(@%|$LUBpF-F{1rjSZSo-b=aL=lWw{=G{hQqtsPu#xN@u^_dCf
zqyk*p`#iYT%wYh${Rx^_nD|8u?E3f5;<*i_?*Bp4Ir!K4Ja0cXPHZQQ+n}-Sq_N%D
zwi`9J?Z&q4#^#A}V(UpizvufO%xmx6nVoCj*WAtm1+`yBhTG++(vt;wwl=t1x|iNA
z)_{<AO!Os?KGDUCfyj(tp=@lu+}4q(OMkj9|Lq?zFny0J`l}H2PH^=q9o_GXKt1mK
z7ZRq$X~1G5A>3lG3OLR$X|{Bvs~fSD9>Dq<%Cl0|wKNGer6@1b%a!v>ysV|P^sj?e
zWB7bwDiWYZyUZ{Ndcp!}>7L6#MW;b6B<uW(v=Rp8hrf_JrAz-2bL<o5yu}fcZ}a0j
z>dWp5-f>9_rK$)e?5LP7GcAp&BUSU=p)nQ{7o`O!`9To&5cS(zr|&ub=1tSXQN*`@
zA`Z?NG_U;<r2FeLkY|@cv1mHZ^h#w=>pB`1I-F^y5w``<aBp^so#-!X2bPTAB$h)m
zn7;tZmx(<Xr<F2fAyt1AqGCECmsQMj=+FaDzPAg?t3&PC`n$boli$>?*zpusU2?QR
z>MEkv<D)(YWTzwcHZ{B9JSR*?_nMP77<3-LH`@v(f?HpR?x(Q)d8n-3x{&$S%)waE
zV~;B;j&zgfk*iB&->#tiKwz1`e&+x3_AFx_gVY3HC;!#C|LTgFxa)<?=juNNqQ?ex
zJFO&V<$h2iNtawi;Pm2KF-QF*f$K3X?_N?@#~0ZC6KF7PhTvW)1n;w>gaf%Vh+nPj
z@rf4(b%O(eC*x8pH_JtmLd4_x#w>w9@xQO05K_E2B|vY*jzag*t^ZJPhOIzK+aeaO
zR6vM@c!j%`%`eB?W|nh#c5qL)f*x8nYaxt!*g703xPYtKvlB3d{mu0UCw0MMNBQMt
z7g*mg3O7ds(MZMn#yZ%Y0Sc-|WOK!0Pcy)^bkXqu{pot_LxjKwhs$B(b-o4oj-UF{
zS8cVRv0V#6Rq<OjjaI~X1z^u#10cAu@iu#Dw<q02&>_aMFR9YEmQ@M~*z41JH&N<;
z`gxo+M#T9l2oPxTI!rRVp$W5cpHeOV`JLi+Arh#P&q~%jAGM#Vtc3AQb~ctckQzw0
zEjh3YyjmU*aSI*wsn<pui8iF{FTjSvGa8oWgrYK6RKqs_!Wjopg2=%fWDJVID6ZPh
z&ukun)gQn%uutynlk5Iey7e5U=>d~V*N(*MBkZfoiUoXXvtaR=w(f!F)xkk<^&cYE
z@NAq)`Cy`ly)||0BN5m-U}!@a*z3rw34Xt^6gvGCh0P*%8W2+JN^6>iRKjqNUf98s
z4>=+nyRO#jW93r~egrN+fMOAbqLoO<!O@j-!*~eg(_xc0UmjB>^A#)>su>a}S!8!9
zbA2>;ZE-ca5)ZEAq&AVymky`0`}^Ixg>k@k>QSP=eof;~rQC3K`qmX390c^J3bTcp
z=vJnpUJ;3G-bG{m{0MH3GenUb84fYi-6{8;fXJssqbAD4P2>#occ?Hp?{J3<DpLDc
z51m%ET&Bczf<vWGnyc=bz6`&ZPO5g2A<824=X$vx$t023Q{E2MhgXE`ppshXY`sP<
z7fu9y<y?I@$K9~#pBr*;aUgDnnCJG(83=iH(DcJIF5FI(*5owX;IpUXczZ%HzzRZS
zTErb6x@<lHKE8zf=E*YlWW2NQ*_n3%2YlX=ZFRkYR$XWce0TGiAI9~OQTVSnfr#m~
z_a~kiD^v45QN?v4vR}SH2Rzwgk^<7+rj+U>*$33L#B$bF-nz;)|H6T?SNl4GV;|ut
z&adXHh$E1(!{Q5m>vkY9CD7_I>kRw`V}QqCJw{VU7lG}q`zntqU*i(vr}B_3>nsUH
zTkWBQ>Ze|BfG%Ra;)@F}cfxx)BqdqH$u<6rG5KXB9(QimX7?W2KOsSx5Qy7-zPVK#
z;s0syX<@rsT<T(*(pJ9Xr<<wdMOI%VqX}w=$2ph|rrRjJ4(T{C;jsbnrW_!0X(Af0
zplsjU#b8k?c4%Nz&|cuhH_30a{~E}pA`nD4k?APZ^hLRrN<*zEU48)KL_;O-Q7=DS
zJ3}~ZqK>bjq}9*N_0HoR+q?)@g+^=z4T@Tt(f95~Qd>S5yP^gb6b8gkjgnm!x-aWD
zP$1BVWtjE9xoyOJ^W2VbM*D|rHGcthoKO8=fHuq$hGL=2BaTKHm(Ct+^8A4n*#)|~
z){o_R2U=L4Y{r~?FM-Ck(9c4PF{q5FxgqIGNgCt~D_^CNA`G{Jp0PHk+M=oo5K{=S
z-(+5U*73lR2gIJ+7sxs_Pcmxu_r{Bmgnsh*aK$oR%X}1_-DUH(f2Nof3GREn^+o0T
zRSX#BS5o06u-RG0<d#0$!r0`;QEsmTLJ%jl-9J3fK4SMdiNIK5m8&=g>|mz$Yl?$N
z+LVVg;VMWc;F{mB6z0hzVd@2`hc&?d#*n=p?vzRHucJm|5AX0MgU>4-Moz3OrCSHc
zmV?qZ?$JEC4U_RN-WAMZrGI?GQ$eWUEpBd77dp9-y)BfRltx=KDYS_!TNircqXfG0
z$jgkIGX+A{Qo~ogMSL%)=BI~Qxx7Byp4C73l|+!Zi+5O-0hgiecS^RO_7yAj>SOYM
zD6%b|_e*&<(X?(`qS~$No=2_PD{G5aKB&a%zI5|Y%#)&qDxL^>#k`wG#KkV4ePve;
zRfc)!K;FI7w4LS?1%?#KWJ5hlP3w%lbAb^mpb{K5z%kz0Y||f6Z=z%Wgsa2-%h@3r
zsAz(OVs1;QbfJGieT(IPsSdHq9gG(DvsK`SD$@>31Y^X<h_E7`WrruqD7gY#bm&vD
zxxak+1Xj60oo{*_PfZ-hM*qdj*m1XDrz>jOaxULzf3ASKgWK=M__XTfSc914-aIm>
zRYq+h@S8J^Bo;!{%$oxGu;v2wL=CCh3$^mGh1)KuhF=^WQ_j^Su2y}&c%^-<j`%o_
z{Jzw!N0rxzP4;)UAinqQTKfxU^6@lNLXK+mN*~wFz`2G8(p3&^iB!H!SrCNXZ+}Vy
z%;Co{v*eh;k_BTX&oTPKimp`XO8-#3dw`zT;o-^u5BA@?-h5LtO`TB_%VaB^&MJfk
z)>&Akjh+(IP>URnlcw4A`BTT=LGP+uF*HIb$856~UEol6XeryIkM-H8o6U;`Kq4fN
z0)g7YsMHNsR0gY}D0wj701kVt(PA<)+}2Bov+^rG20H>3u18i~H%>C_7s>+dd|D->
zdG@oA6bH0>N#723b3-N!R%XEPfHA=!UxiPIZGv(Nc-kdb&T%wiGjMk$q7C=IN`h!M
zzEZY^QWZ}NhT7Q3a@Z+pq8G+hW<<!|6J4V}#dyl(+PqSHA(ZE?g3!Q)pn)57tFWa@
zQBPF1l`1(w^pI2#s}IbtOEFu!jlp{@{t42N5;Y%8X*Ac(?ym3<lq8=Z(zrzepyy@z
z{G!yxr1ECOJCEE-`&KtJGhop{ds=H6JYcUQYhj?;9cVFjlsAsKfWyp9wRT7adM5!Q
zMMo5Be7=wNF@_K<**R<7A@xku*yev_*Ht%aO>2Q*5N0JVt^jw?3o5|+iUh~P&Qor~
zH4@|VG6?=R`FGZ<nTScN+B~C!LsdM52czV6m5Xfy?-x1G`p!QaO1TY0F#&g7wrKzk
z9@;5YCrLNyWl2flNLH=DMm#_&Qth)sOlyZg?OacVx3(LP#jQ~O4|bv?v)$(N51umg
zy8B;qW;S~kL8aUnGp8I?J9~SgIFSExg4NF0KK)KVN8q>9598|R!gGHm@_xR`gs4lA
zq6WKUn}DAoMQqs+whYCP7&)jjQUP{0D3m;#gk`BxInA&vhRjp|Cvqd1;oklw-izZ4
z8bl?_+Wrz*)ps4V2GQBfXQ=W##lH-Kdq0+E_XUyO5Ci6v<KyGm_^VSX@brH@dZw7G
z+U|j*cMAKA$ah|33MZRKuo=V4m#ToTS01`Z|JJiI=;Ar>0w0Q5NvRiLv(lOA*&b7k
zV=I#a0*pu5Ca-O#9R(|b&c9!Zuo0W>vW69N;xAzZRWj4yR;@ve^YWUn7@IuYWTr)T
z-Tq!EwvfmCRu@b&JUcRIy<?bLDOgt)P2j3T%rGR&bu6ScI>8rZ2=}wg9Fk!THmo2n
zxMzvpIr?mh1UJG+F<Ssu>ZC;mx&6>|_L}&hqOV2@qWd6VX**&{3LyE}Yps*J@0r95
zAowgw@1P$a_l;uFB&pqK*=EOwsR%jt9$PPrG57b!4WbBl<hmhh>22NUa49jtNx{l&
zg-8orTuf7vh306kB&VJgR)rc8WmN2Nw=aAA=tRsymN^Rs{W9|+7wCZQF`N&15ZvU4
zg7&Eb@f8I#FTXseyTkVl=S>X^rzo>Mkqa@<o|QE4GM9b3pQa#*phnyiJ3w#wsCsdj
zUh#5P{I6`mfV$2>7NFU3A9nLR`j&PDoYob@uz*<)v%eJW(|oawizEKE_{%F7#LtLU
zOd@}_4;eE?qa<KFgevY+t^(pD{0BX*Z_{(Is<oZzbz~Og>()3jYcsl7EljGi5;{-1
z2sR=W{rBkz9T5HFnW%-uF+GJP&y0@l-WGV-KWb?Zb%sJMn!I^8Iu9e{%gKyOaxzqa
z*l!)4(vpIR!Crh7jb8iq>kd08ne>PM3wbJsD<;GK)aY&5ZGXq!uF5JE$2^;y)2MM!
zXgLCdxxCpe>+5xLpa85eYVCCR$Z#QOQmU#t;%T08+qc`{nT1~3ZF8X{7Z?YH3+3Wi
zma%y4of7^x%qp?hefj1=C3;xeCwW||fRu#7k>FR>t95Aow#cNN?r0{F|D`?qMGCO|
z#^XR$#Ek_C!bbSg<6*{QJGL{DOI&^@&#BSj&C#r1LKu2V44Ko-8^vr4Pxqhqsjo5s
z=!jWW)!&rNpie~XYqxiQnAf+CyF!%)5tUs{P%%|#DD!1;thzdQI91^x!X^NZDfu~V
zOge)oqO~mf@X<*%Zf*1D=2~H>a?vN>EpT=SRm;Piz0|%E+syUsYG7OM1X%wNzq2`J
zBM&2;Nbe*GDfu}S7M$}7b8hd8_8mU$`I9$L*oKdrxKhk$fCouRss_R~hc)8){S4Rq
zHjQbE%#9n?Lz-kx4Kb64WI(3Y=T7LKHKXJE&N}<K-X(weHTHap)!8F#ZMoq&Gw;Uc
zPys8KZyM&BH-k1edTkpJffI3MAZ4Kq48$m}&BHI#9QBLi0Z&;o@0%4s%br|k(t<`;
z%Q}Kr%%GsEk0v@x<2tQlDaa7ch*$^5E7x>#C|B8_HjjT6;UVkcOLsT%PhU+o$HZ;E
zQJKQ`L>|g0h@8>%$p$mgn|N-BAz*B=Cc57LSOC6@t;d*HnrEc<(l)~X$^_iq4_bq(
z^;FYxhWUEx)w%Ks6^m)B)?rKf$mX*9hn1lzba2AwEJ)dl9|M;p*mu15*>1BjvVOOK
zBJ0CsDMwVvq}Icq1J-nBRLn$Y!(}}k&9~3_PI1$fu+yl+@9?#f#G`7Qi;t^MVl7YC
zk0>$eXr135s33+D|1RO$1dVPb0JJe+bI|8rG%XN7Wm5e)t!Y9wetdj<Sp>}gYzXdU
zz}vm=Dr2?i4FJ1L)5#{BR#$f@`TfVqFnjMo_7etogr71Gy}Jl$hu7#Fv`~!E9Zs`g
z&7zUAz2im?{f^XBF%YhL-EV)mCzCO;ZHCFFjSr2<-UhK-xLhG<%%IaIB=sOnIk;L+
z&4z97g`-3x1t~})d=YtlSNVSaoS~7{nBC#=1B>K=VFfR(V*l^PEoSfNSy%f~FGl3h
z=DI7J8uOxOc+O$hk7A5JF#~R^hQvb!J5yXW8EeCwef4yD*Wz{ikZSG@N71DW?+A9s
z#D2N4=YNfCoAb(TaQ=%iW|zQYCV;7GN3_Q+1!Aqd$dT6;*1m6+9c_IS38CIc-Yi@K
zYFb;-YZHG(=F7o&81|S~4o+KW(V*H*2AkH<sWQZW_bFOJlu(CG=jgp;^(AXre+km#
zd?uA(kE$_qrgahloGk{?J<(_2yR#%y=@>EwOoiXQKc-gCC8a-*Hus12)*`r|dsOrw
zKlAr5{1lmW?{tppeIkdH*k@gtEzH}b*9SE>a&Lh%R1Z(Y9=|)Lrm>uZ)in3-M)+W!
z6wf8Z`>cgM&WzU?YVF@+Z*P=mQ-|Hw;6wXA>*l{EB^cd*4pMcpOSx|f?u=h`ML31?
zvH4jkpX&;WVfrCT=b#imj$kRd9T6MVsM^Twh6tWwYjui?rM-GAK<>pL?d)NpsjM@I
zR5~Fw8s+u*j~~Ywvi^{5$6C61EQYay{j%<5v5(8*sDkW-4Mu;86V8a=<x{#%-A4zB
z*(!i-6{le)E^mv|NO}d>Ja{$#m{gSY(E$#q@DHyC%U%2fCHSu(ahEn82(wDpHL+Jk
z(J@|saQ8+Jnz!_2^qLz7sTW$N{pr*Lwp9YnO2W)0!G@0h=qEp>|8(V3uSnas6&eRC
z&_;t)JpArln_DHe?R68<Njp+qg1XH<jYb~C?`Du{eP~l2u*E4u*%wQWhc!!lh}Tue
zJbR<{=M4>$=#j7f5}#1bTjAZ07bfC8wPd3obCb_Z>ejB<^Lo6z@i){zY|obLu}bYC
ze}|iXnD*Axn{0FK=A`*<vdP67{})~Cq=h6(DhEpZP)B>*VUO(BWE3!?Q_hjs5QtQI
zABJ!lBwyO~#(`ezjY+o{-AH}b`+<Acc*w4E*)kd~TqwyL0z2Zn#}~ql*}t8r{tR)f
zWtzg_OGpidNJc2Pq;@F!dzqR#;akdxWARzME#1c3wC%DNxDgy&4G-V`#kQ}Ys|kUO
z*xq`fQge=zU7#E(Xu-?$?X{LAn{n%_knC&6ZDRH{wv6_%cVzjr&yk}>6$6mpBet=K
z&ZW{5*ukY9%O~|LJD)`Mc;I9>ox>G5)SLhT3>&Z2uE`wd7r)E`P0W&&DRa%#HeBrl
zM~?)Nh=kp3KTMY_*ln%pYeE_7I%<>24#>URuT6>u{Ijpxj}Lrk?wG8tZS?rDl56F>
zX(6diy)Azi&{I7y{(CjZ>i+^mtiF>?4aOa8IW2xwaPs{OCx-SfcRo$uvd~^*v!v_I
zv}jW64|;}LqK7%=gD(^CF~g0*dL9i~&SOqWP4(FE=!{#(D35wZ%nc;o4>P>fv_X$)
zvN=q{Kh~;=G)q=s<`#}Lz6=*61{$>?eLB*9X+wR^61WK*)w?{+_b$yQA4S?LPC3|W
z{e5VVj2=NVeG(Sgi|g*bVQmrN^?ed=_@Ltwry(k336Cl^!38vRl3!xUTln=JZyQ{L
zdZx1Nog-<jb|Y`XQD%#$|DHGLD&6F4-IVHjUm;Nr#zdARkbu+`L!RSo9@GQ?GmF(9
zO}qN8LP$h}d}{KqZmr|P`wxyS_Wrgn8&hzuPm;w}^;l1xv+ETc5>W-w%G9)0Eq&W<
zt>{>Z>}yd#Q}3Ekhwe@luUKGMbWbe1n6VzRsl|GiC8b7REZ2<L@y2CP1j{`0Wf=3s
zUPWXDk3@`Bj<cWfh6Ba&l;=u)GjwF&O9O|7%^SLt%#7n-H5`@HPEZ}s$VS9t%2I)h
zj*j_pCW-Ukr?c8Vnn0TzmMTt4@)><Ki5(DsN#a^y*V>d%zjmmah_=%to9>4r)7~8t
zUKbJTT18S8YoX*M4w{U<&O!@Ek?F{=a?6IfoVx=9Qa)EZ{pDRg$$mw&VXO}AbYNmT
zJCI9+T9Kzc<5)30sxF&!VzB%1_pz6zJmP{XdFqF(Id6v*P=Uq7U@ADl1O3oF*%{Sz
zX*5|??AODHy|=Ts)4uS3Wq*$wOkx<=cP2AA9N=`_lhPAVC@2wWb5Yl*(?G4p(`-6g
zZ})q;ffS<@Dp!#8WUS5&ZjVJmlofH%)HwIXiHfQffWud|JxMvD$<GyfrEi7)SI(tw
zM4xFhkInbMvPF4ToVqB4UtR_~bMi`3eyJBRql-FceL8jW&2#M>vgT63+RmBYf+PwP
zaga|NGvnbLlN=ERM`p{$RfQNaYR`ec_v)&a6YTRrZwLGN?;WH6y!br`f|Gos0!#vm
zUE<5C%gYiPjs^JEy5bL!L6UOcujU!OlS+ujQrN<4MkSsHf_oNc*3n|p%h*Idlw~^;
z&lgs|9Bi0wNHnZI)PIa*NrhD>H60FH!-vPE&hVy$3^Mc@qhk+x?rIYhxk!O<U!39G
z>^_*wVxzkkpQ>8Uk#rdv&iG<U4!OeN^`s{_kM|xZ_EefWScivC{!ayk=P;Qj=y1o#
z3E%x1#6|qmgZYnSm%SSf*BV;(>CNLMPlnBDaQ1;B0l!L;?Ku6V`0LHiSBc&jUKsW}
zeg!O!!7{~wd;c5@rxmf9eZGp4HP@w$lEzBZO7BBwb4SugW~1BmfSN3khZed~SwFpi
z3}KlHJ4xQCWarjFXR|QTS>LXUeG_&P3OWQsILS!x$Ra0DEj=11X?8qYzg|dV!qZiV
zM0|<qdk?6q{9ozS>uYgniCb_@=lvt$BG4?jnX&XD33Ho!xK(n=zIc%;deCtqk<X=j
zJQ?r6bFss7g)T@0i~6#|zcvEmL1*XZ1bbN&5DyW`9&u%#in*|z;tD_GtTR?x-_Dq3
z-LszrqVSz=J6?;y3#XRwNRcT<5^MzP6?w_JXL2(|SG=|;Sb7uFmuM(b(}tP6u@bzw
zuZxEt_DdKve^$(E1IHRTc+#!&J^Rn8BL8a+sy15?s@v79EpRrKqfTi7!&cRb<8Q^_
z{RL@LsX|`Phik)yL|PF)ZI2y%@b7Du1XaK((Fm#MGKiE6G4X%@<f5J<JcGY?XJ8Sb
z=V@rN(UiP&u(m;t&7nxUYpI4G-IPAe50QWu_hTpkJ0lC~nVd#+qj~nIZPo1C^O>g4
z);0Lugy_w|V=h(1Q->ID#t8ej)O>g+eu1zmM`u`yZ$|9@l9T)HEJoRs$PZZpD<|yn
zk4F5=inC4<C#nMu<YVlYG1Gb~UkrAiN$6`hbl$o9;AtF4CSjSCHMJhng4W5O<WQQ6
z7`dAwN~=!kB|OY`MlO8it_tG!rkVZ=MUHL{8Pqf=fA&2Fn53=G?!<>Y(qW^{=tr6f
z%#1Gr=v=g|qfJ}bKNaneOk45#FVi_0S+`6K)x|{8s9C|4%C~0=W)78lbN@fm$4hE{
zUZj9NwwC6-;bfh8(;Tb$iRR5UXo<^=93e;k#mm$OJ|a$S^|wqcA0L;s8*G{~Xb^)<
zrus%mEvaf+(&1YdFhZm~e%=AMmj&%DGxb%oh&_7-Q)NTA&M-R>1_#uKY3^tyOx?M7
z0KKiV63Q%g3I3&zi1rH<mpST?Jlh^A!J#3)pRBKICn32Dxr^{~=Y2fjUFTgI@=ewM
zsFs?zzog1f`hVH=!uR!J_i=*xdEJAt`U}xCQeGX*WMZf?$#`wxog;60HG^t))bA}E
zWVh@Sf<~JXK(yEXbr*EjB1?5PCdj%0Wt~wqiWzNG9#S40$#!M~kU+4_LoS*ZWt$k*
zQgV2oY|r(V&R5T45B9s~x<x)Pp#5*er2}>XtHBR36fQ6qA%Fzhh!$*Oq{g*&7zr)n
zjhg~d0<Y3F!{9m(6LvyvEs|yV`qj-LxHg2Rw|8U=|GVOANy0~A#J{$n#l`+=cTlX9
zuLYt+RRB?#yEZ=y%LIBlflqmeuWYZq-wK)zHbiA7Sgl1_EOkucX2u9qT1npA)ApcN
z>uH(hBxJXfDiN9s?SW|NT8^@b>$L|Y>|K~U3Yrp_tk^)}5rO<uXV-*pCZpOptzdxN
zRRR+9WOWVY^nw~Moko=hwQbZXRP_vrm2vnG8&gx~3{Mi}YN7FG^qlB1*J(<}f7NO6
zuQ!|epL)0)H)$|E^sROOEH{_<+X4IPCO^kp*0(NpNY`|QL!XzH+Wj4m6!(NStmr#7
zdo%I`(9l~X-SUj>7Dyuj52YLAD{yi4n#%8AcGuBN^2faT*yTFG&>3b?VoFV<s}!*6
zh&o^_?bvanLxmwwuMyz16gcSRjiO&uq~?sD4`KLM&yri78IQ%2f8Yk4TkWPEwtU>I
z{9roVqanj}`*Rmmn4|u)t*#rjcseH073d5+wdqH*0jBSmMH251#hz(6=c->p9LxyU
zjNtI(L3)SQUT01(rPo34KJK(#73Y%(ORnlW-p4+}&pZHldON`1b6Ueo($S0Y$V~d@
z4Am78;%0KFtCdPH3$~{YO|@>5S@On7$h=q%0^W>o#$;yETI)+FfeBr=`6C2}h&P;>
z3H%C{N#U`p+^oiY^$y&YQSgCt_i!b6)Fm8ENgDs92kFN_YQMPOJH*R$y5EgS4XPhH
z4sbMp;i&#pV4f9!ePHrVl8}rK2E8Pg=J7;d&f6I5aMm2i_o8ZaTgA3(zoML4(bnS)
zYjNOhusa=YAKEMvFToueujMx?=wkgYWhI`XYZp*(si=7CeJrP7tIcqc6pm+UNBo=!
z4kfTgq)BQPcJ-hE9e6!Pp%hpH5NRFHNdR-#z{+fc2{RH-j#rI9Rs1CLqi?R}_e-t@
z7O0(>|C5uj-)9s)C^EVD<-s>ybu<~V^;H@j!cTkgswbDz#!{qwEmRp_zf$8e8q5<F
z5Swm#RSM2ln(+&ZRs78g%;jM{VjbQ3fy@JL&2lz;qat&avIJ*$t&i{<?pKEiHnTS9
zysL4Di~ri3%#J2<<AocNwL2vCm;16KZa_LlMNjCq|MaLBsERZm7dZk2l3Iu?z<F!N
zaNQ=`z$J72ou+6T7~@AMaD7ZNGx%R$r1gk1{ffBmv6NNIowZsm(+HwuY@aIj5-d6P
z(~B$UNubrQ<re!<89@&ePs$Cw@2l9f0<{m*#asW{P299_jlQMkQ$TK&E)5e=Vmg>Z
z*`oe-21SP|<g7Ns)=(G6i8TbCh8{g;+HtJIfb<4<1t-p@-svGD$Kpg9K(cSf9QVN7
z4q89LjY>+B1X1P*ogJGV&hXj9IBTC2(k&OJO=t0hLKcGk*B~h_&se8T-?dQ&WN44D
z!P?|}W~<iEMyEK3Ks5)*6>B<A`-4k8S{K)h234HhkI2U9tGi8jGj=8{P)A_ECtJCo
zY90KK?ZzxF<rRd;VF2Axizf~bdcXoIW#|C=uD$efN8EnPM$GbgnACV=-KKo5agP5;
z29jYHtGxH0-BC(&IlWaL^I9Ol7PTT@H2khLDrVNhg=9s{RS(SH(Hn|qabNx4LCb&K
zW6dE<8Kgn4*V>5Ww&ZL#WhMCH&`7Y*u{i8f!Wh$!bIWh#hJ9FzXV7e*D-kP%fX#u?
zdNmV#Ni`ZqMvlJM5>_=&B*puJ1{Ne+GkhMtLU;w3Xn8>k_AFJ^Zw1aw1y54oGPhK<
zzXh=ic0}+K9EuuJGB-4t=@l#qx-)K^jm)V@{ro(|1FaFFjwl(57!d0HoF0Za{Y1@u
z>vz?Bc~|Dd9(T`JydGjVe*e0uh+Tc3NBunKW^NQ-M5j$fZIP8e>4%^BPMqsFVE3et
zO0ZYcKrMXeFvcVGw$u`Yc{9OZ)v8uSuCAmnlPoMzgr=kwYC(T<mI|qBRQjBedMUtW
zZnDMEhIGPYyF_=%z~}?wpul(&b|Z7jVOJ5-3kO=gXR$^C`CUpev^-;8qE622m)nHE
zCwgTLFhi(|{P`YHHaA~fStM}2*z<8RpC8r_IY*0&<#?YYJYMNPI_N_ECn|>fy)Fw3
z`8;fdo;WR7Yl;)h%<r~g9|exfT9Z#rZ>NR-?4lsmpBq^graWVw48om|$0AAHAyn}}
z>n_9mIdm^nB;BRHsRzjgSSJ%a3z;@Z&;oi5_k~A(gXuN6_X1$=_UO7{BJp`bTW267
z2)FX|mqZ%BSQRNkWgU(I;bkIyeh_RPat0)#)UPHaSl=uQgD0Ji&dgZA?1N}Oc4zun
z-bnm-obDN-r-^|SpXS;K|4YrmTKRy>l|Gw&_VpeM1Gfj3t&Mbht$KsT22TzI7LtWd
z4{G<xEMLr3b-M=_u)&f1PODDV8Gr`i>pJt|yVkQ%K(p<W^FyZ_Y6jwBn3;HT*PJnm
za&?dQGbHCW71ucQXy>v1g-Va>lQD;U;;NMfoXt!OSt)hX&58?ZovJ+u>=!el8{$xU
ze&x#VC&|B=5A4HE^9^e;EtYBQ_?+;|l*D|TU+acMF~ie0A$a@j7p-!cQDU+<Z7Sbz
zPdEL|x>8D9{~-E*LYnrcyOy25QT<*8ly)Wx`C^0xv%__}TB;|xe52@X2%A&oNEVNk
zsIt=mI>>b(9}NeYa+eBn_403YzYO=IfB@Ck-jOe7Q`1{EmO}&C7fyF4h73%;`o`_u
zjtd~C?{(09+<!ndep^py3+lQMoKjE&=K;P9J~c`fNN8b!3ne2;09|rK<1Lbsit;4F
zhL=N%GWr9ek3vJj4Zxh0v{k$Yw&1SU<NCtkW!^A<;b+YMZWvc(&$JyE#uxorINze_
zGRuJ*bf~rQ;{jGH1zTkdDN^hSC<L|DUyfI*>^WACH8|cZ|HL}QRyV5mJ7DfK;E?Pg
zbCcvY*3l<i{GhPQC*mP^b*I?($l8Q798jX>vgPT@l&sVSFiWMIefj;;V6Z_M#VV06
zU_dq6Q-<@yO&pI0Uab-i9Ub$hRnuG1S1CC?aCsRNw$75LIdl({PROLfAaH!;pIjyq
z%pzRMmyjP%u+HEB{?mUz*qJN1eD(I(6KjieS$^Vd>r<4VYVmyM)k2%hiYrVL^d_!)
zp7l(+_UHjt^lYSeKIk=5Tr|swV{Ha?^W8{3kR{|;#^7AzWjPPO!yp>Q8w0Q^PT=BY
z)7fZCq1Np4^4=3X;^<_})B$a+HY#3m&&&eW{ygX(<`E*oQOK?R-J}|3z!up8a{jW%
zAt=D?x~pV8MbsDK3T-kjE;x)c?<hJ-UiPC(XQWuZqigv9i+>F>&Ukj~2A}>Vw$-E(
z;Y)h@@gMqsY!%q$<DCNVP~fSSb~vITA6f!>QB9yRo?d3HNv-{g7q_A<RHc@RV68$6
zN9`E^t>4$@Ui90y+KD+RoFWdJR&u^pUC;OwKdcKPTO4P{qg6MH56aw*q&z>n#CZ3s
zxL@HaRY*DYIVozTBPz&CgPU-j3!ctj{$ii>#ACVdlF}iw5xK=hzg@X->F?xrVP4%k
z#O?)enf&7XhR|IL)$R(M#TS0+66(j}VP7qM@6Rkr`ntD}GXN{_F0}4(HC3!jLjO4d
zTy+5N6cfM#JQ-i2>RC;Qz)uKJw0@2~j#8~uFcgS~0AcA5{wxnQT0Hzi28*H}sE$n$
z?O97)=*~4lkrleUSfwdhMxKfXt!+GQ9FLz(tx|1>R0A`LuSdT)3|9Z*K~&p4$o56_
zO-E&waAe{|T8cuz?ON@UNV%w|O!B^W1+m8s%Ewb^x=K0#0l<x@y|&*J(Y*8R?N)yl
zN8epYaFS-HK01hqU0Y47`Sjekc{CICPk^n+eWRKL^H$rg+?Y!$VqPx0sc)XYCV1kB
zHvJ}&8n}QZ&Zp)M^P>~()g#8+c)Q)E%5#ATy0Q`V*B_kV>$7_Z<Tcy&K?xZ%Q+{AW
z!j`RO=s9R;mc!pS#DE?5x6vs9!W*6&RGi=|)M-@!aZv<cl!`bG6vr_GWwP&4U#uXi
zqY>*e&J}ZOgp%^902+JHjAC8DM0rGZD*;;+8LtbYrS#W2l-_0kQh%W{KOrJ8Ap`Hn
zQB)uf{~IDrQ3FEl*FaY5O2lzh*0Py}tcYjQx$|-ma-IJE35Li-u<8jNbR+ROUGq|B
zehlQg6d>#lHgz65FsTSkv*a&8eJSjxgbKsh=f6xIMSns<H*e~e5xZO+E`squdLBjZ
zp#^=*0K0l>t;JBg%jBW`UIj;hUU46mWrHLN%$s>ynfsP|qkQ<%fzC3jGFIS4-XX6@
zN6d<BNY6k3De>v0yO{1!|6Kad4deW}cKFUn><4mKcU`m5EHQcRGwa2|t}&Fm&)Q~A
zd=&P=-){Bkj#X#587<dy(C5n-k%iFQxXOHBAOy~6PPy?O_kYA2ZCUG1Lk*Ts|H|X;
zBnAKls$s8<)s^NcIy+DDT=ava^<<PRk^5xMVmaweO0Xu`mCBfR5DvSp-*_t_m2$<E
zSZ`ZHNwgmwyazIWf0c+bArxixi>bEz29HPO2kKH89&EoD(Em{I)75w1frk8~zi^=V
zU7nQP55`zIuPNG=IoMy#RXLjY|E8WXavcq^c2@GGUcl7T`m$=CW0{&Tom8sYyz$%e
z?HoDwB+FWPw$PLwteN-Llwl?NM)D8%SU0pXrs3b(gsi^2^diT(KRXE;SbHYkCOmt<
zqlB1CN8nN<ox8E)A)9Ik8dxAH&JFb}Q<5f-4huU2n*;!B&-}l#J(ZNoVuD8Gz?8O&
z|Fm&e>OR-;w^BlF``gA<z$=7nvA^d1ny@+|j6w;c4z$!_uWZ~E5O`<ynfd32A_Lm_
zoZ0PMADd+IIkA_`7-rQfiLHGbZ~-jW{OPX+@p>oyL5}nRYm^U2uVG|j3mF#7{nGi7
zPIr3NcIef9zFu4<lnK{c50+O+B;_40Ccus6jS^lntkll-OhBqSYv?_Dq5o10k#pKc
zb2g~!o^x2bD7lDK6_Yv~TG4?s%su`RiZ2;MIAisgNjbX(x8_3Wo-`!2b9V<6+oST=
z6KF;{$=mIE0rjK4?V%n=eEpXoz5dP81aY}tB)*EJJZG_V>h8LpwRi<<r@7Xp&UQmb
zTZW)V>M%*0KhOezL4@i%dQDTku@qJQIPp6!8ZNoG8`Y|JO;iAykck1-rjtgNU6}Hh
zXpl(x0S8P0YW(&*kNNOHf~baKsP%P?dQ}*Tw86DL1!WV^)Pxsz14fdiTjeS!JP2Fm
zzHR=x^okX}CjLfG0V$H5Brs0|^_^{%!U+O%^@@!XeafXXlR->kG_esn&40#2Gdiz{
zO_*CZu|uW0<z(ryYy4s^MdzO_@cxq8Z&zV=b;lA=weocx>kVPN5uaf8?5WFZ9+;(y
zSGvI4aYnB>p~Ti&Agms@)CpMm^!M8H@FuKUB7?)z#(LO4+)z3KdA$AcWj*`;7{bM}
zHPu<E(^l}z4rsFxLC{{&hA=wFbwI~}ehp1a1n{2VHawJ&M<VXFRy$E8*r2;{gEPqS
zvVF;)x9{$D2^Oc;KDqRrpNyGJ;8OY<DQO#)8a|xmwi*8Mrf+fo9|Jrc;i+N>OMsP@
zW`pAei4X<|v&d#WJd+=+in8>@z`8ZWo?p1)M*FMHW~;J!-+8{er`_+PjjRivx}esy
zb|f5m*K4cvQ`=?T88*EChoRn(_txq+jlji&fM7aez0d;15|o<Giywk#M8RJeHJGCk
zE2g*TX(?dFH@X&^)E-%LcCiL3(X%%KrY3V8Ao9xqF`|}m#hFlKl~0rY1eGB^Qeas`
zh;zPv#z9EIq1KnI4TLm8Wnq-_BSNK=934@TD0lt^P7>}1dw4#r|5*c{E{#c^ndi~d
z&S#uULVmMXRL$tPLyZ?{$*}q;bOio32{{jKo4AOJ{zkv;fMZ|_SJ=qg^t_=A$OInM
zYV~;C7!POC>mW?Lv2RTKLiNkK%iOrwI!Npk;$z|iSM_eVNk=KwwAOjC$zw=uu{k>p
zrRqZ2ksKu`D)7EOzf|(Y;0Li63ma@Hl?Kqywv)J6L%Y{GW_LkjzDm$>`1#&XXnJp(
z3HT4&@)mz<{=BdOvQa-S6FvYEIMLgo)?01(vyt>3N(C8S8>u$0ZP2C5t0iilHUSVG
z=M@>NvSO(S`V5AOB}2T)ltojADCO?B2#q?OQ`=fn=&2xmDbmoe7>7vz#l?q)KP}R*
zhf8bvuDa;)g=T;EQ?0DqZ?5jH`bt|{#q<;OdP*}7ojg3>92)wy;E9XesSzD@tqMCo
zQfWOULmt(IbV}vjBreUIBq0joK2TcDqY>S26JmB#P`fMsFK}O~*CT~D8ryE*J)kH5
zb3$5Uq<I`7spiShN!-#{;Jx>tt^Y027hWEe#XTil2%9^TIRiPsi6rHhh@8v||0J7f
zsmbN$m`IoT<i!TAdw|y1Vs|EIPYP67aiJ+M>c!LNPp$gC^c{uSVXw9Pj|G@dt*DiA
zOoodlfX2l~yj%rkaI<=8qwt`2FPI7Ut)VoIig}4~MicL+u`<tQSQ~D%(t$Yr-U<0%
zm#4QWQa%R&HU3-lcbUun?%RG&KK{WS`>;O_9*u}netvL+q%aI!%hc2@(pkUMoIa(1
zx6RW<>?#n?ug<TY3F>fJVOIPQZ|MWMn(v-R29f&>tL<>hnvm;(-j&+JxwE{T1UpD9
zB<A9}+Af>J$S%JxZg14B_;F}0(j;0onz}>e*DKf}HM!HOQ1(0VhfwmoYAN+^9{{h1
zBPL($aj_@Xec;KZMcPA~FzE7c?PtN3DYQ`9%~l;b=Mi|mJ}xH+#GvYb)O5}FA)-sT
zvvw(z{F}#=rob0e?eVs>{fT)o)xn3bMQoAX2Gu?<rrI-|;y*W;w1|df$T*vOJ|h1l
zSpVokJ3i_fb#-4SJjeCs|FUIDX#62jPfNUpBEHN0>fLh-S)3CkCrm*5*IRdIdsZvw
zaI5xA0U4?->_`W9)E#cN^X=fp(#wbXFUFie>p58)?2xW^)3!;D<gZC6)T#(dPG{wZ
zfd$RlVnzrz8RN)855X8e&^j0I{h6`*biu_;ispYNYPLr+g%4I<pEnD_lYr2Qh-hzT
z*K#SxrGhQJc+kEYYpR$Y1_kdHbrcv~sc>bdR`sb)hF<6rjd%aT>w!beh<eW%lfU|!
z5>^`&r!2%aT}s4{tR-IlD;NF?LmhzjGb>Rk8E5oY;V9NeLVvG^J}dmB`B6lTb%fI?
z2Qm_E<BR&vnrh?d4ww}uB;V+YXS1ERjGT;wet7<?b?RHO|1605i2Uy|B*Pq?#~GLF
zPSbgbfnR-D)z%FvpY7;9b!K8LQ_DS0$PJ`n3ATpJSbL9~bONS{1E+ttzYS_P+OY?_
zng#{RxJRrZ+%AI{kiY9Ie$SEG0JlW`>0zMP-fwF|!h^WORipO&_Hh5v>}JROi9lox
z`@Q)6`BQ#O@LdjrDFqyf^Gh9dLND{8J2}<we9<u(V$(!eiF7oz&3s8kBQaLr@XP^e
z%Ap&kXx?NBDqnlzU7GZ`a10~sJpvfi>{{k!7=oHswvF51Do|T?=i$!BmREJ-M+xM2
z-3`@+tr(~cU6(4Clg!ThO{;1uWhn<v#AVkxL=$Mz#7?hPpijEu{BX|f4~zMEwOs;O
z;VMwz<VaZmn6PylTKa%odxw5G^w8=Dsk*Q1)5w0LO%dhf^rRK-*JD(YH<8VO<=Ik5
zf5y{^+sJIb`-*#4FDzriHt5yoN0FkQ<(xV7rRImpAh)eS4wBFagbjNHztV@Cmxf^g
z)_fVk38W~MOaIgByLcNv?nvX6Tv6vbjD`r`M+Z4Ti6rw^Dr91wfk6t1M+Kz2q|#Z)
z;xN0tlnBwsU(7cW%Lh~+Sn1a|l|K)IgnNab<HPCUM)E`_ur93o!JT?p1YwlVZCmoK
zP}dV3zH%YcPJ+-3BFM|Q$P7$3Ea@H=7P3n-Pk*rRIPMx)H$kgpVD76H&@5n4W^f<L
zYdms;aghuV8_LpJFjgIx6)0T6z|e#BJaM!0ePNV(Sa*m~o2o+cddb^r8S|Sa0QHXv
z>eFeQTzBvz)nEOsf=blm+lRUCS*xH({0Q~duKF2!-i2|pFP;W*-3o58ep`a_PRF`p
z;Dmhw5u%OuLyyg#E%>FnmG3?+hNf8=rJ(a;UKDxM?VXtjb-{Tx!ES|qi*r~V#Ciw4
zzS-q{*Im5f@LO)MZ+@OAwU&zMg|pC<n8P_dHhyJMl8VV`0U=}!LFjjT{QLHfz+WSc
z`4Dz@iXbeoZSU91ThzNC9KYO*>JCjSE2}pKk5apwHg5j?XkTVgmofsnN92Wb%)~ie
zBiR#ff%jm;%Tsz7`OtCKqDL?N_-=iZqbW8Y`Th!iYJ}pwz$o4WSPS>py9nBWyi$Gj
zbnv}iN}TP}Rm~PD_6hi3CanFDz}C^+DLkloJU1Ir4Ib3C>kpI9;kZe-83Se+>`6P!
z?7jY$ME+^ez7sZL$~v^_rnkeiz%z;r=I0JrHi>V*iV#IPU%@r1A9vq}Im3UX50zCd
zI|aXk*8HfYw4~@e0))W8GOI5teH3C|_t13x7Vi471qCQhC(!Rov#K2va{f*@ht_p4
z)4C*RIX9C$jk|E)$p!S)L}!Qe>Wgq~|8+49<zJ}lM>sJGXIuZ(G5<Wd2JrZaT5KpU
zed1`hLzqY-brK>j;G%Lt4}dMgRQ(N)Dv;B0t*DOnoGt9SPiB|1$KEaSXe9pfPEQtm
zy*&0yV5`)KkK7`i`7S{1`+jo9%9Fj9!!iu*F!3av;22x5vbGNG^w9LeX%FF2z1M3o
zx?!hH6w8N5<nQa4#>MzjvCzVMQK9+W-TZ8UyN>sR!S0=?Po7X2Z26ksYp>pOXAdzw
zBZu{{zu*`=XF7UqmkVh9=-t_|Mc{O!?j)~&?n0^W+A;wKw71<NREX%$#h!C7Hm66)
zrm*U6$elb~FA$(0kz@Ckt<4OM0VVcarW!eg@IN0&0_(<r;EaP;)*Pt*Z@>h7;pv!q
zq=Whh_622hj~d(PBeA)fk=HXBIY=*Zvga}X`vH-S77m*j3Aq^WnIiM@@5Ok~nUw0#
z%mT?#QOM_;?b;7~o+Ne})&zTC2HKB@I3Jqbo;TH&OFs>98ALRVrnO)5&U%-e-aUf(
z=c_n<zhs^0Y*sIGe8`*n@vmS&MQH{@NWbVNncT)p7=XIJoTY_`dSF{?Jsg};*Kc0j
zKiw?$M&7)#Id!q4{-K8TuFvA-A+aG@1}2T>^gkq_XS{vvWn5D#AC;bm&=lp>#(sO#
zfiY*3xJh5bJ%6xL1E=opCON0;<!Zvdc8WQW+;Qe!*y#_wyZYv%6O-i=$wA+Q+yqu*
z!|QWqvEeeQO9eI}^I);8jH*kF8&dSb$xv2Kzzq%4y34^#7m_<=+jJPfMCtT9_vZA8
z>~`tAkBM|?|0;HAHnj6$%Jl6a?YDH9{(SRj=%_Odl9Z3H2v;qWGtUI;^v+etE3b_m
z)Ji5;5~IJjW3C=K3KyivN>*&lYMKGr0@J{E17~PI>lULR_!WHErvb4<%zT1Rundr~
z$E%*w4LTjK82F_U^E9b9DtTDCdGx}veEqkntswmwmW5uyW5t5y6RuA9c9c=lHJX9B
zhM*0$%>I7M<M-!oboB>D?$?dgy5^!-g^5XL%VX`Rv4`h<{W9zo#jkPn?amw1(lT!^
z7V)$5Sma8q5jH7hy4W6R$Isw@CLGt=-d)QCP^kRn6f*Xbm*0Gfmz`e{jzvqqOZ!I@
zE9oaPx>+UfJG~Tsf7Q8ma(N(<6YJK9o}gOlDBVJ@QGG2uYJ(YC2AwX!2+mm$BEMGw
z6l)&1Kz!RL2&ue*uii3b6h+0PO8SnTTS;Db$9BG25<tbxLQ*g=_HjSYZGqF@km`v-
zoZrU}Ozc{pm||!x=y(JNR?n-ESR5HcUWD}0SEu~tl3TXyQmQ9#tXexWy|$e&LVAlD
z=CXW{D!>16s9(__03tQBj#+>HHpQ=iFn~<>_e}G*DXL4yul{y56kAD5i*#Z8hhOF}
z$i5VD-UXGHIpUT$=%js{vK+z;J>;npJh}$x!0*0tn$S@UdFOVQk<+wx`rNb^DzXif
z;+C{skI~=txDo$NQSeLSpl%}i+)(G<z+<~35Wz=fa`F_7tgvSK^kATo^hwCX?Oz-~
z#iUV)Fu%hH^w9)yhp>vYu5O^hzKWh-#gG26{#dsh5!B$SY)Q#hx}D2Zr5__+m>c%8
zOenDTZH88)>gVuMv?#5xMKubWG?F6SPyDF4)7uLB)`E<`DfbB^Ta^s?1GcB`7i<t0
z%#?y?wF_w)CEzC=x@ea8-41-ay${9GVC1U&e^_iWr~_!&?;hADI+D~yChn}S^_;__
z53Z83!E2#D6)fk91<3O;#fhv$6+1IuU%hYHo>E($`ybcE15Kjnq)kbKHKn0?9+GY(
zo-tJ$ewAuVYCaA*uV#}_D*AOC^WgR>vrCBm{GIfWI?;qp;VyY72Iq3f`llD{BMUR|
z=dlDoBQBnParw>BHc;7RpmkJ){^F)-Gvv4U{#?!wQrdt#5g?Mt1GLM@k<pRml9Xc0
zW4b587D>nw(5gyVC-z1;x+c9qKupT?cjfBF#`*lHRK!_u;jS;#&sy&@*u?3zMSy}Y
zhWVU0E*}^Vr#bSk7<RG%Ft7|pbv3WY;Ltm(=8yC*>E`$)MRW#C8xTQwugYbR1`xj#
znMn7wz^M#s?woIO@#D*HIV^ip5+2NwPSlAem3iKX$KKP0hgoWa6uMZGphO(muD!wX
zH6>8kEKw*|OxfAs9I&1zCKo~O#o_UliyQ^CirF(SX<pYp;OW2wODA?yw(D?~l_wwn
z#HqMjoQx1*=|lI9vPtDqZ3dy)J`gnD)iuWRKn#Cx209d2&tO9_8)K&K-*!9S=BaG1
z@~TtsmrdS~<N_xVv|N1b@5Aq}Nr9UDsJ=Sif}Asmw)|LE?uAY3&Lv)E{4KlCWnXkt
z6u)&_k}d^I&$l*Dx_&Px_N&}l;|=-Z%H+q42RO)R1n$tlNp&q$(;sF$LkQN6UO$NW
z$CvjDob2M5xd;$OU!*C+R5giM|Av}8xx}@pE6|}5B#_OT(R_RF@17<=`;4;a@>7I%
zarcb!Jt%H>zCZij_BAr3bt?KgPx<^KW#V=N3Ps4a)Xwbb&C%O23+8;)hi=m2gx^#8
zpl($5c(OYPk46Ne|JH4X=N#GT!&I9;Rm9_tGk2}tP9#9<W(XSAHdn#%<<#=@sXhH8
zy|&se`9yUMVm$ME>?@e{Degd~B;GzcTGABXTr;?+lyu~~bBK;ozIf%Ym-etP-}1UA
zvdiy}Aag#z>;ylzK+0@=HD9^gS-0|%u1l7h`lcYi;1TR$A|iYdlh*gkN#B#Nf^e<k
z{<8A^If<|Y0Lpg8xS{%w9dVi6TzENa6#seNiTl6Znp{UI`*PNX$x|X<+snCAOAO?d
zQVZh9qSQH*v`@GAM77m48*TmO4%BHUON*B#25#;WE&#Z461~^%riqYWo8!!Gn4{$#
zMy&PrIzqWehPfXzYy+9ab$up<-kM<riVxLtfRmv%F`pNMMZL7Hd|1CnF(Q8ZO4sw%
zqPx30Q+UB56FVB#rK)d|2_fWyW%VMZ(yFiXNy?BXAr2+S={O~=gLby737AIuMc;zU
zgwN)K^Fjq<wS6SXN+ZfJ#}tnUAcL240Fol|f+MU(&B1Z%cp*xBCi?~>@NiF0^PFS{
zX1F%3A1aRcV-q}&SOMR?^BRznU&H-*!%`9u&k+LbU?|rdIVQ~)tjrGk1&QV4LQ=hX
zwmHj(g3?(=S>vIcMDj~#BYP`h27ZpyQ|r21()sL{RUhXq5${I9s)6}eZXfTLxX=*K
zGKShIu7}yW>fqnB?R6(AY#^`Q)@M8<&$)Xf^L{77ubf%?*;|}>X`XJ&av6jNCBjn*
z6BWGy%}N8C0?<&$?TalmzxeZAhK?Fx_OC<DrmX<eB8)IgIVRA@d*wugjl;nCNrjH(
zd3InlYdnST#LN-ndYfqS!^b$!ybU_LU@WJSp46*LzsOXuTM4jnBVV>C7B*LQ4_YZV
zljki!{m4PR34sI$t5IbL5#w{bM%&<QRpcOQ(<CS-pdza|fL>Jw%RB2V!5oua6-RK@
zTnmL_g;GE7M*7wJ0GW6Jk(qv)@shkQ%eDLm(&L955Ukf^E`tKDOlr@mR{RF;O<YVF
zUA@sOmp;R4^`LRz=Y<8fjPjth)1z@Tpp14`CE~e|M!j?d8!_J0<SIj`Yh%l93<~uw
zQJPAafO7!1vBj%dkN>64_o2LdJOlajM5@*0Av1=E`Rp&NJI}4lwcXgbS$cSQ(BM_f
zFz}}S5?G_+ph;D0W<}CQDEK#9nuMBc)qs4tcY)CR+oZ<?5j79SbdX)T19tA&#e)J3
z8#QF&P`I7#wp`Ol^hX=P_x=CZ+I0stwXORNp@V>eQbfQjAczzRMbHosMWrhWDkbr7
z00Ak21Suhbh#V1tL+?d;4GPjpKoq12NC^-mSm}fkY7+7`=gr(V_r19@@6Nq{WM<E-
zwZ8SW_1oWG>&yDKS@e8VnKFM_Isfa5hwml6(3Y5&;aGC~`;M_|rK;nJ$}tKVa51j3
zE*>XXgz(Q#>nX4F8yCK>vVX8IJ;%+d<R+PqqE1)Z+9F2LLX={WH4blWaB<q5<B2PX
zL@=AYDCp*uhOdGuDp@w9h_xdajpsY}rDSO=8aHdH?YKL&Wo<iwdi)0@svyx+K#=6I
zNGmA1HqiGscxl$BUYVn{I08&ERmOci2_Wx<dT~)i5Bv7gyDN{5)a<Cz9ifYJv3qPE
zxwsWhs-+WvvWO=OWw^@Y$TRGnMdz&Sxbrfvee`GDro#ocUwhm)RK7RnDoqz~*f#)x
zhuoG@=u7p>t>*QN5fwf3UbKS4@cO&V9Y0<6z`;YMb;6%;p`S)%xM+i0d=`dK!72LD
zFninaLt8Ggo;~wreM?<X*4>{W*4A4CTD<Xi>}>2fSwS~+v|Z-wu;K<WwDOpE{401=
z@ek>YoLwCUR=isKBAJoCn7%k#WHE%-PW1#zb+4!|HsqG7sHd4}PQZp{2~1rk-iei=
zbCd_bF3&vFD;JAt%_UbgnUfGq?JQltu~8ny;0dD)q+I|!l4~my<5sMk6XAU-Y9x^-
zTY@iDgCXyvzsm?qoFrc_N+!YwsEZqPLqzugV`Cbv<TF>s!DW4|r2iv+Im9!fEw|`q
zZso{ntuAJW8i4tP36Vr5UQ-;_^66X%C+qv*TGW&?A9{S9I$K(MEM}$PT{a|`78}dT
z-(NV5`EZ;M^iY)V!yvP(G15a>k<`I<G&fz6?Tvi6AI}VQ4>uw6abiPW_9LQvk=<ES
z=;V&OVND9q!)GMTz^Mq2*pG|~MAemA)a>Ck^<)rG&VGl;Ium5*=h83StD|9)8?5!<
zU4pKaq=Rw%;*^d)*EnACJqqPzbMofH7_O#iV5t6LUAx(*(|?#dVEj;dT-;0|zGV+9
z9rBHT?}f}hr?(vFiR7W)<7$gP%1`^xz724vesiqE<4J||i#vif<V=n`To~&F3U!l?
z#@OwuB_2gvFA?AK<S}50wXBifMKmSYIs|kZDj|My>Z2-8f1KGKvC}?PWolCK+VG-l
zo5lhp?gw-~BR@(h>%yJtpMhTjF{MjiJs!KjwcCw+VFJ&Vh@skeZ5C2dNvi+GJ1M!R
zxAso_Y=;NLPX+i8rGwT_qL=8bEFIwkYcF+qz{g6z7eDTL8}NYgEwmC}IXV&aAbBd%
znMIgH_~1PGw7TIFO8(&XdAlZ^_d5<(s?tlA?&?iqq<`NcJkN1!a#B-nJmu{S{v`tS
z1?#}i+pl-VHi1*~`(*?7Gwa>VRxZKsOBiyrYe@8fe%*Zo+u*x?wRpKzd68=Z5up!7
z3R9=t!_nD~^hT!`EyuQ17fdZfZ^+R1yPkZ<0>C(LwjJ7{EA|AbGSX{wl#U<kS&zEg
z<IOdfIYZ*$D$1EzlJJ`-){%e09Gte{^WjCc*YZ~_M=U;S+9KGqBX|^y)eT>mfAiz#
zaHENXGwo(qQV_1o1U}>~+Dl9iX*riFvhCZs-`K=da;0@W{$$N@Zm-D5dDYf)&2Hmx
z$Y|SnhFS4B_eZ2xwWfRT5)gx3Is50m#X&P)=(ZdSeI@1?=t!bAI_jJtTsJLFdG_Am
zLc)M9pb^X}YDR!ppOmT$QYr*$p)_Pbal-Op*@U=M`*AB=q<ymOPr_2)g@#siBfI`}
z^R?_BDZ`%XH*o^w+^hMcxS`kj_3X$RW|t|;%@~@eM~|&C`prFo+o{zI#%5K|;j+ak
zew0@-ig8xeU8Q1vBNpR`+5JxZ@sgb#K%Uln^XRgr4Emm*hhNZkCG~Tub+J~O86!12
z{Ta6A^lpA*i^<*lyWs{!&qCFEzj<os*lDE1O2*IATv4OW%8QN9TkRI=1E8n6khPq7
zd3P+<p`jV)Q#!8-S)25C;~r_`UU=b69n=yu$^T5y|2mMV|HrRcWQ<Uq12bgRikr0?
z5twD}x;cLpUP*-SZMPVL;J5Vq>F?KJzKp}3nNx!>>Jz+8vTfqcho3fkD|kLu3MNK{
zndEPUXm_jDnsT`aXWwWi^^JR8Y1gd!k`c1_^+)o`aETM*3~vl7PW$%eRMcgWTLqev
zUf1$vPib9w5%SzoMy|x|h^9bihvDUvHrH4_K{DG=_Hsaypt%?^uL*$`cwMBC+K$;?
zxsnxQ+O*vsyxF$^Z8-;WX0J+Ura72fT5Q(T?^lQx&Og>W^YcRbe#Up)zC9M->>VqV
z{uTn|wuG864yANUEEt+MB3~}jQn-bUkJ2ZdUydm7)%8ki6R!Cuo!oT+%;Wwv=I7PU
zAa<(z59lkU0`HSgY$<c+S3-{8iss`;TPF?~-+Fs0_gOmYobfV+h`4GSyHHQuA-5bh
z0NP^NQapsKQNHGIbcdzK{WrNUHxI#|artGc{$TD|*+7gV!X1_YqU4MXWBKf4!O7^J
z&0mHZBcTxgqbH+Nw#aE44-WtB<q^o$auJjK7>xV_9$zhv_;Ts-TVul&&h!z{H3=@a
z>m4+ToFEvr6Dsg(mkJ(utG%?8e}Bg&P|)7rAeKmL2&H-ui$7G~F}Vgw$<GZ&6o)ER
zcYJy66B#<&O3cUcb89)|ocU1T^*PBiOqE0FF<%F77z5#^AbP1aI=m_GgOAuA^=B`N
zZ}S0i?gjr(TsYHHNd5&5Z!n&QSE_a3U0kMlzA*jp>dkrK^fQsF8tQL(Z$3!o3imud
zlR`7U(Q(70y<qL!<>oRZB=-UCkGgo|dJRMK-ig5yv9^+OWJMvm`GW;(bq79&$E=eW
zpCKH8!RA%guh_@rJhCQUS49m^gK_i#)2xYzd*;;~?2_!bD!j6|%c1ow(VIHp#qGY0
zQdjyUf6(*8I{a_fAMg2K@+Dj^jvoIZuiIK&Oyf<t=<-~S@0imPOG-ztj3jZJ<7^}3
zhN`hT#NUnKWTTik=^2){fi!c*AW(KlmxR21l#|)QrDBKXfcf`5yl7gv%xLTw=DnJp
zI+7oVs}(=C*=8y<XLYeadE36wh+EKYzE8qGZ^L@-;)7<xLBZGN-tcXvx_fqlw;X9K
zpx$}wP1o$ks9d*v{aLl$5p117tjd;%=l#4od7o=l<e8-==Fj#WIl_1aP;l?<U^X+h
zKa`*;x1{v4PIEmTlR0GD_DjaB__~8wt<Q(>?2GFK`kR%O^V}Zr8L<;cPT+j~_EKPM
z=sbcMze3pbQpveH)VbHxRF(0Xfw1Lnnn_tVDuFVB-pQtVa$E==Xytka?-wQ74_9cW
z22iaOp4>UkV_4`O_QkjwiXQb0J7U2>;=55~iuLwQH9LYhJ~e)~)lFJ+MPYnD%@5EF
z-i6mfnRNuLaer757#~w9_=NJ)n~h!Y;sNR1v&0dA4Os1DjvXQvBKFe|WA7dt_V)Is
zn<<2L!&$amYhS6lchqr&R*OT@X2Mqakxeiw6o)&(@a898@j6J)@^~RSAt(2)Kff7R
z3Tigeii@d85<A(QbdeSj+?m8<8i(xN)-D&(xXta!`A*8}{ai34dW&KGxwG?GRr9_c
zj4{&D#44q4&P`n1y}|{)8#gwFwnJ_OIABsNq~JHWgRk>BxIv|++F)`*s60Wc^B86G
zCGOc%c(WzdWmkJbZ3n$SQO?%*{Dx%w;mC=ack0GMvl7p&`A$C7z<nwg(u&Asy;__W
z^F5hAp$w?fDGq8cP1tgvh&D}@5~Nk>wv?;Do_{ySh`voF1=Z)pUR*s4Bks3Yycc1t
zvx8BO-G(wZ=86m>KxQOO#C62qLE`c<FPqLE8Bg1WZW8DLBpIdJG;}{-So$!#d>H)c
z<cC2H9wu`ZYhdn*99~jPE8}X<F%p1A9dA6#VK;rAn=2pHMac4bBOgOHHu&kg{K$Cp
zm*MB=sxT&oF1R%81P?Wn+1<Lj<ID+agP&@-vM<ugTwT8BASucB;r!X<0HZpB#Eel%
zAiMKJq0m6MH>B_UFIP*6XctCc?#jYAf&~{n!B>=UKdYo%TiZv1eUnnU!i-dxZursy
zA06h@fBw3kEe`LAWQS;(?rG0dKMy;X#`kQvpnEEFM7|PLzDMrbx7j8J!HKz`b5u8i
zCGkS+>9bpIC;L1+Ju4|0)bQ*38<1vG29z!Q_&82<WMUW#RZVc6ZRZqTF^8Fmj;MdP
z%m;Tl5Q<`l-U?$KfH^4pP3u1tsZ1S6L&gNjlbe!T0+XC03y>?r#1nq~Qdsz<aPJ<x
zvN%S+5KdpoS>xvgU-V)Fn3fgz+^lyfzKVj$62;lr*lNvR0zai*aK4?`HE+cpQB3Vk
zG7K3%bFGZcpz)yyB(VoqW%a1!JMpgIHQnMi)p_m&tGT9~q%y;zCPZuO?<Oa<lK3K%
zJ4@%IQeA11dg3w3j0Ao@U*>-I@2|etE{*+3ikTa&!7p^gqVL?qJoS^WT>WoeNUb`Q
zayy~vR{>M27M0l!Lkm4+P1kc|Q|)-0Um2nhlw(}+atY_h6?XmIkF9KYPO=;1n}p>D
zgxGOZr~BK>rulx<+9aY@J<2)CP_SBE;I%z+O1}CrhuPb4D=8P|Ig6v0iXrsv#g88N
zxis6HA>070#QQ87hqwsFV+}N~)Mi5}@fS0Qo=4u?s3%@E#j7;t<Gg$Z8Ua3M3_<nh
ztmo6r*Ay-RRHAk<q{qZSU+NC!n-T`*&G`dgWaYZy(w}ROkKXOBg|Dw&BC|J4SIjFa
zl5Nflgc;HO6U2lI8qVG3GvvlMnRKPZE_zs^&Ee<w(dhZNk+h&RJpkYnzkb>9){Zj-
z^vlZGrf&Zx&uz~j%1i1n5i_ecN9!ilHZ|Sj<L&OF75?hOtT(c+)M9Uy3;!~l);v-M
z@t#EqeYy?FU73zd7bz)H$GR;fD6^%;z4BrME3;^I<K0B2Y?h(hZV9a4qSHG|a`Zy(
zblF-gU_y6A^kA?`Zxzf7gz7<Ts;~c;6iFjopcF$-r_>V8dB#BY{svF~6S!l;7Ou7e
ztx<}L=Via?0E=@&+MBTbGSuH4#fkoINvFr1EL|2G8RLuFOK#CU-6jt?<9=ttn;ko)
zdPncc+?m!lv?zVrOypyQtoz<FvH(z5PYEG=FOXQ9cn|&l#lCrHdPZMT56bg?&ent6
ze%iqET|;zb*i@Rg&F&0;>9HTBFd=uXuj%r_rdIdA@qdUHoonJqPUro+(rP;wtcJE^
zZDz0{5XTOrNZV&*!%1)HRim9f&yLNC70OlOy%W#1cpHpVa5T(gpo6pe>?X{yOB!8#
zrk5~f-QlX;@KKw0`Gyox5evfIKd%c}U8m@bLVC|!8ZJ3)rT`v6J@EIxeeSZG;ogEZ
zVzfA$DM}Ovm#|OZ&PxxB5tX>i<QvX~@drOf4kSelmx6(ydqUp*A}Xb}>?kB*ih$;E
zL9jN9H)kIlktM5K+vT}08M9oPC@8HelJMI^{I&dh%r6DQN1Fo{mnNeuvUT&S2j>f|
z)fQq|6q%IZ8ATZbFsMt`_xaBKc(L71Yv?jPV3~9%(rZx8thTncK-}rB2KCZ|9^T?f
zZlsH=3<gC};g@T)X8dGzjI<^TR6&A=rK&5=CK|&!bhefnFKzJi>%C>9XJ1&a_$;?D
zvf$A~?WR9@&BhJ@HH>db#FBc%F3MbUXgZ=bX!a#_WRzZ&{OVw)x1(AlrE2_zktCaU
zC&j)gIpc0tg7uejWED4<iQmI-#qc&^W!)NL5`SA@)g(chErP2WF1=_L^G7XLWQWeX
zwfcMuEalfDgxKc<u0dN$KqX>zoDk#1Ipl4>NgbkPmY#~mG5>9qfW=ND9XHB1>B5tW
zcN`rb`O|xkUmU5^ukuAYjpSLz{}v;#!2WJ(DsyY)OS!{~=2~rs;n$=X@NVdwkpRd2
z7|`x-^&CbwdIuKQlDY!d08lis&twJf;p}ed{>Z?>#M<mJ|ADW;w5p8hLJvXveDn)?
zt$KZ~Mb=HTsNoXuRIjqK(#^@q=v?Q0yFBl^Q~p^Bej*3?0N@dTpP%1?LRNhI*!QMn
zlI`Pfv`4T2nl75zg&_4Rt9cMIY;TSD+K-jaE1ih#3cP<XIZ!?7&)@+7(D?y?1N>nR
z9zZY#{%SQicmSILP$U0BC+xw9f0xMruyeqt!2!vC<b>QK1!o7L^7H9oU80!2_zqhb
z*k^jlpa<X+29W%HE~>w{H*5l>8fu9F^9j#M;t%2=SkJ?Xe-XkWMV`DEX9r|<F3jn^
z?mL7%3aDE_IIe<{@|^ig7pnPp^=mN5Xer=fn#2W}&*Ocv0H6#s2!!+gT_4Z@0MG>*
z=H7946dl@1(fFfb(3LhY+h{)rZWiASn6a;iEoxKdHYWR?>5U*k+ST2-IhT+)FPp(N
z7q4MQl(NvV*^Nx?#a;V_+j&_#dteMQ{%3m!suABWeO_&AV={WSCdt;XZgG+S&JSQF
ze*BY6w3sh)@=T!6e8PPA#bkc}<K)0qN)%qr0KoS8Du6j!g=Dw1;9{Ym3u~KTP+>6G
z#=RR81bfogW@jV_sHXK_JmjO4GrTKswkBR?U=}RkT+qI&U);|~TX{+n17*}+gKS(v
z&k>TsbTHoKoEK&<>=1`$X*P(C7rMxm_aw0=u!n5O-u@D8Ct0%6fPXn`x<AN*{HU%^
zKn4t<u4LwUMF{;^-f6eIahwZ<RROSuGb%6=Mk&Rqc?k{u2xdYcGtfJ4sC=M}#}z)+
zx153M0S!Lm>}|<+IiJ+vn5e$8*+-7jVaf&opf0=GvZD+3Y}*YLCZ@?V`yKaPk;oZt
z6uU1_?c9<UM!$)^20gF71Ad&e9b+J;`zGKx2+^s{;@vU8hpp8ScqiMj$PfDC><$*)
zDl}xeb~0G^_NQj4SgV^7hf_|~0d0{qXKkcL>e>c74|qJN?{oJzPH+Ltyz2YRqleOV
zM1X_a?4*Px%s?<g_I{ds-8iwt!FFKJQ{fT(kLU-s5Qr9ost47WXDt1!w-&BWaztQ3
z+&A7Y6k@%AskfxjgHAyxi?DrC@Jb7zZS2Yk;Ng7Q1ZvL*T^_sHzjg6ReykJJYvVWg
zX>cT%ED|o{Wj7y+njG+MW=x5vf_WCJ?JcFT&gD~`A9f@VF`V%{a-e>e24`j}r)F)W
zr9da-3=R=nuX}<%VAD?Mh&N3yrD^f2UF(-Dbsnz>l30TxaS<%yW6VD5rc66M-q*Ei
z%vF(faij1$xKRbl7z3*8KL`YWt>OP15FAhfCH~()@bBQ(zl3XliGw|0;Gf9!?{M;u
z;P!V){{;O0-u_QGkv-t@|91K(ll;GlV0FH+AfdlGyNG5QM;=UZ{ffoqs!Pc5{{rAI
B!Mgwe

literal 7889
zcmeHsXH=6}+ivU*7MhCEqJZE~rT5?rAShKK6e&?4fKp;06bS*HIS8Suj6guh2u?6m
z0YL~5Ktm#3YG?sWXraZ3kkHS=th3g9->>()-?z?>bJqFstiAJOKlk4I-gmj~Yh&$g
zElvrD3xGhNQ#UNlZi7Gvf$l-j@uNWVBXVF9XpVYWS(pLs7Z3>+Gr$0PKRvW`4F!Qt
zi0(fJK-sU(122!EZrGR~`+8LTh@9?94IvMBC3WA?1!al|3W5itfS(|cX$brt3hr|;
z;y%j%qQwmxdmmN!F%U>v`-a&sj*+9w40M)HgvZoZ1az&GRKGc4{2?zuLlZ}N*7ht*
z=+|jQe|x-#&@U~wobJW7UK2S25Bs!vaZBjq<pj%Ur!!ZPaf6S~3!^R_7CA2W)F&jj
zbEnU^zn^EdR$8>4_CMxYES(2CQO*%|O`Il-@4^6a6N>33hQ=re3u3B;K+TCS-v0!;
z2CNcLfe;Av80Z}afi42g0TAdo=wJNxZw~(tll<>U{}03eS<`=Mo%@ph5%Dj#^`9p`
z4$Ap&ef=+V_@5{HNAv&wY5Xrq|A@E-`nS&Y-yHsrg**nm`+vfS?y`xMKY?6S1u`4*
zr!}zP=&q+BfY|^iam}pc86MQG@AJc*zJk8GBEAUI=(z+<82-Ro7<S2lEXOWBJg?l<
zBjGJ-0m}F@A|mL{?Zwq3mE!LC4lu}RN%*lQ(uSZ?X06*AQ7LQXg$bS?pEq~SM~AL6
zK^7p%BQ9Czi3n_mcy{AO(DBDN`5T1pVb3alJOi;*$rF4GdOJ?NA<v4a*HK$A2rRxq
ztHzyHI|@4Z=Zl!X;9(`DMXv8@P2^B-xpYr?(BW(5gM{1MGIN6i<+844n?_00B+z4!
z%Spt2H?giZ$5t?JIafj^H{>-S;qEOhD3mrfN_YOD9v~}>2;kIk54Z@0tKruy!?jdx
z{bskf5D_J5f;_22;uS|9OiXo<4GK!{-r&V6TxUI6yPzhitUeppEc_TgYpNi4Zf9#D
zo5ZiKseb8-`}NYq;H~Y3-*dK3NA&`F^jlniJ)viit3v8b$(4|GeR2py*9oJfqFAqD
zO^jZq7#>A8`UCr~(v}bgFB-a|aI1^rOl=j96J%B0@L<JFUfK_-ME8#YM<0W-#PACy
z;-9KC%`+cGVAbZTs*6=c)w<tzZSYz~*!<Ne-k!>!!_CnbRHj)qBCxU^gnw$L_IuS~
zgFi^@9)+zmYUCwO>%pm#T7fBj$WX+UvPBoLwt3lBtQ~!pPe1hg>h3TDs?AL@kMYXt
zoVmGcT`@fR0$NdB1F0E!<85VQ&|O@b)}_t%zX3J();N2r%~4C<;TGQ7Tvb5b<BFLM
zKB;9q@Z_{FbGXw{GOL?9LBvL0F%%c{v+%C`)!DN|E~j{rx$rcjR*UhYGXR>Cy6zaJ
zWwa&Ubxz>9%CwhOW>SG>I?~@)LmDrc#<4v~i%@v#t%t7?&iu(+<bXZFyQ&{avqvli
zyXnqps39Jtd4%C2ABLbj!CSex5(Om7$Y|ep3bwPp8J#r?mQJlNPjw+(F`-5#j5CJ)
zDZLnRUAvp+W;SM8grfY=R4eJikUIVl#eSP*3EN(~%XtyC+tD?{wr+S0w`r)UQyQWZ
ztYWSXm@D2XmeCm?u!_JNW7ZI{Nl9>`+R5C6o>S|TEZN&sxsKa1(whtV_>e-h9WUvD
zgjdfI=d&KWh+}A0=4lfR#A4PBIo9Vmx>+c6Eo}#_icgcWn~*@qPT!0R$)ktj$D;XF
zVPX_3@i8wq4^wj(jUBDJ8_f3^AE;N$Q%1H@e{HZ()VMgeQGN4_0CzM4%0+wRu=+L$
zk6@EuM{u=4Q!d+F?2h{TW{V@X5t5m#?FCeWO#e9(*GWmk1#vIaFb}Q2iez#vuR~-A
z0vqSsyQr_(flK&qs)K_l*Fr&1xt&z@UcJt-rc@TB)LG!bLed|?wgW@wUUf7O>Xf>R
z%aSmf>8szfnnos!=Q3l>C}I|yyNt{|uc!dprun1sY#&9>Ns_$hSc4*DBvxwzvrYVL
za7Mqdcrk~S&M;&u^qtVX=NJkN+qR_>_-jMj+^t4C8eUKm_I>OxO{i488=X@Ap)~14
zl6!DYazc^ib<-lnp}~PxD7UlDWajW=^|p{Hxn})8vi%iaT2oUza%N{LZpS4o8t9zy
znEm~-yyBf(gW1+pLjzrkU`^9S)wjeCzvLCDig1ZxhRl^!Rktr{d*H!a9ugl)o322b
zxXjOT8MCzZBFC`tO5Xs<ab(zdLom8mEjIbafp@=QyrZv>O(1|XGD-vTm7tiRv^7!&
zwBq$=MCGKUR07A>qTxzUMRnPw6-Lw}_vgWt>Uq_FkyKa4Hq*HosVnAnDL(?-oM^^#
zFzMXYtE#ih9Y4ziFAWQ!)gte?PgeiDz_{CyWd?e+eCsi)NU>~j{NYfV!$Mz^VD@^1
zZ7JY_GhK$>WA|Upqsm61nb@rlp2CKUV!Thh7n=nB?4wL`bO^V}U(L>sd2Gy6NVj}U
z8dvn-5H)LBAK58MzKYT~ZEZuD9jz0*zvG0Ch@PT6(S(R@7K-0tZk*~0-No32YwaSZ
z9nC%t#D=opmZkI{8st>RwsKvFbF#4K!HMO8BWG3MF>N#7H);`HdSr->5YO%;ZI>M=
ziN_^!qgB7hC7?7ectEu)D&(ay2|%bf4FF8eX?<e#2%E}p%2CB;a$+y~irquM5fI+P
ztYt(Z=!AUdp}W=spqP?q8RjQUJd?#ROdMKq8>?q!IQWHQVu+1<g1JWTm7BIhH=>R7
zwT1U5ElBs~@&_U%ae2vkBkc1XT~wb-;A*VToAfq+Yo}Jy!svV%F=<(Qjr)<B5%~+o
zY6RvhEZkGvLqR(SVRLMkU`S4XsW!VdVD&F}Q27%an{T%FoIg!0=uOYr<({}KLj`;y
z2ba8~na*9~w(!3ZKlMJdq~?qbQPCtF+GsYZ51Dg6X|LKhV0^ghL;jez2h?VJnL5`B
zO(}&?l5ZSt#%(1%VIljAR`VN4zTNPNk-AI4#$o*TRuOJC24!8S&JA8c{|JBabsoH`
zG}Ri;!qYZcO0tDa81-nP-MMs2iq9D@4Iq3*tEP6^ns0wIiYNO`WR)XarGO-mY}Ib`
z27{qJ<)@QBAr(#Py(aKLQrrGCo7?L&y|ZEZA=f~h!+xZAwC7t$BllMbWFl4zV*Jo3
z*tOnxqOaHE`(#6vw`p|Dyjg4ay+@Bs1IEc*rhfT7*!}&*yJlUPX4!3}QNSe-L^qri
z(8r|$9?EX%->M|P4t3}it%i(7=w)oa)4!@MjK8piZIW6@p%LU~m-lj0fH1g5g$b@x
zww&-{oaIsX?{8|Xp<xY;p{5O-lk0l3q~J&*EHv7U7gy0(#vfS{ts9B#|7y&Qki`HI
z#XBy#VQrXI;TNJ6tP+A!X5xzByFQE~$c=uUvky8N-ce?G*?FC4GuI9{jPg%llQ6m9
zrSbD@nWorX+c^UNM>DrlkRBmd%(N*jp4;B~vSd9z6pOkMoYp&n<A40t#xHJRA$h}7
zzwMgcvXo;A+AXCO66Bdx5^Ab-+c|ff%CiJ>=sFRti-`^KGBVVVDsDSQklHx%bptH6
zW8n>j1~o*iW#o5w41JL_$z&(Qo;R+Z8hbOYwr5dQfTa7!8eLTvLCe#alupN!bAGb0
zgts^3@>Oxk-9_0hP^jqG0}19w($m^XvVOQqZ`D`|pz?$4jxLJdQFNkhO@%DueAAbK
z3ozwX(-i=uBpz)o+)Sg+i{yG$vwIQSpH~p@Zae<CJ))tcLM5gY<Iy|QT^x{*6d=KT
zPUMDe8jn1S^z9*KMMJ>#f*jXpK%gVBDdb2v!B|x(L?*zD!U+#5vIL#c)H9Td)&C-j
zUoz3)y}5%;2sAPj+ePW*Wp`7JML${X?%cHwk#|4pLU7wWZLSL2KC!{@$m!T@daw_Y
z@LRloqPr?!37@aWrcOfE%}#b@K>GL7d1#EA`(&NE(@TEtR&1WpRYd&GoQ8xj!l0pW
zdbpNU5!S1ELIRhI<*ltGrKB-L={%!qAKw8jd0|ioWr7_TT|tRwpAdIrny+<T-YaJW
z1r!v2j_1uijmoE=(%JpJ_gBcu`304_@fmo-(GFKDjkEO3+NkL#+^>-^4mq);N3>s*
zJM+8`%|kr!aN`E8;hwN6*02bgjl#Oxi0lKZ+`+pSYU`5Okyg@2uAE_dm=kuo=2qdx
z-8a_;HOT%tc$Vn1rC<-Y?;#};QF%r4GX-EZmd3C%d{n6h5>Ke)_7ygP>(h)Dg2Mn=
zQ%e{HLy<{w31w1ebyqG|v^sS1`Qo6B6!Mqn`k(jiO*^)(6je(u<CJ#{nN*FkTd?kl
zKF{s%^=g8=RtC%TtVdz26gZjH--<{MyKf*GbT&)sTWU*QEx!%TT4eoxG+7-Bdi&$n
zW1CP8E)0Nx2*!`X+Po3siw-S?9!97e5ch9RP-Y!=EY86hD@w>pcST%s$GOOCW`rch
zC}!iEbo|!7m2GeJS;CB-ODT~$)v8MpPeJ#%y1V<32}ua*j^!;^v>Y+^-g3X{NtM%C
zoBK9UULL%ly!khloa^0f{pqnrs=<=`RK4hKn@A&SC`(JK3Zy3{CxW!XYW^rrC)U1R
zG|77t=1sqj-dlaQV@0&etq1FvxcSU}PDn6}-#QnxvUaSh;Bsc&+isP}lp7fWG<bJ2
zVD`*3AXXG7ZI`XVMu%FrqIk6CDu=se<wYrgBX-qovqmcTeU_7n^=vx>k%}6Uj*~N;
zy70F<Nq7uu_vRI)t`{x%TR|-XiWIXQpuMk35;F$c8w=dzpC@}<UjLH=qXZ1ub=hXR
z`{w=}wXcg19jQ1zpD4@St#+GpCtQM_<?x^Xe6@UW-2O+I4|u^4)g7}zzb>O{<HyV=
zQHPz}z+(XtUZFMyq~d^%>`!@qOV)ljZ5ua-r<pc28urwY^~E9pmta9IvjF6gi$M&|
z`YUVXOvVOqQU&w$grHcn?dxOXRd6YMUUJWAX%oL1n<61(n735}iKyv0@I}OMQRCL4
z(3Go^pZF+Eo^~#1XR{+qh)~)-k^i^YqpNlN$wM?INk+61<w&O@-j^q3n`vYxMSsIA
zom`QtJ>%h&iTx0cqQwR;REkxAYUtX3xDz<cOl9`mGh4mo&-)PL5Tq~S%ESa2Qj{o}
z(Fla|GluU>Gz>*!!yi1t*KLR5Qu*NG8p^6f=X&+CA!oI{0OI0{gUx?`db-QHbuQkH
zB5{Y_S=UJ&Woq7K=sZ-uE>H*G*v31L3E}4_gq?M3qBI@lKpA_Sxk1%qn)0q1(|lKh
z94j6H*udwI2DaU6Ax<C+JjsZP6U-J^C<!?(<}Csgjmhyq)P!B%WX;$Vn)GZe|K5mf
zNVY1>a8y4hv+MQAyrMpc(XfLD3La#juVR#MA#-{O^(qUON*-bBz0AP^%{)FA>rlr&
z|0*}7W!&0F?a@YJbopOW5ZZpSP|@W{87+f8&#fXuCtKiaMxt@Qj#qFWaY;jiem^*A
zwtg(Ms4N#T(i<5VqP%WvLm{&RlXGgS8$gzN(W(1~aGPwPBV>|w9&2Umowr(leT!8=
z!~&A`{MR-LcYax&qCAWaey2b-3Tej-_uO6+$dMBON|krY(Qi5S(c!FCxY}Mz`mv0`
zRW#h&ZQJvCj-)Z2e%-d!rg4igc30Zw?DtzR=KI{Dc=9>@+;=kP(_g8WD0ZheU06tw
zb(k6a5kZY-=3!?vkEh2aq?Ir{L(Y*B68167OH)Cb9hk2R)>>80QNy^@OguWM#QJ?~
zf8$bB!rWem_>S={liHHJv6UL_3R#a$dDUZu^30+_PTE+!ZKSF4W30vsX=uKtSn0R@
zt$GD7nuwcTCYWMELX=k|A$28rbVN-U;6e|>4LoZ&Pa^vei6>^wE;uI#z9m+@b^`5h
zl#+b*JC`WJlWqEoV}B;2x6OUA_yH?X!!|g2tXIKnuk(#=%Rz(N)OCh?dd=%@<bEv1
zZn{i<&1&D_n^rgWr*oYT8FwsfG-&jDevhEis=T?ePoo<7CzigT*n+FMmxIMRzx!Fs
zfHL0ZjibgPwC4J?f#+GNA1k9EnSXHOLbmLCDh-O%Cq?4g8whDOFUkFr&{HZ$zv_2q
z`H=Oz{SP#3%zJZZ3(|5$duEuVJ_T`xu}*D1jN>RHTy-|`6~`v|5BJ%`O@jXog4Y$i
zrclo<s$43_UU;!XkGRApzQnw^73Sz`7tk~9;uG5HP#}*>q-&Lbr)tXwT{#T$D<me@
ze>gSm+dVReS7MEB-DEJsb!5ouo>4t3rOS+oTI!oqaiFOspZ40aZTA>ao0sYeQKm-_
zNc7x8SQ}h*zev}qm3^iD(}cpSE{QkE1!K$5!MUYXHNWq<8ICh~dznw|sDT$OE<@gj
zyUCrHXrjs;2X%jmya3aY==mDZv*l|AzR9>nx35@ZcXa`!*-h|~+V|w2CkE?UB!;sN
zA85wus~bW?aG5$aP+zz}TrIhv684}GZnS6BZv$kbv`qb(AK-F*ld_U;q^_BEl!N3L
zSLV<@;Cko2q~<N&yEiaiJ+;{TvM4onv{EV9^+RKRPb}hspF<OgSdhPn;_>aHi<3JV
z9=ss(`(|^I_kwov8)F~H2*(ar>ywca@QNX=R^aF#&#<0gd;8GMYc|{yxVSBmZ5(x-
z-%_K*f}Y*YPf3VGRsNVZ6f4x^G6n3KLwC3evM}oFsqTeQ{^p}h=&t3p*Fxp@7n0*Y
zz%FpyLSqI9w~wX+#(P(PV>a@UXyQ0&<u{k~A{?DIaVI@hEtn*?Vt{Zi@qE)rL(}5h
z@2m(q1rg_?FlvV4vHC6(@B2J@t~VQw){8|Cee}7+)V9gxHrFUIPvk^U*EQrzTlO_@
z7=sDCc+|JO_Jl`}0l5<H99U9jyhsbQAuweFYFhJ_)e`XK&96JXq&riocP~VIMc*eF
zPxRMS<S&LZDipjp(~+(nLx0^y2Jlk(LmQd2!L_bcvZ@Dhp|--?bZLzHk^gZvw<6$x
z^dZ2Zt{v&RPMLe!KGq-YiIJC{SpSW`yuQ|(rML58C^dVtHf(uaua;%b?Ji5XmF~X%
ziMnA%nao5kW6UVWhJup>OGm`R3N<zFz7|p|L8RK1)L(q68pXX|I_7c-jL`dGX+7PJ
zPv93(hid&6?Whd5JTM~A6?473U$FEhlm@_Inn@5@E7c>?X1^c~yhB+%mE87HT^?t$
za^%_#FxybFX>dYn5Pou(P_)2z;T_@bYR}PfKPj-t035q&C_?ikc<Jd%cyG7^1=?ph
zhYB)5Rkb82*<%gI$5~qhmQKx}3R(R?Uh7(3Y`?Sqw9JO9q*BZRXfpon@ZJ5YkLE}4
z%Kz3GeQ=q$;NsvRkxAEW9XwUaO{CVigr1AP4bGBGp-V;S?Z)(9hBrb?Q2RV%+xu1&
zz|Ba56FJt&6w{IC!zM3N06IziMNg{_1U!f}^Lat^zX@&4$VR!_(}lzawW->tN|E<Q
zzhVHrH|sA?b^2`I-|MYi(K?OPB@{7Jf&y5;lex3HH$-_juBmfg?SV2Pym3%F42hu=
zYRLf(=0hB?#g;eks|BlE#~pP?Scu#C@}OGVdzzKT^29t<PAM4=y3zq&UrIXUAeuy$
z-ZL0&x{|h4=53dueQ46F&YN%Mj-GmbK2Q5tgL<9DzKaN4_<5SS7B7u$8)uIDhRfrV
zCQZn?o)w%Y=8v|I$y=~?0K$e%pAYapgdFVW(FEITgRWAiL%`|BL5lOcOO_2^zkE77
zDGCADMKP0|Ytesl?w%3Bnxl7h0sP%_S`yY*-s|lkirkpsP{H_Nu;#}23)gZ?I*YqS
z<B6O7?WPOey$)QGsi1RUIZN{pjm1>pB%!N5CGAa%Vuvx2cG3LlmdiWhU1k(Cn%A1D
zu#(brVd>|9kAKEp#dWkw{cg;y1R(RA33r))ZSt2x`$**7tDPNyXB!}MXe~#!ceu}&
z{2Lxj9;(>-T%dm2#Q<FyXC@OoKO(WuHm|EanS>>+g!NccB~Ej&_{i_%+G>uy>*|G9
zrP%Snaeb6b%<`8!m(^hgw<DfM*^>Y#zsvNuuAHtFc&r%`8!i_PS<8*wTUcc^)kIh*
z>YJ!+G;+W4=ZU6B8bI_x-bd11VxyOV8ewIqn(HRT@YCjY`KXFbcBE2_;oaZDNz(Yd
zgvC^ovm6MZeBAvsXWa;DkB@;D!>DUI{NV#2!0VicNkT5{8I6KR9)i8RU(8$tZkPuB
zXG-?jY7QzWk^Z41l{&!Ioq0|KmfR;6adMr48JT%>aE!1(;<K&M?w*rp#0GRIn+qfW
z%$ghE5~I&}8R3(9-BnWo==B`ergt?r#TXz!EW?$hbHtNc^&(<1(4eK8eqMeUhd|;D
zi-@owlr!Btv`De<Z%V}S`aZ??d3LoIpM%ZwqwitcxRIz3Winn0TX0sdav!mRK(kMP
zd%ge0<;Q>ZcIf}2JFtuYUqS!!{_y|21-$|o!N%CsBE<?~5@5HW8|JoVWxwA2?SBF|
Cw2k@z

diff --git a/Templates/BaseGame/game/tools/assetBrowser/art/postEffectIcon.png b/Templates/BaseGame/game/tools/assetBrowser/art/postEffectIcon.png
index 316cb2c8360b1209e07c58fc492b6a5b4b6681e5..2b7fda7e4d249f28173670bbf4a9e0efd88552cd 100644
GIT binary patch
literal 10506
zcmch51yo#J*5$(q7D$j_!65{9cP%tnfS?IlkitEMO9&8L3kfd4-Q9v)a3{E1AoyST
zx_iFvneOSHf7VQ`RqMUF_q=oOJA0pfPn}P%ROGNRNH72Zzy`@ns{;Tc{1y>FM}=R`
z-M(J~z|&a|O&urox2}|S4z}jt_hyt%?sjIBW^Q0}0C1Z-fLS}x^5FzLoZ){!7L{1z
zhsy3_U;Mi9on%oondLCKneO=t(JE~CDv$U{n*PJW{YY!X4Ut%m>5)T$vS!y=43G7G
z6ZrmW=hF4~>fY<2YkHP#Yq1wCO5>A>hp6Rg1H>_nNfMg+WrV|NI6?LC_}#TJ^e(;i
zIsUx0&t;e)QqD2f%JiPZ-OqG<Bbu$PqZ1O{s>u;Wx5cfIy))7vbHyLpDm)5Nuee$r
z&#OaDTV%d4+3WF+X@0?NLc2b(y=>v;%&XIozrPP3VUD?@P~XbGthGx`-AgIH9JHPd
zkL5sF+GDC2d)OJF7+Ug7yJtEO%N2qq97ed7zHf9Tq-_zE7c&KkhA*c*-ndJr8250z
z1e<~>XuJi!^a~Bziq|ZwyA4}y?OQmDU@FE>XD%t$AJy6DR2>?06nfbEl%4b#_7|!V
z#+1i@@j8Y{NYTbItd~hXX4wCb@|Lrk%(aNjBqe-*u1}VeTV<SBy+)hAJo+?_q%TdJ
z+Md^IkZ$4aPaHm}vw<suI&ReGs2=y%19$s@TT{~LEuLK=?lMy3mB+s4^S%S$B=}3y
z<4IR8_j)M?tf~Dsg6hlL4nKZ)&Y|!NTYraM(Ejb}FIs``KRp1dciSDNlGI3si1N7R
znkGe5xZh;`1T`WUdnHgM8SOdx5}(q&rr{Z!S<vWg=8pfB5`?AUQb3z=3nQTG>#z6u
z0waC4OBbiF5T&lj^rnHf9OG%hyP`Skul4aStEV=<PA#bq6mx^Ct8<I3za#Gv<~*-1
zusXt;b9dM}97bu5;2-~%g+=UKm0@%K2x^{Y)?ZYqoa)&fN9f#SIyo6%($a~lAaqn=
zHoaJL=;bp9V)){)uIV~AHX&AVp|E#k*cw@V-2bL2sRDCPZi-)T?*^}ZJ6mV?o6ewb
zfOds!4^Xo)SR3hBHK;q>B>Oc}nqHS#fJvw4oADA={8Lef%l;IakO%oCeF&fJ$&vZ6
z?yeW7W9!JgtFGQu+SbsFMi8Oqm;4rc&i6W2N6r>&mfkv~*B(yZ=k2A>A0E;l;?NNK
z>3K?dG2EDOfAANcmwexR4k?|`J{Y5DMaWHXlHIjYX7zg`G%5c0z1+)w+7oWwop0zQ
zj$#$35(8c3Rw6<H*l1rCJED<HRa3j|I~-jb87h{u<{HZxi<DVDmrc!j5+0Ura4&x6
zezEK_83z7odKB+kz?SAo!q7s_NcPpMx~nPqWcfKm_H6!~MqTBGAg76IgFNwNlGCM!
zXvE1puB%l`ny6&?h?AB_izL`A;zO<NVM$1BsaARJ1vrJR6Zh9kdA#88n1aq?23bVD
z^R~#mNgV4osKvKkfycI1^p<_{u`jYfMyafc7__Kb2gC|#Z`+^KMYWjk;FO@JxGzf%
zd;i$pSJpYH5;v>}Nap&qSHv&KlE=cy)|NX$#USBrp=fJO-D;g!*i$YN)hTIdDU9@M
zGUg_T>TJhMS??9NET4H1aWSa;t;>tn!8fJ{TK&Q_!{ILK_JOb4De)BIzE7Q4_^Zg$
zUQ|dLI<sRlN~s}o0qL5#3N}1><>wcX#Z;p*xng5n-E$gr26Wi1A-^&N&4tc0@Cw6H
zA!Fr7!?A4Q?}Ul4EG8)z!M0@$SVMYS!5P(tdixF2OHNqoeOA@l=w75{N|V3FuwFFc
z;rR&q*g0`GIPSjb5bPf>Xz!r)38F`Tvwdu>T5&Qja!Ghp|0%vkVACyA$aCPtEKYy`
z5{H?nOH-}vBs^JaLC=I@?73GM<Yeg(z>Z08UwIv!sYI5&tzz)Wf_kabj(&>X)ig|0
z!v2YevBuMOM+a-GnA>4cwQb!-+3BqQe1N4!B8dBQCQXkT<7=6yVv#2kp@kIIwT{RG
z9`jl2+#0hIL?VVK9A<)L>7Op@sUcM=B8{<xg=i0wK`S-N;nRfCxThH#>I9KmLJ;Br
zMZP(qS>mDh8DZ|y9#+YwA#^^*%=GF-3o1yoMWqf;c}9aPD9?l*4&r&okFGkK_LhYj
ziU~;V5aLVp9s#mR>B^e6#Gb_&_U4R4*ZGMHxKt>lPg4ohKI_UqRb<bpIHfccYM-1*
z$mUmBD+X=C;tN;UhIoJ7aOx)I(8x0SB4@a~Vu}=IOME1uh4RsaRe@3t1D%Iu;E1NY
zfWk!SyMZmjaTK^KZb1K)&=q>;y<7svmV8dUm&eRDg^#SSn>#_Un5u7E_J?b<eFRTa
z6v>Euh9L~IUAn1g8+RQo9|`WMY%XA5x7~UJv_k$8@w6~dWxpsC_p{;&I=fr?bTwv_
zzEGH`-Aa3=ZwuE{k}CMTuKg0KK*RE#Hg45ij+H3~FB~+eFro12RL8GmAQ<Gazc9<E
zng1)Nn+vZ$=!tZf94C@}LVSVObKxTEZCb#7)NHi&AYFS$Dpm4j21rvJlc2l@GJYCx
z-){gaaxScl=VJg_V7VW6u{&wM2D30+;i%EIz23^FYPn`dlPpiGQHw7PC%H%SKtI@4
z^+2B~B>c75Ze|^+L<vh8MVUKMm|I=eBg7AE+_~2zS}}^~ex)k&3HM7kEIa)>RW5-G
z_Tq%5DkBYP=^Lt{Gy@xBjLdJxTX7;uxq4JX2>y>3+D_H0s5CP(8Jv2JC$(=_A|N^R
z{CBIz7_`v9q^?d)f|W=3{_$IHJj5EP872q@Eb3=+DfD-qbT(x8bjOfg=AIO?{6a?Z
zzZn0ZICj^cwG-$t!n0?oE#<sSNKq=)7#o=PnHhndFqk+H$jS@m3VHy~T&s~AZz_7G
z*ESq6ep`x5jxbq8*2$#3jTt$<C`jg{rpPp)qyuyXg)8#$mzW^XA(CTZ&NiaYJPw~@
z#0#~ylLCA!)Sij^kFm-SVZ3fC)t{_1e?Gwda<$rm9K#QXd7Xbp^iVGU0b_iNA-j<x
z<6b-J(CeX{g35E2b;{5C(PY_OFpQyCMcH<xVocN|?aTnF3@zH59~milw`o9JJ3Aba
z3B}wX0Q+T*ku2~inNs)yd3lBKF^02k*C;(&(#i;g^lJ}mUiJJ_3a7ELA1{MT$>;RS
zWk@>ws4JoKGz~L^KI2eaq$P7?gG_d6#|(+F%v1X-wdE;}lNM1L7vlOQj&^rCBTK6;
znx0vxKy<h+ootSVkp!bZ&rDc;#ax1@ugFw>QVXLPzb5jkZ>XGXK#o9ij#2ZLiC_##
zw!3xz_T+)ism`}2ngQ7X4|#WP3ZdWPDW{0qw2_nE{?H9q&pIa;GzcN5imsv6?7?Mt
z<MHZq%o+Ny%zIqQMX#LslG4nw4lnBvtFvF3(n`Vn8r12C<w~84C%bqg<Z*ApactZD
zneQY}7cPgqy?>u!M-iV!-Dug!yXMUU+nN9@J`2fN?8wH!4{nn2CN_0gWs1ZVHM>z6
zW=fh}gY$OHj;HcJy@V=~;(M1jR+{MFftfO#6|#(|<IjXelwVdkhxIFE8PU(0B=|ez
z{;GeAuqY!p8UFr7aPW%qK@vTlO}{S_h7}EM6`e@Hrdqf_rMh9|%#kis39;XaEB<^N
zOI|?IVkjWB?S7ryj&<3pjAgCyXO&XLb9FzV9aU^f!w*p4lb<-A<XJ=|3h0GTA$|FW
z(cSX*6RE?O{v^>njY1<MmC^;c8Xt}&S?14__f|~CKad=OpfCv|o1|Ka1j@lW+c6`@
zB&<);uQOBA1TGTjavV*izZ=AQ!=goH=aOoJ<BB+OKL<UpP--01_+ew*oCSF{t-vvs
zyOACjte+M|I0x;?&h<ri?!6`^W-)j@AOthOefE+R%^mBJ)-hfRh1412$3sUq)ODZF
z+l|@oY-f$b&Gx8%7%a#pnW%Y`Og*w63B#(k7A)U3auh$o7HDG_=aJgy7J+3FuowDj
zvxK_py~>qI6WX2vus(lnk$(*<{18WX%j;dU-6A5`B{0x6Zk&0MLnb;i^-U7hQ#vw*
z07gh=(inj^AVprqube(G812atRkVs{pB0PlVV*txVpTChGKIGaJ37sA-Kx4?D!tj_
zF?qC^SYy%;|585pwrl$}_DLzTv`4QN=1zWHkfVtrh2+Ss@NL%<){S90f2MEybzt6n
z=hoHX7hmp}#L7L1#WQZI!v0JpoQGIZJ6n={0;?q&k}xg^t7dc#Qhki=4z4TlRQjls
z#yf}1pi>C>mf6H2EPpnL?@F(<9?Q7)&e%4!y)mROU3_#6*|VjI4F9B14{~^iO7}H)
zoet)07%wH>;<Wu9<z;cUCGqAq&^$F2?9dhYgSu_&NiFqD{uv@rqNn*gh-u7$a;d*e
zz~KaTSFE>BQNg(K7wM<WFT=(=ChSC26Rdbt-@Pk!*Rq3|SeeHGlPa~D@uOLM)+6$Z
zNS!p3c5{|=^9{U1JB^A<>)feHCEPLfO1H$^_&aa#PI@hoCJY9HkFsK{k<^Tzi*)R&
z+ZUSX5#g;rR<JPnNjjmvC%{fF-S`%F(6jn^gMIuE29_eaz$3pwm+Nw|z$XT8QorU}
zEgsDk1m1I3%6ZDycwP!y_OVRF)7tWgAXB5M2R+)tLQN!TVBmGdRf76#A#uIhHaA4S
zeNKQ7n!psms(p@QSHHo{oV%@7c@vQBB+X=RCr_%0xgF&3!kC(!19uMnToMt1w@cFx
z|K}zpbL;^s5&L?FSeX5@)ES}uyL9x&7EoSs$~YoKc21J<<}S+fH%w2s7H9+9GZ#&E
zEU|VUWyP2)EFL5(nE6DPe@grKsgyVdomqmenCJp$l<HXsubEgcElEa{xHM*LLqT>b
z*@CqJVOH7bME-l$0*EiA6&uX^;KXCXRM|=vcNSwsrXUj!LuWbGobrxfI?#C;^P}9T
z<92#orGh_hWlB=lJJy$J2@HwQ3xcw0RT2`EgOY$A%0$ewJA3hgs<neW$fK0wtDp~_
z92|by#!2|dD!w^XGI%{RLYq8eA45X7V@~%ccw?(jpKkGx6j04~@gj}B#8y;S<XI{N
znFrfsR+d{M6Z0F}j%wTt>o**zq(Mlxa`Ww9x=HaE32w+!PmSVFHrdnf)lK3-Ydxts
z6Gh(zEpPJN1zbU>&Z&y1q6v(-<c(R}r?9h6RC;)8Bv$=q3}1$kw^Q9Yk!8`d*SH+k
zcxo{Ep<othhXxTV(ZAJ`Ni&Sz=4vt+BQq_eRCt{y_;_V)Nj_D)HQ&IAsP7z~RA00n
z?c2Ep(!p%%T0}=a5Iww<o~NWTJh1P9L9+Ocw7lE$vCm9v7`sB@0$8c6z@|)%wVLt7
z$(f_Y^KvQXI#*Ja`=rIG^O5j#!^Q0Ak5Rnys~~!O*YY~wu<=Mqv_t{h0LgL`EXq9u
zfj)(${CsK@$uljQREVo$6l7nMSx?yXV~E<<!VI2f!CbZcS%GxpF0`Z>B#vy9NPHGc
zODCNSF{`lV%vdVn*$XyqO8W0o%`PMNbeJf<VY_KTO1;^8gd~dFGuRylW0r}t2=cn4
zhy!Zam4RQsPRK(jiQHmcX(;PlY9Rt?!#|y8rqC7%u`2l01Ir?6wn3&UnK0OudAIs_
zQn=Dr=X|}~t#J}=h9>@ZI9=Ni#r4pTwyxJ<)Cp)_tJ|YP-`3?9#xfAJ=rnrOKXyo7
zzu7-!|M{ex7g^!GTQ=rrsRQhvzGyUo{0`PJ-`FS2FE-lz)FtgtR)n;ltq^M`%=Jie
zt_TqMbiLo^={BcAI#wXG!(vBKJ!%sU8qy=SS$p~@Ph7oiHOh8W{nou+R$@p$<BiiY
z_0ZlG>N7*;3s0;$p*d${QwEJ%Mzb!4Xt3ITTWi8p<E9O1`Z*@_;pfeLIjUEdbL5kY
z&#!2#(9xqQ#<t(7OMwTb6j;B1YdIjFwhXbT!&f3R-u+D1M~d&0l4;q)&R}La4kKO3
zPKs1bF`%nmX_9JrrdfyaD2`l&EwLA+<TDCJel?3$PA3_SCk#d30zZ9va@KY97gCie
zCzDM#Xfyqdho2`T{MOGQRKS4QmwWy!P>|$N01~$D@sf0n>9TTemT5+=%c}@^iK142
zpGY!;eI^V{#>1R;A!*%{o^z`k2HvMF3%TN@gn1$FMR8p>M?aT33A!D0L9TT}`bKQt
z75TWN*d!yVxyAUZNC`airSOY4wzDls4UUgDj$M2Cdb(zA=Q?B&{TLPJS(Vuwro2SH
zR3Z1TfG-^eVYn*bA>PNlm{cbjnI_?#c(a>fD9PKO!5c7isuQV;aSW<w^Ynl=z6|O%
z6G8-rywZFo<0q=MUKGDLYK0L}d!9-*6jlbGLGIb<T1%v__^ZONj%UNe1mA0P#hb0a
zD|Dz}Gbw<m&9)+B<{;{4lM{Dn!OrDyM&+MW1gQi<+Qthd_w8PfOh$63xMF=6grv8L
zW0;vVu)54&$bDSFkB8Lbx9_^n|4?k67o|qDp?(w4t7IaJPg+LZ5C<k^n@NyNq?S#~
zCFpyc4m4YrFYH2O=Bu!<pU|!fDwu*ylxu0n?pCzjG(8q7J2iBRf6BVupIf>CJI1I&
z6A5z2l`e?ISYmB0EX8%rEO~a5>FN1J@~7X_^e+sk2<a?P_ytkE<^WqQbL?&BI;guz
z-0v~dqyW9W4B2C)7uw@U&l{s2x!|uvoireZh&-n8HZ32vXJmci&q#Qvk*h)LwCtqU
z_1Lkjnf)gIaXSJko&tBfNiLG*cx#rHQ!PtgI!dbPF7`nvnu{fQ#ql#)blUsLRPW0X
zsPpjyny0I@LX=@wr#Av8<GaR@(s6VEKnMg&NxcF|N&T(K2XF1Act(lHcZ!pB8|hhV
zy~J_Bwg2`il{uKATkWe3GG<Qk=vV)~9HY@}Dv-TBzCI?77xQa!{S;?sI|AhP$GCia
z3^GKFC*Gh8nJ~28J2%%O`%9c--j_-o4fKEv&reNZdQ-<j$rXa;?H~%S;E=)5Cp+C(
z`n}U4!qDc>W9Cao?{F^xTlO{@+z}3CzE6C?S;@IQ?qB%36f%{dD#9fbD4!_mSp{x;
z>Mbi1EP~FJtkU?Unel~mc8y<;6Rd&P%8K%1kA?)99hcUMG_8u9Rqs2D4Gln!shj9)
zI+BPW^vG9I!~}`KqhF)nQOewK5IvL~s75PNYZHf&VdhKvTHdrjthm<7zO@<$Ve|kG
zp=O?8h`t8ty0t||CIeP!K#RqS0_3I;+xQ~p+(QqO0s(2ht=m~I=E7%y+;|)G)Ojo(
z%H14@c<d#+9E*f%>)XPUS34!DLg9nuTn$AcBSSQi={IzBcU85peMkfUyhQ5DcIZcV
ze%%XizM{TUl#_;EM}Y<-ukVZSyGM5Nx{d&V`SkY}0f41EgAbxPfs|#?HXfm(;US+b
z?w7%bh@E6~oTO|a5HlMmK+3`Ft&^E4r7PIUl2Q(&{7TywhX??k+=8SfG~wObMS}=h
z?YF(F4+SM&Njs^YGQ6Dp_J}yhp=B>Bq@l#0A~u-3nIaux6csHc5IYnz#U+EazugE{
za!o8cJ8)Q=kW~&kT{^iA2}e}v_|)cZe%}#nEh#x<bwBne0ao6Cu@C?_y~N?$f;X0N
z0l)`-hYSFe@CyR)Z>Iha&Bft9|FXz`<o!=`ANYfR+0#E8`}g~VKlP`J|H%CBf`MR+
z{@)DG|J}0xF8Kc{6#oK7<IAcbpB8r(IwJ_|)_G!+>3|(gIT;3nnQFrJ<LI+Ciy+oK
zhPU21DR*a8d#9N$0y_<~ebhV=jqY9oVneO0o2VEFK;wF$a*QpG?A3)StaZ6DiS08z
zs5ogFb|;aX+^I&doE)9ar4RL`2Pr!&44pZ-z_JoT?=oGkzDy9!ia}GBokz|nFrL8u
ztWqe%9O3j{O}W8r_ZJ7JFKjmsEl*F^4Y-J_>IKLwj{7u(-2zLdgi}-3EjezSaLCCb
z92QtOOL@e;P;5;vQa`XD;{s(OXrPwK@YALHROn4lYLn>F$j~Z(O#3W%Ndb7EZEfVL
z6gf7U^x#F7d8GQVpYaSgF`qxwy()oC%scj@T!fJ!8=MZLm$f<T#koVvpD#{_c8Z~U
zo6Sn|V|kbl6uP(di4qg0rHqV>1qH;9=N3r99bLKmz_s7}V>)l&d%a7C?*ZG$dJgJZ
z^~F}nX1)64J}>lPHrjT~!hJ*azA~GI?jXHyQSEedUG^S)WIp%9;;Q?WTdd&lr3BC>
zd#5EdSbJ%^d2pv!f0fit!8%Yz4EN!6f6|k>&!>zkr+OMQTkZ=trC+oTy6Sfm`@M*)
zkb<@~N$F3=B!=GH^<m5C))GF)H;uQ~>o4%&89P%%>MwDK%}_6tX3F`jVS6NpNuW`p
zEPH)tpSu=SB>`?xXAgE54X@yPMuNqg%SeaTsb+)SJ8O%I8c@j7ijCmO{(=r-(ojL3
zl?&RVV?YMp%WZY)%&aYN-N4@$rTY2>Va+q(r1{BTmBVx00MK{u4Rudzy6s4KQ`xnJ
z_B}S1J13h(nckn5Z|-f7;sQa-b<4SwwzUH20<Cl5dhn9x{AZmn;Pc#rQ>gD_gjm0S
zryQI}I|HQ{qSKP`FxI~OSfym%%b*`k)vl4Hs<vAfmStm}JE5@kvgAA#y30J*)5C-5
z1PmVoK^saS{bM*`r7%A<_VSB&)3{5^G}h^o8%zy+y1CT;`Z9-2RQ`0heQ}9`uP$T(
zsVz?1n$xJ0Wr1QEHZhl@I8<Sap*P)f-rY2nbCkB6^8*zTxaRLOGDJ1(wq|tyFuG|z
zVXgz?Ry3?L>TNmis{$vqjJ!<<Cq)Og3$#>kvK%gq!7j!|B@=Z=<Mv4ZRyY4Kb^m7G
z7WYc~_9l;K$Ke947aJKk7uUANX}nUHcT0pBv241}4RIA3G{hy)lkwpKb_EKcIrY~|
z!;9*iFO^}jvG_=PbrPl3K|X~x-t2>SJE_n}Q$y=q<qwBu>59q;rkV=5%E=!(?Uxdj
zxNJ~Sr+#m<aevA##nrYo%@yY`cPhL7xUwG>9i1CnmD6WBYCea9UGzH=F0=3-oa~e2
zd@Gd;NPm;?|AwIc!?BXy`bMfv%e5(St8brHE>zb_8K%x!7x?G;o3cWKWyH_)e}`iK
zD??=r^w+Pf-w3-GC-Fjt8)KaccA~=+;9xk~@(=5MK)bp=cd?0Jru_}ej4s^eb28EX
zn-MWXu+XwKs=KZ5P(HW2<563ipv|cDA;L<3Ay3kD!>NmC2~S?NVgd|iWlRo_Y}rK2
z?S|QkR#SX*EgHmz7ZQ{Mih1{!slC@C2NC_V{@qADe}#Dk`gNHA4o9<7^=4VJQS$O7
zoSlW7@Z(C~F^3jXFUpr$os(U6gyV8{0!BA>{7wEZOMPg4fnp1}Y`X&%_YlT<vF4b&
z_EBFn1Yml;c$NQX$xGyjY{B642jnKBkS8YvWu$m@<}cH~p*Su>su>Xh{`Y6}ibL_W
zr_<lDsZFrO@A9pcS9RhRm~W)WWd}OZ{0F@A4e$vYM&dYnWd#LjZ}AV*yG=b%-RbKq
zj3rhcgJ?BIc)Sm>d)-Yqhw6x#tJ!`h`k;zKRiZ(mEt38wW~9r`ADR5-j>*khK>?;d
z9#0=5kqmBJa9t2fN?q^lrPyd+&BA1}@>Gi<b2+QZS-(G5S!%w!R!1mP{DbPFtez-G
zWAEb8K1Q70pGA~*&v-|!r}{TGi`m!_)T05sSNnBo2E#3^o7K4uM>z24-k>cEOlOyd
zf+q}TZ^+;oMWlXP@^47_w@mxbIee^8Ottb=$Z+t?)FnEro4J}^nUQEgQW*r&P?#Gx
z<+OCnA~&DG!YcVAl9MsBAW`V8+Hc}DO~KV`%Rr&wyAwz@$8@f$o{wy+xY-}-=^<1r
zNBHCqS{K1xKE|QgxZ9#Atx7%O@o(ZwGuMPQ)w>$Q3AfF23D|8+!UnAk+=c!sRm#dd
zWq%NS2XueRdHm8)v2PwOvB|uh<JlmNzf3t7rd`Nw?6<EW{D9-~x6<i9s(b!N0Mn;;
zL%biV=naPN-+%a1*hD5KVVyQD<GjyvH?`q3a5)>aO0en60h8a1GkjbWHYkQ8_FIkr
zCv}P~K2$WS$}ycaa)ryLeqV1MJgoB+SdQKv3>36*-3L#keIVXepP(a-iv~|@F4?8<
z(NBaWxA(xc`|q=)?D8*s`7=$Fi$RX77I8dubjpli#hAYIp(=74u+jA&nZvSH8}tLN
z`nbTT6r7TM>D6rEq{qaEa3=ggh8e2E<(>s3gf?d(1R{pFHKaf{vNX`P>CB`13zw+I
zGzvC+E(QNRWSuZ!6D9LAqvXAysI|F4LVf*5z-LIPzyN2fl5E&QSCeA9f1?mYSnVZv
zq=F1DA9;`R_fFlsV0o1>Da?e2Xe;A!v>(qVpiT~n%U{Sg``+2Sf@=*JUS5d`x<`Fv
zkaI6jB*x`kgR5aH^!|mIhzD$WP!$_pJ0xN@ljy!IajP~@uAalvaWtG0A}2~0UR`+g
zqft40v-0-n<gM5J8raL}mbrCDA3+>w>$%HKwmAC59{PsM?aHf&?enE0J6R43t7-Xj
zgJSqX8?*b|k5zHbLbDjIy8G0;IK_s%;aP?NBwuFPL{T`iosPh<wA!rRv~7@C8kDe!
zphpd^X1<p@)4jKIh<$*ba6jCy>3UtS={_F}KjR7&gTL?|WnbmU?WMQw;OShS+T8eh
zm5YGkprZx%)%nXdh6LMYMW3@5Y!A%pj&m#y++Vg<cS3KkyC-hv``&u-!fSxV4sj~L
zcp}ZS{o!Juo0)+vZKF1?_iB7BMk!eWb&0600`JwZsHK%*W6F0{)kYaFF|nbe26r!u
zlPv|bV}A;_3S?k9tTAu<Gm;cQ3DkL|5hMODq^E@E!ym~1cWU~7QCf?`eg3nlTeD&+
zzy)+Sd}(y`kU;TZ$58VK5imx=d?<PU6dCXdq(BC=_mFp^^W7^x37DRsA++JJ5xxUf
zc28J=VFIKyt+9_5yPJ%4h;4LfWd?XUN13L=d_ufE^H3R}tm9D!$j3m>lv&@7!w|l_
zHc%JBdOf%$T$<H@VVrgj78}&EL-BD;W3K&4$O=D@((n-fc>6XLeUxKPKwPZ;QDpJl
zg<kFOQ+A@+k7j<`q4&dD9#<QgCZ}J$A7bq5!yp%COC^rOuu^yx;38316hUifPLZ-c
zI1d>nc8qsEdjeQ{qC$yB_@_=>#Tq}G)&8J~V!5AB<l1CL^jZ2M?)nyC*`>?QbE{Y&
z6j+%PzNsIK84)x>a*;G6+6se@wSk=EF54f)4Zz@!B(Knm*Bp*4nj9ynyxzOzUt^ma
z=42Q!t8tvP{ob&hm|`K!YLZMOa<K>F8n7`T7h8rB0A=TW+gc3%TFWJxUbmfbG{$jv
zVk3IPCF8EtMJ6W=7$)WYO^aPA92UAnYzTG*m>pk3yUo(_hZ`Xbio86w(?9p;Q{d4&
z2U$*99PKrQZBL-j#%(Wdc37!dEH)vpWKV@Yopm?Fu{$+O*la7@+^1*lw7uc*X9D<%
zF=*H+>`{Qwht11LY&EwcKRCDyu@K=HT{EhO+k3<5m`!IRW|u4Cx<E1n@gr67!j?Pm
z?Byog4T`i%%Q+RUIIyDI3;VHp#^A*PuiTl}r(Yn7QXuu<ZwnnEuFT1_2@={S_#?po
zqErmaT*lz)(4k5LqZWpU#y>)Tl^BS^7tuctl3+vAe;m$L0<__zy_mk@nznZa&IsWJ
zBvh@8z3c!uad?{0t_bMs?%jI1)hR?EoKa{4GxdS9T$Cl_O^chiKNBT@GJ?HZjAgUd
z%t<<}8UfpBk*z^pIA@%H?h{836i>UVOdUZVRPXQ1OfE9TKE%~SS_~=RMU*;GOY6BZ
zv{Z04WsA0Ex6g|FrYs!Aj7X(n@8001Au?s_DUEg#U*Yp3?Yn(t5p!ujz$ew4-fJo1
z!N7%L%9;8cMS9x$u*C|md0)V~<@6C8q@9u6nq~+Cg9~^m&Eh8E=a~p0E^vNt>M;hf
z`9P84HZ%|USa=lzq)#(UXo)6TEPf&U_A{||KBaN*c9s&@KIn5IXDD~x?_@<rzr&b;
z3=5paiG2t=TS1#-FJmceVcD(lzBfDQtns$J7O<`1aUIl#OM*V$?=1TNr44`fT>had
z{#R1+r}>{fmwz_)M}q&m&cUB9{v-2$+|&Q_0F^a7AepMi_~$wE7Xa`NNJd4vMAF#r
FzW}kW_3i)w

literal 8615
zcmdUVcT`hp*KcgYyr44kGJt@9GpI<HUJ}5Lh!lZ{)Sxt(NCz>55X%5#1Cb6P8AV_S
z7&Jg2lu(ooi8K)igqB2VBq52R<sRm)yZq;V>wCTTuWx0Yb<TOte)idWKl|)w@BPa|
zCkLAYl8TZb5a@vI#dFRe&~D&zH|WP7fYaKYp>^Q&!wox|bHMons1BAeGyz=wEBvB+
z6bK|GvvceM<zWs1gA&oU_U9$0e^A_aRGqhrv@=sV*!5cU*|3n1fY4~*76dvQ8E`#1
z!2d{WaP-Y1Hn#Ro{<;AYAkYzz?YYygcgB_{VljcSr#Y(}$lxNiSCHkOu48-T)lUN&
zwl^j3KyS(GD(ij%O)oS$@4d2D_lE0FvKe+Rr_Uw&Ht#)miTKAKznFxi-=bxWjv6#t
z)9BWxU_S{Fw*zB=pKvRok?V*ZWn;{vs8LpI2z%23x<W=6fSQAge18Vr1%%tXBM1nz
z3k3QR1Udy=0jBr~^xr-DPV#Rr`H#4NBmXAT|84BQmlK%vjm3XN{>>Oaf#i1m|I7y6
z1+4k~Vt*6h6fplg?Dd`G-<JF?@Sg9Nb7$7B|6xw#;Abqi>tr_OiVH5NDtb;qrvP#0
zY?R#9k-+Qr-X2oJ3OGz}r@w}TdOHz)12W!`%=`S=N#&42Z%|x4YcATCfbX_6b@bTZ
z+;tl|d%q!MG;j0V_>AAi$$DXyxv_Hi4^u~T8@{-AY=)^{Dtcm{W#FaB43B_FJf0o3
zGI_4!cb1H-wN{cq5|KB0$KEw~H3cy*&Y0bPWDiY@zr~l~K347tj8SnMiarJEWhXkH
zcy&C{2&ygxUnH7zG5f5y4H?QyUDkpX8au9z7!&{g%mcqSb;VYu1o8=alj?$h5ANC(
zu2@@6w#+uJVNdjYWDQy(d0=FXKl}aP`wXR1o)xqfC@DH;>S6B|a3AI!Bu$9gy+IwN
zbxxf<7H+KRs0u1F>owH%<at$(m{47dU0|lnKWZ64VcrGe%4mB+$b6?`NWJ>T<5@Y$
zj0oGaaG&aMXd4c3^Ue{RMT2RLG@sSd-?ApBZs4q0R9$CL23I0dC>rvnB<4Ud$!oZ3
z>Xn1UUJ$u~Y{~H0$ndIRI><|&QD`F1^%5%%$f<LaCh~bB$->PM`LgF&XMM}U2ct$7
zIW%Dm?cw}gP>#B0LaLE@?ie0l^$UK`-8+9c=74z<<rwYed}oxWd~tQL;BQV7<%Kz5
z6tfXXoK4bkyN?De>bj+bb}6BcrgP0hz|UT4&=VW&0n-8Paw@#`e1Tb6mKk8@!b@{>
zX4OQ(7Hs_24}PM=f_&oV?XbB3ut~t;=MPsHteIjG{mqRB%zvfw*0NHDeo5Kvk8%kU
zK3UHAXVEY}v>W6)3YL13l0*BD^(19J8#Y1y&CR6l>yHUT#(m2Hu#L|x9jpmpfiV}3
zKi?EkY<P>Qme&x|a*~Lifl8f|Uw?Ka{M1%+kWZ}#)HOSR`aI<)ntNd>i)N{N$_GO2
z3ljHPSJn0kJ{Vi&ttd1gS?BB}_BIDEm<l17v>R_{-0$Kb?fM<lu0vN)bMRDY$0xL&
z9ZvSkdMWIzdk<vM#RIWv;dQ}!m3}LFvTSCwFU8<s^Zu{NSVDtu%X4A{&XW;OAG}$r
zIX9L?g;W=*$s1M8E!DMa;|carFD#(Yu2XMw_Oz|uQdXiCr`?N(PlZ#g!cXi`pEh}4
zj6Z{&q^FhTjYnPgv!mkSz1+MyBYC`wC-fpZ__xM3)y*1YyixvzA0io@r%Vn=`ww=W
zx&-}L>f#>qV*O8XQ%)Dcyr9&gu-IyZ6wT^p?HhGsV2op)23HVlftR;+b?wi3G@o~<
zN3c3gH-tQU`oL23ySQaPd(QGrOpHBh$3Zjumfc~D3}Dv$-#a2dd)w7@IPVbc#mpUn
z!xJX;1%+-kls=xk9^Yo*h#{u#u}Yh@g$;dpUT^B<F5sj5)ZDkHYEtGKD{kKEQIf~y
z%2(-Ja^bJVh5T)nrYDGDC#@8SR>B$Odc4IvFn27mjC-GSKDgY9L|Q61L^G9;X4|18
zxQUZn^LecjT@T|7CcWyK5-3lyt;W&$;;-I-vlJ`;YU?xh_P2@!uUsw9V)XHFfHzIJ
zLQ{?5bXuzIQJ)LDio-WlMIn4f$p&tRXGeR+C6L@vEK20%=%!M3^2peH?Xtz5@JFMj
zKB8Yw>2$m?gp`ne1wLFK>^SN3r_}dlaIT$l4{zttYn%{OPe=!BXhX<f29iF;hYyoG
zHm|Q1$_)*%_DN;U?HshL*!+q$)m~gQr_)VB+Ot2$&4*6W=6F*~$`%w;;Yta%>_-i?
zDEIB+AlPIBd)ggbN65qUmdO)(IXa&CMb-QczE8Gk4V%jnY)*6e<bWwBs}GH8HTw?}
zoqP2OyK;6(q!3S=xY~#5H`V!_r!-A>&yI<#CwX$(RFo2-w`VMy_L;Mt)fN;mTh|ll
z&lbZLs+>A`^4e4#xL);h{V;9Kp*bzMF13W#Fjaed+gfni`^4O_0<B2ex>h7~w%0n<
z7jObfqd-H{xuAYnNENU0wlJjgWD!O^XmDMt{P6Cnp~}CUL_eZ$D#|NQyopCy#kI>6
zqw3I_d4R!I4RJX_9Z%$Dn2C9AD#1dJ<MWoVbQ2z4hj2zkt$3i%V+|jyZWmr1GM>wd
z((S7Bv<O<V#C;sX){nr_$~-IrV@4rw-wsRu26C{JO6A7iUD2@m<+G#PtxhE^NP~az
z=EnhJQ8PEDgRjDIr|4E#b-R3=ijD*VDJ6kg<nGNdD;o^P6S~;6x|5E1_Z~mS4G!e$
z;ZPBB9~H~yqURLv=6?E;YCz`{`n|J3rH<%%6~JKe7us+dnU_S9;b_XI8f%!U8K!Zz
zaOW%We;!~Q<L={$TlBEt-6ypnE=4g1{|NJlysDzC+>KKmvs`8f>sTq9A7{E>41o2q
zJMPWe24XJcS;6ePc|BQ|%vWTm0@-T5c_m3--k8MFun$38u(Pq)pYt9P6BvS`#0%Qy
zA>Ao!f)*^Djy@^23O56{Cq?~bhHY`yS01i*zvi9)SkZGQVm5@gJl7_KYf_5pj^n_K
ztzNYVzY8g=y7%l9J$Rx@UC6>{JNDsfe3AH6=+Yu}kJ^KIMOC}l2yH$zQJYZOQ@391
zH93^Eqs$QNV9;Ln&#}9D@1~YR^eWt4w{LzG3PQR#(IGk;>qQ4%lS3w4x+h5)M`QO3
zSp0g`?%3ix#$xDGDQ*i?DbhBPot>Kbh&+?VVXe%2c|*)|IbpR1@)_m@rdKst6W-&I
zXN4(ij<a&_Tm2)Uy!)GHHi(-yHU_j2^khb~IFQHG6p7v>&_)o}R|ZS%pp^O*qSq(a
z?Nd|mEeT!<%Ci`<H^K$_YZEaXI$6Dhc@#U;fMk4Zcn$BVVv`G<3hb2#-Q9IbL~Fxq
zn9hy**g2H<c=2HcJ3O5CJcTK$K3^7f6*Z`@BXmKH7udZTi}?LAG=bE52xQBxmUL^n
z>UbPoy}tPfEEe7l=?O@sTQLjJ&*>)gd^=T&CAtcY6iE}##BBf07inBp+f@-ZuU*em
z)sf?s>%=m>H)`zRY~0Zz{M`82M#L7j&z;|F%6qxYpf#RFT|LQah}8v`EK!@TX)<+?
zDqV&(@nIe`)kAsOOlj$*-oYArF3OL|p(EbS7!v<Jxg|qZ^+5Qv6^OUqZJCQ-jC1R~
zJxgMeuA?I$s%CEt*^oPMA2N@!bV!+WzxO(2x0yqjPh?;lho+*WL^YK-s1CJJnPABl
zXlbgLH$*YAHbX}~62+7owr)^nA5yg|yfmXm7tB5TP&e4)S@vyRT8A{JU;s&Z)40hS
zW{fmiG7c}8uLM|N=Qwfo+*r#EE^pb6x6NF9ebX>{4(#bLqE;Cb^Hc<rrPLwk2^-uR
zOYe@Vt>azF@3s)r0uEaVu4g$@%FkNJYY3diH<TbZG8nv4dnxWqDmQk|g!!j@_N_*(
z<V!Lg4PKX^U1D&9DbBn>FAR3uVY1=tlOd>CXN$sJ1p9f?$A%DFX2}+6ZffOn*63HM
z^e)dVg2qOexSG=}eS5oOKE&ITTfNPFC)*U$m8XH*S4(Vllf+?foV$#waL%OhS7`3i
zsPXQ0%o-tponeU-rZlE*`?ArPP^FbVz)vzzTg(EjVtxYJX?pk6p4mdgB&j|X&K4IY
z8Rph3A&uOuBW+Yv6slT(yzBBVZ!9T3qVIfZg)Xc*S-qXxvIpEl*_H{Bs$~7hNIz!%
zb$dC+20{N4-EezkkAkKOqR?mj116}(VVU%@Qj0#);CJi&qn2PlAgm@Nw4~AgoUk0q
zX5`<yBbGLe=A790@Rom|&)pMT4VKmozS(Ci8!Fu3Pvlpk<$h4Ci+W|PWWoq6`WeJy
z@cWcUYgdSm7%z@>jSE9;9TW9IJ|C}8=++T;I8Rc>Y69Yq;_%^rY;&oZE^)YG$&ytM
z%*?D27oVu*;>~&_WPGY5FXcA*^?M(t$*<S-P!dAm9T{w3Ea~1m(dDpg>vGW4Mct5_
zeL=L^BQS5|{1uy?Ix^>!RlKj;=m`8dq$K9L2xL|j)Xr`iKw1HJ_>wQir(kb4OIyk;
z`OgMBX_@4&!h6&A;{DzPwU-F{?s4B;hs9@jrllWEPZx#Bs@QL5OQ`Z}Ec<GI{1Tyb
z(Hr`!ec~B8=t#i%5Y)#J(|>YY#z1cM0T-n^e!R|8K2?4$ZEAOW^5tH=?ggDmeX^h0
z{SIkzP#DnD=}R?l<@Ecw<oD!_5m!$PPJs121U_tr5AnDuU-@GH;HFtyfx9P8J%g;o
z3JY5I$Wg6pZ1vvDw!iN5mz0u654L(I-C)NZ-jcdIc-`9iv72p}ib7{4iJtkuhWsZ>
zL-x@Y=>^t3ziB)vE)|Fyk@LUoo&uk346y!6xD`xeQ{$X{-Y#yh#j)0HXMN^J-R5tN
zgbdbBgjopeGti$ub!$9fpb?2JEuqRw=B261thq0;&HL9ch+lZ|JC#R`_2Y(cDCfk8
zw;bgaTs5M6ZBpLhdijbHvR;d_Z3ujTU&wB3v9^_APubI@j?&VB&p2V<fFDxYA*0DG
ztp7@qnz#j$&7g1&o3N4$L5I`(Z|HLt#`1(K4D7%!j%c^Kylw3CC~`$;DZ6`WNdrP&
zYNzZOHL-9NtRx<FclN{y%dg=WFp^2^ejyXSl^nU~>qs#iN`FV)A1-ND)2boda*S{P
z7Y^5sFNEE#C$*X&OHSA91r54rXL5y&-iXCXo63;*qq*&|j7*2oWd&U0_`KkWo5j;l
z;X`N`{*q7A#tZr#!7-by(S<X=x*64oKNa4ud3umZnBJxv4`tUUZ$yoR!|DR(MXZya
zR~@f=nx`q^Q&m7^n(?e#N`^OZAm2+WiYlFKq>!y9q1r>$z^qt5zvTGS60WUqjv_g7
z97wByNETlz_T3H}A#GkwJpH8G-33Tr`S#W(FQ-!ar{hsmPN56d&nniGa|9<_!(Zy;
zCp*$Sy{5IulQVx<<3WG9Y6jejG*C+~T9a2N#@;YOw%b%9qE8493WH{yI8W#}*nEaJ
zLp$`zRvR~>|K!t>J6jx7YTzAWMvacUi@@h|sYNA4U#|j|o2}=SyAABX_#l|o8#I!X
zqIB&~aw$S31<`-)I#?F8d#Xxbp75Md7XEn3snqCog-o&EU#+8w>-hQQPR3}pF>D_E
ztjQ}T0XsBgp~f5WaLI?cS6NgnT}u<jgwZ&$Ax~3}v+|PgqS&qIqGjY?u9#}t;k}?#
zLm=UbWc+3#E2)rEG&t2Ko3gt-<$4}NVWlTgI;_``q}#0|hf4#t{-8O;)Pdn)L<cb{
z(mo35Q@iC;BWqCdi(zgg8}$1MIlv($F@k6nl~Ygu;m-5@j#-Qs)liyGHZ+biJ)oZe
za)mOB?>#_JN%fU$Ky@bz=JW&|<n*m5+%ak9zn0>)RqEyqoJb6BB{3w&FS%R~O(?&*
z-s|qPeC>k*$RX#f%<TN%=G^n<A&GfQU7yM?*9;^jg#SQjw|33z1h%CuT8C5xp_Eo+
zA3}chRwvtt#F}aUs9ljiDLdo{U+x8G6%;UXTawF~S3hex_@B;|LS%m&DnZAuctaVU
zm=hbhm4DS8uUBv1yuJ^l-nz2dPgLW+#=oYW^*dW>Fd=Kqmt_YRFXtWVBT!a02U8)P
z{yTNg@1eA69c4u5;!BJ>dTmu=vi9?n%?Ke?0eM;DaB2tO5OuwA^~DtZRB8+8&aHT(
zpiBj+sot@6$VrPiX=L82Y_lz~x)oL968EM<AHO!KzTh+EEmJ7E73Stsv+)AMpQ?%M
zQ)BeW#|hjvO<x;VBO*Esv<^nK3M9c_)lEs%E(Bq%cEv7#Z1V~rc(>4|JGC=5VsHs{
z*ENnadiZ{AIUY~97|O>@Muhng{ahZ&Qal?e0n@$ZYXtQvGw9e=Z2y3{Ive4VNW-X`
zQd2>1mL>1HoGE%?iW{S2@m;yF!LsA(QT8sP<Q&Y>YP0o3r5@U6I_;Ib5vjK``u8$A
z=lv?VuvLKc2J%y>D9-pWN116@5~@O%xH&EhD*5B-*~WQ2UU(`r<|#QrF6B3%TGZZX
z4B))KLoxh>9LVnJkY3i<7<0AJy!?DsvgUw^T)E&d&Qk(u;1u`;GX`W+?AFYvP;8je
zLSJ|;Vx|0bkCeQ2t_&}Dhke7tqo&e_H8<9Kz(L!4<^l?|x+%A##4Y9#9PZh|2LZ5r
z>cvDgS<0pG9+?ifQ979{_8lET`>o~%m*sgD?mK9o#SPn&3~bMN=Kt0qdG8AM`0Afn
zI03r_%X_To5qQf(e#n&FB<}pWkt%%n4#|3NP&#zPa_|sg?Np+t;>fVEyT~k56<k%n
z1h@Nrkw=kTWYHnwKIt%;<#V{FJgdZ0zF-Ye1z2^kwP{VcliIHav-fg2F;`ed#ic#=
z!5>%W^$)X4NWEW~;}?>-Ov(e7xQY<Ak7b$azZbP2f&A%UdT~`*t1K<sSmzBlf*!g6
zer99Sje8q6@p4$Cx?G85cOzo#$>^<2mu(UH^K$pLWX(pxonb^UE|GoMYv4m(vWeG@
zwKkJ)K)DhdHJPZb0oFdzV<`JrN7U)5Ie)8KF5PR=YkQ_CHa5gA_)&?Nh7aquE<i<4
z8dx*sWpK=D0C#}O1bQhK5(l$Wg}#Xu|Mux8-?*wvoLe(+hi29+k2{OBTNZe{0rx-e
zX5r6FR<AA58@C@}te-yi>qu`viv`3Ay$X1zJhkqGj^SGQ0~Y?ww(saze9(jo@%p16
zqmX(a(5;Rn-wtv~^nBz~c@w%F$CpV7eqX%MHK$farB&!!6)w@};32ow*7``G;yxh^
zsWm`Xu0JHlCE+*CbqYkoiDkf20u{SULd8>A-J4!OUNxfa6~LUWMUjGFlz!N@2Nv)t
ztB4)_GuhNms6a}}7|}CRNnCD#a|HqHSCqJQn?+T~8?A9Ij6Ko=9z=<wrdQrkl%G(U
zZ=MZU?)hhnt;r^6AO-y-Esz6T#@45D@!n<E+AqvZDL2-}VnuIEpR!8=1D+3#<Rocv
z^UgC(vsRt;D<=8P`mjwmx4)^6Ewb6;i@H6Qi@G#8*e$S2KmKMF6v{5Jqfwv2bu~AR
zyvUEMuPkj%Ynh#(qu<Qr>^229-XL24Ms=<Y9?u;p5Hi19N$N)}zZ^!)(aU)2iDiRE
zeT9py{@h+xN_;$DG#az*!dsDDB>qj>&Iv*or6Yz363+NHD6dI6HksCF5#|xyUUksQ
zqf8PJ!tSQmOn1j`_NoWA86|I#ma$XArb2rBC9LC4gO!P%H~(Tb)qxy*X~?~osg$xF
zB|OMy;x_7d)j;iPX_bev-kfsxaLEShRx+i?(7MsrRu|ja=~IDTYKec-iV_Zb6KtI|
zGb7pIFd(_<QwEA4|L7CocAEh=Oy?(m4g17}Dmi@AZEqLshfkQDg0tb{`QX<Yss|sm
zJ@nfA63gv0ve9e^=sSi89B+NZTQ9{niZ<SPlf(Rvc+2>S%~S1uUm(5!I-fwvjAscT
zugPl5Lh(k!wI;`Ii7q2jsZ4bUwv%=@$Ru{o4z7zG_!&V1!Vu6%V;nNWa1Qc|;WxB_
z&hfmS+@RNqSA}&ZiwpUY31_3QWArq*r$tKLJL@b4+Z$M-@$7=AA>5*hYM=d<1h)vt
zkRS#*Th<sxJ6^SSk$j+!{P$bqk?LrcLZ7m1c8e>U=Q??NAJ7wgDO~|EZECp5|5xru
z+-**$k^ll>$3lvnHS{JCFss3F<7G4w6=g%I6AYvi(`7&<ZlI%GG?EULfsJU<FUYcX
zUu1P$Ex@^9n#aY(7Pt~F37q{^()XY!vqPm97sJ8u=jm_6pKfofkDV*cfK6_F&|lt6
zpMyV0=H*J(ShieV@1U$ekc-~tW>#n{UfAs|WINWy_L4=!ohao9g(ig1Sesmegn_d*
z_3OB_tU4E8AY|JkQ&DWR_+N28&4m7G2zq=%bTJY6x@5+<UZqnx%J+}64$?qL*tIX;
zlvO;rB4g0#T$)kASA_^n|HgMK0lm`f<xd%uhpX-dBVqQlx+>!YkXgu9+lvXrz&oWV
zJH|Z)Bn`;7I(HcOb(l}lWK6?)qiW*yaGd$>&)Vm@0d=e=o7C806dke0^;hpp6?3$i
z^Qn{5H}A^?hDB)8#uFT|O?(0!Yy_r_d@{DcFc>w)aMe0v8a-|#qKTo76figYYMANC
z0@nt!@VX0++v2$&uwF!jAC|;)7+>)Mv!V|))Bk}QB32a;3F9w~9HI{OPS2bRT>?K-
zs*9ZiSAO{mw=Z#Fv-kcnQ7O>g3A77plM<z{`qNtCH$PzGXTD$|Ci>tKCv<U0#AKbn
zJ(dpH8ke(q)Mhj(4CCF{veHmJO4xN`G1z_?G2EJo@L7DRUH%%(67F>L#q^N^^vVQo
zJUK4iJ?<oRwE6&IC(ak`v+J<}zj}V7G$ZVw3YEcM>akvnW`>vU?6QYbKjP02!sdI8
zb(G0}y*LJ6P^_#i*6p)y2nl`T+I{cg+yB!zMgomvlkgK;=|wUI=;8FPWA?AfFN05G
zKYVx|!?$+_P?|R5m|)FcoZX<EU;H&1+a3bALZt5vZHB5sr!Z+Fvcn0sf@{}F=vXAS
zle|U-(n_kM=gP<0waZKGZDQ;nrFWeQ{%zxUI}sj#H1)|rW=mQN-I9*0PuegDHJ&s3
z<#;+!dPTYq-uD{%lvlZ^ScxZD6&P0sm*XAmq0n_Z8FMepMaKvTvb`e`$nq(sL)qZu
z4PwyDdzfeVm9ut);80q+(m0Vo(ExCcfh*qW?Pp@z)$Pn(F`d&uv-wFXi#iQ7n?L36
zBp$jc<G1&LKqu7;hkpBR#Pu6M_Z^VnH;iuwNc_g)J2BDkBtNo)4E_VWekbC33Yhr6
zwL1dR-u)lI(Eo)--vs!^@h-sozaani=sU^3nfDuuZ)5)%b{lb_Z4D4jyz^gx|94cq
i`G2rOHA95rT@t4KPFEkti~^<r*`9YeM>ykq|9=4i&tDV(

diff --git a/Templates/BaseGame/game/tools/assetBrowser/art/prefabIcon.png b/Templates/BaseGame/game/tools/assetBrowser/art/prefabIcon.png
new file mode 100644
index 0000000000000000000000000000000000000000..91ce8888ce5e704cf22edf0e5523a247d9830bda
GIT binary patch
literal 12431
zcmd6NcT|(>*5?~aK&c)PM1gPsQ4|3I=}i=oE=@qHNC-$T0YXVo4x)6aLMTe_Nbdwh
z=|#G9kR~<sP?LE%cfNIJ&APMhcW3??NLF5+Jaw1f-oO3u{;8%i-NkDc0RW&=dGbgH
z0LZ{cGJqNie(ZS-9fR%a-g<`aIxjpqon4)*ZSCQl?kHzCC)~@{8UVb;Hxi7ZxNAPV
zopA}4BzxvLD`CiHUE9oNo=TM<Ih?DSt2(vIb$RT&1(f^C;f`Q`Gm+pVe#%gM?MBde
zc^BjR`qdn6t;W4W@1A9m@5jFA`kj+?SZ`1tOgQ^u+s^Ult`o6&8H0>dIh=W$sN@X#
zs?E=np#3)3lFz5fnajQfzh$*miZA>^F^JBP$DXFtG!o7532^r_7aIJ@FFz9Tug@nV
zhdD}RqAJgi3MBJ7XMOrgZo5b~{zxlk^i|*6$8WjVT5F7{-rhdyF4kuz#dj`9q-f1a
z$&1e{(~!&M(`AI-*z&7?iJh1C^Q$`En%|kRB_(d|mAPZkJ_u=Fs|PzLK|43pc2K7)
zM?-SZ<EW9Fp7P!NXKqXKDY$<0r0e06R8k#b&u62e&M5G1mya&Y7}e-9wPPdedBG{{
zk6T}RSuhOK$(27d_P(*R;FBMBX6$4oY9_Am`h-h6#2J>s7eDUOTlH&sMBUrrt;p5G
zWMgAvQU_G_vUn~cc9)+Ih-`ReP2{#+{-t7)csW2@mPC|3T@56xypORYg<e_fG(#3}
z@ebgr1h~0Z8Uw~t08BluQKmSMw(@3oGF@-=SG#w^1Eebks6R}rzqt7B>kRC2_%q%^
zzPy(k`TACFIZwe8w~-iXtD6s^GnaLCxyW-Xd=0IN0+|QZ8AQYhHr@g~cX68JZ!_Nx
z1T)<b7roJuSD`KcT>8GKv28^KuZFQxx(44bcHXpKIZ_oi!&zy0vcG?fsTDUMSH^u{
ze&I3~b0(l?6316xYVszB%GCI{HYeRFE?s@47FX2x*w9T^u5PmuzP9PJj@sc1l9O}Y
z+Y{+6w~C3<x8uzkarjvuGk&*f+GFum^;x*IeA$8KntVNm+ioSf;?$~BaHy}q<=Otr
zcMHw~G6*aF(MMln3qIVtIN`?ZlXu@|Ne1C!RhtH99+Q#0iE3@PsEC=+NUiZf2rz!f
z@i;v=iLN?Dh_J{YaUW|i-4lJK9!V*L=n{kL-cMhCK2gu;n_Mn5)^Rvp=Goi7+ITYO
z89`$IEpPwH<7wdHX2x@Vnj1#3QJuz}rfvC`IX@$47{?HXG~WlT&6Ilt==fg3#^SWz
zj*UAHv0mJwzlbVCsftPOWv2)m<MmwA%Wtf^ADD*a1*Ts=E=FCdLYH3qB4@Cszsa^S
zg!~@6*ja}}1R(9h+;nlWOa51Z4<G#^Ud9oUMPnSFrgEesmsKsLZ&R$-#T{uReKo&i
z6M?W{8K1G`%b6TeMfHh(_H8G|$!>mb?mMF9yA;NvLf&=VxkS(Py8p-CPsT&;k?+=$
z8~g9un%(W1p%~H>;M81us2U$7B@wT=X^vqq7x?%p-66*%u0-LCEF~^_RG=z(a7nI9
zVZ`lHkE_Dsw5L)3<7!r0OyPakExorf4GEbZk=sT3l^XEa>=Gp-pV$i{`mAe7DUNE_
z^QP|v*074uDKM+b*Db0ht#0%DdH+X#u37*am(mA%J?FY){p=BP@fZk%j^`O&V)U@7
zUsd{8oFfgS^2bn<Okz#e)R8p(f}vD;bhI6u>p~n-VFGY%1<KN6nqM7!QoZ2mWYg3d
zC2x>*HH*-h^1(K#u)Au$KALA{1>lhCdNTEdOHqa;@h=<gx8C}Ze>O;&lzqLn8!)+z
zeff^`>rE=#m~O+zORttJ+wA$<ZzTC#uWYJMUtu4-AI5vP<Ko8mcv`H7H?foFK~DNF
z#cPyqvlTTz48kgFJ~!HB8X1##NIAlm>PEc}?XG?QVFmyEwEyBAak}=U_oCB0j==(o
zep(gYkMbo2ueDNoEX(%g=YLUmW=oE$nAy|5Fc+k=rE18B+N>^*jN+S2m^;oHnq`RH
z?o1s?x=D*JoOaHvB$v8UGjz%OYp+ZDKw~7O!pk?Scc*T|=jDE>4=&6fg38&XY2)n+
z?$Q>8iCy<BXsx*PB%P}L8|BK+>m6Iqr@F*GEBqu7n5B(<g;~$8$~B%QyeyJ^n*<#Z
zc?rGLID0AD+(2Zgi6Z;krMwHSJ@Ej#&3Ku;tTq7h@PZv#=H^B3I!=v|cB#j_<*)KL
z2J8AQS(LbgTt~V4qXGM6w1JEsMNWN3=(yv)qVj4Ue$>gP=u|MI7(M0BTTPeB(sXQU
zHEA4ro6?Boi>k!@XuqHR2rZ+^=gBqyFP0wLP?vIM-UhW%`*HUL@19*hPlV;vt+Mq_
zO@qgNWEW`E>k-_*9h#zB70D~nD%(`v%bjw_aZ&g|%`%#qPD@da!t6l0FTL&Hsq$&Z
zJzqkLxU%W|K)Z#+_uw?S3k3n<c9FHn$F)D2jIrbv?N2>3Z)mc$N@ed3Tx$9>hkf6X
z&-r3Fm1*Jeo38EO^X7f)4sCTF9synrkfnsfONx(anqG@<n#}XCwxq7^seQ@KR}1@G
zKFV?Ruc;m5mS;!oMRYj#7t-O#-;S@Lj;<`gfk%|-=Wmctg|iN-Pppu8Dg}e60Nqb~
z7vXPQ+@#;`wcqDRqzU(Fnk;$aQ50NMxL^M64ue+&mt3fOgARUYSAs4>KJxXa@!|&p
z6~Fju%w`|8&<xYhvgV-)x_)7QKrSs`y4*=?_}ay`C999UyFtLp3qr!9)3SSh>Z|m;
z`ZKp{5O7Q{XP((oXIdqj(7hk_nT)IaoA$N+g1u<E%HSh*Tfs?sL8<o))nyy&4q_X7
zcW>7J*zD^n+=_<f`29xhzorT`769H2sZMVlUsZLcHGwMg4z#if*Z#$V5Jh5D%`Go0
zD<;g9*Iw7jxsjq?im{<`r+aR6?aWQj*-z2nFZIEvT)~~9Kg;OXKJ@YgGuj#097^z}
zLq992f2MU+<9>~+yE!_PF5#}Ad?{&FF2b+d?aE@P-eWHMhw*dw&meyghK=*qe?~Hw
zrHw=;JA^eu$$8o$CDd`jF_r^&(xT+MoJu+b`?Wut)xDXh`Et3FF7<>-=u^Q0FE<@|
zSlZxgMZ*fn3Qa>)WL40cN3gP?5huvv2ik{?>_Uw6d&FEyis11n7pBB00Wn$$F38jC
z#7F>QT~U+Xyvnbr@D4f4&56-7e#cjmMEy0IRl!bP^A=3PajNlK(X-Itx$gwU7@ePX
zOc&W9qBd)k<Vs>!ul^C|+>q3rN;5z``BChQG5;IK9Yxp(yG@9`=3l8E59773(WTwT
zJkxLM{QLx4s-6Cn>Dw*%FJiN`1q(J%RryMKksEaEnp?UZC#S!t@E?4d)So~0D}NKm
zy62JoQudpuemjyT$7sCgIF;|gtdReFUW)zqHH<g2@-^)0c={CqYRb2^j~*fukwrB>
z{$wjGZ+n=l_QS1v<0mW47ME(g)<&4Hx}TBasr3b2=GX}ZtBZTg1-w<*b{9{fB<Jgc
zWc}i`^j;KutD9VWSG_~u&d#L#UdL`Td=dAEJZ5}F+oj8=m{wArH8;n{vYGz=Q!4b6
z<?S4izI>*{IP`^Tq0QckC;H}OqqTDR<I)7(mz?~(@Xzskw~~V1x?$dXt`?<h+Iju;
zF0Uc{L9HpB&dX&uH*mDT@LNLjmGQmym_Aq0=hH(>#sW|GKmVmPl@X{k7p~IYY!r0a
zU4-s6=|N-o#ge)q_oo_sKI!6~a#vJujWii$zWnw)402iQY2nYR^<f8{x;2H;LKkin
z&^8ijS@MvWus;6wua%DSNp&ksI9xery<}U#OU$`|sd>lK=8S*KMd)rr>~kxIMtHZP
zZG;Y%m$13K%_^&C=$*qA0hRnnt(-yshvKVJwkuRWl;^KJ`oj_#s%n`|bxAp5B<1nR
z7u~^H@)dv1;<j*;5>$IFivr7;rDHL*WvrSHyz1f<caTQHOLzO5(?MUAUKawaEljAR
zSjHD*iM0-w%O$t3DWDPzA9^W8W@y^Pz?nV@*L~t|&wgX#$M{F`?n&0h+P!+*kA;31
z^+gk;(Gm307z<^h&BL;hgwXv+CU@E**1t^kHg?Q1bqqKWo#7Kn0=B@<H_b1tWb7Rb
zvy)vPK;{pxcYhx0zrmxf*zv1cyZj<k+of)#wz0oHMb*>xL&?9Ilb!?&7Skd+UO3v0
zIE($zTN%w!-2bx{YI0v_ycyPKAwe-<AB`>`H_5m7zAjzE(iY8&30EWIm1sM-yQC{@
z6qGvkgd68FMk`H;X~>n<Kt%M&oi+<Cab%DFIJ2ozk}O>8_LgR!kAjLCQJcmLKHkWf
zeVX{kWTfqUig*32nUdsddAF;UH&I_j{1`?yrF3$CG?e)>1BXu|pQ<w)8g7zJw<<ma
zjDjzRFK$gsTwH*Deb}!-O~uEv=5Kj;ovl_;=u@dILl?P^%fkTqyDhnmhuqi8Au?~D
zuMjbZU&LZoqRbfDZ)<-MeWYpnqtzgvr<i*n#qWaqhf$>Hf@zjd7_*d}0&{MOs#1c%
z9;e?DDgHb4%@?8)UJo;wpZ17Se%DfP2)MN=(CwhU!c8x9`O6L3<=SplH||G=(&44k
z98`02eLsn5%L!mYNOIs@7-qFu!;wEo-|^j1Nl*d+NTBV*hfh@=KKw6U1+u9mzYnrc
zS`^s6n;YBd-=_CqbZLK@%>NGdT|3W^f+n-@M_xcjrumPIKUG{@m`rHs(frTYO_GpE
z=PMM=42<I9H<eiUwlON7l|rf7&b&PFE(H25vD@nRYIy;r`}=w_yjE`cinCW5e!qo@
zybJFB@yE({T9dX>SsCAkkS%_K8zvkr=_J&|&DeKOL;St?yL4<;D=Jmun`)Z6ucl1V
zAmw{ljez87YmH4=JmT%1`l}R)NBm6EhN~9O2Cn?F{q?0FCkEdm#qT!#t3dBn0aA<j
z)xykF#VvV>`j??1nF@8}(}%2AKEC^r7iGz*baIb{^kqXUN{!2aHI$7eNAb1INi%8I
zv+D7SR|6^+TLDrC+%J^uwdp6LssjAWu2(5QBVtz7;Uu5V;vjm@+n5FhA)jdajx>%w
z@b6-`_^omo*&pXC+7L*#g?>B}Lk@L%-FQE{YD7*G=1+^P@FizsBYUaTY37OY)IvCs
zQf&7L<Q*BVoe+-WHjwW^E!C7C0i^TaPYv18V9N#PCq`}nKy&&04FM99u7ZtJ?kXBe
zRErm&R9AQv`)!_rO|0%phVBoY930?|?!ZG=_zQQq6{n}IyA7wZipEoe*Yqp^zzL{4
zdY}gq=Bcr`>jsv~Yx4d{H-#nNG4Z`mv#QANyuT-j?0w$2CsOV-(KoO!(0G7#FXmV;
z%~wt1?bW4!0^B2W5s1pu4d4k^AxoI4igV<-$4bpvf+=~a{0NUD#*;=U0SVn>4+uaF
z01Du)Kq}7&0RG?;#rg7}$pQc7tN*aO0yyVC7Wr?@{?G3I;J|<E>0h<|`+b6={yD{e
ztNZ^V42T8G|I6rqC&T~KiT-nK{Lh*Gt@8Y<EIS1JtLzY-vUMzCWhEtvvBQh}cNwC1
zOh?bgNTX}}Q9KSJ8m9LX)brNyVIq@)y?X}`GJtttpFv<@UTdZ=Fl4#3qT$2vaO_@G
zH__66gW$aqrKg|V-_PTt#jv|yc*43lBRe=jMGY8U&9_q<n>6bgwyQhZD_c9-O3!a2
zUmtn=?3uy9+P*Nhhv*BAA4Hn2=Jnc$cGS2T8$G|4F^XSoZa52#$kT)S@K!P~0$(EK
zh<gpEQ-V%Q$5i;m(@o9FO0m+$lDOE|MOtXUo_7O2*%DtXFc?;0Z(oG)@eyGWOzvwF
zFJ9bCRzBJw9o@!}HX1}q{QLp`KsVyo$ByV@G<rL~Z>O0Gk3hjCRS4^B-hzFanWRre
zY9phgrDbKYcUCfUu_o1C0?{rBK?DZZFXEEJ6I4l|&4QR?23*PYSqgLw^vrj!<NN6z
z3v5yTY$1KJ+C|oQ0=q)+Ss|RP?0XCDYvE?VSJ%Lf&hZ&KYfvm;(QIH%m{mVPvo3zT
zF*f#rTs?|U{^+Q~(LCPham!AzH6tJbINvTTy1VFvIevjAcHugP?c&QCOAcDm2gj|?
z<%kOb1%-vy4#*opC(%P%ZG!tEVpXF%(W!nhsb{Crm!}$I7c*thLfuv-Cr`lx59W{J
z;eLLSsl<)p$!gSHn6KCU<zBoM>Zs?ewy=PI`PcU;P>5_C;ja7R0kjOk>e*#1DaqB|
z8@@%DL$e|b*j>x!Bo6GtuHj0W9-KTr3t&=;cC_XNmR{=uTW=dMXTIn&Lh2$5?if3H
zc=+5yFsW;Nd=*xV#c+S<UpsSgF*6;tO%ywO5MOJXTDOA+txsIuPcYTj1N>}Axnm%Z
z{PSS{<cwcX5blHEo>(5yQSS_Wo5^tDBgB7jIUS2%T*e)W!ltU@HZ}?i3ItMr&Qz3^
zChabJ?(~P{CunAa=DIxn4ng>8?da=zA2uZ+w_|Q3S+ikmYT6NdC%&|#B(A5Yf{pHG
z4Q9D1h=Kx0qHjP88WbmYDT~i^X`v5XiW)JJ%buR4_4U4K7`%m0`^bUybe-$HXq696
zIP~G9d|6FJ+#LhKg@!vUWfctx%@)p<6Qg)SS!H8lvyMD+YT>5*iG<3|hC#&6?DXeB
z2q$1sQdlgwj7RUgpot+`Zu@6lV^gy6nVHd~{ndSMBXjevK$>M?w(!!LqtifNEY_~Z
zdD~aOL?V8Fzd~GUpA=v&s-|{6B$c=xy}s#)@L7IFPasWwRRDdWTA4U=_pt7$W8c?(
z{&_Ec)5_L%rI5CuW82ohaH9v|x#2?$ZRuQfJ@=K022|Q033KK4bvq+7qt4Dw*VcJq
z20Y&ADmCcagTr>qJD#{>332(Fl<P29>aP5XEeRIv|2H<sVx%y(wvpg-mDnN4mI71~
z=wf%o<r?F7YIcZ$rw15}gDDs-4EdehnrGZF2~=%_Im`#6kj%?6coLTgBQx|3=y<zD
z%%`%Ly5kjGlWh>XINl6L>a867`z(>u!*6i9gvFOHIKgRRxJjN3v-mdmG9zn2XWW_5
zXePF2`ixjE#7F_~zd;#o5gv}O>;*!597i&fHJ7>b_-QF1z^-Eo^XXY;t)q^C#`wVz
zxzB{Au7SpCEo#kx?39s)`~lEpk}yh%!N?@yYehA%{rwW@{XEEF8F}VBUhpYB-KDZp
zysZ9oQ|pD{xm=by>je+jYBN5@j7>;)PY(u!w)J6t^m>_C<5wPdcvK2sr7bNli<LC|
z>U<h#b-s14QDx$8{VZO(Y>a<?n<oM$+tWhj!x~}62|R{#$o=eES~}j2IT?9;eAeu{
z?)mqg>O}E0L?Q_y!WzbVbbzHgIvzO#kvH`OaX@H2|AYT7o$L01W06U6)#yJ~QC>nd
z&!pz9@lu_%_#S<4INhAtZ1|DNy2%2*Rv3<JK%*E!M(^)8Pd14Cy~u>*PSP%T^gIX9
zQ-Wns_3=KQu;sb4c-U3gw0wI*U4+}pj-!BSV`Ny^K8tr;(}d*<&ZL6>!aB~epN1X9
zBx2d=G3iLf5xw)k!?O>LM8b=Dk1z;#(cXCT=?)xeqR^LkB8~DQaXRd}iW6391x&@&
zObtLJ92<Y$w>rK$*)W2}rDkSk+B-N|d3xSiL86>J1vNzWKU0bTTi(jVkT0|Nx(9W6
zt1_t4RO3_(mUJ{D-`8>yl-qfb39{bGqhADqn`jb`iid|-S!u1XXFq5&AV^%^ChqSZ
z?ayH1%uiRHT<7OOUz$5L;W+X%jc;gZnIs;d8|#rbF^5wdzJ6=kd1)GEaN6~#%7je*
zRsOq#LD(J`jf4%aS^4=PH@Pf?u3G(oS=pi@H<H8bQ;pT`@rhiEllx`?1<a<?_z&~*
zq!>2kdr8MITvuTqerda9?hgAAW=6e9++42H3N(<87sTD-=$@Yaf}Xh*;BOtQv1<#A
zzrk(uXr-(#PdIHZk1TucF2XqAQhsg>dy+q~3%|DxpB#V9bOVv0CsVC%?C0bcAx2HU
zY(OHK*|B-1aN>wCGu;V8drA{F*E2uXA4$(6P2<Px<7$g^<KW&6R(5tRUloMNf$aHq
z%%3c$elF6aT^uHb%9CNby_^)$L%|d+E%_66L&c-l0d#$9z+(IE=^NZ-wo{yl!(Cbm
zF!XdL?Ned|PYK3<BSSJJrnvR1g2Yr3+3Zl+EPnVOqyCIIy?f{*A_4(Dn-vW6%%=^K
z|9qU=_}f#v^TGHgU_RABB`#pR<w?fu_hL5LiDP*?;Kk~AE#Q37Ul)Ed=}jyq5z0<y
za71GoqGmgnAnp2ov@!#O4s)0}b2splGAS{UeQ%ezKjnMae}#rP{Z+k*OMq5JDskap
zl)=s2uy<db1~dSc^0K-VY-(e?mfZO#I+9Ri(m6h!M~S&<)6Wb&@NUZ{Ps~!m{K#}1
z51hn<nk0VP4D6XaTzDl{>vI1b`AdaUVH-*yx_m80d|-wa@t<cJ=U)!4h(@c#&Y|bx
zsUSdzy_?-#gCetb9|HkvJ3H=xW{aXqr%NoS4LM3iS0zA9sHpe=F5YdWvoKK%JN^#h
z&R43YrRM@BGO08yy<jYM*vul{oL2!2Qo5?KI=R?!s&781MHfl$EtR~u-SPr`f@uW9
z_rf6VNGR3!_ywq~z8<jy?}mcn;>E9lZmjgmW0NMkApwBDQdMbfQej~j=up;hI9lLH
znvRBOX3c9c%>ped;78c`h!`7Rck?l)W(2l`VGEfLo;{0ScHEi)5iQ^(Vs}HFusd9M
zlI^iY($ud+ITJX|H>Ueqm%M}1I)@2@%iwBmS0H!tyWEi8WE4Psni(!WQ&Jj_83%Q)
zPSJhxwJEcivjN>FNDl@QQ{1Rp@l0xngJci5i=p~+WuB}MD8P)`D?sz)4UVOP`fp!&
zgGHLwj@7YS^$oni#V1_&*cSMD%0A9$dAkV=0A5oCYSMn53|^8U=hMgt(AsAYx{E;0
z)3?#e!6E(VTF2>*SO9@+p6PnjRL@Uau*QoV&Tx>u#0UXsii;9MA4i9Vw~mcZckk>>
zpr|83lioB1cT+2%F=!3qm5r#1DT<2|-17AQ4(C<(>g>U3QSmh7bpm|6@Ph;TGQu9`
zyvqvRKQx)s4PrVd|Gw7N=VDc21NhWQ?M%>5#4m3NFhhH-%R<|tWzc(~46t>$%pd1*
z(d)!#9z-2<TpYB<%U0Z=C}rV81~_8PlphpORKHD>6Al$w>@?L!oc?+JHK<kbNkQRB
z!2#Hw+ivt)?i%mf+D#F1i{=?@h<{a$(3c`C+d9MUA`4-s4pX;Gr*Q5jybO5Q0<od3
z#vLWjBDiVo=XbyBPFJy?-WZr(*Q#j8jLk@w&*JHhx&mKcziv0?ckrk!R(!AVJ~BEj
zXJ>B(y*cBP1SY!cUQdJ%7qv)p;vVGLN~1`XVm19yFvBu3GVSPGRfQHGCHZIBx_y!F
z9tA-kPn^&9-9DM9@$nJ-o>4hC)8r$D?HQ=l2rlimm+D!)?mKfp2s&Erl0KTkH-guf
z)zMT0`T?;tx^BQ3Oz^SBI80>vix0JV5rS0fgm4(CwsdD89$T>?iZn%tCN4Awv>lx?
z%q+~1_OUXxn2#MlXGy#WGBjzTZfxc{JI?8j)0STy=Ctvw4d;hdCNLxyK}3M0-j<Gx
z+z6+OqRE<rniDbb*h+`!&BM<R0y3N3vf~hCM!_lx0Rb;KCNW9HxO%K0t~$E7u{z$T
zia<xa`N=jbH(#u5OjP3pI#XrrxwE)TaK#@?Z=Wnd{W$@NhVd1C<rXf6&5gya*;{4Z
z!iKBaGkAn8YHPBNQj=Hdfbh02{213mBEnLa<%#<f^OP8UJ4VS4!p2q)&Pj^{H8U$H
zN!hfLMEwz&+bO0$X6>#AM=c(v%dxUZ%E-inaRV{f*&shH^!sp3$aLHzal5*mIQ@b{
zZnDe3e6kBhoJWth7QSq70+URa@Y`5hN6fB7dODZ6!%SD}((3lbT{ONpE2geUO<dY+
zTb|W`mHi4RF4jl&=OZp{$Z{a?CD(CYGyeF!4YGep{VmLD7yudvqyyh|Z2p*BRa~+g
z*2q-4QQv+P39>XRq{EG_J`SFFfiH+I&#H^B#%=RTHFwvu6hJ@jsO}_AOSA;2ta>Lp
zE)9Yf9eD5RUYQ%3+hAHgbq!|LS+N#h29hj+HikeWW8;p41M6o722o~x@ux;K{%FCK
z+J7)gC8Har@hk3e4cS3QJ0W#P2W!fbKQBW-pSsnRA7Fwa`JPibxx+2hX`F}TgtT!-
z*>YELQK2=+0nZvmOc7)DVqL#&lG1Xbcm`MYB$y&#T#?PQwj8oovyy8Zgg^lJ+Pb9b
zI9Z>FJ6mb1@jX(kY?L1F+kOa-i=%>K2EhEjq~^n7?Bd=)R{<7|Lh%J;J`fWh6*0WF
zFxT)<`XU$*EPW8Nc=NiL2uG8y8n=l)zh^RtQHvja7GDz0isOscKuQr)v0nj#x3vV@
zviT^k*Gq3qJE>5jlE(1SojU>RW<NU*4jzk%i-XGzuI&?7VNZ4tsX^f2#l=N?C#NMa
z4hi6@u-8+~dM#$x7)1b~Q86(C*SVc%9)g>oCcZ25-7z*c?g6>^?h0ZwTA;=gAxPzO
zSsDs<jUTQRZeLn@E+#foT3*gHFJJr$g_6W#*J|94e5dPbv0**>(v%Ru?d0>ueoFG-
zhV=1r#h!OZXQvAVNT=cO;fz~gGCZ<ARxvra!Vjjl$z4?_B~#COUJH;HEG|Ac_IvOi
z@UIyj84PWM^F|8~=Gs-E3Mty%#ncANLEbmG(k(F8Ej07}YeMK+dCv<0(`gm``!3Pu
zW(eq~qBW3L3d<yA6g`&)vp}If&}Kl(Nvw6DF)*`(e#)I-qibX32-jr}GX-e`%77UO
z`a=RR8;byH!7O*qIVs@m11oS&4YCrfrINEM==}}o{WEg0Z0wq)q#;@``Y?YjPtGjD
z4j~<w{lU`14F~C-E$5{4mH{pWa9nWhD_y4HGU~0xo-U|@AQ<k`wQUigqiDOE#-|ks
zv$F7Yb@pEuEOf{QPXof72*|%~Wepnf&I>Cm&ogaaXi`h;v1W}3VN!~<y~A+{_#$CG
zJ18)({b6qI_hFVoAu#(r;`C;;a5`f9oNzrEMds#7DQRcst#(gd{unQDT%30sB$}mr
zV_=N2^n34Vn&_RFS1>5%AQb|jaseBV59`4<taU)k&tdg9iq9+1WrDBPx-hkcP&K*7
z<rN4g#I%V3x~c5odGr8vUj6X5(er^OMP##-8i+E`o3^W;7!9p_;|7=it>!zv`1?yY
zar%~$w)N6&z|0c*i9atioHs%JcA0XLN(!|77aH8eTPmfIk)VW7HBa(|@AA?hYX0&%
zun`szabrD?oyy{C!W!`>p7g>TS2iiyX|TQ4d|kI&T3mSNZ;yW{Yv%(r1JiN_DpM9(
zX?g*5M1p#_7L1)eu82$lXi9sPD5j4*^|J7C1l-#^Klp;QVg3VU26#fl!If>vsWgek
z8(;LNWbnJf94wMj?kwl3Dz8k=;?IjwO2~4#?GKYYPGz4V|HLl?P@l*B+zEsTpr4p^
zpS;N&Bp;xX!J?9l=%rw4pw3_S9{CS--MHcHm#+)SXMM;yZ4>7wNSeIx#MWhyJ<>Qy
zC1>VNh-%E2G@Z6DTP4;O4Gx7peRLjLgIWDO5=--R4SLFy{0}Z*?o&Cl1#4il91BmC
z&%cKvr>uSTtV9ztiV7jKL5d|BM$h;<Zx`yG2Y=u18NJifLR2TppvvC^vx4EIy7MeV
zMnHr$KG!Y;0Ig-KGp%<zI$a*>e*qv$0pZ2W385jO%7OVHGJ8O>Euj{Z3mxe%=ns^0
z*IH?TnS6(d&^D#V>0J7JV2>|bpecsacd>DVf?H+<3*XRBYNq0>V7bO!LS>!_w13Tr
zj)lX|3e1olzty}B;<Pr0tW39+-q@c>wj5O5xhHR&CKA-@56$34VCk(v2IXaiuz)rR
z%!=A3+KyLhOo)0wG3TzuzqT%W|1bcU9a^zgF%{?Q8qWoY>iQ$OYf=t&9@G>-wjfX|
zpl_6Yt1||^p$8=N)D8`ABhrc{Xpb8Y6aeSr#`QV@C2cq;EB?-I8I~r5rI^}2Kaf`{
zc87w@U-t+upA44~a1&*N3-b*oLbeh<YU=7EK~T}xNAQBBYUgXX^}0}HrME3E!D)L|
z3c^@q?kX=_JL@*K`_Z4&faYAh-)QDXJxQs=j9a(O53ELzwpcObREF);DHXUs9q~0C
z_0`abU_E&3m^yH%-aSz1ke8>TTeafL15Pgmn$sF6+`PPw?y9o{@#LPAo{M2333>^^
zii|*#T$uo02(OZMb`jQHgr>3A7bqVLZH-=+Ww-Vc>h1PB-=P!&2zE(MZ&3k7tqxH8
zuZYg~^Jt~gx_Jq`kDvgzxEO!NKd&7NvK$c(mZBqG5K_S+V|E0C$Yg4@B$Lei3xy=r
zmNTw-mk%Rw|1@W@E-Rg-m2~aZ@nr~@Hm$}gZKwhRVjJ6EpGJ@<Ax&dHL>(TdtAMX@
zk5%_3Bev5CTQKD_MM?2c1HDfHb&-S^Fq2KpdcRGwKUWFT&-V;74^;qj8Ii0FQH`mL
zBD*RIxtFy?Y7>>93&V{rfOeIX3w-Py7;;F=@~hmLU}_q>;6Lw10#S=UuRIK(fHWoa
ziw!dMg#*R}e|ftLky*C7%=*D;>fGl-@EAg3JF2_AOtNgBhX8%!v<eehw>p`kZ)@BI
z9sthPU;$=3r`^hgO`f9l5R+vMtY&q1nOKS5)}c9Hnq7Zv>9<YPcFvQ*YTEUJ9zYMC
z+!Bz^whqhWe<e*x0U)fQpBzQ5F@seTO-ND=@LNY8Nq-PgO4_>x|MTw^V&Ktd4cc#m
zUM~ChSps69gt%Jfc#w-{LAV7YAZZ%-D2ke7TWrWr9|C8P1W_NZ4foYUL4l8u*#cXv
z?c1Q}A>@1lfB@k-p>j~YRlij^^8~yPm{sqkU_!3ul`wA6CiGZ?`MGk-`*aMrZGGev
zar?E9HKg|~o`cL?lz)Tvymincu2Qn`hVz7`2)5?htUK%sCQp%5bUj4=0WkZ{IWfyt
zhWT)afmk+#Ois(uK~V@%137C;hq=zo<SDPfpbIz3{K&+oCQgEYQim~t<jhMigZ~c1
zxf20&mUi0cWhCkKrI1|!)xGpdXamG!Fpcc=lIbX~xP3a*Y9`%dWn$&!6$7S`_N(p;
zV7JXrLRdI{1q6c0zAfjN*7Vm}g;@?FGHi?eEobYpvYkWr45yr)WD7%fSR;<fiN2j3
z&SlT4-DYL{1Yh=jAW=*!g>3;_ytxe4>Ope=Kr>8+eC*xX>%XPqx)GozDRcFl9^bih
zN2PY}g!e16{wNYtpO+4D7Y^Fp!+tX`W#!R=g$=9`)_Fi7jXn4^h9m`@C~Z!oqxw8?
zD)(|reO}z0n81$xH0c|NG7nVJ1A$<k3oNV!QKe7T><W20$#=}5w-I<*(2!fktrMMa
z-bq=GyT9kqj%e?@qw>{JG^X*%$#+E{AqVKnK{h&N)Q*)r0Wa6PF~Q)5?~O+2l9;{0
ztU|to<erpgufv3_bq7Oy%bbL?G??ugYY5J0+?g=g%^6kmK0|}<agVPI=lQWMg5X9t
zNcTP2Pyf5p{_7Z2{+4WBY0rF65I7!Op$E*ko{bum){8!gx_Yu~3^L<U_O=Nt9ni$A
zybKqdF;S&9>L(zD$BQTT3SWE1N|!&`k-|=v)bp{D2K1o+x-RnvpZ@K&&Oh(9{=@EI
zYyjQu?>nx4b>p`*5oHS02V;owGpD~Xq-@M-STY3}AaRGB#N}9J_y7QsN?*emfvbP9
zow1%mAOJ?T`aS49&R2j_C0dDb<Q{`HFdNF?ZB1bodPZRlH1*?Iz0XK{5x9F`7y$t0
zKwTi|wxEybF_-co=~OV>b>>?mv>Pnd(pd@$M;cLs*GSHyG@M{p2$1c;+++*Pik46_
zPW!`x1Mnfi_!ErzBGWf4`r1qvv=@u6?yZ+K{m~M@2sFKCxOH<|gn7>Taq*6~=Fa_w
z-v`y&OxfpG7R=%6(+9Jpc#Pw;rg{CQSn@YJ@7UDkk$!4m_8at_`2F_oE`@#Gs(FpG
z0`YAQkiSsEzG&?p)US<t{(-?Yvrqs+ZRAU~u$(~ZkX9}QuMjiqu;vijTY}!P&H0WK
z6J{4kdBw{b(?v%?=<tch+@K6Nnj3mqPE<^y2oL3V>oBC3^79T1dc|c<<_r7vVG2Ij
z35ZjGF5vvteAQ{~$&tfp1AagSm%?&(6uxx{a8`v9M<vHos?y=)Cv`JW5eoi`*?=<-
zCYY)VbKC}_PpU#)n-zT=@|xqkh?lSfLgdv`h$dw=U=a=_mB|#^tAeSa#Hu`bz=AEu
z))WIMPpBW;3aA9~nr7HX24)Bu6a&@{w>D**pvsT@!S)3{sbf#ihh8U1WB_^4DD6LN
zrMLs-1BzFgO`Yyr8k7R)E{Qg|;4~|BbY`hRP6m7ofvlyH7W-hPCzaf@8no{)N7tqo
z<*sNaF$<9YC7Dd=HLb8ag&}>09JCQnWv23pZDwr~9QMn$#tHy%)Af;*6GH)N3UZ*)
zm|`%+JV@gI<NOQ=2=mc$YQ^jR*$4nwLO(^Z1Po&jrL`>U=q9NF3rBD%IvuASM8ih&
z0Z-Kl5>xpOoDQ0M`DZxGnMiS2_^f_a*KA+f>e(o1XGW?H!rT`^>#-{*(X;#T4cZ>e
zPr#dSi$5hP|1bUS+>!nRH~nAy4jlEbFX1cA-O!-flb!!B!2g#Q^5>}YPyF}~PygTT
cKD&R0QDP>!(XcqN0pO2{lIEi#MT<B816InYHvj+t

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/tools/assetBrowser/art/prefabIcon_image.asset.taml b/Templates/BaseGame/game/tools/assetBrowser/art/prefabIcon_image.asset.taml
new file mode 100644
index 000000000..cc31d5ea5
--- /dev/null
+++ b/Templates/BaseGame/game/tools/assetBrowser/art/prefabIcon_image.asset.taml
@@ -0,0 +1,8 @@
+<ImageAsset
+    canSave="true"
+    canSaveDynamicFields="true"
+    AssetName="prefabIcon_image"
+    imageFile="@assetFile=prefabIcon.png"
+    UseMips="true"
+    isHDRImage="false"
+    imageType="Albedo" />
diff --git a/Templates/BaseGame/game/tools/assetBrowser/art/scriptIcon.png b/Templates/BaseGame/game/tools/assetBrowser/art/scriptIcon.png
index 1a2433dea6c67e3abe4e89db66fac55c32c7db5b..2cd25eee460f7221f09b18fe8b4fd714938982a6 100644
GIT binary patch
literal 7772
zcmdUTcTiMIoBkn6#(=~@f=UpOs6&vPB!dLWc?gmjau`8^l0}f91Vzb1kc?!IoP$G7
zlAQsB0fsy~?zdZ8ckABoe!E-0KYmr`RCm3n`|UUM^Sq}!N?TKzl8liI002sr#|lpX
z03X-I2S|u<&4J&<DF9G$1?U-iJ+bm-b@z0$b99EVdilFUSRsCnb^zcvvz=~~0&1XC
zz}A!Thu(N>Ee0CiqiPJYD6cSn;uHkC-1n%}Gs;Zw#3NB4teCr;lukIiA}yARs+cgS
zq8Zjgz`vmLPA0Wl%Gx&0PA{W|r`?7c637#Eqih1q9M(>z)*tzXA7^Bj*=%N{mJyF#
zn9?trZw||Rk-X9P^guni-3h-XEA&)YJ9>EF<PhU$cYo&Rq=}!@#xV3E^5ZnZueY#^
z{qDqoQ+zWbr_pV6Lv=2NPvrYkl7$<=m$OZ7ad7S(nl~+Fd)0lmSoxoz!)Dr@O6dGf
zeVLXhh}(v=agwuU6uZA+U+inak5xI_@OsITd$uy4<boNJiyDqN;8t5(IqpEqE)WE(
zA_wQ63a1_kqQM)%B#X||P2=|1VWaJgiy5;kn0Nh^g&2b!i5(`|lC#2gx5G}n_AaI~
zeHar&P-Sa>oEm07a#dxGR17}SL3(z}K8;tfo0+GZKL2)uPemd{T+&2j@-{fbP~}85
zPDG0}QIts<aeb#MApiZxleKfQIYxpo2BFIp3rs#Z%jAYaUGTSPZ$)|L;$NW$v!Sy+
zk43e#*NBfV&Q7}b-}QW$697M)x^ORJiwx&qQU#AjF-5Etr^uNN1L3a<BRazsh=V?=
z%2_Es=wieVb-q(jd64D_vSoest&`nGGube1LI8?RXWS{#`GFL%O{-9Qqgu2YnRCZT
zjQqH;KJ?>#m5Nt1g<}f2se15s)xu80>PbE5TjOUXgZd>+xhe0f#-2H8m`oOsB5vm1
zsxExCt3Ja}kKP)hY)TLv>ycMt@UHskdO#XvmnGB>uhhs4?tDw@-Pl)D%x4z-k}}z6
zp`yRE!Dapes7}(9^6V?zsrr=v+;&?9>D%(0&1t#UxG}wg38{<_H9-cxvh-q45f-9_
zvM#@cCklqRh@tsbL442@;j+Y{*FEf=Zz^9vVky>{b25G<HgH1Yxh|jXuRm+>k9iJ;
z4n4uVOh1!ylkS@l^3MX>lnGURI8`_toVP)Gu-=(osB*11IoX8yESKHFN{?WBWCGfg
z(>53c8LxMfO$-P@$4(3EjqXkeYbAABDEEuyRY~rV7GVK(>93g}&eF=nUdg+<3`h`J
zEK_}oPl2cAybzVA-$TXM$mvpc*a}KGz4+s;yFMQmh6BBJv-cK1O|nq`r2n44x~s3|
z=F?w`ysX&VjXab)X{RIDXE{mElq}V|wl~u+s~E3usO(?yYZ$cP7QdtAmR#a12tC91
zh6}28ShY$Xccd5he;m};f4Z%Dux{2o>^Wsvg33EX1kRe+%?QRt+Evl_GYZ<MJ=x|?
z$9S(Ki>+1%W(Zg<HfIwO(`H;b;|ncRo%T42vT2`INR0NiBBG3izvJCc)8R_2s%9<R
zX>Yg_j-s#|S2!MHbmU))UfZ&KD_R;BRRoWYm4V&`DW98wglE^7AJbLAQWCyp@MRmh
z(lS*@PVe?MBSoWpKla<o!Zs_W=eoVhdYiL<;vb|V?S%ys0yV-rkJI`XQxu}37jJ&$
zh_t5>q?Cl3vm(Mu538p{vJ@kGBVss$9tim9b|uLA#-{M}wk9Uj-nA#1W3fp$hnu5S
z6qQjjHYFLDtonMFcroOy^i4O^D#uU*sh~a9o1(Sy=$i#CV<wGW7%3NtWhI3guflND
zeRiHhQ2NINhEMDAF(dsjHbDZhdbcL*;poK<aeT{*pLpiVV~#@z$j-;O!Q7@OyN8wQ
zlZ2g?EmSp*6caTUTWZQJy}S;bQpw?~eLk7i22gT)4z}wPZR}$H*RzGbS|cgB4M}vB
zGrB+Dop*d2|Klhp>R3L^HW^;R%-`)Dy(&Yn)XrM)x|_-|`!xmlq|tzig<)_NqHcSi
ze!s`LYZ~w_$rrC+14gxK9jL&_wSgKTR_o|CD)a`!re;oqu0W`)A+==%8~etD@{i7E
z76;_xR&qtbBHI@?y%?%C4Qk;qDsao5D@}P9d~ZV@qdPNGn6WfDBQNn_ZGWpI0|9Zk
zE#Ya6=Y5@X`^D)OeMAX{1w}tldrfmZ9OF|AX2>y{d6(JRDYYy<wsCvi(;D`n)a=b&
z$H|9Ns<av7keJao6Dbk+tt`Rb+bgO75x(q+Q=G%{`tF^vi!UiucI>5uZ^XkokLYa^
z;VSx%^3Lw+rh;{C&fPO!($tR03JsXhN^svLa~4V%n<(dw2!P1eBvxs7CQl1QePq1;
z^V;Y4aVY<sSN1Z!ZBK$K5--Ag#)$6d<_|v|)LcNCqG}nN=Bpdplvmc=oMn$aJA=R4
z(uC2ss`vcLLW=N2RK*5t%a>0NK1FT!Llms)Cz&zgPXlWi{d;}fx@J!zkWbLVWmBv1
zG70W6N8N!fCL2^TwZVNn$}b*FniJ55x^jnW>rzmaE4A*(9+k>Y;P2lBt&aH&W+}EE
zQU%az3%5uQ+ZlY?NMh$`Z<kd?yr$)lBqEDxD(dL)yZcd$f79!e$_KnM=G#gQd&T6y
z{tDw%R`i`F(Rb$X^Dj5*GcKI2$e}Ly*z~Sty?#)vgGVMLB|G2r#Z_x~vj8PFPE}AS
z2Mrz>rEwaf0b$B3oJC{b(bvT|=x8{Pp(s?<?wHRiYIQ&GWa5UChH{bMv(NA;X3mYE
z1geOGNF{G#Kal7Fr%$~~&|hsoYh&QEeeqoUw->@*+uqpb3H1wy%`a&~jcbaXcc6_y
z(Z%Po@4c5Fe&6AZtU=3FC~|+IcGAt>kj$GN;r~=)gIecJ7RWUXQ$ZRZ*vr2|UY+?K
zvkl=}*y0c9sQ;29i1_T_JTV;hE-=JOWBr5U-Mk5z?jT#EqYtU2;>aEk0zL5Zu+a}Q
zfx`GQb{g_CQH<oyb=WWhQC7j`%#7zb<TOIbDI44|MaV>Ooh(f6wtWzEdWwCXdOE_n
z&-MK@tXF9Od>@^+T7O{b&gK^M^OE|!yH**)gS|Gm_enqZr;3G*@so!-Jd$bm;ao0X
z*Tue*G3i4&-^|c+AJuW1fK142XRl7oi9!SNj&;d&m)}lTaCq8<tvr*)L)O-byZe=W
z-fz@vSrhlP`#|;8T+9jfvlwfoTdX{O@@q~i_zU=AZ<_kU{fq%`Uz5=~&}Gs$8@G$V
zQ)KP#!6f1Q$@X04;)NyNQ~4eI^UCmS_S3c3&XhYnYOo!4DZXVjLfBP6mH3is7Iej~
z9g-%wf@c!_scck3yFmAxd9D!>oQ`hbZs|>u0Bh7-iG7&eP3=M{QM&1I!_xO2s={KO
zVUcfeWGo6D5R@nLN<8z2eUW6(GVLmxLEwFcZoi<%u4Ujs?E2<8%e-NUP+L`ZETk&W
z`NnCQn+dX4&-a+JrXBxnybQ?=DvvWISweJ=$ZDE4;qk0$j&qI@ugYwlPyqS6cdL~T
zIA4T0As)pIZgi`vlRdCXrCtl)94E5EcLGzK%lOQ(kWb>u&b-{D2Duw;-CgnXw-U^B
znNxi<j%b6PX~r0kR{q;3Redxtx`BIx6YBBJWoIP_`z0FuJ{v81C+>&^s`n;{E|>Hh
z@*`U!4;>0pnJpI-iSO0WYqYaKMiS&>lJUH9*fC$sGOfm65_nRu1hZ+(Z$WabSxesI
zpC$?GiEw;Dk!~am)sDVsUzl%(lPl-a23UOaunjOQ?@oTA^ivx~xO38qXl<2JBH~RO
zVPI(AA?15$k}_VQT1-^fdMQ9x7uk|0DIFTYZGX>-BQS$|{Bl@5NavbZ@M*R1JJZ*5
zQK@m{pwMiE2Z|G{J1M{|`VP7eYW-O@yk9?n;)8P|nCM5>Do_kD-T`|grO}X)ElP2R
z0`V+8$5^Jb^cvrc{ls_<E0N6#o#vT$q{-p~z1AIq6~BN3y8X|ACGq-dM0mE38Xa7&
zQ!{n{ipZp_K45wGODtEhk(r=v#VKHh#mj5#(|E~Zwb4rhsy?!?5mPyFM6A_QdtK4T
z<)Z%M*jCR5Rj9x?H!3Z(JYD0qyhgzHs(3cnQEzk2=qIlE4%DP$R(vqaywAx>yK39w
zW}Fnrpcn?k?6tJvt`V+v2dx3!Y`>2TvHh>N$<_sGUYX=}c5&TpG@7lt%Dg)L>A=TY
zzXX*}tJ`L9Tz9xqGQwaHMYUvXqnN5(VsJL)ymc)~y;Nbq?19&<UlDX;XP@m|%6G`K
zqDR;p;0U_gHrIg^$6XWy({i*56J@S1k(4o$8KHK}qw-MGd{Z&K=vOsWjWguLmVQpL
zUM+DiU;-g$vo!2gCL)!t>@-KtS4P-JV(KRFSdMZ@H=?RW^o{2YvW*vsW+)x~zJ|1J
zd`+)p=xuk`Ej}<cE`eROC4(I~b9{jS>8RP*l&}7l{dEi*jShj{G{r{R9oq5=%)Wka
z+ISjuEaA6q5?bE$0#k>|RwItu)-v(Hu!tA8ZB=5t)dcB8-04!^1;15pfj+8BujCrk
zS{8O;TjPYBJ-jW4+$8NJ=;6+`T7&~l*Vi-rhS(8hR+F@39kNw^5ydF-s}T1*@p`wP
zPOV=Fs3h4823F)0iVBHl32%LG9#9zNwtq%q<Lr`DQZV}X^?{C~8)O1$9CjU&EqLhQ
zEw9$w+K$Z$hAWT2jMs&_u8y!lm(@)6^b#$O2Du}MlsWZGIbx@+d^BokzaZk-Y%EeM
zUpN)u-;&oJgfS6i?Eaj;1^$R3q$kv^_wqI4;2pm%TJE;o%X6`^-~TG#O*xhNy*0?H
zP8_bp$tPwTb`_}}nmwmu5x|y{*;BADi{|kP=+;iBXV=F(s@A68a+AdPV&nL!E~Q6y
z<BtphsZ%iDFM&5kTrd&<z>9E{m)BO2m;cW*BkrV_5u7ObxI+fiX<_1|e~-%Nsz;A@
zChsejPMsn{Lh{^_k)p8PT#J#<Y$_feG^XTKFkS;@(+qEK_nU-m)K|e^PDMKIz2_<)
z6=Sb-U-<d%dSIx2J-nwb_>}`td~m4uh{G0IEVp#CX)}^V_*L}4$n~vG3e)aM$wxs=
zF~4{*(C6_mF*kwM+gFDLHNa8eSD)VJb@^wDepAg+57K;8I!+YDQh#6UysO@!GSxov
zK>b;kr~)sIgyBz1gRz@G9DkI<3zByS#d)C%Kj3=L;NDu7?Uv?dD$vYzk{^b0_$nl?
zwdEOZro9>|dSlJ1cqT}PE#KC9qsIP}Ar?elAQ$Rz)`ng3tyQvmHl{+>1z=+!!Lj(E
zW*>}d;k!2d&$57K`z2MEvtmliqojiX6LJ<jg4xziZ<C~>kbY*%O_dwoqbWfmO%eFN
zU`mV01jKHk%@6Wx5mK5gAr#)#K?EQWzKvp^xv#&kmc1J`%kdCH(EHi55AW7#H|{J?
zY^|oO09XJ4fEDYw1s_gA>i*aW3IOCce!qCYy9|1q@QRm;hT@eqQsOHV)bDMK?%+fW
zUW$fZ@@_6J5LYii-V<Ww1+iuIb@XyzRaVi^ei}+ehr2t#swl|n;VuK_=Y5#g7$TSL
z?@U*$S-2a>h17-0(N$fE*t1%4(G2Tks}8I(BO1G-!CG^}+N1*Fn8zeT8!q~VuNN`w
zy{!`qZ`3)QM?2c-1s!#6=mR0?PlWM-s{jy!GlUQTSaA&=0N{3*46cW}s`%%h{)fXu
za6137hzzdxx7z<}_<z~-XR?1y)BnJ&KQ4mbO7gEo<B!w+5yL-|{lB*N@3Qt+HvJ<t
zA&!#*_<3ec23pY4^y=L2aQ-rT4=cgKB0c>v2a&N1r@YbQ6D*m&KEo6RcQm`o81m55
zGvLkmg5#Udy!}-Pv;O<eVCm}TLR^G^dd|A3FxUWG;U6f>(&!6D79&;Oz@~@W&*f55
zpN?f@YbCPh0%_dUIgj7o<D7S;N}%!#^2{hw?W@S<JZm^vZ*UufO~I}avjUcKyhHr!
z^KrBFP^9L=#rc8t2H%S2nyjLtCn=D3gAs6EzI+3;;}kDXztBtNms=oT^K<kQC+_+2
zq=SAKYziy*vis%MVPIqg5aRKaM$r}SvN}#JJ=pCl-4|EuYU}SWHh5z9=JUN`5k|@w
z>B8^N9QkU5z+g<jrgpm0r^J)`6KA;FYWCs<&vPtBnh=-7u6a|N`~Bqo^-X)4Qhr!h
zsjp``#xW(?bg<d;M!6<)E!?9+Q&@BljYb<8nfK208EXbM%>@SWCmgXb(clzJ_x(_P
z=r-S*Is1Ov&uOLe2NpR5G@@$DVsf~~3c$GMw~M~6bA1*Mr8P?mAlM~G@%i{r!97&4
z(Ax!be;$@*tnB5%f?Y~#3T3$3d#3@&%644P{xavuY&P~ClM_?q3!J~zbH+o1aVGWk
z9>OJ^27N^$H1~7O%j{hse7j9(^M&UdnurtxMMUA!Z6I&V8Y+k^b~3Us)2f`V+8)lm
zshEhc=26sHUD{moW#J43LIi~;)B16-B_}73Y-@d1ZJc7PW@KhO*xoovqr3n0A%5N=
zWrNOSEyc;J!qLY~24E6GAXYg0OxRgpKR3Gn@ijnT!EIt8pCLfcVCQxy@Sm*k8|JY$
zCso?iYJ6%at@?s5)}BU&Fax*$byA{_bt4E*J<bztrTP;#qi4BK5RT`v?ab63?or4&
zg<J1$X~FVa5FJ3#6TF5e@z*p-AI^l=7V_^_x7YdK_<O~se6{$Ic=aW`mRJ57u3_%C
zS?f4VBxWPsHRc*gQGdPuf6#PkiV0rF0}lz~KlT1U23-f^zmT4qnSL0~y}_aWd;Ncj
z_$l7=6TC=0&Y}NP-T#}&%HR^;vECnIDbs97Tu$&;WoK!S>~^aY86hBiq+~|JP3AV~
zXBG-r=IQCD!;BaS<-hay>%E=4iGvd+?yJT6LDhTMG?*eX2i|uOkiUf?`i)eB+DVO#
zx+Kl~B-pf;zJ6qTuActe3f}Q8uQ4gt{8=O;8E(*b70jJsYHCk+zt^s{NT|vE60Ybf
ziEY%*uAQ$Ncw2K;`zjz%I@7(4lAP_oth@kagP2GN{9(tB78kKni&DoA1BWpb;e|`c
zkaX3TnH}flXY$76F-Fh$a;v9Qq0Np08EX3a{62Bw-I+M0>kTg#H)dZhuH}E)AP&c&
z^l*F>Js0T357EyvFV0teTRRD^m@`&wG6%CR&;#3=63W}3P?Gcg80ww1<pgT<>a?q7
z0O!9?{VwIW(V{gYwh7AP?LRoZ@M@T!Yxb8Y<|!urmflyPj`RJ({>=aQ*lI^Q;B_Fj
zAyqjr!87RR${idsb91<0zFpYyj(q=LD`6AJ!;B+M=$PbhzWRBXZE@O?#kk2B%J6*t
ze1B#u6`~oKzXhtT#Cl0%SQdvbx~cd5urEQkSQvgY+V|r7nAyPQZ1a{>POa=!X$&?g
z;v{0?+0gSf{XN6HMScrYrBl=|qbwHY&-32v()a*}=Go`WBNd6?oJict4<Z))uIz>T
z1F?&3z~cR%i>M_bz>3>ue~a?pd+`rHB(Ftcfx6hTmh+#~*jdC-O<QX?m(<x0bRT{B
ztIWY1pD*?4bW?aCQDz6jr~WZaI2h#xE!Xn6pBRzd#qDL?>R;F+K|W78Vvh7;p!_&t
z*+xq!hJyr1o9VP51d@i70a5GV!D~o=+GC@0QA;QLSxAV$at2|~z^w}l+b^E=OU})j
z=b1u-L4+ZnF0Y+G3IRe$EzT8j?pWfRPDc4_k`Qu4B>`4)IcpUXSM4Q_if`>Uavo87
z@+`$X%9edT`5|;&L75P6-)<moxkPc%e(;!W65T~Jtf}Lim6twcvTb8N$^jR~VEeIg
zBq1>#RDf{pV++g+Fnm#Zb0r8zzBbjz)TcoiVR*RABFgEwW3v2lW(Z23GJoH#+)Te>
z8VLo`RPE=Bj^Lfv6WJ`;zB*qw8897L({&fj<~}K9;+#uDmEPufKDhdQdnrc(f71J)
zuDUXK9UVO1!lZO3V`Hy-Yj-Gz0v}NF)RREb(<5}&xoDd`Ox1_c849><K)+=z_|puJ
ze0ps|aOY{@?<gdM6qDe!{r<N6!~Z+m5|`f9wmQ$7fN+CD?D+gKZvd`j)cs%%l^woT
z{+a+EuoED5M&nu(g@DpG2HZ3*VqOuPA_hu4+{R#Uy&vKp7PT%Ulh=o&wTi*R&HjcL
z0su-Y-VIbQ2<tSZ@Iy$U2BHH$ltJudD4<oH_XX`E8KCth|A$Y8L42F3+1>A92$gJB
zpq%{I%ZQa6@?C$}C45l=-hajZF6|I{1BBpJz{eSK;DFX3?}b=fO%1O-8n&9Dt(d&<
zFB1w!jR*|lQa`bSZ@QLv_?~tNEyY4U<ZdT8z#4GkKlK1dx#}{6vE#c8-_c)K)31==
z{OerGNsvZu*nD9Mx@GqY2;nxTQQG5pKHUvMK-0S-oL);OMSyVV79ot>6AgRRRq(<t
zCE-UWL1n=)DrT6+#?l}Yqfn{Cf3?yp1*_Oxz9qi?;}V|)2yvnUEWLtoHQ^6<V8sFC
z4=AcrbtR$zeEz%mpC1@-VFms_JOTW5iT>v?!Uco%{~n;$iDPLl9>24$dqf>LZGeiR
Lrb4Nl<%@p<1DT1*

literal 10044
zcmeHtcTiJNw{JiNlqMpeARwZERHYNDg7n^d=slqH4vG+^_ZB)r=)FkjBB0VC5Q=~Z
z2uTQt5RiTk_s#w9&G)|h?sw<Syt$d|IVYKY*4g{F*IMVde*3)F)>NXr!FU4%0#T|c
zE9ini#K0*rh>Qd{?E9mRfdh$+nvw!=90wsGp{PaR?D|V(6E6^moc6L2fwFV%0DqEt
zt7yC+T_It-#>N@%`@9?Yi`iM<*jwHM3bl9l27ZD-@}BnA-u8C){hYm>?klNiXxs7I
zlY&6^K`IK*^!?}Yivj-Tj@CQ7%Q<t7!a~W4G1dLaVgbuP#osrQCd-kTJbqi!Ng1TF
zaGRgHwNTq>-cukXJH6%hc1ddD`14ygRPMixN|dh8{p{;D*v>c9-t78e4lQ(;z?*QL
zBv?^sQu#PE4+fKZuL$-U9nRUwSr38EpZn{8Kvs%Rjjw?~H-RCBUyk!C(C%NJ5CM%0
zXmUXNcWC~}F8^e=@JqA*_-6mVTdD#a?*9hi|2=g7V+n95IiUR?oRth@2)On?_Pp>*
zGyi0lf3n;COOyXNrvAfH&;Gg<ojRqaO3e4r>fb1*a)csOv(+@meZ&`O;OO_owQ<Py
z&YxKdI(_{XWBnQ7w8z=13>tB3UX1)}!l`4<Wr@?}=8DpDsZ{p5*smNSF7(D<0c5Ni
z+U%zK&rLh4OD#Pr%h9F~IsU#-!-Qrv&(2-yS~%_;pK$k^eG?zu6i<0(OKH)3c5DS_
zhJ!q)N7#PqU@)dCihJ%(e^E_YIhqvbfcd4Jg1uLxVv(0J*OV8hw6AWXpf&gaJ6bZU
zoO!d~z$op2Wqw!9kfnzvyu8m*Xn*CHKBUw-{#VecL8Ey!e}as$tQl)nKA#FWQ*(1-
zGm#~Z3OlEuAR)>OWTU##M{su!Cp5E$7o9J%A~b*@@btK8uvSaVhbwsuTUh^WQFb1|
zY0EAMb<+Y8)^EwhJ5J*kd=>_TxaDXtOpWz=E0%r5kgy?$^jk~q5($2TBLU?kO;3Sy
zM$4t#ujE)YM_I^bHkwn9m<ieYoqJ4gdE>%F#-@Aw88EwTuCrf2Jv5-4Z5xR4p-+`I
zd`ME-b@GX~LEURgO29Rie#4p@3Dqr+JQwg)6ri59FlSpj{iO`}1|~0lee0A6bhSr)
zH*!GpY`W^GiVP%YuyR}O+S#j*8et0!byeMa3Zf+pDYo-j(KtDda`w4Yl06ej22a&)
znf=-!hcAwI{xJC-QM9|@HAh|rpjP(F`qm8)L&ej1;q!}@qPGBqxDe!>Y$4SpmAu`!
zlFwz^3Hz9&%>t^knuRSlQG0#;0bZ^@zy6*-?#zikpHC2-%Qf8~$C^WwGmc$->bnoB
zU`!-{75|vJmGLXNJZtv`M}<AIkzq|*VPY>8+6CW7^KQtoA(U+U0)<6+Rc_2uSkRH-
zvaKR&D21I`hWZAs0&(VutK=ge^r>8)s<&SBwaGuQPoYJAuP-VmEsh9$0_G~_vS2Pl
zR}-p{GPCz<b2DymP(}0r$fSDJa26z>np5{@)e8&82rT1hn3nqS-V^Ag?JkWpJ*&=_
zI-EQJaMpl?=@ShS0pjqi_;%2@Ee}V5L~CP6b@5S7&DNYLo#aI;qY(M=uP@j6=38}I
z@68qRy?-hyd^xecTNzqAT-Fae{Ml-GsG-y3U$IN|*`gSj?G;n>S%W)vt~5_QIgScg
zOm|l&0nDpbmW7gP%xr344fSADlijl7S$}y%^m^8vJ0P;~yITX=#p{FL88Fic#Swac
zjvNe77k8zKrb#VPL+^DgK|p{FOI1pXq}QH~!ArZw7o^wogS7aoV~}FFonz`DVGT=)
z%Rcuqj&QuPzv^e}s4i+=hm^kS_#k<Vv|m1YC_n=Eu|xd&65~)pfWKQf9VsaDcI*{x
zj-l@}SFF5}7cdpi+WV@>&ziBGC&FXv(^45mjk()m8@j)lqK1o7xwBQXuTlPL1Sbt`
zD)3iJW8V6Hu$|9~cHSB(%y_+<W$%Y=$PVP&``i3^)hJ`A*0f!osNF&&%3{t&r~bL6
zPGdoyn`+S1b-d;v!7f-qsr0MPi<=-l#h5AR(Nm>{4js;jF^5g0Rk1sn2-XIIH_?h-
zOSfqDtmt2#sAxSEn-XpoVn*xjz6-s}G()><{mSENmGRF%7;2o^{-~UBWpMBEaigY6
zXuEvlL!W@tzzyeC)*Y=u!fHKHi0kIt_;sNw<5NXZXjsP=mpk1__8H})D-HX1P7Wa7
zn(DVXzLj*DF3ybC_>nTL)&3qIU~j8piKf~-SI*CiR^o2Sjj60@IEZ51xY_;;ZefH%
zIadpmJ!0vmZ#%oOkbC2f?-6Btbh2lEk#7GRMe+dVu~Hu{_~g0z^OMQzXAed7o5!Gn
z>4RLVtte5P9wi?6p|qxI2ri}}eTx~z5ZK=AM;t}hiVWrO864D}x<|x?$iBsKUjB3|
znqI=q+!;;E=&dwmUR_(BTi0!}<Bcg^5e*UkUi#WxQI?Tuyqhw2JYGHcTXlC}U*U2s
zy!voj6c-Fpj$eK{Sz?i_<U1{4o{c-e=*swqg^=p=Vz2l#?yvtk!d8s`o~P;?*JvII
z^s9Ted<R_Ey@fOE_+kOR5BfIByCSZd+gIom4=PJ7anJ9XLn>rk!*cpaWaqeFLbbp+
zPf+kS_M>E(5ctV%(0y*$=IX8Fg>b(i`W5P!z3JID45_Sb<)69XVfFkxZ>kPArNJC%
zRQGI0qM_KPG3E^@vtIXwp1a9OqT8#FKEi_%NY#$A3x^rvv#|jQ&%4vjt4P5+Gikkb
zz9lxtu-;-M=cHMh<hi8d2%554qa*WM+1xe?ZOVWF=EJ$Z;|Hv|^Gd*Rgl+r&kK4?_
z6zl!aaC<?+FJ_^`*UoS9)C`+4^Gl0`<!(FWnfXXwOz|C(>@P|TRk~zhDcZXxkj7^1
zqmCO82QgBnX4i>hm4&13UPr&p*YRn{N2p;%A|h>mPSuZuUp8UPJT<ZWglQKu^flVR
znlR+wzWKTN?!ONJSoqs}2cNh3+f6M()d;I?mDAdva-XODctUZuk+Y6`Jo|;@0Z5yw
z<ol$b#{H_gUXx5ue@Bf@7I>>-oWUP9Ndw`z++&pu?!~G493LYGuY2xL<ByuGRIP@K
z4H6Xc%kW0?q3@xhw~4}c=aU*_;Q8q7an{HM<A7Cf+k$7*el_W6O?8u3Q#e>jE%mF9
z-M3o2b8EeVr-QO<2e!wxz($XqR*A>5qP2zv=W@8A`rTt9KG>7ukk}=IBDG+)#pQa>
z??&Z=<N;9iSnQm?LeS(Z=HXJ|#4&EmFFbm@+)k}LPU6A~n3-D%keJ0#i?!P6fG#To
zi0g0o(!O7_H)f1c(x1p+TwlCMaCsHI-0F=<;XG{UB?F~m`#)#iitJb?a(GUK=#q78
z<CkrUOj_m5-q_#l9W_{;Ka!<kp7B%E#IDp6l@OS=*PB#|9i9Q-!9RC9Q=_|%@=rzO
zf!M=bX>Rn9FRTA~g(A)f-dA#gH7_AQHRsfci+9uwl#;2!muLDSXaRCU$G1kucYCd2
zPT$tgDSoP$zg3Ij$koT^epTe^J*6ME1is_Y4@P5;vL=H{tsnLX2A0{DxL5JvvGYm;
zB>U&Zl4*7Y@r^&zG|bxh$CGbySSNpA_(^kiR30&($-Nv*5ehH7jJ3u%W>eqvL;nOn
zt9zBjwUq0EDS=P3(>5fhm57@frn<!@D_Io+)fnq{9zc}y-E)eUD{~G02ySWiH`!cp
z&_P=&Ou{G_4Fb%sXe-Lz!Sfu|qa(BTCqM0Z$8+{XOOZpMCdQMavL;_}Q=A8w<n0mr
z#UnM{A}4Hnk|p1Aw+fojQN%zyeHd5qn*6L{V8CAiedwk)xU@mYID@IO)cDDJs_#f6
z^)l`Sn=E1`Nsdf@QEmc3Gs`7JfdG9AxN7Al*E!eZ&@S~zI<!r!AcH;+5yXzzPdo1e
z5Bm@~dY9K4hTU>+J^k3_W{PHBs^P<A>i2qp8|L;KXX`@gnP&J39nN;<$c4x7@CKZu
zD}58&(+bM>Pl06L%*l+_W<xl!)xI@JTy#j$6K$iAXX`5jx9d?-A;9LAJ|Cq_vAeF3
z2t{&p8Ox4jOTh8=I!Ot`Os|bg(Lc$*KCPDioxF`RF7%76TK;(mBrc@v<k;!Mt02{+
zjQxZNCBk8KjOz0JsKSJ(1#ef27?$@`*t{gY<DJ>MhM(#qOaikWtpaJ*yOxC2tW<vK
zCi_nUEx}e*5b8L}P4W>h!cnQF1merJh*D?l?%#LkA%EYpBvA4kz%@1I+`g%Ot1L@3
z8K1?WRk+w6)2v(z%4W~{u)T?&xng@pcfvGb^Gu9ot_B7+!kNa<jIZzFj;$hCTAo<b
zmWpZ;rOu&Y@i=1+k?mz$F^Wawg(}!a^~8^cq5VDyp8fa7hJ2m@B|nGbUMI}7n&wH_
zb7f2zNSkruHDjuxk3GW@W|;j=7Lq3_EW68}TV6={>ysZq$3<YRn8AtO<&M2UlgF8*
z=gvRM((%js6S)^mp2_YK#}x;qRa#PnSMF-R$Uv$YIyzyVp826*4~@A{$MF?Z5WucG
zYx9d^)*9z?VqMg@D~ytLI+LR@FGUUJ`sNLK_~2c$Qs_TobJPH5Ih#X$5V(j}H{W0l
zR=EuD1Mc=~0*>_icmQG5umsKZ#*U<+51c6|So}6Bru;o+x55PKB)+S{2szs7jlwX$
zuA66eXC4z$x=s|HEOm=%(hsI(=ytUZpwUL8Ox`|qD<ffI>0_8_Z*xiAr+D?j<~_ni
zzUEX|DDU?Q(G2vY?KY!S1;lV-I7mVz%oiJ;rxlBpgsN5AWaY(D;to<ynmAL|M$8nc
z6^{4cuLf~IzwKCLy*>BYd@D2MeNgW#X4#&y&Keb8Pjnr~LM^mG&BLqc09x;EpD!z@
zM<PDJ(|Fsc>x^Zj<dR}kmVX48P2i)u24lCSO@FJzz&I1^b&o5%<PDC@Lxn{PSmP+w
zv4XK{4ahT8Xh_&SzuF&SK^OJ8DP0s{3(Lh?Z_W7Pv|feOB>{x%35zqG&)Et-(7hKt
zv{5zG|Ab=1=R_EdKS^7$RN9k(s=XlS3RW=C76(3-DD8UgLoMI5#MC4ecD!*y#ogbZ
z;<&##TOi{b>^JS<7c2B<xMQ0|qC^&&<294eHV&x-_tm^JvAT8(#AOi1h8P0a;Mb!K
z7w7j^X7ry|_m%SyTU*eObsz0emC^?C(@f}H(qHD8cUiR+K1Vt+2tBG2TBN|F7``^9
zjvH9hqb2vQm67|)EHc)QLHD8xTS-5qgucB&`}<LnfwoCVWDY+z)Z~JhxeB{(zPXFL
zq#@n5CC3>Sr5hXhm9mtr<zKgR_U#+#VvwUhQ6(3G-W^57*%}5JejfH4vVB{_51WR5
z+S%hO{co`Y<nLRV$#}E$!hXLVY1(7`3u_UW_2$oP@R{1etz7fK^3cgPRU<S?YaS27
z1+$5m-09^9#>kqa*YSI_;CnHvjmzKieu4W8Hvy9U4dK*?;fYXcI{2YBe<vS&<%2kd
zJQ|k0A9LgiJj??-Wl_8fS7ANPh(-KMQGnBlhh5J(&wFRmPU{dSc3(1M45)c(7qi~-
zgPUILNOV}7sNN~F73A9^@rG=uLU&AShd5q}whf*6q=%kck6I9S+sNDK2kdQmTtAp+
z&fYj^_(=xR{}eItjBl}9M~vV$MZQ}uVuw|Q$c^zDBia|zxveUHtCbm}Tw;taWN97A
zOn-O-zR~kjoSHnV{WVDL+96aF&Js_FNtQQjvfCjEX})-A5=E281w8z*(=Tv5;E0vy
zty<3p=OFLIGl!fY9KA8*{xNuZfva1dv;YJgpS#?2^LKEDgIx^XqvsmOo*u2D1MJ@n
zkJ`30TeZdn#Ek%E!}I3^ZG3ugp~^i_9oBQ#+bqZ3pM~fN{wb9l-F$kys~Nban?;<r
z)(zPMsU&nI&K$o14>D;xrgc6I@rAK$8kd_T?C_tIc^Y;{{>HP4H?q@j^f`HcG<F6?
zpr`smI``csW~$V%T4W16cw$OXwNKIngxiDG<;j=%_F-&yqqdzPrRU~~TB)xXXAKd9
zrl1ekK|j>v?W;$k<~Cn8OaeH<fpP(Hi$>aKK7PiK*QI8tvV^5OJ<z4;yIyfx9wVRc
z$$E>{@V$M2yi!XVxe(47AaL3)ig{j=o?VsfKMZBQ?DVh@_cbyQQFwWwQ)4-2h9OWb
z<@ZM|pB^3*HGNr~x}hbvar6fH8G@KzVpP+6YpS#H60?9;BgFSDeDl8A1I28dc&Xcy
zr?P{vTU#t-Aa&<!a3Im3^3-*yV+m@>!J_iG5H<^4J%sBON-!F-q|;qPCAv8v7Xd6{
zoGce_C>cR0L;9tn?KRiEppQ^<cA3TcNXG)Z2~^7acjpz|N;o9MaADh#fZ#lELG&-Y
z4TVcO@^KCA?3zmH(o{C6#D=>hHH*LDBm&eG67j4tECi<IwEmjG=f$CeGz~M$;f^_m
zJk`EQuC|}LFg9{xG(3wAG_%BX6`1wiUs<2aYQU$_OJ4pbA4wk_D~I4dW(>L-Q-nXb
zl6l23x%KbT%O`mxMB!PO-pzs;7Jr>F(;S60@0}ZO2c=&nYRt&IjeY<M7kXuKs+iC3
zDI5pti50Q?<zqi)D9y}+PnC<9s%~ET@iCok#9FO@_d9*}1R_%>1=KT~p5Z+-kqb`Z
z!+ZAxtmYU=L3ic9Kz}EbjDEJ=eKUU>J#`b*W5tH3-Dl;;)EhefVcLNuF4r~oh6|A`
zRL5;)`~a2>q&z9jju6glltC_^z8Za;$7_0W)8^E(Kx!vWW&j1~U6|&h&taCIdSnch
z{+u*Zv&FEVh|q$1vX+@NU3Vy>ra3_2Vo=pslTh`DkYLF*TKWXAajqmN^D+I$s*x%c
zpos5*w>&IPXI*99coDz}EEnIw-#P7`yS#q@kaz*mLA6Z0D>*;>J%$>O`RwZ9Ake5?
zdHcZRSa)`GBjBb#L}+3f->c{b=NR4EQQ_o0JC#`Nz=1O3r5c=@54WxqSY^-W#cOOo
z7pmYS3dbh#u5?*d3MF<<^E`G%Fq@jQjI4q|Ka6rV$W5||PXVE3?P0=ICkA;MT2L7y
zQ9B`Mi*z7>XCl)?TZ_XP^E6``RbL-I)xmzJWq%K@H=zP?;Pj%o2`Xd3KMHPKN@KYQ
zP^e^JUAp69V@rf+lW@XI@5bD6KjIT(=nDi)vXsPPTN^2eek**RH@|9xerwPNBfYO;
zx?VG36SHv<rW5tJcbVIDH}Jl|Wq-YA*8K~FX%lk0{9ouQb6U5$(@e_u6R$27m5OJ&
z;{3OKL(1Gm1=QsxS;d;nj*mvl%c4et=Q7xBcNri2FAFx07^BWR0&4Ogb(+kp_l{~z
zBPrUKnCs|4XKk^Tn(=Wb9{JxK3DNz_UO|2LEHg8A87W{g`eH+qwxLq<kR<zhaHHdw
zmvuzf!^>?$G^$&CED8=a`@F_m#fEiytf7KQ`ART--l<3_>Ub*S<D-%#MnI?g@#6hm
z{OBC{T4VlMys#_%ey6g>i*$Q&54`A4#h84t`ydXB+`bZ4-<rwd+)Bg<-f1s~<t#uC
zu|62$xMnw(zOtR9_sv8K_ScWk;-}<QhYEZ5ZW+sE8_ZML7%Jz2x4SZ<irxK^Z@?Co
zq7R6kh;;Ix$`)hzQMn^~YgwNT8w2g8LYR5hTFn;Hwv`o|3n^e1%j0HWurx7fV()-c
zWbxaVS!7~Y8HJHso=aS1WEpP9y*YI0+h-XcJgD=_W(5hqsz-43GYod}w?KLsgYM`I
zhY|ESpd9KEsy#L8Z@&CmdLn6vl?tm~A3Wb1uWt|-6NAMAWo}0H21d$*5S%FfXi+4n
zkY&rf<R(m9hi%!(tSU{$)erBc5sRt+tK6TCDd^vos<D!yCbj}+t{!0Fcr_pYul>i~
zA1#(1-y{aq%Y;#jVkVbr$XFdG9lDc!T{hvb-Gd^a{Be~u@2g?;snU0)Q>X3tjz<rX
zkD(pmVEdObwA^c>zXFbpKaL!)9tUwF&4c);aGhWDiVf&D1VBXE&4AN~R730I`8yT-
zMl8!p+#v@18!x&NTl}igY4l3eL4C}fr1pkoueLX(osOR3-D_Fke(|4DybbErL>K3z
zw15&F?Ly^Rq#OO>a)w>Pu3hUeca>O7(hchKMrr#H_ty(dZEzSU(}6M9J*1^vublz%
zL4$k-vr6E*G0$<4ho*<A`L*&*d+m)Gz}lP0U$Wf8*KU%2jathLwb_jashDn4I!%4r
z6ApVLFdXc6zsiWgqCj9ITY%wEWQ<D|Z(cH_CLUrK&C#xxFl<pgmi}@?tykD*;cF)y
zWS}$aEs57m&6U4rNE6e~{oz-8ynSAG8(z$GsYeV6OwsO*PUJ@}aGq|z7Rh4_X@|ZK
zq=!^d!_3rVq!!^CINHHO{osI$wKdDQU)7NEj`6*Dw!eq4Y@V)IT<0@s8NWD|EWddA
z0P$D}S_=l3$tm&~=fO|p`-3Z@k=!@K4~q8dk@R@eCd(Zvk@S7ZuBXA~a6Q^5d-)@!
zj=XuFyzcs*1)T_P|0+juOdJemdA-VsuB_n><3s$sWQV1nGcDEQUBWmXr(yB}VITHF
z*gDy7&S(^J@Co$YMoKgmxCXXhzAD%~pE<fH%Pk3#G)z6mySd4QO)OL|W+@yksRQ~w
zwJ6q0BNw^JD`3@t|GWOS>tNvIu;M7h0J9;wbQplt9uFIg+J_XM1xkrZ)l3{P;x*4g
z7kL-y-O<De-D}HU;wh+aXYkwk1z8tMtS&PlxjcNb+vm!)=Raoo*CRb2R8^pEdBmmr
zyY7EQ!*=g|wQrVY*7M^ik)QiOWuFXA)^M##H2OZw<4&LYguG$F&2x?-z%2@k*NkM=
zY!+Y4-uUD4dI2G_6mA$m{AYIP1iH35c&Ir$3Q6t~n@9LvWAcgV*BM=U8B(T#CSlx9
z*(?A!cllsZANQ<k(3Q*mjh*WvxG3%7Yy?I*@s4c5Vh!8{?xP27yir=7i}~nVvN{jf
zbn@UR?3+uqi9|0Ay=pA@V3IiKP&TlwT{%@9>7H*GbOrexg7E1oST{Re;x_n#lUDLo
zzZ?TlymIS&G3%=Sd*;(PjroJs1K2^(^}U!Taq~c>`&GDzxIo8(XG<1ZyKf$XO5+0&
zY93xugcdmh-vTp&YIA8~>H0<crP}O^Fk?vfZ%<r&;_U@(bgzNVDDzit0F{Oe%|w^_
z^Tn(WBzqE%hTr_@FM93^1Mr!axCdyz%`;3WQx7@U4x%CUhs3^p<1Ubwx&k-O*4}r{
z8%BLaRw>`sSY*OXL+Lj-6D=hzkWheK-%QwKsAq#}D*8Nx>q2BIQ=PdXmts-n=(avE
zV*u>YT@s(y0(Q=V4~aqI<h2%3O<EU*12h*^%9Uj}Y7g{4<VLycJ=n8lvMMGQxGEA)
zlj+hmi7vjlgNLVfhoF0CLW;T!;&0W8AU~FBG6*TknY^UAuPT^5hWW)V$pPKCh_V){
z<)MO3)V%-r?s_K4Wm()c8|E~5e!gOE3K6i@7PtvAz_iVNi4E*xTBWI$sZ)`y{vFci
zh|`y;R6~ln%1eEUq4~>q{_4j&nW-SF$&6LCkVUY~D?7Q%3mfvPP3t|1&zHwv^^;E>
zf~W1+Y6bGZWoqrMn`Qkc0X$F?@8&moGeX#r1JP-Aj>$MH^D>Ygo+KJR`W#d04sMWt
zPmCtef~I<E)Su^r+qC%F^QSNSXzWfn6Hb9Ngia1&BBb@QKeFJHrJ3Z$wxpbR%a4gt
z8kiJxOxsSdSuAyCiBWNH8*`LY23bzDavXUtnn3}PyNkV++k&eui7Xt$W++UkPD(-k
z9(UlI-Rs!ilKjvgf+GjsHb}jE7a#)jIW<H^mX!$=NoqM61eEEvN5iSczw!s7P|Y3@
z=K;UV8XO40A3u;^TNDb`tvrCDF6D-~&s-jv&Rd669_S_gVBL(B_CC&LK)aIGE2(YH
zAB6efSD=hv?E`w%iAjjF?+-18F5YoL0huFrmE3^Pz(F2x=I<s4VUhx`v|dkJAVwI4
zNx0@MF}U!b%#u3dtiXjku{o%2>im1?9|De_<m6}%zpI+C6mx~txu?sZXPpClyLSEA
zSSB`tsIifPnqMtc@KmkmUZb8CjAi+m%*(d}S#N@-)GPZ+TG1#R{&n4wp&p`z`wkB5
zksbI{qVytmAKRszU(}EBF|O%-xk<Ysx@fvw6uH`A|J#k?mtdfioAz={&Scb$P%>K3
zG&2a%J_$i2z!tpa>vXnnd@gg&4iuCr3S*Qi1*VHwJK4ViNM0jVN7;~-LoR?U>c<^v
zCX5myn`RhL5=-GT{=^l2hQ7!1Z=A7K9OW8cpGwm+O|I5k$7Ktxnt#`A)e^f3_tvO;
z=GsYgw6)4g)fXIM*UGudejMPftTo6^2dAOYlT-$TX<$DD6J=El?28&X<y=w0D=QKj
zHxn;YQl5Drb|*FZg$08fs+z!u1mA3ta`}<91XuEM?gW$_TN`~Q+T!`-UoF<e1<}(?
zR3lyiB4hYz^9&<C%~r-Oejp)60%0$i^Jk8t%`M72iY;S=1LpRPE=H9BARLa_jC^Y-
z_!w57zgVv=Hr`GzP=tAERNvgW9)o}3+=fuxIDTWgc~IWBK5-AB)R^NA?1BJgk!4>^
zQM77SDIo4g993!l5(MX|xq5&Ljr5)ZGL!S?wP*+8p7~aFv-+~Myzo)NwSV6-T0qQE
zwPrK(U&B)Y>H3~1JlWyd)5Zd2HpI5NYLL)%Kp5KBcT)(7{N7}-!7}Gv*lmalepda5
z<Z}OV1f%n1I}!cFZnN1ZMVOpXXb+q=wCT@ZygJuJWuG#itLfwiuK9eG%1`}rqr68|
z-e8p<IQ#E@twHZygaHWD4Tla2m|O?y8W5lf0Usiu{bz4Y3|#ZCd1vKcXX$c0|C%xV
wkEQ<{l;J>kK=b)8_|t!^+y6UDaxYH9#@^mk9HhP_b~zoD7n%w+&#m748(Wmi)c^nh

diff --git a/Templates/BaseGame/game/tools/assetBrowser/art/serverScriptIcon.png b/Templates/BaseGame/game/tools/assetBrowser/art/serverScriptIcon.png
index f65bccb3980c63b93a36c873f539048e41e3558f..23b7861bd95ac17291bb6f76a459c919cca005fe 100644
GIT binary patch
literal 9224
zcmc(DWmFt%vu@)~Ah=I}pc8^S1cDPR1RI<H!QCxD2m}oT*TEga;K3nifS|!$g2Uh*
zIJ3X|-IaB|v(MUlulwWv=+)izmc4IRJyl&{YASMg*p%1+0N^ReOREC_GU5>#z(hyf
zPCb8I1HeNAZw(z+brTPeqqD;sD_e7rtCyoW$lTNF4FGt~?x#ZBsYGH!mMX&ykqg>k
z)VP5z-WV;ncgPC;b+$9Dn!kP&GV0|eE8ue7qOcU+pDgwMA~TAO^?+Ejw-66&A2jrK
z#BF3&IQgSz!iO)keOs<OcMsN{ujhA}dUMnqd#4=>d%VB&_7jUXIc)S5P@9?xzFG@D
zqGYL?LWPsGFe$F2w8N()*7(%ID^gBQZhXJ%dzUUbtelDa8%{Zpr`ko)2~Ftay-&SL
z$*rh$h1PGmJhq=BP2C}ScOjkW?*Z3iunA9netco!tCh0nFCWzV)}QpCdMae0Q?<dP
zN>{F52YL90y>9gWe7AI>37&MXc(dvH!6^S`ZH9gBAS3vp5!qNFI3c>%sFikIY^1Pe
zao$hB#fpyS{?Z$N`{qfL$MxR5P*X<k@PRCcZ9_Bv*<!z6kKcHX+mhzx=T^aR*il!j
z$Wm0DPM+({Pv#}|Q-YM6_tfs>E2u5e?BK-Y+@5~Z$bnA=K9!#$X~~N5Sm!(hD`Sr{
zD6I_RrB^2|D-#_H_dOa(QkRC{?d4pY$(lWFxBGYJJuW`<s7vCnyBl*fX-W?RPv=nT
zKYemEluV#nzPQ+YI$%Q|<lH$wy?i(>CZ&Y66wbaN&1_Fhn`wyc)`kv}R(b+vV&q<a
zA^#AYy@YF$0Mm>?GAO?{evJ`DlF^=&!X>BMI`2bD+Qkn?hp2~{Nl2aXG<MqRj|F%i
zf9r=7Wu{W`@iHoqexlb*b)|SrvI|qU=F*_yo6yfs)U|P`of=giP}a4ot(~0Ps$^Ev
z7XCG@2lvBeqKOpsyjTw5dXsLo!CE~iJhx~6QRb?w*(^a*ThA|w#$)#Mh@<JC?uM2!
zUVW@AN2Zj2Ul>2%ee9c@iqJ%c`!xj}#3%o(5bhsSd)TkroKi)#D>vy`J9$CSu`CU?
zFavK$d}W6)m=f3h9ITIVsTqU}`9`}2OOvuDrqh5;%{XmBoxjQ*7^b*5-7c+vpKw1R
zy<Zp<da+>i=3uk=7n{x8me)e0n4P8MS=fP|@M|ik=ZrJZ8k3r<t5H9<l}zzFi>!NQ
zlry5luI8c0Q8uRoiD6qJX1hV}I=AOyySy{E?%qPZ$?lAck{5K?<HIIThlnm-TB;|R
z37ck01vxQH#fGqLY9x4Nb>{L)ewH%`zTFtDPA=`BeT<*IH0<LFH(G0xt7xPB!Bvte
zxmcPwx|c{d^~-Mb8QyO2IoeaE<!2|XsbVEHQmbz9C=t}VFr*W+l}y&=XQGX5EiY@9
zy1{2?ThlIyAzuNXkq_+JNm6=E=dHV2(hdthZ@?d-Ci?9|987sNAqu9ccte(4iDIU*
ziFv{?zbuUeR3WdR3%T#Hny#H5^1(VpM;vhEHN$)ONW-zriDcMjgGqR;&8Eyg$weZE
z<&~o;XyOdV5>)Y|lrw)#I#+5G(FUtx6nCwOhZgmh^kH&pe|73=>u#trn3QM?IIH$!
z+_1eWbFQAw+V6g=dY(HR=Sdm@CSA8!;!nFtK1kWyEVd79-MF@9+He|{mXC}s9)vNf
zYcy*ur;<Y<U4o}&Za9^+o_2fR3r4}*Q5^cbtEGV*dKS0jjXjnPu}VV6=XF2#0<KNL
zYY}4B;>D*F82ObRLnZ72g$2njQz>Ds^vnr@Hbk$7?sn6OhbMzu!Q>gl-VbE6G=Ma7
zo!5_krEk&Ks1JW4>Cxvp_l05RZoLXiiH*DYakKQS@!3NA8eH*A%}{R4YG~4YCtLYv
zEZgWH)8wt823M^S^Bga#wRPJy_p$@`i&`Q&-RI8cO`jRGTyQKNKYDoD!6f8Gn8__C
zH>sBodK5|Xk{0JhiB%HP+Q%`XBMkI!ERZ?Mr#*P7>j27+-~?j~QC>!|N05c}lQL>i
z?&NQCF?|}G%b#W<tC4mVD-Qa!kYe68D!Y7XFdDQKc_ppHHDhuoigLi%D1t_$gLNUr
zHAC=esxi7NVnX~7XYA4Qk`}(=x7v-kx{dDj<^K2rZMzE~<6+IUDXHjJvy&Pshd#S|
zK~U$bNG%mAZXX5_=hxXgj2wH<FJ3k6&B5EIx%ige2$nO~)X(L9ix<z^=fl*e#wla)
z6Q}1OTgBKKiv=s_&Y7`8)Ktixym_InM@k9!oi5Zyvj?&f0R2W*?}PRHbL20k^o3Kx
zzC4t_#w8vX`bH0ln;lI)sFycbl#e=;a-vnA@6U>rT&$W=V0|eO=O$bbqU@HX&2LPl
zFh?(!f)_{L_^5+cGUQv|C$dOSrWk5)H#61r(*W?oJF}hBtCDZud@>@|+;i)jTy?Ha
zJ&&j$1g!>6nH&^d66hcz-ZGoaH{~&Pk`*mjyiHf(xqeN!thN{PP8BY0xVxV|)XDM8
z52+d?rM9)cjuSx^>$ICSg8#D55MdEMV}(;=P0ltlvmnopVP+SQQ+HFcx~rPo;Eg>2
zEq#^bu$$V02)mVMXDSz`EE>tBOe|mJg@(c$V`9bfgM$kLOg?G5c@tDH3U0Dym~bjs
z1=#ckjN0EGAfsJ5Ma>%0D0*{JKGnL@4bvaIYe9Z=epg3OhN;qLIFSXQr(`NFwAd`D
z3_EJL59J~8@3+q<3#Pu_D0|h*um{Et86_feBYaX4rkt7{Xcg8~ZE)#o_^43LM43Q3
zkN`Al!b-W0Ufnq&mi6LL;}(V97-_k!(<UfW?+v!5wx*3pPBWh81L@ePnx|+vggu%;
z)oEi@2Ij9aPexfkALH=vCeH1+TU1($s6N(<=e~s{+=;@ultbQ9)zU}_SY)HJ{=`-)
zv)MMnvnr8-mDbnQLz;PLJ*65dbA&E(tZaV_2c>!gCQ%y!+bT-ifq|EO$O4Ixr9*xj
zMZ_g~%bRRR9LXBJg;?ER#fSYqHli+7&s-Z2w;%8TLtd)$jt{2=lparG#;B3!Q3~d!
zMbJkywzhManYzzKUO&N3VP`ujSa;iY>j*B}()dMo+8Z5x;Bn26y85A1ai7`GXgs#+
zlP*Pvr-_`^0N?P7a@eT-j<k9jPdA}kWp}YUFo&MK(Zg<GmijCoCj6yJ_aH2NX1Qoq
zHTbNzQP}vhDDPObY{@x8h-W0L5t`1|cD?35{eyPYQ@q*UsC7E-Xl$n9UE@!)5})bt
zjqbyz52KsU;M*08t>Z?7uAB8!2e$`gIA5rp$(D^?Tvp}K1)JG8%F$joL|oRqcObl!
z0W2vFMT%JQyWS6gd}LATh&QKQ$g@WZw?tqNbN{rHLRSC2I1vHmI*j-HaJdIo4=6oO
zi?FOc+(u;Rjv@~d-%N0ap1j>wLL#_vrV)F!5Bi|DhuSvVV3vN8FXik5<-PwPcd>>;
zFJDGtNqkM&65$(Qu<}lkb*!X;Bw95!7i5AZF-mMTV*ZY1)B&~m{^JwWDE+L%s3?oV
z?`6g+S$G@d<{>s_%3LYEWH3C(&N__K8%kaNhpK*C42hAU-KUX9Yt5HZ78rJx38|8+
z+*18<hwiA4Y=a(rmRCEkJReLGc}48VnM7k-$g9dhPR)-Id22dYM1ak2)&Jf;AyFoz
zgI<qkC@TQxojlX8A8S2llVNQd<gJeWAHkT56xrIul%p7SIKH8g64T4=%_oknF^BrT
zQunlPCU~3P>nhH)Up!W=EMGBagP`>|ArZg^zd?`LP;i|I!|Iz<4Z@x+lWb{*pyVOH
z4y}7?^F5Wx1dKG3Q*`P1?1p7_M`gsKBAM_5gqGZ0qO8imWVrjHQN=t9trjFuT4*qs
zxD7y)uGDWwsdY-`ji+d4rKKfiJi}T*ewXQE*1H|#+1uI3CO#rhBW*kB>y2ZCA7qHi
z)vyHP+xK-du!d&Osy(n?{Mh(dC56=Bd}jS&2|mVX<))Bloft9R%C?U;7bmDmMKO{o
zY+l})7YIzHxr{5`YK8>5i>UVN>5Op5+Y3{oU`0DTA#YWeys4V|`h0m_M15|p0Zm83
zTBm*Qmf~lA$Z%CVQMWY;zg-NA?Qm)t)rUZ2WFLYk6}2D=r_i)UlhnnJrl+)nBVx*W
z*di(V&+qaAbtoTAY9fo1D0YR2aZF>?#<m!k@R;$e$9Lsz>Y7D(?{F<IaALSBR`NJ^
zjSZUBfDFb_(IvaI42ZsqygaFOZO1_(tqJfd)ZXDdOHfkEH?79-c9RP@l88z$>D+kH
zo`F36c|~dtOym?Zjm=e{`X!;>(WD~ap}cu-Dr8(V*maU0X50XxbFWC~p*$eq-!Zne
zPGN}xB5_?(B#@G;%(8OIbvVyxe2;9$@+u@bU!DXtKTg=Qbsl%xyY<X}^eNZXNMNgD
z8edB^jpAKazy+!xTcwJGMJ^O~$}wxbFX3nTqkutkmz0}4?-4x>wwXvp9%Ft|VnuUg
zjR{ILvz#a=L}M~qiHec3TrBUD-eOXKVz{;#evZVi&2B+#y*I{M&ke&-%kvYIVUL3)
zV5ZokCdPfn&_eTifeDiC73O+36J_1R>Xtl(D%GV(q-sD0!O4!CMj4q${Xq0VYF`Zl
z3qH1wV#a&N{a%7o7F9)p55=1&x7#C=rqV#iq@4R@x@Fq?DU1PvJ+XApVUO{xWEXvG
zXYsj5sb6cFq`x@7Dd_%@|1DM0Ri2%}3%!X_BO*D+!%`6lF1l_|qH<}FEK-z|$zZjh
z#NWd6bBNuv_^#0g3f$g;hBAZfF}Odk%<sjhMvO)kyX;Z%%}R~iV^AMHJ)FOawj93E
zAu_(t+Etkx?;2C1#PTXDzga#KtD!0bc=296I>owlDGqhl2V;MS?Yr`ECKtRfCTdQx
zpl{BTa?0)AC&~(?$%CcTVud2vWQCE<2GW4!DDha4dMz_0k1z*#N#%a358=2B?jHJb
z4_T^lhR>@@FLn`iKjJmmkGIi7@-1~YrrQ7U;K9J1K!||Ut5wUG@?sRcx9&U8s7slP
zS*#}yFWy42-+|PFFx4NP2F@Dg45%>damI_g$3r1!6CHXQ%eA31mlQICP(?#mCbvMW
ztc>aoad9oH30(d(%Mc8?;*TjZB{UPGa1Cu3PqT2Yq*D!A72b`iV>s7x<8e2Ov4n^3
z4L;gCxdK2$1W6d;lMTn6=_6VHuwNHFHPeS$7wF*GB`$f;l?334yhaV$dO@rQo76@j
z<wZNIiF8wYfz3K%6y+9hhGYp4-Q?heGBd%_;(13aU{w5_QS43(5_Xx-HAIfp-9vre
zkyzx*8lltb-{}6b!yFTD%qqzCdgt@3x2~s#=cgeE8iWku;5FodOw<ReSNDr)XW8vu
z@$5&It686_1#z<&bseYJipROeRH3C0)#MQ}MZadzs@exWzY#R8R;Aq@Swr9OV}LAU
zablWv-YRi$WIH=v=Tkb*Eb*U4c?m?nOs!vbn#-xdyLi+7JjU_Mu>_;*gT#fqzDLOL
zc%GCx2HjbGfs>5EccIuDS(-OgSVRU&PYIyHzHzz>KNnT`7=&3YPQPa}{BUJ+{>HMR
z)3O<pWu%rj!KamKeZw5do8K7{9s1FNUD~Mwf{~4S`hckTMU?6_=i@f`wzCmaRlwu2
zk@Qh<!D+0iee91svmLb=-3$GU$DvkWHRVX$#8-fzn^9(7$07=iAMzIg6Fzn`>elfg
zUt>aF$%OrEOl`g@tC;!9P6GlnE<)V!X^fKYJUW9!7u&&3qBqj8R~eCLV{!7h{QRMm
zb~w?nV(<*tx8(C)5|;cDp(o?w0nEi%Vtn7bJx#yJyO6wBeB`<Z8)>%Qe30uaD617Q
zwBG>OePL!`RZFUaCOnsVIO;hOMkA(e$)3aJi0`^0UBE?C>m{Klql5fG1BJ8T9Lu|_
zxv+4V_-G3B4*O#B<J=)?Yg#cp3Q5iFQUn%ZgqvO|?fx;zc#A*z{c7zvhOl6WVdQIV
zXH>N;JMM{@<4RNJ(om043XO?CppXX1LsSu3L`s?L@!(5RPdJg^_C~V2qj?KJ;%M3y
zWCnAxVoW0?y)gwT9k2Au3xB!~+TncIY5e2k9i5wydsJrdQ221;UR;A&reaq3%R%E*
zwjTqnc&3DTwQ_l8j2=Z2CrN`c)UVw-ss#69pkI&%gaa6-QK%xm+4NXxK|6ZweP48}
z1&%6x+h932S>I7&!rw;j5$KoMugK%f!qhnxv?iRWj|n=JY)3mSWeoM|f{>pP3cP~Q
z(-e!)^r;%qvyBAu3QfT9+Q}cE+zT0f$hzN(SulcF-e(5h{R({O>gw)sk0TUJ>@ph_
zftWxc1zSl;sVPWF{og?oV!V{@_eo5?Q-ZqNNY6%-4d0!>sZT8f97@;yvP1_JC%=58
zB<Ned(MaAS1t%wBeH{F^U@aQ`bT>Cg64Z_d1OfugGGwer{tDSLkr=(dJU!q}7x;(#
zY)V{>On?mEnT9BnnM>*OWs;Vy5IUaF@WGLX+ugYOy;EYMzAX`l;0qW3k8gz>INKQr
zhPjjl!URHd(+YaLG6lO7bCi5lL_d$Ch0!%|2;KHHSXL)lgq$i_Lj|S5#3DL7##&<}
zt5&P9vZ8qScVV#0;%b?Ob(x#$-B)8n0|l3i4a`-Y=g10(zEz5XBsp}XB=$8(=7x*x
z9=5L<`+{DZB9a=X=y{;!O~?JRN4>0x^_T*74{#r0?iYz1XpjY|FN2#7SVMtUi)BT-
zn^HXE^SD!QJsdhDl)3h9H@&#?fB_ogEd?UC(L`U~mSE(=x3Wv|DCiD>t$c;`lj16L
z0l03pz9`hx$fh#=h8|uXsum9SP^+^Gly7;?{YbRey@&xI`s){R(tr_wXwO08Mo$nF
zEJt~W3jp8{{c#}ysp;ehB8IDivJA#gEOZQ9L59U!b_9vSRYu2E%E8Xg+};(CayB<{
zH8%r!Sh-q)<P?<Ev;*<U0N{bUg0!RtVuH9Z=T5Xq5wPOGI8$Zr6_?!2gqoD6pgm@&
zL2V@Kn?Bdq|G3t|s)_P>AaV!ka+G`G8*hoPikQZbxs=h9^x6pWqwT3@@W}j^#}fiZ
z7Dxa%A)F8hKzM-)03gH-2>>twKmzfE7;X{(f3@@v*?$}PTiSoK|Muz6Xn*Y|Lh84Q
zzs3IhFbDwIzj+#e=G&jq{+0v(5B>rHi0}8$4gY(~@dn>9S(>c#DbEtTZ5?d8Ra}@S
zrzRPyz*XQJtx_4keA?RC(xm5!=IC|Ov5aA%p&iBqEfI$LxE%EK^vdIw9&<-~-7lMM
z+jv<}0pgbk{;4{5Q~0Ezuk(%lp6$N0bQdR0&+LvaZ(7<*BZDZ$Sb4N|^<qW^vrjS=
zOVQOQ<6GyApUerZgd;7=b1zpGAB?{J@s<W11Z06GwWro{7xbJqdorePET5i>Hxh}=
ziF`7L<XKUkUF+J~^X94_&B4qQ3#`&JGGz+qyneL_P*RPyZFM7Tj!zCdO^QWyI2!9<
z0)0)43ahi{_P$r!Nk>-;!>h9xQ#muXvVOI+goKb(nQ|?cLuR%FMczrO%Brg4frKnx
z>ssBi&t*LaL-w~Pi*2j$`@0W_RFPOL|Dl!BFd3=WB(N424ezn=coxy)y*3fJWd3$B
zN4H$IRyT@KfqtM$$G{-!`^Fnv2m9V`V}gs!`RLwqX7penKy*%jDYAviV|A#!W%`%#
z#aYMw6g$dc!P4glMui-$a+z}7h>ZP=FJAkyx90GZBE|&E4Do1{HdA9_s7+@4*oQQ_
zu0lHhhyIN%WZ$C-0y*mvW)=6|exWk*y_UJ%ANG&3nQIDp2Lv=*^QSubUC8P$wa`YL
z$>u?<St9dw%X`i@+~-@pM8sRYnCk@U@PgG3*#SkXmR4F3y}8QjTB0-W1#|zNL`DU~
zX?$W-NQY+L9ZV^J0FZ^2HGAdgbZBiYU#Icw1jWbvlvI_ql_WN$lf;i9Q?e2efjwQ#
zCGMX*1-eg45=tZyGQ+ovnN|accsk@#M+Me>a_dxi&WZ--<&ggyob-`o#=R5RqoXB%
z{>|@x-y<Y|{hwqaC&dyvro*AK6GH5NCIsl2FD?O7jlZWcCfZsqbQw`o|2pA#HkttA
z=LhT$z98W1e_;<$_(DjaWO;wsPJrF>J*}POuVA#@w}FIHsn5<FNgI*1|Lp{R;{+#`
z0P;JunP;M$@6nu2m>kjmD!)06?9p&>R^4m<boUYnONcFmIx>JRgMM|QNU;bBm>?tU
z|9j!LVGx4zKYePix#9+S20aZ&(nl=)51hGLF%96%{+CvAx--;&q%}F_Y2u%2MYu}<
zI5u=)!U`k+m>HE@taR-3=gQBB7mX@#lu0Tj>MK5_@jmWdY$V`nq3DB^zW%9cGCp2V
zv3xZzdQb#8J{n@r&ZW<`<O=7)R0@eYUCAMd6xgQUs=#BsQ3%4my~uS?Yc?W6E4+Uh
zrl)80Y|mJo-uSiEo7*bHN;i#v%$<BmO+zQsG|o?q2wcskxsPjPy`$cv;r10aAf@&7
zJ;t}*hp%og4|@g0h4={+JEo9cDOzMydwQSpQrhhPktjXh3_GQ6K_-ll#Fkd;AKUJ$
zMQ+3ww7-a-i8qox9ahD~L;}3dj&B(cp0(0hCCb*SM}ey@9W4Y>qoRtmO3}OWkwy+`
z)|&ljdxxXf3O`(|jSfez&P3#H;d!IK|0BaMW{;LE_67ITWl{^c$nkTR;JxL$^{;JQ
z1_C?_d6jd=_oa7b*lESQh#$~Ci@dpSqKl5Ele_p@5k~;Tyika}J)pTC9)|XIX43tE
zToD~Ir`Ijhi}N3?&nCw1&&mVE8DQ(X8%ec1O5<P1^`#5vK2Dx!iFzJ`XhprqRdrR@
z%6#nA5CB_R?>7&>%p(a}0YSz5N$<T5Gj;R~A{4uCjJ)(j3%IBYDxS$+ukOjDr)SDG
z!87hL0hV<43YvXG5!!kvIePokbo7@yJi>?&d(pFS|L;iqTOk^N2;2V*%m9EB`ERr|
z|0(vbL@A;`l5p}xfRO*?{rQ6jxFPH>TCX>D2g#4Ga?a^{y)Aw;q>z0E;%$k1r!p^I
z_j+UKBe7h`Zh^6O7rg1r6VFlfk#ycg9o9b^kD%S9dDN+SMJy30(CKw+3tNonkR(Ea
znWbeb6YkQGe=tHK&Rdq7In<}^_I`Rl=!+X;b;Q(8onEZ}vwL^#l@5H;XJ#sF(^dQy
z8`NtdX-JNsh+qQ$N1OnVffWg`c?A(qia1g@Ag}jR?J!!H!LMf=Zc>t3W~@l-Wil>?
z2ggOr&#pw_aiRioWy7VSP^(tb9xPrPO(15xy2$8$ugoxJTrihvlV){XG!8r`T7EGj
z`pnD6Ue-^v+OQfEc;h-LSgveIn%1sKJJ2Nluy)If%ndpKTVzh@t;x*Hp}l3svpeqe
z0Z6}CJ@H1lyqkj;xYuPQ^}dEiq*)M7`p~{rS)9Dii|!?1LXtpwpyhSvb@EneeEP?L
zxa#i0i772|05z14W0#3DdLTNYu?y0p>_)ijr{$j+1oa}$xBv!MmbrH9lsDaA6c-u8
zC%%DX+ZW**DNASKJCS5px9fK0(I>?LOLr*(_cu;&cKy&0pN9?kvv){MUv;8~*y69w
zpp<*4M|_(plqaR9&0}UGrSMGro9~-nx8T)=l=TJ|HBw-(@|dhr=;N`VMJ?grs)|!Y
zD;Uz{m1y3gx(jw8bs1diaQ$RMf&@aAou)p4J$en5(SbwLW(FDHndcHfyz{H{pFM)#
zpIRNwxSR~$c$49R0MfdYcym+m*T4-w7w%5y&mP02pjBsaw3r~Wm(T+h^vR|m+Rp&z
zCQly3mo<_H(UP2Rq`=P(B=A22#MkXE6Uz3nH_k~b0q3p5S#5Uw)wcpT?|myg5a!%n
zP<JzA2rasowE?tQYB?{-CpSGpQOdnN<}E=$Ry>9vY!L}b?W^)AWb~&C7sD>iO5I*F
zhA}=y8hx{1|LHrLGaRcoLLbcMfQY(9L_Kn@hX}WebXFpy03JbdA<z?#EU&v2k~ZY5
z8jOHa`_rMF1~6?o72!{8AYUX|Y3;lW3>O`EOHk88h;SC*8t{1abPe4K+Koq#aeB15
zVgo}1UI|M?y4;LIpiu^H41FhZy9HM?n;VekGx2f>y+j@IpG!jJkWf^lb`t&`s}?W2
zA5EnO=Om5rrp?wqp5f-Q3kBK%mgsC-jH+f|w>oy-lNIFv7eR@^6D8ABs<AK8y?*UU
z9#Ahmc&<1tM*8;P>%^OAv2K!pG3eu=6L`wm+P85WxA<P}?KOh}FI_mk{Kg}I<x=u%
zflj2q$IDH~`PqT7z?JBr8US91Fe8n4JD(}^y_cudf38Zr%{<wHcB(1p{`6iMe;qjh
z%{FrUR>*vjVCmxW*foG{Hzf6sAR1=zS?5><8;XLp{`H^L1M|#nJ$gg?G#TRmW5mS<
z>IH!hoO0Zk`kIW>Z>-)SBLe|w7{EYB#b1`-lXb0j;E#3%gn+pJtjvD~dw<~9?|S~f
xbS;0a>9>l1X!swp|K5TG@c;L>izVtFCB8x`oP#CS1mOyxAfqDv`ML4C{{q?~M6Cb-

literal 14897
zcmeHuWmr^S^zI==8WE8$r5go_p^@&EE)hw|VMs+mL|QtA?k?#Nlm_YU9y*7fd;Hz6
z_w&8aeV+e^IcJ|UXZGy1_S$Q`>s|YVYN*K*;8NlO06?IqAgcuc=wK5az`+JjXVCF$
z@Py{3B`*z>4N>oa7nrtEs!{+@8HsmmfdyVabWt#L0|3IVe;>3s4nivMCbp%ryexSB
z3pASfk1v3&2kwfhat~IpDX|z>B0Qzrz*{tSItK1C&W?^YPVV3(0LZx7Sh(9*(|g&u
zzoVB|RMoKNws`;m!caw7DIKWk{sIA1S3m9WIABqIkrZ7qLz4a>CM%Dlo&Cd7$J&X^
z+9w_*JOW<h6d@5J*=gN#_B5hvQ0Fv?^2H?nh(#m!@u9GZp#t4}4Wk?G%(}nmnLnb4
zadM-MlA}`BpAoxGiOkgez<y;9Z$Zv%l^k|&iS4<aOpnIaBJWFUr>@I6XKuF>!BG}l
ziw1x?3L^&F6~t)Z5s&15n*XDR|1XU|Bi_N^eL(oNfvl2s9E_`=Aie?XIX}z2VdaZI
z0nm5@9g#D5C&nnPC@ax#Y-^*#z?!ZA9H6}m2guBDx~zR!Rn`1juYjsWNQZZOH#)?}
zXPuA?2LN7?qS1dz=Ac|ZNQQZgd5Irs%By_&n6CB<0O%utDD*+Hu#Nl1<j{~aKk_&a
zcAWXKg+VKHpyDYSy+Sm$p%J-CB<hzA@%Ah`lGh9XN@M{X+0c^YT7v@)B;u+y#1i7#
zgo|!(IphNbk{MucH$7_jX=nJ#`TkAL>jV2YoW-d>0YH=(@YUt8pBO~BWj;NTfKxV9
z*L4YF1Ji-PGL_${+2fe4JMu{bQ>MWoK7js|1n|uaxf|QsBmydkVgbLu#&evz_RY}E
z@~|uXp3cgkDii%npMKevM}`H`e?BSH4sh`(R(;iooNu)$F8Q#C2Jlm%wcAHy+c_7h
zTZXr_?s)ZepNaSh37j(3x;o3%&Kq03u?+-Wh2RQFV7}7&q6kt57163^*qST1x%a{Q
zbjotURUWCARK3AxxH!qaYpJ;fy1(X+z;f<4Sc1TPc2%Q&=VkcPRTmx?JO2FmB%>ia
zPRRiisPIKe;OINzZfg8hH}m+Q*+PzA=}5Ue*2VV+A3e4x4Zq6Sq`2V#J-(Pgx$OJ(
zx8yA-4->>Doeo*+<=1wrs^;R;QYrISN{Z${1rAy}(;ykQAach(E(Mmh2GpJ%Xi1p|
z%`c8I(HyI1RW&w=`eOnW7{!1XpXtHW-c_5x8J*4{9S|tMi@qHCD9K*rc4?}2kPe9A
z#{_s}zu82%B^G$J;5T3ZS|PwP78x**j*_=wX$b%%aY+ENztnsSiq4XCq@Zrt{)LTp
zX-t5KQ{_D=EdYFy|L?{)+EIIvp-`XS#!$*<4UG1*m`mTVFJu!{T6e<vk^y?0;adiu
zW>y?NkBf`Zi~4l`)G^IAofK}7vG(r8B-P7C_>3-TMv9HkG0njq6yQ*Z)cEMXLz2q^
zN0M%i)g|S8KKK=7yOlq5&{RYbpMDl)nI3SK3vXc!8<fcFA!&X*IFIiil4r~3(W^ao
zb?fLN_w>_rKHUA`gMUBt&zk*PxN3Hgd2R6YA-6sCOn*AWp?7{`fnfUSNP^pkm$x_A
z93!X*v@6(@o(G19I4<tKIJeloxBw{rGBdEv-)`trfaStnrfw-igIGN|KQQSqTVBf1
zo8&fp#*yl^H8xT$wdroQjGoI~WWPHu!P9%_loj=Ueo|&;h=9ZEkBE);T$!X(a?MR>
zZsUS2`z8R*_&s>^#=B*H_f#=G;tZ?8uQ$A^bqE!fF<IbGgnYTcx?fFctxI_;PN_S5
z<h#0LrhP&#<tQgt>h|L^Z=Ks%coXCAs=vZ#c>DLaqh$;E577h3Ej4YmX-I#cG`#Vl
zoW+u(v@UI=|IHIPBriqTMlaa^=3LayQ(Rf-c(Gx43GO}36`#VPvTJ?W4_)K-@V}|k
z72FrMld8E<kpqrC`KxVEQ?i*ov*$>)vXAR2G92We)HzgysjF3%6c|3+O?i?pSH7)s
zE&9SAf8+I`l;IXNb5UiUsh)6mp+4i!xD-Ei8b63QK5Fcsh1j5JSOXJKckh?+8_LWi
z^B8<0f%`Pzi4S}QYsM=&8CuS2;?Hx<_;lWDJFj%Ar>_FjWNalMw68N=9XETyhhf?i
zo`eI?8jj7aQ75s-59eB(s3oUYRCl@KZP4#5DPQsg!!8B3!!lCpXydnvHak&}lZ*t?
zjd#d&1-YhSS#V+1Kc)1OfjvLW*$K-?uUKm)D33D3=XjF;_Hs<sh^L&e!z%DG(Z9h)
z7kR=zf?kVZ?YWjSNt}m?(MH~P(~u$`$zC%|QJvwEmctCO9GLCgP<rAMw&*Vi#=49w
z11D|`NNWy{HN^EMzO?F(_ZB4RaQ&>RQ6Z>CXyQinct=e6a=zyL2T!?{P()=T<(4XA
zGv~BiQ$X>VJu)d6SY~rpb8R`eyeQKtA2|<Nx!$dA;2zgx93(sMEiJ$B;HuyGqS0(;
zOYYi=mzje1;TuoMA2LzM&CTcmOMLLYc;^vLyY_;scEVf(VEZ)(HJS=~<c$-?0-it<
zs%OQH#r^Ci7^9<2x|=l+=KhJpZr|R#EPoc{RIrusT#?}>xzvK2@xnwA_a@aMv=CYB
z1G8Qb{*+ht$x96ZM^@NLs_s|?zA?1ZDKoM*DHjq#n{5%29yt)eX9Cid`S;;mPvSfv
z6h{W_&`S^F5T!LbZM*q7+OKm<(PlDPwBgjM?K!JPZgN5MrLZuL)!Yv}w@b--k!auN
z;PP$uvv=M(woSv&Fafj6zZGL5IQ2K;kJwQ=$)+Kt36{dnr0c^=y^(kpz^UTsHlO7C
zV3ZwlD<N-RJP4GU9F*E9zlq_eo92$Y+yXy^QH*~icC!7hj3>!Bw)J2-LDj6wQ&D3%
z$050M%h@-#Z8&*@R)ORHEHmhdM$<4oCeYU9*-Oo{iP8K;yOzW8lVs_<<13Xtl-yAb
zT0?f}go~n4_&i07Z5F9pFt4ifKv}_Id3Q~Ceg><CT<uD@fiuZ2b>r(MBE6`6aW`V%
zcD(7O_|+e}{Gh<azcN^8<(t&dfqL@CyFVhaTuH<ReOKRFd8;Y}B^;n(-QJGMsRm|*
zp_dl%`d}}Oj3u3UDKrsj;m-O6(*u_(!@mYyMKOe=!Z#Wtyq<bp@b6>E*?8#l&Xu()
zI_J+sy~{B@AY7m&gbl*jVUpZR7!Mj{GIoyI$a4eikR6J;O~d$@f%IJot2OCvGokvX
zORECUa=(Q8NcpAFl9}+?i2s0Wq0hx)JDMcuW7!WRC14Y}gh-C9pbSp_cMmpA!<d+X
z8C_>x?F6nqX5&}w65+?H5G@F!`5RB&=T`^IwjpgpF07(Dotb{6F{8LXPM$dU+cyHV
z_v(#jJp1Cjg-%F{K!BJPg7NdWpC+M9c_hxZF#3?~N4^D*!Ju?~SNxDFrhmRnh0Uap
zYeTocaU-3!)4X`L+p#rd?D2o|MDooOevbpN5tk3u+W5YpPoyWlE&BMj(`0J$JZG6=
z+pzApij$?q^s1oTa0JWWQG3ew7*Kq3k=w%#4bYL}tk@xUKxo6imW>8;YDWOHc+IWv
z>7%aDHajy!Wsaza&zR#8TbVQvqt4UYF*#MBEhJVo1Qly`quxX$T`=pH%mn1TDKR?G
zkfP@hSL6+(Cx+8y$Yb1!g(_P+y&(t^8AmQ1P%~%o#gYGNPY5^Z2^4!rY3=9t-xz++
z2F$h`N>3e(QK8XuuEt^p;iAJ{m?s6eVKDyY?-o|+ad`m=ImP{^{epo#RVE`7hHox*
z8^C+zv0mc?=Q}%mi7q*vN`iUo|AN<4BBSFpcIHg@9n^D)66bf+9@dxKEodDv1RKZy
z67G4}R8e>H;x&L%JQj(4o6h;P5GjVqsRLmk-QQ`vdu#AkHY7M~wB26}`|FFIH0DlJ
zrCLLG(1vx5PYxBj<hF1umItv0xxU$_z<h=b*(Z-*g*<%NEz1h+s%H*Ff(zDXRk8eT
z>K#%+!r?(`a5Be}{=1h5#x0LwHaVjV1YSk&vu6^6Y(fp*vNj$m<Z(UtZ2~RWja<#c
z(&0ZB&(GTOyIh8E9^Vm?&HBBqy>XWX6s!ix2wc5XTS|_2aY}Y!oV|!Q{(HwXdd4^`
zIp_$3v=xENoVhfnQTlz=^U$RMu^VnX<R%VK_=hR*#pGy{veSE?fw8_%9Ec|@KM#NI
zsJydIe|$ikn7k73#WV7SEYJhk>OE00okrfhzHDG6Fg8syKKd@e(-nI=6d-xc2w3AE
zUQoO%Df9~9(}OU?(mv&n^;QLllm?O~SCFpc;<J!ZVl?{BE_sZYMOdO{U>AOmXSox7
z(jRc)TGL@95~6%6FP7B6xG4qn$PP_*7RSC)jHSe?_(DFh#vczVTM>fIOLLFRIxEk8
zholGsqAIc1BXVA&|Ek#4PdxA0caVpfeiX;%rM=%`-Xz=?k0l29-~5~(pV)z^NfvqC
z;pP{(pVjuAa2YjxG*$?VM0<LVq}mrJ)qK#7K3F?g)%vGI#V$3)<L4jy_Leu=sYCow
zNX-Wy4T#EG%6E%nI*C?^*%rKUG=-P10nWdpEfWjAz<Ylt!#^+4jK#2dsqc{v`w~&0
zPW4>)82U>SBdN$42t57;Yl}}Rpo9ddo0<#wf6A=*eD#^LRQ3tf;4RehH~$ne;DMH1
z_<Nt%eY+crpXWZW?4kZTuqijmBS-*;6-()Ojv|)F@dRqbkNgjapT@5Q{HINTt^0kD
zimfSSePuIq=6<361f|0*69fcSM?da!7nmk+fXSy(`<+9X<=Eem!p`f`iO1jRqzcpT
z9Le`)ruvj(9Yg#~z_lrV%>cApaesO(^+CD?lEb$qukla}yP!aD)_-cL76lqL9XcTP
zlk08$YT!oj6JE1W*UWC9n0)|&cWH8+;2G&I15~^Y<z#gsB;9lxi;Pd)ahs&qqoSW^
z_QNO6TS0yJZ(RhwR2oR2DWn|~-1_?!Ufmkq+U$!@T(lDKV4v157%&f0s2un}NGeF}
z(O}*8`*Q)NtshewK@Sb&?Mt+w3GVN~D62GAb$U_M$U(Fz4iL|~z$v%OOFJqyD7Vq^
z`K=$*e$qt@iv#)FPE<$SKLxZ910@<9UR2K5Ka6{IPWyuXfjTeI4u-VEc<glZ#QArZ
zOZlU1Tar!kA`E~*Mnm1=w)f5}FH*p4EAJ#j^Pxcw$Jl7QEm3R=0qTMAKS^Im0}9_3
zgU?=57-gBNhS}({;`!9?+;J!lCwo?-k+d*yJe9yMNN6%!V&E<5MCF4+6~_S--<6r%
z{-Irurfev;OR5=uuOZcb#kt`w$v5qM<DqG|kak;Qr%y#3#}iYVH`l>9_^eVUW8^5{
zy%K8lAetNOz~HI3{cvMtvnkfcw}!=!{NCFl<3Tvtzlg)id@Zs;$P=t;)wI4FOb&CD
zGZB!<qHt36%AZlKYJQ_vC;@5?!{A1O0kj%SwD#IlvPrghvX^1jcQKE#J}Q(Vu6SZ^
zRB&^fhf)?%c7MpP>n*QRaWz*Oo)+=y&e7Y;yljl!{0@%;Ati403QBVF9*(h3y91_}
z#bZ*-f7)pYUg&eiU*yRh!0wavTTo-h7r|;~_)~dR8s7-Ds*`OTLUFZUo>wu7H&(w|
zB$cZgfX9^=2zaM%1nexGW-Txg5CiD^_wOXtpSr)s5+lSIBx5fu4!FM-IX%C3-j1F_
zLYM5{ROe4rNYC1_OHN=x%Cov2YQik@akVyVB{nmCi}j5m9O^nn!Kh(yE~iNV^sVo>
zuPo^OV~T5>X>raT`iK<nQne`|6w@<y8|$v!NA}`V8VBP2({|jUCx@R3+LUQB{`f$S
zi9Ln_)GNIeZBzyZV;Vj~Z=Uu;W+A`0lm#V3HmN(mrdu4k#w=WQWv#Vjt)SUO2Ds!s
zO482Y#wS$~SJ9In#!gy0{l24H?c^@Zv%-lGeKR%1Ms!ZtLn$<Y%k&)a=?xPeJD8hJ
zjPcR%8BU!i&adwrxt5lgSn@X0?EctrY(h6(+$5dYrPdarRsXVgleqv7`@Jvz477lw
zy)L!dR=wU6i)~b?FRp4)_f)1&3~4ZPt|S)AT|Tbb0bOMCN4(4geAFB%v25Z?nI<^M
zHB3M;qcF$5z0J&Vy6?wmxU$D^m7l{l+`p<QZ*1QQGxiQIN!-p2*c_1~HWes;=;GfI
zf3J$aPrCxfl-JJrL@XXIBB?0>6``}`VHO%$e?(hXZp8>jr4sH{pMp=xfXhL=(8$JQ
zHtngV;Z&{ECZ_+XgyXFxwCO|dI5EyX0dqLTVRnF1N5cI}sV4b)VjyOcOK2yyvAg@Z
zs;L&s$-X0(t9D<A;sX$5J~3R3V_q^c*3t7i#vk=Dg<vbF?wASG_<VkV)=rAZIap+O
zn|)*B@owx6S}p<N@sfv{G0r;#H%LM5`+95Tu%B`<M<QNvr$diE)uKW{)56CAOuu>b
z)37htIzAlx8rXP@{0{FbJUoYY?i_NtM{27Dctz$OeF%LnR`4*YZ?vuK??JRBC&rnf
zTaKPnaVb2bDt>qz%fmxGf1YGA<^F10E2r>s=!I?RIRx=`^wG53j7yS%dA}gW6T7I3
zJeXJYq<}@}Q!t(6uU*IoBc1{R(@a;Bi=$t8RoT5ck3|wPKgUK?l;WS4b1{b2r@9g&
z>t29o)^xo{tM$=NmAx~DdsIu4$E&E0??Yz(@yn(CYsQ7N-WL9INWs!iarraKi_o^P
z57%D#Q|-Hg@OUYt*gItY%;<qO7!j3<j)jV+etpHoV#gY0d%6Uye<FwEnwVTZ^VCRd
z$Ee~8a=P5|y1rqLk0V2fDi!<<)#j8NS(;HhPjj4FN`hfcjiJRzHHAokbPHhcRWb12
z5o`v2`QJDGr}=-@LzVSuw$%`yG^=_`GVV7U%^cY$1yg6u=t+5|+7re6Ec&?BuFqo9
zxS~rODB}1iD74G9^R1zKKf1<uw|hxlt<OGF>jlu#(nQ~}1n0V0D|iwR6-qqFMUHP@
zw&4KgWayGT>&0fh6Tit$B4QMer$)21dWVNT_#;|6*@>H9jPvjmP32{-RoNZYyQhB@
zmcRn6+0i9&tP4$V&Jk}>BYkhY1H5Z>HaA5j6vL-pTb`V?^Lewwbkg@Em}yvoQ{lip
zrIBm4n>Dk2zts>)pezZXRlv$&B+h4-e0#N?G)m0oDNX>tFwmhD_cv%E>>V4ia{YBh
zeME@{;1HtGW1aD$Y*~h*nu=_dbxq&<+~h^1QAfkiX=3QkJ^R=0<TrHUPchmtFai2k
zn1O+%oN1g(iGo7okbBwl)Ti+`kp~Gk5qnmPfEWn=#PZs-{S!JYD9k0<tK8N@1jze_
z5j=xmQ`+=m_32UBZ|iD?jkqI+TF0**15t!H09t)xf$^J^_+EMTd=a>H{NA2JL#0F2
zDdB(Lir*Og*17Vy(@IJ=+xA5VBtcB&d$y4byOLUvX6re2rjY;uCy+-y$z`ivFSn;k
z^#Xv;c*TJ4QBu*)iTc=<=wWlEv$aAx)n4pmCfba!7^~0tjSP$Ys*S&u+RoB#i33~T
zQ2gp1^|@_?&iZ=q!0p%ZjY56@%mJ<L1X(4U*B>P!nG##VtSfQpPb+Zgn?VxBo|`iv
zpE5xy{lSJ$0M&jR9nEgM8Lh;#CNbl;`lX*b$mDEXy)_$}Tk082Vbfu*ovHN-PtfR3
ziGg2Xz;b5Mp7G4QyRH`Ly;{*?Gk4W#ZIF-koXhytxLK~@jH{JhTnTFmr%-}geBl+z
z7R%dLAEG(YB{vy>&*W(BGD}I~X5xk~7rbo`dheM|cKk%GyL&QD6_2WP?V<WR&#o?W
z!q!{Zi63vSi%2x^su=^eOyDnL0f?)2j?R6BYx3#Pz|nSrujdlSNyHGjHtclD-EK)9
zJEAWHS=TqdKip$$>L({++3_8uIzPz(M?Da2sx_<+D(C593_|WsG0wCzTfUEI{qkRL
z%*i7a$0D9w{Y~ep;+x&N#RQ@bKm{ej&7K{4YCd!}Kg*e~u#dfc%R4Wm2Vp-lUy^Fb
zTJ!cc+fp7CPMy`n1td?v=P%FJDTbnxA`cgsQ!MX>n$C_iP!>sT*>d-m0ZnIcYb$d=
zK_8@COE}@H)Xxt-T0K~2=_V3B9PR)5y?2RrmMLM+S1mpALIjQuj6Ou8R|IG7d&1pL
zuD_Yc-<4)%GZ^0T1`SWo6wI@q?R*InP@uyMd}d-~yaV<Yea}=SDswR`QE2Mr;iaIq
zyS7FL0Hf$&H+Xo;so7nSaj(C^=m7moR?Htc@xdI{hKgTKx%remYkDRFi*8ru->yGV
zaQpCOfQvQe`u5kQ{d?1nT_3i`wzmCj9-jE&X)ztz*~cy97imxR$`c(T<!qEo%mj(f
zyAzbrO$!ElW9^lhdw)k;CY77IordKyvgj+hx#q~$_C{Co?a)Ekx^+`_sVQRgbwquI
z1?eM+sN*0EG`cy&8c-4-rp9)0Ld&+kLG5aiW&QH0P<RHJjZHt7jrRKF37e~j<`<R}
z#+?SDQUv;K7w9)iP+xCh%U>%5(V5TqS0h!EncKAAJXikKm#RKkTj+Ti+ZyD$wBlEV
zT(3B_0~Z@;uu(bL<YpXk4Oc@=UF#11oUL`V9nhx6ncdvvL$(yo-`Kg~3$I|7vi_d8
z=DwsXG`P3dkOzL6T>X8~yUOe~g^f}>>2}&ul{$rs@9lhZp2?rdt$#+O5f+-y6~hY3
zBf6{;5SeuZ@-`ue-1}zK(WL|{nnjbv<uP*P`A-QQO(wY3{t4xI3rta+f0F9!PUxR<
zObx^Fvm3?dzka8HDtJ+~P4h<-#fMJ(9T~3{5Bf1GiLB$k4${sOc#(YF>+_yEe4<xy
z7}M93^_)H9tGm8J*OW%hmeK-aR}-B^vBC8vcrO~g@|T=QoyoogdrIpvTrGc*5ASta
zb7vRLJiU6_69bCfae$pL#X!Z;;jgN?o7Z!AwF{p<F?tvI7v47CkN#M=twl6{y6oxP
z^zL7;oJr_yQf3yGc=+=<*7KA0fiG179dkD4XWmuD=NhpMS61`2zsag{?UHVN7A%*X
z?~@M_=QT}OQZ`MW<Kf++kPLS&dMt|S!~!q5ezpsLN^mc^o|}E`t!Q#o#zinScoAI1
z?ww;%SX0zC*R5MF^8G9vmD%|Gxc$W9+>5h^k80*u*L&BK^$>Oq$OQBYCp)KyI6(v<
zRa=@{Zgbl}vpEG=3Zhr^%Z5E~PAdM^pT-2;$eQ={&RfB4D1KYFP9+}ma8%j@<Fd7p
z;<IAzb!)4~h}eX-Z_4}|&3#{7p6!$a!HHdz!Z#T+O|`PydZ$X?g62P0nDoFiRi1|e
z9<^bsQm=#{z3RwoZQ*%%nYbRG?(8O4q(o7VMdFeGNpH-dsu{gRl3%FG5MK9Jxc~Q4
zXLjG#$Y|iztF_n~+b%JngtauL$YB!=y5gn8+{<*H(Dx(C*m_LPLoNN*ck<Cc|KBPa
zIXJ)-b?#OcrLJSL4!R@}%-b+rG;#qJ02dU`D0sl@lw+VbPNFdRpgG8hLz$&trkXo6
z0IraFfQGQxLB<QrABKdxEiosMeL?b>g^HNDUydn@S_q*_#+W{J{h5GDo2a(dGwt$z
zpgmQ9w-*T#ED%jc(5s2TZYzB40-Bo3PoEpsXUi4+gglos@~0`E(wMpaJl=Bq-MIGj
z=SgVG+$t5_-P`5F?>QFd5;U;~X@dIxA~%m<cj8JRhjk2EoM!rtXr9@Gk}+r1t(|z~
zZo1}qatjJ&bG6ZZAA%9OE~C}SvEFspyKD06@W|FDO9>25c&x1QUU7(;KHXv>(_V|i
zQVl@$mdOj6_(0Y+@;4-O$`6ZH#|L673JC+L$_a^jvoYjXb92oi<Un|$5wRQ7mYp2~
zk0U#*9oE@5O(-=j^A9;>FO3ma<bFP`%UQlutC&uq;-u`10CITH10VS3!Lm3w<_F8}
zavRb7>Wg);{W!;?6>)WACw7y!nx;Q1j<q0p3Kspt`lC}qw|O(dHhle+(u`A=`O7mf
z+E++B+0wqh2A~{%V{NEuw5v>5L*ew#<^tn`M1F1mpIMVvUGx3yE}ZY@=&jhTFP}TK
zsW*R=2cv?8^G`SHgZL8!)cK-H;b=E#Y-C9_Weu?@Q2^8S+M8pTa&KPV88izkI=b-l
zATcZ8&iU!y$~r6;yQ_J{z$q}oCw_ul97@PJh_l_`@$qcno@(;1P!}%{A)2a@;GyC3
zN(tL(FXABmrS=_wN)p{4qy>bl40@qd%%%=oQPcic?}wdcXhuz1v{ZSJK2;Wl)>Pd3
zyR@ObTunm#e-f`gtNuKL?Y1S&vYunf4Y4>sIl~F0f~9xD$lgxM->ixbIqH{pX0xoy
zjA@=%Q%~3rXeUJZp5L$z55@JRiY29{uy|a3L6AjbMOzv^W{duF%h>DaH-D9HYLFKJ
zY@1*H#@IjkL4>BMzU`CY6g{uw)Y|2ok4tpwRbxHSN~S;!RzgvJCn{Iha;ih3$k%D%
zV*W1fZ6&)Bj7;3=>b8tDRi;kw1-UbeLJXH$?X8sRlm_+lrxM=3?I$m`ZLw+lT7eDR
z8DEZk%syFQx>?tpxWCpuddEJ7-k!c9)vzlWa$8^Cebq(hjX1A1Oz0WpmJUn@ZlXGZ
zRhe;smETN2r0?lbah3jpLriX1<@OaO(S#X$2zRR<ZEAypo@%2)vQD|upFIMMfSgv0
zv6MFd13#;+ydV3qWu0>gJ|Y|6(uVt$gSykyJM9$C5&Cq9m_IbTHop%N)>+s;=dEtS
z72Oltkmd=-^K~7_l(sw;(trZ{;%0v9*5h%yYR(xYOdt}!IP4DITG#2l6<#$jc4cl;
zIxl4PaW65Tmf8fGcKiM!_he!g`$}@=aZ+gl$s1x^Tpjgmr-@j>OrI*cg(lV6*D*vk
zy`!RNt)+KAPa+Z6RD!VXdgtP!BIjGLy`|nYmPq#^Q`7_qAK-M;6x*0)5V{RPGW4^<
ziLNH)Vry)l9|mC2IMeKcF8+|td(eBUr4Mwa`ZLy7VIWQ&o=H&H`edKuwQ_!<(z$Um
zXs3D{{mJHwjaE#YVcVp-p2@SZbDXaqoeNU-tuW-%ybAMuY~k8M(?ka|jNR(NRx4W|
z1YeIy8}7B$aajm(?Yes0dwpE#)KIf8?Cr$*GFyBuIQv9B1Sx#@C|jQPT<OX57h!;Q
z%mXdmsoA(pWdvrgiu7;NQ7?NbNN*H^Z4H7CQ))5pv__%5HCMVehcutK5$^Zbnge1J
z*))C2SERjS3F2Tp7jJ4)y@!NOaQG`Bg#im_FoaE1|DuTSlcL`@+v~`_+O(8ZuSE+&
zNhlxsGM|agW=oS$x9w!!xAf-{O&P4Fi1UNlYbaWx3BuCF0hC_$&gPiQ&6z8WvsM^3
zt5Ls0LNLaq(>A@3J|cv&7Mu4{;C8ZqxIaj@_zH%|@jcx3-!idG*3FkY#DC}mLj1o1
zFzK>=s8n53;`g=uZ}Vaetu^eeHf8D7Q1ca!s_H_+R#CrJ-<mAuMSGkS3I2Hvn*>}_
zBI>nGPr*Bt%eJ;j=EIq4!$#d3+0C0FlIm^%mYv~Mw2QGP1ssL8_HZ9UO($t2z&N7T
zn7U1;tC|o{Zo~-zvCpueF?T@T;_kw#7MHz)iWA>_;~5=M8^T_<+TFvXoB2v21SxW8
z9yGa9;2<zx;$Zkyi0=~;2M|Z-wv?ran#D9BfA$}}yA+BXfdm#Svv1Jl4<}4LX@;~~
zO*bhq=Q`wekRdE}95p)Bkglln#F>hGuI4iTuV+ViorFEQm_RWoex6UZ8Kg!&z78d5
zivGd`bhBGv0m#D6cXyg7VXDh#U8=Fcp~~$?BFi|^XTar(G^#g!Tgd34o1I1BI<Ma!
zN-%e87Nd^aXcFvu;OQJs!;nJd!q8}XiBbKef3u-~eHPFcGS>eGiC-V?Jy<4a{87y<
zkY4aB)wqy{*T^;OOb)=AR*$5M!E)p}9!-JSHo8~U7wDwFZ<cNq^85JX+Qi=6L4}(y
z^$w+z><15AIxEUa>wKF+FxU%+qHwKg(Is)WyU`mDE?$B|xYeKRUpn8r$ocM~A+G5W
z?cn%kbC)pK4foq>95JcKc2~vTQ?-RrW%?39DmBbhp9q4IC~vU*RcB?b(K@}r;34YI
zlu+v!#Y4CKb(rk0Xyum~PLF74-Lb28+Y0BM?2c_Tv*|dw@LLpy^N2<L!cl`~h3vl^
zsz<pJ?F#<Dt9uJqr$(IZaC@57Y<7uTVt+sMkoAe6oN&X*TI25%AF{<m7N=RfOeB$t
zL*$D8(+Lm&lkn4^(dW27Z(_;rUUw$kk0x?=jGGaiRJPeAJy9dWJ@746y+7af_x@0!
zo|Vm#hLV53J%KKf_@Q#%{FTL_H1{YK4aIcyuf8zJ#C;mRxn;X=9oa%TAl#rF@xV&g
z$XuohLH5x#UsrKD2AC@8vc8+XFPR^`%JQ{94MBOQ`JrNe8!<#M#a`K04xG6NRqh0%
zE$ez#VlcapSDdUpehrjJ0Say~X^Z^Et2=!Z$<<Ow<7&rp%*B#YB`!Akp#cxwVzuu5
z{W7gL!>nzyT*1Q@?G>-LoGy#c4;h2dCEpA`^sL5Uwxk5u2?U9yVN8H^!3bycerM3h
zS}X0<?MKgssx|Mz>5Cupe=9XxM_ZHyizJs{w&))BX;rU6wk%;J2n$gob7{Ze$cK3R
z4x%4YsoLzq@FUV<x<QqdgFYXZ3@5Mcw&r%GRX=CKCF$>#Z*JX)u##HlN}2UtzLqFC
zI!-Z3CvG|>;B%BxH*H@ub*nCa(Yp#dz;n<Cmq*fl@Lx^mezGoC+b-Q1_P0W+R-m1k
ziTyH#9+(bVda;`R?V>Nd$?SUqyILLV2%Q@L+%GT2FEhbt^m0^B&@8-0kLG)F(}Q2)
z08mnsBIwT0*1BD%s_c-vww>-M)dQPCRMJyz6vmO>RWRf_apf!8C^;J7{NZw3u_4nf
zR&3_*Ai90M8Qt)W!Dh2t_ZeeX#dF?D^iJA4V$t_+f{K}$bMnXi3W{|vDD+4~_xqk9
z$s#FCKjY%lQ2=#cpQ;tmSc-?gtbf0nN*JCVRerJOxtPSa(0k~RN1kcf8Afd$RzzLh
z=dbzST(*1PEpOjns`=zm#>{K`x(w_w%HFw}Tjp)O7JB&-oa}b*ox8573p&rm=R-9y
zOEZlG95)lhK;XlP^`tba9}{&C&;at94!Mc;Ug6$_C?rLMNa6tvFrCG><Y23c9tgn!
z>NCQ@5S-nWRJJBDCk|?~S)tMmb6G`|q!Tc&_o4qMKDm3(Z-EZ$gpH&N=}j`Qf3RM}
z`XS;`wa2@5Vd*?3VEI!7#Q}33!874lXw%C5eZunw1Xv0Lk-jo6DG`vJuhzSn=;aes
zFReS=P7Jt61#wSer5s3l){%z{(2A<`M=C&0fk2^=^H(SM@jVCBwBMa6<CTPibtPA5
z!T;Auwrc%zZyuu@daV|&l;8L?slF~}R2V&@rKzM(SZM$+xMPmUdryw|DLTOYE;uax
zyw2ccm_(I@u8gzXGXi*b$Ri-i;=f_pTRx?N<PP-l9jm7o(!F~FDxi&)cP?z%<hica
zuiqG7jkGivPx0X>R9_HR$FQK~D>~L0GFb)cCHF_K$y>DV%jz^;`F)4_zE$-OX|7Jn
z`=l`;X~mr;sY2J+dk%HgJQmSBZw5d<L(}r?2o<f}JGhY4Q?WvwCEW*m5DY|pc8Jqy
z(-1I9cWjnM#FY4w>un&ceboyMfo)+v&S9ctaw3tr`&g!vtQCo^>R4M5`M?%t+pQvA
z<K1TE0d<&9DwA{4!Jc8+{Q(X(T02I+68m~?gMRM=fg_5V*39_LWJl&Iz4Q5QvE-i9
zvBe;898Vs{_b7F?qgyAJt2qA1O6_vafhFFXMbNk`dhhlqR@-!G<ChD$L;}mv|DcP@
z<RfqB<a3H@YE_h%Zze4Ml=}n9_w3~stM`&<qnX-MahcoMng(e)^t#6S41;^<=nF7X
z-z$H)2;xTgJ<IBLk^5V6yDs=hW)<XinhJftHP4T8niUpClCLP}UmxB}E-<nQZp*zh
z!j9~R5e1{vMR`RS+g_yN@d{~idNts1OV!u9SDl&qrkxTV>9vYD2fT8N9+?f;7nQ#d
zmR}Tg8Fes=%$2hlBDsAH9DPjxexYAWFe>QW;QM}5?l_h|ZM*FdOx611ev=Kcgc|ul
z%iY$~oay{0gq7ya3IR_W3n=$9n8qoU_EwL&EmyQ_@T-+rXH_^$SlEExzQebRUZ#IY
zY|&n*Wa|UuTnrr~!A1r?Nnc%j$ExzVpKz6*z-LnlqSwfT5fTlz>Nu71!iOvT-bo%v
zAnx3{{&_kfjP6vg&=E)mN{3-Hi`ap*xgx_L9eyf!<$GRo*`?V|1RFn&)g4Ro3cXQM
z&v#po)W`3K3CSs~DnDJ3D0_|e*XBJ+>iKCI78u$;;^7W>ZsGQwWVz0Wc_q!88$kAI
znh0z9+2H&U_qHj?ndsAChODUj?Je1E^kYBG#TQ6N*N2_SNBz?Vw~blyG^&m|Ehw{V
z<6GO)sH;VEc-pV`>GWXX?#1(R`b9in??u;{zfd{fEHy(t#8k7IcFX#|1bz60F}DXI
zZ|9G?kB@Il)V4R4gpe^w1{Wu19D!TekKjO-x2^d#N_B!JWNoZl)nzm6ZHcwAWp2lp
z1L25Nv8#<e<+Uj??Z%_wd^4Zl-dk|};B43J&og3yOXVeT%*+_q;D!`N{X)F1WD4^B
z%r8@Y<+?oQZn^^KW)K&<9NAU@zgG95rZ@la!S2cq1{0s*Il^-*E#O|qqy$Eg@Yv3c
zaZTokj=TJW`0;SnFMe+wlc<0~|9luL=|w|s^P6-Xw1EE9;&lPtv9;P4&3R#wepRl?
z4)$-D582?WzVA1U<W1wqjn9U{ZESkAgCmdJ-`$rridQ9fn;BMJX<nGR+d1@x4@G;K
zQcy<OW_4T3)To0@a-1OK<Dcx8=hxOSBar4bI#*lD=hkZUO66>kb(Y&wKHfT$x(xdE
zrlHL#`gCZX=bEt3jCwmNLASh%!_dm=WU-3PH6QVXOWg%sdosQ|mB~wG&a?{EO8;fQ
zjcevqOi+Y<_nN3b;OwF&`%XTls7^@k{L<s_a;&KHZ^5ThqoxTDn-6o?6gcm;BxqXc
z5^JZu6YA+`MCnnEhl0ng;tVg)B_G}50Jfqq%V(_;UfoAgdz2JEOb}fQ*|2$7(*l|Y
z!^q8n`~-*m7tEH>*Rn0lg<-O~PU$NB98uS|(srDzG0GEz{)#y-TBSRb=?-U^ksy;J
zxo+(L!Y$gjr=o8r>Fn>;Fo*>YY5Y`ah5cn;o2+xt<SlCQD~e}uJNzu7H3+wOu7KX&
zVDkoe73<^!gX6at#-~%~hje>I;wuK+`qGBCVNWQ-yPpd;xJJL%cN@PdMy}PD)oYcp
zvJ055det$UAHG>U{?xqQ;ZGCFu7`qvP~5(`#K4DpmIFSE{MJaAjPg5QQ(agYLA&!(
zVo_eHV@ZWeG6ByRz5>K=z4n*b%tXgGn(-paG>@R2T6P!a4N-&!!$o)l)gx9_GA7?e
zb=pPTPh`b((sUp<t{xquAB*^f^f#Y8?jQZdf6gBMfPD-%)RqxQHDZ1c$a@)7rgt^9
z=(J_x@{bO?s#&?mv>oO6c;@tl2cK3yErVf4T$oXYU1R68M#aN{eZsp4BUW69M|*2W
zS8l_32A?f$C<t71G3NHbQ@B`-%p}y{c=$*9%o6`rA9Mr`ZUlNIgdP~sI=jH;h1_#p
z#IpA^mGvAl;%;Cw##IKO0?cT?zNUXh-b0MEK+^uqZG6|u@rR?7iX}RKd&`3+Ezi>_
zPx#kfA(O}FpTJ%4iqO2JHiV(YIKPVu_e_J7|H^6OitNq;dif4iYLaS*7u(?!`2hJZ
zt=(x>PHRIPL_vb%&{pU`>nYoxe-;K3+$ilrPxBXUTZM#0sJee?%$%s8Qo;(%wCy~d
zGLFjAF$SePj1I+XQQA^BUEqd$X)5#+!6rIxE*zrYVVm)c{bS?*C8&i{o;@`Q@Cf)j
zDr{I9+#1_t*|rr|7))upCmgQmyR13ISym>864qUM(EDaUlQJmVg?4y9xU@YyiUPNP
z%Qf))j@%u}vprp^v$gm2ex?PMQlkCi9L_^0n|HD7=I={<bA1wOs3zM9V{83Fa=f>k
zH!w_$Y|2-hObfH<R0kF+P4(yy-wvH=pIl2LgP6*DACcwg?fHY7kKgJkbfw%K91I@A
zXbaE$CKjK7nMJ<z?BpaNb#%%^Lx%ney@vtTvOo*TK;H@5@h{N?vN%zAa4anXrMM(@
z^}qvzz%{&rj`9?DgU5b%qwa)q*q-j0(u4K@z09K~gk`GAaYASX?lOUe5mp9Dd<Ic;
z4c7G<-1<1z7OrA46Z-s)C7W*lbaFM^y<qw&dGEL>?d`MkY>PCY5_fqJtdfn2j<r-<
z$23>hC@pGgv5m=S>|U=IYM-Pw8r;rRVw|*BIth!%8+N+JR=e5gPPl_rAiLw3cK@-L
z!vT|C3ilh+_m}rr{tQ4f!*{f06`{xaeRRcwQ2Uw3Y)1^=)3vsa)-dEZ7G-?aAiM5o
zBxK_#eaD~|m%b5?fW_}Xlr$_Txj(GW#!fTII4`Uptcz)-x6Mr<Uf#k24hRsNX9}nl
zsGSxhdI%dv{>P}l$VP5v9m)r1B-ia7%HwHmtV(GG$|3#+={gYJHcwgE_fRqg_G&k<
zNP&P7*PD7^_QkS3%XOp><3{Dqrk1^%@n+ogO>T8p+&3Ec%I>^w(qZXUooE->ajRDL
z;~6eKEPOso72x>2(&17CGcYPC2UgPP>+C0$IiMGSaBYosJ6X&1D|S7xj=8R81*y^t
zAqgW?5(rACpwek#m6h6SJQGJg^6EVwW0|VV&K1s;^@nDQC<Au?O8Snb?w`G7$76cV
z9vJsqxpZ<v-Z~H0x)yQ6tw;X;j)uHQqI(?WUR%j<-a@Ojv}KQI^3^rbai^FnmAN~~
zg3+8qp>!*&-CsYq&T#2{H2c|hRWv24U)xdGfTb0i!efK@ldp`nRpe%rfOVi>ZiVoj
z+-UdMS=RHQl^6-oX`HZ4QqsS1;4b@`Aa0uV3zjA#lwX`sHegs#<}-uXx^5aN7x%c|
zv7ax#e)%XYK_$R24bD?+POH1cH53jO`M08bBaO_3^uRZs%o+Z@Ecb*FJp5m7X8!j!
znj1a<aCZDFyZ^r!!~Zkk|L2eYFHH9&$rY-MJ7U_#YwX`Upn#&BnrxZ0`KSK{;5o2}

diff --git a/Templates/BaseGame/game/tools/assetBrowser/art/soundIcon.png b/Templates/BaseGame/game/tools/assetBrowser/art/soundIcon.png
index 9705c33d8ec8c8f79e2c4693daea10071ea6c6a4..0346a4c93269a844f15eaa3998b47f7475a0131f 100644
GIT binary patch
literal 11705
zcmdUU2T+q;x9&?3R1hqvGyxGoklv-M6hVq~DH5bbdMEVq@hK_-N<cses0fHO0RaPq
zBGQ|5=}katAk;w0+3}w<|2gyDIp^HDGk5Ntfg!wEyRE&}vz}+Y&+h4KojS>W5`v&p
z+IQ5AAcz`#q=t^ufj>KegNG2rhzmBk?`QN7!Q<uQ>E!I@$m18}<;de0=<EbRfn)1w
zR<AkbnAFMW=N8nk8T%W2RGCtWsSCXtX8u-*B36k@uJJX6J!@UUDv?jscrLA}lIvz+
zgrrgXkNsNdMH=BNg;HYrnxVwPCB*YxJaG#-ZC+o^rQ+!zdOm)^-~P+~$ct5_SGc3Y
zpi2XD)u9qUzU;>lcjI=st|jc#a$gTNFzI*w>mxR5IOJ{OwA9GR^pUb}dUgc*@&5i?
z*mT4<@laR7r<^5zk=+jL8+)v~kBUzr>TAB(mmTxtD*T6g*v+j+PI{v{LR)wgtU#C~
zmfY;EQqR%byrd(z>rbp0Q|q`-y|jI4oRhq>6jHzp6D6beJO@yuYm-@UtXoWi@E1az
zVO_h?krHWkmyeq!3^^=-fOSo@EOo&i2&C>Uyl&DuBurxzHY!Fo%-r437`ffj<fRu&
zm0GKKv-tsghDa~3xvX}$TI_8dnar>F3~6Jhy>yrUFa3IZoCXTQrB0nF`yPRp59;Ob
zv~(?LyYCuQqme!$G!Q4x>~c?*t9I{~?X-;#XJpj%l-`_+j>?3Q|K<+cRLQs_7~gxp
zw0P~K{dtL3;i{XgY})&mOoFHhTll@!ZOgW|N)Nf*yqYiB+;-Ehk19}lCaQFe6K1XR
zV4CJMZ|;Q)$dhbOMb2x-o!`v}(V_Ku`L?;=H$Mm&#g~|@v1s}Bey>+58n18An{9zx
zm9)F>a?Qwc`4^p0Vxi?R!j3}2k3?Qm^*4TOl8zPq84rtg7e7@8FIU|4#O$9rTysq_
zjCmn@$Z8)ivn~9wSoc7_HN#hg|G|segT1+^ihwD{5s{kpy4K8xB{ZS>%06Su@Qk3>
zP9i50Dx62&8K+#O(J|92w5WPGFnr9VY9e@{a=hshVrn<70$~}kkAGH}gBZpk1tUI3
zIK>rUA{bv;>wovvZ1K_Kt3}F4(tTEjdw;MjhxhnifIm5(Xz?M?M>?pb&9)+GA-8t|
zBX#lV9GTDaU4noo9_u6;xDqbzTi-j*?Wl)Q$`Y^_V-LP(j}G@<D8&tbdrx!|E=ix}
zY})rAtZijQk;Lf76sLY3Hr%lOS?y_M-9HF9z%DxKrHnbg8+7-cyyjmL;+7rY?o9pF
zEAO5Fy~||P&Vz?O$(4OJ`s`iB+21Q(uO6Hn9(kQxVD`Ycv(jH!?9R(Kae5-k7DI>k
zU-;_Od|I+R)AZe?X|`+JvoC07%+dc^)U7PGaoIazdC6B6ZoRbrP_zv9!F(M}lJA|k
ze`_&GI5k@+pHBNdTjyNF9m1~tK><B&v?NYNyKLR+HLg5hU0uO~c)U`O3#Y|(ZeZ@Q
z;qcA(H!SkzYYl8V;}E&ee;U1eTe!uxsvFm3rHMoGHnsI@@=soucvtdeNqsiiipk>l
zh>O+DXZh~un3vR>=7=jK&nmP9M`U}^dFj$$?Bye;^p(!N>s&js`=%aX%6H15@agKS
zsnxx+k4<GUZaSVByT!R2H)J2YFJyZ6;1_FziGqJ*!_T+YgQGf1cO7#3jyG>TFnjqr
zzA#P$stv8WfBg~v54PJPdS`o|C$81xe7YOBG0exCKUw8s6|z$y&ACwKt(#~lWiwWz
zN#t#v^?XPFJN`+2zT9Iw<SDV&T2TnOSP|4}07g@gYGOD+1I8Wd|JL@}t_?lGVYDGk
zK||z4U18?QQny0tl9=-+IlJ8K;|xO?Vy>oowgv}b8Kj6ZufECY@-7mq1XP~xO?(g^
zeX<h%T1We?oQ&1lj4~6=dYWfRY|r=HDI19Y3<_;<iO3Z&a3WZEF?WRCIoG744LXH8
z9nF<etTw8wE0d3D@=#r`Jl=EkF<=Xauv-;%+)f<!_0*`wRr^`A#&yKCWL}TW%|l7+
z=$c9-SLq(B)5*Pf9foDUD|L^o<Jy$)95=k+Lx*y&QA`U=Gt+d9FDQGl@u-n$`Ut8i
zIQ_cj!Lb6Z7>W2Zn8fo!Ip`Qvv9s9s_j0oZG*qT;cYpq%H`>t%__R$Gw?<S!vt{3$
zxz$$2HF@j@Ov!SA<4OLHI2Ad?5e@!Fvc`x<tT~pC_^>*i4t*wxBWZi>#0=R>9Vbo}
zUnBmwvOq6QI8{RshS+Jd8F+KE3_>T!U$y54#5`PQUV9m+cXjus9s5|uX`b-I;AS~}
zjXpAYu$g}|b~C!f%sLkma+{|M7hm+!W=MJ-OJ$|y`1E$!xg92#;iB?v?tc9yBYTcg
zlP4O{anT(b*nlf9W~uJaCHq`SRuNtFjJr^NFP>-2){1~w?Ngx@{NPs+OVxsr{e_1V
z()^H;Kd)@BSPom~^Re62zB~id38FDj>B&e`4Pu-QQ{%X-ZoJJwwaR>2&CC4i_tlJ-
z9UiXoK}zoUW6$xnbBlqy;dZxXS-<e#czv@u)`{ccjl5!(YqAF}w~<Fv?tzQ^ZuIYN
zJ-aUL97^N-uCZ8yNtts~^f;rrb@ds)462hSEPL)*IB;;T-%WN14w=!54itT?EkylS
zN#OIupT@`)2BW*qWj_laSJb>^Dch7$w%7Jrmwxm7<2{pZn%VxZ_m2CIEnA&ke9HVY
z->p|7G=nfXZ%$J&^yGg0_?=YNA<-;TB5FYJ_bnS*cHM8O3hl3TY0C_+`gfk#zr$zc
z&Zl0_6rpI?Z$=yQJD6-}Xd_=E&lH^M7og2^k0Jk}m%(vDvXNIaF${f#w?Bxb=Si`X
zDy8{0%yBZ|Jywuf-12=)Hgk2f0+-i2VXfbloB5Gn)RpPi`i<H3teigjY2oPH3EE%1
zubk#y52bc&urpWRp_cJZx$5G|?CG9=WG^qIX6^lCaJ5{-IC%KAxqOc9Nb4Q73d4f_
z&;YaW#H!gNW(Rj)<N*`MW_`ZaWLhTL{Os4L$a?K+e!IJcf75j4)Ae!a6HIbWXi}f~
zBArqCD`_cf0a3^kc6F?o>q|M6u*@Ua=Oos?LNhrH@vp5^mtW1r(l=?&rkuW0%W^Cd
zSN_z-SxQhchPg=D6JfD6oce`67yWT^uQt_)R?_LiTj`IC!BK&42arZs%M)Gss>?qD
zI6S(ZiqT~o|1JDmT3<X2;b#q9c>nP40|SYKr_1^iV)O#u<MaGiPIWXiS)hxR2W_N;
zy&?T<?g*LIy3;8>qnqz8TKaSHsyAMq`r7D=dFAO|eQ|k5Ui#MQg6=1n{xe=iPJ9mc
z^o5$mT18_Xc0bhdmUQvMu$zysGTM24y1%AIWU(yPZA>*Z{kDmyQ<I#;ENu<J#HLut
zd|#D)?&Q2!e|u8c%!mD_=cL)JP_3x(Beu=6BvKpk;k)DL-c}bk)T7<g5!qjj6_0bC
zGK@A^!3wA4Jw5vMtXrqe!H7qtsnh9=8G*}Tl>V{0j5gOT?pO2uZ_KN1IG+%#d=xq*
zAG1=d<Qqq==M}O!qTujM6Z^c(=6i)hO<FgjZp{*JZ<i!yIK<I$J{+HDq!wL2*ovl=
zBbc}#;@U+nC#F=^OMav0agOHw{u+bI`J0W0_DuSmI(0=8-RlUpAUe-j#)LsRIl}ZK
z3(4_~KF+77N~{N$3Ref=<#r@?-7uZT1#y}O_fp&P`j`>HMM3Gvm+$EWPTzNlea{NN
z(WRT=u(Gl9%a{LYoQaTlG0CSx@B1iA^_`k;e`S(qy}HGZSW5Z?tKInKZ~N)r=W6%f
zW<<D&?3pf2O>M0I_{qHY@%Fc;DIanaZ9nzDQ*3m{=X&UKJzMpNP-0?zJM-;wgYHg1
zIa`=&=E=Cok)JGfl2^L5*{Xu#?=g6lbC0Nwx!!y372d^_WV~g1Ui=;nzkSd+QBrn2
zB~I@EBW^UI@Xn3Ss0GTrrp9K#t&`O5h|4@iNQtJ=FRU)Dgid(x9YGU+LvvAT9GP9a
z1)BTeNoRFmq?{S7Eo=I;ysW8+k_|kQYknwmnmg)uuIaay_0+{jn9sK|_*>rH>J4w#
zdn~v!g|cZLXb+ai@#hX^^}G{}eDmDUY)1}PV2)imBh11whNZSiSY^IuT=`d*)OCZ4
z+`{>GHE$~nc?1u1%Kt`u{nBt^oX(@cFY{-K|74_{oYq|Wj4^#Y%vRF9U%jw1?f04R
zYdiWo1ev4U9moEuFd8*h?bU*7ESMVJ^QVL!dP&rs7?|U`CH^_$%)Nf+Cux0qc7wbJ
zl}xw$6cwJTF$N4SZXn~K@J!)AMLxK_-ylrz^77e{@4XYx4sP2Wgwg)Rs(0D)L+o;X
z`~iJa`qYb-3qM>xZ>a=G_OnTz?W4IGQ~j3Zj(^{$tIA^6Br8j)JcS?iCY;y!)UowV
z2Wh;Qb9T1uqsY#6X||miw%&YpuU68@bn14dW$W=N*0aI>bUDv$^%Os{F~F$kW{a&E
z<u13m&M!S$D19KYaBo-QzVojr+tL?w_ORhtKZ3m8w-OmfGULuZ{Vff_atXr4+17*W
zil;fHAc*R*^X=RBv~S=3cl84_Pe#})<vUGkoXs#RS5qOTfYaV>_fW!5xtk3?-KS;9
zDf;m#x;+Q><HKcbZ*LZB2BvUfvrE<){{CL)X&aeO%gG67Tol}j(0-@!g1(g)h`@U9
zGi}NW=}J`dLmD!>CQAGcz6G~t&SQQ*;g)*(yz9r=<z`0f))8f;P)zKm@V;+EeE1Dd
z@rEm>dnNSbp2<DUPS0%#%98)C^IkVpU#WQD*fVal=nX;(`cZib{K<~4OQyWKFpJ{-
z6<f3Z^K;H~p9?=GVY?NCeW&IMO<W574M^W?Z60X*q85+O-M>Yxef;IU+id4kpZ@ri
zXvd>*Byo}adEFrKF0VP;3r>cQx1t^$HIio#Rhkc7`n6BCK;&4*uou)(58hf-6=Ll>
zT{59M_>7MGQNbzOJ>*WX6$3XF&3HqzzZG&Xvh$MdZ|!sbeXm2MF^{P?!!@UqXy`nn
z>SXe&hE?>rBN_cGLTNZTsqHm7Y!E>R1GpzS(|LEFru~CY2Nl<0D^R6$c6YVZp}UYH
z6tnua+Y>xF;dRHt7lIhhQGThQHyNzpA-$iro(BEG2|7C76M@ZH6ot#?r*Yr!wx_$h
zqlX`K+sE;tpQ8g0!rAW;kCwLHJ@Y80ix9+>sI7j}1jyP+=YVv0_~PtQGvjF<`DaNV
zEh^p2O>;MPmIp9T95~w9%c31lS!f0Pn9MrdxtCo0wF6mbF{gy&$tCfa=d6`ID5LEe
z@sF>+FMUV#^cG=rhPk$RnlPyvPXk#CUcLKAXrG3lNU$$j2;u>Ms37P#1gU{fK!g7m
zU;S^I|8u7Q(d_>;|L30mSI_?YeS%T{oZ^3E9tr)sGt{8_)c=(a{_7q6A1wRdIbS~L
z{9VXg3uD>y%}?s?HtI|IE{n#i*+)A?C4xqL+VS+!oV$n1yD@?nJxP;O55=xq(ce(w
zy03d0YS6eR^t?-VXuEGRhp^UUg_fPxGh|_7jA=h$rhaR}H~(w%V@lCFW{rE#NHoQW
z&tmdt`)2ILpvp?un>Qh7=|Q<!dmKJsV<NS)=|~PYvk@oU)%(GOWtsWOG}B|FS6lKo
z6jmHv;bQbLT7oG$g3o!&Cj$~c7+SS=EQT`$M>E#>{sjVTCgXmF^FoOV8fBpJ6_wMB
z?&|g%aFH=$X@7KpIz>pICz+LJnw7sI*}gO~<kKh<S4FPI`r;3wyF(B01B3*aO2=CP
zN|Y|GUaU3g(5=Y~>D<O2G_Hr@Ha)5b)>$-`5k~}Om6L;?hQ7Rsd(k@2(wuG_#m6Ql
z<`fhn$0m@aYSEo-Zgqj37V^rJCDV6G1qH$dxhF80>766}D33gA(fXkXGXLr4SYmma
zhrme6A}*FW1<7|kJ!BNi#z;#AWuVgnl$o)@3#!D0rU^7UX?Zz7C#Su3yUK(mEj_JA
zOr;tbT=WJ;+;dimsC(E4+y~FGC~)x3O{Q#iW@DE!D5n{JA|i!%0F^&sW1|}(-ZhZ2
z`izo>8K~woGtzu7b`i<!v9yS*&^4$MASvtQ@ER96J%8V}F?DmSsQNKIuxuCG=4K>>
z;TqQoYuPo+`UoST^8z@cPL9!-agi<}x4&>?f{F)<EdNO$2hNlreel0j*J~_`GCKCD
zXrawZ)2f^1;4@cT3tK|#1}%sZ=NqV~dTu$c1p6b(0`CV{4`_g=Y{I<_f@YY3!Hu7U
zUY9?g*lu)2se+rxTT@~rP*Fqjj&vljee>m%!3J&~XlBKo^p6KGC}s`k?I@$Xj<HcD
zw9bLup^1ouA`7bU9Dg22{KNL?KWrWT*d~YL|IA!GwdnchLGz#8SYQ5!?aM#5riU6*
zoAk$_ufgf{QT51?Leny7#bgeKf&396i|Mi6@}YG%EH_-5%ZdjqU(HBB)mr8xr3GA3
z4e`1XvDJ?GVi~6tzNat`3xAb8-_6OzEPVDjB#(iApd;zSx9cTFdL}u1gS_B^``D>A
zlY%rIbkaJCXd<+r1e@$R?0JO*Na2M8^O`|P+nXD9;iOIdjVVhVL^V<q^V+I2Rxnw|
z!aB7*52n;zQXiZ=w0@g`jvCVcozl@Top1TO(g!<i#5Gl){21@?raM?@!Dn&FNpi>~
zS9z$zR=%szP<4JQcsM{EWRHAQ_jJSb@<;Pdw2ESK0#;<9rQg~KuHbA?VZ=h_vW(MI
zX4sw#^+McO@DcQ#%n#jllj$`_lub)rjD#Tm?_ex?*nOc_r8bQjJKZ)%aC;MXSS3rI
zPIHmjo|)?I>eh!Bk85Y!=oK0Dq=?libKVy^DMby^Hcw&`ap)neyEL`l4C1v*w+iV}
zafpGL3nllv$buh9t_0tSi1KA-&H2zhKjMCRT{kxsL~sC3JQ|IV>Wq~_2hCd+i}k==
zKH<#-M10F9LjzTvWmg1KIt8Eq!guHgFeQixQ9}nO>eaxYFw9aO2Rg)FRIa2K?j6oA
zHQ8fD-tX2_mh-f}TV$qJuiEA%uPdk#e&nYd-PcBa1&XX1e*tcx*d-^4UT$f-oY`|>
z7-u)OK5S4I_x_qBm|#6Uww{boq{k>dm@I7or!tTNr+Txi!!=>k(W_dWp5yB4Jh+PW
zQ>?I*kt-Ja(DxB8&+g>zD|e*TIy$Nva29wm-1eO0CW3!u$VcVtjV!B926UZ#)`s6v
zNFHfgf%?;sb$V8N&qhUPAVM*E_F6(_$<pp{RI?@oMRWo8*Hrvy7uZk1ZBF@k2#b6e
zb*mj&BrAHV2ztpzfKG-qdj%)gB?eHFH&L()G!bwo=VD}5M4%$`h6wy&ak>s#sdRip
zziQy)h!KlMrV6Z6tUlDe@eI^Z?+LQ4r^l@-Imfjegj=^s!Hq5dk`Y%5A`unu;>E^8
zf_6fc3&vwqI4Eff^1M8*q{l>RU|`*E%=p}mL$XSd(-r0o(L8IRoS}~k^<<o3JUunV
zHWApG7bSr^9>6mDOmKg&DR5HaGEky**>$;a(Fw_CrFfKfv|?)GzEML1vf(`2fnrEg
z-?d(t=i)#w_tNI(wb+qG$?^3Mr0&%{Btx8z!g@YqOty78)(Jo6CmX=*tF&3E25<od
zW2A{#YT2?)GN`v{9~%zmnzCqzk?~DRp<dS~jRc2u9N+J2qpfv9KBb}4^gUo%og3j|
zC31VACgRjkaR&ejZ0M-s3LHCRb{PH8sb>9)<?aj3?5-Z&Jev}|oe<N4A-|gS2@E=Q
zYKtcZQwM5EgQ@KdmM}J<+y#f#9}-Q8>~V+RY2IE-^vFXgR=w`$X51$1I%O8ETZV!i
zngKW06Q_8xlr6d&`@B~wTrN1(c=EnAL;Y4#D;RB?`{uUC9Pi^^j8w8LJpeg-J?FiA
z-@c<*&llWC{nzvaZq@@u?3v9_e*u_E5DJvL=<Mu?+HgunoIpV=`9q(aFBWwLC|cNL
zbVqYY1=UrilWc#LQvtt@>Eogh#RF}a1$-!>p<!C%Gh(pUldHr5jul_Es>x64Oj`~x
z64LX~&o(Q{9SGW{Qs<tkdu?R+Yk5UKnD|Z+TqgYC!|F7v*hyUj3|{GAR?!CIF3*{B
z?fI8C6@KGI!mzAfT-;;7ym2~`Xk^@Ew%Zz4j<x7Q53T~#dxuIzln+|EG=+wJ*K!e_
z=eyc+D_}nX=MyHUd^Z8q8E@CpbTT1@d$DEC8dRaf=$kmE7@F+9bm-%VtFwX3K&FdR
zwUkUB{8dJ6ayL;ayzY&DP4fIIv8%WHgT%YW2A!NlO3^LpcJdEXOzzO>=eX}j3uQb`
zTQ=Je7F*ow&XJ?~fvxW(krxMkC7QTWiu~ZG^XcTrN+;yIMtaQ#KAIW}B?I`>7lk?&
z{Kkp^rsXLrCzqu>1`Z5huW-rDeUp}%se?A@@Q!#{+Z5UmnDHTSdsb{nXW_eweI{~f
zm3g~)dzVowTUSq}EHvygKn`_}8f($Kp<rLhL6<>EPBus#Y8WNvh@=>mm>L(=;#aLo
zOs9`z-ANb6_rk@<`?2O|w0ydOic;IR37(;qBh}hu9gUTWm2~6Bn#!i-m#uk8vc9t{
z8e2t|G4HQU9dV2Prum83s4;gP52`53Os<II<m7TxdWVRo@EEJOiCS6rzB7=QSxftO
zuAk_ibw|TLDvB_K#aK9gtuxPJ`e)ChTUvVn^-%%W_dOqUYE>;tP8M2(iYkdwc}ZMp
zAocFwpT5ymABN|h-;&?<ofH=7(fcKW$}tk`cDlj<{>QGt$(uiSL6|{H%~OV|u-czp
zel@Q!nCP9O=)q6O)HB*HLpln^abNP@<eMt{`D_K9fWG>f$?laQypn9Nfp%gSO@$V~
zedx-p=9_k2V55S(rq<T>%c>$$F~lZLu3bsac+hfxKG$7CrLb<6t5_uMqEDgOOZ`)%
zhq6_O@*2d;#+fixOv#-hv%7f%I#p81ni!X;Gr**8Z|df-9HQ<-<bF-0fg#_J%T<6@
zMNZ28QlKzKZUdlp^gZG!aJ3p8oec5CJl!`DOffDnGcGVS#zm?9F%f5nySs{&j8vAD
zhrDdu3^Rb9C+Xyv6eOEmPd1^2QX+kYXK*NpvDISwhAy1geHUulXN>&S-AZi^Yzoe&
z#I~G(8iJ(R6Us5uovU#avMkB2zgQGGq;s{x<!W+b6%{W8^*BO&?H$86<AYn-;<V1y
ztoxudzB&Fmg(B@Cu~EI`((ITa*b#%RJiEcp*qP$nQ4sX?_}Wh%h(Z9ZkJ)?y<jeY|
z4F!C`>1KqK+LD#JfKhP<NWVUb$oJRmK7sGN;`QWQ^G80NQ$EHTr+JQOds+UvC>^bJ
z9b8u96{v$b=m5*^!|&8@r@1Ngo@D#z6~&huQAO4c#RFY))&lEhR~En-w*oU}A0;(q
z+r-BQ-`HS)L~mZRqMj)OEM5wwxd<O~u3$fh4#hr_?ywcV1GwrV>9RI(0AB?4Jt4^f
z4=0aY<erJt0`3S_hfoUlJ-b;Gp$0)2QVT|c11P6Or)gTX1!WprCH*H&595z05yhxQ
zIh>cMo<W7Asv=51L@2rAC=+_&8#>VoqG4~3c|dW)%9a-R+c-a|-&sydYBJoH`d$$E
zT;$Z2cR;{?c|}cD(-o?Qs|U)Zv<;2}g{C0uKPV6BmT!?fX*l5-^Ye}MS<nvs1vUY2
zXuTR!g91Z?Y>9Wh5UT*Ok>`kBYjj*yr*|CkriQ%22MZRuD*rGJl>YS!7k}O=#U6Pg
ziKixnesoN^>lGU)${BS&`Kb-}E~fPDj^-1F1gf?-N!`L-{sK4>`B%39!(RLmMK{F`
zt*>1=NwKe<#&C1gxjKg{a4UaJrWA32pt`@yl(YNfW3(`}Hq-6p6%QEV0Cau^Sv0g;
zB+U_*q@!_2yxD?ZzA4UCKg#uKNQXTx*k#B?=jupM&1Yt(9HZjy03Y|d^wG3s&nIMl
z-v}<QOOE83Yw3#g7uW&9FYJ!#s}Kp=va$%k5`fF67SwFTS#z(Qw@6)G9L8021>}Le
z5ZOFtQjp}cI_9^yq_F%Y53o2R-5K_Vrde?<%)FaB))5X@jZxMjgCZt%-6{mX6T1{d
za=D`M3PG~oYqC)Vx6AAyMj}<rf$NJ4c7LCeu;4IMurN`hf{a02@U{0AH8$>k=0>WI
z{f;3<yLqgGLdDZsO#Kv`w;b`aw>-H>x^fTfv1Q(SY5{4Ha1;#^awnethQbEi-c@ej
zbGmIe2QSUx&k%Mq={Ya=bWLVGp*eb@+FPW^$=<F?nU$%$3XvLDH0g%D^g-3@3=eR6
znoUINE-Jegi`<#M#0d)6VwHi}_V&@LV4`jXJ1CO*CLQNO_}kkp-k>@FH3|wOn>kev
zoI}mCGCmodRBRh-(XR|(V$9-&W`yHf=3lhTJKQp8q05#t-11DYfd_f>8y9H?w-P~V
zF<7f`;P<S2(7WE87K&^1@vy0Xtq*sZyPbiV@*bA0-2T;UX;XsDRrRBegd*=Qy_IVt
z<9D<x5zO0g?&)?wI#Vnw-na~vv<LZNTdYZ|5rL`nh?H_achQA@2UQL`Y4(Mgk0~kF
zIq)N5HV*DfKi*$~X38>!m25`a=aW%#z2Y_NgRVn<3dR5j=xBOharmx>dch_3vBFDx
zIHNb+hw52G=9p|sJ%Ph1;O9mHVo9hjxblt1k|BkvV0+@MVbZLDHiWf}TO`74QRvQ$
z*@eaGX*Uuwwj4kMF*>@i(0yT{<H<e=tS%H(U7fy*nqF+~FiUj!<Sf2vtz?_5gFl$s
zCCtr-SlC$JshNCp&<;?dXRjwbQz-(~+G|!8@}qo{va;s9_g?%V*lK&Os<LV4t*Yds
zstdTSXe)H7be2aID!52?3p>KiSXNP<4#werkGjYrE|I~)9TKd8dn-dmD%HLs5nEfR
z33NqL&SP|!pJM)q>$$8$?u1rK6T;qCj>4=W!oJKgQP`dG32`vaDKF2*HAn*CA(}Ip
zIpG*i{sF|*>_agQD@BV3(;eo$a>7c~5U@1c3yEgY=>KRQ5z&{6{DEc0xj2d>aMc5L
zVeb2b<31pPw&I(@yYcjFj8E8@w7^e&eLxf6B`&Uo)w~j1eFV{zOBq)68vysI=qNZG
zkh6kSE0AE4sv~+KpKg?<z%;Yvu=t3IvR8RxX4`n=Q0<h$opvIS|D>0V4Fmf=?gC_N
zm4VOT>Jmt#emC6>4B2YDCTPz`CLy!73wd$XVp4?=wh1aio&Q;|8^0nC?hj=A_6~hC
zXsAf4j(7Xz5vQ=!zc1~VSC*p0>ce04)&;-HE2(lL{LwwEfeOLIhc=#<K5PeH?}Zh?
z19Fjlff;~|xhza_wE+C7tU_$NI4Z+JiIRZowgaL2N5s4V`>Uw)eVHdV((fUY$XDUA
zfTGkF2iFj}5_37+PP3)T(V~9@Xcbt2>#DBYPuM<a4*rzvv$E^rRD=5RraNoLNDauh
z#XS$3TI=o+1K7eU{CW_&6z&ali~(GHbLX$s*o*0-ic0z+pI&j?-FB|B@>FK|ski}r
zDJEu9ya<cfzE*#@=A2nKRrwj5XHt$oIx25zXfd2i71l`{=Kxd_x#9PwyCor$78IMc
zwY7zzmEgMYLm|pAm9SbT39yy}E29!y&ijMmze$}HD8gRn5?cb2dE;tlTyWx?Ru*10
zY)c_43@@A&MierzaVP#>j|TehY;=^sd`<fH%HB=VQV9?@zvThxV(^u6mR(gn>>`(o
zWi8YbOM1g2jJEBon1P~g=SXgBK#l-j>0>X}edw|=ZPEG7T8?2`3g~V!(KWbrbZn|S
zcEmM^u;Z_CbU4KAPRhgsMf*$=+><Q8iiLS|kluJ(@wUlvIin&INmj=4Iy4GI4{mwM
z0JkcZ8G&ucq9|@%0$+peO#8U<@1+8`tKjnwmPH@No%6=s;jXT7y|CiNzWEgVf@kKU
zZ_55LDk!fT7_+_5v>2VZYsk0jBBPNAVgU33m4ZqW1;mE8?Yc`<0shm_(HIPed%hGX
zLG&wf{n|YY0Kx~L7|z9B3<zpYX3got;B<=Rd0@H3H-kU484h4F7Cb+SJw^KMs<aIl
z4g4EeY;`wgnXGnilyDPjNJG(rD?s_v0o1-rM?(dq=F3JkO0&p8{4}8Jk3qi;NUlC4
z6deWN^Lm#p4`?i%lw>^)faEVmI%**K#Q*VCFi3;{Fy!Wcn$79YR~iP?|7l3uf1K@G
zPm}H2VL(YT8nqiNnCap*=N*&+;6U*Ae6u)3#}t$Of|f$X+%lSNXSTdmG4u0`bhi<d
zN5UC<wzeRkr${&d&=#(*G=TiTm%q@_Bm`p$Jw4#=_KG3&$_yYD<X4fANG`^;-S~2J
zMY?&39L~jGs)k<c0vDyrmhs(oX0OKv)D7IP(bZ7WZ;iU}y4Mx!G_j|^P_ghw;+qd(
zO!D$d9R<m|p~M~2@S}xt!pio=pbE6-yPJUJv~x4jO<BJIFq4LfZu-K$3zTVFpi+-~
z1VOfr*YgQoD_h>3SB<tWLCFMNFCmz65K1hwnAEoj6FTX6g3{f*sMXpOdN|a%#?9#%
z9-tsKVC*~y0?AXQZ7GCB;}4-QWJ(AgomA}@?g=-O3n;5b?_*j?vXq>^A;}ttOBZkr
z+VPPZsV<thpQ>Lobifa3s-A{&0I`WrptqPD>x>;jt#NW${pm{&fV{8^6T^^rih^Y{
zwid5OVijqxh51s8v&NU9LsE%T`}HH!lqj6}>*vI}V+eVDx`s>>L+eTETBNv?tU14x
zt{37UG9z@|;{VOQ{lC00AVfaD3LSWpalPct=!m_l2(rP2<AA0{o`dA~d#99QDNWK+
zJ#tK)4I_9VBZ_Y!+gDwtjqL1Vgi@U5v%W8?E~io&kMUW%v7m<$*$o2%CX)>+{+l~Q
znd~lm5P@Hc5C^kSMaJUR$ev_U7U@?DQ5H7OM;Ue^bJt*Q6*PgZHz^~*3X$as@%xgH
zmjx^J-@YuTu_4qF?XknPtG$P!s!h%?x7Ow`keFx%nXfwB+Jwqg$#w&$&~ZfQQ_3Va
zk)b~#vQijDx2>3`9Un}|(N67#JcmTDOF`BhdWVIuf~-NUb6MZDIAPzr$%VHWLA3L8
zv^b9b%^y_C&mj+RL#{W|U3SS8HOal%)CGAxB(6`B2MpL(6vRpv>N@!dSQ4QO!$mB1
zm1yrKABEG+0#|)~%h8sAI-W5YeKZ~}y>&#Ww|*VBY!F7kIse_0KxFhh+WG+i<1h6F
z=jMhQQil1%fuM16>-Oghydcw4#Hs5zXaw+U<UB&?67dq##YX2TO6U47RV&5(b5RI9
zT68tnmrKRI@d*=k<lXAVjFHp8c|5cbz$?Gwwb&O8M+Cg~Y5rjffZbxuXkP8MDWKC&
zWTu|$Xo-Zs09*8u^s>vNyw(wI%cs0<JLAQl2kCQ0A|2==8J1dQTekOvNs=}VOT6kC
zfz$%f(`YGGnXkgr=l&5gqSUQ(k<iSonn$hE*s`s$!pEn9ubSx(kcZ#vvwUi>zJgZe
zR7e<oV<ga%I}lm)A}%PsM0NSp-Uqq#Dh#o+ZrOtVG-Mq$5Ltyz?d9Y8JuRoBe_f3<
z*z08>iy8Q;I>Wnt1G4^2e=rcrFP9G|FFmv`MO!d<Q8(m-zebErFY!fWZf{B*9DyEx
zaaT0K07FC`1oh0pzY3@49fyDbONiY5yrmyJ5R^qO*~hbqj_2a*Trcy2Fw?kYd$wx3
zuFBi2cTQ~82`(}-{=6Pv6TxXkCt6;038xT8f3zQzK-M5lU0lZgtp^GiWNis_FSs56
ztst=fyEkJ0l38HvzdZXN&Gi4#i%k$m|5qFoiP$7log1{3zMcA08LSCuYv`*N-?IJd
F-vE8X7RUeq

literal 10582
zcmeHtXH=8Vw{B=QP=1IMsS1jU6zN5p3et=87MgSjD1<6a5D-G|ReBA*lTcJdqzNG;
z2pA9%A%sq7q2#{&Kb%i@t#j`==gYn8pOslN@0*#)%$}J&`+4?`(bG}AdWG!@2n4#S
zuBNOH0#O1*O3<YXKt}YRBmvn4J55z(ARh-ItV1SoK<V-;H8XDzh?em@QGjytSb>)p
zq3YTy7Z)zD(eU1&N_z4Tc*W^rXbOGi34u6xK!HaP=$V&;E!4sOmY)mM`If4>ww}F^
z!$lD27D!$BiJ||@I_^!DrH?Indn~VW-giG_-rZLUIsKD8C5gHd7G~U1XjGZmR{Wd(
zi!nSMYdp!^>iono)+j{ZjV4&5)rf(DH}lp4vs%+XP3n@lqmG*g`Puo$TI5H1N_V_{
zoqV07Hm7#C=*P4i_eYkxmh(0b-U!Tihdu{^ex=zpTs|KL@Sy<GB_JsQ>0iS52gt+D
zAE<$J>%8!vSNT7z_V1oRKLDxzS0wzu7u~;m0=8!ukp7d+`VYt*IOqTEZT=sN@Zav~
zqg!JmZ~|dQj(xdJJ+%&-RPK)wfN6YW0Nr?`$yeeSZ9%Y9sP#U^{CNfcx?vbUTI7}c
zObB+n-S(S{NSglhMyUC=*7HU!^986z$>6)M`j_MR7TI*Z`rP4qVdDNAy!}3*zeL0A
z$5-HB7v8Gz@`on(YAqjW`n0tx_e;JpK4{kPV#S)A^kSzvg9XwjyirNMs^NirqO}!{
z<*oOw8|K_UR|mT#-~WyuYq&yHUdLnKob2vo>A;P0yC@(#7pzF3se|u)qwW!HoGp8=
zB*1x@|MpV=Z94Za3Kg7H7r)pPs!KUF>YZbG+BjOLNtuqgqxV34HAV%h`^r!;mknG0
zbWvj`g#ttoHtp7gguaBp=gcg@<73SzJQnl)0vJ43*r;sjr+XFuJ?4r0^$$q`d4QIs
z1erBzB6_M-3Tm9w(5_&^vF?$LaigWHi0ZB<(Z#l>gdeYQB6IcI;sZ1wn?_r<UvlOI
z;_4u_mZasgTReNzYYrcV*JEo9=U1BpY$?KcL5IOY^oDrkRrpeyP_6cc`JdZVAPx$p
zIZJCy4KkzN+Us#B2&4+ydJ|MuZd6cX`913V5Ld*G8A&X=FDvG}ckvW2?M^P-R}Pou
z$VEYA%kYN!XnbjSRazc1tSidM3T|Z8S1pUw)V|i9@%X2!S4YeDB?Bb-A^g)@Za~Q<
zv4nC|PVQj@y-89R7GIn$Pd04iv5qe$<EMHXRbua#sL58L7)y2z1{_0{9YbJ6Xn6|A
z9yRnsy`j@_Y^c+o5}>8S%$$8XeBPX{n$44K#A^r_uHi$=pL_KPcs@$SCTzX)eRq%8
zpImZ<)wsLgx~`pupU52A8QWy(%L?p~Uq(F!y@AG$C$^O>tyyJ@Ed~NZk-z8UYMRB;
zb?|jnw{a2@cM|)@m-;azJ+u6_09e3niZGB;+qvX8LaXq{^2|Bo$iV$7;hWYC%L=LL
z1SI1rX+yaeE8R^}Rw<b?(Fgydd4me%1w+}$*bmwh6Pu+s$%?6cvh{8U;TtE`>qn-h
zCS3FNSgKxBZ^Ax*hQ>A}6)>$SFZCCZ=9X3l2LX?y%l-D(j4ZRmPjUmViv*W$hRr<Y
zM#~%Uc6~da1m?^-AfjrP{;pl%GAbDM`^p<t#uwdtD_me~w`zCeC1FWm-IDGU^p6M3
zT{k#5BAi9QHlE5VW^<ts5lAAs%GL@BEXS+2^^=n{A&8e^q{Ns{Do5=)Wd?z74!BOW
z$xrU0U95tDIyzv-iqX?oUiX*1PnOgBi-i-3-{u-4Shzu#!VIR^GRG#@{ip|iID^7y
z`eZ>e6Mu<Wh|^uvKkR~I{I$OMctNaeyY=X`_8d+R%nyzoHshlj$xgv2p6r&-_%z^q
z;kpQCjOrv)VkPhO$&v;2s}<MX)v}I7ei2vQJsXV+I`*HJ^p)|zwN;{wBw;GaM9+Ee
z;Fzqy>n}LpN9`SslycGP3L-?F+%tf*5`sdjBs)%A{Q_D)FT9As@R4K2tmRUT1yWJU
z{6!1)mOw+<mtr&ASMl3hY1i(tzS05-Q1<f)?>+vY(S+KuK_b;m(k54ULbGR@vQqG=
zx94M~>Zb81cH+?6ynIyB25kcVB4b40j{Vfjj}Hb@23LZttL9A1OJG3`)xI582m8K#
z)jZQii?3XoDTPnT_Oi9ApBYK0KS@1`bM<O(b*?I8J0dkhjm_bjRO#k~{oV}-PV`TP
zp?fnNFA<`A^=k>@o^&-in++u#QNlCeeKLpna4hB?)d{PSw-#cI0D<3xmSz1QcK&K*
zMIdUPa6hOwX&&SiapXvd+7o`+O~S5h(~!NsyZamLbMJK13mm!`UK*2{8Y}wJuv)S-
zO#Cz<E9i~zCRwUp7s1JSX_4h73>w_tb<Onm=m#U3)R({8-JNugyZf88@Tc(1q2_>z
zMb^T-AoA&F)-X#>jm9i?l+*ru3M<}Xd(^y<kjYqeGxR0c!piR~rRDPyM%!n7)hswe
z0gSpIEzotTqR^|aoZZbF)4VDWT;!<o9jIn#>$eJPtqt^8^37j=utxC8TNK2;6tsYP
z4wrYWpWLkiw44OfFfr(uov4I%L45qv;@0&w1g4!-!VAKuojl){H?sA1e!n~1?Az0>
zOg8V;c&Js^l?4}G7M^Ou>uS30Ei4}It&H3d{`TOb5PoLIfplE$$TWsF60-nXtvgSb
z>e6#eXqOCJaeYHg2k$YTEvL`Gj2*wU)-x=pjU6H?`=?0pse+iT?n69kPqa69BxeL*
zd+e<bTVMA7rI|kJ{mI|1OW*E}HE}g}cqQqi{us@uH!!qLT1KSrw(W-E<vm%?%Ow51
z*zjqtS)58>$kI*PrrpraTFcfn(0yuPA6Cs4d}5zE5%z?GALmHnOPGeQEK}LDlI)kf
zPMZQsG&)>=r!1zZNMTy=MH!>!E?(81bzl=r>6oE_^%lg-LA{pCeYysbO6N;W@oH#A
zU0EA<HlY-mm-p<udG}}$_+i`1n%sw%c`zxabV4Ij1$@SJx!;_}SoUWi0s>dCn!XQz
z!D^juUFm`9?}<F73u<dpZx^<B>54J<2c$XIqc;At-VAB5`Jl?S&!Gso9U}yDwXI!V
z_p~B|Nj}4lfLRWkLsF&(R{OxQdG>6xU7@z@Q9bSMwXrO}oY8wmqoknGD{~ywAglGN
zo4ej$$c+e<r3;IXtaU#&xT+49(<sgt)EapdgkYM~6==C@``1*5rM`JS97%$=Jl<Q%
z!3G46BxYa;-Wb6ykqp*-1(_x>xgt}3ht+Y@_`b4Gi#B6V!d!DlJ#Esx46WyWLKadL
z-t~h}bKUP+E>8aXx~k<EPFSTBgVFtbeewK^;YWYOYO33jlWS17W~7=^0IU_mn6+m+
z-|EqOKJ2;I(0coYNO_~R{A}!L(d+ei>OIRlrJwAz45~`6XUEA!71_bT@z*kqJG*52
z3~Cew_)Q{lGVlRJQ;UxEO@(Tq)Cw-AMN7{{k7`IRx>qFcJ$_;Q+;Et@nTuNZ5yz(=
zlX*e+m<}EkrLE9c&5wNcFn^Ab9MIBlAWm3+ml`zC^pD=g&)Jq2EG+4{J@dHKh``V>
zZ<y~=ebCWUqvo@aj9%G<ua3~+Zz4De8EH5^L&7+^?tT^4Iz!l?PhdG9w49vOBkd(F
zJR21mwsXwUwD<H*>1G`FR3cyWWI<dmqF#cxyQD+Epx*TbayIBs$Qxou-Rhg$_4O9D
zqeb$NS;tl?oeDGwPki4akF7Wkf7wh<P91cv9j<6+PA4Q%rhBs;jXhPO222Kq%8C5p
zsj=0bi#)f3-^(ls%Zx5fG1gWLJMNeq+KU$T-jpt#9XL*d^=GW7DCis4vsasBDcs3Z
zt7yUhVqAS6c{%JZGl*U*aW!heLq0DeVC9+_)BuuOCnAHqo2OAtI*Mi*`m>qxQxV+r
zB$Jw7dwz4_SBJvfe3jGgtI<>@-}X6c^OA>}1VcA3K1zx$jl9Z{B4kCBxV@L`FW3xD
zVclIGeBRcngQ|k)+u~R{%Wj-IccgfOV``Nu5pN+gbEK*NbVBNDf}8fT5OAwMVxf;R
zns+f3)QtLS#qUc!0404I@UcB;mYD`>THXw9={1nL=97ykm~ursH2;usBIw4#wKh){
z@o5SnCt=^$17(FDhpNlwy<cg5raF1}S*M$@Vl|gWtz@gFMoJl^--d&)S5A7)=$NR^
zN`g&LmFd?G9<+1TKkyuXp4b_gvcXC~=O(OSmH0noE>Gsh;k)W^2sgWrlc#NgFdq!1
za7K71Aub9!nCt}ol<Y)I8@#DFjqv!D#3de(y){f}6c8X}1uM#RGs!`W8HyIQa|9S$
zvlH?&8->-?$ubfnxv8N09PRO(Qwu9U>5uAsj`zxDBsooe$`jfOsvfVJ5UM9+A<&}?
z;y3L~0YsfwXVvk^v45|^_;J@xaBzQzXrSkqH)$;9iNV3KmJ#FBRnyYn__Q<I22H|a
z?x`{Djl9tzQvs6mJVn{WH1~w!tVv#`(S5}is7ejS<<q{ZQXz$%IKV#hM+@+bP=4#v
z`AyY5Mga7is8@@>S_!&V(Hn~&8(O`ijxy93Q+XCBd42K&BiTne;>zD`%U?l9YG&Q8
zT6t5)+Rjh8rT0&|;@fmBN)I>)<6hAg7G2Z%)m45SdqqvMI9cC3`fof<o_v+(zj_C-
z_H7@pC62CCpm`B3(n#z5yOPmZWbjOCU*CFJly;~QD(lpVCm+is&l#9E?7#?0^8K!b
zk6PF;OSDnM*V_YVpql~`g1J`tSh6I+S&cI}X<sE`hUGHe#@!L6CDLLqN_rO~{2|8P
zGV@@~!1V*U=Uu7a-WqzY4Z=U<W%KLaLpC3RvoM;HCB`$316@I)7y5P=Ne=E(B!H4i
zuL_0gQ2ol;xj>^u=iePb%nD)VSkit5`lV99xu%aq!xe?9KC}<Gdj(GZA+A7#**nBi
zHC#RKlsfUC17$^P?|n81yv;21jT04lCTd`?p`hrmJdnCg6Ho^jhPX#RYeR>;LWo`!
zs-DDjulLa8L(|aZaQXd&@s1Qc6dPd!fFu0`p;)I;HExC1r6TNrt#ju1>mN^6N>KfY
zj2o(egOG%=Lpk&t(e8`O8Rxbg$F|}QLcN{trCwgo$)4mbx-5SqXFOF5P4hbK*O+EA
z`8Pf`%7<XO8Llv&s~QOPF^gbpj?17=!!m%Rt8Dmc6P)i8-ZluzaNIxHSBhNKK6z8H
zrg&e-wZ~uN(xb$blsO-0fd~7#VCAxrdoy8Fg^8pO$@Oi8V779+iKkH#fyiD<+SbD=
z3+C?bN*==Oyl9}nX2h8e-)%gBuMTyl`u0jEE8TkmIj7%AA==kW2E`Z`bl=_ERd{rr
z`eSiMlbXo^=Xe448y)oEXZIyh<g-n|T1=>v=j1rh|L9D*`O?-1!CQLDgx@4%_<pp$
zI)JsT|C!y`Z&Vm9ZPH{&#FRG&-wnF|N<Z38%xu1GCL<TLWljgS`K=KlmB_Ie$pcD?
z56xvAM|=k(`~pi03!Gv`i`@7#T*%c@D=gZfg|!>S0RcZ@u|rKg>)q&*0PyKZ99~P~
zAp4LB0I_lOR64F7zl7VJae!}bjjAk}sUAA>lq2s&`xjjT*%M4f%iE!wC>1brZ%u1K
zH#@-lMI@K!Y&Ex3-IN#dVSS>*-^_tfrXRn#0brSZ`1mr&o&hwtM)fhh1pn1j;x%V#
zfmZy;@ftgD+kXbGyL{i3%iy1_7Jx?P&lg%dI?iM^aUlanjj35gTC@WM*HnqiK3xjo
zri*8p+z)t^b^5UfBUGOkNA*#ij<2Zz_j?3YRx!3^ADWzB&_Kye5!Tr$EM7;8EHK)A
ztGYM+wr_^}GSiy3j|Bu#)&o8ehZrXJ=b%I1<j)rDmHE-D^s(tMVNGM-8d|D0$vL@+
z(beYmEycffWtC_wZI!sF3W~i7HwRCv_>1OaOGX@TgOb?gW3tX{J1pF;ZA`?TKHl42
zyhz-wV$c>C=Qx<!%}|Q;ZT(PZp3Cb*{(FHj^C=Eo2#=SC{7(CRp}jy#-pT~}A@Pcb
zqzKk&{<@jZjT$PwSBUE`f*~~~fX+-``r^|d^(GdYgH)^NJe~QqKkNqnkqK#?t%$ae
zB;?gqXj@aAwzlL*pUk`1L5V@D;*FN>aC9F#XZ=ITvBy7J`4TkNAN=A?zXi&Oi|a2=
zFg4|DY}k-~%_Pgq+lrJk-`sJFAFhxPsy9Y<xxV(-vR3dDGVbUiZ7zitHq$GXt#D*&
z)=G%PSBbF+eVZE6%9{N9YEDv`GKn^xkC_~BTLXZ2rvJDMdkV8QDN6EoyAwN~F}FUJ
zH{aZM>z=Lm5h}nUgQ|W0coNT;J(aAhAm~<aOUc&nU#>OIe_2^Mn)I}rG3KNQOQlhA
z?4i1KyczS1Ch*2J>W>c|*2V4jf1Y8X)l4P(b<Xg^!A?gS(2RCdr$AWi+|n36IUGK`
z>a+YM%y)F*XIHlMm%bSPCmv*5#)_w|5NeQ)-G_P%%Em5d(?;|=;TgzAgjM4%^Z>y6
z3L=n-Z+4hm*pQD)p}yySrbDm<a(>_u9Zs+L=`weKBbFSM9jW#F3UPQ~WOv8n=togQ
zTJ|9qD-S4x&XFR|u3YTFsk5tECO1KE{Y(|QzRfZzGvFP#d^8LtaTwEyHz%pLD5-L*
zPE@Utt!TL)-(XIRxm2L_`iPqn1hbM(#Yzn%xb3|KBlZtzy>omIpD?m8WDj2xF)pO|
zN32mPW%k$0=+D0;cW-Km(IkOBrX;tmC|{B*zxTNr*>G6)_KKNfr$%9R`pESF)0jsr
z*ZDqw83dRta}cW|k6hmcUQoj%UHNs{<t;QKG;op_JiM+0*&o>uSNi#dB^IZjHM}yT
zy*9ZhP#hjU%V1CL9C{BR?1nr2X(-^{k(Gs2Da^{fHIsLQUOox*&AF6%DO&G^bHN+N
zf+rVM8!mwaz>E0OI(BJyQV6?~%s=BJAlY_X!EX@9zX2-Jlwm5IAj^?hVAQ?`f06?2
z7z_?vL>hB`3`c5FEA?|!2>#WKjB(?Ar+w1>G3ZhAjtv9a^fE{Q@&HCe<AKWA>(|?<
z_>56-{&5v(wH9?)wh`6aqes~qj={6~@cgUKK{i#h4qnfdrUgRt53)_?+Iy5TQ4-Bv
zp7U}S!y;eIN?#U(9j7gCX%yZ9=@srjk0|%pY#Z4)>B{D`Lk?Rc&AO(?z^nG|7VnaN
z*5oy-T%)qd#`XV8YVr3*YY!cAmlDc{zr;mgzJI0*^JUCDT#r@#yVu#cb4%yzh)V}w
zMee@_k^AVim0n7@_S{(+@73hBL~-~0CBwcTvE43!m;(ClqLKBcj9h#rcYMiHc>K~u
ziZBk*H-G*4<&mHtELR_-FWvvc7Og2r<9n%TdSi&xG+YHW=ajh=CSKB({On@!LX9U9
zweA$b05V;T)!vXsI0ZOA&Qs4td_7b-+X<i1VL2RbA{WO;G7WyxaCQ6(5p!jq?h<YW
zI0s`9)pTH)Add8VJ|hd&;g6p#n$7R$_ovge=ATLHrDyi;?q!+DH>Lo>is`YpjM!eg
zP{9^ev>R0BE=~zbNi#ioerj~oboan7TYmm*ZDfreGS9*>Olorq&@{BZ^|+M{{%o0~
z(L{b+G2pe+@yT!>cA05)QvF88{D_uA@GMM=V~>)ep>&$=nRTs26*8kX-RW|CM~`^Y
zsqi{fw)Qx@q&cL<I{GWquvdkn7#-N+)+ZlGzvy&RSBklK`oyz^m^`_S!kAV@^P4S^
z0&8>*<hdZ#Lj5>_+n_Dc%*@G^Z7jNVqVcd|(B12(6=#xnT2EHfi>Ufi!!4YrPT*ps
z*j{J~OlPA#X1ejH22tH2M3^PJ2P%unAg+B>;yDhOW&f$5kSF~>tfFFQUFX#HZG1lk
zMZ+&_=V@RYVEx0L(|j0&KkoPEFqM0dBL?5fDE{SK3<fUPAC6PYa0_NAdvIN~O4<IJ
zu1e6<mw7)?Fkd+YvP=Ev28?21Po9OAkQ6fwDyVd}FJS=rOSEIkg)wdTs<zsh74x9p
z9tBf<I4!KH{y5uE-!JZ9?CAAoJ{MX^?$~JO9Hgu_cTp}_LS7&HXa@vi+c)D?wBo&`
z@tLhL6q#IbZ5E+%8H;EEL|I$BaHPub0fRnZdEG;+zV9&$uk3;c@Pd?udJy6b{5cEj
zi>nU5+2Ske6hKLG1S6}CgF@|;Qe`?mgNJy6Aw*Mbd;86(4Oh$hlz<N@fUromi-FVH
zavP&1@<V@Ksn2yYc#8?uiNCJqF#%Bf3<jaXy_osCcst^<x9W~Z6~wxMH{T=^ONhau
z15lU3K0Aof1y^=iMbC^)j!HnP@BfmSX7Se~!v3QFwB&TO1@l*hvdX43FK>;atm3mw
zGg<)pc`R3QNM1L(1J|_Tq|J_Tx5LlB^*3yf=NiNB{$RZ9I`Kt+H1kHfTZDH=!t?1n
z!R2<H`z??u7aD{Yua$+WK#gknbRv!E<~HF%Y6b0bHELtBTbtd-t&hLc>`yGnl+Mx^
ze%93VLe)6G%7QS{+Lm+;>>x_AKN3AH4k!uYQ`EEOUN<U;p^eEK(c-IRk4^-T%gvta
zICR&Gw{qN<FR>b*b_JAt7Zq98P3e&fGJLVL@1#G&BkycCo?*+1s0~SvlOvlWznN4!
z&9>pW-7J=xnoLLRi1Ce92JK`+fR8n>%s*ION>T|0qbiq8J`}-VtYK;(fu{;^ZIeu?
z%92yMb%02DNNGeXtK=4eu23~`N13b|=g5`{sz;YB<eia1QGz7{#IC_5ud&@s{5Dg?
zvS1Cs_Rh5ahUR<jSdu<uyWnJJax<5SjEu`}cU_S6rc#)t<)9PCOzQ&)$fU4^q>G?t
zzmTiq2M%lqV?`ES-}nI=c4a7K=47o@bm9#R?$dC3l~ge!8E}Nr1qskNku;#oJ9}(q
z-U%Tc?)h^}m1%w-una#|g(h(EggvcU<L*y?gw548%F%)3#^oE|Q7vtmnrbAy&9j<%
z`mJK$c3s_e4-7!U$jl~i!HUL=C0+ao#<ij{`9j$`goy6r^dW=!Q-4>}+o>!zBv|b8
z;BH?BkMFaNqKJ<c#TRpQ&;}3Nv)QC$Kc}~;O<m;>_2GuwuIxLw5pg7p414Ngnu<v}
zwyOD*F1Yt~K3nG%+waNxG#@>i3AnqMKtJ`?;;J+*x<o?q_&ctvx~qfPF8$uG4u7N!
zI;SGlJRk5+Az|>=zy$BUdUokja5BCNk_t|C!HEZI6;xY#Y-skmVwS5dpxS2LJu)-!
zO>H84;7e9Gi(s?NUPW0eqOI!*Q?sS|re+^*hI4d2o%}hwCFGGvA$*8k3%5BF>oBu%
zdBuS0;+~%W1aVQQ9SQh#S{3xn;Y>o$ZG}}7X%kjI{mS|-7Vw2IHoQs%umVneqGWb}
zq*Z^_ZqUAElyUr6(`|3#H-CCVoR5`R%kmjru5E(iJISsGo@8G@Q8p(RUi<P{_C_x1
zlc_0gyOPh~G7b6xje)v~n2U@+6bCbm(l~dh#@A>%-}QAz>t{UbdAoJ)Pn9b_yu?7;
z*yNWa=TN7)c6f5~hMR&m%Z<^HD;Bc(*bOy3`sjPa$&s{c13atR%1pA2I7{YdfK%l{
zwC2M+F32`DG@;!z7pEc`H_feb*gyGxZsycoNA;{X<2lkGdS>2+L>z_5mfXgP$yeWV
zD#tM8qPCR{(fBkwd`k^8EVfn>^CJ(i5%J=F$wE7s*$UU~NSZF2RJ3O@qf_3dT4U{l
z8xsI%-5J|?!<(#wms)smDl1+G;LLNEkDh4VE7`KRJH56>F_=2Z3RO5*0Z_iso_a$E
z-+|&cp0BAv0Sis$z|G+9YSa^icv+*1cKK-qI3?@OV*$7cgvlT}3pI;Uzk@Zj0mMQ(
z9ucad%o^3^Pc`#9zZbP~jy(UEs?GsS@nq_Iyv564M4O$jCT~6TsAZyG<Lx0B7gMQ#
z3e}r8YjZR{XlFOhCkSIYLxeaCD_N<+YH-q%we%eG^+dS@GY;K*dtd8tfGdu<Us9Ii
zDj^<>lt_>8VQAWGr;47mD4cZ?%^rV@IM`Y+EA=Q?nc{pIOmlp)QNXpN!UJM94&v%v
zWBCjfEjrkTuAn2LS^jJ%@)gUr6Y$}QVST8EbH=9v&C|><RJu3!a*XNc@m9=MsU%mB
zrQ!#!1x-7K<E`yelFv1h#*roZ6e;e243_sGQ`7ikzg5}@Fk4Q)P4m+Odw=~3PM}2=
zhvoS4YjFll+cRBf6X&K|?dWHpUPBa#f4VkLtcl-7O6%4M0`DOVx)spVkGA;%hYvWl
zm5;(r|D>b{t<Slwy1qRU&v}pM#JwTnKlSYfil=}+y0K~9g`SQx2+sBzY;NMmOK5hU
zWWxa8m&w7#6!1sYaHXCv7Y#1wqxaH!@)wQv{;m>u<q?H$?a$GJG{Ic+T$^ZXF2#nz
zv4!mH2N0RVcRc`^aL4+p=2s|R87<P6@S!SFK4%wJ#ZXK5+5h4$W#QJBbkxDUi$2Cv
zXjdG$(t}m5_$BPm&pp`Zs!|WG4b%|e_JS-1?}{dk#=R?rldQ)3!AJ~euG#pq*L^nZ
zQFH;;n#eseYZ=<?ag%^~6S)5%FJ~UN`6I^Wr`MMHIxO-?)HJ+!XaxdH^yrfi+6_8l
z<S9@*oVbDJ=E8|p3@0q6XVE0xi)Lgv#pz|9d2BU&-?~9)`mF(Gt~5jos5XxcupIh*
zJ%*yy5}z}Fy13Re-huVqn6Nexni?2l|LfDUWy(_ruogs2GFQK$f3x#u9>>H7H9a!6
zL2|R1+YulGBz-NV=r~czvUlrbyIRTwCzhiUoK;_G%~xB?FYhVqIP%<_5-jOPysorh
z5P2y-WqQ%(1LPG6`r<{l&{q1Ymgjc3)d&xui$9HboRR%|LqsL=QfZ=@!{_Z*02&Bv
zWL&=#Kv%QzBks(h#RQ=2#)hxFmm$A$5<RDzLoG0AyIXl`U-xj^AvozE!#*?Wm$yeg
zIdO*l6cwF_26S3`y0+`LZT{fX?Me^Mb&Qni8;N{%!K$frP*~}_kWVLuaUB1F2eMDy
zGQDo1`N72a@%3C(U(sb8I|qj9Q)8ax*LE9wQCYM_%|pN~o?I_}Z+7REc#ZXi0qE41
zLayBGGy&M=y}IONp@(&o=brPTdUq@fK3o0n-Yfs7WD$`<at?>kw-RpCtb?i9*rB~o
zO@aBF53~0YbAau45dD?7xk!Z&mi`J-r2I9x*vJZ~NzCt8@M-)Dz~6Tz_t}y$atLxQ
z-F)4P{j26fGN4oiQtYx@it#Og@9-(U^aA7Sy?ZZLb-zq<COTW+sq9W3S9c41P}Mf$
zQ(mtOL={K?4rt#FqnCa|Zl+5THC|?PfNmZwHMmk{z^3)(UjYO`&pA;^TvxRPI(Oq0
zU`1kG{WE_rI|HzM>00LMy3i3F{AW~AT&WFznT>4KTV>1q#s=A!w(<&MWdolLVEgwO
z{%)#{PWN1g98gbg?6{VpOZamQdKe2jmHBG*{^cE)kEy)&)sgsAye5C)@_Gz4t;Yxh
z1rPv{!QlvGfIIuY9*p!KQ5xsHoF^b;;C~?K=Kt@W{w1UT5jp+4r~k_>_y0~17jq_=
YMz1{4xS6F|;CzzmDmuz_Pi?~g7vXvhjsO4v

diff --git a/Templates/BaseGame/game/tools/assetBrowser/art/stateMachineIcon.png b/Templates/BaseGame/game/tools/assetBrowser/art/stateMachineIcon.png
index 95ef798eec2267de8e28636ebd4b9ba740244bcc..ed94703a1f3af737695fa008be3fc088623b4f0d 100644
GIT binary patch
literal 20797
zcmb@tg;!MX_Xaw2he#u-AYIbZ-QC@t(v5&1sdVQs)W9HJ5`wgJNtfhEHwfIr=XdX4
zaKCHKFlWs=^Pc_gch~dmO^mv#91bQqCI|$=QIMC`1c4BNOGFSlD)4dPH**I95oZKw
z>w9Th_|mw4aI<xAwxRLzcekOj@pG^Rf&3N^vkj6d_=#nnYGX|icPs=mO{I?uGuCz)
z3}%y^N0R?OdU90`(xqf|QyhUx+MjNlTSHH^WY5?$=HTVC=P7bj9%se(^W#B}s09UG
z)MBR(M|#KY<9Kv#^!d~92-7vQ_V42_Xgk-|YIZsOyMjE5J=UnJYQ!>+U-mtAb`N}B
zB~je)MhIPfn|=Hea?|-C<e_U-4+d`LC_8z~Z@%7DBW)|~FUU2lf<&d?=78O*aZRuH
zJYT!YA*mb^g@3^czVEsh;NdRy(~^I@r7#04-{Cl%3FmjEZT&k}Rm|%;6-=HK((K3g
z6IrcIcx)F7<q5dnK3Q{k;#=9co_e@F$aA?)`b54)UE)@!EmjbE{h%(YdZA)iupI2M
zy(m`mZ}#3P`fNLOMegpx$){~0c+_=gI29hKNv-8?>ancZkng5LHL54~!pC%v%g<}k
zGG%J3*-Y4nlr~urOE8x+;?uqG@i#KdM1H<}tL4PM2cxRovde0Y^;ADBUvEdh8E9aN
z`PqKz$-2?{*N?qf>U!Yzr2r4ADzP?E*PXjqK%t1pi}2%uT1#UModL!mnumZ*PHuv~
zlrv|@H(RHNU(T`z&Ha0pv(_(0I#g>FZ_GR(Zzp4ru*PdlF%Q41iGObKvf!jmLNJqJ
zF5)gGw!-=-?nA&s7N9K1&W*1a6D`r7YhO#eZvh+iHT1(xpzmBo#n$qvD9I*oEn-s8
z9s6|W(5fX>Uy`iE)YvdJ!dPEgi3@GiDLQbj*w!_4srH_i%@Mg=R;uZ^T$L+$orrvp
zE+LjE+Mk&cr#dEld-W$wP|w(5TSwQ#<&t+fJLhb{Kf}a#Dfo+sn(+R_Kv}-e9hu##
zI};?wt@W~L>9}Q@kyk0bTEB6pYU$f;R-><B==n`d)hFM%%@iie-=g*X?bX4#bm*$F
zA7uM2ao>DT;^mgLV6p3r&INOq<=(#7k0l_p*7%^R-alyGNlT1X&>Cnr_M)$g-VJv7
z*6p;$c8tkeEVFfO=kU7DM|%8z=r<IHNV{N9RLQAdbgS+45{=9q8tK2gg<G+kb-RKm
z!O5owY2SvtvCG?*IiH;fNsHNc%#G&T(!;iViZ*G41F-yL2VTU$ulGgVZdyb9u`_$6
zy=2B;>@;&k@>XPBo8XA=n=dsdUZM><ZuRHRA9)2*1)DheuoC@-g6e#wAWN?j#5N6s
zoeTNLMVS6-3gszY@4Dl;)b)4Lo_i!w-96Y{+oAp2t9P==Y;N4*PI^%fwzDE{=-r=R
zYW3$|WaGh_w(a~TW!xzBry~+kE9@P_S`VV^%7&_&m)*AgZH!!Wg^yXUZe&0_!7%-b
zx=h>f%jY9^&C_>yPKt$KvgqAGlLRXxIbwVrc!%r$kCxzt>9tyk7SqKONZyodF7z^x
zH${*yHR^%|wX*8K-|W?Q*P&@<VFSc6fqg^`b7ampKUv?3dGm1GZ9ZtyEe3zT>D#ri
zD3d3pd}DM>pGp74KNF<K@x7L*`Q^yq`Wvk_?_ZYJvXBy%8=I(pwAK`8UGWmiE7YGa
z9@F1U4;%Q-@tS`UZ4V=mXD6u)&)y~9^7-cOWh-pQG2_uR%TKPUq5(%Xm!hJbWJIWT
zE_amm4$y}zWDn7WIjgHh)0Tg7Cmt{H!HuHG?du4nb4%!7{FRB>%s1$=3{Uk|bqOT;
zwj>lBo|QHC*7ab_bbO^FuRQ=ub>gTdP06~aE`QJDx1AA|=Wz$R<XcNEkG9;d8d>}$
z=LD`^OuGFvAxrHfid0(#;{)QmJR$0rcUs40KVQppwG7fJQ+%mMcf`hGx8P1yFXB<9
z|LsyTH%~{~I!kmI-!PrW0%_sl#=}a>xv^d>sv@x{gAGz$5`(_Pd}3zLcUqums{Y}y
z?<$Q+$T!jLR1;`viX%$56rtR2ED&DIYQHQPZhiQ!aFbNb-E*^eK#?-TuoWZ6kL-`-
zUwKh6{>{Iyh+_N#j-{|5t)5xR3?>nqCOFMID^7bf<7_{<|N8Wbx*Y$2R2RrtXSZGb
zsUl0%Wa8$rb{k?)dGD6xN;wQ(&$i9HPJSXL4L~sFDJBuGS#Wz?>Mq!^@oQBfhnB|4
z7gx#;{&-s)@JePg21DK~F^`zaua`SgA0aU|ckgym8}#liY0{k_Iy5|l(Tew^utJYA
z97|g@IDOhoq~m?!4wav!damd;S5@Svg^CxM#h-dVduu>`BH&_{m6%x5ex`XLL%|zP
zxwmb8jjVI8q1Gqh`mO*j9q^7)DHTa(C@VT~GgM%t2+q)mFJhi+Uiw;Dx^p|H8lvJ^
zfLM<}!SYES%PXvyn1?2WjKXNr)FbZ?L0<9@FE2vO58E(q3(VAUQmkww#irpfRCMra
zY!)mmf@Ak02}C$!R6rK_%KQ4(ul}1U6Zz{$9+p-y!7yij4IS|^#Pw*OC~bMBmj>W`
zl{s3X5nPcL`{hQB?DlC}%4>!7dKzqd%&20KR3Q@t+d`Am+@B2o4R$z@R+)n%2$^VZ
z6t^An=<A5A)$%Uif;D)<<njw&o$*N|T#&yV)0SuJS&Akqs)cL5*R@E0$?^KwM@68a
z2xOX~w1L%e)C@^n-|M$W`Yw|qGNGD+xV>xXh}b9>5_5(zG5E_v4HE;`YHuHVqvn&e
zLZ7&yD|a1wzkz8bH_WhGP43sx4t_s*w=;LwNiYR1dz|Sm0iUYCNA_LJxX<Pk>x}*0
zOf+7tuTZ?-WNM-DMHzS*(zwc}kce*{SqwTcyf_l>bO|Z5)BTyLe@OI&jSWRvjw-eS
z^|<H~*}42d_AlD@5c*%g*UQ)0mEFxt=`mLthEA_KQ_16XJKzlZq2w$Lkp_Zq9LMTB
z!|%%G77<PMpe5#GvT=xJ@sSOZ`1KmBXxyHEP&nmuygG?=$r0`(b~puD%&CF{ErvVQ
z<jEvFuND!&5^68*$()hCdQ)Z-uYWG_VHZc(m_e<Kh9Z{vWd@uL+f9xPQZa_)CGsFU
zKq#%h4$E{!wdLBkY~~GOO-9CPeDBU;y|Fit8`UMGz6q<RiGt2<XCO#=+tKNNOiN#(
zNMpL~D*e53jmwCqkMgfzZhY_t9OJBrC;L;%>7U|P5L4psB#sR`SrokS6AK??DxKOF
zNU5Yf(fZvAzdmm2GZx0Q(5-anq`4!WP!5AGX>{-sB>V<^de%(V;VASpM8)W{=(I(M
z$)o{NuL)oO*y2%X5kLqX5m((n{8*|mS34E9bAog2@CG-%^JANw3>{}yB69ZSrxya4
zx4+--Yz*RcT($Ap7C9u!jO2;k{tdao!X|1F#TPbNx}hi!h!2u1D`I`6PE7jNx*T^A
zRjnd0uABISG!bd!=&L=KSq#MYat;p_menPWC5`p13$?~L3+j`%pZlT)%Nv#k>v%g}
zZnLczxL-urUw<}rFf=1OG2iKlT$J^(rl0P*m2cp`2?Col-~4@{Q$kM8uK|6r{LwtY
zOF*+Sa!G=ae4nw+yX}`;19>W%PlNBU*3E)`V07<C^KpS_AyCOjzJ^;AWV~Gt)2SCn
zpJ+T1(Ip+j#vrfJPUMib?7vcpwi;_h3St|4_vfNj4%HZV7wqQjAW7034{FTiWRE=@
z5{Ho?1(?FO&#L@J7o$^G(f3?Ru=l+G2x?Fe+6#+=$90>&kn!&Rc#Risjf(hJn`}&x
zM3+gL?VL25s8$HM1}Z^=<7^xwsfbpcia5+J<umg_6w~P+)fM>b#3U)7SP}nTt5|I2
z2L4O7s$RUD8)wHobNqKJn~nC{#dtFe#P43dPYvql4NI}k&^l8~EJJ2fqy1PrhLXxa
znG+`^eMc@FJHLcWE2r&8oe;z?x<^KF`4GX4Y~b3Fus<=mAJCIHc9=#s14WGViPC3q
zjSo{y-Godyb{S?x*&qlbx%2nB@RINID-eH$sXxhOCPtfE4|4t1fggq8)k5HwlA9yT
z9|<sM9I!rN?a(f{`tIfR%sR>%ze?TtbVnkAjHw}JTx^uaJ66QG$o_FPhn&+2=cDSa
z_%B*Z!h9tz$<L0xNUtq9zXcA|MCqjvkWWvs64IgKp~ORs&kJ=2LdqFbmr=FAIwW-z
zZ0@54Q}xt`2JC`gt6NAAzhkMIwUZIfIE)F(NxpMZi)+TGm@}!=GeYcU&X>^$Z`UZy
z|LP5*pUoeSS_N@J4LR_qUZ;HKjStXVBty|jKX>;^X20r)$K5Y<3hb^*MU}KNu6R8i
zi^#kN60DGzz_d5ai?PRvF71UOdEC-XZNE{@F6?8ssh%A|1^cnRl9rrdqf;oo`_qui
znax8;tr|wawK3OcGmm9l_?VC{ZCd!Wz5$jLuW0f%|9~u}9kbY4!QT11`HD*$+hdAu
zAny<=v8tt;#v=te!`U{s|NJuKv$S!LED^2|6IL1q#&Kk4M{!G1gT`jLuDgeQ1_Z^?
zmYb1qT|QX&Lhe{J5hH$pypY-*&+FABGr`Nkk3BD<;tUh$XD_Hwu+gTINkuS>+^0x5
z^FEJ!j^5$L&Zc7AR-p;7LFdJ4-fLU{xv{<<#K>?RBKVqPYgM98$EI+O>+&rrigGE=
zO+j<hgte5xfkxi<_bV@%86UE6gFru$nuNr7&e1)L2WeU)l@i1clI0#Uk!x27SYH&e
z-0{?pljZo<2YC#U))8fve5E7xkvi_#3^n!W-GuhIFGc<c!gO&o;tA=s#CFWT<)G5<
zRXE1)hQs9V5TJhRg{O>vl0wb7z>(@wY6R;mPL32_nAyKg)@Q6}utPt_a%grTsl<ly
zFY8LZqE-7chpStXK_B>_w;RPS(7rY6c_wJ|YMmh1kYO6+Di}I6_zpvcCVaSrtd_Iz
zf*$trEtZx1eU$t1EF!ae3yDNqp+<HS^CnFb<#7Cl0k<K`(wWDgvNUGaq-FCJ;xMUb
zm9|M+iZm;m7&jNYDu?eu%r{M8(r9&u`{a|XhHJryaHNHk{Y_edHw9Z{Z$d^Jj6F_7
zZ$TXEt8CtAzl43ju8JFt#9?64h~EK^=AW~7_d?J(<-{5fuxDCG)2sZ%l?ds7c76u=
z$+%eE{Fs|)Yl>*-kDG#o;e*Q&Q4?ABUYfhpP!rVWOIClZ!XhVK$9*%0I!4*rtDdoJ
zHDq}6X6GwU`4Eaf7l?_xbJB@W?3a}M1rm;@C?X!g&VxS5aDxN1G)7PoS-iq7<z$AO
z{9kRudhm*D8mi@9QCUgPfTyL>4=G0kA-0K788?%fjso#|POAy;aUXF)KNb^dIbZyN
z8G@bu6&XKJS8#)NCVr3!OZ{g;5XE*Fp`^38ns$^!Fx~`8{x{x~NFj0j46F!_U!<a*
z6@CRaM#}mZ)`VOUmc?Ia7vziIvtx4i(3qc)@5SFqCKUd}c(g@C@PbG-b*o_D1@=~{
z9e9j0!s@^E<WEc{+<g8KNPJ&uI?!@hi};1G8~r*0`Ew+JN2t16DN12-W2ibG2>k$7
z)~;Qs{43Qh)dle%#RQ(uYccZOsD5?g7x`#6O=S<~sF~+mIvenWiNbyUSBNI=hzP-d
z1O<NQv*IrQ)DP*|$~Q%f6;S-d7Z#bf1lClUiQE*o_M;~z@2?t+{Yyc~j76%r&L(;J
ziIZa2iVC^6Eqzs_U-x}~LS&JD5r&Hq9nZ)2T%OM7_Ms~9X%KdDZ!sZRfSU;I5u;lh
zexwWs(nJ~oir6Hc*Jef1sn)+q@Q`Ka7+M&T&`b-bis3@M{bX^PLBnXZAp_iWM2$}G
zw77}K#iTmc{4e)8lBs!8PlN3sKIO1*`Fq9w)gN!;Zq=_%mE3}&Y&hufD%9>kp9B2x
zh;{B7zY5ATQ@zEF=gVfFtShodV%$O*1F0nXuVW6?ya3yOq^$li@qu^)mZQ<=Y0XF~
z4D-w5vB!~(@^gH1h^p`ztB~Hzp><ApDspBlEcdXD3p93W9nu05Dk`cY7LQ7gx4*k#
z{h{7Yh!dv#bE&nEUlaCr6hHlk752)chj@zMKCivytFwNLB$OrSILlerubA-2VV={9
z?LQH1E3}TiM2T`(A}dZcN3)93PU^@+hDZdJ+QPi<gYH9NT{IXnDtJYhU9Pb;fjz-p
zOx=D_+=B)s%s(2!!;oUSc?k!wR~!2Du!gCr<94LfNwh8Hq2QA4BNc14KvE`jf%TBk
z#`gFa#7o<Oi6X{*r|@i#bi*n1$U&zc*^hFUFT7H5DD9&!t_kj=l1Mv!?!Kc0R+knQ
zPd)Z_y!L8M-)LIKX2mqNufS0l6>OknuawL1B1HGWdq66s|ADW<()aV1igp!Ssx-NU
zucbRuQ9n$sddnz6D#m{l<W1ydSr^_!f2GZ6T)2nYyV~N8O&N=aMBVr?vaaMq!(Pp0
zGJ+Wl!N~$a93yh&#oR$Y(n*u7Z+b56EK@KFKJ6=36E=5-Fk$=2Gn!^K$?n&5r@ez2
zxnZ=TYwNqe$MaLC4JTyhHMU8$1LALXzBPm(28VSZHR8o?m=f!}@<P)hcw3w-=>O7E
zGPf7QTHvs%joMA>H5$}<T!fI6`tX<OVG`xxI_m6&3Q5+h<n#&LBH<Q`RG1Vgk|80f
z-$xF~Ac;{4EcdAcG(PE}E8{^~)Kl;TuEx7Wvaq3{EPiGLp-O_BHsA2Jj<9Z-xh+j`
zH0`(l+U+C@a2tDwmxdlH<cn_Ye#Cvfsr$-{%*Kdg$c#&rxl*^uh2~71Xsz_GKN|fi
z{+9;ajPXV4mmwDB4r{GzY0gQz7j_al_D+uCE0Cr4=D~iQ#|l`UK7a8UYiVpBxgZ<e
zuNlATob}u|q*%vEOy+;<J~8iin#O83Y!Jg}Ny1;2pE02^xc^#C0{Q0hW~lX)J=$74
z=d^2%NhlU^y1u<Lb)#hrc~2ZOuIFd5qM!Z4cihL3Uai?rF_IRl?_8;7VtBec2xRNz
z3DHL9<D?(#$y5jh<D~cKKAs>lSiwWm<tWziHJk-9g&OXvcx$CQrpfe1c0aF>@ySQO
zo8qanrXjaW(r1v!TC-1575Qw2c4S;t7=%4rv~M3t#}pqlD88F64T*O|ys9lMrIa}t
zSCz1$XEL{Pto<xwu>uK@a+`_gds$umcXHgqo|<~p-l8PJLY8Yb+Arfsy)aKZiIFep
zL3UE-f-jyTu#H~jFkC}kK#dD0{-rk_DL(XOvQd|r!JPJmrnr^44tUyj@ZD4u{RyLM
zdSx=2^uu(m;de?uUZ=(1f9>3=6U3X0Qg<?NA&}fTT?wA>=oU#OC6o;fD9>w5Ts6#?
zu3?)!c3w<L@*?48b#)^97%3f9eu8jP3U}(4um|ne!fjb8;gjs|i%I7{BlR?BfelH-
zuah`!UB*@9QHQ8Vx?d-DBIs~LB#K2aIQ69=l_0|F5<c!-fnh4U*e?+C`w34+9f-aW
zH+iQLub<`eI3S^-uxBgvkiS`&P#hqbdPQJFuP3F}_6~(t^4!e$ogp7@v;2{)zvI;4
z?~g&G5FN(QeODaoujyF$<vM3O;k{6?ABEebSgUH+cqMSll96p_lWuy$sb25UI)ire
zX#<h6BF_g|YPhNDiOgIQfi7APZaMWKrr-?2{+!e5tf7)QHY2O0{)9eG9OzZdCww-o
z_YK;PlQ4?G9xEyD^<=@ezN<j1%ZrDRW`h>9PO+_mmk%5D3uH%KL&bcY#It@#AP~YQ
z2Pr9a1u3cjkD>;M>D=HX5&2&6SAAwiPCCrEKKLGk>Upf6srxi4^^vh4)f1HwLlCox
z5?Tch4?<%s+z?h>O5<E_Z+9Z(A9(ou{BLDQm`+0#ie%!^1|Ix;k3Ft&PxzRXx!M>&
zGQ5}C!VK1)P|0<oj=d=Acb{W_O%Uw&VH*$3iwFmG#GSBSdxj>42)c20zs4WuQsIx`
z{|wG4?e{Mb_^DW|9Hc4?n?{MDZe<tz*WYSipJ5kuq3oD1Ak9knUjM*ccZz7!Ve?y6
zdFt_~5Uc0vW|g*MmABeskGZLdf@j_i`lh}lq5}F?bty8U%+C{*$(A%S_go}T-wxH1
zmFV=y;$LBvOMbM!|M9f$+bnD0IHiEu4|<BT364knXi{j<Ty<<U;+PNWv|CqnxrgGI
zU!`0G7-3N(AT4$Gc^jo%g^f^}?<u_Wo=gwo>G*_r5+b{niiGO+v6Hu~c}`T7It<&p
zF$n3^D?}@qVN+j!Uo|_or+kOYYowu)55ovlcLPA{0M$}SP8#@B21TD!FX#hT81C{0
zo*)p`%jY)&C_9%F_!7-aK}7~_8v_-UfjFs1?;iMy%u7b!OUli~#m3bOB=y0@!pp{*
z#@E5io<>eVMP2VBE(r)k15%Kd&<1)BD??vi8HDd%7aZ=~6K~X_4Xx|8a@KQ0>!9i@
zy!MTyrL*e%G%K=UpggZhjWWS8m!0x1aS{{c2Gj^yhY3e*4*Jwer$cLE77~UG8nQq?
z*3M&BTOq%%X+v+`wf@{ZI(-1euxcm2upQ4|xL*hyUwwCx@kC1i0tx6T#{$AWH%n-M
z_y6Jo8CXXAd9DA!1v;=y*z;QdgA4rUbr68}|KNh=d9DAE(!@c9!0!IHD+1E}|J44t
zr4}+sRcn&Zn|7l-^F!JhCB!l@Xgt};sE$o5%0fQ5nDK70z=|{qTM9E=K0#G2O;&GK
z*DOufY-zMpw;kaV4xr}v*tAqI|L(LQYpKq!w`t>VQWfvcMC4#rBRr#S&i|;<K+`-k
za6D}oUt_(V&VFH0^+VexBudved;FoDX<A(*zJ(M}Ot-@KeLG66CR&Jy(zJqF{X(WK
z7RD%{CNr@nvvta_ErH@2%TRPsRE2yJVTT{6e1?3u^kw$gJny@-Da+cTk$2uAi%#}k
z3wr$Myy&kFuO-t^X%oc6K_GX{)nEQ?d>M0R&a(Ad4n%br5G@b-mz|cKEaTpP0*}6J
z_);!3(U0&zz_ej*${=!Fgh+|<%wy)fcqb27p=xuPYFU|WJ5;tF{GqX8C8BN47ut5a
zt`2$NBS8ZM7r;0!GwJZ;s)3V~di(nu#(AP_dot0#<hspg>E($!Y^NoY!)eX`cfT#2
z^yd~fwf{5a7k*?BYJ_;6s@k@r3B?i`v-K5WR8olSe=d+X9&5KBKwBEum&(p&?d?%i
z*lMZzZklYn-T{)#)e7_c+jZ^XcXJjon!GEd_%pZ_#x_#-ClE&9q35ZkAhHN^Y+s(U
zZ3MR`h)N+oD;C<8dw$vLOMG!P>pwdFhgV0QB`<#D+!)yOK-1Wt76K2mCKsj@MSE9<
zGAEYv#bv>Xx4zBZ=VLJPhwOtx1QL9}%>2lxt%XgpW8u|tC>_Dx67#w{+PTBbDXN1!
z;~^C<rg@0YMf!r&7L+CXDyouWGO>HVx@0N#z1rqyzO!i^=|cvb()8!OgPzzwT@C8*
z9VKx}GNZ~isiUQ-@%OJMZ^T%zTVUW#ZC#iZRDaOEGgE`M9<nbNeOEGL{qXF~>;9Uh
zMM@q<ZetLyt%Iu7_S)j@TZh*C*IVU9lscsrjCrvvd9hASnOdwn%&}3P7(x&0PV;!r
zL1nDbVPNK3@9ggCQqZJ>2Wm+R*8fEjXT{%nQt=Tkl$|$L5nNHm8LRE$bNLczCxbvI
z&M0eh@Ad31^C&VJ1o(OR5}xX<-!WAibH0&UT&dZQb|MlbdfrmL51TFgUJuLAAb;-c
zU&C2z>MOe-YWj2=<^m<?^x^(NUvY@O3)9nyc-NYZ==0Jv3U`yvlA-^0a#!1g%HrZ=
zAeyHyZ=0T!0}!VaI=q7ohNP9X7UU|Q&OYiYv9SvQKXJF=tG-?}o@yL9&(0cV-f4g7
z>3Z5ygQfINv263;8m+C}r~C`vduAL-cH!sk*7znT0;ba_kTL&DTX$dEvc&Gb3v+}g
zP33K)fY}6^8{2Rb&cn_lf)jEWpxA#*i={9-krn+hM}PJjNp=zLxPQ6G(>yw?)|abG
zBt++wI^-Q3D4-?+R0L3W>sN2(j>fN(2`u%7xg&te)ttA)utB}vi0Sc6-tECA`5X$(
z*9HH4$wQTuP0G+gL3t9S`@@>1Ze~U^XFV7Cp=Z~{#`78sc{AFy)oGCM$1?uXi;zW~
z$(<yO01znmWnWA6_U(6ewsHH)uSxLSF9ZEsIFac)SOHG~O6d;ewT8BuG|$_NzGnZ!
zo2CYcFp~3C?a@?Qc*h}xp~k1I%&;E3CR(XZD-Hs2E_4>0ds%ToDfH}8#~HST##&jB
z#(jC;<!KSh07p4gKUe-7elnf07BXRGjC-3ssZ$j#Rh|NmE?K4A`;p-^6WZ(*6_KxX
zZr|Xid?aH7<uesrG;rojJ99y;domny*9JZvw<<COu@Mt!V*{3|+~n1xQ~Pz!ixzw%
zn0fouD1y)g@%uI1<E0p?8}HOtUrzJ<z!}gwQ-%T~;6c~IS*0E!NMR1lSts5WqGi79
zJB_(M6*Q!QzYstt%0n$>+T5kqbPT<mW8Ma&QAOHxrQ4sFc$Y-dnAse@utiAVfx<A(
z0TnWDFzp2HcAio*fS8ESdD7G>^yQf-!Dyfh;CVDm(-XON`$qK&^jn>*DZY{5E3-rw
zmKWD)$~R{sRC$GHpl;+L{V4X`AU0J<s<I!q^6DeC9B7~k2rfXdoVO)-Ry)IIC-Q8?
z`|Po|sh{ubSgBqlTazYl{f-?Frnk%&&Unt4VHlf6Q6HGpZk3HsGY9ayQ$Xf}9?pH1
z`IcO2FsbMK+>KnTBIPlz!F@Dzog1@yb)ANoygTekxj>BYoYP+Rd$YDCvW;-xBCeCM
zjtI{?(E)~Pu1Sp<MLWW6lT~W}RG=Zs@c-V+heOuy{>!MrV_drS`8G?L7dFokBX_*N
z0RQCgSrNK8P+*)#`@aCx4l?=g`8QB6BovEs8f+q&7oG_D7Wl}RQkbZ~qpeskXLg;T
zE8;7rg*2q72&TSWtmu-LcStzlVLi{1-&BfSGThtswVY*T0+BO+L@~?^2;M>~`2igt
zQ6s)0{`hUBrUXhZd3v;zJvL!F7-jKn`^H%<$<8*g@q$)CgOCYZ>JkkJc%fh;Jj+Y)
z&z`Rcuag(b&oRD#)@Lv}PMj)#Q|14J5<#P0!>``Fq!-$a{~SB|XMog@u;0Qy4)J#J
zSJdMev$x=@*_V`!5lDEN76GlenqA5&HOd+t9)(FF0K(cUW%cXz-_h?oik6B6x*71p
zIP3uz31Wu;=CtN%v&8dgh6~bcpPsd7g++XjYP8Mxzu(<kZgp)M7|OS1kK6>@Po=JQ
zHWfN$kN_sdLUq3IaO@NSGCYJSqVc*M>*%;#G7$p$j*q5R?YlUP6ErdX<>bI#bDQ<u
zHcpVJ?8BLHbpI2aw3jOEP*VnvkA-=5AK_V*nJu-sv&}W*@Pj@B6JzGeuSz2#cQaoO
zUAl_UXyRuay&F5VCaW9ksAdBRF@f#N&NpUOQ`9ST)aFi8WY{&<Y0oS>n`(Wkvg}ks
z=qPlpsgZ?(M?2a=LVg#C182^;xN0U3?|NKMhM8v1{!>=HbvBIo>7GRWJu@V<P`19>
zv7=fut)ChhWKKuuqIJY_5pqpe!4nSs0a2Fn%!ia%9ca?Rjyrg3_-okrdMq_=ofT^{
z2V_FC;LC8RuA9SgVdX<_+ZB2ILj>UVkwD;*TuySzsq5mzeXRPlsw~B=BGn;Ljuw5G
zgbfO9%A5)kE#lWJ^>%PD#H#lnRklkTFWqiiKH`8b!JUGg)CyLXW)9Kl(+q>2@DM?q
zSC0b6aHDev8-je{`D7QI`HnC7^(grc+1xl%d8^`D6;c02vqh^C#;m^q5r5|#!^Cj#
zAi`JAYkM<Svm&wztPt|+EY!bRSMQqYXpcI?TdgZtTjRAkhB-bcto8)F5Lr5%pWF#<
zIcD5hh`moF;L^*|2ExtTd2ef@&`gY{?`-ZkQry^568M#q2M1`EO@?{-Z5<yMS2_(3
zJIN0_hZA5vl`hq@0fvY9|B`Eg=mx(FlFcBlGt3`xa_B6C+&XM~I*>oibCMzpRn0Ya
zn#?^t-2RZix&gd=olI9)X{}Rx0@C;WLssOJf?2DwW~;JfObf?I9S~C-GP&cy#E&@y
z-IJksJ?elAV(2sQ%UMTXo$6*Ub(mAT_Uy_fQr4GYL$*fMi&rF+T4F(gs>fZeRei1B
zF<Tp^_9Hc8NE4o%_O9+0mul?GfL!=ZV(VG6!^D(Y4g=cN)Q;>&dtYkQ;Qft)Y@;Np
z3Vmsc{b{3bQpZaZy>pg0v7es?<@Z*HvE-;Sl3k~&^?7+TSI%lmIW^{!OO*JKig+5V
zW@t31*idS{!;o7uVA{)b!V1_OjT<i694>kJw)2x4scbSGS-&+d3$jFcL~rFB-}Qxi
zu$d8>iYq&C4jNah&YJVY+=lt1j<8IP|H~U*%<SWye}oc))<mvQr+8HQtn!toQ+I`)
zOWuM}cmfOCA>~{{qtPVzurB0jU0lqxrsL{3@ZIkI7Z|bk)?zL@tFnVDLya<X2;J^g
z75|oNa}5nTVVwV2$B>ay;q;+{Z%wgL^St-@Rl2L&d}}M<EwZzCWtMFo6@~n|wqBQ0
zRm8icsj7Wn`md|O{Ih#MSM^n<Q;%EEgyj~T6{E1d1A}!cy+@DJdDB>icuH)23)lWO
zo3)axM{98f-)l-7ceIutFY8bCEYD1GcM6^MKb<D}CG5D%eXlSM*hCcX5>xM3om$-K
ze0=1`yC|U2Zuw7!$t?_by^M21gY3CYV~LD(yHw?$e?n|(b5agrRH}6UdXGQf!j#{!
zO>=GwqzjKv262IponIY{*~%0gHhPskj25H?dn~QSc^a5xa_pUbA{$lSB^3K~eAh1L
z`Rd>@9e0@bFqIjzNB!YZyvd3wFTTL<M!>;>v|`d3{!Md!=c@BalsOo38oCOL1wxd7
z&AesP<LuIT!0{+O+ZYj#2~ayLGVZk3$y&cRny&>+g(%J+D9R3ixXmW=TbH|&VQEp%
z30#`+IIqST2+f=*Sk|9tjFVyGPzGvK9icRVG(Z&;r{IL-qbgS?Z!5DLNLw<O9JN<K
z9jn%cSGh4CZ__zKF(VL^bsV~?zPQ!w@7Ph?tvqzp{1YS(1uW*BZi9-6yujV#Z1`#?
zUzt<JE`WhV(lFdPMmVwk^Iwm90_Rr1liKkpo^CVDQ_^KxEqq=r1~+Ka{tSO`lIigF
zRwc=Z%`RYK%uvbG1pn6Rn4CH?H7KZY-G2@ePxo&F)mEddI>COw(&&abRcxkXYOxTW
zgMc&CxB|WrpwQKJDgSi(6ga4Y3V0J{{!u`%n-EOwX+3<kg}VkTZaO=Qyz|8uDgK77
z--f1{=`J`F%HxdyE_>LGo_!l?JIQq!5ogfh2`OhGiOuHN;Q=s7h5~b*V(twWF6u{I
z7Vkr9?Z(>RLb;s#JFmu)FLO|{0E$k3H?>lWa^2(dReL8NhO&kI@4{}vS7dwFXv}&C
z&$y){`h8nR8#L$ox^?5(r2D2#YTVd%FIFfryj*NHhOnPJ$RiSO^L5#O0hQ8$SD<54
zfTK6k!-|ho@<m5q!>Vc4oUfblOk)~~%{z?N#Metrs@pj2#??+P^(BFLzL#*LFBiVl
z$9vOr;uU30*pH_HDg~+8cY5!2I(+r#o7u;Qz7}owZ4R16NN{2c8ofum+e?wV<9G_n
zzzC%Qfxribzvigf>@JQj0VuYk!&qWtG^d{*XF)n_lhW3ruZ=IQNH1)%R>62A*!Ep}
zVtA^7ot;=`u;8EaJ!33@qG$Fmw4wZsjh^NAPVIMpRudmLrcHta8Xh0EXs-IGvSwWi
z`}2@wG)m-?fRb&XHdTTCkHA&Mr*smc=Ne@-h5u<*uKjLrj5t9I9n{TuKjOP{@ncD;
zt%<wLn1Qz`;mIl=Zg1hL7}HX-AEc;<>!|osgl$aCfjL80I7Dda>I&^6?g+1l{?hD$
zp@P#=bU=g2Y)4+3EAQRf@7G%7k#~K)vEiJWgbE3^a&hM<fcvE?yp?qXj0Ozph=>J(
z-{t8pMVr5!95rn621uLnRbmB72MKA#Fthymf6fvykz!Z7*4aSmy;1iwAI_Mgz_=5b
z&9tMseSb%TK6~V)<JQp7*;w;M)MT0?qzh(Nqhq#r{*$9^nrd%s7wzB*$tBJ4ZoR)Q
zoJJcTS&@G0%y?Hh0I7#l)33qV6S|_|&{cd{9lX-nRb3F$a0O{40sNelmL(rDB4|c!
zOyTPGo<Bv8Jte50|IsSw<>K6l$^r#na@pjKZ+kFhDs+(vhvFw1#r@q)hypdND`@LU
z2EKhYDd<ve=;jo{0A1M6#k>U|L?i*%u{O+vP=*{keB%x!VS@_iKAQLNuTEpF*4)aa
z)WebeSf5qU?sGbl1Zr-RJT>^}h-Y>InXAv1K#HDA@R~@rNa&f{V1z{BREPoG=)TQ6
z@L?#{S556Kkf@8*w{db0ey*vdRRGvFd$pTc!Srn0yX>4%C!qojW+Jgui;sZ5_OBX3
z1^y*(Ot<GeJCYnE>WaMADk$Iq<-b^>feCuY^sv4X*B0QQt93i%{Et5Gre8>d5J&IA
z$=gd^G#k{cJ2ko#nhEkX##xsYd&LJ!=oA(GJIINR6RzH9E4QsEwcsTg6Is)8JmleQ
zkj^y1V`Gr6eBL)=A#kc5+p}>LAMs;-$hzMa3O4M30QJ&b6Ry|!Rny~6eTUuA!9dQl
zA%1QpuJ^WJhdQx%8n$vmy@Vu+z83=p-C-Wmv#o(gkwg|nXC6jlMMX9eToohKsok`-
zUA)s;%`~}p7z<*YEEvF974h8rEy);Wr@uMzTk>Cz@Z`6@KA%RQ!G3*tkJKpirTva#
zkv$Dyp|lz&HL4eMDyF6mOwU`5?xy}T#LvYpj&scytD3SS=YpfEKye0P%GC3NQ)43n
z^}kLfj>t0OK7Ute`In>g3;1QFZu^glR|Df$OH(2DN>6KD9m(@cELzzGW946!m{Sq~
zl7$IK6fRD`Tg1vtLYBqwWs`bnw9A%4r*3Los1JI_eJ?_nZ6&C~fMP7A0sCS7gT%2Z
zwX1KA@=wN8J^Oz-)rpmjrA@wgjZKX;fnTn?;DE)s&UH@R6!`GpMCb5+(kRhvtq5W+
z)$Y-v+Zn#5G$<APyZYr#??grbQm23rCjiTNvB|4p%$H4kSLAmjqHrX15UHBM_*5F?
z`>H_p&92Hs{L}Q*{*`t$Z)2$b^mxd5Ylx4NR6$1e0rKR#wSQ{u6hZA2_TMy8x=b=$
z$j?}{U^cG~%WpP&z*|QsNo^A4vSQk=3zev8K<2E^%-wCOZLHvST}8~@pW`>5EJ}RJ
zz_MU~ID@S`R33@`o^*3_`?7p}bjhjtkQzk;z%)(<%}%f~bEz>y1%OGGnix|_CLDbm
znhd7E2_n^Qlm{DgMMrKrm!}wN7f3)%PwbNvg?TZ<q?gN1pHRQp_4u}nq+PMJU7O2M
z2RFg+j?*vrop=GbfB*s?=aqoreUa=O+i9x(e|~F^yE*=Qzmor~($?U@#%iP$fBmVq
zcz73a)u<@Qz&UXFpQ{Dl&3!N(@f4&_sm;j8_gN)>(rt%6L{y622AMovK;Pe8b_A!r
zN1DCc@a*zO1K_T#D($vIr+_gH!;5q4Y=%!~sQ|hFXhQ&C^eUR<EJfel9F;!a?ab+=
zH=zLc_e%<GRO-t+Fc;_w?+g_ptt$asV49&6q$8Hk7uWlG19nt(2(Q1yOb~m%Tklt6
z+JANF7tx2;2*M8kBE;{bbtrWY+OFN@3Rc(V#DW`&3jXpiy#k8rczyt`w<ZeDC)pTW
zfL`ri-Br%!2vyDKEY=*%?dG)k*GO;S0UO1rh)<^lZWTypjXQlBxO@1BI}8x0zo)C0
zDDL*FRUWJ=WPX7B*o1AkG(|vMYiY-UADrRR%>$HgzxaNKd)-&gyf<_BrxnBoK-e&k
z9igU8k7Ij8nuJBGC|bcpw(&-ybLVP5Gt*Zwht3GVDbG1CrEYODU-FFbL~k(iEpyeZ
zYsmtbHnW7^L;>~PQ&&KWVd-XP8Nh8wFTb3A{cIT;bU4?31A2iV;WZt)Bc`4AALO4I
z((XU+u%*%+2AkLnsuIz|0H9B;!DIX+RveA|T(X&E{(atIjI})X?Z4v%8&4kW?%ky4
zM+qdA$ba7vt?}A>KobXbOOs<u0)YW@lSzWKa_JB{dsI1n$YRa<Oc11$%u|=o9#qaA
zaW5Py{a{q@SeUbb6e)I8n~E=h0AmloK>N6umoJnDyNd|JKWRauL7#E<)~?{yaq^nM
zk;Fs+7I}G5N+ErKhj@Aa5s|!=13656R97!Lt@Mh;MZ}&<8S(iX;0ORZIk>vR3=dOq
zlPk9WjWq$s<3X3~`~86TpByU`Kw_y_wXaw@JeTQy0i^U1hDKqtiP`P%AuXx4SmvOb
z1eZQeZpYF5E8GKSYbOA83`=8R%4iB7IeEAmdaR{b868}q9^gnm_;tu`JPZGia;ANe
zRVQuaCog{r2_*>7CNsdIc{qCq1oIkF8l+b^_skyiRkqFUX~~039~X+9p6=GPut{V1
zR~R*a<E6$5J|jF^p|>fpBMuaVfu>Z&ex4LH2M2~~mcGaxmwnrc+h1KN+&Gu$nxH*|
zZpQZ6J-9Bo*pi_XfasjqHno?BFH0SO<PJO+SO@y4HGC&laG?p(_)r>BcRq`+ZZ}B-
z0_-`iy0_HvvWdJp@k7=dl(RG%bLO=8ktWux(h3Ru!CJQ9(Dtg14@yhh=|@M+7fc0M
zh`|1GwU>e^waFL7$_Ke|=n1$C7(@`%&V%)CjSachrhArCuW%~^8fwdcplZFkI#-4V
zB_w!uHMwdEd%LdE(LAYzbo!AxfZ!thrG?$A{>zu>+yo%?ZKg49f%>|Uh-r%E^TqUN
z+kr(%szdyYyZ9tunz!<8I_(mVHCYs^)(6uMgS)4l=n{k#B+>`ilCyV3l@dQso~^E>
z!V77|OiUXH*tKjnQwoUPSn`lf!^}L*U)S1$5HEiRMKOJ`iD+M+i+N~TlF(f9c_-{w
zX{yq#;!oqgU^xJuulZVMl@{B#+!tBwDPc(ld+`6^j3uP1rdrs)(sA?FVdlTQmDLGt
zUMZA(R$-1T{(iwRb@>VfV@j-pzlGtgacuZ4DsbinN=#Ytz{lLOvg!1v_#Va?(++6C
zQKQ_ZKv%)}#aQ2W7%P$XAbpympJIP7B-x|S3g*0|NhlMriuL{U69^yqBS3lqZcurd
z?xU#V-vkN4KcH4(V@3fsD!_yznMPhDgvS!FWoZzIrbD0N0d!t=5Wj=wYqxEaKjd0S
zEgs{gs`OpH4b(ZLYPxW*IsL_fs@emPT>Z+DBYh<wDl(Hj^jf`)wQf@}7fOKC-nlz`
z{R&_bg~!uu$T=FYy+~zZ0Wc>~Xj)Sv*$xfjtEdRlTr*@k;DEc#=9nDn87=;HJ9rF<
z<9+#jz(4Y?#B&09MU2-{0AP}vqsgwM)*Tmnn{Qj{3G5Icp&S8V3?zopsw4a6T92xP
zjq@E+<6nMvamQwJ0E1LNO$GpiKC4dSfpnX!I##7phe2+YtpBPWQjVr8DMB2QxWpcL
z3sPouDWWpZwgzD+AR3Sj0>IUWng&MgL=U}gRC_-hvs#}yur2fInTfn;dcg8Ck8#C9
z>)9}OP%=v^q?h&Rj#vtmSknG0BG|Ny?s4`tWSYr?iCnY}Pc9ioMIM3X*+jCN1MQ&$
z!xnr|)AanEAkf}v_+X)%<#jeg>>FDwpJ02hP<XSRAh<o9f8;jref_PvBSfCGyR~02
zjMPDcLw(|Kh+7hp!bQKCA2gmeq~5I*jj-mq-P$x&k*Q039^k|UZLWvS9Kur!kM%>w
z%~&CqU|*7px5w;ov}2R0b~o1jDNPN}dKCJXwOTlCQ5HZ{rnl_W#4vlOMF!AO@H<V_
z49w0RS-EQp5oWYK1d!|`a0b3q+A{~Z+P}(DRR(Oxqt0#{oa6GtGByO7O3UgL%U%L4
z83%_D#a3nG2Z?eYF@bc2@MF{bIp0;&xjsnoPVA?R?>J5Z&?i>OrLAB>&7sU4TTDma
zHfB8v=0C}mylp{jpa2jfYJ7It{I@Q><9)-a^j&>T!lAF$2BpqR0UKOfNe2s`i#N)g
zE=vzan}GaVY9SxR_3s*^i|9U|WuOUQ7c@Qeux?vc$8HVXRs1E&4_!}s#LgcYprQ52
z(_Ifob*q7%3K<-~9D$CLXhym}PibiS{NCwtvx`#a@vyhEAaJ5~`zzneY{tLxqc;fE
z=xKpKq&Cm90FxLkr$8k$wph>iEhgJ!7K-C7WFlk1$OJU>&Vqgajn#-v{IF2*)oZ?R
z?<kSLXY_B_Eb_(_p#aqD!wPg3fyNooz|iH}X4zh<3m5mjHsbgmGZA_%tMN2iU_5`_
z87%WGS>;y^W-{u9gk0wl?O&d}B59MG&bmXHVBHRgVk7uNcP@}*!;<PJF}yr$Amww(
zZZaQOwIuNEnG48rR3e@!h!q{k;>6utr|6xRN`ct#v<i8c(-03fSt;!<VE~_U@7HJI
zKNyfm@XEbeVxEr&PO2DPq!~r{N%LGVW&1IRy+X|2S7FWHPG+8+gE2#aYIKrx#guGo
z@B2#+vwiKL8zzgIw;Zn~p1qS(F`o)o-{m3=3u#+x)m<YKe7c=^ocPaOyliQDZmdYO
zy}js**xJPL(O-M-_Da=usB0P2wjC@HT1bPw?LSsA>goP>BYEVsrEK3=kz}X7O<$R5
zTi&9q25qz^g!@KpEpxJ<GgJZ~!JngGmbT^JC@bfsWE*nDev`gnrCCR%<|_knbbt<i
zBMfD^t5=k(e#qw8W5Gmf9Xm-7%=(=0*B{{UK0u1bk6`epe@i)c9Q^zj_bX8VLw$GO
zSV<+atXH#;+#?>v<(&G`<7tLr+#d$ErYi*qcYvkeFX50%3J)<0si}!J`)zVE+EV>=
z^@aVQonP1M^6a~2Ov@`f;a$SOd?>*G4e)vE!}bew@mlu*Taj&jyKdoBC>>g;3k5G!
z3@oAIJ$1V$uP=ns1KesQ|Kc+N!j#t7)LOQ-VmkkH-p;n-c%g#@e!Bv1?@+&wX0xFj
zQZEMxO=@gHY($w@Yx4dWTyN4S+G(CIbH*puS-rF$m8WKv7w0b<z+@xptI3_sniIZj
zorOS4c(^p>gK?m<*eH*RRz6&w9LDO$>&jfCp0IOr2V@v?<UqtK8tvbB4Xs*pz(D~d
zTUIRL7yl0?yUG+0##k?R{n_42li-k0Eq*co60@~{lC@Q)eQ@vCyYaGD(q{mb=;-3&
zO6?eUt$wJg2Xh(nc4<xYblidi_&+ZeXkr265M#j^uij_4CKp5r%ipA3xD0Z;uXP9!
z7&@`aDos`}n{JI1emAwFsslen;HP3BhJ(zjRvhrW%2vKMQ6wwgP5w=MjOI+<6$Hq?
zp-7H#N>#-;p4=NBf~}d}6?ifDazFaXm2c^pMLN7U0!sF#kh`I#5QC$Tt?|2kQ=_{c
z{@W+`H90UD!5!6$K4h(&56`{vYq!Y)I0oSL!9)%quZ`YEJ2thSiRew={*peNBK>lo
z?dc5IfFZcrcmC?Kyc3!bGMIoG0Pw!ei+fH(X@EJ*8cIcPw>e&x3axbZ&<JN=*iZ#-
zEx>WKq0J4x>a%l4ALsZKpNswGW4Hb3`}RBQL-nVN*!JnZJ0wBO8CP$B5t(tunaBC&
zqIATR&@QL(W~u3!y5(C|U<%~f3N5DkoX#}O$+L%N9a#h;v^>zx4kCMYINYYIoVN25
zalHBK#ttK0$lQcEr$E4chVzKf9EKA>k<JEay$`gh7G0iv>&tfuHNv}m3b|45x^Xt5
zcAN7mn+iTE^IEg+5}7E26S=r$G#XWw>pBhd(9yqqtnlu7-^8}&n<jswSVo`-**p{R
zWhJq=V~FDV%XZ+?&i!WAF$kCx{fQ4^7?Ty7k!^&oX}23LRKoAm(uGzw@=v!N|BqSV
z827ebnsaY#+empjg&&<8M!kI!!G4VsE)Fo9fV}`?dG8^yRL+0lkFo|`h9VQu0}Y)a
z5BA{vguK!a1IK+1a+54MCzOWwA~sV%?grYB$3I0Wc(A4Bkom60gBTanfj)1iw~a=V
zi<8a0`aG46SM)7VCxf=E8Yvjtr`6j@_BM27Dq5hK$HEI4qIs`S5k|NRlwtR6S8JTu
zC;$kCLV^4a{Pk%DdQfE_s=*zGa_?so`3&Dq>(BJcH~Uh=7ONco<@fTSEgKn;VPjLS
z&>sZqFO@$=w+>1_qc4k>;P6dJiO>e)q%MPL)wk*n{}-NXPb{i^FZfI!rk<X9D>7lg
zyo7?^nX!|=q-yW!ksa6Q#*KR!|HPGqRM%P+<&x3kNXvhvHeI#uMcFj{L(Xx-EHyG_
zgnAS(A(03a&N3R(q<*9MVa5!QzJ=V??>rC*{EAvrotVVuY;by2|In1(A^xf5^*o<V
z=*D@Q9nO4Cly!DgK!iFT?$TX@_Z8a@wd+OZRkn&XyaqFvQ<1i=2Q%1`7V7MC#;~8)
zlzHrE(NqX@;a%Mdjf{9PQGftJ;M{=9+|l#f)h%)^`gRG8DEPa{JmepYoiHU}YqMcB
z5FQT8KCkmkcg}H1F}p?B|D9dH#)vMJhI^nGNTC_W{w!N9KgL$;CFfLG^+!>cS)FBv
z1CGUDe^@nRvTbS3a7hX<3v=7a;`EE;uizzGi48OHIZ#h)4>IuNU6hdMk06ku1)-uV
zf3+nYI>7OA|2?5vQDs|S%}IL1X1+u$g~%}^U>LH%i48E%-l5ecIe|e0=s+*~MZ*ft
zg#iR?<~&p4sKqp%>XKFWYeTGeoGKw{wa%9?LcCRT{wPGoq67Smx=!u6O)D#a%@e?!
znbfwDe~{30kdPkG(aAdESBJuBstjJxZC^>FL^%+%i?a>`0jcJK&Y@;`PPd{o&<SmE
z0V*$1D7~C=ENIthG1Y<&RtI{z5j5J*{WHGH`v^Xih}!-);^v4zhw>84evlASp724B
z**9&`fl9^MbN28`XRr(aV+E{1TLQua`F)(&z*NpBXHBivk}0ko&F3c~&lbEBHNkuR
zF!F#jn=N9JxiYz_tcz7I*x~Q3@F^%8bn+cUBL#yq0<~vKEX$6DD&PvF@5IFZ?(IfX
z?oW$6%xW60b?9n$QSTkPv5oLx15-HDoTTJ8ns{M<+L{PrGJ#56^uO->)?d9PoYtla
zV7SK3rvZSi0MgL9ZP@exMh|LpzeP!bU{*j!8AujqdrZ$AYXKGjr#ga5$9*V<gBvRF
zV9NVlcVKAmDrh>D>|9^r<g)`V2?{V@mMC?M4(PgnSyn9du4sn5{NHIJj9tyagS|%j
zFP;&D6;PK8CXU9&X2z>4y#U=58$Q!e6#@0t65Var;|Cb#FX(}$wKCxn&&>Yiti8|7
z;T0irmCtorbg2a=2O=;FkYa-`8%xJDbwUj!InZtiS~m~2f!x!M%rz8U7SKuNAc)iX
z0w<>bDT|T#c`eu1ax7@TMJ~144oEm3J*=isUmWN|C-pFD;zt6B=SB63-pE^Qq9{Ua
zKz0V@8tU?SYDV-P3pG&Z8(=%ni*iPAYC@Ovz_U7KOM0YHgu^6WZ6cQe!OsH--M_7v
z%t4{{>*4a-0eaE1=|B@65izV}Blq(U8uj*RE$FmXjT#6f0xT}i5#L}2w?F<?0WhyL
zG$3rGu$f~#psOAQeRG8l`fuE$0yXI<<NYu_+>xjK7s8DcvU>BpUdMv&vz5-5$v?|3
z2w>cRz`{SOQlW}?-5CL(ww2Dx+0x<J^lTRZQBg~QK%JYthH8znz(1Zw$Al%*$pDr3
zBFB7Vpt@G0%zx7sk(GQxLRCE4u$fu-<@kfUICOf}r=mD|i74&Bg!%ax8F)ZE?Lv(6
z-ue#ZEBkqH5I(jfuaSvMT4h_i&a`cZ9LlqCSXc4}0#gKzQh8&yt|x6B`Q!;re2U%=
z)@2p5>}CKH1u~bMT?#&=ngPg6Ko>fGxPhQ>PVJg`J@A4C1n4)0q{JcsPCeA5b+~u5
z_z|F@b!wUkvB%b|yUp>-7mfh<S2ZPJvK0Sd6@EfS6J~dJYa#b+`JuHcCT3Y$HES8W
zg1eR20S_PN`2S1FUz&ywkgMVVya9|ZQHu)9JX)wU1}Lp~Uh#_8&ra%AR4qZ<?^X^v
zQJoQypKl_8%!xZ0MQ0l=>5xV-t8O!NzNLw!^KKJKgW|Y2Qy=(VUtiox7zGB;Ndo|}
z+uvV4GwP_Cn)$`GHK`^yS-~C%UnVL0KW^CPnmOQ`fBDlzp`^_7y|<eC(RbGM%+uTe
zuHqFlQWql2uu<7Tx5SUEoXcJmtJ*(`pj=rhIYk3*7Stw>WIk-3{fh!jZhBi-{6F1X
z_g7Qd7QP0?FencY=^>~n^DGQS1_Dw9Mlcva6o~?pfIOus)kup;C{Lt?Cy3Id2ojW%
zL691%4vdIFYDQ`>Lk&`f2?-_So%sHR`QfekA#2^Wa@Sq=?0vHLx4-W@v0uxg5si*@
zXEW^1(^;&I<s#BXZXa)KY-}r{+40!d=kvTOX?&v|w`=3r-f%FuNpIF-!VIEdfQ;Zw
zc|EUsU3pKqG;)7;{mltwB>2rV)Ldo_`KW`PPrZHo;e+GIb?wjNfG;qr=htreVhbjw
z`sa=*2|;e5qiD;qpn#gzqMJ0jhj!5mqHR^c`?`v1%X<IHqA|V^FF6f4KN2S~oV5ld
z6KJQy-}qw?R`yP02%tpho38GS82iL{T~_rCm9F3NF383E*8xzh9@T&w0B%NJdEbSt
z?n}x0QWJd^M%#Az2PG&^`qh8*$L5-%%3iX*ydz*5?G#`?g_~K(FY)32b*4?CVD~n`
zlQUbte1JDalAQ{c>Rr4$G(So}5dI1fy2dK+@7^sh5>*eRbFYFa2%Wyt`07i)#sR4}
z7eU2to){jzi3X5uQM5%H19$ILRss=;a2D<S{Om<<PR^Hnu~rHsk<CxBpY?-|CP?hH
zDgzCvS+<TkBC!0LBnUSGmMPlc$_R(=I=mCCCIjvSRQSvX+gge+pl|^V9UyDr;;gyw
z_xiLuVYH%0er1mJKvIELKja4*k{P(cfrRp{z-F4*7gzk8XauZ3rCBTapT;R)<+NeI
zS_ah;g0Bv?d=&<%BnFOS9ScE_F6UZMFWAv8EyJwOqxninsye;1wZL?<<6)KU0$RpD
zDu#2#co__cM&Ui9zg7AY%3nIw`R-Uj5XF1#eJB>FRL{q@#fHZfeEualNdt^c9I5bM
z2HJgu{0gM6O1hUyw*f}({=*~Z09)ZDXA!wRHBmm#TzqWNTJ!vWT)yFsc<WV1jHqlm
z-OYLBU{mT>=5ZSck}jsImrp2SjWn<)<ez8)(t?VZ<0&bqNydN@<yJ}cPkrpqd#v_h
zS~LkPn;l&-7I<AQzAk%7T%r-VJ~HqU3_wi*3#3S!&9wR}=Nobyx0_J8{q?{A5fTDu
zGW&P&bTJbnpTU#fmX`EF-4bwhGB?WI#>NNZQtz3MSIzI<b>L=FO|43-R9>j*^~-_^
z4rH&3vRW@R?Z3phEZe{2I`P#OWnh3>b(pzi|D87wQ~?GR6IeN5&3yqcHD#6JolC%I
zCa%t6b4zVAcDUuW`Mr(#v*b26XTSE)R&fZ<H((cfnwx1)<L(1iOrQ05<x{A}1?p`u
zkhlCA9d!_d(2Gw7EoFGQd|=+6HUM0}HXK>7*pzfJPWW>FZG>5H>EGupfMdRcJk-uj
zB<-xUZnUYBd78(Mg4IGabz3RW@ba#Io-2J5GE_8JW>*}FKs5%a3I$Uk!m|)66+Tn5
zYi6v8qfI)KA%wB^o>sPm;D)*=L!b%;yXoo`!YS%EB`0UKZ^z0jl=>coK1u|CubE<Y
z$LeW^pVrklNbiWOJ97Sz3xv9`e^1`UXQYP-Co`HM1pjnmA7llgI_jS(H)bP6*+E;8
z@el(uQBuW5<vUT{%C#p>d5ov1unPB4APVbN@3)}%!JwdXjMSJW7`s;=?g>M#cAG5B
zHMI3xa@S1~!%SuRa(jPRKK!|Y{>wjgriFy=&;$IHaz{7P<kXo&PQlQ2HqbkyG&rvq
zYvp-^4Q41ue*-r9-&E%^e6for?$3Qi&J`KDZq)93I~hbv1&A5rT#?dU%~(TOmM}SS
z9K)$yyCPBxQ$O#9mQfPnj|ytR_U7+;aP~2^1+*I3oEfH?8ER4`RI;5Rc5Qb2AkE`8
zP`%O@hfo@#l8HV^2($EoIAZ)MM6~Nn_C@g5o?Z#xMhkn<<+8<QL2+C=a0DfF4u#bY
zj9+(mox739Mdz8Jbzw8%2eKqqQ;dsh@=De#3c^QgaQGP&5Hy--*)OlJoVkQdfOn!v
zGQp4M?s)LHSLh4ZMiQ{uS1cD<E2uPb`if5!)YTA6{wb{;<<hF`7f}$tjOS0;nh&=z
zO;Z0Lm{)n9sYC}BUu?tiRdBT4wuQO0t-Q2B)b6@C4qb+lDc&k5ZrAlk)NllnQG7tj
zcGDxR+-IT0q8c%`9pFMGA6WK*wVU`Zb?Hc@a2(#m9->eET;Qtul=r&OnN8}#>ciRJ
zAQ8oX>gdaMWSFq%&CI3F@ZCjL8M6hI+!Qg6f57PJ<B&?>Y>eh!y1SS5JzuDJTh2n3
zM~&WB2xq$>J2M8fDE)ySakbRE5qHI+eTSe`PeEtgG{N<F?%SCd6J|zbxKB%A4+>|j
z7P{;s2ibnVKgC)qYe+o}F3s9Aq$LM+z4W1|OVgvw@!A+_XI(SIRLX#y^!77;wb`gJ
z`qVB+=yh&k4(U=L$bsqFsFH@G)Kp~*>3S0NB!le_v$@EWVxz<VnK85y!lWRExnJl_
z`2t#Iop$6bKba__mt=FHw+qf+_w|xus~~TUdm?lXr*Xeo6a$HD3%x$B+P9D3tD!0|
z_6Iq`^db5a)OVAvz?Up*hw)_}J{4oyF2q2PVsMJhSPA~L^-2CA{%KYL6r7~EdUWKv
zsB|hCA-ly9sCK_Dp7t~H&<$fa6-*s9H*^I5xlu&Yz)Dzq>#JG?f`r4`Rk5AQoBO%7
zC&oi|^66(L2Pb<3H%P4HsycxKSC2T+Xrpi$<Qp|lFxf8b5fX`6l7bZJh@2qlZr<6*
zt*bcRT<fxl2J4w^H^HJiB(S(CjPrhk6%rj6of)w9Y{tqaxHU?mYX;=Z6LV=ECCo>Y
zqg4}@Z!fM33UpKV@=x!f*hgqviW;asF0%@V@Xh?Wgk6-5mV*!mzVp0wVjAs|RZ|sD
zU*ERd+-u6@5-zcJ&En&nU*L-m=5&Bapym|U2xR6pO9cMUl{{Y69r|`y<VB3FFlr*2
zYU^!aeTuaj&|^#9)I5?jJ@b^H6`og<Y3DV&jz+!-AtojEGwL|RQ*4qpsCJag-QuDL
zumyA$eEy0HfF2-<_*s9!h4|e-_xe9Pkp<rA?-#W8lLFBm<*O+Colz^MIP~aqjz3me
Hd&d431hmiH

literal 13506
zcmeHuXH-*Nw{Adr5fQM0AjN`o>Ak-o3etNof|SsE4`2fY6$R-{1VSfDCo~Zu(o29y
zAfQqcnv_riA$ReeGwvAY-23Aj<Geraj|<uCP1t*}%A9LH^Lb`o8tC0;ILmex0)a4S
zY2G!0K&ZhbHRQ}+;ItDuMgph59JTM?g-}kuKeQGngLmkBH7x@m5c*3e2NfhU`zm;o
zHc(4fgZAf{^OtDP{q}Zm0&j6ZO)LV{eZ0J!y#v9o5Qw_J^TR;rN7qB3fo|9DYv~$1
z5_YDAK(0fy?*45Oie1BnMcRbGHYg4EYTR8Ut?p;tu}-*cncDDe(9t!7omWroVv?jP
z+x7SLsy>emMk7u=pHkz~g+9<ez-iOd7@fJ(r|YIBt&mkCn{^45AY_^P$g;l9r(neG
zo<zaO1`}_`dHgG(0Zq08Vx(f|pU_af#r}ik{_MSj+>IpoN}Jpb2*lS+%n(e$8PM67
zlOF#A7w1pfp#sN0aB=;lt&=7C2QE}WGmz8Z_y;axKr{cuT>YyZs+f!aNT>ey;Qra(
zfsy_LEBP;r_=i^VUl#H2tR(%@jEfG+mS}Ws*^kOAG<qou&L!WSjNhQkgyJmCYP8G(
zkljv~&c+s;)o?tk;j|U^k+Ai;)FV{KwoNREq~^X(=f-!n=mW5rFKP?bMJv?=8(YJi
z;&JWi>P$34gT72rk9&P@0JeQRr6s!A+g>xS`IP%A+ek-pXW7P8LrLksJE$BkLXqoP
zM{16G^YV9)<fGfzHmqQrloI~%8bhLoPqRLPi(|~A@+pCxar^#>u`jN3XAQ><369(s
zv61IxIWDy!RpO4sAU`=2sa2CUNCTu5rZKmHq<#%Q#pd;yyWc<5gUJ=GmYk|O^r<v`
zjM5VWz8q8Y7~?gf5?!L#BrMo<((Yh<axXU-M{AzD*+u#0U=V?gbjPzAdd!xPPF;8%
zi;|L;uA<ZZ?j_UbEYatzZT>f0H^r`4U@NCg$hUW;-Y^t6p@TAP>$h{+A0)iaOHw+2
zc6DXci8g#}j6-xf*jKWwW5n2rd<{t*-Uj{Iit*23&M_v8ggILxKi$0Vtxzlt3`x{A
zUQrt7ulK9A9v3oQd>B$o_@U}Mak$2Gx3(r<U*Q_*(Szhce&TYO=>alSqe^_yZ=MP~
z=WEso=B_$@&fYf<x;#FsJd^$YWw_&|(Of6xHMzy)f$5Ke=8O1K9`pxuC)-btgG4d3
zueYUfYE4C~0zp}PvFJ!0|9SZtr^0YKig9O)mO2Lg>FW85E}hjCjRR{=Bk64i`_nc@
zRKSh;9}|mm8>d#iISt}`UO7^M_7XInV^~A7mKgU8`A#N6jDPnVSHdh-;Xyvcf$GDh
z>lb;@4_`LxM#o$^SbWm;9$u{&XLh;K1RvxcW)~~IhWDT9_n#c7w$?d&-wC|7XbK4Q
zcgN%|8wKdA#x>s?8<x6hW|W&NsatY$wiJ1>q3o=UKyP*VuvZE?Rk(RvsD@uR|9j)T
z&N%`rr*WJ}VW%w>hpb!$IFULXIEQS_PThT?c*w%ShkG<#61YG{@Fh{3r-ss_x%)hs
zTQ-q*ur}`s1_b@<f?ryjZTBy!TxCrl)J^=YRNrpxQ-8=^lrvtJqvQ2Xd&(><s3)F%
zp&zWe9VI>2YZcw;6I5*@<wm7SU`y1(`*8|{vAYmyZeAArJKHR|s%qQ)&>bOAEO+=j
zu+h`S%Q6FTM{s+5f@Qe9J<vvko%O@dBx&Kj<pLJrk<8n<mhI+kQ}8M2)aBHG1Y)2%
zqHXU;jN#Q58O$<2k0^7>xMw7<iRDid`<3%unMDFVvEDZJg?FTys;!d`rR;K-#xOn=
zBjuG(ksB`;Yj&wqmTH#+%u`pA%BG*ShamZN!2s%-#P3tKbjoupife?D67^y<(>bG$
ze!*B$U5!gl?;oQk@K`Att@i!A^(R}N<eyF+rWtvDW-~;}pTQulrv1D@XNi^EHB;nD
zuYb{q0x*ff`1<4h0Fr$TQZ-DEzUzTulW=+4_Ag|O!0GAQHiJD}ixDSkI;TOVN@UEu
zs{H0@;DTemf4=!ndwIGfAMeqYIqT{dIPmvEC05$9%msLzHffutq%Y&Q%~Mfp)0yY2
z%@$YIy;8D$HQDY_UH1!#)2oRhmNJOz&Y}Eg{qojf6<SKiW8t~%2-=8`5t&2t0nZA=
zIM(QwHA7SfS_|Z{G6K<j;Pvs{aHHBtIy-Z6wsej7noG)(Ysu)!7_um%OgK>gPy!hB
zuo9DuFcRAqLRHl>ZjM0Y?(X8+-tKblLBV!Z3H$rt-YqspjVl~^2KDHVV5gLNE^KS?
zt{^~LqL{qDIHh2{v(nIf@c8eqBXsBK&|EJFMCm-?^zMM;I&CFV5AVdvJ2EbOzfu@Z
zn_KkG;4Y$;k#NvS4zCR2TQ}%am4&OyR&YjJfKFrmmQ9Ll7Md7s8{n!kRe~>?%jV#{
z?6xKum1&u@EVfGJXR}H6n2Pj?dLl=Z(msK%bz1yGX{`3{zWz9})YT+$b>kiC;RH(N
z&N%JFm0nMAZ-&GE1!pXJ5&bg%Jg@v2h(%)*iLeQ!foN4*50IWR+(s^B-{c^$k0jhD
z5$|Q`SGE=?9%RG2_1dF$Nm{MbiXYrOcQ-H-Tw@`59_U+#$iTh&_(pZy@$yHb)-grm
zbCKK8mvu+es!HFFdrl`^IhVL{%y9=h`NunvjK_Roc}2*}lPkNw7ld!Kc3%k6S4w~n
zc#g6(m@aRtAeNrdQbFi3kCShOm$lsoc3MoHP1oTWPkB^U#ciCII?tprK8#n9x@Egm
zN)eMLg`DhNlpin~ANK9r3*;$UHRQ??k%VQC!rEj=ECeqc=vCSiMrP(Z6X5kBHlOY~
zA9Sx+WnVo<$c<wgQx<J*-kNCppiE9ClO`(b1Y~|Jk&F_hg}1raHW;WOZ_m%pOqOM;
zrKK(mRunf*c~68nPs$@!8}85nb6}gHJ5A&$h8r*>=C!V!jy}$#O>Rqc(;@XDt`Vat
zzI6|0W7f)B6L=tx<oc0bPA`8+KYjeEZNE>Qpfl`L-llqYPjT!+G-Y4D$<vs^9qoxW
zqJ~_IH-u<5I&j0=_cdDO|9VOnF+`ncn`XL%N2lGvgs4>C(~mr+Cilgy1fpne3k(Gq
z>~OQ@y=^0!By=;7F54L7wz_dbBIl1T%2gQe!Cu@&1r4b)&^7P3mwU)o9Ok-7PrDG4
zbnXl-*qqF?&4%XPyr@4hyLp;}Ir)?C;ZoY-#GZsS{QZzB%&Cy7aj$Ff^Yul>N2e7=
zCCZe%jE82@@t;bN!x>vBsIESGcbq16>S%8Y=e~TF+nEBkvf-(<?vQ=VSeV?6zad|~
z%3OX$sG)?Z&Q6WP9YPgL53RuV<SHzJMkohWDF;l7hp{W-9u(T@l4B9(ER9CTS4Ap&
zQ>K)OVRK9x#5o))nZ(K&x%TYW3X7R&GS3-^=7mcS(9vx(`BTw<QlnZMjGbOCmwA8j
zRwAC;bB&IC<85JmT`c$d4aT5-27AN~Jc?em1sWAy({6qIdH%0S%v2;{OBeUq*U~$-
z#aob<8??wle*B`1ykki2*xOyU52-6{jg~Au44CXEeKoy8I?VD26M75Ty!Y_3>!dMh
zzaK8?Ws&RLIItbJ<nlPT)sOSk7;}>>7_BOS_3S-j4Mrgl#WXv?8`Wa264hi&<c(uc
z$QbB8SePWKG$2wj1Ef<mzv$U$V-(HZF(J=o)LH+^p&%n~Nb%q&DTmam*%z)P<k!*A
zbMG5b_ot=Ke6R}FU%ub0&)4ZbTISeb#*D13{$81RGtEEyC6pjEFfgowGb`3t2~}-#
z*r_P>3GOZ}bro#YOL;VDI{#Tvu(Lv^StHm3Da6y2v*v@W7B_0PL?Vaxt4Ke!DA}-7
zCqFBci+l?+h}nO$F`#yU&->Jp>klM`poY5dw8x(dk25!!ny+SVZZ+JVWQ37p-C^tP
z1ePE~%$8zY{lub&u||FB(f}^!<3Kj{^~)4HOoedoOUbJi)0KCwLm+-25QdkA{b_Al
z9DqxLwgMk&)Pu(aXB|jmJr%Zu5wB|rM0=k=A*7X;&EiN7ONzVc=Lox9AF1M99SBWE
z_noV#zn%o_TE_lX@|Nq|=DZHMzM$cB2^&3%AoG$*4J_EYhfVjnW@}A?ZfBsQ5*38`
zMlR7tFb@>OM5bwk_>_+wENm+%dMc;(>3VX!KJ_IHQ8}uFX_*QRBvAAd6`>pK6d%f3
z!<r7%*n9hUFLUrg<~`UI0125}>F}-h|6(y;TwX61ocH_Y!xl7ohxC)AMt0kK`5w`M
zz3q*QaC$AyAxSr6W)|zmki7R|uHRa(0uMdvczga8wQ6s~=P=d0NQXSD@O$t&a*)Sa
zqbLHFp-+(%XYJ9n&--E^Nj_xUOyUmY0}UipKT)NEazJ6*L4;J8dS@?AD>mo~CfLZ2
z$t5MBtTLT2tuhljhid1qCY0p|+||Y1k_P~3?@#())DIbG{{y8vvgM^4w7g3P(6=`9
zR7^(1jq{M0_u~o|M^seMWeA+XrI0CNQ3gLNWRx2gc6hdv#)BKGD4p-h7EauM%(<o@
zR&n*xO}3AUVD0$5&5heLBkuiXTq)xZES}%=svI!ZeYfeVB6oGn{J7chPV38+ru9!k
z>k9J*vI1#2DE^bDgmjx3_fQOwF3VE6_k_+RR)lGEMYKs?*q@kt7ZqJwr`j6x6liaW
zHJx*jXj@l6+=g*L9I7^d(kBdB`z;!!1$GCV5jvf6z$!457w(_u=Bc)K4CnvF60Oy1
zGarH?`|-^3_tbB9QBy%ImXUF&-`;bd3THUhy2a<Z-0eI#OpNvYT`KzQ=LLsZE5Gn+
zX;*VZepZD*n34G-`^iUzSw=qB9a=1pb3InG8eql9U0Dfo%7Pe0`3&UC6PX++RQ=sp
zL~b+pU{bR#uE)C4o5<Q<pB~RP_v*}~&AR~>`qL1H`~(@M81C1xuFQ~bC$UZpI!X3}
z&<y*ZQ;&U(cC#KzmBK|2=;;Ssy;c;C;#pVQg=R~Oc1{5ZXYu1f^>2znNO#zx0#T!P
zKPckjA@h&9TF=wBJ{PX;Wy){7GJmL(f@P#Ba9<VorfGCHRkjxfYxsQi_mw8U201a=
z8p!#Lk;h6e=N8bvg)YzeaUWA>@Zc8%;+N((r1R=h^agG`oSz6tNJ;Lnp#lp+p9Dgz
zM#^R$W+G(Yb?3NER=X}dS++%VhQ{C0`?o@wm;G8!%?;meOKU9<c+Gz;k4Xhvpg|<i
zK1g~DfgH8@;Hr(T9BfZnlM+RQQ+RJham6&eIdIuIhTZBOnoL{d_Gz@pn+*+}drr4r
zV)h<7PHFt;Id~j=(jpuCYeG|JcO?Wfwy?5AuxVQbT`E>U2wBfkmf2v?h=rEGbopXQ
zV=l#F(e>chwzmj>UJtl&@y;pA%Z6m|LQxpy^YH-<b|3mr5BzWyE5Zw6%!lyU?QP4c
z5Hf20QvB6gYJd_zOGShH1M~Du)DT}}V6qm#55zCL6L<syG1@D)tR$Sn1}BEdU<7cN
zDet2K?J=+R(4!uTBZFOn{+EI;9K(nlow0~!PZwCQc7{uH?Q1C|UHkUW;e)8-Ay=>2
zAV<E!xLvk9E|3+s`Jo?p*=ES_28m@Amb-87v`(3CpL+W3*sh$=+YUdc`Ak7ZgzQzV
zqit+y7h7d*T{3WGGIRKue5~5pMBZS&G_?C@o{dqNN^^@&>drn3MbBPyPiaJPPW#a#
zMfkM|U0kn&M3%|Bjj{DqDvgVg701Jk-txuYeY4^ti*2N9X56l2jwr_~N#jDcA5@AA
z$j?!BQO$`%g#E>u`eFrNM~gJGg<hxOUqeaWqqj|)tWupYGr@V?A74@wwQJT$!`+VL
z@gP&Ady4si_f&<)x$}^>J7Csq(oC}i19oVan4!+^tb?^PW1kw*e3i(1Rm|N7&zfKX
zQ*Vl&cD58R()Dp^Z-*UePQwFloho=}+YDFLn;Pr<o%%?j7FK6|AY3klhsNvb@G&b8
z+b3;!B0EZi`TF9U-*kW=Hj(CXvVW;}EZ5FVd1+&~>^|MKpRp_bT9KjTk+;?bRrZKL
zx~-a=X@n163+et|9a*g0*k<sYGYfdTq%2#;L84z~tv9|DWsx^!1Xqwra|ikUEbFl*
zMD=D79_dqkS^A<Q2A4JHcKD{_1LNN5z(R!&PUHf@X59D^li*cWb3Sq5nx4XQ)<|(7
z9%qG0fuSJ-jW*-*c-ykv4*#~q^_2;gRksYHU)0veBIMlHBCXP2MYCA1eNtD79C8ny
z32mRvt-rD6&1wLPv&VIwa3h)NZ^bL{0$V>!OqWMvoh<<dy;UAYV18drh^X~S2{Frq
z<zs@YttbNw<F1lkJDZOU$3yl_XT?6I=ElUT8y=_|zJ8T+)=@ail64}mY1Jic)g@)Y
zwM0=w-8qcaDtG0D!mQd&_j4@?3o&9o@iiO*gTc#Ngn1QhSb>)&z^X}a_ejw`K?IOD
zE_@m!KT#8rW^&V?dMhoIXLpGlyI_f)nOOd~o2X#*`>z-i#M+~}<3rvoVw$<Rp2BIN
zfu7;f>~prZ=3iLY={a*CpO;$$3+?Tr8Vz5Ddn(GZjkmY@dd|FA^5OCsbx4Af$uQWl
z7>?YhepX`%p6}b{ad?<pu`!;;<!vC!zL0Pl0BC`apXtc^3&G@Z1e1qQ<`1Yp7j~*B
zZkCXpHb-E(OH6B*FMMafU3!QoCgSPaWeW#?{mJH>jhqM;2T2j$SOtez%)QWNVqvm;
z`o*)bs?YjQ3od}%+F4;KguGAYjU*8O*w%519^Ks}jNCYQa-mY#@0zlT$|dyL{5aQ(
z<+_5WfLlR*LQm_gDXgPyRS@P4lm-?`seD*2-qn7&E~no>v<$@*C@3wKpQ*M~doP>&
zfhha<8<HJtrN@Oxd-G`c`a|%~3oVkIG0x*nU`;CtYJ03fg_)%mLU1KiBxyV=Cwy&r
zIGe*GwX=dL*SOHDe9Lq>19w`}72DGXtb3_S2t9%QrkJ-!bBolGuofO@zjqiuj#`<|
zc*W=rcCpg`WWJC{VHN&gE4YBBQiTt^OuNgaB)iu<(0tzWfJ@aBi0dju0^dmqul0t)
z%jmPK(=VZW1leEX4dU!Y8qO_0herhs_yrI*1cw4js!j+!;X6Hkd>E*qS*%8|HnJZe
zz!En&OKGNBv2yL_yDa7ly^2pijgLxvyuTadfy%dg9n0JPqyIj{;!K^CJffkZAAK7T
zB5jh!6PCH?$Dd1fYZ>t41?u5-&IYFnrq`ZAVl=uv9~f(;+7`(%rYy?W0*>uwqOEWQ
z@+7wgj%9&%7SFi+@{ORPa{fC56ZMW4e^Fn^VLyxCSJfO)x+M>?3b$9r`#a2!w|lE=
zk=({t?222w%M}@GDqNDgos2}qtH5J9ZDKiB&y{}eL&zi^jLk6_w^)A4LYvqwkM`bd
z=-px$_+HzyQs3jOoi^Z^)a5xE>Z$h2P3M-=9NXD@<7@Qzc>_%p>8bp*)W`Z`LtVbt
zj!z)qD=E$p{QRe=+mm*#g9D((|H(y+Rt7(nZ}3#m9#1DmggoK>h5_J02xOQ#MglpN
z-Y)~3FPR7nIJRsUn<tcG%=0#*Q5=^}{(kz0)k;n=dC@rXgnw(R5E(G3LW>t4?#T9I
zEmCzisQ}}0kmN0nkI!t8!!2Er3KP#7<x@W49P{cY2E8CZkm89SPaw*6C33j3XmVF>
z(%cYkTK+(sUmo1`Nz{sJi)B3OL?p=OVarP2nMGt5xEz#He=*6UhkTM1WBS4#QRAh#
zl-Ax(8>LmRUZ)`pm;^0sTRDBUz`#KIPMwmMI`TvIJ1PsC^akn=G!7j<!b<jDZ46#o
z5O}&LL$W!UJ{Nq~Ei&MoliPyBf~u0F<VAEZAsypU=Q{p0+9{3>anYW5L#jcb8Zdf2
zl2tvr>~&vFQuQoDU(NfuT0Ih0dw|TAFbaeua9<e*@m?ZT5}I{*dGpE0(g{`i_PS3k
z161^U?oM5TK!CFZ@2*@707w7@@WQ-A&rblx^q3ED+N#xEJcUb)`p5mahq`%Nj!MQX
zrY?e=naX&NA?e+h7h)j3yAQAaRGc)NEdYKmiTAMf*an2%@6<EW?#Hu}!wo;(oy3Yt
zg@*EhE1HJqSmmbW>qH=@rE6@0YgU<)zmBAX7l@1`>I*@P&&Q@O4gadTAQkvpXx|_i
zPG>r=U~0W;X8Kqg1irJ=X3p|L)fwnVQpFzJm)}Ku+H`ij&^s3!SQ2m-B$?x*3T2xw
zp9cz^B#D4c1e}%$^o@G%xdh;cx|)E%Cvee~cgn!Kt1h$#^%p<o=-fC;b8YA{X$~2}
zBa@7m0u57bpL>^Q*9T5kx@71=&uVl_v2mIY{YjUPyuq=4cKJ)sLvVU=c%J%;WkJ5+
zhvcU>Qgp;={(!);CEE`O+nSlgk=|%tT6K5L-z}$Hzpm7~1!%mHMtmO!d6MM-K6Xl>
zf=8|*iMO+C)JCf)chBzHf8kh}#}XF+4~IpH>jM<>UP+_4fA2V$)htY$+gZWHI=i&o
zENoVxZHeuW`0cUx_|V*}2s*dw1eSCMJ@56?g$V&@CeFc}vY>E6a7G8d8=K=otAmL6
zt3m$C14r61+Yle|NLc;$>HZzEaegq`)Ovoj-qg;v`X=g+1$Pfrq7Nz|IO~NjOVaVG
zR3dJ)9*ZeW{U`<z%Vfzno&GeH!{$_23CJ~VNXIJi{JQ32^Y~w_wly<xVBiW&#Qv2{
zg-RY<+okc{aXZs+Te=AQw1Eo1_SQK&w_!=tq`kB^E6;D8+77QUH(4U=(m%N9pAF(Y
z261PY=s_O{vLvQe<tkUU!$qOxLM<c|maiP<SDIa)L4FpBlZFvS7mx?pH*xI+8X!RC
zNQE3F6a`;Pi`W^VPjef%I8-rv(tEFK+JSvdUE#=l^Vx{w^uO-ivH?U#0tU?hOa2Rj
zH>rW$q>g#GP02ri9wW9~mb-}>SfgaYW~rv)pIeH>ZBb6I?Yua~VEU3n2Z;~Da@FmB
zSmlpvC)GgE)zjx-M3Otq&FN)ZL%FU`JrggvisB(-;sJv?#+ENOdy$&6JcylXSmGB!
zUS{GR?DLrL5Of5@Kn%d4bkQ4u#+mh%TkZkQZ;lr-%#<u=dAXT#AWI{g9dFs1d3?Uw
zny#7|!h_5<>_Hk)=D1ggkP6%f*jrKrMJ6X!qU$`)CPi(k;AjA$(t(;N6IXE>+zso*
zQj=FWJd%SqDLDoJeyPlurH#QZM|hGN603B7(5wdLHI|r!cw1GwwXgi=oOLQ-ZZG_f
zmIo^oQE!f~66{O4w*jI4;#h}v(~AkoJ>XebZ~wJ=?Jy4rTMArN+Tmw3lLIj+3n#=-
zbtVhSTxiyLq`}9!=%)TwYUT0%qLHmtO3m_MbC*#wuu1~pv3ut}^;@n1g1!V{W3F-L
zIz&isNOIR*QA_Z&-W8BJUJ8f*TJ^LF!1g0I7E^kAG$#^&JX@c%E4_wc5zfq<?B^kq
z@6-wC{H9q2wp(rjSIWWO`Gm#Q=WFJ*SKHv>P3@07fuPXbVCw%_lbQtSujv>mnQ`CK
zm8baw7R&UC?D!am?A)G|)xpMqlRDdjFK3=UI&<Gi9?LTPZapS5;(k!AkIAtCc-_5~
z@Av$pn4A!goR^C;cHjgP7hy_+v?WY!mvbkSx2C0Wt(9tfiqq+ThA72pLg;!4w<fy#
zDB_}6-i-3Pv2lnh2-N_E(R9xFTcA^*DnZ#Amcf<6JtnrFty5;sS@s8nygNEdaTXW~
z0Xw&-VpRhc7EWINz}9?E^6Cp9CYomQykDy=`|gAetJ;5`1c6*;JE;Y5o<s&}yaABc
zZ*QSKi}-S&h*a$QMmT<B&#?rTnrQ=D+^UB9%&yTxH~jK;>kr4UEbo0JKmIZ>8QG+B
zR=CsapKfZrJW6v#PQF1hz$%d%VQc&WzJ7sBTJsiWI~~*Id>=OS-UH%UIgkYy*rL+t
z`)U_jN99YFnD$ocCT?i_KKGmHnbX;4ohKQ@v_cujMxcvL?#eLWa{}j(Pa0Xi>w>(X
zMBG|Liiu|@ZtK>P{)VL|B3ef!x<EZ~ZDYcXTe^oC3J5kyHpUY!7M^Rk<}NRlbfeR8
zG^OqU2^Y4n>+0FC{{#!_I6U?eV*A&=RgB0T{{CaXkYZcxqXXu)bzHe(qup0WCeON1
z-%~iHGm~=<b$q`$k@wNn)ktk37OXe1y~<Lo@`QH?|1*9myvbSB__Zc}GmkVQO?*Xo
zM^*xxHEADSMEZjK%70(5bwwgA4XU5zGeZ)-0C{^^gp<{Pk3C0{&Zo2oLkX+Wz2qwT
zO;Gm|R(zp1dW5EC%igKjUL}HDXb03kN$JBqj}<0D^H3fB9n2OPVXZO!ODj6iu++{y
zmxLnd%*ziTJv_Q<>&XkbjO3qPP7<7*N^CE|&A9MK_6?~^@;jRY+Clhu_Kd}nuw4sE
z$?+0`F=r%nZIceq5+M)hehf?o!^ZfyCQ}y~TxYHl(dsk;!x)zayCm-vc?ityI?=_V
zf+%lN(L7hOj`w>0yTUL9pPq1$#wSb(>>T7_0!B2?lORHn4o%PAE7SqDW;w>;E_0r*
z&5k3Q!hC0VnI@whE$ojpT90>%X=}^*#aJllI;LlVn4uM-f6e9(%2s6Ygb0!QQC@VE
zM$>fgoFd1Y?wxUp_lX>${bTk+rAkSARH0ThDVdB#rygzoq}4mOGQ_DUI@e>xn9V*S
z!>MpFq`9wrn;EyKIPM;TqR}>y?wU&o0SK3%A64x$ArW7{OGCuxt(tov{5<|skvMZY
zM#FjOM!^;8?V;sX=I{-Q3T5bN_^lrL^BPX0=25tkPTQ!?wR*(vV7R^1b3I$TWR|6E
zon>t%sTRzuJU3mX0#brK=L2`$2(lAtw3A^=f5cPC79gl@ujgd~f&6`+L)rL@D}yZ=
zYrLl{92*B5u2+a0Z@tCRUPN=xvb<OZiixDS%hCRCr>s=}4zQ6417SW%MD~DND$Qh}
zH&eOQMXDf$5_|6!aOh!6V>DPmYyCPMxn4DSDU~mtT#(3}ulp*Rv#?#aQFVPI57q?y
zwM32)UpK`Y8+$)Jc;~!pTo@PiKLjTqem}S!OJ=w^;)mNdcq$KbqN_B;_*wvh#ItdL
za61E}!skIeBRCRm=H`25pb~(B-mRTMxh=FW4Sr3byxDohCjHt~UI-|9gZt!dTV`7W
z@1urEwDkM8mK;myzJaIM2t~h|bJBrtmiNDu{E|+wTly$V3x+?jQ>&#QlDpnMyKbg#
zex08f{_A_pjJFJ9AJ8;tsK0zndVzv;8&h_3Q-W~gkES14*@|u-93ZN;1#lnswnByA
z(cws`1&{p%CEiQNxrkb}#4i^0n(JFemBE0LVcT`xjQdF1T%XgboP3I4)%S}0CF%1*
z6{5*Xt8hfP3h*rUz}eD&>Qx+s6>-FpjY*kXMCUU`kFKXmn_nGjt6%YLf5Qad{Zs_l
z40&Ji%_TkU#7&MzkN-~ebx&)-c4aN@$s9Jj;?i#9{!8q5evVoXNFC*>5DSxB@9Y+t
z%C79HzTZ3RCjkK;TN7gVI+PxA#dW|lRXVYgeQ&d);LtewcT($G559RA%OV-6GzHBM
z4zN)G0{gYpYY6i{N59%=44bhx(@xra#dYc`EhLk|D`UFU8?w;kvg_1T{oPr1cZTJa
zn@^JYQWia}9w~XNP2KNFMqjGl+G1m{U<<49?v12EVSCNjTH(8tHpuzn*>8^cTjF`?
zXWSk`xz6By)1pVAUgl|y3qjW7bI}x8M_^lQ3S@rFxttt7cjWK`gz;_5;45LPy}hD>
zXzzEpOyLAAx-3Q+K_?g8m!^JEF*BamtS)P(v#)6nG9A19Xk?vq*DD4CX(p)6H4~m{
zos~?MoA8+)@dH{A7|F9r$O$@1?kNOy61wtzX(PDkGD%9>l3Z<_w0)L9b)BNm`e>_H
ztl)0fA(i{G6+2A$D1TmYgW((NM(b5GBb_=dKzubwKHgD>>vDHOfQz_+JmEyS%L-hm
ztgJh5y$mA$XPWk{*=}b}T$myL{hg~lE>c6DJP;qa)F5tl`J*gX+?=9XM(NAbIvqM|
z7t5~?%E3IZ%evNGi{D%Jz7TlvHsmLabgDR)Lw|y`SaG&=OA)mZNG)!4;Nx@XJFVxt
zeH&mB+>}62)WH!WJ_CQTct%!56%bSjzaz6ZN()MHHc`C)TLaN)VNoxf%{fq6%h@o(
zLJb#MG4Sa{@`hAS&>g^KWjlb-2wlpb;g6W}t{lL$w+(adt=lIB3k?rOd!#i6ZM>H1
z4J`DQuxsJ^@L2WPC0731f}Q(^ZrWI<3<;l+^!3$}bhZKra|z3v9S_fVQ~&z0`JB}B
zV!H#8%WnwJ;m0%~p4U>tc9<F_;5%LRNuJDekn{1c0&Y4P=Ah|&9GAHt&_j5n*xo=x
z`o0tjMqCM9wQBxW0OO5iFh8EciI+HV*ME3ZE{Up&@TthyO_LF2HdSAGk%_z?=+9TU
z{!5JE^j9{<dspJWU5@`IsVsIOBz_Lys0aI>Eq;Gn0>Z+@5PnTipt6|z77|1A&=t1v
zUOVDsq-~cv{mhQ7EpjOTsgh{i`)?{qivvdF#W(J(j*X(p_o;u1-aLNvu>m#tys;ss
z6)Vp-yFBj^XK$5qEA0-fH-!?}@xm@a!hYXo$||ck^X6RcF)!^?(i|n!dN#DhG9r<8
z@%P3j?j=bkR1<RQj-=tux@TVv<5lS)%um2RdH|2YeX3f9AwUX9`dxpvGlkO4Vv$Yx
z6V|<wz_r3P?#ik7;oa#WiS>HkB{lY|32efdNprQ_M;0-U&fatMXYGFl!-d#sljKiS
zrVY`|uY3Ma>!_HqW9|Q4W#MP(*NO0#zqY&oI_}`gBXK>}(jt|??<q;13K}<oO2aOT
zm$A9xA)eFrmN9srWz5f0NW#ux9u&$*5xHG|XCHA_vPn<A?=KeYb1E|`Obu<90`kk{
zmynpI<lyd*ZGA4nxY`Pg(<ikZ<Z+8$vl8RXuJHCuH8VkVcW9ynnkzpQ5+fH34>;IR
zto;K&w!P@ugM+WnSBlmnxh42FB4h_`DA!V5#m=1PFZzt$&z`Y)r~B><BwgE!{5J<a
zcjl}3edMVCdHcP<uB?WL>*w`)qa-SL#xL`@KFp6Dyzm+Y=cN1TXHnZGnSALge?eO(
zBE3V-Hg#jnh(rarkOuhSRR>glF3rKgnjiDD*2FUnu=P7P@VI_T07*B4-+FqLwegpp
zg!f{XUzLgJ^-Y+TZ}DHIf&}34v38x!y3mJ+qcmn$Kc>W6o9e_-Zd|0EpHbpU(IORK
zbjk-8-q7(on`h%YeUut3<XDBev>{)z@l1E?HlFzn9XCwH%`whph-@x)*{5dh4{A)A
zM<gqI;!B^lZs;5+Gyz!y01sAPQKN2SV(Z!a#m8;(6?oEoSJ7qn3l29wT=oY@#dx=7
z?*KJltqViiTD+@lz{XvwZ~v%MevD$b38e)A`arW?SSmgF*U^?I%;B{;s1o_b-Tg!c
zaJ&I=hjoCe?)9oF?ZaI2QV(DERiP=Mfrw80Uo@D>@Lx<V{?ni4-gBQwCWA%l*NwhK
zuPW!i_**ch=h0|dy*Yt>5K0X>uMdmc#I^RhOt?0@ht~JKvp}PFh}X)KrFWyn@3j7{
zbjg+TRDzuCY)g|Fiz$!mRa4W)#(T3?eJ^95$%<VbRgY+X)$Xwv2%Cea0CvDfPdRy#
z+txIzcmvm#sbcWa{Q;dQiyf48v{*!9#>J!3T)n`M96eMw!1vcl3OI`~@3QsfV{JS1
z%o-HzOGSwVE%9Yd79wU1D(%}QOQWMpZJkCYMJ7HeV)7Gh8}EXGi{3{!hi>^r?He@<
z3k{i-{!Pg~=Yc#XAO*b2zE3pdd5`<@Z5oG(4Aie=$|I^kHX$U>brJG5{0+nD@!?;X
zUfGbv25&w<-WXFFYfQb!=&YeHfD5j?79TVf`>~MWAi<UI>Nr`!YNzg+`?&^*44so2
z5n)6RI=VH=NS}Rm#BIMnR@KEq2U{&}52P~>Q###Gnr{H@6}|12e7wO`^={mgT^M1J
zfzZ7&iJcrSj@t_^EecsghZh%Xd89rfe2w=!>Fg-G3l}$#%$4@BTDS;f-RZRnVdC;*
z{R+(gDPYJ3VGQR#mzE6|G4xf}Hi@JD&=N{XoSlriFRRO;sw!a%jq8oR&}pw$?=0o!
zBAYy9U=z@yMyF6PcLHNcAIs>l+g(s9xSARW63DGb7AByzs&AEmw>AsSsZO_azuJQV
z=@UW;TiD)|Z-wWXYf@Y_tEsZLE?L1a695<^C>)*ChHC4pcIKBH<(J&+*1IFKTAh*d
zP&cj5I~C<^W*HURyDe^#nwG!N^d^jc>onxLmYpZ(Fc=Of&5){GlMx!q+^sj3Qx+|Y
zo*ohBrBY3b`eW4Gl2H%c7;=|}0`5WDe9`xbLr0Vk<+#U%yfB{Pr~aimb@7oKR4=xw
z%IRjs^H*`P>BiBAp~-(GORjBftZXOZ*X=ot_^5`k#Ui@1ku8>qEx0bOYYE-S#8%Q)
zCj+1?FF%Dq`gNkOm$e^_-+28jN#UU(NCEBlyKV$A#w{IP<>kh;*O*ea`VBktO;iQK
zih?xrNcbqJy;lb3s3D>fCn$Y2n!_Y9T8Mw6eWOty6b{U`h{W%dH^>uRRTN6#Rr3@F
z>EPGPRe4<V^J+$Q#JHVel}Q9w>$LJxB~^#7$w{usrSeBQ`o-ydCdi_OwvR#H{>T(*
zI>i}lm6g7<-R5vtCG@lHiNf`bT5hltM@8<@-#sb!BYh9MEzlFpy+gK+I2G=&=chC~
zCh~b-bWv53ha9>`r-VdUH{`Y7HODOULA3{qxS115|BFyDA_@k9I&zvr?tOM469)87
zXd>aN-jvC}MV8O0xfhhG5!MQf#N5rd$R^QzNwQ0HBInd><v@xY=o^B*x7uYI9R?WK
zn%Cs;Er*88@EH#8t}d>Ca+UKVA-PIr8||Swpbik9bfwA4K9he%=zhuR?vGfsbfI}7
zBYr&fZ-!U*_=1xPfdZ&!@R!hOZ)+s*_fbNUj%jGl7P1m#zSWt!phmL;REnw@29df0
z9YqVfh1+Ko7mX8Dvi(u+Ky@`<HnG)$pP1Nt=QNC0N~dEI&fQE%`o@3M4+2sFMN*d^
z!<(ze*@Kv~S=6QWNT#?HIb4*Y;hnM|XYv-BjPXkDOBK$V<W86@-2Cwj(7gA$yQM(D
zm|_|2$$$HXNE_7Xao3Anka>L=RJTJ^{fFs*gz!HT5B}@p|4sq;zkAO=@Ue#&Fv@>@
zB;fxs#pVA`+W$naQaxGKf7gosotyt%OLGt=Q<UN!{8T%4#`>fWS{izHtJEBx{4XjN
BQEUJJ

diff --git a/Templates/BaseGame/game/tools/assetBrowser/art/terrainIcon.png b/Templates/BaseGame/game/tools/assetBrowser/art/terrainIcon.png
new file mode 100644
index 0000000000000000000000000000000000000000..29036c61e58dc59aedbbc577037f5b1c874aa7f1
GIT binary patch
literal 13631
zcmbuk1yq$^w>SE*=?3W%1SF+Fx}>G08$nvSdm|!9BOTJEfOL1aw1jknbZvTnkN@|)
z_l$eTH|}@NcVIB~X00`QuHRg1uFq;Ja@ZK;7ytlZE67W~0RRa26#}54fFBoL)3*RX
zn(m{i>-OfYCykSfqovJz3mP|XCkq-2FB?k$@LD)b({b4pNeWr14A+CS=;4gWNFSRf
ziLbmZ+}F9;|KXiR`t5aUZVJ8AC>QYc0oMNGj-$<%d46lshpN`6?QDQfW!VjWn>IGK
zdVYSs!P*uR;J)a8Bekiv&e!@l{^!oT&-o|XslQ*lardUzja$y!WAV~*IOhsU_=A6N
z41TL)Lf0RZ#}*FW6_VGd{yX=#{;kJ`a*kO=CyyEJ$L->8chktlU2H3p$o03aqT6bP
zyjJqYq8g~Md24mh#2hXTkB>H{2U2niV(-s++GJBN#PbLLcm-(xJRgg@rW|B$k^Li2
zCbjzD)&KI=B;euw#nJi6iVghb(wf}f<Jr+ydstiu`AVSt%DZm?-VbZ1YGUjc%KBN0
z{!OljCP()(rwvkY5erzH*h4$)!uOD`Ih9r8$FYLH(w29>x8j74nAVL$n^1Vgx$H{t
zv5LX_H$L}Q5yw=rVfkmDC{<F{P<)L&=difsBBEwV>*<<><`nwE?iB2Qc{WtWt;P#|
zUQUo+x4!32I$87(sh^^cIcIdT#WIZCzZq*^%F6W0%0%mgaa5Was%!N#`O!T1tnqR`
zIT9}3LO<z;)te02(FSj!yIOsi;(#^vu&iaRzgEp9U?es+X(e3nHi6<f|LHP)MT^+>
zN%NJ3G+Q4rB<O(Nn)@Qf#qb?X!V}!!NWlp+w#n|r^s$<g401(3DikaYk8k;D<c&GV
z3fezIZfzPhq^k43C^Fa9Ob#<u7k<YnsnyEafB$VuTi?FSeO5MI^m0+Ly!CQfE{iT2
zX+KF)JX)+TB|cr{hse#v=0`ytLz^uvZ6o_jzQwfkvw81iBhTOdF`}v>d*l5@nI5-f
zR{ET;2djumewF^N@Mf+}cWB%C^?UKqbMfZ6-EmC-?7{IJTT3-@meO9&)pI*a`@@YV
zl1^_Dc({pOY1X1j<G3&k1kXh`DH8>^Mq=c35(a1@zPNtimPM%!(RH}~((JiSseW%V
zm~QtlXmI~~M6lopmj~v*9FR~;=d-NZXKY`beJc$k8y7Rrs*AS=<c?)BOxl~W9@bX;
zAKIOAoRNucWLMZO%*mvqa~h!Zws@|8I#rg>>)d<=aeL^#(oCe%a~3E44#nM5%bI;f
zqu6g9@e-4o)nUvAyG2jafn(4%o%JyP#ggTs$!zYVLyaB_y-RU=v(9(alog(NnN)yo
z5KCZfyX_tM_nL%n?rltWHaweM?N1s8&wt%zwFtq}2_7$ILfl6v&i1Z;M(T+2IRuW)
ztrglzCzz_Yqz^0^k?<LXXYnMwh(ad_<<U9T^iU>#$z!bP&^luq9x?wUW0yl?@eo*A
zI>TGfCzz#$COQ~KsFrT-)NbsH<V_mie6sE7rL})+k%cql_}d<<DTEh$rK(njyQ?fN
zXTr46ogM;XBI?yPLwKfEd4kG`mpsa+(0f>oP??M(Y(I7O^gyu2Vw0Vk%<h+mtsSN3
zdzyMH!R1|V11n34!K9AE&*pmF2e4<Jf$2O9zj*eX>wsoiY%Xo-9C1y3L92uc{DNN;
z=ZY3iBSS61A&4SRO}-6FsN7a?TQ;HdRXx%D)W*LlxzORQJT;kb(l_GY?~Vaeaxc}o
zD!T!;F7ve(Y=gRsYGcbWAIP7vb(r$AQ!(slNZw2fhh9!v(l%JS>#*K9us^+P?5!VG
zw%lnVE@~uV(5rEAa9A_!GgIr2QrP<Z>5aiW8=;n2rhg)#{d78NuLUY;cKo-lU2g0d
z;alHhw*A~Y%&9g60`*~~X|lssOWLoAg{`~29iL<0d|%5LLB+va{Z6fEwKDQ9nU7Hy
z|B7~T0N=#G@b)CrUwtoX(1o^jxwt~(8~^L1{oS_{c7pcR_)KNw@5_Cwm^D|&jU`^E
z_M~ywYveXCVlqlwU^Q{MHx<oA9ZgqB{E+VQBvg-%ioSfAbI~JDjf7~?W!i!}k|CC(
z#J$6)PUYz5eCOpu$Rq{(<z8On*9e^@qw`dxdM;{7^+-!{q`U_$3LSY>S79modti1T
zI-e?_y(FfZ<&8p%e9Ze8<5@MFc%1##YR)o6`udH=0L&M%AsP=y^}-v=k%9zuvfCPt
z2xqN)cp}+#b=bW9#h9t=J@Po0P{V9wk=^NUUz6g6Ge00qkz$fc%%QpE=Mm89qBQV5
zy98cJT&4+MjO_gAtx}+p8@D5o_cXrd)SpzIz|Ba;c4PWOB#okWo8?w<*NeVJFCRW}
zS;sfJ$QX_`)Y(8Px~hPD^yp*zUO?Y0GJU7FxW#ae!7+WTP|}oqf|mFCr~DloJ)U0b
z{ns|cJRX6g3GF(gPi`sjltbiBHt2=b)7Lmyg;ul1JrD2pWYetFBZJnt#WCcLa@c4h
zH+RW6tG=QMxVrNCg!+sg80J%2B>Fa;*L=QXc2+Ze%M;|z>E>i!V#6!Z)_A1AbFAi3
z^Y%-$xys<K;_6d<jL>9hv-e{6CZlIB^M7knJugHEPuyY%VVB+La^qP{)aHzJ>6Rm^
zPX6@u?M>*&X{x~D3TJ4TIk(CFX~R9;J`HU><GwR`ifudoi|kz36OKAHnHnhmZg>p}
zou@m^+h=l^2*ZTLG_Lpg!9mt7Mfd@H+(3fo(>5TGE8_z@$_+oV2F{^T82)r4R_y8r
zLXG(bF0o{^3!wz_L|&R!)=)3H<Ts36oJ_iU9)b>fx7vnr4bK>@cYN;JO!KnhzL51M
zp?(~-k_LcUtk`vjFss)xvDlIabE`!VnB0YEMae~aZ^dq@o>uE;A9go83WNn<xv#~%
zoJ~vF#ynZVr3%6#6F$tPha5MQ_Qk!!3-*!78mT6X6q2>~yk}NY@4)415s=&F4wFV4
z#n##>61I|IK^Z}3l&az#%!N%zL{3;qB^D=74_XsvBfP9>NNGS(;bz8QacznNhUG_J
z9yMWpB93n^X3t>ZSFP#_g{MB!bv}qE_s248W1{GX<)hi5t-un3a;OLOgy}^EGUh4N
zU)pmayy?SUS1!wyL_6U(g-n>4$}^zUy+t93t&zUcu;Wh7bYV32+D%ilsmi98XOp;c
zZ7anp);Nc4_z7KV<Tb5$vV_Ne{GleIRl=u=W2i)ZW}YYD$6NNh!H{pP_O2l=`uu)6
z8#y(hx*_Qx%NjMYDMxFcMRs%MilLIeQvpTM#f3PXa^kWYDcucmyIxK}RBa{aPX05l
z(=)*2yS<9!imcm&ecZd;0n)VU@R&u<S6k}lc^1WfpE*o(;#>+1(1wxVmK8Zw`AW*m
z#+8LEc13VXiLf<^F1$kkU)fa7440K0BUXLt=~q9mcTYJHZ?t_h#Z7zK&Wxbjl2ViM
z1-ve<ihNOuoVg<%WZ5il2eX$r_0IJ>e<;*deAhKXA{vskvu!XU`AsBeF|EWB^?t${
zFXA%`^A{C4(bqxSx#k2+oS%6L0@f0{62qnazB?F-eg3>$O)IumOoMUdKFYMD9NKlV
z6&5Vl7Cc{0vB6`#`DU`IOT(~d_j0?wT;539z#H#@(*1RTCd*meUeUq$WzQ2+wWfC)
zWFw9Al+loeEF8>yS1UGwXXTZ=BwIeAHKb*#G4xq#wN;*{)P)5DruwExeoL%7$>+n@
zMYF<eB7qP3tkqxHcXG$0QL>LiDno+n!iyB2#P=a_8WVZsAJG`aI)_FUN*0UE{E|p5
z<9nGWZjEL=R}XnI{u*63V?cUL8ZsKw&(dngMxh9$Pzw7-tHsQHim0B7@G{>yC=Ja(
zMs|{(#uJr=b|1lU7r9OTK+iIu4p=t8aEY#Ace=^%7WHn#Cu+zi>Ndhuk;Yz*Ff<PS
zz@u7iNH`Kw?aUxe));1M*7KHhy(u51B2Mm|bEnZ}xL_{+BzZ+Co1_>ih4dVPOJ)rb
zq)Ow#;x}H?+adKrwKhd8t`$-tE>@)&Qhj0lh&0?QztXYkGrQyM3t8^vDPe_(?q0KD
zJcDQNF{iujCa~Y(%y`B(y`*)=VpIJTTlPq!$6+=N!-^<cjTn!T4RLl>UxjUi9T+)j
zQZv|4vbi8v5V3i(KJ~~$u<W2}tzo52mwim<L;AJ=#U#;xZw=WavH6m1E3=39P0qC@
zEZxyuyrSjhIc7tpfIL1S9{xU#Kg&eKL);nUDVDb*J(smVa%chW#~>aVuT5@Fi3^H`
zxgO*UO{B%%#gNRYyvAY=HV)$J42X<EoAk!_Gp_dFPa&m2i)`6AP61?qv3aEB-H5Di
zP9P=X@*lT7=XcXu=?F7!L_pjg2F3|ehj`Y5fQ4*^@N+@#uMifg8#SgjRp-V4k=rK&
zO7bfu<VYq%&<?!D`|Yj{6g81Bw2!o2X!1eXxMlE@ZoQ+lU^SGMXlwuLKw*bDbs0>l
z%W-w&&qzg*DimJN<h`cl<SZW+i?7qWNewS>(3M2mkkQ^`o(gUO>RM5HZmOI@8v7Az
z5YajHpQJQmWsINTyf4`34i8E7eydVCX^3ax(BZ)1%2y#3p*9(nEbDTN`K&{Q-NwN=
zb7G&)hreY6rRTif7DVN4P5SMeW%lQRXWXP8#urz<9i+57x}-XR42bvZNco`Tm&K||
zogH5<k5xNo6`tF>1ycT2We((iYV7JPo<8E3cc)ypB)<2!r5QlDQvQ1O!TYd{;Y|7}
zK&Q_1ikn%m2A})Owqy#RIe^LSxI`Wn9tgeuJr9+W428(8sQ!G=7}ij%Ue}-`kDQsX
z$3~QtvkY{gV9tF)k@Pdzr0@YKi#Q~3UMy)q$FiGf$bK{1y{$EzBu;lbR<6re1!Y=n
zKo0#Hk+S2)o2haiKTfw<xv9V2^B#w$!kmP<C}#lg!*nd>7qWNK8uWAHObjGS((Q2=
z^f;8(#hj%^K3Ci{1YT5j(d>l3$=(9;sjo{!RlT%d+4aqj>1ZRz&5cR4t@+1>b8av_
z%ZwW8h|q-kMBy|sXh2`t5}CdDF@eXapG0V|NUUf=cZPm5FT1Q2_h}vfeD1}R%a#M?
zn6pTbY#dE{sjb4s=d`4mtVS;4j`+r}g^dMTgVB8O5jK`8Qp0UIo0s2Doqv)Rd`+e!
zSG|1cPI7@RZyxUbt%3IA3(M>YgzJN5l)~U?jz0z@eKgCr(faPl?!|mD1!aF^(&R@Z
zWKY#a?9^9izA`fjb6I^9<yln?qn(b_TtQ?b%&*HXX7$5UcrJ<@1UF-4YZ94(FlW1n
zY}W6xOlcGRG_}OYrn|~zr(E3du#qM+5;GIt5p)e{WEBf;_G{WMXPI`EE8~3@5lwul
z*fDSBEo2d);}GfaPKdl;lVkFw&1m4NW6ArX?1sD}Yp+nfu2rK&mtMxHT#X;2>>)~L
z>jA_v`<!f4&hiv&`;BRL?Bha&pP5BG8xA$%#=8;d?pJMz5GIVKa|UK(MTnxfcl9-$
z$kESP_c(-FiyfaaYpsWk`f$n22r06E{cI82<+=XRQc_iuEyi8NHVq$Tb@gr{`%)~T
z2;H@bGO6H4L$rRLx_(uzQSR69)oYpWc%qcB2{R<3Pq;f>r|U>^c9fZ{K?e>Lq+O?B
z#JRKneNMNFUu?MeYzi0*%W4N1aLc4NICxS=SsY_Myq$0(T_}D!#;e*HwT-?(w)wyx
zSy(03pFQjG>dp3|v(`76ybVcjkwpmwo<{Yx0K{2Z+sIp;QImCgymkv0K6>FWX_Gfp
zVYxwM+n2Sf!btT2E6eKpo#^aENw&}&46o^~>2djSvUPl}h<@s}AnzKCUf?lj80~eK
z_ZC6Cwq>+YD6g&JS*7hTWZ?CH_o2!Z?+0$bWt1xiRk=v@v2JGR2WGj2dI}lev|&<+
z7bUG?c8mvMv7#DnhA}b>;iO<HeIMI&e7S3ZKGrO!df?JOWy~<1@%SUp>O<oznq`7#
zf5^6(@wK0{0($DKocbpy;z=uRjHDO>SV}wC+t6i&sH`X|0}Ps)MWI-JHNsaKpO#st
zF>O#+LnBYiMHTN-=F_GwkV&0FsuEO7y#CO>Cc_u#pu5s{bG8qvnaLH$qO7;j>p-QL
zWQYpLPUbcqH$=85((ZxsWjmE>pd&qH;neI)veC4CS(hi&U12L&`W%<cdbSd~<gsv@
z%Az1R#cVN)N&?sEW9<M<aeB=yo-ux2uI;Zp-c?c$S=E$}h>5v272FO7+S5oHh>6oI
zciW7$=SgxnA9N~tV}&de*&;tI0)EyPM9<=9YUB^Chq_9eh?&0yzdkC=7ia0S`_{&L
zgYJhLt!zmU#p|?2sEPDNpo9tkya|GJfyWWaI1$YEDI~R5(PA^NY=@@oVp5rd$maPF
z60!W=hU?L9To;V)j>^}4$sfJ@4M`ur=g-vU79?ekh|*6;hUhw_CFQ*De*0OPiHb${
z!<L?}>_raM!m~vm8Z+^dDzS_H>Q0gb`Iw5spY*9iN$F;ki44EWpb}}+4@h;k%wZA$
z_Sx_3n5Sg<xMuNUEDPY#nj)kx@`N0Mgj#}(%*jz!YIM_-ZUbBIm`};VV@5;^p+La!
zj>2Y`ycsE+DWH3jw^!>W(bGiCo=(fqKB~7slcM}J?1{ocGzSpSuQb?iF5-#wi}r||
z1ETI-meTirJ+vYV6?HsN72BQxL7R5iAm|~nz6$knnk2`15rrz^Wvw*K^WBSh6C^rK
z@d#SZAX@WGxm@)-L^s_OHePbqccTo*6;?reOu~KKRG+j;1fxD0Nq6*J(0$kq!7?hl
z7RhNufY^s4o_&6AcN!p>LbyKM4Gox*aUz55#wQBaB30L#%~^!iD!euTtO$st)9k*q
zNM1~c>KaJv<xifhGb!<BhC1EHH||pl6n=Tuw3NT#Tskb5@?7@A$B~q8B%)L`C=TAk
zz-GxolY33OoMfJCjl8Q<xAu>qHEZf~<p^hefN5tUB;UhE?u}x!RCDn1MOdgOdTLHV
znHAZph@D)nd1ON1RmZbT*;`di!|^e)jq?|f+MHeM)W&f-FMO7=7~PBMptd{FO}0GS
z=!MrXthYB-e>`mvSvoN~`tYUgtZwJ;LQsvY?K~tt;m*v}TE^-RBs$3m$fxVLnbxK^
zwmA{1S4-Nt2{<s~Qwp;d_#1twJy17TU>!?frz!L|nxno85;`Cl=%S2^!Kj>ATre{h
zML3n~BF0-lCzX6t#>AO9X}-izg_Z-Q51048pDXP6a+|=~p>!LAM3#cFOP7dt*7Lks
zEEztBFe<)+z!s)Ssr>=l)FzgfkQwK&^^YVD>P{a-8yde@MVQfnhc{mEc}QBS`&2*j
zm+?>|uiS*?q{C#D&v<F53W-Flezx*k+f%h4y)_=#$!?-|QXT4@#mX6z*>u&mGx6|~
z1OH-N1hsd^D7NU4nLB!|Y@7tr<dh%!mBv1))2I^{nSNGQeX8tZ5w4S6oBgur?sVs!
zy?c{<Ol1PAP$}8jZtGd2(ct^g@%`r^n*26|o@5Ki29)SVsL?gGPcfEM8FJE|$tfDi
zX{vDO)a|GY6v=VEfVG|C7KXlr43s>qlrYQ?lbBL}bFi9>>Q*x&!IFH|PK-qSiZoY9
z|EO;*GZxz>+RiHDi{sX_6Z-pLvYozbX6uiHabfdYM#)NThqcVQW=Ua}iU)PIC%)h7
zjL}TvnM*HXlgi@wcITxac37gF@1+X(S1*7jjpbuqV7yht?8otYpK*y~drqz&drvku
z{8ATAa-x}Z$f5@bx3|aR9y{2@d?WRnRrNK;1sE)8kwlH7Y{oS(=Xe-@h2k8{TP~%$
zh|qBw$KpcMke~E2xaW&JIMvR|?I8Z5_b6PDQm4Lpv*d~&lyD_nKHa$d1^dFR^PO6Z
z*DvTaZSLGAlAHbcWFZ#z+Sf}jI%NayylFARR2FvHmWzyz_~v($QLt<nHTuLXZ<#hN
z*YU)U5d39#RONV5b!m1p?n)`ih(2{(tCLQJH*0TbfacgZYciXc)&evrtt6S`0n)H9
zN|0yGnRpT>$e-lvJCN|We8ffaza3iJ3)-0@tN4*ceL5CJpZN5QV(OT*dddO!?QAB!
zDSb^YruFeRA~XRkhxbq~sn%TEf%>vsR6(fZ05)N9iLH7EvYxXjqhun!gpkb?qM4rr
zlB+0tBAXbp9hTdRuQobZdLIB%vU*fvD^GpWXS}Gfh@Ca>v?`y+((GGwrd>D6oIFpx
zu$H1(q0JE8#H?M*oCp-f4*j6;b&Mu^@|SUcULaSs&jIQS2YtMuepizhryt3xJ^1<g
zB)ZRpwIQUCY6Sh0uP)H1ECKQKq7id7LJRTBQmk(^i+#K_$5>}4PnoRj#FHblm4b_+
zt+~if`d4($KIY|h2iMi_-`OO!%pSvjE@s*Pcz}mIKEBc)D>PVy1CJx$rC+S+WB~v|
zh>et#nu3(nzn>|<$B7L8I8pg-3Cdm*13N7i91lF_0ky9$!l--Izw07l7L<*D4<0Nq
z8P9*F;OtCjh=~*MLYvAk!`<D92&oenkDs4WhJ^VvP$5Sq61D%q%k$V7hI8_gMTx74
z0g&Ol)D&TO=UVb=m8f<16E#m*_{jK^y<RNC{#j8Gzt)J87cker=m0@S&JH@fF)n5P
z&-`I|>4kmXSpq$;bCvv5M1D*mf2M9^7rgIlw60FJ`gEaWn<*guf>2m@-&A{&Xx(PL
zqO>^ScvR?x>+*W3rfsRa>SLFwv5|u7*KM?Q-B%C=v{*GMGNP2Q@$X;EXk_lVNZ=KR
zs$Udob;u$qF^gXXS>JWSS3T=x-`Y+pVDtg-2n+v6NRUysUVZ7Y`LJy!&}Oyz+WxKt
z+w>~_!p8uU8UgWlN3Xj<{1tSV%5+zOz<nagkGC}hauOiBl7NWf7}UmBRR2p%g&K<G
zUh9WQNeMBR88Y_t_EfcUglF1Z!Vm}ZU4{^z-u8pfM<`~Ba?$|&?{9W%Q9L+;?j*10
z3ILb{fBz7Gv<y;k5Y<gVSq60r9R-DonZiBs5ga0OlhJjPa<sR%aBu^pTrA$YS-hk1
zv~jbhkyB7s(+R>M0RVDG1!+l5@cn7YCc)6+YsXrkmb-h?lrm&q{sSBDJR$=<f{FxT
zg3LIlsRRPPNF?G1FKMgo)l{<6;7sQp=hU}IKO0meLdoVCy(DCj<DMgu5~JI_g38nC
z>3-q;n%`WqErrz=ThMIRT)*!v)<~bYZvb0{!P+i8v@ARGF(VKF-h@)Af8NXR000VV
zjRXKR;0FQ#paFmc_ziqY`~R8xZ!Z5&PX8tD|GE4>b^70p{h##&ss5A2|86;y+{OjX
zntn&j_tF4<lQu{qNF&ib^diOW?Zn&cIFv^!bcAetZ%pW?r}uZ~a6~kqxVqB>>0jO%
zXR3zV|1@?92}VH!ta%&#mL)+y@=hMKPq(A~ORP=mgQGbIs6#fwJSON`>x%inMrzc5
zY4SzrZl%u{^tJ?I6$$9=anow}YjJic@HZUv_DPR%q40T06p&@wueXOd5RglpC4A=5
z^Iy@*{#EUg^$$}Cv44~6!<+x5Tgrn@dMg-ND9XEk#CKZ46?~umKXYmS-?>2Jf6o~p
z{|!71&~dQ9@*mE#oY6-3S88yk*J1oCLnJmva?2q9A_5&@Rq`Kc#5+_v|Cg@A6rBc;
zm;)DMeZhf%HU%Nl0GtA#5j0W%`0TGYYUTskvtS<(ApjCC6eK|d6~5JcLA+4|ze__z
zpnnxF1)UGva&K)D%WQXa7I~a8$oOlN?8${u#Clv{%QFlLUs_sP{#?OZ<E8Zu00Qls
zU~0#iZ4EFl^<UfaT2;i%-N7|7zWz8LK(zl)czN?jJ}8h7Q=xpfn7+5+x@(CyKS=o5
z^gyN~R?ACl6ky~g-s&+MSWG$rOVfht<J=2Bfq-F;T@2f<e{`K1NJ{bPM0f63Oy%-h
zQU3;?5AQX5f8@h+bh8~}K6<En_2<}&f<`d79Zdp|NQ9XB`cgHSj5Mt#kh*sSObC^V
zx{J>mP~5k<oI~M1(ByxvazLzkuK=~FPH|eZ?rx5LQCt(E#x*IkeHq4{>5b^HXZBKb
z@q_e_I}6Ui)O%0wJ23!FE@0W?4bEV1Gy6k?z{yf|p8fIL&v$x5O`T)LP-zsX7ElTb
zM}>!lt#7w^-LvxdZ=|N1kA&icr&{^b$hNuq(Tb_In^4@NB&`0#tq!aJ12k7~P_doj
z^wZa@iz~EuAlg~W|1o%em0#@&LhpD|j{zkDiceRm@zr(PpJz6oC7&)PwnzF$XW~_h
zd%Hv)`N{R_Aithp4NVo-MUVhACGHMRxeg;?{Q*2h(uxLldgi9CI-VllJFTbFMD=o&
z&E+ipLo5<!kPa3=8=!d`94Ot>*UP$*(<>ewN^1sJr6ki(5#g5g^hmf!S^C4@rx=mk
zvtDjU9l|brH~I*Afu0@kD0Ckh5ZIh5>S?ecK)FwaaEMjW6Z`Ki>>5oOrIS<7kf&$)
zcYltr=v-j|Q}v11wIfHfj##0Q-}+N=4b$H!?I!+Pcc%;GS>>ay_GA5}fdZn1ZH_-W
z8FF|6%P}tp41no^u1}e|XSE@fn|7GyE8eL6(;6|+Tm;Kxqh)N452^I;Ptu*|L*WPK
zI6u9&zc+Xc6}3V^UyVEtTkO_MaQ#`=FdOMXTu*H#)^ZPCiI&ac6<xmLr(W6H|2S`1
zWeGPXK>{wO(CdxJBLXWpjqfh2q(#fka!7mGLYO>YGKGQ^sm~e*c(q{hUiwAR;f*E&
ztbMBK))fj9tH*qjKnLK^_eZ-l+`?0waQMfAGU2b;E1kvg)?TLf2T@E1PE9-9arSoK
zz0fxM>w57`9;MscPX<imOFLKod;p-5i?Me;K4wdbtmdb<Bz;XLVmc3<fr@YcthQ6k
z=QIw~Yz{p-I<|K@N{lt?){uZ<YX6H@==_`Z6vqLuOZeyY?V)zK@d2CcTYq>!miSag
z)O+8XtKOrA&N0*YN8qFhM6Hh$XLTm6zPBW}JsLX8_#xPdHyvL=6GO0D@%<mfdxtBZ
zR5W7;prpIuJ{ptke>OqP-{;>{Vjy5Uw09o(*58`|8;jCXWsB%<_cU-5t!!#h{a!DS
z4eprS6HAkK=~clC1mi2%0r|cssH}k6cKR7bd1(|0u_&=>AnfO^QT?~ge%6+GieBXq
z1bA!E4+xf9aMrw~KNcvh6j&`ZEKEN;@t5lz(TI*pEuy3d^s@AR@i@`tb$Ik7AhCk8
zp<Np^FmM|lytImHiVPrBQ22|AR$AU1qdufULZVvL7r9R`<~A%l3>hr%AHF@eKjHbU
z1Ump-Oav?@uzG3y+&bs-aIx|`IUDP1A}TSv@sH`L%37R)bNm@hx<j|fJ#T^a9Pp^V
z7)BAF6uk}x$x=$Je_LUQcr1;XUydb7A8a2Sjvd2~YbZRbP))mvqCeX(QW16cN5A~d
zd+lok?%>Y$1(zGY$kd8JN_a13?jN4Od!-=97m;Q#6_ndTC24k^)fJ?$LUA@Ktgm81
zD%ZcP@(RlMTy9!OmR51y>HgrwYTNtbMg)s{xs8}yZ>5~iRGaNyh-ZDZsxlDY_Ux#J
z7b?B`ea^L$^)nn7eiAWJ2dj|AdPI?mgKTZG0sGs9v$InK6u;VtWA1kjE6;9w9UqP#
z{8?$hoH$s%NjdeLSz6`Ci>g`7s0*4gKtKZ)GYD48#t5%FIdVNO(+$L*G}z5%VWj*n
z5@ZNG`sg(~*iRo2Y(j^{Ym=dc2_OLuKhdildcS+E1@*7r{5g&o9X5_Jb6hJML$en5
zGgJ~g_jg`hOeMO(qefIV$9klN@>Ze8Hnj`J9FUUG3HSA8#ANF7mj?x*FeNHOCCnm)
zt+d_1(sJwL^XBH>9!(lBy^5JNgSybA{dIW{8>2BXt{=Qmx7sg+gd7P_8v|$H2kq?*
ztB(!mrH(ypBz}C_B9BUL<tr)ISvloJjM^N&TtZ@7&Cldf(*dqK)k>dv%nEbhfN9XA
zwxz&VqtwsEM&zpXx7kKsNnKw@i9tpNeI}@jvIT76+`jm3uhx0i8%}&!-PeyF=xZ72
zw{x8qATU)omf>}~1M5GBJF61%U$(MYOM{@vdDqX<aRf2-660<R@;~ZoxC!maaNW_m
zY$gLuGSdLz))N+7dC}x+b{^q)aC006mIdHInw@|vY|K#KeJaoSw{lFM*s&-l&cpOK
zA|w2{#TlxSOnvgPrAj94m8*}lSgb(GgE>+5<~-b3Ic_kyjl}ynPiW&LLN#LIE0u+>
z!@rT)e5LKVkFmGw2`j2LLInh<SUNDb{_)~3s{etp#|R%k$R7AlBRJ2=oTIkVRvi8*
zq=p~EqjZSH@YQ+6yD$JtxGpl&pVcg?FBH>ffq^yD-0YT_;v9XdS)?G)`re=azd<fJ
zu+M=AU<D-1hb`&?wp`k(s3ogTC$yYbdRHQn6zI%;K0nVh-=3~7Lp!(*Q3p5e$YU8q
zQ^LbbjFup7P#d03Y`_>3IiEZd<1f_LcPm~RA=l<>_ulJz>$@0g380Grkh|8!l}zZo
zAfa0}tYQdoJ(^K}K}h%eON5eZotdNfLHHO7jkEd@p6S(bZAlFe^_@q{-Ozd7L#(sb
z)B6bZ-J__kPs>bKgtWKe>bv_<ZI_}3?Zo6@1T<g1#z}E?avMo`^2b=8EaGvisB$f5
zMdyl|oiNW)%29enWqIp>6-3nIU!!4cf+YYiy)PK;aw!Eco0`vUM$d>&R}=aBK+l$s
zjI@_<gd1Fm43E{kqZ6+2aeam$@x}`iC{|F4J~{{^fbXpfJTeASfjO1zd=kUtz<yzO
z5);Pcz#{GJYO-Yo?@l-Gv!ITidfKu$C`k)aR>Ot-*``h!fkr>EKBYNvmBw4l%Cm0;
zmAhwua={cW7<+6+eVI+tbW8g?p=?05H?ChLoVlotzfU<GPio<lEJM8W2U-B&Y8<_`
zA=t=g6{EH@@e+J`e;e3aSWu4RaL@7H2$}R`<qw-QgHGlHkeZ|HyxMsD`5UzW_Z4~V
z*l)358nz%=|7z5~x@bp878>qMM#Q}M9NO;f|6c!g0g8Iob-Nt2f))CX?zi?rhV}hk
zwfPY03RRxaN@c$)4dLJTecV(z5dV`+>N@jSc@>hpQNPm2)$}y5ph`6$RwL&s)!cmh
z=G<(t<}+7*nY%>)Ya}p9sss1Uh_b)zOr~wIu6y#|(`qkW?>^NA!qs(Gcuvyay1uMB
ze8?c!;;uXn#fc`fqBJ?v!H@X6tzNnCgJ+eViL5)XQurLI`GjWxdHHg!+YX}l%esJ}
z6^Wvk4|Bkr$4N?x^J5Dszx}Hk96MO9IWoX+Pwq>UO}sPlSLSDmKq6L0-Iner5`V)(
zxJ)_c2zdvyUD!(|<clIB*AVwMq~!Fp#9HyxWHF%zciObF^xrtcjL$0PoURm3$8jB^
zX6i*x`)x*lVf&{po3)E$((uqzq!x-}KhD1$<yy;t^?WqPiHM`xXc^E&=!l{y0Te`I
zmg{IMnqwf##_ZMZS6QPy1Llmq2kjz_o3P6=2<RHTI6g!C0c^YQSDq$>{D*$e|KfU~
zbD8tW&USCmaV8a5JkE2?KzkfYA^A6y`qh3iBCh=pr|Tc?^5!(c%pAFL>nq${O<xk2
zkEM_ih;xGZqWY8ZLJzqE1BkW03*0X55$^|Kg=@WhyT7zrC47{kIoI?2mkIWJ@-H#Z
z4(%r<f9YRZ1c0?}Ui{lvi)~q6Iq9AjgEmsI40=eEL1N#uVdIe|6gjl>g8)d078DJ1
zjE3-Dk8`y1UQ_f{h_j_~+`*d7HFW9`F(80^aOb13ucb9Rw{l>c`cdcc$^jI^9V{~}
z(|;OcZGOtuZ5^5<HlKa!1xq~!Dj`?_lKI1z{1krjcrH3}KuzU<Rm)ecUkQGDJRA>2
zU>?<zfJI78^@{fzy!1hxz-fk8Uo$8ksP5?wkewcA0qCc+8^>cX#ugml^=IU%b&c!0
zE$j&M?uA)OwOK9*V4W}ze~J6Bs*Q?=1XyC{9~v@SfSXm<|2M%Eq#+X@kVwlo9jK>m
zH}M^e0WX#y6Jq(eXZB^zyCh=zXB%^vt4*??SjnLSaXX(HC35w@W8l$OKF&~#+EvU`
z|1TM|15|BWVkk08tnx((0CN5bat`OMuj|QB+)ln1xB~A39i`BOy%a${ea4s<H_pUH
z-mSrVK5_tH6F0nL?m?!F@atiH{<@oIm`V)~NWqRJ-dez{xR%2_M0Q%D1E4ibv&PWb
zBV%H_B=|A{G6GZ&uu=cf3gDXf#|Q7-{$=#{Uq_LXFRkEpQ4O9yc)drE=e|(<g}UDu
zfFU3Ov9uuaJJ0Qizxitf4FnHpSXD@kCetu47raZn7r=ci83PYvK>pBLazYzM#acZ_
ze|UeE2d6RyxO7|rEK$c{{?VywXB#3Hhkwi!VGMtR7>fepnq`)!%V5mZ!}Nmg&E^}_
z=}iCuikVSEDqO(xiTd>C7wVnL<E3qWhy<vo%dSj8AbUrjoKA03vbInP13DUDIF~Oo
ze+9XAlfVNcd=l(9I{v`g@a&Sxog|crLFw5F5tSN3=9|v(iUAp@<t-DSNm!t423HRD
z2Ui5+cF)Ft%s$H>G|s#Fd|EWde&ehy4*L?kw;TijleEcW{hdXv?VJ62u#pHH1~h<B
z#D=@6nohRGF&A;|=?AchG`cwESCikK<!I-OCkbRPDx|+Pm+fho!Xdj@S%GDv<K+6H
zgON`MBY!OP&>#taP)GF;2%`l}jY#ArUz*1cH43<b!k5)`jPSZ)R9gVZb<*~1BD6n2
zQDqmFl@+kpG8cFyiIede83K?n+j#EkQHRr&U%zX&e5~H4K8Av-?#t|~@t7@_CHGz^
z?i{-P5<mVmJaVthDGy}`?dV0{dI?^Wx$GWKEpI>&0SK^>0QT45HUStY(Et)U=p7E^
zZ>Nccvf}|2;cxfp5_?tbBLKEQp!+CJ;;(>)xxf906z~W1`a9?y!9VMZ?K=E1{#mcd
zw;B-g&-yeJr<GS=>jF#^cA9^PdT0Pc0e}VoI8!Bo22(%+08HNm15P<$69MSh1a}Gq
z!6^pp=s^JqGQ@^ibO2nE9fklC0TrYH5;&p0)c=UXAng#vLja)QrCwkUyxsz)uRa1!
zRfvDt^q?WE(xZZT2t|Ja=@<mnX9mDd8uUA|Q#;{b)@s$Z#2x+`;2=bz7qa@u3}m!`
z+_4^kqk@0>VNBWpO!FU!Ae|cDtWw*6B;ce<^bc_<(2!iH_D|amM+!dQiD9}5b`T|4
zyfOdVT|3Z^puzws>3`aW+t-bk0`Q!Vs&$Uf;LVn2GB~jti~w|KiF1hw0YQy%%Rm_=
z<|2y+?5nviwMTEY8E3#~z!Sl9wCt?+kdH!H&x8X&Rmd42A3<H@i4^Cw5hXy?h~5&I
zMp?f1O-oHd{skA@m<1HYVRt;;jvrS_K@Yn>jXt<1)!z>dIwuBb3PFl#YE~o~(5wp7
zj!0{g*LrW3X3UQdxbB+qe>{oNE7_<n>R(wh$K5`@`I2<ozCCnFY3r{-|8Rp2>|deO
zREryYizs`dSXCglZ5plm#!>#^L67A@sCoN~v&!?m1^#PH;E5mI_lr>)o8Z94u4l~r
zMV<E|uV|ilsw8dHGWEO1CAfAqG6TgErUuazZx*Z`W}0jm4@qZ(ZQIzlTDD(%A1O3l
zDf<6Ffe%%nkFTy&1S>uX&i@7X&^Ou07dg()(6DK`!hVDR{QBad=H@4=C+Ed7i=_9g
z!v+Ah9|84%!`<uRo?fG${gel%3PW;ZINSA*edkrxNgD3C+5Gk$P3Hdmg`E&I5`f<N
zWaTjsv^GJgW5#Ed!{S%mr<ly8smi$-7~b?oWSf3);5Xs9yYsXJx)+L~^(Bph69?^Q
zEy&~0Ti3T*`|FCgrQ(BdOTjE1x<$h&&U22PbGBI*pECY?vU_BJuMItnZt|X-!DbdN
zkvW|Ccwnj{H+jMO{YU5iDKWIuzCJKOhva=)yIHNVBj?s*>8F~fMf4Akx2Bm=PnL7P
z&A4)28z2D1L+_`?(lU0ePwF9n+AqoejyHGn4V@-{De<cAo2#HA^5&g*w@j>y9j*pi
zfU{Wer8@;yZ6x$HR*M2$OL;$76yUw@IF|kGRf2-%1Qu(dFu*Vd0xZ5iNs}_KKm||)
z^LVpqw1?oX27~y(w5f!vt9u4#iq^(c&8TAv)3Fw0Q)oXIz08gxogbuVh7SRd_#ABa
z1Z9dUD{EW@#Svj#ZRACEja`9ZFf3E-Plo}5HXuK+YPCv#xZ}x&65naauh8)8`z7W3
z8X_Qn^Mec5n;7Txe7hfS@HZA@K#eITuL8vm`M<b~K>U47tA1|zc(c8J5F8?+oe|5_
zMzHOF3KcR!-W{{bJ3d;sn}%(Bcp5H-O$w)%U)(HY!KzVxTN8zi6$RT_-6;=I@qqkY
zOM_#Qci)0zDYUCTG-PgAW}k9c&i5Gr4nE)7zrCDvWo#^We-1CB_j_<GJ7&(60b-$;
zbx%>oUGA}7b*-921-f#^=pF5-mzgs|kN}Ie?4cXq=1bn)#9RNvX}F-tuxs9QR$j&!
zoq{wJ$Q~kbZpHCR%rI(H*9sh09r8}g@AR#R(JI-P&kCHX)q0wW9MAqj2rH^6NjPB2
zM``3%;qGRO60GPF!Qi(1A7jhEf$+c12?PKT9R4o^OMry`;QPOE@xRIm3KIVJ_52U2
i|0($XHwDk_!x5&1lfPWY4L5^o0}3)K(m!6Ae)wM^Y&jhO

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/tools/assetBrowser/art/terrainIcon_image.asset.taml b/Templates/BaseGame/game/tools/assetBrowser/art/terrainIcon_image.asset.taml
new file mode 100644
index 000000000..4a6ef4a57
--- /dev/null
+++ b/Templates/BaseGame/game/tools/assetBrowser/art/terrainIcon_image.asset.taml
@@ -0,0 +1,8 @@
+<ImageAsset
+    canSave="true"
+    canSaveDynamicFields="true"
+    AssetName="terrainMaterialIcon_image"
+    imageFile="@assetFile=terrainMaterialIcon.png"
+    UseMips="true"
+    isHDRImage="false"
+    imageType="Albedo" />
diff --git a/Templates/BaseGame/game/tools/assetBrowser/art/terrainMaterialIcon.png b/Templates/BaseGame/game/tools/assetBrowser/art/terrainMaterialIcon.png
index 0e6c456a644cf50a23d8fd1abf5609681bcda256..75ae72c45d0a3d164969db47da33b66cff8411b8 100644
GIT binary patch
literal 14057
zcmdVBRaBf!^Dp`g4ub~w0TM`X2=49yg1Zwu1a}w+B)A6)7A&{~2rfx*2yVe$0|a;2
z4|%_D|JOd};;jANoeSuhuBxu8?&@DvcdrRkRhGrVAj1Fv083s@N(}%Iz>f$38VcB)
zc#dBI0GYqHhK{S6sR!(hv*RlpdrO$B*BeWirKim+0PvhyPt#7KYjBso=fJ>%EMTH;
zn6dm6`!OXV{z@~c;#`kfPwkaQJRznGFhzkFTz!8vw0rk9OF+%Np~gtIEHg{!C^Uh0
zzRiE*nD^r5=Jq1&Aa{|%!&oGgLZP`}3bm!R?G?plB<^DO`7XCobg~LD+1Z_m-}N_N
z<ELlmSRyhftuHYu$S;mthryoC^Ni!&#a+Km0q<*}kn{5!zks{oPj<F9y+xgRw$`a_
z{8y7ZOMWpTyesZp!{bIY7xg3O_wLl6Wx5DhLe{d{4!QgC?j_Tjqc<Jbh3+ZBii86e
zm*3<?(){snHYdMz4DjdnKKHsfs0qm0|5NQ6;B`Lu^}0tQ>HufdL$}!2D8O4NF$U_F
zJjvjZwQq2pEEwS8dlqBjOJH%I_T5LNZOW+nV*}^<RpxlNMy5x49YNWq{)fell3X-F
z#}mPey_!z?{BFm#i+R&vIY!5x<zUj+m78wwf8x5-OnXK-34SSgn_&@IpEdsK_8mF-
zGtr`il^61lqr2G5(T5zmU79ExMF+Fmi#XnJ6mKrxy9M~H_<7SJEw*)pJ4tI&=Kcvh
z*$o-%k*hz*PGV@MZd<&6S`mhs#4wP7uG}`a`=}(iqVq$h6oWEzbF25Wn&Vc0W@R$u
zTd)+0FIG`-U#MOr3lf67X)N}ld7o2UpsIopCg+A!M6Dc-i(~89cNbgcLpKt3BpP-3
z4`;i!3h^IYKKbkIj}J2!t*I%nl$~()l@=BMuyxQZ6wtSA_@Je4H(xvQN=5j5)XuTx
zd}K3}F0j#ZI3_oSV`Hr#fk~xRnBR1eP+QOIgQm8=A6DH)fv@|5<<z|UqWKWMionTX
z(dP{Ru2iB(wJ-La#oW6*_C^YO1s@$7PI)}8DLwpqX9UYcZ|<PF(1X%W26cfdzg{v~
z{p)%u+;oEV$jD9#IZrw}i^%U<gT6TYvX;vH$8@8FPdIyW*3z>h<G$I`B$2nS?Pu`I
z65PukZRiCY5#8Htq^q4Lr(Sb7iuTXo2_G<+SMX@4`sG|>T4z<M%=YrYbI)l99gXKJ
zL@u<A@7WBj4aB8eM?9dnIw*1GPg!AMWF2$fl?ms~Eb~T#h=+0va<25~n8oX7%aQ`)
zo3*$-qZ~6iKfh0f&${R#Iud=DRs1rup&<B7v5xe7s<yC(+#v}gjACbF|HBSs<6O!8
zC4IXbC!%tF16%4lMixuk4C+4r8O(-1#^`fvUc0w!Mj7`%&;zb_z6)$%UAp>Mb(Lh2
z)wNmuexuG!t5ErL;l<j1c|;m(=MbqvQde-;kJJ(m#wL2`M^ZM%x&>SA&Q5!D<&)%R
z`|j}l*IsB&qhWS<?Fzi*oxEB{$1_fDnJ;ZBd?mS8%;LUQeo;YPuiN86nU_d==lE-e
zmUMZtXV|)OPT*0XPhz+kQxzPyQ0D@XB(#4cEpO%Q7kparZN^s{FPt-q8BXWqm`H9r
z!CLNUK^_GNMKrJX!er_%nJ-V?_^jwmvR}LO%!~dc#otXm;nRm3=Ds6g${D6+EK7f`
zFdeG48+Dn_$@j`~A>%uQDyCxG62{=CL;8F^m`oR)S#pv52<EWVTwr4}%4WXNx+)Oj
zQy?(Ocs=P0Kk^=Bbf|4#9@FcY3h|GMB{HcbPsUC-F3R@Z$@t-I^Bm8hy0PSgFE4S-
z?cB=jI(@Z^VZ_)RMgp@QKX2U|R&$QR)vmlFDaoR;-$dbz97C-N;XFG(->!T?#2oI`
zFm+9Rw?nz!a!%wnavNf^2oEc?q~D1=GkP93s4!-9VzwkD_iW;g@&*(Y?ac&Eakb;C
zFa2rwrD#5Quh&8=SXlkMhFS|xx-9tPj2tzli^j>HD7u|gZq=rL{e_mOh4pnx_!j}=
z8*4ULzLMFC)Y)e*=MqBjb2w4vQv~MKf6I8->cX^Xmj%P0cFS~oe^m80%fkr@<TPbp
zKz*g0rAnWAoKP6e+gk4@B#e>x$!E7wTd&oieK#_$DL*=%sv0{W4tieT+CC=vibh|j
zI@4jz&O&w+`@Xd#rkYVrzF98DKE`ND6*~cYr=^;`O!0BuYJ)$NStdmNcE3(=bs>@;
z|EtV~x+CPMg&S8W`|DRMuI@r;Dr<)v_9@&T8(C;;yeK0nK`=82GDZR=5t~MH&CA87
z(?O}{ra1+8#7@%$PX^A*JHN<N$`0ER%Xt`Gu<MP!7{N(T#&UhSODKh+dbQ|UdHoZ8
z`LSI1$mv(^pK}c1Xno)6Nrac=k@xSsZSDE=%pyN-b`~}pOw&7lJSY%1AseCP!h4i=
zOY|tTR7vFXLHibFv`@_khh!Sc4bfLV;%}g^+tl~*h;O%l)e<|2>Ndu0=n|M`*AK*e
zkMpsHqS5htqeR*>APmk?L@j(WdM-%(OjdV2b6?0|#b1GfKxbOXgc6f-ZrYX%E7q~x
zXLLX?k<uY0Z#6}o^XgIk`=sy7PvS^E;@oRjH)Cz{Xv&7!z|AZh<Ud7>)U(fHdgK#g
z=FR<i+4(!))Jo^>nTszy_PI)mWCuqo+o`9)9jO~`+${cSJ(5!GA{vqEh))=?ej%-1
zJDRJs-rKk)f!NB}+z_}W1~iu6fApIe*TNWD8yP9kCx~MVZzE9_Cw_bLG3eR*Gu95Y
z9Rn1(H{#(%_H!hQib&p+eN_r%u?rt0o8uIV@J&ewm~-s<o%%=XR>C{5_{9aMX3vqy
zZzB^2o_-aA*^AI20EL!t0uM<cb;cljG_!6LQNnuBoP$8a{6*$>(pEo<cV3LUeA1sq
z8%FuVvq9<OP-Lq>-h>pNK&bjm%^<p$F;rtRu@teZiJ?@CE?c?-_d<z{rWL!-EV+6U
zg^x2?{4tsJ>p}t1d447}4ijZQ()fINqLvsGvq%y0VyTuqWtnOKtMXH4X9xG2c=?yA
zsbf({Ix@CeCE`sc)*KBHJKu|(j~_GnUWkqbJg&dLJ|f}lwEZRqjUzC{TE5QYWIv(f
zw|k$5`u@2OU0(qUy;xtpcyo~^7aHUaMG2;diP_uH&NHxt5TDfJZ~J0nRDIt96UPvr
z@dZ&LQW0{G|6uY5h@0)5Q@YA$e_M_7O=W4k_+i5E&$hK2y@3(ilK%Dt?_&zw$dgMp
z8r-RQN1Za;$ZB8-&O}r3xA=S6YP>ZHhMl3!GYgNC9`p5@$SV(;CD1kcCz&L?ZofH0
z`;59H=t}+U5W<SIq*(j&+16|*Ya>g%5&@~Ci`HS>wQ`}5t$hvV2ew0GW-hfsSEy;~
z(jq30Mp9x??<~`#hUMN#79tu4g&au^B`gR1x7=@2X-NpD?M!Y0PRsz}E7+n!%nnZE
zw00|WSjbwAtSC|D_3NSnCv=%aQa(hDC(NWZ<n(q%Ow-)GL|TL;5!n*_)-SN?cFmer
z3M13x^W#{^u*^7KK9L^XE|h&XY~X5-fK2aHFwWMjR<9NpsxlGP&&x65qt(GcK`8aD
zwVX7+X<L<~mBQ&yj|cm;o4GGal!1btwr6+*Nz1~`Az@L3H4{!wR<3eUqJp#t=WQZo
zW2O!Qrb4p4&|CiG;2$r6^D)yv*ZopthBfY_jU0o6Sfbq1?YK4kVy!b)e@ne^%mQSY
z_Nf+UfBv?}0PmKu@5gl&wVbot&a4=F*1(k!i9VloiD%<u4jUz4Rnt^<2YVEm)T76m
zEVxhI0W0yBp84~ux9{NZ{Fq>nvP5`in9_;T<KY|6($S{LFI7nO--1&Z)jrVTi{gGD
zHIXDEE)1*Gw0Qgi!Pz65HizoZJENtDj!er9E9g>7K5SEN7a>_iU@jq<{AHk`9>-km
zlGON8OV2v@Q@&%ae(7%peB@RViE$By^fDChXv!6B0dg-XBH}se@)SBUnlecL%%iop
zRpP;vuuXY=8kpdO@mH)*<OLL#80$?PxW`eS@T<R{gnp{ctu4GX8S1`LVre^nt?c-C
zRk$UghR=ZcD`pkp_pf5Y%|!EJ8>)W1MRs&*-NQ!~Xuo!F;!kO1{Dvw$F<Q~)tu;u9
ziIM$9qk9&RWlv4xyGCfW0sRr@x)oDiG82@!5yd9jFE(odU*5qq$=@tXM3fmud(ysm
zq*3;ilJ?X(n#k$c;Wuj1)GL1oFA?gqAOu>8`A;fOysJdjjN0GQ97H`vDXUnjJPBcc
zQ-Bs@fPxb0k4XHn9-a^mZ%SzzcJbySo+w}MM95Ole%hOCZJ;T#p)y<<%N^T<JPsLT
zLu|K;9I?;(g~oIeW8UtQ!73ab*=YMbJFOf6#%U-H$pkJotEoQ^gt~lwEL)&1X8DvF
zqx1Y3>r{-aF+wW(wvXo9B}GzP658Z|2KGt_0S+y~Cp0PqHQ1KquIR0EQqu-35mG^?
zM}4;#P42ES@?BNfRYRQin@#K(iV@l)s?(7;-2h(3yA5^};uc8+{1`__P@<KuGQXIH
zra93(e&k@{m07(Qj(g&Blu(u3uw_v!#eO*-L7B-jeAKz|iqAhnfB3C2)dRmx$*fAl
zFGkR}!@q1-PMJLY8nb-k&S<stsxaPbFi@#t-F@!!wD&#c$@!t*i?xqlFnn*9b9Glp
z`_SP;Y$n8pX>Ba_MzHn#*naNwwlDR3R`;2DUsmM%DTBER`s3~`|73@A?)kQizM+-t
z7u$_(74uV4nLP{CeMAFB^iSUNNXU!|q2a?Zyu>%k^bubk;@}1dlK*+SrMk4$-P=%6
zD^$zHB+~imn-1mtBs;FF#o6Z9I9kRk(`}&(%Nd;E#%U3}?w0V6?Uh7PP)0Xld!t(W
zOQxJ;Y_ZHq#D$FNPMkmS+`a*<l$FzzoD@eCJ}EUtQK$^`9lamRQ{mCLz15is-SI_`
z&kEgC1&|BlyVRm@4FpOiNxj0S{U?EGhDK3pWbc@@Lb(Hp9+QZoxwfI3(8-9trN<z!
zdw)o)%;#M8B4?~Y$7o9`b_lUp1=S$s>uXF7bFsjQ;G+W<4l^Bn?7i1&v(9XKP2K84
zOsD1f#3%228l#_WW;X>@Qi!CuBfYhQ=EXF&^S!jQ7${9Fi;~EGZ50)n{$ruRB$&fw
z{AWip+knU0q(8qSO85zOv7_ws!o}0A>~y(<Oi5S&lo~GSvPo3YB;39WsbS0^?3=9J
zWPgh7%g7$Y($0mtht87j;N4*>9vxBjhPk7Ru+|~c`YeMKd-UDHU@S)K3ntv6;Tk!{
zXE;ZGMtNmV6jsL9<o9B`6MsBHu)jefq_Q}9^SFcZ{o&U{LfvDe=v4<<E)s0^0_2Zk
zaa{A?^R;@VUB{<6z48L#&ksfT;0K?+l6O_C@MkKhGX8n*HQYbi9p;~E-Bw*g(#W{r
zaFh|IHvj4Q_%U-YXEl%P({hGaA6zEPq&lAkV4m*wkzK%>4yUif`3haNL}#3*jD%l#
z3!VLH8hhni=CNvP1Wj{0Db{?7^86}Zren1KBk!6@SMza9)HuSSw+KQ!jZj+8XV)jZ
zPkm~j$_y(z!(<nDQqrHhzG%>$xh;OTjGpX>!=$0poG6+OUa7>UGfxNI=FT@y$(&@w
z=L<py(mC<SHC_x;*&Kv575=fL1<FcKm-dIz&pUJ8IeN}$Licdy-buV58H_36ZIBJ-
zmt=G9N|aj^$FGpx-G6PWhz*nHx0)vl;e_0z)Rw;Jvg(nU#Ub~xyT`|n8$V~Qf4St@
zy^c4x&Zmo|$_b4!(>|0vDV<#UnA{DRjY!C11sV2oIf(5^>e{6l>n+PTCTOAxAd_m@
z8VRy^P)8xgFRY<aF0ysJLz`+ux)5V9B0VB<?jTP{3dQOlYf|t*)GB)fRkYzHLr1@0
z??%C2_MWckyfeu~s}9^0#)lWwl4(-+%u?XZ&8RA)h-S~EN|So3wfiM9W|<NQNz^XN
zJ^xCgoGdM2_Py5!?-_mJJToF}@-$Qy<AgOGy($>nSyNW+nfaK>HO6!Ln;PpBCd@h|
z${^$~A1{Rxv4~gY!jR}jyoo&#E;WUc&=9lSYoyxv+O*`iBMYeBu89|{<C0wrlnFIO
zLL@119F>vlY@OH0YeWJ6-|4`b`33ruTA=xzv;-hOhM-+P%?zuLeZuIaitO+UW_!^l
zFG?>LiGpV!r2nWG?X^3MlI2g5ORc<E(A!+?cW0)9zLWiLMmrMK68pCc-I(oRUz)Ce
ztfe^isodh|Mcb-Llzh);$%+t+u#Np-ql2w}iO+4sxY};|$+dRngS*XzvcelX2!*`L
zr_+y|NQq6k1V!ssZrBX`%fW9w^c#W(>S!&+Xgd6~M>g`L)xO1TwK?)F@**eq@bv}A
z&nU{{O?(dgtQDBYSyQD@Rcv(l?pAl#Vib+(ZZuj7p#d@Hm)m-1$7XX%O#NmTHGN(f
zjcGRPQ|Q%qQnAu{cY3uL%lN`uT;0eXSS`(zp#U46-q1@XSFuq6w=XNz2XK!_HGW~C
z_)9D<R}wjs8U5+oY<_AEJrVlH6q$$^hi{6gLUXuK=xcr?`i-iKGnJF>WlPU{%YIg>
zxw2%ytgHRT6IP!YyMltY8NA2%MyKf0yI&Pau}`SYgt*%&A@0a-Wv|nD?K_Zj+@r}~
zRhd@Wj?u>~^KE~@eP>KOPWSEk<$$7MCpkkN)^n}LxZJH<#HXIS(ciMs2H7tz6i_;3
zCp^k95^!PMYzkEID9TD$?-8Ii)D4?hes3TbBotA4Q`K<=4iP}R++*4oVmd4+!ynMC
zbQ@CTNaXmpSfs{|TrCfSD*N{+$K}ZBP}|*@_r~KJcuGtp64mlwG>v?>vR(bo%T6Ew
z$c8iz+2%PzKQ#qr3F|^@Q3FGC4122GoK~D`<Io?Ag_5)VQWxQswCxTi>X!uOePwrf
zlB<I+wh&t(k>O{z5e&X!<5Co#$yUy`=wjW(OHBelKdL!KDjV&PqPD5f6!px+R$Nkv
zqlE3N5=zu62}ceu<DvQC2}I&rsMVlYaAF|6KQL^x-q=;5%{8rwYrAz4&?u&=wc%&=
z4i+31*Mmshe4lu+Ywq*WsK|ldNoAT4Oa2F4Yk?FFNsP5TI@Ot2f>a$xn#{JDyBt+o
zy|v|K$7r8~i>(*BQHTm<Jbtg1m^<ftlY@4>5^oC@8z-x{krZOm-u5=g*BWt$8J(;N
z#8&;NF&X#dSMzqK;-?j_Q?D8H>^P2)x-O-usx<P@i&SYnpqX|{(VV3VPfCbZd8}rB
z7fG=FS#9?zBgul3o8kAVc8(YN*j5SE7;?Ag8s4|o+&EZxk+;8FnJ`EF*j}3(B;zOa
z2i6iC45_L`x)cI{Hxk*)?QYiaFxtfG(KG=gq(}$C+H3|KwECobvE%YG)P>T9G3Z<7
zAqyJDy%xwa4u{%2zPVdDxh0K3eFXCD#P`%04C#nCjAhz33oP+?PrL!Kfbk2#?m{<q
z0b6nsq3{`%5am3JN9rQpM4{M|W*o0Du;h2idaV<mNzF7)9@gYrv56NuJi_Qe&#gOa
zS*BYETSVWVLj!D&*d>o5oTW>hR+;alC0=G+Ea7EJpQNgyrjV&s5=lrEXpCcwJgR06
zCS$_R8~KymNXqTTGKk0#*wpVho)Yw!Gqd~Kp%@az{V%ZKPZ?sPFUuCi60U`Nujf@z
zb&tHqsLxY>iZd4E$}7ki>u6VEpbQ!Ngvz1(BS$D&6-U_j^qrMaTj-+~JKGgvia8;L
z1sUnMdipY&IS|S6mIT5#Z|k?BW`|#snF<5X59@k6D__=-`BuC51`8=q2<C-Ve&FyV
zH7lfYD3IZ_i7P_+#!hf*`4Z18Pt|yr!_8X=?e^S$i2rqHLte<*1X6vCby5?TaH;jo
z^NQ(i-L0r^TQ)RO80%EdyM*n7`m;y9+g{!AvE-i|=oLo_nsK63Z0ifC_R#RQ<#cJ8
zro^uZgqsUzC}SCc$c^t8PB;VhdyjD64#lZ>D{;KM;Glbr>t6Hh7II|&xYpunIMH_Q
z>2a>6QYDoN`DwkZ*sd6gv&lO#u~Iu@6?j2D+zJmtQAPn_(07Z5`L%S*A6;4PT`%@?
zq48R$a#cZtMRblk26v50neugHj2b4A6nFfO?Rp=-OyMKUoI%H2lEy?nd_K5{ELQsN
z?m$4~P+_A_XcOf18%5T{#9D9XPxj>F;1OYqZ0C8eIjJ8@P?vC+agbXqzA9SA6!lH9
zbeG-Cu`7o8Tqp`_D#tk`9&xRDlzs(TS?s}6@t|Os-FAK(0X{7aab?7JTVxS|AhJDG
zUVcS>_h1u9gl14bA<MH6shIerpx<1P2Zb`*ZaAw;1LzET*ytXYg|ukZ9K<s=jLh2P
zjFK@}PH57t@a(33O-uEn`k9xzq2BRT9J!baYFOL4liy>t_lCQ=>YgfaRMWkIcsyDc
zN8xHUXTz0#M2(o5F&aLD*k)~6Qj_X`>Y75;f<V1LTK=j*2Tg_mkxX9&X$=#i<!QZp
zX(Zp4eJj<$r{s2;j)VS~uy~eMmrnvIG27xsZ#BZ^tkU`i3d<I$WIAJU97Q&4C2msk
zR}WoJP+#65Mlu&d=tP&55^6Wr6=eqgc%uo7nSReLBGdl&5qfb9By@!9PXg6OEoa2n
z7#=e2PsTY7Z+nEP;>Fx;F<X~msPu&Ta=X?{wA;FH^#=M#6l*O#<hwB<5x4FzDvsZO
z8q7=^p?1Zx&mN^!_LvAs=)`37+T|>*O1ou8$<aEySg<7{tHC#B1ZUJWe8fdOU--ny
z*6=a5aG$WxtjKvy=aarbQwr9Fg{+}+Av7%G&`ssqoJ#4k?P*Gyh)S^UKvaaQeQ_P0
zuQt^(7OX4nl`>nt^x3B<IO!k5pD9Am=D~tb8WlP{HnA4Y`4;FrrT{G`IstIxY_bVY
zW2HtBQEM6<$NE*di4oVu*UdH5^NlOJ>*Xpo$B23nq+iN#jEOCfUC8;98?jih%vek#
z<wA3$c)v`Ra8d+);-7(a9QQbH*-+86Qgun{Y^OR@yw6c(>Zr6gjLd_*sl}S6tbaL?
zi-S3uexF5Ma%b#9ql<99=+PX}Q=9Nx9RMI9Hj<L6@{*GOeTf3!pVIx}gynvSQFI#X
z+i5alyW=|bsAe#SQg^;A)<J^imkk%c?aenH&ZCicaw0H*V*4{|Q5vMXxxFDo`i6tc
z%gZ25{OmA5{*!bhYWJ<D$AQy1_8%TbC5}dVK$`nhLx|qOr9@(hux0BV_4Cm1f#FBn
zotOsQQ^G>NEfIg1&s_qd{rMf)+v#wJI9~9E@rLGpEa>ve;_FbzQSwz5Dj!1*qi$g3
zzv*hQu1>akccNsQ$tT53AgHrrqBTmmVzW|NT9|n7Q-IlJVWm{Vw$x4K?z@SRp}b4R
z2HJ{_1cE$Ttg0j_VM^$5al9E!`kI6IzH(0`UXfOtG?D^ZC=qCV{q26qqfW-uc2pjt
z3%HN4^ov9YG|bkmD?Kppx6K4vt(FuVu1l~?&Js?%^`X=d#M$;vH~oY&ct54dmOQ@O
zNRlsCO9;Xrf0@NZL=?xsR_@PrlOoF0a7?#aUqlKD1as*=BM&bR6)VU4Oq<hl#NIsT
zJ_yxSH~2z`Vx}l71$+XY0M@;`CVXHI`Wrc27XX0bKm0*}v~&`%6V+Azg*56qItmIo
zsofdEIM_w%Dy`!x>FD5K`Pvnbbhb2gwX}eF*tlB5WaVF|Y6oHygD;Of@>1d&o-=#%
zK8fj;eyD#I2Y%bTS1Tek#32#uIOC+mBJqiftFj`z3xXg^{ZWMmc_PhH2|IL(o{Wc|
zj;aN!<2f{sYwcrE#pcjD%R_!hf9IwVdmLy0Brt!p@UXg)#e9bwKcA60f1YuEd>Ns5
z_Vf3#Nb<o!s?|a-ONy&0KLA(iwL<`KL4zT{ziPxlQ6vEPSIxgv`C#h5RSC-de>e*l
zAI(PZiFe6rxcV7zx4ag?g%+#ZfSka}Y=`ot=Ffo~F7TyCAF%K~JotH!iVI{95(Uuw
zXV5Qdw~j7n@l0G~FhFdQAY3{MKm%g)ciKj?5dTp-3UaJ610WfNANoM7+G(4ag8V~_
z*ZY4HC#R7AL)6L-So;((*#idv-7%q3O*-%y+oI@-daDifpV=q*T|DOk0cVG^=buLF
z7Uygc3IiS<yo>JxH~vq(qBa$X{|IW_*Zx0g+ZE9N(%c~rvyBUgxj7L3$4`w3u=DTg
ziE;n$&M)fHv&jD}47^lh=)W8=Ce3QYhxmwi0tbK~EI0s{R-*%5hb@8sbSOaIVNrud
z&LJ|OY>(cl@l&GtHz0c;=vBKJ8YpvGWWd^ObAQf_1$iv-mR{`C*oU&BB4%^nkRrzK
z^c5v&6bzbqb(-UOL0u6u+EpGJ`ZUryGE=+GnnVnM34S?psvkThH{UyE>%2AA!!=~{
zs6RxnzGWT9VKB}U@5!4Bk|$2$Mntq6zp>%CZcZ@&op{!GOQ|i=z(r(uH@4+#yC-=6
z$ysX1&K-i{vb-1v1Fhm#BN@5a5ao@u4=*C7puQf;ApLPp_2Fu<477G5ns;U2@s4kD
z?o6t}ziSrg)x8M;{UgZ+DqDoHe=)o=e4`LK6Od(1HJR49xcd{)-?*V@NR$cbvDG0l
zLJyf0Kr-GbN^AB*lC5(d$B-~&S<-Ary1RSa94Cf`MUpPL|H<9?%psh5+vw&SHh^gY
zc<O(qPz&`4xMN#^pASYS3BP}`?@_b^5w(ImA_aaUn4khEo`*4^PaXHex?7#qg_4?{
zb@^_!r+7`Gny<C4;vWj#8d3h)RY#f<)wl<_Axo6&@435zU7{n=WvR*NX1lPqb`ORi
zZLQ8kFt3O<L*O^i4r9B+!^=O_U-`upKssb}*+0Eoh|Y1Hz|g&Q<}u-`ogI(pU-)1l
zf*4lKAQko4;Dy-l=Pn9dwOrcVnD+ZykqrCw44KU<U!QuMVan<MLY6ZEDxq*nKyG@4
z8n4Rfu+Q_&Va)2c(CGvGgRo}|%?vVib(*d}!3ACI>{K*6)Gm)ud!KMy98ie}gh2tp
zF(FF}ikoe9v$+~{KmUSuC=OegwDHwT*NSb5bS{x%ejd?dSxN@e2M3S<xr>#ymK&<h
z6!$~)CclFAuZaF_SAFLzwTnW$d=<5|B-MAzCn;BV4MZP<weI$zr{LBf&mVnPu5(ly
zQnh9WH9zn|?HpH+3Fp8+i|X1a;JsIRgnjX|{`U_@uZ3^?D#nDOX-77^xRr?Toi@F9
z%H)*QtRhdkl;%V;?@n_d!b^3zBMizh=eIw*JsJf+%_wP|9<+k+z(yIcyJ>z{3tg>U
zWL6yCWlZjSxu6#AY^AbBb{t2p7HaULT_o(Y*G^%|bx5_@O-&flM*^0+eRKri#FW#h
z&P<cJY4@AXS?;2Y&FzwZN7<ZV^k~<9=qUDlOKgO%qU6uFVovso6nE<?Cs)uIW}aTX
zn|Wd+V5>WLZft^Z*T{f0qOFa6^7iOgpz%#z;#bzYrdVpdPy_W(I|1iss5e(9Y5kU9
zY<<0Wz%kWt!OeS1^9OBrqAwQ=uFn_y=hvT>9n5cDx<p;})M*_U{EkMwVdmM!0rsH?
zfCf8_<Mr0Oy2k>wijkL3BG33npy0Y1zXEw9owxU5XGs-)WeK7`(MMOdhe_|~21x&)
z^C$O9tJ^73`0iA3tRuRZPbBoORN1|bitg6dK9_b&zOK2Dl}cRL3iFk0HMT<V_Gym+
z#lc7}7J7Dn_@VajCP#L)=wJbFewRnnw`G)k{^f$k&hgNx8*z38>W#+7)2fRmwrNOv
zo<Y96*Tq7v*~YW(jsf-Pu;eTws)&F}cB7_}pqNKVSLf#I`_3l?cLxU$Q9uxMziAkp
zGrOewPm4nYPaS?oA0@SZhR;)>Ft3?)EoSMBKtv~AHI@XNBMSm4iFSO?h{HQc1RI2v
z8*i$sUUwGj_#gbJ`pw{Re%J4PG~qAaU@dyklj665uF1b7+ei$CHayG=aPTQ;&lSCu
zF1@>q4>delSn$0I_}pO1U<J_o?rf#Fui$a`{<fYd=v?#zHyqJ@pw?3&^MT;om3lTK
zT*|D=vFFIGRqTBkg1TGe&UhgPS)%B;SOE(HBm#b}6!&FAGU|#hV9w&5U%_#st3a14
z0WqXgoPm<?nAo3x!}qk5MBuh;!i%--l%vhB{Epl?&XJ`nJwSj-<mQ%5ra$w?qpAyi
z%n*V?dPj&VZ-SAEwzj>_wVu#TR$XV`E>YX%qR+LKSUCsvrEmnt>H*3b+}PN{ritGH
zT2hCA3$XJuw0|5Ts6QLrGP>=Wltu7pK30c7eYm^U6k}pMvV2`va4sxOKgpYGvVaNH
z#92ATjY+HX_*|51$k4;l-ssFbu}RTUgf9EE(uw18;Jh2+Vl}x&BSMsB&wM8V*sS5g
z+(h|f?8%8iEbB~<$yDV%Z<j#S=%W#Xadc%oXA&?nrWQ6dEb_g@Mxq6>uew{da=(Xm
z>D(SaaXLm%?z~-W;+SMMUY2<a0OQplrS9e$3f+$o9K4d5^Zll6-f6BPyLlBAc2DWu
z*l2e8g*azVy_G!3^$i;CL_qjNzb>2-u{}EeMzddEfVZ=cA*m~OYL1MYTDO)Pv$;`v
z^YI}C0uqX*f6Tm!WQIyvlyTO%<A{KrFU4J*RacK+H_pzF)UU!WD@De0#6!2;VEm3B
ze-)!c0%Lqa)E(kZ2)rYv)83kOA@2Gq%D0g&=qT3q@zduLCLTA}u4)fqT*Uxy4}1UR
zn5KJD8ZdAH!IwSKC#$K7C9i!Sziv5<o8I+9?V!mLs4Wmg_$Vj<ZZXBxU$exWJNncf
zLk|!}-2@P7-}`V$mFryUt_jCj$NXRwVR?Y$y;`^OMG`hvqen6R*Be{j>rr<H6w}D<
z*g(7cME9_SCeeLp=+uEOmB-w1)bw%a?dovE#<`EI$?Vh%(X+*S@(N~Op`22Y@7O?b
zz;6T%x5FWvXD4>oZM=FoRK(ARvWQndt3-kbJAZfiu<l=)s3I*zuN)F5wcE_<9x?`O
z7NeoexWS-wk4}z9<O}0|%SD=X8W-(`0jKE9D`mgg==Nx15@dHk?9`Ds8|COn1YSd^
zf&WsQO_kRXxZQehrb`^`O9Q+Ng>L5cA5t&Ymfhc61p7E4V;b9P)<ALC70-P*>rxTz
zTtsnMAOT`Ax6k!*h9?i0d)Cu{i8dc?J1dc^J<o#=o3gv#R>73ZCR<c32m)K~oM!me
zGufhCLGMWqhg&^sFkz|As(!gof1Bgbm8f&R(x-F6CK`c-bNA_MfKw5L@B<jSAF*1g
z@GI;#)ltdVGfpGJ64D`H1@u1NnaD)@*5>CC;bHp+-j3aK=86~VizE2!EKL<hE-x;7
za475b<N(;SW@G?UA%$Xofr#N|tkY>u<xW7)Dym{-g&G9voe40>f+!e%w2?WZegA{p
zyvve0dW@>xU=xPdj0~nM<pWEyOsMLAkR-9B4VNj)fGmRb-o{m=_UqA3TeTz9yC|38
z2<tM9LW9C<ATPyv=lUV}a^zWBuQ~Hm5<mc4`Z`ik2eWj~&P}t2Dh$#1zGAxOWa6&u
zKEJF9@Vjf+S6joF;Kzw2pTR{<_pwmAUGg!DdFj)#M~Y;FZavOx1*qOmRejU3D4s|*
z^7ND!I{CS4Ha0qS)f}5V>2dDINf968t7yqRaxrGrotUsdo;$NxJIjEJ0ZfDCYj4K1
z<76PmM)B=m^#`pklCDB$3J%7;qKcm;Q_amcE{{Qz!#MKt8&n*g{Ij3js-UX<tu?PM
z!!K@6J-Uj?seb*$7JFEVD-lwj4Z6jd{<Ol_h!#;-)d9ZM`tY`J9W*f7VRHN5x6Z!u
z?Tp5BU&Uk)M6@1Pd!9}ydbGxFn(wOLUFpr7tN<qc;^t;uf3>2I2$fE}=*9-<9lo?c
z*-37#9~Sijt1bM)6x)I+6qeK6z@XrGvX=l{3X{2CJ(0#Tf7dmxLPh@HnzQd3(H(#{
zqQ~XV&aU_+`!e&S`<V%O?y*!|O?KaFOxg<%C-1VJU+Dr3G?zWxH(ub@vWrCDq#(tQ
z7U7cl8s(Bu1!frXCP02q)^QeZdLkEIr`_XFc6Z!B^01<}$qd>zt*s9gA0V*?+eagK
z$1PP<&CvJJy%j&!Zb0@&{RZFGsFzc_kCiN#2<9|?112k7tYT@`!)fbGE8DXN5yV7u
z#Ovj1iB0`@^Z8}(5y7E-x&~4%zBO>X_IA!3wju@rNi1jYJeBUzJ(+A>U1w-p8g=!c
z00)ob@6i39`l4jh?0F=Tdips<`CjdHmtc-74p7s#B$DBhk?Lsv*hccBJ9;wP9U}K^
z5e4m}KcQ|OA4GF92{BoqeNBSQcPrU==RTO@_mKWZ|J`l*^!P}TxHtfeX18V84PmiJ
zl`of}u2Wqsydcw11x4~CTFycY%tek~INle}fol=X-LGw}iVMzk`cwDAC;Tdl{#n%k
zf*=AwkH1r<VlQ}luWY3A2JC}@hZYNuh<lzv1hjoLAVsP$p><@oQ}nwouu2R8dNkJC
zTDl!CK0I({d&BJfEY?pW%zw;GaTPj60)R#S)#AoCJI4_?NVbJJ_~pkxoCQwHVg#Wk
zLUaIN<J|RQF?>a&jL^7S7d-x`vc%F#>ZPs5via7m?D9cP4Cnxpc$nqcM{eOX`l!MS
zfk6cD$dV`bNhgv&IaBM<Egc#64<49uV>v-oE$w54R|8%A2tX`t)Xx_joAH<b9hfkd
z)8YANnd7xMLSw6u4^uWutCSExE<&P;q`IUMTDd=HwX*&>*$$i*RjgQ|2?1#31u8TH
znSCD*fY%gG>cXe?^@zaANc?RO0B8KC>wS6aOLMY&G(b#GW0$#|`XFHB!Hd{C`GmtU
z2ASiUmw(kCgU8mt203kQim3gy`Jqf$l283gs%{>`f34x0fqFOL0uciMwe?Cx#zo}m
zKTXMIU>3Gfl7=7vC;~PdjkktXQzQ6{t%GkDTUo!lz8=j6SI6c7(9XOVw0$!M8K%0x
zOl+&#`5?h(!{M&rgDL8}7+!I_#a(wL1y*-rX%x;c*N2d&FM5hWm{y1?k^|4C?er|g
z?nLcl5OFYua`mhrMs1syI@P`*D4NV*c_NlTWd6CPyT|-N32J%sH(kI51$2nsg{}Oi
z0jOB4p8M<cntXz=%pT#YN|xcFo0jNxP8XNQgM}}j60K&BiKrgBO$y%zbs<3j^h_>N
z5XR{iL|;m#NP=-#ntGiYqjhrJnM5Cjh5*D1+B~-(2qp2D`F4AE*@Bavjra2jX#EU9
zc&F$2cK6x!rYz-f0p7zw6jN)|+SNy&!u#?Uh`w~?jj(qI!U~8%V316#<zh!XOQu-d
z6&1ZbJ~nIng=)(ef(%a1GaHW{UFz_2gTr1U&AaLi>d)W6so#;lHhpfkz>?f~GBh-6
zGa-7A)UR=ef%zy~9G@gz)d4&e6F%_vp@Id+Q!a1?pFZ4osJ?*#B$2=d<=?BE*zb@5
zQ8WO6128|tl=pwHJj8ZT*r{m%5_@n7fTv0X^q>i(CjJt@!}U*|UAs^S_z4Y=n}A<p
zKpt)=@@#-(A_Nek00cM$35*^foCFC#L<QLag6C)e3g+LDY;gfh0+1b01)qILV8907
zU+LIL$bcIt0|Q`qh#Nxxm=z2e@cYLs2x1B%9;gKjL09j;(zrCh)^Cs<$Yz%ShI=2v
zP%JPQ$aX<YVL%2y17gL<?8e|v4?w4WDpUg-FaEJo2N=jgfDb}JD?6#%4Z{C=@rVh|
zPxzM(Ud5TT-@G}JCWEx6GlE0}cn1c&fh)urN^ht$iP^G=!~_p91_^4t`VZ#*{Y}Ha
zY2cvfU+4Zs^LL{DYF1St<AMOq6AeQKx6$_p?-SS_0ohb2ZY`Lv*f)BlfN4zuaybF#
ztLp)f!|?pPs%|xZaxXS<Dv;y-b3hE?EjJ8+hu}o=+qRPe?ZL*mi@iL&?f`6AX`JzS
zBtHZYD}*;D&(r}|2~-YKMSQ-G(IffQr~s4fAagAycZU!T?M1N285dFl{xOQt!-Sm=
zF*X~$HvYVCVS7ff>6IhS`uIxP+X<1Trn~a;`K&C(G2*c1G4ZmR_o24upYLv1Cqw{k
zHW#_FZkI>hsesAI!9-S>W_MYqg~2xW^_Yk}<y_0Hp{-w5$*thTirXZk>$rMAUmr#M
z=`|Ceb7LnGn(*~Pn~CqSrHQs0<>c-fS8RlI%jxIR0UF)5wzoe?;bd-;wwOt_hPg9{
zb)$A#$ES~%{dT-PD};XHn}dwZe;E<r#i9w6JYkNKk4=MqjtZA-X0W(~UP=IB@45dV
z2|E-7G_-|nV73Du)2*3_Wnc9uw~E(my+QlDoDBm+2xAFqZ@9$b_hkdF)dR{kBUH%7
zS1IBrzyW%|i;mlX#R+c4y~?*Of3!JYo)!4TH~yLGU(qW=uhzS*q`Foo+Keq7B$i)h
zfg|N_=wVgnffZ({(A9C{sH&63DtCe9$_ssD9Y>c?&}oaDt0_FJapsfbytz%TGX~I1
zGj>lX%rwJITffuBf3esI)uC3U=HnbQ!Uk?cGgzOyB~+Xnii2^R(-xzxIU?TZ1vLQ}
zRB9~K+#y%qqNAS03%gv#Xuww949acqK|Tl#?6JQlZg=~W{LAX@PZ^GpZ&xt^l;?zO
zb8p>@AHIW-@EpB4xwiD~l)*2u&l3vQ(9EDmK4F+MhGeq}6mnH$#4iMRcpRXZ$Ny9d
z=v$d)H^#(tgpj1q#5Sho?H-ceTeE=)Z9Ld6f)EL)lw*f!rrlYziUEb!gZ3ac;3B~Z
zv;|Sv8NCN+&;T{xio4%u0U~>d^<)v<(GC*sKP2L>#>7x^!G+#{f+`tW=H2=XZ|}YL
z2b!*1uq;MrvaXIiQY8n75r4V>k6OtqSBEB!we0f|>lS7i&}n#IB-p84jYU`F5={-P
zkZ>4JL*(XJ#o{XtY7>&K4JvMXDa=|yz*=ggz@50DRKld+$UFUPTNlRP;Y$PL`No%O
zb(d_^j*1jwy;_Db{fC`Xgl1;r_w^7TV3Cd`6QE!_kvWkec`SXfMx@kOX^%ll(z0!@
zt60{0^45D-rPdcqHw&~7+&-!_jt~&9{skcX2T1-07hvEh|5xAsEfj%r|JS<yM*t3*
g`Trx$zsK(p75~h(_J=O#f|djF(#lfh5+*_a3z=$`?EnA(

literal 7889
zcmeHsXH=6}+ivU*7MhCEqJZE~rT5?rAShKK6e&?4fKp;06bS*HIS8Suj6guh2u?6m
z0YL~5Ktm#3YG?sWXraZ3kkHS=th3g9->>()-?z?>bJqFstiAJOKlk4I-gmj~Yh&$g
zElvrD3xGhNQ#UNlZi7Gvf$l-j@uNWVBXVF9XpVYWS(pLs7Z3>+Gr$0PKRvW`4F!Qt
zi0(fJK-sU(122!EZrGR~`+8LTh@9?94IvMBC3WA?1!al|3W5itfS(|cX$brt3hr|;
z;y%j%qQwmxdmmN!F%U>v`-a&sj*+9w40M)HgvZoZ1az&GRKGc4{2?zuLlZ}N*7ht*
z=+|jQe|x-#&@U~wobJW7UK2S25Bs!vaZBjq<pj%Ur!!ZPaf6S~3!^R_7CA2W)F&jj
zbEnU^zn^EdR$8>4_CMxYES(2CQO*%|O`Il-@4^6a6N>33hQ=re3u3B;K+TCS-v0!;
z2CNcLfe;Av80Z}afi42g0TAdo=wJNxZw~(tll<>U{}03eS<`=Mo%@ph5%Dj#^`9p`
z4$Ap&ef=+V_@5{HNAv&wY5Xrq|A@E-`nS&Y-yHsrg**nm`+vfS?y`xMKY?6S1u`4*
zr!}zP=&q+BfY|^iam}pc86MQG@AJc*zJk8GBEAUI=(z+<82-Ro7<S2lEXOWBJg?l<
zBjGJ-0m}F@A|mL{?Zwq3mE!LC4lu}RN%*lQ(uSZ?X06*AQ7LQXg$bS?pEq~SM~AL6
zK^7p%BQ9Czi3n_mcy{AO(DBDN`5T1pVb3alJOi;*$rF4GdOJ?NA<v4a*HK$A2rRxq
ztHzyHI|@4Z=Zl!X;9(`DMXv8@P2^B-xpYr?(BW(5gM{1MGIN6i<+844n?_00B+z4!
z%Spt2H?giZ$5t?JIafj^H{>-S;qEOhD3mrfN_YOD9v~}>2;kIk54Z@0tKruy!?jdx
z{bskf5D_J5f;_22;uS|9OiXo<4GK!{-r&V6TxUI6yPzhitUeppEc_TgYpNi4Zf9#D
zo5ZiKseb8-`}NYq;H~Y3-*dK3NA&`F^jlniJ)viit3v8b$(4|GeR2py*9oJfqFAqD
zO^jZq7#>A8`UCr~(v}bgFB-a|aI1^rOl=j96J%B0@L<JFUfK_-ME8#YM<0W-#PACy
z;-9KC%`+cGVAbZTs*6=c)w<tzZSYz~*!<Ne-k!>!!_CnbRHj)qBCxU^gnw$L_IuS~
zgFi^@9)+zmYUCwO>%pm#T7fBj$WX+UvPBoLwt3lBtQ~!pPe1hg>h3TDs?AL@kMYXt
zoVmGcT`@fR0$NdB1F0E!<85VQ&|O@b)}_t%zX3J();N2r%~4C<;TGQ7Tvb5b<BFLM
zKB;9q@Z_{FbGXw{GOL?9LBvL0F%%c{v+%C`)!DN|E~j{rx$rcjR*UhYGXR>Cy6zaJ
zWwa&Ubxz>9%CwhOW>SG>I?~@)LmDrc#<4v~i%@v#t%t7?&iu(+<bXZFyQ&{avqvli
zyXnqps39Jtd4%C2ABLbj!CSex5(Om7$Y|ep3bwPp8J#r?mQJlNPjw+(F`-5#j5CJ)
zDZLnRUAvp+W;SM8grfY=R4eJikUIVl#eSP*3EN(~%XtyC+tD?{wr+S0w`r)UQyQWZ
ztYWSXm@D2XmeCm?u!_JNW7ZI{Nl9>`+R5C6o>S|TEZN&sxsKa1(whtV_>e-h9WUvD
zgjdfI=d&KWh+}A0=4lfR#A4PBIo9Vmx>+c6Eo}#_icgcWn~*@qPT!0R$)ktj$D;XF
zVPX_3@i8wq4^wj(jUBDJ8_f3^AE;N$Q%1H@e{HZ()VMgeQGN4_0CzM4%0+wRu=+L$
zk6@EuM{u=4Q!d+F?2h{TW{V@X5t5m#?FCeWO#e9(*GWmk1#vIaFb}Q2iez#vuR~-A
z0vqSsyQr_(flK&qs)K_l*Fr&1xt&z@UcJt-rc@TB)LG!bLed|?wgW@wUUf7O>Xf>R
z%aSmf>8szfnnos!=Q3l>C}I|yyNt{|uc!dprun1sY#&9>Ns_$hSc4*DBvxwzvrYVL
za7Mqdcrk~S&M;&u^qtVX=NJkN+qR_>_-jMj+^t4C8eUKm_I>OxO{i488=X@Ap)~14
zl6!DYazc^ib<-lnp}~PxD7UlDWajW=^|p{Hxn})8vi%iaT2oUza%N{LZpS4o8t9zy
znEm~-yyBf(gW1+pLjzrkU`^9S)wjeCzvLCDig1ZxhRl^!Rktr{d*H!a9ugl)o322b
zxXjOT8MCzZBFC`tO5Xs<ab(zdLom8mEjIbafp@=QyrZv>O(1|XGD-vTm7tiRv^7!&
zwBq$=MCGKUR07A>qTxzUMRnPw6-Lw}_vgWt>Uq_FkyKa4Hq*HosVnAnDL(?-oM^^#
zFzMXYtE#ih9Y4ziFAWQ!)gte?PgeiDz_{CyWd?e+eCsi)NU>~j{NYfV!$Mz^VD@^1
zZ7JY_GhK$>WA|Upqsm61nb@rlp2CKUV!Thh7n=nB?4wL`bO^V}U(L>sd2Gy6NVj}U
z8dvn-5H)LBAK58MzKYT~ZEZuD9jz0*zvG0Ch@PT6(S(R@7K-0tZk*~0-No32YwaSZ
z9nC%t#D=opmZkI{8st>RwsKvFbF#4K!HMO8BWG3MF>N#7H);`HdSr->5YO%;ZI>M=
ziN_^!qgB7hC7?7ectEu)D&(ay2|%bf4FF8eX?<e#2%E}p%2CB;a$+y~irquM5fI+P
ztYt(Z=!AUdp}W=spqP?q8RjQUJd?#ROdMKq8>?q!IQWHQVu+1<g1JWTm7BIhH=>R7
zwT1U5ElBs~@&_U%ae2vkBkc1XT~wb-;A*VToAfq+Yo}Jy!svV%F=<(Qjr)<B5%~+o
zY6RvhEZkGvLqR(SVRLMkU`S4XsW!VdVD&F}Q27%an{T%FoIg!0=uOYr<({}KLj`;y
z2ba8~na*9~w(!3ZKlMJdq~?qbQPCtF+GsYZ51Dg6X|LKhV0^ghL;jez2h?VJnL5`B
zO(}&?l5ZSt#%(1%VIljAR`VN4zTNPNk-AI4#$o*TRuOJC24!8S&JA8c{|JBabsoH`
zG}Ri;!qYZcO0tDa81-nP-MMs2iq9D@4Iq3*tEP6^ns0wIiYNO`WR)XarGO-mY}Ib`
z27{qJ<)@QBAr(#Py(aKLQrrGCo7?L&y|ZEZA=f~h!+xZAwC7t$BllMbWFl4zV*Jo3
z*tOnxqOaHE`(#6vw`p|Dyjg4ay+@Bs1IEc*rhfT7*!}&*yJlUPX4!3}QNSe-L^qri
z(8r|$9?EX%->M|P4t3}it%i(7=w)oa)4!@MjK8piZIW6@p%LU~m-lj0fH1g5g$b@x
zww&-{oaIsX?{8|Xp<xY;p{5O-lk0l3q~J&*EHv7U7gy0(#vfS{ts9B#|7y&Qki`HI
z#XBy#VQrXI;TNJ6tP+A!X5xzByFQE~$c=uUvky8N-ce?G*?FC4GuI9{jPg%llQ6m9
zrSbD@nWorX+c^UNM>DrlkRBmd%(N*jp4;B~vSd9z6pOkMoYp&n<A40t#xHJRA$h}7
zzwMgcvXo;A+AXCO66Bdx5^Ab-+c|ff%CiJ>=sFRti-`^KGBVVVDsDSQklHx%bptH6
zW8n>j1~o*iW#o5w41JL_$z&(Qo;R+Z8hbOYwr5dQfTa7!8eLTvLCe#alupN!bAGb0
zgts^3@>Oxk-9_0hP^jqG0}19w($m^XvVOQqZ`D`|pz?$4jxLJdQFNkhO@%DueAAbK
z3ozwX(-i=uBpz)o+)Sg+i{yG$vwIQSpH~p@Zae<CJ))tcLM5gY<Iy|QT^x{*6d=KT
zPUMDe8jn1S^z9*KMMJ>#f*jXpK%gVBDdb2v!B|x(L?*zD!U+#5vIL#c)H9Td)&C-j
zUoz3)y}5%;2sAPj+ePW*Wp`7JML${X?%cHwk#|4pLU7wWZLSL2KC!{@$m!T@daw_Y
z@LRloqPr?!37@aWrcOfE%}#b@K>GL7d1#EA`(&NE(@TEtR&1WpRYd&GoQ8xj!l0pW
zdbpNU5!S1ELIRhI<*ltGrKB-L={%!qAKw8jd0|ioWr7_TT|tRwpAdIrny+<T-YaJW
z1r!v2j_1uijmoE=(%JpJ_gBcu`304_@fmo-(GFKDjkEO3+NkL#+^>-^4mq);N3>s*
zJM+8`%|kr!aN`E8;hwN6*02bgjl#Oxi0lKZ+`+pSYU`5Okyg@2uAE_dm=kuo=2qdx
z-8a_;HOT%tc$Vn1rC<-Y?;#};QF%r4GX-EZmd3C%d{n6h5>Ke)_7ygP>(h)Dg2Mn=
zQ%e{HLy<{w31w1ebyqG|v^sS1`Qo6B6!Mqn`k(jiO*^)(6je(u<CJ#{nN*FkTd?kl
zKF{s%^=g8=RtC%TtVdz26gZjH--<{MyKf*GbT&)sTWU*QEx!%TT4eoxG+7-Bdi&$n
zW1CP8E)0Nx2*!`X+Po3siw-S?9!97e5ch9RP-Y!=EY86hD@w>pcST%s$GOOCW`rch
zC}!iEbo|!7m2GeJS;CB-ODT~$)v8MpPeJ#%y1V<32}ua*j^!;^v>Y+^-g3X{NtM%C
zoBK9UULL%ly!khloa^0f{pqnrs=<=`RK4hKn@A&SC`(JK3Zy3{CxW!XYW^rrC)U1R
zG|77t=1sqj-dlaQV@0&etq1FvxcSU}PDn6}-#QnxvUaSh;Bsc&+isP}lp7fWG<bJ2
zVD`*3AXXG7ZI`XVMu%FrqIk6CDu=se<wYrgBX-qovqmcTeU_7n^=vx>k%}6Uj*~N;
zy70F<Nq7uu_vRI)t`{x%TR|-XiWIXQpuMk35;F$c8w=dzpC@}<UjLH=qXZ1ub=hXR
z`{w=}wXcg19jQ1zpD4@St#+GpCtQM_<?x^Xe6@UW-2O+I4|u^4)g7}zzb>O{<HyV=
zQHPz}z+(XtUZFMyq~d^%>`!@qOV)ljZ5ua-r<pc28urwY^~E9pmta9IvjF6gi$M&|
z`YUVXOvVOqQU&w$grHcn?dxOXRd6YMUUJWAX%oL1n<61(n735}iKyv0@I}OMQRCL4
z(3Go^pZF+Eo^~#1XR{+qh)~)-k^i^YqpNlN$wM?INk+61<w&O@-j^q3n`vYxMSsIA
zom`QtJ>%h&iTx0cqQwR;REkxAYUtX3xDz<cOl9`mGh4mo&-)PL5Tq~S%ESa2Qj{o}
z(Fla|GluU>Gz>*!!yi1t*KLR5Qu*NG8p^6f=X&+CA!oI{0OI0{gUx?`db-QHbuQkH
zB5{Y_S=UJ&Woq7K=sZ-uE>H*G*v31L3E}4_gq?M3qBI@lKpA_Sxk1%qn)0q1(|lKh
z94j6H*udwI2DaU6Ax<C+JjsZP6U-J^C<!?(<}Csgjmhyq)P!B%WX;$Vn)GZe|K5mf
zNVY1>a8y4hv+MQAyrMpc(XfLD3La#juVR#MA#-{O^(qUON*-bBz0AP^%{)FA>rlr&
z|0*}7W!&0F?a@YJbopOW5ZZpSP|@W{87+f8&#fXuCtKiaMxt@Qj#qFWaY;jiem^*A
zwtg(Ms4N#T(i<5VqP%WvLm{&RlXGgS8$gzN(W(1~aGPwPBV>|w9&2Umowr(leT!8=
z!~&A`{MR-LcYax&qCAWaey2b-3Tej-_uO6+$dMBON|krY(Qi5S(c!FCxY}Mz`mv0`
zRW#h&ZQJvCj-)Z2e%-d!rg4igc30Zw?DtzR=KI{Dc=9>@+;=kP(_g8WD0ZheU06tw
zb(k6a5kZY-=3!?vkEh2aq?Ir{L(Y*B68167OH)Cb9hk2R)>>80QNy^@OguWM#QJ?~
zf8$bB!rWem_>S={liHHJv6UL_3R#a$dDUZu^30+_PTE+!ZKSF4W30vsX=uKtSn0R@
zt$GD7nuwcTCYWMELX=k|A$28rbVN-U;6e|>4LoZ&Pa^vei6>^wE;uI#z9m+@b^`5h
zl#+b*JC`WJlWqEoV}B;2x6OUA_yH?X!!|g2tXIKnuk(#=%Rz(N)OCh?dd=%@<bEv1
zZn{i<&1&D_n^rgWr*oYT8FwsfG-&jDevhEis=T?ePoo<7CzigT*n+FMmxIMRzx!Fs
zfHL0ZjibgPwC4J?f#+GNA1k9EnSXHOLbmLCDh-O%Cq?4g8whDOFUkFr&{HZ$zv_2q
z`H=Oz{SP#3%zJZZ3(|5$duEuVJ_T`xu}*D1jN>RHTy-|`6~`v|5BJ%`O@jXog4Y$i
zrclo<s$43_UU;!XkGRApzQnw^73Sz`7tk~9;uG5HP#}*>q-&Lbr)tXwT{#T$D<me@
ze>gSm+dVReS7MEB-DEJsb!5ouo>4t3rOS+oTI!oqaiFOspZ40aZTA>ao0sYeQKm-_
zNc7x8SQ}h*zev}qm3^iD(}cpSE{QkE1!K$5!MUYXHNWq<8ICh~dznw|sDT$OE<@gj
zyUCrHXrjs;2X%jmya3aY==mDZv*l|AzR9>nx35@ZcXa`!*-h|~+V|w2CkE?UB!;sN
zA85wus~bW?aG5$aP+zz}TrIhv684}GZnS6BZv$kbv`qb(AK-F*ld_U;q^_BEl!N3L
zSLV<@;Cko2q~<N&yEiaiJ+;{TvM4onv{EV9^+RKRPb}hspF<OgSdhPn;_>aHi<3JV
z9=ss(`(|^I_kwov8)F~H2*(ar>ywca@QNX=R^aF#&#<0gd;8GMYc|{yxVSBmZ5(x-
z-%_K*f}Y*YPf3VGRsNVZ6f4x^G6n3KLwC3evM}oFsqTeQ{^p}h=&t3p*Fxp@7n0*Y
zz%FpyLSqI9w~wX+#(P(PV>a@UXyQ0&<u{k~A{?DIaVI@hEtn*?Vt{Zi@qE)rL(}5h
z@2m(q1rg_?FlvV4vHC6(@B2J@t~VQw){8|Cee}7+)V9gxHrFUIPvk^U*EQrzTlO_@
z7=sDCc+|JO_Jl`}0l5<H99U9jyhsbQAuweFYFhJ_)e`XK&96JXq&riocP~VIMc*eF
zPxRMS<S&LZDipjp(~+(nLx0^y2Jlk(LmQd2!L_bcvZ@Dhp|--?bZLzHk^gZvw<6$x
z^dZ2Zt{v&RPMLe!KGq-YiIJC{SpSW`yuQ|(rML58C^dVtHf(uaua;%b?Ji5XmF~X%
ziMnA%nao5kW6UVWhJup>OGm`R3N<zFz7|p|L8RK1)L(q68pXX|I_7c-jL`dGX+7PJ
zPv93(hid&6?Whd5JTM~A6?473U$FEhlm@_Inn@5@E7c>?X1^c~yhB+%mE87HT^?t$
za^%_#FxybFX>dYn5Pou(P_)2z;T_@bYR}PfKPj-t035q&C_?ikc<Jd%cyG7^1=?ph
zhYB)5Rkb82*<%gI$5~qhmQKx}3R(R?Uh7(3Y`?Sqw9JO9q*BZRXfpon@ZJ5YkLE}4
z%Kz3GeQ=q$;NsvRkxAEW9XwUaO{CVigr1AP4bGBGp-V;S?Z)(9hBrb?Q2RV%+xu1&
zz|Ba56FJt&6w{IC!zM3N06IziMNg{_1U!f}^Lat^zX@&4$VR!_(}lzawW->tN|E<Q
zzhVHrH|sA?b^2`I-|MYi(K?OPB@{7Jf&y5;lex3HH$-_juBmfg?SV2Pym3%F42hu=
zYRLf(=0hB?#g;eks|BlE#~pP?Scu#C@}OGVdzzKT^29t<PAM4=y3zq&UrIXUAeuy$
z-ZL0&x{|h4=53dueQ46F&YN%Mj-GmbK2Q5tgL<9DzKaN4_<5SS7B7u$8)uIDhRfrV
zCQZn?o)w%Y=8v|I$y=~?0K$e%pAYapgdFVW(FEITgRWAiL%`|BL5lOcOO_2^zkE77
zDGCADMKP0|Ytesl?w%3Bnxl7h0sP%_S`yY*-s|lkirkpsP{H_Nu;#}23)gZ?I*YqS
z<B6O7?WPOey$)QGsi1RUIZN{pjm1>pB%!N5CGAa%Vuvx2cG3LlmdiWhU1k(Cn%A1D
zu#(brVd>|9kAKEp#dWkw{cg;y1R(RA33r))ZSt2x`$**7tDPNyXB!}MXe~#!ceu}&
z{2Lxj9;(>-T%dm2#Q<FyXC@OoKO(WuHm|EanS>>+g!NccB~Ej&_{i_%+G>uy>*|G9
zrP%Snaeb6b%<`8!m(^hgw<DfM*^>Y#zsvNuuAHtFc&r%`8!i_PS<8*wTUcc^)kIh*
z>YJ!+G;+W4=ZU6B8bI_x-bd11VxyOV8ewIqn(HRT@YCjY`KXFbcBE2_;oaZDNz(Yd
zgvC^ovm6MZeBAvsXWa;DkB@;D!>DUI{NV#2!0VicNkT5{8I6KR9)i8RU(8$tZkPuB
zXG-?jY7QzWk^Z41l{&!Ioq0|KmfR;6adMr48JT%>aE!1(;<K&M?w*rp#0GRIn+qfW
z%$ghE5~I&}8R3(9-BnWo==B`ergt?r#TXz!EW?$hbHtNc^&(<1(4eK8eqMeUhd|;D
zi-@owlr!Btv`De<Z%V}S`aZ??d3LoIpM%ZwqwitcxRIz3Winn0TX0sdav!mRK(kMP
zd%ge0<;Q>ZcIf}2JFtuYUqS!!{_y|21-$|o!N%CsBE<?~5@5HW8|JoVWxwA2?SBF|
Cw2k@z

diff --git a/Templates/BaseGame/game/tools/assetBrowser/main.tscript b/Templates/BaseGame/game/tools/assetBrowser/main.tscript
index 976383396..dc41eacb9 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/main.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/main.tscript
@@ -84,6 +84,7 @@ function initializeAssetBrowser()
    exec("./scripts/directoryHandling." @ $TorqueScriptFileExtension);
    exec("./scripts/selectPath." @ $TorqueScriptFileExtension);
    exec("./scripts/looseFileAudit." @ $TorqueScriptFileExtension);
+   exec("./scripts/creator." @ $TorqueScriptFileExtension);
    
    //Processing for the different asset types
    exec("./scripts/assetTypes/component." @ $TorqueScriptFileExtension); 
@@ -152,6 +153,9 @@ function initializeAssetBrowser()
    ImportAssetWindow.importingFilesArray = new ArrayObject();
       
    ImportAssetWindow.importer = new AssetImporter();
+   
+   if(!isObject(AssetBrowserCreatorGroupsList))
+      new ArrayObject(AssetBrowserCreatorGroupsList);
       
    AssetBrowser.buildPopupMenus();
    
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
index e95ec0572..0d63f23d4 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
@@ -512,7 +512,7 @@ function AssetBrowser::buildAssetPreview( %this, %asset, %moduleName )
       AssetBrowser-->previewSlider.setValue(1);
    }
    
-   if(%previewScaleSize == 0)
+   if(%previewScaleSize == 0 || startsWith(AssetBrowser.dirHandler.currentAddress, "Creator"))
    {
       %previewButton.iconLocation = "Left";
       %previewButton.textLocation = "Right";
@@ -830,137 +830,6 @@ function AssetBrowser::setTagActive(%this, %tag)
    %this.rebuildAssetArray();
 }
 
-function AssetBrowser::loadCreatorClasses(%this)
-{
-   // Just so we can recall this method for testing changes
-   // without restarting.
-   if ( isObject( %this.creatorClassArray ) )
-      %this.creatorClassArray.delete();
-      
-   %this.creatorClassArray = new ArrayObject();
-   %this.creatorClassArray.caseSensitive = true; 
-   //%this.setListView( true );
-   
-   %this.beginCreatorGroup( "Environment" );
-   
-      // Removed Prefab as there doesn't really seem to be a point in creating a blank one
-      //%this.addCreatorClass( "Prefab",              "Prefab" );
-      %this.addCreatorClass( "SkyBox",              "Sky Box" );
-      %this.addCreatorClass( "CloudLayer",          "Cloud Layer" );
-      %this.addCreatorClass( "BasicClouds",         "Basic Clouds" );
-      %this.addCreatorClass( "ScatterSky",          "Scatter Sky" );
-      %this.addCreatorClass( "Sun",                 "Basic Sun" );
-      %this.addCreatorClass( "Lightning" );
-      %this.addCreatorClass( "WaterBlock",          "Water Block" );
-      %this.addCreatorClass( "SFXEmitter",          "Sound Emitter" );
-      %this.addCreatorClass( "Precipitation" );
-      %this.addCreatorClass( "ParticleEmitterNode", "Particle Emitter" );
-      
-      // Legacy features. Users should use Ground Cover and the Forest Editor.   
-      //%this.addCreatorClass( "fxShapeReplicator",   "Shape Replicator" );
-      //%this.addCreatorClass( "fxFoliageReplicator", "Foliage Replicator" );
-      
-      %this.addCreatorClass( "PointLight",          "Point Light" );
-      %this.addCreatorClass( "SpotLight",           "Spot Light" );
-      %this.addCreatorClass( "GroundCover",         "Ground Cover" );
-      %this.addCreatorClass( "TerrainBlock",        "Terrain Block" );
-      %this.addCreatorClass( "GroundPlane",         "Ground Plane" );
-      %this.addCreatorClass( "WaterPlane",          "Water Plane" );
-      %this.addCreatorClass( "PxCloth",             "Cloth" );
-      %this.addCreatorClass( "ForestWindEmitter",   "Wind Emitter" );
-               
-      %this.addCreatorClass( "DustEmitter", "Dust Emitter" );
-      %this.addCreatorClass( "DustSimulation", "Dust Simulation" );
-      %this.addCreatorClass( "DustEffecter", "Dust Effecter" );
-      
-   %this.endCreatorGroup();
-
-   %this.beginCreatorGroup( "Level" );
-   
-      %this.addCreatorClass("MissionArea",  "Mission Area" );
-      %this.addCreatorClass("Path" );
-      %this.addCreatorClass("Marker",       "Path Node" );
-      %this.addCreatorClass("Trigger" );
-      %this.addCreatorClass("PhysicalZone", "Physical Zone" );
-      %this.addCreatorClass("Camera" );
-      %this.addCreatorClass( "LevelInfo",    "Level Info" );
-      %this.addCreatorClass( "TimeOfDay",    "Time of Day" );
-      %this.addCreatorClass( "Zone",         "Zone" );
-      %this.addCreatorClass( "Portal",       "Zone Portal" );
-      %this.addCreatorClass( "SpawnSphere",  "Player Spawn Sphere"/*, "PlayerDropPoint"*/ );
-      %this.addCreatorClass( "SpawnSphere",  "Observer Spawn Sphere"/*, "ObserverDropPoint"*/ );
-      %this.addCreatorClass( "SFXSpace",      "Sound Space" );
-      %this.addCreatorClass( "OcclusionVolume", "Occlusion Volume" );
-      
-   %this.endCreatorGroup();
-   
-   %this.beginCreatorGroup( "System" );
-   
-      %this.addCreatorClass( "SimGroup" );
-      %this.addCreatorClass( "AIPathGroup" );
-      
-   %this.endCreatorGroup();  
-
-   %this.beginCreatorGroup( "ExampleObjects" );
-   
-      %this.addCreatorClass( "RenderObjectExample" );
-      %this.addCreatorClass( "RenderMeshExample" );
-      %this.addCreatorClass( "RenderShapeExample" );
-      
-   %this.endCreatorGroup(); 
-   
-   %this.creatorClassArray.sortk();
-}
-
-function AssetBrowser::beginCreatorGroup(%this, %group)
-{
-   AssetBrowser-->filterTree.insertItem(AssetBrowser-->filterTree.creatorIdx, %group);
-   %this.currentCreatorGroup = %group;
-}
-
-function AssetBrowser::endCreatorGroup(%this, %group)
-{
-   %this.currentCreatorGroup = "";
-}
-
-function AssetBrowser::addCreatorClass(%this, %class, %name, %buildfunc)
-{
-   if( !isClass(%class) )
-      return;
-      
-   if ( %name $= "" )
-      %name = %class;
-      
-   if ( %this.currentCreatorGroup !$= "" && %group $= "" )
-      %group = %this.currentCreatorGroup;
-   
-   if ( %class $= "" || %group $= "" )
-   {
-      warn( "AssetBrowser::addCreatorClass, invalid parameters!" );
-      return;  
-   }
-   
-   if(%buildfunc $= "")
-   {
-      %method = "build" @ %buildfunc;
-      if( !ObjectBuilderGui.isMethod( %method ) )
-         %method = "build" @ %class;
-
-      if( !ObjectBuilderGui.isMethod( %method ) )
-         %cmd = "return new " @ %class @ "();";
-      else
-         %cmd = "ObjectBuilderGui." @ %method @ "();";
-
-      %buildfunc = "ObjectBuilderGui.newObjectCallback = \"AssetBrowser.onFinishCreateObject\"; EWCreatorWindow.createObject( \"" @ %cmd @ "\" );";
-   }
-
-   %args = new ScriptObject();
-   %args.val[0] = %class;
-   %args.val[1] = %name;
-   %args.val[2] = %buildfunc;
-   
-   %this.creatorClassArray.push_back( %group, %args );
-}
 //
 //needs to be deleted with the persistence manager and needs to be blanked out of the matmanager
 //also need to update instances... i guess which is the tricky part....
@@ -1474,47 +1343,6 @@ function AssetBrowser::doRebuildAssetArray(%this)
 			   %assetType = AssetDatabase.getAssetType(%assetId);
 			}
 			
-			/*%validType = false;
-         
-         if(AssetBrowser.assetTypeFilter $= "")
-         {
-            if(AssetTypeListPopup.isItemChecked(0))
-            {
-               %validType = true;
-            }
-            else
-            {
-               for(%f=1; %f < AssetFilterTypeList.Count(); %f++)
-               {
-                  %isChecked = AssetTypeListPopup.isItemChecked(%f+1);  
-                  
-                  if(%isChecked)
-                  {
-                     %filterTypeName = AssetFilterTypeList.getKey(%f);
-                     
-                     if(%activeTypeFilterList $= "")
-                        %activeTypeFilterList = %filterTypeName;
-                     else
-                        %activeTypeFilterList = %activeTypeFilterList @ ", " @ %filterTypeName;
-                        
-                     if(%filterTypeName @ "Asset" $= %assetType)
-                     {
-                        %validType = true;
-                        break;  
-                     }
-                  }
-               }
-            }
-            
-            if(!%validType)
-               continue;
-         }
-         else
-         {
-            if(%assetType !$= AssetBrowser.assetTypeFilter)
-               continue;  
-         }*/
-			
          //stop adding after previewsPerPage is hit
          %assetName = AssetDatabase.getAssetName(%assetId);
 
@@ -1589,7 +1417,7 @@ function AssetBrowser::doRebuildAssetArray(%this)
    }
 
    //Add Non-Asset Scripted Objects. Datablock, etc based
-   if(AssetBrowser.assetTypeFilter $= "" && %breadcrumbPath !$= "" && !startsWith(%breadcrumbPath, "Creator/"))
+   if(AssetBrowser.assetTypeFilter $= "" && %breadcrumbPath !$= "" && isDirectory(%breadcrumbPath))
    {
       %category = getWord( %breadcrumbPath, 1 );                  
       %dataGroup = "DataBlockGroup";
@@ -1779,11 +1607,28 @@ function AssetBrowser::doRebuildAssetArray(%this)
       //One of the creator folders was selected
       %creatorGroup = AssetBrowserFilterTree.getItemText(AssetBrowserFilterTree.getSelectedItem(0));
             
+      if(%creatorGroup $= "Creator")
+      {
+         //add folders for the groups
+         %placeholderVar = "";
+      }
+      else
+      {
       for ( %i = 0; %i < AssetBrowser.creatorClassArray.count(); %i++ )
       {
          %group = AssetBrowser.creatorClassArray.getKey( %i );
 
-         if ( %group $= %creatorGroup )
+            //Do some filter logic do skip out of groups if we're in the wrong editor mode for it
+            %creatorEditorFilter = "WorldEditor";
+            if(GuiEditorIsActive())
+            {
+               %creatorEditorFilter = "GuiEditor";
+            }
+            
+            %creatorGroupIndex = AssetBrowserCreatorGroupsList.getIndexFromValue(%group);
+            %creatorGroupKey = AssetBrowserCreatorGroupsList.getKey(%creatorGroupIndex);
+            
+            if ( %group $= %creatorGroup && %creatorGroupKey $= %creatorEditorFilter )
          {
             %creatorObj = AssetBrowser.creatorClassArray.getValue( %i );
             %class = %creatorObj.val[0];
@@ -1794,6 +1639,7 @@ function AssetBrowser::doRebuildAssetArray(%this)
          }               
       }   
 	}
+	}
 	
    for(%i=0; %i < $AssetBrowser::AssetArray.count(); %i++)
 		AssetBrowser.buildAssetPreview( $AssetBrowser::AssetArray.getValue(%i), $AssetBrowser::AssetArray.getKey(%i) );  
@@ -2519,6 +2365,9 @@ function AssetBrowserFilterTree::onDragDropped( %this )
 
 function AssetBrowser::hasLooseFilesInDir(%this)
 {
+   if(!isDirectory(%this.dirHandler.currentAddress))
+      return false;
+   
    //First, wipe out any files inside the folder first
    %file = findFirstFileMultiExpr( %this.dirHandler.currentAddress @ "/*.*", false);
    
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImport.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImport.tscript
index 152a4c78c..c4de919f9 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImport.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImport.tscript
@@ -410,63 +410,6 @@ function ImportAssetWindow::reloadImportOptionConfigs(%this)
    //ImportAssetConfigList.setSelected(%importConfigIdx);
 }
 
-//
-/*function importLooseFile(%filePath, %forceAutoImport)
-{
-   %assetType = getAssetTypeByFilename(%filePath);
-   
-   if(%forceAutoImport)
-   {
-      //If we're attempting to fast-track the import, check that that's even an option
-      if(ImportAssetWindow.importConfigsList.count() == 0 || 
-      EditorSettings.value("Assets/AssetImporDefaultConfig") $= "" || 
-      EditorSettings.value("Assets/AutoImport", false) == false)
-      {
-         toolsMessageBoxOK("Unable to AutoImport", "Attempted to import a loose file " @ %filePath @ " with AutoImport but was unable to either due to lacking a valid import config, or the editor settings are not set to auto import.");
-         return false;      
-      }
-      
-      if(%assetType $= "folder" || %assetType $= "zip")
-      {
-         toolsMessageBoxOK("Unable to AutoImport", "Unable to auto import folders or zips at this time");
-         return false; 
-      }
-      
-      if(%assetType $= "")
-      {
-         toolsMessageBoxOK("Unable to AutoImport", "Unable to auto import unknown file type for file " @ %filePath);
-         return false; 
-      }
-   }
-   
-   %assetItem = AssetBrowser.addImportingAsset(%assetType, %filePath, "", "");
-   ImportAssetItems.add(%assetItem);
-   
-   if(%forceAutoImport)
-   {
-      %targetModule = AssetBrowser.dirHandler.getModuleFromAddress(filePath(%filePath)).ModuleId;
-      AssetImportTargetModule.text = %targetModule;
-      
-      %assetItem.moduleName = %targetModule;
-      
-      %assetName = %assetItem.assetName;
-      
-      AssetBrowser.dirHandler.currentAddress = filePath(%filePath);
-      
-      //skip the refresh delay, we'll force it here
-      ImportAssetWindow.doRefresh();
-      
-      ImportAssetItems.empty();
-      
-      if(ImportAssetWindow.hasImportIssues)
-         return false;
-   }
-   
-   $importedLooseFileAsset = %assetItem.moduleName @ ":" @ %assetItem.assetName;
-   
-   return true;
-}*/
-
 //
 function assetImportUpdatePath(%newPath)
 {
@@ -475,91 +418,6 @@ function assetImportUpdatePath(%newPath)
    AssetImportTargetModule.text = AssetBrowser.dirHandler.getModuleFromAddress(AssetBrowser.dirHandler.currentAddress).ModuleId;
 }
 
-//
-/*function ImportAssetWindow::processImportAssets(%this, %assetItem)
-{
-   if(!isObject(%assetItem))
-   {
-      //Zero this out
-      ImportAssetWindow.assetHeirarchyChanged = false;
-      
-      for(%i=0; %i < ImportAssetItems.count(); %i++)
-      {
-         %assetItem = ImportAssetItems.getKey(%i);
-         
-         if(!isObject(%assetItem) || %assetItem.skip )
-            return;
-            
-         if(%assetItem.processed == false)
-         {
-            //sanetize before modifying our asset name(suffix additions, etc)      
-            if(%assetItem.assetName !$= %assetItem.cleanAssetName)
-               %assetItem.assetName = %assetItem.cleanAssetName;
-            
-            if(%assetItem.assetType $= "AnimationAsset")
-            {
-               //if we don't have our own file, that means we're gunna be using our parent shape's file so reference that
-               if(!isFile(%assetItem.filePath))
-               {
-                  %assetItem.filePath = %assetItem.parentAssetItem.filePath;
-               }
-            }
-            
-            if(AssetBrowser.isMethod("prepareImport" @ %assetItem.assetType))
-            {
-               %command = AssetBrowser @ ".prepareImport" @ %assetItem.assetType @ "(" @ %assetItem @ ");";
-               eval(%command);
-            }
-            
-            %assetItem.processed = true;
-         }
-         
-         %this.processImportAssets(%assetItem);
-      }
-   }
-   else
-   {
-      for(%i=0; %i < %assetItem.childAssetItems.count(); %i++)
-      {
-         %childAssetItem = %assetItem.childAssetItems.getKey(%i);
-         
-         if(!isObject(%childAssetItem) || %childAssetItem.skip)
-            return;
-            
-         if(%childAssetItem.processed == false)
-         {
-            //sanetize before modifying our asset name(suffix additions, etc)      
-            if(%childAssetItem.assetName !$= %childAssetItem.cleanAssetName)
-               %childAssetItem.assetName = %childAssetItem.cleanAssetName;
-            
-            if(%childAssetItem.assetType $= "AnimationAsset")
-            {
-               //if we don't have our own file, that means we're gunna be using our parent shape's file so reference that
-               if(!isFile(%childAssetItem.filePath))
-               {
-                  %childAssetItem.filePath = %childAssetItem.parentAssetItem.filePath;
-               }
-            }
-            
-            if(AssetBrowser.isMethod("prepareImport" @ %childAssetItem.assetType))
-            {
-               %command = AssetBrowser @ ".prepareImport" @ %childAssetItem.assetType @ "(" @ %childAssetItem @ ");";
-               eval(%command);
-            }
-            
-            %childAssetItem.processed = true;
-         }
-         
-         %this.processImportAssets(%childAssetItem);
-      }
-   }
-   
-   //If our hierarchy changed, it's because we did so during processing
-   //so we'll loop back through again until everything has been processed
-   if(ImportAssetWindow.assetHeirarchyChanged)
-      %this.processImportAssets();
-}*/
-
 function ImportAssetWindow::findImportingAssetByName(%this, %assetName, %assetItem)
 {
    if(!isObject(%assetItem))
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/cpp.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/cpp.tscript
index 4fdd7b173..a2686fd37 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/cpp.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/cpp.tscript
@@ -11,6 +11,19 @@ function AssetBrowser::buildCppPreview(%this, %assetDef, %previewData)
    %previewData.tooltip = %assetDef.assetName;
 }
 
+function AssetBrowser::buildCppAssetPreview(%this, %assetDef, %previewData)
+{
+   %previewData.assetName = %assetDef.assetName;
+   %previewData.assetPath = %assetDef.codeFilePath;
+   %previewData.doubleClickCommand = "echo(\"Not yet implemented to edit C++ files from the editor\");";//"EditorOpenFileInTorsion( "@%previewData.assetPath@", 0 );";
+   
+   %previewData.previewImage = "ToolsModule:cppIcon_image";
+   
+   %previewData.assetFriendlyName = %assetDef.assetName;
+   %previewData.assetDesc = %assetDef.description;
+   %previewData.tooltip = %assetDef.assetName;
+}
+
 function AssetBrowser::createCpp(%this)
 {
    %moduleName = AssetBrowser.newAssetSettings.moduleName;
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/creatorObj.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/creatorObj.tscript
index 3c90e1782..1dec09e34 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/creatorObj.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/creatorObj.tscript
@@ -9,6 +9,14 @@ function AssetBrowser::buildCreatorPreview(%this, %assetDef, %previewData)
    
    %previewData.previewImage = "ToolsModule:" @ %class @ "_image";
    
+   if(!AssetDatabase.isDeclaredAsset(%previewData.previewImage))
+   {
+      if(EditorIsActive())
+         %previewData.previewImage = "ToolsModule:SceneObject_image";
+      else if(GuiEditorIsActive())
+         %previewData.previewImage = "ToolsModule:GuiControl_image";
+   }
+   
    //%previewData.assetFriendlyName = %assetDef.assetName;
    %previewData.assetDesc = %assetDef;
    %previewData.tooltip = "This creates a new object of the class " @ %class;
@@ -22,6 +30,8 @@ function AssetBrowser::onFinishCreateObject(%this, %objId)
 
 function AssetBrowser::onCreatorEditorDropped(%this, %assetDef, %position)
 {
+   if(EditorIsActive())
+   {
    %targetPosition = EWorldEditor.unproject(%position SPC 1000);
    %camPos = LocalClientConnection.camera.getPosition();
    %rayResult = containerRayCast(%camPos, %targetPosition, -1);
@@ -41,4 +51,9 @@ function AssetBrowser::onCreatorEditorDropped(%this, %assetDef, %position)
    
    %this.createdObjectPos = %pos;
    %newObj = eval(%func);
+   }
+   else if(GuiEditorIsActive())
+   {
+      %placeholderVar = "";
+   }
 }
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
index 37e874fb4..4363209a5 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
@@ -434,10 +434,20 @@ function AssetBrowser::buildMaterialAssetPreview(%this, %assetDef, %previewData)
    %generatePreview = false;
 
    %previewFilePath = %previewPath @ %assetDef.assetName @ "_Preview.png";
-   if(!isFile(%previewFilePath) || (compareFileTimes(%assetDef.getImagePath(), %previewFilePath) == 1))
+   if(!isFile(%previewFilePath))
    {
       %generatePreview = true;
    }
+   else
+   {
+      if(isObject(%assetDef.materialDefinitionName))
+      {
+         if(compareFileTimes(%assetDef.materialDefinitionName.getDiffuseMap(0), %previewFilePath) == 1 ||
+            compareFileTimes(%assetDef.materialDefinitionName.getFilename(), %previewFilePath) == 1)
+      %generatePreview = true;
+         
+      }
+   }
 
    %previewAssetName = %module.moduleId @ "_" @ %assetDef.assetName @ "_PreviewImage";
                                    
@@ -479,7 +489,7 @@ function AssetBrowser::buildMaterialAssetPreview(%this, %assetDef, %previewData)
    
    //Revalidate. If it didn't work, just use the default placeholder one
    if(!isFile(%previewFilePath))
-      %previewAssetName = "ToolsModule:genericAssetIcon_image";
+      %previewAssetName = "ToolsModule:materialIcon_image";
       
    %previewData.assetName = %assetDef.assetName;
    %previewData.assetPath = %assetDef.scriptFile;
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/prefab.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/prefab.tscript
index a13711aae..f4b42a66b 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/prefab.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/prefab.tscript
@@ -21,7 +21,7 @@ function AssetBrowser::buildPrefabPreview(%this, %assetDef, %previewData)
    %previewData.assetName = %assetDef.assetName;
    %previewData.assetPath = %fullPath;
    
-   %previewData.previewImage = "ToolsModule:genericAssetIcon_image";
+   %previewData.previewImage = "ToolsModule:prefabIcon_image";
    
    //%previewData.assetFriendlyName = %assetDef.assetName;
    %previewData.assetDesc = %assetDef.description;
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/script.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/script.tscript
index c23850c2c..78003103f 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/script.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/script.tscript
@@ -90,6 +90,22 @@ function AssetBrowser::moveScriptAsset(%this, %assetDef, %destination)
    AssetDatabase.addDeclaredAsset(%targetModule, %newAssetPath);
 }
 
+function AssetBrowser::buildScriptAssetPreview(%this, %assetDef, %previewData)
+{
+   %previewData.assetName = %assetDef.assetName;
+   %previewData.assetPath = %assetDef.scriptFile;
+   %previewData.doubleClickCommand = "EditorOpenFileInTorsion( \""@%previewData.assetPath@"\", 0 );";
+   
+   if(%assetDef.isServerSide)
+      %previewData.previewImage = "ToolsModule:serverScriptIcon_image";
+   else
+      %previewData.previewImage = "ToolsModule:clientScriptIcon_image";
+   
+   %previewData.assetFriendlyName = %assetDef.assetName;
+   %previewData.assetDesc = %assetDef.description;
+   %previewData.tooltip = "Asset Name: " @ %assetDef.assetName @ "\nDefinition Path: " @ %assetDef.getFilename();
+}
+
 function AssetBrowser::buildTScriptPreview(%this, %assetDef, %previewData)
 {
    %previewData.assetName = %assetDef.assetName;
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
index 4bf17453a..1908e3f23 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
@@ -353,6 +353,7 @@ function AssetBrowser::onShapeAssetEditorDropped(%this, %assetDef, %position)
       
    EWorldEditor.isDirty = true;
    
+   MECreateUndoAction::submit(%newStatic );
 }
 
 function GuiInspectorTypeShapeAssetPtr::onControlDropped( %this, %payload, %position )
@@ -367,15 +368,15 @@ function GuiInspectorTypeShapeAssetPtr::onControlDropped( %this, %payload, %posi
    
    if(%assetType $= "ShapeAsset")
    {
-      //echo("DROPPED A SHAPE ON A SHAPE ASSET COMPONENT FIELD!");  
-      
       %module = %payload.moduleName;
       %asset = %payload.assetName;
       
-      %targetComponent = %this.targetObject;
-      %targetComponent.shapeAsset = %module @ ":" @ %asset;
+      %oldValue = %targetObject.shapeAsset;
+      %arrayIndex = "";
       
-      //Inspector.refresh();
+      %targetObject = %this.targetObject;
+      %targetObject.shapeAsset = %module @ ":" @ %asset;
+
    }
    
    EWorldEditor.isDirty = true;
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrain.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrain.tscript
index 27cbc0b7c..9081729d0 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrain.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrain.tscript
@@ -166,7 +166,7 @@ function AssetBrowser::buildTerrainAssetPreview(%this, %assetDef, %previewData)
    %previewData.assetName = %assetDef.assetName;
    %previewData.assetPath = "";
    
-   %previewData.previewImage = "ToolsModule:gameObjectIcon_image";
+   %previewData.previewImage = "ToolsModule:terrainIcon_image";
    
    %previewData.assetFriendlyName = %assetDef.gameObjectName;
    %previewData.assetDesc = %assetDef.description;
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript
new file mode 100644
index 000000000..1c04ea1b7
--- /dev/null
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript
@@ -0,0 +1,194 @@
+function AssetBrowser::loadCreatorClasses(%this)
+{
+   // Just so we can recall this method for testing changes
+   // without restarting.
+   if ( isObject( %this.creatorClassArray ) )
+      %this.creatorClassArray.delete();
+      
+   AssetBrowserCreatorGroupsList.empty();
+      
+   %this.creatorClassArray = new ArrayObject();
+   %this.creatorClassArray.caseSensitive = true; 
+   //%this.setListView( true );
+   
+   //World Editor Creator Groups
+   %this.beginCreatorGroup( "Environment" );
+      %this.addCreatorClass( "BasicClouds",        "Basic Clouds" );
+      %this.addCreatorClass( "PxCloth",            "Cloth" );
+      %this.addCreatorClass( "CloudLayer",         "Cloud Layer" );
+      %this.addCreatorClass( "GroundCover",        "Ground Cover" );
+      %this.addCreatorClass( "Lightning" );
+      %this.addCreatorClass( "ParticleEmitterNode","Particle Emitter" );
+      %this.addCreatorClass( "Precipitation" );
+      // Legacy features. Users should use Ground Cover and the Forest Editor.   
+      //%this.addCreatorClass( "fxShapeReplicator",   "Shape Replicator" );
+      //%this.addCreatorClass( "fxFoliageReplicator", "Foliage Replicator" );
+      %this.addCreatorClass( "RibbonNode",         "Ribbon Emitter" );
+      %this.addCreatorClass( "ScatterSky",         "Scatter Sky" );
+      %this.addCreatorClass( "SkyBox",             "Sky Box" );
+      %this.addCreatorClass( "SFXEmitter",         "Sound Emitter" );
+      %this.addCreatorClass( "TerrainBlock",       "Terrain Block" );
+      %this.addCreatorClass( "VolumetricFog",      "Volumetric Fog" );
+      %this.addCreatorClass( "TimeOfDay",          "Time of Day" );
+      %this.addCreatorClass( "WaterBlock",         "Water Block" );
+      %this.addCreatorClass( "WaterPlane",         "Water Plane" );
+       %this.addCreatorClass( "ForestWindEmitter",  "Wind Emitter" );
+   %this.endCreatorGroup();
+   
+   %this.beginCreatorGroup( "ExampleObjects" );
+      %this.addCreatorClass( "RenderMeshExample" );
+      %this.addCreatorClass( "RenderObjectExample" );
+      %this.addCreatorClass( "RenderShapeExample" );
+   %this.endCreatorGroup(); 
+   
+   %this.beginCreatorGroup( "Level" );
+      %this.addCreatorClass("Camera" );
+      %this.addCreatorClass("GroundPlane",  "Ground Plane" );
+      %this.addCreatorClass("LevelInfo",    "Level Info" );
+      %this.addCreatorClass("Marker",       "Path Node" );
+      %this.addCreatorClass("MissionArea",  "Mission Area" );
+      %this.addCreatorClass("Note",         "Note" );
+      %this.addCreatorClass("Path" );
+      %this.addCreatorClass("SpawnSphere",  "General Spawn Sphere" );
+      %this.addCreatorClass("SpawnSphere",  "Player Spawn Sphere"/*, "PlayerDropPoint"*/ );
+      %this.addCreatorClass("SpawnSphere",  "Observer Spawn Sphere"/*, "ObserverDropPoint"*/ );
+      %this.addCreatorClass("VPath",        "Verve Path" );
+   %this.endCreatorGroup();
+   
+   %this.beginCreatorGroup( "Lighting" );
+      %this.addCreatorClass( "BoxEnvironmentProbe",      "Box Env. Probe" );
+      %this.addCreatorClass( "PointLight",               "Point Light" );
+      %this.addCreatorClass( "Skylight",                 "Skylight" );
+      %this.addCreatorClass( "SphereEnvironmentProbe",   "Sphere Env. Probe" );
+      %this.addCreatorClass( "SpotLight",                "Spot Light" );
+      %this.addCreatorClass( "Sun",                      "Basic Sun" );
+   %this.endCreatorGroup(); 
+
+   %this.beginCreatorGroup( "Navigation" );
+      %this.addCreatorClass( "AIPathGroup" );
+      %this.addCreatorClass( "CoverPoint",      "Cover Point" );
+      %this.addCreatorClass( "NavMesh",         "Navigation Mesh" );
+      %this.addCreatorClass( "NavPath",         "Navigation Path" );
+   %this.endCreatorGroup();  
+   
+   %this.beginCreatorGroup( "System" );
+      %this.addCreatorClass( "SimGroup" );
+   %this.endCreatorGroup();  
+   
+   %this.beginCreatorGroup( "Volumes" );
+      %this.addCreatorClass("AccumulationVolume",  "Accumulation Volume" );
+      %this.addCreatorClass("OcclusionVolume",     "Occlusion Volume" );
+      %this.addCreatorClass("PhysicalZone",        "Physical Zone" );
+      %this.addCreatorClass("Portal",              "Zone Portal" );
+      %this.addCreatorClass("SFXSpace",            "Sound Space" );
+      %this.addCreatorClass("Trigger" );
+      %this.addCreatorClass("Zone",                "Zone" );
+   %this.endCreatorGroup();  
+   
+   
+   
+   //Gui Editor Creator Groups
+   %controls = enumerateConsoleClassesByCategory( "Gui" );
+   %guiClasses = new ArrayObject();
+
+   foreach$( %className in %controls )
+   {
+      if( GuiEditor.isFilteredClass( %className )
+          || !isMemberOfClass( %className, "GuiControl" ) )
+         continue;
+         
+      %category = getWord( getCategoryOfClass( %className ), 1 );
+      if( %category $= "" )
+         continue;
+         
+      %guiClasses.add(%category, %className);
+   }
+   
+   %guiCats.sortk(true);
+   %guiClasses.sortk(true);
+   
+   %guiClasses.echo();
+   
+   %currentCat = "";
+   for(%i=0; %i < %guiClasses.count(); %i++)
+   {
+      %guiCat = %guiClasses.getKey(%i);
+      if(%currentCat !$= %guiCat)
+      {
+         if(%currentCat !$= "")
+            %this.endCreatorGroup(); 
+
+         %this.beginCreatorGroup( %guiCat, "GuiEditor" );
+         %currentCat = %guiCat;
+      }
+      
+      %guiClass = %guiClasses.getValue(%i);
+      %this.addCreatorClass( %guiClass );
+   }
+   
+   %this.endCreatorGroup(); 
+   
+   %this.creatorClassArray.sortk(true);
+   %this.creatorClassArray.sort(true);
+   
+   %guiClasses.delete();
+}
+
+function AssetBrowser::beginCreatorGroup(%this, %group, %editor)
+{
+   if(%editor $= "")
+      %editor = "WorldEditor";
+         
+   if((GuiEditorIsActive() && %editor $= "GuiEditor") || (EditorIsActive() && %editor $= "WorldEditor"))
+   {
+      AssetBrowser-->filterTree.insertItem(AssetBrowser-->filterTree.creatorIdx, %group);
+   }
+   
+   %this.currentCreatorGroup = %group;
+         
+   AssetBrowserCreatorGroupsList.add(%editor, %group);
+}
+
+function AssetBrowser::endCreatorGroup(%this, %group)
+{
+   %this.currentCreatorGroup = "";
+}
+
+function AssetBrowser::addCreatorClass(%this, %class, %name, %buildfunc)
+{
+   if( !isClass(%class) )
+      return;
+      
+   if ( %name $= "" )
+      %name = %class;
+      
+   if ( %this.currentCreatorGroup !$= "" && %group $= "" )
+      %group = %this.currentCreatorGroup;
+   
+   if ( %class $= "" || %group $= "" )
+   {
+      warn( "AssetBrowser::addCreatorClass, invalid parameters!" );
+      return;  
+   }
+   
+   if(%buildfunc $= "")
+   {
+      %method = "build" @ %buildfunc;
+      if( !ObjectBuilderGui.isMethod( %method ) )
+         %method = "build" @ %class;
+
+      if( !ObjectBuilderGui.isMethod( %method ) )
+         %cmd = "return new " @ %class @ "();";
+      else
+         %cmd = "ObjectBuilderGui." @ %method @ "();";
+
+      %buildfunc = "ObjectBuilderGui.newObjectCallback = \"AssetBrowser.onFinishCreateObject\"; EWCreatorWindow.createObject( \"" @ %cmd @ "\" );";
+   }
+   
+   %args = new ScriptObject();
+   %args.val[0] = %class;
+   %args.val[1] = %name;
+   %args.val[2] = %buildfunc;
+   
+   %this.creatorClassArray.push_back( %group, %args );
+}
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/profiles.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/profiles.tscript
index 5010d6cd0..b8825155e 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/profiles.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/profiles.tscript
@@ -24,4 +24,67 @@ singleton GuiControlProfile(AssetBrowserPreviewShapeAsset : ToolsGuiDefaultProfi
    border = true;
    borderColor   = "0 0 200 255";
    borderColorNA = "0 0 200 255";
+};
+
+singleton GuiControlProfile(AssetBrowserPreviewShapeAnimationAsset : ToolsGuiDefaultProfile)
+{
+   fillColor = "128 128 128 255"; //hovered/selected
+   
+   border = true;
+   borderColor   = "0 0 200 255";
+   borderColorNA = "0 0 200 255";
+};
+
+singleton GuiControlProfile(AssetBrowserPreviewSoundAsset : ToolsGuiDefaultProfile)
+{
+   fillColor = "128 128 128 255"; //hovered/selected
+   
+   border = true;
+   borderColor   = "75 101 135 255";
+   borderColorNA = "75 101 135 255";
+};
+
+singleton GuiControlProfile(AssetBrowserPreviewTerrainAsset : ToolsGuiDefaultProfile)
+{
+   fillColor = "128 128 128 255"; //hovered/selected
+   
+   border = true;
+   borderColor   = "200 198 198 255";
+   borderColorNA = "200 198 198 255";
+};
+
+singleton GuiControlProfile(AssetBrowserPreviewTerrainMaterialAsset : ToolsGuiDefaultProfile)
+{
+   fillColor = "128 128 128 255"; //hovered/selected
+   
+   border = true;
+   borderColor   = "200 198 198 255";
+   borderColorNA = "200 198 198 255";
+};
+
+singleton GuiControlProfile(AssetBrowserPreviewStateMachineAsset : ToolsGuiDefaultProfile)
+{
+   fillColor = "128 128 128 255"; //hovered/selected
+   
+   border = true;
+   borderColor   = "0 76 135 255";
+   borderColorNA = "0 76 135 255";
+};
+
+singleton GuiControlProfile(AssetBrowserPreviewGUIAsset : ToolsGuiDefaultProfile)
+{
+   fillColor = "128 128 128 255"; //hovered/selected
+   
+   border = true;
+   borderColor   = "17 5 44 255";
+   borderColorNA = "17 5 44 255";
+};
+
+singleton GuiControlProfile(AssetBrowserPreviewLevelAsset : ToolsGuiDefaultProfile)
+{
+   fillColor = "128 128 128 255"; //hovered/selected
+   
+   border = true;
+   borderColor   = "0 208 186 255";
+   borderColorNA = "0 208 186 255";
 };
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/gui/editorSettingsWindow.ed.tscript b/Templates/BaseGame/game/tools/gui/editorSettingsWindow.ed.tscript
index 3b41dca16..07b3e12b2 100644
--- a/Templates/BaseGame/game/tools/gui/editorSettingsWindow.ed.tscript
+++ b/Templates/BaseGame/game/tools/gui/editorSettingsWindow.ed.tscript
@@ -289,6 +289,11 @@ function ESettingsWindow::getAxisSettings(%this)
 
 function ESettingsWindow::getGeneralSettings(%this)
 {
+   SettingsInspector.startGroup("Level Load");
+   SettingsInspector.addSettingsField("WorldEditor/LevelLoad/LoadMode", "Editor Startup Scene", "list", "When the editor loads, this setting dictates what scene is loaded first", 
+                                                                              "Last Edited Level,Editor Default Scene");
+   SettingsInspector.endGroup();
+   
    SettingsInspector.startGroup("Autosave");
    SettingsInspector.addSettingsField("WorldEditor/AutosaveInterval", "Autosave Interval(in minutes)", "int", "");
    SettingsInspector.endGroup();
diff --git a/Templates/BaseGame/game/tools/gui/images/tab-border.png b/Templates/BaseGame/game/tools/gui/images/tab_border.png
similarity index 100%
rename from Templates/BaseGame/game/tools/gui/images/tab-border.png
rename to Templates/BaseGame/game/tools/gui/images/tab_border.png
diff --git a/Templates/BaseGame/game/tools/gui/images/tab_border_image.asset.taml b/Templates/BaseGame/game/tools/gui/images/tab_border_image.asset.taml
index 9d4db0d2d..c5f250a2d 100644
--- a/Templates/BaseGame/game/tools/gui/images/tab_border_image.asset.taml
+++ b/Templates/BaseGame/game/tools/gui/images/tab_border_image.asset.taml
@@ -2,7 +2,7 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="tab_border_image"
-    imageFile="@assetFile=tab-border.png"
+    imageFile="@assetFile=tab_border.png"
     UseMips="true"
     isHDRImage="false"
     imageType="Albedo" />
diff --git a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditor.ed.tscript b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditor.ed.tscript
index 3c5d36d89..2a9717571 100644
--- a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditor.ed.tscript
@@ -670,16 +670,21 @@ function GuiEditor::onControlDropped(%this, %payload, %position)
 {  
    // Make sure we have the right kind of D&D.
    
-   if( !%payload.parentGroup.isInNamespaceHierarchy( "GuiDragAndDropControlType_GuiControl" ) )
+   if( !%payload.parentGroup.isInNamespaceHierarchy( "GuiDragAndDropControlType_GuiControl" ) &&
+         !%payload.parentGroup.isInNamespaceHierarchy( "AssetPreviewControlType_AssetDrop" ))
       return;
 
    %pos = %payload.getGlobalPosition();
    %x = getWord(%pos, 0);
    %y = getWord(%pos, 1);
 
-   %this.addNewCtrl(%payload);
+   %asset = %payload.assetName;
+   %cmd = "return new " @ %asset @ "();";
+   %ctrl = eval( %cmd );
+
+   %this.addNewCtrl(%ctrl);
    
-   %payload.setPositionGlobal(%x, %y);
+   %ctrl.setPositionGlobal(%x, %y);
    %this.setFirstResponder();
 }
 
@@ -844,6 +849,8 @@ function GuiEditorTabBook::onWake( %this )
          item[ 0 ] = "Alphabetical View" TAB "" TAB "GuiEditorToolbox.setViewType( \"Alphabetical\" );";
          item[ 1 ] = "Categorized View" TAB "" TAB "GuiEditorToolbox.setViewType( \"Categorized\" );";
       };
+      
+   GlobalActionMap.bindCmd( keyboard, space, "", "AssetBrowser.toggleDialog();" );
 }
 
 //---------------------------------------------------------------------------------------------
@@ -1008,6 +1015,8 @@ function GuiEditorGui::onWake( %this )
 
 function GuiEditorGui::onSleep( %this)
 {
+   GlobalActionMap.unbind( keyboard, space );
+   
    // If we are editing a control, store its guide state.
    
    %content = GuiEditor.getContentControl();
diff --git a/Templates/BaseGame/game/tools/main.tscript b/Templates/BaseGame/game/tools/main.tscript
index 99c8e01ff..7e613bc31 100644
--- a/Templates/BaseGame/game/tools/main.tscript
+++ b/Templates/BaseGame/game/tools/main.tscript
@@ -278,7 +278,35 @@ function fastLoadWorldEdit(%val)
          
       if( !$missionRunning )
       {
+         if(EditorSettings.value("WorldEditor/LevelLoad/LoadMode", "Editor Default Scene") $= "Editor Default Scene")
+         {
          EditorNewLevel("ToolsModule:DefaultEditorLevel");
+         }
+         else
+         {
+            //go back through our recent levels list to find the most recent valid editor level.
+            //if NONE work, then just load the default editor scene
+            %recentLevels = EditorSettings.value("WorldEditor/recentLevelsList");
+            %recentCount = getTokenCount(%recentLevels, ",");
+            %loadedScene = false;
+            
+            for(%i=0; %i < %recentCount; %i++)
+            {
+               %recentEntry = getToken(%recentLevels, ",", %i);
+               
+               if(AssetDatabase.isDeclaredAsset(%recentEntry))
+               {
+                  EditorOpenMission(%recentEntry);
+                  %loadedScene = true;
+                  break;
+               }
+            }
+            
+            if(!%loadedScene)
+            {
+               EditorNewLevel("ToolsModule:DefaultEditorLevel");
+            }
+         }
       }
       else
       {
diff --git a/Templates/BaseGame/game/tools/shapeEditor/scripts/shapeEditor.ed.tscript b/Templates/BaseGame/game/tools/shapeEditor/scripts/shapeEditor.ed.tscript
index 987ff1640..17e617862 100644
--- a/Templates/BaseGame/game/tools/shapeEditor/scripts/shapeEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/shapeEditor/scripts/shapeEditor.ed.tscript
@@ -315,7 +315,7 @@ function ShapeEditor::selectShape( %this, %shapeAsset, %saveOld )
    ShapeEditor.shape = findShapeConstructorByAssetId( %shapeAsset.getAssetId() );
    if ( ShapeEditor.shape <= 0 )
    {
-      ShapeEditor.shape = %this.createConstructor( %shapeAsset );
+      ShapeEditor.shape = %this.createConstructor( %shapeAsset.getAssetId() );
       if ( ShapeEditor.shape <= 0 )
       {
          error( "ShapeEditor: Error - could not select " @ %shapeAsset.getAssetId() );
@@ -2336,7 +2336,7 @@ function ShapeEdMaterials::updateSelectedMaterial( %this, %highlight )
    %this.savedMap = %this.selectedMaterial.diffuseMap[1];
    if ( %highlight && isObject( %this.selectedMaterial ) )
    {
-      %this.selectedMaterial.diffuseMap[1] = "tools/shapeEditor/images/highlight_material";
+      %this.selectedMaterial.setDiffuseMap("ToolsModule:highlight_material_image", 1);
       %this.selectedMaterial.reload();
    }
 }
@@ -3066,7 +3066,7 @@ function ShapeEditor::addLODFromFile( %this, %dest, %assetId, %size, %allowUnmat
 
    %source = findShapeConstructorByAssetId( %assetId );
    if ( %source == -1 )
-      %source = ShapeEditor.createConstructor( %filename );
+      %source = ShapeEditor.createConstructor( %assetId  );
    %source.lodType = "SingleSize";
    %source.singleDetailSize = %size;
 

From b9c071b9fdb9c71c4b9f72d69f88a8bbd96c941a Mon Sep 17 00:00:00 2001
From: Areloch <Areloch@gmail.com>
Date: Fri, 10 Sep 2021 15:14:57 -0500
Subject: [PATCH 061/399] Cleanup mismerge lines

---
 Engine/source/T3D/assets/assetImporter.cpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/Engine/source/T3D/assets/assetImporter.cpp b/Engine/source/T3D/assets/assetImporter.cpp
index 380c9bcd6..5df1ca8ab 100644
--- a/Engine/source/T3D/assets/assetImporter.cpp
+++ b/Engine/source/T3D/assets/assetImporter.cpp
@@ -2433,8 +2433,6 @@ void AssetImporter::importAssets(AssetImportObject* assetItem)
 
             if (!refreshSuccess)
             {
-               const char* importReturnVal = Con::executef(this, processCommand.c_str(), childItem).getString();
-               assetPath = Torque::Path(importReturnVal);
                dSprintf(importLogBuffer, sizeof(importLogBuffer), "AssetImporter::importAssets - Failed to refresh reimporting asset %s.", item->assetName.c_str());
                activityLog.push_back(importLogBuffer);
             }

From 140c575f474b308999d5b8136ffb310b69b99b16 Mon Sep 17 00:00:00 2001
From: Areloch <Areloch@gmail.com>
Date: Fri, 10 Sep 2021 16:23:00 -0500
Subject: [PATCH 062/399] Minor corrections for localvar issues

---
 .../game/tools/assetBrowser/scripts/assetTypes/shape.tscript  | 2 +-
 .../BaseGame/game/tools/assetBrowser/scripts/creator.tscript  | 4 +---
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
index 7764376b4..89f981438 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
@@ -375,7 +375,7 @@ function GuiInspectorTypeShapeAssetPtr::onControlDropped( %this, %payload, %posi
       %module = %payload.moduleName;
       %asset = %payload.assetName;
       
-      %oldValue = %targetObject.shapeAsset;
+      %oldValue = %this.targetObject.shapeAsset;
       %arrayIndex = "";
       
       %targetObject = %this.targetObject;
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript
index 1c04ea1b7..d2254ee12 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript
@@ -104,7 +104,6 @@ function AssetBrowser::loadCreatorClasses(%this)
       %guiClasses.add(%category, %className);
    }
    
-   %guiCats.sortk(true);
    %guiClasses.sortk(true);
    
    %guiClasses.echo();
@@ -162,8 +161,7 @@ function AssetBrowser::addCreatorClass(%this, %class, %name, %buildfunc)
    if ( %name $= "" )
       %name = %class;
       
-   if ( %this.currentCreatorGroup !$= "" && %group $= "" )
-      %group = %this.currentCreatorGroup;
+   %group = %this.currentCreatorGroup;
    
    if ( %class $= "" || %group $= "" )
    {

From 5f0551b831888e295d7baf2e11eab16756bc6adf Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Fri, 10 Sep 2021 18:18:30 -0500
Subject: [PATCH 063/399] don't try to generate mipmaps for images that aren't
 n^2 dureing preview map generation

---
 Engine/source/gfx/bitmap/gBitmap.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Engine/source/gfx/bitmap/gBitmap.cpp b/Engine/source/gfx/bitmap/gBitmap.cpp
index 33c1c700c..9560586dd 100644
--- a/Engine/source/gfx/bitmap/gBitmap.cpp
+++ b/Engine/source/gfx/bitmap/gBitmap.cpp
@@ -1385,8 +1385,8 @@ DefineEngineFunction(saveScaledImage, bool, (const char* bitmapSource, const cha
          }
       }
    }*/
-
-   image->extrudeMipLevels();
+   if (isPow2(image->getWidth())&& isPow2(image->getHeight()))
+      image->extrudeMipLevels();
 
    U32 mipCount = image->getNumMipLevels();
    U32 targetMips = mFloor(mLog2((F32)resolutionSize)) + 1;

From f6f204a13a064158958cd86b8577ded001ecf29d Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Fri, 10 Sep 2021 20:10:53 -0400
Subject: [PATCH 064/399] * BugFix: Correct an error where the GUI editor
 cannot be opened when going from GUI editor to mission editor (or any other
 editor).

---
 .../BaseGame/game/tools/guiEditor/scripts/guiEditor.ed.tscript  | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditor.ed.tscript b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditor.ed.tscript
index 3c5d36d89..c867a74cc 100644
--- a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditor.ed.tscript
@@ -121,6 +121,8 @@ function GuiEditor::close(%this)
    if(Canvas.getContent() != GuiEditorGui.getId())
       return;
 
+   $InGuiEditor = false;
+
    GuiGroup.add(GuiEditorGui);
    
    Canvas.setContent(GuiEditor.lastContent);

From 3384d7f42670f67451d20e1dc30bbd2727986f11 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Fri, 10 Sep 2021 22:37:05 -0500
Subject: [PATCH 065/399] fix PhysicsShapeData upconvert entry

---
 .../scripts/pre40/T3Dpre4ProjectImporter.tscript                | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
index 99099085e..ceb9dfbcc 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
@@ -917,7 +917,7 @@ T3Dpre4ProjectImporter::genProcessor("PrecipitationData", "drop dropAsset dropTe
 T3Dpre4ProjectImporter::genProcessor("SplashData", "texture textureAsset");
 T3Dpre4ProjectImporter::genProcessor("LightFlareData", "flareTexture flareTextureAsset");
 T3Dpre4ProjectImporter::genProcessor("PhysicsDebrisData", "shape shapeAsset shapeFile shapeAsset");
-T3Dpre4ProjectImporter::genProcessor("PhysicsShapeData", "shape shapeAsset");
+T3Dpre4ProjectImporter::genProcessor("PhysicsShapeData", "shape shapeAsset shapeName shapeAsset");
 T3Dpre4ProjectImporter::genProcessor("PlayerData", "shapeFP shapeFPAsset shapeNameFP shapeFPAsset");
 T3Dpre4ProjectImporter::genProcessor("ProjectileData", "projectileShape projectileShapeAsset projectileShapeName projectileShapeAsset");
 T3Dpre4ProjectImporter::genProcessor("ShapeBaseData", "shapeFile shapeAsset shape shapeAsset debrisShape debrisShapeAsset debrisShapeName debrisShapeAsset");

From 4cf40defe66ea192d038a54301d3488ae82a7c44 Mon Sep 17 00:00:00 2001
From: Areloch <Areloch@gmail.com>
Date: Sat, 11 Sep 2021 02:28:14 -0500
Subject: [PATCH 066/399] Adds handling to project importer so if incoming gui
 files have the %guiContent declaration at the start, it's converted to a
 global to comply with the script interpreter

---
 .../scripts/pre40/T3Dpre4ProjectImporter.tscript            | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
index ceb9dfbcc..d996182dd 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
@@ -470,6 +470,12 @@ function T3Dpre4ProjectImporter::beginCodeFilesImport(%this)
                
                %objectName = findObjectName(%line, "new");
                
+               if(strIsMatchExpr("*%guiContent*=*new*", %line))
+               {
+                  %line = strReplace(%line, "%guiContent", "$guiContent");
+                  %fileWasChanged = true;
+               }
+               
                if(%objectName !$= "")
                {
                   %sanitizedName = sanitizeString(%objectName);

From 7f59bc6350aa3637a1600b350996bcb4e622cc35 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Sat, 11 Sep 2021 15:16:36 -0400
Subject: [PATCH 067/399] Forgot to null out the datablock after being deleted
 when it fails to preload.

---
 Engine/source/console/compiledEval.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index a18729fd4..f33586676 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -1103,6 +1103,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
             Con::errorf(ConsoleLogEntry::General, "%s: preload failed for %s: %s.", getFileLine(ip - 2),
                currentNewObject->getName(), errorStr.c_str());
             dataBlock->deleteObject();
+            currentNewObject = NULL;
             ip = failJump;
             break;
          }

From 41bd5ef6b6919bc30abcdae57ec54ea1c9b4bb37 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Sat, 11 Sep 2021 14:53:28 -0400
Subject: [PATCH 068/399] remove FMODex from Torque3D

The current version of FMod in Torque3D uses the legacy ex plugin, which hasn't been around for a long time.
---
 Engine/source/sfx/fmod/fmodErrors.h           | 115 ----
 Engine/source/sfx/fmod/fmodFunctions.h        | 157 -----
 Engine/source/sfx/fmod/sfxFMODBuffer.cpp      | 322 ----------
 Engine/source/sfx/fmod/sfxFMODBuffer.h        |  63 --
 Engine/source/sfx/fmod/sfxFMODDevice.cpp      | 578 ------------------
 Engine/source/sfx/fmod/sfxFMODDevice.h        | 342 -----------
 Engine/source/sfx/fmod/sfxFMODEvent.cpp       | 339 ----------
 Engine/source/sfx/fmod/sfxFMODEvent.h         | 135 ----
 Engine/source/sfx/fmod/sfxFMODEventGroup.cpp  | 510 ----------------
 Engine/source/sfx/fmod/sfxFMODEventGroup.h    | 159 -----
 Engine/source/sfx/fmod/sfxFMODEventSource.cpp | 337 ----------
 Engine/source/sfx/fmod/sfxFMODEventSource.h   | 101 ---
 Engine/source/sfx/fmod/sfxFMODPlugin.cpp      |  37 --
 Engine/source/sfx/fmod/sfxFMODPlugin.h        |  48 --
 Engine/source/sfx/fmod/sfxFMODProject.cpp     | 493 ---------------
 Engine/source/sfx/fmod/sfxFMODProject.h       | 162 -----
 Engine/source/sfx/fmod/sfxFMODProvider.cpp    | 398 ------------
 Engine/source/sfx/fmod/sfxFMODVoice.cpp       | 303 ---------
 Engine/source/sfx/fmod/sfxFMODVoice.h         | 121 ----
 Engine/source/sfx/sfxDescription.cpp          |   5 +-
 Engine/source/sfx/sfxDevice.h                 |   1 -
 Engine/source/sfx/sfxProfile.cpp              |   2 +-
 Engine/source/sfx/sfxSystem.cpp               |  22 +-
 Engine/source/sfx/sfxTrack.cpp                |   2 +-
 .../game/core/sfx/scripts/audio.tscript       |  12 +-
 .../game/data/UI/guis/guiMusicPlayer.tscript  |   1 -
 .../game/data/UI/guis/profiler.tscript        |   3 +-
 .../datablockEditor/datablockEditor.tscript   |   9 +-
 ...ddFMODProjectDlg,EditorGuiGroup.asset.taml |   7 -
 .../worldEditor/gui/AddFMODProjectDlg.ed.gui  | 284 ---------
 .../game/tools/worldEditor/main.tscript       |   2 -
 .../scripts/AddFMODProjectDlg.ed.tscript      | 253 --------
 .../worldEditor/scripts/menus.ed.tscript      |   5 +-
 Tools/CMake/torque3d.cmake                    |   2 -
 34 files changed, 13 insertions(+), 5317 deletions(-)
 delete mode 100644 Engine/source/sfx/fmod/fmodErrors.h
 delete mode 100644 Engine/source/sfx/fmod/fmodFunctions.h
 delete mode 100644 Engine/source/sfx/fmod/sfxFMODBuffer.cpp
 delete mode 100644 Engine/source/sfx/fmod/sfxFMODBuffer.h
 delete mode 100644 Engine/source/sfx/fmod/sfxFMODDevice.cpp
 delete mode 100644 Engine/source/sfx/fmod/sfxFMODDevice.h
 delete mode 100644 Engine/source/sfx/fmod/sfxFMODEvent.cpp
 delete mode 100644 Engine/source/sfx/fmod/sfxFMODEvent.h
 delete mode 100644 Engine/source/sfx/fmod/sfxFMODEventGroup.cpp
 delete mode 100644 Engine/source/sfx/fmod/sfxFMODEventGroup.h
 delete mode 100644 Engine/source/sfx/fmod/sfxFMODEventSource.cpp
 delete mode 100644 Engine/source/sfx/fmod/sfxFMODEventSource.h
 delete mode 100644 Engine/source/sfx/fmod/sfxFMODPlugin.cpp
 delete mode 100644 Engine/source/sfx/fmod/sfxFMODPlugin.h
 delete mode 100644 Engine/source/sfx/fmod/sfxFMODProject.cpp
 delete mode 100644 Engine/source/sfx/fmod/sfxFMODProject.h
 delete mode 100644 Engine/source/sfx/fmod/sfxFMODProvider.cpp
 delete mode 100644 Engine/source/sfx/fmod/sfxFMODVoice.cpp
 delete mode 100644 Engine/source/sfx/fmod/sfxFMODVoice.h
 delete mode 100644 Templates/BaseGame/game/tools/worldEditor/gui/AddFMODProjectDlg,EditorGuiGroup.asset.taml
 delete mode 100644 Templates/BaseGame/game/tools/worldEditor/gui/AddFMODProjectDlg.ed.gui
 delete mode 100644 Templates/BaseGame/game/tools/worldEditor/scripts/AddFMODProjectDlg.ed.tscript

diff --git a/Engine/source/sfx/fmod/fmodErrors.h b/Engine/source/sfx/fmod/fmodErrors.h
deleted file mode 100644
index 265d0dd55..000000000
--- a/Engine/source/sfx/fmod/fmodErrors.h
+++ /dev/null
@@ -1,115 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-FMOD_ERROR( FMOD_OK )
-FMOD_ERROR( FMOD_ERR_ALREADYLOCKED )
-FMOD_ERROR( FMOD_ERR_BADCOMMAND )
-FMOD_ERROR( FMOD_ERR_CDDA_DRIVERS )
-FMOD_ERROR( FMOD_ERR_CDDA_INIT )
-FMOD_ERROR( FMOD_ERR_CDDA_INVALID_DEVICE )
-FMOD_ERROR( FMOD_ERR_CDDA_NOAUDIO )
-FMOD_ERROR( FMOD_ERR_CDDA_NODEVICES )
-FMOD_ERROR( FMOD_ERR_CDDA_NODISC )
-FMOD_ERROR( FMOD_ERR_CDDA_READ )
-FMOD_ERROR( FMOD_ERR_CHANNEL_ALLOC )
-FMOD_ERROR( FMOD_ERR_CHANNEL_STOLEN )
-FMOD_ERROR( FMOD_ERR_COM )
-FMOD_ERROR( FMOD_ERR_DMA )
-FMOD_ERROR( FMOD_ERR_DSP_CONNECTION )
-FMOD_ERROR( FMOD_ERR_DSP_FORMAT )
-FMOD_ERROR( FMOD_ERR_DSP_NOTFOUND )
-FMOD_ERROR( FMOD_ERR_DSP_RUNNING )
-FMOD_ERROR( FMOD_ERR_DSP_TOOMANYCONNECTIONS )
-FMOD_ERROR( FMOD_ERR_FILE_BAD )
-FMOD_ERROR( FMOD_ERR_FILE_COULDNOTSEEK )
-FMOD_ERROR( FMOD_ERR_FILE_DISKEJECTED )
-FMOD_ERROR( FMOD_ERR_FILE_EOF )
-FMOD_ERROR( FMOD_ERR_FILE_NOTFOUND )
-FMOD_ERROR( FMOD_ERR_FILE_UNWANTED )
-FMOD_ERROR( FMOD_ERR_FORMAT )
-FMOD_ERROR( FMOD_ERR_HTTP )
-FMOD_ERROR( FMOD_ERR_HTTP_ACCESS )
-FMOD_ERROR( FMOD_ERR_HTTP_PROXY_AUTH )
-FMOD_ERROR( FMOD_ERR_HTTP_SERVER_ERROR )
-FMOD_ERROR( FMOD_ERR_HTTP_TIMEOUT )
-FMOD_ERROR( FMOD_ERR_INITIALIZATION )
-FMOD_ERROR( FMOD_ERR_INITIALIZED )
-FMOD_ERROR( FMOD_ERR_INTERNAL )
-FMOD_ERROR( FMOD_ERR_INVALID_ADDRESS )
-FMOD_ERROR( FMOD_ERR_INVALID_FLOAT )
-FMOD_ERROR( FMOD_ERR_INVALID_HANDLE )
-FMOD_ERROR( FMOD_ERR_INVALID_PARAM )
-FMOD_ERROR( FMOD_ERR_INVALID_POSITION )
-FMOD_ERROR( FMOD_ERR_INVALID_SPEAKER )
-FMOD_ERROR( FMOD_ERR_INVALID_SYNCPOINT )
-FMOD_ERROR( FMOD_ERR_INVALID_VECTOR )
-FMOD_ERROR( FMOD_ERR_MAXAUDIBLE )
-FMOD_ERROR( FMOD_ERR_MEMORY )
-FMOD_ERROR( FMOD_ERR_MEMORY_CANTPOINT )
-FMOD_ERROR( FMOD_ERR_MEMORY_SRAM )
-FMOD_ERROR( FMOD_ERR_NEEDS2D )
-FMOD_ERROR( FMOD_ERR_NEEDS3D )
-FMOD_ERROR( FMOD_ERR_NEEDSHARDWARE )
-FMOD_ERROR( FMOD_ERR_NEEDSSOFTWARE )
-FMOD_ERROR( FMOD_ERR_NET_CONNECT )
-FMOD_ERROR( FMOD_ERR_NET_SOCKET_ERROR )
-FMOD_ERROR( FMOD_ERR_NET_URL )
-FMOD_ERROR( FMOD_ERR_NET_WOULD_BLOCK )
-FMOD_ERROR( FMOD_ERR_NOTREADY )
-FMOD_ERROR( FMOD_ERR_OUTPUT_ALLOCATED )
-FMOD_ERROR( FMOD_ERR_OUTPUT_CREATEBUFFER )
-FMOD_ERROR( FMOD_ERR_OUTPUT_DRIVERCALL )
-FMOD_ERROR( FMOD_ERR_OUTPUT_ENUMERATION )
-FMOD_ERROR( FMOD_ERR_OUTPUT_FORMAT )
-FMOD_ERROR( FMOD_ERR_OUTPUT_INIT )
-FMOD_ERROR( FMOD_ERR_OUTPUT_NOHARDWARE )
-FMOD_ERROR( FMOD_ERR_OUTPUT_NOSOFTWARE )
-FMOD_ERROR( FMOD_ERR_PAN )
-FMOD_ERROR( FMOD_ERR_PLUGIN )
-FMOD_ERROR( FMOD_ERR_PLUGIN_INSTANCES )
-FMOD_ERROR( FMOD_ERR_PLUGIN_MISSING )
-FMOD_ERROR( FMOD_ERR_PLUGIN_RESOURCE )
-FMOD_ERROR( FMOD_ERR_RECORD )
-FMOD_ERROR( FMOD_ERR_REVERB_INSTANCE )
-FMOD_ERROR( FMOD_ERR_SUBSOUND_ALLOCATED )
-FMOD_ERROR( FMOD_ERR_SUBSOUND_CANTMOVE )
-FMOD_ERROR( FMOD_ERR_SUBSOUND_MODE )
-FMOD_ERROR( FMOD_ERR_SUBSOUNDS )
-FMOD_ERROR( FMOD_ERR_TAGNOTFOUND )
-FMOD_ERROR( FMOD_ERR_TOOMANYCHANNELS )
-FMOD_ERROR( FMOD_ERR_UNIMPLEMENTED )
-FMOD_ERROR( FMOD_ERR_UNINITIALIZED )
-FMOD_ERROR( FMOD_ERR_UNSUPPORTED )
-FMOD_ERROR( FMOD_ERR_UPDATE )
-FMOD_ERROR( FMOD_ERR_VERSION )
-FMOD_ERROR( FMOD_ERR_PRELOADED )
-FMOD_ERROR( FMOD_ERR_EVENT_FAILED )
-FMOD_ERROR( FMOD_ERR_EVENT_INFOONLY )
-FMOD_ERROR( FMOD_ERR_EVENT_INTERNAL )
-FMOD_ERROR( FMOD_ERR_EVENT_MAXSTREAMS )
-FMOD_ERROR( FMOD_ERR_EVENT_MISMATCH )
-FMOD_ERROR( FMOD_ERR_EVENT_NAMECONFLICT )
-FMOD_ERROR( FMOD_ERR_EVENT_NOTFOUND )
-FMOD_ERROR( FMOD_ERR_EVENT_NEEDSSIMPLE )
-FMOD_ERROR( FMOD_ERR_EVENT_GUIDCONFLICT )
-FMOD_ERROR( FMOD_ERR_EVENT_ALREADY_LOADED )
-FMOD_ERROR( FMOD_ERR_MUSIC_UNINITIALIZED )
diff --git a/Engine/source/sfx/fmod/fmodFunctions.h b/Engine/source/sfx/fmod/fmodFunctions.h
deleted file mode 100644
index f01e79ccb..000000000
--- a/Engine/source/sfx/fmod/fmodFunctions.h
+++ /dev/null
@@ -1,157 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-// Xcode has problems properly detecting the dependencies for this file.
-// If you change something here, manually recompile all the FMOD modules.
-
-
-// FMOD Ex API:
-
-FMOD_FUNCTION( FMOD_Channel_GetPaused, (FMOD_CHANNEL *channel, FMOD_BOOL *paused))
-FMOD_FUNCTION( FMOD_Channel_SetPaused, (FMOD_CHANNEL *channel, FMOD_BOOL paused));
-FMOD_FUNCTION( FMOD_Channel_IsPlaying, (FMOD_CHANNEL *channel, FMOD_BOOL *isplaying))
-FMOD_FUNCTION( FMOD_Channel_Set3DAttributes, (FMOD_CHANNEL *channel, const FMOD_VECTOR *pos, const FMOD_VECTOR *vel))
-FMOD_FUNCTION( FMOD_Channel_SetFrequency, (FMOD_CHANNEL *channel, float frequency))
-FMOD_FUNCTION( FMOD_Channel_SetLoopCount, (FMOD_CHANNEL *channel, int loopcount))
-FMOD_FUNCTION( FMOD_Channel_SetPosition, (FMOD_CHANNEL *channel, unsigned int position, FMOD_TIMEUNIT postype))
-FMOD_FUNCTION( FMOD_Channel_GetPosition, (FMOD_CHANNEL* channel, unsigned int* position, FMOD_TIMEUNIT postype))
-FMOD_FUNCTION( FMOD_Channel_SetVolume, (FMOD_CHANNEL *channel, float volume))
-FMOD_FUNCTION( FMOD_Channel_GetVolume, (FMOD_CHANNEL *channel, float *volume))
-FMOD_FUNCTION( FMOD_Channel_Stop, (FMOD_CHANNEL *channel))
-FMOD_FUNCTION( FMOD_Channel_SetMode, (FMOD_CHANNEL *channel, FMOD_MODE mode))
-FMOD_FUNCTION( FMOD_Channel_Set3DMinMaxDistance, (FMOD_CHANNEL *channel, float mindistance, float maxdistance));
-FMOD_FUNCTION( FMOD_Channel_Set3DConeSettings, (FMOD_CHANNEL *channel, float insideconeangle, float outsideconeangle, float outsidevolume))
-FMOD_FUNCTION( FMOD_Channel_Set3DConeOrientation, (FMOD_CHANNEL *channel, FMOD_VECTOR *orientation))
-FMOD_FUNCTION( FMOD_Channel_SetReverbProperties, ( FMOD_CHANNEL* channel, const FMOD_REVERB_CHANNELPROPERTIES* prop ) )
-FMOD_FUNCTION( FMOD_Channel_SetPriority, ( FMOD_CHANNEL* channel, int priority ) )
-FMOD_FUNCTION( FMOD_Channel_IsVirtual, ( FMOD_CHANNEL* channel, FMOD_BOOL* isvirtual ) )
-FMOD_FUNCTION( FMOD_Channel_AddDSP, ( FMOD_CHANNEL* channel, FMOD_DSP* dsp, FMOD_DSPCONNECTION** connection ) )
-
-FMOD_FUNCTION( FMOD_Sound_Lock, (FMOD_SOUND *sound, unsigned int offset, unsigned int length, void **ptr1, void **ptr2, unsigned int *len1, unsigned int *len2))
-FMOD_FUNCTION( FMOD_Sound_Unlock, (FMOD_SOUND *sound, void *ptr1, void *ptr2, unsigned int len1, unsigned int len2))
-FMOD_FUNCTION( FMOD_Sound_Release, (FMOD_SOUND *sound))
-FMOD_FUNCTION( FMOD_Sound_Set3DMinMaxDistance, (FMOD_SOUND *sound, float min, float max))
-FMOD_FUNCTION( FMOD_Sound_SetMode, (FMOD_SOUND *sound, FMOD_MODE mode))
-FMOD_FUNCTION( FMOD_Sound_GetMode, (FMOD_SOUND *sound, FMOD_MODE *mode))
-FMOD_FUNCTION( FMOD_Sound_SetLoopCount, (FMOD_SOUND *sound, int loopcount))
-FMOD_FUNCTION( FMOD_Sound_GetFormat, ( FMOD_SOUND* sound, FMOD_SOUND_TYPE* type, FMOD_SOUND_FORMAT* format, int* channels, int* bits ) )
-FMOD_FUNCTION( FMOD_Sound_GetLength, ( FMOD_SOUND* sound, unsigned int* length, FMOD_TIMEUNIT lengthtype ) )
-FMOD_FUNCTION( FMOD_Sound_GetDefaults, ( FMOD_SOUND* sound, float* frequency, float* volume, float* pan, int* priority ) ) 
-FMOD_FUNCTION( FMOD_Sound_GetMemoryInfo, ( FMOD_SOUND* sound, unsigned int memorybits, unsigned int event_memorybits, unsigned int* memoryused, unsigned int* memoryused_array ) );
-
-FMOD_FUNCTION( FMOD_Geometry_AddPolygon, ( FMOD_GEOMETRY* geometry, float directocclusion, float reverbocclusion, FMOD_BOOL doublesided, int numvertices, const FMOD_VECTOR* vertices, int* polygonindex ) )
-FMOD_FUNCTION( FMOD_Geometry_SetPosition, ( FMOD_GEOMETRY* geometry, const FMOD_VECTOR* position ) )
-FMOD_FUNCTION( FMOD_Geometry_SetRotation, ( FMOD_GEOMETRY* geometry, const FMOD_VECTOR* forward, const FMOD_VECTOR* up ) )
-FMOD_FUNCTION( FMOD_Geometry_SetScale, ( FMOD_GEOMETRY* geometry, const FMOD_VECTOR* scale ) )
-FMOD_FUNCTION( FMOD_Geometry_Release, ( FMOD_GEOMETRY* geometry ) )
-
-FMOD_FUNCTION( FMOD_DSP_GetInfo, ( FMOD_DSP* dsp, char* name, unsigned int* version, int* channels, int* configwidth, int* configheight ) )
-FMOD_FUNCTION( FMOD_DSP_Release, ( FMOD_DSP* dsp ) )
-FMOD_FUNCTION( FMOD_DSP_GetParameterInfo, ( FMOD_DSP* dsp, int index, char* name, char* label, char* description, int descriptionlen, float* min, float* max ) )
-FMOD_FUNCTION( FMOD_DSP_GetNumParameters, ( FMOD_DSP* dsp, int* numparams ) )
-FMOD_FUNCTION( FMOD_DSP_GetParameter, ( FMOD_DSP* dsp, int index, float* value, char* valuestr, int valuestrlen ) )
-FMOD_FUNCTION( FMOD_DSP_SetParameter, ( FMOD_DSP* dsp, int index, float value ) )
-FMOD_FUNCTION( FMOD_DSP_GetNumInputs, ( FMOD_DSP* dsp, int* numinputs ) )
-FMOD_FUNCTION( FMOD_DSP_GetNumOutputs, ( FMOD_DSP* dsp, int* numoutputs ) )
-
-FMOD_FUNCTION( FMOD_System_Close, (FMOD_SYSTEM *system))
-FMOD_FUNCTION( FMOD_System_Create, (FMOD_SYSTEM **system))
-FMOD_FUNCTION( FMOD_System_Release, (FMOD_SYSTEM *system))
-FMOD_FUNCTION( FMOD_System_CreateSound, (FMOD_SYSTEM *system, const char *name_or_data, FMOD_MODE mode, FMOD_CREATESOUNDEXINFO *exinfo, FMOD_SOUND **sound))
-FMOD_FUNCTION( FMOD_System_CreateGeometry, ( FMOD_SYSTEM* system, int maxpolygons, int maxvertices, FMOD_GEOMETRY** geometry ) )
-FMOD_FUNCTION( FMOD_System_SetDriver, (FMOD_SYSTEM *system, int driver))
-FMOD_FUNCTION( FMOD_System_GetDriverCaps, (FMOD_SYSTEM *system, int id, FMOD_CAPS *caps, int *controlpaneloutputrate, FMOD_SPEAKERMODE *controlpanelspeakermode))
-FMOD_FUNCTION( FMOD_System_GetDriverInfo, (FMOD_SYSTEM *system, int id, char *name, int namelen, FMOD_GUID *GUID))
-FMOD_FUNCTION( FMOD_System_GetNumDrivers, (FMOD_SYSTEM *system, int *numdrivers))
-FMOD_FUNCTION( FMOD_System_GetVersion, (FMOD_SYSTEM *system, unsigned int *version))
-FMOD_FUNCTION( FMOD_System_Init, (FMOD_SYSTEM *system, int maxchannels, FMOD_INITFLAGS flags, void *extradriverdata))
-FMOD_FUNCTION( FMOD_System_PlaySound, (FMOD_SYSTEM *system, FMOD_CHANNELINDEX channelid, FMOD_SOUND *sound, FMOD_BOOL paused, FMOD_CHANNEL **channel))
-FMOD_FUNCTION( FMOD_System_Set3DListenerAttributes, (FMOD_SYSTEM *system, int listener, const FMOD_VECTOR *pos, const FMOD_VECTOR *vel, const FMOD_VECTOR *forward, const FMOD_VECTOR *up))
-FMOD_FUNCTION( FMOD_System_Set3DNumListeners, ( FMOD_SYSTEM* system, int numlisteners ) )
-FMOD_FUNCTION( FMOD_System_SetGeometrySettings, ( FMOD_SYSTEM* system, float maxworldsize ) )
-FMOD_FUNCTION( FMOD_System_Get3DSettings, (FMOD_SYSTEM* system, float* dopplerFactor, float* distanceFactor, float* rolloffFactor))
-FMOD_FUNCTION( FMOD_System_Set3DSettings, (FMOD_SYSTEM *system, float dopplerscale, float distancefactor, float rolloffscale))
-FMOD_FUNCTION( FMOD_System_SetDSPBufferSize, (FMOD_SYSTEM *system, unsigned int bufferlength, int numbuffers))
-FMOD_FUNCTION( FMOD_System_SetSpeakerMode, (FMOD_SYSTEM *system, FMOD_SPEAKERMODE speakermode))
-FMOD_FUNCTION( FMOD_System_SetReverbProperties, ( FMOD_SYSTEM* system, const FMOD_REVERB_PROPERTIES* prop ) )
-FMOD_FUNCTION( FMOD_System_SetReverbAmbientProperties, ( FMOD_SYSTEM* system, FMOD_REVERB_PROPERTIES* prop ) )
-FMOD_FUNCTION( FMOD_System_Update, ( FMOD_SYSTEM *system ) )
-FMOD_FUNCTION( FMOD_System_CreateDSPByType, ( FMOD_SYSTEM* system, FMOD_DSP_TYPE type, FMOD_DSP** dsp ) )
-FMOD_FUNCTION( FMOD_System_AddDSP, ( FMOD_SYSTEM* system, FMOD_DSP* dsp, FMOD_DSPCONNECTION** connection ) )
-FMOD_FUNCTION( FMOD_System_GetMemoryInfo, ( FMOD_SYSTEM* system, unsigned int memorybits, unsigned int event_memorybits, unsigned int* memoryused, unsigned int* memoryused_array ) )
-FMOD_FUNCTION( FMOD_System_SetFileSystem, ( FMOD_SYSTEM* system, FMOD_FILE_OPENCALLBACK useropen, FMOD_FILE_CLOSECALLBACK userclose, FMOD_FILE_READCALLBACK userread, FMOD_FILE_SEEKCALLBACK userseek, int blockalign ) )
-FMOD_FUNCTION( FMOD_System_SetPluginPath, ( FMOD_SYSTEM* system, const char* path ) )
-FMOD_FUNCTION( FMOD_System_GetHardwareChannels, ( FMOD_SYSTEM* system, int* num2d, int* num3d, int* total ) )
-
-FMOD_FUNCTION( FMOD_Memory_GetStats, ( int*, int* ) )
-FMOD_FUNCTION( FMOD_Memory_Initialize, ( void *poolmem, int poollen, FMOD_MEMORY_ALLOCCALLBACK useralloc, FMOD_MEMORY_REALLOCCALLBACK userrealloc, FMOD_MEMORY_FREECALLBACK userfree ) )
-
-// FMOD Designer API:
-
-FMOD_EVENT_FUNCTION( FMOD_EventSystem_Create, ( FMOD_EVENTSYSTEM** eventsystem ) )
-FMOD_EVENT_FUNCTION( FMOD_EventSystem_GetSystemObject, ( FMOD_EVENTSYSTEM* eventsystem, FMOD_SYSTEM** system ) )
-FMOD_EVENT_FUNCTION( FMOD_EventSystem_GetVersion, ( FMOD_EVENTSYSTEM* eventsystem, unsigned int* version ) )
-FMOD_EVENT_FUNCTION( FMOD_EventSystem_Init, ( FMOD_EVENTSYSTEM* eventsystem, int maxchannels, FMOD_INITFLAGS flags, void* extradriverdata, FMOD_EVENT_INITFLAGS eventflags ) )
-FMOD_EVENT_FUNCTION( FMOD_EventSystem_Release, ( FMOD_EVENTSYSTEM* eventsystem ) )
-FMOD_EVENT_FUNCTION( FMOD_EventSystem_Load, ( FMOD_EVENTSYSTEM* eventsystem, const char* name_or_data, FMOD_EVENT_LOADINFO* loadinfo, FMOD_EVENTPROJECT** project ) )
-FMOD_EVENT_FUNCTION( FMOD_EventSystem_Update, ( FMOD_EVENTSYSTEM* eventsystem ) )
-FMOD_EVENT_FUNCTION( FMOD_EventSystem_GetMemoryInfo, ( FMOD_EVENTSYSTEM* eventsystem, unsigned int memorybits, unsigned int event_memorybits, unsigned int* memoryused, unsigned int* memoryused_array ) )
-FMOD_EVENT_FUNCTION( FMOD_EventSystem_SetMediaPath, ( FMOD_EVENTSYSTEM* eventsystem, const char* path ) )
-
-FMOD_EVENT_FUNCTION( FMOD_EventProject_Release, ( FMOD_EVENTPROJECT* eventproject ) )
-FMOD_EVENT_FUNCTION( FMOD_EventProject_GetInfo, ( FMOD_EVENTPROJECT* eventproject, FMOD_EVENT_PROJECTINFO* info ) )
-FMOD_EVENT_FUNCTION( FMOD_EventProject_GetNumEvents, ( FMOD_EVENTPROJECT* eventproject, int* numevents ) )
-FMOD_EVENT_FUNCTION( FMOD_EventProject_GetNumGroups, ( FMOD_EVENTPROJECT* eventproject, int* numgroups ) )
-FMOD_EVENT_FUNCTION( FMOD_EventProject_GetGroupByIndex, ( FMOD_EVENTPROJECT* eventproject, int index, FMOD_BOOL cacheevents, FMOD_EVENTGROUP** group ) )
-FMOD_EVENT_FUNCTION( FMOD_EventProject_GetGroup, ( FMOD_EVENTPROJECT* eventproject, const char* name, FMOD_BOOL cacheevents, FMOD_EVENTGROUP** group ) )
-
-FMOD_EVENT_FUNCTION( FMOD_EventGroup_GetInfo, ( FMOD_EVENTGROUP* eventgroup, int* index, char** name ) )
-FMOD_EVENT_FUNCTION( FMOD_EventGroup_LoadEventData, ( FMOD_EVENTGROUP* eventgroup, FMOD_EVENT_RESOURCE resource, FMOD_EVENT_MODE mode ) )
-FMOD_EVENT_FUNCTION( FMOD_EventGroup_FreeEventData, ( FMOD_EVENTGROUP* eventgroup, FMOD_EVENT* event, FMOD_BOOL waituntilready ) )
-FMOD_EVENT_FUNCTION( FMOD_EventGroup_GetNumEvents, ( FMOD_EVENTGROUP* eventgroup, int* numevents ) )
-FMOD_EVENT_FUNCTION( FMOD_EventGroup_GetNumGroups, ( FMOD_EVENTGROUP* eventgroup, int* numgroups ) )
-FMOD_EVENT_FUNCTION( FMOD_EventGroup_GetEventByIndex, ( FMOD_EVENTGROUP* eventgroup, int index, FMOD_EVENT_MODE mode, FMOD_EVENT** event ) )
-FMOD_EVENT_FUNCTION( FMOD_EventGroup_GetEvent, ( FMOD_EVENTGROUP* eventgroup, const char* name, FMOD_EVENT_MODE mode, FMOD_EVENT** event ) )
-FMOD_EVENT_FUNCTION( FMOD_EventGroup_GetGroupByIndex, ( FMOD_EVENTGROUP* eventgroup, int index, FMOD_BOOL cacheevents, FMOD_EVENTGROUP** group ) )
-FMOD_EVENT_FUNCTION( FMOD_EventGroup_GetGroup, ( FMOD_EVENTGROUP* eventgroup, const char* name, FMOD_BOOL cacheevents, FMOD_EVENTGROUP** group ) )
-
-FMOD_EVENT_FUNCTION( FMOD_Event_GetInfo, ( FMOD_EVENT* event, int* index, char** name, FMOD_EVENT_INFO* info ) )
-FMOD_EVENT_FUNCTION( FMOD_Event_Release, ( FMOD_EVENT* event, FMOD_BOOL freeeventdata, FMOD_BOOL waituntilready ) )
-FMOD_EVENT_FUNCTION( FMOD_Event_Start, ( FMOD_EVENT* event ) )
-FMOD_EVENT_FUNCTION( FMOD_Event_Stop, ( FMOD_EVENT* event, FMOD_BOOL immediate ) )
-FMOD_EVENT_FUNCTION( FMOD_Event_SetPaused, ( FMOD_EVENT* event, FMOD_BOOL paused ) )
-FMOD_EVENT_FUNCTION( FMOD_Event_SetVolume, ( FMOD_EVENT* event, float volume ) )
-FMOD_EVENT_FUNCTION( FMOD_Event_SetPitch, ( FMOD_EVENT* event, float pitch, FMOD_EVENT_PITCHUNITS units ) )
-FMOD_EVENT_FUNCTION( FMOD_Event_Set3DAttributes, ( FMOD_EVENT* event, const FMOD_VECTOR* position, const FMOD_VECTOR* velocity, const FMOD_VECTOR* orientation ) )
-FMOD_EVENT_FUNCTION( FMOD_Event_GetState, ( FMOD_EVENT* event, FMOD_EVENT_STATE* state ) )
-FMOD_EVENT_FUNCTION( FMOD_Event_GetNumParameters, ( FMOD_EVENT* event, int* numparameters ) )
-FMOD_EVENT_FUNCTION( FMOD_Event_GetParameter, ( FMOD_EVENT* event, const char* name, FMOD_EVENTPARAMETER** parameter ) )
-FMOD_EVENT_FUNCTION( FMOD_Event_GetParameterByIndex, ( FMOD_EVENT* event, int index, FMOD_EVENTPARAMETER** parameter ) )
-FMOD_EVENT_FUNCTION( FMOD_Event_GetPropertyByIndex, ( FMOD_EVENT* event, int propertyidex, void* value, FMOD_BOOL this_instance ) )
-FMOD_EVENT_FUNCTION( FMOD_Event_SetPropertyByIndex, ( FMOD_EVENT* event, int propertyidex, void* value, FMOD_BOOL this_instance ) )
-FMOD_EVENT_FUNCTION( FMOD_Event_GetProperty, ( FMOD_EVENT* event, const char* propertyname, void* value, FMOD_BOOL this_instance ) )
-FMOD_EVENT_FUNCTION( FMOD_Event_GetPropertyInfo, ( FMOD_EVENT* event, int* propertyindex, char** propertyname, FMOD_EVENTPROPERTY_TYPE* type ) )
-
-FMOD_EVENT_FUNCTION( FMOD_EventParameter_GetInfo, ( FMOD_EVENTPARAMETER* eventparameter, int* index, char** name ) )
-FMOD_EVENT_FUNCTION( FMOD_EventParameter_GetValue, ( FMOD_EVENTPARAMETER* eventparameter, float* value ) )
-FMOD_EVENT_FUNCTION( FMOD_EventParameter_SetValue, ( FMOD_EVENTPARAMETER* eventparameter, float value ) )
-FMOD_EVENT_FUNCTION( FMOD_EventParameter_GetRange, ( FMOD_EVENTPARAMETER* eventparameter, float* rangemin, float* rangemax ) )
\ No newline at end of file
diff --git a/Engine/source/sfx/fmod/sfxFMODBuffer.cpp b/Engine/source/sfx/fmod/sfxFMODBuffer.cpp
deleted file mode 100644
index 07cbb8a0f..000000000
--- a/Engine/source/sfx/fmod/sfxFMODBuffer.cpp
+++ /dev/null
@@ -1,322 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#include "sfx/fmod/sfxFMODBuffer.h"
-#include "sfx/fmod/sfxFMODDevice.h"
-#include "sfx/sfxDescription.h"
-#include "core/util/safeDelete.h"
-#include "core/volume.h"
-
-
-//-----------------------------------------------------------------------------
-
-static const char* sExtensions[] =
-{
-   "",      // First try without doing anything with the given path.
-   "",      // Then try it without an extension but by expanding it through Torque::FS.
-   "aiff",
-   "asf",
-   "asx",
-   "dls",
-   "flac",
-   "fsb",
-   "it",
-   "m3u",
-   "mid",
-   "mod",
-   "mp2",
-   "mp3",
-   "ogg",
-   "pls",
-   "s3m",
-   "vag",
-   "wav",
-   "wax",
-   "wma",
-   "xm",
-   
-#ifdef TORQUE_OS_XENON
-   ".xma",
-#endif
-
-   NULL
-};
-
-//-----------------------------------------------------------------------------
-
-SFXFMODBuffer* SFXFMODBuffer::create( const ThreadSafeRef< SFXStream >& stream, SFXDescription* description )
-{
-   SFXFMODBuffer *buffer = new SFXFMODBuffer( stream, description );
-   if( !buffer->mSound )
-      SAFE_DELETE( buffer );
-
-   return buffer;
-}
-
-//-----------------------------------------------------------------------------
-
-SFXFMODBuffer* SFXFMODBuffer::create( const String& filename, SFXDescription* description )
-{
-   if( Con::getBoolVariable( "$pref::SFX::FMOD::noCustomFileLoading", false ) )
-      return NULL;
-      
-   SFXFMODBuffer *buffer = new SFXFMODBuffer( filename, description );
-   if( !buffer->mSound )
-      SAFE_DELETE( buffer );
-
-   return buffer;
-}
-
-//-----------------------------------------------------------------------------
-
-SFXFMODBuffer::SFXFMODBuffer( const String& filename, SFXDescription* description )
-   : Parent( description ),
-     mSound( NULL )
-{
-   FMOD_MODE fMode = ( description->mUseHardware ? FMOD_HARDWARE : FMOD_SOFTWARE )
-      | ( description->mIs3D ? FMOD_3D : FMOD_2D );
-
-   if( description->mIsStreaming )
-   {
-      fMode |= FMOD_CREATESTREAM;
-      mIsUnique = true;
-   }
-   
-   // Go through the extensions and try each with the given path.  The
-   // first two are special.  First we try without touching the filename at all
-   // so FMOD gets a chance to handle URLs and whatever, and then second we
-   // try by expanding the path but without adding an extension.
-   
-   Torque::Path path = filename;
-   for( U32 i = 0; sExtensions[ i ]; ++ i )
-   {
-      path.setExtension( sExtensions[ i ] );
-
-      if( !i || Torque::FS::IsFile( path ) )
-      {
-         // Translate to full path.
-         //TODO: Remove this when hooking up the file system functions in sfxFMODDevice.cpp
-
-         String fullPath;
-         if( !i )
-            fullPath = filename;
-         else
-         {
-            Torque::Path realPath;
-            if( !Torque::FS::GetFSPath( path, realPath ) )
-               continue;
-            
-            fullPath = realPath.getFullPath().c_str();
-         }
-      
-         mSound = NULL;
-         FMOD_RESULT result = SFXFMODDevice::smFunc->FMOD_System_CreateSound(
-               SFXFMODDevice::smSystem, 
-               fullPath.c_str(), 
-               fMode, 
-               ( FMOD_CREATESOUNDEXINFO* ) NULL, 
-               &mSound );
-               
-         if( result == FMOD_OK )
-         {
-            SFXFMODDevice::smFunc->FMOD_Sound_GetMode( mSound, &mMode );
-            
-            // Read out format.
-            
-            int numChannels;
-            int bitsPerSample;
-            unsigned int length;
-            float frequency;
-            
-            SFXFMODDevice::smFunc->FMOD_Sound_GetFormat( mSound, ( FMOD_SOUND_TYPE* ) NULL, ( FMOD_SOUND_FORMAT* ) NULL, &numChannels, &bitsPerSample );
-            SFXFMODDevice::smFunc->FMOD_Sound_GetLength( mSound, &length, FMOD_TIMEUNIT_MS );
-            SFXFMODDevice::smFunc->FMOD_Sound_GetDefaults( mSound, &frequency, ( float* ) NULL, ( float* ) NULL, ( int* ) NULL );
-
-            mDuration = length;
-            mFormat = SFXFormat( numChannels, numChannels * bitsPerSample, frequency );
-            
-            break;
-         }
-      }
-   }
-
-   if( !mSound )
-      Con::errorf( "SFXFMODBuffer::SFXFMODBuffer - failed to load '%s' through FMOD", filename.c_str() );
-}
-
-//-----------------------------------------------------------------------------
-
-SFXFMODBuffer::SFXFMODBuffer( const ThreadSafeRef< SFXStream >& stream, SFXDescription* description )
-   : Parent( stream, description ),
-     mSound( NULL )
-{
-   FMOD_MODE fMode = ( description->mUseHardware ? FMOD_HARDWARE : FMOD_SOFTWARE )
-      | ( description->mIs3D ? FMOD_3D : FMOD_2D );
-
-   FMOD_CREATESOUNDEXINFO* pCreatesoundexinfo = NULL;
-   FMOD_CREATESOUNDEXINFO  createsoundexinfo;
-
-   fMode |= FMOD_OPENUSER; // this tells fmod we are supplying the data directly
-   if( isStreaming() )
-      fMode |= FMOD_LOOP_NORMAL | FMOD_UNIQUE;
-
-   const SFXFormat& format = getFormat();
-   U32 channels = format.getChannels();
-   U32 frequency = format.getSamplesPerSecond();
-   U32 bitsPerChannel = format.getBitsPerSample() / channels;
-   U32 dataSize = mBufferSize;
-
-   FMOD_SOUND_FORMAT sfxFmt = FMOD_SOUND_FORMAT_NONE;
-   switch(bitsPerChannel)
-   {
-      case 8:
-         sfxFmt = FMOD_SOUND_FORMAT_PCM8;
-         break;
-      case 16:
-         sfxFmt = FMOD_SOUND_FORMAT_PCM16;
-         break;
-      case 24:
-         sfxFmt = FMOD_SOUND_FORMAT_PCM24;
-         break;
-      case 32:
-         sfxFmt = FMOD_SOUND_FORMAT_PCM32;
-         break;
-      default:
-         AssertISV(false, "SFXFMODBuffer::SFXFMODBuffer() - unsupported bits-per-sample (what format is it in, 15bit PCM?)");
-         break;
-   }
-
-   dMemset(&createsoundexinfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
-   createsoundexinfo.cbsize            = sizeof(FMOD_CREATESOUNDEXINFO); /* required. */
-   createsoundexinfo.decodebuffersize  = frequency; /* Chunk size of stream update in samples.  This will be the amount of data passed to the user callback. */
-   createsoundexinfo.length            = dataSize; /* Length of PCM data in bytes of whole sound (for Sound::getLength) */
-   createsoundexinfo.numchannels       = channels; /* Number of channels in the sound. */
-   createsoundexinfo.defaultfrequency  = frequency; /* Default playback rate of sound. */
-   createsoundexinfo.format            = sfxFmt;  /* Data format of sound. */
-   createsoundexinfo.pcmreadcallback   = NULL; /* User callback for reading. */
-   createsoundexinfo.pcmsetposcallback = NULL; /* User callback for seeking. */
-   pCreatesoundexinfo = &createsoundexinfo;
-
-   FMOD_RESULT result = SFXFMODDevice::smFunc->FMOD_System_CreateSound(
-         SFXFMODDevice::smSystem, 
-         ( const char* ) NULL, 
-         fMode, 
-         pCreatesoundexinfo, 
-         &mSound );
-         
-   if( result != FMOD_OK )
-   {
-      mSound = NULL;
-      Con::errorf( "SFXFMODBuffer::SFXFMODBuffer - failed to create buffer (%i)", result );
-   }
-   else
-      SFXFMODDevice::smFunc->FMOD_Sound_GetMode( mSound, &mMode );
-}
-
-//-----------------------------------------------------------------------------
-
-SFXFMODBuffer::~SFXFMODBuffer()
-{
-   if( mSound )
-      FModAssert( SFXFMODDevice::smFunc->FMOD_Sound_Release( mSound ), 
-         "SFXFMODBuffer::~SFXFMODBuffer - Failed to release a sound!" );
-
-   mSound = NULL;
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODBuffer::_flush()
-{
-   AssertFatal( isStreaming(), "SFXFMODBuffer::_flush() - not a streaming buffer" );
-   AssertFatal( SFXInternal::isSFXThread(), "SFXFMODBuffer::_flush() - not on SFX thread" );
-
-   Parent::_flush();
-   SFXFMODDevice::smFunc->FMOD_Channel_SetPosition
-      ( ( ( SFXFMODVoice* ) mUniqueVoice.getPointer() )->mChannel, 0, FMOD_TIMEUNIT_PCM );
-}
-
-//-----------------------------------------------------------------------------
-
-bool SFXFMODBuffer::_copyData( U32 offset, const U8* data, U32 length )
-{
-   AssertFatal( data != NULL && length > 0, "Must have data!" );
-
-   // Fill the buffer with the resource data.      
-   void* lpvWrite;
-   U32  dwLength;
-   void* lpvWrite2;
-   U32  dwLength2;
-   int res = SFXFMODDevice::smFunc->FMOD_Sound_Lock(
-      mSound,
-      offset,           // Offset at which to start lock.
-      length,           // Size of lock.
-      &lpvWrite,        // Gets address of first part of lock.
-      &lpvWrite2,       // Address of wraparound not needed. 
-      &dwLength,        // Gets size of first part of lock.
-      &dwLength2       // Size of wraparound not needed.
-      );
-
-   if ( res != FMOD_OK )
-   {
-      // You can remove this if it gets spammy. However since we can
-      // safely fail in this case it doesn't seem right to assert...
-      // at the same time it can be very annoying not to know why 
-      // an upload fails!
-      Con::errorf("SFXFMODBuffer::_copyData - failed to lock a sound buffer! (%d)", this);
-      return false;
-   }
-
-   // Copy the first part.
-   dMemcpy( lpvWrite, data, dwLength );
-
-   // Do we have a wrap?
-   if ( lpvWrite2 )
-      dMemcpy( lpvWrite2, data + dwLength, dwLength2 );
-
-   // And finally, unlock.
-   FModAssert( SFXFMODDevice::smFunc->FMOD_Sound_Unlock(
-      mSound,
-      lpvWrite,      // Address of lock start.
-      lpvWrite2,     // No wraparound portion.
-      dwLength,      // Size of lock.
-      dwLength2 ),   // No wraparound size.
-      "Failed to unlock sound buffer!" );
-
-   return true;
-}
-
-//-----------------------------------------------------------------------------
-
-U32 SFXFMODBuffer::getMemoryUsed() const
-{
-   unsigned int memoryUsed;
-   
-   SFXFMODDevice::smFunc->FMOD_Sound_GetMemoryInfo(
-      mSound,
-      FMOD_MEMBITS_ALL,
-      FMOD_EVENT_MEMBITS_ALL,
-      &memoryUsed,
-      ( unsigned int* ) NULL );
-      
-   return memoryUsed;
-}
diff --git a/Engine/source/sfx/fmod/sfxFMODBuffer.h b/Engine/source/sfx/fmod/sfxFMODBuffer.h
deleted file mode 100644
index 1ce76ecb5..000000000
--- a/Engine/source/sfx/fmod/sfxFMODBuffer.h
+++ /dev/null
@@ -1,63 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#ifndef _SFXFMODBUFFER_H_
-#define _SFXFMODBUFFER_H_
-
-#include "fmod.h"
-
-#ifndef _SFXINTERNAL_H_
-#  include "sfx/sfxInternal.h"
-#endif
-
-
-class SFXFMODBuffer : public SFXInternal::SFXWrapAroundBuffer
-{
-      typedef SFXInternal::SFXWrapAroundBuffer Parent;
-
-      friend class SFXFMODDevice;
-      friend class SFXFMODVoice;
-
-   protected:
-
-      FMOD_SOUND *mSound;	   
-      FMOD_MODE mMode;
-
-      SFXFMODBuffer( const ThreadSafeRef< SFXStream >& stream, SFXDescription* description );
-      SFXFMODBuffer( const String& filename, SFXDescription* description );
-
-      // SFXWrapAroundBuffer.
-      virtual bool _copyData( U32 offset, const U8* data, U32 length );
-      virtual void _flush();
-
-      virtual ~SFXFMODBuffer();
-
-   public:
-
-      ///
-      static SFXFMODBuffer* create( const ThreadSafeRef< SFXStream >& stream, SFXDescription* description );
-      static SFXFMODBuffer* create( const String& filename, SFXDescription* description );
-
-      virtual U32 getMemoryUsed() const;
-};
-
-#endif // _SFXFMODBUFFER_H_
\ No newline at end of file
diff --git a/Engine/source/sfx/fmod/sfxFMODDevice.cpp b/Engine/source/sfx/fmod/sfxFMODDevice.cpp
deleted file mode 100644
index 7875abf67..000000000
--- a/Engine/source/sfx/fmod/sfxFMODDevice.cpp
+++ /dev/null
@@ -1,578 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#include "platform/platform.h"
-#include "platform/threads/mutex.h"
-#include "sfx/fmod/sfxFMODDevice.h"
-#include "sfx/fmod/sfxFMODBuffer.h"
-#include "sfx/sfxSystem.h"
-#include "platform/async/asyncUpdate.h"
-#include "console/consoleTypes.h"
-#include "core/volume.h"
-
-
-bool                 SFXFMODDevice::smPrefDisableSoftware = false;
-bool                 SFXFMODDevice::smPrefUseSoftwareOcclusion = true;
-bool                 SFXFMODDevice::smPrefUseSoftwareHRTF = true;
-bool                 SFXFMODDevice::smPrefEnableProfile = false;
-bool                 SFXFMODDevice::smPrefGeometryUseClosest = false;
-const char*          SFXFMODDevice::smPrefDSoundHRTF = "full";
-const char*          SFXFMODDevice::smPrefPluginPath = "";
-U32                  SFXFMODDevice::smStatMemUsageCore;
-U32                  SFXFMODDevice::smStatMemUsageEvents;
-U32                  SFXFMODDevice::smStatNumEventSources;
-SFXFMODDevice*       SFXFMODDevice::smInstance;
-FMOD_SYSTEM*         SFXFMODDevice::smSystem;
-FMOD_EVENTSYSTEM*    SFXFMODDevice::smEventSystem;
-FModFNTable*         SFXFMODDevice::smFunc;
-Mutex*               FModFNTable::mutex;
-
-
-//-----------------------------------------------------------------------------
-
-String FMODResultToString( FMOD_RESULT result )
-{
-   switch( result )
-   {
-      #define FMOD_ERROR( n ) case n: return #n;
-      #include "fmodErrors.h"
-      #undef FMOD_ERROR
-      
-      default:
-         break;
-   }
-   
-   return String();
-}
-
-//------------------------------------------------------------------------------
-// FMOD filesystem wrappers.
-//FIXME: these are not thread-safe and cannot be used as such
-
-FMOD_RESULT F_CALLBACK fmodFileOpenCallback( const char* name, int unicode, unsigned int* filesize, void** handle, void** userdata )
-{
-   String fileName;
-   if( unicode )
-      fileName = String( ( UTF16* ) name );
-   else
-      fileName = String( name );
-      
-   Torque::FS::FileRef file = Torque::FS::OpenFile( fileName, Torque::FS::File::Read );
-   if( !file )
-      return FMOD_ERR_FILE_NOTFOUND;
-   else if( file->getStatus() != Torque::FS::File::Open )
-      return FMOD_ERR_FILE_BAD;
-      
-   // Add a reference so we can pass it into FMOD.
-   file->incRefCount();
-      
-   *filesize = U32( file->getSize() );
-   *handle = file.getPointer();
-
-   return FMOD_OK;
-}
-
-FMOD_RESULT F_CALLBACK fmodFileCloseCallback( void* handle, void* userdata )
-{
-   Torque::FS::File* file = reinterpret_cast< Torque::FS::File* >( handle );
-   file->decRefCount();
-   return FMOD_OK;
-}
-
-FMOD_RESULT F_CALLBACK fmodFileReadCallback( void* handle, void* buffer, unsigned int sizebytes, unsigned int* bytesread, void* userdata )
-{
-   Torque::FS::File* file = reinterpret_cast< Torque::FS::File* >( handle );
-
-   U32 numRead = file->read( buffer, sizebytes );
-   *bytesread = numRead;
-   
-   if( file->getStatus() == Torque::FS::File::EndOfFile )
-      return FMOD_ERR_FILE_EOF;
-   else if( file->getStatus() != Torque::FS::File::Open )
-      return FMOD_ERR_FILE_BAD;
-      
-   return FMOD_OK;
-}
-
-FMOD_RESULT F_CALLBACK fmodFileSeekCallback( void* handle, unsigned int pos, void* userdata )
-{
-   Torque::FS::File* file = reinterpret_cast< Torque::FS::File* >( handle );
-   
-   if( file->setPosition( pos, Torque::FS::File::Begin ) != pos )
-      return FMOD_ERR_FILE_COULDNOTSEEK;
-      
-   return FMOD_OK;
-}
-
-//-----------------------------------------------------------------------------
-
-SFXFMODDevice::SFXFMODDevice( SFXProvider* provider, 
-                              FModFNTable *fmodFnTbl, 
-                              int deviceIdx, 
-                              String name )
-   :  SFXDevice( name, provider, false, 32 ),
-      m3drolloffmode( FMOD_3D_INVERSEROLLOFF ),
-      mDeviceIndex( deviceIdx )
-{
-	// Store off the function pointers for later use.
-	smFunc = fmodFnTbl;
-
-   smStatMemUsageCore = 0;
-   smStatMemUsageEvents = 0;
-   smStatNumEventSources = 0;
-      
-   // Register our SFXSystem plugin.
-   
-   SFX->addPlugin( &mPlugin );
-   
-   smInstance = this;
-}
-
-//-----------------------------------------------------------------------------
-
-SFXFMODDevice::~SFXFMODDevice()
-{
-   _releaseAllResources();
-   
-   SFX->removePlugin( &mPlugin );
-   
-   if( smEventSystem )
-   {
-      smFunc->FMOD_EventSystem_Release( smEventSystem );
-      smEventSystem = NULL;
-      smSystem = NULL;
-   }
-   else
-      smFunc->FMOD_System_Close( smSystem );
-      
-   smInstance = NULL;
-}
-
-//-----------------------------------------------------------------------------
-
-bool SFXFMODDevice::_init()
-{
-   #define FMOD_CHECK( message )                               \
-      if( result != FMOD_OK )                                  \
-      {                                                        \
-         Con::errorf( "SFXFMODDevice::_init() - %s (%s)",      \
-            message,                                           \
-            FMOD_ErrorString( result ) );                      \
-         return false;                                         \
-      }
-
-	AssertISV(smSystem, 
-      "SFXFMODDevice::_init() - can't init w/o an existing FMOD system handle!");
-
-   FMOD_RESULT result;
-   
-   // Get some prefs.
-   
-   if( smPrefPluginPath && smPrefPluginPath[ 0 ] )
-   {
-      char fullPath[ 4096 ];
-      Platform::makeFullPathName( smPrefPluginPath, fullPath, sizeof( fullPath ) );
-      
-      smFunc->FMOD_System_SetPluginPath( smSystem, fullPath );
-   }
-   else
-   {
-      smFunc->FMOD_System_SetPluginPath( smSystem, Platform::getExecutablePath() );
-   }
-   
-	// Initialize everything from fmod.
-	FMOD_SPEAKERMODE speakermode;
-	FMOD_CAPS        caps;
-	result = smFunc->FMOD_System_GetDriverCaps(smSystem, 0, &caps, ( int* ) 0, &speakermode);
-   FMOD_CHECK( "SFXFMODDevice::init - Failed to get driver caps" );
-
-	result = smFunc->FMOD_System_SetDriver(smSystem, mDeviceIndex);
-   FMOD_CHECK( "SFXFMODDevice::init - Failed to set driver" );
-
-	result = smFunc->FMOD_System_SetSpeakerMode(smSystem, speakermode);
-   FMOD_CHECK( "SFXFMODDevice::init - Failed to set the user selected speaker mode" );
-
-	if (caps & FMOD_CAPS_HARDWARE_EMULATED)             /* The user has the 'Acceleration' slider set to off!  This is really bad for latency!. */
-	{                                                   /* You might want to warn the user about this. */
-		result = smFunc->FMOD_System_SetDSPBufferSize(smSystem, 1024, 10);
-      FMOD_CHECK( "SFXFMODDevice::init - Failed to set DSP buffer size" );
-	}
-   
-   Con::printf( "\nFMOD Device caps:" );
-   #define PRINT_CAP( name )              \
-      if( caps & FMOD_CAPS_ ## name )     \
-         Con::printf( #name );
-         
-   PRINT_CAP( HARDWARE );
-   PRINT_CAP( HARDWARE_EMULATED );
-   PRINT_CAP( OUTPUT_MULTICHANNEL );
-   PRINT_CAP( OUTPUT_FORMAT_PCM8 );
-   PRINT_CAP( OUTPUT_FORMAT_PCM16 );
-   PRINT_CAP( OUTPUT_FORMAT_PCM24 );
-   PRINT_CAP( OUTPUT_FORMAT_PCM32 );
-   PRINT_CAP( OUTPUT_FORMAT_PCMFLOAT );
-   PRINT_CAP( REVERB_LIMITED );
-   
-   Con::printf( "" );
-   
-   bool tryAgain;
-   do
-   {
-      tryAgain = false;
-      
-      FMOD_INITFLAGS flags = FMOD_INIT_NORMAL | FMOD_INIT_VOL0_BECOMES_VIRTUAL;
-      
-      if( smPrefDisableSoftware )
-         flags |= FMOD_INIT_SOFTWARE_DISABLE;
-      if( smPrefUseSoftwareOcclusion )
-         flags |= FMOD_INIT_OCCLUSION_LOWPASS;
-      if( smPrefUseSoftwareHRTF )
-         flags |= FMOD_INIT_HRTF_LOWPASS;
-      if( smPrefEnableProfile )
-         flags |= FMOD_INIT_ENABLE_PROFILE;
-      if( smPrefGeometryUseClosest )
-         flags |= FMOD_INIT_GEOMETRY_USECLOSEST;
-      
-      if( smEventSystem )
-         result = smFunc->FMOD_EventSystem_Init( smEventSystem, 100, flags, ( void* ) 0, FMOD_EVENT_INIT_NORMAL );
-      else
-         result = smFunc->FMOD_System_Init( smSystem, 100, flags, ( void* ) 0 );
-         
-      if( result == FMOD_ERR_OUTPUT_CREATEBUFFER )         /* Ok, the speaker mode selected isn't supported by this soundcard.  Switch it back to stereo... */
-      {
-         result = smFunc->FMOD_System_SetSpeakerMode( smSystem, FMOD_SPEAKERMODE_STEREO );
-         FMOD_CHECK( "SFXFMODDevice::init - failed on fallback speaker mode setup" );
-         tryAgain = true;
-      }
-   } while( tryAgain );
-   FMOD_CHECK( "SFXFMODDevice::init - failed to init system" );
-   
-   // Print hardware channel info.
-
-   if( caps & FMOD_CAPS_HARDWARE )
-   {
-      int num3D, num2D, numTotal;
-      
-      if( smFunc->FMOD_System_GetHardwareChannels( smSystem, &num2D, &num3D, &numTotal ) == FMOD_OK )
-         Con::printf( "FMOD Hardware channels: 2d=%i, 3d=%i, total=%i", num2D, num3D, numTotal );
-   }
-
-   // Set up filesystem.
-   
-   //FIXME: Don't do this for now.  Crashes on Windows.
-   #if 0
-   smFunc->FMOD_System_SetFileSystem( smSystem, fmodFileOpenCallback, fmodFileCloseCallback, fmodFileReadCallback, fmodFileSeekCallback, -1 );
-   #endif
-      
-   // Set capabilities.
-   
-   mCaps = CAPS_Reverb | CAPS_VoiceManagement;
-   if( smEventSystem )
-      mCaps |= CAPS_FMODDesigner;
-
-   // Start the update thread.
-   
-   #ifndef TORQUE_DEDICATED // Avoid dependency on platform/async for Linx dedicated.
-   
-   if( !Con::getBoolVariable( "$_forceAllMainThread" ) )
-   {
-      SFXInternal::gUpdateThread = new AsyncPeriodicUpdateThread
-         ( "FMOD Update Thread", SFXInternal::gBufferUpdateList,
-           Con::getIntVariable( "$pref::SFX::updateInterval", SFXInternal::DEFAULT_UPDATE_INTERVAL ) );
-      SFXInternal::gUpdateThread->start();
-   }
-   
-   #endif
-   
-   return true;
-}
-
-//-----------------------------------------------------------------------------
-
-SFXBuffer* SFXFMODDevice::createBuffer( const ThreadSafeRef< SFXStream >& stream, SFXDescription* description )
-{
-   AssertFatal( stream, "SFXFMODDevice::createBuffer() - Got a null stream!" );
-   AssertFatal( description, "SFXFMODDevice::createBuffer() - Got null description!" );
-
-   SFXFMODBuffer *buffer = SFXFMODBuffer::create( stream, description );
-   if ( buffer )
-      _addBuffer( buffer );
-
-   return buffer;
-}
-
-//-----------------------------------------------------------------------------
-
-SFXBuffer* SFXFMODDevice::createBuffer( const String& filename, SFXDescription* description )
-{
-   AssertFatal( filename.isNotEmpty(), "SFXFMODDevice::createBuffer() - Got an empty filename!" );
-   AssertFatal( description, "SFXFMODDevice::createBuffer() - Got null description!" );
-
-   SFXFMODBuffer* buffer = SFXFMODBuffer::create( filename, description );
-   if( buffer )
-      _addBuffer( buffer );
-      
-   return buffer;
-}
-
-//-----------------------------------------------------------------------------
-
-SFXVoice* SFXFMODDevice::createVoice( bool is3D, SFXBuffer* buffer )
-{
-   AssertFatal( buffer, "SFXFMODDevice::createVoice() - Got null buffer!" );
-
-   SFXFMODBuffer* fmodBuffer = dynamic_cast<SFXFMODBuffer*>( buffer );
-   AssertFatal( fmodBuffer, "SFXFMODDevice::createVoice() - Got bad buffer!" );
-
-   SFXFMODVoice* voice = SFXFMODVoice::create( this, fmodBuffer );
-   if ( !voice )
-      return NULL;
-
-   _addVoice( voice );
-	return voice;
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODDevice::update()
-{
-   Parent::update();
-
-   if( smEventSystem )
-   {
-      FModAssert( smFunc->FMOD_EventSystem_Update( smEventSystem ), "Failed to update event system!" );
-   }
-   else
-   {
-      FModAssert(smFunc->FMOD_System_Update(smSystem), "Failed to update system!");
-   }
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODDevice::setNumListeners( U32 num )
-{
-   smFunc->FMOD_System_Set3DNumListeners( smSystem, num );
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODDevice::setListener( U32 index, const SFXListenerProperties& listener )
-{
-   FMOD_VECTOR position, forward, up, velocity;
-   
-   TorqueTransformToFMODVectors( listener.getTransform(), position, forward, up );
-   TorqueVectorToFMODVector( listener.getVelocity(), velocity );
-
-	// Do the listener state update, then update!
-	smFunc->FMOD_System_Set3DListenerAttributes( smSystem, index, &position, &velocity, &forward, &up );
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODDevice::setDistanceModel( SFXDistanceModel model )
-{
-   switch( model )
-   {
-      case SFXDistanceModelLinear:
-         m3drolloffmode = FMOD_3D_LINEARROLLOFF;
-         break;
-         
-      case SFXDistanceModelLogarithmic:
-         m3drolloffmode = FMOD_3D_INVERSEROLLOFF;
-         break;
-         
-      default:
-         AssertWarn( false, "SFXFMODDevice::setDistanceModel - model not implemented" );
-   }
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODDevice::setDopplerFactor( F32 factor )
-{
-   F32 dopplerFactor;
-   F32 distanceFactor;
-   F32 rolloffFactor;
-   
-   smFunc->FMOD_System_Get3DSettings( smSystem, &dopplerFactor, &distanceFactor, &rolloffFactor );
-   dopplerFactor = factor;
-   smFunc->FMOD_System_Set3DSettings( smSystem, dopplerFactor, distanceFactor, rolloffFactor );
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODDevice::setRolloffFactor( F32 factor )
-{
-   F32 dopplerFactor;
-   F32 distanceFactor;
-   F32 rolloffFactor;
-   
-   smFunc->FMOD_System_Get3DSettings( smSystem, &dopplerFactor, &distanceFactor, &rolloffFactor );
-   rolloffFactor = factor;
-   smFunc->FMOD_System_Set3DSettings( smSystem, dopplerFactor, distanceFactor, rolloffFactor );
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODDevice::setReverb( const SFXReverbProperties& reverb )
-{
-   FMOD_REVERB_PROPERTIES prop = FMOD_PRESET_GENERIC;
-
-   prop.Environment           = 0;
-   prop.EnvDiffusion          = reverb.mEnvDiffusion;
-   prop.Room                  = reverb.mRoom;
-   prop.RoomHF                = reverb.mRoomHF;
-   prop.RoomLF                = reverb.mRoomLF;
-   prop.DecayTime             = reverb.mDecayTime;
-   prop.DecayLFRatio          = reverb.mDecayLFRatio;
-   prop.DecayHFRatio          = reverb.mDecayHFRatio;
-   prop.Reflections           = reverb.mReflections;
-   prop.ReflectionsDelay      = reverb.mReflectionsDelay;
-   prop.Reverb                = reverb.mReverb;
-   prop.ReverbDelay           = reverb.mReverbDelay;
-   prop.ModulationTime        = reverb.mModulationTime;
-   prop.ModulationDepth       = reverb.mModulationDepth;
-   prop.HFReference           = reverb.mHFReference;
-   prop.LFReference           = reverb.mLFReference;
-   prop.Diffusion             = reverb.mDiffusion;
-   prop.Density               = reverb.mDensity;
-   prop.Flags                 = reverb.mFlags;
-   
-   // Here we only want to affect 3D sounds.  While not quite obvious from the docs,
-   // SetReverbProperties sets the global reverb environment for 2D sounds whereas
-   // SetAmbientReverbProperties sets the global reverb environment for 3D sounds.
-   
-   FMOD_RESULT result = smFunc->FMOD_System_SetReverbAmbientProperties( smSystem, &prop );
-   if( result != FMOD_OK )
-      Con::errorf( "SFXFMODDevice::setReverb - Failed to set reverb (%s)", FMODResultToString( result ).c_str() );
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODDevice::resetReverb()
-{
-   FMOD_REVERB_PROPERTIES prop = FMOD_PRESET_OFF;
-   smFunc->FMOD_System_SetReverbProperties( smSystem, &prop );
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODDevice::updateMemUsageStats()
-{
-   smFunc->FMOD_System_GetMemoryInfo( smSystem, ( unsigned int ) FMOD_MEMBITS_ALL,
-      ( unsigned int ) 0, ( unsigned int* ) &smStatMemUsageCore, ( unsigned int* ) 0 );
-      
-   if( smEventSystem )
-      smFunc->FMOD_EventSystem_GetMemoryInfo( smEventSystem, ( unsigned int ) 0,
-         ( unsigned int ) FMOD_EVENT_MEMBITS_ALL, ( unsigned int* ) &smStatMemUsageEvents, ( unsigned int* ) 0 );
-}
-
-//=============================================================================
-//    Console Functions.
-//=============================================================================
-// MARK: ---- Console Functions ----
-
-//------------------------------------------------------------------------------
-
-ConsoleFunction( fmodDumpDSPInfo, void, 1, 1, "()"
-				"@brief Dump information about the standard DSP effects.\n\n"
-				"@ingroup SFXFMOD")
-{
-   if( !SFXFMODDevice::smFunc )
-      return;
-      
-   const U32 firstDSPType = FMOD_DSP_TYPE_MIXER;
-   const U32 lastDSPType = FMOD_DSP_TYPE_TREMOLO;
-   
-   for( U32 i = firstDSPType; i <= lastDSPType; ++ i )
-   {
-      FMOD_DSP* dsp;
-      if( SFXFMODDevice::smFunc->FMOD_System_CreateDSPByType( SFXFMODDevice::smSystem, ( FMOD_DSP_TYPE ) i, &dsp ) == FMOD_OK )
-      {
-         // Print general info.
-         
-         char name[ 33 ];
-         unsigned int version;
-         int channels;
-         int numParameters;
-         
-         dMemset( name, 0, sizeof( name ) );
-         SFXFMODDevice::smFunc->FMOD_DSP_GetInfo( dsp, name, &version, &channels, ( int* ) NULL, ( int* ) NULL );
-         SFXFMODDevice::smFunc->FMOD_DSP_GetNumParameters( dsp, &numParameters );
-         
-         Con::printf( "----------------------------------------------------------------" );
-         Con::printf( "DSP: %s", name );
-         Con::printf( "Version: %i.%i", ( version & 0xffff0000 ) >> 16, version & 0xffff );
-         Con::printf( "Channels: %i", channels );
-         Con::printf( "Parameters: %i", numParameters );
-         Con::printf( "" );
-         
-         // Print parameter info.
-         
-         for( U32 n = 0; n < numParameters; ++ n )
-         {
-            char name[ 17 ];
-            char label[ 17 ];
-            char description[ 1024 ];
-            float minValue, maxValue;
-            float value;
-            char valueString[ 256 ];
-            
-            dMemset( name, 0, sizeof( name ) );
-            dMemset( label, 0, sizeof( label ) );
-            dMemset( description, 0, sizeof( description ) );
-            dMemset( valueString, 0, sizeof( valueString ) );
-            
-            SFXFMODDevice::smFunc->FMOD_DSP_GetParameterInfo( dsp, n, name, label, description, sizeof( description ) - 1, &minValue, &maxValue );
-            SFXFMODDevice::smFunc->FMOD_DSP_GetParameter( dsp, n, &value, valueString, sizeof( valueString ) - 1 );
-            
-            Con::printf( "* Parameter %i", n );
-            Con::printf( "Name: %s", name );
-            Con::printf( "Label: %s", label );
-            Con::printf( "Description: %s", description );
-            Con::printf( "Min: %f", minValue );
-            Con::printf( "Max: %f", maxValue );
-            Con::printf( "Value: %f (%s)", value, valueString );
-            Con::printf( "" );
-         }
-         
-         // Release the DSP.
-         
-         SFXFMODDevice::smFunc->FMOD_DSP_Release( dsp );
-      }
-   }
-}
-
-//-----------------------------------------------------------------------------
-
-ConsoleFunction( fmodDumpMemoryStats, void, 1, 1, "()"
-				"@return Prints the current memory consumption of the FMOD module\n\n"
-				"@ingroup SFXFMOD")
-{
-   int current = 0;
-   int max = 0;
-
-   if (SFXFMODDevice::smFunc && SFXFMODDevice::smFunc->FMOD_Memory_GetStats.fn)
-         SFXFMODDevice::smFunc->FMOD_Memory_GetStats(&current, &max);
-   Con::printf("Fmod current: %d, max: %d", current, max);
-}
diff --git a/Engine/source/sfx/fmod/sfxFMODDevice.h b/Engine/source/sfx/fmod/sfxFMODDevice.h
deleted file mode 100644
index fc15041e9..000000000
--- a/Engine/source/sfx/fmod/sfxFMODDevice.h
+++ /dev/null
@@ -1,342 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#ifndef _SFXFMODDEVICE_H_
-#define _SFXFMODDEVICE_H_
-
-#ifndef _SFXDEVICE_H_
-   #include "sfx/sfxDevice.h"
-#endif
-#ifndef _SFXFMODVOICE_H_
-   #include "sfx/fmod/sfxFMODVoice.h"
-#endif
-#ifndef _SFXFMODBUFFER_H_
-   #include "sfx/fmod/sfxFMODBuffer.h"
-#endif
-#ifndef _SFXFMODPLUGIN_H_
-   #include "sfx/fmod/sfxFMODPlugin.h"
-#endif
-
-#include "core/util/tDictionary.h"
-
-
-// Disable warning for unused static functions.
-#ifdef TORQUE_COMPILER_VISUALC
-   #pragma warning( disable : 4505 )
-#endif
-
-#if defined( TORQUE_OS_XENON ) || defined( TORQUE_OS_PS3 )
-   #define TORQUE_FMOD_STATIC
-   #define TORQUE_FMOD_NO_EVENTS //TEMP
-#endif
-
-
-#include "fmod.h"
-#include "fmod_errors.h"
-#include "fmod_event.h"
-
-#include "platform/platformDlibrary.h"
-#include "platform/threads/mutex.h"
-
-
-// This doesn't appear to exist in some contexts, so let's just add it.
-#if defined(TORQUE_OS_WIN) || defined(TORQUE_OS_XENON)
-#ifndef WINAPI
-#define WINAPI __stdcall
-#endif
-#else
-#define WINAPI
-#endif
-
-
-#define FModAssert(x, msg) \
-   { FMOD_RESULT result = ( x ); \
-     AssertISV( result == FMOD_OK, String::ToString( "%s: %s", msg, FMOD_ErrorString( result ) ) ); }
-
-#define FMOD_FN_FILE "sfx/fmod/fmodFunctions.h"
-
-
-// Typedefs
-#define FMOD_FUNCTION(fn_name, fn_args) \
-   typedef FMOD_RESULT (WINAPI *FMODFNPTR##fn_name)fn_args;
-#define FMOD_EVENT_FUNCTION(fn_name, fn_args) \
-   typedef FMOD_RESULT (WINAPI *FMODFNPTR##fn_name)fn_args;
-#include FMOD_FN_FILE
-#undef FMOD_FUNCTION
-#undef FMOD_EVENT_FUNCTION
-
-
-/// FMOD API function table.
-///
-/// FMOD doesn't want to be called concurrently so in order to
-/// not force everything to the main thread (where sound updates
-/// would just stall during loading), we thunk all the API
-/// calls and lock all API entry points to a single mutex.
-struct FModFNTable
-{
-   FModFNTable()
-      : isLoaded( false ),
-        eventIsLoaded( false ),
-        dllRef( NULL ),
-        eventDllRef( NULL )
-   {
-      AssertFatal( mutex == NULL,
-         "FModFNTable::FModFNTable() - this should be a singleton" );
-      mutex = new Mutex;
-   }
-   ~FModFNTable()
-   {
-      dllRef = NULL;
-      eventDllRef = NULL;      
-      delete mutex;
-   }
-
-   bool isLoaded;
-   bool eventIsLoaded;
-   DLibraryRef dllRef;
-   DLibraryRef eventDllRef;
-   static Mutex* mutex;
-
-   template< typename FN >
-   struct Thunk
-   {
-      FN fn;
-
-      template< typename A >
-      FMOD_RESULT operator()( A a )
-      {
-         mutex->lock();
-         FMOD_RESULT result = fn( a );
-         mutex->unlock();
-         return result;
-      }
-      template< typename A, typename B >
-      FMOD_RESULT operator()( A a, B b )
-      {
-         mutex->lock();
-         FMOD_RESULT result = fn( a, b );
-         mutex->unlock();
-         return result;
-      }
-      template< typename A, typename B, typename C >
-      FMOD_RESULT operator()( A a, B b, C c )
-      {
-         mutex->lock();
-         FMOD_RESULT result = fn( a, b, c );
-         mutex->unlock();
-         return result;
-      }
-      template< typename A, typename B, typename C, typename D >
-      FMOD_RESULT operator()( A a, B b, C c, D d )
-      {
-         mutex->lock();
-         FMOD_RESULT result = fn( a, b, c, d );
-         mutex->unlock();
-         return result;
-      }
-      template< typename A, typename B, typename C, typename D, typename E >
-      FMOD_RESULT operator()( A a, B b, C c, D d, E e )
-      {
-         mutex->lock();
-         FMOD_RESULT result = fn( a, b, c, d, e );
-         mutex->unlock();
-         return result;
-      }
-      template< typename A, typename B, typename C, typename D, typename E, typename F >
-      FMOD_RESULT operator()( A a, B b, C c, D d, E e, F f )
-      {
-         mutex->lock();
-         FMOD_RESULT result = fn( a, b, c, d, e, f );
-         mutex->unlock();
-         return result;
-      }
-      template< typename A, typename B, typename C, typename D, typename E, typename F, typename G >
-      FMOD_RESULT operator()( A a, B b, C c, D d, E e, F f, G g )
-      {
-         mutex->lock();
-         FMOD_RESULT result = fn( a, b, c, d, e, f, g );
-         mutex->unlock();
-         return result;
-      }
-      template< typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H >
-      FMOD_RESULT operator()( A a, B b, C c, D d, E e, F f, G g, H h )
-      {
-         mutex->lock();
-         FMOD_RESULT result = fn( a, b, c, d, e, f, g, h );
-         mutex->unlock();
-         return result;
-      }
-   };
-
-#define FMOD_FUNCTION(fn_name, fn_args) \
-   Thunk< FMODFNPTR##fn_name > fn_name;
-#define FMOD_EVENT_FUNCTION(fn_name, fn_args) \
-   Thunk< FMODFNPTR##fn_name > fn_name;
-#include FMOD_FN_FILE
-#undef FMOD_FUNCTION
-#undef FMOD_EVENT_FUNCTION
-};
-
-
-inline void TorqueVectorToFMODVector( const Point3F& torque, FMOD_VECTOR& fmod )
-{
-   fmod.x = torque.x;
-   fmod.y = torque.z;
-   fmod.z = torque.y;
-}
-
-inline void TorqueTransformToFMODVectors( const MatrixF& transform, FMOD_VECTOR& position, FMOD_VECTOR& forward, FMOD_VECTOR& up )
-{
-   Point3F _pos, _fwd, _up;
-   
-   transform.getColumn( 3, &_pos );
-	transform.getColumn( 1, &_fwd );
-	transform.getColumn( 2, &_up );
-
-   TorqueVectorToFMODVector( _pos, position );
-   TorqueVectorToFMODVector( _fwd, forward );
-   TorqueVectorToFMODVector( _up, up );
-}
-
-inline int TorquePriorityToFMODPriority( F32 priority )
-{
-   // Map [-2,2] to [256,0].
-   
-   F32 n = mClampF( priority, -2.0f, 2.0f ) + 2.0f;
-   return ( n * 256.0f / 4.0f );
-}
-
-inline String FMODEventPathToTorqueName( const String& path )
-{
-   String p = path;
-   p.replace( '/', '_' );
-   p.replace( '-', '_' );
-   p.replace( ' ', '_' );
-   p.replace( '(', '_' );
-   p.replace( ')', '_' );
-   p.replace( '%', '_' );
-   p.replace( '$', '_' );
-   return p;
-}
-
-inline String FMODEventPathToTorqueName( const String& projectName, const String& path )
-{
-   return String::ToString( "%s_%s", projectName.c_str(), FMODEventPathToTorqueName( path ).c_str() );
-}
-
-extern String FMODResultToString( FMOD_RESULT result );
-
-
-class SFXProvider;
-class SFXFMODPlugin;
-
-
-
-class SFXFMODDevice : public SFXDevice
-{
-   public:
-
-      typedef SFXDevice Parent;
-      friend class SFXFMODProvider; // _init
-      friend class SFXFMODEventSource; // smStatNumEventSources
-
-      explicit SFXFMODDevice();
-
-      SFXFMODDevice( SFXProvider* provider, FModFNTable *fmodFnTbl, int deviceIdx, String name );
-
-      virtual ~SFXFMODDevice();
-
-   protected:
-
-      FMOD_MODE m3drolloffmode;
-      int mDeviceIndex;
-      
-      /// The FMOD SFXSystemPlugin instance.
-      SFXFMODPlugin mPlugin;
-      
-      /// @name Console Variables
-      /// @{
-      
-      /// Current core FMOD memory usage in bytes.
-      static U32 smStatMemUsageCore;
-      
-      /// Current FMOD Event DLL memory usage in bytes.
-      static U32 smStatMemUsageEvents;
-      
-      /// Current number of SFXFMODEventSource instances.
-      static U32 smStatNumEventSources;
-      
-      ///
-      static bool smPrefDisableSoftware;
-      
-      ///
-      static bool smPrefUseSoftwareOcclusion;
-      
-      ///
-      static bool smPrefUseSoftwareHRTF;
-      
-      ///
-      static bool smPrefEnableProfile;
-      
-      ///
-      static bool smPrefGeometryUseClosest;
-      
-      ///
-      static const char* smPrefDSoundHRTF;
-      
-      ///
-      static const char* smPrefPluginPath;
-      
-      /// @}
-      
-      bool _init();
-      
-      static SFXFMODDevice* smInstance;
-      
-   public:
-   
-      static SFXFMODDevice* instance() { return smInstance; }
-   
-      FMOD_MODE get3dRollOffMode() { return m3drolloffmode; }
-
-      static FMOD_SYSTEM* smSystem;
-      static FMOD_EVENTSYSTEM* smEventSystem;
-      static FModFNTable* smFunc;
-      
-      // Update memory usage stats for metrics display.
-      void updateMemUsageStats();
-
-      // SFXDevice.
-      virtual SFXBuffer* createBuffer( const ThreadSafeRef< SFXStream >& stream, SFXDescription* description );
-      virtual SFXBuffer* createBuffer( const String& filename, SFXDescription* description );
-      virtual SFXVoice* createVoice( bool is3D, SFXBuffer* buffer );
-      virtual void update();
-      virtual void setNumListeners( U32 num );
-      virtual void setListener( U32 index, const SFXListenerProperties& listener );
-      virtual void setDistanceModel( SFXDistanceModel model );
-      virtual void setDopplerFactor( F32 factor );
-      virtual void setRolloffFactor( F32 factor );
-      virtual void setReverb( const SFXReverbProperties& reverb );
-      virtual void resetReverb();
-};
-
-#endif // _SFXFMODDEVICE_H_
diff --git a/Engine/source/sfx/fmod/sfxFMODEvent.cpp b/Engine/source/sfx/fmod/sfxFMODEvent.cpp
deleted file mode 100644
index dd8fbfa0e..000000000
--- a/Engine/source/sfx/fmod/sfxFMODEvent.cpp
+++ /dev/null
@@ -1,339 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#include "platform/platform.h"
-#include "sfx/fmod/sfxFMODEvent.h"
-#include "sfx/fmod/sfxFMODEventGroup.h"
-#include "sfx/fmod/sfxFMODProject.h"
-#include "sfx/fmod/sfxFMODDevice.h"
-#include "sfx/sfxParameter.h"
-#include "sfx/sfxDescription.h"
-#include "core/stream/bitStream.h"
-
-
-IMPLEMENT_CO_DATABLOCK_V1( SFXFMODEvent );
-
-
-ConsoleDocClass( SFXFMODEvent,
-   "@brief A playable sound event in an FMOD Designer audio project.\n\n"
-   
-   "@ingroup SFXFMOD\n"
-   "@ingroup Datablocks"
-);
-
-
-//-----------------------------------------------------------------------------
-
-SFXFMODEvent::SFXFMODEvent()
-   : mGroup( NULL ),
-     mHandle( NULL ),
-     mGroupId( 0 ),
-     mSibling( NULL )
-{
-   dMemset( mParameterRanges, 0, sizeof( mParameterRanges ) );
-   dMemset( mParameterValues, 0, sizeof( mParameterValues ) );
-}
-
-//-----------------------------------------------------------------------------
-
-SFXFMODEvent::SFXFMODEvent( SFXFMODEventGroup* group, FMOD_EVENT* handle )
-   : mGroup( group ),
-     mHandle( handle ),
-     mGroupId( 0 ),
-     mSibling( NULL )
-{
-   dMemset( mParameterRanges, 0, sizeof( mParameterRanges ) );
-   dMemset( mParameterValues, 0, sizeof( mParameterValues ) );
-   
-   // Fetch name.
-   
-   int index;
-   char* name = NULL;
-   
-   SFXFMODDevice::smFunc->FMOD_Event_GetInfo( mHandle, &index, &name, ( FMOD_EVENT_INFO* ) 0 );
-   
-   mName = name;
-   
-   // Read out the parameter info so we can immediately create
-   // the events on the client-side without having to open and
-   // read all the project info there.
-   
-   int numParameters;
-   SFXFMODDevice::smFunc->FMOD_Event_GetNumParameters( mHandle, &numParameters );
-   if( numParameters > MaxNumParameters )
-   {
-      Con::errorf( "SFXFMODEvent::SFXFMODEvent - event '%s' has more parameters (%i) than supported per SFXTrack (%i)",
-         getQualifiedName().c_str(),
-         numParameters,
-         MaxNumParameters );
-      numParameters = MaxNumParameters;
-   }
-   
-   for( U32 i = 0; i < numParameters; ++ i )
-   {
-      FMOD_EVENTPARAMETER* parameter;
-      SFXFMODDevice::smFunc->FMOD_Event_GetParameterByIndex( mHandle, i, &parameter );
-      
-      SFXFMODDevice::smFunc->FMOD_EventParameter_GetInfo( parameter, &index, &name );
-      setParameter( i, name );
-         
-      // Get value and range of parameter.
-      
-      SFXFMODDevice::smFunc->FMOD_EventParameter_GetValue( parameter, &mParameterValues[ i ] );
-      SFXFMODDevice::smFunc->FMOD_EventParameter_GetRange( parameter, &mParameterRanges[ i ].x, &mParameterRanges[ i ].y );
-   }
-   
-   // Read out the properties and create a custom SFXDescription for the event.
-   
-   mDescription = new SFXDescription;
-   if( !group->isClientOnly() )
-      mDescription->assignId();
-      
-   mDescription->registerObject(
-      String::ToString( "%s_%s_Description",
-         group->getName(),
-         FMODEventPathToTorqueName( mName ).c_str()
-      )
-   );
-   if( group->isClientOnly() )
-      Sim::getRootGroup()->addObject( mDescription );
-   
-   FMOD_MODE modeValue;
-   float floatValue;
-   
-   if( SFXFMODDevice::smFunc->FMOD_Event_GetPropertyByIndex( mHandle, FMOD_EVENTPROPERTY_MODE, &modeValue, true ) == FMOD_OK )
-      mDescription->mIs3D = ( modeValue == FMOD_3D );
-   if( SFXFMODDevice::smFunc->FMOD_Event_GetPropertyByIndex( mHandle, FMOD_EVENTPROPERTY_VOLUME, &floatValue, true ) == FMOD_OK )
-      mDescription->mVolume = floatValue;
-   if( SFXFMODDevice::smFunc->FMOD_Event_GetPropertyByIndex( mHandle, FMOD_EVENTPROPERTY_PITCH, &floatValue, true ) == FMOD_OK )
-      mDescription->mPitch = floatValue;
-   if( SFXFMODDevice::smFunc->FMOD_Event_GetPropertyByIndex( mHandle, FMOD_EVENTPROPERTY_3D_MINDISTANCE, &floatValue, true ) == FMOD_OK )
-      mDescription->mMinDistance = floatValue;
-   if( SFXFMODDevice::smFunc->FMOD_Event_GetPropertyByIndex( mHandle, FMOD_EVENTPROPERTY_3D_MAXDISTANCE, &floatValue, true ) == FMOD_OK )
-      mDescription->mMaxDistance = floatValue;
-   if( SFXFMODDevice::smFunc->FMOD_Event_GetPropertyByIndex( mHandle, FMOD_EVENTPROPERTY_3D_CONEINSIDEANGLE, &floatValue, true ) == FMOD_OK )
-      mDescription->mConeInsideAngle = floatValue;
-   if( SFXFMODDevice::smFunc->FMOD_Event_GetPropertyByIndex( mHandle, FMOD_EVENTPROPERTY_3D_CONEOUTSIDEANGLE, &floatValue, true ) == FMOD_OK )
-      mDescription->mConeOutsideAngle = floatValue;
-   if( SFXFMODDevice::smFunc->FMOD_Event_GetPropertyByIndex( mHandle, FMOD_EVENTPROPERTY_3D_CONEOUTSIDEVOLUME, &floatValue, true ) == FMOD_OK )
-      mDescription->mConeOutsideVolume = floatValue;
-      
-   // Don't read out fade values as we want to leave fade-effects to
-   // FMOD rather than having the fading system built into SFX pick
-   // these values up.
-}
-
-//-----------------------------------------------------------------------------
-
-SFXFMODEvent::~SFXFMODEvent()
-{
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEvent::initPersistFields()
-{
-   addGroup( "DO NOT MODIFY!!" );
-   addField( "fmodGroup", TYPEID< SFXFMODEventGroup >(), Offset( mGroup, SFXFMODEvent ), "DO NOT MODIFY!!" );
-   addField( "fmodName", TypeRealString, Offset( mName, SFXFMODEvent ), "DO NOT MODIFY!!" );
-   addField( "fmodParameterRanges", TypePoint2F, Offset( mParameterRanges, SFXFMODEvent ), MaxNumParameters, "DO NOT MODIFY!!" );
-   addField( "fmodParameterValues", TypeF32, Offset( mParameterValues, SFXFMODEvent ), MaxNumParameters, "DO NOT MODIFY!!" );
-   endGroup( "DO NOT MODIFY!!" );
-   
-   Parent::initPersistFields();
-}
-
-//-----------------------------------------------------------------------------
-
-bool SFXFMODEvent::onAdd()
-{
-   if( !Parent::onAdd() )
-      return false;
-      
-   if( !mGroup )
-   {
-      Con::errorf( "SFXFMODEvent::onAdd - no group set; this event was not properly constructed" );
-      return false;
-   }
-   
-   mGroup->_addEvent( this );
-   mGroup->mProject->_addEvent( this );
-   
-   // For non-networked event datablocks, create the parameter
-   // instances now.
-   
-   if( isClientOnly() )
-      _createParameters();
-      
-   return true;
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEvent::onRemove()
-{
-   Parent::onRemove();
-   
-   if( !mGroup )
-      return;
-   
-   release();
-   mGroup->_removeEvent( this );
-}
-
-//-----------------------------------------------------------------------------
-
-bool SFXFMODEvent::preload( bool server, String& errorStr )
-{
-   if( !Parent::preload( server, errorStr ) )
-      return false;
-      
-   if( !server )
-   {
-      if( !Sim::findObject( mGroupId, mGroup ) )
-      {
-         errorStr = String::ToString( "SFXFMODEvent - group '%i' does not exist", mGroupId );
-         return false;
-      }
-
-      // Create parameters.
-
-      _createParameters();
-   }
-      
-   return true;
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEvent::packData( BitStream* stream )
-{
-   Parent::packData( stream );
-   
-   stream->write( mName );
-   stream->writeRangedS32( mGroup->getId(), DataBlockObjectIdFirst, DataBlockObjectIdLast );
-   
-   for( U32 i = 0; i < MaxNumParameters; ++ i )
-      if( stream->writeFlag( mParameters[ i ] ) )
-      {
-         stream->write( mParameterValues[ i ] );
-         stream->write( mParameterRanges[ i ].x );
-         stream->write( mParameterRanges[ i ].y );
-      }
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEvent::unpackData( BitStream* stream )
-{
-   Parent::unpackData( stream );
-
-   stream->read( &mName );
-   mGroupId = stream->readRangedS32( DataBlockObjectIdFirst, DataBlockObjectIdLast );
-   
-   for( U32 i = 0; i < MaxNumParameters; ++ i )
-      if( stream->readFlag() )
-      {
-         stream->read( &mParameterValues[ i ] );
-         stream->read( &mParameterRanges[ i ].x );
-         stream->read( &mParameterRanges[ i ].y );
-      }
-      else
-      {
-         mParameterValues[ i ] = 0.f;
-         mParameterRanges[ i ].x = 0.f;
-         mParameterRanges[ i ].y = 0.f;
-      }
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEvent::acquire()
-{
-   if( mHandle )
-      return;
-      
-   mGroup->acquire();
-   if( SFXFMODDevice::smFunc->FMOD_EventGroup_GetEvent(
-         mGroup->mHandle, mName.c_str(), FMOD_EVENT_INFOONLY, &mHandle ) != FMOD_OK )
-   {
-      Con::errorf( "SFXFMODEvent::acquire() - failed to acquire event '%s'", getQualifiedName().c_str() );
-      return;
-   }
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEvent::release()
-{
-   if( !mHandle )
-      return;
-      
-   SFXFMODDevice::smFunc->FMOD_Event_Release( mHandle, true, false );
-   mHandle = NULL;
-}
-
-//-----------------------------------------------------------------------------
-
-String SFXFMODEvent::getQualifiedName() const
-{
-   return String::ToString( "%s/%s", getEventGroup()->getQualifiedName().c_str(), mName.c_str() );
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEvent::_createParameters()
-{
-   const String& projectFileName = getEventGroup()->getProject()->getFileName();
-   const String qualifiedGroupName = getEventGroup()->getQualifiedName();
-   const String description = String::ToString( "FMOD Event Parameter (%s)", projectFileName.c_str() );
-   
-   for( U32 i = 0; i < MaxNumParameters; ++ i )
-   {
-      StringTableEntry name = getParameter( i );
-      if( !name )
-         continue;
-         
-      SFXParameter* parameter = SFXParameter::find( name );
-      if( !parameter )
-      {
-         parameter = new SFXParameter();
-         parameter->setInternalName( name );
-         parameter->registerObject();
-         
-         // Set up parameter.
-         
-         parameter->setChannel( SFXChannelUser0 );
-         parameter->setRange( mParameterRanges[ i ] );
-         parameter->setDefaultValue( mParameterValues[ i ] );
-         parameter->setValue( mParameterValues[ i ] );
-         parameter->setDescription( description );
-         
-         // Set categories for easy filtering.
-         
-         static StringTableEntry sCategories = StringTable->insert( "categories" );
-         parameter->setDataField( sCategories, "0", "FMOD" );
-         parameter->setDataField( sCategories, "1", avar( "FMOD Project: %s", projectFileName.c_str() ) );
-         parameter->setDataField( sCategories, "2", avar( "FMOD Group: %s", qualifiedGroupName.c_str() ) );
-      }
-   }
-}
diff --git a/Engine/source/sfx/fmod/sfxFMODEvent.h b/Engine/source/sfx/fmod/sfxFMODEvent.h
deleted file mode 100644
index 1e4c53e00..000000000
--- a/Engine/source/sfx/fmod/sfxFMODEvent.h
+++ /dev/null
@@ -1,135 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#ifndef _SFXFMODEVENT_H_
-#define _SFXFMODEVENT_H_
-
-#ifndef _SFXTRACK_H_
-   #include "sfx/sfxTrack.h"
-#endif
-#ifndef _CONSOLETYPES_H_
-   #include "console/consoleTypes.h"
-#endif
-#ifndef _MPOINT2_H_
-   #include "math/mPoint2.h"
-#endif
-
-#include "fmod_event.h"
-
-
-class SFXFMODProject;
-class SFXFMODEventGroup;
-
-
-/// An event in an FMOD Designer project.
-///
-/// This class must not be manually instanced by the user.  Instead, SFXFMODEvents
-/// are automatically created when an SFXFMODProject is loaded.
-///
-/// Be aware that as all the playback happens internally within FMOD's event system,
-/// this bypasses the SFX layer and will thus not work with features that rely the
-/// structures there.  Namely, sound occlusion (except for FMOD's own occlusion) will
-/// not work with FMOD events.
-///
-/// The parameters of an FMOD event are automatically created and designed using the
-/// information in the project.
-///
-class SFXFMODEvent : public SFXTrack
-{
-   public:
-   
-      typedef SFXTrack Parent;
-      friend class SFXFMODEventGroup;
-      friend class SFXFMODEventSource;
-      
-   protected:
-   
-      /// Name of the event in the Designer project.
-      String mName;
-      
-      /// Event group that this event belongs to.
-      SFXFMODEventGroup* mGroup;
-      
-      /// Next event in the group's event chain.
-      SFXFMODEvent* mSibling;
-      
-      /// FMOD event handle when event is open.  Client-side only.
-      FMOD_EVENT* mHandle;
-      
-      ///
-      Point2F mParameterRanges[ MaxNumParameters ];
-      
-      ///
-      F32 mParameterValues[ MaxNumParameters ];
-      
-      /// Group ID for client net sync.
-      S32 mGroupId;
-      
-      ///
-      void _createParameters();
-      
-   public:
-   
-      ///
-      SFXFMODEvent();
-      
-      ///
-      SFXFMODEvent( SFXFMODEventGroup* group, const String& name );
-      
-      ///
-      SFXFMODEvent( SFXFMODEventGroup* group, FMOD_EVENT* handle );
-      
-      ~SFXFMODEvent();
-
-      /// Create the event object on the FMOD device.
-      void acquire();
-      
-      /// Release the event object on the FMOD device.
-      void release();
-      
-      ///
-      const String& getEventName() const { return mName; }
-      
-      ///
-      SFXFMODEventGroup* getEventGroup() const { return mGroup; }
-      
-      ///
-      String getQualifiedName() const;
-      
-      ///
-      bool isDataLoaded() const;
-      
-      // SFXTrack.
-      virtual bool onAdd();
-      virtual void onRemove();
-      virtual bool preload( bool server, String& errorStr );
-      virtual void packData( BitStream* stream );
-      virtual void unpackData( BitStream* stream );
-      
-      static void initPersistFields();
-      
-      DECLARE_CONOBJECT( SFXFMODEvent );
-      DECLARE_CATEGORY( "SFX FMOD" );
-      DECLARE_DESCRIPTION( "An FMOD Designer event." );
-};
-
-#endif // !_SFXFMODEVENT_H_
diff --git a/Engine/source/sfx/fmod/sfxFMODEventGroup.cpp b/Engine/source/sfx/fmod/sfxFMODEventGroup.cpp
deleted file mode 100644
index a42f08bde..000000000
--- a/Engine/source/sfx/fmod/sfxFMODEventGroup.cpp
+++ /dev/null
@@ -1,510 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#include "sfx/fmod/sfxFMODEventGroup.h"
-#include "sfx/fmod/sfxFMODDevice.h"
-#include "sfx/fmod/sfxFMODEvent.h"
-#include "sfx/fmod/sfxFMODProject.h"
-#include "core/stream/bitStream.h"
-#include "console/engineAPI.h"
-
-
-IMPLEMENT_CO_DATABLOCK_V1( SFXFMODEventGroup );
-
-ConsoleDocClass( SFXFMODEventGroup,
-   "@brief A group of events in an imported FMOD Designer project.\n\n"
-   
-   ""
-   
-   "@note Instances of this class \n\n"
-   
-   "@ingroup SFXFMOD\n"
-   "@ingroup Datablocks"
-);
-
-//-----------------------------------------------------------------------------
-
-SFXFMODEventGroup::SFXFMODEventGroup()
-   : mProject( NULL ),
-     mHandle( NULL ),
-     mParent( NULL ),
-     mChildren( NULL ),
-     mSibling( NULL ),
-     mLoadCount( 0 ),
-     mEvents( NULL ),
-     mNumEvents( 0 ),
-     mNumGroups( 0 ),
-     mParentId( 0 ),
-     mProjectId( 0 )
-{
-}
-
-//-----------------------------------------------------------------------------
-
-SFXFMODEventGroup::SFXFMODEventGroup( SFXFMODProject* project, FMOD_EVENTGROUP* handle, SFXFMODEventGroup* parent )
-   : mProject( project ),
-     mHandle( handle ),
-     mParent( parent ),
-     mChildren( NULL ),
-     mSibling( NULL ),
-     mLoadCount( 0 ),
-     mEvents( NULL ),
-     mNumEvents( 0 ),
-     mNumGroups( 0 ),
-     mParentId( 0 ),
-     mProjectId( 0 )
-{
-   AssertFatal( project != NULL, "SFXFMODEventGroup::SFXFMODEventGroup - got a NULL project!" );
-   AssertFatal( handle != NULL, "SFXFMODEventGroup::SFXFMODEventGroup - got a NULL group handle!" );
-   
-   // Fetch the name.
-   
-   int index;
-   char* name = NULL;
-   
-   SFXFMODDevice::smFunc->FMOD_EventGroup_GetInfo( handle, &index, &name );
-   
-   mName = name;
-}
-
-//-----------------------------------------------------------------------------
-
-SFXFMODEventGroup::~SFXFMODEventGroup()
-{
-   AssertFatal( mEvents == NULL, "SFXFMODEventGroup::~SFXFMODEventGroup - group still has events attached" );
-   AssertFatal( mChildren == NULL, "SFXFMODEventGroup::~SFXFMODEventGroup - group still has subgroups attached" );
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEventGroup::initPersistFields()
-{
-   addGroup( "DO NOT MODIFY!!" );
-   addField( "fmodProject", TYPEID< SFXFMODProject >(), Offset( mProject, SFXFMODEventGroup ), "DO NOT MODIFY!!" );
-   addField( "fmodGroup", TYPEID< SFXFMODEventGroup >(), Offset( mParent, SFXFMODEventGroup ), "DO NOT MODIFY!!" );
-   addField( "fmodName", TypeRealString, Offset( mName, SFXFMODEventGroup ), "DO NOT MODIFY!!" );
-   endGroup( "DO NOT MODIFY!!" );
-   
-   Parent::initPersistFields();
-}
-
-//-----------------------------------------------------------------------------
-
-bool SFXFMODEventGroup::onAdd()
-{
-   if( !Parent::onAdd() )
-      return false;
-      
-   if( !mProject )
-   {
-      Con::errorf( "SFXFMODEventGroup - not part of a project" );
-      return false;
-   }
-      
-   if( mParent )
-      mParent->_addGroup( this );
-   
-   mProject->_addGroup( this );
-      
-   return true;
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEventGroup::onRemove()
-{
-   Parent::onRemove();
-   
-   if( !mProject )
-      return;
-   
-   release();
-   
-   while( mEvents )
-      mEvents->deleteObject();
-   while( mChildren )
-      mChildren->deleteObject();
-   
-   if( mParent )
-      mParent->_removeGroup( this );
-      
-   mProject->_removeGroup( this );
-}
-
-//-----------------------------------------------------------------------------
-
-bool SFXFMODEventGroup::preload( bool server, String& errorStr )
-{
-   if( !Parent::preload( server, errorStr ) )
-      return false;
-   
-   if( !server )
-   {
-      if( mParentId != 0 && !Sim::findObject( mParentId, mParent ) )
-      {
-         errorStr = String::ToString( "SFXFMODEventGroup - parent group '%i' does not exist", mParentId );
-         return false;
-      }
-      if( !Sim::findObject( mProjectId, mProject ) )
-      {
-         errorStr = String::ToString( "SFXFMODEventGroup - project '%i' does not exist", mProjectId );
-         return false;
-      }
-   }
-      
-   return true;
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEventGroup::packData( BitStream* stream )
-{
-   Parent::packData( stream );
-   
-   stream->write( mName );
-   stream->writeRangedS32( mProject->getId(), DataBlockObjectIdFirst, DataBlockObjectIdLast );
-   if( stream->writeFlag( mParent ) )
-      stream->writeRangedS32( mParent->getId(), DataBlockObjectIdFirst, DataBlockObjectIdLast );
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEventGroup::unpackData( BitStream* stream )
-{
-   Parent::unpackData( stream );
-   
-   stream->read( &mName );
-   
-   mProjectId = stream->readRangedS32( DataBlockObjectIdFirst, DataBlockObjectIdLast );
-   if( stream->readFlag() )
-      mParentId = stream->readRangedS32( DataBlockObjectIdFirst, DataBlockObjectIdLast );
-   else
-      mParentId = 0;
-}
-
-//-----------------------------------------------------------------------------
-
-String SFXFMODEventGroup::getQualifiedName() const
-{
-   if( mParent )
-      return String::ToString( "%s/%s", mParent->getQualifiedName().c_str(), mName.c_str() );
-   else
-      return mName;
-}
-
-//-----------------------------------------------------------------------------
-
-bool SFXFMODEventGroup::isDataLoaded() const
-{
-   // Check whether we or any of our parents has triggered a load.
-   
-   for( const SFXFMODEventGroup* group = this; group != NULL; group = group->mParent )
-      if( group->mLoadCount > 0 )
-         return true;
-         
-   return false;
-}
-
-//-----------------------------------------------------------------------------
-
-bool SFXFMODEventGroup::loadData( bool samples, bool streams )
-{
-   if( !mHandle )
-      acquire();
-   
-   if( !mLoadCount )
-   {
-      FMOD_EVENT_RESOURCE resource;
-      if( samples && streams )
-         resource = FMOD_EVENT_RESOURCE_STREAMS_AND_SAMPLES;
-      else if( samples )
-         resource = FMOD_EVENT_RESOURCE_SAMPLES;
-      else if( streams )
-         resource = FMOD_EVENT_RESOURCE_STREAMS;
-      else
-         return true;
-         
-      FMOD_RESULT result = SFXFMODDevice::smFunc->FMOD_EventGroup_LoadEventData( mHandle, resource, FMOD_EVENT_DEFAULT );
-      if( result != FMOD_OK )
-      {
-         Con::errorf( "SFXFMODEventGroup::loadData - could not load data: %s", FMODResultToString( result ).c_str() );
-         return false;
-      }
-      
-      SFXFMODDevice::instance()->updateMemUsageStats();
-      Con::printf( "SFXFMODProject - %s: Loaded data for group '%s'", mProject->getName(), getQualifiedName().c_str() );
-   }
-   
-   mLoadCount ++;
-   return true;
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEventGroup::freeData( bool force )
-{
-   bool isLoaded = ( mLoadCount > 0 );
-   
-   if( !isLoaded )
-      isLoaded = ( mParent ? mParent->isDataLoaded() : false );
-   else
-   {
-      if( force )
-         mLoadCount = 0;
-      else
-         -- mLoadCount;
-   }
-      
-   if( !mLoadCount && isLoaded )
-   {
-      FMOD_RESULT result = SFXFMODDevice::smFunc->FMOD_EventGroup_FreeEventData( mHandle, ( FMOD_EVENT* ) NULL, false );
-      if( result != FMOD_OK )
-         Con::errorf( "SFXFMODEventGroup - failed freeing event data: %s", FMODResultToString( result ).c_str() );
-         
-      SFXFMODDevice::instance()->updateMemUsageStats();
-      Con::printf( "SFXFMODProject - %s: Cleared data for group '%s'", mProject->getName(), getQualifiedName().c_str() );
-   }
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEventGroup::acquire( bool recursive )
-{
-   // Make sure the project is acquired.
-   
-   mProject->acquire();
-   
-   // Acquire the group.
-   
-   if( !mHandle )
-   {
-      if( mParent )
-      {
-         mParent->acquire();
-         SFXFMODDevice::smFunc->FMOD_EventGroup_GetGroup( mParent->mHandle, mName, true, &mHandle );
-      }
-      else
-      {
-         mProject->acquire();
-         SFXFMODDevice::smFunc->FMOD_EventProject_GetGroup( mProject->mHandle, mName, true, &mHandle );
-      }
-   }
-   
-   // Acquite events and subgroups.
-   
-   if( recursive )
-   {
-      for( SFXFMODEvent* event = mEvents; event != NULL; event = event->mSibling )
-         event->acquire();
-         
-      for( SFXFMODEventGroup* group = mChildren; group != NULL; group = group->mSibling )
-         group->acquire( true );
-   }
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEventGroup::release()
-{
-   if( !mHandle )
-      return;
-      
-   // Free the event data if we still have it loaded.
-      
-   if( isDataLoaded() )
-      freeData( true );
-      
-   // Release events.
-   
-   for( SFXFMODEvent* event = mEvents; event != NULL; event = event->mSibling )
-      event->release();
-   
-   // Release children.
-   
-   for( SFXFMODEventGroup* child = mChildren; child != NULL; child = child->mSibling )
-      child->release();
-   
-   // Release our handle.
-   
-   freeData();
-   mHandle = NULL;
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEventGroup::_load()
-{
-   // Make sure we have the group open.
-   
-   if( !mHandle )
-      acquire();
-      
-   // Fetch info.
-   
-   int numEvents;
-   int numGroups;
-
-   SFXFMODDevice::smFunc->FMOD_EventGroup_GetNumEvents( mHandle, &numEvents );
-   SFXFMODDevice::smFunc->FMOD_EventGroup_GetNumGroups( mHandle, &numGroups );
-   
-   // Load events.
-   
-   for( U32 i = 0; i < numEvents; ++ i )
-   {
-      FMOD_EVENT* handle;
-      if( SFXFMODDevice::smFunc->FMOD_EventGroup_GetEventByIndex( mHandle, i, FMOD_EVENT_INFOONLY, &handle ) == FMOD_OK )
-      {
-         SFXFMODEvent* event = new SFXFMODEvent( this, handle );
-         if( !isClientOnly() )
-            event->assignId();
-            
-         event->registerObject( String::ToString( "%s_%s", getName(), FMODEventPathToTorqueName( event->getEventName() ).c_str() ) );
-         if( isClientOnly() )
-            Sim::getRootGroup()->addObject( event );
-      }
-   }
-   
-   // Load subgroups.
-   
-   for( U32 i = 0; i < numGroups; ++ i )
-   {
-      FMOD_EVENTGROUP* handle;
-      if( SFXFMODDevice::smFunc->FMOD_EventGroup_GetGroupByIndex( mHandle, i, true, &handle ) == FMOD_OK )
-      {
-         SFXFMODEventGroup* group = new SFXFMODEventGroup( mProject, handle, this );
-         if( !isClientOnly() )
-            group->assignId();
-            
-         group->registerObject( String::ToString( "%s_%s", getName(), FMODEventPathToTorqueName( group->getGroupName() ).c_str() ) );
-         if( isClientOnly() )
-            Sim::getRootGroup()->addObject( group );
-         
-         group->_load();
-      }
-   }
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEventGroup::_addEvent( SFXFMODEvent* event )
-{
-   event->mSibling = mEvents;
-   mEvents = event;
-   mNumEvents ++;
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEventGroup::_removeEvent( SFXFMODEvent* event )
-{
-   if( mEvents == event )
-   {
-      mEvents = event->mSibling;
-      event->mSibling = NULL;
-      mNumEvents --;
-   }
-   else
-   {
-      SFXFMODEvent* p = mEvents;
-      while( p != NULL && p->mSibling != event )
-         p = p->mSibling;
-      
-      if( p )
-      {
-         p->mSibling = event->mSibling;
-         event->mSibling = NULL;
-         mNumEvents --;
-      }
-   }
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEventGroup::_addGroup( SFXFMODEventGroup* group )
-{
-   group->mSibling = mChildren;
-   mChildren = group;
-   mNumGroups ++;
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEventGroup::_removeGroup( SFXFMODEventGroup* group )
-{
-   if( mChildren == group )
-   {
-      mChildren = group->mSibling;
-      group->mSibling = NULL;
-      mNumGroups --;
-   }
-   else
-   {
-      SFXFMODEventGroup* p = mChildren;
-      while( p != NULL && p->mSibling != group )
-         p = p->mSibling;
-      
-      if( p )
-      {
-         p->mSibling = group->mSibling;
-         group->mSibling = NULL;
-         mNumGroups --;
-      }
-   }
-}
-
-//=============================================================================
-//    Console Methods.
-//=============================================================================
-// MARK: ---- Console Methods ----
-
-//-----------------------------------------------------------------------------
-
-DefineEngineMethod( SFXFMODEventGroup, isDataLoaded, bool, (),,
-   "Test whether the resource data for this group has been loaded.\n\n"
-   "@return True if the resource data for this group is currently loaded.\n" )
-{
-   return object->isDataLoaded();
-}
-
-//-----------------------------------------------------------------------------
-
-DefineEngineMethod( SFXFMODEventGroup, loadData, bool, ( bool loadStreams, bool loadSamples ), ( true, true ),
-   "Load the resource data for this group, if it has not already been loaded (either directly "
-   "or indirectly through a parent group).\n"
-   "This method works recursively and thus data for direct and indirect child groups to this group will be "
-   "loaded as well.\n\n"
-   "@param loadStreams Whether to open streams.\n"
-   "@param loadSamples Whether to load sample banks.\n"
-   "@return True if the data has been successfully loaded; false otherwise.\n\n"
-   "@see SFXFMODProject_resources" )
-{
-   return object->loadData( loadSamples, loadStreams );
-}
-
-//-----------------------------------------------------------------------------
-
-DefineEngineMethod( SFXFMODEventGroup, freeData, void, (),,
-   "Release the resource data for this group and its subgroups.\n\n"
-   "@see SFXFMODProject_resources" )
-{
-   object->freeData();
-}
diff --git a/Engine/source/sfx/fmod/sfxFMODEventGroup.h b/Engine/source/sfx/fmod/sfxFMODEventGroup.h
deleted file mode 100644
index 12140c2bf..000000000
--- a/Engine/source/sfx/fmod/sfxFMODEventGroup.h
+++ /dev/null
@@ -1,159 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#ifndef _SFXFMODEVENTGROUP_H_
-#define _SFXFMODEVENTGROUP_H_
-
-#ifndef _SIMDATABLOCK_H_
-   #include "console/simDatablock.h"
-#endif
-#ifndef _TVECTOR_H_
-   #include "core/util/tVector.h"
-#endif
-#ifndef _CONSOLETYPES_H_
-   #include "console/consoleTypes.h"
-#endif
-
-#include "fmod_event.h"
-
-
-class SFXFMODProject;
-class SFXFMODEvent;
-
-
-///
-class SFXFMODEventGroup : public SimDataBlock
-{
-   public:
-   
-      typedef SimDataBlock Parent;
-      friend class SFXFMODProject;
-      friend class SFXFMODEvent; // mHandle
-      friend class SFXFMODEventSource; // mHandle
-      
-   protected:
-   
-      ///
-      String mName;
-      
-      ///
-      U32 mNumEvents;
-      
-      ///
-      U32 mNumGroups;
-      
-      ///
-      SFXFMODProject* mProject;
-
-      ///
-      SFXFMODEventGroup* mParent;
-
-      ///
-      SFXFMODEventGroup* mChildren;
-      
-      ///
-      SFXFMODEventGroup* mSibling;
-   
-      ///
-      SFXFMODEvent* mEvents;
-      
-      ///
-      FMOD_EVENTGROUP* mHandle;
-      
-      ///
-      U32 mLoadCount;
-      
-      /// Project ID for client net sync.
-      S32 mParentId;
-      
-      /// Project ID for client net sync.
-      S32 mProjectId;
-                  
-      ///
-      void _load();
-      
-      ///
-      void _addEvent( SFXFMODEvent* event );
-      
-      ///
-      void _addGroup( SFXFMODEventGroup* group );
-      
-      ///
-      void _removeEvent( SFXFMODEvent* event );
-      
-      ///
-      void _removeGroup( SFXFMODEventGroup* group );
-      
-   public:
-   
-      ///
-      SFXFMODEventGroup();
-   
-      ///
-      SFXFMODEventGroup( SFXFMODProject* project, const String& name, SFXFMODEventGroup* parent = NULL );
-
-      ///
-      SFXFMODEventGroup( SFXFMODProject* project, FMOD_EVENTGROUP* handle, SFXFMODEventGroup* parent = NULL );
-      
-      ~SFXFMODEventGroup();
-      
-      /// Create the event group object on the FMOD device.
-      void acquire( bool recursive = false );
-      
-      /// Release the event group object on the FMOD device.
-      void release();
-      
-      ///
-      const String& getGroupName() const { return mName; }
-
-      ///
-      String getQualifiedName() const;
-      
-      ///
-      SFXFMODProject* getProject() const { return mProject; }
-      
-      /// Return true if the event data for this group has been loaded.
-      bool isDataLoaded() const;
-
-      /// Load the event data for this group.
-      ///
-      /// @note Loading is reference-counted.
-      bool loadData( bool samples = true, bool streams = true );
-      
-      ///
-      void freeData( bool force = false );
-      
-      // SimDataBlock.
-      virtual bool onAdd();
-      virtual void onRemove();
-      virtual bool preload( bool server, String& errorStr );
-      virtual void packData( BitStream* stream );
-      virtual void unpackData( BitStream* stream );
-      
-      static void initPersistFields();
-      
-      DECLARE_CONOBJECT( SFXFMODEventGroup );
-      DECLARE_CATEGORY( "SFX FMOD" );
-      DECLARE_DESCRIPTION( "An event group in an FMOD Designer project." );
-};
-
-#endif // !_SFXFMODEVENTGROUP_H_
diff --git a/Engine/source/sfx/fmod/sfxFMODEventSource.cpp b/Engine/source/sfx/fmod/sfxFMODEventSource.cpp
deleted file mode 100644
index 747bcd56f..000000000
--- a/Engine/source/sfx/fmod/sfxFMODEventSource.cpp
+++ /dev/null
@@ -1,337 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#include "platform/platform.h"
-#include "sfx/fmod/sfxFMODEventSource.h"
-#include "sfx/fmod/sfxFMODEvent.h"
-#include "sfx/fmod/sfxFMODEventGroup.h"
-#include "sfx/fmod/sfxFMODDevice.h"
-#include "sfx/sfxDescription.h"
-
-
-IMPLEMENT_CONOBJECT( SFXFMODEventSource );
-
-ConsoleDocClass( SFXFMODEventSource,
-   "@brief A sound source controller playing an %FMOD Designer event (SFXFMODEvent).\n\n"
-   
-   "%FMOD event sources are internally created by the sound system to play events from imported %FMOD Designer projects.\n\n"
-   
-   "@note This class cannot be instantiated directly by the user.  Instead, instances of SFXFMODEventSource will be "
-      "implicitly created by the sound system when playing an SFXFMODEvent.\n\n"
-   
-   "@ingroup SFXFMOD\n"
-);
-
-
-//-----------------------------------------------------------------------------
-
-SFXFMODEventSource::SFXFMODEventSource()
-   : mHandle( NULL )
-{
-   SFXFMODDevice::instance()->smStatNumEventSources ++;
-}
-
-//-----------------------------------------------------------------------------
-
-SFXFMODEventSource::SFXFMODEventSource( SFXFMODEvent* event )
-   : Parent( event ),
-     mHandle( NULL )
-{
-   SFXFMODDevice::instance()->smStatNumEventSources ++;
-
-   // Make sure the group has its data loaded.
-      
-   SFXFMODEventGroup* group = event->getEventGroup();
-   if( !group->loadData() )
-      return;
-      
-   // Create an event instance.
-
-   if( SFXFMODDevice::smFunc->FMOD_EventGroup_GetEvent(
-         event->getEventGroup()->mHandle,
-         event->getEventName(),
-         FMOD_EVENT_DEFAULT,
-         &mHandle ) != FMOD_OK )
-   {
-      Con::errorf( "SFXFMODEventSource::SFXFMODEventSource - failed to open event '%s'", event->getQualifiedName().c_str() );
-      mHandle = NULL;
-   }
-}
-
-//-----------------------------------------------------------------------------
-
-SFXFMODEventSource::~SFXFMODEventSource()
-{
-   SFXFMODDevice::instance()->smStatNumEventSources --;
-
-   if( mHandle )
-      SFXFMODDevice::smFunc->FMOD_Event_Release( mHandle, true, true );
-      
-   if( getEvent() )
-      getEvent()->getEventGroup()->freeData();
-}
-
-//-----------------------------------------------------------------------------
-
-SFXFMODEventSource* SFXFMODEventSource::create( SFXFMODEvent* event )
-{
-   AssertFatal( event != NULL, "SFXFMODEventSource::create - got a NULL event!" );
-   
-   // Create the source.
-   
-   SFXFMODEventSource* source = new SFXFMODEventSource( event );
-   if( source->mHandle )
-      source->registerObject();
-   else
-   {
-      delete source;
-      source = NULL;
-   }
-
-   return source;
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEventSource::play( F32 fadeInTime )
-{
-   if( getStatus() == SFXStatusPlaying )
-      return;
-      
-   if( isPaused() )
-      SFXFMODDevice::smFunc->FMOD_Event_SetPaused( mHandle, false );
-   else
-   {
-      AssertFatal( getEvent()->getEventGroup()->isDataLoaded(), "SFXFMODEventSource::play() - event data for group not loaded" );
-                     
-      if( fadeInTime != -1.f )
-      {
-         U32 fade = U32( fadeInTime * 1000.f );
-         SFXFMODDevice::smFunc->FMOD_Event_SetPropertyByIndex(
-            mHandle, FMOD_EVENTPROPERTY_FADEIN,
-            &fade, true
-         );
-      }
-      
-      FMOD_RESULT result = SFXFMODDevice::smFunc->FMOD_Event_Start( mHandle );
-      if( result != FMOD_OK )
-      {
-         Con::errorf( "SFXFMODEventSoure::play() - failed to start event: %s", FMODResultToString( result ).c_str() );
-         return;
-      }
-   }
-   
-   mPlayTimer.start();
-   _setStatus( SFXStatusPlaying );
-   
-   _play();
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEventSource::stop( F32 fadeOutTime )
-{
-   if( getStatus() == SFXStatusStopped )
-      return;
-      
-   AssertFatal( mHandle, "SFXFMODEvent::stop() - event not acquired" );
-   
-   bool immediate = ( fadeOutTime == 0.f );
-   
-   FMOD_RESULT result = SFXFMODDevice::smFunc->FMOD_Event_Stop( mHandle, immediate );
-   if( result != FMOD_OK )
-      Con::errorf( "SFXFMODEventSource::stop() - failed to stop event: %s", FMODResultToString( result ).c_str() );
-
-   mPlayTimer.stop();
-   _setStatus( SFXStatusStopped );
-   
-   // Reset fade-in to default in case it got overwritten
-   // in play().
-
-   U32 fade = U32( mFadeInTime * 1000.f );
-   SFXFMODDevice::smFunc->FMOD_Event_SetPropertyByIndex(
-      mHandle, FMOD_EVENTPROPERTY_FADEIN,
-      &fade, true
-   );
-   
-   _stop();
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEventSource::pause( F32 fadeOutTime )
-{
-   if( getStatus() != SFXStatusPlaying )
-      return;
-
-   SFXFMODDevice::smFunc->FMOD_Event_SetPaused( mHandle, true );
-
-   mPlayTimer.pause();
-   _setStatus( SFXStatusPaused );
-   
-   _pause();
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEventSource::setTransform( const MatrixF& transform )
-{
-   Parent::setTransform( transform );
-   _update3DAttributes();
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEventSource::setVelocity( const VectorF& velocity )
-{
-   Parent::setVelocity( velocity );
-   _update3DAttributes();
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEventSource::_update3DAttributes()
-{
-   FMOD_VECTOR position;
-   FMOD_VECTOR velocity;
-   FMOD_VECTOR orientation;
-   
-   Point3F direction;
-   getTransform().getColumn( 1, &direction );
-   
-   TorqueVectorToFMODVector( getTransform().getPosition(), position );
-   TorqueVectorToFMODVector( getVelocity(), velocity );
-   TorqueVectorToFMODVector( direction, orientation );
-   
-   SFXFMODDevice::smFunc->FMOD_Event_Set3DAttributes( mHandle, &position, &velocity, &orientation );
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEventSource::_updateStatus()
-{
-   if( mStatus == SFXStatusPlaying )
-   {
-      if( !getEvent() )
-         _setStatus( SFXStatusStopped );
-      else
-      {
-         FMOD_EVENT_STATE state;
-         SFXFMODDevice::smFunc->FMOD_Event_GetState( mHandle, &state );
-         
-         if( !( state & FMOD_EVENT_STATE_PLAYING ) )
-            _setStatus( SFXStatusStopped );
-      }
-   }
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEventSource::_updateVolume( const MatrixF& listener )
-{
-   F32 oldPreAttenuatedVolume = mPreAttenuatedVolume;
-   Parent::_updateVolume( listener );
-   
-   if( oldPreAttenuatedVolume != mPreAttenuatedVolume )
-      SFXFMODDevice::smFunc->FMOD_Event_SetVolume( mHandle, mPreAttenuatedVolume );
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEventSource::_updatePitch()
-{
-   F32 oldEffectivePitch = mEffectivePitch;
-   Parent::_updatePitch();
-   
-   if( mEffectivePitch != oldEffectivePitch )
-      SFXFMODDevice::smFunc->FMOD_Event_SetPitch( mHandle, mEffectivePitch - 1.0f, FMOD_EVENT_PITCHUNITS_RAW );
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEventSource::_updatePriority()
-{
-   //TODO
-   Parent::_updatePriority();
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEventSource::_setMinMaxDistance( F32 min, F32 max )
-{
-   Parent::_setMinMaxDistance( min, max );
-   _update3DAttributes();
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEventSource::_setFadeTimes( F32 fadeInTime, F32 fadeOutTime )
-{
-   Parent::_setFadeTimes( fadeInTime, fadeOutTime );
-
-   U32 fadeIn = U32( mFadeInTime * 1000.f );
-   SFXFMODDevice::smFunc->FMOD_Event_SetPropertyByIndex(
-      mHandle, FMOD_EVENTPROPERTY_FADEIN,
-      &fadeIn, true
-   );
-
-   U32 fadeOut = U32( mFadeOutTime * 1000.f );
-   SFXFMODDevice::smFunc->FMOD_Event_SetPropertyByIndex(
-      mHandle, FMOD_EVENTPROPERTY_FADEOUT,
-      &fadeOut, true
-   );
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEventSource::_setCone( F32 innerAngle, F32 outerAngle, F32 outerVolume )
-{
-   Parent::_setCone( innerAngle, outerAngle, outerVolume );
-   _update3DAttributes();
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODEventSource::_onParameterEvent( SFXParameter* parameter, SFXParameterEvent event )
-{
-   Parent::_onParameterEvent( parameter, event );
-   
-   // If it's a value-change on a custom parameter,
-   // pass it along to FMOD.
-   
-   if(    getEvent()
-       && event == SFXParameterEvent_ValueChanged
-       && parameter->getChannel() == SFXChannelUser0 )
-   {
-      const char* name = parameter->getInternalName();
-      
-      FMOD_EVENTPARAMETER* fmodParameter;
-      if( SFXFMODDevice::smFunc->FMOD_Event_GetParameter( mHandle, name, &fmodParameter ) != FMOD_OK )
-      {
-         Con::errorf( "SFXFMODEventSource::_onParameterEvent - could not access parameter '%s' of event '%s'",
-            name, getEvent()->getQualifiedName().c_str() );
-         return;
-      }
-      
-      SFXFMODDevice::smFunc->FMOD_EventParameter_SetValue( fmodParameter, parameter->getValue() );
-   }
-}
diff --git a/Engine/source/sfx/fmod/sfxFMODEventSource.h b/Engine/source/sfx/fmod/sfxFMODEventSource.h
deleted file mode 100644
index 0e3493592..000000000
--- a/Engine/source/sfx/fmod/sfxFMODEventSource.h
+++ /dev/null
@@ -1,101 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#ifndef _SFXFMODEVENTSOURCE_H_
-#define _SFXFMODEVENTSOURCE_H_
-
-#ifndef _SFXSOURCE_H_
-   #include "sfx/sfxSource.h"
-#endif
-
-#include "fmod_event.h"
-
-
-class SFXFMODEvent;
-
-
-/// An SFXSource that controls the playback of an SFXFMODEvent.
-///
-/// SFXFMODEvents can be played back directly through their console methods.
-/// However, this class integrates them with the remaining SFX system and makes
-/// events usable wherever SFX tracks are usable though with the important
-/// distinction that there can only ever be a single source for a given event.
-///
-/// Note that calling playback methods directly on an event will cause a source
-/// for the event to be created if there is not already one.
-///
-/// Be aware that using fade-outs in events in combination with play-once sources
-/// does not work well at the moment.
-///
-class SFXFMODEventSource : public SFXSource
-{
-   public:
-   
-      typedef SFXSource Parent;
-      
-   protected:
-   
-      /// The event instance handle for this source.
-      FMOD_EVENT* mHandle;
-   
-      ///
-      SFXFMODEventSource( SFXFMODEvent* event );
-            
-      /// Update 3D position, velocity, and orientation from current source transform.
-      void _update3DAttributes();
-      
-      // SFXSource.
-      virtual void _updateStatus();
-      virtual void _updateVolume( const MatrixF& listener );
-      virtual void _updatePitch();
-      virtual void _updatePriority();
-      virtual void _onParameterEvent( SFXParameter* parameter, SFXParameterEvent event );
-      virtual void _setMinMaxDistance( F32 min, F32 max );
-      virtual void _setCone( F32 innerAngle, F32 outerAngle, F32 outerVolume );
-      virtual void _setFadeTimes( F32 fadeInTime, F32 fadeOutTime );
-   
-   public:
-   
-      ///
-      SFXFMODEventSource();
-      
-      virtual ~SFXFMODEventSource();
-   
-      /// Return the FMOD event object that is being played back by this source.
-      SFXFMODEvent* getEvent() const { return ( SFXFMODEvent* ) mTrack.getPointer(); }
-
-      /// Create a new source for the given event.
-      static SFXFMODEventSource* create( SFXFMODEvent* event );
-      
-      // SFXSource.
-      virtual void play( F32 fadeInTime = -1.f ); // fadeInTime ignored when resuming from paused
-      virtual void stop( F32 fadeOutTime = -1.f ); // fadeOutTime!=0 ignored
-      virtual void pause( F32 fadeOutTime = -1.f ); // fadeOutTime currently ignored
-      virtual void setTransform( const MatrixF& transform );
-      virtual void setVelocity( const VectorF& velocity );
-      
-      DECLARE_CONOBJECT( SFXFMODEventSource );
-      DECLARE_CATEGORY( "SFX FMOD" );
-      DECLARE_DESCRIPTION( "An SFX source controlling the playback of an FMOD Designer event." );
-};
-
-#endif // !_SFXFMODEVENTSOURCE_H_
diff --git a/Engine/source/sfx/fmod/sfxFMODPlugin.cpp b/Engine/source/sfx/fmod/sfxFMODPlugin.cpp
deleted file mode 100644
index 9db0af7ff..000000000
--- a/Engine/source/sfx/fmod/sfxFMODPlugin.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#include "sfx/fmod/sfxFMODPlugin.h"
-#include "sfx/fmod/sfxFMODEvent.h"
-#include "sfx/fmod/sfxFMODEventSource.h"
-
-
-//-----------------------------------------------------------------------------
-
-SFXSource* SFXFMODPlugin::createSource( SFXTrack* track )
-{
-   SFXFMODEvent* event = dynamic_cast< SFXFMODEvent* >( track );
-   if( !event )
-      return NULL;
-         
-   return SFXFMODEventSource::create( event );
-}
diff --git a/Engine/source/sfx/fmod/sfxFMODPlugin.h b/Engine/source/sfx/fmod/sfxFMODPlugin.h
deleted file mode 100644
index 488cde742..000000000
--- a/Engine/source/sfx/fmod/sfxFMODPlugin.h
+++ /dev/null
@@ -1,48 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#ifndef _SFXFMODPLUGIN_H_
-#define _SFXFMODPLUGIN_H_
-
-#ifndef _SFXSYSTEM_H_
-   #include "sfx/sfxSystem.h"
-#endif
-
-
-/// SFXSystem plugin that adds the capability to create SFXSources for
-/// Designer SFXFMODEvents.
-///
-/// The plugin will only be installed if an FMOD device has been created.
-/// While SFXFMODEvents may be constructed without an FMOD device, trying
-/// to play such an event then will result in an error.
-///
-class SFXFMODPlugin : public SFXSystemPlugin
-{
-   public:
-   
-      typedef SFXSystemPlugin Parent;
-      
-      ///
-      virtual SFXSource* createSource( SFXTrack* track );
-};
-
-#endif // !_SFXFMODPLUGIN_H_
diff --git a/Engine/source/sfx/fmod/sfxFMODProject.cpp b/Engine/source/sfx/fmod/sfxFMODProject.cpp
deleted file mode 100644
index 1f270492c..000000000
--- a/Engine/source/sfx/fmod/sfxFMODProject.cpp
+++ /dev/null
@@ -1,493 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#include "sfx/fmod/sfxFMODProject.h"
-#include "sfx/fmod/sfxFMODDevice.h"
-#include "sfx/fmod/sfxFMODEvent.h"
-#include "sfx/fmod/sfxFMODEventGroup.h"
-#include "sfx/sfxDescription.h"
-#include "core/stringTable.h"
-#include "core/volume.h"
-#include "core/util/path.h"
-#include "core/stream/fileStream.h"
-#include "core/stream/bitStream.h"
-#include "core/util/safeDelete.h"
-
-
-IMPLEMENT_CO_DATABLOCK_V1( SFXFMODProject );
-
-
-ConsoleDocClass( SFXFMODProject,
-   "@brief An FMOD Designer project loaded into Torque.\n\n"
-   
-   "@section SFXFMODProject_resources Resource Loading\n\n"
-   
-   "@ingroup SFXFMOD\n"
-   "@ingroup Datablocks"
-);
-
-
-//-----------------------------------------------------------------------------
-
-SFXFMODProject::SFXFMODProject()
-   : mHandle( NULL ),
-     mRootGroups( NULL )
-{
-   VECTOR_SET_ASSOCIATION( mGroups );
-   VECTOR_SET_ASSOCIATION( mEvents );
-   
-   SFX->getEventSignal().notify( this, &SFXFMODProject::_onSystemEvent );
-}
-
-//-----------------------------------------------------------------------------
-
-SFXFMODProject::~SFXFMODProject()
-{
-   AssertFatal( mGroups.empty(), "SFXFMODProject::~SFXFMODProject - project still has groups attached" );
-   AssertFatal( mEvents.empty(), "SFXFMODProject::~SFXFMODProject - project still has events attached" );
-   
-   if( SFX )
-      SFX->getEventSignal().remove( this, &SFXFMODProject::_onSystemEvent );
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODProject::initPersistFields()
-{
-   addGroup( "FMOD" );
-   
-      addField( "fileName", TypeStringFilename, Offset( mFileName, SFXFMODProject ), "The compiled .fev file from FMOD Designer." );
-      addField( "mediaPath", TypeStringFilename, Offset( mMediaPath, SFXFMODProject ), "Path to the media files; if unset, defaults to project directory." );
-   
-   endGroup( "FMOD" );
-   
-   Parent::initPersistFields();
-}
-
-//-----------------------------------------------------------------------------
-
-bool SFXFMODProject::onAdd()
-{
-   if( !Parent::onAdd() )
-      return false;
-      
-   // If this is a non-networked datablock, load the
-   // project data now.
-      
-   if( isClientOnly() && !_load() )
-      return false;
-      
-   return true;
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODProject::onRemove()
-{
-   Parent::onRemove();
-   
-   _clear();
-}
-
-//-----------------------------------------------------------------------------
-
-bool SFXFMODProject::preload( bool server, String& errorStr )
-{
-   if( !Parent::preload( server, errorStr ) )
-      return false;
-      
-   if( server )
-   {
-      if( mFileName.isEmpty() )
-      {
-         errorStr = String::ToString( "SFXFMODProject::preload - no filename set on %i (%s)",
-            getId(), getName() );
-         return false;
-      }
-      
-      if( mGroups.empty() || mEvents.empty() )
-         _load();
-         
-      release();
-   }
-   
-   return true;
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODProject::packData( BitStream* stream )
-{
-   Parent::packData( stream );
-   
-   stream->write( mFileName );
-   stream->write( mMediaPath );
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODProject::unpackData( BitStream* stream )
-{
-   Parent::unpackData( stream );
-   
-   stream->read( &mFileName );
-   stream->read( &mMediaPath );
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODProject::_onSystemEvent( SFXSystemEventType event )
-{
-   switch( event )
-   {
-      case SFXSystemEvent_DestroyDevice:
-      
-         // If the FMOD device is being destroyed,
-         // release all our data.
-         
-         if( SFXFMODDevice::instance() )
-            release();
-            
-         break;
-         
-      default:
-         break;
-   }
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODProject::_clear()
-{
-   release();
-   
-   for( U32 i = 0; i < mGroups.size(); ++ i )
-      if( !mGroups[ i ]->isRemoved() )
-         mGroups[ i ]->deleteObject();
-      
-   mGroups.clear();
-   mEvents.clear();
-   
-   mRootGroups = NULL;
-}
-
-//-----------------------------------------------------------------------------
-
-bool SFXFMODProject::_load()
-{
-   const Torque::Path eventScriptFileName = mFileName + ".cs";
-   const Torque::Path eventScriptFileNameDSO = eventScriptFileName + ".dso";
-   const bool eventScriptFileExists = Torque::FS::IsFile( eventScriptFileName );
-   const bool eventScriptFileDSOExists = Torque::FS::IsFile( eventScriptFileNameDSO );
-      
-   // Check if we need to (re-)generate the event script file.
-   
-   bool needToGenerateEventScriptFile = false;
-   if(    ( !eventScriptFileExists && !eventScriptFileDSOExists )
-       || ( Torque::FS::CompareModifiedTimes( mFileName, eventScriptFileName ) > 0
-            || Torque::FS::CompareModifiedTimes( mFileName, eventScriptFileNameDSO ) > 0 ) )
-      needToGenerateEventScriptFile = true;
-      
-   // If we need to generate, check if we can.
-   
-   SFXFMODDevice* fmodDevice = SFXFMODDevice::instance();
-   if( needToGenerateEventScriptFile && !fmodDevice )
-   {
-      // If we have neither FMOD nor the event scripts (even if outdated),
-      // there's nothing we can do.
-      
-      if( !eventScriptFileExists && !eventScriptFileDSOExists )
-      {
-         Con::errorf( "SFXFMODProject::_load() - event script for '%s' does not exist and device is not FMOD; load this project under FMOD first",
-            mFileName.c_str() );
-         return false;
-      }
-      
-      // Use the oudated versions.
-      
-      Con::warnf( "SFXMODProject::_load() - event script for '%s' is outdated and device is not FMOD; event data may not match .fev contents",
-         mFileName.c_str() );
-      needToGenerateEventScriptFile = false;
-   }
-   
-   // If we don't need to regenerate, try executing the event script now.
-   
-   if( !needToGenerateEventScriptFile )
-   {
-      if(    ( eventScriptFileExists || eventScriptFileDSOExists )
-          && !Con::evaluatef( "exec( \"%s\" );", eventScriptFileName.getFullPath().c_str() ) )
-      {
-         Con::errorf( "SFXFMODProject::_load() - failed to execute event script for '%s'%s",
-            mFileName.c_str(),
-            fmodDevice != NULL ? "; trying to regenerate" : ""
-         );
-         
-         if( !fmodDevice )
-            return false;
-            
-         needToGenerateEventScriptFile = true;
-      }
-      else
-         Con::printf( "SFXFMODProject - %s: Loaded event script", getName() );
-   }
-      
-   // If we need to generate the event script file,
-   // load the FMOD project now and then emit the file.
-   
-   if( needToGenerateEventScriptFile )
-   {
-      // Try to load the project.
-      
-      acquire();
-      
-      if( !mHandle )
-         return false;
-         
-      // Get the project info.
-
-      FMOD_EVENT_PROJECTINFO info;
-      
-      int numEvents;
-      int numGroups;
-      
-      SFXFMODDevice::smFunc->FMOD_EventProject_GetInfo( mHandle, &info );
-      SFXFMODDevice::smFunc->FMOD_EventProject_GetNumEvents( mHandle, &numEvents );
-      SFXFMODDevice::smFunc->FMOD_EventProject_GetNumGroups( mHandle, &numGroups );
-      
-      Con::printf( "SFXFMODProject - %s: Loading '%s' from '%s' (index: %i, events: %i, groups: %i)",
-         getName(), info.name, mFileName.c_str(), info.index, numEvents, numGroups );
-         
-      // Load the root groups.
-
-      for( U32 i = 0; i < numGroups; ++ i )
-      {
-         FMOD_EVENTGROUP* group;
-         if( SFXFMODDevice::smFunc->FMOD_EventProject_GetGroupByIndex( mHandle, i, true, &group ) == FMOD_OK )
-         {
-            SFXFMODEventGroup* object = new SFXFMODEventGroup( this, group );
-            
-            object->mSibling = mRootGroups;
-            mRootGroups = object;
-            
-            String qualifiedName = FMODEventPathToTorqueName( object->getQualifiedName() );
-            
-            if( !isClientOnly() )
-               object->assignId();
-               
-            object->registerObject( String::ToString( "%s_%s", getName(), qualifiedName.c_str() ) );
-            if( isClientOnly() )
-               Sim::getRootGroup()->addObject( object );
-            
-            object->_load();
-         }
-      }
-
-      // Create the event script file.
-      
-      FileStream stream;
-      if( !stream.open( eventScriptFileName.getFullPath(), Torque::FS::File::Write ) )
-      {
-         Con::errorf( "SFXFMODProject::_load - could not create event script file for '%s'", mFileName.c_str() );
-         return true; // Don't treat as failure.
-      }
-      
-      // Write a header.
-      
-      stream.writeText( String::ToString( "// This file has been auto-generated from '%s'\n", mFileName.c_str() ) );
-      stream.writeText( "// Do not edit this file manually and do not move it away from the Designer file.\n\n" );
-      
-      // Write the group objects.
-      
-      for( U32 i = 0; i < mGroups.size(); ++ i )
-      {
-         mGroups[ i ]->write( stream, 0 );
-         stream.writeText( "\n" );
-      }
-
-      // Write the event objects along with their
-      // SFXDescriptions.
-      
-      for( U32 i = 0; i < mEvents.size(); ++ i )
-      {
-         mEvents[ i ]->getDescription()->write( stream, 0 );
-         mEvents[ i ]->write( stream, 0 );
-         stream.writeText( "\n" );
-      }
-      
-      Con::printf( "SFXFMODProject - %s: Generated event script '%s'", getName(), eventScriptFileName.getFullPath().c_str() );
-   }
-
-   return true;
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODProject::acquire( bool recursive )
-{      
-   // Load the project file.
-   
-   if( !mHandle )
-   {
-      FMOD_RESULT result = SFXFMODDevice::smFunc->FMOD_EventSystem_Load(
-         SFXFMODDevice::smEventSystem,
-         mFileName.c_str(),
-         ( FMOD_EVENT_LOADINFO* ) 0,
-         &mHandle
-      );
-      
-      if( result != FMOD_OK )
-      {
-         Con::errorf( "SFXFMODProject::acquire - could not load '%s' (%s)",
-            mFileName.c_str(), FMODResultToString( result ).c_str() );
-         mHandle = NULL;
-         return;
-      }
-      
-      Con::printf( "SFXFMODProject - %s: Opened project '%s'", getName(), mFileName.c_str() );
-      
-      // Set the media path.
-      
-      String mediaPath;
-      if( !mMediaPath.isEmpty() )
-      {
-         mediaPath = mMediaPath;
-         if( mediaPath[ mediaPath.length() - 1 ] != '/' )
-            mediaPath += '/';
-      }
-      else
-      {
-         // Set to project directory.
-         
-         Torque::Path path = mFileName;
-         if( path.getRoot().isEmpty() )
-            path.setRoot( "game" );
-         path.setFileName( "" );
-         path.setExtension( "" );       
-         
-         mediaPath = path.getFullPath() + '/';
-      }
-
-      SFXFMODDevice::smFunc->FMOD_EventSystem_SetMediaPath(
-         SFXFMODDevice::smEventSystem,
-         mediaPath.c_str()
-      );
-   }
-   
-   // Acquire the root groups.
-   
-   if( recursive )
-      for( SFXFMODEventGroup* group = mRootGroups; group != NULL; group = group->mSibling )
-         group->acquire( true );
-         
-   SFXFMODDevice::instance()->updateMemUsageStats();
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODProject::release()
-{
-   if( !mHandle )
-      return;
-      
-   Con::printf( "SFXFMODProject - %s: Closing project '%s'",
-      getName(), mFileName.c_str() );
-   
-   // Clear media path.
-   
-   SFXFMODDevice::smFunc->FMOD_EventSystem_SetMediaPath(
-      SFXFMODDevice::smEventSystem, "" );
-      
-   // Release the root groups.
-   
-   for( SFXFMODEventGroup* group = mRootGroups; group != NULL; group = group->mSibling )
-      group->release();
- 
-   // Release the project.
-   
-   SFXFMODDevice::smFunc->FMOD_EventProject_Release( mHandle );
-   mHandle = NULL;
-
-   SFXFMODDevice::instance()->updateMemUsageStats();
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODProject::_addEvent( SFXFMODEvent* event )
-{
-   mEvents.push_back( event );
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODProject::_addGroup( SFXFMODEventGroup* group )
-{
-   mGroups.push_back( group );
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODProject::_removeEvent( SFXFMODEvent* event )
-{
-   for( U32 i = 0; i < mEvents.size(); ++ i )
-      if( mEvents[ i ] == event )
-      {
-         mEvents.erase( i );
-         break;
-      }
-}
-
-//-----------------------------------------------------------------------------
-
-void SFXFMODProject::_removeGroup( SFXFMODEventGroup* group )
-{
-   // Remove from group array.
-   
-   for( U32 i = 0; i < mGroups.size(); ++ i )
-      if( mGroups[ i ] == group )
-      {
-         mGroups.erase( i );
-         break;;
-      }
-      
-   // Unlink if it's a root group.
-   
-   if( !group->mParent )
-   {
-      if( group == mRootGroups )
-      {
-         mRootGroups = group->mSibling;
-         group->mSibling = NULL;
-      }
-      else
-      {
-         SFXFMODEventGroup* p = mRootGroups;
-         while( p && p->mSibling != group )
-            p = p->mSibling;
-            
-         if( p )
-         {
-            p->mSibling = group->mSibling;
-            group->mSibling = NULL;
-         }
-      }
-   }
-}
diff --git a/Engine/source/sfx/fmod/sfxFMODProject.h b/Engine/source/sfx/fmod/sfxFMODProject.h
deleted file mode 100644
index 0160e321b..000000000
--- a/Engine/source/sfx/fmod/sfxFMODProject.h
+++ /dev/null
@@ -1,162 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#ifndef _SFXFMODPROJECT_H_
-#define _SFXFMODPROJECT_H_
-
-#ifndef _SIMDATABLOCK_H_
-   #include "console/simDatablock.h"
-#endif
-#ifndef _CONSOLETYPES_H_
-   #include "console/consoleTypes.h"
-#endif
-#ifndef _TVECTOR_H_
-   #include "core/util/tVector.h"
-#endif
-#ifndef _SFXSYSTEM_H_
-   #include "sfx/sfxSystem.h"
-#endif
-
-#include "fmod_event.h"
-
-
-class SFXFMODEvent;
-class SFXFMODEventGroup;
-class SimGroup;
-
-
-
-/// Datablock that loads an FMOD Designer project.
-///
-/// All events in the project are automatically made available as SFXFMODEvent track
-/// datablock instances.  Each event object is automatically named by substituting
-/// the slashes in its fully qualified name with underscores and preprending the project
-/// name to this; event 'group1/group2/event' in the SFXFMODProject instance called
-/// 'project', for example, will be available as a TorqueScript object called
-/// 'project_group1_group2_event'.
-///
-/// This class also works in a client-server environment where the server is
-/// not running FMOD.  The event objects are cached in an auto-generated TorqueScript
-/// file alongside the .fev project file (x/y.fev -> x/y.fev.cs) which, when available
-/// and up-to-date, does not require FMOD for the server-side objects to correctly
-/// initialize.
-///
-/// To establish good loading behavior and for good memory management, it is necessary to
-/// wisely distribute events to groups and to manually pre-load groups.  The best solution
-/// probably is to have one group of common events that is loaded during game startup and
-/// then have one event group for each level in the game that is only loaded for the
-/// duration of its particular level.
-///
-/// SFXFMODProject will propagate it's networking model to all its contents.  This means
-/// that if the project is a non-networked datablock, then all event groups, events, and
-/// descriptions contained in the project will also be non-networked datablocks.
-///
-/// It usually makes the most sense to use non-networked ("client-only") datablocks as
-/// otherwise the FMOD datablocks will be purged on each mission load.
-///
-/// @note Only one project's music data can ever be loaded at any one time.
-///   Usually you wouldn't want more than a single SFXFMODProject instance in your game
-///   data.  Also, only a single media path can be set through the designer API so when
-///   loading multiple projects, note that each project will set the media path to its
-///   own directory.  For data loading to work, all project thus need to be placed in
-///   the same directory.
-///
-class SFXFMODProject : public SimDataBlock
-{
-   public:
-   
-      typedef SimDataBlock Parent;
-      friend class SFXFMODEventGroup; // _addGroup
-      friend class SFXFMODEvent; // _addEvent
-      
-   protected:
-   
-      ///
-      String mFileName;
-      
-      ///
-      String mMediaPath;
-      
-      ///
-      SFXFMODEventGroup* mRootGroups;
-      
-      /// A flat list of all the groups in this projet.
-      Vector< SFXFMODEventGroup* > mGroups;
-
-      /// A flat list of all the events in the project.
-      Vector< SFXFMODEvent* > mEvents;
-      
-      ///
-      FMOD_EVENTPROJECT* mHandle;
-      
-      ///
-      void _onSystemEvent( SFXSystemEventType event );
-      
-      ///
-      void _clear();
-      
-      ///
-      bool _load();
-      
-      ///
-      void _addEvent( SFXFMODEvent* event );
-      
-      ///
-      void _addGroup( SFXFMODEventGroup* group );
-      
-      ///
-      void _removeEvent( SFXFMODEvent* event );
-      
-      ///
-      void _removeGroup( SFXFMODEventGroup* group );
-   
-   public:
-   
-      ///
-      SFXFMODProject();
-      
-      virtual ~SFXFMODProject();
-            
-      ///
-      void acquire( bool recursive = false );
-      
-      ///
-      void release();
-      
-      ///
-      const String& getFileName() const { return mFileName; }
-
-      // SimDataBlock.
-      virtual bool onAdd();
-      virtual void onRemove();
-      virtual bool preload( bool server, String& errorStr );
-      virtual void packData( BitStream* stream );
-      virtual void unpackData( BitStream* stream );
-      
-      static void initPersistFields();
-   
-      DECLARE_CONOBJECT( SFXFMODProject );
-      DECLARE_CATEGORY( "SFX FMOD" );
-      DECLARE_DESCRIPTION( "An FMOD Designer project." );
-};
-
-#endif // !_SFXFMODPROJECT_H_
diff --git a/Engine/source/sfx/fmod/sfxFMODProvider.cpp b/Engine/source/sfx/fmod/sfxFMODProvider.cpp
deleted file mode 100644
index f38721c13..000000000
--- a/Engine/source/sfx/fmod/sfxFMODProvider.cpp
+++ /dev/null
@@ -1,398 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#include "sfx/sfxProvider.h"
-#include "sfx/fmod/sfxFMODDevice.h"
-#include "core/util/safeRelease.h"
-#include "console/console.h"
-#include "core/util/safeDelete.h"
-#include "core/module.h"
-#include "console/consoleTypes.h"
-
-
-class SFXFMODProvider : public SFXProvider
-{
-public:
-
-   SFXFMODProvider()
-      : SFXProvider( "FMOD" )
-   {
-      Con::addVariable( "$SFX::Device::fmodNumEventSources", TypeS32, &SFXFMODDevice::smStatNumEventSources,
-         "The current number of SFXFMODEventSource instances in the system.\n"
-         "This tells the number of sounds in the system that are currently playing FMOD Designer events.\n\n"
-         "@note Only relevant if an %FMOD sound device is used.\n\n"
-         "@ingroup SFXFMOD" );
-      Con::addVariable( "$SFX::Device::fmodCoreMem", TypeS32, &SFXFMODDevice::smStatMemUsageCore,
-         "Current number of bytes allocated by the core %FMOD sound system.\n\n"
-         "@note Only relevant if an %FMOD sound device is used.\n\n"
-         "@ingroup SFXFMOD" );
-      Con::addVariable( "$SFX::Device::fmodEventMem", TypeS32, &SFXFMODDevice::smStatMemUsageEvents,
-         "Current number of bytes allocated by the %FMOD Designer event system.\n\n"
-         "@note Only relevant if an %FMOD sound device is used and the FMOD event DLL is loaded.\n\n"
-         "@ingroup SFXFMOD" );
-         
-      Con::addVariable( "$pref::SFX::FMOD::disableSoftware", TypeBool, &SFXFMODDevice::smPrefDisableSoftware,
-         "Whether to disable the %FMOD software mixer to conserve memory.\n"
-         "All sounds not created with SFXDescription::useHardware or using DSP effects will fail to load.\n\n"
-         "@note Only applies when using an %FMOD sound device.\n\n"
-         "@ingroup SFXFMOD" );
-      Con::addVariable( "$pref::SFX::FMOD::useSoftwareHRTF", TypeBool, &SFXFMODDevice::smPrefUseSoftwareHRTF,
-         "Whether to enable HRTF in %FMOD's software mixer.\n"
-         "This will add a lowpass filter effect to the DSP effect chain of all sounds mixed in software.\n\n"
-         "@note Only applies when using an %FMOD sound device.\n\n"
-         "@ingroup SFXFMOD" );
-      Con::addVariable( "$pref::SFX::FMOD::enableProfile", TypeBool, &SFXFMODDevice::smPrefEnableProfile,
-         "Whether to enable support for %FMOD's profiler.\n\n"
-         "@note Only applies when using an %FMOD sound device.\n\n"
-         "@ref FMOD_profiler\n\n"
-         "@ingroup SFXFMOD" );
-      Con::addVariable( "$pref::SFX::FMOD::DSoundHRTF", TypeString, &SFXFMODDevice::smPrefDSoundHRTF,
-         "The type of HRTF to use for hardware-mixed 3D sounds when %FMOD is using DirectSound for sound output "
-         "and hardware-acceleration is not available.\n\n"
-         "Options are\n"
-         "- \"none\": simple stereo panning/doppler/attenuation\n"
-         "- \"light\": slightly higher quality than \"none\"\n"
-         "- \"full\": full quality 3D playback\n\n"
-         "@note Only applies when using an %FMOD sound device.\n\n"
-         "@ingroup SFXFMOD" );
-      Con::addVariable( "$pref::SFX::FMOD::pluginPath", TypeString, &SFXFMODDevice::smPrefPluginPath,
-         "%Path to additional %FMOD plugins.\n\n"
-         "@note Only applies when using an %FMOD sound device.\n\n"
-         "@ingroup SFXFMOD" );
-   }
-   virtual ~SFXFMODProvider();
-
-protected:
-   FModFNTable mFMod;
-
-   struct FModDeviceInfo : SFXDeviceInfo
-   {
-      FMOD_CAPS mCaps;
-      FMOD_SPEAKERMODE mSpeakerMode;
-   };
-
-   void init();
-   
-   bool _createSystem();
-
-public:
-
-   SFXDevice* createDevice( const String& deviceName, bool useHardware, S32 maxBuffers );
-
-};
-
-MODULE_BEGIN( FMOD )
-
-   MODULE_INIT_BEFORE( SFX )
-   MODULE_SHUTDOWN_AFTER( SFX )
-   
-   SFXFMODProvider* mProvider;
-      
-   MODULE_INIT
-   {
-      mProvider = new SFXFMODProvider;
-   }
-   
-   MODULE_SHUTDOWN
-   {
-      delete mProvider;
-   }
-   
-MODULE_END;
-
-
-//------------------------------------------------------------------------------
-// Helper
-
-bool fmodBindFunction( DLibrary *dll, void *&fnAddress, const char* name )
-{
-   if( !dll )
-      return false;
-      
-   fnAddress = dll->bind( name );
-
-   if (!fnAddress)
-      Con::warnf( "FMOD Loader: DLL bind failed for %s", name );
-
-   return fnAddress != 0;
-}
-
-//------------------------------------------------------------------------------
-
-void SFXFMODProvider::init()
-{
-#ifdef TORQUE_FMOD_STATIC
-
-   // FMOD statically linked.
-   
-   mFMod.isLoaded = true;
-   #define FMOD_FUNCTION(fn_name, fn_args) \
-      (*(void**)&mFMod.fn_name.fn) = &fn_name;
-   
-   #ifndef TORQUE_FMOD_NO_EVENTS
-   mFMod.eventIsLoaded = true;
-      #define FMOD_EVENT_FUNCTION(fn_name, fn_args) \
-         (*(void**)&mFMod.fn_name.fn) = &fn_name;
-   #else
-      #define FMOD_EVENT_FUNCTION( fn_name, fn_args )
-   #endif
-
-   #include FMOD_FN_FILE
-   
-   #undef FMOD_FUNCTION
-   #undef FMOD_EVENT_FUNCTION
-   
-#else
-
-   // FMOD dynamically linked.
-   
-   const char* dllName;
-   const char* pDllName; // plugin-based DLL
-   const char* eventDllName;
-   
-#ifdef _WIN64
-   dllName = "fmodex64.dll";
-   pDllName = "fmodexp64.dll";
-   eventDllName = "fmod_event64.dll";
-#elif defined(TORQUE_OS_WIN)
-   dllName = "fmodex.dll";
-   pDllName = "fmodexp.dll";
-   eventDllName = "fmod_event.dll";
-#elif defined( TORQUE_OS_MAC )
-   dllName = "libfmodex.dylib";
-   pDllName = "libfmodexp.dylib";
-   eventDllName = "libfmodevent.dylib";
-#else
-#  warning Need to set FMOD DLL filename for platform.
-   return;
-#endif
-
-   // Grab the functions we'll want from the fmod DLL.
-   mFMod.dllRef = OsLoadLibrary( dllName );
-
-   // Try the plugin-based version.
-   if( !mFMod.dllRef )
-      mFMod.dllRef = OsLoadLibrary( pDllName );
-
-   if(!mFMod.dllRef)
-   {
-      Con::warnf( "SFXFMODProvider - Could not locate '%s' or '%s' - FMOD  not available.", dllName, pDllName );
-      return;
-   }
-   
-   mFMod.eventDllRef = OsLoadLibrary( eventDllName );
-   if(!mFMod.eventDllRef)
-      Con::warnf( "SFXFMODProvider - Could not locate %s - FMOD Designer integration not available.", eventDllName );
-
-   mFMod.isLoaded = true;
-   mFMod.eventIsLoaded = true;
-
-   #define FMOD_FUNCTION(fn_name, fn_args) \
-      mFMod.isLoaded &= fmodBindFunction(mFMod.dllRef, *(void**)&mFMod.fn_name.fn, #fn_name);
-   #define FMOD_EVENT_FUNCTION(fn_name, fn_args) \
-      mFMod.eventIsLoaded &= fmodBindFunction(mFMod.eventDllRef, *(void**)&mFMod.fn_name.fn, #fn_name);
-            
-   #include FMOD_FN_FILE
-   
-   #undef FMOD_FUNCTION
-   #undef FMOD_EVENT_FUNCTION
-
-   if(mFMod.isLoaded == false)
-   {
-      Con::warnf("SFXFMODProvider - Could not load %s - FMOD not available.", dllName);
-      return;
-   }
-   if( !mFMod.eventIsLoaded && mFMod.eventDllRef )
-      Con::warnf("SFXFMODProvider - Could not load %s - FMOD Designer integration not available.", eventDllName);
-
-#endif
-
-   FMOD_RESULT res;
-
-   // Create the FMOD system object.
-      
-   if( !_createSystem() )
-      return;
-      
-   // Check that the Ex API version is OK.
-   
-   unsigned int version;
-   res = mFMod.FMOD_System_GetVersion(SFXFMODDevice::smSystem, &version);
-   FModAssert(res, "SFXFMODProvider - Failed to get FMOD version!");
-
-   Con::printf( "SFXFMODProvider - FMOD Ex API version: %x.%x.%x",
-      ( version & 0xffff0000 ) >> 16,
-      ( version & 0x0000ff00 ) >> 8,
-      ( version & 0x000000ff )
-   );
-
-   if(version < FMOD_VERSION)
-   {
-      Con::warnf("SFXFMODProvider - FMOD Ex API version in DLL is too old - FMOD  not available.");
-      return;
-   }
-   
-   // Check that the Designer API version is ok.
-   
-   if( mFMod.eventIsLoaded )
-   {
-      res = mFMod.FMOD_EventSystem_GetVersion( SFXFMODDevice::smEventSystem, &version );
-      FModAssert(res, "SFXFMODProvider - Failed to get FMOD version!");
-      
-      Con::printf( "SFXFMODProvider - FMOD Designer API version: %x.%x.%x",
-         ( version & 0xffff0000 ) >> 16,
-         ( version & 0x0000ff00 ) >> 8,
-         ( version & 0x000000ff )
-      );
-
-      if( version < FMOD_EVENT_VERSION )
-      {
-         Con::errorf( "SFXFMODProvider - FMOD Designer API version in DLL is too old!" );
-         return;
-      }
-   }
-
-   // Now, enumerate our devices.
-   int numDrivers;
-   res = mFMod.FMOD_System_GetNumDrivers(SFXFMODDevice::smSystem, &numDrivers);
-   FModAssert(res, "SFXFMODProvider - Failed to get driver count - FMOD  not available.");
-
-   char nameBuff[256];
-
-   for(S32 i=0; i<numDrivers; i++)
-   {
-      res = mFMod.FMOD_System_GetDriverInfo(SFXFMODDevice::smSystem, i, nameBuff, 256, ( FMOD_GUID* ) NULL);
-      if( res != FMOD_OK )
-      {
-         Con::errorf( "SFXFMODProvider - Failed to get driver name (%s)", FMODResultToString( res ).c_str() );
-         continue;
-      }
-      nameBuff[ 255 ] = '\0';
-      
-      FMOD_CAPS caps;
-      FMOD_SPEAKERMODE speakerMode;
-      res = mFMod.FMOD_System_GetDriverCaps( SFXFMODDevice::smSystem, i, &caps, ( int* ) 0, &speakerMode );
-      if( res != FMOD_OK )
-      {
-         Con::errorf( "SFXFMODProvider - Failed to get driver caps (%s)", FMODResultToString( res ).c_str() );
-         continue;
-      }
-
-      // Great - got something - so add it to the list of options.
-      FModDeviceInfo *fmodInfo = new FModDeviceInfo();
-      fmodInfo->name = String( nameBuff );
-      fmodInfo->hasHardware = caps & FMOD_CAPS_HARDWARE;
-      fmodInfo->maxBuffers = 32;
-      fmodInfo->driver = String();
-      fmodInfo->mCaps = caps;
-      fmodInfo->mSpeakerMode = speakerMode;
-
-      mDeviceInfo.push_back(fmodInfo);
-   }
-
-   // Did we get any devices?
-   if ( mDeviceInfo.empty() )
-   {
-      Con::warnf( "SFXFMODProvider - No valid devices found - FMOD  not available." );
-      return;
-   }
-
-   // TODO: FMOD_Memory_Initialize
-#ifdef TORQUE_OS_XENON
-   const dsize_t memSz = 5 * 1024 * 1024;
-   void *memBuffer = XPhysicalAlloc( memSz, MAXULONG_PTR, 0, PAGE_READWRITE );
-   mFMod.FMOD_Memory_Initialize( memBuffer, memSz, FMOD_MEMORY_ALLOCCALLBACK(NULL), FMOD_MEMORY_REALLOCCALLBACK(NULL), FMOD_MEMORY_FREECALLBACK(NULL) );
-#endif
-
-   // Wow, we made it - register the provider.
-   regProvider( this );
-}
-
-SFXFMODProvider::~SFXFMODProvider()
-{
-   if( SFXFMODDevice::smEventSystem )
-   {
-      mFMod.FMOD_EventSystem_Release( SFXFMODDevice::smEventSystem );
-      SFXFMODDevice::smEventSystem = NULL;
-      SFXFMODDevice::smSystem = NULL;
-   }
-   else if( SFXFMODDevice::smSystem )
-   {
-      mFMod.FMOD_System_Release( SFXFMODDevice::smSystem );
-      SFXFMODDevice::smSystem = NULL;
-   }   
-}
-
-SFXDevice* SFXFMODProvider::createDevice( const String& deviceName, bool useHardware, S32 maxBuffers )
-{
-   FModDeviceInfo* info = dynamic_cast< FModDeviceInfo* >
-      ( _findDeviceInfo( deviceName ) );
-
-   if( !info )
-      return NULL;
-      
-   if( !SFXFMODDevice::smSystem && !_createSystem() )
-      return false;
-
-   SFXFMODDevice* device = new SFXFMODDevice(this, &mFMod, 0, info->name );
-   if( !device->_init() )
-      SAFE_DELETE( device );
-
-   return device;
-}
-
-bool SFXFMODProvider::_createSystem()
-{
-   AssertFatal( !SFXFMODDevice::smEventSystem, "SFXFMODProvider::_createSystem() - event system already created!" );
-   AssertFatal( !SFXFMODDevice::smSystem, "SFXFMODProvider::_createSystem() - system already created!" );
-   
-   if( mFMod.eventIsLoaded )
-   {
-      FMOD_RESULT res = mFMod.FMOD_EventSystem_Create( &SFXFMODDevice::smEventSystem );
-      if( res != FMOD_OK )
-      {
-         Con::errorf( "SFXFMODProvider - could not create the FMOD event system." );
-         return false;
-      }
-      
-      res = mFMod.FMOD_EventSystem_GetSystemObject( SFXFMODDevice::smEventSystem, &SFXFMODDevice::smSystem );
-      if( res != FMOD_OK )
-      {
-         Con::errorf( "SFXFMODProvider - could not retrieve the FMOD system object." );
-         return false;
-      }
-   }
-   else
-   {
-      // Allocate the FMod system.
-      
-      FMOD_RESULT res = mFMod.FMOD_System_Create( &SFXFMODDevice::smSystem );
-      if( res != FMOD_OK )
-      {
-         // Failed - deal with it!
-         Con::errorf("SFXFMODProvider - could not create the FMOD system.");
-         return false;
-      }
-   }
-      
-   return true;
-}
diff --git a/Engine/source/sfx/fmod/sfxFMODVoice.cpp b/Engine/source/sfx/fmod/sfxFMODVoice.cpp
deleted file mode 100644
index 05ace6e2b..000000000
--- a/Engine/source/sfx/fmod/sfxFMODVoice.cpp
+++ /dev/null
@@ -1,303 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#include "platform/platform.h"
-#include "sfx/fmod/sfxFMODVoice.h"
-
-#include "sfx/fmod/sfxFMODBuffer.h"
-#include "sfx/fmod/sfxFMODDevice.h"
-#include "core/tAlgorithm.h"
-
-
-SFXFMODVoice* SFXFMODVoice::create( SFXFMODDevice *device,
-                                    SFXFMODBuffer *buffer )
-{
-   AssertFatal( device, "SFXFMODVoice::create() - Got null device!" );
-   AssertFatal( buffer, "SFXFMODVoice::create() - Got null buffer!" );
-
-   return new SFXFMODVoice( device, buffer );
-}
-
-SFXFMODVoice::SFXFMODVoice(   SFXFMODDevice *device, 
-                              SFXFMODBuffer *buffer )
-   :  Parent( buffer ),
-      mDevice( device ),
-      mChannel( NULL )
-{
-   AssertFatal( device, "SFXFMODVoice::SFXFMODVoice() - No device assigned!" );
-   AssertFatal( buffer, "SFXFMODVoice::SFXFMODVoice() - No buffer assigned!" );
-   AssertFatal( _getBuffer()->mSound != NULL, "SFXFMODVoice::SFXFMODVoice() - No sound assigned!" );
-}
-
-SFXFMODVoice::~SFXFMODVoice()
-{
-	_stop();
-}
-
-SFXStatus SFXFMODVoice::_status() const
-{
-   if( mChannel )
-   {
-      FMOD_BOOL isTrue = false;
-      SFXFMODDevice::smFunc->FMOD_Channel_GetPaused( mChannel, &isTrue );
-      if ( isTrue )
-         return SFXStatusPaused;
-
-      SFXFMODDevice::smFunc->FMOD_Channel_IsPlaying( mChannel, &isTrue );
-      if ( isTrue )
-         return SFXStatusPlaying;
-   }
-   
-   SFXFMODDevice::smFunc->FMOD_Channel_Stop( mChannel );
-   mChannel = NULL;
-
-   return SFXStatusStopped;
-}
-
-void SFXFMODVoice::_play()
-{
-   if( !mChannel )
-      _assignChannel();
-
-   SFXFMODDevice::smFunc->FMOD_Channel_SetPaused( mChannel, false );
-}
-
-void SFXFMODVoice::_pause()
-{
-   if( mChannel )
-      SFXFMODDevice::smFunc->FMOD_Channel_SetPaused( mChannel, true );
-}
-
-void SFXFMODVoice::_stop()
-{
-   if( mChannel )
-      SFXFMODDevice::smFunc->FMOD_Channel_Stop(mChannel);
-      
-	mChannel = NULL;
-}
-
-void SFXFMODVoice::_seek( U32 sample )
-{
-   if( !mChannel )
-      _assignChannel();
-
-   SFXFMODDevice::smFunc->FMOD_Channel_SetPosition
-      ( mChannel, sample, FMOD_TIMEUNIT_PCM );
-}
-
-bool SFXFMODVoice::_assignChannel()
-{
-   AssertFatal( _getBuffer()->mSound != NULL, "SFXFMODVoice::_assignChannel() - No sound assigned!" );
-
-   // we start playing it now in the paused state, so that we can immediately set attributes that
-   // depend on having a channel (position, volume, etc).  According to the FMod docs
-   // it is ok to do this.
-   bool success = SFXFMODDevice::smFunc->FMOD_System_PlaySound(
-      SFXFMODDevice::smSystem, 
-      FMOD_CHANNEL_FREE, 
-      _getBuffer()->mSound, 
-      true, 
-      &mChannel ) == FMOD_OK;
-      
-   if( success )
-   {
-      SFXFMODDevice::smFunc->FMOD_Channel_SetMode( mChannel, mMode );
-      SFXFMODDevice::smFunc->FMOD_Channel_SetLoopCount( mChannel, mMode & FMOD_LOOP_NORMAL ? -1 : 0 );
-
-      if( mSetFlags.test( SET_Velocity ) )
-         SFXFMODDevice::smFunc->FMOD_Channel_Set3DAttributes( mChannel, ( const FMOD_VECTOR* ) NULL, &mVelocity );
-      if( mSetFlags.test( SET_MinMaxDistance ) )
-         SFXFMODDevice::smFunc->FMOD_Channel_Set3DMinMaxDistance(mChannel, mMinDistance, mMaxDistance);
-      if( mSetFlags.test( SET_Transform ) )
-      {
-         SFXFMODDevice::smFunc->FMOD_Channel_Set3DAttributes( mChannel, &mPosition, ( const FMOD_VECTOR* ) NULL );
-         SFXFMODDevice::smFunc->FMOD_Channel_Set3DConeOrientation( mChannel, &mDirection );
-      }
-      if( mSetFlags.test( SET_Volume ) )
-         SFXFMODDevice::smFunc->FMOD_Channel_SetVolume(mChannel, mVolume);
-      if( mSetFlags.test( SET_Pitch ) )
-         SFXFMODDevice::smFunc->FMOD_Channel_SetFrequency( mChannel, mFrequency );
-      if( mSetFlags.test( SET_Cone ) )
-         SFXFMODDevice::smFunc->FMOD_Channel_Set3DConeSettings( 
-            mChannel, 
-            mConeInnerAngle,
-            mConeOuterAngle,
-            mConeOuterVolume );
-      if( mSetFlags.test( SET_Priority ) )
-         SFXFMODDevice::smFunc->FMOD_Channel_SetPriority( mChannel, TorquePriorityToFMODPriority( mPriority ) );
-      if( mSetFlags.test( SET_Reverb ) )
-         SFXFMODDevice::smFunc->FMOD_Channel_SetReverbProperties( mChannel, &mReverb );
-   }
-   
-   return success;
-}
-
-U32 SFXFMODVoice::_tell() const
-{
-   if( !mChannel )
-      return 0;
-
-   U32 pos;
-   SFXFMODDevice::smFunc->FMOD_Channel_GetPosition( mChannel, &pos, ( FMOD_TIMEUNIT ) FMOD_TIMEUNIT_PCMBYTES );
-   return _getBuffer()->getSamplePos( pos );
-}
-
-void SFXFMODVoice::setMinMaxDistance( F32 min, F32 max )
-{
-	if ( !( _getBuffer()->mMode & FMOD_3D ) )
-		return;
-      
-   mMinDistance = min;
-   mMaxDistance = max;
-   
-   mSetFlags.set( SET_MinMaxDistance );
-
-   if( mChannel )
-      SFXFMODDevice::smFunc->FMOD_Channel_Set3DMinMaxDistance(mChannel, mMinDistance, mMaxDistance);
-}
-
-void SFXFMODVoice::play( bool looping )
-{
-   if( mBuffer->isStreaming() )
-      looping = true;
-   
-   mMode = mDevice->get3dRollOffMode();
-   mMode |= (looping ? FMOD_LOOP_NORMAL : FMOD_LOOP_OFF);
-
-   Parent::play( looping );
-}
-
-void SFXFMODVoice::setVelocity( const VectorF& velocity )
-{
-	if( !( _getBuffer()->mMode & FMOD_3D ) )
-		return;
-
-	// Note we have to do a handedness swap; see the 
-   // listener update code in SFXFMODDevice for details.
-	mVelocity.x = velocity.x;
-   mVelocity.y = velocity.z;
-	mVelocity.z = velocity.y;
-   
-   mSetFlags.set( SET_Velocity );
-
-   if( mChannel )
-      SFXFMODDevice::smFunc->FMOD_Channel_Set3DAttributes( mChannel, ( const FMOD_VECTOR* ) NULL, &mVelocity );
-}
-
-void SFXFMODVoice::setTransform( const MatrixF& transform )
-{
-	if ( !( _getBuffer()->mMode & FMOD_3D ) )
-		return;
-
-   transform.getColumn( 3, (Point3F*)&mPosition );
-   transform.getColumn( 1, (Point3F*)&mDirection );
-
-   // Note we have to do a handedness swap; see the 
-   // listener update code in SFXFMODDevice for details.
-   swap( mPosition.y, mPosition.z );
-   swap( mDirection.y, mDirection.z );
-   
-   mSetFlags.set( SET_Transform );
-
-   if( mChannel )
-   {
-      // This can fail safe, so don't assert if it fails.
-      SFXFMODDevice::smFunc->FMOD_Channel_Set3DAttributes( mChannel, &mPosition, ( const FMOD_VECTOR* ) NULL );
-      SFXFMODDevice::smFunc->FMOD_Channel_Set3DConeOrientation( mChannel, &mDirection );
-   }
-}
-
-void SFXFMODVoice::setVolume( F32 volume )
-{
-   mVolume = volume;
-   mSetFlags.set( SET_Volume );
-   
-   if( mChannel )
-      SFXFMODDevice::smFunc->FMOD_Channel_SetVolume( mChannel, volume );
-}
-
-void SFXFMODVoice::setPriority( F32 priority )
-{
-   mPriority = priority;
-   mSetFlags.set( SET_Priority );
-   
-   if( mChannel )
-      SFXFMODDevice::smFunc->FMOD_Channel_SetPriority( mChannel, TorquePriorityToFMODPriority( priority ) );
-}
-
-void SFXFMODVoice::setPitch( F32 pitch )
-{
-   // if we do not know the frequency, we cannot change the pitch
-   F32 frequency = _getBuffer()->getFormat().getSamplesPerSecond();
-   if ( frequency == 0 )
-      return;
-      
-   mFrequency = frequency * pitch;
-   
-   mSetFlags.set( SET_Pitch );
-
-	// Scale the original frequency by the pitch factor.
-   if( mChannel )
-      SFXFMODDevice::smFunc->FMOD_Channel_SetFrequency(mChannel, mFrequency);
-}
-
-void SFXFMODVoice::setCone( F32 innerAngle, F32 outerAngle, F32 outerVolume )
-{
-   mConeInnerAngle = innerAngle;
-   mConeOuterAngle = outerAngle;
-   mConeOuterVolume = outerVolume;
-   
-   mSetFlags.set( SET_Cone );
-
-   if( mChannel )
-      SFXFMODDevice::smFunc->FMOD_Channel_Set3DConeSettings( 
-         mChannel, 
-         mConeInnerAngle,
-         mConeOuterAngle,
-         mConeOuterVolume );
-}
-
-void SFXFMODVoice::setReverb( const SFXSoundReverbProperties& reverb )
-{
-   dMemset( &mReverb, 0, sizeof( mReverb ) );
-   
-   mReverb.Direct                = reverb.mDirect;
-   mReverb.Room                  = reverb.mRoom;
-   mReverb.Flags                 = reverb.mFlags;
-   
-   mSetFlags.set( SET_Reverb );
-   
-   if( mChannel )
-      SFXFMODDevice::smFunc->FMOD_Channel_SetReverbProperties( mChannel, &mReverb );
-}
-
-bool SFXFMODVoice::isVirtual() const
-{
-   if( mChannel )
-   {
-      FMOD_BOOL result;
-      SFXFMODDevice::smFunc->FMOD_Channel_IsVirtual( mChannel, &result );
-      return result;
-   }
-   else
-      return false;
-}
diff --git a/Engine/source/sfx/fmod/sfxFMODVoice.h b/Engine/source/sfx/fmod/sfxFMODVoice.h
deleted file mode 100644
index 14a5f7ced..000000000
--- a/Engine/source/sfx/fmod/sfxFMODVoice.h
+++ /dev/null
@@ -1,121 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#ifndef _SFXFMODVOICE_H_
-#define _SFXFMODVOICE_H_
-
-#ifndef _SFXDEVICE_H_
-   #include "sfx/sfxDevice.h"
-#endif
-#ifndef _SFXVOICE_H_
-   #include "sfx/sfxVoice.h"
-#endif
-#ifndef _BITSET_H_
-   #include "core/bitSet.h"
-#endif
-
-#include "fmod.h"
-
-class SFXSource;
-class SFXFMODBuffer;
-class SFXFMODDevice;
-
-
-class SFXFMODVoice : public SFXVoice
-{
-      typedef SFXVoice Parent;
-      friend class SFXFMODBuffer;
-
-   protected:
-
-      SFXFMODDevice *mDevice;
-
-      mutable FMOD_CHANNEL *mChannel;
-      
-      enum ESettings
-      {
-         SET_MinMaxDistance   = BIT( 0 ),
-         SET_Velocity         = BIT( 1 ),
-         SET_Transform        = BIT( 2 ),
-         SET_Volume           = BIT( 3 ),
-         SET_Pitch            = BIT( 4 ),
-         SET_Cone             = BIT( 5 ),
-         SET_Priority         = BIT( 6 ),
-         SET_Reverb           = BIT( 7 ),
-      };
-      
-      BitSet32 mSetFlags;
-      
-      FMOD_MODE mMode;
-      F32 mMinDistance;
-      F32 mMaxDistance;
-      F32 mVolume;
-      F32 mPriority;
-      F32 mFrequency;
-      F32 mConeInnerAngle;
-      F32 mConeOuterAngle;
-      F32 mConeOuterVolume;
-      FMOD_VECTOR mVelocity;
-      FMOD_VECTOR mPosition;
-      FMOD_VECTOR mDirection;
-      FMOD_REVERB_CHANNELPROPERTIES mReverb;
-
-      ///
-	   SFXFMODVoice(  SFXFMODDevice *device, 
-                     SFXFMODBuffer *buffer );
-
-      // prep for playback
-      bool _assignChannel();
-
-      SFXFMODBuffer* _getBuffer() const { return ( SFXFMODBuffer* ) mBuffer.getPointer(); }
-
-      // SFXVoice.
-      virtual SFXStatus _status() const;
-      virtual void _play();
-      virtual void _pause();
-      virtual void _stop();
-      virtual void _seek( U32 sample );
-      virtual U32 _tell() const;
-
-   public:
-
-      ///
-      static SFXFMODVoice* create(  SFXFMODDevice *device, 
-                                    SFXFMODBuffer *buffer );
-
-      ///
-      virtual ~SFXFMODVoice();
-
-      /// SFXVoice
-      void setMinMaxDistance( F32 min, F32 max );
-      void play( bool looping );
-      void setVelocity( const VectorF& velocity );
-      void setTransform( const MatrixF& transform );
-      void setVolume( F32 volume );
-      void setPriority( F32 priority );
-      void setPitch( F32 pitch );
-      void setCone( F32 innerAngle, F32 outerAngle, F32 outerVolume );
-      void setReverb( const SFXSoundReverbProperties& reverb );
-      bool isVirtual() const;
-};
-
-#endif // _SFXFMODBUFFER_H_
\ No newline at end of file
diff --git a/Engine/source/sfx/sfxDescription.cpp b/Engine/source/sfx/sfxDescription.cpp
index f07a8f7d6..143e0a31e 100644
--- a/Engine/source/sfx/sfxDescription.cpp
+++ b/Engine/source/sfx/sfxDescription.cpp
@@ -247,7 +247,6 @@ void SFXDescription::initPersistFields()
          "If true, the sound system will try to allocate the voice for the sound directly "
          "on the sound hardware for mixing by the hardware mixer.  Be aware that a hardware mixer "
          "may not provide all features available to sounds mixed in software.\n\n"
-         "@note This flag currently only takes effect when using FMOD.\n\n"
          "@note Generally, it is preferable to let sounds be mixed in software.\n\n" );
       addField( "parameters",          TypeSFXParameterName, Offset( mParameters, SFXDescription ), MaxNumParameters,
          "Names of the parameters to which sources using this description will automatically be linked.\n\n"
@@ -355,7 +354,7 @@ void SFXDescription::initPersistFields()
          "@ref SFXSource_cones" );
       addField( "rolloffFactor",       TypeF32,    Offset( mRolloffFactor, SFXDescription ),
          "Scale factor to apply to logarithmic distance attenuation curve.  If -1, the global rolloff setting is used.\n\n"
-         "@note Per-sound rolloff is only supported on OpenAL and FMOD at the moment.  With other divices, the global rolloff setting "
+         "@note Per-sound rolloff is only supported on OpenAL at the moment.  With other divices, the global rolloff setting "
             "is used for all sounds.\n"
          "@see LevelInfo::soundDistanceModel" );
       
@@ -373,7 +372,6 @@ void SFXDescription::initPersistFields()
          "of sample data determined by this field.  The greater its value, the more sample data each "
          "packet contains, the more work is done per packet.\n\n"
          "@note This field only takes effect when Torque's own sound system performs the streaming. "
-            "When FMOD is used, this field is ignored and streaming is performed by FMOD.\n\n"
          "@ref SFX_streaming" );
       addField( "streamReadAhead",     TypeS32,    Offset( mStreamReadAhead, SFXDescription ),
          "Number of sample packets to read and buffer in advance.\n"
@@ -382,7 +380,6 @@ void SFXDescription::initPersistFields()
          "device before the playback queue is running dry.  Greater values thus allow for more lag "
          "in the streaming pipeline.\n\n"
          "@note This field only takes effect when Torque's own sound system performs the streaming. "
-            "When FMOD is used, this field is ignored and streaming is performed by FMOD.\n\n"
          "@ref SFX_streaming" );
          
    endGroup( "Streaming" );
diff --git a/Engine/source/sfx/sfxDevice.h b/Engine/source/sfx/sfxDevice.h
index f7dc66b77..a2389f587 100644
--- a/Engine/source/sfx/sfxDevice.h
+++ b/Engine/source/sfx/sfxDevice.h
@@ -63,7 +63,6 @@ class SFXDevice
          CAPS_Occlusion       = BIT( 2 ),    ///< Device has its own sound occlusion handling (SFXOcclusionManager).
          CAPS_DSPEffects      = BIT( 3 ),    ///< Device implements DSP effects (SFXDSPManager).
          CAPS_MultiListener   = BIT( 4 ),    ///< Device supports multiple listeners.
-         CAPS_FMODDesigner    = BIT( 5 ),    ///< FMOD Designer support.
       };
       
    protected:
diff --git a/Engine/source/sfx/sfxProfile.cpp b/Engine/source/sfx/sfxProfile.cpp
index 1f7c97a2c..4cd6a8cdb 100644
--- a/Engine/source/sfx/sfxProfile.cpp
+++ b/Engine/source/sfx/sfxProfile.cpp
@@ -49,7 +49,7 @@ ConsoleDocClass( SFXProfile,
    "for it to be created.  However, several of the SFX functions (sfxPlayOnce(), sfxCreateSource()) perform "
    "this creation internally for convenience using temporary profile objects.\n\n"
    
-   "Sound files can be in either OGG or WAV format.  However, extended format support is available when using FMOD. "
+   "Sound files can be in either OGG or WAV format. "
    "See @ref SFX_formats.\n\n"
 
    "@section SFXProfile_loading Profile Loading\n\n"
diff --git a/Engine/source/sfx/sfxSystem.cpp b/Engine/source/sfx/sfxSystem.cpp
index 34db19902..3d793995e 100644
--- a/Engine/source/sfx/sfxSystem.cpp
+++ b/Engine/source/sfx/sfxSystem.cpp
@@ -158,8 +158,6 @@ ImplementEnumType( SFXChannel,
       "- 3: Pause\n\n" },
    { SFXChannelUser0,              "User0",
       "Channel available for custom use.  By default ignored by sources.\n\n"
-      "@note For FMOD Designer event sources (SFXFMODEventSource), this channel is used for event parameters "
-         "defined in FMOD Designer and should not be used otherwise.\n\n"
       "@see SFXSource::onParameterValueChange" },
    { SFXChannelUser1,              "User1",
       "Channel available for custom use.  By default ignored by sources.\n\n"
@@ -179,7 +177,6 @@ static const U32 sDeviceCapsVoiceManagement = SFXDevice::CAPS_VoiceManagement;
 static const U32 sDeviceCapsOcclusion = SFXDevice::CAPS_Occlusion;
 static const U32 sDeviceCapsDSPEffects = SFXDevice::CAPS_DSPEffects;
 static const U32 sDeviceCapsMultiListener = SFXDevice::CAPS_MultiListener;
-static const U32 sDeviceCapsFMODDesigner = SFXDevice::CAPS_FMODDesigner;
 
 static const U32 sDeviceInfoProvider = 0;
 static const U32 sDeviceInfoName = 1;
@@ -253,7 +250,6 @@ SFXSystem::SFXSystem()
    
    Con::addConstant( "$SFX::DEVICE_CAPS_REVERB", TypeS32, &sDeviceCapsReverb,
       "Sound device capability flag indicating that the sound device supports reverb.\n\n"
-      "@note Currently only FMOD implements this.\n\n"
       "@see sfxGetDeviceInfo\n\n"
       "@ref SFX_reverb\n\n"
       "@ingroup SFX" );
@@ -261,7 +257,6 @@ SFXSystem::SFXSystem()
       "Sound device capability flag indicating that the sound device implements its own voice virtualization.\n\n"
       "For these devices, the sound system will deactivate its own voice management and leave voice "
          "virtualization entirely to the device.\n\n"
-      "@note Currently only FMOD implements this.\n\n"
       "@see sfxGetDeviceInfo\n\n"
       "@ref SFXSound_virtualization\n\n"
       "@ingroup SFX" );
@@ -278,16 +273,8 @@ SFXSystem::SFXSystem()
       "@ingroup SFX" );
    Con::addConstant( "$SFX::DEVICE_CAPS_MULTILISTENER", TypeS32, &sDeviceCapsMultiListener,
       "Sound device capability flag indicating that the sound device supports multiple concurrent listeners.\n\n"
-      "@note Currently only FMOD implements this.\n\n"
       "@see sfxGetDeviceInfo\n\n"
       "@ingroup SFX" );
-   Con::addConstant( "$SFX::DEVICE_CAPS_FMODDESIGNER", TypeS32, &sDeviceCapsFMODDesigner,
-      "Sound device capability flag indicating that the sound device supports FMOD Designer audio projects.\n\n"
-      "@note This is exclusive to FMOD.  If the FMOD Event DLLs are in place and could be successfully loaded, this "
-         "flag will be set after initializating an FMOD audio device.\n\n"
-      "@see sfxGetDeviceInfo\n\n"
-      "@ref FMOD_designer\n\n"
-      "@ingroup SFX" );
       
    Con::addConstant( "$SFX::DEVICE_INFO_PROVIDER", TypeS32, &sDeviceInfoProvider,
       "Index of sound provider field in device info string.\n\n"
@@ -1241,7 +1228,7 @@ DefineEngineFunction( sfxGetAvailableDevices, const char*, (),,
    "@verbatim\n"
       "provider TAB device TAB hasHardware TAB numMaxBuffers\n"
    "@endverbatim\n"
-   "- provider: The name of the device provider (e.g. \"FMOD\").\n"
+   "- provider: The name of the device provider (e.g. \"OpenAL\").\n"
    "- device: The name of the device as returned by the device layer.\n"
    "- hasHardware: Whether the device supports hardware mixing or not.\n"
    "- numMaxBuffers: The maximum number of concurrent voices supported by the device's mixer.  If this limit "
@@ -1336,7 +1323,7 @@ DefineEngineFunction( sfxGetDeviceInfo, const char*, (),,
    "@verbatim\n"
       "provider TAB device TAB hasHardware TAB numMaxBuffers TAB caps\n"
    "@endverbatim\n"
-   "- provider: The name of the device provider (e.g. \"FMOD\").\n"
+   "- provider: The name of the device provider (e.g. \"OpenALD\").\n"
    "- device: The name of the device as returned by the device layer.\n"
    "- hasHardware: Whether the device supports hardware mixing or not.\n"
    "- numMaxBuffers: The maximum number of concurrent voices supported by the device's mixer.  If this limit "
@@ -1357,7 +1344,6 @@ DefineEngineFunction( sfxGetDeviceInfo, const char*, (),,
    "@see $SFX::DEVICE_CAPS_OCCLUSION\n\n"
    "@see $SFX::DEVICE_CAPS_DSPEFFECTS\n\n"
    "@see $SFX::DEVICE_CAPS_MULTILISTENER\n\n"
-   "@see $SFX::DEVICE_CAPS_FMODDESIGNER\n\n"
    "@ref SFX_devices\n"
    "@ingroup SFX" )
 {
@@ -1379,7 +1365,7 @@ static ConsoleDocFragment _sfxCreateSource1(
    "@param track The track the source should play.\n"
    "@return A new SFXSource for playback of the given track or 0 if no source could be created from the given track.\n\n"
    "@note Trying to create a source for a device-specific track type will fail if the currently selected device "
-      "does not support the type.  Example: trying to create a source for an FMOD Designer event when not running FMOD.\n\n"
+      "does not support the type. \n\n"
    "@tsexample\n"
    "// Create and play a source from a pre-existing profile:\n"
    "%source = sfxCreateSource( SoundFileProfile );\n"
@@ -1400,7 +1386,7 @@ static ConsoleDocFragment _sfxCreateSource2(
    "@param z The Z coordinate of the 3D sound position.\n"
    "@return A new SFXSource for playback of the given track or 0 if no source could be created from the given track.\n\n"
    "@note Trying to create a source for a device-specific track type will fail if the currently selected device "
-      "does not support the type.  Example: trying to create a source for an FMOD Designer event when not running FMOD.\n\n"
+      "does not support the type. \n\n"
    "@tsexample\n"
    "// Create and play a source from a pre-existing profile and position it at (100, 200, 300):\n"
    "%source = sfxCreateSource( SoundFileProfile, 100, 200, 300 );\n"
diff --git a/Engine/source/sfx/sfxTrack.cpp b/Engine/source/sfx/sfxTrack.cpp
index 987650c0b..6b395fe91 100644
--- a/Engine/source/sfx/sfxTrack.cpp
+++ b/Engine/source/sfx/sfxTrack.cpp
@@ -39,7 +39,7 @@ ConsoleDocClass( SFXTrack,
    
    "The term \"track\" is used in the sound system to refer to any entity that can be played "
    "back as a sound source.  These can be individual files (SFXProfile), patterns of other tracks "
-   "(SFXPlayList), or special sound data defined by a device layer (SFXFMODEvent).\n\n"
+   "(SFXPlayList).\n\n"
    
    "Any track must be paired with a SFXDescription that tells the sound system how to set up "
    "playback for the track.\n\n"
diff --git a/Templates/BaseGame/game/core/sfx/scripts/audio.tscript b/Templates/BaseGame/game/core/sfx/scripts/audio.tscript
index a5932de8f..85479a28f 100644
--- a/Templates/BaseGame/game/core/sfx/scripts/audio.tscript
+++ b/Templates/BaseGame/game/core/sfx/scripts/audio.tscript
@@ -216,26 +216,18 @@ function sfxCompareProvider( %providerA, %providerB )
       
    switch$( %providerA )
    {
-      // Always prefer FMOD over anything else.
-      case "FMOD":
-         return 1;
-         
-      // Prefer OpenAL over anything but FMOD.
       case "OpenAL":
-         if( %providerB $= "FMOD" )
-            return -1;
-         else
             return 1;
       
       // choose XAudio over DirectSound
       case "XAudio":
-         if( %providerB $= "FMOD" || %providerB $= "OpenAL" )
+         if( %providerB $= "OpenAL" )
             return -1;
          else
             return 0;
             
       case "DirectSound":
-         if( %providerB !$= "FMOD" && %providerB !$= "OpenAL" && %providerB !$= "XAudio" )
+         if( %providerB !$= "OpenAL" && %providerB !$= "XAudio" )
             return 1;
          else
             return -1;
diff --git a/Templates/BaseGame/game/data/UI/guis/guiMusicPlayer.tscript b/Templates/BaseGame/game/data/UI/guis/guiMusicPlayer.tscript
index 465659017..2a302e635 100644
--- a/Templates/BaseGame/game/data/UI/guis/guiMusicPlayer.tscript
+++ b/Templates/BaseGame/game/data/UI/guis/guiMusicPlayer.tscript
@@ -25,7 +25,6 @@
 // Preferences.
 
 $pref::GuiMusicPlayer::filePattern = "*.ogg\t*.wav";
-$pref::GuiMusicPlayer::filePatternFMOD = "*.aiff\t*.asf\t*.flac\t*.it\t*.mid\t*.mod\t*.mp2\t*.mp3\t*.ogg\t*.s3m\t*.vag\t*.wav\t*.wma\t*.xm";
 $pref::GuiMusicPlayer::fadeTime = "3.0";
 
 //---------------------------------------------------------------------------------------------
diff --git a/Templates/BaseGame/game/data/UI/guis/profiler.tscript b/Templates/BaseGame/game/data/UI/guis/profiler.tscript
index 402f7b1f1..a13d7d9b5 100644
--- a/Templates/BaseGame/game/data/UI/guis/profiler.tscript
+++ b/Templates/BaseGame/game/data/UI/guis/profiler.tscript
@@ -192,8 +192,7 @@ function sfxMetricsCallback()
 {
    return "  | SFX |" @
           "  Sounds: " @ $SFX::numSounds @
-          "  Lists: " @ ( $SFX::numSources - $SFX::numSounds - $SFX::Device::fmodNumEventSource ) @
-          "  Events: " @ $SFX::fmodNumEventSources @
+          "  Lists: " @ ( $SFX::numSources - $SFX::numSounds ) @
           "  Playing: " @ $SFX::numPlaying @
           "  Culled: " @ $SFX::numCulled @
           "  Voices: " @ $SFX::numVoices @
diff --git a/Templates/BaseGame/game/tools/datablockEditor/datablockEditor.tscript b/Templates/BaseGame/game/tools/datablockEditor/datablockEditor.tscript
index 4980dd3c2..ca9373416 100644
--- a/Templates/BaseGame/game/tools/datablockEditor/datablockEditor.tscript
+++ b/Templates/BaseGame/game/tools/datablockEditor/datablockEditor.tscript
@@ -223,11 +223,7 @@ function DatablockEditorPlugin::isExcludedDatablockType( %this, %className )
       case "SimDatablock":
          return true;
       case "SFXTrack": // Abstract.
-         return true;  
-      case "SFXFMODEvent": // Internally created.
-         return true;
-      case "SFXFMODEventGroup": // Internally created.
-         return true;
+         return true; 
    }
    return false;
 }
@@ -754,8 +750,7 @@ function DatablockEditorPlugin::canBeClientSideDatablock( %className )
            "SFXAmbience" or
            "SFXEnvironment" or
            "SFXState" or
-           "SFXDescription" or
-           "SFXFMODProject":
+           "SFXDescription":
          return true;
          
       default:
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/AddFMODProjectDlg,EditorGuiGroup.asset.taml b/Templates/BaseGame/game/tools/worldEditor/gui/AddFMODProjectDlg,EditorGuiGroup.asset.taml
deleted file mode 100644
index a38ac0145..000000000
--- a/Templates/BaseGame/game/tools/worldEditor/gui/AddFMODProjectDlg,EditorGuiGroup.asset.taml
+++ /dev/null
@@ -1,7 +0,0 @@
-<GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="AddFMODProjectDlg,EditorGuiGroup"
-    scriptFile="@assetFile=AddFMODProjectDlg.ed.gui"
-    GUIFile="@assetFile=AddFMODProjectDlg.ed.gui"
-    VersionId="1" />
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/AddFMODProjectDlg.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/AddFMODProjectDlg.ed.gui
deleted file mode 100644
index b7bc1d86b..000000000
--- a/Templates/BaseGame/game/tools/worldEditor/gui/AddFMODProjectDlg.ed.gui
+++ /dev/null
@@ -1,284 +0,0 @@
-//--- OBJECT WRITE BEGIN ---
-$guiContent = new GuiControl(AddFMODProjectDlg,EditorGuiGroup) {
-   isContainer = "1";
-   Profile = "ToolsGuiOverlayProfile";
-   HorizSizing = "right";
-   VertSizing = "bottom";
-   position = "0 0";
-   Extent = "1024 768";
-   MinExtent = "8 2";
-   canSave = "1";
-   Visible = "1";
-   tooltipprofile = "ToolsGuiToolTipProfile";
-   hovertime = "1000";
-   canSaveDynamicFields = "1";
-
-   new GuiWindowCtrl() {
-      resizeWidth = "0";
-      resizeHeight = "0";
-      canMove = "1";
-      canClose = "1";
-      canMinimize = "0";
-      canMaximize = "0";
-      minSize = "50 50";
-      closeCommand = "AddFMODProjectDlg.onCancel();";
-      EdgeSnap = "1";
-      text = "Add FMOD Designer Audio";
-      Margin = "0 0 0 0";
-      Padding = "0 0 0 0";
-      AnchorTop = "1";
-      AnchorBottom = "0";
-      AnchorLeft = "1";
-      AnchorRight = "0";
-      isContainer = "1";
-      Profile = "ToolsGuiWindowProfile";
-      HorizSizing = "right";
-      VertSizing = "bottom";
-      position = "361 196";
-      Extent = "303 236";
-      MinExtent = "8 2";
-      canSave = "1";
-      Visible = "1";
-      tooltipprofile = "ToolsGuiToolTipProfile";
-      hovertime = "1000";
-      canSaveDynamicFields = "0";
-      internalName = "window";
-
-      new GuiBitmapBorderCtrl() {
-         isContainer = "1";
-         Profile = "ToolsGuiGroupBorderProfile";
-         HorizSizing = "right";
-         VertSizing = "bottom";
-         position = "5 26";
-         Extent = "291 160";
-         MinExtent = "8 2";
-         canSave = "1";
-         Visible = "1";
-         tooltipprofile = "ToolsGuiToolTipProfile";
-         hovertime = "1000";
-         canSaveDynamicFields = "0";
-
-         new GuiTextCtrl() {
-            text = "Path to the compiled event file (.fev):";
-            maxLength = "1024";
-            Margin = "0 0 0 0";
-            Padding = "0 0 0 0";
-            AnchorTop = "1";
-            AnchorBottom = "0";
-            AnchorLeft = "1";
-            AnchorRight = "0";
-            isContainer = "0";
-            Profile = "ToolsGuiAutoSizeTextProfile";
-            HorizSizing = "right";
-            VertSizing = "bottom";
-            position = "8 51";
-            Extent = "176 17";
-            MinExtent = "8 2";
-            canSave = "1";
-            Visible = "1";
-            tooltipprofile = "ToolsGuiToolTipProfile";
-            hovertime = "1000";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextEditCtrl() {
-            historySize = "0";
-            password = "0";
-            tabComplete = "0";
-            sinkAllKeyEvents = "0";
-            passwordMask = "•";
-            maxLength = "1024";
-            Margin = "0 0 0 0";
-            Padding = "0 0 0 0";
-            AnchorTop = "1";
-            AnchorBottom = "0";
-            AnchorLeft = "1";
-            AnchorRight = "0";
-            isContainer = "0";
-            Profile = "ToolsGuiTextEditProfile";
-            HorizSizing = "right";
-            VertSizing = "bottom";
-            position = "7 72";
-            Extent = "254 17";
-            MinExtent = "8 2";
-            canSave = "1";
-            Visible = "1";
-            tooltipprofile = "ToolsGuiToolTipProfile";
-            hovertime = "1000";
-            internalName = "fileNameField";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextEditCtrl() {
-            historySize = "0";
-            password = "0";
-            tabComplete = "0";
-            sinkAllKeyEvents = "0";
-            passwordMask = "•";
-            maxLength = "1024";
-            Margin = "0 0 0 0";
-            Padding = "0 0 0 0";
-            AnchorTop = "1";
-            AnchorBottom = "0";
-            AnchorLeft = "1";
-            AnchorRight = "0";
-            isContainer = "0";
-            Profile = "ToolsGuiTextEditProfile";
-            HorizSizing = "right";
-            VertSizing = "bottom";
-            position = "7 127";
-            Extent = "254 17";
-            MinExtent = "8 2";
-            canSave = "1";
-            Visible = "1";
-            tooltipprofile = "ToolsGuiToolTipProfile";
-            hovertime = "1000";
-            internalName = "mediaPathField";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextCtrl() {
-            text = "Name for the SFXFMODProject object:";
-            maxLength = "1024";
-            Margin = "0 0 0 0";
-            Padding = "0 0 0 0";
-            AnchorTop = "1";
-            AnchorBottom = "0";
-            AnchorLeft = "1";
-            AnchorRight = "0";
-            isContainer = "0";
-            Profile = "ToolsGuiAutoSizeTextProfile";
-            HorizSizing = "right";
-            VertSizing = "bottom";
-            position = "8 10";
-            Extent = "189 17";
-            MinExtent = "8 2";
-            canSave = "1";
-            Visible = "1";
-            tooltipprofile = "ToolsGuiToolTipProfile";
-            hovertime = "1000";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextEditCtrl() {
-            historySize = "0";
-            password = "0";
-            tabComplete = "0";
-            sinkAllKeyEvents = "0";
-            passwordMask = "•";
-            maxLength = "1024";
-            Margin = "0 0 0 0";
-            Padding = "0 0 0 0";
-            AnchorTop = "1";
-            AnchorBottom = "0";
-            AnchorLeft = "1";
-            AnchorRight = "0";
-            isContainer = "0";
-            Profile = "ToolsGuiTextEditProfile";
-            HorizSizing = "right";
-            VertSizing = "bottom";
-            position = "7 30";
-            Extent = "277 17";
-            MinExtent = "8 2";
-            canSave = "1";
-            Visible = "1";
-            tooltipprofile = "ToolsGuiToolTipProfile";
-            hovertime = "1000";
-            internalName = "projectNameField";
-            canSaveDynamicFields = "0";
-         };
-         new GuiMLTextCtrl() {
-            lineSpacing = "2";
-            allowColorChars = "0";
-            maxChars = "-1";
-            text = "Path to the project\'s media files (leave empty if files are in same directory as the project file):";
-            useURLMouseCursor = "0";
-            isContainer = "0";
-            Profile = "ToolsGuiMLTextProfile";
-            HorizSizing = "right";
-            VertSizing = "bottom";
-            position = "8 96";
-            Extent = "276 26";
-            MinExtent = "8 2";
-            canSave = "1";
-            Visible = "1";
-            tooltipprofile = "ToolsGuiToolTipProfile";
-            hovertime = "1000";
-            canSaveDynamicFields = "0";
-         };
-         new GuiButtonCtrl() {
-            text = "...";
-            groupNum = "-1";
-            buttonType = "PushButton";
-            useMouseEvents = "0";
-            isContainer = "0";
-            Profile = "ToolsGuiButtonProfile";
-            HorizSizing = "right";
-            VertSizing = "bottom";
-            position = "266 72";
-            Extent = "18 17";
-            MinExtent = "8 2";
-            canSave = "1";
-            Visible = "1";
-            tooltipprofile = "ToolsGuiToolTipProfile";
-            hovertime = "1000";
-            canSaveDynamicFields = "0";
-            command = "AddFMODProjectDlg.onSelectFile();";
-         };
-         new GuiButtonCtrl() {
-            text = "...";
-            groupNum = "-1";
-            buttonType = "PushButton";
-            useMouseEvents = "0";
-            isContainer = "0";
-            Profile = "ToolsGuiButtonProfile";
-            HorizSizing = "right";
-            VertSizing = "bottom";
-            position = "266 127";
-            Extent = "18 17";
-            MinExtent = "8 2";
-            canSave = "1";
-            Visible = "1";
-            tooltipprofile = "ToolsGuiToolTipProfile";
-            hovertime = "1000";
-            canSaveDynamicFields = "0";
-            command = "AddFMODProjectDlg.onSelectMediaPath();";
-         };
-      };
-      new GuiButtonCtrl() {
-         text = "Cancel";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         isContainer = "0";
-         Profile = "ToolsGuiButtonProfile";
-         HorizSizing = "right";
-         VertSizing = "bottom";
-         position = "206 196";
-         Extent = "90 30";
-         MinExtent = "8 2";
-         canSave = "1";
-         Visible = "1";
-         Command = "AddFMODProjectDlg.onCancel();";
-         tooltipprofile = "ToolsGuiToolTipProfile";
-         hovertime = "1000";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl() {
-         text = "OK";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         isContainer = "0";
-         Profile = "ToolsGuiButtonProfile";
-         HorizSizing = "right";
-         VertSizing = "bottom";
-         position = "112 196";
-         Extent = "90 30";
-         MinExtent = "8 2";
-         canSave = "1";
-         Visible = "1";
-         Command = "AddFMODProjectDlg.onOK();";
-         tooltipprofile = "ToolsGuiToolTipProfile";
-         hovertime = "1000";
-         canSaveDynamicFields = "0";
-      };
-   };
-};
-//--- OBJECT WRITE END ---
diff --git a/Templates/BaseGame/game/tools/worldEditor/main.tscript b/Templates/BaseGame/game/tools/worldEditor/main.tscript
index fed24607e..0d975d380 100644
--- a/Templates/BaseGame/game/tools/worldEditor/main.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/main.tscript
@@ -40,7 +40,6 @@ function initializeWorldEditor()
    exec("./gui/ManageBookmarksWindow.ed.gui");
    exec("./gui/ManageSFXParametersWindow.ed.gui" );
    exec("./gui/TimeAdjustGui.ed.gui");
-   exec("./gui/AddFMODProjectDlg.ed.gui");
    exec("./gui/SelectObjectsWindow.ed.gui");
    exec("./gui/ProceduralTerrainPainterGui.gui" );
    exec("tools/gui/renderTargetVisualizer.ed.gui");
@@ -65,7 +64,6 @@ function initializeWorldEditor()
    exec("./scripts/EditorChooseLevelGui.ed." @ $TorqueScriptFileExtension);
    exec("./scripts/cameraBookmarks.ed." @ $TorqueScriptFileExtension);
    exec("./scripts/ManageSFXParametersWindow.ed." @ $TorqueScriptFileExtension);
-   exec("./scripts/AddFMODProjectDlg.ed." @ $TorqueScriptFileExtension);
    exec("./scripts/SelectObjectsWindow.ed." @ $TorqueScriptFileExtension);
    exec("./scripts/cameraCommands.ed." @ $TorqueScriptFileExtension);
    exec("./scripts/probeBake.ed." @ $TorqueScriptFileExtension);
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/AddFMODProjectDlg.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/AddFMODProjectDlg.ed.tscript
deleted file mode 100644
index 1a2494ae1..000000000
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/AddFMODProjectDlg.ed.tscript
+++ /dev/null
@@ -1,253 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-
-
-//=============================================================================
-//    AddFMODProjectDlg.
-//=============================================================================
-
-//-----------------------------------------------------------------------------
-
-function AddFMODProjectDlg::show( %this )
-{
-   if( $platform $= "macos" )
-   {
-      %fmodex = "libfmodex.dylib";
-      %fmodevent = "libfmodevent.dylib";
-   }
-   else
-   {
-      %fmodex = "fmodex.dll";
-      %fmodevent = "fmod_event.dll";
-   }
-
-   // Make sure we have FMOD running.
-   
-   if( getField( sfxGetDeviceInfo(), $SFX::DEVICE_INFO_PROVIDER ) !$= "FMOD" )
-   {
-      toolsMessageBoxOK( "Error",
-         "You do not currently have FMOD selected as your sound system." NL
-         "" NL
-         "To install FMOD, place the FMOD DLLs (" @ %fmodex @ " and " @ %fmodevent @ ")" SPC
-         "in your game/ folder alongside your game executable" SPC
-         "and restart Torque." NL
-         "" NL
-         "To select FMOD as your sound system, choose it as the sound provider in" SPC
-         "the audio tab of the Game Options dialog."
-      );
-      
-      return;
-   }
-   
-   // Make sure we have the FMOD Event DLL loaded.
-   
-   %deviceCaps = getField( sfxGetDeviceInfo(), $SFX::DEVICE_INFO_CAPS );
-   if( !( %deviceCaps & $SFX::DEVICE_CAPS_FMODDESIGNER ) )
-   {
-      toolsMessageBoxOK( "Error",
-         "You do not have the requisite FMOD Event DLL in place." NL
-         "" NL
-         "Please copy " @ %fmodevent @ " into your game/ folder and restart Torque."
-      );
-      return;
-   }
-   
-   // Show it.
-      
-   Canvas.pushDialog( %this, 0, true );
-}
-
-//-----------------------------------------------------------------------------
-
-function AddFMODProjectDlg::onWake( %this )
-{
-   %this.persistenceMgr = new PersistenceManager();
-}
-
-//-----------------------------------------------------------------------------
-
-function AddFMODProjectDlg::onSleep( %this )
-{
-   %this.persistenceMgr.delete();
-}
-
-//-----------------------------------------------------------------------------
-
-function AddFMODProjectDlg::onCancel( %this )
-{
-   Canvas.popDialog( %this );
-}
-
-//-----------------------------------------------------------------------------
-
-function AddFMODProjectDlg::onOK( %this )
-{
-   %objName    = %this-->projectNameField.getText();
-   %fileName   = %this-->fileNameField.getText();
-   %mediaPath  = %this-->mediaPathField.getText();
-   
-   // Make sure the object name is valid.
-   if( !Editor::validateObjectName( %objName, true ))
-      return;
-
-   // Make sure the .fev file exists.
-   
-   if( %fileName $= "" )
-   {
-      toolsMessageBoxOK( "Error",
-         "Please enter a project file name."
-      );
-      return;
-   }
-   if( !isFile( %fileName ) )
-   {
-      toolsMessageBoxOK( "Error",
-         "'" @ %fileName @ "' is not a valid file."
-      );
-      return;
-   }
-   
-   // Make sure the media path exists.
-   
-   if( !isDirectory( %mediaPath ) )
-   {
-      toolsMessageBoxOK( "Error",
-         "'" @ %mediaPath @ "' is not a valid directory."
-      );
-      return;
-   }
-   
-   // If an event script exists from a previous instantiation,
-   // delete it first.
-   
-   %eventFileName = %fileName @ "." @ $TorqueScriptFileExtension;
-   if( isFile( %eventFileName ) )
-      fileDelete( %eventFileName );
-   
-   // Create the FMOD project object.
-   
-   pushInstantGroup();
-   eval( "new SFXFMODProject( " @ %objName @ ") {" NL
-      "fileName = \"" @ %fileName @ "\";" NL
-      "mediaPath = \"" @ %mediaPath @ "\";" NL
-   "};" );
-   popInstantGroup();
-   
-   if( !isObject( %objName ) )
-   {
-      toolsMessageBoxOK( "Error",
-         "Failed to create the object.  Please take a look at the log for details."
-      );
-      return;
-   }
-   else
-   {
-      // Save the object.
-
-      %objName.setFileName( "scripts/client/audioData." @ $TorqueScriptFileExtension );
-      %this.persistenceMgr.setDirty( %objName );
-      %this.persistenceMgr.saveDirty();
-   }
-      
-   Canvas.popDialog( %this );
-   
-   // Trigger a reinit on the datablock editor, just in case.
-   
-   if( isObject( DatablockEditorPlugin ) )
-      DatablockEditorPlugin.populateTrees();
-}
-
-//-----------------------------------------------------------------------------
-
-function AddFMODProjectDlg::onSelectFile( %this )
-{
-   if( $pref::WorldEditor::AddFMODProjectDlg::lastPath $= "" )
-      $pref::WorldEditor::AddFMODProjectDlg::lastPath = getMainDotCsDir();
-
-   %dlg = new OpenFileDialog()
-   {
-      Title       = "Select Compiled FMOD Designer Event File...";
-      Filters     = "Compiled Event Files (*.fev)|*.fev|All Files (*.*)|*.*|";
-      DefaultPath = $pref::WorldEditor::AddFMODProjectDlg::lastPath;
-      DefaultFile = fileName( %this-->fileNameField.getText() );
-      MustExit    = true;
-      ChangePath  = false;
-   };
-   
-   %ret = %dlg.execute();
-   if( %ret )
-   {
-      %file = %dlg.fileName;
-      $pref::WorldEditor::AddFMODProjectDlg::lastPath = filePath( %file );
-   }
-   
-   %dlg.delete();
-   
-   if( !%ret )
-      return;
-      
-   %file = makeRelativePath( %file, getMainDotCsDir() );
-   %this-->fileNameField.setText( %file );
-   
-   if( %this-->projectNameField.getText() $= "" )
-   {
-      %projectName = "fmod" @ fileBase( %file );
-      if( isValidObjectName( %projectName ) )
-         %this-->projectNameField.setText( %projectName );
-   }
-}
-
-//-----------------------------------------------------------------------------
-
-function AddFMODProjectDlg::onSelectMediaPath( %this )
-{
-   %defaultPath = %this-->mediaPathField.getText();
-   if( %defaultPath $= "" )
-   {
-      %defaultPath = filePath( %this-->fileNameField.getText() );
-      if( %defaultPath $= "" )
-         %defaultPath = getMainDotCsDir();
-      else
-         %defaultPath = makeFullPath( %defaultPath );
-   }
-
-   %dlg = new OpenFolderDialog()
-   {
-      Title       = "Select Media Path...";
-      DefaultPath = %defaultPath;
-      MustExit    = true;
-      ChangePath  = false;
-   };
-   
-   %ret = %dlg.execute();
-   if( %ret )
-      %file = %dlg.fileName;
-   
-   %dlg.delete();
-   
-   if( !%ret )
-      return;
-      
-   %file = makeRelativePath( %file, getMainDotCsDir() );
-   %this-->mediaPathField.setText( %file );
-}
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/menus.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/menus.ed.tscript
index 6e8348948..21eaea05a 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/menus.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/menus.ed.tscript
@@ -167,10 +167,7 @@ function EditorGui::buildMenus(%this)
       //item[6] = "Import Texture Data..." TAB "" TAB "Texture::import();";
       //item[7] = "-";
       //item[8] = "Export Terraform Data..." TAB "" TAB "Heightfield::saveBitmap(\"\");";
-   
-   %fileMenu.appendItem( "-" );
-   %fileMenu.appendItem( "Add FMOD Designer Audio..." TAB "" TAB "AddFMODProjectDlg.show();" );
-   
+  
    %fileMenu.appendItem("-");
    %fileMenu.appendItem("Play Level" TAB "F11" TAB "Editor.close(ProjectSettings.value(\"UI/playGUIName\"));");
       
diff --git a/Tools/CMake/torque3d.cmake b/Tools/CMake/torque3d.cmake
index 982050b4a..987a094b8 100644
--- a/Tools/CMake/torque3d.cmake
+++ b/Tools/CMake/torque3d.cmake
@@ -41,8 +41,6 @@ if(UNIX)
     set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
 endif()
 
-# TODO: fmod support
-
 ###############################################################################
 # modules
 ###############################################################################

From efb98d420dbff15f9f828e01c1ec49cdec59a332 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Sat, 11 Sep 2021 16:26:48 -0400
Subject: [PATCH 069/399] Fix local variable being eval'd in materialEditor

---
 .../tools/materialEditor/scripts/materialEditor.ed.tscript     | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
index 18197d09a..7f3fb2d43 100644
--- a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
@@ -1120,8 +1120,7 @@ function MaterialEditorGui::updateActiveMaterial(%this, %propertyField, %value,
       %action.isSlider = %isSlider;
       %action.onMouseUp = %onMouseUp;
       %action.newValue = %value;
-      eval( "%action.oldValue = " @ MaterialEditorGui.currentMaterial @ "." @ %propertyField @ ";");
-      %action.oldValue = "\"" @ %action.oldValue @ "\"";
+      %action.oldValue = "\"" @ MaterialEditorGui.currentMaterial.getFieldValue(%propertyField) @ "\"";
       MaterialEditorGui.submitUndo( %action );
    }
    

From 97584a9838144e1e58957e312a590646c18ce443 Mon Sep 17 00:00:00 2001
From: Areloch <Areloch@gmail.com>
Date: Sat, 11 Sep 2021 17:07:20 -0500
Subject: [PATCH 070/399] Fixes initial indexing of the tool palette widgets

---
 .../gui/ToolsPaletteGroups/init.tscript       | 26 +++++++------------
 1 file changed, 10 insertions(+), 16 deletions(-)

diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/init.tscript b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/init.tscript
index b6640e8fd..ff69e6a23 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/init.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/ToolsPaletteGroups/init.tscript
@@ -30,16 +30,13 @@ function EWToolsPaletteWindow::loadToolsPalettes()
       exec( %file );
       %paletteGroup = 0;      
       
-      // TODO
-      %paletteId = 0;
-
-      %i = %paletteId.getCount();
+      %i = $paletteId.getCount();
       for( ; %i != 0; %i--)
       {
-         %paletteId.getObject(0).visible = 0;
-         %paletteId.getObject(0).groupNum = %paletteGroup;
-         %paletteId.getObject(0).paletteName = %paletteId.getName();
-         ToolsPaletteArray.addGuiControl(%paletteId.getObject(0));
+         $paletteId.getObject(0).visible = 0;
+         $paletteId.getObject(0).groupNum = %paletteGroup;
+         $paletteId.getObject(0).paletteName = $paletteId.getName();
+         ToolsPaletteArray.addGuiControl($paletteId.getObject(0));
       }
       %paletteGroup++;
    }
@@ -52,16 +49,13 @@ function EWToolsPaletteWindow::loadToolsPalettes()
       exec( %file );
       %paletteGroup = 0;      
       
-      // TODO
-      %paletteId = 0;
-
-      %i = %paletteId.getCount();
+      %i = $paletteId.getCount();
       for( ; %i != 0; %i--)
       {
-         %paletteId.getObject(0).visible = 0;
-         %paletteId.getObject(0).groupNum = %paletteGroup;
-         %paletteId.getObject(0).paletteName = %paletteId.getName();
-         ToolsPaletteArray.addGuiControl(%paletteId.getObject(0));
+         $paletteId.getObject(0).visible = 0;
+         $paletteId.getObject(0).groupNum = %paletteGroup;
+         $paletteId.getObject(0).paletteName = $paletteId.getName();
+         ToolsPaletteArray.addGuiControl($paletteId.getObject(0));
       }
       %paletteGroup++;
    }

From 3bfb9a320a6f82945831d3dc17b4c59377473eae Mon Sep 17 00:00:00 2001
From: Areloch <Areloch@gmail.com>
Date: Sat, 11 Sep 2021 17:13:23 -0500
Subject: [PATCH 071/399] Updates Prototyping module. Reorganizes primitive
 shapes, adds some vehicle shapes, adds datablocks for prototyping wheeled,
 hover and flying vehicles.

---
 .../Prototyping/Materials/Glass.asset.taml    |   1 +
 .../data/Prototyping/Materials/Glass.tscript  | 192 +++++++
 .../game/data/Prototyping/Prototyping.tscript |   4 +
 .../data/Prototyping/datablocks/car.tscript   | 220 +++++++
 .../data/Prototyping/datablocks/flier.tscript | 147 +++++
 .../Prototyping/datablocks/hoverboat.tscript  |  67 +++
 .../game/data/Prototyping/scripts/car.tscript |  20 +
 .../data/Prototyping/scripts/flier.tscript    |  19 +
 .../{ => Primitives}/ConePrimitive.asset.taml |   0
 .../shapes/{ => Primitives}/ConePrimitive.fbx | Bin
 .../{ => Primitives}/ConePrimitive.tscript    |   0
 .../{ => Primitives}/CubePrimitive.asset.taml |   0
 .../shapes/{ => Primitives}/CubePrimitive.fbx | Bin
 .../{ => Primitives}/CubePrimitive.tscript    |   0
 .../CylinderPrimitive.asset.taml              |   0
 .../{ => Primitives}/CylinderPrimitive.fbx    | Bin
 .../CylinderPrimitive.tscript                 |   0
 .../SpherePrimitive.asset.taml                |   0
 .../{ => Primitives}/SpherePrimitive.fbx      | Bin
 .../{ => Primitives}/SpherePrimitive.tscript  |   0
 .../TorusPrimitive.asset.taml                 |   0
 .../{ => Primitives}/TorusPrimitive.fbx       | Bin
 .../{ => Primitives}/TorusPrimitive.tscript   |   0
 .../{ => Primitives}/TubePrimitive.asset.taml |   0
 .../shapes/{ => Primitives}/TubePrimitive.fbx | Bin
 .../{ => Primitives}/TubePrimitive.tscript    |   0
 .../shapes/Vehicles/Car.asset.taml            |   1 +
 .../data/Prototyping/shapes/Vehicles/car.dae  | 537 ++++++++++++++++++
 .../Prototyping/shapes/Vehicles/car.tscript   |  11 +
 .../shapes/Vehicles/carwheel.asset.taml       |   1 +
 .../Prototyping/shapes/Vehicles/carwheel.dae  | 140 +++++
 .../shapes/Vehicles/carwheel.tscript          |  11 +
 .../shapes/Vehicles/flier.asset.taml          |   1 +
 .../Prototyping/shapes/Vehicles/flier.dae     | 253 +++++++++
 .../Prototyping/shapes/Vehicles/flier.tscript |  11 +
 .../shapes/Vehicles/hoverboat.asset.taml      |   1 +
 .../Prototyping/shapes/Vehicles/hoverboat.dae | 156 +++++
 .../shapes/Vehicles/hoverboat.tscript         |  11 +
 .../data/Prototyping/shapes/materials.tscript |   8 -
 39 files changed, 1804 insertions(+), 8 deletions(-)
 create mode 100644 Templates/BaseGame/game/data/Prototyping/Materials/Glass.asset.taml
 create mode 100644 Templates/BaseGame/game/data/Prototyping/Materials/Glass.tscript
 create mode 100644 Templates/BaseGame/game/data/Prototyping/datablocks/car.tscript
 create mode 100644 Templates/BaseGame/game/data/Prototyping/datablocks/flier.tscript
 create mode 100644 Templates/BaseGame/game/data/Prototyping/datablocks/hoverboat.tscript
 create mode 100644 Templates/BaseGame/game/data/Prototyping/scripts/car.tscript
 create mode 100644 Templates/BaseGame/game/data/Prototyping/scripts/flier.tscript
 rename Templates/BaseGame/game/data/Prototyping/shapes/{ => Primitives}/ConePrimitive.asset.taml (100%)
 rename Templates/BaseGame/game/data/Prototyping/shapes/{ => Primitives}/ConePrimitive.fbx (100%)
 rename Templates/BaseGame/game/data/Prototyping/shapes/{ => Primitives}/ConePrimitive.tscript (100%)
 rename Templates/BaseGame/game/data/Prototyping/shapes/{ => Primitives}/CubePrimitive.asset.taml (100%)
 rename Templates/BaseGame/game/data/Prototyping/shapes/{ => Primitives}/CubePrimitive.fbx (100%)
 rename Templates/BaseGame/game/data/Prototyping/shapes/{ => Primitives}/CubePrimitive.tscript (100%)
 rename Templates/BaseGame/game/data/Prototyping/shapes/{ => Primitives}/CylinderPrimitive.asset.taml (100%)
 rename Templates/BaseGame/game/data/Prototyping/shapes/{ => Primitives}/CylinderPrimitive.fbx (100%)
 rename Templates/BaseGame/game/data/Prototyping/shapes/{ => Primitives}/CylinderPrimitive.tscript (100%)
 rename Templates/BaseGame/game/data/Prototyping/shapes/{ => Primitives}/SpherePrimitive.asset.taml (100%)
 rename Templates/BaseGame/game/data/Prototyping/shapes/{ => Primitives}/SpherePrimitive.fbx (100%)
 rename Templates/BaseGame/game/data/Prototyping/shapes/{ => Primitives}/SpherePrimitive.tscript (100%)
 rename Templates/BaseGame/game/data/Prototyping/shapes/{ => Primitives}/TorusPrimitive.asset.taml (100%)
 rename Templates/BaseGame/game/data/Prototyping/shapes/{ => Primitives}/TorusPrimitive.fbx (100%)
 rename Templates/BaseGame/game/data/Prototyping/shapes/{ => Primitives}/TorusPrimitive.tscript (100%)
 rename Templates/BaseGame/game/data/Prototyping/shapes/{ => Primitives}/TubePrimitive.asset.taml (100%)
 rename Templates/BaseGame/game/data/Prototyping/shapes/{ => Primitives}/TubePrimitive.fbx (100%)
 rename Templates/BaseGame/game/data/Prototyping/shapes/{ => Primitives}/TubePrimitive.tscript (100%)
 create mode 100644 Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/Car.asset.taml
 create mode 100644 Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/car.dae
 create mode 100644 Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/car.tscript
 create mode 100644 Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/carwheel.asset.taml
 create mode 100644 Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/carwheel.dae
 create mode 100644 Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/carwheel.tscript
 create mode 100644 Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/flier.asset.taml
 create mode 100644 Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/flier.dae
 create mode 100644 Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/flier.tscript
 create mode 100644 Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/hoverboat.asset.taml
 create mode 100644 Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/hoverboat.dae
 create mode 100644 Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/hoverboat.tscript
 delete mode 100644 Templates/BaseGame/game/data/Prototyping/shapes/materials.tscript

diff --git a/Templates/BaseGame/game/data/Prototyping/Materials/Glass.asset.taml b/Templates/BaseGame/game/data/Prototyping/Materials/Glass.asset.taml
new file mode 100644
index 000000000..cc68824b9
--- /dev/null
+++ b/Templates/BaseGame/game/data/Prototyping/Materials/Glass.asset.taml
@@ -0,0 +1 @@
+<MaterialAsset canSave="true" canSaveDynamicFields="true" AssetName="Glass" scriptFile="@assetFile=Glass.tscript" materialDefinitionName="Glass" VersionId="1"/>
diff --git a/Templates/BaseGame/game/data/Prototyping/Materials/Glass.tscript b/Templates/BaseGame/game/data/Prototyping/Materials/Glass.tscript
new file mode 100644
index 000000000..a3d239a75
--- /dev/null
+++ b/Templates/BaseGame/game/data/Prototyping/Materials/Glass.tscript
@@ -0,0 +1,192 @@
+//--- OBJECT WRITE BEGIN ---
+new Material(Glass) {
+   diffuseColor[0] = "1 1 1 1";
+   diffuseColor[1] = "1 1 1 1";
+   diffuseColor[2] = "1 1 1 1";
+   diffuseColor[3] = "1 1 1 1";
+   diffuseMapSRGB[0] = "1";
+   diffuseMapSRGB[1] = "1";
+   diffuseMapSRGB[2] = "1";
+   diffuseMapSRGB[3] = "1";
+   detailScale[0] = "2 2";
+   detailScale[1] = "2 2";
+   detailScale[2] = "2 2";
+   detailScale[3] = "2 2";
+   detailNormalMapStrength[0] = "1";
+   detailNormalMapStrength[1] = "1";
+   detailNormalMapStrength[2] = "1";
+   detailNormalMapStrength[3] = "1";
+   roughness[0] = "1";
+   roughness[1] = "1";
+   roughness[2] = "1";
+   roughness[3] = "1";
+   metalness[0] = "0";
+   metalness[1] = "0";
+   metalness[2] = "0";
+   metalness[3] = "0";
+   glowMul[0] = "0";
+   glowMul[1] = "0";
+   glowMul[2] = "0";
+   glowMul[3] = "0";
+   accuEnabled[0] = "0";
+   accuEnabled[1] = "0";
+   accuEnabled[2] = "0";
+   accuEnabled[3] = "0";
+   accuScale[0] = "1";
+   accuScale[1] = "1";
+   accuScale[2] = "1";
+   accuScale[3] = "1";
+   accuDirection[0] = "1";
+   accuDirection[1] = "1";
+   accuDirection[2] = "1";
+   accuDirection[3] = "1";
+   accuStrength[0] = "0.6";
+   accuStrength[1] = "0.6";
+   accuStrength[2] = "0.6";
+   accuStrength[3] = "0.6";
+   accuCoverage[0] = "0.9";
+   accuCoverage[1] = "0.9";
+   accuCoverage[2] = "0.9";
+   accuCoverage[3] = "0.9";
+   accuSpecular[0] = "16";
+   accuSpecular[1] = "16";
+   accuSpecular[2] = "16";
+   accuSpecular[3] = "16";
+   isSRGB[0] = "0";
+   isSRGB[1] = "0";
+   isSRGB[2] = "0";
+   isSRGB[3] = "0";
+   invertRoughness[0] = "0";
+   invertRoughness[1] = "0";
+   invertRoughness[2] = "0";
+   invertRoughness[3] = "0";
+   roughnessChan[0] = "0";
+   roughnessChan[1] = "0";
+   roughnessChan[2] = "0";
+   roughnessChan[3] = "0";
+   AOChan[0] = "1";
+   AOChan[1] = "1";
+   AOChan[2] = "1";
+   AOChan[3] = "1";
+   metalChan[0] = "2";
+   metalChan[1] = "2";
+   metalChan[2] = "2";
+   metalChan[3] = "2";
+   glow[0] = "0";
+   glow[1] = "0";
+   glow[2] = "0";
+   glow[3] = "0";
+   parallaxScale[0] = "0";
+   parallaxScale[1] = "0";
+   parallaxScale[2] = "0";
+   parallaxScale[3] = "0";
+   useAnisotropic[0] = "1";
+   useAnisotropic[1] = "1";
+   useAnisotropic[2] = "1";
+   useAnisotropic[3] = "1";
+   vertLit[0] = "0";
+   vertLit[1] = "0";
+   vertLit[2] = "0";
+   vertLit[3] = "0";
+   vertColor[0] = "0";
+   vertColor[1] = "0";
+   vertColor[2] = "0";
+   vertColor[3] = "0";
+   minnaertConstant[0] = "-1";
+   minnaertConstant[1] = "-1";
+   minnaertConstant[2] = "-1";
+   minnaertConstant[3] = "-1";
+   subSurface[0] = "0";
+   subSurface[1] = "0";
+   subSurface[2] = "0";
+   subSurface[3] = "0";
+   subSurfaceColor[0] = "1 0.2 0.2 1";
+   subSurfaceColor[1] = "1 0.2 0.2 1";
+   subSurfaceColor[2] = "1 0.2 0.2 1";
+   subSurfaceColor[3] = "1 0.2 0.2 1";
+   subSurfaceRolloff[0] = "0.2";
+   subSurfaceRolloff[1] = "0.2";
+   subSurfaceRolloff[2] = "0.2";
+   subSurfaceRolloff[3] = "0.2";
+   emissive[0] = "0";
+   emissive[1] = "0";
+   emissive[2] = "0";
+   emissive[3] = "0";
+   doubleSided = "0";
+   animFlags[0] = "0x00000000";
+   animFlags[1] = "0x00000000";
+   animFlags[2] = "0x00000000";
+   animFlags[3] = "0x00000000";
+   scrollDir[0] = "0 0";
+   scrollDir[1] = "0 0";
+   scrollDir[2] = "0 0";
+   scrollDir[3] = "0 0";
+   scrollSpeed[0] = "0";
+   scrollSpeed[1] = "0";
+   scrollSpeed[2] = "0";
+   scrollSpeed[3] = "0";
+   rotSpeed[0] = "0";
+   rotSpeed[1] = "0";
+   rotSpeed[2] = "0";
+   rotSpeed[3] = "0";
+   rotPivotOffset[0] = "0 0";
+   rotPivotOffset[1] = "0 0";
+   rotPivotOffset[2] = "0 0";
+   rotPivotOffset[3] = "0 0";
+   waveType[0] = "Sin";
+   waveType[1] = "Sin";
+   waveType[2] = "Sin";
+   waveType[3] = "Sin";
+   waveFreq[0] = "0";
+   waveFreq[1] = "0";
+   waveFreq[2] = "0";
+   waveFreq[3] = "0";
+   waveAmp[0] = "0";
+   waveAmp[1] = "0";
+   waveAmp[2] = "0";
+   waveAmp[3] = "0";
+   sequenceFramePerSec[0] = "0";
+   sequenceFramePerSec[1] = "0";
+   sequenceFramePerSec[2] = "0";
+   sequenceFramePerSec[3] = "0";
+   sequenceSegmentSize[0] = "0";
+   sequenceSegmentSize[1] = "0";
+   sequenceSegmentSize[2] = "0";
+   sequenceSegmentSize[3] = "0";
+   cellIndex[0] = "0 0";
+   cellIndex[1] = "0 0";
+   cellIndex[2] = "0 0";
+   cellIndex[3] = "0 0";
+   cellLayout[0] = "0 0";
+   cellLayout[1] = "0 0";
+   cellLayout[2] = "0 0";
+   cellLayout[3] = "0 0";
+   cellSize[0] = "0";
+   cellSize[1] = "0";
+   cellSize[2] = "0";
+   cellSize[3] = "0";
+   bumpAtlas[0] = "0";
+   bumpAtlas[1] = "0";
+   bumpAtlas[2] = "0";
+   bumpAtlas[3] = "0";
+   castShadows = "1";
+   planarReflection = "0";
+   translucent = "1";
+   translucentBlendOp = "PreMul";
+   translucentZWrite = "0";
+   alphaTest = "0";
+   alphaRef = "1";
+   dynamicCubemap = "0";
+   showFootprints = "1";
+   showDust = "0";
+   effectColor[0] = "0 0 0 0";
+   effectColor[1] = "0 0 0 0";
+   footstepSoundId = "-1";
+   impactSoundId = "-1";
+   ImpactFXIndex = "-1";
+   canSave = "1";
+   canSaveDynamicFields = "1";
+   DiffuseMapAsset[0] = "Prototyping:WaterBlue_ALBEDO";
+   originalAssetName = "Glass";
+};
+//--- OBJECT WRITE END ---
diff --git a/Templates/BaseGame/game/data/Prototyping/Prototyping.tscript b/Templates/BaseGame/game/data/Prototyping/Prototyping.tscript
index e9a1eff28..73a1dc447 100644
--- a/Templates/BaseGame/game/data/Prototyping/Prototyping.tscript
+++ b/Templates/BaseGame/game/data/Prototyping/Prototyping.tscript
@@ -9,11 +9,15 @@ function Prototyping::onDestroy(%this)
 //This is called when the server is initially set up by the game application
 function Prototyping::initServer(%this)
 {
+   %this.queueExec("./scripts/car");
 }
 
 //This is called when the server is created for an actual game/map to be played
 function Prototyping::onCreateGameServer(%this)
 {
+   %this.registerDatablock("./datablocks/hoverboat.tscript");
+   %this.registerDatablock("./datablocks/car.tscript");
+   %this.registerDatablock("./datablocks/flier.tscript");
 }
 
 //This is called when the server is shut down due to the game/map being exited
diff --git a/Templates/BaseGame/game/data/Prototyping/datablocks/car.tscript b/Templates/BaseGame/game/data/Prototyping/datablocks/car.tscript
new file mode 100644
index 000000000..2a22e8bba
--- /dev/null
+++ b/Templates/BaseGame/game/data/Prototyping/datablocks/car.tscript
@@ -0,0 +1,220 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2012 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+/*
+datablock SFXProfile(cheetahEngine)
+{
+   preload = "1";
+   description = "AudioCloseLoop3D";
+   fileName = "data/FPSGameplay/sound/cheetah/cheetah_engine.ogg";
+};
+
+datablock SFXProfile(cheetahSqueal)
+{
+   preload = "1";
+   description = "AudioDefault3D";
+   fileName = "data/FPSGameplay/sound/cheetah/cheetah_squeal.ogg";
+};
+
+datablock SFXProfile(hardImpact)
+{
+   preload = "1";
+   description = "AudioDefault3D";
+   fileName = "data/FPSGameplay/sound/cheetah/hardImpact.ogg";
+};
+
+datablock SFXProfile(softImpact)
+{
+   preload = "1";
+   description = "AudioDefault3D";
+   fileName = "data/FPSGameplay/sound/cheetah/softImpact.ogg";
+};
+
+datablock SFXProfile(DirtKickup)
+{
+   preload = "1";
+   description = "AudioDefault3D";
+   fileName = "data/FPSGameplay/sound/cheetah/softImpact.ogg";
+};
+
+datablock SFXProfile(CheetahTurretFireSound)
+{
+   //filename = "data/FPSGameplay/sound/cheetah/turret_firing.wav";
+   filename = "data/FPSGameplay/sound/turret/wpn_turret_fire.wav";
+   description = BulletFireDesc;
+   preload = true;
+};
+
+datablock ParticleData(CheetahTireParticle)
+{
+   textureName          = "data/FPSGameplay/art/particles/dustParticle";
+   dragCoefficient      = "1.99902";
+   gravityCoefficient   = "-0.100122";
+   inheritedVelFactor   = "0.0998043";
+   constantAcceleration = 0.0;
+   lifetimeMS           = 1000;
+   lifetimeVarianceMS   = 400;
+   colors[0]            = "0.456693 0.354331 0.259843 1";
+   colors[1]            = "0.456693 0.456693 0.354331 0";
+   sizes[0]             = "0.997986";
+   sizes[1]             = "3.99805";
+   sizes[2]             = "1.0";
+   sizes[3]             = "1.0";
+   times[0]             = "0.0";
+   times[1]             = "1";
+   times[2]             = "1";
+   times[3]             = "1";
+};
+
+datablock ParticleEmitterData(CheetahTireEmitter)
+{
+   ejectionPeriodMS = 20;
+   periodVarianceMS = 10;
+   ejectionVelocity = "14.57";
+   velocityVariance = 1.0;
+   ejectionOffset   = 0.0;
+   thetaMin         = 0;
+   thetaMax         = 60;
+   phiReferenceVel  = 0;
+   phiVariance      = 360;
+   overrideAdvance = false;
+   particles = "CheetahTireParticle";
+   blendStyle = "ADDITIVE";
+};*/
+
+//-----------------------------------------------------------------------------
+// Information extacted from the shape.
+//
+// Wheel Sequences
+//    spring#        Wheel spring motion: time 0 = wheel fully extended,
+//                   the hub must be displaced, but not directly animated
+//                   as it will be rotated in code.
+// Other Sequences
+//    steering       Wheel steering: time 0 = full right, 0.5 = center
+//    breakLight     Break light, time 0 = off, 1 = breaking
+//
+// Wheel Nodes
+//    hub#           Wheel hub, the hub must be in it's upper position
+//                   from which the springs are mounted.
+//
+// The steering and animation sequences are optional.
+// The center of the shape acts as the center of mass for the car.
+
+//-----------------------------------------------------------------------------
+datablock WheeledVehicleTire(CarTire)
+{
+   // Tires act as springs and generate lateral and longitudinal
+   // forces to move the vehicle. These distortion/spring forces
+   // are what convert wheel angular velocity into forces that
+   // act on the rigid body.
+   shapeAsset = "Prototyping:carwheel";
+   staticFriction = 4.2;
+   kineticFriction = "1";
+
+   // Spring that generates lateral tire forces
+   lateralForce = 18000;
+   lateralDamping = 6000;
+   lateralRelaxation = 1;
+
+   // Spring that generates longitudinal tire forces
+   longitudinalForce = 18000;
+   longitudinalDamping = 4000;
+   longitudinalRelaxation = 1;
+   radius = "0.609998";
+};
+
+datablock WheeledVehicleSpring(CarSpring)
+{
+   // Wheel suspension properties
+   length = 0.5;             // Suspension travel
+   force = 2800;              // Spring force
+   damping = 3600;             // Spring damping
+   antiSwayForce = 3;         // Lateral anti-sway force
+};
+
+datablock WheeledVehicleData(Car)
+{
+   category = "Vehicles";
+   emap = 1;
+
+   mountPose[0] = sitting;
+   numMountPoints = 6;
+
+   useEyePoint = true;  // Use the vehicle's camera node rather than the player's
+
+   maxSteeringAngle = 0.585;  // Maximum steering angle, should match animation
+
+   // 3rd person camera settings
+   cameraRoll = false;        // Roll the camera with the vehicle
+   cameraMaxDist = 7.8;       // Far distance from vehicle
+   cameraOffset = 1.0;        // Vertical offset from camera mount point
+   cameraLag = "0.3";           // Velocity lag of camera
+   cameraDecay = 1.25;        // Decay per sec. rate of velocity lag
+
+   // Rigid Body
+   mass = "400";
+   massCenter = "0 0.5 0";    // Center of mass for rigid body
+   massBox = "0 0 0";         // Size of box used for moment of inertia,
+                              // if zero it defaults to object bounding box
+   drag = 0.6;                // Drag coefficient
+   bodyFriction = 0.6;
+   bodyRestitution = 0.4;
+   minImpactSpeed = 5;        // Impacts over this invoke the script callback
+   softImpactSpeed = 5;       // Play SoftImpact Sound
+   hardImpactSpeed = 15;      // Play HardImpact Sound
+   integration = 8;           // Physics integration: TickSec/Rate
+   collisionTol = "0.1";        // Collision distance tolerance
+   contactTol = "0.4";          // Contact velocity tolerance
+
+   // Engine
+   engineTorque = 4300;       // Engine power
+   engineBrake = "5000";         // Braking when throttle is 0
+   brakeTorque = "10000";        // When brakes are applied
+   maxWheelSpeed = 50;        // Engine scale by current speed / max speed
+
+   // Energy
+   maxEnergy = 100;
+   jetForce = 3000;
+   minJetEnergy = 30;
+   jetEnergyDrain = 2;
+
+   // Sounds
+   //engineSound = cheetahEngine;
+   //squealSound = cheetahSqueal;
+   //softImpactSound = softImpact;
+   //hardImpactSound = hardImpact;
+
+   // Dynamic fields accessed via script
+   nameTag = 'Cheetah';
+   maxDismountSpeed = 10;
+   maxMountSpeed = 5;
+   mountPose0 = "sitting";
+  // tireEmitter = "CheetahTireEmitter";
+  // dustEmitter = "CheetahTireEmitter";
+   dustHeight = "1";
+
+   // Mount slots
+   turretSlot = 1;
+   rightBrakeSlot = 2;
+   leftBrakeSlot = 3;
+   dragForce = "0.01";
+   ShapeAsset = "Prototyping:car";
+};
diff --git a/Templates/BaseGame/game/data/Prototyping/datablocks/flier.tscript b/Templates/BaseGame/game/data/Prototyping/datablocks/flier.tscript
new file mode 100644
index 000000000..06820acad
--- /dev/null
+++ b/Templates/BaseGame/game/data/Prototyping/datablocks/flier.tscript
@@ -0,0 +1,147 @@
+//Flying Vehicle
+//---------------------------------------------------------------------------------------
+datablock FlyingVehicleData(Flier)
+{
+	spawnOffset						= "0 0 2";
+	category						   = "Vehicles";
+	shapeAsset						= "Prototyping:flier";
+	multipassenger					= false;
+	computeCRC						= true;
+									
+	//debrisShapeName					= "~/data/shapes/vehicles/Drone/flyer.dts";
+	//debris							= DroneShapeDebris;
+	//renderWhenDestroyed				= false;
+
+	drag							= 0.15;
+	density							= 3.0;
+
+	mountPose[0]					= sitting;
+	numMountPoints					= 1;
+	isProtectedMountPoint[0]		= true;
+	cameraMaxDist					= 0.5;
+	cameraOffset					= 4.5;
+	cameraLag						= 0.0;
+    cameraRoll = true;         // Roll the camera with the vehicle
+
+
+
+    // explosion						= DroneVehicleExplosion;
+	explosionDamage					= 10.5;
+	explosionRadius					= 15.0;
+
+	maxDamage						= 50.40;
+	destroyedLevel					= 50.40;
+									
+	isShielded						= true; 
+	energyPerDamagePoint			= 160;
+	maxEnergy						= 280;      // Afterburner and any energy weapon pool
+	rechargeRate					= 0.8;
+
+	minDrag							= 30;           // Linear Drag (eventually slows you down when not thrusting...constant drag)
+	rotationalDrag					= 10;        // Anguler Drag (dampens the drift after you stop moving the mouse...also tumble drag)
+
+	maxAutoSpeed					= 10;       // Autostabilizer kicks in when less than this speed. (meters/second)
+	autoAngularForce				= 200;       // Angular stabilizer force (this force levels you out when autostabilizer kicks in)
+	autoLinearForce					= 200;        // Linear stabilzer force (this slows you down when autostabilizer kicks in)
+	autoInputDamping				= 0.95;      // Dampen control input so you don't` whack out at very slow speeds
+    integration = 6;           // Physics integration: TickSec/Rate
+    collisionTol = 0.2;        // Collision distance tolerance
+    contactTol = 0.1;
+   
+	// Maneuvering
+	maxSteeringAngle				= 3;    // Max radiens you can rotate the wheel. Smaller number is more maneuverable.
+	horizontalSurfaceForce			= 6;   // Horizontal center "wing" (provides "bite" into the wind for climbing/diving and turning)
+	verticalSurfaceForce			= 4;     // Vertical center "wing" (controls side slip. lower numbers make MORE slide.)
+	maneuveringForce				= 2400;      // Horizontal jets (W,S,D,A key thrust)
+	steeringForce					= 50;         // Steering jets (force applied when you move the mouse)
+	steeringRollForce				= 10;      // Steering jets (how much you heel over when you turn)
+	rollForce						= 80;  // Auto-roll (self-correction to right you after you roll/invert)
+	hoverHeight						= 45;       // Height off the ground at rest
+	createHoverHeight				= 45;  // Height off the ground when created
+	maxForwardSpeed					= 60;  // speed in which forward thrust force is no longer applied (meters/second)
+
+	// Turbo Jet
+	jetForce						= 3000;      // Afterburner thrust (this is in addition to normal thrust)
+	minJetEnergy					= 28;     // Afterburner can't be used if below this threshhold.
+	jetEnergyDrain					= 2.8;       // Energy use of the afterburners (low number is less drain...can be fractional)                                                                                                                                                                                                                                                                                          // Auto stabilize speed
+	vertThrustMultiple				= 3.0;
+
+	// Rigid body
+	mass							= 30;        // Mass of the vehicle
+	bodyFriction					= 0;     // Don't mess with this.
+	bodyRestitution					= 1.0;   // When you hit the ground, how much you rebound. (between 0 and 1)
+	minRollSpeed					= 2000;     // Don't mess with this.
+	softImpactSpeed					= 3;       // Sound hooks. This is the soft hit.
+	hardImpactSpeed					= 15;    // Sound hooks. This is the hard hit.
+
+	// Ground Impact Damage (uses DamageType::Ground)
+	minImpactSpeed					= 10;      // If hit ground at speed above this then it's an impact. Meters/second
+	speedDamageScale				= 0.06;
+
+	// Object Impact Damage (uses DamageType::Impact)
+	collDamageThresholdVel			= 23.0;
+	collDamageMultiplier			= 0.02;
+
+	//
+	minTrailSpeed					= 15;      // The speed your contrail shows up at.
+	//trailEmitter					= DroneContrailEmitter;
+	//forwardJetEmitter				= DroneJetEmitter;
+	//downJetEmitter					= DroneJetEmitter;
+
+	//
+	//jetSound						= DroneThrustSound;
+	//engineSound						= DroneEngineSound;
+	//softImpactSound					= DroneSoftImpactSound;
+	//hardImpactSound					= DroneHardImpactSound;
+	//
+	//softSplashSoundVelocity			= 10.0;
+	//mediumSplashSoundVelocity		= 15.0;
+	//hardSplashSoundVelocity			= 20.0;
+	//exitSplashSoundVelocity			= 10.0;
+
+	//exitingWater					= DroneExitWaterMediumSound;
+	//impactWaterEasy					= DroneImpactWaterSoftSound;
+	//impactWaterMedium				= DroneImpactWaterMediumSound;
+	//impactWaterHard					= DroneImpactWaterMediumSound;
+	//waterWakeSound					= DroneWakeMediumSplashSound;
+
+//	dustEmitter						= VehicleLiftoffDustEmitter;
+	
+	triggerDustHeight				= 4.0;
+	dustHeight						= 1.0;
+
+//	damageEmitter[0]				= LightDamageSmoke;
+
+//	damageEmitter[1]				= HeavyDamageSmoke;
+
+//	damageEmitter[2]				= DamageBubbles;
+
+	damageEmitterOffset[0]			= "0.0 -3.0 0.0 ";
+	damageLevelTolerance[0]			= 0.3;
+	damageLevelTolerance[1]			= 0.7;
+	numDmgEmitterAreas				= 3;
+						
+	//
+	//max[RocketAmmo]					= 1000;
+
+	minMountDist					= 2;
+
+	//splashEmitter[0]				= VehicleFoamDropletsEmitter;
+	//splashEmitter[1]				= VehicleFoamEmitter;
+
+	//shieldImpact					= VehicleShieldImpact;
+
+	//cmdCategory						= "Tactical";
+	//cmdIcon							= CMDFlyingScoutIcon;
+	//cmdMiniIconName					= "commander/MiniIcons/com_scout_grey";
+	//targetNameTag					= 'Drone';
+	//targetTypeTag					= 'FlyingVehicle';
+	//sensorData						= AWACPulseSensor;
+	//sensorRadius					= AWACPulseSensor.detectRadius;
+	//sensorColor						= "255 194 9";
+									
+	checkRadius						= 5.5;
+	observeParameters				= "0 0 0";
+									
+	shieldEffectScale				= "0.937 1.125 0.60";
+};
diff --git a/Templates/BaseGame/game/data/Prototyping/datablocks/hoverboat.tscript b/Templates/BaseGame/game/data/Prototyping/datablocks/hoverboat.tscript
new file mode 100644
index 000000000..cd5afd471
--- /dev/null
+++ b/Templates/BaseGame/game/data/Prototyping/datablocks/hoverboat.tscript
@@ -0,0 +1,67 @@
+datablock HoverVehicleData(hoverboat)
+{
+   spawnOffset = "0 0 1";
+
+   floatingGravMag = 55.5;
+   ShapeAsset = "Prototyping:hoverboat";
+   category = "Vehicles";
+   emap = 1;
+
+   category = "Vehicle";
+
+
+    drag = 0.2;
+      density = 0.3;
+      hoverHeight = 3;              // Height off the ground at rest
+      createHoverHeight = 3;
+      integration = 4;           // Physics integration: TickSec/Rate
+      collisionTol = 0.3;        // Collision distance tolerance
+      contactTol = 0.2;          // Contact velocity tolerance
+
+      cameraMaxDist = "4.23615";
+      cameraOffset = 5.7;
+      cameraLag = 5.5;
+
+      explosionDamage = 0.5;
+      explosionRadius = 5;
+
+      rechargeRate = 0.7;
+      energyPerDamagePoint = 75;
+      maxEnergy = 650;
+      minJetEnergy = 165;
+      jetEnergyDrain = 1.3;
+
+   // Rigid Body
+      mass = "2";
+      bodyFriction = 0.1;
+      bodyRestitution = 0.3;
+      softImpactSpeed = 20; // Play SoftImpact Sound
+      hardImpactSpeed = 28; // Play HardImpact Sound
+
+
+       dragForce = 1.0;
+    // dragForce = 25 / 45.0;
+       vertFactor = 0.8;
+       floatingThrustFactor = 0.5;
+
+       mainThrustForce = "20";
+       reverseThrustForce = "10";
+       strafeThrustForce = "25";
+       turboFactor = 1.5;
+
+       brakingForce = "20";
+       brakingActivationSpeed = 30;
+
+       stabLenMin = "1.5"; //was 3
+       stabLenMax = "2.5"; //was 4
+       stabSpringConstant = "25";
+       stabDampingConstant = 28;
+
+       gyroDrag = 18; // 16
+       //gyroForce = 50;
+       normalForce = "30";
+       restorativeForce = "19000";
+       steeringForce = "30";
+       rollForce = "0";
+       pitchForce = 30;
+};
diff --git a/Templates/BaseGame/game/data/Prototyping/scripts/car.tscript b/Templates/BaseGame/game/data/Prototyping/scripts/car.tscript
new file mode 100644
index 000000000..8b37727fc
--- /dev/null
+++ b/Templates/BaseGame/game/data/Prototyping/scripts/car.tscript
@@ -0,0 +1,20 @@
+function Car::onAdd(%this, %obj)
+{
+   Parent::onAdd(%this, %obj);
+
+   %obj.setWheelTire(0,CarTire);
+   %obj.setWheelTire(1,CarTire);
+   %obj.setWheelTire(2,CarTire);
+   %obj.setWheelTire(3,CarTire);
+
+   // Setup the car with some tires & springs
+   for (%i = %obj.getWheelCount() - 1; %i >= 0; %i--)
+   {
+      %obj.setWheelPowered(%i, true);
+      %obj.setWheelSpring(%i, CarSpring);
+   }
+
+   // Steer with the front tires
+   %obj.setWheelSteering(0, 1);
+   %obj.setWheelSteering(1, 1);
+}
\ No newline at end of file
diff --git a/Templates/BaseGame/game/data/Prototyping/scripts/flier.tscript b/Templates/BaseGame/game/data/Prototyping/scripts/flier.tscript
new file mode 100644
index 000000000..32b29a652
--- /dev/null
+++ b/Templates/BaseGame/game/data/Prototyping/scripts/flier.tscript
@@ -0,0 +1,19 @@
+function Flier::onDamage(%this, %obj, %delta)
+{
+	Parent::onDamage(%this, %obj);
+	%currentDamage = %obj.getDamageLevel();
+	if(%currentDamage > %obj.destroyedLevel)
+	{
+		if(%obj.getDamageState() !$= "Destroyed")
+		{
+			if(%obj.respawnTime !$= "")
+				%obj.marker.schedule = %obj.marker.data.schedule(%obj.respawnTime, "respawn", %obj.marker); 
+			%obj.setDamageState(Destroyed);
+		}
+	}
+	else
+	{
+		if(%obj.getDamageState() !$= "Enabled")
+			%obj.setDamageState(Enabled);
+	}
+}
\ No newline at end of file
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/ConePrimitive.asset.taml b/Templates/BaseGame/game/data/Prototyping/shapes/Primitives/ConePrimitive.asset.taml
similarity index 100%
rename from Templates/BaseGame/game/data/Prototyping/shapes/ConePrimitive.asset.taml
rename to Templates/BaseGame/game/data/Prototyping/shapes/Primitives/ConePrimitive.asset.taml
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/ConePrimitive.fbx b/Templates/BaseGame/game/data/Prototyping/shapes/Primitives/ConePrimitive.fbx
similarity index 100%
rename from Templates/BaseGame/game/data/Prototyping/shapes/ConePrimitive.fbx
rename to Templates/BaseGame/game/data/Prototyping/shapes/Primitives/ConePrimitive.fbx
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/ConePrimitive.tscript b/Templates/BaseGame/game/data/Prototyping/shapes/Primitives/ConePrimitive.tscript
similarity index 100%
rename from Templates/BaseGame/game/data/Prototyping/shapes/ConePrimitive.tscript
rename to Templates/BaseGame/game/data/Prototyping/shapes/Primitives/ConePrimitive.tscript
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/CubePrimitive.asset.taml b/Templates/BaseGame/game/data/Prototyping/shapes/Primitives/CubePrimitive.asset.taml
similarity index 100%
rename from Templates/BaseGame/game/data/Prototyping/shapes/CubePrimitive.asset.taml
rename to Templates/BaseGame/game/data/Prototyping/shapes/Primitives/CubePrimitive.asset.taml
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/CubePrimitive.fbx b/Templates/BaseGame/game/data/Prototyping/shapes/Primitives/CubePrimitive.fbx
similarity index 100%
rename from Templates/BaseGame/game/data/Prototyping/shapes/CubePrimitive.fbx
rename to Templates/BaseGame/game/data/Prototyping/shapes/Primitives/CubePrimitive.fbx
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/CubePrimitive.tscript b/Templates/BaseGame/game/data/Prototyping/shapes/Primitives/CubePrimitive.tscript
similarity index 100%
rename from Templates/BaseGame/game/data/Prototyping/shapes/CubePrimitive.tscript
rename to Templates/BaseGame/game/data/Prototyping/shapes/Primitives/CubePrimitive.tscript
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/CylinderPrimitive.asset.taml b/Templates/BaseGame/game/data/Prototyping/shapes/Primitives/CylinderPrimitive.asset.taml
similarity index 100%
rename from Templates/BaseGame/game/data/Prototyping/shapes/CylinderPrimitive.asset.taml
rename to Templates/BaseGame/game/data/Prototyping/shapes/Primitives/CylinderPrimitive.asset.taml
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/CylinderPrimitive.fbx b/Templates/BaseGame/game/data/Prototyping/shapes/Primitives/CylinderPrimitive.fbx
similarity index 100%
rename from Templates/BaseGame/game/data/Prototyping/shapes/CylinderPrimitive.fbx
rename to Templates/BaseGame/game/data/Prototyping/shapes/Primitives/CylinderPrimitive.fbx
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/CylinderPrimitive.tscript b/Templates/BaseGame/game/data/Prototyping/shapes/Primitives/CylinderPrimitive.tscript
similarity index 100%
rename from Templates/BaseGame/game/data/Prototyping/shapes/CylinderPrimitive.tscript
rename to Templates/BaseGame/game/data/Prototyping/shapes/Primitives/CylinderPrimitive.tscript
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/SpherePrimitive.asset.taml b/Templates/BaseGame/game/data/Prototyping/shapes/Primitives/SpherePrimitive.asset.taml
similarity index 100%
rename from Templates/BaseGame/game/data/Prototyping/shapes/SpherePrimitive.asset.taml
rename to Templates/BaseGame/game/data/Prototyping/shapes/Primitives/SpherePrimitive.asset.taml
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/SpherePrimitive.fbx b/Templates/BaseGame/game/data/Prototyping/shapes/Primitives/SpherePrimitive.fbx
similarity index 100%
rename from Templates/BaseGame/game/data/Prototyping/shapes/SpherePrimitive.fbx
rename to Templates/BaseGame/game/data/Prototyping/shapes/Primitives/SpherePrimitive.fbx
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/SpherePrimitive.tscript b/Templates/BaseGame/game/data/Prototyping/shapes/Primitives/SpherePrimitive.tscript
similarity index 100%
rename from Templates/BaseGame/game/data/Prototyping/shapes/SpherePrimitive.tscript
rename to Templates/BaseGame/game/data/Prototyping/shapes/Primitives/SpherePrimitive.tscript
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/TorusPrimitive.asset.taml b/Templates/BaseGame/game/data/Prototyping/shapes/Primitives/TorusPrimitive.asset.taml
similarity index 100%
rename from Templates/BaseGame/game/data/Prototyping/shapes/TorusPrimitive.asset.taml
rename to Templates/BaseGame/game/data/Prototyping/shapes/Primitives/TorusPrimitive.asset.taml
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/TorusPrimitive.fbx b/Templates/BaseGame/game/data/Prototyping/shapes/Primitives/TorusPrimitive.fbx
similarity index 100%
rename from Templates/BaseGame/game/data/Prototyping/shapes/TorusPrimitive.fbx
rename to Templates/BaseGame/game/data/Prototyping/shapes/Primitives/TorusPrimitive.fbx
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/TorusPrimitive.tscript b/Templates/BaseGame/game/data/Prototyping/shapes/Primitives/TorusPrimitive.tscript
similarity index 100%
rename from Templates/BaseGame/game/data/Prototyping/shapes/TorusPrimitive.tscript
rename to Templates/BaseGame/game/data/Prototyping/shapes/Primitives/TorusPrimitive.tscript
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/TubePrimitive.asset.taml b/Templates/BaseGame/game/data/Prototyping/shapes/Primitives/TubePrimitive.asset.taml
similarity index 100%
rename from Templates/BaseGame/game/data/Prototyping/shapes/TubePrimitive.asset.taml
rename to Templates/BaseGame/game/data/Prototyping/shapes/Primitives/TubePrimitive.asset.taml
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/TubePrimitive.fbx b/Templates/BaseGame/game/data/Prototyping/shapes/Primitives/TubePrimitive.fbx
similarity index 100%
rename from Templates/BaseGame/game/data/Prototyping/shapes/TubePrimitive.fbx
rename to Templates/BaseGame/game/data/Prototyping/shapes/Primitives/TubePrimitive.fbx
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/TubePrimitive.tscript b/Templates/BaseGame/game/data/Prototyping/shapes/Primitives/TubePrimitive.tscript
similarity index 100%
rename from Templates/BaseGame/game/data/Prototyping/shapes/TubePrimitive.tscript
rename to Templates/BaseGame/game/data/Prototyping/shapes/Primitives/TubePrimitive.tscript
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/Car.asset.taml b/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/Car.asset.taml
new file mode 100644
index 000000000..a41260bc3
--- /dev/null
+++ b/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/Car.asset.taml
@@ -0,0 +1 @@
+<ShapeAsset canSave="true" canSaveDynamicFields="true" AssetName="Car" fileName="@assetFile=car.dae" constuctorFileName="@assetFile=car.tscript"/>
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/car.dae b/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/car.dae
new file mode 100644
index 000000000..b4dc919f7
--- /dev/null
+++ b/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/car.dae
@@ -0,0 +1,537 @@
+<?xml version="1.0" encoding="utf-8"?>
+<COLLADA xmlns="http://www.collada.org/2005/11/COLLADASchema" version="1.4.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <asset>
+    <contributor>
+      <author>Blender User</author>
+      <authoring_tool>Blender 2.90.0 commit date:2020-08-31, commit time:11:26, hash:0330d1af29c0</authoring_tool>
+    </contributor>
+    <created>2021-09-11T16:03:37</created>
+    <modified>2021-09-11T16:03:37</modified>
+    <unit name="meter" meter="1"/>
+    <up_axis>Z_UP</up_axis>
+  </asset>
+  <library_lights>
+    <light id="EnvironmentAmbientLight-light" name="EnvironmentAmbientLight">
+      <technique_common>
+        <directional>
+          <color sid="color">0 0 0</color>
+        </directional>
+      </technique_common>
+      <extra>
+        <technique profile="blender">
+          <type sid="type" type="int">1</type>
+          <flag sid="flag" type="int">0</flag>
+          <mode sid="mode" type="int">1</mode>
+          <gamma sid="blender_gamma" type="float">1</gamma>
+          <red sid="red" type="float">0</red>
+          <green sid="green" type="float">0</green>
+          <blue sid="blue" type="float">0</blue>
+          <shadow_r sid="blender_shadow_r" type="float">0</shadow_r>
+          <shadow_g sid="blender_shadow_g" type="float">0</shadow_g>
+          <shadow_b sid="blender_shadow_b" type="float">0</shadow_b>
+          <energy sid="blender_energy" type="float">1</energy>
+          <dist sid="blender_dist" type="float">25</dist>
+          <spotsize sid="spotsize" type="float">45</spotsize>
+          <spotblend sid="spotblend" type="float">0.15</spotblend>
+          <att1 sid="att1" type="float">0</att1>
+          <att2 sid="att2" type="float">1</att2>
+          <falloff_type sid="falloff_type" type="int">2</falloff_type>
+          <clipsta sid="clipsta" type="float">0.04999995</clipsta>
+          <clipend sid="clipend" type="float">40</clipend>
+          <bias sid="bias" type="float">1</bias>
+          <soft sid="soft" type="float">3</soft>
+          <bufsize sid="bufsize" type="int">512</bufsize>
+          <samp sid="samp" type="int">3</samp>
+          <buffers sid="buffers" type="int">1</buffers>
+          <area_shape sid="area_shape" type="int">0</area_shape>
+          <area_size sid="area_size" type="float">0.25</area_size>
+          <area_sizey sid="area_sizey" type="float">0.25</area_sizey>
+          <area_sizez sid="area_sizez" type="float">0.25</area_sizez>
+        </technique>
+      </extra>
+    </light>
+  </library_lights>
+  <library_effects>
+    <effect id="InteractiveRed-effect">
+      <profile_COMMON>
+        <technique sid="common">
+          <lambert>
+            <emission>
+              <color sid="emission">0 0 0 1</color>
+            </emission>
+            <diffuse>
+              <color sid="diffuse">0.8 0.8 0.8 1</color>
+            </diffuse>
+            <index_of_refraction>
+              <float sid="ior">1.45</float>
+            </index_of_refraction>
+          </lambert>
+        </technique>
+      </profile_COMMON>
+    </effect>
+  </library_effects>
+  <library_images/>
+  <library_materials>
+    <material id="InteractiveRed-material" name="InteractiveRed">
+      <instance_effect url="#InteractiveRed-effect"/>
+    </material>
+  </library_materials>
+  <library_geometries>
+    <geometry id="ID15_001-mesh" name="ID15.001">
+      <mesh>
+        <source id="ID15_001-mesh-positions">
+          <float_array id="ID15_001-mesh-positions-array" count="3714">-1.3 -2.60617 0.8404262 -1.033334 -2.60617 0.8404262 -1.3 -2.605922 0.8423042 -1.03396 -2.605922 0.8423042 -1.258669 -2.954252 0.6404263 -1.258669 -2.954252 0.8404263 -1.273205 -2.9325 0.6404263 -1.273205 -2.9325 0.8404263 -1.241421 -2.973922 0.6404263 -1.221752 -2.99117 0.6404263 -1.241421 -2.973922 0.8404263 -1.221752 -2.99117 0.8404263 -1.273205 -2.9325 0.6404263 -1.273205 -2.9325 0.8404263 -1.284775 -2.909036 0.6404263 -1.284775 -2.909036 0.8404263 -1.3 0.6074998 0.4404257 -1.3 0.6074998 0.6404257 -1.3 0.7874998 0.4404256 -1.3 0.6340779 0.8423037 -1.3 0.7119999 1.030426 -1.3 0.7874998 0.6404257 -1.3 0.8359559 1.19197 -1.3 0.8079439 0.7957177 -1.3 0.8678839 0.9404256 -1.3 0.9975 1.315926 -1.3 0.9632359 1.06469 -1.3 1.0875 1.160042 -1.3 1.185622 1.393848 -1.3 1.232208 1.219982 -1.3 1.3875 1.420426 -1.3 1.3875 1.240426 -1.3 1.542792 1.219982 -1.3 1.589378 1.393848 -1.3 1.6875 1.160042 -1.3 1.7775 1.315925 -1.3 1.811764 1.064689 -1.3 1.939044 1.191969 -1.3 1.907116 0.9404255 -1.3 1.967056 0.7957175 -1.3 2.063 1.030425 -1.3 1.9875 0.6404255 -1.3 1.9875 0.4404255 -1.3 2.14117 0.8404255 -1.3 2.3675 0.4404254 -1.3 2.140922 0.8423035 -1.3 2.3675 0.8404254 1.241422 -2.973922 0.6404263 1.25867 -2.954252 0.6404263 1.241422 -2.973922 0.8404263 1.25867 -2.954252 0.8404263 -1.241421 -2.973922 0.6404263 -1.241421 -2.973922 0.8404263 -1.258669 -2.954252 0.6404263 -1.258669 -2.954252 0.8404263 1.1 -3.0325 0.6404263 1.126106 -3.03079 0.6404263 1.1 -3.0325 0.8404263 1.126106 -3.03079 0.8404263 1.151764 -3.025686 0.6404263 1.176536 -3.017276 0.6404263 1.151764 -3.025686 0.8404263 1.176536 -3.017276 0.8404263 -1.1 -3.0325 0.6404263 1.1 -3.0325 0.6404263 -1.1 -3.0325 0.8404263 1.1 -3.0325 0.8404263 1.298288 -2.858606 0.6404263 1.3 -2.8325 0.6404263 1.298288 -2.858606 0.8404263 1.3 -2.8325 0.8404263 -1.176535 -3.017276 0.6404263 -1.151764 -3.025686 0.6404263 -1.176535 -3.017276 0.8404263 -1.151764 -3.025686 0.8404263 -1.2 -3.005704 0.6404263 -1.176535 -3.017276 0.6404263 -1.2 -3.005704 0.8404263 -1.176535 -3.017276 0.8404263 1.221753 -2.99117 0.6404263 1.241422 -2.973922 0.6404263 1.221753 -2.99117 0.8404263 1.241422 -2.973922 0.8404263 1.200001 -3.005704 0.6404263 1.221753 -2.99117 0.6404263 1.200001 -3.005704 0.8404263 1.221753 -2.99117 0.8404263 1.126106 -3.03079 0.6404263 1.151764 -3.025686 0.6404263 1.126106 -3.03079 0.8404263 1.151764 -3.025686 0.8404263 -1.151764 -3.025686 0.6404263 -1.126106 -3.03079 0.6404263 -1.151764 -3.025686 0.8404263 -1.126106 -3.03079 0.8404263 1.284776 -2.909036 0.6404263 1.293186 -2.884264 0.6404263 1.284776 -2.909036 0.8404263 1.293186 -2.884264 0.8404263 -1.221752 -2.99117 0.6404263 -1.2 -3.005704 0.6404263 -1.221752 -2.99117 0.8404263 -1.2 -3.005704 0.8404263 -1.298287 -2.858606 0.6404263 -1.298287 -2.858606 0.8404263 -1.299999 -2.8325 0.6404263 -1.299999 -2.8325 0.8404263 1.273206 -2.9325 0.6404263 1.284776 -2.909036 0.6404263 1.273206 -2.9325 0.8404263 1.284776 -2.909036 0.8404263 1.3 -2.8325 0.8404263 1.3 -2.8325 0.6404263 1.3 -2.60617 0.8404262 1.3 -2.4525 0.6404262 1.3 -2.605922 0.8423042 1.3 -2.528 1.030426 1.3 -2.404044 1.19197 1.3 -2.432056 0.7957182 1.3 -2.372116 0.9404262 1.3 -2.2425 1.315926 1.3 -2.276764 1.06469 1.3 -2.1525 1.160042 1.3 -2.054378 1.393848 1.3 -2.007792 1.219982 1.3 -1.8525 1.420426 1.3 -1.8525 1.240426 1.3 -1.650622 1.393848 1.3 -1.697208 1.219982 1.3 -1.5525 1.160042 1.3 -1.4625 1.315926 1.3 -1.428236 1.06469 1.3 -1.300956 1.19197 1.3 -1.332884 0.940426 1.3 -1.272944 0.795718 1.3 -1.177 1.030426 1.3 -1.2525 0.640426 1.3 -1.2525 0.440426 1.3 -1.0725 0.4404259 1.3 -1.099078 0.842304 1.3 -1.0725 0.640426 1.176536 -3.017276 0.6404263 1.200001 -3.005704 0.6404263 1.176536 -3.017276 0.8404263 1.200001 -3.005704 0.8404263 -1.126106 -3.03079 0.6404263 -1.1 -3.0325 0.6404263 -1.126106 -3.03079 0.8404263 -1.1 -3.0325 0.8404263 1.25867 -2.954252 0.6404263 1.273206 -2.9325 0.6404263 1.25867 -2.954252 0.8404263 1.273206 -2.9325 0.8404263 -1.293185 -2.884264 0.6404263 -1.293185 -2.884264 0.8404263 -1.298287 -2.858606 0.6404263 -1.298287 -2.858606 0.8404263 1.293186 -2.884264 0.6404263 1.298288 -2.858606 0.6404263 1.293186 -2.884264 0.8404263 1.298288 -2.858606 0.8404263 -1.284775 -2.909036 0.6404263 -1.284775 -2.909036 0.8404263 -1.293185 -2.884264 0.6404263 -1.293185 -2.884264 0.8404263 1.1 2.055326 1.040426 1.096666 2.063 1.030425 1.1 2.3675 1.040425 1.03396 2.140922 0.8423035 1.033334 2.14117 0.8404255 1.033334 2.300834 0.8404254 1.033334 -2.899166 0.8404263 1.033334 -2.60617 0.8404262 1.1 -2.8325 1.040426 1.03396 -2.605922 0.8423042 1.096666 -2.528 1.030426 1.1 -2.520326 1.040426 -1.1 1.7775 1.315925 -1.1 1.939044 1.191969 -1.3 1.7775 1.315925 -1.3 1.939044 1.191969 -1.1 -1.650622 1.393848 -1.1 -1.4625 1.315926 -1.3 -1.650622 1.393848 -1.3 -1.4625 1.315926 1.3 1.6875 1.160042 1.3 1.542792 1.219982 0.6499997 1.6875 1.160042 0.6499997 1.542792 1.219982 1.3 0.9975004 1.315926 1.3 1.185622 1.393848 1.1 0.9975003 1.315926 1.1 1.185622 1.393848 1.3 -1.650622 1.393848 1.3 -1.4625 1.315926 1.1 -1.650622 1.393848 1.1 -1.4625 1.315926 1.3 -2.404044 1.19197 1.3 -2.2425 1.315926 1.1 -2.404044 1.19197 1.1 -2.2425 1.315926 1.3 0.6340782 0.8423037 1.3 0.7120003 1.030426 1.03396 0.6340782 0.8423037 1.096666 0.7120003 1.030426 1.3 1.907116 0.9404255 1.3 1.811764 1.064689 0.6499997 1.907116 0.9404255 0.6499997 1.811764 1.064689 1.096666 -1.177 1.030426 1.1 -1.184674 1.040426 1.3 -1.177 1.030426 1.3 -1.300956 1.19197 1.1 -1.300956 1.19197 1.3 0.7875002 0.4404256 0.6499999 0.7875001 0.4404256 1.3 0.7875002 0.6404257 0.6499999 0.7875001 0.6404257 -1.1 -1.4625 1.315926 -1.1 -1.300956 1.19197 -1.3 -1.4625 1.315926 -1.3 -1.300956 1.19197 1.3 0.8359563 1.19197 1.3 0.9975004 1.315926 1.1 0.8359563 1.19197 1.1 0.9975003 1.315926 1.3 1.811764 1.064689 1.3 1.6875 1.160042 0.6499997 1.811764 1.064689 0.6499997 1.6875 1.160042 1.3 -1.4625 1.315926 1.3 -1.300956 1.19197 1.1 -1.4625 1.315926 1.1 -1.300956 1.19197 1.3 1.185622 1.393848 1.3 1.3875 1.420426 1.1 1.185622 1.393848 1.1 1.3875 1.420426 1.3 1.3875 1.420426 1.3 1.589378 1.393848 1.1 1.3875 1.420426 1.1 1.589378 1.393848 1.3 1.7775 1.315925 1.3 1.939044 1.191969 1.1 1.7775 1.315925 1.1 1.939044 1.191969 -1.1 -1.8525 1.420426 -1.1 -1.650622 1.393848 -1.3 -1.8525 1.420426 -1.3 -1.650622 1.393848 1.3 1.0875 1.160042 1.3 0.9632363 1.06469 0.6499998 1.0875 1.160042 0.6499999 0.9632362 1.06469 1.3 -1.8525 1.420426 1.3 -1.650622 1.393848 1.1 -1.8525 1.420426 1.1 -1.650622 1.393848 1.3 1.542792 1.219982 1.3 1.3875 1.240426 0.6499997 1.542792 1.219982 0.6499998 1.3875 1.240426 1.3 1.232208 1.219982 1.3 1.0875 1.160042 0.6499998 1.232208 1.219982 0.6499998 1.0875 1.160042 -1.3 0.6340779 0.8423037 -1.03396 0.6340779 0.8423037 -1.3 0.7119999 1.030426 -1.096666 0.712 1.030426 1.3 -2.2425 1.315926 1.3 -2.054378 1.393848 1.1 -2.2425 1.315926 1.1 -2.054378 1.393848 1.3 0.7875002 0.6404257 0.6499999 0.7875001 0.6404257 1.3 0.8079442 0.7957177 0.6499999 0.8079442 0.7957177 -1.033334 -2.899166 0.8404263 -1.1 -2.8325 1.040426 -1.033334 -2.60617 0.8404262 -1.03396 -2.605922 0.8423042 -1.096666 -2.528 1.030426 -1.1 -2.520326 1.040426 -1.03396 -1.099078 0.842304 -1.3 -1.099078 0.842304 -1.096666 -1.177 1.030426 -1.3 -1.177 1.030426 1.3 2.140922 0.8423035 1.03396 2.140922 0.8423035 1.3 2.063 1.030425 1.096666 2.063 1.030425 -1.3 2.140922 0.8423035 -1.3 2.063 1.030425 -1.03396 2.140922 0.8423035 -1.096666 2.063 1.030425 -1.1 0.8359559 1.19197 -1.1 0.9975 1.315926 -1.3 0.8359559 1.19197 -1.3 0.9975 1.315926 -1.1 -2.054378 1.393848 -1.1 -1.8525 1.420426 -1.3 -2.054378 1.393848 -1.3 -1.8525 1.420426 1.3 0.8079442 0.7957177 0.6499999 0.8079442 0.7957177 1.3 0.8678843 0.9404256 0.6499999 0.8678842 0.9404256 -1.3 -2.605922 0.8423042 -1.03396 -2.605922 0.8423042 -1.3 -2.528 1.030426 -1.096666 -2.528 1.030426 -1.3 0.6074998 0.6404257 -0.9666661 0.6074999 0.6404257 -1.3 0.6340779 0.8423037 -1.03396 0.6340779 0.8423037 1.3 1.9875 0.6404255 1.3 1.967056 0.7957175 0.6499997 1.9875 0.6404255 0.6499997 1.967056 0.7957175 1.03396 -1.099078 0.842304 1.096666 -1.177 1.030426 1.3 -1.099078 0.842304 1.3 -1.177 1.030426 -1.3 -2.528 1.030426 -1.096666 -2.528 1.030426 -1.3 -2.404044 1.19197 -1.1 -2.520326 1.040426 -1.1 -2.404044 1.19197 0.9666662 -1.0725 0.640426 1.03396 -1.099078 0.842304 1.3 -1.0725 0.640426 1.3 -1.099078 0.842304 -1.1 1.185622 1.393848 -1.1 1.3875 1.420426 -1.3 1.185622 1.393848 -1.3 1.3875 1.420426 1.096666 2.063 1.030425 1.1 2.055326 1.040426 1.3 2.063 1.030425 1.3 1.939044 1.191969 1.1 1.939044 1.191969 1.096666 0.7120003 1.030426 1.3 0.7120003 1.030426 1.1 0.7196742 1.040426 1.3 0.8359563 1.19197 1.1 0.8359563 1.19197 0.9666659 0.6075002 0.6404257 1.3 0.6075003 0.6404257 1.03396 0.6340782 0.8423037 1.3 0.6340782 0.8423037 -1.1 1.589378 1.393848 -1.1 1.7775 1.315925 -1.3 1.589378 1.393848 -1.3 1.7775 1.315925 -1.096666 -1.177 1.030426 -1.3 -1.177 1.030426 -1.1 -1.184674 1.040426 -1.3 -1.300956 1.19197 -1.1 -1.300956 1.19197 -1.096666 2.063 1.030425 -1.3 2.063 1.030425 -1.1 2.055326 1.040426 -1.3 1.939044 1.191969 -1.1 1.939044 1.191969 1.3 -2.054378 1.393848 1.3 -1.8525 1.420426 1.1 -2.054378 1.393848 1.1 -1.8525 1.420426 -1.1 1.3875 1.420426 -1.1 1.589378 1.393848 -1.3 1.3875 1.420426 -1.3 1.589378 1.393848 1.033334 -2.60617 0.8404262 1.3 -2.60617 0.8404262 1.03396 -2.605922 0.8423042 1.3 -2.605922 0.8423042 1.3 0.8678843 0.9404256 0.6499999 0.8678842 0.9404256 1.3 0.9632363 1.06469 0.6499999 0.9632362 1.06469 -1.1 -2.2425 1.315926 -1.1 -2.054378 1.393848 -1.3 -2.2425 1.315926 -1.3 -2.054378 1.393848 1.3 -2.605922 0.8423042 1.3 -2.528 1.030426 1.03396 -2.605922 0.8423042 1.096666 -2.528 1.030426 -0.9666658 -1.0725 0.640426 -1.3 -1.0725 0.640426 -1.03396 -1.099078 0.842304 -1.3 -1.099078 0.842304 -1.096666 0.712 1.030426 -1.1 0.7196739 1.040426 -1.3 0.7119999 1.030426 -1.3 0.8359559 1.19197 -1.1 0.8359559 1.19197 -1.1 0.9975 1.315926 -1.1 1.185622 1.393848 -1.3 0.9975 1.315926 -1.3 1.185622 1.393848 1.3 1.967056 0.7957175 1.3 1.907116 0.9404255 0.6499997 1.967056 0.7957175 0.6499997 1.907116 0.9404255 1.3 -2.528 1.030426 1.3 -2.404044 1.19197 1.096666 -2.528 1.030426 1.1 -2.520326 1.040426 1.1 -2.404044 1.19197 -1.293186 2.419264 0.4404254 -1.293186 2.419264 0.8404254 -1.284776 2.444036 0.4404254 -1.284776 2.444036 0.8404254 -1.284776 2.444036 0.4404254 -1.284776 2.444036 0.8404254 -1.273206 2.4675 0.4404254 -1.273206 2.4675 0.8404254 -1.273206 2.4675 0.4404254 -1.273206 2.4675 0.8404254 -1.25867 2.489252 0.4404254 -1.25867 2.489252 0.8404254 -1.221752 2.52617 0.4404254 -1.241422 2.508922 0.4404254 -1.221752 2.52617 0.8404254 -1.241422 2.508922 0.8404254 1.25867 2.489252 0.8404254 1.25867 2.489252 0.4404254 1.241422 2.508922 0.8404254 1.241422 2.508922 0.4404254 1.126106 2.565788 0.4404253 1.1 2.5675 0.4404253 1.126106 2.565788 0.8404254 1.1 2.5675 0.8404254 -1.25867 2.489252 0.4404254 -1.25867 2.489252 0.8404254 -1.241422 2.508922 0.4404254 -1.241422 2.508922 0.8404254 -1.298288 2.393606 0.4404254 -1.298288 2.393606 0.8404254 -1.293186 2.419264 0.4404254 -1.293186 2.419264 0.8404254 -1.3 2.3675 0.4404254 -1.3 2.3675 0.8404254 -1.298288 2.393606 0.4404254 -1.298288 2.393606 0.8404254 1.1 2.5675 0.4404253 -1.1 2.5675 0.4404253 1.1 2.5675 0.8404254 -1.1 2.5675 0.8404254 1.3 2.3675 0.8404254 1.3 2.3675 0.4404254 1.298288 2.393606 0.8404254 1.298288 2.393606 0.4404254 1.293186 2.419264 0.8404254 1.293186 2.419264 0.4404254 1.284776 2.444036 0.8404254 1.284776 2.444036 0.4404254 1.273206 2.4675 0.8404254 1.273206 2.4675 0.4404254 1.25867 2.489252 0.8404254 1.25867 2.489252 0.4404254 1.3 1.589378 1.393848 1.3 1.7775 1.315925 1.1 1.589378 1.393848 1.1 1.7775 1.315925 1.033334 2.300834 0.8404254 -1.033334 2.300834 0.8404254 1.1 2.3675 1.040425 -1.1 2.3675 1.040425 0.6999996 2.3675 1.040425 -0.7000004 2.3675 1.040425 -1.033334 2.14117 0.8404255 -1.033334 2.300834 0.8404254 -1.3 2.14117 0.8404255 -1.1 2.5675 0.8404254 -1.126106 2.565788 0.8404254 -1.151764 2.560686 0.8404254 -1.176536 2.552276 0.8404254 -1.2 2.540706 0.8404254 -1.221752 2.52617 0.8404254 -1.241422 2.508922 0.8404254 -1.25867 2.489252 0.8404254 -1.273206 2.4675 0.8404254 -1.284776 2.444036 0.8404254 -1.293186 2.419264 0.8404254 -1.298288 2.393606 0.8404254 -1.3 2.3675 0.8404254 1.033334 2.300834 0.8404254 1.1 2.5675 0.8404254 1.033334 2.14117 0.8404255 1.126106 2.565788 0.8404254 1.151764 2.560686 0.8404254 1.176536 2.552276 0.8404254 1.2 2.540706 0.8404254 1.221752 2.52617 0.8404254 1.241422 2.508922 0.8404254 1.25867 2.489252 0.8404254 1.273206 2.4675 0.8404254 1.284776 2.444036 0.8404254 1.293186 2.419264 0.8404254 1.298288 2.393606 0.8404254 1.3 2.3675 0.8404254 1.3 2.14117 0.8404255 1.151764 2.560686 0.4404253 1.126106 2.565788 0.4404253 1.151764 2.560686 0.8404254 1.126106 2.565788 0.8404254 1.176536 2.552276 0.4404253 1.151764 2.560686 0.4404253 1.176536 2.552276 0.8404254 1.151764 2.560686 0.8404254 -1.151764 2.560686 0.4404253 -1.176536 2.552276 0.4404253 -1.151764 2.560686 0.8404254 -1.176536 2.552276 0.8404254 -1.176536 2.552276 0.4404253 -1.2 2.540706 0.4404253 -1.176536 2.552276 0.8404254 -1.2 2.540706 0.8404254 -1.033334 2.14117 0.8404255 -1.3 2.14117 0.8404255 -1.03396 2.140922 0.8423035 -1.3 2.140922 0.8423035 -1.126106 2.565788 0.4404253 -1.151764 2.560686 0.4404253 -1.126106 2.565788 0.8404254 -1.151764 2.560686 0.8404254 -1.1 -2.404044 1.19197 -1.1 -2.2425 1.315926 -1.3 -2.404044 1.19197 -1.3 -2.2425 1.315926 1.221752 2.52617 0.4404254 1.2 2.540706 0.4404253 1.221752 2.52617 0.8404254 1.2 2.540706 0.8404254 -1.1 2.055326 1.040426 -1.1 2.3675 1.040425 -1.096666 2.063 1.030425 -1.03396 2.140922 0.8423035 -1.033334 2.14117 0.8404255 -1.033334 2.300834 0.8404254 1.284776 2.444036 0.8404254 1.284776 2.444036 0.4404254 1.273206 2.4675 0.8404254 1.273206 2.4675 0.4404254 1.3 2.14117 0.8404255 1.033334 2.14117 0.8404255 1.3 2.140922 0.8423035 1.03396 2.140922 0.8423035 1.298288 2.393606 0.8404254 1.298288 2.393606 0.4404254 1.293186 2.419264 0.8404254 1.293186 2.419264 0.4404254 1.241422 2.508922 0.4404254 1.221752 2.52617 0.4404254 1.241422 2.508922 0.8404254 1.221752 2.52617 0.8404254 -1.1 2.5675 0.4404253 -1.126106 2.565788 0.4404253 -1.1 2.5675 0.8404254 -1.126106 2.565788 0.8404254 -1.3 1.9875 0.4404255 -0.6500003 1.9875 0.4404255 -1.3 1.9875 0.6404255 -0.6500003 1.9875 0.6404255 -1.2 2.540706 0.4404253 -1.221752 2.52617 0.4404254 -1.2 2.540706 0.8404254 -1.221752 2.52617 0.8404254 1.2 2.540706 0.4404253 1.176536 2.552276 0.4404253 1.2 2.540706 0.8404254 1.176536 2.552276 0.8404254 1.3 1.3875 1.240426 1.3 1.232208 1.219982 0.6499998 1.3875 1.240426 0.6499998 1.232208 1.219982 -1.3 1.9875 0.6404255 -0.6500003 1.9875 0.6404255 -1.3 1.967056 0.7957175 -0.6500003 1.967056 0.7957175 -0.6500001 0.7874999 0.4404256 -1.3 0.7874998 0.4404256 -0.6500001 0.7874999 0.6404257 -1.3 0.7874998 0.6404257 -0.6500002 1.3875 1.240426 -0.6500002 1.232208 1.219982 -1.3 1.3875 1.240426 -1.3 1.232208 1.219982 -0.6500002 1.232208 1.219982 -0.6500002 1.0875 1.160042 -1.3 1.232208 1.219982 -1.3 1.0875 1.160042 -1.3 1.907116 0.9404255 -0.6500003 1.907116 0.9404255 -1.3 1.811764 1.064689 -0.6500002 1.811764 1.064689 -0.6500001 0.7874999 0.6404257 -1.3 0.7874998 0.6404257 -0.6500001 0.8079439 0.7957177 -1.3 0.8079439 0.7957177 -0.6500001 0.867884 0.9404256 -1.3 0.8678839 0.9404256 -0.6500001 0.963236 1.06469 -1.3 0.9632359 1.06469 -0.6500001 0.8079439 0.7957177 -1.3 0.8079439 0.7957177 -0.6500001 0.867884 0.9404256 -1.3 0.8678839 0.9404256 -0.6500002 1.0875 1.160042 -0.6500001 0.963236 1.06469 -1.3 1.0875 1.160042 -1.3 0.9632359 1.06469 -0.6500002 1.811764 1.064689 -0.6500002 1.6875 1.160042 -1.3 1.811764 1.064689 -1.3 1.6875 1.160042 -0.6500002 1.542792 1.219982 -0.6500002 1.3875 1.240426 -1.3 1.542792 1.219982 -1.3 1.3875 1.240426 -1.3 1.967056 0.7957175 -0.6500003 1.967056 0.7957175 -1.3 1.907116 0.9404255 -0.6500003 1.907116 0.9404255 -0.6500002 1.6875 1.160042 -0.6500002 1.542792 1.219982 -1.3 1.6875 1.160042 -1.3 1.542792 1.219982 -0.6500001 0.7874999 0.4404256 -0.6500001 0.7874999 0.6404257 -0.6500003 1.9875 0.4404255 -0.6500001 0.8079439 0.7957177 -0.6500001 0.867884 0.9404256 -0.6500001 0.963236 1.06469 -0.6500002 1.0875 1.160042 -0.6500002 1.232208 1.219982 -0.6500002 1.3875 1.240426 -0.6500002 1.542792 1.219982 -0.6500002 1.6875 1.160042 -0.6500002 1.811764 1.064689 -0.6500003 1.907116 0.9404255 -0.6500003 1.967056 0.7957175 -0.6500003 1.9875 0.6404255 0.6499999 0.7875001 0.6404257 0.6499999 0.7875001 0.4404256 0.6499999 0.8079442 0.7957177 0.6499997 1.9875 0.4404255 0.6499999 0.8678842 0.9404256 0.6499999 0.9632362 1.06469 0.6499998 1.0875 1.160042 0.6499998 1.232208 1.219982 0.6499998 1.3875 1.240426 0.6499997 1.542792 1.219982 0.6499997 1.6875 1.160042 0.6499997 1.811764 1.064689 0.6499997 1.907116 0.9404255 0.6499997 1.967056 0.7957175 0.6499997 1.9875 0.6404255 0.6499997 1.9875 0.4404255 1.3 1.9875 0.4404255 0.6499997 1.9875 0.6404255 1.3 1.9875 0.6404255 1.1 -3.0325 0.8404263 1.033334 -2.899166 0.8404263 -1.1 -3.0325 0.8404263 -1.033334 -2.899166 0.8404263 -1.033334 -2.60617 0.8404262 -1.3 -2.60617 0.8404262 -1.126106 -3.03079 0.8404263 -1.151764 -3.025686 0.8404263 -1.176535 -3.017276 0.8404263 -1.2 -3.005704 0.8404263 -1.221752 -2.99117 0.8404263 -1.241421 -2.973922 0.8404263 -1.258669 -2.954252 0.8404263 -1.273205 -2.9325 0.8404263 -1.284775 -2.909036 0.8404263 -1.293185 -2.884264 0.8404263 -1.298287 -2.858606 0.8404263 -1.299999 -2.8325 0.8404263 1.3 -2.8325 0.8404263 1.3 -2.60617 0.8404262 1.298288 -2.858606 0.8404263 1.033334 -2.60617 0.8404262 1.293186 -2.884264 0.8404263 1.284776 -2.909036 0.8404263 1.273206 -2.9325 0.8404263 1.25867 -2.954252 0.8404263 1.241422 -2.973922 0.8404263 1.221753 -2.99117 0.8404263 1.200001 -3.005704 0.8404263 1.176536 -3.017276 0.8404263 1.151764 -3.025686 0.8404263 1.126106 -3.03079 0.8404263 -1.033334 -2.899166 0.8404263 1.033334 -2.899166 0.8404263 -1.1 -2.8325 1.040426 1.1 -2.8325 1.040426 -0.5999996 -2.8325 1.040426 0.6000005 -2.8325 1.040426 -0.5999996 -2.8325 1.040426 0.6000005 -2.8325 1.040426 -0.5999996 -2.8325 1.240426 0.6000005 -2.8325 1.240426 1.3 0.7875002 0.4404256 1.3 0.6075002 0.4404257 0.6499999 0.7875001 0.4404256 0.9666659 0.6075001 0.4404257 0.6500002 -1.2525 0.440426 0.6500003 -2.4525 0.4404262 -0.6499996 -2.4525 0.4404262 -0.6499998 -1.2525 0.440426 0.9666662 -1.0725 0.4404259 1.3 -1.0725 0.4404259 1.3 -1.2525 0.440426 -0.6500003 1.9875 0.4404255 -1.1 2.5675 0.4404253 0.6499997 1.9875 0.4404255 1.1 2.5675 0.4404253 1.126106 2.565788 0.4404253 1.151764 2.560686 0.4404253 1.176536 2.552276 0.4404253 1.2 2.540706 0.4404253 1.221752 2.52617 0.4404254 1.241422 2.508922 0.4404254 1.25867 2.489252 0.4404254 1.273206 2.4675 0.4404254 1.284776 2.444036 0.4404254 1.293186 2.419264 0.4404254 1.298288 2.393606 0.4404254 1.3 2.3675 0.4404254 1.3 1.9875 0.4404255 -1.3 1.9875 0.4404255 -1.126106 2.565788 0.4404253 -1.151764 2.560686 0.4404253 -1.176536 2.552276 0.4404253 -1.2 2.540706 0.4404253 -1.221752 2.52617 0.4404254 -1.241422 2.508922 0.4404254 -1.25867 2.489252 0.4404254 -1.273206 2.4675 0.4404254 -1.284776 2.444036 0.4404254 -1.293186 2.419264 0.4404254 -1.298288 2.393606 0.4404254 -1.3 2.3675 0.4404254 -0.6500001 0.7874999 0.4404256 -0.9666658 -1.0725 0.4404259 -0.9666661 0.6074999 0.4404257 -1.3 0.7874998 0.4404256 -1.3 0.6074998 0.4404257 -1.3 -1.2525 0.440426 -1.3 -1.0725 0.4404259 -1.3 -1.2525 0.440426 -0.6499998 -1.2525 0.440426 -1.3 -1.2525 0.640426 -0.6499998 -1.2525 0.640426 1.3 -2.1525 1.160042 1.3 -2.276764 1.06469 0.6500003 -2.1525 1.160042 0.6500003 -2.276764 1.06469 1.3 -1.272944 0.795718 1.3 -1.332884 0.940426 0.6500002 -1.272944 0.795718 0.6500002 -1.332884 0.940426 1.3 -1.8525 1.240426 1.3 -2.007792 1.219982 0.6500003 -1.8525 1.240426 0.6500003 -2.007792 1.219982 1.3 -1.332884 0.940426 1.3 -1.428236 1.06469 0.6500002 -1.332884 0.940426 0.6500002 -1.428236 1.06469 1.3 -1.5525 1.160042 1.3 -1.697208 1.219982 0.6500002 -1.5525 1.160042 0.6500002 -1.697208 1.219982 1.3 -2.432056 0.7957182 0.6500003 -2.432056 0.7957182 1.3 -2.372116 0.9404262 0.6500003 -2.372116 0.9404262 1.3 -2.372116 0.9404262 0.6500003 -2.372116 0.9404262 1.3 -2.276764 1.06469 0.6500003 -2.276764 1.06469 1.3 -1.428236 1.06469 1.3 -1.5525 1.160042 0.6500002 -1.428236 1.06469 0.6500002 -1.5525 1.160042 1.3 -2.007792 1.219982 1.3 -2.1525 1.160042 0.6500003 -2.007792 1.219982 0.6500003 -2.1525 1.160042 1.3 -1.2525 0.640426 1.3 -1.272944 0.795718 0.6500002 -1.2525 0.640426 0.6500002 -1.272944 0.795718 1.3 -2.4525 0.6404262 0.6500003 -2.4525 0.6404262 1.3 -2.432056 0.7957182 0.6500003 -2.432056 0.7957182 1.3 -1.697208 1.219982 1.3 -1.8525 1.240426 0.6500002 -1.697208 1.219982 0.6500003 -1.8525 1.240426 -1.3 -1.2525 0.640426 -0.6499998 -1.2525 0.640426 -1.3 -1.272944 0.795718 -0.6499998 -1.272944 0.795718 -0.6499997 -2.007792 1.219982 -0.6499996 -2.1525 1.160042 -1.3 -2.007792 1.219982 -1.3 -2.1525 1.160042 -0.6499996 -2.4525 0.6404262 -1.3 -2.4525 0.6404262 -0.6499996 -2.432056 0.7957182 -1.3 -2.432056 0.7957182 -0.6499997 -1.428236 1.06469 -0.6499997 -1.5525 1.160042 -1.3 -1.428236 1.06469 -1.3 -1.5525 1.160042 -0.6499996 -2.432056 0.7957182 -1.3 -2.432056 0.7957182 -0.6499996 -2.372116 0.9404262 -1.3 -2.372116 0.9404262 -0.6499996 -2.4525 0.4404262 -0.6499996 -2.4525 0.6404262 -0.6499998 -1.2525 0.440426 -0.6499996 -2.432056 0.7957182 -0.6499996 -2.372116 0.9404262 -0.6499996 -2.276764 1.06469 -0.6499996 -2.1525 1.160042 -0.6499997 -2.007792 1.219982 -0.6499997 -1.8525 1.240426 -0.6499997 -1.697208 1.219982 -0.6499997 -1.5525 1.160042 -0.6499997 -1.428236 1.06469 -0.6499997 -1.332884 0.940426 -0.6499998 -1.272944 0.795718 -0.6499998 -1.2525 0.640426 -1.3 -1.272944 0.795718 -0.6499998 -1.272944 0.795718 -1.3 -1.332884 0.940426 -0.6499997 -1.332884 0.940426 -0.6499997 -1.697208 1.219982 -0.6499997 -1.8525 1.240426 -1.3 -1.697208 1.219982 -1.3 -1.8525 1.240426 -0.6499997 -1.332884 0.940426 -0.6499997 -1.428236 1.06469 -1.3 -1.332884 0.940426 -1.3 -1.428236 1.06469 -0.6499996 -2.1525 1.160042 -0.6499996 -2.276764 1.06469 -1.3 -2.1525 1.160042 -1.3 -2.276764 1.06469 -0.6499997 -1.5525 1.160042 -0.6499997 -1.697208 1.219982 -1.3 -1.5525 1.160042 -1.3 -1.697208 1.219982 0.6500002 -1.2525 0.440426 1.3 -1.2525 0.440426 0.6500002 -1.2525 0.640426 1.3 -1.2525 0.640426 0.6500003 -2.4525 0.6404262 0.6500003 -2.4525 0.4404262 0.6500003 -2.432056 0.7957182 0.6500002 -1.2525 0.440426 0.6500003 -2.372116 0.9404262 0.6500003 -2.276764 1.06469 0.6500003 -2.1525 1.160042 0.6500003 -2.007792 1.219982 0.6500003 -1.8525 1.240426 0.6500002 -1.697208 1.219982 0.6500002 -1.5525 1.160042 0.6500002 -1.428236 1.06469 0.6500002 -1.332884 0.940426 0.6500002 -1.272944 0.795718 0.6500002 -1.2525 0.640426 -0.6499997 -1.8525 1.240426 -0.6499997 -2.007792 1.219982 -1.3 -1.8525 1.240426 -1.3 -2.007792 1.219982 -0.6499996 -2.372116 0.9404262 -1.3 -2.372116 0.9404262 -0.6499996 -2.276764 1.06469 -1.3 -2.276764 1.06469 -0.6499996 -2.4525 0.4404262 0.6500003 -2.4525 0.4404262 -0.6499996 -2.4525 0.6404262 0.6500003 -2.4525 0.6404262 1.3 -2.8325 0.6404263 1.298288 -2.858606 0.6404263 1.3 -2.4525 0.6404262 0.6500003 -2.4525 0.6404262 1.293186 -2.884264 0.6404263 1.284776 -2.909036 0.6404263 1.273206 -2.9325 0.6404263 1.25867 -2.954252 0.6404263 1.241422 -2.973922 0.6404263 1.221753 -2.99117 0.6404263 1.200001 -3.005704 0.6404263 1.176536 -3.017276 0.6404263 1.151764 -3.025686 0.6404263 1.126106 -3.03079 0.6404263 1.1 -3.0325 0.6404263 -1.1 -3.0325 0.6404263 -0.6499996 -2.4525 0.6404262 -1.3 -2.4525 0.6404262 -1.126106 -3.03079 0.6404263 -1.151764 -3.025686 0.6404263 -1.176535 -3.017276 0.6404263 -1.2 -3.005704 0.6404263 -1.221752 -2.99117 0.6404263 -1.241421 -2.973922 0.6404263 -1.258669 -2.954252 0.6404263 -1.273205 -2.9325 0.6404263 -1.284775 -2.909036 0.6404263 -1.293185 -2.884264 0.6404263 -1.298287 -2.858606 0.6404263 -1.299999 -2.8325 0.6404263 0.6999996 2.3675 1.040425 -0.7000004 2.3675 1.040425 0.6999996 2.3675 1.240425 -0.7000004 2.3675 1.240425 0.77604 0.4333043 2.000426 -0.7760401 0.4333041 2.000426 0.7360399 0.2733044 2.120426 -0.7360401 0.2733041 2.120426 1.3 0.7120003 1.030426 1.3 0.7875002 0.6404257 1.3 0.8359563 1.19197 1.3 0.8079442 0.7957177 1.3 0.8678843 0.9404256 1.3 0.9975004 1.315926 1.3 0.9632363 1.06469 1.3 1.0875 1.160042 1.3 1.185622 1.393848 1.3 1.232208 1.219982 1.3 1.3875 1.420426 1.3 1.3875 1.240426 1.3 1.589378 1.393848 1.3 1.542792 1.219982 1.3 1.6875 1.160042 1.3 1.7775 1.315925 1.3 1.811764 1.064689 1.3 1.939044 1.191969 1.3 1.907116 0.9404255 1.3 1.967056 0.7957175 1.3 2.063 1.030425 1.3 1.9875 0.6404255 1.3 1.9875 0.4404255 1.3 2.14117 0.8404255 1.3 2.3675 0.4404254 1.3 2.140922 0.8423035 1.3 2.3675 0.8404254 1.3 0.6075003 0.6404257 1.3 0.6075002 0.4404257 1.3 0.6340782 0.8423037 1.3 0.7875002 0.4404256 1.3 -1.0725 0.4404259 1.3 -1.0725 0.640426 0.9666662 -1.0725 0.4404259 0.9666662 -1.0725 0.640426 1.3 0.6075002 0.4404257 0.9666659 0.6075001 0.4404257 1.3 0.6075003 0.6404257 0.9666659 0.6075002 0.6404257 -1.299999 -2.8325 0.6404263 -1.299999 -2.8325 0.8404263 -1.3 -2.4525 0.6404262 -1.3 -2.60617 0.8404262 -1.3 -2.605922 0.8423042 -1.3 -2.528 1.030426 -1.3 -2.404044 1.19197 -1.3 -2.432056 0.7957182 -1.3 -2.372116 0.9404262 -1.3 -2.2425 1.315926 -1.3 -2.276764 1.06469 -1.3 -2.1525 1.160042 -1.3 -2.054378 1.393848 -1.3 -2.007792 1.219982 -1.3 -1.8525 1.420426 -1.3 -1.8525 1.240426 -1.3 -1.697208 1.219982 -1.3 -1.650622 1.393848 -1.3 -1.5525 1.160042 -1.3 -1.4625 1.315926 -1.3 -1.428236 1.06469 -1.3 -1.300956 1.19197 -1.3 -1.332884 0.940426 -1.3 -1.272944 0.795718 -1.3 -1.177 1.030426 -1.3 -1.2525 0.640426 -1.3 -1.2525 0.440426 -1.3 -1.0725 0.4404259 -1.3 -1.099078 0.842304 -1.3 -1.0725 0.640426 -0.9666661 0.6074999 0.4404257 -1.3 0.6074998 0.4404257 -0.9666661 0.6074999 0.6404257 -1.3 0.6074998 0.6404257 -0.9666658 -1.0725 0.4404259 -0.9666658 -1.0725 0.640426 -1.3 -1.0725 0.4404259 -1.3 -1.0725 0.640426 1.1 -1.184674 1.040426 1.096666 -1.177 1.030426 1.1 -1.0725 1.040426 1.03396 -1.099078 0.842304 0.9666662 -1.0725 0.640426 1.1 0.6075003 1.040426 0.9666659 0.6075002 0.6404257 1.03396 0.6340782 0.8423037 1.096666 0.7120003 1.030426 1.1 0.7196742 1.040426 -1.1 -1.184674 1.040426 -1.1 -1.0725 1.040426 -1.096666 -1.177 1.030426 -1.03396 -1.099078 0.842304 -0.9666658 -1.0725 0.640426 -0.9666661 0.6074999 0.6404257 -1.1 0.6075 1.040426 -1.03396 0.6340779 0.8423037 -1.096666 0.712 1.030426 -1.1 0.7196739 1.040426 0.9000003 -2.097922 2.240426 0.9705103 -2.097922 2.028894 0.9000002 -1.697921 2.240426 -0.9705097 -2.097922 2.028894 -0.8999997 -2.097922 2.240426 -0.8999997 -1.697922 2.240426 -0.9705097 -2.097922 2.028894 0.9705103 -2.097922 2.028894 -0.8999997 -2.097922 2.240426 0.9000003 -2.097922 2.240426 0.9000003 -2.097922 2.240426 0.9000002 -1.697921 2.240426 -0.8999997 -2.097922 2.240426 -0.8999997 -1.697922 2.240426 1.3 0.9133043 1.440426 1.1 0.9133043 1.440426 1.3 0.9133044 1.640426 1.1 0.9133043 1.640426 1.3 0.7133044 1.640426 1.3 0.9133044 1.640426 1.1 0.7133044 1.640426 1.1 0.9133043 1.640426 0.9 0.1133044 2.240426 -0.9 0.1133041 2.240426 1.3 0.9133043 1.440426 1.3 0.7133044 1.440426 1.1 0.9133043 1.440426 1.1 0.7133044 1.440426 1.1 0.9133043 1.640426 0.8960399 0.9133043 1.640426 0.9 0.1133044 2.240426 -0.9 0.1133041 2.240426 0.77604 0.4333043 2.000426 -0.8960402 0.913304 1.640426 -1.1 0.913304 1.640426 -1.1 0.913304 1.440426 -1.1 0.713304 1.440426 -1.3 0.9133039 1.440426 -1.3 0.7133039 1.440426 -1.1 -2.8325 1.640426 -1.037668 -2.4789 1.82742 -1.1 -0.9923101 1.640426 -0.9632458 -0.9923099 2.05069 -0.9 0.1133041 2.240426 -0.963246 0.04379606 2.05069 -1.1 0.590814 1.640426 -1.1 0.713304 1.640426 -1.1 0.913304 1.640426 -1.1 0.713304 1.640426 -1.1 0.913304 1.640426 -1.3 0.713304 1.640426 -1.3 0.913304 1.640426 -1.1 0.913304 1.440426 -1.3 0.9133039 1.440426 -1.1 0.913304 1.640426 -1.3 0.913304 1.640426 -1.3 0.7133039 1.440426 -1.3 0.713304 1.640426 -1.3 0.9133039 1.440426 -1.3 0.913304 1.640426 1.3 0.7133044 1.640426 1.3 0.7133044 1.440426 1.3 0.9133044 1.640426 1.3 0.9133043 1.440426 0.9632462 -0.9923097 2.05069 0.9 0.1133044 2.240426 0.963246 0.04379636 2.05069 1.1 0.5908144 1.640426 1.1 0.7133044 1.640426 1.1 0.9133043 1.640426 1.1 -0.9923097 1.640426 1.037668 -2.4789 1.82742 1.1 -2.8325 1.640426 1.1 0.9133043 1.640426 1.1 2.3675 1.240425 0.8960399 0.9133043 1.640426 0.6999996 2.3675 1.240425 -0.8960402 0.913304 1.640426 -0.7000004 2.3675 1.240425 -1.1 2.3675 1.240425 -1.1 0.913304 1.640426 1.1 0.9133043 1.440426 1.1 1.3875 1.420426 1.1 0.9133043 1.640426 1.1 1.589378 1.393848 1.1 2.3675 1.240425 1.1 1.185622 1.393848 1.1 0.9975003 1.315926 1.1 1.7775 1.315925 1.1 1.939044 1.191969 1.1 2.055326 1.040426 1.1 2.3675 1.040425 1.1 0.8359563 1.19197 1.1 0.7196742 1.040426 1.1 0.7133044 1.440426 1.1 0.6075003 1.040426 1.1 0.7133044 1.640426 1.1 0.5908144 1.640426 1.1 -0.9923097 1.640426 1.1 -1.0725 1.040426 1.1 -1.184674 1.040426 1.1 -1.300956 1.19197 1.1 -1.4625 1.315926 1.1 -1.650622 1.393848 1.1 -1.8525 1.420426 1.1 -2.054378 1.393848 1.1 -2.8325 1.640426 1.1 -2.2425 1.315926 1.1 -2.8325 1.040426 1.1 -2.404044 1.19197 1.1 -2.520326 1.040426 -1.1 0.6075 1.040426 -1.1 0.713304 1.440426 -1.1 0.7196739 1.040426 -1.1 0.913304 1.440426 -1.1 0.8359559 1.19197 -1.1 0.9975 1.315926 -1.1 0.913304 1.640426 -1.1 1.185622 1.393848 -1.1 1.3875 1.420426 -1.1 1.589378 1.393848 -1.1 2.3675 1.240425 -1.1 1.7775 1.315925 -1.1 1.939044 1.191969 -1.1 2.055326 1.040426 -1.1 2.3675 1.040425 -1.1 0.713304 1.640426 -1.1 0.590814 1.640426 -1.1 -0.9923101 1.640426 -1.1 -1.0725 1.040426 -1.1 -1.184674 1.040426 -1.1 -1.300956 1.19197 -1.1 -1.4625 1.315926 -1.1 -1.650622 1.393848 -1.1 -1.8525 1.420426 -1.1 -2.054378 1.393848 -1.1 -2.8325 1.640426 -1.1 -2.2425 1.315926 -1.1 -2.404044 1.19197 -1.1 -2.520326 1.040426 -1.1 -2.8325 1.040426 1.3 -1.0725 1.040426 1.3 0.6075003 1.040426 1.1 -1.0725 1.040426 1.1 0.6075003 1.040426 0.9666662 -1.0725 1.040426 0.9666659 0.6075003 1.040426 1.3 -1.0725 1.040426 1.3 0.6075003 1.040426 1.3 0.6075003 0.6404257 0.9666662 -1.0725 1.040426 1.1 -1.0725 1.040426 1.3 -1.0725 1.040426 1.3 0.6075003 1.040426 0.9666659 0.6075003 1.040426 1.1 0.6075003 1.040426 -1.1 -1.0725 1.040426 -1.1 0.6075 1.040426 -1.3 -1.0725 1.040426 -1.3 0.6074999 1.040426 -0.9666661 0.6075 1.040426 -0.9666658 -1.0725 1.040426 -1.3 -1.0725 1.040426 -1.3 0.6074999 1.040426 -1.3 0.6074999 1.040426 -0.9666661 0.6075 1.040426 -1.1 0.6075 1.040426 -0.9666658 -1.0725 1.040426 -1.1 -1.0725 1.040426 -1.3 -1.0725 1.040426 0.9666662 -1.0725 1.040426 0.9666659 0.6075003 1.040426 0.9666662 -1.0725 0.640426 0.9666659 0.6075002 0.6404257 -0.9666658 -1.0725 0.640426 -0.9666661 0.6074999 0.6404257 -0.9666658 -1.0725 1.040426 -0.9666661 0.6075 1.040426 0.8688344 -2.8325 1.640426 0.8688344 -2.4789 1.82742 -0.8688336 -2.8325 1.640426 -0.8688337 -2.4789 1.82742 -0.9705097 -2.097922 2.028894 0.9705103 -2.097922 2.028894 1.037668 -2.4789 1.82742 -1.037668 -2.4789 1.82742 -1.1 -2.8325 1.040426 -1.1 -2.8325 1.640426 -0.8688336 -2.8325 1.640426 0.8688344 -2.8325 1.640426 1.1 -2.8325 1.640426 1.1 -2.8325 1.040426 -1.1 2.3675 1.040425 -1.1 2.3675 1.240425 1.1 2.3675 1.040425 1.1 2.3675 1.240425 1.1 0.7133044 1.440426 1.3 0.7133044 1.440426 1.1 0.7133044 1.640426 1.3 0.7133044 1.640426 1.1 0.7133044 1.640426 1.3 0.7133044 1.440426 -1.3 0.7133039 1.440426 -1.1 0.713304 1.440426 -1.3 0.713304 1.640426 -1.1 0.713304 1.640426 -1.3 0.713304 1.640426 -1.1 0.713304 1.440426 1.1 -2.8325 1.640426 -1.1 -2.8325 1.640426</float_array>
+          <technique_common>
+            <accessor source="#ID15_001-mesh-positions-array" count="1238" stride="3">
+              <param name="X" type="float"/>
+              <param name="Y" type="float"/>
+              <param name="Z" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="ID15_001-mesh-normals">
+          <float_array id="ID15_001-mesh-normals-array" count="1497">0 -0.991388 0.1309581 0 -0.9914082 0.1308042 -0.83143 -0.5556295 0 -0.6593081 -0.751873 0 -0.8968917 -0.4422504 0 -1 -1.65569e-6 0 -1 1.43096e-6 0 -1 -1.98097e-6 0 -1 0 0 -1 1.96912e-6 0 -1 -3.02592e-6 0 -1 -8.20144e-7 -1.52829e-7 -1 0 0 -1 1.06618e-6 0 -1 -1.64029e-6 0 -1 0 0 -1 3.02597e-6 -1.23726e-7 -1 -1.97154e-6 -1.54115e-7 -1 0 -1.77504e-7 -1 -1.31676e-6 0 0.751873 -0.6593081 0 -0.751873 -0.6593081 0 0.06534206 -0.9978629 0 0.3214601 -0.9469232 0 2.16744e-7 -1 2.16744e-6 0 -1 0 0.997857 -0.0654332 0 -0.3214601 -0.9469232 0 -0.4423117 -0.8968614 0 0.6593081 -0.751873 0 0.5555732 -0.8314677 0 0.1950772 -0.9807879 0 0.1951066 -0.9807821 0 -0.1951066 -0.9807821 0 -0.1950772 -0.9807879 0 0.9469232 -0.3214601 0 0.946914 -0.3214874 0 -0.5555732 -0.8314677 0 -0.5555591 -0.8314771 0 -0.555538 -0.8314912 0 -0.997857 -0.0654332 0 0.8968917 -0.4422504 0 1 0 0 1 7.84272e-7 2.41039e-7 1 -8.20137e-7 0 1 1.64029e-6 1.52829e-7 1 1.64027e-6 0 1 1.1225e-6 0 1 4.53005e-6 1.20401e-7 1 -2.24263e-5 0 0.4423117 -0.8968614 0 -0.06534206 -0.9978629 0 0.83143 -0.5556295 0 0.8314442 -0.5556084 0 -0.9807996 -0.1950185 0 0.9807996 -0.1950185 0 -0.9469232 -0.3214601 0 0.9486647 -5.66029e-7 -0.3162837 0.9486853 -2.49558e-6 -0.3162218 0.9486774 0 -0.3162456 0.9486843 0 -0.3162249 0.9486845 9.64962e-7 -0.3162243 0.9486833 0 -0.3162277 0.9486847 2.43471e-6 -0.3162235 0.9486662 0 -0.3162791 0 0.6087679 0.7933484 0 0.3826816 0.9238803 0 -0.3826816 -0.9238803 0 -0.3826816 0.9238803 0 -0.6087679 0.7933484 0 -0.9238803 0.3826816 0 -0.7933484 -0.6087679 0 0.7933223 0.6088019 0 0.7933484 0.6087679 0 1 0 0 -0.6087679 -0.7933484 0 -0.1305003 0.9914484 0 0.1305003 0.9914484 0 0.1305303 0.9914444 0 0.6087679 -0.7933484 0 -0.1305003 -0.9914484 0 0.3826816 -0.9238803 0 0.9914484 -0.1305003 -0.9486842 0 -0.3162251 -0.9487012 -5.95656e-5 -0.3161742 -0.9486851 1.94777e-6 -0.3162227 -0.9486666 0 -0.3162781 0 0.9238803 0.3826816 0 0.9238803 -0.3826816 0 -0.9914444 0.1305303 0 -0.9914484 0.1305003 0 -0.9914484 -0.1305003 0 -0.7933484 0.6087679 3.05193e-5 -0.7933484 0.6087679 0 0.9914444 0.1305303 0 -0.7933337 0.6087871 0 0.7933337 0.6087871 0 -0.9914202 0.1307142 0 -0.9913801 0.1310182 0 0.7933484 -0.6087679 0 0.9914484 0.1305003 0 -0.7933223 0.6088019 0 -0.9238803 -0.3826816 -3.05194e-5 -0.7933223 0.6088019 -0.9469232 0.3214601 0 -0.946914 0.3214874 0 -0.8968917 0.4422504 0 -0.83143 0.5556295 0 -0.8314442 0.5556084 0 -0.6593081 0.751873 0 0.751873 0.6593081 0 0.0654332 0.997857 0 -0.751873 0.6593081 0 -0.9807996 0.1950185 0 -0.997857 0.0654332 0 -2.16744e-7 1 0 0 1 -1.08372e-6 0.997857 0.0654332 0 0.9469232 0.3214601 0 0.83143 0.5556295 0 0 0.948685 -0.3162227 0 0.9486847 -0.3162238 0 0 1 6.99962e-7 3.73312e-7 1 -3.64532e-7 2.4302e-7 1 5.52544e-6 2.88496e-7 1 0 3.05631e-7 1 -6.51738e-6 3.22899e-7 1 0 3.40376e-7 1 0 3.58298e-7 1 0 3.76781e-7 1 0 3.9611e-7 1 0 4.16477e-7 1 -1.89405e-5 4.38283e-7 1 0 4.6201e-7 1 0 4.889e-7 1 0 5.26742e-7 1 0 2.23518e-7 1 0 2.23518e-7 1 0 3.73311e-7 1 0 2.76779e-7 1 0 2.69055e-7 1 5.23388e-6 2.59309e-7 1 0 2.47466e-7 1 0 2.33327e-7 1 0 2.16656e-7 1 0 1.9702e-7 1 0 1.73958e-7 1 6.33826e-6 1.46667e-7 1 0 0 1 0 0 1 0 0 1 0 5.26706e-7 1 0.1950185 0.9807996 0 0.3214601 0.9469232 0 -0.3214601 0.9469232 0 -0.4422504 0.8968917 0 0 0.991388 0.1309581 0 0.9914082 0.1308042 -0.1950185 0.9807996 0 0.5556295 0.83143 0 0.5556084 0.8314442 0 -0.9486647 0 -0.316284 -0.9486851 -2.28254e-6 -0.3162227 -0.9486774 5.95678e-5 -0.3162456 -0.9486843 -8.8539e-7 -0.3162249 0.8968917 0.4422504 0 0 0.9914162 0.1307442 0 0.9913801 0.1310182 0.9807996 0.1950185 0 0.6593081 0.751873 0 -0.0654332 0.997857 0 0 -1 0 -0.5556084 0.8314442 0 -0.5556295 0.83143 0 0.4422504 0.8968917 0 0 0.1305003 -0.9914484 -1 -2.48353e-7 0 -1 -1.56493e-7 0 -1 -1.55231e-7 0 -1 -3.19076e-7 0 -1 0 -2.21587e-7 -1 -3.77053e-7 0 -1 0 1.35621e-7 -1 0 -1.54068e-7 -1 0 0 -1 0 1.21788e-7 -1 -1.58157e-6 -1.27133e-7 -1 -3.25036e-6 0 1 2.09703e-7 0 1 3.10461e-7 0 1 3.19076e-7 0 1 3.40133e-7 2.21587e-7 1 -3.77053e-7 0 1 0 -1.35621e-7 1 0 1.54068e-7 1 0 0 1 0 -1.21788e-7 1 1.58157e-6 1.27133e-7 1 -3.25037e-6 0 0 4.47034e-7 1 0 4.47032e-7 1 2.28862e-6 2.03431e-7 1 0 2.79618e-7 1 0 2.88479e-7 1 0 3.05647e-7 1 6.51733e-6 3.22894e-7 1 -7.25337e-6 3.40386e-7 1 0 3.58293e-7 1 -9.57767e-6 3.76781e-7 1 1.14828e-5 3.96113e-7 1 -1.43256e-5 -1.75604e-7 1 0 2.19141e-7 1 0 2.31006e-7 1 0 2.44462e-7 1 0 2.63337e-7 1 0 2.6337e-7 1 0 2.36118e-7 1 0 0 1 0 0 1 0 0 1 5.98358e-6 1.52227e-6 1 -5.71141e-6 1.9702e-7 1 5.50734e-6 2.16659e-7 1 0 2.33334e-7 1 0 2.47462e-7 1 0 2.59306e-7 1 0 2.69048e-7 1 0 2.76785e-7 1 -3.05151e-6 2.03431e-7 1 0 -0.9486844 0.3162247 0 -0.9486835 0.3162275 0 0 -1 1.98682e-7 -1 0 -1.2736e-7 -1.65568e-7 -1 2.48353e-7 -1.65569e-7 -1 2.99869e-7 -1.60699e-7 -1 -0.9995504 0 0.02998632 0 -1.65568e-7 -1 1.52832e-7 -1.73847e-7 -1 0 -1.59655e-7 -1 0 -1.65568e-7 -1 0 -1.65569e-7 -1 0 -1.5637e-7 -1 -1.1141e-6 -3.48158e-7 -1 0 -1.49012e-7 -1 0 -2.05533e-7 -1 3.74588e-6 -1.95581e-7 -1 -3.45204e-6 -1.77144e-7 -1 0 -1.60328e-7 -1 0 -1.44602e-7 -1 1.48801e-6 -9.47872e-7 -1 0 0 -1 0 0 -1 0 0 -1 0 0 -1 0 0 -1 0 0 -1 0 0 -1 0 -2.35282e-7 -1 1.58103e-7 -2.05533e-7 -1 -4.02758e-6 -2.10287e-7 -1 0 -2.19253e-7 -1 0 -2.27994e-7 -1 0 -2.36574e-7 -1 -2.81693e-6 0 -1 0 -1.90202e-7 -1 0 -1.96666e-7 -1 0 -2.03239e-7 -1 0 -2.10043e-7 -1 0 -2.17169e-7 -1 1.46951e-5 -2.2493e-7 -1 0 -2.35264e-7 -1 0.9995504 -2.38311e-7 0.02998644 -2.76802e-7 -1.60699e-7 -1 0 -1.59655e-7 -1 -1.2736e-7 -1.65569e-7 -1 2.48352e-7 -1.65568e-7 -1 0 -1.65568e-7 -1 0 -1.65569e-7 -1 -1 -1.55231e-7 0 -1 -3.19076e-7 0 -1 0 1.26799e-7 -1 -3.77053e-7 -1.75661e-7 -1 0 1.35621e-7 -1 0 -1.54068e-7 -1 0 1.50805e-7 -1 -3.25037e-6 0 1 7.28887e-6 0 1 1.39802e-7 0 1 3.10461e-7 0 1 0 0 1 3.40133e-7 -1.26799e-7 1 0 1.7566e-7 1 0 -1.35621e-7 1 0 1.54068e-7 1 0 -1.50805e-7 1 0 0 1.83399e-7 -1 1.83399e-6 -9.16219e-5 -1.56864e-7 -1 0 -1.46771e-7 -1 0 0 -1 0 0 -1 -2.95417e-6 0 -1 0 0 -1 2.88967e-6 0 -1 0 0 -1 0 0 -1 0 0 -1 0 0 -1 0 0 -1 -3.74616e-6 0 -1 0 0 -1 0 0 -1 4.02748e-6 0 -1 0 0 -1 0 0 -1 0 0 -1 0 -1.22546e-7 -1 0 -1.26803e-7 -1 -7.60138e-6 -1.3111e-7 -1 0 -1.35493e-7 -1 1.21027e-5 -1.40028e-7 -1 0 -1.44779e-7 -1 0 -1.49954e-7 -1 9.1623e-5 -1.56844e-7 -1 -1.70299e-7 1 0 0 0.6 0.8000001 -2.02451e-7 0.5999997 0.8000003 1 2.13236e-6 0 1 1.64029e-6 1.52829e-7 1 -1.06618e-6 0 1 0 0 1 3.02597e-6 1.23726e-7 1 -1.97154e-6 1.54115e-7 1 7.84272e-7 1.77504e-7 1 2.98954e-4 0 1 -1.98097e-6 0 1 7.89465e-6 0 3.57627e-7 -1 0 3.57627e-7 -1 0 -1.78813e-7 1 0 -1.78814e-7 1 0 -1 -1.31676e-6 -4.04695e-7 -1 -8.20145e-7 -1.52828e-7 -1 -2.13235e-6 0 -1 -1.06618e-6 0 -1 1.64027e-6 0 -1 -3.02597e-6 0 -1 1.1225e-6 0 -1 -9.06009e-6 -1.20399e-7 -1.78814e-7 1 0 0 -1 8.94068e-7 0.9486661 3.15042e-6 -0.3162794 0.9486841 -7.00324e-6 -0.3162255 0.948683 3.7232e-5 -0.3162289 0.948683 0 -0.316229 0.9486829 1.68291e-7 -0.316229 0.9486824 -3.7232e-5 -0.3162304 0.9486846 6.91678e-6 -0.3162238 0.9486648 0 -0.3162835 -0.9486657 -1.57521e-6 -0.3162804 -0.9486849 -5.79281e-6 -0.3162231 -0.9486824 3.45725e-5 -0.3162307 -0.9486829 -1.68291e-7 -0.3162292 -0.9486829 -1.68291e-7 -0.3162294 -0.948683 -3.72322e-5 -0.3162286 -0.9486846 6.91678e-6 -0.3162239 -0.9486648 -1.57523e-6 -0.3162835 0.9486839 0 0.316226 -0.9486842 0 0.3162251 2.45663e-7 -1 0 1.32455e-7 -1 1.25234e-6 -2.98023e-7 1 0 0 1.31634e-7 1 0 1.31634e-7 1 0 0.5999999 0.8000001 -1.46118e-6 0.6000003 0.7999999 -3.31137e-7 0.6000005 0.7999998 0 -0.8944273 -0.4472137 0 0.6000005 0.7999997 -1.46119e-6 0.6000001 0.8000001 9.74123e-7 0.6000001 0.8 0 0.6 0.8 -0.9486823 -2.46492e-7 0.316231 -0.9486833 -5.33811e-7 0.3162279 -0.9486836 -1.01686e-6 0.316227 -0.9486837 -1.56265e-6 0.3162267 -0.9486827 0 0.31623 -0.9486828 -1.43819e-7 0.3162295 -0.9486825 3.6328e-6 0.3162301 -0.9486832 0 0.3162283 -0.9486833 0 0.3162282 -2.98024e-7 1 0 0.9486823 1.64542e-7 0.3162307 0.9486826 2.87638e-7 0.3162301 0.9486826 2.77803e-6 0.3162299 0.9486831 0 0.3162284 0.9486835 0 0.3162273 0.9486838 -1.17199e-6 0.3162263 0.9486836 -7.26327e-7 0.316227 0.9486832 -1.52518e-7 0.3162282 0.9486821 1.64328e-7 0.3162313 0 0.2652159 0.9641891 0 0.2652159 0.9641891 -2.2583e-7 0.2652159 0.9641891 0 0.265216 0.9641891 1.55012e-6 0.2652158 0.9641891 1 -3.14241e-7 0 1 0 -7.56545e-7 1 0 -1.38015e-7 1 2.23865e-7 1.9508e-6 1 2.48502e-7 0 1 9.38037e-7 7.05862e-7 1 7.33598e-7 3.16022e-7 1 0 -5.27376e-7 1 -1.95113e-6 0 1 1.255e-7 0 1 0 0 1 0 -1.42032e-7 1 6.02549e-7 1.40131e-7 1 0 1.73955e-7 1 6.10179e-7 2.29576e-7 1 4.42992e-7 3.57721e-7 1 2.76573e-6 -3.64143e-6 1 1.3136e-7 1.2983e-7 1 0 -2.0955e-7 1 3.36749e-7 0 1 0 -6.72671e-7 1 0 -2.93014e-7 -1 -1.95113e-6 0 -1 1.76982e-6 0 -1 0 -5.6936e-7 -1 0 7.56544e-7 -1 -6.76224e-7 1.38014e-7 -1 0 -7.05863e-7 -1 -4.89064e-7 -3.16021e-7 -1 0 5.27376e-7 -1 -1.255e-7 0 -1 0 0 -1 0 1.42032e-7 -1 -6.0255e-7 -1.40131e-7 -1 0 -1.73956e-7 -1 -6.10179e-7 -2.29576e-7 -1 0 -3.57722e-7 -1 0 3.64143e-6 -1 -1.3136e-7 -1.2983e-7 -1 0 2.0955e-7 -1 0 1.5338e-7 -1 0 0 -1 -1.27289e-6 0 0 1.41916e-7 1 7.09579e-7 1.41916e-7 1 0 1.41916e-7 1 0 1.41916e-7 1 1 1.77395e-7 0 1 7.09579e-7 0 1 0 0 0.09950375 0.9950373 0 3.57627e-7 -1 0 0 -1 -1.11758e-6 -1.78814e-7 1 -2.23517e-7 -1.78814e-7 1 -2.23517e-7 2.12873e-7 -1.59655e-7 -1 0 -1.59655e-7 -1 7.09579e-7 1.41916e-7 1 0 1.41916e-7 1 2.12873e-7 -1.59655e-7 -1 0 -1.59655e-7 -1 -1 0 0 -1 -1.77395e-7 0 -1 -1.77395e-7 0 -1.78814e-7 1 -2.23517e-7 8.94066e-7 -1 -2.23516e-6 -1 -1.77395e-7 0 1 0 0 1 1.77395e-7 0 0 -0.4674859 0.8840006 0 -0.4674842 0.8840015 1.59183e-7 -0.4674893 0.8839988 0 -0.4674881 0.8839995 1.63833e-6 -0.4674879 0.8839995 0 -0.4674884 0.8839992 1.98682e-7 -1 9.93411e-7 1.37206e-7 -1 1.71508e-7 1.03137e-6 -1 -2.57843e-6 1.58946e-7 -1 0 2.98023e-7 -1 7.45058e-7 2.98023e-7 -1 7.45058e-7 0.9486837 1.33025e-7 0.3162267 0.9486839 3.48243e-7 0.3162262 -0.9486837 0 0.3162265 -0.9486836 -2.66051e-7 0.3162268 0 0.6000002 0.8 -1.2801e-7 0.6000002 0.7999999 0 -0.4674846 0.8840013 0 -0.4674857 0.8840007 0 -0.4674851 0.884001 0 -0.4674854 0.8840009</float_array>
+          <technique_common>
+            <accessor source="#ID15_001-mesh-normals-array" count="499" stride="3">
+              <param name="X" type="float"/>
+              <param name="Y" type="float"/>
+              <param name="Z" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="ID15_001-mesh-map-0">
+          <float_array id="ID15_001-mesh-map-0-array" count="5088">25.59055 0.936891 20.34121 0.936891 25.59055 0.974195 20.35354 0.974195 25.59055 0.974195 20.34121 0.936891 -35.69321 3.937008 -35.69321 7.874016 -35.17822 3.937008 -35.17822 7.874016 -35.17822 3.937008 -35.69321 7.874016 -21.10233 3.937008 -21.61732 3.937008 -21.10233 7.874016 -21.61732 7.874016 -21.10233 7.874016 -21.61732 3.937008 -41.8798 3.937008 -41.8798 7.874016 -41.36482 3.937008 -41.36482 7.874016 -41.36482 3.937008 -41.8798 7.874016 10.62992 0 10.62992 3.937008 14.17323 0 11.15311 7.911001 14.17323 0 10.62992 3.937008 12.68701 11.61417 14.17323 0 11.15311 7.911001 14.17323 3.937008 14.17323 0 12.68701 11.61417 15.1271 14.79416 14.17323 3.937008 12.68701 11.61417 14.57568 6.993926 14.17323 3.937008 15.1271 14.79416 15.75561 9.84252 14.57568 6.993926 15.1271 14.79416 18.30709 17.23425 15.75561 9.84252 15.1271 14.79416 17.6326 12.28866 15.75561 9.84252 18.30709 17.23425 20.07874 14.16565 17.6326 12.28866 18.30709 17.23425 22.01026 18.76815 20.07874 14.16565 18.30709 17.23425 22.92733 15.34558 20.07874 14.16565 22.01026 18.76815 25.98425 19.29134 22.92733 15.34558 22.01026 18.76815 25.98425 15.74803 22.92733 15.34558 25.98425 19.29134 29.04117 15.34558 25.98425 15.74803 25.98425 19.29134 29.95825 18.76815 29.04117 15.34558 25.98425 19.29134 31.88977 14.16565 29.04117 15.34558 29.95825 18.76815 33.66142 17.23425 31.88977 14.16565 29.95825 18.76815 34.33591 12.28866 31.88977 14.16565 33.66142 17.23425 36.8414 14.79416 34.33591 12.28866 33.66142 17.23425 36.21289 9.84252 34.33591 12.28866 36.8414 14.79416 37.39282 6.993926 36.21289 9.84252 36.8414 14.79416 39.28149 11.61417 37.39282 6.993926 36.8414 14.79416 37.79528 3.937008 37.39282 6.993926 39.28149 11.61417 37.79528 0 37.79528 3.937008 39.28149 11.61417 40.82027 7.874016 37.79528 0 39.28149 11.61417 45.27559 0 37.79528 0 40.82027 7.874016 40.81539 7.911001 40.82027 7.874016 39.28149 11.61417 45.27559 7.874016 45.27559 0 40.82027 7.874016 28.90031 3.937008 28.38533 3.937008 28.90031 7.874016 28.38533 7.874016 28.90031 7.874016 28.38533 3.937008 -28.90031 3.937008 -28.90031 7.874016 -28.38533 3.937008 -28.38533 7.874016 -28.38533 3.937008 -28.90031 7.874016 -17.61604 3.937008 -18.13103 3.937008 -17.61604 7.874016 -18.13103 7.874016 -17.61604 7.874016 -18.13103 3.937008 -1.897009 3.937008 -2.411994 3.937008 -1.897009 7.874016 -2.411994 7.874016 -1.897009 7.874016 -2.411994 3.937008 21.65354 3.937008 -21.65354 3.937008 21.65354 7.874016 -21.65354 7.874016 21.65354 7.874016 -21.65354 3.937008 55.80567 3.937008 55.29068 3.937008 55.80567 7.874016 55.29068 7.874016 55.80567 7.874016 55.29068 3.937008 2.411994 3.937008 1.897009 3.937008 2.411994 7.874016 1.897009 7.874016 2.411994 7.874016 1.897009 3.937008 -5.570798 3.937008 -6.085783 3.937008 -5.570798 7.874016 -6.085783 7.874016 -5.570798 7.874016 -6.085783 3.937008 21.61732 3.937008 21.10233 3.937008 21.61732 7.874016 21.10233 7.874016 21.61732 7.874016 21.10233 3.937008 13.96885 3.937008 13.45387 3.937008 13.96885 7.874016 13.45387 7.874016 13.96885 7.874016 13.45387 3.937008 -9.842939 3.937008 -10.35792 3.937008 -9.842939 7.874016 -10.35792 7.874016 -9.842939 7.874016 -10.35792 3.937008 10.35792 3.937008 9.842939 3.937008 10.35792 7.874016 9.842939 7.874016 10.35792 7.874016 9.842939 3.937008 47.35422 3.937008 46.83924 3.937008 47.35422 7.874016 46.83924 7.874016 47.35422 7.874016 46.83924 3.937008 -13.45387 3.937008 -13.96885 3.937008 -13.45387 7.874016 -13.96885 7.874016 -13.45387 7.874016 -13.96885 3.937008 -55.80567 3.937008 -55.80567 7.874016 -55.29068 3.937008 -55.29068 7.874016 -55.29068 3.937008 -55.80567 7.874016 41.8798 3.937008 41.36482 3.937008 41.8798 7.874016 41.36482 7.874016 41.8798 7.874016 41.36482 3.937008 57.08661 7.874016 57.08661 3.937008 52.63129 7.874016 49.6063 3.937008 52.63129 7.874016 57.08661 3.937008 52.62642 7.911001 52.63129 7.874016 49.6063 3.937008 51.09252 11.61417 52.62642 7.911001 49.6063 3.937008 48.65243 14.79416 51.09252 11.61417 49.6063 3.937008 49.20384 6.993926 48.65243 14.79416 49.6063 3.937008 48.02392 9.84252 48.65243 14.79416 49.20384 6.993926 45.47244 17.23425 48.65243 14.79416 48.02392 9.84252 46.14693 12.28866 45.47244 17.23425 48.02392 9.84252 43.70079 14.16565 45.47244 17.23425 46.14693 12.28866 41.76927 18.76815 45.47244 17.23425 43.70079 14.16565 40.85219 15.34558 41.76927 18.76815 43.70079 14.16565 37.79528 19.29134 41.76927 18.76815 40.85219 15.34558 37.79528 15.74803 37.79528 19.29134 40.85219 15.34558 33.82128 18.76815 37.79528 19.29134 37.79528 15.74803 34.73836 15.34558 33.82128 18.76815 37.79528 15.74803 31.88977 14.16565 33.82128 18.76815 34.73836 15.34558 30.11811 17.23425 33.82128 18.76815 31.88977 14.16565 29.44362 12.28866 30.11811 17.23425 31.88977 14.16565 26.93812 14.79416 30.11811 17.23425 29.44362 12.28866 27.56663 9.84252 26.93812 14.79416 29.44362 12.28866 26.3867 6.993926 26.93812 14.79416 27.56663 9.84252 24.49804 11.61417 26.93812 14.79416 26.3867 6.993926 25.98425 3.937008 24.49804 11.61417 26.3867 6.993926 25.98425 0 24.49804 11.61417 25.98425 3.937008 22.44095 0 24.49804 11.61417 25.98425 0 22.96413 7.911001 24.49804 11.61417 22.44095 0 22.44095 3.937008 22.96413 7.911001 22.44095 0 6.085783 3.937008 5.570798 3.937008 6.085783 7.874016 5.570798 7.874016 6.085783 7.874016 5.570798 3.937008 18.13103 3.937008 17.61604 3.937008 18.13103 7.874016 17.61604 7.874016 18.13103 7.874016 17.61604 3.937008 35.69321 3.937008 35.17822 3.937008 35.69321 7.874016 35.17822 7.874016 35.69321 7.874016 35.17822 3.937008 -52.02281 3.937008 -52.02281 7.874016 -51.50782 3.937008 -51.50782 7.874016 -51.50782 3.937008 -52.02281 7.874016 52.02281 3.937008 51.50782 3.937008 52.02281 7.874016 51.50782 7.874016 52.02281 7.874016 51.50782 3.937008 -47.35422 3.937008 -47.35422 7.874016 -46.83924 3.937008 -46.83924 7.874016 -46.83924 3.937008 -47.35422 7.874016 -39.13044 18.05237 -39.28149 17.84487 -45.27559 18.05237 -40.81539 13.94139 -45.27559 18.05237 -39.28149 17.84487 -40.82027 13.9024 -45.27559 18.05237 -40.81539 13.94139 -43.96325 13.9024 -45.27559 18.05237 -40.82027 13.9024 58.39895 13.9024 52.63129 13.9024 57.08661 18.05237 52.62642 13.94139 57.08661 18.05237 52.63129 13.9024 51.09252 17.84487 57.08661 18.05237 52.62642 13.94139 50.94147 18.05237 57.08661 18.05237 51.09252 17.84487 -21.65354 -16.21385 -21.65354 -20.22214 -25.59055 -16.21385 -25.59055 -20.22214 -25.59055 -16.21385 -21.65354 -20.22214 -21.65354 38.42905 -21.65354 34.42077 -25.59055 38.42905 -25.59055 34.42077 -25.59055 38.42905 -21.65354 34.42077 -25.59055 -24.04134 -25.59055 -20.95804 -12.79528 -24.04134 -12.79528 -20.95804 -12.79528 -24.04134 -25.59055 -20.95804 -25.59055 23.50881 -25.59055 27.51709 -21.65354 23.50881 -21.65354 27.51709 -21.65354 23.50881 -25.59055 27.51709 25.59055 38.42905 25.59055 34.42077 21.65354 38.42905 21.65354 34.42077 21.65354 38.42905 25.59055 34.42077 -25.59055 -29.59245 -25.59055 -25.58417 -21.65354 -29.59245 -21.65354 -25.58417 -21.65354 -29.59245 -25.59055 -25.58417 -25.59055 11.57692 -25.59055 15.58521 -20.35354 11.57692 -21.58793 15.58521 -20.35354 11.57692 -25.59055 15.58521 -25.59055 -14.23642 -25.59055 -11.15312 -12.79528 -14.23642 -12.79528 -11.15312 -12.79528 -14.23642 -25.59055 -11.15312 21.58793 24.1276 21.65354 24.37573 25.59055 24.1276 25.59055 28.13589 25.59055 24.1276 21.65354 24.37573 21.65354 28.13589 25.59055 28.13589 21.65354 24.37573 25.59055 0 12.79528 0 25.59055 3.937008 12.79528 3.937008 25.59055 3.937008 12.79528 0 -21.65354 34.38585 -21.65354 30.37756 -25.59055 34.38585 -25.59055 30.37756 -25.59055 34.38585 -21.65354 30.37756 -25.59055 21.00725 -25.59055 25.01553 -21.65354 21.00725 -21.65354 25.01553 -21.65354 21.00725 -25.59055 25.01553 -25.59055 -19.75964 -25.59055 -16.67635 -12.79528 -19.75964 -12.79528 -16.67635 -12.79528 -19.75964 -25.59055 -16.67635 25.59055 34.38585 25.59055 30.37756 21.65354 34.38585 21.65354 30.37756 21.65354 34.38585 25.59055 30.37756 -25.59055 24.27169 -25.59055 28.27998 -21.65354 24.27169 -21.65354 28.27998 -21.65354 24.27169 -25.59055 28.27998 25.59055 -23.24393 25.59055 -27.25221 21.65354 -23.24393 21.65354 -27.25221 21.65354 -23.24393 25.59055 -27.25221 25.59055 -16.21385 25.59055 -20.22214 21.65354 -16.21385 21.65354 -20.22214 21.65354 -16.21385 25.59055 -20.22214 -21.65354 39.98995 -21.65354 35.98167 -25.59055 39.98995 -25.59055 35.98167 -25.59055 39.98995 -21.65354 35.98167 25.59055 24.55304 25.59055 21.46974 12.79528 24.55304 12.79528 21.46974 12.79528 24.55304 25.59055 21.46974 25.59055 39.98995 25.59055 35.98167 21.65354 39.98995 21.65354 35.98167 21.65354 39.98995 25.59055 35.98167 -25.59055 -26.78972 -25.59055 -23.70643 -12.79528 -26.78972 -12.79528 -23.70643 -12.79528 -26.78972 -25.59055 -23.70643 25.59055 27.05459 25.59055 23.9713 12.79528 27.05459 12.79528 23.9713 12.79528 27.05459 25.59055 23.9713 25.59055 11.57692 20.35354 11.57692 25.59055 15.58521 21.58793 15.58521 25.59055 15.58521 20.35354 11.57692 -25.59055 -35.41579 -25.59055 -31.40751 -21.65354 -35.41579 -21.65354 -31.40751 -21.65354 -35.41579 -25.59055 -31.40751 25.59055 5.753304 12.79528 5.753304 25.59055 8.8366 12.79528 8.8366 25.59055 8.8366 12.79528 5.753304 -58.39895 13.9024 -57.08661 18.05237 -52.63129 13.9024 -52.62642 13.94139 -52.63129 13.9024 -57.08661 18.05237 -51.09252 17.84487 -52.62642 13.94139 -57.08661 18.05237 -50.94147 18.05237 -51.09252 17.84487 -57.08661 18.05237 -20.35354 16.0968 -25.59055 16.0968 -21.58793 20.10509 -25.59055 20.10509 -21.58793 20.10509 -25.59055 16.0968 25.59055 -8.310564 20.35354 -8.310564 25.59055 -4.302279 21.58793 -4.302279 25.59055 -4.302279 20.35354 -8.310564 -25.59055 -8.310564 -25.59055 -4.302279 -20.35354 -8.310564 -21.58793 -4.302279 -20.35354 -8.310564 -25.59055 -4.302279 21.65354 21.00725 21.65354 25.01553 25.59055 21.00725 25.59055 25.01553 25.59055 21.00725 21.65354 25.01553 21.65354 -38.96219 21.65354 -34.95391 25.59055 -38.96219 25.59055 -34.95391 25.59055 -38.96219 21.65354 -34.95391 25.59055 12.03942 12.79528 12.03942 25.59055 15.12271 12.79528 15.12271 25.59055 15.12271 12.79528 12.03942 25.59055 -12.83045 20.35354 -12.83045 25.59055 -8.822163 21.58793 -8.822163 25.59055 -8.822163 20.35354 -12.83045 25.59055 5.290809 19.02887 5.290809 25.59055 9.299095 20.35354 9.299095 25.59055 9.299095 19.02887 5.290809 -25.59055 -1.029947 -25.59055 2.053349 -12.79528 -1.029947 -12.79528 2.053349 -12.79528 -1.029947 -25.59055 2.053349 20.35354 16.0968 21.58793 20.10509 25.59055 16.0968 25.59055 20.10509 25.59055 16.0968 21.58793 20.10509 25.59055 -21.88901 21.58793 -21.88901 25.59055 -17.88073 21.65354 -21.64089 25.59055 -17.88073 21.58793 -21.88901 21.65354 -17.88073 25.59055 -17.88073 21.65354 -21.64089 19.02887 6.832458 20.35354 10.84074 25.59055 6.832458 25.59055 10.84074 25.59055 6.832458 20.35354 10.84074 21.65354 24.27169 21.65354 28.27998 25.59055 24.27169 25.59055 28.27998 25.59055 24.27169 21.65354 28.27998 21.58793 -14.69891 21.65354 -14.45079 25.59055 -14.69891 25.59055 -10.69063 25.59055 -14.69891 21.65354 -14.45079 21.65354 -10.69063 25.59055 -10.69063 21.65354 -14.45079 -21.58793 16.93751 -25.59055 16.93751 -21.65354 17.18563 -25.59055 20.94579 -21.65354 17.18563 -25.59055 16.93751 -21.65354 20.94579 -21.65354 17.18563 -25.59055 20.94579 -19.02887 5.290809 -25.59055 5.290809 -20.35354 9.299095 -25.59055 9.299095 -20.35354 9.299095 -25.59055 5.290809 -21.65354 -20.49555 -21.65354 -24.50383 -25.59055 -20.49555 -25.59055 -24.50383 -25.59055 -20.49555 -21.65354 -24.50383 -21.58793 24.1276 -25.59055 24.1276 -21.65354 24.37573 -25.59055 28.13589 -21.65354 24.37573 -25.59055 24.1276 -21.65354 28.13589 -21.65354 24.37573 -25.59055 28.13589 -21.58793 -14.69891 -25.59055 -14.69891 -21.65354 -14.45079 -25.59055 -10.69063 -21.65354 -14.45079 -25.59055 -14.69891 -21.65354 -10.69063 -21.65354 -14.45079 -25.59055 -10.69063 -25.59055 -38.96219 -25.59055 -34.95391 -21.65354 -38.96219 -21.65354 -34.95391 -21.65354 -38.96219 -25.59055 -34.95391 -21.65354 -23.24393 -21.65354 -27.25221 -25.59055 -23.24393 -25.59055 -27.25221 -25.59055 -23.24393 -21.65354 -27.25221 -20.34121 0.936891 -25.59055 0.936891 -20.35354 0.974195 -25.59055 0.974195 -20.35354 0.974195 -25.59055 0.936891 25.59055 17.4 12.79528 17.4 25.59055 20.4833 12.79528 20.4833 25.59055 20.4833 12.79528 17.4 21.65354 -35.41579 21.65354 -31.40751 25.59055 -35.41579 25.59055 -31.40751 25.59055 -35.41579 21.65354 -31.40751 -25.59055 -12.83045 -25.59055 -8.822163 -20.35354 -12.83045 -21.58793 -8.822163 -20.35354 -12.83045 -25.59055 -8.822163 -19.02887 6.832458 -25.59055 6.832458 -20.35354 10.84074 -25.59055 10.84074 -20.35354 10.84074 -25.59055 6.832458 21.58793 16.93751 21.65354 17.18563 25.59055 16.93751 25.59055 20.94579 25.59055 16.93751 21.65354 17.18563 21.65354 20.94579 25.59055 20.94579 21.65354 17.18563 21.65354 23.50881 21.65354 27.51709 25.59055 23.50881 25.59055 27.51709 25.59055 23.50881 21.65354 27.51709 -25.59055 -7.84807 -25.59055 -4.764774 -12.79528 -7.84807 -12.79528 -4.764774 -12.79528 -7.84807 -25.59055 -4.764774 -25.59055 -21.88901 -25.59055 -17.88073 -21.58793 -21.88901 -21.65354 -21.64089 -21.58793 -21.88901 -25.59055 -17.88073 -21.65354 -17.88073 -21.65354 -21.64089 -25.59055 -17.88073 35.65502 0 35.65502 7.874016 36.17001 0 36.17001 7.874016 36.17001 0 35.65502 7.874016 30.77183 0 30.77183 7.874016 31.28682 0 31.28682 7.874016 31.28682 0 30.77183 7.874016 25.35772 0 25.35772 7.874016 25.8727 0 25.8727 7.874016 25.8727 0 25.35772 7.874016 13.82977 0 13.31478 0 13.82977 7.874016 13.31478 7.874016 13.82977 7.874016 13.31478 0 -19.50532 7.874016 -19.50532 0 -20.02031 7.874016 -20.02031 0 -20.02031 7.874016 -19.50532 0 18.90351 0 18.38852 0 18.90351 7.874016 18.38852 7.874016 18.90351 7.874016 18.38852 0 19.50532 0 19.50532 7.874016 20.02031 0 20.02031 7.874016 20.02031 0 19.50532 7.874016 39.92374 0 39.92374 7.874016 40.43873 0 40.43873 7.874016 40.43873 0 39.92374 7.874016 43.50495 0 43.50495 7.874016 44.01993 0 44.01993 7.874016 44.01993 0 43.50495 7.874016 21.65354 0 -21.65354 0 21.65354 7.874016 -21.65354 7.874016 21.65354 7.874016 -21.65354 0 -43.50495 7.874016 -43.50495 0 -44.01993 7.874016 -44.01993 0 -44.01993 7.874016 -43.50495 0 -35.65502 7.874016 -35.65502 0 -36.17001 7.874016 -36.17001 0 -36.17001 7.874016 -35.65502 0 -25.35772 7.874016 -25.35772 0 -25.8727 7.874016 -25.8727 0 -25.8727 7.874016 -25.35772 0 25.59055 -20.49555 25.59055 -24.50383 21.65354 -20.49555 21.65354 -24.50383 21.65354 -20.49555 25.59055 -24.50383 20.34121 21.37235 -20.34121 21.37235 21.65354 25.52232 -21.65354 25.52232 21.65354 25.52232 -20.34121 21.37235 13.77953 25.52232 21.65354 25.52232 -21.65354 25.52232 -13.77953 25.52232 13.77953 25.52232 -21.65354 25.52232 20.34121 40.82027 20.34121 43.96325 25.59055 40.82027 21.65354 49.2126 25.59055 40.82027 20.34121 43.96325 22.16742 49.17892 25.59055 40.82027 21.65354 49.2126 22.67252 49.07845 25.59055 40.82027 22.16742 49.17892 23.16017 48.91291 25.59055 40.82027 22.67252 49.07845 23.62205 48.68514 25.59055 40.82027 23.16017 48.91291 24.05024 48.39903 25.59055 40.82027 23.62205 48.68514 24.43743 48.05947 25.59055 40.82027 24.05024 48.39903 24.77698 47.67229 25.59055 40.82027 24.43743 48.05947 25.06309 47.24409 25.59055 40.82027 24.77698 47.67229 25.29086 46.78222 25.59055 40.82027 25.06309 47.24409 25.4564 46.29456 25.59055 40.82027 25.29086 46.78222 25.55687 45.78947 25.59055 40.82027 25.4564 46.29456 25.59055 45.27559 25.59055 40.82027 25.55687 45.78947 20.34121 43.96325 -20.34121 43.96325 21.65354 49.2126 21.65354 49.2126 -20.34121 43.96325 -21.65354 49.2126 -20.34121 43.96325 -20.34121 40.82027 -21.65354 49.2126 -21.65354 49.2126 -20.34121 40.82027 -22.16742 49.17892 -22.16742 49.17892 -20.34121 40.82027 -22.67252 49.07845 -22.67252 49.07845 -20.34121 40.82027 -23.16017 48.91291 -23.16017 48.91291 -20.34121 40.82027 -23.62205 48.68514 -23.62205 48.68514 -20.34121 40.82027 -24.05024 48.39903 -24.05024 48.39903 -20.34121 40.82027 -24.43743 48.05947 -24.43743 48.05947 -20.34121 40.82027 -24.77698 47.67229 -24.77698 47.67229 -20.34121 40.82027 -25.06309 47.24409 -25.06309 47.24409 -20.34121 40.82027 -25.29086 46.78222 -25.29086 46.78222 -20.34121 40.82027 -25.4564 46.29456 -25.4564 46.29456 -20.34121 40.82027 -25.55687 45.78947 -25.55687 45.78947 -20.34121 40.82027 -25.59055 45.27559 -25.59055 40.82027 -25.59055 45.27559 -20.34121 40.82027 12.66214 0 12.14715 0 12.66214 7.874016 12.14715 7.874016 12.66214 7.874016 12.14715 0 6.208524 0 5.693538 0 6.208524 7.874016 5.693538 7.874016 6.208524 7.874016 5.693538 0 -5.693538 0 -6.208524 0 -5.693538 7.874016 -6.208524 7.874016 -5.693538 7.874016 -6.208524 0 0.861902 0 0.346916 0 0.861902 7.874016 0.346916 7.874016 0.861902 7.874016 0.346916 0 -20.34121 2.478539 -25.59055 2.478539 -20.35354 2.515843 -25.59055 2.515843 -20.35354 2.515843 -25.59055 2.478539 -12.14715 0 -12.66214 0 -12.14715 7.874016 -12.66214 7.874016 -12.14715 7.874016 -12.66214 0 21.65354 -29.59245 21.65354 -25.58417 25.59055 -29.59245 25.59055 -25.58417 25.59055 -29.59245 21.65354 -25.58417 -6.892015 0 -7.407 0 -6.892015 7.874016 -7.407 7.874016 -6.892015 7.874016 -7.407 0 39.13044 18.05237 45.27559 18.05237 39.28149 17.84487 40.81539 13.94139 39.28149 17.84487 45.27559 18.05237 40.82027 13.9024 40.81539 13.94139 45.27559 18.05237 43.96325 13.9024 40.82027 13.9024 45.27559 18.05237 -30.77183 7.874016 -30.77183 0 -31.28682 7.874016 -31.28682 0 -31.28682 7.874016 -30.77183 0 25.59055 2.478539 20.34121 2.478539 25.59055 2.515843 20.35354 2.515843 25.59055 2.515843 20.34121 2.478539 -39.92374 7.874016 -39.92374 0 -40.43873 7.874016 -40.43873 0 -40.43873 7.874016 -39.92374 0 -13.31478 0 -13.82977 0 -13.31478 7.874016 -13.82977 7.874016 -13.31478 7.874016 -13.82977 0 -18.38852 0 -18.90351 0 -18.38852 7.874016 -18.90351 7.874016 -18.38852 7.874016 -18.90351 0 25.59055 0 12.79528 0 25.59055 3.937008 12.79528 3.937008 25.59055 3.937008 12.79528 0 7.407 0 6.892015 0 7.407 7.874016 6.892015 7.874016 7.407 7.874016 6.892015 0 -0.346916 0 -0.861902 0 -0.346916 7.874016 -0.861902 7.874016 -0.346916 7.874016 -0.861902 0 25.59055 27.81748 25.59055 24.73419 12.79528 27.81748 12.79528 24.73419 12.79528 27.81748 25.59055 24.73419 25.59055 -1.029947 12.79528 -1.029947 25.59055 2.053349 12.79528 2.053349 25.59055 2.053349 12.79528 -1.029947 -12.79528 0 -25.59055 0 -12.79528 3.937008 -25.59055 3.937008 -12.79528 3.937008 -25.59055 0 -12.79528 27.81748 -12.79528 24.73419 -25.59055 27.81748 -25.59055 24.73419 -25.59055 27.81748 -12.79528 24.73419 -12.79528 27.05459 -12.79528 23.9713 -25.59055 27.05459 -25.59055 23.9713 -25.59055 27.05459 -12.79528 23.9713 25.59055 -14.23642 12.79528 -14.23642 25.59055 -11.15312 12.79528 -11.15312 25.59055 -11.15312 12.79528 -14.23642 -12.79528 5.753304 -25.59055 5.753304 -12.79528 8.8366 -25.59055 8.8366 -12.79528 8.8366 -25.59055 5.753304 -12.79528 17.4 -25.59055 17.4 -12.79528 20.4833 -25.59055 20.4833 -12.79528 20.4833 -25.59055 17.4 -12.79528 12.03942 -25.59055 12.03942 -12.79528 15.12271 -25.59055 15.12271 -12.79528 15.12271 -25.59055 12.03942 -12.79528 24.55304 -12.79528 21.46974 -25.59055 24.55304 -25.59055 21.46974 -25.59055 24.55304 -12.79528 21.46974 12.79528 -19.75964 12.79528 -16.67635 25.59055 -19.75964 25.59055 -16.67635 25.59055 -19.75964 12.79528 -16.67635 12.79528 -26.78972 12.79528 -23.70643 25.59055 -26.78972 25.59055 -23.70643 25.59055 -26.78972 12.79528 -23.70643 25.59055 -7.84807 12.79528 -7.84807 25.59055 -4.764774 12.79528 -4.764774 25.59055 -4.764774 12.79528 -7.84807 12.79528 -24.04134 12.79528 -20.95804 25.59055 -24.04134 25.59055 -20.95804 25.59055 -24.04134 12.79528 -20.95804 14.17323 0 14.17323 3.937008 37.79528 0 14.57568 6.993926 37.79528 0 14.17323 3.937008 15.75561 9.84252 37.79528 0 14.57568 6.993926 17.6326 12.28866 37.79528 0 15.75561 9.84252 20.07874 14.16565 37.79528 0 17.6326 12.28866 22.92733 15.34558 37.79528 0 20.07874 14.16565 25.98425 15.74803 37.79528 0 22.92733 15.34558 29.04117 15.34558 37.79528 0 25.98425 15.74803 31.88977 14.16565 37.79528 0 29.04117 15.34558 34.33591 12.28866 37.79528 0 31.88977 14.16565 36.21289 9.84252 37.79528 0 34.33591 12.28866 37.39282 6.993926 37.79528 0 36.21289 9.84252 37.79528 3.937008 37.79528 0 37.39282 6.993926 -14.17323 3.937008 -14.17323 0 -14.57568 6.993926 -37.79528 0 -14.57568 6.993926 -14.17323 0 -15.75561 9.84252 -14.57568 6.993926 -37.79528 0 -17.6326 12.28866 -15.75561 9.84252 -37.79528 0 -20.07874 14.16565 -17.6326 12.28866 -37.79528 0 -22.92733 15.34558 -20.07874 14.16565 -37.79528 0 -25.98425 15.74803 -22.92733 15.34558 -37.79528 0 -29.04117 15.34558 -25.98425 15.74803 -37.79528 0 -31.88977 14.16565 -29.04117 15.34558 -37.79528 0 -34.33591 12.28866 -31.88977 14.16565 -37.79528 0 -36.21289 9.84252 -34.33591 12.28866 -37.79528 0 -37.39282 6.993926 -36.21289 9.84252 -37.79528 0 -37.79528 3.937008 -37.39282 6.993926 -37.79528 0 -12.79528 0 -25.59055 0 -12.79528 3.937008 -25.59055 3.937008 -12.79528 3.937008 -25.59055 0 -21.65354 -61.02362 -20.34121 -58.39895 21.65354 -61.02362 20.34121 -58.39895 21.65354 -61.02362 -20.34121 -58.39895 20.34121 -52.63129 21.65354 -61.02362 20.34121 -58.39895 25.59055 -52.63129 21.65354 -61.02362 20.34121 -52.63129 22.16742 -60.98994 21.65354 -61.02362 25.59055 -52.63129 22.67252 -60.88947 22.16742 -60.98994 25.59055 -52.63129 23.16017 -60.72393 22.67252 -60.88947 25.59055 -52.63129 23.62205 -60.49616 23.16017 -60.72393 25.59055 -52.63129 24.05024 -60.21005 23.62205 -60.49616 25.59055 -52.63129 24.43743 -59.8705 24.05024 -60.21005 25.59055 -52.63129 24.77698 -59.48331 24.43743 -59.8705 25.59055 -52.63129 25.06309 -59.05512 24.77698 -59.48331 25.59055 -52.63129 25.29086 -58.59324 25.06309 -59.05512 25.59055 -52.63129 25.4564 -58.10559 25.29086 -58.59324 25.59055 -52.63129 25.55687 -57.60049 25.4564 -58.10559 25.59055 -52.63129 25.59055 -57.08661 25.55687 -57.60049 25.59055 -52.63129 -25.59055 -57.08661 -25.59055 -52.63129 -25.55687 -57.60049 -20.34121 -52.63129 -25.55687 -57.60049 -25.59055 -52.63129 -25.4564 -58.10559 -25.55687 -57.60049 -20.34121 -52.63129 -25.29086 -58.59324 -25.4564 -58.10559 -20.34121 -52.63129 -25.06309 -59.05512 -25.29086 -58.59324 -20.34121 -52.63129 -24.77698 -59.48331 -25.06309 -59.05512 -20.34121 -52.63129 -24.43743 -59.8705 -24.77698 -59.48331 -20.34121 -52.63129 -24.05024 -60.21005 -24.43743 -59.8705 -20.34121 -52.63129 -23.62205 -60.49616 -24.05024 -60.21005 -20.34121 -52.63129 -23.16017 -60.72393 -23.62205 -60.49616 -20.34121 -52.63129 -22.67252 -60.88947 -23.16017 -60.72393 -20.34121 -52.63129 -22.16742 -60.98994 -22.67252 -60.88947 -20.34121 -52.63129 -21.65354 -61.02362 -22.16742 -60.98994 -20.34121 -52.63129 -20.34121 -58.39895 -21.65354 -61.02362 -20.34121 -52.63129 20.34121 -10.99742 -20.34121 -10.99742 21.65354 -6.847452 -21.65354 -6.847452 21.65354 -6.847452 -20.34121 -10.99742 11.81102 -6.847452 21.65354 -6.847452 -21.65354 -6.847452 -11.81102 -6.847452 11.81102 -6.847452 -21.65354 -6.847452 11.81102 11.81102 -11.81102 11.81102 11.81102 15.74803 -11.81102 15.74803 11.81102 15.74803 -11.81102 11.81102 25.59055 14.17323 25.59055 10.62992 12.79528 14.17323 19.02887 10.62992 12.79528 14.17323 25.59055 10.62992 12.79528 -25.98425 12.79528 14.17323 19.02887 10.62992 12.79528 -49.6063 12.79528 14.17323 12.79528 -25.98425 -12.79528 -49.6063 12.79528 14.17323 12.79528 -49.6063 -12.79528 -25.98425 12.79528 14.17323 -12.79528 -49.6063 19.02887 10.62992 19.02887 -22.44095 12.79528 -25.98425 19.02887 -22.44095 25.59055 -22.44095 12.79528 -25.98425 25.59055 -25.98425 12.79528 -25.98425 25.59055 -22.44095 -12.79528 -25.98425 -12.79528 37.79528 12.79528 14.17323 -12.79528 37.79528 -21.65354 49.2126 12.79528 14.17323 12.79528 14.17323 -21.65354 49.2126 12.79528 37.79528 -21.65354 49.2126 21.65354 49.2126 12.79528 37.79528 21.65354 49.2126 22.16742 49.17892 12.79528 37.79528 22.16742 49.17892 22.67252 49.07845 12.79528 37.79528 22.67252 49.07845 23.16017 48.91291 12.79528 37.79528 23.16017 48.91291 23.62205 48.68514 12.79528 37.79528 23.62205 48.68514 24.05024 48.39903 12.79528 37.79528 24.05024 48.39903 24.43743 48.05947 12.79528 37.79528 24.43743 48.05947 24.77698 47.67229 12.79528 37.79528 24.77698 47.67229 25.06309 47.24409 12.79528 37.79528 25.06309 47.24409 25.29086 46.78222 12.79528 37.79528 25.29086 46.78222 25.4564 46.29456 12.79528 37.79528 25.4564 46.29456 25.55687 45.78947 12.79528 37.79528 25.55687 45.78947 25.59055 45.27559 12.79528 37.79528 25.59055 37.79528 12.79528 37.79528 25.59055 45.27559 -25.59055 37.79528 -21.65354 49.2126 -12.79528 37.79528 -22.16742 49.17892 -21.65354 49.2126 -25.59055 37.79528 -22.67252 49.07845 -22.16742 49.17892 -25.59055 37.79528 -23.16017 48.91291 -22.67252 49.07845 -25.59055 37.79528 -23.62205 48.68514 -23.16017 48.91291 -25.59055 37.79528 -24.05024 48.39903 -23.62205 48.68514 -25.59055 37.79528 -24.43743 48.05947 -24.05024 48.39903 -25.59055 37.79528 -24.77698 47.67229 -24.43743 48.05947 -25.59055 37.79528 -25.06309 47.24409 -24.77698 47.67229 -25.59055 37.79528 -25.29086 46.78222 -25.06309 47.24409 -25.59055 37.79528 -25.4564 46.29456 -25.29086 46.78222 -25.59055 37.79528 -25.55687 45.78947 -25.4564 46.29456 -25.59055 37.79528 -25.59055 45.27559 -25.55687 45.78947 -25.59055 37.79528 -12.79528 37.79528 -12.79528 -25.98425 -12.79528 14.17323 -12.79528 14.17323 -12.79528 -25.98425 -19.02887 -22.44095 -19.02887 -22.44095 -19.02887 10.62992 -12.79528 14.17323 -25.59055 14.17323 -12.79528 14.17323 -19.02887 10.62992 -25.59055 10.62992 -25.59055 14.17323 -19.02887 10.62992 -25.59055 -25.98425 -19.02887 -22.44095 -12.79528 -25.98425 -25.59055 -22.44095 -19.02887 -22.44095 -25.59055 -25.98425 25.59055 0 12.79528 0 25.59055 3.937008 12.79528 3.937008 25.59055 3.937008 12.79528 0 25.59055 -26.04666 25.59055 -29.12996 12.79528 -26.04666 12.79528 -29.12996 12.79528 -26.04666 25.59055 -29.12996 -25.59055 16.5593 -25.59055 19.6426 -12.79528 16.5593 -12.79528 19.6426 -12.79528 16.5593 -25.59055 19.6426 25.59055 -35.4164 25.59055 -38.4997 12.79528 -35.4164 12.79528 -38.4997 12.79528 -35.4164 25.59055 -38.4997 -25.59055 24.5901 -25.59055 27.67339 -12.79528 24.5901 -12.79528 27.67339 -12.79528 24.5901 -25.59055 27.67339 -25.59055 34.88326 -25.59055 37.96656 -12.79528 34.88326 -12.79528 37.96656 -12.79528 34.88326 -25.59055 37.96656 25.59055 -12.36795 12.79528 -12.36795 25.59055 -9.284657 12.79528 -9.284657 25.59055 -9.284657 12.79528 -12.36795 25.59055 -21.42652 12.79528 -21.42652 25.59055 -18.34322 12.79528 -18.34322 25.59055 -18.34322 12.79528 -21.42652 -25.59055 30.84006 -25.59055 33.92335 -12.79528 30.84006 -12.79528 33.92335 -12.79528 30.84006 -25.59055 33.92335 25.59055 -31.87001 25.59055 -34.9533 12.79528 -31.87001 12.79528 -34.9533 12.79528 -31.87001 25.59055 -34.9533 -25.59055 7.294952 -25.59055 10.37825 -12.79528 7.294952 -12.79528 10.37825 -12.79528 7.294952 -25.59055 10.37825 25.59055 -2.571595 12.79528 -2.571595 25.59055 0.511701 12.79528 0.511701 25.59055 0.511701 12.79528 -2.571595 -25.59055 36.44417 -25.59055 39.52746 -12.79528 36.44417 -12.79528 39.52746 -12.79528 36.44417 -25.59055 39.52746 25.59055 7.294952 12.79528 7.294952 25.59055 10.37825 12.79528 10.37825 25.59055 10.37825 12.79528 7.294952 -12.79528 -31.87001 -12.79528 -34.9533 -25.59055 -31.87001 -25.59055 -34.9533 -25.59055 -31.87001 -12.79528 -34.9533 -12.79528 -2.571595 -25.59055 -2.571595 -12.79528 0.511701 -25.59055 0.511701 -12.79528 0.511701 -25.59055 -2.571595 12.79528 30.84006 12.79528 33.92335 25.59055 30.84006 25.59055 33.92335 25.59055 30.84006 12.79528 33.92335 -12.79528 -12.36795 -25.59055 -12.36795 -12.79528 -9.284657 -25.59055 -9.284657 -12.79528 -9.284657 -25.59055 -12.36795 -49.6063 0 -49.6063 3.937008 -25.98425 0 -49.20384 6.993926 -25.98425 0 -49.6063 3.937008 -48.02392 9.84252 -25.98425 0 -49.20384 6.993926 -46.14693 12.28866 -25.98425 0 -48.02392 9.84252 -43.70079 14.16565 -25.98425 0 -46.14693 12.28866 -40.85219 15.34558 -25.98425 0 -43.70079 14.16565 -37.79528 15.74803 -25.98425 0 -40.85219 15.34558 -34.73836 15.34558 -25.98425 0 -37.79528 15.74803 -31.88977 14.16565 -25.98425 0 -34.73836 15.34558 -29.44362 12.28866 -25.98425 0 -31.88977 14.16565 -27.56663 9.84252 -25.98425 0 -29.44362 12.28866 -26.3867 6.993926 -25.98425 0 -27.56663 9.84252 -25.98425 3.937008 -25.98425 0 -26.3867 6.993926 25.59055 16.5593 12.79528 16.5593 25.59055 19.6426 12.79528 19.6426 25.59055 19.6426 12.79528 16.5593 12.79528 36.44417 12.79528 39.52746 25.59055 36.44417 25.59055 39.52746 25.59055 36.44417 12.79528 39.52746 12.79528 24.5901 12.79528 27.67339 25.59055 24.5901 25.59055 27.67339 25.59055 24.5901 12.79528 27.67339 -12.79528 -26.04666 -12.79528 -29.12996 -25.59055 -26.04666 -25.59055 -29.12996 -25.59055 -26.04666 -12.79528 -29.12996 12.79528 34.88326 12.79528 37.96656 25.59055 34.88326 25.59055 37.96656 25.59055 34.88326 12.79528 37.96656 -12.79528 0 -25.59055 0 -12.79528 3.937008 -25.59055 3.937008 -12.79528 3.937008 -25.59055 0 49.6063 3.937008 49.6063 0 49.20384 6.993926 25.98425 0 49.20384 6.993926 49.6063 0 48.02392 9.84252 49.20384 6.993926 25.98425 0 46.14693 12.28866 48.02392 9.84252 25.98425 0 43.70079 14.16565 46.14693 12.28866 25.98425 0 40.85219 15.34558 43.70079 14.16565 25.98425 0 37.79528 15.74803 40.85219 15.34558 25.98425 0 34.73836 15.34558 37.79528 15.74803 25.98425 0 31.88977 14.16565 34.73836 15.34558 25.98425 0 29.44362 12.28866 31.88977 14.16565 25.98425 0 27.56663 9.84252 29.44362 12.28866 25.98425 0 26.3867 6.993926 27.56663 9.84252 25.98425 0 25.98425 3.937008 26.3867 6.993926 25.98425 0 -12.79528 -35.4164 -12.79528 -38.4997 -25.59055 -35.4164 -25.59055 -38.4997 -25.59055 -35.4164 -12.79528 -38.4997 -12.79528 -21.42652 -25.59055 -21.42652 -12.79528 -18.34322 -25.59055 -18.34322 -12.79528 -18.34322 -25.59055 -21.42652 12.79528 0 -12.79528 0 12.79528 3.937008 -12.79528 3.937008 12.79528 3.937008 -12.79528 0 25.59055 -57.08661 25.55687 -57.60049 25.59055 -49.6063 12.79528 -49.6063 25.59055 -49.6063 25.55687 -57.60049 25.4564 -58.10559 12.79528 -49.6063 25.55687 -57.60049 25.29086 -58.59324 12.79528 -49.6063 25.4564 -58.10559 25.06309 -59.05512 12.79528 -49.6063 25.29086 -58.59324 24.77698 -59.48331 12.79528 -49.6063 25.06309 -59.05512 24.43743 -59.8705 12.79528 -49.6063 24.77698 -59.48331 24.05024 -60.21005 12.79528 -49.6063 24.43743 -59.8705 23.62205 -60.49616 12.79528 -49.6063 24.05024 -60.21005 23.16017 -60.72393 12.79528 -49.6063 23.62205 -60.49616 22.67252 -60.88947 12.79528 -49.6063 23.16017 -60.72393 22.16742 -60.98994 12.79528 -49.6063 22.67252 -60.88947 21.65354 -61.02362 12.79528 -49.6063 22.16742 -60.98994 -21.65354 -61.02362 12.79528 -49.6063 21.65354 -61.02362 -12.79528 -49.6063 12.79528 -49.6063 -21.65354 -61.02362 -25.59055 -49.6063 -12.79528 -49.6063 -21.65354 -61.02362 -22.16742 -60.98994 -25.59055 -49.6063 -21.65354 -61.02362 -22.67252 -60.88947 -25.59055 -49.6063 -22.16742 -60.98994 -23.16017 -60.72393 -25.59055 -49.6063 -22.67252 -60.88947 -23.62205 -60.49616 -25.59055 -49.6063 -23.16017 -60.72393 -24.05024 -60.21005 -25.59055 -49.6063 -23.62205 -60.49616 -24.43743 -59.8705 -25.59055 -49.6063 -24.05024 -60.21005 -24.77698 -59.48331 -25.59055 -49.6063 -24.43743 -59.8705 -25.06309 -59.05512 -25.59055 -49.6063 -24.77698 -59.48331 -25.29086 -58.59324 -25.59055 -49.6063 -25.06309 -59.05512 -25.4564 -58.10559 -25.59055 -49.6063 -25.29086 -58.59324 -25.55687 -57.60049 -25.59055 -49.6063 -25.4564 -58.10559 -25.59055 -57.08661 -25.59055 -49.6063 -25.55687 -57.60049 13.77953 11.81102 -13.77953 11.81102 13.77953 15.74803 -13.77953 15.74803 13.77953 15.74803 -13.77953 11.81102 15.27636 12.6645 -15.27636 12.6645 14.48896 16.60151 -14.48896 16.60151 14.48896 16.60151 -15.27636 12.6645 -12.68701 11.61417 -14.17323 3.937008 -15.1271 14.79416 -14.57568 6.993926 -15.1271 14.79416 -14.17323 3.937008 -15.75561 9.84252 -15.1271 14.79416 -14.57568 6.993926 -18.30709 17.23425 -15.1271 14.79416 -15.75561 9.84252 -17.6326 12.28866 -18.30709 17.23425 -15.75561 9.84252 -20.07874 14.16565 -18.30709 17.23425 -17.6326 12.28866 -22.01026 18.76815 -18.30709 17.23425 -20.07874 14.16565 -22.92733 15.34558 -22.01026 18.76815 -20.07874 14.16565 -25.98425 19.29134 -22.01026 18.76815 -22.92733 15.34558 -25.98425 15.74803 -25.98425 19.29134 -22.92733 15.34558 -29.95825 18.76815 -25.98425 19.29134 -25.98425 15.74803 -29.04117 15.34558 -29.95825 18.76815 -25.98425 15.74803 -31.88977 14.16565 -29.95825 18.76815 -29.04117 15.34558 -33.66142 17.23425 -29.95825 18.76815 -31.88977 14.16565 -34.33591 12.28866 -33.66142 17.23425 -31.88977 14.16565 -36.8414 14.79416 -33.66142 17.23425 -34.33591 12.28866 -36.21289 9.84252 -36.8414 14.79416 -34.33591 12.28866 -37.39282 6.993926 -36.8414 14.79416 -36.21289 9.84252 -39.28149 11.61417 -36.8414 14.79416 -37.39282 6.993926 -37.79528 3.937008 -39.28149 11.61417 -37.39282 6.993926 -37.79528 0 -39.28149 11.61417 -37.79528 3.937008 -40.82027 7.874016 -39.28149 11.61417 -37.79528 0 -45.27559 0 -40.82027 7.874016 -37.79528 0 -40.81539 7.911001 -39.28149 11.61417 -40.82027 7.874016 -45.27559 7.874016 -40.82027 7.874016 -45.27559 0 -10.62992 3.937008 -10.62992 0 -11.15311 7.911001 -14.17323 0 -11.15311 7.911001 -10.62992 0 -12.68701 11.61417 -11.15311 7.911001 -14.17323 0 -14.17323 3.937008 -12.68701 11.61417 -14.17323 0 -25.59055 0 -25.59055 3.937008 -19.02887 0 -19.02887 3.937008 -19.02887 0 -25.59055 3.937008 25.59055 0 19.02887 0 25.59055 3.937008 19.02887 3.937008 25.59055 3.937008 19.02887 0 -57.08661 3.937008 -57.08661 7.874016 -49.6063 3.937008 -52.63129 7.874016 -49.6063 3.937008 -57.08661 7.874016 -52.62642 7.911001 -49.6063 3.937008 -52.63129 7.874016 -51.09252 11.61417 -49.6063 3.937008 -52.62642 7.911001 -48.65243 14.79416 -49.6063 3.937008 -51.09252 11.61417 -49.20384 6.993926 -49.6063 3.937008 -48.65243 14.79416 -48.02392 9.84252 -49.20384 6.993926 -48.65243 14.79416 -45.47244 17.23425 -48.02392 9.84252 -48.65243 14.79416 -46.14693 12.28866 -48.02392 9.84252 -45.47244 17.23425 -43.70079 14.16565 -46.14693 12.28866 -45.47244 17.23425 -41.76927 18.76815 -43.70079 14.16565 -45.47244 17.23425 -40.85219 15.34558 -43.70079 14.16565 -41.76927 18.76815 -37.79528 19.29134 -40.85219 15.34558 -41.76927 18.76815 -37.79528 15.74803 -40.85219 15.34558 -37.79528 19.29134 -34.73836 15.34558 -37.79528 15.74803 -37.79528 19.29134 -33.82128 18.76815 -34.73836 15.34558 -37.79528 19.29134 -31.88977 14.16565 -34.73836 15.34558 -33.82128 18.76815 -30.11811 17.23425 -31.88977 14.16565 -33.82128 18.76815 -29.44362 12.28866 -31.88977 14.16565 -30.11811 17.23425 -26.93812 14.79416 -29.44362 12.28866 -30.11811 17.23425 -27.56663 9.84252 -29.44362 12.28866 -26.93812 14.79416 -26.3867 6.993926 -27.56663 9.84252 -26.93812 14.79416 -24.49804 11.61417 -26.3867 6.993926 -26.93812 14.79416 -25.98425 3.937008 -26.3867 6.993926 -24.49804 11.61417 -25.98425 0 -25.98425 3.937008 -24.49804 11.61417 -22.44095 0 -25.98425 0 -24.49804 11.61417 -22.96413 7.911001 -22.44095 0 -24.49804 11.61417 -22.44095 3.937008 -22.44095 0 -22.96413 7.911001 -19.02887 0 -25.59055 0 -19.02887 3.937008 -25.59055 3.937008 -19.02887 3.937008 -25.59055 0 19.02887 0 19.02887 3.937008 25.59055 0 25.59055 3.937008 25.59055 0 19.02887 3.937008 24.64908 18.05237 24.49804 17.84487 22.44095 18.05237 22.96413 13.94139 22.44095 18.05237 24.49804 17.84487 22.44095 9.752431 22.44095 18.05237 22.96413 13.94139 -10.62992 18.05237 22.44095 18.05237 22.44095 9.752431 -10.62992 9.752431 -10.62992 18.05237 22.44095 9.752431 -11.15311 13.94139 -10.62992 18.05237 -10.62992 9.752431 -12.68701 17.84487 -10.62992 18.05237 -11.15311 13.94139 -12.83806 18.05237 -10.62992 18.05237 -12.68701 17.84487 -24.64908 18.05237 -22.44095 18.05237 -24.49804 17.84487 -22.96413 13.94139 -24.49804 17.84487 -22.44095 18.05237 -22.44095 9.752431 -22.96413 13.94139 -22.44095 18.05237 10.62992 9.752431 -22.44095 9.752431 -22.44095 18.05237 10.62992 18.05237 10.62992 9.752431 -22.44095 18.05237 11.15311 13.94139 10.62992 9.752431 10.62992 18.05237 12.68701 17.84487 11.15311 13.94139 10.62992 18.05237 12.83806 18.05237 12.68701 17.84487 10.62992 18.05237 42.62643 28.0123 42.62643 23.62303 34.75241 28.0123 -42.62643 23.62303 -42.62643 28.0123 -34.75241 28.0123 19.10454 31.26904 -19.10454 31.26904 17.71654 35.43307 -17.71654 35.43307 17.71654 35.43307 -19.10454 31.26904 -17.71654 -42.62643 -17.71654 -34.75241 17.71654 -42.62643 17.71654 -34.75241 17.71654 -42.62643 -17.71654 -34.75241 25.59055 19.68504 21.65354 19.68504 25.59055 23.62205 21.65354 23.62205 25.59055 23.62205 21.65354 19.68504 -25.59055 12.71269 -25.59055 16.6497 -21.65354 12.71269 -21.65354 16.6497 -21.65354 12.71269 -25.59055 16.6497 -17.71654 -34.75241 -17.71654 0.901662 17.71654 -34.75241 17.71654 0.901662 17.71654 -34.75241 -17.71654 0.901662 25.59055 16.6497 25.59055 12.71269 21.65354 16.6497 21.65354 12.71269 21.65354 16.6497 25.59055 12.71269 21.65354 0.853473 17.63857 0.853473 17.71654 20.53851 14.48896 16.60151 17.71654 20.53851 17.63857 0.853473 -17.71654 20.53851 17.71654 20.53851 14.48896 16.60151 15.27636 12.6645 14.48896 16.60151 17.63857 0.853473 -14.48896 16.60151 -17.71654 20.53851 14.48896 16.60151 -15.27636 12.6645 -17.71654 20.53851 -14.48896 16.60151 -17.63857 0.853473 -17.71654 20.53851 -15.27636 12.6645 -21.65354 0.853473 -17.71654 20.53851 -17.63857 0.853473 -21.65354 16.6497 -21.65354 12.71269 -25.59055 16.6497 -25.59055 12.71269 -25.59055 16.6497 -21.65354 12.71269 -57.08661 15.56239 -50.12598 19.44251 -20.86239 15.56239 -42.62643 23.62303 -20.86239 15.56239 -50.12598 19.44251 -34.75241 28.0123 -20.86239 15.56239 -42.62643 23.62303 -20.86239 24.0753 -20.86239 15.56239 -34.75241 28.0123 0.901662 28.0123 -20.86239 24.0753 -34.75241 28.0123 -0.466608 24.0753 -20.86239 24.0753 0.901662 28.0123 10.30146 15.56239 -0.466608 24.0753 0.901662 28.0123 12.71269 15.56239 10.30146 15.56239 0.901662 28.0123 16.6497 15.56239 12.71269 15.56239 0.901662 28.0123 21.65354 12.71269 21.65354 16.6497 25.59055 12.71269 25.59055 16.6497 25.59055 12.71269 21.65354 16.6497 -21.65354 19.68504 -25.59055 19.68504 -21.65354 23.62205 -25.59055 23.62205 -21.65354 23.62205 -25.59055 19.68504 12.71269 19.68504 12.71269 23.62205 16.6497 19.68504 16.6497 23.62205 16.6497 19.68504 12.71269 23.62205 -12.71269 23.62205 -12.71269 19.68504 -16.6497 23.62205 -16.6497 19.68504 -16.6497 23.62205 -12.71269 19.68504 34.75241 28.0123 20.86239 24.0753 -0.901662 28.0123 0.466608 24.0753 -0.901662 28.0123 20.86239 24.0753 -10.30146 15.56239 -0.901662 28.0123 0.466608 24.0753 -12.71269 15.56239 -0.901662 28.0123 -10.30146 15.56239 -16.6497 15.56239 -0.901662 28.0123 -12.71269 15.56239 20.86239 24.0753 34.75241 28.0123 20.86239 15.56239 34.75241 28.0123 42.62643 23.62303 20.86239 15.56239 42.62643 23.62303 50.12598 19.44251 20.86239 15.56239 57.08661 15.56239 20.86239 15.56239 50.12598 19.44251 21.65354 -9.788514 21.65354 -39.4776 17.63857 -9.788514 13.77953 -39.4776 17.63857 -9.788514 21.65354 -39.4776 -17.63857 -9.788514 17.63857 -9.788514 13.77953 -39.4776 -13.77953 -39.4776 -17.63857 -9.788514 13.77953 -39.4776 -21.65354 -39.4776 -17.63857 -9.788514 -13.77953 -39.4776 -21.65354 -9.788514 -17.63857 -9.788514 -21.65354 -39.4776 -16.6497 19.68504 -25.98425 19.29134 -16.6497 23.62205 -29.95825 18.76815 -16.6497 23.62205 -25.98425 19.29134 -45.27559 15.74803 -16.6497 23.62205 -29.95825 18.76815 -22.01026 18.76815 -25.98425 19.29134 -16.6497 19.68504 -18.30709 17.23425 -22.01026 18.76815 -16.6497 19.68504 -33.66142 17.23425 -45.27559 15.74803 -29.95825 18.76815 -36.8414 14.79416 -45.27559 15.74803 -33.66142 17.23425 -39.13044 11.81102 -45.27559 15.74803 -36.8414 14.79416 -45.27559 11.81102 -45.27559 15.74803 -39.13044 11.81102 -18.30709 17.23425 -16.6497 19.68504 -15.1271 14.79416 -15.1271 14.79416 -16.6497 19.68504 -12.83806 11.81102 -16.6497 19.68504 -12.71269 19.68504 -12.83806 11.81102 -12.83806 11.81102 -12.71269 19.68504 -10.62992 11.81102 -12.71269 19.68504 -12.71269 23.62205 -10.62992 11.81102 -12.71269 23.62205 -10.30146 23.62205 -10.62992 11.81102 -10.30146 23.62205 20.86239 23.62205 -10.62992 11.81102 -10.62992 11.81102 20.86239 23.62205 22.44095 11.81102 22.44095 11.81102 20.86239 23.62205 24.64908 11.81102 24.64908 11.81102 20.86239 23.62205 26.93812 14.79416 26.93812 14.79416 20.86239 23.62205 30.11811 17.23425 30.11811 17.23425 20.86239 23.62205 33.82128 18.76815 33.82128 18.76815 20.86239 23.62205 37.79528 19.29134 37.79528 19.29134 20.86239 23.62205 41.76927 18.76815 20.86239 23.62205 57.08661 23.62205 41.76927 18.76815 41.76927 18.76815 57.08661 23.62205 45.47244 17.23425 57.08661 11.81102 45.47244 17.23425 57.08661 23.62205 48.65243 14.79416 45.47244 17.23425 57.08661 11.81102 50.94147 11.81102 48.65243 14.79416 57.08661 11.81102 10.62992 11.81102 12.71269 19.68504 12.83806 11.81102 16.6497 19.68504 12.83806 11.81102 12.71269 19.68504 15.1271 14.79416 12.83806 11.81102 16.6497 19.68504 18.30709 17.23425 15.1271 14.79416 16.6497 19.68504 16.6497 23.62205 18.30709 17.23425 16.6497 19.68504 22.01026 18.76815 18.30709 17.23425 16.6497 23.62205 25.98425 19.29134 22.01026 18.76815 16.6497 23.62205 29.95825 18.76815 25.98425 19.29134 16.6497 23.62205 45.27559 15.74803 29.95825 18.76815 16.6497 23.62205 33.66142 17.23425 29.95825 18.76815 45.27559 15.74803 36.8414 14.79416 33.66142 17.23425 45.27559 15.74803 39.13044 11.81102 36.8414 14.79416 45.27559 15.74803 45.27559 11.81102 39.13044 11.81102 45.27559 15.74803 12.71269 19.68504 10.62992 11.81102 12.71269 23.62205 12.71269 23.62205 10.62992 11.81102 10.30146 23.62205 10.30146 23.62205 10.62992 11.81102 -20.86239 23.62205 10.62992 11.81102 -22.44095 11.81102 -20.86239 23.62205 -22.44095 11.81102 -24.64908 11.81102 -20.86239 23.62205 -24.64908 11.81102 -26.93812 14.79416 -20.86239 23.62205 -26.93812 14.79416 -30.11811 17.23425 -20.86239 23.62205 -30.11811 17.23425 -33.82128 18.76815 -20.86239 23.62205 -33.82128 18.76815 -37.79528 19.29134 -20.86239 23.62205 -37.79528 19.29134 -41.76927 18.76815 -20.86239 23.62205 -20.86239 23.62205 -41.76927 18.76815 -57.08661 23.62205 -41.76927 18.76815 -45.47244 17.23425 -57.08661 23.62205 -45.47244 17.23425 -48.65243 14.79416 -57.08661 23.62205 -48.65243 14.79416 -50.94147 11.81102 -57.08661 23.62205 -57.08661 11.81102 -57.08661 23.62205 -50.94147 11.81102 -25.59055 -22.44095 -25.59055 10.62992 -21.65354 -22.44095 -21.65354 10.62992 -21.65354 -22.44095 -25.59055 10.62992 -21.65354 -22.44095 -21.65354 10.62992 -19.02887 -22.44095 -19.02887 10.62992 -19.02887 -22.44095 -21.65354 10.62992 22.44095 11.81102 22.44095 3.937008 -10.62992 11.81102 22.44095 0 -10.62992 11.81102 22.44095 3.937008 -10.62992 0 -10.62992 11.81102 22.44095 0 -10.62992 3.937008 -10.62992 11.81102 -10.62992 0 -19.02887 3.937008 -25.59055 3.937008 -19.02887 11.81102 -21.65354 11.81102 -19.02887 11.81102 -25.59055 3.937008 -25.59055 11.81102 -21.65354 11.81102 -25.59055 3.937008 25.59055 3.937008 19.02887 3.937008 25.59055 11.81102 19.02887 11.81102 25.59055 11.81102 19.02887 3.937008 21.65354 11.81102 25.59055 11.81102 19.02887 11.81102 25.59055 -22.44095 19.02887 -22.44095 25.59055 10.62992 19.02887 10.62992 25.59055 10.62992 19.02887 -22.44095 21.65354 -22.44095 21.65354 10.62992 25.59055 -22.44095 25.59055 10.62992 25.59055 -22.44095 21.65354 10.62992 21.65354 10.62992 21.65354 -22.44095 19.02887 10.62992 19.02887 -22.44095 19.02887 10.62992 21.65354 -22.44095 -19.02887 -22.44095 -25.59055 -22.44095 -19.02887 10.62992 -25.59055 10.62992 -19.02887 10.62992 -25.59055 -22.44095 -22.44095 0 -22.44095 3.937008 10.62992 0 -22.44095 11.81102 10.62992 0 -22.44095 3.937008 10.62992 3.937008 10.62992 0 -22.44095 11.81102 10.62992 11.81102 10.62992 3.937008 -22.44095 11.81102 -25.59055 3.937008 -25.59055 11.81102 -19.02887 3.937008 -19.02887 11.81102 -19.02887 3.937008 -25.59055 11.81102 -21.65354 11.81102 -19.02887 11.81102 -25.59055 11.81102 19.02887 3.937008 19.02887 11.81102 25.59055 3.937008 21.65354 11.81102 25.59055 3.937008 19.02887 11.81102 25.59055 11.81102 25.59055 3.937008 21.65354 11.81102 -22.44095 11.81102 10.62992 11.81102 -22.44095 3.937008 10.62992 3.937008 -22.44095 3.937008 10.62992 11.81102 22.44095 3.937008 -10.62992 3.937008 22.44095 11.81102 -10.62992 11.81102 22.44095 11.81102 -10.62992 3.937008 -17.10304 -39.42158 -17.10304 -31.54756 17.10304 -39.42158 17.10304 -39.42158 -17.10304 -31.54756 17.10304 -31.54756 17.10304 -31.54756 -17.10304 -31.54756 19.10454 -23.0639 19.10454 -23.0639 -17.10304 -31.54756 -19.10454 -23.0639 -20.42654 -31.54756 -19.10454 -23.0639 -17.10304 -31.54756 20.42654 -31.54756 17.10304 -31.54756 19.10454 -23.0639 21.65354 11.81102 11.81102 11.81102 21.65354 23.62205 11.81102 15.74803 21.65354 23.62205 11.81102 11.81102 -11.81102 15.74803 21.65354 23.62205 11.81102 15.74803 17.10304 23.62205 21.65354 23.62205 -11.81102 15.74803 17.10304 23.62205 -11.81102 15.74803 -17.10304 23.62205 -17.10304 23.62205 -11.81102 15.74803 -21.65354 23.62205 -21.65354 23.62205 -11.81102 15.74803 -21.65354 11.81102 -11.81102 11.81102 -21.65354 11.81102 -11.81102 15.74803 -13.77953 11.81102 -21.65354 11.81102 -13.77953 15.74803 -21.65354 15.74803 -13.77953 15.74803 -21.65354 11.81102 21.65354 11.81102 13.77953 11.81102 21.65354 15.74803 13.77953 15.74803 21.65354 15.74803 13.77953 11.81102 -21.65354 16.6497 -21.65354 12.71269 -25.59055 16.6497 -21.65354 16.6497 -21.65354 12.71269 -25.59055 16.6497 -21.65354 0.853473 -17.71654 20.53851 -17.63857 0.853473 -21.65354 0.853473 -17.71654 20.53851 -17.63857 0.853473 20.86239 24.0753 20.86239 15.56239 0.466608 24.0753 -10.30146 15.56239 0.466608 24.0753 20.86239 15.56239 -20.86239 15.56239 -20.86239 24.0753 10.30146 15.56239 -0.466608 24.0753 10.30146 15.56239 -20.86239 24.0753 17.63857 0.853473 -17.63857 0.853473 15.27636 12.6645 -15.27636 12.6645 15.27636 12.6645 -17.63857 0.853473 -21.65354 -39.42158 -20.42654 -31.54756 -17.10304 -39.42158 -17.10304 -31.54756 -17.10304 -39.42158 -20.42654 -31.54756 17.10304 -39.42158 17.10304 -31.54756 21.65354 -39.42158 20.42654 -31.54756 21.65354 -39.42158 17.10304 -31.54756</float_array>
+          <technique_common>
+            <accessor source="#ID15_001-mesh-map-0-array" count="2544" stride="2">
+              <param name="S" type="float"/>
+              <param name="T" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <vertices id="ID15_001-mesh-vertices">
+          <input semantic="POSITION" source="#ID15_001-mesh-positions"/>
+        </vertices>
+        <triangles material="InteractiveRed-material" count="848">
+          <input semantic="VERTEX" source="#ID15_001-mesh-vertices" offset="0"/>
+          <input semantic="NORMAL" source="#ID15_001-mesh-normals" offset="1"/>
+          <input semantic="TEXCOORD" source="#ID15_001-mesh-map-0" offset="2" set="0"/>
+          <p>0 0 0 1 1 1 2 0 2 3 1 3 2 0 4 1 1 5 4 2 6 5 2 7 6 2 8 7 2 9 6 2 10 5 2 11 8 3 12 9 3 13 10 3 14 11 3 15 10 3 16 9 3 17 12 4 18 13 4 19 14 4 20 15 4 21 14 4 22 13 4 23 16 5 24 17 5 25 18 5 26 19 6 27 18 6 28 17 6 29 20 7 30 18 7 31 19 7 32 21 8 33 18 8 34 20 8 35 22 9 36 21 9 37 20 9 38 23 8 39 21 8 40 22 8 41 24 8 42 23 8 43 22 8 44 25 8 45 24 8 46 22 8 47 26 10 48 24 10 49 25 10 50 27 8 51 26 8 52 25 8 53 28 8 54 27 8 55 25 8 56 29 8 57 27 8 58 28 8 59 30 11 60 29 11 61 28 11 62 31 12 63 29 12 64 30 12 65 32 13 66 31 13 67 30 13 68 33 14 69 32 14 70 30 14 71 34 8 72 32 8 73 33 8 74 35 8 75 34 8 76 33 8 77 36 8 78 34 8 79 35 8 80 37 8 81 36 8 82 35 8 83 38 8 84 36 8 85 37 8 86 39 8 87 38 8 88 37 8 89 40 15 90 39 15 91 37 15 92 41 16 93 39 16 94 40 16 95 42 8 96 41 8 97 40 8 98 43 17 99 42 17 100 40 17 101 44 18 102 42 18 103 43 18 104 45 8 105 43 8 106 40 8 107 46 19 108 44 19 109 43 19 110 47 20 111 48 20 112 49 20 113 50 20 114 49 20 115 48 20 116 51 21 117 52 21 118 53 21 119 54 21 120 53 21 121 52 21 122 55 22 123 56 22 124 57 22 125 58 22 126 57 22 127 56 22 128 59 23 129 60 23 130 61 23 131 62 23 132 61 23 133 60 23 134 63 24 135 64 24 136 65 24 137 66 25 138 65 25 139 64 25 140 67 26 141 68 26 142 69 26 143 70 26 144 69 26 145 68 26 146 71 27 147 72 27 148 73 27 149 74 27 150 73 27 151 72 27 152 75 28 153 76 28 154 77 28 155 78 28 156 77 28 157 76 28 158 79 29 159 80 29 160 81 29 161 82 29 162 81 29 163 80 29 164 83 30 165 84 30 166 85 30 167 86 30 168 85 30 169 84 30 170 87 31 171 88 31 172 89 32 173 90 32 174 89 32 175 88 31 176 91 33 177 92 33 178 93 34 179 94 34 180 93 34 181 92 33 182 95 35 183 96 35 184 97 36 185 98 36 186 97 36 187 96 35 188 99 37 189 100 37 190 101 38 191 102 39 192 101 38 193 100 37 194 103 40 195 104 40 196 105 40 197 106 40 198 105 40 199 104 40 200 107 41 201 108 41 202 109 41 203 110 41 204 109 41 205 108 41 206 111 42 207 112 42 208 113 42 209 114 43 210 113 43 211 112 43 212 115 42 213 113 42 214 114 42 215 116 42 216 115 42 217 114 42 218 117 42 219 116 42 220 114 42 221 118 42 222 117 42 223 114 42 224 119 42 225 117 42 226 118 42 227 120 42 228 117 42 229 119 42 230 121 42 231 120 42 232 119 42 233 122 42 234 120 42 235 121 42 236 123 44 237 120 44 238 122 44 239 124 42 240 123 42 241 122 42 242 125 45 243 123 45 244 124 45 245 126 42 246 125 42 247 124 42 248 127 42 249 125 42 250 126 42 251 128 42 252 127 42 253 126 42 254 129 42 255 127 42 256 128 42 257 130 42 258 127 42 259 129 42 260 131 42 261 130 42 262 129 42 263 132 46 264 130 46 265 131 46 266 133 42 267 132 42 268 131 42 269 134 42 270 132 42 271 133 42 272 135 42 273 132 42 274 134 42 275 136 42 276 135 42 277 134 42 278 137 42 279 135 42 280 136 42 281 138 47 282 135 47 283 137 47 284 139 48 285 135 48 286 138 48 287 140 49 288 139 49 289 138 49 290 141 50 291 142 50 292 143 50 293 144 50 294 143 50 295 142 50 296 145 51 297 146 51 298 147 51 299 148 51 300 147 51 301 146 51 302 149 52 303 150 52 304 151 53 305 152 53 306 151 53 307 150 52 308 153 54 309 154 54 310 155 54 311 156 54 312 155 54 313 154 54 314 157 55 315 158 55 316 159 55 317 160 55 318 159 55 319 158 55 320 161 56 321 162 56 322 163 56 323 164 56 324 163 56 325 162 56 326 165 57 327 166 57 328 167 57 329 168 58 330 167 58 331 166 58 332 169 59 333 167 59 334 168 59 335 170 60 336 167 60 337 169 60 338 171 61 339 172 61 340 173 61 341 174 62 342 173 62 343 172 62 344 175 63 345 173 63 346 174 63 347 176 64 348 173 64 349 175 64 350 177 65 351 178 65 352 179 65 353 180 65 354 179 65 355 178 65 356 181 66 357 182 66 358 183 66 359 184 66 360 183 66 361 182 66 362 185 67 363 186 67 364 187 67 365 188 67 366 187 67 367 186 67 368 189 68 369 190 68 370 191 68 371 192 68 372 191 68 373 190 68 374 193 66 375 194 66 376 195 66 377 196 66 378 195 66 379 194 66 380 197 69 381 198 69 382 199 69 383 200 69 384 199 69 385 198 69 386 201 70 387 202 70 388 203 70 389 204 70 390 203 70 391 202 70 392 205 71 393 206 71 394 207 71 395 208 71 396 207 71 397 206 71 398 209 72 399 210 73 400 211 73 401 212 73 402 211 73 403 210 73 404 213 73 405 212 73 406 210 73 407 214 74 408 215 74 409 216 74 410 217 74 411 216 74 412 215 74 413 218 65 414 219 65 415 220 65 416 221 65 417 220 65 418 219 65 419 222 69 420 223 69 421 224 69 422 225 69 423 224 69 424 223 69 425 226 75 426 227 75 427 228 75 428 229 75 429 228 75 430 227 75 431 230 65 432 231 65 433 232 65 434 233 65 435 232 65 436 231 65 437 234 76 438 235 76 439 236 76 440 237 76 441 236 76 442 235 76 443 238 77 444 239 77 445 240 77 446 241 77 447 240 77 448 239 77 449 242 65 450 243 65 451 244 65 452 245 65 453 244 65 454 243 65 455 246 78 456 247 78 457 248 78 458 249 78 459 248 78 460 247 78 461 250 79 462 251 79 463 252 79 464 253 79 465 252 79 466 251 79 467 254 78 468 255 78 469 256 78 470 257 77 471 256 78 472 255 78 473 258 80 474 259 80 475 260 80 476 261 80 477 260 80 478 259 80 479 262 81 480 263 81 481 264 81 482 265 81 483 264 81 484 263 81 485 266 70 486 267 70 487 268 70 488 269 70 489 268 70 490 267 70 491 270 68 492 271 68 493 272 68 494 273 68 495 272 68 496 271 68 497 274 82 498 275 82 499 276 82 500 277 82 501 276 82 502 275 82 503 278 83 504 279 83 505 280 83 506 281 84 507 280 84 508 279 84 509 282 85 510 281 85 511 279 85 512 283 86 513 282 86 514 279 86 515 284 87 516 285 87 517 286 87 518 287 87 519 286 87 520 285 87 521 288 87 522 289 87 523 290 87 524 291 87 525 290 87 526 289 87 527 292 87 528 293 87 529 294 87 530 295 87 531 294 87 532 293 87 533 296 69 534 297 69 535 298 69 536 299 69 537 298 69 538 297 69 539 300 76 540 301 76 541 302 76 542 303 76 543 302 76 544 301 76 545 304 88 546 305 88 547 306 88 548 307 88 549 306 88 550 305 88 551 308 70 552 309 70 553 310 70 554 311 70 555 310 70 556 309 70 557 312 89 558 313 90 559 314 90 560 315 90 561 314 90 562 313 90 563 316 91 564 317 91 565 318 91 566 319 91 567 318 91 568 317 91 569 320 87 570 321 87 571 322 87 572 323 87 573 322 87 574 321 87 575 324 92 576 325 92 577 326 92 578 327 93 579 326 92 580 325 92 581 328 92 582 326 92 583 327 93 584 329 94 585 330 94 586 331 94 587 332 94 588 331 94 589 330 94 590 333 76 591 334 76 592 335 76 593 336 76 594 335 76 595 334 76 596 337 72 597 338 73 598 339 73 599 340 73 600 339 73 601 338 73 602 341 73 603 340 73 604 338 73 605 342 95 606 343 92 607 344 92 608 345 92 609 344 92 610 343 92 611 346 92 612 344 92 613 345 92 614 347 90 615 348 90 616 349 90 617 350 90 618 349 90 619 348 90 620 351 66 621 352 66 622 353 66 623 354 66 624 353 66 625 352 66 626 355 96 627 356 73 628 357 73 629 358 73 630 357 73 631 356 73 632 359 73 633 357 73 634 358 73 635 360 72 636 361 73 637 362 96 638 363 73 639 362 96 640 361 73 641 364 73 642 362 96 643 363 73 644 365 76 645 366 76 646 367 76 647 368 76 648 367 76 649 366 76 650 369 77 651 370 77 652 371 77 653 372 77 654 371 77 655 370 77 656 373 97 657 374 98 658 375 97 659 376 98 660 375 97 661 374 98 662 377 99 663 378 99 664 379 99 665 380 99 666 379 99 667 378 99 668 381 68 669 382 68 670 383 68 671 384 68 672 383 68 673 382 68 674 385 70 675 386 70 676 387 70 677 388 70 678 387 70 679 386 70 680 389 94 681 390 100 682 391 94 683 392 100 684 391 94 685 390 100 686 393 101 687 394 92 688 395 92 689 396 92 690 395 92 691 394 92 692 397 92 693 396 92 694 394 92 695 398 68 696 399 68 697 400 68 698 401 68 699 400 68 700 399 68 701 402 102 702 403 102 703 404 102 704 405 102 705 404 102 706 403 102 707 406 92 708 407 92 709 408 92 710 409 103 711 408 92 712 407 92 713 410 92 714 409 103 715 407 92 716 411 104 717 412 105 718 413 104 719 414 105 720 413 104 721 412 105 722 415 106 723 416 106 724 417 106 725 418 106 726 417 106 727 416 106 728 419 107 729 420 108 730 421 107 731 422 108 732 421 107 733 420 108 734 423 109 735 424 109 736 425 109 737 426 109 738 425 109 739 424 109 740 427 110 741 428 110 742 429 110 743 430 110 744 429 110 745 428 110 746 431 111 747 432 111 748 433 111 749 434 111 750 433 111 751 432 111 752 435 112 753 436 112 754 437 112 755 438 112 756 437 112 757 436 112 758 439 113 759 440 113 760 441 113 761 442 113 762 441 113 763 440 113 764 443 114 765 444 114 766 445 114 767 446 114 768 445 114 769 444 114 770 447 115 771 448 115 772 449 115 773 450 116 774 449 116 775 448 116 776 451 117 777 452 117 778 453 117 779 454 117 780 453 117 781 452 117 782 455 118 783 456 118 784 457 118 785 458 118 786 457 118 787 456 118 788 459 119 789 460 119 790 461 119 791 462 119 792 461 119 793 460 119 794 463 66 795 464 66 796 465 66 797 466 66 798 465 66 799 464 66 800 467 120 801 468 120 802 469 120 803 470 121 804 469 121 805 468 121 806 471 122 807 469 122 808 470 122 809 472 122 810 471 122 811 470 122 812 473 123 813 474 123 814 475 123 815 476 124 816 475 124 817 474 124 818 477 125 819 475 125 820 476 125 821 478 126 822 475 126 823 477 126 824 479 127 825 475 127 826 478 127 827 480 128 828 475 128 829 479 128 830 481 129 831 475 129 832 480 129 833 482 130 834 475 130 835 481 130 836 483 131 837 475 131 838 482 131 839 484 132 840 475 132 841 483 132 842 485 133 843 475 133 844 484 133 845 486 134 846 475 134 847 485 134 848 487 135 849 475 135 850 486 135 851 488 136 852 475 136 853 487 136 854 474 137 855 489 137 856 476 137 857 476 138 858 489 138 859 490 138 860 489 139 861 491 139 862 490 139 863 490 140 864 491 140 865 492 140 866 492 141 867 491 141 868 493 141 869 493 142 870 491 142 871 494 142 872 494 143 873 491 143 874 495 143 875 495 144 876 491 144 877 496 144 878 496 145 879 491 145 880 497 145 881 497 146 882 491 146 883 498 146 884 498 147 885 491 147 886 499 147 887 499 148 888 491 148 889 500 148 890 500 149 891 491 149 892 501 149 893 501 150 894 491 150 895 502 150 896 502 151 897 491 151 898 503 151 899 504 152 900 503 152 901 491 152 902 505 153 903 506 153 904 507 153 905 508 153 906 507 153 907 506 153 908 509 154 909 510 154 910 511 154 911 512 154 912 511 154 913 510 154 914 513 155 915 514 155 916 515 155 917 516 155 918 515 155 919 514 155 920 517 156 921 518 156 922 519 156 923 520 156 924 519 156 925 518 156 926 521 157 927 522 158 928 523 157 929 524 158 930 523 157 931 522 158 932 525 159 933 526 159 934 527 159 935 528 159 936 527 159 937 526 159 938 529 69 939 530 69 940 531 69 941 532 69 942 531 69 943 530 69 944 533 160 945 534 160 946 535 161 947 536 161 948 535 161 949 534 160 950 537 162 951 538 162 952 539 162 953 540 163 954 539 163 955 538 163 956 541 164 957 540 164 958 538 164 959 542 165 960 541 165 961 538 165 962 543 166 963 544 166 964 545 166 965 546 166 966 545 166 967 544 166 968 547 167 969 548 168 970 549 167 971 550 168 972 549 167 973 548 168 974 551 169 975 552 169 976 553 169 977 554 169 978 553 169 979 552 169 980 555 170 981 556 170 982 557 170 983 558 170 984 557 170 985 556 170 986 559 171 987 560 171 988 561 171 989 562 171 990 561 171 991 560 171 992 563 172 993 564 172 994 565 172 995 566 172 996 565 172 997 564 172 998 567 173 999 568 173 1000 569 174 1001 570 174 1002 569 174 1003 568 173 1004 571 175 1005 572 175 1006 573 175 1007 574 175 1008 573 175 1009 572 175 1010 575 176 1011 576 176 1012 577 176 1013 578 176 1014 577 176 1015 576 176 1016 579 91 1017 580 91 1018 581 91 1019 582 91 1020 581 91 1021 580 91 1022 583 74 1023 584 74 1024 585 74 1025 586 74 1026 585 74 1027 584 74 1028 587 176 1029 588 176 1030 589 176 1031 590 176 1032 589 176 1033 588 176 1034 591 81 1035 592 81 1036 593 81 1037 594 81 1038 593 81 1039 592 81 1040 595 71 1041 596 71 1042 597 71 1043 598 71 1044 597 71 1045 596 71 1046 599 82 1047 600 82 1048 601 82 1049 602 82 1050 601 82 1051 600 82 1052 603 99 1053 604 99 1054 605 99 1055 606 99 1056 605 99 1057 604 99 1058 607 88 1059 608 88 1060 609 88 1061 610 88 1062 609 88 1063 608 88 1064 611 79 1065 612 79 1066 613 79 1067 614 79 1068 613 79 1069 612 79 1070 615 75 1071 616 75 1072 617 75 1073 618 75 1074 617 75 1075 616 75 1076 619 80 1077 620 80 1078 621 80 1079 622 80 1080 621 80 1081 620 80 1082 623 102 1083 624 102 1084 625 102 1085 626 102 1086 625 102 1087 624 102 1088 627 67 1089 628 67 1090 629 67 1091 630 67 1092 629 67 1093 628 67 1094 631 177 1095 632 177 1096 633 177 1097 634 178 1098 633 178 1099 632 178 1100 635 179 1101 633 179 1102 634 179 1103 636 180 1104 633 180 1105 635 180 1106 637 181 1107 633 181 1108 636 181 1109 638 182 1110 633 182 1111 637 182 1112 639 183 1113 633 183 1114 638 183 1115 640 184 1116 633 184 1117 639 184 1118 641 185 1119 633 185 1120 640 185 1121 642 186 1122 633 186 1123 641 186 1124 643 187 1125 633 187 1126 642 187 1127 644 188 1128 633 188 1129 643 188 1130 645 8 1131 633 8 1132 644 8 1133 646 42 1134 647 42 1135 648 42 1136 649 189 1137 648 189 1138 647 189 1139 650 190 1140 648 190 1141 649 190 1142 651 191 1143 650 191 1144 649 191 1145 652 192 1146 651 192 1147 649 192 1148 653 193 1149 652 193 1150 649 193 1151 654 194 1152 653 194 1153 649 194 1154 655 195 1155 654 195 1156 649 195 1157 656 196 1158 655 196 1159 649 196 1160 657 197 1161 656 197 1162 649 197 1163 658 198 1164 657 198 1165 649 198 1166 659 199 1167 658 199 1168 649 199 1169 660 42 1170 659 42 1171 649 42 1172 661 172 1173 662 172 1174 663 172 1175 664 172 1176 663 172 1177 662 172 1178 665 200 1179 666 200 1180 667 200 1181 668 201 1182 667 201 1183 666 201 1184 669 202 1185 667 202 1186 668 202 1187 670 203 1188 667 203 1189 669 203 1190 671 204 1191 667 204 1192 670 204 1193 672 205 1194 671 205 1195 670 205 1196 673 206 1197 672 206 1198 670 206 1199 674 207 1200 673 207 1201 670 207 1202 675 208 1203 674 208 1204 670 208 1205 676 209 1206 675 209 1207 670 209 1208 677 210 1209 676 210 1210 670 210 1211 678 211 1212 677 211 1213 670 211 1214 679 212 1215 678 212 1216 670 212 1217 680 213 1218 679 213 1219 670 213 1220 681 214 1221 680 214 1222 670 214 1223 682 215 1224 681 215 1225 670 215 1226 683 216 1227 684 216 1228 685 216 1229 686 217 1230 685 217 1231 684 217 1232 687 218 1233 685 218 1234 686 218 1235 688 219 1236 687 219 1237 686 219 1238 689 220 1239 688 220 1240 686 220 1241 690 221 1242 689 221 1243 686 221 1244 691 222 1245 690 222 1246 686 222 1247 692 223 1248 691 223 1249 686 223 1250 693 224 1251 692 224 1252 686 224 1253 694 225 1254 693 225 1255 686 225 1256 695 226 1257 694 226 1258 686 226 1259 696 227 1260 695 227 1261 686 227 1262 665 228 1263 696 228 1264 686 228 1265 666 229 1266 665 229 1267 686 229 1268 697 230 1269 698 230 1270 699 230 1271 700 231 1272 699 231 1273 698 231 1274 701 122 1275 699 122 1276 700 122 1277 702 232 1278 701 232 1279 700 232 1280 703 233 1281 704 233 1282 705 233 1283 706 233 1284 705 233 1285 704 233 1286 707 234 1287 708 234 1288 709 234 1289 710 235 1290 709 235 1291 708 235 1292 711 236 1293 709 236 1294 710 236 1295 712 237 1296 709 237 1297 711 237 1298 713 238 1299 709 238 1300 712 238 1301 714 239 1302 709 239 1303 713 239 1304 710 240 1305 715 240 1306 711 240 1307 715 241 1308 716 241 1309 711 241 1310 717 242 1311 711 242 1312 716 242 1313 714 243 1314 718 243 1315 709 243 1316 718 244 1317 719 244 1318 709 244 1319 709 245 1320 719 245 1321 720 245 1322 719 246 1323 721 246 1324 720 246 1325 721 247 1326 722 247 1327 720 247 1328 722 248 1329 723 248 1330 720 248 1331 723 249 1332 724 249 1333 720 249 1334 724 250 1335 725 250 1336 720 250 1337 725 251 1338 726 251 1339 720 251 1340 726 252 1341 727 252 1342 720 252 1343 727 253 1344 728 253 1345 720 253 1346 728 254 1347 729 254 1348 720 254 1349 729 255 1350 730 255 1351 720 255 1352 730 256 1353 731 256 1354 720 256 1355 731 257 1356 732 257 1357 720 257 1358 732 258 1359 733 258 1360 720 258 1361 734 259 1362 720 259 1363 733 259 1364 735 260 1365 719 260 1366 718 260 1367 736 261 1368 719 261 1369 735 261 1370 737 262 1371 736 262 1372 735 262 1373 738 263 1374 737 263 1375 735 263 1376 739 264 1377 738 264 1378 735 264 1379 740 265 1380 739 265 1381 735 265 1382 741 266 1383 740 266 1384 735 266 1385 742 267 1386 741 267 1387 735 267 1388 743 268 1389 742 268 1390 735 268 1391 744 269 1392 743 269 1393 735 269 1394 745 270 1395 744 270 1396 735 270 1397 746 271 1398 745 271 1399 735 271 1400 747 272 1401 746 272 1402 735 272 1403 718 273 1404 714 273 1405 748 273 1406 748 274 1407 714 274 1408 749 274 1409 749 275 1410 750 275 1411 748 275 1412 751 276 1413 748 276 1414 750 276 1415 752 277 1416 751 277 1417 750 277 1418 753 278 1419 749 278 1420 714 278 1421 754 279 1422 749 279 1423 753 279 1424 755 172 1425 756 172 1426 757 172 1427 758 172 1428 757 172 1429 756 172 1430 759 79 1431 760 79 1432 761 79 1433 762 79 1434 761 79 1435 760 79 1436 763 102 1437 764 102 1438 765 102 1439 766 102 1440 765 102 1441 764 102 1442 767 176 1443 768 176 1444 769 176 1445 770 176 1446 769 176 1447 768 176 1448 771 71 1449 772 71 1450 773 71 1451 774 71 1452 773 71 1453 772 71 1454 775 67 1455 776 67 1456 777 67 1457 778 67 1458 777 67 1459 776 67 1460 779 88 1461 780 88 1462 781 88 1463 782 88 1464 781 88 1465 780 88 1466 783 99 1467 784 99 1468 785 99 1469 786 99 1470 785 99 1471 784 99 1472 787 75 1473 788 75 1474 789 75 1475 790 75 1476 789 75 1477 788 75 1478 791 81 1479 792 81 1480 793 81 1481 794 81 1482 793 81 1483 792 81 1484 795 91 1485 796 91 1486 797 91 1487 798 91 1488 797 91 1489 796 91 1490 799 82 1491 800 82 1492 801 82 1493 802 82 1494 801 82 1495 800 82 1496 803 80 1497 804 80 1498 805 80 1499 806 80 1500 805 80 1501 804 80 1502 807 91 1503 808 91 1504 809 91 1505 810 91 1506 809 91 1507 808 91 1508 811 81 1509 812 81 1510 813 81 1511 814 81 1512 813 81 1513 812 81 1514 815 82 1515 816 82 1516 817 82 1517 818 82 1518 817 82 1519 816 82 1520 819 75 1521 820 75 1522 821 75 1523 822 75 1524 821 75 1525 820 75 1526 823 88 1527 824 88 1528 825 88 1529 826 88 1530 825 88 1531 824 88 1532 827 177 1533 828 177 1534 829 177 1535 830 178 1536 829 178 1537 828 178 1538 831 280 1539 829 280 1540 830 280 1541 832 281 1542 829 281 1543 831 281 1544 833 282 1545 829 282 1546 832 282 1547 834 283 1548 829 283 1549 833 283 1550 835 284 1551 829 284 1552 834 284 1553 836 285 1554 829 285 1555 835 285 1556 837 185 1557 829 185 1558 836 185 1559 838 186 1560 829 186 1561 837 186 1562 839 286 1563 829 286 1564 838 286 1565 840 287 1566 829 287 1567 839 287 1568 841 8 1569 829 8 1570 840 8 1571 842 102 1572 843 102 1573 844 102 1574 845 102 1575 844 102 1576 843 102 1577 846 80 1578 847 80 1579 848 80 1580 849 80 1581 848 80 1582 847 80 1583 850 71 1584 851 71 1585 852 71 1586 853 71 1587 852 71 1588 851 71 1589 854 79 1590 855 79 1591 856 79 1592 857 79 1593 856 79 1594 855 79 1595 858 67 1596 859 67 1597 860 67 1598 861 67 1599 860 67 1600 859 67 1601 862 172 1602 863 172 1603 864 172 1604 865 172 1605 864 172 1606 863 172 1607 866 288 1608 867 288 1609 868 288 1610 869 289 1611 868 289 1612 867 289 1613 870 290 1614 868 290 1615 869 290 1616 871 291 1617 870 291 1618 869 291 1619 872 292 1620 871 292 1621 869 292 1622 873 293 1623 872 293 1624 869 293 1625 874 294 1626 873 294 1627 869 294 1628 875 295 1629 874 295 1630 869 295 1631 876 196 1632 875 196 1633 869 196 1634 877 197 1635 876 197 1636 869 197 1637 878 296 1638 877 296 1639 869 296 1640 879 297 1641 878 297 1642 869 297 1643 880 42 1644 879 42 1645 869 42 1646 881 176 1647 882 176 1648 883 176 1649 884 176 1650 883 176 1651 882 176 1652 885 99 1653 886 99 1654 887 99 1655 888 99 1656 887 99 1657 886 99 1658 889 172 1659 890 172 1660 891 172 1661 892 298 1662 891 298 1663 890 298 1664 893 299 1665 894 299 1666 895 299 1667 896 300 1668 895 300 1669 894 300 1670 897 301 1671 896 301 1672 894 301 1673 898 302 1674 896 302 1675 897 302 1676 899 303 1677 896 303 1678 898 303 1679 900 304 1680 896 304 1681 899 304 1682 901 305 1683 896 305 1684 900 305 1685 902 306 1686 896 306 1687 901 306 1688 903 307 1689 896 307 1690 902 307 1691 904 308 1692 896 308 1693 903 308 1694 905 309 1695 896 309 1696 904 309 1697 906 310 1698 896 310 1699 905 310 1700 907 311 1701 896 311 1702 906 311 1703 908 312 1704 896 312 1705 907 312 1706 909 313 1707 896 313 1708 908 313 1709 910 313 1710 909 313 1711 908 313 1712 911 314 1713 910 314 1714 908 314 1715 912 315 1716 910 315 1717 911 315 1718 913 316 1719 910 316 1720 912 316 1721 914 317 1722 910 317 1723 913 317 1724 915 318 1725 910 318 1726 914 318 1727 916 319 1728 910 319 1729 915 319 1730 917 320 1731 910 320 1732 916 320 1733 918 321 1734 910 321 1735 917 321 1736 919 322 1737 910 322 1738 918 322 1739 920 323 1740 910 323 1741 919 323 1742 921 324 1743 910 324 1744 920 324 1745 922 325 1746 910 325 1747 921 325 1748 923 326 1749 924 326 1750 925 326 1751 926 326 1752 925 326 1753 924 326 1754 927 327 1755 928 327 1756 929 327 1757 930 328 1758 929 328 1759 928 328 1760 931 42 1761 932 42 1762 933 42 1763 934 42 1764 933 42 1765 932 42 1766 935 42 1767 933 42 1768 934 42 1769 936 42 1770 933 42 1771 935 42 1772 937 42 1773 936 42 1774 935 42 1775 938 329 1776 936 329 1777 937 329 1778 939 42 1779 936 42 1780 938 42 1781 940 42 1782 939 42 1783 938 42 1784 941 330 1785 939 330 1786 940 330 1787 942 42 1788 941 42 1789 940 42 1790 943 42 1791 941 42 1792 942 42 1793 944 42 1794 943 42 1795 942 42 1796 945 42 1797 943 42 1798 944 42 1799 946 42 1800 943 42 1801 945 42 1802 947 331 1803 946 331 1804 945 331 1805 948 42 1806 946 42 1807 947 42 1808 949 42 1809 948 42 1810 947 42 1811 950 42 1812 948 42 1813 949 42 1814 951 332 1815 948 332 1816 950 332 1817 952 333 1818 951 333 1819 950 333 1820 953 42 1821 951 42 1822 952 42 1823 954 334 1824 951 334 1825 953 334 1826 955 335 1827 954 335 1828 953 335 1829 956 336 1830 951 336 1831 954 336 1832 957 42 1833 954 42 1834 955 42 1835 958 42 1836 959 42 1837 960 42 1838 961 42 1839 960 42 1840 959 42 1841 931 337 1842 960 337 1843 961 337 1844 932 338 1845 931 338 1846 961 338 1847 962 339 1848 963 339 1849 964 339 1850 965 340 1851 964 340 1852 963 340 1853 966 341 1854 967 341 1855 968 341 1856 969 342 1857 968 342 1858 967 342 1859 970 8 1860 971 8 1861 972 8 1862 973 343 1863 972 343 1864 971 343 1865 974 8 1866 972 8 1867 973 8 1868 975 8 1869 972 8 1870 974 8 1871 976 8 1872 972 8 1873 975 8 1874 977 8 1875 972 8 1876 976 8 1877 978 8 1878 977 8 1879 976 8 1880 979 8 1881 978 8 1882 976 8 1883 980 10 1884 978 10 1885 979 10 1886 981 8 1887 980 8 1888 979 8 1889 982 8 1890 981 8 1891 979 8 1892 983 8 1893 981 8 1894 982 8 1895 984 344 1896 983 344 1897 982 344 1898 985 345 1899 983 345 1900 984 345 1901 986 13 1902 985 13 1903 984 13 1904 987 8 1905 986 8 1906 984 8 1907 988 8 1908 986 8 1909 987 8 1910 989 8 1911 988 8 1912 987 8 1913 990 346 1914 988 346 1915 989 346 1916 991 347 1917 990 347 1918 989 347 1919 992 8 1920 990 8 1921 991 8 1922 993 8 1923 992 8 1924 991 8 1925 994 8 1926 993 8 1927 991 8 1928 995 348 1929 993 348 1930 994 348 1931 996 8 1932 995 8 1933 994 8 1934 997 349 1935 996 349 1936 994 349 1937 998 350 1938 997 350 1939 994 350 1940 999 8 1941 997 8 1942 998 8 1943 1000 341 1944 1001 341 1945 1002 341 1946 1003 351 1947 1002 351 1948 1001 351 1949 1004 339 1950 1005 339 1951 1006 339 1952 1007 352 1953 1006 352 1954 1005 352 1955 1008 353 1956 1009 353 1957 1010 353 1958 1011 354 1959 1010 354 1960 1009 354 1961 1012 355 1962 1010 355 1963 1011 355 1964 1013 356 1965 1010 356 1966 1012 356 1967 1014 357 1968 1013 357 1969 1012 357 1970 1015 358 1971 1013 358 1972 1014 358 1973 1016 359 1974 1013 359 1975 1015 359 1976 1017 360 1977 1013 360 1978 1016 360 1979 1018 361 1980 1019 361 1981 1020 361 1982 1021 362 1983 1020 362 1984 1019 362 1985 1022 363 1986 1021 363 1987 1019 363 1988 1023 364 1989 1022 364 1990 1019 364 1991 1024 365 1992 1023 365 1993 1019 365 1994 1025 366 1995 1023 366 1996 1024 366 1997 1026 367 1998 1025 367 1999 1024 367 2000 1027 368 2001 1026 368 2002 1024 368 2003 1028 369 2004 1029 369 2005 1030 369 2006 1031 370 2007 1032 370 2008 1033 370 2009 1034 371 2010 1035 371 2011 1036 371 2012 1037 372 2013 1036 372 2014 1035 372 2015 1038 122 2016 1039 122 2017 1040 122 2018 1041 122 2019 1040 122 2020 1039 122 2021 1042 74 2022 1043 74 2023 1044 74 2024 1045 373 2025 1044 373 2026 1043 373 2027 1046 122 2028 1047 122 2029 1048 122 2030 1049 122 2031 1048 122 2032 1047 122 2033 1039 374 2034 1050 374 2035 1041 374 2036 1051 375 2037 1041 375 2038 1050 375 2039 1052 232 2040 1053 232 2041 1054 232 2042 1055 232 2043 1054 232 2044 1053 232 2045 1056 376 2046 1057 376 2047 1058 376 2048 929 377 2049 1058 377 2050 1057 377 2051 1059 378 2052 1058 378 2053 929 378 2054 1060 379 2055 929 379 2056 1057 379 2057 930 380 2058 1059 380 2059 929 380 2060 928 381 2061 1059 381 2062 930 381 2063 1061 382 2064 1059 382 2065 928 382 2066 1062 383 2067 1059 383 2068 1061 383 2069 1063 232 2070 1064 232 2071 1065 232 2072 1066 232 2073 1065 232 2074 1064 232 2075 1067 384 2076 1068 384 2077 1069 384 2078 1031 385 2079 1069 385 2080 1068 385 2081 1033 386 2082 1069 386 2083 1031 386 2084 1070 387 2085 1069 387 2086 1033 387 2087 1071 388 2088 1070 388 2089 1033 388 2090 1072 389 2091 1070 389 2092 1071 389 2093 1073 390 2094 1072 390 2095 1071 390 2096 1074 391 2097 1073 391 2098 1071 391 2099 1075 392 2100 1074 392 2101 1071 392 2102 1076 122 2103 1077 122 2104 1078 122 2105 1079 122 2106 1078 122 2107 1077 122 2108 1080 393 2109 1081 393 2110 1082 393 2111 1083 74 2112 1082 74 2113 1081 74 2114 1084 8 2115 1085 8 2116 1086 8 2117 1087 8 2118 1086 8 2119 1085 8 2120 1088 42 2121 1089 42 2122 1090 42 2123 1091 42 2124 1090 42 2125 1089 42 2126 1030 394 2127 1092 394 2128 1093 394 2129 1094 395 2130 1093 395 2131 1092 395 2132 1095 396 2133 1093 396 2134 1094 396 2135 1096 397 2136 1093 397 2137 1095 397 2138 1097 398 2139 1093 398 2140 1096 398 2141 1092 399 2142 1030 399 2143 1098 399 2144 1030 400 2145 1029 400 2146 1098 400 2147 1029 401 2148 1099 401 2149 1098 401 2150 1100 402 2151 1098 402 2152 1099 402 2153 1101 403 2154 1102 403 2155 1103 403 2156 1104 404 2157 1103 404 2158 1102 404 2159 1105 403 2160 1103 403 2161 1104 403 2162 1106 405 2163 1105 405 2164 1104 405 2165 1107 406 2166 1105 406 2167 1106 406 2168 1108 407 2169 1105 407 2170 1107 407 2171 1109 408 2172 1110 408 2173 1111 408 2174 1112 409 2175 1111 409 2176 1110 409 2177 1113 410 2178 1111 410 2179 1112 410 2180 1114 411 2181 1110 411 2182 1109 411 2183 1115 412 2184 1114 412 2185 1109 412 2186 1116 413 2187 1113 413 2188 1112 413 2189 1117 414 2190 1113 414 2191 1116 414 2192 1118 415 2193 1113 415 2194 1117 415 2195 1119 42 2196 1113 42 2197 1118 42 2198 1115 416 2199 1109 416 2200 1120 416 2201 1120 42 2202 1109 42 2203 1121 42 2204 1109 42 2205 1122 42 2206 1121 42 2207 1121 42 2208 1122 42 2209 1123 42 2210 1122 42 2211 1124 42 2212 1123 42 2213 1124 42 2214 1125 42 2215 1123 42 2216 1125 417 2217 1126 417 2218 1123 417 2219 1123 418 2220 1126 418 2221 1127 418 2222 1127 419 2223 1126 419 2224 1128 419 2225 1128 420 2226 1126 420 2227 1129 420 2228 1129 421 2229 1126 421 2230 1130 421 2231 1130 422 2232 1126 422 2233 1131 422 2234 1131 423 2235 1126 423 2236 1132 423 2237 1132 424 2238 1126 424 2239 1133 424 2240 1126 425 2241 1134 425 2242 1133 425 2243 1133 426 2244 1134 426 2245 1135 426 2246 1136 427 2247 1135 427 2248 1134 427 2249 1137 428 2250 1135 428 2251 1136 428 2252 1138 429 2253 1137 429 2254 1136 429 2255 1139 8 2256 1140 8 2257 1141 8 2258 1142 8 2259 1141 8 2260 1140 8 2261 1143 8 2262 1141 8 2263 1142 8 2264 1144 430 2265 1143 430 2266 1142 430 2267 1145 431 2268 1144 431 2269 1142 431 2270 1146 8 2271 1144 8 2272 1145 8 2273 1147 432 2274 1146 432 2275 1145 432 2276 1148 433 2277 1147 433 2278 1145 433 2279 1149 434 2280 1148 434 2281 1145 434 2282 1150 435 2283 1148 435 2284 1149 435 2285 1151 436 2286 1150 436 2287 1149 436 2288 1152 437 2289 1151 437 2290 1149 437 2291 1153 8 2292 1152 8 2293 1149 8 2294 1140 8 2295 1139 8 2296 1154 8 2297 1154 8 2298 1139 8 2299 1155 8 2300 1155 438 2301 1139 438 2302 1156 438 2303 1139 439 2304 1157 439 2305 1156 439 2306 1157 440 2307 1158 440 2308 1156 440 2309 1158 441 2310 1159 441 2311 1156 441 2312 1159 442 2313 1160 442 2314 1156 442 2315 1160 443 2316 1161 443 2317 1156 443 2318 1161 444 2319 1162 444 2320 1156 444 2321 1162 445 2322 1163 445 2323 1156 445 2324 1156 446 2325 1163 446 2326 1164 446 2327 1163 447 2328 1165 447 2329 1164 447 2330 1165 448 2331 1166 448 2332 1164 448 2333 1166 449 2334 1167 449 2335 1164 449 2336 1168 450 2337 1164 450 2338 1167 450 2339 1169 451 2340 1170 451 2341 1171 451 2342 1172 452 2343 1171 452 2344 1170 452 2345 1171 453 2346 1172 453 2347 1173 453 2348 1174 454 2349 1173 454 2350 1172 454 2351 1175 455 2352 140 455 2353 1176 455 2354 138 456 2355 1176 456 2356 140 456 2357 959 457 2358 1176 457 2359 138 457 2360 1177 458 2361 1176 458 2362 959 458 2363 965 459 2364 963 459 2365 1178 459 2366 1179 460 2367 1178 460 2368 963 460 2369 1180 172 2370 1179 172 2371 963 172 2372 968 461 2373 969 461 2374 1181 461 2375 1182 462 2376 1181 462 2377 969 462 2378 1183 122 2379 1181 122 2380 1182 122 2381 716 463 2382 715 463 2383 708 463 2384 710 464 2385 708 464 2386 715 464 2387 1184 454 2388 1185 454 2389 1186 454 2390 1187 465 2391 1186 465 2392 1185 465 2393 1185 454 2394 1184 454 2395 1188 454 2396 1189 466 2397 1188 466 2398 1184 466 2399 749 467 2400 754 467 2401 750 467 2402 752 468 2403 750 468 2404 754 468 2405 997 469 2406 999 469 2407 16 469 2408 1190 470 2409 16 470 2410 999 470 2411 17 8 2412 16 8 2413 1190 8 2414 1191 471 2415 17 471 2416 1190 471 2417 1003 462 2418 1192 462 2419 1002 462 2420 1193 472 2421 1002 472 2422 1192 472 2423 1194 122 2424 1193 122 2425 1192 122 2426 1005 352 2427 1195 352 2428 1007 352 2429 1196 473 2430 1007 473 2431 1195 473 2432 1197 172 2433 1007 172 2434 1196 172 2435 1198 474 2436 1199 474 2437 1200 474 2438 1201 471 2439 1200 471 2440 1199 471 2441 1202 475 2442 1203 475 2443 1204 475 2444 1205 476 2445 1204 476 2446 1203 476 2447 1206 477 2448 1207 477 2449 1208 477 2450 1208 478 2451 1207 478 2452 1209 478 2453 1209 479 2454 1207 479 2455 1210 479 2456 1210 480 2457 1207 480 2458 1211 480 2459 1212 481 2460 1211 481 2461 1207 481 2462 1213 482 2463 1209 482 2464 1210 482 2465 1214 172 2466 703 172 2467 1215 172 2468 705 172 2469 1215 172 2470 703 172 2471 706 483 2472 1215 483 2473 705 483 2474 1216 172 2475 1215 172 2476 706 172 2477 1216 484 2478 706 484 2479 1217 484 2480 1217 485 2481 706 485 2482 1218 485 2483 1218 486 2484 706 486 2485 1219 486 2486 704 172 2487 1219 172 2488 706 172 2489 924 74 2490 1220 74 2491 926 74 2492 1221 74 2493 926 74 2494 1220 74 2495 1222 74 2496 923 74 2497 1223 74 2498 925 74 2499 1223 74 2500 923 74 2501 1224 172 2502 1225 172 2503 1226 172 2504 1227 487 2505 1228 487 2506 1229 487 2507 1230 488 2508 1231 488 2509 1232 488 2510 1233 172 2511 1234 172 2512 1235 172 2513 1092 489 2514 1098 489 2515 1094 489 2516 1095 490 2517 1094 490 2518 1098 490 2519 1069 491 2520 1070 491 2521 1073 491 2522 1072 492 2523 1073 492 2524 1070 492 2525 1057 493 2526 1061 493 2527 927 493 2528 928 494 2529 927 494 2530 1061 494 2531 1236 495 2532 1212 495 2533 1206 495 2534 1207 496 2535 1206 496 2536 1212 496 2537 1208 497 2538 1209 497 2539 1237 497 2540 1213 498 2541 1237 498 2542 1209 498 2543</p>
+        </triangles>
+      </mesh>
+    </geometry>
+    <geometry id="Cube_001-mesh" name="Cube.001">
+      <mesh>
+        <source id="Cube_001-mesh-positions">
+          <float_array id="Cube_001-mesh-positions-array" count="60">0.8897584 -0.463859 0.8003035 1.315013 1.497067 -1 0.8897584 -1.703711 0.8242678 1.315013 -2.658771 -1 -0.8897584 -0.463859 0.8003035 -1.315013 1.497067 -1 -0.8897584 -1.703711 0.8242678 -1.315013 -2.658771 -1 -0.9862595 -3.305811 -0.790426 -0.9862595 -3.142889 0.209574 0.9862595 -3.142889 0.209574 0.9862595 -3.305811 -0.790426 0.9862595 2.32828 -0.8612616 -0.9862595 2.32828 -0.8612616 0.9862595 2.32828 -0.2650246 -0.9862595 2.32828 -0.2650246 1.292753 0.4100483 -0.002020597 1.319143 -2.045174 0.1720353 -1.292753 0.4100483 -0.002020597 -1.319143 -2.045174 0.1720356</float_array>
+          <technique_common>
+            <accessor source="#Cube_001-mesh-positions-array" count="20" stride="3">
+              <param name="X" type="float"/>
+              <param name="Y" type="float"/>
+              <param name="Z" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="Cube_001-mesh-normals">
+          <float_array id="Cube_001-mesh-normals-array" count="96">0 0.01932471 0.9998133 0 -0.3081364 -0.9513423 -0.8727803 0.04384464 0.4861401 0 0 -1 0.8727804 0.04384464 0.4861401 0 0.3564792 0.9343033 0 -0.9869868 0.1608016 0 -0.3927869 0.9196295 0.7623983 -0.21027 0.611993 -0.9482683 -0.2826182 0.1446174 0 1 0 0.9578633 0.1833587 0.2210829 -0.7659848 0.2058865 0.6089976 0 0.1646333 -0.9863549 0.9997513 0 0.02229923 0.7659848 0.2058864 0.6089976 0.898351 -0.4335622 0.07063674 -0.9997514 0 0.02229923 -0.9299094 0.3677889 0 -0.7623982 -0.2102699 0.6119932 0 -0.3081364 -0.9513422 -0.8377318 0.01055276 0.54598 0.8377319 0.01055288 0.5459798 0 0.3564792 0.9343032 0 -0.3927869 0.9196295 -0.898351 -0.4335622 0.07063674 0.9299094 0.3677889 0 0 0.1646333 -0.9863548 0.9999098 0.01012217 -0.008822977 0.9482683 -0.2826185 0.1446174 -0.9999099 0.010122 -0.008822977 -0.9578633 0.1833587 0.2210829</float_array>
+          <technique_common>
+            <accessor source="#Cube_001-mesh-normals-array" count="32" stride="3">
+              <param name="X" type="float"/>
+              <param name="Y" type="float"/>
+              <param name="Z" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="Cube_001-mesh-map-0">
+          <float_array id="Cube_001-mesh-map-0-array" count="216">0.875 0.5 0.625 0.75 0.625 0.5 0.375 0.75 0.125 0.75 0.125 0.75 0.5356172 0 0.625 0.25 0.5135849 0.25 0.375 0.5 0.125 0.75 0.125 0.5 0.625 0.5 0.5356172 0.75 0.5135849 0.5 0.625 0.5 0.875 0.5 0.875 0.5 0.625 0.75 0.375 1 0.375 0.75 0.875 0.75 0.625 0.75 0.625 0.75 0.5356172 0.75 0.625 0.75 0.625 0.75 0.375 0 0.625 0 0.5356172 0 0.625 0.25 0.375 0.5 0.375 0.25 0.375 0.5 0.625 0.5 0.5135849 0.5 0.5135849 0.25 0.625 0.25 0.625 0.25 0.125 0.5 0.375 0.5 0.375 0.5 0.5135849 0.5 0.375 0.75 0.375 0.5 0.625 0.5 0.5135849 0.5 0.625 0.5 0.375 0.75 0.625 0.75 0.375 0.75 0.375 0 0.5135849 0.25 0.375 0.25 0.375 0.25 0.625 0.25 0.375 0.25 0.625 0 0.5356172 0 0.625 0 0.875 0.5 0.875 0.75 0.625 0.75 0.375 0.75 0.375 0.75 0.125 0.75 0.5356172 0 0.625 0 0.625 0.25 0.375 0.5 0.375 0.75 0.125 0.75 0.625 0.5 0.625 0.75 0.5356172 0.75 0.625 0.5 0.625 0.5 0.875 0.5 0.625 0.75 0.625 1 0.375 1 0.875 0.75 0.875 0.75 0.625 0.75 0.375 0 0.375 0 0.625 0 0.625 0.25 0.625 0.5 0.375 0.5 0.375 0.5 0.375 0.5 0.625 0.5 0.125 0.5 0.125 0.5 0.375 0.5 0.5135849 0.5 0.5356172 0.75 0.375 0.75 0.375 0.75 0.5356172 0.75 0.625 0.75 0.375 0 0.5356172 0 0.5135849 0.25 0.375 0.25 0.5135849 0.25 0.625 0.25</float_array>
+          <technique_common>
+            <accessor source="#Cube_001-mesh-map-0-array" count="108" stride="2">
+              <param name="S" type="float"/>
+              <param name="T" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <vertices id="Cube_001-mesh-vertices">
+          <input semantic="POSITION" source="#Cube_001-mesh-positions"/>
+        </vertices>
+        <triangles count="36">
+          <input semantic="VERTEX" source="#Cube_001-mesh-vertices" offset="0"/>
+          <input semantic="NORMAL" source="#Cube_001-mesh-normals" offset="1"/>
+          <input semantic="TEXCOORD" source="#Cube_001-mesh-map-0" offset="2" set="0"/>
+          <p>4 0 0 2 0 1 0 0 2 3 1 3 8 1 4 7 1 5 19 2 6 4 2 7 18 2 8 1 3 9 7 3 10 5 3 11 0 4 12 17 4 13 16 4 14 0 5 15 15 5 16 4 5 17 10 6 18 8 6 19 11 6 20 6 7 21 10 7 22 2 7 23 17 8 24 2 8 25 10 8 26 7 9 27 9 9 28 19 9 29 15 10 30 12 10 31 13 10 32 1 11 33 14 11 34 16 11 35 18 12 36 4 12 37 15 12 38 5 13 39 12 13 40 1 13 41 16 14 42 3 14 43 1 14 44 0 15 45 16 15 46 14 15 47 3 16 48 10 16 49 11 16 50 7 17 51 18 17 52 5 17 53 5 18 54 15 18 55 13 18 56 6 19 57 19 19 58 9 19 59 4 0 60 6 0 61 2 0 62 3 20 63 11 20 64 8 20 65 19 21 66 6 21 67 4 21 68 1 3 69 3 3 70 7 3 71 0 22 72 2 22 73 17 22 74 0 23 75 14 23 76 15 23 77 10 6 78 9 6 79 8 6 80 6 24 81 9 24 82 10 24 83 7 25 84 8 25 85 9 25 86 15 10 87 14 10 88 12 10 89 1 26 90 12 26 91 14 26 92 5 27 93 13 27 94 12 27 95 16 28 96 17 28 97 3 28 98 3 29 99 17 29 100 10 29 101 7 30 102 19 30 103 18 30 104 5 31 105 18 31 106 15 31 107</p>
+        </triangles>
+      </mesh>
+    </geometry>
+  </library_geometries>
+  <library_controllers/>
+  <library_animations>
+    <animation id="action_container-Armature" name="Armature">
+      <animation id="Armature_ArmatureAction_bn_ShockFrontLeft_pose_matrix" name="Armature">
+        <source id="Armature_ArmatureAction_bn_ShockFrontLeft_pose_matrix-input">
+          <float_array id="Armature_ArmatureAction_bn_ShockFrontLeft_pose_matrix-input-array" count="250">0.04166662 0.08333331 0.125 0.1666666 0.2083333 0.25 0.2916666 0.3333333 0.375 0.4166666 0.4583333 0.5 0.5416667 0.5833333 0.625 0.6666667 0.7083333 0.75 0.7916667 0.8333333 0.875 0.9166667 0.9583333 1 1.041667 1.083333 1.125 1.166667 1.208333 1.25 1.291667 1.333333 1.375 1.416667 1.458333 1.5 1.541667 1.583333 1.625 1.666667 1.708333 1.75 1.791667 1.833333 1.875 1.916667 1.958333 2 2.041667 2.083333 2.125 2.166667 2.208333 2.25 2.291667 2.333333 2.375 2.416667 2.458333 2.5 2.541667 2.583333 2.625 2.666667 2.708333 2.75 2.791667 2.833333 2.875 2.916667 2.958333 3 3.041667 3.083333 3.125 3.166667 3.208333 3.25 3.291667 3.333333 3.375 3.416667 3.458333 3.5 3.541667 3.583333 3.625 3.666667 3.708333 3.75 3.791667 3.833333 3.875 3.916667 3.958333 4 4.041666 4.083333 4.125 4.166666 4.208333 4.25 4.291666 4.333333 4.375 4.416666 4.458333 4.5 4.541666 4.583333 4.625 4.666666 4.708333 4.75 4.791666 4.833333 4.875 4.916666 4.958333 5 5.041666 5.083333 5.125 5.166666 5.208333 5.25 5.291666 5.333333 5.375 5.416666 5.458333 5.5 5.541666 5.583333 5.625 5.666666 5.708333 5.75 5.791666 5.833333 5.875 5.916666 5.958333 6 6.041666 6.083333 6.125 6.166666 6.208333 6.25 6.291666 6.333333 6.375 6.416666 6.458333 6.5 6.541666 6.583333 6.625 6.666666 6.708333 6.75 6.791666 6.833333 6.875 6.916666 6.958333 7 7.041666 7.083333 7.125 7.166666 7.208333 7.25 7.291666 7.333333 7.375 7.416666 7.458333 7.5 7.541666 7.583333 7.625 7.666666 7.708333 7.75 7.791666 7.833333 7.875 7.916666 7.958333 8 8.041667 8.083333 8.125 8.166667 8.208333 8.25 8.291667 8.333333 8.375 8.416667 8.458333 8.5 8.541667 8.583333 8.625 8.666667 8.708333 8.75 8.791667 8.833333 8.875 8.916667 8.958333 9 9.041667 9.083333 9.125 9.166667 9.208333 9.25 9.291667 9.333333 9.375 9.416667 9.458333 9.5 9.541667 9.583333 9.625 9.666667 9.708333 9.75 9.791667 9.833333 9.875 9.916667 9.958333 10 10.04167 10.08333 10.125 10.16667 10.20833 10.25 10.29167 10.33333 10.375 10.41667</float_array>
+          <technique_common>
+            <accessor source="#Armature_ArmatureAction_bn_ShockFrontLeft_pose_matrix-input-array" count="250" stride="1">
+              <param name="TIME" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="Armature_ArmatureAction_bn_ShockFrontLeft_pose_matrix-output">
+          <float_array id="Armature_ArmatureAction_bn_ShockFrontLeft_pose_matrix-output-array" count="4000">1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.6380447 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.6380447 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.6380447 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.6380447 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.6380447 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.6380447 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.6380447 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1 1 2.69074e-14 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.78547e-9 -0.9999892 0.004656792 0.9881917 0 0 0 1</float_array>
+          <technique_common>
+            <accessor source="#Armature_ArmatureAction_bn_ShockFrontLeft_pose_matrix-output-array" count="250" stride="16">
+              <param name="TRANSFORM" type="float4x4"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="Armature_ArmatureAction_bn_ShockFrontLeft_pose_matrix-interpolation">
+          <Name_array id="Armature_ArmatureAction_bn_ShockFrontLeft_pose_matrix-interpolation-array" count="250">LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR</Name_array>
+          <technique_common>
+            <accessor source="#Armature_ArmatureAction_bn_ShockFrontLeft_pose_matrix-interpolation-array" count="250" stride="1">
+              <param name="INTERPOLATION" type="name"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <sampler id="Armature_ArmatureAction_bn_ShockFrontLeft_pose_matrix-sampler">
+          <input semantic="INPUT" source="#Armature_ArmatureAction_bn_ShockFrontLeft_pose_matrix-input"/>
+          <input semantic="OUTPUT" source="#Armature_ArmatureAction_bn_ShockFrontLeft_pose_matrix-output"/>
+          <input semantic="INTERPOLATION" source="#Armature_ArmatureAction_bn_ShockFrontLeft_pose_matrix-interpolation"/>
+        </sampler>
+        <channel source="#Armature_ArmatureAction_bn_ShockFrontLeft_pose_matrix-sampler" target="Armature_bn_ShockFrontLeft/transform"/>
+      </animation>
+      <animation id="Armature_ArmatureAction_bn_ShockBackLeft_pose_matrix" name="Armature">
+        <source id="Armature_ArmatureAction_bn_ShockBackLeft_pose_matrix-input">
+          <float_array id="Armature_ArmatureAction_bn_ShockBackLeft_pose_matrix-input-array" count="250">0.04166662 0.08333331 0.125 0.1666666 0.2083333 0.25 0.2916666 0.3333333 0.375 0.4166666 0.4583333 0.5 0.5416667 0.5833333 0.625 0.6666667 0.7083333 0.75 0.7916667 0.8333333 0.875 0.9166667 0.9583333 1 1.041667 1.083333 1.125 1.166667 1.208333 1.25 1.291667 1.333333 1.375 1.416667 1.458333 1.5 1.541667 1.583333 1.625 1.666667 1.708333 1.75 1.791667 1.833333 1.875 1.916667 1.958333 2 2.041667 2.083333 2.125 2.166667 2.208333 2.25 2.291667 2.333333 2.375 2.416667 2.458333 2.5 2.541667 2.583333 2.625 2.666667 2.708333 2.75 2.791667 2.833333 2.875 2.916667 2.958333 3 3.041667 3.083333 3.125 3.166667 3.208333 3.25 3.291667 3.333333 3.375 3.416667 3.458333 3.5 3.541667 3.583333 3.625 3.666667 3.708333 3.75 3.791667 3.833333 3.875 3.916667 3.958333 4 4.041666 4.083333 4.125 4.166666 4.208333 4.25 4.291666 4.333333 4.375 4.416666 4.458333 4.5 4.541666 4.583333 4.625 4.666666 4.708333 4.75 4.791666 4.833333 4.875 4.916666 4.958333 5 5.041666 5.083333 5.125 5.166666 5.208333 5.25 5.291666 5.333333 5.375 5.416666 5.458333 5.5 5.541666 5.583333 5.625 5.666666 5.708333 5.75 5.791666 5.833333 5.875 5.916666 5.958333 6 6.041666 6.083333 6.125 6.166666 6.208333 6.25 6.291666 6.333333 6.375 6.416666 6.458333 6.5 6.541666 6.583333 6.625 6.666666 6.708333 6.75 6.791666 6.833333 6.875 6.916666 6.958333 7 7.041666 7.083333 7.125 7.166666 7.208333 7.25 7.291666 7.333333 7.375 7.416666 7.458333 7.5 7.541666 7.583333 7.625 7.666666 7.708333 7.75 7.791666 7.833333 7.875 7.916666 7.958333 8 8.041667 8.083333 8.125 8.166667 8.208333 8.25 8.291667 8.333333 8.375 8.416667 8.458333 8.5 8.541667 8.583333 8.625 8.666667 8.708333 8.75 8.791667 8.833333 8.875 8.916667 8.958333 9 9.041667 9.083333 9.125 9.166667 9.208333 9.25 9.291667 9.333333 9.375 9.416667 9.458333 9.5 9.541667 9.583333 9.625 9.666667 9.708333 9.75 9.791667 9.833333 9.875 9.916667 9.958333 10 10.04167 10.08333 10.125 10.16667 10.20833 10.25 10.29167 10.33333 10.375 10.41667</float_array>
+          <technique_common>
+            <accessor source="#Armature_ArmatureAction_bn_ShockBackLeft_pose_matrix-input-array" count="250" stride="1">
+              <param name="TIME" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="Armature_ArmatureAction_bn_ShockBackLeft_pose_matrix-output">
+          <float_array id="Armature_ArmatureAction_bn_ShockBackLeft_pose_matrix-output-array" count="4000">1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 0.8568032 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 0.8568032 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 0.8568032 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 0.8568032 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 0.8568032 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 0.8568032 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 0.8568032 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1 1 -1.04361e-14 2.38419e-7 -1.013585 -2.38395e-7 0.01410433 0.9999006 -1.82486 -3.36275e-9 -0.9999006 0.01410425 1.238739 0 0 0 1</float_array>
+          <technique_common>
+            <accessor source="#Armature_ArmatureAction_bn_ShockBackLeft_pose_matrix-output-array" count="250" stride="16">
+              <param name="TRANSFORM" type="float4x4"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="Armature_ArmatureAction_bn_ShockBackLeft_pose_matrix-interpolation">
+          <Name_array id="Armature_ArmatureAction_bn_ShockBackLeft_pose_matrix-interpolation-array" count="250">LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR</Name_array>
+          <technique_common>
+            <accessor source="#Armature_ArmatureAction_bn_ShockBackLeft_pose_matrix-interpolation-array" count="250" stride="1">
+              <param name="INTERPOLATION" type="name"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <sampler id="Armature_ArmatureAction_bn_ShockBackLeft_pose_matrix-sampler">
+          <input semantic="INPUT" source="#Armature_ArmatureAction_bn_ShockBackLeft_pose_matrix-input"/>
+          <input semantic="OUTPUT" source="#Armature_ArmatureAction_bn_ShockBackLeft_pose_matrix-output"/>
+          <input semantic="INTERPOLATION" source="#Armature_ArmatureAction_bn_ShockBackLeft_pose_matrix-interpolation"/>
+        </sampler>
+        <channel source="#Armature_ArmatureAction_bn_ShockBackLeft_pose_matrix-sampler" target="Armature_bn_ShockBackLeft/transform"/>
+      </animation>
+      <animation id="Armature_ArmatureAction_bn_ShockBackRight_pose_matrix" name="Armature">
+        <source id="Armature_ArmatureAction_bn_ShockBackRight_pose_matrix-input">
+          <float_array id="Armature_ArmatureAction_bn_ShockBackRight_pose_matrix-input-array" count="250">0.04166662 0.08333331 0.125 0.1666666 0.2083333 0.25 0.2916666 0.3333333 0.375 0.4166666 0.4583333 0.5 0.5416667 0.5833333 0.625 0.6666667 0.7083333 0.75 0.7916667 0.8333333 0.875 0.9166667 0.9583333 1 1.041667 1.083333 1.125 1.166667 1.208333 1.25 1.291667 1.333333 1.375 1.416667 1.458333 1.5 1.541667 1.583333 1.625 1.666667 1.708333 1.75 1.791667 1.833333 1.875 1.916667 1.958333 2 2.041667 2.083333 2.125 2.166667 2.208333 2.25 2.291667 2.333333 2.375 2.416667 2.458333 2.5 2.541667 2.583333 2.625 2.666667 2.708333 2.75 2.791667 2.833333 2.875 2.916667 2.958333 3 3.041667 3.083333 3.125 3.166667 3.208333 3.25 3.291667 3.333333 3.375 3.416667 3.458333 3.5 3.541667 3.583333 3.625 3.666667 3.708333 3.75 3.791667 3.833333 3.875 3.916667 3.958333 4 4.041666 4.083333 4.125 4.166666 4.208333 4.25 4.291666 4.333333 4.375 4.416666 4.458333 4.5 4.541666 4.583333 4.625 4.666666 4.708333 4.75 4.791666 4.833333 4.875 4.916666 4.958333 5 5.041666 5.083333 5.125 5.166666 5.208333 5.25 5.291666 5.333333 5.375 5.416666 5.458333 5.5 5.541666 5.583333 5.625 5.666666 5.708333 5.75 5.791666 5.833333 5.875 5.916666 5.958333 6 6.041666 6.083333 6.125 6.166666 6.208333 6.25 6.291666 6.333333 6.375 6.416666 6.458333 6.5 6.541666 6.583333 6.625 6.666666 6.708333 6.75 6.791666 6.833333 6.875 6.916666 6.958333 7 7.041666 7.083333 7.125 7.166666 7.208333 7.25 7.291666 7.333333 7.375 7.416666 7.458333 7.5 7.541666 7.583333 7.625 7.666666 7.708333 7.75 7.791666 7.833333 7.875 7.916666 7.958333 8 8.041667 8.083333 8.125 8.166667 8.208333 8.25 8.291667 8.333333 8.375 8.416667 8.458333 8.5 8.541667 8.583333 8.625 8.666667 8.708333 8.75 8.791667 8.833333 8.875 8.916667 8.958333 9 9.041667 9.083333 9.125 9.166667 9.208333 9.25 9.291667 9.333333 9.375 9.416667 9.458333 9.5 9.541667 9.583333 9.625 9.666667 9.708333 9.75 9.791667 9.833333 9.875 9.916667 9.958333 10 10.04167 10.08333 10.125 10.16667 10.20833 10.25 10.29167 10.33333 10.375 10.41667</float_array>
+          <technique_common>
+            <accessor source="#Armature_ArmatureAction_bn_ShockBackRight_pose_matrix-input-array" count="250" stride="1">
+              <param name="TIME" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="Armature_ArmatureAction_bn_ShockBackRight_pose_matrix-output">
+          <float_array id="Armature_ArmatureAction_bn_ShockBackRight_pose_matrix-output-array" count="4000">1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 0.8520589 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 0.8520589 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 0.8520589 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 0.8520589 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 0.8520589 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 0.8520589 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 0.8520589 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1 1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1</float_array>
+          <technique_common>
+            <accessor source="#Armature_ArmatureAction_bn_ShockBackRight_pose_matrix-output-array" count="250" stride="16">
+              <param name="TRANSFORM" type="float4x4"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="Armature_ArmatureAction_bn_ShockBackRight_pose_matrix-interpolation">
+          <Name_array id="Armature_ArmatureAction_bn_ShockBackRight_pose_matrix-interpolation-array" count="250">LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR</Name_array>
+          <technique_common>
+            <accessor source="#Armature_ArmatureAction_bn_ShockBackRight_pose_matrix-interpolation-array" count="250" stride="1">
+              <param name="INTERPOLATION" type="name"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <sampler id="Armature_ArmatureAction_bn_ShockBackRight_pose_matrix-sampler">
+          <input semantic="INPUT" source="#Armature_ArmatureAction_bn_ShockBackRight_pose_matrix-input"/>
+          <input semantic="OUTPUT" source="#Armature_ArmatureAction_bn_ShockBackRight_pose_matrix-output"/>
+          <input semantic="INTERPOLATION" source="#Armature_ArmatureAction_bn_ShockBackRight_pose_matrix-interpolation"/>
+        </sampler>
+        <channel source="#Armature_ArmatureAction_bn_ShockBackRight_pose_matrix-sampler" target="Armature_bn_ShockBackRight/transform"/>
+      </animation>
+      <animation id="Armature_ArmatureAction_bn_ShockFrontRight_pose_matrix" name="Armature">
+        <source id="Armature_ArmatureAction_bn_ShockFrontRight_pose_matrix-input">
+          <float_array id="Armature_ArmatureAction_bn_ShockFrontRight_pose_matrix-input-array" count="250">0.04166662 0.08333331 0.125 0.1666666 0.2083333 0.25 0.2916666 0.3333333 0.375 0.4166666 0.4583333 0.5 0.5416667 0.5833333 0.625 0.6666667 0.7083333 0.75 0.7916667 0.8333333 0.875 0.9166667 0.9583333 1 1.041667 1.083333 1.125 1.166667 1.208333 1.25 1.291667 1.333333 1.375 1.416667 1.458333 1.5 1.541667 1.583333 1.625 1.666667 1.708333 1.75 1.791667 1.833333 1.875 1.916667 1.958333 2 2.041667 2.083333 2.125 2.166667 2.208333 2.25 2.291667 2.333333 2.375 2.416667 2.458333 2.5 2.541667 2.583333 2.625 2.666667 2.708333 2.75 2.791667 2.833333 2.875 2.916667 2.958333 3 3.041667 3.083333 3.125 3.166667 3.208333 3.25 3.291667 3.333333 3.375 3.416667 3.458333 3.5 3.541667 3.583333 3.625 3.666667 3.708333 3.75 3.791667 3.833333 3.875 3.916667 3.958333 4 4.041666 4.083333 4.125 4.166666 4.208333 4.25 4.291666 4.333333 4.375 4.416666 4.458333 4.5 4.541666 4.583333 4.625 4.666666 4.708333 4.75 4.791666 4.833333 4.875 4.916666 4.958333 5 5.041666 5.083333 5.125 5.166666 5.208333 5.25 5.291666 5.333333 5.375 5.416666 5.458333 5.5 5.541666 5.583333 5.625 5.666666 5.708333 5.75 5.791666 5.833333 5.875 5.916666 5.958333 6 6.041666 6.083333 6.125 6.166666 6.208333 6.25 6.291666 6.333333 6.375 6.416666 6.458333 6.5 6.541666 6.583333 6.625 6.666666 6.708333 6.75 6.791666 6.833333 6.875 6.916666 6.958333 7 7.041666 7.083333 7.125 7.166666 7.208333 7.25 7.291666 7.333333 7.375 7.416666 7.458333 7.5 7.541666 7.583333 7.625 7.666666 7.708333 7.75 7.791666 7.833333 7.875 7.916666 7.958333 8 8.041667 8.083333 8.125 8.166667 8.208333 8.25 8.291667 8.333333 8.375 8.416667 8.458333 8.5 8.541667 8.583333 8.625 8.666667 8.708333 8.75 8.791667 8.833333 8.875 8.916667 8.958333 9 9.041667 9.083333 9.125 9.166667 9.208333 9.25 9.291667 9.333333 9.375 9.416667 9.458333 9.5 9.541667 9.583333 9.625 9.666667 9.708333 9.75 9.791667 9.833333 9.875 9.916667 9.958333 10 10.04167 10.08333 10.125 10.16667 10.20833 10.25 10.29167 10.33333 10.375 10.41667</float_array>
+          <technique_common>
+            <accessor source="#Armature_ArmatureAction_bn_ShockFrontRight_pose_matrix-input-array" count="250" stride="1">
+              <param name="TIME" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="Armature_ArmatureAction_bn_ShockFrontRight_pose_matrix-output">
+          <float_array id="Armature_ArmatureAction_bn_ShockFrontRight_pose_matrix-output-array" count="4000">1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.635203 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.635203 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.635203 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.635203 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.635203 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.635203 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.635203 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1 1 1.65979e-14 -1.42109e-14 0.9832793 7.10543e-15 0.00465621 0.9999892 1.432958 1.50435e-14 -0.9999892 0.004656196 0.9881967 0 0 0 1</float_array>
+          <technique_common>
+            <accessor source="#Armature_ArmatureAction_bn_ShockFrontRight_pose_matrix-output-array" count="250" stride="16">
+              <param name="TRANSFORM" type="float4x4"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="Armature_ArmatureAction_bn_ShockFrontRight_pose_matrix-interpolation">
+          <Name_array id="Armature_ArmatureAction_bn_ShockFrontRight_pose_matrix-interpolation-array" count="250">LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR</Name_array>
+          <technique_common>
+            <accessor source="#Armature_ArmatureAction_bn_ShockFrontRight_pose_matrix-interpolation-array" count="250" stride="1">
+              <param name="INTERPOLATION" type="name"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <sampler id="Armature_ArmatureAction_bn_ShockFrontRight_pose_matrix-sampler">
+          <input semantic="INPUT" source="#Armature_ArmatureAction_bn_ShockFrontRight_pose_matrix-input"/>
+          <input semantic="OUTPUT" source="#Armature_ArmatureAction_bn_ShockFrontRight_pose_matrix-output"/>
+          <input semantic="INTERPOLATION" source="#Armature_ArmatureAction_bn_ShockFrontRight_pose_matrix-interpolation"/>
+        </sampler>
+        <channel source="#Armature_ArmatureAction_bn_ShockFrontRight_pose_matrix-sampler" target="Armature_bn_ShockFrontRight/transform"/>
+      </animation>
+    </animation>
+    <animation id="action_container-EYE" name="EYE">
+      <animation id="EYE_EYEAction_transform" name="EYE">
+        <source id="EYE_EYEAction_transform-input">
+          <float_array id="EYE_EYEAction_transform-input-array" count="250">0.04166662 0.08333331 0.125 0.1666666 0.2083333 0.25 0.2916666 0.3333333 0.375 0.4166666 0.4583333 0.5 0.5416667 0.5833333 0.625 0.6666667 0.7083333 0.75 0.7916667 0.8333333 0.875 0.9166667 0.9583333 1 1.041667 1.083333 1.125 1.166667 1.208333 1.25 1.291667 1.333333 1.375 1.416667 1.458333 1.5 1.541667 1.583333 1.625 1.666667 1.708333 1.75 1.791667 1.833333 1.875 1.916667 1.958333 2 2.041667 2.083333 2.125 2.166667 2.208333 2.25 2.291667 2.333333 2.375 2.416667 2.458333 2.5 2.541667 2.583333 2.625 2.666667 2.708333 2.75 2.791667 2.833333 2.875 2.916667 2.958333 3 3.041667 3.083333 3.125 3.166667 3.208333 3.25 3.291667 3.333333 3.375 3.416667 3.458333 3.5 3.541667 3.583333 3.625 3.666667 3.708333 3.75 3.791667 3.833333 3.875 3.916667 3.958333 4 4.041666 4.083333 4.125 4.166666 4.208333 4.25 4.291666 4.333333 4.375 4.416666 4.458333 4.5 4.541666 4.583333 4.625 4.666666 4.708333 4.75 4.791666 4.833333 4.875 4.916666 4.958333 5 5.041666 5.083333 5.125 5.166666 5.208333 5.25 5.291666 5.333333 5.375 5.416666 5.458333 5.5 5.541666 5.583333 5.625 5.666666 5.708333 5.75 5.791666 5.833333 5.875 5.916666 5.958333 6 6.041666 6.083333 6.125 6.166666 6.208333 6.25 6.291666 6.333333 6.375 6.416666 6.458333 6.5 6.541666 6.583333 6.625 6.666666 6.708333 6.75 6.791666 6.833333 6.875 6.916666 6.958333 7 7.041666 7.083333 7.125 7.166666 7.208333 7.25 7.291666 7.333333 7.375 7.416666 7.458333 7.5 7.541666 7.583333 7.625 7.666666 7.708333 7.75 7.791666 7.833333 7.875 7.916666 7.958333 8 8.041667 8.083333 8.125 8.166667 8.208333 8.25 8.291667 8.333333 8.375 8.416667 8.458333 8.5 8.541667 8.583333 8.625 8.666667 8.708333 8.75 8.791667 8.833333 8.875 8.916667 8.958333 9 9.041667 9.083333 9.125 9.166667 9.208333 9.25 9.291667 9.333333 9.375 9.416667 9.458333 9.5 9.541667 9.583333 9.625 9.666667 9.708333 9.75 9.791667 9.833333 9.875 9.916667 9.958333 10 10.04167 10.08333 10.125 10.16667 10.20833 10.25 10.29167 10.33333 10.375 10.41667</float_array>
+          <technique_common>
+            <accessor source="#EYE_EYEAction_transform-input-array" count="250" stride="1">
+              <param name="TIME" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="EYE_EYEAction_transform-output">
+          <float_array id="EYE_EYEAction_transform-output-array" count="4000">1 0 0 0.08639416 0 1 0 -5.181648 0 0 1 3.878492 0 0 0 1 1 0 0 0.08641761 0 1 0 -5.182283 0 0 1 3.878672 0 0 0 1 1 0 0 0.08645652 0 1 0 -5.183338 0 0 1 3.87897 0 0 0 1 1 0 0 0.08651079 0 1 0 -5.184808 0 0 1 3.879387 0 0 0 1 1 0 0 0.08658028 0 1 0 -5.186691 0 0 1 3.87992 0 0 0 1 1 0 0 0.08666487 0 1 0 -5.188984 0 0 1 3.880569 0 0 0 1 1 0 0 0.08676443 0 1 0 -5.191681 0 0 1 3.881333 0 0 0 1 1 0 0 0.08687884 0 1 0 -5.194782 0 0 1 3.882211 0 0 0 1 1 0 0 0.08700795 0 1 0 -5.198281 0 0 1 3.883202 0 0 0 1 1 0 0 0.08715168 0 1 0 -5.202176 0 0 1 3.884305 0 0 0 1 1 0 0 0.08730987 0 1 0 -5.206463 0 0 1 3.88552 0 0 0 1 1 0 0 0.08748239 0 1 0 -5.211138 0 0 1 3.886843 0 0 0 1 1 0 0 0.08766914 0 1 0 -5.216199 0 0 1 3.888277 0 0 0 1 1 0 0 0.08786998 0 1 0 -5.221642 0 0 1 3.889818 0 0 0 1 1 0 0 0.08808479 0 1 0 -5.227463 0 0 1 3.891466 0 0 0 1 1 0 0 0.08831342 0 1 0 -5.233659 0 0 1 3.893221 0 0 0 1 1 0 0 0.08855578 0 1 0 -5.240227 0 0 1 3.895081 0 0 0 1 1 0 0 0.08881173 0 1 0 -5.247163 0 0 1 3.897046 0 0 0 1 1 0 0 0.08908112 0 1 0 -5.254463 0 0 1 3.899113 0 0 0 1 1 0 0 0.08936387 0 1 0 -5.262125 0 0 1 3.901283 0 0 0 1 1 0 0 0.08965982 0 1 0 -5.270146 0 0 1 3.903554 0 0 0 1 1 0 0 0.08996885 0 1 0 -5.278521 0 0 1 3.905926 0 0 0 1 1 0 0 0.09029085 0 1 0 -5.287247 0 0 1 3.908397 0 0 0 1 1 0 0 0.09062567 0 1 0 -5.29632 0 0 1 3.910967 0 0 0 1 1 0 0 0.09097321 0 1 0 -5.305738 0 0 1 3.913634 0 0 0 1 1 0 0 0.09133332 0 1 0 -5.315497 0 0 1 3.916398 0 0 0 1 1 0 0 0.0917059 0 1 0 -5.325594 0 0 1 3.919257 0 0 0 1 1 0 0 0.09209079 0 1 0 -5.336025 0 0 1 3.922211 0 0 0 1 1 0 0 0.0924879 0 1 0 -5.346786 0 0 1 3.925258 0 0 0 1 1 0 0 0.09289708 0 1 0 -5.357874 0 0 1 3.928399 0 0 0 1 1 0 0 0.09331821 0 1 0 -5.369287 0 0 1 3.931631 0 0 0 1 1 0 0 0.09375118 0 1 0 -5.381021 0 0 1 3.934953 0 0 0 1 1 0 0 0.09419583 0 1 0 -5.39307 0 0 1 3.938366 0 0 0 1 1 0 0 0.09465206 0 1 0 -5.405435 0 0 1 3.941867 0 0 0 1 1 0 0 0.09511975 0 1 0 -5.418108 0 0 1 3.945457 0 0 0 1 1 0 0 0.09559876 0 1 0 -5.431089 0 0 1 3.949133 0 0 0 1 1 0 0 0.09608896 0 1 0 -5.444374 0 0 1 3.952895 0 0 0 1 1 0 0 0.09659024 0 1 0 -5.457958 0 0 1 3.956742 0 0 0 1 1 0 0 0.09710246 0 1 0 -5.471839 0 0 1 3.960673 0 0 0 1 1 0 0 0.0976255 0 1 0 -5.486014 0 0 1 3.964687 0 0 0 1 1 0 0 0.09815924 0 1 0 -5.500477 0 0 1 3.968783 0 0 0 1 1 0 0 0.09870355 0 1 0 -5.515228 0 0 1 3.972961 0 0 0 1 1 0 0 0.09925829 0 1 0 -5.530262 0 0 1 3.977218 0 0 0 1 1 0 0 0.09982336 0 1 0 -5.545575 0 0 1 3.981555 0 0 0 1 1 0 0 0.1003986 0 1 0 -5.561164 0 0 1 3.98597 0 0 0 1 1 0 0 0.1009839 0 1 0 -5.577025 0 0 1 3.990462 0 0 0 1 1 0 0 0.1015792 0 1 0 -5.593157 0 0 1 3.99503 0 0 0 1 1 0 0 0.1021843 0 1 0 -5.609554 0 0 1 3.999673 0 0 0 1 1 0 0 0.102799 0 1 0 -5.626214 0 0 1 4.004391 0 0 0 1 1 0 0 0.1034233 0 1 0 -5.643133 0 0 1 4.009183 0 0 0 1 1 0 0 0.1040571 0 1 0 -5.660307 0 0 1 4.014047 0 0 0 1 1 0 0 0.1047001 0 1 0 -5.677734 0 0 1 4.018982 0 0 0 1 1 0 0 0.1053524 0 1 0 -5.69541 0 0 1 4.023987 0 0 0 1 1 0 0 0.1060137 0 1 0 -5.713331 0 0 1 4.029063 0 0 0 1 1 0 0 0.106684 0 1 0 -5.731495 0 0 1 4.034207 0 0 0 1 1 0 0 0.107363 0 1 0 -5.749897 0 0 1 4.039418 0 0 0 1 1 0 0 0.1080507 0 1 0 -5.768534 0 0 1 4.044696 0 0 0 1 1 0 0 0.108747 0 1 0 -5.787403 0 0 1 4.05004 0 0 0 1 1 0 0 0.1094517 0 1 0 -5.8065 0 0 1 4.055448 0 0 0 1 1 0 0 0.1101647 0 1 0 -5.825823 0 0 1 4.06092 0 0 0 1 1 0 0 0.1108859 0 1 0 -5.845367 0 0 1 4.066455 0 0 0 1 1 0 0 0.1116152 0 1 0 -5.865129 0 0 1 4.072052 0 0 0 1 1 0 0 0.1123524 0 1 0 -5.885107 0 0 1 4.077709 0 0 0 1 1 0 0 0.1130973 0 1 0 -5.905295 0 0 1 4.083426 0 0 0 1 1 0 0 0.11385 0 1 0 -5.925692 0 0 1 4.089203 0 0 0 1 1 0 0 0.1146102 0 1 0 -5.946293 0 0 1 4.095037 0 0 0 1 1 0 0 0.1153778 0 1 0 -5.967095 0 0 1 4.100928 0 0 0 1 1 0 0 0.1161527 0 1 0 -5.988095 0 0 1 4.106875 0 0 0 1 1 0 0 0.1169348 0 1 0 -6.00929 0 0 1 4.112877 0 0 0 1 1 0 0 0.1177239 0 1 0 -6.030674 0 0 1 4.118934 0 0 0 1 1 0 0 0.11852 0 1 0 -6.052248 0 0 1 4.125043 0 0 0 1 1 0 0 0.1193228 0 1 0 -6.074005 0 0 1 4.131205 0 0 0 1 1 0 0 0.1201323 0 1 0 -6.095942 0 0 1 4.137417 0 0 0 1 1 0 0 0.1209484 0 1 0 -6.118057 0 0 1 4.14368 0 0 0 1 1 0 0 0.1217709 0 1 0 -6.140346 0 0 1 4.149992 0 0 0 1 1 0 0 0.1225996 0 1 0 -6.162806 0 0 1 4.156353 0 0 0 1 1 0 0 0.1234346 0 1 0 -6.185431 0 0 1 4.16276 0 0 0 1 1 0 0 0.1242755 0 1 0 -6.208221 0 0 1 4.169214 0 0 0 1 1 0 0 0.1251224 0 1 0 -6.231172 0 0 1 4.175714 0 0 0 1 1 0 0 0.1259751 0 1 0 -6.254279 0 0 1 4.182257 0 0 0 1 1 0 0 0.1268334 0 1 0 -6.277539 0 0 1 4.188845 0 0 0 1 1 0 0 0.1276973 0 1 0 -6.30095 0 0 1 4.195474 0 0 0 1 1 0 0 0.1285666 0 1 0 -6.324507 0 0 1 4.202146 0 0 0 1 1 0 0 0.1294411 0 1 0 -6.348207 0 0 1 4.208858 0 0 0 1 1 0 0 0.1303208 0 1 0 -6.372047 0 0 1 4.215609 0 0 0 1 1 0 0 0.1312056 0 1 0 -6.396024 0 0 1 4.222399 0 0 0 1 1 0 0 0.1320952 0 1 0 -6.420133 0 0 1 4.229227 0 0 0 1 1 0 0 0.1329897 0 1 0 -6.444372 0 0 1 4.236091 0 0 0 1 1 0 0 0.1338888 0 1 0 -6.468737 0 0 1 4.242991 0 0 0 1 1 0 0 0.1347924 0 1 0 -6.493225 0 0 1 4.249926 0 0 0 1 1 0 0 0.1357004 0 1 0 -6.517832 0 0 1 4.256895 0 0 0 1 1 0 0 0.1366127 0 1 0 -6.542555 0 0 1 4.263897 0 0 0 1 1 0 0 0.1375292 0 1 0 -6.567391 0 0 1 4.27093 0 0 0 1 1 0 0 0.1384496 0 1 0 -6.592336 0 0 1 4.277994 0 0 0 1 1 0 0 0.139374 0 1 0 -6.617386 0 0 1 4.285089 0 0 0 1 1 0 0 0.1403022 0 1 0 -6.642539 0 0 1 4.292212 0 0 0 1 1 0 0 0.141234 0 1 0 -6.66779 0 0 1 4.299363 0 0 0 1 1 0 0 0.1421693 0 1 0 -6.693137 0 0 1 4.306541 0 0 0 1 1 0 0 0.143108 0 1 0 -6.718577 0 0 1 4.313745 0 0 0 1 1 0 0 0.14405 0 1 0 -6.744104 0 0 1 4.320974 0 0 0 1 1 0 0 0.1449952 0 1 0 -6.769717 0 0 1 4.328228 0 0 0 1 1 0 0 0.1459433 0 1 0 -6.795412 0 0 1 4.335505 0 0 0 1 1 0 0 0.1468944 0 1 0 -6.821186 0 0 1 4.342803 0 0 0 1 1 0 0 0.1478482 0 1 0 -6.847034 0 0 1 4.350124 0 0 0 1 1 0 0 0.1488047 0 1 0 -6.872954 0 0 1 4.357464 0 0 0 1 1 0 0 0.1497636 0 1 0 -6.898942 0 0 1 4.364824 0 0 0 1 1 0 0 0.150725 0 1 0 -6.924994 0 0 1 4.372202 0 0 0 1 1 0 0 0.1516887 0 1 0 -6.951108 0 0 1 4.379598 0 0 0 1 1 0 0 0.1526544 0 1 0 -6.977281 0 0 1 4.38701 0 0 0 1 1 0 0 0.1536222 0 1 0 -7.003508 0 0 1 4.394436 0 0 0 1 1 0 0 0.1545919 0 1 0 -7.029785 0 0 1 4.401879 0 0 0 1 1 0 0 0.1555633 0 1 0 -7.056111 0 0 1 4.409334 0 0 0 1 1 0 0 0.1565364 0 1 0 -7.082481 0 0 1 4.416802 0 0 0 1 1 0 0 0.157511 0 1 0 -7.108892 0 0 1 4.424281 0 0 0 1 1 0 0 0.1584869 0 1 0 -7.13534 0 0 1 4.431771 0 0 0 1 1 0 0 0.1594642 0 1 0 -7.161822 0 0 1 4.439271 0 0 0 1 1 0 0 0.1604425 0 1 0 -7.188335 0 0 1 4.446779 0 0 0 1 1 0 0 0.1614219 0 1 0 -7.214876 0 0 1 4.454296 0 0 0 1 1 0 0 0.1624021 0 1 0 -7.24144 0 0 1 4.461818 0 0 0 1 1 0 0 0.1633831 0 1 0 -7.268025 0 0 1 4.469347 0 0 0 1 1 0 0 0.1643647 0 1 0 -7.294626 0 0 1 4.476881 0 0 0 1 1 0 0 0.1653469 0 1 0 -7.321242 0 0 1 4.484418 0 0 0 1 1 0 0 0.1663294 0 1 0 -7.347868 0 0 1 4.491959 0 0 0 1 1 0 0 0.1673121 0 1 0 -7.3745 0 0 1 4.499501 0 0 0 1 1 0 0 0.168295 0 1 0 -7.401136 0 0 1 4.507044 0 0 0 1 1 0 0 0.1692779 0 1 0 -7.427772 0 0 1 4.514587 0 0 0 1 1 0 0 0.1702606 0 1 0 -7.454403 0 0 1 4.522129 0 0 0 1 1 0 0 0.1712432 0 1 0 -7.48103 0 0 1 4.52967 0 0 0 1 1 0 0 0.1722253 0 1 0 -7.507646 0 0 1 4.537207 0 0 0 1 1 0 0 0.1732069 0 1 0 -7.534247 0 0 1 4.54474 0 0 0 1 1 0 0 0.1741879 0 1 0 -7.560832 0 0 1 4.552269 0 0 0 1 1 0 0 0.1751681 0 1 0 -7.587396 0 0 1 4.559792 0 0 0 1 1 0 0 0.1761475 0 1 0 -7.613936 0 0 1 4.567308 0 0 0 1 1 0 0 0.1771258 0 1 0 -7.64045 0 0 1 4.574816 0 0 0 1 1 0 0 0.1781031 0 1 0 -7.666932 0 0 1 4.582316 0 0 0 1 1 0 0 0.179079 0 1 0 -7.69338 0 0 1 4.589807 0 0 0 1 1 0 0 0.1800536 0 1 0 -7.719791 0 0 1 4.597286 0 0 0 1 1 0 0 0.1810267 0 1 0 -7.746161 0 0 1 4.604754 0 0 0 1 1 0 0 0.1819981 0 1 0 -7.772487 0 0 1 4.612209 0 0 0 1 1 0 0 0.1829678 0 1 0 -7.798764 0 0 1 4.619651 0 0 0 1 1 0 0 0.1839356 0 1 0 -7.82499 0 0 1 4.627078 0 0 0 1 1 0 0 0.1849014 0 1 0 -7.851163 0 0 1 4.63449 0 0 0 1 1 0 0 0.185865 0 1 0 -7.877277 0 0 1 4.641885 0 0 0 1 1 0 0 0.1868264 0 1 0 -7.90333 0 0 1 4.649263 0 0 0 1 1 0 0 0.1877854 0 1 0 -7.929318 0 0 1 4.656623 0 0 0 1 1 0 0 0.1887418 0 1 0 -7.955237 0 0 1 4.663964 0 0 0 1 1 0 0 0.1896956 0 1 0 -7.981087 0 0 1 4.671284 0 0 0 1 1 0 0 0.1906467 0 1 0 -8.00686 0 0 1 4.678583 0 0 0 1 1 0 0 0.1915948 0 1 0 -8.032555 0 0 1 4.685859 0 0 0 1 1 0 0 0.19254 0 1 0 -8.058167 0 0 1 4.693113 0 0 0 1 1 0 0 0.193482 0 1 0 -8.083694 0 0 1 4.700342 0 0 0 1 1 0 0 0.1944207 0 1 0 -8.109135 0 0 1 4.707546 0 0 0 1 1 0 0 0.195356 0 1 0 -8.134481 0 0 1 4.714725 0 0 0 1 1 0 0 0.1962878 0 1 0 -8.159733 0 0 1 4.721876 0 0 0 1 1 0 0 0.197216 0 1 0 -8.184885 0 0 1 4.728999 0 0 0 1 1 0 0 0.1981404 0 1 0 -8.209936 0 0 1 4.736094 0 0 0 1 1 0 0 0.1990608 0 1 0 -8.23488 0 0 1 4.743157 0 0 0 1 1 0 0 0.1999773 0 1 0 -8.259716 0 0 1 4.750191 0 0 0 1 1 0 0 0.2008896 0 1 0 -8.28444 0 0 1 4.757193 0 0 0 1 1 0 0 0.2017976 0 1 0 -8.309047 0 0 1 4.764161 0 0 0 1 1 0 0 0.2027012 0 1 0 -8.333534 0 0 1 4.771096 0 0 0 1 1 0 0 0.2036003 0 1 0 -8.3579 0 0 1 4.777997 0 0 0 1 1 0 0 0.2044948 0 1 0 -8.382139 0 0 1 4.784861 0 0 0 1 1 0 0 0.2053844 0 1 0 -8.406248 0 0 1 4.791688 0 0 0 1 1 0 0 0.2062692 0 1 0 -8.430225 0 0 1 4.798478 0 0 0 1 1 0 0 0.2071489 0 1 0 -8.454065 0 0 1 4.80523 0 0 0 1 1 0 0 0.2080234 0 1 0 -8.477766 0 0 1 4.811942 0 0 0 1 1 0 0 0.2088927 0 1 0 -8.501322 0 0 1 4.818613 0 0 0 1 1 0 0 0.2097566 0 1 0 -8.524733 0 0 1 4.825243 0 0 0 1 1 0 0 0.2106149 0 1 0 -8.547993 0 0 1 4.831831 0 0 0 1 1 0 0 0.2114676 0 1 0 -8.5711 0 0 1 4.838374 0 0 0 1 1 0 0 0.2123145 0 1 0 -8.59405 0 0 1 4.844873 0 0 0 1 1 0 0 0.2131554 0 1 0 -8.61684 0 0 1 4.851327 0 0 0 1 1 0 0 0.2139904 0 1 0 -8.639466 0 0 1 4.857735 0 0 0 1 1 0 0 0.2148191 0 1 0 -8.661926 0 0 1 4.864096 0 0 0 1 1 0 0 0.2156416 0 1 0 -8.684215 0 0 1 4.870408 0 0 0 1 1 0 0 0.2164577 0 1 0 -8.706329 0 0 1 4.87667 0 0 0 1 1 0 0 0.2172672 0 1 0 -8.728268 0 0 1 4.882884 0 0 0 1 1 0 0 0.21807 0 1 0 -8.750024 0 0 1 4.889044 0 0 0 1 1 0 0 0.2188661 0 1 0 -8.771597 0 0 1 4.895154 0 0 0 1 1 0 0 0.2196552 0 1 0 -8.792982 0 0 1 4.90121 0 0 0 1 1 0 0 0.2204373 0 1 0 -8.814177 0 0 1 4.907212 0 0 0 1 1 0 0 0.2212122 0 1 0 -8.835176 0 0 1 4.913159 0 0 0 1 1 0 0 0.2219798 0 1 0 -8.855978 0 0 1 4.91905 0 0 0 1 1 0 0 0.22274 0 1 0 -8.87658 0 0 1 4.924885 0 0 0 1 1 0 0 0.2234927 0 1 0 -8.896976 0 0 1 4.930661 0 0 0 1 1 0 0 0.2242376 0 1 0 -8.917165 0 0 1 4.936378 0 0 0 1 1 0 0 0.2249748 0 1 0 -8.937141 0 0 1 4.942036 0 0 0 1 1 0 0 0.2257041 0 1 0 -8.956904 0 0 1 4.947632 0 0 0 1 1 0 0 0.2264253 0 1 0 -8.976449 0 0 1 4.953167 0 0 0 1 1 0 0 0.2271383 0 1 0 -8.99577 0 0 1 4.958639 0 0 0 1 1 0 0 0.227843 0 1 0 -9.014869 0 0 1 4.964047 0 0 0 1 1 0 0 0.2285393 0 1 0 -9.033737 0 0 1 4.969391 0 0 0 1 1 0 0 0.229227 0 1 0 -9.052376 0 0 1 4.974669 0 0 0 1 1 0 0 0.229906 0 1 0 -9.070778 0 0 1 4.979881 0 0 0 1 1 0 0 0.2305763 0 1 0 -9.088941 0 0 1 4.985025 0 0 0 1 1 0 0 0.2312376 0 1 0 -9.106861 0 0 1 4.9901 0 0 0 1 1 0 0 0.2318899 0 1 0 -9.124537 0 0 1 4.995106 0 0 0 1 1 0 0 0.2325329 0 1 0 -9.141963 0 0 1 5.000041 0 0 0 1 1 0 0 0.2331667 0 1 0 -9.159138 0 0 1 5.004905 0 0 0 1 1 0 0 0.233791 0 1 0 -9.176058 0 0 1 5.009696 0 0 0 1 1 0 0 0.2344057 0 1 0 -9.192719 0 0 1 5.014414 0 0 0 1 1 0 0 0.2350108 0 1 0 -9.209115 0 0 1 5.019058 0 0 0 1 1 0 0 0.2356061 0 1 0 -9.225245 0 0 1 5.023626 0 0 0 1 1 0 0 0.2361914 0 1 0 -9.241108 0 0 1 5.028118 0 0 0 1 1 0 0 0.2367667 0 1 0 -9.256697 0 0 1 5.032533 0 0 0 1 1 0 0 0.2373317 0 1 0 -9.27201 0 0 1 5.036869 0 0 0 1 1 0 0 0.2378865 0 1 0 -9.287045 0 0 1 5.041127 0 0 0 1 1 0 0 0.2384308 0 1 0 -9.301794 0 0 1 5.045304 0 0 0 1 1 0 0 0.2389645 0 1 0 -9.316257 0 0 1 5.0494 0 0 0 1 1 0 0 0.2394875 0 1 0 -9.330433 0 0 1 5.053414 0 0 0 1 1 0 0 0.2399998 0 1 0 -9.344314 0 0 1 5.057345 0 0 0 1 1 0 0 0.240501 0 1 0 -9.357897 0 0 1 5.061193 0 0 0 1 1 0 0 0.2409912 0 1 0 -9.371181 0 0 1 5.064955 0 0 0 1 1 0 0 0.2414702 0 1 0 -9.384163 0 0 1 5.06863 0 0 0 1 1 0 0 0.2419379 0 1 0 -9.396837 0 0 1 5.07222 0 0 0 1 1 0 0 0.2423941 0 1 0 -9.409201 0 0 1 5.075721 0 0 0 1 1 0 0 0.2428388 0 1 0 -9.421251 0 0 1 5.079134 0 0 0 1 1 0 0 0.2432718 0 1 0 -9.432983 0 0 1 5.082457 0 0 0 1 1 0 0 0.2436929 0 1 0 -9.444397 0 0 1 5.085689 0 0 0 1 1 0 0 0.2441021 0 1 0 -9.455485 0 0 1 5.088829 0 0 0 1 1 0 0 0.2444992 0 1 0 -9.466248 0 0 1 5.091877 0 0 0 1 1 0 0 0.2448841 0 1 0 -9.476678 0 0 1 5.094831 0 0 0 1 1 0 0 0.2452567 0 1 0 -9.486773 0 0 1 5.09769 0 0 0 1 1 0 0 0.2456168 0 1 0 -9.496534 0 0 1 5.100453 0 0 0 1 1 0 0 0.2459643 0 1 0 -9.505951 0 0 1 5.103121 0 0 0 1 1 0 0 0.2462992 0 1 0 -9.515026 0 0 1 5.10569 0 0 0 1 1 0 0 0.2466211 0 1 0 -9.52375 0 0 1 5.108161 0 0 0 1 1 0 0 0.2469302 0 1 0 -9.532126 0 0 1 5.110533 0 0 0 1 1 0 0 0.2472261 0 1 0 -9.540146 0 0 1 5.112804 0 0 0 1 1 0 0 0.2475089 0 1 0 -9.547808 0 0 1 5.114974 0 0 0 1 1 0 0 0.2477783 0 1 0 -9.555109 0 0 1 5.117043 0 0 0 1 1 0 0 0.2480342 0 1 0 -9.562044 0 0 1 5.119006 0 0 0 1 1 0 0 0.2482765 0 1 0 -9.568613 0 0 1 5.120866 0 0 0 1 1 0 0 0.2485052 0 1 0 -9.574808 0 0 1 5.122622 0 0 0 1 1 0 0 0.24872 0 1 0 -9.580629 0 0 1 5.124269 0 0 0 1 1 0 0 0.2489208 0 1 0 -9.586072 0 0 1 5.125811 0 0 0 1 1 0 0 0.2491076 0 1 0 -9.591133 0 0 1 5.127244 0 0 0 1 1 0 0 0.2492801 0 1 0 -9.595808 0 0 1 5.128568 0 0 0 1 1 0 0 0.2494383 0 1 0 -9.600096 0 0 1 5.129782 0 0 0 1 1 0 0 0.249582 0 1 0 -9.603991 0 0 1 5.130885 0 0 0 1 1 0 0 0.2497111 0 1 0 -9.607489 0 0 1 5.131876 0 0 0 1 1 0 0 0.2498256 0 1 0 -9.61059 0 0 1 5.132754 0 0 0 1 1 0 0 0.2499251 0 1 0 -9.613289 0 0 1 5.133518 0 0 0 1 1 0 0 0.2500097 0 1 0 -9.61558 0 0 1 5.134167 0 0 0 1 1 0 0 0.2500792 0 1 0 -9.617464 0 0 1 5.134701 0 0 0 1 1 0 0 0.2501335 0 1 0 -9.618934 0 0 1 5.135117 0 0 0 1 1 0 0 0.2501723 0 1 0 -9.619989 0 0 1 5.135416 0 0 0 1 1 0 0 0.2501958 0 1 0 -9.620625 0 0 1 5.135595 0 0 0 1 1 0 0 0.2502037 0 1 0 -9.620836 0 0 1 5.135656 0 0 0 1</float_array>
+          <technique_common>
+            <accessor source="#EYE_EYEAction_transform-output-array" count="250" stride="16">
+              <param name="TRANSFORM" type="float4x4"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="EYE_EYEAction_transform-interpolation">
+          <Name_array id="EYE_EYEAction_transform-interpolation-array" count="250">LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR</Name_array>
+          <technique_common>
+            <accessor source="#EYE_EYEAction_transform-interpolation-array" count="250" stride="1">
+              <param name="INTERPOLATION" type="name"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <sampler id="EYE_EYEAction_transform-sampler">
+          <input semantic="INPUT" source="#EYE_EYEAction_transform-input"/>
+          <input semantic="OUTPUT" source="#EYE_EYEAction_transform-output"/>
+          <input semantic="INTERPOLATION" source="#EYE_EYEAction_transform-interpolation"/>
+        </sampler>
+        <channel source="#EYE_EYEAction_transform-sampler" target="EYE/transform"/>
+      </animation>
+    </animation>
+    <animation id="action_container-CAM" name="CAM">
+      <animation id="CAM_CAMAction_transform" name="CAM">
+        <source id="CAM_CAMAction_transform-input">
+          <float_array id="CAM_CAMAction_transform-input-array" count="250">0.04166662 0.08333331 0.125 0.1666666 0.2083333 0.25 0.2916666 0.3333333 0.375 0.4166666 0.4583333 0.5 0.5416667 0.5833333 0.625 0.6666667 0.7083333 0.75 0.7916667 0.8333333 0.875 0.9166667 0.9583333 1 1.041667 1.083333 1.125 1.166667 1.208333 1.25 1.291667 1.333333 1.375 1.416667 1.458333 1.5 1.541667 1.583333 1.625 1.666667 1.708333 1.75 1.791667 1.833333 1.875 1.916667 1.958333 2 2.041667 2.083333 2.125 2.166667 2.208333 2.25 2.291667 2.333333 2.375 2.416667 2.458333 2.5 2.541667 2.583333 2.625 2.666667 2.708333 2.75 2.791667 2.833333 2.875 2.916667 2.958333 3 3.041667 3.083333 3.125 3.166667 3.208333 3.25 3.291667 3.333333 3.375 3.416667 3.458333 3.5 3.541667 3.583333 3.625 3.666667 3.708333 3.75 3.791667 3.833333 3.875 3.916667 3.958333 4 4.041666 4.083333 4.125 4.166666 4.208333 4.25 4.291666 4.333333 4.375 4.416666 4.458333 4.5 4.541666 4.583333 4.625 4.666666 4.708333 4.75 4.791666 4.833333 4.875 4.916666 4.958333 5 5.041666 5.083333 5.125 5.166666 5.208333 5.25 5.291666 5.333333 5.375 5.416666 5.458333 5.5 5.541666 5.583333 5.625 5.666666 5.708333 5.75 5.791666 5.833333 5.875 5.916666 5.958333 6 6.041666 6.083333 6.125 6.166666 6.208333 6.25 6.291666 6.333333 6.375 6.416666 6.458333 6.5 6.541666 6.583333 6.625 6.666666 6.708333 6.75 6.791666 6.833333 6.875 6.916666 6.958333 7 7.041666 7.083333 7.125 7.166666 7.208333 7.25 7.291666 7.333333 7.375 7.416666 7.458333 7.5 7.541666 7.583333 7.625 7.666666 7.708333 7.75 7.791666 7.833333 7.875 7.916666 7.958333 8 8.041667 8.083333 8.125 8.166667 8.208333 8.25 8.291667 8.333333 8.375 8.416667 8.458333 8.5 8.541667 8.583333 8.625 8.666667 8.708333 8.75 8.791667 8.833333 8.875 8.916667 8.958333 9 9.041667 9.083333 9.125 9.166667 9.208333 9.25 9.291667 9.333333 9.375 9.416667 9.458333 9.5 9.541667 9.583333 9.625 9.666667 9.708333 9.75 9.791667 9.833333 9.875 9.916667 9.958333 10 10.04167 10.08333 10.125 10.16667 10.20833 10.25 10.29167 10.33333 10.375 10.41667</float_array>
+          <technique_common>
+            <accessor source="#CAM_CAMAction_transform-input-array" count="250" stride="1">
+              <param name="TIME" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="CAM_CAMAction_transform-output">
+          <float_array id="CAM_CAMAction_transform-output-array" count="4000">1 0 0 0.09937604 0 1 0 -5.24674 0 0 1 3.877148 0 0 0 1 1 0 0 0.09939948 0 1 0 -5.247375 0 0 1 3.877328 0 0 0 1 1 0 0 0.0994384 0 1 0 -5.24843 0 0 1 3.877626 0 0 0 1 1 0 0 0.09949267 0 1 0 -5.249901 0 0 1 3.878043 0 0 0 1 1 0 0 0.09956216 0 1 0 -5.251784 0 0 1 3.878576 0 0 0 1 1 0 0 0.09964675 0 1 0 -5.254076 0 0 1 3.879225 0 0 0 1 1 0 0 0.09974631 0 1 0 -5.256774 0 0 1 3.879989 0 0 0 1 1 0 0 0.09986071 0 1 0 -5.259875 0 0 1 3.880867 0 0 0 1 1 0 0 0.09998983 0 1 0 -5.263374 0 0 1 3.881858 0 0 0 1 1 0 0 0.1001336 0 1 0 -5.267268 0 0 1 3.882961 0 0 0 1 1 0 0 0.1002917 0 1 0 -5.271555 0 0 1 3.884176 0 0 0 1 1 0 0 0.1004643 0 1 0 -5.276231 0 0 1 3.885499 0 0 0 1 1 0 0 0.100651 0 1 0 -5.281292 0 0 1 3.886933 0 0 0 1 1 0 0 0.1008519 0 1 0 -5.286734 0 0 1 3.888474 0 0 0 1 1 0 0 0.1010667 0 1 0 -5.292555 0 0 1 3.890122 0 0 0 1 1 0 0 0.1012953 0 1 0 -5.298751 0 0 1 3.891877 0 0 0 1 1 0 0 0.1015377 0 1 0 -5.305319 0 0 1 3.893737 0 0 0 1 1 0 0 0.1017936 0 1 0 -5.312255 0 0 1 3.895702 0 0 0 1 1 0 0 0.102063 0 1 0 -5.319556 0 0 1 3.897769 0 0 0 1 1 0 0 0.1023457 0 1 0 -5.327218 0 0 1 3.899939 0 0 0 1 1 0 0 0.1026417 0 1 0 -5.335238 0 0 1 3.90221 0 0 0 1 1 0 0 0.1029507 0 1 0 -5.343613 0 0 1 3.904582 0 0 0 1 1 0 0 0.1032727 0 1 0 -5.352339 0 0 1 3.907053 0 0 0 1 1 0 0 0.1036076 0 1 0 -5.361413 0 0 1 3.909623 0 0 0 1 1 0 0 0.1039551 0 1 0 -5.370831 0 0 1 3.91229 0 0 0 1 1 0 0 0.1043152 0 1 0 -5.38059 0 0 1 3.915054 0 0 0 1 1 0 0 0.1046878 0 1 0 -5.390687 0 0 1 3.917913 0 0 0 1 1 0 0 0.1050727 0 1 0 -5.401117 0 0 1 3.920867 0 0 0 1 1 0 0 0.1054698 0 1 0 -5.411879 0 0 1 3.923914 0 0 0 1 1 0 0 0.105879 0 1 0 -5.422967 0 0 1 3.927055 0 0 0 1 1 0 0 0.1063001 0 1 0 -5.43438 0 0 1 3.930287 0 0 0 1 1 0 0 0.1067331 0 1 0 -5.446113 0 0 1 3.933609 0 0 0 1 1 0 0 0.1071777 0 1 0 -5.458163 0 0 1 3.937022 0 0 0 1 1 0 0 0.1076339 0 1 0 -5.470527 0 0 1 3.940523 0 0 0 1 1 0 0 0.1081016 0 1 0 -5.483201 0 0 1 3.944113 0 0 0 1 1 0 0 0.1085806 0 1 0 -5.496182 0 0 1 3.947789 0 0 0 1 1 0 0 0.1090708 0 1 0 -5.509466 0 0 1 3.951551 0 0 0 1 1 0 0 0.1095721 0 1 0 -5.523051 0 0 1 3.955398 0 0 0 1 1 0 0 0.1100843 0 1 0 -5.536932 0 0 1 3.959329 0 0 0 1 1 0 0 0.1106074 0 1 0 -5.551106 0 0 1 3.963343 0 0 0 1 1 0 0 0.1111411 0 1 0 -5.56557 0 0 1 3.967439 0 0 0 1 1 0 0 0.1116854 0 1 0 -5.580321 0 0 1 3.971617 0 0 0 1 1 0 0 0.1122402 0 1 0 -5.595354 0 0 1 3.975874 0 0 0 1 1 0 0 0.1128052 0 1 0 -5.610667 0 0 1 3.980211 0 0 0 1 1 0 0 0.1133805 0 1 0 -5.626256 0 0 1 3.984626 0 0 0 1 1 0 0 0.1139658 0 1 0 -5.642118 0 0 1 3.989117 0 0 0 1 1 0 0 0.1145611 0 1 0 -5.658249 0 0 1 3.993686 0 0 0 1 1 0 0 0.1151661 0 1 0 -5.674646 0 0 1 3.99833 0 0 0 1 1 0 0 0.1157809 0 1 0 -5.691307 0 0 1 4.003047 0 0 0 1 1 0 0 0.1164052 0 1 0 -5.708225 0 0 1 4.007839 0 0 0 1 1 0 0 0.117039 0 1 0 -5.7254 0 0 1 4.012702 0 0 0 1 1 0 0 0.117682 0 1 0 -5.742826 0 0 1 4.017638 0 0 0 1 1 0 0 0.1183343 0 1 0 -5.760502 0 0 1 4.022644 0 0 0 1 1 0 0 0.1189956 0 1 0 -5.778424 0 0 1 4.027719 0 0 0 1 1 0 0 0.1196658 0 1 0 -5.796587 0 0 1 4.032863 0 0 0 1 1 0 0 0.1203449 0 1 0 -5.814989 0 0 1 4.038074 0 0 0 1 1 0 0 0.1210326 0 1 0 -5.833627 0 0 1 4.043352 0 0 0 1 1 0 0 0.1217289 0 1 0 -5.852495 0 0 1 4.048696 0 0 0 1 1 0 0 0.1224336 0 1 0 -5.871593 0 0 1 4.054104 0 0 0 1 1 0 0 0.1231466 0 1 0 -5.890915 0 0 1 4.059577 0 0 0 1 1 0 0 0.1238678 0 1 0 -5.91046 0 0 1 4.065111 0 0 0 1 1 0 0 0.1245971 0 1 0 -5.930222 0 0 1 4.070708 0 0 0 1 1 0 0 0.1253342 0 1 0 -5.9502 0 0 1 4.076365 0 0 0 1 1 0 0 0.1260792 0 1 0 -5.970388 0 0 1 4.082083 0 0 0 1 1 0 0 0.1268319 0 1 0 -5.990784 0 0 1 4.087859 0 0 0 1 1 0 0 0.127592 0 1 0 -6.011385 0 0 1 4.093693 0 0 0 1 1 0 0 0.1283597 0 1 0 -6.032188 0 0 1 4.099584 0 0 0 1 1 0 0 0.1291346 0 1 0 -6.053188 0 0 1 4.105531 0 0 0 1 1 0 0 0.1299167 0 1 0 -6.074382 0 0 1 4.111534 0 0 0 1 1 0 0 0.1307058 0 1 0 -6.095767 0 0 1 4.117589 0 0 0 1 1 0 0 0.1315019 0 1 0 -6.11734 0 0 1 4.123699 0 0 0 1 1 0 0 0.1323047 0 1 0 -6.139097 0 0 1 4.12986 0 0 0 1 1 0 0 0.1331142 0 1 0 -6.161035 0 0 1 4.136073 0 0 0 1 1 0 0 0.1339303 0 1 0 -6.18315 0 0 1 4.142336 0 0 0 1 1 0 0 0.1347528 0 1 0 -6.205438 0 0 1 4.148648 0 0 0 1 1 0 0 0.1355815 0 1 0 -6.227898 0 0 1 4.155008 0 0 0 1 1 0 0 0.1364165 0 1 0 -6.250524 0 0 1 4.161417 0 0 0 1 1 0 0 0.1372574 0 1 0 -6.273314 0 0 1 4.167871 0 0 0 1 1 0 0 0.1381043 0 1 0 -6.296264 0 0 1 4.174369 0 0 0 1 1 0 0 0.1389569 0 1 0 -6.319371 0 0 1 4.180913 0 0 0 1 1 0 0 0.1398153 0 1 0 -6.342631 0 0 1 4.1875 0 0 0 1 1 0 0 0.1406792 0 1 0 -6.366042 0 0 1 4.19413 0 0 0 1 1 0 0 0.1415484 0 1 0 -6.389599 0 0 1 4.200802 0 0 0 1 1 0 0 0.142423 0 1 0 -6.4133 0 0 1 4.207514 0 0 0 1 1 0 0 0.1433027 0 1 0 -6.43714 0 0 1 4.214265 0 0 0 1 1 0 0 0.1441875 0 1 0 -6.461116 0 0 1 4.221056 0 0 0 1 1 0 0 0.1450771 0 1 0 -6.485226 0 0 1 4.227883 0 0 0 1 1 0 0 0.1459716 0 1 0 -6.509465 0 0 1 4.234747 0 0 0 1 1 0 0 0.1468706 0 1 0 -6.53383 0 0 1 4.241648 0 0 0 1 1 0 0 0.1477743 0 1 0 -6.558317 0 0 1 4.248582 0 0 0 1 1 0 0 0.1486823 0 1 0 -6.582925 0 0 1 4.255551 0 0 0 1 1 0 0 0.1495946 0 1 0 -6.607648 0 0 1 4.262553 0 0 0 1 1 0 0 0.1505111 0 1 0 -6.632483 0 0 1 4.269586 0 0 0 1 1 0 0 0.1514315 0 1 0 -6.657428 0 0 1 4.27665 0 0 0 1 1 0 0 0.1523559 0 1 0 -6.682478 0 0 1 4.283744 0 0 0 1 1 0 0 0.1532841 0 1 0 -6.707631 0 0 1 4.290867 0 0 0 1 1 0 0 0.1542159 0 1 0 -6.732882 0 0 1 4.298018 0 0 0 1 1 0 0 0.1551512 0 1 0 -6.75823 0 0 1 4.305197 0 0 0 1 1 0 0 0.1560899 0 1 0 -6.783669 0 0 1 4.312401 0 0 0 1 1 0 0 0.1570319 0 1 0 -6.809197 0 0 1 4.31963 0 0 0 1 1 0 0 0.157977 0 1 0 -6.83481 0 0 1 4.326884 0 0 0 1 1 0 0 0.1589252 0 1 0 -6.860505 0 0 1 4.334161 0 0 0 1 1 0 0 0.1598763 0 1 0 -6.886278 0 0 1 4.34146 0 0 0 1 1 0 0 0.1608301 0 1 0 -6.912126 0 0 1 4.34878 0 0 0 1 1 0 0 0.1617866 0 1 0 -6.938046 0 0 1 4.356121 0 0 0 1 1 0 0 0.1627455 0 1 0 -6.964035 0 0 1 4.36348 0 0 0 1 1 0 0 0.1637069 0 1 0 -6.990087 0 0 1 4.370858 0 0 0 1 1 0 0 0.1646705 0 1 0 -7.016201 0 0 1 4.378253 0 0 0 1 1 0 0 0.1656363 0 1 0 -7.042373 0 0 1 4.385665 0 0 0 1 1 0 0 0.1666041 0 1 0 -7.0686 0 0 1 4.393093 0 0 0 1 1 0 0 0.1675738 0 1 0 -7.094878 0 0 1 4.400535 0 0 0 1 1 0 0 0.1685452 0 1 0 -7.121203 0 0 1 4.40799 0 0 0 1 1 0 0 0.1695183 0 1 0 -7.147573 0 0 1 4.415458 0 0 0 1 1 0 0 0.1704929 0 1 0 -7.173984 0 0 1 4.422937 0 0 0 1 1 0 0 0.1714688 0 1 0 -7.200432 0 0 1 4.430428 0 0 0 1 1 0 0 0.172446 0 1 0 -7.226915 0 0 1 4.437927 0 0 0 1 1 0 0 0.1734244 0 1 0 -7.253428 0 0 1 4.445436 0 0 0 1 1 0 0 0.1744037 0 1 0 -7.279969 0 0 1 4.452951 0 0 0 1 1 0 0 0.175384 0 1 0 -7.306533 0 0 1 4.460474 0 0 0 1 1 0 0 0.176365 0 1 0 -7.333117 0 0 1 4.468003 0 0 0 1 1 0 0 0.1773466 0 1 0 -7.359719 0 0 1 4.475536 0 0 0 1 1 0 0 0.1783288 0 1 0 -7.386335 0 0 1 4.483074 0 0 0 1 1 0 0 0.1793112 0 1 0 -7.41296 0 0 1 4.490614 0 0 0 1 1 0 0 0.180294 0 1 0 -7.439592 0 0 1 4.498157 0 0 0 1 1 0 0 0.1812769 0 1 0 -7.466228 0 0 1 4.5057 0 0 0 1 1 0 0 0.1822598 0 1 0 -7.492864 0 0 1 4.513243 0 0 0 1 1 0 0 0.1832425 0 1 0 -7.519496 0 0 1 4.520785 0 0 0 1 1 0 0 0.184225 0 1 0 -7.546122 0 0 1 4.528326 0 0 0 1 1 0 0 0.1852072 0 1 0 -7.572738 0 0 1 4.535863 0 0 0 1 1 0 0 0.1861888 0 1 0 -7.59934 0 0 1 4.543396 0 0 0 1 1 0 0 0.1871698 0 1 0 -7.625924 0 0 1 4.550925 0 0 0 1 1 0 0 0.18815 0 1 0 -7.652489 0 0 1 4.558448 0 0 0 1 1 0 0 0.1891294 0 1 0 -7.679029 0 0 1 4.565964 0 0 0 1 1 0 0 0.1901077 0 1 0 -7.705542 0 0 1 4.573473 0 0 0 1 1 0 0 0.191085 0 1 0 -7.732024 0 0 1 4.580972 0 0 0 1 1 0 0 0.1920609 0 1 0 -7.758472 0 0 1 4.588462 0 0 0 1 1 0 0 0.1930355 0 1 0 -7.784883 0 0 1 4.595942 0 0 0 1 1 0 0 0.1940086 0 1 0 -7.811254 0 0 1 4.60341 0 0 0 1 1 0 0 0.19498 0 1 0 -7.837579 0 0 1 4.610865 0 0 0 1 1 0 0 0.1959497 0 1 0 -7.863856 0 0 1 4.618307 0 0 0 1 1 0 0 0.1969174 0 1 0 -7.890082 0 0 1 4.625734 0 0 0 1 1 0 0 0.1978832 0 1 0 -7.916255 0 0 1 4.633146 0 0 0 1 1 0 0 0.1988469 0 1 0 -7.942369 0 0 1 4.640541 0 0 0 1 1 0 0 0.1998082 0 1 0 -7.968422 0 0 1 4.647919 0 0 0 1 1 0 0 0.2007672 0 1 0 -7.994411 0 0 1 4.655279 0 0 0 1 1 0 0 0.2017237 0 1 0 -8.02033 0 0 1 4.66262 0 0 0 1 1 0 0 0.2026775 0 1 0 -8.046179 0 0 1 4.66994 0 0 0 1 1 0 0 0.2036286 0 1 0 -8.071953 0 0 1 4.677238 0 0 0 1 1 0 0 0.2045767 0 1 0 -8.097647 0 0 1 4.684515 0 0 0 1 1 0 0 0.2055218 0 1 0 -8.12326 0 0 1 4.691769 0 0 0 1 1 0 0 0.2064638 0 1 0 -8.148787 0 0 1 4.698998 0 0 0 1 1 0 0 0.2074026 0 1 0 -8.174227 0 0 1 4.706203 0 0 0 1 1 0 0 0.2083379 0 1 0 -8.199574 0 0 1 4.713381 0 0 0 1 1 0 0 0.2092697 0 1 0 -8.224825 0 0 1 4.720532 0 0 0 1 1 0 0 0.2101979 0 1 0 -8.249977 0 0 1 4.727655 0 0 0 1 1 0 0 0.2111222 0 1 0 -8.275028 0 0 1 4.734749 0 0 0 1 1 0 0 0.2120427 0 1 0 -8.299973 0 0 1 4.741814 0 0 0 1 1 0 0 0.2129592 0 1 0 -8.324808 0 0 1 4.748847 0 0 0 1 1 0 0 0.2138715 0 1 0 -8.349532 0 0 1 4.755848 0 0 0 1 1 0 0 0.2147795 0 1 0 -8.374139 0 0 1 4.762817 0 0 0 1 1 0 0 0.2156831 0 1 0 -8.398626 0 0 1 4.769752 0 0 0 1 1 0 0 0.2165822 0 1 0 -8.422992 0 0 1 4.776652 0 0 0 1 1 0 0 0.2174767 0 1 0 -8.447231 0 0 1 4.783517 0 0 0 1 1 0 0 0.2183663 0 1 0 -8.47134 0 0 1 4.790344 0 0 0 1 1 0 0 0.219251 0 1 0 -8.495317 0 0 1 4.797134 0 0 0 1 1 0 0 0.2201308 0 1 0 -8.519157 0 0 1 4.803885 0 0 0 1 1 0 0 0.2210053 0 1 0 -8.542858 0 0 1 4.810598 0 0 0 1 1 0 0 0.2218746 0 1 0 -8.566414 0 0 1 4.817269 0 0 0 1 1 0 0 0.2227385 0 1 0 -8.589825 0 0 1 4.823899 0 0 0 1 1 0 0 0.2235968 0 1 0 -8.613085 0 0 1 4.830486 0 0 0 1 1 0 0 0.2244495 0 1 0 -8.636192 0 0 1 4.83703 0 0 0 1 1 0 0 0.2252963 0 1 0 -8.659142 0 0 1 4.843529 0 0 0 1 1 0 0 0.2261373 0 1 0 -8.681932 0 0 1 4.849983 0 0 0 1 1 0 0 0.2269723 0 1 0 -8.704558 0 0 1 4.856391 0 0 0 1 1 0 0 0.227801 0 1 0 -8.727018 0 0 1 4.862751 0 0 0 1 1 0 0 0.2286235 0 1 0 -8.749307 0 0 1 4.869063 0 0 0 1 1 0 0 0.2294396 0 1 0 -8.771421 0 0 1 4.875327 0 0 0 1 1 0 0 0.2302491 0 1 0 -8.79336 0 0 1 4.881539 0 0 0 1 1 0 0 0.2310519 0 1 0 -8.815116 0 0 1 4.8877 0 0 0 1 1 0 0 0.231848 0 1 0 -8.836689 0 0 1 4.89381 0 0 0 1 1 0 0 0.2326371 0 1 0 -8.858073 0 0 1 4.899866 0 0 0 1 1 0 0 0.2334192 0 1 0 -8.879269 0 0 1 4.905868 0 0 0 1 1 0 0 0.2341941 0 1 0 -8.900269 0 0 1 4.911815 0 0 0 1 1 0 0 0.2349617 0 1 0 -8.92107 0 0 1 4.917706 0 0 0 1 1 0 0 0.2357219 0 1 0 -8.941672 0 0 1 4.923541 0 0 0 1 1 0 0 0.2364746 0 1 0 -8.962069 0 0 1 4.929317 0 0 0 1 1 0 0 0.2372195 0 1 0 -8.982257 0 0 1 4.935034 0 0 0 1 1 0 0 0.2379567 0 1 0 -9.002234 0 0 1 4.940691 0 0 0 1 1 0 0 0.238686 0 1 0 -9.021996 0 0 1 4.946288 0 0 0 1 1 0 0 0.2394072 0 1 0 -9.041541 0 0 1 4.951823 0 0 0 1 1 0 0 0.2401201 0 1 0 -9.060863 0 0 1 4.957295 0 0 0 1 1 0 0 0.2408249 0 1 0 -9.079961 0 0 1 4.962704 0 0 0 1 1 0 0 0.2415212 0 1 0 -9.098829 0 0 1 4.968047 0 0 0 1 1 0 0 0.2422089 0 1 0 -9.117467 0 0 1 4.973325 0 0 0 1 1 0 0 0.242888 0 1 0 -9.135869 0 0 1 4.978537 0 0 0 1 1 0 0 0.2435582 0 1 0 -9.154033 0 0 1 4.98368 0 0 0 1 1 0 0 0.2442195 0 1 0 -9.171953 0 0 1 4.988756 0 0 0 1 1 0 0 0.2448717 0 1 0 -9.18963 0 0 1 4.993761 0 0 0 1 1 0 0 0.2455148 0 1 0 -9.207056 0 0 1 4.998697 0 0 0 1 1 0 0 0.2461485 0 1 0 -9.224232 0 0 1 5.003561 0 0 0 1 1 0 0 0.2467729 0 1 0 -9.24115 0 0 1 5.008352 0 0 0 1 1 0 0 0.2473876 0 1 0 -9.257809 0 0 1 5.01307 0 0 0 1 1 0 0 0.2479927 0 1 0 -9.274207 0 0 1 5.017714 0 0 0 1 1 0 0 0.248588 0 1 0 -9.290339 0 0 1 5.022282 0 0 0 1 1 0 0 0.2491733 0 1 0 -9.3062 0 0 1 5.026774 0 0 0 1 1 0 0 0.2497485 0 1 0 -9.321789 0 0 1 5.031188 0 0 0 1 1 0 0 0.2503136 0 1 0 -9.337102 0 0 1 5.035525 0 0 0 1 1 0 0 0.2508684 0 1 0 -9.352137 0 0 1 5.039783 0 0 0 1 1 0 0 0.2514126 0 1 0 -9.366886 0 0 1 5.04396 0 0 0 1 1 0 0 0.2519464 0 1 0 -9.38135 0 0 1 5.048056 0 0 0 1 1 0 0 0.2524694 0 1 0 -9.395525 0 0 1 5.05207 0 0 0 1 1 0 0 0.2529817 0 1 0 -9.409406 0 0 1 5.056001 0 0 0 1 1 0 0 0.2534829 0 1 0 -9.42299 0 0 1 5.059848 0 0 0 1 1 0 0 0.2539731 0 1 0 -9.436274 0 0 1 5.06361 0 0 0 1 1 0 0 0.2544521 0 1 0 -9.449255 0 0 1 5.067286 0 0 0 1 1 0 0 0.2549198 0 1 0 -9.461929 0 0 1 5.070876 0 0 0 1 1 0 0 0.255376 0 1 0 -9.474294 0 0 1 5.074377 0 0 0 1 1 0 0 0.2558207 0 1 0 -9.486343 0 0 1 5.07779 0 0 0 1 1 0 0 0.2562537 0 1 0 -9.498076 0 0 1 5.081112 0 0 0 1 1 0 0 0.2566748 0 1 0 -9.509489 0 0 1 5.084345 0 0 0 1 1 0 0 0.257084 0 1 0 -9.520577 0 0 1 5.087485 0 0 0 1 1 0 0 0.2574811 0 1 0 -9.53134 0 0 1 5.090532 0 0 0 1 1 0 0 0.257866 0 1 0 -9.54177 0 0 1 5.093486 0 0 0 1 1 0 0 0.2582386 0 1 0 -9.551867 0 0 1 5.096346 0 0 0 1 1 0 0 0.2585987 0 1 0 -9.561625 0 0 1 5.099109 0 0 0 1 1 0 0 0.2589462 0 1 0 -9.571043 0 0 1 5.101777 0 0 0 1 1 0 0 0.259281 0 1 0 -9.580116 0 0 1 5.104347 0 0 0 1 1 0 0 0.259603 0 1 0 -9.588842 0 0 1 5.106817 0 0 0 1 1 0 0 0.2599121 0 1 0 -9.597217 0 0 1 5.109189 0 0 0 1 1 0 0 0.260208 0 1 0 -9.605236 0 0 1 5.11146 0 0 0 1 1 0 0 0.2604907 0 1 0 -9.6129 0 0 1 5.11363 0 0 0 1 1 0 0 0.2607602 0 1 0 -9.620199 0 0 1 5.115698 0 0 0 1 1 0 0 0.2610161 0 1 0 -9.627136 0 0 1 5.117662 0 0 0 1 1 0 0 0.2612584 0 1 0 -9.633703 0 0 1 5.119522 0 0 0 1 1 0 0 0.2614871 0 1 0 -9.6399 0 0 1 5.121277 0 0 0 1 1 0 0 0.2617019 0 1 0 -9.645721 0 0 1 5.122926 0 0 0 1 1 0 0 0.2619027 0 1 0 -9.651164 0 0 1 5.124467 0 0 0 1 1 0 0 0.2620895 0 1 0 -9.656225 0 0 1 5.1259 0 0 0 1 1 0 0 0.262262 0 1 0 -9.6609 0 0 1 5.127224 0 0 0 1 1 0 0 0.2624202 0 1 0 -9.665188 0 0 1 5.128438 0 0 0 1 1 0 0 0.2625639 0 1 0 -9.669083 0 0 1 5.12954 0 0 0 1 1 0 0 0.262693 0 1 0 -9.672583 0 0 1 5.130532 0 0 0 1 1 0 0 0.2628075 0 1 0 -9.675682 0 0 1 5.13141 0 0 0 1 1 0 0 0.262907 0 1 0 -9.678379 0 0 1 5.132174 0 0 0 1 1 0 0 0.2629916 0 1 0 -9.680672 0 0 1 5.132823 0 0 0 1 1 0 0 0.2630611 0 1 0 -9.682556 0 0 1 5.133357 0 0 0 1 1 0 0 0.2631153 0 1 0 -9.684028 0 0 1 5.133773 0 0 0 1 1 0 0 0.2631543 0 1 0 -9.685081 0 0 1 5.134071 0 0 0 1 1 0 0 0.2631777 0 1 0 -9.685715 0 0 1 5.134252 0 0 0 1 1 0 0 0.2631856 0 1 0 -9.685928 0 0 1 5.134312 0 0 0 1</float_array>
+          <technique_common>
+            <accessor source="#CAM_CAMAction_transform-output-array" count="250" stride="16">
+              <param name="TRANSFORM" type="float4x4"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="CAM_CAMAction_transform-interpolation">
+          <Name_array id="CAM_CAMAction_transform-interpolation-array" count="250">LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR LINEAR</Name_array>
+          <technique_common>
+            <accessor source="#CAM_CAMAction_transform-interpolation-array" count="250" stride="1">
+              <param name="INTERPOLATION" type="name"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <sampler id="CAM_CAMAction_transform-sampler">
+          <input semantic="INPUT" source="#CAM_CAMAction_transform-input"/>
+          <input semantic="OUTPUT" source="#CAM_CAMAction_transform-output"/>
+          <input semantic="INTERPOLATION" source="#CAM_CAMAction_transform-interpolation"/>
+        </sampler>
+        <channel source="#CAM_CAMAction_transform-sampler" target="CAM/transform"/>
+      </animation>
+    </animation>
+  </library_animations>
+  <library_visual_scenes>
+    <visual_scene id="Scene" name="Scene">
+      <node id="CarBody" name="CarBody" type="NODE">
+        <matrix sid="transform">1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1</matrix>
+        <instance_geometry url="#ID15_001-mesh" name="CarBody">
+          <bind_material>
+            <technique_common>
+              <instance_material symbol="InteractiveRed-material" target="#InteractiveRed-material">
+                <bind_vertex_input semantic="ID20" input_semantic="TEXCOORD" input_set="0"/>
+              </instance_material>
+            </technique_common>
+          </bind_material>
+        </instance_geometry>
+      </node>
+      <node id="colMesh_1" name="colMesh_1" type="NODE">
+        <matrix sid="transform">1 0 0 0 0 1 0 0.2790807 0 0 1 1.424781 0 0 0 1</matrix>
+        <instance_geometry url="#Cube_001-mesh" name="colMesh_1"/>
+      </node>
+      <node id="NULLDETAIL1" name="NULLDETAIL1" type="NODE">
+        <matrix sid="transform">1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1</matrix>
+      </node>
+      <node id="MOUNT0" name="MOUNT0" type="NODE">
+        <matrix sid="transform">1 0 0 -3.17719e-16 0 1 0 -0.2920505 0 0 1 1.778878 0 0 0 1</matrix>
+      </node>
+      <node id="EYE" name="EYE" type="NODE">
+        <matrix sid="transform">1 0 0 0.2502037 0 1 0 -9.620836 0 0 1 5.135656 0 0 0 1</matrix>
+      </node>
+      <node id="CAM" name="CAM" type="NODE">
+        <matrix sid="transform">1 0 0 0.2631856 0 1 0 -9.685928 0 0 1 5.134312 0 0 0 1</matrix>
+      </node>
+      <node id="Armature" name="Armature" type="NODE">
+        <matrix sid="transform">1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1</matrix>
+        <node id="Armature_bn_Root" name="bn_Root" sid="bn_Root" type="JOINT">
+          <matrix sid="transform">1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1</matrix>
+          <node id="Armature_bn_ShockFrontLeft" name="bn_ShockFrontLeft" sid="bn_ShockFrontLeft" type="JOINT">
+            <matrix sid="transform">1 0 5.98164e-7 -1.004052 -5.98157e-7 0.00465675 0.9999892 1.432954 -2.7855e-9 -0.9999892 0.004656792 0.9881912 0 0 0 1</matrix>
+            <node id="Armature_hub0" name="hub0" sid="hub0" type="JOINT">
+              <matrix sid="transform">1 -5.98084e-7 1.18541e-7 -0.001434088 1.21325e-7 0.004656792 -0.9999892 0.424885 5.97526e-7 0.9999892 0.004656792 -0.006624699 0 0 0 1</matrix>
+              <extra>
+                <technique profile="blender">
+                  <layer sid="layer" type="string">0</layer>
+                  <roll sid="roll" type="float">1.21326e-7</roll>
+                  <tip_x sid="tip_x" type="float">0</tip_x>
+                  <tip_y sid="tip_y" type="float">0.6195614</tip_y>
+                  <tip_z sid="tip_z" type="float">0</tip_z>
+                </technique>
+              </extra>
+            </node>
+            <extra>
+              <technique profile="blender">
+                <layer sid="layer" type="string">0</layer>
+                <roll sid="roll" type="float">5.98164e-7</roll>
+                <tip_x sid="tip_x" type="float">0</tip_x>
+                <tip_y sid="tip_y" type="float">0.002052783</tip_y>
+                <tip_z sid="tip_z" type="float">-0.4408142</tip_z>
+              </technique>
+            </extra>
+          </node>
+          <node id="Armature_bn_ShockBackLeft" name="bn_ShockBackLeft" sid="bn_ShockBackLeft" type="JOINT">
+            <matrix sid="transform">1 2.22045e-16 2.6077e-7 -1.013585 -2.60744e-7 0.01410433 0.9999006 -1.82486 -3.67799e-9 -0.9999006 0.01410425 1.238739 0 0 0 1</matrix>
+            <node id="Armature_hub3" name="hub3" sid="hub3" type="JOINT">
+              <matrix sid="transform">1 -2.60498e-7 1.86736e-8 0.007035851 2.23459e-8 0.01410425 -0.9999005 0.4207921 2.60209e-7 0.9999005 0.01410431 0.001840234 0 0 0 1</matrix>
+              <extra>
+                <technique profile="blender">
+                  <layer sid="layer" type="string">0</layer>
+                  <roll sid="roll" type="float">0</roll>
+                  <tip_x sid="tip_x" type="float">0</tip_x>
+                  <tip_y sid="tip_y" type="float">0.5452125</tip_y>
+                  <tip_z sid="tip_z" type="float">0</tip_z>
+                </technique>
+              </extra>
+            </node>
+            <extra>
+              <technique profile="blender">
+                <layer sid="layer" type="string">0</layer>
+                <roll sid="roll" type="float">2.6077e-7</roll>
+                <tip_x sid="tip_x" type="float">0</tip_x>
+                <tip_y sid="tip_y" type="float">0.005790472</tip_y>
+                <tip_z sid="tip_z" type="float">-0.4105049</tip_z>
+              </technique>
+            </extra>
+          </node>
+          <node id="Armature_bn_ShockBackRight" name="bn_ShockBackRight" sid="bn_ShockBackRight" type="JOINT">
+            <matrix sid="transform">1 2.22045e-16 2.38419e-7 0.9971877 -2.38395e-7 0.01410375 0.9999005 -1.824859 -3.3626e-9 -0.9999005 0.01410383 1.238739 0 0 0 1</matrix>
+            <node id="Armature_hub2" name="hub2" sid="hub2" type="JOINT">
+              <matrix sid="transform">1 -2.38398e-7 -4.802e-7 -5.88655e-4 -4.76789e-7 0.01410383 -0.9999006 0.4227737 2.45147e-7 0.9999006 0.01410395 0.001935124 0 0 0 1</matrix>
+              <extra>
+                <technique profile="blender">
+                  <layer sid="layer" type="string">0</layer>
+                  <roll sid="roll" type="float">-4.76837e-7</roll>
+                  <tip_x sid="tip_x" type="float">0</tip_x>
+                  <tip_y sid="tip_y" type="float">0.5452123</tip_y>
+                  <tip_z sid="tip_z" type="float">0</tip_z>
+                </technique>
+              </extra>
+            </node>
+            <extra>
+              <technique profile="blender">
+                <layer sid="layer" type="string">0</layer>
+                <roll sid="roll" type="float">2.38419e-7</roll>
+                <tip_x sid="tip_x" type="float">0</tip_x>
+                <tip_y sid="tip_y" type="float">0.005790233</tip_y>
+                <tip_z sid="tip_z" type="float">-0.4105048</tip_z>
+              </technique>
+            </extra>
+          </node>
+          <node id="Armature_bn_ShockFrontRight" name="bn_ShockFrontRight" sid="bn_ShockFrontRight" type="JOINT">
+            <matrix sid="transform">1 0 1.11759e-7 0.9832794 -1.11758e-7 0.00465621 0.9999892 1.432958 -5.20373e-10 -0.9999892 0.004656196 0.9881967 0 0 0 1</matrix>
+            <node id="Armature_hub1" name="hub1" sid="hub1" type="JOINT">
+              <matrix sid="transform">1 -1.1274e-7 1.11239e-7 0.008342445 1.11762e-7 0.004656195 -0.9999892 0.4229819 1.12221e-7 0.9999892 0.004656196 -0.006754637 0 0 0 1</matrix>
+              <extra>
+                <technique profile="blender">
+                  <layer sid="layer" type="string">0</layer>
+                  <roll sid="roll" type="float">0</roll>
+                  <tip_x sid="tip_x" type="float">0</tip_x>
+                  <tip_y sid="tip_y" type="float">0.6195612</tip_y>
+                  <tip_z sid="tip_z" type="float">0</tip_z>
+                </technique>
+              </extra>
+            </node>
+            <extra>
+              <technique profile="blender">
+                <layer sid="layer" type="string">0</layer>
+                <roll sid="roll" type="float">0</roll>
+                <tip_x sid="tip_x" type="float">0</tip_x>
+                <tip_y sid="tip_y" type="float">0.002052545</tip_y>
+                <tip_z sid="tip_z" type="float">-0.4408142</tip_z>
+              </technique>
+            </extra>
+          </node>
+          <node id="Armature_COLCONVEX-002" name="COLCONVEX-002" sid="COLCONVEX-002" type="JOINT">
+            <matrix sid="transform">1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1</matrix>
+            <extra>
+              <technique profile="blender">
+                <layer sid="layer" type="string">0</layer>
+                <tip_x sid="tip_x" type="float">0</tip_x>
+                <tip_y sid="tip_y" type="float">1.631059</tip_y>
+                <tip_z sid="tip_z" type="float">0</tip_z>
+              </technique>
+            </extra>
+          </node>
+          <node id="Armature_COLCONVEX-001" name="COLCONVEX-001" sid="COLCONVEX-001" type="JOINT">
+            <matrix sid="transform">1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1</matrix>
+            <extra>
+              <technique profile="blender">
+                <layer sid="layer" type="string">0</layer>
+                <tip_x sid="tip_x" type="float">0</tip_x>
+                <tip_y sid="tip_y" type="float">1.631059</tip_y>
+                <tip_z sid="tip_z" type="float">0</tip_z>
+              </technique>
+            </extra>
+          </node>
+          <extra>
+            <technique profile="blender">
+              <layer sid="layer" type="string">0</layer>
+              <tip_x sid="tip_x" type="float">0</tip_x>
+              <tip_y sid="tip_y" type="float">1.631059</tip_y>
+              <tip_z sid="tip_z" type="float">0</tip_z>
+            </technique>
+          </extra>
+        </node>
+      </node>
+      <node id="EnvironmentAmbientLight" name="EnvironmentAmbientLight" type="NODE">
+        <matrix sid="transform">1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1</matrix>
+        <instance_light url="#EnvironmentAmbientLight-light"/>
+      </node>
+    </visual_scene>
+  </library_visual_scenes>
+  <scene>
+    <instance_visual_scene url="#Scene"/>
+  </scene>
+</COLLADA>
\ No newline at end of file
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/car.tscript b/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/car.tscript
new file mode 100644
index 000000000..105f6b9fb
--- /dev/null
+++ b/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/car.tscript
@@ -0,0 +1,11 @@
+
+singleton TSShapeConstructor(cardae)
+{
+   baseShapeAsset = "./car.dae";
+   singleDetailSize = "0";
+   flipUVCoords = "0";
+   JoinIdenticalVerts = "0";
+   reverseWindingOrder = "0";
+   removeRedundantMats = "0";
+   animFPS = "2";
+};
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/carwheel.asset.taml b/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/carwheel.asset.taml
new file mode 100644
index 000000000..65df6a497
--- /dev/null
+++ b/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/carwheel.asset.taml
@@ -0,0 +1 @@
+<ShapeAsset canSave="true" canSaveDynamicFields="true" AssetName="carwheel" fileName="@assetFile=carwheel.dae" constuctorFileName="@assetFile=carwheel.tscript"/>
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/carwheel.dae b/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/carwheel.dae
new file mode 100644
index 000000000..dc394f12e
--- /dev/null
+++ b/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/carwheel.dae
@@ -0,0 +1,140 @@
+<?xml version="1.0" encoding="utf-8"?>
+<COLLADA xmlns="http://www.collada.org/2005/11/COLLADASchema" version="1.4.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <asset>
+    <contributor>
+      <author>Blender User</author>
+      <authoring_tool>Blender 2.90.0 commit date:2020-08-31, commit time:11:26, hash:0330d1af29c0</authoring_tool>
+    </contributor>
+    <created>2021-09-11T01:23:24</created>
+    <modified>2021-09-11T01:23:24</modified>
+    <unit name="meter" meter="1"/>
+    <up_axis>Z_UP</up_axis>
+  </asset>
+  <library_effects>
+    <effect id="InteractiveRed-effect">
+      <profile_COMMON>
+        <technique sid="common">
+          <lambert>
+            <emission>
+              <color sid="emission">0 0 0 1</color>
+            </emission>
+            <diffuse>
+              <color sid="diffuse">0.8 0.8 0.8 1</color>
+            </diffuse>
+            <index_of_refraction>
+              <float sid="ior">1.45</float>
+            </index_of_refraction>
+          </lambert>
+        </technique>
+      </profile_COMMON>
+    </effect>
+  </library_effects>
+  <library_images/>
+  <library_materials>
+    <material id="InteractiveRed-material" name="InteractiveRed">
+      <instance_effect url="#InteractiveRed-effect"/>
+    </material>
+  </library_materials>
+  <library_geometries>
+    <geometry id="ID7-mesh" name="ID7">
+      <mesh>
+        <source id="ID7-mesh-positions">
+          <float_array id="ID7-mesh-positions-array" count="1845">0.519616 0.1267148 -0.3000001 0.4416719 0.3267148 -0.2550001 0.5795559 0.1267148 -0.155292 0.4926219 0.3267148 -0.1319981 0 0.1267148 0.6 0 0.3267148 0.51 -0.1552919 0.1267148 0.579556 -0.1319979 0.3267148 0.492622 0.4242641 0.1267148 0.424264 0.360624 0.3267148 0.3606239 0.3000001 0.1267148 0.519616 0.2550001 0.3267148 0.441672 -0.3 0.1267148 0.5196161 -0.2549999 0.3267148 0.441672 -0.424264 0.1267147 0.4242641 -0.360624 0.3267148 0.360624 -0.155292 -0.2732852 -0.579556 -0.3000001 -0.2732852 -0.519616 -0.1552921 0.1267148 -0.579556 -0.3000001 0.1267148 -0.519616 0.4242639 0.1267148 -0.4242641 0.3606239 0.3267148 -0.360624 0.519616 0.1267148 -0.3000001 0.4416719 0.3267148 -0.2550001 -0.3000001 0.1267148 -0.519616 -0.4242641 0.1267147 -0.424264 -0.2550001 0.3267148 -0.441672 -0.3606241 0.3267148 -0.3606239 -0.51 0.3267148 0 -0.6 0.1267147 0 -0.492622 0.3267148 0.1319981 -0.579556 0.1267147 0.155292 0.424264 -0.2732852 -0.4242641 0.2999999 -0.2732852 -0.5196161 0.4242639 0.1267148 -0.4242641 0.2999999 0.1267148 -0.5196161 0 -0.2732852 0.6 0 0.1267148 0.6 -0.1552919 -0.2732852 0.579556 -0.1552919 0.1267148 0.579556 0.441672 0.3267148 0.2549999 0.360624 0.3267148 0.3606239 0.5196161 0.1267148 0.2999999 0.4242641 0.1267148 0.424264 -0.5196161 0.1267147 -0.2999999 -0.5196161 -0.2732852 -0.2999999 -0.5795561 0.1267147 -0.1552919 -0.579556 -0.2732852 -0.1552919 0 0.1267148 -0.6 -0.1552921 0.1267148 -0.579556 0 0.3267148 -0.51 -0.1319981 0.3267148 -0.492622 0.579556 -0.2732852 -0.155292 0.5795559 0.1267148 -0.155292 0.6 -0.2732852 0 0.6 0.1267148 0 0.3000001 0.1267148 0.519616 0.2550001 0.3267148 0.441672 0.155292 0.1267148 0.579556 0.131998 0.3267148 0.492622 -0.3000001 -0.2732852 -0.519616 -0.4242641 -0.2732852 -0.424264 -0.3000001 0.1267148 -0.519616 -0.4242641 0.1267147 -0.424264 -0.441672 0.3267148 0.2550001 -0.519616 0.1267147 0.3000001 -0.360624 0.3267148 0.360624 -0.424264 0.1267147 0.4242641 0.579556 -0.2732852 0.1552919 0.579556 0.1267148 0.1552919 0.5196161 -0.2732852 0.2999999 0.5196161 0.1267148 0.2999999 0.4242639 0.1267148 -0.4242641 0.2999999 0.1267148 -0.5196161 0.3606239 0.3267148 -0.360624 0.2549999 0.3267148 -0.441672 0.3000001 -0.2732852 0.519616 0.3000001 0.1267148 0.519616 0.155292 -0.2732852 0.579556 0.155292 0.1267148 0.579556 0.424264 -0.2732852 -0.4242641 0.4242639 0.1267148 -0.4242641 0.519616 -0.2732852 -0.3000001 0.519616 0.1267148 -0.3000001 -0.1552919 0.1267148 0.579556 -0.1319979 0.3267148 0.492622 -0.3 0.1267148 0.5196161 -0.2549999 0.3267148 0.441672 -0.519616 0.1267147 0.3000001 -0.519616 -0.2732852 0.3000001 -0.424264 0.1267147 0.4242641 -0.424264 -0.2732852 0.4242641 0.4242641 -0.2732852 0.424264 0.4242641 0.1267148 0.424264 0.3000001 -0.2732852 0.519616 0.3000001 0.1267148 0.519616 -0.4242641 0.1267147 -0.424264 -0.5196161 0.1267147 -0.2999999 -0.3606241 0.3267148 -0.3606239 -0.441672 0.3267148 -0.2549999 0.1552919 -0.2732852 -0.579556 0 -0.2732852 -0.6 0.1552919 0.1267148 -0.579556 0 0.1267148 -0.6 -0.4242641 0.1267147 -0.424264 -0.4242641 -0.2732852 -0.424264 -0.5196161 0.1267147 -0.2999999 -0.5196161 -0.2732852 -0.2999999 0.5795559 0.1267148 -0.155292 0.4926219 0.3267148 -0.1319981 0.6 0.1267148 0 0.51 0.3267148 0 -0.6 -0.2732852 0 -0.579556 -0.2732852 -0.1552919 -0.579556 -0.2732852 0.155292 -0.5196161 -0.2732852 -0.2999999 -0.519616 -0.2732852 0.3000001 -0.424264 -0.2732852 0.4242641 -0.4242641 -0.2732852 -0.424264 -0.2999999 -0.2732852 0.5196161 -0.3000001 -0.2732852 -0.519616 -0.1552919 -0.2732852 0.579556 -0.155292 -0.2732852 -0.579556 0 -0.2732852 0.6 0 -0.2732852 -0.6 0.155292 -0.2732852 0.579556 0.1552919 -0.2732852 -0.579556 0.3000001 -0.2732852 0.519616 0.2999999 -0.2732852 -0.5196161 0.4242641 -0.2732852 0.424264 0.424264 -0.2732852 -0.4242641 0.5196161 -0.2732852 0.2999999 0.519616 -0.2732852 -0.3000001 0.579556 -0.2732852 0.1552919 0.579556 -0.2732852 -0.155292 0.6 -0.2732852 0 -0.1552919 -0.2732852 0.579556 -0.1552919 0.1267148 0.579556 -0.2999999 -0.2732852 0.5196161 -0.3 0.1267148 0.5196161 0 -0.2732852 -0.6 -0.155292 -0.2732852 -0.579556 0 0.1267148 -0.6 -0.1552921 0.1267148 -0.579556 -0.2999999 -0.2732852 0.5196161 -0.3 0.1267148 0.5196161 -0.424264 -0.2732852 0.4242641 -0.424264 0.1267147 0.4242641 0.519616 -0.2732852 -0.3000001 0.519616 0.1267148 -0.3000001 0.579556 -0.2732852 -0.155292 0.5795559 0.1267148 -0.155292 0.155292 0.1267148 0.579556 0.131998 0.3267148 0.492622 0 0.1267148 0.6 0 0.3267148 0.51 0.1552919 0.1267148 -0.579556 0 0.1267148 -0.6 0.1319979 0.3267148 -0.492622 0 0.3267148 -0.51 0.492622 0.3267148 0.1319979 0.441672 0.3267148 0.2549999 0.579556 0.1267148 0.1552919 0.5196161 0.1267148 0.2999999 0.5196161 -0.2732852 0.2999999 0.5196161 0.1267148 0.2999999 0.4242641 -0.2732852 0.424264 0.4242641 0.1267148 0.424264 -0.579556 0.1267147 0.155292 -0.579556 -0.2732852 0.155292 -0.519616 0.1267147 0.3000001 -0.519616 -0.2732852 0.3000001 0.155292 -0.2732852 0.579556 0.155292 0.1267148 0.579556 0 -0.2732852 0.6 0 0.1267148 0.6 0.2999999 -0.2732852 -0.5196161 0.1552919 -0.2732852 -0.579556 0.2999999 0.1267148 -0.5196161 0.1552919 0.1267148 -0.579556 -0.492622 0.3267148 0.1319981 -0.579556 0.1267147 0.155292 -0.441672 0.3267148 0.2550001 -0.519616 0.1267147 0.3000001 -0.1552921 0.1267148 -0.579556 -0.3000001 0.1267148 -0.519616 -0.1319981 0.3267148 -0.492622 -0.2550001 0.3267148 -0.441672 0.6 0.1267148 0 0.51 0.3267148 0 0.579556 0.1267148 0.1552919 0.492622 0.3267148 0.1319979 -0.5196161 0.1267147 -0.2999999 -0.5795561 0.1267147 -0.1552919 -0.441672 0.3267148 -0.2549999 -0.492622 0.3267148 -0.1319979 -0.6 0.1267147 0 -0.6 -0.2732852 0 -0.579556 0.1267147 0.155292 -0.579556 -0.2732852 0.155292 0.6 -0.2732852 0 0.6 0.1267148 0 0.579556 -0.2732852 0.1552919 0.579556 0.1267148 0.1552919 -0.5795561 0.1267147 -0.1552919 -0.579556 -0.2732852 -0.1552919 -0.6 0.1267147 0 -0.6 -0.2732852 0 -0.51 0.3267148 0 -0.492622 0.3267148 0.1319981 -0.492622 0.3267148 -0.1319979 -0.441672 0.3267148 -0.2549999 -0.441672 0.3267148 0.2550001 -0.3606241 0.3267148 -0.3606239 -0.362736 0.3267148 0 -0.350376 0.3267148 -0.09388393 -0.2550001 0.3267148 -0.441672 -0.3141381 0.3267148 -0.1813679 -0.2564941 0.3267148 -0.2564939 -0.1813681 0.3267148 -0.3141379 -0.1319981 0.3267148 -0.492622 -0.09388405 0.3267148 -0.350376 0 0.3267148 -0.51 0 0.3267148 -0.362736 0.1319979 0.3267148 -0.492622 0.09388387 0.3267148 -0.350376 0.1813679 0.3267148 -0.314138 0.2549999 0.3267148 -0.441672 0.2564939 0.3267148 -0.256494 0.3606239 0.3267148 -0.360624 0.3141379 0.3267148 -0.181368 0.350376 0.3267148 -0.09388405 0.3627359 0.3267148 0 0.4416719 0.3267148 -0.2550001 0.441672 0.3267148 0.2549999 0.360624 0.3267148 0.3606239 0.350376 0.3267148 0.09388393 0.314138 0.3267148 0.1813679 0.256494 0.3267148 0.2564939 0.2550001 0.3267148 0.441672 0.181368 0.3267148 0.3141379 0.131998 0.3267148 0.492622 0.09388399 0.3267148 0.350376 0 0.3267148 0.51 0 0.3267148 0.362736 -0.09388393 0.3267148 0.350376 -0.1319979 0.3267148 0.492622 -0.1813679 0.3267148 0.314138 -0.2549999 0.3267148 0.441672 -0.2564939 0.3267148 0.256494 -0.314138 0.3267148 0.181368 -0.350376 0.3267148 0.09388405 -0.360624 0.3267148 0.360624 0.4926219 0.3267148 -0.1319981 0.492622 0.3267148 0.1319979 0.51 0.3267148 0 -0.5795561 0.1267147 -0.1552919 -0.6 0.1267147 0 -0.492622 0.3267148 -0.1319979 -0.51 0.3267148 0 0.2999999 0.1267148 -0.5196161 0.1552919 0.1267148 -0.579556 0.2549999 0.3267148 -0.441672 0.1319979 0.3267148 -0.492622 -0.208674 0.3267148 -0.1204779 -0.232746 0.3267148 -0.06236392 -0.156506 0.2267147 -0.09035795 -0.17456 0.2267147 -0.04677194 -0.156506 0.2267147 -0.09035795 -0.232746 0.3267148 -0.06236392 0.1807159 0.2267147 0 0.17456 0.2267147 0.04677194 0.240956 0.3267148 0 0.232746 0.3267148 0.06236392 0.240956 0.3267148 0 0.17456 0.2267147 0.04677194 -0.180716 0.2267147 0 -0.240956 0.3267148 0 -0.17456 0.2267147 0.046772 -0.232746 0.3267148 0.06236404 -0.17456 0.2267147 0.046772 -0.240956 0.3267148 0 0.127786 0.2267147 0.1277859 0.09035795 0.2267147 0.156506 0.170382 0.3267148 0.1703819 0.120478 0.3267148 0.208674 0.170382 0.3267148 0.1703819 0.09035795 0.2267147 0.156506 0.09035795 0.2267147 -0.156506 0.1277859 0.2267147 -0.127786 0.1204779 0.3267148 -0.208674 0.1703819 0.3267148 -0.170382 0.1204779 0.3267148 -0.208674 0.1277859 0.2267147 -0.127786 0.046772 0.2267147 0.17456 0 0.2267147 0.180716 0.06236398 0.3267148 0.232746 0 0.3267148 0.240956 0.06236398 0.3267148 0.232746 0 0.2267147 0.180716 -0.046772 0.2267147 -0.17456 -0.06236404 0.3267148 -0.232746 -0.09035801 0.2267147 -0.156506 -0.120478 0.3267148 -0.208674 -0.09035801 0.2267147 -0.156506 -0.06236404 0.3267148 -0.232746 -0.127786 0.2267147 -0.1277859 -0.09035801 0.2267147 -0.156506 -0.170382 0.3267148 -0.1703819 -0.120478 0.3267148 -0.208674 -0.170382 0.3267148 -0.1703819 -0.09035801 0.2267147 -0.156506 0.232746 0.3267148 -0.06236404 0.17456 0.2267147 -0.046772 0.240956 0.3267148 0 0.1807159 0.2267147 0 0.240956 0.3267148 0 0.17456 0.2267147 -0.046772 0.04677194 0.2267147 -0.17456 0.06236392 0.3267148 -0.232746 0 0.2267147 -0.180716 0 0.3267148 -0.240956 0 0.2267147 -0.180716 0.06236392 0.3267148 -0.232746 -0.046772 0.2267147 -0.17456 0 0.2267147 -0.180716 -0.06236404 0.3267148 -0.232746 0 0.3267148 -0.240956 -0.06236404 0.3267148 -0.232746 0 0.2267147 -0.180716 -0.17456 0.2267147 0.046772 -0.232746 0.3267148 0.06236404 -0.156506 0.2267147 0.09035801 -0.208674 0.3267148 0.120478 -0.156506 0.2267147 0.09035801 -0.232746 0.3267148 0.06236404 -0.156506 0.2267147 0.09035801 -0.208674 0.3267148 0.120478 -0.127786 0.2267147 0.127786 -0.170382 0.3267148 0.170382 -0.127786 0.2267147 0.127786 -0.208674 0.3267148 0.120478 0.156506 0.2267147 0.09035795 0.127786 0.2267147 0.1277859 0.208674 0.3267148 0.1204779 0.170382 0.3267148 0.1703819 0.208674 0.3267148 0.1204779 0.127786 0.2267147 0.1277859 -0.180716 0.2267147 0 -0.17456 0.2267147 0.046772 -0.17456 0.2267147 -0.04677194 -0.156506 0.2267147 -0.09035795 -0.17456 0.2267147 -0.04677194 -0.17456 0.2267147 0.046772 -0.156506 0.2267147 0.09035801 -0.156506 0.2267147 -0.09035795 -0.17456 0.2267147 0.046772 -0.127786 0.2267147 -0.1277859 -0.156506 0.2267147 -0.09035795 -0.156506 0.2267147 0.09035801 -0.127786 0.2267147 0.127786 -0.127786 0.2267147 -0.1277859 -0.156506 0.2267147 0.09035801 -0.09035801 0.2267147 -0.156506 -0.127786 0.2267147 -0.1277859 -0.127786 0.2267147 0.127786 -0.09035795 0.2267147 0.156506 -0.09035801 0.2267147 -0.156506 -0.127786 0.2267147 0.127786 -0.046772 0.2267147 -0.17456 -0.09035801 0.2267147 -0.156506 -0.09035795 0.2267147 0.156506 -0.04677194 0.2267147 0.17456 -0.046772 0.2267147 -0.17456 -0.09035795 0.2267147 0.156506 0 0.2267147 -0.180716 -0.046772 0.2267147 -0.17456 -0.04677194 0.2267147 0.17456 0 0.2267147 0.180716 0 0.2267147 -0.180716 -0.04677194 0.2267147 0.17456 0.04677194 0.2267147 -0.17456 0 0.2267147 -0.180716 0 0.2267147 0.180716 0.046772 0.2267147 0.17456 0.04677194 0.2267147 -0.17456 0 0.2267147 0.180716 0.09035795 0.2267147 -0.156506 0.04677194 0.2267147 -0.17456 0.046772 0.2267147 0.17456 0.09035795 0.2267147 0.156506 0.09035795 0.2267147 -0.156506 0.046772 0.2267147 0.17456 0.1277859 0.2267147 -0.127786 0.09035795 0.2267147 -0.156506 0.09035795 0.2267147 0.156506 0.127786 0.2267147 0.1277859 0.1277859 0.2267147 -0.127786 0.09035795 0.2267147 0.156506 0.156506 0.2267147 -0.09035801 0.1277859 0.2267147 -0.127786 0.127786 0.2267147 0.1277859 0.156506 0.2267147 0.09035795 0.156506 0.2267147 -0.09035801 0.127786 0.2267147 0.1277859 0.17456 0.2267147 -0.046772 0.156506 0.2267147 -0.09035801 0.156506 0.2267147 0.09035795 0.17456 0.2267147 0.04677194 0.17456 0.2267147 -0.046772 0.156506 0.2267147 0.09035795 0.1807159 0.2267147 0 0.17456 0.2267147 -0.046772 0.17456 0.2267147 0.04677194 -0.04677194 0.2267147 0.17456 -0.09035795 0.2267147 0.156506 -0.06236398 0.3267148 0.232746 -0.120478 0.3267148 0.208674 -0.06236398 0.3267148 0.232746 -0.09035795 0.2267147 0.156506 0.17456 0.2267147 0.04677194 0.156506 0.2267147 0.09035795 0.232746 0.3267148 0.06236392 0.208674 0.3267148 0.1204779 0.232746 0.3267148 0.06236392 0.156506 0.2267147 0.09035795 0.2086739 0.3267148 -0.120478 0.156506 0.2267147 -0.09035801 0.232746 0.3267148 -0.06236404 0.17456 0.2267147 -0.046772 0.232746 0.3267148 -0.06236404 0.156506 0.2267147 -0.09035801 -0.362736 0.3267148 0 -0.350376 0.3267148 0.09388405 -0.350376 0.3267148 -0.09388393 -0.3141381 0.3267148 -0.1813679 -0.350376 0.3267148 -0.09388393 -0.350376 0.3267148 0.09388405 -0.314138 0.3267148 0.181368 -0.3141381 0.3267148 -0.1813679 -0.350376 0.3267148 0.09388405 -0.2564941 0.3267148 -0.2564939 -0.3141381 0.3267148 -0.1813679 -0.314138 0.3267148 0.181368 -0.2564939 0.3267148 0.256494 -0.2564941 0.3267148 -0.2564939 -0.314138 0.3267148 0.181368 -0.240956 0.3267148 0 -0.2564941 0.3267148 -0.2564939 -0.2564939 0.3267148 0.256494 -0.1813679 0.3267148 0.314138 -0.232746 0.3267148 0.06236404 -0.232746 0.3267148 -0.06236392 -0.2564941 0.3267148 -0.2564939 -0.240956 0.3267148 0 -0.1813681 0.3267148 -0.3141379 -0.2564941 0.3267148 -0.2564939 -0.232746 0.3267148 -0.06236392 -0.208674 0.3267148 -0.1204779 -0.1813681 0.3267148 -0.3141379 -0.232746 0.3267148 -0.06236392 -0.170382 0.3267148 -0.1703819 -0.1813681 0.3267148 -0.3141379 -0.208674 0.3267148 -0.1204779 -0.09388405 0.3267148 -0.350376 -0.1813681 0.3267148 -0.3141379 -0.170382 0.3267148 -0.1703819 -0.120478 0.3267148 -0.208674 -0.09388405 0.3267148 -0.350376 -0.170382 0.3267148 -0.1703819 -0.06236404 0.3267148 -0.232746 -0.09388405 0.3267148 -0.350376 -0.120478 0.3267148 -0.208674 0 0.3267148 -0.362736 -0.09388405 0.3267148 -0.350376 -0.06236404 0.3267148 -0.232746 0 0.3267148 -0.240956 0 0.3267148 -0.362736 -0.06236404 0.3267148 -0.232746 0.09388387 0.3267148 -0.350376 0 0.3267148 -0.362736 0 0.3267148 -0.240956 0.06236392 0.3267148 -0.232746 0.09388387 0.3267148 -0.350376 0 0.3267148 -0.240956 0.1204779 0.3267148 -0.208674 0.09388387 0.3267148 -0.350376 0.06236392 0.3267148 -0.232746 0.1813679 0.3267148 -0.314138 0.09388387 0.3267148 -0.350376 0.1204779 0.3267148 -0.208674 0.1703819 0.3267148 -0.170382 0.1813679 0.3267148 -0.314138 0.1204779 0.3267148 -0.208674 0.2086739 0.3267148 -0.120478 0.1813679 0.3267148 -0.314138 0.1703819 0.3267148 -0.170382 0.2564939 0.3267148 -0.256494 0.1813679 0.3267148 -0.314138 0.2086739 0.3267148 -0.120478 0.232746 0.3267148 -0.06236404 0.2564939 0.3267148 -0.256494 0.2086739 0.3267148 -0.120478 0.240956 0.3267148 0 0.2564939 0.3267148 -0.256494 0.232746 0.3267148 -0.06236404 0.256494 0.3267148 0.2564939 0.2564939 0.3267148 -0.256494 0.240956 0.3267148 0 0.208674 0.3267148 0.1204779 0.181368 0.3267148 0.3141379 0.314138 0.3267148 0.1813679 0.2564939 0.3267148 -0.256494 0.256494 0.3267148 0.2564939 0.3141379 0.3267148 -0.181368 0.2564939 0.3267148 -0.256494 0.314138 0.3267148 0.1813679 0.350376 0.3267148 -0.09388405 0.3141379 0.3267148 -0.181368 0.314138 0.3267148 0.1813679 0.350376 0.3267148 0.09388393 0.350376 0.3267148 -0.09388405 0.314138 0.3267148 0.1813679 0.3627359 0.3267148 0 0.350376 0.3267148 -0.09388405 0.350376 0.3267148 0.09388393 -0.240956 0.3267148 0 -0.2564939 0.3267148 0.256494 -0.232746 0.3267148 0.06236404 -0.208674 0.3267148 0.120478 -0.232746 0.3267148 0.06236404 -0.1813679 0.3267148 0.314138 -0.170382 0.3267148 0.170382 -0.208674 0.3267148 0.120478 -0.09388393 0.3267148 0.350376 -0.170382 0.3267148 0.170382 -0.1813679 0.3267148 0.314138 -0.120478 0.3267148 0.208674 -0.170382 0.3267148 0.170382 -0.09388393 0.3267148 0.350376 -0.06236398 0.3267148 0.232746 -0.120478 0.3267148 0.208674 -0.09388393 0.3267148 0.350376 0 0.3267148 0.362736 -0.06236398 0.3267148 0.232746 -0.09388393 0.3267148 0.350376 0 0.3267148 0.240956 -0.06236398 0.3267148 0.232746 0 0.3267148 0.362736 0.06236398 0.3267148 0.232746 0 0.3267148 0.240956 0 0.3267148 0.362736 0.09388399 0.3267148 0.350376 0.06236398 0.3267148 0.232746 0 0.3267148 0.362736 0.120478 0.3267148 0.208674 0.06236398 0.3267148 0.232746 0.09388399 0.3267148 0.350376 0.181368 0.3267148 0.3141379 0.120478 0.3267148 0.208674 0.09388399 0.3267148 0.350376 0.170382 0.3267148 0.1703819 0.120478 0.3267148 0.208674 0.181368 0.3267148 0.3141379 0.208674 0.3267148 0.1204779 0.170382 0.3267148 0.1703819 0.181368 0.3267148 0.3141379 0.232746 0.3267148 0.06236392 0.208674 0.3267148 0.1204779 0.256494 0.3267148 0.2564939 0.240956 0.3267148 0 0.232746 0.3267148 0.06236392 0.256494 0.3267148 0.2564939 0.09035795 0.2267147 0.156506 0.046772 0.2267147 0.17456 0.120478 0.3267148 0.208674 0.06236398 0.3267148 0.232746 0.120478 0.3267148 0.208674 0.046772 0.2267147 0.17456 0.04677194 0.2267147 -0.17456 0.09035795 0.2267147 -0.156506 0.06236392 0.3267148 -0.232746 0.1204779 0.3267148 -0.208674 0.06236392 0.3267148 -0.232746 0.09035795 0.2267147 -0.156506 -0.232746 0.3267148 -0.06236392 -0.240956 0.3267148 0 -0.17456 0.2267147 -0.04677194 -0.180716 0.2267147 0 -0.17456 0.2267147 -0.04677194 -0.240956 0.3267148 0 0.1703819 0.3267148 -0.170382 0.1277859 0.2267147 -0.127786 0.2086739 0.3267148 -0.120478 0.156506 0.2267147 -0.09035801 0.2086739 0.3267148 -0.120478 0.1277859 0.2267147 -0.127786 -0.09035795 0.2267147 0.156506 -0.127786 0.2267147 0.127786 -0.120478 0.3267148 0.208674 -0.170382 0.3267148 0.170382 -0.120478 0.3267148 0.208674 -0.127786 0.2267147 0.127786 -0.170382 0.3267148 -0.1703819 -0.208674 0.3267148 -0.1204779 -0.127786 0.2267147 -0.1277859 -0.156506 0.2267147 -0.09035795 -0.127786 0.2267147 -0.1277859 -0.208674 0.3267148 -0.1204779 0 0.2267147 0.180716 -0.04677194 0.2267147 0.17456 0 0.3267148 0.240956 -0.06236398 0.3267148 0.232746 0 0.3267148 0.240956 -0.04677194 0.2267147 0.17456</float_array>
+          <technique_common>
+            <accessor source="#ID7-mesh-positions-array" count="615" stride="3">
+              <param name="X" type="float"/>
+              <param name="Y" type="float"/>
+              <param name="Z" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="ID7-mesh-normals">
+          <float_array id="ID7-mesh-normals-array" count="525">0.8437166 0.4074378 -0.3494809 -0.1191788 0.4074361 0.9054238 0.5559365 0.4074304 0.7245241 -0.5559365 0.4074304 0.7245241 -0.3826816 0 -0.9238803 0.7245241 0.4074304 -0.5559365 -0.5559365 0.4074304 -0.7245241 -0.9054238 0.4074361 0.1191788 0.6087679 0 -0.7933484 -0.1305003 0 0.9914484 0.7245241 0.4074304 0.5559365 -0.9238803 0 -0.3826816 -0.1191788 0.4074361 -0.9054238 0.9914484 0 -0.1305003 0.3494809 0.4074378 0.8437166 -0.6087679 0 -0.7933484 -0.7245241 0.4074304 0.5559365 0.9238803 0 0.3826816 0.5559365 0.4074304 -0.7245241 0.3826816 0 0.9238803 0.7933484 0 -0.6087679 -0.3494719 0.4074273 0.8437254 -0.3494809 0.4074378 0.8437166 -0.7933484 0 0.6087679 0.6087679 0 0.7933484 -0.7245241 0.4074304 -0.5559365 0.1305003 0 -0.9914484 -0.7933484 0 -0.6087679 0.9054238 0.4074361 -0.1191788 0 -1 0 0 -1 0 0 -1 0 0 -1 0 2.39831e-7 -1 0 2.39831e-7 -1 0 0 -1 0 0 -1 0 0 -1 0 0 -1 0 0 -1 0 0 -1 0 0 -1 0 2.39831e-7 -1 0 2.39831e-7 -1 0 0 -1 0 0 -1 0 0 -1 0 -0.3826816 0 0.9238803 -0.1305003 0 -0.9914484 -0.6087679 0 0.7933484 0.9238803 0 -0.3826816 0.1191788 0.4074361 0.9054238 0.1191788 0.4074361 -0.9054238 0.8437166 0.4074378 0.3494809 0.7933484 0 0.6087679 -0.9238803 0 0.3826816 0.1305003 0 0.9914484 0.3826816 0 -0.9238803 -0.8437166 0.4074378 0.3494809 -0.3494719 0.4074273 -0.8437254 -0.3494809 0.4074378 -0.8437166 0.9054238 0.4074361 0.1191788 -0.8437166 0.4074378 -0.3494809 -0.9914484 0 0.1305003 0.9914484 0 0.1305003 -0.9914484 0 -0.1305003 0 1 0 0 1 1.50978e-7 0 1 0 0 1 0 0 1 1.33391e-7 0 1 0 0 1 -1.44492e-7 0 1 3.52701e-7 0 1 0 0 1 2.69452e-7 0 1 2.87467e-7 0 1 -2.69446e-7 0 1 0 0 1 -1.34726e-7 0 1 -1.22775e-7 0 1 0 0 1 0 0 1 0 0 1 0 0 1 0 0 1 -5.38907e-7 0 1 0 0 1 2.6945e-7 0 1 2.13308e-7 0 1 -2.69446e-7 0 1 0 0 1 0 0 1 3.52702e-7 0 1 0 0 1 1.36669e-7 0 1 0 0 1 0 0 1 -2.76961e-7 0 1 0 -0.9054238 0.4074361 -0.1191788 0.3494809 0.4074378 -0.8437166 0.7931899 0.5127505 0.3285375 -0.851202 0.5127477 -0.1120042 -0.8511992 0.512746 -0.1120344 0.851202 0.5127477 -0.1120042 0.8511992 0.512746 -0.1120344 -0.5226402 0.512752 -0.6811261 -0.5226402 0.512752 0.6811261 -0.1120042 0.5127477 -0.851202 -0.1120373 0.5127593 -0.8511908 0.3285375 0.5127505 0.7931899 0.5226402 0.512752 0.6811261 -0.8511992 0.512746 0.1120344 -0.851202 0.5127477 0.1120042 -0.1120042 0.5127477 0.851202 -0.1120373 0.5127593 0.8511908 0.1120042 0.5127477 0.851202 0.1120373 0.5127593 0.8511908 0.7931899 0.5127505 -0.3285375 0.6811261 0.512752 -0.5226402 -0.6811261 0.512752 -0.5226402 0 1 0 0 1 -1.40552e-7 0 1 2.8545e-7 0 1 0 0 1 1.26883e-7 0 1 0 0 1 0 0 1 1.22408e-7 0 1 0 0 1 0 0 1 0 0 1 0 0 1 0 0 1 0 0 1 1.7944e-7 0 1 -1.45507e-7 0 1 0 0.3285375 0.5127505 -0.7931899 -0.7931899 0.5127505 -0.3285375 -0.7931899 0.5127505 0.3285375 0 1 0 0 1 1.49225e-7 0 1 0 0 1 0 0 1 -1.75136e-7 0 1 0 0 1 -1.43562e-7 0 1 3.25832e-7 0 1 -4.90513e-7 0 1 -1.5643e-7 0 1 2.45256e-7 0 1 -1.53862e-7 0 1 -1.43558e-7 0 1 0 0 1 -1.78162e-7 0 1 0 0 1 0 0 1 0 0 1 -2.45256e-7 0 1 1.62916e-7 0 1 2.55021e-7 0 1 -3.25832e-7 0 1 -3.25838e-7 0 1 0 -0.3285375 0.5127505 -0.7931899 -0.3285375 0.5127505 0.7931899 0.8511992 0.512746 0.1120344 0.851202 0.5127477 0.1120042 -0.6811261 0.512752 0.5226402 0.5226402 0.512752 -0.6811261 0.6811261 0.512752 0.5226402 0.1120042 0.5127477 -0.851202 0.1120344 0.512746 -0.8511992</float_array>
+          <technique_common>
+            <accessor source="#ID7-mesh-normals-array" count="175" stride="3">
+              <param name="X" type="float"/>
+              <param name="Y" type="float"/>
+              <param name="Z" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="ID7-mesh-map-0">
+          <float_array id="ID7-mesh-map-0-array" count="1704">-2.642518 -1.11748 -6.85499 -0.172037 -2.129416 1.922823 -6.418854 2.41222 -2.129416 1.922823 -6.85499 -0.172037 2.210953 -1.828482 3.31643 -6.001815 -0.722982 -2.776501 0.822585 -6.807631 -0.722982 -2.776501 3.31643 -6.001815 -1.414126 -2.496379 -5.330165 -4.313911 -2.860106 0.226827 -6.559249 -1.999185 -2.860106 0.226827 -5.330165 -4.313911 2.860106 0.226827 6.559249 -1.999185 1.414126 -2.496379 5.330165 -4.313911 1.414126 -2.496379 6.559249 -1.999185 0 -1.541648 0 1.541648 7.874016 -1.541648 7.874016 1.541648 7.874016 -1.541648 0 1.541648 -2.769491 -0.749384 -6.815154 0.757733 -1.849449 2.193444 -6.033118 3.259136 -1.849449 2.193444 -6.815154 0.757733 2.860106 -0.226827 1.414126 2.496379 6.559249 1.999185 5.330165 4.313911 6.559249 1.999185 1.414126 2.496379 6.650924 -1.669042 2.333658 -1.669042 6.791303 0.947997 2.498809 1.409827 6.791303 0.947997 2.333658 -1.669042 0 1.541648 0 -1.541648 -7.874016 1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 -1.541648 0 1.541648 7.874016 1.541648 0 -1.541648 7.874016 -1.541648 0 -1.541648 7.874016 1.541648 -6.033118 -3.259136 -6.815154 -0.757733 -1.849449 -2.193444 -2.769491 0.749384 -1.849449 -2.193444 -6.815154 -0.757733 7.874016 -1.541648 0 -1.541648 7.874016 1.541648 0 1.541648 7.874016 1.541648 0 -1.541648 2.210953 1.828482 -0.722982 2.776501 3.31643 6.001815 0.822585 6.807631 3.31643 6.001815 -0.722982 2.776501 0 -1.541648 -7.874016 -1.541648 0 1.541648 -7.874016 1.541648 0 1.541648 -7.874016 -1.541648 -0.643955 -2.795887 -3.879534 -5.654176 -2.806125 -0.597765 -5.717378 -3.785773 -2.806125 -0.597765 -3.879534 -5.654176 0 -1.541648 0 1.541648 7.874016 -1.541648 7.874016 1.541648 7.874016 -1.541648 0 1.541648 6.033118 -3.259136 1.849449 -2.193444 6.815154 -0.757733 2.769491 0.749384 6.815154 -0.757733 1.849449 -2.193444 0 -1.541648 -7.874016 -1.541648 0 1.541648 -7.874016 1.541648 0 1.541648 -7.874016 -1.541648 -1.414126 2.496379 -2.860106 -0.226827 -5.330165 4.313911 -6.559249 1.999185 -5.330165 4.313911 -2.860106 -0.226827 0 -1.541648 -7.874016 -1.541648 0 1.541648 -7.874016 1.541648 0 1.541648 -7.874016 -1.541648 0 -1.541648 -7.874016 -1.541648 0 1.541648 -7.874016 1.541648 0 1.541648 -7.874016 -1.541648 2.806125 -0.597765 5.717378 -3.785773 0.643955 -2.795887 3.879534 -5.654176 0.643955 -2.795887 5.717378 -3.785773 7.874016 -1.541648 0 -1.541648 7.874016 1.541648 0 1.541648 7.874016 1.541648 0 -1.541648 0 -1.541648 -7.874016 -1.541648 0 1.541648 -7.874016 1.541648 0 1.541648 -7.874016 -1.541648 2.769491 -0.749384 1.849449 2.193444 6.815154 0.757733 6.033118 3.259136 6.815154 0.757733 1.849449 2.193444 0 1.541648 0 -1.541648 -7.874016 1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 -1.541648 7.874016 -1.541648 0 -1.541648 7.874016 1.541648 0 1.541648 7.874016 1.541648 0 -1.541648 -2.498809 -1.409827 -6.791303 -0.947997 -2.333658 1.669042 -6.650924 1.669042 -2.333658 1.669042 -6.791303 -0.947997 11.81102 0 11.40857 -3.056918 11.40857 3.056918 10.22865 -5.905512 11.40857 3.056918 11.40857 -3.056918 10.22865 5.905512 11.40857 3.056918 10.22865 -5.905512 8.351655 8.351655 10.22865 5.905512 10.22865 -5.905512 8.351655 -8.351655 8.351655 8.351655 10.22865 -5.905512 5.905512 10.22865 8.351655 8.351655 8.351655 -8.351655 5.905512 -10.22865 5.905512 10.22865 8.351655 -8.351655 3.056918 11.40857 5.905512 10.22865 5.905512 -10.22865 3.056918 -11.40857 3.056918 11.40857 5.905512 -10.22865 0 11.81102 3.056918 11.40857 3.056918 -11.40857 0 -11.81102 0 11.81102 3.056918 -11.40857 -3.056918 11.40857 0 11.81102 0 -11.81102 -3.056918 -11.40857 -3.056918 11.40857 0 -11.81102 -5.905512 10.22865 -3.056918 11.40857 -3.056918 -11.40857 -5.905512 -10.22865 -5.905512 10.22865 -3.056918 -11.40857 -8.351655 8.351655 -5.905512 10.22865 -5.905512 -10.22865 -8.351655 -8.351655 -8.351655 8.351655 -5.905512 -10.22865 -10.22865 5.905512 -8.351655 8.351655 -8.351655 -8.351655 -10.22865 -5.905512 -10.22865 5.905512 -8.351655 -8.351655 -11.40857 3.056918 -10.22865 5.905512 -10.22865 -5.905512 -11.40857 -3.056918 -11.40857 3.056918 -10.22865 -5.905512 -11.81102 0 -11.40857 3.056918 -11.40857 -3.056918 0 1.541648 7.874016 1.541648 0 -1.541648 7.874016 -1.541648 0 -1.541648 7.874016 1.541648 0 -1.541648 0 1.541648 7.874016 -1.541648 7.874016 1.541648 7.874016 -1.541648 0 1.541648 0 1.541648 7.874016 1.541648 0 -1.541648 7.874016 -1.541648 0 -1.541648 7.874016 1.541648 0 -1.541648 -7.874016 -1.541648 0 1.541648 -7.874016 1.541648 0 1.541648 -7.874016 -1.541648 0.722982 -2.776501 -0.822585 -6.807631 -2.210953 -1.828482 -3.31643 -6.001815 -2.210953 -1.828482 -0.822585 -6.807631 0.722982 2.776501 -2.210953 1.828482 -0.822585 6.807631 -3.31643 6.001815 -0.822585 6.807631 -2.210953 1.828482 -6.418854 -2.41222 -6.85499 0.172037 -2.129416 -1.922823 -2.642518 1.11748 -2.129416 -1.922823 -6.85499 0.172037 0 -1.541648 -7.874016 -1.541648 0 1.541648 -7.874016 1.541648 0 1.541648 -7.874016 -1.541648 7.874016 -1.541648 0 -1.541648 7.874016 1.541648 0 1.541648 7.874016 1.541648 0 -1.541648 0 -1.541648 -7.874016 -1.541648 0 1.541648 -7.874016 1.541648 0 1.541648 -7.874016 -1.541648 0 1.541648 0 -1.541648 -7.874016 1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 -1.541648 6.418854 -2.41222 2.129416 -1.922823 6.85499 0.172037 2.642518 1.11748 6.85499 0.172037 2.129416 -1.922823 2.806125 0.597765 0.643955 2.795887 5.717378 3.785773 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 -2.333658 -1.669042 -6.650924 -1.669042 -2.498809 1.409827 -6.791303 0.947997 -2.498809 1.409827 -6.650924 -1.669042 2.642518 -1.11748 2.129416 1.922823 6.85499 -0.172037 6.418854 2.41222 6.85499 -0.172037 2.129416 1.922823 7.874016 -1.541648 0 -1.541648 7.874016 1.541648 0 1.541648 7.874016 1.541648 0 -1.541648 0 -1.541648 -7.874016 -1.541648 0 1.541648 -7.874016 1.541648 0 1.541648 -7.874016 -1.541648 7.874016 -1.541648 0 -1.541648 7.874016 1.541648 0 1.541648 7.874016 1.541648 0 -1.541648 -10.03937 0 -9.697287 2.59838 -9.697287 -2.59838 -8.69435 -5.019685 -9.697287 -2.59838 -9.697287 2.59838 -8.69435 5.019685 -8.69435 -5.019685 -9.697287 2.59838 -7.098907 -7.098907 -8.69435 -5.019685 -8.69435 5.019685 -7.140481 0 -7.098907 -7.098907 -8.69435 5.019685 -6.897174 -1.848092 -7.098907 -7.098907 -7.140481 0 -5.019685 -8.69435 -7.098907 -7.098907 -6.897174 -1.848092 -6.183837 -3.57024 -5.019685 -8.69435 -6.897174 -1.848092 -5.049082 -5.049082 -5.019685 -8.69435 -6.183837 -3.57024 -3.57024 -6.183837 -5.019685 -8.69435 -5.049082 -5.049082 -2.59838 -9.697287 -5.019685 -8.69435 -3.57024 -6.183837 -1.848092 -6.897174 -2.59838 -9.697287 -3.57024 -6.183837 0 -10.03937 -2.59838 -9.697287 -1.848092 -6.897174 0 -7.140481 0 -10.03937 -1.848092 -6.897174 2.59838 -9.697287 0 -10.03937 0 -7.140481 1.848092 -6.897174 2.59838 -9.697287 0 -7.140481 3.57024 -6.183837 2.59838 -9.697287 1.848092 -6.897174 5.019685 -8.69435 2.59838 -9.697287 3.57024 -6.183837 5.049082 -5.049082 5.019685 -8.69435 3.57024 -6.183837 7.098907 -7.098907 5.019685 -8.69435 5.049082 -5.049082 6.183837 -3.57024 7.098907 -7.098907 5.049082 -5.049082 6.897174 -1.848092 7.098907 -7.098907 6.183837 -3.57024 7.140481 0 7.098907 -7.098907 6.897174 -1.848092 8.69435 -5.019685 7.098907 -7.098907 7.140481 0 8.69435 -5.019685 7.140481 0 8.69435 5.019685 8.69435 5.019685 7.140481 0 7.098907 7.098907 7.140481 0 6.897174 1.848092 7.098907 7.098907 6.897174 1.848092 6.183837 3.57024 7.098907 7.098907 6.183837 3.57024 5.049082 5.049082 7.098907 7.098907 7.098907 7.098907 5.049082 5.049082 5.019685 8.69435 5.049082 5.049082 3.57024 6.183837 5.019685 8.69435 5.019685 8.69435 3.57024 6.183837 2.59838 9.697287 3.57024 6.183837 1.848092 6.897174 2.59838 9.697287 2.59838 9.697287 1.848092 6.897174 0 10.03937 1.848092 6.897174 0 7.140481 0 10.03937 0 7.140481 -1.848092 6.897174 0 10.03937 0 10.03937 -1.848092 6.897174 -2.59838 9.697287 -1.848092 6.897174 -3.57024 6.183837 -2.59838 9.697287 -2.59838 9.697287 -3.57024 6.183837 -5.019685 8.69435 -3.57024 6.183837 -5.049082 5.049082 -5.019685 8.69435 -5.049082 5.049082 -6.183837 3.57024 -5.019685 8.69435 -6.183837 3.57024 -6.897174 1.848092 -5.019685 8.69435 -5.019685 8.69435 -6.897174 1.848092 -7.098907 7.098907 -6.897174 1.848092 -7.140481 0 -7.098907 7.098907 -8.69435 5.019685 -7.098907 7.098907 -7.140481 0 9.697287 -2.59838 8.69435 -5.019685 8.69435 5.019685 9.697287 2.59838 9.697287 -2.59838 8.69435 5.019685 10.03937 0 9.697287 -2.59838 9.697287 2.59838 2.498809 -1.409827 2.333658 1.669042 6.791303 -0.947997 6.650924 1.669042 6.791303 -0.947997 2.333658 1.669042 -0.643955 2.795887 -2.806125 0.597765 -3.879534 5.654176 -5.717378 3.785773 -3.879534 5.654176 -2.806125 0.597765 -7.874016 1.541648 0 1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 1.541648 -7.874016 -1.541648 0 1.541648 7.874016 1.541648 0 -1.541648 0 1.541648 7.874016 1.541648 0 -1.541648 -6.650924 1.669042 -2.333658 1.669042 -6.791303 -0.947997 -6.650924 1.669042 -2.333658 1.669042 -6.791303 -0.947997 -6.650924 1.669042 -2.333658 1.669042 -6.791303 -0.947997 -6.650924 1.669042 -2.333658 1.669042 -6.791303 -0.947997 7.874016 1.541648 7.874016 -1.541648 0 1.541648 7.874016 1.541648 7.874016 -1.541648 0 1.541648 7.874016 1.541648 7.874016 -1.541648 0 1.541648 7.874016 1.541648 7.874016 -1.541648 0 1.541648 7.874016 1.541648 7.874016 -1.541648 0 1.541648 7.874016 1.541648 7.874016 -1.541648 0 1.541648 7.874016 -1.541648 0 -1.541648 7.874016 1.541648 7.874016 -1.541648 0 -1.541648 7.874016 1.541648 7.874016 -1.541648 0 -1.541648 7.874016 1.541648 7.874016 -1.541648 0 -1.541648 7.874016 1.541648 -7.874016 1.541648 0 1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 1.541648 -7.874016 -1.541648 -3.31643 -6.001815 -2.210953 -1.828482 -0.822585 -6.807631 -3.31643 -6.001815 -2.210953 -1.828482 -0.822585 -6.807631 -3.31643 -6.001815 -2.210953 -1.828482 -0.822585 -6.807631 -3.31643 -6.001815 -2.210953 -1.828482 -0.822585 -6.807631 -7.874016 1.541648 0 1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 1.541648 -7.874016 -1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 -1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 -1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 -1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 -1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 -1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 -1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 -1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 -1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 -1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 -1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 -1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 -1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 -1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 -1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 -1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 -1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 -1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 -1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 -1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 -1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 -1.541648 -7.874016 -1.541648 -7.874016 1.541648 0 -1.541648 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 3.879534 5.654176 5.717378 3.785773 0.643955 2.795887 6.418854 2.41222 6.85499 -0.172037 2.129416 1.922823 6.418854 2.41222 6.85499 -0.172037 2.129416 1.922823 6.418854 2.41222 6.85499 -0.172037 2.129416 1.922823 6.418854 2.41222 6.85499 -0.172037 2.129416 1.922823 0 1.541648 7.874016 1.541648 0 -1.541648 0 1.541648 7.874016 1.541648 0 -1.541648 6.650924 1.669042 6.791303 -0.947997 2.333658 1.669042 6.650924 1.669042 6.791303 -0.947997 2.333658 1.669042</float_array>
+          <technique_common>
+            <accessor source="#ID7-mesh-map-0-array" count="852" stride="2">
+              <param name="S" type="float"/>
+              <param name="T" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <vertices id="ID7-mesh-vertices">
+          <input semantic="POSITION" source="#ID7-mesh-positions"/>
+        </vertices>
+        <triangles material="InteractiveRed-material" count="284">
+          <input semantic="VERTEX" source="#ID7-mesh-vertices" offset="0"/>
+          <input semantic="NORMAL" source="#ID7-mesh-normals" offset="1"/>
+          <input semantic="TEXCOORD" source="#ID7-mesh-map-0" offset="2" set="0"/>
+          <p>0 0 0 1 0 1 2 0 2 3 0 3 2 0 4 1 0 5 4 1 6 5 1 7 6 1 8 7 1 9 6 1 10 5 1 11 8 2 12 9 2 13 10 2 14 11 2 15 10 2 16 9 2 17 12 3 18 13 3 19 14 3 20 15 3 21 14 3 22 13 3 23 16 4 24 17 4 25 18 4 26 19 4 27 18 4 28 17 4 29 20 5 30 21 5 31 22 5 32 23 5 33 22 5 34 21 5 35 24 6 36 25 6 37 26 6 38 27 6 39 26 6 40 25 6 41 28 7 42 29 7 43 30 7 44 31 7 45 30 7 46 29 7 47 32 8 48 33 8 49 34 8 50 35 8 51 34 8 52 33 8 53 36 9 54 37 9 55 38 9 56 39 9 57 38 9 58 37 9 59 40 10 60 41 10 61 42 10 62 43 10 63 42 10 64 41 10 65 44 11 66 45 11 67 46 11 68 47 11 69 46 11 70 45 11 71 48 12 72 49 12 73 50 12 74 51 12 75 50 12 76 49 12 77 52 13 78 53 13 79 54 13 80 55 13 81 54 13 82 53 13 83 56 14 84 57 14 85 58 14 86 59 14 87 58 14 88 57 14 89 60 15 90 61 15 91 62 15 92 63 15 93 62 15 94 61 15 95 64 16 96 65 16 97 66 16 98 67 16 99 66 16 100 65 16 101 68 17 102 69 17 103 70 17 104 71 17 105 70 17 106 69 17 107 72 18 108 73 18 109 74 18 110 75 18 111 74 18 112 73 18 113 76 19 114 77 19 115 78 19 116 79 19 117 78 19 118 77 19 119 80 20 120 81 20 121 82 20 122 83 20 123 82 20 124 81 20 125 84 21 126 85 22 127 86 22 128 87 22 129 86 22 130 85 22 131 88 23 132 89 23 133 90 23 134 91 23 135 90 23 136 89 23 137 92 24 138 93 24 139 94 24 140 95 24 141 94 24 142 93 24 143 96 25 144 97 25 145 98 25 146 99 25 147 98 25 148 97 25 149 100 26 150 101 26 151 102 26 152 103 26 153 102 26 154 101 26 155 104 27 156 105 27 157 106 27 158 107 27 159 106 27 160 105 27 161 108 28 162 109 28 163 110 28 164 111 28 165 110 28 166 109 28 167 112 29 168 113 29 169 114 29 170 115 29 171 114 29 172 113 29 173 116 30 174 114 30 175 115 30 176 117 31 177 116 31 178 115 31 179 118 32 180 117 32 181 115 32 182 119 33 183 117 33 184 118 33 185 120 34 186 119 34 187 118 34 188 121 35 189 119 35 190 120 35 191 122 36 192 121 36 193 120 36 194 123 37 195 121 37 196 122 37 197 124 38 198 123 38 199 122 38 200 125 39 201 123 39 202 124 39 203 126 29 204 125 29 205 124 29 206 127 40 207 125 40 208 126 40 209 128 41 210 127 41 211 126 41 212 129 42 213 127 42 214 128 42 215 130 43 216 129 43 217 128 43 218 131 44 219 129 44 220 130 44 221 132 45 222 131 45 223 130 45 224 133 46 225 131 46 226 132 46 227 134 29 228 133 29 229 132 29 230 135 29 231 133 29 232 134 29 233 136 47 234 137 47 235 138 47 236 139 47 237 138 47 238 137 47 239 140 48 240 141 48 241 142 48 242 143 48 243 142 48 244 141 48 245 144 49 246 145 49 247 146 49 248 147 49 249 146 49 250 145 49 251 148 50 252 149 50 253 150 50 254 151 50 255 150 50 256 149 50 257 152 51 258 153 51 259 154 51 260 155 51 261 154 51 262 153 51 263 156 52 264 157 52 265 158 52 266 159 52 267 158 52 268 157 52 269 160 53 270 161 53 271 162 53 272 163 53 273 162 53 274 161 53 275 164 54 276 165 54 277 166 54 278 167 54 279 166 54 280 165 54 281 168 55 282 169 55 283 170 55 284 171 55 285 170 55 286 169 55 287 172 56 288 173 56 289 174 56 290 175 56 291 174 56 292 173 56 293 176 57 294 177 57 295 178 57 296 179 57 297 178 57 298 177 57 299 180 58 300 181 58 301 182 58 302 183 58 303 182 58 304 181 58 305 184 59 306 185 60 307 186 60 308 187 60 309 186 60 310 185 60 311 188 61 312 189 61 313 190 61 314 191 61 315 190 61 316 189 61 317 192 62 318 193 62 319 194 62 320 195 62 321 194 62 322 193 62 323 196 63 324 197 63 325 198 63 326 199 63 327 198 63 328 197 63 329 200 64 330 201 64 331 202 64 332 203 64 333 202 64 334 201 64 335 204 65 336 205 65 337 206 65 338 207 65 339 206 65 340 205 65 341 208 66 342 209 66 343 210 66 344 211 67 345 210 67 346 209 67 347 212 68 348 211 68 349 209 68 350 213 69 351 211 69 352 212 69 353 214 70 354 213 70 355 212 70 356 215 71 357 213 71 358 214 71 359 216 72 360 213 72 361 215 72 362 217 68 363 216 68 364 215 68 365 218 73 366 216 73 367 217 73 368 219 74 369 216 74 370 218 74 371 220 68 372 216 68 373 219 68 374 221 75 375 220 75 376 219 75 377 222 76 378 220 76 379 221 76 380 223 77 381 222 77 382 221 77 383 224 78 384 222 78 385 223 78 386 225 68 387 224 68 388 223 68 389 226 79 390 224 79 391 225 79 392 227 68 393 224 68 394 226 68 395 228 68 396 227 68 397 226 68 398 229 80 399 227 80 400 228 80 401 230 68 402 229 68 403 228 68 404 231 68 405 229 68 406 230 68 407 232 81 408 229 81 409 231 81 410 233 82 411 229 82 412 232 82 413 233 83 414 232 83 415 234 83 416 234 84 417 232 84 418 235 84 419 232 85 420 236 85 421 235 85 422 236 68 423 237 68 424 235 68 425 237 86 426 238 86 427 235 86 428 235 87 429 238 87 430 239 87 431 238 88 432 240 88 433 239 88 434 239 68 435 240 68 436 241 68 437 240 68 438 242 68 439 241 68 440 241 68 441 242 68 442 243 68 443 242 89 444 244 89 445 243 89 446 244 90 447 245 90 448 243 90 449 243 91 450 245 91 451 246 91 452 245 75 453 247 75 454 246 75 455 246 68 456 247 68 457 248 68 458 247 92 459 249 92 460 248 92 461 249 93 462 250 93 463 248 93 464 250 68 465 251 68 466 248 68 467 248 94 468 251 94 469 252 94 470 251 95 471 214 95 472 252 95 473 212 96 474 252 96 475 214 96 476 253 97 477 233 97 478 234 97 479 254 98 480 253 98 481 234 98 482 255 99 483 253 99 484 254 99 485 256 100 486 257 100 487 258 100 488 259 100 489 258 100 490 257 100 491 260 101 492 261 101 493 262 101 494 263 101 495 262 101 496 261 101 497 264 102 498 265 102 499 266 102 500 267 102 501 268 102 502 269 102 503 270 103 504 271 103 505 272 103 506 273 104 507 274 104 508 275 104 509 276 105 510 277 105 511 278 105 512 279 106 513 280 106 514 281 106 515 282 107 516 283 107 517 284 107 518 285 107 519 286 107 520 287 107 521 288 108 522 289 108 523 290 108 524 291 108 525 292 108 526 293 108 527 294 109 528 295 109 529 296 109 530 297 110 531 298 110 532 299 110 533 300 111 534 301 111 535 302 111 536 303 111 537 304 111 538 305 111 539 306 112 540 307 112 541 308 112 542 309 112 543 310 112 544 311 112 545 312 113 546 313 113 547 314 113 548 315 114 549 316 114 550 317 114 551 318 115 552 319 115 553 320 115 554 321 116 555 322 116 556 323 116 557 324 117 558 325 117 559 326 117 560 327 118 561 328 118 562 329 118 563 330 119 564 331 119 565 332 119 566 333 119 567 334 119 568 335 119 569 336 120 570 337 120 571 338 120 572 339 120 573 340 120 574 341 120 575 342 121 576 343 121 577 344 121 578 345 121 579 346 121 580 347 121 581 348 122 582 349 122 583 350 122 584 351 123 585 352 123 586 353 123 587 354 124 588 355 124 589 356 124 590 357 125 591 358 125 592 359 125 593 360 126 594 361 126 595 362 126 596 363 127 597 364 127 598 365 127 599 366 68 600 367 68 601 368 68 602 369 128 603 370 128 604 371 128 605 372 129 606 373 129 607 374 129 608 375 130 609 376 130 610 377 130 611 378 68 612 379 68 613 380 68 614 381 131 615 382 131 616 383 131 617 384 132 618 385 132 619 386 132 620 387 133 621 388 133 622 389 133 623 390 68 624 391 68 625 392 68 626 393 134 627 394 134 628 395 134 629 396 68 630 397 68 631 398 68 632 399 135 633 400 135 634 401 135 635 402 136 636 403 136 637 404 136 638 405 137 639 406 137 640 407 137 641 408 68 642 409 68 643 410 68 644 411 138 645 412 138 646 413 138 647 414 139 648 415 139 649 416 139 650 417 139 651 418 139 652 419 139 653 420 140 654 421 140 655 422 140 656 423 140 657 424 140 658 425 140 659 426 141 660 427 141 661 428 141 662 429 141 663 430 141 664 431 141 665 432 142 666 433 142 667 434 142 668 435 143 669 436 143 670 437 143 671 438 68 672 439 68 673 440 68 674 441 144 675 442 144 676 443 144 677 444 68 678 445 68 679 446 68 680 447 145 681 448 145 682 449 145 683 450 146 684 451 146 685 449 146 686 452 68 687 453 68 688 454 68 689 455 147 690 456 147 691 457 147 692 458 68 693 459 68 694 460 68 695 461 68 696 462 68 697 463 68 698 464 148 699 465 148 700 466 148 701 467 68 702 468 68 703 469 68 704 470 68 705 471 68 706 472 68 707 473 149 708 474 149 709 475 149 710 476 150 711 477 150 712 478 150 713 479 151 714 480 151 715 481 151 716 482 68 717 483 68 718 484 68 719 485 152 720 486 152 721 487 152 722 488 68 723 489 68 724 490 68 725 491 68 726 492 68 727 493 68 728 494 153 729 495 153 730 496 153 731 497 68 732 498 68 733 499 68 734 500 68 735 501 68 736 502 68 737 503 68 738 504 68 739 505 68 740 506 68 741 507 68 742 508 68 743 506 154 744 509 154 745 510 154 746 511 155 747 512 155 748 513 155 749 514 156 750 515 156 751 516 156 752 517 157 753 518 157 754 519 157 755 520 68 756 521 68 757 522 68 758 523 158 759 524 158 760 525 158 761 526 68 762 527 68 763 528 68 764 529 68 765 530 68 766 531 68 767 532 68 768 533 68 769 531 68 770 534 159 771 535 159 772 536 159 773 537 68 774 538 68 775 539 68 776 540 160 777 541 160 778 542 160 779 543 161 780 544 161 781 545 161 782 546 150 783 547 150 784 548 150 785 549 162 786 550 162 787 551 162 788 552 163 789 553 163 790 554 163 791 555 68 792 556 68 793 557 68 794 558 164 795 559 164 796 560 164 797 561 68 798 562 68 799 563 68 800 564 165 801 565 165 802 566 165 803 567 68 804 568 68 805 569 68 806 570 68 807 571 68 808 572 68 809 573 166 810 574 166 811 575 166 812 576 166 813 577 166 814 578 166 815 579 167 816 580 167 817 581 167 818 582 167 819 583 167 820 584 167 821 585 168 822 586 168 823 587 168 824 588 169 825 589 169 826 590 169 827 591 170 828 592 170 829 593 170 830 594 170 831 595 170 832 596 170 833 597 171 834 598 171 835 599 171 836 600 171 837 601 171 838 602 171 839 603 172 840 604 172 841 605 172 842 606 172 843 607 172 844 608 172 845 609 173 846 610 173 847 611 173 848 612 174 849 613 174 850 614 174 851</p>
+        </triangles>
+      </mesh>
+    </geometry>
+    <geometry id="collision-1-mesh" name="collision-1">
+      <mesh>
+        <source id="collision-1-mesh-positions">
+          <float_array id="collision-1-mesh-positions-array" count="24">0.5763563 -0.2305425 -0.5763563 0.5763563 0.2305426 -0.5763563 -0.5763563 -0.2305425 -0.5763563 -0.5763563 0.2305426 -0.5763563 0.5763563 -0.2305426 0.5763563 0.5763563 0.2305425 0.5763563 -0.5763563 -0.2305426 0.5763563 -0.5763563 0.2305425 0.5763563</float_array>
+          <technique_common>
+            <accessor source="#collision-1-mesh-positions-array" count="8" stride="3">
+              <param name="X" type="float"/>
+              <param name="Y" type="float"/>
+              <param name="Z" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="collision-1-mesh-normals">
+          <float_array id="collision-1-mesh-normals-array" count="24">0 0 -1 0 0 1 1 0 0 0 1 0 0 1 1.34573e-7 -1 0 0 0 -1 -1.34573e-7 0 -1 0</float_array>
+          <technique_common>
+            <accessor source="#collision-1-mesh-normals-array" count="8" stride="3">
+              <param name="X" type="float"/>
+              <param name="Y" type="float"/>
+              <param name="Z" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <vertices id="collision-1-mesh-vertices">
+          <input semantic="POSITION" source="#collision-1-mesh-positions"/>
+        </vertices>
+        <triangles count="12">
+          <input semantic="VERTEX" source="#collision-1-mesh-vertices" offset="0"/>
+          <input semantic="NORMAL" source="#collision-1-mesh-normals" offset="1"/>
+          <p>3 0 1 0 0 0 0 0 2 0 3 0 7 1 6 1 4 1 4 1 5 1 7 1 5 2 4 2 0 2 0 2 1 2 5 2 7 3 5 3 1 3 1 4 3 4 7 4 6 5 7 5 3 5 3 5 2 5 6 5 4 6 6 6 2 6 2 7 0 7 4 7</p>
+        </triangles>
+      </mesh>
+    </geometry>
+  </library_geometries>
+  <library_visual_scenes>
+    <visual_scene id="Scene" name="Scene">
+      <node id="wheelDefault" name="wheelDefault" type="NODE">
+        <matrix sid="transform">1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1</matrix>
+        <instance_geometry url="#ID7-mesh" name="wheelDefault">
+          <bind_material>
+            <technique_common>
+              <instance_material symbol="InteractiveRed-material" target="#InteractiveRed-material">
+                <bind_vertex_input semantic="ID12" input_semantic="TEXCOORD" input_set="0"/>
+              </instance_material>
+            </technique_common>
+          </bind_material>
+        </instance_geometry>
+      </node>
+      <node id="nulldetail1" name="nulldetail1" type="NODE">
+        <matrix sid="transform">1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1</matrix>
+      </node>
+      <node id="collision-1" name="collision-1" type="NODE">
+        <matrix sid="transform">1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1</matrix>
+        <instance_geometry url="#collision-1-mesh" name="collision-1"/>
+      </node>
+    </visual_scene>
+  </library_visual_scenes>
+  <scene>
+    <instance_visual_scene url="#Scene"/>
+  </scene>
+</COLLADA>
\ No newline at end of file
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/carwheel.tscript b/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/carwheel.tscript
new file mode 100644
index 000000000..cd0ab9d0c
--- /dev/null
+++ b/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/carwheel.tscript
@@ -0,0 +1,11 @@
+
+singleton TSShapeConstructor(carwheeldae)
+{
+   baseShapeAsset = "./carwheel.dae";
+   singleDetailSize = "0";
+   flipUVCoords = "0";
+   JoinIdenticalVerts = "0";
+   reverseWindingOrder = "0";
+   removeRedundantMats = "0";
+   animFPS = "2";
+};
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/flier.asset.taml b/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/flier.asset.taml
new file mode 100644
index 000000000..8e4d115cb
--- /dev/null
+++ b/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/flier.asset.taml
@@ -0,0 +1 @@
+<ShapeAsset canSave="true" canSaveDynamicFields="true" AssetName="flier" fileName="@assetFile=flier.dae" constuctorFileName="@assetFile=flier.tscript"/>
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/flier.dae b/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/flier.dae
new file mode 100644
index 000000000..ea6deafb1
--- /dev/null
+++ b/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/flier.dae
@@ -0,0 +1,253 @@
+<?xml version="1.0" encoding="utf-8"?>
+<COLLADA xmlns="http://www.collada.org/2005/11/COLLADASchema" version="1.4.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <asset>
+    <contributor>
+      <author>Blender User</author>
+      <authoring_tool>Blender 2.90.0 commit date:2020-08-31, commit time:11:26, hash:0330d1af29c0</authoring_tool>
+    </contributor>
+    <created>2021-09-11T14:15:31</created>
+    <modified>2021-09-11T14:15:31</modified>
+    <unit name="meter" meter="1"/>
+    <up_axis>Z_UP</up_axis>
+  </asset>
+  <library_lights>
+    <light id="EnvironmentAmbientLight-light" name="EnvironmentAmbientLight">
+      <technique_common>
+        <directional>
+          <color sid="color">0 0 0</color>
+        </directional>
+      </technique_common>
+      <extra>
+        <technique profile="blender">
+          <type sid="type" type="int">1</type>
+          <flag sid="flag" type="int">0</flag>
+          <mode sid="mode" type="int">1</mode>
+          <gamma sid="blender_gamma" type="float">1</gamma>
+          <red sid="red" type="float">0</red>
+          <green sid="green" type="float">0</green>
+          <blue sid="blue" type="float">0</blue>
+          <shadow_r sid="blender_shadow_r" type="float">0</shadow_r>
+          <shadow_g sid="blender_shadow_g" type="float">0</shadow_g>
+          <shadow_b sid="blender_shadow_b" type="float">0</shadow_b>
+          <energy sid="blender_energy" type="float">1</energy>
+          <dist sid="blender_dist" type="float">25</dist>
+          <spotsize sid="spotsize" type="float">45</spotsize>
+          <spotblend sid="spotblend" type="float">0.15</spotblend>
+          <att1 sid="att1" type="float">0</att1>
+          <att2 sid="att2" type="float">1</att2>
+          <falloff_type sid="falloff_type" type="int">2</falloff_type>
+          <clipsta sid="clipsta" type="float">0.04999995</clipsta>
+          <clipend sid="clipend" type="float">40</clipend>
+          <bias sid="bias" type="float">1</bias>
+          <soft sid="soft" type="float">3</soft>
+          <bufsize sid="bufsize" type="int">512</bufsize>
+          <samp sid="samp" type="int">3</samp>
+          <buffers sid="buffers" type="int">1</buffers>
+          <area_shape sid="area_shape" type="int">0</area_shape>
+          <area_size sid="area_size" type="float">0.25</area_size>
+          <area_sizey sid="area_sizey" type="float">0.25</area_sizey>
+          <area_sizez sid="area_sizez" type="float">0.25</area_sizez>
+        </technique>
+      </extra>
+    </light>
+  </library_lights>
+  <library_effects>
+    <effect id="InteractiveRed-effect">
+      <profile_COMMON>
+        <technique sid="common">
+          <lambert>
+            <emission>
+              <color sid="emission">0 0 0 1</color>
+            </emission>
+            <diffuse>
+              <color sid="diffuse">0.8 0.8 0.8 1</color>
+            </diffuse>
+            <index_of_refraction>
+              <float sid="ior">1.45</float>
+            </index_of_refraction>
+          </lambert>
+        </technique>
+      </profile_COMMON>
+    </effect>
+  </library_effects>
+  <library_images/>
+  <library_materials>
+    <material id="InteractiveRed-material" name="InteractiveRed">
+      <instance_effect url="#InteractiveRed-effect"/>
+    </material>
+  </library_materials>
+  <library_geometries>
+    <geometry id="ID11-mesh" name="ID11">
+      <mesh>
+        <source id="ID11-mesh-positions">
+          <float_array id="ID11-mesh-positions-array" count="1524">2.8 -0.4256695 0.3000001 1.6 -0.02566969 0.4 2.8 -0.4256695 0.5000001 1.6 -0.02566957 0.8 2.8 -1.02567 0.3000002 2.8 -1.02567 0.5000002 1.6 -1.02567 0.4000002 1.6 -1.02567 0.8000002 2.8 -1.02567 0.5000002 2.8 -0.4256695 0.5000001 1.6 -1.02567 0.8000002 1.6 -0.02566957 0.8 2.8 -0.4256695 0.3000001 2.8 -1.02567 0.3000002 1.6 -0.02566969 0.4 1.6 -1.02567 0.4000002 2.8 -1.02567 0.5000002 2.8 -1.02567 0.3000002 2.8 -0.4256695 0.5000001 2.8 -0.4256695 0.3000001 0.4000003 -2.22567 0.4000003 0.5000004 -2.22567 0.5280784 0.4000003 -2.22567 1.2 0.5000004 -2.22567 1.071922 1.2 -2.22567 0.6000004 1.1 -2.22567 0.6780784 1.2 -2.22567 1 1.1 -2.22567 0.9219223 0.8000001 -0.2256697 0.8000001 0.4 -0.2256698 0.8000001 0.8000001 -0.2256697 0.9 0.4 -0.2256698 1 0.6000001 -0.2256697 1 0.8000001 -0.4256697 0.9 0.8000001 -0.2256697 0.9 0.6000001 -0.4256697 1 0.6000001 -0.2256697 1 0.6000001 -0.4256697 1 0.6000001 -0.2256697 1 0.4 -0.4256698 1 0.4 -0.2256698 1 0.8000001 -0.4256697 0.9 0.8000001 -0.4256697 0.8000001 0.8000001 -0.2256697 0.9 0.8000001 -0.2256697 0.8000001 0.4 -0.4256698 0.8000001 0.8000001 -0.4256697 0.8000001 0.4 -0.4256698 1 0.8000001 -0.4256697 0.9 0.6000001 -0.4256697 1 -0.3999997 -2.22567 0.4000003 -0.4999997 -2.22567 0.5280784 -1.2 -2.22567 0.6000004 -1.1 -2.22567 0.6780784 -1.2 -2.22567 1 -1.1 -2.22567 0.9219223 -0.4999997 -2.22567 1.071922 -0.3999997 -2.22567 1.2 -1.6 -0.02567017 0.4 -1.6 -1.02567 0.4000002 -2.8 -0.4256704 0.3000001 -2.8 -1.02567 0.3000002 -2.8 -0.4256704 0.3000001 -2.8 -0.4256703 0.5000001 -1.6 -0.02567017 0.4 -1.6 -0.02567011 0.8 -1.6 -1.02567 0.8000002 -1.6 -0.02567011 0.8 -2.8 -1.02567 0.5000002 -2.8 -0.4256703 0.5000001 -2.8 -1.02567 0.3000002 -2.8 -1.02567 0.5000002 -2.8 -0.4256704 0.3000001 -2.8 -0.4256703 0.5000001 -2.8 -1.02567 0.3000002 -1.6 -1.02567 0.4000002 -2.8 -1.02567 0.5000002 -1.6 -1.02567 0.8000002 -0.3999999 -0.3216579 1 -0.4 -0.2256699 1 -0.3999999 -0.4256699 1 -0.6 -0.2256699 1 -0.6 -0.4256699 1 -0.8 -0.42567 0.8000001 -0.8 -0.42567 0.9 -0.8 -0.2256699 0.8000001 -0.8 -0.2256699 0.9 -0.4 -0.2256699 0.8000001 -0.8 -0.2256699 0.8000001 -0.4 -0.2256699 1 -0.8 -0.2256699 0.9 -0.6 -0.2256699 1 -0.8 -0.42567 0.8000001 -0.3999999 -0.4256699 0.8000001 -0.8 -0.42567 0.9 -0.3999999 -0.4256699 1 -0.6 -0.4256699 1 -0.6 -0.2256699 1 -0.8 -0.2256699 0.9 -0.6 -0.4256699 1 -0.8 -0.42567 0.9 1.2 -1.02567 0.4000002 1.2 -1.02567 0.6000002 1.2 -1.02567 0.8000002 1.2 0.1076622 0.4 1.2 0.1076623 0.6 0.3999999 0.3743301 0.6 0.3999999 0.3743302 0.8 1.6 -0.02566969 0.4 1.6 -1.02567 0.4000002 1.2 0.1076622 0.4 1.2 -1.02567 0.4000002 1.2 -2.22567 1 1.2 -2.22567 0.6000004 1.2 -1.82567 1 1.2 -1.02567 0.6000002 1.2 -1.02567 1 1.2 -1.02567 0.8000002 1.2 -1.02567 0.6000002 1.2 -2.22567 0.6000004 0.4000002 -1.02567 0.4000002 0.4000003 -1.82567 0.4000003 0.4000002 -1.42567 0.4000002 0.4000003 -2.22567 0.4000003 1.2 -1.02567 0.8000002 0.4000002 -1.02567 0.8000002 1.2 -1.02567 1 0.4000002 -1.02567 1.2 0.8119422 -1.02567 1.097014 1.2 -1.02567 1 0.4000002 -1.02567 1.2 1.2 -2.22567 1 1.2 -1.82567 1 0.4000003 -2.22567 1.2 0.8119423 -1.82567 1.097014 0.8119422 -1.02567 1.097014 0.4000002 -1.02567 1.2 0.4000003 -1.82567 1.2 0.4000003 -2.22567 0.4000003 0.4000003 -2.22567 1.2 0.4000003 -1.82567 0.4000003 0.4000003 -1.82567 1.2 0.3999999 0.9743301 -1.58739e-7 -0.4000002 0.97433 -1.58739e-7 0.3999999 0.9743301 0.3999999 -0.4000002 0.97433 0.3999999 0.4000002 -1.42567 0.4000002 0.4000002 -1.42567 2.32271e-7 0.4000002 -1.02567 0.4000002 0.4000002 -1.02567 1.67103e-7 0.3999999 0.9743301 -1.58739e-7 0.4000002 -1.02567 1.67103e-7 -0.4000002 0.97433 -1.58739e-7 -0.3999999 -1.02567 1.67103e-7 -0.3999998 -1.42567 2.32271e-7 0.4000002 -1.42567 2.32271e-7 -0.3999998 -1.42567 2.32271e-7 0.4000002 -1.42567 2.32271e-7 -0.3999998 -1.42567 0.4000002 0.4000002 -1.42567 0.4000002 1.2 -1.02567 0.8000002 0.8000001 -0.4256697 0.8000001 0.4000002 -1.02567 0.8000002 0.4 -0.4256698 0.8000001 0.8000001 -0.2256697 0.8000001 1.6 -0.02566957 0.8 1.6 -1.02567 0.8000002 0.3999999 0.3743302 0.8 0.4 -0.2256698 0.8000001 0.0999999 0.3743303 1.7 -0.1 0.3743302 1.7 0.09999996 0.1743303 1.8 -0.1 0.1743302 1.8 0.0999999 0.3743302 1.6 0.0130859 0.3743302 1.6 0.0999999 0.3743303 1.7 -0.1 0.3743302 1.6 -0.1 0.3743302 1.7 -0.0999999 -0.4256697 1.8 -0.1 0.1743302 1.8 -0.0999999 -0.4256697 1.6 -0.1 0.3743302 1.6 -0.1 0.3743302 1.7 4.40643e-5 -0.4256697 1.6 0.1 -0.4256697 1.6 -0.0999999 -0.4256697 1.6 0.1 -0.4256697 1.8 -0.0999999 -0.4256697 1.8 0.09999996 0.1743303 1.8 -0.1 0.1743302 1.8 0.1 -0.4256697 1.8 -0.0999999 -0.4256697 1.8 0.1 -0.4256697 1.8 0.1 -0.4256697 1.6 0.09999996 0.1743303 1.8 0.0999999 0.3743302 1.6 0.0999999 0.3743303 1.7 -0.3999999 -1.02567 0.4000002 -0.3999998 -1.42567 0.4000002 -1.2 -1.02567 0.6000002 -0.3999997 -1.82567 0.4000003 -1.2 -2.22567 0.6000004 -0.3999997 -2.22567 0.4000003 -0.3999997 -2.22567 1.2 -0.3999997 -2.22567 0.4000003 -0.3999997 -1.82567 1.2 -0.3999997 -1.82567 0.4000003 -1.2 -2.22567 0.6000004 -1.2 -2.22567 1 -1.2 -1.02567 0.6000002 -1.2 -1.82567 1 -1.2 -1.02567 0.8000002 -1.2 -1.02567 1 -0.3999998 -1.42567 2.32271e-7 -0.3999998 -1.42567 0.4000002 -0.3999999 -1.02567 1.67103e-7 -0.3999999 -1.02567 0.4000002 -0.3999999 -1.02567 0.8000002 -1.2 -1.02567 0.8000002 -0.3999999 -1.02567 1.2 -1.2 -1.02567 1 -0.8119418 -1.02567 1.097014 -0.3999999 -1.02567 1.2 -1.2 -1.02567 1 -0.3999999 -1.02567 0.8000002 -0.3999999 -0.4256699 0.8000001 -1.2 -1.02567 0.8000002 -0.8 -0.42567 0.8000001 -1.6 -0.02567011 0.8 -0.8 -0.2256699 0.8000001 -0.4 0.3743301 0.8 -0.4 -0.2256699 0.8000001 -1.6 -1.02567 0.8000002 -1.2 0.1076619 0.4 -1.2 -1.02567 0.4000002 -1.6 -0.02567017 0.4 -1.6 -1.02567 0.4000002 -1.2 -1.02567 0.4000002 -1.2 -1.02567 0.6000002 -1.2 -1.02567 0.8000002 -0.4 0.37433 0.6 -1.2 0.1076619 0.6 -0.4 0.3743301 0.8 -1.2 0.1076619 0.4 0.3999998 1.17433 0.3999998 0.3999999 0.9743301 0.3999999 -0.4000002 1.17433 0.3999998 -0.4000002 0.97433 0.3999999 0.3999997 1.668394 0.4784297 0.3999998 1.17433 0.3999998 -0.4000002 1.668394 0.4784297 -0.4000002 1.17433 0.3999998 0.4 -0.2256698 1 0.4 -0.2256698 0.8000001 0.3999999 0.7733362 0.9999999 0.3999999 0.3743302 0.8 0.3999999 0.3743301 0.6 0.3999999 0.9743302 0.5999999 0.3999997 1.668394 0.4784297 0.3999999 0.9743301 0.3999999 0.3999998 1.17433 0.3999998 -0.4000002 0.97433 0.3999999 -0.4000002 0.9743301 0.5999999 -0.4000002 1.17433 0.3999998 -0.4000002 1.668394 0.4784297 -0.4000001 0.7733361 0.9999999 -0.4 0.37433 0.6 -0.4 0.3743301 0.8 -0.4 -0.2256699 1 -0.4 -0.2256699 0.8000001 -0.3999997 -2.22567 1.2 -0.3999997 -1.82567 1.2 -1.2 -2.22567 1 -0.8119417 -1.82567 1.097014 -0.3999999 -1.02567 1.2 -1.2 -1.82567 1 -0.8119418 -1.02567 1.097014 1.1 -2.22567 0.6780784 1.1 -2.02567 0.6780784 0.5000004 -2.22567 0.5280784 0.5000003 -2.02567 0.5280784 1.1 -2.02567 0.9219223 1.1 -2.22567 0.9219223 0.5000003 -2.02567 1.071922 0.5000004 -2.22567 1.071922 0.5000003 -2.02567 0.5280784 1.1 -2.02567 0.6780784 0.5000003 -2.02567 1.071922 1.1 -2.02567 0.9219223 1.1 -2.22567 0.6780784 1.1 -2.22567 0.9219223 1.1 -2.02567 0.6780784 1.1 -2.02567 0.9219223 0.5000004 -2.22567 1.071922 0.5000004 -2.22567 0.5280784 0.5000003 -2.02567 1.071922 0.5000003 -2.02567 0.5280784 0.541422 0.3157501 0.1999999 1.058578 0.3157502 0.1999999 0.5414219 0.8329081 0.1999998 0.5414219 0.8329081 0.3999999 1.058578 0.3157503 0.3999999 0.541422 0.3157501 0.3999999 1.058578 0.3157502 0.1999999 0.541422 0.3157501 0.1999999 1.058578 0.3157503 0.3999999 0.541422 0.3157501 0.3999999 0.541422 0.3157501 0.3999999 0.541422 0.3157501 0.1999999 0.5414219 0.8329081 0.3999999 0.5414219 0.8329081 0.1999998 -0.4999997 -2.02567 0.5280784 -0.4999997 -2.02567 1.071922 -1.1 -2.02567 0.6780784 -1.1 -2.02567 0.9219223 -0.4999997 -2.02567 1.071922 -0.4999997 -2.22567 1.071922 -1.1 -2.02567 0.9219223 -1.1 -2.22567 0.9219223 -1.1 -2.22567 0.9219223 -1.1 -2.22567 0.6780784 -1.1 -2.02567 0.9219223 -1.1 -2.02567 0.6780784 -0.4999997 -2.22567 0.5280784 -0.4999997 -2.02567 0.5280784 -1.1 -2.22567 0.6780784 -1.1 -2.02567 0.6780784 -0.4999997 -2.22567 0.5280784 -0.4999997 -2.22567 1.071922 -0.4999997 -2.02567 0.5280784 -0.4999997 -2.02567 1.071922 -0.5414221 0.31575 0.1999999 -0.5414221 0.31575 0.3999999 -0.5414221 0.8329079 0.1999998 -0.5414221 0.832908 0.3999999 -0.5414221 0.31575 0.1999999 -1.058578 0.3157499 0.1999999 -0.5414221 0.31575 0.3999999 -1.058578 0.3157499 0.3999999 -0.5414221 0.832908 0.3999999 -0.5414221 0.31575 0.3999999 -1.058578 0.3157499 0.3999999 -0.5414221 0.31575 0.1999999 -0.5414221 0.8329079 0.1999998 -1.058578 0.3157499 0.1999999 0.1999998 1.42567 1.533792 0.3999999 0.7733363 1.5801 0.3999997 2.22567 0.7337917 -0.4000001 0.7733362 1.5801 -0.2000002 1.42567 1.533792 -0.4000003 2.22567 0.7337917 0.3999997 2.22567 0.7337917 -0.4000003 2.22567 0.7337917 0.1999998 1.42567 1.533792 -0.2000002 1.42567 1.533792 0.3999999 0.7733363 1.5801 0.1999998 1.42567 1.533792 -0.4000001 0.7733362 1.5801 -0.2000002 1.42567 1.533792 1.26583 -1.82567 1.263324 1.2 -1.82567 1 1.26583 -1.62567 1.263324 1.2 -1.02567 1 0.8777743 -1.82567 1.360338 0.8777742 -1.62567 1.360338 0.8119423 -1.82567 1.097014 0.8119422 -1.02567 1.097014 1.26583 -1.82567 1.263324 1.26583 -1.62567 1.263324 0.8777743 -1.82567 1.360338 0.8777742 -1.62567 1.360338 1.2 -1.82567 1 1.26583 -1.82567 1.263324 0.8119423 -1.82567 1.097014 0.8777743 -1.82567 1.360338 1.26583 -1.62567 1.263324 1.2 -1.02567 1 0.8777742 -1.62567 1.360338 0.8119422 -1.02567 1.097014 1.2 0.1743301 0 1.2 -1.02567 1.67103e-7 0.3999999 0.9743301 -1.58739e-7 1.058578 0.3157502 0.1999999 1.2 0.1743301 0 1.2 0.1743302 0.6 1.058578 0.3157503 0.3999999 0.5414219 0.8329081 0.3999999 0.3999999 0.9743301 0.3999999 0.3999999 0.9743302 0.5999999 0.5414219 0.8329081 0.1999998 1.2 0.1076623 0.6 1.2 0.1743302 0.6 0.3999999 0.3743301 0.6 0.3999999 0.9743302 0.5999999 0.4000002 -1.02567 1.67103e-7 1.2 -1.02567 1.67103e-7 0.4000002 -1.02567 0.4000002 1.2 0.1076623 0.6 1.2 0.1076622 0.4 1.2 0.1743302 0.6 1.2 0.1743301 0 1.2 -1.02567 1.67103e-7 1.2 -1.02567 0.4000002 0.4000003 -1.82567 1.4 0.4 -0.4256697 1.6 -0.3999997 -1.82567 1.4 0.1 -0.4256697 1.6 4.40643e-5 -0.4256697 1.6 -0.0999999 -0.4256697 1.6 -0.3999999 -0.4256698 1.6 -0.3999997 -1.82567 0.4000003 0.4000003 -1.82567 0.4000003 -0.3999997 -1.82567 1.2 0.4000003 -1.82567 1.2 -0.3999997 -1.82567 1.4 0.4000003 -1.82567 1.4 0.4000003 -1.82567 0.4000003 -0.3999997 -1.82567 0.4000003 0.4000002 -1.42567 0.4000002 -0.3999998 -1.42567 0.4000002 0.4 -0.4256697 1.6 0.3999999 0.3743303 1.6 0.1 -0.4256697 1.6 0.0999999 0.3743302 1.6 -0.1 0.3743302 1.6 -0.4 0.3743302 1.6 -0.0999999 -0.4256697 1.6 -0.3999999 -0.4256698 1.6 -1.2 -1.02567 1.67103e-7 -0.3999999 -1.02567 1.67103e-7 -0.3999999 -1.02567 0.4000002 -1.2 -1.02567 1.67103e-7 -1.2 0.1743298 0 -1.2 0.1743299 0.6 -1.058578 0.3157499 0.1999999 -1.2 0.1743298 0 -0.4000002 0.97433 -1.58739e-7 -0.5414221 0.8329079 0.1999998 -0.5414221 0.832908 0.3999999 -1.058578 0.3157499 0.3999999 -0.4000002 0.9743301 0.5999999 -0.4000002 0.97433 0.3999999 -1.2 -1.02567 0.4000002 -1.2 0.1076619 0.4 -1.2 -1.02567 1.67103e-7 -1.2 0.1743298 0 -1.2 0.1076619 0.6 -1.2 0.1743299 0.6 -0.4 0.37433 0.6 -0.4000002 0.9743301 0.5999999 -1.2 0.1076619 0.6 -1.2 0.1743299 0.6 0.3999999 0.3743303 1.6 0.3999999 0.7733363 1.5801 0.0999999 0.3743302 1.6 -0.4000001 0.7733362 1.5801 0.0130859 0.3743302 1.6 -0.1 0.3743302 1.6 -0.4 0.3743302 1.6 -0.3999999 -1.02567 0.8000002 -0.3999999 -1.02567 1.2 -0.3999999 -0.4256699 0.8000001 -0.3999999 -0.4256698 1.6 -0.3999997 -1.82567 1.4 -0.3999997 -1.82567 1.2 -0.3999999 -0.4256699 1 -0.3999999 -0.3216579 1 -0.4 0.3743302 1.6 -0.4000001 0.7733362 1.5801 -0.4000003 2.22567 0.7337917 -0.4000003 2.22567 0.5668957 0.3999997 2.22567 0.5668957 -0.4000003 2.22567 0.5668957 0.3999997 2.22567 0.7337917 -0.4000003 2.22567 0.7337917 0.4 -0.4256697 1.6 0.4 -0.4256698 1 0.3999999 0.3743303 1.6 0.3999999 0.7733363 1.5801 0.3999997 2.22567 0.7337917 0.3999997 2.22567 0.5668957 0.4 -0.4256698 0.8000001 0.4000002 -1.02567 0.8000002 0.4000002 -1.02567 1.2 0.4000003 -1.82567 1.2 0.4000003 -1.82567 1.4 0.3999997 2.22567 0.5668957 -0.4000003 2.22567 0.5668957 -0.8119418 -1.02567 1.097014 -1.2 -1.02567 1 -0.8777738 -1.62567 1.360338 -1.26583 -1.62567 1.263324 -0.8777737 -1.82567 1.360338 -0.8777738 -1.62567 1.360338 -1.26583 -1.82567 1.263324 -1.26583 -1.62567 1.263324 -1.2 -1.82567 1 -0.8119417 -1.82567 1.097014 -1.26583 -1.82567 1.263324 -0.8777737 -1.82567 1.360338 -0.8777737 -1.82567 1.360338 -0.8119417 -1.82567 1.097014 -0.8777738 -1.62567 1.360338 -0.8119418 -1.02567 1.097014 -1.26583 -1.82567 1.263324 -1.26583 -1.62567 1.263324 -1.2 -1.82567 1 -1.2 -1.02567 1</float_array>
+          <technique_common>
+            <accessor source="#ID11-mesh-positions-array" count="508" stride="3">
+              <param name="X" type="float"/>
+              <param name="Y" type="float"/>
+              <param name="Z" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="ID11-mesh-normals">
+          <float_array id="ID11-mesh-normals-array" count="795">0.3162278 0.9486834 -2.35608e-7 0.3162277 0.9486834 0 0 -1 0 0 -1 0 0.2425357 3.2125e-7 0.9701426 0.2425357 1.9275e-7 0.9701426 -0.08304548 -1.64997e-7 -0.9965459 -0.08304548 -2.22745e-7 -0.9965459 1 0 0 1 9.9341e-7 0 0 -1 0 0 -1 -3.85499e-6 0 -1 2.40937e-6 -1.49011e-7 1 0 -1.49012e-7 1 -3.72529e-7 -1.49011e-7 1 7.45058e-7 0.4472138 0 0.8944271 0.4472133 3.332e-7 0.8944274 0 5.96046e-7 1 0 5.96046e-7 1 1.49012e-7 -1 0 2.23518e-7 -1 7.45059e-7 2.98024e-7 -1 0 0 -1 -2.89124e-6 0 -1 -4.81873e-7 -2.07943e-7 -1 5.78247e-6 3.81703e-7 -1 3.72529e-7 2.38419e-6 -1 0 0.08304542 -1.48497e-7 -0.9965459 0.08304554 -1.64997e-7 -0.9965459 -0.316228 0.9486833 -2.35608e-7 -0.3162279 0.9486833 0 -0.2425356 1.9275e-7 0.9701426 -0.2425357 0 0.9701426 -1 0 0 -1 -9.93411e-7 0 1.98682e-7 -1 0 1.98682e-7 -1 0 0 2.29222e-6 1 0 5.96046e-7 1 -1.49012e-7 1 0 -1.49012e-7 1 -3.72529e-7 -1.49012e-7 1 0 1.49012e-7 -1 0 0 -1 0 1.49012e-7 -1 0 -0.4472134 3.332e-7 0.8944274 -0.4472137 0 0.8944273 2.98023e-7 -1 0 2.98023e-7 -1 0 0 -1 7.45059e-7 0.3162246 0.9486845 -1.54618e-7 0.3162252 0.9486842 -1.3253e-7 0.3162289 0.9486829 -9.43168e-6 0.3162275 0.9486835 0 0 -1.78814e-7 -1 1.31481e-7 -1.84073e-7 -1 1 7.45058e-7 0 1 -1.24176e-7 0 1 3.72529e-7 0 0.2425354 0 -0.9701426 0.2425357 -1.35527e-7 -0.9701425 0 0 1 0.2425355 0 -0.9701426 -1.49012e-7 1 0 -1.49012e-7 1 0 -0.02498906 -0.9659332 -0.2575822 0.242536 4.51758e-7 0.9701424 0.2425342 3.16649e-6 0.9701429 0.2425367 2.19331e-7 0.9701423 0.242537 2.19331e-7 0.9701423 -1 -3.72529e-7 0 -1.49012e-7 1 -3.72529e-7 1 1.86265e-7 0 0 -1.62921e-7 -1 0 -1.62921e-7 -1 0 -1.62921e-7 -1 0 -1.62921e-7 -1 2.98023e-7 -1 7.45058e-7 1.49012e-7 -1 0 1.24176e-7 1.98682e-7 1 4.96705e-7 1.98682e-7 1 -1.49012e-6 0 1 -1.65568e-7 1.65568e-7 1 0 1.78814e-7 1 0 2.12874e-7 1 0 1.98682e-7 1 0 0.4472138 0.8944272 0 0.4472137 0.8944272 0 1 -8.57236e-7 -2.63537e-7 1 6.58842e-7 -1.49012e-7 1 -7.45058e-7 -1 -1.55221e-7 0 -1 -1.62981e-7 0 1.49012e-7 -1 0 -1.98682e-6 1.98682e-7 1 1.98682e-6 1.98682e-7 1 1 1.55221e-7 0 1 1.86264e-7 0 -0.2425356 -1.80703e-7 -0.9701426 -0.2425354 0 -0.9701426 -0.2425356 -1.80703e-7 -0.9701426 -0.2425358 -1.80703e-7 -0.9701425 1 1.86265e-7 0 -1 -2.48353e-7 0 -1 0 -2.98023e-7 -1 -3.72529e-7 0 -1 -2.98023e-7 0 -1 -3.72529e-7 0 -1.49012e-7 1 0 -0.02424633 -0.9997061 0 0 1.98682e-7 1 -2.48353e-7 1.98682e-7 1 0 1.86264e-7 1 0 2.12874e-7 1 -2.48353e-7 1.98682e-7 1 -2.98023e-7 1.78814e-7 1 0 -1.84073e-7 -1 0 -1.78814e-7 -1 2.98023e-7 -1 7.45059e-7 -0.3162295 0.9486829 0 -0.3162277 0.9486834 -6.43505e-6 -0.3162251 0.9486843 -1.76706e-7 -0.316225 0.9486842 -1.76706e-7 0 -1.49012e-7 -1 0 -1.49012e-7 -1 0 0.1567812 -0.9876334 0 0.1567813 -0.9876334 1 1.4916e-7 0 1 1.24176e-7 0 1 0 0 1 2.48353e-7 0 1 0 0 1 1.61021e-7 0 1 0 -1.78716e-7 -1 3.72529e-7 0 -1 -2.60285e-7 0 -1 0 0 -1 -1.24176e-7 0 -1 -3.73457e-7 0 -1 0 0 -1 -2.48353e-7 0 -0.2425356 2.71055e-7 0.9701426 -0.2425373 2.9829e-6 0.9701421 -0.2425374 1.53531e-7 0.9701421 -0.2425342 2.79396e-7 0.9701429 -0.2425366 0 0.9701423 -0.242536 0 0.9701424 -0.2425349 -1.20468e-7 0.9701427 -0.2425349 0 -0.9701427 -0.2425358 -1.20469e-7 -0.9701426 1 1.09599e-6 0 0 1.72881e-7 1 1.56003e-7 -1.72881e-7 -1 0 1 -2.88137e-7 -1.72882e-7 1 0 1 2.88136e-7 0 0.2425358 1.20469e-7 -0.9701426 0.2425354 0 -0.9701427 0.2425354 1.20469e-7 0.9701427 0.242536 0 0.9701424 -1 -5.47994e-7 0 -1 -2.88136e-7 0 0 1 -2.88137e-7 0 1 0 1.78289e-7 -1.72881e-7 -1 0 1.72881e-7 1 0.8217637 0.2868959 0.4923366 -0.8217638 0.2868956 0.4923366 -2.63418e-7 0.7071068 0.7071068 0 0.7071069 0.7071067 0 0.07081001 0.9974899 0 0.07081001 0.9974899 0.9701434 0 -0.2425318 0.9701433 2.74496e-7 -0.2425324 -0.9701417 0 0.2425394 -0.9701417 -1.37248e-7 0.2425392 0.2425349 0 0.9701427 0.2425356 0 0.9701426 0.2209759 0.412167 0.8839051 0.2209749 0.4121683 0.8839047 0 -1.62921e-7 -1 0 -1.62921e-7 -1 0.7071067 0.707107 6.58544e-6 0.7071021 0.7071115 -1.24177e-7 0.7071024 0.7071112 -1.86265e-7 0.7071079 0.7071057 -9.21937e-6 0.7071061 0.7071076 0 0.7071067 0.707107 0 0.7071067 0.7071069 -3.72527e-7 0.7071081 0.7071055 -1.62994e-6 0.7071069 0.7071067 0 -2.79391e-7 0 1 0 1.98682e-7 1 1.49012e-7 -1 0 1 2.98017e-6 0 1 0 0 1 2.62962e-7 0 0 -0.1414213 0.9899495 -1.12392e-6 -0.1414213 0.9899496 0 -0.1414212 0.9899496 0 -0.1414212 0.9899496 0 -0.1414213 0.9899495 1.49012e-7 -1 3.72529e-7 1.49012e-7 -1 0 0 -1.49012e-7 -1 0 -1.49012e-7 -1 0 2.98023e-7 1 0 2.98023e-7 1 0 2.98023e-7 1 1.49012e-7 -1 7.45058e-7 1.49012e-7 -1 3.72529e-7 1.49012e-7 -1 0 0 -1.62921e-7 -1 0 -1.62921e-7 -1 -0.7071022 0.7071114 -1.24177e-7 -0.7071068 0.7071067 7.0135e-6 -0.7071083 0.7071053 -2.03743e-6 -0.7071069 0.7071067 0 -0.7071024 0.7071112 -1.86265e-7 -0.707107 0.7071067 -7.44155e-6 -0.7071084 0.7071052 2.03743e-6 -0.7071071 0.7071065 -2.48352e-7 -1 -1.31481e-7 0 -1 0 0 -1 8.94051e-6 0 -9.94649e-7 0.04981219 0.9987586 0 0.04981219 0.9987586 0 0.04981219 0.9987587 0 0.04981225 0.9987587 0 0.04981219 0.9987586 -1 -2.48353e-7 0 -1 -1.24176e-7 0 -1 -1.35465e-7 0 -1 -1.86265e-7 0 -1 -1.24176e-7 0 -1 -5.17468e-7 1.61469e-7 -1 -1.4916e-7 0 -1 -1.28756e-7 0 -1 0 0 -1 -1.41495e-7 0 -2.98023e-7 1 0 1 1.86265e-7 0 1 2.48353e-7 0 1 0 0 1 1.28756e-7 0 1 1.41495e-7 0 1 1.43495e-7 0 1 1.60215e-7 0 1 1.24176e-7 0 1 2.48353e-7 0 1 1.86265e-7 0 1 0 0 -1.32043e-7 0.1567836 -0.9876331 0 0.1567838 -0.9876329 -0.2209749 0.4121678 0.8839049 -0.2209764 0.4121677 0.8839045 -0.2425349 0 0.9701427 -0.2425356 0 0.9701426 0 -1 -1.09798e-6 1.82606e-7 -1 1.09798e-6 0.9701415 0 0.2425396 0.9701416 4.11743e-7 0.2425392 -0.9701434 0 -0.2425318 -0.9701434 -2.74496e-7 -0.2425321</float_array>
+          <technique_common>
+            <accessor source="#ID11-mesh-normals-array" count="265" stride="3">
+              <param name="X" type="float"/>
+              <param name="Y" type="float"/>
+              <param name="Z" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="ID11-mesh-map-0">
+          <float_array id="ID11-mesh-map-0-array" count="1932">54.93941 5.905512 30.03959 7.874016 54.93941 9.84252 30.03959 15.74803 54.93941 9.84252 30.03959 7.874016 -55.11811 5.905512 -55.11811 9.84252 -31.49606 7.874016 -31.49606 15.74803 -31.49606 7.874016 -55.11811 9.84252 20.19037 -51.08525 8.379343 -51.08525 20.19037 -26.73621 0.505327 -26.73621 20.19037 -26.73621 8.379343 -51.08525 -8.379343 -54.43729 -20.19037 -54.43729 -0.505327 -30.73337 -20.19037 -30.73337 -0.505327 -30.73337 -20.19037 -54.43729 20.19037 9.84252 20.19037 5.905512 8.379343 9.84252 8.379343 5.905512 8.379343 9.84252 20.19037 5.905512 -7.874016 7.874016 -9.84252 10.39523 -7.874016 23.62205 -9.84252 21.10083 -7.874016 23.62205 -9.84252 10.39523 -7.874016 7.874016 -23.62205 11.81102 -9.84252 10.39523 -21.65354 13.34799 -9.84252 10.39523 -23.62205 11.81102 -23.62205 19.68504 -21.65354 13.34799 -23.62205 11.81102 -7.874016 23.62205 -9.84252 21.10083 -23.62205 19.68504 -21.65354 18.14808 -21.65354 13.34799 -23.62205 19.68504 -9.84252 21.10083 -21.65354 18.14808 -23.62205 19.68504 15.74803 15.74803 7.874016 15.74803 15.74803 17.71654 7.874016 19.68504 15.74803 17.71654 7.874016 15.74803 11.81102 19.68504 15.74803 17.71654 7.874016 19.68504 8.379343 -6.162392 4.442334 -6.162392 8.379343 -1.760683 4.442334 -1.760683 8.379343 -1.760683 4.442334 -6.162392 -11.81102 -8.379343 -11.81102 -4.442334 -7.874016 -8.379343 -7.874016 -4.442334 -7.874016 -8.379343 -11.81102 -4.442334 8.379343 17.71654 8.379343 15.74803 4.442334 17.71654 4.442334 15.74803 4.442334 17.71654 8.379343 15.74803 -7.874016 15.74803 -15.74803 15.74803 -7.874016 19.68504 -15.74803 17.71654 -7.874016 19.68504 -15.74803 15.74803 -11.81102 19.68504 -7.874016 19.68504 -15.74803 17.71654 7.874016 7.874016 9.84252 10.39523 23.62205 11.81102 21.65354 13.34799 23.62205 11.81102 9.84252 10.39523 23.62205 19.68504 23.62205 11.81102 21.65354 13.34799 21.65354 18.14808 23.62205 19.68504 21.65354 13.34799 9.84252 21.10083 23.62205 19.68504 21.65354 18.14808 7.874016 23.62205 23.62205 19.68504 9.84252 21.10083 7.874016 7.874016 7.874016 23.62205 9.84252 10.39523 9.84252 21.10083 9.84252 10.39523 7.874016 23.62205 0.505327 -30.73337 20.19037 -30.73337 8.379343 -54.43729 20.19037 -54.43729 8.379343 -54.43729 20.19037 -30.73337 -54.93941 5.905512 -54.93941 9.84252 -30.03959 7.874016 -30.03959 15.74803 -30.03959 7.874016 -54.93941 9.84252 -20.19037 -26.73621 -0.505327 -26.73621 -20.19037 -51.08525 -8.379343 -51.08525 -20.19037 -51.08525 -0.505327 -26.73621 -20.19037 5.905512 -20.19037 9.84252 -8.379343 5.905512 -8.379343 9.84252 -8.379343 5.905512 -20.19037 9.84252 55.11811 5.905512 31.49606 7.874016 55.11811 9.84252 31.49606 15.74803 55.11811 9.84252 31.49606 7.874016 7.874016 -6.331833 7.874016 -4.442335 7.874016 -8.379343 11.81102 -4.442334 7.874016 -8.379343 7.874016 -4.442335 11.81102 -8.379343 7.874016 -8.379343 11.81102 -4.442334 -8.379343 15.74803 -8.379343 17.71654 -4.442335 15.74803 -4.442335 17.71654 -4.442335 15.74803 -8.379343 17.71654 -7.874016 15.74803 -15.74803 15.74803 -7.874016 19.68504 -15.74803 17.71654 -7.874016 19.68504 -15.74803 15.74803 -11.81102 19.68504 -7.874016 19.68504 -15.74803 17.71654 15.74803 15.74803 7.874016 15.74803 15.74803 17.71654 7.874016 19.68504 15.74803 17.71654 7.874016 15.74803 11.81102 19.68504 15.74803 17.71654 7.874016 19.68504 -4.442335 -1.760683 -4.442335 -6.162392 -8.379343 -1.760683 -8.379343 -6.162392 -8.379343 -1.760683 -4.442335 -6.162392 -23.62205 7.874016 -31.49606 7.874016 -23.62205 11.81102 -31.49606 15.74803 -23.62205 11.81102 -31.49606 7.874016 -23.62205 15.74803 -23.62205 11.81102 -31.49606 15.74803 30.03959 7.874016 21.73964 7.874016 30.03959 15.74803 21.73964 11.81102 30.03959 15.74803 21.73964 7.874016 5.139763 11.81102 30.03959 15.74803 21.73964 11.81102 5.139763 15.74803 30.03959 15.74803 5.139763 11.81102 31.49606 -0.505327 31.49606 -20.19037 23.62205 2.119345 23.62205 -20.19037 23.62205 2.119345 31.49606 -20.19037 43.81241 19.68504 43.81241 11.81102 35.9384 19.68504 20.19037 11.81102 35.9384 19.68504 43.81241 11.81102 20.19037 19.68504 35.9384 19.68504 20.19037 11.81102 20.19037 15.74803 20.19037 19.68504 20.19037 11.81102 20.19037 25.78134 43.81241 25.78134 20.19037 9.548647 35.9384 9.548647 20.19037 9.548647 43.81241 25.78134 28.06439 9.548647 20.19037 9.548647 35.9384 9.548647 35.9384 9.548647 43.81241 25.78134 43.81241 9.548647 23.62205 15.74803 7.874016 15.74803 23.62205 19.68504 7.874016 23.62205 23.62205 19.68504 7.874016 15.74803 15.98313 21.59477 23.62205 19.68504 7.874016 23.62205 43.81241 -18.14243 35.9384 -18.14243 43.81241 -1.909729 35.9384 -10.26841 43.81241 -1.909729 35.9384 -18.14243 20.19037 -10.26841 43.81241 -1.909729 35.9384 -10.26841 20.19037 -1.909729 43.81241 -1.909729 20.19037 -10.26841 35.9384 -1.909729 43.81241 -1.909729 20.19037 -1.909729 -43.81241 7.874016 -43.81241 23.62205 -35.9384 7.874016 -35.9384 23.62205 -35.9384 7.874016 -43.81241 23.62205 7.874016 0 -7.874016 0 7.874016 7.874016 -7.874016 7.874016 7.874016 7.874016 -7.874016 0 28.06439 7.874016 28.06439 0 20.19037 7.874016 20.19037 0 20.19037 7.874016 28.06439 0 7.874016 19.17971 7.874016 -20.19037 -7.874016 19.17971 -7.874016 -20.19037 -7.874016 19.17971 7.874016 -20.19037 -7.874016 -20.19037 7.874016 -20.19037 -7.874016 -28.06439 7.874016 -28.06439 -7.874016 -28.06439 7.874016 -20.19037 7.874016 0 -7.874016 0 7.874016 7.874016 -7.874016 7.874016 7.874016 7.874016 -7.874016 0 -23.62205 -20.19037 -15.74803 -8.379343 -7.874016 -20.19037 -7.874016 -8.379343 -7.874016 -20.19037 -15.74803 -8.379343 -15.74803 -8.379343 -23.62205 -20.19037 -15.74803 -4.442334 -15.74803 -4.442334 -23.62205 -20.19037 -31.49606 -0.505327 -31.49606 -20.19037 -31.49606 -0.505327 -23.62205 -20.19037 -7.874016 7.368689 -15.74803 -4.442334 -31.49606 -0.505327 -7.874016 -4.442334 -15.74803 -4.442334 -7.874016 7.368689 1.968504 8.375054 -1.968504 8.375054 1.968504 12.77676 -1.968504 12.77676 1.968504 12.77676 -1.968504 8.375054 1.968504 31.49606 0.257605 31.49606 1.968504 33.46456 -1.968504 31.49606 1.968504 33.46456 0.257605 31.49606 -1.968504 33.46456 1.968504 33.46456 -1.968504 31.49606 -8.379343 35.43307 3.431681 35.43307 -8.379342 31.49606 7.368689 31.49606 -8.379342 31.49606 3.431681 35.43307 7.368689 33.46456 7.368689 31.49606 3.431681 35.43307 -8.71e-4 31.49606 -1.968504 31.49606 1.968504 31.49606 -1.968504 35.43307 1.968504 31.49606 -1.968504 31.49606 1.968504 35.43307 1.968504 31.49606 -1.968504 35.43307 -1.968504 3.431681 1.968504 3.431681 -1.968504 -8.379343 1.968504 -8.379343 -1.968504 -8.379343 1.968504 3.431681 8.379343 35.43307 8.379342 31.49606 -3.431681 35.43307 -7.368689 31.49606 -3.431681 35.43307 8.379342 31.49606 -7.368689 33.46456 -3.431681 35.43307 -7.368689 31.49606 -20.19037 9.548647 -28.06439 9.548647 -20.19037 25.78134 -35.9384 9.548647 -20.19037 25.78134 -28.06439 9.548647 -20.19037 25.78134 -35.9384 9.548647 -43.81241 25.78134 -43.81241 9.548647 -43.81241 25.78134 -35.9384 9.548647 43.81241 23.62205 43.81241 7.874016 35.9384 23.62205 35.9384 7.874016 35.9384 23.62205 43.81241 7.874016 -43.81241 11.81102 -43.81241 19.68504 -20.19037 11.81102 -35.9384 19.68504 -20.19037 11.81102 -43.81241 19.68504 -20.19037 15.74803 -20.19037 11.81102 -35.9384 19.68504 -20.19037 15.74803 -35.9384 19.68504 -20.19037 19.68504 -28.06439 0 -28.06439 7.874016 -20.19037 0 -20.19037 7.874016 -20.19037 0 -28.06439 7.874016 -7.874016 15.74803 -23.62205 15.74803 -7.874016 23.62205 -23.62205 19.68504 -7.874016 23.62205 -23.62205 15.74803 -15.98313 21.59477 -7.874016 23.62205 -23.62205 19.68504 7.874016 -20.19037 7.874016 -8.379343 23.62205 -20.19037 15.74803 -8.379343 23.62205 -20.19037 7.874016 -8.379343 23.62205 -20.19037 15.74803 -8.379343 31.49606 -0.505327 15.74803 -8.379343 15.74803 -4.442334 31.49606 -0.505327 31.49606 -0.505327 15.74803 -4.442334 7.874016 7.368689 7.874016 -4.442335 7.874016 7.368689 15.74803 -4.442334 31.49606 -20.19037 23.62205 -20.19037 31.49606 -0.505327 -23.62205 2.119345 -23.62205 -20.19037 -31.49606 -0.505327 -31.49606 -20.19037 -31.49606 -0.505327 -23.62205 -20.19037 31.49606 7.874016 23.62205 7.874016 31.49606 15.74803 23.62205 11.81102 31.49606 15.74803 23.62205 7.874016 23.62205 15.74803 31.49606 15.74803 23.62205 11.81102 -5.139763 11.81102 -21.73964 11.81102 -5.139763 15.74803 -5.139763 15.74803 -21.73964 11.81102 -30.03959 15.74803 -30.03959 15.74803 -21.73964 11.81102 -30.03959 7.874016 -21.73964 7.874016 -30.03959 7.874016 -21.73964 11.81102 7.874016 23.11672 7.874016 19.17971 -7.874016 23.11672 -7.874016 19.17971 -7.874016 23.11672 7.874016 19.17971 7.874016 33.91281 7.874016 24.06535 -7.874016 33.91281 -7.874016 24.06535 -7.874016 33.91281 7.874016 24.06535 4.442334 19.68504 4.442334 15.74803 -15.22317 19.68504 -7.368689 15.74803 -15.22317 19.68504 4.442334 15.74803 -7.368689 11.81102 -15.22317 19.68504 -7.368689 15.74803 -19.17971 11.81102 -15.22317 19.68504 -7.368689 11.81102 -32.8424 9.417931 -15.22317 19.68504 -19.17971 11.81102 -19.17971 7.874016 -32.8424 9.417931 -19.17971 11.81102 -23.11672 7.874016 -32.8424 9.417931 -19.17971 7.874016 19.17971 7.874016 19.17971 11.81102 23.11672 7.874016 23.11672 7.874016 19.17971 11.81102 32.8424 9.417931 32.8424 9.417931 19.17971 11.81102 15.22317 19.68504 19.17971 11.81102 7.368689 11.81102 15.22317 19.68504 7.368689 11.81102 7.368689 15.74803 15.22317 19.68504 15.22317 19.68504 7.368689 15.74803 -4.442335 19.68504 -4.442334 15.74803 -4.442335 19.68504 7.368689 15.74803 -43.81241 -1.909729 -35.9384 -1.909729 -43.81241 -18.14243 -35.9384 -10.26841 -43.81241 -18.14243 -35.9384 -1.909729 -20.19037 -1.909729 -35.9384 -10.26841 -35.9384 -1.909729 -35.9384 -18.14243 -43.81241 -18.14243 -35.9384 -10.26841 -35.9384 -10.26841 -20.19037 -1.909729 -20.19037 -10.26841 -43.81241 24.24439 -39.8754 24.24439 -43.81241 12.06986 -39.8754 12.06986 -43.81241 12.06986 -39.8754 24.24439 -39.8754 -16.60547 -43.81241 -16.60547 -39.8754 -4.430943 -43.81241 -4.430943 -39.8754 -4.430943 -43.81241 -16.60547 -9.84252 10.39523 -21.65354 13.34799 -9.84252 21.10083 -21.65354 18.14808 -9.84252 21.10083 -21.65354 13.34799 -43.81241 13.34799 -43.81241 18.14808 -39.8754 13.34799 -39.8754 18.14808 -39.8754 13.34799 -43.81241 18.14808 43.81241 21.10083 43.81241 10.39523 39.8754 21.10083 39.8754 10.39523 39.8754 21.10083 43.81241 10.39523 -10.6579 6.215566 -20.83816 6.215566 -10.6579 16.39583 10.6579 16.39583 20.83816 6.215566 10.6579 6.215566 20.83816 3.937008 10.6579 3.937008 20.83816 7.874016 10.6579 7.874016 20.83816 7.874016 10.6579 3.937008 -6.215566 7.874016 -6.215566 3.937008 -16.39583 7.874016 -16.39583 3.937008 -16.39583 7.874016 -6.215566 3.937008 9.84252 10.39523 9.84252 21.10083 21.65354 13.34799 21.65354 18.14808 21.65354 13.34799 9.84252 21.10083 39.8754 -4.430943 43.81241 -4.430943 39.8754 -16.60547 43.81241 -16.60547 39.8754 -16.60547 43.81241 -4.430943 43.81241 18.14808 43.81241 13.34799 39.8754 18.14808 39.8754 13.34799 39.8754 18.14808 43.81241 13.34799 43.81241 12.06986 39.8754 12.06986 43.81241 24.24439 39.8754 24.24439 43.81241 24.24439 39.8754 12.06986 -43.81241 10.39523 -43.81241 21.10083 -39.8754 10.39523 -39.8754 21.10083 -39.8754 10.39523 -43.81241 21.10083 6.215566 3.937008 6.215566 7.874016 16.39583 3.937008 16.39583 7.874016 16.39583 3.937008 6.215566 7.874016 -10.6579 3.937008 -20.83816 3.937008 -10.6579 7.874016 -20.83816 7.874016 -10.6579 7.874016 -20.83816 3.937008 -10.6579 16.39583 -10.6579 6.215566 -20.83816 6.215566 10.6579 6.215566 10.6579 16.39583 20.83816 6.215566 -25.19838 19.89568 -11.77709 20.94294 -38.76868 1.80292 11.77709 20.94294 25.19838 19.89568 38.76868 1.80292 7.874016 -20.76608 -7.874016 -20.76608 3.937008 1.505001 -3.937008 1.505001 3.937008 1.505001 -7.874016 -20.76608 7.874016 -12.98254 3.937008 -25.85607 -7.874016 -12.98254 -3.937008 -25.85607 -7.874016 -12.98254 3.937008 -25.85607 35.9384 30.16956 35.9384 24.82648 32.00139 30.16956 20.19037 24.82648 32.00139 30.16956 35.9384 24.82648 -35.9384 30.16956 -32.00139 30.16956 -35.9384 24.82648 -20.19037 24.82648 -35.9384 24.82648 -32.00139 30.16956 35.9384 -18.14243 32.00139 -18.14243 35.9384 -10.26841 32.00139 -10.26841 35.9384 -10.26841 32.00139 -18.14243 -23.62205 19.68504 -24.91794 24.86859 -15.98313 21.59477 -17.27902 26.77832 -15.98313 21.59477 -24.91794 24.86859 37.08172 26.15259 30.35884 15.06875 30.34934 30.23611 23.62645 19.15227 30.34934 30.23611 30.35884 15.06875 23.62205 3.431681 23.62205 -20.19037 7.874016 19.17971 7.874016 -20.19037 7.874016 19.17971 23.62205 -20.19037 -7.994335 0 10.33974 3.937008 14.27674 0 14.27674 11.81102 14.27674 0 10.33974 3.937008 10.33974 7.874016 14.27674 11.81102 10.33974 3.937008 -4.057327 7.874016 14.27674 11.81102 10.33974 7.874016 -7.994335 7.874016 14.27674 11.81102 -4.057327 7.874016 -7.994335 11.81102 14.27674 11.81102 -7.994335 7.874016 -7.994335 7.874016 -4.057327 3.937008 -7.994335 0 10.33974 3.937008 -7.994335 0 -4.057327 3.937008 -4.057327 7.874016 -4.057327 3.937008 -7.994335 7.874016 -23.62205 2.119345 -23.62205 3.431681 -7.874016 7.368689 -7.874016 19.17971 -7.874016 7.368689 -23.62205 3.431681 -7.874016 0 -23.62205 0 -7.874016 7.874016 -23.62205 7.874016 -7.874016 7.874016 -23.62205 0 -23.62205 11.81102 -7.874016 7.874016 -23.62205 7.874016 -2.119345 11.81102 -2.119345 7.874016 -3.431681 11.81102 -3.431681 11.81102 -2.119345 7.874016 -3.431681 0 -3.431681 0 -2.119345 7.874016 20.19037 0 20.19037 7.874016 20.19037 0 -2.119345 7.874016 -7.874016 -31.67976 -7.874016 -3.84091 7.874016 -31.67976 -1.968504 -3.840909 7.874016 -31.67976 -7.874016 -3.84091 -8.71e-4 -3.84091 7.874016 -31.67976 -1.968504 -3.840909 1.968504 -3.840909 7.874016 -31.67976 -8.71e-4 -3.84091 7.874016 -3.84091 7.874016 -31.67976 1.968504 -3.840909 7.874016 7.874016 -7.874016 7.874016 7.874016 23.62205 -7.874016 23.62205 7.874016 23.62205 -7.874016 7.874016 7.874016 27.55906 7.874016 23.62205 -7.874016 23.62205 -7.874016 27.55906 7.874016 27.55906 -7.874016 23.62205 7.874016 -35.9384 -7.874016 -35.9384 7.874016 -28.06439 -7.874016 -28.06439 7.874016 -28.06439 -7.874016 -35.9384 -7.874015 -8.379343 -7.874015 7.368689 -1.968503 -8.379342 -1.968503 7.368689 -1.968503 -8.379342 -7.874015 7.368689 1.968503 7.368689 7.874015 7.368689 1.968504 -8.379342 7.874015 -8.379343 1.968504 -8.379342 7.874015 7.368689 23.62205 0 7.874016 0 23.62205 7.874016 7.874016 7.874016 23.62205 7.874016 7.874016 0 23.62205 11.81102 23.62205 7.874016 7.874016 7.874016 -7.874016 -20.19037 -23.62205 -20.19037 -7.874016 19.17971 -23.62205 3.431681 -7.874016 19.17971 -23.62205 -20.19037 -14.27674 11.81102 -10.33974 3.937008 -14.27674 0 7.994335 0 -14.27674 0 -10.33974 3.937008 4.057327 3.937008 7.994335 0 -10.33974 3.937008 4.057327 7.874016 7.994335 0 4.057327 3.937008 -10.33974 3.937008 -14.27674 11.81102 -10.33974 7.874016 7.994335 11.81102 -10.33974 7.874016 -14.27674 11.81102 4.057327 7.874016 -10.33974 7.874016 7.994335 11.81102 7.994335 0 4.057327 7.874016 7.994335 11.81102 7.994335 7.874016 7.994335 0 7.994335 11.81102 -20.19037 7.874016 2.119345 7.874016 -20.19037 0 3.431681 0 -20.19037 0 2.119345 7.874016 2.119345 11.81102 3.431681 0 2.119345 7.874016 3.431681 11.81102 3.431681 0 2.119345 11.81102 7.874016 7.368689 7.874016 19.17971 23.62205 2.119345 23.62205 3.431681 23.62205 2.119345 7.874016 19.17971 7.874016 -5.790606 7.874016 -13.65485 1.968504 -5.790606 -7.874016 -13.65485 1.968504 -5.790606 7.874016 -13.65485 0.257605 -5.790606 1.968504 -5.790606 -7.874016 -13.65485 -1.968504 -5.790606 0.257605 -5.790606 -7.874016 -13.65485 -7.874016 -5.790606 -1.968504 -5.790606 -7.874016 -13.65485 -20.19037 15.74803 -20.19037 23.62205 -8.379343 15.74803 -8.379343 15.74803 -20.19037 23.62205 -8.379343 31.49606 -8.379343 31.49606 -20.19037 23.62205 -35.9384 27.55906 -35.9384 23.62205 -35.9384 27.55906 -20.19037 23.62205 -8.379343 19.68504 -8.379343 15.74803 -8.379343 31.49606 -6.331833 19.68504 -8.379343 19.68504 -8.379343 31.49606 7.368689 31.49606 -6.331833 19.68504 -8.379343 31.49606 -4.442335 19.68504 -6.331833 19.68504 7.368689 31.49606 15.22317 19.68504 -4.442335 19.68504 7.368689 31.49606 15.22317 31.10432 15.22317 19.68504 7.368689 31.49606 32.8424 9.417931 15.22317 19.68504 15.22317 31.10432 43.81241 14.44474 32.8424 9.417931 15.22317 31.10432 43.81241 11.15938 32.8424 9.417931 43.81241 14.44474 7.874016 11.15938 -7.874016 11.15938 7.874016 14.44474 -7.874016 14.44474 7.874016 14.44474 -7.874016 11.15938 8.379343 31.49606 8.379343 19.68504 -7.368689 31.49606 4.442334 19.68504 -7.368689 31.49606 8.379343 19.68504 -15.22317 19.68504 -7.368689 31.49606 4.442334 19.68504 -15.22317 31.10432 -7.368689 31.49606 -15.22317 19.68504 -43.81241 14.44474 -15.22317 31.10432 -15.22317 19.68504 -32.8424 9.417931 -43.81241 14.44474 -15.22317 19.68504 -43.81241 11.15938 -43.81241 14.44474 -32.8424 9.417931 8.379343 19.68504 8.379343 31.49606 8.379343 15.74803 8.379343 15.74803 8.379343 31.49606 20.19037 15.74803 20.19037 15.74803 8.379343 31.49606 20.19037 23.62205 20.19037 23.62205 8.379343 31.49606 35.9384 23.62205 35.9384 27.55906 35.9384 23.62205 8.379343 31.49606 7.874016 45.02019 7.874016 33.91281 -7.874016 45.02019 -7.874016 33.91281 -7.874016 45.02019 7.874016 33.91281 -23.62645 19.15227 -30.35884 15.06875 -30.34934 30.23611 -37.08172 26.15259 -30.34934 30.23611 -30.35884 15.06875 -35.9384 -10.26841 -32.00139 -10.26841 -35.9384 -18.14243 -32.00139 -18.14243 -35.9384 -18.14243 -32.00139 -10.26841 23.62205 19.68504 15.98313 21.59477 24.91794 24.86859 17.27902 26.77832 24.91794 24.86859 15.98313 21.59477 35.9384 30.16956 35.9384 24.82648 32.00139 30.16956 20.19037 24.82648 32.00139 30.16956 35.9384 24.82648 -35.9384 30.16956 -32.00139 30.16956 -35.9384 24.82648 -20.19037 24.82648 -35.9384 24.82648 -32.00139 30.16956</float_array>
+          <technique_common>
+            <accessor source="#ID11-mesh-map-0-array" count="966" stride="2">
+              <param name="S" type="float"/>
+              <param name="T" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <vertices id="ID11-mesh-vertices">
+          <input semantic="POSITION" source="#ID11-mesh-positions"/>
+        </vertices>
+        <triangles material="InteractiveRed-material" count="322">
+          <input semantic="VERTEX" source="#ID11-mesh-vertices" offset="0"/>
+          <input semantic="NORMAL" source="#ID11-mesh-normals" offset="1"/>
+          <input semantic="TEXCOORD" source="#ID11-mesh-map-0" offset="2" set="0"/>
+          <p>0 0 0 1 0 1 2 0 2 3 1 3 2 1 4 1 1 5 4 2 6 5 2 7 6 2 8 7 3 9 6 3 10 5 3 11 8 4 12 9 4 13 10 4 14 11 5 15 10 5 16 9 5 17 12 6 18 13 6 19 14 6 20 15 7 21 14 7 22 13 7 23 16 8 24 17 8 25 18 8 26 19 9 27 18 9 28 17 9 29 20 10 30 21 10 31 22 10 32 23 10 33 22 10 34 21 10 35 20 10 36 24 10 37 21 10 38 25 11 39 21 11 40 24 11 41 26 10 42 25 10 43 24 10 44 22 10 45 23 10 46 26 10 47 27 10 48 25 10 49 26 10 50 23 12 51 27 12 52 26 12 53 28 13 54 29 13 55 30 13 56 31 14 57 30 14 58 29 14 59 32 15 60 30 15 61 31 15 62 33 16 63 34 16 64 35 16 65 36 17 66 35 17 67 34 17 68 37 18 69 38 18 70 39 18 71 40 19 72 39 19 73 38 19 74 41 8 75 42 8 76 43 8 77 44 8 78 43 8 79 42 8 80 45 20 81 46 20 82 47 20 83 48 21 84 47 21 85 46 21 86 49 22 87 47 22 88 48 22 89 50 23 90 51 23 91 52 23 92 53 10 93 52 10 94 51 10 95 54 10 96 52 10 97 53 10 98 55 10 99 54 10 100 53 10 101 56 24 102 54 24 103 55 24 104 57 25 105 54 25 106 56 25 107 50 26 108 57 26 109 51 26 110 56 27 111 51 27 112 57 27 113 58 28 114 59 28 115 60 28 116 61 29 117 60 29 118 59 29 119 62 30 120 63 30 121 64 30 122 65 31 123 64 31 124 63 31 125 66 32 126 67 32 127 68 32 128 69 33 129 68 33 130 67 33 131 70 34 132 71 34 133 72 34 134 73 35 135 72 35 136 71 35 137 74 36 138 75 36 139 76 36 140 77 37 141 76 37 142 75 37 143 78 38 144 79 38 145 80 38 146 81 39 147 80 39 148 79 39 149 82 18 150 80 18 151 81 18 152 83 34 153 84 34 154 85 34 155 86 34 156 85 34 157 84 34 158 87 40 159 88 40 160 89 40 161 90 41 162 89 41 163 88 41 164 91 42 165 89 42 166 90 42 167 92 43 168 93 43 169 94 43 170 95 44 171 94 44 172 93 44 173 96 45 174 94 45 175 95 45 176 97 46 177 98 46 178 99 46 179 100 47 180 99 47 181 98 47 182 101 48 183 6 48 184 102 48 185 7 49 186 102 49 187 6 49 188 103 50 189 102 50 190 7 50 191 1 51 192 104 51 193 3 51 194 105 52 195 3 52 196 104 52 197 106 53 198 3 53 199 105 53 200 107 54 201 3 54 202 106 54 203 108 55 204 109 55 205 110 55 206 111 56 207 110 56 208 109 56 209 112 57 210 113 57 211 114 57 212 115 58 213 114 58 214 113 58 215 116 59 216 114 59 217 115 59 218 117 8 219 116 8 220 115 8 221 118 60 222 119 60 223 120 60 224 121 61 225 120 61 226 119 61 227 122 62 228 120 62 229 121 62 230 121 63 231 119 63 232 123 63 233 124 64 234 125 64 235 126 64 236 127 65 237 126 65 238 125 65 239 128 66 240 129 66 241 130 66 242 131 67 243 132 67 244 133 67 245 134 68 246 133 68 247 132 68 248 135 69 249 133 69 250 134 69 251 136 70 252 133 70 253 135 70 254 137 10 255 133 10 256 136 10 257 138 71 258 139 71 259 140 71 260 141 34 261 140 34 262 139 34 263 142 72 264 143 72 265 144 72 266 145 64 267 144 64 268 143 64 269 146 8 270 147 8 271 148 8 272 149 73 273 148 73 274 147 73 275 150 74 276 151 74 277 152 74 278 153 75 279 152 75 280 151 75 281 153 76 282 151 76 283 154 76 284 155 77 285 154 77 286 151 77 287 156 78 288 157 78 289 158 78 290 159 79 291 158 79 292 157 79 293 160 80 294 161 80 295 162 80 296 163 81 297 162 81 298 161 81 299 161 82 300 160 82 301 164 82 302 164 83 303 160 83 304 165 83 305 166 84 306 165 84 307 160 84 308 167 85 309 164 85 310 165 85 311 168 86 312 164 86 313 167 86 314 169 87 315 170 87 316 171 87 317 172 88 318 171 88 319 170 88 320 173 89 321 174 89 322 175 89 323 176 90 324 175 90 325 174 90 326 177 91 327 175 91 328 176 91 329 178 92 330 179 92 331 180 92 332 181 93 333 180 93 334 179 93 335 182 34 336 181 34 337 179 34 338 183 62 339 184 62 340 185 62 341 186 94 342 185 94 343 184 94 344 187 43 345 185 43 346 186 43 347 188 95 348 189 95 349 190 95 350 191 96 351 190 96 352 189 96 353 192 97 354 193 97 355 194 97 356 195 98 357 194 98 358 193 98 359 196 8 360 194 8 361 195 8 362 197 99 363 198 99 364 199 99 365 200 100 366 199 100 367 198 100 368 199 101 369 200 101 370 201 101 371 202 102 372 201 102 373 200 102 374 203 103 375 204 103 376 205 103 377 206 8 378 205 8 379 204 8 380 207 104 381 208 104 382 209 104 383 210 105 384 209 105 385 208 105 386 211 106 387 209 106 388 210 106 389 211 107 390 210 107 391 212 107 392 213 34 393 214 34 394 215 34 395 216 108 396 215 108 397 214 108 398 217 109 399 218 109 400 219 109 401 220 13 402 219 13 403 218 13 404 221 110 405 222 110 406 223 110 407 224 111 408 225 111 409 226 111 410 227 112 411 226 112 412 225 112 413 226 113 414 227 113 415 228 113 416 227 62 417 229 62 418 228 62 419 228 114 420 229 114 421 230 114 422 231 115 423 230 115 424 229 115 425 232 116 426 226 116 427 228 116 428 233 117 429 234 117 430 235 117 431 236 118 432 235 118 433 234 118 434 75 10 435 237 10 436 77 10 437 238 10 438 77 10 439 237 10 440 239 119 441 77 119 442 238 119 443 240 120 444 241 120 445 242 120 446 242 121 447 241 121 448 65 121 449 65 122 450 241 122 451 64 122 452 243 123 453 64 123 454 241 123 455 244 124 456 245 124 457 246 124 458 247 125 459 246 125 460 245 125 461 248 126 462 249 126 463 250 126 464 251 127 465 250 127 466 249 127 467 252 128 468 253 128 469 254 128 470 255 129 471 254 129 472 253 129 473 256 130 474 254 130 475 255 130 476 257 131 477 254 131 478 256 131 479 258 132 480 254 132 481 257 132 482 259 133 483 258 133 484 257 133 485 260 134 486 258 134 487 259 134 488 261 135 489 262 135 490 263 135 491 263 136 492 262 136 493 264 136 494 264 137 495 262 137 496 265 137 497 262 138 498 266 138 499 265 138 500 266 139 501 267 139 502 265 139 503 265 140 504 267 140 505 268 140 506 269 141 507 268 141 508 267 141 509 270 142 510 271 142 511 272 142 512 273 143 513 272 143 514 271 143 515 274 144 516 273 144 517 271 144 518 275 145 519 272 145 520 273 145 521 273 146 522 274 146 523 276 146 524 277 147 525 278 147 526 279 147 527 280 148 528 279 148 529 278 148 530 281 149 531 282 149 532 283 149 533 284 150 534 283 150 535 282 150 536 285 10 537 286 10 538 287 10 539 288 10 540 287 10 541 286 10 542 289 34 543 290 34 544 291 34 545 292 34 546 291 34 547 290 34 548 293 8 549 294 8 550 295 8 551 296 151 552 295 151 553 294 151 554 297 152 555 298 152 556 299 152 557 300 153 558 301 153 559 302 153 560 303 154 561 304 154 562 305 154 563 306 155 564 305 155 565 304 155 566 307 156 567 308 156 568 309 156 569 310 8 570 309 8 571 308 8 572 311 10 573 312 10 574 313 10 575 314 10 576 313 10 577 312 10 578 315 157 579 316 157 580 317 157 581 318 158 582 317 158 583 316 158 584 319 8 585 320 8 586 321 8 587 322 8 588 321 8 589 320 8 590 323 159 591 324 159 592 325 159 593 326 160 594 325 160 595 324 160 596 327 161 597 328 161 598 329 161 599 330 34 600 329 34 601 328 34 602 331 162 603 332 162 604 333 162 605 334 34 606 333 34 607 332 34 608 335 163 609 336 163 610 337 163 611 338 164 612 337 164 613 336 164 614 339 165 615 340 165 616 341 165 617 342 166 618 343 166 619 344 166 620 345 167 621 346 167 622 347 167 623 348 168 624 349 168 625 350 168 626 351 169 627 352 169 628 353 169 629 354 170 630 353 170 631 352 170 632 355 171 633 356 171 634 357 171 635 358 172 636 357 172 637 356 172 638 359 173 639 360 173 640 361 173 641 362 174 642 361 174 643 360 174 644 363 175 645 364 175 646 365 175 647 366 176 648 365 176 649 364 176 650 367 177 651 368 177 652 369 177 653 370 178 654 369 178 655 368 178 656 371 10 657 372 10 658 373 10 659 374 10 660 373 10 661 372 10 662 375 179 663 376 179 664 377 179 665 378 180 666 377 180 667 376 180 668 379 181 669 380 181 670 150 181 671 151 182 672 150 182 673 380 182 674 381 183 675 382 183 676 383 183 677 384 184 678 383 184 679 382 184 680 385 185 681 384 185 682 382 185 683 386 186 684 384 186 685 385 186 686 387 187 687 384 187 688 386 187 689 388 188 690 384 188 691 387 188 692 387 189 693 389 189 694 381 189 695 382 190 696 381 190 697 389 190 698 386 191 699 389 191 700 387 191 701 390 192 702 391 192 703 392 192 704 393 193 705 392 193 706 391 193 707 394 79 708 395 79 709 396 79 710 101 79 711 396 79 712 395 79 713 102 194 714 396 194 715 101 194 716 397 8 717 398 8 718 399 8 719 399 195 720 398 195 721 400 195 722 400 196 723 398 196 724 401 196 725 402 197 726 401 197 727 398 197 728 403 198 729 404 198 730 405 198 731 406 199 732 405 199 733 404 199 734 407 200 735 405 200 736 406 200 737 408 201 738 405 201 739 407 201 740 409 202 741 405 202 742 408 202 743 410 203 744 411 203 745 412 203 746 413 194 747 412 194 748 411 194 749 414 43 750 412 43 751 413 43 752 415 204 753 414 204 754 413 204 755 416 205 756 417 205 757 418 205 758 419 206 759 418 206 760 417 206 761 420 207 762 421 207 763 422 207 764 423 208 765 422 208 766 421 208 767 424 209 768 425 209 769 426 209 770 427 209 771 426 209 772 425 209 773 428 210 774 429 210 775 237 210 776 430 211 777 237 211 778 429 211 779 238 212 780 237 212 781 430 212 782 153 213 783 431 213 784 152 213 785 432 214 786 152 214 787 431 214 788 433 215 789 434 215 790 435 215 791 436 216 792 435 216 793 434 216 794 437 217 795 436 217 796 434 217 797 438 218 798 436 218 799 437 218 800 434 219 801 433 219 802 439 219 803 440 220 804 439 220 805 433 220 806 438 221 807 439 221 808 440 221 809 436 222 810 438 222 811 440 222 812 441 8 813 436 8 814 440 8 815 442 223 816 443 223 817 444 223 818 445 224 819 444 224 820 443 224 821 446 225 822 445 225 823 443 225 824 447 34 825 445 34 826 446 34 827 448 111 828 449 111 829 450 111 830 451 62 831 450 62 832 449 62 833 452 226 834 453 226 835 454 226 836 455 227 837 454 227 838 453 227 839 456 228 840 454 228 841 455 228 842 457 229 843 456 229 844 455 229 845 458 230 846 457 230 847 455 230 848 459 231 849 460 231 850 461 231 851 461 232 852 460 232 853 462 232 854 462 233 855 460 233 856 463 233 857 464 234 858 463 234 859 460 234 860 465 8 861 461 8 862 462 8 863 466 34 864 465 34 865 462 34 866 467 235 867 466 235 868 462 235 869 268 236 870 466 236 871 467 236 872 265 237 873 268 237 874 467 237 875 468 238 876 265 238 877 467 238 878 264 239 879 265 239 880 468 239 881 469 240 882 264 240 883 468 240 884 470 34 885 264 34 886 469 34 887 471 241 888 472 241 889 473 241 890 474 241 891 473 241 892 472 241 893 475 242 894 476 242 895 477 242 896 252 243 897 477 243 898 476 243 899 254 244 900 477 244 901 252 244 902 478 245 903 477 245 904 254 245 905 479 246 906 478 246 907 254 246 908 258 247 909 479 247 910 254 247 911 480 248 912 479 248 913 258 248 914 476 34 915 475 34 916 481 34 917 481 249 918 475 249 919 482 249 920 482 250 921 475 250 922 483 250 923 483 251 924 475 251 925 484 251 926 485 252 927 484 252 928 475 252 929 486 253 930 248 253 931 487 253 932 250 254 933 487 254 934 248 254 935 488 255 936 489 255 937 490 255 938 491 256 939 490 256 940 489 256 941 492 257 942 493 257 943 494 257 944 495 258 945 494 258 946 493 258 947 496 259 948 497 259 949 498 259 950 499 260 951 498 260 952 497 260 953 500 261 954 501 261 955 502 261 956 503 262 957 502 262 958 501 262 959 504 263 960 505 263 961 506 263 962 507 264 963 506 264 964 505 264 965</p>
+        </triangles>
+      </mesh>
+    </geometry>
+    <geometry id="Cube_001-mesh" name="Cube.001">
+      <mesh>
+        <source id="Cube_001-mesh-positions">
+          <float_array id="Cube_001-mesh-positions-array" count="60">1.188083 -0.08953237 0.371709 0.7994193 1.140056 -1.433514 1.188083 -1.474636 0.3514011 1.315013 -1.853213 -1.433514 -1.188083 -0.08953237 0.371709 -0.7994193 1.140056 -1.433514 -1.188083 -1.474636 0.3514011 -1.315013 -1.853213 -1.433514 -0.9862595 -2.500253 -1.22394 -0.9862595 -2.519339 -0.2239396 0.9862595 -2.519339 -0.2239396 0.9862595 -2.500253 -1.22394 0.5995645 1.971269 -0.8815678 -0.5995645 1.971269 -0.8815678 0.5995645 1.16453 0.09344267 -0.5995645 1.16453 0.09344267 2.776942 -0.1095306 -0.8880948 2.83363 -1.621893 -0.8862085 -2.776942 -0.1095306 -0.8880948 -2.83363 -1.621893 -0.8862083</float_array>
+          <technique_common>
+            <accessor source="#Cube_001-mesh-positions-array" count="20" stride="3">
+              <param name="X" type="float"/>
+              <param name="Y" type="float"/>
+              <param name="Z" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="Cube_001-mesh-normals">
+          <float_array id="Cube_001-mesh-normals-array" count="99">0 -0.01466006 0.9998926 0 -0.3081366 -0.9513422 -0.6022508 0.02356946 0.7979589 0 0 -1 0.602251 0.02356934 0.7979589 0 0.2166231 0.9762553 0 -0.999818 -0.01908236 0 -0.482404 0.8759489 0.4953244 -0.4905348 0.7169584 -0.2783797 -0.8712932 -0.4041697 0 0.7704592 0.6374894 0.5225462 0.8508509 0.05475574 -0.5663074 0.4227536 0.7075135 0 0.5531756 -0.8330647 0.2952768 0.05086171 -0.954057 0.5663074 0.4227536 0.7075136 0.8903515 -0.4551908 -0.008687913 -0.2952769 0.05086171 -0.9540569 -0.9803138 0.1521239 0.1258695 -0.4953244 -0.4905348 0.7169584 0 -0.01466006 0.9998925 0 -0.3081362 -0.9513424 -0.6211663 -0.01148867 0.7835946 0.6211663 -0.01148867 0.7835946 0 -0.999818 -0.01908284 0 -0.4824041 0.8759489 -0.8903515 -0.4551908 -0.008687913 0 0.7704591 0.6374895 0.9803138 0.1521239 0.1258695 0.3374801 0.0114758 -0.9412627 0.2783796 -0.8712932 -0.4041697 -0.3374803 0.01147562 -0.9412626 -0.5225462 0.8508509 0.05475574</float_array>
+          <technique_common>
+            <accessor source="#Cube_001-mesh-normals-array" count="33" stride="3">
+              <param name="X" type="float"/>
+              <param name="Y" type="float"/>
+              <param name="Z" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="Cube_001-mesh-map-0">
+          <float_array id="Cube_001-mesh-map-0-array" count="216">0.875 0.5 0.625 0.75 0.625 0.5 0.375 0.75 0.125 0.75 0.125 0.75 0.625 0 0.5135849 0.25 0.5356172 0 0.375 0.5 0.125 0.75 0.125 0.5 0.5135849 0.5 0.625 0.75 0.5356172 0.75 0.625 0.5 0.875 0.5 0.875 0.5 0.625 0.75 0.375 1 0.375 0.75 0.875 0.75 0.625 0.75 0.625 0.75 0.5356172 0.75 0.625 0.75 0.625 0.75 0.375 0 0.625 0 0.5356172 0 0.625 0.25 0.375 0.5 0.375 0.25 0.375 0.5 0.625 0.5 0.5135849 0.5 0.5135849 0.25 0.625 0.25 0.625 0.25 0.125 0.5 0.375 0.5 0.375 0.5 0.5135849 0.5 0.375 0.75 0.375 0.5 0.625 0.5 0.5135849 0.5 0.625 0.5 0.375 0.75 0.625 0.75 0.375 0.75 0.375 0 0.5135849 0.25 0.375 0.25 0.375 0.25 0.625 0.25 0.375 0.25 0.625 0 0.5356172 0 0.625 0 0.875 0.5 0.875 0.75 0.625 0.75 0.375 0.75 0.375 0.75 0.125 0.75 0.625 0 0.625 0.25 0.5135849 0.25 0.375 0.5 0.375 0.75 0.125 0.75 0.5135849 0.5 0.625 0.5 0.625 0.75 0.625 0.5 0.625 0.5 0.875 0.5 0.625 0.75 0.625 1 0.375 1 0.875 0.75 0.875 0.75 0.625 0.75 0.375 0 0.375 0 0.625 0 0.625 0.25 0.625 0.5 0.375 0.5 0.375 0.5 0.375 0.5 0.625 0.5 0.125 0.5 0.125 0.5 0.375 0.5 0.5135849 0.5 0.5356172 0.75 0.375 0.75 0.375 0.75 0.5356172 0.75 0.625 0.75 0.375 0 0.5356172 0 0.5135849 0.25 0.375 0.25 0.5135849 0.25 0.625 0.25</float_array>
+          <technique_common>
+            <accessor source="#Cube_001-mesh-map-0-array" count="108" stride="2">
+              <param name="S" type="float"/>
+              <param name="T" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <vertices id="Cube_001-mesh-vertices">
+          <input semantic="POSITION" source="#Cube_001-mesh-positions"/>
+        </vertices>
+        <triangles count="36">
+          <input semantic="VERTEX" source="#Cube_001-mesh-vertices" offset="0"/>
+          <input semantic="NORMAL" source="#Cube_001-mesh-normals" offset="1"/>
+          <input semantic="TEXCOORD" source="#Cube_001-mesh-map-0" offset="2" set="0"/>
+          <p>4 0 0 2 0 1 0 0 2 3 1 3 8 1 4 7 1 5 6 2 6 18 2 7 19 2 8 1 3 9 7 3 10 5 3 11 16 4 12 2 4 13 17 4 14 0 5 15 15 5 16 4 5 17 10 6 18 8 6 19 11 6 20 6 7 21 10 7 22 2 7 23 17 8 24 2 8 25 10 8 26 7 9 27 9 9 28 19 9 29 15 10 30 12 10 31 13 10 32 1 11 33 14 11 34 16 11 35 18 12 36 4 12 37 15 12 38 5 13 39 12 13 40 1 13 41 16 14 42 3 14 43 1 14 44 0 15 45 16 15 46 14 15 47 3 16 48 10 16 49 11 16 50 7 17 51 18 17 52 5 17 53 5 18 54 15 18 55 13 18 56 6 19 57 19 19 58 9 19 59 4 20 60 6 20 61 2 20 62 3 21 63 11 21 64 8 21 65 6 22 66 4 22 67 18 22 68 1 3 69 3 3 70 7 3 71 16 23 72 0 23 73 2 23 74 0 5 75 14 5 76 15 5 77 10 24 78 9 24 79 8 24 80 6 25 81 9 25 82 10 25 83 7 26 84 8 26 85 9 26 86 15 27 87 14 27 88 12 27 89 1 28 90 12 28 91 14 28 92 5 13 93 13 13 94 12 13 95 16 29 96 17 29 97 3 29 98 3 30 99 17 30 100 10 30 101 7 31 102 19 31 103 18 31 104 5 32 105 18 32 106 15 32 107</p>
+        </triangles>
+      </mesh>
+    </geometry>
+  </library_geometries>
+  <library_controllers/>
+  <library_visual_scenes>
+    <visual_scene id="Scene" name="Scene">
+      <node id="contrail1" name="contrail1" type="NODE">
+        <matrix sid="transform">1 0 0 2.746234 0 1 0 -0.7129033 0 0 1 0.3962743 0 0 0 1</matrix>
+      </node>
+      <node id="contrail0" name="contrail0" type="NODE">
+        <matrix sid="transform">1 0 0 -2.753439 0 1 0 -0.7129033 0 0 1 0.3962743 0 0 0 1</matrix>
+      </node>
+      <node id="JetNozzle1" name="JetNozzle1" type="NODE">
+        <matrix sid="transform">1 0 0 0.7613215 0 1 0 -2.217451 0 0 1 0.8382882 0 0 0 1</matrix>
+      </node>
+      <node id="JetNozzle0" name="JetNozzle0" type="NODE">
+        <matrix sid="transform">1 0 0 -0.7983776 0 1 0 -2.217451 0 0 1 0.8382882 0 0 0 1</matrix>
+      </node>
+      <node id="FlyingShipBody" name="FlyingShipBody" type="NODE">
+        <matrix sid="transform">1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1</matrix>
+        <instance_geometry url="#ID11-mesh" name="FlyingShipBody">
+          <bind_material>
+            <technique_common>
+              <instance_material symbol="InteractiveRed-material" target="#InteractiveRed-material">
+                <bind_vertex_input semantic="ID16" input_semantic="TEXCOORD" input_set="0"/>
+              </instance_material>
+            </technique_common>
+          </bind_material>
+        </instance_geometry>
+      </node>
+      <node id="colMesh_1" name="colMesh_1" type="NODE">
+        <matrix sid="transform">1 0 0 0 0 1 0 0.2790807 0 0 1 1.424781 0 0 0 1</matrix>
+        <instance_geometry url="#Cube_001-mesh" name="colMesh_1"/>
+      </node>
+      <node id="NULLDETAIL1" name="NULLDETAIL1" type="NODE">
+        <matrix sid="transform">1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1</matrix>
+      </node>
+      <node id="MOUNT0" name="MOUNT0" type="NODE">
+        <matrix sid="transform">1 0 0 0 0 1 0 0.1752674 0 0 1 1.070523 0 0 0 1</matrix>
+      </node>
+      <node id="EYE" name="EYE" type="NODE">
+        <matrix sid="transform">1 0 0 0 0 1 0 1.608763 0 0 1 1.325542 0 0 0 1</matrix>
+      </node>
+      <node id="CAM" name="CAM" type="NODE">
+        <matrix sid="transform">1 0 0 0 0 1 0 -0.02438152 0 0 1 2.130329 0 0 0 1</matrix>
+      </node>
+      <node id="Armature" name="Armature" type="NODE">
+        <matrix sid="transform">1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1</matrix>
+        <node id="Armature_bn_Root" name="bn_Root" sid="bn_Root" type="JOINT">
+          <matrix sid="transform">1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1</matrix>
+          <node id="Armature_COLCONVEX-002" name="COLCONVEX-002" sid="COLCONVEX-002" type="JOINT">
+            <matrix sid="transform">1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1</matrix>
+            <extra>
+              <technique profile="blender">
+                <layer sid="layer" type="string">0</layer>
+                <tip_x sid="tip_x" type="float">0</tip_x>
+                <tip_y sid="tip_y" type="float">1.631059</tip_y>
+                <tip_z sid="tip_z" type="float">0</tip_z>
+              </technique>
+            </extra>
+          </node>
+          <node id="Armature_COLCONVEX-001" name="COLCONVEX-001" sid="COLCONVEX-001" type="JOINT">
+            <matrix sid="transform">1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1</matrix>
+            <extra>
+              <technique profile="blender">
+                <layer sid="layer" type="string">0</layer>
+                <tip_x sid="tip_x" type="float">0</tip_x>
+                <tip_y sid="tip_y" type="float">1.631059</tip_y>
+                <tip_z sid="tip_z" type="float">0</tip_z>
+              </technique>
+            </extra>
+          </node>
+          <extra>
+            <technique profile="blender">
+              <layer sid="layer" type="string">0</layer>
+              <tip_x sid="tip_x" type="float">0</tip_x>
+              <tip_y sid="tip_y" type="float">1.631059</tip_y>
+              <tip_z sid="tip_z" type="float">0</tip_z>
+            </technique>
+          </extra>
+        </node>
+      </node>
+      <node id="EnvironmentAmbientLight" name="EnvironmentAmbientLight" type="NODE">
+        <matrix sid="transform">1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1</matrix>
+        <instance_light url="#EnvironmentAmbientLight-light"/>
+      </node>
+    </visual_scene>
+  </library_visual_scenes>
+  <scene>
+    <instance_visual_scene url="#Scene"/>
+  </scene>
+</COLLADA>
\ No newline at end of file
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/flier.tscript b/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/flier.tscript
new file mode 100644
index 000000000..9f2b53390
--- /dev/null
+++ b/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/flier.tscript
@@ -0,0 +1,11 @@
+
+singleton TSShapeConstructor(flierdae)
+{
+   baseShapeAsset = "./flier.dae";
+   singleDetailSize = "0";
+   flipUVCoords = "0";
+   JoinIdenticalVerts = "0";
+   reverseWindingOrder = "0";
+   removeRedundantMats = "0";
+   animFPS = "2";
+};
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/hoverboat.asset.taml b/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/hoverboat.asset.taml
new file mode 100644
index 000000000..c2c15714a
--- /dev/null
+++ b/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/hoverboat.asset.taml
@@ -0,0 +1 @@
+<ShapeAsset canSave="true" canSaveDynamicFields="true" AssetName="hoverboat" fileName="@assetFile=hoverboat.dae" constuctorFileName="@assetFile=hoverboat.tscript"/>
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/hoverboat.dae b/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/hoverboat.dae
new file mode 100644
index 000000000..18b22f7ad
--- /dev/null
+++ b/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/hoverboat.dae
@@ -0,0 +1,156 @@
+<?xml version="1.0" encoding="utf-8"?>
+<COLLADA xmlns="http://www.collada.org/2005/11/COLLADASchema" version="1.4.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <asset>
+    <contributor>
+      <author>Blender User</author>
+      <authoring_tool>Blender 2.90.0 commit date:2020-08-31, commit time:11:26, hash:0330d1af29c0</authoring_tool>
+    </contributor>
+    <created>2021-09-11T16:05:47</created>
+    <modified>2021-09-11T16:05:47</modified>
+    <unit name="meter" meter="1"/>
+    <up_axis>Z_UP</up_axis>
+  </asset>
+  <library_effects>
+    <effect id="InteractiveRed-effect">
+      <profile_COMMON>
+        <technique sid="common">
+          <lambert>
+            <emission>
+              <color sid="emission">0 0 0 1</color>
+            </emission>
+            <diffuse>
+              <color sid="diffuse">0.8 0.8 0.8 1</color>
+            </diffuse>
+            <index_of_refraction>
+              <float sid="ior">1.45</float>
+            </index_of_refraction>
+          </lambert>
+        </technique>
+      </profile_COMMON>
+    </effect>
+  </library_effects>
+  <library_images/>
+  <library_materials>
+    <material id="InteractiveRed-material" name="InteractiveRed">
+      <instance_effect url="#InteractiveRed-effect"/>
+    </material>
+  </library_materials>
+  <library_geometries>
+    <geometry id="Mesh1_Group1_Model_1-mesh" name="Mesh1 Group1 Model_1">
+      <mesh>
+        <source id="Mesh1_Group1_Model_1-mesh-positions">
+          <float_array id="Mesh1_Group1_Model_1-mesh-positions-array" count="666">0.7238646 -2.736287 0 1.46437e-7 -3.198901 0.4 1.30974e-7 -2.933427 0 0.8008492 -2.870321 0.4 1.509492 -1.992523 0.01999771 0.8008492 -2.870321 0.4 0.7238646 -2.736287 0 1.67003 -1.67303 0.3850017 1.509492 -1.992523 0.01999771 1.83015 2.968142 0.4 1.67003 -1.67303 0.3850017 1.65422 2.791054 0 0.7238646 -2.736287 0 1.65422 2.791054 0 1.509492 -1.992523 0.01999771 1.30974e-7 -2.933427 0 -0.7238643 -2.736287 0 -1.509492 -1.992523 0.01999771 -1.65422 2.791054 0 -1.670029 -1.67303 0.3850017 -1.65422 2.791054 0 -1.509492 -1.992523 0.01999771 -1.83015 2.968142 0.4 -1.670029 -1.67303 0.3850017 -1.785 2.968142 1.2 -1.83015 2.968142 0.4 -1.785 -1.346858 1.2 -0.800849 -2.870321 0.4 -1.785 -1.346858 1.2 -1.670029 -1.67303 0.3850017 -0.7810919 -2.939518 1.2 -0.800849 -2.870321 0.4 1.36834e-7 -3.371857 1.2 -0.7810919 -2.939518 1.2 1.46437e-7 -3.198901 0.4 -0.7238643 -2.736287 0 1.46437e-7 -3.198901 0.4 -0.800849 -2.870321 0.4 1.30974e-7 -2.933427 0 -0.800849 -2.870321 0.4 -1.509492 -1.992523 0.01999771 -0.7238643 -2.736287 0 -1.670029 -1.67303 0.3850017 0.8008492 -2.870321 0.4 1.36834e-7 -3.371857 1.2 1.46437e-7 -3.198901 0.4 0.7810921 -2.939518 1.2 0.8008492 -2.870321 0.4 1.785 -1.346858 1.2 0.7810921 -2.939518 1.2 1.67003 -1.67303 0.3850017 1.67003 -1.67303 0.3850017 1.785 2.968142 1.2 1.785 -1.346858 1.2 1.83015 2.968142 0.4 1.83015 2.968142 0.4 -1.785 2.968142 1.2 1.785 2.968142 1.2 -1.83015 2.968142 0.4 1.65422 2.791054 0 -1.65422 2.791054 0 -1.785 2.968142 1.2 1.785 2.968142 1.2 -1.69575 2.968142 1.6 1.69575 2.968142 1.6 -1.102238 2.968142 1.8 -1.69575 2.968142 1.6 -1.102238 -0.7950175 1.8 -1.102238 2.968142 1.8 -1.69575 -1.227617 1.6 -1.785 2.968142 1.2 -1.69575 -1.227617 1.6 -1.69575 2.968142 1.6 -1.785 -1.346858 1.2 -1.785 -1.346858 1.2 -0.7420379 -2.740638 1.6 -1.69575 -1.227617 1.6 -0.7810919 -2.939518 1.2 -0.7810919 -2.939518 1.2 1.36834e-7 -3.151357 1.6 -0.7420379 -2.740638 1.6 1.36834e-7 -3.371857 1.2 1.36834e-7 -3.371857 1.2 0.7420381 -2.740638 1.6 1.36834e-7 -3.151357 1.6 0.7810921 -2.939518 1.2 1.785 -1.346858 1.2 0.7420381 -2.740638 1.6 0.7810921 -2.939518 1.2 1.69575 -1.227617 1.6 1.785 2.968142 1.2 1.69575 -1.227617 1.6 1.785 -1.346858 1.2 1.69575 2.968142 1.6 1.102238 2.968142 1.8 1.69575 -1.227617 1.6 1.69575 2.968142 1.6 1.102238 2.468142 1.8 1.102238 1.664157 1.8 1.102238 -0.3559176 1.8 1.102238 -0.7950175 1.8 1.102238 1.664157 1.8 -1.102238 2.468142 1.8 -1.102238 1.664157 1.8 -0.8022379 2.468142 1.8 -0.8022379 2.968142 1.8 0.8022381 2.468142 1.8 1.102238 2.468142 1.8 1.102238 2.968142 1.8 -0.8022379 2.968142 1.8 0.8022381 2.968142 1.8 0.8022381 2.968142 1.8 -1.102238 1.664157 1.8 -1.102238 2.468142 1.8 -1.102238 -0.3559176 1.8 -1.102238 -0.7950175 1.8 -0.7420379 -2.740638 1.6 -0.4823238 -1.778477 1.8 -1.69575 -1.227617 1.6 1.36834e-7 -3.151357 1.6 -0.4823238 -1.778477 1.8 -0.7420379 -2.740638 1.6 1.36834e-7 -2.045438 1.8 0.7420381 -2.740638 1.6 1.36834e-7 -2.045438 1.8 1.36834e-7 -3.151357 1.6 0.4823241 -1.778477 1.8 0.7420381 -2.740638 1.6 1.102238 -0.7950175 1.8 0.4823241 -1.778477 1.8 1.69575 -1.227617 1.6 0.8266781 -0.3559176 2.399 1.102238 -0.7950175 1.8 1.102238 -0.3559176 1.8 0.3617441 -1.093518 2.399 1.102238 -0.7950175 1.8 0.8266781 -0.3559176 2.399 0.4823241 -1.778477 1.8 1.36834e-7 -1.293737 2.399 0.4823241 -1.778477 1.8 0.3617441 -1.093518 2.399 1.36834e-7 -2.045438 1.8 -0.3617438 -1.093518 2.399 1.36834e-7 -2.045438 1.8 1.36834e-7 -1.293737 2.399 -0.4823238 -1.778477 1.8 -0.3617438 -1.093518 2.399 -1.102238 -0.7950175 1.8 -0.4823238 -1.778477 1.8 -0.8266779 -0.3559176 2.399 -0.3617438 -1.093518 2.399 0.8266781 -0.3559176 2.399 -0.8266779 -0.3559176 2.399 1.36834e-7 -1.293737 2.399 0.3617441 -1.093518 2.399 -1.102238 -0.3559176 1.8 -1.102238 -0.7950175 1.8 -0.8266779 -0.3559176 2.399 0.8266781 -0.3559176 2.399 -0.8266779 -0.3559176 2.399 -0.8266779 1.164156 2.399 0.8266781 1.164156 2.399 0.8266781 -0.3559176 2.399 1.102238 1.664157 1.8 0.8266781 1.164156 2.399 1.102238 -0.3559176 1.8 1.102238 1.664157 1.8 -0.8266779 1.164156 2.399 0.8266781 1.164156 2.399 -1.102238 1.664157 1.8 1.102238 2.868143 3 0.8022381 2.468142 1.8 1.102238 2.468142 1.8 0.8022381 2.768142 2.7 -0.8022379 2.768142 2.7 -1.102238 2.868143 3 -1.102238 2.468142 1.8 -0.8022379 2.468142 1.8 -0.8022379 2.968142 1.8 -0.8022379 2.768142 2.7 -0.8022379 2.468142 1.8 -0.8022379 3.268142 2.7 -0.8022379 2.968142 1.8 -1.102238 3.368143 3 -0.8022379 3.268142 2.7 -1.102238 2.968142 1.8 0.8022381 2.768142 2.7 0.8022381 2.968142 1.8 0.8022381 2.468142 1.8 0.8022381 3.268142 2.7 -0.8022379 2.768142 2.7 0.8022381 3.268142 2.7 0.8022381 2.768142 2.7 -0.8022379 3.268142 2.7 0.8022381 3.268142 2.7 1.102238 3.368143 3 1.102238 2.968142 1.8 0.8022381 2.968142 1.8 1.102238 2.968142 1.8 1.102238 2.868143 3 1.102238 2.468142 1.8 1.102238 3.368143 3 -1.102238 3.368143 3 1.102238 2.868143 3 1.102238 3.368143 3 -1.102238 2.868143 3 -1.102238 2.968142 1.8 -1.102238 2.868143 3 -1.102238 3.368143 3 -1.102238 2.468142 1.8 -0.8266779 1.164156 2.399 -1.102238 -0.3559176 1.8 -0.8266779 -0.3559176 2.399 -1.102238 1.664157 1.8 -1.102238 2.468142 1.8 -0.8022379 2.468142 1.8 -0.8022379 2.968142 1.8 0.8022381 2.468142 1.8 1.102238 2.468142 1.8 -1.102238 2.968142 1.8 0.8022381 2.968142 1.8 1.102238 2.968142 1.8</float_array>
+          <technique_common>
+            <accessor source="#Mesh1_Group1_Model_1-mesh-positions-array" count="222" stride="3">
+              <param name="X" type="float"/>
+              <param name="Y" type="float"/>
+              <param name="Z" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="Mesh1_Group1_Model_1-mesh-normals">
+          <float_array id="Mesh1_Group1_Model_1-mesh-normals-array" count="369">0.2212894 -0.8125379 -0.5392711 0.3544659 -0.863941 -0.3577151 0.6484157 -0.675471 -0.3511354 0.8004003 -0.579115 0.154872 0.9240899 -0.03055113 -0.3809523 0.9200505 -0.02954447 -0.3906844 0.9245606 -0.03066992 -0.379799 0.9197186 -0.02946275 -0.3914711 0.03026527 -0.00509417 -0.999529 0 0 -1 -0.01808375 0.007780373 -0.9998062 0 -0.004180431 -0.9999914 -0.9240651 -0.029594 -0.3810878 -0.9200519 -0.03042972 -0.3906134 -0.9242513 -0.0295546 -0.3806391 -0.9198509 -0.0304709 -0.3910831 -0.9978132 -0.03460645 0.05631381 -0.9901961 0 -0.1396851 -0.8041464 -0.5822765 0.1195945 -0.8456949 -0.5330703 -0.02522212 -0.4324874 -0.8926935 -0.1267009 -0.4268929 -0.8944119 -0.1333786 -0.4832925 -0.8731467 -0.0635876 -0.3722102 -0.9071894 -0.1961297 -0.3544659 -0.8639412 -0.3577146 -0.2212894 -0.8125381 -0.5392709 -0.6484157 -0.675471 -0.3511354 -0.8004005 -0.5791149 0.1548717 0.4324874 -0.8926935 -0.1267008 0.4268929 -0.894412 -0.1333785 0.3722102 -0.9071894 -0.1961297 0.4832926 -0.8731467 -0.06358742 0.845695 -0.5330703 -0.025222 0.8041464 -0.5822765 0.1195945 0.990196 0 -0.139685 0.9978132 -0.03460639 0.05631381 0 1 0 0 1 -6.51364e-7 0 0.9143953 -0.4048224 0 0.9143947 -0.4048241 0 1 -1.33568e-6 0 1 1.40598e-6 0 1 3.51494e-7 -0.3193336 0 0.9476425 -0.3197686 0 0.9474958 -0.3192518 0 0.9476699 -0.3193343 0 0.9476422 -0.9760001 0 0.2177699 -0.9760001 0 0.2177701 -0.799037 -0.5036623 0.3284268 -0.799036 -0.5036595 0.3284335 -0.4361897 -0.7880539 0.4344075 -0.4361911 -0.7880498 0.4344134 0.4361883 -0.7880512 0.4344137 0.4361925 -0.7880522 0.4344076 0.7990362 -0.5036595 0.3284333 0.799037 -0.5036625 0.3284265 0.9760001 0 0.2177699 0.9760001 0 0.21777 0.9760002 0 0.21777 0.9760001 0 0.2177699 0.319334 0 0.9476422 0.319334 0 0.9476423 0.3193349 0 0.9476419 0.3193358 0 0.9476417 0.319333 0 0.9476427 0.319333 0 0.9476426 0.3193328 0 0.9476426 0.3193333 0 0.9476425 0 0 1 -4.76718e-5 1 0 -4.79658e-5 1 0 0 1 -2.16304e-6 -4.79658e-5 1 0 -0.3193297 -4.54545e-5 0.9476437 0.9476437 -4.54545e-5 0.3193297 -0.3193298 -4.54545e-5 0.9476436 -0.2227466 -0.1404055 0.9647126 -0.2227461 -0.1404054 0.9647127 -0.2227452 -0.1404052 0.9647129 -0.2227471 -0.1404055 0.9647125 -0.09802633 -0.1771023 0.9792985 -0.09802353 -0.1771012 0.9792991 0.09802603 -0.1771011 0.9792988 0.09802401 -0.1771028 0.9792987 0.2227461 -0.1404054 0.9647126 0.2227466 -0.1404055 0.9647125 0.2227452 -0.1404053 0.9647129 0.2227472 -0.1404056 0.9647125 0.908479 0 0.4179307 0.6670235 -0.4204472 0.6150641 0.6670231 -0.4204514 0.6150618 0.3260775 -0.5891351 0.7393195 0.3260786 -0.5891344 0.7393196 -0.3260778 -0.5891345 0.7393199 -0.3260784 -0.5891349 0.7393193 -0.667023 -0.4204514 0.6150617 -0.6670234 -0.4204474 0.6150642 0 0 1 3.43081e-7 0 1 -0.908479 0 0.4179307 0.9084789 0 0.4179307 0.9084789 0 0.4179308 0 0.7676952 0.6408152 0 0.7676949 0.6408155 0 -0.9486833 0.3162277 0 -0.9486833 0.3162277 0 -0.9486833 0.3162277 0 -0.9486835 0.3162274 0 -0.948683 0.3162288 0 -0.9486829 0.3162289 0 -0.9486833 0.3162277 1 0 0 0 0.9486833 -0.3162277 0 0.9486834 -0.3162276 0 0.9486835 -0.3162273 -1 0 0 0 0.9486832 -0.3162283 0 0.9486832 -0.3162284 0 0.9486833 -0.3162277 0 0.9486833 -0.3162277 -0.9084789 0 0.4179307 -0.9084789 0 0.4179308</float_array>
+          <technique_common>
+            <accessor source="#Mesh1_Group1_Model_1-mesh-normals-array" count="123" stride="3">
+              <param name="X" type="float"/>
+              <param name="Y" type="float"/>
+              <param name="Z" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="Mesh1_Group1_Model_1-mesh-map-0">
+          <float_array id="Mesh1_Group1_Model_1-mesh-map-0-array" count="744">-14.1628 38.434 -36.9745 66.3048 -22.1765 38.434 -36.9745 66.3048 -14.1628 38.434 -23.6182 66.3048 -14.819 26.0998 -52.8879 46.5459 -31.7185 26.0998 -52.8879 46.5459 -14.819 26.0998 -24.7221 46.5459 -27.6169 12.8975 27.6169 26.1678 -46.0563 26.1678 27.6169 26.1678 -27.6169 12.8975 27.6169 12.8975 -7.01139 -41.9133 -16.0228 27.6169 -16.0228 -27.6169 0 -45.7941 -16.0228 27.6169 -7.01139 -41.9133 7.01139 -41.9133 -16.0228 27.6169 0 -45.7941 16.0228 -27.6169 -16.0228 27.6169 7.01139 -41.9133 -16.0228 27.6169 16.0228 -27.6169 16.0228 27.6169 46.0563 26.1678 -27.6169 12.8975 27.6169 12.8975 -27.6169 12.8975 46.0563 26.1678 -27.6169 26.1678 46.0563 19.548 -27.6169 37.4119 -27.6169 19.548 -27.6169 37.4119 46.0563 19.548 57.324 37.4119 52.8879 36.2561 29.7573 56.7677 24.7221 36.2561 29.7573 56.7677 52.8879 36.2561 66.8176 56.7677 23.6182 55.6976 47.064 79.7867 29.49 79.7867 47.064 79.7867 23.6182 55.6976 36.9745 55.6976 14.1628 38.434 36.9745 66.3048 23.6182 66.3048 36.9745 66.3048 14.1628 38.434 22.1765 38.434 52.8879 46.5459 14.819 26.0998 31.7185 26.0998 14.819 26.0998 52.8879 46.5459 24.7221 46.5459 -23.6182 55.6976 -47.064 79.7867 -36.9745 55.6976 -47.064 79.7867 -23.6182 55.6976 -29.49 79.7867 -52.8879 36.2561 -29.7573 56.7677 -66.8176 56.7677 -29.7573 56.7677 -52.8879 36.2561 -24.7221 36.2561 -46.0563 19.548 27.6169 37.4119 -57.324 37.4119 27.6169 37.4119 -46.0563 19.548 27.6169 19.548 -26.7047 7.87402 35.1378 23.622 -35.1378 23.622 35.1378 23.622 -26.7047 7.87402 26.7047 7.87402 -16.0228 0 26.7047 7.87402 -26.7047 7.87402 26.7047 7.87402 -16.0228 0 16.0228 0 33.3809 31.4961 -35.1378 23.622 35.1378 23.622 -35.1378 23.622 33.3809 31.4961 -33.3809 31.4961 -33.3809 31.4961 33.3809 31.4961 21.6976 35.4331 -27.6169 -21.5754 46.4608 -9.246581 -27.6169 -9.246581 46.4608 -9.246581 -27.6169 -21.5754 54.9766 -21.5754 -27.6169 15.4032 54.9766 23.4708 -27.6169 23.4708 54.9766 23.4708 -27.6169 15.4032 57.324 15.4032 29.7573 2.50924 63.9156 10.8457 28.7083 10.8457 63.9156 10.8457 29.7573 2.50924 66.8176 2.50924 29.49 -15.6617 44.962 -6.91968 28.2667 -6.91968 44.962 -6.91968 29.49 -15.6617 47.064 -15.6617 -47.064 -15.6617 -28.2667 -6.91968 -44.962 -6.91968 -28.2667 -6.91968 -47.064 -15.6617 -29.49 -15.6617 -29.7573 2.50924 -63.9156 10.8457 -66.8176 2.50924 -63.9156 10.8457 -29.7573 2.50924 -28.7083 10.8457 27.6169 15.4032 -54.9766 23.4708 -57.324 15.4032 -54.9766 23.4708 27.6169 15.4032 27.6169 23.4708 27.6169 -9.246581 -54.9766 -21.5754 27.6169 -21.5754 17.7744 -9.246581 -54.9766 -21.5754 27.6169 -9.246581 1.94793 -9.246581 -54.9766 -21.5754 17.7744 -9.246581 -37.8173 -9.246581 -54.9766 -21.5754 1.94793 -9.246581 -54.9766 -21.5754 -37.8173 -9.246581 -46.4608 -9.246581 21.6976 1.94793 -21.6976 17.7744 -21.6976 1.94793 -21.6976 17.7744 21.6976 1.94793 -15.7921 17.7744 -15.7921 17.7744 21.6976 1.94793 -15.7921 27.6169 -15.7921 27.6169 21.6976 1.94793 15.7921 17.7744 15.7921 17.7744 21.6976 1.94793 21.6976 17.7744 -21.6976 35.4331 21.6976 35.4331 15.7921 35.4331 -33.3809 31.4961 21.6976 35.4331 -21.6976 35.4331 -21.6976 35.4331 15.7921 35.4331 -15.7921 35.4331 15.7921 27.6169 -15.7921 27.6169 15.7921 17.7744 -27.6169 -9.246581 -1.94793 -9.246581 -17.7744 -9.246581 -27.6169 -9.246581 37.8173 -9.246581 -1.94793 -9.246581 -27.6169 -9.246581 46.4608 -9.246581 37.8173 -9.246581 27.7343 -32.2784 63.9156 -47.2306 50.619 -32.2784 63.9156 -47.2306 27.7343 -32.2784 28.7083 -47.2306 44.962 -73.1755 23.5676 -53.7259 28.2667 -73.1755 23.5676 -53.7259 44.962 -73.1755 34.4196 -53.7259 -28.2667 -73.1755 -34.4196 -53.7259 -44.962 -73.1755 -34.4196 -53.7259 -28.2667 -73.1755 -23.5676 -53.7259 -63.9156 -47.2306 -27.7343 -32.2784 -50.619 -32.2784 -27.7343 -32.2784 -63.9156 -47.2306 -28.7083 -47.2306 -37.8173 36.1016 -46.4608 23.1223 -37.8173 23.1223 -40.4782 16.3656 -27.7343 1.41104 -23.3147 16.3656 -27.7343 1.41104 -40.4782 16.3656 -50.619 1.41104 -27.2538 -4.60419 -23.5676 -22.1155 -19.1148 -4.60419 -23.5676 -22.1155 -27.2538 -4.60419 -34.4196 -22.1155 19.1148 -4.60419 34.4196 -22.1155 27.2538 -4.60419 34.4196 -22.1155 19.1148 -4.60419 23.5676 -22.1155 40.4782 16.3656 27.7343 1.41104 50.619 1.41104 27.7343 1.41104 40.4782 16.3656 23.3147 16.3656 -7.12094 -52.3371 16.2732 -37.8173 -16.2732 -37.8173 16.2732 -37.8173 -7.12094 -52.3371 0 -56.2785 16.2732 -37.8173 0 -56.2785 7.12094 -52.3371 37.8173 23.1223 46.4608 23.1223 37.8173 36.1016 16.2732 -37.8173 -16.2732 -7.89459 -16.2732 -37.8173 -16.2732 -7.89459 16.2732 -37.8173 16.2732 -7.89459 -37.8173 36.1016 1.94793 23.1223 -7.89459 36.1016 1.94793 23.1223 -37.8173 36.1016 -37.8173 23.1223 -21.6976 25.9537 16.2732 41.3131 -16.2732 41.3131 16.2732 41.3131 -21.6976 25.9537 21.6976 25.9537 21.6976 64.1353 15.7921 39.2355 21.6976 39.2355 15.7921 39.2355 21.6976 64.1353 15.7921 57.9104 15.7921 57.9104 21.6976 64.1353 -15.7921 57.9104 -21.6976 64.1353 -15.7921 57.9104 21.6976 64.1353 -21.6976 39.2355 -15.7921 57.9104 -21.6976 64.1353 -15.7921 57.9104 -21.6976 39.2355 -15.7921 39.2355 27.6169 35.4331 23.6799 53.1496 17.7744 35.4331 23.6799 53.1496 27.6169 35.4331 33.5224 53.1496 15.7921 42.348 21.6976 67.24781 15.7921 61.0229 21.6976 67.24781 15.7921 42.348 21.6976 42.348 -23.6799 53.1496 -27.6169 35.4331 -17.7744 35.4331 -27.6169 35.4331 -23.6799 53.1496 -33.5224 53.1496 15.7921 23.6799 -15.7921 33.5224 -15.7921 23.6799 -15.7921 33.5224 15.7921 23.6799 15.7921 33.5224 15.7921 61.0229 21.6976 67.24781 -15.7921 61.0229 -21.6976 67.24781 -15.7921 61.0229 21.6976 67.24781 -21.6976 42.348 -15.7921 61.0229 -21.6976 67.24781 -15.7921 61.0229 -21.6976 42.348 -15.7921 42.348 27.6169 35.4331 25.6484 59.0551 17.7744 35.4331 25.6484 59.0551 27.6169 35.4331 35.4909 59.0551 -21.6976 35.4909 21.6976 25.6484 21.6976 35.4909 21.6976 25.6484 -21.6976 35.4909 -21.6976 25.6484 -27.6169 35.4331 -25.6484 59.0551 -35.4909 59.0551 -25.6484 59.0551 -27.6169 35.4331 -17.7744 35.4331 7.89459 36.1016 37.8173 23.1223 37.8173 36.1016 37.8173 23.1223 7.89459 36.1016 -1.94793 23.1223 -15.7921 17.7744 -21.6976 27.6169 -21.6976 17.7744 -21.6976 27.6169 -15.7921 17.7744 -15.7921 27.6169 15.7921 27.6169 21.6976 17.7744 21.6976 27.6169 21.6976 17.7744 15.7921 27.6169 15.7921 17.7744</float_array>
+          <technique_common>
+            <accessor source="#Mesh1_Group1_Model_1-mesh-map-0-array" count="372" stride="2">
+              <param name="S" type="float"/>
+              <param name="T" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <vertices id="Mesh1_Group1_Model_1-mesh-vertices">
+          <input semantic="POSITION" source="#Mesh1_Group1_Model_1-mesh-positions"/>
+        </vertices>
+        <triangles material="InteractiveRed-material" count="124">
+          <input semantic="VERTEX" source="#Mesh1_Group1_Model_1-mesh-vertices" offset="0"/>
+          <input semantic="NORMAL" source="#Mesh1_Group1_Model_1-mesh-normals" offset="1"/>
+          <input semantic="TEXCOORD" source="#Mesh1_Group1_Model_1-mesh-map-0" offset="2" set="0"/>
+          <p>0 0 0 1 0 1 2 0 2 1 1 3 0 1 4 3 1 5 4 2 6 5 2 7 6 2 8 5 3 9 4 3 10 7 3 11 8 4 12 9 5 13 10 6 14 9 5 15 8 4 16 11 7 17 12 8 18 13 8 19 14 8 20 15 9 21 13 9 22 12 9 23 16 9 24 13 9 25 15 9 26 17 10 27 13 10 28 16 10 29 13 11 30 17 11 31 18 11 32 19 12 33 20 13 34 21 14 35 20 13 36 19 12 37 22 15 38 23 16 39 24 16 40 25 16 41 24 17 42 23 17 43 26 17 44 27 18 45 28 18 46 29 18 47 28 19 48 27 19 49 30 19 50 31 20 51 32 21 52 33 22 53 32 21 54 31 20 55 34 23 56 35 24 57 36 24 58 37 24 59 36 25 60 35 25 61 38 25 62 39 26 63 40 26 64 41 26 65 40 27 66 39 27 67 42 27 68 43 28 69 44 29 70 45 30 71 44 29 72 43 28 73 46 31 74 47 32 75 48 32 76 49 32 77 48 33 78 47 33 79 50 33 80 51 34 81 52 34 82 53 34 83 52 35 84 51 35 85 54 35 86 55 36 87 56 36 88 57 36 89 56 37 90 55 37 91 58 37 92 59 38 93 58 38 94 55 38 95 58 39 96 59 39 97 60 39 98 63 40 99 62 40 100 61 40 101 62 41 102 63 41 103 64 41 104 64 42 105 63 42 106 65 42 107 66 43 108 67 44 109 68 45 110 67 44 111 66 43 112 69 46 113 70 47 114 71 47 115 72 47 116 71 48 117 70 48 118 73 48 119 74 49 120 75 49 121 76 49 122 75 50 123 74 50 124 77 50 125 78 51 126 79 51 127 80 51 128 79 52 129 78 52 130 81 52 131 82 53 132 83 53 133 84 53 134 83 54 135 82 54 136 85 54 137 86 55 138 87 55 139 88 55 140 87 56 141 86 56 142 89 56 143 90 57 144 91 58 145 92 59 146 91 58 147 90 57 148 93 60 149 94 61 150 95 61 151 96 62 152 97 63 153 95 61 154 94 61 155 98 64 156 95 64 157 97 64 158 99 65 159 95 66 160 98 67 161 95 66 162 99 65 163 100 68 164 101 69 165 102 69 166 103 69 167 102 69 168 101 69 169 104 69 170 104 69 171 101 69 172 105 69 173 105 69 174 101 69 175 106 69 176 106 69 177 101 69 178 107 69 179 108 36 180 65 70 181 109 71 182 64 72 183 65 72 184 108 72 185 108 36 186 109 71 187 110 73 188 111 69 189 105 69 190 106 69 191 68 45 192 112 74 193 113 75 194 68 45 195 114 76 196 112 74 197 68 45 198 67 44 199 114 76 200 115 77 201 116 78 202 117 79 203 116 78 204 115 77 205 118 80 206 119 81 207 120 81 208 121 81 209 120 82 210 119 82 211 122 82 212 123 83 213 124 83 214 125 83 215 124 84 216 123 84 217 126 84 218 127 85 219 128 86 220 129 87 221 128 86 222 127 85 223 130 88 224 131 89 225 132 89 226 133 89 227 134 90 228 135 90 229 136 90 230 135 91 231 134 91 232 137 91 233 138 92 234 139 92 235 140 92 236 139 93 237 138 93 238 141 93 239 142 94 240 143 94 241 144 94 242 143 95 243 142 95 244 145 95 245 146 96 246 147 96 247 148 96 248 147 97 249 146 97 250 149 97 251 150 69 252 151 69 253 152 69 254 151 98 255 150 98 256 153 98 257 151 99 258 153 99 259 154 99 260 155 100 261 156 100 262 157 100 263 158 69 264 160 69 265 159 69 266 160 69 267 158 69 268 161 69 269 162 101 270 163 101 271 164 101 272 163 102 273 162 102 274 165 102 275 166 103 276 167 103 277 168 103 278 167 104 279 166 104 280 169 104 281 170 105 282 171 106 283 172 107 284 171 106 285 170 105 286 173 108 287 173 108 288 170 105 289 174 109 290 175 110 291 174 109 292 170 105 293 176 105 294 174 109 295 175 110 296 174 109 297 176 105 298 177 111 299 178 112 300 179 112 301 180 112 302 179 112 303 178 112 304 181 112 305 182 113 306 183 114 307 184 115 308 183 114 309 182 113 310 185 113 311 186 116 312 187 116 313 188 116 314 187 116 315 186 116 316 189 116 317 190 9 318 191 9 319 192 9 320 191 9 321 190 9 322 193 9 323 184 115 324 183 114 325 194 117 326 195 118 327 194 117 328 183 114 329 196 119 330 194 117 331 195 118 332 194 117 333 196 119 334 197 120 335 198 112 336 199 112 337 200 112 338 199 112 339 198 112 340 201 112 341 202 69 342 203 69 343 204 69 344 203 69 345 202 69 346 205 69 347 206 116 348 207 116 349 208 116 350 207 116 351 206 116 352 209 116 353 210 121 354 211 121 355 212 121 356 211 122 357 210 122 358 213 122 359 215 69 360 219 69 361 214 69 362 219 69 363 215 69 364 216 69 365 220 69 366 218 69 367 221 69 368 218 69 369 220 69 370 217 69 371</p>
+        </triangles>
+      </mesh>
+    </geometry>
+    <geometry id="Cube_001-mesh" name="Cube.001">
+      <mesh>
+        <source id="Cube_001-mesh-positions">
+          <float_array id="Cube_001-mesh-positions-array" count="51">-1.554587 -3.327249 1.217115 -0.8379113 -3.199351 1.635984 -2 3.004421 0.8137459 -2 2.984745 1.626146 1.554587 -3.327249 1.217115 0.8379115 -3.199351 1.635984 2 3.004421 0.8137459 2 2.984745 1.626146 -0.8341614 -1.28556 2.393531 -0.8341614 1.169336 2.364016 0.8341616 1.169336 2.364016 0.8341616 -1.28556 2.393531 -1.725639 -2.667086 0.8137459 1.36834e-7 2.984745 1.626146 1.72564 -2.667086 0.8137459 -1.975116 -1.32069 1.631065 1.975116 -1.32069 1.631065</float_array>
+          <technique_common>
+            <accessor source="#Cube_001-mesh-positions-array" count="17" stride="3">
+              <param name="X" type="float"/>
+              <param name="Y" type="float"/>
+              <param name="Z" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="Cube_001-mesh-normals">
+          <float_array id="Cube_001-mesh-normals-array" count="87">-0.5558079 0.009994029 0.8312508 0 0.9997069 0.02421271 0.5209673 -0.3132765 0.7940095 0 -0.9564092 0.29203 0 -0.5213904 -0.8533183 0 -0.3680505 0.9298059 0 0.3765351 0.9264024 0 0.01202195 0.9999278 0 0 -1 -0.4495213 -0.2698778 0.851526 0.4495213 -0.2698778 0.851526 0.5371739 -0.002140939 0.8434689 -0.5209673 -0.3132765 0.7940095 -0.9745129 -0.2164185 0.05905586 0.974513 -0.2164187 0.05905592 0.974411 -0.04713737 -0.2197759 -0.9999833 -0.005779683 -1.39986e-4 -0.5371739 -0.002140998 0.8434688 0 0.9997069 0.02421331 0 0.9997069 0.02421271 0 -0.956409 0.2920307 0 -0.5213901 -0.8533185 0 -0.3680503 0.9298059 0 0.376535 0.9264024 0 0.376535 0.9264024 0 0.01202195 0.9999278 0.5558079 0.00999391 0.8312508 0.9999833 -0.005779802 -1.39988e-4 -0.974411 -0.04713737 -0.2197759</float_array>
+          <technique_common>
+            <accessor source="#Cube_001-mesh-normals-array" count="29" stride="3">
+              <param name="X" type="float"/>
+              <param name="Y" type="float"/>
+              <param name="Z" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="Cube_001-mesh-map-0">
+          <float_array id="Cube_001-mesh-map-0-array" count="180">0.625 0.1666666 0.625 0.125 0.625 0.08333331 0.625 0.375 0.625 0.5 0.375 0.5 0.625 0.625 0.625 0.6666666 0.625 0.75 0.625 0.75 0.375 1 0.375 0.75 0.375 0.625 0.125 0.75 0.125 0.625 0.875 0.6666666 0.625 0.75 0.625 0.6666666 0.75 0.5 0.875 0.5833333 0.625 0.5833333 0.875 0.5833333 0.625 0.6666666 0.625 0.5833333 0.375 0.5 0.125 0.625 0.125 0.5 0.375 0 0.625 0 0.625 0.125 0.375 0.75 0.625 0.625 0.625 0.75 0.625 0.5833333 0.625 0.625 0.625 0.5 0.625 0 0.625 0.08333331 0.625 0.125 0.375 0.125 0.375 0 0.625 0.125 0.375 0.625 0.625 0.625 0.375 0.75 0.375 0.5 0.625 0.625 0.375 0.625 0.375 0.25 0.625 0.125 0.625 0.25 0.625 0.1666666 0.625 0.25 0.625 0.125 0.375 0.5 0.375 0.25 0.625 0.375 0.375 0.25 0.625 0.25 0.625 0.375 0.625 0.75 0.625 1 0.375 1 0.375 0.625 0.375 0.75 0.125 0.75 0.875 0.6666666 0.875 0.75 0.625 0.75 0.625 0.5833333 0.625 0.5 0.75 0.5 0.75 0.5 0.875 0.5 0.875 0.5833333 0.875 0.5833333 0.875 0.6666666 0.625 0.6666666 0.375 0.5 0.375 0.625 0.125 0.625 0.625 0.5833333 0.625 0.6666666 0.625 0.625 0.375 0.5 0.625 0.5 0.625 0.625 0.375 0.25 0.375 0.125 0.625 0.125</float_array>
+          <technique_common>
+            <accessor source="#Cube_001-mesh-map-0-array" count="90" stride="2">
+              <param name="S" type="float"/>
+              <param name="T" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <vertices id="Cube_001-mesh-vertices">
+          <input semantic="POSITION" source="#Cube_001-mesh-positions"/>
+        </vertices>
+        <triangles count="30">
+          <input semantic="VERTEX" source="#Cube_001-mesh-vertices" offset="0"/>
+          <input semantic="NORMAL" source="#Cube_001-mesh-normals" offset="1"/>
+          <input semantic="TEXCOORD" source="#Cube_001-mesh-map-0" offset="2" set="0"/>
+          <p>9 0 0 15 0 1 8 0 2 13 1 3 7 1 4 6 1 5 16 2 6 11 2 7 5 2 8 5 3 9 0 3 10 4 3 11 14 4 12 0 4 13 12 4 14 8 5 15 5 5 16 11 5 17 13 6 18 9 6 19 10 6 20 9 7 21 11 7 22 10 7 23 6 8 24 12 8 25 2 8 26 0 9 27 1 9 28 15 9 29 4 10 30 16 10 31 5 10 32 10 11 33 16 11 34 7 11 35 1 12 36 8 12 37 15 12 38 12 13 39 0 13 40 15 13 41 14 14 42 16 14 43 4 14 44 6 15 45 16 15 46 14 15 47 2 16 48 15 16 49 3 16 50 9 17 51 3 17 52 15 17 53 6 18 54 2 18 55 13 18 56 2 19 57 3 19 58 13 19 59 5 20 60 1 20 61 0 20 62 14 21 63 4 21 64 0 21 65 8 22 66 1 22 67 5 22 68 10 23 69 7 23 70 13 23 71 13 24 72 3 24 73 9 24 74 9 25 75 8 25 76 11 25 77 6 8 78 14 8 79 12 8 80 10 26 81 11 26 82 16 26 83 6 27 84 7 27 85 16 27 86 2 28 87 12 28 88 15 28 89</p>
+        </triangles>
+      </mesh>
+    </geometry>
+  </library_geometries>
+  <library_visual_scenes>
+    <visual_scene id="Scene" name="Scene">
+      <node id="Cam" name="Cam" type="NODE">
+        <matrix sid="transform">1 0 0 -1.30003e-15 0 1 0 -8.471325 0 0 1 5.85482 0 0 0 1</matrix>
+      </node>
+      <node id="Eye" name="Eye" type="NODE">
+        <matrix sid="transform">1 0 0 -1.30395e-15 0 1 0 -8.471325 0 0 1 5.872447 0 0 0 1</matrix>
+      </node>
+      <node id="Mount0" name="Mount0" type="NODE">
+        <matrix sid="transform">1 0 0 -3.45175e-16 0 1 0 0.2570481 0 0 1 1.554529 0 0 0 1</matrix>
+      </node>
+      <node id="BodyModel" name="BodyModel" type="NODE">
+        <matrix sid="transform">-1 8.74228e-8 0 0 -8.74228e-8 -1 0 0 0 0 1 0 0 0 0 1</matrix>
+        <instance_geometry url="#Mesh1_Group1_Model_1-mesh" name="BodyModel">
+          <bind_material>
+            <technique_common>
+              <instance_material symbol="InteractiveRed-material" target="#InteractiveRed-material">
+                <bind_vertex_input semantic="UVMap" input_semantic="TEXCOORD" input_set="0"/>
+              </instance_material>
+            </technique_common>
+          </bind_material>
+        </instance_geometry>
+      </node>
+      <node id="colMesh_1" name="colMesh_1" type="NODE">
+        <matrix sid="transform">-1 8.74228e-8 0 0 -8.74228e-8 -1 0 0 0 0 1 0 0 0 0 1</matrix>
+        <instance_geometry url="#Cube_001-mesh" name="colMesh_1"/>
+      </node>
+    </visual_scene>
+  </library_visual_scenes>
+  <scene>
+    <instance_visual_scene url="#Scene"/>
+  </scene>
+</COLLADA>
\ No newline at end of file
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/hoverboat.tscript b/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/hoverboat.tscript
new file mode 100644
index 000000000..dc5c5a796
--- /dev/null
+++ b/Templates/BaseGame/game/data/Prototyping/shapes/Vehicles/hoverboat.tscript
@@ -0,0 +1,11 @@
+
+singleton TSShapeConstructor(hoverboatdae)
+{
+   baseShapeAsset = "./hoverboat.dae";
+   singleDetailSize = "0";
+   flipUVCoords = "0";
+   JoinIdenticalVerts = "0";
+   reverseWindingOrder = "0";
+   removeRedundantMats = "0";
+   animFPS = "2";
+};
diff --git a/Templates/BaseGame/game/data/Prototyping/shapes/materials.tscript b/Templates/BaseGame/game/data/Prototyping/shapes/materials.tscript
deleted file mode 100644
index 482e431af..000000000
--- a/Templates/BaseGame/game/data/Prototyping/shapes/materials.tscript
+++ /dev/null
@@ -1,8 +0,0 @@
-
-singleton Material(DetailBlue)
-{
-   mapTo = "DetailBlue";
-   diffuseColor[0] = "0.8 0.8 0.8 1";
-   DiffuseMap[0] = "data/Prototyping/Materials/DetailBlue.png";
-   translucentBlendOp = "None";
-};

From 5892ff7428fbe5d89f310da9cbe05573a0ea70af Mon Sep 17 00:00:00 2001
From: Areloch <Areloch@gmail.com>
Date: Sun, 12 Sep 2021 05:32:30 -0500
Subject: [PATCH 072/399] Adds handling for drag-and-drop import of files even
 if asset browser is not open. If world or gui editor are the active controls,
 then it will injest the incoming files and prompt what their destination
 module and path will be via a new popup window. After clicking OK, import
 continues into that destination. Cleaned up commented lines from
 drag-and-drop functions. Fixed issue where material icon on buttons in the
 object creator windows wouldn't display. Fixed issue where it wasn't
 correctly binding cloud textures for BasicClouds object or ripple/foam/depth
 textures for water objects when newly created Fixed issue where when
 double-clicking on a datablock type in the datablock editor, wasn't correctly
 going through the module selection process, making an invalid destination.
 Added handling for Trigger object creation via TriggerData class Standardized
 double-click handling of datablock entries in AB to respect double click
 action mode, and properly either open the datablock editor to the given
 datablock, or spawn it. Made Create New Datablock prompt window indicate the
 destination module to be clearer where it's going if force-prompt of module
 setting is off.

---
 .../assetBrowser/guis/setAssetTarget.gui      | 220 ++++++++++++++++++
 .../game/tools/assetBrowser/main.tscript      |   2 +
 .../scripts/addModuleWindow.tscript           |   7 +-
 .../assetBrowser/scripts/assetImport.tscript  |  90 +++----
 .../assetTypes/datablockObjects.tscript       |  17 +-
 .../assetBrowser/scripts/creator.tscript      |   2 -
 .../scripts/setAssetTarget.tscript            |  43 ++++
 .../DatablockEditorCreatePrompt.ed.gui        |  26 +--
 .../DatablockEditorTreeWindow.ed.gui          |   2 +-
 .../datablockEditor/datablockEditor.tscript   |   2 +
 .../scripts/input/dragDropEvents.ed.tscript   |   1 -
 .../guiEditor/scripts/guiEditor.ed.tscript    |  58 +++++
 .../scripts/guiEditorUndo.ed.tscript          |   2 +-
 .../worldEditor/gui/objectBuilderGui.ed.gui   |  29 ++-
 .../scripts/editors/worldEditor.ed.tscript    |  58 +++++
 15 files changed, 469 insertions(+), 90 deletions(-)
 create mode 100644 Templates/BaseGame/game/tools/assetBrowser/guis/setAssetTarget.gui
 create mode 100644 Templates/BaseGame/game/tools/assetBrowser/scripts/setAssetTarget.tscript

diff --git a/Templates/BaseGame/game/tools/assetBrowser/guis/setAssetTarget.gui b/Templates/BaseGame/game/tools/assetBrowser/guis/setAssetTarget.gui
new file mode 100644
index 000000000..700058f74
--- /dev/null
+++ b/Templates/BaseGame/game/tools/assetBrowser/guis/setAssetTarget.gui
@@ -0,0 +1,220 @@
+//--- OBJECT WRITE BEGIN ---
+$guiContent = new GuiControl(AssetBrowser_setAssetTarget) {
+   position = "0 0";
+   extent = "1024 768";
+   minExtent = "8 2";
+   horizSizing = "right";
+   vertSizing = "bottom";
+   profile = "ToolsGuiDefaultNonModalProfile";
+   visible = "1";
+   active = "1";
+   tooltipProfile = "GuiToolTipProfile";
+   hovertime = "1000";
+   isContainer = "1";
+   canSave = "1";
+   canSaveDynamicFields = "1";
+
+   new GuiWindowCtrl(AssetBrowser_setAssetTargetWindow) {
+      text = "Set Asset Destination";
+      resizeWidth = "1";
+      resizeHeight = "1";
+      canMove = "1";
+      canClose = "1";
+      canMinimize = "0";
+      canMaximize = "0";
+      canCollapse = "0";
+      closeCommand = "Canvas.popDialog(AssetBrowser_setAssetTarget);";
+      edgeSnap = "1";
+      margin = "0 0 0 0";
+      padding = "0 0 0 0";
+      anchorTop = "1";
+      anchorBottom = "0";
+      anchorLeft = "1";
+      anchorRight = "0";
+      position = "328 311";
+      extent = "368 118";
+      minExtent = "48 92";
+      horizSizing = "center";
+      vertSizing = "center";
+      profile = "ToolsGuiWindowProfile";
+      visible = "1";
+      active = "1";
+      tooltipProfile = "ToolsGuiToolTipProfile";
+      hovertime = "1000";
+      isContainer = "1";
+      canSave = "1";
+      canSaveDynamicFields = "0";
+
+      new GuiTextCtrl() {
+         text = "Target Module:";
+         maxLength = "1024";
+         margin = "0 0 0 0";
+         padding = "0 0 0 0";
+         anchorTop = "1";
+         anchorBottom = "0";
+         anchorLeft = "1";
+         anchorRight = "0";
+         position = "12 29";
+         extent = "116 17";
+         minExtent = "8 2";
+         horizSizing = "right";
+         vertSizing = "bottom";
+         profile = "ToolsGuiTextProfile";
+         visible = "1";
+         active = "1";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "1";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      new GuiPopUpMenuCtrlEx() {
+         maxPopupHeight = "200";
+         sbUsesNAColor = "0";
+         reverseTextList = "0";
+         bitmapBounds = "16 16";
+         hotTrackCallback = "0";
+         maxLength = "1024";
+         margin = "0 0 0 0";
+         padding = "0 0 0 0";
+         anchorTop = "1";
+         anchorBottom = "0";
+         anchorLeft = "1";
+         anchorRight = "0";
+         position = "135 28";
+         extent = "202 18";
+         minExtent = "8 2";
+         horizSizing = "right";
+         vertSizing = "bottom";
+         profile = "ToolsGuiPopUpMenuProfile";
+         visible = "1";
+         active = "1";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "1";
+         internalName = "ModuleList";
+         class = "AssetBrowserModuleList";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      new GuiTextCtrl() {
+         text = "Target Path:";
+         maxLength = "1024";
+         margin = "0 0 0 0";
+         padding = "0 0 0 0";
+         anchorTop = "1";
+         anchorBottom = "0";
+         anchorLeft = "1";
+         anchorRight = "0";
+         position = "12 54";
+         extent = "116 17";
+         minExtent = "8 2";
+         horizSizing = "right";
+         vertSizing = "bottom";
+         profile = "ToolsGuiTextProfile";
+         visible = "1";
+         active = "1";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "1";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      new GuiTextEditCtrl() {
+         historySize = "0";
+         tabComplete = "0";
+         sinkAllKeyEvents = "0";
+         password = "0";
+         passwordMask = "*";
+         text = "data/";
+         maxLength = "1024";
+         margin = "0 0 0 0";
+         padding = "0 0 0 0";
+         anchorTop = "1";
+         anchorBottom = "0";
+         anchorLeft = "1";
+         anchorRight = "0";
+         position = "135 54";
+         extent = "201 18";
+         minExtent = "8 2";
+         horizSizing = "width";
+         vertSizing = "bottom";
+         profile = "ToolsGuiTextEditProfile";
+         visible = "1";
+         active = "0";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "1";
+         internalName = "targetPath";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      new GuiBitmapButtonCtrl() {
+         BitmapAsset = "ToolsModule:iconOpen_image";
+         bitmapMode = "Centered";
+         autoFitExtents = "0";
+         useModifiers = "0";
+         useStates = "1";
+         masked = "0";
+         groupNum = "-1";
+         buttonType = "PushButton";
+         useMouseEvents = "0";
+         position = "340 51";
+         extent = "22 22";
+         minExtent = "8 2";
+         horizSizing = "left";
+         vertSizing = "bottom";
+         profile = "ToolsGuiButtonProfile";
+         visible = "1";
+         active = "1";
+         command = "SelectAssetPath.showDialog(AssetBrowser.dirHandler.currentAddress, \"setAssetTargetUpdatePath\");\nSelectAssetPathWindow.selectWindow();";
+         tooltipProfile = "GuiToolTipProfile";
+         tooltip = "New Module";
+         hovertime = "1000";
+         isContainer = "0";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      new GuiButtonCtrl() {
+         text = "Done";
+         groupNum = "-1";
+         buttonType = "PushButton";
+         useMouseEvents = "0";
+         position = "227 87";
+         extent = "64 22";
+         minExtent = "8 2";
+         horizSizing = "left";
+         vertSizing = "top";
+         profile = "ToolsGuiButtonProfile";
+         visible = "1";
+         active = "1";
+         command = "setAssetTarget();";
+         tooltipProfile = "ToolsGuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "0";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      new GuiButtonCtrl() {
+         text = "Cancel";
+         groupNum = "-1";
+         buttonType = "PushButton";
+         useMouseEvents = "0";
+         position = "295 87";
+         extent = "64 22";
+         minExtent = "8 2";
+         horizSizing = "left";
+         vertSizing = "top";
+         profile = "ToolsGuiButtonProfile";
+         visible = "1";
+         active = "1";
+         command = "AssetBrowser_setAssetTargetWindow.onClose();";
+         tooltipProfile = "ToolsGuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "0";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+   };
+};
+//--- OBJECT WRITE END ---
diff --git a/Templates/BaseGame/game/tools/assetBrowser/main.tscript b/Templates/BaseGame/game/tools/assetBrowser/main.tscript
index dc41eacb9..8f6ca92dd 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/main.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/main.tscript
@@ -69,6 +69,7 @@ function initializeAssetBrowser()
    exec("./guis/looseFileAudit.gui");
    exec("./guis/assetNameEdit.gui");
    exec("./guis/createNewCollectionSet.gui");
+   exec("./guis/setAssetTarget.gui");
 
    exec("./scripts/assetBrowser." @ $TorqueScriptFileExtension);
    exec("./scripts/popupMenus." @ $TorqueScriptFileExtension);
@@ -85,6 +86,7 @@ function initializeAssetBrowser()
    exec("./scripts/selectPath." @ $TorqueScriptFileExtension);
    exec("./scripts/looseFileAudit." @ $TorqueScriptFileExtension);
    exec("./scripts/creator." @ $TorqueScriptFileExtension);
+   exec("./scripts/setAssetTarget." @ $TorqueScriptFileExtension);
    
    //Processing for the different asset types
    exec("./scripts/assetTypes/component." @ $TorqueScriptFileExtension); 
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/addModuleWindow.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/addModuleWindow.tscript
index ade7dce8e..ff085835b 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/addModuleWindow.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/addModuleWindow.tscript
@@ -95,7 +95,7 @@ function AssetBrowser_addModuleWindow::CreateNewModule(%this)
    
    //force a refresh of our modules list
    ModuleDatabase.ignoreLoadedGroups(true);
-   ModuleDatabase.scanModules();
+   ModuleDatabase.registerModule(%moduleFilePath, %newModuleName @ ".module");
    %success = ModuleDatabase.loadExplicit(%newModuleName, 1);
    ModuleDatabase.ignoreLoadedGroups(false);
    
@@ -123,8 +123,9 @@ function AssetBrowserModuleList::refresh(%this)
    %count = getWordCount(%moduleList);
    for(%i=0; %i < %count; %i++)
    {
-      %moduleName = getWord(%moduleList, %i);
-      %this.add(%moduleName.ModuleId, %i);  
+      %moduleDef = getWord(%moduleList, %i);
+      %moduleName = %moduleDef.ModuleId;
+      %this.add(%moduleName, %i);  
    }
 }
 
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImport.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImport.tscript
index a65a0af7b..1b42f482f 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImport.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImport.tscript
@@ -165,8 +165,14 @@ function getAssetTypeByFilename(%filePath)
 
 function AssetBrowser::onBeginDropFiles( %this )
 {   
-   if(!AssetBrowser.isAwake())
+   if(!AssetBrowser.isAwake() || !AssetBrowser.isVisible())
+   {
+      if(GuiEditorIsActive())
+         GuiEditor.onBeginDropFiles();
+      else if(EditorIsActive())
+         EWorldEditor.onBeginDropFiles();
       return;
+   }
       
    error("% DragDrop - Beginning files dropping.");
    if(!ImportAssetWindow.isAwake())
@@ -175,45 +181,28 @@ function AssetBrowser::onBeginDropFiles( %this )
 
 function AssetBrowser::onDropFile( %this, %filePath )
 {
-   if(!%this.isVisible())
+   if(!AssetBrowser.isAwake() || !AssetBrowser.isVisible())
+   {
+      if(GuiEditorIsActive())
+         GuiEditor.onDropFile(%filePath);
+      else if(EditorIsActive())
+         EWorldEditor.onDropFile(%filePath);
       return;
+   }
       
    ImportAssetWindow.importer.addImportingFile(%filePath);
-      
-   /*%fileExt = fileExt( %filePath );
-   //add it to our array!
-   if(isImageFormat(%fileExt))
-      %assetItem = %this.addImportingAsset("ImageAsset", %filePath);
-   else if( isShapeFormat(%fileExt))
-      %assetItem = %this.addImportingAsset("ShapeAsset", %filePath);
-   else if( isSoundFormat(%fileExt))
-      %assetItem = %this.addImportingAsset("SoundAsset", %filePath);
-   else if( %fileExt $= "." @ $TorqueScriptFileExtension || %fileExt $= "." @ $TorqueScriptFileExtension @ ".dso" )
-      %assetItem = %this.addImportingAsset("ScriptAsset", %filePath);
-   else if( %fileExt $= ".gui" || %fileExt $= ".gui.dso" )
-      %assetItem = %this.addImportingAsset("GUIAsset", %filePath);
-   else if (%fileExt $= ".zip")
-      %this.onDropZipFile(%filePath);
-   else if( %fileExt $= "")
-      %this.onDropFolder(%filePath);
-      
-   if(%assetItem !$= "")
-   {
-      SessionImportAssetItems.add(%assetItem);
-      ImportAssetItems.add(%assetItem);
-   }*/
-      
-   //Used to keep tabs on what files we were trying to import, used mainly in the event of
-   //adjusting configs and needing to completely reprocess the import
-   //ensure we're not doubling-up on files by accident
-   //if(ImportAssetWindow.importingFilesArray.getIndexFromKey(%filePath) == -1)
-   //   ImportAssetWindow.importingFilesArray.add(%filePath);
 }
 
 function AssetBrowser::onDropZipFile(%this, %filePath)
 {
-   if(!%this.isVisible())
+   if(!AssetBrowser.isAwake() || !AssetBrowser.isVisible())
+   {
+      if(GuiEditorIsActive())
+         GuiEditor.onDropZipFile(%filePath);
+      else if(EditorIsActive())
+         EWorldEditor.onDropZipFile(%filePath);
       return;
+   }
       
    %zip = new ZipObject();
    %zip.openArchive(%filePath);
@@ -226,27 +215,6 @@ function AssetBrowser::onDropZipFile(%this, %filePath)
       %fileEntry = %zip.getFileEntry(%i);
       %fileFrom = getField(%fileEntry, 0);
       
-      //First, we wanna scan to see if we have modules to contend with. If we do, we'll just plunk them in wholesale
-      //and not process their contents.
-      
-      //If not modules, it's likely an art pack or other mixed files, so we'll import them as normal
-      /*if( (%fileExt $= ".png") || (%fileExt $= ".jpg") || (%fileExt $= ".bmp") || (%fileExt $= ".dds") )
-         %this.importAssetListArray.add("ImageAsset", %filePath);
-      else if( (%fileExt $= ".dae") || (%fileExt $= ".dts"))
-         %this.importAssetListArray.add("ShapeAsset", %filePath);
-      else if( (%fileExt $= ".ogg") || (%fileExt $= ".wav") || (%fileExt $= ".mp3"))
-         %this.importAssetListArray.add("SoundAsset", %filePath);
-      else if( (%fileExt $= ".gui") || (%fileExt $= ".gui.dso"))
-         %this.importAssetListArray.add("GUIAsset", %filePath);
-      //else if( (%fileExt $= "." @ $TorqueScriptFileExtension) || (%fileExt $= ".dso"))
-      //   %this.importAssetListArray.add("Script", %filePath);
-      else if( (%fileExt $= ".mis"))
-         %this.importAssetListArray.add("LevelAsset", %filePath);*/
-         
-      // For now, if it's a .tscript file, we'll assume it's a behavior.
-      //if (fileExt(%fileFrom) !$= "." @ $TorqueScriptFileExtension)
-      //   continue;
-      
       %fileTo = expandFilename("^tools/assetBrowser/importTemp/") @ %fileFrom;
       %zip.extractFile(%fileFrom, %fileTo);
       //exec(%fileTo);
@@ -259,8 +227,14 @@ function AssetBrowser::onDropZipFile(%this, %filePath)
 
 function AssetBrowser::onDropFolder(%this, %filePath)
 {
-   if(!%this.isVisible())
+   if(!AssetBrowser.isAwake() || !AssetBrowser.isVisible())
+   {
+      if(GuiEditorIsActive())
+         GuiEditor.onDropFolder(%filePath);
+      else if(EditorIsActive())
+         EWorldEditor.onDropFolder(%filePath);
       return;
+   }
       
    %zip = new ZipObject();
    %zip.openArchive(%filePath);
@@ -306,8 +280,14 @@ function AssetBrowser::onDropFolder(%this, %filePath)
 
 function AssetBrowser::onEndDropFiles( %this )
 {
-   if(!%this.isVisible())
+   if(!AssetBrowser.isAwake() || !AssetBrowser.isVisible())
+   {
+      if(GuiEditorIsActive())
+         GuiEditor.onEndDropFiles();
+      else if(EditorIsActive())
+         EWorldEditor.onEndDropFiles();
       return;
+   }
       
    ImportAssetWindow.refresh();
 }
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/datablockObjects.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/datablockObjects.tscript
index ea77f8b1a..a0aad9382 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/datablockObjects.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/datablockObjects.tscript
@@ -63,7 +63,22 @@ function AssetBrowser::buildDatablockPreview(%this, %assetDef, %previewData)
                            "\nDatablock Type: " @ %assetDef.getClassName() @
                            "\nDefinition Path: " @ %assetDef.getFilename();
                            
-   %previewData.doubleClickCommand = "AssetBrowser.schedule(10, \"spawnDatablockObject\",\""@ %assetDef @"\");";//browseTo %assetDef.dirPath / %assetDef.assetName
+   
+   if(%this.selectMode)
+   {
+      %previewData.doubleClickCommand = "AssetBrowser.selectAsset( AssetBrowser.selectedAsset );";
+   }
+   else
+   {
+      if(EditorSettings.value("Assets/Browser/doubleClickAction", "Edit Asset") $= "Edit Asset")
+      {
+         %previewData.doubleClickCommand = "DatablockEditorPlugin.openDatablock( "@%assetDef@" );";
+      }
+      else
+      {
+         %previewData.doubleClickCommand = "AssetBrowser.onDatablockEditorDropped( "@%assetDef@" );";
+      }
+   }
 }
 
 function spawnDatablockObject(%datablock)
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript
index d2254ee12..15dc88d0a 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript
@@ -106,8 +106,6 @@ function AssetBrowser::loadCreatorClasses(%this)
    
    %guiClasses.sortk(true);
    
-   %guiClasses.echo();
-   
    %currentCat = "";
    for(%i=0; %i < %guiClasses.count(); %i++)
    {
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/setAssetTarget.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/setAssetTarget.tscript
new file mode 100644
index 000000000..f2440e873
--- /dev/null
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/setAssetTarget.tscript
@@ -0,0 +1,43 @@
+function AssetBrowser_setAssetTarget::showDialog(%this, %callback)
+{
+   AssetBrowser_setAssetTarget.callback = %callback;
+   Canvas.pushDialog(AssetBrowser_setAssetTarget);
+}
+
+function AssetBrowser_setAssetTarget::onWake(%this)
+{
+   %targetModule = AssetBrowser.dirHandler.getModuleFromAddress(AssetBrowser.dirHandler.currentAddress).ModuleId;
+
+   if(%targetModule $= "")
+      %targetModule = EditorSettings.value("Assets/New/defaultModule", "");
+      
+   AssetBrowser_setAssetTarget-->moduleList.setText(%targetModule);
+   
+   %moduleDef = ModuleDatabase.findModule(%targetModule);
+   
+   %targetPath = AssetBrowser.dirHandler.currentAddress;
+   if(!startsWith(%targetPath, %moduleDef.ModulePath))
+   {
+      %targetPath = %moduleDef.ModulePath;
+   }
+   
+   AssetBrowser_setAssetTarget-->targetPath.text = %targetPath;
+}
+
+function AssetBrowser_setAssetTargetWindow::onClose(%this)
+{
+   Canvas.popDialog(AssetBrowser_setAssetTarget);
+}
+
+function setAssetTargetUpdatePath(%targetPath)
+{
+   AssetBrowser_setAssetTarget-->targetPath.text = %targetPath;
+}
+
+function setAssetTarget()
+{
+   AssetBrowser.dirHandler.currentAddress = AssetBrowser_setAssetTarget-->targetPath.text;
+   eval(AssetBrowser_setAssetTarget.callback);
+   
+   Canvas.popDialog(AssetBrowser_setAssetTarget);
+}
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/datablockEditor/DatablockEditorCreatePrompt.ed.gui b/Templates/BaseGame/game/tools/datablockEditor/DatablockEditorCreatePrompt.ed.gui
index 5f1783390..29b3afb9e 100644
--- a/Templates/BaseGame/game/tools/datablockEditor/DatablockEditorCreatePrompt.ed.gui
+++ b/Templates/BaseGame/game/tools/datablockEditor/DatablockEditorCreatePrompt.ed.gui
@@ -5,7 +5,6 @@ $guiContent = new GuiControl(DatablockEditorCreatePrompt,EditorGuiGroup) {
    minExtent = "8 2";
    horizSizing = "right";
    vertSizing = "bottom";
-   fixedAspectRatio = "0";
    profile = "ToolsGuiDefaultProfile";
    visible = "1";
    active = "1";
@@ -14,6 +13,7 @@ $guiContent = new GuiControl(DatablockEditorCreatePrompt,EditorGuiGroup) {
    isContainer = "1";
    canSave = "1";
    canSaveDynamicFields = "1";
+      fixedAspectRatio = "0";
 
    new GuiWindowCtrl() {
       text = "Create New Datablock";
@@ -32,18 +32,18 @@ $guiContent = new GuiControl(DatablockEditorCreatePrompt,EditorGuiGroup) {
       anchorBottom = "0";
       anchorLeft = "1";
       anchorRight = "0";
-      position = "389 252";
-      extent = "207 167";
+      position = "374 252";
+      extent = "309 167";
       minExtent = "8 2";
       horizSizing = "right";
       vertSizing = "bottom";
-      fixedAspectRatio = "0";
       profile = "ToolsGuiWindowProfile";
       visible = "1";
       active = "1";
       tooltipProfile = "ToolsGuiToolTipProfile";
       hovertime = "1000";
       isContainer = "1";
+      internalName = "promptWindow";
       canSave = "1";
       canSaveDynamicFields = "0";
 
@@ -61,7 +61,6 @@ $guiContent = new GuiControl(DatablockEditorCreatePrompt,EditorGuiGroup) {
          minExtent = "8 2";
          horizSizing = "right";
          vertSizing = "bottom";
-         fixedAspectRatio = "0";
          profile = "ToolsGuiTextProfile";
          visible = "1";
          active = "1";
@@ -86,11 +85,10 @@ $guiContent = new GuiControl(DatablockEditorCreatePrompt,EditorGuiGroup) {
          anchorLeft = "1";
          anchorRight = "0";
          position = "7 45";
-         extent = "191 17";
+         extent = "294 18";
          minExtent = "8 2";
          horizSizing = "right";
          vertSizing = "bottom";
-         fixedAspectRatio = "0";
          profile = "ToolsGuiTextEditProfile";
          visible = "1";
          active = "1";
@@ -106,12 +104,11 @@ $guiContent = new GuiControl(DatablockEditorCreatePrompt,EditorGuiGroup) {
          groupNum = "-1";
          buttonType = "PushButton";
          useMouseEvents = "0";
-         position = "7 137";
+         position = "111 137";
          extent = "122 22";
          minExtent = "8 2";
          horizSizing = "right";
          vertSizing = "bottom";
-         fixedAspectRatio = "0";
          profile = "ToolsGuiButtonProfile";
          visible = "1";
          active = "1";
@@ -128,12 +125,11 @@ $guiContent = new GuiControl(DatablockEditorCreatePrompt,EditorGuiGroup) {
          groupNum = "-1";
          buttonType = "PushButton";
          useMouseEvents = "0";
-         position = "135 137";
+         position = "239 137";
          extent = "63 22";
          minExtent = "8 2";
          horizSizing = "right";
          vertSizing = "bottom";
-         fixedAspectRatio = "0";
          profile = "ToolsGuiButtonProfile";
          visible = "1";
          active = "1";
@@ -159,7 +155,6 @@ $guiContent = new GuiControl(DatablockEditorCreatePrompt,EditorGuiGroup) {
          minExtent = "8 2";
          horizSizing = "right";
          vertSizing = "bottom";
-         fixedAspectRatio = "0";
          profile = "ToolsGuiTextProfile";
          visible = "1";
          active = "1";
@@ -182,11 +177,10 @@ $guiContent = new GuiControl(DatablockEditorCreatePrompt,EditorGuiGroup) {
          anchorLeft = "1";
          anchorRight = "0";
          position = "7 87";
-         extent = "191 19";
+         extent = "294 19";
          minExtent = "8 2";
          horizSizing = "right";
          vertSizing = "bottom";
-         fixedAspectRatio = "0";
          profile = "ToolsGuiPopUpMenuProfile";
          visible = "1";
          active = "1";
@@ -198,7 +192,6 @@ $guiContent = new GuiControl(DatablockEditorCreatePrompt,EditorGuiGroup) {
          canSaveDynamicFields = "0";
       };
       new GuiCheckBoxCtrl() {
-         useInactiveState = "0";
          text = "Client-Side Datablock";
          groupNum = "-1";
          buttonType = "ToggleButton";
@@ -208,10 +201,9 @@ $guiContent = new GuiControl(DatablockEditorCreatePrompt,EditorGuiGroup) {
          minExtent = "8 2";
          horizSizing = "right";
          vertSizing = "bottom";
-         fixedAspectRatio = "0";
          profile = "ToolsGuiCheckBoxProfile";
          visible = "1";
-         active = "1";
+         active = "0";
          tooltipProfile = "ToolsGuiToolTipProfile";
          hovertime = "1000";
          isContainer = "0";
diff --git a/Templates/BaseGame/game/tools/datablockEditor/DatablockEditorTreeWindow.ed.gui b/Templates/BaseGame/game/tools/datablockEditor/DatablockEditorTreeWindow.ed.gui
index 95ba4a277..8f0d0eaee 100644
--- a/Templates/BaseGame/game/tools/datablockEditor/DatablockEditorTreeWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/datablockEditor/DatablockEditorTreeWindow.ed.gui
@@ -259,7 +259,7 @@ $guiContent = new GuiControl() {
                   tooltipprofile = "ToolsGuiToolTipProfile";
                   hovertime = "1000";
                   canSaveDynamicFields = "0";
-                  altCommand = "DatablockEditorPlugin.createDatablock();";
+                  altCommand = "DatablockEditorPlugin.pickDatablockPath();";
                };
             };
          };
diff --git a/Templates/BaseGame/game/tools/datablockEditor/datablockEditor.tscript b/Templates/BaseGame/game/tools/datablockEditor/datablockEditor.tscript
index ca9373416..d780731ef 100644
--- a/Templates/BaseGame/game/tools/datablockEditor/datablockEditor.tscript
+++ b/Templates/BaseGame/game/tools/datablockEditor/datablockEditor.tscript
@@ -666,6 +666,7 @@ function DatablockEditorPlugin::createDatablock(%this)
       // Show the dialog.
       
       canvas.pushDialog( DatablockEditorCreatePrompt, 0, true );
+      DatablockEditorCreatePrompt-->promptWindow.text = "Create New Datablock in module: " @ DatablockEditorPlugin.targetCreationModule;
    }
 }
 
@@ -679,6 +680,7 @@ function DatablockEditorPlugin::pickDatablockPath(%this)
 
 function DatablockEditorPlugin::pickedNewDBTargetModule(%this, %module)
 {
+   DatablockEditorPlugin.targetCreationModule = %module;
    %moduleDef = ModuleDatabase.findModule(%module);
    
    $DATABLOCK_EDITOR_DEFAULT_FILENAME = %moduleDef.ModulePath @ "/scripts/managedData/managedDatablocks." @ $TorqueScriptFileExtension;
diff --git a/Templates/BaseGame/game/tools/editorClasses/scripts/input/dragDropEvents.ed.tscript b/Templates/BaseGame/game/tools/editorClasses/scripts/input/dragDropEvents.ed.tscript
index 70582bd20..5e4405282 100644
--- a/Templates/BaseGame/game/tools/editorClasses/scripts/input/dragDropEvents.ed.tscript
+++ b/Templates/BaseGame/game/tools/editorClasses/scripts/input/dragDropEvents.ed.tscript
@@ -39,7 +39,6 @@ function onDropFile( %filePath )
 }
 function onDropEnd( %fileCount )
 {
-   
    //error("% DragDrop - Completed file dropping");
    Input::GetEventManager().postEvent( "EndDropFiles" );
 }
diff --git a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditor.ed.tscript b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditor.ed.tscript
index 9436283d4..e9eabea7e 100644
--- a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditor.ed.tscript
@@ -722,6 +722,64 @@ function GuiEditor::onMouseModeChange( %this )
    GuiEditorStatusBar.setText( GuiEditorStatusBar.getMouseModeHelp() );
 }
 
+//
+function GuiEditor::onBeginDropFiles( %this )
+{   
+   if(!%this.isVisible())
+      return;
+      
+   AssetBrowser_setAssetTarget.showDialog("EWorldEditor.doFileDropProcessing();");
+   
+   if(!isObject($EditorImportFileList))
+      $EditorImportFileList = new ArrayObject();
+      
+   $EditorImportFileList.empty();
+}
+
+function GuiEditor::onDropFile( %this, %filePath )
+{
+   if(!%this.isVisible())
+      return;
+      
+   $EditorImportFileList.add(%filePath);
+}
+
+function GuiEditor::onDropZipFile(%this, %filePath)
+{
+   if(!%this.isVisible())
+      return;
+}
+
+function GuiEditor::onDropFolder(%this, %filePath)
+{
+   if(!%this.isVisible())
+      return;
+}
+
+function GuiEditor::onEndDropFiles( %this )
+{
+   if(!%this.isVisible())
+      return;
+}
+
+function GuiEditor::doFileDropProcessing(%this)
+{
+   if(!ImportAssetWindow.isAwake())
+      ImportAssetWindow.showDialog();
+   
+   for(%i=0; %i < $EditorImportFileList.Count(); %i++)
+   {
+      %file = $EditorImportFileList.getKey(%i);
+      ImportAssetWindow.importer.addImportingFile(%file);
+   }
+   
+   $EditorImportFileList.empty();
+   
+   ImportAssetWindow.refresh();
+}
+
+//
+
 //=============================================================================================
 //    Resolution List.
 //=============================================================================================
diff --git a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorUndo.ed.tscript b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorUndo.ed.tscript
index f28a26109..ba75ee7a0 100644
--- a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorUndo.ed.tscript
+++ b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorUndo.ed.tscript
@@ -599,4 +599,4 @@ function GuiEditor::onFitIntoParents( %this )
 {
    %selected = %this.getSelection();
    //TODO
-}
+}
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/objectBuilderGui.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/objectBuilderGui.ed.gui
index 755227156..dc757dc54 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/objectBuilderGui.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/objectBuilderGui.ed.gui
@@ -375,7 +375,7 @@ function ObjectBuilderGui::createImageAssetType(%this, %index)
       modal = "1";
       command = %this @ ".getImageAsset(" @ %index @ ");";
    };
-   %button.setBitmap("tools/materialEditor/gui/change-material-btn");
+   %button.setBitmap("ToolsModule:change_material_btn_n_image");
    %this.controls[%this.numControls].addGuiControl(%button);
 
    %this.numControls++;
@@ -466,7 +466,7 @@ function ObjectBuilderGui::createMaterialNameType(%this, %index)
       modal = "1";
       command = %this @ ".getMaterialName(" @ %index @ ");";
    };
-   %button.setBitmap("tools/materialEditor/gui/change-material-btn");
+   %button.setBitmap("ToolsModule:change_material_btn_n_image");
    %this.controls[%this.numControls].addGuiControl(%button);
 
    //%val = %this.field[%index, value];
@@ -869,7 +869,6 @@ function ObjectBuilderGui::buildCloudLayer(%this)
    OBObjectName.setValue( "" );      
    %this.objectClassName = "CloudLayer";
    %this.addField( "textureAsset", "TypeImageAsset", "Image", "Core_Rendering:clouds_normal_displacement_image" ); 
-   //%this.addField( "textureFile", "TypeImageFilename", "Texture", "core/rendering/images/clouds_normal_displacement" );   
 	%this.process();
 }
 
@@ -881,9 +880,10 @@ function ObjectBuilderGui::buildBasicClouds(%this)
 	
    // This is a trick... any fields added after process won't show
    // up as controls, but will be applied to the created object.
-   %this.addField( "texture[0]", "TypeImageFilename", "Texture", "core/rendering/images/cloud1" );   
-   %this.addField( "texture[1]", "TypeImageFilename", "Texture", "core/rendering/images/cloud2" );   
-   %this.addField( "texture[2]", "TypeImageFilename", "Texture", "core/rendering/images/cloud3" );   	   
+   %this.addField( "textureAsset[0]", "TypeImageAssetId", "TextureAsset", "Core_Rendering:cloud1_image" );   
+   %this.addField( "textureAsset[1]", "TypeImageAssetId", "TextureAsset", "Core_Rendering:cloud2_image" ); 
+   %this.addField( "textureAsset[2]", "TypeImageAssetId", "TextureAsset", "Core_Rendering:cloud3_image" ); 
+
 }
 
 function ObjectBuilderGui::checkExists( %this, %classname )
@@ -994,9 +994,9 @@ function ObjectBuilderGui::addWaterObjectFields(%this)
    %this.addField("waveSpeed[2]", "TypeFloat", "Wave Speed", "1");
    %this.addField("overallWaveMagnitude", "TypeFloat", "Overall Wave Magnitude", "1.0");
    
-   %this.addField("rippleTex", "TypeImageFilename", "Ripple Texture", "core/rendering/images/ripple" );
-   %this.addField("depthGradientTex", "TypeImageFilename", "Depth Gradient Texture", "core/rendering/images/depthcolor_ramp" );
-   %this.addField("foamTex", "TypeImageFilename", "Foam Texture", "core/rendering/images/foam" );
+   %this.addField("rippleTexAsset", "TypeImageAssetId", "Ripple Texture", "Core_Rendering:ripple_image" );
+   %this.addField("depthGradientTexAsset", "TypeImageAssetId", "Depth Gradient Texture", "Core_Rendering:depthcolor_ramp_imag" );
+   %this.addField("foamTexAsset", "TypeImageAssetId", "Foam Texture", "Core_Rendering:foam_image" );
 }
 
 function ObjectBuilderGui::buildWaterBlock(%this)
@@ -1410,4 +1410,15 @@ function PrecipitationData::create(%datablock)
       parentGroup = EWCreatorWindow.objectGroup;
    };
    return %obj;
+}
+
+function TriggerData::create(%datablock)
+{
+   %obj = new Trigger()
+   {
+      dataBlock = %datablock;
+      parentGroup = EWCreatorWindow.objectGroup;
+      polyhedron = "-0.5 0.5 0.0 1.0 0.0 0.0 0.0 -1.0 0.0 0.0 0.0 1.0";
+   };
+   return %obj;
 }
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/editors/worldEditor.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/editors/worldEditor.ed.tscript
index 08b65c716..3ff1a1075 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/editors/worldEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/editors/worldEditor.ed.tscript
@@ -321,6 +321,64 @@ function WorldEditor::onWorldEditorUndo( %this )
    Inspector.refresh();
 }
 
+//
+function WorldEditor::onBeginDropFiles( %this )
+{   
+   if(!%this.isVisible())
+      return;
+      
+   AssetBrowser_setAssetTarget.showDialog("EWorldEditor.doFileDropProcessing();");
+   
+   if(!isObject($EditorImportFileList))
+      $EditorImportFileList = new ArrayObject();
+   
+   $EditorImportFileList.empty();
+}
+
+function WorldEditor::onDropFile( %this, %filePath )
+{
+   if(!%this.isVisible())
+      return;
+      
+   $EditorImportFileList.add(%filePath);
+}
+
+function WorldEditor::onDropZipFile(%this, %filePath)
+{
+   if(!%this.isVisible())
+      return;
+}
+
+function WorldEditor::onDropFolder(%this, %filePath)
+{
+   if(!%this.isVisible())
+      return;
+}
+
+function WorldEditor::onEndDropFiles( %this )
+{
+   if(!%this.isVisible())
+      return;
+}
+
+function WorldEditor::doFileDropProcessing(%this)
+{
+   if(!ImportAssetWindow.isAwake())
+      ImportAssetWindow.showDialog();
+   
+   for(%i=0; %i < $EditorImportFileList.Count(); %i++)
+   {
+      %file = $EditorImportFileList.getKey(%i);
+      ImportAssetWindow.importer.addImportingFile(%file);
+   }
+   
+   $EditorImportFileList.empty();
+   
+   ImportAssetWindow.refresh();
+}
+
+//
+
 function Inspector::onInspectorFieldModified( %this, %object, %fieldName, %arrayIndex, %oldValue, %newValue )
 {
    // The instant group will try to add our

From 7556e403e79353c1b802733d3cae89127c571349 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Sun, 12 Sep 2021 15:05:19 -0400
Subject: [PATCH 073/399] Clean up more evals that have local variables are not
 working correctly.

---
 .../Scripts/Inspector/Controls.tscript        |  2 +-
 .../game/tools/gui/materialSelector.ed.gui    |  6 ++--
 .../game/tools/gui/scriptEditorDlg.ed.gui     |  2 +-
 .../scripts/materialEditor.ed.tscript         | 12 ++++----
 .../scripts/materialEditorUndo.ed.tscript     | 30 +++++++++----------
 .../game/tools/navEditor/navEditor.tscript    |  4 +--
 6 files changed, 27 insertions(+), 29 deletions(-)

diff --git a/Templates/BaseGame/game/tools/VerveEditor/Scripts/Inspector/Controls.tscript b/Templates/BaseGame/game/tools/VerveEditor/Scripts/Inspector/Controls.tscript
index b2b64f858..79beeda86 100644
--- a/Templates/BaseGame/game/tools/VerveEditor/Scripts/Inspector/Controls.tscript
+++ b/Templates/BaseGame/game/tools/VerveEditor/Scripts/Inspector/Controls.tscript
@@ -123,7 +123,7 @@ function VerveEditor::CreateField( %targetStack, %fieldName, %fieldType )
     if ( isMethod( "VerveEditor", "Create" @ %fieldType @ "Field" ) )
     {
         // Create the Input Control.
-        eval( "%fieldInput = VerveEditor::Create" @ %fieldType @ "Field( %fieldContainer, %fieldName );" );
+        %fieldInput = eval( "return VerveEditor::Create" @ %fieldType @ "Field( %fieldContainer, %fieldName );" );
     }
     else
     {
diff --git a/Templates/BaseGame/game/tools/gui/materialSelector.ed.gui b/Templates/BaseGame/game/tools/gui/materialSelector.ed.gui
index b043d62fc..a1e263b2a 100644
--- a/Templates/BaseGame/game/tools/gui/materialSelector.ed.gui
+++ b/Templates/BaseGame/game/tools/gui/materialSelector.ed.gui
@@ -1420,15 +1420,13 @@ function MaterialSelector::updateSelection( %this, %material, %previewImagePath
    // after we move away from the material. eg: if we remove a field from the material,
    // the empty checkbox will still be there until you move fro and to the material again
    
-   %isMaterialBorder = 0;
-   eval("%isMaterialBorder = isObject(MaterialSelector-->"@%material@"Border);");
+   %isMaterialBorder = eval("return isObject(MaterialSelector-->"@%material@"Border);");
    if( %isMaterialBorder )
    {
       eval( "MaterialSelector-->"@%material@"Border.setStateOn(1);");
    }
       
-   %isMaterialBorderPrevious = 0;
-   eval("%isMaterialBorderPrevious = isObject(MaterialSelector-->"@$prevSelectedMaterialHL@"Border);");
+   %isMaterialBorderPrevious = eval("return isObject(MaterialSelector-->"@$prevSelectedMaterialHL@"Border);");
    if( %isMaterialBorderPrevious )
    {
       eval( "MaterialSelector-->"@$prevSelectedMaterialHL@"Border.setStateOn(0);");
diff --git a/Templates/BaseGame/game/tools/gui/scriptEditorDlg.ed.gui b/Templates/BaseGame/game/tools/gui/scriptEditorDlg.ed.gui
index 3758916f6..0bbad9488 100644
--- a/Templates/BaseGame/game/tools/gui/scriptEditorDlg.ed.gui
+++ b/Templates/BaseGame/game/tools/gui/scriptEditorDlg.ed.gui
@@ -205,7 +205,7 @@ function _TextPadOnOk()
    if(ScriptEditorDlg.callback !$= "")
    {
       %text = ScriptEditorDlg-->textpad.getText();
-      %command  = ScriptEditorDlg.callback @ "( %text );";
+      %command  = ScriptEditorDlg.callback @ "(\"" @ expandEscape(%text) @ "\");";
       eval(%command);
    }
    ScriptEditorDlg.callback = "";
diff --git a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
index 7f3fb2d43..bdca293da 100644
--- a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
@@ -1124,13 +1124,13 @@ function MaterialEditorGui::updateActiveMaterial(%this, %propertyField, %value,
       MaterialEditorGui.submitUndo( %action );
    }
    
-   eval("materialEd_previewMaterial." @ %propertyField @ " = " @ %value @ ";");
+   materialEd_previewMaterial.setFieldValue(%propertyField, %value);
    materialEd_previewMaterial.flush();
    materialEd_previewMaterial.reload();
    
    if (MaterialEditorGui.livePreview == true)
    {
-      eval("MaterialEditorGui.currentMaterial." @ %propertyField @ " = " @ %value @ ";");
+      MaterialEditorGui.setFieldValue(%propertyField, %value);
       MaterialEditorGui.currentMaterial.flush();
       MaterialEditorGui.currentMaterial.reload();
    }
@@ -1173,7 +1173,7 @@ function MaterialEditorGui::updateMaterialReferences( %this, %obj, %oldName, %ne
          %fieldName = %obj.getField( %i );
          if ( ( %obj.getFieldType( %fieldName ) $= "TypeMaterialName" ) && ( %obj.getFieldValue( %fieldName ) $= %oldName ) )
          {
-            eval( %obj @ "." @ %fieldName @ " = " @ %newName @ ";" );
+            %obj.setFieldValue(%fieldName, %newName);
             %objChanged = true;
          }
       }
@@ -1431,13 +1431,13 @@ function MaterialEditorGui::updateAnimationFlags(%this)
    %action.oldValue = %oldFlags;
    MaterialEditorGui.submitUndo( %action );
    
-   eval("materialEd_previewMaterial.animFlags[" @ MaterialEditorGui.currentLayer @ "] = " @ %flags @ ";");
+   materialEd_previewMaterial.animFlags[MaterialEditorGui.currentLayer] = %flags;
    materialEd_previewMaterial.flush();
    materialEd_previewMaterial.reload();
    
    if (MaterialEditorGui.livePreview == true)
    {
-      eval("MaterialEditorGui.currentMaterial.animFlags[" @ MaterialEditorGui.currentLayer @ "] = " @ %flags @ ";");
+      MaterialEditorGui.currentMaterial.animFlags[MaterialEditorGui.currentLayer] = %flags;
       MaterialEditorGui.currentMaterial.flush();
       MaterialEditorGui.currentMaterial.reload();
    }
@@ -2324,7 +2324,7 @@ function MaterialEditorGui::changeMaterial(%this, %fromMaterial, %toMaterial)
    {
       %action.mode = "editorShapes";
 
-      eval("MaterialEditorGui.currentObject." @ SubMaterialSelector.getText() @ " = " @ %toMaterial.getName() @ ";");
+      MaterialEditorGui.currentObject.setFieldValue(SubMaterialSelector.getText(), %toMaterial.getName());
       if( MaterialEditorGui.currentObject.isMethod("postApply") )
          MaterialEditorGui.currentObject.postApply();
       
diff --git a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditorUndo.ed.tscript b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditorUndo.ed.tscript
index 4f08ed9e0..5e1aa0ec7 100644
--- a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditorUndo.ed.tscript
+++ b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditorUndo.ed.tscript
@@ -62,13 +62,13 @@ function ActionUpdateActiveMaterial::redo(%this)
          MaterialEditorGui.setActiveMaterial(%this.material);
       }
       */
-      eval("materialEd_previewMaterial." @ %this.field @ " = " @ %this.newValue @ ";");
+      materialEd_previewMaterial.setFieldValue(%this.field, %this.newValue);
       materialEd_previewMaterial.flush();
       materialEd_previewMaterial.reload();
       
       if (MaterialEditorGui.livePreview == true)
       {
-         eval("%this.material." @ %this.field @ " = " @ %this.newValue @ ";");
+         %this.material.setFieldValue(%this.field, %this.newValue);
          MaterialEditorGui.currentMaterial.flush();
          MaterialEditorGui.currentMaterial.reload();
       }      
@@ -80,7 +80,7 @@ function ActionUpdateActiveMaterial::redo(%this)
    }
    else
    {
-      eval("%this.material." @ %this.field @ " = " @ %this.newValue @ ";");
+      %this.material.setFieldValue(%this.field, %this.newValue);
       %this.material.flush();
       %this.material.reload();
    }
@@ -100,13 +100,13 @@ function ActionUpdateActiveMaterial::undo(%this)
       }
       */
       
-      eval("materialEd_previewMaterial." @ %this.field @ " = " @ %this.oldValue @ ";");
+      materialEd_previewMaterial.setFieldValue(%this.field, %this.oldValue);
       materialEd_previewMaterial.flush();
       materialEd_previewMaterial.reload();
       
       if (MaterialEditorGui.livePreview == true)
       {
-         eval("%this.material." @ %this.field @ " = " @ %this.oldValue @ ";");
+         %this.material.setFieldValue(%this.field, %this.oldValue);
          MaterialEditorGui.currentMaterial.flush();
          MaterialEditorGui.currentMaterial.reload();
       }
@@ -115,7 +115,7 @@ function ActionUpdateActiveMaterial::undo(%this)
    }
    else
    {
-      eval("%this.material." @ %this.field @ " = " @ %this.oldValue @ ";");
+      %this.material.setFieldValue(%this.field, %this.oldValue);
       %this.material.flush();
       %this.material.reload();
    }
@@ -138,13 +138,13 @@ function ActionUpdateActiveMaterialAnimationFlags::redo(%this)
       }
       */
       
-      eval("materialEd_previewMaterial.animFlags[" @ %this.layer @ "] = " @ %this.newValue @ ";");
+      materialEd_previewMaterial.animFlags[%this.layer] = %this.newValue;
       materialEd_previewMaterial.flush();
       materialEd_previewMaterial.reload();
       
       if (MaterialEditorGui.livePreview == true)
       {
-         eval("%this.material.animFlags[" @ %this.layer @ "] = " @ %this.newValue @ ";");
+         %this.material.animFlags[%this.layer] = %this.newValue;
          MaterialEditorGui.currentMaterial.flush();
          MaterialEditorGui.currentMaterial.reload();
       }
@@ -153,7 +153,7 @@ function ActionUpdateActiveMaterialAnimationFlags::redo(%this)
    }
    else
    {
-      eval("%this.material.animFlags[" @ %this.layer @ "] = " @ %this.newValue @ ";");
+      %this.material.animFlags[%this.layer] = %this.newValue;
       %this.material.flush();
       %this.material.reload();
    }
@@ -162,14 +162,14 @@ function ActionUpdateActiveMaterialAnimationFlags::redo(%this)
 function ActionUpdateActiveMaterialAnimationFlags::undo(%this)
 {
    if( MaterialEditorPreviewWindow.isVisible() && MaterialEditorGui.currentMaterial == %this.material )
-   {      
-      eval("materialEd_previewMaterial.animFlags[" @ %this.layer @ "] = " @ %this.oldValue @ ";");
+   {  
+      materialEd_previewMaterial.animFlags[%this.layer] = %this.oldValue;
       materialEd_previewMaterial.flush();
       materialEd_previewMaterial.reload();
       
       if (MaterialEditorGui.livePreview == true)
       {
-         eval("%this.material.animFlags[" @ %this.layer @ "] = " @ %this.oldValue @ ";");
+         %this.material.animFlags[%this.layer] = %this.oldValue;
          MaterialEditorGui.currentMaterial.flush();
          MaterialEditorGui.currentMaterial.reload();
       }
@@ -178,7 +178,7 @@ function ActionUpdateActiveMaterialAnimationFlags::undo(%this)
    }
    else
    {
-      eval("%this.material.animFlags[" @ %this.layer @ "] = " @ %this.oldValue @ ";");
+      %this.material.animFlags[%this.layer] = %this.oldValue;
       %this.material.flush();
       %this.material.reload();
    }
@@ -340,7 +340,7 @@ function ActionChangeMaterial::redo(%this)
    }
    else
    {
-      eval("%this.object." @ %this.materialTarget @ " = " @ %this.toMaterial.getName() @ ";");
+      %this.object.setFieldValue(%this.materialTarget, %this.toMaterial.getName());
       MaterialEditorGui.currentObject.postApply();
    }
    
@@ -372,7 +372,7 @@ function ActionChangeMaterial::undo(%this)
    }
    else
    {
-      eval("%this.object." @ %this.materialTarget @ " = " @ %this.fromMaterial.getName() @ ";");
+      %this.object.setFieldValue(%this.materialTarget, %this.fromMaterial.getName());
       MaterialEditorGui.currentObject.postApply();
    }
    
diff --git a/Templates/BaseGame/game/tools/navEditor/navEditor.tscript b/Templates/BaseGame/game/tools/navEditor/navEditor.tscript
index 1f9e023bf..8fc2b15ba 100644
--- a/Templates/BaseGame/game/tools/navEditor/navEditor.tscript
+++ b/Templates/BaseGame/game/tools/navEditor/navEditor.tscript
@@ -262,7 +262,7 @@ function NavEditorGui::findCover(%this)
       %pos = LocalClientConnection.getControlObject().getPosition();
       %text = NavEditorOptionsWindow-->TestProperties->CoverPosition.getText();
       if(%text !$= "")
-         %pos = eval(%text);
+         %pos = eval("return " @ %text);
       %this.getPlayer().findCover(%pos, NavEditorOptionsWindow-->TestProperties->CoverRadius.getText());
    }
 }
@@ -275,7 +275,7 @@ function NavEditorGui::followObject(%this)
       %text = NavEditorOptionsWindow-->TestProperties->FollowObject.getText();
       if(%text !$= "")
       {
-         eval("%obj = " @ %text);
+         %obj = eval("return " @ %text);
          if(!isObject(%obj))
             toolsMessageBoxOk("Error", "Cannot find object" SPC %text);
       }

From a7db690b59cca8a9859e28ee13d3d3755ec88a6d Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Mon, 13 Sep 2021 19:46:21 -0400
Subject: [PATCH 074/399] Reimplement object copy failures.

---
 Engine/source/console/compiledEval.cpp | 7 ++++++-
 Engine/source/console/console.cpp      | 4 ++++
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index f33586676..f4c48ef68 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -142,6 +142,7 @@ namespace Con
    // console variables.
    extern StringTableEntry gCurrentFile;
    extern StringTableEntry gCurrentRoot;
+   extern S32 gObjectCopyFailures;
 }
 
 namespace Con
@@ -972,7 +973,11 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
                }
                else
                {
-                  Con::errorf(ConsoleLogEntry::General, "%s: Unable to find parent object %s for %s.", getFileLine(ip - 1), objParent, callArgv[1].getString());
+                  if (Con::gObjectCopyFailures == -1)
+                     Con::errorf(ConsoleLogEntry::General, "%s: Unable to find parent object %s for %s.", getFileLine(ip - 1), objParent, callArgv[1].getString());
+                  else
+                     ++Con::gObjectCopyFailures;
+
                   delete object;
                   currentNewObject = NULL;
                   ip = failJump;
diff --git a/Engine/source/console/console.cpp b/Engine/source/console/console.cpp
index ab93d554e..643f8cbec 100644
--- a/Engine/source/console/console.cpp
+++ b/Engine/source/console/console.cpp
@@ -300,6 +300,7 @@ Con::ConsoleInputEvent smConsoleInput;
 ///
 StringTableEntry gCurrentFile;
 StringTableEntry gCurrentRoot;
+S32 gObjectCopyFailures = -1;
 /// @}
 
 bool alwaysUseDebugOutput = true;
@@ -373,6 +374,9 @@ void init()
       "@ingroup Console\n");
    addVariable( "instantGroup", TypeRealString, &gInstantGroup, "The group that objects will be added to when they are created.\n"
       "@ingroup Console\n");
+   addVariable("Con::objectCopyFailures", TypeS32, &gObjectCopyFailures, "If greater than zero then it counts the number of object creation "
+      "failures based on a missing copy object and does not report an error..\n"
+      "@ingroup Console\n");
 
    // Current script file name and root
    addVariable( "Con::File", TypeString, &gCurrentFile, "The currently executing script file.\n"

From 98a4e7fb12a918a35b258661c9a235b6798a7762 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Tue, 14 Sep 2021 17:49:27 -0500
Subject: [PATCH 075/399] dedicated gfx device surpression augments
 $Video::forceDisplayAdapter = -1; to force usage of
 GFXAdapterType::NullDevice skips trying to open a splash window for dedicated
 servers bypasses guicanvas window display if window does not exist

---
 Engine/source/gfx/gfxInit.cpp           |  2 +-
 Engine/source/gui/core/guiCanvas.cpp    | 14 ++++++++------
 Templates/BaseGame/game/main.tscript.in | 14 +++++++++-----
 3 files changed, 18 insertions(+), 12 deletions(-)

diff --git a/Engine/source/gfx/gfxInit.cpp b/Engine/source/gfx/gfxInit.cpp
index b5d67206d..0a5c66466 100644
--- a/Engine/source/gfx/gfxInit.cpp
+++ b/Engine/source/gfx/gfxInit.cpp
@@ -290,7 +290,7 @@ GFXAdapter *GFXInit::getBestAdapterChoice()
    {
      S32 adapterIdx = dAtoi(adapterDevice.c_str());
      if (adapterIdx == -1)
-        adapter = chooseAdapter(adapterType, outputDevice.c_str());
+        adapter = chooseAdapter(NullDevice, outputDevice.c_str());
      else
         adapter = chooseAdapter(adapterType, adapterIdx);
    }
diff --git a/Engine/source/gui/core/guiCanvas.cpp b/Engine/source/gui/core/guiCanvas.cpp
index 7cbea6d64..967c3e7d7 100644
--- a/Engine/source/gui/core/guiCanvas.cpp
+++ b/Engine/source/gui/core/guiCanvas.cpp
@@ -258,17 +258,19 @@ bool GuiCanvas::onAdd()
    // Make sure we're able to render.
    newDevice->setAllowRender( true );
 
-   if(mDisplayWindow)
+   // NULL device returns a nullptr for getPlatformWindow
+   PlatformWindow* window = getPlatformWindow();
+   if (mDisplayWindow && window)
    {
-      getPlatformWindow()->show();
+      window->show();
       WindowManager->setDisplayWindow(true);
-      getPlatformWindow()->setDisplayWindow(true);
+      window->setDisplayWindow(true);
    }
-   else
+   else if (window)
    {
-      getPlatformWindow()->hide();
+      window->hide();
       WindowManager->setDisplayWindow(false);
-      getPlatformWindow()->setDisplayWindow(false);
+      window->setDisplayWindow(false);
    }
 
    // Propagate add to parents.
diff --git a/Templates/BaseGame/game/main.tscript.in b/Templates/BaseGame/game/main.tscript.in
index 5d5569e7d..4e83ff2b2 100644
--- a/Templates/BaseGame/game/main.tscript.in
+++ b/Templates/BaseGame/game/main.tscript.in
@@ -1,10 +1,6 @@
 $Core::windowIcon = "data/icon.png";
 $Core::splashWindowImage = "data/splash.png";
 
-// Display a splash window immediately to improve app responsiveness before
-// engine is initialized and main window created.
-displaySplashWindow($Core::splashWindowImage);
-
 // Console does something.
 setLogMode(6);
 
@@ -20,6 +16,13 @@ ModuleDatabase.setModuleExtension("module");
 ModuleDatabase.scanModules( "core", false );
 ModuleDatabase.LoadExplicit( "CoreModule" );
 
+// Display a splash window immediately to improve app responsiveness before
+// engine is initialized and main window created.
+if ($Server::Dedicated == false)
+    displaySplashWindow($Core::splashWindowImage);
+else
+    $Video::forceDisplayAdapter = -1;
+    
 //-----------------------------------------------------------------------------
 // Load any gameplay modules
 ModuleDatabase.scanModules( "data", false );
@@ -42,6 +45,7 @@ else
    }
 }
 
-closeSplashWindow();
+if ($Server::Dedicated == false)
+    closeSplashWindow();
 
 echo("Engine initialized...");
\ No newline at end of file

From 433d32f237cf09b47f05d0c92ec361a41b38412e Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Wed, 15 Sep 2021 00:02:50 -0400
Subject: [PATCH 076/399] Implement better CPU Detection

---
 Engine/source/platform/platform.h          |  47 +---
 Engine/source/platform/platformCPU.cpp     | 277 ++++-----------------
 Engine/source/platformWin32/winCPUInfo.cpp |  38 ++-
 3 files changed, 88 insertions(+), 274 deletions(-)

diff --git a/Engine/source/platform/platform.h b/Engine/source/platform/platform.h
index 7158c5163..35cd1a687 100644
--- a/Engine/source/platform/platform.h
+++ b/Engine/source/platform/platform.h
@@ -55,50 +55,11 @@
 /// @note These enums must be globally scoped so that they work with the inline assembly
 enum ProcessorType
 {
-   // x86
    CPU_X86Compatible,
-   CPU_Intel_Unknown,
-   CPU_Intel_486,
-   CPU_Intel_Pentium,
-   CPU_Intel_PentiumMMX,
-   CPU_Intel_PentiumPro,
-   CPU_Intel_PentiumII,
-   CPU_Intel_PentiumCeleron,
-   CPU_Intel_PentiumIII,
-   CPU_Intel_Pentium4,
-   CPU_Intel_PentiumM,
-   CPU_Intel_Core,
-   CPU_Intel_Core2,
-   CPU_Intel_Corei7Xeon, // Core i7 or Xeon
-   CPU_AMD_K6,
-   CPU_AMD_K6_2,
-   CPU_AMD_K6_3,
-   CPU_AMD_Athlon,
-   CPU_AMD_Phenom,
-   CPU_AMD_PhenomII,
-   CPU_AMD_Bulldozer,
-   CPU_AMD_Unknown,
-   CPU_Cyrix_6x86,
-   CPU_Cyrix_MediaGX,
-   CPU_Cyrix_6x86MX,
-   CPU_Cyrix_GXm,          ///< Media GX w/ MMX
-   CPU_Cyrix_Unknown,
-
-   // PowerPC
-   CPU_PowerPC_Unknown,
-   CPU_PowerPC_601,
-   CPU_PowerPC_603,
-   CPU_PowerPC_603e,
-   CPU_PowerPC_603ev,
-   CPU_PowerPC_604,
-   CPU_PowerPC_604e,
-   CPU_PowerPC_604ev,
-   CPU_PowerPC_G3,
-   CPU_PowerPC_G4,
-   CPU_PowerPC_G4_7450,
-   CPU_PowerPC_G4_7455,
-   CPU_PowerPC_G4_7447, 
-   CPU_PowerPC_G5,
+   CPU_ArmCompatible,
+   CPU_Intel,
+   CPU_AMD,
+   CPU_Apple
 };
 
 /// Properties for CPU.
diff --git a/Engine/source/platform/platformCPU.cpp b/Engine/source/platform/platformCPU.cpp
index 4eaa33b8d..d0a852431 100644
--- a/Engine/source/platform/platformCPU.cpp
+++ b/Engine/source/platform/platformCPU.cpp
@@ -31,12 +31,11 @@ Signal<void(void)> Platform::SystemInfoReady;
 enum CPUFlags
 {
    // EDX Register flags
-   BIT_FPU     = BIT(0),
    BIT_RDTSC   = BIT(4),
    BIT_MMX     = BIT(23),
    BIT_SSE     = BIT(25),
    BIT_SSE2    = BIT(26),
-   BIT_3DNOW   = BIT(31),
+   BIT_3DNOW   = BIT(31), // only available for amd cpus in x86
 
    // These use a different value for comparison than the above flags (ECX Register)
    BIT_SSE3    = BIT(0),
@@ -47,241 +46,63 @@ enum CPUFlags
 
 // fill the specified structure with information obtained from asm code
 void SetProcessorInfo(Platform::SystemInfo_struct::Processor& pInfo,
-   char* vendor, U32 processor, U32 properties, U32 properties2)
+   char* vendor, char* brand, U32 processor, U32 properties, U32 properties2)
 {
-   Platform::SystemInfo.processor.properties |= (properties & BIT_FPU)   ? CPU_PROP_FPU : 0;
-   Platform::SystemInfo.processor.properties |= (properties & BIT_RDTSC) ? CPU_PROP_RDTSC : 0;
-   Platform::SystemInfo.processor.properties |= (properties & BIT_MMX)   ? CPU_PROP_MMX : 0;
+   // always assume FPU is available in 2021...
+   pInfo.properties |= CPU_PROP_FPU;
+
+#if defined(TORQUE_CPU_X86) || defined(TORQUE_CPU_X64) || defined(TORQUE_CPU_ARM64)
+   pInfo.properties |= CPU_PROP_LE;
+#endif
+
+#if defined(TORQUE_CPU_X64) || defined(TORQUE_CPU_ARM64)
+   pInfo.properties |= CPU_PROP_64bit;
+#endif
+
+#if defined(TORQUE_CPU_X86) || defined(TORQUE_CPU_X64)
+   pInfo.properties |= (properties & BIT_RDTSC)   ? CPU_PROP_RDTSC : 0;
+   pInfo.properties |= (properties & BIT_MMX)     ? CPU_PROP_MMX : 0;
+   pInfo.properties |= (properties & BIT_SSE)     ? CPU_PROP_SSE : 0;
+   pInfo.properties |= (properties & BIT_SSE2)    ? CPU_PROP_SSE2 : 0;
+   pInfo.properties |= (properties2 & BIT_SSE3)   ? CPU_PROP_SSE3 : 0;
+   pInfo.properties |= (properties2 & BIT_SSE3xt) ? CPU_PROP_SSE3xt : 0;
+   pInfo.properties |= (properties2 & BIT_SSE4_1) ? CPU_PROP_SSE4_1 : 0;
+   pInfo.properties |= (properties2 & BIT_SSE4_2) ? CPU_PROP_SSE4_2 : 0;
+#endif
 
    if (dStricmp(vendor, "GenuineIntel") == 0)
    {
-      pInfo.properties |= (properties & BIT_SSE) ? CPU_PROP_SSE : 0;
-      pInfo.properties |= (properties & BIT_SSE2) ? CPU_PROP_SSE2 : 0;
-      pInfo.properties |= (properties2 & BIT_SSE3) ? CPU_PROP_SSE3 : 0;
-      pInfo.properties |= (properties2 & BIT_SSE3xt) ? CPU_PROP_SSE3xt : 0;
-      pInfo.properties |= (properties2 & BIT_SSE4_1) ? CPU_PROP_SSE4_1 : 0;
-      pInfo.properties |= (properties2 & BIT_SSE4_2) ? CPU_PROP_SSE4_2 : 0;
-
-      pInfo.type = CPU_Intel_Unknown;
-      // switch on processor family code
-      switch ((processor >> 8) & 0x0f)
-      {
-         case 4:
-            pInfo.type = CPU_Intel_486;
-            pInfo.name = StringTable->insert("Intel 486 class");
-            break;
-
-            // Pentium Family
-         case 5:
-            // switch on processor model code
-            switch ((processor >> 4) & 0xf)
-            {
-               case 1:
-               case 2:
-               case 3:
-                  pInfo.type = CPU_Intel_Pentium;
-                  pInfo.name = StringTable->insert("Intel Pentium");
-                  break;
-               case 4:
-                  pInfo.type = CPU_Intel_PentiumMMX;
-                  pInfo.name = StringTable->insert("Intel Pentium MMX");
-                  break;
-               default:
-                  pInfo.type = CPU_Intel_Pentium;
-                  pInfo.name = StringTable->insert( "Intel (unknown)" );
-                  break;
-            }
-            break;
-
-            // Pentium Pro/II/II family
-         case 6:
-         {
-            U32 extendedModel = ( processor & 0xf0000 ) >> 16;
-            // switch on processor model code
-            switch ((processor >> 4) & 0xf)
-            {
-               case 1:
-                  pInfo.type = CPU_Intel_PentiumPro;
-                  pInfo.name = StringTable->insert("Intel Pentium Pro");
-                  break;
-               case 3:
-               case 5:
-                  pInfo.type = CPU_Intel_PentiumII;
-                  pInfo.name = StringTable->insert("Intel Pentium II");
-                  break;
-               case 6:
-                  pInfo.type = CPU_Intel_PentiumCeleron;
-                  pInfo.name = StringTable->insert("Intel Pentium Celeron");
-                  break;
-               case 7:
-               case 8:
-               case 11:
-                  pInfo.type = CPU_Intel_PentiumIII;
-                  pInfo.name = StringTable->insert("Intel Pentium III");
-                  break;
-               case 0xA:
-                  if( extendedModel == 1)
-                  {
-                     pInfo.type = CPU_Intel_Corei7Xeon;
-                     pInfo.name = StringTable->insert( "Intel Core i7 / Xeon" );
-                  }
-                  else
-                  {
-                     pInfo.type = CPU_Intel_PentiumIII;
-                     pInfo.name = StringTable->insert( "Intel Pentium III Xeon" );
-                  }
-                  break;
-               case 0xD:
-                  if( extendedModel == 1 )
-                  {
-                     pInfo.type = CPU_Intel_Corei7Xeon;
-                     pInfo.name = StringTable->insert( "Intel Core i7 / Xeon" );
-                  }
-                  else
-                  {
-                     pInfo.type = CPU_Intel_PentiumM;
-                     pInfo.name = StringTable->insert( "Intel Pentium/Celeron M" );
-                  }
-                  break;
-               case 0xE:
-                  pInfo.type = CPU_Intel_Core;
-                  pInfo.name = StringTable->insert( "Intel Core" );
-                  break;
-               case 0xF:
-                  pInfo.type = CPU_Intel_Core2;
-                  pInfo.name = StringTable->insert( "Intel Core 2" );
-                  break;
-               default:
-                  pInfo.type = CPU_Intel_PentiumPro;
-                  pInfo.name = StringTable->insert( "Intel (unknown)" );
-                  break;
-            }
-            break;
-         }
-
-            // Pentium4 Family
-         case 0xf:
-            pInfo.type = CPU_Intel_Pentium4;
-            pInfo.name = StringTable->insert( "Intel Pentium 4" );
-            break;
-
-         default:
-            pInfo.type = CPU_Intel_Unknown;
-            pInfo.name = StringTable->insert( "Intel (unknown)" );
-            break;
-      }
+      pInfo.type = CPU_Intel;
+      pInfo.name = StringTable->insert(brand ? brand : "Intel (Unknown)");
    }
    //--------------------------------------
+   else if (dStricmp(vendor, "AuthenticAMD") == 0)
+   {
+      pInfo.name = StringTable->insert(brand ? brand : "AMD (unknown)");
+      pInfo.type = CPU_AMD;
+
+      // 3dnow! is only available in AMD cpus on x86. Otherwise its not reliably set.
+      pInfo.properties |= (properties & BIT_3DNOW) ? CPU_PROP_3DNOW : 0;
+   }
+   else if (dStricmp(vendor, "Apple") == 0)
+   {
+      pInfo.name = StringTable->insert(brand ? brand : "Apple (unknown)");
+      pInfo.type = CPU_Apple;
+   }
    else
-      if (dStricmp(vendor, "AuthenticAMD") == 0)
-      {
-         // AthlonXP processors support SSE
-         pInfo.properties |= (properties & BIT_SSE) ? CPU_PROP_SSE : 0;
-         pInfo.properties |= ( properties & BIT_SSE2 ) ? CPU_PROP_SSE2 : 0;
-         pInfo.properties |= (properties & BIT_3DNOW) ? CPU_PROP_3DNOW : 0;
-       // Phenom and PhenomII support SSE3, SSE4a
-       pInfo.properties |= ( properties2 & BIT_SSE3 ) ? CPU_PROP_SSE3 : 0;
-         pInfo.properties |= ( properties2 & BIT_SSE4_1 ) ? CPU_PROP_SSE4_1 : 0;
-         // switch on processor family code
-         switch ((processor >> 8) & 0xf)
-         {
-            // K6 Family
-            case 5:
-               // switch on processor model code
-               switch ((processor >> 4) & 0xf)
-               {
-                  case 0:
-                  case 1:
-                  case 2:
-                  case 3:
-                     pInfo.type = CPU_AMD_K6_3;
-                     pInfo.name = StringTable->insert("AMD K5");
-                     break;
-                  case 4:
-                  case 5:
-                  case 6:
-                  case 7:
-                     pInfo.type = CPU_AMD_K6;
-                     pInfo.name = StringTable->insert("AMD K6");
-                     break;
-                  case 8:
-                     pInfo.type = CPU_AMD_K6_2;
-                     pInfo.name = StringTable->insert("AMD K6-2");
-                     break;
-                  case 9:
-                  case 10:
-                  case 11:
-                  case 12:
-                  case 13:
-                  case 14:
-                  case 15:
-                     pInfo.type = CPU_AMD_K6_3;
-                     pInfo.name = StringTable->insert("AMD K6-3");
-                     break;
-               }
-               break;
-
-               // Athlon Family
-            case 6:
-               pInfo.type = CPU_AMD_Athlon;
-               pInfo.name = StringTable->insert("AMD Athlon");
-               break;
-
-               // Phenom Family
-         case 15:
-               pInfo.type = CPU_AMD_Phenom;
-               pInfo.name = StringTable->insert("AMD Phenom");
-               break;
-
-            // Phenom II Family
-         case 16:
-               pInfo.type = CPU_AMD_PhenomII;
-               pInfo.name = StringTable->insert("AMD Phenom II");
-               break;
-
-            // Bulldozer Family
-         case 17:
-               pInfo.type = CPU_AMD_Bulldozer;
-               pInfo.name = StringTable->insert("AMD Bulldozer");
-               break;
-
-            default:
-               pInfo.type = CPU_AMD_Unknown;
-               pInfo.name = StringTable->insert("AMD (unknown)");
-               break;
-         }
-      }
-   //--------------------------------------
-      else
-         if (dStricmp(vendor, "CyrixInstead") == 0)
-         {
-            switch (processor)
-            {
-               case 0x520:
-                  pInfo.type = CPU_Cyrix_6x86;
-                  pInfo.name = StringTable->insert("Cyrix 6x86");
-                  break;
-               case 0x440:
-                  pInfo.type = CPU_Cyrix_MediaGX;
-                  pInfo.name = StringTable->insert("Cyrix Media GX");
-                  break;
-               case 0x600:
-                  pInfo.type = CPU_Cyrix_6x86MX;
-                  pInfo.name = StringTable->insert("Cyrix 6x86mx/MII");
-                  break;
-               case 0x540:
-                  pInfo.type = CPU_Cyrix_GXm;
-                  pInfo.name = StringTable->insert("Cyrix GXm");
-                  break;
-               default:
-                  pInfo.type = CPU_Cyrix_Unknown;
-                  pInfo.name = StringTable->insert("Cyrix (unknown)");
-                  break;
-            }
-         }
+   {
+#if defined(TORQUE_CPU_X86) || defined(TORQUE_CPU_X64)
+      pInfo.name = StringTable->insert(brand ? brand : "x86 Compatible (unknown)");
+      pInfo.type = CPU_X86Compatible;
+#elif defined(TORQUE_CPU_ARM64)
+      pInfo.name = StringTable->insert(brand ? brand : "Arm Compatible (unknown)");
+      pInfo.type = CPU_ArmCompatible;
+#else
+#error "Unknown CPU Architecture"
+#endif
+   }
 
    // Get multithreading caps.
-
    CPUInfo::EConfig config = CPUInfo::CPUCount( pInfo.numLogicalProcessors, pInfo.numAvailableCores, pInfo.numPhysicalProcessors );
    pInfo.isHyperThreaded = CPUInfo::isHyperThreaded( config );
    pInfo.isMultiCore = CPUInfo::isMultiCore( config );
diff --git a/Engine/source/platformWin32/winCPUInfo.cpp b/Engine/source/platformWin32/winCPUInfo.cpp
index 4c836ad9e..3765f5c51 100644
--- a/Engine/source/platformWin32/winCPUInfo.cpp
+++ b/Engine/source/platformWin32/winCPUInfo.cpp
@@ -30,7 +30,7 @@
 Platform::SystemInfo_struct Platform::SystemInfo;
 extern void PlatformBlitInit();
 extern void SetProcessorInfo(Platform::SystemInfo_struct::Processor& pInfo,
-   char* vendor, U32 processor, U32 properties, U32 properties2); // platform/platformCPU.cc
+   char* vendor, char* brand, U32 processor, U32 properties, U32 properties2); // platform/platformCPU.cc
 
 void Processor::init()
 {
@@ -45,7 +45,7 @@ void Processor::init()
    Platform::SystemInfo.processor.type = CPU_X86Compatible;
    Platform::SystemInfo.processor.name = StringTable->insert("Unknown x86 Compatible");
    Platform::SystemInfo.processor.mhz  = 0;
-   Platform::SystemInfo.processor.properties = CPU_PROP_C | CPU_PROP_LE;
+   Platform::SystemInfo.processor.properties = CPU_PROP_C;
 
    char  vendor[0x20];
    dMemset(vendor, 0, sizeof(vendor));
@@ -65,7 +65,31 @@ void Processor::init()
    properties = cpuInfo[3];  // edx
    properties2 = cpuInfo[2]; // ecx
 
-   SetProcessorInfo(Platform::SystemInfo.processor, vendor, processor, properties, properties2);
+   char brand[0x40];
+   dMemset(brand, 0, sizeof(brand));
+   S32 extendedInfo[4];
+   __cpuid(extendedInfo, 0x80000000);
+   S32 numberExtendedIds = extendedInfo[0];
+
+   // Sets brand
+   if (numberExtendedIds >= 0x80000004)
+   {
+      int offset = 0;
+      for (int i = 0; i < 3; ++i)
+      {
+         S32 brandInfo[4];
+         __cpuidex(brandInfo, 0x80000002 + i, 0);
+
+         *reinterpret_cast<int*>(brand + offset + 0) = brandInfo[0];
+         *reinterpret_cast<int*>(brand + offset + 4) = brandInfo[1];
+         *reinterpret_cast<int*>(brand + offset + 8) = brandInfo[2];
+         *reinterpret_cast<int*>(brand + offset + 12) = brandInfo[3];
+
+         offset += sizeof(S32) * 4;
+      }
+   }
+
+   SetProcessorInfo(Platform::SystemInfo.processor, vendor, brand, processor, properties, properties2);
 
 // now calculate speed of processor...
    U32 nearmhz = 0; // nearest rounded mhz
@@ -126,6 +150,14 @@ void Processor::init()
       Con::printf( "   SSE detected" );
    if( Platform::SystemInfo.processor.properties & CPU_PROP_SSE2 )
       Con::printf( "   SSE2 detected" );
+   if (Platform::SystemInfo.processor.properties & CPU_PROP_SSE3)
+      Con::printf( "   SSE3 detected" );
+   if (Platform::SystemInfo.processor.properties & CPU_PROP_SSE3xt)
+      Con::printf( "   SSE3ex detected ");
+   if (Platform::SystemInfo.processor.properties & CPU_PROP_SSE4_1)
+      Con::printf( "   SSE4.1 detected" );
+   if (Platform::SystemInfo.processor.properties & CPU_PROP_SSE4_2)
+      Con::printf( "   SSE4.2 detected" );
    if( Platform::SystemInfo.processor.isHyperThreaded )
       Con::printf( "   HT detected" );
    if( Platform::SystemInfo.processor.properties & CPU_PROP_MP )

From 17d1253ba29b97d74686e5f3eccb34755ebe1758 Mon Sep 17 00:00:00 2001
From: Areloch <Areloch@gmail.com>
Date: Wed, 15 Sep 2021 00:41:23 -0500
Subject: [PATCH 077/399] Converts precipitationData to use sound asset macros
 Adds handling for soundProfile fields and lookups of sound assets by
 SFXProfile name in project importer

---
 Engine/source/T3D/fx/precipitation.cpp        | 17 ++++----
 Engine/source/T3D/fx/precipitation.h          | 39 ++++++++++---------
 .../pre40/T3Dpre4ProjectImporter.tscript      |  2 +-
 .../scripts/projectImporter.tscript           | 28 ++++++++++++-
 4 files changed, 58 insertions(+), 28 deletions(-)

diff --git a/Engine/source/T3D/fx/precipitation.cpp b/Engine/source/T3D/fx/precipitation.cpp
index caebe48cd..91249fe2b 100644
--- a/Engine/source/T3D/fx/precipitation.cpp
+++ b/Engine/source/T3D/fx/precipitation.cpp
@@ -127,7 +127,7 @@ ConsoleDocClass( PrecipitationData,
 //----------------------------------------------------------
 PrecipitationData::PrecipitationData()
 {
-   soundProfile      = NULL;
+   INIT_SOUNDASSET(Sound);
 
    INIT_IMAGEASSET(Drop);
 
@@ -143,8 +143,7 @@ PrecipitationData::PrecipitationData()
 
 void PrecipitationData::initPersistFields()
 {
-   addField( "soundProfile", TYPEID< SFXTrack >(), Offset(soundProfile, PrecipitationData),
-      "Looping SFXProfile effect to play while Precipitation is active." );
+   INITPERSISTFIELD_SOUNDASSET(Sound, PrecipitationData, "Looping SFXProfile effect to play while Precipitation is active.");
 
    addProtectedField( "dropTexture", TypeFilename, Offset(mDropName, PrecipitationData), &_setDropData, &defaultProtectedGetFn,
       "@brief Texture filename for drop particles.\n\n"
@@ -190,7 +189,7 @@ bool PrecipitationData::preload( bool server, String &errorStr )
    if( Parent::preload( server, errorStr) == false)
       return false;
 
-   if( !server && !sfxResolve( &soundProfile, errorStr ) )
+   if (!server && (mSoundAsset.isNull() || !mSoundAsset->getSfxProfile()))
       return false;
 
    return true;
@@ -200,7 +199,8 @@ void PrecipitationData::packData(BitStream* stream)
 {
    Parent::packData(stream);
 
-   sfxWrite( stream, soundProfile );
+   PACKDATA_SOUNDASSET(Sound);
+   //sfxWrite( stream, soundProfile );
 
    PACKDATA_IMAGEASSET(Drop);
 
@@ -217,7 +217,8 @@ void PrecipitationData::unpackData(BitStream* stream)
 {
    Parent::unpackData(stream);
 
-   sfxRead( stream, &soundProfile );
+   UNPACKDATA_SOUNDASSET(Sound);
+   //sfxRead( stream, &soundProfile );
 
    UNPACKDATA_IMAGEASSET(Drop);
 
@@ -598,9 +599,9 @@ bool Precipitation::onNewDataBlock( GameBaseData *dptr, bool reload )
    {
       SFX_DELETE( mAmbientSound );
 
-      if ( mDataBlock->soundProfile )
+      if ( mDataBlock->mSoundAsset && mDataBlock->mSoundAsset->getSfxProfile() )
       {
-         mAmbientSound = SFX->createSource( mDataBlock->soundProfile, &getTransform() );
+         mAmbientSound = SFX->createSource(mDataBlock->mSoundAsset->getSfxProfile(), &getTransform() );
          if ( mAmbientSound )
             mAmbientSound->play();
       }
diff --git a/Engine/source/T3D/fx/precipitation.h b/Engine/source/T3D/fx/precipitation.h
index 58c8c44dd..0bb06e0f2 100644
--- a/Engine/source/T3D/fx/precipitation.h
+++ b/Engine/source/T3D/fx/precipitation.h
@@ -34,8 +34,9 @@
 #endif
 
 #include "T3D/assets/ImageAsset.h"
+#include "T3D/assets/SoundAsset.h"
 
-class SFXTrack;
+//class SFXTrack;
 class SFXSource;
 
 //--------------------------------------------------------------------------
@@ -45,30 +46,32 @@ class PrecipitationData : public GameBaseData
    typedef GameBaseData Parent;
 
   public:
-   SFXTrack*     soundProfile;
+   //SFXTrack*     soundProfile;
+     DECLARE_SOUNDASSET(PrecipitationData, Sound);
+     DECLARE_SOUNDASSET_SETGET(PrecipitationData, Sound);
 
-   DECLARE_IMAGEASSET(PrecipitationData, Drop, onDropChanged, GFXStaticTextureSRGBProfile); ///< Texture for drop particles
-   DECLARE_IMAGEASSET_SETGET(PrecipitationData, Drop);
+      DECLARE_IMAGEASSET(PrecipitationData, Drop, onDropChanged, GFXStaticTextureSRGBProfile); ///< Texture for drop particles
+      DECLARE_IMAGEASSET_SETGET(PrecipitationData, Drop);
 
-   StringTableEntry mDropShaderName;   ///< The name of the shader used for raindrops
+      StringTableEntry mDropShaderName;   ///< The name of the shader used for raindrops
 
-   DECLARE_IMAGEASSET(PrecipitationData, Splash, onSplashChanged, GFXStaticTextureSRGBProfile); ///< Texture for splash particles
-   DECLARE_IMAGEASSET_SETGET(PrecipitationData, Splash);
+      DECLARE_IMAGEASSET(PrecipitationData, Splash, onSplashChanged, GFXStaticTextureSRGBProfile); ///< Texture for splash particles
+      DECLARE_IMAGEASSET_SETGET(PrecipitationData, Splash);
 
-   StringTableEntry mSplashShaderName; ///< The name of the shader used for raindrops
+      StringTableEntry mSplashShaderName; ///< The name of the shader used for raindrops
 
-   S32  mDropsPerSide;     ///< How many drops are on a side of the raindrop texture.
-   S32  mSplashesPerSide;  ///< How many splash are on a side of the splash texture.
+      S32  mDropsPerSide;     ///< How many drops are on a side of the raindrop texture.
+      S32  mSplashesPerSide;  ///< How many splash are on a side of the splash texture.
    
-   PrecipitationData();
-   DECLARE_CONOBJECT(PrecipitationData);
-   bool preload( bool server, String& errorStr );
-   static void  initPersistFields();
-   virtual void packData(BitStream* stream);
-   virtual void unpackData(BitStream* stream);
+      PrecipitationData();
+      DECLARE_CONOBJECT(PrecipitationData);
+      bool preload( bool server, String& errorStr );
+      static void  initPersistFields();
+      virtual void packData(BitStream* stream);
+      virtual void unpackData(BitStream* stream);
 
-   void onDropChanged() {}
-   void onSplashChanged() {}
+      void onDropChanged() {}
+      void onSplashChanged() {}
 };
 
 struct Raindrop
diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
index d996182dd..645bd38ca 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
@@ -919,7 +919,7 @@ T3Dpre4ProjectImporter::genProcessor("DebrisData", "shape shapeAsset shapeFile s
 T3Dpre4ProjectImporter::genProcessor("DecalData", "material materialAsset");
 T3Dpre4ProjectImporter::genProcessor("ExplosionData", "explosionShape explosionShapeAsset");
 T3Dpre4ProjectImporter::genProcessor("ParticleData", "texture textureAsset textureName textureAsset textureExt textureExtAsset textureExtName textureExtAsset");
-T3Dpre4ProjectImporter::genProcessor("PrecipitationData", "drop dropAsset dropTexture dropAsset splash splashAsset splashTexture splashAsset");
+T3Dpre4ProjectImporter::genProcessor("PrecipitationData", "drop dropAsset dropTexture dropAsset splash splashAsset splashTexture splashAsset soundProfile soundAsset");
 T3Dpre4ProjectImporter::genProcessor("SplashData", "texture textureAsset");
 T3Dpre4ProjectImporter::genProcessor("LightFlareData", "flareTexture flareTextureAsset");
 T3Dpre4ProjectImporter::genProcessor("PhysicsDebrisData", "shape shapeAsset shapeFile shapeAsset");
diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
index ab62befb8..073a7a6bf 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
@@ -556,23 +556,49 @@ function processLegacyField(%line, %originalFieldName, %newFieldName)
       %targetFilename = sanitizeFilename(%value);
       
       if(isObject(%targetFilename))
+         {
+         if(%originalFieldName $= "soundProfile")
+         {
+            $ProjectImporter::assetQuery.clear();
+            %foundAssets = AssetDatabase.findAssetName($ProjectImporter::assetQuery, %targetFilename);
+            if(%foundAssets != 0)
+            {
+               %assetId = $ProjectImporter::assetQuery.getAsset(0);  
+            }
+         }
+         else
          {
          //likely a material name, so handle it that way
          %assetId = MaterialAsset::getAssetIdByMaterialName(%targetFilename);
       }
+      }
       else
       {
          if(!isFile(%targetFilename))
       {
+            if(%originalFieldName $= "soundProfile")
+            {
+               $ProjectImporter::assetQuery.clear();
+               %foundAssets = AssetDatabase.findAssetName($ProjectImporter::assetQuery, %targetFilename);
+               if(%foundAssets != 0)
+               {
+                  %assetId = $ProjectImporter::assetQuery.getAsset(0);  
+               }
+            }
+            else
+            {
          error("Legacy Project Importer - file described in line could not be found/is not valid");
          return %line;
       }
-      
+         }
+         else
+         {
       $ProjectImporter::assetQuery.clear();
       %foundAssets = AssetDatabase.findAssetLooseFile($ProjectImporter::assetQuery, %targetFilename);
       if(%foundAssets != 0)
       {
          %assetId = $ProjectImporter::assetQuery.getAsset(0);
+            }
          }
       }
      

From f9b78597f768595d88cf757e1b7ac3b03db51305 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Thu, 16 Sep 2021 21:21:04 -0400
Subject: [PATCH 078/399] * BugFix: Correct an error that causes the engine to
 crash when calling non-namespaced engine functions incorrectly.

---
 Engine/source/console/compiledEval.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index f4c48ef68..561e1f04a 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -734,7 +734,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
    SimObject* curObject = NULL;
    SimObject* saveObject = NULL;
    Namespace::Entry* nsEntry;
-   Namespace* ns;
+   Namespace* ns = NULL;
    const char* curFNDocBlock = NULL;
    const char* curNSDocBlock = NULL;
    const S32 nsDocLength = 128;

From 21c17d0ed1748973d4558fd76c1a893bb2e7906a Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Fri, 17 Sep 2021 01:24:20 -0500
Subject: [PATCH 079/399] cleanups for shadergen and the visibility feature
 math fixes, feature inclusion removal. will still need to circle back on why
 the crosshatch.. isn't

---
 .../lighting/shadowMap/shadowMatHook.cpp      |  4 +---
 .../shaderGen/GLSL/shaderFeatureGLSL.cpp      | 24 ++++---------------
 .../shaderGen/HLSL/shaderFeatureHLSL.cpp      |  6 ++---
 .../core/rendering/shaders/gl/torque.glsl     |  4 ++--
 4 files changed, 11 insertions(+), 27 deletions(-)

diff --git a/Engine/source/lighting/shadowMap/shadowMatHook.cpp b/Engine/source/lighting/shadowMap/shadowMatHook.cpp
index 30f2db593..c6b8bab01 100644
--- a/Engine/source/lighting/shadowMap/shadowMatHook.cpp
+++ b/Engine/source/lighting/shadowMap/shadowMatHook.cpp
@@ -186,10 +186,8 @@ void ShadowMaterialHook::_overrideFeatures(  ProcessedMaterial *mat,
          type == MFT_TexAnim ||
          type == MFT_DiffuseMap ||
          type == MFT_IsTranslucent ||
-         type == MFT_Visibility ||
          type == MFT_UseInstancing ||
-         type == MFT_EyeSpaceDepthOut ||
-         type == MFT_DeferredConditioner)
+         type == MFT_EyeSpaceDepthOut)
             newFeatures.addFeature(type);
       else if (type.getGroup() == MFG_PreTransform ||
             type.getGroup() == MFG_Transform ||
diff --git a/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp b/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
index 2bd24931d..3ee76ffdf 100644
--- a/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
+++ b/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
@@ -455,12 +455,12 @@ Var* ShaderFeatureGLSL::addOutVpos( MultiLine *meta,
       outVpos = connectComp->getElement( RT_TEXCOORD );
       outVpos->setName( "outVpos" );
       outVpos->setStructName( "OUT" );
-      outVpos->setType( "vec4" );
+      outVpos->setType( "vec3" );
 
       Var *outPosition = (Var*) LangElement::find( "gl_Position" );
       AssertFatal( outPosition, "ShaderFeatureGLSL::addOutVpos - Didn't find the output position." );
 
-      meta->addStatement( new GenOp( "   @ = @;\r\n", outVpos, outPosition ) );
+      meta->addStatement( new GenOp( "   @ = @.xyz;\r\n", outVpos, outPosition ) );
    }
 
    return outVpos;
@@ -474,25 +474,11 @@ Var* ShaderFeatureGLSL::getInVpos(  MultiLine *meta,
       return inVpos;
 
    ShaderConnector *connectComp = dynamic_cast<ShaderConnector*>( componentList[C_CONNECTOR] );
-   /*
-   if ( GFX->getPixelShaderVersion() >= 3.0f )
-   {
-      inVpos = connectComp->getElement( RT_VPOS );
-      inVpos->setName( "vpos" );
-      inVpos->setStructName( "IN" );
-      inVpos->setType( "vec2" );
-      return inVpos;
-   }
-   */
    inVpos = connectComp->getElement( RT_TEXCOORD );
    inVpos->setName( "inVpos" );
    inVpos->setStructName( "IN" );
    inVpos->setType( "vec4" );
-
-   Var *vpos = new Var( "vpos", "vec2" );
-   meta->addStatement( new GenOp( "   @ = @.xy / @.w;\r\n", new DecOp( vpos ), inVpos, inVpos ) );
-
-   return vpos;
+   return inVpos;
 }
 
 Var* ShaderFeatureGLSL::getInWorldToTangent( Vector<ShaderComponent*> &componentList )
@@ -2473,7 +2459,7 @@ void VisibilityFeatGLSL::processPix(   Vector<ShaderComponent*> &componentList,
 
    // Everything else does a fizzle.
    Var *vPos = getInVpos( meta, componentList );
-   meta->addStatement( new GenOp( "   fizzle( @, @ );\r\n", vPos, visibility ) );
+   meta->addStatement( new GenOp( "   fizzle( @.xy, @ );\r\n", vPos, visibility ) );
 }
 
 ShaderFeature::Resources VisibilityFeatGLSL::getResources( const MaterialFeatureData &fd )
@@ -2616,7 +2602,7 @@ void FoliageFeatureGLSL::processVert( Vector<ShaderComponent*> &componentList,
    tangent->setType( "vec3" );
    tangent->setName( "T" );
    LangElement *tangentDec = new DecOp( tangent );
-   meta->addStatement( new GenOp( "   @;\n", tangentDec ) );         
+   meta->addStatement( new GenOp( "   @ = vec3(1.0,0,0);\n", tangentDec ) );         
 	
 	// We add a float foliageFade to the OUT structure.
    ShaderConnector *connectComp = dynamic_cast<ShaderConnector *>( componentList[C_CONNECTOR] );
diff --git a/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp b/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
index 80601ad68..2fe171aba 100644
--- a/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
+++ b/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
@@ -453,12 +453,12 @@ Var* ShaderFeatureHLSL::addOutVpos( MultiLine *meta,
       outVpos = connectComp->getElement( RT_TEXCOORD );
       outVpos->setName( "outVpos" );
       outVpos->setStructName( "OUT" );
-      outVpos->setType( "float4" );
+      outVpos->setType( "float3" );
 
       Var *outPosition = (Var*) LangElement::find( "hpos" );
       AssertFatal( outPosition, "ShaderFeatureHLSL::addOutVpos - Didn't find the output position." );
 
-      meta->addStatement( new GenOp( "   @ = @;\r\n", outVpos, outPosition ) );
+      meta->addStatement( new GenOp( "   @ = @.xyz;\r\n", outVpos, outPosition ) );
    }
 
    return outVpos;
@@ -2686,7 +2686,7 @@ void FoliageFeatureHLSL::processVert( Vector<ShaderComponent*> &componentList,
    tangent->setType( "float3" );
    tangent->setName( "T" );
    LangElement *tangentDec = new DecOp( tangent );
-   meta->addStatement( new GenOp( "   @;\n", tangentDec ) );         
+   meta->addStatement( new GenOp( "   @ = float3(1.0,0,0);\n", tangentDec ) );         
 
    // We add a float foliageFade to the OUT structure.
    ShaderConnector *connectComp = dynamic_cast<ShaderConnector *>( componentList[C_CONNECTOR] );
diff --git a/Templates/BaseGame/game/core/rendering/shaders/gl/torque.glsl b/Templates/BaseGame/game/core/rendering/shaders/gl/torque.glsl
index 5482bdaf3..4ec0303aa 100644
--- a/Templates/BaseGame/game/core/rendering/shaders/gl/torque.glsl
+++ b/Templates/BaseGame/game/core/rendering/shaders/gl/torque.glsl
@@ -291,8 +291,8 @@ void fizzle(vec2 vpos, float visibility)
    // I'm sure there are many more patterns here to 
    // discover for different effects.
    
-   mat2x2 m = mat2x2( vpos.x, vpos.y, 0.916, 0.350 );
-   if( (visibility - fract( determinant( m ) )) < 0 ) //if(a < 0) discard;
+   mat2x2 m = mat2x2( vpos.x, 0.916, vpos.y, 0.350 );
+   if( (visibility - fract( determinant( m ) )) < 0 )
       discard;
 }
 #endif //TORQUE_PIXEL_SHADER

From c8a5ccb191b22d0d974778a8c98a789923528218 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Fri, 17 Sep 2021 17:37:19 -0400
Subject: [PATCH 080/399] * [OpenGL] BugFix: Correct shader errors being thrown
 during the load phase due to direct use of glUseProgram causing desync with
 GFXGLDevice.

---
 Engine/source/gfx/gl/gfxGLDevice.cpp | 2 +-
 Engine/source/gfx/gl/gfxGLShader.cpp | 8 +++++---
 Engine/source/gfx/gl/gfxGLShader.h   | 6 ++++--
 3 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/Engine/source/gfx/gl/gfxGLDevice.cpp b/Engine/source/gfx/gl/gfxGLDevice.cpp
index 6179bd618..1c82b4e74 100644
--- a/Engine/source/gfx/gl/gfxGLDevice.cpp
+++ b/Engine/source/gfx/gl/gfxGLDevice.cpp
@@ -933,7 +933,7 @@ void GFXGLDevice::setupGenericShaders( GenericShaderType type )
 }
 GFXShader* GFXGLDevice::createShader()
 {
-   GFXGLShader* shader = new GFXGLShader();
+   GFXGLShader* shader = new GFXGLShader(this);
    shader->registerResourceWithDevice( this );
    return shader;
 }
diff --git a/Engine/source/gfx/gl/gfxGLShader.cpp b/Engine/source/gfx/gl/gfxGLShader.cpp
index d2f2edd22..ce8e7c855 100644
--- a/Engine/source/gfx/gl/gfxGLShader.cpp
+++ b/Engine/source/gfx/gl/gfxGLShader.cpp
@@ -382,10 +382,11 @@ void GFXGLShaderConstBuffer::onShaderReload( GFXGLShader *shader )
    mWasLost = true;
 }
 
-GFXGLShader::GFXGLShader() :
+GFXGLShader::GFXGLShader(GFXGLDevice* device) :
    mVertexShader(0),
    mPixelShader(0),
    mProgram(0),
+   mDevice(device),
    mConstBufferSize(0),
    mConstBuffer(NULL)
 {
@@ -706,7 +707,8 @@ void GFXGLShader::initHandles()
    dMemset(mConstBuffer, 0, mConstBufferSize);
    
    // Set our program so uniforms are assigned properly.
-   glUseProgram(mProgram);
+   mDevice->setShader(this, false);
+
    // Iterate through uniforms to set sampler numbers.
    for (HandleMap::Iterator iter = mHandles.begin(); iter != mHandles.end(); ++iter)
    {
@@ -723,7 +725,6 @@ void GFXGLShader::initHandles()
          dMemcpy(mConstBuffer + handle->mOffset, &handle->mSamplerNum, handle->getSize());
       }
    }
-   glUseProgram(0);
 
    //instancing
    if (!mInstancingFormat)
@@ -830,6 +831,7 @@ void GFXGLShader::setConstantsFromBuffer(GFXGLShaderConstBuffer* buffer)
          
       // Copy new value into our const buffer and set in GL.
       dMemcpy(mConstBuffer + handle->mOffset, buffer->mBuffer + handle->mOffset, handle->getSize());
+
       switch(handle->mDesc.constType)
       {
          case GFXSCT_Float:
diff --git a/Engine/source/gfx/gl/gfxGLShader.h b/Engine/source/gfx/gl/gfxGLShader.h
index 80fa4d9d9..e3d3bb69c 100644
--- a/Engine/source/gfx/gl/gfxGLShader.h
+++ b/Engine/source/gfx/gl/gfxGLShader.h
@@ -32,14 +32,15 @@
 class GFXGLShaderConstHandle;
 class FileStream;
 class GFXGLShaderConstBuffer;
+class GFXGLDevice;
 
 class GFXGLShader : public GFXShader
 {
    typedef Map<String, GFXGLShaderConstHandle*> HandleMap;
 public:
-   GFXGLShader();
+   GFXGLShader(GFXGLDevice* device);
    virtual ~GFXGLShader();
-   
+
    /// @name GFXShader interface
    /// @{
    virtual GFXShaderConstHandle* getShaderConstHandle(const String& name);
@@ -99,6 +100,7 @@ protected:
    U32 mConstBufferSize;
    U8* mConstBuffer;
    HandleMap mHandles;
+   GFXGLDevice* mDevice;
    Vector<GFXGLShaderConstHandle*> mValidHandles;
 };
 

From 2a8f8c15f36a309eeb1bcdc7842881645d804bde Mon Sep 17 00:00:00 2001
From: Areloch <Areloch@gmail.com>
Date: Sat, 18 Sep 2021 02:46:15 -0500
Subject: [PATCH 081/399] Shifted long-form check/fetch of sound asset's
 SFXProfile to a convenience function Fixed formatting on
 projectImporter.tscript file

---
 Engine/source/T3D/fx/precipitation.cpp        |  8 +++---
 Engine/source/T3D/fx/precipitation.h          |  7 +++++
 .../scripts/projectImporter.tscript           | 26 +++++++++----------
 3 files changed, 23 insertions(+), 18 deletions(-)

diff --git a/Engine/source/T3D/fx/precipitation.cpp b/Engine/source/T3D/fx/precipitation.cpp
index 91249fe2b..4356cd45f 100644
--- a/Engine/source/T3D/fx/precipitation.cpp
+++ b/Engine/source/T3D/fx/precipitation.cpp
@@ -189,7 +189,7 @@ bool PrecipitationData::preload( bool server, String &errorStr )
    if( Parent::preload( server, errorStr) == false)
       return false;
 
-   if (!server && (mSoundAsset.isNull() || !mSoundAsset->getSfxProfile()))
+   if (!server && !getSFXProfile())
       return false;
 
    return true;
@@ -200,7 +200,6 @@ void PrecipitationData::packData(BitStream* stream)
    Parent::packData(stream);
 
    PACKDATA_SOUNDASSET(Sound);
-   //sfxWrite( stream, soundProfile );
 
    PACKDATA_IMAGEASSET(Drop);
 
@@ -218,7 +217,6 @@ void PrecipitationData::unpackData(BitStream* stream)
    Parent::unpackData(stream);
 
    UNPACKDATA_SOUNDASSET(Sound);
-   //sfxRead( stream, &soundProfile );
 
    UNPACKDATA_IMAGEASSET(Drop);
 
@@ -599,9 +597,9 @@ bool Precipitation::onNewDataBlock( GameBaseData *dptr, bool reload )
    {
       SFX_DELETE( mAmbientSound );
 
-      if ( mDataBlock->mSoundAsset && mDataBlock->mSoundAsset->getSfxProfile() )
+      if ( mDataBlock->getSFXProfile())
       {
-         mAmbientSound = SFX->createSource(mDataBlock->mSoundAsset->getSfxProfile(), &getTransform() );
+         mAmbientSound = SFX->createSource(mDataBlock->getSFXProfile(), &getTransform() );
          if ( mAmbientSound )
             mAmbientSound->play();
       }
diff --git a/Engine/source/T3D/fx/precipitation.h b/Engine/source/T3D/fx/precipitation.h
index 0bb06e0f2..cdef0c2a8 100644
--- a/Engine/source/T3D/fx/precipitation.h
+++ b/Engine/source/T3D/fx/precipitation.h
@@ -72,6 +72,13 @@ class PrecipitationData : public GameBaseData
 
       void onDropChanged() {}
       void onSplashChanged() {}
+
+      SFXProfile* getSFXProfile() {
+         if (mSoundAsset.notNull())
+            return mSoundAsset->getSfxProfile();
+         else
+            return NULL;
+      }
 };
 
 struct Raindrop
diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
index 073a7a6bf..039a71238 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
@@ -556,7 +556,7 @@ function processLegacyField(%line, %originalFieldName, %newFieldName)
       %targetFilename = sanitizeFilename(%value);
       
       if(isObject(%targetFilename))
-         {
+      {
          if(%originalFieldName $= "soundProfile")
          {
             $ProjectImporter::assetQuery.clear();
@@ -568,14 +568,14 @@ function processLegacyField(%line, %originalFieldName, %newFieldName)
          }
          else
          {
-         //likely a material name, so handle it that way
-         %assetId = MaterialAsset::getAssetIdByMaterialName(%targetFilename);
-      }
+            //likely a material name, so handle it that way
+            %assetId = MaterialAsset::getAssetIdByMaterialName(%targetFilename);
+         }
       }
       else
       {
          if(!isFile(%targetFilename))
-      {
+         {
             if(%originalFieldName $= "soundProfile")
             {
                $ProjectImporter::assetQuery.clear();
@@ -587,17 +587,17 @@ function processLegacyField(%line, %originalFieldName, %newFieldName)
             }
             else
             {
-         error("Legacy Project Importer - file described in line could not be found/is not valid");
-         return %line;
-      }
+               error("Legacy Project Importer - file described in line could not be found/is not valid");
+               return %line;
+            }
          }
          else
          {
-      $ProjectImporter::assetQuery.clear();
-      %foundAssets = AssetDatabase.findAssetLooseFile($ProjectImporter::assetQuery, %targetFilename);
-      if(%foundAssets != 0)
-      {
-         %assetId = $ProjectImporter::assetQuery.getAsset(0);
+            $ProjectImporter::assetQuery.clear();
+            %foundAssets = AssetDatabase.findAssetLooseFile($ProjectImporter::assetQuery, %targetFilename);
+            if(%foundAssets != 0)
+            {
+               %assetId = $ProjectImporter::assetQuery.getAsset(0);
             }
          }
       }

From adec6e7c74375bbad47bb4accc0b18f0db8965c7 Mon Sep 17 00:00:00 2001
From: Areloch <Areloch@gmail.com>
Date: Sun, 19 Sep 2021 01:01:47 -0500
Subject: [PATCH 082/399] Adds load status to MaterialAsset for if the Script
 file itself has been loaded, but the material itself hasn't yet been
 processed. Fixed String -> StringTableEntry conversion in prefab file to
 correct corruption when setting the filename Cleaned up message spam from the
 MaterialSlot fields on TSStatics Added getter/setters for terrain file and
 assets Removed unneeded exec of tools profiles for MainMenuGUI Add logic to
 remove creators section of AB if in select mode Fixed misc. messageBox
 invokes that were erroneously converted to 'toolsMessageBox' Fix classname
 for NotesObject in AB Creator Entry Fix issue where ConvexShapeEditor toolbar
 would hide after being seen once Changed keybind for quick AB access from
 'space' to 'shift space' to avoid input issues when typing in fields in some
 cases Fixed default image assignments for River objects on foam/ripple/depth
 Added handling for Material, Sound and Shape asset fields in Object Builder,
 and updated various objectBuilder class entries to utilize them now. Updated
 various fields' defaults for ObjectBuilder to utilize correct assetId's Fixed
 editor SceneTree tooltips for TSShape and GroundCovert to correctly reference
 assets as needed Added logic to properly check terrain asset validity when
 prompting to save changes, which would break saving actions before Added
 menubar items in the Object category to take control and release control of
 control objects quickly for testing

---
 Engine/source/T3D/assets/MaterialAsset.cpp    |  27 +-
 Engine/source/T3D/assets/MaterialAsset.h      |   6 +
 Engine/source/T3D/prefab.cpp                  |   4 +-
 Engine/source/T3D/prefab.h                    |   2 +-
 Engine/source/T3D/tsStatic.cpp                |   4 -
 Engine/source/terrain/terrData.cpp            |  12 +
 Engine/source/terrain/terrData.h              |  33 ++
 .../BaseGame/game/data/UI/guis/mainMenu.gui   |   2 -
 .../assetBrowser/scripts/assetBrowser.tscript |   4 +-
 .../scripts/assetTypes/terrain.tscript        |   2 +-
 .../assetBrowser/scripts/creator.tscript      |   2 +-
 .../game/tools/convexEditor/main.tscript      |   1 -
 .../guiEditor/scripts/guiEditor.ed.tscript    |   2 +-
 .../scripts/guiEditorCanvas.ed.tscript        |  10 +-
 .../scripts/guiEditorNewGuiDialog.ed.tscript  |   2 +-
 .../tools/riverEditor/riverEditorGui.tscript  |   6 +-
 .../worldEditor/gui/objectBuilderGui.ed.gui   | 333 ++++++++++++++++--
 .../worldEditor/scripts/EditorGui.ed.tscript  |  10 +-
 .../scripts/editor.keybinds.tscript           |   2 +-
 .../scripts/menuHandlers.ed.tscript           |  42 ++-
 .../worldEditor/scripts/menus.ed.tscript      |   8 +-
 21 files changed, 436 insertions(+), 78 deletions(-)

diff --git a/Engine/source/T3D/assets/MaterialAsset.cpp b/Engine/source/T3D/assets/MaterialAsset.cpp
index eaafca03d..8fd2b6ecf 100644
--- a/Engine/source/T3D/assets/MaterialAsset.cpp
+++ b/Engine/source/T3D/assets/MaterialAsset.cpp
@@ -169,7 +169,13 @@ void MaterialAsset::initializeAsset()
    mScriptPath = getOwned() ? expandAssetFilePath(mScriptFile) : mScriptPath;
 
    if (Torque::FS::IsScriptFile(mScriptPath))
-      Con::executeFile(mScriptPath, false, false);
+   {
+      if (!Sim::findObject(mMatDefinitionName))
+         if (Con::executeFile(mScriptPath, false, false))
+            mLoadedState = ScriptLoaded;
+         else
+            mLoadedState = Failed;
+   }
 
    loadMaterial();
 }
@@ -179,7 +185,22 @@ void MaterialAsset::onAssetRefresh()
    mScriptPath = getOwned() ? expandAssetFilePath(mScriptFile) : mScriptPath;
 
    if (Torque::FS::IsScriptFile(mScriptPath))
-      Con::executeFile(mScriptPath, false, false);
+   {
+      //Since we're refreshing, we can assume that the file we're executing WILL have an existing definition.
+      //But that definition, whatever it is, is the 'correct' one, so we enable the Replace Existing behavior
+      //when the engine encounters a named object conflict.
+      String redefineBehaviorPrev = Con::getVariable("$Con::redefineBehavior");
+      Con::setVariable("$Con::redefineBehavior", "replaceExisting");
+
+      if (Con::executeFile(mScriptPath, false, false))
+         mLoadedState = ScriptLoaded;
+      else
+         mLoadedState = Failed;
+
+      //And now that we've executed, switch back to the prior behavior
+      Con::setVariable("$Con::redefineBehavior", redefineBehaviorPrev.c_str());
+      
+   }
 
    loadMaterial();
 }
@@ -206,7 +227,7 @@ void MaterialAsset::loadMaterial()
    if (mMaterialDefinition)
       SAFE_DELETE(mMaterialDefinition);
 
-   if (mMatDefinitionName != StringTable->EmptyString())
+   if (mLoadedState == ScriptLoaded && mMatDefinitionName != StringTable->EmptyString())
    {
       Material* matDef;
       if (!Sim::findObject(mMatDefinitionName, matDef))
diff --git a/Engine/source/T3D/assets/MaterialAsset.h b/Engine/source/T3D/assets/MaterialAsset.h
index 018e2a989..07ec0227a 100644
--- a/Engine/source/T3D/assets/MaterialAsset.h
+++ b/Engine/source/T3D/assets/MaterialAsset.h
@@ -70,6 +70,12 @@ class MaterialAsset : public AssetBase
 public:
    static StringTableEntry smNoMaterialAssetFallback;
 
+   enum MaterialAssetErrCode
+   {
+      ScriptLoaded = AssetErrCode::Extended,
+      Extended
+   };
+
 public:
    MaterialAsset();
    virtual ~MaterialAsset();
diff --git a/Engine/source/T3D/prefab.cpp b/Engine/source/T3D/prefab.cpp
index 38934062f..0bebb443f 100644
--- a/Engine/source/T3D/prefab.cpp
+++ b/Engine/source/T3D/prefab.cpp
@@ -242,7 +242,7 @@ bool Prefab::protectedSetFile( void *object, const char *index, const char *data
    return false;
 }
 
-void Prefab::setFile( String file )
+void Prefab::setFile( StringTableEntry file )
 {  
    AssertFatal( isServerObject(), "Prefab-bad" );
 
@@ -257,7 +257,7 @@ void Prefab::setFile( String file )
    // be called for the client-side prefab but maybe the user did so accidentally.
    if ( isClientObject() )
    {
-      Con::errorf( "Prefab::setFile( %s ) - Should not be called on a client-side Prefab.", file.c_str() );
+      Con::errorf( "Prefab::setFile( %s ) - Should not be called on a client-side Prefab.", file );
       return;
    }
 
diff --git a/Engine/source/T3D/prefab.h b/Engine/source/T3D/prefab.h
index 6ebe88b0a..def70857e 100644
--- a/Engine/source/T3D/prefab.h
+++ b/Engine/source/T3D/prefab.h
@@ -90,7 +90,7 @@ public:
    void render( ObjectRenderInst *ri, SceneRenderState *state, BaseMatInstance *overrideMat );
 
    ///
-   void setFile( String file );
+   void setFile(StringTableEntry file );
 
    /// Removes all children from this Prefab and puts them into a SimGroup
    /// which is added to the Scene and returned to the caller.
diff --git a/Engine/source/T3D/tsStatic.cpp b/Engine/source/T3D/tsStatic.cpp
index 9b093f476..9028653b8 100644
--- a/Engine/source/T3D/tsStatic.cpp
+++ b/Engine/source/T3D/tsStatic.cpp
@@ -1675,10 +1675,6 @@ void TSStatic::onInspect(GuiInspector* inspector)
          {
             dSprintf(matFieldName, 128, "MaterialSlot%d", i);
 
-            //addComponentField(matFieldName, "A material used in the shape file", "Material", matAsset->getAssetId(), "");
-            //Con::executef(this, "onConstructComponentField", mTargetComponent, field->mFieldName);
-            Con::printf("Added material field for MaterialSlot %d", i);
-
             GuiInspectorField* fieldGui = materialGroup->constructField(TypeMaterialAssetPtr);
             fieldGui->init(inspector, materialGroup);
 
diff --git a/Engine/source/terrain/terrData.cpp b/Engine/source/terrain/terrData.cpp
index a80e350f0..be43d6638 100644
--- a/Engine/source/terrain/terrData.cpp
+++ b/Engine/source/terrain/terrData.cpp
@@ -1613,3 +1613,15 @@ void TerrainBlock::deleteZodiacPrimitiveBuffer()
    }
 }
 
+DefineEngineMethod(TerrainBlock, getTerrain, String, (), , "Returns the terrain file used for this terrain block, either via the asset or the filename assigned, which ever is valid")
+{
+   return object->getTerrain(); 
+}
+DefineEngineMethod(TerrainBlock, getTerrainAsset, String, (), , "Returns the assetId used for this terrain block")
+{
+   return object->getTerrainAssetId();
+}
+DefineEngineMethod(TerrainBlock, setTerrain, bool, (const char* terrain), , "Terrain assignment.first tries asset then flat file.")
+{
+   return object->_setTerrain(StringTable->insert(terrain));
+}
diff --git a/Engine/source/terrain/terrData.h b/Engine/source/terrain/terrData.h
index 5550ea30e..cc1479004 100644
--- a/Engine/source/terrain/terrData.h
+++ b/Engine/source/terrain/terrData.h
@@ -488,6 +488,39 @@ public:
    void inspectPostApply();
 
    virtual void getUtilizedAssets(Vector<StringTableEntry>* usedAssetsList);
+
+   const StringTableEntry getTerrain() const
+   {
+      if (mTerrainAsset && (mTerrainAsset->getTerrainFilePath() != StringTable->EmptyString()))
+         return mTerrainAsset->getTerrainFilePath(); 
+      else if (mTerrainAssetId != StringTable->EmptyString())
+         return mTerrainAssetId; 
+      else if (mTerrFileName != StringTable->EmptyString())
+         return mTerrFileName; 
+      else
+         return StringTable->EmptyString(); 
+   }
+
+   const StringTableEntry getTerrainAssetId() const
+   {
+      if (mTerrainAssetId != StringTable->EmptyString())
+         return mTerrainAssetId;
+      else
+         return StringTable->EmptyString();
+   }
+
+   bool _setTerrain(StringTableEntry terrain)
+   {
+      if (terrain == StringTable->EmptyString())
+         return false;
+
+      if (AssetDatabase.isDeclaredAsset(terrain))
+         setTerrainAsset(terrain);
+      else
+         mTerrFileName = terrain;
+
+      return true;
+   }
  
 protected:
    bool mUpdateBasetex;
diff --git a/Templates/BaseGame/game/data/UI/guis/mainMenu.gui b/Templates/BaseGame/game/data/UI/guis/mainMenu.gui
index 4cc06b26e..f33c06b1d 100644
--- a/Templates/BaseGame/game/data/UI/guis/mainMenu.gui
+++ b/Templates/BaseGame/game/data/UI/guis/mainMenu.gui
@@ -1,5 +1,3 @@
-exec( "tools/gui/profiles.ed.tscript" );
-
 //--- OBJECT WRITE BEGIN ---
 $guiContent = new GuiChunkedBitmapCtrl(MainMenuGui) {
    bitmapAsset = "UI:background_dark_image";
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
index ec2d0db4d..747d3e86d 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
@@ -618,7 +618,9 @@ function AssetBrowser::loadDirectories( %this )
    
    %dataItem = AssetBrowser-->filterTree.insertItem(AssetBrowser-->filterTree.modulesIdx, "data");
    AssetBrowser-->filterTree.tagsIdx = AssetBrowser-->filterTree.insertItem(1, "Tags");
-   AssetBrowser-->filterTree.creatorIdx = AssetBrowser-->filterTree.insertItem(1, "Creator");
+   
+   if(!%this.selectMode)
+      AssetBrowser-->filterTree.creatorIdx = AssetBrowser-->filterTree.insertItem(1, "Creator");
    
    %this.dirHandler.loadFolders("data", %dataItem);
    
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrain.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrain.tscript
index 9081729d0..c7e8fe92e 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrain.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrain.tscript
@@ -79,7 +79,7 @@ function AssetBrowser::createTerrainAsset(%this)
       }
       else
       {
-         toolsMessageBox( "Import Terrain", 
+         MessageBox( "Import Terrain", 
             "Terrain import failed! Check console for error messages.", 
             "Ok", "Error" );
       }
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript
index 15dc88d0a..48366f453 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript
@@ -47,7 +47,7 @@ function AssetBrowser::loadCreatorClasses(%this)
       %this.addCreatorClass("LevelInfo",    "Level Info" );
       %this.addCreatorClass("Marker",       "Path Node" );
       %this.addCreatorClass("MissionArea",  "Mission Area" );
-      %this.addCreatorClass("Note",         "Note" );
+      %this.addCreatorClass("NotesObject",         "Note" );
       %this.addCreatorClass("Path" );
       %this.addCreatorClass("SpawnSphere",  "General Spawn Sphere" );
       %this.addCreatorClass("SpawnSphere",  "Player Spawn Sphere"/*, "PlayerDropPoint"*/ );
diff --git a/Templates/BaseGame/game/tools/convexEditor/main.tscript b/Templates/BaseGame/game/tools/convexEditor/main.tscript
index 260c955ae..3930f5b11 100644
--- a/Templates/BaseGame/game/tools/convexEditor/main.tscript
+++ b/Templates/BaseGame/game/tools/convexEditor/main.tscript
@@ -145,7 +145,6 @@ function ConvexEditorPlugin::onDeactivated( %this )
 
    ConvexEditorTreeWindow.setVisible( false );
    ConvexEditorOptionsWindow.setVisible( false );
-   ConvexEditorToolbar.setVisible( false );
    %this.map.pop();
    
    // Remove our menu.
diff --git a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditor.ed.tscript b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditor.ed.tscript
index e9eabea7e..823fa39b3 100644
--- a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditor.ed.tscript
@@ -910,7 +910,7 @@ function GuiEditorTabBook::onWake( %this )
          item[ 1 ] = "Categorized View" TAB "" TAB "GuiEditorToolbox.setViewType( \"Categorized\" );";
       };
       
-   GlobalActionMap.bindCmd( keyboard, space, "", "AssetBrowser.toggleDialog();" );
+   GlobalActionMap.bindCmd( keyboard, "shift space", "", "AssetBrowser.toggleDialog();" );
 }
 
 //---------------------------------------------------------------------------------------------
diff --git a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorCanvas.ed.tscript b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorCanvas.ed.tscript
index 1fbe50c12..f62fe12ea 100644
--- a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorCanvas.ed.tscript
+++ b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorCanvas.ed.tscript
@@ -283,7 +283,7 @@ function GuiEditCanvas::load( %this, %filename )
    // group. And, it should be the only thing in the group.
    if( !isObject( $guiContent ) )
    {
-      toolsMessageBox( getEngineName(),
+      MessageBox( getEngineName(),
          "You have loaded a Gui file that was created before this version.  It has been loaded but you must open it manually from the content list dropdown",
          "Ok", "Information" );   
       return 0;
@@ -333,7 +333,7 @@ function GuiEditCanvas::save( %this, %selectedOnly, %noPrompt )
          return;
       else if( %selected.getCount() > 1 )
       {
-         toolsMessageBox( "Invalid selection", "Only a single control hierarchy can be saved to a file.  Make sure you have selected only one control in the tree view." );
+         MessageBox( "Invalid selection", "Only a single control hierarchy can be saved to a file.  Make sure you have selected only one control in the tree view." );
          return;
       }
          
@@ -464,7 +464,7 @@ function GuiEditCanvas::save( %this, %selectedOnly, %noPrompt )
       GuiEditorStatusBar.print( "Saved file '" @ %currentObject.getFileName() @ "'" );
    }
    else
-      toolsMessageBox( "Error writing to file", "There was an error writing to file '" @ %currentFile @ "'. The file may be read-only.", "Ok", "Error" );   
+      MessageBox( "Error writing to file", "There was an error writing to file '" @ %currentFile @ "'. The file may be read-only.", "Ok", "Error" );   
 }
 
 //---------------------------------------------------------------------------------------------
@@ -490,7 +490,7 @@ function GuiEditCanvas::append( %this )
    
    if( !isObject( $guiContent ) )
    {
-      toolsMessageBox( "Error loading GUI file", "The GUI content controls could not be found.  This function can only be used with files saved by the GUI editor.", "Ok", "Error" );
+      MessageBox( "Error loading GUI file", "The GUI content controls could not be found.  This function can only be used with files saved by the GUI editor.", "Ok", "Error" );
       return;
    }
    
@@ -519,7 +519,7 @@ function GuiEditCanvas::revert( %this )
    if( %filename $= "" )
       return;
       
-   if( toolsMessageBox( "Revert Gui", "Really revert the current Gui?  This cannot be undone.", "OkCancel", "Question" ) == $MROk )
+   if( MessageBox( "Revert Gui", "Really revert the current Gui?  This cannot be undone.", "OkCancel", "Question" ) == $MROk )
       %this.load( %filename );
 }
 
diff --git a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorNewGuiDialog.ed.tscript b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorNewGuiDialog.ed.tscript
index 85fa7263e..248c0e97d 100644
--- a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorNewGuiDialog.ed.tscript
+++ b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorNewGuiDialog.ed.tscript
@@ -81,7 +81,7 @@ function GuiEditorNewGuiDialog::onOK( %this )
 
    if( isObject( %name ) && %name.isMemberOfClass( "GuiControl" ) )
    {
-      if( toolsMessageBox( "Warning", "Replace the existing control '" @ %name @ "'?", "OkCancel", "Question" ) == $MROk )
+      if( MessageBox( "Warning", "Replace the existing control '" @ %name @ "'?", "OkCancel", "Question" ) == $MROk )
          %name.delete();
       else
          return;
diff --git a/Templates/BaseGame/game/tools/riverEditor/riverEditorGui.tscript b/Templates/BaseGame/game/tools/riverEditor/riverEditorGui.tscript
index 814782cb2..bb0f40037 100644
--- a/Templates/BaseGame/game/tools/riverEditor/riverEditorGui.tscript
+++ b/Templates/BaseGame/game/tools/riverEditor/riverEditorGui.tscript
@@ -76,9 +76,9 @@ function RiverEditorGui::createRiver( %this )
 
       baseColor = "45 108 171 255";
       
-      rippleTex = "core/rendering/images/ripple.dds";
-      foamTex = "core/rendering/images/foam";
-      depthGradientTex = "core/rendering/images/depthcolor_ramp";
+      rippleTex = "Core_Rendering:ripple_image";
+      foamTex = "Core_Rendering:foam_image";
+      depthGradientTex = "Core_Rendering:depthcolor_ramp_image";
    };
    
    return %river;
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/objectBuilderGui.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/objectBuilderGui.ed.gui
index dc757dc54..8dafe0357 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/objectBuilderGui.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/objectBuilderGui.ed.gui
@@ -313,30 +313,6 @@ function ObjectBuilderGui::createImageAssetType(%this, %index)
    else
       %name = %this.field[%index, text];
 
-   // 
-   /*%this.textControls[%this.numControls] = new GuiTextCtrl() {
-      profile = "ToolsGuiTextRightProfile";
-      internalName = "assetText";
-      text = %name;
-      extent = %this.fieldNameExtent;
-      position = %this.curXPos @ " " @ %this.curYPos;
-      modal = "1";
-   };
-
-   // 
-   %this.controls[%this.numControls] = new GuiButtonCtrl() {
-      HorizSizing = "width";
-      profile = "ToolsGuiButtonProfile";
-      internalName = "assetButton";
-      extent = %this.fileButtonExtent;
-      position = %this.curXPos + %this.columnOffset @ " " @ %this.curYPos;
-      modal = "1";
-      command = %this @ ".getImageAsset(" @ %index @ ");";
-   };
-
-   %val = %this.field[%index, value];
-   %this.controls[%this.numControls].setText(fileBase(%val) @ fileExt(%val));*/
-   
    %this.textControls[%this.numControls] = new GuiTextCtrl() {
       profile = "ToolsGuiTextRightProfile";
       text = %name;
@@ -375,7 +351,7 @@ function ObjectBuilderGui::createImageAssetType(%this, %index)
       modal = "1";
       command = %this @ ".getImageAsset(" @ %index @ ");";
    };
-   %button.setBitmap("ToolsModule:change_material_btn_n_image");
+   %button.setBitmap("ToolsModule:GameTSCtrl_image");
    %this.controls[%this.numControls].addGuiControl(%button);
 
    %this.numControls++;
@@ -412,6 +388,279 @@ function ObjectBuilderGui::gotImageAsset(%this, %name)
    // This doesn't work for button controls as getValue returns their state!
    //%this.controls[%this.currentControl].setValue(%name);
 }
+
+//------------------------------------------------------------------------------
+function ObjectBuilderGui::createMaterialAssetType(%this, %index)
+{
+   if(%index >= %this.numFields || %this.field[%index, name] $= "")
+   {
+      error("ObjectBuilderGui::createMaterialAssetType: invalid field");
+      return;
+   }
+
+   //
+   if(%this.field[%index, text] $= "")
+      %name = %this.field[%index, name];
+   else
+      %name = %this.field[%index, text];
+   
+   %this.textControls[%this.numControls] = new GuiTextCtrl() {
+      profile = "ToolsGuiTextRightProfile";
+      text = %name;
+      extent = %this.fieldNameExtent;
+      position = %this.curXPos @ " " @ %this.curYPos;
+      modal = "1";
+   };
+
+   // 
+   %this.controls[%this.numControls] = new GuiControl() {
+      HorizSizing = "width";
+      profile = "ToolsGuiDefaultProfile";
+      extent = %this.textEditExtent;
+      position = %this.curXPos + %this.columnOffset @ " " @ %this.curYPos;
+      modal = "1";
+   };
+   
+   %text = new GuiTextEditCtrl() {
+      class = ObjectBuilderGuiTextEditCtrl;
+      internalName = "assetText";
+      HorizSizing = "width";
+      profile = "ToolsGuiTextEditProfile";
+      extent = getWord(%this.textEditExtent,0) - getWord(%this.matButtonExtent,0) - 2 @ " " @ getWord(%this.textEditExtent,1);
+      text = %this.field[%index, value];
+      position = "0 0";
+      modal = "1";
+   };
+   %this.controls[%this.numControls].addGuiControl(%text);
+   
+   %button = new GuiBitmapButtonCtrl() {
+      internalName = "assetButton";
+      HorizSizing = "left";
+      profile = "ToolsGuiButtonProfile";
+      extent = %this.matButtonExtent;
+      position = getWord(%this.textEditExtent,0) - getWord(%this.matButtonExtent,0) @ " 0";
+      modal = "1";
+      command = %this @ ".getMaterialAsset(" @ %index @ ");";
+   };
+   %button.setBitmap("ToolsModule:change_material_btn_n_image");
+   %this.controls[%this.numControls].addGuiControl(%button);
+
+   %this.numControls++;
+   %this.curYPos += %this.defaultFieldStep;
+}
+
+function ObjectBuilderGui::getMaterialAsset(%this, %index)
+{
+   if(%index >= %this.numFields || %this.field[%index, name] $= "")
+   {
+      error("ObjectBuilderGui::getMaterialAsset: invalid field");
+      return;
+   }
+   
+   %val = %this.field[%index, ext];
+
+   //%path = filePath(%val);
+   //%ext = fileExt(%val);
+
+   %this.currentControl = %index;
+   AssetBrowser.showDialog("MaterialAsset", %this @ ".gotMaterialAsset", "", "", "");
+   //getLoadFilename( %val @ "|" @ %val, %this @ ".gotFileName", %this.lastPath );
+}
+
+function ObjectBuilderGui::gotMaterialAsset(%this, %name)
+{
+   %index = %this.currentControl;
+   
+   %this.field[%index, value] = %name;
+   %this.controls[%this.currentControl]-->assetText.setText(%name);
+   
+   %this.lastPath = %name;
+   
+   // This doesn't work for button controls as getValue returns their state!
+   //%this.controls[%this.currentControl].setValue(%name);
+}
+
+//------------------------------------------------------------------------------
+function ObjectBuilderGui::createShapeAssetType(%this, %index)
+{
+   if(%index >= %this.numFields || %this.field[%index, name] $= "")
+   {
+      error("ObjectBuilderGui::createShapeAssetType: invalid field");
+      return;
+   }
+
+   //
+   if(%this.field[%index, text] $= "")
+      %name = %this.field[%index, name];
+   else
+      %name = %this.field[%index, text];
+   
+   %this.textControls[%this.numControls] = new GuiTextCtrl() {
+      profile = "ToolsGuiTextRightProfile";
+      text = %name;
+      extent = %this.fieldNameExtent;
+      position = %this.curXPos @ " " @ %this.curYPos;
+      modal = "1";
+   };
+
+   // 
+   %this.controls[%this.numControls] = new GuiControl() {
+      HorizSizing = "width";
+      profile = "ToolsGuiDefaultProfile";
+      extent = %this.textEditExtent;
+      position = %this.curXPos + %this.columnOffset @ " " @ %this.curYPos;
+      modal = "1";
+   };
+   
+   %text = new GuiTextEditCtrl() {
+      class = ObjectBuilderGuiTextEditCtrl;
+      internalName = "assetText";
+      HorizSizing = "width";
+      profile = "ToolsGuiTextEditProfile";
+      extent = getWord(%this.textEditExtent,0) - getWord(%this.matButtonExtent,0) - 2 @ " " @ getWord(%this.textEditExtent,1);
+      text = %this.field[%index, value];
+      position = "0 0";
+      modal = "1";
+   };
+   %this.controls[%this.numControls].addGuiControl(%text);
+   
+   %button = new GuiBitmapButtonCtrl() {
+      internalName = "assetButton";
+      HorizSizing = "left";
+      profile = "ToolsGuiButtonProfile";
+      extent = %this.matButtonExtent;
+      position = getWord(%this.textEditExtent,0) - getWord(%this.matButtonExtent,0) @ " 0";
+      modal = "1";
+      command = %this @ ".getShapeAsset(" @ %index @ ");";
+   };
+   %button.setBitmap("ToolsModule:shape_editor_n_image");
+   %this.controls[%this.numControls].addGuiControl(%button);
+
+   %this.numControls++;
+   %this.curYPos += %this.defaultFieldStep;
+}
+
+function ObjectBuilderGui::getShapeAsset(%this, %index)
+{
+   if(%index >= %this.numFields || %this.field[%index, name] $= "")
+   {
+      error("ObjectBuilderGui::getShapeAsset: invalid field");
+      return;
+   }
+   
+   %val = %this.field[%index, ext];
+
+   //%path = filePath(%val);
+   //%ext = fileExt(%val);
+
+   %this.currentControl = %index;
+   AssetBrowser.showDialog("ShapeAsset", %this @ ".gotShapeAsset", "", "", "");
+   //getLoadFilename( %val @ "|" @ %val, %this @ ".gotFileName", %this.lastPath );
+}
+
+function ObjectBuilderGui::gotShapeAsset(%this, %name)
+{
+   %index = %this.currentControl;
+   
+   %this.field[%index, value] = %name;
+   %this.controls[%this.currentControl]-->assetText.setText(%name);
+   
+   %this.lastPath = %name;
+   
+   // This doesn't work for button controls as getValue returns their state!
+   //%this.controls[%this.currentControl].setValue(%name);
+}
+
+//------------------------------------------------------------------------------
+function ObjectBuilderGui::createSoundAssetType(%this, %index)
+{
+   if(%index >= %this.numFields || %this.field[%index, name] $= "")
+   {
+      error("ObjectBuilderGui::createSoundAssetType: invalid field");
+      return;
+   }
+
+   //
+   if(%this.field[%index, text] $= "")
+      %name = %this.field[%index, name];
+   else
+      %name = %this.field[%index, text];
+   
+   %this.textControls[%this.numControls] = new GuiTextCtrl() {
+      profile = "ToolsGuiTextRightProfile";
+      text = %name;
+      extent = %this.fieldNameExtent;
+      position = %this.curXPos @ " " @ %this.curYPos;
+      modal = "1";
+   };
+
+   // 
+   %this.controls[%this.numControls] = new GuiControl() {
+      HorizSizing = "width";
+      profile = "ToolsGuiDefaultProfile";
+      extent = %this.textEditExtent;
+      position = %this.curXPos + %this.columnOffset @ " " @ %this.curYPos;
+      modal = "1";
+   };
+   
+   %text = new GuiTextEditCtrl() {
+      class = ObjectBuilderGuiTextEditCtrl;
+      internalName = "assetText";
+      HorizSizing = "width";
+      profile = "ToolsGuiTextEditProfile";
+      extent = getWord(%this.textEditExtent,0) - getWord(%this.matButtonExtent,0) - 2 @ " " @ getWord(%this.textEditExtent,1);
+      text = %this.field[%index, value];
+      position = "0 0";
+      modal = "1";
+   };
+   %this.controls[%this.numControls].addGuiControl(%text);
+   
+   %button = new GuiBitmapButtonCtrl() {
+      internalName = "assetButton";
+      HorizSizing = "left";
+      profile = "ToolsGuiButtonProfile";
+      extent = %this.matButtonExtent;
+      position = getWord(%this.textEditExtent,0) - getWord(%this.matButtonExtent,0) @ " 0";
+      modal = "1";
+      command = %this @ ".getSoundAsset(" @ %index @ ");";
+   };
+   %button.setBitmap("ToolsModule:SFXEmitter_image");
+   %this.controls[%this.numControls].addGuiControl(%button);
+
+   %this.numControls++;
+   %this.curYPos += %this.defaultFieldStep;
+}
+
+function ObjectBuilderGui::getSoundAsset(%this, %index)
+{
+   if(%index >= %this.numFields || %this.field[%index, name] $= "")
+   {
+      error("ObjectBuilderGui::getSoundAsset: invalid field");
+      return;
+   }
+   
+   %val = %this.field[%index, ext];
+
+   //%path = filePath(%val);
+   //%ext = fileExt(%val);
+
+   %this.currentControl = %index;
+   AssetBrowser.showDialog("SoundAsset", %this @ ".gotSoundAsset", "", "", "");
+   //getLoadFilename( %val @ "|" @ %val, %this @ ".gotFileName", %this.lastPath );
+}
+
+function ObjectBuilderGui::gotSoundAsset(%this, %name)
+{
+   %index = %this.currentControl;
+   
+   %this.field[%index, value] = %name;
+   %this.controls[%this.currentControl]-->assetText.setText(%name);
+   
+   %this.lastPath = %name;
+   
+   // This doesn't work for button controls as getValue returns their state!
+   //%this.controls[%this.currentControl].setValue(%name);
+}
 //------------------------------------------------------------------------------
 function ObjectBuilderGui::createMaterialNameType(%this, %index)
 {
@@ -680,6 +929,15 @@ function ObjectBuilderGui::process(%this)
          case "TypeImageAsset":
             %this.createImageAssetType(%i);
 
+         case "TypeMaterialAsset":
+            %this.createMaterialAssetType(%i);
+            
+         case "TypeShapeAsset":
+            %this.createShapeAssetType(%i);
+            
+         case "TypeSoundAsset":
+            %this.createSoundAssetType(%i);
+
          case "TypeMaterialName":
             %this.createMaterialNameType(%i);
 
@@ -753,7 +1011,10 @@ function ObjectBuilderGui::onOK(%this)
          continue;
       }
       if (%this.field[%i, type] $= "TypeImageAsset" || 
-      %this.field[%i, type] $= "TypeTerrainAsset")
+      %this.field[%i, type] $= "TypeTerrainAsset" || 
+      %this.field[%i, type] $= "TypeMaterialAsset" ||
+      %this.field[%i, type] $= "TypeShapeAsset"
+      )
       {
          %this.field[%i, value] = %this.controls[%i]-->assetText.getText();
          continue;
@@ -861,7 +1122,6 @@ function ObjectBuilderGui::buildScatterSky( %this, %dontWarnAboutSun )
    %this.addField( "moonMatAsset", "TypeMaterialAsset", "Moon Material", "Core_Rendering:moon_wglow" );
    %this.addField( "nightCubemap", "TypeCubemapName", "Night Cubemap", "NightCubemap" );
    %this.addField( "useNightCubemap", "TypeBool", "Use Night Cubemap", "true" );
-   
 }
 
 function ObjectBuilderGui::buildCloudLayer(%this)
@@ -954,7 +1214,7 @@ function ObjectBuilderGui::buildSun( %this, %dontWarnAboutScatterSky )
    
    // This is a trick... any fields added after process won't show
    // up as controls, but will be applied to the created object.
-   %this.addField( "coronaMaterial", "TypeMaterialName", "Corona Material", "Corona_Mat" );
+   %this.addField( "coronaMaterial", "TypeMaterialAsset", "Corona Material", "Core_Rendering:Corona_Mat" );
    %this.addField( "flareType", "TypeLightFlareDataPtr", "Flare", "SunFlareExample" );
 }
 
@@ -994,9 +1254,9 @@ function ObjectBuilderGui::addWaterObjectFields(%this)
    %this.addField("waveSpeed[2]", "TypeFloat", "Wave Speed", "1");
    %this.addField("overallWaveMagnitude", "TypeFloat", "Overall Wave Magnitude", "1.0");
    
-   %this.addField("rippleTexAsset", "TypeImageAssetId", "Ripple Texture", "Core_Rendering:ripple_image" );
-   %this.addField("depthGradientTexAsset", "TypeImageAssetId", "Depth Gradient Texture", "Core_Rendering:depthcolor_ramp_imag" );
-   %this.addField("foamTexAsset", "TypeImageAssetId", "Foam Texture", "Core_Rendering:foam_image" );
+   %this.addField("rippleTex", "TypeImageAsset", "Ripple Texture", "Core_Rendering:ripple_image" );
+   %this.addField("depthGradientTex", "TypeImageAsset", "Depth Gradient Texture", "Core_Rendering:depthcolor_ramp_image" );
+   %this.addField("foamTex", "TypeImageAsset", "Foam Texture", "Core_Rendering:foam_image" );
 }
 
 function ObjectBuilderGui::buildWaterBlock(%this)
@@ -1038,8 +1298,8 @@ function ObjectBuilderGui::buildTerrainBlock(%this)
 function ObjectBuilderGui::buildGroundCover( %this )
 {
    %this.objectClassName = "GroundCover";
-   %this.addField( "material", "TypeMaterialName", "Material Name", "" );
-   %this.addField( "shapeFilename[0]", "TypeFile", "Shape File [Optional]", "", "*.*");
+   %this.addField( "materialAsset", "TypeMaterialAsset", "Material Asset", "" );
+   %this.addField( "shapeAsset[0]", "TypeShapeAsset", "Shape Asset [Optional]", "", "");
    %this.process();
    
    // This is a trick... any fields added after process won't show
@@ -1212,6 +1472,9 @@ function ObjectBuilderGui::buildGeneralDropPoint(%this)
 function ObjectBuilderGui::buildNotesObject(%this)
 {
    %this.objectClassName = "NotesObject";
+   %this.addField("note",           "TypeString",     "Note Text", "");
+   %this.addField("showArrow",      "TypeBool",       "Show Arrow", "");
+   %this.addField("arrowColor",     "TypeColorI",     "Arrow Color", "255 0 0 255");
    %this.process();
 }
 //------------------------------------------------------------------------------
@@ -1221,11 +1484,11 @@ function ObjectBuilderGui::buildVolumetricFog(%this)
 {
 	// Change this if you want to default to another Folder
 	// Otherwise every time you want to add a Fog you will go this.
-	%defShape = "core/rendering/shapes/Fog_Cube.DAE";
+	%defShape = "Core_Rendering:Fog_Cube";
 	%this.lastPath=getMainDotCsDir() @ %defShape;
 	OBObjectName.setValue( "" );
 	%this.objectClassName = "VolumetricFog";
-	%this.addField( "shapeName", "TypeFile", "Shape (Fog volume)", "", "*.dts;*.dae");
+	%this.addField( "shapeAsset", "TypeShapeAsset", "Shape (Fog volume)", "", "");
 	%this.addField("Scale", "TypePoint3", "Scale", "1 1 1");
 	%this.addField("FogColor", "TypeColorI", "FogColor", "200 200 200 255");
 	%this.process();
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
index e7972a4c8..dca4d1f30 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
@@ -1826,7 +1826,10 @@ function EditorTree::update( %this )
 // Tooltip for TSStatic
 function EditorTree::GetTooltipTSStatic( %this, %obj )
 {
-   return "Shape: " @ %obj.shapeName;
+   %shapeName = %obj.shapeAsset;
+   if(%shapeName $= "")
+      %shapeName = %obj.getShape();
+   return "Shape: " @ %shapeName;
 }
 
 // Tooltip for ShapeBase
@@ -1862,7 +1865,10 @@ function EditorTree::GetTooltipPrefab( %this, %obj )
 // Tooltip for GroundCover
 function EditorTree::GetTooltipGroundCover( %this, %obj )
 {
-   %text = "Material: " @ %obj.material;
+   %matName = %obj.materialAsset;
+   if(%matName $= "")
+      %matName = %obj.getMaterial();
+   %text = "Material: " @ %matName;
    for(%i=0; %i<8; %i++)
    {
       if(%obj.probability[%i] > 0 && %obj.shapeFilename[%i] !$= "")
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/editor.keybinds.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/editor.keybinds.tscript
index a077b8611..74c681bd5 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/editor.keybinds.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/editor.keybinds.tscript
@@ -79,4 +79,4 @@ GlobalActionMap.bind(keyboard, "tilde", toggleConsole);
 
 EditorMap.bind( mouse, "alt zaxis", editorWheelFadeScroll );
 
-EditorMap.bindCmd( keyboard, space, "", "AssetBrowser.toggleDialog();" );
+EditorMap.bindCmd( keyboard, "shift space", "", "AssetBrowser.toggleDialog();" );
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/menuHandlers.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/menuHandlers.ed.tscript
index a1771cdcf..4679dba92 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/menuHandlers.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/menuHandlers.ed.tscript
@@ -204,8 +204,7 @@ function EditorNewLevel( %level )
    %saveFirst = false;
    if ( EditorIsDirty() )
    {
-      error(knob);
-      %saveFirst = toolsMessageBox("Mission Modified", "Would you like to save changes to the current mission \"" @
+      %saveFirst = MessageBox("Mission Modified", "Would you like to save changes to the current mission \"" @
          $Server::MissionFile @ "\" before creating a new mission?", "SaveDontSave", "Question") == $MROk;
    }
       
@@ -300,7 +299,7 @@ function EditorSaveMission()
    // first check for dirty and read-only files:
    if((EWorldEditor.isDirty || ETerrainEditor.isMissionDirty) && !isWriteableFileName($Server::MissionFile))
    {
-      toolsMessageBox("Error", "Mission file \""@ $Server::MissionFile @ "\" is read-only.  Continue?", "Ok", "Stop");
+      MessageBox("Error", "Mission file \""@ $Server::MissionFile @ "\" is read-only.  Continue?", "Ok", "Stop");
       return false;
    }
    if(ETerrainEditor.isDirty)
@@ -310,9 +309,18 @@ function EditorSaveMission()
 
       while ((%terrainObject = containerSearchNext()) != 0)
       {
-         if (!isWriteableFileName(%terrainObject.terrainFile))
+         %terrFile = %terrainObject.getTerrain();
+         if(AssetDatabase.isDeclaredAsset(%terrFile))
          {
-            if (toolsMessageBox("Error", "Terrain file \""@ %terrainObject.terrainFile @ "\" is read-only.  Continue?", "Ok", "Stop") == $MROk)
+            %assetDef = AssetDatabase.acquireAsset(%terrFile);  
+            %file = %assetDef.getTerrainFilePath();
+            AssetDatabase.releaseAsset(%terrFile);
+            %terrFile = %file;
+         }
+         
+         if (!isWriteableFileName(%terrFile) && %bypass $= "")
+         {
+            if (MessageBox("Error", "Terrain file \""@ %terrainObject.terrainFile @ "\" is read-only.  Continue?", "Ok", "Stop") == $MROk)
                continue;
             else
                return false;
@@ -497,12 +505,12 @@ function EditorOpenMission(%levelAsset)
    if( EditorIsDirty())
    {
       // "EditorSaveBeforeLoad();", "getLoadFilename(\"*.mis\", \"EditorDoLoadMission\");"
-      if(toolsMessageBox("Mission Modified", "Would you like to save changes to the current mission \"" @
+      if(MessageBox("Mission Modified", "Would you like to save changes to the current mission \"" @
          $Server::MissionFile @ "\" before opening a new mission?", SaveDontSave, Question) == $MROk)
       {
-         if(! EditorSaveMission())
-            return;
-      }
+      if(!EditorSaveMission())
+        return;
+   }
    }
 
    if(%levelAsset $= "")
@@ -779,8 +787,20 @@ function makeSelectedAMesh(%assetId)
 function EditorTakeControlOfEntity()
 {
    %object = EWorldEditor.getSelectedObject(0);
-   switchCamera(localClientConnection, %object);
-   switchControlObject(localClientConnection, %object);  
+   if(isObject(%object) && %object.getClassName() !$= "Camera")
+   {
+      $Editor::previousControlObject = localClientConnection.getControlObject(); 
+      localClientConnection.setControlObject(%object);
+
+   }
+}
+
+function EditorReleaseControlOfEntity()
+{
+   if(isObject($Editor::previousControlObject))
+   {
+      localClientConnection.setControlObject($Editor::previousControlObject);
+   }
 }
 
 function EditorMount()
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/menus.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/menus.ed.tscript
index 21eaea05a..bf69e6bdb 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/menus.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/menus.ed.tscript
@@ -459,9 +459,11 @@ function EditorGui::buildMenus(%this)
          Item[18] = "Explode Selected Prefab" TAB "" TAB "EditorExplodePrefab();";
          Item[19] = "-";
          Item[20] = "Take control of entity" TAB "" TAB "EditorTakeControlOfEntity();";
-         Item[21] = "-";
-         Item[22] = "Mount Selection A to B" TAB "" TAB "EditorMount();";
-         Item[23] = "Unmount Selected Object" TAB "" TAB "EditorUnmount();";
+         Item[21] = "Release control of entity" TAB "" TAB "EditorReleaseControlOfEntity();";
+
+         Item[22] = "-";
+         Item[23] = "Mount Selection A to B" TAB "" TAB "EditorMount();";
+         Item[24] = "Unmount Selected Object" TAB "" TAB "EditorUnmount();";
       };
    }
 }

From ef5daae77045588f054152bd325c9f2ee44e8af7 Mon Sep 17 00:00:00 2001
From: Areloch <Areloch@gmail.com>
Date: Sun, 19 Sep 2021 12:55:56 -0500
Subject: [PATCH 083/399] Removed unneeded var

---
 .../game/tools/worldEditor/scripts/menuHandlers.ed.tscript      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/menuHandlers.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/menuHandlers.ed.tscript
index 4679dba92..a2ea3b015 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/menuHandlers.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/menuHandlers.ed.tscript
@@ -318,7 +318,7 @@ function EditorSaveMission()
             %terrFile = %file;
          }
          
-         if (!isWriteableFileName(%terrFile) && %bypass $= "")
+         if (!isWriteableFileName(%terrFile))
          {
             if (MessageBox("Error", "Terrain file \""@ %terrainObject.terrainFile @ "\" is read-only.  Continue?", "Ok", "Stop") == $MROk)
                continue;

From c92cfe3e81898f66fe2dfb35118605e97b10a577 Mon Sep 17 00:00:00 2001
From: marauder2k7 <ctrl-intelligence@live.co.uk>
Date: Mon, 20 Sep 2021 09:37:31 +0100
Subject: [PATCH 084/399] SoundAssetImplements

-Explosion
-Lightning
-Splash

-Other sound asset implementations will require soundasset array if possible.
---
 Engine/source/T3D/fx/explosion.cpp | 32 ++++++++++++++----------------
 Engine/source/T3D/fx/explosion.h   | 13 +++++++++++-
 Engine/source/T3D/fx/lightning.cpp | 21 ++++++++++----------
 Engine/source/T3D/fx/lightning.h   | 16 +++++++++++++--
 Engine/source/T3D/fx/splash.cpp    | 24 +++++++++++++++++++---
 Engine/source/T3D/fx/splash.h      | 16 +++++++++++++--
 6 files changed, 87 insertions(+), 35 deletions(-)

diff --git a/Engine/source/T3D/fx/explosion.cpp b/Engine/source/T3D/fx/explosion.cpp
index aa86e27a9..e842f73e4 100644
--- a/Engine/source/T3D/fx/explosion.cpp
+++ b/Engine/source/T3D/fx/explosion.cpp
@@ -230,7 +230,9 @@ ExplosionData::ExplosionData()
 
    faceViewer   = false;
 
-   soundProfile      = NULL;
+   INIT_SOUNDASSET(Sound);
+
+   //soundProfile      = NULL;
    particleEmitter   = NULL;
    particleEmitterId = 0;
 
@@ -308,7 +310,7 @@ ExplosionData::ExplosionData(const ExplosionData& other, bool temp_clone) : Game
    faceViewer = other.faceViewer;
    particleDensity = other.particleDensity;
    particleRadius = other.particleRadius;
-   soundProfile = other.soundProfile;
+   CLONE_SOUNDASSET(Sound);
    particleEmitter = other.particleEmitter;
    particleEmitterId = other.particleEmitterId; // -- for pack/unpack of particleEmitter ptr 
    explosionScale = other.explosionScale;
@@ -358,12 +360,6 @@ ExplosionData::~ExplosionData()
    if (!isTempClone())
       return;
 
-   if (soundProfile && soundProfile->isTempClone())
-   {
-      delete soundProfile;
-      soundProfile = 0;
-   }
-
    // particleEmitter, emitterList[*], debrisList[*], explosionList[*] will delete themselves
 
 #ifdef TRACK_EXPLOSION_DATA_CLONES
@@ -399,8 +395,9 @@ void ExplosionData::initPersistFields()
       "of the explosion." );
    addField( "playSpeed", TypeF32, Offset(playSpeed, ExplosionData),
       "Time scale at which to play the explosionShape <i>ambient</i> sequence." );
-   addField( "soundProfile", TYPEID< SFXTrack >(), Offset(soundProfile, ExplosionData),
-      "Non-looping sound effect that will be played at the start of the explosion." );
+
+   INITPERSISTFIELD_SOUNDASSET(Sound, ExplosionData, "Sound to play when this explosion explodes.");
+
    addField( "faceViewer", TypeBool, Offset(faceViewer, ExplosionData),
       "Controls whether the visual effects of the explosion always face the camera." );
 
@@ -523,7 +520,6 @@ void ExplosionData::initPersistFields()
    onlyKeepClearSubstitutions("debris"); // subs resolving to "~~", or "~0" are OK
    onlyKeepClearSubstitutions("emitter");
    onlyKeepClearSubstitutions("particleEmitter");
-   onlyKeepClearSubstitutions("soundProfile");
    onlyKeepClearSubstitutions("subExplosion");
    Parent::initPersistFields();
 }
@@ -656,7 +652,8 @@ void ExplosionData::packData(BitStream* stream)
 
    PACKDATA_SHAPEASSET(ExplosionShape);
 
-   sfxWrite( stream, soundProfile );
+   PACKDATA_SOUNDASSET(Sound);
+
    if (stream->writeFlag(particleEmitter))
       stream->writeRangedU32(particleEmitter->getId(),DataBlockObjectIdFirst,DataBlockObjectIdLast);
 
@@ -759,7 +756,7 @@ void ExplosionData::unpackData(BitStream* stream)
 
    UNPACKDATA_SHAPEASSET(ExplosionShape);
 
-   sfxRead( stream, &soundProfile );
+   UNPACKDATA_SOUNDASSET(Sound);
 
    if (stream->readFlag())
       particleEmitterId = stream->readRangedU32(DataBlockObjectIdFirst, DataBlockObjectIdLast);
@@ -861,12 +858,13 @@ bool ExplosionData::preload(bool server, String &errorStr)
 {
    if (Parent::preload(server, errorStr) == false)
       return false;
-      
+
+   if (!server && !getSFXProfile())
+      return false;
+
    if( !server )
    {
       String sfxErrorStr;
-      if( !sfxResolve( &soundProfile, sfxErrorStr ) )
-         Con::errorf(ConsoleLogEntry::General, "Error, unable to load sound profile for explosion datablock: %s", sfxErrorStr.c_str());
       if (!particleEmitter && particleEmitterId != 0)
          if (Sim::findObject(particleEmitterId, particleEmitter) == false)
             Con::errorf(ConsoleLogEntry::General, "Error, unable to load particle emitter for explosion datablock");
@@ -1384,7 +1382,7 @@ bool Explosion::explode()
       resetWorldBox();
    }
 
-   SFXProfile* sound_prof = dynamic_cast<SFXProfile*>(mDataBlock->soundProfile);
+   SFXProfile* sound_prof = dynamic_cast<SFXProfile*>(mDataBlock->getSFXProfile());
    if (sound_prof)
    {
       soundProfile_clone = sound_prof->cloneAndPerformSubstitutions(ss_object, ss_index);
diff --git a/Engine/source/T3D/fx/explosion.h b/Engine/source/T3D/fx/explosion.h
index a82d28644..ae01c4bee 100644
--- a/Engine/source/T3D/fx/explosion.h
+++ b/Engine/source/T3D/fx/explosion.h
@@ -42,6 +42,7 @@
 #endif
 
 #include "T3D/assets/ShapeAsset.h"
+#include "T3D/assets/SoundAsset.h"
 
 class ParticleEmitter;
 class ParticleEmitterData;
@@ -69,7 +70,17 @@ class ExplosionData : public GameBaseData {
    S32 particleDensity;
    F32 particleRadius;
 
-   SFXTrack*        soundProfile;
+   //SFXTrack*        soundProfile;
+   DECLARE_SOUNDASSET(ExplosionData, Sound);
+   DECLARE_SOUNDASSET_SETGET(ExplosionData, Sound);
+
+   SFXProfile* getSFXProfile() {
+      if (mSoundAsset.notNull())
+         return mSoundAsset->getSfxProfile();
+      else
+         return NULL;
+   }
+
    ParticleEmitterData* particleEmitter;
    S32                  particleEmitterId;
 
diff --git a/Engine/source/T3D/fx/lightning.cpp b/Engine/source/T3D/fx/lightning.cpp
index e808fb406..20925ec58 100644
--- a/Engine/source/T3D/fx/lightning.cpp
+++ b/Engine/source/T3D/fx/lightning.cpp
@@ -238,7 +238,7 @@ void LightningStrikeEvent::process(NetConnection*)
 //
 LightningData::LightningData()
 {
-   strikeSound = NULL;
+   INIT_SOUNDASSET(StrikeSound);
 
    for (S32 i = 0; i < MaxThunders; i++)
       thunderSounds[i] = NULL;
@@ -260,8 +260,9 @@ LightningData::~LightningData()
 //--------------------------------------------------------------------------
 void LightningData::initPersistFields()
 {
-   addField( "strikeSound", TYPEID< SFXTrack >(), Offset(strikeSound, LightningData),
-      "Sound profile to play when a lightning strike occurs." );
+
+   INITPERSISTFIELD_SOUNDASSET(StrikeSound, LightningData, "Sound to play when lightning STRIKES!");
+
    addField( "thunderSounds", TYPEID< SFXTrack >(), Offset(thunderSounds, LightningData), MaxThunders,
       "@brief List of thunder sound effects to play.\n\n"
       "A random one of these sounds will be played shortly after each strike "
@@ -302,8 +303,8 @@ bool LightningData::preload(bool server, String &errorStr)
             Con::errorf(ConsoleLogEntry::General, "LightningData::preload: Invalid packet: %s", sfxErrorStr.c_str());
       }
 
-      if( !sfxResolve( &strikeSound, sfxErrorStr ) )
-         Con::errorf(ConsoleLogEntry::General, "LightningData::preload: Invalid packet: %s", sfxErrorStr.c_str());
+      if(!getSFXProfile())
+         Con::errorf(ConsoleLogEntry::General, "LightningData::preload: can't get sfxProfile from asset");
 
       mNumStrikeTextures = 0;
       for (U32 i = 0; i < MaxTextures; i++) 
@@ -338,7 +339,7 @@ void LightningData::packData(BitStream* stream)
    for (i = 0; i < MaxTextures; i++)
       stream->writeString(strikeTextureNames[i]);
 
-   sfxWrite( stream, strikeSound );
+   PACKDATA_SOUNDASSET(StrikeSound);
 }
 
 void LightningData::unpackData(BitStream* stream)
@@ -359,7 +360,7 @@ void LightningData::unpackData(BitStream* stream)
    for (i = 0; i < MaxTextures; i++)
       strikeTextureNames[i] = stream->readSTString();
 
-   sfxRead( stream, &strikeSound );
+   UNPACKDATA_SOUNDASSET(StrikeSound);
 }
 
 
@@ -735,9 +736,9 @@ void Lightning::processEvent(LightningStrikeEvent* pEvent)
       MatrixF trans(true);
       trans.setPosition( strikePoint );
 
-      if (mDataBlock->strikeSound)
+      if (mDataBlock->getSFXProfile())
       {
-         SFX->playOnce(mDataBlock->strikeSound, &trans );
+         SFX->playOnce(mDataBlock->getSFXProfile(), &trans );
       }
 
 }
@@ -1337,4 +1338,4 @@ void LightningBolt::update( F32 dt )
       isFading = false;
       elapsedTime = 0.0f;
    }
-}
\ No newline at end of file
+}
diff --git a/Engine/source/T3D/fx/lightning.h b/Engine/source/T3D/fx/lightning.h
index 93a54ffc7..78ef4a20b 100644
--- a/Engine/source/T3D/fx/lightning.h
+++ b/Engine/source/T3D/fx/lightning.h
@@ -41,7 +41,8 @@
 
 #include "gfx/gfxTextureHandle.h"
 
-
+#include "T3D/assets/ImageAsset.h"
+#include "T3D/assets/SoundAsset.h"
 
 class ShapeBase;
 class LightningStrikeEvent;
@@ -63,7 +64,10 @@ class LightningData : public GameBaseData
    //-------------------------------------- Console set variables
   public:
    SFXTrack*          thunderSounds[MaxThunders];
-   SFXTrack*         strikeSound;
+
+   DECLARE_SOUNDASSET(LightningData, StrikeSound);
+   DECLARE_SOUNDASSET_SETGET(LightningData, StrikeSound);
+
    StringTableEntry  strikeTextureNames[MaxTextures];
 
    //-------------------------------------- load set variables
@@ -86,6 +90,14 @@ class LightningData : public GameBaseData
 
    DECLARE_CONOBJECT(LightningData);
    static void initPersistFields();
+
+   SFXProfile* getSFXProfile() {
+      if (mStrikeSoundAsset.notNull())
+         return mStrikeSoundAsset->getSfxProfile();
+      else
+         return NULL;
+   }
+
 };
 
 
diff --git a/Engine/source/T3D/fx/splash.cpp b/Engine/source/T3D/fx/splash.cpp
index c6ac5582b..6af8a0c1a 100644
--- a/Engine/source/T3D/fx/splash.cpp
+++ b/Engine/source/T3D/fx/splash.cpp
@@ -67,8 +67,10 @@ ConsoleDocClass( Splash,
 //--------------------------------------------------------------------------
 SplashData::SplashData()
 {
-   soundProfile      = NULL;
-   soundProfileId    = 0;
+   //soundProfile      = NULL;
+   //soundProfileId    = 0;
+
+   INIT_SOUNDASSET(Sound);
 
    scale.set(1, 1, 1);
 
@@ -112,7 +114,8 @@ SplashData::SplashData()
 //--------------------------------------------------------------------------
    void SplashData::initPersistFields()
 {
-   addField("soundProfile",      TYPEID< SFXProfile >(),       Offset(soundProfile,       SplashData), "SFXProfile effect to play.\n");
+   INITPERSISTFIELD_SOUNDASSET(Sound, SplashData, "Sound to play when splash, splashes.");
+
    addField("scale",             TypePoint3F,                  Offset(scale,              SplashData), "The scale of this splashing effect, defined as the F32 points X, Y, Z.\n");
    addField("emitter",           TYPEID< ParticleEmitterData >(),   Offset(emitterList,        SplashData), NUM_EMITTERS, "List of particle emitters to create at the point of this Splash effect.\n");
    addField("delayMS",           TypeS32,                      Offset(delayMS,            SplashData), "Time to delay, in milliseconds, before actually starting this effect.\n");
@@ -158,6 +161,8 @@ void SplashData::packData(BitStream* stream)
 {
    Parent::packData(stream);
 
+   PACKDATA_SOUNDASSET(Sound);
+
    mathWrite(*stream, scale);
    stream->write(delayMS);
    stream->write(delayVariance);
@@ -212,6 +217,8 @@ void SplashData::unpackData(BitStream* stream)
 {
    Parent::unpackData(stream);
 
+   UNPACKDATA_SOUNDASSET(Sound);
+
    mathRead(*stream, &scale);
    stream->read(&delayMS);
    stream->read(&delayVariance);
@@ -267,6 +274,9 @@ bool SplashData::preload(bool server, String &errorStr)
    if (Parent::preload(server, errorStr) == false)
       return false;
 
+   if (!server && !getSFXProfile())
+      return false;
+
    if (!server)
    {
       S32 i;
@@ -667,6 +677,14 @@ void Splash::spawnExplosion()
 {
    if( !mDataBlock->explosion ) return;
 
+   /// could just play the explosion one, but explosion could be weapon specific,
+   /// splash sound could be liquid specific. food for thought.
+   SFXProfile* sound_prof = dynamic_cast<SFXProfile*>(mDataBlock->getSFXProfile());
+   if (sound_prof)
+   {
+      SFX->playOnce(sound_prof, &getTransform());
+   }
+
    Explosion* pExplosion = new Explosion;
    pExplosion->onNewDataBlock(mDataBlock->explosion, false);
 
diff --git a/Engine/source/T3D/fx/splash.h b/Engine/source/T3D/fx/splash.h
index f90a72d3c..40c6838fc 100644
--- a/Engine/source/T3D/fx/splash.h
+++ b/Engine/source/T3D/fx/splash.h
@@ -34,6 +34,7 @@
 #include "gfx/gfxTextureHandle.h"
 
 #include "T3D/assets/ImageAsset.h"
+#include "T3D/assets/SoundAsset.h"
 
 class ParticleEmitter;
 class ParticleEmitterData;
@@ -91,8 +92,19 @@ class SplashData : public GameBaseData
    };
 
 public:
-   AudioProfile*           soundProfile;
-   S32                     soundProfileId;
+   //AudioProfile*           soundProfile;
+   //S32                     soundProfileId;
+
+   DECLARE_SOUNDASSET(SplashData, Sound);
+   DECLARE_SOUNDASSET_SETGET(SplashData, Sound);
+
+   /// this should probably be added as a function higher up to stop repeats.
+   SFXProfile* getSFXProfile() {
+      if (mSoundAsset.notNull())
+         return mSoundAsset->getSfxProfile();
+      else
+         return NULL;
+   }
 
    ParticleEmitterData*    emitterList[NUM_EMITTERS];
    S32                     emitterIDList[NUM_EMITTERS];

From 3ad6d47ca9eaf57e64afc872cbde5c76cf47557d Mon Sep 17 00:00:00 2001
From: marauder2k7 <ctrl-intelligence@live.co.uk>
Date: Mon, 20 Sep 2021 09:55:36 +0100
Subject: [PATCH 085/399] Update SoundAsset.h

-SoundAsset array setters getters and binds in place
---
 Engine/source/T3D/assets/SoundAsset.h | 218 ++++++++++++++++++++++++++
 1 file changed, 218 insertions(+)

diff --git a/Engine/source/T3D/assets/SoundAsset.h b/Engine/source/T3D/assets/SoundAsset.h
index 710652830..757d85ab6 100644
--- a/Engine/source/T3D/assets/SoundAsset.h
+++ b/Engine/source/T3D/assets/SoundAsset.h
@@ -360,5 +360,223 @@ DefineEngineMethod(className, set##name, bool, (const char*  shape), , assetText
 
 #pragma endregion
 
+#pragma region Arrayed Asset Macros
+
+#define DECLARE_SOUNDASSET_ARRAY(className, name, max) public: \
+   static const U32 sm##name##count = max;\
+   Resource<SFXResource> m##name[max];\
+   StringTableEntry m##name##Name[max]; \
+   StringTableEntry m##name##AssetId[max];\
+   AssetPtr<SoundAsset> m##name##Asset[max] = NULL;\
+   SFXProfile* m##name##Profile[max] = NULL;\
+public: \
+   const StringTableEntry get##name##File(const U32& id) const { return m##name##Name[id]; }\
+   void set##name##File(const FileName &_in, const U32& id) { m##name##Name[id] = StringTable->insert(_in.c_str());}\
+   const AssetPtr<SoundAsset> & get##name##Asset(const U32& id) const { return m##name##Asset[id]; }\
+   void set##name##Asset(const AssetPtr<SoundAsset> &_in, const U32& id) { m##name##Asset[id] = _in;}\
+   \
+   bool _set##name(StringTableEntry _in, const U32& id)\
+   {\
+      if(m##name##AssetId[id] != _in || m##name##Name[id] != _in)\
+      {\
+         if (_in == NULL || _in == StringTable->EmptyString())\
+         {\
+            if(id >= sm##name##Count || id < 0) \
+               return false;\
+            m##name##Name[id] = StringTable->EmptyString();\
+            m##name##AssetId[id] = StringTable->EmptyString();\
+            m##name##Asset[id] = NULL;\
+            m##name[id] = NULL;\
+            return true;\
+         }\
+         \
+         if (AssetDatabase.isDeclaredAsset(_in))\
+         {\
+            m##name##AssetId[id] = _in;\
+            \
+            U32 assetState = SoundAsset::getAssetById(m##name##AssetId[id], &m##name##Asset[id]);\
+            \
+            if (SoundAsset::Ok == assetState)\
+            {\
+               m##name##Name[id] = StringTable->EmptyString();\
+            }\
+         }\
+         else\
+         {\
+            StringTableEntry assetId = SoundAsset::getAssetIdByFileName(_in);\
+            if (assetId != StringTable->EmptyString())\
+            {\
+               m##name##AssetId[id] = assetId;\
+               if(SoundAsset::getAssetById(m##name##AssetId, &m##name##Asset) == SoundAsset::Ok)\
+               {\
+                  m##name##Name[id] = StringTable->EmptyString();\
+               }\
+            }\
+            else\
+            {\
+               m##name##Name[id] = _in;\
+               m##name##AssetId[id] = StringTable->EmptyString();\
+               m##name##Asset[id] = NULL;\
+            }\
+         }\
+      }\
+      if (get##name(id) != StringTable->EmptyString() && m##name##Asset[id].notNull())\
+      {\
+         m##name[id] = m##name##Asset[id]->getSoundResource();\
+      }\
+      else\
+      {\
+         m##name[id] = NULL;\
+      }\
+      \
+      if (m##name##Asset[id].notNull() && m##name##Asset[id]->getStatus() != SoundAsset::Ok)\
+      {\
+         Con::errorf("%s(%s)::_set%s(%i) - sound asset failure\"%s\" due to [%s]", macroText(className), getName(), macroText(name),id, _in, SoundAsset::getAssetErrstrn(m##name##Asset->getStatus()).c_str());\
+         return false; \
+      }\
+      else if (!m##name)\
+      {\
+         Con::errorf("%s(%s)::_set%s(%i) - Couldn't load sound \"%s\"", macroText(className), getName(), macroText(name),id, _in);\
+         return false;\
+      }\
+      return true;\
+   }\
+   \
+   const StringTableEntry get##name(const U32& id) const\
+   {\
+      if (m##name##Asset[id] && (m##name##Asset[id]->getSoundPath() != StringTable->EmptyString()))\
+         return m##name##Asset[id]->getSoundPath();\
+      else if (m##name##AssetId[id] != StringTable->EmptyString())\
+         return m##name##AssetId[id];\
+      else if (m##name##Name[id] != StringTable->EmptyString())\
+         return StringTable->insert(m##name##Name[id]);\
+      else\
+         return StringTable->EmptyString();\
+   }\
+   Resource<SFXResource> get##name##Resource() \
+   {\
+      return m##name;\
+   }
+
+#define DECLARE_SOUNDASSET_ARRAY_SETGET(className, name)\
+   static bool _set##name##Data(void* obj, const char* index, const char* data)\
+   {\
+      if(!index) return false;\
+      U32 idx = dAtoi(index);\
+      if (idx >= sm##name##Count)\
+         return false;\
+      bool ret = false;\
+      className* object = static_cast<className*>(obj);\
+      ret = object->_set##name(StringTable->insert(data), idx);\
+      return ret;\
+   }
+
+#define DECLARE_SOUNDASSET_ARRAY_NET_SETGET(className, name, bitmask)\
+   static bool _set##name##Data(void* obj, const char* index, const char* data)\
+   {\
+      if (!index) return false;\
+      U32 idx = dAtoi(index);\
+      if (idx >= sm##name##Count)\
+         return false;\
+      bool ret = false;\
+      className* object = static_cast<className*>(obj);\
+      ret = object->_set##name(StringTable->insert(data, idx));\
+      if(ret)\
+         object->setMaskBits(bitmask);\
+      return ret;\
+   }
+
+#define DEF_SOUNDASSET_ARRAY_BINDS(className,name)\
+DefineEngineMethod(className, get##name, const char*, (S32 index), , "get name")\
+{\
+   return object->get##name(index); \
+}\
+DefineEngineMethod(className, get##name##Asset, const char*, (S32 index), , assetText(name, asset reference))\
+{\
+   if(index >= className::sm##name##Count || index < 0)\
+      return "";\
+   return object->m##name##AssetId[index]; \
+}\
+DefineEngineMethod(className, set##name, bool, (const char* map, S32 index), , assetText(name,assignment. first tries asset then flat file.))\
+{\
+    return object->_set##name(StringTable->insert(map), index);\
+}
+
+#define INIT_SOUNDASSET_ARRAY(name, index) \
+{\
+   m##name##Name[index] = StringTable->EmptyString(); \
+   m##name##AssetId[index] = StringTable->EmptyString(); \
+   m##name##Asset[index] = NULL;\
+}
+
+#ifdef TORQUE_SHOW_LEGACY_FILE_FIELDS
+
+#define INITPERSISTFIELD_IMAGEASSET_ARRAY(name, arraySize, consoleClass, docs) \
+   addProtectedField(#name, TypeImageFilename, Offset(m##name##Name, consoleClass), _set##name##Data, &defaultProtectedGetFn, arraySize, assetDoc(name, docs)); \
+   addProtectedField(assetText(name, Asset), TypeImageAssetId, Offset(m##name##AssetId, consoleClass), _set##name##Data, &defaultProtectedGetFn, arraySize, assetDoc(name, asset docs.));
+
+#else
+
+#define INITPERSISTFIELD_SOUNDASSET_ARRAY(name, arraySize, consoleClass, docs) \
+   addProtectedField(#name, TypeImageFilename, Offset(m##name##Name, consoleClass), _set##name##Data, &defaultProtectedGetFn, arraySize, assetDoc(name, docs), AbstractClassRep::FIELD_HideInInspectors); \
+   addProtectedField(assetText(name, Asset), TypeImageAssetId, Offset(m##name##AssetId, consoleClass), _set##name##Data, &defaultProtectedGetFn, arraySize, assetDoc(name, asset docs.));
+
+#endif
+
+#define CLONE_SOUNDASSET_ARRAY(name, index) \
+{\
+   m##name##Name[index] = other.m##name##Name[index];\
+   m##name##AssetId[index] = other.m##name##AssetId[index];\
+   m##name##Asset[index] = other.m##name##Asset[index];\
+}
+
+#define LOAD_SOUNDASSET_ARRAY(name, index)\
+if (m##name##AssetId[index] != StringTable->EmptyString())\
+{\
+   S32 assetState = SoundAsset::getAssetById(m##name##AssetId[index], &m##name##Asset[index]);\
+   if (assetState == SoundAsset::Ok )\
+   {\
+      m##name##Name[index] = StringTable->EmptyString();\
+   }\
+   else Con::warnf("Warning: %s::LOAD_IMAGEASSET(%s)-%s", mClassName, m##name##AssetId[index], ImageAsset::getAssetErrstrn(assetState).c_str());\
+}
+
+#define PACKDATA_SOUNDASSET_ARRAY(name, index)\
+   if (stream->writeFlag(m##name##Asset[index].notNull()))\
+   {\
+      stream->writeString(m##name##Asset[index].getAssetId());\
+   }\
+   else\
+      stream->writeString(m##name##Name[index]);
+
+#define UNPACKDATA_SOUNDASSET_ARRAY(name, index)\
+   if (stream->readFlag())\
+   {\
+      m##name##AssetId[index] = stream->readSTString();\
+      _set##name(m##name##AssetId[index], index);\
+   }\
+   else\
+      m##name##Name[index] = stream->readSTString();
+
+#define PACK_SOUNDASSET_ARRAY(netconn, name, index)\
+   if (stream->writeFlag(m##name##Asset[index].notNull()))\
+   {\
+      NetStringHandle assetIdStr = m##name##Asset[index].getAssetId();\
+      netconn->packNetStringHandleU(stream, assetIdStr);\
+   }\
+   else\
+      stream->writeString(m##name##Name[index]);
+
+#define UNPACK_SOUNDASSET_ARRAY(netconn, name, index)\
+   if (stream->readFlag())\
+   {\
+      m##name##AssetId[index] = StringTable->insert(netconn->unpackNetStringHandleU(stream).getString());\
+      _set##name(m##name##AssetId[index], index);\
+   }\
+   else\
+      m##name##Name[index] = stream->readSTString();
+
+#pragma endregion
+
 #endif // _ASSET_BASE_H_
 

From 1ea693fea637a065f17446aefc8f3408b7f684d6 Mon Sep 17 00:00:00 2001
From: marauder2k7 <ctrl-intelligence@live.co.uk>
Date: Mon, 20 Sep 2021 10:49:34 +0100
Subject: [PATCH 086/399] SoundAsset Array

Few fixes to soundasset array to stop it complaining
---
 Engine/source/T3D/assets/SoundAsset.cpp |  1 +
 Engine/source/T3D/assets/SoundAsset.h   | 98 ++++++++++++++-----------
 Engine/source/T3D/fx/lightning.cpp      | 29 ++++----
 Engine/source/T3D/fx/lightning.h        | 13 +++-
 4 files changed, 80 insertions(+), 61 deletions(-)

diff --git a/Engine/source/T3D/assets/SoundAsset.cpp b/Engine/source/T3D/assets/SoundAsset.cpp
index d00c0dbe2..72a3a2526 100644
--- a/Engine/source/T3D/assets/SoundAsset.cpp
+++ b/Engine/source/T3D/assets/SoundAsset.cpp
@@ -107,6 +107,7 @@ ConsoleSetType(TypeSoundAssetId)
 //-----------------------------------------------------------------------------
 
 SoundAsset::SoundAsset()
+   : AssetBase()
 {
    mSoundFile = StringTable->EmptyString();
    mSoundPath = StringTable->EmptyString();
diff --git a/Engine/source/T3D/assets/SoundAsset.h b/Engine/source/T3D/assets/SoundAsset.h
index 757d85ab6..adacf2d9b 100644
--- a/Engine/source/T3D/assets/SoundAsset.h
+++ b/Engine/source/T3D/assets/SoundAsset.h
@@ -362,43 +362,51 @@ DefineEngineMethod(className, set##name, bool, (const char*  shape), , assetText
 
 #pragma region Arrayed Asset Macros
 
-#define DECLARE_SOUNDASSET_ARRAY(className, name, max) public: \
-   static const U32 sm##name##count = max;\
+#define DECLARE_SOUNDASSET_ARRAY(className,name,max) public: \
+   static const U32 sm##name##Count = max;\
    Resource<SFXResource> m##name[max];\
    StringTableEntry m##name##Name[max]; \
    StringTableEntry m##name##AssetId[max];\
-   AssetPtr<SoundAsset> m##name##Asset[max] = NULL;\
-   SFXProfile* m##name##Profile[max] = NULL;\
+   AssetPtr<SoundAsset> m##name##Asset[max];\
+   SFXProfile* m##name##Profile[max];\
 public: \
-   const StringTableEntry get##name##File(const U32& id) const { return m##name##Name[id]; }\
-   void set##name##File(const FileName &_in, const U32& id) { m##name##Name[id] = StringTable->insert(_in.c_str());}\
-   const AssetPtr<SoundAsset> & get##name##Asset(const U32& id) const { return m##name##Asset[id]; }\
-   void set##name##Asset(const AssetPtr<SoundAsset> &_in, const U32& id) { m##name##Asset[id] = _in;}\
+   const StringTableEntry get##name##File(const U32& index) const { return m##name##Name[index]; }\
+   void set##name##File(const FileName &_in, const U32& index) { m##name##Name[index] = StringTable->insert(_in.c_str());}\
+   const AssetPtr<SoundAsset> & get##name##Asset(const U32& index) const { return m##name##Asset[index]; }\
+   void set##name##Asset(const AssetPtr<SoundAsset> &_in, const U32& index) { m##name##Asset[index] = _in;}\
    \
-   bool _set##name(StringTableEntry _in, const U32& id)\
+   bool _set##name(StringTableEntry _in, const U32& index)\
    {\
-      if(m##name##AssetId[id] != _in || m##name##Name[id] != _in)\
+      if(m##name##AssetId[index] != _in || m##name##Name[index] != _in)\
       {\
+         if(index >= sm##name##Count || index < 0) \
+               return false;\
          if (_in == NULL || _in == StringTable->EmptyString())\
          {\
-            if(id >= sm##name##Count || id < 0) \
-               return false;\
-            m##name##Name[id] = StringTable->EmptyString();\
-            m##name##AssetId[id] = StringTable->EmptyString();\
-            m##name##Asset[id] = NULL;\
-            m##name[id] = NULL;\
+            m##name##Name[index] = StringTable->EmptyString();\
+            m##name##AssetId[index] = StringTable->EmptyString();\
+            m##name##Asset[index] = NULL;\
+            m##name[index] = NULL;\
+            return true;\
+         }\
+         else if(_in[0] == '$' || _in[0] == '#')\
+         {\
+            m##name##Name[index] = _in;\
+            m##name##AssetId[index] = StringTable->EmptyString();\
+            m##name##Asset[index] = NULL;\
+            m##name[index] = NULL;\
             return true;\
          }\
          \
          if (AssetDatabase.isDeclaredAsset(_in))\
          {\
-            m##name##AssetId[id] = _in;\
+            m##name##AssetId[index] = _in;\
             \
-            U32 assetState = SoundAsset::getAssetById(m##name##AssetId[id], &m##name##Asset[id]);\
+            U32 assetState = SoundAsset::getAssetById(m##name##AssetId[index], &m##name##Asset[index]);\
             \
             if (SoundAsset::Ok == assetState)\
             {\
-               m##name##Name[id] = StringTable->EmptyString();\
+               m##name##Name[index] = StringTable->EmptyString();\
             }\
          }\
          else\
@@ -406,56 +414,58 @@ public: \
             StringTableEntry assetId = SoundAsset::getAssetIdByFileName(_in);\
             if (assetId != StringTable->EmptyString())\
             {\
-               m##name##AssetId[id] = assetId;\
-               if(SoundAsset::getAssetById(m##name##AssetId, &m##name##Asset) == SoundAsset::Ok)\
+               m##name##AssetId[index] = assetId;\
+               if(SoundAsset::getAssetById(m##name##AssetId[index], &m##name##Asset[index]) == SoundAsset::Ok)\
                {\
-                  m##name##Name[id] = StringTable->EmptyString();\
+                  m##name##Name[index] = StringTable->EmptyString();\
                }\
             }\
             else\
             {\
-               m##name##Name[id] = _in;\
-               m##name##AssetId[id] = StringTable->EmptyString();\
-               m##name##Asset[id] = NULL;\
+               m##name##Name[index] = _in;\
+               m##name##AssetId[index] = StringTable->EmptyString();\
+               m##name##Asset[index] = NULL;\
             }\
          }\
       }\
-      if (get##name(id) != StringTable->EmptyString() && m##name##Asset[id].notNull())\
+      if (get##name(index) != StringTable->EmptyString() && m##name##Asset[index].notNull())\
       {\
-         m##name[id] = m##name##Asset[id]->getSoundResource();\
+         m##name[index] = m##name##Asset[index]->getSoundResource();\
       }\
       else\
       {\
-         m##name[id] = NULL;\
+         m##name[index] = NULL;\
       }\
       \
-      if (m##name##Asset[id].notNull() && m##name##Asset[id]->getStatus() != SoundAsset::Ok)\
+      if (m##name##Asset[index].notNull() && m##name##Asset[index]->getStatus() != SoundAsset::Ok)\
       {\
-         Con::errorf("%s(%s)::_set%s(%i) - sound asset failure\"%s\" due to [%s]", macroText(className), getName(), macroText(name),id, _in, SoundAsset::getAssetErrstrn(m##name##Asset->getStatus()).c_str());\
+         Con::errorf("%s(%s)::_set%s(%i) - sound asset failure\"%s\" due to [%s]", macroText(className), getName(), macroText(name),index, _in, SoundAsset::getAssetErrstrn(m##name##Asset[index]->getStatus()).c_str());\
          return false; \
       }\
-      else if (!m##name)\
+      else if (!m##name[index])\
       {\
-         Con::errorf("%s(%s)::_set%s(%i) - Couldn't load sound \"%s\"", macroText(className), getName(), macroText(name),id, _in);\
+         Con::errorf("%s(%s)::_set%s(%i) - Couldn't load sound \"%s\"", macroText(className), getName(), macroText(name),index, _in);\
          return false;\
       }\
       return true;\
    }\
    \
-   const StringTableEntry get##name(const U32& id) const\
+   const StringTableEntry get##name(const U32& index) const\
    {\
-      if (m##name##Asset[id] && (m##name##Asset[id]->getSoundPath() != StringTable->EmptyString()))\
-         return m##name##Asset[id]->getSoundPath();\
-      else if (m##name##AssetId[id] != StringTable->EmptyString())\
-         return m##name##AssetId[id];\
-      else if (m##name##Name[id] != StringTable->EmptyString())\
-         return StringTable->insert(m##name##Name[id]);\
+      if (m##name##Asset[index] && (m##name##Asset[index]->getSoundPath() != StringTable->EmptyString()))\
+         return m##name##Asset[index]->getSoundPath();\
+      else if (m##name##AssetId[index] != StringTable->EmptyString())\
+         return m##name##AssetId[index];\
+      else if (m##name##Name[index] != StringTable->EmptyString())\
+         return StringTable->insert(m##name##Name[index]);\
       else\
          return StringTable->EmptyString();\
    }\
-   Resource<SFXResource> get##name##Resource() \
+   Resource<SFXResource> get##name##Resource(const U32& id) \
    {\
-      return m##name;\
+      if(id >= sm##name##Count || id < 0)\
+         return ResourceManager::get().load( "" );\
+      return m##name[id];\
    }
 
 #define DECLARE_SOUNDASSET_ARRAY_SETGET(className, name)\
@@ -512,14 +522,14 @@ DefineEngineMethod(className, set##name, bool, (const char* map, S32 index), , a
 #ifdef TORQUE_SHOW_LEGACY_FILE_FIELDS
 
 #define INITPERSISTFIELD_IMAGEASSET_ARRAY(name, arraySize, consoleClass, docs) \
-   addProtectedField(#name, TypeImageFilename, Offset(m##name##Name, consoleClass), _set##name##Data, &defaultProtectedGetFn, arraySize, assetDoc(name, docs)); \
+   addProtectedField(#name, TypeSoundFilename, Offset(m##name##Name, consoleClass), _set##name##Data, &defaultProtectedGetFn, arraySize, assetDoc(name, docs)); \
    addProtectedField(assetText(name, Asset), TypeImageAssetId, Offset(m##name##AssetId, consoleClass), _set##name##Data, &defaultProtectedGetFn, arraySize, assetDoc(name, asset docs.));
 
 #else
 
 #define INITPERSISTFIELD_SOUNDASSET_ARRAY(name, arraySize, consoleClass, docs) \
-   addProtectedField(#name, TypeImageFilename, Offset(m##name##Name, consoleClass), _set##name##Data, &defaultProtectedGetFn, arraySize, assetDoc(name, docs), AbstractClassRep::FIELD_HideInInspectors); \
-   addProtectedField(assetText(name, Asset), TypeImageAssetId, Offset(m##name##AssetId, consoleClass), _set##name##Data, &defaultProtectedGetFn, arraySize, assetDoc(name, asset docs.));
+   addProtectedField(#name, TypeSoundFilename, Offset(m##name##Name, consoleClass), _set##name##Data, &defaultProtectedGetFn, arraySize, assetDoc(name, docs), AbstractClassRep::FIELD_HideInInspectors); \
+   addProtectedField(assetText(name, Asset), TypeSoundAssetId, Offset(m##name##AssetId, consoleClass), _set##name##Data, &defaultProtectedGetFn, arraySize, assetDoc(name, asset docs.));
 
 #endif
 
diff --git a/Engine/source/T3D/fx/lightning.cpp b/Engine/source/T3D/fx/lightning.cpp
index 20925ec58..efc521319 100644
--- a/Engine/source/T3D/fx/lightning.cpp
+++ b/Engine/source/T3D/fx/lightning.cpp
@@ -241,7 +241,7 @@ LightningData::LightningData()
    INIT_SOUNDASSET(StrikeSound);
 
    for (S32 i = 0; i < MaxThunders; i++)
-      thunderSounds[i] = NULL;
+      INIT_SOUNDASSET_ARRAY(ThunderSound, MaxThunders);
 
    for (S32 i = 0; i < MaxTextures; i++)
    {
@@ -263,10 +263,8 @@ void LightningData::initPersistFields()
 
    INITPERSISTFIELD_SOUNDASSET(StrikeSound, LightningData, "Sound to play when lightning STRIKES!");
 
-   addField( "thunderSounds", TYPEID< SFXTrack >(), Offset(thunderSounds, LightningData), MaxThunders,
-      "@brief List of thunder sound effects to play.\n\n"
-      "A random one of these sounds will be played shortly after each strike "
-      "occurs." );
+   INITPERSISTFIELD_SOUNDASSET_ARRAY(ThunderSound, MaxThunders, LightningData, "Sounds for thunder.");
+
    addField( "strikeTextures", TypeString, Offset(strikeTextureNames, LightningData), MaxTextures,
       "List of textures to use to render lightning strikes." );
 
@@ -292,15 +290,18 @@ bool LightningData::preload(bool server, String &errorStr)
    //dQsort(thunderSounds, MaxThunders, sizeof(SFXTrack*), cmpSounds);
 
    for (S32 i = 0; i < MaxThunders; i++) {
-	   if (thunderSounds[i]!= NULL) numThunders++;
+      if (mThunderSound[i] == NULL)
+      {
+         _setThunderSound(getThunderSound(i), i);
+      }
    }
 
    if (server == false) 
    {
       String sfxErrorStr;
       for (U32 i = 0; i < MaxThunders; i++) {
-         if( !sfxResolve( &thunderSounds[ i ], sfxErrorStr ) )
-            Con::errorf(ConsoleLogEntry::General, "LightningData::preload: Invalid packet: %s", sfxErrorStr.c_str());
+         if (!getThunderProfile(i))
+            Con::errorf(ConsoleLogEntry::General, "LightningData::preload: Cant get an sfxProfile for thunder.");
       }
 
       if(!getSFXProfile())
@@ -330,8 +331,7 @@ void LightningData::packData(BitStream* stream)
    U32 i;
    for (i = 0; i < MaxThunders; i++)
    {
-      if (stream->writeFlag(thunderSounds[i]))
-         sfxWrite(stream, thunderSounds[i]);
+      PACKDATA_SOUNDASSET_ARRAY(ThunderSound, i);
    }
 
    stream->writeInt(mNumStrikeTextures, 4);
@@ -349,10 +349,7 @@ void LightningData::unpackData(BitStream* stream)
    U32 i;
    for (i = 0; i < MaxThunders; i++)
    {
-      if (stream->readFlag())
-         sfxRead(stream, &thunderSounds[i]);
-      else
-         thunderSounds[i] = NULL;
+      UNPACKDATA_SOUNDASSET_ARRAY(ThunderSound, i);
    }
 
    mNumStrikeTextures = stream->readInt(4);
@@ -585,7 +582,7 @@ void Lightning::scheduleThunder(Strike* newStrike)
          if (t <= 0.03f) {
             // If it's really close, just play it...
             U32 thunder = sgLightningRand.randI(0, mDataBlock->numThunders - 1);
-            SFX->playOnce(mDataBlock->thunderSounds[thunder]);
+            SFX->playOnce(mDataBlock->getThunderProfile(thunder));
          } else {
             Thunder* pThunder = new Thunder;
             pThunder->tRemaining = t;
@@ -652,7 +649,7 @@ void Lightning::advanceTime(F32 dt)
 
          // Play the sound...
          U32 thunder = sgLightningRand.randI(0, mDataBlock->numThunders - 1);
-         SFX->playOnce(mDataBlock->thunderSounds[thunder]);
+         SFX->playOnce(mDataBlock->getThunderProfile(thunder));
       } else {
          pThunderWalker = &((*pThunderWalker)->next);
       }
diff --git a/Engine/source/T3D/fx/lightning.h b/Engine/source/T3D/fx/lightning.h
index 78ef4a20b..1e04bd61d 100644
--- a/Engine/source/T3D/fx/lightning.h
+++ b/Engine/source/T3D/fx/lightning.h
@@ -63,7 +63,10 @@ class LightningData : public GameBaseData
 
    //-------------------------------------- Console set variables
   public:
-   SFXTrack*          thunderSounds[MaxThunders];
+   //SFXTrack*          thunderSounds[MaxThunders];
+
+   DECLARE_SOUNDASSET_ARRAY(LightningData, ThunderSound, MaxThunders);
+   DECLARE_SOUNDASSET_ARRAY_SETGET(LightningData, ThunderSound);
 
    DECLARE_SOUNDASSET(LightningData, StrikeSound);
    DECLARE_SOUNDASSET_SETGET(LightningData, StrikeSound);
@@ -91,6 +94,14 @@ class LightningData : public GameBaseData
    DECLARE_CONOBJECT(LightningData);
    static void initPersistFields();
 
+   SFXProfile* getThunderProfile(U32 id)
+   {
+      if (mThunderSoundAsset[id] != NULL)
+         return mThunderSoundAsset[id]->getSfxProfile();
+      else
+         return NULL;
+   }
+
    SFXProfile* getSFXProfile() {
       if (mStrikeSoundAsset.notNull())
          return mStrikeSoundAsset->getSfxProfile();

From 704eb27600bccb34e4713b787c1470f4a093db08 Mon Sep 17 00:00:00 2001
From: marauder2k7 <ctrl-intelligence@live.co.uk>
Date: Mon, 20 Sep 2021 13:07:50 +0100
Subject: [PATCH 087/399] More Implements

-Most Vehicles and FX classes
-Vehicle classes may need more preloads for assets.
---
 Engine/source/T3D/fx/explosion.h              |  1 -
 Engine/source/T3D/fx/lightning.cpp            |  2 +-
 Engine/source/T3D/fx/lightning.h              |  1 -
 Engine/source/T3D/fx/precipitation.h          |  1 -
 Engine/source/T3D/projectile.cpp              | 25 +++---
 Engine/source/T3D/projectile.h                | 10 ++-
 Engine/source/T3D/rigidShape.cpp              | 58 +++++++------
 Engine/source/T3D/rigidShape.h                | 25 +++++-
 Engine/source/T3D/vehicles/hoverVehicle.cpp   | 43 +++++-----
 Engine/source/T3D/vehicles/hoverVehicle.h     | 10 ++-
 Engine/source/T3D/vehicles/vehicle.cpp        | 86 ++++++++-----------
 Engine/source/T3D/vehicles/vehicle.h          | 26 +++++-
 Engine/source/T3D/vehicles/wheeledVehicle.cpp | 38 ++++----
 Engine/source/T3D/vehicles/wheeledVehicle.h   | 12 ++-
 14 files changed, 191 insertions(+), 147 deletions(-)

diff --git a/Engine/source/T3D/fx/explosion.h b/Engine/source/T3D/fx/explosion.h
index ae01c4bee..20eadcd88 100644
--- a/Engine/source/T3D/fx/explosion.h
+++ b/Engine/source/T3D/fx/explosion.h
@@ -70,7 +70,6 @@ class ExplosionData : public GameBaseData {
    S32 particleDensity;
    F32 particleRadius;
 
-   //SFXTrack*        soundProfile;
    DECLARE_SOUNDASSET(ExplosionData, Sound);
    DECLARE_SOUNDASSET_SETGET(ExplosionData, Sound);
 
diff --git a/Engine/source/T3D/fx/lightning.cpp b/Engine/source/T3D/fx/lightning.cpp
index efc521319..73a63550e 100644
--- a/Engine/source/T3D/fx/lightning.cpp
+++ b/Engine/source/T3D/fx/lightning.cpp
@@ -290,7 +290,7 @@ bool LightningData::preload(bool server, String &errorStr)
    //dQsort(thunderSounds, MaxThunders, sizeof(SFXTrack*), cmpSounds);
 
    for (S32 i = 0; i < MaxThunders; i++) {
-      if (mThunderSound[i] == NULL)
+      if (mThunderSound[i])
       {
          _setThunderSound(getThunderSound(i), i);
       }
diff --git a/Engine/source/T3D/fx/lightning.h b/Engine/source/T3D/fx/lightning.h
index 1e04bd61d..7f706d9f8 100644
--- a/Engine/source/T3D/fx/lightning.h
+++ b/Engine/source/T3D/fx/lightning.h
@@ -63,7 +63,6 @@ class LightningData : public GameBaseData
 
    //-------------------------------------- Console set variables
   public:
-   //SFXTrack*          thunderSounds[MaxThunders];
 
    DECLARE_SOUNDASSET_ARRAY(LightningData, ThunderSound, MaxThunders);
    DECLARE_SOUNDASSET_ARRAY_SETGET(LightningData, ThunderSound);
diff --git a/Engine/source/T3D/fx/precipitation.h b/Engine/source/T3D/fx/precipitation.h
index cdef0c2a8..e8114b040 100644
--- a/Engine/source/T3D/fx/precipitation.h
+++ b/Engine/source/T3D/fx/precipitation.h
@@ -46,7 +46,6 @@ class PrecipitationData : public GameBaseData
    typedef GameBaseData Parent;
 
   public:
-   //SFXTrack*     soundProfile;
      DECLARE_SOUNDASSET(PrecipitationData, Sound);
      DECLARE_SOUNDASSET_SETGET(PrecipitationData, Sound);
 
diff --git a/Engine/source/T3D/projectile.cpp b/Engine/source/T3D/projectile.cpp
index 739daf4a5..678fde550 100644
--- a/Engine/source/T3D/projectile.cpp
+++ b/Engine/source/T3D/projectile.cpp
@@ -146,7 +146,7 @@ ProjectileData::ProjectileData()
 {
    INIT_SHAPEASSET(ProjectileShape);
 
-   sound = NULL;
+   INIT_SOUNDASSET(ProjectileSound);
 
    explosion = NULL;
    explosionId = 0;
@@ -217,7 +217,7 @@ ProjectileData::ProjectileData(const ProjectileData& other, bool temp_clone) : G
    splashId = other.splashId; // -- for pack/unpack of splash ptr
    decal = other.decal;
    decalId = other.decalId; // -- for pack/unpack of decal ptr
-   sound = other.sound;
+   CLONE_SOUNDASSET(ProjectileSound);
    lightDesc = other.lightDesc;
    lightDescId = other.lightDescId; // -- for pack/unpack of lightDesc ptr
    CLONE_SHAPEASSET(ProjectileShape);// -- TSShape loads using mProjectileShapeName
@@ -252,8 +252,7 @@ void ProjectileData::initPersistFields()
       "@brief Scale to apply to the projectile's size.\n\n"
       "@note This is applied after SceneObject::scale\n");
 
-   addField("sound", TypeSFXTrackName, Offset(sound, ProjectileData),
-      "@brief SFXTrack datablock used to play sounds while in flight.\n\n");
+   INITPERSISTFIELD_SOUNDASSET(ProjectileSound, ProjectileData, "The sound for the projectile.");
 
    addField("explosion", TYPEID< ExplosionData >(), Offset(explosion, ProjectileData),
       "@brief Explosion datablock used when the projectile explodes outside of water.\n\n");
@@ -368,9 +367,8 @@ bool ProjectileData::preload(bool server, String &errorStr)
          if (Sim::findObject(decalId, decal) == false)
             Con::errorf(ConsoleLogEntry::General, "ProjectileData::preload: Invalid packet, bad datablockId(decal): %d", decalId);
 
-      String sfxErrorStr;
-      if( !sfxResolve( &sound, sfxErrorStr ) )
-         Con::errorf(ConsoleLogEntry::General, "ProjectileData::preload: Invalid packet: %s", sfxErrorStr.c_str());
+      if( !getProjectileSound() )
+         Con::errorf(ConsoleLogEntry::General, "ProjectileData::preload: Invalid asset");
 
       if (!lightDesc && lightDescId != 0)
          if (Sim::findObject(lightDescId, lightDesc) == false)
@@ -436,8 +434,7 @@ void ProjectileData::packData(BitStream* stream)
    if (stream->writeFlag(decal != NULL))
       stream->writeRangedU32(decal->getId(), DataBlockObjectIdFirst,
                                               DataBlockObjectIdLast);
-
-   sfxWrite( stream, sound );
+   PACKDATA_SOUNDASSET(ProjectileSound);
 
    if ( stream->writeFlag(lightDesc != NULL))
       stream->writeRangedU32(lightDesc->getId(), DataBlockObjectIdFirst,
@@ -497,8 +494,8 @@ void ProjectileData::unpackData(BitStream* stream)
 
    if (stream->readFlag())
       decalId = stream->readRangedU32(DataBlockObjectIdFirst, DataBlockObjectIdLast);
-   
-   sfxRead( stream, &sound );
+
+   UNPACKDATA_SOUNDASSET(ProjectileSound);
 
    if (stream->readFlag())
       lightDescId = stream->readRangedU32(DataBlockObjectIdFirst, DataBlockObjectIdLast);
@@ -882,8 +879,8 @@ bool Projectile::onNewDataBlock( GameBaseData *dptr, bool reload )
 
       SFX_DELETE( mSound );
 
-      if ( mDataBlock->sound )
-         mSound = SFX->createSource( mDataBlock->sound );
+      if ( mDataBlock->getProjectileSound() )
+         mSound = SFX->createSource( mDataBlock->getSFXProfile() );
    }
 
    return true;
@@ -1097,7 +1094,7 @@ void Projectile::explode( const Point3F &p, const Point3F &n, const U32 collideT
 
 void Projectile::updateSound()
 {
-   if (!mDataBlock->sound)
+   if (!mDataBlock->getProjectileSound())
       return;
 
    if ( mSound )
diff --git a/Engine/source/T3D/projectile.h b/Engine/source/T3D/projectile.h
index 6209ba531..f340d54a7 100644
--- a/Engine/source/T3D/projectile.h
+++ b/Engine/source/T3D/projectile.h
@@ -44,6 +44,7 @@
 #include "lighting/lightInfo.h"
 #endif
 
+#include "T3D/assets/SoundAsset.h"
 #include "T3D/assets/ShapeAsset.h"
 
 class ExplosionData;
@@ -115,7 +116,14 @@ public:
    DecalData *decal;                   // (impact) Decal Datablock
    S32 decalId;                        // (impact) Decal ID
 
-   SFXTrack* sound;                    // Projectile Sound
+   DECLARE_SOUNDASSET(ProjectileData, ProjectileSound);
+   DECLARE_SOUNDASSET_SETGET(ProjectileData, ProjectileSound);
+   SFXProfile* getSFXProfile() {
+      if (mProjectileSoundAsset.notNull())
+         return mProjectileSoundAsset->getSfxProfile();
+      else
+         return NULL;
+   }
    
    LightDescription *lightDesc;
    S32 lightDescId;   
diff --git a/Engine/source/T3D/rigidShape.cpp b/Engine/source/T3D/rigidShape.cpp
index cf26f8ea9..73c8925cf 100644
--- a/Engine/source/T3D/rigidShape.cpp
+++ b/Engine/source/T3D/rigidShape.cpp
@@ -238,7 +238,7 @@ RigidShapeData::RigidShapeData()
    density = 4;
 
    for (S32 i = 0; i < Body::MaxSounds; i++)
-      body.sound[i] = 0;
+      INIT_SOUNDASSET_ARRAY(BodySounds, i);
 
    dustEmitter = NULL;
    dustID = 0;
@@ -256,7 +256,8 @@ RigidShapeData::RigidShapeData()
    hardSplashSoundVel = 3.0;
    enablePhysicsRep = true;
 
-   dMemset(waterSound, 0, sizeof(waterSound));
+   for (S32 i = 0; i < Sounds::MaxSounds; i++)
+      INIT_SOUNDASSET_ARRAY(WaterSounds, i);
 
    dragForce            = 0;
    vertFactor           = 0.25;
@@ -299,7 +300,10 @@ bool RigidShapeData::preload(bool server, String &errorStr)
    // Resolve objects transmitted from server
    if (!server) {
       for (S32 i = 0; i < Body::MaxSounds; i++)
-         sfxResolve( &body.sound[ i ], errorStr );
+         if (mBodySounds[i])
+         {
+            _setBodySounds(getBodySounds(i), i);
+         }
    }
 
    if( !dustEmitter && dustID != 0 )
@@ -354,8 +358,10 @@ void RigidShapeData::packData(BitStream* stream)
 
    stream->write(body.restitution);
    stream->write(body.friction);
-   for( U32 i = 0; i < Body::MaxSounds; ++ i )
-      sfxWrite( stream, body.sound[ i ] );
+   for (U32 i = 0; i < Body::MaxSounds; ++i)
+   {
+      PACKDATA_SOUNDASSET_ARRAY(BodySounds, i);
+   }
 
    stream->write(minImpactSpeed);
    stream->write(softImpactSpeed);
@@ -384,8 +390,10 @@ void RigidShapeData::packData(BitStream* stream)
    stream->write(enablePhysicsRep);
 
    // write the water sound profiles
-   for( U32 i = 0; i < MaxSounds; ++ i )
-      sfxWrite( stream, waterSound[ i ] );
+   for (U32 i = 0; i < Sounds::MaxSounds; ++i)
+   {
+      PACKDATA_SOUNDASSET_ARRAY(WaterSounds, i);
+   }
 
    if (stream->writeFlag( dustEmitter ))
       stream->writeRangedU32( dustEmitter->getId(), DataBlockObjectIdFirst,  DataBlockObjectIdLast );
@@ -413,8 +421,10 @@ void RigidShapeData::unpackData(BitStream* stream)
    stream->read(&body.restitution);
    stream->read(&body.friction);
 
-   for( U32 i = 0; i < Body::MaxSounds; i++)
-      sfxRead( stream, &body.sound[ i ] );
+   for (U32 i = 0; i < Body::Sounds::MaxSounds; i++)
+   {
+      UNPACKDATA_SOUNDASSET_ARRAY(BodySounds, i);
+   }
 
    stream->read(&minImpactSpeed);
    stream->read(&softImpactSpeed);
@@ -443,8 +453,10 @@ void RigidShapeData::unpackData(BitStream* stream)
    stream->read(&enablePhysicsRep);
 
    // write the water sound profiles
-   for( U32 i = 0; i < MaxSounds; ++ i )
-      sfxRead( stream, &waterSound[ i ] );
+   for (U32 i = 0; i < Sounds::MaxSounds; ++i)
+   {
+      UNPACKDATA_SOUNDASSET_ARRAY(WaterSounds, i);
+   }
 
    if( stream->readFlag() )
       dustID = (S32) stream->readRangedU32(DataBlockObjectIdFirst, DataBlockObjectIdLast);
@@ -516,21 +528,15 @@ void RigidShapeData::initPersistFields()
    
    addGroup( "Sounds" );
 
-      addField("softImpactSound", TypeSFXTrackName, Offset(body.sound[Body::SoftImpactSound], RigidShapeData),
-         "Sound to play when body impacts with at least softImageSpeed but less than hardImpactSpeed." );
-      addField("hardImpactSound", TypeSFXTrackName, Offset(body.sound[Body::HardImpactSound], RigidShapeData),
-         "Sound to play when body impacts with at least hardImpactSpeed." );
+      INITPERSISTFIELD_SOUNDASSET_ARRAY(BodySounds, Body::Sounds::MaxSounds, RigidShapeData, "Sounds for body.");
 
       addField("exitSplashSoundVelocity", TypeF32,       Offset(exitSplashSoundVel, RigidShapeData), "The minimum velocity at which the exit splash sound will be played when emerging from water.\n");
       addField("softSplashSoundVelocity", TypeF32,       Offset(softSplashSoundVel, RigidShapeData),"The minimum velocity at which the soft splash sound will be played when impacting water.\n");
       addField("mediumSplashSoundVelocity", TypeF32,     Offset(medSplashSoundVel, RigidShapeData), "The minimum velocity at which the medium splash sound will be played when impacting water.\n");
       addField("hardSplashSoundVelocity", TypeF32,       Offset(hardSplashSoundVel, RigidShapeData), "The minimum velocity at which the hard splash sound will be played when impacting water.\n");
-      addField("exitingWater",      TypeSFXTrackName,   Offset(waterSound[ExitWater],   RigidShapeData), "The AudioProfile will be used to produce sounds when emerging from water.\n");
-      addField("impactWaterEasy",   TypeSFXTrackName,   Offset(waterSound[ImpactSoft],   RigidShapeData), "The AudioProfile will be used to produce sounds when a soft impact with water occurs.\n");
-      addField("impactWaterMedium", TypeSFXTrackName,   Offset(waterSound[ImpactMedium],   RigidShapeData), "The AudioProfile will be used to produce sounds when a medium impact with water occurs.\n");
-      addField("impactWaterHard",   TypeSFXTrackName,   Offset(waterSound[ImpactHard],   RigidShapeData), "The AudioProfile will be used to produce sounds when a hard impact with water occurs.\n");
-      addField("waterWakeSound",    TypeSFXTrackName,   Offset(waterSound[Wake],   RigidShapeData), "The AudioProfile will be used to produce sounds when a water wake is displayed.\n");
       
+      INITPERSISTFIELD_SOUNDASSET_ARRAY(WaterSounds, Sounds::MaxSounds, RigidShapeData, "Sounds for interacting with water.");
+
    endGroup( "Sounds" );
    
    addGroup( "Camera" );
@@ -1155,27 +1161,27 @@ void RigidShape::updatePos(F32 dt)
             if (collSpeed >= mDataBlock->softImpactSpeed)
                impactSound = RigidShapeData::Body::SoftImpactSound;
 
-         if (impactSound != -1 && mDataBlock->body.sound[impactSound] != NULL)
-            SFX->playOnce(mDataBlock->body.sound[impactSound], &getTransform());
+         if (impactSound != -1 && mDataBlock->getBodySounds(impactSound) != NULL)
+            SFX->playOnce(mDataBlock->getBodySoundProfile(impactSound), &getTransform());
       }
 
       // Water volume sounds
       F32 vSpeed = getVelocity().len();
       if (!inLiquid && mWaterCoverage >= 0.8f) {
          if (vSpeed >= mDataBlock->hardSplashSoundVel)
-            SFX->playOnce(mDataBlock->waterSound[RigidShapeData::ImpactHard], &getTransform());
+            SFX->playOnce(mDataBlock->getWaterSoundProfile(RigidShapeData::ImpactHard), &getTransform());
          else
             if (vSpeed >= mDataBlock->medSplashSoundVel)
-               SFX->playOnce(mDataBlock->waterSound[RigidShapeData::ImpactMedium], &getTransform());
+               SFX->playOnce(mDataBlock->getWaterSoundProfile(RigidShapeData::ImpactMedium), &getTransform());
             else
                if (vSpeed >= mDataBlock->softSplashSoundVel)
-                  SFX->playOnce(mDataBlock->waterSound[RigidShapeData::ImpactSoft], &getTransform());
+                  SFX->playOnce(mDataBlock->getWaterSoundProfile(RigidShapeData::ImpactSoft), &getTransform());
          inLiquid = true;
       }
       else
          if (inLiquid && mWaterCoverage < 0.8f) {
             if (vSpeed >= mDataBlock->exitSplashSoundVel)
-               SFX->playOnce(mDataBlock->waterSound[RigidShapeData::ExitWater], &getTransform());
+               SFX->playOnce(mDataBlock->getWaterSoundProfile(RigidShapeData::ExitWater), &getTransform());
             inLiquid = false;
          }
    }
diff --git a/Engine/source/T3D/rigidShape.h b/Engine/source/T3D/rigidShape.h
index 0389f2a72..5fc6ee786 100644
--- a/Engine/source/T3D/rigidShape.h
+++ b/Engine/source/T3D/rigidShape.h
@@ -35,6 +35,8 @@
 #include "T3D/physics/physicsBody.h"
 #endif
 
+#include "T3D/assets/SoundAsset.h"
+
 class ParticleEmitter;
 class ParticleEmitterData;
 class ClippedPolyList;
@@ -57,11 +59,21 @@ class RigidShapeData : public ShapeBaseData
          HardImpactSound,
          MaxSounds,
       };
-      SFXTrack* sound[MaxSounds];
       F32 restitution;
       F32 friction;
    } body;
 
+   DECLARE_SOUNDASSET_ARRAY(RigidShapeData, BodySounds, Body::Sounds::MaxSounds)
+   DECLARE_SOUNDASSET_ARRAY_SETGET(RigidShapeData, BodySounds);
+
+   SFXProfile* getBodySoundProfile(U32 id)
+   {
+      if (mBodySoundsAsset[id] != NULL)
+         return mBodySoundsAsset[id]->getSfxProfile();
+      else
+         return NULL;
+   }
+
    enum RigidShapeConsts
    {
       VC_NUM_DUST_EMITTERS = 1,
@@ -79,7 +91,16 @@ class RigidShapeData : public ShapeBaseData
       Wake,
       MaxSounds
    };
-   SFXTrack* waterSound[MaxSounds];
+   DECLARE_SOUNDASSET_ARRAY(RigidShapeData, WaterSounds, Sounds::MaxSounds)
+   DECLARE_SOUNDASSET_ARRAY_SETGET(RigidShapeData, WaterSounds);
+
+   SFXProfile* getWaterSoundProfile(U32 id)
+   {
+      if (mWaterSoundsAsset[id] != NULL)
+         return mWaterSoundsAsset[id]->getSfxProfile();
+      else
+         return NULL;
+   }
 
    F32 exitSplashSoundVel;
    F32 softSplashSoundVel;
diff --git a/Engine/source/T3D/vehicles/hoverVehicle.cpp b/Engine/source/T3D/vehicles/hoverVehicle.cpp
index ee49b917f..404f54506 100644
--- a/Engine/source/T3D/vehicles/hoverVehicle.cpp
+++ b/Engine/source/T3D/vehicles/hoverVehicle.cpp
@@ -152,7 +152,7 @@ HoverVehicleData::HoverVehicleData()
       jetEmitter[j] = 0;
 
    for (S32 i = 0; i < MaxSounds; i++)
-      sound[i] = 0;
+      INIT_SOUNDASSET_ARRAY(HoverSounds, i);
 }
 
 HoverVehicleData::~HoverVehicleData()
@@ -232,14 +232,8 @@ void HoverVehicleData::initPersistFields()
    addField( "pitchForce", TypeF32, Offset(pitchForce, HoverVehicleData),
       "Pitch (rotation about the X-axis) force applied when steering in the y-axis direction." );
 
-   addField( "jetSound", TYPEID< SFXProfile >(), Offset(sound[JetSound], HoverVehicleData),
-      "Looping sound played when the vehicle is jetting." );
-   addField( "engineSound", TYPEID< SFXProfile >(), Offset(sound[EngineSound], HoverVehicleData),
-      "Looping engine sound.\nThe volume is dynamically adjusted based on the "
-      "current thrust level." );
-   addField( "floatSound", TYPEID< SFXProfile >(), Offset(sound[FloatSound], HoverVehicleData),
-      "Looping sound played while the vehicle is floating.\n\n@see stabMinLen" );
-
+   INITPERSISTFIELD_SOUNDASSET_ARRAY(HoverSounds, Sounds::MaxSounds, HoverVehicleData, "Sounds for hover vehicle.");
+   
    addField( "dustTrailEmitter", TYPEID< ParticleEmitterData >(), Offset(dustTrailEmitter, HoverVehicleData),
       "Emitter to generate particles for the vehicle's dust trail.\nThe trail "
       "of dust particles is generated only while the vehicle is moving." );
@@ -312,8 +306,11 @@ bool HoverVehicleData::preload(bool server, String &errorStr)
    // Resolve objects transmitted from server
    if (!server) {
       for (S32 i = 0; i < MaxSounds; i++)
-         if (sound[i])
-            Sim::findObject(SimObjectId((uintptr_t)sound[i]),sound[i]);
+         if (mHoverSounds[i])
+         {
+            _setHoverSounds(getHoverSounds(i), i);
+         }
+
       for (S32 j = 0; j < MaxJetEmitters; j++)
          if (jetEmitter[j])
             Sim::findObject(SimObjectId((uintptr_t)jetEmitter[j]),jetEmitter[j]);
@@ -361,9 +358,9 @@ void HoverVehicleData::packData(BitStream* stream)
    stream->write(dustTrailFreqMod);
 
    for (S32 i = 0; i < MaxSounds; i++)
-      if (stream->writeFlag(sound[i]))
-         stream->writeRangedU32(mPacked ? SimObjectId((uintptr_t)sound[i]):
-                                sound[i]->getId(),DataBlockObjectIdFirst,DataBlockObjectIdLast);
+   {
+      PACKDATA_SOUNDASSET_ARRAY(HoverSounds, i);
+   }
 
    for (S32 j = 0; j < MaxJetEmitters; j++)
    {
@@ -410,9 +407,9 @@ void HoverVehicleData::unpackData(BitStream* stream)
    stream->read(&dustTrailFreqMod);
 
    for (S32 i = 0; i < MaxSounds; i++)
-      sound[i] = stream->readFlag()?
-         (SFXProfile*)(uintptr_t)stream->readRangedU32(DataBlockObjectIdFirst,
-                                               DataBlockObjectIdLast): 0;
+   {
+      UNPACKDATA_SOUNDASSET_ARRAY(HoverSounds, i);
+   }
 
    for (S32 j = 0; j < MaxJetEmitters; j++) {
       jetEmitter[j] = NULL;
@@ -539,14 +536,14 @@ bool HoverVehicle::onNewDataBlock(GameBaseData* dptr, bool reload)
       SFX_DELETE( mFloatSound );
       SFX_DELETE( mJetSound );
 
-      if ( mDataBlock->sound[HoverVehicleData::EngineSound] )
-         mEngineSound = SFX->createSource( mDataBlock->sound[HoverVehicleData::EngineSound], &getTransform() );
+      if ( mDataBlock->getHoverSounds(HoverVehicleData::EngineSound) )
+         mEngineSound = SFX->createSource( mDataBlock->getHoverSoundProfile(HoverVehicleData::EngineSound), &getTransform() );
 
-      if ( !mDataBlock->sound[HoverVehicleData::FloatSound] )
-         mFloatSound = SFX->createSource( mDataBlock->sound[HoverVehicleData::FloatSound], &getTransform() );
+      if ( !mDataBlock->getHoverSounds(HoverVehicleData::FloatSound) )
+         mFloatSound = SFX->createSource( mDataBlock->getHoverSoundProfile(HoverVehicleData::FloatSound), &getTransform() );
 
-      if ( mDataBlock->sound[HoverVehicleData::JetSound] )
-         mJetSound = SFX->createSource( mDataBlock->sound[HoverVehicleData::JetSound], &getTransform() );
+      if ( mDataBlock->getHoverSounds(HoverVehicleData::JetSound) )
+         mJetSound = SFX->createSource( mDataBlock->getHoverSoundProfile(HoverVehicleData::JetSound), &getTransform() );
    }
 
    // Todo: Uncomment if this is a "leaf" class
diff --git a/Engine/source/T3D/vehicles/hoverVehicle.h b/Engine/source/T3D/vehicles/hoverVehicle.h
index 7b44e5987..63ff65977 100644
--- a/Engine/source/T3D/vehicles/hoverVehicle.h
+++ b/Engine/source/T3D/vehicles/hoverVehicle.h
@@ -46,7 +46,15 @@ class HoverVehicleData : public VehicleData
       FloatSound,
       MaxSounds
    };
-   SFXProfile* sound[MaxSounds];
+   DECLARE_SOUNDASSET_ARRAY(HoverVehicleData, HoverSounds, Sounds::MaxSounds);
+   DECLARE_SOUNDASSET_ARRAY_SETGET(HoverVehicleData, HoverSounds);
+   SFXProfile* getHoverSoundProfile(U32 id)
+   {
+      if (mHoverSoundsAsset[id] != NULL)
+         return mHoverSoundsAsset[id]->getSfxProfile();
+      else
+         return NULL;
+   }
 
    enum Jets {
       // These enums index into a static name list.
diff --git a/Engine/source/T3D/vehicles/vehicle.cpp b/Engine/source/T3D/vehicles/vehicle.cpp
index c673cd3b7..3aaac0646 100644
--- a/Engine/source/T3D/vehicles/vehicle.cpp
+++ b/Engine/source/T3D/vehicles/vehicle.cpp
@@ -166,7 +166,9 @@ VehicleData::VehicleData()
    powerSteering = false;
 
    for (S32 i = 0; i < Body::MaxSounds; i++)
-      body.sound[i] = 0;
+   {
+      INIT_SOUNDASSET_ARRAY(VehicleBodySounds, i);
+   }
 
    dustEmitter = NULL;
    dustID = 0;
@@ -189,7 +191,8 @@ VehicleData::VehicleData()
    medSplashSoundVel = 2.0;
    hardSplashSoundVel = 3.0;
 
-   dMemset(waterSound, 0, sizeof(waterSound));
+   for (S32 i = 0; i < Sounds::MaxSounds; i++)
+      INIT_SOUNDASSET_ARRAY(VehicleWaterSounds, i);
 
    collDamageThresholdVel = 20;
    collDamageMultiplier = 0.05f;
@@ -215,8 +218,10 @@ bool VehicleData::preload(bool server, String &errorStr)
    // Resolve objects transmitted from server
    if (!server) {
       for (S32 i = 0; i < Body::MaxSounds; i++)
-         if (body.sound[i])
-            Sim::findObject(SimObjectId((uintptr_t)body.sound[i]),body.sound[i]);
+         if (mVehicleBodySounds[i])
+         {
+            _setVehicleBodySounds(getVehicleBodySounds(i), i);
+         }
    }
 
    if( !dustEmitter && dustID != 0 )
@@ -264,10 +269,9 @@ void VehicleData::packData(BitStream* stream)
    stream->write(body.restitution);
    stream->write(body.friction);
    for (i = 0; i < Body::MaxSounds; i++)
-      if (stream->writeFlag(body.sound[i]))
-         stream->writeRangedU32(mPacked ? SimObjectId((uintptr_t)body.sound[i]):
-                                body.sound[i]->getId(),DataBlockObjectIdFirst,
-                                DataBlockObjectIdLast);
+   {
+      PACKDATA_SOUNDASSET_ARRAY(VehicleBodySounds, i);
+   }
 
    stream->write(minImpactSpeed);
    stream->write(softImpactSpeed);
@@ -308,9 +312,10 @@ void VehicleData::packData(BitStream* stream)
    stream->write(enablePhysicsRep);
 
    // write the water sound profiles
-   for(i = 0; i < MaxSounds; i++)
-      if(stream->writeFlag(waterSound[i]))
-         stream->writeRangedU32(waterSound[i]->getId(), DataBlockObjectIdFirst,  DataBlockObjectIdLast);
+   for (i = 0; i < MaxSounds; i++)
+   {
+      PACKDATA_SOUNDASSET_ARRAY(VehicleWaterSounds, i);
+   }
 
    if (stream->writeFlag( dustEmitter ))
    {
@@ -359,11 +364,9 @@ void VehicleData::unpackData(BitStream* stream)
    stream->read(&body.restitution);
    stream->read(&body.friction);
    S32 i;
-   for (i = 0; i < Body::MaxSounds; i++) {
-      body.sound[i] = NULL;
-      if (stream->readFlag())
-         body.sound[i] = (SFXProfile*)(uintptr_t)stream->readRangedU32(DataBlockObjectIdFirst,
-                                                              DataBlockObjectIdLast);
+   for (i = 0; i < Body::MaxSounds; i++)
+   {
+      UNPACKDATA_SOUNDASSET_ARRAY(VehicleBodySounds, i);
    }
 
    stream->read(&minImpactSpeed);
@@ -405,12 +408,10 @@ void VehicleData::unpackData(BitStream* stream)
    stream->read(&enablePhysicsRep);
 
    // write the water sound profiles
-   for(i = 0; i < MaxSounds; i++)
-      if(stream->readFlag())
-      {
-         U32 id = stream->readRangedU32(DataBlockObjectIdFirst, DataBlockObjectIdLast);
-         waterSound[i] = dynamic_cast<SFXProfile*>( Sim::findObject(id) );
-      }
+   for (i = 0; i < Sounds::MaxSounds; i++)
+   {
+      UNPACKDATA_SOUNDASSET_ARRAY(VehicleWaterSounds, i);
+   }
 
    if( stream->readFlag() )
    {
@@ -491,15 +492,8 @@ void VehicleData::initPersistFields()
    addField( "bodyFriction", TypeF32, Offset(body.friction, VehicleData),
       "Collision friction coefficient.\nHow well this object will slide against "
       "objects it collides with." );
-   addField( "softImpactSound", TYPEID< SFXProfile >(), Offset(body.sound[Body::SoftImpactSound], VehicleData),
-      "@brief Sound to play on a 'soft' impact.\n\n"
-      "This sound is played if the impact speed is < hardImpactSpeed and >= "
-      "softImpactSpeed.\n\n"
-      "@see softImpactSpeed" );
-   addField( "hardImpactSound", TYPEID< SFXProfile >(), Offset(body.sound[Body::HardImpactSound], VehicleData),
-      "@brief Sound to play on a 'hard' impact.\n\n"
-      "This sound is played if the impact speed >= hardImpactSpeed.\n\n"
-      "@see hardImpactSpeed" );
+
+   INITPERSISTFIELD_SOUNDASSET_ARRAY(VehicleBodySounds, Body::Sounds::MaxSounds, VehicleData, "Sounds for vehicle body impacts.");
 
    addField( "minImpactSpeed", TypeF32, Offset(minImpactSpeed, VehicleData),
       "Minimum collision speed for the onImpact callback to be invoked." );
@@ -596,18 +590,8 @@ void VehicleData::initPersistFields()
    addField( "hardSplashSoundVelocity", TypeF32, Offset(hardSplashSoundVel, VehicleData),
       "Minimum velocity when entering the water for the imapactWaterHard sound "
       "to play.\n\n@see impactWaterHard" );
-   addField( "exitingWater", TYPEID< SFXProfile >(), Offset(waterSound[ExitWater], VehicleData),
-      "Sound to play when exiting the water." );
-   addField( "impactWaterEasy", TYPEID< SFXProfile >(), Offset(waterSound[ImpactSoft], VehicleData),
-      "Sound to play when entering the water with speed >= softSplashSoundVelocity "
-      "and < mediumSplashSoundVelocity." );
-   addField( "impactWaterMedium", TYPEID< SFXProfile >(), Offset(waterSound[ImpactMedium], VehicleData),
-      "Sound to play when entering the water with speed >= mediumSplashSoundVelocity "
-      "and < hardSplashSoundVelocity." );
-   addField( "impactWaterHard", TYPEID< SFXProfile >(), Offset(waterSound[ImpactHard], VehicleData),
-      "Sound to play when entering the water with speed >= hardSplashSoundVelocity." );
-   addField( "waterWakeSound", TYPEID< SFXProfile >(), Offset(waterSound[Wake], VehicleData),
-      "Looping sound to play while moving through the water." );
+
+   INITPERSISTFIELD_SOUNDASSET_ARRAY(WaterSounds, Sounds::MaxSounds, VehicleData, "Sounds for interacting with water.");
 
    addField( "collDamageThresholdVel", TypeF32, Offset(collDamageThresholdVel, VehicleData),
       "Minimum collision velocity to cause damage to this vehicle.\nCurrently unused." );
@@ -876,8 +860,8 @@ bool Vehicle::onNewDataBlock(GameBaseData* dptr,bool reload)
       // costs and makes the system easier to understand.
       SFX_DELETE( mWakeSound );
 
-      if ( mDataBlock->waterSound[VehicleData::Wake] )
-         mWakeSound = SFX->createSource( mDataBlock->waterSound[VehicleData::Wake], &getTransform() );
+      if ( mDataBlock->getVehicleWaterSounds(VehicleData::Wake) != NULL )
+         mWakeSound = SFX->createSource( mDataBlock->getVehicleWaterSoundProfile(VehicleData::Wake), &getTransform() );
    }
 
    return true;
@@ -1140,27 +1124,27 @@ void Vehicle::updatePos(F32 dt)
             if (collSpeed >= mDataBlock->softImpactSpeed)
                impactSound = VehicleData::Body::SoftImpactSound;
 
-         if (impactSound != -1 && mDataBlock->body.sound[impactSound] != NULL)
-            SFX->playOnce( mDataBlock->body.sound[impactSound], &getTransform() );
+         if (impactSound != -1 && mDataBlock->getVehicleBodySounds(impactSound) != NULL)
+            SFX->playOnce( mDataBlock->getVehicleBodySoundProfile(impactSound), &getTransform() );
       }
 
       // Water volume sounds
       F32 vSpeed = getVelocity().len();
       if (!inLiquid && mWaterCoverage >= 0.8f) {
          if (vSpeed >= mDataBlock->hardSplashSoundVel)
-            SFX->playOnce( mDataBlock->waterSound[VehicleData::ImpactHard], &getTransform() );
+            SFX->playOnce( mDataBlock->getVehicleWaterSoundProfile(VehicleData::ImpactHard), &getTransform() );
          else
             if (vSpeed >= mDataBlock->medSplashSoundVel)
-               SFX->playOnce( mDataBlock->waterSound[VehicleData::ImpactMedium], &getTransform() );
+               SFX->playOnce( mDataBlock->getVehicleWaterSoundProfile(VehicleData::ImpactMedium), &getTransform() );
          else
             if (vSpeed >= mDataBlock->softSplashSoundVel)
-               SFX->playOnce( mDataBlock->waterSound[VehicleData::ImpactSoft], &getTransform() );
+               SFX->playOnce( mDataBlock->getVehicleWaterSoundProfile(VehicleData::ImpactSoft), &getTransform() );
          inLiquid = true;
       }
       else
          if(inLiquid && mWaterCoverage < 0.8f) {
             if (vSpeed >= mDataBlock->exitSplashSoundVel)
-               SFX->playOnce( mDataBlock->waterSound[VehicleData::ExitWater], &getTransform() );
+               SFX->playOnce( mDataBlock->getVehicleWaterSoundProfile(VehicleData::ExitWater), &getTransform() );
          inLiquid = false;
       }
    }
diff --git a/Engine/source/T3D/vehicles/vehicle.h b/Engine/source/T3D/vehicles/vehicle.h
index 585f81b90..1c26f6cba 100644
--- a/Engine/source/T3D/vehicles/vehicle.h
+++ b/Engine/source/T3D/vehicles/vehicle.h
@@ -45,11 +45,22 @@ struct VehicleData : public RigidShapeData
          HardImpactSound,
          MaxSounds,
       };
-      SFXProfile* sound[MaxSounds];
       F32 restitution;
       F32 friction;
    } body;
 
+   DECLARE_SOUNDASSET_ARRAY(VehicleData, VehicleBodySounds, Body::Sounds::MaxSounds)
+   DECLARE_SOUNDASSET_ARRAY_SETGET(VehicleData, VehicleBodySounds);
+
+   SFXProfile* getVehicleBodySoundProfile(U32 id)
+   {
+      if (mVehicleBodySoundsAsset[id] != NULL)
+         return mVehicleBodySoundsAsset[id]->getSfxProfile();
+      else
+         return NULL;
+   }
+
+
    enum VehicleConsts
    {
       VC_NUM_DUST_EMITTERS = 1,
@@ -69,7 +80,18 @@ struct VehicleData : public RigidShapeData
       Wake,
       MaxSounds
    };
-   SFXProfile* waterSound[MaxSounds];
+
+  DECLARE_SOUNDASSET_ARRAY(VehicleData, VehicleWaterSounds, Sounds::MaxSounds)
+  DECLARE_SOUNDASSET_ARRAY_SETGET(VehicleData, VehicleWaterSounds);
+
+  SFXProfile* getVehicleWaterSoundProfile(U32 id)
+  {
+     if (mVehicleWaterSoundsAsset[id] != NULL)
+        return mVehicleWaterSoundsAsset[id]->getSfxProfile();
+     else
+        return NULL;
+  }
+
    F32 exitSplashSoundVel;
    F32 softSplashSoundVel;
    F32 medSplashSoundVel;
diff --git a/Engine/source/T3D/vehicles/wheeledVehicle.cpp b/Engine/source/T3D/vehicles/wheeledVehicle.cpp
index 36a355cdb..3fbde4af7 100644
--- a/Engine/source/T3D/vehicles/wheeledVehicle.cpp
+++ b/Engine/source/T3D/vehicles/wheeledVehicle.cpp
@@ -301,7 +301,7 @@ WheeledVehicleData::WheeledVehicleData()
    wheelCount = 0;
    dMemset(&wheel, 0, sizeof(wheel));
    for (S32 i = 0; i < MaxSounds; i++)
-      sound[i] = 0;
+      INIT_SOUNDASSET_ARRAY(WheeledVehicleSounds, i);
 }
 
 
@@ -335,10 +335,9 @@ bool WheeledVehicleData::preload(bool server, String &errorStr)
    if (!server) {
       for (S32 i = 0; i < MaxSounds; i++)
       {
-         if (!sfxResolve(&sound[i], errorStr))
+         if (mWheeledVehicleSounds[i])
          {
-            delete si;
-            return false;
+            _setWheeledVehicleSounds(getWheeledVehicleSounds(i), i);
          }
       }
 
@@ -438,16 +437,7 @@ bool WheeledVehicleData::mirrorWheel(Wheel* we)
 
 void WheeledVehicleData::initPersistFields()
 {
-   addField( "jetSound", TYPEID< SFXTrack >(), Offset(sound[JetSound], WheeledVehicleData),
-      "Looping sound played when the vehicle is jetting." );
-   addField( "engineSound", TYPEID< SFXTrack >(), Offset(sound[EngineSound], WheeledVehicleData),
-      "@brief Looping engine sound.\n\n"
-      "The pitch is dynamically adjusted based on the current engine RPM" );
-   addField("squealSound", TYPEID< SFXTrack >(), Offset(sound[SquealSound], WheeledVehicleData),
-      "@brief Looping sound played while any of the wheels is slipping.\n\n"
-      "The volume is dynamically adjusted based on how much the wheels are slipping." );
-   addField("WheelImpactSound", TYPEID< SFXTrack >(), Offset(sound[WheelImpactSound], WheeledVehicleData),
-      "Sound played when the wheels impact the ground.\nCurrently unused." );
+   INITPERSISTFIELD_SOUNDASSET_ARRAY(WheeledVehicleSounds, Sounds::MaxSounds, WheeledVehicleData, "Sounds related to wheeled vehicle.");
 
    addField("tireEmitter",TYPEID< ParticleEmitterData >(), Offset(tireEmitter, WheeledVehicleData),
       "ParticleEmitterData datablock used to generate particles from each wheel "
@@ -481,7 +471,9 @@ void WheeledVehicleData::packData(BitStream* stream)
          tireEmitter->getId(),DataBlockObjectIdFirst,DataBlockObjectIdLast);
 
    for (S32 i = 0; i < MaxSounds; i++)
-      sfxWrite( stream, sound[ i ] );
+   {
+      PACKDATA_SOUNDASSET_ARRAY(WheeledVehicleSounds, i);
+   }
 
    stream->write(maxWheelSpeed);
    stream->write(engineTorque);
@@ -498,7 +490,9 @@ void WheeledVehicleData::unpackData(BitStream* stream)
          DataBlockObjectIdLast): 0;
 
    for (S32 i = 0; i < MaxSounds; i++)
-      sfxRead( stream, &sound[ i ] );
+   {
+      UNPACKDATA_SOUNDASSET_ARRAY(WheeledVehicleSounds, i);
+   }
 
    stream->read(&maxWheelSpeed);
    stream->read(&engineTorque);
@@ -683,14 +677,14 @@ bool WheeledVehicle::onNewDataBlock(GameBaseData* dptr, bool reload)
       SFX_DELETE( mSquealSound );
       SFX_DELETE( mJetSound );
 
-      if ( mDataBlock->sound[WheeledVehicleData::EngineSound] )
-         mEngineSound = SFX->createSource( mDataBlock->sound[WheeledVehicleData::EngineSound], &getTransform() );
+      if ( mDataBlock->getWheeledVehicleSounds(WheeledVehicleData::EngineSound) )
+         mEngineSound = SFX->createSource( mDataBlock->getWheeledVehicleSound(WheeledVehicleData::EngineSound), &getTransform() );
 
-      if ( mDataBlock->sound[WheeledVehicleData::SquealSound] )
-         mSquealSound = SFX->createSource( mDataBlock->sound[WheeledVehicleData::SquealSound], &getTransform() );
+      if ( mDataBlock->getWheeledVehicleSounds(WheeledVehicleData::SquealSound) )
+         mSquealSound = SFX->createSource( mDataBlock->getWheeledVehicleSound(WheeledVehicleData::SquealSound), &getTransform() );
 
-      if ( mDataBlock->sound[WheeledVehicleData::JetSound] )
-         mJetSound = SFX->createSource( mDataBlock->sound[WheeledVehicleData::JetSound], &getTransform() );
+      if ( mDataBlock->getWheeledVehicleSounds(WheeledVehicleData::JetSound) )
+         mJetSound = SFX->createSource( mDataBlock->getWheeledVehicleSound(WheeledVehicleData::JetSound), &getTransform() );
    }
 
    scriptOnNewDataBlock();
diff --git a/Engine/source/T3D/vehicles/wheeledVehicle.h b/Engine/source/T3D/vehicles/wheeledVehicle.h
index b096670ca..f5fe52fef 100644
--- a/Engine/source/T3D/vehicles/wheeledVehicle.h
+++ b/Engine/source/T3D/vehicles/wheeledVehicle.h
@@ -118,7 +118,17 @@ struct WheeledVehicleData: public VehicleData
       WheelImpactSound,
       MaxSounds,
    };
-   SFXTrack* sound[MaxSounds];
+   DECLARE_SOUNDASSET_ARRAY(WheeledVehicleData, WheeledVehicleSounds, Sounds::MaxSounds);
+   DECLARE_SOUNDASSET_ARRAY_SETGET(WheeledVehicleData, WheeledVehicleSounds);
+
+   SFXProfile* getWheeledVehicleSound(U32 id)
+   {
+      if (mWheeledVehicleSoundsAsset[id] != NULL)
+         return mWheeledVehicleSoundsAsset[id]->getSfxProfile();
+      else
+         return NULL;
+   }
+
 
    ParticleEmitterData* tireEmitter;
 

From 30b57c0f95c91f2f576b8dcf3933c1c0d3b28329 Mon Sep 17 00:00:00 2001
From: marauder2k7 <ctrl-intelligence@live.co.uk>
Date: Mon, 20 Sep 2021 14:17:10 +0100
Subject: [PATCH 088/399] More turns

-Flying Vehicle
-Proximinity Mine
---
 Engine/source/T3D/proximityMine.cpp          | 42 ++++++++++----------
 Engine/source/T3D/proximityMine.h            |  8 +++-
 Engine/source/T3D/vehicles/flyingVehicle.cpp | 36 +++++++----------
 Engine/source/T3D/vehicles/flyingVehicle.h   | 10 ++++-
 4 files changed, 50 insertions(+), 46 deletions(-)

diff --git a/Engine/source/T3D/proximityMine.cpp b/Engine/source/T3D/proximityMine.cpp
index 2102ef7e1..12eb60a1a 100644
--- a/Engine/source/T3D/proximityMine.cpp
+++ b/Engine/source/T3D/proximityMine.cpp
@@ -74,16 +74,16 @@ IMPLEMENT_CALLBACK( ProximityMineData, onExplode, void, ( ProximityMine* obj, Po
 ProximityMineData::ProximityMineData()
  : armingDelay( 0 ),
    armingSequence( -1 ),
-   armingSound( NULL ),
    triggerRadius( 5.0f ),
    triggerSpeed( 1.0f ),
    autoTriggerDelay( 0 ),
    triggerOnOwner( false ),
    triggerDelay( 0 ),
    triggerSequence( -1 ),
-   triggerSound( NULL ),
    explosionOffset( 0.05f )
 {
+   INIT_SOUNDASSET(ArmSound);
+   INIT_SOUNDASSET(TriggerSound);
 }
 
 void ProximityMineData::initPersistFields()
@@ -91,9 +91,9 @@ void ProximityMineData::initPersistFields()
    addGroup( "Arming" );
    addField( "armingDelay", TypeF32, Offset(armingDelay, ProximityMineData), 
       "Delay (in seconds) from when the mine is placed to when it becomes active." );
-   addField( "armingSound", TypeSFXTrackName, Offset(armingSound, ProximityMineData),
-      "Sound to play when the mine is armed (starts at the same time as "
-      "the <i>armed</i> sequence if defined)." );
+
+   INITPERSISTFIELD_SOUNDASSET(ArmSound, ProximityMineData, "Arming sound for this proximity mine.");
+
    endGroup( "Arming" );
 
    addGroup( "Triggering" );
@@ -111,9 +111,9 @@ void ProximityMineData::initPersistFields()
       "Speed above which moving objects within the trigger radius will trigger the mine" );
    addField( "triggerDelay", TypeF32, Offset(triggerDelay, ProximityMineData),
       "Delay (in seconds) from when the mine is triggered until it explodes." );
-   addField( "triggerSound", TypeSFXTrackName, Offset(triggerSound, ProximityMineData),
-      "Sound to play when the mine is triggered (starts at the same time as "
-      "the <i>triggered</i> sequence if defined)." );
+
+   INITPERSISTFIELD_SOUNDASSET(TriggerSound, ProximityMineData, "Arming sound for this proximity mine.");
+
    endGroup( "Triggering" );
 
    addGroup( "Explosion" );
@@ -135,12 +135,10 @@ bool ProximityMineData::preload( bool server, String& errorStr )
 
    if ( !server )
    {
-      // Resolve sounds
-      String sfxErrorStr;
-      if( !sfxResolve( &armingSound, sfxErrorStr ) )
-         Con::errorf( ConsoleLogEntry::General, "ProximityMineData::preload: Invalid packet: %s", sfxErrorStr.c_str() );
-      if( !sfxResolve( &triggerSound, sfxErrorStr ) )
-         Con::errorf( ConsoleLogEntry::General, "ProximityMineData::preload: Invalid packet: %s", sfxErrorStr.c_str() );
+      if( !getArmSound() )
+         Con::errorf( ConsoleLogEntry::General, "ProximityMineData::preload: Invalid arming sound." );
+      if( !getTriggerSound() )
+         Con::errorf( ConsoleLogEntry::General, "ProximityMineData::preload: Invalid trigger sound." );
    }
 
    if ( mShape )
@@ -158,14 +156,14 @@ void ProximityMineData::packData( BitStream* stream )
    Parent::packData( stream );
 
    stream->write( armingDelay );
-   sfxWrite( stream, armingSound );
+   PACKDATA_SOUNDASSET(ArmSound);
 
    stream->write( autoTriggerDelay );
    stream->writeFlag( triggerOnOwner );
    stream->write( triggerRadius );
    stream->write( triggerSpeed );
    stream->write( triggerDelay );
-   sfxWrite( stream, triggerSound );
+   PACKDATA_SOUNDASSET(TriggerSound);
 }
 
 void ProximityMineData::unpackData( BitStream* stream )
@@ -173,14 +171,14 @@ void ProximityMineData::unpackData( BitStream* stream )
    Parent::unpackData(stream);
 
    stream->read( &armingDelay );
-   sfxRead( stream, &armingSound );
+   UNPACKDATA_SOUNDASSET(ArmSound);
 
    stream->read( &autoTriggerDelay );
    triggerOnOwner = stream->readFlag();
    stream->read( &triggerRadius );
    stream->read( &triggerSpeed );
    stream->read( &triggerDelay );
-   sfxRead( stream, &triggerSound );
+   UNPACKDATA_SOUNDASSET(TriggerSound);
 }
 
 //----------------------------------------------------------------------------
@@ -428,8 +426,8 @@ void ProximityMine::processTick( const Move* move )
                   mAnimThread = mShapeInstance->addThread();
                   mShapeInstance->setSequence( mAnimThread, mDataBlock->armingSequence, 0.0f );
                }
-               if ( mDataBlock->armingSound )
-                  SFX->playOnce( mDataBlock->armingSound, &getRenderTransform() );
+               if ( mDataBlock->getArmSound() )
+                  SFX->playOnce( mDataBlock->getArmSoundAsset()->getSfxProfile(), &getRenderTransform() );
             }
             break;
 
@@ -469,8 +467,8 @@ void ProximityMine::processTick( const Move* move )
                   mAnimThread = mShapeInstance->addThread();
                   mShapeInstance->setSequence( mAnimThread, mDataBlock->triggerSequence, 0.0f );
                }
-               if ( mDataBlock->triggerSound )
-                  SFX->playOnce( mDataBlock->triggerSound, &getRenderTransform() );
+               if ( mDataBlock->getTriggerSound() )
+                  SFX->playOnce( mDataBlock->getTriggerSoundAsset()->getSfxProfile(), &getRenderTransform() );
 
                if ( isServerObject() )
                   mDataBlock->onTriggered_callback( this, sql.mList[0] );
diff --git a/Engine/source/T3D/proximityMine.h b/Engine/source/T3D/proximityMine.h
index 7b448e628..4736c0e16 100644
--- a/Engine/source/T3D/proximityMine.h
+++ b/Engine/source/T3D/proximityMine.h
@@ -27,6 +27,8 @@
    #include "T3D/item.h"
 #endif
 
+#include "T3D/assets/SoundAsset.h"
+
 class ExplosionData;
 class SFXTrack;
 class ProximityMine;
@@ -43,7 +45,8 @@ struct ProximityMineData: public ItemData
 public:
    F32               armingDelay;
    S32               armingSequence;
-   SFXTrack*         armingSound;
+   DECLARE_SOUNDASSET(ProximityMineData, ArmSound);
+   DECLARE_SOUNDASSET_SETGET(ProximityMineData, ArmSound);
 
    F32               autoTriggerDelay;
    bool              triggerOnOwner;
@@ -51,7 +54,8 @@ public:
    F32               triggerSpeed;
    F32               triggerDelay;
    S32               triggerSequence;
-   SFXTrack*         triggerSound;
+   DECLARE_SOUNDASSET(ProximityMineData, TriggerSound);
+   DECLARE_SOUNDASSET_SETGET(ProximityMineData, TriggerSound);
 
    F32               explosionOffset;
 
diff --git a/Engine/source/T3D/vehicles/flyingVehicle.cpp b/Engine/source/T3D/vehicles/flyingVehicle.cpp
index e092668d8..64ec41fd6 100644
--- a/Engine/source/T3D/vehicles/flyingVehicle.cpp
+++ b/Engine/source/T3D/vehicles/flyingVehicle.cpp
@@ -116,7 +116,7 @@ FlyingVehicleData::FlyingVehicleData()
       jetEmitter[j] = 0;
 
    for (S32 i = 0; i < MaxSounds; i++)
-      sound[i] = 0;
+      INIT_SOUNDASSET_ARRAY(FlyingSounds, i);
 
    vertThrustMultiple = 1.0;
 }
@@ -131,8 +131,10 @@ bool FlyingVehicleData::preload(bool server, String &errorStr)
    // Resolve objects transmitted from server
    if (!server) {
       for (S32 i = 0; i < MaxSounds; i++)
-         if (sound[i])
-            Sim::findObject(SimObjectId((uintptr_t)sound[i]),sound[i]);
+         if (mFlyingSounds[i])
+         {
+            _setFlyingSounds(getFlyingSounds(i), i);
+         }
 
       for (S32 j = 0; j < MaxJetEmitters; j++)
          if (jetEmitter[j])
@@ -163,10 +165,8 @@ bool FlyingVehicleData::preload(bool server, String &errorStr)
 
 void FlyingVehicleData::initPersistFields()
 {
-   addField( "jetSound", TYPEID< SFXProfile >(), Offset(sound[JetSound], FlyingVehicleData),
-      "Looping sound to play while the vehicle is jetting." );
-   addField( "engineSound", TYPEID< SFXProfile >(), Offset(sound[EngineSound], FlyingVehicleData),
-      "Looping engine sound." );
+
+   INITPERSISTFIELD_SOUNDASSET_ARRAY(FlyingSounds, Sounds::MaxSounds, FlyingVehicleData, "Sounds for flying vehicle");
 
    addField( "maneuveringForce", TypeF32, Offset(maneuveringForce, FlyingVehicleData),
       "@brief Maximum X and Y (horizontal plane) maneuvering force.\n\n"
@@ -240,11 +240,7 @@ void FlyingVehicleData::packData(BitStream* stream)
 
    for (S32 i = 0; i < MaxSounds; i++)
    {
-      if (stream->writeFlag(sound[i]))
-      {
-         SimObjectId writtenId = mPacked ? SimObjectId((uintptr_t)sound[i]) : sound[i]->getId();
-         stream->writeRangedU32(writtenId, DataBlockObjectIdFirst, DataBlockObjectIdLast);
-      }
+      PACKDATA_SOUNDASSET_ARRAY(FlyingSounds, i);
    }
 
    for (S32 j = 0; j < MaxJetEmitters; j++)
@@ -277,11 +273,9 @@ void FlyingVehicleData::unpackData(BitStream* stream)
 {
    Parent::unpackData(stream);
 
-   for (S32 i = 0; i < MaxSounds; i++) {
-      sound[i] = NULL;
-      if (stream->readFlag())
-         sound[i] = (SFXProfile*)(uintptr_t)stream->readRangedU32(DataBlockObjectIdFirst,
-                                                         DataBlockObjectIdLast);
+   for (S32 i = 0; i < MaxSounds; i++)
+   {
+      UNPACKDATA_SOUNDASSET_ARRAY(FlyingSounds, i);
    }
 
    for (S32 j = 0; j < MaxJetEmitters; j++) {
@@ -374,11 +368,11 @@ bool FlyingVehicle::onNewDataBlock(GameBaseData* dptr, bool reload)
       SFX_DELETE( mJetSound );
       SFX_DELETE( mEngineSound );
 
-      if ( mDataBlock->sound[FlyingVehicleData::EngineSound] )
-         mEngineSound = SFX->createSource( mDataBlock->sound[FlyingVehicleData::EngineSound], &getTransform() );
+      if ( mDataBlock->getFlyingSounds(FlyingVehicleData::EngineSound) )
+         mEngineSound = SFX->createSource( mDataBlock->getFlyingSoundProfile(FlyingVehicleData::EngineSound), &getTransform() );
 
-      if ( mDataBlock->sound[FlyingVehicleData::JetSound] )
-         mJetSound = SFX->createSource( mDataBlock->sound[FlyingVehicleData::JetSound], &getTransform() );
+      if ( mDataBlock->getFlyingSounds(FlyingVehicleData::JetSound))
+         mJetSound = SFX->createSource( mDataBlock->getFlyingSoundProfile(FlyingVehicleData::JetSound), &getTransform() );
    }
 
    // Jet Sequences
diff --git a/Engine/source/T3D/vehicles/flyingVehicle.h b/Engine/source/T3D/vehicles/flyingVehicle.h
index 814b66250..18c3379e1 100644
--- a/Engine/source/T3D/vehicles/flyingVehicle.h
+++ b/Engine/source/T3D/vehicles/flyingVehicle.h
@@ -45,7 +45,15 @@ struct FlyingVehicleData: public VehicleData {
       EngineSound,
       MaxSounds,
    };
-   SFXProfile* sound[MaxSounds];
+   DECLARE_SOUNDASSET_ARRAY(FlyingVehicleData, FlyingSounds, Sounds::MaxSounds);
+   DECLARE_SOUNDASSET_ARRAY_SETGET(FlyingVehicleData, FlyingSounds);
+   SFXProfile* getFlyingSoundProfile(U32 id)
+   {
+      if (mFlyingSoundsAsset[id] != NULL)
+         return mFlyingSoundsAsset[id]->getSfxProfile();
+      else
+         return NULL;
+   }
 
    enum Jets {
       // These enums index into a static name list.

From e9d0f68b55a08e8036c1f858265ed3eb88891714 Mon Sep 17 00:00:00 2001
From: marauder2k7 <ctrl-intelligence@live.co.uk>
Date: Mon, 20 Sep 2021 17:05:11 +0100
Subject: [PATCH 089/399] Preload all soundAsset

-Fixed: Preloads need to preload all soundAssets not just the ones it was preloading before.
---
 Engine/source/T3D/fx/lightning.cpp           | 26 ++++++++++----------
 Engine/source/T3D/rigidShape.cpp             | 11 +++++++++
 Engine/source/T3D/vehicles/flyingVehicle.cpp |  3 ++-
 Engine/source/T3D/vehicles/hoverVehicle.cpp  |  1 +
 Engine/source/T3D/vehicles/vehicle.cpp       | 10 ++++++++
 5 files changed, 37 insertions(+), 14 deletions(-)

diff --git a/Engine/source/T3D/fx/lightning.cpp b/Engine/source/T3D/fx/lightning.cpp
index 73a63550e..7586602d4 100644
--- a/Engine/source/T3D/fx/lightning.cpp
+++ b/Engine/source/T3D/fx/lightning.cpp
@@ -289,18 +289,18 @@ bool LightningData::preload(bool server, String &errorStr)
 
    //dQsort(thunderSounds, MaxThunders, sizeof(SFXTrack*), cmpSounds);
 
-   for (S32 i = 0; i < MaxThunders; i++) {
-      if (mThunderSound[i])
-      {
-         _setThunderSound(getThunderSound(i), i);
-      }
-   }
-
+   
    if (server == false) 
    {
-      String sfxErrorStr;
-      for (U32 i = 0; i < MaxThunders; i++) {
-         if (!getThunderProfile(i))
+      for (S32 i = 0; i < MaxThunders; i++) {
+         if (mThunderSound[i])
+         {
+            _setThunderSound(getThunderSound(i), i);
+         }
+      }
+
+      for (U32 j = 0; j < MaxThunders; j++) {
+         if (!getThunderProfile(j))
             Con::errorf(ConsoleLogEntry::General, "LightningData::preload: Cant get an sfxProfile for thunder.");
       }
 
@@ -308,11 +308,11 @@ bool LightningData::preload(bool server, String &errorStr)
          Con::errorf(ConsoleLogEntry::General, "LightningData::preload: can't get sfxProfile from asset");
 
       mNumStrikeTextures = 0;
-      for (U32 i = 0; i < MaxTextures; i++) 
+      for (U32 k = 0; k < MaxTextures; k++) 
       {
-         if (strikeTextureNames[i][0])
+         if (strikeTextureNames[k][0])
          {
-            strikeTextures[i] = GFXTexHandle(strikeTextureNames[i], &GFXStaticTextureProfile, avar("%s() - strikeTextures[%d] (line %d)", __FUNCTION__, i, __LINE__));
+            strikeTextures[k] = GFXTexHandle(strikeTextureNames[i], &GFXStaticTextureProfile, avar("%s() - strikeTextures[%d] (line %d)", __FUNCTION__, k, __LINE__));
             mNumStrikeTextures++;
          }
       }
diff --git a/Engine/source/T3D/rigidShape.cpp b/Engine/source/T3D/rigidShape.cpp
index 73c8925cf..475854bbb 100644
--- a/Engine/source/T3D/rigidShape.cpp
+++ b/Engine/source/T3D/rigidShape.cpp
@@ -300,10 +300,21 @@ bool RigidShapeData::preload(bool server, String &errorStr)
    // Resolve objects transmitted from server
    if (!server) {
       for (S32 i = 0; i < Body::MaxSounds; i++)
+      {
          if (mBodySounds[i])
          {
             _setBodySounds(getBodySounds(i), i);
          }
+      }
+
+      for (S32 j = 0; j < Sounds::MaxSounds; j++)
+      {
+         if (mWaterSounds[j])
+         {
+            _setWaterSounds(getWaterSounds(j), j);
+         }
+      }
+
    }
 
    if( !dustEmitter && dustID != 0 )
diff --git a/Engine/source/T3D/vehicles/flyingVehicle.cpp b/Engine/source/T3D/vehicles/flyingVehicle.cpp
index 64ec41fd6..dcc1f8dd2 100644
--- a/Engine/source/T3D/vehicles/flyingVehicle.cpp
+++ b/Engine/source/T3D/vehicles/flyingVehicle.cpp
@@ -131,11 +131,12 @@ bool FlyingVehicleData::preload(bool server, String &errorStr)
    // Resolve objects transmitted from server
    if (!server) {
       for (S32 i = 0; i < MaxSounds; i++)
+      {
          if (mFlyingSounds[i])
          {
             _setFlyingSounds(getFlyingSounds(i), i);
          }
-
+      }
       for (S32 j = 0; j < MaxJetEmitters; j++)
          if (jetEmitter[j])
             Sim::findObject(SimObjectId((uintptr_t)jetEmitter[j]),jetEmitter[j]);
diff --git a/Engine/source/T3D/vehicles/hoverVehicle.cpp b/Engine/source/T3D/vehicles/hoverVehicle.cpp
index 404f54506..0cddc2c72 100644
--- a/Engine/source/T3D/vehicles/hoverVehicle.cpp
+++ b/Engine/source/T3D/vehicles/hoverVehicle.cpp
@@ -305,6 +305,7 @@ bool HoverVehicleData::preload(bool server, String &errorStr)
 
    // Resolve objects transmitted from server
    if (!server) {
+
       for (S32 i = 0; i < MaxSounds; i++)
          if (mHoverSounds[i])
          {
diff --git a/Engine/source/T3D/vehicles/vehicle.cpp b/Engine/source/T3D/vehicles/vehicle.cpp
index 3aaac0646..b773dd58f 100644
--- a/Engine/source/T3D/vehicles/vehicle.cpp
+++ b/Engine/source/T3D/vehicles/vehicle.cpp
@@ -218,10 +218,20 @@ bool VehicleData::preload(bool server, String &errorStr)
    // Resolve objects transmitted from server
    if (!server) {
       for (S32 i = 0; i < Body::MaxSounds; i++)
+      {
          if (mVehicleBodySounds[i])
          {
             _setVehicleBodySounds(getVehicleBodySounds(i), i);
          }
+      }
+
+      for (S32 j = 0; j < Sounds::MaxSounds; j++)
+      {
+         if (mVehicleWaterSounds[j])
+         {
+            _setVehicleWaterSounds(getVehicleWaterSounds(j), j);
+         }
+      }
    }
 
    if( !dustEmitter && dustID != 0 )

From 57aceb60fb0b83bc531b328e70a5ec9c730d9d1f Mon Sep 17 00:00:00 2001
From: marauder2k7 <ctrl-intelligence@live.co.uk>
Date: Mon, 20 Sep 2021 17:57:16 +0100
Subject: [PATCH 090/399] QOC

Code cleaning of unnecessary else'
Remove unnecessary dynamic_casts
---
 Engine/source/T3D/fx/explosion.cpp          | 2 +-
 Engine/source/T3D/fx/explosion.h            | 4 ++--
 Engine/source/T3D/fx/lightning.cpp          | 2 ++
 Engine/source/T3D/fx/lightning.h            | 8 ++++----
 Engine/source/T3D/fx/precipitation.h        | 4 ++--
 Engine/source/T3D/fx/splash.cpp             | 4 +++-
 Engine/source/T3D/fx/splash.h               | 4 ++--
 Engine/source/T3D/projectile.h              | 5 +++--
 Engine/source/T3D/rigidShape.h              | 8 ++++----
 Engine/source/T3D/vehicles/flyingVehicle.h  | 4 ++--
 Engine/source/T3D/vehicles/hoverVehicle.h   | 4 ++--
 Engine/source/T3D/vehicles/vehicle.h        | 8 ++++----
 Engine/source/T3D/vehicles/wheeledVehicle.h | 4 ++--
 13 files changed, 33 insertions(+), 28 deletions(-)

diff --git a/Engine/source/T3D/fx/explosion.cpp b/Engine/source/T3D/fx/explosion.cpp
index e842f73e4..6fc59b825 100644
--- a/Engine/source/T3D/fx/explosion.cpp
+++ b/Engine/source/T3D/fx/explosion.cpp
@@ -1382,7 +1382,7 @@ bool Explosion::explode()
       resetWorldBox();
    }
 
-   SFXProfile* sound_prof = dynamic_cast<SFXProfile*>(mDataBlock->getSFXProfile());
+   SFXProfile* sound_prof = mDataBlock->getSFXProfile();
    if (sound_prof)
    {
       soundProfile_clone = sound_prof->cloneAndPerformSubstitutions(ss_object, ss_index);
diff --git a/Engine/source/T3D/fx/explosion.h b/Engine/source/T3D/fx/explosion.h
index 20eadcd88..37694dd1e 100644
--- a/Engine/source/T3D/fx/explosion.h
+++ b/Engine/source/T3D/fx/explosion.h
@@ -76,8 +76,8 @@ class ExplosionData : public GameBaseData {
    SFXProfile* getSFXProfile() {
       if (mSoundAsset.notNull())
          return mSoundAsset->getSfxProfile();
-      else
-         return NULL;
+
+      return NULL;
    }
 
    ParticleEmitterData* particleEmitter;
diff --git a/Engine/source/T3D/fx/lightning.cpp b/Engine/source/T3D/fx/lightning.cpp
index 7586602d4..16e234818 100644
--- a/Engine/source/T3D/fx/lightning.cpp
+++ b/Engine/source/T3D/fx/lightning.cpp
@@ -241,7 +241,9 @@ LightningData::LightningData()
    INIT_SOUNDASSET(StrikeSound);
 
    for (S32 i = 0; i < MaxThunders; i++)
+   {
       INIT_SOUNDASSET_ARRAY(ThunderSound, MaxThunders);
+   }
 
    for (S32 i = 0; i < MaxTextures; i++)
    {
diff --git a/Engine/source/T3D/fx/lightning.h b/Engine/source/T3D/fx/lightning.h
index 7f706d9f8..f639db3b2 100644
--- a/Engine/source/T3D/fx/lightning.h
+++ b/Engine/source/T3D/fx/lightning.h
@@ -97,15 +97,15 @@ class LightningData : public GameBaseData
    {
       if (mThunderSoundAsset[id] != NULL)
          return mThunderSoundAsset[id]->getSfxProfile();
-      else
-         return NULL;
+
+      return NULL;
    }
 
    SFXProfile* getSFXProfile() {
       if (mStrikeSoundAsset.notNull())
          return mStrikeSoundAsset->getSfxProfile();
-      else
-         return NULL;
+
+      return NULL;
    }
 
 };
diff --git a/Engine/source/T3D/fx/precipitation.h b/Engine/source/T3D/fx/precipitation.h
index e8114b040..f9eb4bf02 100644
--- a/Engine/source/T3D/fx/precipitation.h
+++ b/Engine/source/T3D/fx/precipitation.h
@@ -75,8 +75,8 @@ class PrecipitationData : public GameBaseData
       SFXProfile* getSFXProfile() {
          if (mSoundAsset.notNull())
             return mSoundAsset->getSfxProfile();
-         else
-            return NULL;
+
+         return NULL;
       }
 };
 
diff --git a/Engine/source/T3D/fx/splash.cpp b/Engine/source/T3D/fx/splash.cpp
index 6af8a0c1a..c046ef1a0 100644
--- a/Engine/source/T3D/fx/splash.cpp
+++ b/Engine/source/T3D/fx/splash.cpp
@@ -97,7 +97,9 @@ SplashData::SplashData()
 
    U32 i;
    for (i = 0; i < NUM_TEX; i++)
+   {
       INIT_IMAGEASSET_ARRAY(Texture, i);
+   }
 
    for( i=0; i<NUM_TIME_KEYS; i++ )
       times[i] = 1.0;
@@ -679,7 +681,7 @@ void Splash::spawnExplosion()
 
    /// could just play the explosion one, but explosion could be weapon specific,
    /// splash sound could be liquid specific. food for thought.
-   SFXProfile* sound_prof = dynamic_cast<SFXProfile*>(mDataBlock->getSFXProfile());
+   SFXProfile* sound_prof = mDataBlock->getSFXProfile();
    if (sound_prof)
    {
       SFX->playOnce(sound_prof, &getTransform());
diff --git a/Engine/source/T3D/fx/splash.h b/Engine/source/T3D/fx/splash.h
index 40c6838fc..fec9f601e 100644
--- a/Engine/source/T3D/fx/splash.h
+++ b/Engine/source/T3D/fx/splash.h
@@ -102,8 +102,8 @@ public:
    SFXProfile* getSFXProfile() {
       if (mSoundAsset.notNull())
          return mSoundAsset->getSfxProfile();
-      else
-         return NULL;
+
+      return NULL;
    }
 
    ParticleEmitterData*    emitterList[NUM_EMITTERS];
diff --git a/Engine/source/T3D/projectile.h b/Engine/source/T3D/projectile.h
index f340d54a7..69bb84001 100644
--- a/Engine/source/T3D/projectile.h
+++ b/Engine/source/T3D/projectile.h
@@ -118,11 +118,12 @@ public:
 
    DECLARE_SOUNDASSET(ProjectileData, ProjectileSound);
    DECLARE_SOUNDASSET_SETGET(ProjectileData, ProjectileSound);
+
    SFXProfile* getSFXProfile() {
       if (mProjectileSoundAsset.notNull())
          return mProjectileSoundAsset->getSfxProfile();
-      else
-         return NULL;
+
+      return NULL;
    }
    
    LightDescription *lightDesc;
diff --git a/Engine/source/T3D/rigidShape.h b/Engine/source/T3D/rigidShape.h
index 5fc6ee786..49e8c1fd6 100644
--- a/Engine/source/T3D/rigidShape.h
+++ b/Engine/source/T3D/rigidShape.h
@@ -70,8 +70,8 @@ class RigidShapeData : public ShapeBaseData
    {
       if (mBodySoundsAsset[id] != NULL)
          return mBodySoundsAsset[id]->getSfxProfile();
-      else
-         return NULL;
+
+      return NULL;
    }
 
    enum RigidShapeConsts
@@ -98,8 +98,8 @@ class RigidShapeData : public ShapeBaseData
    {
       if (mWaterSoundsAsset[id] != NULL)
          return mWaterSoundsAsset[id]->getSfxProfile();
-      else
-         return NULL;
+
+      return NULL;
    }
 
    F32 exitSplashSoundVel;
diff --git a/Engine/source/T3D/vehicles/flyingVehicle.h b/Engine/source/T3D/vehicles/flyingVehicle.h
index 18c3379e1..573d10ccc 100644
--- a/Engine/source/T3D/vehicles/flyingVehicle.h
+++ b/Engine/source/T3D/vehicles/flyingVehicle.h
@@ -51,8 +51,8 @@ struct FlyingVehicleData: public VehicleData {
    {
       if (mFlyingSoundsAsset[id] != NULL)
          return mFlyingSoundsAsset[id]->getSfxProfile();
-      else
-         return NULL;
+
+      return NULL;
    }
 
    enum Jets {
diff --git a/Engine/source/T3D/vehicles/hoverVehicle.h b/Engine/source/T3D/vehicles/hoverVehicle.h
index 63ff65977..da22da280 100644
--- a/Engine/source/T3D/vehicles/hoverVehicle.h
+++ b/Engine/source/T3D/vehicles/hoverVehicle.h
@@ -52,8 +52,8 @@ class HoverVehicleData : public VehicleData
    {
       if (mHoverSoundsAsset[id] != NULL)
          return mHoverSoundsAsset[id]->getSfxProfile();
-      else
-         return NULL;
+
+      return NULL;
    }
 
    enum Jets {
diff --git a/Engine/source/T3D/vehicles/vehicle.h b/Engine/source/T3D/vehicles/vehicle.h
index 1c26f6cba..3e9636027 100644
--- a/Engine/source/T3D/vehicles/vehicle.h
+++ b/Engine/source/T3D/vehicles/vehicle.h
@@ -56,8 +56,8 @@ struct VehicleData : public RigidShapeData
    {
       if (mVehicleBodySoundsAsset[id] != NULL)
          return mVehicleBodySoundsAsset[id]->getSfxProfile();
-      else
-         return NULL;
+
+      return NULL;
    }
 
 
@@ -88,8 +88,8 @@ struct VehicleData : public RigidShapeData
   {
      if (mVehicleWaterSoundsAsset[id] != NULL)
         return mVehicleWaterSoundsAsset[id]->getSfxProfile();
-     else
-        return NULL;
+
+     return NULL;
   }
 
    F32 exitSplashSoundVel;
diff --git a/Engine/source/T3D/vehicles/wheeledVehicle.h b/Engine/source/T3D/vehicles/wheeledVehicle.h
index f5fe52fef..2f37b6c13 100644
--- a/Engine/source/T3D/vehicles/wheeledVehicle.h
+++ b/Engine/source/T3D/vehicles/wheeledVehicle.h
@@ -125,8 +125,8 @@ struct WheeledVehicleData: public VehicleData
    {
       if (mWheeledVehicleSoundsAsset[id] != NULL)
          return mWheeledVehicleSoundsAsset[id]->getSfxProfile();
-      else
-         return NULL;
+
+      return NULL;
    }
 
 

From c150afebaac2a72558dcf9997138151baf8561bf Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Mon, 20 Sep 2021 13:50:47 -0500
Subject: [PATCH 091/399] particle cleanups misc dupe code cleanup bits.
 safeties for the varous flavors of void ParticleEmitter::setup ideally we
 circle back to break some of that logic on out to shared steps

---
 Engine/source/T3D/fx/particleEmitter.cpp | 21 +++++++++------------
 1 file changed, 9 insertions(+), 12 deletions(-)

diff --git a/Engine/source/T3D/fx/particleEmitter.cpp b/Engine/source/T3D/fx/particleEmitter.cpp
index 5f7b0829d..45acd1ecb 100644
--- a/Engine/source/T3D/fx/particleEmitter.cpp
+++ b/Engine/source/T3D/fx/particleEmitter.cpp
@@ -1551,13 +1551,10 @@ void ParticleEmitter::updateBBox()
 
    for (Particle* part = part_list_head.next; part != NULL; part = part->next)
    {
-      for (Particle* part = part_list_head.next; part != NULL; part = part->next)
-      {
-         Point3F particleSize(part->size * 0.5f);
-         F32 motion = getMax((part->vel.len() * part->totalLifetime / 1000.0f), 1.0f);
-         minPt.setMin(part->pos - particleSize - Point3F(motion));
-         maxPt.setMax(part->pos + particleSize + Point3F(motion));
-      }
+      Point3F particleSize(part->size * 0.5f);
+      F32 motion = getMax((part->vel.len() * part->totalLifetime / 1000.0f), 1.0f);
+      minPt.setMin(part->pos - particleSize - Point3F(motion));
+      maxPt.setMax(part->pos + particleSize + Point3F(motion));
    }
    
    mObjBox = Box3F(minPt, maxPt);
@@ -1675,8 +1672,8 @@ void ParticleEmitter::addParticle(const Point3F& pos, const Point3F& axis, const
    }
    else
    {
-      U32 dBlockIndex = gRandGen.randI() % mDataBlock->particleDataBlocks.size();
-   mDataBlock->particleDataBlocks[dBlockIndex]->initializeParticle(pNew, vel);
+      dBlockIndex = gRandGen.randI() % mDataBlock->particleDataBlocks.size();
+      mDataBlock->particleDataBlocks[dBlockIndex]->initializeParticle(pNew, vel);
    }
    updateKeyData( pNew );
 
@@ -2220,7 +2217,7 @@ void ParticleEmitter::setupOriented( Particle *part,
    LinearColorF partCol = mLerp( part->color, ( part->color * ambientColor ), ambientLerp );
    const ColorI color = partCol.toColorI();
    // Here we deal with UVs for animated particle (oriented)
-   if (part->dataBlock->animateTexture)
+   if (part->dataBlock->animateTexture && !part->dataBlock->animTexFrames.empty())
    { 
       // Let particle compute the UV indices for current frame
       S32 fm = (S32)(part->currentAge*(1.0f/1000.0f)*part->dataBlock->framesPerSec);
@@ -2331,7 +2328,7 @@ void ParticleEmitter::setupAligned( const Particle *part,
    LinearColorF partCol = mLerp( part->color, ( part->color * ambientColor ), ambientLerp );
    const ColorI color = partCol.toColorI();
    // Here we deal with UVs for animated particle
-   if (part->dataBlock->animateTexture)
+   if (part->dataBlock->animateTexture && !part->dataBlock->animTexFrames.empty())
    { 
       // Let particle compute the UV indices for current frame
       S32 fm = (S32)(part->currentAge*(1.0f/1000.0f)*part->dataBlock->framesPerSec);
@@ -2520,7 +2517,7 @@ void ParticleEmitter::setupRibbon(Particle *part,
    ColorI pCol = partCol.toColorI();
 
    // Here we deal with UVs for animated particle (oriented)
-   if (part->dataBlock->animateTexture)
+   if (part->dataBlock->animateTexture && !part->dataBlock->animTexFrames.empty())
    {
       // Let particle compute the UV indices for current frame
       S32 fm = (S32)(part->currentAge*(1.0f / 1000.0f)*part->dataBlock->framesPerSec);

From 8ce207561e487bd3495dbe4ed3b8cd9bbcc9c51f Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Mon, 20 Sep 2021 16:56:53 -0500
Subject: [PATCH 092/399] revert a bit causing crashes on certain 'nix boxes.

---
 Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp | 4 ++--
 Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp b/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
index 3ee76ffdf..0cf46277c 100644
--- a/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
+++ b/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
@@ -455,12 +455,12 @@ Var* ShaderFeatureGLSL::addOutVpos( MultiLine *meta,
       outVpos = connectComp->getElement( RT_TEXCOORD );
       outVpos->setName( "outVpos" );
       outVpos->setStructName( "OUT" );
-      outVpos->setType( "vec3" );
+      outVpos->setType( "vec4" );
 
       Var *outPosition = (Var*) LangElement::find( "gl_Position" );
       AssertFatal( outPosition, "ShaderFeatureGLSL::addOutVpos - Didn't find the output position." );
 
-      meta->addStatement( new GenOp( "   @ = @.xyz;\r\n", outVpos, outPosition ) );
+      meta->addStatement( new GenOp( "   @ = @;\r\n", outVpos, outPosition ) );
    }
 
    return outVpos;
diff --git a/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp b/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
index 2fe171aba..1ebc3982a 100644
--- a/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
+++ b/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
@@ -453,12 +453,12 @@ Var* ShaderFeatureHLSL::addOutVpos( MultiLine *meta,
       outVpos = connectComp->getElement( RT_TEXCOORD );
       outVpos->setName( "outVpos" );
       outVpos->setStructName( "OUT" );
-      outVpos->setType( "float3" );
+      outVpos->setType( "float4" );
 
       Var *outPosition = (Var*) LangElement::find( "hpos" );
       AssertFatal( outPosition, "ShaderFeatureHLSL::addOutVpos - Didn't find the output position." );
 
-      meta->addStatement( new GenOp( "   @ = @.xyz;\r\n", outVpos, outPosition ) );
+      meta->addStatement( new GenOp( "   @ = @;\r\n", outVpos, outPosition ) );
    }
 
    return outVpos;

From 2d50f52cf135fd8e6ebed638767dd60fd34d01c0 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Mon, 20 Sep 2021 21:00:33 -0400
Subject: [PATCH 093/399] Allow local variables to be used in eval.

---
 Engine/source/console/astNodes.cpp     | 55 ++------------------------
 Engine/source/console/codeBlock.cpp    | 15 ++++++-
 Engine/source/console/compiledEval.cpp |  3 +-
 Engine/source/console/compiler.cpp     | 42 ++++++++++++++++++++
 Engine/source/console/compiler.h       | 29 ++++++++++++++
 5 files changed, 90 insertions(+), 54 deletions(-)

diff --git a/Engine/source/console/astNodes.cpp b/Engine/source/console/astNodes.cpp
index 091f6cf1c..aaca1ea06 100644
--- a/Engine/source/console/astNodes.cpp
+++ b/Engine/source/console/astNodes.cpp
@@ -56,57 +56,7 @@ namespace Compiler
 
 using namespace Compiler;
 
-class FuncVars
-{
-   struct Var
-   {
-      S32 reg;
-      TypeReq currentType;
-      StringTableEntry name;
-      bool isConstant;
-   };
-
-public:
-   S32 assign(StringTableEntry var, TypeReq currentType, S32 lineNumber, bool isConstant = false)
-   {
-      std::unordered_map<StringTableEntry, Var>::iterator found = vars.find(var);
-      if (found != vars.end())
-      {
-         AssertISV(!found->second.isConstant, avar("Reassigning variable %s when it is a constant. File: %s Line : %d", var, CodeBlock::smCurrentParser->getCurrentFile(), lineNumber));
-         return found->second.reg;
-      }
-
-      S32 id = counter++;
-      vars[var] = { id, currentType, var, isConstant };
-      variableNameMap[id] = var;
-
-      return id;
-   }
-
-   S32 lookup(StringTableEntry var, S32 lineNumber)
-   {
-      std::unordered_map<StringTableEntry, Var>::iterator found = vars.find(var);
-      AssertISV(found != vars.end(), avar("Variable %s referenced before used when compiling script. File: %s Line: %d", var, CodeBlock::smCurrentParser->getCurrentFile(), lineNumber));
-      return found->second.reg;
-   }
-
-   TypeReq lookupType(StringTableEntry var, S32 lineNumber)
-   {
-      std::unordered_map<StringTableEntry, Var>::iterator found = vars.find(var);
-
-      AssertISV(found != vars.end(), avar("Variable %s referenced before used when compiling script. File: %s Line: %d", var, CodeBlock::smCurrentParser->getCurrentFile(), lineNumber));
-      return found->second.currentType;
-   }
-
-   inline S32 count() { return counter; }
-
-   std::unordered_map<S32, StringTableEntry> variableNameMap;
-
-private:
-   std::unordered_map<StringTableEntry, Var> vars;
-   S32 counter = 0;
-};
-
+FuncVars gEvalFuncVars;
 FuncVars* gFuncVars = NULL;
 
 inline FuncVars* getFuncVars(S32 lineNumber)
@@ -1602,7 +1552,8 @@ U32 FunctionDeclStmtNode::compileStmt(CodeStream& codeStream, U32 ip)
       tbl->add(fnName, nameSpace, varName);
    }
 
-   gFuncVars = NULL;
+   // In eval mode, global func vars are allowed.
+   gFuncVars = gIsEvalCompile ? &gEvalFuncVars : NULL;
 
    return ip;
 }
diff --git a/Engine/source/console/codeBlock.cpp b/Engine/source/console/codeBlock.cpp
index 1d1ad7593..f03ec25f6 100644
--- a/Engine/source/console/codeBlock.cpp
+++ b/Engine/source/console/codeBlock.cpp
@@ -37,6 +37,9 @@ CodeBlock *    CodeBlock::smCodeBlockList = NULL;
 CodeBlock *    CodeBlock::smCurrentCodeBlock = NULL;
 ConsoleParser *CodeBlock::smCurrentParser = NULL;
 
+extern FuncVars gEvalFuncVars;
+extern FuncVars* gFuncVars;
+
 //-------------------------------------------------------------------------
 
 CodeBlock::CodeBlock()
@@ -491,6 +494,8 @@ bool CodeBlock::compile(const char *codeFileName, StringTableEntry fileName, con
    chompUTF8BOM(inScript, &script);
 
    gSyntaxError = false;
+   gIsEvalCompile = false;
+   gFuncVars = NULL;
 
    consoleAllocReset();
 
@@ -629,6 +634,11 @@ ConsoleValue CodeBlock::compileExec(StringTableEntry fileName, const char *inStr
       addToCodeList();
 
    gStatementList = NULL;
+   
+   // we are an eval compile if we don't have a file name associated (no exec)
+   gIsEvalCompile = fileName == NULL;
+   // In eval mode, global func vars are allowed.
+   gFuncVars = gIsEvalCompile ? &gEvalFuncVars : NULL;
 
    // Set up the parser.
    smCurrentParser = getParserForFile(fileName);
@@ -667,6 +677,8 @@ ConsoleValue CodeBlock::compileExec(StringTableEntry fileName, const char *inStr
 
    codeStream.emit(OP_RETURN_VOID);
    codeStream.emitCodeStream(&codeSize, &code, &lineBreakPairs);
+   
+   S32 localRegisterCount = gIsEvalCompile ? gEvalFuncVars.count() : 0;
 
    consoleAllocReset();
 
@@ -683,7 +695,8 @@ ConsoleValue CodeBlock::compileExec(StringTableEntry fileName, const char *inStr
    if (lastIp + 1 != codeSize)
       Con::warnf(ConsoleLogEntry::General, "precompile size mismatch, precompile: %d compile: %d", codeSize, lastIp);
 
-   return std::move(exec(0, fileName, NULL, 0, 0, noCalls, NULL, setFrame));
+   // repurpose argc as local register counter for global state
+   return std::move(exec(0, fileName, NULL, localRegisterCount, 0, noCalls, NULL, setFrame));
 }
 
 //-------------------------------------------------------------------------
diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index 561e1f04a..360c13c90 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -693,7 +693,8 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
       // Do we want this code to execute using a new stack frame?
       if (setFrame < 0)
       {
-         gEvalState.pushFrame(NULL, NULL, 0);
+         // argc is the local count for eval
+         gEvalState.pushFrame(NULL, NULL, argc);
          gCallStack.pushFrame(0);
          popFrame = true;
       }
diff --git a/Engine/source/console/compiler.cpp b/Engine/source/console/compiler.cpp
index 1ab6e7b22..13839feda 100644
--- a/Engine/source/console/compiler.cpp
+++ b/Engine/source/console/compiler.cpp
@@ -34,6 +34,8 @@
 
 #include "console/simBase.h"
 
+extern FuncVars gEvalFuncVars;
+
 namespace Compiler
 {
 
@@ -86,6 +88,7 @@ namespace Compiler
    //------------------------------------------------------------
 
    bool gSyntaxError = false;
+   bool gIsEvalCompile = false;
 
    //------------------------------------------------------------
 
@@ -121,6 +124,7 @@ namespace Compiler
       getFunctionStringTable().reset();
       getIdentTable().reset();
       getFunctionVariableMappingTable().reset();
+      gEvalFuncVars.clear();
    }
 
    void *consoleAlloc(U32 size) { return gConsoleAllocator.alloc(size); }
@@ -132,6 +136,44 @@ namespace Compiler
 
 using namespace Compiler;
 
+S32 FuncVars::assign(StringTableEntry var, TypeReq currentType, S32 lineNumber, bool isConstant)
+{
+   std::unordered_map<StringTableEntry, Var>::iterator found = vars.find(var);
+   if (found != vars.end())
+   {
+      AssertISV(!found->second.isConstant, avar("Reassigning variable %s when it is a constant. File: %s Line : %d", var, CodeBlock::smCurrentParser->getCurrentFile(), lineNumber));
+      return found->second.reg;
+   }
+
+   S32 id = counter++;
+   vars[var] = { id, currentType, var, isConstant };
+   variableNameMap[id] = var;
+
+   return id;
+}
+
+S32 FuncVars::lookup(StringTableEntry var, S32 lineNumber)
+{
+   std::unordered_map<StringTableEntry, Var>::iterator found = vars.find(var);
+   AssertISV(found != vars.end(), avar("Variable %s referenced before used when compiling script. File: %s Line: %d", var, CodeBlock::smCurrentParser->getCurrentFile(), lineNumber));
+   return found->second.reg;
+}
+
+TypeReq FuncVars::lookupType(StringTableEntry var, S32 lineNumber)
+{
+   std::unordered_map<StringTableEntry, Var>::iterator found = vars.find(var);
+
+   AssertISV(found != vars.end(), avar("Variable %s referenced before used when compiling script. File: %s Line: %d", var, CodeBlock::smCurrentParser->getCurrentFile(), lineNumber));
+   return found->second.currentType;
+}
+
+void FuncVars::clear()
+{
+   vars.clear();
+   variableNameMap.clear();
+   counter = 0;
+}
+
 //-------------------------------------------------------------------------
 
 
diff --git a/Engine/source/console/compiler.h b/Engine/source/console/compiler.h
index 117576a61..24067257f 100644
--- a/Engine/source/console/compiler.h
+++ b/Engine/source/console/compiler.h
@@ -276,6 +276,35 @@ namespace Compiler
    void consoleAllocReset();
 
    extern bool gSyntaxError;
+   extern bool gIsEvalCompile;
+};
+
+class FuncVars
+{
+   struct Var
+   {
+      S32 reg;
+      TypeReq currentType;
+      StringTableEntry name;
+      bool isConstant;
+   };
+
+public:
+   S32 assign(StringTableEntry var, TypeReq currentType, S32 lineNumber, bool isConstant = false);
+
+   S32 lookup(StringTableEntry var, S32 lineNumber);
+
+   TypeReq lookupType(StringTableEntry var, S32 lineNumber);
+   
+   inline S32 count() { return counter; }
+
+   std::unordered_map<S32, StringTableEntry> variableNameMap;
+
+   void clear();
+   
+private:
+   std::unordered_map<StringTableEntry, Var> vars;
+   S32 counter = 0;
 };
 
 /// Utility class to emit and patch bytecode

From 9775d69988fc1ca269e13ef9d6e8b1caae8f8a58 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Tue, 21 Sep 2021 17:10:07 -0500
Subject: [PATCH 094/399] pad shader uniform length pipe by 1 to avoid a bug
 with some integrated chips clipping

---
 Engine/source/gfx/gl/gfxGLShader.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Engine/source/gfx/gl/gfxGLShader.cpp b/Engine/source/gfx/gl/gfxGLShader.cpp
index d2f2edd22..eed45b3e1 100644
--- a/Engine/source/gfx/gl/gfxGLShader.cpp
+++ b/Engine/source/gfx/gl/gfxGLShader.cpp
@@ -561,6 +561,7 @@ void GFXGLShader::initConstantDescs()
 
    if(!maxNameLength)
       return;
+   maxNameLength++;
 
    FrameTemp<GLchar> uniformName(maxNameLength);
    

From 901228c3a8f2208227e077472fdc73053672e434 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Tue, 21 Sep 2021 23:19:00 -0500
Subject: [PATCH 095/399] kill splashscreen on nonwindows was worth a shot, but
 it's playing up way too much to focus on at present

---
 Templates/BaseGame/game/main.tscript.in | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/Templates/BaseGame/game/main.tscript.in b/Templates/BaseGame/game/main.tscript.in
index 4e83ff2b2..800e9625a 100644
--- a/Templates/BaseGame/game/main.tscript.in
+++ b/Templates/BaseGame/game/main.tscript.in
@@ -19,9 +19,14 @@ ModuleDatabase.LoadExplicit( "CoreModule" );
 // Display a splash window immediately to improve app responsiveness before
 // engine is initialized and main window created.
 if ($Server::Dedicated == false)
-    displaySplashWindow($Core::splashWindowImage);
+{
+    if ($platform $= "windows")
+       displaySplashWindow($Core::splashWindowImage);
+}
 else
+{
     $Video::forceDisplayAdapter = -1;
+}
     
 //-----------------------------------------------------------------------------
 // Load any gameplay modules
@@ -45,7 +50,7 @@ else
    }
 }
 
-if ($Server::Dedicated == false)
+if ( ($Server::Dedicated == false) && ($platform $= "windows") )
     closeSplashWindow();
 
 echo("Engine initialized...");
\ No newline at end of file

From c86cc489458cc4c1d32fbf40d08d996a6b91351c Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Wed, 22 Sep 2021 18:27:42 -0500
Subject: [PATCH 096/399] use srgb sapce for backbuffer

---
 Engine/source/postFx/postEffectManager.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Engine/source/postFx/postEffectManager.cpp b/Engine/source/postFx/postEffectManager.cpp
index 7904c522d..d65e25e25 100644
--- a/Engine/source/postFx/postEffectManager.cpp
+++ b/Engine/source/postFx/postEffectManager.cpp
@@ -141,7 +141,7 @@ GFXTextureObject* PostEffectManager::getBackBufferTex()
 
       mBackBufferCopyTex.set( targetSize.x, targetSize.y, 
                               targetFormat, 
-                              &PostFxTargetProfile, "mBackBufferCopyTex" );
+                              &PostFxTextureSRGBProfile, "mBackBufferCopyTex" );
 
       target->resolveTo( mBackBufferCopyTex );
       mLastBackBufferTarget = target;

From 5682bafb291fe7a5a865d256153d6229e74f4d4a Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Wed, 22 Sep 2021 18:28:19 -0500
Subject: [PATCH 097/399] kills off that second buffer in terrain rendering
 when in forward mode

---
 .../source/terrain/glsl/terrFeatureGLSL.cpp   | 132 ++++++++--------
 Engine/source/terrain/glsl/terrFeatureGLSL.h  |   1 -
 .../source/terrain/hlsl/terrFeatureHLSL.cpp   | 141 +++++++++---------
 Engine/source/terrain/hlsl/terrFeatureHLSL.h  |   2 -
 4 files changed, 142 insertions(+), 134 deletions(-)

diff --git a/Engine/source/terrain/glsl/terrFeatureGLSL.cpp b/Engine/source/terrain/glsl/terrFeatureGLSL.cpp
index 14f321cce..d30e639ec 100644
--- a/Engine/source/terrain/glsl/terrFeatureGLSL.cpp
+++ b/Engine/source/terrain/glsl/terrFeatureGLSL.cpp
@@ -304,29 +304,28 @@ void TerrainBaseMapFeatGLSL::processPix(  Vector<ShaderComponent*> &componentLis
    baseColor->setName( "baseColor" );
    meta->addStatement( new GenOp( "   @ = tex2D( @, @.xy );\r\n", new DecOp( baseColor ), diffuseMap, texCoord ) );
 
-  ShaderFeature::OutputTarget target = ShaderFeature::DefaultTarget;
+   ShaderFeature::OutputTarget target = (fd.features[MFT_isDeferred]) ? RenderTarget1 : DefaultTarget;
+   meta->addStatement(new GenOp("   @;\r\n", assignColor(baseColor, Material::Mul, NULL, target)));
 
-   if(fd.features.hasFeature(MFT_isDeferred))
-   {
-      target= ShaderFeature::RenderTarget1;
-   }
-   meta->addStatement( new GenOp( "   @;\r\n", assignColor( baseColor, Material::Mul,NULL,target ) ) );
-
-   // Set base ORM info
    Var* ormConfig;
-   OutputTarget targ = RenderTarget1;
-   if (fd.features[MFT_isDeferred])
+   if ((fd.features[MFT_isDeferred]))
    {
-      targ = RenderTarget2;
+      // Set base ORM info
+      ormConfig = (Var*)LangElement::find(getOutputTargetVarName(RenderTarget2));
+
+      if (!ormConfig)
+      {
+         // create color var
+         ormConfig = new Var;
+         ormConfig->setType("fragout");
+         ormConfig->setName(getOutputTargetVarName(RenderTarget2));
+         ormConfig->setStructName("OUT");
+      }
    }
-   ormConfig = (Var*)LangElement::find(getOutputTargetVarName(targ));
-   if (!ormConfig)
+   else
    {
-      // create color var
-      ormConfig = new Var;
-      ormConfig->setType("fragout");
-      ormConfig->setName(getOutputTargetVarName(targ));
-      ormConfig->setStructName("OUT");
+      ormConfig = new Var("ORMConfig", "float4");
+      meta->addStatement(new GenOp("   @;\r\n", new DecOp(ormConfig)));
    }
 
    meta->addStatement(new GenOp("   @ = float4(0.0, 1.0, 1.0, 0.0);\r\n", ormConfig));
@@ -347,7 +346,7 @@ ShaderFeature::Resources TerrainBaseMapFeatGLSL::getResources( const MaterialFea
 
 U32 TerrainBaseMapFeatGLSL::getOutputTargets( const MaterialFeatureData &fd ) const
 {
-   return fd.features[MFT_isDeferred] ? ShaderFeature::RenderTarget1 | ShaderFeature::RenderTarget2 : ShaderFeature::DefaultTarget | ShaderFeature::RenderTarget1;
+   return fd.features[MFT_isDeferred] ? ShaderFeature::RenderTarget2 | ShaderFeature::RenderTarget1 : ShaderFeature::DefaultTarget;
 }
 
 TerrainDetailMapFeatGLSL::TerrainDetailMapFeatGLSL()
@@ -1167,24 +1166,36 @@ void TerrainORMMapFeatGLSL::processPix(Vector<ShaderComponent*> &componentList,
 	else
 		texOp = new GenOp("tex2D(@, vec3(@.xy, @.x))", ormConfigMap, inDet, new IndexOp(detailInfo, compositeIndex));
 
-	// search for material var
-	Var * ormConfig;
-	OutputTarget targ = RenderTarget1;
-	if (fd.features[MFT_isDeferred])
-	{
-		targ = RenderTarget2;
-	}
-   ormConfig = (Var*)LangElement::find(getOutputTargetVarName(targ));
+   MultiLine* meta = new MultiLine;
+   // search for material var
+   Var* ormConfig;
+   if ((fd.features[MFT_isDeferred]))
+   {
+      // Set base ORM info
+      ormConfig = (Var*)LangElement::find(getOutputTargetVarName(RenderTarget2));
 
-	MultiLine * meta = new MultiLine;
-	if (!ormConfig)
-	{
-		// create color var
-      ormConfig = new Var;
-      ormConfig->setType("fragout");
-      ormConfig->setName(getOutputTargetVarName(targ));
-      ormConfig->setStructName("OUT");
-	}
+      if (!ormConfig)
+      {
+         // create color var
+         ormConfig = new Var;
+         ormConfig->setType("fragout");
+         ormConfig->setName(getOutputTargetVarName(RenderTarget2));
+         ormConfig->setStructName("OUT");
+      }
+   }
+   else
+   {
+      ormConfig = (Var*)LangElement::find("ORMConfig");
+      if (!ormConfig)
+      {
+         ormConfig = new Var("ORMConfig", "vec4");
+         meta->addStatement(new GenOp("   @;\r\n", new DecOp(ormConfig)));
+      }
+   }
+   if (compositeIndex == 0)
+   {
+      meta->addStatement(new GenOp("   @ = vec4(0.0, 0.0, 0.0, 0.0);\r\n", ormConfig));
+   }
 
 	Var *detailBlend = (Var*)LangElement::find(String::ToString("detailBlend%d", compositeIndex));
 	AssertFatal(detailBlend, "The detail blend is missing!");
@@ -1192,11 +1203,6 @@ void TerrainORMMapFeatGLSL::processPix(Vector<ShaderComponent*> &componentList,
 	String matinfoName(String::ToString("matinfoCol%d", compositeIndex));
 	Var *matinfoCol = new Var(matinfoName, "vec3");
 
-   if (compositeIndex == 0)
-   {
-      meta->addStatement(new GenOp("   @ = vec4(0.0, 0.0, 0.0, 0.0);\r\n", ormConfig));
-   }
-
    meta->addStatement(new GenOp("   @ = @.rgb;\r\n", new DecOp(matinfoCol), texOp));
 
    if (fd.features.hasFeature(MFT_InvertRoughness, compositeIndex))
@@ -1236,40 +1242,40 @@ ShaderFeature::Resources TerrainORMMapFeatGLSL::getResources(const MaterialFeatu
    return res;
 }
 
-
-U32 TerrainBlankInfoMapFeatGLSL::getOutputTargets(const MaterialFeatureData &fd) const
-{
-   return fd.features[MFT_isDeferred] ? ShaderFeature::RenderTarget2 : ShaderFeature::RenderTarget1;
-}
-
 // reminder, the matinfo buffer is flags, smooth, ao, metal
 void TerrainBlankInfoMapFeatGLSL::processPix(Vector<ShaderComponent*> &componentList,
    const MaterialFeatureData &fd)
 {
    S32 compositeIndex = getProcessIndex();
 
-   // search for material var
-   Var *material;
-   OutputTarget targ = DefaultTarget;
-   if (fd.features[MFT_isDeferred])
+   MultiLine* meta = new MultiLine;   Var* ormConfig;
+   if ((fd.features[MFT_isDeferred]))
    {
-      targ = RenderTarget2;
-   }
-   material = (Var*)LangElement::find(getOutputTargetVarName(targ));
+      // Set base ORM info
+      ormConfig = (Var*)LangElement::find(getOutputTargetVarName(RenderTarget2));
 
-   MultiLine * meta = new MultiLine;
-   if (!material)
+      if (!ormConfig)
+      {
+         // create color var
+         ormConfig = new Var;
+         ormConfig->setType("fragout");
+         ormConfig->setName(getOutputTargetVarName(RenderTarget2));
+         ormConfig->setStructName("OUT");
+      }
+   }
+   else
    {
-      // create color var
-      material = new Var;
-      material->setType("vec4");
-      material->setName(getOutputTargetVarName(targ));
-      material->setStructName("OUT");
+      ormConfig = (Var*)LangElement::find("ORMConfig");
+      if (!ormConfig)
+      {
+         ormConfig = new Var("ORMConfig", "vec4");
+         meta->addStatement(new GenOp("   @;\r\n", new DecOp(ormConfig)));
+      }
    }
 
    if (compositeIndex == 0)
    {
-      meta->addStatement(new GenOp("   @ = vec4(0.0, 0.0, 0.0, 0.0);\r\n", material));
+      meta->addStatement(new GenOp("   @ = float4(0.0, 0.0, 0.0, 0.0);\r\n", ormConfig));
    }
 
    Var* detailBlend = (Var*)LangElement::find(String::ToString("detailBlend%d", compositeIndex));
@@ -1277,7 +1283,7 @@ void TerrainBlankInfoMapFeatGLSL::processPix(Vector<ShaderComponent*> &component
 
    String matinfoName(String::ToString("matinfoCol%d", compositeIndex));
 
-   meta->addStatement(new GenOp("   @.gba += vec3(@, @, 0.0);\r\n", material, detailBlend, detailBlend));
+   meta->addStatement(new GenOp("   @.gba += vec3(@, @, 0.0);\r\n", ormConfig, detailBlend, detailBlend));
 
    output = meta;
 }
diff --git a/Engine/source/terrain/glsl/terrFeatureGLSL.h b/Engine/source/terrain/glsl/terrFeatureGLSL.h
index 5b48c0a51..7d56a75bf 100644
--- a/Engine/source/terrain/glsl/terrFeatureGLSL.h
+++ b/Engine/source/terrain/glsl/terrFeatureGLSL.h
@@ -174,7 +174,6 @@ public:
    virtual void processPix(Vector<ShaderComponent*> &componentList,
       const MaterialFeatureData &fd);
 
-   virtual U32 getOutputTargets(const MaterialFeatureData &fd) const;
    virtual String getName() { return "Blank Matinfo map"; }
 };
 
diff --git a/Engine/source/terrain/hlsl/terrFeatureHLSL.cpp b/Engine/source/terrain/hlsl/terrFeatureHLSL.cpp
index e136c82eb..362a012a3 100644
--- a/Engine/source/terrain/hlsl/terrFeatureHLSL.cpp
+++ b/Engine/source/terrain/hlsl/terrFeatureHLSL.cpp
@@ -337,27 +337,27 @@ void TerrainBaseMapFeatHLSL::processVert( Vector<ShaderComponent*> &componentLis
       new DecOp( inTanget ), squareSize, inTangentZ ) );
 }
 
-void TerrainBaseMapFeatHLSL::processPix(  Vector<ShaderComponent*> &componentList, 
-                                          const MaterialFeatureData &fd )
+void TerrainBaseMapFeatHLSL::processPix(Vector<ShaderComponent*>& componentList,
+   const MaterialFeatureData& fd)
 {
    // grab connector texcoord register
-   Var *texCoord = getInTexCoord( "texCoord", "float3", componentList );
+   Var* texCoord = getInTexCoord("texCoord", "float3", componentList);
 
    // create texture var
-   Var *diffuseMap = new Var;
-   diffuseMap->setType( "SamplerState" );
-   diffuseMap->setName( "baseTexMap" );
+   Var* diffuseMap = new Var;
+   diffuseMap->setType("SamplerState");
+   diffuseMap->setName("baseTexMap");
    diffuseMap->uniform = true;
    diffuseMap->sampler = true;
    diffuseMap->constNum = Var::getTexUnitNum();     // used as texture unit num here
 
-   MultiLine *meta = new MultiLine;
+   MultiLine* meta = new MultiLine;
 
-   Var *baseColor = new Var;
-   baseColor->setType( "float4" );
-   baseColor->setName( "baseColor" );
+   Var* baseColor = new Var;
+   baseColor->setType("float4");
+   baseColor->setName("baseColor");
 
-   Var *diffuseTex = new Var;
+   Var* diffuseTex = new Var;
    diffuseTex->setType("Texture2D");
    diffuseTex->setName("baseTexture");
    diffuseTex->uniform = true;
@@ -365,33 +365,31 @@ void TerrainBaseMapFeatHLSL::processPix(  Vector<ShaderComponent*> &componentLis
    diffuseTex->constNum = diffuseMap->constNum;
    meta->addStatement(new GenOp("   @ = @.Sample( @, @.xy );\r\n", new DecOp(baseColor), diffuseTex, diffuseMap, texCoord));
 
-   ShaderFeature::OutputTarget target = ShaderFeature::DefaultTarget;
+   ShaderFeature::OutputTarget target = (fd.features[MFT_isDeferred]) ? RenderTarget1 : DefaultTarget;
+   meta->addStatement(new GenOp("   @;\r\n", assignColor(baseColor, Material::Mul, NULL, target)));
 
-   if (fd.features.hasFeature(MFT_isDeferred))
-   {
-      target= ShaderFeature::RenderTarget1;
-   }
-
-   meta->addStatement( new GenOp( "   @;\r\n", assignColor( baseColor, Material::Mul,NULL,target ) ) );
-
-   if (fd.features[MFT_isDeferred])
+   Var* ormConfig;
+   if ((fd.features[MFT_isDeferred]))
    {
       // Set base ORM info
-      Var* ormConfig;
-      OutputTarget targ = RenderTarget1;
-      targ = RenderTarget2;
-      ormConfig = (Var*)LangElement::find(getOutputTargetVarName(targ));
+      ormConfig = (Var*)LangElement::find(getOutputTargetVarName(RenderTarget2));
+
       if (!ormConfig)
       {
          // create color var
          ormConfig = new Var;
          ormConfig->setType("fragout");
-         ormConfig->setName(getOutputTargetVarName(targ));
+         ormConfig->setName(getOutputTargetVarName(RenderTarget2));
          ormConfig->setStructName("OUT");
       }
-
-      meta->addStatement(new GenOp("   @ = float4(0.0, 1.0, 1.0, 0.0);\r\n", ormConfig));
    }
+   else
+   {
+      ormConfig = new Var("ORMConfig", "float4");
+      meta->addStatement(new GenOp("   @;\r\n", new DecOp(ormConfig)));
+   }
+
+   meta->addStatement(new GenOp("   @ = float4(0.0, 1.0, 1.0, 0.0);\r\n", ormConfig));
 
    output = meta;
 }
@@ -407,7 +405,7 @@ ShaderFeature::Resources TerrainBaseMapFeatHLSL::getResources( const MaterialFea
 
 U32 TerrainBaseMapFeatHLSL::getOutputTargets( const MaterialFeatureData &fd ) const
 {
-   return fd.features[MFT_isDeferred] ? ShaderFeature::RenderTarget1 | ShaderFeature::RenderTarget2 : ShaderFeature::DefaultTarget;
+   return fd.features[MFT_isDeferred] ? ShaderFeature::RenderTarget2 | ShaderFeature::RenderTarget1 : ShaderFeature::DefaultTarget;
 }
 
 TerrainDetailMapFeatHLSL::TerrainDetailMapFeatHLSL()
@@ -1259,23 +1257,35 @@ void TerrainORMMapFeatHLSL::processPix(Vector<ShaderComponent*> &componentList,
    else
       texOp = new GenOp("@.Sample(@, float3(@.xy, @.x))", ormMapArray, ormMapSampler, inDet, new IndexOp(detailInfo, compositeIndex));
 
+   MultiLine* meta = new MultiLine;
    // search for material var
-   Var * ormConfig;
-   OutputTarget targ = RenderTarget1;
-   if (fd.features[MFT_isDeferred])
+   Var* ormConfig;
+   if ((fd.features[MFT_isDeferred]))
    {
-      targ = RenderTarget2;
-   }
-   ormConfig = (Var*)LangElement::find(getOutputTargetVarName(targ));
+      // Set base ORM info
+      ormConfig = (Var*)LangElement::find(getOutputTargetVarName(RenderTarget2));
 
-   MultiLine * meta = new MultiLine;
-   if (!ormConfig)
+      if (!ormConfig)
+      {
+         // create color var
+         ormConfig = new Var;
+         ormConfig->setType("fragout");
+         ormConfig->setName(getOutputTargetVarName(RenderTarget2));
+         ormConfig->setStructName("OUT");
+      }
+   }
+   else
    {
-      // create color var
-      ormConfig = new Var;
-      ormConfig->setType("fragout");
-      ormConfig->setName(getOutputTargetVarName(targ));
-      ormConfig->setStructName("OUT");
+      ormConfig = (Var*)LangElement::find("ORMConfig");
+      if (!ormConfig)
+      {
+         ormConfig = new Var("ORMConfig", "float4");
+         meta->addStatement(new GenOp("   @;\r\n", new DecOp(ormConfig)));
+      }
+   }
+   if (compositeIndex == 0)
+   {
+      meta->addStatement(new GenOp("   @ = float4(0.0, 0.0, 0.0, 0.0);\r\n", ormConfig));
    }
 
    Var *detailBlend = (Var*)LangElement::find(String::ToString("detailBlend%d", compositeIndex));
@@ -1284,11 +1294,6 @@ void TerrainORMMapFeatHLSL::processPix(Vector<ShaderComponent*> &componentList,
    String matinfoName(String::ToString("matinfoCol%d", compositeIndex));
    Var *matinfoCol = new Var(matinfoName, "float3");
 
-   if (compositeIndex == 0)
-   {
-      meta->addStatement(new GenOp("   @ = float4(0.0, 0.0, 0.0, 0.0);\r\n", ormConfig));
-   }
-
    meta->addStatement(new GenOp("   @ = @.rgb;\r\n", new DecOp(matinfoCol), texOp));
 
    if (fd.features.hasFeature(MFT_InvertRoughness, compositeIndex))
@@ -1313,39 +1318,39 @@ ShaderFeature::Resources TerrainORMMapFeatHLSL::getResources(const MaterialFeatu
    return res;
 }
 
-// reminder, the matinfo buffer is flags, smooth, ao, metal
-U32 TerrainBlankInfoMapFeatHLSL::getOutputTargets(const MaterialFeatureData &fd) const
-{
-   return fd.features[MFT_isDeferred] ? ShaderFeature::RenderTarget2 : ShaderFeature::RenderTarget1;
-}
-
 void TerrainBlankInfoMapFeatHLSL::processPix(Vector<ShaderComponent*> &componentList,
    const MaterialFeatureData &fd)
 {
    S32 compositeIndex = getProcessIndex();
 
-   // search for material var
-   Var *material;
-   OutputTarget ormConfig = RenderTarget1;
-   if (fd.features[MFT_isDeferred])
+   MultiLine * meta = new MultiLine;   Var* ormConfig;
+   if ((fd.features[MFT_isDeferred]))
    {
-      ormConfig = RenderTarget2;
-   }
-   material = (Var*)LangElement::find(getOutputTargetVarName(ormConfig));
+      // Set base ORM info
+      ormConfig = (Var*)LangElement::find(getOutputTargetVarName(RenderTarget2));
 
-   MultiLine * meta = new MultiLine;
-   if (!material)
+      if (!ormConfig)
+      {
+         // create color var
+         ormConfig = new Var;
+         ormConfig->setType("fragout");
+         ormConfig->setName(getOutputTargetVarName(RenderTarget2));
+         ormConfig->setStructName("OUT");
+      }
+   }
+   else
    {
-      // create color var
-      material = new Var;
-      material->setType("fragout");
-      material->setName(getOutputTargetVarName(ormConfig));
-      material->setStructName("OUT");
+      ormConfig = (Var*)LangElement::find("ORMConfig");
+      if (!ormConfig)
+      {
+         ormConfig = new Var("ORMConfig", "float4");
+         meta->addStatement(new GenOp("   @;\r\n", new DecOp(ormConfig)));
+      }
    }
 
    if (compositeIndex == 0)
    {
-      meta->addStatement(new GenOp("   @ = float4(0.0, 0.0, 0.0, 0.0);\r\n", material));
+      meta->addStatement(new GenOp("   @ = float4(0.0, 0.0, 0.0, 0.0);\r\n", ormConfig));
    }
 
    Var* detailBlend = (Var*)LangElement::find(String::ToString("detailBlend%d", compositeIndex));
@@ -1355,7 +1360,7 @@ void TerrainBlankInfoMapFeatHLSL::processPix(Vector<ShaderComponent*> &component
 
    if (!fd.features.hasFeature(MFT_TerrainHeightBlend))
    {
-      meta->addStatement(new GenOp("   @.gba += float3(@, @, 0.0);\r\n", material, detailBlend, detailBlend));
+      meta->addStatement(new GenOp("   @.gba += float3(@, @, 0.0);\r\n", ormConfig, detailBlend, detailBlend));
    }
 
    output = meta;
diff --git a/Engine/source/terrain/hlsl/terrFeatureHLSL.h b/Engine/source/terrain/hlsl/terrFeatureHLSL.h
index 829af9c6f..f3803f2d9 100644
--- a/Engine/source/terrain/hlsl/terrFeatureHLSL.h
+++ b/Engine/source/terrain/hlsl/terrFeatureHLSL.h
@@ -179,8 +179,6 @@ public:
 
    virtual void processPix(Vector<ShaderComponent*> &componentList,
       const MaterialFeatureData &fd);
-   
-   virtual U32 getOutputTargets(const MaterialFeatureData &fd) const;
    virtual String getName() { return "Blank Matinfo map"; }
 };
 

From 4cfb3c4f04bb5ab0c239bc733508295ae1a6c16a Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Wed, 22 Sep 2021 20:28:39 -0400
Subject: [PATCH 098/399] * [Linux] BugFix: Corrections to allow the Linux win
 console (Ie. the terminal you ran the game from) to act as a console input.

---
 Engine/source/platformX86UNIX/x86UNIXConsole.cpp | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/Engine/source/platformX86UNIX/x86UNIXConsole.cpp b/Engine/source/platformX86UNIX/x86UNIXConsole.cpp
index 88e17f38e..85828b202 100644
--- a/Engine/source/platformX86UNIX/x86UNIXConsole.cpp
+++ b/Engine/source/platformX86UNIX/x86UNIXConsole.cpp
@@ -41,7 +41,10 @@ StdConsole *stdConsole = NULL;
 DefineEngineFunction(enableWinConsole, void, (bool _enable),, "enableWinConsole(bool);")
 {
    if (stdConsole)
-      stdConsole->enable(_enable);
+   {
+       stdConsole->enable(_enable);
+       stdConsole->enableInput(_enable);
+   }
 }
 
 void StdConsole::create()
@@ -141,6 +144,9 @@ StdConsole::StdConsole()
    stdIn  = dup(0);
    stdErr = dup(2);
 
+   // Ensure in buffer is null terminated after allocation
+   inbuf[0] = 0x00;
+
    iCmdIndex = 0;
    stdConsoleEnabled = false;
    stdConsoleInputEnabled = false;
@@ -195,11 +201,14 @@ void StdConsole::processConsoleLine(const char *consoleLine)
 {
    if(stdConsoleEnabled)
    {
-      inbuf[inpos] = 0;
       if(lineOutput)
          printf("%s\n", consoleLine);
       else
-         printf("%c%s\n%s%s", '\r', consoleLine, Con::getVariable("Con::Prompt"), inbuf);
+      {
+          // Clear current line before outputting the console line. This prevents prompt text from overflowing onto normal output.
+          printf("%c[2K", 27);
+          printf("%c%s\n%s%s", '\r', consoleLine, Con::getVariable("Con::Prompt"), inbuf);
+      }
    }
 }
 
@@ -323,6 +332,7 @@ void StdConsole::process()
 
                   printf("%s", Con::getVariable("Con::Prompt"));
                   inpos = outpos = 0;
+                  inbuf[0] = 0x00; // Ensure inbuf is NULL terminated after sending out command
                   break;
             case 27:
                // JMQTODO: are these magic numbers keyboard map specific?

From e784b0140c32f2de6c5ca7ac5d23d3961cb28d00 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Wed, 22 Sep 2021 21:41:38 -0400
Subject: [PATCH 099/399] Let's fix the texcoord alignment for RT Lighting.

---
 .../source/shaderGen/GLSL/shaderFeatureGLSL.cpp  | 16 +++++++---------
 .../source/shaderGen/HLSL/shaderFeatureHLSL.cpp  | 12 +++++-------
 2 files changed, 12 insertions(+), 16 deletions(-)

diff --git a/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp b/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
index 0cf46277c..e9604eb77 100644
--- a/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
+++ b/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
@@ -2090,12 +2090,15 @@ void RTLightingFeatGLSL::processVert(  Vector<ShaderComponent*> &componentList,
 		
       return;
    }
-		
+	
+   addOutWsPosition( componentList, fd.features[MFT_UseInstancing], meta );
+   getOutWorldToTangent(componentList, meta, fd);
+   
+   output = meta;
+   
    // Find the incoming vertex normal.
    Var *inNormal = (Var*)LangElement::find( "normal" );   
-	
-   // Skip out on realtime lighting if we don't have a normal
-   // or we're doing some sort of baked lighting.
+
    if (  !inNormal || 
          fd.features[MFT_LightMap] || 
          fd.features[MFT_ToneMap] || 
@@ -2119,11 +2122,6 @@ void RTLightingFeatGLSL::processVert(  Vector<ShaderComponent*> &componentList,
       meta->addStatement( new GenOp( "   @ = tMul( @, vec4( normalize( @ ), 0.0 ) ).xyz;\r\n", outNormal, objTrans, inNormal ) );
    }*/
 
-	addOutWsPosition( componentList, fd.features[MFT_UseInstancing], meta );
-
-   getOutWorldToTangent(componentList, meta, fd);
-	
-   output = meta;
 }
 
 void RTLightingFeatGLSL::processPix(   Vector<ShaderComponent*> &componentList, 
diff --git a/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp b/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
index 1ebc3982a..dfdb5439c 100644
--- a/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
+++ b/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
@@ -2178,11 +2178,14 @@ void RTLightingFeatHLSL::processVert(  Vector<ShaderComponent*> &componentList,
       return;
    }
 
+   addOutWsPosition( componentList, fd.features[MFT_UseInstancing], meta );
+   getOutWorldToTangent(componentList, meta, fd);
+   output = meta;
+
+
    // Find the incoming vertex normal.
    Var *inNormal = (Var*)LangElement::find( "normal" );   
 
-   // Skip out on realtime lighting if we don't have a normal
-   // or we're doing some sort of baked lighting.
    if (  !inNormal || 
          fd.features[MFT_LightMap] || 
          fd.features[MFT_ToneMap] || 
@@ -2205,11 +2208,6 @@ void RTLightingFeatHLSL::processVert(  Vector<ShaderComponent*> &componentList,
       // Transform the normal to world space.
       meta->addStatement( new GenOp( "   @ = mul( @, float4( normalize( @ ), 0.0 ) ).xyz;\r\n", outNormal, objTrans, inNormal ) );
    }
-
-   addOutWsPosition( componentList, fd.features[MFT_UseInstancing], meta );
-   getOutWorldToTangent(componentList, meta, fd);
-
-   output = meta;
 }
 
 void RTLightingFeatHLSL::processPix(   Vector<ShaderComponent*> &componentList, 

From 55063601e6aacc6aca62855a2c575450666a57ea Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Thu, 23 Sep 2021 22:58:25 -0400
Subject: [PATCH 100/399] * [Projectile] BugFix: Correct the onAdd callback not
 being raised for projectiles.

---
 Engine/source/T3D/projectile.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Engine/source/T3D/projectile.cpp b/Engine/source/T3D/projectile.cpp
index 739daf4a5..b21fe9542 100644
--- a/Engine/source/T3D/projectile.cpp
+++ b/Engine/source/T3D/projectile.cpp
@@ -786,6 +786,8 @@ bool Projectile::onAdd()
       // If we're on the server, we need to inherit some of our parent's velocity
       //
       mCurrTick = 0;
+
+      scriptOnAdd();
    }
    else
    {

From 12f4af51f557cc76a4d018fe262b816eae58b119 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Fri, 24 Sep 2021 17:58:17 -0400
Subject: [PATCH 101/399] * [Editor] BugFix: Fix a crash that sometimes occurs
 when groups of objects are deleted in the world editor.

---
 Engine/source/gui/worldEditor/worldEditor.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Engine/source/gui/worldEditor/worldEditor.cpp b/Engine/source/gui/worldEditor/worldEditor.cpp
index d6642cd1c..dfccf8533 100644
--- a/Engine/source/gui/worldEditor/worldEditor.cpp
+++ b/Engine/source/gui/worldEditor/worldEditor.cpp
@@ -1993,12 +1993,12 @@ void WorldEditor::on3DMouseMove(const Gui3DMouseEvent & event)
    if ( !mHitObject )
    {
       SceneObject *hitObj = NULL;
-      if ( collide(event, &hitObj) && hitObj->isSelectionEnabled() && !objClassIgnored(hitObj) )
+      if ( collide(event, &hitObj) && !hitObj->isDeleted() && hitObj->isSelectionEnabled() && !objClassIgnored(hitObj) )
       {
          mHitObject = hitObj;
       }
    }
-   
+
    mLastMouseEvent = event;
 }
 

From d7919950bfbe217650fbb457f13fe31bcbf6e4a0 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Fri, 24 Sep 2021 18:34:57 -0400
Subject: [PATCH 102/399] * [Editor] BugFix: Correct an object spawning error
 when attempting to drag and drop datablocks from the asset browser where they
 would always spawn at origin.

---
 .../game/tools/worldEditor/scripts/editors/creator.ed.tscript   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/editors/creator.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/editors/creator.ed.tscript
index 08bd46598..8fce4a3fd 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/editors/creator.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/editors/creator.ed.tscript
@@ -227,7 +227,7 @@ function EWCreatorWindow::createObject( %this, %cmd )
       %this.setNewObjectGroup( getScene(0) );
 
    pushInstantGroup();
-   %objId = eval(%cmd);
+   %objId = eval("return " @ %cmd);
    popInstantGroup();
    
    if( isObject( %objId ) )

From f1ee4f781b2ead4f881665784cd4751d7b87cb69 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Fri, 24 Sep 2021 19:09:43 -0400
Subject: [PATCH 103/399] Material editor fixes from eval cleanup.

---
 .../scripts/materialEditor.ed.tscript           | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
index bdca293da..8a21c9907 100644
--- a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
@@ -1097,9 +1097,6 @@ function MaterialEditorGui::updateActiveMaterial(%this, %propertyField, %value,
 {
    MaterialEditorGui.setMaterialDirty();
 
-   if(%value $= "")
-      %value = "\"\"";
-   
    // Here is where we handle undo actions with slider controls. We want to be able to
    // undo every onMouseUp; so we overrite the same undo action when necessary in order
    // to achieve this desired effect.
@@ -1130,7 +1127,7 @@ function MaterialEditorGui::updateActiveMaterial(%this, %propertyField, %value,
    
    if (MaterialEditorGui.livePreview == true)
    {
-      MaterialEditorGui.setFieldValue(%propertyField, %value);
+      MaterialEditorGui.currentMaterial.setFieldValue(%propertyField, %value);
       MaterialEditorGui.currentMaterial.flush();
       MaterialEditorGui.currentMaterial.reload();
    }
@@ -1263,8 +1260,8 @@ function MaterialEditorGui::doUpdateTextureMap( %this, %assetId )
          %bitmap = strreplace(%bitmap,"tools/materialEditor/scripts/","");
          %bitmapCtrl.setBitmap(%bitmap);
          %textCtrl.setText(%assetId);
-         MaterialEditorGui.updateActiveMaterial(%type @ "Map[" @ %layer @ "]","\"\"");
-         MaterialEditorGui.updateActiveMaterial(%type @ "MapAsset[" @ %layer @ "]","\"" @ %assetId @ "\"");	
+         MaterialEditorGui.updateActiveMaterial(%type @ "Map[" @ %layer @ "]","");
+         MaterialEditorGui.updateActiveMaterial(%type @ "MapAsset[" @ %layer @ "]", %assetId);	
       }
    }
    
@@ -1276,7 +1273,7 @@ function MaterialEditorGui::updateDetailScale(%this,%newScale)
 {
    %layer = MaterialEditorGui.currentLayer;
    
-   %detailScale = "\"" @ %newScale SPC %newScale @ "\"";
+   %detailScale = %newScale SPC %newScale;
    MaterialEditorGui.updateActiveMaterial("detailScale[" @ %layer @ "]", %detailScale);
    }
    
@@ -1284,7 +1281,7 @@ function MaterialEditorGui::updateDetailNormalStrength(%this,%newStrength)
 {
    %layer = MaterialEditorGui.currentLayer;
    
-   %detailStrength = "\"" @ %newStrength @ "\"";
+   %detailStrength = %newStrength;
    MaterialEditorGui.updateActiveMaterial("detailNormalMapStrength[" @ %layer @ "]", %detailStrength);
 }
 
@@ -1295,7 +1292,7 @@ function MaterialEditorGui::updateRotationOffset(%this, %isSlider, %onMouseUp)
 	%Y = MaterialEditorPropertiesWindow-->RotationTextEditV.getText();
 	MaterialEditorPropertiesWindow-->RotationCrosshair.setPosition(45*mAbs(%X)-2, 45*mAbs(%Y)-2);
 	
-	MaterialEditorGui.updateActiveMaterial("rotPivotOffset[" @ %layer @ "]","\"" @ %X SPC %Y @ "\"",%isSlider,%onMouseUp);
+	MaterialEditorGui.updateActiveMaterial("rotPivotOffset[" @ %layer @ "]", %X SPC %Y,%isSlider,%onMouseUp);
 }
 
 function MaterialEditorGui::updateRotationSpeed(%this, %isSlider, %onMouseUp)
@@ -1457,7 +1454,7 @@ function MaterialEditorGui::syncGuiColor(%this, %guiCtrl, %propname, %color)
    %a = getWord(%color,3);
 
    %colorSwatch = (%r SPC %g SPC %b SPC %a);
-   %color = "\"" @ %r SPC %g SPC %b SPC %a @ "\"";
+   %color = %r SPC %g SPC %b SPC %a;
 
    %guiCtrl.color = %colorSwatch;
 	MaterialEditorGui.updateActiveMaterial(%propName, %color);

From 755bbacaa0ee10a5b91c27ab29e604947c7a4adb Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Fri, 24 Sep 2021 19:32:57 -0400
Subject: [PATCH 104/399] Fix specific usage of Con::executef where it was not
 being assigned to a ConsoleValue before getting it's data out of it.

---
 Engine/source/Verve/Core/Persistence/VPersistence.h      | 5 +++--
 Engine/source/afx/afxEffectron.cpp                       | 3 ++-
 Engine/source/afx/afxSelectron.cpp                       | 6 ++++--
 Engine/source/console/arrayObject.cpp                    | 6 ++++--
 Engine/source/console/simObjectList.cpp                  | 3 ++-
 Engine/source/environment/editors/guiRiverEditorCtrl.cpp | 3 ++-
 Engine/source/forest/editor/forestBrushTool.cpp          | 5 +++--
 Engine/source/gui/controls/guiTreeViewCtrl.cpp           | 4 +++-
 Engine/source/gui/editor/guiPopupMenuCtrl.cpp            | 4 +++-
 Engine/source/gui/editor/popupMenu.cpp                   | 3 ++-
 Engine/source/gui/worldEditor/worldEditor.cpp            | 4 +++-
 Engine/source/module/moduleManager.cpp                   | 6 ++++--
 Engine/source/util/messaging/scriptMsgListener.cpp       | 4 ----
 13 files changed, 35 insertions(+), 21 deletions(-)

diff --git a/Engine/source/Verve/Core/Persistence/VPersistence.h b/Engine/source/Verve/Core/Persistence/VPersistence.h
index edbc892c8..a350005fc 100644
--- a/Engine/source/Verve/Core/Persistence/VPersistence.h
+++ b/Engine/source/Verve/Core/Persistence/VPersistence.h
@@ -250,8 +250,9 @@ namespace VPersistence
             if ( object->isMethod( "onAdd" ) )
             {
                 // Callback.
-                const char *retValue = Con::executef( object, "onAdd" );
-                if ( !dAtob( retValue ) )
+                ConsoleValue cValue = Con::executef( object, "onAdd" );
+
+                if ( !cValue.getBool() )
                 {
                     // Delete.
                     object->deleteObject();
diff --git a/Engine/source/afx/afxEffectron.cpp b/Engine/source/afx/afxEffectron.cpp
index 1c68256c1..f90d20f73 100644
--- a/Engine/source/afx/afxEffectron.cpp
+++ b/Engine/source/afx/afxEffectron.cpp
@@ -989,9 +989,10 @@ afxEffectron::start_effect(afxEffectronData* datablock, SimObject* extra)
   }
 
   // CALL SCRIPT afxEffectronData::onPreactivate(%params, %extra)
-  const char* result = Con::executef(datablock, "onPreactivate", 
+  ConsoleValue cValue = Con::executef(datablock, "onPreactivate", 
                                      Con::getIntArg(param_holder->getId()), 
                                      (extra) ? Con::getIntArg(extra->getId()) : "");
+  const char* result = cValue.getString();
   if (result && result[0] != '\0' && !dAtob(result))
   {
 #if defined(TORQUE_DEBUG)
diff --git a/Engine/source/afx/afxSelectron.cpp b/Engine/source/afx/afxSelectron.cpp
index 63157a4f1..1b6194b9a 100644
--- a/Engine/source/afx/afxSelectron.cpp
+++ b/Engine/source/afx/afxSelectron.cpp
@@ -1068,9 +1068,11 @@ afxSelectron::start_selectron(SceneObject* picked, U8 subcode, SimObject* extra)
   }
 
   // CALL SCRIPT afxSelectronData::onPreactivate(%params, %extra)
-  const char* result = Con::executef(datablock, "onPreactivate",
+  ConsoleValue cValue = Con::executef(datablock, "onPreactivate",
                                      Con::getIntArg(param_holder->getId()),
-                                     (extra) ? Con::getIntArg(extra->getId()) : "").getString();
+                                     (extra) ? Con::getIntArg(extra->getId()) : "");
+
+  const char* result = cValue.getString();
   if (result && result[0] != '\0' && !dAtob(result))
   {
 #if defined(TORQUE_DEBUG)
diff --git a/Engine/source/console/arrayObject.cpp b/Engine/source/console/arrayObject.cpp
index 92458852d..68b34059e 100644
--- a/Engine/source/console/arrayObject.cpp
+++ b/Engine/source/console/arrayObject.cpp
@@ -103,7 +103,8 @@ S32 QSORT_CALLBACK ArrayObject::_keyFunctionCompare( const void* a, const void*
    ArrayObject::Element* ea = ( ArrayObject::Element* )( a );
    ArrayObject::Element* eb = ( ArrayObject::Element* )( b );
    
-   S32 result = dAtoi(Con::executef((const char*)smCompareFunction, ea->key, eb->key));
+   ConsoleValue cValue = Con::executef((const char*)smCompareFunction, ea->key, eb->key);
+   S32 result = cValue.getInt();
    S32 res = result < 0 ? -1 : ( result > 0 ? 1 : 0 );
    return ( smDecreasing ? -res : res );
 }
@@ -113,7 +114,8 @@ S32 QSORT_CALLBACK ArrayObject::_valueFunctionCompare( const void* a, const void
    ArrayObject::Element* ea = ( ArrayObject::Element* )( a );
    ArrayObject::Element* eb = ( ArrayObject::Element* )( b );
    
-   S32 result = dAtoi( Con::executef( (const char*)smCompareFunction, ea->value, eb->value ) );
+   ConsoleValue cValue = Con::executef( (const char*)smCompareFunction, ea->value, eb->value );
+   S32 result = cValue.getInt();
    S32 res = result < 0 ? -1 : ( result > 0 ? 1 : 0 );
    return ( smDecreasing ? -res : res );
 }
diff --git a/Engine/source/console/simObjectList.cpp b/Engine/source/console/simObjectList.cpp
index 8388f6e9d..ac286f22b 100644
--- a/Engine/source/console/simObjectList.cpp
+++ b/Engine/source/console/simObjectList.cpp
@@ -118,7 +118,8 @@ S32 QSORT_CALLBACK SimObjectList::_callbackSort( const void *a, const void *b )
    static char idB[64];
    dSprintf( idB, sizeof( idB ), "%d", objB->getId() );
 
-   return dAtoi( Con::executef( (const char*)smSortScriptCallbackFn, idA, idB ) );
+   ConsoleValue cValue = Con::executef( (const char*)smSortScriptCallbackFn, idA, idB );
+   return cValue.getInt();
 }
 
 void SimObjectList::scriptSort( const String &scriptCallback )
diff --git a/Engine/source/environment/editors/guiRiverEditorCtrl.cpp b/Engine/source/environment/editors/guiRiverEditorCtrl.cpp
index ae9084588..e650fdf59 100644
--- a/Engine/source/environment/editors/guiRiverEditorCtrl.cpp
+++ b/Engine/source/environment/editors/guiRiverEditorCtrl.cpp
@@ -438,7 +438,8 @@ void GuiRiverEditorCtrl::_process3DMouseDown( const Gui3DMouseEvent& event )
          return;
       }
 
-      const char *res = Con::executef( this, "createRiver" );
+      ConsoleValue cValue = Con::executef( this, "createRiver" );
+      const char* res = cValue.getString();
 
       River *newRiver;
       if ( !Sim::findObject( res, newRiver ) )
diff --git a/Engine/source/forest/editor/forestBrushTool.cpp b/Engine/source/forest/editor/forestBrushTool.cpp
index d0d64d517..5b9278ea6 100644
--- a/Engine/source/forest/editor/forestBrushTool.cpp
+++ b/Engine/source/forest/editor/forestBrushTool.cpp
@@ -588,7 +588,8 @@ void ForestBrushTool::_collectElements()
    if ( !Sim::findObject( "ForestEditBrushTree", brushTree ) )
       return;
       
-   const char* objectIdList = Con::executef( brushTree, "getSelectedObjectList" );
+   ConsoleValue cValue = Con::executef( brushTree, "getSelectedObjectList" );
+   const char* objectIdList = cValue.getString();
 
    // Collect those objects in a vector and mark them as selected.
 
@@ -685,4 +686,4 @@ bool ForestBrushTool::getGroundAt( const Point3F &worldPt, F32 *zValueOut, Vecto
 DefineEngineMethod( ForestBrushTool, collectElements, void, (), , "" )
 {
    object->collectElements();
-}
\ No newline at end of file
+}
diff --git a/Engine/source/gui/controls/guiTreeViewCtrl.cpp b/Engine/source/gui/controls/guiTreeViewCtrl.cpp
index e2804b1f1..aaed67a78 100644
--- a/Engine/source/gui/controls/guiTreeViewCtrl.cpp
+++ b/Engine/source/gui/controls/guiTreeViewCtrl.cpp
@@ -637,7 +637,9 @@ void GuiTreeViewCtrl::Item::getTooltipText(U32 bufLen, char *buf)
          method += pClassName;
          if(mParentControl->isMethod(method.c_str()))
          {
-            const char* tooltip = Con::executef( mParentControl, method.c_str(), pObject->getIdString() );
+            ConsoleValue cValue = Con::executef( mParentControl, method.c_str(), pObject->getIdString() );
+            const char* tooltip = cValue.getString();
+
             dsize_t len = dStrlen(buf);
             S32 newBufLen = bufLen-len;
             if(dStrlen(tooltip) > 0 && newBufLen > 0)
diff --git a/Engine/source/gui/editor/guiPopupMenuCtrl.cpp b/Engine/source/gui/editor/guiPopupMenuCtrl.cpp
index 7c63ebe52..ba04467c2 100644
--- a/Engine/source/gui/editor/guiPopupMenuCtrl.cpp
+++ b/Engine/source/gui/editor/guiPopupMenuCtrl.cpp
@@ -226,7 +226,9 @@ void GuiPopupMenuTextListCtrl::onMouseUp(const GuiEvent &event)
       if (item)
       {
          if (item->mEnabled)
-            dAtob(Con::executef(mPopup, "onSelectItem", Con::getIntArg(getSelectedCell().y), item->mText.isNotEmpty() ? item->mText : ""));
+         {
+            Con::executef(mPopup, "onSelectItem", Con::getIntArg(getSelectedCell().y), item->mText.isNotEmpty() ? item->mText : "");
+         }
       }
    }
 
diff --git a/Engine/source/gui/editor/popupMenu.cpp b/Engine/source/gui/editor/popupMenu.cpp
index 14fff6844..6e7cb39ee 100644
--- a/Engine/source/gui/editor/popupMenu.cpp
+++ b/Engine/source/gui/editor/popupMenu.cpp
@@ -288,7 +288,8 @@ bool PopupMenu::canHandleID(U32 id)
 
 bool PopupMenu::handleSelect(U32 command, const char *text /* = NULL */)
 {
-   return dAtob(Con::executef(this, "onSelectItem", Con::getIntArg(command), text ? text : ""));
+   ConsoleValue cValue = Con::executef(this, "onSelectItem", Con::getIntArg(command), text ? text : "");
+   return cValue.getBool();
 }
 
 //////////////////////////////////////////////////////////////////////////
diff --git a/Engine/source/gui/worldEditor/worldEditor.cpp b/Engine/source/gui/worldEditor/worldEditor.cpp
index d6642cd1c..d2aa75c4d 100644
--- a/Engine/source/gui/worldEditor/worldEditor.cpp
+++ b/Engine/source/gui/worldEditor/worldEditor.cpp
@@ -461,7 +461,9 @@ bool WorldEditor::pasteSelection( bool dropSel )
    SimGroup *targetGroup = NULL;   
    if( isMethod( "getNewObjectGroup" ) )
    {
-      const char* targetGroupName = Con::executef( this, "getNewObjectGroup" );
+      ConsoleValue cValue = Con::executef( this, "getNewObjectGroup" );
+      const char* targetGroupName = cValue.getString();
+
       if( targetGroupName && targetGroupName[ 0 ] && !Sim::findObject( targetGroupName, targetGroup) )
          Con::errorf( "WorldEditor::pasteSelection() - no SimGroup called '%s'", targetGroupName );
    }
diff --git a/Engine/source/module/moduleManager.cpp b/Engine/source/module/moduleManager.cpp
index f91ae060d..08db0da6c 100644
--- a/Engine/source/module/moduleManager.cpp
+++ b/Engine/source/module/moduleManager.cpp
@@ -397,7 +397,8 @@ bool ModuleManager::loadModuleGroup( const char* pModuleGroup )
         if ( pLoadReadyModuleDefinition->getModuleScriptFilePath() != StringTable->EmptyString() )
         {
             // Yes, so execute the script file.
-            const bool scriptFileExecuted = dAtob( Con::executef("exec", pLoadReadyModuleDefinition->getModuleScriptFilePath() ) );
+            ConsoleValue cValue = Con::executef("exec", pLoadReadyModuleDefinition->getModuleScriptFilePath());
+            const bool scriptFileExecuted = cValue.getBool();
 
             // Did we execute the script file?
             if ( scriptFileExecuted )
@@ -784,7 +785,8 @@ bool ModuleManager::loadModuleExplicit( const char* pModuleId, const U32 version
         if ( pLoadReadyModuleDefinition->getModuleScriptFilePath() != StringTable->EmptyString() )
         {
             // Yes, so execute the script file.
-            const bool scriptFileExecuted = dAtob( Con::executef("exec", pLoadReadyModuleDefinition->getModuleScriptFilePath() ) );
+            ConsoleValue cValue = Con::executef("exec", pLoadReadyModuleDefinition->getModuleScriptFilePath());
+            const bool scriptFileExecuted = cValue.getBool();
 
             // Did we execute the script file?
             if ( !scriptFileExecuted )
diff --git a/Engine/source/util/messaging/scriptMsgListener.cpp b/Engine/source/util/messaging/scriptMsgListener.cpp
index fa47b7e7c..f64d2a6b2 100644
--- a/Engine/source/util/messaging/scriptMsgListener.cpp
+++ b/Engine/source/util/messaging/scriptMsgListener.cpp
@@ -121,7 +121,6 @@ IMPLEMENT_CALLBACK( ScriptMsgListener, onMessageReceived, bool, ( const char* qu
 bool ScriptMsgListener::onMessageReceived(StringTableEntry queue, const char* event, const char* data)
 {
 	return onMessageReceived_callback(queue, event, data);
-   //return dAtob(Con::executef(this, "onMessageReceived", queue, event, data));
 }
 
 IMPLEMENT_CALLBACK( ScriptMsgListener, onMessageObjectReceived, bool, ( const char* queue, Message *msg ), ( queue, msg ),
@@ -135,7 +134,6 @@ IMPLEMENT_CALLBACK( ScriptMsgListener, onMessageObjectReceived, bool, ( const ch
 bool ScriptMsgListener::onMessageObjectReceived(StringTableEntry queue, Message *msg)
 {
 	return onMessageObjectReceived_callback(queue, msg);
-   //return dAtob(Con::executef(this, "onMessageObjectReceived", queue, Con::getIntArg(msg->getId())));
 }
 
 //-----------------------------------------------------------------------------
@@ -150,7 +148,6 @@ IMPLEMENT_CALLBACK( ScriptMsgListener, onAddToQueue, void, ( const char* queue),
 
 void ScriptMsgListener::onAddToQueue(StringTableEntry queue)
 {
-   //Con::executef(this, "onAddToQueue", queue);
    onAddToQueue_callback(queue);
    IMLParent::onAddToQueue(queue);
 }
@@ -176,7 +173,6 @@ IMPLEMENT_CALLBACK( ScriptMsgListener, onRemoveFromQueue, void, ( const char* qu
 
 void ScriptMsgListener::onRemoveFromQueue(StringTableEntry queue)
 {
-   //Con::executef(this, "onRemoveFromQueue", queue);
    onRemoveFromQueue_callback(queue);
    IMLParent::onRemoveFromQueue(queue);
 }

From 58a79e0105a6a88848e4f21c77cf3b6220b2d1b3 Mon Sep 17 00:00:00 2001
From: OTHGMars <mmars1149@aol.com>
Date: Fri, 24 Sep 2021 22:55:59 -0400
Subject: [PATCH 105/399] inputTest Module Update Updates the input event
 monitor to work with the current BaseGame template.

---
 Templates/Modules/inputTest/inputTest.tscript   | 17 +++++++++++------
 .../inputTest/scripts/gui/inputMonitor.gui      |  2 +-
 .../inputTest/scripts/menuButtons.tscript       |  8 +++++++-
 3 files changed, 19 insertions(+), 8 deletions(-)

diff --git a/Templates/Modules/inputTest/inputTest.tscript b/Templates/Modules/inputTest/inputTest.tscript
index 7dad50618..07f27fc9f 100644
--- a/Templates/Modules/inputTest/inputTest.tscript
+++ b/Templates/Modules/inputTest/inputTest.tscript
@@ -4,6 +4,11 @@
 
 function inputTest::create( %this )
 {
+   // If addToMainMenu is true, a button to display the input monitor will be
+   // added to the MainMenu gui. If false, you will need to call
+   // "$GameCanvas.pushDialog(InputMonitorDlg);" from the console or add a
+   // shortcut somewhere else to access the Input Event Monitor.
+   %this.addToMainMenu = true;
 }
 
 function inputTest::destroy( %this )
@@ -13,12 +18,12 @@ function inputTest::destroy( %this )
 
 function inputTest::initClient( %this )
 {
-   %this.queueExec("/scripts/customProfiles." @ $TorqueScriptFileExtension);
-   %this.queueExec("/scripts/inputMonitor." @ $TorqueScriptFileExtension);
-   %this.queueExec("/scripts/gui/inputMonitor.gui");
-   %this.queueExec("/scripts/joystickSettings." @ $TorqueScriptFileExtension);
-   %this.queueExec("/scripts/gui/joystickSettings.gui");
-   %this.queueExec("/scripts/menuButtons." @ $TorqueScriptFileExtension);
+   %this.queueExec("./scripts/customProfiles." @ $TorqueScriptFileExtension);
+   %this.queueExec("./scripts/inputMonitor." @ $TorqueScriptFileExtension);
+   %this.queueExec("./scripts/gui/inputMonitor.gui");
+   %this.queueExec("./scripts/joystickSettings." @ $TorqueScriptFileExtension);
+   %this.queueExec("./scripts/gui/joystickSettings.gui");
+   %this.queueExec("./scripts/menuButtons." @ $TorqueScriptFileExtension);
 }
 
 function onSDLDeviceConnected(%sdlIndex, %deviceName, %deviceType)
diff --git a/Templates/Modules/inputTest/scripts/gui/inputMonitor.gui b/Templates/Modules/inputTest/scripts/gui/inputMonitor.gui
index 67708cf2e..c695016af 100644
--- a/Templates/Modules/inputTest/scripts/gui/inputMonitor.gui
+++ b/Templates/Modules/inputTest/scripts/gui/inputMonitor.gui
@@ -55,7 +55,7 @@ $guiContent = new GuiControl(InputMonitorDlg) {
          canSaveDynamicFields = "0";
       };
       new GuiChunkedBitmapCtrl() {
-         bitmap = "data/ui/art/hudfill.png";
+         bitmap = "data/ui/images/hudfill.png";
          useVariable = "0";
          tile = "0";
          position = "0 0";
diff --git a/Templates/Modules/inputTest/scripts/menuButtons.tscript b/Templates/Modules/inputTest/scripts/menuButtons.tscript
index 471676a07..8f97d2262 100644
--- a/Templates/Modules/inputTest/scripts/menuButtons.tscript
+++ b/Templates/Modules/inputTest/scripts/menuButtons.tscript
@@ -2,6 +2,8 @@
 // Add buttons to the MainMenu after all other scripts have been exec'ed.
 //-----------------------------------------------------------------------------
 
+function inputTest::addMenuButton( %this )
+{
    if (isObject(MainMenuGui))
    {
       %testBtn = new GuiButtonCtrl() {
@@ -56,4 +58,8 @@
       }
 
       MMTestContainer.add(%testBtn);
-   }
\ No newline at end of file
+   }
+}
+
+if (inputTest.addToMainMenu)
+   inputTest.addMenuButton();
\ No newline at end of file

From 666065ce6c59b917700c0c606843beb424212fe4 Mon Sep 17 00:00:00 2001
From: OTHGMars <mmars1149@aol.com>
Date: Sat, 25 Sep 2021 02:48:30 -0400
Subject: [PATCH 106/399] GuiGameListMenuCtrl Update Methods to simplify
 managing localized option lists. Adds a text key to each option in an option
 row. Adds methods for getting the current selections index or key value. Adds
 methods for setting the current selection by index or key value. This change
 is backward compatible. If the new methods are not called, the control
 behavior is unaffected.

---
 .../gui/controls/guiGameListMenuCtrl.cpp      | 144 +++++++++++++++++-
 .../source/gui/controls/guiGameListMenuCtrl.h |  54 ++++++-
 2 files changed, 189 insertions(+), 9 deletions(-)

diff --git a/Engine/source/gui/controls/guiGameListMenuCtrl.cpp b/Engine/source/gui/controls/guiGameListMenuCtrl.cpp
index 61833a8d0..72b3d02f2 100644
--- a/Engine/source/gui/controls/guiGameListMenuCtrl.cpp
+++ b/Engine/source/gui/controls/guiGameListMenuCtrl.cpp
@@ -237,7 +237,7 @@ void GuiGameListMenuCtrl::onRenderListOption(Row* row, Point2I currentOffset)
 
       // calculate text to be at the center between the arrows
       GFont* font = profile->mFont;
-      StringTableEntry text = row->mOptions[row->mSelectedOption];
+      StringTableEntry text = row->mOptions[row->mSelectedOption].mDisplayText;
       S32 textWidth = font->getStrWidth(text);
       S32 columnWidth = profile->mHitAreaLowerRight.x * xScale - profile->mRightPad - columnSplit;
       S32 columnCenter = columnSplit + (columnWidth >> 1);
@@ -489,15 +489,18 @@ void GuiGameListMenuCtrl::addRow(const char* label, const char* optionsList, boo
 {
    static StringTableEntry DELIM = StringTable->insert("\t", true);
    Row* row = new Row();
-   Vector<StringTableEntry> options(__FILE__, __LINE__);
+   Vector<OptionEntry> options(__FILE__, __LINE__);
 
    S32 defaultOption = 0;
 
    S32 count = StringUnit::getUnitCount(optionsList, DELIM);
    for (S32 i = 0; i < count; ++i)
    {
+      OptionEntry e;
       const char* option = StringUnit::getUnit(optionsList, i, DELIM);
-      options.push_back(StringTable->insert(option, true));
+      e.mDisplayText = StringTable->insert(option, true);
+      e.mKeyString = e.mDisplayText;
+      options.push_back(e);
 
       if (String::compare(option, defaultValue) == 0)
          defaultOption = options.size() - 1;
@@ -1075,12 +1078,38 @@ StringTableEntry GuiGameListMenuCtrl::getCurrentOption(S32 rowIndex) const
       Row* row = (Row*)mRows[rowIndex];
       if (row->mSelectedOption != NO_OPTION)
       {
-         return row->mOptions[row->mSelectedOption];
+         return row->mOptions[row->mSelectedOption].mDisplayText;
       }
    }
    return StringTable->insert("", false);
 }
 
+StringTableEntry GuiGameListMenuCtrl::getCurrentOptionKey(S32 rowIndex) const
+{
+   if (isValidRowIndex(rowIndex))
+   {
+      Row* row = (Row*)mRows[rowIndex];
+      if (row->mSelectedOption != NO_OPTION)
+      {
+         return row->mOptions[row->mSelectedOption].mKeyString;
+      }
+   }
+   return StringTable->insert("", false);
+}
+
+S32 GuiGameListMenuCtrl::getCurrentOptionIndex(S32 rowIndex) const
+{
+   if (isValidRowIndex(rowIndex))
+   {
+      Row* row = (Row*)mRows[rowIndex];
+      if (row->mSelectedOption != NO_OPTION)
+      {
+         return row->mSelectedOption;
+      }
+   }
+   return S32(-1);
+}
+
 bool GuiGameListMenuCtrl::selectOption(S32 rowIndex, const char* theOption)
 {
    if (!isValidRowIndex(rowIndex))
@@ -1090,9 +1119,9 @@ bool GuiGameListMenuCtrl::selectOption(S32 rowIndex, const char* theOption)
 
    Row* row = (Row*)mRows[rowIndex];
 
-   for (Vector<StringTableEntry>::iterator anOption = row->mOptions.begin(); anOption < row->mOptions.end(); ++anOption)
+   for (Vector<OptionEntry>::iterator anOption = row->mOptions.begin(); anOption < row->mOptions.end(); ++anOption)
    {
-      if (String::compare(*anOption, theOption) == 0)
+      if (String::compare((*anOption).mDisplayText, theOption) == 0)
       {
          S32 newIndex = anOption - row->mOptions.begin();
          row->mSelectedOption = newIndex;
@@ -1103,6 +1132,45 @@ bool GuiGameListMenuCtrl::selectOption(S32 rowIndex, const char* theOption)
    return false;
 }
 
+bool GuiGameListMenuCtrl::selectOptionByKey(S32 rowIndex, const char* optionKey)
+{
+   if (!isValidRowIndex(rowIndex))
+   {
+      return false;
+   }
+
+   Row* row = (Row*)mRows[rowIndex];
+
+   for (Vector<OptionEntry>::iterator anOption = row->mOptions.begin(); anOption < row->mOptions.end(); ++anOption)
+   {
+      if (String::compare((*anOption).mKeyString, optionKey) == 0)
+      {
+         S32 newIndex = anOption - row->mOptions.begin();
+         row->mSelectedOption = newIndex;
+         return true;
+      }
+   }
+
+   return false;
+}
+
+bool GuiGameListMenuCtrl::selectOptionByIndex(S32 rowIndex, S32 optionIndex)
+{
+   if (!isValidRowIndex(rowIndex) || (optionIndex < 0))
+   {
+      return false;
+   }
+
+   Row* row = (Row*)mRows[rowIndex];
+   if (optionIndex < row->mOptions.size())
+   {
+      row->mSelectedOption = optionIndex;
+      return true;
+   }
+
+   return false;
+}
+
 void GuiGameListMenuCtrl::setOptions(S32 rowIndex, const char* optionsList)
 {
    static StringTableEntry DELIM = StringTable->insert("\t", true);
@@ -1119,7 +1187,10 @@ void GuiGameListMenuCtrl::setOptions(S32 rowIndex, const char* optionsList)
    for (S32 i = 0; i < count; ++i)
    {
       const char* option = StringUnit::getUnit(optionsList, i, DELIM);
-      row->mOptions[i] = StringTable->insert(option, true);
+      OptionEntry e;
+      e.mDisplayText = StringTable->insert(option, true);
+      e.mKeyString = e.mDisplayText;
+      row->mOptions[i] = e;
    }
 
    if (row->mSelectedOption >= row->mOptions.size())
@@ -1128,6 +1199,21 @@ void GuiGameListMenuCtrl::setOptions(S32 rowIndex, const char* optionsList)
    }
 }
 
+void GuiGameListMenuCtrl::addOption(S32 rowIndex, const char* displayText, const char* keyText)
+{
+   if (!isValidRowIndex(rowIndex))
+   {
+      return;
+   }
+
+   OptionEntry e;
+   e.mDisplayText = StringTable->insert(displayText, true);
+   e.mKeyString = (keyText[0] == '\0') ? e.mDisplayText : StringTable->insert(keyText, true);
+
+   Row* row = (Row*)mRows[rowIndex];
+   row->mOptions.push_back(e);
+}
+
 void GuiGameListMenuCtrl::clickOption(Row* row, S32 xPos)
 {
    GuiGameListMenuProfile* profile = (GuiGameListMenuProfile*)mProfile;
@@ -1566,6 +1652,22 @@ DefineEngineMethod(GuiGameListMenuCtrl, getCurrentOption, const char*, (S32 row)
    return object->getCurrentOption(row);
 }
 
+DefineEngineMethod(GuiGameListMenuCtrl, getCurrentOptionKey, const char*, (S32 row), ,
+   "Gets the key string for the currently selected option of the given row.\n\n"
+   "@param row Index of the row to get the option from.\n"
+   "@return The key (or id) that was assigned to the selected option on the given row. If there is no selected option then the empty string is returned.")
+{
+   return object->getCurrentOptionKey(row);
+}
+
+DefineEngineMethod(GuiGameListMenuCtrl, getCurrentOptionIndex, S32, (S32 row), ,
+   "Gets the index into the option list for the currently selected option of the given row.\n\n"
+   "@param row Index of the row to get the option from.\n"
+   "@return The index of the selected option on the given row. If there is no selected option then -1 is returned.")
+{
+   return object->getCurrentOptionIndex(row);
+}
+
 DefineEngineMethod(GuiGameListMenuCtrl, selectOption, bool, (S32 row, const char* option), ,
    "Set the row's current option to the one specified\n\n"
    "@param row Index of the row to set an option on.\n"
@@ -1575,6 +1677,24 @@ DefineEngineMethod(GuiGameListMenuCtrl, selectOption, bool, (S32 row, const char
    return object->selectOption(row, option);
 }
 
+DefineEngineMethod(GuiGameListMenuCtrl, selectOptionByKey, bool, (S32 row, const char* optionKey), ,
+   "Set the row's current option to the one with the specified key.\n\n"
+   "@param row Index of the row to set an option on.\n"
+   "@param optionKey The key string that was assigned to the option to be made active.\n"
+   "@return True if the row contained the key and the option and was set, false otherwise.")
+{
+   return object->selectOptionByKey(row, optionKey);
+}
+
+DefineEngineMethod(GuiGameListMenuCtrl, selectOptionByIndex, bool, (S32 row, S32 optionIndex), ,
+   "Set the row's current option to the one at the specified index.\n\n"
+   "@param row Index of the row to set an option on.\n"
+   "@param optionIndex The index of the option to be made active.\n"
+   "@return True if the index was valid and the option and was set, false otherwise.")
+{
+   return object->selectOptionByIndex(row, optionIndex);
+}
+
 DefineEngineMethod(GuiGameListMenuCtrl, setOptions, void, (S32 row, const char* optionsList), ,
    "Sets the list of options on the given row.\n\n"
    "@param row Index of the row to set options on."
@@ -1583,6 +1703,16 @@ DefineEngineMethod(GuiGameListMenuCtrl, setOptions, void, (S32 row, const char*
    object->setOptions(row, optionsList);
 }
 
+DefineEngineMethod(GuiGameListMenuCtrl, addOption, void, (S32 row, const char* displayText, const char* keyText), (""),
+   "Adds an option to the list of options on the given row.\n\n"
+   "@param row Index of the row to add the option on.\n"
+   "@param displayText The text to display for this option.\n"
+   "@param keyText [Optional] The id string to associate with this value. "
+   "If unset, the id will be the same as the display text.\n")
+{
+   object->addOption(row, displayText, keyText);
+}
+
 DefineEngineMethod(GuiGameListMenuCtrl, getValue, F32, (S32 row), ,
    "Sets the list of options on the given row.\n\n"
    "@param row Index of the row to set options on."
diff --git a/Engine/source/gui/controls/guiGameListMenuCtrl.h b/Engine/source/gui/controls/guiGameListMenuCtrl.h
index 15bbf49a3..3e6c3c7b0 100644
--- a/Engine/source/gui/controls/guiGameListMenuCtrl.h
+++ b/Engine/source/gui/controls/guiGameListMenuCtrl.h
@@ -37,6 +37,18 @@ public:
    typedef GuiGameListMenuProfile Profile;
 
 protected:
+
+   /// \struct OptionEntry
+   /// Display text and ID key for each entry in an option row.
+   struct OptionEntry
+   {
+      StringTableEntry mDisplayText;   ///< The text that is displayed for the option
+      StringTableEntry mKeyString;     ///< Key value that is associated with this option
+      OptionEntry() : mDisplayText(StringTable->EmptyString()), mKeyString(StringTable->EmptyString()) {}
+      virtual ~OptionEntry() {}
+   };
+
+
    /// \struct Row
    /// Internal data representation of a single row in the control.
    struct Row
@@ -60,7 +72,7 @@ protected:
       Mode mMode;
 
       //List options
-      Vector<StringTableEntry>   mOptions;         ///< Collection of options available to display
+      Vector<OptionEntry>        mOptions;         ///< Collection of options available to display
       S32                        mSelectedOption;  ///< Index into mOptions pointing at the selected option
       bool                       mWrapOptions;     ///< Determines if options should "wrap around" at the ends
 
@@ -174,13 +186,43 @@ public:
    /// string is returned.
    StringTableEntry getCurrentOption(S32 rowIndex) const;
 
+   /// Gets the key string for the currently selected option of the given row
+   ///
+   /// \param rowIndex Index of the row to get the option from.
+   /// \return The key (or id) that was assigned to the selected option on the
+   ///  given row. If there is no selected option then the empty string is returned.
+   StringTableEntry getCurrentOptionKey(S32 rowIndex) const;
+
+   /// Gets the index into the option list for the currently selected option of the given row.
+   ///
+   /// \param rowIndex Index of the row to get the option from.
+   /// \return The index of the selected option on the given row. If there is no
+   /// selected option then -1 is returned.
+   S32 getCurrentOptionIndex(S32 rowIndex) const;
+
    /// Attempts to set the given row to the specified selected option. The option
    /// will only be set if the option exists in the control.
    ///
    /// \param rowIndex Index of the row to set an option on.
    /// \param option The option to be made active.
    /// \return True if the row contained the option and was set, false otherwise.
-   bool selectOption(S32 rowIndex, StringTableEntry option);
+   bool selectOption(S32 rowIndex, const char* option);
+
+   /// Attempts to set the given row to the option with the specified key. The
+   /// option will only be set if the key exists in the control.
+   ///
+   /// \param rowIndex Index of the row to set an option on.
+   /// \param optionKey The key string that was assigned to the option to be made active.
+   /// \return True if the row contained the key and the option and was set, false otherwise.
+   bool selectOptionByKey(S32 rowIndex, const char* optionKey);
+
+   /// Attempts to set the given row to the option at the specified index. The option
+   /// will only be set if the index is valid.
+   ///
+   /// \param rowIndex Index of the row to set an option on.
+   /// \param optionIndex The index of the option to be made active.
+   /// \return True if the index was valid and the option and was set, false otherwise.
+   bool selectOptionByIndex(S32 rowIndex, S32 optionIndex);
 
    /// Sets the list of options on the given row.
    ///
@@ -188,6 +230,14 @@ public:
    /// \param optionsList A tab separated list of options for the control.
    void setOptions(S32 rowIndex, const char* optionsList);
 
+   /// Adds an option to the list of options on the given row.
+   ///
+   /// \param rowIndex Index of the row to set options on.
+   /// \param displayText The text to display for this option.
+   /// \param keyText The id string to associate with this value. If NULL the
+   ///  id will be the same as the display text.
+   void addOption(S32 rowIndex, const char* displayText, const char* keyText);
+
    /// Activates the current row. The script callback of  the current row will
    /// be called (if it has one).
    virtual void activateRow();

From 7cb306b65a3b5551b4ae4c80a001e27e3c162bcc Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Sat, 25 Sep 2021 22:39:40 -0400
Subject: [PATCH 107/399] macos platform fixes for intel macs

---
 Engine/source/platform/platform.h             |   6 +-
 Engine/source/platform/platformCPU.cpp        |  53 +-
 Engine/source/platform/platformCPUCount.cpp   | 657 ------------------
 Engine/source/platform/platformCPUCount.h     |  11 +-
 Engine/source/platform/threads/threadPool.cpp |   3 +-
 Engine/source/platformMac/macCPU.mm           | 287 ++++----
 6 files changed, 132 insertions(+), 885 deletions(-)
 delete mode 100644 Engine/source/platform/platformCPUCount.cpp

diff --git a/Engine/source/platform/platform.h b/Engine/source/platform/platform.h
index 35cd1a687..4d8d22f3c 100644
--- a/Engine/source/platform/platform.h
+++ b/Engine/source/platform/platform.h
@@ -73,9 +73,10 @@ enum ProcessorProperties
    CPU_PROP_RDTSC     = (1<<5),  ///< Supports Read Time Stamp Counter op.
    CPU_PROP_SSE2      = (1<<6),  ///< Supports SSE2 instruction set extension.
    CPU_PROP_SSE3      = (1<<7),  ///< Supports SSE3 instruction set extension.  
-   CPU_PROP_SSE3xt    = (1<<8),  ///< Supports extended SSE3 instruction set  
+   CPU_PROP_SSE3ex    = (1<<8),  ///< Supports extended SSE3 instruction set  
    CPU_PROP_SSE4_1    = (1<<9),  ///< Supports SSE4_1 instruction set extension.  
-   CPU_PROP_SSE4_2    = (1<<10), ///< Supports SSE4_2 instruction set extension.  
+   CPU_PROP_SSE4_2    = (1<<10), ///< Supports SSE4_2 instruction set extension.
+   CPU_PROP_AVX       = (1<<11), ///< Supports AVX256 instruction set extension.
    CPU_PROP_MP        = (1<<11), ///< This is a multi-processor system.
    CPU_PROP_LE        = (1<<12), ///< This processor is LITTLE ENDIAN.  
    CPU_PROP_64bit     = (1<<13), ///< This processor is 64-bit capable
@@ -297,7 +298,6 @@ namespace Platform
             bool           isHyperThreaded;
             U32            numLogicalProcessors;
             U32            numPhysicalProcessors;
-            U32            numAvailableCores;
             U32            properties;      // CPU type specific enum
          } processor;
    };
diff --git a/Engine/source/platform/platformCPU.cpp b/Engine/source/platform/platformCPU.cpp
index d0a852431..8449d1daa 100644
--- a/Engine/source/platform/platformCPU.cpp
+++ b/Engine/source/platform/platformCPU.cpp
@@ -28,48 +28,8 @@
 
 Signal<void(void)> Platform::SystemInfoReady;
 
-enum CPUFlags
+void SetProcessoInfo(Platform::SystemInfo_struct::Processor& pInfo, char* vendor, char* brand)
 {
-   // EDX Register flags
-   BIT_RDTSC   = BIT(4),
-   BIT_MMX     = BIT(23),
-   BIT_SSE     = BIT(25),
-   BIT_SSE2    = BIT(26),
-   BIT_3DNOW   = BIT(31), // only available for amd cpus in x86
-
-   // These use a different value for comparison than the above flags (ECX Register)
-   BIT_SSE3    = BIT(0),
-   BIT_SSE3xt  = BIT(9),
-   BIT_SSE4_1  = BIT(19),
-   BIT_SSE4_2  = BIT(20),
-};
-
-// fill the specified structure with information obtained from asm code
-void SetProcessorInfo(Platform::SystemInfo_struct::Processor& pInfo,
-   char* vendor, char* brand, U32 processor, U32 properties, U32 properties2)
-{
-   // always assume FPU is available in 2021...
-   pInfo.properties |= CPU_PROP_FPU;
-
-#if defined(TORQUE_CPU_X86) || defined(TORQUE_CPU_X64) || defined(TORQUE_CPU_ARM64)
-   pInfo.properties |= CPU_PROP_LE;
-#endif
-
-#if defined(TORQUE_CPU_X64) || defined(TORQUE_CPU_ARM64)
-   pInfo.properties |= CPU_PROP_64bit;
-#endif
-
-#if defined(TORQUE_CPU_X86) || defined(TORQUE_CPU_X64)
-   pInfo.properties |= (properties & BIT_RDTSC)   ? CPU_PROP_RDTSC : 0;
-   pInfo.properties |= (properties & BIT_MMX)     ? CPU_PROP_MMX : 0;
-   pInfo.properties |= (properties & BIT_SSE)     ? CPU_PROP_SSE : 0;
-   pInfo.properties |= (properties & BIT_SSE2)    ? CPU_PROP_SSE2 : 0;
-   pInfo.properties |= (properties2 & BIT_SSE3)   ? CPU_PROP_SSE3 : 0;
-   pInfo.properties |= (properties2 & BIT_SSE3xt) ? CPU_PROP_SSE3xt : 0;
-   pInfo.properties |= (properties2 & BIT_SSE4_1) ? CPU_PROP_SSE4_1 : 0;
-   pInfo.properties |= (properties2 & BIT_SSE4_2) ? CPU_PROP_SSE4_2 : 0;
-#endif
-
    if (dStricmp(vendor, "GenuineIntel") == 0)
    {
       pInfo.type = CPU_Intel;
@@ -80,9 +40,6 @@ void SetProcessorInfo(Platform::SystemInfo_struct::Processor& pInfo,
    {
       pInfo.name = StringTable->insert(brand ? brand : "AMD (unknown)");
       pInfo.type = CPU_AMD;
-
-      // 3dnow! is only available in AMD cpus on x86. Otherwise its not reliably set.
-      pInfo.properties |= (properties & BIT_3DNOW) ? CPU_PROP_3DNOW : 0;
    }
    else if (dStricmp(vendor, "Apple") == 0)
    {
@@ -92,18 +49,22 @@ void SetProcessorInfo(Platform::SystemInfo_struct::Processor& pInfo,
    else
    {
 #if defined(TORQUE_CPU_X86) || defined(TORQUE_CPU_X64)
+      
       pInfo.name = StringTable->insert(brand ? brand : "x86 Compatible (unknown)");
       pInfo.type = CPU_X86Compatible;
+      
 #elif defined(TORQUE_CPU_ARM64)
       pInfo.name = StringTable->insert(brand ? brand : "Arm Compatible (unknown)");
       pInfo.type = CPU_ArmCompatible;
+      
 #else
 #error "Unknown CPU Architecture"
+      
 #endif
    }
-
+   
    // Get multithreading caps.
-   CPUInfo::EConfig config = CPUInfo::CPUCount( pInfo.numLogicalProcessors, pInfo.numAvailableCores, pInfo.numPhysicalProcessors );
+   CPUInfo::EConfig config = CPUInfo::CPUCount( pInfo.numLogicalProcessors, pInfo.numPhysicalProcessors );
    pInfo.isHyperThreaded = CPUInfo::isHyperThreaded( config );
    pInfo.isMultiCore = CPUInfo::isMultiCore( config );
 
diff --git a/Engine/source/platform/platformCPUCount.cpp b/Engine/source/platform/platformCPUCount.cpp
deleted file mode 100644
index a3fe99d67..000000000
--- a/Engine/source/platform/platformCPUCount.cpp
+++ /dev/null
@@ -1,657 +0,0 @@
-// Original code is:
-// Copyright (c) 2005 Intel Corporation 
-// All Rights Reserved
-//
-// CPUCount.cpp : Detects three forms of hardware multi-threading support across IA-32 platform
-//					The three forms of HW multithreading are: Multi-processor, Multi-core, and 
-//					HyperThreading Technology.
-//					This application enumerates all the logical processors enabled by OS and BIOS,
-//					determine the HW topology of these enabled logical processors in the system 
-//					using information provided by CPUID instruction.
-//					A multi-processing system can support any combination of the three forms of HW
-//					multi-threading support. The relevant topology can be identified using a 
-//					three level decomposition of the "initial APIC ID" into 
-//					Package_id, core_id, and SMT_id. Such decomposition provides a three-level map of 
-//					the topology of hardware resources and
-//					allow multi-threaded software to manage shared hardware resources in 
-//					the platform to reduce resource contention
-
-//					Multicore detection algorithm for processor and cache topology requires
-//					all leaf functions of CPUID instructions be available. System administrator
-//					must ensure BIOS settings is not configured to restrict CPUID functionalities.
-//-------------------------------------------------------------------------------------------------
-
-#if defined(TORQUE_OS_LINUX) || defined(LINUX)
-
-// TODO GCC code don't compile on Release with optimizations, mover code to platform layer
-
-#else
-
-#include "platform/platform.h"
-#include "platform/platformCPUCount.h"
-
-#if defined(TORQUE_OS_LINUX) || defined(TORQUE_OS_OSX)
-
-#ifdef TORQUE_OS_LINUX
-// 	The Linux source code listing can be compiled using Linux kernel verison 2.6 
-//	or higher (e.g. RH 4AS-2.8 using GCC 3.4.4). 
-//	Due to syntax variances of Linux affinity APIs with earlier kernel versions 
-//	and dependence on glibc library versions, compilation on Linux environment 
-//	with older kernels and compilers may require kernel patches or compiler upgrades.
-
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <sched.h>
-#define DWORD unsigned long
-#elif defined( TORQUE_OS_WIN )
-#include <windows.h>
-#elif defined( TORQUE_OS_MAC )
-#  include <sys/types.h>
-#  include <sys/sysctl.h>
-#else
-#error Not implemented on platform.
-#endif
-#include <stdio.h>
-#include <assert.h>
-
-namespace CPUInfo {
-
-#define HWD_MT_BIT         0x10000000     // EDX[28]  Bit 28 is set if HT or multi-core is supported
-#define NUM_LOGICAL_BITS   0x00FF0000     // EBX[23:16] Bit 16-23 in ebx contains the number of logical
-      // processors per physical processor when execute cpuid with 
-      // eax set to 1
-#define NUM_CORE_BITS      0xFC000000     // EAX[31:26] Bit 26-31 in eax contains the number of cores minus one
-      // per physical processor when execute cpuid with 
-      // eax set to 4. 
-
-
-#define INITIAL_APIC_ID_BITS  0xFF000000  // EBX[31:24] Bits 24-31 (8 bits) return the 8-bit unique 
-      // initial APIC ID for the processor this code is running on.
-
-
-      #ifndef TORQUE_OS_MAC
-      static U32  CpuIDSupported(void);      
-      static U32  find_maskwidth(unsigned int);
-      static U32  HWD_MTSupported(void);
-      static U32  MaxLogicalProcPerPhysicalProc(void);
-      static U32  MaxCorePerPhysicalProc(void);
-      static U8 GetAPIC_ID(void);
-      static U8 GetNzbSubID(U8, U8, U8);
-      #endif
-
-      static char g_s3Levels[2048];
-
-#ifndef TORQUE_OS_MAC
-
-      //
-      // CpuIDSupported will return 0 if CPUID instruction is unavailable. Otherwise, it will return 
-      // the maximum supported standard function.
-      //
-      static U32 CpuIDSupported(void)
-      {
-         U32 maxInputValue = 0;
-         // If CPUID instruction is supported
-#ifdef TORQUE_COMPILER_GCC
-         try    
-         {		
-            // call cpuid with eax = 0
-            asm
-               (
-               "pushl %%ebx\n\t"
-               "xorl %%eax,%%eax\n\t"
-               "cpuid\n\t"
-               "popl %%ebx\n\t"
-               : "=a" (maxInputValue)
-               : 
-               : "%ecx", "%edx"
-               );		
-         }
-         catch (...)
-         {
-            return(0);                   // cpuid instruction is unavailable
-         }
-#elif defined( TORQUE_COMPILER_VISUALC )
-         try
-         {
-            // call cpuid with eax = 0
-            __asm
-            {
-               xor eax, eax
-                  cpuid
-                  mov maxInputValue, eax
-            }
-         }
-         catch (...)
-         {
-            // cpuid instruction is unavailable
-         }
-#else
-#  error Not implemented.
-#endif
-
-         return maxInputValue;
-      }
-
-
-
-      //
-      // Function returns the maximum cores per physical package. Note that the number of 
-      // AVAILABLE cores per physical to be used by an application might be less than this
-      // maximum value.
-      //
-
-      static U32 MaxCorePerPhysicalProc(void)
-      {
-
-         U32 Regeax        = 0;
-
-         if (!HWD_MTSupported()) return (U32) 1;  // Single core
-#ifdef TORQUE_COMPILER_GCC
-         {
-            asm
-               (
-               "pushl %ebx\n\t"
-               "xorl %eax, %eax\n\t"
-               "cpuid\n\t"
-               "cmpl $4, %eax\n\t"			// check if cpuid supports leaf 4
-               "jl .single_core\n\t"		// Single core
-               "movl $4, %eax\n\t"		
-               "movl $0, %ecx\n\t"			// start with index = 0; Leaf 4 reports
-               "popl %ebx\n\t"
-               );								// at least one valid cache level
-            asm
-               (
-               "cpuid"
-               : "=a" (Regeax)
-               :
-               : "%ecx", "%edx"
-               );		
-            asm
-               (
-               "jmp .multi_core\n"
-               ".single_core:\n\t"
-               "xor %eax, %eax\n"
-               ".multi_core:"
-               );		
-         }
-#elif defined( TORQUE_COMPILER_VISUALC )
-         __asm
-         {
-            xor eax, eax
-               cpuid
-               cmp eax, 4			// check if cpuid supports leaf 4
-               jl single_core		// Single core
-               mov eax, 4			
-               mov ecx, 0			// start with index = 0; Leaf 4 reports
-               cpuid				// at least one valid cache level
-               mov Regeax, eax
-               jmp multi_core
-
-single_core:
-            xor eax, eax		
-
-multi_core:
-
-         }
-#else
-#  error Not implemented.
-#endif
-         return (U32)((Regeax & NUM_CORE_BITS) >> 26)+1;
-
-      }
-
-
-
-      //
-      // The function returns 0 when the hardware multi-threaded bit is not set.
-      //
-      static U32 HWD_MTSupported(void)
-      {
-
-
-         U32 Regedx      = 0;
-
-
-         if ((CpuIDSupported() >= 1))
-         {
-#ifdef TORQUE_COMPILER_GCC
-            asm 
-               (
-               "pushl %%ebx\n\t"
-               "movl $1,%%eax\n\t"
-               "cpuid\n\t"
-               "popl %%ebx\n\t"
-               : "=d" (Regedx)
-               :
-               : "%eax","%ecx"
-               );
-#elif defined( TORQUE_COMPILER_VISUALC )
-            __asm
-            {
-               mov eax, 1
-                  cpuid
-                  mov Regedx, edx
-            }		
-#else
-#  error Not implemented.
-#endif
-         }
-
-         return (Regedx & HWD_MT_BIT);  
-
-
-      }
-
-
-
-      //
-      // Function returns the maximum logical processors per physical package. Note that the number of 
-      // AVAILABLE logical processors per physical to be used by an application might be less than this
-      // maximum value.
-      //
-      static U32 MaxLogicalProcPerPhysicalProc(void)
-      {
-
-         U32 Regebx = 0;
-
-         if (!HWD_MTSupported()) return (U32) 1;
-#ifdef TORQUE_COMPILER_GCC
-         asm 
-            (
-            "movl $1,%%eax\n\t"
-            "cpuid"
-            : "=b" (Regebx)
-            :
-            : "%eax","%ecx","%edx"
-            );
-#elif defined( TORQUE_COMPILER_VISUALC )
-         __asm
-         {
-            mov eax, 1
-               cpuid
-               mov Regebx, ebx
-         }
-#else
-#  error Not implemented.
-#endif
-         return (unsigned int) ((Regebx & NUM_LOGICAL_BITS) >> 16);
-
-      }
-
-
-      static U8 GetAPIC_ID(void)
-      {
-
-         U32 Regebx = 0;
-#ifdef TORQUE_COMPILER_GCC
-         asm
-            (
-            "movl $1, %%eax\n\t"	
-            "cpuid"
-            : "=b" (Regebx) 
-            :
-            : "%eax","%ecx","%edx" 
-            );
-
-#elif defined( TORQUE_COMPILER_VISUALC )
-         __asm
-         {
-            mov eax, 1
-               cpuid
-               mov Regebx, ebx
-         }
-#else
-#  error Not implemented.
-#endif                                
-
-         return (unsigned char) ((Regebx & INITIAL_APIC_ID_BITS) >> 24);
-
-      }
-
-      //
-      // Determine the width of the bit field that can represent the value count_item. 
-      //
-      U32 find_maskwidth(U32 CountItem)
-      {
-         U32 MaskWidth,
-            count = CountItem;
-#ifdef TORQUE_COMPILER_GCC
-         asm
-            (
-#ifdef __x86_64__		// define constant to compile  
-            "push %%rcx\n\t"		// under 64-bit Linux
-            "push %%rax\n\t"
-#else
-            "pushl %%ecx\n\t"
-            "pushl %%eax\n\t"
-#endif
-            //		"movl $count, %%eax\n\t" //done by Assembler below
-            "xorl %%ecx, %%ecx"
-            //		"movl %%ecx, MaskWidth\n\t" //done by Assembler below
-            : "=c" (MaskWidth)
-            : "a" (count)
-            //		: "%ecx", "%eax" We don't list these as clobbered because we don't want the assembler
-            //to put them back when we are done
-            );
-         asm
-            (
-            "decl %%eax\n\t"
-            "bsrw %%ax,%%cx\n\t"
-            "jz next\n\t"
-            "incw %%cx\n\t"
-            //		"movl %%ecx, MaskWidth\n" //done by Assembler below
-            : "=c" (MaskWidth)
-            :
-         );
-         asm
-            (
-            "next:\n\t"
-#ifdef __x86_64__
-            "pop %rax\n\t"
-            "pop %rcx"		
-#else
-            "popl %eax\n\t"
-            "popl %ecx"		
-#endif
-            );
-
-#elif defined( TORQUE_COMPILER_VISUALC )
-         __asm
-         {
-            mov eax, count
-               mov ecx, 0
-               mov MaskWidth, ecx
-               dec eax
-               bsr cx, ax
-               jz next
-               inc cx
-               mov MaskWidth, ecx
-next:
-
-         }
-#else
-#  error Not implemented.
-#endif
-         return MaskWidth;
-      }
-
-
-      //
-      // Extract the subset of bit field from the 8-bit value FullID.  It returns the 8-bit sub ID value
-      //
-      static U8 GetNzbSubID(U8 FullID,
-         U8 MaxSubIDValue,
-         U8 ShiftCount)
-      {
-         U32 MaskWidth;
-         U8 MaskBits;
-
-         MaskWidth = find_maskwidth((U32) MaxSubIDValue);
-         MaskBits  = (0xff << ShiftCount) ^ 
-            ((U8) (0xff << (ShiftCount + MaskWidth)));
-
-         return (FullID & MaskBits);
-      }
-
-#endif
-
-
-      //
-      //
-      //
-      EConfig CPUCount(U32& TotAvailLogical, U32& TotAvailCore, U32& PhysicalNum)
-      {
-         EConfig StatusFlag = CONFIG_UserConfigIssue;
-
-         g_s3Levels[0] = 0;
-         TotAvailCore = 1;
-         PhysicalNum  = 1;
-         
-         U32 numLPEnabled = 0;
-         S32 MaxLPPerCore = 1;
-
-#ifdef TORQUE_OS_MAC
-
-         //FIXME: This isn't a proper port but more or less just some sneaky cheating
-         //  to get around having to mess with yet another crap UNIX-style API.  Seems
-         //  like there isn't a way to do this that's working across all OSX incarnations
-         //  and machine configurations anyway.
-
-         S32 numCPUs;
-         S32 numPackages;
-
-         // Get the number of CPUs.
-
-         size_t len = sizeof( numCPUs );
-         if( sysctlbyname( "hw.ncpu", &numCPUs, &len, 0, 0 ) == -1 )
-            return CONFIG_UserConfigIssue;
-
-         // Get the number of packages.
-         len = sizeof( numPackages );
-         if( sysctlbyname( "hw.packages", &numPackages, &len, 0, 0 ) == -1 )
-            return CONFIG_UserConfigIssue;
-
-         TotAvailCore = numCPUs;
-         TotAvailLogical = numCPUs;
-         PhysicalNum = numPackages;
-#else
-
-         U32 dwAffinityMask;
-         S32 j = 0;
-         U8 apicID, PackageIDMask;
-         U8 tblPkgID[256], tblCoreID[256], tblSMTID[256];
-         char	tmp[256];
-
-#ifdef TORQUE_OS_LINUX
-         //we need to make sure that this process is allowed to run on 
-         //all of the logical processors that the OS itself can run on.
-         //A process could acquire/inherit affinity settings that restricts the 
-         // current process to run on a subset of all logical processor visible to OS.
-
-         // Linux doesn't easily allow us to look at the Affinity Bitmask directly,
-         // but it does provide an API to test affinity maskbits of the current process 
-         // against each logical processor visible under OS.
-         S32 sysNumProcs = sysconf(_SC_NPROCESSORS_CONF); //This will tell us how many 
-         //CPUs are currently enabled.
-
-         //this will tell us which processors this process can run on. 
-         cpu_set_t allowedCPUs;	 
-         sched_getaffinity(0, sizeof(allowedCPUs), &allowedCPUs);
-
-         for (S32 i = 0; i < sysNumProcs; i++ )
-         {
-            if ( CPU_ISSET(i, &allowedCPUs) == 0 )
-               return CONFIG_UserConfigIssue;
-         }
-#elif defined( TORQUE_OS_WIN )
-         DWORD dwProcessAffinity, dwSystemAffinity;
-         GetProcessAffinityMask(GetCurrentProcess(), 
-            &dwProcessAffinity,
-            &dwSystemAffinity);
-         if (dwProcessAffinity != dwSystemAffinity)  // not all CPUs are enabled
-            return CONFIG_UserConfigIssue;
-#else
-#  error Not implemented.
-#endif
-
-         // Assume that cores within a package have the SAME number of 
-         // logical processors.  Also, values returned by
-         // MaxLogicalProcPerPhysicalProc and MaxCorePerPhysicalProc do not have
-         // to be power of 2.
-
-         MaxLPPerCore = MaxLogicalProcPerPhysicalProc() / MaxCorePerPhysicalProc();
-         dwAffinityMask = 1;
-
-#ifdef TORQUE_OS_LINUX
-         cpu_set_t currentCPU;
-         while ( j < sysNumProcs )
-         {
-            CPU_ZERO(&currentCPU);
-            CPU_SET(j, &currentCPU);
-            if ( sched_setaffinity (0, sizeof(currentCPU), &currentCPU) == 0 )
-            {
-               sleep(0);  // Ensure system to switch to the right CPU
-#elif defined( TORQUE_OS_WIN )
-         while (dwAffinityMask && dwAffinityMask <= dwSystemAffinity)
-         {
-            if (SetThreadAffinityMask(GetCurrentThread(), dwAffinityMask))
-            {
-               Sleep(0);  // Ensure system to switch to the right CPU
-#else
-#  error Not implemented.
-#endif
-               apicID = GetAPIC_ID();
-
-
-               // Store SMT ID and core ID of each logical processor
-               // Shift vlaue for SMT ID is 0
-               // Shift value for core ID is the mask width for maximum logical
-               // processors per core
-
-               tblSMTID[j]  = GetNzbSubID(apicID, MaxLPPerCore, 0);
-               U8 maxCorePPP = MaxCorePerPhysicalProc();
-               U8 maskWidth = find_maskwidth(MaxLPPerCore);
-               tblCoreID[j] = GetNzbSubID(apicID, maxCorePPP, maskWidth);
-
-               // Extract package ID, assume single cluster.
-               // Shift value is the mask width for max Logical per package
-
-               PackageIDMask = (unsigned char) (0xff << 
-                  find_maskwidth(MaxLogicalProcPerPhysicalProc()));
-
-               tblPkgID[j] = apicID & PackageIDMask;
-               sprintf(tmp,"  AffinityMask = %d; Initial APIC = %d; Physical ID = %d, Core ID = %d,  SMT ID = %d\n",
-                  dwAffinityMask, apicID, tblPkgID[j], tblCoreID[j], tblSMTID[j]);
-               dStrcat(g_s3Levels, tmp, 2048);
-
-               numLPEnabled ++;   // Number of available logical processors in the system.
-
-            } // if
-
-            j++;  
-            dwAffinityMask = 1 << j;
-         } // while
-
-         // restore the affinity setting to its original state
-#ifdef TORQUE_OS_LINUX
-         sched_setaffinity (0, sizeof(allowedCPUs), &allowedCPUs);
-         sleep(0);
-#elif defined( TORQUE_OS_WIN )
-         SetThreadAffinityMask(GetCurrentThread(), dwProcessAffinity);
-         Sleep(0);
-#else
-#  error Not implemented.
-#endif
-         TotAvailLogical = numLPEnabled;
-
-         //
-         // Count available cores (TotAvailCore) in the system
-         //
-         U8 CoreIDBucket[256];
-         DWORD ProcessorMask, pCoreMask[256];
-         U32 i, ProcessorNum;
-
-         CoreIDBucket[0] = tblPkgID[0] | tblCoreID[0];
-         ProcessorMask = 1;
-         pCoreMask[0] = ProcessorMask;
-
-         for (ProcessorNum = 1; ProcessorNum < numLPEnabled; ProcessorNum++)
-         {
-            ProcessorMask <<= 1;
-            for (i = 0; i < TotAvailCore; i++)
-            {
-               // Comparing bit-fields of logical processors residing in different packages
-               // Assuming the bit-masks are the same on all processors in the system.
-               if ((tblPkgID[ProcessorNum] | tblCoreID[ProcessorNum]) == CoreIDBucket[i])
-               {
-                  pCoreMask[i] |= ProcessorMask;
-                  break;
-               }
-
-            }  // for i
-
-            if (i == TotAvailCore)   // did not match any bucket.  Start a new one.
-            {
-               CoreIDBucket[i] = tblPkgID[ProcessorNum] | tblCoreID[ProcessorNum];
-               pCoreMask[i] = ProcessorMask;
-
-               TotAvailCore++;	// Number of available cores in the system
-
-            }
-
-         }  // for ProcessorNum
-
-
-         //
-         // Count physical processor (PhysicalNum) in the system
-         //
-         U8 PackageIDBucket[256];
-         DWORD pPackageMask[256];
-
-         PackageIDBucket[0] = tblPkgID[0];
-         ProcessorMask = 1;
-         pPackageMask[0] = ProcessorMask;
-
-         for (ProcessorNum = 1; ProcessorNum < numLPEnabled; ProcessorNum++)
-         {
-            ProcessorMask <<= 1;
-            for (i = 0; i < PhysicalNum; i++)
-            {
-               // Comparing bit-fields of logical processors residing in different packages
-               // Assuming the bit-masks are the same on all processors in the system.
-               if (tblPkgID[ProcessorNum]== PackageIDBucket[i])
-               {
-                  pPackageMask[i] |= ProcessorMask;
-                  break;
-               }
-
-            }  // for i
-
-            if (i == PhysicalNum)   // did not match any bucket.  Start a new one.
-            {
-               PackageIDBucket[i] = tblPkgID[ProcessorNum];
-               pPackageMask[i] = ProcessorMask;
-
-               PhysicalNum++;	// Total number of physical processors in the system
-
-            }
-
-         }  // for ProcessorNum
-#endif
-
-         //
-         // Check to see if the system is multi-core 
-         // Check if the system is hyper-threading
-         //
-         if (TotAvailCore > PhysicalNum) 
-         {
-            // Multi-core
-            if (MaxLPPerCore == 1)
-               StatusFlag = CONFIG_MultiCoreAndHTNotCapable;
-            else if (numLPEnabled > TotAvailCore)
-               StatusFlag = CONFIG_MultiCoreAndHTEnabled;
-            else StatusFlag = CONFIG_MultiCoreAndHTDisabled;
-
-         }
-         else
-         {
-            // Single-core
-            if (MaxLPPerCore == 1)
-               StatusFlag = CONFIG_SingleCoreAndHTNotCapable;
-            else if (numLPEnabled > TotAvailCore)
-               StatusFlag = CONFIG_SingleCoreHTEnabled;
-            else StatusFlag = CONFIG_SingleCoreHTDisabled;
-
-
-         }
-
-
-
-         return StatusFlag;
-      }
-
-} // namespace CPUInfo
-#endif
-
-#endif
diff --git a/Engine/source/platform/platformCPUCount.h b/Engine/source/platform/platformCPUCount.h
index 2ee07c2eb..d008201b3 100644
--- a/Engine/source/platform/platformCPUCount.h
+++ b/Engine/source/platform/platformCPUCount.h
@@ -29,13 +29,10 @@ namespace CPUInfo
 {
    enum EConfig
    {
-      CONFIG_UserConfigIssue,
       CONFIG_SingleCoreHTEnabled,
-      CONFIG_SingleCoreHTDisabled,
       CONFIG_SingleCoreAndHTNotCapable,
       CONFIG_MultiCoreAndHTNotCapable,
       CONFIG_MultiCoreAndHTEnabled,
-      CONFIG_MultiCoreAndHTDisabled,
    };
 
    inline bool isMultiCore( EConfig config )
@@ -44,7 +41,6 @@ namespace CPUInfo
       {
       case CONFIG_MultiCoreAndHTNotCapable:
       case CONFIG_MultiCoreAndHTEnabled:
-      case CONFIG_MultiCoreAndHTDisabled:
          return true;
 
       default:
@@ -65,11 +61,10 @@ namespace CPUInfo
       }
    }
 
-   EConfig CPUCount( U32& totalAvailableLogical,
-      U32& totalAvailableCores,
-      U32& numPhysical );
-
+   EConfig CPUCount( U32& totalAvailableLogical, U32& totalAvailableCores );
 } // namespace CPUInfo
 
+void SetProcessoInfo(Platform::SystemInfo_struct::Processor& pInfo, char* vendor, char* brand);
+
 #endif // _TORQUE_PLATFORM_PLATFORMCOUNT_H_
 
diff --git a/Engine/source/platform/threads/threadPool.cpp b/Engine/source/platform/threads/threadPool.cpp
index 86402522f..1cad50dda 100644
--- a/Engine/source/platform/threads/threadPool.cpp
+++ b/Engine/source/platform/threads/threadPool.cpp
@@ -322,10 +322,9 @@ ThreadPool::ThreadPool( const char* name, U32 numThreads )
       // Platform::SystemInfo will not yet have been initialized.
       
       U32 numLogical = 0;
-      U32 numPhysical = 0;
       U32 numCores = 0;
 
-      CPUInfo::CPUCount( numLogical, numCores, numPhysical );
+      CPUInfo::CPUCount( numLogical, numCores );
       
       const U32 baseCount = getMax( numLogical, numCores );
       mNumThreads = (baseCount > 0) ? baseCount : 2;
diff --git a/Engine/source/platformMac/macCPU.mm b/Engine/source/platformMac/macCPU.mm
index 24a1a8a62..8987cff75 100644
--- a/Engine/source/platformMac/macCPU.mm
+++ b/Engine/source/platformMac/macCPU.mm
@@ -35,15 +35,6 @@
 // we now have to use NSProcessInfo
 #import <Foundation/Foundation.h>
 
-//recently removed in Xcode 8 - most likely don't need these anymore
-#ifndef CPUFAMILY_INTEL_YONAH
-#define CPUFAMILY_INTEL_YONAH		0x73d67300
-#endif
-
-#ifndef CPUFAMILY_INTEL_MEROM
-#define CPUFAMILY_INTEL_MEROM		0x426f69ef
-#endif
-
 // Original code by Sean O'Brien (http://www.garagegames.com/community/forums/viewthread/81815).
 
 
@@ -89,8 +80,58 @@ int _getSysCTLvalue(const char key[], T * dest) {
 
 Platform::SystemInfo_struct Platform::SystemInfo;
 
-#define BASE_MHZ_SPEED      0
-//TODO update cpu list
+#define BASE_MHZ_SPEED 1000
+
+static void detectCpuFeatures(U32 &procflags)
+{
+   // Now we can directly query the system about a litany of "Optional" processor capabilities
+   // and determine the status by using BOTH the 'err' value and the 'lraw' value. If we request
+   // a non-existant feature from SYSCTL(), the 'err' result will be -1; 0 denotes it exists
+   // >>>> BUT <<<<<
+   // it may not be supported, only defined. Thus we need to check 'lraw' to determine if it's
+   // actually supported/implemented by the processor: 0 = no, 1 = yes, others are undefined.
+   
+   int err;
+   U32 lraw;
+   
+   // List of chip-specific features
+   err = _getSysCTLvalue<U32>("hw.optional.mmx", &lraw);
+   if ((err==0)&&(lraw==1))
+      procflags |= CPU_PROP_MMX;
+   err = _getSysCTLvalue<U32>("hw.optional.sse", &lraw);
+   if ((err==0)&&(lraw==1))
+      procflags |= CPU_PROP_SSE;
+   err = _getSysCTLvalue<U32>("hw.optional.sse2", &lraw);
+   if ((err==0)&&(lraw==1))
+      procflags |= CPU_PROP_SSE2;
+   err = _getSysCTLvalue<U32>("hw.optional.sse3", &lraw);
+   if ((err==0)&&(lraw==1))
+      procflags |= CPU_PROP_SSE3;
+   err = _getSysCTLvalue<U32>("hw.optional.supplementalsse3", &lraw);
+   if ((err==0)&&(lraw==1))
+      procflags |= CPU_PROP_SSE3ex;
+   err = _getSysCTLvalue<U32>("hw.optional.sse4_1", &lraw);
+   if ((err==0)&&(lraw==1))
+      procflags |= CPU_PROP_SSE4_1;
+   err = _getSysCTLvalue<U32>("hw.optional.sse4_2", &lraw);
+   if ((err==0)&&(lraw==1))
+      procflags |= CPU_PROP_SSE4_2;
+   err = _getSysCTLvalue<U32>("hw.optional.avx1_0", &lraw);
+   if ((err==0)&&(lraw==1))
+      procflags |= CPU_PROP_AVX;
+
+   err = _getSysCTLvalue<U32>("hw.ncpu", &lraw);
+   if ((err==0)&&(lraw>1))
+      procflags |= CPU_PROP_MP;
+   err = _getSysCTLvalue<U32>("hw.cpu64bit_capable", &lraw);
+   if ((err==0)&&(lraw==1))
+      procflags |= CPU_PROP_64bit;
+   err = _getSysCTLvalue<U32>("hw.byteorder", &lraw);
+   if ((err==0)&&(lraw==1234))
+      procflags |= CPU_PROP_LE;
+   
+}
+
 void Processor::init()
 {
 	U32 procflags;
@@ -98,178 +139,64 @@ void Processor::init()
 	char buf[255];
 	U32 lraw;
 	U64 llraw;
-	
-	Con::printf( "System & Processor Information:" );
 
-   // Gestalt has been deprecated since Mac OSX Mountain Lion and has stopped working on
-   // Mac OSX Yosemite. we have to use NSProcessInfo now.
    // Availability: Mac OS 10.2 or greater.
    NSString *osVersionStr = [[NSProcessInfo processInfo] operatingSystemVersionString];
-   Con::printf( "   OSX Version: %s", [osVersionStr UTF8String]);
-	
-	err = _getSysCTLstring("kern.ostype", buf, sizeof(buf));	
-	if (err)
-		Con::printf( "   Unable to determine OS type\n" );
-	else
-		Con::printf( "   Mac OS Kernel name: %s", buf);
-	
-	err = _getSysCTLstring("kern.osrelease", buf, sizeof(buf));	
-	if (err)
-		Con::printf( "   Unable to determine OS release number\n" );
-	else
-		Con::printf( "   Mac OS Kernel version: %s", buf );
-	
+
+   S32 ramMB;
 	err = _getSysCTLvalue<U64>("hw.memsize", &llraw);
 	if (err)
-		Con::printf( "   Unable to determine amount of physical RAM\n" );
+      ramMB = 512;
 	else
-		Con::printf( "   Physical memory installed: %d MB", (llraw >> 20));
-	
-	err = _getSysCTLvalue<U32>("hw.usermem", &lraw);
-	if (err)
-		Con::printf( "   Unable to determine available user address space\n");
-	else
-		Con::printf( "   Addressable user memory: %d MB", (lraw >> 20));
-	
-	////////////////////////////////
-	// Values for the Family Type, CPU Type and CPU Subtype are defined in the
-	// SDK files for the Mach Kernel ==>  mach/machine.h
-	////////////////////////////////
-	
-	// CPU Family, Type, and Subtype
-	cpufam = 0;
-	cputype = 0;
-	cpusub = 0;
-	err = _getSysCTLvalue<U32>("hw.cpufamily", &lraw);
-	if (err)
-		Con::printf( "   Unable to determine 'family' of CPU\n");
-	else {
-		cpufam = (int) lraw;
-		err = _getSysCTLvalue<U32>("hw.cputype", &lraw);
-		if (err)
-			Con::printf( "   Unable to determine CPU type\n");
-		else {
-			cputype = (int) lraw;
-			err = _getSysCTLvalue<U32>("hw.cpusubtype", &lraw);
-			if (err)
-				Con::printf( "   Unable to determine CPU subtype\n");
-			else
-				cpusub = (int) lraw;
-			// If we've made it this far, 
-			Con::printf( "   Installed processor ID: Family 0x%08x  Type %d  Subtype %d",cpufam, cputype,cpusub);
-		}
-	}
+      ramMB = llraw >> 20;
 	
+   char brandString[256];
+   err = _getSysCTLstring("machdep.cpu.brand_string", brandString, sizeof(brandString));
+   if (err)
+      brandString[0] = '\0';
+   
+   char vendor[256];
+   err = _getSysCTLstring("machdep.cpu.vendor", vendor, sizeof(vendor));
+   if (err)
+      vendor[0] = '\0';
+   
 	// The Gestalt version was known to have issues with some Processor Upgrade cards
 	// but it is uncertain whether this version has similar issues.
 	err = _getSysCTLvalue<U64>("hw.cpufrequency", &llraw);
 	if (err) {
 		llraw = BASE_MHZ_SPEED;
-		Con::printf( "   Unable to determine CPU Frequency. Defaulting to %d MHz\n", llraw);
 	} else {
 		llraw /= 1000000;
-		Con::printf( "   Installed processor clock frequency: %d MHz", llraw);
 	}
 	Platform::SystemInfo.processor.mhz = (unsigned int)llraw;
 	
-	// Here's one that the original version of this routine couldn't do -- number
-	// of processors (cores)
-   U32 ncpu = 1;
-	err = _getSysCTLvalue<U32>("hw.ncpu", &lraw);
-	if (err)
-		Con::printf( "   Unable to determine number of processor cores\n");
-	else
-   {
-      ncpu = lraw;
-		Con::printf( "   Installed/available processor cores: %d", lraw);
-   }
-	
-	// Now use CPUFAM to determine and then store the processor type
-	// and 'friendly name' in GG-accessible structure. Note that since
-	// we have access to the Family code, the Type and Subtypes are useless.
-	//
-	// NOTE: Even this level of detail is almost assuredly not needed anymore
-	// and the Optional Capability flags (further down) should be more than enough.
-	switch(cpufam)
-	{
-		case CPUFAMILY_INTEL_YONAH:
-			Platform::SystemInfo.processor.type = CPU_Intel_Core;
-         if( ncpu == 2 )
-            Platform::SystemInfo.processor.name = StringTable->insert("Intel Core Duo");
-         else
-            Platform::SystemInfo.processor.name = StringTable->insert("Intel Core");
-			break;
-      case CPUFAMILY_INTEL_PENRYN:
-		case CPUFAMILY_INTEL_MEROM:
-			Platform::SystemInfo.processor.type = CPU_Intel_Core2;
-         if( ncpu == 4 )
-            Platform::SystemInfo.processor.name = StringTable->insert("Intel Core 2 Quad");
-         else
-            Platform::SystemInfo.processor.name = StringTable->insert("Intel Core 2 Duo");
-			break;
-         
-      case CPUFAMILY_INTEL_NEHALEM:
-         Platform::SystemInfo.processor.type = CPU_Intel_Core2;
-         Platform::SystemInfo.processor.name = StringTable->insert( "Intel 'Nehalem' Core Processor" );
-         break;
-      
-		default:
-			// explain why we can't get the processor type.
-			Con::warnf( "   Unknown Processor (family, type, subtype): 0x%x\t%d  %d", cpufam, cputype, cpusub);
-			// for now, identify it as an x86 processor, because Apple is moving to Intel chips...
-			Platform::SystemInfo.processor.type = CPU_X86Compatible;
-			Platform::SystemInfo.processor.name = StringTable->insert("Unknown Processor, assuming x86 Compatible");
-			break;
-	}
-   // Now we can directly query the system about a litany of "Optional" processor capabilities
-	// and determine the status by using BOTH the 'err' value and the 'lraw' value. If we request
-	// a non-existant feature from SYSCTL(), the 'err' result will be -1; 0 denotes it exists 
-	// >>>> BUT <<<<<
-	// it may not be supported, only defined. Thus we need to check 'lraw' to determine if it's 
-	// actually supported/implemented by the processor: 0 = no, 1 = yes, others are undefined.
-	procflags = 0;
-	// Seriously this one should be an Assert()
-	err = _getSysCTLvalue<U32>("hw.optional.floatingpoint", &lraw);
-	if ((err==0)&&(lraw==1)) procflags |= CPU_PROP_FPU;
-	// List of chip-specific features
-	err = _getSysCTLvalue<U32>("hw.optional.mmx", &lraw);
-	if ((err==0)&&(lraw==1)) procflags |= CPU_PROP_MMX;
-	err = _getSysCTLvalue<U32>("hw.optional.sse", &lraw);
-	if ((err==0)&&(lraw==1)) procflags |= CPU_PROP_SSE;
-	err = _getSysCTLvalue<U32>("hw.optional.sse2", &lraw);
-	if ((err==0)&&(lraw==1)) procflags |= CPU_PROP_SSE2;
-	err = _getSysCTLvalue<U32>("hw.optional.sse3", &lraw);
-	if ((err==0)&&(lraw==1)) procflags |= CPU_PROP_SSE3;
-	err = _getSysCTLvalue<U32>("hw.optional.supplementalsse3", &lraw);
-	if ((err==0)&&(lraw==1)) procflags |= CPU_PROP_SSE3xt;
-	err = _getSysCTLvalue<U32>("hw.optional.sse4_1", &lraw);
-	if ((err==0)&&(lraw==1)) procflags |= CPU_PROP_SSE4_1;
-	err = _getSysCTLvalue<U32>("hw.optional.sse4_2", &lraw);
-	if ((err==0)&&(lraw==1)) procflags |= CPU_PROP_SSE4_2;
-
-	// Finally some architecture-wide settings
-	err = _getSysCTLvalue<U32>("hw.ncpu", &lraw);
-	if ((err==0)&&(lraw>1)) procflags |= CPU_PROP_MP;
-	err = _getSysCTLvalue<U32>("hw.cpu64bit_capable", &lraw);
-	if ((err==0)&&(lraw==1)) procflags |= CPU_PROP_64bit;
-	err = _getSysCTLvalue<U32>("hw.byteorder", &lraw);
-	if ((err==0)&&(lraw==1234)) procflags |= CPU_PROP_LE;
-
-	Platform::SystemInfo.processor.properties = procflags;
-	
-	Con::printf( "%s, %2.2f GHz", Platform::SystemInfo.processor.name, F32( Platform::SystemInfo.processor.mhz ) / 1000.0 );
+   procflags = CPU_PROP_FPU;
+   detectCpuFeatures(procflags);
+   
+   Platform::SystemInfo.processor.properties = procflags;
+   SetProcessoInfo(Platform::SystemInfo.processor, vendor, brandString);
+   
+   
+   Con::printf("System & Processor Information:");
+   Con::printf("   MacOS Version: %s", [osVersionStr UTF8String]);
+   Con::printf("   Physical memory installed: %d MB", ramMB);
+   Con::printf("   Processor: %s", Platform::SystemInfo.processor.name);
 	if (Platform::SystemInfo.processor.properties & CPU_PROP_MMX)
-		Con::printf( "   MMX detected");
+		Con::printf("      MMX detected");
 	if (Platform::SystemInfo.processor.properties & CPU_PROP_SSE)
-		Con::printf( "   SSE detected");
+		Con::printf("      SSE detected");
 	if (Platform::SystemInfo.processor.properties & CPU_PROP_SSE2)
-		Con::printf( "   SSE2 detected");
+		Con::printf("      SSE2 detected");
 	if (Platform::SystemInfo.processor.properties & CPU_PROP_SSE3)
-		Con::printf( "   SSE3 detected");
+		Con::printf("      SSE3 detected");
+   if (Platform::SystemInfo.processor.properties & CPU_PROP_SSE3ex)
+      Con::printf("      SSE3ex detected");
 	if (Platform::SystemInfo.processor.properties & CPU_PROP_SSE4_1)
-		Con::printf( "   SSE4.1 detected");
+		Con::printf("      SSE4.1 detected");
 	if (Platform::SystemInfo.processor.properties & CPU_PROP_SSE4_2)
-		Con::printf( "   SSE4.2 detected");
+		Con::printf("      SSE4.2 detected");
+   if (Platform::SystemInfo.processor.properties & CPU_PROP_AVX)
+      Con::printf("      AVX detected");
 	
 	Con::printf( "" );
    
@@ -277,16 +204,38 @@ void Processor::init()
    Platform::SystemInfoReady.trigger();
 }
 
+
 namespace CPUInfo {
-   EConfig CPUCount(U32 &logical, U32 &numCores, U32 &numPhysical) {
-      // todo properly implement this
-      logical = [[NSProcessInfo processInfo] activeProcessorCount];
-      numCores = [[NSProcessInfo processInfo] activeProcessorCount];
-      numPhysical = [[NSProcessInfo processInfo] processorCount];
+   EConfig CPUCount(U32 &logical, U32 &physical) {
+      U32 lraw;
+      int err;
       
-      // todo check for hyperthreading
-      if (numCores > 1)
-         return CONFIG_MultiCoreAndHTNotCapable;
-      return CONFIG_SingleCoreAndHTNotCapable;
+      err = _getSysCTLvalue<U32>("hw.physicalcpu", &lraw);
+      if (err == 0)
+         physical = lraw;
+      else
+         physical = 1;
+      
+      err = _getSysCTLvalue<U32>("hw.logicalcpu", &lraw);
+      if (err == 0)
+      {
+         logical = lraw;
+      }
+      else
+      {
+         // fallback to querying the number of cpus. If that fails, then assume same as number of cores
+         err = _getSysCTLvalue<U32>("hw.ncpu", &lraw);
+         if (err == 0)
+            logical = lraw;
+         else
+            logical = physical;
+      }
+      
+      const bool smtEnabled = logical > physical;
+      
+      if (physical == 1)
+         return smtEnabled ? CONFIG_SingleCoreHTEnabled : CONFIG_SingleCoreAndHTNotCapable;
+      
+      return smtEnabled ? CONFIG_MultiCoreAndHTEnabled : CONFIG_MultiCoreAndHTNotCapable;
    }
 }

From 960ea2aa5a2e74f88e6452c200d692f434cde12c Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Sat, 25 Sep 2021 22:53:34 -0400
Subject: [PATCH 108/399] Add support for Neon.

---
 Engine/source/platform/platform.h   |  1 +
 Engine/source/platformMac/macCPU.mm | 19 +++++++++++++++----
 2 files changed, 16 insertions(+), 4 deletions(-)

diff --git a/Engine/source/platform/platform.h b/Engine/source/platform/platform.h
index 4d8d22f3c..2944e596c 100644
--- a/Engine/source/platform/platform.h
+++ b/Engine/source/platform/platform.h
@@ -80,6 +80,7 @@ enum ProcessorProperties
    CPU_PROP_MP        = (1<<11), ///< This is a multi-processor system.
    CPU_PROP_LE        = (1<<12), ///< This processor is LITTLE ENDIAN.  
    CPU_PROP_64bit     = (1<<13), ///< This processor is 64-bit capable
+   CPU_PROP_NEON      = (1<<14), ///< Supports the Arm Neon instruction set extension.
 };
 
 /// Processor info manager. 
diff --git a/Engine/source/platformMac/macCPU.mm b/Engine/source/platformMac/macCPU.mm
index 8987cff75..e961542e9 100644
--- a/Engine/source/platformMac/macCPU.mm
+++ b/Engine/source/platformMac/macCPU.mm
@@ -94,6 +94,11 @@ static void detectCpuFeatures(U32 &procflags)
    int err;
    U32 lraw;
    
+   // All Cpus have fpu
+   procflags = CPU_PROP_FPU;
+   
+#if defined(TORQUE_CPU_X86) || defined(TORQUE_CPU_X64)
+   
    // List of chip-specific features
    err = _getSysCTLvalue<U32>("hw.optional.mmx", &lraw);
    if ((err==0)&&(lraw==1))
@@ -119,6 +124,12 @@ static void detectCpuFeatures(U32 &procflags)
    err = _getSysCTLvalue<U32>("hw.optional.avx1_0", &lraw);
    if ((err==0)&&(lraw==1))
       procflags |= CPU_PROP_AVX;
+   
+#elif defined(TORQUE_CPU_ARM64)
+   // All Apple Cpus have Neon
+   procflags |= CPU_PROP_NEON;
+   
+#endif
 
    err = _getSysCTLvalue<U32>("hw.ncpu", &lraw);
    if ((err==0)&&(lraw>1))
@@ -129,12 +140,11 @@ static void detectCpuFeatures(U32 &procflags)
    err = _getSysCTLvalue<U32>("hw.byteorder", &lraw);
    if ((err==0)&&(lraw==1234))
       procflags |= CPU_PROP_LE;
-   
 }
 
 void Processor::init()
 {
-	U32 procflags;
+	U32 procflags = 0;
 	int err, cpufam, cputype, cpusub;
 	char buf[255];
 	U32 lraw;
@@ -170,7 +180,6 @@ void Processor::init()
 	}
 	Platform::SystemInfo.processor.mhz = (unsigned int)llraw;
 	
-   procflags = CPU_PROP_FPU;
    detectCpuFeatures(procflags);
    
    Platform::SystemInfo.processor.properties = procflags;
@@ -197,7 +206,9 @@ void Processor::init()
 		Con::printf("      SSE4.2 detected");
    if (Platform::SystemInfo.processor.properties & CPU_PROP_AVX)
       Con::printf("      AVX detected");
-	
+	if (Platform::SystemInfo.processor.properties & CPU_PROP_NEON)
+      Con::printf("      Neon detected");
+   
 	Con::printf( "" );
    
    // Trigger the signal

From 2181ce08c3264a2809c4a3e7c51a282f1e89a20e Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Sun, 26 Sep 2021 03:12:14 -0500
Subject: [PATCH 109/399] lightning ref fixes

---
 Engine/source/T3D/fx/lightning.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Engine/source/T3D/fx/lightning.cpp b/Engine/source/T3D/fx/lightning.cpp
index 16e234818..13051d7f4 100644
--- a/Engine/source/T3D/fx/lightning.cpp
+++ b/Engine/source/T3D/fx/lightning.cpp
@@ -242,7 +242,7 @@ LightningData::LightningData()
 
    for (S32 i = 0; i < MaxThunders; i++)
    {
-      INIT_SOUNDASSET_ARRAY(ThunderSound, MaxThunders);
+      INIT_SOUNDASSET_ARRAY(ThunderSound, i);
    }
 
    for (S32 i = 0; i < MaxTextures; i++)
@@ -295,7 +295,7 @@ bool LightningData::preload(bool server, String &errorStr)
    if (server == false) 
    {
       for (S32 i = 0; i < MaxThunders; i++) {
-         if (mThunderSound[i])
+         if (getThunderSound(i))
          {
             _setThunderSound(getThunderSound(i), i);
          }
@@ -314,7 +314,7 @@ bool LightningData::preload(bool server, String &errorStr)
       {
          if (strikeTextureNames[k][0])
          {
-            strikeTextures[k] = GFXTexHandle(strikeTextureNames[i], &GFXStaticTextureProfile, avar("%s() - strikeTextures[%d] (line %d)", __FUNCTION__, k, __LINE__));
+            strikeTextures[k] = GFXTexHandle(strikeTextureNames[k], &GFXStaticTextureProfile, avar("%s() - strikeTextures[%d] (line %d)", __FUNCTION__, k, __LINE__));
             mNumStrikeTextures++;
          }
       }

From dba08998874f1b843535a9cbde36862cebfc4506 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Sun, 26 Sep 2021 17:30:13 -0500
Subject: [PATCH 110/399] soundasset augments: get<name>Profile methods, test
 for emptystring, initialize asset arrays lightning provides a conversion
 sample (attempt. it's still yelling)

---
 Engine/source/T3D/assets/SoundAsset.h | 15 +++++++++++++++
 Engine/source/T3D/fx/lightning.cpp    | 12 ++++++------
 Engine/source/T3D/fx/lightning.h      | 16 ----------------
 3 files changed, 21 insertions(+), 22 deletions(-)

diff --git a/Engine/source/T3D/assets/SoundAsset.h b/Engine/source/T3D/assets/SoundAsset.h
index adacf2d9b..df0ac0d6b 100644
--- a/Engine/source/T3D/assets/SoundAsset.h
+++ b/Engine/source/T3D/assets/SoundAsset.h
@@ -262,6 +262,12 @@ public: \
    Resource<SFXResource> get##name##Resource() \
    {\
       return m##name;\
+   }\
+   SFXProfile* get##name##Profile()\
+   {\
+      if (get##name() != StringTable->EmptyString() && m##name##Asset.notNull())\
+         return m##name##Asset->getSfxProfile();\
+      return NULL;\
    }
 
 #define DECLARE_SOUNDASSET_SETGET(className, name)\
@@ -436,6 +442,8 @@ public: \
       {\
          m##name[index] = NULL;\
       }\
+      if(get##name(index) == StringTable->EmptyString())\
+         return true;\
       \
       if (m##name##Asset[index].notNull() && m##name##Asset[index]->getStatus() != SoundAsset::Ok)\
       {\
@@ -466,6 +474,12 @@ public: \
       if(id >= sm##name##Count || id < 0)\
          return ResourceManager::get().load( "" );\
       return m##name[id];\
+   }\
+   SFXProfile* get##name##Profile(const U32& id)\
+   {\
+      if (get##name(id) != StringTable->EmptyString() && m##name##Asset[id].notNull())\
+         return m##name##Asset[id]->getSfxProfile();\
+      return NULL;\
    }
 
 #define DECLARE_SOUNDASSET_ARRAY_SETGET(className, name)\
@@ -517,6 +531,7 @@ DefineEngineMethod(className, set##name, bool, (const char* map, S32 index), , a
    m##name##Name[index] = StringTable->EmptyString(); \
    m##name##AssetId[index] = StringTable->EmptyString(); \
    m##name##Asset[index] = NULL;\
+   m##name[index] = NULL;\
 }
 
 #ifdef TORQUE_SHOW_LEGACY_FILE_FIELDS
diff --git a/Engine/source/T3D/fx/lightning.cpp b/Engine/source/T3D/fx/lightning.cpp
index 13051d7f4..2f16f4cc0 100644
--- a/Engine/source/T3D/fx/lightning.cpp
+++ b/Engine/source/T3D/fx/lightning.cpp
@@ -302,11 +302,11 @@ bool LightningData::preload(bool server, String &errorStr)
       }
 
       for (U32 j = 0; j < MaxThunders; j++) {
-         if (!getThunderProfile(j))
+         if (!getThunderSoundProfile(j))
             Con::errorf(ConsoleLogEntry::General, "LightningData::preload: Cant get an sfxProfile for thunder.");
       }
 
-      if(!getSFXProfile())
+      if(!getStrikeSoundProfile())
          Con::errorf(ConsoleLogEntry::General, "LightningData::preload: can't get sfxProfile from asset");
 
       mNumStrikeTextures = 0;
@@ -584,7 +584,7 @@ void Lightning::scheduleThunder(Strike* newStrike)
          if (t <= 0.03f) {
             // If it's really close, just play it...
             U32 thunder = sgLightningRand.randI(0, mDataBlock->numThunders - 1);
-            SFX->playOnce(mDataBlock->getThunderProfile(thunder));
+            SFX->playOnce(mDataBlock->getThunderSoundProfile(thunder));
          } else {
             Thunder* pThunder = new Thunder;
             pThunder->tRemaining = t;
@@ -651,7 +651,7 @@ void Lightning::advanceTime(F32 dt)
 
          // Play the sound...
          U32 thunder = sgLightningRand.randI(0, mDataBlock->numThunders - 1);
-         SFX->playOnce(mDataBlock->getThunderProfile(thunder));
+         SFX->playOnce(mDataBlock->getThunderSoundProfile(thunder));
       } else {
          pThunderWalker = &((*pThunderWalker)->next);
       }
@@ -735,9 +735,9 @@ void Lightning::processEvent(LightningStrikeEvent* pEvent)
       MatrixF trans(true);
       trans.setPosition( strikePoint );
 
-      if (mDataBlock->getSFXProfile())
+      if (mDataBlock->getStrikeSoundProfile())
       {
-         SFX->playOnce(mDataBlock->getSFXProfile(), &trans );
+         SFX->playOnce(mDataBlock->getStrikeSoundProfile(), &trans );
       }
 
 }
diff --git a/Engine/source/T3D/fx/lightning.h b/Engine/source/T3D/fx/lightning.h
index f639db3b2..d241257b0 100644
--- a/Engine/source/T3D/fx/lightning.h
+++ b/Engine/source/T3D/fx/lightning.h
@@ -92,22 +92,6 @@ class LightningData : public GameBaseData
 
    DECLARE_CONOBJECT(LightningData);
    static void initPersistFields();
-
-   SFXProfile* getThunderProfile(U32 id)
-   {
-      if (mThunderSoundAsset[id] != NULL)
-         return mThunderSoundAsset[id]->getSfxProfile();
-
-      return NULL;
-   }
-
-   SFXProfile* getSFXProfile() {
-      if (mStrikeSoundAsset.notNull())
-         return mStrikeSoundAsset->getSfxProfile();
-
-      return NULL;
-   }
-
 };
 
 

From 7b137c2ee8127511c98abedfa35a139338b12a6b Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Sun, 26 Sep 2021 17:30:57 -0500
Subject: [PATCH 111/399] genProcessor("LightningData"... attempt. will need to
 re-review.

---
 .../projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
index 645bd38ca..d9eec5f2e 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
@@ -845,6 +845,7 @@ T3Dpre4ProjectImporter::genProcessor("afxModelData", "shapeName shapeAsset shape
 T3Dpre4ProjectImporter::genProcessor("afxZodiacData", "texture textureAsset");
 T3Dpre4ProjectImporter::genProcessor("afxZodiacPlaneData", "texture textureAsset");
 T3Dpre4ProjectImporter::genProcessor("sfxEmitter", "track soundAsset filename soundAsset");
+T3Dpre4ProjectImporter::genProcessor("LightningData", "thunderSounds ThunderSoundAsset strikeSound StrikeSoundAsset");
 //==============================================================================
 // Levels
 //==============================================================================

From eb92a8927e37f782d785a2201b46d9c28b43689b Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Sun, 26 Sep 2021 19:36:12 -0400
Subject: [PATCH 112/399] M1 Support for cpu detection

---
 Engine/source/platform/platform.h   |  8 ++++----
 Engine/source/platformMac/macCPU.mm | 15 +++++++++++----
 2 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/Engine/source/platform/platform.h b/Engine/source/platform/platform.h
index 2944e596c..f8239f817 100644
--- a/Engine/source/platform/platform.h
+++ b/Engine/source/platform/platform.h
@@ -77,10 +77,10 @@ enum ProcessorProperties
    CPU_PROP_SSE4_1    = (1<<9),  ///< Supports SSE4_1 instruction set extension.  
    CPU_PROP_SSE4_2    = (1<<10), ///< Supports SSE4_2 instruction set extension.
    CPU_PROP_AVX       = (1<<11), ///< Supports AVX256 instruction set extension.
-   CPU_PROP_MP        = (1<<11), ///< This is a multi-processor system.
-   CPU_PROP_LE        = (1<<12), ///< This processor is LITTLE ENDIAN.  
-   CPU_PROP_64bit     = (1<<13), ///< This processor is 64-bit capable
-   CPU_PROP_NEON      = (1<<14), ///< Supports the Arm Neon instruction set extension.
+   CPU_PROP_MP        = (1<<12), ///< This is a multi-processor system.
+   CPU_PROP_LE        = (1<<13), ///< This processor is LITTLE ENDIAN.
+   CPU_PROP_64bit     = (1<<14), ///< This processor is 64-bit capable
+   CPU_PROP_NEON      = (1<<15), ///< Supports the Arm Neon instruction set extension.
 };
 
 /// Processor info manager. 
diff --git a/Engine/source/platformMac/macCPU.mm b/Engine/source/platformMac/macCPU.mm
index e961542e9..96cf068a9 100644
--- a/Engine/source/platformMac/macCPU.mm
+++ b/Engine/source/platformMac/macCPU.mm
@@ -81,6 +81,7 @@ int _getSysCTLvalue(const char key[], T * dest) {
 Platform::SystemInfo_struct Platform::SystemInfo;
 
 #define BASE_MHZ_SPEED 1000
+#define BASE_APPLE_SILICON_MHZ_SPEED 3200
 
 static void detectCpuFeatures(U32 &procflags)
 {
@@ -126,8 +127,10 @@ static void detectCpuFeatures(U32 &procflags)
       procflags |= CPU_PROP_AVX;
    
 #elif defined(TORQUE_CPU_ARM64)
-   // All Apple Cpus have Neon
-   procflags |= CPU_PROP_NEON;
+   
+   err = _getSysCTLvalue<U32>("hw.optional.neon", &lraw);
+   if ((err==0)&&(lraw==1))
+      procflags |= CPU_PROP_NEON;
    
 #endif
 
@@ -170,11 +173,15 @@ void Processor::init()
    if (err)
       vendor[0] = '\0';
    
-	// The Gestalt version was known to have issues with some Processor Upgrade cards
-	// but it is uncertain whether this version has similar issues.
+   // Note: hw.cpufrequency seems to be missing on the M1. For Apple Silicon,
+   // we will assume the base frequency of the M1 which is 3.2ghz
 	err = _getSysCTLvalue<U64>("hw.cpufrequency", &llraw);
 	if (err) {
+#if defined(TORQUE_CPU_ARM64)
+      llraw = BASE_APPLE_SILICON_MHZ_SPEED;
+#else
 		llraw = BASE_MHZ_SPEED;
+#endif
 	} else {
 		llraw /= 1000000;
 	}

From ef652ad8b9ee12d9ab11e000aa85335bc97a28e2 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Sun, 26 Sep 2021 20:07:49 -0500
Subject: [PATCH 113/399] clean out of the manual getSFXProfile() methods

---
 Engine/source/T3D/fx/explosion.cpp     | 4 ++--
 Engine/source/T3D/fx/explosion.h       | 7 -------
 Engine/source/T3D/fx/precipitation.cpp | 6 +++---
 Engine/source/T3D/fx/precipitation.h   | 7 -------
 Engine/source/T3D/fx/splash.cpp        | 4 ++--
 Engine/source/T3D/fx/splash.h          | 8 --------
 Engine/source/T3D/projectile.cpp       | 2 +-
 Engine/source/T3D/projectile.h         | 7 -------
 8 files changed, 8 insertions(+), 37 deletions(-)

diff --git a/Engine/source/T3D/fx/explosion.cpp b/Engine/source/T3D/fx/explosion.cpp
index 6fc59b825..d770e2f36 100644
--- a/Engine/source/T3D/fx/explosion.cpp
+++ b/Engine/source/T3D/fx/explosion.cpp
@@ -859,7 +859,7 @@ bool ExplosionData::preload(bool server, String &errorStr)
    if (Parent::preload(server, errorStr) == false)
       return false;
 
-   if (!server && !getSFXProfile())
+   if (!server && !getSoundProfile())
       return false;
 
    if( !server )
@@ -1382,7 +1382,7 @@ bool Explosion::explode()
       resetWorldBox();
    }
 
-   SFXProfile* sound_prof = mDataBlock->getSFXProfile();
+   SFXProfile* sound_prof = mDataBlock->getSoundProfile();
    if (sound_prof)
    {
       soundProfile_clone = sound_prof->cloneAndPerformSubstitutions(ss_object, ss_index);
diff --git a/Engine/source/T3D/fx/explosion.h b/Engine/source/T3D/fx/explosion.h
index 37694dd1e..41116cd32 100644
--- a/Engine/source/T3D/fx/explosion.h
+++ b/Engine/source/T3D/fx/explosion.h
@@ -73,13 +73,6 @@ class ExplosionData : public GameBaseData {
    DECLARE_SOUNDASSET(ExplosionData, Sound);
    DECLARE_SOUNDASSET_SETGET(ExplosionData, Sound);
 
-   SFXProfile* getSFXProfile() {
-      if (mSoundAsset.notNull())
-         return mSoundAsset->getSfxProfile();
-
-      return NULL;
-   }
-
    ParticleEmitterData* particleEmitter;
    S32                  particleEmitterId;
 
diff --git a/Engine/source/T3D/fx/precipitation.cpp b/Engine/source/T3D/fx/precipitation.cpp
index 4356cd45f..bf3246dc9 100644
--- a/Engine/source/T3D/fx/precipitation.cpp
+++ b/Engine/source/T3D/fx/precipitation.cpp
@@ -189,7 +189,7 @@ bool PrecipitationData::preload( bool server, String &errorStr )
    if( Parent::preload( server, errorStr) == false)
       return false;
 
-   if (!server && !getSFXProfile())
+   if (!server && !getSoundProfile())
       return false;
 
    return true;
@@ -597,9 +597,9 @@ bool Precipitation::onNewDataBlock( GameBaseData *dptr, bool reload )
    {
       SFX_DELETE( mAmbientSound );
 
-      if ( mDataBlock->getSFXProfile())
+      if ( mDataBlock->getSoundProfile())
       {
-         mAmbientSound = SFX->createSource(mDataBlock->getSFXProfile(), &getTransform() );
+         mAmbientSound = SFX->createSource(mDataBlock->getSoundProfile(), &getTransform() );
          if ( mAmbientSound )
             mAmbientSound->play();
       }
diff --git a/Engine/source/T3D/fx/precipitation.h b/Engine/source/T3D/fx/precipitation.h
index f9eb4bf02..719613384 100644
--- a/Engine/source/T3D/fx/precipitation.h
+++ b/Engine/source/T3D/fx/precipitation.h
@@ -71,13 +71,6 @@ class PrecipitationData : public GameBaseData
 
       void onDropChanged() {}
       void onSplashChanged() {}
-
-      SFXProfile* getSFXProfile() {
-         if (mSoundAsset.notNull())
-            return mSoundAsset->getSfxProfile();
-
-         return NULL;
-      }
 };
 
 struct Raindrop
diff --git a/Engine/source/T3D/fx/splash.cpp b/Engine/source/T3D/fx/splash.cpp
index c046ef1a0..d1230e5c5 100644
--- a/Engine/source/T3D/fx/splash.cpp
+++ b/Engine/source/T3D/fx/splash.cpp
@@ -276,7 +276,7 @@ bool SplashData::preload(bool server, String &errorStr)
    if (Parent::preload(server, errorStr) == false)
       return false;
 
-   if (!server && !getSFXProfile())
+   if (!server && !getSoundProfile())
       return false;
 
    if (!server)
@@ -681,7 +681,7 @@ void Splash::spawnExplosion()
 
    /// could just play the explosion one, but explosion could be weapon specific,
    /// splash sound could be liquid specific. food for thought.
-   SFXProfile* sound_prof = mDataBlock->getSFXProfile();
+   SFXProfile* sound_prof = mDataBlock->getSoundProfile();
    if (sound_prof)
    {
       SFX->playOnce(sound_prof, &getTransform());
diff --git a/Engine/source/T3D/fx/splash.h b/Engine/source/T3D/fx/splash.h
index fec9f601e..4cde2db00 100644
--- a/Engine/source/T3D/fx/splash.h
+++ b/Engine/source/T3D/fx/splash.h
@@ -98,14 +98,6 @@ public:
    DECLARE_SOUNDASSET(SplashData, Sound);
    DECLARE_SOUNDASSET_SETGET(SplashData, Sound);
 
-   /// this should probably be added as a function higher up to stop repeats.
-   SFXProfile* getSFXProfile() {
-      if (mSoundAsset.notNull())
-         return mSoundAsset->getSfxProfile();
-
-      return NULL;
-   }
-
    ParticleEmitterData*    emitterList[NUM_EMITTERS];
    S32                     emitterIDList[NUM_EMITTERS];
 
diff --git a/Engine/source/T3D/projectile.cpp b/Engine/source/T3D/projectile.cpp
index d7532e368..a88276f73 100644
--- a/Engine/source/T3D/projectile.cpp
+++ b/Engine/source/T3D/projectile.cpp
@@ -882,7 +882,7 @@ bool Projectile::onNewDataBlock( GameBaseData *dptr, bool reload )
       SFX_DELETE( mSound );
 
       if ( mDataBlock->getProjectileSound() )
-         mSound = SFX->createSource( mDataBlock->getSFXProfile() );
+         mSound = SFX->createSource( mDataBlock->getProjectileSoundProfile() );
    }
 
    return true;
diff --git a/Engine/source/T3D/projectile.h b/Engine/source/T3D/projectile.h
index 69bb84001..e633e3fd4 100644
--- a/Engine/source/T3D/projectile.h
+++ b/Engine/source/T3D/projectile.h
@@ -118,13 +118,6 @@ public:
 
    DECLARE_SOUNDASSET(ProjectileData, ProjectileSound);
    DECLARE_SOUNDASSET_SETGET(ProjectileData, ProjectileSound);
-
-   SFXProfile* getSFXProfile() {
-      if (mProjectileSoundAsset.notNull())
-         return mProjectileSoundAsset->getSfxProfile();
-
-      return NULL;
-   }
    
    LightDescription *lightDesc;
    S32 lightDescId;   

From 24e5db942be6a33c2946ba20d846249efb6e4540 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Sun, 26 Sep 2021 23:43:06 -0400
Subject: [PATCH 114/399] flush out windows cpu detection.

---
 Engine/source/platform/platform.h             |  21 +-
 Engine/source/platform/platformCPUInfo.asm    | 128 ------------
 Engine/source/platformMac/macCPU.mm           |   5 +-
 Engine/source/platformWin32/winCPUInfo.cpp    | 192 ++++++++++--------
 .../platformWin32/winPlatformCPUCount.cpp     |  38 ++--
 5 files changed, 136 insertions(+), 248 deletions(-)
 delete mode 100644 Engine/source/platform/platformCPUInfo.asm

diff --git a/Engine/source/platform/platform.h b/Engine/source/platform/platform.h
index f8239f817..6073786b7 100644
--- a/Engine/source/platform/platform.h
+++ b/Engine/source/platform/platform.h
@@ -70,17 +70,16 @@ enum ProcessorProperties
    CPU_PROP_MMX       = (1<<2),  ///< Supports MMX instruction set extension.
    CPU_PROP_3DNOW     = (1<<3),  ///< Supports AMD 3dNow! instruction set extension.
    CPU_PROP_SSE       = (1<<4),  ///< Supports SSE instruction set extension.
-   CPU_PROP_RDTSC     = (1<<5),  ///< Supports Read Time Stamp Counter op.
-   CPU_PROP_SSE2      = (1<<6),  ///< Supports SSE2 instruction set extension.
-   CPU_PROP_SSE3      = (1<<7),  ///< Supports SSE3 instruction set extension.  
-   CPU_PROP_SSE3ex    = (1<<8),  ///< Supports extended SSE3 instruction set  
-   CPU_PROP_SSE4_1    = (1<<9),  ///< Supports SSE4_1 instruction set extension.  
-   CPU_PROP_SSE4_2    = (1<<10), ///< Supports SSE4_2 instruction set extension.
-   CPU_PROP_AVX       = (1<<11), ///< Supports AVX256 instruction set extension.
-   CPU_PROP_MP        = (1<<12), ///< This is a multi-processor system.
-   CPU_PROP_LE        = (1<<13), ///< This processor is LITTLE ENDIAN.
-   CPU_PROP_64bit     = (1<<14), ///< This processor is 64-bit capable
-   CPU_PROP_NEON      = (1<<15), ///< Supports the Arm Neon instruction set extension.
+   CPU_PROP_SSE2      = (1<<5),  ///< Supports SSE2 instruction set extension.
+   CPU_PROP_SSE3      = (1<<6),  ///< Supports SSE3 instruction set extension.  
+   CPU_PROP_SSE3ex    = (1<<7),  ///< Supports Supplemental SSE3 instruction set  
+   CPU_PROP_SSE4_1    = (1<<8),  ///< Supports SSE4_1 instruction set extension.  
+   CPU_PROP_SSE4_2    = (1<<9),  ///< Supports SSE4_2 instruction set extension.
+   CPU_PROP_AVX       = (1<<10), ///< Supports AVX256 instruction set extension.
+   CPU_PROP_MP        = (1<<11), ///< This is a multi-processor system.
+   CPU_PROP_LE        = (1<<12), ///< This processor is LITTLE ENDIAN.
+   CPU_PROP_64bit     = (1<<13), ///< This processor is 64-bit capable
+   CPU_PROP_NEON      = (1<<14), ///< Supports the Arm Neon instruction set extension.
 };
 
 /// Processor info manager. 
diff --git a/Engine/source/platform/platformCPUInfo.asm b/Engine/source/platform/platformCPUInfo.asm
deleted file mode 100644
index bce39d220..000000000
--- a/Engine/source/platform/platformCPUInfo.asm
+++ /dev/null
@@ -1,128 +0,0 @@
-;-----------------------------------------------------------------------------
-; Copyright (c) 2012 GarageGames, LLC
-;
-; Permission is hereby granted, free of charge, to any person obtaining a copy
-; of this software and associated documentation files (the "Software"), to
-; deal in the Software without restriction, including without limitation the
-; rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-; sell copies of the Software, and to permit persons to whom the Software is
-; furnished to do so, subject to the following conditions:
-;
-; The above copyright notice and this permission notice shall be included in
-; all copies or substantial portions of the Software.
-;
-; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-; IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-; FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-; AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-; LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-; FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-; IN THE SOFTWARE.
-;-----------------------------------------------------------------------------
-
-        
-segment .text
-
-; syntax: export_fn <function name>
-%macro export_fn 1
-   %ifidn __OUTPUT_FORMAT__, elf
-   ; No underscore needed for ELF object files
-   global %1
-   %1:
-   %else
-   global _%1
-   _%1:
-   %endif
-%endmacro
-
-; push registers 
-%macro pushreg 0
-;    pushad
-    push ebx
-    push ebp
-    push esi
-    push edi
-%endmacro
-
-; pop registers
-%macro popreg 0
-    pop edi
-    pop esi
-    pop ebp
-    pop ebx
-;    popad
-%endmacro
-      
-; void detectX86CPUInfo(char *vendor, U32 *processor, U32 *properties);
-export_fn detectX86CPUInfo
-   push         ebp
-   mov          ebp, esp
-
-   pushreg
-
-   push         edx
-   push         ecx
-   pushfd
-   pushfd                        ; save EFLAGS to stack
-   pop          eax              ; move EFLAGS into EAX
-   mov          ebx, eax
-   xor          eax, 0x200000    ; flip bit 21
-   push         eax
-   popfd                         ; restore EFLAGS
-   pushfd
-   pop          eax
-   cmp          eax, ebx
-   jz           EXIT             ; doesn't support CPUID instruction
-
-   ;
-   ; get vendor information using CPUID eax == 0
-   xor          eax, eax
-   cpuid
-
-   ; store the vendor tag (12 bytes in ebx, edx, ecx) in the first parameter,
-   ; which should be a char[13]
-   push         eax             ; save eax
-   mov          eax, [ebp+8]    ; store the char* address in eax
-   mov          [eax], ebx      ; move ebx into the first 4 bytes
-   add          eax, 4          ; advance the char* 4 bytes
-   mov          [eax], edx      ; move edx into the next 4 bytes
-   add          eax, 4          ; advance the char* 4 bytes
-   mov          [eax], ecx      ; move ecx into the last 4 bytes
-   pop          eax             ; restore eax
-        
-   ; get generic extended CPUID info
-   mov          eax, 1
-   cpuid                         ; eax=1, so cpuid queries feature information
-
-   and          eax, 0x0fff3fff
-   push         ecx
-   mov          ecx, [ebp+12]
-   mov          [ecx], eax      ; just store the model bits in processor param
-   mov          ecx, [ebp+16]
-   mov          [ecx], edx      ; set properties param
-   pop          ecx
-
-   ; want to check for 3DNow(tm).  
-   ; need to see if extended cpuid functions present. 
-   mov          eax, 0x80000000
-   cpuid
-   cmp          eax, 0x80000000
-   jbe          MAYBE_3DLATER
-   mov          eax, 0x80000001
-   cpuid
-   ; 3DNow if bit 31 set -> put bit in our properties        
-   and          edx, 0x80000000  
-   push         eax
-   mov          eax, [ebp+16]
-   or           [eax], edx
-   pop          eax
-MAYBE_3DLATER:
-EXIT:
-   popfd
-   pop          ecx
-   pop          edx
-
-   popreg
-
-   pop          ebp
-   ret
diff --git a/Engine/source/platformMac/macCPU.mm b/Engine/source/platformMac/macCPU.mm
index 96cf068a9..d93bcf25f 100644
--- a/Engine/source/platformMac/macCPU.mm
+++ b/Engine/source/platformMac/macCPU.mm
@@ -96,7 +96,7 @@ static void detectCpuFeatures(U32 &procflags)
    U32 lraw;
    
    // All Cpus have fpu
-   procflags = CPU_PROP_FPU;
+   procflags = CPU_PROP_C | CPU_PROP_FPU;
    
 #if defined(TORQUE_CPU_X86) || defined(TORQUE_CPU_X64)
    
@@ -215,6 +215,9 @@ void Processor::init()
       Con::printf("      AVX detected");
 	if (Platform::SystemInfo.processor.properties & CPU_PROP_NEON)
       Con::printf("      Neon detected");
+
+   if (Platform::SystemInfo.processor.properties & CPU_PROP_MP)
+      Con::printf("   MultiCore CPU detected [%i cores, %i logical]", Platform::SystemInfo.processor.numPhysicalProcessors, Platform::SystemInfo.processor.numLogicalProcessors);
    
 	Con::printf( "" );
    
diff --git a/Engine/source/platformWin32/winCPUInfo.cpp b/Engine/source/platformWin32/winCPUInfo.cpp
index 3765f5c51..f8ea9ab2d 100644
--- a/Engine/source/platformWin32/winCPUInfo.cpp
+++ b/Engine/source/platformWin32/winCPUInfo.cpp
@@ -24,49 +24,15 @@
 #include "platformWin32/platformWin32.h"
 #include "console/console.h"
 #include "core/stringTable.h"
+#include "platform/platformCPUCount.h"
 #include <math.h>
 #include <intrin.h>
 
 Platform::SystemInfo_struct Platform::SystemInfo;
 extern void PlatformBlitInit();
-extern void SetProcessorInfo(Platform::SystemInfo_struct::Processor& pInfo,
-   char* vendor, char* brand, U32 processor, U32 properties, U32 properties2); // platform/platformCPU.cc
 
-void Processor::init()
+static void getBrand(char* brand)
 {
-   // Reference:
-   //    www.cyrix.com
-   //    www.amd.com
-   //    www.intel.com
-   //       http://developer.intel.com/design/PentiumII/manuals/24512701.pdf
-
-   Con::printf("Processor Init:");
-
-   Platform::SystemInfo.processor.type = CPU_X86Compatible;
-   Platform::SystemInfo.processor.name = StringTable->insert("Unknown x86 Compatible");
-   Platform::SystemInfo.processor.mhz  = 0;
-   Platform::SystemInfo.processor.properties = CPU_PROP_C;
-
-   char  vendor[0x20];
-   dMemset(vendor, 0, sizeof(vendor));
-   U32   properties = 0;
-   U32   processor  = 0;
-   U32   properties2 = 0;
-
-   S32 vendorInfo[4];
-   __cpuid(vendorInfo, 0);
-   *reinterpret_cast<int*>(vendor) = vendorInfo[1];     // ebx
-   *reinterpret_cast<int*>(vendor + 4) = vendorInfo[3]; // edx
-   *reinterpret_cast<int*>(vendor + 8) = vendorInfo[2]; // ecx
-
-   S32 cpuInfo[4];
-   __cpuid(cpuInfo, 1);
-   processor = cpuInfo[0];   // eax
-   properties = cpuInfo[3];  // edx
-   properties2 = cpuInfo[2]; // ecx
-
-   char brand[0x40];
-   dMemset(brand, 0, sizeof(brand));
    S32 extendedInfo[4];
    __cpuid(extendedInfo, 0x80000000);
    S32 numberExtendedIds = extendedInfo[0];
@@ -88,12 +54,93 @@ void Processor::init()
          offset += sizeof(S32) * 4;
       }
    }
+}
 
-   SetProcessorInfo(Platform::SystemInfo.processor, vendor, brand, processor, properties, properties2);
+enum CpuFlags
+{
+   // EDX Register flags
+   BIT_MMX = BIT(23),
+   BIT_SSE = BIT(25),
+   BIT_SSE2 = BIT(26),
+   BIT_3DNOW = BIT(31), // only available for amd cpus in x86
 
-// now calculate speed of processor...
-   U32 nearmhz = 0; // nearest rounded mhz
-   U32 mhz = 0; // calculated value.
+   // These use a different value for comparison than the above flags (ECX Register)
+   BIT_SSE3 = BIT(0),
+   BIT_SSE3ex = BIT(9),
+   BIT_SSE4_1 = BIT(19),
+   BIT_SSE4_2 = BIT(20),
+
+   BIT_XSAVE_RESTORE = BIT(27),
+   BIT_AVX = BIT(28),
+};
+
+static void detectCpuFeatures(Platform::SystemInfo_struct::Processor &processor)
+{
+   S32 cpuInfo[4];
+   __cpuid(cpuInfo, 1);
+   U32 eax = cpuInfo[0];   // eax
+   U32 edx = cpuInfo[3];  // edx
+   U32 ecx = cpuInfo[2]; // ecx
+
+   if (processor.type == ProcessorType::CPU_AMD)
+      processor.properties |= (edx & BIT_3DNOW) ? CPU_PROP_3DNOW : 0;
+
+   processor.properties |= (edx & BIT_MMX) ? CPU_PROP_MMX : 0;
+   processor.properties |= (edx & BIT_SSE) ? CPU_PROP_SSE : 0;
+   processor.properties |= (edx & BIT_SSE2) ? CPU_PROP_SSE2 : 0;
+   processor.properties |= (ecx & BIT_SSE3) ? CPU_PROP_SSE3 : 0;
+   processor.properties |= (ecx & BIT_SSE3ex) ? CPU_PROP_SSE3ex : 0;
+   processor.properties |= (ecx & BIT_SSE4_1) ? CPU_PROP_SSE4_1 : 0;
+   processor.properties |= (ecx & BIT_SSE4_2) ? CPU_PROP_SSE4_2 : 0;
+
+   // AVX detection requires that xsaverestore is supported
+   if (ecx & BIT_XSAVE_RESTORE && ecx & BIT_AVX)
+   {
+      bool supportsAVX = _xgetbv(_XCR_XFEATURE_ENABLED_MASK) & 0x6;
+      if (supportsAVX)
+      {
+         processor.properties |= CPU_PROP_AVX;
+      }
+   }
+
+   if (processor.isMultiCore)
+      processor.properties |= CPU_PROP_MP;
+
+#ifdef TORQUE_CPU_X64
+   processor.properties |= CPU_PROP_64bit;
+#endif
+}
+
+void Processor::init()
+{
+   // Reference:
+   //    www.cyrix.com
+   //    www.amd.com
+   //    www.intel.com
+   //       http://developer.intel.com/design/PentiumII/manuals/24512701.pdf
+
+   Platform::SystemInfo.processor.type = CPU_X86Compatible;
+   Platform::SystemInfo.processor.name = StringTable->insert("Unknown x86 Compatible");
+   Platform::SystemInfo.processor.mhz  = 0;
+   Platform::SystemInfo.processor.properties = CPU_PROP_C | CPU_PROP_FPU | CPU_PROP_LE;
+
+   char  vendor[0x20];
+   dMemset(vendor, 0, sizeof(vendor));
+
+   S32 vendorInfo[4];
+   __cpuid(vendorInfo, 0);
+   *reinterpret_cast<int*>(vendor) = vendorInfo[1];     // ebx
+   *reinterpret_cast<int*>(vendor + 4) = vendorInfo[3]; // edx
+   *reinterpret_cast<int*>(vendor + 8) = vendorInfo[2]; // ecx
+
+   char brand[0x40];
+   dMemset(brand, 0, sizeof(brand));
+   getBrand(brand);
+
+   SetProcessoInfo(Platform::SystemInfo.processor, vendor, brand);
+   detectCpuFeatures(Platform::SystemInfo.processor);
+
+   U32 mhz = 1000; // default if it can't be found
 
    LONG result;
    DWORD data = 0;
@@ -107,64 +154,37 @@ void Processor::init()
       result = ::RegQueryValueExA (hKey, "~MHz",NULL, NULL,(LPBYTE)&data, &dataSize);
 
       if (result == ERROR_SUCCESS)
-         nearmhz = mhz = data;
+         mhz = data;
 
       ::RegCloseKey(hKey);
    }
 
    Platform::SystemInfo.processor.mhz = mhz;
 
-   if (mhz==0)
-   {
-      Con::printf("   %s, (Unknown) Mhz", Platform::SystemInfo.processor.name);
-      // stick SOMETHING in so it isn't ZERO.
-      Platform::SystemInfo.processor.mhz = 200; // seems a decent value.
-   }
-   else
-   {
-      if (nearmhz >= 1000)
-         Con::printf("   %s, ~%.2f Ghz", Platform::SystemInfo.processor.name, ((float)nearmhz)/1000.0f);
-      else
-         Con::printf("   %s, ~%d Mhz", Platform::SystemInfo.processor.name, nearmhz);
-      if (nearmhz != mhz)
-      {
-         if (mhz >= 1000)
-            Con::printf("     (timed at roughly %.2f Ghz)", ((float)mhz)/1000.0f);
-         else
-            Con::printf("     (timed at roughly %d Mhz)", mhz);
-      }
-   }
-
-   if( Platform::SystemInfo.processor.numAvailableCores > 0
-       || Platform::SystemInfo.processor.numPhysicalProcessors > 0
-       || Platform::SystemInfo.processor.isHyperThreaded )
-      Platform::SystemInfo.processor.properties |= CPU_PROP_MP;
-
-   if (Platform::SystemInfo.processor.properties & CPU_PROP_FPU)
-      Con::printf( "   FPU detected" );
+   Con::printf("Processor Init:");
+   Con::printf("   Processor: %s", Platform::SystemInfo.processor.name);
    if (Platform::SystemInfo.processor.properties & CPU_PROP_MMX)
-      Con::printf( "   MMX detected" );
+      Con::printf("      MMX detected" );
    if (Platform::SystemInfo.processor.properties & CPU_PROP_3DNOW)
-      Con::printf( "   3DNow detected" );
+      Con::printf("      3DNow detected" );
    if (Platform::SystemInfo.processor.properties & CPU_PROP_SSE)
-      Con::printf( "   SSE detected" );
-   if( Platform::SystemInfo.processor.properties & CPU_PROP_SSE2 )
-      Con::printf( "   SSE2 detected" );
+      Con::printf("      SSE detected" );
+   if (Platform::SystemInfo.processor.properties & CPU_PROP_SSE2)
+      Con::printf("      SSE2 detected" );
    if (Platform::SystemInfo.processor.properties & CPU_PROP_SSE3)
-      Con::printf( "   SSE3 detected" );
-   if (Platform::SystemInfo.processor.properties & CPU_PROP_SSE3xt)
-      Con::printf( "   SSE3ex detected ");
+      Con::printf("      SSE3 detected" );
+   if (Platform::SystemInfo.processor.properties & CPU_PROP_SSE3ex)
+      Con::printf("      SSE3ex detected ");
    if (Platform::SystemInfo.processor.properties & CPU_PROP_SSE4_1)
-      Con::printf( "   SSE4.1 detected" );
+      Con::printf("      SSE4.1 detected" );
    if (Platform::SystemInfo.processor.properties & CPU_PROP_SSE4_2)
-      Con::printf( "   SSE4.2 detected" );
-   if( Platform::SystemInfo.processor.isHyperThreaded )
-      Con::printf( "   HT detected" );
-   if( Platform::SystemInfo.processor.properties & CPU_PROP_MP )
-      Con::printf( "   MP detected [%i cores, %i logical, %i physical]",
-         Platform::SystemInfo.processor.numAvailableCores,
-         Platform::SystemInfo.processor.numLogicalProcessors,
-         Platform::SystemInfo.processor.numPhysicalProcessors );
+      Con::printf("      SSE4.2 detected" );
+   if (Platform::SystemInfo.processor.properties & CPU_PROP_AVX)
+      Con::printf("      AVX detected");
+
+   if (Platform::SystemInfo.processor.properties & CPU_PROP_MP)
+      Con::printf("   MultiCore CPU detected [%i cores, %i logical]", Platform::SystemInfo.processor.numPhysicalProcessors, Platform::SystemInfo.processor.numLogicalProcessors);
+
    Con::printf(" ");
    
    PlatformBlitInit();
diff --git a/Engine/source/platformWin32/winPlatformCPUCount.cpp b/Engine/source/platformWin32/winPlatformCPUCount.cpp
index e4a5d54d6..e4b113c67 100644
--- a/Engine/source/platformWin32/winPlatformCPUCount.cpp
+++ b/Engine/source/platformWin32/winPlatformCPUCount.cpp
@@ -26,6 +26,7 @@
 #if defined( TORQUE_OS_WIN )
 
 #include "platform/platformCPUCount.h"
+#include "console/console.h"
 #include <windows.h>
 #include <intrin.h>
 #include <stdio.h>
@@ -52,12 +53,10 @@ namespace CPUInfo {
       return bitSetCount;
    }
 
-   EConfig CPUCount( U32& TotAvailLogical, U32& TotAvailCore, U32& PhysicalNum )
+   EConfig CPUCount( U32& TotAvailLogical, U32& TotAvailCore )
    {
-      EConfig StatusFlag = CONFIG_UserConfigIssue;
       TotAvailLogical = 0;
       TotAvailCore = 0;
-      PhysicalNum = 0;
 
       PSYSTEM_LOGICAL_PROCESSOR_INFORMATION buffer = NULL;
       DWORD returnLength = 0;
@@ -68,42 +67,37 @@ namespace CPUInfo {
 
       rc = GetLogicalProcessorInformation( buffer, &returnLength );      
 
+      // if we fail, assume single threaded
       if( FALSE == rc )
       {           
          free( buffer );
-         return StatusFlag;
+         Con::errorf("Unable to determine CPU Count, assuming 1 core");
+         TotAvailCore = 1;
+         TotAvailLogical = 1;
+         return CONFIG_SingleCoreAndHTNotCapable;
       }      
 
+#pragma push
+#pragma warning (disable: 6011)
       PSYSTEM_LOGICAL_PROCESSOR_INFORMATION ptr = buffer;
 
       DWORD byteOffset = 0;
       while( byteOffset + sizeof( SYSTEM_LOGICAL_PROCESSOR_INFORMATION ) <= returnLength )
       {
-         switch( ptr->Relationship )
-         {         
-
-         case RelationProcessorCore:
+         if (ptr->Relationship == RelationProcessorCore)
+         {
             TotAvailCore++;
-
-            // A hyperthreaded core supplies more than one logical processor.
-            TotAvailLogical += CountSetBits( ptr->ProcessorMask );
-            break;         
-
-         case RelationProcessorPackage:
-            // Logical processors share a physical package.
-            PhysicalNum++;
-            break;
-
-         default:            
-            break;
+            TotAvailLogical += CountSetBits(ptr->ProcessorMask);
          }
+
          byteOffset += sizeof( SYSTEM_LOGICAL_PROCESSOR_INFORMATION );
          ptr++;
-      }      
+      }
 
       free( buffer );
+#pragma pop
 
-      StatusFlag = CONFIG_SingleCoreAndHTNotCapable;
+      EConfig StatusFlag = CONFIG_SingleCoreAndHTNotCapable;
 
       if( TotAvailCore == 1 && TotAvailLogical > TotAvailCore )
          StatusFlag = CONFIG_SingleCoreHTEnabled;

From 737fd70c6946f4fa6763d4597c14962bf738c28d Mon Sep 17 00:00:00 2001
From: Areloch <Areloch@gmail.com>
Date: Mon, 27 Sep 2021 18:46:20 -0500
Subject: [PATCH 115/399] Adjusted handling of field converts in the project
 importer to deal with fields that didn't contain quotation marks

---
 .../scripts/projectImporter.tscript           | 42 +++++++++----------
 1 file changed, 20 insertions(+), 22 deletions(-)

diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
index 039a71238..eca0e0b07 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
@@ -516,31 +516,24 @@ function testFilenameExtensions(%filename)
 
 function processLegacyField(%line, %originalFieldName, %newFieldName)
 {
-   if(!strIsMatchExpr("*"@%originalFieldName@"=*\"*\";*", %line) && 
-      !strIsMatchExpr("*"@%originalFieldName@"[*=*\"*\";*", %line) &&
-      !strIsMatchExpr("*"@%originalFieldName@" *=*\"*\";*", %line))
+   if(!strIsMatchExpr("*"@%originalFieldName@"=*;*", %line) && 
+      !strIsMatchExpr("*"@%originalFieldName@"[*=*;*", %line) &&
+      !strIsMatchExpr("*"@%originalFieldName@" *=*;*", %line))
       return %line;
       
    %outLine = strreplace(%line, %originalFieldName, %newFieldName);
    
    //get the value
    %value = "";
-   %pos = strpos(%outLine, "= \"");
+   %pos = strpos(%outLine, "=");
    if(%pos != -1)
    {
-     %endPos = strpos(%outLine, "\";", %pos); 
+     %endPos = strpos(%outLine, ";", %pos); 
+     %value = getSubStr(%outLine, %pos+1, %endPos-%pos-1);
      
-     %value = getSubStr(%outLine, %pos+3, %endPos-%pos-3);
-   }
-   else
-   {
-      %pos = strpos(%outLine, "=\"");
-      if(%pos != -1)
-      {
-        %endPos = strpos(%outLine, "\";", %pos); 
-        
-        %value = getSubStr(%outLine, %pos+2, %endPos-%pos-2);
-      }
+     %originalValue = %value;
+     %value = trim(%value);
+     %value = strreplace(%value, "\"", "");
    }
    
    if(%outLine !$= %line && %pos != -1 && %endPos != -1 && %value !$= "")
@@ -557,8 +550,13 @@ function processLegacyField(%line, %originalFieldName, %newFieldName)
       
       if(isObject(%targetFilename))
       {
-         if(%originalFieldName $= "soundProfile")
+         //likely a material name, so handle it that way
+         %assetId = MaterialAsset::getAssetIdByMaterialName(%targetFilename);
+           
+         if(%assetId $= "" || %assetId $= "Core_Rendering:NoMaterial")
          {
+            //if not, just do a lookup directly to see if it was another asset by that name
+            //e.g. sound profiles when converted will match names
             $ProjectImporter::assetQuery.clear();
             %foundAssets = AssetDatabase.findAssetName($ProjectImporter::assetQuery, %targetFilename);
             if(%foundAssets != 0)
@@ -566,11 +564,6 @@ function processLegacyField(%line, %originalFieldName, %newFieldName)
                %assetId = $ProjectImporter::assetQuery.getAsset(0);  
             }
          }
-         else
-         {
-            //likely a material name, so handle it that way
-            %assetId = MaterialAsset::getAssetIdByMaterialName(%targetFilename);
-         }
       }
       else
       {
@@ -605,6 +598,11 @@ function processLegacyField(%line, %originalFieldName, %newFieldName)
       if(%assetId !$= "" && AssetDatabase.isDeclaredAsset(%assetId))
       {
          echo("Legacy Project Importer - processing of legacy field line's value: " @ %value @ " has found a matching AssetId: " @ %assetId);
+         
+         //double check if this already had the quotes around the value or not
+         if(!strIsMatchExpr("*\"*\"*", %originalValue))
+            %assetId = "\"" @ %assetId @ "\"";
+         
          //if (%assetId.getStatusString() $= "Ok")
          %outLine = strReplace(%outLine, %value, %assetId);
          //else

From 44b81ace69b3141d1c4a5f8c261d55a7cf2307b9 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Mon, 27 Sep 2021 20:04:58 -0500
Subject: [PATCH 116/399] don't check a profile if we don't have a sound asset

---
 Engine/source/T3D/fx/lightning.cpp | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/Engine/source/T3D/fx/lightning.cpp b/Engine/source/T3D/fx/lightning.cpp
index 2f16f4cc0..8f1ba8bf6 100644
--- a/Engine/source/T3D/fx/lightning.cpp
+++ b/Engine/source/T3D/fx/lightning.cpp
@@ -294,19 +294,17 @@ bool LightningData::preload(bool server, String &errorStr)
    
    if (server == false) 
    {
-      for (S32 i = 0; i < MaxThunders; i++) {
+      for (S32 i = 0; i < MaxThunders; i++)
+      {
          if (getThunderSound(i))
          {
             _setThunderSound(getThunderSound(i), i);
+            if (!getThunderSoundProfile(i))
+               Con::errorf(ConsoleLogEntry::General, "LightningData::preload: Cant get an sfxProfile for thunder.");
          }
       }
 
-      for (U32 j = 0; j < MaxThunders; j++) {
-         if (!getThunderSoundProfile(j))
-            Con::errorf(ConsoleLogEntry::General, "LightningData::preload: Cant get an sfxProfile for thunder.");
-      }
-
-      if(!getStrikeSoundProfile())
+      if(getStrikeSound() && !getStrikeSoundProfile())
          Con::errorf(ConsoleLogEntry::General, "LightningData::preload: can't get sfxProfile from asset");
 
       mNumStrikeTextures = 0;

From ad0c141189a8ecfe74331115eadee0dc0f75b736 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Mon, 27 Sep 2021 21:12:27 -0500
Subject: [PATCH 117/399] use _set<assetname> for all network recipts of
 shapes, sounds, images and materials to ensure we at least try and fill that
 out whichever way is ghosted to us

---
 Engine/source/T3D/assets/ImageAsset.h    | 12 +++++++++---
 Engine/source/T3D/assets/MaterialAsset.h |  5 ++++-
 Engine/source/T3D/assets/ShapeAsset.h    | 10 ++++++++--
 Engine/source/T3D/assets/SoundAsset.h    |  5 ++++-
 4 files changed, 25 insertions(+), 7 deletions(-)

diff --git a/Engine/source/T3D/assets/ImageAsset.h b/Engine/source/T3D/assets/ImageAsset.h
index ff50ef655..b79dc5f5d 100644
--- a/Engine/source/T3D/assets/ImageAsset.h
+++ b/Engine/source/T3D/assets/ImageAsset.h
@@ -345,7 +345,6 @@ if (m##name##AssetId != StringTable->EmptyString())\
    if (stream->writeFlag(m##name##Asset.notNull()))\
    {\
       stream->writeString(m##name##Asset.getAssetId());\
-      _set##name(m##name##AssetId);\
    }\
    else\
       stream->writeString(m##name##Name);
@@ -354,9 +353,13 @@ if (m##name##AssetId != StringTable->EmptyString())\
    if (stream->readFlag())\
    {\
       m##name##AssetId = stream->readSTString();\
+      _set##name(m##name##AssetId);\
    }\
    else\
-      m##name##Name = stream->readSTString();
+   {\
+      m##name##Name = stream->readSTString();\
+      _set##name(m##name##Name);\
+   }\
 
 #define PACK_IMAGEASSET(netconn, name)\
    if (stream->writeFlag(m##name##Asset.notNull()))\
@@ -591,7 +594,10 @@ if (m##name##AssetId[index] != StringTable->EmptyString())\
       _set##name(m##name##AssetId[index], index);\
    }\
    else\
-      m##name##Name[index] = stream->readSTString();
+   {\
+      m##name##Name[index] = stream->readSTString();\
+      _set##name(m##name##Name[index], index);\
+   }\
 
 #define PACK_IMAGEASSET_ARRAY(netconn, name, index)\
    if (stream->writeFlag(m##name##Asset[index].notNull()))\
diff --git a/Engine/source/T3D/assets/MaterialAsset.h b/Engine/source/T3D/assets/MaterialAsset.h
index 07ec0227a..c747be793 100644
--- a/Engine/source/T3D/assets/MaterialAsset.h
+++ b/Engine/source/T3D/assets/MaterialAsset.h
@@ -346,7 +346,10 @@ if (m##name##AssetId != StringTable->EmptyString())\
       _set##name(m##name##AssetId);\
    }\
    else\
-      m##name##Name = stream->readSTString();
+   {\
+      m##name##Name = stream->readSTString();\
+      _set##name(m##name##Name);\
+   }\
 
 #define PACK_MATERIALASSET(netconn, name)\
    if (stream->writeFlag(m##name##Asset.notNull()))\
diff --git a/Engine/source/T3D/assets/ShapeAsset.h b/Engine/source/T3D/assets/ShapeAsset.h
index d5c899564..d3af516c5 100644
--- a/Engine/source/T3D/assets/ShapeAsset.h
+++ b/Engine/source/T3D/assets/ShapeAsset.h
@@ -397,7 +397,10 @@ DefineEngineMethod(className, set##name, bool, (const char*  shape), , assetText
       _set##name(m##name##AssetId);\
    }\
    else\
-      m##name##Name = stream->readSTString();
+   {\
+      m##name##Name = stream->readSTString();\
+      _set##name(m##name##Name);\
+   }
 
 #define PACK_SHAPEASSET(netconn, name)\
    if (stream->writeFlag(m##name##Asset.notNull()))\
@@ -609,7 +612,10 @@ DefineEngineMethod(className, set##name, bool, (const char*  shape, S32 index),
       _set##name(m##name##AssetId[index], index);\
    }\
    else\
-      m##name##Name[index] = stream->readSTString();
+   {\
+      m##name##Name[index] = stream->readSTString();\
+      _set##name(m##name##Name[index], index);\
+   }
 
 #define PACK_SHAPEASSET_ARRAY(netconn, name, index)\
    if (stream->writeFlag(m##name##Asset[index].notNull()))\
diff --git a/Engine/source/T3D/assets/SoundAsset.h b/Engine/source/T3D/assets/SoundAsset.h
index df0ac0d6b..ca83e477b 100644
--- a/Engine/source/T3D/assets/SoundAsset.h
+++ b/Engine/source/T3D/assets/SoundAsset.h
@@ -344,7 +344,10 @@ DefineEngineMethod(className, set##name, bool, (const char*  shape), , assetText
       _set##name(m##name##AssetId);\
    }\
    else\
-      m##name##Name = stream->readSTString();
+   {\
+      m##name##Name = stream->readSTString();\
+      _set##name(m##name##Name);\
+   }
 
 #define PACK_SOUNDASSET(netconn, name)\
    if (stream->writeFlag(m##name##Asset.notNull()))\

From e035aa911481d237a40c0467089df536f00883c0 Mon Sep 17 00:00:00 2001
From: OTHGMars <mmars1149@aol.com>
Date: Tue, 28 Sep 2021 05:38:17 -0400
Subject: [PATCH 118/399] GuiCanvas Callbacks Adds handler modes for keyboard
 translations and native accelerators. This is needed so APIs that provide
 software keyboards can be notified when controls that require text input
 become active. This was previously hardcoded in OpenVROverlay, but is also
 needed by Steam Input and Big Picture so moving to GuiCanvas will make it
 accessible there as well. Handler mode for both settings default to
 "Platform" so there is no change to the default behavior. If the setting is
 changed to "Callback", callbacks will be triggered to allow script to
 determine if the request should fall through to the platform window. The
 script callback is also the appropriate place to display a software keyboard
 and attach it to the input control.

---
 Engine/source/gui/core/guiCanvas.cpp | 60 +++++++++++++++++++++++++---
 Engine/source/gui/core/guiCanvas.h   | 19 +++++++++
 2 files changed, 73 insertions(+), 6 deletions(-)

diff --git a/Engine/source/gui/core/guiCanvas.cpp b/Engine/source/gui/core/guiCanvas.cpp
index 967c3e7d7..8ad674474 100644
--- a/Engine/source/gui/core/guiCanvas.cpp
+++ b/Engine/source/gui/core/guiCanvas.cpp
@@ -94,6 +94,33 @@ ConsoleDocClass( GuiCanvas,
 
    "@ingroup GuiCore\n");
 
+   ImplementEnumType(KeyboardTranslationMode,
+      "Modes for handling keyboard translation or native accelerator requests.\n\n")
+      { GuiCanvas::TranslationMode_Platform, "Platform",
+         "Requests will be passed to the platform window for handling." },
+      { GuiCanvas::TranslationMode_Callback, "Callback",
+         "Script callbacks will be issued to notify and allow override of these events." },
+      { GuiCanvas::TranslationMode_Ignore, "Ignore",
+         "Requsts to enable/disable keyboard translations or native accelerators will be ignored "
+         "with no callback triggered." },
+   EndImplementEnumType;
+
+   IMPLEMENT_CALLBACK(GuiCanvas, onSetKeyboardTranslationEnabled, bool, (bool enable), (enable),
+      "Called when the canvas receives an enableKeyboardTranslation request. This is usually the "
+      "result of a GuitTextInputCtrl gaining or losing focus. Return false to allow the request "
+      "to be passed to the platform window. Return true to override the request and handle it in script.\n\n"
+      "@note This callback is only issued if keyTranslationMode is set to \"Callback\" for this canvas.\n"
+      "@param enable Requested keyboard translation state.\n"
+      "@see KeyboardTranslationMode\n");
+
+   IMPLEMENT_CALLBACK(GuiCanvas, onSetNativeAcceleratorsEnabled, bool, (bool enable), (enable),
+      "Called when the canvas receives a setNativeAcceleratorsEnabled request. This is usually the "
+      "result of a GuitTextInputCtrl gaining or losing focus. Return false to allow the request to "
+      "be passed to the platform window. Return true to override the request and handle it in script.\n\n"
+      "@note This callback is only issued if nativeAcceleratorMode is set to \"Callback\" for this canvas.\n"
+      "@param enable Requested accelerator state.\n"
+      "@see KeyboardTranslationMode\n");
+
 ColorI gCanvasClearColor( 255, 0, 255 ); ///< For GFX->clear
 
 extern InputModifiers convertModifierBits(const U32 in);
@@ -127,6 +154,8 @@ GuiCanvas::GuiCanvas(): GuiControl(),
                         mHoverPositionSet(false),
                         mLeftMouseLast(false),
                         mHoverLeftControlTime(0),
+                        mKeyTranslationMode(TranslationMode_Platform),
+                        mNativeAcceleratorMode(TranslationMode_Platform),
                         mMiddleMouseLast(false),
                         mRightMouseLast(false),
                         mMouseDownPoint(0.0f,0.0f),
@@ -183,6 +212,13 @@ void GuiCanvas::initPersistFields()
    addField("displayWindow", TypeBool, Offset(mDisplayWindow, GuiCanvas), "Controls if the canvas window is rendered or not." );
    endGroup("Canvas Rendering");
 
+   addGroup("KeyboardMode Callbacks");
+   addField("keyTranslationMode", TYPEID< KeyTranslationMode >(), Offset(mKeyTranslationMode, GuiCanvas),
+      "How to handle enable/disable keyboard translation requests. \"Platform\", \"Callback\" or \"Ignore\".\n");
+   addField("nativeAcceleratorMode", TYPEID< KeyTranslationMode >(), Offset(mNativeAcceleratorMode, GuiCanvas),
+      "How to handle enable/disable native accelerator requests. \"Platform\", \"Callback\" or \"Ignore\".\n");
+   endGroup("KeyboardMode Callbacks");
+
    Parent::initPersistFields();
 }
 
@@ -442,20 +478,32 @@ Point2I GuiCanvas::getWindowSize()
 
 void GuiCanvas::enableKeyboardTranslation()
 {
-   AssertISV(mPlatformWindow, "GuiCanvas::enableKeyboardTranslation - no window present!");
-   mPlatformWindow->setKeyboardTranslation(true);
+   if ((mKeyTranslationMode == TranslationMode_Platform) ||
+      ((mKeyTranslationMode == TranslationMode_Callback) && onSetKeyboardTranslationEnabled_callback(true)))
+   {
+      AssertISV(mPlatformWindow, "GuiCanvas::enableKeyboardTranslation - no window present!");
+      mPlatformWindow->setKeyboardTranslation(true);
+   }
 }
 
 void GuiCanvas::disableKeyboardTranslation()
 {
-   AssertISV(mPlatformWindow, "GuiCanvas::disableKeyboardTranslation - no window present!");
-   mPlatformWindow->setKeyboardTranslation(false);
+   if ((mKeyTranslationMode == TranslationMode_Platform) ||
+      ((mKeyTranslationMode == TranslationMode_Callback) && onSetKeyboardTranslationEnabled_callback(false)))
+   {
+      AssertISV(mPlatformWindow, "GuiCanvas::disableKeyboardTranslation - no window present!");
+      mPlatformWindow->setKeyboardTranslation(false);
+   }
 }
 
 void GuiCanvas::setNativeAcceleratorsEnabled( bool enabled )
 {
-   AssertISV(mPlatformWindow, "GuiCanvas::setNativeAcceleratorsEnabled - no window present!");
-   mPlatformWindow->setAcceleratorsEnabled( enabled );
+   if ((mNativeAcceleratorMode == TranslationMode_Platform) ||
+      ((mNativeAcceleratorMode == TranslationMode_Callback) && onSetNativeAcceleratorsEnabled_callback(enabled)))
+   {
+      AssertISV(mPlatformWindow, "GuiCanvas::setNativeAcceleratorsEnabled - no window present!");
+      mPlatformWindow->setAcceleratorsEnabled(enabled);
+   }
 }
 
 void GuiCanvas::setForceMouseToGUI(bool onOff)
diff --git a/Engine/source/gui/core/guiCanvas.h b/Engine/source/gui/core/guiCanvas.h
index f9f4a37af..fdb1cfd25 100644
--- a/Engine/source/gui/core/guiCanvas.h
+++ b/Engine/source/gui/core/guiCanvas.h
@@ -178,6 +178,19 @@ protected:
    bool           mHoverPositionSet;
    U32            mHoverLeftControlTime;
 
+public:
+   /// Setting for how to handle 'enableKeyboardTranslation' and 'setNativeAcceleratorsEnabled' requests.
+   enum KeyTranslationMode
+   {
+      TranslationMode_Platform,
+      TranslationMode_Callback,
+      TranslationMode_Ignore,
+   };
+
+protected:
+   KeyTranslationMode mKeyTranslationMode;
+   KeyTranslationMode mNativeAcceleratorMode;
+
    /// @}
 
    // Internal event handling callbacks for use with PlatformWindow.
@@ -454,6 +467,10 @@ public:
 
    virtual void setWindowTitle(const char *newTitle);
 
+   DECLARE_CALLBACK(bool, onSetKeyboardTranslationEnabled, (bool enable));
+   DECLARE_CALLBACK(bool, onSetNativeAcceleratorsEnabled, (bool enable));
+
+
 private:
    static const U32 MAX_GAMEPADS = 4; ///< The maximum number of supported gamepads
   protected:
@@ -464,5 +481,7 @@ private:
      void setConsumeLastInputEvent(bool flag) { mConsumeLastInputEvent = flag; }
      bool getLastCursorPoint(Point2I& pt) const { pt = mLastCursorPt; return mLastCursorEnabled; }
 };
+typedef GuiCanvas::KeyTranslationMode KeyboardTranslationMode;
+DefineEnumType(KeyboardTranslationMode);
 
 #endif

From 37c924512c4bb7856de65d35b8fa8ff4204214b1 Mon Sep 17 00:00:00 2001
From: OTHGMars <mmars1149@aol.com>
Date: Tue, 28 Sep 2021 05:52:45 -0400
Subject: [PATCH 119/399] Corrects console documentation.

---
 Engine/source/gui/core/guiCanvas.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Engine/source/gui/core/guiCanvas.cpp b/Engine/source/gui/core/guiCanvas.cpp
index 8ad674474..96022edaa 100644
--- a/Engine/source/gui/core/guiCanvas.cpp
+++ b/Engine/source/gui/core/guiCanvas.cpp
@@ -107,16 +107,16 @@ ConsoleDocClass( GuiCanvas,
 
    IMPLEMENT_CALLBACK(GuiCanvas, onSetKeyboardTranslationEnabled, bool, (bool enable), (enable),
       "Called when the canvas receives an enableKeyboardTranslation request. This is usually the "
-      "result of a GuitTextInputCtrl gaining or losing focus. Return false to allow the request "
-      "to be passed to the platform window. Return true to override the request and handle it in script.\n\n"
+      "result of a GuitTextInputCtrl gaining or losing focus. Return true to allow the request "
+      "to be passed to the platform window. Return false to override the request and handle it in script.\n\n"
       "@note This callback is only issued if keyTranslationMode is set to \"Callback\" for this canvas.\n"
       "@param enable Requested keyboard translation state.\n"
       "@see KeyboardTranslationMode\n");
 
    IMPLEMENT_CALLBACK(GuiCanvas, onSetNativeAcceleratorsEnabled, bool, (bool enable), (enable),
       "Called when the canvas receives a setNativeAcceleratorsEnabled request. This is usually the "
-      "result of a GuitTextInputCtrl gaining or losing focus. Return false to allow the request to "
-      "be passed to the platform window. Return true to override the request and handle it in script.\n\n"
+      "result of a GuitTextInputCtrl gaining or losing focus. Return true to allow the request to "
+      "be passed to the platform window. Return false to override the request and handle it in script.\n\n"
       "@note This callback is only issued if nativeAcceleratorMode is set to \"Callback\" for this canvas.\n"
       "@param enable Requested accelerator state.\n"
       "@see KeyboardTranslationMode\n");

From 8a1d3f2021cab0a8e3db7f68a7e534a981ae8c1b Mon Sep 17 00:00:00 2001
From: marauder2k7 <ctrl-intelligence@live.co.uk>
Date: Tue, 28 Sep 2021 13:56:35 +0100
Subject: [PATCH 120/399] Working thunder. These changes may need to be applied
 to other sound arrays or image arrays.

---
 Engine/source/T3D/assets/SoundAsset.cpp | 10 +++++-----
 Engine/source/T3D/fx/lightning.cpp      |  6 ++++++
 2 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/Engine/source/T3D/assets/SoundAsset.cpp b/Engine/source/T3D/assets/SoundAsset.cpp
index 72a3a2526..45f78bc48 100644
--- a/Engine/source/T3D/assets/SoundAsset.cpp
+++ b/Engine/source/T3D/assets/SoundAsset.cpp
@@ -279,18 +279,18 @@ StringTableEntry SoundAsset::getAssetIdByFileName(StringTableEntry fileName)
    return materialAssetId;
 }
 
-U32 SoundAsset::getAssetById(StringTableEntry assetId, AssetPtr<SoundAsset>* materialAsset)
+U32 SoundAsset::getAssetById(StringTableEntry assetId, AssetPtr<SoundAsset>* soundAsset)
 {
-   (*materialAsset) = assetId;
+   (*soundAsset) = assetId;
 
-   if (materialAsset->notNull())
+   if (soundAsset->notNull())
    {
-      return (*materialAsset)->mLoadedState;
+      return (*soundAsset)->mLoadedState;
    }
    else
    {
       //Well that's bad, loading the fallback failed.
-      Con::warnf("MaterialAsset::getAssetById - Finding of asset with id %s failed with no fallback asset", assetId);
+      Con::warnf("SoundAsset::getAssetById - Finding of asset with id %s failed with no fallback asset", assetId);
       return AssetErrCode::Failed;
    }
 }
diff --git a/Engine/source/T3D/fx/lightning.cpp b/Engine/source/T3D/fx/lightning.cpp
index 8f1ba8bf6..e032284e7 100644
--- a/Engine/source/T3D/fx/lightning.cpp
+++ b/Engine/source/T3D/fx/lightning.cpp
@@ -265,7 +265,9 @@ void LightningData::initPersistFields()
 
    INITPERSISTFIELD_SOUNDASSET(StrikeSound, LightningData, "Sound to play when lightning STRIKES!");
 
+   addArray("Thunders", MaxThunders);
    INITPERSISTFIELD_SOUNDASSET_ARRAY(ThunderSound, MaxThunders, LightningData, "Sounds for thunder.");
+   endArray("Thunders");
 
    addField( "strikeTextures", TypeString, Offset(strikeTextureNames, LightningData), MaxTextures,
       "List of textures to use to render lightning strikes." );
@@ -299,9 +301,13 @@ bool LightningData::preload(bool server, String &errorStr)
          if (getThunderSound(i))
          {
             _setThunderSound(getThunderSound(i), i);
+            Con::printf("Thunder sound: %d %s", i, getThunderSound(i));
+
             if (!getThunderSoundProfile(i))
                Con::errorf(ConsoleLogEntry::General, "LightningData::preload: Cant get an sfxProfile for thunder.");
+
          }
+
       }
 
       if(getStrikeSound() && !getStrikeSoundProfile())

From 4429de59b04a0631721a64a3485103983dca314a Mon Sep 17 00:00:00 2001
From: marauder2k7 <ctrl-intelligence@live.co.uk>
Date: Tue, 28 Sep 2021 14:08:27 +0100
Subject: [PATCH 121/399] okay so addArray isn't even required.

---
 Engine/source/T3D/fx/lightning.cpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/Engine/source/T3D/fx/lightning.cpp b/Engine/source/T3D/fx/lightning.cpp
index e032284e7..6726c5183 100644
--- a/Engine/source/T3D/fx/lightning.cpp
+++ b/Engine/source/T3D/fx/lightning.cpp
@@ -265,9 +265,7 @@ void LightningData::initPersistFields()
 
    INITPERSISTFIELD_SOUNDASSET(StrikeSound, LightningData, "Sound to play when lightning STRIKES!");
 
-   addArray("Thunders", MaxThunders);
    INITPERSISTFIELD_SOUNDASSET_ARRAY(ThunderSound, MaxThunders, LightningData, "Sounds for thunder.");
-   endArray("Thunders");
 
    addField( "strikeTextures", TypeString, Offset(strikeTextureNames, LightningData), MaxTextures,
       "List of textures to use to render lightning strikes." );

From 76addc52eb73fdb631380c27beb3e7a6f61f8e89 Mon Sep 17 00:00:00 2001
From: marauder2k7 <ctrl-intelligence@live.co.uk>
Date: Tue, 28 Sep 2021 21:10:48 +0100
Subject: [PATCH 122/399] Checks for emptyString in preload Sound asset out for
 emptyString

---
 Engine/source/T3D/assets/SoundAsset.h  |  2 ++
 Engine/source/T3D/fx/explosion.cpp     | 10 +++++++++-
 Engine/source/T3D/fx/lightning.cpp     | 11 ++++++++---
 Engine/source/T3D/fx/precipitation.cpp | 11 +++++++++--
 Engine/source/T3D/fx/splash.cpp        | 12 +++++++++---
 Engine/source/T3D/projectile.cpp       |  9 +++++++--
 6 files changed, 44 insertions(+), 11 deletions(-)

diff --git a/Engine/source/T3D/assets/SoundAsset.h b/Engine/source/T3D/assets/SoundAsset.h
index ca83e477b..502732fee 100644
--- a/Engine/source/T3D/assets/SoundAsset.h
+++ b/Engine/source/T3D/assets/SoundAsset.h
@@ -235,6 +235,8 @@ public: \
          m##name = NULL;\
       }\
       \
+      if(get##name() == StringTable->EmptyString())\
+         return true;\
       if (m##name##Asset.notNull() && m##name##Asset->getStatus() != SoundAsset::Ok)\
       {\
          Con::errorf("%s(%s)::_set%s() - sound asset failure\"%s\" due to [%s]", macroText(className), getName(), macroText(name), _in, SoundAsset::getAssetErrstrn(m##name##Asset->getStatus()).c_str());\
diff --git a/Engine/source/T3D/fx/explosion.cpp b/Engine/source/T3D/fx/explosion.cpp
index d770e2f36..17aa6017c 100644
--- a/Engine/source/T3D/fx/explosion.cpp
+++ b/Engine/source/T3D/fx/explosion.cpp
@@ -864,7 +864,15 @@ bool ExplosionData::preload(bool server, String &errorStr)
 
    if( !server )
    {
-      String sfxErrorStr;
+
+      if (getSound() != StringTable->EmptyString())
+      {
+         _setSound(getSound());
+
+         if (!getSoundProfile())
+            Con::errorf(ConsoleLogEntry::General, "SplashData::preload: Cant get an sfxProfile for splash.");
+      }
+
       if (!particleEmitter && particleEmitterId != 0)
          if (Sim::findObject(particleEmitterId, particleEmitter) == false)
             Con::errorf(ConsoleLogEntry::General, "Error, unable to load particle emitter for explosion datablock");
diff --git a/Engine/source/T3D/fx/lightning.cpp b/Engine/source/T3D/fx/lightning.cpp
index 6726c5183..a53a1f540 100644
--- a/Engine/source/T3D/fx/lightning.cpp
+++ b/Engine/source/T3D/fx/lightning.cpp
@@ -296,7 +296,7 @@ bool LightningData::preload(bool server, String &errorStr)
    {
       for (S32 i = 0; i < MaxThunders; i++)
       {
-         if (getThunderSound(i))
+         if (getThunderSound(i) != StringTable->EmptyString())
          {
             _setThunderSound(getThunderSound(i), i);
             Con::printf("Thunder sound: %d %s", i, getThunderSound(i));
@@ -308,8 +308,13 @@ bool LightningData::preload(bool server, String &errorStr)
 
       }
 
-      if(getStrikeSound() && !getStrikeSoundProfile())
-         Con::errorf(ConsoleLogEntry::General, "LightningData::preload: can't get sfxProfile from asset");
+      if (getStrikeSound() != StringTable->EmptyString())
+      {
+         _setStrikeSound(getStrikeSound());
+
+         if(!getStrikeSoundProfile())
+            Con::errorf(ConsoleLogEntry::General, "LightningData::preload: can't get sfxProfile from strike sound.");
+      }
 
       mNumStrikeTextures = 0;
       for (U32 k = 0; k < MaxTextures; k++) 
diff --git a/Engine/source/T3D/fx/precipitation.cpp b/Engine/source/T3D/fx/precipitation.cpp
index bf3246dc9..68880edf4 100644
--- a/Engine/source/T3D/fx/precipitation.cpp
+++ b/Engine/source/T3D/fx/precipitation.cpp
@@ -188,9 +188,16 @@ bool PrecipitationData::preload( bool server, String &errorStr )
 {
    if( Parent::preload( server, errorStr) == false)
       return false;
+   if (!server)
+   {
+      if (getSound() != StringTable->EmptyString())
+      {
+         _setSound(getSound());
 
-   if (!server && !getSoundProfile())
-      return false;
+         if (!getSoundProfile())
+            Con::errorf(ConsoleLogEntry::General, "SplashData::preload: Cant get an sfxProfile for splash.");
+      }
+   }
 
    return true;
 }
diff --git a/Engine/source/T3D/fx/splash.cpp b/Engine/source/T3D/fx/splash.cpp
index d1230e5c5..38a4f4e89 100644
--- a/Engine/source/T3D/fx/splash.cpp
+++ b/Engine/source/T3D/fx/splash.cpp
@@ -276,11 +276,17 @@ bool SplashData::preload(bool server, String &errorStr)
    if (Parent::preload(server, errorStr) == false)
       return false;
 
-   if (!server && !getSoundProfile())
-      return false;
-
    if (!server)
    {
+
+      if (getSound() != StringTable->EmptyString())
+      {
+         _setSound(getSound());
+
+         if(!getSoundProfile())
+            Con::errorf(ConsoleLogEntry::General, "SplashData::preload: Cant get an sfxProfile for splash.");
+      }
+
       S32 i;
       for( i=0; i<NUM_EMITTERS; i++ )
       {
diff --git a/Engine/source/T3D/projectile.cpp b/Engine/source/T3D/projectile.cpp
index a88276f73..762b63c1f 100644
--- a/Engine/source/T3D/projectile.cpp
+++ b/Engine/source/T3D/projectile.cpp
@@ -367,8 +367,13 @@ bool ProjectileData::preload(bool server, String &errorStr)
          if (Sim::findObject(decalId, decal) == false)
             Con::errorf(ConsoleLogEntry::General, "ProjectileData::preload: Invalid packet, bad datablockId(decal): %d", decalId);
 
-      if( !getProjectileSound() )
-         Con::errorf(ConsoleLogEntry::General, "ProjectileData::preload: Invalid asset");
+      if (getProjectileSound() != StringTable->EmptyString())
+      {
+         _setProjectileSound(getProjectileSound());
+
+         if (!getProjectileSoundProfile())
+            Con::errorf(ConsoleLogEntry::General, "SplashData::preload: Cant get an sfxProfile for splash.");
+      }
 
       if (!lightDesc && lightDescId != 0)
          if (Sim::findObject(lightDescId, lightDesc) == false)

From 96891e5673ca114f3d5c5490cdc180cb0cf2b57e Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Tue, 28 Sep 2021 17:33:36 -0500
Subject: [PATCH 123/399] early out if any asset feed route results in
 explicitly being told to use an emptystring

---
 Engine/source/T3D/assets/SoundAsset.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Engine/source/T3D/assets/SoundAsset.h b/Engine/source/T3D/assets/SoundAsset.h
index ca83e477b..d6baadbbf 100644
--- a/Engine/source/T3D/assets/SoundAsset.h
+++ b/Engine/source/T3D/assets/SoundAsset.h
@@ -234,6 +234,8 @@ public: \
       {\
          m##name = NULL;\
       }\
+      if(get##name() == StringTable->EmptyString())\
+         return true;\
       \
       if (m##name##Asset.notNull() && m##name##Asset->getStatus() != SoundAsset::Ok)\
       {\

From 6bec47d3fa9855030f5f6506c257fc0dc8a49f42 Mon Sep 17 00:00:00 2001
From: marauder2k7 <ctrl-intelligence@live.co.uk>
Date: Tue, 28 Sep 2021 23:36:04 +0100
Subject: [PATCH 124/399] -SoundAsset added init for enum types. -Vehicles
 updated to use enum initpersistfield.

---
 Engine/source/T3D/assets/SoundAsset.h         | 10 +++++++
 Engine/source/T3D/vehicles/hoverVehicle.cpp   | 14 +++++++--
 Engine/source/T3D/vehicles/vehicle.cpp        | 30 ++++++++++++++++---
 Engine/source/T3D/vehicles/wheeledVehicle.cpp | 15 ++++++++--
 Engine/source/T3D/vehicles/wheeledVehicle.h   |  1 +
 5 files changed, 62 insertions(+), 8 deletions(-)

diff --git a/Engine/source/T3D/assets/SoundAsset.h b/Engine/source/T3D/assets/SoundAsset.h
index 502732fee..486aca6c0 100644
--- a/Engine/source/T3D/assets/SoundAsset.h
+++ b/Engine/source/T3D/assets/SoundAsset.h
@@ -371,6 +371,16 @@ DefineEngineMethod(className, set##name, bool, (const char*  shape), , assetText
 
 #pragma endregion
 
+#define assetEnumNameConcat(x,suff,ForT)(new std::string(std::string(#x) + suff + std::string(#ForT)))->c_str()
+
+#define INITPERSISTFIELD_SOUNDASSET_ENUMED(name, enumType, maxValue, consoleClass, docs) \
+   for (U32 i = 0; i <= maxValue; i++)\
+   {\
+      const char* enumString = castConsoleTypeToString(static_cast<enumType>(i));\
+      addProtectedField(assetEnumNameConcat(name,enumString, File), TypeSoundFilename, Offset(m##name##Name[i], consoleClass), _set##name##Data, & defaultProtectedGetFn, assetText(name, docs), AbstractClassRep::FIELD_HideInInspectors); \
+      addProtectedField(assetEnumNameConcat(name,enumString, Asset), TypeSoundAssetId, Offset(m##name##AssetId[i], consoleClass), _set##name##Data, & defaultProtectedGetFn, assetText(name, asset reference.));\
+   }\
+
 #pragma region Arrayed Asset Macros
 
 #define DECLARE_SOUNDASSET_ARRAY(className,name,max) public: \
diff --git a/Engine/source/T3D/vehicles/hoverVehicle.cpp b/Engine/source/T3D/vehicles/hoverVehicle.cpp
index 0cddc2c72..7deb81fe0 100644
--- a/Engine/source/T3D/vehicles/hoverVehicle.cpp
+++ b/Engine/source/T3D/vehicles/hoverVehicle.cpp
@@ -68,6 +68,16 @@ ConsoleDocClass( HoverVehicle,
    "@ingroup Vehicles\n"
 );
 
+typedef HoverVehicleData::Sounds hoverSoundsEnum;
+DefineEnumType(hoverSoundsEnum);
+
+ImplementEnumType(hoverSoundsEnum, "enum types.\n"
+   "@ingroup HoverVehicleData\n\n")
+   { HoverVehicleData::JetSound,       "JetSound", "..." },
+   { HoverVehicleData::EngineSound,    "EngineSound", "..." },
+   { HoverVehicleData::FloatSound,     "FloatSound", "..." },
+EndImplementEnumType;
+
 namespace {
 
 const U32 sCollisionMoveMask = (TerrainObjectType     | PlayerObjectType  | 
@@ -232,7 +242,7 @@ void HoverVehicleData::initPersistFields()
    addField( "pitchForce", TypeF32, Offset(pitchForce, HoverVehicleData),
       "Pitch (rotation about the X-axis) force applied when steering in the y-axis direction." );
 
-   INITPERSISTFIELD_SOUNDASSET_ARRAY(HoverSounds, Sounds::MaxSounds, HoverVehicleData, "Sounds for hover vehicle.");
+   INITPERSISTFIELD_SOUNDASSET_ENUMED(HoverSounds, hoverSoundsEnum, Sounds::MaxSounds, HoverVehicleData, "Sounds for hover vehicle.");
    
    addField( "dustTrailEmitter", TYPEID< ParticleEmitterData >(), Offset(dustTrailEmitter, HoverVehicleData),
       "Emitter to generate particles for the vehicle's dust trail.\nThe trail "
@@ -307,7 +317,7 @@ bool HoverVehicleData::preload(bool server, String &errorStr)
    if (!server) {
 
       for (S32 i = 0; i < MaxSounds; i++)
-         if (mHoverSounds[i])
+         if (getHoverSounds(i) != StringTable->EmptyString())
          {
             _setHoverSounds(getHoverSounds(i), i);
          }
diff --git a/Engine/source/T3D/vehicles/vehicle.cpp b/Engine/source/T3D/vehicles/vehicle.cpp
index b773dd58f..8079fc163 100644
--- a/Engine/source/T3D/vehicles/vehicle.cpp
+++ b/Engine/source/T3D/vehicles/vehicle.cpp
@@ -80,6 +80,28 @@ static U32 sTriggerMask = ItemObjectType     |
 
 IMPLEMENT_CONOBJECT(VehicleData);
 
+typedef VehicleData::Body::Sounds bodySounds;
+DefineEnumType(bodySounds);
+
+ImplementEnumType(bodySounds, "enum types.\n"
+   "@ingroup VehicleData\n\n")
+   { VehicleData::Body::SoftImpactSound,  "SoftImpactSound", "..." },
+   { VehicleData::Body::HardImpactSound,  "HardImpactSound", "..." },
+EndImplementEnumType;
+
+
+typedef VehicleData::Sounds vehSoundsEnum;
+DefineEnumType(vehSoundsEnum);
+
+ImplementEnumType(vehSoundsEnum, "enum types.\n"
+   "@ingroup VehicleData\n\n")
+   { VehicleData::ExitWater,     "ExitWater", "..." },
+   { VehicleData::ImpactSoft,    "ImpactSoft", "..." },
+   { VehicleData::ImpactMedium,  "ImpactMedium", "..." },
+   { VehicleData::ImpactHard,    "ImpactHard", "..." },
+   { VehicleData::Wake,          "Wake", "..." },
+EndImplementEnumType;
+
 ConsoleDocClass( VehicleData,
    "@brief Base properties shared by all Vehicles (FlyingVehicle, HoverVehicle, "
    "WheeledVehicle).\n\n"
@@ -219,7 +241,7 @@ bool VehicleData::preload(bool server, String &errorStr)
    if (!server) {
       for (S32 i = 0; i < Body::MaxSounds; i++)
       {
-         if (mVehicleBodySounds[i])
+         if (getVehicleBodySounds(i) != StringTable->EmptyString() )
          {
             _setVehicleBodySounds(getVehicleBodySounds(i), i);
          }
@@ -227,7 +249,7 @@ bool VehicleData::preload(bool server, String &errorStr)
 
       for (S32 j = 0; j < Sounds::MaxSounds; j++)
       {
-         if (mVehicleWaterSounds[j])
+         if (getVehicleWaterSounds(j) != StringTable->EmptyString()) 
          {
             _setVehicleWaterSounds(getVehicleWaterSounds(j), j);
          }
@@ -503,7 +525,7 @@ void VehicleData::initPersistFields()
       "Collision friction coefficient.\nHow well this object will slide against "
       "objects it collides with." );
 
-   INITPERSISTFIELD_SOUNDASSET_ARRAY(VehicleBodySounds, Body::Sounds::MaxSounds, VehicleData, "Sounds for vehicle body impacts.");
+   INITPERSISTFIELD_SOUNDASSET_ENUMED(VehicleBodySounds, bodySounds, Body::Sounds::MaxSounds, VehicleData, "Sounds for vehicle body impacts.");
 
    addField( "minImpactSpeed", TypeF32, Offset(minImpactSpeed, VehicleData),
       "Minimum collision speed for the onImpact callback to be invoked." );
@@ -601,7 +623,7 @@ void VehicleData::initPersistFields()
       "Minimum velocity when entering the water for the imapactWaterHard sound "
       "to play.\n\n@see impactWaterHard" );
 
-   INITPERSISTFIELD_SOUNDASSET_ARRAY(WaterSounds, Sounds::MaxSounds, VehicleData, "Sounds for interacting with water.");
+   INITPERSISTFIELD_SOUNDASSET_ENUMED(WaterSounds, vehSoundsEnum, VehicleData::Sounds::MaxSounds, VehicleData, "Sounds for interacting with water.");
 
    addField( "collDamageThresholdVel", TypeF32, Offset(collDamageThresholdVel, VehicleData),
       "Minimum collision velocity to cause damage to this vehicle.\nCurrently unused." );
diff --git a/Engine/source/T3D/vehicles/wheeledVehicle.cpp b/Engine/source/T3D/vehicles/wheeledVehicle.cpp
index 3fbde4af7..4e9e7201e 100644
--- a/Engine/source/T3D/vehicles/wheeledVehicle.cpp
+++ b/Engine/source/T3D/vehicles/wheeledVehicle.cpp
@@ -289,6 +289,17 @@ ConsoleDocClass( WheeledVehicleData,
    "@ingroup Vehicles\n"
 );
 
+typedef WheeledVehicleData::Sounds wheelSoundsEnum;
+DefineEnumType(wheelSoundsEnum);
+
+ImplementEnumType(wheelSoundsEnum, "enum types.\n"
+   "@ingroup WheeledVehicleData\n\n")
+   {WheeledVehicleData::JetSound,          "JetSound", "..." },
+   {WheeledVehicleData::EngineSound,       "EngineSound", "..." },
+   {WheeledVehicleData::SquealSound,       "SquealSound", "..." },
+   {WheeledVehicleData::WheelImpactSound,  "WheelImpactSound", "..." },
+EndImplementEnumType;
+
 WheeledVehicleData::WheeledVehicleData()
 {
    tireEmitter = 0;
@@ -335,7 +346,7 @@ bool WheeledVehicleData::preload(bool server, String &errorStr)
    if (!server) {
       for (S32 i = 0; i < MaxSounds; i++)
       {
-         if (mWheeledVehicleSounds[i])
+         if (getWheeledVehicleSounds(i) != StringTable->EmptyString())
          {
             _setWheeledVehicleSounds(getWheeledVehicleSounds(i), i);
          }
@@ -437,7 +448,7 @@ bool WheeledVehicleData::mirrorWheel(Wheel* we)
 
 void WheeledVehicleData::initPersistFields()
 {
-   INITPERSISTFIELD_SOUNDASSET_ARRAY(WheeledVehicleSounds, Sounds::MaxSounds, WheeledVehicleData, "Sounds related to wheeled vehicle.");
+   INITPERSISTFIELD_SOUNDASSET_ENUMED(WheeledVehicleSounds, wheelSoundsEnum, MaxSounds, WheeledVehicleData, "Sounds related to wheeled vehicle.");
 
    addField("tireEmitter",TYPEID< ParticleEmitterData >(), Offset(tireEmitter, WheeledVehicleData),
       "ParticleEmitterData datablock used to generate particles from each wheel "
diff --git a/Engine/source/T3D/vehicles/wheeledVehicle.h b/Engine/source/T3D/vehicles/wheeledVehicle.h
index 2f37b6c13..a2ab03b11 100644
--- a/Engine/source/T3D/vehicles/wheeledVehicle.h
+++ b/Engine/source/T3D/vehicles/wheeledVehicle.h
@@ -118,6 +118,7 @@ struct WheeledVehicleData: public VehicleData
       WheelImpactSound,
       MaxSounds,
    };
+
    DECLARE_SOUNDASSET_ARRAY(WheeledVehicleData, WheeledVehicleSounds, Sounds::MaxSounds);
    DECLARE_SOUNDASSET_ARRAY_SETGET(WheeledVehicleData, WheeledVehicleSounds);
 

From 776741770db23fb0684d81b65eddd0d1aed295c5 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Tue, 28 Sep 2021 18:16:14 -0500
Subject: [PATCH 125/399] boolean is<thing>valid chjecks for assets. tests
 wether it's non-empty and reporting zero flaws

---
 Engine/source/T3D/assets/ImageAsset.h    | 6 ++++--
 Engine/source/T3D/assets/MaterialAsset.h | 3 ++-
 Engine/source/T3D/assets/ShapeAsset.h    | 6 ++++--
 Engine/source/T3D/assets/SoundAsset.h    | 6 ++++--
 Engine/source/T3D/fx/lightning.cpp       | 4 ++--
 5 files changed, 16 insertions(+), 9 deletions(-)

diff --git a/Engine/source/T3D/assets/ImageAsset.h b/Engine/source/T3D/assets/ImageAsset.h
index b79dc5f5d..57155ff2f 100644
--- a/Engine/source/T3D/assets/ImageAsset.h
+++ b/Engine/source/T3D/assets/ImageAsset.h
@@ -270,7 +270,8 @@ public: \
    GFXTexHandle get##name##Resource() \
    {\
       return m##name;\
-   }
+   }\
+   bool name##Valid() { (get##name() != StringTable->EmptyString() && m##name##Asset->getStatus() == AssetBase::Ok) ? true : false; }
 
 #define DECLARE_IMAGEASSET_SETGET(className, name)\
    static bool _set##name##Data(void* obj, const char* index, const char* data)\
@@ -494,7 +495,8 @@ public: \
       if(index >= sm##name##Count || index < 0)\
          return nullptr;\
       return m##name[index];\
-   }
+   }\
+   bool name##Valid(const U32& id) { (get##name(id) != StringTable->EmptyString() && m##name##Asset[id]->getStatus() == AssetBase::Ok) ? true : false; }
 
 #define DECLARE_IMAGEASSET_ARRAY_SETGET(className, name)\
    static bool _set##name##Data(void* obj, const char* index, const char* data)\
diff --git a/Engine/source/T3D/assets/MaterialAsset.h b/Engine/source/T3D/assets/MaterialAsset.h
index c747be793..e9a74174a 100644
--- a/Engine/source/T3D/assets/MaterialAsset.h
+++ b/Engine/source/T3D/assets/MaterialAsset.h
@@ -259,7 +259,8 @@ public: \
    SimObjectPtr<Material> get##name##Resource() \
    {\
       return m##name;\
-   }
+   }\
+   bool is##name##Valid() { (get##name() != StringTable->EmptyString() && m##name##Asset->getStatus() == AssetBase::Ok) ? true : false; }
 
 #define DECLARE_MATERIALASSET_SETGET(className, name)\
    static bool _set##name##Data(void* obj, const char* index, const char* data)\
diff --git a/Engine/source/T3D/assets/ShapeAsset.h b/Engine/source/T3D/assets/ShapeAsset.h
index d3af516c5..055ecdb42 100644
--- a/Engine/source/T3D/assets/ShapeAsset.h
+++ b/Engine/source/T3D/assets/ShapeAsset.h
@@ -321,7 +321,8 @@ public: \
    Resource<TSShape> get##name##Resource() \
    {\
       return m##name;\
-   }
+   }\
+   bool is##name##Valid() { (get##name() != StringTable->EmptyString() && m##name##Asset->getStatus() == AssetBase::Ok) ? true : false; }
 
 #define DECLARE_SHAPEASSET_SETGET(className, name)\
    static bool _set##name##Data(void* obj, const char* index, const char* data)\
@@ -522,7 +523,8 @@ public: \
       if(index >= sm##name##Count || index < 0)\
          return ResourceManager::get().load( "" );\
       return m##name[index];\
-   }
+   }\
+   bool is##name##Valid(const U32& id) { (get##name(id) != StringTable->EmptyString() && m##name##Asset[id]->getStatus() == AssetBase::Ok) ? true : false; }
 
 #define DECLARE_SHAPEASSET_ARRAY_SETGET(className, name)\
    static bool _set##name##Data(void* obj, const char* index, const char* data)\
diff --git a/Engine/source/T3D/assets/SoundAsset.h b/Engine/source/T3D/assets/SoundAsset.h
index d6baadbbf..2f70b83c7 100644
--- a/Engine/source/T3D/assets/SoundAsset.h
+++ b/Engine/source/T3D/assets/SoundAsset.h
@@ -270,7 +270,8 @@ public: \
       if (get##name() != StringTable->EmptyString() && m##name##Asset.notNull())\
          return m##name##Asset->getSfxProfile();\
       return NULL;\
-   }
+   }\
+   bool is##name##Valid() { (get##name() != StringTable->EmptyString() && m##name##Asset->getStatus() == AssetBase::Ok) ? true : false; }
 
 #define DECLARE_SOUNDASSET_SETGET(className, name)\
    static bool _set##name##Data(void* obj, const char* index, const char* data)\
@@ -485,7 +486,8 @@ public: \
       if (get##name(id) != StringTable->EmptyString() && m##name##Asset[id].notNull())\
          return m##name##Asset[id]->getSfxProfile();\
       return NULL;\
-   }
+   }\
+   bool is##name##Valid(const U32& id) { (get##name(id) != StringTable->EmptyString() && m##name##Asset[id]->getStatus() == AssetBase::Ok) ? true : false; }
 
 #define DECLARE_SOUNDASSET_ARRAY_SETGET(className, name)\
    static bool _set##name##Data(void* obj, const char* index, const char* data)\
diff --git a/Engine/source/T3D/fx/lightning.cpp b/Engine/source/T3D/fx/lightning.cpp
index 8f1ba8bf6..905615a3d 100644
--- a/Engine/source/T3D/fx/lightning.cpp
+++ b/Engine/source/T3D/fx/lightning.cpp
@@ -296,7 +296,7 @@ bool LightningData::preload(bool server, String &errorStr)
    {
       for (S32 i = 0; i < MaxThunders; i++)
       {
-         if (getThunderSound(i))
+         if (isThunderSoundValid(i))
          {
             _setThunderSound(getThunderSound(i), i);
             if (!getThunderSoundProfile(i))
@@ -304,7 +304,7 @@ bool LightningData::preload(bool server, String &errorStr)
          }
       }
 
-      if(getStrikeSound() && !getStrikeSoundProfile())
+      if(isStrikeSoundValid() && !getStrikeSoundProfile())
          Con::errorf(ConsoleLogEntry::General, "LightningData::preload: can't get sfxProfile from asset");
 
       mNumStrikeTextures = 0;

From c5d5a9135645bd87920cd4d2e091711c2e12b8dd Mon Sep 17 00:00:00 2001
From: Areloch <Areloch@gmail.com>
Date: Tue, 28 Sep 2021 18:17:49 -0500
Subject: [PATCH 126/399] Add handling to RotationF's addRotation function to
 ensure formatted return

---
 Engine/source/math/mRotation.cpp | 11 +++++++++--
 Engine/source/math/mathTypes.cpp | 12 ++++++++++--
 2 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/Engine/source/math/mRotation.cpp b/Engine/source/math/mRotation.cpp
index 43b696d4a..18114c58d 100644
--- a/Engine/source/math/mRotation.cpp
+++ b/Engine/source/math/mRotation.cpp
@@ -325,14 +325,21 @@ TEST(Maths, RotationF_Calculations)
 };
 #endif
 
-DefineEngineFunction(AddRotation, RotationF, (RotationF a, RotationF b), ,
+DefineEngineFunction(AddRotation, RotationF, (RotationF a, RotationF b, const char* returnType), ("Euler"),
    "Adds two rotations together.\n"
    "@param a Rotation one."
    "@param b Rotation two."
    "@returns v sum of both rotations."
    "@ingroup Math")
 {
-   return a + b;
+   RotationF ret;
+   RotationF sum = a + b;
+   if (String(returnType) == String("Euler"))
+      ret.set(sum.asEulerF());
+   else
+      ret.set(sum.asAxisAngle());
+
+   return ret;
 }
  
 DefineEngineFunction(SubtractRotation, RotationF, (RotationF a, RotationF b), ,
diff --git a/Engine/source/math/mathTypes.cpp b/Engine/source/math/mathTypes.cpp
index 14c7335e8..70ac9adf7 100644
--- a/Engine/source/math/mathTypes.cpp
+++ b/Engine/source/math/mathTypes.cpp
@@ -620,8 +620,16 @@ ConsoleGetType(TypeRotationF)
    static const U32 bufSize = 256;
    char* returnBuffer = Con::getReturnBuffer(bufSize);
 
-   EulerF out = pt->asEulerF(RotationF::Degrees);
-   dSprintf(returnBuffer, bufSize, "%g %g %g", out.x, out.y, out.z);
+   if (pt->mRotationType == RotationF::Euler)
+   {
+      EulerF out = pt->asEulerF(RotationF::Degrees);
+      dSprintf(returnBuffer, bufSize, "%g %g %g", out.x, out.y, out.z);
+   }
+   else if (pt->mRotationType == RotationF::AxisAngle)
+   {
+      AngAxisF out = pt->asAxisAngle(RotationF::Degrees);
+      dSprintf(returnBuffer, bufSize, "%g %g %g %g", out.axis.x, out.axis.y, out.axis.z, out.angle);
+   }
 
    return returnBuffer;
 }

From 2630b4ada6a97222ad1e200fa962cf426b7d4161 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Tue, 28 Sep 2021 18:50:35 -0500
Subject: [PATCH 127/399] corrected and simplified the is<foo>Valid method
 macro injections

---
 Engine/source/T3D/assets/ImageAsset.h    | 4 ++--
 Engine/source/T3D/assets/MaterialAsset.h | 2 +-
 Engine/source/T3D/assets/ShapeAsset.h    | 4 ++--
 Engine/source/T3D/assets/SoundAsset.h    | 4 ++--
 4 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/Engine/source/T3D/assets/ImageAsset.h b/Engine/source/T3D/assets/ImageAsset.h
index 57155ff2f..7afcd6da2 100644
--- a/Engine/source/T3D/assets/ImageAsset.h
+++ b/Engine/source/T3D/assets/ImageAsset.h
@@ -271,7 +271,7 @@ public: \
    {\
       return m##name;\
    }\
-   bool name##Valid() { (get##name() != StringTable->EmptyString() && m##name##Asset->getStatus() == AssetBase::Ok) ? true : false; }
+   bool name##Valid() {return (get##name() != StringTable->EmptyString() && m##name##Asset->getStatus() == AssetBase::Ok); }
 
 #define DECLARE_IMAGEASSET_SETGET(className, name)\
    static bool _set##name##Data(void* obj, const char* index, const char* data)\
@@ -496,7 +496,7 @@ public: \
          return nullptr;\
       return m##name[index];\
    }\
-   bool name##Valid(const U32& id) { (get##name(id) != StringTable->EmptyString() && m##name##Asset[id]->getStatus() == AssetBase::Ok) ? true : false; }
+   bool name##Valid(const U32& id) {return (get##name(id) != StringTable->EmptyString() && m##name##Asset[id]->getStatus() == AssetBase::Ok); }
 
 #define DECLARE_IMAGEASSET_ARRAY_SETGET(className, name)\
    static bool _set##name##Data(void* obj, const char* index, const char* data)\
diff --git a/Engine/source/T3D/assets/MaterialAsset.h b/Engine/source/T3D/assets/MaterialAsset.h
index e9a74174a..fc383810f 100644
--- a/Engine/source/T3D/assets/MaterialAsset.h
+++ b/Engine/source/T3D/assets/MaterialAsset.h
@@ -260,7 +260,7 @@ public: \
    {\
       return m##name;\
    }\
-   bool is##name##Valid() { (get##name() != StringTable->EmptyString() && m##name##Asset->getStatus() == AssetBase::Ok) ? true : false; }
+   bool is##name##Valid() {return (get##name() != StringTable->EmptyString() && m##name##Asset->getStatus() == AssetBase::Ok); }
 
 #define DECLARE_MATERIALASSET_SETGET(className, name)\
    static bool _set##name##Data(void* obj, const char* index, const char* data)\
diff --git a/Engine/source/T3D/assets/ShapeAsset.h b/Engine/source/T3D/assets/ShapeAsset.h
index 055ecdb42..2d641a840 100644
--- a/Engine/source/T3D/assets/ShapeAsset.h
+++ b/Engine/source/T3D/assets/ShapeAsset.h
@@ -322,7 +322,7 @@ public: \
    {\
       return m##name;\
    }\
-   bool is##name##Valid() { (get##name() != StringTable->EmptyString() && m##name##Asset->getStatus() == AssetBase::Ok) ? true : false; }
+   bool is##name##Valid() {return (get##name() != StringTable->EmptyString() && m##name##Asset->getStatus() == AssetBase::Ok); }
 
 #define DECLARE_SHAPEASSET_SETGET(className, name)\
    static bool _set##name##Data(void* obj, const char* index, const char* data)\
@@ -524,7 +524,7 @@ public: \
          return ResourceManager::get().load( "" );\
       return m##name[index];\
    }\
-   bool is##name##Valid(const U32& id) { (get##name(id) != StringTable->EmptyString() && m##name##Asset[id]->getStatus() == AssetBase::Ok) ? true : false; }
+   bool is##name##Valid(const U32& id) {return (get##name(id) != StringTable->EmptyString() && m##name##Asset[id]->getStatus() == AssetBase::Ok); }
 
 #define DECLARE_SHAPEASSET_ARRAY_SETGET(className, name)\
    static bool _set##name##Data(void* obj, const char* index, const char* data)\
diff --git a/Engine/source/T3D/assets/SoundAsset.h b/Engine/source/T3D/assets/SoundAsset.h
index 2f70b83c7..2f3cc4615 100644
--- a/Engine/source/T3D/assets/SoundAsset.h
+++ b/Engine/source/T3D/assets/SoundAsset.h
@@ -271,7 +271,7 @@ public: \
          return m##name##Asset->getSfxProfile();\
       return NULL;\
    }\
-   bool is##name##Valid() { (get##name() != StringTable->EmptyString() && m##name##Asset->getStatus() == AssetBase::Ok) ? true : false; }
+   bool is##name##Valid() { return (get##name() != StringTable->EmptyString() && m##name##Asset->getStatus() == AssetBase::Ok); }
 
 #define DECLARE_SOUNDASSET_SETGET(className, name)\
    static bool _set##name##Data(void* obj, const char* index, const char* data)\
@@ -487,7 +487,7 @@ public: \
          return m##name##Asset[id]->getSfxProfile();\
       return NULL;\
    }\
-   bool is##name##Valid(const U32& id) { (get##name(id) != StringTable->EmptyString() && m##name##Asset[id]->getStatus() == AssetBase::Ok) ? true : false; }
+   bool is##name##Valid(const U32& id) {return (get##name(id) != StringTable->EmptyString() && m##name##Asset[id]->getStatus() == AssetBase::Ok); }
 
 #define DECLARE_SOUNDASSET_ARRAY_SETGET(className, name)\
    static bool _set##name##Data(void* obj, const char* index, const char* data)\

From d700ea487842ed6fb614c981837c2029ea8d1324 Mon Sep 17 00:00:00 2001
From: marauder2k7 <ctrl-intelligence@live.co.uk>
Date: Wed, 29 Sep 2021 11:41:57 +0100
Subject: [PATCH 128/399] Committing player separately. shapeBase is its own
 beast and will require a very critical look over once its up.

---
 Engine/source/T3D/player.cpp | 131 ++++++++++++++---------------------
 Engine/source/T3D/player.h   |   5 +-
 2 files changed, 56 insertions(+), 80 deletions(-)

diff --git a/Engine/source/T3D/player.cpp b/Engine/source/T3D/player.cpp
index 5bfc44746..3144bfcd9 100644
--- a/Engine/source/T3D/player.cpp
+++ b/Engine/source/T3D/player.cpp
@@ -189,6 +189,31 @@ PlayerData::ActionAnimationDef PlayerData::ActionAnimationList[NumTableActionAni
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
+typedef PlayerData::Sounds playerSoundsEnum;
+DefineEnumType(playerSoundsEnum);
+
+ImplementEnumType(playerSoundsEnum, "enum types.\n"
+   "@ingroup PlayerData\n\n")
+   {PlayerData::Sounds::FootSoft,            "FootSoft","..." },
+   {PlayerData::Sounds::FootHard,            "FootHard","..." },
+   {PlayerData::Sounds::FootMetal,           "FootMetal","..." },
+   {PlayerData::Sounds::FootSnow,            "FootSnow","..." },
+   {PlayerData::Sounds::FootShallowSplash,   "FootShallowSplash","..." },
+   {PlayerData::Sounds::FootWading,          "FootWading","..." },
+   {PlayerData::Sounds::FootUnderWater,      "FootUnderWater","..." },
+   {PlayerData::Sounds::FootBubbles,         "FootBubbles","..." },
+   {PlayerData::Sounds::MoveBubbles,         "MoveBubbles","..." },
+   {PlayerData::Sounds::WaterBreath,         "WaterBreath","..." },
+   {PlayerData::Sounds::ImpactStart,         "ImpactStart","..." },
+   {PlayerData::Sounds::ImpactHard,          "ImpactHard","..." },
+   {PlayerData::Sounds::ImpactMetal,         "ImpactMetal","..." },
+   {PlayerData::Sounds::ImpactSnow,          "ImpactSnow","..." },
+   {PlayerData::Sounds::ImpactWaterEasy,     "ImpactWaterEasy","..." },
+   {PlayerData::Sounds::ImpactWaterMedium,   "ImpactWaterMedium","..." },
+   {PlayerData::Sounds::ImpactWaterHard,     "ImpactWaterHard","..." },
+   {PlayerData::Sounds::ExitWater,           "ExitWater","..." },
+EndImplementEnumType;
+
 //----------------------------------------------------------------------------
 
 IMPLEMENT_CO_DATABLOCK_V1(PlayerData);
@@ -397,7 +422,7 @@ PlayerData::PlayerData()
    boxHeadFrontPercentage = 1;
 
    for (S32 i = 0; i < MaxSounds; i++)
-      sound[i] = NULL;
+      INIT_SOUNDASSET_ARRAY(PlayerSound, i);
 
    footPuffEmitter = NULL;
    footPuffID = 0;
@@ -449,9 +474,13 @@ bool PlayerData::preload(bool server, String &errorStr)
    {
       for( U32 i = 0; i < MaxSounds; ++ i )
       {
-         String sfxErrorStr;
-         if( !sfxResolve( &sound[ i ], sfxErrorStr ) )
-            Con::errorf( "PlayerData::preload: %s", sfxErrorStr.c_str() );
+         if (getPlayerSound(i) != StringTable->EmptyString())
+         {
+            _setPlayerSound(getPlayerSound(i), i);
+         }
+
+         if (!getPlayerSoundProfile(i))
+            Con::errorf("PlayerData::Preload() - unable to find sfxProfile for asset %d %s", i, getPlayerSound(i));
       }
    }
 
@@ -1022,63 +1051,7 @@ void PlayerData::initPersistFields()
 
    addGroup( "Interaction: Sounds" );
 
-      addField( "FootSoftSound", TypeSFXTrackName, Offset(sound[FootSoft], PlayerData),
-         "@brief Sound to play when walking on a surface with Material footstepSoundId 0.\n\n" );
-      addField( "FootHardSound", TypeSFXTrackName, Offset(sound[FootHard], PlayerData),
-         "@brief Sound to play when walking on a surface with Material footstepSoundId 1.\n\n" );
-      addField( "FootMetalSound", TypeSFXTrackName, Offset(sound[FootMetal], PlayerData),
-         "@brief Sound to play when walking on a surface with Material footstepSoundId 2.\n\n" );
-      addField( "FootSnowSound", TypeSFXTrackName, Offset(sound[FootSnow], PlayerData),
-         "@brief Sound to play when walking on a surface with Material footstepSoundId 3.\n\n" );
-
-      addField( "FootShallowSound", TypeSFXTrackName, Offset(sound[FootShallowSplash], PlayerData),
-         "@brief Sound to play when walking in water and coverage is less than "
-         "footSplashHeight.\n\n"
-         "@see footSplashHeight\n" );
-      addField( "FootWadingSound", TypeSFXTrackName, Offset(sound[FootWading], PlayerData),
-         "@brief Sound to play when walking in water and coverage is less than 1, "
-         "but > footSplashHeight.\n\n"
-         "@see footSplashHeight\n" );
-      addField( "FootUnderwaterSound", TypeSFXTrackName, Offset(sound[FootUnderWater], PlayerData),
-         "@brief Sound to play when walking in water and coverage equals 1.0 "
-         "(fully underwater).\n\n" );
-      addField( "FootBubblesSound", TypeSFXTrackName, Offset(sound[FootBubbles], PlayerData),
-         "@brief Sound to play when walking in water and coverage equals 1.0 "
-         "(fully underwater).\n\n" );
-      addField( "movingBubblesSound", TypeSFXTrackName, Offset(sound[MoveBubbles], PlayerData),
-         "@brief Sound to play when in water and coverage equals 1.0 (fully underwater).\n\n"
-         "Note that unlike FootUnderwaterSound, this sound plays even if the "
-         "player is not moving around in the water.\n" );
-      addField( "waterBreathSound", TypeSFXTrackName, Offset(sound[WaterBreath], PlayerData),
-         "@brief Sound to play when in water and coverage equals 1.0 (fully underwater).\n\n"
-         "Note that unlike FootUnderwaterSound, this sound plays even if the "
-         "player is not moving around in the water.\n" );
-
-      addField( "impactSoftSound", TypeSFXTrackName, Offset(sound[ImpactSoft], PlayerData),
-         "@brief Sound to play after falling on a surface with Material footstepSoundId 0.\n\n" );
-      addField( "impactHardSound", TypeSFXTrackName, Offset(sound[ImpactHard], PlayerData),
-         "@brief Sound to play after falling on a surface with Material footstepSoundId 1.\n\n" );
-      addField( "impactMetalSound", TypeSFXTrackName, Offset(sound[ImpactMetal], PlayerData),
-         "@brief Sound to play after falling on a surface with Material footstepSoundId 2.\n\n" );
-      addField( "impactSnowSound", TypeSFXTrackName, Offset(sound[ImpactSnow], PlayerData),
-         "@brief Sound to play after falling on a surface with Material footstepSoundId 3.\n\n" );
-
-      addField( "impactWaterEasy", TypeSFXTrackName, Offset(sound[ImpactWaterEasy], PlayerData),
-         "@brief Sound to play when entering the water with velocity < "
-         "mediumSplashSoundVelocity.\n\n"
-         "@see mediumSplashSoundVelocity\n");
-      addField( "impactWaterMedium", TypeSFXTrackName, Offset(sound[ImpactWaterMedium], PlayerData),
-         "@brief Sound to play when entering the water with velocity >= "
-         "mediumSplashSoundVelocity and < hardSplashSoundVelocity.\n\n"
-         "@see mediumSplashSoundVelocity\n"
-         "@see hardSplashSoundVelocity\n");
-      addField( "impactWaterHard", TypeSFXTrackName, Offset(sound[ImpactWaterHard], PlayerData),
-         "@brief Sound to play when entering the water with velocity >= "
-         "hardSplashSoundVelocity.\n\n"
-         "@see hardSplashSoundVelocity\n");
-      addField( "exitingWater", TypeSFXTrackName, Offset(sound[ExitWater], PlayerData),
-         "@brief Sound to play when exiting the water with velocity >= exitSplashSoundVelocity.\n\n"
-         "@see exitSplashSoundVelocity\n");
+      INITPERSISTFIELD_SOUNDASSET_ENUMED(PlayerSound, playerSoundsEnum, PlayerData::Sounds::MaxSounds, PlayerData, "Sounds related to player interaction.");
 
    endGroup( "Interaction: Sounds" );
 
@@ -1303,8 +1276,8 @@ void PlayerData::packData(BitStream* stream)
    stream->write(minImpactSpeed);
    stream->write(minLateralImpactSpeed);
 
-   for( U32 i = 0; i < MaxSounds; i++)
-      sfxWrite( stream, sound[ i ] );
+   for (U32 i = 0; i < MaxSounds; i++)
+      PACKDATA_SOUNDASSET_ARRAY(PlayerSound, i);
 
    mathWrite(*stream, boxSize);
    mathWrite(*stream, crouchBoxSize);
@@ -1484,8 +1457,8 @@ void PlayerData::unpackData(BitStream* stream)
    stream->read(&minImpactSpeed);
    stream->read(&minLateralImpactSpeed);
 
-   for( U32 i = 0; i < MaxSounds; i++)
-      sfxRead( stream, &sound[ i ] );
+   for (U32 i = 0; i < MaxSounds; i++)
+      UNPACKDATA_SOUNDASSET_ARRAY(PlayerSound, i);
 
    mathRead(*stream, &boxSize);
    mathRead(*stream, &crouchBoxSize);
@@ -1932,11 +1905,11 @@ bool Player::onNewDataBlock( GameBaseData *dptr, bool reload )
       SFX_DELETE( mMoveBubbleSound );
       SFX_DELETE( mWaterBreathSound );
 
-      if ( mDataBlock->sound[PlayerData::MoveBubbles] )
-         mMoveBubbleSound = SFX->createSource( mDataBlock->sound[PlayerData::MoveBubbles] );
+      if ( mDataBlock->getPlayerSound(PlayerData::MoveBubbles) )
+         mMoveBubbleSound = SFX->createSource( mDataBlock->getPlayerSoundProfile(PlayerData::MoveBubbles) );
 
-      if ( mDataBlock->sound[PlayerData::WaterBreath] )
-         mWaterBreathSound = SFX->createSource( mDataBlock->sound[PlayerData::WaterBreath] );
+      if ( mDataBlock->getPlayerSound(PlayerData::WaterBreath) )
+         mWaterBreathSound = SFX->createSource( mDataBlock->getPlayerSoundProfile(PlayerData::WaterBreath) );
    }
 
    mObjBox.maxExtents.x = mDataBlock->boxSize.x * 0.5f;
@@ -3300,7 +3273,7 @@ void Player::updateMove(const Move* move)
       {
          // exit-water splash sound happens for client only
          if ( getSpeed() >= mDataBlock->exitSplashSoundVel && !isMounted() )         
-            SFX->playOnce( mDataBlock->sound[PlayerData::ExitWater], &getTransform() );                     
+            SFX->playOnce( mDataBlock->getPlayerSoundProfile(PlayerData::ExitWater), &getTransform() );                     
       }
    }
 
@@ -7060,17 +7033,17 @@ void Player::playFootstepSound( bool triggeredLeft, Material* contactMaterial, S
       // Treading water.
 
       if ( mWaterCoverage < mDataBlock->footSplashHeight )
-         SFX->playOnce( mDataBlock->sound[ PlayerData::FootShallowSplash ], &footMat );
+         SFX->playOnce( mDataBlock->getPlayerSoundProfile( PlayerData::FootShallowSplash ), &footMat );
       else
       {
          if ( mWaterCoverage < 1.0 )
-            SFX->playOnce( mDataBlock->sound[ PlayerData::FootWading ], &footMat );
+            SFX->playOnce( mDataBlock->getPlayerSoundProfile( PlayerData::FootWading ), &footMat );
          else
          {
             if ( triggeredLeft )
             {
-               SFX->playOnce( mDataBlock->sound[ PlayerData::FootUnderWater ], &footMat );
-               SFX->playOnce( mDataBlock->sound[ PlayerData::FootBubbles ], &footMat );
+               SFX->playOnce( mDataBlock->getPlayerSoundProfile( PlayerData::FootUnderWater ), &footMat );
+               SFX->playOnce( mDataBlock->getPlayerSoundProfile( PlayerData::FootBubbles ), &footMat );
             }
          }
       }
@@ -7092,7 +7065,7 @@ void Player::playFootstepSound( bool triggeredLeft, Material* contactMaterial, S
          sound = 2;
 
       if (sound>=0)
-         SFX->playOnce(mDataBlock->sound[sound], &footMat);
+         SFX->playOnce(mDataBlock->getPlayerSoundProfile(sound), &footMat);
    }
 }
 
@@ -7123,7 +7096,7 @@ void Player:: playImpactSound()
                sound = 2; // Play metal;
 
             if (sound >= 0)
-               SFX->playOnce(mDataBlock->sound[PlayerData::ImpactStart + sound], &getTransform());
+               SFX->playOnce(mDataBlock->getPlayerSoundProfile(PlayerData::ImpactStart + sound), &getTransform());
          }
       }
    }
@@ -7277,11 +7250,11 @@ bool Player::collidingWithWater( Point3F &waterHeight )
 void Player::createSplash( Point3F &pos, F32 speed )
 {
    if ( speed >= mDataBlock->hardSplashSoundVel )
-      SFX->playOnce( mDataBlock->sound[PlayerData::ImpactWaterHard], &getTransform() );
+      SFX->playOnce( mDataBlock->getPlayerSoundProfile(PlayerData::ImpactWaterHard), &getTransform() );
    else if ( speed >= mDataBlock->medSplashSoundVel )
-      SFX->playOnce( mDataBlock->sound[PlayerData::ImpactWaterMedium], &getTransform() );
+      SFX->playOnce( mDataBlock->getPlayerSoundProfile(PlayerData::ImpactWaterMedium), &getTransform() );
    else
-      SFX->playOnce( mDataBlock->sound[PlayerData::ImpactWaterEasy], &getTransform() );
+      SFX->playOnce( mDataBlock->getPlayerSoundProfile(PlayerData::ImpactWaterEasy), &getTransform() );
 
    if( mDataBlock->splash )
    {
diff --git a/Engine/source/T3D/player.h b/Engine/source/T3D/player.h
index 042f45b37..5b775a79f 100644
--- a/Engine/source/T3D/player.h
+++ b/Engine/source/T3D/player.h
@@ -35,6 +35,7 @@
 #include "collision/boxConvex.h"
 #endif
 
+#include "T3D/assets/SoundAsset.h"
 #include "T3D/gameBase/gameProcess.h"
 
 class Material;
@@ -218,7 +219,9 @@ struct PlayerData: public ShapeBaseData {
       ExitWater,
       MaxSounds
    };
-   SFXTrack* sound[MaxSounds];
+
+   DECLARE_SOUNDASSET_ARRAY(PlayerData, PlayerSound, Sounds::MaxSounds);
+   DECLARE_SOUNDASSET_ARRAY_SETGET(PlayerData, PlayerSound);
 
    Point3F boxSize;           ///< Width, depth, height
    Point3F crouchBoxSize;

From 1c14dc5ec451543a95fdff7323abc1d96e0d227c Mon Sep 17 00:00:00 2001
From: marauder2k7 <ctrl-intelligence@live.co.uk>
Date: Wed, 29 Sep 2021 12:36:02 +0100
Subject: [PATCH 129/399] The beast is ready for a look over. Can't have a
 soundAsset inside a struct. If we could this might work better. PrevState
 needs to be kept track of for clearing looping sounds before the next state
 is loaded in. This might cause issues when switching weapons.

---
 Engine/source/T3D/shapeBase.h    | 15 ++++++++----
 Engine/source/T3D/shapeImage.cpp | 39 ++++++++++++++++++++------------
 2 files changed, 35 insertions(+), 19 deletions(-)

diff --git a/Engine/source/T3D/shapeBase.h b/Engine/source/T3D/shapeBase.h
index 4d3286b5c..bdfb68e4f 100644
--- a/Engine/source/T3D/shapeBase.h
+++ b/Engine/source/T3D/shapeBase.h
@@ -73,6 +73,7 @@
 
 // Need full definition visible for SimObjectPtr<ParticleEmitter>
 #include "T3D/fx/particleEmitter.h"
+#include "T3D/assets/SoundAsset.h"
 
 class GFXCubemap;
 class TSShapeInstance;
@@ -259,11 +260,12 @@ struct ShapeBaseImageData: public GameBaseData {
                                     ///  the imageSlot.
       ParticleEmitterData* emitter; ///< A particle emitter; this emitter will emit as long as the gun is in this
                                     ///  this state.
-      SFXTrack* sound;
+      
+      //SFXTrack* sound;
       F32 emitterTime;              ///<
       S32 emitterNode[MaxShapes];   ///< Node ID on the shape to emit from
+      //DECLARE_SOUNDASSET(StateData, Sound);
    };
-
    /// @name State Data
    /// Individual state data used to initialize struct array
    /// @{
@@ -321,7 +323,10 @@ struct ShapeBaseImageData: public GameBaseData {
 
    bool                    stateIgnoreLoadedForReady  [MaxStates];
 
-   SFXTrack*               stateSound                 [MaxStates];
+   DECLARE_SOUNDASSET_ARRAY(ShapeBaseImageData, stateSound, MaxStates);
+   DECLARE_SOUNDASSET_ARRAY_SETGET(ShapeBaseImageData, stateSound);
+
+   //SFXTrack*               stateSound                 [MaxStates];
    const char*             stateScript                [MaxStates];
 
    ParticleEmitterData*    stateEmitter               [MaxStates];
@@ -662,7 +667,7 @@ public:
    DECLARE_CALLBACK( void, onCollision, ( ShapeBase* obj, SceneObject* collObj, VectorF vec, F32 len ) );
    DECLARE_CALLBACK( void, onDamage, ( ShapeBase* obj, F32 delta ) );
    DECLARE_CALLBACK( void, onTrigger, ( ShapeBase* obj, S32 index, bool state ) );
-   DECLARE_CALLBACK(void, onEndSequence, (ShapeBase* obj, S32 slot, const char* name));
+   DECLARE_CALLBACK( void, onEndSequence, (ShapeBase* obj, S32 slot, const char* name));
    DECLARE_CALLBACK( void, onForceUncloak, ( ShapeBase* obj, const char* reason ) );
    /// @}
    struct TextureTagRemapping
@@ -1070,6 +1075,8 @@ protected:
    /// @param   imageSlot   Image slot id
    /// @param   state       State id
    /// @param   force       Force image to state or let it finish then change
+
+   U32 prevState = 0;
    void setImageState(U32 imageSlot, U32 state, bool force = false);
 
    void updateAnimThread(U32 imageSlot, S32 imageShapeIndex, ShapeBaseImageData::StateData* lastState=NULL);
diff --git a/Engine/source/T3D/shapeImage.cpp b/Engine/source/T3D/shapeImage.cpp
index 7bd42bea5..b60105329 100644
--- a/Engine/source/T3D/shapeImage.cpp
+++ b/Engine/source/T3D/shapeImage.cpp
@@ -132,7 +132,7 @@ ShapeBaseImageData::StateData::StateData()
    loaded = IgnoreLoaded;
    spin = IgnoreSpin;
    recoil = NoRecoil;
-   sound = 0;
+   //sound = 0;
    emitter = NULL;
    shapeSequence = NULL;
    shapeSequenceScale = true;
@@ -256,7 +256,7 @@ ShapeBaseImageData::ShapeBaseImageData()
       stateShapeSequence[i] = 0;
       stateScaleShapeSequence[i] = false;
 
-      stateSound[i] = 0;
+      INIT_SOUNDASSET_ARRAY(stateSound, i);
       stateScript[i] = 0;
       stateEmitter[i] = 0;
       stateEmitterTime[i] = 0;
@@ -303,6 +303,7 @@ ShapeBaseImageData::ShapeBaseImageData()
    camShakeDuration = 1.5f;
    camShakeRadius = 3.0f;
    camShakeFalloff = 10.0f;
+   
 }
 
 ShapeBaseImageData::~ShapeBaseImageData()
@@ -368,7 +369,7 @@ bool ShapeBaseImageData::onAdd()
          s.shapeSequence = stateShapeSequence[i];
          s.shapeSequenceScale = stateScaleShapeSequence[i];
 
-         s.sound = stateSound[i];
+         _setstateSound(getstateSound(i),i);
          s.script = stateScript[i];
          s.emitter = stateEmitter[i];
          s.emitterTime = stateEmitterTime[i];
@@ -419,10 +420,14 @@ bool ShapeBaseImageData::preload(bool server, String &errorStr)
          if (state[i].emitter)
             if (!Sim::findObject(SimObjectId((uintptr_t)state[i].emitter), state[i].emitter))
                Con::errorf(ConsoleLogEntry::General, "Error, unable to load emitter for image datablock");
-               
-         String str;
-         if( !sfxResolve( &state[ i ].sound, str ) )
-            Con::errorf( ConsoleLogEntry::General, str.c_str() );
+
+         if (getstateSound(i) != StringTable->EmptyString())
+         {
+            _setstateSound(getstateSound(i), i);
+            if (!getstateSoundProfile(i))
+               Con::errorf("ShapeBaseImageData::preload() - Could not find profile for asset %s on state %d", getstateSound(i), i);
+         }
+
       }
    }
 
@@ -922,8 +927,8 @@ void ShapeBaseImageData::initPersistFields()
       addField( "stateScaleShapeSequence", TypeBool, Offset(stateScaleShapeSequence, ShapeBaseImageData), MaxStates,
          "Indicates if the sequence to be played on the mounting shape should be scaled to the length of the state." );
 
-      addField( "stateSound", TypeSFXTrackName, Offset(stateSound, ShapeBaseImageData), MaxStates,
-         "Sound to play on entry to this state." );
+      INITPERSISTFIELD_SOUNDASSET_ARRAY(stateSound, MaxStates, ShapeBaseImageData, "State sound.");
+
       addField( "stateScript", TypeCaseString, Offset(stateScript, ShapeBaseImageData), MaxStates,
          "@brief Method to execute on entering this state.\n\n"
          "Scoped to this image class name, then ShapeBaseImageData. The script "
@@ -1140,7 +1145,7 @@ void ShapeBaseImageData::packData(BitStream* stream)
             }
          }
 
-         sfxWrite( stream, s.sound );
+         PACKDATA_SOUNDASSET_ARRAY(stateSound, i);
       }
    stream->write(maxConcurrentSounds);
    stream->writeFlag(useRemainderDT);
@@ -1345,7 +1350,7 @@ void ShapeBaseImageData::unpackData(BitStream* stream)
          else
             s.emitter = 0;
             
-         sfxRead( stream, &s.sound );
+         UNPACKDATA_SOUNDASSET_ARRAY(stateSound, i);
       }
    }
    
@@ -2753,9 +2758,10 @@ void ShapeBase::setImageState(U32 imageSlot, U32 newState,bool force)
    {
       onImageStateAnimation(imageSlot, stateData.shapeSequence, stateData.direction, stateData.shapeSequenceScale, stateData.timeoutValue);
    }
-
    // Delete any loooping sounds that were in the previous state.
-   if (lastState->sound && lastState->sound->getDescription()->mIsLooping)  
+   // this is the crazy bit =/ needs to know prev state in order to stop sounds.
+   // lastState does not return an id for the prev state so we keep track of it.
+   if (image.dataBlock->getstateSound(prevState) && image.dataBlock->getstateSoundProfile(prevState)->getDescription()->mIsLooping)
    {  
       for(Vector<SFXSource*>::iterator i = image.mSoundSources.begin(); i != image.mSoundSources.end(); i++)      
          SFX_DELETE((*i));    
@@ -2764,12 +2770,15 @@ void ShapeBase::setImageState(U32 imageSlot, U32 newState,bool force)
    }  
 
    // Play sound
-   if( stateData.sound && isGhost() )
+   if( image.dataBlock->getstateSound(newState) && isGhost() )
    {
       const Point3F& velocity         = getVelocity();
-      image.addSoundSource(SFX->createSource( stateData.sound, &getRenderTransform(), &velocity )); 
+      image.addSoundSource(SFX->createSource(image.dataBlock->getstateSoundProfile(newState), &getRenderTransform(), &velocity ));
    }
 
+   /// update our prevState.
+   prevState = newState;
+
    // Play animation
    updateAnimThread(imageSlot, imageShapeIndex, lastState);
    for (U32 i=0; i<ShapeBaseImageData::MaxShapes; ++i)

From 656096e01661b2bcb7ca549b6fc40576f00856cc Mon Sep 17 00:00:00 2001
From: marauder2k7 <ctrl-intelligence@live.co.uk>
Date: Wed, 29 Sep 2021 12:48:37 +0100
Subject: [PATCH 130/399] Another way of doing shapeBase, this requires fewer
 changes but will have an empty asset in each stateData until it is filled
 with an asset.

Both these will need to be tested to see which one is better.
---
 Engine/source/T3D/shapeBase.h    |  4 +---
 Engine/source/T3D/shapeImage.cpp | 15 +++++++--------
 2 files changed, 8 insertions(+), 11 deletions(-)

diff --git a/Engine/source/T3D/shapeBase.h b/Engine/source/T3D/shapeBase.h
index bdfb68e4f..a2696819e 100644
--- a/Engine/source/T3D/shapeBase.h
+++ b/Engine/source/T3D/shapeBase.h
@@ -264,7 +264,7 @@ struct ShapeBaseImageData: public GameBaseData {
       //SFXTrack* sound;
       F32 emitterTime;              ///<
       S32 emitterNode[MaxShapes];   ///< Node ID on the shape to emit from
-      //DECLARE_SOUNDASSET(StateData, Sound);
+      SoundAsset* sound;
    };
    /// @name State Data
    /// Individual state data used to initialize struct array
@@ -1075,8 +1075,6 @@ protected:
    /// @param   imageSlot   Image slot id
    /// @param   state       State id
    /// @param   force       Force image to state or let it finish then change
-
-   U32 prevState = 0;
    void setImageState(U32 imageSlot, U32 state, bool force = false);
 
    void updateAnimThread(U32 imageSlot, S32 imageShapeIndex, ShapeBaseImageData::StateData* lastState=NULL);
diff --git a/Engine/source/T3D/shapeImage.cpp b/Engine/source/T3D/shapeImage.cpp
index b60105329..ab43a0ba3 100644
--- a/Engine/source/T3D/shapeImage.cpp
+++ b/Engine/source/T3D/shapeImage.cpp
@@ -132,7 +132,7 @@ ShapeBaseImageData::StateData::StateData()
    loaded = IgnoreLoaded;
    spin = IgnoreSpin;
    recoil = NoRecoil;
-   //sound = 0;
+   sound = NULL;
    emitter = NULL;
    shapeSequence = NULL;
    shapeSequenceScale = true;
@@ -156,6 +156,7 @@ ShapeBaseImageData::StateData::StateData()
       flashSequence[i] = false;
       emitterNode[i] = -1;
    }
+
 }
 
 static ShapeBaseImageData::StateData gDefaultStateData;
@@ -369,7 +370,8 @@ bool ShapeBaseImageData::onAdd()
          s.shapeSequence = stateShapeSequence[i];
          s.shapeSequenceScale = stateScaleShapeSequence[i];
 
-         _setstateSound(getstateSound(i),i);
+         //_setstateSound(getstateSound(i),i);
+         s.sound = getstateSoundAsset(i);
          s.script = stateScript[i];
          s.emitter = stateEmitter[i];
          s.emitterTime = stateEmitterTime[i];
@@ -2761,7 +2763,7 @@ void ShapeBase::setImageState(U32 imageSlot, U32 newState,bool force)
    // Delete any loooping sounds that were in the previous state.
    // this is the crazy bit =/ needs to know prev state in order to stop sounds.
    // lastState does not return an id for the prev state so we keep track of it.
-   if (image.dataBlock->getstateSound(prevState) && image.dataBlock->getstateSoundProfile(prevState)->getDescription()->mIsLooping)
+   if (lastState->sound && lastState->sound->getSfxProfile()->getDescription()->mIsLooping)
    {  
       for(Vector<SFXSource*>::iterator i = image.mSoundSources.begin(); i != image.mSoundSources.end(); i++)      
          SFX_DELETE((*i));    
@@ -2770,15 +2772,12 @@ void ShapeBase::setImageState(U32 imageSlot, U32 newState,bool force)
    }  
 
    // Play sound
-   if( image.dataBlock->getstateSound(newState) && isGhost() )
+   if( stateData.sound && isGhost() )
    {
       const Point3F& velocity         = getVelocity();
-      image.addSoundSource(SFX->createSource(image.dataBlock->getstateSoundProfile(newState), &getRenderTransform(), &velocity ));
+      image.addSoundSource(SFX->createSource(stateData.sound->getSfxProfile(), &getRenderTransform(), &velocity ));
    }
 
-   /// update our prevState.
-   prevState = newState;
-
    // Play animation
    updateAnimThread(imageSlot, imageShapeIndex, lastState);
    for (U32 i=0; i<ShapeBaseImageData::MaxShapes; ++i)

From 0c6ca6c701152819743ade1f122682b79e470924 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Wed, 29 Sep 2021 12:38:47 -0500
Subject: [PATCH 131/399] conflict resolution

---
 Engine/source/T3D/fx/lightning.cpp | 22 ++++------------------
 1 file changed, 4 insertions(+), 18 deletions(-)

diff --git a/Engine/source/T3D/fx/lightning.cpp b/Engine/source/T3D/fx/lightning.cpp
index dc92c1647..0e28b1a42 100644
--- a/Engine/source/T3D/fx/lightning.cpp
+++ b/Engine/source/T3D/fx/lightning.cpp
@@ -296,34 +296,20 @@ bool LightningData::preload(bool server, String &errorStr)
    {
       for (S32 i = 0; i < MaxThunders; i++)
       {
-<<<<<<< HEAD
-         if (getThunderSound(i) != StringTable->EmptyString())
-=======
-         if (isThunderSoundValid(i))
->>>>>>> 2630b4ada6a97222ad1e200fa962cf426b7d4161
+         _setThunderSound(getThunderSound(i), i);
+         if (isThunderSoundValid(i) && !getThunderSoundProfile(i))
          {
-            _setThunderSound(getThunderSound(i), i);
-            Con::printf("Thunder sound: %d %s", i, getThunderSound(i));
-
-            if (!getThunderSoundProfile(i))
                Con::errorf(ConsoleLogEntry::General, "LightningData::preload: Cant get an sfxProfile for thunder.");
 
          }
 
       }
 
-<<<<<<< HEAD
-      if (getStrikeSound() != StringTable->EmptyString())
+      _setStrikeSound(getStrikeSound());
+      if (isStrikeSoundValid() && !getStrikeSoundProfile())
       {
-         _setStrikeSound(getStrikeSound());
-
-         if(!getStrikeSoundProfile())
             Con::errorf(ConsoleLogEntry::General, "LightningData::preload: can't get sfxProfile from strike sound.");
       }
-=======
-      if(isStrikeSoundValid() && !getStrikeSoundProfile())
-         Con::errorf(ConsoleLogEntry::General, "LightningData::preload: can't get sfxProfile from asset");
->>>>>>> 2630b4ada6a97222ad1e200fa962cf426b7d4161
 
       mNumStrikeTextures = 0;
       for (U32 k = 0; k < MaxTextures; k++) 

From 64a87ceba8a0d76b20c2efc60039d887f0131b12 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Thu, 30 Sep 2021 13:46:03 -0500
Subject: [PATCH 132/399] trim assetEnumNameConcat to 2 values, set
 INITPERSISTFIELD_SOUNDASSET_ENUMED to exclude maxValue

---
 Engine/source/T3D/assets/SoundAsset.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Engine/source/T3D/assets/SoundAsset.h b/Engine/source/T3D/assets/SoundAsset.h
index 7bbbcdc15..44817eb72 100644
--- a/Engine/source/T3D/assets/SoundAsset.h
+++ b/Engine/source/T3D/assets/SoundAsset.h
@@ -374,14 +374,14 @@ DefineEngineMethod(className, set##name, bool, (const char*  shape), , assetText
 
 #pragma endregion
 
-#define assetEnumNameConcat(x,suff,ForT)(new std::string(std::string(#x) + suff + std::string(#ForT)))->c_str()
+#define assetEnumNameConcat(x,suff)(new std::string( x + std::string(#suff)))->c_str()
 
 #define INITPERSISTFIELD_SOUNDASSET_ENUMED(name, enumType, maxValue, consoleClass, docs) \
-   for (U32 i = 0; i <= maxValue; i++)\
+   for (U32 i = 0; i < maxValue; i++)\
    {\
       const char* enumString = castConsoleTypeToString(static_cast<enumType>(i));\
-      addProtectedField(assetEnumNameConcat(name,enumString, File), TypeSoundFilename, Offset(m##name##Name[i], consoleClass), _set##name##Data, & defaultProtectedGetFn, assetText(name, docs), AbstractClassRep::FIELD_HideInInspectors); \
-      addProtectedField(assetEnumNameConcat(name,enumString, Asset), TypeSoundAssetId, Offset(m##name##AssetId[i], consoleClass), _set##name##Data, & defaultProtectedGetFn, assetText(name, asset reference.));\
+      addProtectedField(assetEnumNameConcat(enumString, File), TypeSoundFilename, Offset(m##name##Name[i], consoleClass), _set##name##Data, & defaultProtectedGetFn, assetText(name, docs), AbstractClassRep::FIELD_HideInInspectors); \
+      addProtectedField(assetEnumNameConcat(enumString, Asset), TypeSoundAssetId, Offset(m##name##AssetId[i], consoleClass), _set##name##Data, & defaultProtectedGetFn, assetText(name, asset reference.));\
    }\
 
 #pragma region Arrayed Asset Macros

From 65774ff123985804c1b1b6aa7e43c6a7aacfa357 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Thu, 30 Sep 2021 14:15:42 -0500
Subject: [PATCH 133/399] converter work pt1

---
 .../pre40/T3Dpre4ProjectImporter.tscript      | 21 ++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)

diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
index d9eec5f2e..4d368ea12 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
@@ -839,7 +839,7 @@ T3Dpre4ProjectImporter::genProcessor("LevelInfo", "accuTexture accuTextureAsset"
 T3Dpre4ProjectImporter::genProcessor("TSStatic", "shape shapeAsset shapeName shapeAsset");
 T3Dpre4ProjectImporter::genProcessor("TSForestItemData", "shape shapeAsset shapeName shapeAsset shapeFile shapeAsset");
 T3Dpre4ProjectImporter::genProcessor("TerrainBlock", "terrainFile terrainAsset");
-T3Dpre4ProjectImporter::genProcessor("afxMagicMissileData", "projectileShapeName projectileShapeAsset");
+T3Dpre4ProjectImporter::genProcessor("afxMagicMissileData", "projectileShapeName projectileShapeAsset sound soundAsset");
 T3Dpre4ProjectImporter::genProcessor("afxBillboardData", "texture textureAsset");
 T3Dpre4ProjectImporter::genProcessor("afxModelData", "shapeName shapeAsset shapeFile shapeAsset");
 T3Dpre4ProjectImporter::genProcessor("afxZodiacData", "texture textureAsset");
@@ -921,15 +921,30 @@ T3Dpre4ProjectImporter::genProcessor("DecalData", "material materialAsset");
 T3Dpre4ProjectImporter::genProcessor("ExplosionData", "explosionShape explosionShapeAsset");
 T3Dpre4ProjectImporter::genProcessor("ParticleData", "texture textureAsset textureName textureAsset textureExt textureExtAsset textureExtName textureExtAsset");
 T3Dpre4ProjectImporter::genProcessor("PrecipitationData", "drop dropAsset dropTexture dropAsset splash splashAsset splashTexture splashAsset soundProfile soundAsset");
-T3Dpre4ProjectImporter::genProcessor("SplashData", "texture textureAsset");
+T3Dpre4ProjectImporter::genProcessor("SplashData", "texture textureAsset soundProfile SoundAsset");
 T3Dpre4ProjectImporter::genProcessor("LightFlareData", "flareTexture flareTextureAsset");
 T3Dpre4ProjectImporter::genProcessor("PhysicsDebrisData", "shape shapeAsset shapeFile shapeAsset");
 T3Dpre4ProjectImporter::genProcessor("PhysicsShapeData", "shape shapeAsset shapeName shapeAsset");
 T3Dpre4ProjectImporter::genProcessor("PlayerData", "shapeFP shapeFPAsset shapeNameFP shapeFPAsset");
-T3Dpre4ProjectImporter::genProcessor("ProjectileData", "projectileShape projectileShapeAsset projectileShapeName projectileShapeAsset");
+T3Dpre4ProjectImporter::genProcessor("ProjectileData", "projectileShape projectileShapeAsset projectileShapeName projectileShapeAsset sound soundAsset");
 T3Dpre4ProjectImporter::genProcessor("ShapeBaseData", "shapeFile shapeAsset shape shapeAsset debrisShape debrisShapeAsset debrisShapeName debrisShapeAsset");
 T3Dpre4ProjectImporter::genProcessor("ShapeBaseImageData", "shape shapeAsset[0] shapeFP shapeAsset[1] shapeFile shapeAsset[0] shapeFileFP shapeAsset[1]");
 T3Dpre4ProjectImporter::genProcessor("WheeledVehicleTire", "shape shapeAsset shapeFile shapeAsset");
+T3Dpre4ProjectImporter::genProcessor("WheeledVehicleData", "engineSound engineSoundAsset squealSound squealSoundAsset");
+T3Dpre4ProjectImporter::genProcessor("FlyingVehicleData", "engineSound engineSoundAsset jetSound jetSoundAsset");
+T3Dpre4ProjectImporter::genProcessor("HoverVehicleData", "engineSound engineSoundAsset jetSound jetSoundAsset floatSound floatSoundAsset");
+
+//==============================================================================
+// Datablocks - Long Lists
+//==============================================================================
+
+$rigidSoundList = "softImpactSound softImpactSoundAsset hardImpactSound hardImpactSoundAsset";
+$rigidSoundList = $rigidSoundList SPC "exitingWater exitingWaterAsset impactWaterEasy impactWaterEasyAsset";
+$rigidSoundList = $rigidSoundList SPC "impactWaterMedium impactWaterMediumAsset impactWaterHard impactWaterHardAsset";
+$rigidSoundList = $rigidSoundList SPC "waterWakeSound waterWakeSoundAsset";
+T3Dpre4ProjectImporter::genProcessor("RigidShapeData",$rigidSoundList);
+
+
 //==============================================================================
 // Materials
 //==============================================================================

From d3693bef8dca3d2c5948f80ee28cccb38b851e23 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Thu, 30 Sep 2021 14:40:03 -0500
Subject: [PATCH 134/399] shifted playerdata down to the Long Lists block. fix
 player enum ref source side

---
 Engine/source/T3D/player.cpp                  |  2 +-
 .../pre40/T3Dpre4ProjectImporter.tscript      | 26 ++++++++++++++-----
 2 files changed, 20 insertions(+), 8 deletions(-)

diff --git a/Engine/source/T3D/player.cpp b/Engine/source/T3D/player.cpp
index 3144bfcd9..37655598f 100644
--- a/Engine/source/T3D/player.cpp
+++ b/Engine/source/T3D/player.cpp
@@ -204,7 +204,7 @@ ImplementEnumType(playerSoundsEnum, "enum types.\n"
    {PlayerData::Sounds::FootBubbles,         "FootBubbles","..." },
    {PlayerData::Sounds::MoveBubbles,         "MoveBubbles","..." },
    {PlayerData::Sounds::WaterBreath,         "WaterBreath","..." },
-   {PlayerData::Sounds::ImpactStart,         "ImpactStart","..." },
+   {PlayerData::Sounds::ImpactSoft,          "ImpactSoft","..." },
    {PlayerData::Sounds::ImpactHard,          "ImpactHard","..." },
    {PlayerData::Sounds::ImpactMetal,         "ImpactMetal","..." },
    {PlayerData::Sounds::ImpactSnow,          "ImpactSnow","..." },
diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
index 4d368ea12..8382fa7ca 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
@@ -925,10 +925,10 @@ T3Dpre4ProjectImporter::genProcessor("SplashData", "texture textureAsset soundPr
 T3Dpre4ProjectImporter::genProcessor("LightFlareData", "flareTexture flareTextureAsset");
 T3Dpre4ProjectImporter::genProcessor("PhysicsDebrisData", "shape shapeAsset shapeFile shapeAsset");
 T3Dpre4ProjectImporter::genProcessor("PhysicsShapeData", "shape shapeAsset shapeName shapeAsset");
-T3Dpre4ProjectImporter::genProcessor("PlayerData", "shapeFP shapeFPAsset shapeNameFP shapeFPAsset");
 T3Dpre4ProjectImporter::genProcessor("ProjectileData", "projectileShape projectileShapeAsset projectileShapeName projectileShapeAsset sound soundAsset");
 T3Dpre4ProjectImporter::genProcessor("ShapeBaseData", "shapeFile shapeAsset shape shapeAsset debrisShape debrisShapeAsset debrisShapeName debrisShapeAsset");
-T3Dpre4ProjectImporter::genProcessor("ShapeBaseImageData", "shape shapeAsset[0] shapeFP shapeAsset[1] shapeFile shapeAsset[0] shapeFileFP shapeAsset[1]");
+T3Dpre4ProjectImporter::genProcessor("ShapeBaseImageData", "shape shapeAsset[0] shapeFP shapeAsset[1] shapeFile shapeAsset[0] shapeFileFP shapeAsset[1] stateSound stateSoundAsset");
+T3Dpre4ProjectImporter::genProcessor("ProximityMineData","armingSound ArmSoundAsset TriggerSound TriggerSoundAsset");
 T3Dpre4ProjectImporter::genProcessor("WheeledVehicleTire", "shape shapeAsset shapeFile shapeAsset");
 T3Dpre4ProjectImporter::genProcessor("WheeledVehicleData", "engineSound engineSoundAsset squealSound squealSoundAsset");
 T3Dpre4ProjectImporter::genProcessor("FlyingVehicleData", "engineSound engineSoundAsset jetSound jetSoundAsset");
@@ -938,13 +938,25 @@ T3Dpre4ProjectImporter::genProcessor("HoverVehicleData", "engineSound engineSoun
 // Datablocks - Long Lists
 //==============================================================================
 
-$rigidSoundList = "softImpactSound softImpactSoundAsset hardImpactSound hardImpactSoundAsset";
-$rigidSoundList = $rigidSoundList SPC "exitingWater exitingWaterAsset impactWaterEasy impactWaterEasyAsset";
-$rigidSoundList = $rigidSoundList SPC "impactWaterMedium impactWaterMediumAsset impactWaterHard impactWaterHardAsset";
-$rigidSoundList = $rigidSoundList SPC "waterWakeSound waterWakeSoundAsset";
-T3Dpre4ProjectImporter::genProcessor("RigidShapeData",$rigidSoundList);
+$rigidEntriesList = "softImpactSound softImpactSoundAsset hardImpactSound hardImpactSoundAsset";
+$rigidEntriesList = $rigidEntriesList SPC "exitingWater exitingWaterAsset impactWaterEasy impactWaterEasyAsset";
+$rigidEntriesList = $rigidEntriesList SPC "impactWaterMedium impactWaterMediumAsset impactWaterHard impactWaterHardAsset";
+$rigidEntriesList = $rigidEntriesList SPC "waterWakeSound waterWakeSoundAsset";
+T3Dpre4ProjectImporter::genProcessor("RigidShapeData",$rigidEntriesList);
+
+$PlayerEntriesList = "shapeFP shapeFPAsset shapeNameFP shapeFPAsset";
+$PlayerEntriesList = $PlayerEntriesList SPC "FootSoftSound FootSoftAsset FootHardSound FootHardAsset";
+$PlayerEntriesList = $PlayerEntriesList SPC "FootSnowSound FootSnowAsset FootShallowSound FootShallowSplashAsset";
+$PlayerEntriesList = $PlayerEntriesList SPC "FootWadingSound FootWadingAsset FootUnderwaterSound FootUnderWaterAsset";
+$PlayerEntriesList = $PlayerEntriesList SPC "FootBubblesSound FootBubblesAsset movingBubblesSound MoveBubblesAsset";
+$PlayerEntriesList = $PlayerEntriesList SPC "waterBreathSound WaterBreathAsset";
+$PlayerEntriesList = $PlayerEntriesList SPC "impactSoftSound ImpactSoftAsset impactHardSound impactHardAsset";
+$PlayerEntriesList = $PlayerEntriesList SPC "impactMetalSound ImpactMetalAsset impactSnowSound impactSnowAsset";
+$PlayerEntriesList = $PlayerEntriesList SPC "impactWaterEasy impactWaterEasyAsset impactWaterMedium impactWaterMediumAsset impactWaterHard impactWaterHardAsset";
+$PlayerEntriesList = $PlayerEntriesList SPC "exitingWater ExitWaterAsset";
 
 
+T3Dpre4ProjectImporter::genProcessor("PlayerData", $PlayerEntriesList);
 //==============================================================================
 // Materials
 //==============================================================================

From 5c7069555a98cbfb7833b624fbbd44e20239f80c Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Thu, 30 Sep 2021 16:00:37 -0500
Subject: [PATCH 135/399] filter out array entries without enum strings

---
 Engine/source/T3D/assets/SoundAsset.h | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/Engine/source/T3D/assets/SoundAsset.h b/Engine/source/T3D/assets/SoundAsset.h
index 44817eb72..97b68f745 100644
--- a/Engine/source/T3D/assets/SoundAsset.h
+++ b/Engine/source/T3D/assets/SoundAsset.h
@@ -380,10 +380,12 @@ DefineEngineMethod(className, set##name, bool, (const char*  shape), , assetText
    for (U32 i = 0; i < maxValue; i++)\
    {\
       const char* enumString = castConsoleTypeToString(static_cast<enumType>(i));\
-      addProtectedField(assetEnumNameConcat(enumString, File), TypeSoundFilename, Offset(m##name##Name[i], consoleClass), _set##name##Data, & defaultProtectedGetFn, assetText(name, docs), AbstractClassRep::FIELD_HideInInspectors); \
-      addProtectedField(assetEnumNameConcat(enumString, Asset), TypeSoundAssetId, Offset(m##name##AssetId[i], consoleClass), _set##name##Data, & defaultProtectedGetFn, assetText(name, asset reference.));\
-   }\
-
+      if (enumString && enumString[0])\
+      {\
+         addProtectedField(assetEnumNameConcat(enumString, File), TypeSoundFilename, Offset(m##name##Name[i], consoleClass), _set##name##Data, & defaultProtectedGetFn, assetText(name, docs), AbstractClassRep::FIELD_HideInInspectors); \
+         addProtectedField(assetEnumNameConcat(enumString, Asset), TypeSoundAssetId, Offset(m##name##AssetId[i], consoleClass), _set##name##Data, & defaultProtectedGetFn, assetText(name, asset reference.));\
+      }\
+   }
 #pragma region Arrayed Asset Macros
 
 #define DECLARE_SOUNDASSET_ARRAY(className,name,max) public: \

From 1676d102f35cc588bf717897ff5e5bc35125a046 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Sat, 2 Oct 2021 16:22:55 -0400
Subject: [PATCH 136/399] * [AssetBrowser] BugFix: Correct a logic error in the
 filtering of the asset browser causing tags queries to display all assets.

---
 .../game/tools/assetBrowser/scripts/assetBrowser.tscript        | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
index 747d3e86d..660577c78 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
@@ -1802,7 +1802,7 @@ function matchesSearch(%assetName, %assetType)
          }
          else
          {
-            if(%assetName.tags !$= %word)
+            if(strstr(strlwr(%assetName.tags), strlwr(%word)) != -1)
                %matchTags = true;
          }
       }

From 5e88ab25708cb9771d99fb5b1e5c02d94586a9d6 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Fri, 1 Oct 2021 21:34:45 -0400
Subject: [PATCH 137/399] * BugFix: Fix AL device listing so that functions
 like sfxGetAvailableDevices return the actual devices on the system.

---
 Engine/source/sfx/openal/aldlist.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Engine/source/sfx/openal/aldlist.cpp b/Engine/source/sfx/openal/aldlist.cpp
index a453579e3..8f7c0d4a6 100644
--- a/Engine/source/sfx/openal/aldlist.cpp
+++ b/Engine/source/sfx/openal/aldlist.cpp
@@ -56,7 +56,7 @@ ALDeviceList::ALDeviceList( const OPENALFNTABLE &oalft )
 
    // grab function pointers for 1.0-API functions, and if successful proceed to enumerate all devices
    if (ALFunction.alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT")) {
-      devices = (char *)ALFunction.alcGetString(NULL, ALC_DEVICE_SPECIFIER);
+      devices = (char *)ALFunction.alcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER);
       defaultDeviceName = (char *)ALFunction.alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER);
       index = 0;
       // go through device list (each device terminated with a single NULL, list terminated with double NULL)
@@ -70,7 +70,7 @@ ALDeviceList::ALDeviceList( const OPENALFNTABLE &oalft )
             if (context) {
                ALFunction.alcMakeContextCurrent(context);
                // if new actual device name isn't already in the list, then add it...
-               actualDeviceName = ALFunction.alcGetString(device, ALC_DEVICE_SPECIFIER);
+               actualDeviceName = devices;
                bool bNewName = true;
                for (int i = 0; i < GetNumDevices(); i++) {
                   if (String::compare(GetDeviceName(i), actualDeviceName) == 0) {
@@ -313,4 +313,4 @@ unsigned int ALDeviceList::GetMaxNumSources()
 	}
 
 	return iSourceCount;
-}
\ No newline at end of file
+}

From c99c9cc3652fb6c0b86c9857587d7bbfd12bec64 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Sat, 2 Oct 2021 20:58:44 -0500
Subject: [PATCH 138/399] include metal FootMetalSound oversight, include
 correction for mangled entries where a given varname and a given assetname
 match

---
 .../scripts/pre40/T3Dpre4ProjectImporter.tscript       |  2 +-
 .../projectImporter/scripts/projectImporter.tscript    | 10 +++++-----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
index 8382fa7ca..119ba6066 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
@@ -945,7 +945,7 @@ $rigidEntriesList = $rigidEntriesList SPC "waterWakeSound waterWakeSoundAsset";
 T3Dpre4ProjectImporter::genProcessor("RigidShapeData",$rigidEntriesList);
 
 $PlayerEntriesList = "shapeFP shapeFPAsset shapeNameFP shapeFPAsset";
-$PlayerEntriesList = $PlayerEntriesList SPC "FootSoftSound FootSoftAsset FootHardSound FootHardAsset";
+$PlayerEntriesList = $PlayerEntriesList SPC "FootSoftSound FootSoftAsset FootHardSound FootHardAsset FootMetalSound FootMetal";
 $PlayerEntriesList = $PlayerEntriesList SPC "FootSnowSound FootSnowAsset FootShallowSound FootShallowSplashAsset";
 $PlayerEntriesList = $PlayerEntriesList SPC "FootWadingSound FootWadingAsset FootUnderwaterSound FootUnderWaterAsset";
 $PlayerEntriesList = $PlayerEntriesList SPC "FootBubblesSound FootBubblesAsset movingBubblesSound MoveBubblesAsset";
diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
index eca0e0b07..cfdd7c8bf 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
@@ -515,7 +515,7 @@ function testFilenameExtensions(%filename)
 }
 
 function processLegacyField(%line, %originalFieldName, %newFieldName)
-{
+{ 
    if(!strIsMatchExpr("*"@%originalFieldName@"=*;*", %line) && 
       !strIsMatchExpr("*"@%originalFieldName@"[*=*;*", %line) &&
       !strIsMatchExpr("*"@%originalFieldName@" *=*;*", %line))
@@ -603,10 +603,10 @@ function processLegacyField(%line, %originalFieldName, %newFieldName)
          if(!strIsMatchExpr("*\"*\"*", %originalValue))
             %assetId = "\"" @ %assetId @ "\"";
          
-         //if (%assetId.getStatusString() $= "Ok")
-         %outLine = strReplace(%outLine, %value, %assetId);
-         //else
-         //   error("Asset assignment failure:", %assetId, getStatusString());
+         %firstPart = getToken(%outLine, "=", 0);
+         %secondPart = getToken(%outLine, "=", 1);
+         %secondPart = strReplace(%secondPart, %value, %assetId);
+         %outLine = %firstPart @ "=" @ %secondPart;
       }
    }
    

From 0760621212117b9e6eeeafcf133019aa4b08cb8d Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Sat, 2 Oct 2021 21:01:14 -0500
Subject: [PATCH 139/399] fix item->importStatus tagging in importer

---
 Engine/source/T3D/assets/assetImporter.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Engine/source/T3D/assets/assetImporter.cpp b/Engine/source/T3D/assets/assetImporter.cpp
index 5df1ca8ab..254df381d 100644
--- a/Engine/source/T3D/assets/assetImporter.cpp
+++ b/Engine/source/T3D/assets/assetImporter.cpp
@@ -1409,7 +1409,7 @@ void AssetImporter::processImportAssets(AssetImportObject* assetItem)
 		      Con::executef(this, processCommand.c_str(), item);
 		}
 
-      item->importStatus == AssetImportObject::Processed;
+      item->importStatus = AssetImportObject::Processed;
 
       //try recusing on the children(if any)
       processImportAssets(item);
@@ -2018,7 +2018,7 @@ void AssetImporter::validateAsset(AssetImportObject* assetItem)
       AssetQuery aQuery;
       U32 numAssetsFound = AssetDatabase.findAllAssets(&aQuery);
 
-      bool hasCollision = false;
+      hasCollision = false;
       for (U32 i = 0; i < numAssetsFound; i++)
       {
          StringTableEntry assetId = aQuery.mAssetList[i];

From 19eb3c42f015a80b09bfeb7f66181ce3af8ad8fa Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Sat, 2 Oct 2021 21:05:04 -0500
Subject: [PATCH 140/399] more enum work, now with somewhat clearer boundary
 names, and some debug spam for initpersistfields, and pack and unpack macros
 to help us try and trace why those are scrambling

---
 Engine/source/T3D/assets/SoundAsset.h | 47 ++++++++++++++++++--
 Engine/source/T3D/player.cpp          | 64 +++++++++++++--------------
 Engine/source/T3D/player.h            |  4 +-
 3 files changed, 77 insertions(+), 38 deletions(-)

diff --git a/Engine/source/T3D/assets/SoundAsset.h b/Engine/source/T3D/assets/SoundAsset.h
index 97b68f745..5a9af9eb3 100644
--- a/Engine/source/T3D/assets/SoundAsset.h
+++ b/Engine/source/T3D/assets/SoundAsset.h
@@ -381,11 +381,18 @@ DefineEngineMethod(className, set##name, bool, (const char*  shape), , assetText
    {\
       const char* enumString = castConsoleTypeToString(static_cast<enumType>(i));\
       if (enumString && enumString[0])\
-      {\
+      { Con::printf("%s", enumString);\
          addProtectedField(assetEnumNameConcat(enumString, File), TypeSoundFilename, Offset(m##name##Name[i], consoleClass), _set##name##Data, & defaultProtectedGetFn, assetText(name, docs), AbstractClassRep::FIELD_HideInInspectors); \
          addProtectedField(assetEnumNameConcat(enumString, Asset), TypeSoundAssetId, Offset(m##name##AssetId[i], consoleClass), _set##name##Data, & defaultProtectedGetFn, assetText(name, asset reference.));\
       }\
    }
+
+#define INITPERSISTFIELD_SOUNDASSET_ENUM(enumString, name, enumVal, consoleClass, docs) \
+      {\
+         addProtectedField(assetText(enumString, File), TypeSoundFilename, Offset(m##name##Name[enumVal], consoleClass), _set##name##Data, & defaultProtectedGetFn, assetText(name[enumVal], docs), AbstractClassRep::FIELD_HideInInspectors); \
+         addProtectedField(assetText(enumString, Asset), TypeSoundAssetId, Offset(m##name##AssetId[enumVal], consoleClass), _set##name##Data, & defaultProtectedGetFn, assetText(name[enumVal], asset reference.));\
+      }\
+
 #pragma region Arrayed Asset Macros
 
 #define DECLARE_SOUNDASSET_ARRAY(className,name,max) public: \
@@ -574,6 +581,7 @@ DefineEngineMethod(className, set##name, bool, (const char* map, S32 index), , a
    m##name##Name[index] = other.m##name##Name[index];\
    m##name##AssetId[index] = other.m##name##AssetId[index];\
    m##name##Asset[index] = other.m##name##Asset[index];\
+   m##name[index] = = other.m##name[index];\
 }
 
 #define LOAD_SOUNDASSET_ARRAY(name, index)\
@@ -602,7 +610,10 @@ if (m##name##AssetId[index] != StringTable->EmptyString())\
       _set##name(m##name##AssetId[index], index);\
    }\
    else\
-      m##name##Name[index] = stream->readSTString();
+   {\
+      m##name##Name[index] = stream->readSTString();\
+      _set##name(m##name##AssetId[index], index);\
+   }
 
 #define PACK_SOUNDASSET_ARRAY(netconn, name, index)\
    if (stream->writeFlag(m##name##Asset[index].notNull()))\
@@ -620,8 +631,38 @@ if (m##name##AssetId[index] != StringTable->EmptyString())\
       _set##name(m##name##AssetId[index], index);\
    }\
    else\
-      m##name##Name[index] = stream->readSTString();
+   {\
+      m##name##Name[index] = stream->readSTString();\
+      _set##name(m##name##AssetId[index], index);\
+   }
 
+#define PACKDATA_SOUNDASSET_ARRAY_ENUMED(name, enumType, index )\
+{\
+   if (stream->writeFlag(m##name##Asset[index].notNull()))\
+   {\
+      stream->writeString(m##name##Asset[index].getAssetId());\
+      const char* enumString = castConsoleTypeToString(static_cast<enumType>(index));\
+      Con::printf("pack: %s = %s",enumString, m##name##AssetId[index]);\
+   }\
+   else\
+      stream->writeString(m##name##Name[index]);\
+}
+
+#define UNPACKDATA_SOUNDASSET_ARRAY_ENUMED(name, enumType, index )\
+{\
+   if (stream->readFlag())\
+   {\
+      m##name##AssetId[index] = stream->readSTString();\
+      _set##name(m##name##AssetId[index], index);\
+      const char* enumString = castConsoleTypeToString(static_cast<enumType>(index));\
+      Con::printf("unpack: %s = %s",enumString, m##name##AssetId[index]);\
+   }\
+   else\
+   {\
+      m##name##Name[index] = stream->readSTString();\
+      _set##name(m##name##AssetId[index], index);\
+   }\
+}
 #pragma endregion
 
 #endif // _ASSET_BASE_H_
diff --git a/Engine/source/T3D/player.cpp b/Engine/source/T3D/player.cpp
index 37655598f..3e994995a 100644
--- a/Engine/source/T3D/player.cpp
+++ b/Engine/source/T3D/player.cpp
@@ -194,24 +194,24 @@ DefineEnumType(playerSoundsEnum);
 
 ImplementEnumType(playerSoundsEnum, "enum types.\n"
    "@ingroup PlayerData\n\n")
-   {PlayerData::Sounds::FootSoft,            "FootSoft","..." },
-   {PlayerData::Sounds::FootHard,            "FootHard","..." },
-   {PlayerData::Sounds::FootMetal,           "FootMetal","..." },
-   {PlayerData::Sounds::FootSnow,            "FootSnow","..." },
-   {PlayerData::Sounds::FootShallowSplash,   "FootShallowSplash","..." },
-   {PlayerData::Sounds::FootWading,          "FootWading","..." },
-   {PlayerData::Sounds::FootUnderWater,      "FootUnderWater","..." },
-   {PlayerData::Sounds::FootBubbles,         "FootBubbles","..." },
-   {PlayerData::Sounds::MoveBubbles,         "MoveBubbles","..." },
-   {PlayerData::Sounds::WaterBreath,         "WaterBreath","..." },
-   {PlayerData::Sounds::ImpactSoft,          "ImpactSoft","..." },
-   {PlayerData::Sounds::ImpactHard,          "ImpactHard","..." },
-   {PlayerData::Sounds::ImpactMetal,         "ImpactMetal","..." },
-   {PlayerData::Sounds::ImpactSnow,          "ImpactSnow","..." },
-   {PlayerData::Sounds::ImpactWaterEasy,     "ImpactWaterEasy","..." },
-   {PlayerData::Sounds::ImpactWaterMedium,   "ImpactWaterMedium","..." },
-   {PlayerData::Sounds::ImpactWaterHard,     "ImpactWaterHard","..." },
-   {PlayerData::Sounds::ExitWater,           "ExitWater","..." },
+   { playerSoundsEnum::FootSoft,            "FootSoft", "..." },
+   { playerSoundsEnum::FootHard,            "FootHard","..." },
+   { playerSoundsEnum::FootMetal,           "FootMetal","..." },
+   { playerSoundsEnum::FootSnow,            "FootSnow","..." },
+   { playerSoundsEnum::FootShallowSplash,   "FootShallowSplash","..." },
+   { playerSoundsEnum::FootWading,          "FootWading","..." },
+   { playerSoundsEnum::FootUnderWater,      "FootUnderWater","..." },
+   { playerSoundsEnum::FootBubbles,         "FootBubbles","..." },
+   { playerSoundsEnum::MoveBubbles,         "MoveBubbles","..." },
+   { playerSoundsEnum::WaterBreath,         "WaterBreath","..." },
+   { playerSoundsEnum::ImpactSoft,          "ImpactSoft","..." },
+   { playerSoundsEnum::ImpactHard,          "ImpactHard","..." },
+   { playerSoundsEnum::ImpactMetal,         "ImpactMetal","..." },
+   { playerSoundsEnum::ImpactSnow,          "ImpactSnow","..." },
+   { playerSoundsEnum::ImpactWaterEasy,     "ImpactWaterEasy","..." },
+   { playerSoundsEnum::ImpactWaterMedium,   "ImpactWaterMedium","..." },
+   { playerSoundsEnum::ImpactWaterHard,     "ImpactWaterHard","..." },
+   { playerSoundsEnum::ExitWater,           "ExitWater","..." },
 EndImplementEnumType;
 
 //----------------------------------------------------------------------------
@@ -469,18 +469,16 @@ bool PlayerData::preload(bool server, String &errorStr)
    if(!Parent::preload(server, errorStr))
       return false;
 
-   // Resolve objects transmitted from server
-   if( !server )
+   for (U32 i = 0; i < MaxSounds; ++i)
    {
-      for( U32 i = 0; i < MaxSounds; ++ i )
+      _setPlayerSound(getPlayerSound(i), i);
+      if (getPlayerSound(i) != StringTable->EmptyString())
       {
-         if (getPlayerSound(i) != StringTable->EmptyString())
-         {
-            _setPlayerSound(getPlayerSound(i), i);
-         }
-
          if (!getPlayerSoundProfile(i))
-            Con::errorf("PlayerData::Preload() - unable to find sfxProfile for asset %d %s", i, getPlayerSound(i));
+            Con::errorf("PlayerData::Preload() - unable to find sfxProfile for asset %d %s", i, mPlayerSoundAssetId[i]);
+
+         const char* enumString = castConsoleTypeToString(static_cast<Sounds>(i));
+            Con::printf("preload: %s = %s", enumString, mPlayerSoundAssetId[i]);
       }
    }
 
@@ -1051,7 +1049,7 @@ void PlayerData::initPersistFields()
 
    addGroup( "Interaction: Sounds" );
 
-      INITPERSISTFIELD_SOUNDASSET_ENUMED(PlayerSound, playerSoundsEnum, PlayerData::Sounds::MaxSounds, PlayerData, "Sounds related to player interaction.");
+   INITPERSISTFIELD_SOUNDASSET_ENUMED(PlayerSound, playerSoundsEnum, PlayerData::Sounds::MaxSounds, PlayerData, "Sounds related to player interaction.");
 
    endGroup( "Interaction: Sounds" );
 
@@ -1277,7 +1275,7 @@ void PlayerData::packData(BitStream* stream)
    stream->write(minLateralImpactSpeed);
 
    for (U32 i = 0; i < MaxSounds; i++)
-      PACKDATA_SOUNDASSET_ARRAY(PlayerSound, i);
+      PACKDATA_SOUNDASSET_ARRAY_ENUMED(PlayerSound, PlayerData::Sounds, i);
 
    mathWrite(*stream, boxSize);
    mathWrite(*stream, crouchBoxSize);
@@ -1458,7 +1456,7 @@ void PlayerData::unpackData(BitStream* stream)
    stream->read(&minLateralImpactSpeed);
 
    for (U32 i = 0; i < MaxSounds; i++)
-      UNPACKDATA_SOUNDASSET_ARRAY(PlayerSound, i);
+      UNPACKDATA_SOUNDASSET_ARRAY_ENUMED(PlayerSound, PlayerData::Sounds, i);
 
    mathRead(*stream, &boxSize);
    mathRead(*stream, &crouchBoxSize);
@@ -7059,7 +7057,7 @@ void Player::playFootstepSound( bool triggeredLeft, Material* contactMaterial, S
       // Play default sound.
 
       S32 sound = -1;
-      if (contactMaterial && (contactMaterial->mFootstepSoundId>-1 && contactMaterial->mFootstepSoundId<PlayerData::MaxSoundOffsets))
+      if (contactMaterial && (contactMaterial->mFootstepSoundId > -1 && contactMaterial->mFootstepSoundId < PlayerData::WaterStart))
          sound = contactMaterial->mFootstepSoundId;
       else if( contactObject && contactObject->getTypeMask() & VehicleObjectType )
          sound = 2;
@@ -7090,13 +7088,13 @@ void Player:: playImpactSound()
          else
          {
             S32 sound = -1;
-            if (material && (material->mImpactSoundId>-1 && material->mImpactSoundId<PlayerData::MaxSoundOffsets))
+            if (material && (material->mImpactSoundId > -1 && material->mImpactSoundId < PlayerData::WaterStart))
                sound = material->mImpactSoundId;
             else if( rInfo.object->getTypeMask() & VehicleObjectType )
                sound = 2; // Play metal;
 
             if (sound >= 0)
-               SFX->playOnce(mDataBlock->getPlayerSoundProfile(PlayerData::ImpactStart + sound), &getTransform());
+               SFX->playOnce(mDataBlock->getPlayerSoundProfile(PlayerData::ImpactSoft + sound), &getTransform());
          }
       }
    }
diff --git a/Engine/source/T3D/player.h b/Engine/source/T3D/player.h
index 5b775a79f..55430749c 100644
--- a/Engine/source/T3D/player.h
+++ b/Engine/source/T3D/player.h
@@ -201,8 +201,8 @@ struct PlayerData: public ShapeBaseData {
       FootHard,
       FootMetal,
       FootSnow,
-      MaxSoundOffsets,
-      FootShallowSplash,
+      WaterStart,
+      FootShallowSplash = WaterStart,
       FootWading,
       FootUnderWater,
       FootBubbles,

From 43630c31c2938efb107eca01494fd73633e56fea Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Sat, 2 Oct 2021 22:24:11 -0400
Subject: [PATCH 141/399] * BugFix: Tweaks to the ALC device listing logic to
 be more consistent with the AL API.

---
 Engine/source/sfx/openal/aldlist.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Engine/source/sfx/openal/aldlist.cpp b/Engine/source/sfx/openal/aldlist.cpp
index 8f7c0d4a6..51f5a3b51 100644
--- a/Engine/source/sfx/openal/aldlist.cpp
+++ b/Engine/source/sfx/openal/aldlist.cpp
@@ -55,9 +55,9 @@ ALDeviceList::ALDeviceList( const OPENALFNTABLE &oalft )
    defaultDeviceIndex = 0;
 
    // grab function pointers for 1.0-API functions, and if successful proceed to enumerate all devices
-   if (ALFunction.alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT")) {
+   if (ALFunction.alcIsExtensionPresent(NULL, "ALC_ENUMERATE_ALL_EXT")) {
       devices = (char *)ALFunction.alcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER);
-      defaultDeviceName = (char *)ALFunction.alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER);
+      defaultDeviceName = (char *)ALFunction.alcGetString(NULL, ALC_DEFAULT_ALL_DEVICES_SPECIFIER);
       index = 0;
       // go through device list (each device terminated with a single NULL, list terminated with double NULL)
       while (*devices != 0) {

From 6a94946e5b1621b2e0e2bdce45e016816f247b21 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Sat, 2 Oct 2021 22:29:34 -0400
Subject: [PATCH 142/399] * BugFix: Fallback to ALC_ENUMERATION_EXT if
 ALC_ENUMERATE_ALL_EXT is not available.

---
 Engine/source/sfx/openal/aldlist.cpp | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/Engine/source/sfx/openal/aldlist.cpp b/Engine/source/sfx/openal/aldlist.cpp
index 51f5a3b51..73307f50b 100644
--- a/Engine/source/sfx/openal/aldlist.cpp
+++ b/Engine/source/sfx/openal/aldlist.cpp
@@ -55,9 +55,20 @@ ALDeviceList::ALDeviceList( const OPENALFNTABLE &oalft )
    defaultDeviceIndex = 0;
 
    // grab function pointers for 1.0-API functions, and if successful proceed to enumerate all devices
-   if (ALFunction.alcIsExtensionPresent(NULL, "ALC_ENUMERATE_ALL_EXT")) {
-      devices = (char *)ALFunction.alcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER);
-      defaultDeviceName = (char *)ALFunction.alcGetString(NULL, ALC_DEFAULT_ALL_DEVICES_SPECIFIER);
+   const bool enumerationExtensionPresent = ALFunction.alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT");
+   const bool enumerateAllExtensionPresent = ALFunction.alcIsExtensionPresent(NULL, "ALC_ENUMERATE_ALL_EXT");
+   if (enumerateAllExtensionPresent || enumerationExtensionPresent) {
+      if (enumerateAllExtensionPresent)
+      {
+          devices = (char *)ALFunction.alcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER);
+          defaultDeviceName = (char *)ALFunction.alcGetString(NULL, ALC_DEFAULT_ALL_DEVICES_SPECIFIER);
+      }
+      else
+      {
+          devices = (char *)ALFunction.alcGetString(NULL, ALC_DEVICE_SPECIFIER);
+          defaultDeviceName = (char *)ALFunction.alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER);
+      }
+
       index = 0;
       // go through device list (each device terminated with a single NULL, list terminated with double NULL)
       while (*devices != 0) {

From 10f2453ceede5fd9f8a9ef6648c77fef9e22d2a9 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Sat, 2 Oct 2021 23:24:46 -0500
Subject: [PATCH 143/399] setget was causing active interference with
 INITPERSISTFIELD_SOUNDASSET_ENUMED

---
 Engine/source/T3D/assets/SoundAsset.h | 32 +++++++++++----------------
 Engine/source/T3D/player.h            |  1 -
 2 files changed, 13 insertions(+), 20 deletions(-)

diff --git a/Engine/source/T3D/assets/SoundAsset.h b/Engine/source/T3D/assets/SoundAsset.h
index 5a9af9eb3..1d98b61b1 100644
--- a/Engine/source/T3D/assets/SoundAsset.h
+++ b/Engine/source/T3D/assets/SoundAsset.h
@@ -374,25 +374,6 @@ DefineEngineMethod(className, set##name, bool, (const char*  shape), , assetText
 
 #pragma endregion
 
-#define assetEnumNameConcat(x,suff)(new std::string( x + std::string(#suff)))->c_str()
-
-#define INITPERSISTFIELD_SOUNDASSET_ENUMED(name, enumType, maxValue, consoleClass, docs) \
-   for (U32 i = 0; i < maxValue; i++)\
-   {\
-      const char* enumString = castConsoleTypeToString(static_cast<enumType>(i));\
-      if (enumString && enumString[0])\
-      { Con::printf("%s", enumString);\
-         addProtectedField(assetEnumNameConcat(enumString, File), TypeSoundFilename, Offset(m##name##Name[i], consoleClass), _set##name##Data, & defaultProtectedGetFn, assetText(name, docs), AbstractClassRep::FIELD_HideInInspectors); \
-         addProtectedField(assetEnumNameConcat(enumString, Asset), TypeSoundAssetId, Offset(m##name##AssetId[i], consoleClass), _set##name##Data, & defaultProtectedGetFn, assetText(name, asset reference.));\
-      }\
-   }
-
-#define INITPERSISTFIELD_SOUNDASSET_ENUM(enumString, name, enumVal, consoleClass, docs) \
-      {\
-         addProtectedField(assetText(enumString, File), TypeSoundFilename, Offset(m##name##Name[enumVal], consoleClass), _set##name##Data, & defaultProtectedGetFn, assetText(name[enumVal], docs), AbstractClassRep::FIELD_HideInInspectors); \
-         addProtectedField(assetText(enumString, Asset), TypeSoundAssetId, Offset(m##name##AssetId[enumVal], consoleClass), _set##name##Data, & defaultProtectedGetFn, assetText(name[enumVal], asset reference.));\
-      }\
-
 #pragma region Arrayed Asset Macros
 
 #define DECLARE_SOUNDASSET_ARRAY(className,name,max) public: \
@@ -663,6 +644,19 @@ if (m##name##AssetId[index] != StringTable->EmptyString())\
       _set##name(m##name##AssetId[index], index);\
    }\
 }
+
+#define assetEnumNameConcat(x,suff)(new std::string( x + std::string(#suff)))->c_str()
+
+#define INITPERSISTFIELD_SOUNDASSET_ENUMED(name, enumType, maxValue, consoleClass, docs) \
+   for (U32 i = 0; i < maxValue; i++)\
+   {\
+      const char* enumString = castConsoleTypeToString(static_cast<enumType>(i));\
+      if (enumString && enumString[0])\
+      { Con::printf("%s", enumString);\
+         addField(assetEnumNameConcat(enumString, File), TypeSoundFilename, Offset(m##name##Name[i], consoleClass), assetText(name, docs), AbstractClassRep::FIELD_HideInInspectors); \
+         addField(assetEnumNameConcat(enumString, Asset), TypeSoundAssetId, Offset(m##name##AssetId[i], consoleClass), assetText(name, asset reference.));\
+      }\
+   }
 #pragma endregion
 
 #endif // _ASSET_BASE_H_
diff --git a/Engine/source/T3D/player.h b/Engine/source/T3D/player.h
index 55430749c..ed0cfea63 100644
--- a/Engine/source/T3D/player.h
+++ b/Engine/source/T3D/player.h
@@ -221,7 +221,6 @@ struct PlayerData: public ShapeBaseData {
    };
 
    DECLARE_SOUNDASSET_ARRAY(PlayerData, PlayerSound, Sounds::MaxSounds);
-   DECLARE_SOUNDASSET_ARRAY_SETGET(PlayerData, PlayerSound);
 
    Point3F boxSize;           ///< Width, depth, height
    Point3F crouchBoxSize;

From 98a079a797c6e85bece7d9ea6ea541618a1cdf90 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Sun, 3 Oct 2021 02:56:26 -0500
Subject: [PATCH 144/399] code duplication prune. should aid in stability

---
 Engine/source/T3D/accumulationVolume.cpp      |   6 +-
 Engine/source/T3D/accumulationVolume.h        |   2 +-
 Engine/source/T3D/assets/ImageAsset.h         | 135 +--------
 Engine/source/T3D/assets/MaterialAsset.h      |  85 +-----
 Engine/source/T3D/assets/ShapeAsset.h         | 181 +-----------
 Engine/source/T3D/assets/SoundAsset.h         | 214 +-------------
 Engine/source/T3D/assets/assetMacroHelpers.h  | 274 ++++++++++++++++++
 Engine/source/T3D/convexShape.cpp             |   8 +-
 Engine/source/T3D/convexShape.h               |   6 +-
 Engine/source/T3D/debris.cpp                  |   8 +-
 Engine/source/T3D/debris.h                    |   2 +-
 Engine/source/T3D/decal/decalData.cpp         |   6 +-
 Engine/source/T3D/decal/decalData.h           |   4 +-
 .../source/T3D/examples/renderMeshExample.cpp |   6 +-
 .../source/T3D/examples/renderMeshExample.h   |   2 +-
 .../T3D/examples/renderShapeExample.cpp       |   6 +-
 .../source/T3D/examples/renderShapeExample.h  |   2 +-
 Engine/source/T3D/fx/explosion.cpp            |  16 +-
 Engine/source/T3D/fx/explosion.h              |   4 +-
 Engine/source/T3D/fx/groundCover.cpp          |  12 +-
 Engine/source/T3D/fx/groundCover.h            |   4 +-
 Engine/source/T3D/fx/lightning.cpp            |  12 +-
 Engine/source/T3D/fx/lightning.h              |   4 +-
 Engine/source/T3D/fx/particle.cpp             |  18 +-
 Engine/source/T3D/fx/particle.h               |   4 +-
 Engine/source/T3D/fx/precipitation.cpp        |  18 +-
 Engine/source/T3D/fx/precipitation.h          |   6 +-
 Engine/source/T3D/fx/splash.cpp               |  12 +-
 Engine/source/T3D/fx/splash.h                 |   2 +-
 Engine/source/T3D/groundPlane.cpp             |   6 +-
 Engine/source/T3D/groundPlane.h               |   2 +-
 Engine/source/T3D/levelInfo.cpp               |   6 +-
 Engine/source/T3D/levelInfo.h                 |   2 +-
 Engine/source/T3D/lightFlareData.cpp          |   6 +-
 Engine/source/T3D/lightFlareData.h            |   2 +-
 Engine/source/T3D/physics/physicsDebris.cpp   |   6 +-
 Engine/source/T3D/physics/physicsDebris.h     |   2 +-
 Engine/source/T3D/physics/physicsShape.cpp    |   6 +-
 Engine/source/T3D/physics/physicsShape.h      |   2 +-
 Engine/source/T3D/player.cpp                  |  17 +-
 Engine/source/T3D/player.h                    |   7 +-
 Engine/source/T3D/projectile.cpp              |  16 +-
 Engine/source/T3D/projectile.h                |   4 +-
 Engine/source/T3D/proximityMine.cpp           |  12 +-
 Engine/source/T3D/proximityMine.h             |   4 +-
 Engine/source/T3D/rigidShape.cpp              |  12 +-
 Engine/source/T3D/rigidShape.h                |   4 +-
 Engine/source/T3D/sfx/sfxEmitter.cpp          |   6 +-
 Engine/source/T3D/sfx/sfxEmitter.h            |   2 +-
 Engine/source/T3D/shapeBase.cpp               |  16 +-
 Engine/source/T3D/shapeBase.h                 |  10 +-
 Engine/source/T3D/shapeImage.cpp              |  12 +-
 Engine/source/T3D/tsStatic.cpp                |   6 +-
 Engine/source/T3D/tsStatic.h                  |   2 +-
 Engine/source/T3D/vehicles/flyingVehicle.cpp  |   6 +-
 Engine/source/T3D/vehicles/flyingVehicle.h    |   2 +-
 Engine/source/T3D/vehicles/hoverVehicle.cpp   |   6 +-
 Engine/source/T3D/vehicles/hoverVehicle.h     |   2 +-
 Engine/source/T3D/vehicles/vehicle.cpp        |  12 +-
 Engine/source/T3D/vehicles/vehicle.h          |   4 +-
 Engine/source/T3D/vehicles/wheeledVehicle.cpp |  12 +-
 Engine/source/T3D/vehicles/wheeledVehicle.h   |   4 +-
 Engine/source/afx/afxMagicMissile.cpp         |   8 +-
 Engine/source/afx/afxMagicMissile.h           |   2 +-
 Engine/source/afx/ce/afxBillboard.cpp         |   8 +-
 Engine/source/afx/ce/afxBillboard.h           |   2 +-
 Engine/source/afx/ce/afxModel.cpp             |   8 +-
 Engine/source/afx/ce/afxModel.h               |   2 +-
 Engine/source/afx/ce/afxZodiac.cpp            |   8 +-
 Engine/source/afx/ce/afxZodiac.h              |   2 +-
 Engine/source/afx/ce/afxZodiacPlane.cpp       |   8 +-
 Engine/source/afx/ce/afxZodiacPlane.h         |   2 +-
 Engine/source/assets/assetBase.h              |   1 -
 Engine/source/environment/VolumetricFog.cpp   |  12 +-
 Engine/source/environment/VolumetricFog.h     |   6 +-
 Engine/source/environment/basicClouds.cpp     |   4 +-
 Engine/source/environment/cloudLayer.cpp      |   6 +-
 Engine/source/environment/cloudLayer.h        |   4 +-
 Engine/source/environment/decalRoad.cpp       |   6 +-
 Engine/source/environment/decalRoad.h         |   2 +-
 .../editors/guiMeshRoadEditorCtrl.cpp         |   6 +-
 .../editors/guiMeshRoadEditorCtrl.h           |   6 +-
 .../environment/editors/guiRoadEditorCtrl.h   |   2 +-
 Engine/source/environment/meshRoad.cpp        |  18 +-
 Engine/source/environment/meshRoad.h          |   6 +-
 Engine/source/environment/scatterSky.cpp      |   6 +-
 Engine/source/environment/scatterSky.h        |   2 +-
 Engine/source/environment/skyBox.cpp          |   6 +-
 Engine/source/environment/skyBox.h            |   2 +-
 Engine/source/environment/sun.cpp             |   6 +-
 Engine/source/environment/sun.h               |   2 +-
 Engine/source/environment/waterObject.cpp     |  18 +-
 Engine/source/environment/waterObject.h       |   6 +-
 Engine/source/forest/forestItem.cpp           |   6 +-
 Engine/source/forest/forestItem.h             |   2 +-
 Engine/source/gfx/sim/cubemapData.cpp         |   4 +-
 Engine/source/gfx/sim/cubemapData.h           |   2 +-
 .../gui/buttons/guiBitmapButtonCtrl.cpp       |   4 +-
 .../source/gui/buttons/guiBitmapButtonCtrl.h  |   2 +-
 .../source/gui/buttons/guiIconButtonCtrl.cpp  |   4 +-
 Engine/source/gui/buttons/guiIconButtonCtrl.h |   2 +-
 .../gui/buttons/guiToolboxButtonCtrl.cpp      |  12 +-
 .../source/gui/buttons/guiToolboxButtonCtrl.h |   6 +-
 Engine/source/gui/controls/guiBitmapCtrl.cpp  |   2 +-
 Engine/source/gui/controls/guiBitmapCtrl.h    |   2 +-
 .../source/gui/controls/guiMaterialCtrl.cpp   |   2 +-
 Engine/source/gui/controls/guiMaterialCtrl.h  |   2 +-
 Engine/source/gui/controls/guiPopUpCtrl.cpp   |   4 +-
 Engine/source/gui/controls/guiPopUpCtrlEx.cpp |   4 +-
 Engine/source/gui/core/guiControl.cpp         |   2 +-
 Engine/source/gui/core/guiTypes.cpp           |   4 +-
 Engine/source/gui/core/guiTypes.h             |   4 +-
 .../source/gui/game/guiChunkedBitmapCtrl.cpp  |   2 +-
 Engine/source/gui/game/guiChunkedBitmapCtrl.h |   2 +-
 .../source/gui/game/guiProgressBitmapCtrl.cpp |   2 +-
 .../source/gui/game/guiProgressBitmapCtrl.h   |   2 +-
 .../source/gui/worldEditor/guiMissionArea.cpp |   2 +-
 .../source/gui/worldEditor/guiMissionArea.h   |   2 +-
 Engine/source/gui/worldEditor/worldEditor.h   |   6 +-
 .../source/materials/materialDefinition.cpp   |  24 +-
 Engine/source/postFx/postEffect.cpp           |   2 +-
 Engine/source/terrain/terrMaterial.cpp        |  20 +-
 Engine/source/terrain/terrMaterial.h          |  10 +-
 123 files changed, 632 insertions(+), 966 deletions(-)
 create mode 100644 Engine/source/T3D/assets/assetMacroHelpers.h

diff --git a/Engine/source/T3D/accumulationVolume.cpp b/Engine/source/T3D/accumulationVolume.cpp
index 37e9f4ae9..139a843b9 100644
--- a/Engine/source/T3D/accumulationVolume.cpp
+++ b/Engine/source/T3D/accumulationVolume.cpp
@@ -85,7 +85,7 @@ AccumulationVolume::AccumulationVolume()
    mWorldToObj.identity();
 
    // Accumulation Texture.
-   INIT_IMAGEASSET(Texture);
+   INIT_ASSET(Texture);
 
    resetWorldBox();
 }
@@ -236,7 +236,7 @@ U32 AccumulationVolume::packUpdate( NetConnection *connection, U32 mask, BitStre
 
    if (stream->writeFlag(mask & InitialUpdateMask))
    {
-      PACK_IMAGEASSET(connection, Texture);
+      PACK_ASSET(connection, Texture);
    }
 
    return retMask;  
@@ -248,7 +248,7 @@ void AccumulationVolume::unpackUpdate( NetConnection *connection, BitStream *str
 
    if (stream->readFlag())
    {
-      UNPACK_IMAGEASSET(connection, Texture);
+      UNPACK_ASSET(connection, Texture);
       //setTexture(mTextureName);
    }
 }
diff --git a/Engine/source/T3D/accumulationVolume.h b/Engine/source/T3D/accumulationVolume.h
index 2b05fa81b..4c4049b6c 100644
--- a/Engine/source/T3D/accumulationVolume.h
+++ b/Engine/source/T3D/accumulationVolume.h
@@ -62,7 +62,7 @@ class AccumulationVolume : public ScenePolyhedralSpace
       virtual void _renderObject( ObjectRenderInst* ri, SceneRenderState* state, BaseMatInstance* overrideMat );
 
       DECLARE_IMAGEASSET(AccumulationVolume, Texture, onTextureChanged, GFXStaticTextureSRGBProfile);
-      DECLARE_IMAGEASSET_NET_SETGET(AccumulationVolume, Texture, -1);
+      DECLARE_ASSET_NET_SETGET(AccumulationVolume, Texture, -1);
 
       void onTextureChanged() {}
 
diff --git a/Engine/source/T3D/assets/ImageAsset.h b/Engine/source/T3D/assets/ImageAsset.h
index 7afcd6da2..d4de538f7 100644
--- a/Engine/source/T3D/assets/ImageAsset.h
+++ b/Engine/source/T3D/assets/ImageAsset.h
@@ -47,7 +47,7 @@
 #include "sim/netConnection.h"
 
 #include <string>
-
+#include "assetMacroHelpers.h"
 //-----------------------------------------------------------------------------
 class ImageAsset : public AssetBase
 {
@@ -273,45 +273,6 @@ public: \
    }\
    bool name##Valid() {return (get##name() != StringTable->EmptyString() && m##name##Asset->getStatus() == AssetBase::Ok); }
 
-#define DECLARE_IMAGEASSET_SETGET(className, name)\
-   static bool _set##name##Data(void* obj, const char* index, const char* data)\
-   {\
-      bool ret = false;\
-      className* object = static_cast<className*>(obj);\
-      ret = object->_set##name(StringTable->insert(data));\
-      return ret;\
-   }
-
-#define DECLARE_IMAGEASSET_NET_SETGET(className, name, bitmask)\
-   static bool _set##name##Data(void* obj, const char* index, const char* data)\
-   {\
-      bool ret = false;\
-      className* object = static_cast<className*>(obj);\
-      ret = object->_set##name(StringTable->insert(data));\
-      if(ret)\
-         object->setMaskBits(bitmask);\
-      return ret;\
-   }
-
-#define DEF_IMAGEASSET_BINDS(className,name)\
-DefineEngineMethod(className, get##name, const char*, (), , "get name")\
-{\
-   return object->get##name(); \
-}\
-DefineEngineMethod(className, get##name##Asset, const char*, (), , assetText(name, asset reference))\
-{\
-   return object->m##name##AssetId; \
-}\
-DefineEngineMethod(className, set##name, bool, (const char* map), , assetText(name,assignment. first tries asset then flat file.))\
-{\
-    return object->_set##name(StringTable->insert(map));\
-}
-
-#define INIT_IMAGEASSET(name) \
-   m##name##Name = StringTable->EmptyString(); \
-   m##name##AssetId = StringTable->EmptyString(); \
-   m##name##Asset = NULL;
-
 #ifdef TORQUE_SHOW_LEGACY_FILE_FIELDS
 
 #define INITPERSISTFIELD_IMAGEASSET(name, consoleClass, docs) \
@@ -326,11 +287,6 @@ DefineEngineMethod(className, set##name, bool, (const char* map), , assetText(na
 
 #endif // SHOW_LEGACY_FILE_FIELDS
 
-#define CLONE_IMAGEASSET(name) \
-   m##name##Name = other.m##name##Name;\
-   m##name##AssetId = other.m##name##AssetId;\
-   m##name##Asset = other.m##name##Asset;
-
 #define LOAD_IMAGEASSET(name)\
 if (m##name##AssetId != StringTable->EmptyString())\
 {\
@@ -342,43 +298,6 @@ if (m##name##AssetId != StringTable->EmptyString())\
    else Con::warnf("Warning: %s::LOAD_IMAGEASSET(%s)-%s", mClassName, m##name##AssetId, ImageAsset::getAssetErrstrn(assetState).c_str());\
 }
 
-#define PACKDATA_IMAGEASSET(name)\
-   if (stream->writeFlag(m##name##Asset.notNull()))\
-   {\
-      stream->writeString(m##name##Asset.getAssetId());\
-   }\
-   else\
-      stream->writeString(m##name##Name);
-
-#define UNPACKDATA_IMAGEASSET(name)\
-   if (stream->readFlag())\
-   {\
-      m##name##AssetId = stream->readSTString();\
-      _set##name(m##name##AssetId);\
-   }\
-   else\
-   {\
-      m##name##Name = stream->readSTString();\
-      _set##name(m##name##Name);\
-   }\
-
-#define PACK_IMAGEASSET(netconn, name)\
-   if (stream->writeFlag(m##name##Asset.notNull()))\
-   {\
-      NetStringHandle assetIdStr = m##name##Asset.getAssetId();\
-      netconn->packNetStringHandleU(stream, assetIdStr);\
-   }\
-   else\
-      stream->writeString(m##name##Name);
-
-#define UNPACK_IMAGEASSET(netconn, name)\
-   if (stream->readFlag())\
-   {\
-      m##name##AssetId = StringTable->insert(netconn->unpackNetStringHandleU(stream).getString());\
-      _set##name(m##name##AssetId);\
-   }\
-   else\
-      m##name##Name = stream->readSTString();
 
 #pragma endregion
 
@@ -542,13 +461,6 @@ DefineEngineMethod(className, set##name, bool, (const char* map, S32 index), , a
     return object->_set##name(StringTable->insert(map), index);\
 }
 
-#define INIT_IMAGEASSET_ARRAY(name, index) \
-{\
-   m##name##Name[index] = StringTable->EmptyString(); \
-   m##name##AssetId[index] = StringTable->EmptyString(); \
-   m##name##Asset[index] = NULL;\
-}
-
 #ifdef TORQUE_SHOW_LEGACY_FILE_FIELDS
 
 #define INITPERSISTFIELD_IMAGEASSET_ARRAY(name, arraySize, consoleClass, docs) \
@@ -563,13 +475,6 @@ DefineEngineMethod(className, set##name, bool, (const char* map, S32 index), , a
 
 #endif
 
-#define CLONE_IMAGEASSET_ARRAY(name, index) \
-{\
-   m##name##Name[index] = other.m##name##Name[index];\
-   m##name##AssetId[index] = other.m##name##AssetId[index];\
-   m##name##Asset[index] = other.m##name##Asset[index];\
-}
-
 #define LOAD_IMAGEASSET_ARRAY(name, index)\
 if (m##name##AssetId[index] != StringTable->EmptyString())\
 {\
@@ -581,44 +486,6 @@ if (m##name##AssetId[index] != StringTable->EmptyString())\
    else Con::warnf("Warning: %s::LOAD_IMAGEASSET(%s)-%s", mClassName, m##name##AssetId[index], ImageAsset::getAssetErrstrn(assetState).c_str());\
 }
 
-#define PACKDATA_IMAGEASSET_ARRAY(name, index)\
-   if (stream->writeFlag(m##name##Asset[index].notNull()))\
-   {\
-      stream->writeString(m##name##Asset[index].getAssetId());\
-   }\
-   else\
-      stream->writeString(m##name##Name[index]);
-
-#define UNPACKDATA_IMAGEASSET_ARRAY(name, index)\
-   if (stream->readFlag())\
-   {\
-      m##name##AssetId[index] = stream->readSTString();\
-      _set##name(m##name##AssetId[index], index);\
-   }\
-   else\
-   {\
-      m##name##Name[index] = stream->readSTString();\
-      _set##name(m##name##Name[index], index);\
-   }\
-
-#define PACK_IMAGEASSET_ARRAY(netconn, name, index)\
-   if (stream->writeFlag(m##name##Asset[index].notNull()))\
-   {\
-      NetStringHandle assetIdStr = m##name##Asset[index].getAssetId();\
-      netconn->packNetStringHandleU(stream, assetIdStr);\
-   }\
-   else\
-      stream->writeString(m##name##Name[index]);
-
-#define UNPACK_IMAGEASSET_ARRAY(netconn, name, index)\
-   if (stream->readFlag())\
-   {\
-      m##name##AssetId[index] = StringTable->insert(netconn->unpackNetStringHandleU(stream).getString());\
-      _set##name(m##name##AssetId[index], index);\
-   }\
-   else\
-      m##name##Name[index] = stream->readSTString();
-
 #pragma endregion
 
 
diff --git a/Engine/source/T3D/assets/MaterialAsset.h b/Engine/source/T3D/assets/MaterialAsset.h
index fc383810f..9fab8a1da 100644
--- a/Engine/source/T3D/assets/MaterialAsset.h
+++ b/Engine/source/T3D/assets/MaterialAsset.h
@@ -54,6 +54,7 @@
 #include "materials/materialDefinition.h"
 #include "materials/customMaterialDefinition.h"
 #include "materials/materialManager.h"
+#include "assetMacroHelpers.h"
 
 //-----------------------------------------------------------------------------
 class MaterialAsset : public AssetBase
@@ -262,46 +263,6 @@ public: \
    }\
    bool is##name##Valid() {return (get##name() != StringTable->EmptyString() && m##name##Asset->getStatus() == AssetBase::Ok); }
 
-#define DECLARE_MATERIALASSET_SETGET(className, name)\
-   static bool _set##name##Data(void* obj, const char* index, const char* data)\
-   {\
-      bool ret = false;\
-      className* object = static_cast<className*>(obj);\
-      ret = object->_set##name(StringTable->insert(data));\
-      return ret;\
-   }
-
-#define DECLARE_MATERIALASSET_NET_SETGET(className, name, bitmask)\
-   static bool _set##name##Data(void* obj, const char* index, const char* data)\
-   {\
-      bool ret = false;\
-      className* object = static_cast<className*>(obj);\
-      ret = object->_set##name(StringTable->insert(data));\
-      if(ret)\
-         object->setMaskBits(bitmask);\
-      return ret;\
-   }
-
-#define DEF_MATERIALASSET_BINDS(className,name)\
-DefineEngineMethod(className, get##name, const char*, (), , "get name")\
-{\
-   return object->get##name(); \
-}\
-DefineEngineMethod(className, get##name##Asset, const char*, (), , assetText(name, asset reference))\
-{\
-   return object->m##name##AssetId; \
-}\
-DefineEngineMethod(className, set##name, bool, (const char* mat), , assetText(name,assignment. first tries asset then material name.))\
-{\
-    return object->_set##name(StringTable->insert(mat));\
-}
-
-#define INIT_MATERIALASSET(name) \
-   m##name##Name = StringTable->EmptyString(); \
-   m##name##AssetId = StringTable->EmptyString(); \
-   m##name##Asset = NULL;\
-   m##name = NULL;
-
 #ifdef TORQUE_SHOW_LEGACY_FILE_FIELDS
 
 #define INITPERSISTFIELD_MATERIALASSET(name, consoleClass, docs) \
@@ -316,11 +277,6 @@ DefineEngineMethod(className, set##name, bool, (const char* mat), , assetText(na
 
 #endif // SHOW_LEGACY_FILE_FIELDS
 
-#define CLONE_MATERIALASSET(name) \
-   m##name##Name = other.m##name##Name;\
-   m##name##AssetId = other.m##name##AssetId;\
-   m##name##Asset = other.m##name##Asset;
-
 #define LOAD_MATERIALASSET(name)\
 if (m##name##AssetId != StringTable->EmptyString())\
 {\
@@ -331,45 +287,6 @@ if (m##name##AssetId != StringTable->EmptyString())\
    }\
    else Con::warnf("Warning: %s::LOAD_MATERIALASSET(%s)-%s", mClassName, m##name##AssetId, MaterialAsset::getAssetErrstrn(assetState).c_str());\
 }
-
-#define PACKDATA_MATERIALASSET(name)\
-   if (stream->writeFlag(m##name##Asset.notNull()))\
-   {\
-      stream->writeString(m##name##Asset.getAssetId());\
-   }\
-   else\
-      stream->writeString(m##name##Name);
-
-#define UNPACKDATA_MATERIALASSET(name)\
-   if (stream->readFlag())\
-   {\
-      m##name##AssetId = stream->readSTString();\
-      _set##name(m##name##AssetId);\
-   }\
-   else\
-   {\
-      m##name##Name = stream->readSTString();\
-      _set##name(m##name##Name);\
-   }\
-
-#define PACK_MATERIALASSET(netconn, name)\
-   if (stream->writeFlag(m##name##Asset.notNull()))\
-   {\
-      NetStringHandle assetIdStr = m##name##Asset.getAssetId();\
-      netconn->packNetStringHandleU(stream, assetIdStr);\
-   }\
-   else\
-      stream->writeString(m##name##Name);
-
-#define UNPACK_MATERIALASSET(netconn, name)\
-   if (stream->readFlag())\
-   {\
-      m##name##AssetId = StringTable->insert(netconn->unpackNetStringHandleU(stream).getString());\
-      _set##name(m##name##AssetId);\
-   }\
-   else\
-      m##name##Name = stream->readSTString();
-
 #pragma endregion
 
 #endif // _ASSET_BASE_H_
diff --git a/Engine/source/T3D/assets/ShapeAsset.h b/Engine/source/T3D/assets/ShapeAsset.h
index 2d641a840..36a0a68c1 100644
--- a/Engine/source/T3D/assets/ShapeAsset.h
+++ b/Engine/source/T3D/assets/ShapeAsset.h
@@ -60,6 +60,7 @@
 #ifndef _BITSTREAM_H_
 #include "core/stream/bitStream.h"
 #endif
+#include "assetMacroHelpers.h"
 //-----------------------------------------------------------------------------
 class ShapeAsset : public AssetBase
 {
@@ -324,46 +325,6 @@ public: \
    }\
    bool is##name##Valid() {return (get##name() != StringTable->EmptyString() && m##name##Asset->getStatus() == AssetBase::Ok); }
 
-#define DECLARE_SHAPEASSET_SETGET(className, name)\
-   static bool _set##name##Data(void* obj, const char* index, const char* data)\
-   {\
-      bool ret = false;\
-      className* object = static_cast<className*>(obj);\
-      ret = object->_set##name(StringTable->insert(data));\
-      return ret;\
-   }
-
-#define DECLARE_SHAPEASSET_NET_SETGET(className, name, bitmask)\
-   static bool _set##name##Data(void* obj, const char* index, const char* data)\
-   {\
-      bool ret = false;\
-      className* object = static_cast<className*>(obj);\
-      ret = object->_set##name(StringTable->insert(data));\
-      if(ret)\
-         object->setMaskBits(bitmask);\
-      return ret;\
-   }
-
-#define DEF_SHAPEASSET_BINDS(className,name)\
-DefineEngineMethod(className, get##name, String, (), , "get name")\
-{\
-   return object->get##name(); \
-}\
-DefineEngineMethod(className, get##name##Asset, String, (), , assetText(name, asset reference))\
-{\
-   return object->m##name##AssetId; \
-}\
-DefineEngineMethod(className, set##name, bool, (const char*  shape), , assetText(name,assignment. first tries asset then flat file.))\
-{\
-   return object->_set##name(StringTable->insert(shape));\
-}
-
-#define INIT_SHAPEASSET(name) \
-   m##name##Name = StringTable->EmptyString(); \
-   m##name##AssetId = StringTable->EmptyString(); \
-   m##name##Asset = NULL; \
-   m##name = NULL;
-
 #ifdef TORQUE_SHOW_LEGACY_FILE_FIELDS
 
 #define INITPERSISTFIELD_SHAPEASSET(name, consoleClass, docs) \
@@ -378,49 +339,6 @@ DefineEngineMethod(className, set##name, bool, (const char*  shape), , assetText
 
 #endif // SHOW_LEGACY_FILE_FIELDS
 
-#define CLONE_SHAPEASSET(name) \
-   m##name##Name = other.m##name##Name;\
-   m##name##AssetId = other.m##name##AssetId;\
-   m##name##Asset = other.m##name##Asset;\
-
-#define PACKDATA_SHAPEASSET(name)\
-   if (stream->writeFlag(m##name##Asset.notNull()))\
-   {\
-      stream->writeString(m##name##Asset.getAssetId());\
-   }\
-   else\
-      stream->writeString(m##name##Name);
-
-#define UNPACKDATA_SHAPEASSET(name)\
-   if (stream->readFlag())\
-   {\
-      m##name##AssetId = stream->readSTString();\
-      _set##name(m##name##AssetId);\
-   }\
-   else\
-   {\
-      m##name##Name = stream->readSTString();\
-      _set##name(m##name##Name);\
-   }
-
-#define PACK_SHAPEASSET(netconn, name)\
-   if (stream->writeFlag(m##name##Asset.notNull()))\
-   {\
-      NetStringHandle assetIdStr = m##name##Asset.getAssetId();\
-      netconn->packNetStringHandleU(stream, assetIdStr);\
-   }\
-   else\
-      stream->writeString(m##name##Name);
-
-#define UNPACK_SHAPEASSET(netconn, name)\
-   if (stream->readFlag())\
-   {\
-      m##name##AssetId = StringTable->insert(netconn->unpackNetStringHandleU(stream).getString());\
-      _set##name(m##name##AssetId);\
-   }\
-   else\
-      m##name##Name = stream->readSTString();
-
 #pragma endregion
 
 #pragma region Arrayed Asset Macros
@@ -526,58 +444,6 @@ public: \
    }\
    bool is##name##Valid(const U32& id) {return (get##name(id) != StringTable->EmptyString() && m##name##Asset[id]->getStatus() == AssetBase::Ok); }
 
-#define DECLARE_SHAPEASSET_ARRAY_SETGET(className, name)\
-   static bool _set##name##Data(void* obj, const char* index, const char* data)\
-   {\
-      if (!index) return false;\
-      U32 idx = dAtoi(index);\
-      if (idx >= sm##name##Count)\
-         return false;\
-      bool ret = false;\
-      className* object = static_cast<className*>(obj);\
-      ret = object->_set##name(StringTable->insert(data), idx);\
-      return ret;\
-   }
-
-#define DECLARE_SHAPEASSET_ARRAY_NET_SETGET(className, name, bitmask)\
-   static bool _set##name##Data(void* obj, const char* index, const char* data)\
-   {\
-      if (!index) return false;\
-      U32 idx = dAtoi(index);\
-      if (idx >= sm##name##Count)\
-         return false;\
-      bool ret = false;\
-      className* object = static_cast<className*>(obj);\
-      ret = object->_set##name(StringTable->insert(data), idx);\
-      if(ret)\
-         object->setMaskBits(bitmask);\
-      return ret;\
-   }
-
-#define DEF_SHAPEASSET_ARRAY_BINDS(className,name)\
-DefineEngineMethod(className, get##name, String, (S32 index), , "get name")\
-{\
-   return object->get##name(index); \
-}\
-DefineEngineMethod(className, get##name##Asset, String, (S32 index), , assetText(name, asset reference))\
-{\
-   if(index >= className::sm##name##Count || index < 0)\
-      return "";\
-   return object->m##name##AssetId[index]; \
-}\
-DefineEngineMethod(className, set##name, bool, (const char*  shape, S32 index), , assetText(name,assignment. first tries asset then flat file.))\
-{\
-   return object->_set##name(StringTable->insert(shape), index);\
-}
-
-#define INIT_SHAPEASSET_ARRAY(name, index) \
-{\
-   m##name##Name[index] = StringTable->EmptyString(); \
-   m##name##AssetId[index] = StringTable->EmptyString(); \
-   m##name##Asset[index] = NULL; \
-   m##name[index] = NULL;\
-}
-
 #ifdef TORQUE_SHOW_LEGACY_FILE_FIELDS
 
 #define INITPERSISTFIELD_SHAPEASSET_ARRAY(name, arraySize, consoleClass, docs) \
@@ -592,51 +458,6 @@ DefineEngineMethod(className, set##name, bool, (const char*  shape, S32 index),
 
 #endif // SHOW_LEGACY_FILE_FIELDS
 
-#define CLONE_SHAPEASSET_ARRAY(name, index) \
-{\
-   m##name##Name[index] = other.m##name##Name[index];\
-   m##name##AssetId[index] = other.m##name##AssetId[index];\
-   m##name##Asset[index] = other.m##name##Asset[index];\
-}
-
-#define PACKDATA_SHAPEASSET_ARRAY(name, index)\
-   if (stream->writeFlag(m##name##Asset[index].notNull()))\
-   {\
-      stream->writeString(m##name##Asset[index].getAssetId());\
-   }\
-   else\
-      stream->writeString(m##name##Name[index]);
-
-#define UNPACKDATA_SHAPEASSET_ARRAY(name, index)\
-   if (stream->readFlag())\
-   {\
-      m##name##AssetId[index] = stream->readSTString();\
-      _set##name(m##name##AssetId[index], index);\
-   }\
-   else\
-   {\
-      m##name##Name[index] = stream->readSTString();\
-      _set##name(m##name##Name[index], index);\
-   }
-
-#define PACK_SHAPEASSET_ARRAY(netconn, name, index)\
-   if (stream->writeFlag(m##name##Asset[index].notNull()))\
-   {\
-      NetStringHandle assetIdStr = m##name##Asset[index].getAssetId();\
-      netconn->packNetStringHandleU(stream, assetIdStr);\
-   }\
-   else\
-      stream->writeString(m##name##Name[index]);
-
-#define UNPACK_SHAPEASSET_ARRAY(netconn, name, index)\
-   if (stream->readFlag())\
-   {\
-      m##name##AssetId[index] = StringTable->insert(netconn->unpackNetStringHandleU(stream).getString());\
-      _set##name(m##name##AssetId[index], index);\
-   }\
-   else\
-      m##name##Name[index] = stream->readSTString();
-
 #pragma endregion
 
 #endif
diff --git a/Engine/source/T3D/assets/SoundAsset.h b/Engine/source/T3D/assets/SoundAsset.h
index 1d98b61b1..77c1e7180 100644
--- a/Engine/source/T3D/assets/SoundAsset.h
+++ b/Engine/source/T3D/assets/SoundAsset.h
@@ -57,6 +57,7 @@
 #include "sfx/sfxProfile.h"
 #endif // !_SFXPROFILE_H_
 
+#include "assetMacroHelpers.h"
 class SFXResource;
 
 //-----------------------------------------------------------------------------
@@ -275,46 +276,6 @@ public: \
    }\
    bool is##name##Valid() { return (get##name() != StringTable->EmptyString() && m##name##Asset->getStatus() == AssetBase::Ok); }
 
-#define DECLARE_SOUNDASSET_SETGET(className, name)\
-   static bool _set##name##Data(void* obj, const char* index, const char* data)\
-   {\
-      bool ret = false;\
-      className* object = static_cast<className*>(obj);\
-      ret = object->_set##name(StringTable->insert(data));\
-      return ret;\
-   }
-
-#define DECLARE_SOUNDASSET_NET_SETGET(className, name, bitmask)\
-   static bool _set##name##Data(void* obj, const char* index, const char* data)\
-   {\
-      bool ret = false;\
-      className* object = static_cast<className*>(obj);\
-      ret = object->_set##name(StringTable->insert(data));\
-      if(ret)\
-         object->setMaskBits(bitmask);\
-      return ret;\
-   }
-
-#define DEF_SOUNDASSET_BINDS(className,name)\
-DefineEngineMethod(className, get##name, String, (), , "get name")\
-{\
-   return object->get##name(); \
-}\
-DefineEngineMethod(className, get##name##Asset, String, (), , assetText(name, asset reference))\
-{\
-   return object->m##name##AssetId; \
-}\
-DefineEngineMethod(className, set##name, bool, (const char*  shape), , assetText(name,assignment. first tries asset then flat file.))\
-{\
-   return object->_set##name(StringTable->insert(shape));\
-}
-
-#define INIT_SOUNDASSET(name) \
-   m##name##Name = StringTable->EmptyString(); \
-   m##name##AssetId = StringTable->EmptyString(); \
-   m##name##Asset = NULL; \
-   m##name = NULL;\
-
 #ifdef TORQUE_SHOW_LEGACY_FILE_FIELDS
 
 #define INITPERSISTFIELD_SOUNDASSET(name, consoleClass, docs) \
@@ -329,49 +290,6 @@ DefineEngineMethod(className, set##name, bool, (const char*  shape), , assetText
 
 #endif // TORQUE_SHOW_LEGACY_FILE_FIELDS
 
-#define CLONE_SOUNDASSET(name) \
-   m##name##Name = other.m##name##Name;\
-   m##name##AssetId = other.m##name##AssetId;\
-   m##name##Asset = other.m##name##Asset;\
-
-#define PACKDATA_SOUNDASSET(name)\
-   if (stream->writeFlag(m##name##Asset.notNull()))\
-   {\
-      stream->writeString(m##name##Asset.getAssetId());\
-   }\
-   else\
-      stream->writeString(m##name##Name);
-
-#define UNPACKDATA_SOUNDASSET(name)\
-   if (stream->readFlag())\
-   {\
-      m##name##AssetId = stream->readSTString();\
-      _set##name(m##name##AssetId);\
-   }\
-   else\
-   {\
-      m##name##Name = stream->readSTString();\
-      _set##name(m##name##Name);\
-   }
-
-#define PACK_SOUNDASSET(netconn, name)\
-   if (stream->writeFlag(m##name##Asset.notNull()))\
-   {\
-      NetStringHandle assetIdStr = m##name##Asset.getAssetId();\
-      netconn->packNetStringHandleU(stream, assetIdStr);\
-   }\
-   else\
-      stream->writeString(m##name##Name);
-
-#define UNPACK_SOUNDASSET(netconn, name)\
-   if (stream->readFlag())\
-   {\
-      m##name##AssetId = StringTable->insert(netconn->unpackNetStringHandleU(stream).getString());\
-      _set##name(m##name##AssetId);\
-   }\
-   else\
-      m##name##Name = stream->readSTString();
-
 #pragma endregion
 
 #pragma region Arrayed Asset Macros
@@ -491,57 +409,6 @@ public: \
    }\
    bool is##name##Valid(const U32& id) {return (get##name(id) != StringTable->EmptyString() && m##name##Asset[id]->getStatus() == AssetBase::Ok); }
 
-#define DECLARE_SOUNDASSET_ARRAY_SETGET(className, name)\
-   static bool _set##name##Data(void* obj, const char* index, const char* data)\
-   {\
-      if(!index) return false;\
-      U32 idx = dAtoi(index);\
-      if (idx >= sm##name##Count)\
-         return false;\
-      bool ret = false;\
-      className* object = static_cast<className*>(obj);\
-      ret = object->_set##name(StringTable->insert(data), idx);\
-      return ret;\
-   }
-
-#define DECLARE_SOUNDASSET_ARRAY_NET_SETGET(className, name, bitmask)\
-   static bool _set##name##Data(void* obj, const char* index, const char* data)\
-   {\
-      if (!index) return false;\
-      U32 idx = dAtoi(index);\
-      if (idx >= sm##name##Count)\
-         return false;\
-      bool ret = false;\
-      className* object = static_cast<className*>(obj);\
-      ret = object->_set##name(StringTable->insert(data, idx));\
-      if(ret)\
-         object->setMaskBits(bitmask);\
-      return ret;\
-   }
-
-#define DEF_SOUNDASSET_ARRAY_BINDS(className,name)\
-DefineEngineMethod(className, get##name, const char*, (S32 index), , "get name")\
-{\
-   return object->get##name(index); \
-}\
-DefineEngineMethod(className, get##name##Asset, const char*, (S32 index), , assetText(name, asset reference))\
-{\
-   if(index >= className::sm##name##Count || index < 0)\
-      return "";\
-   return object->m##name##AssetId[index]; \
-}\
-DefineEngineMethod(className, set##name, bool, (const char* map, S32 index), , assetText(name,assignment. first tries asset then flat file.))\
-{\
-    return object->_set##name(StringTable->insert(map), index);\
-}
-
-#define INIT_SOUNDASSET_ARRAY(name, index) \
-{\
-   m##name##Name[index] = StringTable->EmptyString(); \
-   m##name##AssetId[index] = StringTable->EmptyString(); \
-   m##name##Asset[index] = NULL;\
-   m##name[index] = NULL;\
-}
 
 #ifdef TORQUE_SHOW_LEGACY_FILE_FIELDS
 
@@ -557,14 +424,6 @@ DefineEngineMethod(className, set##name, bool, (const char* map, S32 index), , a
 
 #endif
 
-#define CLONE_SOUNDASSET_ARRAY(name, index) \
-{\
-   m##name##Name[index] = other.m##name##Name[index];\
-   m##name##AssetId[index] = other.m##name##AssetId[index];\
-   m##name##Asset[index] = other.m##name##Asset[index];\
-   m##name[index] = = other.m##name[index];\
-}
-
 #define LOAD_SOUNDASSET_ARRAY(name, index)\
 if (m##name##AssetId[index] != StringTable->EmptyString())\
 {\
@@ -576,75 +435,6 @@ if (m##name##AssetId[index] != StringTable->EmptyString())\
    else Con::warnf("Warning: %s::LOAD_IMAGEASSET(%s)-%s", mClassName, m##name##AssetId[index], ImageAsset::getAssetErrstrn(assetState).c_str());\
 }
 
-#define PACKDATA_SOUNDASSET_ARRAY(name, index)\
-   if (stream->writeFlag(m##name##Asset[index].notNull()))\
-   {\
-      stream->writeString(m##name##Asset[index].getAssetId());\
-   }\
-   else\
-      stream->writeString(m##name##Name[index]);
-
-#define UNPACKDATA_SOUNDASSET_ARRAY(name, index)\
-   if (stream->readFlag())\
-   {\
-      m##name##AssetId[index] = stream->readSTString();\
-      _set##name(m##name##AssetId[index], index);\
-   }\
-   else\
-   {\
-      m##name##Name[index] = stream->readSTString();\
-      _set##name(m##name##AssetId[index], index);\
-   }
-
-#define PACK_SOUNDASSET_ARRAY(netconn, name, index)\
-   if (stream->writeFlag(m##name##Asset[index].notNull()))\
-   {\
-      NetStringHandle assetIdStr = m##name##Asset[index].getAssetId();\
-      netconn->packNetStringHandleU(stream, assetIdStr);\
-   }\
-   else\
-      stream->writeString(m##name##Name[index]);
-
-#define UNPACK_SOUNDASSET_ARRAY(netconn, name, index)\
-   if (stream->readFlag())\
-   {\
-      m##name##AssetId[index] = StringTable->insert(netconn->unpackNetStringHandleU(stream).getString());\
-      _set##name(m##name##AssetId[index], index);\
-   }\
-   else\
-   {\
-      m##name##Name[index] = stream->readSTString();\
-      _set##name(m##name##AssetId[index], index);\
-   }
-
-#define PACKDATA_SOUNDASSET_ARRAY_ENUMED(name, enumType, index )\
-{\
-   if (stream->writeFlag(m##name##Asset[index].notNull()))\
-   {\
-      stream->writeString(m##name##Asset[index].getAssetId());\
-      const char* enumString = castConsoleTypeToString(static_cast<enumType>(index));\
-      Con::printf("pack: %s = %s",enumString, m##name##AssetId[index]);\
-   }\
-   else\
-      stream->writeString(m##name##Name[index]);\
-}
-
-#define UNPACKDATA_SOUNDASSET_ARRAY_ENUMED(name, enumType, index )\
-{\
-   if (stream->readFlag())\
-   {\
-      m##name##AssetId[index] = stream->readSTString();\
-      _set##name(m##name##AssetId[index], index);\
-      const char* enumString = castConsoleTypeToString(static_cast<enumType>(index));\
-      Con::printf("unpack: %s = %s",enumString, m##name##AssetId[index]);\
-   }\
-   else\
-   {\
-      m##name##Name[index] = stream->readSTString();\
-      _set##name(m##name##AssetId[index], index);\
-   }\
-}
-
 #define assetEnumNameConcat(x,suff)(new std::string( x + std::string(#suff)))->c_str()
 
 #define INITPERSISTFIELD_SOUNDASSET_ENUMED(name, enumType, maxValue, consoleClass, docs) \
@@ -652,7 +442,7 @@ if (m##name##AssetId[index] != StringTable->EmptyString())\
    {\
       const char* enumString = castConsoleTypeToString(static_cast<enumType>(i));\
       if (enumString && enumString[0])\
-      { Con::printf("%s", enumString);\
+      {\
          addField(assetEnumNameConcat(enumString, File), TypeSoundFilename, Offset(m##name##Name[i], consoleClass), assetText(name, docs), AbstractClassRep::FIELD_HideInInspectors); \
          addField(assetEnumNameConcat(enumString, Asset), TypeSoundAssetId, Offset(m##name##AssetId[i], consoleClass), assetText(name, asset reference.));\
       }\
diff --git a/Engine/source/T3D/assets/assetMacroHelpers.h b/Engine/source/T3D/assets/assetMacroHelpers.h
new file mode 100644
index 000000000..42f51e8e8
--- /dev/null
+++ b/Engine/source/T3D/assets/assetMacroHelpers.h
@@ -0,0 +1,274 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2013 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+#pragma once
+
+//general class-injection hooks for asset support. not all cases are needed for every class/usage. 
+
+//-----------------------------------------------------------------------------
+/// INDIVIDUALIZED CLASS ENTRIES
+//-----------------------------------------------------------------------------
+
+//iniitalization
+#define INIT_ASSET(name) \
+   m##name##Name = StringTable->EmptyString(); \
+   m##name##AssetId = StringTable->EmptyString(); \
+   m##name##Asset = NULL;\
+   m##name = NULL;
+
+// copy constructor 
+#define CLONE_ASSET(name) \
+   m##name##Name = other.m##name##Name;\
+   m##name##AssetId = other.m##name##AssetId;\
+   m##name##Asset = other.m##name##Asset;\
+   m##name = other.m##name
+
+// addProtectedField acessors
+#define DECLARE_ASSET_SETGET(className, name)\
+   static bool _set##name##Data(void* obj, const char* index, const char* data)\
+   {\
+      bool ret = false;\
+      className* object = static_cast<className*>(obj);\
+      ret = object->_set##name(StringTable->insert(data));\
+      return ret;\
+   }
+
+// addProtectedField acessors for networked objects (sets a flag)
+#define DECLARE_ASSET_NET_SETGET(className, name, bitmask)\
+   static bool _set##name##Data(void* obj, const char* index, const char* data)\
+   {\
+      bool ret = false;\
+      className* object = static_cast<className*>(obj);\
+      ret = object->_set##name(StringTable->insert(data));\
+      if(ret)\
+         object->setMaskBits(bitmask);\
+      return ret;\
+   }
+
+//network send - datablock
+#define PACKDATA_ASSET(name)\
+   if (stream->writeFlag(m##name##Asset.notNull()))\
+   {\
+      stream->writeString(m##name##Asset.getAssetId());\
+   }\
+   else\
+      stream->writeString(m##name##Name);
+
+//network recieve - datablock
+#define UNPACKDATA_ASSET(name)\
+   if (stream->readFlag())\
+   {\
+      m##name##AssetId = stream->readSTString();\
+      _set##name(m##name##AssetId);\
+   }\
+   else\
+   {\
+      m##name##Name = stream->readSTString();\
+      _set##name(m##name##Name);\
+   }
+
+//network send - object-instance
+#define PACK_ASSET(netconn, name)\
+   if (stream->writeFlag(m##name##Asset.notNull()))\
+   {\
+      NetStringHandle assetIdStr = m##name##Asset.getAssetId();\
+      netconn->packNetStringHandleU(stream, assetIdStr);\
+   }\
+   else\
+      stream->writeString(m##name##Name);
+
+//network recieve - object-instance
+#define UNPACK_ASSET(netconn, name)\
+   if (stream->readFlag())\
+   {\
+      m##name##AssetId = StringTable->insert(netconn->unpackNetStringHandleU(stream).getString());\
+      _set##name(m##name##AssetId);\
+   }\
+   else\
+      m##name##Name = stream->readSTString();
+
+//script methods for class.asset acces
+//declare general get<entry>, get<entry>Asset and set<entry> methods
+#define DEF_ASSET_BINDS(className,name)\
+DefineEngineMethod(className, get##name, String, (), , "get name")\
+{\
+   return object->get##name(); \
+}\
+DefineEngineMethod(className, get##name##Asset, String, (), , assetText(name, asset reference))\
+{\
+   return object->m##name##AssetId; \
+}\
+DefineEngineMethod(className, set##name, bool, (const char* assetName), , assetText(name,assignment. first tries asset then flat file.))\
+{\
+   return object->_set##name(StringTable->insert(assetName));\
+}
+
+//-----------------------------------------------------------------------------
+/// ARRAY CLASS ENTRIES
+//-----------------------------------------------------------------------------
+
+//iniitalization
+#define INIT_ASSET_ARRAY(name, index) \
+{\
+   m##name##Name[index] = StringTable->EmptyString(); \
+   m##name##AssetId[index] = StringTable->EmptyString(); \
+   m##name##Asset[index] = NULL;\
+   m##name[index] = NULL;\
+}
+
+// copy constructor 
+#define CLONE_ASSET_ARRAY(name, index) \
+{\
+   m##name##Name[index] = other.m##name##Name[index];\
+   m##name##AssetId[index] = other.m##name##AssetId[index];\
+   m##name##Asset[index] = other.m##name##Asset[index];\
+   m##name[index] = other.m##name[index];\
+}
+// addProtectedField acessors
+#define DECLARE_ASSET_ARRAY_SETGET(className, name)\
+   static bool _set##name##Data(void* obj, const char* index, const char* data)\
+   {\
+      if(!index) return false;\
+      U32 idx = dAtoi(index);\
+      if (idx >= sm##name##Count)\
+         return false;\
+      bool ret = false;\
+      className* object = static_cast<className*>(obj);\
+      ret = object->_set##name(StringTable->insert(data), idx);\
+      return ret;\
+   }
+// addProtectedField acessors for networked objects (sets a flag)
+#define DECLARE_ASSET_ARRAY_NET_SETGET(className, name, bitmask)\
+   static bool _set##name##Data(void* obj, const char* index, const char* data)\
+   {\
+      if (!index) return false;\
+      U32 idx = dAtoi(index);\
+      if (idx >= sm##name##Count)\
+         return false;\
+      bool ret = false;\
+      className* object = static_cast<className*>(obj);\
+      ret = object->_set##name(StringTable->insert(data), idx);\
+      if(ret)\
+         object->setMaskBits(bitmask);\
+      return ret;\
+   }
+//network send - datablock
+#define PACKDATA_ASSET_ARRAY(name, index)\
+   if (stream->writeFlag(m##name##Asset[index].notNull()))\
+   {\
+      stream->writeString(m##name##Asset[index].getAssetId());\
+   }\
+   else\
+      stream->writeString(m##name##Name[index]);
+
+//network recieve - datablock
+#define UNPACKDATA_ASSET_ARRAY(name, index)\
+   if (stream->readFlag())\
+   {\
+      m##name##AssetId[index] = stream->readSTString();\
+      _set##name(m##name##AssetId[index], index);\
+   }\
+   else\
+   {\
+      m##name##Name[index] = stream->readSTString();\
+      _set##name(m##name##Name[index], index);\
+   }
+
+//network send - object-instance
+#define PACK_ASSET_ARRAY(netconn, name, index)\
+   if (stream->writeFlag(m##name##Asset[index].notNull()))\
+   {\
+      NetStringHandle assetIdStr = m##name##Asset[index].getAssetId();\
+      netconn->packNetStringHandleU(stream, assetIdStr);\
+   }\
+   else\
+      stream->writeString(m##name##Name[index]);
+
+//network recieve - object-instance
+#define UNPACK_ASSET_ARRAY(netconn, name, index)\
+   if (stream->readFlag())\
+   {\
+      m##name##AssetId[index] = StringTable->insert(netconn->unpackNetStringHandleU(stream).getString());\
+      _set##name(m##name##AssetId[index], index);\
+   }\
+   else\
+   {\
+      m##name##Name[index] = stream->readSTString();\
+      _set##name(m##name##Name[index], index);\
+   }
+
+//script methods for class.asset acces
+//declare general get<entry>, get<entry>Asset and set<entry> methods
+//signatures are:
+//using DiffuseMap as an example
+//material.getDiffuseMap(%layer); //returns the raw file referenced
+//material.getDiffuseMapAsset(%layer); //returns the asset id
+//material.setDiffuseMap(%texture, %layer); //tries to set the asset and failing that attempts a flat file reference
+#define DEF_ASSET_ARRAY_BINDS(className,name)\
+DefineEngineMethod(className, get##name, const char*, (S32 index), , "get name")\
+{\
+   return object->get##name(index); \
+}\
+DefineEngineMethod(className, get##name##Asset, const char*, (S32 index), , assetText(name, asset reference))\
+{\
+   if(index >= className::sm##name##Count || index < 0)\
+      return "";\
+   return object->m##name##AssetId[index]; \
+}\
+DefineEngineMethod(className, set##name, bool, (const char* assetName, S32 index), , assetText(name,assignment. first tries asset then flat file.))\
+{\
+    return object->_set##name(StringTable->insert(assetName), index);\
+}
+
+//-----------------------------------------------------------------------------
+/// ARRAYS REFERENCED VIA ENUM CLASS ENTRIES
+//-----------------------------------------------------------------------------
+// 
+// substite these in to see the enum strings and assigned values
+//network send - object-instance
+#define PACKDATA_ASSET_ARRAY_ENUMED(name, enumType, index )\
+{\
+   if (stream->writeFlag(m##name##Asset[index].notNull()))\
+   {\
+      stream->writeString(m##name##Asset[index].getAssetId());\
+      const char* enumString = castConsoleTypeToString(static_cast<enumType>(index));\
+      Con::printf("pack: %s = %s",enumString, m##name##AssetId[index]);\
+   }\
+   else\
+      stream->writeString(m##name##Name[index]);\
+}
+//network recieve - object-instance
+#define UNPACKDATA_ASSET_ARRAY_ENUMED(name, enumType, index )\
+{\
+   if (stream->readFlag())\
+   {\
+      m##name##AssetId[index] = stream->readSTString();\
+      _set##name(m##name##AssetId[index], index);\
+      const char* enumString = castConsoleTypeToString(static_cast<enumType>(index));\
+      Con::printf("unpack: %s = %s",enumString, m##name##AssetId[index]);\
+   }\
+   else\
+   {\
+      m##name##Name[index] = stream->readSTString();\
+      _set##name(m##name##AssetId[index], index);\
+   }\
+}
+
diff --git a/Engine/source/T3D/convexShape.cpp b/Engine/source/T3D/convexShape.cpp
index 99f3f418a..47271fd03 100644
--- a/Engine/source/T3D/convexShape.cpp
+++ b/Engine/source/T3D/convexShape.cpp
@@ -290,7 +290,7 @@ ConvexShape::ConvexShape()
    mSurfaceUVs.clear();
    mSurfaceTextures.clear();
 
-   INIT_MATERIALASSET(Material);
+   INIT_ASSET(Material);
 }
 
 ConvexShape::~ConvexShape()
@@ -528,7 +528,7 @@ U32 ConvexShape::packUpdate( NetConnection *conn, U32 mask, BitStream *stream )
 
    if ( stream->writeFlag( mask & UpdateMask ) )
    {
-      PACK_MATERIALASSET(conn, Material);
+      PACK_ASSET(conn, Material);
       
       U32 surfCount = mSurfaces.size();
       stream->writeInt( surfCount, 32 );
@@ -584,7 +584,7 @@ void ConvexShape::unpackUpdate( NetConnection *conn, BitStream *stream )
 
    if ( stream->readFlag() ) // UpdateMask
    {
-      UNPACK_MATERIALASSET(conn, Material);
+      UNPACK_ASSET(conn, Material);
 
       mSurfaces.clear();
       mSurfaceUVs.clear();
@@ -2171,4 +2171,4 @@ void ConvexShape::Geometry::generate(const Vector< PlaneF > &planes, const Vecto
    }
 }
 
-DEF_MATERIALASSET_BINDS(ConvexShape, Material);
+DEF_ASSET_BINDS(ConvexShape, Material);
diff --git a/Engine/source/T3D/convexShape.h b/Engine/source/T3D/convexShape.h
index 22dc4553b..c6d74fe17 100644
--- a/Engine/source/T3D/convexShape.h
+++ b/Engine/source/T3D/convexShape.h
@@ -138,14 +138,14 @@ public:
       // The name of the Material we will use for rendering
       DECLARE_MATERIALASSET(surfaceMaterial, Material);
       
-      DECLARE_MATERIALASSET_SETGET(surfaceMaterial, Material);
+      DECLARE_ASSET_SETGET(surfaceMaterial, Material);
 
       // The actual Material instance
       BaseMatInstance*  materialInst;
 
       surfaceMaterial()
       {
-         INIT_MATERIALASSET(Material);
+         INIT_ASSET(Material);
 
          materialInst = NULL;
       }
@@ -264,7 +264,7 @@ protected:
 protected:
    
    DECLARE_MATERIALASSET(ConvexShape, Material);
-   DECLARE_MATERIALASSET_SETGET(ConvexShape, Material);
+   DECLARE_ASSET_SETGET(ConvexShape, Material);
 
    // The actual Material instance
    BaseMatInstance*  mMaterialInst;
diff --git a/Engine/source/T3D/debris.cpp b/Engine/source/T3D/debris.cpp
index 2362fd089..ba94b0892 100644
--- a/Engine/source/T3D/debris.cpp
+++ b/Engine/source/T3D/debris.cpp
@@ -116,7 +116,7 @@ DebrisData::DebrisData()
    terminalVelocity = 0.0f;
    ignoreWater = true;
 
-   INIT_SHAPEASSET(Shape);
+   INIT_ASSET(Shape);
 }
 
 //#define TRACK_DEBRIS_DATA_CLONES
@@ -152,7 +152,7 @@ DebrisData::DebrisData(const DebrisData& other, bool temp_clone) : GameBaseData(
    terminalVelocity = other.terminalVelocity;
    ignoreWater = other.ignoreWater;
 
-   CLONE_SHAPEASSET(Shape);
+   CLONE_ASSET(Shape);
 
    textureName = other.textureName;
    explosionId = other.explosionId; // -- for pack/unpack of explosion ptr
@@ -382,7 +382,7 @@ void DebrisData::packData(BitStream* stream)
 
    stream->writeString( textureName );
 
-   PACKDATA_SHAPEASSET(Shape);
+   PACKDATA_ASSET(Shape);
 
    for( S32 i=0; i<DDC_NUM_EMITTERS; i++ )
    {
@@ -426,7 +426,7 @@ void DebrisData::unpackData(BitStream* stream)
 
    textureName = stream->readSTString();
 
-   UNPACKDATA_SHAPEASSET(Shape);
+   UNPACKDATA_ASSET(Shape);
 
    for( S32 i=0; i<DDC_NUM_EMITTERS; i++ )
    {
diff --git a/Engine/source/T3D/debris.h b/Engine/source/T3D/debris.h
index cc5e25c7d..83224f190 100644
--- a/Engine/source/T3D/debris.h
+++ b/Engine/source/T3D/debris.h
@@ -84,7 +84,7 @@ struct DebrisData : public GameBaseData
    bool     ignoreWater;
 
    DECLARE_SHAPEASSET(DebrisData, Shape, onShapeChanged);
-   DECLARE_SHAPEASSET_SETGET(DebrisData, Shape);
+   DECLARE_ASSET_SETGET(DebrisData, Shape);
 
    StringTableEntry  textureName;
 
diff --git a/Engine/source/T3D/decal/decalData.cpp b/Engine/source/T3D/decal/decalData.cpp
index 7c033b7f6..d40d50853 100644
--- a/Engine/source/T3D/decal/decalData.cpp
+++ b/Engine/source/T3D/decal/decalData.cpp
@@ -76,7 +76,7 @@ ConsoleDocClass( DecalData,
 DecalData::DecalData()
 {
    size = 5;
-   INIT_MATERIALASSET(Material);
+   INIT_ASSET(Material);
 
    lifeSpan = 5000;
    fadeTime = 1000;
@@ -258,7 +258,7 @@ void DecalData::packData( BitStream *stream )
    stream->write( lookupName );
    stream->write( size );
 
-   PACKDATA_MATERIALASSET(Material);
+   PACKDATA_ASSET(Material);
 
    stream->write( lifeSpan );
    stream->write( fadeTime );
@@ -287,7 +287,7 @@ void DecalData::unpackData( BitStream *stream )
    assignName(lookupName);
    stream->read( &size );
 
-   UNPACKDATA_MATERIALASSET(Material);
+   UNPACKDATA_ASSET(Material);
    
    _updateMaterial();
    stream->read( &lifeSpan );
diff --git a/Engine/source/T3D/decal/decalData.h b/Engine/source/T3D/decal/decalData.h
index 5c32c4427..4a053f303 100644
--- a/Engine/source/T3D/decal/decalData.h
+++ b/Engine/source/T3D/decal/decalData.h
@@ -78,7 +78,7 @@ class DecalData : public SimDataBlock
       F32 fadeEndPixelSize;
 
       DECLARE_MATERIALASSET(DecalData, Material);
-      DECLARE_MATERIALASSET_SETGET(DecalData, Material);
+      DECLARE_ASSET_SETGET(DecalData, Material);
       
       /// Material instance for decal.
       BaseMatInstance *matInst;
@@ -139,4 +139,4 @@ inline SimSet* DecalData::getSet()
    return set;
 }
 
-#endif // _DECALDATA_H_
\ No newline at end of file
+#endif // _DECALDATA_H_
diff --git a/Engine/source/T3D/examples/renderMeshExample.cpp b/Engine/source/T3D/examples/renderMeshExample.cpp
index 772c7bae6..fe1d099eb 100644
--- a/Engine/source/T3D/examples/renderMeshExample.cpp
+++ b/Engine/source/T3D/examples/renderMeshExample.cpp
@@ -59,7 +59,7 @@ RenderMeshExample::RenderMeshExample()
    // Set it as a "static" object that casts shadows
    mTypeMask |= StaticObjectType | StaticShapeObjectType;
 
-   INIT_MATERIALASSET(Material);
+   INIT_ASSET(Material);
 }
 
 RenderMeshExample::~RenderMeshExample()
@@ -143,7 +143,7 @@ U32 RenderMeshExample::packUpdate( NetConnection *conn, U32 mask, BitStream *str
    // Write out any of the updated editable properties
    if (stream->writeFlag(mask & UpdateMask))
    {
-      PACK_MATERIALASSET(conn, Material);
+      PACK_ASSET(conn, Material);
    }
 
    return retMask;
@@ -164,7 +164,7 @@ void RenderMeshExample::unpackUpdate(NetConnection *conn, BitStream *stream)
 
    if ( stream->readFlag() )  // UpdateMask
    {
-      UNPACK_MATERIALASSET(conn, Material);
+      UNPACK_ASSET(conn, Material);
 
       if ( isProperlyAdded() )
          updateMaterial();
diff --git a/Engine/source/T3D/examples/renderMeshExample.h b/Engine/source/T3D/examples/renderMeshExample.h
index 1c20e4bfe..45686b4a6 100644
--- a/Engine/source/T3D/examples/renderMeshExample.h
+++ b/Engine/source/T3D/examples/renderMeshExample.h
@@ -74,7 +74,7 @@ class RenderMeshExample : public SceneObject
    BaseMatInstance* mMaterialInst;
 
    DECLARE_MATERIALASSET(RenderMeshExample, Material);
-   DECLARE_MATERIALASSET_NET_SETGET(RenderMeshExample, Material, UpdateMask);
+   DECLARE_ASSET_NET_SETGET(RenderMeshExample, Material, UpdateMask);
 
    // The GFX vertex and primitive buffers
    GFXVertexBufferHandle< VertexType > mVertexBuffer;
diff --git a/Engine/source/T3D/examples/renderShapeExample.cpp b/Engine/source/T3D/examples/renderShapeExample.cpp
index faf2f9b3f..b8aad1ebf 100644
--- a/Engine/source/T3D/examples/renderShapeExample.cpp
+++ b/Engine/source/T3D/examples/renderShapeExample.cpp
@@ -145,7 +145,7 @@ U32 RenderShapeExample::packUpdate( NetConnection *conn, U32 mask, BitStream *st
    // Write out any of the updated editable properties
    if ( stream->writeFlag( mask & UpdateMask ) )
    {
-      PACK_SHAPEASSET(conn, Shape);
+      PACK_ASSET(conn, Shape);
 
       // Allow the server object a chance to handle a new shape
       createShape();
@@ -169,7 +169,7 @@ void RenderShapeExample::unpackUpdate(NetConnection *conn, BitStream *stream)
 
    if ( stream->readFlag() )  // UpdateMask
    {
-      UNPACK_SHAPEASSET(conn, Shape);
+      UNPACK_ASSET(conn, Shape);
 
       if ( isProperlyAdded() )
          createShape();
@@ -258,4 +258,4 @@ void RenderShapeExample::prepRenderImage( SceneRenderState *state )
 
    // Allow the shape to submit the RenderInst(s) for itself
    mShapeInstance->render( rdata );
-}
\ No newline at end of file
+}
diff --git a/Engine/source/T3D/examples/renderShapeExample.h b/Engine/source/T3D/examples/renderShapeExample.h
index 9c03cbc72..2b3ccf86e 100644
--- a/Engine/source/T3D/examples/renderShapeExample.h
+++ b/Engine/source/T3D/examples/renderShapeExample.h
@@ -62,7 +62,7 @@ class RenderShapeExample : public SceneObject
    // Rendering variables
    //--------------------------------------------------------------------------
    DECLARE_SHAPEASSET(RenderShapeExample, Shape, onShapeChanged);
-   DECLARE_SHAPEASSET_SETGET(RenderShapeExample, Shape);
+   DECLARE_ASSET_SETGET(RenderShapeExample, Shape);
 
    // The actual shape instance
    TSShapeInstance*  mShapeInstance;
diff --git a/Engine/source/T3D/fx/explosion.cpp b/Engine/source/T3D/fx/explosion.cpp
index 17aa6017c..88a5a9432 100644
--- a/Engine/source/T3D/fx/explosion.cpp
+++ b/Engine/source/T3D/fx/explosion.cpp
@@ -230,7 +230,7 @@ ExplosionData::ExplosionData()
 
    faceViewer   = false;
 
-   INIT_SOUNDASSET(Sound);
+   INIT_ASSET(Sound);
 
    //soundProfile      = NULL;
    particleEmitter   = NULL;
@@ -239,7 +239,7 @@ ExplosionData::ExplosionData()
    explosionScale.set(1.0f, 1.0f, 1.0f);
    playSpeed = 1.0f;
 
-   INIT_SHAPEASSET(ExplosionShape);
+   INIT_ASSET(ExplosionShape);
 
    explosionAnimation = -1;
 
@@ -310,12 +310,12 @@ ExplosionData::ExplosionData(const ExplosionData& other, bool temp_clone) : Game
    faceViewer = other.faceViewer;
    particleDensity = other.particleDensity;
    particleRadius = other.particleRadius;
-   CLONE_SOUNDASSET(Sound);
+   CLONE_ASSET(Sound);
    particleEmitter = other.particleEmitter;
    particleEmitterId = other.particleEmitterId; // -- for pack/unpack of particleEmitter ptr 
    explosionScale = other.explosionScale;
    playSpeed = other.playSpeed;
-   CLONE_SHAPEASSET(ExplosionShape);
+   CLONE_ASSET(ExplosionShape);
    explosionAnimation = other.explosionAnimation; // -- from explosionShape sequence "ambient"
    dMemcpy( emitterList, other.emitterList, sizeof( emitterList ) );
    dMemcpy( emitterIDList, other.emitterIDList, sizeof( emitterIDList ) ); // -- for pack/unpack of emitterList ptrs
@@ -650,9 +650,9 @@ void ExplosionData::packData(BitStream* stream)
 {
    Parent::packData(stream);
 
-   PACKDATA_SHAPEASSET(ExplosionShape);
+   PACKDATA_ASSET(ExplosionShape);
 
-   PACKDATA_SOUNDASSET(Sound);
+   PACKDATA_ASSET(Sound);
 
    if (stream->writeFlag(particleEmitter))
       stream->writeRangedU32(particleEmitter->getId(),DataBlockObjectIdFirst,DataBlockObjectIdLast);
@@ -754,9 +754,9 @@ void ExplosionData::unpackData(BitStream* stream)
 {
 	Parent::unpackData(stream);
 
-   UNPACKDATA_SHAPEASSET(ExplosionShape);
+   UNPACKDATA_ASSET(ExplosionShape);
 
-   UNPACKDATA_SOUNDASSET(Sound);
+   UNPACKDATA_ASSET(Sound);
 
    if (stream->readFlag())
       particleEmitterId = stream->readRangedU32(DataBlockObjectIdFirst, DataBlockObjectIdLast);
diff --git a/Engine/source/T3D/fx/explosion.h b/Engine/source/T3D/fx/explosion.h
index 41116cd32..eac392e11 100644
--- a/Engine/source/T3D/fx/explosion.h
+++ b/Engine/source/T3D/fx/explosion.h
@@ -71,7 +71,7 @@ class ExplosionData : public GameBaseData {
    F32 particleRadius;
 
    DECLARE_SOUNDASSET(ExplosionData, Sound);
-   DECLARE_SOUNDASSET_SETGET(ExplosionData, Sound);
+   DECLARE_ASSET_SETGET(ExplosionData, Sound);
 
    ParticleEmitterData* particleEmitter;
    S32                  particleEmitterId;
@@ -80,7 +80,7 @@ class ExplosionData : public GameBaseData {
    F32                  playSpeed;
 
    DECLARE_SHAPEASSET(ExplosionData, ExplosionShape, onShapeChanged);
-   DECLARE_SHAPEASSET_SETGET(ExplosionData, ExplosionShape);
+   DECLARE_ASSET_SETGET(ExplosionData, ExplosionShape);
 
    S32               explosionAnimation;
 
diff --git a/Engine/source/T3D/fx/groundCover.cpp b/Engine/source/T3D/fx/groundCover.cpp
index 41f8a8c1a..a9c975eec 100644
--- a/Engine/source/T3D/fx/groundCover.cpp
+++ b/Engine/source/T3D/fx/groundCover.cpp
@@ -459,7 +459,7 @@ GroundCover::GroundCover()
 
    mRandomSeed = 1;
 
-   INIT_MATERIALASSET(Material);
+   INIT_ASSET(Material);
    mMaterialInst = NULL;
 
    mMatParams = NULL;
@@ -520,7 +520,7 @@ GroundCover::GroundCover()
       mBillboardRects[i].point.set( 0.0f, 0.0f );
       mBillboardRects[i].extent.set( 1.0f, 1.0f );
 
-      INIT_SHAPEASSET_ARRAY(Shape, i);
+      INIT_ASSET_ARRAY(Shape, i);
 
       mShapeInstances[i] = NULL;
 
@@ -713,7 +713,7 @@ U32 GroundCover::packUpdate( NetConnection *connection, U32 mask, BitStream *str
       // TODO: We could probably optimize a few of these
       // based on reasonable units at some point.
 
-      PACK_MATERIALASSET(connection, Material);
+      PACK_ASSET(connection, Material);
 
       stream->write( mRadius );
       stream->write( mZOffset );
@@ -766,7 +766,7 @@ U32 GroundCover::packUpdate( NetConnection *connection, U32 mask, BitStream *str
          stream->write( mBillboardRects[i].extent.x );
          stream->write( mBillboardRects[i].extent.y );
 
-         PACK_SHAPEASSET_ARRAY(connection, Shape, i);
+         PACK_ASSET_ARRAY(connection, Shape, i);
       }
 
       stream->writeFlag( mDebugRenderCells );
@@ -784,7 +784,7 @@ void GroundCover::unpackUpdate( NetConnection *connection, BitStream *stream )
 
    if (stream->readFlag())
    {
-      UNPACK_MATERIALASSET(connection, Material);
+      UNPACK_ASSET(connection, Material);
 
       stream->read( &mRadius );
       stream->read( &mZOffset );
@@ -837,7 +837,7 @@ void GroundCover::unpackUpdate( NetConnection *connection, BitStream *stream )
          stream->read( &mBillboardRects[i].extent.x );
          stream->read( &mBillboardRects[i].extent.y );
 
-         UNPACK_SHAPEASSET_ARRAY(connection, Shape, i);
+         UNPACK_ASSET_ARRAY(connection, Shape, i);
       }
 
       mDebugRenderCells    = stream->readFlag();
diff --git a/Engine/source/T3D/fx/groundCover.h b/Engine/source/T3D/fx/groundCover.h
index fbf6bf263..aba467810 100644
--- a/Engine/source/T3D/fx/groundCover.h
+++ b/Engine/source/T3D/fx/groundCover.h
@@ -269,7 +269,7 @@ protected:
    BaseMatInstance* mMaterialInst;
 
    DECLARE_MATERIALASSET(GroundCover, Material);
-   DECLARE_MATERIALASSET_NET_SETGET(GroundCover, Material, InitialUpdateMask);
+   DECLARE_ASSET_NET_SETGET(GroundCover, Material, InitialUpdateMask);
 
    GroundCoverShaderConstData mShaderConstData;
 
@@ -341,7 +341,7 @@ protected:
 
    /// The cover shape filenames.
    DECLARE_SHAPEASSET_ARRAY(GroundCover, Shape, MAX_COVERTYPES);
-   DECLARE_SHAPEASSET_ARRAY_NET_SETGET(GroundCover, Shape, -1);
+   DECLARE_ASSET_ARRAY_NET_SETGET(GroundCover, Shape, -1);
 
    /// The cover shape instances.
    TSShapeInstance* mShapeInstances[MAX_COVERTYPES];
diff --git a/Engine/source/T3D/fx/lightning.cpp b/Engine/source/T3D/fx/lightning.cpp
index 0e28b1a42..8d9e20183 100644
--- a/Engine/source/T3D/fx/lightning.cpp
+++ b/Engine/source/T3D/fx/lightning.cpp
@@ -238,11 +238,11 @@ void LightningStrikeEvent::process(NetConnection*)
 //
 LightningData::LightningData()
 {
-   INIT_SOUNDASSET(StrikeSound);
+   INIT_ASSET(StrikeSound);
 
    for (S32 i = 0; i < MaxThunders; i++)
    {
-      INIT_SOUNDASSET_ARRAY(ThunderSound, i);
+      INIT_ASSET_ARRAY(ThunderSound, i);
    }
 
    for (S32 i = 0; i < MaxTextures; i++)
@@ -335,7 +335,7 @@ void LightningData::packData(BitStream* stream)
    U32 i;
    for (i = 0; i < MaxThunders; i++)
    {
-      PACKDATA_SOUNDASSET_ARRAY(ThunderSound, i);
+      PACKDATA_ASSET_ARRAY(ThunderSound, i);
    }
 
    stream->writeInt(mNumStrikeTextures, 4);
@@ -343,7 +343,7 @@ void LightningData::packData(BitStream* stream)
    for (i = 0; i < MaxTextures; i++)
       stream->writeString(strikeTextureNames[i]);
 
-   PACKDATA_SOUNDASSET(StrikeSound);
+   PACKDATA_ASSET(StrikeSound);
 }
 
 void LightningData::unpackData(BitStream* stream)
@@ -353,7 +353,7 @@ void LightningData::unpackData(BitStream* stream)
    U32 i;
    for (i = 0; i < MaxThunders; i++)
    {
-      UNPACKDATA_SOUNDASSET_ARRAY(ThunderSound, i);
+      UNPACKDATA_ASSET_ARRAY(ThunderSound, i);
    }
 
    mNumStrikeTextures = stream->readInt(4);
@@ -361,7 +361,7 @@ void LightningData::unpackData(BitStream* stream)
    for (i = 0; i < MaxTextures; i++)
       strikeTextureNames[i] = stream->readSTString();
 
-   UNPACKDATA_SOUNDASSET(StrikeSound);
+   UNPACKDATA_ASSET(StrikeSound);
 }
 
 
diff --git a/Engine/source/T3D/fx/lightning.h b/Engine/source/T3D/fx/lightning.h
index d241257b0..be3b65319 100644
--- a/Engine/source/T3D/fx/lightning.h
+++ b/Engine/source/T3D/fx/lightning.h
@@ -65,10 +65,10 @@ class LightningData : public GameBaseData
   public:
 
    DECLARE_SOUNDASSET_ARRAY(LightningData, ThunderSound, MaxThunders);
-   DECLARE_SOUNDASSET_ARRAY_SETGET(LightningData, ThunderSound);
+   DECLARE_ASSET_ARRAY_SETGET(LightningData, ThunderSound);
 
    DECLARE_SOUNDASSET(LightningData, StrikeSound);
-   DECLARE_SOUNDASSET_SETGET(LightningData, StrikeSound);
+   DECLARE_ASSET_SETGET(LightningData, StrikeSound);
 
    StringTableEntry  strikeTextureNames[MaxTextures];
 
diff --git a/Engine/source/T3D/fx/particle.cpp b/Engine/source/T3D/fx/particle.cpp
index 7cfa7e182..090a2f119 100644
--- a/Engine/source/T3D/fx/particle.cpp
+++ b/Engine/source/T3D/fx/particle.cpp
@@ -122,8 +122,8 @@ ParticleData::ParticleData()
    animTexFramesString = NULL;  // string of animation frame indices
    animTexUVs = NULL;           // array of tile vertex UVs
 
-   INIT_IMAGEASSET(Texture);
-   INIT_IMAGEASSET(TextureExt);
+   INIT_ASSET(Texture);
+   INIT_ASSET(TextureExt);
 
    constrain_pos = false;
    start_angle = 0.0f;
@@ -293,7 +293,7 @@ void ParticleData::packData(BitStream* stream)
       stream->writeFloat( times[i], 8);
    }
 
-   //PACKDATA_IMAGEASSET(Texture);
+   //PACKDATA_ASSET(Texture);
 
    for (i = 0; i < 4; i++)
       mathWrite(*stream, texCoords[i]);
@@ -307,7 +307,7 @@ void ParticleData::packData(BitStream* stream)
       stream->writeInt(framesPerSec, 8);
    }
 
-   //PACKDATA_IMAGEASSET(TextureExt);
+   //PACKDATA_ASSET(TextureExt);
 
    stream->writeFlag(constrain_pos);
    stream->writeFloat(start_angle/360.0f, 11);
@@ -378,7 +378,7 @@ void ParticleData::unpackData(BitStream* stream)
       times[i] = stream->readFloat(8);
    }
 
-   //UNPACKDATA_IMAGEASSET(Texture);
+   //UNPACKDATA_ASSET(Texture);
 
    for (i = 0; i < 4; i++)
       mathRead(*stream, &texCoords[i]);
@@ -391,7 +391,7 @@ void ParticleData::unpackData(BitStream* stream)
      framesPerSec = stream->readInt(8);
    }
 
-   //UNPACKDATA_IMAGEASSET(Texture);
+   //UNPACKDATA_ASSET(Texture);
 
    constrain_pos = stream->readFlag();
    start_angle = 360.0f*stream->readFloat(11);
@@ -763,12 +763,12 @@ ParticleData::ParticleData(const ParticleData& other, bool temp_clone) : SimData
   animTexFramesString = other.animTexFramesString;
   animTexFrames = other.animTexFrames; // -- parsed from animTexFramesString
 
-  CLONE_IMAGEASSET(Texture);
+  CLONE_ASSET(Texture);
   
   spinBias = other.spinBias;
   randomizeSpinDir = other.randomizeSpinDir;
 
-  CLONE_IMAGEASSET(TextureExt);
+  CLONE_ASSET(TextureExt);
 
   constrain_pos = other.constrain_pos;
   start_angle = other.start_angle;
@@ -804,4 +804,4 @@ void ParticleData::onPerformSubstitutions()
   reload(errorBuffer);
 }
 
-DEF_IMAGEASSET_BINDS(ParticleData, Texture);
+DEF_ASSET_BINDS(ParticleData, Texture);
diff --git a/Engine/source/T3D/fx/particle.h b/Engine/source/T3D/fx/particle.h
index 1d6d88c12..e05b67b88 100644
--- a/Engine/source/T3D/fx/particle.h
+++ b/Engine/source/T3D/fx/particle.h
@@ -87,7 +87,7 @@ class ParticleData : public SimDataBlock
    Vector<U8>        animTexFrames;
 
    DECLARE_IMAGEASSET(ParticleData, Texture, onImageChanged, GFXStaticTextureSRGBProfile);
-   DECLARE_IMAGEASSET_SETGET(ParticleData, Texture);
+   DECLARE_ASSET_SETGET(ParticleData, Texture);
 
    static bool protectedSetSizes(void* object, const char* index, const char* data);
    static bool protectedSetTimes(void* object, const char* index, const char* data);
@@ -118,7 +118,7 @@ public:
    bool  randomizeSpinDir;
   public:
    DECLARE_IMAGEASSET(ParticleData, TextureExt, onImageChanged, GFXStaticTextureSRGBProfile);
-   DECLARE_IMAGEASSET_SETGET(ParticleData, TextureExt);
+   DECLARE_ASSET_SETGET(ParticleData, TextureExt);
 
    bool   constrain_pos;
    F32    start_angle;
diff --git a/Engine/source/T3D/fx/precipitation.cpp b/Engine/source/T3D/fx/precipitation.cpp
index 68880edf4..1de61e8e2 100644
--- a/Engine/source/T3D/fx/precipitation.cpp
+++ b/Engine/source/T3D/fx/precipitation.cpp
@@ -127,13 +127,13 @@ ConsoleDocClass( PrecipitationData,
 //----------------------------------------------------------
 PrecipitationData::PrecipitationData()
 {
-   INIT_SOUNDASSET(Sound);
+   INIT_ASSET(Sound);
 
-   INIT_IMAGEASSET(Drop);
+   INIT_ASSET(Drop);
 
    mDropShaderName   = StringTable->EmptyString();
 
-   INIT_IMAGEASSET(Splash);
+   INIT_ASSET(Splash);
 
    mSplashShaderName = StringTable->EmptyString();
 
@@ -206,13 +206,13 @@ void PrecipitationData::packData(BitStream* stream)
 {
    Parent::packData(stream);
 
-   PACKDATA_SOUNDASSET(Sound);
+   PACKDATA_ASSET(Sound);
 
-   PACKDATA_IMAGEASSET(Drop);
+   PACKDATA_ASSET(Drop);
 
    stream->writeString(mDropShaderName);
 
-   PACKDATA_IMAGEASSET(Splash);
+   PACKDATA_ASSET(Splash);
 
    stream->writeString(mSplashShaderName);
    stream->write(mDropsPerSide);
@@ -223,13 +223,13 @@ void PrecipitationData::unpackData(BitStream* stream)
 {
    Parent::unpackData(stream);
 
-   UNPACKDATA_SOUNDASSET(Sound);
+   UNPACKDATA_ASSET(Sound);
 
-   UNPACKDATA_IMAGEASSET(Drop);
+   UNPACKDATA_ASSET(Drop);
 
    mDropShaderName = stream->readSTString();
 
-   UNPACKDATA_IMAGEASSET(Splash);
+   UNPACKDATA_ASSET(Splash);
 
    mSplashShaderName = stream->readSTString();
    stream->read(&mDropsPerSide);
diff --git a/Engine/source/T3D/fx/precipitation.h b/Engine/source/T3D/fx/precipitation.h
index 719613384..eb3a540e0 100644
--- a/Engine/source/T3D/fx/precipitation.h
+++ b/Engine/source/T3D/fx/precipitation.h
@@ -47,15 +47,15 @@ class PrecipitationData : public GameBaseData
 
   public:
      DECLARE_SOUNDASSET(PrecipitationData, Sound);
-     DECLARE_SOUNDASSET_SETGET(PrecipitationData, Sound);
+     DECLARE_ASSET_SETGET(PrecipitationData, Sound);
 
       DECLARE_IMAGEASSET(PrecipitationData, Drop, onDropChanged, GFXStaticTextureSRGBProfile); ///< Texture for drop particles
-      DECLARE_IMAGEASSET_SETGET(PrecipitationData, Drop);
+      DECLARE_ASSET_SETGET(PrecipitationData, Drop);
 
       StringTableEntry mDropShaderName;   ///< The name of the shader used for raindrops
 
       DECLARE_IMAGEASSET(PrecipitationData, Splash, onSplashChanged, GFXStaticTextureSRGBProfile); ///< Texture for splash particles
-      DECLARE_IMAGEASSET_SETGET(PrecipitationData, Splash);
+      DECLARE_ASSET_SETGET(PrecipitationData, Splash);
 
       StringTableEntry mSplashShaderName; ///< The name of the shader used for raindrops
 
diff --git a/Engine/source/T3D/fx/splash.cpp b/Engine/source/T3D/fx/splash.cpp
index 38a4f4e89..3ae7e54b4 100644
--- a/Engine/source/T3D/fx/splash.cpp
+++ b/Engine/source/T3D/fx/splash.cpp
@@ -70,7 +70,7 @@ SplashData::SplashData()
    //soundProfile      = NULL;
    //soundProfileId    = 0;
 
-   INIT_SOUNDASSET(Sound);
+   INIT_ASSET(Sound);
 
    scale.set(1, 1, 1);
 
@@ -98,7 +98,7 @@ SplashData::SplashData()
    U32 i;
    for (i = 0; i < NUM_TEX; i++)
    {
-      INIT_IMAGEASSET_ARRAY(Texture, i);
+      INIT_ASSET_ARRAY(Texture, i);
    }
 
    for( i=0; i<NUM_TIME_KEYS; i++ )
@@ -163,7 +163,7 @@ void SplashData::packData(BitStream* stream)
 {
    Parent::packData(stream);
 
-   PACKDATA_SOUNDASSET(Sound);
+   PACKDATA_ASSET(Sound);
 
    mathWrite(*stream, scale);
    stream->write(delayMS);
@@ -208,7 +208,7 @@ void SplashData::packData(BitStream* stream)
 
    for( i=0; i<NUM_TEX; i++ )
    {
-      PACKDATA_IMAGEASSET_ARRAY(Texture, i);
+      PACKDATA_ASSET_ARRAY(Texture, i);
    }
 }
 
@@ -219,7 +219,7 @@ void SplashData::unpackData(BitStream* stream)
 {
    Parent::unpackData(stream);
 
-   UNPACKDATA_SOUNDASSET(Sound);
+   UNPACKDATA_ASSET(Sound);
 
    mathRead(*stream, &scale);
    stream->read(&delayMS);
@@ -264,7 +264,7 @@ void SplashData::unpackData(BitStream* stream)
 
    for( i=0; i<NUM_TEX; i++ )
    {
-      UNPACKDATA_IMAGEASSET_ARRAY(Texture, i);
+      UNPACKDATA_ASSET_ARRAY(Texture, i);
    }
 }
 
diff --git a/Engine/source/T3D/fx/splash.h b/Engine/source/T3D/fx/splash.h
index 4cde2db00..b81c074f5 100644
--- a/Engine/source/T3D/fx/splash.h
+++ b/Engine/source/T3D/fx/splash.h
@@ -96,7 +96,7 @@ public:
    //S32                     soundProfileId;
 
    DECLARE_SOUNDASSET(SplashData, Sound);
-   DECLARE_SOUNDASSET_SETGET(SplashData, Sound);
+   DECLARE_ASSET_SETGET(SplashData, Sound);
 
    ParticleEmitterData*    emitterList[NUM_EMITTERS];
    S32                     emitterIDList[NUM_EMITTERS];
diff --git a/Engine/source/T3D/groundPlane.cpp b/Engine/source/T3D/groundPlane.cpp
index 5c3033cbc..3062ff813 100644
--- a/Engine/source/T3D/groundPlane.cpp
+++ b/Engine/source/T3D/groundPlane.cpp
@@ -87,7 +87,7 @@ GroundPlane::GroundPlane()
    mConvexList = new Convex;
    mTypeMask |= TerrainLikeObjectType;
 
-   INIT_MATERIALASSET(Material);
+   INIT_ASSET(Material);
 }
 
 GroundPlane::~GroundPlane()
@@ -199,7 +199,7 @@ U32 GroundPlane::packUpdate( NetConnection* connection, U32 mask, BitStream* str
    stream->write( mScaleU );
    stream->write( mScaleV );
 
-   PACK_MATERIALASSET(connection, Material);
+   PACK_ASSET(connection, Material);
 
    return retMask;
 }
@@ -212,7 +212,7 @@ void GroundPlane::unpackUpdate( NetConnection* connection, BitStream* stream )
    stream->read( &mScaleU );
    stream->read( &mScaleV );
 
-   UNPACK_MATERIALASSET(connection, Material);
+   UNPACK_ASSET(connection, Material);
 
    // If we're added then something possibly changed in 
    // the editor... do an update of the material and the
diff --git a/Engine/source/T3D/groundPlane.h b/Engine/source/T3D/groundPlane.h
index 752c78668..9e57c325c 100644
--- a/Engine/source/T3D/groundPlane.h
+++ b/Engine/source/T3D/groundPlane.h
@@ -108,7 +108,7 @@ private:
    BaseMatInstance* mMaterialInst;
 
    DECLARE_MATERIALASSET(GroundPlane, Material);
-   DECLARE_MATERIALASSET_NET_SETGET(GroundPlane, Material, -1);
+   DECLARE_ASSET_NET_SETGET(GroundPlane, Material, -1);
 
    PhysicsBody *mPhysicsRep;
 
diff --git a/Engine/source/T3D/levelInfo.cpp b/Engine/source/T3D/levelInfo.cpp
index 7d6905841..d10077cea 100644
--- a/Engine/source/T3D/levelInfo.cpp
+++ b/Engine/source/T3D/levelInfo.cpp
@@ -99,7 +99,7 @@ LevelInfo::LevelInfo()
 
    mAdvancedLightmapSupport = true;
 
-   INIT_IMAGEASSET(AccuTexture);
+   INIT_ASSET(AccuTexture);
 
    // Register with the light manager activation signal, and we need to do it first
    // so the advanced light bin manager can be instructed about MRT lightmaps
@@ -215,7 +215,7 @@ U32 LevelInfo::packUpdate(NetConnection *conn, U32 mask, BitStream *stream)
    sfxWrite( stream, mSoundAmbience );
    stream->writeInt( mSoundDistanceModel, 1 );
 
-   PACK_IMAGEASSET(conn, AccuTexture);
+   PACK_ASSET(conn, AccuTexture);
 
    return retMask;
 }
@@ -262,7 +262,7 @@ void LevelInfo::unpackUpdate(NetConnection *conn, BitStream *stream)
       SFX->setDistanceModel( mSoundDistanceModel );
    }
 
-   UNPACK_IMAGEASSET(conn, AccuTexture);
+   UNPACK_ASSET(conn, AccuTexture);
    setLevelAccuTexture(getAccuTexture());
 }
 
diff --git a/Engine/source/T3D/levelInfo.h b/Engine/source/T3D/levelInfo.h
index 5b998dada..122d7ad8d 100644
--- a/Engine/source/T3D/levelInfo.h
+++ b/Engine/source/T3D/levelInfo.h
@@ -105,7 +105,7 @@ class LevelInfo : public NetObject
    protected:
 
       DECLARE_IMAGEASSET(LevelInfo, AccuTexture, onAccuTextureChanged, GFXStaticTextureSRGBProfile);
-      DECLARE_IMAGEASSET_SETGET(LevelInfo, AccuTexture);
+      DECLARE_ASSET_SETGET(LevelInfo, AccuTexture);
 
       void onAccuTextureChanged() {}
 
diff --git a/Engine/source/T3D/lightFlareData.cpp b/Engine/source/T3D/lightFlareData.cpp
index 98f406a1b..fb8fbaa55 100644
--- a/Engine/source/T3D/lightFlareData.cpp
+++ b/Engine/source/T3D/lightFlareData.cpp
@@ -133,7 +133,7 @@ LightFlareData::LightFlareData()
    for ( U32 i = 0; i < MAX_ELEMENTS; i++ )   
       mElementDist[i] = -1.0f;
 
-   INIT_IMAGEASSET(FlareTexture);
+   INIT_ASSET(FlareTexture);
 }
 
 LightFlareData::~LightFlareData()
@@ -219,7 +219,7 @@ void LightFlareData::packData( BitStream *stream )
 
    stream->writeFlag( mFlareEnabled );
 
-   PACKDATA_IMAGEASSET(FlareTexture);
+   PACKDATA_ASSET(FlareTexture);
 
    stream->write( mScale );
    stream->write( mOcclusionRadius );
@@ -244,7 +244,7 @@ void LightFlareData::unpackData( BitStream *stream )
 
    mFlareEnabled = stream->readFlag();
 
-   UNPACKDATA_IMAGEASSET(FlareTexture);
+   UNPACKDATA_ASSET(FlareTexture);
 
    stream->read( &mScale );
    stream->read( &mOcclusionRadius );
diff --git a/Engine/source/T3D/lightFlareData.h b/Engine/source/T3D/lightFlareData.h
index 6d79aac7b..b2a87520c 100644
--- a/Engine/source/T3D/lightFlareData.h
+++ b/Engine/source/T3D/lightFlareData.h
@@ -121,7 +121,7 @@ protected:
    bool mFlareEnabled;
 
    DECLARE_IMAGEASSET(LightFlareData, FlareTexture, onImageChanged, GFXStaticTextureSRGBProfile);
-   DECLARE_IMAGEASSET_SETGET(LightFlareData, FlareTexture);
+   DECLARE_ASSET_SETGET(LightFlareData, FlareTexture);
 
    F32 mOcclusionRadius;
    bool mRenderReflectPass;
diff --git a/Engine/source/T3D/physics/physicsDebris.cpp b/Engine/source/T3D/physics/physicsDebris.cpp
index 835871bb5..077fcf7d8 100644
--- a/Engine/source/T3D/physics/physicsDebris.cpp
+++ b/Engine/source/T3D/physics/physicsDebris.cpp
@@ -74,7 +74,7 @@ PhysicsDebrisData::PhysicsDebrisData()
    lifetime = 5.0f;
    lifetimeVariance = 0.0f;
 
-   INIT_SHAPEASSET(Shape);
+   INIT_ASSET(Shape);
 }
 
 bool PhysicsDebrisData::onAdd()
@@ -215,7 +215,7 @@ void PhysicsDebrisData::packData(BitStream* stream)
    stream->write( waterDampingScale );
    stream->write( buoyancyDensity );
 
-   PACKDATA_SHAPEASSET(Shape);
+   PACKDATA_ASSET(Shape);
 }
 
 void PhysicsDebrisData::unpackData(BitStream* stream)
@@ -236,7 +236,7 @@ void PhysicsDebrisData::unpackData(BitStream* stream)
    stream->read( &waterDampingScale );
    stream->read( &buoyancyDensity );
 
-   UNPACKDATA_SHAPEASSET(Shape);
+   UNPACKDATA_ASSET(Shape);
 }
 
 DefineEngineMethod( PhysicsDebrisData, preload, void, (), , 
diff --git a/Engine/source/T3D/physics/physicsDebris.h b/Engine/source/T3D/physics/physicsDebris.h
index c58d66626..2a4a3d0fc 100644
--- a/Engine/source/T3D/physics/physicsDebris.h
+++ b/Engine/source/T3D/physics/physicsDebris.h
@@ -87,7 +87,7 @@ public:
    bool castShadows;
 
    DECLARE_SHAPEASSET(PhysicsDebrisData, Shape, onShapeChanged);
-   DECLARE_SHAPEASSET_SETGET(PhysicsDebrisData, Shape);
+   DECLARE_ASSET_SETGET(PhysicsDebrisData, Shape);
 
    PhysicsDebrisData();
 
diff --git a/Engine/source/T3D/physics/physicsShape.cpp b/Engine/source/T3D/physics/physicsShape.cpp
index 6808866ca..6e6b4e937 100644
--- a/Engine/source/T3D/physics/physicsShape.cpp
+++ b/Engine/source/T3D/physics/physicsShape.cpp
@@ -78,7 +78,7 @@ PhysicsShapeData::PhysicsShapeData()
       buoyancyDensity( 0.0f ),
       simType( SimType_ClientServer )      
 {
-   INIT_SHAPEASSET(Shape);
+   INIT_ASSET(Shape);
 }
 
 PhysicsShapeData::~PhysicsShapeData()
@@ -180,7 +180,7 @@ void PhysicsShapeData::packData( BitStream *stream )
 { 
    Parent::packData( stream );
 
-   PACKDATA_SHAPEASSET(Shape);
+   PACKDATA_ASSET(Shape);
 
    stream->write( mass );
    stream->write( dynamicFriction );
@@ -204,7 +204,7 @@ void PhysicsShapeData::unpackData( BitStream *stream )
 {
    Parent::unpackData(stream);
 
-   UNPACKDATA_SHAPEASSET(Shape);
+   UNPACKDATA_ASSET(Shape);
 
    stream->read( &mass );
    stream->read( &dynamicFriction );
diff --git a/Engine/source/T3D/physics/physicsShape.h b/Engine/source/T3D/physics/physicsShape.h
index a80d85afc..ebbad92d2 100644
--- a/Engine/source/T3D/physics/physicsShape.h
+++ b/Engine/source/T3D/physics/physicsShape.h
@@ -75,7 +75,7 @@ public:
 public:
 
    DECLARE_SHAPEASSET(PhysicsShapeData, Shape, onShapeChanged);
-   DECLARE_SHAPEASSET_SETGET(PhysicsShapeData, Shape);
+   DECLARE_ASSET_SETGET(PhysicsShapeData, Shape);
 
    /// The shared unscaled collision shape.
    PhysicsCollisionRef colShape;
diff --git a/Engine/source/T3D/player.cpp b/Engine/source/T3D/player.cpp
index 3e994995a..7aabe0384 100644
--- a/Engine/source/T3D/player.cpp
+++ b/Engine/source/T3D/player.cpp
@@ -186,7 +186,6 @@ PlayerData::ActionAnimationDef PlayerData::ActionAnimationList[NumTableActionAni
 };
 
 
-//----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 typedef PlayerData::Sounds playerSoundsEnum;
@@ -216,6 +215,8 @@ EndImplementEnumType;
 
 //----------------------------------------------------------------------------
 
+//----------------------------------------------------------------------------
+
 IMPLEMENT_CO_DATABLOCK_V1(PlayerData);
 
 ConsoleDocClass( PlayerData,
@@ -297,7 +298,7 @@ PlayerData::PlayerData()
    imageAnimPrefixFP = StringTable->EmptyString();
    for (U32 i=0; i<ShapeBase::MaxMountedImages; ++i)
    {
-      INIT_SHAPEASSET_ARRAY(ShapeFP, i);
+      INIT_ASSET_ARRAY(ShapeFP, i);
       mCRCFP[i] = 0;
       mValidShapeFP[i] = false;
    }
@@ -422,7 +423,7 @@ PlayerData::PlayerData()
    boxHeadFrontPercentage = 1;
 
    for (S32 i = 0; i < MaxSounds; i++)
-      INIT_SOUNDASSET_ARRAY(PlayerSound, i);
+      INIT_ASSET_ARRAY(PlayerSound, i);
 
    footPuffEmitter = NULL;
    footPuffID = 0;
@@ -1048,9 +1049,7 @@ void PlayerData::initPersistFields()
    endGroup( "Interaction: Footsteps" );
 
    addGroup( "Interaction: Sounds" );
-
    INITPERSISTFIELD_SOUNDASSET_ENUMED(PlayerSound, playerSoundsEnum, PlayerData::Sounds::MaxSounds, PlayerData, "Sounds related to player interaction.");
-
    endGroup( "Interaction: Sounds" );
 
    addGroup( "Interaction: Splashes" );
@@ -1275,7 +1274,7 @@ void PlayerData::packData(BitStream* stream)
    stream->write(minLateralImpactSpeed);
 
    for (U32 i = 0; i < MaxSounds; i++)
-      PACKDATA_SOUNDASSET_ARRAY_ENUMED(PlayerSound, PlayerData::Sounds, i);
+      PACKDATA_ASSET_ARRAY(PlayerSound, i);
 
    mathWrite(*stream, boxSize);
    mathWrite(*stream, crouchBoxSize);
@@ -1343,7 +1342,7 @@ void PlayerData::packData(BitStream* stream)
    stream->writeString(imageAnimPrefixFP);
    for (U32 i=0; i<ShapeBase::MaxMountedImages; ++i)
    {
-      PACKDATA_SHAPEASSET_ARRAY(ShapeFP, i);
+      PACKDATA_ASSET_ARRAY(ShapeFP, i);
 
       // computeCRC is handled in ShapeBaseData
       if (computeCRC)
@@ -1456,7 +1455,7 @@ void PlayerData::unpackData(BitStream* stream)
    stream->read(&minLateralImpactSpeed);
 
    for (U32 i = 0; i < MaxSounds; i++)
-      UNPACKDATA_SOUNDASSET_ARRAY_ENUMED(PlayerSound, PlayerData::Sounds, i);
+      UNPACKDATA_ASSET_ARRAY(PlayerSound, i);
 
    mathRead(*stream, &boxSize);
    mathRead(*stream, &crouchBoxSize);
@@ -1523,7 +1522,7 @@ void PlayerData::unpackData(BitStream* stream)
    imageAnimPrefixFP = stream->readSTString();
    for (U32 i=0; i<ShapeBase::MaxMountedImages; ++i)
    {
-      UNPACKDATA_SHAPEASSET_ARRAY(ShapeFP, i);
+      UNPACKDATA_ASSET_ARRAY(ShapeFP, i);
 
       // computeCRC is handled in ShapeBaseData
       if (computeCRC)
diff --git a/Engine/source/T3D/player.h b/Engine/source/T3D/player.h
index ed0cfea63..cd216fa53 100644
--- a/Engine/source/T3D/player.h
+++ b/Engine/source/T3D/player.h
@@ -77,7 +77,7 @@ struct PlayerData: public ShapeBaseData {
                                                                   ///  need to.
 
    DECLARE_SHAPEASSET_ARRAY(PlayerData, ShapeFP, ShapeBase::MaxMountedImages); ///< Used to render with mounted images in first person [optional]
-   DECLARE_SHAPEASSET_ARRAY_SETGET(PlayerData, ShapeFP);
+   DECLARE_ASSET_ARRAY_SETGET(PlayerData, ShapeFP);
 
    StringTableEntry  imageAnimPrefixFP;                           ///< Passed along to mounted images to modify
                                                                   ///  animation sequences played in first person. [optional]
@@ -202,14 +202,14 @@ struct PlayerData: public ShapeBaseData {
       FootMetal,
       FootSnow,
       WaterStart,
-      FootShallowSplash = WaterStart,
+      FootShallowSplash,
       FootWading,
       FootUnderWater,
       FootBubbles,
       MoveBubbles,
       WaterBreath,
       ImpactStart,
-      ImpactSoft = ImpactStart,
+      ImpactSoft,
       ImpactHard,
       ImpactMetal,
       ImpactSnow,
@@ -879,5 +879,4 @@ public:
 typedef Player::Pose PlayerPose;
 
 DefineEnumType( PlayerPose );
-
 #endif
diff --git a/Engine/source/T3D/projectile.cpp b/Engine/source/T3D/projectile.cpp
index 762b63c1f..4150f1506 100644
--- a/Engine/source/T3D/projectile.cpp
+++ b/Engine/source/T3D/projectile.cpp
@@ -144,9 +144,9 @@ U32 Projectile::smProjectileWarpTicks = 5;
 //
 ProjectileData::ProjectileData()
 {
-   INIT_SHAPEASSET(ProjectileShape);
+   INIT_ASSET(ProjectileShape);
 
-   INIT_SOUNDASSET(ProjectileSound);
+   INIT_ASSET(ProjectileSound);
 
    explosion = NULL;
    explosionId = 0;
@@ -217,10 +217,10 @@ ProjectileData::ProjectileData(const ProjectileData& other, bool temp_clone) : G
    splashId = other.splashId; // -- for pack/unpack of splash ptr
    decal = other.decal;
    decalId = other.decalId; // -- for pack/unpack of decal ptr
-   CLONE_SOUNDASSET(ProjectileSound);
+   CLONE_ASSET(ProjectileSound);
    lightDesc = other.lightDesc;
    lightDescId = other.lightDescId; // -- for pack/unpack of lightDesc ptr
-   CLONE_SHAPEASSET(ProjectileShape);// -- TSShape loads using mProjectileShapeName
+   CLONE_ASSET(ProjectileShape);// -- TSShape loads using mProjectileShapeName
    activateSeq = other.activateSeq; // -- from projectileShape sequence "activate"
    maintainSeq = other.maintainSeq; // -- from projectileShape sequence "maintain"
    particleEmitter = other.particleEmitter;
@@ -406,7 +406,7 @@ void ProjectileData::packData(BitStream* stream)
 {
    Parent::packData(stream);
 
-   PACKDATA_SHAPEASSET(ProjectileShape);
+   PACKDATA_ASSET(ProjectileShape);
 
    stream->writeFlag(faceViewer);
    if(stream->writeFlag(scale.x != 1 || scale.y != 1 || scale.z != 1))
@@ -439,7 +439,7 @@ void ProjectileData::packData(BitStream* stream)
    if (stream->writeFlag(decal != NULL))
       stream->writeRangedU32(decal->getId(), DataBlockObjectIdFirst,
                                               DataBlockObjectIdLast);
-   PACKDATA_SOUNDASSET(ProjectileSound);
+   PACKDATA_ASSET(ProjectileSound);
 
    if ( stream->writeFlag(lightDesc != NULL))
       stream->writeRangedU32(lightDesc->getId(), DataBlockObjectIdFirst,
@@ -470,7 +470,7 @@ void ProjectileData::unpackData(BitStream* stream)
 {
    Parent::unpackData(stream);
 
-   UNPACKDATA_SHAPEASSET(ProjectileShape);
+   UNPACKDATA_ASSET(ProjectileShape);
 
    faceViewer = stream->readFlag();
    if(stream->readFlag())
@@ -500,7 +500,7 @@ void ProjectileData::unpackData(BitStream* stream)
    if (stream->readFlag())
       decalId = stream->readRangedU32(DataBlockObjectIdFirst, DataBlockObjectIdLast);
 
-   UNPACKDATA_SOUNDASSET(ProjectileSound);
+   UNPACKDATA_ASSET(ProjectileSound);
 
    if (stream->readFlag())
       lightDescId = stream->readRangedU32(DataBlockObjectIdFirst, DataBlockObjectIdLast);
diff --git a/Engine/source/T3D/projectile.h b/Engine/source/T3D/projectile.h
index e633e3fd4..9aa0690d0 100644
--- a/Engine/source/T3D/projectile.h
+++ b/Engine/source/T3D/projectile.h
@@ -72,7 +72,7 @@ protected:
 
 public:
    DECLARE_SHAPEASSET(ProjectileData, ProjectileShape, onShapeChanged);
-   DECLARE_SHAPEASSET_SETGET(ProjectileData, ProjectileShape);
+   DECLARE_ASSET_SETGET(ProjectileData, ProjectileShape);
 
    /// Set to true if it is a billboard and want it to always face the viewer, false otherwise
    bool faceViewer;
@@ -117,7 +117,7 @@ public:
    S32 decalId;                        // (impact) Decal ID
 
    DECLARE_SOUNDASSET(ProjectileData, ProjectileSound);
-   DECLARE_SOUNDASSET_SETGET(ProjectileData, ProjectileSound);
+   DECLARE_ASSET_SETGET(ProjectileData, ProjectileSound);
    
    LightDescription *lightDesc;
    S32 lightDescId;   
diff --git a/Engine/source/T3D/proximityMine.cpp b/Engine/source/T3D/proximityMine.cpp
index 12eb60a1a..683021255 100644
--- a/Engine/source/T3D/proximityMine.cpp
+++ b/Engine/source/T3D/proximityMine.cpp
@@ -82,8 +82,8 @@ ProximityMineData::ProximityMineData()
    triggerSequence( -1 ),
    explosionOffset( 0.05f )
 {
-   INIT_SOUNDASSET(ArmSound);
-   INIT_SOUNDASSET(TriggerSound);
+   INIT_ASSET(ArmSound);
+   INIT_ASSET(TriggerSound);
 }
 
 void ProximityMineData::initPersistFields()
@@ -156,14 +156,14 @@ void ProximityMineData::packData( BitStream* stream )
    Parent::packData( stream );
 
    stream->write( armingDelay );
-   PACKDATA_SOUNDASSET(ArmSound);
+   PACKDATA_ASSET(ArmSound);
 
    stream->write( autoTriggerDelay );
    stream->writeFlag( triggerOnOwner );
    stream->write( triggerRadius );
    stream->write( triggerSpeed );
    stream->write( triggerDelay );
-   PACKDATA_SOUNDASSET(TriggerSound);
+   PACKDATA_ASSET(TriggerSound);
 }
 
 void ProximityMineData::unpackData( BitStream* stream )
@@ -171,14 +171,14 @@ void ProximityMineData::unpackData( BitStream* stream )
    Parent::unpackData(stream);
 
    stream->read( &armingDelay );
-   UNPACKDATA_SOUNDASSET(ArmSound);
+   UNPACKDATA_ASSET(ArmSound);
 
    stream->read( &autoTriggerDelay );
    triggerOnOwner = stream->readFlag();
    stream->read( &triggerRadius );
    stream->read( &triggerSpeed );
    stream->read( &triggerDelay );
-   UNPACKDATA_SOUNDASSET(TriggerSound);
+   UNPACKDATA_ASSET(TriggerSound);
 }
 
 //----------------------------------------------------------------------------
diff --git a/Engine/source/T3D/proximityMine.h b/Engine/source/T3D/proximityMine.h
index 4736c0e16..2c748317c 100644
--- a/Engine/source/T3D/proximityMine.h
+++ b/Engine/source/T3D/proximityMine.h
@@ -46,7 +46,7 @@ public:
    F32               armingDelay;
    S32               armingSequence;
    DECLARE_SOUNDASSET(ProximityMineData, ArmSound);
-   DECLARE_SOUNDASSET_SETGET(ProximityMineData, ArmSound);
+   DECLARE_ASSET_SETGET(ProximityMineData, ArmSound);
 
    F32               autoTriggerDelay;
    bool              triggerOnOwner;
@@ -55,7 +55,7 @@ public:
    F32               triggerDelay;
    S32               triggerSequence;
    DECLARE_SOUNDASSET(ProximityMineData, TriggerSound);
-   DECLARE_SOUNDASSET_SETGET(ProximityMineData, TriggerSound);
+   DECLARE_ASSET_SETGET(ProximityMineData, TriggerSound);
 
    F32               explosionOffset;
 
diff --git a/Engine/source/T3D/rigidShape.cpp b/Engine/source/T3D/rigidShape.cpp
index 475854bbb..01b830db0 100644
--- a/Engine/source/T3D/rigidShape.cpp
+++ b/Engine/source/T3D/rigidShape.cpp
@@ -238,7 +238,7 @@ RigidShapeData::RigidShapeData()
    density = 4;
 
    for (S32 i = 0; i < Body::MaxSounds; i++)
-      INIT_SOUNDASSET_ARRAY(BodySounds, i);
+      INIT_ASSET_ARRAY(BodySounds, i);
 
    dustEmitter = NULL;
    dustID = 0;
@@ -257,7 +257,7 @@ RigidShapeData::RigidShapeData()
    enablePhysicsRep = true;
 
    for (S32 i = 0; i < Sounds::MaxSounds; i++)
-      INIT_SOUNDASSET_ARRAY(WaterSounds, i);
+      INIT_ASSET_ARRAY(WaterSounds, i);
 
    dragForce            = 0;
    vertFactor           = 0.25;
@@ -371,7 +371,7 @@ void RigidShapeData::packData(BitStream* stream)
    stream->write(body.friction);
    for (U32 i = 0; i < Body::MaxSounds; ++i)
    {
-      PACKDATA_SOUNDASSET_ARRAY(BodySounds, i);
+      PACKDATA_ASSET_ARRAY(BodySounds, i);
    }
 
    stream->write(minImpactSpeed);
@@ -403,7 +403,7 @@ void RigidShapeData::packData(BitStream* stream)
    // write the water sound profiles
    for (U32 i = 0; i < Sounds::MaxSounds; ++i)
    {
-      PACKDATA_SOUNDASSET_ARRAY(WaterSounds, i);
+      PACKDATA_ASSET_ARRAY(WaterSounds, i);
    }
 
    if (stream->writeFlag( dustEmitter ))
@@ -434,7 +434,7 @@ void RigidShapeData::unpackData(BitStream* stream)
 
    for (U32 i = 0; i < Body::Sounds::MaxSounds; i++)
    {
-      UNPACKDATA_SOUNDASSET_ARRAY(BodySounds, i);
+      UNPACKDATA_ASSET_ARRAY(BodySounds, i);
    }
 
    stream->read(&minImpactSpeed);
@@ -466,7 +466,7 @@ void RigidShapeData::unpackData(BitStream* stream)
    // write the water sound profiles
    for (U32 i = 0; i < Sounds::MaxSounds; ++i)
    {
-      UNPACKDATA_SOUNDASSET_ARRAY(WaterSounds, i);
+      UNPACKDATA_ASSET_ARRAY(WaterSounds, i);
    }
 
    if( stream->readFlag() )
diff --git a/Engine/source/T3D/rigidShape.h b/Engine/source/T3D/rigidShape.h
index 49e8c1fd6..ef3ead6e5 100644
--- a/Engine/source/T3D/rigidShape.h
+++ b/Engine/source/T3D/rigidShape.h
@@ -64,7 +64,7 @@ class RigidShapeData : public ShapeBaseData
    } body;
 
    DECLARE_SOUNDASSET_ARRAY(RigidShapeData, BodySounds, Body::Sounds::MaxSounds)
-   DECLARE_SOUNDASSET_ARRAY_SETGET(RigidShapeData, BodySounds);
+   DECLARE_ASSET_ARRAY_SETGET(RigidShapeData, BodySounds);
 
    SFXProfile* getBodySoundProfile(U32 id)
    {
@@ -92,7 +92,7 @@ class RigidShapeData : public ShapeBaseData
       MaxSounds
    };
    DECLARE_SOUNDASSET_ARRAY(RigidShapeData, WaterSounds, Sounds::MaxSounds)
-   DECLARE_SOUNDASSET_ARRAY_SETGET(RigidShapeData, WaterSounds);
+   DECLARE_ASSET_ARRAY_SETGET(RigidShapeData, WaterSounds);
 
    SFXProfile* getWaterSoundProfile(U32 id)
    {
diff --git a/Engine/source/T3D/sfx/sfxEmitter.cpp b/Engine/source/T3D/sfx/sfxEmitter.cpp
index 655e0071a..8ac0de6ad 100644
--- a/Engine/source/T3D/sfx/sfxEmitter.cpp
+++ b/Engine/source/T3D/sfx/sfxEmitter.cpp
@@ -109,7 +109,7 @@ SFXEmitter::SFXEmitter()
    mLocalProfile.mFilename = StringTable->EmptyString();
    mLocalProfile._registerSignals();
 
-   INIT_SOUNDASSET(Sound);
+   INIT_ASSET(Sound);
 
    mObjBox.minExtents.set( -1.f, -1.f, -1.f );
    mObjBox.maxExtents.set( 1.f, 1.f, 1.f );
@@ -290,7 +290,7 @@ U32 SFXEmitter::packUpdate( NetConnection *con, U32 mask, BitStream *stream )
       stream->writeAffineTransform( mObjToWorld );
 
    // track
-   PACK_SOUNDASSET(con, Sound);
+   PACK_ASSET(con, Sound);
    //if (stream->writeFlag(mDirty.test(Track)))
    //   sfxWrite( stream, mTrack );
 
@@ -401,7 +401,7 @@ void SFXEmitter::unpackUpdate( NetConnection *conn, BitStream *stream )
    }
 
    // track
-   UNPACK_SOUNDASSET(conn, Sound);
+   UNPACK_ASSET(conn, Sound);
    /*if (_readDirtyFlag(stream, Track))
    {
       String errorStr;
diff --git a/Engine/source/T3D/sfx/sfxEmitter.h b/Engine/source/T3D/sfx/sfxEmitter.h
index aeecd13bf..cdb93a8bf 100644
--- a/Engine/source/T3D/sfx/sfxEmitter.h
+++ b/Engine/source/T3D/sfx/sfxEmitter.h
@@ -105,7 +105,7 @@ class SFXEmitter : public SceneObject
       BitSet32 mDirty;
 
       DECLARE_SOUNDASSET(SFXEmitter, Sound);
-      DECLARE_SOUNDASSET_NET_SETGET(SFXEmitter, Sound, DirtyUpdateMask);
+      DECLARE_ASSET_NET_SETGET(SFXEmitter, Sound, DirtyUpdateMask);
 
       /// The sound source for the emitter.
       SFXSource *mSource;
diff --git a/Engine/source/T3D/shapeBase.cpp b/Engine/source/T3D/shapeBase.cpp
index c1a814f07..4730ee6b7 100644
--- a/Engine/source/T3D/shapeBase.cpp
+++ b/Engine/source/T3D/shapeBase.cpp
@@ -197,8 +197,8 @@ ShapeBaseData::ShapeBaseData()
    renderWhenDestroyed( true ),
    inheritEnergyFromMount( false )
 {
-   INIT_SHAPEASSET(Shape);
-   INIT_SHAPEASSET(DebrisShape);
+   INIT_ASSET(Shape);
+   INIT_ASSET(DebrisShape);
 
    dMemset( mountPointNode, -1, sizeof( S32 ) * SceneObject::NumMountPoints );
    remap_txr_tags = NULL;
@@ -214,13 +214,13 @@ ShapeBaseData::ShapeBaseData(const ShapeBaseData& other, bool temp_clone) : Game
    shadowProjectionDistance = other.shadowProjectionDistance;
    shadowSphereAdjust = other.shadowSphereAdjust;
    cloakTexName = other.cloakTexName;
-   CLONE_SHAPEASSET(Shape);
+   CLONE_ASSET(Shape);
    cubeDescName = other.cubeDescName;
    cubeDescId = other.cubeDescId;
    reflectorDesc = other.reflectorDesc;
    debris = other.debris;
    debrisID = other.debrisID; // -- for pack/unpack of debris ptr
-   CLONE_SHAPEASSET(DebrisShape);
+   CLONE_ASSET(DebrisShape);
    explosion = other.explosion;
    explosionID = other.explosionID; // -- for pack/unpack of explosion ptr
    underwaterExplosion = other.underwaterExplosion;
@@ -757,8 +757,8 @@ void ShapeBaseData::packData(BitStream* stream)
    stream->write(shadowProjectionDistance);
    stream->write(shadowSphereAdjust);
 
-   PACKDATA_SHAPEASSET(Shape);
-   PACKDATA_SHAPEASSET(DebrisShape);
+   PACKDATA_ASSET(Shape);
+   PACKDATA_ASSET(DebrisShape);
 
    stream->writeString(cloakTexName);
    if(stream->writeFlag(mass != gShapeBaseDataProto.mass))
@@ -835,8 +835,8 @@ void ShapeBaseData::unpackData(BitStream* stream)
    stream->read(&shadowProjectionDistance);
    stream->read(&shadowSphereAdjust);
 
-   UNPACKDATA_SHAPEASSET(Shape);
-   UNPACKDATA_SHAPEASSET(DebrisShape);
+   UNPACKDATA_ASSET(Shape);
+   UNPACKDATA_ASSET(DebrisShape);
 
    cloakTexName = stream->readSTString();
    if(stream->readFlag())
diff --git a/Engine/source/T3D/shapeBase.h b/Engine/source/T3D/shapeBase.h
index a2696819e..1670a8230 100644
--- a/Engine/source/T3D/shapeBase.h
+++ b/Engine/source/T3D/shapeBase.h
@@ -324,7 +324,7 @@ struct ShapeBaseImageData: public GameBaseData {
    bool                    stateIgnoreLoadedForReady  [MaxStates];
 
    DECLARE_SOUNDASSET_ARRAY(ShapeBaseImageData, stateSound, MaxStates);
-   DECLARE_SOUNDASSET_ARRAY_SETGET(ShapeBaseImageData, stateSound);
+   DECLARE_ASSET_ARRAY_SETGET(ShapeBaseImageData, stateSound);
 
    //SFXTrack*               stateSound                 [MaxStates];
    const char*             stateScript                [MaxStates];
@@ -379,10 +379,10 @@ struct ShapeBaseImageData: public GameBaseData {
                                     ///< when the script prefix has changed.
 
    DECLARE_SHAPEASSET_ARRAY(ShapeBaseImageData, Shape, MaxShapes);  ///< Name of shape to render.
-   DECLARE_SHAPEASSET_ARRAY_SETGET(ShapeBaseImageData, Shape);
+   DECLARE_ASSET_ARRAY_SETGET(ShapeBaseImageData, Shape);
 
    //DECLARE_SHAPEASSET(ShapeBaseImageData, ShapeFP);  ///< Name of shape to render in first person (optional).
-   //DECLARE_SHAPEASSET_SETGET(ShapeBaseImageData, ShapeFP);
+   //DECLARE_ASSET_SETGET(ShapeBaseImageData, ShapeFP);
 
    StringTableEntry  imageAnimPrefix;     ///< Passed along to the mounting shape to modify
                                           ///  animation sequences played in 3rd person. [optional]
@@ -546,7 +546,7 @@ public:
    F32 shadowSphereAdjust;
 
    DECLARE_SHAPEASSET(ShapeBaseData, Shape, onShapeChanged);
-   DECLARE_SHAPEASSET_SETGET(ShapeBaseData, Shape);
+   DECLARE_ASSET_SETGET(ShapeBaseData, Shape);
 
    StringTableEntry  cloakTexName;
 
@@ -562,7 +562,7 @@ public:
    S32               debrisID;
 
    DECLARE_SHAPEASSET(ShapeBaseData, DebrisShape, onDebrisChanged);
-   DECLARE_SHAPEASSET_SETGET(ShapeBaseData, DebrisShape);
+   DECLARE_ASSET_SETGET(ShapeBaseData, DebrisShape);
 
    ExplosionData*    explosion;
    S32               explosionID;
diff --git a/Engine/source/T3D/shapeImage.cpp b/Engine/source/T3D/shapeImage.cpp
index ab43a0ba3..1563f3be5 100644
--- a/Engine/source/T3D/shapeImage.cpp
+++ b/Engine/source/T3D/shapeImage.cpp
@@ -257,7 +257,7 @@ ShapeBaseImageData::ShapeBaseImageData()
       stateShapeSequence[i] = 0;
       stateScaleShapeSequence[i] = false;
 
-      INIT_SOUNDASSET_ARRAY(stateSound, i);
+      INIT_ASSET_ARRAY(stateSound, i);
       stateScript[i] = 0;
       stateEmitter[i] = 0;
       stateEmitterTime[i] = 0;
@@ -295,7 +295,7 @@ ShapeBaseImageData::ShapeBaseImageData()
       hasFlash[i] = false;
       shapeIsValid[i] = false;
 
-      INIT_SHAPEASSET_ARRAY(Shape, i);
+      INIT_ASSET_ARRAY(Shape, i);
    }
 
    shakeCamera = false;
@@ -983,7 +983,7 @@ void ShapeBaseImageData::packData(BitStream* stream)
 
    for (U32 j = 0; j < MaxShapes; ++j)
    {
-      PACKDATA_SHAPEASSET_ARRAY(Shape, j);        // shape 0 for normal use, shape 1 for first person use (optional)
+      PACKDATA_ASSET_ARRAY(Shape, j);        // shape 0 for normal use, shape 1 for first person use (optional)
    }
 
    stream->writeString(imageAnimPrefix);
@@ -1147,7 +1147,7 @@ void ShapeBaseImageData::packData(BitStream* stream)
             }
          }
 
-         PACKDATA_SOUNDASSET_ARRAY(stateSound, i);
+         PACKDATA_ASSET_ARRAY(stateSound, i);
       }
    stream->write(maxConcurrentSounds);
    stream->writeFlag(useRemainderDT);
@@ -1167,7 +1167,7 @@ void ShapeBaseImageData::unpackData(BitStream* stream)
 
    for (U32 j = 0; j < MaxShapes; ++j)
    {
-      UNPACKDATA_SHAPEASSET_ARRAY(Shape, j);        // shape 0 for normal use, shape 1 for first person use (optional)
+      UNPACKDATA_ASSET_ARRAY(Shape, j);        // shape 0 for normal use, shape 1 for first person use (optional)
    }
 
    imageAnimPrefix = stream->readSTString();
@@ -1352,7 +1352,7 @@ void ShapeBaseImageData::unpackData(BitStream* stream)
          else
             s.emitter = 0;
             
-         UNPACKDATA_SOUNDASSET_ARRAY(stateSound, i);
+         UNPACKDATA_ASSET_ARRAY(stateSound, i);
       }
    }
    
diff --git a/Engine/source/T3D/tsStatic.cpp b/Engine/source/T3D/tsStatic.cpp
index 9028653b8..169e6d806 100644
--- a/Engine/source/T3D/tsStatic.cpp
+++ b/Engine/source/T3D/tsStatic.cpp
@@ -149,7 +149,7 @@ TSStatic::TSStatic()
    mAnimOffset = 0.0f;
    mAnimSpeed = 1.0f;
 
-   INIT_SHAPEASSET(Shape);
+   INIT_ASSET(Shape);
 }
 
 TSStatic::~TSStatic()
@@ -958,7 +958,7 @@ U32 TSStatic::packUpdate(NetConnection* con, U32 mask, BitStream* stream)
 
    if (stream->writeFlag(mask & AdvancedStaticOptionsMask))
    {
-      PACK_SHAPEASSET(con, Shape);
+      PACK_ASSET(con, Shape);
 
       stream->write((U32)mDecalType);
 
@@ -1073,7 +1073,7 @@ void TSStatic::unpackUpdate(NetConnection* con, BitStream* stream)
 
    if (stream->readFlag()) // AdvancedStaticOptionsMask
    {
-      UNPACK_SHAPEASSET(con, Shape);
+      UNPACK_ASSET(con, Shape);
 
       stream->read((U32*)&mDecalType);
 
diff --git a/Engine/source/T3D/tsStatic.h b/Engine/source/T3D/tsStatic.h
index 1c82671cb..03c74c651 100644
--- a/Engine/source/T3D/tsStatic.h
+++ b/Engine/source/T3D/tsStatic.h
@@ -192,7 +192,7 @@ protected:
    Convex* mConvexList;
 
    DECLARE_SHAPEASSET(TSStatic, Shape, onShapeChanged);
-   DECLARE_SHAPEASSET_NET_SETGET(TSStatic, Shape, AdvancedStaticOptionsMask);
+   DECLARE_ASSET_NET_SETGET(TSStatic, Shape, AdvancedStaticOptionsMask);
 
    U32               mShapeHash;
    Vector<S32> mCollisionDetails;
diff --git a/Engine/source/T3D/vehicles/flyingVehicle.cpp b/Engine/source/T3D/vehicles/flyingVehicle.cpp
index dcc1f8dd2..8426da2c3 100644
--- a/Engine/source/T3D/vehicles/flyingVehicle.cpp
+++ b/Engine/source/T3D/vehicles/flyingVehicle.cpp
@@ -116,7 +116,7 @@ FlyingVehicleData::FlyingVehicleData()
       jetEmitter[j] = 0;
 
    for (S32 i = 0; i < MaxSounds; i++)
-      INIT_SOUNDASSET_ARRAY(FlyingSounds, i);
+      INIT_ASSET_ARRAY(FlyingSounds, i);
 
    vertThrustMultiple = 1.0;
 }
@@ -241,7 +241,7 @@ void FlyingVehicleData::packData(BitStream* stream)
 
    for (S32 i = 0; i < MaxSounds; i++)
    {
-      PACKDATA_SOUNDASSET_ARRAY(FlyingSounds, i);
+      PACKDATA_ASSET_ARRAY(FlyingSounds, i);
    }
 
    for (S32 j = 0; j < MaxJetEmitters; j++)
@@ -276,7 +276,7 @@ void FlyingVehicleData::unpackData(BitStream* stream)
 
    for (S32 i = 0; i < MaxSounds; i++)
    {
-      UNPACKDATA_SOUNDASSET_ARRAY(FlyingSounds, i);
+      UNPACKDATA_ASSET_ARRAY(FlyingSounds, i);
    }
 
    for (S32 j = 0; j < MaxJetEmitters; j++) {
diff --git a/Engine/source/T3D/vehicles/flyingVehicle.h b/Engine/source/T3D/vehicles/flyingVehicle.h
index 573d10ccc..f0a45edd3 100644
--- a/Engine/source/T3D/vehicles/flyingVehicle.h
+++ b/Engine/source/T3D/vehicles/flyingVehicle.h
@@ -46,7 +46,7 @@ struct FlyingVehicleData: public VehicleData {
       MaxSounds,
    };
    DECLARE_SOUNDASSET_ARRAY(FlyingVehicleData, FlyingSounds, Sounds::MaxSounds);
-   DECLARE_SOUNDASSET_ARRAY_SETGET(FlyingVehicleData, FlyingSounds);
+   DECLARE_ASSET_ARRAY_SETGET(FlyingVehicleData, FlyingSounds);
    SFXProfile* getFlyingSoundProfile(U32 id)
    {
       if (mFlyingSoundsAsset[id] != NULL)
diff --git a/Engine/source/T3D/vehicles/hoverVehicle.cpp b/Engine/source/T3D/vehicles/hoverVehicle.cpp
index 7deb81fe0..dbaee9993 100644
--- a/Engine/source/T3D/vehicles/hoverVehicle.cpp
+++ b/Engine/source/T3D/vehicles/hoverVehicle.cpp
@@ -162,7 +162,7 @@ HoverVehicleData::HoverVehicleData()
       jetEmitter[j] = 0;
 
    for (S32 i = 0; i < MaxSounds; i++)
-      INIT_SOUNDASSET_ARRAY(HoverSounds, i);
+      INIT_ASSET_ARRAY(HoverSounds, i);
 }
 
 HoverVehicleData::~HoverVehicleData()
@@ -370,7 +370,7 @@ void HoverVehicleData::packData(BitStream* stream)
 
    for (S32 i = 0; i < MaxSounds; i++)
    {
-      PACKDATA_SOUNDASSET_ARRAY(HoverSounds, i);
+      PACKDATA_ASSET_ARRAY(HoverSounds, i);
    }
 
    for (S32 j = 0; j < MaxJetEmitters; j++)
@@ -419,7 +419,7 @@ void HoverVehicleData::unpackData(BitStream* stream)
 
    for (S32 i = 0; i < MaxSounds; i++)
    {
-      UNPACKDATA_SOUNDASSET_ARRAY(HoverSounds, i);
+      UNPACKDATA_ASSET_ARRAY(HoverSounds, i);
    }
 
    for (S32 j = 0; j < MaxJetEmitters; j++) {
diff --git a/Engine/source/T3D/vehicles/hoverVehicle.h b/Engine/source/T3D/vehicles/hoverVehicle.h
index da22da280..8e7cce79b 100644
--- a/Engine/source/T3D/vehicles/hoverVehicle.h
+++ b/Engine/source/T3D/vehicles/hoverVehicle.h
@@ -47,7 +47,7 @@ class HoverVehicleData : public VehicleData
       MaxSounds
    };
    DECLARE_SOUNDASSET_ARRAY(HoverVehicleData, HoverSounds, Sounds::MaxSounds);
-   DECLARE_SOUNDASSET_ARRAY_SETGET(HoverVehicleData, HoverSounds);
+   DECLARE_ASSET_ARRAY_SETGET(HoverVehicleData, HoverSounds);
    SFXProfile* getHoverSoundProfile(U32 id)
    {
       if (mHoverSoundsAsset[id] != NULL)
diff --git a/Engine/source/T3D/vehicles/vehicle.cpp b/Engine/source/T3D/vehicles/vehicle.cpp
index 8079fc163..2fad95b6d 100644
--- a/Engine/source/T3D/vehicles/vehicle.cpp
+++ b/Engine/source/T3D/vehicles/vehicle.cpp
@@ -189,7 +189,7 @@ VehicleData::VehicleData()
 
    for (S32 i = 0; i < Body::MaxSounds; i++)
    {
-      INIT_SOUNDASSET_ARRAY(VehicleBodySounds, i);
+      INIT_ASSET_ARRAY(VehicleBodySounds, i);
    }
 
    dustEmitter = NULL;
@@ -214,7 +214,7 @@ VehicleData::VehicleData()
    hardSplashSoundVel = 3.0;
 
    for (S32 i = 0; i < Sounds::MaxSounds; i++)
-      INIT_SOUNDASSET_ARRAY(VehicleWaterSounds, i);
+      INIT_ASSET_ARRAY(VehicleWaterSounds, i);
 
    collDamageThresholdVel = 20;
    collDamageMultiplier = 0.05f;
@@ -302,7 +302,7 @@ void VehicleData::packData(BitStream* stream)
    stream->write(body.friction);
    for (i = 0; i < Body::MaxSounds; i++)
    {
-      PACKDATA_SOUNDASSET_ARRAY(VehicleBodySounds, i);
+      PACKDATA_ASSET_ARRAY(VehicleBodySounds, i);
    }
 
    stream->write(minImpactSpeed);
@@ -346,7 +346,7 @@ void VehicleData::packData(BitStream* stream)
    // write the water sound profiles
    for (i = 0; i < MaxSounds; i++)
    {
-      PACKDATA_SOUNDASSET_ARRAY(VehicleWaterSounds, i);
+      PACKDATA_ASSET_ARRAY(VehicleWaterSounds, i);
    }
 
    if (stream->writeFlag( dustEmitter ))
@@ -398,7 +398,7 @@ void VehicleData::unpackData(BitStream* stream)
    S32 i;
    for (i = 0; i < Body::MaxSounds; i++)
    {
-      UNPACKDATA_SOUNDASSET_ARRAY(VehicleBodySounds, i);
+      UNPACKDATA_ASSET_ARRAY(VehicleBodySounds, i);
    }
 
    stream->read(&minImpactSpeed);
@@ -442,7 +442,7 @@ void VehicleData::unpackData(BitStream* stream)
    // write the water sound profiles
    for (i = 0; i < Sounds::MaxSounds; i++)
    {
-      UNPACKDATA_SOUNDASSET_ARRAY(VehicleWaterSounds, i);
+      UNPACKDATA_ASSET_ARRAY(VehicleWaterSounds, i);
    }
 
    if( stream->readFlag() )
diff --git a/Engine/source/T3D/vehicles/vehicle.h b/Engine/source/T3D/vehicles/vehicle.h
index 3e9636027..c9a50b831 100644
--- a/Engine/source/T3D/vehicles/vehicle.h
+++ b/Engine/source/T3D/vehicles/vehicle.h
@@ -50,7 +50,7 @@ struct VehicleData : public RigidShapeData
    } body;
 
    DECLARE_SOUNDASSET_ARRAY(VehicleData, VehicleBodySounds, Body::Sounds::MaxSounds)
-   DECLARE_SOUNDASSET_ARRAY_SETGET(VehicleData, VehicleBodySounds);
+   DECLARE_ASSET_ARRAY_SETGET(VehicleData, VehicleBodySounds);
 
    SFXProfile* getVehicleBodySoundProfile(U32 id)
    {
@@ -82,7 +82,7 @@ struct VehicleData : public RigidShapeData
    };
 
   DECLARE_SOUNDASSET_ARRAY(VehicleData, VehicleWaterSounds, Sounds::MaxSounds)
-  DECLARE_SOUNDASSET_ARRAY_SETGET(VehicleData, VehicleWaterSounds);
+  DECLARE_ASSET_ARRAY_SETGET(VehicleData, VehicleWaterSounds);
 
   SFXProfile* getVehicleWaterSoundProfile(U32 id)
   {
diff --git a/Engine/source/T3D/vehicles/wheeledVehicle.cpp b/Engine/source/T3D/vehicles/wheeledVehicle.cpp
index 4e9e7201e..258222847 100644
--- a/Engine/source/T3D/vehicles/wheeledVehicle.cpp
+++ b/Engine/source/T3D/vehicles/wheeledVehicle.cpp
@@ -75,7 +75,7 @@ ConsoleDocClass( WheeledVehicleTire,
 
 WheeledVehicleTire::WheeledVehicleTire()
 {
-   INIT_SHAPEASSET(Shape);
+   INIT_ASSET(Shape);
 
    staticFriction = 1;
    kineticFriction = 0.5f;
@@ -177,7 +177,7 @@ void WheeledVehicleTire::packData(BitStream* stream)
 {
    Parent::packData(stream);
 
-   PACKDATA_SHAPEASSET(Shape);
+   PACKDATA_ASSET(Shape);
 
    stream->write(mass);
    stream->write(staticFriction);
@@ -196,7 +196,7 @@ void WheeledVehicleTire::unpackData(BitStream* stream)
 {
    Parent::unpackData(stream);
 
-   UNPACKDATA_SHAPEASSET(Shape);
+   UNPACKDATA_ASSET(Shape);
 
    stream->read(&mass);
    stream->read(&staticFriction);
@@ -312,7 +312,7 @@ WheeledVehicleData::WheeledVehicleData()
    wheelCount = 0;
    dMemset(&wheel, 0, sizeof(wheel));
    for (S32 i = 0; i < MaxSounds; i++)
-      INIT_SOUNDASSET_ARRAY(WheeledVehicleSounds, i);
+      INIT_ASSET_ARRAY(WheeledVehicleSounds, i);
 }
 
 
@@ -483,7 +483,7 @@ void WheeledVehicleData::packData(BitStream* stream)
 
    for (S32 i = 0; i < MaxSounds; i++)
    {
-      PACKDATA_SOUNDASSET_ARRAY(WheeledVehicleSounds, i);
+      PACKDATA_ASSET_ARRAY(WheeledVehicleSounds, i);
    }
 
    stream->write(maxWheelSpeed);
@@ -502,7 +502,7 @@ void WheeledVehicleData::unpackData(BitStream* stream)
 
    for (S32 i = 0; i < MaxSounds; i++)
    {
-      UNPACKDATA_SOUNDASSET_ARRAY(WheeledVehicleSounds, i);
+      UNPACKDATA_ASSET_ARRAY(WheeledVehicleSounds, i);
    }
 
    stream->read(&maxWheelSpeed);
diff --git a/Engine/source/T3D/vehicles/wheeledVehicle.h b/Engine/source/T3D/vehicles/wheeledVehicle.h
index a2ab03b11..c8759e52d 100644
--- a/Engine/source/T3D/vehicles/wheeledVehicle.h
+++ b/Engine/source/T3D/vehicles/wheeledVehicle.h
@@ -44,7 +44,7 @@ struct WheeledVehicleTire: public SimDataBlock
    typedef SimDataBlock Parent;
 
    DECLARE_SHAPEASSET(WheeledVehicleTire, Shape, onShapeChanged);
-   DECLARE_SHAPEASSET_SETGET(WheeledVehicleTire, Shape);
+   DECLARE_ASSET_SETGET(WheeledVehicleTire, Shape);
 
    // Physical properties
    F32 mass;                  // Mass of the whole wheel
@@ -120,7 +120,7 @@ struct WheeledVehicleData: public VehicleData
    };
 
    DECLARE_SOUNDASSET_ARRAY(WheeledVehicleData, WheeledVehicleSounds, Sounds::MaxSounds);
-   DECLARE_SOUNDASSET_ARRAY_SETGET(WheeledVehicleData, WheeledVehicleSounds);
+   DECLARE_ASSET_ARRAY_SETGET(WheeledVehicleData, WheeledVehicleSounds);
 
    SFXProfile* getWheeledVehicleSound(U32 id)
    {
diff --git a/Engine/source/afx/afxMagicMissile.cpp b/Engine/source/afx/afxMagicMissile.cpp
index 93d4ef237..a67447248 100644
--- a/Engine/source/afx/afxMagicMissile.cpp
+++ b/Engine/source/afx/afxMagicMissile.cpp
@@ -141,7 +141,7 @@ U32 Projectile::smProjectileWarpTicks = 5;
 //
 afxMagicMissileData::afxMagicMissileData()
 {
-   INIT_SHAPEASSET(ProjectileShape);
+   INIT_ASSET(ProjectileShape);
 
    sound = NULL;
 
@@ -246,7 +246,7 @@ afxMagicMissileData::afxMagicMissileData()
 
 afxMagicMissileData::afxMagicMissileData(const afxMagicMissileData& other, bool temp_clone) : GameBaseData(other, temp_clone)
 {
-   CLONE_SHAPEASSET(ProjectileShape);
+   CLONE_ASSET(ProjectileShape);
   projectileShape = other.projectileShape; // -- TSShape loads using projectileShapeName
   sound = other.sound;
   splash = other.splash;
@@ -599,7 +599,7 @@ void afxMagicMissileData::packData(BitStream* stream)
 {
    Parent::packData(stream);
 
-   PACKDATA_SHAPEASSET(ProjectileShape);
+   PACKDATA_ASSET(ProjectileShape);
 
    /* From stock Projectile code...
    stream->writeFlag(faceViewer);
@@ -710,7 +710,7 @@ void afxMagicMissileData::unpackData(BitStream* stream)
 {
    Parent::unpackData(stream);
 
-   UNPACKDATA_SHAPEASSET(ProjectileShape);
+   UNPACKDATA_ASSET(ProjectileShape);
    /* From stock Projectile code...
    faceViewer = stream->readFlag();
    */
diff --git a/Engine/source/afx/afxMagicMissile.h b/Engine/source/afx/afxMagicMissile.h
index 1206354fd..626dfd91d 100644
--- a/Engine/source/afx/afxMagicMissile.h
+++ b/Engine/source/afx/afxMagicMissile.h
@@ -72,7 +72,7 @@ public:
    // variables set in datablock definition:
    // Shape related
    DECLARE_SHAPEASSET(afxMagicMissileData, ProjectileShape, onShapeChanged);
-   DECLARE_SHAPEASSET_SETGET(afxMagicMissileData, ProjectileShape);
+   DECLARE_ASSET_SETGET(afxMagicMissileData, ProjectileShape);
   //StringTableEntry      projectileShapeName;
 
   //bool                  hasLight;
diff --git a/Engine/source/afx/ce/afxBillboard.cpp b/Engine/source/afx/ce/afxBillboard.cpp
index 553c2942f..c0092c389 100644
--- a/Engine/source/afx/ce/afxBillboard.cpp
+++ b/Engine/source/afx/ce/afxBillboard.cpp
@@ -51,7 +51,7 @@ ConsoleDocClass( afxBillboardData,
 afxBillboardData::afxBillboardData()
 {
   color.set(1.0f, 1.0f, 1.0f, 1.0f);
-  INIT_IMAGEASSET(Texture);
+  INIT_ASSET(Texture);
   dimensions.set(1.0f, 1.0f);
   texCoords[0].set(0.0f, 0.0f);
   texCoords[1].set(0.0f, 1.0f);
@@ -66,7 +66,7 @@ afxBillboardData::afxBillboardData(const afxBillboardData& other, bool temp_clon
   : GameBaseData(other, temp_clone)
 {
   color = other.color;
-  CLONE_IMAGEASSET(Texture);
+  CLONE_ASSET(Texture);
   dimensions = other.dimensions;
   texCoords[0] = other.texCoords[0];
   texCoords[1] = other.texCoords[1];
@@ -123,7 +123,7 @@ void afxBillboardData::packData(BitStream* stream)
 	Parent::packData(stream);
 
   stream->write(color);
-  PACKDATA_IMAGEASSET(Texture);
+  PACKDATA_ASSET(Texture);
 
   mathWrite(*stream, dimensions);
   mathWrite(*stream, texCoords[0]);
@@ -140,7 +140,7 @@ void afxBillboardData::unpackData(BitStream* stream)
   Parent::unpackData(stream);
 
   stream->read(&color);
-  UNPACKDATA_IMAGEASSET(Texture);
+  UNPACKDATA_ASSET(Texture);
   mathRead(*stream, &dimensions);
   mathRead(*stream, &texCoords[0]);
   mathRead(*stream, &texCoords[1]);
diff --git a/Engine/source/afx/ce/afxBillboard.h b/Engine/source/afx/ce/afxBillboard.h
index 1183500a2..8c6532539 100644
--- a/Engine/source/afx/ce/afxBillboard.h
+++ b/Engine/source/afx/ce/afxBillboard.h
@@ -48,7 +48,7 @@ public:
 
 public:
    DECLARE_IMAGEASSET(afxBillboardData, Texture, onChangeTexture, GFXStaticTextureSRGBProfile);
-   DECLARE_IMAGEASSET_SETGET(afxBillboardData, Texture);
+   DECLARE_ASSET_SETGET(afxBillboardData, Texture);
 
 
   LinearColorF            color;
diff --git a/Engine/source/afx/ce/afxModel.cpp b/Engine/source/afx/ce/afxModel.cpp
index ba452156b..7c6eb019c 100644
--- a/Engine/source/afx/ce/afxModel.cpp
+++ b/Engine/source/afx/ce/afxModel.cpp
@@ -54,7 +54,7 @@ ConsoleDocClass( afxModelData,
 
 afxModelData::afxModelData()
 {
-   INIT_SHAPEASSET(Shape);
+   INIT_ASSET(Shape);
   sequence = ST_NULLSTRING;
   seq_rate = 1.0f;
   seq_offset = 0.0f;
@@ -84,7 +84,7 @@ afxModelData::afxModelData()
 
 afxModelData::afxModelData(const afxModelData& other, bool temp_clone) : GameBaseData(other, temp_clone)
 {
-   CLONE_SHAPEASSET(Shape);
+   CLONE_ASSET(Shape);
   sequence = other.sequence;
   seq_rate = other.seq_rate;
   seq_offset = other.seq_offset;
@@ -253,7 +253,7 @@ void afxModelData::packData(BitStream* stream)
 {
   Parent::packData(stream);
 
-  PACKDATA_SHAPEASSET(Shape);
+  PACKDATA_ASSET(Shape);
   stream->writeString(sequence);
   stream->write(seq_rate);  
   stream->write(seq_offset);
@@ -285,7 +285,7 @@ void afxModelData::unpackData(BitStream* stream)
 {
   Parent::unpackData(stream);
 
-  UNPACKDATA_SHAPEASSET(Shape);
+  UNPACKDATA_ASSET(Shape);
   sequence = stream->readSTString();
   stream->read(&seq_rate);
   stream->read(&seq_offset);
diff --git a/Engine/source/afx/ce/afxModel.h b/Engine/source/afx/ce/afxModel.h
index 0d13692ef..80c6803f7 100644
--- a/Engine/source/afx/ce/afxModel.h
+++ b/Engine/source/afx/ce/afxModel.h
@@ -44,7 +44,7 @@ struct afxModelData : public GameBaseData
   typedef GameBaseData Parent;
 
   DECLARE_SHAPEASSET(afxModelData, Shape, onShapeChanged);
-  DECLARE_SHAPEASSET_SETGET(afxModelData, Shape);
+  DECLARE_ASSET_SETGET(afxModelData, Shape);
 
   StringTableEntry      sequence;
 
diff --git a/Engine/source/afx/ce/afxZodiac.cpp b/Engine/source/afx/ce/afxZodiac.cpp
index eca56af5a..dc4cb5b01 100644
--- a/Engine/source/afx/ce/afxZodiac.cpp
+++ b/Engine/source/afx/ce/afxZodiac.cpp
@@ -78,7 +78,7 @@ bool afxZodiacData::sPreferDestinationGradients = false;
 
 afxZodiacData::afxZodiacData()
 {
-   INIT_IMAGEASSET(Texture);
+   INIT_ASSET(Texture);
 
   radius_xy = 1;
   vert_range.set(0.0f, 0.0f);
@@ -120,7 +120,7 @@ afxZodiacData::afxZodiacData()
 
 afxZodiacData::afxZodiacData(const afxZodiacData& other, bool temp_clone) : GameBaseData(other, temp_clone)
 {
-   CLONE_IMAGEASSET(Texture);
+   CLONE_ASSET(Texture);
 
   radius_xy = other.radius_xy;
   vert_range = other.vert_range;
@@ -269,7 +269,7 @@ void afxZodiacData::packData(BitStream* stream)
 
   merge_zflags();
 
-  PACKDATA_IMAGEASSET(Texture);
+  PACKDATA_ASSET(Texture);
   stream->write(radius_xy);
   stream->write(vert_range.x);
   stream->write(vert_range.y);
@@ -294,7 +294,7 @@ void afxZodiacData::unpackData(BitStream* stream)
 {
   Parent::unpackData(stream);
 
-  UNPACKDATA_IMAGEASSET(Texture);
+  UNPACKDATA_ASSET(Texture);
   stream->read(&radius_xy);
   stream->read(&vert_range.x);
   stream->read(&vert_range.y);
diff --git a/Engine/source/afx/ce/afxZodiac.h b/Engine/source/afx/ce/afxZodiac.h
index d03fcf593..917ee5490 100644
--- a/Engine/source/afx/ce/afxZodiac.h
+++ b/Engine/source/afx/ce/afxZodiac.h
@@ -60,7 +60,7 @@ public:
 
 public:
    DECLARE_IMAGEASSET(afxZodiacData, Texture, onImageChanged, AFX_GFXZodiacTextureProfile);
-   DECLARE_IMAGEASSET_SETGET(afxZodiacData, Texture);
+   DECLARE_ASSET_SETGET(afxZodiacData, Texture);
 
   F32               radius_xy;
   Point2F           vert_range;
diff --git a/Engine/source/afx/ce/afxZodiacPlane.cpp b/Engine/source/afx/ce/afxZodiacPlane.cpp
index aaea763e7..c9045bc95 100644
--- a/Engine/source/afx/ce/afxZodiacPlane.cpp
+++ b/Engine/source/afx/ce/afxZodiacPlane.cpp
@@ -51,7 +51,7 @@ ConsoleDocClass( afxZodiacPlaneData,
 
 afxZodiacPlaneData::afxZodiacPlaneData()
 {
-   INIT_IMAGEASSET(Texture);
+   INIT_ASSET(Texture);
 
   radius_xy = 1;
   start_ang = 0;
@@ -71,7 +71,7 @@ afxZodiacPlaneData::afxZodiacPlaneData()
 afxZodiacPlaneData::afxZodiacPlaneData(const afxZodiacPlaneData& other, bool temp_clone)
   : GameBaseData(other, temp_clone)
 {
-   CLONE_IMAGEASSET(Texture);
+   CLONE_ASSET(Texture);
 
   radius_xy = other.radius_xy;
   start_ang = other.start_ang;
@@ -165,7 +165,7 @@ void afxZodiacPlaneData::packData(BitStream* stream)
 
   merge_zflags();
 
-  PACKDATA_IMAGEASSET(Texture);
+  PACKDATA_ASSET(Texture);
 
   stream->write(radius_xy);
   stream->write(start_ang);
@@ -184,7 +184,7 @@ void afxZodiacPlaneData::unpackData(BitStream* stream)
 {
   Parent::unpackData(stream);
 
-  UNPACKDATA_IMAGEASSET(Texture);
+  UNPACKDATA_ASSET(Texture);
 
   stream->read(&radius_xy);
   stream->read(&start_ang);
diff --git a/Engine/source/afx/ce/afxZodiacPlane.h b/Engine/source/afx/ce/afxZodiacPlane.h
index e99702b4c..7b2d7aec2 100644
--- a/Engine/source/afx/ce/afxZodiacPlane.h
+++ b/Engine/source/afx/ce/afxZodiacPlane.h
@@ -60,7 +60,7 @@ public:
 
 public:
    DECLARE_IMAGEASSET(afxZodiacPlaneData, Texture, onImageChanged, AFX_GFXZodiacTextureProfile);
-   DECLARE_IMAGEASSET_SETGET(afxZodiacPlaneData, Texture);
+   DECLARE_ASSET_SETGET(afxZodiacPlaneData, Texture);
 
   F32               radius_xy;
   F32               start_ang;
diff --git a/Engine/source/assets/assetBase.h b/Engine/source/assets/assetBase.h
index 7d1918857..d4efc6a8a 100644
--- a/Engine/source/assets/assetBase.h
+++ b/Engine/source/assets/assetBase.h
@@ -173,6 +173,5 @@ private:
 #define assetText(x,suff) #x#suff
 #define macroText(x) #x
 #define assetDoc(x,suff) "@brief "#x" "#suff
-
 #endif // _ASSET_BASE_H_
 
diff --git a/Engine/source/environment/VolumetricFog.cpp b/Engine/source/environment/VolumetricFog.cpp
index b602d87ac..c9eaff9df 100644
--- a/Engine/source/environment/VolumetricFog.cpp
+++ b/Engine/source/environment/VolumetricFog.cpp
@@ -137,8 +137,8 @@ VolumetricFog::VolumetricFog()
    mSpeed1.set(0.5f, 0.0f);
    mSpeed2.set(0.1f, 0.1f);
 
-   INIT_SHAPEASSET(Shape);
-   INIT_IMAGEASSET(Texture);
+   INIT_ASSET(Shape);
+   INIT_ASSET(Texture);
 }
 
 VolumetricFog::~VolumetricFog()
@@ -543,7 +543,7 @@ U32 VolumetricFog::packUpdate(NetConnection *con, U32 mask, BitStream *stream)
       stream->write(mFogDensity);
    if (stream->writeFlag(mask & FogModulationMask))
    {
-      PACK_IMAGEASSET(con, Texture);
+      PACK_ASSET(con, Texture);
       mTexTiles = mFabs(mTexTiles);
       stream->write(mTexTiles);
       stream->write(mStrength);
@@ -567,7 +567,7 @@ U32 VolumetricFog::packUpdate(NetConnection *con, U32 mask, BitStream *stream)
    }
    if (stream->writeFlag(mask & FogShapeMask))
    {
-      PACK_SHAPEASSET(con, Shape);
+      PACK_ASSET(con, Shape);
       mathWrite(*stream, getTransform());
       mathWrite(*stream, getScale());
 
@@ -613,7 +613,7 @@ void VolumetricFog::unpackUpdate(NetConnection *con, BitStream *stream)
    }
    if (stream->readFlag())// Fog Modulation
    {
-      UNPACK_IMAGEASSET(con, Texture);
+      UNPACK_ASSET(con, Texture);
       stream->read(&mTexTiles);
       mTexTiles = mFabs(mTexTiles);
       stream->read(&mStrength);
@@ -667,7 +667,7 @@ void VolumetricFog::unpackUpdate(NetConnection *con, BitStream *stream)
    }
    if (stream->readFlag())//Fog shape
    {
-      UNPACK_SHAPEASSET(con, Shape);
+      UNPACK_ASSET(con, Shape);
 
       mathRead(*stream, &mat);
       mathRead(*stream, &scale);
diff --git a/Engine/source/environment/VolumetricFog.h b/Engine/source/environment/VolumetricFog.h
index 1a4abaca3..83df0c184 100644
--- a/Engine/source/environment/VolumetricFog.h
+++ b/Engine/source/environment/VolumetricFog.h
@@ -85,7 +85,7 @@ class VolumetricFog : public SceneObject
    };
 
    DECLARE_SHAPEASSET(VolumetricFog, Shape, onShapeChanged);
-   DECLARE_SHAPEASSET_NET_SETGET(VolumetricFog, Shape, FogShapeMask);
+   DECLARE_ASSET_NET_SETGET(VolumetricFog, Shape, FogShapeMask);
    
    protected:
       // Rendertargets;
@@ -163,7 +163,7 @@ class VolumetricFog : public SceneObject
    
       // Fog Modulation data
       DECLARE_IMAGEASSET(VolumetricFog, Texture, onImageChanged, GFXStaticTextureSRGBProfile);
-      DECLARE_IMAGEASSET_NET_SETGET(VolumetricFog, Texture, FogModulationMask);
+      DECLARE_ASSET_NET_SETGET(VolumetricFog, Texture, FogModulationMask);
 
       bool mIsTextured;
       F32 mTexTiles;
@@ -257,4 +257,4 @@ class VolumetricFog : public SceneObject
       DECLARE_CALLBACK(void, onEnterFog, (SimObjectId obj));
       DECLARE_CALLBACK(void, onLeaveFog, (SimObjectId obj));
 };
-#endif
\ No newline at end of file
+#endif
diff --git a/Engine/source/environment/basicClouds.cpp b/Engine/source/environment/basicClouds.cpp
index defd8fc41..462bf573f 100644
--- a/Engine/source/environment/basicClouds.cpp
+++ b/Engine/source/environment/basicClouds.cpp
@@ -215,7 +215,7 @@ U32 BasicClouds::packUpdate( NetConnection *conn, U32 mask, BitStream *stream )
    {
       stream->writeFlag( mLayerEnabled[i] );
 
-      PACK_IMAGEASSET_ARRAY(conn, Texture, i);
+      PACK_ASSET_ARRAY(conn, Texture, i);
 
       stream->write( mTexScale[i] );
       mathWrite( *stream, mTexDirection[i] );
@@ -236,7 +236,7 @@ void BasicClouds::unpackUpdate( NetConnection *conn, BitStream *stream )
    {
       mLayerEnabled[i] = stream->readFlag();
 
-      UNPACK_IMAGEASSET_ARRAY(conn, Texture, i);
+      UNPACK_ASSET_ARRAY(conn, Texture, i);
       
       stream->read( &mTexScale[i] );      
       mathRead( *stream, &mTexDirection[i] );
diff --git a/Engine/source/environment/cloudLayer.cpp b/Engine/source/environment/cloudLayer.cpp
index 01e55dc6e..dce8f84a2 100644
--- a/Engine/source/environment/cloudLayer.cpp
+++ b/Engine/source/environment/cloudLayer.cpp
@@ -113,7 +113,7 @@ CloudLayer::CloudLayer()
 
    mHeight = 4.0f;
 
-   INIT_IMAGEASSET(Texture);
+   INIT_ASSET(Texture);
 }
 
 IMPLEMENT_CO_NETOBJECT_V1( CloudLayer );
@@ -242,7 +242,7 @@ U32 CloudLayer::packUpdate( NetConnection *conn, U32 mask, BitStream *stream )
 {
    U32 retMask = Parent::packUpdate( conn, mask, stream );
 
-   PACK_IMAGEASSET(conn, Texture);
+   PACK_ASSET(conn, Texture);
    
    for ( U32 i = 0; i < TEX_COUNT; i++ )
    {
@@ -264,7 +264,7 @@ void CloudLayer::unpackUpdate( NetConnection *conn, BitStream *stream )
 {
    Parent::unpackUpdate( conn, stream );
 
-   UNPACK_IMAGEASSET(conn, Texture);
+   UNPACK_ASSET(conn, Texture);
 
    if(mTextureAssetId != StringTable->EmptyString())
       mTextureAsset = mTextureAssetId;
diff --git a/Engine/source/environment/cloudLayer.h b/Engine/source/environment/cloudLayer.h
index 82e152dfb..8f7ffc667 100644
--- a/Engine/source/environment/cloudLayer.h
+++ b/Engine/source/environment/cloudLayer.h
@@ -97,7 +97,7 @@ protected:
    static U32 smTriangleCount;
 
    DECLARE_IMAGEASSET(CloudLayer, Texture, onImageChanged, GFXStaticTextureSRGBProfile);
-   DECLARE_IMAGEASSET_NET_SETGET(CloudLayer, Texture, CloudLayerMask);
+   DECLARE_ASSET_NET_SETGET(CloudLayer, Texture, CloudLayerMask);
 
    GFXShaderRef mShader;
 
@@ -136,4 +136,4 @@ protected:
 };
 
 
-#endif // _CLOUDLAYER_H_
\ No newline at end of file
+#endif // _CLOUDLAYER_H_
diff --git a/Engine/source/environment/decalRoad.cpp b/Engine/source/environment/decalRoad.cpp
index e1d9a27ee..bd5e1e619 100644
--- a/Engine/source/environment/decalRoad.cpp
+++ b/Engine/source/environment/decalRoad.cpp
@@ -287,7 +287,7 @@ DecalRoad::DecalRoad()
    mTypeMask |= StaticObjectType | StaticShapeObjectType;
    mNetFlags.set(Ghostable);
 
-   INIT_MATERIALASSET(Material);
+   INIT_ASSET(Material);
 
    mMaterialInst = nullptr;
 }
@@ -491,7 +491,7 @@ U32 DecalRoad::packUpdate(NetConnection * con, U32 mask, BitStream * stream)
    if ( stream->writeFlag( mask & DecalRoadMask ) )
    {
       // Write Texture Name.
-      PACK_MATERIALASSET(con, Material);
+      PACK_ASSET(con, Material);
 
       stream->write( mBreakAngle );      
 
@@ -580,7 +580,7 @@ void DecalRoad::unpackUpdate( NetConnection *con, BitStream *stream )
    // DecalRoadMask
    if ( stream->readFlag() )
    {
-      UNPACK_MATERIALASSET(con, Material);
+      UNPACK_ASSET(con, Material);
 
       if (isProperlyAdded())
          _initMaterial();
diff --git a/Engine/source/environment/decalRoad.h b/Engine/source/environment/decalRoad.h
index 7934d7889..180b92d08 100644
--- a/Engine/source/environment/decalRoad.h
+++ b/Engine/source/environment/decalRoad.h
@@ -243,7 +243,7 @@ protected:
    BaseMatInstance* mMaterialInst;
 
    DECLARE_MATERIALASSET(DecalRoad, Material);
-   DECLARE_MATERIALASSET_NET_SETGET(DecalRoad, Material, DecalRoadMask);
+   DECLARE_ASSET_NET_SETGET(DecalRoad, Material, DecalRoadMask);
 
    U32 mRenderPriority;
 
diff --git a/Engine/source/environment/editors/guiMeshRoadEditorCtrl.cpp b/Engine/source/environment/editors/guiMeshRoadEditorCtrl.cpp
index b0812f738..7d139c2ea 100644
--- a/Engine/source/environment/editors/guiMeshRoadEditorCtrl.cpp
+++ b/Engine/source/environment/editors/guiMeshRoadEditorCtrl.cpp
@@ -97,9 +97,9 @@ GuiMeshRoadEditorCtrl::GuiMeshRoadEditorCtrl()
     mHoverNodeColor( 255,255,255,255 ),
 	 mHasCopied( false )
 {
-   INIT_MATERIALASSET(TopMaterial);
-   INIT_MATERIALASSET(BottomMaterial);
-   INIT_MATERIALASSET(SideMaterial);
+   INIT_ASSET(TopMaterial);
+   INIT_ASSET(BottomMaterial);
+   INIT_ASSET(SideMaterial);
 
    mTopMaterialAssetId = Con::getVariable("$MeshRoadEditor::defaultTopMaterialAsset");
    mBottomMaterialAssetId = Con::getVariable("$MeshRoadEditor::defaultBottomMaterialAsset");
diff --git a/Engine/source/environment/editors/guiMeshRoadEditorCtrl.h b/Engine/source/environment/editors/guiMeshRoadEditorCtrl.h
index 95cffeab0..497dd14f8 100644
--- a/Engine/source/environment/editors/guiMeshRoadEditorCtrl.h
+++ b/Engine/source/environment/editors/guiMeshRoadEditorCtrl.h
@@ -160,13 +160,13 @@ class GuiMeshRoadEditorCtrl : public EditTSCtrl
 	public:
 
       DECLARE_MATERIALASSET(GuiMeshRoadEditorCtrl, TopMaterial);
-      DECLARE_MATERIALASSET_SETGET(GuiMeshRoadEditorCtrl, TopMaterial);
+      DECLARE_ASSET_SETGET(GuiMeshRoadEditorCtrl, TopMaterial);
 
       DECLARE_MATERIALASSET(GuiMeshRoadEditorCtrl, BottomMaterial);
-      DECLARE_MATERIALASSET_SETGET(GuiMeshRoadEditorCtrl, BottomMaterial);
+      DECLARE_ASSET_SETGET(GuiMeshRoadEditorCtrl, BottomMaterial);
 
       DECLARE_MATERIALASSET(GuiMeshRoadEditorCtrl, SideMaterial);
-      DECLARE_MATERIALASSET_SETGET(GuiMeshRoadEditorCtrl, SideMaterial);
+      DECLARE_ASSET_SETGET(GuiMeshRoadEditorCtrl, SideMaterial);
 };
 
 class GuiMeshRoadEditorUndoAction : public UndoAction
diff --git a/Engine/source/environment/editors/guiRoadEditorCtrl.h b/Engine/source/environment/editors/guiRoadEditorCtrl.h
index 5e076aa68..9d2c5d014 100644
--- a/Engine/source/environment/editors/guiRoadEditorCtrl.h
+++ b/Engine/source/environment/editors/guiRoadEditorCtrl.h
@@ -104,7 +104,7 @@ class GuiRoadEditorCtrl : public EditTSCtrl
 	public:
 
       DECLARE_MATERIALASSET(GuiRoadEditorCtrl, Material);
-      DECLARE_MATERIALASSET_SETGET(GuiRoadEditorCtrl, Material);
+      DECLARE_ASSET_SETGET(GuiRoadEditorCtrl, Material);
 
    protected:
 
diff --git a/Engine/source/environment/meshRoad.cpp b/Engine/source/environment/meshRoad.cpp
index f27d2d84a..d3f143d88 100644
--- a/Engine/source/environment/meshRoad.cpp
+++ b/Engine/source/environment/meshRoad.cpp
@@ -920,9 +920,9 @@ MeshRoad::MeshRoad()
       mTriangleCount[i] = 0;
    }
 
-   INIT_MATERIALASSET(TopMaterial);
-   INIT_MATERIALASSET(BottomMaterial);
-   INIT_MATERIALASSET(SideMaterial);
+   INIT_ASSET(TopMaterial);
+   INIT_ASSET(BottomMaterial);
+   INIT_ASSET(SideMaterial);
 
    mSideProfile.mRoad = this;
 }
@@ -1416,9 +1416,9 @@ U32 MeshRoad::packUpdate(NetConnection * con, U32 mask, BitStream * stream)
       stream->writeAffineTransform( mObjToWorld );
 
       // Write Materials
-      PACK_MATERIALASSET(con, TopMaterial);
-      PACK_MATERIALASSET(con, BottomMaterial);
-      PACK_MATERIALASSET(con, SideMaterial);
+      PACK_ASSET(con, TopMaterial);
+      PACK_ASSET(con, BottomMaterial);
+      PACK_ASSET(con, SideMaterial);
 
       stream->write( mTextureLength );      
       stream->write( mBreakAngle );
@@ -1515,9 +1515,9 @@ void MeshRoad::unpackUpdate(NetConnection * con, BitStream * stream)
       stream->readAffineTransform(&ObjectMatrix);
       Parent::setTransform(ObjectMatrix);
 
-      UNPACK_MATERIALASSET(con, TopMaterial);
-      UNPACK_MATERIALASSET(con, BottomMaterial);
-      UNPACK_MATERIALASSET(con, SideMaterial);
+      UNPACK_ASSET(con, TopMaterial);
+      UNPACK_ASSET(con, BottomMaterial);
+      UNPACK_ASSET(con, SideMaterial);
 
       if ( isProperlyAdded() )
          _initMaterial(); 
diff --git a/Engine/source/environment/meshRoad.h b/Engine/source/environment/meshRoad.h
index 718a015cd..9fe7505b9 100644
--- a/Engine/source/environment/meshRoad.h
+++ b/Engine/source/environment/meshRoad.h
@@ -622,13 +622,13 @@ protected:
    GFXPrimitiveBufferHandle mPB[SurfaceCount];      
 
    DECLARE_MATERIALASSET(MeshRoad, TopMaterial);
-   DECLARE_MATERIALASSET_NET_SETGET(MeshRoad, TopMaterial, MeshRoadMask);
+   DECLARE_ASSET_NET_SETGET(MeshRoad, TopMaterial, MeshRoadMask);
 
    DECLARE_MATERIALASSET(MeshRoad, BottomMaterial);
-   DECLARE_MATERIALASSET_NET_SETGET(MeshRoad, BottomMaterial, MeshRoadMask);
+   DECLARE_ASSET_NET_SETGET(MeshRoad, BottomMaterial, MeshRoadMask);
 
    DECLARE_MATERIALASSET(MeshRoad, SideMaterial);
-   DECLARE_MATERIALASSET_NET_SETGET(MeshRoad, SideMaterial, MeshRoadMask);
+   DECLARE_ASSET_NET_SETGET(MeshRoad, SideMaterial, MeshRoadMask);
 
    //String mMaterialName[SurfaceCount];   
    SimObjectPtr<Material> mMaterial[SurfaceCount];
diff --git a/Engine/source/environment/scatterSky.cpp b/Engine/source/environment/scatterSky.cpp
index cd447e56c..36ab28ecf 100644
--- a/Engine/source/environment/scatterSky.cpp
+++ b/Engine/source/environment/scatterSky.cpp
@@ -168,7 +168,7 @@ ScatterSky::ScatterSky()
    mNightCubemapName = StringTable->EmptyString();
    mSunSize = 1.0f;
 
-   INIT_MATERIALASSET(MoonMat);
+   INIT_ASSET(MoonMat);
 
    mMoonMatInst = NULL;
 
@@ -503,7 +503,7 @@ U32 ScatterSky::packUpdate(NetConnection *con, U32 mask, BitStream *stream)
 
       stream->writeFlag( mMoonEnabled );
 
-      PACK_MATERIALASSET(con, MoonMat);
+      PACK_ASSET(con, MoonMat);
       
       stream->write( mMoonScale );
       stream->write( mMoonTint );
@@ -617,7 +617,7 @@ void ScatterSky::unpackUpdate(NetConnection *con, BitStream *stream)
 
       mMoonEnabled = stream->readFlag();
 
-      UNPACK_MATERIALASSET(con, MoonMat);
+      UNPACK_ASSET(con, MoonMat);
 
       stream->read( &mMoonScale );
       stream->read( &mMoonTint );
diff --git a/Engine/source/environment/scatterSky.h b/Engine/source/environment/scatterSky.h
index 2657aa6b8..0633e9e23 100644
--- a/Engine/source/environment/scatterSky.h
+++ b/Engine/source/environment/scatterSky.h
@@ -212,7 +212,7 @@ protected:
    bool mMoonEnabled;
 
    DECLARE_MATERIALASSET(ScatterSky, MoonMat);
-   DECLARE_MATERIALASSET_NET_SETGET(ScatterSky, MoonMat, UpdateMask);
+   DECLARE_ASSET_NET_SETGET(ScatterSky, MoonMat, UpdateMask);
 
    BaseMatInstance *mMoonMatInst;
    F32 mMoonScale;
diff --git a/Engine/source/environment/skyBox.cpp b/Engine/source/environment/skyBox.cpp
index 057de94aa..468ecb8dd 100644
--- a/Engine/source/environment/skyBox.cpp
+++ b/Engine/source/environment/skyBox.cpp
@@ -56,7 +56,7 @@ SkyBox::SkyBox()
    mTypeMask |= EnvironmentObjectType | StaticObjectType;
    mNetFlags.set(Ghostable | ScopeAlways);
 
-   INIT_MATERIALASSET(Material);
+   INIT_ASSET(Material);
    mMatInstance = NULL;
 
    mIsVBDirty = false;
@@ -139,7 +139,7 @@ U32 SkyBox::packUpdate( NetConnection *conn, U32 mask, BitStream *stream )
 {
    U32 retMask = Parent::packUpdate( conn, mask, stream );
 
-   PACK_MATERIALASSET(conn, Material);
+   PACK_ASSET(conn, Material);
 
    stream->writeFlag( mDrawBottom );
    stream->write( mFogBandHeight );
@@ -152,7 +152,7 @@ void SkyBox::unpackUpdate( NetConnection *conn, BitStream *stream )
    Parent::unpackUpdate( conn, stream );
 
    StringTableEntry oldMatName = getMaterial();
-   UNPACK_MATERIALASSET(conn, Material);
+   UNPACK_ASSET(conn, Material);
    if (oldMatName != getMaterial())
    {
       _updateMaterial();
diff --git a/Engine/source/environment/skyBox.h b/Engine/source/environment/skyBox.h
index 38c2b0ac7..7f2ebe494 100644
--- a/Engine/source/environment/skyBox.h
+++ b/Engine/source/environment/skyBox.h
@@ -102,7 +102,7 @@ protected:
 
    // Material
    DECLARE_MATERIALASSET(SkyBox, Material);
-   DECLARE_MATERIALASSET_NET_SETGET(SkyBox, Material, -1);
+   DECLARE_ASSET_NET_SETGET(SkyBox, Material, -1);
 
    BaseMatInstance *mMatInstance;
    SkyMatParams mMatParamHandle;
diff --git a/Engine/source/environment/sun.cpp b/Engine/source/environment/sun.cpp
index 42062a78b..47cc91070 100644
--- a/Engine/source/environment/sun.cpp
+++ b/Engine/source/environment/sun.cpp
@@ -90,7 +90,7 @@ Sun::Sun()
    mCoronaUseLightColor = true;
    mCoronaMatInst = NULL;
 
-   INIT_MATERIALASSET(CoronaMaterial);
+   INIT_ASSET(CoronaMaterial);
 
    mMatrixSet = reinterpret_cast<MatrixSet *>(dMalloc_aligned(sizeof(MatrixSet), 16));
    constructInPlace(mMatrixSet);
@@ -240,7 +240,7 @@ U32 Sun::packUpdate(NetConnection *conn, U32 mask, BitStream *stream )
 
       stream->writeFlag( mCoronaEnabled );
 
-      PACK_MATERIALASSET(conn, CoronaMaterial);
+      PACK_ASSET(conn, CoronaMaterial);
 
       stream->write( mCoronaScale );
       stream->write( mCoronaTint );
@@ -286,7 +286,7 @@ void Sun::unpackUpdate( NetConnection *conn, BitStream *stream )
 
       mCoronaEnabled = stream->readFlag();
 
-      UNPACK_MATERIALASSET(conn, CoronaMaterial);
+      UNPACK_ASSET(conn, CoronaMaterial);
 
       stream->read( &mCoronaScale );
       stream->read( &mCoronaTint );
diff --git a/Engine/source/environment/sun.h b/Engine/source/environment/sun.h
index 9d11c0ed1..f9d1674f8 100644
--- a/Engine/source/environment/sun.h
+++ b/Engine/source/environment/sun.h
@@ -79,7 +79,7 @@ protected:
    bool mCoronaEnabled;
 
    DECLARE_MATERIALASSET(Sun, CoronaMaterial);
-   DECLARE_MATERIALASSET_NET_SETGET(Sun, CoronaMaterial, UpdateMask);
+   DECLARE_ASSET_NET_SETGET(Sun, CoronaMaterial, UpdateMask);
 
    BaseMatInstance *mCoronaMatInst;
    MatrixSet *mMatrixSet;   
diff --git a/Engine/source/environment/waterObject.cpp b/Engine/source/environment/waterObject.cpp
index dd5ea1a6f..7aba59163 100644
--- a/Engine/source/environment/waterObject.cpp
+++ b/Engine/source/environment/waterObject.cpp
@@ -260,9 +260,9 @@ WaterObject::WaterObject()
    mMatrixSet = reinterpret_cast<MatrixSet *>(dMalloc_aligned(sizeof(MatrixSet), 16));
    constructInPlace(mMatrixSet);
 
-   INIT_IMAGEASSET(RippleTex);
-   INIT_IMAGEASSET(FoamTex);
-   INIT_IMAGEASSET(DepthGradientTex);
+   INIT_ASSET(RippleTex);
+   INIT_ASSET(FoamTex);
+   INIT_ASSET(DepthGradientTex);
 
    mCubemapName = StringTable->EmptyString();
 }
@@ -546,9 +546,9 @@ U32 WaterObject::packUpdate( NetConnection * conn, U32 mask, BitStream *stream )
 
    if ( stream->writeFlag( mask & TextureMask ) )
    {
-      PACK_IMAGEASSET(conn, RippleTex);
-      PACK_IMAGEASSET(conn, DepthGradientTex);
-      PACK_IMAGEASSET(conn, FoamTex);
+      PACK_ASSET(conn, RippleTex);
+      PACK_ASSET(conn, DepthGradientTex);
+      PACK_ASSET(conn, FoamTex);
 
       stream->writeString( mCubemapName );      
    }
@@ -668,9 +668,9 @@ void WaterObject::unpackUpdate( NetConnection * conn, BitStream *stream )
    // TextureMask
    if ( stream->readFlag() )
    {
-      UNPACK_IMAGEASSET(conn, RippleTex);
-      UNPACK_IMAGEASSET(conn, DepthGradientTex);
-      UNPACK_IMAGEASSET(conn, FoamTex);
+      UNPACK_ASSET(conn, RippleTex);
+      UNPACK_ASSET(conn, DepthGradientTex);
+      UNPACK_ASSET(conn, FoamTex);
 
       mCubemapName = stream->readSTString();
 
diff --git a/Engine/source/environment/waterObject.h b/Engine/source/environment/waterObject.h
index 3c72ba21e..17d5d8428 100644
--- a/Engine/source/environment/waterObject.h
+++ b/Engine/source/environment/waterObject.h
@@ -273,11 +273,11 @@ protected:
 
    // Other textures
    DECLARE_IMAGEASSET(WaterObject, RippleTex, onRippleTexChanged, GFXStaticTextureProfile);
-   DECLARE_IMAGEASSET_NET_SETGET(WaterObject, RippleTex, TextureMask);
+   DECLARE_ASSET_NET_SETGET(WaterObject, RippleTex, TextureMask);
    DECLARE_IMAGEASSET(WaterObject, FoamTex, onFoamTexChanged, GFXStaticTextureSRGBProfile);
-   DECLARE_IMAGEASSET_NET_SETGET(WaterObject, FoamTex, TextureMask);
+   DECLARE_ASSET_NET_SETGET(WaterObject, FoamTex, TextureMask);
    DECLARE_IMAGEASSET(WaterObject, DepthGradientTex, onDepthGradientTexChanged, GFXStaticTextureSRGBProfile);
-   DECLARE_IMAGEASSET_NET_SETGET(WaterObject, DepthGradientTex, TextureMask);
+   DECLARE_ASSET_NET_SETGET(WaterObject, DepthGradientTex, TextureMask);
 
    StringTableEntry mCubemapName;
 
diff --git a/Engine/source/forest/forestItem.cpp b/Engine/source/forest/forestItem.cpp
index 11d514b34..26624abb9 100644
--- a/Engine/source/forest/forestItem.cpp
+++ b/Engine/source/forest/forestItem.cpp
@@ -53,7 +53,7 @@ ForestItemData::ForestItemData()
       mTightnessCoefficient( 0.4f ),
       mDampingCoefficient( 0.7f )      
 {
-   INIT_SHAPEASSET(Shape);
+   INIT_ASSET(Shape);
 }
 
 void ForestItemData::initPersistFields()
@@ -164,7 +164,7 @@ void ForestItemData::packData(BitStream* stream)
 
    stream->write( localName );
 
-   PACKDATA_SHAPEASSET(Shape);
+   PACKDATA_ASSET(Shape);
    
    stream->writeFlag( mCollidable );
 
@@ -192,7 +192,7 @@ void ForestItemData::unpackData(BitStream* stream)
 
    char readBuffer[1024];
 
-   UNPACKDATA_SHAPEASSET(Shape);
+   UNPACKDATA_ASSET(Shape);
    
    mCollidable = stream->readFlag();
 
diff --git a/Engine/source/forest/forestItem.h b/Engine/source/forest/forestItem.h
index 0c7eb0697..2ffb9f9ab 100644
--- a/Engine/source/forest/forestItem.h
+++ b/Engine/source/forest/forestItem.h
@@ -63,7 +63,7 @@ protected:
 public:
    
    DECLARE_SHAPEASSET(ForestItemData, Shape, onShapeChanged);
-   DECLARE_SHAPEASSET_SETGET(ForestItemData, Shape);
+   DECLARE_ASSET_SETGET(ForestItemData, Shape);
 
    /// This is the radius used during placement to ensure
    /// the element isn't crowded up against other trees.
diff --git a/Engine/source/gfx/sim/cubemapData.cpp b/Engine/source/gfx/sim/cubemapData.cpp
index a6833de5c..3be7cfbda 100644
--- a/Engine/source/gfx/sim/cubemapData.cpp
+++ b/Engine/source/gfx/sim/cubemapData.cpp
@@ -44,10 +44,10 @@ CubemapData::CubemapData()
 
    for (U32 i = 0; i < 6; i++)
    {
-      INIT_IMAGEASSET_ARRAY(CubeMapFace, i);
+      INIT_ASSET_ARRAY(CubeMapFace, i);
    }
 
-   INIT_IMAGEASSET(CubeMap);
+   INIT_ASSET(CubeMap);
 }
 
 CubemapData::~CubemapData()
diff --git a/Engine/source/gfx/sim/cubemapData.h b/Engine/source/gfx/sim/cubemapData.h
index 7ec2e0fb5..c33cf7021 100644
--- a/Engine/source/gfx/sim/cubemapData.h
+++ b/Engine/source/gfx/sim/cubemapData.h
@@ -74,7 +74,7 @@ public:
 
 protected:
    DECLARE_IMAGEASSET(CubemapData, CubeMap, onCubemapChanged, GFXStaticTextureSRGBProfile);
-   DECLARE_IMAGEASSET_SETGET(CubemapData, CubeMap);
+   DECLARE_ASSET_SETGET(CubemapData, CubeMap);
 
    DECLARE_IMAGEASSET_ARRAY(CubemapData, CubeMapFace, GFXStaticTextureSRGBProfile, 6);
    DECLARE_IMAGEASSET_ARRAY_SETGET(CubemapData, CubeMapFace);
diff --git a/Engine/source/gui/buttons/guiBitmapButtonCtrl.cpp b/Engine/source/gui/buttons/guiBitmapButtonCtrl.cpp
index 91088b2a4..23c451fab 100644
--- a/Engine/source/gui/buttons/guiBitmapButtonCtrl.cpp
+++ b/Engine/source/gui/buttons/guiBitmapButtonCtrl.cpp
@@ -129,7 +129,7 @@ GuiBitmapButtonCtrl::GuiBitmapButtonCtrl()
    setExtent( 140, 30 );
    mMasked = false;
 
-   INIT_IMAGEASSET(Bitmap);
+   INIT_ASSET(Bitmap);
 }
 
 //-----------------------------------------------------------------------------
@@ -668,4 +668,4 @@ bool GuiBitmapButtonCtrl::pointInControl(const Point2I& parentCoordPoint)
       return Parent::pointInControl(parentCoordPoint);
 }
 
-DEF_IMAGEASSET_BINDS(GuiBitmapButtonCtrl, Bitmap);
+DEF_ASSET_BINDS(GuiBitmapButtonCtrl, Bitmap);
diff --git a/Engine/source/gui/buttons/guiBitmapButtonCtrl.h b/Engine/source/gui/buttons/guiBitmapButtonCtrl.h
index 59e7825f1..1791c563a 100644
--- a/Engine/source/gui/buttons/guiBitmapButtonCtrl.h
+++ b/Engine/source/gui/buttons/guiBitmapButtonCtrl.h
@@ -119,7 +119,7 @@ class GuiBitmapButtonCtrl : public GuiButtonCtrl
       BitmapMode mBitmapMode;
 
       DECLARE_IMAGEASSET(GuiBitmapButtonCtrl, Bitmap, onBitmapChange, GFXDefaultGUIProfile);
-      DECLARE_IMAGEASSET_SETGET(GuiBitmapButtonCtrl, Bitmap);
+      DECLARE_ASSET_SETGET(GuiBitmapButtonCtrl, Bitmap);
       
       /// alpha masking
       bool mMasked;
diff --git a/Engine/source/gui/buttons/guiIconButtonCtrl.cpp b/Engine/source/gui/buttons/guiIconButtonCtrl.cpp
index c0fb939ff..093c79cb7 100644
--- a/Engine/source/gui/buttons/guiIconButtonCtrl.cpp
+++ b/Engine/source/gui/buttons/guiIconButtonCtrl.cpp
@@ -85,7 +85,7 @@ ConsoleDocClass( GuiIconButtonCtrl,
 
 GuiIconButtonCtrl::GuiIconButtonCtrl()
 {
-   INIT_IMAGEASSET(Bitmap);
+   INIT_ASSET(Bitmap);
    mTextLocation = TextLocLeft;
    mIconLocation = IconLocLeft;
    mTextMargin = 4;
@@ -412,4 +412,4 @@ void GuiIconButtonCtrl::renderBitmapArray(RectI &bounds, S32 state)
    }
 }
 
-DEF_IMAGEASSET_BINDS(GuiIconButtonCtrl, Bitmap);
+DEF_ASSET_BINDS(GuiIconButtonCtrl, Bitmap);
diff --git a/Engine/source/gui/buttons/guiIconButtonCtrl.h b/Engine/source/gui/buttons/guiIconButtonCtrl.h
index d2cf0b9bd..8196fef49 100644
--- a/Engine/source/gui/buttons/guiIconButtonCtrl.h
+++ b/Engine/source/gui/buttons/guiIconButtonCtrl.h
@@ -43,7 +43,7 @@ private:
 protected:
 
    DECLARE_IMAGEASSET(GuiIconButtonCtrl, Bitmap, onImageChanged, GFXTexturePersistentSRGBProfile);
-   DECLARE_IMAGEASSET_SETGET(GuiIconButtonCtrl, Bitmap);
+   DECLARE_ASSET_SETGET(GuiIconButtonCtrl, Bitmap);
 
    S32               mIconLocation;
    S32               mTextLocation;
diff --git a/Engine/source/gui/buttons/guiToolboxButtonCtrl.cpp b/Engine/source/gui/buttons/guiToolboxButtonCtrl.cpp
index 3f1b26f0c..f75a93d83 100644
--- a/Engine/source/gui/buttons/guiToolboxButtonCtrl.cpp
+++ b/Engine/source/gui/buttons/guiToolboxButtonCtrl.cpp
@@ -43,9 +43,9 @@ ConsoleDocClass( GuiToolboxButtonCtrl,
 //-------------------------------------
 GuiToolboxButtonCtrl::GuiToolboxButtonCtrl()
 {
-   INIT_IMAGEASSET(NormalBitmap);
-   INIT_IMAGEASSET(LoweredBitmap);
-   INIT_IMAGEASSET(HoverBitmap);
+   INIT_ASSET(NormalBitmap);
+   INIT_ASSET(LoweredBitmap);
+   INIT_ASSET(HoverBitmap);
 
    setMinExtent(Point2I(16,16));
    setExtent(48, 48);
@@ -193,6 +193,6 @@ void GuiToolboxButtonCtrl::renderButton(GFXTexHandle &texture, Point2I &offset,
    }
 }
 
-DEF_IMAGEASSET_BINDS(GuiToolboxButtonCtrl, NormalBitmap);
-DEF_IMAGEASSET_BINDS(GuiToolboxButtonCtrl, LoweredBitmap);
-DEF_IMAGEASSET_BINDS(GuiToolboxButtonCtrl, HoverBitmap);
+DEF_ASSET_BINDS(GuiToolboxButtonCtrl, NormalBitmap);
+DEF_ASSET_BINDS(GuiToolboxButtonCtrl, LoweredBitmap);
+DEF_ASSET_BINDS(GuiToolboxButtonCtrl, HoverBitmap);
diff --git a/Engine/source/gui/buttons/guiToolboxButtonCtrl.h b/Engine/source/gui/buttons/guiToolboxButtonCtrl.h
index ec2b56711..8741cdee9 100644
--- a/Engine/source/gui/buttons/guiToolboxButtonCtrl.h
+++ b/Engine/source/gui/buttons/guiToolboxButtonCtrl.h
@@ -40,11 +40,11 @@ private:
 protected:
 
    DECLARE_IMAGEASSET(GuiToolboxButtonCtrl, NormalBitmap, onNormalImageChanged, GFXTexturePersistentSRGBProfile);
-   DECLARE_IMAGEASSET_SETGET(GuiToolboxButtonCtrl, NormalBitmap);
+   DECLARE_ASSET_SETGET(GuiToolboxButtonCtrl, NormalBitmap);
    DECLARE_IMAGEASSET(GuiToolboxButtonCtrl, LoweredBitmap, onLoweredImageChanged, GFXTexturePersistentSRGBProfile);
-   DECLARE_IMAGEASSET_SETGET(GuiToolboxButtonCtrl, LoweredBitmap);
+   DECLARE_ASSET_SETGET(GuiToolboxButtonCtrl, LoweredBitmap);
    DECLARE_IMAGEASSET(GuiToolboxButtonCtrl, HoverBitmap, onHoverImageChanged, GFXTexturePersistentSRGBProfile);
-   DECLARE_IMAGEASSET_SETGET(GuiToolboxButtonCtrl, HoverBitmap);
+   DECLARE_ASSET_SETGET(GuiToolboxButtonCtrl, HoverBitmap);
 
    void renderButton(GFXTexHandle &texture, Point2I &offset, const RectI& updateRect);
    void renderStateRect( GFXTexHandle &texture, const RectI& rect );
diff --git a/Engine/source/gui/controls/guiBitmapCtrl.cpp b/Engine/source/gui/controls/guiBitmapCtrl.cpp
index 1b158d435..89e8ecbb3 100644
--- a/Engine/source/gui/controls/guiBitmapCtrl.cpp
+++ b/Engine/source/gui/controls/guiBitmapCtrl.cpp
@@ -60,7 +60,7 @@ GuiBitmapCtrl::GuiBitmapCtrl(void)
    mColor(ColorI::WHITE),
    mWrap( false )
 {
-   INIT_IMAGEASSET(Bitmap);
+   INIT_ASSET(Bitmap);
 }
 
 bool GuiBitmapCtrl::setBitmapName( void *object, const char *index, const char *data )
diff --git a/Engine/source/gui/controls/guiBitmapCtrl.h b/Engine/source/gui/controls/guiBitmapCtrl.h
index 05f4ca047..c5e2130dd 100644
--- a/Engine/source/gui/controls/guiBitmapCtrl.h
+++ b/Engine/source/gui/controls/guiBitmapCtrl.h
@@ -40,7 +40,7 @@ class GuiBitmapCtrl : public GuiControl
       /// Name of the bitmap file.  If this is 'texhandle' the bitmap is not loaded
       /// from a file but rather set explicitly on the control.
       DECLARE_IMAGEASSET(GuiBitmapCtrl, Bitmap, onImageChanged, GFXDefaultGUIProfile);
-      DECLARE_IMAGEASSET_SETGET(GuiBitmapCtrl, Bitmap);
+      DECLARE_ASSET_SETGET(GuiBitmapCtrl, Bitmap);
             
       Point2I mStartPoint;
       ColorI   mColor;
diff --git a/Engine/source/gui/controls/guiMaterialCtrl.cpp b/Engine/source/gui/controls/guiMaterialCtrl.cpp
index 34c0243a9..6d177767f 100644
--- a/Engine/source/gui/controls/guiMaterialCtrl.cpp
+++ b/Engine/source/gui/controls/guiMaterialCtrl.cpp
@@ -45,7 +45,7 @@ ConsoleDocClass( GuiMaterialCtrl,
 GuiMaterialCtrl::GuiMaterialCtrl()
    : mMaterialInst( NULL )
 {
-   INIT_MATERIALASSET(Material);
+   INIT_ASSET(Material);
 }
 
 void GuiMaterialCtrl::initPersistFields()
diff --git a/Engine/source/gui/controls/guiMaterialCtrl.h b/Engine/source/gui/controls/guiMaterialCtrl.h
index bafbdf0eb..ff0b44efa 100644
--- a/Engine/source/gui/controls/guiMaterialCtrl.h
+++ b/Engine/source/gui/controls/guiMaterialCtrl.h
@@ -41,7 +41,7 @@ private:
 protected:
 
    DECLARE_MATERIALASSET(GuiMaterialCtrl, Material);
-   DECLARE_MATERIALASSET_SETGET(GuiMaterialCtrl, Material);
+   DECLARE_ASSET_SETGET(GuiMaterialCtrl, Material);
 
    BaseMatInstance *mMaterialInst;
 
diff --git a/Engine/source/gui/controls/guiPopUpCtrl.cpp b/Engine/source/gui/controls/guiPopUpCtrl.cpp
index 0cd08dfb8..47abbc17c 100644
--- a/Engine/source/gui/controls/guiPopUpCtrl.cpp
+++ b/Engine/source/gui/controls/guiPopUpCtrl.cpp
@@ -278,8 +278,8 @@ GuiPopUpMenuCtrl::GuiPopUpMenuCtrl(void)
    mBackgroundCancel = false; //  Added
    mReverseTextList = false; //  Added - Don't reverse text list if displaying up
 
-   INIT_IMAGEASSET_ARRAY(Bitmap, 0);
-   INIT_IMAGEASSET_ARRAY(Bitmap, 1);
+   INIT_ASSET_ARRAY(Bitmap, 0);
+   INIT_ASSET_ARRAY(Bitmap, 1);
 
    mBitmapBounds.set(16, 16); //  Added
    mIdMax = -1;
diff --git a/Engine/source/gui/controls/guiPopUpCtrlEx.cpp b/Engine/source/gui/controls/guiPopUpCtrlEx.cpp
index 5cbd1e3bc..852424075 100644
--- a/Engine/source/gui/controls/guiPopUpCtrlEx.cpp
+++ b/Engine/source/gui/controls/guiPopUpCtrlEx.cpp
@@ -329,8 +329,8 @@ GuiPopUpMenuCtrlEx::GuiPopUpMenuCtrlEx(void)
    mBackgroundCancel = false; //  Added
    mReverseTextList = false; //  Added - Don't reverse text list if displaying up
 
-   INIT_IMAGEASSET_ARRAY(Bitmap, Normal);
-   INIT_IMAGEASSET_ARRAY(Bitmap, Depressed);
+   INIT_ASSET_ARRAY(Bitmap, Normal);
+   INIT_ASSET_ARRAY(Bitmap, Depressed);
 
    mBitmapBounds.set(16, 16); //  Added
    mHotTrackItems = false;
diff --git a/Engine/source/gui/core/guiControl.cpp b/Engine/source/gui/core/guiControl.cpp
index 2011aa68b..d312c7610 100644
--- a/Engine/source/gui/core/guiControl.cpp
+++ b/Engine/source/gui/core/guiControl.cpp
@@ -2898,7 +2898,7 @@ static ConsoleDocFragment _sGuiControlSetExtent2(
    "GuiControl", // The class to place the method in; use NULL for functions.
    "void setExtent( Point2I p );" ); // The definition string.
 
-DefineEngineMethod( GuiControl, setExtent, void, ( const char* extOrX, const char* y ), (""),
+DefineEngineMethod( GuiControl, setExtent, void, ( const char* extOrX, const char* y ), ("", nullAsType<const char*>()),
    "( Point2I p | int x, int y ) Set the width and height of the control.\n\n"
    "@hide" )
 {
diff --git a/Engine/source/gui/core/guiTypes.cpp b/Engine/source/gui/core/guiTypes.cpp
index 59fc8b854..d4575d21a 100644
--- a/Engine/source/gui/core/guiTypes.cpp
+++ b/Engine/source/gui/core/guiTypes.cpp
@@ -79,7 +79,7 @@ GuiCursor::GuiCursor()
    mRenderOffset.set(0.0f,0.0f);
    mExtent.set(1,1);
 
-   INIT_IMAGEASSET(Bitmap);
+   INIT_ASSET(Bitmap);
 }
 
 GuiCursor::~GuiCursor()
@@ -324,7 +324,7 @@ GuiControlProfile::GuiControlProfile(void) :
    mMouseOverSelected = false;
    
    // bitmap members
-   INIT_IMAGEASSET(Bitmap);
+   INIT_ASSET(Bitmap);
    mUseBitmapArray = false;
 
    mChildrenProfileName = NULL;
diff --git a/Engine/source/gui/core/guiTypes.h b/Engine/source/gui/core/guiTypes.h
index 23fa13246..c82c2fd50 100644
--- a/Engine/source/gui/core/guiTypes.h
+++ b/Engine/source/gui/core/guiTypes.h
@@ -345,7 +345,7 @@ private:
    typedef SimObject Parent;
 
    DECLARE_IMAGEASSET(GuiCursor, Bitmap, onImageChanged, GFXGuiCursorProfile);
-   DECLARE_IMAGEASSET_SETGET(GuiCursor, Bitmap);
+   DECLARE_ASSET_SETGET(GuiCursor, Bitmap);
 
    Point2I mHotSpot;
    Point2F mRenderOffset;
@@ -555,7 +555,7 @@ public:
    {
       return mBitmap;
    }
-   DECLARE_IMAGEASSET_SETGET(GuiControlProfile, Bitmap);
+   DECLARE_ASSET_SETGET(GuiControlProfile, Bitmap);
 
    void onBitmapChanged() {}
 
diff --git a/Engine/source/gui/game/guiChunkedBitmapCtrl.cpp b/Engine/source/gui/game/guiChunkedBitmapCtrl.cpp
index 138488f05..90e940e07 100644
--- a/Engine/source/gui/game/guiChunkedBitmapCtrl.cpp
+++ b/Engine/source/gui/game/guiChunkedBitmapCtrl.cpp
@@ -87,7 +87,7 @@ DefineEngineMethod( GuiChunkedBitmapCtrl, setBitmap, void, (const char* filename
 
 GuiChunkedBitmapCtrl::GuiChunkedBitmapCtrl()
 {
-   INIT_IMAGEASSET(Bitmap);
+   INIT_ASSET(Bitmap);
 
    mUseVariable = false;
    mTile = false;
diff --git a/Engine/source/gui/game/guiChunkedBitmapCtrl.h b/Engine/source/gui/game/guiChunkedBitmapCtrl.h
index 037eb91f6..f5d3405b8 100644
--- a/Engine/source/gui/game/guiChunkedBitmapCtrl.h
+++ b/Engine/source/gui/game/guiChunkedBitmapCtrl.h
@@ -18,7 +18,7 @@ private:
 protected:
 
    DECLARE_IMAGEASSET(GuiChunkedBitmapCtrl, Bitmap, onImageChanged, GFXDefaultGUIProfile);
-   DECLARE_IMAGEASSET_SETGET(GuiChunkedBitmapCtrl, Bitmap);
+   DECLARE_ASSET_SETGET(GuiChunkedBitmapCtrl, Bitmap);
 
    bool  mUseVariable;
    bool  mTile;
diff --git a/Engine/source/gui/game/guiProgressBitmapCtrl.cpp b/Engine/source/gui/game/guiProgressBitmapCtrl.cpp
index 0d0baa483..0faf2a8e0 100644
--- a/Engine/source/gui/game/guiProgressBitmapCtrl.cpp
+++ b/Engine/source/gui/game/guiProgressBitmapCtrl.cpp
@@ -124,7 +124,7 @@ GuiProgressBitmapCtrl::GuiProgressBitmapCtrl()
      mNumberOfBitmaps(0),
      mDim(0)
 {
-   INIT_IMAGEASSET(Bitmap);
+   INIT_ASSET(Bitmap);
 }
 
 //-----------------------------------------------------------------------------
diff --git a/Engine/source/gui/game/guiProgressBitmapCtrl.h b/Engine/source/gui/game/guiProgressBitmapCtrl.h
index e391f7b72..fba8aaa3c 100644
--- a/Engine/source/gui/game/guiProgressBitmapCtrl.h
+++ b/Engine/source/gui/game/guiProgressBitmapCtrl.h
@@ -48,7 +48,7 @@ class GuiProgressBitmapCtrl : public GuiTextCtrl
       F32 mProgress;
 
       DECLARE_IMAGEASSET(GuiProgressBitmapCtrl, Bitmap, onImageChanged, GFXDefaultGUIProfile);
-      DECLARE_IMAGEASSET_SETGET(GuiProgressBitmapCtrl, Bitmap);
+      DECLARE_ASSET_SETGET(GuiProgressBitmapCtrl, Bitmap);
 
       bool mUseVariable;
       bool mTile;
diff --git a/Engine/source/gui/worldEditor/guiMissionArea.cpp b/Engine/source/gui/worldEditor/guiMissionArea.cpp
index cd9c82ac9..a17b5a4ab 100644
--- a/Engine/source/gui/worldEditor/guiMissionArea.cpp
+++ b/Engine/source/gui/worldEditor/guiMissionArea.cpp
@@ -59,7 +59,7 @@ ConsoleDocClass( GuiMissionAreaCtrl,
 
 GuiMissionAreaCtrl::GuiMissionAreaCtrl()
 {
-   INIT_IMAGEASSET(HandleBitmap);
+   INIT_ASSET(HandleBitmap);
 
    mHandleTextureSize = Point2I::Zero;
    mHandleTextureHalfSize = Point2F::Zero;
diff --git a/Engine/source/gui/worldEditor/guiMissionArea.h b/Engine/source/gui/worldEditor/guiMissionArea.h
index 885f85107..c14438ac6 100644
--- a/Engine/source/gui/worldEditor/guiMissionArea.h
+++ b/Engine/source/gui/worldEditor/guiMissionArea.h
@@ -64,7 +64,7 @@ protected:
    GFXStateBlockRef  mSolidStateBlock;
 
    DECLARE_IMAGEASSET(GuiMissionAreaCtrl, HandleBitmap, onHandleBitmapChanged, GFXTexturePersistentSRGBProfile);
-   DECLARE_IMAGEASSET_SETGET(GuiMissionAreaCtrl, HandleBitmap);
+   DECLARE_ASSET_SETGET(GuiMissionAreaCtrl, HandleBitmap);
 
    Point2I           mHandleTextureSize;
    Point2F           mHandleTextureHalfSize;
diff --git a/Engine/source/gui/worldEditor/worldEditor.h b/Engine/source/gui/worldEditor/worldEditor.h
index dd596af74..a94fe068d 100644
--- a/Engine/source/gui/worldEditor/worldEditor.h
+++ b/Engine/source/gui/worldEditor/worldEditor.h
@@ -329,11 +329,11 @@ class WorldEditor : public EditTSCtrl
       ColorI            mPopupTextColor;
 
       DECLARE_IMAGEASSET(WorldEditor, SelectHandle, onSelectHandleChanged, GFXStaticTextureSRGBProfile);
-      DECLARE_IMAGEASSET_SETGET(WorldEditor, SelectHandle);
+      DECLARE_ASSET_SETGET(WorldEditor, SelectHandle);
       DECLARE_IMAGEASSET(WorldEditor, DefaultHandle, onDefaultHandleChanged, GFXStaticTextureSRGBProfile);
-      DECLARE_IMAGEASSET_SETGET(WorldEditor, DefaultHandle);
+      DECLARE_ASSET_SETGET(WorldEditor, DefaultHandle);
       DECLARE_IMAGEASSET(WorldEditor, LockedHandle, onLockedHandleChanged, GFXStaticTextureSRGBProfile);
-      DECLARE_IMAGEASSET_SETGET(WorldEditor, LockedHandle);
+      DECLARE_ASSET_SETGET(WorldEditor, LockedHandle);
 
       ColorI            mObjectTextColor;
       bool              mObjectsUseBoxCenter;
diff --git a/Engine/source/materials/materialDefinition.cpp b/Engine/source/materials/materialDefinition.cpp
index 7eb49ffc0..823072c4f 100644
--- a/Engine/source/materials/materialDefinition.cpp
+++ b/Engine/source/materials/materialDefinition.cpp
@@ -142,18 +142,18 @@ Material::Material()
       mAccuCoverage[i] = 0.9f;
       mAccuSpecular[i] = 16.0f;
 
-      INIT_IMAGEASSET_ARRAY(DiffuseMap, i);
-      INIT_IMAGEASSET_ARRAY(OverlayMap, i);
-      INIT_IMAGEASSET_ARRAY(LightMap, i);
-      INIT_IMAGEASSET_ARRAY(ToneMap, i);
-      INIT_IMAGEASSET_ARRAY(DetailMap, i);
-      INIT_IMAGEASSET_ARRAY(NormalMap, i);
-      INIT_IMAGEASSET_ARRAY(ORMConfigMap, i);
-      INIT_IMAGEASSET_ARRAY(RoughMap, i);
-      INIT_IMAGEASSET_ARRAY(AOMap, i);
-      INIT_IMAGEASSET_ARRAY(MetalMap, i);
-      INIT_IMAGEASSET_ARRAY(GlowMap, i);
-      INIT_IMAGEASSET_ARRAY(DetailNormalMap, i);
+      INIT_ASSET_ARRAY(DiffuseMap, i);
+      INIT_ASSET_ARRAY(OverlayMap, i);
+      INIT_ASSET_ARRAY(LightMap, i);
+      INIT_ASSET_ARRAY(ToneMap, i);
+      INIT_ASSET_ARRAY(DetailMap, i);
+      INIT_ASSET_ARRAY(NormalMap, i);
+      INIT_ASSET_ARRAY(ORMConfigMap, i);
+      INIT_ASSET_ARRAY(RoughMap, i);
+      INIT_ASSET_ARRAY(AOMap, i);
+      INIT_ASSET_ARRAY(MetalMap, i);
+      INIT_ASSET_ARRAY(GlowMap, i);
+      INIT_ASSET_ARRAY(DetailNormalMap, i);
 
       mParallaxScale[i] = 0.0f;
 
diff --git a/Engine/source/postFx/postEffect.cpp b/Engine/source/postFx/postEffect.cpp
index a9587c4aa..2f87ffa67 100644
--- a/Engine/source/postFx/postEffect.cpp
+++ b/Engine/source/postFx/postEffect.cpp
@@ -508,7 +508,7 @@ PostEffect::PostEffect()
 
    for (U32 i = 0; i < NumTextures; i++)
    {
-      INIT_IMAGEASSET_ARRAY(Texture, i);
+      INIT_ASSET_ARRAY(Texture, i);
    }
 }
 
diff --git a/Engine/source/terrain/terrMaterial.cpp b/Engine/source/terrain/terrMaterial.cpp
index 06b3b27bd..8a7683078 100644
--- a/Engine/source/terrain/terrMaterial.cpp
+++ b/Engine/source/terrain/terrMaterial.cpp
@@ -73,11 +73,11 @@ TerrainMaterial::TerrainMaterial()
       mIsSRGB(false),
       mInvertRoughness(false)
 {
-   INIT_IMAGEASSET(DiffuseMap);
-   INIT_IMAGEASSET(NormalMap);
-   INIT_IMAGEASSET(DetailMap);
-   INIT_IMAGEASSET(ORMConfigMap);
-   INIT_IMAGEASSET(MacroMap);
+   INIT_ASSET(DiffuseMap);
+   INIT_ASSET(NormalMap);
+   INIT_ASSET(DetailMap);
+   INIT_ASSET(ORMConfigMap);
+   INIT_ASSET(MacroMap);
 }
 
 TerrainMaterial::~TerrainMaterial()
@@ -203,8 +203,8 @@ TerrainMaterial* TerrainMaterial::findOrCreate( const char *nameOrPath )
 //material.getDiffuseMap(); //returns the raw file referenced
 //material.getDiffuseMapAsset(); //returns the asset id
 //material.setDiffuseMap(%texture); //tries to set the asset and failing that attempts a flat file reference
-DEF_IMAGEASSET_BINDS(TerrainMaterial, DiffuseMap);
-DEF_IMAGEASSET_BINDS(TerrainMaterial, NormalMap);
-DEF_IMAGEASSET_BINDS(TerrainMaterial, DetailMap);
-DEF_IMAGEASSET_BINDS(TerrainMaterial, ORMConfigMap);
-DEF_IMAGEASSET_BINDS(TerrainMaterial, MacroMap);
+DEF_ASSET_BINDS(TerrainMaterial, DiffuseMap);
+DEF_ASSET_BINDS(TerrainMaterial, NormalMap);
+DEF_ASSET_BINDS(TerrainMaterial, DetailMap);
+DEF_ASSET_BINDS(TerrainMaterial, ORMConfigMap);
+DEF_ASSET_BINDS(TerrainMaterial, MacroMap);
diff --git a/Engine/source/terrain/terrMaterial.h b/Engine/source/terrain/terrMaterial.h
index daf111321..4e129ef73 100644
--- a/Engine/source/terrain/terrMaterial.h
+++ b/Engine/source/terrain/terrMaterial.h
@@ -43,7 +43,7 @@ protected:
    //AssetPtr<ImageAsset> mDiffuseAsset;
 
    DECLARE_IMAGEASSET(TerrainMaterial, DiffuseMap, onDiffuseMapChanged, GFXStaticTextureSRGBProfile);
-   DECLARE_IMAGEASSET_SETGET(TerrainMaterial, DiffuseMap);
+   DECLARE_ASSET_SETGET(TerrainMaterial, DiffuseMap);
 
    /// The size of the diffuse base map in meters 
    /// used to generate its texture coordinates.
@@ -51,11 +51,11 @@ protected:
 
    ///
    DECLARE_IMAGEASSET(TerrainMaterial, NormalMap, onNormalMapChanged, GFXNormalMapProfile);
-   DECLARE_IMAGEASSET_SETGET(TerrainMaterial, NormalMap);
+   DECLARE_ASSET_SETGET(TerrainMaterial, NormalMap);
 
    ///
    DECLARE_IMAGEASSET(TerrainMaterial, DetailMap, onDetailMapChanged, GFXStaticTextureProfile);
-   DECLARE_IMAGEASSET_SETGET(TerrainMaterial, DetailMap);
+   DECLARE_ASSET_SETGET(TerrainMaterial, DetailMap);
    
    /// The size of the detail map in meters used
    /// to generate the texture coordinates for the
@@ -70,7 +70,7 @@ protected:
 
    ///
    DECLARE_IMAGEASSET(TerrainMaterial, ORMConfigMap, onORMConfigMapChanged, GFXStaticTextureProfile);
-   DECLARE_IMAGEASSET_SETGET(TerrainMaterial, ORMConfigMap);
+   DECLARE_ASSET_SETGET(TerrainMaterial, ORMConfigMap);
 
    bool mIsSRGB;
    bool mInvertRoughness;
@@ -82,7 +82,7 @@ protected:
    bool mSideProjection;
 
    DECLARE_IMAGEASSET(TerrainMaterial, MacroMap, onMacroMapChanged, GFXStaticTextureProfile);
-   DECLARE_IMAGEASSET_SETGET(TerrainMaterial, MacroMap);
+   DECLARE_ASSET_SETGET(TerrainMaterial, MacroMap);
    F32 mMacroSize;
    F32 mMacroStrength;
    F32 mMacroDistance;

From ab1b14587e322230da9261e3a00890be858198a5 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Sun, 3 Oct 2021 15:19:04 -0500
Subject: [PATCH 145/399] generic asset loader macros. currently unused

---
 Engine/source/T3D/assets/assetMacroHelpers.h | 24 ++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/Engine/source/T3D/assets/assetMacroHelpers.h b/Engine/source/T3D/assets/assetMacroHelpers.h
index 42f51e8e8..ef37cd7d5 100644
--- a/Engine/source/T3D/assets/assetMacroHelpers.h
+++ b/Engine/source/T3D/assets/assetMacroHelpers.h
@@ -34,6 +34,18 @@
    m##name##Asset = NULL;\
    m##name = NULL;
 
+//load asset into memory by looking up the ID, spew a warning if anything goes wrong
+#define LOAD_ASSET(name, assetClass)\
+if (m##name##AssetId != StringTable->EmptyString())\
+{\
+   S32 assetState = assetClass::getAssetById(m##name##AssetId, &m##name##Asset);\
+   if (assetState == assetClass::Ok )\
+   {\
+      m##name##Name = StringTable->EmptyString();\
+   }\
+   else Con::warnf("Warning: %s::LOAD_ASSET(%s)-%s", mClassName, m##name##AssetId, assetClass::getAssetErrstrn(assetState).c_str());\
+}
+
 // copy constructor 
 #define CLONE_ASSET(name) \
    m##name##Name = other.m##name##Name;\
@@ -134,6 +146,18 @@ DefineEngineMethod(className, set##name, bool, (const char* assetName), , assetT
    m##name[index] = NULL;\
 }
 
+//load asset into memory by looking up the ID, spew a warning if anything goes wrong
+#define LOAD_ASSET_ARRAY(name, index, assetClass)\
+if (m##name##AssetId[index] != StringTable->EmptyString())\
+{\
+   S32 assetState = assetClass::getAssetById(m##name##AssetId[index], &m##name##Asset[index]);\
+   if (assetState == assetClass::Ok )\
+   {\
+      m##name##Name[index] = StringTable->EmptyString();\
+   }\
+   else Con::warnf("Warning: %s::LOAD_ASSET(%s[%d])-%s", mClassName, m##name##AssetId[index],index, assetClass::getAssetErrstrn(assetState).c_str());\
+}
+
 // copy constructor 
 #define CLONE_ASSET_ARRAY(name, index) \
 {\

From 42d137f4a9513c395f281d849dbbf887ec9443b5 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Sun, 3 Oct 2021 15:20:08 -0500
Subject: [PATCH 146/399]    DECLARE_ASSET_ARRAY_SETGET is incompatible with
 INITPERSISTFIELD_SOUNDASSET_ENUMED

---
 Engine/source/T3D/vehicles/hoverVehicle.h   | 1 -
 Engine/source/T3D/vehicles/vehicle.h        | 2 --
 Engine/source/T3D/vehicles/wheeledVehicle.h | 1 -
 3 files changed, 4 deletions(-)

diff --git a/Engine/source/T3D/vehicles/hoverVehicle.h b/Engine/source/T3D/vehicles/hoverVehicle.h
index 8e7cce79b..8f666a76a 100644
--- a/Engine/source/T3D/vehicles/hoverVehicle.h
+++ b/Engine/source/T3D/vehicles/hoverVehicle.h
@@ -47,7 +47,6 @@ class HoverVehicleData : public VehicleData
       MaxSounds
    };
    DECLARE_SOUNDASSET_ARRAY(HoverVehicleData, HoverSounds, Sounds::MaxSounds);
-   DECLARE_ASSET_ARRAY_SETGET(HoverVehicleData, HoverSounds);
    SFXProfile* getHoverSoundProfile(U32 id)
    {
       if (mHoverSoundsAsset[id] != NULL)
diff --git a/Engine/source/T3D/vehicles/vehicle.h b/Engine/source/T3D/vehicles/vehicle.h
index c9a50b831..2e6440662 100644
--- a/Engine/source/T3D/vehicles/vehicle.h
+++ b/Engine/source/T3D/vehicles/vehicle.h
@@ -50,7 +50,6 @@ struct VehicleData : public RigidShapeData
    } body;
 
    DECLARE_SOUNDASSET_ARRAY(VehicleData, VehicleBodySounds, Body::Sounds::MaxSounds)
-   DECLARE_ASSET_ARRAY_SETGET(VehicleData, VehicleBodySounds);
 
    SFXProfile* getVehicleBodySoundProfile(U32 id)
    {
@@ -82,7 +81,6 @@ struct VehicleData : public RigidShapeData
    };
 
   DECLARE_SOUNDASSET_ARRAY(VehicleData, VehicleWaterSounds, Sounds::MaxSounds)
-  DECLARE_ASSET_ARRAY_SETGET(VehicleData, VehicleWaterSounds);
 
   SFXProfile* getVehicleWaterSoundProfile(U32 id)
   {
diff --git a/Engine/source/T3D/vehicles/wheeledVehicle.h b/Engine/source/T3D/vehicles/wheeledVehicle.h
index c8759e52d..56f5997a9 100644
--- a/Engine/source/T3D/vehicles/wheeledVehicle.h
+++ b/Engine/source/T3D/vehicles/wheeledVehicle.h
@@ -120,7 +120,6 @@ struct WheeledVehicleData: public VehicleData
    };
 
    DECLARE_SOUNDASSET_ARRAY(WheeledVehicleData, WheeledVehicleSounds, Sounds::MaxSounds);
-   DECLARE_ASSET_ARRAY_SETGET(WheeledVehicleData, WheeledVehicleSounds);
 
    SFXProfile* getWheeledVehicleSound(U32 id)
    {

From 67c889279dbbd27671ef45c4df3ca1dbd97091c4 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Sun, 3 Oct 2021 17:42:32 -0500
Subject: [PATCH 147/399] fix groundplane material reference in examplelevel

---
 .../BaseGame/game/data/ExampleModule/levels/ExampleLevel.mis    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Templates/BaseGame/game/data/ExampleModule/levels/ExampleLevel.mis b/Templates/BaseGame/game/data/ExampleModule/levels/ExampleLevel.mis
index ba5384a96..e2b9ce7d1 100644
--- a/Templates/BaseGame/game/data/ExampleModule/levels/ExampleLevel.mis
+++ b/Templates/BaseGame/game/data/ExampleModule/levels/ExampleLevel.mis
@@ -36,7 +36,7 @@ new Scene(EditorTemplateLevel) {
       squareSize = "128";
       scaleU = "25";
       scaleV = "25";
-      MaterialFile = "FloorGray";
+      MaterialAsset = "Prototyping:FloorGray";
       canSave = "1";
       canSaveDynamicFields = "1";
          Enabled = "1";

From a1117b1c41ad728311c82aa558598971dedf8788 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Sun, 3 Oct 2021 21:51:40 -0500
Subject: [PATCH 148/399] add getInWorldNormal method glsl side

---
 .../shaderGen/GLSL/shaderFeatureGLSL.cpp      | 35 +++++++++++++------
 .../source/shaderGen/GLSL/shaderFeatureGLSL.h |  1 +
 2 files changed, 25 insertions(+), 11 deletions(-)

diff --git a/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp b/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
index e9604eb77..73bb56fd1 100644
--- a/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
+++ b/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
@@ -765,6 +765,21 @@ Var* ShaderFeatureGLSL::getWsView( Var *wsPosition, MultiLine *meta )
    return wsView;
 }
 
+Var* ShaderFeatureGLSL::getInWorldNormal(Vector<ShaderComponent*>& componentList)
+{
+   Var* wsNormal = (Var*)LangElement::find("wsNormal");
+   if (!wsNormal)
+   {
+      ShaderConnector* connectComp = dynamic_cast<ShaderConnector*>(componentList[C_CONNECTOR]);
+      wsNormal = connectComp->getElement(RT_TEXCOORD);
+      wsNormal->setName("wsNormal");
+      wsNormal->setStructName("IN");
+      wsNormal->setType("float3");
+   }
+
+   return wsNormal;
+}
+
 Var* ShaderFeatureGLSL::addOutDetailTexCoord(   Vector<ShaderComponent*> &componentList, 
 															MultiLine *meta,
 															bool useTexAnim,
@@ -851,21 +866,23 @@ Var* ShaderFeatureGLSL::getSurface(Vector<ShaderComponent*>& componentList, Mult
       meta->addStatement(new GenOp("   @ = vec4(0.0,1.0,@,@);\r\n", colorDecl, roughness, metalness)); //reconstruct ormConfig, no ao darkening
    }
 
-   Var* wsNormal = (Var*)LangElement::find("wsNormal");
    Var* normal = (Var*)LangElement::find("normal");
    if (!normal)
    {
       normal = new Var("normal", "vec3");
       meta->addStatement(new GenOp("  @;\r\n\n", new DecOp(normal)));
+
+      Var* wsNormal = (Var*)LangElement::find("wsNormal");
       if (!fd.features[MFT_NormalMap])
       {
-         Var* worldToTangent = getInWorldToTangent(componentList);
-         meta->addStatement(new GenOp("  @ = normalize(tMul(@,vec3(0,0,1.0f)));\r\n\n", normal, worldToTangent));
+         if (!wsNormal)
+            wsNormal = getInWorldNormal(componentList);
+         meta->addStatement(new GenOp("  @ = normalize( @ );\r\n\n", normal, wsNormal));
       }
       else
       {
-         meta->addStatement(new GenOp("   @ = normalize( half3( @ ) );\r\n", normal, wsNormal));
-      }      
+         meta->addStatement(new GenOp("   @ = normalize(  @ );\r\n", normal, wsNormal));
+      }
    }
 
    Var* wsEyePos = (Var*)LangElement::find("eyePosWorld");
@@ -2142,14 +2159,10 @@ void RTLightingFeatGLSL::processPix(   Vector<ShaderComponent*> &componentList,
 
 	// Now the wsPosition and wsView.
    Var *wsPosition = getInWsPosition( componentList );
+   Var* worldToTangent = getInWorldToTangent(componentList);
+   Var* wsNormal = getInWorldNormal(componentList);
    Var *wsView = getWsView( wsPosition, meta );
 
-   // Create temporaries to hold results of lighting.
-   Var *rtShading = new Var( "rtShading", "vec4" );
-   Var *specular = new Var( "specular", "vec4" );
-   meta->addStatement( new GenOp( "   @; @;\r\n", 
-      new DecOp( rtShading ), new DecOp( specular ) ) );   
-
    // Look for a light mask generated from a previous
    // feature (this is done for BL terrain lightmaps).
    LangElement *lightMask = LangElement::find( "lightMask" );
diff --git a/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.h b/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.h
index 24a2a8115..d4dbb1886 100644
--- a/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.h
+++ b/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.h
@@ -137,6 +137,7 @@ public:
 								MultiLine *meta );
 
    Var* getSurface(Vector<ShaderComponent*>& componentList, MultiLine* meta, const MaterialFeatureData& fd);
+   Var* getInWorldNormal(Vector<ShaderComponent*>& componentList);
 		
    // ShaderFeature
    Var* getVertTexCoord( const String &name );

From 661a192e878a951ac10d0d2f715e352fd5e57ba4 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Sun, 3 Oct 2021 21:53:16 -0500
Subject: [PATCH 149/399] orderfix for RTLightingFeatHLSL vert vs pixel shader.
 the order needs to match, same as network comunicating

---
 Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp b/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
index dfdb5439c..ecd4619d0 100644
--- a/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
+++ b/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
@@ -879,12 +879,10 @@ Var* ShaderFeatureHLSL::getSurface(Vector<ShaderComponent*>& componentList, Mult
       meta->addStatement(new GenOp("  @;\r\n\n", new DecOp(normal)));
 
       Var* wsNormal = (Var*)LangElement::find("wsNormal");
-
       if (!fd.features[MFT_NormalMap])
       {
          if (!wsNormal)
             wsNormal = getInWorldNormal(componentList);
-
          meta->addStatement(new GenOp("  @ = normalize( @ );\r\n\n", normal, wsNormal));
       }
       else
@@ -2227,10 +2225,9 @@ void RTLightingFeatHLSL::processPix(   Vector<ShaderComponent*> &componentList,
    MultiLine *meta = new MultiLine;
 
    // Now the wsPosition and wsView.
-   Var* worldToTangent = getInWorldToTangent(componentList);
-   Var* wsNormal = getInWorldNormal(componentList);
    Var *wsPosition = getInWsPosition( componentList );
-   
+   Var* worldToTangent = getInWorldToTangent(componentList);
+   Var* wsNormal = getInWorldNormal(componentList);   
    Var *wsView = getWsView( wsPosition, meta );
    
    // Look for a light mask generated from a previous

From 79ad78361d75e8f233a7504b949836d803ffc4fd Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Mon, 4 Oct 2021 18:24:33 -0500
Subject: [PATCH 150/399] item->importStatus cleanup for asset importer

---
 Engine/source/T3D/assets/assetImporter.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Engine/source/T3D/assets/assetImporter.cpp b/Engine/source/T3D/assets/assetImporter.cpp
index 5df1ca8ab..254df381d 100644
--- a/Engine/source/T3D/assets/assetImporter.cpp
+++ b/Engine/source/T3D/assets/assetImporter.cpp
@@ -1409,7 +1409,7 @@ void AssetImporter::processImportAssets(AssetImportObject* assetItem)
 		      Con::executef(this, processCommand.c_str(), item);
 		}
 
-      item->importStatus == AssetImportObject::Processed;
+      item->importStatus = AssetImportObject::Processed;
 
       //try recusing on the children(if any)
       processImportAssets(item);
@@ -2018,7 +2018,7 @@ void AssetImporter::validateAsset(AssetImportObject* assetItem)
       AssetQuery aQuery;
       U32 numAssetsFound = AssetDatabase.findAllAssets(&aQuery);
 
-      bool hasCollision = false;
+      hasCollision = false;
       for (U32 i = 0; i < numAssetsFound; i++)
       {
          StringTableEntry assetId = aQuery.mAssetList[i];

From 1b6b803a20d7f58f639ff2c09e7f8bf0e7b78742 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Mon, 4 Oct 2021 20:04:21 -0400
Subject: [PATCH 151/399] * BugFix: Clear a lot of warnings and correct a few
 actual programming errors along the way.

---
 Engine/lib/collada/include/dae.h              |  2 +-
 .../lib/collada/include/dae/daeErrorHandler.h |  2 +-
 .../include/dae/daeStandardURIResolver.h      |  2 +-
 .../lib/collada/src/dae/daeErrorHandler.cpp   |  2 +-
 Engine/source/T3D/assets/MaterialAsset.cpp    | 15 ++++---
 Engine/source/T3D/assets/assetImporter.cpp    |  2 +-
 Engine/source/T3D/assets/assetImporter.h      |  9 -----
 Engine/source/T3D/convexShape.cpp             |  4 +-
 Engine/source/T3D/fx/particleEmitter.cpp      | 12 +++++-
 Engine/source/T3D/fx/precipitation.cpp        |  2 +-
 Engine/source/T3D/gameBase/gameConnection.cpp |  2 +-
 Engine/source/T3D/shapeBase.h                 |  2 +-
 Engine/source/afx/util/afxAnimCurve.h         |  2 +-
 Engine/source/afx/util/afxCurveEval.h         |  1 +
 Engine/source/afx/xm/afxXM_WaveBase.h         |  3 +-
 Engine/source/collision/optimizedPolyList.h   |  2 +-
 Engine/source/collision/polytope.h            |  2 +-
 Engine/source/console/CMDscan.cpp             | 40 +++++++++----------
 Engine/source/console/arrayObject.cpp         |  4 +-
 Engine/source/console/simObject.cpp           |  4 +-
 Engine/source/core/stringBuffer.cpp           |  2 +-
 Engine/source/core/strings/unicode.cpp        |  4 +-
 Engine/source/core/util/hashFunction.h        |  4 +-
 Engine/source/environment/decalRoad.cpp       |  2 +-
 .../editors/guiMeshRoadEditorCtrl.cpp         |  2 +-
 .../editors/guiRiverEditorCtrl.cpp            |  2 +-
 .../environment/editors/guiRoadEditorCtrl.cpp |  2 +-
 Engine/source/environment/meshRoad.cpp        |  4 +-
 Engine/source/environment/river.cpp           |  2 +-
 Engine/source/gfx/bitmap/gBitmap.cpp          |  4 +-
 .../source/gfx/bitmap/loaders/bitmapPng.cpp   |  2 +-
 Engine/source/gfx/gl/gfxGLCubemap.cpp         |  2 +-
 Engine/source/gfx/gl/gfxGLStateBlock.cpp      |  4 +-
 Engine/source/gfx/gl/gfxGLTextureArray.cpp    |  2 +-
 Engine/source/gfx/gl/gfxGLTextureArray.h      |  2 +-
 Engine/source/gfx/gl/gfxGLTextureObject.cpp   |  2 +-
 Engine/source/gfx/sim/cubemapData.cpp         |  2 +-
 .../source/gfx/video/videoEncoderTheora.cpp   |  2 +-
 Engine/source/gui/core/guiCanvas.cpp          |  2 +-
 Engine/source/gui/editor/guiInspector.cpp     |  4 +-
 .../source/gui/editor/guiShapeEdPreview.cpp   |  6 +--
 .../worldEditor/guiConvexShapeEditorCtrl.h    |  2 +-
 .../source/gui/worldEditor/guiMissionArea.h   |  2 +-
 .../source/gui/worldEditor/terrainActions.cpp |  2 +-
 .../advanced/advancedLightBinManager.h        |  2 +-
 .../source/lighting/basic/blTerrainSystem.cpp |  4 +-
 .../source/materials/materialDefinition.cpp   |  2 +-
 Engine/source/math/mRandom.h                  |  2 +-
 Engine/source/navigation/guiNavEditorCtrl.h   |  2 +-
 Engine/source/persistence/taml/taml.cpp       |  2 +-
 Engine/source/platform/platformNet.cpp        |  2 +-
 Engine/source/platformSDL/sdlInput.cpp        |  2 +-
 .../source/platformX86UNIX/x86UNIXFileio.cpp  | 16 ++++----
 .../renderInstance/renderImposterMgr.cpp      |  2 +-
 .../renderInstance/renderPassStateToken.cpp   |  2 +-
 .../scene/mixin/scenePolyhedralObject.impl.h  |  6 +--
 Engine/source/sim/actionMap.cpp               |  2 +-
 Engine/source/sim/actionMap.h                 |  2 +-
 Engine/source/sim/netObject.cpp               |  4 +-
 Engine/source/ts/tsShape.cpp                  |  6 +--
 Engine/source/ts/tsShapeConstruct.cpp         |  2 +-
 61 files changed, 120 insertions(+), 118 deletions(-)

diff --git a/Engine/lib/collada/include/dae.h b/Engine/lib/collada/include/dae.h
index d6f217ed8..d5d16f125 100644
--- a/Engine/lib/collada/include/dae.h
+++ b/Engine/lib/collada/include/dae.h
@@ -195,7 +195,7 @@ private:
 	daeRawRefCache rawRefCache;
 	daeSidRefCache sidRefCache;
 
-	std::auto_ptr<charEncoding> localCharEncoding;
+	std::unique_ptr<charEncoding> localCharEncoding;
 	static charEncoding globalCharEncoding;
 };
 
diff --git a/Engine/lib/collada/include/dae/daeErrorHandler.h b/Engine/lib/collada/include/dae/daeErrorHandler.h
index 6d6499486..edc20ee31 100644
--- a/Engine/lib/collada/include/dae/daeErrorHandler.h
+++ b/Engine/lib/collada/include/dae/daeErrorHandler.h
@@ -60,7 +60,7 @@ public:
 
 private:
 	static daeErrorHandler *_instance;
-	static std::auto_ptr<daeErrorHandler> _defaultInstance;
+	static std::unique_ptr<daeErrorHandler> _defaultInstance;
 };
 
 #endif
diff --git a/Engine/lib/collada/include/dae/daeStandardURIResolver.h b/Engine/lib/collada/include/dae/daeStandardURIResolver.h
index 0c92bcc6e..6d9bcf15d 100644
--- a/Engine/lib/collada/include/dae/daeStandardURIResolver.h
+++ b/Engine/lib/collada/include/dae/daeStandardURIResolver.h
@@ -12,7 +12,7 @@
  */
 
 #ifndef __DAE_STANDARD_URI_RESOLVER__
-#define __DAE_STANDARD_URI_RESOVLER__
+#define __DAE_STANDARD_URI_RESOLVER__
 
 #include <string>
 #include "dae/daeURI.h"
diff --git a/Engine/lib/collada/src/dae/daeErrorHandler.cpp b/Engine/lib/collada/src/dae/daeErrorHandler.cpp
index 843bbbae3..2e7edcf9c 100644
--- a/Engine/lib/collada/src/dae/daeErrorHandler.cpp
+++ b/Engine/lib/collada/src/dae/daeErrorHandler.cpp
@@ -15,7 +15,7 @@
 #include <modules/stdErrPlugin.h>
 
 daeErrorHandler *daeErrorHandler::_instance = NULL;
-std::auto_ptr<daeErrorHandler> daeErrorHandler::_defaultInstance(new stdErrPlugin);
+std::unique_ptr<daeErrorHandler> daeErrorHandler::_defaultInstance(new stdErrPlugin);
 
 daeErrorHandler::daeErrorHandler() {
 }
diff --git a/Engine/source/T3D/assets/MaterialAsset.cpp b/Engine/source/T3D/assets/MaterialAsset.cpp
index 8fd2b6ecf..57008b025 100644
--- a/Engine/source/T3D/assets/MaterialAsset.cpp
+++ b/Engine/source/T3D/assets/MaterialAsset.cpp
@@ -19,7 +19,6 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
-#pragma once
 
 #ifndef MATERIALASSET_H
 #include "MaterialAsset.h"
@@ -171,10 +170,16 @@ void MaterialAsset::initializeAsset()
    if (Torque::FS::IsScriptFile(mScriptPath))
    {
       if (!Sim::findObject(mMatDefinitionName))
-         if (Con::executeFile(mScriptPath, false, false))
-            mLoadedState = ScriptLoaded;
-         else
-            mLoadedState = Failed;
+      {
+          if (Con::executeFile(mScriptPath, false, false))
+          {
+              mLoadedState = ScriptLoaded;
+          }
+          else
+          {
+              mLoadedState = Failed;
+          }
+      }
    }
 
    loadMaterial();
diff --git a/Engine/source/T3D/assets/assetImporter.cpp b/Engine/source/T3D/assets/assetImporter.cpp
index 5df1ca8ab..c9ed8a211 100644
--- a/Engine/source/T3D/assets/assetImporter.cpp
+++ b/Engine/source/T3D/assets/assetImporter.cpp
@@ -1409,7 +1409,7 @@ void AssetImporter::processImportAssets(AssetImportObject* assetItem)
 		      Con::executef(this, processCommand.c_str(), item);
 		}
 
-      item->importStatus == AssetImportObject::Processed;
+      item->importStatus = AssetImportObject::Processed;
 
       //try recusing on the children(if any)
       processImportAssets(item);
diff --git a/Engine/source/T3D/assets/assetImporter.h b/Engine/source/T3D/assets/assetImporter.h
index 0c176840a..b03c89c40 100644
--- a/Engine/source/T3D/assets/assetImporter.h
+++ b/Engine/source/T3D/assets/assetImporter.h
@@ -931,15 +931,6 @@ public:
       return imagePath;
    }
 
-   static inline const char* makeFullPath(const String& path)
-   {
-      char qualifiedFilePath[2048];
-
-      Platform::makeFullPathName(path.c_str(), qualifiedFilePath, sizeof(qualifiedFilePath));
-
-      return qualifiedFilePath;
-   }
-
    //
    void setTargetModuleId(const String& moduleId) { targetModuleId = moduleId; }
    const String& getTargetModuleId() { return targetModuleId; }
diff --git a/Engine/source/T3D/convexShape.cpp b/Engine/source/T3D/convexShape.cpp
index 99f3f418a..e0184f2f4 100644
--- a/Engine/source/T3D/convexShape.cpp
+++ b/Engine/source/T3D/convexShape.cpp
@@ -318,10 +318,10 @@ void ConvexShape::initPersistFields()
 
    addGroup( "Internal" );
 
-      addProtectedField( "surface", TypeRealString, NULL, &protectedSetSurface, &defaultProtectedGetFn, 
+      addProtectedField( "surface", TypeRealString, 0, &protectedSetSurface, &defaultProtectedGetFn,
          "Do not modify, for internal use.", AbstractClassRep::FIELD_HideInInspectors );
 
-	  addProtectedField( "surfaceTexture", TypeRealString, NULL, &protectedSetSurfaceTexture, &defaultProtectedGetFn, 
+	  addProtectedField( "surfaceTexture", TypeRealString, 0, &protectedSetSurfaceTexture, &defaultProtectedGetFn,
          "Do not modify, for internal use.", AbstractClassRep::FIELD_HideInInspectors );
 
    endGroup( "Internal" );
diff --git a/Engine/source/T3D/fx/particleEmitter.cpp b/Engine/source/T3D/fx/particleEmitter.cpp
index 45acd1ecb..c60dc6d49 100644
--- a/Engine/source/T3D/fx/particleEmitter.cpp
+++ b/Engine/source/T3D/fx/particleEmitter.cpp
@@ -1914,7 +1914,11 @@ void ParticleEmitter::copyToVB( const Point3F &camPos, const LinearColorF &ambie
          {
             SortParticle* partPtr = orderedVector.address();
             for (U32 i = 0; i < n_parts - 1; i++, partPtr++, buffPtr -= 4)
-               setupRibbon(partPtr->p, partPtr++->p, partPtr--->p, camPos, ambientColor, buffPtr);
+            {
+                SortParticle* part = partPtr;
+                partPtr++;
+                setupRibbon(part->p, partPtr->p, partPtr->p, camPos, ambientColor, buffPtr);
+            }
          }
          // do unsorted-oriented particles
          else
@@ -1933,7 +1937,11 @@ void ParticleEmitter::copyToVB( const Point3F &camPos, const LinearColorF &ambie
          {
             SortParticle* partPtr = orderedVector.address();
             for (U32 i = 0; i < n_parts - 1; i++, partPtr++, buffPtr += 4)
-               setupRibbon(partPtr->p, partPtr++->p, partPtr--->p, camPos, ambientColor, buffPtr);
+            {
+                SortParticle* part = partPtr;
+                partPtr++;
+                setupRibbon(part->p, partPtr->p, partPtr->p, camPos, ambientColor, buffPtr);
+            }
          }
          // do unsorted-oriented particles
          else
diff --git a/Engine/source/T3D/fx/precipitation.cpp b/Engine/source/T3D/fx/precipitation.cpp
index 4356cd45f..5740edae6 100644
--- a/Engine/source/T3D/fx/precipitation.cpp
+++ b/Engine/source/T3D/fx/precipitation.cpp
@@ -996,7 +996,7 @@ void Precipitation::initRenderObjects()
    // entire or a partially filled vb.
    mRainIB.set(GFX, mMaxVBDrops * 6, 0, GFXBufferTypeStatic);
    U16 *idxBuff;
-   mRainIB.lock(&idxBuff, NULL, NULL, NULL);
+   mRainIB.lock(&idxBuff, NULL, 0, 0);
    for( U32 i=0; i < mMaxVBDrops; i++ )
    {
       //
diff --git a/Engine/source/T3D/gameBase/gameConnection.cpp b/Engine/source/T3D/gameBase/gameConnection.cpp
index 09cfa13cf..f759a03da 100644
--- a/Engine/source/T3D/gameBase/gameConnection.cpp
+++ b/Engine/source/T3D/gameBase/gameConnection.cpp
@@ -807,7 +807,7 @@ bool GameConnection::isValidControlCameraFov(F32 fov)
       return cObj->isValidCameraFov(fov);
    }
 
-   return NULL;
+   return false;
 }
 
 bool GameConnection::setControlCameraFov(F32 fov)
diff --git a/Engine/source/T3D/shapeBase.h b/Engine/source/T3D/shapeBase.h
index 4d3286b5c..2deb7996c 100644
--- a/Engine/source/T3D/shapeBase.h
+++ b/Engine/source/T3D/shapeBase.h
@@ -116,7 +116,7 @@ class ShapeBaseConvex : public Convex
    Box3F       box;
 
   public:
-   ShapeBaseConvex() :pShapeBase(NULL), transform(NULL), hullId(NULL), nodeTransform(0) { mType = ShapeBaseConvexType; }
+   ShapeBaseConvex() :pShapeBase(NULL), transform(NULL), hullId(0), nodeTransform(0) { mType = ShapeBaseConvexType; }
    ShapeBaseConvex(const ShapeBaseConvex& cv) {
       mObject    = cv.mObject;
       pShapeBase = cv.pShapeBase;
diff --git a/Engine/source/afx/util/afxAnimCurve.h b/Engine/source/afx/util/afxAnimCurve.h
index 158203b44..6ed7dbfd0 100644
--- a/Engine/source/afx/util/afxAnimCurve.h
+++ b/Engine/source/afx/util/afxAnimCurve.h
@@ -56,7 +56,7 @@ class afxAnimCurve
 
 	public:
 		afxAnimCurve();
-		~afxAnimCurve();
+		virtual ~afxAnimCurve();
 
 		void    addKey( Point2F &v );
 		void    addKey( F32 time, F32 value );
diff --git a/Engine/source/afx/util/afxCurveEval.h b/Engine/source/afx/util/afxCurveEval.h
index 0a8765c19..d5c6853b9 100644
--- a/Engine/source/afx/util/afxCurveEval.h
+++ b/Engine/source/afx/util/afxCurveEval.h
@@ -32,6 +32,7 @@
 class afxCurveEval
 {
 public:
+  virtual ~afxCurveEval() { }
   virtual Point2F evaluateCurve(Point2F& v0, Point2F& v1, F32 t)=0;
   virtual Point2F evaluateCurve(Point2F& v0, Point2F& v1, Point2F& t0, Point2F& t1, F32 t)=0;
   virtual Point2F evaluateCurveTangent(Point2F& v0, Point2F& v1, F32 t)=0;
diff --git a/Engine/source/afx/xm/afxXM_WaveBase.h b/Engine/source/afx/xm/afxXM_WaveBase.h
index f7dd26f31..e231ef2b8 100644
--- a/Engine/source/afx/xm/afxXM_WaveBase.h
+++ b/Engine/source/afx/xm/afxXM_WaveBase.h
@@ -81,6 +81,7 @@ public:
 class afxXM_WaveInterp
 {
 public:
+  virtual ~afxXM_WaveInterp() { }
   virtual void interpolate(F32 t, afxXM_Params& params)=0;
   virtual void pulse()=0;
 
@@ -250,7 +251,7 @@ protected:
 
 public:
   /*C*/                 afxXM_WaveBase(afxXM_WaveBaseData*, afxEffectWrapper*, afxXM_WaveInterp*);
-  /*D*/                 ~afxXM_WaveBase();
+  /*D*/                 virtual ~afxXM_WaveBase();
 
   virtual void          updateParams(F32 dt, F32 elapsed, afxXM_Params& params);
 };
diff --git a/Engine/source/collision/optimizedPolyList.h b/Engine/source/collision/optimizedPolyList.h
index b66cc76c0..b42469fe1 100644
--- a/Engine/source/collision/optimizedPolyList.h
+++ b/Engine/source/collision/optimizedPolyList.h
@@ -87,7 +87,7 @@ class OptimizedPolyList : public AbstractPolyList
 
       Poly()
          : plane( -1 ),
-           material( NULL ),
+           material( 0 ),
            vertexStart(0),
            vertexCount( 0 ),
            surfaceKey(0),
diff --git a/Engine/source/collision/polytope.h b/Engine/source/collision/polytope.h
index 347a85c70..34483c976 100644
--- a/Engine/source/collision/polytope.h
+++ b/Engine/source/collision/polytope.h
@@ -76,7 +76,7 @@ public:
       Collision()
       {
          object = NULL;
-         material = NULL;
+         material = 0;
          distance = 0.0;
       }
    };
diff --git a/Engine/source/console/CMDscan.cpp b/Engine/source/console/CMDscan.cpp
index 43a864570..787b4e845 100644
--- a/Engine/source/console/CMDscan.cpp
+++ b/Engine/source/console/CMDscan.cpp
@@ -774,9 +774,9 @@ YY_MALLOC_DECL
 
 YY_DECL
 	{
-	register yy_state_type yy_current_state;
-	register char *yy_cp, *yy_bp;
-	register int yy_act;
+    yy_state_type yy_current_state;
+    char *yy_cp, *yy_bp;
+    int yy_act;
 
 #line 105 "CMDscan.l"
 
@@ -823,7 +823,7 @@ YY_DECL
 yy_match:
 		do
 			{
-			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
+		    YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
 			if ( yy_accept[yy_current_state] )
 				{
 				yy_last_accepting_state = yy_current_state;
@@ -1430,9 +1430,9 @@ case YY_STATE_EOF(INITIAL):
 
 static int yy_get_next_buffer()
 	{
-	register char *dest = yy_current_buffer->yy_ch_buf;
-	register char *source = yytext_ptr;
-	register int number_to_move, i;
+    char *dest = yy_current_buffer->yy_ch_buf;
+    char *source = yytext_ptr;
+    int number_to_move, i;
 	int ret_val;
 
 	if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
@@ -1560,14 +1560,14 @@ static int yy_get_next_buffer()
 
 static yy_state_type yy_get_previous_state()
 	{
-	register yy_state_type yy_current_state;
-	register char *yy_cp;
+    yy_state_type yy_current_state;
+    char *yy_cp;
 
 	yy_current_state = yy_start;
 
 	for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
 		{
-		register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+	    YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
 		if ( yy_accept[yy_current_state] )
 			{
 			yy_last_accepting_state = yy_current_state;
@@ -1599,10 +1599,10 @@ static yy_state_type yy_try_NUL_trans( yy_current_state )
 yy_state_type yy_current_state;
 #endif
 	{
-	register int yy_is_jam;
-	register char *yy_cp = yy_c_buf_p;
+    int yy_is_jam;
+    char *yy_cp = yy_c_buf_p;
 
-	register YY_CHAR yy_c = 1;
+    YY_CHAR yy_c = 1;
 	if ( yy_accept[yy_current_state] )
 		{
 		yy_last_accepting_state = yy_current_state;
@@ -1623,14 +1623,14 @@ yy_state_type yy_current_state;
 
 #ifndef YY_NO_UNPUT
 #ifdef YY_USE_PROTOS
-static void yyunput( int c, register char *yy_bp )
+static void yyunput( int c, char *yy_bp )
 #else
 static void yyunput( c, yy_bp )
 int c;
-register char *yy_bp;
+char *yy_bp;
 #endif
 	{
-	register char *yy_cp = yy_c_buf_p;
+    char *yy_cp = yy_c_buf_p;
 
 	/* undo effects of setting up yytext */
 	*yy_cp = yy_hold_char;
@@ -1638,10 +1638,10 @@ register char *yy_bp;
 	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
 		{ /* need to shift things up to make room */
 		/* +2 for EOB chars. */
-		register int number_to_move = yy_n_chars + 2;
-		register char *dest = &yy_current_buffer->yy_ch_buf[
+		int number_to_move = yy_n_chars + 2;
+		char *dest = &yy_current_buffer->yy_ch_buf[
 					yy_current_buffer->yy_buf_size + 2];
-		register char *source =
+		char *source =
 				&yy_current_buffer->yy_ch_buf[number_to_move];
 
 		while ( source > yy_current_buffer->yy_ch_buf )
@@ -2095,7 +2095,7 @@ yyconst char *s2;
 int n;
 #endif
 	{
-	register int i;
+    int i;
 	for ( i = 0; i < n; ++i )
 		s1[i] = s2[i];
 	}
diff --git a/Engine/source/console/arrayObject.cpp b/Engine/source/console/arrayObject.cpp
index 68b34059e..4c18ac306 100644
--- a/Engine/source/console/arrayObject.cpp
+++ b/Engine/source/console/arrayObject.cpp
@@ -125,7 +125,7 @@ S32 QSORT_CALLBACK ArrayObject::_valueFunctionCompare( const void* a, const void
 
 ArrayObject::ArrayObject()
    : mCaseSensitive( false ),
-     mCurrentIndex( NULL )
+     mCurrentIndex( 0 )
 {
 }
 
@@ -137,7 +137,7 @@ void ArrayObject::initPersistFields()
       "Makes the keys and values case-sensitive.\n"
       "By default, comparison of key and value strings will be case-insensitive." );
 
-   addProtectedField( "key", TypeCaseString, NULL, &_addKeyFromField, &emptyStringProtectedGetFn, 
+   addProtectedField( "key", TypeCaseString, 0, &_addKeyFromField, &emptyStringProtectedGetFn,
       "Helper field which allows you to add new key['keyname'] = value pairs." );
 
    Parent::initPersistFields();
diff --git a/Engine/source/console/simObject.cpp b/Engine/source/console/simObject.cpp
index 6b54bdd1d..3d485354c 100644
--- a/Engine/source/console/simObject.cpp
+++ b/Engine/source/console/simObject.cpp
@@ -179,10 +179,10 @@ void SimObject::initPersistFields()
    
    addGroup( "Editing" );
    
-      addProtectedField( "hidden", TypeBool, NULL,
+      addProtectedField( "hidden", TypeBool, 0,
          &_setHidden, &_getHidden,
          "Whether the object is visible." );
-      addProtectedField( "locked", TypeBool, NULL,
+      addProtectedField( "locked", TypeBool, 0,
          &_setLocked, &_getLocked,
          "Whether the object can be edited." );
    
diff --git a/Engine/source/core/stringBuffer.cpp b/Engine/source/core/stringBuffer.cpp
index 2bc3fb069..66983fcf2 100644
--- a/Engine/source/core/stringBuffer.cpp
+++ b/Engine/source/core/stringBuffer.cpp
@@ -371,7 +371,7 @@ void StringBuffer::getCopy(UTF16 *buff, const U32 buffSize) const
    AssertFatal(mBuffer.last() == 0, "StringBuffer::get UTF8 - not a null terminated string!");
    dMemcpy(buff, mBuffer.address(), sizeof(UTF16) * getMin(buffSize, (U32)mBuffer.size()));
    // ensure null termination.
-   buff[buffSize-1] = NULL;
+   buff[buffSize-1] = 0;
 }
 
 UTF8* StringBuffer::createCopy8() const
diff --git a/Engine/source/core/strings/unicode.cpp b/Engine/source/core/strings/unicode.cpp
index fd2341b7b..ad43ad3e1 100644
--- a/Engine/source/core/strings/unicode.cpp
+++ b/Engine/source/core/strings/unicode.cpp
@@ -236,8 +236,8 @@ U32 convertUTF16toUTF8DoubleNULL( const UTF16 *unistring, UTF8  *outbuffer, U32
    }
 
    nCodeunits = getMin(nCodeunits,len - 1);
-   outbuffer[nCodeunits] = NULL;
-   outbuffer[nCodeunits+1] = NULL;
+   outbuffer[nCodeunits] = '\0';
+   outbuffer[nCodeunits+1] = '\0';
 
    PROFILE_END();
    return nCodeunits;
diff --git a/Engine/source/core/util/hashFunction.h b/Engine/source/core/util/hashFunction.h
index d2e1d5b4a..02ecd019b 100644
--- a/Engine/source/core/util/hashFunction.h
+++ b/Engine/source/core/util/hashFunction.h
@@ -30,9 +30,9 @@
 namespace Torque
 {
 
-extern U32 hash(register const U8 *k, register U32 length, register U32 initval);
+extern U32 hash(const U8 *k, U32 length, U32 initval);
 
-extern U64 hash64(register const U8 *k, register U32 length, register U64 initval);
+extern U64 hash64(const U8 *k, U32 length, U64 initval);
 
 }
 
diff --git a/Engine/source/environment/decalRoad.cpp b/Engine/source/environment/decalRoad.cpp
index e1d9a27ee..33d137a83 100644
--- a/Engine/source/environment/decalRoad.cpp
+++ b/Engine/source/environment/decalRoad.cpp
@@ -320,7 +320,7 @@ void DecalRoad::initPersistFields()
 
    addGroup( "Internal" );
 
-      addProtectedField( "node", TypeString, NULL, &addNodeFromField, &emptyStringProtectedGetFn, 
+      addProtectedField( "node", TypeString, 0, &addNodeFromField, &emptyStringProtectedGetFn,
          "Do not modify, for internal use." );
 
    endGroup( "Internal" );
diff --git a/Engine/source/environment/editors/guiMeshRoadEditorCtrl.cpp b/Engine/source/environment/editors/guiMeshRoadEditorCtrl.cpp
index b0812f738..6433332d7 100644
--- a/Engine/source/environment/editors/guiMeshRoadEditorCtrl.cpp
+++ b/Engine/source/environment/editors/guiMeshRoadEditorCtrl.cpp
@@ -1757,7 +1757,7 @@ DefineEngineMethod( GuiMeshRoadEditorCtrl, getSelectedRoad, S32, (), , "" )
 {
    MeshRoad *road = object->getSelectedRoad();
    if ( !road )
-      return NULL;
+      return 0;
 
    return road->getId();
 }
diff --git a/Engine/source/environment/editors/guiRiverEditorCtrl.cpp b/Engine/source/environment/editors/guiRiverEditorCtrl.cpp
index e650fdf59..983c8a01e 100644
--- a/Engine/source/environment/editors/guiRiverEditorCtrl.cpp
+++ b/Engine/source/environment/editors/guiRiverEditorCtrl.cpp
@@ -1472,7 +1472,7 @@ DefineEngineMethod( GuiRiverEditorCtrl, getSelectedRiver, S32, (), , "" )
 {
    River *river = object->getSelectedRiver();
    if ( !river )
-      return NULL;
+      return 0;
 
    return river->getId();
 }
diff --git a/Engine/source/environment/editors/guiRoadEditorCtrl.cpp b/Engine/source/environment/editors/guiRoadEditorCtrl.cpp
index 3f111a80e..67b6ef883 100644
--- a/Engine/source/environment/editors/guiRoadEditorCtrl.cpp
+++ b/Engine/source/environment/editors/guiRoadEditorCtrl.cpp
@@ -1097,7 +1097,7 @@ DefineEngineMethod( GuiRoadEditorCtrl, getSelectedRoad, S32, (), , "" )
    if ( road )
       return road->getId();
    
-   return NULL;
+   return 0;
 }
 
 DefineEngineMethod( GuiRoadEditorCtrl, getSelectedNode, S32, (), , "" )
diff --git a/Engine/source/environment/meshRoad.cpp b/Engine/source/environment/meshRoad.cpp
index f27d2d84a..01f8017de 100644
--- a/Engine/source/environment/meshRoad.cpp
+++ b/Engine/source/environment/meshRoad.cpp
@@ -954,10 +954,10 @@ void MeshRoad::initPersistFields()
 
    addGroup( "Internal" );
 
-      addProtectedField( "Node", TypeString, NULL, &addNodeFromField, &emptyStringProtectedGetFn, 
+      addProtectedField( "Node", TypeString, 0, &addNodeFromField, &emptyStringProtectedGetFn,
          "Do not modify, for internal use." );
 
-      addProtectedField( "ProfileNode", TypeString, NULL, &addProfileNodeFromField, &emptyStringProtectedGetFn,
+      addProtectedField( "ProfileNode", TypeString, 0, &addProfileNodeFromField, &emptyStringProtectedGetFn,
          "Do not modify, for internal use." );
 
    endGroup( "Internal" );
diff --git a/Engine/source/environment/river.cpp b/Engine/source/environment/river.cpp
index 9bb1d7aac..0213f9d1d 100644
--- a/Engine/source/environment/river.cpp
+++ b/Engine/source/environment/river.cpp
@@ -647,7 +647,7 @@ void River::initPersistFields()
 
    addGroup( "Internal" );
 
-      addProtectedField( "Node", TypeString, NULL, &addNodeFromField, &emptyStringProtectedGetFn, "For internal use, do not modify." );
+      addProtectedField( "Node", TypeString, 0, &addNodeFromField, &emptyStringProtectedGetFn, "For internal use, do not modify." );
 
    endGroup( "Internal" );
 
diff --git a/Engine/source/gfx/bitmap/gBitmap.cpp b/Engine/source/gfx/bitmap/gBitmap.cpp
index 9560586dd..b7045d129 100644
--- a/Engine/source/gfx/bitmap/gBitmap.cpp
+++ b/Engine/source/gfx/bitmap/gBitmap.cpp
@@ -1199,7 +1199,7 @@ bool  GBitmap::readBitmap( const String &bmType, Stream &ioStream )
    if ( regInfo == NULL )
    {
       Con::errorf( "[GBitmap::readBitmap] unable to find registration for extension [%s]", bmType.c_str() );
-      return NULL;
+      return false;
    }
 
    return regInfo->readFunc( ioStream, this );
@@ -1212,7 +1212,7 @@ bool  GBitmap::writeBitmap( const String &bmType, Stream &ioStream, U32 compress
    if ( regInfo == NULL )
    {
       Con::errorf( "[GBitmap::writeBitmap] unable to find registration for extension [%s]", bmType.c_str() );
-      return NULL;
+      return false;
    }
 
    return regInfo->writeFunc( this, ioStream, (compressionLevel == U32_MAX) ? regInfo->defaultCompression : compressionLevel );
diff --git a/Engine/source/gfx/bitmap/loaders/bitmapPng.cpp b/Engine/source/gfx/bitmap/loaders/bitmapPng.cpp
index 65586caa8..9eb1d7b2c 100644
--- a/Engine/source/gfx/bitmap/loaders/bitmapPng.cpp
+++ b/Engine/source/gfx/bitmap/loaders/bitmapPng.cpp
@@ -143,7 +143,7 @@ static bool sReadPNG(Stream &stream, GBitmap *bitmap)
    stream.read(cs_headerBytesChecked, header);
 
    bool isPng = png_check_sig(header, cs_headerBytesChecked) != 0;
-   if (isPng == false) 
+   if (!isPng)
    {
       AssertWarn(false, "GBitmap::readPNG: stream doesn't contain a PNG");
       return false;
diff --git a/Engine/source/gfx/gl/gfxGLCubemap.cpp b/Engine/source/gfx/gl/gfxGLCubemap.cpp
index 99f3f02a8..db23a0fc2 100644
--- a/Engine/source/gfx/gl/gfxGLCubemap.cpp
+++ b/Engine/source/gfx/gl/gfxGLCubemap.cpp
@@ -308,7 +308,7 @@ U8* GFXGLCubemap::getTextureData(U32 face, U32 mip)
 
 GFXGLCubemapArray::GFXGLCubemapArray()
 {
-   mCubemap = NULL;
+   mCubemap = 0;
 }
 
 GFXGLCubemapArray::~GFXGLCubemapArray()
diff --git a/Engine/source/gfx/gl/gfxGLStateBlock.cpp b/Engine/source/gfx/gl/gfxGLStateBlock.cpp
index 5be2e43d5..12eab71b0 100644
--- a/Engine/source/gfx/gl/gfxGLStateBlock.cpp
+++ b/Engine/source/gfx/gl/gfxGLStateBlock.cpp
@@ -101,8 +101,8 @@ void GFXGLStateBlock::activate(const GFXGLStateBlock* oldState)
    // the state value even if that value is identical to the current value.
 
 #define STATE_CHANGE(state) (!oldState || oldState->mDesc.state != mDesc.state)
-#define TOGGLE_STATE(state, enum) if(mDesc.state) glEnable(enum); else glDisable(enum)
-#define CHECK_TOGGLE_STATE(state, enum) if(!oldState || oldState->mDesc.state != mDesc.state) if(mDesc.state) glEnable(enum); else glDisable(enum)
+#define TOGGLE_STATE(state, enum) if(mDesc.state) { glEnable(enum); } else { glDisable(enum); }
+#define CHECK_TOGGLE_STATE(state, enum) if(!oldState || oldState->mDesc.state != mDesc.state) { if(mDesc.state) { glEnable(enum); } else { glDisable(enum); }}
 
    // Blending
    CHECK_TOGGLE_STATE(blendEnable, GL_BLEND);
diff --git a/Engine/source/gfx/gl/gfxGLTextureArray.cpp b/Engine/source/gfx/gl/gfxGLTextureArray.cpp
index f2b403bb0..e0137a448 100644
--- a/Engine/source/gfx/gl/gfxGLTextureArray.cpp
+++ b/Engine/source/gfx/gl/gfxGLTextureArray.cpp
@@ -6,7 +6,7 @@
 
 GFXGLTextureArray::GFXGLTextureArray()
 {
-   mTextureArray = NULL;
+   mTextureArray = 0;
 }
 
 void GFXGLTextureArray::init()
diff --git a/Engine/source/gfx/gl/gfxGLTextureArray.h b/Engine/source/gfx/gl/gfxGLTextureArray.h
index 65e1d9729..7073b1653 100644
--- a/Engine/source/gfx/gl/gfxGLTextureArray.h
+++ b/Engine/source/gfx/gl/gfxGLTextureArray.h
@@ -13,7 +13,7 @@ public:
 
    ~GFXGLTextureArray() { Release(); };
 
-   void init();
+   void init() override;
 
    void setToTexUnit(U32 tuNum) override;
 
diff --git a/Engine/source/gfx/gl/gfxGLTextureObject.cpp b/Engine/source/gfx/gl/gfxGLTextureObject.cpp
index 9eabc8114..1d5c043e4 100644
--- a/Engine/source/gfx/gl/gfxGLTextureObject.cpp
+++ b/Engine/source/gfx/gl/gfxGLTextureObject.cpp
@@ -46,7 +46,7 @@ GFXGLTextureObject::GFXGLTextureObject(GFXDevice * aDevice, GFXTextureProfile *p
 {
 
 #if TORQUE_DEBUG
-   mFrameAllocatorMarkGuard == FrameAllocator::getWaterMark();
+   mFrameAllocatorMarkGuard = FrameAllocator::getWaterMark();
 #endif
 
    dMemset(&mLockedRect, 0, sizeof(mLockedRect));
diff --git a/Engine/source/gfx/sim/cubemapData.cpp b/Engine/source/gfx/sim/cubemapData.cpp
index a6833de5c..bf9390dfe 100644
--- a/Engine/source/gfx/sim/cubemapData.cpp
+++ b/Engine/source/gfx/sim/cubemapData.cpp
@@ -135,7 +135,7 @@ void CubemapData::createMap()
        if( initSuccess )
        {
            mCubemap = GFX->createCubemap();
-           if (mCubeMapFace == NULL || mCubeMapFace->isNull())
+           if (!mCubeMapFace || mCubeMapFace->isNull())
               return;
            mCubemap->initStatic(mCubeMapFace);
        }
diff --git a/Engine/source/gfx/video/videoEncoderTheora.cpp b/Engine/source/gfx/video/videoEncoderTheora.cpp
index d64f76487..ef88787f8 100644
--- a/Engine/source/gfx/video/videoEncoderTheora.cpp
+++ b/Engine/source/gfx/video/videoEncoderTheora.cpp
@@ -226,7 +226,7 @@ public:
          return setStatus(false);
       }
 
-      ogg_stream_init(&to, Platform::getRandom() * S32_MAX);
+      ogg_stream_init(&to, Platform::getRandom() * double(S32_MAX));
 
       ogg_packet op;
 
diff --git a/Engine/source/gui/core/guiCanvas.cpp b/Engine/source/gui/core/guiCanvas.cpp
index 96022edaa..0b894f7c3 100644
--- a/Engine/source/gui/core/guiCanvas.cpp
+++ b/Engine/source/gui/core/guiCanvas.cpp
@@ -2438,7 +2438,7 @@ DefineEngineMethod( GuiCanvas, getMouseControl, S32, (),,
    if (control)
       return control->getId();
    
-   return NULL;
+   return 0;
 }
 
 DefineEngineFunction(excludeOtherInstance, bool, (const char* appIdentifer),,
diff --git a/Engine/source/gui/editor/guiInspector.cpp b/Engine/source/gui/editor/guiInspector.cpp
index 48c4dcc94..47d1e3c85 100644
--- a/Engine/source/gui/editor/guiInspector.cpp
+++ b/Engine/source/gui/editor/guiInspector.cpp
@@ -908,12 +908,12 @@ DefineEngineMethod( GuiInspector, findByObject, S32, (SimObject* obj), ,
 	"@return id of an awake inspector that is inspecting the passed object if one exists, else NULL or 0.")
 {
    if ( !obj)
-      return NULL;
+      return 0;
 
    SimObject *inspector = GuiInspector::findByObject(obj);
 
    if ( !inspector )
-      return NULL;
+      return 0;
 
    return inspector->getId();
 }
diff --git a/Engine/source/gui/editor/guiShapeEdPreview.cpp b/Engine/source/gui/editor/guiShapeEdPreview.cpp
index 5ea20ec13..eba775edb 100644
--- a/Engine/source/gui/editor/guiShapeEdPreview.cpp
+++ b/Engine/source/gui/editor/guiShapeEdPreview.cpp
@@ -160,11 +160,11 @@ void GuiShapeEdPreview::initPersistFields()
    addGroup( "Animation" );
    addField( "activeThread",              TypeS32,    Offset( mActiveThread, GuiShapeEdPreview ),
       "Index of the active thread, or -1 if none" );
-   addProtectedField( "threadPos",        TypeF32,    NULL, &setFieldThreadPos, &getFieldThreadPos,
+   addProtectedField( "threadPos",        TypeF32,    0, &setFieldThreadPos, &getFieldThreadPos,
       "Current position of the active thread (0-1)" );
-   addProtectedField( "threadDirection",  TypeS32,    NULL, &setFieldThreadDir, &getFieldThreadDir,
+   addProtectedField( "threadDirection",  TypeS32,    0, &setFieldThreadDir, &getFieldThreadDir,
       "Playback direction of the active thread" );
-   addProtectedField( "threadPingPong",   TypeBool,   NULL, &setFieldThreadPingPong, &getFieldThreadPingPong,
+   addProtectedField( "threadPingPong",   TypeBool,   0, &setFieldThreadPingPong, &getFieldThreadPingPong,
       "'PingPong' mode of the active thread" );
    endGroup( "Animation" );
 
diff --git a/Engine/source/gui/worldEditor/guiConvexShapeEditorCtrl.h b/Engine/source/gui/worldEditor/guiConvexShapeEditorCtrl.h
index 6ede0cf61..1600a4e50 100644
--- a/Engine/source/gui/worldEditor/guiConvexShapeEditorCtrl.h
+++ b/Engine/source/gui/worldEditor/guiConvexShapeEditorCtrl.h
@@ -248,7 +248,7 @@ class GuiConvexEditorUndoAction : public UndoAction
    friend class GuiConvexEditorCtrl;
 public:
 
-   GuiConvexEditorUndoAction( const UTF8* actionName ) : UndoAction( actionName ), mEditor(NULL), mObjId(NULL)
+   GuiConvexEditorUndoAction( const UTF8* actionName ) : UndoAction( actionName ), mEditor(NULL), mObjId(0)
    {
    }
 
diff --git a/Engine/source/gui/worldEditor/guiMissionArea.h b/Engine/source/gui/worldEditor/guiMissionArea.h
index 885f85107..9c3dec0a5 100644
--- a/Engine/source/gui/worldEditor/guiMissionArea.h
+++ b/Engine/source/gui/worldEditor/guiMissionArea.h
@@ -145,7 +145,7 @@ class GuiMissionAreaUndoAction : public UndoAction
 {
    public:
 
-      GuiMissionAreaUndoAction( const UTF8* actionName ) : UndoAction( actionName ), mMissionAreaEditor(NULL), mObjId(NULL)
+      GuiMissionAreaUndoAction( const UTF8* actionName ) : UndoAction( actionName ), mMissionAreaEditor(NULL), mObjId(0)
       {
       }
 
diff --git a/Engine/source/gui/worldEditor/terrainActions.cpp b/Engine/source/gui/worldEditor/terrainActions.cpp
index 3fc07205d..a6fbb5c21 100644
--- a/Engine/source/gui/worldEditor/terrainActions.cpp
+++ b/Engine/source/gui/worldEditor/terrainActions.cpp
@@ -773,7 +773,7 @@ ConsoleDocClass( TerrainSmoothAction,
 );
 
 TerrainSmoothAction::TerrainSmoothAction()
-   : UndoAction("Terrain Smoothing"), mFactor(1.0), mSteps(1), mTerrainId(NULL)
+   : UndoAction("Terrain Smoothing"), mFactor(1.0), mSteps(1), mTerrainId(0)
 {
 }
 
diff --git a/Engine/source/lighting/advanced/advancedLightBinManager.h b/Engine/source/lighting/advanced/advancedLightBinManager.h
index 4f97e4239..4d04f3cfc 100644
--- a/Engine/source/lighting/advanced/advancedLightBinManager.h
+++ b/Engine/source/lighting/advanced/advancedLightBinManager.h
@@ -70,7 +70,7 @@ protected:
    GFXStateBlockRef mLitState[NUM_LIT_STATES][2];
 
 public:
-   LightMatInstance(Material &mat) : Parent(mat), mLightMapParamsSC(NULL), mInternalPass(false),  mSpecialLight(NULL) {}
+   LightMatInstance(Material &mat) : Parent(mat), mLightMapParamsSC(NULL), mInternalPass(false),  mSpecialLight(false) {}
 
    virtual bool init( const FeatureSet &features, const GFXVertexFormat *vertexFormat );
    virtual bool setupPass( SceneRenderState *state, const SceneData &sgData );
diff --git a/Engine/source/lighting/basic/blTerrainSystem.cpp b/Engine/source/lighting/basic/blTerrainSystem.cpp
index d6fb3f9d5..1cf077575 100644
--- a/Engine/source/lighting/basic/blTerrainSystem.cpp
+++ b/Engine/source/lighting/basic/blTerrainSystem.cpp
@@ -682,9 +682,9 @@ bool blTerrainSystem::createPersistChunkFromProxy(SceneLighting::ObjectProxy* ob
    {
       *ret = new blTerrainChunk();
       return true;
-   } else {
-      return NULL;
    }
+
+   return false;
 }
 
 // Given a ray, this will return the color from the lightmap of this object, return true if handled
diff --git a/Engine/source/materials/materialDefinition.cpp b/Engine/source/materials/materialDefinition.cpp
index 7eb49ffc0..3c3cb5898 100644
--- a/Engine/source/materials/materialDefinition.cpp
+++ b/Engine/source/materials/materialDefinition.cpp
@@ -218,7 +218,7 @@ Material::Material()
    mPlanarReflection = false;
 
    mCubemapData = NULL;
-   mDynamicCubemap = NULL;
+   mDynamicCubemap = false;
 
    mLastUpdateTime = 0;
 
diff --git a/Engine/source/math/mRandom.h b/Engine/source/math/mRandom.h
index c69c06477..dbd4a2328 100644
--- a/Engine/source/math/mRandom.h
+++ b/Engine/source/math/mRandom.h
@@ -54,7 +54,7 @@ public:
 inline F32 MRandomGenerator::randF()
 {
    // default: multiply by 1/(2^31)
-   return F32(randI()) * (1.0f / S32_MAX);
+   return F32(randI()) * (1.0f / F64(S32_MAX));
 }
 
 inline S32 MRandomGenerator::randI(S32 i, S32 n)
diff --git a/Engine/source/navigation/guiNavEditorCtrl.h b/Engine/source/navigation/guiNavEditorCtrl.h
index 4a6780b33..2d4c96bce 100644
--- a/Engine/source/navigation/guiNavEditorCtrl.h
+++ b/Engine/source/navigation/guiNavEditorCtrl.h
@@ -168,7 +168,7 @@ protected:
 class GuiNavEditorUndoAction : public UndoAction
 {
 public:
-   GuiNavEditorUndoAction(const UTF8* actionName) : UndoAction(actionName), mNavEditor(NULL), mObjId(NULL)
+   GuiNavEditorUndoAction(const UTF8* actionName) : UndoAction(actionName), mNavEditor(NULL), mObjId(0)
    {
    }
 
diff --git a/Engine/source/persistence/taml/taml.cpp b/Engine/source/persistence/taml/taml.cpp
index 837843c72..0454e102a 100644
--- a/Engine/source/persistence/taml/taml.cpp
+++ b/Engine/source/persistence/taml/taml.cpp
@@ -335,7 +335,7 @@ ImplementEnumType(_TamlFormatMode,
 
          // Write.
          //return writer.write( stream, pRootNode );
-         return NULL;
+         return false;
       }
 
       /// Invalid.
diff --git a/Engine/source/platform/platformNet.cpp b/Engine/source/platform/platformNet.cpp
index 1e5cb0a5a..db7c26604 100644
--- a/Engine/source/platform/platformNet.cpp
+++ b/Engine/source/platform/platformNet.cpp
@@ -241,7 +241,7 @@ namespace PlatformNetState
 
    struct addrinfo* pickAddressByProtocol(struct addrinfo* addr, int protocol)
    {
-      for (addr; addr != NULL; addr = addr->ai_next)
+      for (; addr != NULL; addr = addr->ai_next)
       {
          if (addr->ai_family == protocol)
             return addr;
diff --git a/Engine/source/platformSDL/sdlInput.cpp b/Engine/source/platformSDL/sdlInput.cpp
index a60a0e7b5..67d86b277 100644
--- a/Engine/source/platformSDL/sdlInput.cpp
+++ b/Engine/source/platformSDL/sdlInput.cpp
@@ -102,7 +102,7 @@ U16 Input::getKeyCode( U16 asciiCode )
 
     char c[2];
     c[0]= asciiCode;
-    c[1] = NULL;
+    c[1] = 0;
     return KeyMapSDL::getTorqueScanCodeFromSDL( SDL_GetScancodeFromKey( SDL_GetKeyFromName(c) ) );
 }
 
diff --git a/Engine/source/platformX86UNIX/x86UNIXFileio.cpp b/Engine/source/platformX86UNIX/x86UNIXFileio.cpp
index 77419a96a..eee06a84e 100644
--- a/Engine/source/platformX86UNIX/x86UNIXFileio.cpp
+++ b/Engine/source/platformX86UNIX/x86UNIXFileio.cpp
@@ -594,20 +594,20 @@ bool dPathCopy(const char *fromName, const char *toName, bool nooverwrite)
          return currentStatus;
 
      U32 finalPos = 0;
-     switch (absolutePos)
+
+     if (absolutePos)
      {
-     case true:                                                    // absolute position
          AssertFatal(0 <= position, "File::setPosition: negative absolute position");
 
          // position beyond EOS is OK
          finalPos = lseek(*((int *)handle), position, SEEK_SET);
-         break;
-     case false:                                                    // relative position
+     }
+     else
+     {
          AssertFatal((getPosition() >= (U32)abs(position) && 0 > position) || 0 <= position, "File::setPosition: negative relative position");
 
          // position beyond EOS is OK
          finalPos = lseek(*((int *)handle), position, SEEK_CUR);
- 	break;
      }
 
      if (0xffffffff == finalPos)
@@ -1110,7 +1110,7 @@ bool dPathCopy(const char *fromName, const char *toName, bool nooverwrite)
    if (dip == NULL)
      return false;
 
-   while (d = readdir(dip))
+   while ((d = readdir(dip)))
      {
 	bool isDir = false;
 	if (d->d_type == DT_UNKNOWN)
@@ -1229,14 +1229,14 @@ bool dPathCopy(const char *fromName, const char *toName, bool nooverwrite)
    // Iterate through and grab valid directories
    //////////////////////////////////////////////////////////////////////////
 
-	while (d = readdir(dip))
+	while ((d = readdir(dip)))
 	{
 		bool	isDir;
 		isDir = false;
 		if (d->d_type == DT_UNKNOWN)
 		{
 			char child [1024];
-			if ((Path[dStrlen(Path) - 1] == '/'))
+			if (Path[dStrlen(Path) - 1] == '/')
 				dSprintf(child, 1024, "%s%s", Path, d->d_name);
 			else
 				dSprintf(child, 1024, "%s/%s", Path, d->d_name);
diff --git a/Engine/source/renderInstance/renderImposterMgr.cpp b/Engine/source/renderInstance/renderImposterMgr.cpp
index d93c6c620..e0b8b3156 100644
--- a/Engine/source/renderInstance/renderImposterMgr.cpp
+++ b/Engine/source/renderInstance/renderImposterMgr.cpp
@@ -152,7 +152,7 @@ void RenderImposterMgr::_innerRender( const SceneRenderState *state, RenderDefer
       // Setup a static index buffer for rendering.
       mIB.set( GFX, smImposterBatchSize * 6, 0, GFXBufferTypeStatic );
       U16 *idxBuff;
-      mIB.lock(&idxBuff, NULL, NULL, NULL);
+      mIB.lock(&idxBuff, NULL, 0, 0);
       for ( U32 i=0; i < smImposterBatchSize; i++ )
       {
          //
diff --git a/Engine/source/renderInstance/renderPassStateToken.cpp b/Engine/source/renderInstance/renderPassStateToken.cpp
index 560fb40f3..c00b05cdf 100644
--- a/Engine/source/renderInstance/renderPassStateToken.cpp
+++ b/Engine/source/renderInstance/renderPassStateToken.cpp
@@ -86,7 +86,7 @@ static const char *_get_enable(void* obj, const char* data)
 
 void RenderPassStateToken::initPersistFields()
 {
-   addProtectedField("enabled", TypeBool, NULL, &_set_enable, &_get_enable, "Enables or disables this token.");
+   addProtectedField("enabled", TypeBool, 0, &_set_enable, &_get_enable, "Enables or disables this token.");
    Parent::initPersistFields();
 }
 
diff --git a/Engine/source/scene/mixin/scenePolyhedralObject.impl.h b/Engine/source/scene/mixin/scenePolyhedralObject.impl.h
index 4ce8998f0..32ec98e71 100644
--- a/Engine/source/scene/mixin/scenePolyhedralObject.impl.h
+++ b/Engine/source/scene/mixin/scenePolyhedralObject.impl.h
@@ -44,15 +44,15 @@ void ScenePolyhedralObject< Base, P >::initPersistFields()
 {
    Parent::addGroup( "Internal" );
 
-      Parent::addProtectedField( "plane", TypeRealString, NULL,
+      Parent::addProtectedField( "plane", TypeRealString, 0,
          &_setPlane, &defaultProtectedGetFn,
          "For internal use only.",
          AbstractClassRep::FIELD_HideInInspectors );
-      Parent::addProtectedField( "point", TypeRealString, NULL,
+      Parent::addProtectedField( "point", TypeRealString, 0,
          &_setPoint, &defaultProtectedGetFn,
          "For internal use only.",
          AbstractClassRep::FIELD_HideInInspectors );
-      Parent::addProtectedField( "edge", TypeRealString, NULL,
+      Parent::addProtectedField( "edge", TypeRealString, 0,
          &_setEdge, &defaultProtectedGetFn,
          "For internal use only.",
          AbstractClassRep::FIELD_HideInInspectors );
diff --git a/Engine/source/sim/actionMap.cpp b/Engine/source/sim/actionMap.cpp
index 40a41aa06..117278aff 100644
--- a/Engine/source/sim/actionMap.cpp
+++ b/Engine/source/sim/actionMap.cpp
@@ -1962,7 +1962,7 @@ void ContextAction::processTick()
    if (mActive)
    {
       F32 currTime = Sim::getCurrentTime();
-      static const char *argv[2];
+      static const char *argv[3];
 
       //see if this key even is still active  
       if (!mBreakEvent)
diff --git a/Engine/source/sim/actionMap.h b/Engine/source/sim/actionMap.h
index 26caffe7b..840dd70f9 100644
--- a/Engine/source/sim/actionMap.h
+++ b/Engine/source/sim/actionMap.h
@@ -92,7 +92,7 @@ class ActionMap : public SimObject
       U32 deviceInst;
 
       Vector<Node> nodeMap;
-      DeviceMap():deviceType(NULL), deviceInst(NULL){
+      DeviceMap():deviceType(0), deviceInst(0){
          VECTOR_SET_ASSOCIATION(nodeMap);
       }
       ~DeviceMap();
diff --git a/Engine/source/sim/netObject.cpp b/Engine/source/sim/netObject.cpp
index 25c5e3657..0a33379ec 100644
--- a/Engine/source/sim/netObject.cpp
+++ b/Engine/source/sim/netObject.cpp
@@ -407,7 +407,7 @@ DefineEngineMethod( NetObject, getClientObject, S32, (),,
 	if ( obj )
 		return obj->getId();
 	
-	return NULL;
+	return 0;
 }
 
 //ConsoleMethod( NetObject, getClientObject, S32, 2, 2, "Short-Circuit-Netorking: this is only valid for a local-client / singleplayer situation." )
@@ -439,7 +439,7 @@ DefineEngineMethod( NetObject, getServerObject, S32, (),,
 	if ( obj )
 		return obj->getId();
 	
-	return NULL;
+	return 0;
 }
 
 //ConsoleMethod( NetObject, getServerObject, S32, 2, 2, "Short-Circuit-Netorking: this is only valid for a local-client / singleplayer situation." )
diff --git a/Engine/source/ts/tsShape.cpp b/Engine/source/ts/tsShape.cpp
index b3026a98a..36825014b 100644
--- a/Engine/source/ts/tsShape.cpp
+++ b/Engine/source/ts/tsShape.cpp
@@ -74,7 +74,7 @@ TSShape::TSShape()
    mRadius = 0;
    mFlags = 0;
    tubeRadius = 0;
-   data = NULL;
+   data = 0;
    materialList = NULL;
    mReadVersion = -1; // -1 means constructed from scratch (e.g., in exporter or no read yet)
    mSequencesConstructed = false;
@@ -225,11 +225,7 @@ const String& TSShape::getTargetName( S32 mapToNameIndex ) const
 
 S32 TSShape::getTargetCount() const
 {
-	if(!this)
-		return -1;
-
 	return materialList->getMaterialNameList().size();
-
 }
 
 S32 TSShape::findNode(S32 nameIndex) const
diff --git a/Engine/source/ts/tsShapeConstruct.cpp b/Engine/source/ts/tsShapeConstruct.cpp
index 08dbc21c2..6f53670b8 100644
--- a/Engine/source/ts/tsShapeConstruct.cpp
+++ b/Engine/source/ts/tsShapeConstruct.cpp
@@ -357,7 +357,7 @@ void TSShapeConstructor::initPersistFields()
    endGroup("Collada");
 
    addGroup("Sequences");
-   addProtectedField("sequence", TypeStringFilename, NULL, &addSequenceFromField, &emptyStringProtectedGetFn,
+   addProtectedField("sequence", TypeStringFilename, 0, &addSequenceFromField, &emptyStringProtectedGetFn,
       "Legacy method of adding sequences to a DTS or DAE shape after loading.\n\n"
       "@tsexample\n"
       "singleton TSShapeConstructor(MyShapeDae)\n"

From eb8434c5a447b30886d94d54c04e7e3dd4edfeab Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Tue, 5 Oct 2021 00:23:26 -0500
Subject: [PATCH 152/399] don't try and sort ribbon particles

---
 Engine/source/T3D/fx/particleEmitter.cpp | 37 +++---------------------
 1 file changed, 4 insertions(+), 33 deletions(-)

diff --git a/Engine/source/T3D/fx/particleEmitter.cpp b/Engine/source/T3D/fx/particleEmitter.cpp
index c60dc6d49..79d2e6f1d 100644
--- a/Engine/source/T3D/fx/particleEmitter.cpp
+++ b/Engine/source/T3D/fx/particleEmitter.cpp
@@ -1908,50 +1908,21 @@ void ParticleEmitter::copyToVB( const Point3F &camPos, const LinearColorF &ambie
 
       if (mDataBlock->reverseOrder)
       {
-         buffPtr += 4 * (n_parts - 1);
-         // do sorted-oriented particles
-         if (mDataBlock->sortParticles)
-         {
-            SortParticle* partPtr = orderedVector.address();
-            for (U32 i = 0; i < n_parts - 1; i++, partPtr++, buffPtr -= 4)
-            {
-                SortParticle* part = partPtr;
-                partPtr++;
-                setupRibbon(part->p, partPtr->p, partPtr->p, camPos, ambientColor, buffPtr);
-            }
-         }
-         // do unsorted-oriented particles
-         else
-         {
             Particle* oldPtr = NULL;
-            for (Particle* partPtr = part_list_head.next; partPtr != NULL; partPtr = partPtr->next, buffPtr -= 4) {
+            for (Particle* partPtr = part_list_head.next; partPtr != NULL; partPtr = partPtr->next, buffPtr -= 4)
+            {
                setupRibbon(partPtr, partPtr->next, oldPtr, camPos, ambientColor, buffPtr);
                oldPtr = partPtr;
             }
-         }
       }
       else
       {
-         // do sorted-oriented particles
-         if (mDataBlock->sortParticles)
-         {
-            SortParticle* partPtr = orderedVector.address();
-            for (U32 i = 0; i < n_parts - 1; i++, partPtr++, buffPtr += 4)
-            {
-                SortParticle* part = partPtr;
-                partPtr++;
-                setupRibbon(part->p, partPtr->p, partPtr->p, camPos, ambientColor, buffPtr);
-            }
-         }
-         // do unsorted-oriented particles
-         else
-         {
             Particle* oldPtr = NULL;
-            for (Particle* partPtr = part_list_head.next; partPtr != NULL; partPtr = partPtr->next, buffPtr += 4) {
+            for (Particle* partPtr = part_list_head.next; partPtr != NULL; partPtr = partPtr->next, buffPtr += 4)
+            {
                setupRibbon(partPtr, partPtr->next, oldPtr, camPos, ambientColor, buffPtr);
                oldPtr = partPtr;
             }
-         }
       }
       PROFILE_END();
    }

From 42e90ad3fb7cbb5b5fa9c78baa8875e4ea2e8d46 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Tue, 5 Oct 2021 14:46:37 -0500
Subject: [PATCH 153/399] RTLightingFeat work. 1) we do *not* in fact want to
 early out in the presence of MFT_ImposterVert. it mangles the position-send.
 2) dx sucessfuly handles the    if ( !fd.features[MFT_NormalMap] ) case, so
 use the same for gl

---
 Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp | 6 ++----
 Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp | 3 ---
 2 files changed, 2 insertions(+), 7 deletions(-)

diff --git a/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp b/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
index 73bb56fd1..6df9a01bf 100644
--- a/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
+++ b/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
@@ -2070,7 +2070,6 @@ RTLightingFeatGLSL::RTLightingFeatGLSL()
 void RTLightingFeatGLSL::processVert(  Vector<ShaderComponent*> &componentList, 
                                        const MaterialFeatureData &fd )
 {
-   if (fd.features[MFT_ImposterVert]) return;
 	MultiLine *meta = new MultiLine;
 	
 	ShaderConnector *connectComp = dynamic_cast<ShaderConnector *>( componentList[C_CONNECTOR] );
@@ -2124,8 +2123,7 @@ void RTLightingFeatGLSL::processVert(  Vector<ShaderComponent*> &componentList,
 	
    // If there isn't a normal map then we need to pass
    // the world space normal to the pixel shader ourselves.
-   //Temporarily disabled while we figure out how to better handle normals without a normal map
-   /*if ( !fd.features[MFT_NormalMap] )
+   if ( !fd.features[MFT_NormalMap] )
    {
       Var *outNormal = connectComp->getElement( RT_TEXCOORD );
       outNormal->setName( "wsNormal" );
@@ -2137,7 +2135,7 @@ void RTLightingFeatGLSL::processVert(  Vector<ShaderComponent*> &componentList,
    
       // Transform the normal to world space.
       meta->addStatement( new GenOp( "   @ = tMul( @, vec4( normalize( @ ), 0.0 ) ).xyz;\r\n", outNormal, objTrans, inNormal ) );
-   }*/
+   }
 
 }
 
diff --git a/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp b/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
index ecd4619d0..eae07aa95 100644
--- a/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
+++ b/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
@@ -2136,8 +2136,6 @@ RTLightingFeatHLSL::RTLightingFeatHLSL()
 void RTLightingFeatHLSL::processVert(  Vector<ShaderComponent*> &componentList, 
                                        const MaterialFeatureData &fd )
 {
-   if (fd.features[MFT_ImposterVert]) return;
-
    MultiLine *meta = new MultiLine;   
 
    ShaderConnector *connectComp = dynamic_cast<ShaderConnector *>( componentList[C_CONNECTOR] );
@@ -2192,7 +2190,6 @@ void RTLightingFeatHLSL::processVert(  Vector<ShaderComponent*> &componentList,
 
    // If there isn't a normal map then we need to pass
    // the world space normal to the pixel shader ourselves.
-   //Temporarily disabled while we figure out how to better handle normals without a normal map
    if ( !fd.features[MFT_NormalMap] )
    {
       Var *outNormal = connectComp->getElement( RT_TEXCOORD );

From 070a3a30b60bea1c7d14a5bd1a5e5f5aa00bcaf3 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Wed, 6 Oct 2021 00:35:38 -0400
Subject: [PATCH 154/399] * [Linux] BugFix: Free the mouse cursor when
 triggering SIGTRAP on Linux to ensure that the cursor is available for
 debugging.

---
 .../source/platformX86UNIX/x86UNIXProcessControl.cpp  | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/Engine/source/platformX86UNIX/x86UNIXProcessControl.cpp b/Engine/source/platformX86UNIX/x86UNIXProcessControl.cpp
index 09c59af4d..db7d0bdb7 100644
--- a/Engine/source/platformX86UNIX/x86UNIXProcessControl.cpp
+++ b/Engine/source/platformX86UNIX/x86UNIXProcessControl.cpp
@@ -24,6 +24,8 @@
 #include "platformX86UNIX/x86UNIXState.h"
 #include "platformX86UNIX/x86UNIXStdConsole.h"
 #include "platform/platformInput.h"
+#include "windowManager/platformWindow.h"
+#include "windowManager/platformWindowMgr.h"
 #include "console/console.h"
 
 #include <stdlib.h>
@@ -165,6 +167,15 @@ void Platform::debugBreak()
    Con::errorf(ConsoleLogEntry::General, 
       "Platform::debugBreak: triggering SIGSEGV for core dump");
    //kill(getpid(), SIGSEGV);
+
+   // On Linux, the mouse cursor will remain trapped when the SIGTRAP below triggers so we ensure the mouse
+   // locked state is disabled prior to dropping to debug
+   PlatformWindow* firstWindow = WindowManager->getFirstWindow();
+   if (firstWindow)
+   {
+       firstWindow->setMouseLocked(false);
+   }
+
    kill(getpid(), SIGTRAP);
 }
 

From 24bf807713a3a361406ae3365a5483b8e0be68cd Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Wed, 6 Oct 2021 21:53:26 -0400
Subject: [PATCH 155/399] various shadergen fixes.

---
 .../shaderGen/GLSL/shaderFeatureGLSL.cpp      |  1 +
 .../shaderGen/HLSL/shaderFeatureHLSL.cpp      |  8 ++++
 .../source/terrain/glsl/terrFeatureGLSL.cpp   | 41 +++++++++++--------
 3 files changed, 34 insertions(+), 16 deletions(-)

diff --git a/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp b/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
index 6df9a01bf..b41dfc234 100644
--- a/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
+++ b/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
@@ -1982,6 +1982,7 @@ void ReflectCubeFeatGLSL::processPix(  Vector<ShaderComponent*> &componentList,
          Var *envColor = new Var("envColor", "vec3");
          meta->addStatement(new GenOp("   @ = @.rgb - (@.rgb * @);\r\n", new DecOp(dColor), targ, targ, metalness));
          meta->addStatement(new GenOp("   @ = @.rgb*(@).rgb;\r\n", new DecOp(envColor), targ, texCube));
+         meta->addStatement(new GenOp("   @.rgb = @+@;\r\n", targ, dColor, envColor));
       }
       else if (lerpVal)
          meta->addStatement(new GenOp("   @ *= vec4(@.rgb*@.a, @.a);\r\n", targ, texCube, lerpVal, targ));
diff --git a/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp b/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
index eae07aa95..0b5f79e4d 100644
--- a/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
+++ b/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
@@ -892,6 +892,14 @@ Var* ShaderFeatureHLSL::getSurface(Vector<ShaderComponent*>& componentList, Mult
    }
 
    Var* wsEyePos = (Var*)LangElement::find("eyePosWorld");
+
+   if (!wsEyePos)
+   {
+      wsEyePos = new Var("eyePosWorld", "float3");
+      wsEyePos->uniform = true;
+      wsEyePos->constSortPos = cspPass;
+   }
+
    Var* wsPosition = getInWsPosition(componentList);
    Var* wsView = getWsView(wsPosition, meta);
 
diff --git a/Engine/source/terrain/glsl/terrFeatureGLSL.cpp b/Engine/source/terrain/glsl/terrFeatureGLSL.cpp
index d30e639ec..3b66006ce 100644
--- a/Engine/source/terrain/glsl/terrFeatureGLSL.cpp
+++ b/Engine/source/terrain/glsl/terrFeatureGLSL.cpp
@@ -281,6 +281,8 @@ void TerrainBaseMapFeatGLSL::processVert( Vector<ShaderComponent*> &componentLis
    Var *squareSize = _getUniformVar( "squareSize", "float", cspPass );
    meta->addStatement( new GenOp( "   @ = normalize( vec3( @, 0, @ ) );\r\n", 
       new DecOp( inTanget ), squareSize, inTangentZ ) );
+
+   getOutViewToTangent(componentList, meta, fd);
 }
 
 void TerrainBaseMapFeatGLSL::processPix(  Vector<ShaderComponent*> &componentList, 
@@ -331,6 +333,8 @@ void TerrainBaseMapFeatGLSL::processPix(  Vector<ShaderComponent*> &componentLis
    meta->addStatement(new GenOp("   @ = float4(0.0, 1.0, 1.0, 0.0);\r\n", ormConfig));
 
    output = meta;
+
+   Var* viewToTangent = getInViewToTangent(componentList);
 }
 
 ShaderFeature::Resources TerrainBaseMapFeatGLSL::getResources( const MaterialFeatureData &fd )
@@ -781,6 +785,22 @@ void TerrainMacroMapFeatGLSL::processPix(   Vector<ShaderComponent*> &componentL
    meta->addStatement( new GenOp( "   @ = calcBlend( @.x, @.xy, @, @ );\r\n", 
                                     new DecOp( detailBlend ), detailInfo, inTex, layerSize, layerSample ) );
 
+   // Check to see if we have a gbuffer normal.
+   Var* gbNormal = (Var*)LangElement::find("gbNormal");
+
+   // If we have a gbuffer normal and we don't have a
+   // normal map feature then we need to lerp in a 
+   // default normal else the normals below this layer
+   // will show thru.
+   if (gbNormal &&
+      !fd.features.hasFeature(MFT_TerrainNormalMap, detailIndex))
+   {
+      Var* viewToTangent = getInViewToTangent(componentList);
+
+      meta->addStatement(new GenOp("   @ = lerp( @, @[2], min( @, @.w ) );\r\n",
+         gbNormal, gbNormal, viewToTangent, detailBlend, inDet));
+   }
+
    Var *detailColor = (Var*)LangElement::find( "macroColor" ); 
    if ( !detailColor )
    {
@@ -1224,21 +1244,7 @@ void TerrainORMMapFeatGLSL::processPix(Vector<ShaderComponent*> &componentList,
 ShaderFeature::Resources TerrainORMMapFeatGLSL::getResources(const MaterialFeatureData &fd)
 {
    Resources res;
-
-   S32 featureIndex = 0, firstOrmMapIndex = 0;
-   for (int idx = 0; idx < fd.features.getCount(); ++idx) {
-      const FeatureType& type = fd.features.getAt(idx, &featureIndex);
-      if (type == MFT_TerrainORMMap) {
-         firstOrmMapIndex = getMin(firstOrmMapIndex, featureIndex);
-      }
-   }
-
-   // We only need to process normals during the deferred.
-   if (getProcessIndex() == firstOrmMapIndex)
-   {
-      res.numTexReg = 1;
-      res.numTex = 1;
-   }
+   res.numTex = 1;
    return res;
 }
 
@@ -1283,7 +1289,10 @@ void TerrainBlankInfoMapFeatGLSL::processPix(Vector<ShaderComponent*> &component
 
    String matinfoName(String::ToString("matinfoCol%d", compositeIndex));
 
-   meta->addStatement(new GenOp("   @.gba += vec3(@, @, 0.0);\r\n", ormConfig, detailBlend, detailBlend));
+   if (!fd.features.hasFeature(MFT_TerrainHeightBlend))
+   {
+      meta->addStatement(new GenOp("   @.gba += vec3(@, @, 0.0);\r\n", ormConfig, detailBlend, detailBlend));
+   }
 
    output = meta;
 }

From 5d26dba7da4967f7a0845a9b2f61e3cb5c55f81c Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Thu, 7 Oct 2021 00:27:39 -0400
Subject: [PATCH 156/399] * BugFix: Clear some MSVC compiler warnings.

---
 Engine/source/T3D/convexShape.cpp             | 17 --------
 Engine/source/T3D/lighting/IBLUtilities.cpp   |  2 -
 Engine/source/T3D/shapeImage.cpp              |  1 -
 Engine/source/console/SimXMLDocument.cpp      |  1 -
 Engine/source/console/astNodes.cpp            |  6 +--
 Engine/source/console/compiledEval.cpp        |  5 +--
 Engine/source/environment/cloudLayer.cpp      |  1 -
 Engine/source/environment/meshRoad.cpp        |  1 -
 Engine/source/forest/forestItem.cpp           |  2 -
 Engine/source/gfx/D3D11/gfxD3D11Cubemap.cpp   |  3 --
 .../gui/controls/guiGameListMenuCtrl.cpp      |  9 -----
 Engine/source/gui/controls/guiPopUpCtrl.cpp   |  1 -
 Engine/source/gui/controls/guiPopUpCtrlEx.cpp |  1 -
 .../gui/utility/guiRenderTargetVizCtrl.cpp    |  2 -
 .../advanced/advancedLightBinManager.cpp      |  2 -
 .../materials/processedShaderMaterial.cpp     |  7 ----
 Engine/source/persistence/taml/taml.cpp       |  2 +-
 .../source/platform/async/asyncPacketStream.h |  2 +-
 Engine/source/platform/platformNet.cpp        | 40 +++----------------
 .../renderInstance/renderTranslucentMgr.cpp   |  1 -
 Engine/source/terrain/terrCellMaterial.cpp    |  2 -
 Engine/source/terrain/terrData.cpp            |  3 --
 Engine/source/ts/tsCollision.cpp              | 24 +++++------
 23 files changed, 24 insertions(+), 111 deletions(-)

diff --git a/Engine/source/T3D/convexShape.cpp b/Engine/source/T3D/convexShape.cpp
index e0184f2f4..729548ce7 100644
--- a/Engine/source/T3D/convexShape.cpp
+++ b/Engine/source/T3D/convexShape.cpp
@@ -222,7 +222,6 @@ bool ConvexShape::protectedSetSurface( void *object, const char *index, const ch
 	*/
 
    String t = data;
-   S32 len = t.length();
 
 	dSscanf( data, "%g %g %g %g %g %g %g %i %g %g %g %g %f", &quat.x, &quat.y, &quat.z, &quat.w, &pos.x, &pos.y, &pos.z,
       &matID, &offset.x, &offset.y, &scale.x, &scale.y, &rot);
@@ -961,17 +960,6 @@ bool ConvexShape::castRay( const Point3F &start, const Point3F &end, RayInfo *in
    VectorF rayDir( end - start );
    rayDir.normalizeSafe();
 
-   if ( false )
-   {
-      PlaneF plane( Point3F(0,0,0), Point3F(0,0,1) );
-      Point3F sp( 0,0,-1 );
-      Point3F ep( 0,0,1 );
-
-      F32 t = plane.intersect( sp, ep );
-      Point3F hitPnt;
-      hitPnt.interpolate( sp, ep, t );
-   }
-
    for ( S32 i = 0; i < planeCount; i++ )
    {
       // Don't hit the back-side of planes.
@@ -1376,8 +1364,6 @@ void ConvexShape::_updateGeometry( bool updateCollision )
 	{
       U32 count = faceList[i].triangles.size();
 
-      S32 matID = mSurfaceUVs[i].matID;
-
       mSurfaceBuffers[mSurfaceUVs[i].matID].mPrimCount += count;
       mSurfaceBuffers[mSurfaceUVs[i].matID].mVertCount += count * 3;
 	}
@@ -1429,9 +1415,6 @@ void ConvexShape::_updateGeometry( bool updateCollision )
    {
       if (mSurfaceBuffers[i].mVertCount > 0)
       {
-         U32 primCount = mSurfaceBuffers[i].mPrimCount;
-         U32 vertCount = mSurfaceBuffers[i].mVertCount;
-
          mSurfaceBuffers[i].mVertexBuffer.set(GFX, mSurfaceBuffers[i].mVertCount, GFXBufferTypeStatic);
          VertexType *pVert = mSurfaceBuffers[i].mVertexBuffer.lock();
 
diff --git a/Engine/source/T3D/lighting/IBLUtilities.cpp b/Engine/source/T3D/lighting/IBLUtilities.cpp
index f3b7c477c..5cdf27acb 100644
--- a/Engine/source/T3D/lighting/IBLUtilities.cpp
+++ b/Engine/source/T3D/lighting/IBLUtilities.cpp
@@ -46,7 +46,6 @@ namespace IBLUtilities
       }
 
       GFXShaderConstBufferRef irrConsts = irrShader->allocConstBuffer();
-      GFXShaderConstHandle* irrEnvMapSC = irrShader->getShaderConstHandle("$environmentMap");
       GFXShaderConstHandle* irrFaceSC = irrShader->getShaderConstHandle("$face");
 
       GFXStateBlockDesc desc;
@@ -132,7 +131,6 @@ namespace IBLUtilities
       }
 
       GFXShaderConstBufferRef prefilterConsts = prefilterShader->allocConstBuffer();
-      GFXShaderConstHandle* prefilterEnvMapSC = prefilterShader->getShaderConstHandle("$environmentMap");
       GFXShaderConstHandle* prefilterFaceSC = prefilterShader->getShaderConstHandle("$face");
       GFXShaderConstHandle* prefilterRoughnessSC = prefilterShader->getShaderConstHandle("$roughness");
       GFXShaderConstHandle* prefilterMipSizeSC = prefilterShader->getShaderConstHandle("$mipSize");
diff --git a/Engine/source/T3D/shapeImage.cpp b/Engine/source/T3D/shapeImage.cpp
index 7bd42bea5..b8ea08a75 100644
--- a/Engine/source/T3D/shapeImage.cpp
+++ b/Engine/source/T3D/shapeImage.cpp
@@ -407,7 +407,6 @@ bool ShapeBaseImageData::preload(bool server, String &errorStr)
 {
    if (!Parent::preload(server, errorStr))
       return false;
-   bool shapeError = false;
 
    // Resolve objects transmitted from server
    if (!server) {
diff --git a/Engine/source/console/SimXMLDocument.cpp b/Engine/source/console/SimXMLDocument.cpp
index 9f0bd4ff4..6e0de4c19 100644
--- a/Engine/source/console/SimXMLDocument.cpp
+++ b/Engine/source/console/SimXMLDocument.cpp
@@ -827,7 +827,6 @@ void SimXMLDocument::setObjectAttributes(const char* objectID)
 
    char textbuf[1024];
    tinyxml2::XMLElement* field = m_qDocument->NewElement("Field");
-   tinyxml2::XMLElement* group = m_qDocument->NewElement("FieldGroup");
    pElement->SetAttribute( "Name", pObject->getName() );
 
 
diff --git a/Engine/source/console/astNodes.cpp b/Engine/source/console/astNodes.cpp
index aaca1ea06..c34c4b38d 100644
--- a/Engine/source/console/astNodes.cpp
+++ b/Engine/source/console/astNodes.cpp
@@ -74,7 +74,7 @@ void StmtNode::addBreakLine(CodeStream& code)
 
 //------------------------------------------------------------
 
-StmtNode::StmtNode()
+StmtNode::StmtNode() : dbgLineNumber(0)
 {
    next = NULL;
    dbgFileName = CodeBlock::smCurrentParser->getCurrentFile();
@@ -84,12 +84,12 @@ void StmtNode::setPackage(StringTableEntry)
 {
 }
 
-void StmtNode::append(StmtNode* next)
+void StmtNode::append(StmtNode* appended)
 {
    StmtNode* walk = this;
    while (walk->next)
       walk = walk->next;
-   walk->next = next;
+   walk->next = appended;
 }
 
 
diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index 360c13c90..e9862c7ee 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -717,7 +717,7 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
       TelDebugger->pushStackFrame();
 
    StringTableEntry var, objParent;
-   U32 failJump;
+   U32 failJump = 0;
    StringTableEntry fnName;
    StringTableEntry fnNamespace, fnPackage;
 
@@ -776,7 +776,6 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
             fnNamespace = CodeToSTE(code, ip + 2);
             fnPackage = CodeToSTE(code, ip + 4);
             bool hasBody = (code[ip + 6] & 0x01) != 0;
-            U32 lineNumber = code[ip + 6] >> 1;
 
             Namespace::unlinkPackages();
             if (fnNamespace == NULL && fnPackage == NULL)
@@ -1819,8 +1818,6 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          // it handles this method.  It is set to an enum from the table
          // above indicating whether it handles it on a component it owns
          // or just on the object.
-         S32 routingId = 0;
-
          fnName = CodeToSTE(code, ip);
          fnNamespace = CodeToSTE(code, ip + 2);
          U32 callType = code[ip + 4];
diff --git a/Engine/source/environment/cloudLayer.cpp b/Engine/source/environment/cloudLayer.cpp
index 01e55dc6e..29d2ab502 100644
--- a/Engine/source/environment/cloudLayer.cpp
+++ b/Engine/source/environment/cloudLayer.cpp
@@ -278,7 +278,6 @@ void CloudLayer::unpackUpdate( NetConnection *conn, BitStream *stream )
 
    stream->read( &mBaseColor );
 
-   F32 oldCoverage = mCoverage;
    stream->read( &mCoverage );
    stream->read( &mExposure );
 
diff --git a/Engine/source/environment/meshRoad.cpp b/Engine/source/environment/meshRoad.cpp
index 01f8017de..84cbb2d0f 100644
--- a/Engine/source/environment/meshRoad.cpp
+++ b/Engine/source/environment/meshRoad.cpp
@@ -2896,7 +2896,6 @@ void MeshRoad::_generateVerts()
 
    // Make Primitive Buffers   
    U32 p00, p01, p11, p10;
-   U32 pb00, pb01, pb11, pb10;
    U32 offset = 0;
    U16 *pIdx = NULL;   
    U32 curIdx = 0; 
diff --git a/Engine/source/forest/forestItem.cpp b/Engine/source/forest/forestItem.cpp
index 11d514b34..36ac0dfe3 100644
--- a/Engine/source/forest/forestItem.cpp
+++ b/Engine/source/forest/forestItem.cpp
@@ -190,8 +190,6 @@ void ForestItemData::unpackData(BitStream* stream)
    stream->read( &localName );
    setInternalName( localName );
 
-   char readBuffer[1024];
-
    UNPACKDATA_SHAPEASSET(Shape);
    
    mCollidable = stream->readFlag();
diff --git a/Engine/source/gfx/D3D11/gfxD3D11Cubemap.cpp b/Engine/source/gfx/D3D11/gfxD3D11Cubemap.cpp
index 562ab7b63..ed10be7bd 100644
--- a/Engine/source/gfx/D3D11/gfxD3D11Cubemap.cpp
+++ b/Engine/source/gfx/D3D11/gfxD3D11Cubemap.cpp
@@ -528,9 +528,6 @@ void GFXD3D11CubemapArray::init(const U32 cubemapCount, const U32 cubemapFaceSiz
 
 void GFXD3D11CubemapArray::updateTexture(const GFXCubemapHandle &cubemap, const U32 slot)
 {
-   U32 cubeMapSz = cubemap->getSize();
-   U32 cubeMapSize = cubemap->getMipMapLevels();
-
    AssertFatal(slot <= mNumCubemaps, "GFXD3D11CubemapArray::updateTexture - trying to update a cubemap texture that is out of bounds!");
    AssertFatal(mFormat == cubemap->getFormat(), "GFXD3D11CubemapArray::updateTexture - Destination format doesn't match");
    AssertFatal(mSize == cubemap->getSize(), "GFXD3D11CubemapArray::updateTexture - Destination size doesn't match");
diff --git a/Engine/source/gui/controls/guiGameListMenuCtrl.cpp b/Engine/source/gui/controls/guiGameListMenuCtrl.cpp
index 72b3d02f2..33efb32d8 100644
--- a/Engine/source/gui/controls/guiGameListMenuCtrl.cpp
+++ b/Engine/source/gui/controls/guiGameListMenuCtrl.cpp
@@ -275,8 +275,6 @@ void GuiGameListMenuCtrl::onRenderSliderOption(Row* row, Point2I currentOffset)
    Point2I arrowOffset;
    S32 columnSplit = profile->mColumnSplit * xScale;
 
-   S32 iconIndex;
-
    bool isRowSelected = (getSelected() != NO_ROW) && (row == mRows[getSelected()]);
    bool isRowHighlighted = (getHighlighted() != NO_ROW) ? ((row == mRows[getHighlighted()]) && (row->mEnabled)) : false;
    /*if (profileHasArrows)
@@ -384,8 +382,6 @@ void GuiGameListMenuCtrl::onRenderKeybindOption(Row* row, Point2I currentOffset)
 
    S32 rowHeight = profile->getRowHeight();
 
-   S32 optionWidth = xScale - columnSplit;
-
    GFXDrawUtil* drawer = GFX->getDrawUtil();
    //drawer->drawBitmap(row->mBitmap, )
 
@@ -1048,7 +1044,6 @@ RectI GuiGameListMenuCtrl::getRowBounds(S32 rowIndex)
 {
    GuiGameListMenuProfile* profile = (GuiGameListMenuProfile*)mProfile;
 
-   F32 xScale = (float)getWidth() / profile->getRowWidth();
    S32 rowHeight = profile->getRowHeight();
 
    Point2I currentOffset = Point2I::Zero;
@@ -1375,9 +1370,6 @@ void GuiGameListMenuCtrl::clickKeybind(Row* row, S32 xPos)
 
    S32 rowHeight = profile->getRowHeight();
 
-   S32 optionWidth = xScale - columnSplit;
-
-   GFXDrawUtil* drawer = GFX->getDrawUtil();
    //drawer->drawBitmap(row->mBitmap, )
 
    Point2I button;
@@ -1388,7 +1380,6 @@ void GuiGameListMenuCtrl::clickKeybind(Row* row, S32 xPos)
    buttonSize.x = rowHeight / 2;
    buttonSize.y = rowHeight / 2;
 
-   GFXTextureObject* texture = row->mBitmapTex;
    RectI rect(button, buttonSize);
 
    if (rect.pointInRect(Point2I(xPos, rowHeight / 2)))
diff --git a/Engine/source/gui/controls/guiPopUpCtrl.cpp b/Engine/source/gui/controls/guiPopUpCtrl.cpp
index 0cd08dfb8..d66f50e92 100644
--- a/Engine/source/gui/controls/guiPopUpCtrl.cpp
+++ b/Engine/source/gui/controls/guiPopUpCtrl.cpp
@@ -311,7 +311,6 @@ void GuiPopUpMenuCtrl::initPersistFields(void)
 
 bool GuiPopUpMenuCtrl::_setBitmaps(void* obj, const char* index, const char* data)
 {
-   bool ret = false; 
    GuiPopUpMenuCtrl* object = static_cast<GuiPopUpMenuCtrl*>(obj);
 
    object->setBitmap(data);
diff --git a/Engine/source/gui/controls/guiPopUpCtrlEx.cpp b/Engine/source/gui/controls/guiPopUpCtrlEx.cpp
index 5cbd1e3bc..b66e0d209 100644
--- a/Engine/source/gui/controls/guiPopUpCtrlEx.cpp
+++ b/Engine/source/gui/controls/guiPopUpCtrlEx.cpp
@@ -365,7 +365,6 @@ void GuiPopUpMenuCtrlEx::initPersistFields(void)
 
 bool GuiPopUpMenuCtrlEx::_setBitmaps(void* obj, const char* index, const char* data)
 {
-   bool ret = false;
    GuiPopUpMenuCtrlEx* object = static_cast<GuiPopUpMenuCtrlEx*>(obj);
 
    object->setBitmap(data);
diff --git a/Engine/source/gui/utility/guiRenderTargetVizCtrl.cpp b/Engine/source/gui/utility/guiRenderTargetVizCtrl.cpp
index 91544f5e0..6c1366afb 100644
--- a/Engine/source/gui/utility/guiRenderTargetVizCtrl.cpp
+++ b/Engine/source/gui/utility/guiRenderTargetVizCtrl.cpp
@@ -102,8 +102,6 @@ void GuiRenderTargetVizCtrl::onRender(Point2I      offset,
 
       camObject = dynamic_cast<Camera*>(camObject->getClientObject());
 
-      bool servObj = camObject->isServerObject();
-
       if (camObject)
       {
          GFXTexHandle targ = camObject->getCameraRenderTarget();
diff --git a/Engine/source/lighting/advanced/advancedLightBinManager.cpp b/Engine/source/lighting/advanced/advancedLightBinManager.cpp
index 322560799..fd8cd6dc4 100644
--- a/Engine/source/lighting/advanced/advancedLightBinManager.cpp
+++ b/Engine/source/lighting/advanced/advancedLightBinManager.cpp
@@ -323,8 +323,6 @@ void AdvancedLightBinManager::_scoreLights(const MatrixF& cameraTrans)
          {
             if (dist > smLightFadeStart)
             {
-               F32 brightness = light.lightInfo->getBrightness();
-
                float fadeOutAmt = (dist - smLightFadeStart) / (smLightFadeEnd - smLightFadeStart);
                fadeOutAmt = 1 - fadeOutAmt;
 
diff --git a/Engine/source/materials/processedShaderMaterial.cpp b/Engine/source/materials/processedShaderMaterial.cpp
index fc453958f..b6d7be05c 100644
--- a/Engine/source/materials/processedShaderMaterial.cpp
+++ b/Engine/source/materials/processedShaderMaterial.cpp
@@ -1290,16 +1290,9 @@ void ProcessedShaderMaterial::setCustomShaderData(Vector<CustomShaderBindingData
 
 	for (U32 i = 0; i < shaderData.size(); i++)
 	{
-		for (U32 h = 0; h < handles->mCustomHandles.size(); ++h)
-		{
-			StringTableEntry handleName = shaderData[i].getHandleName();
-			bool tmp = true;
-		}
 		//roll through and try setting our data!
 		for (U32 h = 0; h < handles->mCustomHandles.size(); ++h)
 		{
-			StringTableEntry handleName = shaderData[i].getHandleName();
-			StringTableEntry rpdHandleName = handles->mCustomHandles[h].handleName;
 			if (handles->mCustomHandles[h].handleName == shaderData[i].getHandleName())
 			{
 				if (handles->mCustomHandles[h].handle->isValid())
diff --git a/Engine/source/persistence/taml/taml.cpp b/Engine/source/persistence/taml/taml.cpp
index 0454e102a..b05b0d8bc 100644
--- a/Engine/source/persistence/taml/taml.cpp
+++ b/Engine/source/persistence/taml/taml.cpp
@@ -640,7 +640,7 @@ ImplementEnumType(_TamlFormatMode,
 
       // Iterate fields.
       U8 arrayDepth = 0;
-      TamlCustomNode* currentArrayNode;
+      TamlCustomNode* currentArrayNode = NULL;
       for (U32 index = 0; index < fieldCount; ++index)
       {
          // Fetch field.
diff --git a/Engine/source/platform/async/asyncPacketStream.h b/Engine/source/platform/async/asyncPacketStream.h
index 44b4b661f..00f798946 100644
--- a/Engine/source/platform/async/asyncPacketStream.h
+++ b/Engine/source/platform/async/asyncPacketStream.h
@@ -282,7 +282,7 @@ void AsyncPacketBufferedInputStream< Stream, Packet >::_requestNext()
       if( resettable )
       {
          IPositionable< U32 >* positionable = dynamic_cast< IPositionable< U32 >* >( &Deref( stream ) );
-         U32 pos;
+         U32 pos = 0;
          if(positionable)
             pos = positionable->getPosition();
          
diff --git a/Engine/source/platform/platformNet.cpp b/Engine/source/platform/platformNet.cpp
index db7c26604..a97a094c0 100644
--- a/Engine/source/platform/platformNet.cpp
+++ b/Engine/source/platform/platformNet.cpp
@@ -95,36 +95,6 @@ typedef int SOCKET;
 
 #endif
 
-#if defined(TORQUE_USE_WINSOCK)
-static const char* strerror_wsa( S32 code )
-{
-   switch( code )
-   {
-#define E( name ) case name: return #name;
-      E( WSANOTINITIALISED );
-      E( WSAENETDOWN );
-      E( WSAEADDRINUSE );
-      E( WSAEINPROGRESS );
-      E( WSAEALREADY );
-      E( WSAEADDRNOTAVAIL );
-      E( WSAEAFNOSUPPORT );
-      E( WSAEFAULT );
-      E( WSAEINVAL );
-      E( WSAEISCONN );
-      E( WSAENETUNREACH );
-      E( WSAEHOSTUNREACH );
-      E( WSAENOBUFS );
-      E( WSAENOTSOCK );
-      E( WSAETIMEDOUT );
-      E( WSAEWOULDBLOCK );
-      E( WSAEACCES );
-#undef E
-      default:
-         return "Unknown";
-   }
-}
-#endif
-
 #include "core/util/tVector.h"
 #include "platform/platformNetAsync.h"
 #include "console/console.h"
@@ -1243,7 +1213,8 @@ void Net::process()
          }
          break;
       case PolledSocket::NameLookupRequired:
-         U32 newState;
+      {
+         U32 newState = Net::NoError;
 
          // is the lookup complete?
          if (!gNetAsync.checkLookup(
@@ -1262,7 +1233,7 @@ void Net::process()
          {
             // try to connect
             out_h_addr.port = currentSock->remotePort;
-            const sockaddr *ai_addr = NULL;
+            const sockaddr* ai_addr = NULL;
             int ai_addrlen = 0;
             sockaddr_in socketAddress;
             sockaddr_in6 socketAddress6;
@@ -1304,7 +1275,7 @@ void Net::process()
             else
             {
                Con::errorf("Error connecting to %s: Invalid Protocol",
-               currentSock->remoteAddr);
+                  currentSock->remoteAddr);
                newState = Net::ConnectFailed;
                removeSock = true;
                removeSockHandle = currentSock->handleFd;
@@ -1319,7 +1290,7 @@ void Net::process()
                   if (err != Net::WouldBlock)
                   {
                      Con::errorf("Error connecting to %s: %u",
-                     currentSock->remoteAddr, err);
+                        currentSock->remoteAddr, err);
                      newState = Net::ConnectFailed;
                      removeSock = true;
                      removeSockHandle = currentSock->handleFd;
@@ -1340,6 +1311,7 @@ void Net::process()
 
          smConnectionNotify->trigger(currentSock->handleFd, newState);
          break;
+      }
       case PolledSocket::Listening:
          NetAddress incomingAddy;
 
diff --git a/Engine/source/renderInstance/renderTranslucentMgr.cpp b/Engine/source/renderInstance/renderTranslucentMgr.cpp
index 725cd3e7e..8c4b0cc8c 100644
--- a/Engine/source/renderInstance/renderTranslucentMgr.cpp
+++ b/Engine/source/renderInstance/renderTranslucentMgr.cpp
@@ -144,7 +144,6 @@ void RenderTranslucentMgr::render( SceneRenderState *state )
    GFXTextureObject *lastLM = NULL;
    GFXCubemap *lastCubemap = NULL;
    GFXTextureObject *lastReflectTex = NULL;
-   GFXTextureObject *lastMiscTex = NULL;
    GFXTextureObject *lastAccuTex = NULL;
 
    // Find the particle render manager (if we don't have it)
diff --git a/Engine/source/terrain/terrCellMaterial.cpp b/Engine/source/terrain/terrCellMaterial.cpp
index ff34a65ac..5f6eefd08 100644
--- a/Engine/source/terrain/terrCellMaterial.cpp
+++ b/Engine/source/terrain/terrCellMaterial.cpp
@@ -615,8 +615,6 @@ bool TerrainCellMaterial::_initShader(bool deferredMat,
    mOrmTexArrayConst = mShader->getShaderConstHandle("$ormMapSampler");
    if (mOrmTexArrayConst->isValid())
    {
-      GFXTextureProfile* profile = &GFXStaticTextureProfile;
-
       const S32 sampler = mOrmTexArrayConst->getSamplerRegister();
 
       desc.samplers[sampler] = GFXSamplerStateDesc::getWrapLinear();
diff --git a/Engine/source/terrain/terrData.cpp b/Engine/source/terrain/terrData.cpp
index be43d6638..0f07abd9b 100644
--- a/Engine/source/terrain/terrData.cpp
+++ b/Engine/source/terrain/terrData.cpp
@@ -992,8 +992,6 @@ void TerrainBlock::addMaterial( const String &name, U32 insertAt )
       mFile->mMaterials.push_back( mat );
       mFile->_initMaterialInstMapping();
 
-      bool isSrv = isServerObject();
-
       //now we update our asset
       if (mTerrainAsset)
       {
@@ -1418,7 +1416,6 @@ void TerrainBlock::unpackUpdate(NetConnection* con, BitStream *stream)
 
       char buffer[256];
       stream->readString(buffer);
-      bool validAsset = setTerrainAsset(StringTable->insert(buffer));
    }
    if (baseTexSizeChanged && isProperlyAdded())
       _updateBaseTexture(NONE);
diff --git a/Engine/source/ts/tsCollision.cpp b/Engine/source/ts/tsCollision.cpp
index 53fcb60d6..22381436b 100644
--- a/Engine/source/ts/tsCollision.cpp
+++ b/Engine/source/ts/tsCollision.cpp
@@ -1044,9 +1044,9 @@ PhysicsCollision* TSShape::_buildColShapes( bool useVisibleMesh, const Point3F &
          // We need the default mesh transform.
          MatrixF localXfm;
          getNodeWorldTransform( object.nodeIndex, &localXfm );
-         Point3F t = localXfm.getPosition();
-         t.convolve(scale);
-         localXfm.setPosition(t);
+         Point3F nodeWorldPosition = localXfm.getPosition();
+         nodeWorldPosition.convolve(scale);
+         localXfm.setPosition(nodeWorldPosition);
 
          // We have some sort of collision shape... so allocate it.
          if ( !colShape )
@@ -1061,9 +1061,9 @@ PhysicsCollision* TSShape::_buildColShapes( bool useVisibleMesh, const Point3F &
             // Add the offset to the center of the bounds 
             // into the local space transform.
             MatrixF centerXfm( true );
-            Point3F t = mesh->getBounds().getCenter();
-            t.convolve(scale);
-            centerXfm.setPosition(t);
+            Point3F meshBoundsCenter = mesh->getBounds().getCenter();
+            meshBoundsCenter.convolve(scale);
+            centerXfm.setPosition(meshBoundsCenter);
             localXfm.mul( centerXfm );
 
             colShape->addBox( halfWidth, localXfm );
@@ -1077,9 +1077,9 @@ PhysicsCollision* TSShape::_buildColShapes( bool useVisibleMesh, const Point3F &
             // Add the offset to the center of the bounds
             // into the local space transform.
             MatrixF primXfm( true );
-            Point3F t = mesh->getBounds().getCenter();
-            t.convolve(scale);
-            primXfm.setPosition(t);
+            Point3F meshBoundsCenter = mesh->getBounds().getCenter();
+            meshBoundsCenter.convolve(scale);
+            primXfm.setPosition(meshBoundsCenter);
             localXfm.mul( primXfm );
 
             colShape->addSphere( radius, localXfm );
@@ -1092,9 +1092,9 @@ PhysicsCollision* TSShape::_buildColShapes( bool useVisibleMesh, const Point3F &
 
             // We need to center the capsule and align it to the Y axis.
             MatrixF primXfm( true );
-            Point3F t = mesh->getBounds().getCenter();
-            t.convolve(scale);
-            primXfm.setPosition(t);
+            Point3F meshBoundsCenter = mesh->getBounds().getCenter();
+            meshBoundsCenter.convolve(scale);
+            primXfm.setPosition(meshBoundsCenter);
 
             // Use the longest axis as the capsule height.
             F32 height = -radius * 2.0f;

From 22d6b4a1f139c73edde7d466e0d810a2ecc465da Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Thu, 7 Oct 2021 00:32:42 -0400
Subject: [PATCH 157/399] * BugFix: Correct an accidentally removed line from
 clearing compiler warnings.

---
 Engine/source/terrain/terrData.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Engine/source/terrain/terrData.cpp b/Engine/source/terrain/terrData.cpp
index 0f07abd9b..532e0cc19 100644
--- a/Engine/source/terrain/terrData.cpp
+++ b/Engine/source/terrain/terrData.cpp
@@ -1416,6 +1416,7 @@ void TerrainBlock::unpackUpdate(NetConnection* con, BitStream *stream)
 
       char buffer[256];
       stream->readString(buffer);
+      setTerrainAsset(StringTable->insert(buffer));
    }
    if (baseTexSizeChanged && isProperlyAdded())
       _updateBaseTexture(NONE);

From 74cc60508b5e957f72fda20e3aac5b6d1f1c1332 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Thu, 7 Oct 2021 01:10:00 -0400
Subject: [PATCH 158/399] * BugFix: More cleanup of MSVC compiler warnings.

---
 Engine/source/T3D/assets/GUIAsset.cpp         |  2 --
 Engine/source/T3D/assets/ImageAsset.cpp       | 17 -----------------
 Engine/source/T3D/assets/ScriptAsset.cpp      | 10 ----------
 Engine/source/T3D/assets/ShapeAsset.cpp       |  2 --
 Engine/source/T3D/assets/TerrainAsset.cpp     |  2 --
 Engine/source/T3D/assets/assetImporter.cpp    |  9 +--------
 Engine/source/windowManager/sdl/sdlWindow.cpp |  2 +-
 7 files changed, 2 insertions(+), 42 deletions(-)

diff --git a/Engine/source/T3D/assets/GUIAsset.cpp b/Engine/source/T3D/assets/GUIAsset.cpp
index f9a2b500c..cacc3f9be 100644
--- a/Engine/source/T3D/assets/GUIAsset.cpp
+++ b/Engine/source/T3D/assets/GUIAsset.cpp
@@ -65,8 +65,6 @@ ConsoleSetType(TypeGUIAssetPtr)
    if (argc == 1)
    {
       // Yes, so fetch field value.
-      const char* pFieldValue = argv[0];
-
       *((const char**)dptr) = StringTable->insert(argv[0]);
 
       return;
diff --git a/Engine/source/T3D/assets/ImageAsset.cpp b/Engine/source/T3D/assets/ImageAsset.cpp
index 4376614ed..fea2bca3e 100644
--- a/Engine/source/T3D/assets/ImageAsset.cpp
+++ b/Engine/source/T3D/assets/ImageAsset.cpp
@@ -275,21 +275,6 @@ void ImageAsset::loadImage()
       mLoadedState = Ok;
       mIsValidImage = true;
       return;
-
-      //GFXTexHandle texture = getTexture(&GFXStaticTextureSRGBProfile);
-
-      //mTexture.set(mImagePath, &GFXStaticTextureSRGBProfile, avar("%s() - mImage (line %d)", __FUNCTION__, __LINE__));
-
-      /*if (texture.isValid())
-      {
-         mIsValidImage = true;
-
-         //mBitmap = texture.getBitmap();
-
-         return;
-      }*/
-
-      mChangeSignal.trigger();
    }
    mLoadedState = BadFileReference;
 
@@ -497,8 +482,6 @@ GuiControl* GuiInspectorTypeImageAssetPtr::constructEditControl()
       mInspector->getInspectObject()->getIdString(), mCaption);
    mBrowseButton->setField("Command", szBuffer);
 
-   const char* id = mInspector->getInspectObject()->getIdString();
-
    setDataField(StringTable->insert("targetObject"), NULL, mInspector->getInspectObject()->getIdString());
 
    // Create "Open in ShapeEditor" button
diff --git a/Engine/source/T3D/assets/ScriptAsset.cpp b/Engine/source/T3D/assets/ScriptAsset.cpp
index dad8ab1c6..ee1b696d0 100644
--- a/Engine/source/T3D/assets/ScriptAsset.cpp
+++ b/Engine/source/T3D/assets/ScriptAsset.cpp
@@ -191,16 +191,6 @@ bool ScriptAsset::execScript()
       return true;
 
    return false;
-
-   if (Torque::FS::IsScriptFile(mScriptPath))
-   {
-      return Con::executeFile(mScriptPath, false, false);
-   }
-   else
-   {
-      Con::errorf("ScriptAsset:execScript() - Script asset must have a valid file to exec");
-      return false;
-   }
 }
 
 DefineEngineMethod(ScriptAsset, execScript, bool, (), ,
diff --git a/Engine/source/T3D/assets/ShapeAsset.cpp b/Engine/source/T3D/assets/ShapeAsset.cpp
index bde3b4af5..7a8628238 100644
--- a/Engine/source/T3D/assets/ShapeAsset.cpp
+++ b/Engine/source/T3D/assets/ShapeAsset.cpp
@@ -603,8 +603,6 @@ GuiControl* GuiInspectorTypeShapeAssetPtr::constructEditControl()
       mInspector->getInspectObject()->getIdString(), mCaption);
    mBrowseButton->setField("Command", szBuffer);
 
-   const char* id = mInspector->getInspectObject()->getIdString();
-
    setDataField(StringTable->insert("targetObject"), NULL, mInspector->getInspectObject()->getIdString());
 
    // Create "Open in ShapeEditor" button
diff --git a/Engine/source/T3D/assets/TerrainAsset.cpp b/Engine/source/T3D/assets/TerrainAsset.cpp
index da0372097..70ce8786b 100644
--- a/Engine/source/T3D/assets/TerrainAsset.cpp
+++ b/Engine/source/T3D/assets/TerrainAsset.cpp
@@ -468,8 +468,6 @@ GuiControl* GuiInspectorTypeTerrainAssetPtr::constructEditControl()
       mInspector->getInspectObject()->getIdString(), mCaption);
    mBrowseButton->setField("Command", szBuffer);
 
-   const char* id = mInspector->getInspectObject()->getIdString();
-
    setDataField(StringTable->insert("targetObject"), NULL, mInspector->getInspectObject()->getIdString());
 
    // Create "Open in ShapeEditor" button
diff --git a/Engine/source/T3D/assets/assetImporter.cpp b/Engine/source/T3D/assets/assetImporter.cpp
index c9ed8a211..e9afcc479 100644
--- a/Engine/source/T3D/assets/assetImporter.cpp
+++ b/Engine/source/T3D/assets/assetImporter.cpp
@@ -1821,10 +1821,8 @@ void AssetImporter::processShapeAsset(AssetImportObject* assetItem)
    }
 
    S32 meshCount = dAtoi(assetItem->shapeInfo->getDataField(StringTable->insert("_meshCount"), nullptr));
-   S32 shapeItem = assetItem->shapeInfo->findItemByName("Meshes");
 
    S32 animCount = dAtoi(assetItem->shapeInfo->getDataField(StringTable->insert("_animCount"), nullptr));
-   S32 animItem = assetItem->shapeInfo->findItemByName("Animations");
 
    S32 materialCount = dAtoi(assetItem->shapeInfo->getDataField(StringTable->insert("_materialCount"), nullptr));
    S32 matItem = assetItem->shapeInfo->findItemByName("Materials");
@@ -2005,9 +2003,7 @@ void AssetImporter::validateAsset(AssetImportObject* assetItem)
    if (assetItem->importStatus == AssetImportObject::Skipped || assetItem->importStatus == AssetImportObject::NotProcessed)
       return;
 
-   bool hasCollision = checkAssetForCollision(assetItem);
-
-   if (hasCollision)
+   if (checkAssetForCollision(assetItem))
    {
       importIssues = true;
       return;
@@ -2018,7 +2014,6 @@ void AssetImporter::validateAsset(AssetImportObject* assetItem)
       AssetQuery aQuery;
       U32 numAssetsFound = AssetDatabase.findAllAssets(&aQuery);
 
-      bool hasCollision = false;
       for (U32 i = 0; i < numAssetsFound; i++)
       {
          StringTableEntry assetId = aQuery.mAssetList[i];
@@ -2032,7 +2027,6 @@ void AssetImporter::validateAsset(AssetImportObject* assetItem)
 
          if (assetName == StringTable->insert(assetItem->assetName.c_str()))
          {
-            hasCollision = true;
             assetItem->status = "Error";
             assetItem->statusType = "DuplicateAsset";
             assetItem->statusInfo = "Duplicate asset names found within the target module!\nAsset \"" + assetItem->assetName + "\" of type \"" + assetItem->assetType + "\" has a matching name.\nPlease rename it and try again!";
@@ -2241,7 +2235,6 @@ void AssetImporter::resetImportConfig()
       activeImportConfig->registerObject();
    }
 
-   bool foundConfig = false;
    Settings* editorSettings;
    //See if we can get our editor settings
    if (Sim::findObject("EditorSettings", editorSettings))
diff --git a/Engine/source/windowManager/sdl/sdlWindow.cpp b/Engine/source/windowManager/sdl/sdlWindow.cpp
index 2c725a2d1..6b420d080 100644
--- a/Engine/source/windowManager/sdl/sdlWindow.cpp
+++ b/Engine/source/windowManager/sdl/sdlWindow.cpp
@@ -550,7 +550,7 @@ void PlatformWindowSDL::_triggerTextNotify(const SDL_Event& evt)
    }
    else // get a wchar string
    {
-      const U32 len = strlen(evt.text.text);
+      const dsize_t len = strlen(evt.text.text);
       U16 wchar[16] = {};
       dMemcpy(wchar, evt.text.text, sizeof(char)*len);
 

From 15b946fb35c86f6e4207cf55e71e55075444153e Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Thu, 7 Oct 2021 09:59:03 -0400
Subject: [PATCH 159/399] * Adjustment: Utilize native compiler intrinsics for
 endian swapping when available.

---
 Engine/source/core/util/endian.h       | 13 ++++++++++++-
 Engine/source/platform/types.gcc.h     |  7 +++++--
 Engine/source/platform/types.visualc.h |  7 +++++--
 3 files changed, 22 insertions(+), 5 deletions(-)

diff --git a/Engine/source/core/util/endian.h b/Engine/source/core/util/endian.h
index 566f8be54..eaff3c03c 100644
--- a/Engine/source/core/util/endian.h
+++ b/Engine/source/core/util/endian.h
@@ -48,8 +48,12 @@ Convert the byte ordering on the U16 to and from big/little endian format.
 
 inline U16 endianSwap(const U16 in_swap)
 {
+#ifdef TORQUE_U16_ENDIANSWAP_BUILTIN
+    return TORQUE_U16_ENDIANSWAP_BUILTIN(in_swap);
+#else
    return U16(((in_swap >> 8) & 0x00ff) |
       ((in_swap << 8) & 0xff00));
+#endif
 }
 
 inline S16 endianSwap(const S16 in_swap)
@@ -64,10 +68,14 @@ Convert the byte ordering on the U32 to and from big/little endian format.
 */
 inline U32 endianSwap(const U32 in_swap)
 {
+#ifdef TORQUE_U32_ENDIANSWAP_BUILTIN
+    return TORQUE_U32_ENDIANSWAP_BUILTIN(in_swap);
+#else
    return U32(((in_swap >> 24) & 0x000000ff) |
       ((in_swap >>  8) & 0x0000ff00) |
       ((in_swap <<  8) & 0x00ff0000) |
       ((in_swap << 24) & 0xff000000));
+#endif
 }
 
 inline S32 endianSwap(const S32 in_swap)
@@ -77,12 +85,16 @@ inline S32 endianSwap(const S32 in_swap)
 
 inline U64 endianSwap(const U64 in_swap)
 {
+#ifdef TORQUE_U64_ENDIANSWAP_BUILTIN
+    return TORQUE_U64_ENDIANSWAP_BUILTIN(in_swap);
+#else
    U32 *inp = (U32 *) &in_swap;
    U64 ret;
    U32 *outp = (U32 *) &ret;
    outp[0] = endianSwap(inp[1]);
    outp[1] = endianSwap(inp[0]);
    return ret;
+#endif
 }
 
 inline S64 endianSwap(const S64 in_swap)
@@ -138,4 +150,3 @@ TORQUE_DECLARE_TEMPLATIZED_ENDIAN_CONV(F32)
 TORQUE_DECLARE_TEMPLATIZED_ENDIAN_CONV(F64)
 
 #endif
-
diff --git a/Engine/source/platform/types.gcc.h b/Engine/source/platform/types.gcc.h
index 8255a251d..f6f4cf6df 100644
--- a/Engine/source/platform/types.gcc.h
+++ b/Engine/source/platform/types.gcc.h
@@ -107,7 +107,7 @@ typedef unsigned long  U64;
 // This could be reconfigured for static builds, though minimal impact
 //#     define TORQUE_SUPPORTS_NASM
 #  endif
-#else 
+#else
 #  error "GCC: Unsupported Operating System"
 #endif
 
@@ -169,5 +169,8 @@ typedef unsigned long  U64;
 #endif
 #endif
 
-#endif // INCLUDED_TYPES_GCC_H
+#define TORQUE_U16_ENDIANSWAP_BUILTIN __builtin_bswap16
+#define TORQUE_U32_ENDIANSWAP_BUILTIN __builtin_bswap32
+#define TORQUE_U64_ENDIANSWAP_BUILTIN __builtin_bswap64
 
+#endif // INCLUDED_TYPES_GCC_H
diff --git a/Engine/source/platform/types.visualc.h b/Engine/source/platform/types.visualc.h
index 4ccc6ce42..1b62da721 100644
--- a/Engine/source/platform/types.visualc.h
+++ b/Engine/source/platform/types.visualc.h
@@ -69,7 +69,7 @@ typedef unsigned _int64 U64;
 #  define TORQUE_OS_WIN
 #  define TORQUE_OS_WIN64
 #  include "platform/types.win.h"
-#else 
+#else
 #  error "VC: Unsupported Operating System"
 #endif
 
@@ -115,5 +115,8 @@ typedef unsigned _int64 U64;
 #define TORQUE_UNLIKELY
 #endif
 
-#endif // INCLUDED_TYPES_VISUALC_H
+#define TORQUE_U16_ENDIANSWAP_BUILTIN _byteswap_ushort
+#define TORQUE_U32_ENDIANSWAP_BUILTIN _byteswap_ulong
+#define TORQUE_U64_ENDIANSWAP_BUILTIN _byteswap_uint64
 
+#endif // INCLUDED_TYPES_VISUALC_H

From 2d55fcf1bcf3744244a624b65d95b6b2bead3cb1 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Thu, 7 Oct 2021 13:16:55 -0400
Subject: [PATCH 160/399] * BugFix: Invert the corrections made in ImageAsset
 and ScriptAsset to be correct.

---
 Engine/source/T3D/assets/ImageAsset.cpp  | 5 +++--
 Engine/source/T3D/assets/ScriptAsset.cpp | 5 +++++
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/Engine/source/T3D/assets/ImageAsset.cpp b/Engine/source/T3D/assets/ImageAsset.cpp
index fea2bca3e..eb5f5036d 100644
--- a/Engine/source/T3D/assets/ImageAsset.cpp
+++ b/Engine/source/T3D/assets/ImageAsset.cpp
@@ -147,7 +147,7 @@ void ImageAsset::consoleInit()
    Con::addVariable("$Core::NoImageAssetFallback", TypeString, &smNoImageAssetFallback,
       "The assetId of the texture to display when the requested image asset is missing.\n"
       "@ingroup GFX\n");
-   
+
    smNoImageAssetFallback = StringTable->insert(Con::getVariable("$Core::NoImageAssetFallback"));
 }
 
@@ -274,6 +274,7 @@ void ImageAsset::loadImage()
 
       mLoadedState = Ok;
       mIsValidImage = true;
+      mChangeSignal.trigger();
       return;
    }
    mLoadedState = BadFileReference;
@@ -552,7 +553,7 @@ bool GuiInspectorTypeImageAssetPtr::renderTooltip(const Point2I& hoverPos, const
    if (texture.isNull())
       return false;
 
-   // Render image at a reasonable screen size while 
+   // Render image at a reasonable screen size while
    // keeping its aspect ratio...
    Point2I screensize = getRoot()->getWindowSize();
    Point2I offset = hoverPos;
diff --git a/Engine/source/T3D/assets/ScriptAsset.cpp b/Engine/source/T3D/assets/ScriptAsset.cpp
index ee1b696d0..199c6402c 100644
--- a/Engine/source/T3D/assets/ScriptAsset.cpp
+++ b/Engine/source/T3D/assets/ScriptAsset.cpp
@@ -190,6 +190,11 @@ bool ScriptAsset::execScript()
    if (handle)
       return true;
 
+   if (Torque::FS::IsScriptFile(mScriptPath))
+   {
+      return Con::executeFile(mScriptPath, false, false);
+   }
+   Con::errorf("ScriptAsset:execScript() - Script asset must have a valid file to exec");
    return false;
 }
 

From cf9d15a9d48bed4c3174dfaa7156778448d4ea8b Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Fri, 8 Oct 2021 17:23:16 -0400
Subject: [PATCH 161/399] * BugFix: Correct a Windows compilation error in the
 endian swap code due to a missing include.

---
 Engine/source/platform/types.visualc.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Engine/source/platform/types.visualc.h b/Engine/source/platform/types.visualc.h
index 1b62da721..2be0e51b3 100644
--- a/Engine/source/platform/types.visualc.h
+++ b/Engine/source/platform/types.visualc.h
@@ -23,6 +23,7 @@
 #ifndef INCLUDED_TYPES_VISUALC_H
 #define INCLUDED_TYPES_VISUALC_H
 
+#include <stdlib.h>
 
 // For more information on VisualC++ predefined macros
 // http://support.microsoft.com/default.aspx?scid=kb;EN-US;q65472

From 23e5e891ed0f4a57ae11e3c4e1ba90953ee4228c Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Fri, 8 Oct 2021 23:45:20 -0500
Subject: [PATCH 162/399] simplify callOnModules

---
 .../game/core/utility/scripts/module.tscript  | 20 +++----------------
 1 file changed, 3 insertions(+), 17 deletions(-)

diff --git a/Templates/BaseGame/game/core/utility/scripts/module.tscript b/Templates/BaseGame/game/core/utility/scripts/module.tscript
index a895f99bf..1f6a755d1 100644
--- a/Templates/BaseGame/game/core/utility/scripts/module.tscript
+++ b/Templates/BaseGame/game/core/utility/scripts/module.tscript
@@ -4,8 +4,7 @@ if (!isObject(ExecFilesList))
    new ArrayObject(ExecFilesList);
   
 function callOnModules(%functionName, %moduleGroup, %var0, %var1, %var2, %var3, %var4, %var5, %var6)
-{
-   %maxvars = 7; // match this to i/o signature
+{   
    //clear per module group file execution chain
    ExecFilesList.empty();
    //Get our modules so we can exec any specific client-side loading/handling
@@ -19,22 +18,9 @@ function callOnModules(%functionName, %moduleGroup, %var0, %var1, %var2, %var3,
          if(%module.group !$= %moduleGroup)
             continue;  
       }
-      
+      // match this to i/o signature
       if(isObject(%module.scopeSet) && %module.scopeSet.isMethod(%functionName))
-      {
-         %stryng = %module.scopeSet @ "." @ %functionName @ "(";
-         for (%a=0;%a<%maxvars;%a++)
-         {
-            if (%var[%a] !$= "")
-            {
-               %stryng = %stryng @ %var[%a];
-               if (%a<%maxvars-1 && %var[%a+1] !$= "")
-                  %stryng = %stryng @ ",";
-            }
-         }
-         %stryng = %stryng @ ");";
-         eval(%stryng);
-      }
+        %module.scopeSet.call(%functionName, %var0, %var1, %var2, %var3, %var4, %var5, %var6);
    }
    
    %execFilecount = ExecFilesList.count();

From 506621352ceebea54eb3c706bfba252027ebd87a Mon Sep 17 00:00:00 2001
From: Areloch <Areloch@gmail.com>
Date: Sat, 9 Oct 2021 00:07:01 -0500
Subject: [PATCH 163/399] Tweaks the MaterialAsset loading logic to continue to
 see if the matDefinition already points to an existing object(to avoid
 needlessly re-executing files over and over), but also validate other cases,
 and ensures that if we DO have an existing definition, we still process and
 load it in the asset itself properly.

---
 Engine/source/T3D/assets/MaterialAsset.cpp | 19 +++++++++++++++++--
 Engine/source/T3D/assets/MaterialAsset.h   |  1 +
 2 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/Engine/source/T3D/assets/MaterialAsset.cpp b/Engine/source/T3D/assets/MaterialAsset.cpp
index 57008b025..50e75ffa3 100644
--- a/Engine/source/T3D/assets/MaterialAsset.cpp
+++ b/Engine/source/T3D/assets/MaterialAsset.cpp
@@ -167,6 +167,12 @@ void MaterialAsset::initializeAsset()
 
    mScriptPath = getOwned() ? expandAssetFilePath(mScriptFile) : mScriptPath;
 
+   if (mMatDefinitionName == StringTable->EmptyString())
+   {
+      mLoadedState = Failed;
+      return;
+   }
+
    if (Torque::FS::IsScriptFile(mScriptPath))
    {
       if (!Sim::findObject(mMatDefinitionName))
@@ -180,6 +186,10 @@ void MaterialAsset::initializeAsset()
               mLoadedState = Failed;
           }
       }
+      else
+      {
+         mLoadedState = DefinitionAlreadyExists;
+      }
    }
 
    loadMaterial();
@@ -189,6 +199,12 @@ void MaterialAsset::onAssetRefresh()
 {
    mScriptPath = getOwned() ? expandAssetFilePath(mScriptFile) : mScriptPath;
 
+   if (mMatDefinitionName == StringTable->EmptyString())
+   {
+      mLoadedState = Failed;
+      return;
+   }
+
    if (Torque::FS::IsScriptFile(mScriptPath))
    {
       //Since we're refreshing, we can assume that the file we're executing WILL have an existing definition.
@@ -204,7 +220,6 @@ void MaterialAsset::onAssetRefresh()
 
       //And now that we've executed, switch back to the prior behavior
       Con::setVariable("$Con::redefineBehavior", redefineBehaviorPrev.c_str());
-      
    }
 
    loadMaterial();
@@ -232,7 +247,7 @@ void MaterialAsset::loadMaterial()
    if (mMaterialDefinition)
       SAFE_DELETE(mMaterialDefinition);
 
-   if (mLoadedState == ScriptLoaded && mMatDefinitionName != StringTable->EmptyString())
+   if ((mLoadedState == ScriptLoaded || mLoadedState == DefinitionAlreadyExists) && mMatDefinitionName != StringTable->EmptyString())
    {
       Material* matDef;
       if (!Sim::findObject(mMatDefinitionName, matDef))
diff --git a/Engine/source/T3D/assets/MaterialAsset.h b/Engine/source/T3D/assets/MaterialAsset.h
index 07ec0227a..75b1f6b96 100644
--- a/Engine/source/T3D/assets/MaterialAsset.h
+++ b/Engine/source/T3D/assets/MaterialAsset.h
@@ -73,6 +73,7 @@ public:
    enum MaterialAssetErrCode
    {
       ScriptLoaded = AssetErrCode::Extended,
+      DefinitionAlreadyExists,
       Extended
    };
 

From 112dafd8a82bb4485a0dd0a6668e30da9676467f Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Sat, 9 Oct 2021 11:31:26 -0500
Subject: [PATCH 164/399] remove basiconly from decals and decal roads. seems
 we fixed the bit that was causing that to not render

---
 .../game/core/rendering/scripts/renderManager.tscript         | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Templates/BaseGame/game/core/rendering/scripts/renderManager.tscript b/Templates/BaseGame/game/core/rendering/scripts/renderManager.tscript
index 1eefa6cf5..8c024c222 100644
--- a/Templates/BaseGame/game/core/rendering/scripts/renderManager.tscript
+++ b/Templates/BaseGame/game/core/rendering/scripts/renderManager.tscript
@@ -59,8 +59,8 @@ function initRenderManager()
    DiffuseRenderPassManager.addManager( new RenderObjectMgr(ObjectBin)     { bintype = "Object"; renderOrder = 0.6; processAddOrder = 0.6; } );
 
    DiffuseRenderPassManager.addManager( new RenderObjectMgr(ShadowBin)     { bintype = "Shadow"; renderOrder = 0.7; processAddOrder = 0.7; } );
-   DiffuseRenderPassManager.addManager( new RenderMeshMgr(DecalRoadBin)    { bintype = "DecalRoad"; renderOrder = 0.8; processAddOrder = 0.8; basicOnly = true;} );
-   DiffuseRenderPassManager.addManager( new RenderMeshMgr(DecalBin)        { bintype = "Decal"; renderOrder = 0.81; processAddOrder = 0.81; basicOnly = true;} );
+   DiffuseRenderPassManager.addManager( new RenderMeshMgr(DecalRoadBin)    { bintype = "DecalRoad"; renderOrder = 0.8; processAddOrder = 0.8; } );
+   DiffuseRenderPassManager.addManager( new RenderMeshMgr(DecalBin)        { bintype = "Decal"; renderOrder = 0.81; processAddOrder = 0.81;} );
    DiffuseRenderPassManager.addManager( new RenderOcclusionMgr(OccluderBin){ bintype = "Occluder"; renderOrder = 0.9; processAddOrder = 0.9; } );
 
    // Render the sky last

From 0429b5afa56b8d1bf76d86ed4a41eb566f6d97c2 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Sat, 9 Oct 2021 18:47:12 -0400
Subject: [PATCH 165/399] Added more tests for torquescript

---
 Engine/source/console/test/ScriptTest.cpp | 34 +++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/Engine/source/console/test/ScriptTest.cpp b/Engine/source/console/test/ScriptTest.cpp
index 05775694f..05f0582ff 100644
--- a/Engine/source/console/test/ScriptTest.cpp
+++ b/Engine/source/console/test/ScriptTest.cpp
@@ -889,6 +889,40 @@ TEST(Script, InnerObjectTests)
    ASSERT_EQ(nestedFuncCall.getInt(), 123);
 }
 
+TEST(Script, MiscTesting)
+{
+   ConsoleValue test1 = RunScript(R"(
+      function testNotPassedInParameters(%a, %b, %c, %d)
+      {
+         if (%d $= "")
+            return true;
+         return false;
+      }
+
+      return testNotPassedInParameters(1, 2); // skip passing in %c and %d
+   )");
+
+   ASSERT_EQ(test1.getBool(), true);
+
+   ConsoleValue test2 = RunScript(R"(
+      function SimObject::concatNameTest(%this)
+      {
+         return true;
+      }
+
+      new SimObject(WeirdTestObject1);
+
+      function testObjectNameConcatination(%i)
+      {
+         return (WeirdTestObject @ %i).concatNameTest();
+      }
+
+      return testObjectNameConcatination(1);
+   )");
+
+   ASSERT_EQ(test2.getBool(), true);
+}
+
 TEST(Script, MiscRegressions)
 {
    ConsoleValue regression1 = RunScript(R"(

From f7cf1c020c771b191415f26aff6dec1d7d75345d Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Sat, 9 Oct 2021 18:20:57 -0500
Subject: [PATCH 166/399] inject getworldtotangent and getworldnormal to ensure
 var order

---
 Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp b/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
index b41dfc234..bb09113a4 100644
--- a/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
+++ b/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
@@ -2974,6 +2974,8 @@ void ReflectionProbeFeatGLSL::processPix(Vector<ShaderComponent*>& componentList
 
    // Now the wsPosition and wsView.
    Var *wsPosition = getInWsPosition(componentList);
+   Var *worldToTangent = getInWorldToTangent(componentList);
+   Var *wsNormal = getInWorldNormal(componentList);
    Var *wsView = getWsView(wsPosition, meta);
    
    //Reflection Probe WIP

From d53dcb03c2715d11aaab0fdb73d6bebb7e95f650 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Sat, 9 Oct 2021 22:13:06 -0400
Subject: [PATCH 167/399] * [AssetBrowser] BugFix: Correct an error where on
 Linux the select asset path function would not list any directories.

---
 .../game/tools/assetBrowser/scripts/directoryHandling.tscript | 4 ++--
 .../game/tools/assetBrowser/scripts/selectPath.tscript        | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/directoryHandling.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/directoryHandling.tscript
index 3eb822f21..4f13dfb8b 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/directoryHandling.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/directoryHandling.tscript
@@ -216,7 +216,7 @@ function directoryHandler::getFolderTreeItemFromAddress(%this, %address)
    //break down the address
    %folderCount = getTokenCount(%address, "/");
 
-   if(startsWith(%address, "Data/") || startsWith(%address, "Tools/") || startsWith(%address, "Core/"))
+   if(startsWith(%address, "data/") || startsWith(%address, "tools/") || startsWith(%address, "core/"))
    {
       %curItem = %this.treeCtrl.findChildItemByName(1, "Modules");
    }
@@ -242,7 +242,7 @@ function directoryHandler::expandTreeToAddress(%this, %address)
    %rootId = AssetBrowser-->filterTree.findItemByName("Content");
    %this.treeCtrl.expandItem(%rootId);
 
-   if(startsWith(%address, "Data/") || startsWith(%address, "Tools/") || startsWith(%address, "Core/"))
+   if(startsWith(%address, "data/") || startsWith(%address, "tools/") || startsWith(%address, "core/"))
    {
       %curItem = %this.treeCtrl.findChildItemByName(1, "Modules");
    }
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/selectPath.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/selectPath.tscript
index 691a546e0..7db32c752 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/selectPath.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/selectPath.tscript
@@ -22,7 +22,7 @@ function SelectAssetPath::showDialog(%this, %startingPath, %callback, %promptTex
    %this.callback = %callback;
    
    %dataItem = SelectAssetPath-->folderTree.insertItem(0, "Data");
-   %this.dirHandler.loadFolders("Data", %dataItem);
+   %this.dirHandler.loadFolders("data", %dataItem);
    
    %this.dirHandler.expandTreeToAddress(%startingPath);
    %id = %this.dirHandler.getFolderTreeItemFromAddress(%startingPath);
@@ -60,4 +60,4 @@ function SelectAssetPath::newFolder(%this)
 {   
    AssetBrowser_newFolderNameTxt.text = "NewFolder";
    Canvas.pushDialog(AssetBrowser_newFolder);
-}
\ No newline at end of file
+}

From 77ea34d2b2ebb46c9c2eed55099e4d3bbc2b2cac Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Sun, 10 Oct 2021 04:19:27 -0400
Subject: [PATCH 168/399] * Adjustment: Minor tweaks to allow case
 insensitivity on Unix systems.

---
 Engine/source/platformPOSIX/posixVolume.cpp | 83 ++++++++++++++++++++-
 1 file changed, 80 insertions(+), 3 deletions(-)

diff --git a/Engine/source/platformPOSIX/posixVolume.cpp b/Engine/source/platformPOSIX/posixVolume.cpp
index 271df1e18..656a69335 100644
--- a/Engine/source/platformPOSIX/posixVolume.cpp
+++ b/Engine/source/platformPOSIX/posixVolume.cpp
@@ -149,18 +149,95 @@ PosixFileSystem::~PosixFileSystem()
 {
 }
 
+static void MungeCase(char* pathName, S32 pathNameSize)
+{
+    const int MaxPath = PATH_MAX;
+
+    char tempBuf[MaxPath];
+    dStrncpy(tempBuf, pathName, pathNameSize);
+
+    AssertFatal(pathName[0] == '/', "PATH must be absolute");
+
+    struct stat filestat;
+    const int MaxPathEl = 200;
+    char *currChar = pathName;
+    char testPath[MaxPath];
+    char pathEl[MaxPathEl];
+    bool done = false;
+
+    dStrncpy(tempBuf, "/", MaxPath);
+    currChar++;
+
+    while (!done)
+    {
+        char* termChar = dStrchr(currChar, '/');
+        if (termChar == NULL)
+            termChar = dStrchr(currChar, '\0');
+        AssertFatal(termChar, "Can't find / or NULL terminator");
+
+        S32 pathElLen = (termChar - currChar);
+        dStrncpy(pathEl, currChar, pathElLen);
+        pathEl[pathElLen] = '\0';
+        dStrncpy(testPath, tempBuf, MaxPath);
+        dStrcat(testPath, pathEl, MaxPath);
+        if (stat(testPath, &filestat) != -1)
+        {
+            dStrncpy(tempBuf, testPath, MaxPath);
+        }
+        else
+        {
+            DIR *dir = opendir(tempBuf);
+            struct dirent* ent;
+            bool foundMatch = false;
+            while (dir != NULL && (ent = readdir(dir)) != NULL)
+            {
+                if (dStricmp(pathEl, ent->d_name) == 0)
+                {
+                    foundMatch = true;
+                    dStrcat(tempBuf, ent->d_name, MaxPath);
+                    break;
+                }
+            }
+
+            if (!foundMatch)
+                dStrncpy(tempBuf, testPath, MaxPath);
+            if (dir)
+                closedir(dir);
+        }
+        if (*termChar == '/')
+        {
+            dStrcat(tempBuf, "/", MaxPath);
+            termChar++;
+            currChar = termChar;
+        }
+        else
+            done = true;
+    }
+
+    dStrncpy(pathName, tempBuf, pathNameSize);
+}
+
+//  static void MungeCase(char* pathName, S32 pathNameSize)
 FileNodeRef PosixFileSystem::resolve(const Path& path)
 {
    String file = buildFileName(_volume,path);
    struct stat info;
-   if (stat(file.c_str(),&info) == 0)
+
+   UTF8 testPath[1024];
+   dMemcpy(testPath, file.c_str(), file.length());
+   testPath[file.length()] = 0x00;
+   MungeCase(testPath, file.length());
+
+   String realFile(testPath);
+
+   if (stat(realFile.c_str(),&info) == 0)
    {
       // Construct the appropriate object
       if (S_ISREG(info.st_mode))
-         return new PosixFile(path,file);
+         return new PosixFile(path,realFile);
          
       if (S_ISDIR(info.st_mode))
-         return new PosixDirectory(path,file);
+         return new PosixDirectory(path,realFile);
    }
    
    return 0;

From a458c97217ae115361c980ca76ee4b85a4c28f90 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Sun, 10 Oct 2021 20:08:03 -0400
Subject: [PATCH 169/399] Implement more extensions to get graphics card memory
 for OpenGL on windows and Linux.

(cherry picked from commit da942cdb79a87b76e629b36415c83067e3620a70)
---
 Engine/source/gfx/gl/gfxGLDevice.cpp | 36 ++++++++++++++++++++++++++--
 Engine/source/gfx/gl/tGL/tGL.cpp     | 18 +++++++++++---
 2 files changed, 49 insertions(+), 5 deletions(-)

diff --git a/Engine/source/gfx/gl/gfxGLDevice.cpp b/Engine/source/gfx/gl/gfxGLDevice.cpp
index 1c82b4e74..40884bb05 100644
--- a/Engine/source/gfx/gl/gfxGLDevice.cpp
+++ b/Engine/source/gfx/gl/gfxGLDevice.cpp
@@ -51,6 +51,10 @@
 #include "shaderGen/shaderGen.h"
 #include "gfxGLUtils.h"
 
+#if defined(TORQUE_OS_WIN)
+#include "gfx/gl/tGL/tWGL.h"
+#endif
+
 GFXAdapter::CreateDeviceInstanceDelegate GFXGLDevice::mCreateDeviceInstance(GFXGLDevice::createInstance); 
 
 GFXDevice *GFXGLDevice::createInstance( U32 adapterIndex )
@@ -1073,8 +1077,36 @@ U32 GFXGLDevice::getTotalVideoMemory_GL_EXT()
       return mem / 1024;
    }
 
-   // TODO OPENGL, add supprt for INTEL cards.
-   
+
+#if defined(TORQUE_OS_WIN)
+   else if( (gglHasWExtension(AMD_gpu_association)) )
+   {
+      // Just assume 1 AMD gpu. Who uses crossfire anyways now? And, crossfire doesn't double
+      // vram anyways, so does it really matter?
+      UINT id;
+      if (wglGetGPUIDsAMD(1, &id) != 0)
+      {
+         S32 memorySize;
+         if (wglGetGPUInfoAMD(id, WGL_GPU_RAM_AMD, GL_INT, 1, &memorySize) != -1)
+         {
+            // memory size is returned in MB
+            return memorySize;
+         }
+      }
+   }
+#endif
+
+#if defined(TORQUE_OS_LINUX)
+   else if ( (gglHasXExtension(MESA_query_renderer)) )
+   {
+      // memory size is in mb
+      S32 memorySize;
+      glXQueryCurrentRendererIntegerMESA(GLX_RENDERER_VIDEO_MEMORY_MESA, &memorySize);
+      return memorySize;
+   }
+#endif
+
+   // No other way, sad. Probably windows Intel.
    return 0;
 }
 
diff --git a/Engine/source/gfx/gl/tGL/tGL.cpp b/Engine/source/gfx/gl/tGL/tGL.cpp
index b13fec60a..93e1e5a51 100644
--- a/Engine/source/gfx/gl/tGL/tGL.cpp
+++ b/Engine/source/gfx/gl/tGL/tGL.cpp
@@ -25,8 +25,10 @@
 #include "core/strings/stringFunctions.h"
 #include "console/console.h"
 
-#ifdef TORQUE_OS_WIN
-   #include "tWGL.h"
+#if defined(TORQUE_OS_WIN)
+#include "tWGL.h"
+#elif defined(TORQUE_OS_LINUX)
+#include "tXGL.h"
 #endif
 
 namespace GL
@@ -41,7 +43,17 @@ namespace GL
 
    void gglPerformExtensionBinds(void *context)
    {
-	
+#if defined(TORQUE_OS_WIN)
+      if (!gladLoadWGL((HDC)context))
+      {
+         AssertFatal(false, "Unable to load WGL in GLAD. Make sure your OpenGL drivers are up to date!");
+      }
+#elif defined(TORQUE_OS_LINUX)
+      if (!gladLoadGLX())
+      {
+         AssertFatal(false, "Unable to load GLX in GLAD. Make sure your OpenGL drivers are up to date!");
+      }
+#endif
    }
 }
 

From 1385b29f03b7f643e11e5417c1eb9f860c0a0cfe Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Sun, 10 Oct 2021 20:53:55 -0400
Subject: [PATCH 170/399] * Adjustment: Initial testing with extensions to load
 GPU VRAM.

---
 Engine/lib/glad/include/KHR/khrplatform.h |  2 +-
 Engine/lib/glad/include/glad/glad_glx.h   | 20 ++++++++++++++++--
 Engine/lib/glad/src/glx/glad_glx.c        | 25 +++++++++++++++--------
 Engine/source/gfx/gl/gfxGLDevice.cpp      |  6 ++++--
 Engine/source/gfx/gl/tGL/tGL.cpp          |  3 ++-
 5 files changed, 42 insertions(+), 14 deletions(-)

diff --git a/Engine/lib/glad/include/KHR/khrplatform.h b/Engine/lib/glad/include/KHR/khrplatform.h
index 5b55ea2b9..dd22d9270 100644
--- a/Engine/lib/glad/include/KHR/khrplatform.h
+++ b/Engine/lib/glad/include/KHR/khrplatform.h
@@ -119,7 +119,7 @@
  * This follows the return type of the function  and precedes the function
  * name in the function prototype.
  */
-#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(KHRONOS_STATIC)
+#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
     /* Win32 but not WinCE */
 #   define KHRONOS_APIENTRY __stdcall
 #else
diff --git a/Engine/lib/glad/include/glad/glad_glx.h b/Engine/lib/glad/include/glad/glad_glx.h
index 46abf2c5b..696366e44 100644
--- a/Engine/lib/glad/include/glad/glad_glx.h
+++ b/Engine/lib/glad/include/glad/glad_glx.h
@@ -1,6 +1,6 @@
 /*
 
-    GLX loader generated by glad 0.1.33 on Sun Aug 18 11:26:39 2019.
+    GLX loader generated by glad 0.1.34 on Mon Oct 11 00:48:11 2021.
 
     Language/Generator: C/C++
     Specification: glx
@@ -27,6 +27,7 @@
         GLX_EXT_create_context_es_profile,
         GLX_EXT_fbconfig_packed_float,
         GLX_EXT_framebuffer_sRGB,
+        GLX_EXT_get_drawable_type,
         GLX_EXT_import_context,
         GLX_EXT_libglvnd,
         GLX_EXT_no_config_context,
@@ -48,6 +49,7 @@
         GLX_NV_copy_image,
         GLX_NV_delay_before_swap,
         GLX_NV_float_buffer,
+        GLX_NV_multigpu_context,
         GLX_NV_multisample_coverage,
         GLX_NV_present_video,
         GLX_NV_robustness_video_memory_purge,
@@ -79,7 +81,7 @@
     Reproducible: False
 
     Commandline:
-        --api="glx=1.4" --generator="c" --spec="glx" --extensions="GLX_3DFX_multisample,GLX_AMD_gpu_association,GLX_ARB_context_flush_control,GLX_ARB_create_context,GLX_ARB_create_context_no_error,GLX_ARB_create_context_profile,GLX_ARB_create_context_robustness,GLX_ARB_fbconfig_float,GLX_ARB_framebuffer_sRGB,GLX_ARB_get_proc_address,GLX_ARB_multisample,GLX_ARB_robustness_application_isolation,GLX_ARB_robustness_share_group_isolation,GLX_ARB_vertex_buffer_object,GLX_EXT_buffer_age,GLX_EXT_context_priority,GLX_EXT_create_context_es2_profile,GLX_EXT_create_context_es_profile,GLX_EXT_fbconfig_packed_float,GLX_EXT_framebuffer_sRGB,GLX_EXT_import_context,GLX_EXT_libglvnd,GLX_EXT_no_config_context,GLX_EXT_stereo_tree,GLX_EXT_swap_control,GLX_EXT_swap_control_tear,GLX_EXT_texture_from_pixmap,GLX_EXT_visual_info,GLX_EXT_visual_rating,GLX_INTEL_swap_event,GLX_MESA_agp_offset,GLX_MESA_copy_sub_buffer,GLX_MESA_pixmap_colormap,GLX_MESA_query_renderer,GLX_MESA_release_buffers,GLX_MESA_set_3dfx_mode,GLX_MESA_swap_control,GLX_NV_copy_buffer,GLX_NV_copy_image,GLX_NV_delay_before_swap,GLX_NV_float_buffer,GLX_NV_multisample_coverage,GLX_NV_present_video,GLX_NV_robustness_video_memory_purge,GLX_NV_swap_group,GLX_NV_video_capture,GLX_NV_video_out,GLX_OML_swap_method,GLX_OML_sync_control,GLX_SGIS_blended_overlay,GLX_SGIS_multisample,GLX_SGIS_shared_multisample,GLX_SGIX_dmbuffer,GLX_SGIX_fbconfig,GLX_SGIX_hyperpipe,GLX_SGIX_pbuffer,GLX_SGIX_swap_barrier,GLX_SGIX_swap_group,GLX_SGIX_video_resize,GLX_SGIX_video_source,GLX_SGIX_visual_select_group,GLX_SGI_cushion,GLX_SGI_make_current_read,GLX_SGI_swap_control,GLX_SGI_video_sync,GLX_SUN_get_transparent_index"
+        --api="glx=1.4" --generator="c" --spec="glx" --extensions="GLX_3DFX_multisample,GLX_AMD_gpu_association,GLX_ARB_context_flush_control,GLX_ARB_create_context,GLX_ARB_create_context_no_error,GLX_ARB_create_context_profile,GLX_ARB_create_context_robustness,GLX_ARB_fbconfig_float,GLX_ARB_framebuffer_sRGB,GLX_ARB_get_proc_address,GLX_ARB_multisample,GLX_ARB_robustness_application_isolation,GLX_ARB_robustness_share_group_isolation,GLX_ARB_vertex_buffer_object,GLX_EXT_buffer_age,GLX_EXT_context_priority,GLX_EXT_create_context_es2_profile,GLX_EXT_create_context_es_profile,GLX_EXT_fbconfig_packed_float,GLX_EXT_framebuffer_sRGB,GLX_EXT_get_drawable_type,GLX_EXT_import_context,GLX_EXT_libglvnd,GLX_EXT_no_config_context,GLX_EXT_stereo_tree,GLX_EXT_swap_control,GLX_EXT_swap_control_tear,GLX_EXT_texture_from_pixmap,GLX_EXT_visual_info,GLX_EXT_visual_rating,GLX_INTEL_swap_event,GLX_MESA_agp_offset,GLX_MESA_copy_sub_buffer,GLX_MESA_pixmap_colormap,GLX_MESA_query_renderer,GLX_MESA_release_buffers,GLX_MESA_set_3dfx_mode,GLX_MESA_swap_control,GLX_NV_copy_buffer,GLX_NV_copy_image,GLX_NV_delay_before_swap,GLX_NV_float_buffer,GLX_NV_multigpu_context,GLX_NV_multisample_coverage,GLX_NV_present_video,GLX_NV_robustness_video_memory_purge,GLX_NV_swap_group,GLX_NV_video_capture,GLX_NV_video_out,GLX_OML_swap_method,GLX_OML_sync_control,GLX_SGIS_blended_overlay,GLX_SGIS_multisample,GLX_SGIS_shared_multisample,GLX_SGIX_dmbuffer,GLX_SGIX_fbconfig,GLX_SGIX_hyperpipe,GLX_SGIX_pbuffer,GLX_SGIX_swap_barrier,GLX_SGIX_swap_group,GLX_SGIX_video_resize,GLX_SGIX_video_source,GLX_SGIX_visual_select_group,GLX_SGI_cushion,GLX_SGI_make_current_read,GLX_SGI_swap_control,GLX_SGI_video_sync,GLX_SUN_get_transparent_index"
     Online:
         Too many extensions
 */
@@ -139,6 +141,7 @@ typedef void* (* GLADloadproc)(const char *name);
 #endif
 
 GLAPI int gladLoadGLX(Display *dpy, int screen);
+GLAPI void gladUnloadGLX(void);
 
 GLAPI int gladLoadGLXLoader(GLADloadproc, Display *dpy, int screen);
 
@@ -616,6 +619,11 @@ GLAPI PFNGLXGETPROCADDRESSPROC glad_glXGetProcAddress;
 #define GLX_3DFX_WINDOW_MODE_MESA 0x1
 #define GLX_3DFX_FULLSCREEN_MODE_MESA 0x2
 #define GLX_FLOAT_COMPONENTS_NV 0x20B0
+#define GLX_CONTEXT_MULTIGPU_ATTRIB_NV 0x20AA
+#define GLX_CONTEXT_MULTIGPU_ATTRIB_SINGLE_NV 0x20AB
+#define GLX_CONTEXT_MULTIGPU_ATTRIB_AFR_NV 0x20AC
+#define GLX_CONTEXT_MULTIGPU_ATTRIB_MULTICAST_NV 0x20AD
+#define GLX_CONTEXT_MULTIGPU_ATTRIB_MULTI_DISPLAY_MULTICAST_NV 0x20AE
 #define GLX_COVERAGE_SAMPLES_NV 100001
 #define GLX_COLOR_SAMPLES_NV 0x20B3
 #define GLX_NUM_VIDEO_SLOTS_NV 0x20F0
@@ -804,6 +812,10 @@ GLAPI int GLAD_GLX_EXT_fbconfig_packed_float;
 #define GLX_EXT_framebuffer_sRGB 1
 GLAPI int GLAD_GLX_EXT_framebuffer_sRGB;
 #endif
+#ifndef GLX_EXT_get_drawable_type
+#define GLX_EXT_get_drawable_type 1
+GLAPI int GLAD_GLX_EXT_get_drawable_type;
+#endif
 #ifndef GLX_EXT_import_context
 #define GLX_EXT_import_context 1
 GLAPI int GLAD_GLX_EXT_import_context;
@@ -957,6 +969,10 @@ GLAPI PFNGLXDELAYBEFORESWAPNVPROC glad_glXDelayBeforeSwapNV;
 #define GLX_NV_float_buffer 1
 GLAPI int GLAD_GLX_NV_float_buffer;
 #endif
+#ifndef GLX_NV_multigpu_context
+#define GLX_NV_multigpu_context 1
+GLAPI int GLAD_GLX_NV_multigpu_context;
+#endif
 #ifndef GLX_NV_multisample_coverage
 #define GLX_NV_multisample_coverage 1
 GLAPI int GLAD_GLX_NV_multisample_coverage;
diff --git a/Engine/lib/glad/src/glx/glad_glx.c b/Engine/lib/glad/src/glx/glad_glx.c
index 0adb32bd6..69eeb3dd8 100644
--- a/Engine/lib/glad/src/glx/glad_glx.c
+++ b/Engine/lib/glad/src/glx/glad_glx.c
@@ -1,6 +1,6 @@
 /*
 
-    GLX loader generated by glad 0.1.33 on Sun Aug 18 11:26:39 2019.
+    GLX loader generated by glad 0.1.34 on Mon Oct 11 00:48:11 2021.
 
     Language/Generator: C/C++
     Specification: glx
@@ -27,6 +27,7 @@
         GLX_EXT_create_context_es_profile,
         GLX_EXT_fbconfig_packed_float,
         GLX_EXT_framebuffer_sRGB,
+        GLX_EXT_get_drawable_type,
         GLX_EXT_import_context,
         GLX_EXT_libglvnd,
         GLX_EXT_no_config_context,
@@ -48,6 +49,7 @@
         GLX_NV_copy_image,
         GLX_NV_delay_before_swap,
         GLX_NV_float_buffer,
+        GLX_NV_multigpu_context,
         GLX_NV_multisample_coverage,
         GLX_NV_present_video,
         GLX_NV_robustness_video_memory_purge,
@@ -79,7 +81,7 @@
     Reproducible: False
 
     Commandline:
-        --api="glx=1.4" --generator="c" --spec="glx" --extensions="GLX_3DFX_multisample,GLX_AMD_gpu_association,GLX_ARB_context_flush_control,GLX_ARB_create_context,GLX_ARB_create_context_no_error,GLX_ARB_create_context_profile,GLX_ARB_create_context_robustness,GLX_ARB_fbconfig_float,GLX_ARB_framebuffer_sRGB,GLX_ARB_get_proc_address,GLX_ARB_multisample,GLX_ARB_robustness_application_isolation,GLX_ARB_robustness_share_group_isolation,GLX_ARB_vertex_buffer_object,GLX_EXT_buffer_age,GLX_EXT_context_priority,GLX_EXT_create_context_es2_profile,GLX_EXT_create_context_es_profile,GLX_EXT_fbconfig_packed_float,GLX_EXT_framebuffer_sRGB,GLX_EXT_import_context,GLX_EXT_libglvnd,GLX_EXT_no_config_context,GLX_EXT_stereo_tree,GLX_EXT_swap_control,GLX_EXT_swap_control_tear,GLX_EXT_texture_from_pixmap,GLX_EXT_visual_info,GLX_EXT_visual_rating,GLX_INTEL_swap_event,GLX_MESA_agp_offset,GLX_MESA_copy_sub_buffer,GLX_MESA_pixmap_colormap,GLX_MESA_query_renderer,GLX_MESA_release_buffers,GLX_MESA_set_3dfx_mode,GLX_MESA_swap_control,GLX_NV_copy_buffer,GLX_NV_copy_image,GLX_NV_delay_before_swap,GLX_NV_float_buffer,GLX_NV_multisample_coverage,GLX_NV_present_video,GLX_NV_robustness_video_memory_purge,GLX_NV_swap_group,GLX_NV_video_capture,GLX_NV_video_out,GLX_OML_swap_method,GLX_OML_sync_control,GLX_SGIS_blended_overlay,GLX_SGIS_multisample,GLX_SGIS_shared_multisample,GLX_SGIX_dmbuffer,GLX_SGIX_fbconfig,GLX_SGIX_hyperpipe,GLX_SGIX_pbuffer,GLX_SGIX_swap_barrier,GLX_SGIX_swap_group,GLX_SGIX_video_resize,GLX_SGIX_video_source,GLX_SGIX_visual_select_group,GLX_SGI_cushion,GLX_SGI_make_current_read,GLX_SGI_swap_control,GLX_SGI_video_sync,GLX_SUN_get_transparent_index"
+        --api="glx=1.4" --generator="c" --spec="glx" --extensions="GLX_3DFX_multisample,GLX_AMD_gpu_association,GLX_ARB_context_flush_control,GLX_ARB_create_context,GLX_ARB_create_context_no_error,GLX_ARB_create_context_profile,GLX_ARB_create_context_robustness,GLX_ARB_fbconfig_float,GLX_ARB_framebuffer_sRGB,GLX_ARB_get_proc_address,GLX_ARB_multisample,GLX_ARB_robustness_application_isolation,GLX_ARB_robustness_share_group_isolation,GLX_ARB_vertex_buffer_object,GLX_EXT_buffer_age,GLX_EXT_context_priority,GLX_EXT_create_context_es2_profile,GLX_EXT_create_context_es_profile,GLX_EXT_fbconfig_packed_float,GLX_EXT_framebuffer_sRGB,GLX_EXT_get_drawable_type,GLX_EXT_import_context,GLX_EXT_libglvnd,GLX_EXT_no_config_context,GLX_EXT_stereo_tree,GLX_EXT_swap_control,GLX_EXT_swap_control_tear,GLX_EXT_texture_from_pixmap,GLX_EXT_visual_info,GLX_EXT_visual_rating,GLX_INTEL_swap_event,GLX_MESA_agp_offset,GLX_MESA_copy_sub_buffer,GLX_MESA_pixmap_colormap,GLX_MESA_query_renderer,GLX_MESA_release_buffers,GLX_MESA_set_3dfx_mode,GLX_MESA_swap_control,GLX_NV_copy_buffer,GLX_NV_copy_image,GLX_NV_delay_before_swap,GLX_NV_float_buffer,GLX_NV_multigpu_context,GLX_NV_multisample_coverage,GLX_NV_present_video,GLX_NV_robustness_video_memory_purge,GLX_NV_swap_group,GLX_NV_video_capture,GLX_NV_video_out,GLX_OML_swap_method,GLX_OML_sync_control,GLX_SGIS_blended_overlay,GLX_SGIS_multisample,GLX_SGIS_shared_multisample,GLX_SGIX_dmbuffer,GLX_SGIX_fbconfig,GLX_SGIX_hyperpipe,GLX_SGIX_pbuffer,GLX_SGIX_swap_barrier,GLX_SGIX_swap_group,GLX_SGIX_video_resize,GLX_SGIX_video_source,GLX_SGIX_visual_select_group,GLX_SGI_cushion,GLX_SGI_make_current_read,GLX_SGI_swap_control,GLX_SGI_video_sync,GLX_SUN_get_transparent_index"
     Online:
         Too many extensions
 */
@@ -119,7 +121,7 @@ static PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr;
 #endif
 
 static
-int open_gl(void) {
+int open_glx(void) {
 #ifndef IS_UWP
     libGL = LoadLibraryW(L"opengl32.dll");
     if(libGL != NULL) {
@@ -134,7 +136,7 @@ int open_gl(void) {
 }
 
 static
-void close_gl(void) {
+void close_glx(void) {
     if(libGL != NULL) {
         FreeLibrary((HMODULE) libGL);
         libGL = NULL;
@@ -150,7 +152,7 @@ static PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr;
 #endif
 
 static
-int open_gl(void) {
+int open_glx(void) {
 #ifdef __APPLE__
     static const char *NAMES[] = {
         "../Frameworks/OpenGL.framework/OpenGL",
@@ -181,7 +183,7 @@ int open_gl(void) {
 }
 
 static
-void close_gl(void) {
+void close_glx(void) {
     if(libGL != NULL) {
         dlclose(libGL);
         libGL = NULL;
@@ -213,14 +215,17 @@ void* get_proc(const char *namez) {
 int gladLoadGLX(Display *dpy, int screen) {
     int status = 0;
 
-    if(open_gl()) {
+    if(open_glx()) {
         status = gladLoadGLXLoader((GLADloadproc)get_proc, dpy, screen);
-        close_gl();
     }
 
     return status;
 }
 
+void gladUnloadGLX(void) {
+    close_glx();
+}
+
 static Display *GLADGLXDisplay = 0;
 static int GLADGLXscreen = 0;
 
@@ -326,6 +331,7 @@ int GLAD_GLX_EXT_create_context_es2_profile = 0;
 int GLAD_GLX_EXT_create_context_es_profile = 0;
 int GLAD_GLX_EXT_fbconfig_packed_float = 0;
 int GLAD_GLX_EXT_framebuffer_sRGB = 0;
+int GLAD_GLX_EXT_get_drawable_type = 0;
 int GLAD_GLX_EXT_import_context = 0;
 int GLAD_GLX_EXT_libglvnd = 0;
 int GLAD_GLX_EXT_no_config_context = 0;
@@ -347,6 +353,7 @@ int GLAD_GLX_NV_copy_buffer = 0;
 int GLAD_GLX_NV_copy_image = 0;
 int GLAD_GLX_NV_delay_before_swap = 0;
 int GLAD_GLX_NV_float_buffer = 0;
+int GLAD_GLX_NV_multigpu_context = 0;
 int GLAD_GLX_NV_multisample_coverage = 0;
 int GLAD_GLX_NV_present_video = 0;
 int GLAD_GLX_NV_robustness_video_memory_purge = 0;
@@ -752,6 +759,7 @@ static int find_extensionsGLX(void) {
 	GLAD_GLX_EXT_create_context_es_profile = has_ext("GLX_EXT_create_context_es_profile");
 	GLAD_GLX_EXT_fbconfig_packed_float = has_ext("GLX_EXT_fbconfig_packed_float");
 	GLAD_GLX_EXT_framebuffer_sRGB = has_ext("GLX_EXT_framebuffer_sRGB");
+	GLAD_GLX_EXT_get_drawable_type = has_ext("GLX_EXT_get_drawable_type");
 	GLAD_GLX_EXT_import_context = has_ext("GLX_EXT_import_context");
 	GLAD_GLX_EXT_libglvnd = has_ext("GLX_EXT_libglvnd");
 	GLAD_GLX_EXT_no_config_context = has_ext("GLX_EXT_no_config_context");
@@ -773,6 +781,7 @@ static int find_extensionsGLX(void) {
 	GLAD_GLX_NV_copy_image = has_ext("GLX_NV_copy_image");
 	GLAD_GLX_NV_delay_before_swap = has_ext("GLX_NV_delay_before_swap");
 	GLAD_GLX_NV_float_buffer = has_ext("GLX_NV_float_buffer");
+	GLAD_GLX_NV_multigpu_context = has_ext("GLX_NV_multigpu_context");
 	GLAD_GLX_NV_multisample_coverage = has_ext("GLX_NV_multisample_coverage");
 	GLAD_GLX_NV_present_video = has_ext("GLX_NV_present_video");
 	GLAD_GLX_NV_robustness_video_memory_purge = has_ext("GLX_NV_robustness_video_memory_purge");
diff --git a/Engine/source/gfx/gl/gfxGLDevice.cpp b/Engine/source/gfx/gl/gfxGLDevice.cpp
index 40884bb05..1cba42143 100644
--- a/Engine/source/gfx/gl/gfxGLDevice.cpp
+++ b/Engine/source/gfx/gl/gfxGLDevice.cpp
@@ -53,6 +53,8 @@
 
 #if defined(TORQUE_OS_WIN)
 #include "gfx/gl/tGL/tWGL.h"
+#elif defined(TORQUE_OS_LINUX)
+#include "gfx/gl/tGL/tXGL.h"
 #endif
 
 GFXAdapter::CreateDeviceInstanceDelegate GFXGLDevice::mCreateDeviceInstance(GFXGLDevice::createInstance); 
@@ -1097,10 +1099,10 @@ U32 GFXGLDevice::getTotalVideoMemory_GL_EXT()
 #endif
 
 #if defined(TORQUE_OS_LINUX)
-   else if ( (gglHasXExtension(MESA_query_renderer)) )
+   else if ( (gglHasXExtension(NULL, NULL, MESA_query_renderer)) )
    {
       // memory size is in mb
-      S32 memorySize;
+      U32 memorySize;
       glXQueryCurrentRendererIntegerMESA(GLX_RENDERER_VIDEO_MEMORY_MESA, &memorySize);
       return memorySize;
    }
diff --git a/Engine/source/gfx/gl/tGL/tGL.cpp b/Engine/source/gfx/gl/tGL/tGL.cpp
index 93e1e5a51..5d9b4718a 100644
--- a/Engine/source/gfx/gl/tGL/tGL.cpp
+++ b/Engine/source/gfx/gl/tGL/tGL.cpp
@@ -49,7 +49,8 @@ namespace GL
          AssertFatal(false, "Unable to load WGL in GLAD. Make sure your OpenGL drivers are up to date!");
       }
 #elif defined(TORQUE_OS_LINUX)
-      if (!gladLoadGLX())
+
+      if (!gladLoadGLX(NULL, 0))
       {
          AssertFatal(false, "Unable to load GLX in GLAD. Make sure your OpenGL drivers are up to date!");
       }

From 497a94f884badc354dc34e8c616c5ff380eadb72 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Mon, 11 Oct 2021 10:24:24 -0400
Subject: [PATCH 171/399] * Adjustment: Cleanups to the case insensitivity code
 for POSIX systems and add case insensitivty to directory dumping code.

---
 Engine/source/platformPOSIX/posixVolume.cpp   | 93 +++----------------
 .../source/platformX86UNIX/x86UNIXFileio.cpp  | 20 +++-
 Tools/CMake/torque3d.cmake                    |  3 +
 Tools/CMake/torqueConfig.h.in                 |  3 +
 4 files changed, 37 insertions(+), 82 deletions(-)

diff --git a/Engine/source/platformPOSIX/posixVolume.cpp b/Engine/source/platformPOSIX/posixVolume.cpp
index 656a69335..411559ffa 100644
--- a/Engine/source/platformPOSIX/posixVolume.cpp
+++ b/Engine/source/platformPOSIX/posixVolume.cpp
@@ -42,7 +42,7 @@
 
 
 //#define DEBUG_SPEW
-
+extern void ResolvePathCaseInsensitive(char* pathName, S32 pathNameSize);
 
 namespace Torque
 {
@@ -149,95 +149,32 @@ PosixFileSystem::~PosixFileSystem()
 {
 }
 
-static void MungeCase(char* pathName, S32 pathNameSize)
-{
-    const int MaxPath = PATH_MAX;
-
-    char tempBuf[MaxPath];
-    dStrncpy(tempBuf, pathName, pathNameSize);
-
-    AssertFatal(pathName[0] == '/', "PATH must be absolute");
-
-    struct stat filestat;
-    const int MaxPathEl = 200;
-    char *currChar = pathName;
-    char testPath[MaxPath];
-    char pathEl[MaxPathEl];
-    bool done = false;
-
-    dStrncpy(tempBuf, "/", MaxPath);
-    currChar++;
-
-    while (!done)
-    {
-        char* termChar = dStrchr(currChar, '/');
-        if (termChar == NULL)
-            termChar = dStrchr(currChar, '\0');
-        AssertFatal(termChar, "Can't find / or NULL terminator");
-
-        S32 pathElLen = (termChar - currChar);
-        dStrncpy(pathEl, currChar, pathElLen);
-        pathEl[pathElLen] = '\0';
-        dStrncpy(testPath, tempBuf, MaxPath);
-        dStrcat(testPath, pathEl, MaxPath);
-        if (stat(testPath, &filestat) != -1)
-        {
-            dStrncpy(tempBuf, testPath, MaxPath);
-        }
-        else
-        {
-            DIR *dir = opendir(tempBuf);
-            struct dirent* ent;
-            bool foundMatch = false;
-            while (dir != NULL && (ent = readdir(dir)) != NULL)
-            {
-                if (dStricmp(pathEl, ent->d_name) == 0)
-                {
-                    foundMatch = true;
-                    dStrcat(tempBuf, ent->d_name, MaxPath);
-                    break;
-                }
-            }
-
-            if (!foundMatch)
-                dStrncpy(tempBuf, testPath, MaxPath);
-            if (dir)
-                closedir(dir);
-        }
-        if (*termChar == '/')
-        {
-            dStrcat(tempBuf, "/", MaxPath);
-            termChar++;
-            currChar = termChar;
-        }
-        else
-            done = true;
-    }
-
-    dStrncpy(pathName, tempBuf, pathNameSize);
-}
-
-//  static void MungeCase(char* pathName, S32 pathNameSize)
 FileNodeRef PosixFileSystem::resolve(const Path& path)
 {
    String file = buildFileName(_volume,path);
    struct stat info;
 
-   UTF8 testPath[1024];
-   dMemcpy(testPath, file.c_str(), file.length());
-   testPath[file.length()] = 0x00;
-   MungeCase(testPath, file.length());
+#ifdef TORQUE_POSIX_PATH_CASE_INSENSITIVE
+   // Resolve the case sensitive filepath
+   String::SizeType fileLength = file.length();
+   UTF8 caseSensitivePath[fileLength + 1];
+   dMemcpy(caseSensitivePath, file.c_str(), fileLength);
+   caseSensitivePath[fileLength] = 0x00;
+   ResolvePathCaseInsensitive(caseSensitivePath, fileLength);
 
-   String realFile(testPath);
+   String caseSensitiveFile(caseSensitivePath);
+#else
+   String caseSensitiveFile = file;
+#endif
 
-   if (stat(realFile.c_str(),&info) == 0)
+   if (stat(caseSensitiveFile.c_str(),&info) == 0)
    {
       // Construct the appropriate object
       if (S_ISREG(info.st_mode))
-         return new PosixFile(path,realFile);
+         return new PosixFile(path,caseSensitiveFile);
          
       if (S_ISDIR(info.st_mode))
-         return new PosixDirectory(path,realFile);
+         return new PosixDirectory(path,caseSensitiveFile);
    }
    
    return 0;
diff --git a/Engine/source/platformX86UNIX/x86UNIXFileio.cpp b/Engine/source/platformX86UNIX/x86UNIXFileio.cpp
index eee06a84e..26a43ee7e 100644
--- a/Engine/source/platformX86UNIX/x86UNIXFileio.cpp
+++ b/Engine/source/platformX86UNIX/x86UNIXFileio.cpp
@@ -33,7 +33,7 @@
     directory.  Files are never created or modified in the game directory.
 
     For case-sensitivity, the MungePath code will test whether a given path
-    specified by the engine exists.  If not, it will use the MungeCase function
+    specified by the engine exists.  If not, it will use the ResolvePathCaseInsensitive function
     which will try to determine if an actual filesystem path matches the
     specified path case insensitive.  If one is found, the actual path
     transparently (we hope) replaces the one requested by the engine.
@@ -183,7 +183,7 @@ bool dPathCopy(const char *fromName, const char *toName, bool nooverwrite)
  // munge the case of the specified pathName.  This means try to find the actual
  // filename in with case-insensitive matching on the specified pathName, and
  // store the actual found name.
- static void MungeCase(char* pathName, S32 pathNameSize)
+ void ResolvePathCaseInsensitive(char* pathName, S32 pathNameSize)
  {
     char tempBuf[MaxPath];
     dStrncpy(tempBuf, pathName, pathNameSize);
@@ -296,7 +296,7 @@ bool dPathCopy(const char *fromName, const char *toName, bool nooverwrite)
        return;
 
     // otherwise munge the case of the path
-    MungeCase(dest, destSize);
+     ResolvePathCaseInsensitive(dest, destSize);
  }
 
  //-----------------------------------------------------------------------------
@@ -1284,7 +1284,19 @@ bool dPathCopy(const char *fromName, const char *toName, bool nooverwrite)
 
  bool Platform::dumpDirectories(const char *path, Vector<StringTableEntry> &directoryVector, S32 depth, bool noBasePath)
  {
-   bool retVal = recurseDumpDirectories(path, "", directoryVector, -1, depth, noBasePath);
+#ifdef TORQUE_POSIX_PATH_CASE_INSENSITIVE
+   dsize_t pathLength = dStrlen(path);
+   char caseSensitivePath[pathLength + 1];
+
+   // Load path into temporary buffer
+   dMemcpy(caseSensitivePath, path, pathLength);
+   caseSensitivePath[pathLength] = 0x00;
+   ResolvePathCaseInsensitive(caseSensitivePath, pathLength);
+#else
+   const char* caseSensitivePath = path;
+#endif
+
+   bool retVal = recurseDumpDirectories(caseSensitivePath, "", directoryVector, -1, depth, noBasePath);
    clearExcludedDirectories();
    return retVal;
  }
diff --git a/Tools/CMake/torque3d.cmake b/Tools/CMake/torque3d.cmake
index 987a094b8..460d32e51 100644
--- a/Tools/CMake/torque3d.cmake
+++ b/Tools/CMake/torque3d.cmake
@@ -163,6 +163,9 @@ endif()
 option(TORQUE_MULTITHREAD "Multi Threading" ON)
 mark_as_advanced(TORQUE_MULTITHREAD)
 
+option(TORQUE_POSIX_PATH_CASE_INSENSITIVE ON)
+mark_as_advanced(TORQUE_POSIX_PATH_CASE_INSENSITIVE)
+
 option(TORQUE_DISABLE_MEMORY_MANAGER "Disable memory manager" ON)
 mark_as_advanced(TORQUE_DISABLE_MEMORY_MANAGER)
 
diff --git a/Tools/CMake/torqueConfig.h.in b/Tools/CMake/torqueConfig.h.in
index 13ce58b6c..6465012c4 100644
--- a/Tools/CMake/torqueConfig.h.in
+++ b/Tools/CMake/torqueConfig.h.in
@@ -44,6 +44,9 @@
 /// Define me if you want to enable Arcane FX support.
 #cmakedefine TORQUE_AFX_ENABLED
 
+/// Define me if you want path case insensitivity support on POSIX systems. Does nothing on Windows.
+#cmakedefine TORQUE_POSIX_PATH_CASE_INSENSITIVE
+
 /// Define me if you want to enable multithreading support.
 #cmakedefine TORQUE_MULTITHREAD
 

From 444c9dcf41fc3c9fcd358abb29da776ca659dd01 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Mon, 11 Oct 2021 10:45:02 -0400
Subject: [PATCH 172/399] * BugFix: Correct non-constant array allocations in
 the POSIX case insensitivity code.

---
 Engine/source/platformPOSIX/posixVolume.cpp     | 14 +++++++++-----
 Engine/source/platformX86UNIX/x86UNIXFileio.cpp |  6 +++++-
 2 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/Engine/source/platformPOSIX/posixVolume.cpp b/Engine/source/platformPOSIX/posixVolume.cpp
index 411559ffa..b8b070217 100644
--- a/Engine/source/platformPOSIX/posixVolume.cpp
+++ b/Engine/source/platformPOSIX/posixVolume.cpp
@@ -157,7 +157,7 @@ FileNodeRef PosixFileSystem::resolve(const Path& path)
 #ifdef TORQUE_POSIX_PATH_CASE_INSENSITIVE
    // Resolve the case sensitive filepath
    String::SizeType fileLength = file.length();
-   UTF8 caseSensitivePath[fileLength + 1];
+   UTF8* caseSensitivePath = new UTF8[fileLength + 1];
    dMemcpy(caseSensitivePath, file.c_str(), fileLength);
    caseSensitivePath[fileLength] = 0x00;
    ResolvePathCaseInsensitive(caseSensitivePath, fileLength);
@@ -167,17 +167,21 @@ FileNodeRef PosixFileSystem::resolve(const Path& path)
    String caseSensitiveFile = file;
 #endif
 
+   FileNodeRef result = 0;
    if (stat(caseSensitiveFile.c_str(),&info) == 0)
    {
       // Construct the appropriate object
       if (S_ISREG(info.st_mode))
-         return new PosixFile(path,caseSensitiveFile);
+         result = new PosixFile(path,caseSensitiveFile);
          
       if (S_ISDIR(info.st_mode))
-         return new PosixDirectory(path,caseSensitiveFile);
+         result = new PosixDirectory(path,caseSensitiveFile);
    }
-   
-   return 0;
+
+#ifdef TORQUE_POSIX_PATH_CASE_INSENSITIVE
+   delete[] caseSensitivePath;
+#endif
+   return result;
 }
 
 FileNodeRef PosixFileSystem::create(const Path& path, FileNode::Mode mode)
diff --git a/Engine/source/platformX86UNIX/x86UNIXFileio.cpp b/Engine/source/platformX86UNIX/x86UNIXFileio.cpp
index 26a43ee7e..9669638ae 100644
--- a/Engine/source/platformX86UNIX/x86UNIXFileio.cpp
+++ b/Engine/source/platformX86UNIX/x86UNIXFileio.cpp
@@ -1286,7 +1286,7 @@ bool dPathCopy(const char *fromName, const char *toName, bool nooverwrite)
  {
 #ifdef TORQUE_POSIX_PATH_CASE_INSENSITIVE
    dsize_t pathLength = dStrlen(path);
-   char caseSensitivePath[pathLength + 1];
+   char* caseSensitivePath = new char[pathLength + 1];
 
    // Load path into temporary buffer
    dMemcpy(caseSensitivePath, path, pathLength);
@@ -1298,6 +1298,10 @@ bool dPathCopy(const char *fromName, const char *toName, bool nooverwrite)
 
    bool retVal = recurseDumpDirectories(caseSensitivePath, "", directoryVector, -1, depth, noBasePath);
    clearExcludedDirectories();
+
+#ifdef TORQUE_POSIX_PATH_CASE_INSENSITIVE
+   delete[] caseSensitivePath;
+#endif
    return retVal;
  }
 

From e468c2bf73c7d9e1aef3ec252141fdd68ff0c77a Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Mon, 11 Oct 2021 14:38:14 -0500
Subject: [PATCH 173/399] add a bit of further clarity to soundasset code
 injectors

---
 Engine/source/T3D/assets/SoundAsset.h | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/Engine/source/T3D/assets/SoundAsset.h b/Engine/source/T3D/assets/SoundAsset.h
index 77c1e7180..eebcf6590 100644
--- a/Engine/source/T3D/assets/SoundAsset.h
+++ b/Engine/source/T3D/assets/SoundAsset.h
@@ -432,7 +432,7 @@ if (m##name##AssetId[index] != StringTable->EmptyString())\
    {\
       m##name##Name[index] = StringTable->EmptyString();\
    }\
-   else Con::warnf("Warning: %s::LOAD_IMAGEASSET(%s)-%s", mClassName, m##name##AssetId[index], ImageAsset::getAssetErrstrn(assetState).c_str());\
+   else Con::warnf("Warning: %s::LOAD_SOUNDASSET_ARRAY(%s[%i])-%s", mClassName, m##name##AssetId[index], index, ImageAsset::getAssetErrstrn(assetState).c_str());\
 }
 
 #define assetEnumNameConcat(x,suff)(new std::string( x + std::string(#suff)))->c_str()
@@ -440,11 +440,12 @@ if (m##name##AssetId[index] != StringTable->EmptyString())\
 #define INITPERSISTFIELD_SOUNDASSET_ENUMED(name, enumType, maxValue, consoleClass, docs) \
    for (U32 i = 0; i < maxValue; i++)\
    {\
-      const char* enumString = castConsoleTypeToString(static_cast<enumType>(i));\
+      const enumType itter = static_cast<enumType>(i);\
+      const char* enumString = castConsoleTypeToString(static_cast<enumType>(itter));\
       if (enumString && enumString[0])\
       {\
-         addField(assetEnumNameConcat(enumString, File), TypeSoundFilename, Offset(m##name##Name[i], consoleClass), assetText(name, docs), AbstractClassRep::FIELD_HideInInspectors); \
-         addField(assetEnumNameConcat(enumString, Asset), TypeSoundAssetId, Offset(m##name##AssetId[i], consoleClass), assetText(name, asset reference.));\
+         addField(assetEnumNameConcat(enumString, File), TypeSoundFilename, Offset(m##name##Name[itter], consoleClass), assetText(name, docs), AbstractClassRep::FIELD_HideInInspectors); \
+         addField(assetEnumNameConcat(enumString, Asset), TypeSoundAssetId, Offset(m##name##AssetId[itter], consoleClass), assetText(name, asset reference.));\
       }\
    }
 #pragma endregion

From d9eea8e5be4f250abe2a6eb08b1a6cfa58753c76 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Mon, 11 Oct 2021 16:25:37 -0500
Subject: [PATCH 174/399] make gcc happy

---
 Engine/source/T3D/assets/SoundAsset.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Engine/source/T3D/assets/SoundAsset.h b/Engine/source/T3D/assets/SoundAsset.h
index eebcf6590..d320986b9 100644
--- a/Engine/source/T3D/assets/SoundAsset.h
+++ b/Engine/source/T3D/assets/SoundAsset.h
@@ -444,8 +444,8 @@ if (m##name##AssetId[index] != StringTable->EmptyString())\
       const char* enumString = castConsoleTypeToString(static_cast<enumType>(itter));\
       if (enumString && enumString[0])\
       {\
-         addField(assetEnumNameConcat(enumString, File), TypeSoundFilename, Offset(m##name##Name[itter], consoleClass), assetText(name, docs), AbstractClassRep::FIELD_HideInInspectors); \
-         addField(assetEnumNameConcat(enumString, Asset), TypeSoundAssetId, Offset(m##name##AssetId[itter], consoleClass), assetText(name, asset reference.));\
+         addField(assetEnumNameConcat(enumString, File), TypeSoundFilename, Offset(m##name##Name[0], consoleClass) + sizeof(m##name##Name[0])*i, assetText(name, docs), AbstractClassRep::FIELD_HideInInspectors); \
+         addField(assetEnumNameConcat(enumString, Asset), TypeSoundAssetId, Offset(m##name##AssetId[0], consoleClass) + sizeof(m##name##AssetId[0])*i, assetText(name, asset reference.));\
       }\
    }
 #pragma endregion

From 8d0128698a9476f1fd8f79587bf42b63aa00d052 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Mon, 11 Oct 2021 19:02:58 -0400
Subject: [PATCH 175/399] * [ZIPVolume] BugFix: Add the capability of resolving
 ZIP prefix paths with case insensitivity and a CMake option to control this
 behavior.

---
 Engine/source/core/util/zip/zipVolume.cpp | 9 ++++++++-
 Tools/CMake/torque3d.cmake                | 3 +++
 Tools/CMake/torqueConfig.h.in             | 3 +++
 3 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/Engine/source/core/util/zip/zipVolume.cpp b/Engine/source/core/util/zip/zipVolume.cpp
index 5dcb8dee8..a3a0ac7c9 100644
--- a/Engine/source/core/util/zip/zipVolume.cpp
+++ b/Engine/source/core/util/zip/zipVolume.cpp
@@ -407,8 +407,15 @@ FileNodeRef ZipFileSystem::resolve(const Path& path)
    if(mZipNameIsDir)
    {
       // Remove the fake root from the name so things can be found
+#ifdef TORQUE_ZIP_PATH_CASE_INSENSITIVE
+      String lowerFakeRoot = String::ToLower(mFakeRoot);
+      String lowerName = String::ToLower(name);
+      if(lowerName.find(lowerFakeRoot) == 0)
+          name = name.substr(mFakeRoot.length());
+#else
       if(name.find(mFakeRoot) == 0)
-         name = name.substr(mFakeRoot.length());
+          name = name.substr(mFakeRoot.length());
+#endif
 
 #ifdef TORQUE_DISABLE_FIND_ROOT_WITHIN_ZIP
       else
diff --git a/Tools/CMake/torque3d.cmake b/Tools/CMake/torque3d.cmake
index 460d32e51..cd09fabd6 100644
--- a/Tools/CMake/torque3d.cmake
+++ b/Tools/CMake/torque3d.cmake
@@ -166,6 +166,9 @@ mark_as_advanced(TORQUE_MULTITHREAD)
 option(TORQUE_POSIX_PATH_CASE_INSENSITIVE ON)
 mark_as_advanced(TORQUE_POSIX_PATH_CASE_INSENSITIVE)
 
+option(TORQUE_ZIP_PATH_CASE_INSENSITIVE ON)
+mark_as_advanced(TORQUE_ZIP_PATH_CASE_INSENSITIVE)
+
 option(TORQUE_DISABLE_MEMORY_MANAGER "Disable memory manager" ON)
 mark_as_advanced(TORQUE_DISABLE_MEMORY_MANAGER)
 
diff --git a/Tools/CMake/torqueConfig.h.in b/Tools/CMake/torqueConfig.h.in
index 6465012c4..9e045b1d5 100644
--- a/Tools/CMake/torqueConfig.h.in
+++ b/Tools/CMake/torqueConfig.h.in
@@ -47,6 +47,9 @@
 /// Define me if you want path case insensitivity support on POSIX systems. Does nothing on Windows.
 #cmakedefine TORQUE_POSIX_PATH_CASE_INSENSITIVE
 
+/// Define me if you want path case insensitivity support in ZIP files.
+#cmakedefine TORQUE_ZIP_PATH_CASE_INSENSITIVE
+
 /// Define me if you want to enable multithreading support.
 #cmakedefine TORQUE_MULTITHREAD
 

From c376bc3f9cf12b00aaf7aeb437e426b30ef00e6d Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Mon, 11 Oct 2021 19:31:37 -0400
Subject: [PATCH 176/399] * [ZIP] BugFix: Correct another codepath that may
 fail due to case sensitive string searches.

---
 Engine/source/core/util/zip/zipVolume.cpp | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/Engine/source/core/util/zip/zipVolume.cpp b/Engine/source/core/util/zip/zipVolume.cpp
index a3a0ac7c9..d56c9471e 100644
--- a/Engine/source/core/util/zip/zipVolume.cpp
+++ b/Engine/source/core/util/zip/zipVolume.cpp
@@ -487,8 +487,15 @@ FileNodeRef ZipFileSystem::resolveLoose(const Path& path)
    if(mZipNameIsDir)
    {
       // Remove the fake root from the name so things can be found
+#ifdef TORQUE_ZIP_PATH_CASE_INSENSITIVE
+      String lowerFakeRoot = String::ToLower(mFakeRoot);
+      String lowerName = String::ToLower(name);
+      if(lowerName.find(lowerFakeRoot) == 0)
+          name = name.substr(mFakeRoot.length());
+#else
       if(name.find(mFakeRoot) == 0)
-         name = name.substr(mFakeRoot.length());
+          name = name.substr(mFakeRoot.length());
+#endif
 
 #ifdef TORQUE_DISABLE_FIND_ROOT_WITHIN_ZIP
       else

From 8b29dae3b9c08c08033af23322cb0f8bfee29b53 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Mon, 11 Oct 2021 20:12:32 -0400
Subject: [PATCH 177/399] * [AssetBrowser] BugFix: Correct the inability to
 spawn assorted objects.

---
 .../BaseGame/game/tools/assetBrowser/scripts/creator.tscript  | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript
index 48366f453..8971087c5 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript
@@ -174,7 +174,7 @@ function AssetBrowser::addCreatorClass(%this, %class, %name, %buildfunc)
          %method = "build" @ %class;
 
       if( !ObjectBuilderGui.isMethod( %method ) )
-         %cmd = "return new " @ %class @ "();";
+         %cmd = "new " @ %class @ "();";
       else
          %cmd = "ObjectBuilderGui." @ %method @ "();";
 
@@ -187,4 +187,4 @@ function AssetBrowser::addCreatorClass(%this, %class, %name, %buildfunc)
    %args.val[2] = %buildfunc;
    
    %this.creatorClassArray.push_back( %group, %args );
-}
\ No newline at end of file
+}

From bce14ab63fd1a187ec9c9f02b8c6f407c749a5bc Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Mon, 11 Oct 2021 20:02:49 -0500
Subject: [PATCH 178/399] fix opengl cubemap display

---
 Engine/source/gfx/gl/gfxGLDevice.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/Engine/source/gfx/gl/gfxGLDevice.cpp b/Engine/source/gfx/gl/gfxGLDevice.cpp
index 1c82b4e74..38f94ae0f 100644
--- a/Engine/source/gfx/gl/gfxGLDevice.cpp
+++ b/Engine/source/gfx/gl/gfxGLDevice.cpp
@@ -187,6 +187,9 @@ void GFXGLDevice::initGLState()
 
    //enable sRGB
    glEnable(GL_FRAMEBUFFER_SRGB);
+
+   //enable seamless cubemapping
+   glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
 }
 
 void GFXGLDevice::vsyncCallback()

From 66cfd34b7127d37a21665bba41ba5ecabfc9cc12 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Tue, 12 Oct 2021 13:09:12 -0400
Subject: [PATCH 179/399] * [CMake] BugFix: Correctly set the description and
 default values of TORQUE_POSIX_PATH_CASE_INSENSITIVE and
 TORQUE_ZIP_PATH_CASE_INSENSITIVE.

---
 Tools/CMake/torque3d.cmake | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Tools/CMake/torque3d.cmake b/Tools/CMake/torque3d.cmake
index cd09fabd6..97b57260e 100644
--- a/Tools/CMake/torque3d.cmake
+++ b/Tools/CMake/torque3d.cmake
@@ -163,10 +163,10 @@ endif()
 option(TORQUE_MULTITHREAD "Multi Threading" ON)
 mark_as_advanced(TORQUE_MULTITHREAD)
 
-option(TORQUE_POSIX_PATH_CASE_INSENSITIVE ON)
+option(TORQUE_POSIX_PATH_CASE_INSENSITIVE "POSIX Pathing Case Insensitivity" ON)
 mark_as_advanced(TORQUE_POSIX_PATH_CASE_INSENSITIVE)
 
-option(TORQUE_ZIP_PATH_CASE_INSENSITIVE ON)
+option(TORQUE_ZIP_PATH_CASE_INSENSITIVE "ZIP Pathing Case Insensitivity" ON)
 mark_as_advanced(TORQUE_ZIP_PATH_CASE_INSENSITIVE)
 
 option(TORQUE_DISABLE_MEMORY_MANAGER "Disable memory manager" ON)

From ca5e706ab4602b7de09c60a37ceb778810f67624 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Tue, 12 Oct 2021 13:19:28 -0400
Subject: [PATCH 180/399] * [CMake] BugFix: Clear several CMake warnings.

---
 Tools/CMake/basics.cmake | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/Tools/CMake/basics.cmake b/Tools/CMake/basics.cmake
index 952826d97..5a9fc0a42 100644
--- a/Tools/CMake/basics.cmake
+++ b/Tools/CMake/basics.cmake
@@ -364,10 +364,10 @@ macro(finishExecutable)
 endmacro()
 
 macro(setupVersionNumbers)
-    set(TORQUE_APP_VERSION_MAJOR 1 CACHE INTEGER "")
-    set(TORQUE_APP_VERSION_MINOR 0 CACHE INTEGER "")
-    set(TORQUE_APP_VERSION_PATCH 0 CACHE INTEGER "")
-    set(TORQUE_APP_VERSION_TWEAK 0 CACHE INTEGER "")
+    set(TORQUE_APP_VERSION_MAJOR 1 CACHE STRING "")
+    set(TORQUE_APP_VERSION_MINOR 0 CACHE STRING "")
+    set(TORQUE_APP_VERSION_PATCH 0 CACHE STRING "")
+    set(TORQUE_APP_VERSION_TWEAK 0 CACHE STRING "")
     mark_as_advanced(TORQUE_APP_VERSION_TWEAK)
     MATH(EXPR TORQUE_APP_VERSION "${TORQUE_APP_VERSION_MAJOR} * 1000 + ${TORQUE_APP_VERSION_MINOR} * 100 + ${TORQUE_APP_VERSION_PATCH} * 10 + ${TORQUE_APP_VERSION_TWEAK}")
     set(TORQUE_APP_VERSION_STRING "${TORQUE_APP_VERSION_MAJOR}.${TORQUE_APP_VERSION_MINOR}.${TORQUE_APP_VERSION_PATCH}.${TORQUE_APP_VERSION_TWEAK}")
@@ -400,17 +400,17 @@ set(TORQUE_STATIC ON)
 #option(TORQUE_STATIC "enables or disable static" OFF)
 
 if(WIN32)
-    set(TORQUE_CXX_FLAGS_EXECUTABLES "/wd4018 /wd4100 /wd4121 /wd4127 /wd4130 /wd4244 /wd4245 /wd4389 /wd4511 /wd4512 /wd4800 /wd4995 " CACHE TYPE STRING)
+    set(TORQUE_CXX_FLAGS_EXECUTABLES "/wd4018 /wd4100 /wd4121 /wd4127 /wd4130 /wd4244 /wd4245 /wd4389 /wd4511 /wd4512 /wd4800 /wd4995 " CACHE STRING)
     mark_as_advanced(TORQUE_CXX_FLAGS_EXECUTABLES)
 
-    set(TORQUE_CXX_FLAGS_LIBS "/W0" CACHE TYPE STRING)
+    set(TORQUE_CXX_FLAGS_LIBS "/W0" CACHE STRING)
     mark_as_advanced(TORQUE_CXX_FLAGS_LIBS)
 
     set(TORQUE_CXX_FLAGS_COMMON_DEFAULT "-DUNICODE -D_UNICODE -D_CRT_SECURE_NO_WARNINGS /MP /O2 /Ob2 /Oi /Ot /Oy /GT /Zi /W4 /nologo /GF /EHsc /GS- /Gy- /Qpar- /fp:precise /fp:except- /GR /Zc:wchar_t-" )
     if( TORQUE_CPU_X32 )
        set(TORQUE_CXX_FLAGS_COMMON_DEFAULT "${TORQUE_CXX_FLAGS_COMMON_DEFAULT} /arch:SSE2")
     endif()
-    set(TORQUE_CXX_FLAGS_COMMON ${TORQUE_CXX_FLAGS_COMMON_DEFAULT} CACHE TYPE STRING)
+    set(TORQUE_CXX_FLAGS_COMMON ${TORQUE_CXX_FLAGS_COMMON_DEFAULT} CACHE STRING)
 
     mark_as_advanced(TORQUE_CXX_FLAGS_COMMON)
 
@@ -436,11 +436,11 @@ if(WIN32)
     endif()
 else()
     # TODO: improve default settings on other platforms
-    set(TORQUE_CXX_FLAGS_EXECUTABLES "" CACHE TYPE STRING)
+    set(TORQUE_CXX_FLAGS_EXECUTABLES "" CACHE STRING "")
     mark_as_advanced(TORQUE_CXX_FLAGS_EXECUTABLES)
-    set(TORQUE_CXX_FLAGS_LIBS "" CACHE TYPE STRING)
+    set(TORQUE_CXX_FLAGS_LIBS "" CACHE STRING "")
     mark_as_advanced(TORQUE_CXX_FLAGS_LIBS)
-    set(TORQUE_CXX_FLAGS_COMMON "" CACHE TYPE STRING)
+    set(TORQUE_CXX_FLAGS_COMMON "" CACHE STRING "")
     mark_as_advanced(TORQUE_CXX_FLAGS)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${TORQUE_CXX_FLAGS}")
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_CXX_FLAGS}")

From 46b2cc9b53fdd95bc30522b8a56f0b5ebabc2900 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Tue, 12 Oct 2021 14:17:47 -0400
Subject: [PATCH 181/399] * [CMake] Adjustment: Set minimum version to 3.10.2.

---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index eb48b5e97..c1b20657a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 2.8.12)
+cmake_minimum_required (VERSION 3.10.2)
 
 set(TORQUE_APP_NAME "" CACHE STRING "the app name")
 

From 7a78ec46c8e88dd8653ad6db3999be1e59ddd59c Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Tue, 12 Oct 2021 17:20:23 -0400
Subject: [PATCH 182/399] * [lpng] BugFix: Correct some compiler warnings
 associated with lpng and SSE optimizations. This also enables SSE when
 available for lpng.

---
 Tools/CMake/libraries/lpng.cmake | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/Tools/CMake/libraries/lpng.cmake b/Tools/CMake/libraries/lpng.cmake
index 93a32a406..833577e82 100644
--- a/Tools/CMake/libraries/lpng.cmake
+++ b/Tools/CMake/libraries/lpng.cmake
@@ -29,6 +29,11 @@ project(lpng)
 set(PNG_ARM_NEON off CACHE STRING "")
 add_definitions(-DPNG_ARM_NEON_OPT=0)
 
+# Enables SSE for libpng - also takes care of compiler warnings.
+# If we don't want SSE, we should set it to off/0.
+set(PNG_INTEL_SSE on CACHE STRING "")
+add_definitions(-DPNG_INTEL_SSE_OPT=1)
+
 addInclude(${libDir}/zlib)
 
 finishLibrary("${libDir}/${PROJECT_NAME}")

From c965429cf660123556067fafc5ed19064747f042 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Tue, 12 Oct 2021 17:38:27 -0400
Subject: [PATCH 183/399] * [lpng] BugFix: Corrections to allow the SSE
 intrinsics to build properly.

---
 .../lib/lpng/intel/filter_sse2_intrinsics.c   | 406 ++++++++++++++++++
 Engine/lib/lpng/intel/intel_init.c            |  53 +++
 Tools/CMake/basics.cmake                      |   1 +
 Tools/CMake/libraries/lpng.cmake              |  10 +-
 4 files changed, 468 insertions(+), 2 deletions(-)
 create mode 100644 Engine/lib/lpng/intel/filter_sse2_intrinsics.c
 create mode 100644 Engine/lib/lpng/intel/intel_init.c

diff --git a/Engine/lib/lpng/intel/filter_sse2_intrinsics.c b/Engine/lib/lpng/intel/filter_sse2_intrinsics.c
new file mode 100644
index 000000000..5e8553fbb
--- /dev/null
+++ b/Engine/lib/lpng/intel/filter_sse2_intrinsics.c
@@ -0,0 +1,406 @@
+
+/* filter_sse2_intrinsics.c - SSE2 optimized filter functions
+ *
+ * Copyright (c) 2016-2017 Glenn Randers-Pehrson
+ * Written by Mike Klein and Matt Sarett
+ * Derived from arm/filter_neon_intrinsics.c
+ *
+ * Last changed in libpng 1.6.31 [July 27, 2017]
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+#include "../pngpriv.h"
+
+#ifdef PNG_READ_SUPPORTED
+
+#if PNG_INTEL_SSE_IMPLEMENTATION > 0
+
+#include <immintrin.h>
+
+/* Functions in this file look at most 3 pixels (a,b,c) to predict the 4th (d).
+ * They're positioned like this:
+ *    prev:  c b
+ *    row:   a d
+ * The Sub filter predicts d=a, Avg d=(a+b)/2, and Paeth predicts d to be
+ * whichever of a, b, or c is closest to p=a+b-c.
+ */
+
+static __m128i load4(const void* p) {
+   return _mm_cvtsi32_si128(*(const int*)p);
+}
+
+static void store4(void* p, __m128i v) {
+   *(int*)p = _mm_cvtsi128_si32(v);
+}
+
+static __m128i load3(const void* p) {
+   /* We'll load 2 bytes, then 1 byte,
+    * then mask them together, and finally load into SSE.
+    */
+   const png_uint_16* p01 = (png_const_uint_16p)p;
+   const png_byte*    p2  = (const png_byte*)(p01+1);
+
+   png_uint_32 v012 = (png_uint_32)(*p01)
+                    | (png_uint_32)(*p2) << 16;
+   return load4(&v012);
+}
+
+static void store3(void* p, __m128i v) {
+   /* We'll pull from SSE as a 32-bit int, then write
+    * its bottom two bytes, then its third byte.
+    */
+   png_uint_32 v012;
+   png_uint_16* p01;
+   png_byte*    p2;
+
+   store4(&v012, v);
+
+   p01 = (png_uint_16p)p;
+   p2  = (png_byte*)(p01+1);
+   *p01 = (png_uint_16)v012;
+   *p2  = (png_byte)(v012 >> 16);
+}
+
+void png_read_filter_row_sub3_sse2(png_row_infop row_info, png_bytep row,
+   png_const_bytep prev)
+{
+   /* The Sub filter predicts each pixel as the previous pixel, a.
+    * There is no pixel to the left of the first pixel.  It's encoded directly.
+    * That works with our main loop if we just say that left pixel was zero.
+    */
+   png_size_t rb;
+
+   __m128i a, d = _mm_setzero_si128();
+
+   png_debug(1, "in png_read_filter_row_sub3_sse2");
+
+   rb = row_info->rowbytes;
+   while (rb >= 4) {
+      a = d; d = load4(row);
+      d = _mm_add_epi8(d, a);
+      store3(row, d);
+
+      row += 3;
+      rb  -= 3;
+   }
+   if (rb > 0) {
+      a = d; d = load3(row);
+      d = _mm_add_epi8(d, a);
+      store3(row, d);
+
+      row += 3;
+      rb  -= 3;
+   }
+   PNG_UNUSED(prev)
+}
+
+void png_read_filter_row_sub4_sse2(png_row_infop row_info, png_bytep row,
+   png_const_bytep prev)
+{
+   /* The Sub filter predicts each pixel as the previous pixel, a.
+    * There is no pixel to the left of the first pixel.  It's encoded directly.
+    * That works with our main loop if we just say that left pixel was zero.
+    */
+   png_size_t rb;
+
+   __m128i a, d = _mm_setzero_si128();
+
+   png_debug(1, "in png_read_filter_row_sub4_sse2");
+
+   rb = row_info->rowbytes+4;
+   while (rb > 4) {
+      a = d; d = load4(row);
+      d = _mm_add_epi8(d, a);
+      store4(row, d);
+
+      row += 4;
+      rb  -= 4;
+   }
+   PNG_UNUSED(prev)
+}
+
+void png_read_filter_row_avg3_sse2(png_row_infop row_info, png_bytep row,
+   png_const_bytep prev)
+{
+   /* The Avg filter predicts each pixel as the (truncated) average of a and b.
+    * There's no pixel to the left of the first pixel.  Luckily, it's
+    * predicted to be half of the pixel above it.  So again, this works
+    * perfectly with our loop if we make sure a starts at zero.
+    */
+
+   png_size_t rb;
+
+   const __m128i zero = _mm_setzero_si128();
+
+   __m128i    b;
+   __m128i a, d = zero;
+
+   png_debug(1, "in png_read_filter_row_avg3_sse2");
+   rb = row_info->rowbytes;
+   while (rb >= 4) {
+      __m128i avg;
+             b = load4(prev);
+      a = d; d = load4(row );
+
+      /* PNG requires a truncating average, so we can't just use _mm_avg_epu8 */
+      avg = _mm_avg_epu8(a,b);
+      /* ...but we can fix it up by subtracting off 1 if it rounded up. */
+      avg = _mm_sub_epi8(avg, _mm_and_si128(_mm_xor_si128(a,b),
+                                            _mm_set1_epi8(1)));
+      d = _mm_add_epi8(d, avg);
+      store3(row, d);
+
+      prev += 3;
+      row  += 3;
+      rb   -= 3;
+   }
+   if (rb > 0) {
+      __m128i avg;
+             b = load3(prev);
+      a = d; d = load3(row );
+
+      /* PNG requires a truncating average, so we can't just use _mm_avg_epu8 */
+      avg = _mm_avg_epu8(a,b);
+      /* ...but we can fix it up by subtracting off 1 if it rounded up. */
+      avg = _mm_sub_epi8(avg, _mm_and_si128(_mm_xor_si128(a,b),
+                                            _mm_set1_epi8(1)));
+
+      d = _mm_add_epi8(d, avg);
+      store3(row, d);
+
+      prev += 3;
+      row  += 3;
+      rb   -= 3;
+   }
+}
+
+void png_read_filter_row_avg4_sse2(png_row_infop row_info, png_bytep row,
+   png_const_bytep prev)
+{
+   /* The Avg filter predicts each pixel as the (truncated) average of a and b.
+    * There's no pixel to the left of the first pixel.  Luckily, it's
+    * predicted to be half of the pixel above it.  So again, this works
+    * perfectly with our loop if we make sure a starts at zero.
+    */
+   png_size_t rb;
+   const __m128i zero = _mm_setzero_si128();
+   __m128i    b;
+   __m128i a, d = zero;
+
+   png_debug(1, "in png_read_filter_row_avg4_sse2");
+
+   rb = row_info->rowbytes+4;
+   while (rb > 4) {
+      __m128i avg;
+             b = load4(prev);
+      a = d; d = load4(row );
+
+      /* PNG requires a truncating average, so we can't just use _mm_avg_epu8 */
+      avg = _mm_avg_epu8(a,b);
+      /* ...but we can fix it up by subtracting off 1 if it rounded up. */
+      avg = _mm_sub_epi8(avg, _mm_and_si128(_mm_xor_si128(a,b),
+                                            _mm_set1_epi8(1)));
+
+      d = _mm_add_epi8(d, avg);
+      store4(row, d);
+
+      prev += 4;
+      row  += 4;
+      rb   -= 4;
+   }
+}
+
+/* Returns |x| for 16-bit lanes. */
+static __m128i abs_i16(__m128i x) {
+#if PNG_INTEL_SSE_IMPLEMENTATION >= 2
+   return _mm_abs_epi16(x);
+#else
+   /* Read this all as, return x<0 ? -x : x.
+   * To negate two's complement, you flip all the bits then add 1.
+    */
+   __m128i is_negative = _mm_cmplt_epi16(x, _mm_setzero_si128());
+
+   /* Flip negative lanes. */
+   x = _mm_xor_si128(x, is_negative);
+
+   /* +1 to negative lanes, else +0. */
+   x = _mm_sub_epi16(x, is_negative);
+   return x;
+#endif
+}
+
+/* Bytewise c ? t : e. */
+static __m128i if_then_else(__m128i c, __m128i t, __m128i e) {
+#if PNG_INTEL_SSE_IMPLEMENTATION >= 3
+   return _mm_blendv_epi8(e,t,c);
+#else
+   return _mm_or_si128(_mm_and_si128(c, t), _mm_andnot_si128(c, e));
+#endif
+}
+
+void png_read_filter_row_paeth3_sse2(png_row_infop row_info, png_bytep row,
+   png_const_bytep prev)
+{
+   /* Paeth tries to predict pixel d using the pixel to the left of it, a,
+    * and two pixels from the previous row, b and c:
+    *   prev: c b
+    *   row:  a d
+    * The Paeth function predicts d to be whichever of a, b, or c is nearest to
+    * p=a+b-c.
+    *
+    * The first pixel has no left context, and so uses an Up filter, p = b.
+    * This works naturally with our main loop's p = a+b-c if we force a and c
+    * to zero.
+    * Here we zero b and d, which become c and a respectively at the start of
+    * the loop.
+    */
+   png_size_t rb;
+   const __m128i zero = _mm_setzero_si128();
+   __m128i c, b = zero,
+           a, d = zero;
+
+   png_debug(1, "in png_read_filter_row_paeth3_sse2");
+
+   rb = row_info->rowbytes;
+   while (rb >= 4) {
+      /* It's easiest to do this math (particularly, deal with pc) with 16-bit
+       * intermediates.
+       */
+      __m128i pa,pb,pc,smallest,nearest;
+      c = b; b = _mm_unpacklo_epi8(load4(prev), zero);
+      a = d; d = _mm_unpacklo_epi8(load4(row ), zero);
+
+      /* (p-a) == (a+b-c - a) == (b-c) */
+   
+      pa = _mm_sub_epi16(b,c);
+
+      /* (p-b) == (a+b-c - b) == (a-c) */
+      pb = _mm_sub_epi16(a,c);
+
+      /* (p-c) == (a+b-c - c) == (a+b-c-c) == (b-c)+(a-c) */
+      pc = _mm_add_epi16(pa,pb);
+
+      pa = abs_i16(pa);  /* |p-a| */
+      pb = abs_i16(pb);  /* |p-b| */
+      pc = abs_i16(pc);  /* |p-c| */
+
+      smallest = _mm_min_epi16(pc, _mm_min_epi16(pa, pb));
+
+      /* Paeth breaks ties favoring a over b over c. */
+      nearest  = if_then_else(_mm_cmpeq_epi16(smallest, pa), a,
+                 if_then_else(_mm_cmpeq_epi16(smallest, pb), b,
+                                                             c));
+
+      /* Note `_epi8`: we need addition to wrap modulo 255. */
+      d = _mm_add_epi8(d, nearest);
+      store3(row, _mm_packus_epi16(d,d));
+
+      prev += 3;
+      row  += 3;
+      rb   -= 3;
+   }
+   if (rb > 0) {
+      /* It's easiest to do this math (particularly, deal with pc) with 16-bit
+       * intermediates.
+       */
+      __m128i pa,pb,pc,smallest,nearest;
+      c = b; b = _mm_unpacklo_epi8(load3(prev), zero);
+      a = d; d = _mm_unpacklo_epi8(load3(row ), zero);
+
+      /* (p-a) == (a+b-c - a) == (b-c) */
+      pa = _mm_sub_epi16(b,c);
+
+      /* (p-b) == (a+b-c - b) == (a-c) */
+      pb = _mm_sub_epi16(a,c);
+
+      /* (p-c) == (a+b-c - c) == (a+b-c-c) == (b-c)+(a-c) */
+      pc = _mm_add_epi16(pa,pb);
+
+      pa = abs_i16(pa);  /* |p-a| */
+      pb = abs_i16(pb);  /* |p-b| */
+      pc = abs_i16(pc);  /* |p-c| */
+
+      smallest = _mm_min_epi16(pc, _mm_min_epi16(pa, pb));
+
+      /* Paeth breaks ties favoring a over b over c. */
+      nearest  = if_then_else(_mm_cmpeq_epi16(smallest, pa), a,
+                         if_then_else(_mm_cmpeq_epi16(smallest, pb), b,
+                                                                     c));
+
+      /* Note `_epi8`: we need addition to wrap modulo 255. */
+      d = _mm_add_epi8(d, nearest);
+      store3(row, _mm_packus_epi16(d,d));
+
+      prev += 3;
+      row  += 3;
+      rb   -= 3;
+   }
+}
+
+void png_read_filter_row_paeth4_sse2(png_row_infop row_info, png_bytep row,
+   png_const_bytep prev)
+{
+   /* Paeth tries to predict pixel d using the pixel to the left of it, a,
+    * and two pixels from the previous row, b and c:
+    *   prev: c b
+    *   row:  a d
+    * The Paeth function predicts d to be whichever of a, b, or c is nearest to
+    * p=a+b-c.
+    *
+    * The first pixel has no left context, and so uses an Up filter, p = b.
+    * This works naturally with our main loop's p = a+b-c if we force a and c
+    * to zero.
+    * Here we zero b and d, which become c and a respectively at the start of
+    * the loop.
+    */
+   png_size_t rb;
+   const __m128i zero = _mm_setzero_si128();
+   __m128i pa,pb,pc,smallest,nearest;
+   __m128i c, b = zero,
+           a, d = zero;
+
+   png_debug(1, "in png_read_filter_row_paeth4_sse2");
+
+   rb = row_info->rowbytes+4;
+   while (rb > 4) {
+      /* It's easiest to do this math (particularly, deal with pc) with 16-bit
+       * intermediates.
+       */
+      c = b; b = _mm_unpacklo_epi8(load4(prev), zero);
+      a = d; d = _mm_unpacklo_epi8(load4(row ), zero);
+
+      /* (p-a) == (a+b-c - a) == (b-c) */
+      pa = _mm_sub_epi16(b,c);
+
+      /* (p-b) == (a+b-c - b) == (a-c) */
+      pb = _mm_sub_epi16(a,c);
+
+      /* (p-c) == (a+b-c - c) == (a+b-c-c) == (b-c)+(a-c) */
+      pc = _mm_add_epi16(pa,pb);
+
+      pa = abs_i16(pa);  /* |p-a| */
+      pb = abs_i16(pb);  /* |p-b| */
+      pc = abs_i16(pc);  /* |p-c| */
+
+      smallest = _mm_min_epi16(pc, _mm_min_epi16(pa, pb));
+
+      /* Paeth breaks ties favoring a over b over c. */
+      nearest  = if_then_else(_mm_cmpeq_epi16(smallest, pa), a,
+                         if_then_else(_mm_cmpeq_epi16(smallest, pb), b,
+                                                                     c));
+
+      /* Note `_epi8`: we need addition to wrap modulo 255. */
+      d = _mm_add_epi8(d, nearest);
+      store4(row, _mm_packus_epi16(d,d));
+
+      prev += 4;
+      row  += 4;
+      rb   -= 4;
+   }
+}
+
+#endif /* PNG_INTEL_SSE_IMPLEMENTATION > 0 */
+#endif /* READ */
diff --git a/Engine/lib/lpng/intel/intel_init.c b/Engine/lib/lpng/intel/intel_init.c
new file mode 100644
index 000000000..8f08baf8c
--- /dev/null
+++ b/Engine/lib/lpng/intel/intel_init.c
@@ -0,0 +1,53 @@
+
+/* intel_init.c - SSE2 optimized filter functions
+ *
+ * Copyright (c) 2016-2017 Glenn Randers-Pehrson
+ * Written by Mike Klein and Matt Sarett, Google, Inc.
+ * Derived from arm/arm_init.c
+ *
+ * Last changed in libpng 1.6.29 [March 16, 2017]
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+#include "../pngpriv.h"
+
+#ifdef PNG_READ_SUPPORTED
+#if PNG_INTEL_SSE_IMPLEMENTATION > 0
+
+void
+png_init_filter_functions_sse2(png_structp pp, unsigned int bpp)
+{
+   /* The techniques used to implement each of these filters in SSE operate on
+    * one pixel at a time.
+    * So they generally speed up 3bpp images about 3x, 4bpp images about 4x.
+    * They can scale up to 6 and 8 bpp images and down to 2 bpp images,
+    * but they'd not likely have any benefit for 1bpp images.
+    * Most of these can be implemented using only MMX and 64-bit registers,
+    * but they end up a bit slower than using the equally-ubiquitous SSE2.
+   */
+   png_debug(1, "in png_init_filter_functions_sse2");
+   if (bpp == 3)
+   {
+      pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub3_sse2;
+      pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg3_sse2;
+      pp->read_filter[PNG_FILTER_VALUE_PAETH-1] =
+         png_read_filter_row_paeth3_sse2;
+   }
+   else if (bpp == 4)
+   {
+      pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub4_sse2;
+      pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg4_sse2;
+      pp->read_filter[PNG_FILTER_VALUE_PAETH-1] =
+          png_read_filter_row_paeth4_sse2;
+   }
+
+   /* No need optimize PNG_FILTER_VALUE_UP.  The compiler should
+    * autovectorize.
+    */
+}
+
+#endif /* PNG_INTEL_SSE_IMPLEMENTATION > 0 */
+#endif /* PNG_READ_SUPPORTED */
diff --git a/Tools/CMake/basics.cmake b/Tools/CMake/basics.cmake
index 5a9fc0a42..c46386db2 100644
--- a/Tools/CMake/basics.cmake
+++ b/Tools/CMake/basics.cmake
@@ -300,6 +300,7 @@ macro(finishLibrary)
     # more paths?
     if(${ARGC} GREATER 0)
         foreach(dir ${ARGV0})
+            MESSAGE(STATUS "TEST: ${dir}")
             addPath("${dir}")
         endforeach()
     endif()
diff --git a/Tools/CMake/libraries/lpng.cmake b/Tools/CMake/libraries/lpng.cmake
index 833577e82..0d4307239 100644
--- a/Tools/CMake/libraries/lpng.cmake
+++ b/Tools/CMake/libraries/lpng.cmake
@@ -31,8 +31,14 @@ add_definitions(-DPNG_ARM_NEON_OPT=0)
 
 # Enables SSE for libpng - also takes care of compiler warnings.
 # If we don't want SSE, we should set it to off/0.
-set(PNG_INTEL_SSE on CACHE STRING "")
-add_definitions(-DPNG_INTEL_SSE_OPT=1)
+if ( TORQUE_CPU_X32 OR TORQUE_CPU_X64 )
+    set(PNG_INTEL_SSE on CACHE STRING "")
+    add_definitions(-DPNG_INTEL_SSE_OPT=1)
+    addPath("${libDir}/lpng/intel")
+else()
+    set(PNG_INTEL_SSE off CACHE STRING "")
+    add_definitions(-DPNG_INTEL_SSE_OPT=0)
+endif()
 
 addInclude(${libDir}/zlib)
 

From c0ff69a2e6fbcf382ba6f5da791238f8d6af5734 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Tue, 12 Oct 2021 18:44:32 -0400
Subject: [PATCH 184/399] * [CMake] BugFix: Remove a forgotten debug message.

---
 Tools/CMake/basics.cmake | 1 -
 1 file changed, 1 deletion(-)

diff --git a/Tools/CMake/basics.cmake b/Tools/CMake/basics.cmake
index c46386db2..5a9fc0a42 100644
--- a/Tools/CMake/basics.cmake
+++ b/Tools/CMake/basics.cmake
@@ -300,7 +300,6 @@ macro(finishLibrary)
     # more paths?
     if(${ARGC} GREATER 0)
         foreach(dir ${ARGV0})
-            MESSAGE(STATUS "TEST: ${dir}")
             addPath("${dir}")
         endforeach()
     endif()

From 2f3215c4fb76e9547ba9b06ad3283feb2ba8b524 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Tue, 12 Oct 2021 22:04:36 -0400
Subject: [PATCH 185/399] * [lpng] Adjustment: Update libpng to version 1.6.37.

---
 Engine/lib/lpng/ANNOUNCE                      |    58 +-
 Engine/lib/lpng/AUTHORS                       |    45 +
 Engine/lib/lpng/CHANGES                       |   104 +-
 Engine/lib/lpng/CMakeLists.txt                |   320 +-
 Engine/lib/lpng/INSTALL                       |     2 +-
 Engine/lib/lpng/LICENSE                       |   177 +-
 Engine/lib/lpng/Makefile.am                   |   393 +
 Engine/lib/lpng/Makefile.in                   |  2428 +++
 Engine/lib/lpng/README                        |   111 +-
 Engine/lib/lpng/TODO                          |    49 +-
 Engine/lib/lpng/TRADEMARK                     |     8 +
 Engine/lib/lpng/aclocal.m4                    |  1196 ++
 Engine/lib/lpng/arm/arm_init.c                |   136 +
 Engine/lib/lpng/arm/filter_neon.S             |   253 +
 Engine/lib/lpng/arm/filter_neon_intrinsics.c  |   402 +
 Engine/lib/lpng/arm/palette_neon_intrinsics.c |   149 +
 Engine/lib/lpng/autogen.sh                    |   225 +
 Engine/lib/lpng/compile                       |   348 +
 Engine/lib/lpng/config.guess                  |  1476 ++
 Engine/lib/lpng/config.h.in                   |   126 +
 Engine/lib/lpng/config.sub                    |  1801 ++
 Engine/lib/lpng/configure                     | 16116 ++++++++++++++++
 Engine/lib/lpng/configure.ac                  |   532 +
 Engine/lib/lpng/contrib/README.txt            |     5 +
 Engine/lib/lpng/contrib/arm-neon/README       |    83 +
 .../lib/lpng/contrib/arm-neon/android-ndk.c   |    39 +
 Engine/lib/lpng/contrib/arm-neon/linux-auxv.c |   120 +
 Engine/lib/lpng/contrib/arm-neon/linux.c      |   161 +
 Engine/lib/lpng/contrib/conftest/README       |    49 +
 Engine/lib/lpng/contrib/conftest/pngcp.dfa    |    57 +
 Engine/lib/lpng/contrib/conftest/read.dfa     |    58 +
 Engine/lib/lpng/contrib/conftest/s_read.dfa   |    35 +
 Engine/lib/lpng/contrib/conftest/s_write.dfa  |    33 +
 Engine/lib/lpng/contrib/conftest/simple.dfa   |    36 +
 Engine/lib/lpng/contrib/conftest/write.dfa    |    45 +
 Engine/lib/lpng/contrib/examples/README.txt   |    24 +
 Engine/lib/lpng/contrib/examples/iccfrompng.c |   185 +
 Engine/lib/lpng/contrib/examples/pngpixel.c   |   371 +
 Engine/lib/lpng/contrib/examples/pngtopng.c   |    98 +
 Engine/lib/lpng/contrib/examples/simpleover.c |   648 +
 Engine/lib/lpng/contrib/gregbook/COPYING      |   340 +
 Engine/lib/lpng/contrib/gregbook/LICENSE      |    50 +
 .../lpng/contrib/gregbook/Makefile.mingw32    |   131 +
 Engine/lib/lpng/contrib/gregbook/Makefile.sgi |   105 +
 Engine/lib/lpng/contrib/gregbook/Makefile.unx |   134 +
 Engine/lib/lpng/contrib/gregbook/Makefile.w32 |   114 +
 Engine/lib/lpng/contrib/gregbook/README       |   186 +
 Engine/lib/lpng/contrib/gregbook/makevms.com  |   132 +
 Engine/lib/lpng/contrib/gregbook/readpng.c    |   323 +
 Engine/lib/lpng/contrib/gregbook/readpng.h    |    88 +
 Engine/lib/lpng/contrib/gregbook/readpng2.c   |   521 +
 Engine/lib/lpng/contrib/gregbook/readpng2.h   |   116 +
 Engine/lib/lpng/contrib/gregbook/readppm.c    |   188 +
 Engine/lib/lpng/contrib/gregbook/rpng-win.c   |   735 +
 Engine/lib/lpng/contrib/gregbook/rpng-x.c     |   911 +
 Engine/lib/lpng/contrib/gregbook/rpng2-win.c  |  1261 ++
 Engine/lib/lpng/contrib/gregbook/rpng2-x.c    |  2143 ++
 Engine/lib/lpng/contrib/gregbook/toucan.png   |   Bin 0 -> 12901 bytes
 Engine/lib/lpng/contrib/gregbook/wpng.c       |   865 +
 Engine/lib/lpng/contrib/gregbook/writepng.c   |   401 +
 Engine/lib/lpng/contrib/gregbook/writepng.h   |   133 +
 Engine/lib/lpng/contrib/libtests/fakepng.c    |    65 +
 Engine/lib/lpng/contrib/libtests/gentests.sh  |   102 +
 Engine/lib/lpng/contrib/libtests/makepng.c    |  1941 ++
 Engine/lib/lpng/contrib/libtests/pngimage.c   |  1712 ++
 .../lpng/contrib/libtests/pngstest-errors.h   |   165 +
 Engine/lib/lpng/contrib/libtests/pngstest.c   |  3828 ++++
 Engine/lib/lpng/contrib/libtests/pngunknown.c |  1294 ++
 Engine/lib/lpng/contrib/libtests/pngvalid.c   | 12230 ++++++++++++
 Engine/lib/lpng/contrib/libtests/readpng.c    |   115 +
 Engine/lib/lpng/contrib/libtests/tarith.c     |   999 +
 Engine/lib/lpng/contrib/libtests/timepng.c    |   608 +
 Engine/lib/lpng/contrib/mips-msa/README       |    83 +
 Engine/lib/lpng/contrib/mips-msa/linux.c      |    64 +
 Engine/lib/lpng/contrib/oss-fuzz/Dockerfile   |    25 +
 Engine/lib/lpng/contrib/oss-fuzz/README.txt   |    37 +
 Engine/lib/lpng/contrib/oss-fuzz/build.sh     |    51 +
 .../contrib/oss-fuzz/libpng_read_fuzzer.cc    |   190 +
 .../oss-fuzz/libpng_read_fuzzer.options       |     2 +
 Engine/lib/lpng/contrib/oss-fuzz/png.dict     |    39 +
 Engine/lib/lpng/contrib/pngminim/README       |     5 +
 .../lib/lpng/contrib/pngminim/decoder/README  |    10 +
 .../lpng/contrib/pngminim/decoder/makefile    |   151 +
 .../lpng/contrib/pngminim/decoder/pngusr.dfa  |    40 +
 .../lpng/contrib/pngminim/decoder/pngusr.h    |    23 +
 .../lib/lpng/contrib/pngminim/encoder/README  |    10 +
 .../lpng/contrib/pngminim/encoder/makefile    |   150 +
 .../lpng/contrib/pngminim/encoder/pngusr.dfa  |    39 +
 .../lpng/contrib/pngminim/encoder/pngusr.h    |    23 +
 .../lib/lpng/contrib/pngminim/preader/README  |    15 +
 .../lpng/contrib/pngminim/preader/makefile    |   166 +
 .../lpng/contrib/pngminim/preader/pngusr.dfa  |    40 +
 .../lpng/contrib/pngminim/preader/pngusr.h    |    23 +
 Engine/lib/lpng/contrib/pngminus/CHANGES.txt  |    13 +
 .../lib/lpng/contrib/pngminus/CMakeLists.txt  |    24 +
 Engine/lib/lpng/contrib/pngminus/LICENSE.txt  |    22 +
 Engine/lib/lpng/contrib/pngminus/Makefile     |    62 +
 Engine/lib/lpng/contrib/pngminus/README.txt   |   120 +
 Engine/lib/lpng/contrib/pngminus/makevms.com  |    92 +
 Engine/lib/lpng/contrib/pngminus/png2pnm.bat  |    41 +
 Engine/lib/lpng/contrib/pngminus/png2pnm.c    |   427 +
 Engine/lib/lpng/contrib/pngminus/png2pnm.sh   |    42 +
 Engine/lib/lpng/contrib/pngminus/pngminus.bat |     4 +
 Engine/lib/lpng/contrib/pngminus/pngminus.sh  |     5 +
 Engine/lib/lpng/contrib/pngminus/pnm2png.bat  |    41 +
 Engine/lib/lpng/contrib/pngminus/pnm2png.c    |   620 +
 Engine/lib/lpng/contrib/pngminus/pnm2png.sh   |    42 +
 Engine/lib/lpng/contrib/pngsuite/README       |   107 +
 .../pngsuite/bad_interlace_conversions.txt    |     9 +
 Engine/lib/lpng/contrib/pngsuite/basn0g01.png |   Bin 0 -> 164 bytes
 Engine/lib/lpng/contrib/pngsuite/basn0g02.png |   Bin 0 -> 104 bytes
 Engine/lib/lpng/contrib/pngsuite/basn0g04.png |   Bin 0 -> 145 bytes
 Engine/lib/lpng/contrib/pngsuite/basn0g08.png |   Bin 0 -> 138 bytes
 Engine/lib/lpng/contrib/pngsuite/basn0g16.png |   Bin 0 -> 167 bytes
 Engine/lib/lpng/contrib/pngsuite/basn2c08.png |   Bin 0 -> 145 bytes
 Engine/lib/lpng/contrib/pngsuite/basn2c16.png |   Bin 0 -> 302 bytes
 Engine/lib/lpng/contrib/pngsuite/basn3p01.png |   Bin 0 -> 112 bytes
 Engine/lib/lpng/contrib/pngsuite/basn3p02.png |   Bin 0 -> 146 bytes
 Engine/lib/lpng/contrib/pngsuite/basn3p04.png |   Bin 0 -> 216 bytes
 Engine/lib/lpng/contrib/pngsuite/basn3p08.png |   Bin 0 -> 1286 bytes
 Engine/lib/lpng/contrib/pngsuite/basn4a08.png |   Bin 0 -> 126 bytes
 Engine/lib/lpng/contrib/pngsuite/basn4a16.png |   Bin 0 -> 2206 bytes
 Engine/lib/lpng/contrib/pngsuite/basn6a08.png |   Bin 0 -> 184 bytes
 Engine/lib/lpng/contrib/pngsuite/basn6a16.png |   Bin 0 -> 3435 bytes
 .../lib/lpng/contrib/pngsuite/ftbbn0g01.png   |   Bin 0 -> 176 bytes
 .../lib/lpng/contrib/pngsuite/ftbbn0g02.png   |   Bin 0 -> 197 bytes
 .../lib/lpng/contrib/pngsuite/ftbbn0g04.png   |   Bin 0 -> 429 bytes
 .../lib/lpng/contrib/pngsuite/ftbbn2c16.png   |   Bin 0 -> 2041 bytes
 .../lib/lpng/contrib/pngsuite/ftbbn3p08.png   |   Bin 0 -> 1499 bytes
 .../lib/lpng/contrib/pngsuite/ftbgn2c16.png   |   Bin 0 -> 2041 bytes
 .../lib/lpng/contrib/pngsuite/ftbgn3p08.png   |   Bin 0 -> 1499 bytes
 .../lib/lpng/contrib/pngsuite/ftbrn2c08.png   |   Bin 0 -> 1633 bytes
 .../lib/lpng/contrib/pngsuite/ftbwn0g16.png   |   Bin 0 -> 1313 bytes
 .../lib/lpng/contrib/pngsuite/ftbwn3p08.png   |   Bin 0 -> 1496 bytes
 .../lib/lpng/contrib/pngsuite/ftbyn3p08.png   |   Bin 0 -> 1499 bytes
 .../lib/lpng/contrib/pngsuite/ftp0n0g08.png   |   Bin 0 -> 719 bytes
 .../lib/lpng/contrib/pngsuite/ftp0n2c08.png   |   Bin 0 -> 1594 bytes
 .../lib/lpng/contrib/pngsuite/ftp0n3p08.png   |   Bin 0 -> 1476 bytes
 .../lib/lpng/contrib/pngsuite/ftp1n3p08.png   |   Bin 0 -> 1483 bytes
 .../lib/lpng/contrib/pngsuite/ibasn0g08.png   |   Bin 0 -> 237 bytes
 .../lib/lpng/contrib/pngsuite/ibasn0g16.png   |   Bin 0 -> 274 bytes
 .../lib/lpng/contrib/pngsuite/ibasn2c08.png   |   Bin 0 -> 299 bytes
 .../lib/lpng/contrib/pngsuite/ibasn2c16.png   |   Bin 0 -> 558 bytes
 .../lib/lpng/contrib/pngsuite/ibasn3p08.png   |   Bin 0 -> 1492 bytes
 .../lib/lpng/contrib/pngsuite/ibasn4a08.png   |   Bin 0 -> 198 bytes
 .../lib/lpng/contrib/pngsuite/ibasn4a16.png   |   Bin 0 -> 2839 bytes
 .../lib/lpng/contrib/pngsuite/ibasn6a08.png   |   Bin 0 -> 339 bytes
 .../lib/lpng/contrib/pngsuite/ibasn6a16.png   |   Bin 0 -> 4164 bytes
 .../lib/lpng/contrib/pngsuite/iftbbn2c16.png  |   Bin 0 -> 2624 bytes
 .../lib/lpng/contrib/pngsuite/iftbbn3p08.png  |   Bin 0 -> 1507 bytes
 .../lib/lpng/contrib/pngsuite/iftbgn2c16.png  |   Bin 0 -> 2624 bytes
 .../lib/lpng/contrib/pngsuite/iftbgn3p08.png  |   Bin 0 -> 1507 bytes
 .../lib/lpng/contrib/pngsuite/iftbrn2c08.png  |   Bin 0 -> 1624 bytes
 .../lib/lpng/contrib/pngsuite/iftbwn0g16.png  |   Bin 0 -> 1448 bytes
 .../lib/lpng/contrib/pngsuite/iftbwn3p08.png  |   Bin 0 -> 1507 bytes
 .../lib/lpng/contrib/pngsuite/iftbyn3p08.png  |   Bin 0 -> 1507 bytes
 .../lib/lpng/contrib/pngsuite/iftp0n0g08.png  |   Bin 0 -> 847 bytes
 .../lib/lpng/contrib/pngsuite/iftp0n2c08.png  |   Bin 0 -> 2020 bytes
 .../lib/lpng/contrib/pngsuite/iftp0n3p08.png  |   Bin 0 -> 1495 bytes
 .../lib/lpng/contrib/pngsuite/iftp1n3p08.png  |   Bin 0 -> 1507 bytes
 .../lpng/contrib/pngsuite/interlaced/README   |     2 +
 .../contrib/pngsuite/interlaced/ibasn0g01.png |   Bin 0 -> 201 bytes
 .../contrib/pngsuite/interlaced/ibasn0g02.png |   Bin 0 -> 138 bytes
 .../contrib/pngsuite/interlaced/ibasn0g04.png |   Bin 0 -> 231 bytes
 .../contrib/pngsuite/interlaced/ibasn3p01.png |   Bin 0 -> 116 bytes
 .../contrib/pngsuite/interlaced/ibasn3p02.png |   Bin 0 -> 163 bytes
 .../contrib/pngsuite/interlaced/ibasn3p04.png |   Bin 0 -> 288 bytes
 .../pngsuite/interlaced/iftbbn0g01.png        |   Bin 0 -> 214 bytes
 .../pngsuite/interlaced/iftbbn0g02.png        |   Bin 0 -> 211 bytes
 .../pngsuite/interlaced/iftbbn0g04.png        |   Bin 0 -> 489 bytes
 Engine/lib/lpng/contrib/powerpc-vsx/README    |    81 +
 Engine/lib/lpng/contrib/powerpc-vsx/linux.c   |    57 +
 .../lib/lpng/contrib/powerpc-vsx/linux_aux.c  |    34 +
 .../contrib/testpngs/crashers/bad_iCCP.png    |   Bin 0 -> 321 bytes
 .../contrib/testpngs/crashers/badadler.png    |   Bin 0 -> 67 bytes
 .../lpng/contrib/testpngs/crashers/badcrc.png |   Bin 0 -> 67 bytes
 .../crashers/empty_ancillary_chunks.png       |   Bin 0 -> 730 bytes
 .../contrib/testpngs/crashers/huge_IDAT.png   |   Bin 0 -> 79 bytes
 .../testpngs/crashers/huge_bKGD_chunk.png     |   Bin 0 -> 57 bytes
 .../testpngs/crashers/huge_cHRM_chunk.png     |   Bin 0 -> 57 bytes
 .../testpngs/crashers/huge_eXIf_chunk.png     |   Bin 0 -> 57 bytes
 .../testpngs/crashers/huge_gAMA_chunk.png     |   Bin 0 -> 57 bytes
 .../testpngs/crashers/huge_hIST_chunk.png     |   Bin 0 -> 57 bytes
 .../testpngs/crashers/huge_iCCP_chunk.png     |   Bin 0 -> 57 bytes
 .../testpngs/crashers/huge_iTXt_chunk.png     |   Bin 0 -> 57 bytes
 .../crashers/huge_juNK_unsafe_to_copy.png     |   Bin 0 -> 57 bytes
 .../crashers/huge_juNk_safe_to_copy.png       |   Bin 0 -> 57 bytes
 .../testpngs/crashers/huge_pCAL_chunk.png     |   Bin 0 -> 57 bytes
 .../testpngs/crashers/huge_pHYs_chunk.png     |   Bin 0 -> 57 bytes
 .../testpngs/crashers/huge_sCAL_chunk.png     |   Bin 0 -> 57 bytes
 .../testpngs/crashers/huge_sPLT_chunk.png     |   Bin 0 -> 57 bytes
 .../testpngs/crashers/huge_sRGB_chunk.png     |   Bin 0 -> 57 bytes
 .../testpngs/crashers/huge_sTER_chunk.png     |   Bin 0 -> 57 bytes
 .../testpngs/crashers/huge_tEXt_chunk.png     |   Bin 0 -> 57 bytes
 .../testpngs/crashers/huge_tIME_chunk.png     |   Bin 0 -> 57 bytes
 .../testpngs/crashers/huge_zTXt_chunk.png     |   Bin 0 -> 57 bytes
 .../lpng/contrib/testpngs/gray-1-1.8-tRNS.png |   Bin 0 -> 325 bytes
 .../lib/lpng/contrib/testpngs/gray-1-1.8.png  |   Bin 0 -> 311 bytes
 .../contrib/testpngs/gray-1-linear-tRNS.png   |   Bin 0 -> 325 bytes
 .../lpng/contrib/testpngs/gray-1-linear.png   |   Bin 0 -> 311 bytes
 .../contrib/testpngs/gray-1-sRGB-tRNS.png     |   Bin 0 -> 278 bytes
 .../lib/lpng/contrib/testpngs/gray-1-sRGB.png |   Bin 0 -> 264 bytes
 .../lib/lpng/contrib/testpngs/gray-1-tRNS.png |   Bin 0 -> 265 bytes
 Engine/lib/lpng/contrib/testpngs/gray-1.png   |   Bin 0 -> 251 bytes
 .../contrib/testpngs/gray-16-1.8-tRNS.png     |   Bin 0 -> 744 bytes
 .../lib/lpng/contrib/testpngs/gray-16-1.8.png |   Bin 0 -> 744 bytes
 .../contrib/testpngs/gray-16-linear-tRNS.png  |   Bin 0 -> 744 bytes
 .../lpng/contrib/testpngs/gray-16-linear.png  |   Bin 0 -> 744 bytes
 .../contrib/testpngs/gray-16-sRGB-tRNS.png    |   Bin 0 -> 697 bytes
 .../lpng/contrib/testpngs/gray-16-sRGB.png    |   Bin 0 -> 697 bytes
 .../lpng/contrib/testpngs/gray-16-tRNS.png    |   Bin 0 -> 684 bytes
 Engine/lib/lpng/contrib/testpngs/gray-16.png  |   Bin 0 -> 684 bytes
 .../lpng/contrib/testpngs/gray-2-1.8-tRNS.png |   Bin 0 -> 325 bytes
 .../lib/lpng/contrib/testpngs/gray-2-1.8.png  |   Bin 0 -> 311 bytes
 .../contrib/testpngs/gray-2-linear-tRNS.png   |   Bin 0 -> 325 bytes
 .../lpng/contrib/testpngs/gray-2-linear.png   |   Bin 0 -> 311 bytes
 .../contrib/testpngs/gray-2-sRGB-tRNS.png     |   Bin 0 -> 278 bytes
 .../lib/lpng/contrib/testpngs/gray-2-sRGB.png |   Bin 0 -> 264 bytes
 .../lib/lpng/contrib/testpngs/gray-2-tRNS.png |   Bin 0 -> 265 bytes
 Engine/lib/lpng/contrib/testpngs/gray-2.png   |   Bin 0 -> 251 bytes
 .../lpng/contrib/testpngs/gray-4-1.8-tRNS.png |   Bin 0 -> 327 bytes
 .../lib/lpng/contrib/testpngs/gray-4-1.8.png  |   Bin 0 -> 313 bytes
 .../contrib/testpngs/gray-4-linear-tRNS.png   |   Bin 0 -> 327 bytes
 .../lpng/contrib/testpngs/gray-4-linear.png   |   Bin 0 -> 313 bytes
 .../contrib/testpngs/gray-4-sRGB-tRNS.png     |   Bin 0 -> 280 bytes
 .../lib/lpng/contrib/testpngs/gray-4-sRGB.png |   Bin 0 -> 266 bytes
 .../lib/lpng/contrib/testpngs/gray-4-tRNS.png |   Bin 0 -> 267 bytes
 Engine/lib/lpng/contrib/testpngs/gray-4.png   |   Bin 0 -> 253 bytes
 .../lpng/contrib/testpngs/gray-8-1.8-tRNS.png |   Bin 0 -> 327 bytes
 .../lib/lpng/contrib/testpngs/gray-8-1.8.png  |   Bin 0 -> 313 bytes
 .../contrib/testpngs/gray-8-linear-tRNS.png   |   Bin 0 -> 327 bytes
 .../lpng/contrib/testpngs/gray-8-linear.png   |   Bin 0 -> 313 bytes
 .../contrib/testpngs/gray-8-sRGB-tRNS.png     |   Bin 0 -> 280 bytes
 .../lib/lpng/contrib/testpngs/gray-8-sRGB.png |   Bin 0 -> 266 bytes
 .../lib/lpng/contrib/testpngs/gray-8-tRNS.png |   Bin 0 -> 267 bytes
 Engine/lib/lpng/contrib/testpngs/gray-8.png   |   Bin 0 -> 253 bytes
 .../contrib/testpngs/gray-alpha-16-1.8.png    |   Bin 0 -> 919 bytes
 .../contrib/testpngs/gray-alpha-16-linear.png |   Bin 0 -> 919 bytes
 .../contrib/testpngs/gray-alpha-16-sRGB.png   |   Bin 0 -> 872 bytes
 .../lpng/contrib/testpngs/gray-alpha-16.png   |   Bin 0 -> 859 bytes
 .../contrib/testpngs/gray-alpha-8-1.8.png     |   Bin 0 -> 744 bytes
 .../contrib/testpngs/gray-alpha-8-linear.png  |   Bin 0 -> 744 bytes
 .../contrib/testpngs/gray-alpha-8-sRGB.png    |   Bin 0 -> 697 bytes
 .../lpng/contrib/testpngs/gray-alpha-8.png    |   Bin 0 -> 684 bytes
 Engine/lib/lpng/contrib/testpngs/makepngs.sh  |    94 +
 .../contrib/testpngs/palette-1-1.8-tRNS.png   |   Bin 0 -> 342 bytes
 .../lpng/contrib/testpngs/palette-1-1.8.png   |   Bin 0 -> 329 bytes
 .../testpngs/palette-1-linear-tRNS.png        |   Bin 0 -> 342 bytes
 .../contrib/testpngs/palette-1-linear.png     |   Bin 0 -> 329 bytes
 .../contrib/testpngs/palette-1-sRGB-tRNS.png  |   Bin 0 -> 295 bytes
 .../lpng/contrib/testpngs/palette-1-sRGB.png  |   Bin 0 -> 282 bytes
 .../lpng/contrib/testpngs/palette-1-tRNS.png  |   Bin 0 -> 282 bytes
 .../lib/lpng/contrib/testpngs/palette-1.png   |   Bin 0 -> 269 bytes
 .../contrib/testpngs/palette-2-1.8-tRNS.png   |   Bin 0 -> 350 bytes
 .../lpng/contrib/testpngs/palette-2-1.8.png   |   Bin 0 -> 335 bytes
 .../testpngs/palette-2-linear-tRNS.png        |   Bin 0 -> 350 bytes
 .../contrib/testpngs/palette-2-linear.png     |   Bin 0 -> 335 bytes
 .../contrib/testpngs/palette-2-sRGB-tRNS.png  |   Bin 0 -> 303 bytes
 .../lpng/contrib/testpngs/palette-2-sRGB.png  |   Bin 0 -> 288 bytes
 .../lpng/contrib/testpngs/palette-2-tRNS.png  |   Bin 0 -> 290 bytes
 .../lib/lpng/contrib/testpngs/palette-2.png   |   Bin 0 -> 275 bytes
 .../contrib/testpngs/palette-4-1.8-tRNS.png   |   Bin 0 -> 400 bytes
 .../lpng/contrib/testpngs/palette-4-1.8.png   |   Bin 0 -> 373 bytes
 .../testpngs/palette-4-linear-tRNS.png        |   Bin 0 -> 400 bytes
 .../contrib/testpngs/palette-4-linear.png     |   Bin 0 -> 373 bytes
 .../contrib/testpngs/palette-4-sRGB-tRNS.png  |   Bin 0 -> 353 bytes
 .../lpng/contrib/testpngs/palette-4-sRGB.png  |   Bin 0 -> 326 bytes
 .../lpng/contrib/testpngs/palette-4-tRNS.png  |   Bin 0 -> 340 bytes
 .../lib/lpng/contrib/testpngs/palette-4.png   |   Bin 0 -> 313 bytes
 .../contrib/testpngs/palette-8-1.8-tRNS.png   |   Bin 0 -> 1360 bytes
 .../lpng/contrib/testpngs/palette-8-1.8.png   |   Bin 0 -> 1093 bytes
 .../testpngs/palette-8-linear-tRNS.png        |   Bin 0 -> 1360 bytes
 .../contrib/testpngs/palette-8-linear.png     |   Bin 0 -> 1093 bytes
 .../contrib/testpngs/palette-8-sRGB-tRNS.png  |   Bin 0 -> 1313 bytes
 .../lpng/contrib/testpngs/palette-8-sRGB.png  |   Bin 0 -> 1046 bytes
 .../lpng/contrib/testpngs/palette-8-tRNS.png  |   Bin 0 -> 1300 bytes
 .../lib/lpng/contrib/testpngs/palette-8.png   |   Bin 0 -> 1033 bytes
 .../lpng/contrib/testpngs/rgb-16-1.8-tRNS.png |   Bin 0 -> 1211 bytes
 .../lib/lpng/contrib/testpngs/rgb-16-1.8.png  |   Bin 0 -> 1211 bytes
 .../contrib/testpngs/rgb-16-linear-tRNS.png   |   Bin 0 -> 1211 bytes
 .../lpng/contrib/testpngs/rgb-16-linear.png   |   Bin 0 -> 1211 bytes
 .../contrib/testpngs/rgb-16-sRGB-tRNS.png     |   Bin 0 -> 1164 bytes
 .../lib/lpng/contrib/testpngs/rgb-16-sRGB.png |   Bin 0 -> 1164 bytes
 .../lib/lpng/contrib/testpngs/rgb-16-tRNS.png |   Bin 0 -> 1151 bytes
 Engine/lib/lpng/contrib/testpngs/rgb-16.png   |   Bin 0 -> 1151 bytes
 .../lpng/contrib/testpngs/rgb-8-1.8-tRNS.png  |   Bin 0 -> 837 bytes
 .../lib/lpng/contrib/testpngs/rgb-8-1.8.png   |   Bin 0 -> 819 bytes
 .../contrib/testpngs/rgb-8-linear-tRNS.png    |   Bin 0 -> 837 bytes
 .../lpng/contrib/testpngs/rgb-8-linear.png    |   Bin 0 -> 819 bytes
 .../lpng/contrib/testpngs/rgb-8-sRGB-tRNS.png |   Bin 0 -> 790 bytes
 .../lib/lpng/contrib/testpngs/rgb-8-sRGB.png  |   Bin 0 -> 772 bytes
 .../lib/lpng/contrib/testpngs/rgb-8-tRNS.png  |   Bin 0 -> 777 bytes
 Engine/lib/lpng/contrib/testpngs/rgb-8.png    |   Bin 0 -> 759 bytes
 .../contrib/testpngs/rgb-alpha-16-1.8.png     |   Bin 0 -> 1437 bytes
 .../contrib/testpngs/rgb-alpha-16-linear.png  |   Bin 0 -> 1437 bytes
 .../contrib/testpngs/rgb-alpha-16-sRGB.png    |   Bin 0 -> 1390 bytes
 .../lpng/contrib/testpngs/rgb-alpha-16.png    |   Bin 0 -> 1377 bytes
 .../lpng/contrib/testpngs/rgb-alpha-8-1.8.png |   Bin 0 -> 919 bytes
 .../contrib/testpngs/rgb-alpha-8-linear.png   |   Bin 0 -> 919 bytes
 .../contrib/testpngs/rgb-alpha-8-sRGB.png     |   Bin 0 -> 872 bytes
 .../lib/lpng/contrib/testpngs/rgb-alpha-8.png |   Bin 0 -> 859 bytes
 Engine/lib/lpng/contrib/tools/README.txt      |    27 +
 Engine/lib/lpng/contrib/tools/checksum-icc.c  |   102 +
 Engine/lib/lpng/contrib/tools/chkfmt          |   144 +
 Engine/lib/lpng/contrib/tools/cvtcolor.c      |   188 +
 Engine/lib/lpng/contrib/tools/genpng.c        |   881 +
 Engine/lib/lpng/contrib/tools/intgamma.sh     |   110 +
 Engine/lib/lpng/contrib/tools/makesRGB.c      |   430 +
 Engine/lib/lpng/contrib/tools/png-fix-itxt.c  |   164 +
 Engine/lib/lpng/contrib/tools/pngcp.c         |  2453 +++
 Engine/lib/lpng/contrib/tools/pngfix.c        |  4049 ++++
 Engine/lib/lpng/contrib/tools/reindent        |    25 +
 Engine/lib/lpng/contrib/tools/sRGB.h          |    48 +
 Engine/lib/lpng/contrib/visupng/PngFile.c     |   454 +
 Engine/lib/lpng/contrib/visupng/PngFile.h     |    30 +
 Engine/lib/lpng/contrib/visupng/README.txt    |    61 +
 Engine/lib/lpng/contrib/visupng/VisualPng.c   |   978 +
 Engine/lib/lpng/contrib/visupng/VisualPng.dsp |   147 +
 Engine/lib/lpng/contrib/visupng/VisualPng.dsw |    29 +
 Engine/lib/lpng/contrib/visupng/VisualPng.ico |   Bin 0 -> 766 bytes
 Engine/lib/lpng/contrib/visupng/VisualPng.png |   Bin 0 -> 208 bytes
 Engine/lib/lpng/contrib/visupng/VisualPng.rc  |   152 +
 Engine/lib/lpng/contrib/visupng/cexcept.h     |   248 +
 Engine/lib/lpng/contrib/visupng/resource.h    |    23 +
 Engine/lib/lpng/depcomp                       |   791 +
 Engine/lib/lpng/example.c                     |   436 +-
 Engine/lib/lpng/install-sh                    |   518 +
 .../lib/lpng/intel/filter_sse2_intrinsics.c   |    49 +-
 Engine/lib/lpng/intel/intel_init.c            |     3 +-
 Engine/lib/lpng/libpng-manual.txt             |   157 +-
 Engine/lib/lpng/libpng.3                      |   383 +-
 Engine/lib/lpng/libpngpf.3                    |    22 +-
 Engine/lib/lpng/ltmain.sh                     | 11147 +++++++++++
 Engine/lib/lpng/mips/filter_msa_intrinsics.c  |   808 +
 Engine/lib/lpng/mips/mips_init.c              |   130 +
 Engine/lib/lpng/missing                       |   215 +
 Engine/lib/lpng/png.5                         |    66 +-
 Engine/lib/lpng/png.c                         |    83 +-
 Engine/lib/lpng/png.h                         |   359 +-
 Engine/lib/lpng/pngconf.h                     |    45 +-
 Engine/lib/lpng/pngdebug.h                    |     6 +-
 Engine/lib/lpng/pngerror.c                    |    12 +-
 Engine/lib/lpng/pngget.c                      |    21 +-
 Engine/lib/lpng/pnginfo.h                     |    18 +-
 Engine/lib/lpng/pngmem.c                      |     6 +-
 Engine/lib/lpng/pngpread.c                    |    52 +-
 Engine/lib/lpng/pngpriv.h                     |    80 +-
 Engine/lib/lpng/pngread.c                     |    48 +-
 Engine/lib/lpng/pngrio.c                      |    16 +-
 Engine/lib/lpng/pngrtran.c                    |  1958 +-
 Engine/lib/lpng/pngrutil.c                    |   108 +-
 Engine/lib/lpng/pngset.c                      |    28 +-
 Engine/lib/lpng/pngstruct.h                   |    32 +-
 Engine/lib/lpng/pngtest.c                     |    48 +-
 Engine/lib/lpng/pngtrans.c                    |    28 +-
 Engine/lib/lpng/pngusr.dfa                    |    14 +
 Engine/lib/lpng/pngwio.c                      |    14 +-
 Engine/lib/lpng/pngwrite.c                    |    41 +-
 Engine/lib/lpng/pngwtran.c                    |    19 +-
 Engine/lib/lpng/pngwutil.c                    |   197 +-
 .../lib/lpng/powerpc/filter_vsx_intrinsics.c  |   768 +
 Engine/lib/lpng/powerpc/powerpc_init.c        |   126 +
 Engine/lib/lpng/projects/owatcom/libpng.tgt   |   383 +
 Engine/lib/lpng/projects/owatcom/libpng.wpj   |   112 +
 .../lib/lpng/projects/owatcom/pngconfig.mak   |   160 +
 Engine/lib/lpng/projects/owatcom/pngstest.tgt |   219 +
 Engine/lib/lpng/projects/owatcom/pngtest.tgt  |   179 +
 Engine/lib/lpng/projects/owatcom/pngvalid.tgt |   210 +
 .../lib/lpng/projects/visualc71/PRJ0041.mak   |    21 +
 Engine/lib/lpng/projects/visualc71/README.txt |    58 +
 .../lpng/projects/visualc71/README_zlib.txt   |    44 +
 Engine/lib/lpng/projects/vstudio/README.txt   |    87 +
 Engine/lib/lpng/projects/vstudio/zlib.props   |    57 +
 Engine/lib/lpng/scripts/README.txt            |    79 +
 Engine/lib/lpng/scripts/SCOPTIONS.ppc         |     7 +
 Engine/lib/lpng/scripts/checksym.awk          |   173 +
 Engine/lib/lpng/scripts/descrip.mms           |    52 +
 Engine/lib/lpng/scripts/dfn.awk               |   203 +
 Engine/lib/lpng/scripts/genchk.cmake.in       |    37 +
 Engine/lib/lpng/scripts/genout.cmake.in       |    93 +
 Engine/lib/lpng/scripts/gensrc.cmake.in       |   138 +
 Engine/lib/lpng/scripts/intprefix.c           |    22 +
 Engine/lib/lpng/scripts/libpng-config-body.in |    96 +
 Engine/lib/lpng/scripts/libpng-config-head.in |    24 +
 Engine/lib/lpng/scripts/libpng.pc.in          |    10 +
 Engine/lib/lpng/scripts/libtool.m4            |  8369 ++++++++
 Engine/lib/lpng/scripts/ltoptions.m4          |   437 +
 Engine/lib/lpng/scripts/ltsugar.m4            |   124 +
 Engine/lib/lpng/scripts/ltversion.m4          |    23 +
 Engine/lib/lpng/scripts/lt~obsolete.m4        |    99 +
 Engine/lib/lpng/scripts/macro.lst             |     3 +
 Engine/lib/lpng/scripts/makefile.32sunu       |   244 +
 Engine/lib/lpng/scripts/makefile.64sunu       |   244 +
 Engine/lib/lpng/scripts/makefile.acorn        |    57 +
 Engine/lib/lpng/scripts/makefile.aix          |   116 +
 Engine/lib/lpng/scripts/makefile.amiga        |    58 +
 Engine/lib/lpng/scripts/makefile.atari        |    71 +
 Engine/lib/lpng/scripts/makefile.bc32         |   158 +
 Engine/lib/lpng/scripts/makefile.beos         |   222 +
 Engine/lib/lpng/scripts/makefile.cegcc        |   116 +
 Engine/lib/lpng/scripts/makefile.clang        |    87 +
 Engine/lib/lpng/scripts/makefile.clang-asan   |    87 +
 Engine/lib/lpng/scripts/makefile.darwin       |   225 +
 Engine/lib/lpng/scripts/makefile.dec          |   210 +
 Engine/lib/lpng/scripts/makefile.dj2          |    72 +
 Engine/lib/lpng/scripts/makefile.freebsd      |    69 +
 Engine/lib/lpng/scripts/makefile.gcc          |    87 +
 Engine/lib/lpng/scripts/makefile.gcc-asan     |    87 +
 Engine/lib/lpng/scripts/makefile.hp64         |   231 +
 Engine/lib/lpng/scripts/makefile.hpgcc        |   234 +
 Engine/lib/lpng/scripts/makefile.hpux         |   229 +
 Engine/lib/lpng/scripts/makefile.ibmc         |    90 +
 Engine/lib/lpng/scripts/makefile.intel        |   115 +
 Engine/lib/lpng/scripts/makefile.linux        |   246 +
 Engine/lib/lpng/scripts/makefile.linux-opt    |   265 +
 Engine/lib/lpng/scripts/makefile.mips         |   103 +
 Engine/lib/lpng/scripts/makefile.msys         |   202 +
 Engine/lib/lpng/scripts/makefile.netbsd       |    55 +
 Engine/lib/lpng/scripts/makefile.openbsd      |    86 +
 Engine/lib/lpng/scripts/makefile.sco          |   226 +
 Engine/lib/lpng/scripts/makefile.sggcc        |   236 +
 Engine/lib/lpng/scripts/makefile.sgi          |   237 +
 Engine/lib/lpng/scripts/makefile.so9          |   247 +
 Engine/lib/lpng/scripts/makefile.solaris      |   243 +
 Engine/lib/lpng/scripts/makefile.std          |   134 +
 Engine/lib/lpng/scripts/makefile.sunos        |   115 +
 Engine/lib/lpng/scripts/makefile.vcwin32      |   113 +
 Engine/lib/lpng/scripts/makevms.com           |   142 +
 Engine/lib/lpng/scripts/options.awk           |   898 +
 Engine/lib/lpng/scripts/pnglibconf.dfa        |   920 +
 Engine/lib/lpng/scripts/pnglibconf.h.prebuilt |   219 +
 Engine/lib/lpng/scripts/pnglibconf.mak        |    55 +
 Engine/lib/lpng/scripts/pngwin.rc             |   112 +
 Engine/lib/lpng/scripts/prefix.c              |    24 +
 Engine/lib/lpng/scripts/smakefile.ppc         |    34 +
 Engine/lib/lpng/scripts/sym.c                 |    15 +
 Engine/lib/lpng/scripts/symbols.c             |    58 +
 Engine/lib/lpng/scripts/symbols.def           |   255 +
 Engine/lib/lpng/scripts/test.cmake.in         |    31 +
 Engine/lib/lpng/scripts/vers.c                |    19 +
 Engine/lib/lpng/test-driver                   |   148 +
 Engine/lib/lpng/tests/pngimage-full           |     2 +
 Engine/lib/lpng/tests/pngimage-quick          |     2 +
 Engine/lib/lpng/tests/pngstest                |    54 +
 Engine/lib/lpng/tests/pngstest-1.8            |     2 +
 Engine/lib/lpng/tests/pngstest-1.8-alpha      |     2 +
 Engine/lib/lpng/tests/pngstest-linear         |     2 +
 Engine/lib/lpng/tests/pngstest-linear-alpha   |     2 +
 Engine/lib/lpng/tests/pngstest-none           |     2 +
 Engine/lib/lpng/tests/pngstest-none-alpha     |     2 +
 Engine/lib/lpng/tests/pngstest-sRGB           |     2 +
 Engine/lib/lpng/tests/pngstest-sRGB-alpha     |     2 +
 Engine/lib/lpng/tests/pngtest                 |     2 +
 Engine/lib/lpng/tests/pngtest-badpngs         |    13 +
 Engine/lib/lpng/tests/pngunknown-IDAT         |     2 +
 Engine/lib/lpng/tests/pngunknown-discard      |     2 +
 Engine/lib/lpng/tests/pngunknown-if-safe      |     2 +
 Engine/lib/lpng/tests/pngunknown-sAPI         |     2 +
 Engine/lib/lpng/tests/pngunknown-sTER         |     2 +
 Engine/lib/lpng/tests/pngunknown-save         |     2 +
 Engine/lib/lpng/tests/pngunknown-vpAg         |     2 +
 Engine/lib/lpng/tests/pngvalid-gamma-16-to-8  |     2 +
 .../lib/lpng/tests/pngvalid-gamma-alpha-mode  |     2 +
 .../lib/lpng/tests/pngvalid-gamma-background  |     2 +
 .../tests/pngvalid-gamma-expand16-alpha-mode  |     2 +
 .../tests/pngvalid-gamma-expand16-background  |     2 +
 .../tests/pngvalid-gamma-expand16-transform   |     2 +
 Engine/lib/lpng/tests/pngvalid-gamma-sbit     |     2 +
 .../lib/lpng/tests/pngvalid-gamma-threshold   |     2 +
 .../lib/lpng/tests/pngvalid-gamma-transform   |     2 +
 .../pngvalid-progressive-interlace-standard   |     2 +
 .../lib/lpng/tests/pngvalid-progressive-size  |     2 +
 .../lpng/tests/pngvalid-progressive-standard  |     2 +
 Engine/lib/lpng/tests/pngvalid-standard       |     2 +
 Engine/lib/lpng/tests/pngvalid-transform      |     2 +
 475 files changed, 110673 insertions(+), 2682 deletions(-)
 create mode 100644 Engine/lib/lpng/AUTHORS
 create mode 100644 Engine/lib/lpng/Makefile.am
 create mode 100644 Engine/lib/lpng/Makefile.in
 create mode 100644 Engine/lib/lpng/TRADEMARK
 create mode 100644 Engine/lib/lpng/aclocal.m4
 create mode 100644 Engine/lib/lpng/arm/arm_init.c
 create mode 100644 Engine/lib/lpng/arm/filter_neon.S
 create mode 100644 Engine/lib/lpng/arm/filter_neon_intrinsics.c
 create mode 100644 Engine/lib/lpng/arm/palette_neon_intrinsics.c
 create mode 100755 Engine/lib/lpng/autogen.sh
 create mode 100755 Engine/lib/lpng/compile
 create mode 100755 Engine/lib/lpng/config.guess
 create mode 100644 Engine/lib/lpng/config.h.in
 create mode 100755 Engine/lib/lpng/config.sub
 mode change 100644 => 100755 Engine/lib/lpng/configure
 create mode 100644 Engine/lib/lpng/configure.ac
 create mode 100644 Engine/lib/lpng/contrib/README.txt
 create mode 100644 Engine/lib/lpng/contrib/arm-neon/README
 create mode 100644 Engine/lib/lpng/contrib/arm-neon/android-ndk.c
 create mode 100644 Engine/lib/lpng/contrib/arm-neon/linux-auxv.c
 create mode 100644 Engine/lib/lpng/contrib/arm-neon/linux.c
 create mode 100644 Engine/lib/lpng/contrib/conftest/README
 create mode 100644 Engine/lib/lpng/contrib/conftest/pngcp.dfa
 create mode 100644 Engine/lib/lpng/contrib/conftest/read.dfa
 create mode 100644 Engine/lib/lpng/contrib/conftest/s_read.dfa
 create mode 100644 Engine/lib/lpng/contrib/conftest/s_write.dfa
 create mode 100644 Engine/lib/lpng/contrib/conftest/simple.dfa
 create mode 100644 Engine/lib/lpng/contrib/conftest/write.dfa
 create mode 100644 Engine/lib/lpng/contrib/examples/README.txt
 create mode 100644 Engine/lib/lpng/contrib/examples/iccfrompng.c
 create mode 100644 Engine/lib/lpng/contrib/examples/pngpixel.c
 create mode 100644 Engine/lib/lpng/contrib/examples/pngtopng.c
 create mode 100644 Engine/lib/lpng/contrib/examples/simpleover.c
 create mode 100644 Engine/lib/lpng/contrib/gregbook/COPYING
 create mode 100644 Engine/lib/lpng/contrib/gregbook/LICENSE
 create mode 100644 Engine/lib/lpng/contrib/gregbook/Makefile.mingw32
 create mode 100644 Engine/lib/lpng/contrib/gregbook/Makefile.sgi
 create mode 100644 Engine/lib/lpng/contrib/gregbook/Makefile.unx
 create mode 100644 Engine/lib/lpng/contrib/gregbook/Makefile.w32
 create mode 100644 Engine/lib/lpng/contrib/gregbook/README
 create mode 100644 Engine/lib/lpng/contrib/gregbook/makevms.com
 create mode 100644 Engine/lib/lpng/contrib/gregbook/readpng.c
 create mode 100644 Engine/lib/lpng/contrib/gregbook/readpng.h
 create mode 100644 Engine/lib/lpng/contrib/gregbook/readpng2.c
 create mode 100644 Engine/lib/lpng/contrib/gregbook/readpng2.h
 create mode 100644 Engine/lib/lpng/contrib/gregbook/readppm.c
 create mode 100644 Engine/lib/lpng/contrib/gregbook/rpng-win.c
 create mode 100644 Engine/lib/lpng/contrib/gregbook/rpng-x.c
 create mode 100644 Engine/lib/lpng/contrib/gregbook/rpng2-win.c
 create mode 100644 Engine/lib/lpng/contrib/gregbook/rpng2-x.c
 create mode 100644 Engine/lib/lpng/contrib/gregbook/toucan.png
 create mode 100644 Engine/lib/lpng/contrib/gregbook/wpng.c
 create mode 100644 Engine/lib/lpng/contrib/gregbook/writepng.c
 create mode 100644 Engine/lib/lpng/contrib/gregbook/writepng.h
 create mode 100644 Engine/lib/lpng/contrib/libtests/fakepng.c
 create mode 100755 Engine/lib/lpng/contrib/libtests/gentests.sh
 create mode 100644 Engine/lib/lpng/contrib/libtests/makepng.c
 create mode 100644 Engine/lib/lpng/contrib/libtests/pngimage.c
 create mode 100644 Engine/lib/lpng/contrib/libtests/pngstest-errors.h
 create mode 100644 Engine/lib/lpng/contrib/libtests/pngstest.c
 create mode 100644 Engine/lib/lpng/contrib/libtests/pngunknown.c
 create mode 100644 Engine/lib/lpng/contrib/libtests/pngvalid.c
 create mode 100644 Engine/lib/lpng/contrib/libtests/readpng.c
 create mode 100644 Engine/lib/lpng/contrib/libtests/tarith.c
 create mode 100644 Engine/lib/lpng/contrib/libtests/timepng.c
 create mode 100644 Engine/lib/lpng/contrib/mips-msa/README
 create mode 100644 Engine/lib/lpng/contrib/mips-msa/linux.c
 create mode 100644 Engine/lib/lpng/contrib/oss-fuzz/Dockerfile
 create mode 100644 Engine/lib/lpng/contrib/oss-fuzz/README.txt
 create mode 100755 Engine/lib/lpng/contrib/oss-fuzz/build.sh
 create mode 100644 Engine/lib/lpng/contrib/oss-fuzz/libpng_read_fuzzer.cc
 create mode 100644 Engine/lib/lpng/contrib/oss-fuzz/libpng_read_fuzzer.options
 create mode 100644 Engine/lib/lpng/contrib/oss-fuzz/png.dict
 create mode 100644 Engine/lib/lpng/contrib/pngminim/README
 create mode 100644 Engine/lib/lpng/contrib/pngminim/decoder/README
 create mode 100644 Engine/lib/lpng/contrib/pngminim/decoder/makefile
 create mode 100644 Engine/lib/lpng/contrib/pngminim/decoder/pngusr.dfa
 create mode 100644 Engine/lib/lpng/contrib/pngminim/decoder/pngusr.h
 create mode 100644 Engine/lib/lpng/contrib/pngminim/encoder/README
 create mode 100644 Engine/lib/lpng/contrib/pngminim/encoder/makefile
 create mode 100644 Engine/lib/lpng/contrib/pngminim/encoder/pngusr.dfa
 create mode 100644 Engine/lib/lpng/contrib/pngminim/encoder/pngusr.h
 create mode 100644 Engine/lib/lpng/contrib/pngminim/preader/README
 create mode 100644 Engine/lib/lpng/contrib/pngminim/preader/makefile
 create mode 100644 Engine/lib/lpng/contrib/pngminim/preader/pngusr.dfa
 create mode 100644 Engine/lib/lpng/contrib/pngminim/preader/pngusr.h
 create mode 100644 Engine/lib/lpng/contrib/pngminus/CHANGES.txt
 create mode 100644 Engine/lib/lpng/contrib/pngminus/CMakeLists.txt
 create mode 100644 Engine/lib/lpng/contrib/pngminus/LICENSE.txt
 create mode 100644 Engine/lib/lpng/contrib/pngminus/Makefile
 create mode 100644 Engine/lib/lpng/contrib/pngminus/README.txt
 create mode 100644 Engine/lib/lpng/contrib/pngminus/makevms.com
 create mode 100755 Engine/lib/lpng/contrib/pngminus/png2pnm.bat
 create mode 100644 Engine/lib/lpng/contrib/pngminus/png2pnm.c
 create mode 100755 Engine/lib/lpng/contrib/pngminus/png2pnm.sh
 create mode 100755 Engine/lib/lpng/contrib/pngminus/pngminus.bat
 create mode 100755 Engine/lib/lpng/contrib/pngminus/pngminus.sh
 create mode 100755 Engine/lib/lpng/contrib/pngminus/pnm2png.bat
 create mode 100644 Engine/lib/lpng/contrib/pngminus/pnm2png.c
 create mode 100755 Engine/lib/lpng/contrib/pngminus/pnm2png.sh
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/README
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/bad_interlace_conversions.txt
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/basn0g01.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/basn0g02.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/basn0g04.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/basn0g08.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/basn0g16.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/basn2c08.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/basn2c16.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/basn3p01.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/basn3p02.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/basn3p04.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/basn3p08.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/basn4a08.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/basn4a16.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/basn6a08.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/basn6a16.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/ftbbn0g01.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/ftbbn0g02.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/ftbbn0g04.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/ftbbn2c16.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/ftbbn3p08.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/ftbgn2c16.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/ftbgn3p08.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/ftbrn2c08.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/ftbwn0g16.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/ftbwn3p08.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/ftbyn3p08.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/ftp0n0g08.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/ftp0n2c08.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/ftp0n3p08.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/ftp1n3p08.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/ibasn0g08.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/ibasn0g16.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/ibasn2c08.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/ibasn2c16.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/ibasn3p08.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/ibasn4a08.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/ibasn4a16.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/ibasn6a08.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/ibasn6a16.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/iftbbn2c16.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/iftbbn3p08.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/iftbgn2c16.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/iftbgn3p08.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/iftbrn2c08.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/iftbwn0g16.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/iftbwn3p08.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/iftbyn3p08.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/iftp0n0g08.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/iftp0n2c08.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/iftp0n3p08.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/iftp1n3p08.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/interlaced/README
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/interlaced/ibasn0g01.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/interlaced/ibasn0g02.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/interlaced/ibasn0g04.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/interlaced/ibasn3p01.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/interlaced/ibasn3p02.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/interlaced/ibasn3p04.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/interlaced/iftbbn0g01.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/interlaced/iftbbn0g02.png
 create mode 100644 Engine/lib/lpng/contrib/pngsuite/interlaced/iftbbn0g04.png
 create mode 100644 Engine/lib/lpng/contrib/powerpc-vsx/README
 create mode 100644 Engine/lib/lpng/contrib/powerpc-vsx/linux.c
 create mode 100644 Engine/lib/lpng/contrib/powerpc-vsx/linux_aux.c
 create mode 100644 Engine/lib/lpng/contrib/testpngs/crashers/bad_iCCP.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/crashers/badadler.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/crashers/badcrc.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/crashers/empty_ancillary_chunks.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/crashers/huge_IDAT.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/crashers/huge_bKGD_chunk.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/crashers/huge_cHRM_chunk.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/crashers/huge_eXIf_chunk.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/crashers/huge_gAMA_chunk.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/crashers/huge_hIST_chunk.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/crashers/huge_iCCP_chunk.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/crashers/huge_iTXt_chunk.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/crashers/huge_juNK_unsafe_to_copy.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/crashers/huge_juNk_safe_to_copy.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/crashers/huge_pCAL_chunk.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/crashers/huge_pHYs_chunk.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/crashers/huge_sCAL_chunk.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/crashers/huge_sPLT_chunk.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/crashers/huge_sRGB_chunk.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/crashers/huge_sTER_chunk.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/crashers/huge_tEXt_chunk.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/crashers/huge_tIME_chunk.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/crashers/huge_zTXt_chunk.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-1-1.8-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-1-1.8.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-1-linear-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-1-linear.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-1-sRGB-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-1-sRGB.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-1-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-1.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-16-1.8-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-16-1.8.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-16-linear-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-16-linear.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-16-sRGB-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-16-sRGB.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-16-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-16.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-2-1.8-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-2-1.8.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-2-linear-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-2-linear.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-2-sRGB-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-2-sRGB.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-2-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-2.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-4-1.8-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-4-1.8.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-4-linear-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-4-linear.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-4-sRGB-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-4-sRGB.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-4-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-4.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-8-1.8-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-8-1.8.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-8-linear-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-8-linear.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-8-sRGB-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-8-sRGB.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-8-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-8.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-alpha-16-1.8.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-alpha-16-linear.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-alpha-16-sRGB.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-alpha-16.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-alpha-8-1.8.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-alpha-8-linear.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-alpha-8-sRGB.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/gray-alpha-8.png
 create mode 100755 Engine/lib/lpng/contrib/testpngs/makepngs.sh
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-1-1.8-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-1-1.8.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-1-linear-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-1-linear.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-1-sRGB-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-1-sRGB.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-1-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-1.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-2-1.8-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-2-1.8.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-2-linear-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-2-linear.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-2-sRGB-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-2-sRGB.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-2-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-2.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-4-1.8-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-4-1.8.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-4-linear-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-4-linear.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-4-sRGB-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-4-sRGB.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-4-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-4.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-8-1.8-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-8-1.8.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-8-linear-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-8-linear.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-8-sRGB-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-8-sRGB.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-8-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/palette-8.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/rgb-16-1.8-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/rgb-16-1.8.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/rgb-16-linear-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/rgb-16-linear.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/rgb-16-sRGB-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/rgb-16-sRGB.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/rgb-16-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/rgb-16.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/rgb-8-1.8-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/rgb-8-1.8.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/rgb-8-linear-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/rgb-8-linear.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/rgb-8-sRGB-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/rgb-8-sRGB.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/rgb-8-tRNS.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/rgb-8.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/rgb-alpha-16-1.8.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/rgb-alpha-16-linear.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/rgb-alpha-16-sRGB.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/rgb-alpha-16.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/rgb-alpha-8-1.8.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/rgb-alpha-8-linear.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/rgb-alpha-8-sRGB.png
 create mode 100644 Engine/lib/lpng/contrib/testpngs/rgb-alpha-8.png
 create mode 100644 Engine/lib/lpng/contrib/tools/README.txt
 create mode 100644 Engine/lib/lpng/contrib/tools/checksum-icc.c
 create mode 100755 Engine/lib/lpng/contrib/tools/chkfmt
 create mode 100644 Engine/lib/lpng/contrib/tools/cvtcolor.c
 create mode 100644 Engine/lib/lpng/contrib/tools/genpng.c
 create mode 100755 Engine/lib/lpng/contrib/tools/intgamma.sh
 create mode 100644 Engine/lib/lpng/contrib/tools/makesRGB.c
 create mode 100644 Engine/lib/lpng/contrib/tools/png-fix-itxt.c
 create mode 100644 Engine/lib/lpng/contrib/tools/pngcp.c
 create mode 100644 Engine/lib/lpng/contrib/tools/pngfix.c
 create mode 100755 Engine/lib/lpng/contrib/tools/reindent
 create mode 100644 Engine/lib/lpng/contrib/tools/sRGB.h
 create mode 100644 Engine/lib/lpng/contrib/visupng/PngFile.c
 create mode 100644 Engine/lib/lpng/contrib/visupng/PngFile.h
 create mode 100644 Engine/lib/lpng/contrib/visupng/README.txt
 create mode 100644 Engine/lib/lpng/contrib/visupng/VisualPng.c
 create mode 100644 Engine/lib/lpng/contrib/visupng/VisualPng.dsp
 create mode 100644 Engine/lib/lpng/contrib/visupng/VisualPng.dsw
 create mode 100644 Engine/lib/lpng/contrib/visupng/VisualPng.ico
 create mode 100644 Engine/lib/lpng/contrib/visupng/VisualPng.png
 create mode 100644 Engine/lib/lpng/contrib/visupng/VisualPng.rc
 create mode 100644 Engine/lib/lpng/contrib/visupng/cexcept.h
 create mode 100644 Engine/lib/lpng/contrib/visupng/resource.h
 create mode 100755 Engine/lib/lpng/depcomp
 create mode 100755 Engine/lib/lpng/install-sh
 create mode 100755 Engine/lib/lpng/ltmain.sh
 create mode 100644 Engine/lib/lpng/mips/filter_msa_intrinsics.c
 create mode 100644 Engine/lib/lpng/mips/mips_init.c
 create mode 100755 Engine/lib/lpng/missing
 create mode 100644 Engine/lib/lpng/pngusr.dfa
 create mode 100644 Engine/lib/lpng/powerpc/filter_vsx_intrinsics.c
 create mode 100644 Engine/lib/lpng/powerpc/powerpc_init.c
 create mode 100644 Engine/lib/lpng/projects/owatcom/libpng.tgt
 create mode 100644 Engine/lib/lpng/projects/owatcom/libpng.wpj
 create mode 100644 Engine/lib/lpng/projects/owatcom/pngconfig.mak
 create mode 100644 Engine/lib/lpng/projects/owatcom/pngstest.tgt
 create mode 100644 Engine/lib/lpng/projects/owatcom/pngtest.tgt
 create mode 100644 Engine/lib/lpng/projects/owatcom/pngvalid.tgt
 create mode 100644 Engine/lib/lpng/projects/visualc71/PRJ0041.mak
 create mode 100644 Engine/lib/lpng/projects/visualc71/README.txt
 create mode 100644 Engine/lib/lpng/projects/visualc71/README_zlib.txt
 create mode 100644 Engine/lib/lpng/projects/vstudio/README.txt
 create mode 100644 Engine/lib/lpng/projects/vstudio/zlib.props
 create mode 100644 Engine/lib/lpng/scripts/README.txt
 create mode 100644 Engine/lib/lpng/scripts/SCOPTIONS.ppc
 create mode 100755 Engine/lib/lpng/scripts/checksym.awk
 create mode 100644 Engine/lib/lpng/scripts/descrip.mms
 create mode 100755 Engine/lib/lpng/scripts/dfn.awk
 create mode 100644 Engine/lib/lpng/scripts/genchk.cmake.in
 create mode 100644 Engine/lib/lpng/scripts/genout.cmake.in
 create mode 100644 Engine/lib/lpng/scripts/gensrc.cmake.in
 create mode 100644 Engine/lib/lpng/scripts/intprefix.c
 create mode 100644 Engine/lib/lpng/scripts/libpng-config-body.in
 create mode 100644 Engine/lib/lpng/scripts/libpng-config-head.in
 create mode 100644 Engine/lib/lpng/scripts/libpng.pc.in
 create mode 100644 Engine/lib/lpng/scripts/libtool.m4
 create mode 100644 Engine/lib/lpng/scripts/ltoptions.m4
 create mode 100644 Engine/lib/lpng/scripts/ltsugar.m4
 create mode 100644 Engine/lib/lpng/scripts/ltversion.m4
 create mode 100644 Engine/lib/lpng/scripts/lt~obsolete.m4
 create mode 100644 Engine/lib/lpng/scripts/macro.lst
 create mode 100644 Engine/lib/lpng/scripts/makefile.32sunu
 create mode 100644 Engine/lib/lpng/scripts/makefile.64sunu
 create mode 100644 Engine/lib/lpng/scripts/makefile.acorn
 create mode 100644 Engine/lib/lpng/scripts/makefile.aix
 create mode 100644 Engine/lib/lpng/scripts/makefile.amiga
 create mode 100644 Engine/lib/lpng/scripts/makefile.atari
 create mode 100644 Engine/lib/lpng/scripts/makefile.bc32
 create mode 100644 Engine/lib/lpng/scripts/makefile.beos
 create mode 100644 Engine/lib/lpng/scripts/makefile.cegcc
 create mode 100644 Engine/lib/lpng/scripts/makefile.clang
 create mode 100644 Engine/lib/lpng/scripts/makefile.clang-asan
 create mode 100644 Engine/lib/lpng/scripts/makefile.darwin
 create mode 100644 Engine/lib/lpng/scripts/makefile.dec
 create mode 100644 Engine/lib/lpng/scripts/makefile.dj2
 create mode 100644 Engine/lib/lpng/scripts/makefile.freebsd
 create mode 100644 Engine/lib/lpng/scripts/makefile.gcc
 create mode 100644 Engine/lib/lpng/scripts/makefile.gcc-asan
 create mode 100644 Engine/lib/lpng/scripts/makefile.hp64
 create mode 100644 Engine/lib/lpng/scripts/makefile.hpgcc
 create mode 100644 Engine/lib/lpng/scripts/makefile.hpux
 create mode 100644 Engine/lib/lpng/scripts/makefile.ibmc
 create mode 100644 Engine/lib/lpng/scripts/makefile.intel
 create mode 100644 Engine/lib/lpng/scripts/makefile.linux
 create mode 100644 Engine/lib/lpng/scripts/makefile.linux-opt
 create mode 100644 Engine/lib/lpng/scripts/makefile.mips
 create mode 100644 Engine/lib/lpng/scripts/makefile.msys
 create mode 100644 Engine/lib/lpng/scripts/makefile.netbsd
 create mode 100644 Engine/lib/lpng/scripts/makefile.openbsd
 create mode 100644 Engine/lib/lpng/scripts/makefile.sco
 create mode 100644 Engine/lib/lpng/scripts/makefile.sggcc
 create mode 100644 Engine/lib/lpng/scripts/makefile.sgi
 create mode 100644 Engine/lib/lpng/scripts/makefile.so9
 create mode 100644 Engine/lib/lpng/scripts/makefile.solaris
 create mode 100644 Engine/lib/lpng/scripts/makefile.std
 create mode 100644 Engine/lib/lpng/scripts/makefile.sunos
 create mode 100644 Engine/lib/lpng/scripts/makefile.vcwin32
 create mode 100644 Engine/lib/lpng/scripts/makevms.com
 create mode 100755 Engine/lib/lpng/scripts/options.awk
 create mode 100644 Engine/lib/lpng/scripts/pnglibconf.dfa
 create mode 100644 Engine/lib/lpng/scripts/pnglibconf.h.prebuilt
 create mode 100755 Engine/lib/lpng/scripts/pnglibconf.mak
 create mode 100644 Engine/lib/lpng/scripts/pngwin.rc
 create mode 100644 Engine/lib/lpng/scripts/prefix.c
 create mode 100644 Engine/lib/lpng/scripts/smakefile.ppc
 create mode 100644 Engine/lib/lpng/scripts/sym.c
 create mode 100644 Engine/lib/lpng/scripts/symbols.c
 create mode 100644 Engine/lib/lpng/scripts/symbols.def
 create mode 100644 Engine/lib/lpng/scripts/test.cmake.in
 create mode 100644 Engine/lib/lpng/scripts/vers.c
 create mode 100755 Engine/lib/lpng/test-driver
 create mode 100755 Engine/lib/lpng/tests/pngimage-full
 create mode 100755 Engine/lib/lpng/tests/pngimage-quick
 create mode 100755 Engine/lib/lpng/tests/pngstest
 create mode 100755 Engine/lib/lpng/tests/pngstest-1.8
 create mode 100755 Engine/lib/lpng/tests/pngstest-1.8-alpha
 create mode 100755 Engine/lib/lpng/tests/pngstest-linear
 create mode 100755 Engine/lib/lpng/tests/pngstest-linear-alpha
 create mode 100755 Engine/lib/lpng/tests/pngstest-none
 create mode 100755 Engine/lib/lpng/tests/pngstest-none-alpha
 create mode 100755 Engine/lib/lpng/tests/pngstest-sRGB
 create mode 100755 Engine/lib/lpng/tests/pngstest-sRGB-alpha
 create mode 100755 Engine/lib/lpng/tests/pngtest
 create mode 100755 Engine/lib/lpng/tests/pngtest-badpngs
 create mode 100755 Engine/lib/lpng/tests/pngunknown-IDAT
 create mode 100755 Engine/lib/lpng/tests/pngunknown-discard
 create mode 100755 Engine/lib/lpng/tests/pngunknown-if-safe
 create mode 100755 Engine/lib/lpng/tests/pngunknown-sAPI
 create mode 100755 Engine/lib/lpng/tests/pngunknown-sTER
 create mode 100755 Engine/lib/lpng/tests/pngunknown-save
 create mode 100755 Engine/lib/lpng/tests/pngunknown-vpAg
 create mode 100755 Engine/lib/lpng/tests/pngvalid-gamma-16-to-8
 create mode 100755 Engine/lib/lpng/tests/pngvalid-gamma-alpha-mode
 create mode 100755 Engine/lib/lpng/tests/pngvalid-gamma-background
 create mode 100755 Engine/lib/lpng/tests/pngvalid-gamma-expand16-alpha-mode
 create mode 100755 Engine/lib/lpng/tests/pngvalid-gamma-expand16-background
 create mode 100755 Engine/lib/lpng/tests/pngvalid-gamma-expand16-transform
 create mode 100755 Engine/lib/lpng/tests/pngvalid-gamma-sbit
 create mode 100755 Engine/lib/lpng/tests/pngvalid-gamma-threshold
 create mode 100755 Engine/lib/lpng/tests/pngvalid-gamma-transform
 create mode 100755 Engine/lib/lpng/tests/pngvalid-progressive-interlace-standard
 create mode 100755 Engine/lib/lpng/tests/pngvalid-progressive-size
 create mode 100755 Engine/lib/lpng/tests/pngvalid-progressive-standard
 create mode 100755 Engine/lib/lpng/tests/pngvalid-standard
 create mode 100755 Engine/lib/lpng/tests/pngvalid-transform

diff --git a/Engine/lib/lpng/ANNOUNCE b/Engine/lib/lpng/ANNOUNCE
index 0f66c0d1d..ecf9c7043 100644
--- a/Engine/lib/lpng/ANNOUNCE
+++ b/Engine/lib/lpng/ANNOUNCE
@@ -1,35 +1,47 @@
-Libpng 1.6.34 - September 29, 2017
+libpng 1.6.37 - April 14, 2019
+==============================
 
-This is a public release of libpng, intended for use in production codes.
+This is a public release of libpng, intended for use in production code.
 
-Files available for download:
 
-Source files with LF line endings (for Unix/Linux) and with a
-"configure" script
+Files available for download
+----------------------------
 
-   libpng-1.6.34.tar.xz (LZMA-compressed, recommended)
-   libpng-1.6.34.tar.gz
+Source files with LF line endings (for Unix/Linux):
 
-Source files with CRLF line endings (for Windows), without the
-"configure" script
+ * libpng-1.6.37.tar.xz (LZMA-compressed, recommended)
+ * libpng-1.6.37.tar.gz
 
-   lpng1634.7z  (LZMA-compressed, recommended)
-   lpng1634.zip
+Source files with CRLF line endings (for Windows):
+
+ * lp1637.7z (LZMA-compressed, recommended)
+ * lp1637.zip
 
 Other information:
 
-   libpng-1.6.34-README.txt
-   libpng-1.6.34-LICENSE.txt
-   libpng-1.6.34-*.asc (armored detached GPG signatures)
+ * README.md
+ * LICENSE.md
+ * AUTHORS.md
+ * TRADEMARK.md
 
-Changes since the last public release (1.6.33):
-  Removed contrib/pngsuite/i*.png; some of these were incorrect and caused
-    test failures.
 
-Send comments/corrections/commendations to png-mng-implement at lists.sf.net
-(subscription required; visit
+Changes since the previous public release (version 1.6.36)
+----------------------------------------------------------
+
+ * Fixed a use-after-free vulnerability (CVE-2019-7317) in png_image_free.
+ * Fixed a memory leak in the ARM NEON implementation of png_do_expand_palette.
+ * Fixed a memory leak in pngtest.c.
+ * Fixed two vulnerabilities (CVE-2018-14048, CVE-2018-14550) in
+   contrib/pngminus; refactor.
+ * Changed the license of contrib/pngminus to MIT; refresh makefile and docs.
+   (Contributed by Willem van Schaik)
+ * Fixed a typo in the libpng license v2.
+   (Contributed by Miguel Ojeda)
+ * Added makefiles for AddressSanitizer-enabled builds.
+ * Cleaned up various makefiles.
+
+
+Send comments/corrections/commendations to png-mng-implement at lists.sf.net.
+Subscription is required; visit
 https://lists.sourceforge.net/lists/listinfo/png-mng-implement
-to subscribe)
-or to glennrp at users.sourceforge.net
-
-Glenn R-P
+to subscribe.
diff --git a/Engine/lib/lpng/AUTHORS b/Engine/lib/lpng/AUTHORS
new file mode 100644
index 000000000..79a3d1036
--- /dev/null
+++ b/Engine/lib/lpng/AUTHORS
@@ -0,0 +1,45 @@
+PNG REFERENCE LIBRARY AUTHORS
+=============================
+
+This is the list of PNG Reference Library ("libpng") Contributing
+Authors, for copyright and licensing purposes.
+
+ * Andreas Dilger
+ * Cosmin Truta
+ * Dave Martindale
+ * Eric S. Raymond
+ * Gilles Vollant
+ * Glenn Randers-Pehrson
+ * Greg Roelofs
+ * Guy Eric Schalnat
+ * James Yu
+ * John Bowler
+ * Kevin Bracey
+ * Magnus Holmgren
+ * Mandar Sahastrabuddhe
+ * Mans Rullgard
+ * Matt Sarett
+ * Mike Klein
+ * Paul Schmidt
+ * Sam Bushell
+ * Samuel Williams
+ * Simon-Pierre Cadieux
+ * Tim Wegner
+ * Tom Lane
+ * Tom Tanner
+ * Vadim Barkov
+ * Willem van Schaik
+ * Zhijie Liang
+ * Arm Holdings
+   - Richard Townsend
+ * Google Inc.
+   - Matt Sarett
+   - Mike Klein
+
+The build projects, the build scripts, the test scripts, and other
+files in the "projects", "scripts" and "tests" directories, have other
+copyright owners, but are released under the libpng license.
+
+Some files in the "contrib" directory, and some tools-generated files
+that are distributed with libpng, have other copyright owners, and are
+released under other open source licenses.
diff --git a/Engine/lib/lpng/CHANGES b/Engine/lib/lpng/CHANGES
index 4b8211891..f0b0a9342 100644
--- a/Engine/lib/lpng/CHANGES
+++ b/Engine/lib/lpng/CHANGES
@@ -1,4 +1,3 @@
-#if 0
 CHANGES - changes for libpng
 
 version 0.1 [March 29, 1995]
@@ -1454,7 +1453,7 @@ Version 1.2.6beta4 [July 28, 2004]
     sequential read support.
   Added some "#if PNG_WRITE_SUPPORTED" blocks.
   Added #ifdef to remove some redundancy in png_malloc_default().
-  Use png_malloc instead of png_zalloc to allocate the pallete.
+  Use png_malloc instead of png_zalloc to allocate the palette.
 
 Version 1.0.16rc1 and 1.2.6rc1 [August 4, 2004]
   Fixed buffer overflow vulnerability (CVE-2004-0597) in png_handle_tRNS().
@@ -3259,7 +3258,7 @@ Version 1.5.2beta01 [February 13, 2011]
   Revised PNG_EXPORTA macro to not use an empty parameter, to accommodate the
     old VisualC++ preprocessor.
   Turned on interlace handling in png_read_png().
-  Fixed gcc pendantic warnings.
+  Fixed gcc pedantic warnings.
   Handle longjmp in Cygwin.
   Fixed png_get_current_row_number() in the interlaced case.
   Cleaned up ALPHA flags and transformations.
@@ -3359,7 +3358,7 @@ Version 1.5.3beta05 [May 6, 2011]
   Pass "" instead of '\0' to png_default_error() in png_err().  This mistake
     was introduced in libpng-1.2.20beta01.  This fixes CVE-2011-2691.
   Added PNG_WRITE_OPTIMIZE_CMF_SUPPORTED macro to make the zlib "CMF" byte
-    optimization configureable.
+    optimization configurable.
   IDAT compression failed if preceded by a compressed text chunk (bug
     introduced in libpng-1.5.3beta01-02).  This was because the attempt to
     reset the zlib stream in png_write_IDAT happened after the first IDAT
@@ -3643,7 +3642,7 @@ Version 1.5.6beta05 [October 12, 2011]
   Fixed bug in png_write_chunk_header() debug print, introduced in 1.5.6beta01.
 
 Version 1.5.6beta06 [October 17, 2011]
-  Removed two redundant tests for unitialized row.
+  Removed two redundant tests for uninitialized row.
   Fixed a relatively harmless memory overwrite in compressed text writing
     with a 1 byte zlib buffer.
   Add ability to call png_read_update_info multiple times to pngvalid.c.
@@ -3689,7 +3688,7 @@ Version 1.5.7beta01 [November 4, 2011]
     crash.  The pngmem.c implementation of png_malloc() included a cast
     to png_size_t which would fail on large allocations on 16-bit systems.
   Fix for the preprocessor of the Intel C compiler. The preprocessor
-    splits adjacent @ signs with a space; this changes the concatentation
+    splits adjacent @ signs with a space; this changes the concatenation
     token from @-@-@ to PNG_JOIN; that should work with all compiler
     preprocessors.
   Paeth filter speed improvements from work by Siarhei Siamashka. This
@@ -3735,7 +3734,7 @@ Version 1.5.7beta03 [November 17, 2011]
     gray (on palette) itself.
   Fixes for C++ compilation using g++ When libpng source is compiled
     using g++. The compiler imposes C++ rules on the C source; thus it
-    is desireable to make the source work with either C or C++ rules
+    is desirable to make the source work with either C or C++ rules
     without throwing away useful error information.  This change adds
     png_voidcast to allow C semantic (void*) cases or the corresponding
     C++ static_cast operation, as appropriate.
@@ -4061,7 +4060,7 @@ Version 1.6.0beta17 [March 10, 2012]
     possible to call png_inflate() incrementally.  A warning is no longer
     issued if the language tag or translated keyword in the iTXt chunk
     has zero length.
-  If benign errors are disabled use maximum window on ancilliary inflate.
+  If benign errors are disabled use maximum window on ancillary inflate.
     This works round a bug introduced in 1.5.4 where compressed ancillary
     chunks could end up with a too-small windowBits value in the deflate
     header.
@@ -4176,7 +4175,7 @@ Version 1.6.0beta27 [August 11, 2012]
     declared even though the functions are never actually defined.  This
     change provides a dummy definition so that the declarations work, yet any
     implementation will fail to compile because of an incomplete type.
-  Re-eliminated the use of strcpy() in pngtest.c.  An unncessary use of
+  Re-eliminated the use of strcpy() in pngtest.c.  An unnecessary use of
     strcpy() was accidentally re-introduced in libpng16; this change replaces
     it with strncpy().
   Eliminated use of png_sizeof(); use sizeof() instead.
@@ -4309,7 +4308,7 @@ Version 1.6.0beta31 [November 1, 2012]
     resulting in VS2010 having to update the files.
   Removed non-working ICC profile support code that was mostly added to
     libpng-1.6.0beta29 and beta30. There was too much code for too little
-    gain; implementing full ICC color correction may be desireable but is left
+    gain; implementing full ICC color correction may be desirable but is left
     up to applications.
 
 Version 1.6.0beta32 [November 25, 2012]
@@ -4592,7 +4591,7 @@ Version 1.6.3beta07 [June 8, 2013]
     the optimizations ('check' vs 'api') are exposed in the public header files
     except that the new setting PNG_ARM_NEON_OPT documents how libpng makes the
     decision about whether or not to use the optimizations.
-  Protect symbol prefixing against CC/CPPFLAGS/CFLAGS useage.
+  Protect symbol prefixing against CC/CPPFLAGS/CFLAGS usage.
     Previous iOS/Xcode fixes for the ARM NEON optimizations moved the test
     on __ARM_NEON__ from configure time to compile time.  This breaks symbol
     prefixing because the definition of the special png_init_filter_functions
@@ -5635,7 +5634,7 @@ Version 1.6.24beta02 [June 23, 2016]
     to All and adds a list of the warnings that need to be turned off.  This is
     semi-documentary; the intent is to tell libpng users which warnings have
     been examined and judged non-fixable at present.  The warning about
-    structure padding is fixable, but it would be a signficant change (moving
+    structure padding is fixable, but it would be a significant change (moving
     structure members around).
 
 Version 1.6.24beta03 [July 4, 2016]
@@ -5781,7 +5780,7 @@ Version 1.6.28rc01 [January 3, 2017]
   Added option to Cmake build allowing a custom location of zlib to be
     specified in a scenario where libpng is being built as a subproject
     alongside zlib by another project (Sam Serrels).
-  Changed png_ptr->options from a png_byte to png_uint_32, to accomodate
+  Changed png_ptr->options from a png_byte to png_uint_32, to accommodate
     up to 16 options.
 
 Version 1.6.28rc02 [January 4, 2017]
@@ -5932,7 +5931,7 @@ Version 1.6.32beta04 [August 2, 2017]
   Update libpng.3 and libpng-manual.txt about eXIf functions.
 
 Version 1.6.32beta05 [August 2, 2017]
-  Restored png_get_eXIf() and png_set_eXIf() to maintain API compatability.
+  Restored png_get_eXIf() and png_set_eXIf() to maintain API compatibility.
 
 Version 1.6.32beta06 [August 2, 2017]
   Removed png_get_eXIf_1() and png_set_eXIf_1().
@@ -6038,14 +6037,73 @@ Version 1.6.33 [September 28, 2017]
   Add end_info structure and png_read_end() to the libpng fuzzer.
 
 Version 1.6.34 [September 29, 2017]
-  Removed contrib/pngsuite/i*.png; some of these were incorrect and caused
-    test failures.
+  Removed contrib/pngsuite/i*.png; some of them caused test failures.
 
-Send comments/corrections/commendations to png-mng-implement at lists.sf.net
-(subscription required; visit
+Version 1.6.35beta01 [March 6, 2018]
+  Restored 21 of the contrib/pngsuite/i*.png, which do not cause test
+    failures. Placed the remainder in contrib/pngsuite/interlaced/i*.png.
+  Added calls to png_set_*() transforms commonly used by browsers to
+    the fuzzer.
+  Removed some unnecessary brackets in pngrtran.c
+  Fixed miscellaneous typos (Patch by github user "luzpaz").
+  Change "ASM C" to "C ASM" in CMakeLists.txt
+  Fixed incorrect handling of bKGD chunk in sub-8-bit files (Cosmin)
+  Added hardware optimization directories to zip and 7z distributions.
+  Fixed incorrect bitmask for options.
+  Fixed many spelling typos.
+
+Version 1.6.35beta02 [March 28, 2018]
+  Make png_get_iCCP consistent with man page (allow compression-type argument
+  to be NULL, bug report by Lenard Szolnoki).
+
+Version 1.6.35 [July 15, 2018]
+  Replaced the remaining uses of png_size_t with size_t (Cosmin)
+  Fixed the calculation of row_factor in png_check_chunk_length
+    (reported by Thuan Pham in SourceForge issue #278)
+  Added missing parentheses to a macro definition
+    (suggested by "irwir" in GitHub issue #216)
+
+Version 1.6.36 [December 1, 2018]
+  Optimized png_do_expand_palette for ARM processors.
+  Improved performance by around 10-22% on a recent ARM Chromebook.
+    (Contributed by Richard Townsend, ARM Holdings)
+  Fixed manipulation of machine-specific optimization options.
+    (Contributed by Vicki Pfau)
+  Used memcpy instead of manual pointer arithmetic on Intel SSE2.
+    (Contributed by Samuel Williams)
+  Fixed build errors with MSVC on ARM64.
+    (Contributed by Zhijie Liang)
+  Fixed detection of libm in CMakeLists.
+    (Contributed by Cameron Cawley)
+  Fixed incorrect creation of pkg-config file in CMakeLists.
+    (Contributed by Kyle Bentley)
+  Fixed the CMake build on Windows MSYS by avoiding symlinks.
+  Fixed a build warning on OpenBSD.
+    (Contributed by Theo Buehler)
+  Fixed various typos in comments.
+    (Contributed by "luz.paz")
+  Raised the minimum required CMake version from 3.0.2 to 3.1.
+  Removed yet more of the vestigial support for pre-ANSI C compilers.
+  Removed ancient makefiles for ancient systems that have been broken
+    across all previous libpng-1.6.x versions.
+  Removed the Y2K compliance statement and the export control
+    information.
+  Applied various code style and documentation fixes.
+
+Version 1.6.37 [April 14, 2019]
+  Fixed a use-after-free vulnerability (CVE-2019-7317) in png_image_free.
+  Fixed a memory leak in the ARM NEON implementation of png_do_expand_palette.
+  Fixed a memory leak in pngtest.c.
+  Fixed two vulnerabilities (CVE-2018-14048, CVE-2018-14550) in
+    contrib/pngminus; refactor.
+  Changed the license of contrib/pngminus to MIT; refresh makefile and docs.
+    (Contributed by Willem van Schaik)
+  Fixed a typo in the libpng license v2.
+    (Contributed by Miguel Ojeda)
+  Added makefiles for AddressSanitizer-enabled builds.
+  Cleaned up various makefiles.
+
+Send comments/corrections/commendations to png-mng-implement at lists.sf.net.
+Subscription is required; visit
 https://lists.sourceforge.net/lists/listinfo/png-mng-implement
-to subscribe)
-or to glennrp at users.sourceforge.net
-
-Glenn R-P
-#endif
+to subscribe.
diff --git a/Engine/lib/lpng/CMakeLists.txt b/Engine/lib/lpng/CMakeLists.txt
index 48c6fa287..6451fcf1b 100644
--- a/Engine/lib/lpng/CMakeLists.txt
+++ b/Engine/lib/lpng/CMakeLists.txt
@@ -1,42 +1,32 @@
 # CMakeLists.txt
 
-# Copyright (C) 2007,2009-2017 Glenn Randers-Pehrson
+# Copyright (C) 2018 Cosmin Truta
+# Copyright (C) 2007,2009-2018 Glenn Randers-Pehrson
 # Written by Christian Ehrlicher, 2007
 # Revised by Roger Lowman, 2009-2010
-# Revised by Clifford Yapp, 2011-2012
+# Revised by Clifford Yapp, 2011-2012,2017
 # Revised by Roger Leigh, 2016
 # Revised by Andreas Franek, 2016
+# Revised by Sam Serrels, 2017
+# Revised by Vadim Barkov, 2017
+# Revised by Vicky Pfau, 2018
+# Revised by Cameron Cawley, 2018
+# Revised by Cosmin Truta, 2018
+# Revised by Kyle Bentley, 2018
 
 # This code is released under the libpng license.
 # For conditions of distribution and use, see the disclaimer
 # and license in png.h
 
-cmake_minimum_required(VERSION 3.0.2)
-cmake_policy(VERSION 3.0.2)
+cmake_minimum_required(VERSION 3.1)
+cmake_policy(VERSION 3.1)
 
-# Set MacOSX @rpath usage globally.
-if (POLICY CMP0020)
-  cmake_policy(SET CMP0020 NEW)
-endif(POLICY CMP0020)
-if (POLICY CMP0042)
-  cmake_policy(SET CMP0042 NEW)
-endif(POLICY CMP0042)
-# Use new variable expansion policy.
-if (POLICY CMP0053)
-  cmake_policy(SET CMP0053 NEW)
-endif(POLICY CMP0053)
-if (POLICY CMP0054)
-  cmake_policy(SET CMP0054 NEW)
-endif(POLICY CMP0054)
-
-set(CMAKE_CONFIGURATION_TYPES "Release;Debug;MinSizeRel;RelWithDebInfo")
-
-project(libpng ASM C)
+project(libpng C ASM)
 enable_testing()
 
 set(PNGLIB_MAJOR 1)
 set(PNGLIB_MINOR 6)
-set(PNGLIB_RELEASE 34)
+set(PNGLIB_RELEASE 37)
 set(PNGLIB_NAME libpng${PNGLIB_MAJOR}${PNGLIB_MINOR})
 set(PNGLIB_VERSION ${PNGLIB_MAJOR}.${PNGLIB_MINOR}.${PNGLIB_RELEASE})
 
@@ -44,25 +34,19 @@ include(GNUInstallDirs)
 
 # needed packages
 
-#Allow users to specify location of Zlib,
-# Useful if zlib is being built alongside this as a sub-project
+# Allow users to specify location of Zlib.
+# Useful if zlib is being built alongside this as a sub-project.
 option(PNG_BUILD_ZLIB "Custom zlib Location, else find_package is used" OFF)
 
-IF(NOT PNG_BUILD_ZLIB)
+if(NOT PNG_BUILD_ZLIB)
   find_package(ZLIB REQUIRED)
   include_directories(${ZLIB_INCLUDE_DIR})
-ENDIF(NOT PNG_BUILD_ZLIB)
+endif()
 
-if(NOT WIN32)
-  find_library(M_LIBRARY
-    NAMES m
-    PATHS /usr/lib /usr/local/lib
-  )
-  if(NOT M_LIBRARY)
-    message(STATUS "math lib 'libm' not found; floating point support disabled")
-  endif()
+if(UNIX AND NOT APPLE AND NOT BEOS AND NOT HAIKU)
+  find_library(M_LIBRARY m)
 else()
-  # not needed on windows
+  # libm is not needed and/or not available
   set(M_LIBRARY "")
 endif()
 
@@ -73,16 +57,14 @@ option(PNG_TESTS  "Build libpng tests" ON)
 
 # Many more configuration options could be added here
 option(PNG_FRAMEWORK "Build OS X framework" OFF)
-option(PNG_DEBUG     "Build with debug output" OFF)
-option(PNGARG        "Disable ANSI-C prototypes" OFF)
-
-option(PNG_HARDWARE_OPTIMIZATIONS "Enable Hardware Optimizations" ON)
-
+option(PNG_DEBUG "Build with debug output" OFF)
+option(PNG_HARDWARE_OPTIMIZATIONS "Enable hardware optimizations" ON)
 
 set(PNG_PREFIX "" CACHE STRING "Prefix to add to the API function names")
 set(DFA_XTRA "" CACHE FILEPATH "File containing extra configuration settings")
 
 if(PNG_HARDWARE_OPTIMIZATIONS)
+
 # set definitions and sources for arm
 if(CMAKE_SYSTEM_PROCESSOR MATCHES "^arm" OR
   CMAKE_SYSTEM_PROCESSOR MATCHES "^aarch64")
@@ -96,12 +78,13 @@ if(CMAKE_SYSTEM_PROCESSOR MATCHES "^arm" OR
   list(FIND PNG_ARM_NEON_POSSIBLE_VALUES ${PNG_ARM_NEON} index)
   if(index EQUAL -1)
     message(FATAL_ERROR
-      " PNG_ARM_NEON must be one of [${PNG_ARM_NEON_POSSIBLE_VALUES}]")
-  elseif(NOT ${PNG_ARM_NEON} STREQUAL "no")
+            "PNG_ARM_NEON must be one of [${PNG_ARM_NEON_POSSIBLE_VALUES}]")
+  elseif(NOT ${PNG_ARM_NEON} STREQUAL "off")
     set(libpng_arm_sources
       arm/arm_init.c
       arm/filter_neon.S
-      arm/filter_neon_intrinsics.c)
+      arm/filter_neon_intrinsics.c
+      arm/palette_neon_intrinsics.c)
 
     if(${PNG_ARM_NEON} STREQUAL "on")
       add_definitions(-DPNG_ARM_NEON_OPT=2)
@@ -115,7 +98,7 @@ endif()
 
 # set definitions and sources for powerpc
 if(CMAKE_SYSTEM_PROCESSOR MATCHES "^powerpc*" OR
-	CMAKE_SYSTEM_PROCESSOR MATCHES "^ppc64*" )
+   CMAKE_SYSTEM_PROCESSOR MATCHES "^ppc64*")
   set(PNG_POWERPC_VSX_POSSIBLE_VALUES on off)
   set(PNG_POWERPC_VSX "on" CACHE STRING "Enable POWERPC VSX optimizations:
      off: disable the optimizations.")
@@ -124,8 +107,8 @@ if(CMAKE_SYSTEM_PROCESSOR MATCHES "^powerpc*" OR
   list(FIND PNG_POWERPC_VSX_POSSIBLE_VALUES ${PNG_POWERPC_VSX} index)
   if(index EQUAL -1)
     message(FATAL_ERROR
-      " PNG_POWERPC_VSX must be one of [${PNG_POWERPC_VSX_POSSIBLE_VALUES}]")
-  elseif(NOT ${PNG_POWERPC_VSX} STREQUAL "no")
+            "PNG_POWERPC_VSX must be one of [${PNG_POWERPC_VSX_POSSIBLE_VALUES}]")
+  elseif(NOT ${PNG_POWERPC_VSX} STREQUAL "off")
     set(libpng_powerpc_sources
       powerpc/powerpc_init.c
       powerpc/filter_vsx_intrinsics.c)
@@ -139,7 +122,7 @@ endif()
 
 # set definitions and sources for intel
 if(CMAKE_SYSTEM_PROCESSOR MATCHES "^i?86" OR
-	CMAKE_SYSTEM_PROCESSOR MATCHES "^x86_64*" )
+   CMAKE_SYSTEM_PROCESSOR MATCHES "^x86_64*")
   set(PNG_INTEL_SSE_POSSIBLE_VALUES on off)
   set(PNG_INTEL_SSE "on" CACHE STRING "Enable INTEL_SSE optimizations:
      off: disable the optimizations")
@@ -148,8 +131,8 @@ if(CMAKE_SYSTEM_PROCESSOR MATCHES "^i?86" OR
   list(FIND PNG_INTEL_SSE_POSSIBLE_VALUES ${PNG_INTEL_SSE} index)
   if(index EQUAL -1)
     message(FATAL_ERROR
-      " PNG_INTEL_SSE must be one of [${PNG_INTEL_SSE_POSSIBLE_VALUES}]")
-  elseif(NOT ${PNG_INTEL_SSE} STREQUAL "no")
+            "PNG_INTEL_SSE must be one of [${PNG_INTEL_SSE_POSSIBLE_VALUES}]")
+  elseif(NOT ${PNG_INTEL_SSE} STREQUAL "off")
     set(libpng_intel_sources
       intel/intel_init.c
       intel/filter_sse2_intrinsics.c)
@@ -163,7 +146,7 @@ endif()
 
 # set definitions and sources for MIPS
 if(CMAKE_SYSTEM_PROCESSOR MATCHES "mipsel*" OR
-	CMAKE_SYSTEM_PROCESSOR MATCHES "mips64el*" )
+   CMAKE_SYSTEM_PROCESSOR MATCHES "mips64el*")
   set(PNG_MIPS_MSA_POSSIBLE_VALUES on off)
   set(PNG_MIPS_MSA "on" CACHE STRING "Enable MIPS_MSA optimizations:
      off: disable the optimizations")
@@ -172,8 +155,8 @@ if(CMAKE_SYSTEM_PROCESSOR MATCHES "mipsel*" OR
   list(FIND PNG_MIPS_MSA_POSSIBLE_VALUES ${PNG_MIPS_MSA} index)
   if(index EQUAL -1)
     message(FATAL_ERROR
-      " PNG_MIPS_MSA must be one of [${PNG_MIPS_MSA_POSSIBLE_VALUES}]")
-  elseif(NOT ${PNG_MIPS_MSA} STREQUAL "no")
+            "PNG_MIPS_MSA must be one of [${PNG_MIPS_MSA_POSSIBLE_VALUES}]")
+  elseif(NOT ${PNG_MIPS_MSA} STREQUAL "off")
     set(libpng_mips_sources
       mips/mips_init.c
       mips/filter_msa_intrinsics.c)
@@ -184,6 +167,33 @@ if(CMAKE_SYSTEM_PROCESSOR MATCHES "mipsel*" OR
     add_definitions(-DPNG_MIPS_MSA_OPT=0)
   endif()
 endif()
+
+else(PNG_HARDWARE_OPTIMIZATIONS)
+
+# set definitions and sources for arm
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "^arm" OR
+   CMAKE_SYSTEM_PROCESSOR MATCHES "^aarch64")
+  add_definitions(-DPNG_ARM_NEON_OPT=0)
+endif()
+
+# set definitions and sources for powerpc
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "^powerpc*" OR
+   CMAKE_SYSTEM_PROCESSOR MATCHES "^ppc64*")
+  add_definitions(-DPNG_POWERPC_VSX_OPT=0)
+endif()
+
+# set definitions and sources for intel
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "^i?86" OR
+   CMAKE_SYSTEM_PROCESSOR MATCHES "^x86_64*")
+  add_definitions(-DPNG_INTEL_SSE_OPT=0)
+endif()
+
+# set definitions and sources for MIPS
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "mipsel*" OR
+   CMAKE_SYSTEM_PROCESSOR MATCHES "mips64el*")
+  add_definitions(-DPNG_MIPS_MSA_OPT=0)
+endif()
+
 endif(PNG_HARDWARE_OPTIMIZATIONS)
 
 # SET LIBNAME
@@ -241,17 +251,17 @@ function(symbol_prefix)
   foreach(line ${OUT})
     string(REGEX MATCH "^PREFIX=" found_match "${line}")
     if(found_match)
-      STRING(REGEX REPLACE "^PREFIX=(.*\)" "\\1" prefix "${line}")
+      string(REGEX REPLACE "^PREFIX=(.*\)" "\\1" prefix "${line}")
       string(REGEX MATCH "__USER_LABEL_PREFIX__" found_match "${prefix}")
       if(found_match)
-        STRING(REGEX REPLACE "(.*)__USER_LABEL_PREFIX__(.*)" "\\1\\2" prefix "${prefix}")
+        string(REGEX REPLACE "(.*)__USER_LABEL_PREFIX__(.*)" "\\1\\2" prefix "${prefix}")
       endif()
       set(SYMBOL_PREFIX "${prefix}")
     endif()
   endforeach()
 
-    message(STATUS "Symbol prefix: ${SYMBOL_PREFIX}")
-    set(SYMBOL_PREFIX "${SYMBOL_PREFIX}" PARENT_SCOPE)
+  message(STATUS "Symbol prefix: ${SYMBOL_PREFIX}")
+  set(SYMBOL_PREFIX "${SYMBOL_PREFIX}" PARENT_SCOPE)
 endfunction()
 
 if(UNIX)
@@ -276,11 +286,11 @@ else()
     set(oneValueArgs INPUT OUTPUT)
     set(multiValueArgs DEPENDS)
     cmake_parse_arguments(_GC "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-    if (NOT _GC_INPUT)
-      message(FATAL_ERROR "Invalid arguments.  generate_out requires input.")
+    if(NOT _GC_INPUT)
+      message(FATAL_ERROR "generate_chk: Missing INPUT argument")
     endif()
-    if (NOT _GC_OUTPUT)
-      message(FATAL_ERROR "Invalid arguments.  generate_out requires output.")
+    if(NOT _GC_OUTPUT)
+      message(FATAL_ERROR "generate_chk: Missing OUTPUT argument")
     endif()
 
     add_custom_command(OUTPUT "${_GC_OUTPUT}"
@@ -299,11 +309,11 @@ else()
     set(oneValueArgs INPUT OUTPUT)
     set(multiValueArgs DEPENDS)
     cmake_parse_arguments(_GO "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-    if (NOT _GO_INPUT)
-      message(FATAL_ERROR "Invalid arguments.  generate_out requires input.")
+    if(NOT _GO_INPUT)
+      message(FATAL_ERROR "generate_out: Missing INPUT argument")
     endif()
-    if (NOT _GO_OUTPUT)
-      message(FATAL_ERROR "Invalid arguments.  generate_out requires output.")
+    if(NOT _GO_OUTPUT)
+      message(FATAL_ERROR "generate_out: Missing OUTPUT argument")
     endif()
 
     add_custom_command(OUTPUT "${_GO_OUTPUT}"
@@ -322,8 +332,8 @@ else()
     set(oneValueArgs OUTPUT)
     set(multiValueArgs DEPENDS)
     cmake_parse_arguments(_GSO "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-    if (NOT _GSO_OUTPUT)
-      message(FATAL_ERROR "Invalid arguments.  generate_source requires output.")
+    if(NOT _GSO_OUTPUT)
+      message(FATAL_ERROR "generate_source: Missing OUTPUT argument")
     endif()
 
     add_custom_command(OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${_GSO_OUTPUT}"
@@ -424,7 +434,7 @@ else()
                     WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
 
   # A single target handles generation of all generated files.  If
-  # they are dependend upon separately by multiple targets, this
+  # they are depended upon separately by multiple targets, this
   # confuses parallel make (it would require a separate top-level
   # target for each file to track the dependencies properly).
   add_custom_target(genfiles DEPENDS
@@ -505,7 +515,7 @@ set(png_fix_itxt_sources
 
 if(MSVC)
   add_definitions(-D_CRT_SECURE_NO_DEPRECATE)
-endif(MSVC)
+endif()
 
 if(PNG_DEBUG)
   add_definitions(-DPNG_DEBUG)
@@ -585,7 +595,7 @@ if(NOT PNG_LIB_TARGETS)
   message(SEND_ERROR
     "No library variant selected to build. "
     "Please enable at least one of the following options: "
-    " PNG_STATIC, PNG_SHARED, PNG_FRAMEWORK")
+    "PNG_STATIC, PNG_SHARED, PNG_FRAMEWORK")
 endif()
 
 if(PNG_SHARED AND WIN32)
@@ -598,11 +608,11 @@ function(png_add_test)
   set(multiValueArgs OPTIONS FILES)
   cmake_parse_arguments(_PAT "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
 
-  if (NOT _PAT_NAME)
-    message(FATAL_ERROR "Invalid arguments.  png_add_test requires name.")
+  if(NOT _PAT_NAME)
+    message(FATAL_ERROR "png_add_test: Missing NAME argument")
   endif()
-  if (NOT _PAT_COMMAND)
-    message(FATAL_ERROR "Invalid arguments.  png_add_test requires command.")
+  if(NOT _PAT_COMMAND)
+    message(FATAL_ERROR "png_add_test: Missing COMMAND argument")
   endif()
 
   set(TEST_OPTIONS "${_PAT_OPTIONS}")
@@ -610,19 +620,11 @@ function(png_add_test)
 
   configure_file("${CMAKE_CURRENT_SOURCE_DIR}/scripts/test.cmake.in"
                  "${CMAKE_CURRENT_BINARY_DIR}/tests/${_PAT_NAME}.cmake" @ONLY)
-  if(CMAKE_MAJOR_VERSION GREATER 2) # have generator expressions
-    add_test(NAME "${_PAT_NAME}"
-             COMMAND "${CMAKE_COMMAND}"
-             "-DLIBPNG=$<TARGET_FILE:png>"
-             "-DTEST_COMMAND=$<TARGET_FILE:${_PAT_COMMAND}>"
-             -P "${CMAKE_CURRENT_BINARY_DIR}/tests/${_PAT_NAME}.cmake")
-  else() # old 2.x add_test; limited and won't work well on Windows
-    # Note LIBPNG is a dummy value as there are no generator expressions
-    add_test("${_PAT_NAME}" "${CMAKE_COMMAND}"
-             "-DLIBPNG=${CMAKE_CURRENT_BINARY_DIR}/libpng.so"
-             "-DTEST_COMMAND=./${_PAT_COMMAND}"
-             -P "${CMAKE_CURRENT_BINARY_DIR}/tests/${_PAT_NAME}.cmake")
-  endif()
+  add_test(NAME "${_PAT_NAME}"
+           COMMAND "${CMAKE_COMMAND}"
+           "-DLIBPNG=$<TARGET_FILE:png>"
+           "-DTEST_COMMAND=$<TARGET_FILE:${_PAT_COMMAND}>"
+           -P "${CMAKE_CURRENT_BINARY_DIR}/tests/${_PAT_NAME}.cmake")
 endfunction()
 
 if(PNG_TESTS AND PNG_SHARED)
@@ -687,11 +689,11 @@ if(PNG_TESTS AND PNG_SHARED)
         set(TEST_PNG_VALID TRUE)
 
         if(TEST_PNG_ALPHA)
-          if (NOT "${alpha_type}" STREQUAL "alpha")
+          if(NOT "${alpha_type}" STREQUAL "alpha")
             set(TEST_PNG_VALID FALSE)
           endif()
         else()
-          if ("${alpha_type}" STREQUAL "alpha")
+          if("${alpha_type}" STREQUAL "alpha")
             set(TEST_PNG_VALID FALSE)
           endif()
         endif()
@@ -760,51 +762,44 @@ endif()
 # copies if different.
 include(CMakeParseArguments)
 
-function(CREATE_SYMLINK DEST_FILE)
+function(create_symlink DEST_FILE)
 
   cmake_parse_arguments(S "" "FILE;TARGET" "" ${ARGN})
 
   if(NOT S_TARGET AND NOT S_FILE)
-    message(FATAL_ERROR "Specify either a TARGET or a FILE for CREATE_SYMLINK to link to.")
-  endif(NOT S_TARGET AND NOT S_FILE)
+    message(FATAL_ERROR "create_symlink: Missing TARGET or FILE argument")
+  endif()
 
   if(S_TARGET AND S_FILE)
-    message(FATAL_ERROR "CREATE_SYMLINK called with both source file ${S_FILE} and build target ${S_TARGET} arguments - can only handle 1 type per call.")
-  endif(S_TARGET AND S_FILE)
+    message(FATAL_ERROR "create_symlink: Both source file ${S_FILE} and build target ${S_TARGET} arguments are present; can only have one.")
+  endif()
 
   if(S_FILE)
     # If we don't need to symlink something that's coming from a build target,
     # we can go ahead and symlink/copy at configure time.
-
-    if(CMAKE_HOST_WIN32 AND NOT CYGWIN AND NOT MSYS)
+    if(CMAKE_HOST_WIN32 AND NOT CYGWIN)
       execute_process(
-	COMMAND "${CMAKE_COMMAND}" -E copy_if_different ${S_FILE} ${DEST_FILE}
-	WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
-	)
-    else(CMAKE_HOST_WIN32 AND NOT CYGWIN AND NOT MSYS)
+        COMMAND "${CMAKE_COMMAND}" -E copy_if_different ${S_FILE} ${DEST_FILE}
+        WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
+    else()
       execute_process(
-	COMMAND ${CMAKE_COMMAND} -E create_symlink ${S_FILE} ${DEST_FILE}
-	WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
-	)
-    endif(CMAKE_HOST_WIN32 AND NOT CYGWIN AND NOT MSYS)
-  endif(S_FILE)
+        COMMAND ${CMAKE_COMMAND} -E create_symlink ${S_FILE} ${DEST_FILE}
+        WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
+    endif()
+  endif()
 
   if(S_TARGET)
     # We need to use generator expressions, which can be a bit tricky, so for
     # simplicity make the symlink a POST_BUILD step and use the TARGET
     # signature of add_custom_command.
-
-    if(CMAKE_HOST_WIN32 AND NOT CYGWIN AND NOT MSYS)
+    if(CMAKE_HOST_WIN32 AND NOT CYGWIN)
       add_custom_command(TARGET ${S_TARGET} POST_BUILD
-	COMMAND "${CMAKE_COMMAND}" -E copy_if_different $<TARGET_LINKER_FILE_NAME:${S_TARGET}> $<TARGET_LINKER_FILE_DIR:${S_TARGET}>/${DEST_FILE}
-	)
-    else(CMAKE_HOST_WIN32 AND NOT CYGWIN AND NOT MSYS)
+        COMMAND "${CMAKE_COMMAND}" -E copy_if_different $<TARGET_LINKER_FILE_NAME:${S_TARGET}> $<TARGET_LINKER_FILE_DIR:${S_TARGET}>/${DEST_FILE})
+    else()
       add_custom_command(TARGET ${S_TARGET} POST_BUILD
-	COMMAND "${CMAKE_COMMAND}" -E create_symlink $<TARGET_LINKER_FILE_NAME:${S_TARGET}> $<TARGET_LINKER_FILE_DIR:${S_TARGET}>/${DEST_FILE}
-	)
-    endif(CMAKE_HOST_WIN32 AND NOT CYGWIN AND NOT MSYS)
-
-  endif(S_TARGET)
+        COMMAND "${CMAKE_COMMAND}" -E create_symlink $<TARGET_LINKER_FILE_NAME:${S_TARGET}> $<TARGET_LINKER_FILE_DIR:${S_TARGET}>/${DEST_FILE})
+    endif()
+  endif()
 
 endfunction()
 
@@ -816,103 +811,95 @@ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/scripts/genout.cmake.in
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/scripts/gensrc.cmake.in
                ${CMAKE_CURRENT_BINARY_DIR}/scripts/gensrc.cmake @ONLY)
 
-
 # libpng is a library so default to 'lib'
 if(NOT DEFINED CMAKE_INSTALL_LIBDIR)
   set(CMAKE_INSTALL_LIBDIR lib)
-endif(NOT DEFINED CMAKE_INSTALL_LIBDIR)
+endif()
 
 # CREATE PKGCONFIG FILES
-# we use the same files like ./configure, so we have to set its vars
+# We use the same files like ./configure, so we have to set its vars.
 # Only do this on Windows for Cygwin - the files don't make much sense outside
-# a UNIX look alike
+# of a UNIX look-alike.
 if(NOT WIN32 OR CYGWIN OR MINGW)
   set(prefix      ${CMAKE_INSTALL_PREFIX})
   set(exec_prefix ${CMAKE_INSTALL_PREFIX})
-  set(libdir      ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR})
-  set(includedir  ${CMAKE_INSTALL_PREFIX}/include)
+  set(libdir      ${CMAKE_INSTALL_FULL_LIBDIR})
+  set(includedir  ${CMAKE_INSTALL_FULL_INCLUDEDIR})
   set(LIBS        "-lz -lm")
   configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libpng.pc.in
     ${CMAKE_CURRENT_BINARY_DIR}/${PNGLIB_NAME}.pc @ONLY)
-  CREATE_SYMLINK(libpng.pc FILE ${PNGLIB_NAME}.pc)
+  create_symlink(libpng.pc FILE ${PNGLIB_NAME}.pc)
 
   configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libpng-config.in
     ${CMAKE_CURRENT_BINARY_DIR}/${PNGLIB_NAME}-config @ONLY)
-  CREATE_SYMLINK(libpng-config FILE ${PNGLIB_NAME}-config)
-endif(NOT WIN32 OR CYGWIN OR MINGW)
+  create_symlink(libpng-config FILE ${PNGLIB_NAME}-config)
+endif()
 
 # SET UP LINKS
 if(PNG_SHARED)
   set_target_properties(png PROPERTIES
-#   VERSION 16.${PNGLIB_RELEASE}.1.6.34
+#   VERSION 16.${PNGLIB_RELEASE}.1.6.37
     VERSION 16.${PNGLIB_RELEASE}.0
     SOVERSION 16
     CLEAN_DIRECT_OUTPUT 1)
 endif()
 
-# If CMake > 2.4.x, we set a variable used below to export
-# targets to an export file.
-# TODO: Use VERSION_GREATER after our cmake_minimum_required >= 2.6.2
-if(CMAKE_MAJOR_VERSION GREATER 1 AND CMAKE_MINOR_VERSION GREATER 4)
-  set(PNG_EXPORT_RULE EXPORT libpng)
-elseif(CMAKE_MAJOR_VERSION GREATER 2) # future proof
-  set(PNG_EXPORT_RULE EXPORT libpng)
-endif()
-
 # INSTALL
-if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL )
+if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL)
   install(TARGETS ${PNG_LIB_TARGETS}
-      ${PNG_EXPORT_RULE}
-      RUNTIME DESTINATION bin
-      LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-      ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-      FRAMEWORK DESTINATION ${CMAKE_INSTALL_LIBDIR})
+          EXPORT libpng
+          RUNTIME DESTINATION bin
+          LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+          ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+          FRAMEWORK DESTINATION ${CMAKE_INSTALL_LIBDIR})
 
   if(PNG_SHARED)
     # Create a symlink for libpng.dll.a => libpng16.dll.a on Cygwin
     if(CYGWIN OR MINGW)
-      CREATE_SYMLINK(libpng${CMAKE_IMPORT_LIBRARY_SUFFIX} TARGET png)
-      install(FILES $<TARGET_LINKER_FILE_DIR:png>/libpng${CMAKE_IMPORT_LIBRARY_SUFFIX} DESTINATION ${CMAKE_INSTALL_LIBDIR})
-    endif(CYGWIN OR MINGW)
+      create_symlink(libpng${CMAKE_IMPORT_LIBRARY_SUFFIX} TARGET png)
+      install(FILES $<TARGET_LINKER_FILE_DIR:png>/libpng${CMAKE_IMPORT_LIBRARY_SUFFIX}
+              DESTINATION ${CMAKE_INSTALL_LIBDIR})
+    endif()
 
     if(NOT WIN32)
-      CREATE_SYMLINK(libpng${CMAKE_SHARED_LIBRARY_SUFFIX} TARGET png)
-      install(FILES $<TARGET_LINKER_FILE_DIR:png>/libpng${CMAKE_SHARED_LIBRARY_SUFFIX} DESTINATION ${CMAKE_INSTALL_LIBDIR})
-    endif(NOT WIN32)
-  endif(PNG_SHARED)
+      create_symlink(libpng${CMAKE_SHARED_LIBRARY_SUFFIX} TARGET png)
+      install(FILES $<TARGET_LINKER_FILE_DIR:png>/libpng${CMAKE_SHARED_LIBRARY_SUFFIX}
+              DESTINATION ${CMAKE_INSTALL_LIBDIR})
+    endif()
+  endif()
 
   if(PNG_STATIC)
     if(NOT WIN32 OR CYGWIN OR MINGW)
-      CREATE_SYMLINK( libpng${CMAKE_STATIC_LIBRARY_SUFFIX} TARGET png_static)
-      install(FILES $<TARGET_LINKER_FILE_DIR:png_static>/libpng${CMAKE_STATIC_LIBRARY_SUFFIX} DESTINATION ${CMAKE_INSTALL_LIBDIR})
-    endif(NOT WIN32 OR CYGWIN OR MINGW)
- endif()
+      create_symlink(libpng${CMAKE_STATIC_LIBRARY_SUFFIX} TARGET png_static)
+      install(FILES $<TARGET_LINKER_FILE_DIR:png_static>/libpng${CMAKE_STATIC_LIBRARY_SUFFIX}
+              DESTINATION ${CMAKE_INSTALL_LIBDIR})
+    endif()
+  endif()
 endif()
 
-if(NOT SKIP_INSTALL_HEADERS AND NOT SKIP_INSTALL_ALL )
-  install(FILES ${libpng_public_hdrs}   DESTINATION include)
-  install(FILES ${libpng_public_hdrs}   DESTINATION include/${PNGLIB_NAME})
+if(NOT SKIP_INSTALL_HEADERS AND NOT SKIP_INSTALL_ALL)
+  install(FILES ${libpng_public_hdrs} DESTINATION include)
+  install(FILES ${libpng_public_hdrs} DESTINATION include/${PNGLIB_NAME})
 endif()
-if(NOT SKIP_INSTALL_EXECUTABLES AND NOT SKIP_INSTALL_ALL )
+if(NOT SKIP_INSTALL_EXECUTABLES AND NOT SKIP_INSTALL_ALL)
   if(NOT WIN32 OR CYGWIN OR MINGW)
     install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/libpng-config DESTINATION bin)
-    install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/${PNGLIB_NAME}-config
-            DESTINATION bin)
-  endif(NOT WIN32 OR CYGWIN OR MINGW)
+    install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/${PNGLIB_NAME}-config DESTINATION bin)
+  endif()
 endif()
 
-if(NOT SKIP_INSTALL_PROGRAMS AND NOT SKIP_INSTALL_ALL )
+if(NOT SKIP_INSTALL_PROGRAMS AND NOT SKIP_INSTALL_ALL)
   install(TARGETS ${PNG_BIN_TARGETS}
-      RUNTIME DESTINATION bin)
+          RUNTIME DESTINATION bin)
 endif()
 
-if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL )
+if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL)
   # Install man pages
   if(NOT PNG_MAN_DIR)
     set(PNG_MAN_DIR "share/man")
   endif()
-  install(FILES libpng.3 libpngpf.3      DESTINATION ${PNG_MAN_DIR}/man3)
-  install(FILES png.5                    DESTINATION ${PNG_MAN_DIR}/man5)
+  install(FILES libpng.3 libpngpf.3 DESTINATION ${PNG_MAN_DIR}/man3)
+  install(FILES png.5 DESTINATION ${PNG_MAN_DIR}/man5)
   # Install pkg-config files
   if(NOT CMAKE_HOST_WIN32 OR CYGWIN OR MINGW)
     install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libpng.pc
@@ -923,12 +910,11 @@ if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL )
             DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
     install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/${PNGLIB_NAME}-config
             DESTINATION bin)
-  endif(NOT CMAKE_HOST_WIN32 OR CYGWIN OR MINGW)
+  endif()
 endif()
 
-# On versions of CMake that support it, create an export file CMake
-# users can include() to import our targets
-if(PNG_EXPORT_RULE AND NOT SKIP_INSTALL_EXPORT AND NOT SKIP_INSTALL_ALL )
+# Create an export file that CMake users can include() to import our targets.
+if(NOT SKIP_INSTALL_EXPORT AND NOT SKIP_INSTALL_ALL)
   install(EXPORT libpng DESTINATION lib/libpng FILE lib${PNG_LIB_NAME}.cmake)
 endif()
 
diff --git a/Engine/lib/lpng/INSTALL b/Engine/lib/lpng/INSTALL
index e8edb7240..4c1702251 100644
--- a/Engine/lib/lpng/INSTALL
+++ b/Engine/lib/lpng/INSTALL
@@ -284,7 +284,7 @@ those sections that are actually used will be loaded into memory.
 
 XIV. Enabling or disabling hardware optimizations
 
-Certain hardware capabilites, such as the Intel SSE instructions,
+Certain hardware capabilities, such as the Intel SSE instructions,
 are normally detected at run time. Enable them with configure options
 such as one of
 
diff --git a/Engine/lib/lpng/LICENSE b/Engine/lib/lpng/LICENSE
index 4cda4fa0a..e0c5b531c 100644
--- a/Engine/lib/lpng/LICENSE
+++ b/Engine/lib/lpng/LICENSE
@@ -1,53 +1,82 @@
+COPYRIGHT NOTICE, DISCLAIMER, and LICENSE
+=========================================
 
-This copy of the libpng notices is provided for your convenience.  In case of
-any discrepancy between this copy and the notices in the file png.h that is
-included in the libpng distribution, the latter shall prevail.
+PNG Reference Library License version 2
+---------------------------------------
 
-COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:
+ * Copyright (c) 1995-2019 The PNG Reference Library Authors.
+ * Copyright (c) 2018-2019 Cosmin Truta.
+ * Copyright (c) 2000-2002, 2004, 2006-2018 Glenn Randers-Pehrson.
+ * Copyright (c) 1996-1997 Andreas Dilger.
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
 
-If you modify libpng you may insert additional notices immediately following
-this sentence.
+The software is supplied "as is", without warranty of any kind,
+express or implied, including, without limitation, the warranties
+of merchantability, fitness for a particular purpose, title, and
+non-infringement.  In no event shall the Copyright owners, or
+anyone distributing the software, be liable for any damages or
+other liability, whether in contract, tort or otherwise, arising
+from, out of, or in connection with the software, or the use or
+other dealings in the software, even if advised of the possibility
+of such damage.
 
-This code is released under the libpng license.
+Permission is hereby granted to use, copy, modify, and distribute
+this software, or portions hereof, for any purpose, without fee,
+subject to the following restrictions:
 
-libpng versions 1.0.7, July 1, 2000 through 1.6.34, September 29, 2017 are
-Copyright (c) 2000-2002, 2004, 2006-2017 Glenn Randers-Pehrson, are
+ 1. The origin of this software must not be misrepresented; you
+    must not claim that you wrote the original software.  If you
+    use this software in a product, an acknowledgment in the product
+    documentation would be appreciated, but is not required.
+
+ 2. Altered source versions must be plainly marked as such, and must
+    not be misrepresented as being the original software.
+
+ 3. This Copyright notice may not be removed or altered from any
+    source or altered source distribution.
+
+
+PNG Reference Library License version 1 (for libpng 0.5 through 1.6.35)
+-----------------------------------------------------------------------
+
+libpng versions 1.0.7, July 1, 2000, through 1.6.35, July 15, 2018 are
+Copyright (c) 2000-2002, 2004, 2006-2018 Glenn Randers-Pehrson, are
 derived from libpng-1.0.6, and are distributed according to the same
 disclaimer and license as libpng-1.0.6 with the following individuals
 added to the list of Contributing Authors:
 
-   Simon-Pierre Cadieux
-   Eric S. Raymond
-   Mans Rullgard
-   Cosmin Truta
-   Gilles Vollant
-   James Yu
-   Mandar Sahastrabuddhe
-   Google Inc.
-   Vadim Barkov
+    Simon-Pierre Cadieux
+    Eric S. Raymond
+    Mans Rullgard
+    Cosmin Truta
+    Gilles Vollant
+    James Yu
+    Mandar Sahastrabuddhe
+    Google Inc.
+    Vadim Barkov
 
 and with the following additions to the disclaimer:
 
-   There is no warranty against interference with your enjoyment of the
-   library or against infringement.  There is no warranty that our
-   efforts or the library will fulfill any of your particular purposes
-   or needs.  This library is provided with all faults, and the entire
-   risk of satisfactory quality, performance, accuracy, and effort is with
-   the user.
+    There is no warranty against interference with your enjoyment of
+    the library or against infringement.  There is no warranty that our
+    efforts or the library will fulfill any of your particular purposes
+    or needs.  This library is provided with all faults, and the entire
+    risk of satisfactory quality, performance, accuracy, and effort is
+    with the user.
 
 Some files in the "contrib" directory and some configure-generated
-files that are distributed with libpng have other copyright owners and
+files that are distributed with libpng have other copyright owners, and
 are released under other open source licenses.
 
 libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are
 Copyright (c) 1998-2000 Glenn Randers-Pehrson, are derived from
 libpng-0.96, and are distributed according to the same disclaimer and
-license as libpng-0.96, with the following individuals added to the list
-of Contributing Authors:
+license as libpng-0.96, with the following individuals added to the
+list of Contributing Authors:
 
-   Tom Lane
-   Glenn Randers-Pehrson
-   Willem van Schaik
+    Tom Lane
+    Glenn Randers-Pehrson
+    Willem van Schaik
 
 libpng versions 0.89, June 1996, through 0.96, May 1997, are
 Copyright (c) 1996-1997 Andreas Dilger, are derived from libpng-0.88,
@@ -55,14 +84,14 @@ and are distributed according to the same disclaimer and license as
 libpng-0.88, with the following individuals added to the list of
 Contributing Authors:
 
-   John Bowler
-   Kevin Bracey
-   Sam Bushell
-   Magnus Holmgren
-   Greg Roelofs
-   Tom Tanner
+    John Bowler
+    Kevin Bracey
+    Sam Bushell
+    Magnus Holmgren
+    Greg Roelofs
+    Tom Tanner
 
-Some files in the "scripts" directory have other copyright owners
+Some files in the "scripts" directory have other copyright owners,
 but are released under this license.
 
 libpng versions 0.5, May 1995, through 0.88, January 1996, are
@@ -71,63 +100,35 @@ Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
 For the purposes of this copyright and license, "Contributing Authors"
 is defined as the following set of individuals:
 
-   Andreas Dilger
-   Dave Martindale
-   Guy Eric Schalnat
-   Paul Schmidt
-   Tim Wegner
+    Andreas Dilger
+    Dave Martindale
+    Guy Eric Schalnat
+    Paul Schmidt
+    Tim Wegner
 
-The PNG Reference Library is supplied "AS IS".  The Contributing Authors
-and Group 42, Inc. disclaim all warranties, expressed or implied,
-including, without limitation, the warranties of merchantability and of
-fitness for any purpose.  The Contributing Authors and Group 42, Inc.
-assume no liability for direct, indirect, incidental, special, exemplary,
-or consequential damages, which may result from the use of the PNG
-Reference Library, even if advised of the possibility of such damage.
+The PNG Reference Library is supplied "AS IS".  The Contributing
+Authors and Group 42, Inc. disclaim all warranties, expressed or
+implied, including, without limitation, the warranties of
+merchantability and of fitness for any purpose.  The Contributing
+Authors and Group 42, Inc. assume no liability for direct, indirect,
+incidental, special, exemplary, or consequential damages, which may
+result from the use of the PNG Reference Library, even if advised of
+the possibility of such damage.
 
 Permission is hereby granted to use, copy, modify, and distribute this
 source code, or portions hereof, for any purpose, without fee, subject
 to the following restrictions:
 
-  1. The origin of this source code must not be misrepresented.
+ 1. The origin of this source code must not be misrepresented.
 
-  2. Altered versions must be plainly marked as such and must not
-     be misrepresented as being the original source.
+ 2. Altered versions must be plainly marked as such and must not
+    be misrepresented as being the original source.
 
-  3. This Copyright notice may not be removed or altered from any
-     source or altered source distribution.
+ 3. This Copyright notice may not be removed or altered from any
+    source or altered source distribution.
 
-The Contributing Authors and Group 42, Inc. specifically permit, without
-fee, and encourage the use of this source code as a component to
-supporting the PNG file format in commercial products.  If you use this
-source code in a product, acknowledgment is not required but would be
-appreciated.
-
-END OF COPYRIGHT NOTICE, DISCLAIMER, and LICENSE.
-
-TRADEMARK:
-
-The name "libpng" has not been registered by the Copyright owner
-as a trademark in any jurisdiction.  However, because libpng has
-been distributed and maintained world-wide, continually since 1995,
-the Copyright owner claims "common-law trademark protection" in any
-jurisdiction where common-law trademark is recognized.
-
-OSI CERTIFICATION:
-
-Libpng is OSI Certified Open Source Software.  OSI Certified Open Source is
-a certification mark of the Open Source Initiative. OSI has not addressed
-the additional disclaimers inserted at version 1.0.7.
-
-EXPORT CONTROL:
-
-The Copyright owner believes that the Export Control Classification
-Number (ECCN) for libpng is EAR99, which means not subject to export
-controls or International Traffic in Arms Regulations (ITAR) because
-it is open source, publicly available software, that does not contain
-any encryption software.  See the EAR, paragraphs 734.3(b)(3) and
-734.7(b).
-
-Glenn Randers-Pehrson
-glennrp at users.sourceforge.net
-September 29, 2017
+The Contributing Authors and Group 42, Inc. specifically permit,
+without fee, and encourage the use of this source code as a component
+to supporting the PNG file format in commercial products.  If you use
+this source code in a product, acknowledgment is not required but would
+be appreciated.
diff --git a/Engine/lib/lpng/Makefile.am b/Engine/lib/lpng/Makefile.am
new file mode 100644
index 000000000..4f621aa4d
--- /dev/null
+++ b/Engine/lib/lpng/Makefile.am
@@ -0,0 +1,393 @@
+# Makefile.am, the source file for Makefile.in (and hence Makefile), is
+#
+# Copyright (c) 2018 Cosmin Truta
+# Copyright (c) 2004-2016 Glenn Randers-Pehrson
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+PNGLIB_BASENAME= libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@
+
+ACLOCAL_AMFLAGS = -I scripts
+
+# test programs - run on make check, make distcheck
+check_PROGRAMS= pngtest pngunknown pngstest pngvalid pngimage pngcp
+if HAVE_CLOCK_GETTIME
+check_PROGRAMS += timepng
+endif
+
+# Utilities - installed
+bin_PROGRAMS= pngfix png-fix-itxt
+
+# This ensures that pnglibconf.h gets built at the start of 'make all' or
+# 'make check', but it does not add dependencies to the individual programs,
+# this is done below.
+#
+# IMPORTANT: always add the object modules of new programs to the list below
+# because otherwise the sequence 'configure; make new-program' will *sometimes*
+# result in the installed (system) pnglibconf.h being used and the result is
+# always wrong and always very confusing.
+BUILT_SOURCES = pnglibconf.h
+
+pngtest_SOURCES = pngtest.c
+pngtest_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
+
+pngvalid_SOURCES = contrib/libtests/pngvalid.c
+pngvalid_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
+
+pngstest_SOURCES = contrib/libtests/pngstest.c
+pngstest_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
+
+pngunknown_SOURCES = contrib/libtests/pngunknown.c
+pngunknown_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
+
+pngimage_SOURCES = contrib/libtests/pngimage.c
+pngimage_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
+
+timepng_SOURCES = contrib/libtests/timepng.c
+timepng_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
+
+pngfix_SOURCES = contrib/tools/pngfix.c
+pngfix_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
+
+png_fix_itxt_SOURCES = contrib/tools/png-fix-itxt.c
+
+pngcp_SOURCES = contrib/tools/pngcp.c
+pngcp_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
+
+# Generally these are single line shell scripts to run a test with a particular
+# set of parameters:
+TESTS =\
+   tests/pngtest\
+   tests/pngtest-badpngs\
+   tests/pngvalid-gamma-16-to-8 tests/pngvalid-gamma-alpha-mode\
+   tests/pngvalid-gamma-background tests/pngvalid-gamma-expand16-alpha-mode\
+   tests/pngvalid-gamma-expand16-background\
+   tests/pngvalid-gamma-expand16-transform tests/pngvalid-gamma-sbit\
+   tests/pngvalid-gamma-threshold tests/pngvalid-gamma-transform\
+   tests/pngvalid-progressive-size\
+   tests/pngvalid-progressive-interlace-standard\
+   tests/pngvalid-transform\
+   tests/pngvalid-progressive-standard tests/pngvalid-standard\
+   tests/pngstest-1.8 tests/pngstest-1.8-alpha tests/pngstest-linear\
+   tests/pngstest-linear-alpha tests/pngstest-none tests/pngstest-none-alpha\
+   tests/pngstest-sRGB tests/pngstest-sRGB-alpha tests/pngunknown-IDAT\
+   tests/pngunknown-discard tests/pngunknown-if-safe tests/pngunknown-sAPI\
+   tests/pngunknown-sTER tests/pngunknown-save tests/pngunknown-vpAg\
+   tests/pngimage-quick tests/pngimage-full
+
+# man pages
+dist_man_MANS= libpng.3 libpngpf.3 png.5
+
+# generate the -config scripts if required
+binconfigs= libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@-config
+EXTRA_SCRIPTS= libpng-config libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@-config
+bin_SCRIPTS= @binconfigs@
+
+# rules to build libpng, only build the old library on request
+lib_LTLIBRARIES=libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
+# EXTRA_LTLIBRARIES= libpng.la
+libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES = png.c pngerror.c\
+	pngget.c pngmem.c pngpread.c pngread.c pngrio.c pngrtran.c pngrutil.c\
+	pngset.c pngtrans.c pngwio.c pngwrite.c pngwtran.c pngwutil.c\
+	png.h pngconf.h pngdebug.h pnginfo.h pngpriv.h pngstruct.h pngusr.dfa
+
+if PNG_ARM_NEON
+libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES += arm/arm_init.c\
+	arm/filter_neon.S arm/filter_neon_intrinsics.c \
+	arm/palette_neon_intrinsics.c
+endif
+
+if PNG_MIPS_MSA
+libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES += mips/mips_init.c\
+	mips/filter_msa_intrinsics.c
+endif
+
+if PNG_INTEL_SSE
+libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES += intel/intel_init.c\
+	intel/filter_sse2_intrinsics.c
+endif
+
+if PNG_POWERPC_VSX
+libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES += powerpc/powerpc_init.c\
+        powerpc/filter_vsx_intrinsics.c
+endif
+
+nodist_libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES = pnglibconf.h
+
+libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_LDFLAGS = -no-undefined -export-dynamic \
+	-version-number @PNGLIB_MAJOR@@PNGLIB_MINOR@:@PNGLIB_RELEASE@:0
+
+if HAVE_LD_VERSION_SCRIPT
+#   Versioned symbols and restricted exports
+if HAVE_SOLARIS_LD
+  libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_LDFLAGS += -Wl,-M -Wl,libpng.vers
+else
+  libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_LDFLAGS += -Wl,--version-script=libpng.vers
+endif
+
+  libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_DEPENDENCIES = libpng.vers
+else
+#   Only restricted exports when possible
+  libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_LDFLAGS += -export-symbols libpng.sym
+  libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_DEPENDENCIES = libpng.sym
+endif
+
+#distribute headers in /usr/include/libpng/*
+pkgincludedir= $(includedir)/$(PNGLIB_BASENAME)
+pkginclude_HEADERS= png.h pngconf.h
+nodist_pkginclude_HEADERS= pnglibconf.h
+
+# pkg-config stuff, note that libpng.pc is always required in order
+# to get the correct library
+pkgconfigdir = @pkgconfigdir@
+pkgconfig_DATA = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.pc
+
+# Extra source distribution files, '${srcdir}' is used below to stop build files
+# from those directories being included.  This only works if the configure is
+# not done in the source directory!
+EXTRA_DIST= \
+	ANNOUNCE AUTHORS CHANGES INSTALL LICENSE README TODO TRADEMARK \
+	pngtest.png pngbar.png pngnow.png pngbar.jpg autogen.sh \
+	${srcdir}/contrib ${srcdir}/projects ${srcdir}/scripts \
+	$(TESTS) $(XFAIL_TESTS) tests/pngstest \
+	CMakeLists.txt example.c libpng-manual.txt
+
+SCRIPT_CLEANFILES=scripts/*.out scripts/*.chk
+
+CLEANFILES= *.tf? pngout.png libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.pc \
+	libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@-config libpng.vers libpng.sym \
+	check.new pnglibconf.h pngprefix.h symbols.new pngtest-log.txt \
+	pnglibconf.out pnglibconf.c pnglibconf.pre pnglibconf.dfn \
+	$(SCRIPT_CLEANFILES)
+
+MAINTAINERCLEANFILES = Makefile.in aclocal.m4 config.guess config.h.in \
+config.sub configure depcomp install-sh ltmain.sh missing
+
+# PNG_COPTS give extra options for the C compiler to be used on all compilation
+# steps (unless targe_CFLAGS is specified; that will take precedence over
+# AM_CFLAGS)
+PNG_COPTS = @PNG_COPTS@
+AM_CFLAGS = ${PNG_COPTS}
+
+# DFNCPP is normally just CPP - the C preprocessor - but on Solaris and maybe
+# other operating systems (NeXT?) the C preprocessor selected by configure
+# checks input tokens for validity - effectively it performs part of the ANSI-C
+# parsing - and therefore fails with the .df files.  configure.ac has special
+# checks for this and sets DFNCPP appropriately.
+DFNCPP = @DFNCPP@
+
+SUFFIXES = .chk .out
+
+$(PNGLIB_BASENAME).pc: libpng.pc
+	cp libpng.pc $@
+
+$(PNGLIB_BASENAME)-config: libpng-config
+	cp libpng-config $@
+
+scripts/sym.out scripts/vers.out: png.h pngconf.h pnglibconf.h
+scripts/prefix.out: png.h pngconf.h pnglibconf.out
+scripts/symbols.out: png.h pngconf.h $(srcdir)/scripts/pnglibconf.h.prebuilt
+scripts/intprefix.out: pnglibconf.h
+
+libpng.sym: scripts/sym.out
+	rm -f $@
+	cp $? $@
+libpng.vers: scripts/vers.out
+	rm -f $@
+	cp $? $@
+
+if DO_PNG_PREFIX
+# Rename functions in scripts/prefix.out with a PNG_PREFIX prefix.
+# Rename macros in scripts/macro.lst from PNG_PREFIXpng_ to PNG_ (the actual
+# implementation of the macro).
+pnglibconf.h: pnglibconf.out scripts/prefix.out scripts/macro.lst
+	rm -f $@
+	$(AWK) 's==0 && NR>1{print prev}\
+	   s==0{prev=$$0}\
+	   s==1{print "#define", $$1, "@PNG_PREFIX@" $$1}\
+	   s==2{print "#define @PNG_PREFIX@png_" $$1, "PNG_" $$1}\
+	   END{print prev}' s=0 pnglibconf.out s=1 scripts/prefix.out\
+	   s=2 ${srcdir}/scripts/macro.lst >pnglibconf.tf8
+	mv pnglibconf.tf8 $@
+
+pngprefix.h: scripts/intprefix.out
+	rm -f pngprefix.tf1
+	$(AWK) '{print "#define", $$1, "@PNG_PREFIX@" $$1}' $? >pngprefix.tf1
+	mv pngprefix.tf1 $@
+else
+pnglibconf.h: pnglibconf.out
+	rm -f $@
+	cp $? $@
+
+pngprefix.h: # is empty
+	:>$@
+endif
+
+$(srcdir)/scripts/pnglibconf.h.prebuilt:
+	@echo "Attempting to build $@" >&2
+	@echo "This is a machine generated file, but if you want to make" >&2
+	@echo "a new one simply make 'scripts/pnglibconf.out', copy that" >&2
+	@echo "AND set PNG_ZLIB_VERNUM to 0 (you MUST do this)" >&2
+	@exit 1
+
+# The following is necessary to ensure that the local pnglibconf.h is used, not
+# an installed one (this can happen immediately after on a clean system if
+# 'make test' is the first thing the user does.)  Only files which include
+# one of the png source files (typically png.h or pngpriv.h) need to be listed
+# here:
+pngtest.o: pnglibconf.h
+
+contrib/libtests/makepng.o: pnglibconf.h
+contrib/libtests/pngstest.o: pnglibconf.h
+contrib/libtests/pngunknown.o: pnglibconf.h
+contrib/libtests/pngimage.o: pnglibconf.h
+contrib/libtests/pngvalid.o: pnglibconf.h
+contrib/libtests/readpng.o: pnglibconf.h
+contrib/libtests/tarith.o: pnglibconf.h
+contrib/libtests/timepng.o: pnglibconf.h
+
+contrib/tools/makesRGB.o: pnglibconf.h
+contrib/tools/pngfix.o: pnglibconf.h
+contrib/tools/pngcp.o: pnglibconf.h
+
+# We must use -DPNG_NO_USE_READ_MACROS here even when the library may actually
+# be built with PNG_USE_READ_MACROS; this prevents the read macros from
+# interfering with the symbol file format.
+SYMBOL_CFLAGS = -DPNGLIB_LIBNAME='PNG@PNGLIB_MAJOR@@PNGLIB_MINOR@_0'\
+		-DPNGLIB_VERSION='@PNGLIB_VERSION@'\
+		-DSYMBOL_PREFIX='$(SYMBOL_PREFIX)'\
+		-DPNG_NO_USE_READ_MACROS -DPNG_BUILDING_SYMBOL_TABLE
+
+if DO_PNG_PREFIX
+SYMBOL_CFLAGS += -DPNG_PREFIX='@PNG_PREFIX@'
+endif
+
+.c.out:
+	rm -f $@ $*.tf[12]
+	test -d scripts || mkdir scripts || test -d scripts
+	$(DFNCPP) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES)\
+	    $(CPPFLAGS) $(SYMBOL_CFLAGS) $< > $*.tf1
+	$(AWK) -f "${srcdir}/scripts/dfn.awk" out="$*.tf2" $*.tf1 1>&2
+	rm -f $*.tf1
+	mv $*.tf2 $@
+
+# The .c file for pnglibconf.h is machine generated
+pnglibconf.c: scripts/pnglibconf.dfa scripts/options.awk pngconf.h pngusr.dfa $(DFA_XTRA)
+	rm -f $@ $*.tf[45]
+	$(AWK) -f ${srcdir}/scripts/options.awk out=$*.tf4 version=search\
+	    ${srcdir}/pngconf.h ${srcdir}/scripts/pnglibconf.dfa\
+	    ${srcdir}/pngusr.dfa $(DFA_XTRA) 1>&2
+	$(AWK) -f ${srcdir}/scripts/options.awk out=$*.tf5 $*.tf4 1>&2
+	rm $*.tf4
+	mv $*.tf5 $@
+
+# Symbol checks (.def and .out files should match)
+scripts/symbols.chk: scripts/checksym.awk scripts/symbols.def scripts/symbols.out
+
+.out.chk:
+	rm -f $@ $*.new
+	$(AWK) -f ${srcdir}/scripts/checksym.awk ${srcdir}/scripts/${*F}.def\
+	    of="$*.new" $< >&2
+	mv $*.new $@
+
+# used on demand to regenerate the standard header, CPPFLAGS should
+# be empty - no non-standard defines
+scripts/pnglibconf.c: scripts/pnglibconf.dfa scripts/options.awk pngconf.h
+	rm -f $@ pnglibconf.tf[67]
+	test -z "$(CPPFLAGS)"
+	echo "com @PNGLIB_VERSION@ STANDARD API DEFINITION" |\
+	$(AWK) -f ${srcdir}/scripts/options.awk out=pnglibconf.tf6\
+	    logunsupported=1 version=search ${srcdir}/pngconf.h -\
+	    ${srcdir}/scripts/pnglibconf.dfa 1>&2
+	$(AWK) -f ${srcdir}/scripts/options.awk out=pnglibconf.tf7\
+	    pnglibconf.tf6 1>&2
+	rm pnglibconf.tf6
+	mv pnglibconf.tf7 $@
+
+$(libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_OBJECTS): png.h pngconf.h \
+	pnglibconf.h pngpriv.h pngdebug.h pnginfo.h pngstruct.h pngprefix.h
+
+test: check-am
+
+# Extra checks
+check: scripts/symbols.chk
+
+# Don't distribute the generated script files
+dist-hook:
+	cd '$(top_distdir)'; rm -f $(SCRIPT_CLEANFILES)
+
+# Make links between installed files with release-specific names and the generic
+# file names.  If this install rule is run the generic names will be deleted and
+# recreated - this has obvious issues for systems with multiple installations.
+
+install-header-links:
+	@set -ex; cd '$(DESTDIR)$(includedir)'; for f in $(HEADERS); do \
+	   rm -f "$$f"; $(LN_S) "$(PNGLIB_BASENAME)/$$f" "$$f"; done
+
+uninstall-header-links:
+	cd '$(DESTDIR)$(includedir)'; rm -f $(HEADERS)
+
+install-libpng-pc:
+	@set -ex; cd '$(DESTDIR)$(pkgconfigdir)'; rm -f libpng.pc; \
+	   $(LN_S) '$(PNGLIB_BASENAME).pc' libpng.pc
+
+uninstall-libpng-pc:
+	rm -f '$(DESTDIR)$(pkgconfigdir)/libpng.pc'
+
+# EXT_LIST is a list of the possibly library directory extensions, this exists
+# because we can't find a good way of discovering the file extensions that are
+# actually installed on a given system, so instead we check for every extension
+# we have seen.
+
+EXT_LIST = a dll.a so so.@PNGLIB_MAJOR@@PNGLIB_MINOR@.@PNGLIB_RELEASE@ la sl dylib
+
+install-library-links:
+	@set -x; cd '$(DESTDIR)$(libdir)';\
+	for ext in $(EXT_LIST); do\
+	   rm -f "libpng.$$ext";\
+           if test -f "$(PNGLIB_BASENAME).$$ext"; then\
+              $(LN_S) "$(PNGLIB_BASENAME).$$ext" "libpng.$$ext" || exit 1;\
+           fi;\
+	done
+
+uninstall-library-links:
+	@set -x; cd '$(DESTDIR)$(libdir)'; for ext in $(EXT_LIST); do\
+	   rm -f "libpng.$$ext"; done
+
+install-libpng-config:
+	@set -ex; cd '$(DESTDIR)$(bindir)'; rm -f libpng-config; \
+	   $(LN_S) '$(PNGLIB_BASENAME)-config' libpng-config
+
+uninstall-libpng-config:
+	rm -f '$(DESTDIR)$(bindir)/libpng-config'
+
+if DO_INSTALL_LINKS
+# If --enable-unversioned-links is specified the header and lib file links
+# will be automatically made on a 'make install':
+
+install-data-hook: install-header-links
+uninstall-hook: uninstall-header-links
+install-exec-hook: install-library-links
+uninstall-hook: uninstall-library-links
+endif
+
+if DO_INSTALL_LIBPNG_PC
+# Likewise, --install-pc causes libpng.pc to be constructed:
+
+install-data-hook: install-libpng-pc
+uninstall-hook: uninstall-libpng-pc
+endif
+
+if DO_INSTALL_LIBPNG_CONFIG
+# And --install-config:
+
+install-exec-hook: install-libpng-config
+uninstall-hook: uninstall-libpng-config
+endif
+
+# The following addition ensures that 'make all' always builds the test programs
+# too.  It used to, but some change either in libpng or configure stopped this
+# working.
+all-am: $(check_PROGRAMS)
diff --git a/Engine/lib/lpng/Makefile.in b/Engine/lib/lpng/Makefile.in
new file mode 100644
index 000000000..81ac1c855
--- /dev/null
+++ b/Engine/lib/lpng/Makefile.in
@@ -0,0 +1,2428 @@
+# Makefile.in generated by automake 1.16.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2018 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+# Makefile.am, the source file for Makefile.in (and hence Makefile), is
+#
+# Copyright (c) 2018 Cosmin Truta
+# Copyright (c) 2004-2016 Glenn Randers-Pehrson
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+
+
+
+
+VPATH = @srcdir@
+am__is_gnu_make = { \
+  if test -z '$(MAKELEVEL)'; then \
+    false; \
+  elif test -n '$(MAKE_HOST)'; then \
+    true; \
+  elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
+    true; \
+  else \
+    false; \
+  fi; \
+}
+am__make_running_with_option = \
+  case $${target_option-} in \
+      ?) ;; \
+      *) echo "am__make_running_with_option: internal error: invalid" \
+              "target option '$${target_option-}' specified" >&2; \
+         exit 1;; \
+  esac; \
+  has_opt=no; \
+  sane_makeflags=$$MAKEFLAGS; \
+  if $(am__is_gnu_make); then \
+    sane_makeflags=$$MFLAGS; \
+  else \
+    case $$MAKEFLAGS in \
+      *\\[\ \	]*) \
+        bs=\\; \
+        sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+          | sed "s/$$bs$$bs[$$bs $$bs	]*//g"`;; \
+    esac; \
+  fi; \
+  skip_next=no; \
+  strip_trailopt () \
+  { \
+    flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+  }; \
+  for flg in $$sane_makeflags; do \
+    test $$skip_next = yes && { skip_next=no; continue; }; \
+    case $$flg in \
+      *=*|--*) continue;; \
+        -*I) strip_trailopt 'I'; skip_next=yes;; \
+      -*I?*) strip_trailopt 'I';; \
+        -*O) strip_trailopt 'O'; skip_next=yes;; \
+      -*O?*) strip_trailopt 'O';; \
+        -*l) strip_trailopt 'l'; skip_next=yes;; \
+      -*l?*) strip_trailopt 'l';; \
+      -[dEDm]) skip_next=yes;; \
+      -[JT]) skip_next=yes;; \
+    esac; \
+    case $$flg in \
+      *$$target_option*) has_opt=yes; break;; \
+    esac; \
+  done; \
+  test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+check_PROGRAMS = pngtest$(EXEEXT) pngunknown$(EXEEXT) \
+	pngstest$(EXEEXT) pngvalid$(EXEEXT) pngimage$(EXEEXT) \
+	pngcp$(EXEEXT) $(am__EXEEXT_1)
+@HAVE_CLOCK_GETTIME_TRUE@am__append_1 = timepng
+bin_PROGRAMS = pngfix$(EXEEXT) png-fix-itxt$(EXEEXT)
+@PNG_ARM_NEON_TRUE@am__append_2 = arm/arm_init.c\
+@PNG_ARM_NEON_TRUE@	arm/filter_neon.S arm/filter_neon_intrinsics.c \
+@PNG_ARM_NEON_TRUE@	arm/palette_neon_intrinsics.c
+
+@PNG_MIPS_MSA_TRUE@am__append_3 = mips/mips_init.c\
+@PNG_MIPS_MSA_TRUE@	mips/filter_msa_intrinsics.c
+
+@PNG_INTEL_SSE_TRUE@am__append_4 = intel/intel_init.c\
+@PNG_INTEL_SSE_TRUE@	intel/filter_sse2_intrinsics.c
+
+@PNG_POWERPC_VSX_TRUE@am__append_5 = powerpc/powerpc_init.c\
+@PNG_POWERPC_VSX_TRUE@        powerpc/filter_vsx_intrinsics.c
+
+
+#   Versioned symbols and restricted exports
+@HAVE_LD_VERSION_SCRIPT_TRUE@@HAVE_SOLARIS_LD_TRUE@am__append_6 = -Wl,-M -Wl,libpng.vers
+@HAVE_LD_VERSION_SCRIPT_TRUE@@HAVE_SOLARIS_LD_FALSE@am__append_7 = -Wl,--version-script=libpng.vers
+#   Only restricted exports when possible
+@HAVE_LD_VERSION_SCRIPT_FALSE@am__append_8 = -export-symbols libpng.sym
+@DO_PNG_PREFIX_TRUE@am__append_9 = -DPNG_PREFIX='@PNG_PREFIX@'
+subdir = .
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/scripts/libtool.m4 \
+	$(top_srcdir)/scripts/ltoptions.m4 \
+	$(top_srcdir)/scripts/ltsugar.m4 \
+	$(top_srcdir)/scripts/ltversion.m4 \
+	$(top_srcdir)/scripts/lt~obsolete.m4 \
+	$(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+DIST_COMMON = $(srcdir)/Makefile.am $(top_srcdir)/configure \
+	$(am__configure_deps) $(pkginclude_HEADERS) $(am__DIST_COMMON)
+am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \
+ configure.lineno config.status.lineno
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = config.h
+CONFIG_CLEAN_FILES = libpng.pc libpng-config
+CONFIG_CLEAN_VPATH_FILES =
+am__installdirs = "$(DESTDIR)$(bindir)" "$(DESTDIR)$(libdir)" \
+	"$(DESTDIR)$(bindir)" "$(DESTDIR)$(man3dir)" \
+	"$(DESTDIR)$(man5dir)" "$(DESTDIR)$(pkgconfigdir)" \
+	"$(DESTDIR)$(pkgincludedir)" "$(DESTDIR)$(pkgincludedir)"
+@HAVE_CLOCK_GETTIME_TRUE@am__EXEEXT_1 = timepng$(EXEEXT)
+PROGRAMS = $(bin_PROGRAMS)
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+    *) f=$$p;; \
+  esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+  srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+  for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+  for p in $$list; do echo "$$p $$p"; done | \
+  sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+  $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+    if (++n[$$2] == $(am__install_max)) \
+      { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+    END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+  sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+  sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+  test -z "$$files" \
+    || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+    || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+         $(am__cd) "$$dir" && rm -f $$files; }; \
+  }
+LTLIBRARIES = $(lib_LTLIBRARIES)
+libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_LIBADD =
+am__libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES_DIST = png.c \
+	pngerror.c pngget.c pngmem.c pngpread.c pngread.c pngrio.c \
+	pngrtran.c pngrutil.c pngset.c pngtrans.c pngwio.c pngwrite.c \
+	pngwtran.c pngwutil.c png.h pngconf.h pngdebug.h pnginfo.h \
+	pngpriv.h pngstruct.h pngusr.dfa arm/arm_init.c \
+	arm/filter_neon.S arm/filter_neon_intrinsics.c \
+	arm/palette_neon_intrinsics.c mips/mips_init.c \
+	mips/filter_msa_intrinsics.c intel/intel_init.c \
+	intel/filter_sse2_intrinsics.c powerpc/powerpc_init.c \
+	powerpc/filter_vsx_intrinsics.c
+am__dirstamp = $(am__leading_dot)dirstamp
+@PNG_ARM_NEON_TRUE@am__objects_1 = arm/arm_init.lo arm/filter_neon.lo \
+@PNG_ARM_NEON_TRUE@	arm/filter_neon_intrinsics.lo \
+@PNG_ARM_NEON_TRUE@	arm/palette_neon_intrinsics.lo
+@PNG_MIPS_MSA_TRUE@am__objects_2 = mips/mips_init.lo \
+@PNG_MIPS_MSA_TRUE@	mips/filter_msa_intrinsics.lo
+@PNG_INTEL_SSE_TRUE@am__objects_3 = intel/intel_init.lo \
+@PNG_INTEL_SSE_TRUE@	intel/filter_sse2_intrinsics.lo
+@PNG_POWERPC_VSX_TRUE@am__objects_4 = powerpc/powerpc_init.lo \
+@PNG_POWERPC_VSX_TRUE@	powerpc/filter_vsx_intrinsics.lo
+am_libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_OBJECTS = png.lo pngerror.lo \
+	pngget.lo pngmem.lo pngpread.lo pngread.lo pngrio.lo \
+	pngrtran.lo pngrutil.lo pngset.lo pngtrans.lo pngwio.lo \
+	pngwrite.lo pngwtran.lo pngwutil.lo $(am__objects_1) \
+	$(am__objects_2) $(am__objects_3) $(am__objects_4)
+nodist_libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_OBJECTS =
+libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_OBJECTS =  \
+	$(am_libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_OBJECTS) \
+	$(nodist_libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_OBJECTS)
+AM_V_lt = $(am__v_lt_@AM_V@)
+am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
+am__v_lt_0 = --silent
+am__v_lt_1 = 
+libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_LINK = $(LIBTOOL) $(AM_V_lt) \
+	--tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link \
+	$(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_LDFLAGS) $(LDFLAGS) -o \
+	$@
+am_png_fix_itxt_OBJECTS = contrib/tools/png-fix-itxt.$(OBJEXT)
+png_fix_itxt_OBJECTS = $(am_png_fix_itxt_OBJECTS)
+png_fix_itxt_LDADD = $(LDADD)
+am_pngcp_OBJECTS = contrib/tools/pngcp.$(OBJEXT)
+pngcp_OBJECTS = $(am_pngcp_OBJECTS)
+pngcp_DEPENDENCIES = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
+am_pngfix_OBJECTS = contrib/tools/pngfix.$(OBJEXT)
+pngfix_OBJECTS = $(am_pngfix_OBJECTS)
+pngfix_DEPENDENCIES = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
+am_pngimage_OBJECTS = contrib/libtests/pngimage.$(OBJEXT)
+pngimage_OBJECTS = $(am_pngimage_OBJECTS)
+pngimage_DEPENDENCIES = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
+am_pngstest_OBJECTS = contrib/libtests/pngstest.$(OBJEXT)
+pngstest_OBJECTS = $(am_pngstest_OBJECTS)
+pngstest_DEPENDENCIES = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
+am_pngtest_OBJECTS = pngtest.$(OBJEXT)
+pngtest_OBJECTS = $(am_pngtest_OBJECTS)
+pngtest_DEPENDENCIES = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
+am_pngunknown_OBJECTS = contrib/libtests/pngunknown.$(OBJEXT)
+pngunknown_OBJECTS = $(am_pngunknown_OBJECTS)
+pngunknown_DEPENDENCIES = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
+am_pngvalid_OBJECTS = contrib/libtests/pngvalid.$(OBJEXT)
+pngvalid_OBJECTS = $(am_pngvalid_OBJECTS)
+pngvalid_DEPENDENCIES = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
+am_timepng_OBJECTS = contrib/libtests/timepng.$(OBJEXT)
+timepng_OBJECTS = $(am_timepng_OBJECTS)
+timepng_DEPENDENCIES = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
+SCRIPTS = $(bin_SCRIPTS)
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo "  GEN     " $@;
+am__v_GEN_1 = 
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 = 
+DEFAULT_INCLUDES = -I.@am__isrc@
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__maybe_remake_depfiles = depfiles
+am__depfiles_remade = ./$(DEPDIR)/png.Plo ./$(DEPDIR)/pngerror.Plo \
+	./$(DEPDIR)/pngget.Plo ./$(DEPDIR)/pngmem.Plo \
+	./$(DEPDIR)/pngpread.Plo ./$(DEPDIR)/pngread.Plo \
+	./$(DEPDIR)/pngrio.Plo ./$(DEPDIR)/pngrtran.Plo \
+	./$(DEPDIR)/pngrutil.Plo ./$(DEPDIR)/pngset.Plo \
+	./$(DEPDIR)/pngtest.Po ./$(DEPDIR)/pngtrans.Plo \
+	./$(DEPDIR)/pngwio.Plo ./$(DEPDIR)/pngwrite.Plo \
+	./$(DEPDIR)/pngwtran.Plo ./$(DEPDIR)/pngwutil.Plo \
+	arm/$(DEPDIR)/arm_init.Plo arm/$(DEPDIR)/filter_neon.Plo \
+	arm/$(DEPDIR)/filter_neon_intrinsics.Plo \
+	arm/$(DEPDIR)/palette_neon_intrinsics.Plo \
+	contrib/libtests/$(DEPDIR)/pngimage.Po \
+	contrib/libtests/$(DEPDIR)/pngstest.Po \
+	contrib/libtests/$(DEPDIR)/pngunknown.Po \
+	contrib/libtests/$(DEPDIR)/pngvalid.Po \
+	contrib/libtests/$(DEPDIR)/timepng.Po \
+	contrib/tools/$(DEPDIR)/png-fix-itxt.Po \
+	contrib/tools/$(DEPDIR)/pngcp.Po \
+	contrib/tools/$(DEPDIR)/pngfix.Po \
+	intel/$(DEPDIR)/filter_sse2_intrinsics.Plo \
+	intel/$(DEPDIR)/intel_init.Plo \
+	mips/$(DEPDIR)/filter_msa_intrinsics.Plo \
+	mips/$(DEPDIR)/mips_init.Plo \
+	powerpc/$(DEPDIR)/filter_vsx_intrinsics.Plo \
+	powerpc/$(DEPDIR)/powerpc_init.Plo
+am__mv = mv -f
+CPPASCOMPILE = $(CCAS) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CCASFLAGS) $(CCASFLAGS)
+LTCPPASCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=compile $(CCAS) $(DEFS) \
+	$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+	$(AM_CCASFLAGS) $(CCASFLAGS)
+AM_V_CPPAS = $(am__v_CPPAS_@AM_V@)
+am__v_CPPAS_ = $(am__v_CPPAS_@AM_DEFAULT_V@)
+am__v_CPPAS_0 = @echo "  CPPAS   " $@;
+am__v_CPPAS_1 = 
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \
+	$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+	$(AM_CFLAGS) $(CFLAGS)
+AM_V_CC = $(am__v_CC_@AM_V@)
+am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
+am__v_CC_0 = @echo "  CC      " $@;
+am__v_CC_1 = 
+CCLD = $(CC)
+LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CCLD = $(am__v_CCLD_@AM_V@)
+am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
+am__v_CCLD_0 = @echo "  CCLD    " $@;
+am__v_CCLD_1 = 
+SOURCES = $(libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES) \
+	$(nodist_libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES) \
+	$(png_fix_itxt_SOURCES) $(pngcp_SOURCES) $(pngfix_SOURCES) \
+	$(pngimage_SOURCES) $(pngstest_SOURCES) $(pngtest_SOURCES) \
+	$(pngunknown_SOURCES) $(pngvalid_SOURCES) $(timepng_SOURCES)
+DIST_SOURCES =  \
+	$(am__libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES_DIST) \
+	$(png_fix_itxt_SOURCES) $(pngcp_SOURCES) $(pngfix_SOURCES) \
+	$(pngimage_SOURCES) $(pngstest_SOURCES) $(pngtest_SOURCES) \
+	$(pngunknown_SOURCES) $(pngvalid_SOURCES) $(timepng_SOURCES)
+am__can_run_installinfo = \
+  case $$AM_UPDATE_INFO_DIR in \
+    n|no|NO) false;; \
+    *) (install-info --version) >/dev/null 2>&1;; \
+  esac
+man3dir = $(mandir)/man3
+man5dir = $(mandir)/man5
+NROFF = nroff
+MANS = $(dist_man_MANS)
+DATA = $(pkgconfig_DATA)
+HEADERS = $(nodist_pkginclude_HEADERS) $(pkginclude_HEADERS)
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) \
+	$(LISP)config.h.in
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates.  Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+  BEGIN { nonempty = 0; } \
+  { items[$$0] = 1; nonempty = 1; } \
+  END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique.  This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+  list='$(am__tagged_files)'; \
+  unique=`for i in $$list; do \
+    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+  done | $(am__uniquify_input)`
+ETAGS = etags
+CTAGS = ctags
+CSCOPE = cscope
+AM_RECURSIVE_TARGETS = cscope check recheck
+am__tty_colors_dummy = \
+  mgn= red= grn= lgn= blu= brg= std=; \
+  am__color_tests=no
+am__tty_colors = { \
+  $(am__tty_colors_dummy); \
+  if test "X$(AM_COLOR_TESTS)" = Xno; then \
+    am__color_tests=no; \
+  elif test "X$(AM_COLOR_TESTS)" = Xalways; then \
+    am__color_tests=yes; \
+  elif test "X$$TERM" != Xdumb && { test -t 1; } 2>/dev/null; then \
+    am__color_tests=yes; \
+  fi; \
+  if test $$am__color_tests = yes; then \
+    red=''; \
+    grn=''; \
+    lgn=''; \
+    blu=''; \
+    mgn=''; \
+    brg=''; \
+    std=''; \
+  fi; \
+}
+am__recheck_rx = ^[ 	]*:recheck:[ 	]*
+am__global_test_result_rx = ^[ 	]*:global-test-result:[ 	]*
+am__copy_in_global_log_rx = ^[ 	]*:copy-in-global-log:[ 	]*
+# A command that, given a newline-separated list of test names on the
+# standard input, print the name of the tests that are to be re-run
+# upon "make recheck".
+am__list_recheck_tests = $(AWK) '{ \
+  recheck = 1; \
+  while ((rc = (getline line < ($$0 ".trs"))) != 0) \
+    { \
+      if (rc < 0) \
+        { \
+          if ((getline line2 < ($$0 ".log")) < 0) \
+	    recheck = 0; \
+          break; \
+        } \
+      else if (line ~ /$(am__recheck_rx)[nN][Oo]/) \
+        { \
+          recheck = 0; \
+          break; \
+        } \
+      else if (line ~ /$(am__recheck_rx)[yY][eE][sS]/) \
+        { \
+          break; \
+        } \
+    }; \
+  if (recheck) \
+    print $$0; \
+  close ($$0 ".trs"); \
+  close ($$0 ".log"); \
+}'
+# A command that, given a newline-separated list of test names on the
+# standard input, create the global log from their .trs and .log files.
+am__create_global_log = $(AWK) ' \
+function fatal(msg) \
+{ \
+  print "fatal: making $@: " msg | "cat >&2"; \
+  exit 1; \
+} \
+function rst_section(header) \
+{ \
+  print header; \
+  len = length(header); \
+  for (i = 1; i <= len; i = i + 1) \
+    printf "="; \
+  printf "\n\n"; \
+} \
+{ \
+  copy_in_global_log = 1; \
+  global_test_result = "RUN"; \
+  while ((rc = (getline line < ($$0 ".trs"))) != 0) \
+    { \
+      if (rc < 0) \
+         fatal("failed to read from " $$0 ".trs"); \
+      if (line ~ /$(am__global_test_result_rx)/) \
+        { \
+          sub("$(am__global_test_result_rx)", "", line); \
+          sub("[ 	]*$$", "", line); \
+          global_test_result = line; \
+        } \
+      else if (line ~ /$(am__copy_in_global_log_rx)[nN][oO]/) \
+        copy_in_global_log = 0; \
+    }; \
+  if (copy_in_global_log) \
+    { \
+      rst_section(global_test_result ": " $$0); \
+      while ((rc = (getline line < ($$0 ".log"))) != 0) \
+      { \
+        if (rc < 0) \
+          fatal("failed to read from " $$0 ".log"); \
+        print line; \
+      }; \
+      printf "\n"; \
+    }; \
+  close ($$0 ".trs"); \
+  close ($$0 ".log"); \
+}'
+# Restructured Text title.
+am__rst_title = { sed 's/.*/   &   /;h;s/./=/g;p;x;s/ *$$//;p;g' && echo; }
+# Solaris 10 'make', and several other traditional 'make' implementations,
+# pass "-e" to $(SHELL), and POSIX 2008 even requires this.  Work around it
+# by disabling -e (using the XSI extension "set +e") if it's set.
+am__sh_e_setup = case $$- in *e*) set +e;; esac
+# Default flags passed to test drivers.
+am__common_driver_flags = \
+  --color-tests "$$am__color_tests" \
+  --enable-hard-errors "$$am__enable_hard_errors" \
+  --expect-failure "$$am__expect_failure"
+# To be inserted before the command running the test.  Creates the
+# directory for the log if needed.  Stores in $dir the directory
+# containing $f, in $tst the test, in $log the log.  Executes the
+# developer- defined test setup AM_TESTS_ENVIRONMENT (if any), and
+# passes TESTS_ENVIRONMENT.  Set up options for the wrapper that
+# will run the test scripts (or their associated LOG_COMPILER, if
+# thy have one).
+am__check_pre = \
+$(am__sh_e_setup);					\
+$(am__vpath_adj_setup) $(am__vpath_adj)			\
+$(am__tty_colors);					\
+srcdir=$(srcdir); export srcdir;			\
+case "$@" in						\
+  */*) am__odir=`echo "./$@" | sed 's|/[^/]*$$||'`;;	\
+    *) am__odir=.;; 					\
+esac;							\
+test "x$$am__odir" = x"." || test -d "$$am__odir" 	\
+  || $(MKDIR_P) "$$am__odir" || exit $$?;		\
+if test -f "./$$f"; then dir=./;			\
+elif test -f "$$f"; then dir=;				\
+else dir="$(srcdir)/"; fi;				\
+tst=$$dir$$f; log='$@'; 				\
+if test -n '$(DISABLE_HARD_ERRORS)'; then		\
+  am__enable_hard_errors=no; 				\
+else							\
+  am__enable_hard_errors=yes; 				\
+fi; 							\
+case " $(XFAIL_TESTS) " in				\
+  *[\ \	]$$f[\ \	]* | *[\ \	]$$dir$$f[\ \	]*) \
+    am__expect_failure=yes;;				\
+  *)							\
+    am__expect_failure=no;;				\
+esac; 							\
+$(AM_TESTS_ENVIRONMENT) $(TESTS_ENVIRONMENT)
+# A shell command to get the names of the tests scripts with any registered
+# extension removed (i.e., equivalently, the names of the test logs, with
+# the '.log' extension removed).  The result is saved in the shell variable
+# '$bases'.  This honors runtime overriding of TESTS and TEST_LOGS.  Sadly,
+# we cannot use something simpler, involving e.g., "$(TEST_LOGS:.log=)",
+# since that might cause problem with VPATH rewrites for suffix-less tests.
+# See also 'test-harness-vpath-rewrite.sh' and 'test-trs-basic.sh'.
+am__set_TESTS_bases = \
+  bases='$(TEST_LOGS)'; \
+  bases=`for i in $$bases; do echo $$i; done | sed 's/\.log$$//'`; \
+  bases=`echo $$bases`
+RECHECK_LOGS = $(TEST_LOGS)
+TEST_SUITE_LOG = test-suite.log
+TEST_EXTENSIONS = @EXEEXT@ .test
+LOG_DRIVER = $(SHELL) $(top_srcdir)/test-driver
+LOG_COMPILE = $(LOG_COMPILER) $(AM_LOG_FLAGS) $(LOG_FLAGS)
+am__set_b = \
+  case '$@' in \
+    */*) \
+      case '$*' in \
+        */*) b='$*';; \
+          *) b=`echo '$@' | sed 's/\.log$$//'`; \
+       esac;; \
+    *) \
+      b='$*';; \
+  esac
+am__test_logs1 = $(TESTS:=.log)
+am__test_logs2 = $(am__test_logs1:@EXEEXT@.log=.log)
+TEST_LOGS = $(am__test_logs2:.test.log=.log)
+TEST_LOG_DRIVER = $(SHELL) $(top_srcdir)/test-driver
+TEST_LOG_COMPILE = $(TEST_LOG_COMPILER) $(AM_TEST_LOG_FLAGS) \
+	$(TEST_LOG_FLAGS)
+am__DIST_COMMON = $(dist_man_MANS) $(srcdir)/Makefile.in \
+	$(srcdir)/config.h.in $(srcdir)/libpng-config.in \
+	$(srcdir)/libpng.pc.in AUTHORS INSTALL README TODO compile \
+	config.guess config.sub depcomp install-sh ltmain.sh missing \
+	test-driver
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+distdir = $(PACKAGE)-$(VERSION)
+top_distdir = $(distdir)
+am__remove_distdir = \
+  if test -d "$(distdir)"; then \
+    find "$(distdir)" -type d ! -perm -200 -exec chmod u+w {} ';' \
+      && rm -rf "$(distdir)" \
+      || { sleep 5 && rm -rf "$(distdir)"; }; \
+  else :; fi
+am__post_remove_distdir = $(am__remove_distdir)
+DIST_ARCHIVES = $(distdir).tar.gz $(distdir).tar.xz
+GZIP_ENV = --best
+DIST_TARGETS = dist-xz dist-gzip
+distuninstallcheck_listfiles = find . -type f -print
+am__distuninstallcheck_listfiles = $(distuninstallcheck_listfiles) \
+  | sed 's|^\./|$(prefix)/|' | grep -v '$(infodir)/dir$$'
+distcleancheck_listfiles = find . -type f -print
+
+#distribute headers in /usr/include/libpng/*
+pkgincludedir = $(includedir)/$(PNGLIB_BASENAME)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AS = @AS@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCAS = @CCAS@
+CCASDEPMODE = @CCASDEPMODE@
+CCASFLAGS = @CCASFLAGS@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+
+# DFNCPP is normally just CPP - the C preprocessor - but on Solaris and maybe
+# other operating systems (NeXT?) the C preprocessor selected by configure
+# checks input tokens for validity - effectively it performs part of the ANSI-C
+# parsing - and therefore fails with the .df files.  configure.ac has special
+# checks for this and sets DFNCPP appropriately.
+DFNCPP = @DFNCPP@
+DLLTOOL = @DLLTOOL@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
+MAINT = @MAINT@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PNGLIB_MAJOR = @PNGLIB_MAJOR@
+PNGLIB_MINOR = @PNGLIB_MINOR@
+PNGLIB_RELEASE = @PNGLIB_RELEASE@
+PNGLIB_VERSION = @PNGLIB_VERSION@
+
+# PNG_COPTS give extra options for the C compiler to be used on all compilation
+# steps (unless targe_CFLAGS is specified; that will take precedence over
+# AM_CFLAGS)
+PNG_COPTS = @PNG_COPTS@
+PNG_PREFIX = @PNG_PREFIX@
+POW_LIB = @POW_LIB@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+SYMBOL_PREFIX = @SYMBOL_PREFIX@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+
+# generate the -config scripts if required
+binconfigs = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@-config
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+
+# pkg-config stuff, note that libpng.pc is always required in order
+# to get the correct library
+pkgconfigdir = @pkgconfigdir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+PNGLIB_BASENAME = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@
+ACLOCAL_AMFLAGS = -I scripts
+
+# This ensures that pnglibconf.h gets built at the start of 'make all' or
+# 'make check', but it does not add dependencies to the individual programs,
+# this is done below.
+#
+# IMPORTANT: always add the object modules of new programs to the list below
+# because otherwise the sequence 'configure; make new-program' will *sometimes*
+# result in the installed (system) pnglibconf.h being used and the result is
+# always wrong and always very confusing.
+BUILT_SOURCES = pnglibconf.h
+pngtest_SOURCES = pngtest.c
+pngtest_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
+pngvalid_SOURCES = contrib/libtests/pngvalid.c
+pngvalid_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
+pngstest_SOURCES = contrib/libtests/pngstest.c
+pngstest_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
+pngunknown_SOURCES = contrib/libtests/pngunknown.c
+pngunknown_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
+pngimage_SOURCES = contrib/libtests/pngimage.c
+pngimage_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
+timepng_SOURCES = contrib/libtests/timepng.c
+timepng_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
+pngfix_SOURCES = contrib/tools/pngfix.c
+pngfix_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
+png_fix_itxt_SOURCES = contrib/tools/png-fix-itxt.c
+pngcp_SOURCES = contrib/tools/pngcp.c
+pngcp_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
+
+# Generally these are single line shell scripts to run a test with a particular
+# set of parameters:
+TESTS = \
+   tests/pngtest\
+   tests/pngtest-badpngs\
+   tests/pngvalid-gamma-16-to-8 tests/pngvalid-gamma-alpha-mode\
+   tests/pngvalid-gamma-background tests/pngvalid-gamma-expand16-alpha-mode\
+   tests/pngvalid-gamma-expand16-background\
+   tests/pngvalid-gamma-expand16-transform tests/pngvalid-gamma-sbit\
+   tests/pngvalid-gamma-threshold tests/pngvalid-gamma-transform\
+   tests/pngvalid-progressive-size\
+   tests/pngvalid-progressive-interlace-standard\
+   tests/pngvalid-transform\
+   tests/pngvalid-progressive-standard tests/pngvalid-standard\
+   tests/pngstest-1.8 tests/pngstest-1.8-alpha tests/pngstest-linear\
+   tests/pngstest-linear-alpha tests/pngstest-none tests/pngstest-none-alpha\
+   tests/pngstest-sRGB tests/pngstest-sRGB-alpha tests/pngunknown-IDAT\
+   tests/pngunknown-discard tests/pngunknown-if-safe tests/pngunknown-sAPI\
+   tests/pngunknown-sTER tests/pngunknown-save tests/pngunknown-vpAg\
+   tests/pngimage-quick tests/pngimage-full
+
+
+# man pages
+dist_man_MANS = libpng.3 libpngpf.3 png.5
+EXTRA_SCRIPTS = libpng-config libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@-config
+bin_SCRIPTS = @binconfigs@
+
+# rules to build libpng, only build the old library on request
+lib_LTLIBRARIES = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
+# EXTRA_LTLIBRARIES= libpng.la
+libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES = png.c pngerror.c \
+	pngget.c pngmem.c pngpread.c pngread.c pngrio.c pngrtran.c \
+	pngrutil.c pngset.c pngtrans.c pngwio.c pngwrite.c pngwtran.c \
+	pngwutil.c png.h pngconf.h pngdebug.h pnginfo.h pngpriv.h \
+	pngstruct.h pngusr.dfa $(am__append_2) $(am__append_3) \
+	$(am__append_4) $(am__append_5)
+nodist_libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES = pnglibconf.h
+libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_LDFLAGS = -no-undefined \
+	-export-dynamic -version-number \
+	@PNGLIB_MAJOR@@PNGLIB_MINOR@:@PNGLIB_RELEASE@:0 \
+	$(am__append_6) $(am__append_7) $(am__append_8)
+@HAVE_LD_VERSION_SCRIPT_FALSE@libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_DEPENDENCIES = libpng.sym
+@HAVE_LD_VERSION_SCRIPT_TRUE@libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_DEPENDENCIES = libpng.vers
+pkginclude_HEADERS = png.h pngconf.h
+nodist_pkginclude_HEADERS = pnglibconf.h
+pkgconfig_DATA = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.pc
+
+# Extra source distribution files, '${srcdir}' is used below to stop build files
+# from those directories being included.  This only works if the configure is
+# not done in the source directory!
+EXTRA_DIST = \
+	ANNOUNCE AUTHORS CHANGES INSTALL LICENSE README TODO TRADEMARK \
+	pngtest.png pngbar.png pngnow.png pngbar.jpg autogen.sh \
+	${srcdir}/contrib ${srcdir}/projects ${srcdir}/scripts \
+	$(TESTS) $(XFAIL_TESTS) tests/pngstest \
+	CMakeLists.txt example.c libpng-manual.txt
+
+SCRIPT_CLEANFILES = scripts/*.out scripts/*.chk
+CLEANFILES = *.tf? pngout.png libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.pc \
+	libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@-config libpng.vers libpng.sym \
+	check.new pnglibconf.h pngprefix.h symbols.new pngtest-log.txt \
+	pnglibconf.out pnglibconf.c pnglibconf.pre pnglibconf.dfn \
+	$(SCRIPT_CLEANFILES)
+
+MAINTAINERCLEANFILES = Makefile.in aclocal.m4 config.guess config.h.in \
+config.sub configure depcomp install-sh ltmain.sh missing
+
+AM_CFLAGS = ${PNG_COPTS}
+SUFFIXES = .chk .out
+
+# We must use -DPNG_NO_USE_READ_MACROS here even when the library may actually
+# be built with PNG_USE_READ_MACROS; this prevents the read macros from
+# interfering with the symbol file format.
+SYMBOL_CFLAGS = -DPNGLIB_LIBNAME='PNG@PNGLIB_MAJOR@@PNGLIB_MINOR@_0' \
+	-DPNGLIB_VERSION='@PNGLIB_VERSION@' \
+	-DSYMBOL_PREFIX='$(SYMBOL_PREFIX)' -DPNG_NO_USE_READ_MACROS \
+	-DPNG_BUILDING_SYMBOL_TABLE $(am__append_9)
+
+# EXT_LIST is a list of the possibly library directory extensions, this exists
+# because we can't find a good way of discovering the file extensions that are
+# actually installed on a given system, so instead we check for every extension
+# we have seen.
+EXT_LIST = a dll.a so so.@PNGLIB_MAJOR@@PNGLIB_MINOR@.@PNGLIB_RELEASE@ la sl dylib
+all: $(BUILT_SOURCES) config.h
+	$(MAKE) $(AM_MAKEFLAGS) all-am
+
+.SUFFIXES:
+.SUFFIXES: .chk .out .S .c .lo .log .o .obj .test .test$(EXEEXT) .trs
+am--refresh: Makefile
+	@:
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am  $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      echo ' cd $(srcdir) && $(AUTOMAKE) --foreign'; \
+	      $(am__cd) $(srcdir) && $(AUTOMAKE) --foreign \
+		&& exit 0; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign Makefile'; \
+	$(am__cd) $(top_srcdir) && \
+	  $(AUTOMAKE) --foreign Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    echo ' $(SHELL) ./config.status'; \
+	    $(SHELL) ./config.status;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__maybe_remake_depfiles)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__maybe_remake_depfiles);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	$(SHELL) ./config.status --recheck
+
+$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
+	$(am__cd) $(srcdir) && $(AUTOCONF)
+$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
+	$(am__cd) $(srcdir) && $(ACLOCAL) $(ACLOCAL_AMFLAGS)
+$(am__aclocal_m4_deps):
+
+config.h: stamp-h1
+	@test -f $@ || rm -f stamp-h1
+	@test -f $@ || $(MAKE) $(AM_MAKEFLAGS) stamp-h1
+
+stamp-h1: $(srcdir)/config.h.in $(top_builddir)/config.status
+	@rm -f stamp-h1
+	cd $(top_builddir) && $(SHELL) ./config.status config.h
+$(srcdir)/config.h.in: @MAINTAINER_MODE_TRUE@ $(am__configure_deps) 
+	($(am__cd) $(top_srcdir) && $(AUTOHEADER))
+	rm -f stamp-h1
+	touch $@
+
+distclean-hdr:
+	-rm -f config.h stamp-h1
+libpng.pc: $(top_builddir)/config.status $(srcdir)/libpng.pc.in
+	cd $(top_builddir) && $(SHELL) ./config.status $@
+libpng-config: $(top_builddir)/config.status $(srcdir)/libpng-config.in
+	cd $(top_builddir) && $(SHELL) ./config.status $@
+install-binPROGRAMS: $(bin_PROGRAMS)
+	@$(NORMAL_INSTALL)
+	@list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
+	if test -n "$$list"; then \
+	  echo " $(MKDIR_P) '$(DESTDIR)$(bindir)'"; \
+	  $(MKDIR_P) "$(DESTDIR)$(bindir)" || exit 1; \
+	fi; \
+	for p in $$list; do echo "$$p $$p"; done | \
+	sed 's/$(EXEEXT)$$//' | \
+	while read p p1; do if test -f $$p \
+	 || test -f $$p1 \
+	  ; then echo "$$p"; echo "$$p"; else :; fi; \
+	done | \
+	sed -e 'p;s,.*/,,;n;h' \
+	    -e 's|.*|.|' \
+	    -e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \
+	sed 'N;N;N;s,\n, ,g' | \
+	$(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \
+	  { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \
+	    if ($$2 == $$4) files[d] = files[d] " " $$1; \
+	    else { print "f", $$3 "/" $$4, $$1; } } \
+	  END { for (d in files) print "f", d, files[d] }' | \
+	while read type dir files; do \
+	    if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \
+	    test -z "$$files" || { \
+	    echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \
+	    $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \
+	    } \
+	; done
+
+uninstall-binPROGRAMS:
+	@$(NORMAL_UNINSTALL)
+	@list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
+	files=`for p in $$list; do echo "$$p"; done | \
+	  sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \
+	      -e 's/$$/$(EXEEXT)/' \
+	`; \
+	test -n "$$list" || exit 0; \
+	echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \
+	cd "$(DESTDIR)$(bindir)" && rm -f $$files
+
+clean-binPROGRAMS:
+	@list='$(bin_PROGRAMS)'; test -n "$$list" || exit 0; \
+	echo " rm -f" $$list; \
+	rm -f $$list || exit $$?; \
+	test -n "$(EXEEXT)" || exit 0; \
+	list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
+	echo " rm -f" $$list; \
+	rm -f $$list
+
+clean-checkPROGRAMS:
+	@list='$(check_PROGRAMS)'; test -n "$$list" || exit 0; \
+	echo " rm -f" $$list; \
+	rm -f $$list || exit $$?; \
+	test -n "$(EXEEXT)" || exit 0; \
+	list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
+	echo " rm -f" $$list; \
+	rm -f $$list
+
+install-libLTLIBRARIES: $(lib_LTLIBRARIES)
+	@$(NORMAL_INSTALL)
+	@list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+	list2=; for p in $$list; do \
+	  if test -f $$p; then \
+	    list2="$$list2 $$p"; \
+	  else :; fi; \
+	done; \
+	test -z "$$list2" || { \
+	  echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \
+	  $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \
+	  echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \
+	  $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \
+	}
+
+uninstall-libLTLIBRARIES:
+	@$(NORMAL_UNINSTALL)
+	@list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+	for p in $$list; do \
+	  $(am__strip_dir) \
+	  echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \
+	  $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \
+	done
+
+clean-libLTLIBRARIES:
+	-test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES)
+	@list='$(lib_LTLIBRARIES)'; \
+	locs=`for p in $$list; do echo $$p; done | \
+	      sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
+	      sort -u`; \
+	test -z "$$locs" || { \
+	  echo rm -f $${locs}; \
+	  rm -f $${locs}; \
+	}
+arm/$(am__dirstamp):
+	@$(MKDIR_P) arm
+	@: > arm/$(am__dirstamp)
+arm/$(DEPDIR)/$(am__dirstamp):
+	@$(MKDIR_P) arm/$(DEPDIR)
+	@: > arm/$(DEPDIR)/$(am__dirstamp)
+arm/arm_init.lo: arm/$(am__dirstamp) arm/$(DEPDIR)/$(am__dirstamp)
+arm/filter_neon.lo: arm/$(am__dirstamp) arm/$(DEPDIR)/$(am__dirstamp)
+arm/filter_neon_intrinsics.lo: arm/$(am__dirstamp) \
+	arm/$(DEPDIR)/$(am__dirstamp)
+arm/palette_neon_intrinsics.lo: arm/$(am__dirstamp) \
+	arm/$(DEPDIR)/$(am__dirstamp)
+mips/$(am__dirstamp):
+	@$(MKDIR_P) mips
+	@: > mips/$(am__dirstamp)
+mips/$(DEPDIR)/$(am__dirstamp):
+	@$(MKDIR_P) mips/$(DEPDIR)
+	@: > mips/$(DEPDIR)/$(am__dirstamp)
+mips/mips_init.lo: mips/$(am__dirstamp) mips/$(DEPDIR)/$(am__dirstamp)
+mips/filter_msa_intrinsics.lo: mips/$(am__dirstamp) \
+	mips/$(DEPDIR)/$(am__dirstamp)
+intel/$(am__dirstamp):
+	@$(MKDIR_P) intel
+	@: > intel/$(am__dirstamp)
+intel/$(DEPDIR)/$(am__dirstamp):
+	@$(MKDIR_P) intel/$(DEPDIR)
+	@: > intel/$(DEPDIR)/$(am__dirstamp)
+intel/intel_init.lo: intel/$(am__dirstamp) \
+	intel/$(DEPDIR)/$(am__dirstamp)
+intel/filter_sse2_intrinsics.lo: intel/$(am__dirstamp) \
+	intel/$(DEPDIR)/$(am__dirstamp)
+powerpc/$(am__dirstamp):
+	@$(MKDIR_P) powerpc
+	@: > powerpc/$(am__dirstamp)
+powerpc/$(DEPDIR)/$(am__dirstamp):
+	@$(MKDIR_P) powerpc/$(DEPDIR)
+	@: > powerpc/$(DEPDIR)/$(am__dirstamp)
+powerpc/powerpc_init.lo: powerpc/$(am__dirstamp) \
+	powerpc/$(DEPDIR)/$(am__dirstamp)
+powerpc/filter_vsx_intrinsics.lo: powerpc/$(am__dirstamp) \
+	powerpc/$(DEPDIR)/$(am__dirstamp)
+
+libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la: $(libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_OBJECTS) $(libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_DEPENDENCIES) $(EXTRA_libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_DEPENDENCIES) 
+	$(AM_V_CCLD)$(libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_LINK) -rpath $(libdir) $(libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_OBJECTS) $(libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_LIBADD) $(LIBS)
+contrib/tools/$(am__dirstamp):
+	@$(MKDIR_P) contrib/tools
+	@: > contrib/tools/$(am__dirstamp)
+contrib/tools/$(DEPDIR)/$(am__dirstamp):
+	@$(MKDIR_P) contrib/tools/$(DEPDIR)
+	@: > contrib/tools/$(DEPDIR)/$(am__dirstamp)
+contrib/tools/png-fix-itxt.$(OBJEXT): contrib/tools/$(am__dirstamp) \
+	contrib/tools/$(DEPDIR)/$(am__dirstamp)
+
+png-fix-itxt$(EXEEXT): $(png_fix_itxt_OBJECTS) $(png_fix_itxt_DEPENDENCIES) $(EXTRA_png_fix_itxt_DEPENDENCIES) 
+	@rm -f png-fix-itxt$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(png_fix_itxt_OBJECTS) $(png_fix_itxt_LDADD) $(LIBS)
+contrib/tools/pngcp.$(OBJEXT): contrib/tools/$(am__dirstamp) \
+	contrib/tools/$(DEPDIR)/$(am__dirstamp)
+
+pngcp$(EXEEXT): $(pngcp_OBJECTS) $(pngcp_DEPENDENCIES) $(EXTRA_pngcp_DEPENDENCIES) 
+	@rm -f pngcp$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(pngcp_OBJECTS) $(pngcp_LDADD) $(LIBS)
+contrib/tools/pngfix.$(OBJEXT): contrib/tools/$(am__dirstamp) \
+	contrib/tools/$(DEPDIR)/$(am__dirstamp)
+
+pngfix$(EXEEXT): $(pngfix_OBJECTS) $(pngfix_DEPENDENCIES) $(EXTRA_pngfix_DEPENDENCIES) 
+	@rm -f pngfix$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(pngfix_OBJECTS) $(pngfix_LDADD) $(LIBS)
+contrib/libtests/$(am__dirstamp):
+	@$(MKDIR_P) contrib/libtests
+	@: > contrib/libtests/$(am__dirstamp)
+contrib/libtests/$(DEPDIR)/$(am__dirstamp):
+	@$(MKDIR_P) contrib/libtests/$(DEPDIR)
+	@: > contrib/libtests/$(DEPDIR)/$(am__dirstamp)
+contrib/libtests/pngimage.$(OBJEXT): contrib/libtests/$(am__dirstamp) \
+	contrib/libtests/$(DEPDIR)/$(am__dirstamp)
+
+pngimage$(EXEEXT): $(pngimage_OBJECTS) $(pngimage_DEPENDENCIES) $(EXTRA_pngimage_DEPENDENCIES) 
+	@rm -f pngimage$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(pngimage_OBJECTS) $(pngimage_LDADD) $(LIBS)
+contrib/libtests/pngstest.$(OBJEXT): contrib/libtests/$(am__dirstamp) \
+	contrib/libtests/$(DEPDIR)/$(am__dirstamp)
+
+pngstest$(EXEEXT): $(pngstest_OBJECTS) $(pngstest_DEPENDENCIES) $(EXTRA_pngstest_DEPENDENCIES) 
+	@rm -f pngstest$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(pngstest_OBJECTS) $(pngstest_LDADD) $(LIBS)
+
+pngtest$(EXEEXT): $(pngtest_OBJECTS) $(pngtest_DEPENDENCIES) $(EXTRA_pngtest_DEPENDENCIES) 
+	@rm -f pngtest$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(pngtest_OBJECTS) $(pngtest_LDADD) $(LIBS)
+contrib/libtests/pngunknown.$(OBJEXT):  \
+	contrib/libtests/$(am__dirstamp) \
+	contrib/libtests/$(DEPDIR)/$(am__dirstamp)
+
+pngunknown$(EXEEXT): $(pngunknown_OBJECTS) $(pngunknown_DEPENDENCIES) $(EXTRA_pngunknown_DEPENDENCIES) 
+	@rm -f pngunknown$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(pngunknown_OBJECTS) $(pngunknown_LDADD) $(LIBS)
+contrib/libtests/pngvalid.$(OBJEXT): contrib/libtests/$(am__dirstamp) \
+	contrib/libtests/$(DEPDIR)/$(am__dirstamp)
+
+pngvalid$(EXEEXT): $(pngvalid_OBJECTS) $(pngvalid_DEPENDENCIES) $(EXTRA_pngvalid_DEPENDENCIES) 
+	@rm -f pngvalid$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(pngvalid_OBJECTS) $(pngvalid_LDADD) $(LIBS)
+contrib/libtests/timepng.$(OBJEXT): contrib/libtests/$(am__dirstamp) \
+	contrib/libtests/$(DEPDIR)/$(am__dirstamp)
+
+timepng$(EXEEXT): $(timepng_OBJECTS) $(timepng_DEPENDENCIES) $(EXTRA_timepng_DEPENDENCIES) 
+	@rm -f timepng$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(timepng_OBJECTS) $(timepng_LDADD) $(LIBS)
+install-binSCRIPTS: $(bin_SCRIPTS)
+	@$(NORMAL_INSTALL)
+	@list='$(bin_SCRIPTS)'; test -n "$(bindir)" || list=; \
+	if test -n "$$list"; then \
+	  echo " $(MKDIR_P) '$(DESTDIR)$(bindir)'"; \
+	  $(MKDIR_P) "$(DESTDIR)$(bindir)" || exit 1; \
+	fi; \
+	for p in $$list; do \
+	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+	  if test -f "$$d$$p"; then echo "$$d$$p"; echo "$$p"; else :; fi; \
+	done | \
+	sed -e 'p;s,.*/,,;n' \
+	    -e 'h;s|.*|.|' \
+	    -e 'p;x;s,.*/,,;$(transform)' | sed 'N;N;N;s,\n, ,g' | \
+	$(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1; } \
+	  { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \
+	    if ($$2 == $$4) { files[d] = files[d] " " $$1; \
+	      if (++n[d] == $(am__install_max)) { \
+		print "f", d, files[d]; n[d] = 0; files[d] = "" } } \
+	    else { print "f", d "/" $$4, $$1 } } \
+	  END { for (d in files) print "f", d, files[d] }' | \
+	while read type dir files; do \
+	     if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \
+	     test -z "$$files" || { \
+	       echo " $(INSTALL_SCRIPT) $$files '$(DESTDIR)$(bindir)$$dir'"; \
+	       $(INSTALL_SCRIPT) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \
+	     } \
+	; done
+
+uninstall-binSCRIPTS:
+	@$(NORMAL_UNINSTALL)
+	@list='$(bin_SCRIPTS)'; test -n "$(bindir)" || exit 0; \
+	files=`for p in $$list; do echo "$$p"; done | \
+	       sed -e 's,.*/,,;$(transform)'`; \
+	dir='$(DESTDIR)$(bindir)'; $(am__uninstall_files_from_dir)
+
+mostlyclean-compile:
+	-rm -f *.$(OBJEXT)
+	-rm -f arm/*.$(OBJEXT)
+	-rm -f arm/*.lo
+	-rm -f contrib/libtests/*.$(OBJEXT)
+	-rm -f contrib/tools/*.$(OBJEXT)
+	-rm -f intel/*.$(OBJEXT)
+	-rm -f intel/*.lo
+	-rm -f mips/*.$(OBJEXT)
+	-rm -f mips/*.lo
+	-rm -f powerpc/*.$(OBJEXT)
+	-rm -f powerpc/*.lo
+
+distclean-compile:
+	-rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/png.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pngerror.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pngget.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pngmem.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pngpread.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pngread.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pngrio.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pngrtran.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pngrutil.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pngset.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pngtest.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pngtrans.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pngwio.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pngwrite.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pngwtran.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pngwutil.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@arm/$(DEPDIR)/arm_init.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@arm/$(DEPDIR)/filter_neon.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@arm/$(DEPDIR)/filter_neon_intrinsics.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@arm/$(DEPDIR)/palette_neon_intrinsics.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@contrib/libtests/$(DEPDIR)/pngimage.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@contrib/libtests/$(DEPDIR)/pngstest.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@contrib/libtests/$(DEPDIR)/pngunknown.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@contrib/libtests/$(DEPDIR)/pngvalid.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@contrib/libtests/$(DEPDIR)/timepng.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@contrib/tools/$(DEPDIR)/png-fix-itxt.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@contrib/tools/$(DEPDIR)/pngcp.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@contrib/tools/$(DEPDIR)/pngfix.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@intel/$(DEPDIR)/filter_sse2_intrinsics.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@intel/$(DEPDIR)/intel_init.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@mips/$(DEPDIR)/filter_msa_intrinsics.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@mips/$(DEPDIR)/mips_init.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@powerpc/$(DEPDIR)/filter_vsx_intrinsics.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@powerpc/$(DEPDIR)/powerpc_init.Plo@am__quote@ # am--include-marker
+
+$(am__depfiles_remade):
+	@$(MKDIR_P) $(@D)
+	@echo '# dummy' >$@-t && $(am__mv) $@-t $@
+
+am--depfiles: $(am__depfiles_remade)
+
+.S.o:
+@am__fastdepCCAS_TRUE@	$(AM_V_CPPAS)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
+@am__fastdepCCAS_TRUE@	$(CPPASCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCCAS_TRUE@	$(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCCAS_FALSE@	$(AM_V_CPPAS)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCCAS_FALSE@	DEPDIR=$(DEPDIR) $(CCASDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCCAS_FALSE@	$(AM_V_CPPAS@am__nodep@)$(CPPASCOMPILE) -c -o $@ $<
+
+.S.obj:
+@am__fastdepCCAS_TRUE@	$(AM_V_CPPAS)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
+@am__fastdepCCAS_TRUE@	$(CPPASCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
+@am__fastdepCCAS_TRUE@	$(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCCAS_FALSE@	$(AM_V_CPPAS)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCCAS_FALSE@	DEPDIR=$(DEPDIR) $(CCASDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCCAS_FALSE@	$(AM_V_CPPAS@am__nodep@)$(CPPASCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+.S.lo:
+@am__fastdepCCAS_TRUE@	$(AM_V_CPPAS)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
+@am__fastdepCCAS_TRUE@	$(LTCPPASCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCCAS_TRUE@	$(am__mv) $$depbase.Tpo $$depbase.Plo
+@AMDEP_TRUE@@am__fastdepCCAS_FALSE@	$(AM_V_CPPAS)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCCAS_FALSE@	DEPDIR=$(DEPDIR) $(CCASDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCCAS_FALSE@	$(AM_V_CPPAS@am__nodep@)$(LTCPPASCOMPILE) -c -o $@ $<
+
+.c.o:
+@am__fastdepCC_TRUE@	$(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
+@am__fastdepCC_TRUE@	$(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCC_TRUE@	$(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $<
+
+.c.obj:
+@am__fastdepCC_TRUE@	$(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
+@am__fastdepCC_TRUE@	$(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
+@am__fastdepCC_TRUE@	$(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+.c.lo:
+@am__fastdepCC_TRUE@	$(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
+@am__fastdepCC_TRUE@	$(LTCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCC_TRUE@	$(am__mv) $$depbase.Tpo $$depbase.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $<
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+	-rm -rf arm/.libs arm/_libs
+	-rm -rf intel/.libs intel/_libs
+	-rm -rf mips/.libs mips/_libs
+	-rm -rf powerpc/.libs powerpc/_libs
+
+distclean-libtool:
+	-rm -f libtool config.lt
+install-man3: $(dist_man_MANS)
+	@$(NORMAL_INSTALL)
+	@list1=''; \
+	list2='$(dist_man_MANS)'; \
+	test -n "$(man3dir)" \
+	  && test -n "`echo $$list1$$list2`" \
+	  || exit 0; \
+	echo " $(MKDIR_P) '$(DESTDIR)$(man3dir)'"; \
+	$(MKDIR_P) "$(DESTDIR)$(man3dir)" || exit 1; \
+	{ for i in $$list1; do echo "$$i"; done;  \
+	if test -n "$$list2"; then \
+	  for i in $$list2; do echo "$$i"; done \
+	    | sed -n '/\.3[a-z]*$$/p'; \
+	fi; \
+	} | while read p; do \
+	  if test -f $$p; then d=; else d="$(srcdir)/"; fi; \
+	  echo "$$d$$p"; echo "$$p"; \
+	done | \
+	sed -e 'n;s,.*/,,;p;h;s,.*\.,,;s,^[^3][0-9a-z]*$$,3,;x' \
+	      -e 's,\.[0-9a-z]*$$,,;$(transform);G;s,\n,.,' | \
+	sed 'N;N;s,\n, ,g' | { \
+	list=; while read file base inst; do \
+	  if test "$$base" = "$$inst"; then list="$$list $$file"; else \
+	    echo " $(INSTALL_DATA) '$$file' '$(DESTDIR)$(man3dir)/$$inst'"; \
+	    $(INSTALL_DATA) "$$file" "$(DESTDIR)$(man3dir)/$$inst" || exit $$?; \
+	  fi; \
+	done; \
+	for i in $$list; do echo "$$i"; done | $(am__base_list) | \
+	while read files; do \
+	  test -z "$$files" || { \
+	    echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(man3dir)'"; \
+	    $(INSTALL_DATA) $$files "$(DESTDIR)$(man3dir)" || exit $$?; }; \
+	done; }
+
+uninstall-man3:
+	@$(NORMAL_UNINSTALL)
+	@list=''; test -n "$(man3dir)" || exit 0; \
+	files=`{ for i in $$list; do echo "$$i"; done; \
+	l2='$(dist_man_MANS)'; for i in $$l2; do echo "$$i"; done | \
+	  sed -n '/\.3[a-z]*$$/p'; \
+	} | sed -e 's,.*/,,;h;s,.*\.,,;s,^[^3][0-9a-z]*$$,3,;x' \
+	      -e 's,\.[0-9a-z]*$$,,;$(transform);G;s,\n,.,'`; \
+	dir='$(DESTDIR)$(man3dir)'; $(am__uninstall_files_from_dir)
+install-man5: $(dist_man_MANS)
+	@$(NORMAL_INSTALL)
+	@list1=''; \
+	list2='$(dist_man_MANS)'; \
+	test -n "$(man5dir)" \
+	  && test -n "`echo $$list1$$list2`" \
+	  || exit 0; \
+	echo " $(MKDIR_P) '$(DESTDIR)$(man5dir)'"; \
+	$(MKDIR_P) "$(DESTDIR)$(man5dir)" || exit 1; \
+	{ for i in $$list1; do echo "$$i"; done;  \
+	if test -n "$$list2"; then \
+	  for i in $$list2; do echo "$$i"; done \
+	    | sed -n '/\.5[a-z]*$$/p'; \
+	fi; \
+	} | while read p; do \
+	  if test -f $$p; then d=; else d="$(srcdir)/"; fi; \
+	  echo "$$d$$p"; echo "$$p"; \
+	done | \
+	sed -e 'n;s,.*/,,;p;h;s,.*\.,,;s,^[^5][0-9a-z]*$$,5,;x' \
+	      -e 's,\.[0-9a-z]*$$,,;$(transform);G;s,\n,.,' | \
+	sed 'N;N;s,\n, ,g' | { \
+	list=; while read file base inst; do \
+	  if test "$$base" = "$$inst"; then list="$$list $$file"; else \
+	    echo " $(INSTALL_DATA) '$$file' '$(DESTDIR)$(man5dir)/$$inst'"; \
+	    $(INSTALL_DATA) "$$file" "$(DESTDIR)$(man5dir)/$$inst" || exit $$?; \
+	  fi; \
+	done; \
+	for i in $$list; do echo "$$i"; done | $(am__base_list) | \
+	while read files; do \
+	  test -z "$$files" || { \
+	    echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(man5dir)'"; \
+	    $(INSTALL_DATA) $$files "$(DESTDIR)$(man5dir)" || exit $$?; }; \
+	done; }
+
+uninstall-man5:
+	@$(NORMAL_UNINSTALL)
+	@list=''; test -n "$(man5dir)" || exit 0; \
+	files=`{ for i in $$list; do echo "$$i"; done; \
+	l2='$(dist_man_MANS)'; for i in $$l2; do echo "$$i"; done | \
+	  sed -n '/\.5[a-z]*$$/p'; \
+	} | sed -e 's,.*/,,;h;s,.*\.,,;s,^[^5][0-9a-z]*$$,5,;x' \
+	      -e 's,\.[0-9a-z]*$$,,;$(transform);G;s,\n,.,'`; \
+	dir='$(DESTDIR)$(man5dir)'; $(am__uninstall_files_from_dir)
+install-pkgconfigDATA: $(pkgconfig_DATA)
+	@$(NORMAL_INSTALL)
+	@list='$(pkgconfig_DATA)'; test -n "$(pkgconfigdir)" || list=; \
+	if test -n "$$list"; then \
+	  echo " $(MKDIR_P) '$(DESTDIR)$(pkgconfigdir)'"; \
+	  $(MKDIR_P) "$(DESTDIR)$(pkgconfigdir)" || exit 1; \
+	fi; \
+	for p in $$list; do \
+	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+	  echo "$$d$$p"; \
+	done | $(am__base_list) | \
+	while read files; do \
+	  echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(pkgconfigdir)'"; \
+	  $(INSTALL_DATA) $$files "$(DESTDIR)$(pkgconfigdir)" || exit $$?; \
+	done
+
+uninstall-pkgconfigDATA:
+	@$(NORMAL_UNINSTALL)
+	@list='$(pkgconfig_DATA)'; test -n "$(pkgconfigdir)" || list=; \
+	files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
+	dir='$(DESTDIR)$(pkgconfigdir)'; $(am__uninstall_files_from_dir)
+install-nodist_pkgincludeHEADERS: $(nodist_pkginclude_HEADERS)
+	@$(NORMAL_INSTALL)
+	@list='$(nodist_pkginclude_HEADERS)'; test -n "$(pkgincludedir)" || list=; \
+	if test -n "$$list"; then \
+	  echo " $(MKDIR_P) '$(DESTDIR)$(pkgincludedir)'"; \
+	  $(MKDIR_P) "$(DESTDIR)$(pkgincludedir)" || exit 1; \
+	fi; \
+	for p in $$list; do \
+	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+	  echo "$$d$$p"; \
+	done | $(am__base_list) | \
+	while read files; do \
+	  echo " $(INSTALL_HEADER) $$files '$(DESTDIR)$(pkgincludedir)'"; \
+	  $(INSTALL_HEADER) $$files "$(DESTDIR)$(pkgincludedir)" || exit $$?; \
+	done
+
+uninstall-nodist_pkgincludeHEADERS:
+	@$(NORMAL_UNINSTALL)
+	@list='$(nodist_pkginclude_HEADERS)'; test -n "$(pkgincludedir)" || list=; \
+	files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
+	dir='$(DESTDIR)$(pkgincludedir)'; $(am__uninstall_files_from_dir)
+install-pkgincludeHEADERS: $(pkginclude_HEADERS)
+	@$(NORMAL_INSTALL)
+	@list='$(pkginclude_HEADERS)'; test -n "$(pkgincludedir)" || list=; \
+	if test -n "$$list"; then \
+	  echo " $(MKDIR_P) '$(DESTDIR)$(pkgincludedir)'"; \
+	  $(MKDIR_P) "$(DESTDIR)$(pkgincludedir)" || exit 1; \
+	fi; \
+	for p in $$list; do \
+	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+	  echo "$$d$$p"; \
+	done | $(am__base_list) | \
+	while read files; do \
+	  echo " $(INSTALL_HEADER) $$files '$(DESTDIR)$(pkgincludedir)'"; \
+	  $(INSTALL_HEADER) $$files "$(DESTDIR)$(pkgincludedir)" || exit $$?; \
+	done
+
+uninstall-pkgincludeHEADERS:
+	@$(NORMAL_UNINSTALL)
+	@list='$(pkginclude_HEADERS)'; test -n "$(pkgincludedir)" || list=; \
+	files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
+	dir='$(DESTDIR)$(pkgincludedir)'; $(am__uninstall_files_from_dir)
+
+ID: $(am__tagged_files)
+	$(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-am
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+	set x; \
+	here=`pwd`; \
+	$(am__define_uniq_tagged_files); \
+	shift; \
+	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+	  test -n "$$unique" || unique=$$empty_fix; \
+	  if test $$# -gt 0; then \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      "$$@" $$unique; \
+	  else \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      $$unique; \
+	  fi; \
+	fi
+ctags: ctags-am
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+	$(am__define_uniq_tagged_files); \
+	test -z "$(CTAGS_ARGS)$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && $(am__cd) $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) "$$here"
+cscope: cscope.files
+	test ! -s cscope.files \
+	  || $(CSCOPE) -b -q $(AM_CSCOPEFLAGS) $(CSCOPEFLAGS) -i cscope.files $(CSCOPE_ARGS)
+clean-cscope:
+	-rm -f cscope.files
+cscope.files: clean-cscope cscopelist
+cscopelist: cscopelist-am
+
+cscopelist-am: $(am__tagged_files)
+	list='$(am__tagged_files)'; \
+	case "$(srcdir)" in \
+	  [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+	  *) sdir=$(subdir)/$(srcdir) ;; \
+	esac; \
+	for i in $$list; do \
+	  if test -f "$$i"; then \
+	    echo "$(subdir)/$$i"; \
+	  else \
+	    echo "$$sdir/$$i"; \
+	  fi; \
+	done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+	-rm -f cscope.out cscope.in.out cscope.po.out cscope.files
+
+# Recover from deleted '.trs' file; this should ensure that
+# "rm -f foo.log; make foo.trs" re-run 'foo.test', and re-create
+# both 'foo.log' and 'foo.trs'.  Break the recipe in two subshells
+# to avoid problems with "make -n".
+.log.trs:
+	rm -f $< $@
+	$(MAKE) $(AM_MAKEFLAGS) $<
+
+# Leading 'am--fnord' is there to ensure the list of targets does not
+# expand to empty, as could happen e.g. with make check TESTS=''.
+am--fnord $(TEST_LOGS) $(TEST_LOGS:.log=.trs): $(am__force_recheck)
+am--force-recheck:
+	@:
+
+$(TEST_SUITE_LOG): $(TEST_LOGS)
+	@$(am__set_TESTS_bases); \
+	am__f_ok () { test -f "$$1" && test -r "$$1"; }; \
+	redo_bases=`for i in $$bases; do \
+	              am__f_ok $$i.trs && am__f_ok $$i.log || echo $$i; \
+	            done`; \
+	if test -n "$$redo_bases"; then \
+	  redo_logs=`for i in $$redo_bases; do echo $$i.log; done`; \
+	  redo_results=`for i in $$redo_bases; do echo $$i.trs; done`; \
+	  if $(am__make_dryrun); then :; else \
+	    rm -f $$redo_logs && rm -f $$redo_results || exit 1; \
+	  fi; \
+	fi; \
+	if test -n "$$am__remaking_logs"; then \
+	  echo "fatal: making $(TEST_SUITE_LOG): possible infinite" \
+	       "recursion detected" >&2; \
+	elif test -n "$$redo_logs"; then \
+	  am__remaking_logs=yes $(MAKE) $(AM_MAKEFLAGS) $$redo_logs; \
+	fi; \
+	if $(am__make_dryrun); then :; else \
+	  st=0;  \
+	  errmsg="fatal: making $(TEST_SUITE_LOG): failed to create"; \
+	  for i in $$redo_bases; do \
+	    test -f $$i.trs && test -r $$i.trs \
+	      || { echo "$$errmsg $$i.trs" >&2; st=1; }; \
+	    test -f $$i.log && test -r $$i.log \
+	      || { echo "$$errmsg $$i.log" >&2; st=1; }; \
+	  done; \
+	  test $$st -eq 0 || exit 1; \
+	fi
+	@$(am__sh_e_setup); $(am__tty_colors); $(am__set_TESTS_bases); \
+	ws='[ 	]'; \
+	results=`for b in $$bases; do echo $$b.trs; done`; \
+	test -n "$$results" || results=/dev/null; \
+	all=`  grep "^$$ws*:test-result:"           $$results | wc -l`; \
+	pass=` grep "^$$ws*:test-result:$$ws*PASS"  $$results | wc -l`; \
+	fail=` grep "^$$ws*:test-result:$$ws*FAIL"  $$results | wc -l`; \
+	skip=` grep "^$$ws*:test-result:$$ws*SKIP"  $$results | wc -l`; \
+	xfail=`grep "^$$ws*:test-result:$$ws*XFAIL" $$results | wc -l`; \
+	xpass=`grep "^$$ws*:test-result:$$ws*XPASS" $$results | wc -l`; \
+	error=`grep "^$$ws*:test-result:$$ws*ERROR" $$results | wc -l`; \
+	if test `expr $$fail + $$xpass + $$error` -eq 0; then \
+	  success=true; \
+	else \
+	  success=false; \
+	fi; \
+	br='==================='; br=$$br$$br$$br$$br; \
+	result_count () \
+	{ \
+	    if test x"$$1" = x"--maybe-color"; then \
+	      maybe_colorize=yes; \
+	    elif test x"$$1" = x"--no-color"; then \
+	      maybe_colorize=no; \
+	    else \
+	      echo "$@: invalid 'result_count' usage" >&2; exit 4; \
+	    fi; \
+	    shift; \
+	    desc=$$1 count=$$2; \
+	    if test $$maybe_colorize = yes && test $$count -gt 0; then \
+	      color_start=$$3 color_end=$$std; \
+	    else \
+	      color_start= color_end=; \
+	    fi; \
+	    echo "$${color_start}# $$desc $$count$${color_end}"; \
+	}; \
+	create_testsuite_report () \
+	{ \
+	  result_count $$1 "TOTAL:" $$all   "$$brg"; \
+	  result_count $$1 "PASS: " $$pass  "$$grn"; \
+	  result_count $$1 "SKIP: " $$skip  "$$blu"; \
+	  result_count $$1 "XFAIL:" $$xfail "$$lgn"; \
+	  result_count $$1 "FAIL: " $$fail  "$$red"; \
+	  result_count $$1 "XPASS:" $$xpass "$$red"; \
+	  result_count $$1 "ERROR:" $$error "$$mgn"; \
+	}; \
+	{								\
+	  echo "$(PACKAGE_STRING): $(subdir)/$(TEST_SUITE_LOG)" |	\
+	    $(am__rst_title);						\
+	  create_testsuite_report --no-color;				\
+	  echo;								\
+	  echo ".. contents:: :depth: 2";				\
+	  echo;								\
+	  for b in $$bases; do echo $$b; done				\
+	    | $(am__create_global_log);					\
+	} >$(TEST_SUITE_LOG).tmp || exit 1;				\
+	mv $(TEST_SUITE_LOG).tmp $(TEST_SUITE_LOG);			\
+	if $$success; then						\
+	  col="$$grn";							\
+	 else								\
+	  col="$$red";							\
+	  test x"$$VERBOSE" = x || cat $(TEST_SUITE_LOG);		\
+	fi;								\
+	echo "$${col}$$br$${std}"; 					\
+	echo "$${col}Testsuite summary for $(PACKAGE_STRING)$${std}";	\
+	echo "$${col}$$br$${std}"; 					\
+	create_testsuite_report --maybe-color;				\
+	echo "$$col$$br$$std";						\
+	if $$success; then :; else					\
+	  echo "$${col}See $(subdir)/$(TEST_SUITE_LOG)$${std}";		\
+	  if test -n "$(PACKAGE_BUGREPORT)"; then			\
+	    echo "$${col}Please report to $(PACKAGE_BUGREPORT)$${std}";	\
+	  fi;								\
+	  echo "$$col$$br$$std";					\
+	fi;								\
+	$$success || exit 1
+
+check-TESTS: $(check_PROGRAMS)
+	@list='$(RECHECK_LOGS)';           test -z "$$list" || rm -f $$list
+	@list='$(RECHECK_LOGS:.log=.trs)'; test -z "$$list" || rm -f $$list
+	@test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG)
+	@set +e; $(am__set_TESTS_bases); \
+	log_list=`for i in $$bases; do echo $$i.log; done`; \
+	trs_list=`for i in $$bases; do echo $$i.trs; done`; \
+	log_list=`echo $$log_list`; trs_list=`echo $$trs_list`; \
+	$(MAKE) $(AM_MAKEFLAGS) $(TEST_SUITE_LOG) TEST_LOGS="$$log_list"; \
+	exit $$?;
+recheck: all $(check_PROGRAMS)
+	@test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG)
+	@set +e; $(am__set_TESTS_bases); \
+	bases=`for i in $$bases; do echo $$i; done \
+	         | $(am__list_recheck_tests)` || exit 1; \
+	log_list=`for i in $$bases; do echo $$i.log; done`; \
+	log_list=`echo $$log_list`; \
+	$(MAKE) $(AM_MAKEFLAGS) $(TEST_SUITE_LOG) \
+	        am__force_recheck=am--force-recheck \
+	        TEST_LOGS="$$log_list"; \
+	exit $$?
+tests/pngtest.log: tests/pngtest
+	@p='tests/pngtest'; \
+	b='tests/pngtest'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngtest-badpngs.log: tests/pngtest-badpngs
+	@p='tests/pngtest-badpngs'; \
+	b='tests/pngtest-badpngs'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngvalid-gamma-16-to-8.log: tests/pngvalid-gamma-16-to-8
+	@p='tests/pngvalid-gamma-16-to-8'; \
+	b='tests/pngvalid-gamma-16-to-8'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngvalid-gamma-alpha-mode.log: tests/pngvalid-gamma-alpha-mode
+	@p='tests/pngvalid-gamma-alpha-mode'; \
+	b='tests/pngvalid-gamma-alpha-mode'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngvalid-gamma-background.log: tests/pngvalid-gamma-background
+	@p='tests/pngvalid-gamma-background'; \
+	b='tests/pngvalid-gamma-background'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngvalid-gamma-expand16-alpha-mode.log: tests/pngvalid-gamma-expand16-alpha-mode
+	@p='tests/pngvalid-gamma-expand16-alpha-mode'; \
+	b='tests/pngvalid-gamma-expand16-alpha-mode'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngvalid-gamma-expand16-background.log: tests/pngvalid-gamma-expand16-background
+	@p='tests/pngvalid-gamma-expand16-background'; \
+	b='tests/pngvalid-gamma-expand16-background'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngvalid-gamma-expand16-transform.log: tests/pngvalid-gamma-expand16-transform
+	@p='tests/pngvalid-gamma-expand16-transform'; \
+	b='tests/pngvalid-gamma-expand16-transform'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngvalid-gamma-sbit.log: tests/pngvalid-gamma-sbit
+	@p='tests/pngvalid-gamma-sbit'; \
+	b='tests/pngvalid-gamma-sbit'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngvalid-gamma-threshold.log: tests/pngvalid-gamma-threshold
+	@p='tests/pngvalid-gamma-threshold'; \
+	b='tests/pngvalid-gamma-threshold'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngvalid-gamma-transform.log: tests/pngvalid-gamma-transform
+	@p='tests/pngvalid-gamma-transform'; \
+	b='tests/pngvalid-gamma-transform'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngvalid-progressive-size.log: tests/pngvalid-progressive-size
+	@p='tests/pngvalid-progressive-size'; \
+	b='tests/pngvalid-progressive-size'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngvalid-progressive-interlace-standard.log: tests/pngvalid-progressive-interlace-standard
+	@p='tests/pngvalid-progressive-interlace-standard'; \
+	b='tests/pngvalid-progressive-interlace-standard'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngvalid-transform.log: tests/pngvalid-transform
+	@p='tests/pngvalid-transform'; \
+	b='tests/pngvalid-transform'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngvalid-progressive-standard.log: tests/pngvalid-progressive-standard
+	@p='tests/pngvalid-progressive-standard'; \
+	b='tests/pngvalid-progressive-standard'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngvalid-standard.log: tests/pngvalid-standard
+	@p='tests/pngvalid-standard'; \
+	b='tests/pngvalid-standard'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngstest-1.8.log: tests/pngstest-1.8
+	@p='tests/pngstest-1.8'; \
+	b='tests/pngstest-1.8'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngstest-1.8-alpha.log: tests/pngstest-1.8-alpha
+	@p='tests/pngstest-1.8-alpha'; \
+	b='tests/pngstest-1.8-alpha'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngstest-linear.log: tests/pngstest-linear
+	@p='tests/pngstest-linear'; \
+	b='tests/pngstest-linear'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngstest-linear-alpha.log: tests/pngstest-linear-alpha
+	@p='tests/pngstest-linear-alpha'; \
+	b='tests/pngstest-linear-alpha'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngstest-none.log: tests/pngstest-none
+	@p='tests/pngstest-none'; \
+	b='tests/pngstest-none'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngstest-none-alpha.log: tests/pngstest-none-alpha
+	@p='tests/pngstest-none-alpha'; \
+	b='tests/pngstest-none-alpha'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngstest-sRGB.log: tests/pngstest-sRGB
+	@p='tests/pngstest-sRGB'; \
+	b='tests/pngstest-sRGB'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngstest-sRGB-alpha.log: tests/pngstest-sRGB-alpha
+	@p='tests/pngstest-sRGB-alpha'; \
+	b='tests/pngstest-sRGB-alpha'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngunknown-IDAT.log: tests/pngunknown-IDAT
+	@p='tests/pngunknown-IDAT'; \
+	b='tests/pngunknown-IDAT'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngunknown-discard.log: tests/pngunknown-discard
+	@p='tests/pngunknown-discard'; \
+	b='tests/pngunknown-discard'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngunknown-if-safe.log: tests/pngunknown-if-safe
+	@p='tests/pngunknown-if-safe'; \
+	b='tests/pngunknown-if-safe'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngunknown-sAPI.log: tests/pngunknown-sAPI
+	@p='tests/pngunknown-sAPI'; \
+	b='tests/pngunknown-sAPI'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngunknown-sTER.log: tests/pngunknown-sTER
+	@p='tests/pngunknown-sTER'; \
+	b='tests/pngunknown-sTER'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngunknown-save.log: tests/pngunknown-save
+	@p='tests/pngunknown-save'; \
+	b='tests/pngunknown-save'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngunknown-vpAg.log: tests/pngunknown-vpAg
+	@p='tests/pngunknown-vpAg'; \
+	b='tests/pngunknown-vpAg'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngimage-quick.log: tests/pngimage-quick
+	@p='tests/pngimage-quick'; \
+	b='tests/pngimage-quick'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+tests/pngimage-full.log: tests/pngimage-full
+	@p='tests/pngimage-full'; \
+	b='tests/pngimage-full'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+.test.log:
+	@p='$<'; \
+	$(am__set_b); \
+	$(am__check_pre) $(TEST_LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_TEST_LOG_DRIVER_FLAGS) $(TEST_LOG_DRIVER_FLAGS) -- $(TEST_LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+@am__EXEEXT_TRUE@.test$(EXEEXT).log:
+@am__EXEEXT_TRUE@	@p='$<'; \
+@am__EXEEXT_TRUE@	$(am__set_b); \
+@am__EXEEXT_TRUE@	$(am__check_pre) $(TEST_LOG_DRIVER) --test-name "$$f" \
+@am__EXEEXT_TRUE@	--log-file $$b.log --trs-file $$b.trs \
+@am__EXEEXT_TRUE@	$(am__common_driver_flags) $(AM_TEST_LOG_DRIVER_FLAGS) $(TEST_LOG_DRIVER_FLAGS) -- $(TEST_LOG_COMPILE) \
+@am__EXEEXT_TRUE@	"$$tst" $(AM_TESTS_FD_REDIRECT)
+
+distdir: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) distdir-am
+
+distdir-am: $(DISTFILES)
+	$(am__remove_distdir)
+	test -d "$(distdir)" || mkdir "$(distdir)"
+	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	list='$(DISTFILES)'; \
+	  dist_files=`for file in $$list; do echo $$file; done | \
+	  sed -e "s|^$$srcdirstrip/||;t" \
+	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+	case $$dist_files in \
+	  */*) $(MKDIR_P) `echo "$$dist_files" | \
+			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+			   sort -u` ;; \
+	esac; \
+	for file in $$dist_files; do \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  if test -d $$d/$$file; then \
+	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+	    if test -d "$(distdir)/$$file"; then \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+	  else \
+	    test -f "$(distdir)/$$file" \
+	    || cp -p $$d/$$file "$(distdir)/$$file" \
+	    || exit 1; \
+	  fi; \
+	done
+	$(MAKE) $(AM_MAKEFLAGS) \
+	  top_distdir="$(top_distdir)" distdir="$(distdir)" \
+	  dist-hook
+	-test -n "$(am__skip_mode_fix)" \
+	|| find "$(distdir)" -type d ! -perm -755 \
+		-exec chmod u+rwx,go+rx {} \; -o \
+	  ! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; -o \
+	  ! -type d ! -perm -400 -exec chmod a+r {} \; -o \
+	  ! -type d ! -perm -444 -exec $(install_sh) -c -m a+r {} {} \; \
+	|| chmod -R a+r "$(distdir)"
+dist-gzip: distdir
+	tardir=$(distdir) && $(am__tar) | eval GZIP= gzip $(GZIP_ENV) -c >$(distdir).tar.gz
+	$(am__post_remove_distdir)
+
+dist-bzip2: distdir
+	tardir=$(distdir) && $(am__tar) | BZIP2=$${BZIP2--9} bzip2 -c >$(distdir).tar.bz2
+	$(am__post_remove_distdir)
+
+dist-lzip: distdir
+	tardir=$(distdir) && $(am__tar) | lzip -c $${LZIP_OPT--9} >$(distdir).tar.lz
+	$(am__post_remove_distdir)
+dist-xz: distdir
+	tardir=$(distdir) && $(am__tar) | XZ_OPT=$${XZ_OPT--e} xz -c >$(distdir).tar.xz
+	$(am__post_remove_distdir)
+
+dist-tarZ: distdir
+	@echo WARNING: "Support for distribution archives compressed with" \
+		       "legacy program 'compress' is deprecated." >&2
+	@echo WARNING: "It will be removed altogether in Automake 2.0" >&2
+	tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z
+	$(am__post_remove_distdir)
+
+dist-shar: distdir
+	@echo WARNING: "Support for shar distribution archives is" \
+	               "deprecated." >&2
+	@echo WARNING: "It will be removed altogether in Automake 2.0" >&2
+	shar $(distdir) | eval GZIP= gzip $(GZIP_ENV) -c >$(distdir).shar.gz
+	$(am__post_remove_distdir)
+
+dist-zip: distdir
+	-rm -f $(distdir).zip
+	zip -rq $(distdir).zip $(distdir)
+	$(am__post_remove_distdir)
+
+dist dist-all:
+	$(MAKE) $(AM_MAKEFLAGS) $(DIST_TARGETS) am__post_remove_distdir='@:'
+	$(am__post_remove_distdir)
+
+# This target untars the dist file and tries a VPATH configuration.  Then
+# it guarantees that the distribution is self-contained by making another
+# tarfile.
+distcheck: dist
+	case '$(DIST_ARCHIVES)' in \
+	*.tar.gz*) \
+	  eval GZIP= gzip $(GZIP_ENV) -dc $(distdir).tar.gz | $(am__untar) ;;\
+	*.tar.bz2*) \
+	  bzip2 -dc $(distdir).tar.bz2 | $(am__untar) ;;\
+	*.tar.lz*) \
+	  lzip -dc $(distdir).tar.lz | $(am__untar) ;;\
+	*.tar.xz*) \
+	  xz -dc $(distdir).tar.xz | $(am__untar) ;;\
+	*.tar.Z*) \
+	  uncompress -c $(distdir).tar.Z | $(am__untar) ;;\
+	*.shar.gz*) \
+	  eval GZIP= gzip $(GZIP_ENV) -dc $(distdir).shar.gz | unshar ;;\
+	*.zip*) \
+	  unzip $(distdir).zip ;;\
+	esac
+	chmod -R a-w $(distdir)
+	chmod u+w $(distdir)
+	mkdir $(distdir)/_build $(distdir)/_build/sub $(distdir)/_inst
+	chmod a-w $(distdir)
+	test -d $(distdir)/_build || exit 0; \
+	dc_install_base=`$(am__cd) $(distdir)/_inst && pwd | sed -e 's,^[^:\\/]:[\\/],/,'` \
+	  && dc_destdir="$${TMPDIR-/tmp}/am-dc-$$$$/" \
+	  && am__cwd=`pwd` \
+	  && $(am__cd) $(distdir)/_build/sub \
+	  && ../../configure \
+	    $(AM_DISTCHECK_CONFIGURE_FLAGS) \
+	    $(DISTCHECK_CONFIGURE_FLAGS) \
+	    --srcdir=../.. --prefix="$$dc_install_base" \
+	  && $(MAKE) $(AM_MAKEFLAGS) \
+	  && $(MAKE) $(AM_MAKEFLAGS) dvi \
+	  && $(MAKE) $(AM_MAKEFLAGS) check \
+	  && $(MAKE) $(AM_MAKEFLAGS) install \
+	  && $(MAKE) $(AM_MAKEFLAGS) installcheck \
+	  && $(MAKE) $(AM_MAKEFLAGS) uninstall \
+	  && $(MAKE) $(AM_MAKEFLAGS) distuninstallcheck_dir="$$dc_install_base" \
+	        distuninstallcheck \
+	  && chmod -R a-w "$$dc_install_base" \
+	  && ({ \
+	       (cd ../.. && umask 077 && mkdir "$$dc_destdir") \
+	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" install \
+	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" uninstall \
+	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" \
+	            distuninstallcheck_dir="$$dc_destdir" distuninstallcheck; \
+	      } || { rm -rf "$$dc_destdir"; exit 1; }) \
+	  && rm -rf "$$dc_destdir" \
+	  && $(MAKE) $(AM_MAKEFLAGS) dist \
+	  && rm -rf $(DIST_ARCHIVES) \
+	  && $(MAKE) $(AM_MAKEFLAGS) distcleancheck \
+	  && cd "$$am__cwd" \
+	  || exit 1
+	$(am__post_remove_distdir)
+	@(echo "$(distdir) archives ready for distribution: "; \
+	  list='$(DIST_ARCHIVES)'; for i in $$list; do echo $$i; done) | \
+	  sed -e 1h -e 1s/./=/g -e 1p -e 1x -e '$$p' -e '$$x'
+distuninstallcheck:
+	@test -n '$(distuninstallcheck_dir)' || { \
+	  echo 'ERROR: trying to run $@ with an empty' \
+	       '$$(distuninstallcheck_dir)' >&2; \
+	  exit 1; \
+	}; \
+	$(am__cd) '$(distuninstallcheck_dir)' || { \
+	  echo 'ERROR: cannot chdir into $(distuninstallcheck_dir)' >&2; \
+	  exit 1; \
+	}; \
+	test `$(am__distuninstallcheck_listfiles) | wc -l` -eq 0 \
+	   || { echo "ERROR: files left after uninstall:" ; \
+	        if test -n "$(DESTDIR)"; then \
+	          echo "  (check DESTDIR support)"; \
+	        fi ; \
+	        $(distuninstallcheck_listfiles) ; \
+	        exit 1; } >&2
+distcleancheck: distclean
+	@if test '$(srcdir)' = . ; then \
+	  echo "ERROR: distcleancheck can only run from a VPATH build" ; \
+	  exit 1 ; \
+	fi
+	@test `$(distcleancheck_listfiles) | wc -l` -eq 0 \
+	  || { echo "ERROR: files left in build directory after distclean:" ; \
+	       $(distcleancheck_listfiles) ; \
+	       exit 1; } >&2
+check-am: all-am
+	$(MAKE) $(AM_MAKEFLAGS) $(check_PROGRAMS)
+	$(MAKE) $(AM_MAKEFLAGS) check-TESTS
+check: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) check-am
+all-am: Makefile $(PROGRAMS) $(LTLIBRARIES) $(SCRIPTS) $(MANS) $(DATA) \
+		$(HEADERS) config.h
+install-binPROGRAMS: install-libLTLIBRARIES
+
+installdirs:
+	for dir in "$(DESTDIR)$(bindir)" "$(DESTDIR)$(libdir)" "$(DESTDIR)$(bindir)" "$(DESTDIR)$(man3dir)" "$(DESTDIR)$(man5dir)" "$(DESTDIR)$(pkgconfigdir)" "$(DESTDIR)$(pkgincludedir)" "$(DESTDIR)$(pkgincludedir)"; do \
+	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+	done
+install: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	if test -z '$(STRIP)'; then \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	      install; \
+	else \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+	fi
+mostlyclean-generic:
+	-test -z "$(TEST_LOGS)" || rm -f $(TEST_LOGS)
+	-test -z "$(TEST_LOGS:.log=.trs)" || rm -f $(TEST_LOGS:.log=.trs)
+	-test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG)
+
+clean-generic:
+	-test -z "$(CLEANFILES)" || rm -f $(CLEANFILES)
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+	-rm -f arm/$(DEPDIR)/$(am__dirstamp)
+	-rm -f arm/$(am__dirstamp)
+	-rm -f contrib/libtests/$(DEPDIR)/$(am__dirstamp)
+	-rm -f contrib/libtests/$(am__dirstamp)
+	-rm -f contrib/tools/$(DEPDIR)/$(am__dirstamp)
+	-rm -f contrib/tools/$(am__dirstamp)
+	-rm -f intel/$(DEPDIR)/$(am__dirstamp)
+	-rm -f intel/$(am__dirstamp)
+	-rm -f mips/$(DEPDIR)/$(am__dirstamp)
+	-rm -f mips/$(am__dirstamp)
+	-rm -f powerpc/$(DEPDIR)/$(am__dirstamp)
+	-rm -f powerpc/$(am__dirstamp)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+	-test -z "$(BUILT_SOURCES)" || rm -f $(BUILT_SOURCES)
+	-test -z "$(MAINTAINERCLEANFILES)" || rm -f $(MAINTAINERCLEANFILES)
+@DO_INSTALL_LIBPNG_CONFIG_FALSE@@DO_INSTALL_LINKS_FALSE@install-exec-hook:
+@DO_INSTALL_LIBPNG_PC_FALSE@@DO_INSTALL_LINKS_FALSE@install-data-hook:
+@DO_INSTALL_LIBPNG_CONFIG_FALSE@@DO_INSTALL_LIBPNG_PC_FALSE@@DO_INSTALL_LINKS_FALSE@uninstall-hook:
+clean: clean-am
+
+clean-am: clean-binPROGRAMS clean-checkPROGRAMS clean-generic \
+	clean-libLTLIBRARIES clean-libtool mostlyclean-am
+
+distclean: distclean-am
+	-rm -f $(am__CONFIG_DISTCLEAN_FILES)
+		-rm -f ./$(DEPDIR)/png.Plo
+	-rm -f ./$(DEPDIR)/pngerror.Plo
+	-rm -f ./$(DEPDIR)/pngget.Plo
+	-rm -f ./$(DEPDIR)/pngmem.Plo
+	-rm -f ./$(DEPDIR)/pngpread.Plo
+	-rm -f ./$(DEPDIR)/pngread.Plo
+	-rm -f ./$(DEPDIR)/pngrio.Plo
+	-rm -f ./$(DEPDIR)/pngrtran.Plo
+	-rm -f ./$(DEPDIR)/pngrutil.Plo
+	-rm -f ./$(DEPDIR)/pngset.Plo
+	-rm -f ./$(DEPDIR)/pngtest.Po
+	-rm -f ./$(DEPDIR)/pngtrans.Plo
+	-rm -f ./$(DEPDIR)/pngwio.Plo
+	-rm -f ./$(DEPDIR)/pngwrite.Plo
+	-rm -f ./$(DEPDIR)/pngwtran.Plo
+	-rm -f ./$(DEPDIR)/pngwutil.Plo
+	-rm -f arm/$(DEPDIR)/arm_init.Plo
+	-rm -f arm/$(DEPDIR)/filter_neon.Plo
+	-rm -f arm/$(DEPDIR)/filter_neon_intrinsics.Plo
+	-rm -f arm/$(DEPDIR)/palette_neon_intrinsics.Plo
+	-rm -f contrib/libtests/$(DEPDIR)/pngimage.Po
+	-rm -f contrib/libtests/$(DEPDIR)/pngstest.Po
+	-rm -f contrib/libtests/$(DEPDIR)/pngunknown.Po
+	-rm -f contrib/libtests/$(DEPDIR)/pngvalid.Po
+	-rm -f contrib/libtests/$(DEPDIR)/timepng.Po
+	-rm -f contrib/tools/$(DEPDIR)/png-fix-itxt.Po
+	-rm -f contrib/tools/$(DEPDIR)/pngcp.Po
+	-rm -f contrib/tools/$(DEPDIR)/pngfix.Po
+	-rm -f intel/$(DEPDIR)/filter_sse2_intrinsics.Plo
+	-rm -f intel/$(DEPDIR)/intel_init.Plo
+	-rm -f mips/$(DEPDIR)/filter_msa_intrinsics.Plo
+	-rm -f mips/$(DEPDIR)/mips_init.Plo
+	-rm -f powerpc/$(DEPDIR)/filter_vsx_intrinsics.Plo
+	-rm -f powerpc/$(DEPDIR)/powerpc_init.Plo
+	-rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+	distclean-hdr distclean-libtool distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am: install-man install-nodist_pkgincludeHEADERS \
+	install-pkgconfigDATA install-pkgincludeHEADERS
+	@$(NORMAL_INSTALL)
+	$(MAKE) $(AM_MAKEFLAGS) install-data-hook
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am: install-binPROGRAMS install-binSCRIPTS \
+	install-libLTLIBRARIES
+	@$(NORMAL_INSTALL)
+	$(MAKE) $(AM_MAKEFLAGS) install-exec-hook
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man: install-man3 install-man5
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-rm -f $(am__CONFIG_DISTCLEAN_FILES)
+	-rm -rf $(top_srcdir)/autom4te.cache
+		-rm -f ./$(DEPDIR)/png.Plo
+	-rm -f ./$(DEPDIR)/pngerror.Plo
+	-rm -f ./$(DEPDIR)/pngget.Plo
+	-rm -f ./$(DEPDIR)/pngmem.Plo
+	-rm -f ./$(DEPDIR)/pngpread.Plo
+	-rm -f ./$(DEPDIR)/pngread.Plo
+	-rm -f ./$(DEPDIR)/pngrio.Plo
+	-rm -f ./$(DEPDIR)/pngrtran.Plo
+	-rm -f ./$(DEPDIR)/pngrutil.Plo
+	-rm -f ./$(DEPDIR)/pngset.Plo
+	-rm -f ./$(DEPDIR)/pngtest.Po
+	-rm -f ./$(DEPDIR)/pngtrans.Plo
+	-rm -f ./$(DEPDIR)/pngwio.Plo
+	-rm -f ./$(DEPDIR)/pngwrite.Plo
+	-rm -f ./$(DEPDIR)/pngwtran.Plo
+	-rm -f ./$(DEPDIR)/pngwutil.Plo
+	-rm -f arm/$(DEPDIR)/arm_init.Plo
+	-rm -f arm/$(DEPDIR)/filter_neon.Plo
+	-rm -f arm/$(DEPDIR)/filter_neon_intrinsics.Plo
+	-rm -f arm/$(DEPDIR)/palette_neon_intrinsics.Plo
+	-rm -f contrib/libtests/$(DEPDIR)/pngimage.Po
+	-rm -f contrib/libtests/$(DEPDIR)/pngstest.Po
+	-rm -f contrib/libtests/$(DEPDIR)/pngunknown.Po
+	-rm -f contrib/libtests/$(DEPDIR)/pngvalid.Po
+	-rm -f contrib/libtests/$(DEPDIR)/timepng.Po
+	-rm -f contrib/tools/$(DEPDIR)/png-fix-itxt.Po
+	-rm -f contrib/tools/$(DEPDIR)/pngcp.Po
+	-rm -f contrib/tools/$(DEPDIR)/pngfix.Po
+	-rm -f intel/$(DEPDIR)/filter_sse2_intrinsics.Plo
+	-rm -f intel/$(DEPDIR)/intel_init.Plo
+	-rm -f mips/$(DEPDIR)/filter_msa_intrinsics.Plo
+	-rm -f mips/$(DEPDIR)/mips_init.Plo
+	-rm -f powerpc/$(DEPDIR)/filter_vsx_intrinsics.Plo
+	-rm -f powerpc/$(DEPDIR)/powerpc_init.Plo
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+	mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-binPROGRAMS uninstall-binSCRIPTS \
+	uninstall-libLTLIBRARIES uninstall-man \
+	uninstall-nodist_pkgincludeHEADERS uninstall-pkgconfigDATA \
+	uninstall-pkgincludeHEADERS
+	@$(NORMAL_INSTALL)
+	$(MAKE) $(AM_MAKEFLAGS) uninstall-hook
+uninstall-man: uninstall-man3 uninstall-man5
+
+.MAKE: all check check-am install install-am install-data-am \
+	install-exec-am install-strip uninstall-am
+
+.PHONY: CTAGS GTAGS TAGS all all-am am--depfiles am--refresh check \
+	check-TESTS check-am clean clean-binPROGRAMS \
+	clean-checkPROGRAMS clean-cscope clean-generic \
+	clean-libLTLIBRARIES clean-libtool cscope cscopelist-am ctags \
+	ctags-am dist dist-all dist-bzip2 dist-gzip dist-hook \
+	dist-lzip dist-shar dist-tarZ dist-xz dist-zip distcheck \
+	distclean distclean-compile distclean-generic distclean-hdr \
+	distclean-libtool distclean-tags distcleancheck distdir \
+	distuninstallcheck dvi dvi-am html html-am info info-am \
+	install install-am install-binPROGRAMS install-binSCRIPTS \
+	install-data install-data-am install-data-hook install-dvi \
+	install-dvi-am install-exec install-exec-am install-exec-hook \
+	install-html install-html-am install-info install-info-am \
+	install-libLTLIBRARIES install-man install-man3 install-man5 \
+	install-nodist_pkgincludeHEADERS install-pdf install-pdf-am \
+	install-pkgconfigDATA install-pkgincludeHEADERS install-ps \
+	install-ps-am install-strip installcheck installcheck-am \
+	installdirs maintainer-clean maintainer-clean-generic \
+	mostlyclean mostlyclean-compile mostlyclean-generic \
+	mostlyclean-libtool pdf pdf-am ps ps-am recheck tags tags-am \
+	uninstall uninstall-am uninstall-binPROGRAMS \
+	uninstall-binSCRIPTS uninstall-hook uninstall-libLTLIBRARIES \
+	uninstall-man uninstall-man3 uninstall-man5 \
+	uninstall-nodist_pkgincludeHEADERS uninstall-pkgconfigDATA \
+	uninstall-pkgincludeHEADERS
+
+.PRECIOUS: Makefile
+
+
+$(PNGLIB_BASENAME).pc: libpng.pc
+	cp libpng.pc $@
+
+$(PNGLIB_BASENAME)-config: libpng-config
+	cp libpng-config $@
+
+scripts/sym.out scripts/vers.out: png.h pngconf.h pnglibconf.h
+scripts/prefix.out: png.h pngconf.h pnglibconf.out
+scripts/symbols.out: png.h pngconf.h $(srcdir)/scripts/pnglibconf.h.prebuilt
+scripts/intprefix.out: pnglibconf.h
+
+libpng.sym: scripts/sym.out
+	rm -f $@
+	cp $? $@
+libpng.vers: scripts/vers.out
+	rm -f $@
+	cp $? $@
+
+# Rename functions in scripts/prefix.out with a PNG_PREFIX prefix.
+# Rename macros in scripts/macro.lst from PNG_PREFIXpng_ to PNG_ (the actual
+# implementation of the macro).
+@DO_PNG_PREFIX_TRUE@pnglibconf.h: pnglibconf.out scripts/prefix.out scripts/macro.lst
+@DO_PNG_PREFIX_TRUE@	rm -f $@
+@DO_PNG_PREFIX_TRUE@	$(AWK) 's==0 && NR>1{print prev}\
+@DO_PNG_PREFIX_TRUE@	   s==0{prev=$$0}\
+@DO_PNG_PREFIX_TRUE@	   s==1{print "#define", $$1, "@PNG_PREFIX@" $$1}\
+@DO_PNG_PREFIX_TRUE@	   s==2{print "#define @PNG_PREFIX@png_" $$1, "PNG_" $$1}\
+@DO_PNG_PREFIX_TRUE@	   END{print prev}' s=0 pnglibconf.out s=1 scripts/prefix.out\
+@DO_PNG_PREFIX_TRUE@	   s=2 ${srcdir}/scripts/macro.lst >pnglibconf.tf8
+@DO_PNG_PREFIX_TRUE@	mv pnglibconf.tf8 $@
+
+@DO_PNG_PREFIX_TRUE@pngprefix.h: scripts/intprefix.out
+@DO_PNG_PREFIX_TRUE@	rm -f pngprefix.tf1
+@DO_PNG_PREFIX_TRUE@	$(AWK) '{print "#define", $$1, "@PNG_PREFIX@" $$1}' $? >pngprefix.tf1
+@DO_PNG_PREFIX_TRUE@	mv pngprefix.tf1 $@
+@DO_PNG_PREFIX_FALSE@pnglibconf.h: pnglibconf.out
+@DO_PNG_PREFIX_FALSE@	rm -f $@
+@DO_PNG_PREFIX_FALSE@	cp $? $@
+
+@DO_PNG_PREFIX_FALSE@pngprefix.h: # is empty
+@DO_PNG_PREFIX_FALSE@	:>$@
+
+$(srcdir)/scripts/pnglibconf.h.prebuilt:
+	@echo "Attempting to build $@" >&2
+	@echo "This is a machine generated file, but if you want to make" >&2
+	@echo "a new one simply make 'scripts/pnglibconf.out', copy that" >&2
+	@echo "AND set PNG_ZLIB_VERNUM to 0 (you MUST do this)" >&2
+	@exit 1
+
+# The following is necessary to ensure that the local pnglibconf.h is used, not
+# an installed one (this can happen immediately after on a clean system if
+# 'make test' is the first thing the user does.)  Only files which include
+# one of the png source files (typically png.h or pngpriv.h) need to be listed
+# here:
+pngtest.o: pnglibconf.h
+
+contrib/libtests/makepng.o: pnglibconf.h
+contrib/libtests/pngstest.o: pnglibconf.h
+contrib/libtests/pngunknown.o: pnglibconf.h
+contrib/libtests/pngimage.o: pnglibconf.h
+contrib/libtests/pngvalid.o: pnglibconf.h
+contrib/libtests/readpng.o: pnglibconf.h
+contrib/libtests/tarith.o: pnglibconf.h
+contrib/libtests/timepng.o: pnglibconf.h
+
+contrib/tools/makesRGB.o: pnglibconf.h
+contrib/tools/pngfix.o: pnglibconf.h
+contrib/tools/pngcp.o: pnglibconf.h
+
+.c.out:
+	rm -f $@ $*.tf[12]
+	test -d scripts || mkdir scripts || test -d scripts
+	$(DFNCPP) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES)\
+	    $(CPPFLAGS) $(SYMBOL_CFLAGS) $< > $*.tf1
+	$(AWK) -f "${srcdir}/scripts/dfn.awk" out="$*.tf2" $*.tf1 1>&2
+	rm -f $*.tf1
+	mv $*.tf2 $@
+
+# The .c file for pnglibconf.h is machine generated
+pnglibconf.c: scripts/pnglibconf.dfa scripts/options.awk pngconf.h pngusr.dfa $(DFA_XTRA)
+	rm -f $@ $*.tf[45]
+	$(AWK) -f ${srcdir}/scripts/options.awk out=$*.tf4 version=search\
+	    ${srcdir}/pngconf.h ${srcdir}/scripts/pnglibconf.dfa\
+	    ${srcdir}/pngusr.dfa $(DFA_XTRA) 1>&2
+	$(AWK) -f ${srcdir}/scripts/options.awk out=$*.tf5 $*.tf4 1>&2
+	rm $*.tf4
+	mv $*.tf5 $@
+
+# Symbol checks (.def and .out files should match)
+scripts/symbols.chk: scripts/checksym.awk scripts/symbols.def scripts/symbols.out
+
+.out.chk:
+	rm -f $@ $*.new
+	$(AWK) -f ${srcdir}/scripts/checksym.awk ${srcdir}/scripts/${*F}.def\
+	    of="$*.new" $< >&2
+	mv $*.new $@
+
+# used on demand to regenerate the standard header, CPPFLAGS should
+# be empty - no non-standard defines
+scripts/pnglibconf.c: scripts/pnglibconf.dfa scripts/options.awk pngconf.h
+	rm -f $@ pnglibconf.tf[67]
+	test -z "$(CPPFLAGS)"
+	echo "com @PNGLIB_VERSION@ STANDARD API DEFINITION" |\
+	$(AWK) -f ${srcdir}/scripts/options.awk out=pnglibconf.tf6\
+	    logunsupported=1 version=search ${srcdir}/pngconf.h -\
+	    ${srcdir}/scripts/pnglibconf.dfa 1>&2
+	$(AWK) -f ${srcdir}/scripts/options.awk out=pnglibconf.tf7\
+	    pnglibconf.tf6 1>&2
+	rm pnglibconf.tf6
+	mv pnglibconf.tf7 $@
+
+$(libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_OBJECTS): png.h pngconf.h \
+	pnglibconf.h pngpriv.h pngdebug.h pnginfo.h pngstruct.h pngprefix.h
+
+test: check-am
+
+# Extra checks
+check: scripts/symbols.chk
+
+# Don't distribute the generated script files
+dist-hook:
+	cd '$(top_distdir)'; rm -f $(SCRIPT_CLEANFILES)
+
+# Make links between installed files with release-specific names and the generic
+# file names.  If this install rule is run the generic names will be deleted and
+# recreated - this has obvious issues for systems with multiple installations.
+
+install-header-links:
+	@set -ex; cd '$(DESTDIR)$(includedir)'; for f in $(HEADERS); do \
+	   rm -f "$$f"; $(LN_S) "$(PNGLIB_BASENAME)/$$f" "$$f"; done
+
+uninstall-header-links:
+	cd '$(DESTDIR)$(includedir)'; rm -f $(HEADERS)
+
+install-libpng-pc:
+	@set -ex; cd '$(DESTDIR)$(pkgconfigdir)'; rm -f libpng.pc; \
+	   $(LN_S) '$(PNGLIB_BASENAME).pc' libpng.pc
+
+uninstall-libpng-pc:
+	rm -f '$(DESTDIR)$(pkgconfigdir)/libpng.pc'
+
+install-library-links:
+	@set -x; cd '$(DESTDIR)$(libdir)';\
+	for ext in $(EXT_LIST); do\
+	   rm -f "libpng.$$ext";\
+           if test -f "$(PNGLIB_BASENAME).$$ext"; then\
+              $(LN_S) "$(PNGLIB_BASENAME).$$ext" "libpng.$$ext" || exit 1;\
+           fi;\
+	done
+
+uninstall-library-links:
+	@set -x; cd '$(DESTDIR)$(libdir)'; for ext in $(EXT_LIST); do\
+	   rm -f "libpng.$$ext"; done
+
+install-libpng-config:
+	@set -ex; cd '$(DESTDIR)$(bindir)'; rm -f libpng-config; \
+	   $(LN_S) '$(PNGLIB_BASENAME)-config' libpng-config
+
+uninstall-libpng-config:
+	rm -f '$(DESTDIR)$(bindir)/libpng-config'
+
+# If --enable-unversioned-links is specified the header and lib file links
+# will be automatically made on a 'make install':
+
+@DO_INSTALL_LINKS_TRUE@install-data-hook: install-header-links
+@DO_INSTALL_LINKS_TRUE@uninstall-hook: uninstall-header-links
+@DO_INSTALL_LINKS_TRUE@install-exec-hook: install-library-links
+@DO_INSTALL_LINKS_TRUE@uninstall-hook: uninstall-library-links
+
+# Likewise, --install-pc causes libpng.pc to be constructed:
+
+@DO_INSTALL_LIBPNG_PC_TRUE@install-data-hook: install-libpng-pc
+@DO_INSTALL_LIBPNG_PC_TRUE@uninstall-hook: uninstall-libpng-pc
+
+# And --install-config:
+
+@DO_INSTALL_LIBPNG_CONFIG_TRUE@install-exec-hook: install-libpng-config
+@DO_INSTALL_LIBPNG_CONFIG_TRUE@uninstall-hook: uninstall-libpng-config
+
+# The following addition ensures that 'make all' always builds the test programs
+# too.  It used to, but some change either in libpng or configure stopped this
+# working.
+all-am: $(check_PROGRAMS)
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/Engine/lib/lpng/README b/Engine/lib/lpng/README
index 0da5a5ef8..cfc1f0e3d 100644
--- a/Engine/lib/lpng/README
+++ b/Engine/lib/lpng/README
@@ -1,15 +1,16 @@
-README for libpng version 1.6.34 - September 29, 2017 (shared library 16.0)
-See the note about version numbers near the top of png.h
+README for libpng version 1.6.37 - April 14, 2019
+=================================================
 
+See the note about version numbers near the top of png.h.
 See INSTALL for instructions on how to install libpng.
 
 Libpng comes in several distribution formats.  Get libpng-*.tar.gz or
-libpng-*.tar.xz or if you want UNIX-style line endings in the text files,
-or lpng*.7z or lpng*.zip if you want DOS-style line endings.
+libpng-*.tar.xz or if you want UNIX-style line endings in the text
+files, or lpng*.7z or lpng*.zip if you want DOS-style line endings.
 
 Version 0.89 was the first official release of libpng.  Don't let the
-fact that it's the first release fool you.  The libpng library has been in
-extensive use and testing since mid-1995.  By late 1997 it had
+fact that it's the first release fool you.  The libpng library has been
+in extensive use and testing since mid-1995.  By late 1997 it had
 finally gotten to the stage where there hadn't been significant
 changes to the API in some time, and people have a bad feeling about
 libraries with versions < 1.0.  Version 1.0.0 was released in
@@ -60,94 +61,59 @@ the library action on the detection of chunk CRC errors.  It is possible
 to set different actions based on whether the CRC error occurred in a
 critical or an ancillary chunk.
 
-The changes made to the library, and bugs fixed are based on discussions
-on the PNG-implement mailing list and not on material submitted
-privately to Guy, Andreas, or Glenn.  They will forward any good
-suggestions to the list.
-
-For a detailed description on using libpng, read libpng-manual.txt.  For
-examples of libpng in a program, see example.c and pngtest.c.  For usage
-information and restrictions (what little they are) on libpng, see
-png.h.  For a description on using zlib (the compression library used by
-libpng) and zlib's restrictions, see zlib.h
+For a detailed description on using libpng, read libpng-manual.txt.
+For examples of libpng in a program, see example.c and pngtest.c.  For
+usage information and restrictions (what little they are) on libpng,
+see png.h.  For a description on using zlib (the compression library
+used by libpng) and zlib's restrictions, see zlib.h
 
 I have included a general makefile, as well as several machine and
-compiler specific ones, but you may have to modify one for your own needs.
+compiler specific ones, but you may have to modify one for your own
+needs.
 
 You should use zlib 1.0.4 or later to run this, but it MAY work with
 versions as old as zlib 0.95.  Even so, there are bugs in older zlib
 versions which can cause the output of invalid compression streams for
-some images.  You will definitely need zlib 1.0.4 or later if you are
-taking advantage of the MS-DOS "far" structure allocation for the small
-and medium memory models.  You should also note that zlib is a
-compression library that is useful for more things than just PNG files.
-You can use zlib as a drop-in replacement for fread() and fwrite() if
-you are so inclined.
+some images.
 
-zlib should be available at the same place that libpng is, or at zlib.net.
+You should also note that zlib is a compression library that is useful
+for more things than just PNG files.  You can use zlib as a drop-in
+replacement for fread() and fwrite(), if you are so inclined.
+
+zlib should be available at the same place that libpng is, or at
+https://zlib.net.
 
 You may also want a copy of the PNG specification.  It is available
 as an RFC, a W3C Recommendation, and an ISO/IEC Standard.  You can find
 these at http://www.libpng.org/pub/png/pngdocs.html .
 
 This code is currently being archived at libpng.sourceforge.io in the
-[DOWNLOAD] area, and at http://libpng.download/src .  If you
-can't find it in any of those places, e-mail me, and I'll help you find it.
+[DOWNLOAD] area, and at http://libpng.download/src .
 
-I am not a lawyer, but I believe that the Export Control Classification
-Number (ECCN) for libpng is EAR99, which means not subject to export
-controls or International Traffic in Arms Regulations (ITAR) because it
-is open source, publicly available software, that does not contain any
-encryption software.  See the EAR, paragraphs 734.3(b)(3) and 734.7(b).
-
-If you have any code changes, requests, problems, etc., please e-mail
-them to me.  Also, I'd appreciate any make files or project files,
-and any modifications you needed to make to get libpng to compile,
-along with a #define variable to tell what compiler/system you are on.
-If you needed to add transformations to libpng, or wish libpng would
-provide the image in a different way, drop me a note (and code, if
-possible), so I can consider supporting the transformation.
-Finally, if you get any warning messages when compiling libpng
-(note: not zlib), and they are easy to fix, I'd appreciate the
-fix.  Please mention "libpng" somewhere in the subject line.  Thanks.
-
-This release was created and will be supported by myself (of course
-based in a large way on Guy's and Andreas' earlier work), and the PNG
+This release, based in a large way on Glenn's, Guy's and Andreas'
+earlier work, was created and will be supported by myself and the PNG
 development group.
 
 Send comments/corrections/commendations to png-mng-implement at
 lists.sourceforge.net (subscription required; visit
 https://lists.sourceforge.net/lists/listinfo/png-mng-implement
-to subscribe) or to glennrp at users.sourceforge.net
+to subscribe).
 
-You can't reach Guy, the original libpng author, at the addresses
-given in previous versions of this document.  He and Andreas will
-read mail addressed to the png-implement list, however.
-
-Please do not send general questions about PNG.  Send them to
-png-mng-misc at lists.sf.net (subscription required; visit
+Send general questions about the PNG specification to png-mng-misc
+at lists.sourceforge.net (subscription required; visit
 https://lists.sourceforge.net/lists/listinfo/png-mng-misc to
-subscribe).  If you have a question about something
-in the PNG specification that is related to using libpng, send it
-to me.  Send me any questions that start with "I was using libpng,
-and ...".  If in doubt, send questions to me.  I'll bounce them
-to others, if necessary.
-
-Please do not send suggestions on how to change PNG.  We have
-been discussing PNG for twenty years now, and it is official and
-finished.  If you have suggestions for libpng, however, I'll
-gladly listen.  Even if your suggestion is not used immediately,
-it may be used later.
+subscribe).
 
 Files in this distribution:
 
       ANNOUNCE      =>  Announcement of this version, with recent changes
+      AUTHORS       =>  List of contributing authors
       CHANGES       =>  Description of changes between libpng versions
       KNOWNBUG      =>  List of known bugs and deficiencies
       LICENSE       =>  License to use and redistribute libpng
       README        =>  This file
       TODO          =>  Things not implemented in the current library
-      Y2KINFO       =>  Statement of Y2K compliance
+      TRADEMARK     =>  Trademark information
       example.c     =>  Example code for using libpng functions
       libpng.3      =>  manual page for libpng (includes libpng-manual.txt)
       libpng-manual.txt  =>  Description of libpng and its functions
@@ -208,15 +174,10 @@ Files in this distribution:
       scripts       =>  Directory containing scripts for building libpng:
                             (see scripts/README.txt for the list of scripts)
 
-Good luck, and happy coding.
+Good luck, and happy coding!
 
--Glenn Randers-Pehrson (current maintainer, since 1998)
- Internet: glennrp at users.sourceforge.net
-
--Andreas Eric Dilger (former maintainer, 1996-1997)
- Internet: adilger at enel.ucalgary.ca
- Web: http://www-mddsp.enel.ucalgary.ca/People/adilger/
-
--Guy Eric Schalnat (original author and former maintainer, 1995-1996)
- (formerly of Group 42, Inc)
- Internet: gschal at infinet.com
+ * Cosmin Truta (current maintainer, since 2018)
+ * Glenn Randers-Pehrson (former maintainer, 1998-2018)
+ * Andreas Eric Dilger (former maintainer, 1996-1997)
+ * Guy Eric Schalnat (original author and former maintainer, 1995-1996)
+   (formerly of Group 42, Inc.)
diff --git a/Engine/lib/lpng/TODO b/Engine/lib/lpng/TODO
index 36d6092a2..562dab069 100644
--- a/Engine/lib/lpng/TODO
+++ b/Engine/lib/lpng/TODO
@@ -1,30 +1,23 @@
-/*
 TODO - list of things to do for libpng:
 
-Final bug fixes.
-Better C++ wrapper/full C++ implementation?
-Fix problem with C++ and EXTERN "C".
-cHRM transformation.
-Remove setjmp/longjmp usage in favor of returning error codes. As a start on
-  this, minimize the use of png_error(), replacing them with
-  png_warning(); return(0); or similar.
-Palette creation.
-Add "grayscale->palette" transformation and "palette->grayscale" detection.
-Improved dithering.
-Multi-lingual error and warning message support.
-Complete sRGB transformation (presently it simply uses gamma=0.45455).
-Man pages for function calls.
-Better documentation.
-Better filter selection
-   (counting huffman bits/precompression?  filter inertia?  filter costs?).
-Histogram creation.
-Text conversion between different code pages (Latin-1 -> Mac and DOS).
-Avoid building gamma tables whenever possible.
-Use greater precision when changing to linear gamma for compositing against
-  background and doing rgb-to-gray transformation.
-Investigate pre-incremented loop counters and other loop constructions.
-Add interpolated method of handling interlacing.
-Extend pngvalid.c to validate more of the libpng transformations.
-Refactor preprocessor conditionals to compile entire statements
-
-*/
+* Fix all defects (duh!)
+* Better C++ wrapper / full C++ implementation (?)
+* Fix the problems with C++ and 'extern "C"'.
+* cHRM transformation.
+* Palette creation.
+* "grayscale->palette" transformation and "palette->grayscale" detection.
+* Improved dithering.
+* Multi-lingual error and warning message support.
+* Complete sRGB transformation.  (Currently it simply uses gamma=0.45455.)
+* Man pages for function calls.
+* Better documentation.
+* Better filter selection
+  (e.g., counting huffman bits/precompression; filter inertia; filter costs).
+* Histogram creation.
+* Text conversion between different code pages (e.g., Latin-1 -> Mac).
+* Avoid building gamma tables whenever possible.
+* Greater precision in changing to linear gamma for compositing against
+  background, and in doing rgb-to-gray transformations.
+* Investigate pre-incremented loop counters and other loop constructions.
+* Interpolated method of handling interlacing.
+* More validations for libpng transformations.
diff --git a/Engine/lib/lpng/TRADEMARK b/Engine/lib/lpng/TRADEMARK
new file mode 100644
index 000000000..ac667187d
--- /dev/null
+++ b/Engine/lib/lpng/TRADEMARK
@@ -0,0 +1,8 @@
+TRADEMARK
+=========
+
+The name "libpng" has not been registered by the Copyright owners
+as a trademark in any jurisdiction.  However, because libpng has
+been distributed and maintained world-wide, continually since 1995,
+the Copyright owners claim "common-law trademark protection" in any
+jurisdiction where common-law trademark is recognized.
diff --git a/Engine/lib/lpng/aclocal.m4 b/Engine/lib/lpng/aclocal.m4
new file mode 100644
index 000000000..bc18c34f0
--- /dev/null
+++ b/Engine/lib/lpng/aclocal.m4
@@ -0,0 +1,1196 @@
+# generated automatically by aclocal 1.16.1 -*- Autoconf -*-
+
+# Copyright (C) 1996-2018 Free Software Foundation, Inc.
+
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])])
+m4_ifndef([AC_AUTOCONF_VERSION],
+  [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
+m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.69],,
+[m4_warning([this file was generated for autoconf 2.69.
+You have another version of autoconf.  It may work, but is not guaranteed to.
+If you have problems, you may need to regenerate the build system entirely.
+To do so, use the procedure documented by the package, typically 'autoreconf'.])])
+
+# Copyright (C) 2002-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_AUTOMAKE_VERSION(VERSION)
+# ----------------------------
+# Automake X.Y traces this macro to ensure aclocal.m4 has been
+# generated from the m4 files accompanying Automake X.Y.
+# (This private macro should not be called outside this file.)
+AC_DEFUN([AM_AUTOMAKE_VERSION],
+[am__api_version='1.16'
+dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to
+dnl require some minimum version.  Point them to the right macro.
+m4_if([$1], [1.16.1], [],
+      [AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl
+])
+
+# _AM_AUTOCONF_VERSION(VERSION)
+# -----------------------------
+# aclocal traces this macro to find the Autoconf version.
+# This is a private macro too.  Using m4_define simplifies
+# the logic in aclocal, which can simply ignore this definition.
+m4_define([_AM_AUTOCONF_VERSION], [])
+
+# AM_SET_CURRENT_AUTOMAKE_VERSION
+# -------------------------------
+# Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they can be traced.
+# This function is AC_REQUIREd by AM_INIT_AUTOMAKE.
+AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION],
+[AM_AUTOMAKE_VERSION([1.16.1])dnl
+m4_ifndef([AC_AUTOCONF_VERSION],
+  [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
+_AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))])
+
+# Figure out how to run the assembler.                      -*- Autoconf -*-
+
+# Copyright (C) 2001-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_PROG_AS
+# ----------
+AC_DEFUN([AM_PROG_AS],
+[# By default we simply use the C compiler to build assembly code.
+AC_REQUIRE([AC_PROG_CC])
+test "${CCAS+set}" = set || CCAS=$CC
+test "${CCASFLAGS+set}" = set || CCASFLAGS=$CFLAGS
+AC_ARG_VAR([CCAS],      [assembler compiler command (defaults to CC)])
+AC_ARG_VAR([CCASFLAGS], [assembler compiler flags (defaults to CFLAGS)])
+_AM_IF_OPTION([no-dependencies],, [_AM_DEPENDENCIES([CCAS])])dnl
+])
+
+# AM_AUX_DIR_EXPAND                                         -*- Autoconf -*-
+
+# Copyright (C) 2001-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# For projects using AC_CONFIG_AUX_DIR([foo]), Autoconf sets
+# $ac_aux_dir to '$srcdir/foo'.  In other projects, it is set to
+# '$srcdir', '$srcdir/..', or '$srcdir/../..'.
+#
+# Of course, Automake must honor this variable whenever it calls a
+# tool from the auxiliary directory.  The problem is that $srcdir (and
+# therefore $ac_aux_dir as well) can be either absolute or relative,
+# depending on how configure is run.  This is pretty annoying, since
+# it makes $ac_aux_dir quite unusable in subdirectories: in the top
+# source directory, any form will work fine, but in subdirectories a
+# relative path needs to be adjusted first.
+#
+# $ac_aux_dir/missing
+#    fails when called from a subdirectory if $ac_aux_dir is relative
+# $top_srcdir/$ac_aux_dir/missing
+#    fails if $ac_aux_dir is absolute,
+#    fails when called from a subdirectory in a VPATH build with
+#          a relative $ac_aux_dir
+#
+# The reason of the latter failure is that $top_srcdir and $ac_aux_dir
+# are both prefixed by $srcdir.  In an in-source build this is usually
+# harmless because $srcdir is '.', but things will broke when you
+# start a VPATH build or use an absolute $srcdir.
+#
+# So we could use something similar to $top_srcdir/$ac_aux_dir/missing,
+# iff we strip the leading $srcdir from $ac_aux_dir.  That would be:
+#   am_aux_dir='\$(top_srcdir)/'`expr "$ac_aux_dir" : "$srcdir//*\(.*\)"`
+# and then we would define $MISSING as
+#   MISSING="\${SHELL} $am_aux_dir/missing"
+# This will work as long as MISSING is not called from configure, because
+# unfortunately $(top_srcdir) has no meaning in configure.
+# However there are other variables, like CC, which are often used in
+# configure, and could therefore not use this "fixed" $ac_aux_dir.
+#
+# Another solution, used here, is to always expand $ac_aux_dir to an
+# absolute PATH.  The drawback is that using absolute paths prevent a
+# configured tree to be moved without reconfiguration.
+
+AC_DEFUN([AM_AUX_DIR_EXPAND],
+[AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
+# Expand $ac_aux_dir to an absolute path.
+am_aux_dir=`cd "$ac_aux_dir" && pwd`
+])
+
+# AM_CONDITIONAL                                            -*- Autoconf -*-
+
+# Copyright (C) 1997-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_CONDITIONAL(NAME, SHELL-CONDITION)
+# -------------------------------------
+# Define a conditional.
+AC_DEFUN([AM_CONDITIONAL],
+[AC_PREREQ([2.52])dnl
+ m4_if([$1], [TRUE],  [AC_FATAL([$0: invalid condition: $1])],
+       [$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl
+AC_SUBST([$1_TRUE])dnl
+AC_SUBST([$1_FALSE])dnl
+_AM_SUBST_NOTMAKE([$1_TRUE])dnl
+_AM_SUBST_NOTMAKE([$1_FALSE])dnl
+m4_define([_AM_COND_VALUE_$1], [$2])dnl
+if $2; then
+  $1_TRUE=
+  $1_FALSE='#'
+else
+  $1_TRUE='#'
+  $1_FALSE=
+fi
+AC_CONFIG_COMMANDS_PRE(
+[if test -z "${$1_TRUE}" && test -z "${$1_FALSE}"; then
+  AC_MSG_ERROR([[conditional "$1" was never defined.
+Usually this means the macro was only invoked conditionally.]])
+fi])])
+
+# Copyright (C) 1999-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+
+# There are a few dirty hacks below to avoid letting 'AC_PROG_CC' be
+# written in clear, in which case automake, when reading aclocal.m4,
+# will think it sees a *use*, and therefore will trigger all it's
+# C support machinery.  Also note that it means that autoscan, seeing
+# CC etc. in the Makefile, will ask for an AC_PROG_CC use...
+
+
+# _AM_DEPENDENCIES(NAME)
+# ----------------------
+# See how the compiler implements dependency checking.
+# NAME is "CC", "CXX", "OBJC", "OBJCXX", "UPC", or "GJC".
+# We try a few techniques and use that to set a single cache variable.
+#
+# We don't AC_REQUIRE the corresponding AC_PROG_CC since the latter was
+# modified to invoke _AM_DEPENDENCIES(CC); we would have a circular
+# dependency, and given that the user is not expected to run this macro,
+# just rely on AC_PROG_CC.
+AC_DEFUN([_AM_DEPENDENCIES],
+[AC_REQUIRE([AM_SET_DEPDIR])dnl
+AC_REQUIRE([AM_OUTPUT_DEPENDENCY_COMMANDS])dnl
+AC_REQUIRE([AM_MAKE_INCLUDE])dnl
+AC_REQUIRE([AM_DEP_TRACK])dnl
+
+m4_if([$1], [CC],   [depcc="$CC"   am_compiler_list=],
+      [$1], [CXX],  [depcc="$CXX"  am_compiler_list=],
+      [$1], [OBJC], [depcc="$OBJC" am_compiler_list='gcc3 gcc'],
+      [$1], [OBJCXX], [depcc="$OBJCXX" am_compiler_list='gcc3 gcc'],
+      [$1], [UPC],  [depcc="$UPC"  am_compiler_list=],
+      [$1], [GCJ],  [depcc="$GCJ"  am_compiler_list='gcc3 gcc'],
+                    [depcc="$$1"   am_compiler_list=])
+
+AC_CACHE_CHECK([dependency style of $depcc],
+               [am_cv_$1_dependencies_compiler_type],
+[if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
+  # We make a subdir and do the tests there.  Otherwise we can end up
+  # making bogus files that we don't know about and never remove.  For
+  # instance it was reported that on HP-UX the gcc test will end up
+  # making a dummy file named 'D' -- because '-MD' means "put the output
+  # in D".
+  rm -rf conftest.dir
+  mkdir conftest.dir
+  # Copy depcomp to subdir because otherwise we won't find it if we're
+  # using a relative directory.
+  cp "$am_depcomp" conftest.dir
+  cd conftest.dir
+  # We will build objects and dependencies in a subdirectory because
+  # it helps to detect inapplicable dependency modes.  For instance
+  # both Tru64's cc and ICC support -MD to output dependencies as a
+  # side effect of compilation, but ICC will put the dependencies in
+  # the current directory while Tru64 will put them in the object
+  # directory.
+  mkdir sub
+
+  am_cv_$1_dependencies_compiler_type=none
+  if test "$am_compiler_list" = ""; then
+     am_compiler_list=`sed -n ['s/^#*\([a-zA-Z0-9]*\))$/\1/p'] < ./depcomp`
+  fi
+  am__universal=false
+  m4_case([$1], [CC],
+    [case " $depcc " in #(
+     *\ -arch\ *\ -arch\ *) am__universal=true ;;
+     esac],
+    [CXX],
+    [case " $depcc " in #(
+     *\ -arch\ *\ -arch\ *) am__universal=true ;;
+     esac])
+
+  for depmode in $am_compiler_list; do
+    # Setup a source with many dependencies, because some compilers
+    # like to wrap large dependency lists on column 80 (with \), and
+    # we should not choose a depcomp mode which is confused by this.
+    #
+    # We need to recreate these files for each test, as the compiler may
+    # overwrite some of them when testing with obscure command lines.
+    # This happens at least with the AIX C compiler.
+    : > sub/conftest.c
+    for i in 1 2 3 4 5 6; do
+      echo '#include "conftst'$i'.h"' >> sub/conftest.c
+      # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
+      # Solaris 10 /bin/sh.
+      echo '/* dummy */' > sub/conftst$i.h
+    done
+    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
+
+    # We check with '-c' and '-o' for the sake of the "dashmstdout"
+    # mode.  It turns out that the SunPro C++ compiler does not properly
+    # handle '-M -o', and we need to detect this.  Also, some Intel
+    # versions had trouble with output in subdirs.
+    am__obj=sub/conftest.${OBJEXT-o}
+    am__minus_obj="-o $am__obj"
+    case $depmode in
+    gcc)
+      # This depmode causes a compiler race in universal mode.
+      test "$am__universal" = false || continue
+      ;;
+    nosideeffect)
+      # After this tag, mechanisms are not by side-effect, so they'll
+      # only be used when explicitly requested.
+      if test "x$enable_dependency_tracking" = xyes; then
+	continue
+      else
+	break
+      fi
+      ;;
+    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
+      # This compiler won't grok '-c -o', but also, the minuso test has
+      # not run yet.  These depmodes are late enough in the game, and
+      # so weak that their functioning should not be impacted.
+      am__obj=conftest.${OBJEXT-o}
+      am__minus_obj=
+      ;;
+    none) break ;;
+    esac
+    if depmode=$depmode \
+       source=sub/conftest.c object=$am__obj \
+       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
+       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
+         >/dev/null 2>conftest.err &&
+       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
+       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
+      # icc doesn't choke on unknown options, it will just issue warnings
+      # or remarks (even with -Werror).  So we grep stderr for any message
+      # that says an option was ignored or not supported.
+      # When given -MP, icc 7.0 and 7.1 complain thusly:
+      #   icc: Command line warning: ignoring option '-M'; no argument required
+      # The diagnosis changed in icc 8.0:
+      #   icc: Command line remark: option '-MP' not supported
+      if (grep 'ignoring option' conftest.err ||
+          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
+        am_cv_$1_dependencies_compiler_type=$depmode
+        break
+      fi
+    fi
+  done
+
+  cd ..
+  rm -rf conftest.dir
+else
+  am_cv_$1_dependencies_compiler_type=none
+fi
+])
+AC_SUBST([$1DEPMODE], [depmode=$am_cv_$1_dependencies_compiler_type])
+AM_CONDITIONAL([am__fastdep$1], [
+  test "x$enable_dependency_tracking" != xno \
+  && test "$am_cv_$1_dependencies_compiler_type" = gcc3])
+])
+
+
+# AM_SET_DEPDIR
+# -------------
+# Choose a directory name for dependency files.
+# This macro is AC_REQUIREd in _AM_DEPENDENCIES.
+AC_DEFUN([AM_SET_DEPDIR],
+[AC_REQUIRE([AM_SET_LEADING_DOT])dnl
+AC_SUBST([DEPDIR], ["${am__leading_dot}deps"])dnl
+])
+
+
+# AM_DEP_TRACK
+# ------------
+AC_DEFUN([AM_DEP_TRACK],
+[AC_ARG_ENABLE([dependency-tracking], [dnl
+AS_HELP_STRING(
+  [--enable-dependency-tracking],
+  [do not reject slow dependency extractors])
+AS_HELP_STRING(
+  [--disable-dependency-tracking],
+  [speeds up one-time build])])
+if test "x$enable_dependency_tracking" != xno; then
+  am_depcomp="$ac_aux_dir/depcomp"
+  AMDEPBACKSLASH='\'
+  am__nodep='_no'
+fi
+AM_CONDITIONAL([AMDEP], [test "x$enable_dependency_tracking" != xno])
+AC_SUBST([AMDEPBACKSLASH])dnl
+_AM_SUBST_NOTMAKE([AMDEPBACKSLASH])dnl
+AC_SUBST([am__nodep])dnl
+_AM_SUBST_NOTMAKE([am__nodep])dnl
+])
+
+# Generate code to set up dependency tracking.              -*- Autoconf -*-
+
+# Copyright (C) 1999-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# _AM_OUTPUT_DEPENDENCY_COMMANDS
+# ------------------------------
+AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS],
+[{
+  # Older Autoconf quotes --file arguments for eval, but not when files
+  # are listed without --file.  Let's play safe and only enable the eval
+  # if we detect the quoting.
+  # TODO: see whether this extra hack can be removed once we start
+  # requiring Autoconf 2.70 or later.
+  AS_CASE([$CONFIG_FILES],
+          [*\'*], [eval set x "$CONFIG_FILES"],
+          [*], [set x $CONFIG_FILES])
+  shift
+  # Used to flag and report bootstrapping failures.
+  am_rc=0
+  for am_mf
+  do
+    # Strip MF so we end up with the name of the file.
+    am_mf=`AS_ECHO(["$am_mf"]) | sed -e 's/:.*$//'`
+    # Check whether this is an Automake generated Makefile which includes
+    # dependency-tracking related rules and includes.
+    # Grep'ing the whole file directly is not great: AIX grep has a line
+    # limit of 2048, but all sed's we know have understand at least 4000.
+    sed -n 's,^am--depfiles:.*,X,p' "$am_mf" | grep X >/dev/null 2>&1 \
+      || continue
+    am_dirpart=`AS_DIRNAME(["$am_mf"])`
+    am_filepart=`AS_BASENAME(["$am_mf"])`
+    AM_RUN_LOG([cd "$am_dirpart" \
+      && sed -e '/# am--include-marker/d' "$am_filepart" \
+        | $MAKE -f - am--depfiles]) || am_rc=$?
+  done
+  if test $am_rc -ne 0; then
+    AC_MSG_FAILURE([Something went wrong bootstrapping makefile fragments
+    for automatic dependency tracking.  Try re-running configure with the
+    '--disable-dependency-tracking' option to at least be able to build
+    the package (albeit without support for automatic dependency tracking).])
+  fi
+  AS_UNSET([am_dirpart])
+  AS_UNSET([am_filepart])
+  AS_UNSET([am_mf])
+  AS_UNSET([am_rc])
+  rm -f conftest-deps.mk
+}
+])# _AM_OUTPUT_DEPENDENCY_COMMANDS
+
+
+# AM_OUTPUT_DEPENDENCY_COMMANDS
+# -----------------------------
+# This macro should only be invoked once -- use via AC_REQUIRE.
+#
+# This code is only required when automatic dependency tracking is enabled.
+# This creates each '.Po' and '.Plo' makefile fragment that we'll need in
+# order to bootstrap the dependency handling code.
+AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS],
+[AC_CONFIG_COMMANDS([depfiles],
+     [test x"$AMDEP_TRUE" != x"" || _AM_OUTPUT_DEPENDENCY_COMMANDS],
+     [AMDEP_TRUE="$AMDEP_TRUE" MAKE="${MAKE-make}"])])
+
+# Do all the work for Automake.                             -*- Autoconf -*-
+
+# Copyright (C) 1996-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This macro actually does too much.  Some checks are only needed if
+# your package does certain things.  But this isn't really a big deal.
+
+dnl Redefine AC_PROG_CC to automatically invoke _AM_PROG_CC_C_O.
+m4_define([AC_PROG_CC],
+m4_defn([AC_PROG_CC])
+[_AM_PROG_CC_C_O
+])
+
+# AM_INIT_AUTOMAKE(PACKAGE, VERSION, [NO-DEFINE])
+# AM_INIT_AUTOMAKE([OPTIONS])
+# -----------------------------------------------
+# The call with PACKAGE and VERSION arguments is the old style
+# call (pre autoconf-2.50), which is being phased out.  PACKAGE
+# and VERSION should now be passed to AC_INIT and removed from
+# the call to AM_INIT_AUTOMAKE.
+# We support both call styles for the transition.  After
+# the next Automake release, Autoconf can make the AC_INIT
+# arguments mandatory, and then we can depend on a new Autoconf
+# release and drop the old call support.
+AC_DEFUN([AM_INIT_AUTOMAKE],
+[AC_PREREQ([2.65])dnl
+dnl Autoconf wants to disallow AM_ names.  We explicitly allow
+dnl the ones we care about.
+m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl
+AC_REQUIRE([AM_SET_CURRENT_AUTOMAKE_VERSION])dnl
+AC_REQUIRE([AC_PROG_INSTALL])dnl
+if test "`cd $srcdir && pwd`" != "`pwd`"; then
+  # Use -I$(srcdir) only when $(srcdir) != ., so that make's output
+  # is not polluted with repeated "-I."
+  AC_SUBST([am__isrc], [' -I$(srcdir)'])_AM_SUBST_NOTMAKE([am__isrc])dnl
+  # test to see if srcdir already configured
+  if test -f $srcdir/config.status; then
+    AC_MSG_ERROR([source directory already configured; run "make distclean" there first])
+  fi
+fi
+
+# test whether we have cygpath
+if test -z "$CYGPATH_W"; then
+  if (cygpath --version) >/dev/null 2>/dev/null; then
+    CYGPATH_W='cygpath -w'
+  else
+    CYGPATH_W=echo
+  fi
+fi
+AC_SUBST([CYGPATH_W])
+
+# Define the identity of the package.
+dnl Distinguish between old-style and new-style calls.
+m4_ifval([$2],
+[AC_DIAGNOSE([obsolete],
+             [$0: two- and three-arguments forms are deprecated.])
+m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl
+ AC_SUBST([PACKAGE], [$1])dnl
+ AC_SUBST([VERSION], [$2])],
+[_AM_SET_OPTIONS([$1])dnl
+dnl Diagnose old-style AC_INIT with new-style AM_AUTOMAKE_INIT.
+m4_if(
+  m4_ifdef([AC_PACKAGE_NAME], [ok]):m4_ifdef([AC_PACKAGE_VERSION], [ok]),
+  [ok:ok],,
+  [m4_fatal([AC_INIT should be called with package and version arguments])])dnl
+ AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME'])dnl
+ AC_SUBST([VERSION], ['AC_PACKAGE_VERSION'])])dnl
+
+_AM_IF_OPTION([no-define],,
+[AC_DEFINE_UNQUOTED([PACKAGE], ["$PACKAGE"], [Name of package])
+ AC_DEFINE_UNQUOTED([VERSION], ["$VERSION"], [Version number of package])])dnl
+
+# Some tools Automake needs.
+AC_REQUIRE([AM_SANITY_CHECK])dnl
+AC_REQUIRE([AC_ARG_PROGRAM])dnl
+AM_MISSING_PROG([ACLOCAL], [aclocal-${am__api_version}])
+AM_MISSING_PROG([AUTOCONF], [autoconf])
+AM_MISSING_PROG([AUTOMAKE], [automake-${am__api_version}])
+AM_MISSING_PROG([AUTOHEADER], [autoheader])
+AM_MISSING_PROG([MAKEINFO], [makeinfo])
+AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
+AC_REQUIRE([AM_PROG_INSTALL_STRIP])dnl
+AC_REQUIRE([AC_PROG_MKDIR_P])dnl
+# For better backward compatibility.  To be removed once Automake 1.9.x
+# dies out for good.  For more background, see:
+# <https://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
+# <https://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
+AC_SUBST([mkdir_p], ['$(MKDIR_P)'])
+# We need awk for the "check" target (and possibly the TAP driver).  The
+# system "awk" is bad on some platforms.
+AC_REQUIRE([AC_PROG_AWK])dnl
+AC_REQUIRE([AC_PROG_MAKE_SET])dnl
+AC_REQUIRE([AM_SET_LEADING_DOT])dnl
+_AM_IF_OPTION([tar-ustar], [_AM_PROG_TAR([ustar])],
+	      [_AM_IF_OPTION([tar-pax], [_AM_PROG_TAR([pax])],
+			     [_AM_PROG_TAR([v7])])])
+_AM_IF_OPTION([no-dependencies],,
+[AC_PROVIDE_IFELSE([AC_PROG_CC],
+		  [_AM_DEPENDENCIES([CC])],
+		  [m4_define([AC_PROG_CC],
+			     m4_defn([AC_PROG_CC])[_AM_DEPENDENCIES([CC])])])dnl
+AC_PROVIDE_IFELSE([AC_PROG_CXX],
+		  [_AM_DEPENDENCIES([CXX])],
+		  [m4_define([AC_PROG_CXX],
+			     m4_defn([AC_PROG_CXX])[_AM_DEPENDENCIES([CXX])])])dnl
+AC_PROVIDE_IFELSE([AC_PROG_OBJC],
+		  [_AM_DEPENDENCIES([OBJC])],
+		  [m4_define([AC_PROG_OBJC],
+			     m4_defn([AC_PROG_OBJC])[_AM_DEPENDENCIES([OBJC])])])dnl
+AC_PROVIDE_IFELSE([AC_PROG_OBJCXX],
+		  [_AM_DEPENDENCIES([OBJCXX])],
+		  [m4_define([AC_PROG_OBJCXX],
+			     m4_defn([AC_PROG_OBJCXX])[_AM_DEPENDENCIES([OBJCXX])])])dnl
+])
+AC_REQUIRE([AM_SILENT_RULES])dnl
+dnl The testsuite driver may need to know about EXEEXT, so add the
+dnl 'am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen.  This
+dnl macro is hooked onto _AC_COMPILER_EXEEXT early, see below.
+AC_CONFIG_COMMANDS_PRE(dnl
+[m4_provide_if([_AM_COMPILER_EXEEXT],
+  [AM_CONDITIONAL([am__EXEEXT], [test -n "$EXEEXT"])])])dnl
+
+# POSIX will say in a future version that running "rm -f" with no argument
+# is OK; and we want to be able to make that assumption in our Makefile
+# recipes.  So use an aggressive probe to check that the usage we want is
+# actually supported "in the wild" to an acceptable degree.
+# See automake bug#10828.
+# To make any issue more visible, cause the running configure to be aborted
+# by default if the 'rm' program in use doesn't match our expectations; the
+# user can still override this though.
+if rm -f && rm -fr && rm -rf; then : OK; else
+  cat >&2 <<'END'
+Oops!
+
+Your 'rm' program seems unable to run without file operands specified
+on the command line, even when the '-f' option is present.  This is contrary
+to the behaviour of most rm programs out there, and not conforming with
+the upcoming POSIX standard: <http://austingroupbugs.net/view.php?id=542>
+
+Please tell bug-automake@gnu.org about your system, including the value
+of your $PATH and any error possibly output before this message.  This
+can help us improve future automake versions.
+
+END
+  if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then
+    echo 'Configuration will proceed anyway, since you have set the' >&2
+    echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2
+    echo >&2
+  else
+    cat >&2 <<'END'
+Aborting the configuration process, to ensure you take notice of the issue.
+
+You can download and install GNU coreutils to get an 'rm' implementation
+that behaves properly: <https://www.gnu.org/software/coreutils/>.
+
+If you want to complete the configuration process using your problematic
+'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
+to "yes", and re-run configure.
+
+END
+    AC_MSG_ERROR([Your 'rm' program is bad, sorry.])
+  fi
+fi
+dnl The trailing newline in this macro's definition is deliberate, for
+dnl backward compatibility and to allow trailing 'dnl'-style comments
+dnl after the AM_INIT_AUTOMAKE invocation. See automake bug#16841.
+])
+
+dnl Hook into '_AC_COMPILER_EXEEXT' early to learn its expansion.  Do not
+dnl add the conditional right here, as _AC_COMPILER_EXEEXT may be further
+dnl mangled by Autoconf and run in a shell conditional statement.
+m4_define([_AC_COMPILER_EXEEXT],
+m4_defn([_AC_COMPILER_EXEEXT])[m4_provide([_AM_COMPILER_EXEEXT])])
+
+# When config.status generates a header, we must update the stamp-h file.
+# This file resides in the same directory as the config header
+# that is generated.  The stamp files are numbered to have different names.
+
+# Autoconf calls _AC_AM_CONFIG_HEADER_HOOK (when defined) in the
+# loop where config.status creates the headers, so we can generate
+# our stamp files there.
+AC_DEFUN([_AC_AM_CONFIG_HEADER_HOOK],
+[# Compute $1's index in $config_headers.
+_am_arg=$1
+_am_stamp_count=1
+for _am_header in $config_headers :; do
+  case $_am_header in
+    $_am_arg | $_am_arg:* )
+      break ;;
+    * )
+      _am_stamp_count=`expr $_am_stamp_count + 1` ;;
+  esac
+done
+echo "timestamp for $_am_arg" >`AS_DIRNAME(["$_am_arg"])`/stamp-h[]$_am_stamp_count])
+
+# Copyright (C) 2001-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_PROG_INSTALL_SH
+# ------------------
+# Define $install_sh.
+AC_DEFUN([AM_PROG_INSTALL_SH],
+[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
+if test x"${install_sh+set}" != xset; then
+  case $am_aux_dir in
+  *\ * | *\	*)
+    install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
+  *)
+    install_sh="\${SHELL} $am_aux_dir/install-sh"
+  esac
+fi
+AC_SUBST([install_sh])])
+
+# Copyright (C) 2003-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# Check whether the underlying file-system supports filenames
+# with a leading dot.  For instance MS-DOS doesn't.
+AC_DEFUN([AM_SET_LEADING_DOT],
+[rm -rf .tst 2>/dev/null
+mkdir .tst 2>/dev/null
+if test -d .tst; then
+  am__leading_dot=.
+else
+  am__leading_dot=_
+fi
+rmdir .tst 2>/dev/null
+AC_SUBST([am__leading_dot])])
+
+# Add --enable-maintainer-mode option to configure.         -*- Autoconf -*-
+# From Jim Meyering
+
+# Copyright (C) 1996-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_MAINTAINER_MODE([DEFAULT-MODE])
+# ----------------------------------
+# Control maintainer-specific portions of Makefiles.
+# Default is to disable them, unless 'enable' is passed literally.
+# For symmetry, 'disable' may be passed as well.  Anyway, the user
+# can override the default with the --enable/--disable switch.
+AC_DEFUN([AM_MAINTAINER_MODE],
+[m4_case(m4_default([$1], [disable]),
+       [enable], [m4_define([am_maintainer_other], [disable])],
+       [disable], [m4_define([am_maintainer_other], [enable])],
+       [m4_define([am_maintainer_other], [enable])
+        m4_warn([syntax], [unexpected argument to AM@&t@_MAINTAINER_MODE: $1])])
+AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
+  dnl maintainer-mode's default is 'disable' unless 'enable' is passed
+  AC_ARG_ENABLE([maintainer-mode],
+    [AS_HELP_STRING([--]am_maintainer_other[-maintainer-mode],
+      am_maintainer_other[ make rules and dependencies not useful
+      (and sometimes confusing) to the casual installer])],
+    [USE_MAINTAINER_MODE=$enableval],
+    [USE_MAINTAINER_MODE=]m4_if(am_maintainer_other, [enable], [no], [yes]))
+  AC_MSG_RESULT([$USE_MAINTAINER_MODE])
+  AM_CONDITIONAL([MAINTAINER_MODE], [test $USE_MAINTAINER_MODE = yes])
+  MAINT=$MAINTAINER_MODE_TRUE
+  AC_SUBST([MAINT])dnl
+]
+)
+
+# Check to see how 'make' treats includes.	            -*- Autoconf -*-
+
+# Copyright (C) 2001-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_MAKE_INCLUDE()
+# -----------------
+# Check whether make has an 'include' directive that can support all
+# the idioms we need for our automatic dependency tracking code.
+AC_DEFUN([AM_MAKE_INCLUDE],
+[AC_MSG_CHECKING([whether ${MAKE-make} supports the include directive])
+cat > confinc.mk << 'END'
+am__doit:
+	@echo this is the am__doit target >confinc.out
+.PHONY: am__doit
+END
+am__include="#"
+am__quote=
+# BSD make does it like this.
+echo '.include "confinc.mk" # ignored' > confmf.BSD
+# Other make implementations (GNU, Solaris 10, AIX) do it like this.
+echo 'include confinc.mk # ignored' > confmf.GNU
+_am_result=no
+for s in GNU BSD; do
+  AM_RUN_LOG([${MAKE-make} -f confmf.$s && cat confinc.out])
+  AS_CASE([$?:`cat confinc.out 2>/dev/null`],
+      ['0:this is the am__doit target'],
+      [AS_CASE([$s],
+          [BSD], [am__include='.include' am__quote='"'],
+          [am__include='include' am__quote=''])])
+  if test "$am__include" != "#"; then
+    _am_result="yes ($s style)"
+    break
+  fi
+done
+rm -f confinc.* confmf.*
+AC_MSG_RESULT([${_am_result}])
+AC_SUBST([am__include])])
+AC_SUBST([am__quote])])
+
+# Fake the existence of programs that GNU maintainers use.  -*- Autoconf -*-
+
+# Copyright (C) 1997-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_MISSING_PROG(NAME, PROGRAM)
+# ------------------------------
+AC_DEFUN([AM_MISSING_PROG],
+[AC_REQUIRE([AM_MISSING_HAS_RUN])
+$1=${$1-"${am_missing_run}$2"}
+AC_SUBST($1)])
+
+# AM_MISSING_HAS_RUN
+# ------------------
+# Define MISSING if not defined so far and test if it is modern enough.
+# If it is, set am_missing_run to use it, otherwise, to nothing.
+AC_DEFUN([AM_MISSING_HAS_RUN],
+[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
+AC_REQUIRE_AUX_FILE([missing])dnl
+if test x"${MISSING+set}" != xset; then
+  case $am_aux_dir in
+  *\ * | *\	*)
+    MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;;
+  *)
+    MISSING="\${SHELL} $am_aux_dir/missing" ;;
+  esac
+fi
+# Use eval to expand $SHELL
+if eval "$MISSING --is-lightweight"; then
+  am_missing_run="$MISSING "
+else
+  am_missing_run=
+  AC_MSG_WARN(['missing' script is too old or missing])
+fi
+])
+
+# Helper functions for option handling.                     -*- Autoconf -*-
+
+# Copyright (C) 2001-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# _AM_MANGLE_OPTION(NAME)
+# -----------------------
+AC_DEFUN([_AM_MANGLE_OPTION],
+[[_AM_OPTION_]m4_bpatsubst($1, [[^a-zA-Z0-9_]], [_])])
+
+# _AM_SET_OPTION(NAME)
+# --------------------
+# Set option NAME.  Presently that only means defining a flag for this option.
+AC_DEFUN([_AM_SET_OPTION],
+[m4_define(_AM_MANGLE_OPTION([$1]), [1])])
+
+# _AM_SET_OPTIONS(OPTIONS)
+# ------------------------
+# OPTIONS is a space-separated list of Automake options.
+AC_DEFUN([_AM_SET_OPTIONS],
+[m4_foreach_w([_AM_Option], [$1], [_AM_SET_OPTION(_AM_Option)])])
+
+# _AM_IF_OPTION(OPTION, IF-SET, [IF-NOT-SET])
+# -------------------------------------------
+# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.
+AC_DEFUN([_AM_IF_OPTION],
+[m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])])
+
+# Copyright (C) 1999-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# _AM_PROG_CC_C_O
+# ---------------
+# Like AC_PROG_CC_C_O, but changed for automake.  We rewrite AC_PROG_CC
+# to automatically call this.
+AC_DEFUN([_AM_PROG_CC_C_O],
+[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
+AC_REQUIRE_AUX_FILE([compile])dnl
+AC_LANG_PUSH([C])dnl
+AC_CACHE_CHECK(
+  [whether $CC understands -c and -o together],
+  [am_cv_prog_cc_c_o],
+  [AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
+  # Make sure it works both with $CC and with simple cc.
+  # Following AC_PROG_CC_C_O, we do the test twice because some
+  # compilers refuse to overwrite an existing .o file with -o,
+  # though they will create one.
+  am_cv_prog_cc_c_o=yes
+  for am_i in 1 2; do
+    if AM_RUN_LOG([$CC -c conftest.$ac_ext -o conftest2.$ac_objext]) \
+         && test -f conftest2.$ac_objext; then
+      : OK
+    else
+      am_cv_prog_cc_c_o=no
+      break
+    fi
+  done
+  rm -f core conftest*
+  unset am_i])
+if test "$am_cv_prog_cc_c_o" != yes; then
+   # Losing compiler, so override with the script.
+   # FIXME: It is wrong to rewrite CC.
+   # But if we don't then we get into trouble of one sort or another.
+   # A longer-term fix would be to have automake use am__CC in this case,
+   # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
+   CC="$am_aux_dir/compile $CC"
+fi
+AC_LANG_POP([C])])
+
+# For backward compatibility.
+AC_DEFUN_ONCE([AM_PROG_CC_C_O], [AC_REQUIRE([AC_PROG_CC])])
+
+# Copyright (C) 2001-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_RUN_LOG(COMMAND)
+# -------------------
+# Run COMMAND, save the exit status in ac_status, and log it.
+# (This has been adapted from Autoconf's _AC_RUN_LOG macro.)
+AC_DEFUN([AM_RUN_LOG],
+[{ echo "$as_me:$LINENO: $1" >&AS_MESSAGE_LOG_FD
+   ($1) >&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
+   (exit $ac_status); }])
+
+# Check to make sure that the build environment is sane.    -*- Autoconf -*-
+
+# Copyright (C) 1996-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_SANITY_CHECK
+# ---------------
+AC_DEFUN([AM_SANITY_CHECK],
+[AC_MSG_CHECKING([whether build environment is sane])
+# Reject unsafe characters in $srcdir or the absolute working directory
+# name.  Accept space and tab only in the latter.
+am_lf='
+'
+case `pwd` in
+  *[[\\\"\#\$\&\'\`$am_lf]]*)
+    AC_MSG_ERROR([unsafe absolute working directory name]);;
+esac
+case $srcdir in
+  *[[\\\"\#\$\&\'\`$am_lf\ \	]]*)
+    AC_MSG_ERROR([unsafe srcdir value: '$srcdir']);;
+esac
+
+# Do 'set' in a subshell so we don't clobber the current shell's
+# arguments.  Must try -L first in case configure is actually a
+# symlink; some systems play weird games with the mod time of symlinks
+# (eg FreeBSD returns the mod time of the symlink's containing
+# directory).
+if (
+   am_has_slept=no
+   for am_try in 1 2; do
+     echo "timestamp, slept: $am_has_slept" > conftest.file
+     set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
+     if test "$[*]" = "X"; then
+	# -L didn't work.
+	set X `ls -t "$srcdir/configure" conftest.file`
+     fi
+     if test "$[*]" != "X $srcdir/configure conftest.file" \
+	&& test "$[*]" != "X conftest.file $srcdir/configure"; then
+
+	# If neither matched, then we have a broken ls.  This can happen
+	# if, for instance, CONFIG_SHELL is bash and it inherits a
+	# broken ls alias from the environment.  This has actually
+	# happened.  Such a system could not be considered "sane".
+	AC_MSG_ERROR([ls -t appears to fail.  Make sure there is not a broken
+  alias in your environment])
+     fi
+     if test "$[2]" = conftest.file || test $am_try -eq 2; then
+       break
+     fi
+     # Just in case.
+     sleep 1
+     am_has_slept=yes
+   done
+   test "$[2]" = conftest.file
+   )
+then
+   # Ok.
+   :
+else
+   AC_MSG_ERROR([newly created file is older than distributed files!
+Check your system clock])
+fi
+AC_MSG_RESULT([yes])
+# If we didn't sleep, we still need to ensure time stamps of config.status and
+# generated files are strictly newer.
+am_sleep_pid=
+if grep 'slept: no' conftest.file >/dev/null 2>&1; then
+  ( sleep 1 ) &
+  am_sleep_pid=$!
+fi
+AC_CONFIG_COMMANDS_PRE(
+  [AC_MSG_CHECKING([that generated files are newer than configure])
+   if test -n "$am_sleep_pid"; then
+     # Hide warnings about reused PIDs.
+     wait $am_sleep_pid 2>/dev/null
+   fi
+   AC_MSG_RESULT([done])])
+rm -f conftest.file
+])
+
+# Copyright (C) 2009-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_SILENT_RULES([DEFAULT])
+# --------------------------
+# Enable less verbose build rules; with the default set to DEFAULT
+# ("yes" being less verbose, "no" or empty being verbose).
+AC_DEFUN([AM_SILENT_RULES],
+[AC_ARG_ENABLE([silent-rules], [dnl
+AS_HELP_STRING(
+  [--enable-silent-rules],
+  [less verbose build output (undo: "make V=1")])
+AS_HELP_STRING(
+  [--disable-silent-rules],
+  [verbose build output (undo: "make V=0")])dnl
+])
+case $enable_silent_rules in @%:@ (((
+  yes) AM_DEFAULT_VERBOSITY=0;;
+   no) AM_DEFAULT_VERBOSITY=1;;
+    *) AM_DEFAULT_VERBOSITY=m4_if([$1], [yes], [0], [1]);;
+esac
+dnl
+dnl A few 'make' implementations (e.g., NonStop OS and NextStep)
+dnl do not support nested variable expansions.
+dnl See automake bug#9928 and bug#10237.
+am_make=${MAKE-make}
+AC_CACHE_CHECK([whether $am_make supports nested variables],
+   [am_cv_make_support_nested_variables],
+   [if AS_ECHO([['TRUE=$(BAR$(V))
+BAR0=false
+BAR1=true
+V=1
+am__doit:
+	@$(TRUE)
+.PHONY: am__doit']]) | $am_make -f - >/dev/null 2>&1; then
+  am_cv_make_support_nested_variables=yes
+else
+  am_cv_make_support_nested_variables=no
+fi])
+if test $am_cv_make_support_nested_variables = yes; then
+  dnl Using '$V' instead of '$(V)' breaks IRIX make.
+  AM_V='$(V)'
+  AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
+else
+  AM_V=$AM_DEFAULT_VERBOSITY
+  AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY
+fi
+AC_SUBST([AM_V])dnl
+AM_SUBST_NOTMAKE([AM_V])dnl
+AC_SUBST([AM_DEFAULT_V])dnl
+AM_SUBST_NOTMAKE([AM_DEFAULT_V])dnl
+AC_SUBST([AM_DEFAULT_VERBOSITY])dnl
+AM_BACKSLASH='\'
+AC_SUBST([AM_BACKSLASH])dnl
+_AM_SUBST_NOTMAKE([AM_BACKSLASH])dnl
+])
+
+# Copyright (C) 2001-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_PROG_INSTALL_STRIP
+# ---------------------
+# One issue with vendor 'install' (even GNU) is that you can't
+# specify the program used to strip binaries.  This is especially
+# annoying in cross-compiling environments, where the build's strip
+# is unlikely to handle the host's binaries.
+# Fortunately install-sh will honor a STRIPPROG variable, so we
+# always use install-sh in "make install-strip", and initialize
+# STRIPPROG with the value of the STRIP variable (set by the user).
+AC_DEFUN([AM_PROG_INSTALL_STRIP],
+[AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
+# Installed binaries are usually stripped using 'strip' when the user
+# run "make install-strip".  However 'strip' might not be the right
+# tool to use in cross-compilation environments, therefore Automake
+# will honor the 'STRIP' environment variable to overrule this program.
+dnl Don't test for $cross_compiling = yes, because it might be 'maybe'.
+if test "$cross_compiling" != no; then
+  AC_CHECK_TOOL([STRIP], [strip], :)
+fi
+INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
+AC_SUBST([INSTALL_STRIP_PROGRAM])])
+
+# Copyright (C) 2006-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# _AM_SUBST_NOTMAKE(VARIABLE)
+# ---------------------------
+# Prevent Automake from outputting VARIABLE = @VARIABLE@ in Makefile.in.
+# This macro is traced by Automake.
+AC_DEFUN([_AM_SUBST_NOTMAKE])
+
+# AM_SUBST_NOTMAKE(VARIABLE)
+# --------------------------
+# Public sister of _AM_SUBST_NOTMAKE.
+AC_DEFUN([AM_SUBST_NOTMAKE], [_AM_SUBST_NOTMAKE($@)])
+
+# Check how to create a tarball.                            -*- Autoconf -*-
+
+# Copyright (C) 2004-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# _AM_PROG_TAR(FORMAT)
+# --------------------
+# Check how to create a tarball in format FORMAT.
+# FORMAT should be one of 'v7', 'ustar', or 'pax'.
+#
+# Substitute a variable $(am__tar) that is a command
+# writing to stdout a FORMAT-tarball containing the directory
+# $tardir.
+#     tardir=directory && $(am__tar) > result.tar
+#
+# Substitute a variable $(am__untar) that extract such
+# a tarball read from stdin.
+#     $(am__untar) < result.tar
+#
+AC_DEFUN([_AM_PROG_TAR],
+[# Always define AMTAR for backward compatibility.  Yes, it's still used
+# in the wild :-(  We should find a proper way to deprecate it ...
+AC_SUBST([AMTAR], ['$${TAR-tar}'])
+
+# We'll loop over all known methods to create a tar archive until one works.
+_am_tools='gnutar m4_if([$1], [ustar], [plaintar]) pax cpio none'
+
+m4_if([$1], [v7],
+  [am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'],
+
+  [m4_case([$1],
+    [ustar],
+     [# The POSIX 1988 'ustar' format is defined with fixed-size fields.
+      # There is notably a 21 bits limit for the UID and the GID.  In fact,
+      # the 'pax' utility can hang on bigger UID/GID (see automake bug#8343
+      # and bug#13588).
+      am_max_uid=2097151 # 2^21 - 1
+      am_max_gid=$am_max_uid
+      # The $UID and $GID variables are not portable, so we need to resort
+      # to the POSIX-mandated id(1) utility.  Errors in the 'id' calls
+      # below are definitely unexpected, so allow the users to see them
+      # (that is, avoid stderr redirection).
+      am_uid=`id -u || echo unknown`
+      am_gid=`id -g || echo unknown`
+      AC_MSG_CHECKING([whether UID '$am_uid' is supported by ustar format])
+      if test $am_uid -le $am_max_uid; then
+         AC_MSG_RESULT([yes])
+      else
+         AC_MSG_RESULT([no])
+         _am_tools=none
+      fi
+      AC_MSG_CHECKING([whether GID '$am_gid' is supported by ustar format])
+      if test $am_gid -le $am_max_gid; then
+         AC_MSG_RESULT([yes])
+      else
+        AC_MSG_RESULT([no])
+        _am_tools=none
+      fi],
+
+  [pax],
+    [],
+
+  [m4_fatal([Unknown tar format])])
+
+  AC_MSG_CHECKING([how to create a $1 tar archive])
+
+  # Go ahead even if we have the value already cached.  We do so because we
+  # need to set the values for the 'am__tar' and 'am__untar' variables.
+  _am_tools=${am_cv_prog_tar_$1-$_am_tools}
+
+  for _am_tool in $_am_tools; do
+    case $_am_tool in
+    gnutar)
+      for _am_tar in tar gnutar gtar; do
+        AM_RUN_LOG([$_am_tar --version]) && break
+      done
+      am__tar="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$$tardir"'
+      am__tar_="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$tardir"'
+      am__untar="$_am_tar -xf -"
+      ;;
+    plaintar)
+      # Must skip GNU tar: if it does not support --format= it doesn't create
+      # ustar tarball either.
+      (tar --version) >/dev/null 2>&1 && continue
+      am__tar='tar chf - "$$tardir"'
+      am__tar_='tar chf - "$tardir"'
+      am__untar='tar xf -'
+      ;;
+    pax)
+      am__tar='pax -L -x $1 -w "$$tardir"'
+      am__tar_='pax -L -x $1 -w "$tardir"'
+      am__untar='pax -r'
+      ;;
+    cpio)
+      am__tar='find "$$tardir" -print | cpio -o -H $1 -L'
+      am__tar_='find "$tardir" -print | cpio -o -H $1 -L'
+      am__untar='cpio -i -H $1 -d'
+      ;;
+    none)
+      am__tar=false
+      am__tar_=false
+      am__untar=false
+      ;;
+    esac
+
+    # If the value was cached, stop now.  We just wanted to have am__tar
+    # and am__untar set.
+    test -n "${am_cv_prog_tar_$1}" && break
+
+    # tar/untar a dummy directory, and stop if the command works.
+    rm -rf conftest.dir
+    mkdir conftest.dir
+    echo GrepMe > conftest.dir/file
+    AM_RUN_LOG([tardir=conftest.dir && eval $am__tar_ >conftest.tar])
+    rm -rf conftest.dir
+    if test -s conftest.tar; then
+      AM_RUN_LOG([$am__untar <conftest.tar])
+      AM_RUN_LOG([cat conftest.dir/file])
+      grep GrepMe conftest.dir/file >/dev/null 2>&1 && break
+    fi
+  done
+  rm -rf conftest.dir
+
+  AC_CACHE_VAL([am_cv_prog_tar_$1], [am_cv_prog_tar_$1=$_am_tool])
+  AC_MSG_RESULT([$am_cv_prog_tar_$1])])
+
+AC_SUBST([am__tar])
+AC_SUBST([am__untar])
+]) # _AM_PROG_TAR
+
+m4_include([scripts/libtool.m4])
+m4_include([scripts/ltoptions.m4])
+m4_include([scripts/ltsugar.m4])
+m4_include([scripts/ltversion.m4])
+m4_include([scripts/lt~obsolete.m4])
diff --git a/Engine/lib/lpng/arm/arm_init.c b/Engine/lib/lpng/arm/arm_init.c
new file mode 100644
index 000000000..a34ecdbef
--- /dev/null
+++ b/Engine/lib/lpng/arm/arm_init.c
@@ -0,0 +1,136 @@
+
+/* arm_init.c - NEON optimised filter functions
+ *
+ * Copyright (c) 2018 Cosmin Truta
+ * Copyright (c) 2014,2016 Glenn Randers-Pehrson
+ * Written by Mans Rullgard, 2011.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+/* Below, after checking __linux__, various non-C90 POSIX 1003.1 functions are
+ * called.
+ */
+#define _POSIX_SOURCE 1
+
+#include "../pngpriv.h"
+
+#ifdef PNG_READ_SUPPORTED
+
+#if PNG_ARM_NEON_OPT > 0
+#ifdef PNG_ARM_NEON_CHECK_SUPPORTED /* Do run-time checks */
+/* WARNING: it is strongly recommended that you do not build libpng with
+ * run-time checks for CPU features if at all possible.  In the case of the ARM
+ * NEON instructions there is no processor-specific way of detecting the
+ * presence of the required support, therefore run-time detection is extremely
+ * OS specific.
+ *
+ * You may set the macro PNG_ARM_NEON_FILE to the file name of file containing
+ * a fragment of C source code which defines the png_have_neon function.  There
+ * are a number of implementations in contrib/arm-neon, but the only one that
+ * has partial support is contrib/arm-neon/linux.c - a generic Linux
+ * implementation which reads /proc/cpufino.
+ */
+#ifndef PNG_ARM_NEON_FILE
+#  ifdef __linux__
+#     define PNG_ARM_NEON_FILE "contrib/arm-neon/linux.c"
+#  endif
+#endif
+
+#ifdef PNG_ARM_NEON_FILE
+
+#include <signal.h> /* for sig_atomic_t */
+static int png_have_neon(png_structp png_ptr);
+#include PNG_ARM_NEON_FILE
+
+#else  /* PNG_ARM_NEON_FILE */
+#  error "PNG_ARM_NEON_FILE undefined: no support for run-time ARM NEON checks"
+#endif /* PNG_ARM_NEON_FILE */
+#endif /* PNG_ARM_NEON_CHECK_SUPPORTED */
+
+#ifndef PNG_ALIGNED_MEMORY_SUPPORTED
+#  error "ALIGNED_MEMORY is required; set: -DPNG_ALIGNED_MEMORY_SUPPORTED"
+#endif
+
+void
+png_init_filter_functions_neon(png_structp pp, unsigned int bpp)
+{
+   /* The switch statement is compiled in for ARM_NEON_API, the call to
+    * png_have_neon is compiled in for ARM_NEON_CHECK.  If both are defined
+    * the check is only performed if the API has not set the NEON option on
+    * or off explicitly.  In this case the check controls what happens.
+    *
+    * If the CHECK is not compiled in and the option is UNSET the behavior prior
+    * to 1.6.7 was to use the NEON code - this was a bug caused by having the
+    * wrong order of the 'ON' and 'default' cases.  UNSET now defaults to OFF,
+    * as documented in png.h
+    */
+   png_debug(1, "in png_init_filter_functions_neon");
+#ifdef PNG_ARM_NEON_API_SUPPORTED
+   switch ((pp->options >> PNG_ARM_NEON) & 3)
+   {
+      case PNG_OPTION_UNSET:
+         /* Allow the run-time check to execute if it has been enabled -
+          * thus both API and CHECK can be turned on.  If it isn't supported
+          * this case will fall through to the 'default' below, which just
+          * returns.
+          */
+#endif /* PNG_ARM_NEON_API_SUPPORTED */
+#ifdef PNG_ARM_NEON_CHECK_SUPPORTED
+         {
+            static volatile sig_atomic_t no_neon = -1; /* not checked */
+
+            if (no_neon < 0)
+               no_neon = !png_have_neon(pp);
+
+            if (no_neon)
+               return;
+         }
+#ifdef PNG_ARM_NEON_API_SUPPORTED
+         break;
+#endif
+#endif /* PNG_ARM_NEON_CHECK_SUPPORTED */
+
+#ifdef PNG_ARM_NEON_API_SUPPORTED
+      default: /* OFF or INVALID */
+         return;
+
+      case PNG_OPTION_ON:
+         /* Option turned on */
+         break;
+   }
+#endif
+
+   /* IMPORTANT: any new external functions used here must be declared using
+    * PNG_INTERNAL_FUNCTION in ../pngpriv.h.  This is required so that the
+    * 'prefix' option to configure works:
+    *
+    *    ./configure --with-libpng-prefix=foobar_
+    *
+    * Verify you have got this right by running the above command, doing a build
+    * and examining pngprefix.h; it must contain a #define for every external
+    * function you add.  (Notice that this happens automatically for the
+    * initialization function.)
+    */
+   pp->read_filter[PNG_FILTER_VALUE_UP-1] = png_read_filter_row_up_neon;
+
+   if (bpp == 3)
+   {
+      pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub3_neon;
+      pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg3_neon;
+      pp->read_filter[PNG_FILTER_VALUE_PAETH-1] =
+         png_read_filter_row_paeth3_neon;
+   }
+
+   else if (bpp == 4)
+   {
+      pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub4_neon;
+      pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg4_neon;
+      pp->read_filter[PNG_FILTER_VALUE_PAETH-1] =
+          png_read_filter_row_paeth4_neon;
+   }
+}
+#endif /* PNG_ARM_NEON_OPT > 0 */
+#endif /* READ */
diff --git a/Engine/lib/lpng/arm/filter_neon.S b/Engine/lib/lpng/arm/filter_neon.S
new file mode 100644
index 000000000..2308aad13
--- /dev/null
+++ b/Engine/lib/lpng/arm/filter_neon.S
@@ -0,0 +1,253 @@
+
+/* filter_neon.S - NEON optimised filter functions
+ *
+ * Copyright (c) 2018 Cosmin Truta
+ * Copyright (c) 2014,2017 Glenn Randers-Pehrson
+ * Written by Mans Rullgard, 2011.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+/* This is required to get the symbol renames, which are #defines, and the
+ * definitions (or not) of PNG_ARM_NEON_OPT and PNG_ARM_NEON_IMPLEMENTATION.
+ */
+#define PNG_VERSION_INFO_ONLY
+#include "../pngpriv.h"
+
+#if (defined(__linux__) || defined(__FreeBSD__)) && defined(__ELF__)
+.section .note.GNU-stack,"",%progbits /* mark stack as non-executable */
+#endif
+
+#ifdef PNG_READ_SUPPORTED
+
+/* Assembler NEON support - only works for 32-bit ARM (i.e. it does not work for
+ * ARM64).  The code in arm/filter_neon_intrinsics.c supports ARM64, however it
+ * only works if -mfpu=neon is specified on the GCC command line.  See pngpriv.h
+ * for the logic which sets PNG_USE_ARM_NEON_ASM:
+ */
+#if PNG_ARM_NEON_IMPLEMENTATION == 2 /* hand-coded assembler */
+
+#if PNG_ARM_NEON_OPT > 0
+
+#ifdef __ELF__
+#   define ELF
+#else
+#   define ELF @
+#endif
+
+        .arch armv7-a
+        .fpu  neon
+
+.macro  func    name, export=0
+    .macro endfunc
+ELF     .size   \name, . - \name
+        .endfunc
+        .purgem endfunc
+    .endm
+        .text
+
+        /* Explicitly specifying alignment here because some versions of
+         * GAS don't align code correctly.  This is harmless in correctly
+         * written versions of GAS.
+         */
+        .align 2
+
+    .if \export
+        .global \name
+    .endif
+ELF     .type   \name, STT_FUNC
+        .func   \name
+\name:
+.endm
+
+func    png_read_filter_row_sub4_neon, export=1
+        ldr             r3,  [r0, #4]           @ rowbytes
+        vmov.i8         d3,  #0
+1:
+        vld4.32         {d4[],d5[],d6[],d7[]},    [r1,:128]
+        vadd.u8         d0,  d3,  d4
+        vadd.u8         d1,  d0,  d5
+        vadd.u8         d2,  d1,  d6
+        vadd.u8         d3,  d2,  d7
+        vst4.32         {d0[0],d1[0],d2[0],d3[0]},[r1,:128]!
+        subs            r3,  r3,  #16
+        bgt             1b
+
+        bx              lr
+endfunc
+
+func    png_read_filter_row_sub3_neon, export=1
+        ldr             r3,  [r0, #4]           @ rowbytes
+        vmov.i8         d3,  #0
+        mov             r0,  r1
+        mov             r2,  #3
+        mov             r12, #12
+        vld1.8          {q11},    [r0], r12
+1:
+        vext.8          d5,  d22, d23, #3
+        vadd.u8         d0,  d3,  d22
+        vext.8          d6,  d22, d23, #6
+        vadd.u8         d1,  d0,  d5
+        vext.8          d7,  d23, d23, #1
+        vld1.8          {q11},    [r0], r12
+        vst1.32         {d0[0]},  [r1,:32], r2
+        vadd.u8         d2,  d1,  d6
+        vst1.32         {d1[0]},  [r1], r2
+        vadd.u8         d3,  d2,  d7
+        vst1.32         {d2[0]},  [r1], r2
+        vst1.32         {d3[0]},  [r1], r2
+        subs            r3,  r3,  #12
+        bgt             1b
+
+        bx              lr
+endfunc
+
+func    png_read_filter_row_up_neon, export=1
+        ldr             r3,  [r0, #4]           @ rowbytes
+1:
+        vld1.8          {q0}, [r1,:128]
+        vld1.8          {q1}, [r2,:128]!
+        vadd.u8         q0,  q0,  q1
+        vst1.8          {q0}, [r1,:128]!
+        subs            r3,  r3,  #16
+        bgt             1b
+
+        bx              lr
+endfunc
+
+func    png_read_filter_row_avg4_neon, export=1
+        ldr             r12, [r0, #4]           @ rowbytes
+        vmov.i8         d3,  #0
+1:
+        vld4.32         {d4[],d5[],d6[],d7[]},    [r1,:128]
+        vld4.32         {d16[],d17[],d18[],d19[]},[r2,:128]!
+        vhadd.u8        d0,  d3,  d16
+        vadd.u8         d0,  d0,  d4
+        vhadd.u8        d1,  d0,  d17
+        vadd.u8         d1,  d1,  d5
+        vhadd.u8        d2,  d1,  d18
+        vadd.u8         d2,  d2,  d6
+        vhadd.u8        d3,  d2,  d19
+        vadd.u8         d3,  d3,  d7
+        vst4.32         {d0[0],d1[0],d2[0],d3[0]},[r1,:128]!
+        subs            r12, r12, #16
+        bgt             1b
+
+        bx              lr
+endfunc
+
+func    png_read_filter_row_avg3_neon, export=1
+        push            {r4,lr}
+        ldr             r12, [r0, #4]           @ rowbytes
+        vmov.i8         d3,  #0
+        mov             r0,  r1
+        mov             r4,  #3
+        mov             lr,  #12
+        vld1.8          {q11},    [r0], lr
+1:
+        vld1.8          {q10},    [r2], lr
+        vext.8          d5,  d22, d23, #3
+        vhadd.u8        d0,  d3,  d20
+        vext.8          d17, d20, d21, #3
+        vadd.u8         d0,  d0,  d22
+        vext.8          d6,  d22, d23, #6
+        vhadd.u8        d1,  d0,  d17
+        vext.8          d18, d20, d21, #6
+        vadd.u8         d1,  d1,  d5
+        vext.8          d7,  d23, d23, #1
+        vld1.8          {q11},    [r0], lr
+        vst1.32         {d0[0]},  [r1,:32], r4
+        vhadd.u8        d2,  d1,  d18
+        vst1.32         {d1[0]},  [r1], r4
+        vext.8          d19, d21, d21, #1
+        vadd.u8         d2,  d2,  d6
+        vhadd.u8        d3,  d2,  d19
+        vst1.32         {d2[0]},  [r1], r4
+        vadd.u8         d3,  d3,  d7
+        vst1.32         {d3[0]},  [r1], r4
+        subs            r12, r12, #12
+        bgt             1b
+
+        pop             {r4,pc}
+endfunc
+
+.macro  paeth           rx,  ra,  rb,  rc
+        vaddl.u8        q12, \ra, \rb           @ a + b
+        vaddl.u8        q15, \rc, \rc           @ 2*c
+        vabdl.u8        q13, \rb, \rc           @ pa
+        vabdl.u8        q14, \ra, \rc           @ pb
+        vabd.u16        q15, q12, q15           @ pc
+        vcle.u16        q12, q13, q14           @ pa <= pb
+        vcle.u16        q13, q13, q15           @ pa <= pc
+        vcle.u16        q14, q14, q15           @ pb <= pc
+        vand            q12, q12, q13           @ pa <= pb && pa <= pc
+        vmovn.u16       d28, q14
+        vmovn.u16       \rx, q12
+        vbsl            d28, \rb, \rc
+        vbsl            \rx, \ra, d28
+.endm
+
+func    png_read_filter_row_paeth4_neon, export=1
+        ldr             r12, [r0, #4]           @ rowbytes
+        vmov.i8         d3,  #0
+        vmov.i8         d20, #0
+1:
+        vld4.32         {d4[],d5[],d6[],d7[]},    [r1,:128]
+        vld4.32         {d16[],d17[],d18[],d19[]},[r2,:128]!
+        paeth           d0,  d3,  d16, d20
+        vadd.u8         d0,  d0,  d4
+        paeth           d1,  d0,  d17, d16
+        vadd.u8         d1,  d1,  d5
+        paeth           d2,  d1,  d18, d17
+        vadd.u8         d2,  d2,  d6
+        paeth           d3,  d2,  d19, d18
+        vmov            d20, d19
+        vadd.u8         d3,  d3,  d7
+        vst4.32         {d0[0],d1[0],d2[0],d3[0]},[r1,:128]!
+        subs            r12, r12, #16
+        bgt             1b
+
+        bx              lr
+endfunc
+
+func    png_read_filter_row_paeth3_neon, export=1
+        push            {r4,lr}
+        ldr             r12, [r0, #4]           @ rowbytes
+        vmov.i8         d3,  #0
+        vmov.i8         d4,  #0
+        mov             r0,  r1
+        mov             r4,  #3
+        mov             lr,  #12
+        vld1.8          {q11},    [r0], lr
+1:
+        vld1.8          {q10},    [r2], lr
+        paeth           d0,  d3,  d20, d4
+        vext.8          d5,  d22, d23, #3
+        vadd.u8         d0,  d0,  d22
+        vext.8          d17, d20, d21, #3
+        paeth           d1,  d0,  d17, d20
+        vst1.32         {d0[0]},  [r1,:32], r4
+        vext.8          d6,  d22, d23, #6
+        vadd.u8         d1,  d1,  d5
+        vext.8          d18, d20, d21, #6
+        paeth           d2,  d1,  d18, d17
+        vext.8          d7,  d23, d23, #1
+        vld1.8          {q11},    [r0], lr
+        vst1.32         {d1[0]},  [r1], r4
+        vadd.u8         d2,  d2,  d6
+        vext.8          d19, d21, d21, #1
+        paeth           d3,  d2,  d19, d18
+        vst1.32         {d2[0]},  [r1], r4
+        vmov            d4,  d19
+        vadd.u8         d3,  d3,  d7
+        vst1.32         {d3[0]},  [r1], r4
+        subs            r12, r12, #12
+        bgt             1b
+
+        pop             {r4,pc}
+endfunc
+#endif /* PNG_ARM_NEON_OPT > 0 */
+#endif /* PNG_ARM_NEON_IMPLEMENTATION == 2 (assembler) */
+#endif /* READ */
diff --git a/Engine/lib/lpng/arm/filter_neon_intrinsics.c b/Engine/lib/lpng/arm/filter_neon_intrinsics.c
new file mode 100644
index 000000000..553c0be21
--- /dev/null
+++ b/Engine/lib/lpng/arm/filter_neon_intrinsics.c
@@ -0,0 +1,402 @@
+
+/* filter_neon_intrinsics.c - NEON optimised filter functions
+ *
+ * Copyright (c) 2018 Cosmin Truta
+ * Copyright (c) 2014,2016 Glenn Randers-Pehrson
+ * Written by James Yu <james.yu at linaro.org>, October 2013.
+ * Based on filter_neon.S, written by Mans Rullgard, 2011.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+#include "../pngpriv.h"
+
+#ifdef PNG_READ_SUPPORTED
+
+/* This code requires -mfpu=neon on the command line: */
+#if PNG_ARM_NEON_IMPLEMENTATION == 1 /* intrinsics code from pngpriv.h */
+
+#if defined(_MSC_VER) && defined(_M_ARM64)
+#  include <arm64_neon.h>
+#else
+#  include <arm_neon.h>
+#endif
+
+/* libpng row pointers are not necessarily aligned to any particular boundary,
+ * however this code will only work with appropriate alignment.  arm/arm_init.c
+ * checks for this (and will not compile unless it is done). This code uses
+ * variants of png_aligncast to avoid compiler warnings.
+ */
+#define png_ptr(type,pointer) png_aligncast(type *,pointer)
+#define png_ptrc(type,pointer) png_aligncastconst(const type *,pointer)
+
+/* The following relies on a variable 'temp_pointer' being declared with type
+ * 'type'.  This is written this way just to hide the GCC strict aliasing
+ * warning; note that the code is safe because there never is an alias between
+ * the input and output pointers.
+ *
+ * When compiling with MSVC ARM64, the png_ldr macro can't be passed directly
+ * to vst4_lane_u32, because of an internal compiler error inside MSVC.
+ * To avoid this compiler bug, we use a temporary variable (vdest_val) to store
+ * the result of png_ldr.
+ */
+#define png_ldr(type,pointer)\
+   (temp_pointer = png_ptr(type,pointer), *temp_pointer)
+
+#if PNG_ARM_NEON_OPT > 0
+
+void
+png_read_filter_row_up_neon(png_row_infop row_info, png_bytep row,
+   png_const_bytep prev_row)
+{
+   png_bytep rp = row;
+   png_bytep rp_stop = row + row_info->rowbytes;
+   png_const_bytep pp = prev_row;
+
+   png_debug(1, "in png_read_filter_row_up_neon");
+
+   for (; rp < rp_stop; rp += 16, pp += 16)
+   {
+      uint8x16_t qrp, qpp;
+
+      qrp = vld1q_u8(rp);
+      qpp = vld1q_u8(pp);
+      qrp = vaddq_u8(qrp, qpp);
+      vst1q_u8(rp, qrp);
+   }
+}
+
+void
+png_read_filter_row_sub3_neon(png_row_infop row_info, png_bytep row,
+   png_const_bytep prev_row)
+{
+   png_bytep rp = row;
+   png_bytep rp_stop = row + row_info->rowbytes;
+
+   uint8x16_t vtmp = vld1q_u8(rp);
+   uint8x8x2_t *vrpt = png_ptr(uint8x8x2_t, &vtmp);
+   uint8x8x2_t vrp = *vrpt;
+
+   uint8x8x4_t vdest;
+   vdest.val[3] = vdup_n_u8(0);
+
+   png_debug(1, "in png_read_filter_row_sub3_neon");
+
+   for (; rp < rp_stop;)
+   {
+      uint8x8_t vtmp1, vtmp2;
+      uint32x2_t *temp_pointer;
+
+      vtmp1 = vext_u8(vrp.val[0], vrp.val[1], 3);
+      vdest.val[0] = vadd_u8(vdest.val[3], vrp.val[0]);
+      vtmp2 = vext_u8(vrp.val[0], vrp.val[1], 6);
+      vdest.val[1] = vadd_u8(vdest.val[0], vtmp1);
+
+      vtmp1 = vext_u8(vrp.val[1], vrp.val[1], 1);
+      vdest.val[2] = vadd_u8(vdest.val[1], vtmp2);
+      vdest.val[3] = vadd_u8(vdest.val[2], vtmp1);
+
+      vtmp = vld1q_u8(rp + 12);
+      vrpt = png_ptr(uint8x8x2_t, &vtmp);
+      vrp = *vrpt;
+
+      vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[0]), 0);
+      rp += 3;
+      vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[1]), 0);
+      rp += 3;
+      vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[2]), 0);
+      rp += 3;
+      vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[3]), 0);
+      rp += 3;
+   }
+
+   PNG_UNUSED(prev_row)
+}
+
+void
+png_read_filter_row_sub4_neon(png_row_infop row_info, png_bytep row,
+   png_const_bytep prev_row)
+{
+   png_bytep rp = row;
+   png_bytep rp_stop = row + row_info->rowbytes;
+
+   uint8x8x4_t vdest;
+   vdest.val[3] = vdup_n_u8(0);
+
+   png_debug(1, "in png_read_filter_row_sub4_neon");
+
+   for (; rp < rp_stop; rp += 16)
+   {
+      uint32x2x4_t vtmp = vld4_u32(png_ptr(uint32_t,rp));
+      uint8x8x4_t *vrpt = png_ptr(uint8x8x4_t,&vtmp);
+      uint8x8x4_t vrp = *vrpt;
+      uint32x2x4_t *temp_pointer;
+      uint32x2x4_t vdest_val;
+
+      vdest.val[0] = vadd_u8(vdest.val[3], vrp.val[0]);
+      vdest.val[1] = vadd_u8(vdest.val[0], vrp.val[1]);
+      vdest.val[2] = vadd_u8(vdest.val[1], vrp.val[2]);
+      vdest.val[3] = vadd_u8(vdest.val[2], vrp.val[3]);
+
+      vdest_val = png_ldr(uint32x2x4_t, &vdest);
+      vst4_lane_u32(png_ptr(uint32_t,rp), vdest_val, 0);
+   }
+
+   PNG_UNUSED(prev_row)
+}
+
+void
+png_read_filter_row_avg3_neon(png_row_infop row_info, png_bytep row,
+   png_const_bytep prev_row)
+{
+   png_bytep rp = row;
+   png_const_bytep pp = prev_row;
+   png_bytep rp_stop = row + row_info->rowbytes;
+
+   uint8x16_t vtmp;
+   uint8x8x2_t *vrpt;
+   uint8x8x2_t vrp;
+   uint8x8x4_t vdest;
+   vdest.val[3] = vdup_n_u8(0);
+
+   vtmp = vld1q_u8(rp);
+   vrpt = png_ptr(uint8x8x2_t,&vtmp);
+   vrp = *vrpt;
+
+   png_debug(1, "in png_read_filter_row_avg3_neon");
+
+   for (; rp < rp_stop; pp += 12)
+   {
+      uint8x8_t vtmp1, vtmp2, vtmp3;
+
+      uint8x8x2_t *vppt;
+      uint8x8x2_t vpp;
+
+      uint32x2_t *temp_pointer;
+
+      vtmp = vld1q_u8(pp);
+      vppt = png_ptr(uint8x8x2_t,&vtmp);
+      vpp = *vppt;
+
+      vtmp1 = vext_u8(vrp.val[0], vrp.val[1], 3);
+      vdest.val[0] = vhadd_u8(vdest.val[3], vpp.val[0]);
+      vdest.val[0] = vadd_u8(vdest.val[0], vrp.val[0]);
+
+      vtmp2 = vext_u8(vpp.val[0], vpp.val[1], 3);
+      vtmp3 = vext_u8(vrp.val[0], vrp.val[1], 6);
+      vdest.val[1] = vhadd_u8(vdest.val[0], vtmp2);
+      vdest.val[1] = vadd_u8(vdest.val[1], vtmp1);
+
+      vtmp2 = vext_u8(vpp.val[0], vpp.val[1], 6);
+      vtmp1 = vext_u8(vrp.val[1], vrp.val[1], 1);
+
+      vtmp = vld1q_u8(rp + 12);
+      vrpt = png_ptr(uint8x8x2_t,&vtmp);
+      vrp = *vrpt;
+
+      vdest.val[2] = vhadd_u8(vdest.val[1], vtmp2);
+      vdest.val[2] = vadd_u8(vdest.val[2], vtmp3);
+
+      vtmp2 = vext_u8(vpp.val[1], vpp.val[1], 1);
+
+      vdest.val[3] = vhadd_u8(vdest.val[2], vtmp2);
+      vdest.val[3] = vadd_u8(vdest.val[3], vtmp1);
+
+      vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[0]), 0);
+      rp += 3;
+      vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[1]), 0);
+      rp += 3;
+      vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[2]), 0);
+      rp += 3;
+      vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[3]), 0);
+      rp += 3;
+   }
+}
+
+void
+png_read_filter_row_avg4_neon(png_row_infop row_info, png_bytep row,
+   png_const_bytep prev_row)
+{
+   png_bytep rp = row;
+   png_bytep rp_stop = row + row_info->rowbytes;
+   png_const_bytep pp = prev_row;
+
+   uint8x8x4_t vdest;
+   vdest.val[3] = vdup_n_u8(0);
+
+   png_debug(1, "in png_read_filter_row_avg4_neon");
+
+   for (; rp < rp_stop; rp += 16, pp += 16)
+   {
+      uint32x2x4_t vtmp;
+      uint8x8x4_t *vrpt, *vppt;
+      uint8x8x4_t vrp, vpp;
+      uint32x2x4_t *temp_pointer;
+      uint32x2x4_t vdest_val;
+
+      vtmp = vld4_u32(png_ptr(uint32_t,rp));
+      vrpt = png_ptr(uint8x8x4_t,&vtmp);
+      vrp = *vrpt;
+      vtmp = vld4_u32(png_ptrc(uint32_t,pp));
+      vppt = png_ptr(uint8x8x4_t,&vtmp);
+      vpp = *vppt;
+
+      vdest.val[0] = vhadd_u8(vdest.val[3], vpp.val[0]);
+      vdest.val[0] = vadd_u8(vdest.val[0], vrp.val[0]);
+      vdest.val[1] = vhadd_u8(vdest.val[0], vpp.val[1]);
+      vdest.val[1] = vadd_u8(vdest.val[1], vrp.val[1]);
+      vdest.val[2] = vhadd_u8(vdest.val[1], vpp.val[2]);
+      vdest.val[2] = vadd_u8(vdest.val[2], vrp.val[2]);
+      vdest.val[3] = vhadd_u8(vdest.val[2], vpp.val[3]);
+      vdest.val[3] = vadd_u8(vdest.val[3], vrp.val[3]);
+
+      vdest_val = png_ldr(uint32x2x4_t, &vdest);
+      vst4_lane_u32(png_ptr(uint32_t,rp), vdest_val, 0);
+   }
+}
+
+static uint8x8_t
+paeth(uint8x8_t a, uint8x8_t b, uint8x8_t c)
+{
+   uint8x8_t d, e;
+   uint16x8_t p1, pa, pb, pc;
+
+   p1 = vaddl_u8(a, b); /* a + b */
+   pc = vaddl_u8(c, c); /* c * 2 */
+   pa = vabdl_u8(b, c); /* pa */
+   pb = vabdl_u8(a, c); /* pb */
+   pc = vabdq_u16(p1, pc); /* pc */
+
+   p1 = vcleq_u16(pa, pb); /* pa <= pb */
+   pa = vcleq_u16(pa, pc); /* pa <= pc */
+   pb = vcleq_u16(pb, pc); /* pb <= pc */
+
+   p1 = vandq_u16(p1, pa); /* pa <= pb && pa <= pc */
+
+   d = vmovn_u16(pb);
+   e = vmovn_u16(p1);
+
+   d = vbsl_u8(d, b, c);
+   e = vbsl_u8(e, a, d);
+
+   return e;
+}
+
+void
+png_read_filter_row_paeth3_neon(png_row_infop row_info, png_bytep row,
+   png_const_bytep prev_row)
+{
+   png_bytep rp = row;
+   png_const_bytep pp = prev_row;
+   png_bytep rp_stop = row + row_info->rowbytes;
+
+   uint8x16_t vtmp;
+   uint8x8x2_t *vrpt;
+   uint8x8x2_t vrp;
+   uint8x8_t vlast = vdup_n_u8(0);
+   uint8x8x4_t vdest;
+   vdest.val[3] = vdup_n_u8(0);
+
+   vtmp = vld1q_u8(rp);
+   vrpt = png_ptr(uint8x8x2_t,&vtmp);
+   vrp = *vrpt;
+
+   png_debug(1, "in png_read_filter_row_paeth3_neon");
+
+   for (; rp < rp_stop; pp += 12)
+   {
+      uint8x8x2_t *vppt;
+      uint8x8x2_t vpp;
+      uint8x8_t vtmp1, vtmp2, vtmp3;
+      uint32x2_t *temp_pointer;
+
+      vtmp = vld1q_u8(pp);
+      vppt = png_ptr(uint8x8x2_t,&vtmp);
+      vpp = *vppt;
+
+      vdest.val[0] = paeth(vdest.val[3], vpp.val[0], vlast);
+      vdest.val[0] = vadd_u8(vdest.val[0], vrp.val[0]);
+
+      vtmp1 = vext_u8(vrp.val[0], vrp.val[1], 3);
+      vtmp2 = vext_u8(vpp.val[0], vpp.val[1], 3);
+      vdest.val[1] = paeth(vdest.val[0], vtmp2, vpp.val[0]);
+      vdest.val[1] = vadd_u8(vdest.val[1], vtmp1);
+
+      vtmp1 = vext_u8(vrp.val[0], vrp.val[1], 6);
+      vtmp3 = vext_u8(vpp.val[0], vpp.val[1], 6);
+      vdest.val[2] = paeth(vdest.val[1], vtmp3, vtmp2);
+      vdest.val[2] = vadd_u8(vdest.val[2], vtmp1);
+
+      vtmp1 = vext_u8(vrp.val[1], vrp.val[1], 1);
+      vtmp2 = vext_u8(vpp.val[1], vpp.val[1], 1);
+
+      vtmp = vld1q_u8(rp + 12);
+      vrpt = png_ptr(uint8x8x2_t,&vtmp);
+      vrp = *vrpt;
+
+      vdest.val[3] = paeth(vdest.val[2], vtmp2, vtmp3);
+      vdest.val[3] = vadd_u8(vdest.val[3], vtmp1);
+
+      vlast = vtmp2;
+
+      vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[0]), 0);
+      rp += 3;
+      vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[1]), 0);
+      rp += 3;
+      vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[2]), 0);
+      rp += 3;
+      vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[3]), 0);
+      rp += 3;
+   }
+}
+
+void
+png_read_filter_row_paeth4_neon(png_row_infop row_info, png_bytep row,
+   png_const_bytep prev_row)
+{
+   png_bytep rp = row;
+   png_bytep rp_stop = row + row_info->rowbytes;
+   png_const_bytep pp = prev_row;
+
+   uint8x8_t vlast = vdup_n_u8(0);
+   uint8x8x4_t vdest;
+   vdest.val[3] = vdup_n_u8(0);
+
+   png_debug(1, "in png_read_filter_row_paeth4_neon");
+
+   for (; rp < rp_stop; rp += 16, pp += 16)
+   {
+      uint32x2x4_t vtmp;
+      uint8x8x4_t *vrpt, *vppt;
+      uint8x8x4_t vrp, vpp;
+      uint32x2x4_t *temp_pointer;
+      uint32x2x4_t vdest_val;
+
+      vtmp = vld4_u32(png_ptr(uint32_t,rp));
+      vrpt = png_ptr(uint8x8x4_t,&vtmp);
+      vrp = *vrpt;
+      vtmp = vld4_u32(png_ptrc(uint32_t,pp));
+      vppt = png_ptr(uint8x8x4_t,&vtmp);
+      vpp = *vppt;
+
+      vdest.val[0] = paeth(vdest.val[3], vpp.val[0], vlast);
+      vdest.val[0] = vadd_u8(vdest.val[0], vrp.val[0]);
+      vdest.val[1] = paeth(vdest.val[0], vpp.val[1], vpp.val[0]);
+      vdest.val[1] = vadd_u8(vdest.val[1], vrp.val[1]);
+      vdest.val[2] = paeth(vdest.val[1], vpp.val[2], vpp.val[1]);
+      vdest.val[2] = vadd_u8(vdest.val[2], vrp.val[2]);
+      vdest.val[3] = paeth(vdest.val[2], vpp.val[3], vpp.val[2]);
+      vdest.val[3] = vadd_u8(vdest.val[3], vrp.val[3]);
+
+      vlast = vpp.val[3];
+
+      vdest_val = png_ldr(uint32x2x4_t, &vdest);
+      vst4_lane_u32(png_ptr(uint32_t,rp), vdest_val, 0);
+   }
+}
+
+#endif /* PNG_ARM_NEON_OPT > 0 */
+#endif /* PNG_ARM_NEON_IMPLEMENTATION == 1 (intrinsics) */
+#endif /* READ */
diff --git a/Engine/lib/lpng/arm/palette_neon_intrinsics.c b/Engine/lib/lpng/arm/palette_neon_intrinsics.c
new file mode 100644
index 000000000..b4d1fd2ab
--- /dev/null
+++ b/Engine/lib/lpng/arm/palette_neon_intrinsics.c
@@ -0,0 +1,149 @@
+
+/* palette_neon_intrinsics.c - NEON optimised palette expansion functions
+ *
+ * Copyright (c) 2018-2019 Cosmin Truta
+ * Copyright (c) 2017-2018 Arm Holdings. All rights reserved.
+ * Written by Richard Townsend <Richard.Townsend@arm.com>, February 2017.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+#include "../pngpriv.h"
+
+#if PNG_ARM_NEON_IMPLEMENTATION == 1
+
+#if defined(_MSC_VER) && defined(_M_ARM64)
+#  include <arm64_neon.h>
+#else
+#  include <arm_neon.h>
+#endif
+
+/* Build an RGBA8 palette from the separate RGB and alpha palettes. */
+void
+png_riffle_palette_neon(png_structrp png_ptr)
+{
+   png_const_colorp palette = png_ptr->palette;
+   png_bytep riffled_palette = png_ptr->riffled_palette;
+   png_const_bytep trans_alpha = png_ptr->trans_alpha;
+   int num_trans = png_ptr->num_trans;
+   int i;
+
+   png_debug(1, "in png_riffle_palette_neon");
+
+   /* Initially black, opaque. */
+   uint8x16x4_t w = {{
+      vdupq_n_u8(0x00),
+      vdupq_n_u8(0x00),
+      vdupq_n_u8(0x00),
+      vdupq_n_u8(0xff),
+   }};
+
+   /* First, riffle the RGB colours into an RGBA8 palette.
+    * The alpha component is set to opaque for now.
+    */
+   for (i = 0; i < 256; i += 16)
+   {
+      uint8x16x3_t v = vld3q_u8((png_const_bytep)(palette + i));
+      w.val[0] = v.val[0];
+      w.val[1] = v.val[1];
+      w.val[2] = v.val[2];
+      vst4q_u8(riffled_palette + (i << 2), w);
+   }
+
+   /* Fix up the missing transparency values. */
+   for (i = 0; i < num_trans; i++)
+      riffled_palette[(i << 2) + 3] = trans_alpha[i];
+}
+
+/* Expands a palettized row into RGBA8. */
+int
+png_do_expand_palette_rgba8_neon(png_structrp png_ptr, png_row_infop row_info,
+    png_const_bytep row, png_bytepp ssp, png_bytepp ddp)
+{
+   png_uint_32 row_width = row_info->width;
+   const png_uint_32 *riffled_palette =
+      (const png_uint_32 *)png_ptr->riffled_palette;
+   const png_int_32 pixels_per_chunk = 4;
+   int i;
+
+   png_debug(1, "in png_do_expand_palette_rgba8_neon");
+
+   if (row_width < pixels_per_chunk)
+      return 0;
+
+   /* This function originally gets the last byte of the output row.
+    * The NEON part writes forward from a given position, so we have
+    * to seek this back by 4 pixels x 4 bytes.
+    */
+   *ddp = *ddp - ((pixels_per_chunk * sizeof(png_uint_32)) - 1);
+
+   for (i = 0; i < row_width; i += pixels_per_chunk)
+   {
+      uint32x4_t cur;
+      png_bytep sp = *ssp - i, dp = *ddp - (i << 2);
+      cur = vld1q_dup_u32 (riffled_palette + *(sp - 3));
+      cur = vld1q_lane_u32(riffled_palette + *(sp - 2), cur, 1);
+      cur = vld1q_lane_u32(riffled_palette + *(sp - 1), cur, 2);
+      cur = vld1q_lane_u32(riffled_palette + *(sp - 0), cur, 3);
+      vst1q_u32((void *)dp, cur);
+   }
+   if (i != row_width)
+   {
+      /* Remove the amount that wasn't processed. */
+      i -= pixels_per_chunk;
+   }
+
+   /* Decrement output pointers. */
+   *ssp = *ssp - i;
+   *ddp = *ddp - (i << 2);
+   return i;
+}
+
+/* Expands a palettized row into RGB8. */
+int
+png_do_expand_palette_rgb8_neon(png_structrp png_ptr, png_row_infop row_info,
+    png_const_bytep row, png_bytepp ssp, png_bytepp ddp)
+{
+   png_uint_32 row_width = row_info->width;
+   png_const_bytep palette = (png_const_bytep)png_ptr->palette;
+   const png_uint_32 pixels_per_chunk = 8;
+   int i;
+
+   png_debug(1, "in png_do_expand_palette_rgb8_neon");
+
+   if (row_width <= pixels_per_chunk)
+      return 0;
+
+   /* Seeking this back by 8 pixels x 3 bytes. */
+   *ddp = *ddp - ((pixels_per_chunk * sizeof(png_color)) - 1);
+
+   for (i = 0; i < row_width; i += pixels_per_chunk)
+   {
+      uint8x8x3_t cur;
+      png_bytep sp = *ssp - i, dp = *ddp - ((i << 1) + i);
+      cur = vld3_dup_u8(palette + sizeof(png_color) * (*(sp - 7)));
+      cur = vld3_lane_u8(palette + sizeof(png_color) * (*(sp - 6)), cur, 1);
+      cur = vld3_lane_u8(palette + sizeof(png_color) * (*(sp - 5)), cur, 2);
+      cur = vld3_lane_u8(palette + sizeof(png_color) * (*(sp - 4)), cur, 3);
+      cur = vld3_lane_u8(palette + sizeof(png_color) * (*(sp - 3)), cur, 4);
+      cur = vld3_lane_u8(palette + sizeof(png_color) * (*(sp - 2)), cur, 5);
+      cur = vld3_lane_u8(palette + sizeof(png_color) * (*(sp - 1)), cur, 6);
+      cur = vld3_lane_u8(palette + sizeof(png_color) * (*(sp - 0)), cur, 7);
+      vst3_u8((void *)dp, cur);
+   }
+
+   if (i != row_width)
+   {
+      /* Remove the amount that wasn't processed. */
+      i -= pixels_per_chunk;
+   }
+
+   /* Decrement output pointers. */
+   *ssp = *ssp - i;
+   *ddp = *ddp - ((i << 1) + i);
+   return i;
+}
+
+#endif /* PNG_ARM_NEON_IMPLEMENTATION */
diff --git a/Engine/lib/lpng/autogen.sh b/Engine/lib/lpng/autogen.sh
new file mode 100755
index 000000000..a46daf65a
--- /dev/null
+++ b/Engine/lib/lpng/autogen.sh
@@ -0,0 +1,225 @@
+#! /bin/sh
+#
+# Run 'autoreconf' to build 'configure', 'Makefile.in' and other configure
+# control files.
+#
+# The first time this is run on a GIT checkout the only files that exist are
+# configure.ac and Makefile.am; all of the autotools support scripts are
+# missing.  They are instantiated with autoreconf --force --install.
+#
+# For regular ("tarball") distributions all the files should exist.  We do not
+# want them to be updated *under any circumstances*.  It should never be
+# necessary to run autogen.sh because ./configure --enable-maintainer-mode says
+# what to do if Makefile.am or configure.ac are changed.
+#
+# It is *probably* OK to update the files on a GIT checkout, because they have
+# come from the local tools, but leave that to the user who is assumed to know
+# whether it is ok or required.
+#
+# This script is intended to work without arguments, there are, however, hidden
+# arguments (a) for use while testing the script and (b) to fix up systems that
+# have been broken.  If (b) is required the script prompts for the correct
+# options.  For this reason the options are *NOT* documented in the help; this
+# is deliberate; UTSL.
+#
+clean=
+maintainer=
+while test $# -gt 0
+do
+   case "$1" in
+      --maintainer)
+         maintainer=1;;
+
+      --clean)
+         clean=1;;
+
+      *)
+         exec >&2
+         echo "$0: usage: ./autogen.sh"
+         if test -d .git
+         then
+            echo "  ./autogen.sh generates the configure script and"
+            echo "  Makefile.in, or refreshes them after changes to Makefile.am"
+            echo "  or configure.ac.  You may prefer to just run autoreconf."
+         elif test -z "$maintainer"
+         then
+            echo "  DO NOT RUN THIS SCRIPT."
+            echo "  If you need to change Makefile.am or configure.ac then you"
+            echo "  also need to run ./configure --enable-maintainer-mode and"
+            echo "  use the appropriate autotools, *NOT* this script, to update"
+            echo "  everything, please check the documentation of autoreconf."
+            echo "  WARNING: libpng is intentionally generated with a known,"
+            echo "  fixed, set of autotools.  It is known *NOT* to work with"
+            echo "  the collection of autotools distributed on highly reputable"
+            echo "  operating systems."
+            echo "  Remember: autotools is GNU software, you are expected to"
+            echo "  pay for support."
+         else
+            echo "  You have run autogen.sh with --maintainer enabled and you"
+            echo "  are not using a GIT distribution, then you have given an"
+            echo "  unrecognized argument.  This is not good. --maintainer"
+            echo "  switches off any assumptions that you might not know what"
+            echo "  you are doing."
+         fi
+         exit 1;;
+   esac
+
+   shift
+done
+#
+# First check for a set of the autotools files; if absent then this is assumed
+# to be a GIT version and the local autotools must be used.  If present this
+# is a tarball distribution and the script should not be used.  If partially
+# present bad things are happening.
+#
+# The autotools generated files:
+libpng_autotools_files="Makefile.in aclocal.m4 config.guess config.h.in
+   config.sub configure depcomp install-sh ltmain.sh missing\
+   test-driver"
+#
+# Files generated by versions of configue >2.68 or automake >1.13 (i.e. later
+# versions than those required by configure.ac):
+libpng_autotools_extra="compile config.h.in~"
+#
+# These are separate because 'maintainer-clean' does not remove them.
+libpng_libtool_files="scripts/libtool.m4 scripts/ltoptions.m4\
+   scripts/ltsugar.m4 scripts/ltversion.m4 scripts/lt~obsolete.m4"
+
+libpng_autotools_dirs="autom4te.cache" # not required
+#
+# The configure generated files:
+libpng_configure_files="Makefile config.h config.log config.status\
+   libpng-config libpng.pc libtool stamp-h1"
+
+libpng_configure_dirs=".deps"
+#
+# We must remove the configure generated files as well as the autotools
+# generated files if autotools are regenerated because otherwise if configure
+# has been run without "--enable-maintainer-mode" make can do a partial update
+# of Makefile.  These functions do the two bits of cleaning.
+clean_autotools(){
+   rm -rf $libpng_autotools_files $libpng_libtool_files $libpng_autotools_dirs
+   rm -rf $libpng_autotools_extra
+}
+
+clean_configure(){
+   rm -rf $libpng_configure_files $libpng_configure_dirs
+}
+#
+# Clean: remove everything (this is to help with testing)
+if test -n "$clean"
+then
+   clean_configure
+   if test -n "$maintainer"
+   then
+      clean_autotools
+   fi
+
+   exit 0
+fi
+#
+# Validate the distribution.
+libpng_autotools_file_found=
+libpng_autotools_file_missing=
+for file in $libpng_autotools_files
+do
+   if test -f  "$file"
+   then
+      libpng_autotools_file_found=1
+   else
+      libpng_autotools_file_missing=1
+   fi
+done
+#
+# Presence of one of these does not *invalidate* missing, but absence
+# invalidates found.
+for file in $libpng_libtool_files
+do
+   if test ! -f "$file"
+   then
+      libpng_autotools_file_missing=1
+   fi
+done
+#
+# The cache directory doesn't matter - it will be regenerated and does not exist
+# anyway in a tarball.
+#
+# Either everything is missing or everything is there, the --maintainer option
+# just changes this so that the mode is set to generate all the files.
+mode=
+if test -z "$libpng_autotools_file_found" -o -n "$maintainer"
+then
+   mode="autoreconf"
+else
+   if test -n "$libpng_autotools_file_missing"
+   then
+      mode="broken"
+   else
+      mode="configure"
+   fi
+fi
+#
+# So:
+case "$mode" in
+   autoreconf)
+      # Clean in case configure files exist
+      clean_configure
+      clean_autotools
+      # Everything must be initialized, so use --force
+      if autoreconf --warnings=all --force --install
+      then
+         missing=
+         for file in $libpng_autotools_files
+         do
+            test -f "$file" || missing=1
+         done
+         # ignore the cache directory
+         test -z "$missing" || {
+            exec >&2
+            echo "autoreconf was run, but did not produce all the expected"
+            echo "files.  It is likely that your autotools installation is"
+            echo "not compatible with that expected by libpng."
+            exit 1
+         }
+      else
+         exec >&2
+         echo "autoreconf failed: your version of autotools is incompatible"
+         echo "with this libpng version.  Please use a distributed archive"
+         echo "(which includes the autotools generated files) and run configure"
+         echo "instead."
+         exit 1
+      fi;;
+
+   configure)
+      if test -d .git
+      then
+         exec >&2
+         echo "ERROR: running autoreconf on an initialized system"
+         echo "  This is not necessary; it is only necessary to remake the"
+         echo "  autotools generated files if Makefile.am or configure.ac"
+         echo "  change and make does the right thing with:"
+         echo
+         echo "     ./configure --enable-maintainer-mode."
+         echo
+         echo "  You can run autoreconf yourself if you don't like maintainer"
+         echo "  mode and you can also just run autoreconf -f -i to initialize"
+         echo "  everything in the first place; this script is only for"
+         echo "  compatibility with prior releases."
+         exit 1
+      else
+         exec >&2
+         echo "autogen.sh is intended only to generate 'configure' on systems"
+         echo "that do not have it.  You have a complete 'configure', if you"
+         echo "need to change Makefile.am or configure.ac you also need to"
+         echo "run configure with the --enable-maintainer-mode option."
+         exit 1
+      fi;;
+
+   broken)
+      exec >&2
+      echo "Your system has a partial set of autotools generated files."
+      echo "autogen.sh is unable to proceed.  The full set of files is"
+      echo "contained in the libpng 'tar' distribution archive and you do"
+      echo "not need to run autogen.sh if you use it."
+      exit 1;;
+esac
diff --git a/Engine/lib/lpng/compile b/Engine/lib/lpng/compile
new file mode 100755
index 000000000..99e50524b
--- /dev/null
+++ b/Engine/lib/lpng/compile
@@ -0,0 +1,348 @@
+#! /bin/sh
+# Wrapper for compilers which do not understand '-c -o'.
+
+scriptversion=2018-03-07.03; # UTC
+
+# Copyright (C) 1999-2018 Free Software Foundation, Inc.
+# Written by Tom Tromey <tromey@cygnus.com>.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# This file is maintained in Automake, please report
+# bugs to <bug-automake@gnu.org> or send patches to
+# <automake-patches@gnu.org>.
+
+nl='
+'
+
+# We need space, tab and new line, in precisely that order.  Quoting is
+# there to prevent tools from complaining about whitespace usage.
+IFS=" ""	$nl"
+
+file_conv=
+
+# func_file_conv build_file lazy
+# Convert a $build file to $host form and store it in $file
+# Currently only supports Windows hosts. If the determined conversion
+# type is listed in (the comma separated) LAZY, no conversion will
+# take place.
+func_file_conv ()
+{
+  file=$1
+  case $file in
+    / | /[!/]*) # absolute file, and not a UNC file
+      if test -z "$file_conv"; then
+	# lazily determine how to convert abs files
+	case `uname -s` in
+	  MINGW*)
+	    file_conv=mingw
+	    ;;
+	  CYGWIN*)
+	    file_conv=cygwin
+	    ;;
+	  *)
+	    file_conv=wine
+	    ;;
+	esac
+      fi
+      case $file_conv/,$2, in
+	*,$file_conv,*)
+	  ;;
+	mingw/*)
+	  file=`cmd //C echo "$file " | sed -e 's/"\(.*\) " *$/\1/'`
+	  ;;
+	cygwin/*)
+	  file=`cygpath -m "$file" || echo "$file"`
+	  ;;
+	wine/*)
+	  file=`winepath -w "$file" || echo "$file"`
+	  ;;
+      esac
+      ;;
+  esac
+}
+
+# func_cl_dashL linkdir
+# Make cl look for libraries in LINKDIR
+func_cl_dashL ()
+{
+  func_file_conv "$1"
+  if test -z "$lib_path"; then
+    lib_path=$file
+  else
+    lib_path="$lib_path;$file"
+  fi
+  linker_opts="$linker_opts -LIBPATH:$file"
+}
+
+# func_cl_dashl library
+# Do a library search-path lookup for cl
+func_cl_dashl ()
+{
+  lib=$1
+  found=no
+  save_IFS=$IFS
+  IFS=';'
+  for dir in $lib_path $LIB
+  do
+    IFS=$save_IFS
+    if $shared && test -f "$dir/$lib.dll.lib"; then
+      found=yes
+      lib=$dir/$lib.dll.lib
+      break
+    fi
+    if test -f "$dir/$lib.lib"; then
+      found=yes
+      lib=$dir/$lib.lib
+      break
+    fi
+    if test -f "$dir/lib$lib.a"; then
+      found=yes
+      lib=$dir/lib$lib.a
+      break
+    fi
+  done
+  IFS=$save_IFS
+
+  if test "$found" != yes; then
+    lib=$lib.lib
+  fi
+}
+
+# func_cl_wrapper cl arg...
+# Adjust compile command to suit cl
+func_cl_wrapper ()
+{
+  # Assume a capable shell
+  lib_path=
+  shared=:
+  linker_opts=
+  for arg
+  do
+    if test -n "$eat"; then
+      eat=
+    else
+      case $1 in
+	-o)
+	  # configure might choose to run compile as 'compile cc -o foo foo.c'.
+	  eat=1
+	  case $2 in
+	    *.o | *.[oO][bB][jJ])
+	      func_file_conv "$2"
+	      set x "$@" -Fo"$file"
+	      shift
+	      ;;
+	    *)
+	      func_file_conv "$2"
+	      set x "$@" -Fe"$file"
+	      shift
+	      ;;
+	  esac
+	  ;;
+	-I)
+	  eat=1
+	  func_file_conv "$2" mingw
+	  set x "$@" -I"$file"
+	  shift
+	  ;;
+	-I*)
+	  func_file_conv "${1#-I}" mingw
+	  set x "$@" -I"$file"
+	  shift
+	  ;;
+	-l)
+	  eat=1
+	  func_cl_dashl "$2"
+	  set x "$@" "$lib"
+	  shift
+	  ;;
+	-l*)
+	  func_cl_dashl "${1#-l}"
+	  set x "$@" "$lib"
+	  shift
+	  ;;
+	-L)
+	  eat=1
+	  func_cl_dashL "$2"
+	  ;;
+	-L*)
+	  func_cl_dashL "${1#-L}"
+	  ;;
+	-static)
+	  shared=false
+	  ;;
+	-Wl,*)
+	  arg=${1#-Wl,}
+	  save_ifs="$IFS"; IFS=','
+	  for flag in $arg; do
+	    IFS="$save_ifs"
+	    linker_opts="$linker_opts $flag"
+	  done
+	  IFS="$save_ifs"
+	  ;;
+	-Xlinker)
+	  eat=1
+	  linker_opts="$linker_opts $2"
+	  ;;
+	-*)
+	  set x "$@" "$1"
+	  shift
+	  ;;
+	*.cc | *.CC | *.cxx | *.CXX | *.[cC]++)
+	  func_file_conv "$1"
+	  set x "$@" -Tp"$file"
+	  shift
+	  ;;
+	*.c | *.cpp | *.CPP | *.lib | *.LIB | *.Lib | *.OBJ | *.obj | *.[oO])
+	  func_file_conv "$1" mingw
+	  set x "$@" "$file"
+	  shift
+	  ;;
+	*)
+	  set x "$@" "$1"
+	  shift
+	  ;;
+      esac
+    fi
+    shift
+  done
+  if test -n "$linker_opts"; then
+    linker_opts="-link$linker_opts"
+  fi
+  exec "$@" $linker_opts
+  exit 1
+}
+
+eat=
+
+case $1 in
+  '')
+     echo "$0: No command.  Try '$0 --help' for more information." 1>&2
+     exit 1;
+     ;;
+  -h | --h*)
+    cat <<\EOF
+Usage: compile [--help] [--version] PROGRAM [ARGS]
+
+Wrapper for compilers which do not understand '-c -o'.
+Remove '-o dest.o' from ARGS, run PROGRAM with the remaining
+arguments, and rename the output as expected.
+
+If you are trying to build a whole package this is not the
+right script to run: please start by reading the file 'INSTALL'.
+
+Report bugs to <bug-automake@gnu.org>.
+EOF
+    exit $?
+    ;;
+  -v | --v*)
+    echo "compile $scriptversion"
+    exit $?
+    ;;
+  cl | *[/\\]cl | cl.exe | *[/\\]cl.exe | \
+  icl | *[/\\]icl | icl.exe | *[/\\]icl.exe )
+    func_cl_wrapper "$@"      # Doesn't return...
+    ;;
+esac
+
+ofile=
+cfile=
+
+for arg
+do
+  if test -n "$eat"; then
+    eat=
+  else
+    case $1 in
+      -o)
+	# configure might choose to run compile as 'compile cc -o foo foo.c'.
+	# So we strip '-o arg' only if arg is an object.
+	eat=1
+	case $2 in
+	  *.o | *.obj)
+	    ofile=$2
+	    ;;
+	  *)
+	    set x "$@" -o "$2"
+	    shift
+	    ;;
+	esac
+	;;
+      *.c)
+	cfile=$1
+	set x "$@" "$1"
+	shift
+	;;
+      *)
+	set x "$@" "$1"
+	shift
+	;;
+    esac
+  fi
+  shift
+done
+
+if test -z "$ofile" || test -z "$cfile"; then
+  # If no '-o' option was seen then we might have been invoked from a
+  # pattern rule where we don't need one.  That is ok -- this is a
+  # normal compilation that the losing compiler can handle.  If no
+  # '.c' file was seen then we are probably linking.  That is also
+  # ok.
+  exec "$@"
+fi
+
+# Name of file we expect compiler to create.
+cofile=`echo "$cfile" | sed 's|^.*[\\/]||; s|^[a-zA-Z]:||; s/\.c$/.o/'`
+
+# Create the lock directory.
+# Note: use '[/\\:.-]' here to ensure that we don't use the same name
+# that we are using for the .o file.  Also, base the name on the expected
+# object file name, since that is what matters with a parallel build.
+lockdir=`echo "$cofile" | sed -e 's|[/\\:.-]|_|g'`.d
+while true; do
+  if mkdir "$lockdir" >/dev/null 2>&1; then
+    break
+  fi
+  sleep 1
+done
+# FIXME: race condition here if user kills between mkdir and trap.
+trap "rmdir '$lockdir'; exit 1" 1 2 15
+
+# Run the compile.
+"$@"
+ret=$?
+
+if test -f "$cofile"; then
+  test "$cofile" = "$ofile" || mv "$cofile" "$ofile"
+elif test -f "${cofile}bj"; then
+  test "${cofile}bj" = "$ofile" || mv "${cofile}bj" "$ofile"
+fi
+
+rmdir "$lockdir"
+exit $ret
+
+# Local Variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'before-save-hook 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC0"
+# time-stamp-end: "; # UTC"
+# End:
diff --git a/Engine/lib/lpng/config.guess b/Engine/lib/lpng/config.guess
new file mode 100755
index 000000000..256083a70
--- /dev/null
+++ b/Engine/lib/lpng/config.guess
@@ -0,0 +1,1476 @@
+#! /bin/sh
+# Attempt to guess a canonical system name.
+#   Copyright 1992-2018 Free Software Foundation, Inc.
+
+timestamp='2018-03-08'
+
+# This file is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see <https://www.gnu.org/licenses/>.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that
+# program.  This Exception is an additional permission under section 7
+# of the GNU General Public License, version 3 ("GPLv3").
+#
+# Originally written by Per Bothner; maintained since 2000 by Ben Elliston.
+#
+# You can get the latest version of this script from:
+# https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess
+#
+# Please send patches to <config-patches@gnu.org>.
+
+
+me=`echo "$0" | sed -e 's,.*/,,'`
+
+usage="\
+Usage: $0 [OPTION]
+
+Output the configuration name of the system \`$me' is run on.
+
+Options:
+  -h, --help         print this help, then exit
+  -t, --time-stamp   print date of last modification, then exit
+  -v, --version      print version number, then exit
+
+Report bugs and patches to <config-patches@gnu.org>."
+
+version="\
+GNU config.guess ($timestamp)
+
+Originally written by Per Bothner.
+Copyright 1992-2018 Free Software Foundation, Inc.
+
+This is free software; see the source for copying conditions.  There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
+
+help="
+Try \`$me --help' for more information."
+
+# Parse command line
+while test $# -gt 0 ; do
+  case $1 in
+    --time-stamp | --time* | -t )
+       echo "$timestamp" ; exit ;;
+    --version | -v )
+       echo "$version" ; exit ;;
+    --help | --h* | -h )
+       echo "$usage"; exit ;;
+    -- )     # Stop option processing
+       shift; break ;;
+    - )	# Use stdin as input.
+       break ;;
+    -* )
+       echo "$me: invalid option $1$help" >&2
+       exit 1 ;;
+    * )
+       break ;;
+  esac
+done
+
+if test $# != 0; then
+  echo "$me: too many arguments$help" >&2
+  exit 1
+fi
+
+trap 'exit 1' 1 2 15
+
+# CC_FOR_BUILD -- compiler used by this script. Note that the use of a
+# compiler to aid in system detection is discouraged as it requires
+# temporary files to be created and, as you can see below, it is a
+# headache to deal with in a portable fashion.
+
+# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still
+# use `HOST_CC' if defined, but it is deprecated.
+
+# Portable tmp directory creation inspired by the Autoconf team.
+
+set_cc_for_build='
+trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ;
+trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ;
+: ${TMPDIR=/tmp} ;
+ { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } ||
+ { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } ||
+ { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } ||
+ { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ;
+dummy=$tmp/dummy ;
+tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ;
+case $CC_FOR_BUILD,$HOST_CC,$CC in
+ ,,)    echo "int x;" > "$dummy.c" ;
+	for c in cc gcc c89 c99 ; do
+	  if ($c -c -o "$dummy.o" "$dummy.c") >/dev/null 2>&1 ; then
+	     CC_FOR_BUILD="$c"; break ;
+	  fi ;
+	done ;
+	if test x"$CC_FOR_BUILD" = x ; then
+	  CC_FOR_BUILD=no_compiler_found ;
+	fi
+	;;
+ ,,*)   CC_FOR_BUILD=$CC ;;
+ ,*,*)  CC_FOR_BUILD=$HOST_CC ;;
+esac ; set_cc_for_build= ;'
+
+# This is needed to find uname on a Pyramid OSx when run in the BSD universe.
+# (ghazi@noc.rutgers.edu 1994-08-24)
+if (test -f /.attbin/uname) >/dev/null 2>&1 ; then
+	PATH=$PATH:/.attbin ; export PATH
+fi
+
+UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
+UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
+UNAME_SYSTEM=`(uname -s) 2>/dev/null`  || UNAME_SYSTEM=unknown
+UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
+
+case "$UNAME_SYSTEM" in
+Linux|GNU|GNU/*)
+	# If the system lacks a compiler, then just pick glibc.
+	# We could probably try harder.
+	LIBC=gnu
+
+	eval "$set_cc_for_build"
+	cat <<-EOF > "$dummy.c"
+	#include <features.h>
+	#if defined(__UCLIBC__)
+	LIBC=uclibc
+	#elif defined(__dietlibc__)
+	LIBC=dietlibc
+	#else
+	LIBC=gnu
+	#endif
+	EOF
+	eval "`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^LIBC' | sed 's, ,,g'`"
+
+	# If ldd exists, use it to detect musl libc.
+	if command -v ldd >/dev/null && \
+		ldd --version 2>&1 | grep -q ^musl
+	then
+	    LIBC=musl
+	fi
+	;;
+esac
+
+# Note: order is significant - the case branches are not exclusive.
+
+case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in
+    *:NetBSD:*:*)
+	# NetBSD (nbsd) targets should (where applicable) match one or
+	# more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*,
+	# *-*-netbsdecoff* and *-*-netbsd*.  For targets that recently
+	# switched to ELF, *-*-netbsd* would select the old
+	# object file format.  This provides both forward
+	# compatibility and a consistent mechanism for selecting the
+	# object file format.
+	#
+	# Note: NetBSD doesn't particularly care about the vendor
+	# portion of the name.  We always set it to "unknown".
+	sysctl="sysctl -n hw.machine_arch"
+	UNAME_MACHINE_ARCH=`(uname -p 2>/dev/null || \
+	    "/sbin/$sysctl" 2>/dev/null || \
+	    "/usr/sbin/$sysctl" 2>/dev/null || \
+	    echo unknown)`
+	case "$UNAME_MACHINE_ARCH" in
+	    armeb) machine=armeb-unknown ;;
+	    arm*) machine=arm-unknown ;;
+	    sh3el) machine=shl-unknown ;;
+	    sh3eb) machine=sh-unknown ;;
+	    sh5el) machine=sh5le-unknown ;;
+	    earmv*)
+		arch=`echo "$UNAME_MACHINE_ARCH" | sed -e 's,^e\(armv[0-9]\).*$,\1,'`
+		endian=`echo "$UNAME_MACHINE_ARCH" | sed -ne 's,^.*\(eb\)$,\1,p'`
+		machine="${arch}${endian}"-unknown
+		;;
+	    *) machine="$UNAME_MACHINE_ARCH"-unknown ;;
+	esac
+	# The Operating System including object format, if it has switched
+	# to ELF recently (or will in the future) and ABI.
+	case "$UNAME_MACHINE_ARCH" in
+	    earm*)
+		os=netbsdelf
+		;;
+	    arm*|i386|m68k|ns32k|sh3*|sparc|vax)
+		eval "$set_cc_for_build"
+		if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
+			| grep -q __ELF__
+		then
+		    # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).
+		    # Return netbsd for either.  FIX?
+		    os=netbsd
+		else
+		    os=netbsdelf
+		fi
+		;;
+	    *)
+		os=netbsd
+		;;
+	esac
+	# Determine ABI tags.
+	case "$UNAME_MACHINE_ARCH" in
+	    earm*)
+		expr='s/^earmv[0-9]/-eabi/;s/eb$//'
+		abi=`echo "$UNAME_MACHINE_ARCH" | sed -e "$expr"`
+		;;
+	esac
+	# The OS release
+	# Debian GNU/NetBSD machines have a different userland, and
+	# thus, need a distinct triplet. However, they do not need
+	# kernel version information, so it can be replaced with a
+	# suitable tag, in the style of linux-gnu.
+	case "$UNAME_VERSION" in
+	    Debian*)
+		release='-gnu'
+		;;
+	    *)
+		release=`echo "$UNAME_RELEASE" | sed -e 's/[-_].*//' | cut -d. -f1,2`
+		;;
+	esac
+	# Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:
+	# contains redundant information, the shorter form:
+	# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
+	echo "$machine-${os}${release}${abi}"
+	exit ;;
+    *:Bitrig:*:*)
+	UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'`
+	echo "$UNAME_MACHINE_ARCH"-unknown-bitrig"$UNAME_RELEASE"
+	exit ;;
+    *:OpenBSD:*:*)
+	UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'`
+	echo "$UNAME_MACHINE_ARCH"-unknown-openbsd"$UNAME_RELEASE"
+	exit ;;
+    *:LibertyBSD:*:*)
+	UNAME_MACHINE_ARCH=`arch | sed 's/^.*BSD\.//'`
+	echo "$UNAME_MACHINE_ARCH"-unknown-libertybsd"$UNAME_RELEASE"
+	exit ;;
+    *:MidnightBSD:*:*)
+	echo "$UNAME_MACHINE"-unknown-midnightbsd"$UNAME_RELEASE"
+	exit ;;
+    *:ekkoBSD:*:*)
+	echo "$UNAME_MACHINE"-unknown-ekkobsd"$UNAME_RELEASE"
+	exit ;;
+    *:SolidBSD:*:*)
+	echo "$UNAME_MACHINE"-unknown-solidbsd"$UNAME_RELEASE"
+	exit ;;
+    macppc:MirBSD:*:*)
+	echo powerpc-unknown-mirbsd"$UNAME_RELEASE"
+	exit ;;
+    *:MirBSD:*:*)
+	echo "$UNAME_MACHINE"-unknown-mirbsd"$UNAME_RELEASE"
+	exit ;;
+    *:Sortix:*:*)
+	echo "$UNAME_MACHINE"-unknown-sortix
+	exit ;;
+    *:Redox:*:*)
+	echo "$UNAME_MACHINE"-unknown-redox
+	exit ;;
+    mips:OSF1:*.*)
+        echo mips-dec-osf1
+        exit ;;
+    alpha:OSF1:*:*)
+	case $UNAME_RELEASE in
+	*4.0)
+		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
+		;;
+	*5.*)
+		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'`
+		;;
+	esac
+	# According to Compaq, /usr/sbin/psrinfo has been available on
+	# OSF/1 and Tru64 systems produced since 1995.  I hope that
+	# covers most systems running today.  This code pipes the CPU
+	# types through head -n 1, so we only detect the type of CPU 0.
+	ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^  The alpha \(.*\) processor.*$/\1/p' | head -n 1`
+	case "$ALPHA_CPU_TYPE" in
+	    "EV4 (21064)")
+		UNAME_MACHINE=alpha ;;
+	    "EV4.5 (21064)")
+		UNAME_MACHINE=alpha ;;
+	    "LCA4 (21066/21068)")
+		UNAME_MACHINE=alpha ;;
+	    "EV5 (21164)")
+		UNAME_MACHINE=alphaev5 ;;
+	    "EV5.6 (21164A)")
+		UNAME_MACHINE=alphaev56 ;;
+	    "EV5.6 (21164PC)")
+		UNAME_MACHINE=alphapca56 ;;
+	    "EV5.7 (21164PC)")
+		UNAME_MACHINE=alphapca57 ;;
+	    "EV6 (21264)")
+		UNAME_MACHINE=alphaev6 ;;
+	    "EV6.7 (21264A)")
+		UNAME_MACHINE=alphaev67 ;;
+	    "EV6.8CB (21264C)")
+		UNAME_MACHINE=alphaev68 ;;
+	    "EV6.8AL (21264B)")
+		UNAME_MACHINE=alphaev68 ;;
+	    "EV6.8CX (21264D)")
+		UNAME_MACHINE=alphaev68 ;;
+	    "EV6.9A (21264/EV69A)")
+		UNAME_MACHINE=alphaev69 ;;
+	    "EV7 (21364)")
+		UNAME_MACHINE=alphaev7 ;;
+	    "EV7.9 (21364A)")
+		UNAME_MACHINE=alphaev79 ;;
+	esac
+	# A Pn.n version is a patched version.
+	# A Vn.n version is a released version.
+	# A Tn.n version is a released field test version.
+	# A Xn.n version is an unreleased experimental baselevel.
+	# 1.2 uses "1.2" for uname -r.
+	echo "$UNAME_MACHINE"-dec-osf"`echo "$UNAME_RELEASE" | sed -e 's/^[PVTX]//' | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`"
+	# Reset EXIT trap before exiting to avoid spurious non-zero exit code.
+	exitcode=$?
+	trap '' 0
+	exit $exitcode ;;
+    Amiga*:UNIX_System_V:4.0:*)
+	echo m68k-unknown-sysv4
+	exit ;;
+    *:[Aa]miga[Oo][Ss]:*:*)
+	echo "$UNAME_MACHINE"-unknown-amigaos
+	exit ;;
+    *:[Mm]orph[Oo][Ss]:*:*)
+	echo "$UNAME_MACHINE"-unknown-morphos
+	exit ;;
+    *:OS/390:*:*)
+	echo i370-ibm-openedition
+	exit ;;
+    *:z/VM:*:*)
+	echo s390-ibm-zvmoe
+	exit ;;
+    *:OS400:*:*)
+	echo powerpc-ibm-os400
+	exit ;;
+    arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
+	echo arm-acorn-riscix"$UNAME_RELEASE"
+	exit ;;
+    arm*:riscos:*:*|arm*:RISCOS:*:*)
+	echo arm-unknown-riscos
+	exit ;;
+    SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)
+	echo hppa1.1-hitachi-hiuxmpp
+	exit ;;
+    Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)
+	# akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE.
+	if test "`(/bin/universe) 2>/dev/null`" = att ; then
+		echo pyramid-pyramid-sysv3
+	else
+		echo pyramid-pyramid-bsd
+	fi
+	exit ;;
+    NILE*:*:*:dcosx)
+	echo pyramid-pyramid-svr4
+	exit ;;
+    DRS?6000:unix:4.0:6*)
+	echo sparc-icl-nx6
+	exit ;;
+    DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*)
+	case `/usr/bin/uname -p` in
+	    sparc) echo sparc-icl-nx7; exit ;;
+	esac ;;
+    s390x:SunOS:*:*)
+	echo "$UNAME_MACHINE"-ibm-solaris2"`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`"
+	exit ;;
+    sun4H:SunOS:5.*:*)
+	echo sparc-hal-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`"
+	exit ;;
+    sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)
+	echo sparc-sun-solaris2"`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`"
+	exit ;;
+    i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*)
+	echo i386-pc-auroraux"$UNAME_RELEASE"
+	exit ;;
+    i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*)
+	eval "$set_cc_for_build"
+	SUN_ARCH=i386
+	# If there is a compiler, see if it is configured for 64-bit objects.
+	# Note that the Sun cc does not turn __LP64__ into 1 like gcc does.
+	# This test works for both compilers.
+	if [ "$CC_FOR_BUILD" != no_compiler_found ]; then
+	    if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \
+		(CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
+		grep IS_64BIT_ARCH >/dev/null
+	    then
+		SUN_ARCH=x86_64
+	    fi
+	fi
+	echo "$SUN_ARCH"-pc-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`"
+	exit ;;
+    sun4*:SunOS:6*:*)
+	# According to config.sub, this is the proper way to canonicalize
+	# SunOS6.  Hard to guess exactly what SunOS6 will be like, but
+	# it's likely to be more like Solaris than SunOS4.
+	echo sparc-sun-solaris3"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`"
+	exit ;;
+    sun4*:SunOS:*:*)
+	case "`/usr/bin/arch -k`" in
+	    Series*|S4*)
+		UNAME_RELEASE=`uname -v`
+		;;
+	esac
+	# Japanese Language versions have a version number like `4.1.3-JL'.
+	echo sparc-sun-sunos"`echo "$UNAME_RELEASE"|sed -e 's/-/_/'`"
+	exit ;;
+    sun3*:SunOS:*:*)
+	echo m68k-sun-sunos"$UNAME_RELEASE"
+	exit ;;
+    sun*:*:4.2BSD:*)
+	UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null`
+	test "x$UNAME_RELEASE" = x && UNAME_RELEASE=3
+	case "`/bin/arch`" in
+	    sun3)
+		echo m68k-sun-sunos"$UNAME_RELEASE"
+		;;
+	    sun4)
+		echo sparc-sun-sunos"$UNAME_RELEASE"
+		;;
+	esac
+	exit ;;
+    aushp:SunOS:*:*)
+	echo sparc-auspex-sunos"$UNAME_RELEASE"
+	exit ;;
+    # The situation for MiNT is a little confusing.  The machine name
+    # can be virtually everything (everything which is not
+    # "atarist" or "atariste" at least should have a processor
+    # > m68000).  The system name ranges from "MiNT" over "FreeMiNT"
+    # to the lowercase version "mint" (or "freemint").  Finally
+    # the system name "TOS" denotes a system which is actually not
+    # MiNT.  But MiNT is downward compatible to TOS, so this should
+    # be no problem.
+    atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)
+	echo m68k-atari-mint"$UNAME_RELEASE"
+	exit ;;
+    atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)
+	echo m68k-atari-mint"$UNAME_RELEASE"
+	exit ;;
+    *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)
+	echo m68k-atari-mint"$UNAME_RELEASE"
+	exit ;;
+    milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)
+	echo m68k-milan-mint"$UNAME_RELEASE"
+	exit ;;
+    hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)
+	echo m68k-hades-mint"$UNAME_RELEASE"
+	exit ;;
+    *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
+	echo m68k-unknown-mint"$UNAME_RELEASE"
+	exit ;;
+    m68k:machten:*:*)
+	echo m68k-apple-machten"$UNAME_RELEASE"
+	exit ;;
+    powerpc:machten:*:*)
+	echo powerpc-apple-machten"$UNAME_RELEASE"
+	exit ;;
+    RISC*:Mach:*:*)
+	echo mips-dec-mach_bsd4.3
+	exit ;;
+    RISC*:ULTRIX:*:*)
+	echo mips-dec-ultrix"$UNAME_RELEASE"
+	exit ;;
+    VAX*:ULTRIX*:*:*)
+	echo vax-dec-ultrix"$UNAME_RELEASE"
+	exit ;;
+    2020:CLIX:*:* | 2430:CLIX:*:*)
+	echo clipper-intergraph-clix"$UNAME_RELEASE"
+	exit ;;
+    mips:*:*:UMIPS | mips:*:*:RISCos)
+	eval "$set_cc_for_build"
+	sed 's/^	//' << EOF > "$dummy.c"
+#ifdef __cplusplus
+#include <stdio.h>  /* for printf() prototype */
+	int main (int argc, char *argv[]) {
+#else
+	int main (argc, argv) int argc; char *argv[]; {
+#endif
+	#if defined (host_mips) && defined (MIPSEB)
+	#if defined (SYSTYPE_SYSV)
+	  printf ("mips-mips-riscos%ssysv\\n", argv[1]); exit (0);
+	#endif
+	#if defined (SYSTYPE_SVR4)
+	  printf ("mips-mips-riscos%ssvr4\\n", argv[1]); exit (0);
+	#endif
+	#if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD)
+	  printf ("mips-mips-riscos%sbsd\\n", argv[1]); exit (0);
+	#endif
+	#endif
+	  exit (-1);
+	}
+EOF
+	$CC_FOR_BUILD -o "$dummy" "$dummy.c" &&
+	  dummyarg=`echo "$UNAME_RELEASE" | sed -n 's/\([0-9]*\).*/\1/p'` &&
+	  SYSTEM_NAME=`"$dummy" "$dummyarg"` &&
+	    { echo "$SYSTEM_NAME"; exit; }
+	echo mips-mips-riscos"$UNAME_RELEASE"
+	exit ;;
+    Motorola:PowerMAX_OS:*:*)
+	echo powerpc-motorola-powermax
+	exit ;;
+    Motorola:*:4.3:PL8-*)
+	echo powerpc-harris-powermax
+	exit ;;
+    Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*)
+	echo powerpc-harris-powermax
+	exit ;;
+    Night_Hawk:Power_UNIX:*:*)
+	echo powerpc-harris-powerunix
+	exit ;;
+    m88k:CX/UX:7*:*)
+	echo m88k-harris-cxux7
+	exit ;;
+    m88k:*:4*:R4*)
+	echo m88k-motorola-sysv4
+	exit ;;
+    m88k:*:3*:R3*)
+	echo m88k-motorola-sysv3
+	exit ;;
+    AViiON:dgux:*:*)
+	# DG/UX returns AViiON for all architectures
+	UNAME_PROCESSOR=`/usr/bin/uname -p`
+	if [ "$UNAME_PROCESSOR" = mc88100 ] || [ "$UNAME_PROCESSOR" = mc88110 ]
+	then
+	    if [ "$TARGET_BINARY_INTERFACE"x = m88kdguxelfx ] || \
+	       [ "$TARGET_BINARY_INTERFACE"x = x ]
+	    then
+		echo m88k-dg-dgux"$UNAME_RELEASE"
+	    else
+		echo m88k-dg-dguxbcs"$UNAME_RELEASE"
+	    fi
+	else
+	    echo i586-dg-dgux"$UNAME_RELEASE"
+	fi
+	exit ;;
+    M88*:DolphinOS:*:*)	# DolphinOS (SVR3)
+	echo m88k-dolphin-sysv3
+	exit ;;
+    M88*:*:R3*:*)
+	# Delta 88k system running SVR3
+	echo m88k-motorola-sysv3
+	exit ;;
+    XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3)
+	echo m88k-tektronix-sysv3
+	exit ;;
+    Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD)
+	echo m68k-tektronix-bsd
+	exit ;;
+    *:IRIX*:*:*)
+	echo mips-sgi-irix"`echo "$UNAME_RELEASE"|sed -e 's/-/_/g'`"
+	exit ;;
+    ????????:AIX?:[12].1:2)   # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
+	echo romp-ibm-aix     # uname -m gives an 8 hex-code CPU id
+	exit ;;               # Note that: echo "'`uname -s`'" gives 'AIX '
+    i*86:AIX:*:*)
+	echo i386-ibm-aix
+	exit ;;
+    ia64:AIX:*:*)
+	if [ -x /usr/bin/oslevel ] ; then
+		IBM_REV=`/usr/bin/oslevel`
+	else
+		IBM_REV="$UNAME_VERSION.$UNAME_RELEASE"
+	fi
+	echo "$UNAME_MACHINE"-ibm-aix"$IBM_REV"
+	exit ;;
+    *:AIX:2:3)
+	if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
+		eval "$set_cc_for_build"
+		sed 's/^		//' << EOF > "$dummy.c"
+		#include <sys/systemcfg.h>
+
+		main()
+			{
+			if (!__power_pc())
+				exit(1);
+			puts("powerpc-ibm-aix3.2.5");
+			exit(0);
+			}
+EOF
+		if $CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"`
+		then
+			echo "$SYSTEM_NAME"
+		else
+			echo rs6000-ibm-aix3.2.5
+		fi
+	elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
+		echo rs6000-ibm-aix3.2.4
+	else
+		echo rs6000-ibm-aix3.2
+	fi
+	exit ;;
+    *:AIX:*:[4567])
+	IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'`
+	if /usr/sbin/lsattr -El "$IBM_CPU_ID" | grep ' POWER' >/dev/null 2>&1; then
+		IBM_ARCH=rs6000
+	else
+		IBM_ARCH=powerpc
+	fi
+	if [ -x /usr/bin/lslpp ] ; then
+		IBM_REV=`/usr/bin/lslpp -Lqc bos.rte.libc |
+			   awk -F: '{ print $3 }' | sed s/[0-9]*$/0/`
+	else
+		IBM_REV="$UNAME_VERSION.$UNAME_RELEASE"
+	fi
+	echo "$IBM_ARCH"-ibm-aix"$IBM_REV"
+	exit ;;
+    *:AIX:*:*)
+	echo rs6000-ibm-aix
+	exit ;;
+    ibmrt:4.4BSD:*|romp-ibm:4.4BSD:*)
+	echo romp-ibm-bsd4.4
+	exit ;;
+    ibmrt:*BSD:*|romp-ibm:BSD:*)            # covers RT/PC BSD and
+	echo romp-ibm-bsd"$UNAME_RELEASE"   # 4.3 with uname added to
+	exit ;;                             # report: romp-ibm BSD 4.3
+    *:BOSX:*:*)
+	echo rs6000-bull-bosx
+	exit ;;
+    DPX/2?00:B.O.S.:*:*)
+	echo m68k-bull-sysv3
+	exit ;;
+    9000/[34]??:4.3bsd:1.*:*)
+	echo m68k-hp-bsd
+	exit ;;
+    hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*)
+	echo m68k-hp-bsd4.4
+	exit ;;
+    9000/[34678]??:HP-UX:*:*)
+	HPUX_REV=`echo "$UNAME_RELEASE"|sed -e 's/[^.]*.[0B]*//'`
+	case "$UNAME_MACHINE" in
+	    9000/31?)            HP_ARCH=m68000 ;;
+	    9000/[34]??)         HP_ARCH=m68k ;;
+	    9000/[678][0-9][0-9])
+		if [ -x /usr/bin/getconf ]; then
+		    sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
+		    sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
+		    case "$sc_cpu_version" in
+		      523) HP_ARCH=hppa1.0 ;; # CPU_PA_RISC1_0
+		      528) HP_ARCH=hppa1.1 ;; # CPU_PA_RISC1_1
+		      532)                      # CPU_PA_RISC2_0
+			case "$sc_kernel_bits" in
+			  32) HP_ARCH=hppa2.0n ;;
+			  64) HP_ARCH=hppa2.0w ;;
+			  '') HP_ARCH=hppa2.0 ;;   # HP-UX 10.20
+			esac ;;
+		    esac
+		fi
+		if [ "$HP_ARCH" = "" ]; then
+		    eval "$set_cc_for_build"
+		    sed 's/^		//' << EOF > "$dummy.c"
+
+		#define _HPUX_SOURCE
+		#include <stdlib.h>
+		#include <unistd.h>
+
+		int main ()
+		{
+		#if defined(_SC_KERNEL_BITS)
+		    long bits = sysconf(_SC_KERNEL_BITS);
+		#endif
+		    long cpu  = sysconf (_SC_CPU_VERSION);
+
+		    switch (cpu)
+			{
+			case CPU_PA_RISC1_0: puts ("hppa1.0"); break;
+			case CPU_PA_RISC1_1: puts ("hppa1.1"); break;
+			case CPU_PA_RISC2_0:
+		#if defined(_SC_KERNEL_BITS)
+			    switch (bits)
+				{
+				case 64: puts ("hppa2.0w"); break;
+				case 32: puts ("hppa2.0n"); break;
+				default: puts ("hppa2.0"); break;
+				} break;
+		#else  /* !defined(_SC_KERNEL_BITS) */
+			    puts ("hppa2.0"); break;
+		#endif
+			default: puts ("hppa1.0"); break;
+			}
+		    exit (0);
+		}
+EOF
+		    (CCOPTS="" $CC_FOR_BUILD -o "$dummy" "$dummy.c" 2>/dev/null) && HP_ARCH=`"$dummy"`
+		    test -z "$HP_ARCH" && HP_ARCH=hppa
+		fi ;;
+	esac
+	if [ "$HP_ARCH" = hppa2.0w ]
+	then
+	    eval "$set_cc_for_build"
+
+	    # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating
+	    # 32-bit code.  hppa64-hp-hpux* has the same kernel and a compiler
+	    # generating 64-bit code.  GNU and HP use different nomenclature:
+	    #
+	    # $ CC_FOR_BUILD=cc ./config.guess
+	    # => hppa2.0w-hp-hpux11.23
+	    # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess
+	    # => hppa64-hp-hpux11.23
+
+	    if echo __LP64__ | (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) |
+		grep -q __LP64__
+	    then
+		HP_ARCH=hppa2.0w
+	    else
+		HP_ARCH=hppa64
+	    fi
+	fi
+	echo "$HP_ARCH"-hp-hpux"$HPUX_REV"
+	exit ;;
+    ia64:HP-UX:*:*)
+	HPUX_REV=`echo "$UNAME_RELEASE"|sed -e 's/[^.]*.[0B]*//'`
+	echo ia64-hp-hpux"$HPUX_REV"
+	exit ;;
+    3050*:HI-UX:*:*)
+	eval "$set_cc_for_build"
+	sed 's/^	//' << EOF > "$dummy.c"
+	#include <unistd.h>
+	int
+	main ()
+	{
+	  long cpu = sysconf (_SC_CPU_VERSION);
+	  /* The order matters, because CPU_IS_HP_MC68K erroneously returns
+	     true for CPU_PA_RISC1_0.  CPU_IS_PA_RISC returns correct
+	     results, however.  */
+	  if (CPU_IS_PA_RISC (cpu))
+	    {
+	      switch (cpu)
+		{
+		  case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break;
+		  case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break;
+		  case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break;
+		  default: puts ("hppa-hitachi-hiuxwe2"); break;
+		}
+	    }
+	  else if (CPU_IS_HP_MC68K (cpu))
+	    puts ("m68k-hitachi-hiuxwe2");
+	  else puts ("unknown-hitachi-hiuxwe2");
+	  exit (0);
+	}
+EOF
+	$CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"` &&
+		{ echo "$SYSTEM_NAME"; exit; }
+	echo unknown-hitachi-hiuxwe2
+	exit ;;
+    9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:*)
+	echo hppa1.1-hp-bsd
+	exit ;;
+    9000/8??:4.3bsd:*:*)
+	echo hppa1.0-hp-bsd
+	exit ;;
+    *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*)
+	echo hppa1.0-hp-mpeix
+	exit ;;
+    hp7??:OSF1:*:* | hp8?[79]:OSF1:*:*)
+	echo hppa1.1-hp-osf
+	exit ;;
+    hp8??:OSF1:*:*)
+	echo hppa1.0-hp-osf
+	exit ;;
+    i*86:OSF1:*:*)
+	if [ -x /usr/sbin/sysversion ] ; then
+	    echo "$UNAME_MACHINE"-unknown-osf1mk
+	else
+	    echo "$UNAME_MACHINE"-unknown-osf1
+	fi
+	exit ;;
+    parisc*:Lites*:*:*)
+	echo hppa1.1-hp-lites
+	exit ;;
+    C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
+	echo c1-convex-bsd
+	exit ;;
+    C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)
+	if getsysinfo -f scalar_acc
+	then echo c32-convex-bsd
+	else echo c2-convex-bsd
+	fi
+	exit ;;
+    C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)
+	echo c34-convex-bsd
+	exit ;;
+    C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)
+	echo c38-convex-bsd
+	exit ;;
+    C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)
+	echo c4-convex-bsd
+	exit ;;
+    CRAY*Y-MP:*:*:*)
+	echo ymp-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
+	exit ;;
+    CRAY*[A-Z]90:*:*:*)
+	echo "$UNAME_MACHINE"-cray-unicos"$UNAME_RELEASE" \
+	| sed -e 's/CRAY.*\([A-Z]90\)/\1/' \
+	      -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \
+	      -e 's/\.[^.]*$/.X/'
+	exit ;;
+    CRAY*TS:*:*:*)
+	echo t90-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
+	exit ;;
+    CRAY*T3E:*:*:*)
+	echo alphaev5-cray-unicosmk"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
+	exit ;;
+    CRAY*SV1:*:*:*)
+	echo sv1-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
+	exit ;;
+    *:UNICOS/mp:*:*)
+	echo craynv-cray-unicosmp"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
+	exit ;;
+    F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)
+	FUJITSU_PROC=`uname -m | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`
+	FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'`
+	FUJITSU_REL=`echo "$UNAME_RELEASE" | sed -e 's/ /_/'`
+	echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
+	exit ;;
+    5000:UNIX_System_V:4.*:*)
+	FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'`
+	FUJITSU_REL=`echo "$UNAME_RELEASE" | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/ /_/'`
+	echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
+	exit ;;
+    i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
+	echo "$UNAME_MACHINE"-pc-bsdi"$UNAME_RELEASE"
+	exit ;;
+    sparc*:BSD/OS:*:*)
+	echo sparc-unknown-bsdi"$UNAME_RELEASE"
+	exit ;;
+    *:BSD/OS:*:*)
+	echo "$UNAME_MACHINE"-unknown-bsdi"$UNAME_RELEASE"
+	exit ;;
+    *:FreeBSD:*:*)
+	UNAME_PROCESSOR=`/usr/bin/uname -p`
+	case "$UNAME_PROCESSOR" in
+	    amd64)
+		UNAME_PROCESSOR=x86_64 ;;
+	    i386)
+		UNAME_PROCESSOR=i586 ;;
+	esac
+	echo "$UNAME_PROCESSOR"-unknown-freebsd"`echo "$UNAME_RELEASE"|sed -e 's/[-(].*//'`"
+	exit ;;
+    i*:CYGWIN*:*)
+	echo "$UNAME_MACHINE"-pc-cygwin
+	exit ;;
+    *:MINGW64*:*)
+	echo "$UNAME_MACHINE"-pc-mingw64
+	exit ;;
+    *:MINGW*:*)
+	echo "$UNAME_MACHINE"-pc-mingw32
+	exit ;;
+    *:MSYS*:*)
+	echo "$UNAME_MACHINE"-pc-msys
+	exit ;;
+    i*:PW*:*)
+	echo "$UNAME_MACHINE"-pc-pw32
+	exit ;;
+    *:Interix*:*)
+	case "$UNAME_MACHINE" in
+	    x86)
+		echo i586-pc-interix"$UNAME_RELEASE"
+		exit ;;
+	    authenticamd | genuineintel | EM64T)
+		echo x86_64-unknown-interix"$UNAME_RELEASE"
+		exit ;;
+	    IA64)
+		echo ia64-unknown-interix"$UNAME_RELEASE"
+		exit ;;
+	esac ;;
+    i*:UWIN*:*)
+	echo "$UNAME_MACHINE"-pc-uwin
+	exit ;;
+    amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*)
+	echo x86_64-unknown-cygwin
+	exit ;;
+    prep*:SunOS:5.*:*)
+	echo powerpcle-unknown-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`"
+	exit ;;
+    *:GNU:*:*)
+	# the GNU system
+	echo "`echo "$UNAME_MACHINE"|sed -e 's,[-/].*$,,'`-unknown-$LIBC`echo "$UNAME_RELEASE"|sed -e 's,/.*$,,'`"
+	exit ;;
+    *:GNU/*:*:*)
+	# other systems with GNU libc and userland
+	echo "$UNAME_MACHINE-unknown-`echo "$UNAME_SYSTEM" | sed 's,^[^/]*/,,' | tr "[:upper:]" "[:lower:]"``echo "$UNAME_RELEASE"|sed -e 's/[-(].*//'`-$LIBC"
+	exit ;;
+    i*86:Minix:*:*)
+	echo "$UNAME_MACHINE"-pc-minix
+	exit ;;
+    aarch64:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    aarch64_be:Linux:*:*)
+	UNAME_MACHINE=aarch64_be
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    alpha:Linux:*:*)
+	case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in
+	  EV5)   UNAME_MACHINE=alphaev5 ;;
+	  EV56)  UNAME_MACHINE=alphaev56 ;;
+	  PCA56) UNAME_MACHINE=alphapca56 ;;
+	  PCA57) UNAME_MACHINE=alphapca56 ;;
+	  EV6)   UNAME_MACHINE=alphaev6 ;;
+	  EV67)  UNAME_MACHINE=alphaev67 ;;
+	  EV68*) UNAME_MACHINE=alphaev68 ;;
+	esac
+	objdump --private-headers /bin/sh | grep -q ld.so.1
+	if test "$?" = 0 ; then LIBC=gnulibc1 ; fi
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    arc:Linux:*:* | arceb:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    arm*:Linux:*:*)
+	eval "$set_cc_for_build"
+	if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \
+	    | grep -q __ARM_EABI__
+	then
+	    echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	else
+	    if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \
+		| grep -q __ARM_PCS_VFP
+	    then
+		echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"eabi
+	    else
+		echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"eabihf
+	    fi
+	fi
+	exit ;;
+    avr32*:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    cris:Linux:*:*)
+	echo "$UNAME_MACHINE"-axis-linux-"$LIBC"
+	exit ;;
+    crisv32:Linux:*:*)
+	echo "$UNAME_MACHINE"-axis-linux-"$LIBC"
+	exit ;;
+    e2k:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    frv:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    hexagon:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    i*86:Linux:*:*)
+	echo "$UNAME_MACHINE"-pc-linux-"$LIBC"
+	exit ;;
+    ia64:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    k1om:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    m32r*:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    m68*:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    mips:Linux:*:* | mips64:Linux:*:*)
+	eval "$set_cc_for_build"
+	sed 's/^	//' << EOF > "$dummy.c"
+	#undef CPU
+	#undef ${UNAME_MACHINE}
+	#undef ${UNAME_MACHINE}el
+	#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
+	CPU=${UNAME_MACHINE}el
+	#else
+	#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
+	CPU=${UNAME_MACHINE}
+	#else
+	CPU=
+	#endif
+	#endif
+EOF
+	eval "`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^CPU'`"
+	test "x$CPU" != x && { echo "$CPU-unknown-linux-$LIBC"; exit; }
+	;;
+    mips64el:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    openrisc*:Linux:*:*)
+	echo or1k-unknown-linux-"$LIBC"
+	exit ;;
+    or32:Linux:*:* | or1k*:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    padre:Linux:*:*)
+	echo sparc-unknown-linux-"$LIBC"
+	exit ;;
+    parisc64:Linux:*:* | hppa64:Linux:*:*)
+	echo hppa64-unknown-linux-"$LIBC"
+	exit ;;
+    parisc:Linux:*:* | hppa:Linux:*:*)
+	# Look for CPU level
+	case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in
+	  PA7*) echo hppa1.1-unknown-linux-"$LIBC" ;;
+	  PA8*) echo hppa2.0-unknown-linux-"$LIBC" ;;
+	  *)    echo hppa-unknown-linux-"$LIBC" ;;
+	esac
+	exit ;;
+    ppc64:Linux:*:*)
+	echo powerpc64-unknown-linux-"$LIBC"
+	exit ;;
+    ppc:Linux:*:*)
+	echo powerpc-unknown-linux-"$LIBC"
+	exit ;;
+    ppc64le:Linux:*:*)
+	echo powerpc64le-unknown-linux-"$LIBC"
+	exit ;;
+    ppcle:Linux:*:*)
+	echo powerpcle-unknown-linux-"$LIBC"
+	exit ;;
+    riscv32:Linux:*:* | riscv64:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    s390:Linux:*:* | s390x:Linux:*:*)
+	echo "$UNAME_MACHINE"-ibm-linux-"$LIBC"
+	exit ;;
+    sh64*:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    sh*:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    sparc:Linux:*:* | sparc64:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    tile*:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    vax:Linux:*:*)
+	echo "$UNAME_MACHINE"-dec-linux-"$LIBC"
+	exit ;;
+    x86_64:Linux:*:*)
+	echo "$UNAME_MACHINE"-pc-linux-"$LIBC"
+	exit ;;
+    xtensa*:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    i*86:DYNIX/ptx:4*:*)
+	# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.
+	# earlier versions are messed up and put the nodename in both
+	# sysname and nodename.
+	echo i386-sequent-sysv4
+	exit ;;
+    i*86:UNIX_SV:4.2MP:2.*)
+	# Unixware is an offshoot of SVR4, but it has its own version
+	# number series starting with 2...
+	# I am not positive that other SVR4 systems won't match this,
+	# I just have to hope.  -- rms.
+	# Use sysv4.2uw... so that sysv4* matches it.
+	echo "$UNAME_MACHINE"-pc-sysv4.2uw"$UNAME_VERSION"
+	exit ;;
+    i*86:OS/2:*:*)
+	# If we were able to find `uname', then EMX Unix compatibility
+	# is probably installed.
+	echo "$UNAME_MACHINE"-pc-os2-emx
+	exit ;;
+    i*86:XTS-300:*:STOP)
+	echo "$UNAME_MACHINE"-unknown-stop
+	exit ;;
+    i*86:atheos:*:*)
+	echo "$UNAME_MACHINE"-unknown-atheos
+	exit ;;
+    i*86:syllable:*:*)
+	echo "$UNAME_MACHINE"-pc-syllable
+	exit ;;
+    i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*)
+	echo i386-unknown-lynxos"$UNAME_RELEASE"
+	exit ;;
+    i*86:*DOS:*:*)
+	echo "$UNAME_MACHINE"-pc-msdosdjgpp
+	exit ;;
+    i*86:*:4.*:*)
+	UNAME_REL=`echo "$UNAME_RELEASE" | sed 's/\/MP$//'`
+	if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
+		echo "$UNAME_MACHINE"-univel-sysv"$UNAME_REL"
+	else
+		echo "$UNAME_MACHINE"-pc-sysv"$UNAME_REL"
+	fi
+	exit ;;
+    i*86:*:5:[678]*)
+	# UnixWare 7.x, OpenUNIX and OpenServer 6.
+	case `/bin/uname -X | grep "^Machine"` in
+	    *486*)	     UNAME_MACHINE=i486 ;;
+	    *Pentium)	     UNAME_MACHINE=i586 ;;
+	    *Pent*|*Celeron) UNAME_MACHINE=i686 ;;
+	esac
+	echo "$UNAME_MACHINE-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}{$UNAME_VERSION}"
+	exit ;;
+    i*86:*:3.2:*)
+	if test -f /usr/options/cb.name; then
+		UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`
+		echo "$UNAME_MACHINE"-pc-isc"$UNAME_REL"
+	elif /bin/uname -X 2>/dev/null >/dev/null ; then
+		UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')`
+		(/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486
+		(/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \
+			&& UNAME_MACHINE=i586
+		(/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \
+			&& UNAME_MACHINE=i686
+		(/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \
+			&& UNAME_MACHINE=i686
+		echo "$UNAME_MACHINE"-pc-sco"$UNAME_REL"
+	else
+		echo "$UNAME_MACHINE"-pc-sysv32
+	fi
+	exit ;;
+    pc:*:*:*)
+	# Left here for compatibility:
+	# uname -m prints for DJGPP always 'pc', but it prints nothing about
+	# the processor, so we play safe by assuming i586.
+	# Note: whatever this is, it MUST be the same as what config.sub
+	# prints for the "djgpp" host, or else GDB configure will decide that
+	# this is a cross-build.
+	echo i586-pc-msdosdjgpp
+	exit ;;
+    Intel:Mach:3*:*)
+	echo i386-pc-mach3
+	exit ;;
+    paragon:*:*:*)
+	echo i860-intel-osf1
+	exit ;;
+    i860:*:4.*:*) # i860-SVR4
+	if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then
+	  echo i860-stardent-sysv"$UNAME_RELEASE" # Stardent Vistra i860-SVR4
+	else # Add other i860-SVR4 vendors below as they are discovered.
+	  echo i860-unknown-sysv"$UNAME_RELEASE"  # Unknown i860-SVR4
+	fi
+	exit ;;
+    mini*:CTIX:SYS*5:*)
+	# "miniframe"
+	echo m68010-convergent-sysv
+	exit ;;
+    mc68k:UNIX:SYSTEM5:3.51m)
+	echo m68k-convergent-sysv
+	exit ;;
+    M680?0:D-NIX:5.3:*)
+	echo m68k-diab-dnix
+	exit ;;
+    M68*:*:R3V[5678]*:*)
+	test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;;
+    3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0)
+	OS_REL=''
+	test -r /etc/.relid \
+	&& OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
+	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+	  && { echo i486-ncr-sysv4.3"$OS_REL"; exit; }
+	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
+	  && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;;
+    3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
+	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+	  && { echo i486-ncr-sysv4; exit; } ;;
+    NCR*:*:4.2:* | MPRAS*:*:4.2:*)
+	OS_REL='.3'
+	test -r /etc/.relid \
+	    && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
+	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+	    && { echo i486-ncr-sysv4.3"$OS_REL"; exit; }
+	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
+	    && { echo i586-ncr-sysv4.3"$OS_REL"; exit; }
+	/bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \
+	    && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;;
+    m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
+	echo m68k-unknown-lynxos"$UNAME_RELEASE"
+	exit ;;
+    mc68030:UNIX_System_V:4.*:*)
+	echo m68k-atari-sysv4
+	exit ;;
+    TSUNAMI:LynxOS:2.*:*)
+	echo sparc-unknown-lynxos"$UNAME_RELEASE"
+	exit ;;
+    rs6000:LynxOS:2.*:*)
+	echo rs6000-unknown-lynxos"$UNAME_RELEASE"
+	exit ;;
+    PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*)
+	echo powerpc-unknown-lynxos"$UNAME_RELEASE"
+	exit ;;
+    SM[BE]S:UNIX_SV:*:*)
+	echo mips-dde-sysv"$UNAME_RELEASE"
+	exit ;;
+    RM*:ReliantUNIX-*:*:*)
+	echo mips-sni-sysv4
+	exit ;;
+    RM*:SINIX-*:*:*)
+	echo mips-sni-sysv4
+	exit ;;
+    *:SINIX-*:*:*)
+	if uname -p 2>/dev/null >/dev/null ; then
+		UNAME_MACHINE=`(uname -p) 2>/dev/null`
+		echo "$UNAME_MACHINE"-sni-sysv4
+	else
+		echo ns32k-sni-sysv
+	fi
+	exit ;;
+    PENTIUM:*:4.0*:*)	# Unisys `ClearPath HMP IX 4000' SVR4/MP effort
+			# says <Richard.M.Bartel@ccMail.Census.GOV>
+	echo i586-unisys-sysv4
+	exit ;;
+    *:UNIX_System_V:4*:FTX*)
+	# From Gerald Hewes <hewes@openmarket.com>.
+	# How about differentiating between stratus architectures? -djm
+	echo hppa1.1-stratus-sysv4
+	exit ;;
+    *:*:*:FTX*)
+	# From seanf@swdc.stratus.com.
+	echo i860-stratus-sysv4
+	exit ;;
+    i*86:VOS:*:*)
+	# From Paul.Green@stratus.com.
+	echo "$UNAME_MACHINE"-stratus-vos
+	exit ;;
+    *:VOS:*:*)
+	# From Paul.Green@stratus.com.
+	echo hppa1.1-stratus-vos
+	exit ;;
+    mc68*:A/UX:*:*)
+	echo m68k-apple-aux"$UNAME_RELEASE"
+	exit ;;
+    news*:NEWS-OS:6*:*)
+	echo mips-sony-newsos6
+	exit ;;
+    R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
+	if [ -d /usr/nec ]; then
+		echo mips-nec-sysv"$UNAME_RELEASE"
+	else
+		echo mips-unknown-sysv"$UNAME_RELEASE"
+	fi
+	exit ;;
+    BeBox:BeOS:*:*)	# BeOS running on hardware made by Be, PPC only.
+	echo powerpc-be-beos
+	exit ;;
+    BeMac:BeOS:*:*)	# BeOS running on Mac or Mac clone, PPC only.
+	echo powerpc-apple-beos
+	exit ;;
+    BePC:BeOS:*:*)	# BeOS running on Intel PC compatible.
+	echo i586-pc-beos
+	exit ;;
+    BePC:Haiku:*:*)	# Haiku running on Intel PC compatible.
+	echo i586-pc-haiku
+	exit ;;
+    x86_64:Haiku:*:*)
+	echo x86_64-unknown-haiku
+	exit ;;
+    SX-4:SUPER-UX:*:*)
+	echo sx4-nec-superux"$UNAME_RELEASE"
+	exit ;;
+    SX-5:SUPER-UX:*:*)
+	echo sx5-nec-superux"$UNAME_RELEASE"
+	exit ;;
+    SX-6:SUPER-UX:*:*)
+	echo sx6-nec-superux"$UNAME_RELEASE"
+	exit ;;
+    SX-7:SUPER-UX:*:*)
+	echo sx7-nec-superux"$UNAME_RELEASE"
+	exit ;;
+    SX-8:SUPER-UX:*:*)
+	echo sx8-nec-superux"$UNAME_RELEASE"
+	exit ;;
+    SX-8R:SUPER-UX:*:*)
+	echo sx8r-nec-superux"$UNAME_RELEASE"
+	exit ;;
+    SX-ACE:SUPER-UX:*:*)
+	echo sxace-nec-superux"$UNAME_RELEASE"
+	exit ;;
+    Power*:Rhapsody:*:*)
+	echo powerpc-apple-rhapsody"$UNAME_RELEASE"
+	exit ;;
+    *:Rhapsody:*:*)
+	echo "$UNAME_MACHINE"-apple-rhapsody"$UNAME_RELEASE"
+	exit ;;
+    *:Darwin:*:*)
+	UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown
+	eval "$set_cc_for_build"
+	if test "$UNAME_PROCESSOR" = unknown ; then
+	    UNAME_PROCESSOR=powerpc
+	fi
+	if test "`echo "$UNAME_RELEASE" | sed -e 's/\..*//'`" -le 10 ; then
+	    if [ "$CC_FOR_BUILD" != no_compiler_found ]; then
+		if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \
+		       (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
+		       grep IS_64BIT_ARCH >/dev/null
+		then
+		    case $UNAME_PROCESSOR in
+			i386) UNAME_PROCESSOR=x86_64 ;;
+			powerpc) UNAME_PROCESSOR=powerpc64 ;;
+		    esac
+		fi
+		# On 10.4-10.6 one might compile for PowerPC via gcc -arch ppc
+		if (echo '#ifdef __POWERPC__'; echo IS_PPC; echo '#endif') | \
+		       (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
+		       grep IS_PPC >/dev/null
+		then
+		    UNAME_PROCESSOR=powerpc
+		fi
+	    fi
+	elif test "$UNAME_PROCESSOR" = i386 ; then
+	    # Avoid executing cc on OS X 10.9, as it ships with a stub
+	    # that puts up a graphical alert prompting to install
+	    # developer tools.  Any system running Mac OS X 10.7 or
+	    # later (Darwin 11 and later) is required to have a 64-bit
+	    # processor. This is not true of the ARM version of Darwin
+	    # that Apple uses in portable devices.
+	    UNAME_PROCESSOR=x86_64
+	fi
+	echo "$UNAME_PROCESSOR"-apple-darwin"$UNAME_RELEASE"
+	exit ;;
+    *:procnto*:*:* | *:QNX:[0123456789]*:*)
+	UNAME_PROCESSOR=`uname -p`
+	if test "$UNAME_PROCESSOR" = x86; then
+		UNAME_PROCESSOR=i386
+		UNAME_MACHINE=pc
+	fi
+	echo "$UNAME_PROCESSOR"-"$UNAME_MACHINE"-nto-qnx"$UNAME_RELEASE"
+	exit ;;
+    *:QNX:*:4*)
+	echo i386-pc-qnx
+	exit ;;
+    NEO-*:NONSTOP_KERNEL:*:*)
+	echo neo-tandem-nsk"$UNAME_RELEASE"
+	exit ;;
+    NSE-*:NONSTOP_KERNEL:*:*)
+	echo nse-tandem-nsk"$UNAME_RELEASE"
+	exit ;;
+    NSR-*:NONSTOP_KERNEL:*:*)
+	echo nsr-tandem-nsk"$UNAME_RELEASE"
+	exit ;;
+    NSV-*:NONSTOP_KERNEL:*:*)
+	echo nsv-tandem-nsk"$UNAME_RELEASE"
+	exit ;;
+    NSX-*:NONSTOP_KERNEL:*:*)
+	echo nsx-tandem-nsk"$UNAME_RELEASE"
+	exit ;;
+    *:NonStop-UX:*:*)
+	echo mips-compaq-nonstopux
+	exit ;;
+    BS2000:POSIX*:*:*)
+	echo bs2000-siemens-sysv
+	exit ;;
+    DS/*:UNIX_System_V:*:*)
+	echo "$UNAME_MACHINE"-"$UNAME_SYSTEM"-"$UNAME_RELEASE"
+	exit ;;
+    *:Plan9:*:*)
+	# "uname -m" is not consistent, so use $cputype instead. 386
+	# is converted to i386 for consistency with other x86
+	# operating systems.
+	if test "$cputype" = 386; then
+	    UNAME_MACHINE=i386
+	else
+	    UNAME_MACHINE="$cputype"
+	fi
+	echo "$UNAME_MACHINE"-unknown-plan9
+	exit ;;
+    *:TOPS-10:*:*)
+	echo pdp10-unknown-tops10
+	exit ;;
+    *:TENEX:*:*)
+	echo pdp10-unknown-tenex
+	exit ;;
+    KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)
+	echo pdp10-dec-tops20
+	exit ;;
+    XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*)
+	echo pdp10-xkl-tops20
+	exit ;;
+    *:TOPS-20:*:*)
+	echo pdp10-unknown-tops20
+	exit ;;
+    *:ITS:*:*)
+	echo pdp10-unknown-its
+	exit ;;
+    SEI:*:*:SEIUX)
+	echo mips-sei-seiux"$UNAME_RELEASE"
+	exit ;;
+    *:DragonFly:*:*)
+	echo "$UNAME_MACHINE"-unknown-dragonfly"`echo "$UNAME_RELEASE"|sed -e 's/[-(].*//'`"
+	exit ;;
+    *:*VMS:*:*)
+	UNAME_MACHINE=`(uname -p) 2>/dev/null`
+	case "$UNAME_MACHINE" in
+	    A*) echo alpha-dec-vms ; exit ;;
+	    I*) echo ia64-dec-vms ; exit ;;
+	    V*) echo vax-dec-vms ; exit ;;
+	esac ;;
+    *:XENIX:*:SysV)
+	echo i386-pc-xenix
+	exit ;;
+    i*86:skyos:*:*)
+	echo "$UNAME_MACHINE"-pc-skyos"`echo "$UNAME_RELEASE" | sed -e 's/ .*$//'`"
+	exit ;;
+    i*86:rdos:*:*)
+	echo "$UNAME_MACHINE"-pc-rdos
+	exit ;;
+    i*86:AROS:*:*)
+	echo "$UNAME_MACHINE"-pc-aros
+	exit ;;
+    x86_64:VMkernel:*:*)
+	echo "$UNAME_MACHINE"-unknown-esx
+	exit ;;
+    amd64:Isilon\ OneFS:*:*)
+	echo x86_64-unknown-onefs
+	exit ;;
+esac
+
+echo "$0: unable to guess system type" >&2
+
+case "$UNAME_MACHINE:$UNAME_SYSTEM" in
+    mips:Linux | mips64:Linux)
+	# If we got here on MIPS GNU/Linux, output extra information.
+	cat >&2 <<EOF
+
+NOTE: MIPS GNU/Linux systems require a C compiler to fully recognize
+the system type. Please install a C compiler and try again.
+EOF
+	;;
+esac
+
+cat >&2 <<EOF
+
+This script (version $timestamp), has failed to recognize the
+operating system you are using. If your script is old, overwrite *all*
+copies of config.guess and config.sub with the latest versions from:
+
+  https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess
+and
+  https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub
+
+If $0 has already been updated, send the following data and any
+information you think might be pertinent to config-patches@gnu.org to
+provide the necessary information to handle your system.
+
+config.guess timestamp = $timestamp
+
+uname -m = `(uname -m) 2>/dev/null || echo unknown`
+uname -r = `(uname -r) 2>/dev/null || echo unknown`
+uname -s = `(uname -s) 2>/dev/null || echo unknown`
+uname -v = `(uname -v) 2>/dev/null || echo unknown`
+
+/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null`
+/bin/uname -X     = `(/bin/uname -X) 2>/dev/null`
+
+hostinfo               = `(hostinfo) 2>/dev/null`
+/bin/universe          = `(/bin/universe) 2>/dev/null`
+/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null`
+/bin/arch              = `(/bin/arch) 2>/dev/null`
+/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null`
+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null`
+
+UNAME_MACHINE = "$UNAME_MACHINE"
+UNAME_RELEASE = "$UNAME_RELEASE"
+UNAME_SYSTEM  = "$UNAME_SYSTEM"
+UNAME_VERSION = "$UNAME_VERSION"
+EOF
+
+exit 1
+
+# Local variables:
+# eval: (add-hook 'before-save-hook 'time-stamp)
+# time-stamp-start: "timestamp='"
+# time-stamp-format: "%:y-%02m-%02d"
+# time-stamp-end: "'"
+# End:
diff --git a/Engine/lib/lpng/config.h.in b/Engine/lib/lpng/config.h.in
new file mode 100644
index 000000000..2931048bf
--- /dev/null
+++ b/Engine/lib/lpng/config.h.in
@@ -0,0 +1,126 @@
+/* config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#undef HAVE_DLFCN_H
+
+/* Define to 1 if you have the `feenableexcept' function. */
+#undef HAVE_FEENABLEEXCEPT
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#undef HAVE_INTTYPES_H
+
+/* Define to 1 if you have the `m' library (-lm). */
+#undef HAVE_LIBM
+
+/* Define to 1 if you have the `z' library (-lz). */
+#undef HAVE_LIBZ
+
+/* Define to 1 if you have the <memory.h> header file. */
+#undef HAVE_MEMORY_H
+
+/* Define to 1 if you have the `pow' function. */
+#undef HAVE_POW
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#undef HAVE_STDINT_H
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#undef HAVE_STDLIB_H
+
+/* Define to 1 if you have the <strings.h> header file. */
+#undef HAVE_STRINGS_H
+
+/* Define to 1 if you have the <string.h> header file. */
+#undef HAVE_STRING_H
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#undef HAVE_SYS_STAT_H
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#undef HAVE_SYS_TYPES_H
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#undef HAVE_UNISTD_H
+
+/* Define to the sub-directory where libtool stores uninstalled libraries. */
+#undef LT_OBJDIR
+
+/* Name of package */
+#undef PACKAGE
+
+/* Define to the address where bug reports for this package should be sent. */
+#undef PACKAGE_BUGREPORT
+
+/* Define to the full name of this package. */
+#undef PACKAGE_NAME
+
+/* Define to the full name and version of this package. */
+#undef PACKAGE_STRING
+
+/* Define to the one symbol short name of this package. */
+#undef PACKAGE_TARNAME
+
+/* Define to the home page for this package. */
+#undef PACKAGE_URL
+
+/* Define to the version of this package. */
+#undef PACKAGE_VERSION
+
+/* Turn on ARM Neon optimizations at run-time */
+#undef PNG_ARM_NEON_API_SUPPORTED
+
+/* Check for ARM Neon support at run-time */
+#undef PNG_ARM_NEON_CHECK_SUPPORTED
+
+/* Enable ARM Neon optimizations */
+#undef PNG_ARM_NEON_OPT
+
+/* Enable Intel SSE optimizations */
+#undef PNG_INTEL_SSE_OPT
+
+/* Turn on MIPS MSA optimizations at run-time */
+#undef PNG_MIPS_MSA_API_SUPPORTED
+
+/* Check for MIPS MSA support at run-time */
+#undef PNG_MIPS_MSA_CHECK_SUPPORTED
+
+/* Enable MIPS MSA optimizations */
+#undef PNG_MIPS_MSA_OPT
+
+/* Turn on POWERPC VSX optimizations at run-time */
+#undef PNG_POWERPC_VSX_API_SUPPORTED
+
+/* Check for POWERPC VSX support at run-time */
+#undef PNG_POWERPC_VSX_CHECK_SUPPORTED
+
+/* Enable POWERPC VSX optimizations */
+#undef PNG_POWERPC_VSX_OPT
+
+/* Define to 1 if you have the ANSI C header files. */
+#undef STDC_HEADERS
+
+/* Define to 1 if your <sys/time.h> declares `struct tm'. */
+#undef TM_IN_SYS_TIME
+
+/* Version number of package */
+#undef VERSION
+
+/* Define to empty if `const' does not conform to ANSI C. */
+#undef const
+
+/* Define to the equivalent of the C99 'restrict' keyword, or to
+   nothing if this is not supported.  Do not define if restrict is
+   supported directly.  */
+#undef restrict
+/* Work around a bug in Sun C++: it does not support _Restrict or
+   __restrict__, even though the corresponding Sun C compiler ends up with
+   "#define restrict _Restrict" or "#define restrict __restrict__" in the
+   previous line.  Perhaps some future version of Sun C++ will work with
+   restrict; if so, hopefully it defines __RESTRICT like Sun C does.  */
+#if defined __SUNPRO_CC && !defined __RESTRICT
+# define _Restrict
+# define __restrict__
+#endif
+
+/* Define to `unsigned int' if <sys/types.h> does not define. */
+#undef size_t
diff --git a/Engine/lib/lpng/config.sub b/Engine/lib/lpng/config.sub
new file mode 100755
index 000000000..9ccf09a7a
--- /dev/null
+++ b/Engine/lib/lpng/config.sub
@@ -0,0 +1,1801 @@
+#! /bin/sh
+# Configuration validation subroutine script.
+#   Copyright 1992-2018 Free Software Foundation, Inc.
+
+timestamp='2018-03-08'
+
+# This file is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see <https://www.gnu.org/licenses/>.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that
+# program.  This Exception is an additional permission under section 7
+# of the GNU General Public License, version 3 ("GPLv3").
+
+
+# Please send patches to <config-patches@gnu.org>.
+#
+# Configuration subroutine to validate and canonicalize a configuration type.
+# Supply the specified configuration type as an argument.
+# If it is invalid, we print an error message on stderr and exit with code 1.
+# Otherwise, we print the canonical config type on stdout and succeed.
+
+# You can get the latest version of this script from:
+# https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub
+
+# This file is supposed to be the same for all GNU packages
+# and recognize all the CPU types, system types and aliases
+# that are meaningful with *any* GNU software.
+# Each package is responsible for reporting which valid configurations
+# it does not support.  The user should be able to distinguish
+# a failure to support a valid configuration from a meaningless
+# configuration.
+
+# The goal of this file is to map all the various variations of a given
+# machine specification into a single specification in the form:
+#	CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
+# or in some cases, the newer four-part form:
+#	CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
+# It is wrong to echo any other type of specification.
+
+me=`echo "$0" | sed -e 's,.*/,,'`
+
+usage="\
+Usage: $0 [OPTION] CPU-MFR-OPSYS or ALIAS
+
+Canonicalize a configuration name.
+
+Options:
+  -h, --help         print this help, then exit
+  -t, --time-stamp   print date of last modification, then exit
+  -v, --version      print version number, then exit
+
+Report bugs and patches to <config-patches@gnu.org>."
+
+version="\
+GNU config.sub ($timestamp)
+
+Copyright 1992-2018 Free Software Foundation, Inc.
+
+This is free software; see the source for copying conditions.  There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
+
+help="
+Try \`$me --help' for more information."
+
+# Parse command line
+while test $# -gt 0 ; do
+  case $1 in
+    --time-stamp | --time* | -t )
+       echo "$timestamp" ; exit ;;
+    --version | -v )
+       echo "$version" ; exit ;;
+    --help | --h* | -h )
+       echo "$usage"; exit ;;
+    -- )     # Stop option processing
+       shift; break ;;
+    - )	# Use stdin as input.
+       break ;;
+    -* )
+       echo "$me: invalid option $1$help"
+       exit 1 ;;
+
+    *local*)
+       # First pass through any local machine types.
+       echo "$1"
+       exit ;;
+
+    * )
+       break ;;
+  esac
+done
+
+case $# in
+ 0) echo "$me: missing argument$help" >&2
+    exit 1;;
+ 1) ;;
+ *) echo "$me: too many arguments$help" >&2
+    exit 1;;
+esac
+
+# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any).
+# Here we must recognize all the valid KERNEL-OS combinations.
+maybe_os=`echo "$1" | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`
+case $maybe_os in
+  nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \
+  linux-musl* | linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \
+  knetbsd*-gnu* | netbsd*-gnu* | netbsd*-eabi* | \
+  kopensolaris*-gnu* | cloudabi*-eabi* | \
+  storm-chaos* | os2-emx* | rtmk-nova*)
+    os=-$maybe_os
+    basic_machine=`echo "$1" | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`
+    ;;
+  android-linux)
+    os=-linux-android
+    basic_machine=`echo "$1" | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`-unknown
+    ;;
+  *)
+    basic_machine=`echo "$1" | sed 's/-[^-]*$//'`
+    if [ "$basic_machine" != "$1" ]
+    then os=`echo "$1" | sed 's/.*-/-/'`
+    else os=; fi
+    ;;
+esac
+
+### Let's recognize common machines as not being operating systems so
+### that things like config.sub decstation-3100 work.  We also
+### recognize some manufacturers as not being operating systems, so we
+### can provide default operating systems below.
+case $os in
+	-sun*os*)
+		# Prevent following clause from handling this invalid input.
+		;;
+	-dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \
+	-att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \
+	-unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \
+	-convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\
+	-c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \
+	-harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \
+	-apple | -axis | -knuth | -cray | -microblaze*)
+		os=
+		basic_machine=$1
+		;;
+	-bluegene*)
+		os=-cnk
+		;;
+	-sim | -cisco | -oki | -wec | -winbond)
+		os=
+		basic_machine=$1
+		;;
+	-scout)
+		;;
+	-wrs)
+		os=-vxworks
+		basic_machine=$1
+		;;
+	-chorusos*)
+		os=-chorusos
+		basic_machine=$1
+		;;
+	-chorusrdb)
+		os=-chorusrdb
+		basic_machine=$1
+		;;
+	-hiux*)
+		os=-hiuxwe2
+		;;
+	-sco6)
+		os=-sco5v6
+		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco5)
+		os=-sco3.2v5
+		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco4)
+		os=-sco3.2v4
+		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco3.2.[4-9]*)
+		os=`echo $os | sed -e 's/sco3.2./sco3.2v/'`
+		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco3.2v[4-9]*)
+		# Don't forget version if it is 3.2v4 or newer.
+		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco5v6*)
+		# Don't forget version if it is 3.2v4 or newer.
+		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco*)
+		os=-sco3.2v2
+		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
+		;;
+	-udk*)
+		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
+		;;
+	-isc)
+		os=-isc2.2
+		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
+		;;
+	-clix*)
+		basic_machine=clipper-intergraph
+		;;
+	-isc*)
+		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
+		;;
+	-lynx*178)
+		os=-lynxos178
+		;;
+	-lynx*5)
+		os=-lynxos5
+		;;
+	-lynx*)
+		os=-lynxos
+		;;
+	-ptx*)
+		basic_machine=`echo "$1" | sed -e 's/86-.*/86-sequent/'`
+		;;
+	-psos*)
+		os=-psos
+		;;
+	-mint | -mint[0-9]*)
+		basic_machine=m68k-atari
+		os=-mint
+		;;
+esac
+
+# Decode aliases for certain CPU-COMPANY combinations.
+case $basic_machine in
+	# Recognize the basic CPU types without company name.
+	# Some are omitted here because they have special meanings below.
+	1750a | 580 \
+	| a29k \
+	| aarch64 | aarch64_be \
+	| alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \
+	| alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \
+	| am33_2.0 \
+	| arc | arceb \
+	| arm | arm[bl]e | arme[lb] | armv[2-8] | armv[3-8][lb] | armv7[arm] \
+	| avr | avr32 \
+	| ba \
+	| be32 | be64 \
+	| bfin \
+	| c4x | c8051 | clipper \
+	| d10v | d30v | dlx | dsp16xx \
+	| e2k | epiphany \
+	| fido | fr30 | frv | ft32 \
+	| h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
+	| hexagon \
+	| i370 | i860 | i960 | ia16 | ia64 \
+	| ip2k | iq2000 \
+	| k1om \
+	| le32 | le64 \
+	| lm32 \
+	| m32c | m32r | m32rle | m68000 | m68k | m88k \
+	| maxq | mb | microblaze | microblazeel | mcore | mep | metag \
+	| mips | mipsbe | mipseb | mipsel | mipsle \
+	| mips16 \
+	| mips64 | mips64el \
+	| mips64octeon | mips64octeonel \
+	| mips64orion | mips64orionel \
+	| mips64r5900 | mips64r5900el \
+	| mips64vr | mips64vrel \
+	| mips64vr4100 | mips64vr4100el \
+	| mips64vr4300 | mips64vr4300el \
+	| mips64vr5000 | mips64vr5000el \
+	| mips64vr5900 | mips64vr5900el \
+	| mipsisa32 | mipsisa32el \
+	| mipsisa32r2 | mipsisa32r2el \
+	| mipsisa32r6 | mipsisa32r6el \
+	| mipsisa64 | mipsisa64el \
+	| mipsisa64r2 | mipsisa64r2el \
+	| mipsisa64r6 | mipsisa64r6el \
+	| mipsisa64sb1 | mipsisa64sb1el \
+	| mipsisa64sr71k | mipsisa64sr71kel \
+	| mipsr5900 | mipsr5900el \
+	| mipstx39 | mipstx39el \
+	| mn10200 | mn10300 \
+	| moxie \
+	| mt \
+	| msp430 \
+	| nds32 | nds32le | nds32be \
+	| nios | nios2 | nios2eb | nios2el \
+	| ns16k | ns32k \
+	| open8 | or1k | or1knd | or32 \
+	| pdp10 | pj | pjl \
+	| powerpc | powerpc64 | powerpc64le | powerpcle \
+	| pru \
+	| pyramid \
+	| riscv32 | riscv64 \
+	| rl78 | rx \
+	| score \
+	| sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[234]eb | sheb | shbe | shle | sh[1234]le | sh3ele \
+	| sh64 | sh64le \
+	| sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \
+	| sparcv8 | sparcv9 | sparcv9b | sparcv9v \
+	| spu \
+	| tahoe | tic4x | tic54x | tic55x | tic6x | tic80 | tron \
+	| ubicom32 \
+	| v850 | v850e | v850e1 | v850e2 | v850es | v850e2v3 \
+	| visium \
+	| wasm32 \
+	| x86 | xc16x | xstormy16 | xtensa \
+	| z8k | z80)
+		basic_machine=$basic_machine-unknown
+		;;
+	c54x)
+		basic_machine=tic54x-unknown
+		;;
+	c55x)
+		basic_machine=tic55x-unknown
+		;;
+	c6x)
+		basic_machine=tic6x-unknown
+		;;
+	leon|leon[3-9])
+		basic_machine=sparc-$basic_machine
+		;;
+	m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x | nvptx | picochip)
+		basic_machine=$basic_machine-unknown
+		os=-none
+		;;
+	m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65)
+		;;
+	ms1)
+		basic_machine=mt-unknown
+		;;
+
+	strongarm | thumb | xscale)
+		basic_machine=arm-unknown
+		;;
+	xgate)
+		basic_machine=$basic_machine-unknown
+		os=-none
+		;;
+	xscaleeb)
+		basic_machine=armeb-unknown
+		;;
+
+	xscaleel)
+		basic_machine=armel-unknown
+		;;
+
+	# We use `pc' rather than `unknown'
+	# because (1) that's what they normally are, and
+	# (2) the word "unknown" tends to confuse beginning users.
+	i*86 | x86_64)
+	  basic_machine=$basic_machine-pc
+	  ;;
+	# Object if more than one company name word.
+	*-*-*)
+		echo Invalid configuration \`"$1"\': machine \`"$basic_machine"\' not recognized 1>&2
+		exit 1
+		;;
+	# Recognize the basic CPU types with company name.
+	580-* \
+	| a29k-* \
+	| aarch64-* | aarch64_be-* \
+	| alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \
+	| alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \
+	| alphapca5[67]-* | alpha64pca5[67]-* | arc-* | arceb-* \
+	| arm-*  | armbe-* | armle-* | armeb-* | armv*-* \
+	| avr-* | avr32-* \
+	| ba-* \
+	| be32-* | be64-* \
+	| bfin-* | bs2000-* \
+	| c[123]* | c30-* | [cjt]90-* | c4x-* \
+	| c8051-* | clipper-* | craynv-* | cydra-* \
+	| d10v-* | d30v-* | dlx-* \
+	| e2k-* | elxsi-* \
+	| f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \
+	| h8300-* | h8500-* \
+	| hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \
+	| hexagon-* \
+	| i*86-* | i860-* | i960-* | ia16-* | ia64-* \
+	| ip2k-* | iq2000-* \
+	| k1om-* \
+	| le32-* | le64-* \
+	| lm32-* \
+	| m32c-* | m32r-* | m32rle-* \
+	| m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \
+	| m88110-* | m88k-* | maxq-* | mcore-* | metag-* \
+	| microblaze-* | microblazeel-* \
+	| mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \
+	| mips16-* \
+	| mips64-* | mips64el-* \
+	| mips64octeon-* | mips64octeonel-* \
+	| mips64orion-* | mips64orionel-* \
+	| mips64r5900-* | mips64r5900el-* \
+	| mips64vr-* | mips64vrel-* \
+	| mips64vr4100-* | mips64vr4100el-* \
+	| mips64vr4300-* | mips64vr4300el-* \
+	| mips64vr5000-* | mips64vr5000el-* \
+	| mips64vr5900-* | mips64vr5900el-* \
+	| mipsisa32-* | mipsisa32el-* \
+	| mipsisa32r2-* | mipsisa32r2el-* \
+	| mipsisa32r6-* | mipsisa32r6el-* \
+	| mipsisa64-* | mipsisa64el-* \
+	| mipsisa64r2-* | mipsisa64r2el-* \
+	| mipsisa64r6-* | mipsisa64r6el-* \
+	| mipsisa64sb1-* | mipsisa64sb1el-* \
+	| mipsisa64sr71k-* | mipsisa64sr71kel-* \
+	| mipsr5900-* | mipsr5900el-* \
+	| mipstx39-* | mipstx39el-* \
+	| mmix-* \
+	| mt-* \
+	| msp430-* \
+	| nds32-* | nds32le-* | nds32be-* \
+	| nios-* | nios2-* | nios2eb-* | nios2el-* \
+	| none-* | np1-* | ns16k-* | ns32k-* \
+	| open8-* \
+	| or1k*-* \
+	| orion-* \
+	| pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \
+	| powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \
+	| pru-* \
+	| pyramid-* \
+	| riscv32-* | riscv64-* \
+	| rl78-* | romp-* | rs6000-* | rx-* \
+	| sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \
+	| shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \
+	| sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \
+	| sparclite-* \
+	| sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | sv1-* | sx*-* \
+	| tahoe-* \
+	| tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \
+	| tile*-* \
+	| tron-* \
+	| ubicom32-* \
+	| v850-* | v850e-* | v850e1-* | v850es-* | v850e2-* | v850e2v3-* \
+	| vax-* \
+	| visium-* \
+	| wasm32-* \
+	| we32k-* \
+	| x86-* | x86_64-* | xc16x-* | xps100-* \
+	| xstormy16-* | xtensa*-* \
+	| ymp-* \
+	| z8k-* | z80-*)
+		;;
+	# Recognize the basic CPU types without company name, with glob match.
+	xtensa*)
+		basic_machine=$basic_machine-unknown
+		;;
+	# Recognize the various machine names and aliases which stand
+	# for a CPU type and a company and sometimes even an OS.
+	386bsd)
+		basic_machine=i386-pc
+		os=-bsd
+		;;
+	3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc)
+		basic_machine=m68000-att
+		;;
+	3b*)
+		basic_machine=we32k-att
+		;;
+	a29khif)
+		basic_machine=a29k-amd
+		os=-udi
+		;;
+	abacus)
+		basic_machine=abacus-unknown
+		;;
+	adobe68k)
+		basic_machine=m68010-adobe
+		os=-scout
+		;;
+	alliant | fx80)
+		basic_machine=fx80-alliant
+		;;
+	altos | altos3068)
+		basic_machine=m68k-altos
+		;;
+	am29k)
+		basic_machine=a29k-none
+		os=-bsd
+		;;
+	amd64)
+		basic_machine=x86_64-pc
+		;;
+	amd64-*)
+		basic_machine=x86_64-`echo "$basic_machine" | sed 's/^[^-]*-//'`
+		;;
+	amdahl)
+		basic_machine=580-amdahl
+		os=-sysv
+		;;
+	amiga | amiga-*)
+		basic_machine=m68k-unknown
+		;;
+	amigaos | amigados)
+		basic_machine=m68k-unknown
+		os=-amigaos
+		;;
+	amigaunix | amix)
+		basic_machine=m68k-unknown
+		os=-sysv4
+		;;
+	apollo68)
+		basic_machine=m68k-apollo
+		os=-sysv
+		;;
+	apollo68bsd)
+		basic_machine=m68k-apollo
+		os=-bsd
+		;;
+	aros)
+		basic_machine=i386-pc
+		os=-aros
+		;;
+	asmjs)
+		basic_machine=asmjs-unknown
+		;;
+	aux)
+		basic_machine=m68k-apple
+		os=-aux
+		;;
+	balance)
+		basic_machine=ns32k-sequent
+		os=-dynix
+		;;
+	blackfin)
+		basic_machine=bfin-unknown
+		os=-linux
+		;;
+	blackfin-*)
+		basic_machine=bfin-`echo "$basic_machine" | sed 's/^[^-]*-//'`
+		os=-linux
+		;;
+	bluegene*)
+		basic_machine=powerpc-ibm
+		os=-cnk
+		;;
+	c54x-*)
+		basic_machine=tic54x-`echo "$basic_machine" | sed 's/^[^-]*-//'`
+		;;
+	c55x-*)
+		basic_machine=tic55x-`echo "$basic_machine" | sed 's/^[^-]*-//'`
+		;;
+	c6x-*)
+		basic_machine=tic6x-`echo "$basic_machine" | sed 's/^[^-]*-//'`
+		;;
+	c90)
+		basic_machine=c90-cray
+		os=-unicos
+		;;
+	cegcc)
+		basic_machine=arm-unknown
+		os=-cegcc
+		;;
+	convex-c1)
+		basic_machine=c1-convex
+		os=-bsd
+		;;
+	convex-c2)
+		basic_machine=c2-convex
+		os=-bsd
+		;;
+	convex-c32)
+		basic_machine=c32-convex
+		os=-bsd
+		;;
+	convex-c34)
+		basic_machine=c34-convex
+		os=-bsd
+		;;
+	convex-c38)
+		basic_machine=c38-convex
+		os=-bsd
+		;;
+	cray | j90)
+		basic_machine=j90-cray
+		os=-unicos
+		;;
+	craynv)
+		basic_machine=craynv-cray
+		os=-unicosmp
+		;;
+	cr16 | cr16-*)
+		basic_machine=cr16-unknown
+		os=-elf
+		;;
+	crds | unos)
+		basic_machine=m68k-crds
+		;;
+	crisv32 | crisv32-* | etraxfs*)
+		basic_machine=crisv32-axis
+		;;
+	cris | cris-* | etrax*)
+		basic_machine=cris-axis
+		;;
+	crx)
+		basic_machine=crx-unknown
+		os=-elf
+		;;
+	da30 | da30-*)
+		basic_machine=m68k-da30
+		;;
+	decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn)
+		basic_machine=mips-dec
+		;;
+	decsystem10* | dec10*)
+		basic_machine=pdp10-dec
+		os=-tops10
+		;;
+	decsystem20* | dec20*)
+		basic_machine=pdp10-dec
+		os=-tops20
+		;;
+	delta | 3300 | motorola-3300 | motorola-delta \
+	      | 3300-motorola | delta-motorola)
+		basic_machine=m68k-motorola
+		;;
+	delta88)
+		basic_machine=m88k-motorola
+		os=-sysv3
+		;;
+	dicos)
+		basic_machine=i686-pc
+		os=-dicos
+		;;
+	djgpp)
+		basic_machine=i586-pc
+		os=-msdosdjgpp
+		;;
+	dpx20 | dpx20-*)
+		basic_machine=rs6000-bull
+		os=-bosx
+		;;
+	dpx2*)
+		basic_machine=m68k-bull
+		os=-sysv3
+		;;
+	e500v[12])
+		basic_machine=powerpc-unknown
+		os=$os"spe"
+		;;
+	e500v[12]-*)
+		basic_machine=powerpc-`echo "$basic_machine" | sed 's/^[^-]*-//'`
+		os=$os"spe"
+		;;
+	ebmon29k)
+		basic_machine=a29k-amd
+		os=-ebmon
+		;;
+	elxsi)
+		basic_machine=elxsi-elxsi
+		os=-bsd
+		;;
+	encore | umax | mmax)
+		basic_machine=ns32k-encore
+		;;
+	es1800 | OSE68k | ose68k | ose | OSE)
+		basic_machine=m68k-ericsson
+		os=-ose
+		;;
+	fx2800)
+		basic_machine=i860-alliant
+		;;
+	genix)
+		basic_machine=ns32k-ns
+		;;
+	gmicro)
+		basic_machine=tron-gmicro
+		os=-sysv
+		;;
+	go32)
+		basic_machine=i386-pc
+		os=-go32
+		;;
+	h3050r* | hiux*)
+		basic_machine=hppa1.1-hitachi
+		os=-hiuxwe2
+		;;
+	h8300hms)
+		basic_machine=h8300-hitachi
+		os=-hms
+		;;
+	h8300xray)
+		basic_machine=h8300-hitachi
+		os=-xray
+		;;
+	h8500hms)
+		basic_machine=h8500-hitachi
+		os=-hms
+		;;
+	harris)
+		basic_machine=m88k-harris
+		os=-sysv3
+		;;
+	hp300-*)
+		basic_machine=m68k-hp
+		;;
+	hp300bsd)
+		basic_machine=m68k-hp
+		os=-bsd
+		;;
+	hp300hpux)
+		basic_machine=m68k-hp
+		os=-hpux
+		;;
+	hp3k9[0-9][0-9] | hp9[0-9][0-9])
+		basic_machine=hppa1.0-hp
+		;;
+	hp9k2[0-9][0-9] | hp9k31[0-9])
+		basic_machine=m68000-hp
+		;;
+	hp9k3[2-9][0-9])
+		basic_machine=m68k-hp
+		;;
+	hp9k6[0-9][0-9] | hp6[0-9][0-9])
+		basic_machine=hppa1.0-hp
+		;;
+	hp9k7[0-79][0-9] | hp7[0-79][0-9])
+		basic_machine=hppa1.1-hp
+		;;
+	hp9k78[0-9] | hp78[0-9])
+		# FIXME: really hppa2.0-hp
+		basic_machine=hppa1.1-hp
+		;;
+	hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893)
+		# FIXME: really hppa2.0-hp
+		basic_machine=hppa1.1-hp
+		;;
+	hp9k8[0-9][13679] | hp8[0-9][13679])
+		basic_machine=hppa1.1-hp
+		;;
+	hp9k8[0-9][0-9] | hp8[0-9][0-9])
+		basic_machine=hppa1.0-hp
+		;;
+	hppaosf)
+		basic_machine=hppa1.1-hp
+		os=-osf
+		;;
+	hppro)
+		basic_machine=hppa1.1-hp
+		os=-proelf
+		;;
+	i370-ibm* | ibm*)
+		basic_machine=i370-ibm
+		;;
+	i*86v32)
+		basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'`
+		os=-sysv32
+		;;
+	i*86v4*)
+		basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'`
+		os=-sysv4
+		;;
+	i*86v)
+		basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'`
+		os=-sysv
+		;;
+	i*86sol2)
+		basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'`
+		os=-solaris2
+		;;
+	i386mach)
+		basic_machine=i386-mach
+		os=-mach
+		;;
+	vsta)
+		basic_machine=i386-unknown
+		os=-vsta
+		;;
+	iris | iris4d)
+		basic_machine=mips-sgi
+		case $os in
+		    -irix*)
+			;;
+		    *)
+			os=-irix4
+			;;
+		esac
+		;;
+	isi68 | isi)
+		basic_machine=m68k-isi
+		os=-sysv
+		;;
+	leon-*|leon[3-9]-*)
+		basic_machine=sparc-`echo "$basic_machine" | sed 's/-.*//'`
+		;;
+	m68knommu)
+		basic_machine=m68k-unknown
+		os=-linux
+		;;
+	m68knommu-*)
+		basic_machine=m68k-`echo "$basic_machine" | sed 's/^[^-]*-//'`
+		os=-linux
+		;;
+	magnum | m3230)
+		basic_machine=mips-mips
+		os=-sysv
+		;;
+	merlin)
+		basic_machine=ns32k-utek
+		os=-sysv
+		;;
+	microblaze*)
+		basic_machine=microblaze-xilinx
+		;;
+	mingw64)
+		basic_machine=x86_64-pc
+		os=-mingw64
+		;;
+	mingw32)
+		basic_machine=i686-pc
+		os=-mingw32
+		;;
+	mingw32ce)
+		basic_machine=arm-unknown
+		os=-mingw32ce
+		;;
+	miniframe)
+		basic_machine=m68000-convergent
+		;;
+	*mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*)
+		basic_machine=m68k-atari
+		os=-mint
+		;;
+	mips3*-*)
+		basic_machine=`echo "$basic_machine" | sed -e 's/mips3/mips64/'`
+		;;
+	mips3*)
+		basic_machine=`echo "$basic_machine" | sed -e 's/mips3/mips64/'`-unknown
+		;;
+	monitor)
+		basic_machine=m68k-rom68k
+		os=-coff
+		;;
+	morphos)
+		basic_machine=powerpc-unknown
+		os=-morphos
+		;;
+	moxiebox)
+		basic_machine=moxie-unknown
+		os=-moxiebox
+		;;
+	msdos)
+		basic_machine=i386-pc
+		os=-msdos
+		;;
+	ms1-*)
+		basic_machine=`echo "$basic_machine" | sed -e 's/ms1-/mt-/'`
+		;;
+	msys)
+		basic_machine=i686-pc
+		os=-msys
+		;;
+	mvs)
+		basic_machine=i370-ibm
+		os=-mvs
+		;;
+	nacl)
+		basic_machine=le32-unknown
+		os=-nacl
+		;;
+	ncr3000)
+		basic_machine=i486-ncr
+		os=-sysv4
+		;;
+	netbsd386)
+		basic_machine=i386-unknown
+		os=-netbsd
+		;;
+	netwinder)
+		basic_machine=armv4l-rebel
+		os=-linux
+		;;
+	news | news700 | news800 | news900)
+		basic_machine=m68k-sony
+		os=-newsos
+		;;
+	news1000)
+		basic_machine=m68030-sony
+		os=-newsos
+		;;
+	news-3600 | risc-news)
+		basic_machine=mips-sony
+		os=-newsos
+		;;
+	necv70)
+		basic_machine=v70-nec
+		os=-sysv
+		;;
+	next | m*-next)
+		basic_machine=m68k-next
+		case $os in
+		    -nextstep* )
+			;;
+		    -ns2*)
+		      os=-nextstep2
+			;;
+		    *)
+		      os=-nextstep3
+			;;
+		esac
+		;;
+	nh3000)
+		basic_machine=m68k-harris
+		os=-cxux
+		;;
+	nh[45]000)
+		basic_machine=m88k-harris
+		os=-cxux
+		;;
+	nindy960)
+		basic_machine=i960-intel
+		os=-nindy
+		;;
+	mon960)
+		basic_machine=i960-intel
+		os=-mon960
+		;;
+	nonstopux)
+		basic_machine=mips-compaq
+		os=-nonstopux
+		;;
+	np1)
+		basic_machine=np1-gould
+		;;
+	neo-tandem)
+		basic_machine=neo-tandem
+		;;
+	nse-tandem)
+		basic_machine=nse-tandem
+		;;
+	nsr-tandem)
+		basic_machine=nsr-tandem
+		;;
+	nsv-tandem)
+		basic_machine=nsv-tandem
+		;;
+	nsx-tandem)
+		basic_machine=nsx-tandem
+		;;
+	op50n-* | op60c-*)
+		basic_machine=hppa1.1-oki
+		os=-proelf
+		;;
+	openrisc | openrisc-*)
+		basic_machine=or32-unknown
+		;;
+	os400)
+		basic_machine=powerpc-ibm
+		os=-os400
+		;;
+	OSE68000 | ose68000)
+		basic_machine=m68000-ericsson
+		os=-ose
+		;;
+	os68k)
+		basic_machine=m68k-none
+		os=-os68k
+		;;
+	pa-hitachi)
+		basic_machine=hppa1.1-hitachi
+		os=-hiuxwe2
+		;;
+	paragon)
+		basic_machine=i860-intel
+		os=-osf
+		;;
+	parisc)
+		basic_machine=hppa-unknown
+		os=-linux
+		;;
+	parisc-*)
+		basic_machine=hppa-`echo "$basic_machine" | sed 's/^[^-]*-//'`
+		os=-linux
+		;;
+	pbd)
+		basic_machine=sparc-tti
+		;;
+	pbb)
+		basic_machine=m68k-tti
+		;;
+	pc532 | pc532-*)
+		basic_machine=ns32k-pc532
+		;;
+	pc98)
+		basic_machine=i386-pc
+		;;
+	pc98-*)
+		basic_machine=i386-`echo "$basic_machine" | sed 's/^[^-]*-//'`
+		;;
+	pentium | p5 | k5 | k6 | nexgen | viac3)
+		basic_machine=i586-pc
+		;;
+	pentiumpro | p6 | 6x86 | athlon | athlon_*)
+		basic_machine=i686-pc
+		;;
+	pentiumii | pentium2 | pentiumiii | pentium3)
+		basic_machine=i686-pc
+		;;
+	pentium4)
+		basic_machine=i786-pc
+		;;
+	pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*)
+		basic_machine=i586-`echo "$basic_machine" | sed 's/^[^-]*-//'`
+		;;
+	pentiumpro-* | p6-* | 6x86-* | athlon-*)
+		basic_machine=i686-`echo "$basic_machine" | sed 's/^[^-]*-//'`
+		;;
+	pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*)
+		basic_machine=i686-`echo "$basic_machine" | sed 's/^[^-]*-//'`
+		;;
+	pentium4-*)
+		basic_machine=i786-`echo "$basic_machine" | sed 's/^[^-]*-//'`
+		;;
+	pn)
+		basic_machine=pn-gould
+		;;
+	power)	basic_machine=power-ibm
+		;;
+	ppc | ppcbe)	basic_machine=powerpc-unknown
+		;;
+	ppc-* | ppcbe-*)
+		basic_machine=powerpc-`echo "$basic_machine" | sed 's/^[^-]*-//'`
+		;;
+	ppcle | powerpclittle)
+		basic_machine=powerpcle-unknown
+		;;
+	ppcle-* | powerpclittle-*)
+		basic_machine=powerpcle-`echo "$basic_machine" | sed 's/^[^-]*-//'`
+		;;
+	ppc64)	basic_machine=powerpc64-unknown
+		;;
+	ppc64-*) basic_machine=powerpc64-`echo "$basic_machine" | sed 's/^[^-]*-//'`
+		;;
+	ppc64le | powerpc64little)
+		basic_machine=powerpc64le-unknown
+		;;
+	ppc64le-* | powerpc64little-*)
+		basic_machine=powerpc64le-`echo "$basic_machine" | sed 's/^[^-]*-//'`
+		;;
+	ps2)
+		basic_machine=i386-ibm
+		;;
+	pw32)
+		basic_machine=i586-unknown
+		os=-pw32
+		;;
+	rdos | rdos64)
+		basic_machine=x86_64-pc
+		os=-rdos
+		;;
+	rdos32)
+		basic_machine=i386-pc
+		os=-rdos
+		;;
+	rom68k)
+		basic_machine=m68k-rom68k
+		os=-coff
+		;;
+	rm[46]00)
+		basic_machine=mips-siemens
+		;;
+	rtpc | rtpc-*)
+		basic_machine=romp-ibm
+		;;
+	s390 | s390-*)
+		basic_machine=s390-ibm
+		;;
+	s390x | s390x-*)
+		basic_machine=s390x-ibm
+		;;
+	sa29200)
+		basic_machine=a29k-amd
+		os=-udi
+		;;
+	sb1)
+		basic_machine=mipsisa64sb1-unknown
+		;;
+	sb1el)
+		basic_machine=mipsisa64sb1el-unknown
+		;;
+	sde)
+		basic_machine=mipsisa32-sde
+		os=-elf
+		;;
+	sei)
+		basic_machine=mips-sei
+		os=-seiux
+		;;
+	sequent)
+		basic_machine=i386-sequent
+		;;
+	sh5el)
+		basic_machine=sh5le-unknown
+		;;
+	simso-wrs)
+		basic_machine=sparclite-wrs
+		os=-vxworks
+		;;
+	sps7)
+		basic_machine=m68k-bull
+		os=-sysv2
+		;;
+	spur)
+		basic_machine=spur-unknown
+		;;
+	st2000)
+		basic_machine=m68k-tandem
+		;;
+	stratus)
+		basic_machine=i860-stratus
+		os=-sysv4
+		;;
+	strongarm-* | thumb-*)
+		basic_machine=arm-`echo "$basic_machine" | sed 's/^[^-]*-//'`
+		;;
+	sun2)
+		basic_machine=m68000-sun
+		;;
+	sun2os3)
+		basic_machine=m68000-sun
+		os=-sunos3
+		;;
+	sun2os4)
+		basic_machine=m68000-sun
+		os=-sunos4
+		;;
+	sun3os3)
+		basic_machine=m68k-sun
+		os=-sunos3
+		;;
+	sun3os4)
+		basic_machine=m68k-sun
+		os=-sunos4
+		;;
+	sun4os3)
+		basic_machine=sparc-sun
+		os=-sunos3
+		;;
+	sun4os4)
+		basic_machine=sparc-sun
+		os=-sunos4
+		;;
+	sun4sol2)
+		basic_machine=sparc-sun
+		os=-solaris2
+		;;
+	sun3 | sun3-*)
+		basic_machine=m68k-sun
+		;;
+	sun4)
+		basic_machine=sparc-sun
+		;;
+	sun386 | sun386i | roadrunner)
+		basic_machine=i386-sun
+		;;
+	sv1)
+		basic_machine=sv1-cray
+		os=-unicos
+		;;
+	symmetry)
+		basic_machine=i386-sequent
+		os=-dynix
+		;;
+	t3e)
+		basic_machine=alphaev5-cray
+		os=-unicos
+		;;
+	t90)
+		basic_machine=t90-cray
+		os=-unicos
+		;;
+	tile*)
+		basic_machine=$basic_machine-unknown
+		os=-linux-gnu
+		;;
+	tx39)
+		basic_machine=mipstx39-unknown
+		;;
+	tx39el)
+		basic_machine=mipstx39el-unknown
+		;;
+	toad1)
+		basic_machine=pdp10-xkl
+		os=-tops20
+		;;
+	tower | tower-32)
+		basic_machine=m68k-ncr
+		;;
+	tpf)
+		basic_machine=s390x-ibm
+		os=-tpf
+		;;
+	udi29k)
+		basic_machine=a29k-amd
+		os=-udi
+		;;
+	ultra3)
+		basic_machine=a29k-nyu
+		os=-sym1
+		;;
+	v810 | necv810)
+		basic_machine=v810-nec
+		os=-none
+		;;
+	vaxv)
+		basic_machine=vax-dec
+		os=-sysv
+		;;
+	vms)
+		basic_machine=vax-dec
+		os=-vms
+		;;
+	vpp*|vx|vx-*)
+		basic_machine=f301-fujitsu
+		;;
+	vxworks960)
+		basic_machine=i960-wrs
+		os=-vxworks
+		;;
+	vxworks68)
+		basic_machine=m68k-wrs
+		os=-vxworks
+		;;
+	vxworks29k)
+		basic_machine=a29k-wrs
+		os=-vxworks
+		;;
+	w65*)
+		basic_machine=w65-wdc
+		os=-none
+		;;
+	w89k-*)
+		basic_machine=hppa1.1-winbond
+		os=-proelf
+		;;
+	x64)
+		basic_machine=x86_64-pc
+		;;
+	xbox)
+		basic_machine=i686-pc
+		os=-mingw32
+		;;
+	xps | xps100)
+		basic_machine=xps100-honeywell
+		;;
+	xscale-* | xscalee[bl]-*)
+		basic_machine=`echo "$basic_machine" | sed 's/^xscale/arm/'`
+		;;
+	ymp)
+		basic_machine=ymp-cray
+		os=-unicos
+		;;
+	none)
+		basic_machine=none-none
+		os=-none
+		;;
+
+# Here we handle the default manufacturer of certain CPU types.  It is in
+# some cases the only manufacturer, in others, it is the most popular.
+	w89k)
+		basic_machine=hppa1.1-winbond
+		;;
+	op50n)
+		basic_machine=hppa1.1-oki
+		;;
+	op60c)
+		basic_machine=hppa1.1-oki
+		;;
+	romp)
+		basic_machine=romp-ibm
+		;;
+	mmix)
+		basic_machine=mmix-knuth
+		;;
+	rs6000)
+		basic_machine=rs6000-ibm
+		;;
+	vax)
+		basic_machine=vax-dec
+		;;
+	pdp11)
+		basic_machine=pdp11-dec
+		;;
+	we32k)
+		basic_machine=we32k-att
+		;;
+	sh[1234] | sh[24]a | sh[24]aeb | sh[34]eb | sh[1234]le | sh[23]ele)
+		basic_machine=sh-unknown
+		;;
+	cydra)
+		basic_machine=cydra-cydrome
+		;;
+	orion)
+		basic_machine=orion-highlevel
+		;;
+	orion105)
+		basic_machine=clipper-highlevel
+		;;
+	mac | mpw | mac-mpw)
+		basic_machine=m68k-apple
+		;;
+	pmac | pmac-mpw)
+		basic_machine=powerpc-apple
+		;;
+	*-unknown)
+		# Make sure to match an already-canonicalized machine name.
+		;;
+	*)
+		echo Invalid configuration \`"$1"\': machine \`"$basic_machine"\' not recognized 1>&2
+		exit 1
+		;;
+esac
+
+# Here we canonicalize certain aliases for manufacturers.
+case $basic_machine in
+	*-digital*)
+		basic_machine=`echo "$basic_machine" | sed 's/digital.*/dec/'`
+		;;
+	*-commodore*)
+		basic_machine=`echo "$basic_machine" | sed 's/commodore.*/cbm/'`
+		;;
+	*)
+		;;
+esac
+
+# Decode manufacturer-specific aliases for certain operating systems.
+
+if [ x"$os" != x"" ]
+then
+case $os in
+	# First match some system type aliases that might get confused
+	# with valid system types.
+	# -solaris* is a basic system type, with this one exception.
+	-auroraux)
+		os=-auroraux
+		;;
+	-solaris1 | -solaris1.*)
+		os=`echo $os | sed -e 's|solaris1|sunos4|'`
+		;;
+	-solaris)
+		os=-solaris2
+		;;
+	-unixware*)
+		os=-sysv4.2uw
+		;;
+	-gnu/linux*)
+		os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'`
+		;;
+	# es1800 is here to avoid being matched by es* (a different OS)
+	-es1800*)
+		os=-ose
+		;;
+	# Now accept the basic system types.
+	# The portable systems comes first.
+	# Each alternative MUST end in a * to match a version number.
+	# -sysv* is not here because it comes later, after sysvr4.
+	-gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \
+	      | -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\
+	      | -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \
+	      | -sym* | -kopensolaris* | -plan9* \
+	      | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \
+	      | -aos* | -aros* | -cloudabi* | -sortix* \
+	      | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \
+	      | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \
+	      | -hiux* | -knetbsd* | -mirbsd* | -netbsd* \
+	      | -bitrig* | -openbsd* | -solidbsd* | -libertybsd* \
+	      | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \
+	      | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \
+	      | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
+	      | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* | -hcos* \
+	      | -chorusos* | -chorusrdb* | -cegcc* | -glidix* \
+	      | -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
+	      | -midipix* | -mingw32* | -mingw64* | -linux-gnu* | -linux-android* \
+	      | -linux-newlib* | -linux-musl* | -linux-uclibc* \
+	      | -uxpv* | -beos* | -mpeix* | -udk* | -moxiebox* \
+	      | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* \
+	      | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
+	      | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \
+	      | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \
+	      | -morphos* | -superux* | -rtmk* | -windiss* \
+	      | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \
+	      | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es* \
+	      | -onefs* | -tirtos* | -phoenix* | -fuchsia* | -redox* | -bme* \
+	      | -midnightbsd*)
+	# Remember, each alternative MUST END IN *, to match a version number.
+		;;
+	-qnx*)
+		case $basic_machine in
+		    x86-* | i*86-*)
+			;;
+		    *)
+			os=-nto$os
+			;;
+		esac
+		;;
+	-nto-qnx*)
+		;;
+	-nto*)
+		os=`echo $os | sed -e 's|nto|nto-qnx|'`
+		;;
+	-sim | -xray | -os68k* | -v88r* \
+	      | -windows* | -osx | -abug | -netware* | -os9* \
+	      | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*)
+		;;
+	-mac*)
+		os=`echo "$os" | sed -e 's|mac|macos|'`
+		;;
+	-linux-dietlibc)
+		os=-linux-dietlibc
+		;;
+	-linux*)
+		os=`echo $os | sed -e 's|linux|linux-gnu|'`
+		;;
+	-sunos5*)
+		os=`echo "$os" | sed -e 's|sunos5|solaris2|'`
+		;;
+	-sunos6*)
+		os=`echo "$os" | sed -e 's|sunos6|solaris3|'`
+		;;
+	-opened*)
+		os=-openedition
+		;;
+	-os400*)
+		os=-os400
+		;;
+	-wince*)
+		os=-wince
+		;;
+	-utek*)
+		os=-bsd
+		;;
+	-dynix*)
+		os=-bsd
+		;;
+	-acis*)
+		os=-aos
+		;;
+	-atheos*)
+		os=-atheos
+		;;
+	-syllable*)
+		os=-syllable
+		;;
+	-386bsd)
+		os=-bsd
+		;;
+	-ctix* | -uts*)
+		os=-sysv
+		;;
+	-nova*)
+		os=-rtmk-nova
+		;;
+	-ns2)
+		os=-nextstep2
+		;;
+	-nsk*)
+		os=-nsk
+		;;
+	# Preserve the version number of sinix5.
+	-sinix5.*)
+		os=`echo $os | sed -e 's|sinix|sysv|'`
+		;;
+	-sinix*)
+		os=-sysv4
+		;;
+	-tpf*)
+		os=-tpf
+		;;
+	-triton*)
+		os=-sysv3
+		;;
+	-oss*)
+		os=-sysv3
+		;;
+	-svr4*)
+		os=-sysv4
+		;;
+	-svr3)
+		os=-sysv3
+		;;
+	-sysvr4)
+		os=-sysv4
+		;;
+	# This must come after -sysvr4.
+	-sysv*)
+		;;
+	-ose*)
+		os=-ose
+		;;
+	-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
+		os=-mint
+		;;
+	-zvmoe)
+		os=-zvmoe
+		;;
+	-dicos*)
+		os=-dicos
+		;;
+	-pikeos*)
+		# Until real need of OS specific support for
+		# particular features comes up, bare metal
+		# configurations are quite functional.
+		case $basic_machine in
+		    arm*)
+			os=-eabi
+			;;
+		    *)
+			os=-elf
+			;;
+		esac
+		;;
+	-nacl*)
+		;;
+	-ios)
+		;;
+	-none)
+		;;
+	*)
+		# Get rid of the `-' at the beginning of $os.
+		os=`echo $os | sed 's/[^-]*-//'`
+		echo Invalid configuration \`"$1"\': system \`"$os"\' not recognized 1>&2
+		exit 1
+		;;
+esac
+else
+
+# Here we handle the default operating systems that come with various machines.
+# The value should be what the vendor currently ships out the door with their
+# machine or put another way, the most popular os provided with the machine.
+
+# Note that if you're going to try to match "-MANUFACTURER" here (say,
+# "-sun"), then you have to tell the case statement up towards the top
+# that MANUFACTURER isn't an operating system.  Otherwise, code above
+# will signal an error saying that MANUFACTURER isn't an operating
+# system, and we'll never get to this point.
+
+case $basic_machine in
+	score-*)
+		os=-elf
+		;;
+	spu-*)
+		os=-elf
+		;;
+	*-acorn)
+		os=-riscix1.2
+		;;
+	arm*-rebel)
+		os=-linux
+		;;
+	arm*-semi)
+		os=-aout
+		;;
+	c4x-* | tic4x-*)
+		os=-coff
+		;;
+	c8051-*)
+		os=-elf
+		;;
+	hexagon-*)
+		os=-elf
+		;;
+	tic54x-*)
+		os=-coff
+		;;
+	tic55x-*)
+		os=-coff
+		;;
+	tic6x-*)
+		os=-coff
+		;;
+	# This must come before the *-dec entry.
+	pdp10-*)
+		os=-tops20
+		;;
+	pdp11-*)
+		os=-none
+		;;
+	*-dec | vax-*)
+		os=-ultrix4.2
+		;;
+	m68*-apollo)
+		os=-domain
+		;;
+	i386-sun)
+		os=-sunos4.0.2
+		;;
+	m68000-sun)
+		os=-sunos3
+		;;
+	m68*-cisco)
+		os=-aout
+		;;
+	mep-*)
+		os=-elf
+		;;
+	mips*-cisco)
+		os=-elf
+		;;
+	mips*-*)
+		os=-elf
+		;;
+	or32-*)
+		os=-coff
+		;;
+	*-tti)	# must be before sparc entry or we get the wrong os.
+		os=-sysv3
+		;;
+	sparc-* | *-sun)
+		os=-sunos4.1.1
+		;;
+	pru-*)
+		os=-elf
+		;;
+	*-be)
+		os=-beos
+		;;
+	*-ibm)
+		os=-aix
+		;;
+	*-knuth)
+		os=-mmixware
+		;;
+	*-wec)
+		os=-proelf
+		;;
+	*-winbond)
+		os=-proelf
+		;;
+	*-oki)
+		os=-proelf
+		;;
+	*-hp)
+		os=-hpux
+		;;
+	*-hitachi)
+		os=-hiux
+		;;
+	i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent)
+		os=-sysv
+		;;
+	*-cbm)
+		os=-amigaos
+		;;
+	*-dg)
+		os=-dgux
+		;;
+	*-dolphin)
+		os=-sysv3
+		;;
+	m68k-ccur)
+		os=-rtu
+		;;
+	m88k-omron*)
+		os=-luna
+		;;
+	*-next)
+		os=-nextstep
+		;;
+	*-sequent)
+		os=-ptx
+		;;
+	*-crds)
+		os=-unos
+		;;
+	*-ns)
+		os=-genix
+		;;
+	i370-*)
+		os=-mvs
+		;;
+	*-gould)
+		os=-sysv
+		;;
+	*-highlevel)
+		os=-bsd
+		;;
+	*-encore)
+		os=-bsd
+		;;
+	*-sgi)
+		os=-irix
+		;;
+	*-siemens)
+		os=-sysv4
+		;;
+	*-masscomp)
+		os=-rtu
+		;;
+	f30[01]-fujitsu | f700-fujitsu)
+		os=-uxpv
+		;;
+	*-rom68k)
+		os=-coff
+		;;
+	*-*bug)
+		os=-coff
+		;;
+	*-apple)
+		os=-macos
+		;;
+	*-atari*)
+		os=-mint
+		;;
+	*)
+		os=-none
+		;;
+esac
+fi
+
+# Here we handle the case where we know the os, and the CPU type, but not the
+# manufacturer.  We pick the logical manufacturer.
+vendor=unknown
+case $basic_machine in
+	*-unknown)
+		case $os in
+			-riscix*)
+				vendor=acorn
+				;;
+			-sunos*)
+				vendor=sun
+				;;
+			-cnk*|-aix*)
+				vendor=ibm
+				;;
+			-beos*)
+				vendor=be
+				;;
+			-hpux*)
+				vendor=hp
+				;;
+			-mpeix*)
+				vendor=hp
+				;;
+			-hiux*)
+				vendor=hitachi
+				;;
+			-unos*)
+				vendor=crds
+				;;
+			-dgux*)
+				vendor=dg
+				;;
+			-luna*)
+				vendor=omron
+				;;
+			-genix*)
+				vendor=ns
+				;;
+			-mvs* | -opened*)
+				vendor=ibm
+				;;
+			-os400*)
+				vendor=ibm
+				;;
+			-ptx*)
+				vendor=sequent
+				;;
+			-tpf*)
+				vendor=ibm
+				;;
+			-vxsim* | -vxworks* | -windiss*)
+				vendor=wrs
+				;;
+			-aux*)
+				vendor=apple
+				;;
+			-hms*)
+				vendor=hitachi
+				;;
+			-mpw* | -macos*)
+				vendor=apple
+				;;
+			-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
+				vendor=atari
+				;;
+			-vos*)
+				vendor=stratus
+				;;
+		esac
+		basic_machine=`echo "$basic_machine" | sed "s/unknown/$vendor/"`
+		;;
+esac
+
+echo "$basic_machine$os"
+exit
+
+# Local variables:
+# eval: (add-hook 'before-save-hook 'time-stamp)
+# time-stamp-start: "timestamp='"
+# time-stamp-format: "%:y-%02m-%02d"
+# time-stamp-end: "'"
+# End:
diff --git a/Engine/lib/lpng/configure b/Engine/lib/lpng/configure
old mode 100644
new mode 100755
index e69de29bb..1b2c46366
--- a/Engine/lib/lpng/configure
+++ b/Engine/lib/lpng/configure
@@ -0,0 +1,16116 @@
+#! /bin/sh
+# Guess values for system-dependent variables and create Makefiles.
+# Generated by GNU Autoconf 2.69 for libpng 1.6.37.
+#
+# Report bugs to <png-mng-implement@lists.sourceforge.net>.
+#
+#
+# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
+#
+#
+# This configure script is free software; the Free Software Foundation
+# gives unlimited permission to copy, distribute and modify it.
+## -------------------- ##
+## M4sh Initialization. ##
+## -------------------- ##
+
+# Be more Bourne compatible
+DUALCASE=1; export DUALCASE # for MKS sh
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+  setopt NO_GLOB_SUBST
+else
+  case `(set -o) 2>/dev/null` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
+fi
+
+
+as_nl='
+'
+export as_nl
+# Printing a long string crashes Solaris 7 /usr/bin/printf.
+as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
+# Prefer a ksh shell builtin over an external printf program on Solaris,
+# but without wasting forks for bash or zsh.
+if test -z "$BASH_VERSION$ZSH_VERSION" \
+    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='print -r --'
+  as_echo_n='print -rn --'
+elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='printf %s\n'
+  as_echo_n='printf %s'
+else
+  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
+    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
+    as_echo_n='/usr/ucb/echo -n'
+  else
+    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
+    as_echo_n_body='eval
+      arg=$1;
+      case $arg in #(
+      *"$as_nl"*)
+	expr "X$arg" : "X\\(.*\\)$as_nl";
+	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
+      esac;
+      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
+    '
+    export as_echo_n_body
+    as_echo_n='sh -c $as_echo_n_body as_echo'
+  fi
+  export as_echo_body
+  as_echo='sh -c $as_echo_body as_echo'
+fi
+
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+  PATH_SEPARATOR=:
+  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
+    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
+      PATH_SEPARATOR=';'
+  }
+fi
+
+
+# IFS
+# We need space, tab and new line, in precisely that order.  Quoting is
+# there to prevent editors from complaining about space-tab.
+# (If _AS_PATH_WALK were called with IFS unset, it would disable word
+# splitting by setting IFS to empty value.)
+IFS=" ""	$as_nl"
+
+# Find who we are.  Look in the path if we contain no directory separator.
+as_myself=
+case $0 in #((
+  *[\\/]* ) as_myself=$0 ;;
+  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+  done
+IFS=$as_save_IFS
+
+     ;;
+esac
+# We did not find ourselves, most probably we were run as `sh COMMAND'
+# in which case we are not to be found in the path.
+if test "x$as_myself" = x; then
+  as_myself=$0
+fi
+if test ! -f "$as_myself"; then
+  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
+  exit 1
+fi
+
+# Unset variables that we do not need and which cause bugs (e.g. in
+# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
+# suppresses any "Segmentation fault" message there.  '((' could
+# trigger a bug in pdksh 5.2.14.
+for as_var in BASH_ENV ENV MAIL MAILPATH
+do eval test x\${$as_var+set} = xset \
+  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
+done
+PS1='$ '
+PS2='> '
+PS4='+ '
+
+# NLS nuisances.
+LC_ALL=C
+export LC_ALL
+LANGUAGE=C
+export LANGUAGE
+
+# CDPATH.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+# Use a proper internal environment variable to ensure we don't fall
+  # into an infinite loop, continuously re-executing ourselves.
+  if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
+    _as_can_reexec=no; export _as_can_reexec;
+    # We cannot yet assume a decent shell, so we have to provide a
+# neutralization value for shells without unset; and this also
+# works around shells that cannot unset nonexistent variables.
+# Preserve -v and -x to the replacement shell.
+BASH_ENV=/dev/null
+ENV=/dev/null
+(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
+case $- in # ((((
+  *v*x* | *x*v* ) as_opts=-vx ;;
+  *v* ) as_opts=-v ;;
+  *x* ) as_opts=-x ;;
+  * ) as_opts= ;;
+esac
+exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
+# Admittedly, this is quite paranoid, since all the known shells bail
+# out after a failed `exec'.
+$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
+as_fn_exit 255
+  fi
+  # We don't want this to propagate to other subprocesses.
+          { _as_can_reexec=; unset _as_can_reexec;}
+if test "x$CONFIG_SHELL" = x; then
+  as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '\${1+\"\$@\"}'='\"\$@\"'
+  setopt NO_GLOB_SUBST
+else
+  case \`(set -o) 2>/dev/null\` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
+fi
+"
+  as_required="as_fn_return () { (exit \$1); }
+as_fn_success () { as_fn_return 0; }
+as_fn_failure () { as_fn_return 1; }
+as_fn_ret_success () { return 0; }
+as_fn_ret_failure () { return 1; }
+
+exitcode=0
+as_fn_success || { exitcode=1; echo as_fn_success failed.; }
+as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
+as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
+as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
+if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
+
+else
+  exitcode=1; echo positional parameters were not saved.
+fi
+test x\$exitcode = x0 || exit 1
+test -x / || exit 1"
+  as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
+  as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
+  eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
+  test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
+test \$(( 1 + 1 )) = 2 || exit 1
+
+  test -n \"\${ZSH_VERSION+set}\${BASH_VERSION+set}\" || (
+    ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+    ECHO=\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO
+    ECHO=\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO
+    PATH=/empty FPATH=/empty; export PATH FPATH
+    test \"X\`printf %s \$ECHO\`\" = \"X\$ECHO\" \\
+      || test \"X\`print -r -- \$ECHO\`\" = \"X\$ECHO\" ) || exit 1"
+  if (eval "$as_required") 2>/dev/null; then :
+  as_have_required=yes
+else
+  as_have_required=no
+fi
+  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
+
+else
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+as_found=false
+for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  as_found=:
+  case $as_dir in #(
+	 /*)
+	   for as_base in sh bash ksh sh5; do
+	     # Try only shells that exist, to save several forks.
+	     as_shell=$as_dir/$as_base
+	     if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
+		    { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
+  CONFIG_SHELL=$as_shell as_have_required=yes
+		   if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
+  break 2
+fi
+fi
+	   done;;
+       esac
+  as_found=false
+done
+$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
+	      { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
+  CONFIG_SHELL=$SHELL as_have_required=yes
+fi; }
+IFS=$as_save_IFS
+
+
+      if test "x$CONFIG_SHELL" != x; then :
+  export CONFIG_SHELL
+             # We cannot yet assume a decent shell, so we have to provide a
+# neutralization value for shells without unset; and this also
+# works around shells that cannot unset nonexistent variables.
+# Preserve -v and -x to the replacement shell.
+BASH_ENV=/dev/null
+ENV=/dev/null
+(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
+case $- in # ((((
+  *v*x* | *x*v* ) as_opts=-vx ;;
+  *v* ) as_opts=-v ;;
+  *x* ) as_opts=-x ;;
+  * ) as_opts= ;;
+esac
+exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
+# Admittedly, this is quite paranoid, since all the known shells bail
+# out after a failed `exec'.
+$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
+exit 255
+fi
+
+    if test x$as_have_required = xno; then :
+  $as_echo "$0: This script requires a shell more modern than all"
+  $as_echo "$0: the shells that I found on your system."
+  if test x${ZSH_VERSION+set} = xset ; then
+    $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
+    $as_echo "$0: be upgraded to zsh 4.3.4 or later."
+  else
+    $as_echo "$0: Please tell bug-autoconf@gnu.org and
+$0: png-mng-implement@lists.sourceforge.net about your
+$0: system, including any error possibly output before this
+$0: message. Then install a modern shell, or manually run
+$0: the script under such a shell if you do have one."
+  fi
+  exit 1
+fi
+fi
+fi
+SHELL=${CONFIG_SHELL-/bin/sh}
+export SHELL
+# Unset more variables known to interfere with behavior of common tools.
+CLICOLOR_FORCE= GREP_OPTIONS=
+unset CLICOLOR_FORCE GREP_OPTIONS
+
+## --------------------- ##
+## M4sh Shell Functions. ##
+## --------------------- ##
+# as_fn_unset VAR
+# ---------------
+# Portably unset VAR.
+as_fn_unset ()
+{
+  { eval $1=; unset $1;}
+}
+as_unset=as_fn_unset
+
+# as_fn_set_status STATUS
+# -----------------------
+# Set $? to STATUS, without forking.
+as_fn_set_status ()
+{
+  return $1
+} # as_fn_set_status
+
+# as_fn_exit STATUS
+# -----------------
+# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
+as_fn_exit ()
+{
+  set +e
+  as_fn_set_status $1
+  exit $1
+} # as_fn_exit
+
+# as_fn_mkdir_p
+# -------------
+# Create "$as_dir" as a directory, including parents if necessary.
+as_fn_mkdir_p ()
+{
+
+  case $as_dir in #(
+  -*) as_dir=./$as_dir;;
+  esac
+  test -d "$as_dir" || eval $as_mkdir_p || {
+    as_dirs=
+    while :; do
+      case $as_dir in #(
+      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
+      *) as_qdir=$as_dir;;
+      esac
+      as_dirs="'$as_qdir' $as_dirs"
+      as_dir=`$as_dirname -- "$as_dir" ||
+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_dir" : 'X\(//\)[^/]' \| \
+	 X"$as_dir" : 'X\(//\)$' \| \
+	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$as_dir" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+      test -d "$as_dir" && break
+    done
+    test -z "$as_dirs" || eval "mkdir $as_dirs"
+  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
+
+
+} # as_fn_mkdir_p
+
+# as_fn_executable_p FILE
+# -----------------------
+# Test if FILE is an executable regular file.
+as_fn_executable_p ()
+{
+  test -f "$1" && test -x "$1"
+} # as_fn_executable_p
+# as_fn_append VAR VALUE
+# ----------------------
+# Append the text in VALUE to the end of the definition contained in VAR. Take
+# advantage of any shell optimizations that allow amortized linear growth over
+# repeated appends, instead of the typical quadratic growth present in naive
+# implementations.
+if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
+  eval 'as_fn_append ()
+  {
+    eval $1+=\$2
+  }'
+else
+  as_fn_append ()
+  {
+    eval $1=\$$1\$2
+  }
+fi # as_fn_append
+
+# as_fn_arith ARG...
+# ------------------
+# Perform arithmetic evaluation on the ARGs, and store the result in the
+# global $as_val. Take advantage of shells that can avoid forks. The arguments
+# must be portable across $(()) and expr.
+if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
+  eval 'as_fn_arith ()
+  {
+    as_val=$(( $* ))
+  }'
+else
+  as_fn_arith ()
+  {
+    as_val=`expr "$@" || test $? -eq 1`
+  }
+fi # as_fn_arith
+
+
+# as_fn_error STATUS ERROR [LINENO LOG_FD]
+# ----------------------------------------
+# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
+# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
+# script with STATUS, using 1 if that was 0.
+as_fn_error ()
+{
+  as_status=$1; test $as_status -eq 0 && as_status=1
+  if test "$4"; then
+    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
+  fi
+  $as_echo "$as_me: error: $2" >&2
+  as_fn_exit $as_status
+} # as_fn_error
+
+if expr a : '\(a\)' >/dev/null 2>&1 &&
+   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+  as_basename=basename
+else
+  as_basename=false
+fi
+
+if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
+  as_dirname=dirname
+else
+  as_dirname=false
+fi
+
+as_me=`$as_basename -- "$0" ||
+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+	 X"$0" : 'X\(//\)$' \| \
+	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X/"$0" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+
+  as_lineno_1=$LINENO as_lineno_1a=$LINENO
+  as_lineno_2=$LINENO as_lineno_2a=$LINENO
+  eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
+  test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
+  # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
+  sed -n '
+    p
+    /[$]LINENO/=
+  ' <$as_myself |
+    sed '
+      s/[$]LINENO.*/&-/
+      t lineno
+      b
+      :lineno
+      N
+      :loop
+      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
+      t loop
+      s/-\n.*//
+    ' >$as_me.lineno &&
+  chmod +x "$as_me.lineno" ||
+    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
+
+  # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
+  # already done that, so ensure we don't try to do so again and fall
+  # in an infinite loop.  This has already happened in practice.
+  _as_can_reexec=no; export _as_can_reexec
+  # Don't try to exec as it changes $[0], causing all sort of problems
+  # (the dirname of $[0] is not the place where we might find the
+  # original and so on.  Autoconf is especially sensitive to this).
+  . "./$as_me.lineno"
+  # Exit status is that of the last command.
+  exit
+}
+
+ECHO_C= ECHO_N= ECHO_T=
+case `echo -n x` in #(((((
+-n*)
+  case `echo 'xy\c'` in
+  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
+  xy)  ECHO_C='\c';;
+  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
+       ECHO_T='	';;
+  esac;;
+*)
+  ECHO_N='-n';;
+esac
+
+rm -f conf$$ conf$$.exe conf$$.file
+if test -d conf$$.dir; then
+  rm -f conf$$.dir/conf$$.file
+else
+  rm -f conf$$.dir
+  mkdir conf$$.dir 2>/dev/null
+fi
+if (echo >conf$$.file) 2>/dev/null; then
+  if ln -s conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s='ln -s'
+    # ... but there are two gotchas:
+    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
+    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
+    # In both cases, we have to default to `cp -pR'.
+    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+      as_ln_s='cp -pR'
+  elif ln conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s=ln
+  else
+    as_ln_s='cp -pR'
+  fi
+else
+  as_ln_s='cp -pR'
+fi
+rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
+rmdir conf$$.dir 2>/dev/null
+
+if mkdir -p . 2>/dev/null; then
+  as_mkdir_p='mkdir -p "$as_dir"'
+else
+  test -d ./-p && rmdir ./-p
+  as_mkdir_p=false
+fi
+
+as_test_x='test -x'
+as_executable_p=as_fn_executable_p
+
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+
+SHELL=${CONFIG_SHELL-/bin/sh}
+
+
+test -n "$DJDIR" || exec 7<&0 </dev/null
+exec 6>&1
+
+# Name of the host.
+# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
+# so uname gets run too.
+ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
+
+#
+# Initializations.
+#
+ac_default_prefix=/usr/local
+ac_clean_files=
+ac_config_libobj_dir=.
+LIBOBJS=
+cross_compiling=no
+subdirs=
+MFLAGS=
+MAKEFLAGS=
+
+# Identity of this package.
+PACKAGE_NAME='libpng'
+PACKAGE_TARNAME='libpng'
+PACKAGE_VERSION='1.6.37'
+PACKAGE_STRING='libpng 1.6.37'
+PACKAGE_BUGREPORT='png-mng-implement@lists.sourceforge.net'
+PACKAGE_URL=''
+
+ac_unique_file="pngget.c"
+# Factoring default headers for most tests.
+ac_includes_default="\
+#include <stdio.h>
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+#ifdef STDC_HEADERS
+# include <stdlib.h>
+# include <stddef.h>
+#else
+# ifdef HAVE_STDLIB_H
+#  include <stdlib.h>
+# endif
+#endif
+#ifdef HAVE_STRING_H
+# if !defined STDC_HEADERS && defined HAVE_MEMORY_H
+#  include <memory.h>
+# endif
+# include <string.h>
+#endif
+#ifdef HAVE_STRINGS_H
+# include <strings.h>
+#endif
+#ifdef HAVE_INTTYPES_H
+# include <inttypes.h>
+#endif
+#ifdef HAVE_STDINT_H
+# include <stdint.h>
+#endif
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif"
+
+ac_subst_vars='am__EXEEXT_FALSE
+am__EXEEXT_TRUE
+LTLIBOBJS
+PNG_POWERPC_VSX_FALSE
+PNG_POWERPC_VSX_TRUE
+PNG_INTEL_SSE_FALSE
+PNG_INTEL_SSE_TRUE
+PNG_MIPS_MSA_FALSE
+PNG_MIPS_MSA_TRUE
+PNG_ARM_NEON_FALSE
+PNG_ARM_NEON_TRUE
+DO_INSTALL_LIBPNG_CONFIG_FALSE
+DO_INSTALL_LIBPNG_CONFIG_TRUE
+DO_INSTALL_LIBPNG_PC_FALSE
+DO_INSTALL_LIBPNG_PC_TRUE
+DO_INSTALL_LINKS_FALSE
+DO_INSTALL_LINKS_TRUE
+DO_PNG_PREFIX_FALSE
+DO_PNG_PREFIX_TRUE
+PNG_PREFIX
+binconfigs
+pkgconfigdir
+PNGLIB_RELEASE
+PNGLIB_MINOR
+PNGLIB_MAJOR
+PNGLIB_VERSION
+SYMBOL_PREFIX
+HAVE_LD_VERSION_SCRIPT_FALSE
+HAVE_LD_VERSION_SCRIPT_TRUE
+HAVE_SOLARIS_LD_FALSE
+HAVE_SOLARIS_LD_TRUE
+HAVE_CLOCK_GETTIME_FALSE
+HAVE_CLOCK_GETTIME_TRUE
+LIBOBJS
+POW_LIB
+PNG_COPTS
+DFNCPP
+LT_SYS_LIBRARY_PATH
+OTOOL64
+OTOOL
+LIPO
+NMEDIT
+DSYMUTIL
+MANIFEST_TOOL
+RANLIB
+ac_ct_AR
+AR
+NM
+ac_ct_DUMPBIN
+DUMPBIN
+LIBTOOL
+OBJDUMP
+DLLTOOL
+AS
+LN_S
+CPP
+LD
+FGREP
+EGREP
+GREP
+SED
+host_os
+host_vendor
+host_cpu
+host
+build_os
+build_vendor
+build_cpu
+build
+am__fastdepCCAS_FALSE
+am__fastdepCCAS_TRUE
+CCASDEPMODE
+CCASFLAGS
+CCAS
+am__fastdepCC_FALSE
+am__fastdepCC_TRUE
+CCDEPMODE
+am__nodep
+AMDEPBACKSLASH
+AMDEP_FALSE
+AMDEP_TRUE
+am__include
+DEPDIR
+OBJEXT
+EXEEXT
+ac_ct_CC
+CPPFLAGS
+LDFLAGS
+CFLAGS
+CC
+MAINT
+MAINTAINER_MODE_FALSE
+MAINTAINER_MODE_TRUE
+AM_BACKSLASH
+AM_DEFAULT_VERBOSITY
+AM_DEFAULT_V
+AM_V
+am__untar
+am__tar
+AMTAR
+am__leading_dot
+SET_MAKE
+AWK
+mkdir_p
+MKDIR_P
+INSTALL_STRIP_PROGRAM
+STRIP
+install_sh
+MAKEINFO
+AUTOHEADER
+AUTOMAKE
+AUTOCONF
+ACLOCAL
+VERSION
+PACKAGE
+CYGPATH_W
+am__isrc
+INSTALL_DATA
+INSTALL_SCRIPT
+INSTALL_PROGRAM
+target_alias
+host_alias
+build_alias
+LIBS
+ECHO_T
+ECHO_N
+ECHO_C
+DEFS
+mandir
+localedir
+libdir
+psdir
+pdfdir
+dvidir
+htmldir
+infodir
+docdir
+oldincludedir
+includedir
+localstatedir
+sharedstatedir
+sysconfdir
+datadir
+datarootdir
+libexecdir
+sbindir
+bindir
+program_transform_name
+prefix
+exec_prefix
+PACKAGE_URL
+PACKAGE_BUGREPORT
+PACKAGE_STRING
+PACKAGE_VERSION
+PACKAGE_TARNAME
+PACKAGE_NAME
+PATH_SEPARATOR
+SHELL
+am__quote'
+ac_subst_files=''
+ac_user_opts='
+enable_option_checking
+enable_silent_rules
+enable_maintainer_mode
+enable_dependency_tracking
+with_gnu_ld
+enable_shared
+enable_static
+with_pic
+enable_fast_install
+with_aix_soname
+with_sysroot
+enable_libtool_lock
+enable_werror
+with_zlib_prefix
+with_pkgconfigdir
+with_binconfigs
+with_libpng_prefix
+enable_unversioned_links
+enable_unversioned_libpng_pc
+enable_unversioned_libpng_config
+enable_hardware_optimizations
+enable_arm_neon
+enable_mips_msa
+enable_intel_sse
+enable_powerpc_vsx
+'
+      ac_precious_vars='build_alias
+host_alias
+target_alias
+CC
+CFLAGS
+LDFLAGS
+LIBS
+CPPFLAGS
+CCAS
+CCASFLAGS
+CPP
+LT_SYS_LIBRARY_PATH
+PNG_COPTS'
+
+
+# Initialize some variables set by options.
+ac_init_help=
+ac_init_version=false
+ac_unrecognized_opts=
+ac_unrecognized_sep=
+# The variables have the same names as the options, with
+# dashes changed to underlines.
+cache_file=/dev/null
+exec_prefix=NONE
+no_create=
+no_recursion=
+prefix=NONE
+program_prefix=NONE
+program_suffix=NONE
+program_transform_name=s,x,x,
+silent=
+site=
+srcdir=
+verbose=
+x_includes=NONE
+x_libraries=NONE
+
+# Installation directory options.
+# These are left unexpanded so users can "make install exec_prefix=/foo"
+# and all the variables that are supposed to be based on exec_prefix
+# by default will actually change.
+# Use braces instead of parens because sh, perl, etc. also accept them.
+# (The list follows the same order as the GNU Coding Standards.)
+bindir='${exec_prefix}/bin'
+sbindir='${exec_prefix}/sbin'
+libexecdir='${exec_prefix}/libexec'
+datarootdir='${prefix}/share'
+datadir='${datarootdir}'
+sysconfdir='${prefix}/etc'
+sharedstatedir='${prefix}/com'
+localstatedir='${prefix}/var'
+includedir='${prefix}/include'
+oldincludedir='/usr/include'
+docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
+infodir='${datarootdir}/info'
+htmldir='${docdir}'
+dvidir='${docdir}'
+pdfdir='${docdir}'
+psdir='${docdir}'
+libdir='${exec_prefix}/lib'
+localedir='${datarootdir}/locale'
+mandir='${datarootdir}/man'
+
+ac_prev=
+ac_dashdash=
+for ac_option
+do
+  # If the previous option needs an argument, assign it.
+  if test -n "$ac_prev"; then
+    eval $ac_prev=\$ac_option
+    ac_prev=
+    continue
+  fi
+
+  case $ac_option in
+  *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
+  *=)   ac_optarg= ;;
+  *)    ac_optarg=yes ;;
+  esac
+
+  # Accept the important Cygnus configure options, so we can diagnose typos.
+
+  case $ac_dashdash$ac_option in
+  --)
+    ac_dashdash=yes ;;
+
+  -bindir | --bindir | --bindi | --bind | --bin | --bi)
+    ac_prev=bindir ;;
+  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
+    bindir=$ac_optarg ;;
+
+  -build | --build | --buil | --bui | --bu)
+    ac_prev=build_alias ;;
+  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
+    build_alias=$ac_optarg ;;
+
+  -cache-file | --cache-file | --cache-fil | --cache-fi \
+  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
+    ac_prev=cache_file ;;
+  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
+  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
+    cache_file=$ac_optarg ;;
+
+  --config-cache | -C)
+    cache_file=config.cache ;;
+
+  -datadir | --datadir | --datadi | --datad)
+    ac_prev=datadir ;;
+  -datadir=* | --datadir=* | --datadi=* | --datad=*)
+    datadir=$ac_optarg ;;
+
+  -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
+  | --dataroo | --dataro | --datar)
+    ac_prev=datarootdir ;;
+  -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
+  | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
+    datarootdir=$ac_optarg ;;
+
+  -disable-* | --disable-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid feature name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"enable_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval enable_$ac_useropt=no ;;
+
+  -docdir | --docdir | --docdi | --doc | --do)
+    ac_prev=docdir ;;
+  -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
+    docdir=$ac_optarg ;;
+
+  -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
+    ac_prev=dvidir ;;
+  -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
+    dvidir=$ac_optarg ;;
+
+  -enable-* | --enable-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid feature name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"enable_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval enable_$ac_useropt=\$ac_optarg ;;
+
+  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
+  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
+  | --exec | --exe | --ex)
+    ac_prev=exec_prefix ;;
+  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
+  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
+  | --exec=* | --exe=* | --ex=*)
+    exec_prefix=$ac_optarg ;;
+
+  -gas | --gas | --ga | --g)
+    # Obsolete; use --with-gas.
+    with_gas=yes ;;
+
+  -help | --help | --hel | --he | -h)
+    ac_init_help=long ;;
+  -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
+    ac_init_help=recursive ;;
+  -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
+    ac_init_help=short ;;
+
+  -host | --host | --hos | --ho)
+    ac_prev=host_alias ;;
+  -host=* | --host=* | --hos=* | --ho=*)
+    host_alias=$ac_optarg ;;
+
+  -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
+    ac_prev=htmldir ;;
+  -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
+  | --ht=*)
+    htmldir=$ac_optarg ;;
+
+  -includedir | --includedir | --includedi | --included | --include \
+  | --includ | --inclu | --incl | --inc)
+    ac_prev=includedir ;;
+  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
+  | --includ=* | --inclu=* | --incl=* | --inc=*)
+    includedir=$ac_optarg ;;
+
+  -infodir | --infodir | --infodi | --infod | --info | --inf)
+    ac_prev=infodir ;;
+  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
+    infodir=$ac_optarg ;;
+
+  -libdir | --libdir | --libdi | --libd)
+    ac_prev=libdir ;;
+  -libdir=* | --libdir=* | --libdi=* | --libd=*)
+    libdir=$ac_optarg ;;
+
+  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
+  | --libexe | --libex | --libe)
+    ac_prev=libexecdir ;;
+  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
+  | --libexe=* | --libex=* | --libe=*)
+    libexecdir=$ac_optarg ;;
+
+  -localedir | --localedir | --localedi | --localed | --locale)
+    ac_prev=localedir ;;
+  -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
+    localedir=$ac_optarg ;;
+
+  -localstatedir | --localstatedir | --localstatedi | --localstated \
+  | --localstate | --localstat | --localsta | --localst | --locals)
+    ac_prev=localstatedir ;;
+  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
+  | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
+    localstatedir=$ac_optarg ;;
+
+  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
+    ac_prev=mandir ;;
+  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
+    mandir=$ac_optarg ;;
+
+  -nfp | --nfp | --nf)
+    # Obsolete; use --without-fp.
+    with_fp=no ;;
+
+  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
+  | --no-cr | --no-c | -n)
+    no_create=yes ;;
+
+  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
+  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
+    no_recursion=yes ;;
+
+  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
+  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
+  | --oldin | --oldi | --old | --ol | --o)
+    ac_prev=oldincludedir ;;
+  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
+  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
+  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
+    oldincludedir=$ac_optarg ;;
+
+  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
+    ac_prev=prefix ;;
+  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
+    prefix=$ac_optarg ;;
+
+  -program-prefix | --program-prefix | --program-prefi | --program-pref \
+  | --program-pre | --program-pr | --program-p)
+    ac_prev=program_prefix ;;
+  -program-prefix=* | --program-prefix=* | --program-prefi=* \
+  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
+    program_prefix=$ac_optarg ;;
+
+  -program-suffix | --program-suffix | --program-suffi | --program-suff \
+  | --program-suf | --program-su | --program-s)
+    ac_prev=program_suffix ;;
+  -program-suffix=* | --program-suffix=* | --program-suffi=* \
+  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
+    program_suffix=$ac_optarg ;;
+
+  -program-transform-name | --program-transform-name \
+  | --program-transform-nam | --program-transform-na \
+  | --program-transform-n | --program-transform- \
+  | --program-transform | --program-transfor \
+  | --program-transfo | --program-transf \
+  | --program-trans | --program-tran \
+  | --progr-tra | --program-tr | --program-t)
+    ac_prev=program_transform_name ;;
+  -program-transform-name=* | --program-transform-name=* \
+  | --program-transform-nam=* | --program-transform-na=* \
+  | --program-transform-n=* | --program-transform-=* \
+  | --program-transform=* | --program-transfor=* \
+  | --program-transfo=* | --program-transf=* \
+  | --program-trans=* | --program-tran=* \
+  | --progr-tra=* | --program-tr=* | --program-t=*)
+    program_transform_name=$ac_optarg ;;
+
+  -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
+    ac_prev=pdfdir ;;
+  -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
+    pdfdir=$ac_optarg ;;
+
+  -psdir | --psdir | --psdi | --psd | --ps)
+    ac_prev=psdir ;;
+  -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
+    psdir=$ac_optarg ;;
+
+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+  | -silent | --silent | --silen | --sile | --sil)
+    silent=yes ;;
+
+  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
+    ac_prev=sbindir ;;
+  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
+  | --sbi=* | --sb=*)
+    sbindir=$ac_optarg ;;
+
+  -sharedstatedir | --sharedstatedir | --sharedstatedi \
+  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
+  | --sharedst | --shareds | --shared | --share | --shar \
+  | --sha | --sh)
+    ac_prev=sharedstatedir ;;
+  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
+  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
+  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
+  | --sha=* | --sh=*)
+    sharedstatedir=$ac_optarg ;;
+
+  -site | --site | --sit)
+    ac_prev=site ;;
+  -site=* | --site=* | --sit=*)
+    site=$ac_optarg ;;
+
+  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
+    ac_prev=srcdir ;;
+  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
+    srcdir=$ac_optarg ;;
+
+  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
+  | --syscon | --sysco | --sysc | --sys | --sy)
+    ac_prev=sysconfdir ;;
+  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
+  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
+    sysconfdir=$ac_optarg ;;
+
+  -target | --target | --targe | --targ | --tar | --ta | --t)
+    ac_prev=target_alias ;;
+  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
+    target_alias=$ac_optarg ;;
+
+  -v | -verbose | --verbose | --verbos | --verbo | --verb)
+    verbose=yes ;;
+
+  -version | --version | --versio | --versi | --vers | -V)
+    ac_init_version=: ;;
+
+  -with-* | --with-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid package name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"with_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval with_$ac_useropt=\$ac_optarg ;;
+
+  -without-* | --without-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid package name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"with_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval with_$ac_useropt=no ;;
+
+  --x)
+    # Obsolete; use --with-x.
+    with_x=yes ;;
+
+  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
+  | --x-incl | --x-inc | --x-in | --x-i)
+    ac_prev=x_includes ;;
+  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
+  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
+    x_includes=$ac_optarg ;;
+
+  -x-libraries | --x-libraries | --x-librarie | --x-librari \
+  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
+    ac_prev=x_libraries ;;
+  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
+  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
+    x_libraries=$ac_optarg ;;
+
+  -*) as_fn_error $? "unrecognized option: \`$ac_option'
+Try \`$0 --help' for more information"
+    ;;
+
+  *=*)
+    ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
+    # Reject names that are not valid shell variable names.
+    case $ac_envvar in #(
+      '' | [0-9]* | *[!_$as_cr_alnum]* )
+      as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
+    esac
+    eval $ac_envvar=\$ac_optarg
+    export $ac_envvar ;;
+
+  *)
+    # FIXME: should be removed in autoconf 3.0.
+    $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
+    expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+      $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
+    : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
+    ;;
+
+  esac
+done
+
+if test -n "$ac_prev"; then
+  ac_option=--`echo $ac_prev | sed 's/_/-/g'`
+  as_fn_error $? "missing argument to $ac_option"
+fi
+
+if test -n "$ac_unrecognized_opts"; then
+  case $enable_option_checking in
+    no) ;;
+    fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
+    *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
+  esac
+fi
+
+# Check all directory arguments for consistency.
+for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
+		datadir sysconfdir sharedstatedir localstatedir includedir \
+		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
+		libdir localedir mandir
+do
+  eval ac_val=\$$ac_var
+  # Remove trailing slashes.
+  case $ac_val in
+    */ )
+      ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
+      eval $ac_var=\$ac_val;;
+  esac
+  # Be sure to have absolute directory names.
+  case $ac_val in
+    [\\/$]* | ?:[\\/]* )  continue;;
+    NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
+  esac
+  as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
+done
+
+# There might be people who depend on the old broken behavior: `$host'
+# used to hold the argument of --host etc.
+# FIXME: To remove some day.
+build=$build_alias
+host=$host_alias
+target=$target_alias
+
+# FIXME: To remove some day.
+if test "x$host_alias" != x; then
+  if test "x$build_alias" = x; then
+    cross_compiling=maybe
+  elif test "x$build_alias" != "x$host_alias"; then
+    cross_compiling=yes
+  fi
+fi
+
+ac_tool_prefix=
+test -n "$host_alias" && ac_tool_prefix=$host_alias-
+
+test "$silent" = yes && exec 6>/dev/null
+
+
+ac_pwd=`pwd` && test -n "$ac_pwd" &&
+ac_ls_di=`ls -di .` &&
+ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
+  as_fn_error $? "working directory cannot be determined"
+test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
+  as_fn_error $? "pwd does not report name of working directory"
+
+
+# Find the source files, if location was not specified.
+if test -z "$srcdir"; then
+  ac_srcdir_defaulted=yes
+  # Try the directory containing this script, then the parent directory.
+  ac_confdir=`$as_dirname -- "$as_myself" ||
+$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_myself" : 'X\(//\)[^/]' \| \
+	 X"$as_myself" : 'X\(//\)$' \| \
+	 X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$as_myself" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+  srcdir=$ac_confdir
+  if test ! -r "$srcdir/$ac_unique_file"; then
+    srcdir=..
+  fi
+else
+  ac_srcdir_defaulted=no
+fi
+if test ! -r "$srcdir/$ac_unique_file"; then
+  test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
+  as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
+fi
+ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
+ac_abs_confdir=`(
+	cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
+	pwd)`
+# When building in place, set srcdir=.
+if test "$ac_abs_confdir" = "$ac_pwd"; then
+  srcdir=.
+fi
+# Remove unnecessary trailing slashes from srcdir.
+# Double slashes in file names in object file debugging info
+# mess up M-x gdb in Emacs.
+case $srcdir in
+*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
+esac
+for ac_var in $ac_precious_vars; do
+  eval ac_env_${ac_var}_set=\${${ac_var}+set}
+  eval ac_env_${ac_var}_value=\$${ac_var}
+  eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
+  eval ac_cv_env_${ac_var}_value=\$${ac_var}
+done
+
+#
+# Report the --help message.
+#
+if test "$ac_init_help" = "long"; then
+  # Omit some internal or obsolete options to make the list less imposing.
+  # This message is too long to be a string in the A/UX 3.1 sh.
+  cat <<_ACEOF
+\`configure' configures libpng 1.6.37 to adapt to many kinds of systems.
+
+Usage: $0 [OPTION]... [VAR=VALUE]...
+
+To assign environment variables (e.g., CC, CFLAGS...), specify them as
+VAR=VALUE.  See below for descriptions of some of the useful variables.
+
+Defaults for the options are specified in brackets.
+
+Configuration:
+  -h, --help              display this help and exit
+      --help=short        display options specific to this package
+      --help=recursive    display the short help of all the included packages
+  -V, --version           display version information and exit
+  -q, --quiet, --silent   do not print \`checking ...' messages
+      --cache-file=FILE   cache test results in FILE [disabled]
+  -C, --config-cache      alias for \`--cache-file=config.cache'
+  -n, --no-create         do not create output files
+      --srcdir=DIR        find the sources in DIR [configure dir or \`..']
+
+Installation directories:
+  --prefix=PREFIX         install architecture-independent files in PREFIX
+                          [$ac_default_prefix]
+  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
+                          [PREFIX]
+
+By default, \`make install' will install all the files in
+\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
+an installation prefix other than \`$ac_default_prefix' using \`--prefix',
+for instance \`--prefix=\$HOME'.
+
+For better control, use the options below.
+
+Fine tuning of the installation directories:
+  --bindir=DIR            user executables [EPREFIX/bin]
+  --sbindir=DIR           system admin executables [EPREFIX/sbin]
+  --libexecdir=DIR        program executables [EPREFIX/libexec]
+  --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
+  --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
+  --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
+  --libdir=DIR            object code libraries [EPREFIX/lib]
+  --includedir=DIR        C header files [PREFIX/include]
+  --oldincludedir=DIR     C header files for non-gcc [/usr/include]
+  --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
+  --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
+  --infodir=DIR           info documentation [DATAROOTDIR/info]
+  --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
+  --mandir=DIR            man documentation [DATAROOTDIR/man]
+  --docdir=DIR            documentation root [DATAROOTDIR/doc/libpng]
+  --htmldir=DIR           html documentation [DOCDIR]
+  --dvidir=DIR            dvi documentation [DOCDIR]
+  --pdfdir=DIR            pdf documentation [DOCDIR]
+  --psdir=DIR             ps documentation [DOCDIR]
+_ACEOF
+
+  cat <<\_ACEOF
+
+Program names:
+  --program-prefix=PREFIX            prepend PREFIX to installed program names
+  --program-suffix=SUFFIX            append SUFFIX to installed program names
+  --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
+
+System types:
+  --build=BUILD     configure for building on BUILD [guessed]
+  --host=HOST       cross-compile to build programs to run on HOST [BUILD]
+_ACEOF
+fi
+
+if test -n "$ac_init_help"; then
+  case $ac_init_help in
+     short | recursive ) echo "Configuration of libpng 1.6.37:";;
+   esac
+  cat <<\_ACEOF
+
+Optional Features:
+  --disable-option-checking  ignore unrecognized --enable/--with options
+  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
+  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
+  --enable-silent-rules   less verbose build output (undo: "make V=1")
+  --disable-silent-rules  verbose build output (undo: "make V=0")
+  --enable-maintainer-mode
+                          enable make rules and dependencies not useful (and
+                          sometimes confusing) to the casual installer
+  --enable-dependency-tracking
+                          do not reject slow dependency extractors
+  --disable-dependency-tracking
+                          speeds up one-time build
+  --enable-shared[=PKGS]  build shared libraries [default=yes]
+  --enable-static[=PKGS]  build static libraries [default=yes]
+  --enable-fast-install[=PKGS]
+                          optimize for fast installation [default=yes]
+  --disable-libtool-lock  avoid locking (might break parallel builds)
+  --enable-werror[=OPT] Pass -Werror or the given argument to the compiler
+                          if it is supported
+  --enable-unversioned-links
+                          Installed libpng header files are placed in a
+                          versioned subdirectory and installed libpng library
+                          (including DLL) files are versioned. If this option
+                          is enabled unversioned links will be created
+                          pointing to the corresponding installed files. If
+                          you use libpng.pc or libpng-config for all builds
+                          you do not need these links, but if you compile
+                          programs directly they will typically #include
+                          <png.h> and link with -lpng; in that case you need
+                          the links. The links can be installed manually using
+                          'make install-header-links' and 'make
+                          install-library-links' and can be removed using the
+                          corresponding uninstall- targets. If you do enable
+                          this option every libpng 'make install' will
+                          recreate the links to point to the just installed
+                          version of libpng. The default is to create the
+                          links; use --disable-unversioned-links to change
+                          this
+  --enable-unversioned-libpng-pc
+                          Install the configuration file 'libpng.pc' as a link
+                          to the versioned version. This is done by default -
+                          use --disable-unversioned-libpng-pc to change this.
+  --enable-unversioned-libpng-config
+                          Install the configuration file 'libpng-config' as a
+                          link to the versioned version. This is done by
+                          default - use --disable-unversioned-libpng-config to
+                          change this.
+  --enable-hardware-optimizations
+                          Enable hardware optimizations: =no/off, yes/on:
+  --enable-arm-neon     Enable ARM NEON optimizations: =no/off, check, api,
+                          yes/on: no/off: disable the optimizations; check:
+                          use internal checking code (deprecated and poorly
+                          supported); api: disable by default, enable by a
+                          call to png_set_option; yes/on: turn on
+                          unconditionally. If not specified: determined by the
+                          compiler.
+  --enable-mips-msa     Enable MIPS MSA optimizations: =no/off, check, api,
+                          yes/on: no/off: disable the optimizations; check:
+                          use internal checking code (deprecated and poorly
+                          supported); api: disable by default, enable by a
+                          call to png_set_option; yes/on: turn on
+                          unconditionally. If not specified: determined by the
+                          compiler.
+  --enable-intel-sse    Enable Intel SSE optimizations: =no/off, yes/on:
+                          no/off: disable the optimizations; yes/on: enable
+                          the optimizations. If not specified: determined by
+                          the compiler.
+  --enable-powerpc-vsx  Enable POWERPC VSX optimizations: =no/off, check,
+                          api, yes/on: no/off: disable the optimizations;
+                          check: use internal checking code api: disable by
+                          default, enable by a call to png_set_option yes/on:
+                          turn on unconditionally. If not specified:
+                          determined by the compiler.
+
+Optional Packages:
+  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
+  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
+  --with-gnu-ld           assume the C compiler uses GNU ld [default=no]
+  --with-pic[=PKGS]       try to use only PIC/non-PIC objects [default=use
+                          both]
+  --with-aix-soname=aix|svr4|both
+                          shared library versioning (aka "SONAME") variant to
+                          provide on AIX, [default=aix].
+  --with-sysroot[=DIR]    Search for dependent libraries within DIR (or the
+                          compiler's sysroot if not specified).
+  --with-zlib-prefix    prefix that may have been used in installed zlib
+  --with-pkgconfigdir   Use the specified pkgconfig dir (default is
+                          libdir/pkgconfig)
+  --with-binconfigs     Generate shell libpng-config scripts as well as
+                          pkg-config data [default=yes]
+  --with-libpng-prefix  prefix libpng exported function (API) names with the
+                          given value
+
+Some influential environment variables:
+  CC          C compiler command
+  CFLAGS      C compiler flags
+  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
+              nonstandard directory <lib dir>
+  LIBS        libraries to pass to the linker, e.g. -l<library>
+  CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
+              you have headers in a nonstandard directory <include dir>
+  CCAS        assembler compiler command (defaults to CC)
+  CCASFLAGS   assembler compiler flags (defaults to CFLAGS)
+  CPP         C preprocessor
+  LT_SYS_LIBRARY_PATH
+              User-defined run-time library search path.
+  PNG_COPTS   additional flags for the C compiler, use this for options that
+              would cause configure itself to fail
+
+Use these variables to override the choices made by `configure' or to help
+it to find libraries and programs with nonstandard names/locations.
+
+Report bugs to <png-mng-implement@lists.sourceforge.net>.
+_ACEOF
+ac_status=$?
+fi
+
+if test "$ac_init_help" = "recursive"; then
+  # If there are subdirs, report their specific --help.
+  for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
+    test -d "$ac_dir" ||
+      { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
+      continue
+    ac_builddir=.
+
+case "$ac_dir" in
+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
+*)
+  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
+  # A ".." for each directory in $ac_dir_suffix.
+  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
+  case $ac_top_builddir_sub in
+  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
+  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
+  esac ;;
+esac
+ac_abs_top_builddir=$ac_pwd
+ac_abs_builddir=$ac_pwd$ac_dir_suffix
+# for backward compatibility:
+ac_top_builddir=$ac_top_build_prefix
+
+case $srcdir in
+  .)  # We are building in place.
+    ac_srcdir=.
+    ac_top_srcdir=$ac_top_builddir_sub
+    ac_abs_top_srcdir=$ac_pwd ;;
+  [\\/]* | ?:[\\/]* )  # Absolute name.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir
+    ac_abs_top_srcdir=$srcdir ;;
+  *) # Relative name.
+    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_build_prefix$srcdir
+    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
+esac
+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+
+    cd "$ac_dir" || { ac_status=$?; continue; }
+    # Check for guested configure.
+    if test -f "$ac_srcdir/configure.gnu"; then
+      echo &&
+      $SHELL "$ac_srcdir/configure.gnu" --help=recursive
+    elif test -f "$ac_srcdir/configure"; then
+      echo &&
+      $SHELL "$ac_srcdir/configure" --help=recursive
+    else
+      $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
+    fi || ac_status=$?
+    cd "$ac_pwd" || { ac_status=$?; break; }
+  done
+fi
+
+test -n "$ac_init_help" && exit $ac_status
+if $ac_init_version; then
+  cat <<\_ACEOF
+libpng configure 1.6.37
+generated by GNU Autoconf 2.69
+
+Copyright (C) 2012 Free Software Foundation, Inc.
+This configure script is free software; the Free Software Foundation
+gives unlimited permission to copy, distribute and modify it.
+_ACEOF
+  exit
+fi
+
+## ------------------------ ##
+## Autoconf initialization. ##
+## ------------------------ ##
+
+# ac_fn_c_try_compile LINENO
+# --------------------------
+# Try to compile conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_compile ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  rm -f conftest.$ac_objext
+  if { { ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compile") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest.$ac_objext; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_retval=1
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_compile
+
+# ac_fn_c_try_cpp LINENO
+# ----------------------
+# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_cpp ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if { { ac_try="$ac_cpp conftest.$ac_ext"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } > conftest.i && {
+	 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+    ac_retval=1
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_cpp
+
+# ac_fn_c_try_link LINENO
+# -----------------------
+# Try to link conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_link ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  rm -f conftest.$ac_objext conftest$ac_exeext
+  if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest$ac_exeext && {
+	 test "$cross_compiling" = yes ||
+	 test -x conftest$ac_exeext
+       }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_retval=1
+fi
+  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
+  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
+  # interfere with the next link command; also delete a directory that is
+  # left behind by Apple's compiler.  We do this before executing the actions.
+  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_link
+
+# ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
+# -------------------------------------------------------
+# Tests whether HEADER exists and can be compiled using the include files in
+# INCLUDES, setting the cache variable VAR accordingly.
+ac_fn_c_check_header_compile ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+#include <$2>
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  eval "$3=yes"
+else
+  eval "$3=no"
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_header_compile
+
+# ac_fn_c_try_run LINENO
+# ----------------------
+# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
+# that executables *can* be run.
+ac_fn_c_try_run ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
+  { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: program exited with status $ac_status" >&5
+       $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+       ac_retval=$ac_status
+fi
+  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_run
+
+# ac_fn_c_check_func LINENO FUNC VAR
+# ----------------------------------
+# Tests whether FUNC exists, setting the cache variable VAR accordingly
+ac_fn_c_check_func ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+/* Define $2 to an innocuous variant, in case <limits.h> declares $2.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define $2 innocuous_$2
+
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char $2 (); below.
+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+    <limits.h> exists even on freestanding compilers.  */
+
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+
+#undef $2
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char $2 ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_$2 || defined __stub___$2
+choke me
+#endif
+
+int
+main ()
+{
+return $2 ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  eval "$3=yes"
+else
+  eval "$3=no"
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_func
+
+# ac_fn_c_check_type LINENO TYPE VAR INCLUDES
+# -------------------------------------------
+# Tests whether TYPE exists after having included INCLUDES, setting cache
+# variable VAR accordingly.
+ac_fn_c_check_type ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  eval "$3=no"
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+int
+main ()
+{
+if (sizeof ($2))
+	 return 0;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+int
+main ()
+{
+if (sizeof (($2)))
+	    return 0;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+
+else
+  eval "$3=yes"
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_type
+cat >config.log <<_ACEOF
+This file contains any messages produced by compilers while
+running configure, to aid debugging if configure makes a mistake.
+
+It was created by libpng $as_me 1.6.37, which was
+generated by GNU Autoconf 2.69.  Invocation command line was
+
+  $ $0 $@
+
+_ACEOF
+exec 5>>config.log
+{
+cat <<_ASUNAME
+## --------- ##
+## Platform. ##
+## --------- ##
+
+hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
+uname -m = `(uname -m) 2>/dev/null || echo unknown`
+uname -r = `(uname -r) 2>/dev/null || echo unknown`
+uname -s = `(uname -s) 2>/dev/null || echo unknown`
+uname -v = `(uname -v) 2>/dev/null || echo unknown`
+
+/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
+/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
+
+/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
+/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
+/usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
+/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
+/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
+/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
+
+_ASUNAME
+
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    $as_echo "PATH: $as_dir"
+  done
+IFS=$as_save_IFS
+
+} >&5
+
+cat >&5 <<_ACEOF
+
+
+## ----------- ##
+## Core tests. ##
+## ----------- ##
+
+_ACEOF
+
+
+# Keep a trace of the command line.
+# Strip out --no-create and --no-recursion so they do not pile up.
+# Strip out --silent because we don't want to record it for future runs.
+# Also quote any args containing shell meta-characters.
+# Make two passes to allow for proper duplicate-argument suppression.
+ac_configure_args=
+ac_configure_args0=
+ac_configure_args1=
+ac_must_keep_next=false
+for ac_pass in 1 2
+do
+  for ac_arg
+  do
+    case $ac_arg in
+    -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
+    -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+    | -silent | --silent | --silen | --sile | --sil)
+      continue ;;
+    *\'*)
+      ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    esac
+    case $ac_pass in
+    1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
+    2)
+      as_fn_append ac_configure_args1 " '$ac_arg'"
+      if test $ac_must_keep_next = true; then
+	ac_must_keep_next=false # Got value, back to normal.
+      else
+	case $ac_arg in
+	  *=* | --config-cache | -C | -disable-* | --disable-* \
+	  | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
+	  | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
+	  | -with-* | --with-* | -without-* | --without-* | --x)
+	    case "$ac_configure_args0 " in
+	      "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
+	    esac
+	    ;;
+	  -* ) ac_must_keep_next=true ;;
+	esac
+      fi
+      as_fn_append ac_configure_args " '$ac_arg'"
+      ;;
+    esac
+  done
+done
+{ ac_configure_args0=; unset ac_configure_args0;}
+{ ac_configure_args1=; unset ac_configure_args1;}
+
+# When interrupted or exit'd, cleanup temporary files, and complete
+# config.log.  We remove comments because anyway the quotes in there
+# would cause problems or look ugly.
+# WARNING: Use '\'' to represent an apostrophe within the trap.
+# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
+trap 'exit_status=$?
+  # Save into config.log some information that might help in debugging.
+  {
+    echo
+
+    $as_echo "## ---------------- ##
+## Cache variables. ##
+## ---------------- ##"
+    echo
+    # The following way of writing the cache mishandles newlines in values,
+(
+  for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
+    eval ac_val=\$$ac_var
+    case $ac_val in #(
+    *${as_nl}*)
+      case $ac_var in #(
+      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
+$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+      esac
+      case $ac_var in #(
+      _ | IFS | as_nl) ;; #(
+      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
+      *) { eval $ac_var=; unset $ac_var;} ;;
+      esac ;;
+    esac
+  done
+  (set) 2>&1 |
+    case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
+    *${as_nl}ac_space=\ *)
+      sed -n \
+	"s/'\''/'\''\\\\'\'''\''/g;
+	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
+      ;; #(
+    *)
+      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+      ;;
+    esac |
+    sort
+)
+    echo
+
+    $as_echo "## ----------------- ##
+## Output variables. ##
+## ----------------- ##"
+    echo
+    for ac_var in $ac_subst_vars
+    do
+      eval ac_val=\$$ac_var
+      case $ac_val in
+      *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
+      esac
+      $as_echo "$ac_var='\''$ac_val'\''"
+    done | sort
+    echo
+
+    if test -n "$ac_subst_files"; then
+      $as_echo "## ------------------- ##
+## File substitutions. ##
+## ------------------- ##"
+      echo
+      for ac_var in $ac_subst_files
+      do
+	eval ac_val=\$$ac_var
+	case $ac_val in
+	*\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
+	esac
+	$as_echo "$ac_var='\''$ac_val'\''"
+      done | sort
+      echo
+    fi
+
+    if test -s confdefs.h; then
+      $as_echo "## ----------- ##
+## confdefs.h. ##
+## ----------- ##"
+      echo
+      cat confdefs.h
+      echo
+    fi
+    test "$ac_signal" != 0 &&
+      $as_echo "$as_me: caught signal $ac_signal"
+    $as_echo "$as_me: exit $exit_status"
+  } >&5
+  rm -f core *.core core.conftest.* &&
+    rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
+    exit $exit_status
+' 0
+for ac_signal in 1 2 13 15; do
+  trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
+done
+ac_signal=0
+
+# confdefs.h avoids OS command line length limits that DEFS can exceed.
+rm -f -r conftest* confdefs.h
+
+$as_echo "/* confdefs.h */" > confdefs.h
+
+# Predefined preprocessor variables.
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_NAME "$PACKAGE_NAME"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_VERSION "$PACKAGE_VERSION"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_STRING "$PACKAGE_STRING"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_URL "$PACKAGE_URL"
+_ACEOF
+
+
+# Let the site file select an alternate cache file if it wants to.
+# Prefer an explicitly selected file to automatically selected ones.
+ac_site_file1=NONE
+ac_site_file2=NONE
+if test -n "$CONFIG_SITE"; then
+  # We do not want a PATH search for config.site.
+  case $CONFIG_SITE in #((
+    -*)  ac_site_file1=./$CONFIG_SITE;;
+    */*) ac_site_file1=$CONFIG_SITE;;
+    *)   ac_site_file1=./$CONFIG_SITE;;
+  esac
+elif test "x$prefix" != xNONE; then
+  ac_site_file1=$prefix/share/config.site
+  ac_site_file2=$prefix/etc/config.site
+else
+  ac_site_file1=$ac_default_prefix/share/config.site
+  ac_site_file2=$ac_default_prefix/etc/config.site
+fi
+for ac_site_file in "$ac_site_file1" "$ac_site_file2"
+do
+  test "x$ac_site_file" = xNONE && continue
+  if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
+$as_echo "$as_me: loading site script $ac_site_file" >&6;}
+    sed 's/^/| /' "$ac_site_file" >&5
+    . "$ac_site_file" \
+      || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "failed to load site script $ac_site_file
+See \`config.log' for more details" "$LINENO" 5; }
+  fi
+done
+
+if test -r "$cache_file"; then
+  # Some versions of bash will fail to source /dev/null (special files
+  # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
+  if test /dev/null != "$cache_file" && test -f "$cache_file"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
+$as_echo "$as_me: loading cache $cache_file" >&6;}
+    case $cache_file in
+      [\\/]* | ?:[\\/]* ) . "$cache_file";;
+      *)                      . "./$cache_file";;
+    esac
+  fi
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
+$as_echo "$as_me: creating cache $cache_file" >&6;}
+  >$cache_file
+fi
+
+# Check that the precious variables saved in the cache have kept the same
+# value.
+ac_cache_corrupted=false
+for ac_var in $ac_precious_vars; do
+  eval ac_old_set=\$ac_cv_env_${ac_var}_set
+  eval ac_new_set=\$ac_env_${ac_var}_set
+  eval ac_old_val=\$ac_cv_env_${ac_var}_value
+  eval ac_new_val=\$ac_env_${ac_var}_value
+  case $ac_old_set,$ac_new_set in
+    set,)
+      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
+$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
+      ac_cache_corrupted=: ;;
+    ,set)
+      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
+$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
+      ac_cache_corrupted=: ;;
+    ,);;
+    *)
+      if test "x$ac_old_val" != "x$ac_new_val"; then
+	# differences in whitespace do not lead to failure.
+	ac_old_val_w=`echo x $ac_old_val`
+	ac_new_val_w=`echo x $ac_new_val`
+	if test "$ac_old_val_w" != "$ac_new_val_w"; then
+	  { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
+$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
+	  ac_cache_corrupted=:
+	else
+	  { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
+$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
+	  eval $ac_var=\$ac_old_val
+	fi
+	{ $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
+$as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
+	{ $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
+$as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
+      fi;;
+  esac
+  # Pass precious variables to config.status.
+  if test "$ac_new_set" = set; then
+    case $ac_new_val in
+    *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
+    *) ac_arg=$ac_var=$ac_new_val ;;
+    esac
+    case " $ac_configure_args " in
+      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
+      *) as_fn_append ac_configure_args " '$ac_arg'" ;;
+    esac
+  fi
+done
+if $ac_cache_corrupted; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+  { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
+$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
+  as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
+fi
+## -------------------- ##
+## Main body of script. ##
+## -------------------- ##
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+
+
+# libpng does not follow GNU file name conventions (hence 'foreign')
+# color-tests requires automake 1.11 or later
+# silent-rules requires automake 1.11 or later
+# dist-xz requires automake 1.11 or later
+# 1.12.2 fixes a security issue in 1.11.2 and 1.12.1
+# 1.13 is required for parallel tests
+am__api_version='1.16'
+
+ac_aux_dir=
+for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do
+  if test -f "$ac_dir/install-sh"; then
+    ac_aux_dir=$ac_dir
+    ac_install_sh="$ac_aux_dir/install-sh -c"
+    break
+  elif test -f "$ac_dir/install.sh"; then
+    ac_aux_dir=$ac_dir
+    ac_install_sh="$ac_aux_dir/install.sh -c"
+    break
+  elif test -f "$ac_dir/shtool"; then
+    ac_aux_dir=$ac_dir
+    ac_install_sh="$ac_aux_dir/shtool install -c"
+    break
+  fi
+done
+if test -z "$ac_aux_dir"; then
+  as_fn_error $? "cannot find install-sh, install.sh, or shtool in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" "$LINENO" 5
+fi
+
+# These three variables are undocumented and unsupported,
+# and are intended to be withdrawn in a future Autoconf release.
+# They can cause serious problems if a builder's source tree is in a directory
+# whose full name contains unusual characters.
+ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
+ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
+ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
+
+
+# Find a good install program.  We prefer a C program (faster),
+# so one script is as good as another.  But avoid the broken or
+# incompatible versions:
+# SysV /etc/install, /usr/sbin/install
+# SunOS /usr/etc/install
+# IRIX /sbin/install
+# AIX /bin/install
+# AmigaOS /C/install, which installs bootblocks on floppy discs
+# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
+# AFS /usr/afsws/bin/install, which mishandles nonexistent args
+# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
+# OS/2's system install, which has a completely different semantic
+# ./install, which can be erroneously created by make from ./install.sh.
+# Reject install programs that cannot install multiple files.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5
+$as_echo_n "checking for a BSD-compatible install... " >&6; }
+if test -z "$INSTALL"; then
+if ${ac_cv_path_install+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    # Account for people who put trailing slashes in PATH elements.
+case $as_dir/ in #((
+  ./ | .// | /[cC]/* | \
+  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
+  ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \
+  /usr/ucb/* ) ;;
+  *)
+    # OSF1 and SCO ODT 3.0 have their own names for install.
+    # Don't use installbsd from OSF since it installs stuff as root
+    # by default.
+    for ac_prog in ginstall scoinst install; do
+      for ac_exec_ext in '' $ac_executable_extensions; do
+	if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
+	  if test $ac_prog = install &&
+	    grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+	    # AIX install.  It has an incompatible calling convention.
+	    :
+	  elif test $ac_prog = install &&
+	    grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+	    # program-specific install script used by HP pwplus--don't use.
+	    :
+	  else
+	    rm -rf conftest.one conftest.two conftest.dir
+	    echo one > conftest.one
+	    echo two > conftest.two
+	    mkdir conftest.dir
+	    if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
+	      test -s conftest.one && test -s conftest.two &&
+	      test -s conftest.dir/conftest.one &&
+	      test -s conftest.dir/conftest.two
+	    then
+	      ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
+	      break 3
+	    fi
+	  fi
+	fi
+      done
+    done
+    ;;
+esac
+
+  done
+IFS=$as_save_IFS
+
+rm -rf conftest.one conftest.two conftest.dir
+
+fi
+  if test "${ac_cv_path_install+set}" = set; then
+    INSTALL=$ac_cv_path_install
+  else
+    # As a last resort, use the slow shell script.  Don't cache a
+    # value for INSTALL within a source directory, because that will
+    # break other packages using the cache if that directory is
+    # removed, or if the value is a relative name.
+    INSTALL=$ac_install_sh
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5
+$as_echo "$INSTALL" >&6; }
+
+# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
+# It thinks the first close brace ends the variable substitution.
+test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
+
+test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
+
+test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5
+$as_echo_n "checking whether build environment is sane... " >&6; }
+# Reject unsafe characters in $srcdir or the absolute working directory
+# name.  Accept space and tab only in the latter.
+am_lf='
+'
+case `pwd` in
+  *[\\\"\#\$\&\'\`$am_lf]*)
+    as_fn_error $? "unsafe absolute working directory name" "$LINENO" 5;;
+esac
+case $srcdir in
+  *[\\\"\#\$\&\'\`$am_lf\ \	]*)
+    as_fn_error $? "unsafe srcdir value: '$srcdir'" "$LINENO" 5;;
+esac
+
+# Do 'set' in a subshell so we don't clobber the current shell's
+# arguments.  Must try -L first in case configure is actually a
+# symlink; some systems play weird games with the mod time of symlinks
+# (eg FreeBSD returns the mod time of the symlink's containing
+# directory).
+if (
+   am_has_slept=no
+   for am_try in 1 2; do
+     echo "timestamp, slept: $am_has_slept" > conftest.file
+     set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
+     if test "$*" = "X"; then
+	# -L didn't work.
+	set X `ls -t "$srcdir/configure" conftest.file`
+     fi
+     if test "$*" != "X $srcdir/configure conftest.file" \
+	&& test "$*" != "X conftest.file $srcdir/configure"; then
+
+	# If neither matched, then we have a broken ls.  This can happen
+	# if, for instance, CONFIG_SHELL is bash and it inherits a
+	# broken ls alias from the environment.  This has actually
+	# happened.  Such a system could not be considered "sane".
+	as_fn_error $? "ls -t appears to fail.  Make sure there is not a broken
+  alias in your environment" "$LINENO" 5
+     fi
+     if test "$2" = conftest.file || test $am_try -eq 2; then
+       break
+     fi
+     # Just in case.
+     sleep 1
+     am_has_slept=yes
+   done
+   test "$2" = conftest.file
+   )
+then
+   # Ok.
+   :
+else
+   as_fn_error $? "newly created file is older than distributed files!
+Check your system clock" "$LINENO" 5
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+# If we didn't sleep, we still need to ensure time stamps of config.status and
+# generated files are strictly newer.
+am_sleep_pid=
+if grep 'slept: no' conftest.file >/dev/null 2>&1; then
+  ( sleep 1 ) &
+  am_sleep_pid=$!
+fi
+
+rm -f conftest.file
+
+test "$program_prefix" != NONE &&
+  program_transform_name="s&^&$program_prefix&;$program_transform_name"
+# Use a double $ so make ignores it.
+test "$program_suffix" != NONE &&
+  program_transform_name="s&\$&$program_suffix&;$program_transform_name"
+# Double any \ or $.
+# By default was `s,x,x', remove it if useless.
+ac_script='s/[\\$]/&&/g;s/;s,x,x,$//'
+program_transform_name=`$as_echo "$program_transform_name" | sed "$ac_script"`
+
+# Expand $ac_aux_dir to an absolute path.
+am_aux_dir=`cd "$ac_aux_dir" && pwd`
+
+if test x"${MISSING+set}" != xset; then
+  case $am_aux_dir in
+  *\ * | *\	*)
+    MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;;
+  *)
+    MISSING="\${SHELL} $am_aux_dir/missing" ;;
+  esac
+fi
+# Use eval to expand $SHELL
+if eval "$MISSING --is-lightweight"; then
+  am_missing_run="$MISSING "
+else
+  am_missing_run=
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: 'missing' script is too old or missing" >&5
+$as_echo "$as_me: WARNING: 'missing' script is too old or missing" >&2;}
+fi
+
+if test x"${install_sh+set}" != xset; then
+  case $am_aux_dir in
+  *\ * | *\	*)
+    install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
+  *)
+    install_sh="\${SHELL} $am_aux_dir/install-sh"
+  esac
+fi
+
+# Installed binaries are usually stripped using 'strip' when the user
+# run "make install-strip".  However 'strip' might not be the right
+# tool to use in cross-compilation environments, therefore Automake
+# will honor the 'STRIP' environment variable to overrule this program.
+if test "$cross_compiling" != no; then
+  if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
+set dummy ${ac_tool_prefix}strip; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_STRIP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$STRIP"; then
+  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+STRIP=$ac_cv_prog_STRIP
+if test -n "$STRIP"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
+$as_echo "$STRIP" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_STRIP"; then
+  ac_ct_STRIP=$STRIP
+  # Extract the first word of "strip", so it can be a program name with args.
+set dummy strip; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_STRIP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_STRIP"; then
+  ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_STRIP="strip"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
+if test -n "$ac_ct_STRIP"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
+$as_echo "$ac_ct_STRIP" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_STRIP" = x; then
+    STRIP=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    STRIP=$ac_ct_STRIP
+  fi
+else
+  STRIP="$ac_cv_prog_STRIP"
+fi
+
+fi
+INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a thread-safe mkdir -p" >&5
+$as_echo_n "checking for a thread-safe mkdir -p... " >&6; }
+if test -z "$MKDIR_P"; then
+  if ${ac_cv_path_mkdir+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/opt/sfw/bin
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in mkdir gmkdir; do
+	 for ac_exec_ext in '' $ac_executable_extensions; do
+	   as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext" || continue
+	   case `"$as_dir/$ac_prog$ac_exec_ext" --version 2>&1` in #(
+	     'mkdir (GNU coreutils) '* | \
+	     'mkdir (coreutils) '* | \
+	     'mkdir (fileutils) '4.1*)
+	       ac_cv_path_mkdir=$as_dir/$ac_prog$ac_exec_ext
+	       break 3;;
+	   esac
+	 done
+       done
+  done
+IFS=$as_save_IFS
+
+fi
+
+  test -d ./--version && rmdir ./--version
+  if test "${ac_cv_path_mkdir+set}" = set; then
+    MKDIR_P="$ac_cv_path_mkdir -p"
+  else
+    # As a last resort, use the slow shell script.  Don't cache a
+    # value for MKDIR_P within a source directory, because that will
+    # break other packages using the cache if that directory is
+    # removed, or if the value is a relative name.
+    MKDIR_P="$ac_install_sh -d"
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5
+$as_echo "$MKDIR_P" >&6; }
+
+for ac_prog in gawk mawk nawk awk
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_AWK+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$AWK"; then
+  ac_cv_prog_AWK="$AWK" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_AWK="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+AWK=$ac_cv_prog_AWK
+if test -n "$AWK"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
+$as_echo "$AWK" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$AWK" && break
+done
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5
+$as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
+set x ${MAKE-make}
+ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
+if eval \${ac_cv_prog_make_${ac_make}_set+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat >conftest.make <<\_ACEOF
+SHELL = /bin/sh
+all:
+	@echo '@@@%%%=$(MAKE)=@@@%%%'
+_ACEOF
+# GNU make sometimes prints "make[1]: Entering ...", which would confuse us.
+case `${MAKE-make} -f conftest.make 2>/dev/null` in
+  *@@@%%%=?*=@@@%%%*)
+    eval ac_cv_prog_make_${ac_make}_set=yes;;
+  *)
+    eval ac_cv_prog_make_${ac_make}_set=no;;
+esac
+rm -f conftest.make
+fi
+if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+  SET_MAKE=
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+  SET_MAKE="MAKE=${MAKE-make}"
+fi
+
+rm -rf .tst 2>/dev/null
+mkdir .tst 2>/dev/null
+if test -d .tst; then
+  am__leading_dot=.
+else
+  am__leading_dot=_
+fi
+rmdir .tst 2>/dev/null
+
+# Check whether --enable-silent-rules was given.
+if test "${enable_silent_rules+set}" = set; then :
+  enableval=$enable_silent_rules;
+fi
+
+case $enable_silent_rules in # (((
+  yes) AM_DEFAULT_VERBOSITY=0;;
+   no) AM_DEFAULT_VERBOSITY=1;;
+    *) AM_DEFAULT_VERBOSITY=1;;
+esac
+am_make=${MAKE-make}
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $am_make supports nested variables" >&5
+$as_echo_n "checking whether $am_make supports nested variables... " >&6; }
+if ${am_cv_make_support_nested_variables+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if $as_echo 'TRUE=$(BAR$(V))
+BAR0=false
+BAR1=true
+V=1
+am__doit:
+	@$(TRUE)
+.PHONY: am__doit' | $am_make -f - >/dev/null 2>&1; then
+  am_cv_make_support_nested_variables=yes
+else
+  am_cv_make_support_nested_variables=no
+fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables" >&5
+$as_echo "$am_cv_make_support_nested_variables" >&6; }
+if test $am_cv_make_support_nested_variables = yes; then
+    AM_V='$(V)'
+  AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
+else
+  AM_V=$AM_DEFAULT_VERBOSITY
+  AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY
+fi
+AM_BACKSLASH='\'
+
+if test "`cd $srcdir && pwd`" != "`pwd`"; then
+  # Use -I$(srcdir) only when $(srcdir) != ., so that make's output
+  # is not polluted with repeated "-I."
+  am__isrc=' -I$(srcdir)'
+  # test to see if srcdir already configured
+  if test -f $srcdir/config.status; then
+    as_fn_error $? "source directory already configured; run \"make distclean\" there first" "$LINENO" 5
+  fi
+fi
+
+# test whether we have cygpath
+if test -z "$CYGPATH_W"; then
+  if (cygpath --version) >/dev/null 2>/dev/null; then
+    CYGPATH_W='cygpath -w'
+  else
+    CYGPATH_W=echo
+  fi
+fi
+
+
+# Define the identity of the package.
+ PACKAGE='libpng'
+ VERSION='1.6.37'
+
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE "$PACKAGE"
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define VERSION "$VERSION"
+_ACEOF
+
+# Some tools Automake needs.
+
+ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"}
+
+
+AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"}
+
+
+AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"}
+
+
+AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"}
+
+
+MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"}
+
+# For better backward compatibility.  To be removed once Automake 1.9.x
+# dies out for good.  For more background, see:
+# <https://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
+# <https://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
+mkdir_p='$(MKDIR_P)'
+
+# We need awk for the "check" target (and possibly the TAP driver).  The
+# system "awk" is bad on some platforms.
+# Always define AMTAR for backward compatibility.  Yes, it's still used
+# in the wild :-(  We should find a proper way to deprecate it ...
+AMTAR='$${TAR-tar}'
+
+
+# We'll loop over all known methods to create a tar archive until one works.
+_am_tools='gnutar  pax cpio none'
+
+am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'
+
+
+
+
+
+
+# POSIX will say in a future version that running "rm -f" with no argument
+# is OK; and we want to be able to make that assumption in our Makefile
+# recipes.  So use an aggressive probe to check that the usage we want is
+# actually supported "in the wild" to an acceptable degree.
+# See automake bug#10828.
+# To make any issue more visible, cause the running configure to be aborted
+# by default if the 'rm' program in use doesn't match our expectations; the
+# user can still override this though.
+if rm -f && rm -fr && rm -rf; then : OK; else
+  cat >&2 <<'END'
+Oops!
+
+Your 'rm' program seems unable to run without file operands specified
+on the command line, even when the '-f' option is present.  This is contrary
+to the behaviour of most rm programs out there, and not conforming with
+the upcoming POSIX standard: <http://austingroupbugs.net/view.php?id=542>
+
+Please tell bug-automake@gnu.org about your system, including the value
+of your $PATH and any error possibly output before this message.  This
+can help us improve future automake versions.
+
+END
+  if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then
+    echo 'Configuration will proceed anyway, since you have set the' >&2
+    echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2
+    echo >&2
+  else
+    cat >&2 <<'END'
+Aborting the configuration process, to ensure you take notice of the issue.
+
+You can download and install GNU coreutils to get an 'rm' implementation
+that behaves properly: <https://www.gnu.org/software/coreutils/>.
+
+If you want to complete the configuration process using your problematic
+'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
+to "yes", and re-run configure.
+
+END
+    as_fn_error $? "Your 'rm' program is bad, sorry." "$LINENO" 5
+  fi
+fi
+
+# The following line causes --disable-maintainer-mode to be the default to
+# configure. This is necessary because libpng distributions cannot rely on the
+# time stamps of the autotools generated files being correct
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable maintainer-specific portions of Makefiles" >&5
+$as_echo_n "checking whether to enable maintainer-specific portions of Makefiles... " >&6; }
+    # Check whether --enable-maintainer-mode was given.
+if test "${enable_maintainer_mode+set}" = set; then :
+  enableval=$enable_maintainer_mode; USE_MAINTAINER_MODE=$enableval
+else
+  USE_MAINTAINER_MODE=no
+fi
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $USE_MAINTAINER_MODE" >&5
+$as_echo "$USE_MAINTAINER_MODE" >&6; }
+   if test $USE_MAINTAINER_MODE = yes; then
+  MAINTAINER_MODE_TRUE=
+  MAINTAINER_MODE_FALSE='#'
+else
+  MAINTAINER_MODE_TRUE='#'
+  MAINTAINER_MODE_FALSE=
+fi
+
+  MAINT=$MAINTAINER_MODE_TRUE
+
+
+
+
+PNGLIB_VERSION=1.6.37
+PNGLIB_MAJOR=1
+PNGLIB_MINOR=6
+PNGLIB_RELEASE=37
+
+
+
+ac_config_headers="$ac_config_headers config.h"
+
+
+# Checks for programs.
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
+set dummy ${ac_tool_prefix}gcc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="${ac_tool_prefix}gcc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_CC"; then
+  ac_ct_CC=$CC
+  # Extract the first word of "gcc", so it can be a program name with args.
+set dummy gcc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_CC"; then
+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC="gcc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
+$as_echo "$ac_ct_CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_CC" = x; then
+    CC=""
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    CC=$ac_ct_CC
+  fi
+else
+  CC="$ac_cv_prog_CC"
+fi
+
+if test -z "$CC"; then
+          if test -n "$ac_tool_prefix"; then
+    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
+set dummy ${ac_tool_prefix}cc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="${ac_tool_prefix}cc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  fi
+fi
+if test -z "$CC"; then
+  # Extract the first word of "cc", so it can be a program name with args.
+set dummy cc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+  ac_prog_rejected=no
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
+       ac_prog_rejected=yes
+       continue
+     fi
+    ac_cv_prog_CC="cc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+if test $ac_prog_rejected = yes; then
+  # We found a bogon in the path, so make sure we never use it.
+  set dummy $ac_cv_prog_CC
+  shift
+  if test $# != 0; then
+    # We chose a different compiler from the bogus one.
+    # However, it has the same basename, so the bogon will be chosen
+    # first if we set CC to just the basename; use the full file name.
+    shift
+    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
+  fi
+fi
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$CC"; then
+  if test -n "$ac_tool_prefix"; then
+  for ac_prog in cl.exe
+  do
+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+    test -n "$CC" && break
+  done
+fi
+if test -z "$CC"; then
+  ac_ct_CC=$CC
+  for ac_prog in cl.exe
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_CC"; then
+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
+$as_echo "$ac_ct_CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$ac_ct_CC" && break
+done
+
+  if test "x$ac_ct_CC" = x; then
+    CC=""
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    CC=$ac_ct_CC
+  fi
+fi
+
+fi
+
+
+test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "no acceptable C compiler found in \$PATH
+See \`config.log' for more details" "$LINENO" 5; }
+
+# Provide some information about the compiler.
+$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
+set X $ac_compile
+ac_compiler=$2
+for ac_option in --version -v -V -qversion; do
+  { { ac_try="$ac_compiler $ac_option >&5"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    sed '10a\
+... rest of stderr output deleted ...
+         10q' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+  fi
+  rm -f conftest.er1 conftest.err
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+done
+
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
+# Try to create an executable without -o first, disregard a.out.
+# It will help us diagnose broken compilers, and finding out an intuition
+# of exeext.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
+$as_echo_n "checking whether the C compiler works... " >&6; }
+ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
+
+# The possible output files:
+ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
+
+ac_rmfiles=
+for ac_file in $ac_files
+do
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
+    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
+  esac
+done
+rm -f $ac_rmfiles
+
+if { { ac_try="$ac_link_default"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link_default") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
+# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
+# in a Makefile.  We should not override ac_cv_exeext if it was cached,
+# so that the user can short-circuit this test for compilers unknown to
+# Autoconf.
+for ac_file in $ac_files ''
+do
+  test -f "$ac_file" || continue
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
+	;;
+    [ab].out )
+	# We found the default executable, but exeext='' is most
+	# certainly right.
+	break;;
+    *.* )
+	if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
+	then :; else
+	   ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+	fi
+	# We set ac_cv_exeext here because the later test for it is not
+	# safe: cross compilers may not add the suffix if given an `-o'
+	# argument, so we may need to know it at that point already.
+	# Even if this section looks crufty: it has the advantage of
+	# actually working.
+	break;;
+    * )
+	break;;
+  esac
+done
+test "$ac_cv_exeext" = no && ac_cv_exeext=
+
+else
+  ac_file=''
+fi
+if test -z "$ac_file"; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+$as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error 77 "C compiler cannot create executables
+See \`config.log' for more details" "$LINENO" 5; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
+$as_echo_n "checking for C compiler default output file name... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
+$as_echo "$ac_file" >&6; }
+ac_exeext=$ac_cv_exeext
+
+rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
+ac_clean_files=$ac_clean_files_save
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
+$as_echo_n "checking for suffix of executables... " >&6; }
+if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  # If both `conftest.exe' and `conftest' are `present' (well, observable)
+# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
+# work properly (i.e., refer to `conftest.exe'), while it won't with
+# `rm'.
+for ac_file in conftest.exe conftest conftest.*; do
+  test -f "$ac_file" || continue
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
+    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+	  break;;
+    * ) break;;
+  esac
+done
+else
+  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot compute suffix of executables: cannot compile and link
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+rm -f conftest conftest$ac_cv_exeext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
+$as_echo "$ac_cv_exeext" >&6; }
+
+rm -f conftest.$ac_ext
+EXEEXT=$ac_cv_exeext
+ac_exeext=$EXEEXT
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdio.h>
+int
+main ()
+{
+FILE *f = fopen ("conftest.out", "w");
+ return ferror (f) || fclose (f) != 0;
+
+  ;
+  return 0;
+}
+_ACEOF
+ac_clean_files="$ac_clean_files conftest.out"
+# Check that the compiler produces executables we can run.  If not, either
+# the compiler is broken, or we cross compile.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
+$as_echo_n "checking whether we are cross compiling... " >&6; }
+if test "$cross_compiling" != yes; then
+  { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+  if { ac_try='./conftest$ac_cv_exeext'
+  { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; }; then
+    cross_compiling=no
+  else
+    if test "$cross_compiling" = maybe; then
+	cross_compiling=yes
+    else
+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot run C compiled programs.
+If you meant to cross compile, use \`--host'.
+See \`config.log' for more details" "$LINENO" 5; }
+    fi
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
+$as_echo "$cross_compiling" >&6; }
+
+rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
+ac_clean_files=$ac_clean_files_save
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
+$as_echo_n "checking for suffix of object files... " >&6; }
+if ${ac_cv_objext+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.o conftest.obj
+if { { ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compile") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  for ac_file in conftest.o conftest.obj conftest.*; do
+  test -f "$ac_file" || continue;
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
+    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
+       break;;
+  esac
+done
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot compute suffix of object files: cannot compile
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+rm -f conftest.$ac_cv_objext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
+$as_echo "$ac_cv_objext" >&6; }
+OBJEXT=$ac_cv_objext
+ac_objext=$OBJEXT
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
+$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
+if ${ac_cv_c_compiler_gnu+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+#ifndef __GNUC__
+       choke me
+#endif
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_compiler_gnu=yes
+else
+  ac_compiler_gnu=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ac_cv_c_compiler_gnu=$ac_compiler_gnu
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
+$as_echo "$ac_cv_c_compiler_gnu" >&6; }
+if test $ac_compiler_gnu = yes; then
+  GCC=yes
+else
+  GCC=
+fi
+ac_test_CFLAGS=${CFLAGS+set}
+ac_save_CFLAGS=$CFLAGS
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
+$as_echo_n "checking whether $CC accepts -g... " >&6; }
+if ${ac_cv_prog_cc_g+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_save_c_werror_flag=$ac_c_werror_flag
+   ac_c_werror_flag=yes
+   ac_cv_prog_cc_g=no
+   CFLAGS="-g"
+   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_prog_cc_g=yes
+else
+  CFLAGS=""
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+
+else
+  ac_c_werror_flag=$ac_save_c_werror_flag
+	 CFLAGS="-g"
+	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_prog_cc_g=yes
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+   ac_c_werror_flag=$ac_save_c_werror_flag
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
+$as_echo "$ac_cv_prog_cc_g" >&6; }
+if test "$ac_test_CFLAGS" = set; then
+  CFLAGS=$ac_save_CFLAGS
+elif test $ac_cv_prog_cc_g = yes; then
+  if test "$GCC" = yes; then
+    CFLAGS="-g -O2"
+  else
+    CFLAGS="-g"
+  fi
+else
+  if test "$GCC" = yes; then
+    CFLAGS="-O2"
+  else
+    CFLAGS=
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
+$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
+if ${ac_cv_prog_cc_c89+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_cv_prog_cc_c89=no
+ac_save_CC=$CC
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdarg.h>
+#include <stdio.h>
+struct stat;
+/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
+struct buf { int x; };
+FILE * (*rcsopen) (struct buf *, struct stat *, int);
+static char *e (p, i)
+     char **p;
+     int i;
+{
+  return p[i];
+}
+static char *f (char * (*g) (char **, int), char **p, ...)
+{
+  char *s;
+  va_list v;
+  va_start (v,p);
+  s = g (p, va_arg (v,int));
+  va_end (v);
+  return s;
+}
+
+/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
+   function prototypes and stuff, but not '\xHH' hex character constants.
+   These don't provoke an error unfortunately, instead are silently treated
+   as 'x'.  The following induces an error, until -std is added to get
+   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
+   array size at least.  It's necessary to write '\x00'==0 to get something
+   that's true only with -std.  */
+int osf4_cc_array ['\x00' == 0 ? 1 : -1];
+
+/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
+   inside strings and character constants.  */
+#define FOO(x) 'x'
+int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
+
+int test (int i, double x);
+struct s1 {int (*f) (int a);};
+struct s2 {int (*f) (double a);};
+int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
+int argc;
+char **argv;
+int
+main ()
+{
+return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
+  ;
+  return 0;
+}
+_ACEOF
+for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
+	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
+do
+  CC="$ac_save_CC $ac_arg"
+  if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_prog_cc_c89=$ac_arg
+fi
+rm -f core conftest.err conftest.$ac_objext
+  test "x$ac_cv_prog_cc_c89" != "xno" && break
+done
+rm -f conftest.$ac_ext
+CC=$ac_save_CC
+
+fi
+# AC_CACHE_VAL
+case "x$ac_cv_prog_cc_c89" in
+  x)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
+$as_echo "none needed" >&6; } ;;
+  xno)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
+$as_echo "unsupported" >&6; } ;;
+  *)
+    CC="$CC $ac_cv_prog_cc_c89"
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
+$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
+esac
+if test "x$ac_cv_prog_cc_c89" != xno; then :
+
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC understands -c and -o together" >&5
+$as_echo_n "checking whether $CC understands -c and -o together... " >&6; }
+if ${am_cv_prog_cc_c_o+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+  # Make sure it works both with $CC and with simple cc.
+  # Following AC_PROG_CC_C_O, we do the test twice because some
+  # compilers refuse to overwrite an existing .o file with -o,
+  # though they will create one.
+  am_cv_prog_cc_c_o=yes
+  for am_i in 1 2; do
+    if { echo "$as_me:$LINENO: $CC -c conftest.$ac_ext -o conftest2.$ac_objext" >&5
+   ($CC -c conftest.$ac_ext -o conftest2.$ac_objext) >&5 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } \
+         && test -f conftest2.$ac_objext; then
+      : OK
+    else
+      am_cv_prog_cc_c_o=no
+      break
+    fi
+  done
+  rm -f core conftest*
+  unset am_i
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5
+$as_echo "$am_cv_prog_cc_c_o" >&6; }
+if test "$am_cv_prog_cc_c_o" != yes; then
+   # Losing compiler, so override with the script.
+   # FIXME: It is wrong to rewrite CC.
+   # But if we don't then we get into trouble of one sort or another.
+   # A longer-term fix would be to have automake use am__CC in this case,
+   # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
+   CC="$am_aux_dir/compile $CC"
+fi
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+DEPDIR="${am__leading_dot}deps"
+
+ac_config_commands="$ac_config_commands depfiles"
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} supports the include directive" >&5
+$as_echo_n "checking whether ${MAKE-make} supports the include directive... " >&6; }
+cat > confinc.mk << 'END'
+am__doit:
+	@echo this is the am__doit target >confinc.out
+.PHONY: am__doit
+END
+am__include="#"
+am__quote=
+# BSD make does it like this.
+echo '.include "confinc.mk" # ignored' > confmf.BSD
+# Other make implementations (GNU, Solaris 10, AIX) do it like this.
+echo 'include confinc.mk # ignored' > confmf.GNU
+_am_result=no
+for s in GNU BSD; do
+  { echo "$as_me:$LINENO: ${MAKE-make} -f confmf.$s && cat confinc.out" >&5
+   (${MAKE-make} -f confmf.$s && cat confinc.out) >&5 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+  case $?:`cat confinc.out 2>/dev/null` in #(
+  '0:this is the am__doit target') :
+    case $s in #(
+  BSD) :
+    am__include='.include' am__quote='"' ;; #(
+  *) :
+    am__include='include' am__quote='' ;;
+esac ;; #(
+  *) :
+     ;;
+esac
+  if test "$am__include" != "#"; then
+    _am_result="yes ($s style)"
+    break
+  fi
+done
+rm -f confinc.* confmf.*
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ${_am_result}" >&5
+$as_echo "${_am_result}" >&6; }
+
+# Check whether --enable-dependency-tracking was given.
+if test "${enable_dependency_tracking+set}" = set; then :
+  enableval=$enable_dependency_tracking;
+fi
+
+if test "x$enable_dependency_tracking" != xno; then
+  am_depcomp="$ac_aux_dir/depcomp"
+  AMDEPBACKSLASH='\'
+  am__nodep='_no'
+fi
+ if test "x$enable_dependency_tracking" != xno; then
+  AMDEP_TRUE=
+  AMDEP_FALSE='#'
+else
+  AMDEP_TRUE='#'
+  AMDEP_FALSE=
+fi
+
+
+
+depcc="$CC"   am_compiler_list=
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
+$as_echo_n "checking dependency style of $depcc... " >&6; }
+if ${am_cv_CC_dependencies_compiler_type+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
+  # We make a subdir and do the tests there.  Otherwise we can end up
+  # making bogus files that we don't know about and never remove.  For
+  # instance it was reported that on HP-UX the gcc test will end up
+  # making a dummy file named 'D' -- because '-MD' means "put the output
+  # in D".
+  rm -rf conftest.dir
+  mkdir conftest.dir
+  # Copy depcomp to subdir because otherwise we won't find it if we're
+  # using a relative directory.
+  cp "$am_depcomp" conftest.dir
+  cd conftest.dir
+  # We will build objects and dependencies in a subdirectory because
+  # it helps to detect inapplicable dependency modes.  For instance
+  # both Tru64's cc and ICC support -MD to output dependencies as a
+  # side effect of compilation, but ICC will put the dependencies in
+  # the current directory while Tru64 will put them in the object
+  # directory.
+  mkdir sub
+
+  am_cv_CC_dependencies_compiler_type=none
+  if test "$am_compiler_list" = ""; then
+     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
+  fi
+  am__universal=false
+  case " $depcc " in #(
+     *\ -arch\ *\ -arch\ *) am__universal=true ;;
+     esac
+
+  for depmode in $am_compiler_list; do
+    # Setup a source with many dependencies, because some compilers
+    # like to wrap large dependency lists on column 80 (with \), and
+    # we should not choose a depcomp mode which is confused by this.
+    #
+    # We need to recreate these files for each test, as the compiler may
+    # overwrite some of them when testing with obscure command lines.
+    # This happens at least with the AIX C compiler.
+    : > sub/conftest.c
+    for i in 1 2 3 4 5 6; do
+      echo '#include "conftst'$i'.h"' >> sub/conftest.c
+      # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
+      # Solaris 10 /bin/sh.
+      echo '/* dummy */' > sub/conftst$i.h
+    done
+    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
+
+    # We check with '-c' and '-o' for the sake of the "dashmstdout"
+    # mode.  It turns out that the SunPro C++ compiler does not properly
+    # handle '-M -o', and we need to detect this.  Also, some Intel
+    # versions had trouble with output in subdirs.
+    am__obj=sub/conftest.${OBJEXT-o}
+    am__minus_obj="-o $am__obj"
+    case $depmode in
+    gcc)
+      # This depmode causes a compiler race in universal mode.
+      test "$am__universal" = false || continue
+      ;;
+    nosideeffect)
+      # After this tag, mechanisms are not by side-effect, so they'll
+      # only be used when explicitly requested.
+      if test "x$enable_dependency_tracking" = xyes; then
+	continue
+      else
+	break
+      fi
+      ;;
+    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
+      # This compiler won't grok '-c -o', but also, the minuso test has
+      # not run yet.  These depmodes are late enough in the game, and
+      # so weak that their functioning should not be impacted.
+      am__obj=conftest.${OBJEXT-o}
+      am__minus_obj=
+      ;;
+    none) break ;;
+    esac
+    if depmode=$depmode \
+       source=sub/conftest.c object=$am__obj \
+       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
+       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
+         >/dev/null 2>conftest.err &&
+       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
+       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
+      # icc doesn't choke on unknown options, it will just issue warnings
+      # or remarks (even with -Werror).  So we grep stderr for any message
+      # that says an option was ignored or not supported.
+      # When given -MP, icc 7.0 and 7.1 complain thusly:
+      #   icc: Command line warning: ignoring option '-M'; no argument required
+      # The diagnosis changed in icc 8.0:
+      #   icc: Command line remark: option '-MP' not supported
+      if (grep 'ignoring option' conftest.err ||
+          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
+        am_cv_CC_dependencies_compiler_type=$depmode
+        break
+      fi
+    fi
+  done
+
+  cd ..
+  rm -rf conftest.dir
+else
+  am_cv_CC_dependencies_compiler_type=none
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5
+$as_echo "$am_cv_CC_dependencies_compiler_type" >&6; }
+CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
+
+ if
+  test "x$enable_dependency_tracking" != xno \
+  && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then
+  am__fastdepCC_TRUE=
+  am__fastdepCC_FALSE='#'
+else
+  am__fastdepCC_TRUE='#'
+  am__fastdepCC_FALSE=
+fi
+
+
+# By default we simply use the C compiler to build assembly code.
+
+test "${CCAS+set}" = set || CCAS=$CC
+test "${CCASFLAGS+set}" = set || CCASFLAGS=$CFLAGS
+
+
+
+depcc="$CCAS"   am_compiler_list=
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
+$as_echo_n "checking dependency style of $depcc... " >&6; }
+if ${am_cv_CCAS_dependencies_compiler_type+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
+  # We make a subdir and do the tests there.  Otherwise we can end up
+  # making bogus files that we don't know about and never remove.  For
+  # instance it was reported that on HP-UX the gcc test will end up
+  # making a dummy file named 'D' -- because '-MD' means "put the output
+  # in D".
+  rm -rf conftest.dir
+  mkdir conftest.dir
+  # Copy depcomp to subdir because otherwise we won't find it if we're
+  # using a relative directory.
+  cp "$am_depcomp" conftest.dir
+  cd conftest.dir
+  # We will build objects and dependencies in a subdirectory because
+  # it helps to detect inapplicable dependency modes.  For instance
+  # both Tru64's cc and ICC support -MD to output dependencies as a
+  # side effect of compilation, but ICC will put the dependencies in
+  # the current directory while Tru64 will put them in the object
+  # directory.
+  mkdir sub
+
+  am_cv_CCAS_dependencies_compiler_type=none
+  if test "$am_compiler_list" = ""; then
+     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
+  fi
+  am__universal=false
+
+
+  for depmode in $am_compiler_list; do
+    # Setup a source with many dependencies, because some compilers
+    # like to wrap large dependency lists on column 80 (with \), and
+    # we should not choose a depcomp mode which is confused by this.
+    #
+    # We need to recreate these files for each test, as the compiler may
+    # overwrite some of them when testing with obscure command lines.
+    # This happens at least with the AIX C compiler.
+    : > sub/conftest.c
+    for i in 1 2 3 4 5 6; do
+      echo '#include "conftst'$i'.h"' >> sub/conftest.c
+      # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
+      # Solaris 10 /bin/sh.
+      echo '/* dummy */' > sub/conftst$i.h
+    done
+    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
+
+    # We check with '-c' and '-o' for the sake of the "dashmstdout"
+    # mode.  It turns out that the SunPro C++ compiler does not properly
+    # handle '-M -o', and we need to detect this.  Also, some Intel
+    # versions had trouble with output in subdirs.
+    am__obj=sub/conftest.${OBJEXT-o}
+    am__minus_obj="-o $am__obj"
+    case $depmode in
+    gcc)
+      # This depmode causes a compiler race in universal mode.
+      test "$am__universal" = false || continue
+      ;;
+    nosideeffect)
+      # After this tag, mechanisms are not by side-effect, so they'll
+      # only be used when explicitly requested.
+      if test "x$enable_dependency_tracking" = xyes; then
+	continue
+      else
+	break
+      fi
+      ;;
+    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
+      # This compiler won't grok '-c -o', but also, the minuso test has
+      # not run yet.  These depmodes are late enough in the game, and
+      # so weak that their functioning should not be impacted.
+      am__obj=conftest.${OBJEXT-o}
+      am__minus_obj=
+      ;;
+    none) break ;;
+    esac
+    if depmode=$depmode \
+       source=sub/conftest.c object=$am__obj \
+       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
+       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
+         >/dev/null 2>conftest.err &&
+       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
+       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
+      # icc doesn't choke on unknown options, it will just issue warnings
+      # or remarks (even with -Werror).  So we grep stderr for any message
+      # that says an option was ignored or not supported.
+      # When given -MP, icc 7.0 and 7.1 complain thusly:
+      #   icc: Command line warning: ignoring option '-M'; no argument required
+      # The diagnosis changed in icc 8.0:
+      #   icc: Command line remark: option '-MP' not supported
+      if (grep 'ignoring option' conftest.err ||
+          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
+        am_cv_CCAS_dependencies_compiler_type=$depmode
+        break
+      fi
+    fi
+  done
+
+  cd ..
+  rm -rf conftest.dir
+else
+  am_cv_CCAS_dependencies_compiler_type=none
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CCAS_dependencies_compiler_type" >&5
+$as_echo "$am_cv_CCAS_dependencies_compiler_type" >&6; }
+CCASDEPMODE=depmode=$am_cv_CCAS_dependencies_compiler_type
+
+ if
+  test "x$enable_dependency_tracking" != xno \
+  && test "$am_cv_CCAS_dependencies_compiler_type" = gcc3; then
+  am__fastdepCCAS_TRUE=
+  am__fastdepCCAS_FALSE='#'
+else
+  am__fastdepCCAS_TRUE='#'
+  am__fastdepCCAS_FALSE=
+fi
+
+
+# Make sure we can run config.sub.
+$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
+  as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
+$as_echo_n "checking build system type... " >&6; }
+if ${ac_cv_build+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_build_alias=$build_alias
+test "x$ac_build_alias" = x &&
+  ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
+test "x$ac_build_alias" = x &&
+  as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
+ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
+  as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
+$as_echo "$ac_cv_build" >&6; }
+case $ac_cv_build in
+*-*-*) ;;
+*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
+esac
+build=$ac_cv_build
+ac_save_IFS=$IFS; IFS='-'
+set x $ac_cv_build
+shift
+build_cpu=$1
+build_vendor=$2
+shift; shift
+# Remember, the first character of IFS is used to create $*,
+# except with old shells:
+build_os=$*
+IFS=$ac_save_IFS
+case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
+$as_echo_n "checking host system type... " >&6; }
+if ${ac_cv_host+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test "x$host_alias" = x; then
+  ac_cv_host=$ac_cv_build
+else
+  ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
+    as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
+$as_echo "$ac_cv_host" >&6; }
+case $ac_cv_host in
+*-*-*) ;;
+*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
+esac
+host=$ac_cv_host
+ac_save_IFS=$IFS; IFS='-'
+set x $ac_cv_host
+shift
+host_cpu=$1
+host_vendor=$2
+shift; shift
+# Remember, the first character of IFS is used to create $*,
+# except with old shells:
+host_os=$*
+IFS=$ac_save_IFS
+case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
+$as_echo_n "checking for a sed that does not truncate output... " >&6; }
+if ${ac_cv_path_SED+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+            ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
+     for ac_i in 1 2 3 4 5 6 7; do
+       ac_script="$ac_script$as_nl$ac_script"
+     done
+     echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
+     { ac_script=; unset ac_script;}
+     if test -z "$SED"; then
+  ac_path_SED_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in sed gsed; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_SED" || continue
+# Check for GNU ac_path_SED and select it if it is found.
+  # Check for GNU $ac_path_SED
+case `"$ac_path_SED" --version 2>&1` in
+*GNU*)
+  ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
+*)
+  ac_count=0
+  $as_echo_n 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    $as_echo '' >> "conftest.nl"
+    "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_SED_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_SED="$ac_path_SED"
+      ac_path_SED_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_SED_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_SED"; then
+    as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
+  fi
+else
+  ac_cv_path_SED=$SED
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
+$as_echo "$ac_cv_path_SED" >&6; }
+ SED="$ac_cv_path_SED"
+  rm -f conftest.sed
+
+test -z "$SED" && SED=sed
+Xsed="$SED -e 1s/^X//"
+
+
+
+
+
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
+$as_echo_n "checking for grep that handles long lines and -e... " >&6; }
+if ${ac_cv_path_GREP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -z "$GREP"; then
+  ac_path_GREP_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in grep ggrep; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_GREP" || continue
+# Check for GNU ac_path_GREP and select it if it is found.
+  # Check for GNU $ac_path_GREP
+case `"$ac_path_GREP" --version 2>&1` in
+*GNU*)
+  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
+*)
+  ac_count=0
+  $as_echo_n 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    $as_echo 'GREP' >> "conftest.nl"
+    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_GREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_GREP="$ac_path_GREP"
+      ac_path_GREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_GREP_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_GREP"; then
+    as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+  fi
+else
+  ac_cv_path_GREP=$GREP
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
+$as_echo "$ac_cv_path_GREP" >&6; }
+ GREP="$ac_cv_path_GREP"
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
+$as_echo_n "checking for egrep... " >&6; }
+if ${ac_cv_path_EGREP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
+   then ac_cv_path_EGREP="$GREP -E"
+   else
+     if test -z "$EGREP"; then
+  ac_path_EGREP_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in egrep; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_EGREP" || continue
+# Check for GNU ac_path_EGREP and select it if it is found.
+  # Check for GNU $ac_path_EGREP
+case `"$ac_path_EGREP" --version 2>&1` in
+*GNU*)
+  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
+*)
+  ac_count=0
+  $as_echo_n 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    $as_echo 'EGREP' >> "conftest.nl"
+    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_EGREP="$ac_path_EGREP"
+      ac_path_EGREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_EGREP_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_EGREP"; then
+    as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+  fi
+else
+  ac_cv_path_EGREP=$EGREP
+fi
+
+   fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
+$as_echo "$ac_cv_path_EGREP" >&6; }
+ EGREP="$ac_cv_path_EGREP"
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
+$as_echo_n "checking for fgrep... " >&6; }
+if ${ac_cv_path_FGREP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
+   then ac_cv_path_FGREP="$GREP -F"
+   else
+     if test -z "$FGREP"; then
+  ac_path_FGREP_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in fgrep; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_FGREP" || continue
+# Check for GNU ac_path_FGREP and select it if it is found.
+  # Check for GNU $ac_path_FGREP
+case `"$ac_path_FGREP" --version 2>&1` in
+*GNU*)
+  ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
+*)
+  ac_count=0
+  $as_echo_n 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    $as_echo 'FGREP' >> "conftest.nl"
+    "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_FGREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_FGREP="$ac_path_FGREP"
+      ac_path_FGREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_FGREP_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_FGREP"; then
+    as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+  fi
+else
+  ac_cv_path_FGREP=$FGREP
+fi
+
+   fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
+$as_echo "$ac_cv_path_FGREP" >&6; }
+ FGREP="$ac_cv_path_FGREP"
+
+
+test -z "$GREP" && GREP=grep
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO
+ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to print strings" >&5
+$as_echo_n "checking how to print strings... " >&6; }
+# Test print first, because it will be a builtin if present.
+if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \
+   test "X`print -r -- $ECHO 2>/dev/null`" = "X$ECHO"; then
+  ECHO='print -r --'
+elif test "X`printf %s $ECHO 2>/dev/null`" = "X$ECHO"; then
+  ECHO='printf %s\n'
+else
+  # Use this function as a fallback that always works.
+  func_fallback_echo ()
+  {
+    eval 'cat <<_LTECHO_EOF
+$1
+_LTECHO_EOF'
+  }
+  ECHO='func_fallback_echo'
+fi
+
+# func_echo_all arg...
+# Invoke $ECHO with all args, space-separated.
+func_echo_all ()
+{
+    $ECHO ""
+}
+
+case $ECHO in
+  printf*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: printf" >&5
+$as_echo "printf" >&6; } ;;
+  print*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: print -r" >&5
+$as_echo "print -r" >&6; } ;;
+  *) { $as_echo "$as_me:${as_lineno-$LINENO}: result: cat" >&5
+$as_echo "cat" >&6; } ;;
+esac
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# Check whether --with-gnu-ld was given.
+if test "${with_gnu_ld+set}" = set; then :
+  withval=$with_gnu_ld; test no = "$withval" || with_gnu_ld=yes
+else
+  with_gnu_ld=no
+fi
+
+ac_prog=ld
+if test yes = "$GCC"; then
+  # Check if gcc -print-prog-name=ld gives a path.
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5
+$as_echo_n "checking for ld used by $CC... " >&6; }
+  case $host in
+  *-*-mingw*)
+    # gcc leaves a trailing carriage return, which upsets mingw
+    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
+  *)
+    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
+  esac
+  case $ac_prog in
+    # Accept absolute paths.
+    [\\/]* | ?:[\\/]*)
+      re_direlt='/[^/][^/]*/\.\./'
+      # Canonicalize the pathname of ld
+      ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'`
+      while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do
+	ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"`
+      done
+      test -z "$LD" && LD=$ac_prog
+      ;;
+  "")
+    # If it fails, then pretend we aren't using GCC.
+    ac_prog=ld
+    ;;
+  *)
+    # If it is relative, then search for the first ld in PATH.
+    with_gnu_ld=unknown
+    ;;
+  esac
+elif test yes = "$with_gnu_ld"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5
+$as_echo_n "checking for GNU ld... " >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5
+$as_echo_n "checking for non-GNU ld... " >&6; }
+fi
+if ${lt_cv_path_LD+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -z "$LD"; then
+  lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
+  for ac_dir in $PATH; do
+    IFS=$lt_save_ifs
+    test -z "$ac_dir" && ac_dir=.
+    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
+      lt_cv_path_LD=$ac_dir/$ac_prog
+      # Check to see if the program is GNU ld.  I'd rather use --version,
+      # but apparently some variants of GNU ld only accept -v.
+      # Break only if it was the GNU/non-GNU ld that we prefer.
+      case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
+      *GNU* | *'with BFD'*)
+	test no != "$with_gnu_ld" && break
+	;;
+      *)
+	test yes != "$with_gnu_ld" && break
+	;;
+      esac
+    fi
+  done
+  IFS=$lt_save_ifs
+else
+  lt_cv_path_LD=$LD # Let the user override the test with a path.
+fi
+fi
+
+LD=$lt_cv_path_LD
+if test -n "$LD"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LD" >&5
+$as_echo "$LD" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5
+$as_echo_n "checking if the linker ($LD) is GNU ld... " >&6; }
+if ${lt_cv_prog_gnu_ld+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  # I'd rather use --version here, but apparently some GNU lds only accept -v.
+case `$LD -v 2>&1 </dev/null` in
+*GNU* | *'with BFD'*)
+  lt_cv_prog_gnu_ld=yes
+  ;;
+*)
+  lt_cv_prog_gnu_ld=no
+  ;;
+esac
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_gnu_ld" >&5
+$as_echo "$lt_cv_prog_gnu_ld" >&6; }
+with_gnu_ld=$lt_cv_prog_gnu_ld
+
+
+
+
+
+
+
+
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
+$as_echo_n "checking how to run the C preprocessor... " >&6; }
+# On Suns, sometimes $CPP names a directory.
+if test -n "$CPP" && test -d "$CPP"; then
+  CPP=
+fi
+if test -z "$CPP"; then
+  if ${ac_cv_prog_CPP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+      # Double quotes because CPP needs to be expanded
+    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
+    do
+      ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+
+else
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+  # Broken: success on invalid input.
+continue
+else
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+  break
+fi
+
+    done
+    ac_cv_prog_CPP=$CPP
+
+fi
+  CPP=$ac_cv_prog_CPP
+else
+  ac_cv_prog_CPP=$CPP
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
+$as_echo "$CPP" >&6; }
+ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+
+else
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+  # Broken: success on invalid input.
+continue
+else
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+
+else
+  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+for ac_prog in gawk mawk nawk awk
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_AWK+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$AWK"; then
+  ac_cv_prog_AWK="$AWK" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_AWK="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+AWK=$ac_cv_prog_AWK
+if test -n "$AWK"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
+$as_echo "$AWK" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$AWK" && break
+done
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5
+$as_echo_n "checking whether ln -s works... " >&6; }
+LN_S=$as_ln_s
+if test "$LN_S" = "ln -s"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5
+$as_echo "no, using $LN_S" >&6; }
+fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5
+$as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
+set x ${MAKE-make}
+ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
+if eval \${ac_cv_prog_make_${ac_make}_set+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat >conftest.make <<\_ACEOF
+SHELL = /bin/sh
+all:
+	@echo '@@@%%%=$(MAKE)=@@@%%%'
+_ACEOF
+# GNU make sometimes prints "make[1]: Entering ...", which would confuse us.
+case `${MAKE-make} -f conftest.make 2>/dev/null` in
+  *@@@%%%=?*=@@@%%%*)
+    eval ac_cv_prog_make_${ac_make}_set=yes;;
+  *)
+    eval ac_cv_prog_make_${ac_make}_set=no;;
+esac
+rm -f conftest.make
+fi
+if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+  SET_MAKE=
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+  SET_MAKE="MAKE=${MAKE-make}"
+fi
+
+
+case `pwd` in
+  *\ * | *\	*)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5
+$as_echo "$as_me: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&2;} ;;
+esac
+
+
+
+macro_version='2.4.6'
+macro_revision='2.4.6'
+
+
+
+
+
+
+
+
+
+
+
+
+
+ltmain=$ac_aux_dir/ltmain.sh
+
+# Backslashify metacharacters that are still active within
+# double-quoted strings.
+sed_quote_subst='s/\(["`$\\]\)/\\\1/g'
+
+# Same as above, but do not quote variable references.
+double_quote_subst='s/\(["`\\]\)/\\\1/g'
+
+# Sed substitution to delay expansion of an escaped shell variable in a
+# double_quote_subst'ed string.
+delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'
+
+# Sed substitution to delay expansion of an escaped single quote.
+delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g'
+
+# Sed substitution to avoid accidental globbing in evaled expressions
+no_glob_subst='s/\*/\\\*/g'
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for BSD- or MS-compatible name lister (nm)" >&5
+$as_echo_n "checking for BSD- or MS-compatible name lister (nm)... " >&6; }
+if ${lt_cv_path_NM+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$NM"; then
+  # Let the user override the test.
+  lt_cv_path_NM=$NM
+else
+  lt_nm_to_check=${ac_tool_prefix}nm
+  if test -n "$ac_tool_prefix" && test "$build" = "$host"; then
+    lt_nm_to_check="$lt_nm_to_check nm"
+  fi
+  for lt_tmp_nm in $lt_nm_to_check; do
+    lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
+    for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do
+      IFS=$lt_save_ifs
+      test -z "$ac_dir" && ac_dir=.
+      tmp_nm=$ac_dir/$lt_tmp_nm
+      if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext"; then
+	# Check to see if the nm accepts a BSD-compat flag.
+	# Adding the 'sed 1q' prevents false positives on HP-UX, which says:
+	#   nm: unknown option "B" ignored
+	# Tru64's nm complains that /dev/null is an invalid object file
+	# MSYS converts /dev/null to NUL, MinGW nm treats NUL as empty
+	case $build_os in
+	mingw*) lt_bad_file=conftest.nm/nofile ;;
+	*) lt_bad_file=/dev/null ;;
+	esac
+	case `"$tmp_nm" -B $lt_bad_file 2>&1 | sed '1q'` in
+	*$lt_bad_file* | *'Invalid file or object type'*)
+	  lt_cv_path_NM="$tmp_nm -B"
+	  break 2
+	  ;;
+	*)
+	  case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in
+	  */dev/null*)
+	    lt_cv_path_NM="$tmp_nm -p"
+	    break 2
+	    ;;
+	  *)
+	    lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
+	    continue # so that we can try to find one that supports BSD flags
+	    ;;
+	  esac
+	  ;;
+	esac
+      fi
+    done
+    IFS=$lt_save_ifs
+  done
+  : ${lt_cv_path_NM=no}
+fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5
+$as_echo "$lt_cv_path_NM" >&6; }
+if test no != "$lt_cv_path_NM"; then
+  NM=$lt_cv_path_NM
+else
+  # Didn't find any BSD compatible name lister, look for dumpbin.
+  if test -n "$DUMPBIN"; then :
+    # Let the user override the test.
+  else
+    if test -n "$ac_tool_prefix"; then
+  for ac_prog in dumpbin "link -dump"
+  do
+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_DUMPBIN+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$DUMPBIN"; then
+  ac_cv_prog_DUMPBIN="$DUMPBIN" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_DUMPBIN="$ac_tool_prefix$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+DUMPBIN=$ac_cv_prog_DUMPBIN
+if test -n "$DUMPBIN"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5
+$as_echo "$DUMPBIN" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+    test -n "$DUMPBIN" && break
+  done
+fi
+if test -z "$DUMPBIN"; then
+  ac_ct_DUMPBIN=$DUMPBIN
+  for ac_prog in dumpbin "link -dump"
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_DUMPBIN+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_DUMPBIN"; then
+  ac_cv_prog_ac_ct_DUMPBIN="$ac_ct_DUMPBIN" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_DUMPBIN="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_DUMPBIN=$ac_cv_prog_ac_ct_DUMPBIN
+if test -n "$ac_ct_DUMPBIN"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DUMPBIN" >&5
+$as_echo "$ac_ct_DUMPBIN" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$ac_ct_DUMPBIN" && break
+done
+
+  if test "x$ac_ct_DUMPBIN" = x; then
+    DUMPBIN=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    DUMPBIN=$ac_ct_DUMPBIN
+  fi
+fi
+
+    case `$DUMPBIN -symbols -headers /dev/null 2>&1 | sed '1q'` in
+    *COFF*)
+      DUMPBIN="$DUMPBIN -symbols -headers"
+      ;;
+    *)
+      DUMPBIN=:
+      ;;
+    esac
+  fi
+
+  if test : != "$DUMPBIN"; then
+    NM=$DUMPBIN
+  fi
+fi
+test -z "$NM" && NM=nm
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the name lister ($NM) interface" >&5
+$as_echo_n "checking the name lister ($NM) interface... " >&6; }
+if ${lt_cv_nm_interface+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_nm_interface="BSD nm"
+  echo "int some_variable = 0;" > conftest.$ac_ext
+  (eval echo "\"\$as_me:$LINENO: $ac_compile\"" >&5)
+  (eval "$ac_compile" 2>conftest.err)
+  cat conftest.err >&5
+  (eval echo "\"\$as_me:$LINENO: $NM \\\"conftest.$ac_objext\\\"\"" >&5)
+  (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out)
+  cat conftest.err >&5
+  (eval echo "\"\$as_me:$LINENO: output\"" >&5)
+  cat conftest.out >&5
+  if $GREP 'External.*some_variable' conftest.out > /dev/null; then
+    lt_cv_nm_interface="MS dumpbin"
+  fi
+  rm -f conftest*
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_nm_interface" >&5
+$as_echo "$lt_cv_nm_interface" >&6; }
+
+# find the maximum length of command line arguments
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the maximum length of command line arguments" >&5
+$as_echo_n "checking the maximum length of command line arguments... " >&6; }
+if ${lt_cv_sys_max_cmd_len+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+    i=0
+  teststring=ABCD
+
+  case $build_os in
+  msdosdjgpp*)
+    # On DJGPP, this test can blow up pretty badly due to problems in libc
+    # (any single argument exceeding 2000 bytes causes a buffer overrun
+    # during glob expansion).  Even if it were fixed, the result of this
+    # check would be larger than it should be.
+    lt_cv_sys_max_cmd_len=12288;    # 12K is about right
+    ;;
+
+  gnu*)
+    # Under GNU Hurd, this test is not required because there is
+    # no limit to the length of command line arguments.
+    # Libtool will interpret -1 as no limit whatsoever
+    lt_cv_sys_max_cmd_len=-1;
+    ;;
+
+  cygwin* | mingw* | cegcc*)
+    # On Win9x/ME, this test blows up -- it succeeds, but takes
+    # about 5 minutes as the teststring grows exponentially.
+    # Worse, since 9x/ME are not pre-emptively multitasking,
+    # you end up with a "frozen" computer, even though with patience
+    # the test eventually succeeds (with a max line length of 256k).
+    # Instead, let's just punt: use the minimum linelength reported by
+    # all of the supported platforms: 8192 (on NT/2K/XP).
+    lt_cv_sys_max_cmd_len=8192;
+    ;;
+
+  mint*)
+    # On MiNT this can take a long time and run out of memory.
+    lt_cv_sys_max_cmd_len=8192;
+    ;;
+
+  amigaos*)
+    # On AmigaOS with pdksh, this test takes hours, literally.
+    # So we just punt and use a minimum line length of 8192.
+    lt_cv_sys_max_cmd_len=8192;
+    ;;
+
+  bitrig* | darwin* | dragonfly* | freebsd* | netbsd* | openbsd*)
+    # This has been around since 386BSD, at least.  Likely further.
+    if test -x /sbin/sysctl; then
+      lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
+    elif test -x /usr/sbin/sysctl; then
+      lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
+    else
+      lt_cv_sys_max_cmd_len=65536	# usable default for all BSDs
+    fi
+    # And add a safety zone
+    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
+    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
+    ;;
+
+  interix*)
+    # We know the value 262144 and hardcode it with a safety zone (like BSD)
+    lt_cv_sys_max_cmd_len=196608
+    ;;
+
+  os2*)
+    # The test takes a long time on OS/2.
+    lt_cv_sys_max_cmd_len=8192
+    ;;
+
+  osf*)
+    # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure
+    # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not
+    # nice to cause kernel panics so lets avoid the loop below.
+    # First set a reasonable default.
+    lt_cv_sys_max_cmd_len=16384
+    #
+    if test -x /sbin/sysconfig; then
+      case `/sbin/sysconfig -q proc exec_disable_arg_limit` in
+        *1*) lt_cv_sys_max_cmd_len=-1 ;;
+      esac
+    fi
+    ;;
+  sco3.2v5*)
+    lt_cv_sys_max_cmd_len=102400
+    ;;
+  sysv5* | sco5v6* | sysv4.2uw2*)
+    kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null`
+    if test -n "$kargmax"; then
+      lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[	 ]//'`
+    else
+      lt_cv_sys_max_cmd_len=32768
+    fi
+    ;;
+  *)
+    lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null`
+    if test -n "$lt_cv_sys_max_cmd_len" && \
+       test undefined != "$lt_cv_sys_max_cmd_len"; then
+      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
+      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
+    else
+      # Make teststring a little bigger before we do anything with it.
+      # a 1K string should be a reasonable start.
+      for i in 1 2 3 4 5 6 7 8; do
+        teststring=$teststring$teststring
+      done
+      SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}
+      # If test is not a shell built-in, we'll probably end up computing a
+      # maximum length that is only half of the actual maximum length, but
+      # we can't tell.
+      while { test X`env echo "$teststring$teststring" 2>/dev/null` \
+	         = "X$teststring$teststring"; } >/dev/null 2>&1 &&
+	      test 17 != "$i" # 1/2 MB should be enough
+      do
+        i=`expr $i + 1`
+        teststring=$teststring$teststring
+      done
+      # Only check the string length outside the loop.
+      lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1`
+      teststring=
+      # Add a significant safety factor because C++ compilers can tack on
+      # massive amounts of additional arguments before passing them to the
+      # linker.  It appears as though 1/2 is a usable value.
+      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`
+    fi
+    ;;
+  esac
+
+fi
+
+if test -n "$lt_cv_sys_max_cmd_len"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sys_max_cmd_len" >&5
+$as_echo "$lt_cv_sys_max_cmd_len" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: none" >&5
+$as_echo "none" >&6; }
+fi
+max_cmd_len=$lt_cv_sys_max_cmd_len
+
+
+
+
+
+
+: ${CP="cp -f"}
+: ${MV="mv -f"}
+: ${RM="rm -f"}
+
+if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
+  lt_unset=unset
+else
+  lt_unset=false
+fi
+
+
+
+
+
+# test EBCDIC or ASCII
+case `echo X|tr X '\101'` in
+ A) # ASCII based system
+    # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
+  lt_SP2NL='tr \040 \012'
+  lt_NL2SP='tr \015\012 \040\040'
+  ;;
+ *) # EBCDIC based system
+  lt_SP2NL='tr \100 \n'
+  lt_NL2SP='tr \r\n \100\100'
+  ;;
+esac
+
+
+
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to $host format" >&5
+$as_echo_n "checking how to convert $build file names to $host format... " >&6; }
+if ${lt_cv_to_host_file_cmd+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  case $host in
+  *-*-mingw* )
+    case $build in
+      *-*-mingw* ) # actually msys
+        lt_cv_to_host_file_cmd=func_convert_file_msys_to_w32
+        ;;
+      *-*-cygwin* )
+        lt_cv_to_host_file_cmd=func_convert_file_cygwin_to_w32
+        ;;
+      * ) # otherwise, assume *nix
+        lt_cv_to_host_file_cmd=func_convert_file_nix_to_w32
+        ;;
+    esac
+    ;;
+  *-*-cygwin* )
+    case $build in
+      *-*-mingw* ) # actually msys
+        lt_cv_to_host_file_cmd=func_convert_file_msys_to_cygwin
+        ;;
+      *-*-cygwin* )
+        lt_cv_to_host_file_cmd=func_convert_file_noop
+        ;;
+      * ) # otherwise, assume *nix
+        lt_cv_to_host_file_cmd=func_convert_file_nix_to_cygwin
+        ;;
+    esac
+    ;;
+  * ) # unhandled hosts (and "normal" native builds)
+    lt_cv_to_host_file_cmd=func_convert_file_noop
+    ;;
+esac
+
+fi
+
+to_host_file_cmd=$lt_cv_to_host_file_cmd
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_host_file_cmd" >&5
+$as_echo "$lt_cv_to_host_file_cmd" >&6; }
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to toolchain format" >&5
+$as_echo_n "checking how to convert $build file names to toolchain format... " >&6; }
+if ${lt_cv_to_tool_file_cmd+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  #assume ordinary cross tools, or native build.
+lt_cv_to_tool_file_cmd=func_convert_file_noop
+case $host in
+  *-*-mingw* )
+    case $build in
+      *-*-mingw* ) # actually msys
+        lt_cv_to_tool_file_cmd=func_convert_file_msys_to_w32
+        ;;
+    esac
+    ;;
+esac
+
+fi
+
+to_tool_file_cmd=$lt_cv_to_tool_file_cmd
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_tool_file_cmd" >&5
+$as_echo "$lt_cv_to_tool_file_cmd" >&6; }
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $LD option to reload object files" >&5
+$as_echo_n "checking for $LD option to reload object files... " >&6; }
+if ${lt_cv_ld_reload_flag+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_ld_reload_flag='-r'
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_reload_flag" >&5
+$as_echo "$lt_cv_ld_reload_flag" >&6; }
+reload_flag=$lt_cv_ld_reload_flag
+case $reload_flag in
+"" | " "*) ;;
+*) reload_flag=" $reload_flag" ;;
+esac
+reload_cmds='$LD$reload_flag -o $output$reload_objs'
+case $host_os in
+  cygwin* | mingw* | pw32* | cegcc*)
+    if test yes != "$GCC"; then
+      reload_cmds=false
+    fi
+    ;;
+  darwin*)
+    if test yes = "$GCC"; then
+      reload_cmds='$LTCC $LTCFLAGS -nostdlib $wl-r -o $output$reload_objs'
+    else
+      reload_cmds='$LD$reload_flag -o $output$reload_objs'
+    fi
+    ;;
+esac
+
+
+
+
+
+
+
+
+
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args.
+set dummy ${ac_tool_prefix}objdump; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_OBJDUMP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$OBJDUMP"; then
+  ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+OBJDUMP=$ac_cv_prog_OBJDUMP
+if test -n "$OBJDUMP"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
+$as_echo "$OBJDUMP" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_OBJDUMP"; then
+  ac_ct_OBJDUMP=$OBJDUMP
+  # Extract the first word of "objdump", so it can be a program name with args.
+set dummy objdump; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_OBJDUMP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_OBJDUMP"; then
+  ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_OBJDUMP="objdump"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
+if test -n "$ac_ct_OBJDUMP"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
+$as_echo "$ac_ct_OBJDUMP" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_OBJDUMP" = x; then
+    OBJDUMP="false"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    OBJDUMP=$ac_ct_OBJDUMP
+  fi
+else
+  OBJDUMP="$ac_cv_prog_OBJDUMP"
+fi
+
+test -z "$OBJDUMP" && OBJDUMP=objdump
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to recognize dependent libraries" >&5
+$as_echo_n "checking how to recognize dependent libraries... " >&6; }
+if ${lt_cv_deplibs_check_method+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_file_magic_cmd='$MAGIC_CMD'
+lt_cv_file_magic_test_file=
+lt_cv_deplibs_check_method='unknown'
+# Need to set the preceding variable on all platforms that support
+# interlibrary dependencies.
+# 'none' -- dependencies not supported.
+# 'unknown' -- same as none, but documents that we really don't know.
+# 'pass_all' -- all dependencies passed with no checks.
+# 'test_compile' -- check by making test program.
+# 'file_magic [[regex]]' -- check by looking for files in library path
+# that responds to the $file_magic_cmd with a given extended regex.
+# If you have 'file' or equivalent on your system and you're not sure
+# whether 'pass_all' will *always* work, you probably want this one.
+
+case $host_os in
+aix[4-9]*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+beos*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+bsdi[45]*)
+  lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)'
+  lt_cv_file_magic_cmd='/usr/bin/file -L'
+  lt_cv_file_magic_test_file=/shlib/libc.so
+  ;;
+
+cygwin*)
+  # func_win32_libid is a shell function defined in ltmain.sh
+  lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
+  lt_cv_file_magic_cmd='func_win32_libid'
+  ;;
+
+mingw* | pw32*)
+  # Base MSYS/MinGW do not provide the 'file' command needed by
+  # func_win32_libid shell function, so use a weaker test based on 'objdump',
+  # unless we find 'file', for example because we are cross-compiling.
+  if ( file / ) >/dev/null 2>&1; then
+    lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
+    lt_cv_file_magic_cmd='func_win32_libid'
+  else
+    # Keep this pattern in sync with the one in func_win32_libid.
+    lt_cv_deplibs_check_method='file_magic file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)'
+    lt_cv_file_magic_cmd='$OBJDUMP -f'
+  fi
+  ;;
+
+cegcc*)
+  # use the weaker test based on 'objdump'. See mingw*.
+  lt_cv_deplibs_check_method='file_magic file format pe-arm-.*little(.*architecture: arm)?'
+  lt_cv_file_magic_cmd='$OBJDUMP -f'
+  ;;
+
+darwin* | rhapsody*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+freebsd* | dragonfly*)
+  if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
+    case $host_cpu in
+    i*86 )
+      # Not sure whether the presence of OpenBSD here was a mistake.
+      # Let's accept both of them until this is cleared up.
+      lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[3-9]86 (compact )?demand paged shared library'
+      lt_cv_file_magic_cmd=/usr/bin/file
+      lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
+      ;;
+    esac
+  else
+    lt_cv_deplibs_check_method=pass_all
+  fi
+  ;;
+
+haiku*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+hpux10.20* | hpux11*)
+  lt_cv_file_magic_cmd=/usr/bin/file
+  case $host_cpu in
+  ia64*)
+    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64'
+    lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
+    ;;
+  hppa*64*)
+    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF[ -][0-9][0-9])(-bit)?( [LM]SB)? shared object( file)?[, -]* PA-RISC [0-9]\.[0-9]'
+    lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl
+    ;;
+  *)
+    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9]\.[0-9]) shared library'
+    lt_cv_file_magic_test_file=/usr/lib/libc.sl
+    ;;
+  esac
+  ;;
+
+interix[3-9]*)
+  # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here
+  lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|\.a)$'
+  ;;
+
+irix5* | irix6* | nonstopux*)
+  case $LD in
+  *-32|*"-32 ") libmagic=32-bit;;
+  *-n32|*"-n32 ") libmagic=N32;;
+  *-64|*"-64 ") libmagic=64-bit;;
+  *) libmagic=never-match;;
+  esac
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+# This must be glibc/ELF.
+linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+netbsd*)
+  if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
+    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$'
+  else
+    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|_pic\.a)$'
+  fi
+  ;;
+
+newos6*)
+  lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)'
+  lt_cv_file_magic_cmd=/usr/bin/file
+  lt_cv_file_magic_test_file=/usr/lib/libnls.so
+  ;;
+
+*nto* | *qnx*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+openbsd* | bitrig*)
+  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then
+    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|\.so|_pic\.a)$'
+  else
+    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$'
+  fi
+  ;;
+
+osf3* | osf4* | osf5*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+rdos*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+solaris*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+sysv4 | sysv4.3*)
+  case $host_vendor in
+  motorola)
+    lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]'
+    lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
+    ;;
+  ncr)
+    lt_cv_deplibs_check_method=pass_all
+    ;;
+  sequent)
+    lt_cv_file_magic_cmd='/bin/file'
+    lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )'
+    ;;
+  sni)
+    lt_cv_file_magic_cmd='/bin/file'
+    lt_cv_deplibs_check_method="file_magic ELF [0-9][0-9]*-bit [LM]SB dynamic lib"
+    lt_cv_file_magic_test_file=/lib/libc.so
+    ;;
+  siemens)
+    lt_cv_deplibs_check_method=pass_all
+    ;;
+  pc)
+    lt_cv_deplibs_check_method=pass_all
+    ;;
+  esac
+  ;;
+
+tpf*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+os2*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+esac
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_deplibs_check_method" >&5
+$as_echo "$lt_cv_deplibs_check_method" >&6; }
+
+file_magic_glob=
+want_nocaseglob=no
+if test "$build" = "$host"; then
+  case $host_os in
+  mingw* | pw32*)
+    if ( shopt | grep nocaseglob ) >/dev/null 2>&1; then
+      want_nocaseglob=yes
+    else
+      file_magic_glob=`echo aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ | $SED -e "s/\(..\)/s\/[\1]\/[\1]\/g;/g"`
+    fi
+    ;;
+  esac
+fi
+
+file_magic_cmd=$lt_cv_file_magic_cmd
+deplibs_check_method=$lt_cv_deplibs_check_method
+test -z "$deplibs_check_method" && deplibs_check_method=unknown
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}dlltool", so it can be a program name with args.
+set dummy ${ac_tool_prefix}dlltool; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_DLLTOOL+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$DLLTOOL"; then
+  ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_DLLTOOL="${ac_tool_prefix}dlltool"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+DLLTOOL=$ac_cv_prog_DLLTOOL
+if test -n "$DLLTOOL"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5
+$as_echo "$DLLTOOL" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_DLLTOOL"; then
+  ac_ct_DLLTOOL=$DLLTOOL
+  # Extract the first word of "dlltool", so it can be a program name with args.
+set dummy dlltool; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_DLLTOOL+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_DLLTOOL"; then
+  ac_cv_prog_ac_ct_DLLTOOL="$ac_ct_DLLTOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_DLLTOOL="dlltool"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL
+if test -n "$ac_ct_DLLTOOL"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5
+$as_echo "$ac_ct_DLLTOOL" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_DLLTOOL" = x; then
+    DLLTOOL="false"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    DLLTOOL=$ac_ct_DLLTOOL
+  fi
+else
+  DLLTOOL="$ac_cv_prog_DLLTOOL"
+fi
+
+test -z "$DLLTOOL" && DLLTOOL=dlltool
+
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to associate runtime and link libraries" >&5
+$as_echo_n "checking how to associate runtime and link libraries... " >&6; }
+if ${lt_cv_sharedlib_from_linklib_cmd+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_sharedlib_from_linklib_cmd='unknown'
+
+case $host_os in
+cygwin* | mingw* | pw32* | cegcc*)
+  # two different shell functions defined in ltmain.sh;
+  # decide which one to use based on capabilities of $DLLTOOL
+  case `$DLLTOOL --help 2>&1` in
+  *--identify-strict*)
+    lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib
+    ;;
+  *)
+    lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib_fallback
+    ;;
+  esac
+  ;;
+*)
+  # fallback: assume linklib IS sharedlib
+  lt_cv_sharedlib_from_linklib_cmd=$ECHO
+  ;;
+esac
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sharedlib_from_linklib_cmd" >&5
+$as_echo "$lt_cv_sharedlib_from_linklib_cmd" >&6; }
+sharedlib_from_linklib_cmd=$lt_cv_sharedlib_from_linklib_cmd
+test -z "$sharedlib_from_linklib_cmd" && sharedlib_from_linklib_cmd=$ECHO
+
+
+
+
+
+
+
+
+if test -n "$ac_tool_prefix"; then
+  for ac_prog in ar
+  do
+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_AR+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$AR"; then
+  ac_cv_prog_AR="$AR" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_AR="$ac_tool_prefix$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+AR=$ac_cv_prog_AR
+if test -n "$AR"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
+$as_echo "$AR" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+    test -n "$AR" && break
+  done
+fi
+if test -z "$AR"; then
+  ac_ct_AR=$AR
+  for ac_prog in ar
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_AR+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_AR"; then
+  ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_AR="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_AR=$ac_cv_prog_ac_ct_AR
+if test -n "$ac_ct_AR"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
+$as_echo "$ac_ct_AR" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$ac_ct_AR" && break
+done
+
+  if test "x$ac_ct_AR" = x; then
+    AR="false"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    AR=$ac_ct_AR
+  fi
+fi
+
+: ${AR=ar}
+: ${AR_FLAGS=cru}
+
+
+
+
+
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for archiver @FILE support" >&5
+$as_echo_n "checking for archiver @FILE support... " >&6; }
+if ${lt_cv_ar_at_file+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_ar_at_file=no
+   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  echo conftest.$ac_objext > conftest.lst
+      lt_ar_try='$AR $AR_FLAGS libconftest.a @conftest.lst >&5'
+      { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5
+  (eval $lt_ar_try) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+      if test 0 -eq "$ac_status"; then
+	# Ensure the archiver fails upon bogus file names.
+	rm -f conftest.$ac_objext libconftest.a
+	{ { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5
+  (eval $lt_ar_try) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+	if test 0 -ne "$ac_status"; then
+          lt_cv_ar_at_file=@
+        fi
+      fi
+      rm -f conftest.* libconftest.a
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ar_at_file" >&5
+$as_echo "$lt_cv_ar_at_file" >&6; }
+
+if test no = "$lt_cv_ar_at_file"; then
+  archiver_list_spec=
+else
+  archiver_list_spec=$lt_cv_ar_at_file
+fi
+
+
+
+
+
+
+
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
+set dummy ${ac_tool_prefix}strip; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_STRIP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$STRIP"; then
+  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+STRIP=$ac_cv_prog_STRIP
+if test -n "$STRIP"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
+$as_echo "$STRIP" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_STRIP"; then
+  ac_ct_STRIP=$STRIP
+  # Extract the first word of "strip", so it can be a program name with args.
+set dummy strip; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_STRIP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_STRIP"; then
+  ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_STRIP="strip"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
+if test -n "$ac_ct_STRIP"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
+$as_echo "$ac_ct_STRIP" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_STRIP" = x; then
+    STRIP=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    STRIP=$ac_ct_STRIP
+  fi
+else
+  STRIP="$ac_cv_prog_STRIP"
+fi
+
+test -z "$STRIP" && STRIP=:
+
+
+
+
+
+
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
+set dummy ${ac_tool_prefix}ranlib; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_RANLIB+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$RANLIB"; then
+  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+RANLIB=$ac_cv_prog_RANLIB
+if test -n "$RANLIB"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5
+$as_echo "$RANLIB" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_RANLIB"; then
+  ac_ct_RANLIB=$RANLIB
+  # Extract the first word of "ranlib", so it can be a program name with args.
+set dummy ranlib; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_RANLIB+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_RANLIB"; then
+  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_RANLIB="ranlib"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
+if test -n "$ac_ct_RANLIB"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5
+$as_echo "$ac_ct_RANLIB" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_RANLIB" = x; then
+    RANLIB=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    RANLIB=$ac_ct_RANLIB
+  fi
+else
+  RANLIB="$ac_cv_prog_RANLIB"
+fi
+
+test -z "$RANLIB" && RANLIB=:
+
+
+
+
+
+
+# Determine commands to create old-style static archives.
+old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs'
+old_postinstall_cmds='chmod 644 $oldlib'
+old_postuninstall_cmds=
+
+if test -n "$RANLIB"; then
+  case $host_os in
+  bitrig* | openbsd*)
+    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$tool_oldlib"
+    ;;
+  *)
+    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$tool_oldlib"
+    ;;
+  esac
+  old_archive_cmds="$old_archive_cmds~\$RANLIB \$tool_oldlib"
+fi
+
+case $host_os in
+  darwin*)
+    lock_old_archive_extraction=yes ;;
+  *)
+    lock_old_archive_extraction=no ;;
+esac
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# If no C compiler was specified, use CC.
+LTCC=${LTCC-"$CC"}
+
+# If no C compiler flags were specified, use CFLAGS.
+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
+
+# Allow CC to be a program name with arguments.
+compiler=$CC
+
+
+# Check for command to grab the raw symbol name followed by C symbol from nm.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking command to parse $NM output from $compiler object" >&5
+$as_echo_n "checking command to parse $NM output from $compiler object... " >&6; }
+if ${lt_cv_sys_global_symbol_pipe+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+
+# These are sane defaults that work on at least a few old systems.
+# [They come from Ultrix.  What could be older than Ultrix?!! ;)]
+
+# Character class describing NM global symbol codes.
+symcode='[BCDEGRST]'
+
+# Regexp to match symbols that can be accessed directly from C.
+sympat='\([_A-Za-z][_A-Za-z0-9]*\)'
+
+# Define system-specific variables.
+case $host_os in
+aix*)
+  symcode='[BCDT]'
+  ;;
+cygwin* | mingw* | pw32* | cegcc*)
+  symcode='[ABCDGISTW]'
+  ;;
+hpux*)
+  if test ia64 = "$host_cpu"; then
+    symcode='[ABCDEGRST]'
+  fi
+  ;;
+irix* | nonstopux*)
+  symcode='[BCDEGRST]'
+  ;;
+osf*)
+  symcode='[BCDEGQRST]'
+  ;;
+solaris*)
+  symcode='[BDRT]'
+  ;;
+sco3.2v5*)
+  symcode='[DT]'
+  ;;
+sysv4.2uw2*)
+  symcode='[DT]'
+  ;;
+sysv5* | sco5v6* | unixware* | OpenUNIX*)
+  symcode='[ABDT]'
+  ;;
+sysv4)
+  symcode='[DFNSTU]'
+  ;;
+esac
+
+# If we're using GNU nm, then use its standard symbol codes.
+case `$NM -V 2>&1` in
+*GNU* | *'with BFD'*)
+  symcode='[ABCDGIRSTW]' ;;
+esac
+
+if test "$lt_cv_nm_interface" = "MS dumpbin"; then
+  # Gets list of data symbols to import.
+  lt_cv_sys_global_symbol_to_import="sed -n -e 's/^I .* \(.*\)$/\1/p'"
+  # Adjust the below global symbol transforms to fixup imported variables.
+  lt_cdecl_hook=" -e 's/^I .* \(.*\)$/extern __declspec(dllimport) char \1;/p'"
+  lt_c_name_hook=" -e 's/^I .* \(.*\)$/  {\"\1\", (void *) 0},/p'"
+  lt_c_name_lib_hook="\
+  -e 's/^I .* \(lib.*\)$/  {\"\1\", (void *) 0},/p'\
+  -e 's/^I .* \(.*\)$/  {\"lib\1\", (void *) 0},/p'"
+else
+  # Disable hooks by default.
+  lt_cv_sys_global_symbol_to_import=
+  lt_cdecl_hook=
+  lt_c_name_hook=
+  lt_c_name_lib_hook=
+fi
+
+# Transform an extracted symbol line into a proper C declaration.
+# Some systems (esp. on ia64) link data and code symbols differently,
+# so use this general approach.
+lt_cv_sys_global_symbol_to_cdecl="sed -n"\
+$lt_cdecl_hook\
+" -e 's/^T .* \(.*\)$/extern int \1();/p'"\
+" -e 's/^$symcode$symcode* .* \(.*\)$/extern char \1;/p'"
+
+# Transform an extracted symbol line into symbol name and symbol address
+lt_cv_sys_global_symbol_to_c_name_address="sed -n"\
+$lt_c_name_hook\
+" -e 's/^: \(.*\) .*$/  {\"\1\", (void *) 0},/p'"\
+" -e 's/^$symcode$symcode* .* \(.*\)$/  {\"\1\", (void *) \&\1},/p'"
+
+# Transform an extracted symbol line into symbol name with lib prefix and
+# symbol address.
+lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n"\
+$lt_c_name_lib_hook\
+" -e 's/^: \(.*\) .*$/  {\"\1\", (void *) 0},/p'"\
+" -e 's/^$symcode$symcode* .* \(lib.*\)$/  {\"\1\", (void *) \&\1},/p'"\
+" -e 's/^$symcode$symcode* .* \(.*\)$/  {\"lib\1\", (void *) \&\1},/p'"
+
+# Handle CRLF in mingw tool chain
+opt_cr=
+case $build_os in
+mingw*)
+  opt_cr=`$ECHO 'x\{0,1\}' | tr x '\015'` # option cr in regexp
+  ;;
+esac
+
+# Try without a prefix underscore, then with it.
+for ac_symprfx in "" "_"; do
+
+  # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol.
+  symxfrm="\\1 $ac_symprfx\\2 \\2"
+
+  # Write the raw and C identifiers.
+  if test "$lt_cv_nm_interface" = "MS dumpbin"; then
+    # Fake it for dumpbin and say T for any non-static function,
+    # D for any global variable and I for any imported variable.
+    # Also find C++ and __fastcall symbols from MSVC++,
+    # which start with @ or ?.
+    lt_cv_sys_global_symbol_pipe="$AWK '"\
+"     {last_section=section; section=\$ 3};"\
+"     /^COFF SYMBOL TABLE/{for(i in hide) delete hide[i]};"\
+"     /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\
+"     /^ *Symbol name *: /{split(\$ 0,sn,\":\"); si=substr(sn[2],2)};"\
+"     /^ *Type *: code/{print \"T\",si,substr(si,length(prfx))};"\
+"     /^ *Type *: data/{print \"I\",si,substr(si,length(prfx))};"\
+"     \$ 0!~/External *\|/{next};"\
+"     / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\
+"     {if(hide[section]) next};"\
+"     {f=\"D\"}; \$ 0~/\(\).*\|/{f=\"T\"};"\
+"     {split(\$ 0,a,/\||\r/); split(a[2],s)};"\
+"     s[1]~/^[@?]/{print f,s[1],s[1]; next};"\
+"     s[1]~prfx {split(s[1],t,\"@\"); print f,t[1],substr(t[1],length(prfx))}"\
+"     ' prfx=^$ac_symprfx"
+  else
+    lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[	 ]\($symcode$symcode*\)[	 ][	 ]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"
+  fi
+  lt_cv_sys_global_symbol_pipe="$lt_cv_sys_global_symbol_pipe | sed '/ __gnu_lto/d'"
+
+  # Check to see that the pipe works correctly.
+  pipe_works=no
+
+  rm -f conftest*
+  cat > conftest.$ac_ext <<_LT_EOF
+#ifdef __cplusplus
+extern "C" {
+#endif
+char nm_test_var;
+void nm_test_func(void);
+void nm_test_func(void){}
+#ifdef __cplusplus
+}
+#endif
+int main(){nm_test_var='a';nm_test_func();return(0);}
+_LT_EOF
+
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+    # Now try to grab the symbols.
+    nlist=conftest.nm
+    if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist\""; } >&5
+  (eval $NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && test -s "$nlist"; then
+      # Try sorting and uniquifying the output.
+      if sort "$nlist" | uniq > "$nlist"T; then
+	mv -f "$nlist"T "$nlist"
+      else
+	rm -f "$nlist"T
+      fi
+
+      # Make sure that we snagged all the symbols we need.
+      if $GREP ' nm_test_var$' "$nlist" >/dev/null; then
+	if $GREP ' nm_test_func$' "$nlist" >/dev/null; then
+	  cat <<_LT_EOF > conftest.$ac_ext
+/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
+#if defined _WIN32 || defined __CYGWIN__ || defined _WIN32_WCE
+/* DATA imports from DLLs on WIN32 can't be const, because runtime
+   relocations are performed -- see ld's documentation on pseudo-relocs.  */
+# define LT_DLSYM_CONST
+#elif defined __osf__
+/* This system does not cope well with relocations in const data.  */
+# define LT_DLSYM_CONST
+#else
+# define LT_DLSYM_CONST const
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+_LT_EOF
+	  # Now generate the symbol file.
+	  eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | $GREP -v main >> conftest.$ac_ext'
+
+	  cat <<_LT_EOF >> conftest.$ac_ext
+
+/* The mapping between symbol names and symbols.  */
+LT_DLSYM_CONST struct {
+  const char *name;
+  void       *address;
+}
+lt__PROGRAM__LTX_preloaded_symbols[] =
+{
+  { "@PROGRAM@", (void *) 0 },
+_LT_EOF
+	  $SED "s/^$symcode$symcode* .* \(.*\)$/  {\"\1\", (void *) \&\1},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext
+	  cat <<\_LT_EOF >> conftest.$ac_ext
+  {0, (void *) 0}
+};
+
+/* This works around a problem in FreeBSD linker */
+#ifdef FREEBSD_WORKAROUND
+static const void *lt_preloaded_setup() {
+  return lt__PROGRAM__LTX_preloaded_symbols;
+}
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+_LT_EOF
+	  # Now try linking the two files.
+	  mv conftest.$ac_objext conftstm.$ac_objext
+	  lt_globsym_save_LIBS=$LIBS
+	  lt_globsym_save_CFLAGS=$CFLAGS
+	  LIBS=conftstm.$ac_objext
+	  CFLAGS="$CFLAGS$lt_prog_compiler_no_builtin_flag"
+	  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
+  (eval $ac_link) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && test -s conftest$ac_exeext; then
+	    pipe_works=yes
+	  fi
+	  LIBS=$lt_globsym_save_LIBS
+	  CFLAGS=$lt_globsym_save_CFLAGS
+	else
+	  echo "cannot find nm_test_func in $nlist" >&5
+	fi
+      else
+	echo "cannot find nm_test_var in $nlist" >&5
+      fi
+    else
+      echo "cannot run $lt_cv_sys_global_symbol_pipe" >&5
+    fi
+  else
+    echo "$progname: failed program was:" >&5
+    cat conftest.$ac_ext >&5
+  fi
+  rm -rf conftest* conftst*
+
+  # Do not use the global_symbol_pipe unless it works.
+  if test yes = "$pipe_works"; then
+    break
+  else
+    lt_cv_sys_global_symbol_pipe=
+  fi
+done
+
+fi
+
+if test -z "$lt_cv_sys_global_symbol_pipe"; then
+  lt_cv_sys_global_symbol_to_cdecl=
+fi
+if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
+$as_echo "failed" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+$as_echo "ok" >&6; }
+fi
+
+# Response file support.
+if test "$lt_cv_nm_interface" = "MS dumpbin"; then
+  nm_file_list_spec='@'
+elif $NM --help 2>/dev/null | grep '[@]FILE' >/dev/null; then
+  nm_file_list_spec='@'
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5
+$as_echo_n "checking for sysroot... " >&6; }
+
+# Check whether --with-sysroot was given.
+if test "${with_sysroot+set}" = set; then :
+  withval=$with_sysroot;
+else
+  with_sysroot=no
+fi
+
+
+lt_sysroot=
+case $with_sysroot in #(
+ yes)
+   if test yes = "$GCC"; then
+     lt_sysroot=`$CC --print-sysroot 2>/dev/null`
+   fi
+   ;; #(
+ /*)
+   lt_sysroot=`echo "$with_sysroot" | sed -e "$sed_quote_subst"`
+   ;; #(
+ no|'')
+   ;; #(
+ *)
+   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_sysroot" >&5
+$as_echo "$with_sysroot" >&6; }
+   as_fn_error $? "The sysroot must be an absolute path." "$LINENO" 5
+   ;;
+esac
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${lt_sysroot:-no}" >&5
+$as_echo "${lt_sysroot:-no}" >&6; }
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a working dd" >&5
+$as_echo_n "checking for a working dd... " >&6; }
+if ${ac_cv_path_lt_DD+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  printf 0123456789abcdef0123456789abcdef >conftest.i
+cat conftest.i conftest.i >conftest2.i
+: ${lt_DD:=$DD}
+if test -z "$lt_DD"; then
+  ac_path_lt_DD_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in dd; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_lt_DD="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_lt_DD" || continue
+if "$ac_path_lt_DD" bs=32 count=1 <conftest2.i >conftest.out 2>/dev/null; then
+  cmp -s conftest.i conftest.out \
+  && ac_cv_path_lt_DD="$ac_path_lt_DD" ac_path_lt_DD_found=:
+fi
+      $ac_path_lt_DD_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_lt_DD"; then
+    :
+  fi
+else
+  ac_cv_path_lt_DD=$lt_DD
+fi
+
+rm -f conftest.i conftest2.i conftest.out
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_lt_DD" >&5
+$as_echo "$ac_cv_path_lt_DD" >&6; }
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to truncate binary pipes" >&5
+$as_echo_n "checking how to truncate binary pipes... " >&6; }
+if ${lt_cv_truncate_bin+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  printf 0123456789abcdef0123456789abcdef >conftest.i
+cat conftest.i conftest.i >conftest2.i
+lt_cv_truncate_bin=
+if "$ac_cv_path_lt_DD" bs=32 count=1 <conftest2.i >conftest.out 2>/dev/null; then
+  cmp -s conftest.i conftest.out \
+  && lt_cv_truncate_bin="$ac_cv_path_lt_DD bs=4096 count=1"
+fi
+rm -f conftest.i conftest2.i conftest.out
+test -z "$lt_cv_truncate_bin" && lt_cv_truncate_bin="$SED -e 4q"
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_truncate_bin" >&5
+$as_echo "$lt_cv_truncate_bin" >&6; }
+
+
+
+
+
+
+
+# Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
+func_cc_basename ()
+{
+    for cc_temp in $*""; do
+      case $cc_temp in
+        compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
+        distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
+        \-*) ;;
+        *) break;;
+      esac
+    done
+    func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
+}
+
+# Check whether --enable-libtool-lock was given.
+if test "${enable_libtool_lock+set}" = set; then :
+  enableval=$enable_libtool_lock;
+fi
+
+test no = "$enable_libtool_lock" || enable_libtool_lock=yes
+
+# Some flags need to be propagated to the compiler or linker for good
+# libtool support.
+case $host in
+ia64-*-hpux*)
+  # Find out what ABI is being produced by ac_compile, and set mode
+  # options accordingly.
+  echo 'int i;' > conftest.$ac_ext
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+    case `/usr/bin/file conftest.$ac_objext` in
+      *ELF-32*)
+	HPUX_IA64_MODE=32
+	;;
+      *ELF-64*)
+	HPUX_IA64_MODE=64
+	;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+*-*-irix6*)
+  # Find out what ABI is being produced by ac_compile, and set linker
+  # options accordingly.
+  echo '#line '$LINENO' "configure"' > conftest.$ac_ext
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+    if test yes = "$lt_cv_prog_gnu_ld"; then
+      case `/usr/bin/file conftest.$ac_objext` in
+	*32-bit*)
+	  LD="${LD-ld} -melf32bsmip"
+	  ;;
+	*N32*)
+	  LD="${LD-ld} -melf32bmipn32"
+	  ;;
+	*64-bit*)
+	  LD="${LD-ld} -melf64bmip"
+	;;
+      esac
+    else
+      case `/usr/bin/file conftest.$ac_objext` in
+	*32-bit*)
+	  LD="${LD-ld} -32"
+	  ;;
+	*N32*)
+	  LD="${LD-ld} -n32"
+	  ;;
+	*64-bit*)
+	  LD="${LD-ld} -64"
+	  ;;
+      esac
+    fi
+  fi
+  rm -rf conftest*
+  ;;
+
+mips64*-*linux*)
+  # Find out what ABI is being produced by ac_compile, and set linker
+  # options accordingly.
+  echo '#line '$LINENO' "configure"' > conftest.$ac_ext
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+    emul=elf
+    case `/usr/bin/file conftest.$ac_objext` in
+      *32-bit*)
+	emul="${emul}32"
+	;;
+      *64-bit*)
+	emul="${emul}64"
+	;;
+    esac
+    case `/usr/bin/file conftest.$ac_objext` in
+      *MSB*)
+	emul="${emul}btsmip"
+	;;
+      *LSB*)
+	emul="${emul}ltsmip"
+	;;
+    esac
+    case `/usr/bin/file conftest.$ac_objext` in
+      *N32*)
+	emul="${emul}n32"
+	;;
+    esac
+    LD="${LD-ld} -m $emul"
+  fi
+  rm -rf conftest*
+  ;;
+
+x86_64-*kfreebsd*-gnu|x86_64-*linux*|powerpc*-*linux*| \
+s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
+  # Find out what ABI is being produced by ac_compile, and set linker
+  # options accordingly.  Note that the listed cases only cover the
+  # situations where additional linker options are needed (such as when
+  # doing 32-bit compilation for a host where ld defaults to 64-bit, or
+  # vice versa); the common cases where no linker options are needed do
+  # not appear in the list.
+  echo 'int i;' > conftest.$ac_ext
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+    case `/usr/bin/file conftest.o` in
+      *32-bit*)
+	case $host in
+	  x86_64-*kfreebsd*-gnu)
+	    LD="${LD-ld} -m elf_i386_fbsd"
+	    ;;
+	  x86_64-*linux*)
+	    case `/usr/bin/file conftest.o` in
+	      *x86-64*)
+		LD="${LD-ld} -m elf32_x86_64"
+		;;
+	      *)
+		LD="${LD-ld} -m elf_i386"
+		;;
+	    esac
+	    ;;
+	  powerpc64le-*linux*)
+	    LD="${LD-ld} -m elf32lppclinux"
+	    ;;
+	  powerpc64-*linux*)
+	    LD="${LD-ld} -m elf32ppclinux"
+	    ;;
+	  s390x-*linux*)
+	    LD="${LD-ld} -m elf_s390"
+	    ;;
+	  sparc64-*linux*)
+	    LD="${LD-ld} -m elf32_sparc"
+	    ;;
+	esac
+	;;
+      *64-bit*)
+	case $host in
+	  x86_64-*kfreebsd*-gnu)
+	    LD="${LD-ld} -m elf_x86_64_fbsd"
+	    ;;
+	  x86_64-*linux*)
+	    LD="${LD-ld} -m elf_x86_64"
+	    ;;
+	  powerpcle-*linux*)
+	    LD="${LD-ld} -m elf64lppc"
+	    ;;
+	  powerpc-*linux*)
+	    LD="${LD-ld} -m elf64ppc"
+	    ;;
+	  s390*-*linux*|s390*-*tpf*)
+	    LD="${LD-ld} -m elf64_s390"
+	    ;;
+	  sparc*-*linux*)
+	    LD="${LD-ld} -m elf64_sparc"
+	    ;;
+	esac
+	;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+
+*-*-sco3.2v5*)
+  # On SCO OpenServer 5, we need -belf to get full-featured binaries.
+  SAVE_CFLAGS=$CFLAGS
+  CFLAGS="$CFLAGS -belf"
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler needs -belf" >&5
+$as_echo_n "checking whether the C compiler needs -belf... " >&6; }
+if ${lt_cv_cc_needs_belf+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  lt_cv_cc_needs_belf=yes
+else
+  lt_cv_cc_needs_belf=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+     ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_cc_needs_belf" >&5
+$as_echo "$lt_cv_cc_needs_belf" >&6; }
+  if test yes != "$lt_cv_cc_needs_belf"; then
+    # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
+    CFLAGS=$SAVE_CFLAGS
+  fi
+  ;;
+*-*solaris*)
+  # Find out what ABI is being produced by ac_compile, and set linker
+  # options accordingly.
+  echo 'int i;' > conftest.$ac_ext
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+    case `/usr/bin/file conftest.o` in
+    *64-bit*)
+      case $lt_cv_prog_gnu_ld in
+      yes*)
+        case $host in
+        i?86-*-solaris*|x86_64-*-solaris*)
+          LD="${LD-ld} -m elf_x86_64"
+          ;;
+        sparc*-*-solaris*)
+          LD="${LD-ld} -m elf64_sparc"
+          ;;
+        esac
+        # GNU ld 2.21 introduced _sol2 emulations.  Use them if available.
+        if ${LD-ld} -V | grep _sol2 >/dev/null 2>&1; then
+          LD=${LD-ld}_sol2
+        fi
+        ;;
+      *)
+	if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then
+	  LD="${LD-ld} -64"
+	fi
+	;;
+      esac
+      ;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+esac
+
+need_locks=$enable_libtool_lock
+
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}mt", so it can be a program name with args.
+set dummy ${ac_tool_prefix}mt; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_MANIFEST_TOOL+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$MANIFEST_TOOL"; then
+  ac_cv_prog_MANIFEST_TOOL="$MANIFEST_TOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_MANIFEST_TOOL="${ac_tool_prefix}mt"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+MANIFEST_TOOL=$ac_cv_prog_MANIFEST_TOOL
+if test -n "$MANIFEST_TOOL"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MANIFEST_TOOL" >&5
+$as_echo "$MANIFEST_TOOL" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_MANIFEST_TOOL"; then
+  ac_ct_MANIFEST_TOOL=$MANIFEST_TOOL
+  # Extract the first word of "mt", so it can be a program name with args.
+set dummy mt; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_MANIFEST_TOOL+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_MANIFEST_TOOL"; then
+  ac_cv_prog_ac_ct_MANIFEST_TOOL="$ac_ct_MANIFEST_TOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_MANIFEST_TOOL="mt"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_MANIFEST_TOOL=$ac_cv_prog_ac_ct_MANIFEST_TOOL
+if test -n "$ac_ct_MANIFEST_TOOL"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_MANIFEST_TOOL" >&5
+$as_echo "$ac_ct_MANIFEST_TOOL" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_MANIFEST_TOOL" = x; then
+    MANIFEST_TOOL=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    MANIFEST_TOOL=$ac_ct_MANIFEST_TOOL
+  fi
+else
+  MANIFEST_TOOL="$ac_cv_prog_MANIFEST_TOOL"
+fi
+
+test -z "$MANIFEST_TOOL" && MANIFEST_TOOL=mt
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $MANIFEST_TOOL is a manifest tool" >&5
+$as_echo_n "checking if $MANIFEST_TOOL is a manifest tool... " >&6; }
+if ${lt_cv_path_mainfest_tool+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_path_mainfest_tool=no
+  echo "$as_me:$LINENO: $MANIFEST_TOOL '-?'" >&5
+  $MANIFEST_TOOL '-?' 2>conftest.err > conftest.out
+  cat conftest.err >&5
+  if $GREP 'Manifest Tool' conftest.out > /dev/null; then
+    lt_cv_path_mainfest_tool=yes
+  fi
+  rm -f conftest*
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_mainfest_tool" >&5
+$as_echo "$lt_cv_path_mainfest_tool" >&6; }
+if test yes != "$lt_cv_path_mainfest_tool"; then
+  MANIFEST_TOOL=:
+fi
+
+
+
+
+
+
+  case $host_os in
+    rhapsody* | darwin*)
+    if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}dsymutil", so it can be a program name with args.
+set dummy ${ac_tool_prefix}dsymutil; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_DSYMUTIL+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$DSYMUTIL"; then
+  ac_cv_prog_DSYMUTIL="$DSYMUTIL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_DSYMUTIL="${ac_tool_prefix}dsymutil"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+DSYMUTIL=$ac_cv_prog_DSYMUTIL
+if test -n "$DSYMUTIL"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
+$as_echo "$DSYMUTIL" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_DSYMUTIL"; then
+  ac_ct_DSYMUTIL=$DSYMUTIL
+  # Extract the first word of "dsymutil", so it can be a program name with args.
+set dummy dsymutil; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_DSYMUTIL+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_DSYMUTIL"; then
+  ac_cv_prog_ac_ct_DSYMUTIL="$ac_ct_DSYMUTIL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_DSYMUTIL="dsymutil"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_DSYMUTIL=$ac_cv_prog_ac_ct_DSYMUTIL
+if test -n "$ac_ct_DSYMUTIL"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DSYMUTIL" >&5
+$as_echo "$ac_ct_DSYMUTIL" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_DSYMUTIL" = x; then
+    DSYMUTIL=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    DSYMUTIL=$ac_ct_DSYMUTIL
+  fi
+else
+  DSYMUTIL="$ac_cv_prog_DSYMUTIL"
+fi
+
+    if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}nmedit", so it can be a program name with args.
+set dummy ${ac_tool_prefix}nmedit; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_NMEDIT+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$NMEDIT"; then
+  ac_cv_prog_NMEDIT="$NMEDIT" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_NMEDIT="${ac_tool_prefix}nmedit"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+NMEDIT=$ac_cv_prog_NMEDIT
+if test -n "$NMEDIT"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NMEDIT" >&5
+$as_echo "$NMEDIT" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_NMEDIT"; then
+  ac_ct_NMEDIT=$NMEDIT
+  # Extract the first word of "nmedit", so it can be a program name with args.
+set dummy nmedit; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_NMEDIT+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_NMEDIT"; then
+  ac_cv_prog_ac_ct_NMEDIT="$ac_ct_NMEDIT" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_NMEDIT="nmedit"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_NMEDIT=$ac_cv_prog_ac_ct_NMEDIT
+if test -n "$ac_ct_NMEDIT"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NMEDIT" >&5
+$as_echo "$ac_ct_NMEDIT" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_NMEDIT" = x; then
+    NMEDIT=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    NMEDIT=$ac_ct_NMEDIT
+  fi
+else
+  NMEDIT="$ac_cv_prog_NMEDIT"
+fi
+
+    if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}lipo", so it can be a program name with args.
+set dummy ${ac_tool_prefix}lipo; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_LIPO+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$LIPO"; then
+  ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_LIPO="${ac_tool_prefix}lipo"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+LIPO=$ac_cv_prog_LIPO
+if test -n "$LIPO"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5
+$as_echo "$LIPO" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_LIPO"; then
+  ac_ct_LIPO=$LIPO
+  # Extract the first word of "lipo", so it can be a program name with args.
+set dummy lipo; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_LIPO+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_LIPO"; then
+  ac_cv_prog_ac_ct_LIPO="$ac_ct_LIPO" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_LIPO="lipo"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_LIPO=$ac_cv_prog_ac_ct_LIPO
+if test -n "$ac_ct_LIPO"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_LIPO" >&5
+$as_echo "$ac_ct_LIPO" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_LIPO" = x; then
+    LIPO=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    LIPO=$ac_ct_LIPO
+  fi
+else
+  LIPO="$ac_cv_prog_LIPO"
+fi
+
+    if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}otool", so it can be a program name with args.
+set dummy ${ac_tool_prefix}otool; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_OTOOL+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$OTOOL"; then
+  ac_cv_prog_OTOOL="$OTOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_OTOOL="${ac_tool_prefix}otool"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+OTOOL=$ac_cv_prog_OTOOL
+if test -n "$OTOOL"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
+$as_echo "$OTOOL" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_OTOOL"; then
+  ac_ct_OTOOL=$OTOOL
+  # Extract the first word of "otool", so it can be a program name with args.
+set dummy otool; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_OTOOL+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_OTOOL"; then
+  ac_cv_prog_ac_ct_OTOOL="$ac_ct_OTOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_OTOOL="otool"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_OTOOL=$ac_cv_prog_ac_ct_OTOOL
+if test -n "$ac_ct_OTOOL"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL" >&5
+$as_echo "$ac_ct_OTOOL" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_OTOOL" = x; then
+    OTOOL=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    OTOOL=$ac_ct_OTOOL
+  fi
+else
+  OTOOL="$ac_cv_prog_OTOOL"
+fi
+
+    if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}otool64", so it can be a program name with args.
+set dummy ${ac_tool_prefix}otool64; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_OTOOL64+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$OTOOL64"; then
+  ac_cv_prog_OTOOL64="$OTOOL64" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_OTOOL64="${ac_tool_prefix}otool64"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+OTOOL64=$ac_cv_prog_OTOOL64
+if test -n "$OTOOL64"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL64" >&5
+$as_echo "$OTOOL64" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_OTOOL64"; then
+  ac_ct_OTOOL64=$OTOOL64
+  # Extract the first word of "otool64", so it can be a program name with args.
+set dummy otool64; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_OTOOL64+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_OTOOL64"; then
+  ac_cv_prog_ac_ct_OTOOL64="$ac_ct_OTOOL64" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_OTOOL64="otool64"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_OTOOL64=$ac_cv_prog_ac_ct_OTOOL64
+if test -n "$ac_ct_OTOOL64"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL64" >&5
+$as_echo "$ac_ct_OTOOL64" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_OTOOL64" = x; then
+    OTOOL64=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    OTOOL64=$ac_ct_OTOOL64
+  fi
+else
+  OTOOL64="$ac_cv_prog_OTOOL64"
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -single_module linker flag" >&5
+$as_echo_n "checking for -single_module linker flag... " >&6; }
+if ${lt_cv_apple_cc_single_mod+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_apple_cc_single_mod=no
+      if test -z "$LT_MULTI_MODULE"; then
+	# By default we will add the -single_module flag. You can override
+	# by either setting the environment variable LT_MULTI_MODULE
+	# non-empty at configure time, or by adding -multi_module to the
+	# link flags.
+	rm -rf libconftest.dylib*
+	echo "int foo(void){return 1;}" > conftest.c
+	echo "$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
+-dynamiclib -Wl,-single_module conftest.c" >&5
+	$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
+	  -dynamiclib -Wl,-single_module conftest.c 2>conftest.err
+        _lt_result=$?
+	# If there is a non-empty error log, and "single_module"
+	# appears in it, assume the flag caused a linker warning
+        if test -s conftest.err && $GREP single_module conftest.err; then
+	  cat conftest.err >&5
+	# Otherwise, if the output was created with a 0 exit code from
+	# the compiler, it worked.
+	elif test -f libconftest.dylib && test 0 = "$_lt_result"; then
+	  lt_cv_apple_cc_single_mod=yes
+	else
+	  cat conftest.err >&5
+	fi
+	rm -rf libconftest.dylib*
+	rm -f conftest.*
+      fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_apple_cc_single_mod" >&5
+$as_echo "$lt_cv_apple_cc_single_mod" >&6; }
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -exported_symbols_list linker flag" >&5
+$as_echo_n "checking for -exported_symbols_list linker flag... " >&6; }
+if ${lt_cv_ld_exported_symbols_list+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_ld_exported_symbols_list=no
+      save_LDFLAGS=$LDFLAGS
+      echo "_main" > conftest.sym
+      LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym"
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  lt_cv_ld_exported_symbols_list=yes
+else
+  lt_cv_ld_exported_symbols_list=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+	LDFLAGS=$save_LDFLAGS
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_exported_symbols_list" >&5
+$as_echo "$lt_cv_ld_exported_symbols_list" >&6; }
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -force_load linker flag" >&5
+$as_echo_n "checking for -force_load linker flag... " >&6; }
+if ${lt_cv_ld_force_load+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_ld_force_load=no
+      cat > conftest.c << _LT_EOF
+int forced_loaded() { return 2;}
+_LT_EOF
+      echo "$LTCC $LTCFLAGS -c -o conftest.o conftest.c" >&5
+      $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&5
+      echo "$AR cru libconftest.a conftest.o" >&5
+      $AR cru libconftest.a conftest.o 2>&5
+      echo "$RANLIB libconftest.a" >&5
+      $RANLIB libconftest.a 2>&5
+      cat > conftest.c << _LT_EOF
+int main() { return 0;}
+_LT_EOF
+      echo "$LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a" >&5
+      $LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a 2>conftest.err
+      _lt_result=$?
+      if test -s conftest.err && $GREP force_load conftest.err; then
+	cat conftest.err >&5
+      elif test -f conftest && test 0 = "$_lt_result" && $GREP forced_load conftest >/dev/null 2>&1; then
+	lt_cv_ld_force_load=yes
+      else
+	cat conftest.err >&5
+      fi
+        rm -f conftest.err libconftest.a conftest conftest.c
+        rm -rf conftest.dSYM
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_force_load" >&5
+$as_echo "$lt_cv_ld_force_load" >&6; }
+    case $host_os in
+    rhapsody* | darwin1.[012])
+      _lt_dar_allow_undefined='$wl-undefined ${wl}suppress' ;;
+    darwin1.*)
+      _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;;
+    darwin*) # darwin 5.x on
+      # if running on 10.5 or later, the deployment target defaults
+      # to the OS version, if on x86, and 10.4, the deployment
+      # target defaults to 10.4. Don't you love it?
+      case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in
+	10.0,*86*-darwin8*|10.0,*-darwin[91]*)
+	  _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;;
+	10.[012][,.]*)
+	  _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;;
+	10.*)
+	  _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;;
+      esac
+    ;;
+  esac
+    if test yes = "$lt_cv_apple_cc_single_mod"; then
+      _lt_dar_single_mod='$single_module'
+    fi
+    if test yes = "$lt_cv_ld_exported_symbols_list"; then
+      _lt_dar_export_syms=' $wl-exported_symbols_list,$output_objdir/$libname-symbols.expsym'
+    else
+      _lt_dar_export_syms='~$NMEDIT -s $output_objdir/$libname-symbols.expsym $lib'
+    fi
+    if test : != "$DSYMUTIL" && test no = "$lt_cv_ld_force_load"; then
+      _lt_dsymutil='~$DSYMUTIL $lib || :'
+    else
+      _lt_dsymutil=
+    fi
+    ;;
+  esac
+
+# func_munge_path_list VARIABLE PATH
+# -----------------------------------
+# VARIABLE is name of variable containing _space_ separated list of
+# directories to be munged by the contents of PATH, which is string
+# having a format:
+# "DIR[:DIR]:"
+#       string "DIR[ DIR]" will be prepended to VARIABLE
+# ":DIR[:DIR]"
+#       string "DIR[ DIR]" will be appended to VARIABLE
+# "DIRP[:DIRP]::[DIRA:]DIRA"
+#       string "DIRP[ DIRP]" will be prepended to VARIABLE and string
+#       "DIRA[ DIRA]" will be appended to VARIABLE
+# "DIR[:DIR]"
+#       VARIABLE will be replaced by "DIR[ DIR]"
+func_munge_path_list ()
+{
+    case x$2 in
+    x)
+        ;;
+    *:)
+        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\"
+        ;;
+    x:*)
+        eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\"
+        ;;
+    *::*)
+        eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
+        eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
+        ;;
+    *)
+        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\"
+        ;;
+    esac
+}
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
+$as_echo_n "checking for ANSI C header files... " >&6; }
+if ${ac_cv_header_stdc+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <float.h>
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_header_stdc=yes
+else
+  ac_cv_header_stdc=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+
+if test $ac_cv_header_stdc = yes; then
+  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <string.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "memchr" >/dev/null 2>&1; then :
+
+else
+  ac_cv_header_stdc=no
+fi
+rm -f conftest*
+
+fi
+
+if test $ac_cv_header_stdc = yes; then
+  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdlib.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "free" >/dev/null 2>&1; then :
+
+else
+  ac_cv_header_stdc=no
+fi
+rm -f conftest*
+
+fi
+
+if test $ac_cv_header_stdc = yes; then
+  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
+  if test "$cross_compiling" = yes; then :
+  :
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ctype.h>
+#include <stdlib.h>
+#if ((' ' & 0x0FF) == 0x020)
+# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
+# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
+#else
+# define ISLOWER(c) \
+		   (('a' <= (c) && (c) <= 'i') \
+		     || ('j' <= (c) && (c) <= 'r') \
+		     || ('s' <= (c) && (c) <= 'z'))
+# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
+#endif
+
+#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
+int
+main ()
+{
+  int i;
+  for (i = 0; i < 256; i++)
+    if (XOR (islower (i), ISLOWER (i))
+	|| toupper (i) != TOUPPER (i))
+      return 2;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_run "$LINENO"; then :
+
+else
+  ac_cv_header_stdc=no
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
+$as_echo "$ac_cv_header_stdc" >&6; }
+if test $ac_cv_header_stdc = yes; then
+
+$as_echo "#define STDC_HEADERS 1" >>confdefs.h
+
+fi
+
+# On IRIX 5.3, sys/types and inttypes.h are conflicting.
+for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
+		  inttypes.h stdint.h unistd.h
+do :
+  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
+ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default
+"
+if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
+  cat >>confdefs.h <<_ACEOF
+#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+
+done
+
+
+for ac_header in dlfcn.h
+do :
+  ac_fn_c_check_header_compile "$LINENO" "dlfcn.h" "ac_cv_header_dlfcn_h" "$ac_includes_default
+"
+if test "x$ac_cv_header_dlfcn_h" = xyes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_DLFCN_H 1
+_ACEOF
+
+fi
+
+done
+
+
+
+
+
+# Set options
+enable_win32_dll=yes
+
+case $host in
+*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-cegcc*)
+  if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args.
+set dummy ${ac_tool_prefix}as; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_AS+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$AS"; then
+  ac_cv_prog_AS="$AS" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_AS="${ac_tool_prefix}as"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+AS=$ac_cv_prog_AS
+if test -n "$AS"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
+$as_echo "$AS" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_AS"; then
+  ac_ct_AS=$AS
+  # Extract the first word of "as", so it can be a program name with args.
+set dummy as; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_AS+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_AS"; then
+  ac_cv_prog_ac_ct_AS="$ac_ct_AS" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_AS="as"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_AS=$ac_cv_prog_ac_ct_AS
+if test -n "$ac_ct_AS"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AS" >&5
+$as_echo "$ac_ct_AS" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_AS" = x; then
+    AS="false"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    AS=$ac_ct_AS
+  fi
+else
+  AS="$ac_cv_prog_AS"
+fi
+
+  if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}dlltool", so it can be a program name with args.
+set dummy ${ac_tool_prefix}dlltool; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_DLLTOOL+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$DLLTOOL"; then
+  ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_DLLTOOL="${ac_tool_prefix}dlltool"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+DLLTOOL=$ac_cv_prog_DLLTOOL
+if test -n "$DLLTOOL"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5
+$as_echo "$DLLTOOL" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_DLLTOOL"; then
+  ac_ct_DLLTOOL=$DLLTOOL
+  # Extract the first word of "dlltool", so it can be a program name with args.
+set dummy dlltool; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_DLLTOOL+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_DLLTOOL"; then
+  ac_cv_prog_ac_ct_DLLTOOL="$ac_ct_DLLTOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_DLLTOOL="dlltool"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL
+if test -n "$ac_ct_DLLTOOL"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5
+$as_echo "$ac_ct_DLLTOOL" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_DLLTOOL" = x; then
+    DLLTOOL="false"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    DLLTOOL=$ac_ct_DLLTOOL
+  fi
+else
+  DLLTOOL="$ac_cv_prog_DLLTOOL"
+fi
+
+  if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args.
+set dummy ${ac_tool_prefix}objdump; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_OBJDUMP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$OBJDUMP"; then
+  ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+OBJDUMP=$ac_cv_prog_OBJDUMP
+if test -n "$OBJDUMP"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
+$as_echo "$OBJDUMP" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_OBJDUMP"; then
+  ac_ct_OBJDUMP=$OBJDUMP
+  # Extract the first word of "objdump", so it can be a program name with args.
+set dummy objdump; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_OBJDUMP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_OBJDUMP"; then
+  ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_OBJDUMP="objdump"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
+if test -n "$ac_ct_OBJDUMP"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
+$as_echo "$ac_ct_OBJDUMP" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_OBJDUMP" = x; then
+    OBJDUMP="false"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    OBJDUMP=$ac_ct_OBJDUMP
+  fi
+else
+  OBJDUMP="$ac_cv_prog_OBJDUMP"
+fi
+
+  ;;
+esac
+
+test -z "$AS" && AS=as
+
+
+
+
+
+test -z "$DLLTOOL" && DLLTOOL=dlltool
+
+
+
+
+
+test -z "$OBJDUMP" && OBJDUMP=objdump
+
+
+
+
+
+
+
+        enable_dlopen=no
+
+
+
+            # Check whether --enable-shared was given.
+if test "${enable_shared+set}" = set; then :
+  enableval=$enable_shared; p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_shared=yes ;;
+    no) enable_shared=no ;;
+    *)
+      enable_shared=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
+      for pkg in $enableval; do
+	IFS=$lt_save_ifs
+	if test "X$pkg" = "X$p"; then
+	  enable_shared=yes
+	fi
+      done
+      IFS=$lt_save_ifs
+      ;;
+    esac
+else
+  enable_shared=yes
+fi
+
+
+
+
+
+
+
+
+
+  # Check whether --enable-static was given.
+if test "${enable_static+set}" = set; then :
+  enableval=$enable_static; p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_static=yes ;;
+    no) enable_static=no ;;
+    *)
+     enable_static=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
+      for pkg in $enableval; do
+	IFS=$lt_save_ifs
+	if test "X$pkg" = "X$p"; then
+	  enable_static=yes
+	fi
+      done
+      IFS=$lt_save_ifs
+      ;;
+    esac
+else
+  enable_static=yes
+fi
+
+
+
+
+
+
+
+
+
+
+# Check whether --with-pic was given.
+if test "${with_pic+set}" = set; then :
+  withval=$with_pic; lt_p=${PACKAGE-default}
+    case $withval in
+    yes|no) pic_mode=$withval ;;
+    *)
+      pic_mode=default
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
+      for lt_pkg in $withval; do
+	IFS=$lt_save_ifs
+	if test "X$lt_pkg" = "X$lt_p"; then
+	  pic_mode=yes
+	fi
+      done
+      IFS=$lt_save_ifs
+      ;;
+    esac
+else
+  pic_mode=default
+fi
+
+
+
+
+
+
+
+
+  # Check whether --enable-fast-install was given.
+if test "${enable_fast_install+set}" = set; then :
+  enableval=$enable_fast_install; p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_fast_install=yes ;;
+    no) enable_fast_install=no ;;
+    *)
+      enable_fast_install=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
+      for pkg in $enableval; do
+	IFS=$lt_save_ifs
+	if test "X$pkg" = "X$p"; then
+	  enable_fast_install=yes
+	fi
+      done
+      IFS=$lt_save_ifs
+      ;;
+    esac
+else
+  enable_fast_install=yes
+fi
+
+
+
+
+
+
+
+
+  shared_archive_member_spec=
+case $host,$enable_shared in
+power*-*-aix[5-9]*,yes)
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of shared library versioning to provide" >&5
+$as_echo_n "checking which variant of shared library versioning to provide... " >&6; }
+
+# Check whether --with-aix-soname was given.
+if test "${with_aix_soname+set}" = set; then :
+  withval=$with_aix_soname; case $withval in
+    aix|svr4|both)
+      ;;
+    *)
+      as_fn_error $? "Unknown argument to --with-aix-soname" "$LINENO" 5
+      ;;
+    esac
+    lt_cv_with_aix_soname=$with_aix_soname
+else
+  if ${lt_cv_with_aix_soname+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_with_aix_soname=aix
+fi
+
+    with_aix_soname=$lt_cv_with_aix_soname
+fi
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_aix_soname" >&5
+$as_echo "$with_aix_soname" >&6; }
+  if test aix != "$with_aix_soname"; then
+    # For the AIX way of multilib, we name the shared archive member
+    # based on the bitwidth used, traditionally 'shr.o' or 'shr_64.o',
+    # and 'shr.imp' or 'shr_64.imp', respectively, for the Import File.
+    # Even when GNU compilers ignore OBJECT_MODE but need '-maix64' flag,
+    # the AIX toolchain works better with OBJECT_MODE set (default 32).
+    if test 64 = "${OBJECT_MODE-32}"; then
+      shared_archive_member_spec=shr_64
+    else
+      shared_archive_member_spec=shr
+    fi
+  fi
+  ;;
+*)
+  with_aix_soname=aix
+  ;;
+esac
+
+
+
+
+
+
+
+
+
+
+# This can be used to rebuild libtool when needed
+LIBTOOL_DEPS=$ltmain
+
+# Always use our own libtool.
+LIBTOOL='$(SHELL) $(top_builddir)/libtool'
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+test -z "$LN_S" && LN_S="ln -s"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+if test -n "${ZSH_VERSION+set}"; then
+   setopt NO_GLOB_SUBST
+fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for objdir" >&5
+$as_echo_n "checking for objdir... " >&6; }
+if ${lt_cv_objdir+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  rm -f .libs 2>/dev/null
+mkdir .libs 2>/dev/null
+if test -d .libs; then
+  lt_cv_objdir=.libs
+else
+  # MS-DOS does not allow filenames that begin with a dot.
+  lt_cv_objdir=_libs
+fi
+rmdir .libs 2>/dev/null
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_objdir" >&5
+$as_echo "$lt_cv_objdir" >&6; }
+objdir=$lt_cv_objdir
+
+
+
+
+
+cat >>confdefs.h <<_ACEOF
+#define LT_OBJDIR "$lt_cv_objdir/"
+_ACEOF
+
+
+
+
+case $host_os in
+aix3*)
+  # AIX sometimes has problems with the GCC collect2 program.  For some
+  # reason, if we set the COLLECT_NAMES environment variable, the problems
+  # vanish in a puff of smoke.
+  if test set != "${COLLECT_NAMES+set}"; then
+    COLLECT_NAMES=
+    export COLLECT_NAMES
+  fi
+  ;;
+esac
+
+# Global variables:
+ofile=libtool
+can_build_shared=yes
+
+# All known linkers require a '.a' archive for static linking (except MSVC,
+# which needs '.lib').
+libext=a
+
+with_gnu_ld=$lt_cv_prog_gnu_ld
+
+old_CC=$CC
+old_CFLAGS=$CFLAGS
+
+# Set sane defaults for various variables
+test -z "$CC" && CC=cc
+test -z "$LTCC" && LTCC=$CC
+test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS
+test -z "$LD" && LD=ld
+test -z "$ac_objext" && ac_objext=o
+
+func_cc_basename $compiler
+cc_basename=$func_cc_basename_result
+
+
+# Only perform the check for file, if the check method requires it
+test -z "$MAGIC_CMD" && MAGIC_CMD=file
+case $deplibs_check_method in
+file_magic*)
+  if test "$file_magic_cmd" = '$MAGIC_CMD'; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ac_tool_prefix}file" >&5
+$as_echo_n "checking for ${ac_tool_prefix}file... " >&6; }
+if ${lt_cv_path_MAGIC_CMD+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  case $MAGIC_CMD in
+[\\/*] |  ?:[\\/]*)
+  lt_cv_path_MAGIC_CMD=$MAGIC_CMD # Let the user override the test with a path.
+  ;;
+*)
+  lt_save_MAGIC_CMD=$MAGIC_CMD
+  lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
+  ac_dummy="/usr/bin$PATH_SEPARATOR$PATH"
+  for ac_dir in $ac_dummy; do
+    IFS=$lt_save_ifs
+    test -z "$ac_dir" && ac_dir=.
+    if test -f "$ac_dir/${ac_tool_prefix}file"; then
+      lt_cv_path_MAGIC_CMD=$ac_dir/"${ac_tool_prefix}file"
+      if test -n "$file_magic_test_file"; then
+	case $deplibs_check_method in
+	"file_magic "*)
+	  file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
+	  MAGIC_CMD=$lt_cv_path_MAGIC_CMD
+	  if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
+	    $EGREP "$file_magic_regex" > /dev/null; then
+	    :
+	  else
+	    cat <<_LT_EOF 1>&2
+
+*** Warning: the command libtool uses to detect shared libraries,
+*** $file_magic_cmd, produces output that libtool cannot recognize.
+*** The result is that libtool may fail to recognize shared libraries
+*** as such.  This will affect the creation of libtool libraries that
+*** depend on shared libraries, but programs linked with such libtool
+*** libraries will work regardless of this problem.  Nevertheless, you
+*** may want to report the problem to your system manager and/or to
+*** bug-libtool@gnu.org
+
+_LT_EOF
+	  fi ;;
+	esac
+      fi
+      break
+    fi
+  done
+  IFS=$lt_save_ifs
+  MAGIC_CMD=$lt_save_MAGIC_CMD
+  ;;
+esac
+fi
+
+MAGIC_CMD=$lt_cv_path_MAGIC_CMD
+if test -n "$MAGIC_CMD"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5
+$as_echo "$MAGIC_CMD" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+
+
+
+if test -z "$lt_cv_path_MAGIC_CMD"; then
+  if test -n "$ac_tool_prefix"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for file" >&5
+$as_echo_n "checking for file... " >&6; }
+if ${lt_cv_path_MAGIC_CMD+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  case $MAGIC_CMD in
+[\\/*] |  ?:[\\/]*)
+  lt_cv_path_MAGIC_CMD=$MAGIC_CMD # Let the user override the test with a path.
+  ;;
+*)
+  lt_save_MAGIC_CMD=$MAGIC_CMD
+  lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
+  ac_dummy="/usr/bin$PATH_SEPARATOR$PATH"
+  for ac_dir in $ac_dummy; do
+    IFS=$lt_save_ifs
+    test -z "$ac_dir" && ac_dir=.
+    if test -f "$ac_dir/file"; then
+      lt_cv_path_MAGIC_CMD=$ac_dir/"file"
+      if test -n "$file_magic_test_file"; then
+	case $deplibs_check_method in
+	"file_magic "*)
+	  file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
+	  MAGIC_CMD=$lt_cv_path_MAGIC_CMD
+	  if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
+	    $EGREP "$file_magic_regex" > /dev/null; then
+	    :
+	  else
+	    cat <<_LT_EOF 1>&2
+
+*** Warning: the command libtool uses to detect shared libraries,
+*** $file_magic_cmd, produces output that libtool cannot recognize.
+*** The result is that libtool may fail to recognize shared libraries
+*** as such.  This will affect the creation of libtool libraries that
+*** depend on shared libraries, but programs linked with such libtool
+*** libraries will work regardless of this problem.  Nevertheless, you
+*** may want to report the problem to your system manager and/or to
+*** bug-libtool@gnu.org
+
+_LT_EOF
+	  fi ;;
+	esac
+      fi
+      break
+    fi
+  done
+  IFS=$lt_save_ifs
+  MAGIC_CMD=$lt_save_MAGIC_CMD
+  ;;
+esac
+fi
+
+MAGIC_CMD=$lt_cv_path_MAGIC_CMD
+if test -n "$MAGIC_CMD"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5
+$as_echo "$MAGIC_CMD" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  else
+    MAGIC_CMD=:
+  fi
+fi
+
+  fi
+  ;;
+esac
+
+# Use C for the default configuration in the libtool script
+
+lt_save_CC=$CC
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+# Source file extension for C test sources.
+ac_ext=c
+
+# Object file extension for compiled C test sources.
+objext=o
+objext=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code="int some_variable = 0;"
+
+# Code to be used in simple link tests
+lt_simple_link_test_code='int main(){return(0);}'
+
+
+
+
+
+
+
+# If no C compiler was specified, use CC.
+LTCC=${LTCC-"$CC"}
+
+# If no C compiler flags were specified, use CFLAGS.
+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
+
+# Allow CC to be a program name with arguments.
+compiler=$CC
+
+# Save the default compiler, since it gets overwritten when the other
+# tags are being tested, and _LT_TAGVAR(compiler, []) is a NOP.
+compiler_DEFAULT=$CC
+
+# save warnings/boilerplate of simple test code
+ac_outfile=conftest.$ac_objext
+echo "$lt_simple_compile_test_code" >conftest.$ac_ext
+eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_compiler_boilerplate=`cat conftest.err`
+$RM conftest*
+
+ac_outfile=conftest.$ac_objext
+echo "$lt_simple_link_test_code" >conftest.$ac_ext
+eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_linker_boilerplate=`cat conftest.err`
+$RM -r conftest*
+
+
+## CAVEAT EMPTOR:
+## There is no encapsulation within the following macros, do not change
+## the running order or otherwise move them around unless you know exactly
+## what you are doing...
+if test -n "$compiler"; then
+
+lt_prog_compiler_no_builtin_flag=
+
+if test yes = "$GCC"; then
+  case $cc_basename in
+  nvcc*)
+    lt_prog_compiler_no_builtin_flag=' -Xcompiler -fno-builtin' ;;
+  *)
+    lt_prog_compiler_no_builtin_flag=' -fno-builtin' ;;
+  esac
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -fno-rtti -fno-exceptions" >&5
+$as_echo_n "checking if $compiler supports -fno-rtti -fno-exceptions... " >&6; }
+if ${lt_cv_prog_compiler_rtti_exceptions+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_prog_compiler_rtti_exceptions=no
+   ac_outfile=conftest.$ac_objext
+   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+   lt_compiler_flag="-fno-rtti -fno-exceptions"  ## exclude from sc_useless_quotes_in_assignment
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   # The option is referenced via a variable to avoid confusing sed.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>conftest.err)
+   ac_status=$?
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s "$ac_outfile"; then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings other than the usual output.
+     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp
+     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
+       lt_cv_prog_compiler_rtti_exceptions=yes
+     fi
+   fi
+   $RM conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_rtti_exceptions" >&5
+$as_echo "$lt_cv_prog_compiler_rtti_exceptions" >&6; }
+
+if test yes = "$lt_cv_prog_compiler_rtti_exceptions"; then
+    lt_prog_compiler_no_builtin_flag="$lt_prog_compiler_no_builtin_flag -fno-rtti -fno-exceptions"
+else
+    :
+fi
+
+fi
+
+
+
+
+
+
+  lt_prog_compiler_wl=
+lt_prog_compiler_pic=
+lt_prog_compiler_static=
+
+
+  if test yes = "$GCC"; then
+    lt_prog_compiler_wl='-Wl,'
+    lt_prog_compiler_static='-static'
+
+    case $host_os in
+      aix*)
+      # All AIX code is PIC.
+      if test ia64 = "$host_cpu"; then
+	# AIX 5 now supports IA64 processor
+	lt_prog_compiler_static='-Bstatic'
+      fi
+      lt_prog_compiler_pic='-fPIC'
+      ;;
+
+    amigaos*)
+      case $host_cpu in
+      powerpc)
+            # see comment about AmigaOS4 .so support
+            lt_prog_compiler_pic='-fPIC'
+        ;;
+      m68k)
+            # FIXME: we need at least 68020 code to build shared libraries, but
+            # adding the '-m68020' flag to GCC prevents building anything better,
+            # like '-m68040'.
+            lt_prog_compiler_pic='-m68020 -resident32 -malways-restore-a4'
+        ;;
+      esac
+      ;;
+
+    beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
+      # PIC is the default for these OSes.
+      ;;
+
+    mingw* | cygwin* | pw32* | os2* | cegcc*)
+      # This hack is so that the source file can tell whether it is being
+      # built for inclusion in a dll (and should export symbols for example).
+      # Although the cygwin gcc ignores -fPIC, still need this for old-style
+      # (--disable-auto-import) libraries
+      lt_prog_compiler_pic='-DDLL_EXPORT'
+      case $host_os in
+      os2*)
+	lt_prog_compiler_static='$wl-static'
+	;;
+      esac
+      ;;
+
+    darwin* | rhapsody*)
+      # PIC is the default on this platform
+      # Common symbols not allowed in MH_DYLIB files
+      lt_prog_compiler_pic='-fno-common'
+      ;;
+
+    haiku*)
+      # PIC is the default for Haiku.
+      # The "-static" flag exists, but is broken.
+      lt_prog_compiler_static=
+      ;;
+
+    hpux*)
+      # PIC is the default for 64-bit PA HP-UX, but not for 32-bit
+      # PA HP-UX.  On IA64 HP-UX, PIC is the default but the pic flag
+      # sets the default TLS model and affects inlining.
+      case $host_cpu in
+      hppa*64*)
+	# +Z the default
+	;;
+      *)
+	lt_prog_compiler_pic='-fPIC'
+	;;
+      esac
+      ;;
+
+    interix[3-9]*)
+      # Interix 3.x gcc -fpic/-fPIC options generate broken code.
+      # Instead, we relocate shared libraries at runtime.
+      ;;
+
+    msdosdjgpp*)
+      # Just because we use GCC doesn't mean we suddenly get shared libraries
+      # on systems that don't support them.
+      lt_prog_compiler_can_build_shared=no
+      enable_shared=no
+      ;;
+
+    *nto* | *qnx*)
+      # QNX uses GNU C++, but need to define -shared option too, otherwise
+      # it will coredump.
+      lt_prog_compiler_pic='-fPIC -shared'
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	lt_prog_compiler_pic=-Kconform_pic
+      fi
+      ;;
+
+    *)
+      lt_prog_compiler_pic='-fPIC'
+      ;;
+    esac
+
+    case $cc_basename in
+    nvcc*) # Cuda Compiler Driver 2.2
+      lt_prog_compiler_wl='-Xlinker '
+      if test -n "$lt_prog_compiler_pic"; then
+        lt_prog_compiler_pic="-Xcompiler $lt_prog_compiler_pic"
+      fi
+      ;;
+    esac
+  else
+    # PORTME Check for flag to pass linker flags through the system compiler.
+    case $host_os in
+    aix*)
+      lt_prog_compiler_wl='-Wl,'
+      if test ia64 = "$host_cpu"; then
+	# AIX 5 now supports IA64 processor
+	lt_prog_compiler_static='-Bstatic'
+      else
+	lt_prog_compiler_static='-bnso -bI:/lib/syscalls.exp'
+      fi
+      ;;
+
+    darwin* | rhapsody*)
+      # PIC is the default on this platform
+      # Common symbols not allowed in MH_DYLIB files
+      lt_prog_compiler_pic='-fno-common'
+      case $cc_basename in
+      nagfor*)
+        # NAG Fortran compiler
+        lt_prog_compiler_wl='-Wl,-Wl,,'
+        lt_prog_compiler_pic='-PIC'
+        lt_prog_compiler_static='-Bstatic'
+        ;;
+      esac
+      ;;
+
+    mingw* | cygwin* | pw32* | os2* | cegcc*)
+      # This hack is so that the source file can tell whether it is being
+      # built for inclusion in a dll (and should export symbols for example).
+      lt_prog_compiler_pic='-DDLL_EXPORT'
+      case $host_os in
+      os2*)
+	lt_prog_compiler_static='$wl-static'
+	;;
+      esac
+      ;;
+
+    hpux9* | hpux10* | hpux11*)
+      lt_prog_compiler_wl='-Wl,'
+      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
+      # not for PA HP-UX.
+      case $host_cpu in
+      hppa*64*|ia64*)
+	# +Z the default
+	;;
+      *)
+	lt_prog_compiler_pic='+Z'
+	;;
+      esac
+      # Is there a better lt_prog_compiler_static that works with the bundled CC?
+      lt_prog_compiler_static='$wl-a ${wl}archive'
+      ;;
+
+    irix5* | irix6* | nonstopux*)
+      lt_prog_compiler_wl='-Wl,'
+      # PIC (with -KPIC) is the default.
+      lt_prog_compiler_static='-non_shared'
+      ;;
+
+    linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+      case $cc_basename in
+      # old Intel for x86_64, which still supported -KPIC.
+      ecc*)
+	lt_prog_compiler_wl='-Wl,'
+	lt_prog_compiler_pic='-KPIC'
+	lt_prog_compiler_static='-static'
+        ;;
+      # icc used to be incompatible with GCC.
+      # ICC 10 doesn't accept -KPIC any more.
+      icc* | ifort*)
+	lt_prog_compiler_wl='-Wl,'
+	lt_prog_compiler_pic='-fPIC'
+	lt_prog_compiler_static='-static'
+        ;;
+      # Lahey Fortran 8.1.
+      lf95*)
+	lt_prog_compiler_wl='-Wl,'
+	lt_prog_compiler_pic='--shared'
+	lt_prog_compiler_static='--static'
+	;;
+      nagfor*)
+	# NAG Fortran compiler
+	lt_prog_compiler_wl='-Wl,-Wl,,'
+	lt_prog_compiler_pic='-PIC'
+	lt_prog_compiler_static='-Bstatic'
+	;;
+      tcc*)
+	# Fabrice Bellard et al's Tiny C Compiler
+	lt_prog_compiler_wl='-Wl,'
+	lt_prog_compiler_pic='-fPIC'
+	lt_prog_compiler_static='-static'
+	;;
+      pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*)
+        # Portland Group compilers (*not* the Pentium gcc compiler,
+	# which looks to be a dead project)
+	lt_prog_compiler_wl='-Wl,'
+	lt_prog_compiler_pic='-fpic'
+	lt_prog_compiler_static='-Bstatic'
+        ;;
+      ccc*)
+        lt_prog_compiler_wl='-Wl,'
+        # All Alpha code is PIC.
+        lt_prog_compiler_static='-non_shared'
+        ;;
+      xl* | bgxl* | bgf* | mpixl*)
+	# IBM XL C 8.0/Fortran 10.1, 11.1 on PPC and BlueGene
+	lt_prog_compiler_wl='-Wl,'
+	lt_prog_compiler_pic='-qpic'
+	lt_prog_compiler_static='-qstaticlink'
+	;;
+      *)
+	case `$CC -V 2>&1 | sed 5q` in
+	*Sun\ Ceres\ Fortran* | *Sun*Fortran*\ [1-7].* | *Sun*Fortran*\ 8.[0-3]*)
+	  # Sun Fortran 8.3 passes all unrecognized flags to the linker
+	  lt_prog_compiler_pic='-KPIC'
+	  lt_prog_compiler_static='-Bstatic'
+	  lt_prog_compiler_wl=''
+	  ;;
+	*Sun\ F* | *Sun*Fortran*)
+	  lt_prog_compiler_pic='-KPIC'
+	  lt_prog_compiler_static='-Bstatic'
+	  lt_prog_compiler_wl='-Qoption ld '
+	  ;;
+	*Sun\ C*)
+	  # Sun C 5.9
+	  lt_prog_compiler_pic='-KPIC'
+	  lt_prog_compiler_static='-Bstatic'
+	  lt_prog_compiler_wl='-Wl,'
+	  ;;
+        *Intel*\ [CF]*Compiler*)
+	  lt_prog_compiler_wl='-Wl,'
+	  lt_prog_compiler_pic='-fPIC'
+	  lt_prog_compiler_static='-static'
+	  ;;
+	*Portland\ Group*)
+	  lt_prog_compiler_wl='-Wl,'
+	  lt_prog_compiler_pic='-fpic'
+	  lt_prog_compiler_static='-Bstatic'
+	  ;;
+	esac
+	;;
+      esac
+      ;;
+
+    newsos6)
+      lt_prog_compiler_pic='-KPIC'
+      lt_prog_compiler_static='-Bstatic'
+      ;;
+
+    *nto* | *qnx*)
+      # QNX uses GNU C++, but need to define -shared option too, otherwise
+      # it will coredump.
+      lt_prog_compiler_pic='-fPIC -shared'
+      ;;
+
+    osf3* | osf4* | osf5*)
+      lt_prog_compiler_wl='-Wl,'
+      # All OSF/1 code is PIC.
+      lt_prog_compiler_static='-non_shared'
+      ;;
+
+    rdos*)
+      lt_prog_compiler_static='-non_shared'
+      ;;
+
+    solaris*)
+      lt_prog_compiler_pic='-KPIC'
+      lt_prog_compiler_static='-Bstatic'
+      case $cc_basename in
+      f77* | f90* | f95* | sunf77* | sunf90* | sunf95*)
+	lt_prog_compiler_wl='-Qoption ld ';;
+      *)
+	lt_prog_compiler_wl='-Wl,';;
+      esac
+      ;;
+
+    sunos4*)
+      lt_prog_compiler_wl='-Qoption ld '
+      lt_prog_compiler_pic='-PIC'
+      lt_prog_compiler_static='-Bstatic'
+      ;;
+
+    sysv4 | sysv4.2uw2* | sysv4.3*)
+      lt_prog_compiler_wl='-Wl,'
+      lt_prog_compiler_pic='-KPIC'
+      lt_prog_compiler_static='-Bstatic'
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	lt_prog_compiler_pic='-Kconform_pic'
+	lt_prog_compiler_static='-Bstatic'
+      fi
+      ;;
+
+    sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
+      lt_prog_compiler_wl='-Wl,'
+      lt_prog_compiler_pic='-KPIC'
+      lt_prog_compiler_static='-Bstatic'
+      ;;
+
+    unicos*)
+      lt_prog_compiler_wl='-Wl,'
+      lt_prog_compiler_can_build_shared=no
+      ;;
+
+    uts4*)
+      lt_prog_compiler_pic='-pic'
+      lt_prog_compiler_static='-Bstatic'
+      ;;
+
+    *)
+      lt_prog_compiler_can_build_shared=no
+      ;;
+    esac
+  fi
+
+case $host_os in
+  # For platforms that do not support PIC, -DPIC is meaningless:
+  *djgpp*)
+    lt_prog_compiler_pic=
+    ;;
+  *)
+    lt_prog_compiler_pic="$lt_prog_compiler_pic -DPIC"
+    ;;
+esac
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5
+$as_echo_n "checking for $compiler option to produce PIC... " >&6; }
+if ${lt_cv_prog_compiler_pic+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_prog_compiler_pic=$lt_prog_compiler_pic
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic" >&5
+$as_echo "$lt_cv_prog_compiler_pic" >&6; }
+lt_prog_compiler_pic=$lt_cv_prog_compiler_pic
+
+#
+# Check to make sure the PIC flag actually works.
+#
+if test -n "$lt_prog_compiler_pic"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5
+$as_echo_n "checking if $compiler PIC flag $lt_prog_compiler_pic works... " >&6; }
+if ${lt_cv_prog_compiler_pic_works+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_prog_compiler_pic_works=no
+   ac_outfile=conftest.$ac_objext
+   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+   lt_compiler_flag="$lt_prog_compiler_pic -DPIC"  ## exclude from sc_useless_quotes_in_assignment
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   # The option is referenced via a variable to avoid confusing sed.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>conftest.err)
+   ac_status=$?
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s "$ac_outfile"; then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings other than the usual output.
+     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp
+     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
+       lt_cv_prog_compiler_pic_works=yes
+     fi
+   fi
+   $RM conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works" >&5
+$as_echo "$lt_cv_prog_compiler_pic_works" >&6; }
+
+if test yes = "$lt_cv_prog_compiler_pic_works"; then
+    case $lt_prog_compiler_pic in
+     "" | " "*) ;;
+     *) lt_prog_compiler_pic=" $lt_prog_compiler_pic" ;;
+     esac
+else
+    lt_prog_compiler_pic=
+     lt_prog_compiler_can_build_shared=no
+fi
+
+fi
+
+
+
+
+
+
+
+
+
+
+
+#
+# Check to make sure the static flag actually works.
+#
+wl=$lt_prog_compiler_wl eval lt_tmp_static_flag=\"$lt_prog_compiler_static\"
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5
+$as_echo_n "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; }
+if ${lt_cv_prog_compiler_static_works+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_prog_compiler_static_works=no
+   save_LDFLAGS=$LDFLAGS
+   LDFLAGS="$LDFLAGS $lt_tmp_static_flag"
+   echo "$lt_simple_link_test_code" > conftest.$ac_ext
+   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
+     # The linker can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     if test -s conftest.err; then
+       # Append any errors to the config.log.
+       cat conftest.err 1>&5
+       $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp
+       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+       if diff conftest.exp conftest.er2 >/dev/null; then
+         lt_cv_prog_compiler_static_works=yes
+       fi
+     else
+       lt_cv_prog_compiler_static_works=yes
+     fi
+   fi
+   $RM -r conftest*
+   LDFLAGS=$save_LDFLAGS
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works" >&5
+$as_echo "$lt_cv_prog_compiler_static_works" >&6; }
+
+if test yes = "$lt_cv_prog_compiler_static_works"; then
+    :
+else
+    lt_prog_compiler_static=
+fi
+
+
+
+
+
+
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
+$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
+if ${lt_cv_prog_compiler_c_o+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_prog_compiler_c_o=no
+   $RM -r conftest 2>/dev/null
+   mkdir conftest
+   cd conftest
+   mkdir out
+   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+   lt_compiler_flag="-o out/conftest2.$ac_objext"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>out/conftest.err)
+   ac_status=$?
+   cat out/conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s out/conftest2.$ac_objext
+   then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
+     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
+     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
+       lt_cv_prog_compiler_c_o=yes
+     fi
+   fi
+   chmod u+w . 2>&5
+   $RM conftest*
+   # SGI C++ compiler will create directory out/ii_files/ for
+   # template instantiation
+   test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
+   $RM out/* && rmdir out
+   cd ..
+   $RM -r conftest
+   $RM conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5
+$as_echo "$lt_cv_prog_compiler_c_o" >&6; }
+
+
+
+
+
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
+$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
+if ${lt_cv_prog_compiler_c_o+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_prog_compiler_c_o=no
+   $RM -r conftest 2>/dev/null
+   mkdir conftest
+   cd conftest
+   mkdir out
+   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+   lt_compiler_flag="-o out/conftest2.$ac_objext"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>out/conftest.err)
+   ac_status=$?
+   cat out/conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s out/conftest2.$ac_objext
+   then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
+     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
+     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
+       lt_cv_prog_compiler_c_o=yes
+     fi
+   fi
+   chmod u+w . 2>&5
+   $RM conftest*
+   # SGI C++ compiler will create directory out/ii_files/ for
+   # template instantiation
+   test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
+   $RM out/* && rmdir out
+   cd ..
+   $RM -r conftest
+   $RM conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5
+$as_echo "$lt_cv_prog_compiler_c_o" >&6; }
+
+
+
+
+hard_links=nottested
+if test no = "$lt_cv_prog_compiler_c_o" && test no != "$need_locks"; then
+  # do not overwrite the value of need_locks provided by the user
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5
+$as_echo_n "checking if we can lock with hard links... " >&6; }
+  hard_links=yes
+  $RM conftest*
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  touch conftest.a
+  ln conftest.a conftest.b 2>&5 || hard_links=no
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5
+$as_echo "$hard_links" >&6; }
+  if test no = "$hard_links"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&5
+$as_echo "$as_me: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&2;}
+    need_locks=warn
+  fi
+else
+  need_locks=no
+fi
+
+
+
+
+
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5
+$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; }
+
+  runpath_var=
+  allow_undefined_flag=
+  always_export_symbols=no
+  archive_cmds=
+  archive_expsym_cmds=
+  compiler_needs_object=no
+  enable_shared_with_static_runtimes=no
+  export_dynamic_flag_spec=
+  export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+  hardcode_automatic=no
+  hardcode_direct=no
+  hardcode_direct_absolute=no
+  hardcode_libdir_flag_spec=
+  hardcode_libdir_separator=
+  hardcode_minus_L=no
+  hardcode_shlibpath_var=unsupported
+  inherit_rpath=no
+  link_all_deplibs=unknown
+  module_cmds=
+  module_expsym_cmds=
+  old_archive_from_new_cmds=
+  old_archive_from_expsyms_cmds=
+  thread_safe_flag_spec=
+  whole_archive_flag_spec=
+  # include_expsyms should be a list of space-separated symbols to be *always*
+  # included in the symbol list
+  include_expsyms=
+  # exclude_expsyms can be an extended regexp of symbols to exclude
+  # it will be wrapped by ' (' and ')$', so one must not match beginning or
+  # end of line.  Example: 'a|bc|.*d.*' will exclude the symbols 'a' and 'bc',
+  # as well as any symbol that contains 'd'.
+  exclude_expsyms='_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*'
+  # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out
+  # platforms (ab)use it in PIC code, but their linkers get confused if
+  # the symbol is explicitly referenced.  Since portable code cannot
+  # rely on this symbol name, it's probably fine to never include it in
+  # preloaded symbol tables.
+  # Exclude shared library initialization/finalization symbols.
+  extract_expsyms_cmds=
+
+  case $host_os in
+  cygwin* | mingw* | pw32* | cegcc*)
+    # FIXME: the MSVC++ port hasn't been tested in a loooong time
+    # When not using gcc, we currently assume that we are using
+    # Microsoft Visual C++.
+    if test yes != "$GCC"; then
+      with_gnu_ld=no
+    fi
+    ;;
+  interix*)
+    # we just hope/assume this is gcc and not c89 (= MSVC++)
+    with_gnu_ld=yes
+    ;;
+  openbsd* | bitrig*)
+    with_gnu_ld=no
+    ;;
+  esac
+
+  ld_shlibs=yes
+
+  # On some targets, GNU ld is compatible enough with the native linker
+  # that we're better off using the native interface for both.
+  lt_use_gnu_ld_interface=no
+  if test yes = "$with_gnu_ld"; then
+    case $host_os in
+      aix*)
+	# The AIX port of GNU ld has always aspired to compatibility
+	# with the native linker.  However, as the warning in the GNU ld
+	# block says, versions before 2.19.5* couldn't really create working
+	# shared libraries, regardless of the interface used.
+	case `$LD -v 2>&1` in
+	  *\ \(GNU\ Binutils\)\ 2.19.5*) ;;
+	  *\ \(GNU\ Binutils\)\ 2.[2-9]*) ;;
+	  *\ \(GNU\ Binutils\)\ [3-9]*) ;;
+	  *)
+	    lt_use_gnu_ld_interface=yes
+	    ;;
+	esac
+	;;
+      *)
+	lt_use_gnu_ld_interface=yes
+	;;
+    esac
+  fi
+
+  if test yes = "$lt_use_gnu_ld_interface"; then
+    # If archive_cmds runs LD, not CC, wlarc should be empty
+    wlarc='$wl'
+
+    # Set some defaults for GNU ld with shared library support. These
+    # are reset later if shared libraries are not supported. Putting them
+    # here allows them to be overridden if necessary.
+    runpath_var=LD_RUN_PATH
+    hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
+    export_dynamic_flag_spec='$wl--export-dynamic'
+    # ancient GNU ld didn't support --whole-archive et. al.
+    if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then
+      whole_archive_flag_spec=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive'
+    else
+      whole_archive_flag_spec=
+    fi
+    supports_anon_versioning=no
+    case `$LD -v | $SED -e 's/(^)\+)\s\+//' 2>&1` in
+      *GNU\ gold*) supports_anon_versioning=yes ;;
+      *\ [01].* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11
+      *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
+      *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
+      *\ 2.11.*) ;; # other 2.11 versions
+      *) supports_anon_versioning=yes ;;
+    esac
+
+    # See if GNU ld supports shared libraries.
+    case $host_os in
+    aix[3-9]*)
+      # On AIX/PPC, the GNU linker is very broken
+      if test ia64 != "$host_cpu"; then
+	ld_shlibs=no
+	cat <<_LT_EOF 1>&2
+
+*** Warning: the GNU linker, at least up to release 2.19, is reported
+*** to be unable to reliably create shared libraries on AIX.
+*** Therefore, libtool is disabling shared libraries support.  If you
+*** really care for shared libraries, you may want to install binutils
+*** 2.20 or above, or modify your PATH so that a non-GNU linker is found.
+*** You will then need to restart the configuration process.
+
+_LT_EOF
+      fi
+      ;;
+
+    amigaos*)
+      case $host_cpu in
+      powerpc)
+            # see comment about AmigaOS4 .so support
+            archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+            archive_expsym_cmds=''
+        ;;
+      m68k)
+            archive_cmds='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
+            hardcode_libdir_flag_spec='-L$libdir'
+            hardcode_minus_L=yes
+        ;;
+      esac
+      ;;
+
+    beos*)
+      if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+	allow_undefined_flag=unsupported
+	# Joseph Beckenbach <jrb3@best.com> says some releases of gcc
+	# support --undefined.  This deserves some investigation.  FIXME
+	archive_cmds='$CC -nostart $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+      else
+	ld_shlibs=no
+      fi
+      ;;
+
+    cygwin* | mingw* | pw32* | cegcc*)
+      # _LT_TAGVAR(hardcode_libdir_flag_spec, ) is actually meaningless,
+      # as there is no search path for DLLs.
+      hardcode_libdir_flag_spec='-L$libdir'
+      export_dynamic_flag_spec='$wl--export-all-symbols'
+      allow_undefined_flag=unsupported
+      always_export_symbols=no
+      enable_shared_with_static_runtimes=yes
+      export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1 DATA/;s/^.*[ ]__nm__\([^ ]*\)[ ][^ ]*/\1 DATA/;/^I[ ]/d;/^[AITW][ ]/s/.* //'\'' | sort | uniq > $export_symbols'
+      exclude_expsyms='[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname'
+
+      if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
+        archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+	# If the export-symbols file already is a .def file, use it as
+	# is; otherwise, prepend EXPORTS...
+	archive_expsym_cmds='if   test DEF = "`$SED -n     -e '\''s/^[	 ]*//'\''     -e '\''/^\(;.*\)*$/d'\''     -e '\''s/^\(EXPORTS\|LIBRARY\)\([	 ].*\)*$/DEF/p'\''     -e q     $export_symbols`" ; then
+          cp $export_symbols $output_objdir/$soname.def;
+        else
+          echo EXPORTS > $output_objdir/$soname.def;
+          cat $export_symbols >> $output_objdir/$soname.def;
+        fi~
+        $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+      else
+	ld_shlibs=no
+      fi
+      ;;
+
+    haiku*)
+      archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+      link_all_deplibs=yes
+      ;;
+
+    os2*)
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_minus_L=yes
+      allow_undefined_flag=unsupported
+      shrext_cmds=.dll
+      archive_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      archive_expsym_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	prefix_cmds="$SED"~
+	if test EXPORTS = "`$SED 1q $export_symbols`"; then
+	  prefix_cmds="$prefix_cmds -e 1d";
+	fi~
+	prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~
+	cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      old_archive_From_new_cmds='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
+      enable_shared_with_static_runtimes=yes
+      ;;
+
+    interix[3-9]*)
+      hardcode_direct=no
+      hardcode_shlibpath_var=no
+      hardcode_libdir_flag_spec='$wl-rpath,$libdir'
+      export_dynamic_flag_spec='$wl-E'
+      # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
+      # Instead, shared libraries are loaded at an image base (0x10000000 by
+      # default) and relocated if they conflict, which is a slow very memory
+      # consuming and fragmenting process.  To avoid this, we pick a random,
+      # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
+      # time.  Moving up from 0x10000000 also allows more sbrk(2) space.
+      archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+      archive_expsym_cmds='sed "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--retain-symbols-file,$output_objdir/$soname.expsym $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+      ;;
+
+    gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu)
+      tmp_diet=no
+      if test linux-dietlibc = "$host_os"; then
+	case $cc_basename in
+	  diet\ *) tmp_diet=yes;;	# linux-dietlibc with static linking (!diet-dyn)
+	esac
+      fi
+      if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \
+	 && test no = "$tmp_diet"
+      then
+	tmp_addflag=' $pic_flag'
+	tmp_sharedflag='-shared'
+	case $cc_basename,$host_cpu in
+        pgcc*)				# Portland Group C compiler
+	  whole_archive_flag_spec='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
+	  tmp_addflag=' $pic_flag'
+	  ;;
+	pgf77* | pgf90* | pgf95* | pgfortran*)
+					# Portland Group f77 and f90 compilers
+	  whole_archive_flag_spec='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
+	  tmp_addflag=' $pic_flag -Mnomain' ;;
+	ecc*,ia64* | icc*,ia64*)	# Intel C compiler on ia64
+	  tmp_addflag=' -i_dynamic' ;;
+	efc*,ia64* | ifort*,ia64*)	# Intel Fortran compiler on ia64
+	  tmp_addflag=' -i_dynamic -nofor_main' ;;
+	ifc* | ifort*)			# Intel Fortran compiler
+	  tmp_addflag=' -nofor_main' ;;
+	lf95*)				# Lahey Fortran 8.1
+	  whole_archive_flag_spec=
+	  tmp_sharedflag='--shared' ;;
+        nagfor*)                        # NAGFOR 5.3
+          tmp_sharedflag='-Wl,-shared' ;;
+	xl[cC]* | bgxl[cC]* | mpixl[cC]*) # IBM XL C 8.0 on PPC (deal with xlf below)
+	  tmp_sharedflag='-qmkshrobj'
+	  tmp_addflag= ;;
+	nvcc*)	# Cuda Compiler Driver 2.2
+	  whole_archive_flag_spec='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
+	  compiler_needs_object=yes
+	  ;;
+	esac
+	case `$CC -V 2>&1 | sed 5q` in
+	*Sun\ C*)			# Sun C 5.9
+	  whole_archive_flag_spec='$wl--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
+	  compiler_needs_object=yes
+	  tmp_sharedflag='-G' ;;
+	*Sun\ F*)			# Sun Fortran 8.3
+	  tmp_sharedflag='-G' ;;
+	esac
+	archive_cmds='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+
+        if test yes = "$supports_anon_versioning"; then
+          archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~
+            cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+            echo "local: *; };" >> $output_objdir/$libname.ver~
+            $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-version-script $wl$output_objdir/$libname.ver -o $lib'
+        fi
+
+	case $cc_basename in
+	tcc*)
+	  export_dynamic_flag_spec='-rdynamic'
+	  ;;
+	xlf* | bgf* | bgxlf* | mpixlf*)
+	  # IBM XL Fortran 10.1 on PPC cannot create shared libs itself
+	  whole_archive_flag_spec='--whole-archive$convenience --no-whole-archive'
+	  hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
+	  archive_cmds='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib'
+	  if test yes = "$supports_anon_versioning"; then
+	    archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~
+              cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+              echo "local: *; };" >> $output_objdir/$libname.ver~
+              $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib'
+	  fi
+	  ;;
+	esac
+      else
+        ld_shlibs=no
+      fi
+      ;;
+
+    netbsd*)
+      if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+	archive_cmds='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
+	wlarc=
+      else
+	archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+      fi
+      ;;
+
+    solaris*)
+      if $LD -v 2>&1 | $GREP 'BFD 2\.8' > /dev/null; then
+	ld_shlibs=no
+	cat <<_LT_EOF 1>&2
+
+*** Warning: The releases 2.8.* of the GNU linker cannot reliably
+*** create shared libraries on Solaris systems.  Therefore, libtool
+*** is disabling shared libraries support.  We urge you to upgrade GNU
+*** binutils to release 2.9.1 or newer.  Another option is to modify
+*** your PATH or compiler configuration so that the native linker is
+*** used, and then restart.
+
+_LT_EOF
+      elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+	archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+      else
+	ld_shlibs=no
+      fi
+      ;;
+
+    sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)
+      case `$LD -v 2>&1` in
+        *\ [01].* | *\ 2.[0-9].* | *\ 2.1[0-5].*)
+	ld_shlibs=no
+	cat <<_LT_EOF 1>&2
+
+*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 cannot
+*** reliably create shared libraries on SCO systems.  Therefore, libtool
+*** is disabling shared libraries support.  We urge you to upgrade GNU
+*** binutils to release 2.16.91.0.3 or newer.  Another option is to modify
+*** your PATH or compiler configuration so that the native linker is
+*** used, and then restart.
+
+_LT_EOF
+	;;
+	*)
+	  # For security reasons, it is highly recommended that you always
+	  # use absolute paths for naming shared libraries, and exclude the
+	  # DT_RUNPATH tag from executables and libraries.  But doing so
+	  # requires that you compile everything twice, which is a pain.
+	  if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+	    hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
+	    archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	    archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+	  else
+	    ld_shlibs=no
+	  fi
+	;;
+      esac
+      ;;
+
+    sunos4*)
+      archive_cmds='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+      wlarc=
+      hardcode_direct=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    *)
+      if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+	archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+      else
+	ld_shlibs=no
+      fi
+      ;;
+    esac
+
+    if test no = "$ld_shlibs"; then
+      runpath_var=
+      hardcode_libdir_flag_spec=
+      export_dynamic_flag_spec=
+      whole_archive_flag_spec=
+    fi
+  else
+    # PORTME fill in a description of your system's linker (not GNU ld)
+    case $host_os in
+    aix3*)
+      allow_undefined_flag=unsupported
+      always_export_symbols=yes
+      archive_expsym_cmds='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname'
+      # Note: this linker hardcodes the directories in LIBPATH if there
+      # are no directories specified by -L.
+      hardcode_minus_L=yes
+      if test yes = "$GCC" && test -z "$lt_prog_compiler_static"; then
+	# Neither direct hardcoding nor static linking is supported with a
+	# broken collect2.
+	hardcode_direct=unsupported
+      fi
+      ;;
+
+    aix[4-9]*)
+      if test ia64 = "$host_cpu"; then
+	# On IA64, the linker does run time linking by default, so we don't
+	# have to do anything special.
+	aix_use_runtimelinking=no
+	exp_sym_flag='-Bexport'
+	no_entry_flag=
+      else
+	# If we're using GNU nm, then we don't want the "-C" option.
+	# -C means demangle to GNU nm, but means don't demangle to AIX nm.
+	# Without the "-l" option, or with the "-B" option, AIX nm treats
+	# weak defined symbols like other global defined symbols, whereas
+	# GNU nm marks them as "W".
+	# While the 'weak' keyword is ignored in the Export File, we need
+	# it in the Import File for the 'aix-soname' feature, so we have
+	# to replace the "-B" option with "-P" for AIX nm.
+	if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
+	  export_symbols_cmds='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols'
+	else
+	  export_symbols_cmds='`func_echo_all $NM | $SED -e '\''s/B\([^B]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && (substr(\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols'
+	fi
+	aix_use_runtimelinking=no
+
+	# Test if we are trying to use run time linking or normal
+	# AIX style linking. If -brtl is somewhere in LDFLAGS, we
+	# have runtime linking enabled, and use it for executables.
+	# For shared libraries, we enable/disable runtime linking
+	# depending on the kind of the shared library created -
+	# when "with_aix_soname,aix_use_runtimelinking" is:
+	# "aix,no"   lib.a(lib.so.V) shared, rtl:no,  for executables
+	# "aix,yes"  lib.so          shared, rtl:yes, for executables
+	#            lib.a           static archive
+	# "both,no"  lib.so.V(shr.o) shared, rtl:yes
+	#            lib.a(lib.so.V) shared, rtl:no,  for executables
+	# "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables
+	#            lib.a(lib.so.V) shared, rtl:no
+	# "svr4,*"   lib.so.V(shr.o) shared, rtl:yes, for executables
+	#            lib.a           static archive
+	case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*)
+	  for ld_flag in $LDFLAGS; do
+	  if (test x-brtl = "x$ld_flag" || test x-Wl,-brtl = "x$ld_flag"); then
+	    aix_use_runtimelinking=yes
+	    break
+	  fi
+	  done
+	  if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then
+	    # With aix-soname=svr4, we create the lib.so.V shared archives only,
+	    # so we don't have lib.a shared libs to link our executables.
+	    # We have to force runtime linking in this case.
+	    aix_use_runtimelinking=yes
+	    LDFLAGS="$LDFLAGS -Wl,-brtl"
+	  fi
+	  ;;
+	esac
+
+	exp_sym_flag='-bexport'
+	no_entry_flag='-bnoentry'
+      fi
+
+      # When large executables or shared objects are built, AIX ld can
+      # have problems creating the table of contents.  If linking a library
+      # or program results in "error TOC overflow" add -mminimal-toc to
+      # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
+      # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
+
+      archive_cmds=''
+      hardcode_direct=yes
+      hardcode_direct_absolute=yes
+      hardcode_libdir_separator=':'
+      link_all_deplibs=yes
+      file_list_spec='$wl-f,'
+      case $with_aix_soname,$aix_use_runtimelinking in
+      aix,*) ;; # traditional, no import file
+      svr4,* | *,yes) # use import file
+	# The Import File defines what to hardcode.
+	hardcode_direct=no
+	hardcode_direct_absolute=no
+	;;
+      esac
+
+      if test yes = "$GCC"; then
+	case $host_os in aix4.[012]|aix4.[012].*)
+	# We only want to do this on AIX 4.2 and lower, the check
+	# below for broken collect2 doesn't work under 4.3+
+	  collect2name=`$CC -print-prog-name=collect2`
+	  if test -f "$collect2name" &&
+	   strings "$collect2name" | $GREP resolve_lib_name >/dev/null
+	  then
+	  # We have reworked collect2
+	  :
+	  else
+	  # We have old collect2
+	  hardcode_direct=unsupported
+	  # It fails to find uninstalled libraries when the uninstalled
+	  # path is not listed in the libpath.  Setting hardcode_minus_L
+	  # to unsupported forces relinking
+	  hardcode_minus_L=yes
+	  hardcode_libdir_flag_spec='-L$libdir'
+	  hardcode_libdir_separator=
+	  fi
+	  ;;
+	esac
+	shared_flag='-shared'
+	if test yes = "$aix_use_runtimelinking"; then
+	  shared_flag="$shared_flag "'$wl-G'
+	fi
+	# Need to ensure runtime linking is disabled for the traditional
+	# shared library, or the linker may eventually find shared libraries
+	# /with/ Import File - we do not want to mix them.
+	shared_flag_aix='-shared'
+	shared_flag_svr4='-shared $wl-G'
+      else
+	# not using gcc
+	if test ia64 = "$host_cpu"; then
+	# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
+	# chokes on -Wl,-G. The following line is correct:
+	  shared_flag='-G'
+	else
+	  if test yes = "$aix_use_runtimelinking"; then
+	    shared_flag='$wl-G'
+	  else
+	    shared_flag='$wl-bM:SRE'
+	  fi
+	  shared_flag_aix='$wl-bM:SRE'
+	  shared_flag_svr4='$wl-G'
+	fi
+      fi
+
+      export_dynamic_flag_spec='$wl-bexpall'
+      # It seems that -bexpall does not export symbols beginning with
+      # underscore (_), so it is better to generate a list of symbols to export.
+      always_export_symbols=yes
+      if test aix,yes = "$with_aix_soname,$aix_use_runtimelinking"; then
+	# Warning - without using the other runtime loading flags (-brtl),
+	# -berok will link without error, but may produce a broken library.
+	allow_undefined_flag='-berok'
+        # Determine the default libpath from the value encoded in an
+        # empty executable.
+        if test set = "${lt_cv_aix_libpath+set}"; then
+  aix_libpath=$lt_cv_aix_libpath
+else
+  if ${lt_cv_aix_libpath_+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+
+  lt_aix_libpath_sed='
+      /Import File Strings/,/^$/ {
+	  /^0/ {
+	      s/^0  *\([^ ]*\) *$/\1/
+	      p
+	  }
+      }'
+  lt_cv_aix_libpath_=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+  # Check for a 64-bit object if we didn't find anything.
+  if test -z "$lt_cv_aix_libpath_"; then
+    lt_cv_aix_libpath_=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+  fi
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+  if test -z "$lt_cv_aix_libpath_"; then
+    lt_cv_aix_libpath_=/usr/lib:/lib
+  fi
+
+fi
+
+  aix_libpath=$lt_cv_aix_libpath_
+fi
+
+        hardcode_libdir_flag_spec='$wl-blibpath:$libdir:'"$aix_libpath"
+        archive_expsym_cmds='$CC -o $output_objdir/$soname $libobjs $deplibs $wl'$no_entry_flag' $compiler_flags `if test -n "$allow_undefined_flag"; then func_echo_all "$wl$allow_undefined_flag"; else :; fi` $wl'$exp_sym_flag:\$export_symbols' '$shared_flag
+      else
+	if test ia64 = "$host_cpu"; then
+	  hardcode_libdir_flag_spec='$wl-R $libdir:/usr/lib:/lib'
+	  allow_undefined_flag="-z nodefs"
+	  archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\$wl$no_entry_flag"' $compiler_flags $wl$allow_undefined_flag '"\$wl$exp_sym_flag:\$export_symbols"
+	else
+	 # Determine the default libpath from the value encoded in an
+	 # empty executable.
+	 if test set = "${lt_cv_aix_libpath+set}"; then
+  aix_libpath=$lt_cv_aix_libpath
+else
+  if ${lt_cv_aix_libpath_+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+
+  lt_aix_libpath_sed='
+      /Import File Strings/,/^$/ {
+	  /^0/ {
+	      s/^0  *\([^ ]*\) *$/\1/
+	      p
+	  }
+      }'
+  lt_cv_aix_libpath_=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+  # Check for a 64-bit object if we didn't find anything.
+  if test -z "$lt_cv_aix_libpath_"; then
+    lt_cv_aix_libpath_=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+  fi
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+  if test -z "$lt_cv_aix_libpath_"; then
+    lt_cv_aix_libpath_=/usr/lib:/lib
+  fi
+
+fi
+
+  aix_libpath=$lt_cv_aix_libpath_
+fi
+
+	 hardcode_libdir_flag_spec='$wl-blibpath:$libdir:'"$aix_libpath"
+	  # Warning - without using the other run time loading flags,
+	  # -berok will link without error, but may produce a broken library.
+	  no_undefined_flag=' $wl-bernotok'
+	  allow_undefined_flag=' $wl-berok'
+	  if test yes = "$with_gnu_ld"; then
+	    # We only use this code for GNU lds that support --whole-archive.
+	    whole_archive_flag_spec='$wl--whole-archive$convenience $wl--no-whole-archive'
+	  else
+	    # Exported symbols can be pulled into shared objects from archives
+	    whole_archive_flag_spec='$convenience'
+	  fi
+	  archive_cmds_need_lc=yes
+	  archive_expsym_cmds='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d'
+	  # -brtl affects multiple linker settings, -berok does not and is overridden later
+	  compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\\([, ]\\)%-berok\\1%g"`'
+	  if test svr4 != "$with_aix_soname"; then
+	    # This is similar to how AIX traditionally builds its shared libraries.
+	    archive_expsym_cmds="$archive_expsym_cmds"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname'
+	  fi
+	  if test aix != "$with_aix_soname"; then
+	    archive_expsym_cmds="$archive_expsym_cmds"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp'
+	  else
+	    # used by -dlpreopen to get the symbols
+	    archive_expsym_cmds="$archive_expsym_cmds"'~$MV  $output_objdir/$realname.d/$soname $output_objdir'
+	  fi
+	  archive_expsym_cmds="$archive_expsym_cmds"'~$RM -r $output_objdir/$realname.d'
+	fi
+      fi
+      ;;
+
+    amigaos*)
+      case $host_cpu in
+      powerpc)
+            # see comment about AmigaOS4 .so support
+            archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+            archive_expsym_cmds=''
+        ;;
+      m68k)
+            archive_cmds='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
+            hardcode_libdir_flag_spec='-L$libdir'
+            hardcode_minus_L=yes
+        ;;
+      esac
+      ;;
+
+    bsdi[45]*)
+      export_dynamic_flag_spec=-rdynamic
+      ;;
+
+    cygwin* | mingw* | pw32* | cegcc*)
+      # When not using gcc, we currently assume that we are using
+      # Microsoft Visual C++.
+      # hardcode_libdir_flag_spec is actually meaningless, as there is
+      # no search path for DLLs.
+      case $cc_basename in
+      cl*)
+	# Native MSVC
+	hardcode_libdir_flag_spec=' '
+	allow_undefined_flag=unsupported
+	always_export_symbols=yes
+	file_list_spec='@'
+	# Tell ltmain to make .lib files, not .a files.
+	libext=lib
+	# Tell ltmain to make .dll files, not .so files.
+	shrext_cmds=.dll
+	# FIXME: Setting linknames here is a bad hack.
+	archive_cmds='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames='
+	archive_expsym_cmds='if   test DEF = "`$SED -n     -e '\''s/^[	 ]*//'\''     -e '\''/^\(;.*\)*$/d'\''     -e '\''s/^\(EXPORTS\|LIBRARY\)\([	 ].*\)*$/DEF/p'\''     -e q     $export_symbols`" ; then
+            cp "$export_symbols" "$output_objdir/$soname.def";
+            echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp";
+          else
+            $SED -e '\''s/^/-link -EXPORT:/'\'' < $export_symbols > $output_objdir/$soname.exp;
+          fi~
+          $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
+          linknames='
+	# The linker will not automatically build a static lib if we build a DLL.
+	# _LT_TAGVAR(old_archive_from_new_cmds, )='true'
+	enable_shared_with_static_runtimes=yes
+	exclude_expsyms='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*'
+	export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1,DATA/'\'' | $SED -e '\''/^[AITW][ ]/s/.*[ ]//'\'' | sort | uniq > $export_symbols'
+	# Don't use ranlib
+	old_postinstall_cmds='chmod 644 $oldlib'
+	postlink_cmds='lt_outputfile="@OUTPUT@"~
+          lt_tool_outputfile="@TOOL_OUTPUT@"~
+          case $lt_outputfile in
+            *.exe|*.EXE) ;;
+            *)
+              lt_outputfile=$lt_outputfile.exe
+              lt_tool_outputfile=$lt_tool_outputfile.exe
+              ;;
+          esac~
+          if test : != "$MANIFEST_TOOL" && test -f "$lt_outputfile.manifest"; then
+            $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;
+            $RM "$lt_outputfile.manifest";
+          fi'
+	;;
+      *)
+	# Assume MSVC wrapper
+	hardcode_libdir_flag_spec=' '
+	allow_undefined_flag=unsupported
+	# Tell ltmain to make .lib files, not .a files.
+	libext=lib
+	# Tell ltmain to make .dll files, not .so files.
+	shrext_cmds=.dll
+	# FIXME: Setting linknames here is a bad hack.
+	archive_cmds='$CC -o $lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames='
+	# The linker will automatically build a .lib file if we build a DLL.
+	old_archive_from_new_cmds='true'
+	# FIXME: Should let the user specify the lib program.
+	old_archive_cmds='lib -OUT:$oldlib$oldobjs$old_deplibs'
+	enable_shared_with_static_runtimes=yes
+	;;
+      esac
+      ;;
+
+    darwin* | rhapsody*)
+
+
+  archive_cmds_need_lc=no
+  hardcode_direct=no
+  hardcode_automatic=yes
+  hardcode_shlibpath_var=unsupported
+  if test yes = "$lt_cv_ld_force_load"; then
+    whole_archive_flag_spec='`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience $wl-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`'
+
+  else
+    whole_archive_flag_spec=''
+  fi
+  link_all_deplibs=yes
+  allow_undefined_flag=$_lt_dar_allow_undefined
+  case $cc_basename in
+     ifort*|nagfor*) _lt_dar_can_shared=yes ;;
+     *) _lt_dar_can_shared=$GCC ;;
+  esac
+  if test yes = "$_lt_dar_can_shared"; then
+    output_verbose_link_cmd=func_echo_all
+    archive_cmds="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dsymutil"
+    module_cmds="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dsymutil"
+    archive_expsym_cmds="sed 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dar_export_syms$_lt_dsymutil"
+    module_expsym_cmds="sed -e 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dar_export_syms$_lt_dsymutil"
+
+  else
+  ld_shlibs=no
+  fi
+
+      ;;
+
+    dgux*)
+      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_shlibpath_var=no
+      ;;
+
+    # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor
+    # support.  Future versions do this automatically, but an explicit c++rt0.o
+    # does not break anything, and helps significantly (at the cost of a little
+    # extra space).
+    freebsd2.2*)
+      archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o'
+      hardcode_libdir_flag_spec='-R$libdir'
+      hardcode_direct=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    # Unfortunately, older versions of FreeBSD 2 do not have this feature.
+    freebsd2.*)
+      archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_direct=yes
+      hardcode_minus_L=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    # FreeBSD 3 and greater uses gcc -shared to do shared libraries.
+    freebsd* | dragonfly*)
+      archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+      hardcode_libdir_flag_spec='-R$libdir'
+      hardcode_direct=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    hpux9*)
+      if test yes = "$GCC"; then
+	archive_cmds='$RM $output_objdir/$soname~$CC -shared $pic_flag $wl+b $wl$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
+      else
+	archive_cmds='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
+      fi
+      hardcode_libdir_flag_spec='$wl+b $wl$libdir'
+      hardcode_libdir_separator=:
+      hardcode_direct=yes
+
+      # hardcode_minus_L: Not really in the search PATH,
+      # but as the default location of the library.
+      hardcode_minus_L=yes
+      export_dynamic_flag_spec='$wl-E'
+      ;;
+
+    hpux10*)
+      if test yes,no = "$GCC,$with_gnu_ld"; then
+	archive_cmds='$CC -shared $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
+      fi
+      if test no = "$with_gnu_ld"; then
+	hardcode_libdir_flag_spec='$wl+b $wl$libdir'
+	hardcode_libdir_separator=:
+	hardcode_direct=yes
+	hardcode_direct_absolute=yes
+	export_dynamic_flag_spec='$wl-E'
+	# hardcode_minus_L: Not really in the search PATH,
+	# but as the default location of the library.
+	hardcode_minus_L=yes
+      fi
+      ;;
+
+    hpux11*)
+      if test yes,no = "$GCC,$with_gnu_ld"; then
+	case $host_cpu in
+	hppa*64*)
+	  archive_cmds='$CC -shared $wl+h $wl$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	ia64*)
+	  archive_cmds='$CC -shared $pic_flag $wl+h $wl$soname $wl+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	*)
+	  archive_cmds='$CC -shared $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	esac
+      else
+	case $host_cpu in
+	hppa*64*)
+	  archive_cmds='$CC -b $wl+h $wl$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	ia64*)
+	  archive_cmds='$CC -b $wl+h $wl$soname $wl+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	*)
+
+	  # Older versions of the 11.00 compiler do not understand -b yet
+	  # (HP92453-01 A.11.01.20 doesn't, HP92453-01 B.11.X.35175-35176.GP does)
+	  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC understands -b" >&5
+$as_echo_n "checking if $CC understands -b... " >&6; }
+if ${lt_cv_prog_compiler__b+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_prog_compiler__b=no
+   save_LDFLAGS=$LDFLAGS
+   LDFLAGS="$LDFLAGS -b"
+   echo "$lt_simple_link_test_code" > conftest.$ac_ext
+   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
+     # The linker can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     if test -s conftest.err; then
+       # Append any errors to the config.log.
+       cat conftest.err 1>&5
+       $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp
+       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+       if diff conftest.exp conftest.er2 >/dev/null; then
+         lt_cv_prog_compiler__b=yes
+       fi
+     else
+       lt_cv_prog_compiler__b=yes
+     fi
+   fi
+   $RM -r conftest*
+   LDFLAGS=$save_LDFLAGS
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler__b" >&5
+$as_echo "$lt_cv_prog_compiler__b" >&6; }
+
+if test yes = "$lt_cv_prog_compiler__b"; then
+    archive_cmds='$CC -b $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+else
+    archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
+fi
+
+	  ;;
+	esac
+      fi
+      if test no = "$with_gnu_ld"; then
+	hardcode_libdir_flag_spec='$wl+b $wl$libdir'
+	hardcode_libdir_separator=:
+
+	case $host_cpu in
+	hppa*64*|ia64*)
+	  hardcode_direct=no
+	  hardcode_shlibpath_var=no
+	  ;;
+	*)
+	  hardcode_direct=yes
+	  hardcode_direct_absolute=yes
+	  export_dynamic_flag_spec='$wl-E'
+
+	  # hardcode_minus_L: Not really in the search PATH,
+	  # but as the default location of the library.
+	  hardcode_minus_L=yes
+	  ;;
+	esac
+      fi
+      ;;
+
+    irix5* | irix6* | nonstopux*)
+      if test yes = "$GCC"; then
+	archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
+	# Try to use the -exported_symbol ld option, if it does not
+	# work, assume that -exports_file does not work either and
+	# implicitly export all symbols.
+	# This should be the same for all languages, so no per-tag cache variable.
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $host_os linker accepts -exported_symbol" >&5
+$as_echo_n "checking whether the $host_os linker accepts -exported_symbol... " >&6; }
+if ${lt_cv_irix_exported_symbol+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  save_LDFLAGS=$LDFLAGS
+	   LDFLAGS="$LDFLAGS -shared $wl-exported_symbol ${wl}foo $wl-update_registry $wl/dev/null"
+	   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+int foo (void) { return 0; }
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  lt_cv_irix_exported_symbol=yes
+else
+  lt_cv_irix_exported_symbol=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+           LDFLAGS=$save_LDFLAGS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_irix_exported_symbol" >&5
+$as_echo "$lt_cv_irix_exported_symbol" >&6; }
+	if test yes = "$lt_cv_irix_exported_symbol"; then
+          archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations $wl-exports_file $wl$export_symbols -o $lib'
+	fi
+      else
+	archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
+	archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -exports_file $export_symbols -o $lib'
+      fi
+      archive_cmds_need_lc='no'
+      hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
+      hardcode_libdir_separator=:
+      inherit_rpath=yes
+      link_all_deplibs=yes
+      ;;
+
+    linux*)
+      case $cc_basename in
+      tcc*)
+	# Fabrice Bellard et al's Tiny C Compiler
+	ld_shlibs=yes
+	archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	;;
+      esac
+      ;;
+
+    netbsd*)
+      if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+	archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out
+      else
+	archive_cmds='$LD -shared -o $lib $libobjs $deplibs $linker_flags'      # ELF
+      fi
+      hardcode_libdir_flag_spec='-R$libdir'
+      hardcode_direct=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    newsos6)
+      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_direct=yes
+      hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
+      hardcode_libdir_separator=:
+      hardcode_shlibpath_var=no
+      ;;
+
+    *nto* | *qnx*)
+      ;;
+
+    openbsd* | bitrig*)
+      if test -f /usr/libexec/ld.so; then
+	hardcode_direct=yes
+	hardcode_shlibpath_var=no
+	hardcode_direct_absolute=yes
+	if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then
+	  archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	  archive_expsym_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags $wl-retain-symbols-file,$export_symbols'
+	  hardcode_libdir_flag_spec='$wl-rpath,$libdir'
+	  export_dynamic_flag_spec='$wl-E'
+	else
+	  archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	  hardcode_libdir_flag_spec='$wl-rpath,$libdir'
+	fi
+      else
+	ld_shlibs=no
+      fi
+      ;;
+
+    os2*)
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_minus_L=yes
+      allow_undefined_flag=unsupported
+      shrext_cmds=.dll
+      archive_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      archive_expsym_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	prefix_cmds="$SED"~
+	if test EXPORTS = "`$SED 1q $export_symbols`"; then
+	  prefix_cmds="$prefix_cmds -e 1d";
+	fi~
+	prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~
+	cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      old_archive_From_new_cmds='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
+      enable_shared_with_static_runtimes=yes
+      ;;
+
+    osf3*)
+      if test yes = "$GCC"; then
+	allow_undefined_flag=' $wl-expect_unresolved $wl\*'
+	archive_cmds='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
+      else
+	allow_undefined_flag=' -expect_unresolved \*'
+	archive_cmds='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
+      fi
+      archive_cmds_need_lc='no'
+      hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
+      hardcode_libdir_separator=:
+      ;;
+
+    osf4* | osf5*)	# as osf3* with the addition of -msym flag
+      if test yes = "$GCC"; then
+	allow_undefined_flag=' $wl-expect_unresolved $wl\*'
+	archive_cmds='$CC -shared$allow_undefined_flag $pic_flag $libobjs $deplibs $compiler_flags $wl-msym $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
+	hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
+      else
+	allow_undefined_flag=' -expect_unresolved \*'
+	archive_cmds='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
+	archive_expsym_cmds='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~
+          $CC -shared$allow_undefined_flag $wl-input $wl$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib~$RM $lib.exp'
+
+	# Both c and cxx compiler support -rpath directly
+	hardcode_libdir_flag_spec='-rpath $libdir'
+      fi
+      archive_cmds_need_lc='no'
+      hardcode_libdir_separator=:
+      ;;
+
+    solaris*)
+      no_undefined_flag=' -z defs'
+      if test yes = "$GCC"; then
+	wlarc='$wl'
+	archive_cmds='$CC -shared $pic_flag $wl-z ${wl}text $wl-h $wl$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+          $CC -shared $pic_flag $wl-z ${wl}text $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
+      else
+	case `$CC -V 2>&1` in
+	*"Compilers 5.0"*)
+	  wlarc=''
+	  archive_cmds='$LD -G$allow_undefined_flag -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	  archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+            $LD -G$allow_undefined_flag -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp'
+	  ;;
+	*)
+	  wlarc='$wl'
+	  archive_cmds='$CC -G$allow_undefined_flag -h $soname -o $lib $libobjs $deplibs $compiler_flags'
+	  archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+            $CC -G$allow_undefined_flag -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
+	  ;;
+	esac
+      fi
+      hardcode_libdir_flag_spec='-R$libdir'
+      hardcode_shlibpath_var=no
+      case $host_os in
+      solaris2.[0-5] | solaris2.[0-5].*) ;;
+      *)
+	# The compiler driver will combine and reorder linker options,
+	# but understands '-z linker_flag'.  GCC discards it without '$wl',
+	# but is careful enough not to reorder.
+	# Supported since Solaris 2.6 (maybe 2.5.1?)
+	if test yes = "$GCC"; then
+	  whole_archive_flag_spec='$wl-z ${wl}allextract$convenience $wl-z ${wl}defaultextract'
+	else
+	  whole_archive_flag_spec='-z allextract$convenience -z defaultextract'
+	fi
+	;;
+      esac
+      link_all_deplibs=yes
+      ;;
+
+    sunos4*)
+      if test sequent = "$host_vendor"; then
+	# Use $CC to link under sequent, because it throws in some extra .o
+	# files that make .init and .fini sections work.
+	archive_cmds='$CC -G $wl-h $soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	archive_cmds='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'
+      fi
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_direct=yes
+      hardcode_minus_L=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    sysv4)
+      case $host_vendor in
+	sni)
+	  archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	  hardcode_direct=yes # is this really true???
+	;;
+	siemens)
+	  ## LD is ld it makes a PLAMLIB
+	  ## CC just makes a GrossModule.
+	  archive_cmds='$LD -G -o $lib $libobjs $deplibs $linker_flags'
+	  reload_cmds='$CC -r -o $output$reload_objs'
+	  hardcode_direct=no
+        ;;
+	motorola)
+	  archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	  hardcode_direct=no #Motorola manual says yes, but my tests say they lie
+	;;
+      esac
+      runpath_var='LD_RUN_PATH'
+      hardcode_shlibpath_var=no
+      ;;
+
+    sysv4.3*)
+      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_shlibpath_var=no
+      export_dynamic_flag_spec='-Bexport'
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	hardcode_shlibpath_var=no
+	runpath_var=LD_RUN_PATH
+	hardcode_runpath_var=yes
+	ld_shlibs=yes
+      fi
+      ;;
+
+    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*)
+      no_undefined_flag='$wl-z,text'
+      archive_cmds_need_lc=no
+      hardcode_shlibpath_var=no
+      runpath_var='LD_RUN_PATH'
+
+      if test yes = "$GCC"; then
+	archive_cmds='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	archive_cmds='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      fi
+      ;;
+
+    sysv5* | sco3.2v5* | sco5v6*)
+      # Note: We CANNOT use -z defs as we might desire, because we do not
+      # link with -lc, and that would cause any symbols used from libc to
+      # always be unresolved, which means just about no library would
+      # ever link correctly.  If we're not using GNU ld we use -z text
+      # though, which does catch some bad symbols but isn't as heavy-handed
+      # as -z defs.
+      no_undefined_flag='$wl-z,text'
+      allow_undefined_flag='$wl-z,nodefs'
+      archive_cmds_need_lc=no
+      hardcode_shlibpath_var=no
+      hardcode_libdir_flag_spec='$wl-R,$libdir'
+      hardcode_libdir_separator=':'
+      link_all_deplibs=yes
+      export_dynamic_flag_spec='$wl-Bexport'
+      runpath_var='LD_RUN_PATH'
+
+      if test yes = "$GCC"; then
+	archive_cmds='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	archive_cmds='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      fi
+      ;;
+
+    uts4*)
+      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_shlibpath_var=no
+      ;;
+
+    *)
+      ld_shlibs=no
+      ;;
+    esac
+
+    if test sni = "$host_vendor"; then
+      case $host in
+      sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
+	export_dynamic_flag_spec='$wl-Blargedynsym'
+	;;
+      esac
+    fi
+  fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs" >&5
+$as_echo "$ld_shlibs" >&6; }
+test no = "$ld_shlibs" && can_build_shared=no
+
+with_gnu_ld=$with_gnu_ld
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#
+# Do we need to explicitly link libc?
+#
+case "x$archive_cmds_need_lc" in
+x|xyes)
+  # Assume -lc should be added
+  archive_cmds_need_lc=yes
+
+  if test yes,yes = "$GCC,$enable_shared"; then
+    case $archive_cmds in
+    *'~'*)
+      # FIXME: we may have to deal with multi-command sequences.
+      ;;
+    '$CC '*)
+      # Test whether the compiler implicitly links with -lc since on some
+      # systems, -lgcc has to come before -lc. If gcc already passes -lc
+      # to ld, don't add -lc before -lgcc.
+      { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5
+$as_echo_n "checking whether -lc should be explicitly linked in... " >&6; }
+if ${lt_cv_archive_cmds_need_lc+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  $RM conftest*
+	echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+	if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } 2>conftest.err; then
+	  soname=conftest
+	  lib=conftest
+	  libobjs=conftest.$ac_objext
+	  deplibs=
+	  wl=$lt_prog_compiler_wl
+	  pic_flag=$lt_prog_compiler_pic
+	  compiler_flags=-v
+	  linker_flags=-v
+	  verstring=
+	  output_objdir=.
+	  libname=conftest
+	  lt_save_allow_undefined_flag=$allow_undefined_flag
+	  allow_undefined_flag=
+	  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1\""; } >&5
+  (eval $archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+	  then
+	    lt_cv_archive_cmds_need_lc=no
+	  else
+	    lt_cv_archive_cmds_need_lc=yes
+	  fi
+	  allow_undefined_flag=$lt_save_allow_undefined_flag
+	else
+	  cat conftest.err 1>&5
+	fi
+	$RM conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc" >&5
+$as_echo "$lt_cv_archive_cmds_need_lc" >&6; }
+      archive_cmds_need_lc=$lt_cv_archive_cmds_need_lc
+      ;;
+    esac
+  fi
+  ;;
+esac
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5
+$as_echo_n "checking dynamic linker characteristics... " >&6; }
+
+if test yes = "$GCC"; then
+  case $host_os in
+    darwin*) lt_awk_arg='/^libraries:/,/LR/' ;;
+    *) lt_awk_arg='/^libraries:/' ;;
+  esac
+  case $host_os in
+    mingw* | cegcc*) lt_sed_strip_eq='s|=\([A-Za-z]:\)|\1|g' ;;
+    *) lt_sed_strip_eq='s|=/|/|g' ;;
+  esac
+  lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e $lt_sed_strip_eq`
+  case $lt_search_path_spec in
+  *\;*)
+    # if the path contains ";" then we assume it to be the separator
+    # otherwise default to the standard path separator (i.e. ":") - it is
+    # assumed that no part of a normal pathname contains ";" but that should
+    # okay in the real world where ";" in dirpaths is itself problematic.
+    lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED 's/;/ /g'`
+    ;;
+  *)
+    lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED "s/$PATH_SEPARATOR/ /g"`
+    ;;
+  esac
+  # Ok, now we have the path, separated by spaces, we can step through it
+  # and add multilib dir if necessary...
+  lt_tmp_lt_search_path_spec=
+  lt_multi_os_dir=/`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null`
+  # ...but if some path component already ends with the multilib dir we assume
+  # that all is fine and trust -print-search-dirs as is (GCC 4.2? or newer).
+  case "$lt_multi_os_dir; $lt_search_path_spec " in
+  "/; "* | "/.; "* | "/./; "* | *"$lt_multi_os_dir "* | *"$lt_multi_os_dir/ "*)
+    lt_multi_os_dir=
+    ;;
+  esac
+  for lt_sys_path in $lt_search_path_spec; do
+    if test -d "$lt_sys_path$lt_multi_os_dir"; then
+      lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path$lt_multi_os_dir"
+    elif test -n "$lt_multi_os_dir"; then
+      test -d "$lt_sys_path" && \
+	lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path"
+    fi
+  done
+  lt_search_path_spec=`$ECHO "$lt_tmp_lt_search_path_spec" | awk '
+BEGIN {RS = " "; FS = "/|\n";} {
+  lt_foo = "";
+  lt_count = 0;
+  for (lt_i = NF; lt_i > 0; lt_i--) {
+    if ($lt_i != "" && $lt_i != ".") {
+      if ($lt_i == "..") {
+        lt_count++;
+      } else {
+        if (lt_count == 0) {
+          lt_foo = "/" $lt_i lt_foo;
+        } else {
+          lt_count--;
+        }
+      }
+    }
+  }
+  if (lt_foo != "") { lt_freq[lt_foo]++; }
+  if (lt_freq[lt_foo] == 1) { print lt_foo; }
+}'`
+  # AWK program above erroneously prepends '/' to C:/dos/paths
+  # for these hosts.
+  case $host_os in
+    mingw* | cegcc*) lt_search_path_spec=`$ECHO "$lt_search_path_spec" |\
+      $SED 's|/\([A-Za-z]:\)|\1|g'` ;;
+  esac
+  sys_lib_search_path_spec=`$ECHO "$lt_search_path_spec" | $lt_NL2SP`
+else
+  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
+fi
+library_names_spec=
+libname_spec='lib$name'
+soname_spec=
+shrext_cmds=.so
+postinstall_cmds=
+postuninstall_cmds=
+finish_cmds=
+finish_eval=
+shlibpath_var=
+shlibpath_overrides_runpath=unknown
+version_type=none
+dynamic_linker="$host_os ld.so"
+sys_lib_dlsearch_path_spec="/lib /usr/lib"
+need_lib_prefix=unknown
+hardcode_into_libs=no
+
+# when you set need_version to no, make sure it does not cause -set_version
+# flags to be left without arguments
+need_version=unknown
+
+
+
+case $host_os in
+aix3*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  library_names_spec='$libname$release$shared_ext$versuffix $libname.a'
+  shlibpath_var=LIBPATH
+
+  # AIX 3 has no versioning support, so we append a major version to the name.
+  soname_spec='$libname$release$shared_ext$major'
+  ;;
+
+aix[4-9]*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  hardcode_into_libs=yes
+  if test ia64 = "$host_cpu"; then
+    # AIX 5 supports IA64
+    library_names_spec='$libname$release$shared_ext$major $libname$release$shared_ext$versuffix $libname$shared_ext'
+    shlibpath_var=LD_LIBRARY_PATH
+  else
+    # With GCC up to 2.95.x, collect2 would create an import file
+    # for dependence libraries.  The import file would start with
+    # the line '#! .'.  This would cause the generated library to
+    # depend on '.', always an invalid library.  This was fixed in
+    # development snapshots of GCC prior to 3.0.
+    case $host_os in
+      aix4 | aix4.[01] | aix4.[01].*)
+      if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
+	   echo ' yes '
+	   echo '#endif'; } | $CC -E - | $GREP yes > /dev/null; then
+	:
+      else
+	can_build_shared=no
+      fi
+      ;;
+    esac
+    # Using Import Files as archive members, it is possible to support
+    # filename-based versioning of shared library archives on AIX. While
+    # this would work for both with and without runtime linking, it will
+    # prevent static linking of such archives. So we do filename-based
+    # shared library versioning with .so extension only, which is used
+    # when both runtime linking and shared linking is enabled.
+    # Unfortunately, runtime linking may impact performance, so we do
+    # not want this to be the default eventually. Also, we use the
+    # versioned .so libs for executables only if there is the -brtl
+    # linker flag in LDFLAGS as well, or --with-aix-soname=svr4 only.
+    # To allow for filename-based versioning support, we need to create
+    # libNAME.so.V as an archive file, containing:
+    # *) an Import File, referring to the versioned filename of the
+    #    archive as well as the shared archive member, telling the
+    #    bitwidth (32 or 64) of that shared object, and providing the
+    #    list of exported symbols of that shared object, eventually
+    #    decorated with the 'weak' keyword
+    # *) the shared object with the F_LOADONLY flag set, to really avoid
+    #    it being seen by the linker.
+    # At run time we better use the real file rather than another symlink,
+    # but for link time we create the symlink libNAME.so -> libNAME.so.V
+
+    case $with_aix_soname,$aix_use_runtimelinking in
+    # AIX (on Power*) has no versioning support, so currently we cannot hardcode correct
+    # soname into executable. Probably we can add versioning support to
+    # collect2, so additional links can be useful in future.
+    aix,yes) # traditional libtool
+      dynamic_linker='AIX unversionable lib.so'
+      # If using run time linking (on AIX 4.2 or later) use lib<name>.so
+      # instead of lib<name>.a to let people know that these are not
+      # typical AIX shared libraries.
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+      ;;
+    aix,no) # traditional AIX only
+      dynamic_linker='AIX lib.a(lib.so.V)'
+      # We preserve .a as extension for shared libraries through AIX4.2
+      # and later when we are not doing run time linking.
+      library_names_spec='$libname$release.a $libname.a'
+      soname_spec='$libname$release$shared_ext$major'
+      ;;
+    svr4,*) # full svr4 only
+      dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o)"
+      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
+      # We do not specify a path in Import Files, so LIBPATH fires.
+      shlibpath_overrides_runpath=yes
+      ;;
+    *,yes) # both, prefer svr4
+      dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o), lib.a(lib.so.V)"
+      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
+      # unpreferred sharedlib libNAME.a needs extra handling
+      postinstall_cmds='test -n "$linkname" || linkname="$realname"~func_stripname "" ".so" "$linkname"~$install_shared_prog "$dir/$func_stripname_result.$libext" "$destdir/$func_stripname_result.$libext"~test -z "$tstripme" || test -z "$striplib" || $striplib "$destdir/$func_stripname_result.$libext"'
+      postuninstall_cmds='for n in $library_names $old_library; do :; done~func_stripname "" ".so" "$n"~test "$func_stripname_result" = "$n" || func_append rmfiles " $odir/$func_stripname_result.$libext"'
+      # We do not specify a path in Import Files, so LIBPATH fires.
+      shlibpath_overrides_runpath=yes
+      ;;
+    *,no) # both, prefer aix
+      dynamic_linker="AIX lib.a(lib.so.V), lib.so.V($shared_archive_member_spec.o)"
+      library_names_spec='$libname$release.a $libname.a'
+      soname_spec='$libname$release$shared_ext$major'
+      # unpreferred sharedlib libNAME.so.V and symlink libNAME.so need extra handling
+      postinstall_cmds='test -z "$dlname" || $install_shared_prog $dir/$dlname $destdir/$dlname~test -z "$tstripme" || test -z "$striplib" || $striplib $destdir/$dlname~test -n "$linkname" || linkname=$realname~func_stripname "" ".a" "$linkname"~(cd "$destdir" && $LN_S -f $dlname $func_stripname_result.so)'
+      postuninstall_cmds='test -z "$dlname" || func_append rmfiles " $odir/$dlname"~for n in $old_library $library_names; do :; done~func_stripname "" ".a" "$n"~func_append rmfiles " $odir/$func_stripname_result.so"'
+      ;;
+    esac
+    shlibpath_var=LIBPATH
+  fi
+  ;;
+
+amigaos*)
+  case $host_cpu in
+  powerpc)
+    # Since July 2007 AmigaOS4 officially supports .so libraries.
+    # When compiling the executable, add -use-dynld -Lsobjs: to the compileline.
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    ;;
+  m68k)
+    library_names_spec='$libname.ixlibrary $libname.a'
+    # Create ${libname}_ixlibrary.a entries in /sys/libs.
+    finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
+    ;;
+  esac
+  ;;
+
+beos*)
+  library_names_spec='$libname$shared_ext'
+  dynamic_linker="$host_os ld.so"
+  shlibpath_var=LIBRARY_PATH
+  ;;
+
+bsdi[45]*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
+  sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"
+  # the default ld.so.conf also contains /usr/contrib/lib and
+  # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow
+  # libtool to hard-code these into programs
+  ;;
+
+cygwin* | mingw* | pw32* | cegcc*)
+  version_type=windows
+  shrext_cmds=.dll
+  need_version=no
+  need_lib_prefix=no
+
+  case $GCC,$cc_basename in
+  yes,*)
+    # gcc
+    library_names_spec='$libname.dll.a'
+    # DLL is installed to $(libdir)/../bin by postinstall_cmds
+    postinstall_cmds='base_file=`basename \$file`~
+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~
+      dldir=$destdir/`dirname \$dlpath`~
+      test -d \$dldir || mkdir -p \$dldir~
+      $install_prog $dir/$dlname \$dldir/$dlname~
+      chmod a+x \$dldir/$dlname~
+      if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
+        eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
+      fi'
+    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
+      dlpath=$dir/\$dldll~
+       $RM \$dlpath'
+    shlibpath_overrides_runpath=yes
+
+    case $host_os in
+    cygwin*)
+      # Cygwin DLLs use 'cyg' prefix rather than 'lib'
+      soname_spec='`echo $libname | sed -e 's/^lib/cyg/'``echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
+
+      sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/lib/w32api"
+      ;;
+    mingw* | cegcc*)
+      # MinGW DLLs use traditional 'lib' prefix
+      soname_spec='$libname`echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
+      ;;
+    pw32*)
+      # pw32 DLLs use 'pw' prefix rather than 'lib'
+      library_names_spec='`echo $libname | sed -e 's/^lib/pw/'``echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
+      ;;
+    esac
+    dynamic_linker='Win32 ld.exe'
+    ;;
+
+  *,cl*)
+    # Native MSVC
+    libname_spec='$name'
+    soname_spec='$libname`echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
+    library_names_spec='$libname.dll.lib'
+
+    case $build_os in
+    mingw*)
+      sys_lib_search_path_spec=
+      lt_save_ifs=$IFS
+      IFS=';'
+      for lt_path in $LIB
+      do
+        IFS=$lt_save_ifs
+        # Let DOS variable expansion print the short 8.3 style file name.
+        lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"`
+        sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path"
+      done
+      IFS=$lt_save_ifs
+      # Convert to MSYS style.
+      sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([a-zA-Z]\\):| /\\1|g' -e 's|^ ||'`
+      ;;
+    cygwin*)
+      # Convert to unix form, then to dos form, then back to unix form
+      # but this time dos style (no spaces!) so that the unix form looks
+      # like /cygdrive/c/PROGRA~1:/cygdr...
+      sys_lib_search_path_spec=`cygpath --path --unix "$LIB"`
+      sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null`
+      sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
+      ;;
+    *)
+      sys_lib_search_path_spec=$LIB
+      if $ECHO "$sys_lib_search_path_spec" | $GREP ';[c-zC-Z]:/' >/dev/null; then
+        # It is most probably a Windows format PATH.
+        sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
+      else
+        sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
+      fi
+      # FIXME: find the short name or the path components, as spaces are
+      # common. (e.g. "Program Files" -> "PROGRA~1")
+      ;;
+    esac
+
+    # DLL is installed to $(libdir)/../bin by postinstall_cmds
+    postinstall_cmds='base_file=`basename \$file`~
+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~
+      dldir=$destdir/`dirname \$dlpath`~
+      test -d \$dldir || mkdir -p \$dldir~
+      $install_prog $dir/$dlname \$dldir/$dlname'
+    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
+      dlpath=$dir/\$dldll~
+       $RM \$dlpath'
+    shlibpath_overrides_runpath=yes
+    dynamic_linker='Win32 link.exe'
+    ;;
+
+  *)
+    # Assume MSVC wrapper
+    library_names_spec='$libname`echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext $libname.lib'
+    dynamic_linker='Win32 ld.exe'
+    ;;
+  esac
+  # FIXME: first we should search . and the directory the executable is in
+  shlibpath_var=PATH
+  ;;
+
+darwin* | rhapsody*)
+  dynamic_linker="$host_os dyld"
+  version_type=darwin
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$major$shared_ext $libname$shared_ext'
+  soname_spec='$libname$release$major$shared_ext'
+  shlibpath_overrides_runpath=yes
+  shlibpath_var=DYLD_LIBRARY_PATH
+  shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'
+
+  sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/local/lib"
+  sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'
+  ;;
+
+dgux*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+freebsd* | dragonfly*)
+  # DragonFly does not have aout.  When/if they implement a new
+  # versioning mechanism, adjust this.
+  if test -x /usr/bin/objformat; then
+    objformat=`/usr/bin/objformat`
+  else
+    case $host_os in
+    freebsd[23].*) objformat=aout ;;
+    *) objformat=elf ;;
+    esac
+  fi
+  version_type=freebsd-$objformat
+  case $version_type in
+    freebsd-elf*)
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+      soname_spec='$libname$release$shared_ext$major'
+      need_version=no
+      need_lib_prefix=no
+      ;;
+    freebsd-*)
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
+      need_version=yes
+      ;;
+  esac
+  shlibpath_var=LD_LIBRARY_PATH
+  case $host_os in
+  freebsd2.*)
+    shlibpath_overrides_runpath=yes
+    ;;
+  freebsd3.[01]* | freebsdelf3.[01]*)
+    shlibpath_overrides_runpath=yes
+    hardcode_into_libs=yes
+    ;;
+  freebsd3.[2-9]* | freebsdelf3.[2-9]* | \
+  freebsd4.[0-5] | freebsdelf4.[0-5] | freebsd4.1.1 | freebsdelf4.1.1)
+    shlibpath_overrides_runpath=no
+    hardcode_into_libs=yes
+    ;;
+  *) # from 4.6 on, and DragonFly
+    shlibpath_overrides_runpath=yes
+    hardcode_into_libs=yes
+    ;;
+  esac
+  ;;
+
+haiku*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  dynamic_linker="$host_os runtime_loader"
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib'
+  hardcode_into_libs=yes
+  ;;
+
+hpux9* | hpux10* | hpux11*)
+  # Give a soname corresponding to the major version so that dld.sl refuses to
+  # link against other versions.
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=no
+  case $host_cpu in
+  ia64*)
+    shrext_cmds='.so'
+    hardcode_into_libs=yes
+    dynamic_linker="$host_os dld.so"
+    shlibpath_var=LD_LIBRARY_PATH
+    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
+    if test 32 = "$HPUX_IA64_MODE"; then
+      sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
+      sys_lib_dlsearch_path_spec=/usr/lib/hpux32
+    else
+      sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
+      sys_lib_dlsearch_path_spec=/usr/lib/hpux64
+    fi
+    ;;
+  hppa*64*)
+    shrext_cmds='.sl'
+    hardcode_into_libs=yes
+    dynamic_linker="$host_os dld.sl"
+    shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
+    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
+    sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"
+    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+    ;;
+  *)
+    shrext_cmds='.sl'
+    dynamic_linker="$host_os dld.sl"
+    shlibpath_var=SHLIB_PATH
+    shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
+    ;;
+  esac
+  # HP-UX runs *really* slowly unless shared libraries are mode 555, ...
+  postinstall_cmds='chmod 555 $lib'
+  # or fails outright, so override atomically:
+  install_override_mode=555
+  ;;
+
+interix[3-9]*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  ;;
+
+irix5* | irix6* | nonstopux*)
+  case $host_os in
+    nonstopux*) version_type=nonstopux ;;
+    *)
+	if test yes = "$lt_cv_prog_gnu_ld"; then
+		version_type=linux # correct to gnu/linux during the next big refactor
+	else
+		version_type=irix
+	fi ;;
+  esac
+  need_lib_prefix=no
+  need_version=no
+  soname_spec='$libname$release$shared_ext$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$release$shared_ext $libname$shared_ext'
+  case $host_os in
+  irix5* | nonstopux*)
+    libsuff= shlibsuff=
+    ;;
+  *)
+    case $LD in # libtool.m4 will add one of these switches to LD
+    *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")
+      libsuff= shlibsuff= libmagic=32-bit;;
+    *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")
+      libsuff=32 shlibsuff=N32 libmagic=N32;;
+    *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")
+      libsuff=64 shlibsuff=64 libmagic=64-bit;;
+    *) libsuff= shlibsuff= libmagic=never-match;;
+    esac
+    ;;
+  esac
+  shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
+  shlibpath_overrides_runpath=no
+  sys_lib_search_path_spec="/usr/lib$libsuff /lib$libsuff /usr/local/lib$libsuff"
+  sys_lib_dlsearch_path_spec="/usr/lib$libsuff /lib$libsuff"
+  hardcode_into_libs=yes
+  ;;
+
+# No shared lib support for Linux oldld, aout, or coff.
+linux*oldld* | linux*aout* | linux*coff*)
+  dynamic_linker=no
+  ;;
+
+linux*android*)
+  version_type=none # Android doesn't support versioned libraries.
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext'
+  soname_spec='$libname$release$shared_ext'
+  finish_cmds=
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+
+  # This implies no fast_install, which is unacceptable.
+  # Some rework will be needed to allow for fast_install
+  # before this can be enabled.
+  hardcode_into_libs=yes
+
+  dynamic_linker='Android linker'
+  # Don't embed -rpath directories since the linker doesn't support them.
+  hardcode_libdir_flag_spec='-L$libdir'
+  ;;
+
+# This must be glibc/ELF.
+linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+
+  # Some binutils ld are patched to set DT_RUNPATH
+  if ${lt_cv_shlibpath_overrides_runpath+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_shlibpath_overrides_runpath=no
+    save_LDFLAGS=$LDFLAGS
+    save_libdir=$libdir
+    eval "libdir=/foo; wl=\"$lt_prog_compiler_wl\"; \
+	 LDFLAGS=\"\$LDFLAGS $hardcode_libdir_flag_spec\""
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  if  ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null; then :
+  lt_cv_shlibpath_overrides_runpath=yes
+fi
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+    LDFLAGS=$save_LDFLAGS
+    libdir=$save_libdir
+
+fi
+
+  shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath
+
+  # This implies no fast_install, which is unacceptable.
+  # Some rework will be needed to allow for fast_install
+  # before this can be enabled.
+  hardcode_into_libs=yes
+
+  # Ideally, we could use ldconfig to report *all* directores which are
+  # searched for libraries, however this is still not possible.  Aside from not
+  # being certain /sbin/ldconfig is available, command
+  # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64,
+  # even though it is searched at run-time.  Try to do the best guess by
+  # appending ld.so.conf contents (and includes) to the search path.
+  if test -f /etc/ld.so.conf; then
+    lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[	 ]*hwcap[	 ]/d;s/[:,	]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '`
+    sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
+  fi
+
+  # We used to test for /lib/ld.so.1 and disable shared libraries on
+  # powerpc, because MkLinux only supported shared libraries with the
+  # GNU dynamic linker.  Since this was broken with cross compilers,
+  # most powerpc-linux boxes support dynamic linking these days and
+  # people can always --disable-shared, the test was removed, and we
+  # assume the GNU/Linux dynamic linker is in use.
+  dynamic_linker='GNU/Linux ld.so'
+  ;;
+
+netbsd*)
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=no
+  if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
+    finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+    dynamic_linker='NetBSD (a.out) ld.so'
+  else
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
+    dynamic_linker='NetBSD ld.elf_so'
+  fi
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  ;;
+
+newsos6)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  ;;
+
+*nto* | *qnx*)
+  version_type=qnx
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  dynamic_linker='ldqnx.so'
+  ;;
+
+openbsd* | bitrig*)
+  version_type=sunos
+  sys_lib_dlsearch_path_spec=/usr/lib
+  need_lib_prefix=no
+  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then
+    need_version=no
+  else
+    need_version=yes
+  fi
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  ;;
+
+os2*)
+  libname_spec='$name'
+  version_type=windows
+  shrext_cmds=.dll
+  need_version=no
+  need_lib_prefix=no
+  # OS/2 can only load a DLL with a base name of 8 characters or less.
+  soname_spec='`test -n "$os2dllname" && libname="$os2dllname";
+    v=$($ECHO $release$versuffix | tr -d .-);
+    n=$($ECHO $libname | cut -b -$((8 - ${#v})) | tr . _);
+    $ECHO $n$v`$shared_ext'
+  library_names_spec='${libname}_dll.$libext'
+  dynamic_linker='OS/2 ld.exe'
+  shlibpath_var=BEGINLIBPATH
+  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
+  sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+  postinstall_cmds='base_file=`basename \$file`~
+    dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; $ECHO \$dlname'\''`~
+    dldir=$destdir/`dirname \$dlpath`~
+    test -d \$dldir || mkdir -p \$dldir~
+    $install_prog $dir/$dlname \$dldir/$dlname~
+    chmod a+x \$dldir/$dlname~
+    if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
+      eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
+    fi'
+  postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; $ECHO \$dlname'\''`~
+    dlpath=$dir/\$dldll~
+    $RM \$dlpath'
+  ;;
+
+osf3* | osf4* | osf5*)
+  version_type=osf
+  need_lib_prefix=no
+  need_version=no
+  soname_spec='$libname$release$shared_ext$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  shlibpath_var=LD_LIBRARY_PATH
+  sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
+  sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+  ;;
+
+rdos*)
+  dynamic_linker=no
+  ;;
+
+solaris*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  # ldd complains unless libraries are executable
+  postinstall_cmds='chmod +x $lib'
+  ;;
+
+sunos4*)
+  version_type=sunos
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
+  finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  if test yes = "$with_gnu_ld"; then
+    need_lib_prefix=no
+  fi
+  need_version=yes
+  ;;
+
+sysv4 | sysv4.3*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  case $host_vendor in
+    sni)
+      shlibpath_overrides_runpath=no
+      need_lib_prefix=no
+      runpath_var=LD_RUN_PATH
+      ;;
+    siemens)
+      need_lib_prefix=no
+      ;;
+    motorola)
+      need_lib_prefix=no
+      need_version=no
+      shlibpath_overrides_runpath=no
+      sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'
+      ;;
+  esac
+  ;;
+
+sysv4*MP*)
+  if test -d /usr/nec; then
+    version_type=linux # correct to gnu/linux during the next big refactor
+    library_names_spec='$libname$shared_ext.$versuffix $libname$shared_ext.$major $libname$shared_ext'
+    soname_spec='$libname$shared_ext.$major'
+    shlibpath_var=LD_LIBRARY_PATH
+  fi
+  ;;
+
+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
+  version_type=sco
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  if test yes = "$with_gnu_ld"; then
+    sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'
+  else
+    sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'
+    case $host_os in
+      sco3.2v5*)
+        sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"
+	;;
+    esac
+  fi
+  sys_lib_dlsearch_path_spec='/usr/lib'
+  ;;
+
+tpf*)
+  # TPF is a cross-target only.  Preferred cross-host = GNU/Linux.
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  ;;
+
+uts4*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+*)
+  dynamic_linker=no
+  ;;
+esac
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5
+$as_echo "$dynamic_linker" >&6; }
+test no = "$dynamic_linker" && can_build_shared=no
+
+variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
+if test yes = "$GCC"; then
+  variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
+fi
+
+if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then
+  sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec
+fi
+
+if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then
+  sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec
+fi
+
+# remember unaugmented sys_lib_dlsearch_path content for libtool script decls...
+configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec
+
+# ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code
+func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH"
+
+# to be used as default LT_SYS_LIBRARY_PATH value in generated libtool
+configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5
+$as_echo_n "checking how to hardcode library paths into programs... " >&6; }
+hardcode_action=
+if test -n "$hardcode_libdir_flag_spec" ||
+   test -n "$runpath_var" ||
+   test yes = "$hardcode_automatic"; then
+
+  # We can hardcode non-existent directories.
+  if test no != "$hardcode_direct" &&
+     # If the only mechanism to avoid hardcoding is shlibpath_var, we
+     # have to relink, otherwise we might link with an installed library
+     # when we should be linking with a yet-to-be-installed one
+     ## test no != "$_LT_TAGVAR(hardcode_shlibpath_var, )" &&
+     test no != "$hardcode_minus_L"; then
+    # Linking always hardcodes the temporary library directory.
+    hardcode_action=relink
+  else
+    # We can link without hardcoding, and we can hardcode nonexisting dirs.
+    hardcode_action=immediate
+  fi
+else
+  # We cannot hardcode anything, or else we can only hardcode existing
+  # directories.
+  hardcode_action=unsupported
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $hardcode_action" >&5
+$as_echo "$hardcode_action" >&6; }
+
+if test relink = "$hardcode_action" ||
+   test yes = "$inherit_rpath"; then
+  # Fast installation is not supported
+  enable_fast_install=no
+elif test yes = "$shlibpath_overrides_runpath" ||
+     test no = "$enable_shared"; then
+  # Fast installation is not necessary
+  enable_fast_install=needless
+fi
+
+
+
+
+
+
+  if test yes != "$enable_dlopen"; then
+  enable_dlopen=unknown
+  enable_dlopen_self=unknown
+  enable_dlopen_self_static=unknown
+else
+  lt_cv_dlopen=no
+  lt_cv_dlopen_libs=
+
+  case $host_os in
+  beos*)
+    lt_cv_dlopen=load_add_on
+    lt_cv_dlopen_libs=
+    lt_cv_dlopen_self=yes
+    ;;
+
+  mingw* | pw32* | cegcc*)
+    lt_cv_dlopen=LoadLibrary
+    lt_cv_dlopen_libs=
+    ;;
+
+  cygwin*)
+    lt_cv_dlopen=dlopen
+    lt_cv_dlopen_libs=
+    ;;
+
+  darwin*)
+    # if libdl is installed we need to link against it
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
+$as_echo_n "checking for dlopen in -ldl... " >&6; }
+if ${ac_cv_lib_dl_dlopen+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-ldl  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char dlopen ();
+int
+main ()
+{
+return dlopen ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_dl_dlopen=yes
+else
+  ac_cv_lib_dl_dlopen=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
+$as_echo "$ac_cv_lib_dl_dlopen" >&6; }
+if test "x$ac_cv_lib_dl_dlopen" = xyes; then :
+  lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl
+else
+
+    lt_cv_dlopen=dyld
+    lt_cv_dlopen_libs=
+    lt_cv_dlopen_self=yes
+
+fi
+
+    ;;
+
+  tpf*)
+    # Don't try to run any link tests for TPF.  We know it's impossible
+    # because TPF is a cross-compiler, and we know how we open DSOs.
+    lt_cv_dlopen=dlopen
+    lt_cv_dlopen_libs=
+    lt_cv_dlopen_self=no
+    ;;
+
+  *)
+    ac_fn_c_check_func "$LINENO" "shl_load" "ac_cv_func_shl_load"
+if test "x$ac_cv_func_shl_load" = xyes; then :
+  lt_cv_dlopen=shl_load
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5
+$as_echo_n "checking for shl_load in -ldld... " >&6; }
+if ${ac_cv_lib_dld_shl_load+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-ldld  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char shl_load ();
+int
+main ()
+{
+return shl_load ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_dld_shl_load=yes
+else
+  ac_cv_lib_dld_shl_load=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5
+$as_echo "$ac_cv_lib_dld_shl_load" >&6; }
+if test "x$ac_cv_lib_dld_shl_load" = xyes; then :
+  lt_cv_dlopen=shl_load lt_cv_dlopen_libs=-ldld
+else
+  ac_fn_c_check_func "$LINENO" "dlopen" "ac_cv_func_dlopen"
+if test "x$ac_cv_func_dlopen" = xyes; then :
+  lt_cv_dlopen=dlopen
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
+$as_echo_n "checking for dlopen in -ldl... " >&6; }
+if ${ac_cv_lib_dl_dlopen+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-ldl  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char dlopen ();
+int
+main ()
+{
+return dlopen ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_dl_dlopen=yes
+else
+  ac_cv_lib_dl_dlopen=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
+$as_echo "$ac_cv_lib_dl_dlopen" >&6; }
+if test "x$ac_cv_lib_dl_dlopen" = xyes; then :
+  lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5
+$as_echo_n "checking for dlopen in -lsvld... " >&6; }
+if ${ac_cv_lib_svld_dlopen+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lsvld  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char dlopen ();
+int
+main ()
+{
+return dlopen ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_svld_dlopen=yes
+else
+  ac_cv_lib_svld_dlopen=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_svld_dlopen" >&5
+$as_echo "$ac_cv_lib_svld_dlopen" >&6; }
+if test "x$ac_cv_lib_svld_dlopen" = xyes; then :
+  lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-lsvld
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5
+$as_echo_n "checking for dld_link in -ldld... " >&6; }
+if ${ac_cv_lib_dld_dld_link+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-ldld  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char dld_link ();
+int
+main ()
+{
+return dld_link ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_dld_dld_link=yes
+else
+  ac_cv_lib_dld_dld_link=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_dld_link" >&5
+$as_echo "$ac_cv_lib_dld_dld_link" >&6; }
+if test "x$ac_cv_lib_dld_dld_link" = xyes; then :
+  lt_cv_dlopen=dld_link lt_cv_dlopen_libs=-ldld
+fi
+
+
+fi
+
+
+fi
+
+
+fi
+
+
+fi
+
+
+fi
+
+    ;;
+  esac
+
+  if test no = "$lt_cv_dlopen"; then
+    enable_dlopen=no
+  else
+    enable_dlopen=yes
+  fi
+
+  case $lt_cv_dlopen in
+  dlopen)
+    save_CPPFLAGS=$CPPFLAGS
+    test yes = "$ac_cv_header_dlfcn_h" && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"
+
+    save_LDFLAGS=$LDFLAGS
+    wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\"
+
+    save_LIBS=$LIBS
+    LIBS="$lt_cv_dlopen_libs $LIBS"
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a program can dlopen itself" >&5
+$as_echo_n "checking whether a program can dlopen itself... " >&6; }
+if ${lt_cv_dlopen_self+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  	  if test yes = "$cross_compiling"; then :
+  lt_cv_dlopen_self=cross
+else
+  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
+  lt_status=$lt_dlunknown
+  cat > conftest.$ac_ext <<_LT_EOF
+#line $LINENO "configure"
+#include "confdefs.h"
+
+#if HAVE_DLFCN_H
+#include <dlfcn.h>
+#endif
+
+#include <stdio.h>
+
+#ifdef RTLD_GLOBAL
+#  define LT_DLGLOBAL		RTLD_GLOBAL
+#else
+#  ifdef DL_GLOBAL
+#    define LT_DLGLOBAL		DL_GLOBAL
+#  else
+#    define LT_DLGLOBAL		0
+#  endif
+#endif
+
+/* We may have to define LT_DLLAZY_OR_NOW in the command line if we
+   find out it does not work in some platform. */
+#ifndef LT_DLLAZY_OR_NOW
+#  ifdef RTLD_LAZY
+#    define LT_DLLAZY_OR_NOW		RTLD_LAZY
+#  else
+#    ifdef DL_LAZY
+#      define LT_DLLAZY_OR_NOW		DL_LAZY
+#    else
+#      ifdef RTLD_NOW
+#        define LT_DLLAZY_OR_NOW	RTLD_NOW
+#      else
+#        ifdef DL_NOW
+#          define LT_DLLAZY_OR_NOW	DL_NOW
+#        else
+#          define LT_DLLAZY_OR_NOW	0
+#        endif
+#      endif
+#    endif
+#  endif
+#endif
+
+/* When -fvisibility=hidden is used, assume the code has been annotated
+   correspondingly for the symbols needed.  */
+#if defined __GNUC__ && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3))
+int fnord () __attribute__((visibility("default")));
+#endif
+
+int fnord () { return 42; }
+int main ()
+{
+  void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);
+  int status = $lt_dlunknown;
+
+  if (self)
+    {
+      if (dlsym (self,"fnord"))       status = $lt_dlno_uscore;
+      else
+        {
+	  if (dlsym( self,"_fnord"))  status = $lt_dlneed_uscore;
+          else puts (dlerror ());
+	}
+      /* dlclose (self); */
+    }
+  else
+    puts (dlerror ());
+
+  return status;
+}
+_LT_EOF
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
+  (eval $ac_link) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && test -s "conftest$ac_exeext" 2>/dev/null; then
+    (./conftest; exit; ) >&5 2>/dev/null
+    lt_status=$?
+    case x$lt_status in
+      x$lt_dlno_uscore) lt_cv_dlopen_self=yes ;;
+      x$lt_dlneed_uscore) lt_cv_dlopen_self=yes ;;
+      x$lt_dlunknown|x*) lt_cv_dlopen_self=no ;;
+    esac
+  else :
+    # compilation failed
+    lt_cv_dlopen_self=no
+  fi
+fi
+rm -fr conftest*
+
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self" >&5
+$as_echo "$lt_cv_dlopen_self" >&6; }
+
+    if test yes = "$lt_cv_dlopen_self"; then
+      wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\"
+      { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a statically linked program can dlopen itself" >&5
+$as_echo_n "checking whether a statically linked program can dlopen itself... " >&6; }
+if ${lt_cv_dlopen_self_static+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  	  if test yes = "$cross_compiling"; then :
+  lt_cv_dlopen_self_static=cross
+else
+  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
+  lt_status=$lt_dlunknown
+  cat > conftest.$ac_ext <<_LT_EOF
+#line $LINENO "configure"
+#include "confdefs.h"
+
+#if HAVE_DLFCN_H
+#include <dlfcn.h>
+#endif
+
+#include <stdio.h>
+
+#ifdef RTLD_GLOBAL
+#  define LT_DLGLOBAL		RTLD_GLOBAL
+#else
+#  ifdef DL_GLOBAL
+#    define LT_DLGLOBAL		DL_GLOBAL
+#  else
+#    define LT_DLGLOBAL		0
+#  endif
+#endif
+
+/* We may have to define LT_DLLAZY_OR_NOW in the command line if we
+   find out it does not work in some platform. */
+#ifndef LT_DLLAZY_OR_NOW
+#  ifdef RTLD_LAZY
+#    define LT_DLLAZY_OR_NOW		RTLD_LAZY
+#  else
+#    ifdef DL_LAZY
+#      define LT_DLLAZY_OR_NOW		DL_LAZY
+#    else
+#      ifdef RTLD_NOW
+#        define LT_DLLAZY_OR_NOW	RTLD_NOW
+#      else
+#        ifdef DL_NOW
+#          define LT_DLLAZY_OR_NOW	DL_NOW
+#        else
+#          define LT_DLLAZY_OR_NOW	0
+#        endif
+#      endif
+#    endif
+#  endif
+#endif
+
+/* When -fvisibility=hidden is used, assume the code has been annotated
+   correspondingly for the symbols needed.  */
+#if defined __GNUC__ && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3))
+int fnord () __attribute__((visibility("default")));
+#endif
+
+int fnord () { return 42; }
+int main ()
+{
+  void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);
+  int status = $lt_dlunknown;
+
+  if (self)
+    {
+      if (dlsym (self,"fnord"))       status = $lt_dlno_uscore;
+      else
+        {
+	  if (dlsym( self,"_fnord"))  status = $lt_dlneed_uscore;
+          else puts (dlerror ());
+	}
+      /* dlclose (self); */
+    }
+  else
+    puts (dlerror ());
+
+  return status;
+}
+_LT_EOF
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
+  (eval $ac_link) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && test -s "conftest$ac_exeext" 2>/dev/null; then
+    (./conftest; exit; ) >&5 2>/dev/null
+    lt_status=$?
+    case x$lt_status in
+      x$lt_dlno_uscore) lt_cv_dlopen_self_static=yes ;;
+      x$lt_dlneed_uscore) lt_cv_dlopen_self_static=yes ;;
+      x$lt_dlunknown|x*) lt_cv_dlopen_self_static=no ;;
+    esac
+  else :
+    # compilation failed
+    lt_cv_dlopen_self_static=no
+  fi
+fi
+rm -fr conftest*
+
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self_static" >&5
+$as_echo "$lt_cv_dlopen_self_static" >&6; }
+    fi
+
+    CPPFLAGS=$save_CPPFLAGS
+    LDFLAGS=$save_LDFLAGS
+    LIBS=$save_LIBS
+    ;;
+  esac
+
+  case $lt_cv_dlopen_self in
+  yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;;
+  *) enable_dlopen_self=unknown ;;
+  esac
+
+  case $lt_cv_dlopen_self_static in
+  yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;;
+  *) enable_dlopen_self_static=unknown ;;
+  esac
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+striplib=
+old_striplib=
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether stripping libraries is possible" >&5
+$as_echo_n "checking whether stripping libraries is possible... " >&6; }
+if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then
+  test -z "$old_striplib" && old_striplib="$STRIP --strip-debug"
+  test -z "$striplib" && striplib="$STRIP --strip-unneeded"
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+else
+# FIXME - insert some real tests, host_os isn't really good enough
+  case $host_os in
+  darwin*)
+    if test -n "$STRIP"; then
+      striplib="$STRIP -x"
+      old_striplib="$STRIP -S"
+      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+    else
+      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+    fi
+    ;;
+  *)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+    ;;
+  esac
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+  # Report what library types will actually be built
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if libtool supports shared libraries" >&5
+$as_echo_n "checking if libtool supports shared libraries... " >&6; }
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $can_build_shared" >&5
+$as_echo "$can_build_shared" >&6; }
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries" >&5
+$as_echo_n "checking whether to build shared libraries... " >&6; }
+  test no = "$can_build_shared" && enable_shared=no
+
+  # On AIX, shared libraries and static libraries use the same namespace, and
+  # are all built from PIC.
+  case $host_os in
+  aix3*)
+    test yes = "$enable_shared" && enable_static=no
+    if test -n "$RANLIB"; then
+      archive_cmds="$archive_cmds~\$RANLIB \$lib"
+      postinstall_cmds='$RANLIB $lib'
+    fi
+    ;;
+
+  aix[4-9]*)
+    if test ia64 != "$host_cpu"; then
+      case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in
+      yes,aix,yes) ;;			# shared object as lib.so file only
+      yes,svr4,*) ;;			# shared object as lib.so archive member only
+      yes,*) enable_static=no ;;	# shared object in lib.a archive as well
+      esac
+    fi
+    ;;
+  esac
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_shared" >&5
+$as_echo "$enable_shared" >&6; }
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build static libraries" >&5
+$as_echo_n "checking whether to build static libraries... " >&6; }
+  # Make sure either enable_shared or enable_static is yes.
+  test yes = "$enable_shared" || enable_static=yes
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_static" >&5
+$as_echo "$enable_static" >&6; }
+
+
+
+
+fi
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+CC=$lt_save_CC
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+        ac_config_commands="$ac_config_commands libtool"
+
+
+
+
+# Only expand once:
+
+
+
+
+# Some awks crash when confronted with pnglibconf.dfa, do a test run now
+# to make sure this doesn't happen
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking that AWK works" >&5
+$as_echo_n "checking that AWK works... " >&6; }
+if ${AWK} -f ${srcdir}/scripts/options.awk out="/dev/null" version=search\
+   ${srcdir}/pngconf.h ${srcdir}/scripts/pnglibconf.dfa\
+   ${srcdir}/pngusr.dfa 1>&2
+then
+   { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+$as_echo "ok" >&6; }
+else
+   { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error 1 "failed
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+
+# This is a remnant of the old cc -E validation, where it may have been
+# necessary to use a different preprocessor for .dfn files
+DFNCPP="$CPP"
+
+
+# -Werror cannot be passed to GCC in CFLAGS because configure will fail (it
+# checks the compiler with a program that generates a warning), add the
+# following option to deal with this
+
+# Check whether --enable-werror was given.
+if test "${enable_werror+set}" = set; then :
+  enableval=$enable_werror; test "$enable_werror" = "yes" && enable_werror="-Werror"
+    if test "$enable_werror" != "no"; then
+      sav_CFLAGS="$CFLAGS"
+      CFLAGS="$enable_werror $CFLAGS"
+      { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the compiler allows $enable_werror" >&5
+$as_echo_n "checking if the compiler allows $enable_werror... " >&6; }
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+            int main(int argc, char **argv){
+            return argv[argc-1][0];
+            }
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+         PNG_COPTS="$PNG_COPTS $enable_werror"
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+      CFLAGS="$sav_CFLAGS"
+    fi
+fi
+
+
+# For GCC 5 the default mode for C is -std=gnu11 instead of -std=gnu89
+# In pngpriv.h we request just the POSIX 1003.1 and C89 APIs by defining _POSIX_SOURCE to 1
+# This is incompatible with the new default mode, so we test for that and force the
+# "-std=c89" compiler option:
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if we need to force back C standard to C89" >&5
+$as_echo_n "checking if we need to force back C standard to C89... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+      #define _POSIX_SOURCE 1
+      #include <stdio.h>
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+else
+
+      if test "x$GCC" != "xyes"; then
+         as_fn_error $? "Forcing back to C89 is required but the flags are only known for GCC" "$LINENO" 5
+      fi
+   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+   CFLAGS="$CFLAGS -std=c89"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+
+# Checks for header files.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
+$as_echo_n "checking for ANSI C header files... " >&6; }
+if ${ac_cv_header_stdc+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <float.h>
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_header_stdc=yes
+else
+  ac_cv_header_stdc=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+
+if test $ac_cv_header_stdc = yes; then
+  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <string.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "memchr" >/dev/null 2>&1; then :
+
+else
+  ac_cv_header_stdc=no
+fi
+rm -f conftest*
+
+fi
+
+if test $ac_cv_header_stdc = yes; then
+  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdlib.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "free" >/dev/null 2>&1; then :
+
+else
+  ac_cv_header_stdc=no
+fi
+rm -f conftest*
+
+fi
+
+if test $ac_cv_header_stdc = yes; then
+  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
+  if test "$cross_compiling" = yes; then :
+  :
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ctype.h>
+#include <stdlib.h>
+#if ((' ' & 0x0FF) == 0x020)
+# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
+# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
+#else
+# define ISLOWER(c) \
+		   (('a' <= (c) && (c) <= 'i') \
+		     || ('j' <= (c) && (c) <= 'r') \
+		     || ('s' <= (c) && (c) <= 'z'))
+# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
+#endif
+
+#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
+int
+main ()
+{
+  int i;
+  for (i = 0; i < 256; i++)
+    if (XOR (islower (i), ISLOWER (i))
+	|| toupper (i) != TOUPPER (i))
+      return 2;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_run "$LINENO"; then :
+
+else
+  ac_cv_header_stdc=no
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
+$as_echo "$ac_cv_header_stdc" >&6; }
+if test $ac_cv_header_stdc = yes; then
+
+$as_echo "#define STDC_HEADERS 1" >>confdefs.h
+
+fi
+
+
+# Checks for typedefs, structures, and compiler characteristics.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for an ANSI C-conforming const" >&5
+$as_echo_n "checking for an ANSI C-conforming const... " >&6; }
+if ${ac_cv_c_const+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+#ifndef __cplusplus
+  /* Ultrix mips cc rejects this sort of thing.  */
+  typedef int charset[2];
+  const charset cs = { 0, 0 };
+  /* SunOS 4.1.1 cc rejects this.  */
+  char const *const *pcpcc;
+  char **ppc;
+  /* NEC SVR4.0.2 mips cc rejects this.  */
+  struct point {int x, y;};
+  static struct point const zero = {0,0};
+  /* AIX XL C 1.02.0.0 rejects this.
+     It does not let you subtract one const X* pointer from another in
+     an arm of an if-expression whose if-part is not a constant
+     expression */
+  const char *g = "string";
+  pcpcc = &g + (g ? g-g : 0);
+  /* HPUX 7.0 cc rejects these. */
+  ++pcpcc;
+  ppc = (char**) pcpcc;
+  pcpcc = (char const *const *) ppc;
+  { /* SCO 3.2v4 cc rejects this sort of thing.  */
+    char tx;
+    char *t = &tx;
+    char const *s = 0 ? (char *) 0 : (char const *) 0;
+
+    *t++ = 0;
+    if (s) return 0;
+  }
+  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
+    int x[] = {25, 17};
+    const int *foo = &x[0];
+    ++foo;
+  }
+  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
+    typedef const int *iptr;
+    iptr p = 0;
+    ++p;
+  }
+  { /* AIX XL C 1.02.0.0 rejects this sort of thing, saying
+       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
+    struct s { int j; const int *ap[3]; } bx;
+    struct s *b = &bx; b->j = 5;
+  }
+  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
+    const int foo = 10;
+    if (!foo) return 0;
+  }
+  return !cs[0] && !zero.x;
+#endif
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_c_const=yes
+else
+  ac_cv_c_const=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_const" >&5
+$as_echo "$ac_cv_c_const" >&6; }
+if test $ac_cv_c_const = no; then
+
+$as_echo "#define const /**/" >>confdefs.h
+
+fi
+
+ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default"
+if test "x$ac_cv_type_size_t" = xyes; then :
+
+else
+
+cat >>confdefs.h <<_ACEOF
+#define size_t unsigned int
+_ACEOF
+
+fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether struct tm is in sys/time.h or time.h" >&5
+$as_echo_n "checking whether struct tm is in sys/time.h or time.h... " >&6; }
+if ${ac_cv_struct_tm+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <sys/types.h>
+#include <time.h>
+
+int
+main ()
+{
+struct tm tm;
+				     int *p = &tm.tm_sec;
+				     return !p;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_struct_tm=time.h
+else
+  ac_cv_struct_tm=sys/time.h
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_struct_tm" >&5
+$as_echo "$ac_cv_struct_tm" >&6; }
+if test $ac_cv_struct_tm = sys/time.h; then
+
+$as_echo "#define TM_IN_SYS_TIME 1" >>confdefs.h
+
+fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C/C++ restrict keyword" >&5
+$as_echo_n "checking for C/C++ restrict keyword... " >&6; }
+if ${ac_cv_c_restrict+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_cv_c_restrict=no
+   # The order here caters to the fact that C++ does not require restrict.
+   for ac_kw in __restrict __restrict__ _Restrict restrict; do
+     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+typedef int * int_ptr;
+	int foo (int_ptr $ac_kw ip) {
+	return ip[0];
+       }
+int
+main ()
+{
+int s[1];
+	int * $ac_kw t = s;
+	t[0] = 0;
+	return foo(t)
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_c_restrict=$ac_kw
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+     test "$ac_cv_c_restrict" != no && break
+   done
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_restrict" >&5
+$as_echo "$ac_cv_c_restrict" >&6; }
+
+ case $ac_cv_c_restrict in
+   restrict) ;;
+   no) $as_echo "#define restrict /**/" >>confdefs.h
+ ;;
+   *)  cat >>confdefs.h <<_ACEOF
+#define restrict $ac_cv_c_restrict
+_ACEOF
+ ;;
+ esac
+
+
+# Checks for library functions.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for working strtod" >&5
+$as_echo_n "checking for working strtod... " >&6; }
+if ${ac_cv_func_strtod+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test "$cross_compiling" = yes; then :
+  ac_cv_func_strtod=no
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+$ac_includes_default
+#ifndef strtod
+double strtod ();
+#endif
+int
+main()
+{
+  {
+    /* Some versions of Linux strtod mis-parse strings with leading '+'.  */
+    char *string = " +69";
+    char *term;
+    double value;
+    value = strtod (string, &term);
+    if (value != 69 || term != (string + 4))
+      return 1;
+  }
+
+  {
+    /* Under Solaris 2.4, strtod returns the wrong value for the
+       terminating character under some conditions.  */
+    char *string = "NaN";
+    char *term;
+    strtod (string, &term);
+    if (term != string && *(term - 1) == 0)
+      return 1;
+  }
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_run "$LINENO"; then :
+  ac_cv_func_strtod=yes
+else
+  ac_cv_func_strtod=no
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_strtod" >&5
+$as_echo "$ac_cv_func_strtod" >&6; }
+if test $ac_cv_func_strtod = no; then
+  case " $LIBOBJS " in
+  *" strtod.$ac_objext "* ) ;;
+  *) LIBOBJS="$LIBOBJS strtod.$ac_objext"
+ ;;
+esac
+
+ac_fn_c_check_func "$LINENO" "pow" "ac_cv_func_pow"
+if test "x$ac_cv_func_pow" = xyes; then :
+
+fi
+
+if test $ac_cv_func_pow = no; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for pow in -lm" >&5
+$as_echo_n "checking for pow in -lm... " >&6; }
+if ${ac_cv_lib_m_pow+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lm  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char pow ();
+int
+main ()
+{
+return pow ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_m_pow=yes
+else
+  ac_cv_lib_m_pow=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_m_pow" >&5
+$as_echo "$ac_cv_lib_m_pow" >&6; }
+if test "x$ac_cv_lib_m_pow" = xyes; then :
+  POW_LIB=-lm
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cannot find library containing definition of pow" >&5
+$as_echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
+fi
+
+fi
+
+fi
+
+for ac_func in pow
+do :
+  ac_fn_c_check_func "$LINENO" "pow" "ac_cv_func_pow"
+if test "x$ac_cv_func_pow" = xyes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_POW 1
+_ACEOF
+
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for pow in -lm" >&5
+$as_echo_n "checking for pow in -lm... " >&6; }
+if ${ac_cv_lib_m_pow+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lm  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char pow ();
+int
+main ()
+{
+return pow ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_m_pow=yes
+else
+  ac_cv_lib_m_pow=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_m_pow" >&5
+$as_echo "$ac_cv_lib_m_pow" >&6; }
+if test "x$ac_cv_lib_m_pow" = xyes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_LIBM 1
+_ACEOF
+
+  LIBS="-lm $LIBS"
+
+else
+  as_fn_error $? "cannot find pow" "$LINENO" 5
+fi
+
+fi
+done
+
+
+# Some later POSIX 1003.1 functions are required for test programs, failure here
+# is soft (the corresponding test program is not built).
+ac_fn_c_check_func "$LINENO" "clock_gettime" "ac_cv_func_clock_gettime"
+if test "x$ac_cv_func_clock_gettime" = xyes; then :
+
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: not building timepng" >&5
+$as_echo "$as_me: WARNING: not building timepng" >&2;}
+fi
+
+ if test "$ac_cv_func_clock_gettime" = "yes"; then
+  HAVE_CLOCK_GETTIME_TRUE=
+  HAVE_CLOCK_GETTIME_FALSE='#'
+else
+  HAVE_CLOCK_GETTIME_TRUE='#'
+  HAVE_CLOCK_GETTIME_FALSE=
+fi
+
+
+
+# Check whether --with-zlib-prefix was given.
+if test "${with_zlib_prefix+set}" = set; then :
+  withval=$with_zlib_prefix; ZPREFIX=${withval}
+else
+  ZPREFIX='z_'
+fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for zlibVersion in -lz" >&5
+$as_echo_n "checking for zlibVersion in -lz... " >&6; }
+if ${ac_cv_lib_z_zlibVersion+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lz  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char zlibVersion ();
+int
+main ()
+{
+return zlibVersion ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_z_zlibVersion=yes
+else
+  ac_cv_lib_z_zlibVersion=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_z_zlibVersion" >&5
+$as_echo "$ac_cv_lib_z_zlibVersion" >&6; }
+if test "x$ac_cv_lib_z_zlibVersion" = xyes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_LIBZ 1
+_ACEOF
+
+  LIBS="-lz $LIBS"
+
+else
+  as_ac_Lib=`$as_echo "ac_cv_lib_z_${ZPREFIX}zlibVersion" | $as_tr_sh`
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ZPREFIX}zlibVersion in -lz" >&5
+$as_echo_n "checking for ${ZPREFIX}zlibVersion in -lz... " >&6; }
+if eval \${$as_ac_Lib+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lz  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char ${ZPREFIX}zlibVersion ();
+int
+main ()
+{
+return ${ZPREFIX}zlibVersion ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  eval "$as_ac_Lib=yes"
+else
+  eval "$as_ac_Lib=no"
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+eval ac_res=\$$as_ac_Lib
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+if eval test \"x\$"$as_ac_Lib"\" = x"yes"; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_LIBZ 1
+_ACEOF
+
+  LIBS="-lz $LIBS"
+
+else
+  as_fn_error $? "zlib not installed" "$LINENO" 5
+fi
+
+fi
+
+
+# The following is for pngvalid, to ensure it catches FP errors even on
+# platforms that don't enable FP exceptions, the function appears in the math
+# library (typically), it's not an error if it is not found.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for feenableexcept in -lm" >&5
+$as_echo_n "checking for feenableexcept in -lm... " >&6; }
+if ${ac_cv_lib_m_feenableexcept+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lm  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char feenableexcept ();
+int
+main ()
+{
+return feenableexcept ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_m_feenableexcept=yes
+else
+  ac_cv_lib_m_feenableexcept=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_m_feenableexcept" >&5
+$as_echo "$ac_cv_lib_m_feenableexcept" >&6; }
+if test "x$ac_cv_lib_m_feenableexcept" = xyes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_LIBM 1
+_ACEOF
+
+  LIBS="-lm $LIBS"
+
+fi
+
+for ac_func in feenableexcept
+do :
+  ac_fn_c_check_func "$LINENO" "feenableexcept" "ac_cv_func_feenableexcept"
+if test "x$ac_cv_func_feenableexcept" = xyes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_FEENABLEEXCEPT 1
+_ACEOF
+
+fi
+done
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if using Solaris linker" >&5
+$as_echo_n "checking if using Solaris linker... " >&6; }
+SLD=`$LD --version 2>&1 | grep Solaris`
+if test "$SLD"; then
+    have_solaris_ld=yes
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+else
+    have_solaris_ld=no
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+ if test "$have_solaris_ld" = "yes"; then
+  HAVE_SOLARIS_LD_TRUE=
+  HAVE_SOLARIS_LD_FALSE='#'
+else
+  HAVE_SOLARIS_LD_TRUE='#'
+  HAVE_SOLARIS_LD_FALSE=
+fi
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if libraries can be versioned" >&5
+$as_echo_n "checking if libraries can be versioned... " >&6; }
+# Special case for PE/COFF platforms: ld reports
+# support for version-script, but doesn't actually
+# DO anything with it.
+case $host in
+*cygwin* | *mingw32* | *interix* )
+    have_ld_version_script=no
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+;;
+* )
+
+if test "$have_solaris_ld" = "yes"; then
+    GLD=`$LD --help < /dev/null 2>&1 | grep 'M mapfile'`
+else
+    GLD=`$LD --help < /dev/null 2>/dev/null | grep version-script`
+fi
+
+if test "$GLD"; then
+    have_ld_version_script=yes
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+else
+    have_ld_version_script=no
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: *** You have not enabled versioned symbols." >&5
+$as_echo "$as_me: WARNING: *** You have not enabled versioned symbols." >&2;}
+fi
+;;
+esac
+
+ if test "$have_ld_version_script" = "yes"; then
+  HAVE_LD_VERSION_SCRIPT_TRUE=
+  HAVE_LD_VERSION_SCRIPT_FALSE='#'
+else
+  HAVE_LD_VERSION_SCRIPT_TRUE='#'
+  HAVE_LD_VERSION_SCRIPT_FALSE=
+fi
+
+
+if test "$have_ld_version_script" = "yes"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for symbol prefix" >&5
+$as_echo_n "checking for symbol prefix... " >&6; }
+    SYMBOL_PREFIX=`echo "PREFIX=__USER_LABEL_PREFIX__" \
+                  | ${CPP-${CC-gcc} -E} - 2>&1 \
+                  | ${EGREP-grep} "^PREFIX=" \
+                  | ${SED-sed} -e "s:^PREFIX=::" -e "s:__USER_LABEL_PREFIX__::"`
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SYMBOL_PREFIX" >&5
+$as_echo "$SYMBOL_PREFIX" >&6; }
+fi
+
+# Substitutions for .in files
+
+
+
+
+
+# Additional arguments (and substitutions)
+# Allow the pkg-config directory to be set
+
+# Check whether --with-pkgconfigdir was given.
+if test "${with_pkgconfigdir+set}" = set; then :
+  withval=$with_pkgconfigdir; pkgconfigdir=${withval}
+else
+  pkgconfigdir='${libdir}/pkgconfig'
+fi
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: pkgconfig directory is ${pkgconfigdir}" >&5
+$as_echo "$as_me: pkgconfig directory is ${pkgconfigdir}" >&6;}
+
+# Make the *-config binary config scripts optional
+
+# Check whether --with-binconfigs was given.
+if test "${with_binconfigs+set}" = set; then :
+  withval=$with_binconfigs; if test "${withval}" = no; then
+      binconfigs=
+      { $as_echo "$as_me:${as_lineno-$LINENO}: libpng-config scripts will not be built" >&5
+$as_echo "$as_me: libpng-config scripts will not be built" >&6;}
+    else
+      binconfigs='${binconfigs}'
+    fi
+else
+  binconfigs='${binconfigs}'
+fi
+
+
+
+# Support for prefixes to the API function names; this will generate defines
+# at the start of the build to rename exported library functions
+
+# Check whether --with-libpng-prefix was given.
+if test "${with_libpng_prefix+set}" = set; then :
+  withval=$with_libpng_prefix; if test "${withval:-no}" != "no"; then
+      PNG_PREFIX=${withval}
+
+    fi
+fi
+
+ if test "${with_libpng_prefix:-no}" != "no"; then
+  DO_PNG_PREFIX_TRUE=
+  DO_PNG_PREFIX_FALSE='#'
+else
+  DO_PNG_PREFIX_TRUE='#'
+  DO_PNG_PREFIX_FALSE=
+fi
+
+
+# Control over what links are made for installed files.  Versioned files are
+# always installed, when the following options are turned on corresponding
+# unversioned links are also created (normally as symbolic links):
+# Check whether --enable-unversioned-links was given.
+if test "${enable_unversioned_links+set}" = set; then :
+  enableval=$enable_unversioned_links;
+fi
+
+
+# The AM_CONDITIONAL test is written so that the default is enabled;
+# --disable-unversioned-links must be given to turn the option off.
+ if test "$enable_unversioned_links" != "no"; then
+  DO_INSTALL_LINKS_TRUE=
+  DO_INSTALL_LINKS_FALSE='#'
+else
+  DO_INSTALL_LINKS_TRUE='#'
+  DO_INSTALL_LINKS_FALSE=
+fi
+
+
+# Check whether --enable-unversioned-libpng-pc was given.
+if test "${enable_unversioned_libpng_pc+set}" = set; then :
+  enableval=$enable_unversioned_libpng_pc;
+fi
+
+ if test "$enable_unversioned_libpng_pc" != "no"; then
+  DO_INSTALL_LIBPNG_PC_TRUE=
+  DO_INSTALL_LIBPNG_PC_FALSE='#'
+else
+  DO_INSTALL_LIBPNG_PC_TRUE='#'
+  DO_INSTALL_LIBPNG_PC_FALSE=
+fi
+
+
+# Check whether --enable-unversioned-libpng-config was given.
+if test "${enable_unversioned_libpng_config+set}" = set; then :
+  enableval=$enable_unversioned_libpng_config;
+fi
+
+ if test "$enable_unversioned_libpng_config" != "no"; then
+  DO_INSTALL_LIBPNG_CONFIG_TRUE=
+  DO_INSTALL_LIBPNG_CONFIG_FALSE='#'
+else
+  DO_INSTALL_LIBPNG_CONFIG_TRUE='#'
+  DO_INSTALL_LIBPNG_CONFIG_FALSE=
+fi
+
+
+# HOST SPECIFIC OPTIONS
+# =====================
+#
+# DEFAULT
+# =======
+#
+# Check whether --enable-hardware-optimizations was given.
+if test "${enable_hardware_optimizations+set}" = set; then :
+  enableval=$enable_hardware_optimizations; case "$enableval" in
+      no|off)
+         # disable hardware optimization on all systems:
+         enable_arm_neon=no
+
+$as_echo "#define PNG_ARM_NEON_OPT 0" >>confdefs.h
+
+         enable_mips_msa=no
+
+$as_echo "#define PNG_MIPS_MSA_OPT 0" >>confdefs.h
+
+         enable_powerpc_vsx=no
+
+$as_echo "#define PNG_POWERPC_VSX_OPT 0" >>confdefs.h
+
+         enable_intel_sse=no
+
+$as_echo "#define PNG_INTEL_SSE_OPT 0" >>confdefs.h
+
+         ;;
+      *)
+         # allow enabling hardware optimization on any system:
+         case "$host_cpu" in
+            arm*|aarch64*)
+              enable_arm_neon=yes
+
+$as_echo "#define PNG_ARM_NEON_OPT 0" >>confdefs.h
+
+              ;;
+            mipsel*|mips64el*)
+              enable_mips_msa=yes
+
+$as_echo "#define PNG_MIPS_MSA_OPT 0" >>confdefs.h
+
+              ;;
+            i?86|x86_64)
+              enable_intel_sse=yes
+
+$as_echo "#define PNG_INTEL_SSE_OPT 1" >>confdefs.h
+
+              ;;
+            powerpc*|ppc64*)
+              enable_powerpc_vsx=yes
+
+$as_echo "#define PNG_POWERPC_VSX_OPT 2" >>confdefs.h
+
+              ;;
+         esac
+         ;;
+   esac
+fi
+
+
+# ARM
+# ===
+#
+# ARM NEON (SIMD) support.
+
+# Check whether --enable-arm-neon was given.
+if test "${enable_arm_neon+set}" = set; then :
+  enableval=$enable_arm_neon; case "$enableval" in
+      no|off)
+         # disable the default enabling on __ARM_NEON__ systems:
+
+$as_echo "#define PNG_ARM_NEON_OPT 0" >>confdefs.h
+
+         # Prevent inclusion of the assembler files below:
+         enable_arm_neon=no;;
+      check)
+
+$as_echo "#define PNG_ARM_NEON_CHECK_SUPPORTED /**/" >>confdefs.h
+;;
+      api)
+
+$as_echo "#define PNG_ARM_NEON_API_SUPPORTED /**/" >>confdefs.h
+;;
+      yes|on)
+
+$as_echo "#define PNG_ARM_NEON_OPT 2" >>confdefs.h
+
+         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --enable-arm-neon: please specify 'check' or 'api', if
+            you want the optimizations unconditionally pass -mfpu=neon
+            to the compiler." >&5
+$as_echo "$as_me: WARNING: --enable-arm-neon: please specify 'check' or 'api', if
+            you want the optimizations unconditionally pass -mfpu=neon
+            to the compiler." >&2;};;
+      *)
+         as_fn_error $? "--enable-arm-neon=${enable_arm_neon}: invalid value" "$LINENO" 5
+   esac
+fi
+
+
+# Add ARM specific files to all builds where the host_cpu is arm ('arm*') or
+# where ARM optimizations were explicitly requested (this allows a fallback if a
+# future host CPU does not match 'arm*')
+
+ if test "$enable_arm_neon" != 'no' &&
+    case "$host_cpu" in
+      arm*|aarch64*) :;;
+      *)    test "$enable_arm_neon" != '';;
+    esac; then
+  PNG_ARM_NEON_TRUE=
+  PNG_ARM_NEON_FALSE='#'
+else
+  PNG_ARM_NEON_TRUE='#'
+  PNG_ARM_NEON_FALSE=
+fi
+
+
+# MIPS
+# ===
+#
+# MIPS MSA (SIMD) support.
+
+# Check whether --enable-mips-msa was given.
+if test "${enable_mips_msa+set}" = set; then :
+  enableval=$enable_mips_msa; case "$enableval" in
+      no|off)
+         # disable the default enabling on __mips_msa systems:
+
+$as_echo "#define PNG_MIPS_MSA_OPT 0" >>confdefs.h
+
+         # Prevent inclusion of the assembler files below:
+         enable_mips_msa=no;;
+      check)
+
+$as_echo "#define PNG_MIPS_MSA_CHECK_SUPPORTED /**/" >>confdefs.h
+;;
+      api)
+
+$as_echo "#define PNG_MIPS_MSA_API_SUPPORTED /**/" >>confdefs.h
+;;
+      yes|on)
+
+$as_echo "#define PNG_MIPS_MSA_OPT 2" >>confdefs.h
+
+         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --enable-mips-msa: please specify 'check' or 'api', if
+            you want the optimizations unconditionally pass '-mmsa -mfp64'
+            to the compiler." >&5
+$as_echo "$as_me: WARNING: --enable-mips-msa: please specify 'check' or 'api', if
+            you want the optimizations unconditionally pass '-mmsa -mfp64'
+            to the compiler." >&2;};;
+      *)
+         as_fn_error $? "--enable-mips-msa=${enable_mips_msa}: invalid value" "$LINENO" 5
+   esac
+fi
+
+
+# Add MIPS specific files to all builds where the host_cpu is mips ('mips*') or
+# where MIPS optimizations were explicitly requested (this allows a fallback if a
+# future host CPU does not match 'mips*')
+
+ if test "$enable_mips_msa" != 'no' &&
+    case "$host_cpu" in
+      mipsel*|mips64el*) :;;
+    esac; then
+  PNG_MIPS_MSA_TRUE=
+  PNG_MIPS_MSA_FALSE='#'
+else
+  PNG_MIPS_MSA_TRUE='#'
+  PNG_MIPS_MSA_FALSE=
+fi
+
+
+# INTEL
+# =====
+#
+# INTEL SSE (SIMD) support.
+
+# Check whether --enable-intel-sse was given.
+if test "${enable_intel_sse+set}" = set; then :
+  enableval=$enable_intel_sse; case "$enableval" in
+      no|off)
+         # disable the default enabling:
+
+$as_echo "#define PNG_INTEL_SSE_OPT 0" >>confdefs.h
+
+         # Prevent inclusion of the assembler files below:
+         enable_intel_sse=no;;
+      yes|on)
+
+$as_echo "#define PNG_INTEL_SSE_OPT 1" >>confdefs.h
+;;
+      *)
+         as_fn_error $? "--enable-intel-sse=${enable_intel_sse}: invalid value" "$LINENO" 5
+   esac
+fi
+
+
+# Add Intel specific files to all builds where the host_cpu is Intel ('x86*')
+# or where Intel optimizations were explicitly requested (this allows a
+# fallback if a future host CPU does not match 'x86*')
+ if test "$enable_intel_sse" != 'no' &&
+    case "$host_cpu" in
+      i?86|x86_64) :;;
+      *)    test "$enable_intel_sse" != '';;
+    esac; then
+  PNG_INTEL_SSE_TRUE=
+  PNG_INTEL_SSE_FALSE='#'
+else
+  PNG_INTEL_SSE_TRUE='#'
+  PNG_INTEL_SSE_FALSE=
+fi
+
+
+# PowerPC
+# ===
+#
+# PowerPC VSX (SIMD) support.
+
+# Check whether --enable-powerpc-vsx was given.
+if test "${enable_powerpc_vsx+set}" = set; then :
+  enableval=$enable_powerpc_vsx; case "$enableval" in
+      no|off)
+         # disable the default enabling on __ppc64__ systems:
+
+$as_echo "#define PNG_POWERPC_VSX_OPT 0" >>confdefs.h
+
+         # Prevent inclusion of the platform specific files below:
+         enable_powerpc_vsx=no;;
+      check)
+
+$as_echo "#define PNG_POWERPC_VSX_CHECK_SUPPORTED /**/" >>confdefs.h
+
+         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --enable-powerpc-vsx Please check contrib/powerpc/README file
+            for the list of supported OSes." >&5
+$as_echo "$as_me: WARNING: --enable-powerpc-vsx Please check contrib/powerpc/README file
+            for the list of supported OSes." >&2;};;
+      api)
+
+$as_echo "#define PNG_POWERPC_VSX_API_SUPPORTED /**/" >>confdefs.h
+;;
+      yes|on)
+
+$as_echo "#define PNG_POWERPC_VSX_OPT 2" >>confdefs.h
+
+         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --enable-powerpc-vsx: please specify 'check' or 'api', if
+            you want the optimizations unconditionally pass '-maltivec -mvsx'
+            or '-mcpu=power8'to the compiler." >&5
+$as_echo "$as_me: WARNING: --enable-powerpc-vsx: please specify 'check' or 'api', if
+            you want the optimizations unconditionally pass '-maltivec -mvsx'
+            or '-mcpu=power8'to the compiler." >&2;};;
+      *)
+         as_fn_error $? "--enable-powerpc-vsx=${enable_powerpc_vsx}: invalid value" "$LINENO" 5
+   esac
+fi
+
+
+# Add PowerPC specific files to all builds where the host_cpu is powerpc('powerpc*') or
+# where POWERPC optimizations were explicitly requested (this allows a fallback if a
+# future host CPU does not match 'powerpc*')
+
+ if test "$enable_powerpc_vsx" != 'no' &&
+    case "$host_cpu" in
+      powerpc*|ppc64*) :;;
+    esac; then
+  PNG_POWERPC_VSX_TRUE=
+  PNG_POWERPC_VSX_FALSE='#'
+else
+  PNG_POWERPC_VSX_TRUE='#'
+  PNG_POWERPC_VSX_FALSE=
+fi
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: Extra options for compiler: $PNG_COPTS" >&5
+$as_echo "$as_me: Extra options for compiler: $PNG_COPTS" >&6;}
+
+# Config files, substituting as above
+ac_config_files="$ac_config_files Makefile libpng.pc:libpng.pc.in"
+
+ac_config_files="$ac_config_files libpng-config:libpng-config.in"
+
+
+cat >confcache <<\_ACEOF
+# This file is a shell script that caches the results of configure
+# tests run on this system so they can be shared between configure
+# scripts and configure runs, see configure's option --config-cache.
+# It is not useful on other systems.  If it contains results you don't
+# want to keep, you may remove or edit it.
+#
+# config.status only pays attention to the cache file if you give it
+# the --recheck option to rerun configure.
+#
+# `ac_cv_env_foo' variables (set or unset) will be overridden when
+# loading this file, other *unset* `ac_cv_foo' will be assigned the
+# following values.
+
+_ACEOF
+
+# The following way of writing the cache mishandles newlines in values,
+# but we know of no workaround that is simple, portable, and efficient.
+# So, we kill variables containing newlines.
+# Ultrix sh set writes to stderr and can't be redirected directly,
+# and sets the high bit in the cache file unless we assign to the vars.
+(
+  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
+    eval ac_val=\$$ac_var
+    case $ac_val in #(
+    *${as_nl}*)
+      case $ac_var in #(
+      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
+$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+      esac
+      case $ac_var in #(
+      _ | IFS | as_nl) ;; #(
+      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
+      *) { eval $ac_var=; unset $ac_var;} ;;
+      esac ;;
+    esac
+  done
+
+  (set) 2>&1 |
+    case $as_nl`(ac_space=' '; set) 2>&1` in #(
+    *${as_nl}ac_space=\ *)
+      # `set' does not quote correctly, so add quotes: double-quote
+      # substitution turns \\\\ into \\, and sed turns \\ into \.
+      sed -n \
+	"s/'/'\\\\''/g;
+	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
+      ;; #(
+    *)
+      # `set' quotes correctly as required by POSIX, so do not add quotes.
+      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+      ;;
+    esac |
+    sort
+) |
+  sed '
+     /^ac_cv_env_/b end
+     t clear
+     :clear
+     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
+     t end
+     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
+     :end' >>confcache
+if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
+  if test -w "$cache_file"; then
+    if test "x$cache_file" != "x/dev/null"; then
+      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
+$as_echo "$as_me: updating cache $cache_file" >&6;}
+      if test ! -f "$cache_file" || test -h "$cache_file"; then
+	cat confcache >"$cache_file"
+      else
+        case $cache_file in #(
+        */* | ?:*)
+	  mv -f confcache "$cache_file"$$ &&
+	  mv -f "$cache_file"$$ "$cache_file" ;; #(
+        *)
+	  mv -f confcache "$cache_file" ;;
+	esac
+      fi
+    fi
+  else
+    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
+$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
+  fi
+fi
+rm -f confcache
+
+test "x$prefix" = xNONE && prefix=$ac_default_prefix
+# Let make expand exec_prefix.
+test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
+
+DEFS=-DHAVE_CONFIG_H
+
+ac_libobjs=
+ac_ltlibobjs=
+U=
+for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
+  # 1. Remove the extension, and $U if already installed.
+  ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
+  ac_i=`$as_echo "$ac_i" | sed "$ac_script"`
+  # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
+  #    will be set to the directory where LIBOBJS objects are built.
+  as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
+  as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'
+done
+LIBOBJS=$ac_libobjs
+
+LTLIBOBJS=$ac_ltlibobjs
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking that generated files are newer than configure" >&5
+$as_echo_n "checking that generated files are newer than configure... " >&6; }
+   if test -n "$am_sleep_pid"; then
+     # Hide warnings about reused PIDs.
+     wait $am_sleep_pid 2>/dev/null
+   fi
+   { $as_echo "$as_me:${as_lineno-$LINENO}: result: done" >&5
+$as_echo "done" >&6; }
+ if test -n "$EXEEXT"; then
+  am__EXEEXT_TRUE=
+  am__EXEEXT_FALSE='#'
+else
+  am__EXEEXT_TRUE='#'
+  am__EXEEXT_FALSE=
+fi
+
+if test -z "${MAINTAINER_MODE_TRUE}" && test -z "${MAINTAINER_MODE_FALSE}"; then
+  as_fn_error $? "conditional \"MAINTAINER_MODE\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
+  as_fn_error $? "conditional \"AMDEP\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
+  as_fn_error $? "conditional \"am__fastdepCC\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${am__fastdepCCAS_TRUE}" && test -z "${am__fastdepCCAS_FALSE}"; then
+  as_fn_error $? "conditional \"am__fastdepCCAS\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${HAVE_CLOCK_GETTIME_TRUE}" && test -z "${HAVE_CLOCK_GETTIME_FALSE}"; then
+  as_fn_error $? "conditional \"HAVE_CLOCK_GETTIME\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${HAVE_SOLARIS_LD_TRUE}" && test -z "${HAVE_SOLARIS_LD_FALSE}"; then
+  as_fn_error $? "conditional \"HAVE_SOLARIS_LD\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${HAVE_LD_VERSION_SCRIPT_TRUE}" && test -z "${HAVE_LD_VERSION_SCRIPT_FALSE}"; then
+  as_fn_error $? "conditional \"HAVE_LD_VERSION_SCRIPT\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${DO_PNG_PREFIX_TRUE}" && test -z "${DO_PNG_PREFIX_FALSE}"; then
+  as_fn_error $? "conditional \"DO_PNG_PREFIX\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${DO_INSTALL_LINKS_TRUE}" && test -z "${DO_INSTALL_LINKS_FALSE}"; then
+  as_fn_error $? "conditional \"DO_INSTALL_LINKS\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${DO_INSTALL_LIBPNG_PC_TRUE}" && test -z "${DO_INSTALL_LIBPNG_PC_FALSE}"; then
+  as_fn_error $? "conditional \"DO_INSTALL_LIBPNG_PC\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${DO_INSTALL_LIBPNG_CONFIG_TRUE}" && test -z "${DO_INSTALL_LIBPNG_CONFIG_FALSE}"; then
+  as_fn_error $? "conditional \"DO_INSTALL_LIBPNG_CONFIG\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${PNG_ARM_NEON_TRUE}" && test -z "${PNG_ARM_NEON_FALSE}"; then
+  as_fn_error $? "conditional \"PNG_ARM_NEON\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${PNG_MIPS_MSA_TRUE}" && test -z "${PNG_MIPS_MSA_FALSE}"; then
+  as_fn_error $? "conditional \"PNG_MIPS_MSA\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${PNG_INTEL_SSE_TRUE}" && test -z "${PNG_INTEL_SSE_FALSE}"; then
+  as_fn_error $? "conditional \"PNG_INTEL_SSE\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${PNG_POWERPC_VSX_TRUE}" && test -z "${PNG_POWERPC_VSX_FALSE}"; then
+  as_fn_error $? "conditional \"PNG_POWERPC_VSX\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+
+: "${CONFIG_STATUS=./config.status}"
+ac_write_fail=0
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files $CONFIG_STATUS"
+{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
+$as_echo "$as_me: creating $CONFIG_STATUS" >&6;}
+as_write_fail=0
+cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
+#! $SHELL
+# Generated by $as_me.
+# Run this file to recreate the current configuration.
+# Compiler output produced by configure, useful for debugging
+# configure, is in config.log if it exists.
+
+debug=false
+ac_cs_recheck=false
+ac_cs_silent=false
+
+SHELL=\${CONFIG_SHELL-$SHELL}
+export SHELL
+_ASEOF
+cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
+## -------------------- ##
+## M4sh Initialization. ##
+## -------------------- ##
+
+# Be more Bourne compatible
+DUALCASE=1; export DUALCASE # for MKS sh
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+  setopt NO_GLOB_SUBST
+else
+  case `(set -o) 2>/dev/null` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
+fi
+
+
+as_nl='
+'
+export as_nl
+# Printing a long string crashes Solaris 7 /usr/bin/printf.
+as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
+# Prefer a ksh shell builtin over an external printf program on Solaris,
+# but without wasting forks for bash or zsh.
+if test -z "$BASH_VERSION$ZSH_VERSION" \
+    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='print -r --'
+  as_echo_n='print -rn --'
+elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='printf %s\n'
+  as_echo_n='printf %s'
+else
+  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
+    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
+    as_echo_n='/usr/ucb/echo -n'
+  else
+    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
+    as_echo_n_body='eval
+      arg=$1;
+      case $arg in #(
+      *"$as_nl"*)
+	expr "X$arg" : "X\\(.*\\)$as_nl";
+	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
+      esac;
+      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
+    '
+    export as_echo_n_body
+    as_echo_n='sh -c $as_echo_n_body as_echo'
+  fi
+  export as_echo_body
+  as_echo='sh -c $as_echo_body as_echo'
+fi
+
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+  PATH_SEPARATOR=:
+  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
+    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
+      PATH_SEPARATOR=';'
+  }
+fi
+
+
+# IFS
+# We need space, tab and new line, in precisely that order.  Quoting is
+# there to prevent editors from complaining about space-tab.
+# (If _AS_PATH_WALK were called with IFS unset, it would disable word
+# splitting by setting IFS to empty value.)
+IFS=" ""	$as_nl"
+
+# Find who we are.  Look in the path if we contain no directory separator.
+as_myself=
+case $0 in #((
+  *[\\/]* ) as_myself=$0 ;;
+  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+  done
+IFS=$as_save_IFS
+
+     ;;
+esac
+# We did not find ourselves, most probably we were run as `sh COMMAND'
+# in which case we are not to be found in the path.
+if test "x$as_myself" = x; then
+  as_myself=$0
+fi
+if test ! -f "$as_myself"; then
+  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
+  exit 1
+fi
+
+# Unset variables that we do not need and which cause bugs (e.g. in
+# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
+# suppresses any "Segmentation fault" message there.  '((' could
+# trigger a bug in pdksh 5.2.14.
+for as_var in BASH_ENV ENV MAIL MAILPATH
+do eval test x\${$as_var+set} = xset \
+  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
+done
+PS1='$ '
+PS2='> '
+PS4='+ '
+
+# NLS nuisances.
+LC_ALL=C
+export LC_ALL
+LANGUAGE=C
+export LANGUAGE
+
+# CDPATH.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+
+# as_fn_error STATUS ERROR [LINENO LOG_FD]
+# ----------------------------------------
+# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
+# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
+# script with STATUS, using 1 if that was 0.
+as_fn_error ()
+{
+  as_status=$1; test $as_status -eq 0 && as_status=1
+  if test "$4"; then
+    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
+  fi
+  $as_echo "$as_me: error: $2" >&2
+  as_fn_exit $as_status
+} # as_fn_error
+
+
+# as_fn_set_status STATUS
+# -----------------------
+# Set $? to STATUS, without forking.
+as_fn_set_status ()
+{
+  return $1
+} # as_fn_set_status
+
+# as_fn_exit STATUS
+# -----------------
+# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
+as_fn_exit ()
+{
+  set +e
+  as_fn_set_status $1
+  exit $1
+} # as_fn_exit
+
+# as_fn_unset VAR
+# ---------------
+# Portably unset VAR.
+as_fn_unset ()
+{
+  { eval $1=; unset $1;}
+}
+as_unset=as_fn_unset
+# as_fn_append VAR VALUE
+# ----------------------
+# Append the text in VALUE to the end of the definition contained in VAR. Take
+# advantage of any shell optimizations that allow amortized linear growth over
+# repeated appends, instead of the typical quadratic growth present in naive
+# implementations.
+if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
+  eval 'as_fn_append ()
+  {
+    eval $1+=\$2
+  }'
+else
+  as_fn_append ()
+  {
+    eval $1=\$$1\$2
+  }
+fi # as_fn_append
+
+# as_fn_arith ARG...
+# ------------------
+# Perform arithmetic evaluation on the ARGs, and store the result in the
+# global $as_val. Take advantage of shells that can avoid forks. The arguments
+# must be portable across $(()) and expr.
+if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
+  eval 'as_fn_arith ()
+  {
+    as_val=$(( $* ))
+  }'
+else
+  as_fn_arith ()
+  {
+    as_val=`expr "$@" || test $? -eq 1`
+  }
+fi # as_fn_arith
+
+
+if expr a : '\(a\)' >/dev/null 2>&1 &&
+   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+  as_basename=basename
+else
+  as_basename=false
+fi
+
+if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
+  as_dirname=dirname
+else
+  as_dirname=false
+fi
+
+as_me=`$as_basename -- "$0" ||
+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+	 X"$0" : 'X\(//\)$' \| \
+	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X/"$0" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+ECHO_C= ECHO_N= ECHO_T=
+case `echo -n x` in #(((((
+-n*)
+  case `echo 'xy\c'` in
+  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
+  xy)  ECHO_C='\c';;
+  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
+       ECHO_T='	';;
+  esac;;
+*)
+  ECHO_N='-n';;
+esac
+
+rm -f conf$$ conf$$.exe conf$$.file
+if test -d conf$$.dir; then
+  rm -f conf$$.dir/conf$$.file
+else
+  rm -f conf$$.dir
+  mkdir conf$$.dir 2>/dev/null
+fi
+if (echo >conf$$.file) 2>/dev/null; then
+  if ln -s conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s='ln -s'
+    # ... but there are two gotchas:
+    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
+    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
+    # In both cases, we have to default to `cp -pR'.
+    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+      as_ln_s='cp -pR'
+  elif ln conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s=ln
+  else
+    as_ln_s='cp -pR'
+  fi
+else
+  as_ln_s='cp -pR'
+fi
+rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
+rmdir conf$$.dir 2>/dev/null
+
+
+# as_fn_mkdir_p
+# -------------
+# Create "$as_dir" as a directory, including parents if necessary.
+as_fn_mkdir_p ()
+{
+
+  case $as_dir in #(
+  -*) as_dir=./$as_dir;;
+  esac
+  test -d "$as_dir" || eval $as_mkdir_p || {
+    as_dirs=
+    while :; do
+      case $as_dir in #(
+      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
+      *) as_qdir=$as_dir;;
+      esac
+      as_dirs="'$as_qdir' $as_dirs"
+      as_dir=`$as_dirname -- "$as_dir" ||
+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_dir" : 'X\(//\)[^/]' \| \
+	 X"$as_dir" : 'X\(//\)$' \| \
+	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$as_dir" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+      test -d "$as_dir" && break
+    done
+    test -z "$as_dirs" || eval "mkdir $as_dirs"
+  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
+
+
+} # as_fn_mkdir_p
+if mkdir -p . 2>/dev/null; then
+  as_mkdir_p='mkdir -p "$as_dir"'
+else
+  test -d ./-p && rmdir ./-p
+  as_mkdir_p=false
+fi
+
+
+# as_fn_executable_p FILE
+# -----------------------
+# Test if FILE is an executable regular file.
+as_fn_executable_p ()
+{
+  test -f "$1" && test -x "$1"
+} # as_fn_executable_p
+as_test_x='test -x'
+as_executable_p=as_fn_executable_p
+
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+
+
+exec 6>&1
+## ----------------------------------- ##
+## Main body of $CONFIG_STATUS script. ##
+## ----------------------------------- ##
+_ASEOF
+test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# Save the log message, to keep $0 and so on meaningful, and to
+# report actual input values of CONFIG_FILES etc. instead of their
+# values after options handling.
+ac_log="
+This file was extended by libpng $as_me 1.6.37, which was
+generated by GNU Autoconf 2.69.  Invocation command line was
+
+  CONFIG_FILES    = $CONFIG_FILES
+  CONFIG_HEADERS  = $CONFIG_HEADERS
+  CONFIG_LINKS    = $CONFIG_LINKS
+  CONFIG_COMMANDS = $CONFIG_COMMANDS
+  $ $0 $@
+
+on `(hostname || uname -n) 2>/dev/null | sed 1q`
+"
+
+_ACEOF
+
+case $ac_config_files in *"
+"*) set x $ac_config_files; shift; ac_config_files=$*;;
+esac
+
+case $ac_config_headers in *"
+"*) set x $ac_config_headers; shift; ac_config_headers=$*;;
+esac
+
+
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+# Files that config.status was made for.
+config_files="$ac_config_files"
+config_headers="$ac_config_headers"
+config_commands="$ac_config_commands"
+
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+ac_cs_usage="\
+\`$as_me' instantiates files and other configuration actions
+from templates according to the current configuration.  Unless the files
+and actions are specified as TAGs, all are instantiated by default.
+
+Usage: $0 [OPTION]... [TAG]...
+
+  -h, --help       print this help, then exit
+  -V, --version    print version number and configuration settings, then exit
+      --config     print configuration, then exit
+  -q, --quiet, --silent
+                   do not print progress messages
+  -d, --debug      don't remove temporary files
+      --recheck    update $as_me by reconfiguring in the same conditions
+      --file=FILE[:TEMPLATE]
+                   instantiate the configuration file FILE
+      --header=FILE[:TEMPLATE]
+                   instantiate the configuration header FILE
+
+Configuration files:
+$config_files
+
+Configuration headers:
+$config_headers
+
+Configuration commands:
+$config_commands
+
+Report bugs to <png-mng-implement@lists.sourceforge.net>."
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
+ac_cs_version="\\
+libpng config.status 1.6.37
+configured by $0, generated by GNU Autoconf 2.69,
+  with options \\"\$ac_cs_config\\"
+
+Copyright (C) 2012 Free Software Foundation, Inc.
+This config.status script is free software; the Free Software Foundation
+gives unlimited permission to copy, distribute and modify it."
+
+ac_pwd='$ac_pwd'
+srcdir='$srcdir'
+INSTALL='$INSTALL'
+MKDIR_P='$MKDIR_P'
+AWK='$AWK'
+test -n "\$AWK" || AWK=awk
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# The default lists apply if the user does not specify any file.
+ac_need_defaults=:
+while test $# != 0
+do
+  case $1 in
+  --*=?*)
+    ac_option=`expr "X$1" : 'X\([^=]*\)='`
+    ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
+    ac_shift=:
+    ;;
+  --*=)
+    ac_option=`expr "X$1" : 'X\([^=]*\)='`
+    ac_optarg=
+    ac_shift=:
+    ;;
+  *)
+    ac_option=$1
+    ac_optarg=$2
+    ac_shift=shift
+    ;;
+  esac
+
+  case $ac_option in
+  # Handling of the options.
+  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
+    ac_cs_recheck=: ;;
+  --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
+    $as_echo "$ac_cs_version"; exit ;;
+  --config | --confi | --conf | --con | --co | --c )
+    $as_echo "$ac_cs_config"; exit ;;
+  --debug | --debu | --deb | --de | --d | -d )
+    debug=: ;;
+  --file | --fil | --fi | --f )
+    $ac_shift
+    case $ac_optarg in
+    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    '') as_fn_error $? "missing file argument" ;;
+    esac
+    as_fn_append CONFIG_FILES " '$ac_optarg'"
+    ac_need_defaults=false;;
+  --header | --heade | --head | --hea )
+    $ac_shift
+    case $ac_optarg in
+    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    esac
+    as_fn_append CONFIG_HEADERS " '$ac_optarg'"
+    ac_need_defaults=false;;
+  --he | --h)
+    # Conflict between --help and --header
+    as_fn_error $? "ambiguous option: \`$1'
+Try \`$0 --help' for more information.";;
+  --help | --hel | -h )
+    $as_echo "$ac_cs_usage"; exit ;;
+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+  | -silent | --silent | --silen | --sile | --sil | --si | --s)
+    ac_cs_silent=: ;;
+
+  # This is an error.
+  -*) as_fn_error $? "unrecognized option: \`$1'
+Try \`$0 --help' for more information." ;;
+
+  *) as_fn_append ac_config_targets " $1"
+     ac_need_defaults=false ;;
+
+  esac
+  shift
+done
+
+ac_configure_extra_args=
+
+if $ac_cs_silent; then
+  exec 6>/dev/null
+  ac_configure_extra_args="$ac_configure_extra_args --silent"
+fi
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+if \$ac_cs_recheck; then
+  set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
+  shift
+  \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
+  CONFIG_SHELL='$SHELL'
+  export CONFIG_SHELL
+  exec "\$@"
+fi
+
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+exec 5>>config.log
+{
+  echo
+  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
+## Running $as_me. ##
+_ASBOX
+  $as_echo "$ac_log"
+} >&5
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+#
+# INIT-COMMANDS
+#
+AMDEP_TRUE="$AMDEP_TRUE" MAKE="${MAKE-make}"
+
+
+# The HP-UX ksh and POSIX shell print the target directory to stdout
+# if CDPATH is set.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+sed_quote_subst='$sed_quote_subst'
+double_quote_subst='$double_quote_subst'
+delay_variable_subst='$delay_variable_subst'
+SED='`$ECHO "$SED" | $SED "$delay_single_quote_subst"`'
+Xsed='`$ECHO "$Xsed" | $SED "$delay_single_quote_subst"`'
+GREP='`$ECHO "$GREP" | $SED "$delay_single_quote_subst"`'
+EGREP='`$ECHO "$EGREP" | $SED "$delay_single_quote_subst"`'
+FGREP='`$ECHO "$FGREP" | $SED "$delay_single_quote_subst"`'
+SHELL='`$ECHO "$SHELL" | $SED "$delay_single_quote_subst"`'
+ECHO='`$ECHO "$ECHO" | $SED "$delay_single_quote_subst"`'
+LD='`$ECHO "$LD" | $SED "$delay_single_quote_subst"`'
+macro_version='`$ECHO "$macro_version" | $SED "$delay_single_quote_subst"`'
+macro_revision='`$ECHO "$macro_revision" | $SED "$delay_single_quote_subst"`'
+AS='`$ECHO "$AS" | $SED "$delay_single_quote_subst"`'
+DLLTOOL='`$ECHO "$DLLTOOL" | $SED "$delay_single_quote_subst"`'
+OBJDUMP='`$ECHO "$OBJDUMP" | $SED "$delay_single_quote_subst"`'
+enable_shared='`$ECHO "$enable_shared" | $SED "$delay_single_quote_subst"`'
+enable_static='`$ECHO "$enable_static" | $SED "$delay_single_quote_subst"`'
+pic_mode='`$ECHO "$pic_mode" | $SED "$delay_single_quote_subst"`'
+enable_fast_install='`$ECHO "$enable_fast_install" | $SED "$delay_single_quote_subst"`'
+shared_archive_member_spec='`$ECHO "$shared_archive_member_spec" | $SED "$delay_single_quote_subst"`'
+PATH_SEPARATOR='`$ECHO "$PATH_SEPARATOR" | $SED "$delay_single_quote_subst"`'
+host_alias='`$ECHO "$host_alias" | $SED "$delay_single_quote_subst"`'
+host='`$ECHO "$host" | $SED "$delay_single_quote_subst"`'
+host_os='`$ECHO "$host_os" | $SED "$delay_single_quote_subst"`'
+build_alias='`$ECHO "$build_alias" | $SED "$delay_single_quote_subst"`'
+build='`$ECHO "$build" | $SED "$delay_single_quote_subst"`'
+build_os='`$ECHO "$build_os" | $SED "$delay_single_quote_subst"`'
+NM='`$ECHO "$NM" | $SED "$delay_single_quote_subst"`'
+LN_S='`$ECHO "$LN_S" | $SED "$delay_single_quote_subst"`'
+max_cmd_len='`$ECHO "$max_cmd_len" | $SED "$delay_single_quote_subst"`'
+ac_objext='`$ECHO "$ac_objext" | $SED "$delay_single_quote_subst"`'
+exeext='`$ECHO "$exeext" | $SED "$delay_single_quote_subst"`'
+lt_unset='`$ECHO "$lt_unset" | $SED "$delay_single_quote_subst"`'
+lt_SP2NL='`$ECHO "$lt_SP2NL" | $SED "$delay_single_quote_subst"`'
+lt_NL2SP='`$ECHO "$lt_NL2SP" | $SED "$delay_single_quote_subst"`'
+lt_cv_to_host_file_cmd='`$ECHO "$lt_cv_to_host_file_cmd" | $SED "$delay_single_quote_subst"`'
+lt_cv_to_tool_file_cmd='`$ECHO "$lt_cv_to_tool_file_cmd" | $SED "$delay_single_quote_subst"`'
+reload_flag='`$ECHO "$reload_flag" | $SED "$delay_single_quote_subst"`'
+reload_cmds='`$ECHO "$reload_cmds" | $SED "$delay_single_quote_subst"`'
+deplibs_check_method='`$ECHO "$deplibs_check_method" | $SED "$delay_single_quote_subst"`'
+file_magic_cmd='`$ECHO "$file_magic_cmd" | $SED "$delay_single_quote_subst"`'
+file_magic_glob='`$ECHO "$file_magic_glob" | $SED "$delay_single_quote_subst"`'
+want_nocaseglob='`$ECHO "$want_nocaseglob" | $SED "$delay_single_quote_subst"`'
+sharedlib_from_linklib_cmd='`$ECHO "$sharedlib_from_linklib_cmd" | $SED "$delay_single_quote_subst"`'
+AR='`$ECHO "$AR" | $SED "$delay_single_quote_subst"`'
+AR_FLAGS='`$ECHO "$AR_FLAGS" | $SED "$delay_single_quote_subst"`'
+archiver_list_spec='`$ECHO "$archiver_list_spec" | $SED "$delay_single_quote_subst"`'
+STRIP='`$ECHO "$STRIP" | $SED "$delay_single_quote_subst"`'
+RANLIB='`$ECHO "$RANLIB" | $SED "$delay_single_quote_subst"`'
+old_postinstall_cmds='`$ECHO "$old_postinstall_cmds" | $SED "$delay_single_quote_subst"`'
+old_postuninstall_cmds='`$ECHO "$old_postuninstall_cmds" | $SED "$delay_single_quote_subst"`'
+old_archive_cmds='`$ECHO "$old_archive_cmds" | $SED "$delay_single_quote_subst"`'
+lock_old_archive_extraction='`$ECHO "$lock_old_archive_extraction" | $SED "$delay_single_quote_subst"`'
+CC='`$ECHO "$CC" | $SED "$delay_single_quote_subst"`'
+CFLAGS='`$ECHO "$CFLAGS" | $SED "$delay_single_quote_subst"`'
+compiler='`$ECHO "$compiler" | $SED "$delay_single_quote_subst"`'
+GCC='`$ECHO "$GCC" | $SED "$delay_single_quote_subst"`'
+lt_cv_sys_global_symbol_pipe='`$ECHO "$lt_cv_sys_global_symbol_pipe" | $SED "$delay_single_quote_subst"`'
+lt_cv_sys_global_symbol_to_cdecl='`$ECHO "$lt_cv_sys_global_symbol_to_cdecl" | $SED "$delay_single_quote_subst"`'
+lt_cv_sys_global_symbol_to_import='`$ECHO "$lt_cv_sys_global_symbol_to_import" | $SED "$delay_single_quote_subst"`'
+lt_cv_sys_global_symbol_to_c_name_address='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address" | $SED "$delay_single_quote_subst"`'
+lt_cv_sys_global_symbol_to_c_name_address_lib_prefix='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address_lib_prefix" | $SED "$delay_single_quote_subst"`'
+lt_cv_nm_interface='`$ECHO "$lt_cv_nm_interface" | $SED "$delay_single_quote_subst"`'
+nm_file_list_spec='`$ECHO "$nm_file_list_spec" | $SED "$delay_single_quote_subst"`'
+lt_sysroot='`$ECHO "$lt_sysroot" | $SED "$delay_single_quote_subst"`'
+lt_cv_truncate_bin='`$ECHO "$lt_cv_truncate_bin" | $SED "$delay_single_quote_subst"`'
+objdir='`$ECHO "$objdir" | $SED "$delay_single_quote_subst"`'
+MAGIC_CMD='`$ECHO "$MAGIC_CMD" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_no_builtin_flag='`$ECHO "$lt_prog_compiler_no_builtin_flag" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_pic='`$ECHO "$lt_prog_compiler_pic" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_wl='`$ECHO "$lt_prog_compiler_wl" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_static='`$ECHO "$lt_prog_compiler_static" | $SED "$delay_single_quote_subst"`'
+lt_cv_prog_compiler_c_o='`$ECHO "$lt_cv_prog_compiler_c_o" | $SED "$delay_single_quote_subst"`'
+need_locks='`$ECHO "$need_locks" | $SED "$delay_single_quote_subst"`'
+MANIFEST_TOOL='`$ECHO "$MANIFEST_TOOL" | $SED "$delay_single_quote_subst"`'
+DSYMUTIL='`$ECHO "$DSYMUTIL" | $SED "$delay_single_quote_subst"`'
+NMEDIT='`$ECHO "$NMEDIT" | $SED "$delay_single_quote_subst"`'
+LIPO='`$ECHO "$LIPO" | $SED "$delay_single_quote_subst"`'
+OTOOL='`$ECHO "$OTOOL" | $SED "$delay_single_quote_subst"`'
+OTOOL64='`$ECHO "$OTOOL64" | $SED "$delay_single_quote_subst"`'
+libext='`$ECHO "$libext" | $SED "$delay_single_quote_subst"`'
+shrext_cmds='`$ECHO "$shrext_cmds" | $SED "$delay_single_quote_subst"`'
+extract_expsyms_cmds='`$ECHO "$extract_expsyms_cmds" | $SED "$delay_single_quote_subst"`'
+archive_cmds_need_lc='`$ECHO "$archive_cmds_need_lc" | $SED "$delay_single_quote_subst"`'
+enable_shared_with_static_runtimes='`$ECHO "$enable_shared_with_static_runtimes" | $SED "$delay_single_quote_subst"`'
+export_dynamic_flag_spec='`$ECHO "$export_dynamic_flag_spec" | $SED "$delay_single_quote_subst"`'
+whole_archive_flag_spec='`$ECHO "$whole_archive_flag_spec" | $SED "$delay_single_quote_subst"`'
+compiler_needs_object='`$ECHO "$compiler_needs_object" | $SED "$delay_single_quote_subst"`'
+old_archive_from_new_cmds='`$ECHO "$old_archive_from_new_cmds" | $SED "$delay_single_quote_subst"`'
+old_archive_from_expsyms_cmds='`$ECHO "$old_archive_from_expsyms_cmds" | $SED "$delay_single_quote_subst"`'
+archive_cmds='`$ECHO "$archive_cmds" | $SED "$delay_single_quote_subst"`'
+archive_expsym_cmds='`$ECHO "$archive_expsym_cmds" | $SED "$delay_single_quote_subst"`'
+module_cmds='`$ECHO "$module_cmds" | $SED "$delay_single_quote_subst"`'
+module_expsym_cmds='`$ECHO "$module_expsym_cmds" | $SED "$delay_single_quote_subst"`'
+with_gnu_ld='`$ECHO "$with_gnu_ld" | $SED "$delay_single_quote_subst"`'
+allow_undefined_flag='`$ECHO "$allow_undefined_flag" | $SED "$delay_single_quote_subst"`'
+no_undefined_flag='`$ECHO "$no_undefined_flag" | $SED "$delay_single_quote_subst"`'
+hardcode_libdir_flag_spec='`$ECHO "$hardcode_libdir_flag_spec" | $SED "$delay_single_quote_subst"`'
+hardcode_libdir_separator='`$ECHO "$hardcode_libdir_separator" | $SED "$delay_single_quote_subst"`'
+hardcode_direct='`$ECHO "$hardcode_direct" | $SED "$delay_single_quote_subst"`'
+hardcode_direct_absolute='`$ECHO "$hardcode_direct_absolute" | $SED "$delay_single_quote_subst"`'
+hardcode_minus_L='`$ECHO "$hardcode_minus_L" | $SED "$delay_single_quote_subst"`'
+hardcode_shlibpath_var='`$ECHO "$hardcode_shlibpath_var" | $SED "$delay_single_quote_subst"`'
+hardcode_automatic='`$ECHO "$hardcode_automatic" | $SED "$delay_single_quote_subst"`'
+inherit_rpath='`$ECHO "$inherit_rpath" | $SED "$delay_single_quote_subst"`'
+link_all_deplibs='`$ECHO "$link_all_deplibs" | $SED "$delay_single_quote_subst"`'
+always_export_symbols='`$ECHO "$always_export_symbols" | $SED "$delay_single_quote_subst"`'
+export_symbols_cmds='`$ECHO "$export_symbols_cmds" | $SED "$delay_single_quote_subst"`'
+exclude_expsyms='`$ECHO "$exclude_expsyms" | $SED "$delay_single_quote_subst"`'
+include_expsyms='`$ECHO "$include_expsyms" | $SED "$delay_single_quote_subst"`'
+prelink_cmds='`$ECHO "$prelink_cmds" | $SED "$delay_single_quote_subst"`'
+postlink_cmds='`$ECHO "$postlink_cmds" | $SED "$delay_single_quote_subst"`'
+file_list_spec='`$ECHO "$file_list_spec" | $SED "$delay_single_quote_subst"`'
+variables_saved_for_relink='`$ECHO "$variables_saved_for_relink" | $SED "$delay_single_quote_subst"`'
+need_lib_prefix='`$ECHO "$need_lib_prefix" | $SED "$delay_single_quote_subst"`'
+need_version='`$ECHO "$need_version" | $SED "$delay_single_quote_subst"`'
+version_type='`$ECHO "$version_type" | $SED "$delay_single_quote_subst"`'
+runpath_var='`$ECHO "$runpath_var" | $SED "$delay_single_quote_subst"`'
+shlibpath_var='`$ECHO "$shlibpath_var" | $SED "$delay_single_quote_subst"`'
+shlibpath_overrides_runpath='`$ECHO "$shlibpath_overrides_runpath" | $SED "$delay_single_quote_subst"`'
+libname_spec='`$ECHO "$libname_spec" | $SED "$delay_single_quote_subst"`'
+library_names_spec='`$ECHO "$library_names_spec" | $SED "$delay_single_quote_subst"`'
+soname_spec='`$ECHO "$soname_spec" | $SED "$delay_single_quote_subst"`'
+install_override_mode='`$ECHO "$install_override_mode" | $SED "$delay_single_quote_subst"`'
+postinstall_cmds='`$ECHO "$postinstall_cmds" | $SED "$delay_single_quote_subst"`'
+postuninstall_cmds='`$ECHO "$postuninstall_cmds" | $SED "$delay_single_quote_subst"`'
+finish_cmds='`$ECHO "$finish_cmds" | $SED "$delay_single_quote_subst"`'
+finish_eval='`$ECHO "$finish_eval" | $SED "$delay_single_quote_subst"`'
+hardcode_into_libs='`$ECHO "$hardcode_into_libs" | $SED "$delay_single_quote_subst"`'
+sys_lib_search_path_spec='`$ECHO "$sys_lib_search_path_spec" | $SED "$delay_single_quote_subst"`'
+configure_time_dlsearch_path='`$ECHO "$configure_time_dlsearch_path" | $SED "$delay_single_quote_subst"`'
+configure_time_lt_sys_library_path='`$ECHO "$configure_time_lt_sys_library_path" | $SED "$delay_single_quote_subst"`'
+hardcode_action='`$ECHO "$hardcode_action" | $SED "$delay_single_quote_subst"`'
+enable_dlopen='`$ECHO "$enable_dlopen" | $SED "$delay_single_quote_subst"`'
+enable_dlopen_self='`$ECHO "$enable_dlopen_self" | $SED "$delay_single_quote_subst"`'
+enable_dlopen_self_static='`$ECHO "$enable_dlopen_self_static" | $SED "$delay_single_quote_subst"`'
+old_striplib='`$ECHO "$old_striplib" | $SED "$delay_single_quote_subst"`'
+striplib='`$ECHO "$striplib" | $SED "$delay_single_quote_subst"`'
+
+LTCC='$LTCC'
+LTCFLAGS='$LTCFLAGS'
+compiler='$compiler_DEFAULT'
+
+# A function that is used when there is no print builtin or printf.
+func_fallback_echo ()
+{
+  eval 'cat <<_LTECHO_EOF
+\$1
+_LTECHO_EOF'
+}
+
+# Quote evaled strings.
+for var in SED \
+GREP \
+EGREP \
+FGREP \
+SHELL \
+ECHO \
+LD \
+AS \
+DLLTOOL \
+OBJDUMP \
+PATH_SEPARATOR \
+NM \
+LN_S \
+lt_SP2NL \
+lt_NL2SP \
+reload_flag \
+deplibs_check_method \
+file_magic_cmd \
+file_magic_glob \
+want_nocaseglob \
+sharedlib_from_linklib_cmd \
+AR \
+AR_FLAGS \
+archiver_list_spec \
+STRIP \
+RANLIB \
+CC \
+CFLAGS \
+compiler \
+lt_cv_sys_global_symbol_pipe \
+lt_cv_sys_global_symbol_to_cdecl \
+lt_cv_sys_global_symbol_to_import \
+lt_cv_sys_global_symbol_to_c_name_address \
+lt_cv_sys_global_symbol_to_c_name_address_lib_prefix \
+lt_cv_nm_interface \
+nm_file_list_spec \
+lt_cv_truncate_bin \
+lt_prog_compiler_no_builtin_flag \
+lt_prog_compiler_pic \
+lt_prog_compiler_wl \
+lt_prog_compiler_static \
+lt_cv_prog_compiler_c_o \
+need_locks \
+MANIFEST_TOOL \
+DSYMUTIL \
+NMEDIT \
+LIPO \
+OTOOL \
+OTOOL64 \
+shrext_cmds \
+export_dynamic_flag_spec \
+whole_archive_flag_spec \
+compiler_needs_object \
+with_gnu_ld \
+allow_undefined_flag \
+no_undefined_flag \
+hardcode_libdir_flag_spec \
+hardcode_libdir_separator \
+exclude_expsyms \
+include_expsyms \
+file_list_spec \
+variables_saved_for_relink \
+libname_spec \
+library_names_spec \
+soname_spec \
+install_override_mode \
+finish_eval \
+old_striplib \
+striplib; do
+    case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
+    *[\\\\\\\`\\"\\\$]*)
+      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes
+      ;;
+    *)
+      eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
+      ;;
+    esac
+done
+
+# Double-quote double-evaled strings.
+for var in reload_cmds \
+old_postinstall_cmds \
+old_postuninstall_cmds \
+old_archive_cmds \
+extract_expsyms_cmds \
+old_archive_from_new_cmds \
+old_archive_from_expsyms_cmds \
+archive_cmds \
+archive_expsym_cmds \
+module_cmds \
+module_expsym_cmds \
+export_symbols_cmds \
+prelink_cmds \
+postlink_cmds \
+postinstall_cmds \
+postuninstall_cmds \
+finish_cmds \
+sys_lib_search_path_spec \
+configure_time_dlsearch_path \
+configure_time_lt_sys_library_path; do
+    case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
+    *[\\\\\\\`\\"\\\$]*)
+      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes
+      ;;
+    *)
+      eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
+      ;;
+    esac
+done
+
+ac_aux_dir='$ac_aux_dir'
+
+# See if we are running on zsh, and set the options that allow our
+# commands through without removal of \ escapes INIT.
+if test -n "\${ZSH_VERSION+set}"; then
+   setopt NO_GLOB_SUBST
+fi
+
+
+    PACKAGE='$PACKAGE'
+    VERSION='$VERSION'
+    RM='$RM'
+    ofile='$ofile'
+
+
+
+
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+
+# Handling of arguments.
+for ac_config_target in $ac_config_targets
+do
+  case $ac_config_target in
+    "config.h") CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;
+    "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
+    "libtool") CONFIG_COMMANDS="$CONFIG_COMMANDS libtool" ;;
+    "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
+    "libpng.pc") CONFIG_FILES="$CONFIG_FILES libpng.pc:libpng.pc.in" ;;
+    "libpng-config") CONFIG_FILES="$CONFIG_FILES libpng-config:libpng-config.in" ;;
+
+  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
+  esac
+done
+
+
+# If the user did not use the arguments to specify the items to instantiate,
+# then the envvar interface is used.  Set only those that are not.
+# We use the long form for the default assignment because of an extremely
+# bizarre bug on SunOS 4.1.3.
+if $ac_need_defaults; then
+  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
+  test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
+  test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands
+fi
+
+# Have a temporary directory for convenience.  Make it in the build tree
+# simply because there is no reason against having it here, and in addition,
+# creating and moving files from /tmp can sometimes cause problems.
+# Hook for its removal unless debugging.
+# Note that there is a small window in which the directory will not be cleaned:
+# after its creation but before its name has been assigned to `$tmp'.
+$debug ||
+{
+  tmp= ac_tmp=
+  trap 'exit_status=$?
+  : "${ac_tmp:=$tmp}"
+  { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status
+' 0
+  trap 'as_fn_exit 1' 1 2 13 15
+}
+# Create a (secure) tmp directory for tmp files.
+
+{
+  tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
+  test -d "$tmp"
+}  ||
+{
+  tmp=./conf$$-$RANDOM
+  (umask 077 && mkdir "$tmp")
+} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5
+ac_tmp=$tmp
+
+# Set up the scripts for CONFIG_FILES section.
+# No need to generate them if there are no CONFIG_FILES.
+# This happens for instance with `./config.status config.h'.
+if test -n "$CONFIG_FILES"; then
+
+
+ac_cr=`echo X | tr X '\015'`
+# On cygwin, bash can eat \r inside `` if the user requested igncr.
+# But we know of no other shell where ac_cr would be empty at this
+# point, so we can use a bashism as a fallback.
+if test "x$ac_cr" = x; then
+  eval ac_cr=\$\'\\r\'
+fi
+ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null`
+if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
+  ac_cs_awk_cr='\\r'
+else
+  ac_cs_awk_cr=$ac_cr
+fi
+
+echo 'BEGIN {' >"$ac_tmp/subs1.awk" &&
+_ACEOF
+
+
+{
+  echo "cat >conf$$subs.awk <<_ACEOF" &&
+  echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' &&
+  echo "_ACEOF"
+} >conf$$subs.sh ||
+  as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
+ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'`
+ac_delim='%!_!# '
+for ac_last_try in false false false false false :; do
+  . ./conf$$subs.sh ||
+    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
+
+  ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`
+  if test $ac_delim_n = $ac_delim_num; then
+    break
+  elif $ac_last_try; then
+    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
+  else
+    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
+  fi
+done
+rm -f conf$$subs.sh
+
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK &&
+_ACEOF
+sed -n '
+h
+s/^/S["/; s/!.*/"]=/
+p
+g
+s/^[^!]*!//
+:repl
+t repl
+s/'"$ac_delim"'$//
+t delim
+:nl
+h
+s/\(.\{148\}\)..*/\1/
+t more1
+s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/
+p
+n
+b repl
+:more1
+s/["\\]/\\&/g; s/^/"/; s/$/"\\/
+p
+g
+s/.\{148\}//
+t nl
+:delim
+h
+s/\(.\{148\}\)..*/\1/
+t more2
+s/["\\]/\\&/g; s/^/"/; s/$/"/
+p
+b
+:more2
+s/["\\]/\\&/g; s/^/"/; s/$/"\\/
+p
+g
+s/.\{148\}//
+t delim
+' <conf$$subs.awk | sed '
+/^[^""]/{
+  N
+  s/\n//
+}
+' >>$CONFIG_STATUS || ac_write_fail=1
+rm -f conf$$subs.awk
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+_ACAWK
+cat >>"\$ac_tmp/subs1.awk" <<_ACAWK &&
+  for (key in S) S_is_set[key] = 1
+  FS = ""
+
+}
+{
+  line = $ 0
+  nfields = split(line, field, "@")
+  substed = 0
+  len = length(field[1])
+  for (i = 2; i < nfields; i++) {
+    key = field[i]
+    keylen = length(key)
+    if (S_is_set[key]) {
+      value = S[key]
+      line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3)
+      len += length(value) + length(field[++i])
+      substed = 1
+    } else
+      len += 1 + keylen
+  }
+
+  print line
+}
+
+_ACAWK
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then
+  sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
+else
+  cat
+fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \
+  || as_fn_error $? "could not setup config files machinery" "$LINENO" 5
+_ACEOF
+
+# VPATH may cause trouble with some makes, so we remove sole $(srcdir),
+# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and
+# trailing colons and then remove the whole line if VPATH becomes empty
+# (actually we leave an empty line to preserve line numbers).
+if test "x$srcdir" = x.; then
+  ac_vpsub='/^[	 ]*VPATH[	 ]*=[	 ]*/{
+h
+s///
+s/^/:/
+s/[	 ]*$/:/
+s/:\$(srcdir):/:/g
+s/:\${srcdir}:/:/g
+s/:@srcdir@:/:/g
+s/^:*//
+s/:*$//
+x
+s/\(=[	 ]*\).*/\1/
+G
+s/\n//
+s/^[^=]*=[	 ]*$//
+}'
+fi
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+fi # test -n "$CONFIG_FILES"
+
+# Set up the scripts for CONFIG_HEADERS section.
+# No need to generate them if there are no CONFIG_HEADERS.
+# This happens for instance with `./config.status Makefile'.
+if test -n "$CONFIG_HEADERS"; then
+cat >"$ac_tmp/defines.awk" <<\_ACAWK ||
+BEGIN {
+_ACEOF
+
+# Transform confdefs.h into an awk script `defines.awk', embedded as
+# here-document in config.status, that substitutes the proper values into
+# config.h.in to produce config.h.
+
+# Create a delimiter string that does not exist in confdefs.h, to ease
+# handling of long lines.
+ac_delim='%!_!# '
+for ac_last_try in false false :; do
+  ac_tt=`sed -n "/$ac_delim/p" confdefs.h`
+  if test -z "$ac_tt"; then
+    break
+  elif $ac_last_try; then
+    as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5
+  else
+    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
+  fi
+done
+
+# For the awk script, D is an array of macro values keyed by name,
+# likewise P contains macro parameters if any.  Preserve backslash
+# newline sequences.
+
+ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]*
+sed -n '
+s/.\{148\}/&'"$ac_delim"'/g
+t rset
+:rset
+s/^[	 ]*#[	 ]*define[	 ][	 ]*/ /
+t def
+d
+:def
+s/\\$//
+t bsnl
+s/["\\]/\\&/g
+s/^ \('"$ac_word_re"'\)\(([^()]*)\)[	 ]*\(.*\)/P["\1"]="\2"\
+D["\1"]=" \3"/p
+s/^ \('"$ac_word_re"'\)[	 ]*\(.*\)/D["\1"]=" \2"/p
+d
+:bsnl
+s/["\\]/\\&/g
+s/^ \('"$ac_word_re"'\)\(([^()]*)\)[	 ]*\(.*\)/P["\1"]="\2"\
+D["\1"]=" \3\\\\\\n"\\/p
+t cont
+s/^ \('"$ac_word_re"'\)[	 ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p
+t cont
+d
+:cont
+n
+s/.\{148\}/&'"$ac_delim"'/g
+t clear
+:clear
+s/\\$//
+t bsnlc
+s/["\\]/\\&/g; s/^/"/; s/$/"/p
+d
+:bsnlc
+s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p
+b cont
+' <confdefs.h | sed '
+s/'"$ac_delim"'/"\\\
+"/g' >>$CONFIG_STATUS || ac_write_fail=1
+
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+  for (key in D) D_is_set[key] = 1
+  FS = ""
+}
+/^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ {
+  line = \$ 0
+  split(line, arg, " ")
+  if (arg[1] == "#") {
+    defundef = arg[2]
+    mac1 = arg[3]
+  } else {
+    defundef = substr(arg[1], 2)
+    mac1 = arg[2]
+  }
+  split(mac1, mac2, "(") #)
+  macro = mac2[1]
+  prefix = substr(line, 1, index(line, defundef) - 1)
+  if (D_is_set[macro]) {
+    # Preserve the white space surrounding the "#".
+    print prefix "define", macro P[macro] D[macro]
+    next
+  } else {
+    # Replace #undef with comments.  This is necessary, for example,
+    # in the case of _POSIX_SOURCE, which is predefined and required
+    # on some systems where configure will not decide to define it.
+    if (defundef == "undef") {
+      print "/*", prefix defundef, macro, "*/"
+      next
+    }
+  }
+}
+{ print }
+_ACAWK
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+  as_fn_error $? "could not setup config headers machinery" "$LINENO" 5
+fi # test -n "$CONFIG_HEADERS"
+
+
+eval set X "  :F $CONFIG_FILES  :H $CONFIG_HEADERS    :C $CONFIG_COMMANDS"
+shift
+for ac_tag
+do
+  case $ac_tag in
+  :[FHLC]) ac_mode=$ac_tag; continue;;
+  esac
+  case $ac_mode$ac_tag in
+  :[FHL]*:*);;
+  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
+  :[FH]-) ac_tag=-:-;;
+  :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
+  esac
+  ac_save_IFS=$IFS
+  IFS=:
+  set x $ac_tag
+  IFS=$ac_save_IFS
+  shift
+  ac_file=$1
+  shift
+
+  case $ac_mode in
+  :L) ac_source=$1;;
+  :[FH])
+    ac_file_inputs=
+    for ac_f
+    do
+      case $ac_f in
+      -) ac_f="$ac_tmp/stdin";;
+      *) # Look for the file first in the build tree, then in the source tree
+	 # (if the path is not absolute).  The absolute path cannot be DOS-style,
+	 # because $ac_f cannot contain `:'.
+	 test -f "$ac_f" ||
+	   case $ac_f in
+	   [\\/$]*) false;;
+	   *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
+	   esac ||
+	   as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
+      esac
+      case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
+      as_fn_append ac_file_inputs " '$ac_f'"
+    done
+
+    # Let's still pretend it is `configure' which instantiates (i.e., don't
+    # use $as_me), people would be surprised to read:
+    #    /* config.h.  Generated by config.status.  */
+    configure_input='Generated from '`
+	  $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
+	`' by configure.'
+    if test x"$ac_file" != x-; then
+      configure_input="$ac_file.  $configure_input"
+      { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
+$as_echo "$as_me: creating $ac_file" >&6;}
+    fi
+    # Neutralize special characters interpreted by sed in replacement strings.
+    case $configure_input in #(
+    *\&* | *\|* | *\\* )
+       ac_sed_conf_input=`$as_echo "$configure_input" |
+       sed 's/[\\\\&|]/\\\\&/g'`;; #(
+    *) ac_sed_conf_input=$configure_input;;
+    esac
+
+    case $ac_tag in
+    *:-:* | *:-) cat >"$ac_tmp/stdin" \
+      || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
+    esac
+    ;;
+  esac
+
+  ac_dir=`$as_dirname -- "$ac_file" ||
+$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$ac_file" : 'X\(//\)[^/]' \| \
+	 X"$ac_file" : 'X\(//\)$' \| \
+	 X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$ac_file" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+  as_dir="$ac_dir"; as_fn_mkdir_p
+  ac_builddir=.
+
+case "$ac_dir" in
+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
+*)
+  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
+  # A ".." for each directory in $ac_dir_suffix.
+  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
+  case $ac_top_builddir_sub in
+  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
+  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
+  esac ;;
+esac
+ac_abs_top_builddir=$ac_pwd
+ac_abs_builddir=$ac_pwd$ac_dir_suffix
+# for backward compatibility:
+ac_top_builddir=$ac_top_build_prefix
+
+case $srcdir in
+  .)  # We are building in place.
+    ac_srcdir=.
+    ac_top_srcdir=$ac_top_builddir_sub
+    ac_abs_top_srcdir=$ac_pwd ;;
+  [\\/]* | ?:[\\/]* )  # Absolute name.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir
+    ac_abs_top_srcdir=$srcdir ;;
+  *) # Relative name.
+    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_build_prefix$srcdir
+    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
+esac
+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+
+
+  case $ac_mode in
+  :F)
+  #
+  # CONFIG_FILE
+  #
+
+  case $INSTALL in
+  [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
+  *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;;
+  esac
+  ac_MKDIR_P=$MKDIR_P
+  case $MKDIR_P in
+  [\\/$]* | ?:[\\/]* ) ;;
+  */*) ac_MKDIR_P=$ac_top_build_prefix$MKDIR_P ;;
+  esac
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# If the template does not know about datarootdir, expand it.
+# FIXME: This hack should be removed a few years after 2.60.
+ac_datarootdir_hack=; ac_datarootdir_seen=
+ac_sed_dataroot='
+/datarootdir/ {
+  p
+  q
+}
+/@datadir@/p
+/@docdir@/p
+/@infodir@/p
+/@localedir@/p
+/@mandir@/p'
+case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
+*datarootdir*) ac_datarootdir_seen=yes;;
+*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
+$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+  ac_datarootdir_hack='
+  s&@datadir@&$datadir&g
+  s&@docdir@&$docdir&g
+  s&@infodir@&$infodir&g
+  s&@localedir@&$localedir&g
+  s&@mandir@&$mandir&g
+  s&\\\${datarootdir}&$datarootdir&g' ;;
+esac
+_ACEOF
+
+# Neutralize VPATH when `$srcdir' = `.'.
+# Shell code in configure.ac might set extrasub.
+# FIXME: do we really want to maintain this feature?
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+ac_sed_extra="$ac_vpsub
+$extrasub
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+:t
+/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
+s|@configure_input@|$ac_sed_conf_input|;t t
+s&@top_builddir@&$ac_top_builddir_sub&;t t
+s&@top_build_prefix@&$ac_top_build_prefix&;t t
+s&@srcdir@&$ac_srcdir&;t t
+s&@abs_srcdir@&$ac_abs_srcdir&;t t
+s&@top_srcdir@&$ac_top_srcdir&;t t
+s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
+s&@builddir@&$ac_builddir&;t t
+s&@abs_builddir@&$ac_abs_builddir&;t t
+s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
+s&@INSTALL@&$ac_INSTALL&;t t
+s&@MKDIR_P@&$ac_MKDIR_P&;t t
+$ac_datarootdir_hack
+"
+eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \
+  >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+
+test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
+  { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
+  { ac_out=`sed -n '/^[	 ]*datarootdir[	 ]*:*=/p' \
+      "$ac_tmp/out"`; test -z "$ac_out"; } &&
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
+which seems to be undefined.  Please make sure it is defined" >&5
+$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
+which seems to be undefined.  Please make sure it is defined" >&2;}
+
+  rm -f "$ac_tmp/stdin"
+  case $ac_file in
+  -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";;
+  *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";;
+  esac \
+  || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+ ;;
+  :H)
+  #
+  # CONFIG_HEADER
+  #
+  if test x"$ac_file" != x-; then
+    {
+      $as_echo "/* $configure_input  */" \
+      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs"
+    } >"$ac_tmp/config.h" \
+      || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+    if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then
+      { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5
+$as_echo "$as_me: $ac_file is unchanged" >&6;}
+    else
+      rm -f "$ac_file"
+      mv "$ac_tmp/config.h" "$ac_file" \
+	|| as_fn_error $? "could not create $ac_file" "$LINENO" 5
+    fi
+  else
+    $as_echo "/* $configure_input  */" \
+      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \
+      || as_fn_error $? "could not create -" "$LINENO" 5
+  fi
+# Compute "$ac_file"'s index in $config_headers.
+_am_arg="$ac_file"
+_am_stamp_count=1
+for _am_header in $config_headers :; do
+  case $_am_header in
+    $_am_arg | $_am_arg:* )
+      break ;;
+    * )
+      _am_stamp_count=`expr $_am_stamp_count + 1` ;;
+  esac
+done
+echo "timestamp for $_am_arg" >`$as_dirname -- "$_am_arg" ||
+$as_expr X"$_am_arg" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$_am_arg" : 'X\(//\)[^/]' \| \
+	 X"$_am_arg" : 'X\(//\)$' \| \
+	 X"$_am_arg" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$_am_arg" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`/stamp-h$_am_stamp_count
+ ;;
+
+  :C)  { $as_echo "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5
+$as_echo "$as_me: executing $ac_file commands" >&6;}
+ ;;
+  esac
+
+
+  case $ac_file$ac_mode in
+    "depfiles":C) test x"$AMDEP_TRUE" != x"" || {
+  # Older Autoconf quotes --file arguments for eval, but not when files
+  # are listed without --file.  Let's play safe and only enable the eval
+  # if we detect the quoting.
+  # TODO: see whether this extra hack can be removed once we start
+  # requiring Autoconf 2.70 or later.
+  case $CONFIG_FILES in #(
+  *\'*) :
+    eval set x "$CONFIG_FILES" ;; #(
+  *) :
+    set x $CONFIG_FILES ;; #(
+  *) :
+     ;;
+esac
+  shift
+  # Used to flag and report bootstrapping failures.
+  am_rc=0
+  for am_mf
+  do
+    # Strip MF so we end up with the name of the file.
+    am_mf=`$as_echo "$am_mf" | sed -e 's/:.*$//'`
+    # Check whether this is an Automake generated Makefile which includes
+    # dependency-tracking related rules and includes.
+    # Grep'ing the whole file directly is not great: AIX grep has a line
+    # limit of 2048, but all sed's we know have understand at least 4000.
+    sed -n 's,^am--depfiles:.*,X,p' "$am_mf" | grep X >/dev/null 2>&1 \
+      || continue
+    am_dirpart=`$as_dirname -- "$am_mf" ||
+$as_expr X"$am_mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$am_mf" : 'X\(//\)[^/]' \| \
+	 X"$am_mf" : 'X\(//\)$' \| \
+	 X"$am_mf" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$am_mf" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+    am_filepart=`$as_basename -- "$am_mf" ||
+$as_expr X/"$am_mf" : '.*/\([^/][^/]*\)/*$' \| \
+	 X"$am_mf" : 'X\(//\)$' \| \
+	 X"$am_mf" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X/"$am_mf" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+    { echo "$as_me:$LINENO: cd "$am_dirpart" \
+      && sed -e '/# am--include-marker/d' "$am_filepart" \
+        | $MAKE -f - am--depfiles" >&5
+   (cd "$am_dirpart" \
+      && sed -e '/# am--include-marker/d' "$am_filepart" \
+        | $MAKE -f - am--depfiles) >&5 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } || am_rc=$?
+  done
+  if test $am_rc -ne 0; then
+    { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "Something went wrong bootstrapping makefile fragments
+    for automatic dependency tracking.  Try re-running configure with the
+    '--disable-dependency-tracking' option to at least be able to build
+    the package (albeit without support for automatic dependency tracking).
+See \`config.log' for more details" "$LINENO" 5; }
+  fi
+  { am_dirpart=; unset am_dirpart;}
+  { am_filepart=; unset am_filepart;}
+  { am_mf=; unset am_mf;}
+  { am_rc=; unset am_rc;}
+  rm -f conftest-deps.mk
+}
+ ;;
+    "libtool":C)
+
+    # See if we are running on zsh, and set the options that allow our
+    # commands through without removal of \ escapes.
+    if test -n "${ZSH_VERSION+set}"; then
+      setopt NO_GLOB_SUBST
+    fi
+
+    cfgfile=${ofile}T
+    trap "$RM \"$cfgfile\"; exit 1" 1 2 15
+    $RM "$cfgfile"
+
+    cat <<_LT_EOF >> "$cfgfile"
+#! $SHELL
+# Generated automatically by $as_me ($PACKAGE) $VERSION
+# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
+# NOTE: Changes made to this file will be lost: look at ltmain.sh.
+
+# Provide generalized library-building support services.
+# Written by Gordon Matzigkeit, 1996
+
+# Copyright (C) 2014 Free Software Foundation, Inc.
+# This is free software; see the source for copying conditions.  There is NO
+# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+# GNU Libtool is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of of the License, or
+# (at your option) any later version.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program or library that is built
+# using GNU Libtool, you may include this file under the  same
+# distribution terms that you use for the rest of that program.
+#
+# GNU Libtool is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+# The names of the tagged configurations supported by this script.
+available_tags=''
+
+# Configured defaults for sys_lib_dlsearch_path munging.
+: \${LT_SYS_LIBRARY_PATH="$configure_time_lt_sys_library_path"}
+
+# ### BEGIN LIBTOOL CONFIG
+
+# A sed program that does not truncate output.
+SED=$lt_SED
+
+# Sed that helps us avoid accidentally triggering echo(1) options like -n.
+Xsed="\$SED -e 1s/^X//"
+
+# A grep program that handles long lines.
+GREP=$lt_GREP
+
+# An ERE matcher.
+EGREP=$lt_EGREP
+
+# A literal string matcher.
+FGREP=$lt_FGREP
+
+# Shell to use when invoking shell scripts.
+SHELL=$lt_SHELL
+
+# An echo program that protects backslashes.
+ECHO=$lt_ECHO
+
+# Which release of libtool.m4 was used?
+macro_version=$macro_version
+macro_revision=$macro_revision
+
+# Assembler program.
+AS=$lt_AS
+
+# DLL creation program.
+DLLTOOL=$lt_DLLTOOL
+
+# Object dumper program.
+OBJDUMP=$lt_OBJDUMP
+
+# Whether or not to build shared libraries.
+build_libtool_libs=$enable_shared
+
+# Whether or not to build static libraries.
+build_old_libs=$enable_static
+
+# What type of objects to build.
+pic_mode=$pic_mode
+
+# Whether or not to optimize for fast installation.
+fast_install=$enable_fast_install
+
+# Shared archive member basename,for filename based shared library versioning on AIX.
+shared_archive_member_spec=$shared_archive_member_spec
+
+# The PATH separator for the build system.
+PATH_SEPARATOR=$lt_PATH_SEPARATOR
+
+# The host system.
+host_alias=$host_alias
+host=$host
+host_os=$host_os
+
+# The build system.
+build_alias=$build_alias
+build=$build
+build_os=$build_os
+
+# A BSD- or MS-compatible name lister.
+NM=$lt_NM
+
+# Whether we need soft or hard links.
+LN_S=$lt_LN_S
+
+# What is the maximum length of a command?
+max_cmd_len=$max_cmd_len
+
+# Object file suffix (normally "o").
+objext=$ac_objext
+
+# Executable file suffix (normally "").
+exeext=$exeext
+
+# whether the shell understands "unset".
+lt_unset=$lt_unset
+
+# turn spaces into newlines.
+SP2NL=$lt_lt_SP2NL
+
+# turn newlines into spaces.
+NL2SP=$lt_lt_NL2SP
+
+# convert \$build file names to \$host format.
+to_host_file_cmd=$lt_cv_to_host_file_cmd
+
+# convert \$build files to toolchain format.
+to_tool_file_cmd=$lt_cv_to_tool_file_cmd
+
+# Method to check whether dependent libraries are shared objects.
+deplibs_check_method=$lt_deplibs_check_method
+
+# Command to use when deplibs_check_method = "file_magic".
+file_magic_cmd=$lt_file_magic_cmd
+
+# How to find potential files when deplibs_check_method = "file_magic".
+file_magic_glob=$lt_file_magic_glob
+
+# Find potential files using nocaseglob when deplibs_check_method = "file_magic".
+want_nocaseglob=$lt_want_nocaseglob
+
+# Command to associate shared and link libraries.
+sharedlib_from_linklib_cmd=$lt_sharedlib_from_linklib_cmd
+
+# The archiver.
+AR=$lt_AR
+
+# Flags to create an archive.
+AR_FLAGS=$lt_AR_FLAGS
+
+# How to feed a file listing to the archiver.
+archiver_list_spec=$lt_archiver_list_spec
+
+# A symbol stripping program.
+STRIP=$lt_STRIP
+
+# Commands used to install an old-style archive.
+RANLIB=$lt_RANLIB
+old_postinstall_cmds=$lt_old_postinstall_cmds
+old_postuninstall_cmds=$lt_old_postuninstall_cmds
+
+# Whether to use a lock for old archive extraction.
+lock_old_archive_extraction=$lock_old_archive_extraction
+
+# A C compiler.
+LTCC=$lt_CC
+
+# LTCC compiler flags.
+LTCFLAGS=$lt_CFLAGS
+
+# Take the output of nm and produce a listing of raw symbols and C names.
+global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe
+
+# Transform the output of nm in a proper C declaration.
+global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl
+
+# Transform the output of nm into a list of symbols to manually relocate.
+global_symbol_to_import=$lt_lt_cv_sys_global_symbol_to_import
+
+# Transform the output of nm in a C name address pair.
+global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address
+
+# Transform the output of nm in a C name address pair when lib prefix is needed.
+global_symbol_to_c_name_address_lib_prefix=$lt_lt_cv_sys_global_symbol_to_c_name_address_lib_prefix
+
+# The name lister interface.
+nm_interface=$lt_lt_cv_nm_interface
+
+# Specify filename containing input files for \$NM.
+nm_file_list_spec=$lt_nm_file_list_spec
+
+# The root where to search for dependent libraries,and where our libraries should be installed.
+lt_sysroot=$lt_sysroot
+
+# Command to truncate a binary pipe.
+lt_truncate_bin=$lt_lt_cv_truncate_bin
+
+# The name of the directory that contains temporary libtool files.
+objdir=$objdir
+
+# Used to examine libraries when file_magic_cmd begins with "file".
+MAGIC_CMD=$MAGIC_CMD
+
+# Must we lock files when doing compilation?
+need_locks=$lt_need_locks
+
+# Manifest tool.
+MANIFEST_TOOL=$lt_MANIFEST_TOOL
+
+# Tool to manipulate archived DWARF debug symbol files on Mac OS X.
+DSYMUTIL=$lt_DSYMUTIL
+
+# Tool to change global to local symbols on Mac OS X.
+NMEDIT=$lt_NMEDIT
+
+# Tool to manipulate fat objects and archives on Mac OS X.
+LIPO=$lt_LIPO
+
+# ldd/readelf like tool for Mach-O binaries on Mac OS X.
+OTOOL=$lt_OTOOL
+
+# ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4.
+OTOOL64=$lt_OTOOL64
+
+# Old archive suffix (normally "a").
+libext=$libext
+
+# Shared library suffix (normally ".so").
+shrext_cmds=$lt_shrext_cmds
+
+# The commands to extract the exported symbol list from a shared archive.
+extract_expsyms_cmds=$lt_extract_expsyms_cmds
+
+# Variables whose values should be saved in libtool wrapper scripts and
+# restored at link time.
+variables_saved_for_relink=$lt_variables_saved_for_relink
+
+# Do we need the "lib" prefix for modules?
+need_lib_prefix=$need_lib_prefix
+
+# Do we need a version for libraries?
+need_version=$need_version
+
+# Library versioning type.
+version_type=$version_type
+
+# Shared library runtime path variable.
+runpath_var=$runpath_var
+
+# Shared library path variable.
+shlibpath_var=$shlibpath_var
+
+# Is shlibpath searched before the hard-coded library search path?
+shlibpath_overrides_runpath=$shlibpath_overrides_runpath
+
+# Format of library name prefix.
+libname_spec=$lt_libname_spec
+
+# List of archive names.  First name is the real one, the rest are links.
+# The last name is the one that the linker finds with -lNAME
+library_names_spec=$lt_library_names_spec
+
+# The coded name of the library, if different from the real name.
+soname_spec=$lt_soname_spec
+
+# Permission mode override for installation of shared libraries.
+install_override_mode=$lt_install_override_mode
+
+# Command to use after installation of a shared archive.
+postinstall_cmds=$lt_postinstall_cmds
+
+# Command to use after uninstallation of a shared archive.
+postuninstall_cmds=$lt_postuninstall_cmds
+
+# Commands used to finish a libtool library installation in a directory.
+finish_cmds=$lt_finish_cmds
+
+# As "finish_cmds", except a single script fragment to be evaled but
+# not shown.
+finish_eval=$lt_finish_eval
+
+# Whether we should hardcode library paths into libraries.
+hardcode_into_libs=$hardcode_into_libs
+
+# Compile-time system search path for libraries.
+sys_lib_search_path_spec=$lt_sys_lib_search_path_spec
+
+# Detected run-time system search path for libraries.
+sys_lib_dlsearch_path_spec=$lt_configure_time_dlsearch_path
+
+# Explicit LT_SYS_LIBRARY_PATH set during ./configure time.
+configure_time_lt_sys_library_path=$lt_configure_time_lt_sys_library_path
+
+# Whether dlopen is supported.
+dlopen_support=$enable_dlopen
+
+# Whether dlopen of programs is supported.
+dlopen_self=$enable_dlopen_self
+
+# Whether dlopen of statically linked programs is supported.
+dlopen_self_static=$enable_dlopen_self_static
+
+# Commands to strip libraries.
+old_striplib=$lt_old_striplib
+striplib=$lt_striplib
+
+
+# The linker used to build libraries.
+LD=$lt_LD
+
+# How to create reloadable object files.
+reload_flag=$lt_reload_flag
+reload_cmds=$lt_reload_cmds
+
+# Commands used to build an old-style archive.
+old_archive_cmds=$lt_old_archive_cmds
+
+# A language specific compiler.
+CC=$lt_compiler
+
+# Is the compiler the GNU compiler?
+with_gcc=$GCC
+
+# Compiler flag to turn off builtin functions.
+no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag
+
+# Additional compiler flags for building library objects.
+pic_flag=$lt_lt_prog_compiler_pic
+
+# How to pass a linker flag through the compiler.
+wl=$lt_lt_prog_compiler_wl
+
+# Compiler flag to prevent dynamic linking.
+link_static_flag=$lt_lt_prog_compiler_static
+
+# Does compiler simultaneously support -c and -o options?
+compiler_c_o=$lt_lt_cv_prog_compiler_c_o
+
+# Whether or not to add -lc for building shared libraries.
+build_libtool_need_lc=$archive_cmds_need_lc
+
+# Whether or not to disallow shared libs when runtime libs are static.
+allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes
+
+# Compiler flag to allow reflexive dlopens.
+export_dynamic_flag_spec=$lt_export_dynamic_flag_spec
+
+# Compiler flag to generate shared objects directly from archives.
+whole_archive_flag_spec=$lt_whole_archive_flag_spec
+
+# Whether the compiler copes with passing no objects directly.
+compiler_needs_object=$lt_compiler_needs_object
+
+# Create an old-style archive from a shared archive.
+old_archive_from_new_cmds=$lt_old_archive_from_new_cmds
+
+# Create a temporary old-style archive to link instead of a shared archive.
+old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds
+
+# Commands used to build a shared archive.
+archive_cmds=$lt_archive_cmds
+archive_expsym_cmds=$lt_archive_expsym_cmds
+
+# Commands used to build a loadable module if different from building
+# a shared archive.
+module_cmds=$lt_module_cmds
+module_expsym_cmds=$lt_module_expsym_cmds
+
+# Whether we are building with GNU ld or not.
+with_gnu_ld=$lt_with_gnu_ld
+
+# Flag that allows shared libraries with undefined symbols to be built.
+allow_undefined_flag=$lt_allow_undefined_flag
+
+# Flag that enforces no undefined symbols.
+no_undefined_flag=$lt_no_undefined_flag
+
+# Flag to hardcode \$libdir into a binary during linking.
+# This must work even if \$libdir does not exist
+hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec
+
+# Whether we need a single "-rpath" flag with a separated argument.
+hardcode_libdir_separator=$lt_hardcode_libdir_separator
+
+# Set to "yes" if using DIR/libNAME\$shared_ext during linking hardcodes
+# DIR into the resulting binary.
+hardcode_direct=$hardcode_direct
+
+# Set to "yes" if using DIR/libNAME\$shared_ext during linking hardcodes
+# DIR into the resulting binary and the resulting library dependency is
+# "absolute",i.e impossible to change by setting \$shlibpath_var if the
+# library is relocated.
+hardcode_direct_absolute=$hardcode_direct_absolute
+
+# Set to "yes" if using the -LDIR flag during linking hardcodes DIR
+# into the resulting binary.
+hardcode_minus_L=$hardcode_minus_L
+
+# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR
+# into the resulting binary.
+hardcode_shlibpath_var=$hardcode_shlibpath_var
+
+# Set to "yes" if building a shared library automatically hardcodes DIR
+# into the library and all subsequent libraries and executables linked
+# against it.
+hardcode_automatic=$hardcode_automatic
+
+# Set to yes if linker adds runtime paths of dependent libraries
+# to runtime path list.
+inherit_rpath=$inherit_rpath
+
+# Whether libtool must link a program against all its dependency libraries.
+link_all_deplibs=$link_all_deplibs
+
+# Set to "yes" if exported symbols are required.
+always_export_symbols=$always_export_symbols
+
+# The commands to list exported symbols.
+export_symbols_cmds=$lt_export_symbols_cmds
+
+# Symbols that should not be listed in the preloaded symbols.
+exclude_expsyms=$lt_exclude_expsyms
+
+# Symbols that must always be exported.
+include_expsyms=$lt_include_expsyms
+
+# Commands necessary for linking programs (against libraries) with templates.
+prelink_cmds=$lt_prelink_cmds
+
+# Commands necessary for finishing linking programs.
+postlink_cmds=$lt_postlink_cmds
+
+# Specify filename containing input files.
+file_list_spec=$lt_file_list_spec
+
+# How to hardcode a shared library path into an executable.
+hardcode_action=$hardcode_action
+
+# ### END LIBTOOL CONFIG
+
+_LT_EOF
+
+    cat <<'_LT_EOF' >> "$cfgfile"
+
+# ### BEGIN FUNCTIONS SHARED WITH CONFIGURE
+
+# func_munge_path_list VARIABLE PATH
+# -----------------------------------
+# VARIABLE is name of variable containing _space_ separated list of
+# directories to be munged by the contents of PATH, which is string
+# having a format:
+# "DIR[:DIR]:"
+#       string "DIR[ DIR]" will be prepended to VARIABLE
+# ":DIR[:DIR]"
+#       string "DIR[ DIR]" will be appended to VARIABLE
+# "DIRP[:DIRP]::[DIRA:]DIRA"
+#       string "DIRP[ DIRP]" will be prepended to VARIABLE and string
+#       "DIRA[ DIRA]" will be appended to VARIABLE
+# "DIR[:DIR]"
+#       VARIABLE will be replaced by "DIR[ DIR]"
+func_munge_path_list ()
+{
+    case x$2 in
+    x)
+        ;;
+    *:)
+        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\"
+        ;;
+    x:*)
+        eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\"
+        ;;
+    *::*)
+        eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
+        eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
+        ;;
+    *)
+        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\"
+        ;;
+    esac
+}
+
+
+# Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
+func_cc_basename ()
+{
+    for cc_temp in $*""; do
+      case $cc_temp in
+        compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
+        distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
+        \-*) ;;
+        *) break;;
+      esac
+    done
+    func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
+}
+
+
+# ### END FUNCTIONS SHARED WITH CONFIGURE
+
+_LT_EOF
+
+  case $host_os in
+  aix3*)
+    cat <<\_LT_EOF >> "$cfgfile"
+# AIX sometimes has problems with the GCC collect2 program.  For some
+# reason, if we set the COLLECT_NAMES environment variable, the problems
+# vanish in a puff of smoke.
+if test set != "${COLLECT_NAMES+set}"; then
+  COLLECT_NAMES=
+  export COLLECT_NAMES
+fi
+_LT_EOF
+    ;;
+  esac
+
+
+ltmain=$ac_aux_dir/ltmain.sh
+
+
+  # We use sed instead of cat because bash on DJGPP gets confused if
+  # if finds mixed CR/LF and LF-only lines.  Since sed operates in
+  # text mode, it properly converts lines to CR/LF.  This bash problem
+  # is reportedly fixed, but why not run on old versions too?
+  sed '$q' "$ltmain" >> "$cfgfile" \
+     || (rm -f "$cfgfile"; exit 1)
+
+   mv -f "$cfgfile" "$ofile" ||
+    (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile")
+  chmod +x "$ofile"
+
+ ;;
+    "libpng-config":F) chmod +x libpng-config ;;
+
+  esac
+done # for ac_tag
+
+
+as_fn_exit 0
+_ACEOF
+ac_clean_files=$ac_clean_files_save
+
+test $ac_write_fail = 0 ||
+  as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5
+
+
+# configure is writing to config.log, and then calls config.status.
+# config.status does its own redirection, appending to config.log.
+# Unfortunately, on DOS this fails, as config.log is still kept open
+# by configure, so config.status won't be able to write to it; its
+# output is simply discarded.  So we exec the FD to /dev/null,
+# effectively closing config.log, so it can be properly (re)opened and
+# appended to by config.status.  When coming back to configure, we
+# need to make the FD available again.
+if test "$no_create" != yes; then
+  ac_cs_success=:
+  ac_config_status_args=
+  test "$silent" = yes &&
+    ac_config_status_args="$ac_config_status_args --quiet"
+  exec 5>/dev/null
+  $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
+  exec 5>>config.log
+  # Use ||, not &&, to avoid exiting from the if with $? = 1, which
+  # would make configure fail if this is the last instruction.
+  $ac_cs_success || as_fn_exit 1
+fi
+if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
+$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
+fi
+
diff --git a/Engine/lib/lpng/configure.ac b/Engine/lib/lpng/configure.ac
new file mode 100644
index 000000000..52dba94b4
--- /dev/null
+++ b/Engine/lib/lpng/configure.ac
@@ -0,0 +1,532 @@
+# configure.ac
+
+# Copyright (c) 2018 Cosmin Truta
+# Copyright (c) 2004-2016 Glenn Randers-Pehrson
+
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+dnl Process this file with autoconf to produce a configure script.
+dnl
+dnl Minor upgrades (compatible ABI): increment the package version
+dnl (third field in two places below) and set the PNGLIB_RELEASE
+dnl variable.
+dnl
+dnl Major upgrades (incompatible ABI): increment the package major
+dnl version (second field, or first if desired), set the minor
+dnl to 0, set PNGLIB_MAJOR below *and* follow the instructions in
+dnl Makefile.am to upgrade the package name.
+
+dnl This is here to prevent earlier autoconf from being used, it
+dnl should not be necessary to regenerate configure if the time
+dnl stamps are correct
+AC_PREREQ([2.68])
+
+dnl Version number stuff here:
+
+AC_INIT([libpng],[1.6.37],[png-mng-implement@lists.sourceforge.net])
+AC_CONFIG_MACRO_DIR([scripts])
+
+# libpng does not follow GNU file name conventions (hence 'foreign')
+# color-tests requires automake 1.11 or later
+# silent-rules requires automake 1.11 or later
+# dist-xz requires automake 1.11 or later
+# 1.12.2 fixes a security issue in 1.11.2 and 1.12.1
+# 1.13 is required for parallel tests
+AM_INIT_AUTOMAKE([1.13 foreign dist-xz color-tests silent-rules subdir-objects])
+# The following line causes --disable-maintainer-mode to be the default to
+# configure. This is necessary because libpng distributions cannot rely on the
+# time stamps of the autotools generated files being correct
+AM_MAINTAINER_MODE
+
+dnl configure.ac and Makefile.am expect automake 1.11.2 or a compatible later
+dnl version; aclocal.m4 will generate a failure if you use a prior version of
+dnl automake, so the following is not necessary (and is not defined anyway):
+dnl AM_PREREQ([1.11.2])
+dnl stop configure from automagically running automake
+
+PNGLIB_VERSION=1.6.37
+PNGLIB_MAJOR=1
+PNGLIB_MINOR=6
+PNGLIB_RELEASE=37
+
+dnl End of version number stuff
+
+AC_CONFIG_SRCDIR([pngget.c])
+AC_CONFIG_HEADERS([config.h])
+
+# Checks for programs.
+AC_LANG([C])
+AC_PROG_CC
+AM_PROG_AS
+LT_PATH_LD
+AC_PROG_CPP
+AC_PROG_AWK
+AC_PROG_INSTALL
+AC_PROG_LN_S
+AC_PROG_MAKE_SET
+
+dnl libtool/libtoolize; version 2.4.2 is the tested version. This or any
+dnl compatible later version may be used
+LT_INIT([win32-dll])
+LT_PREREQ([2.4.2])
+
+# Some awks crash when confronted with pnglibconf.dfa, do a test run now
+# to make sure this doesn't happen
+AC_MSG_CHECKING([that AWK works])
+if ${AWK} -f ${srcdir}/scripts/options.awk out="/dev/null" version=search\
+   ${srcdir}/pngconf.h ${srcdir}/scripts/pnglibconf.dfa\
+   ${srcdir}/pngusr.dfa 1>&2
+then
+   AC_MSG_RESULT([ok])
+else
+   AC_MSG_FAILURE([failed], 1)
+fi
+
+# This is a remnant of the old cc -E validation, where it may have been
+# necessary to use a different preprocessor for .dfn files
+DFNCPP="$CPP"
+AC_SUBST(DFNCPP)
+
+# -Werror cannot be passed to GCC in CFLAGS because configure will fail (it
+# checks the compiler with a program that generates a warning), add the
+# following option to deal with this
+AC_ARG_VAR(PNG_COPTS,
+   [additional flags for the C compiler, use this for options that would]
+   [cause configure itself to fail])
+AC_ARG_ENABLE(werror,
+   AS_HELP_STRING([[[--enable-werror[=OPT]]]],
+      [Pass -Werror or the given argument to the compiler if it is supported]),
+   [test "$enable_werror" = "yes" && enable_werror="-Werror"
+    if test "$enable_werror" != "no"; then
+      sav_CFLAGS="$CFLAGS"
+      CFLAGS="$enable_werror $CFLAGS"
+      AC_MSG_CHECKING([if the compiler allows $enable_werror])
+      AC_COMPILE_IFELSE(
+         [AC_LANG_SOURCE([
+            [int main(int argc, char **argv){]
+            [return argv[argc-1][0];]
+            [}]])],
+         AC_MSG_RESULT(yes)
+         PNG_COPTS="$PNG_COPTS $enable_werror",
+         AC_MSG_RESULT(no))
+      CFLAGS="$sav_CFLAGS"
+    fi],)
+
+# For GCC 5 the default mode for C is -std=gnu11 instead of -std=gnu89
+# In pngpriv.h we request just the POSIX 1003.1 and C89 APIs by defining _POSIX_SOURCE to 1
+# This is incompatible with the new default mode, so we test for that and force the 
+# "-std=c89" compiler option:
+AC_MSG_CHECKING([if we need to force back C standard to C89])
+AC_COMPILE_IFELSE(
+   [AC_LANG_PROGRAM([
+      [#define _POSIX_SOURCE 1]
+      [#include <stdio.h>]
+   ])],
+   AC_MSG_RESULT(no),[
+      if test "x$GCC" != "xyes"; then
+         AC_MSG_ERROR(
+            [Forcing back to C89 is required but the flags are only known for GCC])
+      fi
+   AC_MSG_RESULT(yes)
+   CFLAGS="$CFLAGS -std=c89"
+])
+
+# Checks for header files.
+AC_HEADER_STDC
+
+# Checks for typedefs, structures, and compiler characteristics.
+AC_C_CONST
+AC_TYPE_SIZE_T
+AC_STRUCT_TM
+AC_C_RESTRICT
+
+# Checks for library functions.
+AC_FUNC_STRTOD
+AC_CHECK_FUNCS([pow], , AC_CHECK_LIB(m, pow, , AC_MSG_ERROR(cannot find pow)) )
+
+# Some later POSIX 1003.1 functions are required for test programs, failure here
+# is soft (the corresponding test program is not built).
+AC_CHECK_FUNC([clock_gettime],,[AC_MSG_WARN([not building timepng])])
+AM_CONDITIONAL([HAVE_CLOCK_GETTIME], [test "$ac_cv_func_clock_gettime" = "yes"])
+
+AC_ARG_WITH(zlib-prefix,
+   AS_HELP_STRING([[[--with-zlib-prefix]]],
+      [prefix that may have been used in installed zlib]),
+      [ZPREFIX=${withval}],
+      [ZPREFIX='z_'])
+AC_CHECK_LIB(z, zlibVersion, ,
+    AC_CHECK_LIB(z, ${ZPREFIX}zlibVersion, , AC_MSG_ERROR(zlib not installed)))
+
+# The following is for pngvalid, to ensure it catches FP errors even on
+# platforms that don't enable FP exceptions, the function appears in the math
+# library (typically), it's not an error if it is not found.
+AC_CHECK_LIB([m], [feenableexcept])
+AC_CHECK_FUNCS([feenableexcept])
+
+AC_MSG_CHECKING([if using Solaris linker])
+SLD=`$LD --version 2>&1 | grep Solaris`
+if test "$SLD"; then
+    have_solaris_ld=yes
+    AC_MSG_RESULT(yes)
+else
+    have_solaris_ld=no
+    AC_MSG_RESULT(no)
+fi
+AM_CONDITIONAL(HAVE_SOLARIS_LD, test "$have_solaris_ld" = "yes")
+
+AC_MSG_CHECKING([if libraries can be versioned])
+# Special case for PE/COFF platforms: ld reports
+# support for version-script, but doesn't actually
+# DO anything with it.
+case $host in
+*cygwin* | *mingw32* | *interix* )
+    have_ld_version_script=no
+    AC_MSG_RESULT(no)
+;;
+* )
+
+if test "$have_solaris_ld" = "yes"; then
+    GLD=`$LD --help < /dev/null 2>&1 | grep 'M mapfile'`
+else
+    GLD=`$LD --help < /dev/null 2>/dev/null | grep version-script`
+fi
+
+if test "$GLD"; then
+    have_ld_version_script=yes
+    AC_MSG_RESULT(yes)
+else
+    have_ld_version_script=no
+    AC_MSG_RESULT(no)
+    AC_MSG_WARN(*** You have not enabled versioned symbols.)
+fi
+;;
+esac
+
+AM_CONDITIONAL(HAVE_LD_VERSION_SCRIPT, test "$have_ld_version_script" = "yes")
+
+if test "$have_ld_version_script" = "yes"; then
+    AC_MSG_CHECKING([for symbol prefix])
+    SYMBOL_PREFIX=`echo "PREFIX=__USER_LABEL_PREFIX__" \
+                  | ${CPP-${CC-gcc} -E} - 2>&1 \
+                  | ${EGREP-grep} "^PREFIX=" \
+                  | ${SED-sed} -e "s:^PREFIX=::" -e "s:__USER_LABEL_PREFIX__::"`
+    AC_SUBST(SYMBOL_PREFIX)
+    AC_MSG_RESULT($SYMBOL_PREFIX)
+fi
+
+# Substitutions for .in files
+AC_SUBST(PNGLIB_VERSION)
+AC_SUBST(PNGLIB_MAJOR)
+AC_SUBST(PNGLIB_MINOR)
+AC_SUBST(PNGLIB_RELEASE)
+
+# Additional arguments (and substitutions)
+# Allow the pkg-config directory to be set
+AC_ARG_WITH(pkgconfigdir,
+   AS_HELP_STRING([[[--with-pkgconfigdir]]],
+      [Use the specified pkgconfig dir (default is libdir/pkgconfig)]),
+   [pkgconfigdir=${withval}],
+   [pkgconfigdir='${libdir}/pkgconfig'])
+
+AC_SUBST([pkgconfigdir])
+AC_MSG_NOTICE([[pkgconfig directory is ${pkgconfigdir}]])
+
+# Make the *-config binary config scripts optional
+AC_ARG_WITH(binconfigs,
+   AS_HELP_STRING([[[--with-binconfigs]]],
+      [Generate shell libpng-config scripts as well as pkg-config data]
+      [@<:@default=yes@:>@]),
+   [if test "${withval}" = no; then
+      binconfigs=
+      AC_MSG_NOTICE([[libpng-config scripts will not be built]])
+    else
+      binconfigs='${binconfigs}'
+    fi],
+   [binconfigs='${binconfigs}'])
+AC_SUBST([binconfigs])
+
+# Support for prefixes to the API function names; this will generate defines
+# at the start of the build to rename exported library functions
+AC_ARG_WITH(libpng-prefix,
+   AS_HELP_STRING([[[--with-libpng-prefix]]],
+      [prefix libpng exported function (API) names with the given value]),
+   [if test "${withval:-no}" != "no"; then
+      AC_SUBST([PNG_PREFIX], [${withval}])
+    fi])
+AM_CONDITIONAL([DO_PNG_PREFIX], [test "${with_libpng_prefix:-no}" != "no"])
+
+# Control over what links are made for installed files.  Versioned files are
+# always installed, when the following options are turned on corresponding
+# unversioned links are also created (normally as symbolic links):
+AC_ARG_ENABLE([unversioned-links],
+   AS_HELP_STRING([[[--enable-unversioned-links]]],
+      [Installed libpng header files are placed in a versioned subdirectory]
+      [and installed libpng library (including DLL) files are versioned.]
+      [If this option is enabled unversioned links will be created pointing to]
+      [the corresponding installed files.  If you use libpng.pc or]
+      [libpng-config for all builds you do not need these links, but if you]
+      [compile programs directly they will typically #include <png.h> and]
+      [link with -lpng; in that case you need the links.]
+      [The links can be installed manually using 'make install-header-links']
+      [and 'make install-library-links' and can be removed using the]
+      [corresponding uninstall- targets.  If you do enable this option every]
+      [libpng 'make install' will recreate the links to point to the just]
+      [installed version of libpng.  The default is to create the links;]
+      [use --disable-unversioned-links to change this]))
+
+# The AM_CONDITIONAL test is written so that the default is enabled;
+# --disable-unversioned-links must be given to turn the option off.
+AM_CONDITIONAL([DO_INSTALL_LINKS],[test "$enable_unversioned_links" != "no"])
+
+AC_ARG_ENABLE([unversioned-libpng-pc],
+   AS_HELP_STRING([[[--enable-unversioned-libpng-pc]]],
+      [Install the configuration file 'libpng.pc' as a link to the versioned]
+      [version.  This is done by default - use --disable-unversioned-libpng-pc]
+      [to change this.]))
+AM_CONDITIONAL([DO_INSTALL_LIBPNG_PC],
+   [test "$enable_unversioned_libpng_pc" != "no"])
+
+AC_ARG_ENABLE([unversioned-libpng-config],
+   AS_HELP_STRING([[[--enable-unversioned-libpng-config]]],
+      [Install the configuration file 'libpng-config' as a link to the]
+      [versioned version.  This is done by default - use]
+      [--disable-unversioned-libpng-config to change this.]))
+AM_CONDITIONAL([DO_INSTALL_LIBPNG_CONFIG],
+   [test "$enable_unversioned_libpng_config" != "no"])
+
+# HOST SPECIFIC OPTIONS
+# =====================
+#
+# DEFAULT
+# =======
+#
+AC_ARG_ENABLE([hardware-optimizations],
+   AS_HELP_STRING([[[--enable-hardware-optimizations]]],
+      [Enable hardware optimizations: =no/off, yes/on:]),
+   [case "$enableval" in
+      no|off)
+         # disable hardware optimization on all systems:
+         enable_arm_neon=no
+         AC_DEFINE([PNG_ARM_NEON_OPT], [0],
+           [Disable ARM_NEON optimizations])
+         enable_mips_msa=no
+         AC_DEFINE([PNG_MIPS_MSA_OPT], [0],
+           [Disable MIPS_MSA optimizations])
+         enable_powerpc_vsx=no
+         AC_DEFINE([PNG_POWERPC_VSX_OPT], [0],
+           [Disable POWERPC VSX optimizations])
+         enable_intel_sse=no
+         AC_DEFINE([PNG_INTEL_SSE_OPT], [0],
+           [Disable INTEL_SSE optimizations])
+         ;;
+      *)
+         # allow enabling hardware optimization on any system:
+         case "$host_cpu" in
+            arm*|aarch64*)
+              enable_arm_neon=yes
+              AC_DEFINE([PNG_ARM_NEON_OPT], [0],
+                [Enable ARM_NEON optimizations])
+              ;;
+            mipsel*|mips64el*)
+              enable_mips_msa=yes
+              AC_DEFINE([PNG_MIPS_MSA_OPT], [0],
+                [Enable MIPS_MSA optimizations])
+              ;;
+            i?86|x86_64)
+              enable_intel_sse=yes
+              AC_DEFINE([PNG_INTEL_SSE_OPT], [1],
+                [Enable Intel SSE optimizations])
+              ;;
+            powerpc*|ppc64*)
+              enable_powerpc_vsx=yes
+              AC_DEFINE([PNG_POWERPC_VSX_OPT], [2],
+                [Enable POWERPC VSX optimizations])
+              ;;
+         esac
+         ;;
+   esac])
+
+# ARM
+# ===
+#
+# ARM NEON (SIMD) support.
+
+AC_ARG_ENABLE([arm-neon],
+   AS_HELP_STRING([[[--enable-arm-neon]]],
+      [Enable ARM NEON optimizations: =no/off, check, api, yes/on:]
+      [no/off: disable the optimizations; check: use internal checking code]
+      [(deprecated and poorly supported); api: disable by default, enable by]
+      [a call to png_set_option; yes/on: turn on unconditionally.]
+      [If not specified: determined by the compiler.]),
+   [case "$enableval" in
+      no|off)
+         # disable the default enabling on __ARM_NEON__ systems:
+         AC_DEFINE([PNG_ARM_NEON_OPT], [0],
+                   [Disable ARM Neon optimizations])
+         # Prevent inclusion of the assembler files below:
+         enable_arm_neon=no;;
+      check)
+         AC_DEFINE([PNG_ARM_NEON_CHECK_SUPPORTED], [],
+                   [Check for ARM Neon support at run-time]);;
+      api)
+         AC_DEFINE([PNG_ARM_NEON_API_SUPPORTED], [],
+                   [Turn on ARM Neon optimizations at run-time]);;
+      yes|on)
+         AC_DEFINE([PNG_ARM_NEON_OPT], [2],
+                   [Enable ARM Neon optimizations])
+         AC_MSG_WARN([--enable-arm-neon: please specify 'check' or 'api', if]
+            [you want the optimizations unconditionally pass -mfpu=neon]
+            [to the compiler.]);;
+      *)
+         AC_MSG_ERROR([--enable-arm-neon=${enable_arm_neon}: invalid value])
+   esac])
+
+# Add ARM specific files to all builds where the host_cpu is arm ('arm*') or
+# where ARM optimizations were explicitly requested (this allows a fallback if a
+# future host CPU does not match 'arm*')
+
+AM_CONDITIONAL([PNG_ARM_NEON],
+   [test "$enable_arm_neon" != 'no' &&
+    case "$host_cpu" in
+      arm*|aarch64*) :;;
+      *)    test "$enable_arm_neon" != '';;
+    esac])
+
+# MIPS
+# ===
+#
+# MIPS MSA (SIMD) support.
+
+AC_ARG_ENABLE([mips-msa],
+   AS_HELP_STRING([[[--enable-mips-msa]]],
+      [Enable MIPS MSA optimizations: =no/off, check, api, yes/on:]
+      [no/off: disable the optimizations; check: use internal checking code]
+      [(deprecated and poorly supported); api: disable by default, enable by]
+      [a call to png_set_option; yes/on: turn on unconditionally.]
+      [If not specified: determined by the compiler.]),
+   [case "$enableval" in
+      no|off)
+         # disable the default enabling on __mips_msa systems:
+         AC_DEFINE([PNG_MIPS_MSA_OPT], [0],
+                   [Disable MIPS MSA optimizations])
+         # Prevent inclusion of the assembler files below:
+         enable_mips_msa=no;;
+      check)
+         AC_DEFINE([PNG_MIPS_MSA_CHECK_SUPPORTED], [],
+                   [Check for MIPS MSA support at run-time]);;
+      api)
+         AC_DEFINE([PNG_MIPS_MSA_API_SUPPORTED], [],
+                   [Turn on MIPS MSA optimizations at run-time]);;
+      yes|on)
+         AC_DEFINE([PNG_MIPS_MSA_OPT], [2],
+                   [Enable MIPS MSA optimizations])
+         AC_MSG_WARN([--enable-mips-msa: please specify 'check' or 'api', if]
+            [you want the optimizations unconditionally pass '-mmsa -mfp64']
+            [to the compiler.]);;
+      *)
+         AC_MSG_ERROR([--enable-mips-msa=${enable_mips_msa}: invalid value])
+   esac])
+
+# Add MIPS specific files to all builds where the host_cpu is mips ('mips*') or
+# where MIPS optimizations were explicitly requested (this allows a fallback if a
+# future host CPU does not match 'mips*')
+
+AM_CONDITIONAL([PNG_MIPS_MSA],
+   [test "$enable_mips_msa" != 'no' &&
+    case "$host_cpu" in
+      mipsel*|mips64el*) :;;
+    esac])
+
+# INTEL
+# =====
+#
+# INTEL SSE (SIMD) support.
+
+AC_ARG_ENABLE([intel-sse],
+   AS_HELP_STRING([[[--enable-intel-sse]]],
+      [Enable Intel SSE optimizations: =no/off, yes/on:]
+      [no/off: disable the optimizations;]
+      [yes/on: enable the optimizations.]
+      [If not specified: determined by the compiler.]),
+   [case "$enableval" in
+      no|off)
+         # disable the default enabling:
+         AC_DEFINE([PNG_INTEL_SSE_OPT], [0],
+                   [Disable Intel SSE optimizations])
+         # Prevent inclusion of the assembler files below:
+         enable_intel_sse=no;;
+      yes|on)
+         AC_DEFINE([PNG_INTEL_SSE_OPT], [1],
+                   [Enable Intel SSE optimizations]);;
+      *)
+         AC_MSG_ERROR([--enable-intel-sse=${enable_intel_sse}: invalid value])
+   esac])
+
+# Add Intel specific files to all builds where the host_cpu is Intel ('x86*')
+# or where Intel optimizations were explicitly requested (this allows a
+# fallback if a future host CPU does not match 'x86*')
+AM_CONDITIONAL([PNG_INTEL_SSE],
+   [test "$enable_intel_sse" != 'no' &&
+    case "$host_cpu" in
+      i?86|x86_64) :;;
+      *)    test "$enable_intel_sse" != '';;
+    esac])
+
+# PowerPC
+# ===
+#
+# PowerPC VSX (SIMD) support.
+
+AC_ARG_ENABLE([powerpc-vsx],
+AS_HELP_STRING([[[--enable-powerpc-vsx]]],
+      [Enable POWERPC VSX optimizations: =no/off, check, api, yes/on:]
+      [no/off: disable the optimizations; check: use internal checking code]
+      [api: disable by default, enable by a call to png_set_option]
+      [yes/on: turn on unconditionally.]
+      [If not specified: determined by the compiler.]),
+   [case "$enableval" in
+      no|off)
+         # disable the default enabling on __ppc64__ systems:
+         AC_DEFINE([PNG_POWERPC_VSX_OPT], [0],
+                   [Disable POWERPC VSX optimizations])
+         # Prevent inclusion of the platform specific files below:
+         enable_powerpc_vsx=no;;
+      check)
+         AC_DEFINE([PNG_POWERPC_VSX_CHECK_SUPPORTED], [],
+                   [Check for POWERPC VSX support at run-time])
+         AC_MSG_WARN([--enable-powerpc-vsx Please check contrib/powerpc/README file]
+            [for the list of supported OSes.]);;
+      api)
+         AC_DEFINE([PNG_POWERPC_VSX_API_SUPPORTED], [],
+                   [Turn on POWERPC VSX optimizations at run-time]);;
+      yes|on)
+         AC_DEFINE([PNG_POWERPC_VSX_OPT], [2],
+                   [Enable POWERPC VSX optimizations])
+         AC_MSG_WARN([--enable-powerpc-vsx: please specify 'check' or 'api', if]
+            [you want the optimizations unconditionally pass '-maltivec -mvsx']
+            [or '-mcpu=power8'to the compiler.]);;
+      *)
+         AC_MSG_ERROR([--enable-powerpc-vsx=${enable_powerpc_vsx}: invalid value])
+   esac])
+
+# Add PowerPC specific files to all builds where the host_cpu is powerpc('powerpc*') or
+# where POWERPC optimizations were explicitly requested (this allows a fallback if a
+# future host CPU does not match 'powerpc*')
+
+AM_CONDITIONAL([PNG_POWERPC_VSX],
+   [test "$enable_powerpc_vsx" != 'no' &&
+    case "$host_cpu" in
+      powerpc*|ppc64*) :;;
+    esac])
+
+
+AC_MSG_NOTICE([[Extra options for compiler: $PNG_COPTS]])
+
+# Config files, substituting as above
+AC_CONFIG_FILES([Makefile libpng.pc:libpng.pc.in])
+AC_CONFIG_FILES([libpng-config:libpng-config.in],
+   [chmod +x libpng-config])
+
+AC_OUTPUT
diff --git a/Engine/lib/lpng/contrib/README.txt b/Engine/lib/lpng/contrib/README.txt
new file mode 100644
index 000000000..97963c6d5
--- /dev/null
+++ b/Engine/lib/lpng/contrib/README.txt
@@ -0,0 +1,5 @@
+
+This "contrib" directory contains contributions which are not necessarily under
+the libpng license, although all are open source.  They are not part of
+libpng proper and are not used for building the library, although some are used
+for testing the library via "make check".
diff --git a/Engine/lib/lpng/contrib/arm-neon/README b/Engine/lib/lpng/contrib/arm-neon/README
new file mode 100644
index 000000000..b4248cf28
--- /dev/null
+++ b/Engine/lib/lpng/contrib/arm-neon/README
@@ -0,0 +1,83 @@
+OPERATING SYSTEM SPECIFIC ARM NEON DETECTION
+--------------------------------------------
+
+Detection of the ability to execute ARM NEON on an ARM processor requires
+operating system support.  (The information is not available in user mode.)
+
+HOW TO USE THIS
+---------------
+
+This directory contains C code fragments that can be included in arm/arm_init.c
+by setting the macro PNG_ARM_NEON_FILE to the file name in "" or <> at build
+time.  This setting is not recorded in pnglibconf.h and can be changed simply by
+rebuilding arm/arm_init.o with the required macro definition.
+
+For any of this code to be used the ARM NEON code must be enabled and run time
+checks must be supported.  I.e.:
+
+#if PNG_ARM_NEON_OPT > 0
+#ifdef PNG_ARM_NEON_CHECK_SUPPORTED
+
+This is done in a 'configure' build by passing configure the argument:
+
+   --enable-arm-neon=check
+
+Apart from the basic Linux implementation in contrib/arm-neon/linux.c this code
+is unsupported.  That means that it is not even compiled on a regular basis and
+may be broken in any given minor release.
+
+FILE FORMAT
+-----------
+
+Each file documents its testing status as of the last time it was tested (which
+may have been a long time ago):
+
+STATUS: one of:
+   SUPPORTED: This indicates that the file is included in the regularly
+         performed test builds and bugs are fixed when discovered.
+   COMPILED: This indicates that the code did compile at least once.  See the
+         more detailed description for the extent to which the result was
+         successful.
+   TESTED: This means the code was fully compiled into the libpng test programs
+         and these were run at least once.
+
+BUG REPORTS: an email address to which to send reports of problems
+
+The file is a fragment of C code. It should not define any 'extern' symbols;
+everything should be static.  It must define the function:
+
+static int png_have_neon(png_structp png_ptr);
+
+That function must return 1 if ARM NEON instructions are supported, 0 if not.
+It must not execute png_error unless it detects a bug.  A png_error will prevent
+the reading of the PNG and in the future, writing too.
+
+BUG REPORTS
+-----------
+
+If you mail a bug report for any file that is not SUPPORTED there may only be
+limited response.  Consider fixing it and sending a patch to fix the problem -
+this is more likely to result in action.
+
+CONTRIBUTIONS
+-------------
+
+You may send contributions of new implementations to
+png-mng-implement@sourceforge.net.  Please write code in strict C90 C where
+possible.  Obviously OS dependencies are to be expected.  If you submit code you
+must have the authors permission and it must have a license that is acceptable
+to the current maintainer; in particular that license must permit modification
+and redistribution.
+
+Please try to make the contribution a single file and give the file a clear and
+unambiguous name that identifies the target OS.  If multiple files really are
+required put them all in a sub-directory.
+
+You must also be prepared to handle bug reports from users of the code, either
+by joining the png-mng-implement mailing list or by providing an email for the
+"BUG REPORTS" entry or both.  Please make sure that the header of the file
+contains the STATUS and BUG REPORTS fields as above.
+
+Please list the OS requirements as precisely as possible.  Ideally you should
+also list the environment in which the code has been tested and certainly list
+any environments where you suspect it might not work.
diff --git a/Engine/lib/lpng/contrib/arm-neon/android-ndk.c b/Engine/lib/lpng/contrib/arm-neon/android-ndk.c
new file mode 100644
index 000000000..fb3a4898d
--- /dev/null
+++ b/Engine/lib/lpng/contrib/arm-neon/android-ndk.c
@@ -0,0 +1,39 @@
+/* contrib/arm-neon/android-ndk.c
+ *
+ * Copyright (c) 2014 Glenn Randers-Pehrson
+ * Written by John Bowler, 2014.
+ * Last changed in libpng 1.6.10 [March 6, 2014]
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * SEE contrib/arm-neon/README before reporting bugs
+ *
+ * STATUS: COMPILED, UNTESTED
+ * BUG REPORTS: png-mng-implement@sourceforge.net
+ *
+ * png_have_neon implemented for the Android NDK, see:
+ *
+ * Documentation:
+ *    http://www.kandroid.org/ndk/docs/CPU-ARM-NEON.html
+ *    https://code.google.com/p/android/issues/detail?id=49065
+ *
+ * NOTE: this requires that libpng is built against the Android NDK and linked
+ * with an implementation of the Android ARM 'cpu-features' library.  The code
+ * has been compiled only, not linked: no version of the library has been found,
+ * only the header files exist in the NDK.
+ */
+#include <cpu-features.h>
+
+static int
+png_have_neon(png_structp png_ptr)
+{
+   /* This is a whole lot easier than the linux code, however it is probably
+    * implemented as below, therefore it is better to cache the result (these
+    * function calls may be slow!)
+    */
+   PNG_UNUSED(png_ptr)
+   return android_getCpuFamily() == ANDROID_CPU_FAMILY_ARM &&
+      (android_getCpuFeatures() & ANDROID_CPU_ARM_FEATURE_NEON) != 0;
+}
diff --git a/Engine/lib/lpng/contrib/arm-neon/linux-auxv.c b/Engine/lib/lpng/contrib/arm-neon/linux-auxv.c
new file mode 100644
index 000000000..4d26bd3b3
--- /dev/null
+++ b/Engine/lib/lpng/contrib/arm-neon/linux-auxv.c
@@ -0,0 +1,120 @@
+/* contrib/arm-neon/linux-auxv.c
+ *
+ * Copyright (c) 2014 Glenn Randers-Pehrson
+ * Written by Mans Rullgard, 2011.
+ * Last changed in libpng 1.6.10 [March 6, 2014]
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * SEE contrib/arm-neon/README before reporting bugs
+ *
+ * STATUS: COMPILED, TESTED
+ * BUG REPORTS: png-mng-implement@sourceforge.net
+ *
+ * png_have_neon implemented for Linux versions which allow access to
+ * /proc/self/auxv.  This is probably faster, cleaner and safer than the code to
+ * read /proc/cpuinfo in contrib/arm-neon/linux, however it is yet another piece
+ * of potentially untested code and has more complex dependencies than the code
+ * to read cpuinfo.
+ *
+ * This generic __linux__ implementation requires reading /proc/self/auxv and
+ * looking at each element for one that records NEON capabilities.
+ */
+#include <unistd.h> /* for POSIX 1003.1 */
+#include <errno.h>  /* for EINTR */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <elf.h>
+#include <asm/hwcap.h>
+
+/* A read call may be interrupted, in which case it returns -1 and sets errno to
+ * EINTR if nothing was done, otherwise (if something was done) a partial read
+ * may result.
+ */
+static size_t
+safe_read(png_structp png_ptr, int fd, void *buffer_in, size_t nbytes)
+{
+   size_t ntotal = 0;
+   char *buffer = png_voidcast(char*, buffer_in);
+
+   while (nbytes > 0)
+   {
+      unsigned int nread;
+      int iread;
+
+      /* Passing nread > INT_MAX to read is implementation defined in POSIX
+       * 1003.1, therefore despite the unsigned argument portable code must
+       * limit the value to INT_MAX!
+       */
+      if (nbytes > INT_MAX)
+         nread = INT_MAX;
+
+      else
+         nread = (unsigned int)/*SAFE*/nbytes;
+
+      iread = read(fd, buffer, nread);
+
+      if (iread == -1)
+      {
+         /* This is the devil in the details, a read can terminate early with 0
+          * bytes read because of EINTR, yet it still returns -1 otherwise end
+          * of file cannot be distinguished.
+          */
+         if (errno != EINTR)
+         {
+            png_warning(png_ptr, "/proc read failed");
+            return 0; /* I.e., a permanent failure */
+         }
+      }
+
+      else if (iread < 0)
+      {
+         /* Not a valid 'read' result: */
+         png_warning(png_ptr, "OS /proc read bug");
+         return 0;
+      }
+
+      else if (iread > 0)
+      {
+         /* Continue reading until a permanent failure, or EOF */
+         buffer += iread;
+         nbytes -= (unsigned int)/*SAFE*/iread;
+         ntotal += (unsigned int)/*SAFE*/iread;
+      }
+
+      else
+         return ntotal;
+   }
+
+   return ntotal; /* nbytes == 0 */
+}
+
+static int
+png_have_neon(png_structp png_ptr)
+{
+   int fd = open("/proc/self/auxv", O_RDONLY);
+   Elf32_auxv_t aux;
+
+   /* Failsafe: failure to open means no NEON */
+   if (fd == -1)
+   {
+      png_warning(png_ptr, "/proc/self/auxv open failed");
+      return 0;
+   }
+
+   while (safe_read(png_ptr, fd, &aux, sizeof aux) == sizeof aux)
+   {
+      if (aux.a_type == AT_HWCAP && (aux.a_un.a_val & HWCAP_NEON) != 0)
+      {
+         close(fd);
+         return 1;
+      }
+   }
+
+   close(fd);
+   return 0;
+}
diff --git a/Engine/lib/lpng/contrib/arm-neon/linux.c b/Engine/lib/lpng/contrib/arm-neon/linux.c
new file mode 100644
index 000000000..a9bc360dd
--- /dev/null
+++ b/Engine/lib/lpng/contrib/arm-neon/linux.c
@@ -0,0 +1,161 @@
+/* contrib/arm-neon/linux.c
+ *
+ * Last changed in libpng 1.6.31 [July 27, 2017]
+ * Copyright (c) 2014, 2017 Glenn Randers-Pehrson
+ * Written by John Bowler, 2014, 2017.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * SEE contrib/arm-neon/README before reporting bugs
+ *
+ * STATUS: SUPPORTED
+ * BUG REPORTS: png-mng-implement@sourceforge.net
+ *
+ * png_have_neon implemented for Linux by reading the widely available
+ * pseudo-file /proc/cpuinfo.
+ *
+ * This code is strict ANSI-C and is probably moderately portable; it does
+ * however use <stdio.h> and it assumes that /proc/cpuinfo is never localized.
+ */
+#include <stdio.h>
+
+static int
+png_have_neon(png_structp png_ptr)
+{
+   FILE *f = fopen("/proc/cpuinfo", "rb");
+
+   if (f != NULL)
+   {
+      /* This is a simple state machine which reads the input byte-by-byte until
+       * it gets a match on the 'neon' feature or reaches the end of the stream.
+       */
+      static const char ch_feature[] = { 70, 69, 65, 84, 85, 82, 69, 83 };
+      static const char ch_neon[] = { 78, 69, 79, 78 };
+
+      enum
+      {
+         StartLine, Feature, Colon, StartTag, Neon, HaveNeon, SkipTag, SkipLine
+      }  state;
+      int counter;
+
+      for (state=StartLine, counter=0;;)
+      {
+         int ch = fgetc(f);
+
+         if (ch == EOF)
+         {
+            /* EOF means error or end-of-file, return false; neon at EOF is
+             * assumed to be a mistake.
+             */
+            fclose(f);
+            return 0;
+         }
+
+         switch (state)
+         {
+            case StartLine:
+               /* Match spaces at the start of line */
+               if (ch <= 32) /* skip control characters and space */
+                  break;
+
+               counter=0;
+               state = Feature;
+               /* FALLTHROUGH */
+
+            case Feature:
+               /* Match 'FEATURE', ASCII case insensitive. */
+               if ((ch & ~0x20) == ch_feature[counter])
+               {
+                  if (++counter == (sizeof ch_feature))
+                     state = Colon;
+                  break;
+               }
+
+               /* did not match 'feature' */
+               state = SkipLine;
+               /* FALLTHROUGH */
+
+            case SkipLine:
+            skipLine:
+               /* Skip everything until we see linefeed or carriage return */
+               if (ch != 10 && ch != 13)
+                  break;
+
+               state = StartLine;
+               break;
+
+            case Colon:
+               /* Match any number of space or tab followed by ':' */
+               if (ch == 32 || ch == 9)
+                  break;
+
+               if (ch == 58) /* i.e. ':' */
+               {
+                  state = StartTag;
+                  break;
+               }
+
+               /* Either a bad line format or a 'feature' prefix followed by
+                * other characters.
+                */
+               state = SkipLine;
+               goto skipLine;
+
+            case StartTag:
+               /* Skip space characters before a tag */
+               if (ch == 32 || ch == 9)
+                  break;
+
+               state = Neon;
+               counter = 0;
+               /* FALLTHROUGH */
+
+            case Neon:
+               /* Look for 'neon' tag */
+               if ((ch & ~0x20) == ch_neon[counter])
+               {
+                  if (++counter == (sizeof ch_neon))
+                     state = HaveNeon;
+                  break;
+               }
+
+               state = SkipTag;
+               /* FALLTHROUGH */
+
+            case SkipTag:
+               /* Skip non-space characters */
+               if (ch == 10 || ch == 13)
+                  state = StartLine;
+
+               else if (ch == 32 || ch == 9)
+                  state = StartTag;
+               break;
+
+            case HaveNeon:
+               /* Have seen a 'neon' prefix, but there must be a space or new
+                * line character to terminate it.
+                */
+               if (ch == 10 || ch == 13 || ch == 32 || ch == 9)
+               {
+                  fclose(f);
+                  return 1;
+               }
+
+               state = SkipTag;
+               break;
+
+            default:
+               png_error(png_ptr, "png_have_neon: internal error (bug)");
+         }
+      }
+   }
+
+#ifdef PNG_WARNINGS_SUPPORTED
+   else
+      png_warning(png_ptr, "/proc/cpuinfo open failed");
+#endif
+
+   return 0;
+}
diff --git a/Engine/lib/lpng/contrib/conftest/README b/Engine/lib/lpng/contrib/conftest/README
new file mode 100644
index 000000000..0f472791f
--- /dev/null
+++ b/Engine/lib/lpng/contrib/conftest/README
@@ -0,0 +1,49 @@
+This directory contains test configuration files, currently always '.dfa' files
+intended to be used in the build by setting the make macro DFA_XTRA to the name
+of the file.
+
+These files are used in release validation of the 'configure' builds of libpng
+by building 'make check', or 'make all-am' for cross-builds, with each .dfa
+file.
+
+The files in this directory may change between minor releases, however
+contributions describing specific builds of libpng are welcomed.  There is no
+guarantee that libpng will continue to build with such configurations; support
+for given configurations can be, and has been, dropped between successive minor
+releases.  However if a .dfa file describing a configuration is not in this
+directory it is very unlikely that it will be tested before a minor release!
+
+You can use these .dfa files as the basis of new configurations.  Files in this
+directory should not have any use restrictions or restrictive licenses.
+
+This directory is not included in the .zip and .7z distributions, which do
+not contain 'configure' scripts.
+
+DOCUMENTATION
+=============
+
+Examples:
+   ${srcdir}/pngusr.dfa
+   ${srcdir}/contrib/pngminim/*/pngusr.dfa
+
+Documentation of the options:
+   ${srcdir}/scripts/pnglibconf.dfa
+
+Documentation of the file format:
+   ${srcdir}/scripts/options.awk
+
+FILE NAMING
+===========
+
+File names in this directory may NOT contain any of the five characters:
+
+   - , + * ?
+
+Neither may they contain any space character.
+
+While other characters may be used it is strongly suggested that file names be
+limited to lower case Latiin alphabetic characters (a-z), digits (0-9) and, if
+necessary the underscore (_) character.  File names should be about 8 characters
+long (excluding the .dfa extension).  Submitted .dfa files should have names
+between 7 and 16 characters long, shorter names (6 characters or less) are
+reserved for standard tests.
diff --git a/Engine/lib/lpng/contrib/conftest/pngcp.dfa b/Engine/lib/lpng/contrib/conftest/pngcp.dfa
new file mode 100644
index 000000000..31c411d5f
--- /dev/null
+++ b/Engine/lib/lpng/contrib/conftest/pngcp.dfa
@@ -0,0 +1,57 @@
+# pngcp.dfa
+#  Build time configuration of libpng
+#
+# Author: John Bowler
+# Copyright: (c) John Bowler, 2016
+# Usage rights:
+#  To the extent possible under law, the author has waived all copyright and
+#  related or neighboring rights to this work.  This work is published from:
+#  United States.
+#
+# Build libpng with support for pngcp.  This means just png_read_png,
+# png_write_png and small number of configuration settings.
+#
+everything = off
+
+# This option is specific to this configuration; it adds a #define to the
+# generated pnglibconf.h which turns on the (not portable) timing option for
+# pngcp.  Note that any option is automatically preceded by PNG_; there is no
+# way round this and this is deliberate.
+option PNGCP_TIMING
+
+# Because of the everything off above the option must also be turned on.  This
+# may not be done in one step because it is safer and avoids mis-spelled options
+# in user .dfa files to error out if an unrecognized option is turned on.
+option PNGCP_TIMING on
+
+# Options to turn on png_read_png and png_write_png:
+option INFO_IMAGE on
+option SEQUENTIAL_READ on
+option EASY_ACCESS on
+option WRITE on
+option WRITE_16BIT on
+option WRITE_FILTER on
+
+# pngcp needs this to preserve unknown chunks, switching all these on means that
+# pngcp can work without explicit known chunk reading support
+option UNKNOWN_CHUNKS on
+option SET_UNKNOWN_CHUNKS on
+option HANDLE_AS_UNKNOWN on
+option SAVE_UNKNOWN_CHUNKS on
+option WRITE_UNKNOWN_CHUNKS on
+
+# pngcp needs this to handle palette files with invalid indices:
+option CHECK_FOR_INVALID_INDEX on
+option GET_PALETTE_MAX on
+
+# Pre-libpng 1.7 pngcp has to stash text chunks manually, post 1.7 without this
+# text chunks should be handled as unknown ok.
+option TEXT on
+
+# this is used to turn off limits:
+option USER_LIMITS on
+option SET_USER_LIMITS on
+
+# these are just required for specific customizations
+option WRITE_CUSTOMIZE_ZTXT_COMPRESSION on
+option WRITE_CUSTOMIZE_COMPRESSION on
diff --git a/Engine/lib/lpng/contrib/conftest/read.dfa b/Engine/lib/lpng/contrib/conftest/read.dfa
new file mode 100644
index 000000000..21e88d01a
--- /dev/null
+++ b/Engine/lib/lpng/contrib/conftest/read.dfa
@@ -0,0 +1,58 @@
+# read.dfa
+#  Build time configuration of libpng
+#
+# Author: John Bowler
+# Copyright: (c) John Bowler, 2013
+# Usage rights:
+#  To the extent possible under law, the author has waived all copyright and
+#  related or neighboring rights to this work.  This work is published from:
+#  United States.
+#
+# Build libpng with basic read support.  This enables the lowest level libpng
+# read API - the one where the calling code has to use a loop to read each row.
+# At present this is the API used by most programs.
+#
+# Support is enabled only for those chunks and transformations that are
+# typically required - others can be added easily.
+#
+
+everything = off
+
+# The sequential read code is enabled here; the progressive code can be used
+# instead but there is no point enabling both.
+
+option SEQUENTIAL_READ on
+
+# Likewise it is pointless enabling both fixed and floating point APIs.  Choose
+# one or the other for both the API and the internal math.
+
+#Fixed point:
+#option FIXED_POINT on
+#option FLOATING_ARITHMETIC off
+
+#Floating point:
+option FLOATING_POINT on
+option FLOATING_ARITHMETIC on
+
+# Basic error handling, IO and user memory support.  The latter allows the
+# application program to provide its own implementations of 'malloc' and 'free'.
+option SETJMP on
+option STDIO on
+option USER_MEM on
+
+# To read the full set of PNG images correctly interlace, transparency and
+# 16-bit support is required.  The application can implement interlace itself,
+# but very few do and it's no longer possible to disable it when READ is
+# enabled.
+option READ_tRNS on
+option READ_16BIT on
+
+# Everything else is application dependent.  This file assumes the app handles
+# all the native PNG bit layouts, so it doesn't need any of layout change
+# transforms, but needs libpng to perform gamma correction.  It doesn't do any
+# colorspace stuff and ignores the 'significant bit' information.
+#
+# If your app always expands the image to a limited set of bit layouts you
+# probably want to consider using the simplified API instead of the low level
+# one - see png.h and s_read.dfa.
+option READ_GAMMA on
diff --git a/Engine/lib/lpng/contrib/conftest/s_read.dfa b/Engine/lib/lpng/contrib/conftest/s_read.dfa
new file mode 100644
index 000000000..cb1ce0ba6
--- /dev/null
+++ b/Engine/lib/lpng/contrib/conftest/s_read.dfa
@@ -0,0 +1,35 @@
+# s_read.dfa
+#  Build time configuration of libpng
+#
+# Author: John Bowler
+# Copyright: (c) John Bowler, 2013
+# Usage rights:
+#  To the extent possible under law, the author has waived all copyright and
+#  related or neighboring rights to this work.  This work is published from:
+#  United States.
+#
+# Build libpng with simplified read support (only).  This builds a minimal
+# libpng able to read all PNG formats and convert them into a small number of
+# well understood memory formats.
+#
+
+everything = off
+
+option SIMPLIFIED_READ on
+
+# It isn't necessary to chose fixed or floating point for the APIs because the
+# simplified API doesn't need fixed or floating point numbers.  It is necessary
+# to chose an internal math implementation.  The default (because of 'everything
+# = off') is fixed point - turn the floating point implementation on if you have
+# hardware floating point or prefer your software floating point implementation.
+option FLOATING_ARITHMETIC on
+
+# This is not strictly necessary, but without it the message strings in the API
+# will not be filled in
+option ERROR_TEXT on
+
+# Switching these options on enables the 'AFIRST' and 'BGR' formats - you don't
+# need this if you don't use them, they just allow the in-memory layout to be
+# changed to match common hardware formats.
+option SIMPLIFIED_READ_AFIRST on
+option SIMPLIFIED_READ_BGR on
diff --git a/Engine/lib/lpng/contrib/conftest/s_write.dfa b/Engine/lib/lpng/contrib/conftest/s_write.dfa
new file mode 100644
index 000000000..e540a46dc
--- /dev/null
+++ b/Engine/lib/lpng/contrib/conftest/s_write.dfa
@@ -0,0 +1,33 @@
+# s_write.dfa
+#  Build time configuration of libpng
+#
+# Author: John Bowler
+# Copyright: (c) John Bowler, 2013
+# Usage rights:
+#  To the extent possible under law, the author has waived all copyright and
+#  related or neighboring rights to this work.  This work is published from:
+#  United States.
+#
+# Build libpng with (just) simplified write support
+#
+
+everything = off
+
+option SIMPLIFIED_WRITE on
+
+# It isn't necessary to chose fixed or floating point for the APIs because the
+# simplified API doesn't need fixed or floating point numbers.  It is necessary
+# to chose an internal math implementation.  The default (because of 'everything
+# = off') is fixed point - turn the floating point implementation on if you have
+# hardware floating point or prefer your software floating point implementation.
+option FLOATING_ARITHMETIC on
+
+# This is not strictly necessary, but without it the message strings in the API
+# will not be filled in
+option ERROR_TEXT on
+
+# Switching these options on enables the 'AFIRST' and 'BGR' formats - you don't
+# need this if you don't use them, they just allow the in-memory layout to be
+# changed to match common hardware formats.
+option SIMPLIFIED_WRITE_AFIRST on
+option SIMPLIFIED_WRITE_BGR on
diff --git a/Engine/lib/lpng/contrib/conftest/simple.dfa b/Engine/lib/lpng/contrib/conftest/simple.dfa
new file mode 100644
index 000000000..041933344
--- /dev/null
+++ b/Engine/lib/lpng/contrib/conftest/simple.dfa
@@ -0,0 +1,36 @@
+# simple.dfa
+#  Build time configuration of libpng
+#
+# Author: John Bowler
+# Copyright: (c) John Bowler, 2013
+# Usage rights:
+#  To the extent possible under law, the author has waived all copyright and
+#  related or neighboring rights to this work.  This work is published from:
+#  United States.
+#
+# Build libpng with just the simplified APIs (read and write).
+#
+
+everything = off
+
+option SIMPLIFIED_WRITE on
+option SIMPLIFIED_READ on
+
+# It isn't necessary to chose fixed or floating point for the APIs because the
+# simplified API doesn't need fixed or floating point numbers.  It is necessary
+# to chose an internal math implementation.  The default (because of 'everything
+# = off') is fixed point - turn the floating point implementation on if you have
+# hardware floating point or prefer your software floating point implementation.
+option FLOATING_ARITHMETIC on
+
+# This is not strictly necessary, but without it the message strings in the API
+# will not be filled in
+option ERROR_TEXT on
+
+# Switching these options on enables the 'AFIRST' and 'BGR' formats - you don't
+# need this if you don't use them, they just allow the in-memory layout to be
+# changed to match common hardware formats.
+option SIMPLIFIED_READ_AFIRST on
+option SIMPLIFIED_READ_BGR on
+option SIMPLIFIED_WRITE_AFIRST on
+option SIMPLIFIED_WRITE_BGR on
diff --git a/Engine/lib/lpng/contrib/conftest/write.dfa b/Engine/lib/lpng/contrib/conftest/write.dfa
new file mode 100644
index 000000000..3319aabee
--- /dev/null
+++ b/Engine/lib/lpng/contrib/conftest/write.dfa
@@ -0,0 +1,45 @@
+# write.dfa
+#  Build time configuration of libpng
+#
+# Author: John Bowler
+# Copyright: (c) John Bowler, 2013
+# Usage rights:
+#  To the extent possible under law, the author has waived all copyright and
+#  related or neighboring rights to this work.  This work is published from:
+#  United States.
+#
+# Build libpng with no read support and minimal write support.
+#
+
+everything = off
+
+# Switch on the write code - this makes a minimalist encoder
+
+option WRITE on
+
+# Choose fixed or floating point APIs and arithmetic.  The choices are
+# independent but normally they will match.  It is typically better to use the
+# floating point if you have floating point hardware.  If you don't know, or
+# (perhaps) to make libpng smaller used fixed point throughout.
+
+#Fixed point:
+#option FIXED_POINT on
+#option FLOATING_ARITHMETIC off
+
+#Floating point:
+option FLOATING_POINT on
+option FLOATING_ARITHMETIC on
+
+# Basic error handling, IO and user memory support.  The latter allows the
+# application program to provide its own implementations of 'malloc' and 'free'.
+option SETJMP on
+option STDIO on
+option USER_MEM on
+
+# Everything else is optional.  Unlike the read code in libpng the write code
+# does not need to deal with arbitrary formats, so only add support for things
+# you really do write!  For example you might only write sRGB images, sometimes
+# with transparency and never write 16 bit images, so:
+option WRITE_sRGB on
+option WRITE_tRNS on
+#option WRITE_16BIT off (this is the default with 'everything = off')
diff --git a/Engine/lib/lpng/contrib/examples/README.txt b/Engine/lib/lpng/contrib/examples/README.txt
new file mode 100644
index 000000000..48dab4f0f
--- /dev/null
+++ b/Engine/lib/lpng/contrib/examples/README.txt
@@ -0,0 +1,24 @@
+
+This directory (contrib/examples) contains examples of libpng usage.
+
+NO COPYRIGHT RIGHTS ARE CLAIMED TO ANY OF THE FILES IN THIS DIRECTORY.
+
+To the extent possible under law, the authors have waived all copyright and
+related or neighboring rights to this work.  This work is published from:
+United States.
+
+The files may be used freely in any way.  The intention is that appropriate
+parts of the files be used in other libpng-using programs without any need for
+the authors of the using code to seek copyright or license from the original
+authors.
+
+The source code and comments in this directory are the original work of the
+people named below.  No other person or organization has made contributions to
+the work in this directory.
+
+ORIGINAL AUTHORS
+    The following people have contributed to the code in this directory.  None
+    of the people below claim any rights with regard to the contents of this
+    directory.
+
+    John Bowler <jbowler at acm.org>
diff --git a/Engine/lib/lpng/contrib/examples/iccfrompng.c b/Engine/lib/lpng/contrib/examples/iccfrompng.c
new file mode 100644
index 000000000..00056abfd
--- /dev/null
+++ b/Engine/lib/lpng/contrib/examples/iccfrompng.c
@@ -0,0 +1,185 @@
+/*- iccfrompng
+ *
+ * COPYRIGHT: Written by John Cunningham Bowler, 2011.
+ * To the extent possible under law, the author has waived all copyright and
+ * related or neighboring rights to this work.  This work is published from:
+ * United States.
+ *
+ * Extract any icc profiles found in the given PNG files.  This is a simple
+ * example of a program that extracts information from the header of a PNG file
+ * without processing the image.  Notice that some header information may occur
+ * after the image data. Textual data and comments are an example; the approach
+ * in this file won't work reliably for such data because it only looks for the
+ * information in the section of the file that precedes the image data.
+ *
+ * Compile and link against libpng and zlib, plus anything else required on the
+ * system you use.
+ *
+ * To use supply a list of PNG files containing iCCP chunks, the chunks will be
+ * extracted to a similarly named file with the extension replaced by 'icc',
+ * which will be overwritten without warning.
+ */
+#include <stdlib.h>
+#include <setjmp.h>
+#include <string.h>
+#include <stdio.h>
+
+#include <png.h>
+
+#if defined(PNG_READ_SUPPORTED) && defined(PNG_STDIO_SUPPORTED) && \
+    defined (PNG_iCCP_SUPPORTED)
+
+
+static int verbose = 1;
+static png_byte no_profile[] = "no profile";
+
+static png_bytep
+extract(FILE *fp, png_uint_32 *proflen)
+{
+   png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,0,0,0);
+   png_infop info_ptr = NULL;
+   png_bytep result = NULL;
+
+   /* Initialize for error or no profile: */
+   *proflen = 0;
+
+   if (png_ptr == NULL)
+   {
+      fprintf(stderr, "iccfrompng: version library mismatch?\n");
+      return 0;
+   }
+
+   if (setjmp(png_jmpbuf(png_ptr)))
+   {
+      png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+      return 0;
+   }
+
+   png_init_io(png_ptr, fp);
+
+   info_ptr = png_create_info_struct(png_ptr);
+   if (info_ptr == NULL)
+      png_error(png_ptr, "OOM allocating info structure");
+
+   png_read_info(png_ptr, info_ptr);
+
+   {
+      png_charp name;
+      int compression_type;
+      png_bytep profile;
+
+      if (png_get_iCCP(png_ptr, info_ptr, &name, &compression_type, &profile,
+         proflen) & PNG_INFO_iCCP)
+      {
+         result = malloc(*proflen);
+         if (result != NULL)
+            memcpy(result, profile, *proflen);
+
+         else
+            png_error(png_ptr, "OOM allocating profile buffer");
+      }
+
+      else
+	result = no_profile;
+   }
+
+   png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+   return result;
+}
+
+static int
+extract_one_file(const char *filename)
+{
+   int result = 0;
+   FILE *fp = fopen(filename, "rb");
+
+   if (fp != NULL)
+   {
+      png_uint_32 proflen = 0;
+      png_bytep profile = extract(fp, &proflen);
+
+      if (profile != NULL && profile != no_profile)
+      {
+         size_t len;
+         char *output;
+
+         {
+            const char *ep = strrchr(filename, '.');
+
+            if (ep != NULL)
+               len = ep-filename;
+
+            else
+               len = strlen(filename);
+         }
+
+         output = malloc(len + 5);
+         if (output != NULL)
+         {
+            FILE *of;
+
+            memcpy(output, filename, len);
+            strcpy(output+len, ".icc");
+
+            of = fopen(output, "wb");
+            if (of != NULL)
+            {
+               if (fwrite(profile, proflen, 1, of) == 1 &&
+                  fflush(of) == 0 &&
+                  fclose(of) == 0)
+               {
+                  if (verbose)
+                     printf("%s -> %s\n", filename, output);
+                  /* Success return */
+                  result = 1;
+               }
+
+               else
+               {
+                  fprintf(stderr, "%s: error writing profile\n", output);
+                  if (remove(output))
+                     fprintf(stderr, "%s: could not remove file\n", output);
+               }
+            }
+
+            else
+               fprintf(stderr, "%s: failed to open output file\n", output);
+
+            free(output);
+         }
+
+         else
+            fprintf(stderr, "%s: OOM allocating string!\n", filename);
+
+         free(profile);
+      }
+
+      else if (verbose && profile == no_profile)
+	printf("%s has no profile\n", filename);
+   }
+
+   else
+      fprintf(stderr, "%s: could not open file\n", filename);
+
+   return result;
+}
+
+int
+main(int argc, char **argv)
+{
+   int i;
+   int extracted = 0;
+
+   for (i=1; i<argc; ++i)
+   {
+      if (strcmp(argv[i], "-q") == 0)
+         verbose = 0;
+
+      else if (extract_one_file(argv[i]))
+         extracted = 1;
+   }
+
+   /* Exit code is true if any extract succeeds */
+   return extracted == 0;
+}
+#endif /* READ && STDIO && iCCP */
diff --git a/Engine/lib/lpng/contrib/examples/pngpixel.c b/Engine/lib/lpng/contrib/examples/pngpixel.c
new file mode 100644
index 000000000..9185d518f
--- /dev/null
+++ b/Engine/lib/lpng/contrib/examples/pngpixel.c
@@ -0,0 +1,371 @@
+/*- pngpixel
+ *
+ * COPYRIGHT: Written by John Cunningham Bowler, 2011.
+ * To the extent possible under law, the author has waived all copyright and
+ * related or neighboring rights to this work.  This work is published from:
+ * United States.
+ *
+ * Read a single pixel value from a PNG file.
+ *
+ * This code illustrates basic 'by-row' reading of a PNG file using libpng.
+ * Rows are read until a particular pixel is found; the value of this pixel is
+ * then printed on stdout.
+ *
+ * The code illustrates how to do this on interlaced as well as non-interlaced
+ * images.  Normally you would call png_set_interlace_handling() to have libpng
+ * deal with the interlace for you, but that obliges you to buffer half of the
+ * image to assemble the interlaced rows.  In this code
+ * png_set_interlace_handling() is not called and, instead, the code handles the
+ * interlace passes directly looking for the required pixel.
+ */
+#include <stdlib.h>
+#include <stdio.h>
+#include <setjmp.h> /* required for error handling */
+
+/* Normally use <png.h> here to get the installed libpng, but this is done to
+ * ensure the code picks up the local libpng implementation:
+ */
+#include "../../png.h"
+
+#if defined(PNG_READ_SUPPORTED) && defined(PNG_SEQUENTIAL_READ_SUPPORTED)
+
+/* Return component 'c' of pixel 'x' from the given row. */
+static unsigned int
+component(png_const_bytep row, png_uint_32 x, unsigned int c,
+   unsigned int bit_depth, unsigned int channels)
+{
+   /* PNG images can be up to 2^31 pixels wide, but this means they can be up to
+    * 2^37 bits wide (for a 64-bit pixel - the largest possible) and hence 2^34
+    * bytes wide.  Since the row fitted into memory, however, the following must
+    * work:
+    */
+   png_uint_32 bit_offset_hi = bit_depth * ((x >> 6) * channels);
+   png_uint_32 bit_offset_lo = bit_depth * ((x & 0x3f) * channels + c);
+
+   row = (png_const_bytep)(((const png_byte (*)[8])row) + bit_offset_hi);
+   row += bit_offset_lo >> 3;
+   bit_offset_lo &= 0x07;
+
+   /* PNG pixels are packed into bytes to put the first pixel in the highest
+    * bits of the byte and into two bytes for 16-bit values with the high 8 bits
+    * first, so:
+    */
+   switch (bit_depth)
+   {
+      case 1: return (row[0] >> (7-bit_offset_lo)) & 0x01;
+      case 2: return (row[0] >> (6-bit_offset_lo)) & 0x03;
+      case 4: return (row[0] >> (4-bit_offset_lo)) & 0x0f;
+      case 8: return row[0];
+      case 16: return (row[0] << 8) + row[1];
+      default:
+         /* This should never happen; it indicates a bug in this program or in
+          * libpng itself:
+          */
+         fprintf(stderr, "pngpixel: invalid bit depth %u\n", bit_depth);
+         exit(1);
+   }
+}
+
+/* Print a pixel from a row returned by libpng; determine the row format, find
+ * the pixel, and print the relevant information to stdout.
+ */
+static void
+print_pixel(png_structp png_ptr, png_infop info_ptr, png_const_bytep row,
+   png_uint_32 x)
+{
+   unsigned int bit_depth = png_get_bit_depth(png_ptr, info_ptr);
+
+   switch (png_get_color_type(png_ptr, info_ptr))
+   {
+      case PNG_COLOR_TYPE_GRAY:
+         printf("GRAY %u\n", component(row, x, 0, bit_depth, 1));
+         return;
+
+      /* The palette case is slightly more difficult - the palette and, if
+       * present, the tRNS ('transparency', though the values are really
+       * opacity) data must be read to give the full picture:
+       */
+      case PNG_COLOR_TYPE_PALETTE:
+         {
+            int index = component(row, x, 0, bit_depth, 1);
+            png_colorp palette = NULL;
+            int num_palette = 0;
+
+            if ((png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette) &
+               PNG_INFO_PLTE) && num_palette > 0 && palette != NULL)
+            {
+               png_bytep trans_alpha = NULL;
+               int num_trans = 0;
+               if ((png_get_tRNS(png_ptr, info_ptr, &trans_alpha, &num_trans,
+                  NULL) & PNG_INFO_tRNS) && num_trans > 0 &&
+                  trans_alpha != NULL)
+                  printf("INDEXED %u = %d %d %d %d\n", index,
+                     palette[index].red, palette[index].green,
+                     palette[index].blue,
+                     index < num_trans ? trans_alpha[index] : 255);
+
+               else /* no transparency */
+                  printf("INDEXED %u = %d %d %d\n", index,
+                     palette[index].red, palette[index].green,
+                     palette[index].blue);
+            }
+
+            else
+               printf("INDEXED %u = invalid index\n", index);
+         }
+         return;
+
+      case PNG_COLOR_TYPE_RGB:
+         printf("RGB %u %u %u\n", component(row, x, 0, bit_depth, 3),
+            component(row, x, 1, bit_depth, 3),
+            component(row, x, 2, bit_depth, 3));
+         return;
+
+      case PNG_COLOR_TYPE_GRAY_ALPHA:
+         printf("GRAY+ALPHA %u %u\n", component(row, x, 0, bit_depth, 2),
+            component(row, x, 1, bit_depth, 2));
+         return;
+
+      case PNG_COLOR_TYPE_RGB_ALPHA:
+         printf("RGBA %u %u %u %u\n", component(row, x, 0, bit_depth, 4),
+            component(row, x, 1, bit_depth, 4),
+            component(row, x, 2, bit_depth, 4),
+            component(row, x, 3, bit_depth, 4));
+         return;
+
+      default:
+         png_error(png_ptr, "pngpixel: invalid color type");
+   }
+}
+
+int main(int argc, const char **argv)
+{
+   /* This program uses the default, <setjmp.h> based, libpng error handling
+    * mechanism, therefore any local variable that exists before the call to
+    * setjmp and is changed after the call to setjmp returns successfully must
+    * be declared with 'volatile' to ensure that their values don't get
+    * destroyed by longjmp:
+    */
+   volatile int result = 1/*fail*/;
+
+   if (argc == 4)
+   {
+      long x = atol(argv[1]);
+      long y = atol(argv[2]);
+      FILE *f = fopen(argv[3], "rb");
+      volatile png_bytep row = NULL;
+
+      if (f != NULL)
+      {
+         /* libpng requires a callback function for handling errors; this
+          * callback must not return.  The default callback function uses a
+          * stored <setjmp.h> style jmp_buf which is held in a png_struct and
+          * writes error messages to stderr.  Creating the png_struct is a
+          * little tricky; just copy the following code.
+          */
+         png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
+            NULL, NULL, NULL);
+
+         if (png_ptr != NULL)
+         {
+            png_infop info_ptr = png_create_info_struct(png_ptr);
+
+            if (info_ptr != NULL)
+            {
+               /* Declare stack variables to hold pointers to locally allocated
+                * data.
+                */
+
+               /* Initialize the error control buffer: */
+               if (setjmp(png_jmpbuf(png_ptr)) == 0)
+               {
+                  png_uint_32 width, height;
+                  int bit_depth, color_type, interlace_method,
+                     compression_method, filter_method;
+                  png_bytep row_tmp;
+
+                  /* Now associate the recently opened (FILE*) with the default
+                   * libpng initialization functions.  Sometimes libpng is
+                   * compiled without stdio support (it can be difficult to do
+                   * in some environments); in that case you will have to write
+                   * your own read callback to read data from the (FILE*).
+                   */
+                  png_init_io(png_ptr, f);
+
+                  /* And read the first part of the PNG file - the header and
+                   * all the information up to the first pixel.
+                   */
+                  png_read_info(png_ptr, info_ptr);
+
+                  /* This fills in enough information to tell us the width of
+                   * each row in bytes, allocate the appropriate amount of
+                   * space.  In this case png_malloc is used - it will not
+                   * return if memory isn't available.
+                   */
+                  row = png_malloc(png_ptr, png_get_rowbytes(png_ptr,
+                     info_ptr));
+
+                  /* To avoid the overhead of using a volatile auto copy row_tmp
+                   * to a local here - just use row for the png_free below.
+                   */
+                  row_tmp = row;
+
+                  /* All the information we need is in the header is returned by
+                   * png_get_IHDR, if this fails we can now use 'png_error' to
+                   * signal the error and return control to the setjmp above.
+                   */
+                  if (png_get_IHDR(png_ptr, info_ptr, &width, &height,
+                     &bit_depth, &color_type, &interlace_method,
+                     &compression_method, &filter_method))
+                  {
+                     int passes, pass;
+
+                     /* png_set_interlace_handling returns the number of
+                      * passes required as well as turning on libpng's
+                      * handling, but since we do it ourselves this is
+                      * necessary:
+                      */
+                     switch (interlace_method)
+                     {
+                        case PNG_INTERLACE_NONE:
+                           passes = 1;
+                           break;
+
+                        case PNG_INTERLACE_ADAM7:
+                           passes = PNG_INTERLACE_ADAM7_PASSES;
+                           break;
+
+                        default:
+                           png_error(png_ptr, "pngpixel: unknown interlace");
+                     }
+
+                     /* Now read the pixels, pass-by-pass, row-by-row: */
+                     png_start_read_image(png_ptr);
+
+                     for (pass=0; pass<passes; ++pass)
+                     {
+                        png_uint_32 ystart, xstart, ystep, xstep;
+                        png_uint_32 py;
+
+                        if (interlace_method == PNG_INTERLACE_ADAM7)
+                        {
+                           /* Sometimes the whole pass is empty because the
+                            * image is too narrow or too short.  libpng
+                            * expects to be called for each row that is
+                            * present in the pass, so it may be necessary to
+                            * skip the loop below (over py) if the image is
+                            * too narrow.
+                            */
+                           if (PNG_PASS_COLS(width, pass) == 0)
+                              continue;
+
+                           /* We need the starting pixel and the offset
+                            * between each pixel in this pass; use the macros
+                            * in png.h:
+                            */
+                           xstart = PNG_PASS_START_COL(pass);
+                           ystart = PNG_PASS_START_ROW(pass);
+                           xstep = PNG_PASS_COL_OFFSET(pass);
+                           ystep = PNG_PASS_ROW_OFFSET(pass);
+                        }
+
+                        else
+                        {
+                           ystart = xstart = 0;
+                           ystep = xstep = 1;
+                        }
+
+                        /* To find the pixel, loop over 'py' for each pass
+                         * reading a row and then checking to see if it
+                         * contains the pixel.
+                         */
+                        for (py = ystart; py < height; py += ystep)
+                        {
+                           png_uint_32 px, ppx;
+
+                           /* png_read_row takes two pointers.  When libpng
+                            * handles the interlace the first is filled in
+                            * pixel-by-pixel, and the second receives the same
+                            * pixels but they are replicated across the
+                            * unwritten pixels so far for each pass.  When we
+                            * do the interlace, however, they just contain
+                            * the pixels from the interlace pass - giving
+                            * both is wasteful and pointless, so we pass a
+                            * NULL pointer.
+                            */
+                           png_read_row(png_ptr, row_tmp, NULL);
+
+                           /* Now find the pixel if it is in this row; there
+                            * are, of course, much better ways of doing this
+                            * than using a for loop:
+                            */
+                           if (y == py) for (px = xstart, ppx = 0;
+                              px < width; px += xstep, ++ppx) if (x == px)
+                           {
+                              /* 'ppx' is the index of the pixel in the row
+                               * buffer.
+                               */
+                              print_pixel(png_ptr, info_ptr, row_tmp, ppx);
+
+                              /* Now terminate the loops early - we have
+                               * found and handled the required data.
+                               */
+                              goto pass_loop_end;
+                           } /* x loop */
+                        } /* y loop */
+                     } /* pass loop */
+
+                     /* Finally free the temporary buffer: */
+                  pass_loop_end:
+                     row = NULL;
+                     png_free(png_ptr, row_tmp);
+                  }
+
+                  else
+                     png_error(png_ptr, "pngpixel: png_get_IHDR failed");
+
+               }
+
+               else
+               {
+                  /* Else libpng has raised an error.  An error message has
+                   * already been output, so it is only necessary to clean up
+                   * locally allocated data:
+                   */
+                  if (row != NULL)
+                  {
+                     /* The default implementation of png_free never errors out
+                      * (it just crashes if something goes wrong), but the safe
+                      * way of using it is still to clear 'row' before calling
+                      * png_free:
+                      */
+                     png_bytep row_tmp = row;
+                     row = NULL;
+                     png_free(png_ptr, row_tmp);
+                  }
+               }
+
+               png_destroy_info_struct(png_ptr, &info_ptr);
+            }
+
+            else
+               fprintf(stderr, "pngpixel: out of memory allocating png_info\n");
+
+            png_destroy_read_struct(&png_ptr, NULL, NULL);
+         }
+
+         else
+            fprintf(stderr, "pngpixel: out of memory allocating png_struct\n");
+      }
+
+      else
+         fprintf(stderr, "pngpixel: %s: could not open file\n", argv[3]);
+   }
+
+   else
+      /* Wrong number of arguments */
+      fprintf(stderr, "pngpixel: usage: pngpixel x y png-file\n");
+
+   return result;
+}
+#endif /* READ && SEQUENTIAL_READ */
diff --git a/Engine/lib/lpng/contrib/examples/pngtopng.c b/Engine/lib/lpng/contrib/examples/pngtopng.c
new file mode 100644
index 000000000..904b97238
--- /dev/null
+++ b/Engine/lib/lpng/contrib/examples/pngtopng.c
@@ -0,0 +1,98 @@
+/*- pngtopng
+ *
+ * COPYRIGHT: Written by John Cunningham Bowler, 2011, 2017.
+ * To the extent possible under law, the author has waived all copyright and
+ * related or neighboring rights to this work.  This work is published from:
+ * United States.
+ *
+ * Last changed in libpng 1.6.29 [March 16, 2017]
+ *
+ * Read a PNG and write it out in a fixed format, using the 'simplified API'
+ * that was introduced in libpng-1.6.0.
+ *
+ * This sample code is just the code from the top of 'example.c' with some error
+ * handling added.  See example.c for more comments.
+ */
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+/* Normally use <png.h> here to get the installed libpng, but this is done to
+ * ensure the code picks up the local libpng implementation:
+ */
+#include "../../png.h"
+#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) && \
+    defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
+
+int main(int argc, const char **argv)
+{
+   int result = 1;
+
+   if (argc == 3)
+   {
+      png_image image;
+
+      /* Only the image structure version number needs to be set. */
+      memset(&image, 0, sizeof image);
+      image.version = PNG_IMAGE_VERSION;
+
+      if (png_image_begin_read_from_file(&image, argv[1]))
+      {
+         png_bytep buffer;
+
+         /* Change this to try different formats!  If you set a colormap format
+          * then you must also supply a colormap below.
+          */
+         image.format = PNG_FORMAT_RGBA;
+
+         buffer = malloc(PNG_IMAGE_SIZE(image));
+
+         if (buffer != NULL)
+         {
+            if (png_image_finish_read(&image, NULL/*background*/, buffer,
+               0/*row_stride*/, NULL/*colormap for PNG_FORMAT_FLAG_COLORMAP */))
+            {
+               if (png_image_write_to_file(&image, argv[2],
+                  0/*convert_to_8bit*/, buffer, 0/*row_stride*/,
+                  NULL/*colormap*/))
+                  result = 0;
+
+               else
+                  fprintf(stderr, "pngtopng: write %s: %s\n", argv[2],
+                      image.message);
+            }
+
+            else
+               fprintf(stderr, "pngtopng: read %s: %s\n", argv[1],
+                   image.message);
+
+            free(buffer);
+         }
+
+         else
+         {
+            fprintf(stderr, "pngtopng: out of memory: %lu bytes\n",
+               (unsigned long)PNG_IMAGE_SIZE(image));
+
+            /* This is the only place where a 'free' is required; libpng does
+             * the cleanup on error and success, but in this case we couldn't
+             * complete the read because of running out of memory and so libpng
+             * has not got to the point where it can do cleanup.
+             */
+            png_image_free(&image);
+         }
+      }
+
+      else
+         /* Failed to read the first argument: */
+         fprintf(stderr, "pngtopng: %s: %s\n", argv[1], image.message);
+   }
+
+   else
+      /* Wrong number of arguments */
+      fprintf(stderr, "pngtopng: usage: pngtopng input-file output-file\n");
+
+   return result;
+}
+#endif /* READ && WRITE */
diff --git a/Engine/lib/lpng/contrib/examples/simpleover.c b/Engine/lib/lpng/contrib/examples/simpleover.c
new file mode 100644
index 000000000..59dd31368
--- /dev/null
+++ b/Engine/lib/lpng/contrib/examples/simpleover.c
@@ -0,0 +1,648 @@
+/*- simpleover
+ *
+ * COPYRIGHT: Written by John Cunningham Bowler, 2015.
+ * To the extent possible under law, the author has waived all copyright and
+ * related or neighboring rights to this work.  This work is published from:
+ * United States.
+ *
+ * Read several PNG files, which should have an alpha channel or transparency
+ * information, and composite them together to produce one or more 16-bit linear
+ * RGBA intermediates.  This involves doing the correct 'over' composition to
+ * combine the alpha channels and corresponding data.
+ *
+ * Finally read an output (background) PNG using the 24-bit RGB format (the
+ * PNG will be composited on green (#00ff00) by default if it has an alpha
+ * channel), and apply the intermediate image generated above to specified
+ * locations in the image.
+ *
+ * The command line has the general format:
+ *
+ *    simpleover <background.png> [output.png]
+ *        {--sprite=width,height,name {[--at=x,y] {sprite.png}}}
+ *        {--add=name {x,y}}
+ *
+ * The --sprite and --add options may occur multiple times. They are executed
+ * in order.  --add may refer to any sprite already read.
+ *
+ * This code is intended to show how to composite multiple images together
+ * correctly.  Apart from the libpng Simplified API the only work done in here
+ * is to combine multiple input PNG images into a single sprite; this involves
+ * a Porter-Duff 'over' operation and the input PNG images may, as a result,
+ * be regarded as being layered one on top of the other with the first (leftmost
+ * on the command line) being at the bottom and the last on the top.
+ */
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+
+/* Normally use <png.h> here to get the installed libpng, but this is done to
+ * ensure the code picks up the local libpng implementation, so long as this
+ * file is linked against a sufficiently recent libpng (1.6+) it is ok to
+ * change this to <png.h>:
+ */
+#include "../../png.h"
+
+#ifdef PNG_SIMPLIFIED_READ_SUPPORTED
+
+#define sprite_name_chars 15
+struct sprite {
+   FILE         *file;
+   png_uint_16p  buffer;
+   unsigned int  width;
+   unsigned int  height;
+   char          name[sprite_name_chars+1];
+};
+
+#if 0 /* div by 65535 test program */
+#include <math.h>
+#include <stdio.h>
+
+int main(void) {
+   double err = 0;
+   unsigned int xerr = 0;
+   unsigned int r = 32769;
+   {
+      unsigned int x = 0;
+
+      do {
+         unsigned int t = x + (x >> 16) /*+ (x >> 31)*/ + r;
+         double v = x, errtest;
+
+         if (t < x) {
+            fprintf(stderr, "overflow: %u+%u -> %u\n", x, r, t);
+            return 1;
+         }
+
+         v /= 65535;
+         errtest = v;
+         t >>= 16;
+         errtest -= t;
+
+         if (errtest > err) {
+            err = errtest;
+            xerr = x;
+
+            if (errtest >= .5) {
+               fprintf(stderr, "error: %u/65535 = %f, not %u, error %f\n",
+                     x, v, t, errtest);
+               return 0;
+            }
+         }
+      } while (++x <= 65535U*65535U);
+   }
+
+   printf("error %f @ %u\n", err, xerr);
+
+   return 0;
+}
+#endif /* div by 65535 test program */
+
+static void
+sprite_op(const struct sprite *sprite, int x_offset, int y_offset,
+   png_imagep image, const png_uint_16 *buffer)
+{
+   /* This is where the Porter-Duff 'Over' operator is evaluated; change this
+    * code to change the operator (this could be parameterized).  Any other
+    * image processing operation could be used here.
+    */
+
+
+   /* Check for an x or y offset that pushes any part of the image beyond the
+    * right or bottom of the sprite:
+    */
+   if ((y_offset < 0 || (unsigned)/*SAFE*/y_offset < sprite->height) &&
+       (x_offset < 0 || (unsigned)/*SAFE*/x_offset < sprite->width))
+   {
+      unsigned int y = 0;
+
+      if (y_offset < 0)
+         y = -y_offset; /* Skip to first visible row */
+
+      do
+      {
+         unsigned int x = 0;
+
+         if (x_offset < 0)
+            x = -x_offset;
+
+         do
+         {
+            /* In and out are RGBA values, so: */
+            const png_uint_16 *in_pixel = buffer + (y * image->width + x)*4;
+            png_uint_32 in_alpha = in_pixel[3];
+
+            /* This is the optimized Porter-Duff 'Over' operation, when the
+             * input alpha is 0 the output is not changed.
+             */
+            if (in_alpha > 0)
+            {
+               png_uint_16 *out_pixel = sprite->buffer +
+                  ((y+y_offset) * sprite->width + (x+x_offset))*4;
+
+               /* This is the weight to apply to the output: */
+               in_alpha = 65535-in_alpha;
+
+               if (in_alpha > 0)
+               {
+                  /* The input must be composed onto the output. This means
+                   * multiplying the current output pixel value by the inverse
+                   * of the input alpha (1-alpha). A division is required but
+                   * it is by the constant 65535.  Approximate this as:
+                   *
+                   *     (x + (x >> 16) + 32769) >> 16;
+                   *
+                   * This is exact (and does not overflow) for all values of
+                   * x in the range 0..65535*65535.  (Note that the calculation
+                   * produces the closest integer; the maximum error is <0.5).
+                   */
+                  png_uint_32 tmp;
+
+#                 define compose(c)\
+                     tmp = out_pixel[c] * in_alpha;\
+                     tmp = (tmp + (tmp >> 16) + 32769) >> 16;\
+                     out_pixel[c] = tmp + in_pixel[c]
+
+                  /* The following is very vectorizable... */
+                  compose(0);
+                  compose(1);
+                  compose(2);
+                  compose(3);
+               }
+
+               else
+                  out_pixel[0] = in_pixel[0],
+                  out_pixel[1] = in_pixel[1],
+                  out_pixel[2] = in_pixel[2],
+                  out_pixel[3] = in_pixel[3];
+            }
+         }
+         while (++x < image->width);
+      }
+      while (++y < image->height);
+   }
+}
+
+static int
+create_sprite(struct sprite *sprite, int *argc, const char ***argv)
+{
+   /* Read the arguments and create this sprite. The sprite buffer has already
+    * been allocated. This reads the input PNGs one by one in linear format,
+    * composes them onto the sprite buffer (the code in the function above)
+    * then saves the result, converting it on the fly to PNG RGBA 8-bit format.
+    */
+   while (*argc > 0)
+   {
+      char tombstone;
+      int x = 0, y = 0;
+
+      if ((*argv)[0][0] == '-' && (*argv)[0][1] == '-')
+      {
+         /* The only supported option is --at. */
+         if (sscanf((*argv)[0], "--at=%d,%d%c", &x, &y, &tombstone) != 2)
+            break; /* success; caller will parse this option */
+
+         ++*argv, --*argc;
+      }
+
+      else
+      {
+         /* The argument has to be a file name */
+         png_image image;
+
+         image.version = PNG_IMAGE_VERSION;
+         image.opaque = NULL;
+
+         if (png_image_begin_read_from_file(&image, (*argv)[0]))
+         {
+            png_uint_16p buffer;
+
+            image.format = PNG_FORMAT_LINEAR_RGB_ALPHA;
+
+            buffer = malloc(PNG_IMAGE_SIZE(image));
+
+            if (buffer != NULL)
+            {
+               if (png_image_finish_read(&image, NULL/*background*/, buffer,
+                  0/*row_stride*/,
+                  NULL/*colormap for PNG_FORMAT_FLAG_COLORMAP*/))
+               {
+                  /* This is the place where the Porter-Duff 'Over' operator
+                   * needs to be done by this code.  In fact, any image
+                   * processing required can be done here; the data is in
+                   * the correct format (linear, 16-bit) and source and
+                   * destination are in memory.
+                   */
+                  sprite_op(sprite, x, y, &image, buffer);
+                  free(buffer);
+                  ++*argv, --*argc;
+                  /* And continue to the next argument */
+                  continue;
+               }
+
+               else
+               {
+                  free(buffer);
+                  fprintf(stderr, "simpleover: read %s: %s\n", (*argv)[0],
+                      image.message);
+               }
+            }
+
+            else
+            {
+               fprintf(stderr, "simpleover: out of memory: %lu bytes\n",
+                  (unsigned long)PNG_IMAGE_SIZE(image));
+
+               /* png_image_free must be called if we abort the Simplified API
+                * read because of a problem detected in this code.  If problems
+                * are detected in the Simplified API it cleans up itself.
+                */
+               png_image_free(&image);
+            }
+         }
+
+         else
+         {
+            /* Failed to read the first argument: */
+            fprintf(stderr, "simpleover: %s: %s\n", (*argv)[0], image.message);
+         }
+
+         return 0; /* failure */
+      }
+   }
+
+   /* All the sprite operations have completed successfully. Save the RGBA
+    * buffer as a PNG using the simplified write API.
+    */
+   sprite->file = tmpfile();
+
+   if (sprite->file != NULL)
+   {
+      png_image save;
+
+      memset(&save, 0, sizeof save);
+      save.version = PNG_IMAGE_VERSION;
+      save.opaque = NULL;
+      save.width = sprite->width;
+      save.height = sprite->height;
+      save.format = PNG_FORMAT_LINEAR_RGB_ALPHA;
+      save.flags = PNG_IMAGE_FLAG_FAST;
+      save.colormap_entries = 0;
+
+      if (png_image_write_to_stdio(&save, sprite->file, 1/*convert_to_8_bit*/,
+          sprite->buffer, 0/*row_stride*/, NULL/*colormap*/))
+      {
+         /* Success; the buffer is no longer needed: */
+         free(sprite->buffer);
+         sprite->buffer = NULL;
+         return 1; /* ok */
+      }
+
+      else
+         fprintf(stderr, "simpleover: write sprite %s: %s\n", sprite->name,
+            save.message);
+   }
+
+   else
+      fprintf(stderr, "simpleover: sprite %s: could not allocate tmpfile: %s\n",
+         sprite->name, strerror(errno));
+
+   return 0; /* fail */
+}
+
+static int
+add_sprite(png_imagep output, png_bytep out_buf, struct sprite *sprite,
+   int *argc, const char ***argv)
+{
+   /* Given a --add argument naming this sprite, perform the operations listed
+    * in the following arguments.  The arguments are expected to have the form
+    * (x,y), which is just an offset at which to add the sprite to the
+    * output.
+    */
+   while (*argc > 0)
+   {
+      char tombstone;
+      int x, y;
+
+      if ((*argv)[0][0] == '-' && (*argv)[0][1] == '-')
+         return 1; /* success */
+
+      if (sscanf((*argv)[0], "%d,%d%c", &x, &y, &tombstone) == 2)
+      {
+         /* Now add the new image into the sprite data, but only if it
+          * will fit.
+          */
+         if (x < 0 || y < 0 ||
+             (unsigned)/*SAFE*/x >= output->width ||
+             (unsigned)/*SAFE*/y >= output->height ||
+             sprite->width > output->width-x ||
+             sprite->height > output->height-y)
+         {
+            fprintf(stderr, "simpleover: sprite %s @ (%d,%d) outside image\n",
+               sprite->name, x, y);
+            /* Could just skip this, but for the moment it is an error */
+            return 0; /* error */
+         }
+
+         else
+         {
+            /* Since we know the sprite fits we can just read it into the
+             * output using the simplified API.
+             */
+            png_image in;
+
+            in.version = PNG_IMAGE_VERSION;
+            rewind(sprite->file);
+
+            if (png_image_begin_read_from_stdio(&in, sprite->file))
+            {
+               in.format = PNG_FORMAT_RGB; /* force compose */
+
+               if (png_image_finish_read(&in, NULL/*background*/,
+                  out_buf + (y*output->width + x)*3/*RGB*/,
+                  output->width*3/*row_stride*/,
+                  NULL/*colormap for PNG_FORMAT_FLAG_COLORMAP*/))
+               {
+                  ++*argv, --*argc;
+                  continue;
+               }
+            }
+
+            /* The read failed: */
+            fprintf(stderr, "simpleover: add sprite %s: %s\n", sprite->name,
+                in.message);
+            return 0; /* error */
+         }
+      }
+
+      else
+      {
+         fprintf(stderr, "simpleover: --add='%s': invalid position %s\n",
+               sprite->name, (*argv)[0]);
+         return 0; /* error */
+      }
+   }
+
+   return 1; /* ok */
+}
+
+static int
+simpleover_process(png_imagep output, png_bytep out_buf, int argc,
+   const char **argv)
+{
+   int result = 1; /* success */
+#  define csprites 10/*limit*/
+#  define str(a) #a
+   int nsprites = 0;
+   struct sprite sprites[csprites];
+
+   while (argc > 0)
+   {
+      result = 0; /* fail */
+
+      if (strncmp(argv[0], "--sprite=", 9) == 0)
+      {
+         char tombstone;
+
+         if (nsprites < csprites)
+         {
+            int n;
+
+            sprites[nsprites].width = sprites[nsprites].height = 0;
+            sprites[nsprites].name[0] = 0;
+
+            n = sscanf(argv[0], "--sprite=%u,%u,%" str(sprite_name_chars) "s%c",
+                &sprites[nsprites].width, &sprites[nsprites].height,
+                sprites[nsprites].name, &tombstone);
+
+            if ((n == 2 || n == 3) &&
+                sprites[nsprites].width > 0 && sprites[nsprites].height > 0)
+            {
+               size_t buf_size, tmp;
+
+               /* Default a name if not given. */
+               if (sprites[nsprites].name[0] == 0)
+                  sprintf(sprites[nsprites].name, "sprite-%d", nsprites+1);
+
+               /* Allocate a buffer for the sprite and calculate the buffer
+                * size:
+                */
+               buf_size = sizeof (png_uint_16 [4]);
+               buf_size *= sprites[nsprites].width;
+               buf_size *= sprites[nsprites].height;
+
+               /* This can overflow a (size_t); check for this: */
+               tmp = buf_size;
+               tmp /= sprites[nsprites].width;
+               tmp /= sprites[nsprites].height;
+
+               if (tmp == sizeof (png_uint_16 [4]))
+               {
+                  sprites[nsprites].buffer = malloc(buf_size);
+                  /* This buffer must be initialized to transparent: */
+                  memset(sprites[nsprites].buffer, 0, buf_size);
+
+                  if (sprites[nsprites].buffer != NULL)
+                  {
+                     sprites[nsprites].file = NULL;
+                     ++argv, --argc;
+
+                     if (create_sprite(sprites+nsprites++, &argc, &argv))
+                     {
+                        result = 1; /* still ok */
+                        continue;
+                     }
+
+                     break; /* error */
+                  }
+               }
+
+               /* Overflow, or OOM */
+               fprintf(stderr, "simpleover: %s: sprite too large\n", argv[0]);
+               break;
+            }
+
+            else
+            {
+               fprintf(stderr, "simpleover: %s: invalid sprite (%u,%u)\n",
+                  argv[0], sprites[nsprites].width, sprites[nsprites].height);
+               break;
+            }
+         }
+
+         else
+         {
+            fprintf(stderr, "simpleover: %s: too many sprites\n", argv[0]);
+            break;
+         }
+      }
+
+      else if (strncmp(argv[0], "--add=", 6) == 0)
+      {
+         const char *name = argv[0]+6;
+         int isprite = nsprites;
+
+         ++argv, --argc;
+
+         while (--isprite >= 0)
+         {
+            if (strcmp(sprites[isprite].name, name) == 0)
+            {
+               if (!add_sprite(output, out_buf, sprites+isprite, &argc, &argv))
+                  goto out; /* error in add_sprite */
+
+               break;
+            }
+         }
+
+         if (isprite < 0) /* sprite not found */
+         {
+            fprintf(stderr, "simpleover: --add='%s': sprite not found\n", name);
+            break;
+         }
+      }
+
+      else
+      {
+         fprintf(stderr, "simpleover: %s: unrecognized operation\n", argv[0]);
+         break;
+      }
+
+      result = 1; /* ok  */
+   }
+
+   /* Clean up the cache of sprites: */
+out:
+   while (--nsprites >= 0)
+   {
+      if (sprites[nsprites].buffer != NULL)
+         free(sprites[nsprites].buffer);
+
+      if (sprites[nsprites].file != NULL)
+         (void)fclose(sprites[nsprites].file);
+   }
+
+   return result;
+}
+
+int main(int argc, const char **argv)
+{
+   int result = 1; /* default to fail */
+
+   if (argc >= 2)
+   {
+      int argi = 2;
+      const char *output = NULL;
+      png_image image;
+
+      if (argc > 2 && argv[2][0] != '-'/*an operation*/)
+      {
+         output = argv[2];
+         argi = 3;
+      }
+
+      image.version = PNG_IMAGE_VERSION;
+      image.opaque = NULL;
+
+      if (png_image_begin_read_from_file(&image, argv[1]))
+      {
+         png_bytep buffer;
+
+         image.format = PNG_FORMAT_RGB; /* 24-bit RGB */
+
+         buffer = malloc(PNG_IMAGE_SIZE(image));
+
+         if (buffer != NULL)
+         {
+            png_color background = {0, 0xff, 0}; /* fully saturated green */
+
+            if (png_image_finish_read(&image, &background, buffer,
+               0/*row_stride*/, NULL/*colormap for PNG_FORMAT_FLAG_COLORMAP */))
+            {
+               /* At this point png_image_finish_read has cleaned up the
+                * allocated data in png_image, and only the buffer needs to be
+                * freed.
+                *
+                * Perform the remaining operations:
+                */
+               if (simpleover_process(&image, buffer, argc-argi, argv+argi))
+               {
+                  /* Write the output: */
+                  if ((output != NULL &&
+                       png_image_write_to_file(&image, output,
+                        0/*convert_to_8bit*/, buffer, 0/*row_stride*/,
+                        NULL/*colormap*/)) ||
+                      (output == NULL &&
+                       png_image_write_to_stdio(&image, stdout,
+                        0/*convert_to_8bit*/, buffer, 0/*row_stride*/,
+                        NULL/*colormap*/)))
+                     result = 0;
+
+                  else
+                     fprintf(stderr, "simpleover: write %s: %s\n",
+                        output == NULL ? "stdout" : output, image.message);
+               }
+
+               /* else simpleover_process writes an error message */
+            }
+
+            else
+               fprintf(stderr, "simpleover: read %s: %s\n", argv[1],
+                   image.message);
+
+            free(buffer);
+         }
+
+         else
+         {
+            fprintf(stderr, "simpleover: out of memory: %lu bytes\n",
+               (unsigned long)PNG_IMAGE_SIZE(image));
+
+            /* This is the only place where a 'free' is required; libpng does
+             * the cleanup on error and success, but in this case we couldn't
+             * complete the read because of running out of memory.
+             */
+            png_image_free(&image);
+         }
+      }
+
+      else
+      {
+         /* Failed to read the first argument: */
+         fprintf(stderr, "simpleover: %s: %s\n", argv[1], image.message);
+      }
+   }
+
+   else
+   {
+      /* Usage message */
+      fprintf(stderr,
+         "simpleover: usage: simpleover background.png [output.png]\n"
+         "  Output 'background.png' as a 24-bit RGB PNG file in 'output.png'\n"
+         "   or, if not given, stdout.  'background.png' will be composited\n"
+         "   on fully saturated green.\n"
+         "\n"
+         "  Optionally, before output, process additional PNG files:\n"
+         "\n"
+         "   --sprite=width,height,name {[--at=x,y] {sprite.png}}\n"
+         "    Produce a transparent sprite of size (width,height) and with\n"
+         "     name 'name'.\n"
+         "    For each sprite.png composite it using a Porter-Duff 'Over'\n"
+         "     operation at offset (x,y) in the sprite (defaulting to (0,0)).\n"
+         "     Input PNGs will be truncated to the area of the sprite.\n"
+         "\n"
+         "   --add='name' {x,y}\n"
+         "    Optionally, before output, composite a sprite, 'name', which\n"
+         "     must have been previously produced using --sprite, at each\n"
+         "     offset (x,y) in the output image.  Each sprite must fit\n"
+         "     completely within the output image.\n"
+         "\n"
+         "  PNG files are processed in the order they occur on the command\n"
+         "  line and thus the first PNG processed appears as the bottommost\n"
+         "  in the output image.\n");
+   }
+
+   return result;
+}
+#endif /* SIMPLIFIED_READ */
diff --git a/Engine/lib/lpng/contrib/gregbook/COPYING b/Engine/lib/lpng/contrib/gregbook/COPYING
new file mode 100644
index 000000000..a3e977479
--- /dev/null
+++ b/Engine/lib/lpng/contrib/gregbook/COPYING
@@ -0,0 +1,340 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year  name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.
diff --git a/Engine/lib/lpng/contrib/gregbook/LICENSE b/Engine/lib/lpng/contrib/gregbook/LICENSE
new file mode 100644
index 000000000..d9567178c
--- /dev/null
+++ b/Engine/lib/lpng/contrib/gregbook/LICENSE
@@ -0,0 +1,50 @@
+  ---------------------------------------------------------------------------
+
+      Copyright (c) 1998-2008 Greg Roelofs.  All rights reserved.
+
+      This software is provided "as is," without warranty of any kind,
+      express or implied.  In no event shall the author or contributors
+      be held liable for any damages arising in any way from the use of
+      this software.
+
+      The contents of this file are DUAL-LICENSED.  You may modify and/or
+      redistribute this software according to the terms of one of the
+      following two licenses (at your option):
+
+
+      LICENSE 1 ("BSD-like with advertising clause"):
+
+      Permission is granted to anyone to use this software for any purpose,
+      including commercial applications, and to alter it and redistribute
+      it freely, subject to the following restrictions:
+
+      1. Redistributions of source code must retain the above copyright
+         notice, disclaimer, and this list of conditions.
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, disclaimer, and this list of conditions in the documenta-
+         tion and/or other materials provided with the distribution.
+      3. All advertising materials mentioning features or use of this
+         software must display the following acknowledgment:
+
+            This product includes software developed by Greg Roelofs
+            and contributors for the book, "PNG: The Definitive Guide,"
+            published by O'Reilly and Associates.
+
+
+      LICENSE 2 (GNU GPL v2 or later):
+
+      This program is free software; you can redistribute it and/or modify
+      it under the terms of the GNU General Public License as published by
+      the Free Software Foundation; either version 2 of the License, or
+      (at your option) any later version.
+
+      This program is distributed in the hope that it will be useful,
+      but WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+      GNU General Public License for more details.
+
+      You should have received a copy of the GNU General Public License
+      along with this program; if not, write to the Free Software Foundation,
+      Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  ---------------------------------------------------------------------------
diff --git a/Engine/lib/lpng/contrib/gregbook/Makefile.mingw32 b/Engine/lib/lpng/contrib/gregbook/Makefile.mingw32
new file mode 100644
index 000000000..3a3ff607e
--- /dev/null
+++ b/Engine/lib/lpng/contrib/gregbook/Makefile.mingw32
@@ -0,0 +1,131 @@
+# Sample makefile for rpng-win / rpng2-win / wpng using mingw32-gcc and make.
+# Greg Roelofs
+# Last modified:  2 June 2007
+#
+#	The programs built by this makefile are described in the book,
+#	"PNG:  The Definitive Guide," by Greg Roelofs (O'Reilly and
+#	Associates, 1999).  Go buy a copy, eh?  Well, OK, it's not
+#	generally for sale anymore, but it's the thought that counts,
+#	right?  (Hint:  http://www.libpng.org/pub/png/book/ )
+#
+# Invoke this makefile from a DOS-prompt window via:
+#
+#	make -f Makefile.mingw32
+#
+# This makefile assumes libpng and zlib have already been built or downloaded
+# and are in subdirectories at the same level as the current subdirectory
+# (as indicated by the PNGDIR and ZDIR macros below).  It makes no assumptions
+# at all about the mingw32 installation tree (W32DIR).  Edit as appropriate.
+#
+# Note that the names of the dynamic and static libpng and zlib libraries
+# used below may change in later releases of the libraries.  This makefile
+# builds both statically and dynamically linked executables by default.
+# (You need only one set, but for testing it can be handy to have both.)
+
+
+# macros --------------------------------------------------------------------
+
+#PNGDIR = ../..#		for libpng-x.y.z/contrib/gregbook builds
+PNGDIR = ../libpng-win32
+PNGINC = -I$(PNGDIR)
+PNGLIBd = $(PNGDIR)/libpng.dll.a	# dynamically linked
+PNGLIBs = $(PNGDIR)/libpng.a		# statically linked, local libpng
+
+#ZDIR = ../../../zlib-win32#	for libpng-x.y.z/contrib/gregbook builds
+ZDIR = ../zlib-win32
+ZINC = -I$(ZDIR)
+ZLIBd = $(ZDIR)/libzdll.a
+ZLIBs = $(ZDIR)/libz.a
+
+# change this to be the path where mingw32 installs its stuff:
+W32DIR =
+#W32DIR = /usr/local/cross-tools/i386-mingw32msvc
+W32INC = -I$(W32DIR)/include
+W32LIB = $(W32DIR)/lib/libuser32.a $(W32DIR)/lib/libgdi32.a
+
+CC = gcc
+#CC = i386-mingw32msvc-gcc #	e.g., Linux -> Win32 cross-compilation
+LD = $(CC)
+RM = rm -f
+CPPFLAGS = $(INCS)
+CFLAGS = -O -Wall $(MINGW_CCFLAGS)
+# [note that -Wall is a gcc-specific compilation flag ("most warnings on")]
+# [-ansi, -pedantic and -W can also be used]
+LDFLAGS = $(MINGW_LDFLAGS)
+O = .o
+E = .exe
+
+INCS = $(PNGINC) $(ZINC) $(W32INC)
+RLIBSd = $(PNGLIBd) $(ZLIBd) $(W32LIB) -lm
+RLIBSs = $(PNGLIBs) $(ZLIBs) $(W32LIB) -lm
+WLIBSd = $(PNGLIBd) $(ZLIBd)
+WLIBSs = $(PNGLIBs) $(ZLIBs)
+
+RPNG   = rpng-win
+RPNG2  = rpng2-win
+WPNG   = wpng
+
+ROBJSd  = $(RPNG)$(O) readpng.pic$(O)
+ROBJS2d = $(RPNG2)$(O) readpng2.pic$(O)
+WOBJSd  = $(WPNG)$(O) writepng.pic$(O)
+
+RPNGs  = $(RPNG)-static
+RPNG2s = $(RPNG2)-static
+WPNGs  = $(WPNG)-static
+
+ROBJSs  = $(RPNG)$(O) readpng$(O)
+ROBJS2s = $(RPNG2)$(O) readpng2$(O)
+WOBJSs  = $(WPNG)$(O) writepng$(O)
+
+STATIC_EXES  = $(RPNGs)$(E) $(RPNG2s)$(E) $(WPNGs)$(E)
+DYNAMIC_EXES = $(RPNG)$(E) $(RPNG2)$(E) $(WPNG)$(E)
+
+EXES = $(STATIC_EXES) $(DYNAMIC_EXES)
+
+
+# implicit make rules -------------------------------------------------------
+
+.c$(O):
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) $<
+
+%.pic$(O): %.c
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -DPNG_BUILD_DLL -o $@ $<
+
+
+# dependencies --------------------------------------------------------------
+
+all:  $(EXES)
+
+$(RPNGs)$(E): $(ROBJSs)
+	$(LD) $(LDFLAGS) -o $@ $(ROBJSs) $(RLIBSs)
+
+$(RPNG)$(E): $(ROBJSd)
+	$(LD) $(LDFLAGS) -o $@ $(ROBJSd) $(RLIBSd)
+
+$(RPNG2s)$(E): $(ROBJS2s)
+	$(LD) $(LDFLAGS) -o $@ $(ROBJS2s) $(RLIBSs)
+
+$(RPNG2)$(E): $(ROBJS2d)
+	$(LD) $(LDFLAGS) -o $@ $(ROBJS2d) $(RLIBSd)
+
+$(WPNGs)$(E): $(WOBJSs)
+	$(LD) $(LDFLAGS) -o $@ $(WOBJSs) $(WLIBSs)
+
+$(WPNG)$(E): $(WOBJSd)
+	$(LD) $(LDFLAGS) -o $@ $(WOBJSd) $(WLIBSd)
+
+$(RPNG)$(O):	$(RPNG).c readpng.h
+$(RPNG2)$(O):	$(RPNG2).c readpng2.h
+$(WPNG)$(O):	$(WPNG).c writepng.h
+
+readpng$(O) readpng.pic$(O):	readpng.c readpng.h
+readpng2$(O) readpng2.pic$(O):	readpng2.c readpng2.h
+writepng$(O) writepng.pic$(O):	writepng.c writepng.h
+
+
+# maintenance ---------------------------------------------------------------
+
+clean:
+	$(RM) $(EXES)
+	$(RM) $(ROBJSs) $(ROBJS2s) $(WOBJSs)
+	$(RM) $(ROBJSd) $(ROBJS2d) $(WOBJSd)
diff --git a/Engine/lib/lpng/contrib/gregbook/Makefile.sgi b/Engine/lib/lpng/contrib/gregbook/Makefile.sgi
new file mode 100644
index 000000000..94d61b465
--- /dev/null
+++ b/Engine/lib/lpng/contrib/gregbook/Makefile.sgi
@@ -0,0 +1,105 @@
+# Sample makefile for rpng-x / rpng2-x / wpng for SGI using cc and make.
+# Greg Roelofs
+# Last modified:  7 March 2002
+#
+#	The programs built by this makefile are described in the book,
+#	"PNG:  The Definitive Guide," by Greg Roelofs (O'Reilly and
+#	Associates, 1999).  Go buy a copy, eh?  Buy some for friends
+#	and family, too.  (Not that this is a blatant plug or anything.)
+#
+# Invoke this makefile from a shell prompt in the usual way; for example:
+#
+#	make -f Makefile.sgi
+#
+# This makefile assumes libpng and zlib have already been built or downloaded
+# and are both installed in /usr/local/{include,lib} (as indicated by the
+# PNG* and Z* macros below).  Edit as appropriate--choose only ONE each of
+# the PNGINC, PNGLIB, ZINC and ZLIB lines.
+#
+# This makefile builds dynamically linked executables (against libpng and zlib,
+# that is), but that can be changed by uncommenting the appropriate PNGLIB and
+# ZLIB lines.
+
+
+# macros --------------------------------------------------------------------
+
+PNGINC = -I/usr/local/include/libpng16
+PNGLIB = -L/usr/local/lib -lpng16	  # dynamically linked against libpng
+#PNGLIB = /usr/local/lib/libpng16.a # statically linked against libpng
+# or:
+#PNGINC = -I../..
+#PNGLIB = -L../.. -lpng
+#PNGLIB = ../../libpng.a
+
+ZINC = -I/usr/local/include
+ZLIB = -L/usr/local/lib -lz		# dynamically linked against zlib
+#ZLIB = /usr/local/lib/libz.a		# statically linked against zlib
+#ZINC = -I../zlib
+#ZLIB = -L../zlib -lz
+#ZLIB = ../../../zlib/libz.a
+
+XINC = -I/usr/include/X11		# old-style, stock X distributions
+XLIB = -L/usr/lib/X11 -lX11
+#XINC = -I/usr/openwin/include    	# Sun workstations (OpenWindows)
+#XLIB = -L/usr/openwin/lib -lX11
+#XINC = -I/usr/X11R6/include		# new X distributions (XFree86, etc.)
+#XLIB = -L/usr/X11R6/lib -lX11
+
+INCS = $(PNGINC) $(ZINC) $(XINC)
+RLIBS = $(PNGLIB) $(ZLIB) $(XLIB) -lm
+WLIBS = $(PNGLIB) $(ZLIB)
+
+CC = cc
+LD = cc
+RM = rm -f
+# ABI must be the same as that used to build libpng.
+ABI =
+CPPFLAGS =
+CFLAGS = $(ABI) -O -fullwarn $(INCS)
+LDFLAGS = $(ABI)
+O = .o
+E =
+
+RPNG  = rpng-x
+RPNG2 = rpng2-x
+WPNG  = wpng
+
+ROBJS  = $(RPNG)$(O) readpng$(O)
+ROBJS2 = $(RPNG2)$(O) readpng2$(O)
+WOBJS  = $(WPNG)$(O) writepng$(O)
+
+EXES = $(RPNG)$(E) $(RPNG2)$(E) $(WPNG)$(E)
+
+
+# implicit make rules -------------------------------------------------------
+
+.c$(O):
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) $<
+
+
+# dependencies --------------------------------------------------------------
+
+all:  $(EXES)
+
+$(RPNG)$(E): $(ROBJS)
+	$(LD) $(LDFLAGS) -o $@ $(ROBJS) $(RLIBS)
+
+$(RPNG2)$(E): $(ROBJS2)
+	$(LD) $(LDFLAGS) -o $@ $(ROBJS2) $(RLIBS)
+
+$(WPNG)$(E): $(WOBJS)
+	$(LD) $(LDFLAGS) -o $@ $(WOBJS) $(WLIBS)
+
+$(RPNG)$(O):	$(RPNG).c readpng.h
+$(RPNG2)$(O):	$(RPNG2).c readpng2.h
+$(WPNG)$(O):	$(WPNG).c writepng.h
+
+readpng$(O):	readpng.c readpng.h
+readpng2$(O):	readpng2.c readpng2.h
+writepng$(O):	writepng.c writepng.h
+
+
+# maintenance ---------------------------------------------------------------
+
+clean:
+	$(RM) $(EXES) $(ROBJS) $(ROBJS2) $(WOBJS)
diff --git a/Engine/lib/lpng/contrib/gregbook/Makefile.unx b/Engine/lib/lpng/contrib/gregbook/Makefile.unx
new file mode 100644
index 000000000..1a73e03bf
--- /dev/null
+++ b/Engine/lib/lpng/contrib/gregbook/Makefile.unx
@@ -0,0 +1,134 @@
+# Sample makefile for rpng-x / rpng2-x / wpng using gcc and make.
+# Greg Roelofs
+# Last modified:  2 June 2007
+#
+#	The programs built by this makefile are described in the book,
+#	"PNG:  The Definitive Guide," by Greg Roelofs (O'Reilly and
+#	Associates, 1999).  Go buy a copy, eh?  Well, OK, it's not
+#	generally for sale anymore, but it's the thought that counts,
+#	right?  (Hint:  http://www.libpng.org/pub/png/book/ )
+#
+# Invoke this makefile from a shell prompt in the usual way; for example:
+#
+#	make -f Makefile.unx
+#
+# This makefile assumes libpng and zlib have already been built or downloaded
+# and are installed in /usr/local/{include,lib} or as otherwise indicated by
+# the PNG* and Z* macros below.  Edit as appropriate--choose only ONE each of
+# the PNGINC, PNGLIBd, PNGLIBs, ZINC, ZLIBd and ZLIBs lines.
+#
+# This makefile builds both dynamically and statically linked executables
+# (against libpng and zlib, that is), but that can be changed by modifying
+# the "EXES =" line.  (You need only one set, but for testing it can be handy
+# to have both.)
+
+
+# macros --------------------------------------------------------------------
+
+#PNGDIR = /usr/local/lib
+#PNGINC = -I/usr/local/include/libpng16
+#PNGLIBd = -L$(PNGDIR) -lpng16 # dynamically linked, installed libpng
+#PNGLIBs = $(PNGDIR)/libpng16.a # statically linked, installed libpng
+# or:
+PNGDIR = ../..#	this one is for libpng-x.y.z/contrib/gregbook builds
+#PNGDIR = ../libpng
+PNGINC = -I$(PNGDIR)
+PNGLIBd = -Wl,-rpath,$(PNGDIR) -L$(PNGDIR) -lpng16	# dynamically linked
+PNGLIBs = $(PNGDIR)/libpng.a		# statically linked, local libpng
+
+ZDIR = /usr/local/lib
+#ZDIR = /usr/lib64
+ZINC = -I/usr/local/include
+ZLIBd = -L$(ZDIR) -lz			# dynamically linked against zlib
+ZLIBs = $(ZDIR)/libz.a			# statically linked against zlib
+# or:
+#ZDIR = ../zlib
+#ZINC = -I$(ZDIR)
+#ZLIBd = -Wl,-rpath,$(ZDIR) -L$(ZDIR) -lz  # -rpath allows in-place testing
+#ZLIBs = $(ZDIR)/libz.a
+
+#XINC = -I/usr/include			# old-style, stock X distributions
+#XLIB = -L/usr/lib/X11 -lX11		#  (including SGI IRIX)
+#XINC = -I/usr/openwin/include		# Sun workstations (OpenWindows)
+#XLIB = -L/usr/openwin/lib -lX11
+XINC = -I/usr/X11R6/include		# new X distributions (X.org, etc.)
+XLIB = -L/usr/X11R6/lib -lX11
+#XLIB = -L/usr/X11R6/lib64 -lX11	# e.g., Red Hat on AMD64
+
+INCS = $(PNGINC) $(ZINC) $(XINC)
+RLIBSd = $(PNGLIBd) $(ZLIBd) $(XLIB) -lm
+RLIBSs = $(PNGLIBs) $(ZLIBs) $(XLIB) -lm
+WLIBSd = $(PNGLIBd) $(ZLIBd) -lm
+WLIBSs = $(PNGLIBs) $(ZLIBs) -lm
+
+CC = gcc
+LD = gcc
+RM = rm -f
+CPPFLAGS = $(INCS) -DFEATURE_LOOP
+CFLAGS = -O -Wall
+#CFLAGS = -O -W -Wall -Wextra -pedantic -ansi
+# [note that -Wall is a gcc-specific compilation flag ("most warnings on")]
+# [-ansi, -pedantic, -Wextra, and -W can also be used]
+LDFLAGS =
+O = .o
+E =
+
+RPNG   = rpng-x
+RPNG2  = rpng2-x
+WPNG   = wpng
+
+RPNGs  = $(RPNG)-static
+RPNG2s = $(RPNG2)-static
+WPNGs  = $(WPNG)-static
+
+ROBJS  = $(RPNG)$(O) readpng$(O)
+ROBJS2 = $(RPNG2)$(O) readpng2$(O)
+WOBJS  = $(WPNG)$(O) writepng$(O)
+
+STATIC_EXES  = $(RPNGs)$(E) $(RPNG2s)$(E) $(WPNGs)$(E)
+DYNAMIC_EXES = $(RPNG)$(E) $(RPNG2)$(E) $(WPNG)$(E)
+
+EXES = $(STATIC_EXES) $(DYNAMIC_EXES)
+
+
+# implicit make rules -------------------------------------------------------
+
+.c$(O):
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) $<
+
+
+# dependencies --------------------------------------------------------------
+
+all:  $(EXES)
+
+$(RPNGs)$(E): $(ROBJS)
+	$(LD) $(LDFLAGS) -o $@ $(ROBJS) $(RLIBSs)
+
+$(RPNG)$(E): $(ROBJS)
+	$(LD) $(LDFLAGS) -o $@ $(ROBJS) $(RLIBSd)
+
+$(RPNG2s)$(E): $(ROBJS2)
+	$(LD) $(LDFLAGS) -o $@ $(ROBJS2) $(RLIBSs)
+
+$(RPNG2)$(E): $(ROBJS2)
+	$(LD) $(LDFLAGS) -o $@ $(ROBJS2) $(RLIBSd)
+
+$(WPNGs)$(E): $(WOBJS)
+	$(LD) $(LDFLAGS) -o $@ $(WOBJS) $(WLIBSs)
+
+$(WPNG)$(E): $(WOBJS)
+	$(LD) $(LDFLAGS) -o $@ $(WOBJS) $(WLIBSd)
+
+$(RPNG)$(O):	$(RPNG).c readpng.h
+$(RPNG2)$(O):	$(RPNG2).c readpng2.h
+$(WPNG)$(O):	$(WPNG).c writepng.h
+
+readpng$(O):	readpng.c readpng.h
+readpng2$(O):	readpng2.c readpng2.h
+writepng$(O):	writepng.c writepng.h
+
+
+# maintenance ---------------------------------------------------------------
+
+clean:
+	$(RM) $(EXES) $(ROBJS) $(ROBJS2) $(WOBJS)
diff --git a/Engine/lib/lpng/contrib/gregbook/Makefile.w32 b/Engine/lib/lpng/contrib/gregbook/Makefile.w32
new file mode 100644
index 000000000..ab7dcf7ca
--- /dev/null
+++ b/Engine/lib/lpng/contrib/gregbook/Makefile.w32
@@ -0,0 +1,114 @@
+# Sample makefile for rpng-win / rpng2-win / wpng using MSVC and NMAKE.
+# Greg Roelofs
+# Last modified:  2 June 2007
+#
+#	The programs built by this makefile are described in the book,
+#	"PNG:  The Definitive Guide," by Greg Roelofs (O'Reilly and
+#	Associates, 1999).  Go buy a copy, eh?  Well, OK, it's not
+#	generally for sale anymore, but it's the thought that counts,
+#	right?  (Hint:  http://www.libpng.org/pub/png/book/ )
+#
+# Invoke this makefile from a DOS prompt window via:
+#
+#	%devstudio%\vc\bin\vcvars32.bat
+#	nmake -nologo -f Makefile.w32
+#
+# where %devstudio% is the installation directory for MSVC / DevStudio.  If
+# you get "environment out of space" errors, create a desktop shortcut with
+# "c:\windows\command.com /e:4096" as the program command line and set the
+# working directory to this directory.  Then double-click to open the new
+# DOS-prompt window with a bigger environment and retry the commands above.
+#
+# This makefile assumes libpng and zlib have already been built or downloaded
+# and are in subdirectories at the same level as the current subdirectory
+# (as indicated by the PNGPATH and ZPATH macros below).  Edit as appropriate.
+#
+# Note that the names of the dynamic and static libpng and zlib libraries
+# used below may change in later releases of the libraries.  This makefile
+# builds statically linked executables, but that can be changed by uncom-
+# menting the appropriate PNGLIB and ZLIB lines.
+
+!include <ntwin32.mak>
+
+
+# macros --------------------------------------------------------------------
+
+PNGPATH = ../libpng
+PNGINC = -I$(PNGPATH)
+#PNGLIB = $(PNGPATH)/pngdll.lib
+PNGLIB = $(PNGPATH)/libpng.lib
+
+ZPATH = ../zlib
+ZINC = -I$(ZPATH)
+#ZLIB = $(ZPATH)/zlibdll.lib
+ZLIB = $(ZPATH)/zlibstat.lib
+
+WINLIBS = -defaultlib:user32.lib gdi32.lib
+# ["real" apps may also need comctl32.lib, comdlg32.lib, winmm.lib, etc.]
+
+INCS = $(PNGINC) $(ZINC)
+RLIBS = $(PNGLIB) $(ZLIB) $(WINLIBS)
+WLIBS = $(PNGLIB) $(ZLIB)
+
+CC = cl
+LD = link
+RM = del
+CPPFLAGS = $(INCS)
+CFLAGS = -nologo -O -W3 $(cvars)
+# [note that -W3 is an MSVC-specific compilation flag ("all warnings on")]
+# [see %devstudio%\vc\include\win32.mak for cvars macro definition]
+O = .obj
+E = .exe
+
+RLDFLAGS = -nologo -subsystem:windows
+WLDFLAGS = -nologo
+
+RPNG  = rpng-win
+RPNG2 = rpng2-win
+WPNG  = wpng
+
+ROBJS  = $(RPNG)$(O) readpng$(O)
+ROBJS2 = $(RPNG2)$(O) readpng2$(O)
+WOBJS  = $(WPNG)$(O) writepng$(O)
+
+EXES = $(RPNG)$(E) $(RPNG2)$(E) $(WPNG)$(E)
+
+
+# implicit make rules -------------------------------------------------------
+
+.c$(O):
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) $<
+
+
+# dependencies --------------------------------------------------------------
+
+all:  $(EXES)
+
+$(RPNG)$(E): $(ROBJS)
+	$(LD) $(RLDFLAGS) -out:$@ $(ROBJS) $(RLIBS)
+
+$(RPNG2)$(E): $(ROBJS2)
+	$(LD) $(RLDFLAGS) -out:$@ $(ROBJS2) $(RLIBS)
+
+$(WPNG)$(E): $(WOBJS)
+	$(LD) $(WLDFLAGS) -out:$@ $(WOBJS) $(WLIBS)
+
+$(RPNG)$(O):	$(RPNG).c readpng.h
+$(RPNG2)$(O):	$(RPNG2).c readpng2.h
+$(WPNG)$(O):	$(WPNG).c writepng.h
+
+readpng$(O):	readpng.c readpng.h
+readpng2$(O):	readpng2.c readpng2.h
+writepng$(O):	writepng.c writepng.h
+
+
+# maintenance ---------------------------------------------------------------
+
+clean:
+#	ideally we could just do this:
+#	$(RM) $(EXES) $(ROBJS) $(ROBJS2) $(WOBJS)
+#	...but the Windows "DEL" command is none too bright, so:
+	$(RM) r*$(E)
+	$(RM) w*$(E)
+	$(RM) r*$(O)
+	$(RM) w*$(O)
diff --git a/Engine/lib/lpng/contrib/gregbook/README b/Engine/lib/lpng/contrib/gregbook/README
new file mode 100644
index 000000000..90e28f7ce
--- /dev/null
+++ b/Engine/lib/lpng/contrib/gregbook/README
@@ -0,0 +1,186 @@
+                     ===========================
+                      PNG: The Definitive Guide
+                     ===========================
+
+                             Source Code
+
+Chapters 13, 14 and 15 of "PNG: The Definitive Guide" discuss three free,
+cross-platform demo programs that show how to use the libpng reference
+library:  rpng, rpng2 and wpng.  rpng and rpng2 are viewers; the first is
+a very simple example that that shows how a standard file-viewer might use
+libpng, while the second is designed to process streaming data and shows
+how a web browser might be written.  wpng is a simple command-line program
+that reads binary PGM and PPM files (the ``raw'' grayscale and RGB subsets
+of PBMPLUS/NetPBM) and converts them to PNG.
+
+The source code for all three demo programs currently compiles under
+Unix, OpenVMS, and 32-bit Windows.  (Special thanks to Martin Zinser,
+zinser at decus.de, for making the necessary changes for OpenVMS and for
+providing an appropriate build script.)  Build instructions can be found
+below.
+
+Files:
+
+   README             this file
+   LICENSE            terms of distribution and reuse (BSD-like or GNU GPL)
+   COPYING            GNU General Public License (GPL)
+
+   Makefile.unx       Unix makefile
+   Makefile.w32       Windows (MSVC) makefile
+   makevms.com        OpenVMS build script
+
+   rpng-win.c         Windows front end for the basic viewer
+   rpng-x.c           X Window System (Unix, OpenVMS) front end
+   readpng.c          generic back end for the basic viewer
+   readpng.h          header file for the basic viewer
+
+   rpng2-win.c        Windows front end for the progressive viewer
+   rpng2-x.c          X front end for the progressive viewer
+   readpng2.c         generic back end for the progressive viewer
+   readpng2.h         header file for the progressive viewer
+
+   wpng.c             generic (text) front end for the converter
+   writepng.c         generic back end for the converter
+   writepng.h         header file for the converter
+
+   toucan.png         transparent PNG for testing (by Stefan Schneider)
+
+Note that, although the programs are designed to be functional, their
+primary purpose is to illustrate how to use libpng to add PNG support to
+other programs.  As such, their user interfaces are crude and definitely
+are not intended for everyday use.
+
+Please see http://www.libpng.org/pub/png/pngbook.html for further infor-
+mation and links to the latest version of the source code, and Chapters
+13-15 of the book for detailed discussion of the three programs.
+
+Greg Roelofs
+https://pobox.com/~newt/greg_contact.html
+16 March 2008
+
+
+BUILD INSTRUCTIONS
+
+ - Prerequisites (in order of compilation):
+
+      - zlib            https://zlib.net/
+      - libpng          http://www.libpng.org/pub/png/libpng.html
+      - pngbook         http://www.libpng.org/pub/png/book/sources.html
+
+     The pngbook demo programs are explicitly designed to demonstrate proper
+     coding techniques for using the libpng reference library.  As a result,
+     you need to download and build both zlib (on which libpng depends) and
+     libpng.  A common build setup is to place the zlib, libpng and pngbook
+     subdirectory trees ("folders") in the same parent directory.  Then the
+     libpng build can refer to files in ../zlib (or ..\zlib or [-.zlib]),
+     and similarly for the pngbook build.
+
+     Note that all three packages are designed to be built from a command
+     line by default; those who wish to use a graphical or other integrated
+     development environments are on their own.
+
+
+ - Unix:
+
+     Unpack the latest pngbook sources (which should correspond to this
+     README file) into a directory and change into that directory.
+
+     Copy Makefile.unx to Makefile and edit the PNG* and Z* variables
+     appropriately (possibly also the X* variables if necessary).
+
+     make
+
+     There is no "install" target, so copy the three executables somewhere
+     in your path or run them from the current directory.  All three will
+     print a basic usage screen when run without any command-line arguments;
+     see the book for more details.
+
+
+ - Windows:
+
+     Unpack the latest pngbook sources (which should correspond to this
+     README file) into a folder, open a "DOS shell" or "command prompt"
+     or equivalent command-line window, and cd into the folder where you
+     unpacked the source code.
+
+     For MSVC, set up the necessary environment variables by invoking
+
+        %devstudio%\vc\bin\vcvars32.bat
+
+     where where %devstudio% is the installation directory for MSVC /
+     DevStudio.  If you get "environment out of space" errors under 95/98,
+     create a desktop shortcut with "c:\windows\command.com /e:4096" as
+     the program command line and set the working directory to the pngbook
+     directory.  Then double-click to open the new DOS-prompt window with
+     a bigger environment and retry the commands above.
+
+     Copy Makefile.w32 to Makefile and edit the PNGPATH and ZPATH variables
+     appropriately (possibly also the "INC" and "LIB" variables if needed).
+     Note that the names of the dynamic and static libpng and zlib libraries
+     used in the makefile may change in later releases of the libraries.
+     Also note that, as of libpng version 1.0.5, MSVC DLL builds do not work.
+     This makefile therefore builds statically linked executables, but if
+     the DLL problems ever get fixed, uncommenting the appropriate PNGLIB
+     and ZLIB lines will build dynamically linked executables instead.
+
+     Do the build by typing
+
+        nmake
+
+     The result should be three executables:  rpng-win.exe, rpng2-win.exe,
+     and wpng.exe.  Copy them somewhere in your PATH or run them from the
+     current folder.  Like the Unix versions, the two windowed programs
+     (rpng and rpng2) now display a usage screen in a console window when
+     invoked without command-line arguments; this is new behavior as of
+     the June 2001 release.  Note that the programs use the Unix-style "-"
+     character to specify options, instead of the more common DOS/Windows
+     "/" character.  (For example:  "rpng2-win -bgpat 4 foo.png", not
+     "rpng2-win /bgpat 4 foo.png")
+
+
+ - OpenVMS:
+
+     Unpack the pngbook sources into a subdirectory and change into that
+     subdirectory.
+
+     Edit makevms.com appropriately, specifically the zpath and pngpath
+     variables.
+
+     @makevms
+
+     To run the programs, they probably first need to be set up as "foreign
+     symbols," with "disk" and "dir" set appropriately:
+
+     $ rpng  == "$disk:[dir]rpng-x.exe"
+     $ rpng2 == "$disk:[dir]rpng2-x.exe"
+     $ wpng  == "$disk:[dir]wpng.exe"
+
+     All three will print a basic usage screen when run without any command-
+     line arguments; see the book for more details.  Note that the options
+     style is Unix-like, i.e., preceded by "-" rather than "/".
+
+
+RUNNING THE PROGRAMS:  (VERY) BRIEF INTRO
+
+     rpng is a simple PNG viewer that can display transparent PNGs with a
+     specified background color; for example,
+
+        rpng -bgcolor \#ff0000 toucan.png
+
+     would display the image with a red background.  rpng2 is a progressive
+     viewer that simulates a web browser in some respects; it can display
+     images against either a background color or a dynamically generated
+     background image.  For example:
+
+        rpng2 -bgpat 16 toucan.png
+
+     wpng is a purely command-line image converter from binary PBMPLUS/NetPBM
+     format (.pgm or .ppm) to PNG; for example,
+
+        wpng -time < toucan-notrans.ppm > toucan-notrans.png
+
+     would convert the specified PPM file (using redirection) to PNG, auto-
+     matically setting the PNG modification-time chunk.
+
+     All options can be abbreviated to the shortest unique value; for example,
+     "-bgc" for -bgcolor (versus "-bgp" for -bgpat), or "-g" for -gamma.
diff --git a/Engine/lib/lpng/contrib/gregbook/makevms.com b/Engine/lib/lpng/contrib/gregbook/makevms.com
new file mode 100644
index 000000000..f32bcaba7
--- /dev/null
+++ b/Engine/lib/lpng/contrib/gregbook/makevms.com
@@ -0,0 +1,132 @@
+$!------------------------------------------------------------------------------
+$! make "PNG: The Definitive Guide" demo programs (for X) under OpenVMS
+$!
+$! Script created by Martin Zinser for libpng; modified by Greg Roelofs
+$! for standalone pngbook source distribution.
+$!
+$!
+$!    Set locations where zlib and libpng sources live.
+$!
+$ zpath   = ""
+$ pngpath = ""
+$!
+$ if f$search("[---.zlib]zlib.h").nes."" then zpath = "[---.zlib]"
+$ if f$search("[--]png.h").nes."" then pngpath = "[--]"
+$!
+$ if f$search("[-.zlib]zlib.h").nes."" then zpath = "[-.zlib]"
+$ if f$search("[-.libpng]png.h").nes."" then pngpath = "[-.libpng]"
+$!
+$ if zpath .eqs. ""
+$ then
+$   write sys$output "zlib include not found. Exiting..."
+$   exit 2
+$ endif
+$!
+$ if pngpath .eqs. ""
+$ then
+$   write sys$output "libpng include not found. Exiting..."
+$   exit 2
+$ endif
+$!
+$!    Look for the compiler used.
+$!
+$ ccopt="/include=(''zpath',''pngpath')"
+$ if f$getsyi("HW_MODEL").ge.1024
+$ then
+$  ccopt = "/prefix=all"+ccopt
+$  comp  = "__decc__=1"
+$  if f$trnlnm("SYS").eqs."" then define sys sys$library:
+$ else
+$  if f$search("SYS$SYSTEM:DECC$COMPILER.EXE").eqs.""
+$   then
+$    if f$trnlnm("SYS").eqs."" then define sys sys$library:
+$    if f$search("SYS$SYSTEM:VAXC.EXE").eqs.""
+$     then
+$      comp  = "__gcc__=1"
+$      CC :== GCC
+$     else
+$      comp = "__vaxc__=1"
+$     endif
+$   else
+$    if f$trnlnm("SYS").eqs."" then define sys decc$library_include:
+$    ccopt = "/decc/prefix=all"+ccopt
+$    comp  = "__decc__=1"
+$  endif
+$ endif
+$ open/write lopt lib.opt
+$ write lopt "''pngpath'libpng.olb/lib"
+$ write lopt "''zpath'libz.olb/lib"
+$ close lopt
+$ open/write xopt x11.opt
+$ write xopt "sys$library:decw$xlibshr.exe/share"
+$ close xopt
+$!
+$!    Build 'em.
+$!
+$ write sys$output "Compiling PNG book programs ..."
+$   CALL MAKE readpng.OBJ "cc ''CCOPT' readpng" -
+	readpng.c readpng.h
+$   CALL MAKE readpng2.OBJ "cc ''CCOPT' readpng2" -
+	readpng2.c readpng2.h
+$   CALL MAKE writepng.OBJ "cc ''CCOPT' writepng" -
+	writepng.c writepng.h
+$   write sys$output "Building rpng-x..."
+$   CALL MAKE rpng-x.OBJ "cc ''CCOPT' rpng-x" -
+	rpng-x.c readpng.h
+$   call make rpng-x.exe -
+	"LINK rpng-x,readpng,lib.opt/opt,x11.opt/opt" -
+	rpng-x.obj readpng.obj
+$   write sys$output "Building rpng2-x..."
+$   CALL MAKE rpng2-x.OBJ "cc ''CCOPT' rpng2-x" -
+	rpng2-x.c readpng2.h
+$   call make rpng2-x.exe -
+	"LINK rpng2-x,readpng2,lib.opt/opt,x11.opt/opt" -
+	rpng2-x.obj readpng2.obj
+$   write sys$output "Building wpng..."
+$   CALL MAKE wpng.OBJ "cc ''CCOPT' wpng" -
+	wpng.c writepng.h
+$   call make wpng.exe -
+	"LINK wpng,writepng,lib.opt/opt" -
+	wpng.obj writepng.obj
+$ exit
+$!
+$!
+$MAKE: SUBROUTINE   !SUBROUTINE TO CHECK DEPENDENCIES
+$ V = 'F$Verify(0)
+$! P1 = What we are trying to make
+$! P2 = Command to make it
+$! P3 - P8  What it depends on
+$
+$ If F$Search(P1) .Eqs. "" Then Goto Makeit
+$ Time = F$CvTime(F$File(P1,"RDT"))
+$arg=3
+$Loop:
+$       Argument = P'arg
+$       If Argument .Eqs. "" Then Goto Exit
+$       El=0
+$Loop2:
+$       File = F$Element(El," ",Argument)
+$       If File .Eqs. " " Then Goto Endl
+$       AFile = ""
+$Loop3:
+$       OFile = AFile
+$       AFile = F$Search(File)
+$       If AFile .Eqs. "" .Or. AFile .Eqs. OFile Then Goto NextEl
+$       If F$CvTime(F$File(AFile,"RDT")) .Ges. Time Then Goto Makeit
+$       Goto Loop3
+$NextEL:
+$       El = El + 1
+$       Goto Loop2
+$EndL:
+$ arg=arg+1
+$ If arg .Le. 8 Then Goto Loop
+$ Goto Exit
+$
+$Makeit:
+$ VV=F$VERIFY(0)
+$ write sys$output P2
+$ 'P2
+$ VV='F$Verify(VV)
+$Exit:
+$ If V Then Set Verify
+$ENDSUBROUTINE
diff --git a/Engine/lib/lpng/contrib/gregbook/readpng.c b/Engine/lib/lpng/contrib/gregbook/readpng.c
new file mode 100644
index 000000000..fad9b536a
--- /dev/null
+++ b/Engine/lib/lpng/contrib/gregbook/readpng.c
@@ -0,0 +1,323 @@
+/*---------------------------------------------------------------------------
+
+   rpng - simple PNG display program                              readpng.c
+
+  ---------------------------------------------------------------------------
+
+      Copyright (c) 1998-2007,2017 Greg Roelofs.  All rights reserved.
+
+      This software is provided "as is," without warranty of any kind,
+      express or implied.  In no event shall the author or contributors
+      be held liable for any damages arising in any way from the use of
+      this software.
+
+      The contents of this file are DUAL-LICENSED.  You may modify and/or
+      redistribute this software according to the terms of one of the
+      following two licenses (at your option):
+
+
+      LICENSE 1 ("BSD-like with advertising clause"):
+
+      Permission is granted to anyone to use this software for any purpose,
+      including commercial applications, and to alter it and redistribute
+      it freely, subject to the following restrictions:
+
+      1. Redistributions of source code must retain the above copyright
+         notice, disclaimer, and this list of conditions.
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, disclaimer, and this list of conditions in the documenta-
+         tion and/or other materials provided with the distribution.
+      3. All advertising materials mentioning features or use of this
+         software must display the following acknowledgment:
+
+            This product includes software developed by Greg Roelofs
+            and contributors for the book, "PNG: The Definitive Guide,"
+            published by O'Reilly and Associates.
+
+
+      LICENSE 2 (GNU GPL v2 or later):
+
+      This program is free software; you can redistribute it and/or modify
+      it under the terms of the GNU General Public License as published by
+      the Free Software Foundation; either version 2 of the License, or
+      (at your option) any later version.
+
+      This program is distributed in the hope that it will be useful,
+      but WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+      GNU General Public License for more details.
+
+      You should have received a copy of the GNU General Public License
+      along with this program; if not, write to the Free Software Foundation,
+      Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  ---------------------------------------------------------------------------*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <zlib.h>
+
+#include "png.h"        /* libpng header */
+#include "readpng.h"    /* typedefs, common macros, public prototypes */
+
+/* future versions of libpng will provide this macro: */
+#ifndef png_jmpbuf
+#  define png_jmpbuf(png_ptr)   ((png_ptr)->jmpbuf)
+#endif
+
+
+static png_structp png_ptr = NULL;
+static png_infop info_ptr = NULL;
+
+png_uint_32  width, height;
+int  bit_depth, color_type;
+uch  *image_data = NULL;
+
+
+void readpng_version_info(void)
+{
+    fprintf(stderr, "   Compiled with libpng %s; using libpng %s.\n",
+      PNG_LIBPNG_VER_STRING, png_libpng_ver);
+    fprintf(stderr, "   Compiled with zlib %s; using zlib %s.\n",
+      ZLIB_VERSION, zlib_version);
+}
+
+
+/* return value = 0 for success, 1 for bad sig, 2 for bad IHDR, 4 for no mem */
+
+int readpng_init(FILE *infile, ulg *pWidth, ulg *pHeight)
+{
+    uch sig[8];
+
+
+    /* first do a quick check that the file really is a PNG image; could
+     * have used slightly more general png_sig_cmp() function instead */
+
+    fread(sig, 1, 8, infile);
+    if (png_sig_cmp(sig, 0, 8))
+        return 1;   /* bad signature */
+
+
+    /* could pass pointers to user-defined error handlers instead of NULLs: */
+
+    png_ptr = png_create_read_struct(png_get_libpng_ver(NULL), NULL, NULL,
+        NULL);
+    if (!png_ptr)
+        return 4;   /* out of memory */
+
+    info_ptr = png_create_info_struct(png_ptr);
+    if (!info_ptr) {
+        png_destroy_read_struct(&png_ptr, NULL, NULL);
+        return 4;   /* out of memory */
+    }
+
+
+    /* we could create a second info struct here (end_info), but it's only
+     * useful if we want to keep pre- and post-IDAT chunk info separated
+     * (mainly for PNG-aware image editors and converters) */
+
+
+    /* setjmp() must be called in every function that calls a PNG-reading
+     * libpng function */
+
+    if (setjmp(png_jmpbuf(png_ptr))) {
+        png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+        return 2;
+    }
+
+
+    png_init_io(png_ptr, infile);
+    png_set_sig_bytes(png_ptr, 8);  /* we already read the 8 signature bytes */
+
+    png_read_info(png_ptr, info_ptr);  /* read all PNG info up to image data */
+
+
+    /* alternatively, could make separate calls to png_get_image_width(),
+     * etc., but want bit_depth and color_type for later [don't care about
+     * compression_type and filter_type => NULLs] */
+
+    png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
+      NULL, NULL, NULL);
+    *pWidth = width;
+    *pHeight = height;
+
+
+    /* OK, that's all we need for now; return happy */
+
+    return 0;
+}
+
+
+
+
+/* returns 0 if succeeds, 1 if fails due to no bKGD chunk, 2 if libpng error;
+ * scales values to 8-bit if necessary */
+
+int readpng_get_bgcolor(uch *red, uch *green, uch *blue)
+{
+    png_color_16p pBackground;
+
+
+    /* setjmp() must be called in every function that calls a PNG-reading
+     * libpng function */
+
+    if (setjmp(png_jmpbuf(png_ptr))) {
+        png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+        return 2;
+    }
+
+
+    if (!png_get_valid(png_ptr, info_ptr, PNG_INFO_bKGD))
+        return 1;
+
+    /* it is not obvious from the libpng documentation, but this function
+     * takes a pointer to a pointer, and it always returns valid red, green
+     * and blue values, regardless of color_type: */
+
+    png_get_bKGD(png_ptr, info_ptr, &pBackground);
+
+
+    /* however, it always returns the raw bKGD data, regardless of any
+     * bit-depth transformations, so check depth and adjust if necessary */
+
+    if (bit_depth == 16) {
+        *red   = pBackground->red   >> 8;
+        *green = pBackground->green >> 8;
+        *blue  = pBackground->blue  >> 8;
+    } else if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) {
+        if (bit_depth == 1)
+            *red = *green = *blue = pBackground->gray? 255 : 0;
+        else if (bit_depth == 2)
+            *red = *green = *blue = (255/3) * pBackground->gray;
+        else /* bit_depth == 4 */
+            *red = *green = *blue = (255/15) * pBackground->gray;
+    } else {
+        *red   = (uch)pBackground->red;
+        *green = (uch)pBackground->green;
+        *blue  = (uch)pBackground->blue;
+    }
+
+    return 0;
+}
+
+
+
+
+/* display_exponent == LUT_exponent * CRT_exponent */
+
+uch *readpng_get_image(double display_exponent, int *pChannels, ulg *pRowbytes)
+{
+    double  gamma;
+    png_uint_32  i, rowbytes;
+    png_bytepp  row_pointers = NULL;
+
+
+    /* setjmp() must be called in every function that calls a PNG-reading
+     * libpng function */
+
+    if (setjmp(png_jmpbuf(png_ptr))) {
+        free(image_data);
+        image_data = NULL;
+        free(row_pointers);
+        row_pointers = NULL;
+        png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+        return NULL;
+    }
+
+
+    /* expand palette images to RGB, low-bit-depth grayscale images to 8 bits,
+     * transparency chunks to full alpha channel; strip 16-bit-per-sample
+     * images to 8 bits per sample; and convert grayscale to RGB[A] */
+
+    if (color_type == PNG_COLOR_TYPE_PALETTE)
+        png_set_expand(png_ptr);
+    if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
+        png_set_expand(png_ptr);
+    if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
+        png_set_expand(png_ptr);
+#ifdef PNG_READ_16_TO_8_SUPPORTED
+    if (bit_depth == 16)
+#  ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
+        png_set_scale_16(png_ptr);
+#  else
+        png_set_strip_16(png_ptr);
+#  endif
+#endif
+    if (color_type == PNG_COLOR_TYPE_GRAY ||
+        color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+        png_set_gray_to_rgb(png_ptr);
+
+
+    /* unlike the example in the libpng documentation, we have *no* idea where
+     * this file may have come from--so if it doesn't have a file gamma, don't
+     * do any correction ("do no harm") */
+
+    if (png_get_gAMA(png_ptr, info_ptr, &gamma))
+        png_set_gamma(png_ptr, display_exponent, gamma);
+
+
+    /* all transformations have been registered; now update info_ptr data,
+     * get rowbytes and channels, and allocate image memory */
+
+    png_read_update_info(png_ptr, info_ptr);
+
+    *pRowbytes = rowbytes = png_get_rowbytes(png_ptr, info_ptr);
+    *pChannels = (int)png_get_channels(png_ptr, info_ptr);
+
+    /* Guard against integer overflow */
+    if (height > ((size_t)(-1))/rowbytes) {
+        fprintf(stderr, "readpng:  image_data buffer would be too large\n",
+        return NULL;
+    }
+
+    if ((image_data = (uch *)malloc(rowbytes*height)) == NULL) {
+        png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+        return NULL;
+    }
+    if ((row_pointers = (png_bytepp)malloc(height*sizeof(png_bytep))) == NULL) {
+        png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+        free(image_data);
+        image_data = NULL;
+        return NULL;
+    }
+
+    Trace((stderr, "readpng_get_image:  channels = %d, rowbytes = %ld, height = %ld\n",
+        *pChannels, rowbytes, height));
+
+
+    /* set the individual row_pointers to point at the correct offsets */
+
+    for (i = 0;  i < height;  ++i)
+        row_pointers[i] = image_data + i*rowbytes;
+
+
+    /* now we can go ahead and just read the whole image */
+
+    png_read_image(png_ptr, row_pointers);
+
+
+    /* and we're done!  (png_read_end() can be omitted if no processing of
+     * post-IDAT text/time/etc. is desired) */
+
+    free(row_pointers);
+    row_pointers = NULL;
+
+    png_read_end(png_ptr, NULL);
+
+    return image_data;
+}
+
+
+void readpng_cleanup(int free_image_data)
+{
+    if (free_image_data && image_data) {
+        free(image_data);
+        image_data = NULL;
+    }
+
+    if (png_ptr && info_ptr) {
+        png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+        png_ptr = NULL;
+        info_ptr = NULL;
+    }
+}
diff --git a/Engine/lib/lpng/contrib/gregbook/readpng.h b/Engine/lib/lpng/contrib/gregbook/readpng.h
new file mode 100644
index 000000000..fad9fe3b4
--- /dev/null
+++ b/Engine/lib/lpng/contrib/gregbook/readpng.h
@@ -0,0 +1,88 @@
+/*---------------------------------------------------------------------------
+
+   rpng - simple PNG display program                              readpng.h
+
+  ---------------------------------------------------------------------------
+
+      Copyright (c) 1998-2007 Greg Roelofs.  All rights reserved.
+
+      This software is provided "as is," without warranty of any kind,
+      express or implied.  In no event shall the author or contributors
+      be held liable for any damages arising in any way from the use of
+      this software.
+
+      The contents of this file are DUAL-LICENSED.  You may modify and/or
+      redistribute this software according to the terms of one of the
+      following two licenses (at your option):
+
+
+      LICENSE 1 ("BSD-like with advertising clause"):
+
+      Permission is granted to anyone to use this software for any purpose,
+      including commercial applications, and to alter it and redistribute
+      it freely, subject to the following restrictions:
+
+      1. Redistributions of source code must retain the above copyright
+         notice, disclaimer, and this list of conditions.
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, disclaimer, and this list of conditions in the documenta-
+         tion and/or other materials provided with the distribution.
+      3. All advertising materials mentioning features or use of this
+         software must display the following acknowledgment:
+
+            This product includes software developed by Greg Roelofs
+            and contributors for the book, "PNG: The Definitive Guide,"
+            published by O'Reilly and Associates.
+
+
+      LICENSE 2 (GNU GPL v2 or later):
+
+      This program is free software; you can redistribute it and/or modify
+      it under the terms of the GNU General Public License as published by
+      the Free Software Foundation; either version 2 of the License, or
+      (at your option) any later version.
+
+      This program is distributed in the hope that it will be useful,
+      but WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+      GNU General Public License for more details.
+
+      You should have received a copy of the GNU General Public License
+      along with this program; if not, write to the Free Software Foundation,
+      Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  ---------------------------------------------------------------------------*/
+
+#ifndef TRUE
+#  define TRUE 1
+#  define FALSE 0
+#endif
+
+#ifndef MAX
+#  define MAX(a,b)  ((a) > (b)? (a) : (b))
+#  define MIN(a,b)  ((a) < (b)? (a) : (b))
+#endif
+
+#ifdef DEBUG
+#  define Trace(x)  {fprintf x ; fflush(stderr); fflush(stdout);}
+#else
+#  define Trace(x)  ;
+#endif
+
+typedef unsigned char   uch;
+typedef unsigned short  ush;
+typedef unsigned long   ulg;
+
+
+/* prototypes for public functions in readpng.c */
+
+void readpng_version_info(void);
+
+int readpng_init(FILE *infile, ulg *pWidth, ulg *pHeight);
+
+int readpng_get_bgcolor(uch *bg_red, uch *bg_green, uch *bg_blue);
+
+uch *readpng_get_image(double display_exponent, int *pChannels,
+                       ulg *pRowbytes);
+
+void readpng_cleanup(int free_image_data);
diff --git a/Engine/lib/lpng/contrib/gregbook/readpng2.c b/Engine/lib/lpng/contrib/gregbook/readpng2.c
new file mode 100644
index 000000000..610b3cd87
--- /dev/null
+++ b/Engine/lib/lpng/contrib/gregbook/readpng2.c
@@ -0,0 +1,521 @@
+/*---------------------------------------------------------------------------
+
+   rpng2 - progressive-model PNG display program                 readpng2.c
+
+  ---------------------------------------------------------------------------
+
+      Copyright (c) 1998-2015 Greg Roelofs.  All rights reserved.
+
+      This software is provided "as is," without warranty of any kind,
+      express or implied.  In no event shall the author or contributors
+      be held liable for any damages arising in any way from the use of
+      this software.
+
+      The contents of this file are DUAL-LICENSED.  You may modify and/or
+      redistribute this software according to the terms of one of the
+      following two licenses (at your option):
+
+
+      LICENSE 1 ("BSD-like with advertising clause"):
+
+      Permission is granted to anyone to use this software for any purpose,
+      including commercial applications, and to alter it and redistribute
+      it freely, subject to the following restrictions:
+
+      1. Redistributions of source code must retain the above copyright
+         notice, disclaimer, and this list of conditions.
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, disclaimer, and this list of conditions in the documenta-
+         tion and/or other materials provided with the distribution.
+      3. All advertising materials mentioning features or use of this
+         software must display the following acknowledgment:
+
+            This product includes software developed by Greg Roelofs
+            and contributors for the book, "PNG: The Definitive Guide,"
+            published by O'Reilly and Associates.
+
+
+      LICENSE 2 (GNU GPL v2 or later):
+
+      This program is free software; you can redistribute it and/or modify
+      it under the terms of the GNU General Public License as published by
+      the Free Software Foundation; either version 2 of the License, or
+      (at your option) any later version.
+
+      This program is distributed in the hope that it will be useful,
+      but WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+      GNU General Public License for more details.
+
+      You should have received a copy of the GNU General Public License
+      along with this program; if not, write to the Free Software Foundation,
+      Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  ---------------------------------------------------------------------------
+
+   Changelog:
+     2015-11-12 - Check return value of png_get_bKGD() (Glenn R-P)
+     2017-04-22 - Guard against integer overflow (Glenn R-P)
+
+  ---------------------------------------------------------------------------*/
+
+
+#include <stdlib.h>     /* for exit() prototype */
+#include <setjmp.h>
+
+#include <zlib.h>
+#include "png.h"        /* libpng header from the local directory */
+#include "readpng2.h"   /* typedefs, common macros, public prototypes */
+
+
+/* local prototypes */
+
+static void readpng2_info_callback(png_structp png_ptr, png_infop info_ptr);
+static void readpng2_row_callback(png_structp png_ptr, png_bytep new_row,
+                                 png_uint_32 row_num, int pass);
+static void readpng2_end_callback(png_structp png_ptr, png_infop info_ptr);
+static void readpng2_error_handler(png_structp png_ptr, png_const_charp msg);
+static void readpng2_warning_handler(png_structp png_ptr, png_const_charp msg);
+
+
+
+
+void readpng2_version_info(void)
+{
+    fprintf(stderr, "   Compiled with libpng %s; using libpng %s\n",
+      PNG_LIBPNG_VER_STRING, png_libpng_ver);
+
+    fprintf(stderr, "   and with zlib %s; using zlib %s.\n",
+      ZLIB_VERSION, zlib_version);
+}
+
+
+
+
+int readpng2_check_sig(uch *sig, int num)
+{
+    return !png_sig_cmp(sig, 0, num);
+}
+
+
+
+
+/* returns 0 for success, 2 for libpng problem, 4 for out of memory */
+
+int readpng2_init(mainprog_info *mainprog_ptr)
+{
+    png_structp  png_ptr;       /* note:  temporary variables! */
+    png_infop  info_ptr;
+
+
+    /* could also replace libpng warning-handler (final NULL), but no need: */
+
+    png_ptr = png_create_read_struct(png_get_libpng_ver(NULL), mainprog_ptr,
+      readpng2_error_handler, readpng2_warning_handler);
+    if (!png_ptr)
+        return 4;   /* out of memory */
+
+    info_ptr = png_create_info_struct(png_ptr);
+    if (!info_ptr) {
+        png_destroy_read_struct(&png_ptr, NULL, NULL);
+        return 4;   /* out of memory */
+    }
+
+
+    /* we could create a second info struct here (end_info), but it's only
+     * useful if we want to keep pre- and post-IDAT chunk info separated
+     * (mainly for PNG-aware image editors and converters) */
+
+
+    /* setjmp() must be called in every function that calls a PNG-reading
+     * libpng function, unless an alternate error handler was installed--
+     * but compatible error handlers must either use longjmp() themselves
+     * (as in this program) or exit immediately, so here we are: */
+
+    if (setjmp(mainprog_ptr->jmpbuf)) {
+        png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+        return 2;
+    }
+
+
+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+    /* prepare the reader to ignore all recognized chunks whose data won't be
+     * used, i.e., all chunks recognized by libpng except for IHDR, PLTE, IDAT,
+     * IEND, tRNS, bKGD, gAMA, and sRGB (small performance improvement) */
+    {
+        /* These byte strings were copied from png.h.  If a future version
+         * of readpng2.c recognizes more chunks, add them to this list.
+         */
+        static const png_byte chunks_to_process[] = {
+            98,  75,  71,  68, '\0',  /* bKGD */
+           103,  65,  77,  65, '\0',  /* gAMA */
+           115,  82,  71,  66, '\0',  /* sRGB */
+           };
+
+       /* Ignore all chunks except for IHDR, PLTE, tRNS, IDAT, and IEND */
+       png_set_keep_unknown_chunks(png_ptr, -1 /* PNG_HANDLE_CHUNK_NEVER */,
+          NULL, -1);
+
+       /* But do not ignore chunks in the "chunks_to_process" list */
+       png_set_keep_unknown_chunks(png_ptr,
+          0 /* PNG_HANDLE_CHUNK_AS_DEFAULT */, chunks_to_process,
+          sizeof(chunks_to_process)/5);
+    }
+#endif /* PNG_HANDLE_AS_UNKNOWN_SUPPORTED */
+
+
+    /* instead of doing png_init_io() here, now we set up our callback
+     * functions for progressive decoding */
+
+    png_set_progressive_read_fn(png_ptr, mainprog_ptr,
+      readpng2_info_callback, readpng2_row_callback, readpng2_end_callback);
+
+
+    /* make sure we save our pointers for use in readpng2_decode_data() */
+
+    mainprog_ptr->png_ptr = png_ptr;
+    mainprog_ptr->info_ptr = info_ptr;
+
+
+    /* and that's all there is to initialization */
+
+    return 0;
+}
+
+
+
+
+/* returns 0 for success, 2 for libpng (longjmp) problem */
+
+int readpng2_decode_data(mainprog_info *mainprog_ptr, uch *rawbuf, ulg length)
+{
+    png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
+    png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;
+
+
+    /* setjmp() must be called in every function that calls a PNG-reading
+     * libpng function */
+
+    if (setjmp(mainprog_ptr->jmpbuf)) {
+        png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+        mainprog_ptr->png_ptr = NULL;
+        mainprog_ptr->info_ptr = NULL;
+        return 2;
+    }
+
+
+    /* hand off the next chunk of input data to libpng for decoding */
+
+    png_process_data(png_ptr, info_ptr, rawbuf, length);
+
+    return 0;
+}
+
+
+
+
+static void readpng2_info_callback(png_structp png_ptr, png_infop info_ptr)
+{
+    mainprog_info  *mainprog_ptr;
+    int  color_type, bit_depth;
+    png_uint_32 width, height;
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+    double  gamma;
+#else
+    png_fixed_point gamma;
+#endif
+
+
+    /* setjmp() doesn't make sense here, because we'd either have to exit(),
+     * longjmp() ourselves, or return control to libpng, which doesn't want
+     * to see us again.  By not doing anything here, libpng will instead jump
+     * to readpng2_decode_data(), which can return an error value to the main
+     * program. */
+
+
+    /* retrieve the pointer to our special-purpose struct, using the png_ptr
+     * that libpng passed back to us (i.e., not a global this time--there's
+     * no real difference for a single image, but for a multithreaded browser
+     * decoding several PNG images at the same time, one needs to avoid mixing
+     * up different images' structs) */
+
+    mainprog_ptr = png_get_progressive_ptr(png_ptr);
+
+    if (mainprog_ptr == NULL) {         /* we be hosed */
+        fprintf(stderr,
+          "readpng2 error:  main struct not recoverable in info_callback.\n");
+        fflush(stderr);
+        return;
+        /*
+         * Alternatively, we could call our error-handler just like libpng
+         * does, which would effectively terminate the program.  Since this
+         * can only happen if png_ptr gets redirected somewhere odd or the
+         * main PNG struct gets wiped, we're probably toast anyway.  (If
+         * png_ptr itself is NULL, we would not have been called.)
+         */
+    }
+
+
+    /* this is just like in the non-progressive case */
+
+    png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
+       NULL, NULL, NULL);
+    mainprog_ptr->width = (ulg)width;
+    mainprog_ptr->height = (ulg)height;
+
+
+    /* since we know we've read all of the PNG file's "header" (i.e., up
+     * to IDAT), we can check for a background color here */
+
+    if (mainprog_ptr->need_bgcolor)
+    {
+        png_color_16p pBackground;
+
+        /* it is not obvious from the libpng documentation, but this function
+         * takes a pointer to a pointer, and it always returns valid red,
+         * green and blue values, regardless of color_type: */
+        if (png_get_bKGD(png_ptr, info_ptr, &pBackground))
+        {
+
+           /* however, it always returns the raw bKGD data, regardless of any
+            * bit-depth transformations, so check depth and adjust if necessary
+            */
+           if (bit_depth == 16) {
+               mainprog_ptr->bg_red   = pBackground->red   >> 8;
+               mainprog_ptr->bg_green = pBackground->green >> 8;
+               mainprog_ptr->bg_blue  = pBackground->blue  >> 8;
+           } else if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) {
+               if (bit_depth == 1)
+                   mainprog_ptr->bg_red = mainprog_ptr->bg_green =
+                     mainprog_ptr->bg_blue = pBackground->gray? 255 : 0;
+               else if (bit_depth == 2)
+                   mainprog_ptr->bg_red = mainprog_ptr->bg_green =
+                     mainprog_ptr->bg_blue = (255/3) * pBackground->gray;
+               else /* bit_depth == 4 */
+                   mainprog_ptr->bg_red = mainprog_ptr->bg_green =
+                     mainprog_ptr->bg_blue = (255/15) * pBackground->gray;
+           } else {
+               mainprog_ptr->bg_red   = (uch)pBackground->red;
+               mainprog_ptr->bg_green = (uch)pBackground->green;
+               mainprog_ptr->bg_blue  = (uch)pBackground->blue;
+           }
+        }
+    }
+
+
+    /* as before, let libpng expand palette images to RGB, low-bit-depth
+     * grayscale images to 8 bits, transparency chunks to full alpha channel;
+     * strip 16-bit-per-sample images to 8 bits per sample; and convert
+     * grayscale to RGB[A] */
+
+    if (color_type == PNG_COLOR_TYPE_PALETTE)
+        png_set_expand(png_ptr);
+    if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
+        png_set_expand(png_ptr);
+    if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
+        png_set_expand(png_ptr);
+#ifdef PNG_READ_16_TO_8_SUPPORTED
+    if (bit_depth == 16)
+#  ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
+        png_set_scale_16(png_ptr);
+#  else
+        png_set_strip_16(png_ptr);
+#  endif
+#endif
+    if (color_type == PNG_COLOR_TYPE_GRAY ||
+        color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+        png_set_gray_to_rgb(png_ptr);
+
+
+    /* Unlike the basic viewer, which was designed to operate on local files,
+     * this program is intended to simulate a web browser--even though we
+     * actually read from a local file, too.  But because we are pretending
+     * that most of the images originate on the Internet, we follow the recom-
+     * mendation of the sRGB proposal and treat unlabelled images (no gAMA
+     * chunk) as existing in the sRGB color space.  That is, we assume that
+     * such images have a file gamma of 0.45455, which corresponds to a PC-like
+     * display system.  This change in assumptions will have no effect on a
+     * PC-like system, but on a Mac, SGI, NeXT or other system with a non-
+     * identity lookup table, it will darken unlabelled images, which effec-
+     * tively favors images from PC-like systems over those originating on
+     * the local platform.  Note that mainprog_ptr->display_exponent is the
+     * "gamma" value for the entire display system, i.e., the product of
+     * LUT_exponent and CRT_exponent. */
+
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+    if (png_get_gAMA(png_ptr, info_ptr, &gamma))
+        png_set_gamma(png_ptr, mainprog_ptr->display_exponent, gamma);
+    else
+        png_set_gamma(png_ptr, mainprog_ptr->display_exponent, 0.45455);
+#else
+    if (png_get_gAMA_fixed(png_ptr, info_ptr, &gamma))
+        png_set_gamma_fixed(png_ptr,
+            (png_fixed_point)(100000*mainprog_ptr->display_exponent+.5), gamma);
+    else
+        png_set_gamma_fixed(png_ptr,
+            (png_fixed_point)(100000*mainprog_ptr->display_exponent+.5), 45455);
+#endif
+
+    /* we'll let libpng expand interlaced images, too */
+
+    mainprog_ptr->passes = png_set_interlace_handling(png_ptr);
+
+
+    /* all transformations have been registered; now update info_ptr data and
+     * then get rowbytes and channels */
+
+    png_read_update_info(png_ptr, info_ptr);
+
+    mainprog_ptr->rowbytes = (int)png_get_rowbytes(png_ptr, info_ptr);
+    mainprog_ptr->channels = png_get_channels(png_ptr, info_ptr);
+
+
+    /* Call the main program to allocate memory for the image buffer and
+     * initialize windows and whatnot.  (The old-style function-pointer
+     * invocation is used for compatibility with a few supposedly ANSI
+     * compilers that nevertheless barf on "fn_ptr()"-style syntax.) */
+
+    (*mainprog_ptr->mainprog_init)();
+
+
+    /* and that takes care of initialization */
+
+    return;
+}
+
+
+
+
+
+static void readpng2_row_callback(png_structp png_ptr, png_bytep new_row,
+                                  png_uint_32 row_num, int pass)
+{
+    mainprog_info  *mainprog_ptr;
+
+
+    /* first check whether the row differs from the previous pass; if not,
+     * nothing to combine or display */
+
+    if (!new_row)
+        return;
+
+
+    /* retrieve the pointer to our special-purpose struct so we can access
+     * the old rows and image-display callback function */
+
+    mainprog_ptr = png_get_progressive_ptr(png_ptr);
+
+
+    /* save the pass number for optional use by the front end */
+
+    mainprog_ptr->pass = pass;
+
+
+    /* have libpng either combine the new row data with the existing row data
+     * from previous passes (if interlaced) or else just copy the new row
+     * into the main program's image buffer */
+
+    png_progressive_combine_row(png_ptr, mainprog_ptr->row_pointers[row_num],
+      new_row);
+
+
+    /* finally, call the display routine in the main program with the number
+     * of the row we just updated */
+
+    (*mainprog_ptr->mainprog_display_row)(row_num);
+
+
+    /* and we're ready for more */
+
+    return;
+}
+
+
+
+
+
+static void readpng2_end_callback(png_structp png_ptr, png_infop info_ptr)
+{
+    mainprog_info  *mainprog_ptr;
+
+
+    /* retrieve the pointer to our special-purpose struct */
+
+    mainprog_ptr = png_get_progressive_ptr(png_ptr);
+
+
+    /* let the main program know that it should flush any buffered image
+     * data to the display now and set a "done" flag or whatever, but note
+     * that it SHOULD NOT DESTROY THE PNG STRUCTS YET--in other words, do
+     * NOT call readpng2_cleanup() either here or in the finish_display()
+     * routine; wait until control returns to the main program via
+     * readpng2_decode_data() */
+
+    (*mainprog_ptr->mainprog_finish_display)();
+
+
+    /* all done */
+
+    (void)info_ptr; /* Unused */
+
+    return;
+}
+
+
+
+
+
+void readpng2_cleanup(mainprog_info *mainprog_ptr)
+{
+    png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
+    png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;
+
+    if (png_ptr && info_ptr)
+        png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+
+    mainprog_ptr->png_ptr = NULL;
+    mainprog_ptr->info_ptr = NULL;
+}
+
+
+static void readpng2_warning_handler(png_structp png_ptr, png_const_charp msg)
+{
+    fprintf(stderr, "readpng2 libpng warning: %s\n", msg);
+    fflush(stderr);
+    (void)png_ptr; /* Unused */
+}
+
+
+static void readpng2_error_handler(png_structp png_ptr, png_const_charp msg)
+{
+    mainprog_info  *mainprog_ptr;
+
+    /* This function, aside from the extra step of retrieving the "error
+     * pointer" (below) and the fact that it exists within the application
+     * rather than within libpng, is essentially identical to libpng's
+     * default error handler.  The second point is critical:  since both
+     * setjmp() and longjmp() are called from the same code, they are
+     * guaranteed to have compatible notions of how big a jmp_buf is,
+     * regardless of whether _BSD_SOURCE or anything else has (or has not)
+     * been defined. */
+
+    fprintf(stderr, "readpng2 libpng error: %s\n", msg);
+    fflush(stderr);
+
+    mainprog_ptr = png_get_error_ptr(png_ptr);
+    if (mainprog_ptr == NULL) {         /* we are completely hosed now */
+        fprintf(stderr,
+          "readpng2 severe error:  jmpbuf not recoverable; terminating.\n");
+        fflush(stderr);
+        exit(99);
+    }
+
+    /* Now we have our data structure we can use the information in it
+     * to return control to our own higher level code (all the points
+     * where 'setjmp' is called in this file.)  This will work with other
+     * error handling mechanisms as well - libpng always calls png_error
+     * when it can proceed no further, thus, so long as the error handler
+     * is intercepted, application code can do its own error recovery.
+     */
+    longjmp(mainprog_ptr->jmpbuf, 1);
+}
diff --git a/Engine/lib/lpng/contrib/gregbook/readpng2.h b/Engine/lib/lpng/contrib/gregbook/readpng2.h
new file mode 100644
index 000000000..6b3660d7c
--- /dev/null
+++ b/Engine/lib/lpng/contrib/gregbook/readpng2.h
@@ -0,0 +1,116 @@
+/*---------------------------------------------------------------------------
+
+   rpng2 - progressive-model PNG display program                 readpng2.h
+
+  ---------------------------------------------------------------------------
+
+      Copyright (c) 1998-2008 Greg Roelofs.  All rights reserved.
+
+      This software is provided "as is," without warranty of any kind,
+      express or implied.  In no event shall the author or contributors
+      be held liable for any damages arising in any way from the use of
+      this software.
+
+      The contents of this file are DUAL-LICENSED.  You may modify and/or
+      redistribute this software according to the terms of one of the
+      following two licenses (at your option):
+
+
+      LICENSE 1 ("BSD-like with advertising clause"):
+
+      Permission is granted to anyone to use this software for any purpose,
+      including commercial applications, and to alter it and redistribute
+      it freely, subject to the following restrictions:
+
+      1. Redistributions of source code must retain the above copyright
+         notice, disclaimer, and this list of conditions.
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, disclaimer, and this list of conditions in the documenta-
+         tion and/or other materials provided with the distribution.
+      3. All advertising materials mentioning features or use of this
+         software must display the following acknowledgment:
+
+            This product includes software developed by Greg Roelofs
+            and contributors for the book, "PNG: The Definitive Guide,"
+            published by O'Reilly and Associates.
+
+
+      LICENSE 2 (GNU GPL v2 or later):
+
+      This program is free software; you can redistribute it and/or modify
+      it under the terms of the GNU General Public License as published by
+      the Free Software Foundation; either version 2 of the License, or
+      (at your option) any later version.
+
+      This program is distributed in the hope that it will be useful,
+      but WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+      GNU General Public License for more details.
+
+      You should have received a copy of the GNU General Public License
+      along with this program; if not, write to the Free Software Foundation,
+      Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  ---------------------------------------------------------------------------*/
+
+#ifndef TRUE
+#  define TRUE 1
+#  define FALSE 0
+#endif
+
+#ifndef MAX
+#  define MAX(a,b)  ((a) > (b)? (a) : (b))
+#  define MIN(a,b)  ((a) < (b)? (a) : (b))
+#endif
+
+#ifdef DEBUG
+#  define Trace(x)  {fprintf x ; fflush(stderr); fflush(stdout);}
+#else
+#  define Trace(x)  ;
+#endif
+
+enum rpng2_states {
+    kPreInit = 0,
+    kWindowInit,
+    kDone
+};
+
+typedef unsigned char   uch;
+typedef unsigned short  ush;
+typedef unsigned long   ulg;
+
+typedef struct _mainprog_info {
+    double display_exponent;
+    ulg width;
+    ulg height;
+    void *png_ptr;
+    void *info_ptr;
+    void (*mainprog_init)(void);
+    void (*mainprog_display_row)(ulg row_num);
+    void (*mainprog_finish_display)(void);
+    uch *image_data;
+    uch **row_pointers;
+    jmp_buf jmpbuf;
+    int passes;              /* not used */
+    int pass;
+    int rowbytes;
+    int channels;
+    int need_bgcolor;
+    int state;
+    uch bg_red;
+    uch bg_green;
+    uch bg_blue;
+} mainprog_info;
+
+
+/* prototypes for public functions in readpng2.c */
+
+void readpng2_version_info(void);
+
+int readpng2_check_sig(uch *sig, int num);
+
+int readpng2_init(mainprog_info *mainprog_ptr);
+
+int readpng2_decode_data(mainprog_info *mainprog_ptr, uch *rawbuf, ulg length);
+
+void readpng2_cleanup(mainprog_info *mainprog_ptr);
diff --git a/Engine/lib/lpng/contrib/gregbook/readppm.c b/Engine/lib/lpng/contrib/gregbook/readppm.c
new file mode 100644
index 000000000..52e702777
--- /dev/null
+++ b/Engine/lib/lpng/contrib/gregbook/readppm.c
@@ -0,0 +1,188 @@
+/*---------------------------------------------------------------------------
+
+   rpng - simple PNG display program                              readppm.c
+
+  ---------------------------------------------------------------------------
+
+   This is a special-purpose replacement for readpng.c that allows binary
+   PPM files to be used in place of PNG images.
+
+  ---------------------------------------------------------------------------
+
+      Copyright (c) 1998-2007,2017 Greg Roelofs.  All rights reserved.
+
+      This software is provided "as is," without warranty of any kind,
+      express or implied.  In no event shall the author or contributors
+      be held liable for any damages arising in any way from the use of
+      this software.
+
+      The contents of this file are DUAL-LICENSED.  You may modify and/or
+      redistribute this software according to the terms of one of the
+      following two licenses (at your option):
+
+
+      LICENSE 1 ("BSD-like with advertising clause"):
+
+      Permission is granted to anyone to use this software for any purpose,
+      including commercial applications, and to alter it and redistribute
+      it freely, subject to the following restrictions:
+
+      1. Redistributions of source code must retain the above copyright
+         notice, disclaimer, and this list of conditions.
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, disclaimer, and this list of conditions in the documenta-
+         tion and/or other materials provided with the distribution.
+      3. All advertising materials mentioning features or use of this
+         software must display the following acknowledgment:
+
+            This product includes software developed by Greg Roelofs
+            and contributors for the book, "PNG: The Definitive Guide,"
+            published by O'Reilly and Associates.
+
+
+      LICENSE 2 (GNU GPL v2 or later):
+
+      This program is free software; you can redistribute it and/or modify
+      it under the terms of the GNU General Public License as published by
+      the Free Software Foundation; either version 2 of the License, or
+      (at your option) any later version.
+
+      This program is distributed in the hope that it will be useful,
+      but WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+      GNU General Public License for more details.
+
+      You should have received a copy of the GNU General Public License
+      along with this program; if not, write to the Free Software Foundation,
+      Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  ---------------------------------------------------------------------------*/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "readpng.h"    /* typedefs, common macros, public prototypes */
+
+
+ulg  width, height;
+int  bit_depth, color_type, channels;
+uch  *image_data = NULL;
+FILE *saved_infile;
+
+
+void readpng_version_info()
+{
+    fprintf(stderr, "   Compiled without libpng, zlib or PBMPLUS/NetPBM.\n");
+}
+
+
+/* return value = 0 for success, 1 for bad sig, 2 for bad IHDR, 4 for no mem */
+
+int readpng_init(FILE *infile, ulg *pWidth, ulg *pHeight)
+{
+    static uch ppmline[256];
+    int maxval;
+
+
+    saved_infile = infile;
+
+    fgets(ppmline, 256, infile);
+    if (ppmline[0] != 'P' || ppmline[1] != '6') {
+        fprintf(stderr, "ERROR:  not a PPM file\n");
+        return 1;
+    }
+    /* possible color types:  P5 = grayscale (0), P6 = RGB (2), P8 = RGBA (6) */
+    if (ppmline[1] == '6') {
+        color_type = 2;
+        channels = 3;
+    } else if (ppmline[1] == '8') {
+        color_type = 6;
+        channels = 4;
+    } else /* if (ppmline[1] == '5') */ {
+        color_type = 0;
+        channels = 1;
+    }
+
+    do {
+        fgets(ppmline, 256, infile);
+    } while (ppmline[0] == '#');
+    sscanf(ppmline, "%lu %lu", &width, &height);
+
+    do {
+        fgets(ppmline, 256, infile);
+    } while (ppmline[0] == '#');
+    sscanf(ppmline, "%d", &maxval);
+    if (maxval != 255) {
+        fprintf(stderr, "ERROR:  maxval = %d\n", maxval);
+        return 2;
+    }
+    bit_depth = 8;
+
+    *pWidth = width;
+    *pHeight = height;
+
+    return 0;
+}
+
+
+
+
+/* returns 0 if succeeds, 1 if fails due to no bKGD chunk, 2 if libpng error;
+ * scales values to 8-bit if necessary */
+
+int readpng_get_bgcolor(uch *red, uch *green, uch *blue)
+{
+    return 1;
+}
+
+
+
+
+/* display_exponent == LUT_exponent * CRT_exponent */
+
+uch *readpng_get_image(double display_exponent, int *pChannels, ulg *pRowbytes)
+{
+    ulg  rowbytes;
+
+
+    /* expand palette images to RGB, low-bit-depth grayscale images to 8 bits,
+     * transparency chunks to full alpha channel; strip 16-bit-per-sample
+     * images to 8 bits per sample; and convert grayscale to RGB[A] */
+
+    /* GRR WARNING:  grayscale needs to be expanded and channels reset! */
+
+    *pRowbytes = rowbytes = channels*width;
+    *pChannels = channels;
+
+    Trace((stderr, "readpng_get_image:  rowbytes = %ld, height = %ld\n", rowbytes, height));
+
+    /* Guard against integer overflow */
+    if (height > ((size_t)(-1))/rowbytes) {
+        fprintf(stderr, PROGNAME ":  image_data buffer would be too large\n",
+        return NULL;
+    }
+
+    if ((image_data = (uch *)malloc(rowbytes*height)) == NULL) {
+        return NULL;
+    }
+
+    /* now we can go ahead and just read the whole image */
+
+    if (fread(image_data, 1L, rowbytes*height, saved_infile) <
+       rowbytes*height) {
+        free (image_data);
+        image_data = NULL;
+        return NULL;
+    }
+
+    return image_data;
+}
+
+
+void readpng_cleanup(int free_image_data)
+{
+    if (free_image_data && image_data) {
+        free(image_data);
+        image_data = NULL;
+    }
+}
diff --git a/Engine/lib/lpng/contrib/gregbook/rpng-win.c b/Engine/lib/lpng/contrib/gregbook/rpng-win.c
new file mode 100644
index 000000000..1a6f87615
--- /dev/null
+++ b/Engine/lib/lpng/contrib/gregbook/rpng-win.c
@@ -0,0 +1,735 @@
+/*---------------------------------------------------------------------------
+
+   rpng - simple PNG display program                             rpng-win.c
+
+   This program decodes and displays PNG images, with gamma correction and
+   optionally with a user-specified background color (in case the image has
+   transparency).  It is very nearly the most basic PNG viewer possible.
+   This version is for 32-bit Windows; it may compile under 16-bit Windows
+   with a little tweaking (or maybe not).
+
+   to do:
+    - handle quoted command-line args (especially filenames with spaces)
+    - have minimum window width:  oh well
+    - use %.1023s to simplify truncation of title-bar string?
+
+  ---------------------------------------------------------------------------
+
+   Changelog:
+    - 1.00:  initial public release
+    - 1.01:  modified to allow abbreviated options; fixed long/ulong mis-
+              match; switched to png_jmpbuf() macro
+    - 1.02:  added extra set of parentheses to png_jmpbuf() macro; fixed
+              command-line parsing bug
+    - 1.10:  enabled "message window"/console (thanks to David Geldreich)
+    - 2.00:  dual-licensed (added GNU GPL)
+    - 2.01:  fixed improper display of usage screen on PNG error(s)
+    - 2.02:  check for integer overflow (Glenn R-P)
+
+  ---------------------------------------------------------------------------
+
+      Copyright (c) 1998-2008, 2017 Greg Roelofs.  All rights reserved.
+
+      This software is provided "as is," without warranty of any kind,
+      express or implied.  In no event shall the author or contributors
+      be held liable for any damages arising in any way from the use of
+      this software.
+
+      The contents of this file are DUAL-LICENSED.  You may modify and/or
+      redistribute this software according to the terms of one of the
+      following two licenses (at your option):
+
+
+      LICENSE 1 ("BSD-like with advertising clause"):
+
+      Permission is granted to anyone to use this software for any purpose,
+      including commercial applications, and to alter it and redistribute
+      it freely, subject to the following restrictions:
+
+      1. Redistributions of source code must retain the above copyright
+         notice, disclaimer, and this list of conditions.
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, disclaimer, and this list of conditions in the documenta-
+         tion and/or other materials provided with the distribution.
+      3. All advertising materials mentioning features or use of this
+         software must display the following acknowledgment:
+
+            This product includes software developed by Greg Roelofs
+            and contributors for the book, "PNG: The Definitive Guide,"
+            published by O'Reilly and Associates.
+
+
+      LICENSE 2 (GNU GPL v2 or later):
+
+      This program is free software; you can redistribute it and/or modify
+      it under the terms of the GNU General Public License as published by
+      the Free Software Foundation; either version 2 of the License, or
+      (at your option) any later version.
+
+      This program is distributed in the hope that it will be useful,
+      but WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+      GNU General Public License for more details.
+
+      You should have received a copy of the GNU General Public License
+      along with this program; if not, write to the Free Software Foundation,
+      Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  ---------------------------------------------------------------------------*/
+
+#define PROGNAME  "rpng-win"
+#define LONGNAME  "Simple PNG Viewer for Windows"
+#define VERSION   "2.01 of 16 March 2008"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <windows.h>
+#ifdef __CYGWIN__
+/* getch replacement. Turns out, we don't really need this,
+ * but leave it here if we ever enable any of the uses of
+ * _getch in the main code
+ */
+#include <unistd.h>
+#include <termio.h>
+#include <sys/ioctl.h>
+int repl_getch( void )
+{
+  char ch;
+  int fd = fileno(stdin);
+  struct termio old_tty, new_tty;
+
+  ioctl(fd, TCGETA, &old_tty);
+  new_tty = old_tty;
+  new_tty.c_lflag &= ~(ICANON | ECHO | ISIG);
+  ioctl(fd, TCSETA, &new_tty);
+  fread(&ch, 1, sizeof(ch), stdin);
+  ioctl(fd, TCSETA, &old_tty);
+
+  return ch;
+}
+#define _getch repl_getch
+#else
+#include <conio.h>      /* only for _getch() */
+#endif
+
+/* #define DEBUG  :  this enables the Trace() macros */
+
+#include "readpng.h"    /* typedefs, common macros, readpng prototypes */
+
+
+/* could just include png.h, but this macro is the only thing we need
+ * (name and typedefs changed to local versions); note that side effects
+ * only happen with alpha (which could easily be avoided with
+ * "ush acopy = (alpha);") */
+
+#define alpha_composite(composite, fg, alpha, bg) {               \
+    ush temp = ((ush)(fg)*(ush)(alpha) +                          \
+                (ush)(bg)*(ush)(255 - (ush)(alpha)) + (ush)128);  \
+    (composite) = (uch)((temp + (temp >> 8)) >> 8);               \
+}
+
+
+/* local prototypes */
+static int        rpng_win_create_window(HINSTANCE hInst, int showmode);
+static int        rpng_win_display_image(void);
+static void       rpng_win_cleanup(void);
+LRESULT CALLBACK  rpng_win_wndproc(HWND, UINT, WPARAM, LPARAM);
+
+
+static char titlebar[1024];
+static char *progname = PROGNAME;
+static char *appname = LONGNAME;
+static char *filename;
+static FILE *infile;
+
+static char *bgstr;
+static uch bg_red=0, bg_green=0, bg_blue=0;
+
+static double display_exponent;
+
+static ulg image_width, image_height, image_rowbytes;
+static int image_channels;
+static uch *image_data;
+
+/* Windows-specific variables */
+static ulg wimage_rowbytes;
+static uch *dib;
+static uch *wimage_data;
+static BITMAPINFOHEADER *bmih;
+
+static HWND global_hwnd;
+
+
+
+
+int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, PSTR cmd, int showmode)
+{
+    char *args[1024];                 /* arbitrary limit, but should suffice */
+    char *p, *q, **argv = args;
+    int argc = 0;
+    int rc, alen, flen;
+    int error = 0;
+    int have_bg = FALSE;
+    double LUT_exponent;              /* just the lookup table */
+    double CRT_exponent = 2.2;        /* just the monitor */
+    double default_display_exponent;  /* whole display system */
+    MSG msg;
+
+
+    filename = (char *)NULL;
+
+#ifndef __CYGWIN__
+    /* First reenable console output, which normally goes to the bit bucket
+     * for windowed apps.  Closing the console window will terminate the
+     * app.  Thanks to David.Geldreich at realviz.com for supplying the magical
+     * incantation. */
+
+    AllocConsole();
+    freopen("CONOUT$", "a", stderr);
+    freopen("CONOUT$", "a", stdout);
+#endif
+
+
+    /* Next set the default value for our display-system exponent, i.e.,
+     * the product of the CRT exponent and the exponent corresponding to
+     * the frame-buffer's lookup table (LUT), if any.  This is not an
+     * exhaustive list of LUT values (e.g., OpenStep has a lot of weird
+     * ones), but it should cover 99% of the current possibilities.  And
+     * yes, these ifdefs are completely wasted in a Windows program... */
+
+#if defined(NeXT)
+    LUT_exponent = 1.0 / 2.2;
+    /*
+    if (some_next_function_that_returns_gamma(&next_gamma))
+        LUT_exponent = 1.0 / next_gamma;
+     */
+#elif defined(sgi)
+    LUT_exponent = 1.0 / 1.7;
+    /* there doesn't seem to be any documented function to get the
+     * "gamma" value, so we do it the hard way */
+    infile = fopen("/etc/config/system.glGammaVal", "r");
+    if (infile) {
+        double sgi_gamma;
+
+        fgets(tmpline, 80, infile);
+        fclose(infile);
+        sgi_gamma = atof(tmpline);
+        if (sgi_gamma > 0.0)
+            LUT_exponent = 1.0 / sgi_gamma;
+    }
+#elif defined(Macintosh)
+    LUT_exponent = 1.8 / 2.61;
+    /*
+    if (some_mac_function_that_returns_gamma(&mac_gamma))
+        LUT_exponent = mac_gamma / 2.61;
+     */
+#else
+    LUT_exponent = 1.0;   /* assume no LUT:  most PCs */
+#endif
+
+    /* the defaults above give 1.0, 1.3, 1.5 and 2.2, respectively: */
+    default_display_exponent = LUT_exponent * CRT_exponent;
+
+
+    /* If the user has set the SCREEN_GAMMA environment variable as suggested
+     * (somewhat imprecisely) in the libpng documentation, use that; otherwise
+     * use the default value we just calculated.  Either way, the user may
+     * override this via a command-line option. */
+
+    if ((p = getenv("SCREEN_GAMMA")) != NULL)
+        display_exponent = atof(p);
+    else
+        display_exponent = default_display_exponent;
+
+
+    /* Windows really hates command lines, so we have to set up our own argv.
+     * Note that we do NOT bother with quoted arguments here, so don't use
+     * filenames with spaces in 'em! */
+
+    argv[argc++] = PROGNAME;
+    p = cmd;
+    for (;;) {
+        if (*p == ' ')
+            while (*++p == ' ')
+                ;
+        /* now p points at the first non-space after some spaces */
+        if (*p == '\0')
+            break;    /* nothing after the spaces:  done */
+        argv[argc++] = q = p;
+        while (*q && *q != ' ')
+            ++q;
+        /* now q points at a space or the end of the string */
+        if (*q == '\0')
+            break;    /* last argv already terminated; quit */
+        *q = '\0';    /* change space to terminator */
+        p = q + 1;
+    }
+    argv[argc] = NULL;   /* terminate the argv array itself */
+
+
+    /* Now parse the command line for options and the PNG filename. */
+
+    while (*++argv && !error) {
+        if (!strncmp(*argv, "-gamma", 2)) {
+            if (!*++argv)
+                ++error;
+            else {
+                display_exponent = atof(*argv);
+                if (display_exponent <= 0.0)
+                    ++error;
+            }
+        } else if (!strncmp(*argv, "-bgcolor", 2)) {
+            if (!*++argv)
+                ++error;
+            else {
+                bgstr = *argv;
+                if (strlen(bgstr) != 7 || bgstr[0] != '#')
+                    ++error;
+                else
+                    have_bg = TRUE;
+            }
+        } else {
+            if (**argv != '-') {
+                filename = *argv;
+                if (argv[1])   /* shouldn't be any more args after filename */
+                    ++error;
+            } else
+                ++error;   /* not expecting any other options */
+        }
+    }
+
+    if (!filename)
+        ++error;
+
+
+    /* print usage screen if any errors up to this point */
+
+    if (error) {
+#ifndef __CYGWIN__
+        int ch;
+#endif
+
+        fprintf(stderr, "\n%s %s:  %s\n\n", PROGNAME, VERSION, appname);
+        readpng_version_info();
+        fprintf(stderr, "\n"
+          "Usage:  %s [-gamma exp] [-bgcolor bg] file.png\n"
+          "    exp \ttransfer-function exponent (``gamma'') of the display\n"
+          "\t\t  system in floating-point format (e.g., ``%.1f''); equal\n"
+          "\t\t  to the product of the lookup-table exponent (varies)\n"
+          "\t\t  and the CRT exponent (usually 2.2); must be positive\n"
+          "    bg  \tdesired background color in 7-character hex RGB format\n"
+          "\t\t  (e.g., ``#ff7700'' for orange:  same as HTML colors);\n"
+          "\t\t  used with transparent images\n"
+          "\nPress Q, Esc or mouse button 1 after image is displayed to quit.\n"
+#ifndef __CYGWIN__
+          "Press Q or Esc to quit this usage screen.\n"
+#endif
+          "\n", PROGNAME, default_display_exponent);
+#ifndef __CYGWIN__
+        do
+            ch = _getch();
+        while (ch != 'q' && ch != 'Q' && ch != 0x1B);
+#endif
+        exit(1);
+    }
+
+
+    if (!(infile = fopen(filename, "rb"))) {
+        fprintf(stderr, PROGNAME ":  can't open PNG file [%s]\n", filename);
+        ++error;
+    } else {
+        if ((rc = readpng_init(infile, &image_width, &image_height)) != 0) {
+            switch (rc) {
+                case 1:
+                    fprintf(stderr, PROGNAME
+                      ":  [%s] is not a PNG file: incorrect signature\n",
+                      filename);
+                    break;
+                case 2:
+                    fprintf(stderr, PROGNAME
+                      ":  [%s] has bad IHDR (libpng longjmp)\n", filename);
+                    break;
+                case 4:
+                    fprintf(stderr, PROGNAME ":  insufficient memory\n");
+                    break;
+                default:
+                    fprintf(stderr, PROGNAME
+                      ":  unknown readpng_init() error\n");
+                    break;
+            }
+            ++error;
+        }
+        if (error)
+            fclose(infile);
+    }
+
+
+    if (error) {
+#ifndef __CYGWIN__
+        int ch;
+#endif
+
+        fprintf(stderr, PROGNAME ":  aborting.\n");
+#ifndef __CYGWIN__
+        do
+            ch = _getch();
+        while (ch != 'q' && ch != 'Q' && ch != 0x1B);
+#endif
+        exit(2);
+    } else {
+        fprintf(stderr, "\n%s %s:  %s\n", PROGNAME, VERSION, appname);
+#ifndef __CYGWIN__
+        fprintf(stderr,
+          "\n   [console window:  closing this window will terminate %s]\n\n",
+          PROGNAME);
+#endif
+    }
+
+
+    /* set the title-bar string, but make sure buffer doesn't overflow */
+
+    alen = strlen(appname);
+    flen = strlen(filename);
+    if (alen + flen + 3 > 1023)
+        sprintf(titlebar, "%s:  ...%s", appname, filename+(alen+flen+6-1023));
+    else
+        sprintf(titlebar, "%s:  %s", appname, filename);
+
+
+    /* if the user didn't specify a background color on the command line,
+     * check for one in the PNG file--if not, the initialized values of 0
+     * (black) will be used */
+
+    if (have_bg) {
+        unsigned r, g, b;   /* this approach quiets compiler warnings */
+
+        sscanf(bgstr+1, "%2x%2x%2x", &r, &g, &b);
+        bg_red   = (uch)r;
+        bg_green = (uch)g;
+        bg_blue  = (uch)b;
+    } else if (readpng_get_bgcolor(&bg_red, &bg_green, &bg_blue) > 1) {
+        readpng_cleanup(TRUE);
+        fprintf(stderr, PROGNAME
+          ":  libpng error while checking for background color\n");
+        exit(2);
+    }
+
+
+    /* do the basic Windows initialization stuff, make the window and fill it
+     * with the background color */
+
+    if (rpng_win_create_window(hInst, showmode))
+        exit(2);
+
+
+    /* decode the image, all at once */
+
+    Trace((stderr, "calling readpng_get_image()\n"))
+    image_data = readpng_get_image(display_exponent, &image_channels,
+      &image_rowbytes);
+    Trace((stderr, "done with readpng_get_image()\n"))
+
+
+    /* done with PNG file, so clean up to minimize memory usage (but do NOT
+     * nuke image_data!) */
+
+    readpng_cleanup(FALSE);
+    fclose(infile);
+
+    if (!image_data) {
+        fprintf(stderr, PROGNAME ":  unable to decode PNG image\n");
+        exit(3);
+    }
+
+
+    /* display image (composite with background if requested) */
+
+    Trace((stderr, "calling rpng_win_display_image()\n"))
+    if (rpng_win_display_image()) {
+        free(image_data);
+        exit(4);
+    }
+    Trace((stderr, "done with rpng_win_display_image()\n"))
+
+
+    /* wait for the user to tell us when to quit */
+
+    printf(
+#ifndef __CYGWIN__
+      "Done.  Press Q, Esc or mouse button 1 (within image window) to quit.\n"
+#else
+      "Done.  Press mouse button 1 (within image window) to quit.\n"
+#endif
+    );
+    fflush(stdout);
+
+    while (GetMessage(&msg, NULL, 0, 0)) {
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+    }
+
+
+    /* OK, we're done:  clean up all image and Windows resources and go away */
+
+    rpng_win_cleanup();
+
+    return msg.wParam;
+}
+
+
+
+
+
+static int rpng_win_create_window(HINSTANCE hInst, int showmode)
+{
+    uch *dest;
+    int extra_width, extra_height;
+    ulg i, j;
+    WNDCLASSEX wndclass;
+
+
+/*---------------------------------------------------------------------------
+    Allocate memory for the display-specific version of the image (round up
+    to multiple of 4 for Windows DIB).
+  ---------------------------------------------------------------------------*/
+
+    wimage_rowbytes = ((3*image_width + 3L) >> 2) << 2;
+
+    /* Guard against integer overflow */
+    if (image_height > ((size_t)(-1))/wimage_rowbytes) {
+        fprintf(stderr, PROGNAME ":  image_data buffer would be too large\n");
+        return 4;   /* fail */
+    }
+
+    if (!(dib = (uch *)malloc(sizeof(BITMAPINFOHEADER) +
+                              wimage_rowbytes*image_height)))
+    {
+        return 4;   /* fail */
+    }
+
+/*---------------------------------------------------------------------------
+    Initialize the DIB.  Negative height means to use top-down BMP ordering
+    (must be uncompressed, but that's what we want).  Bit count of 1, 4 or 8
+    implies a colormap of RGBX quads, but 24-bit BMPs just use B,G,R values
+    directly => wimage_data begins immediately after BMP header.
+  ---------------------------------------------------------------------------*/
+
+    memset(dib, 0, sizeof(BITMAPINFOHEADER));
+    bmih = (BITMAPINFOHEADER *)dib;
+    bmih->biSize = sizeof(BITMAPINFOHEADER);
+    bmih->biWidth = image_width;
+    bmih->biHeight = -((long)image_height);
+    bmih->biPlanes = 1;
+    bmih->biBitCount = 24;
+    bmih->biCompression = 0;
+    wimage_data = dib + sizeof(BITMAPINFOHEADER);
+
+/*---------------------------------------------------------------------------
+    Fill in background color (black by default); data are in BGR order.
+  ---------------------------------------------------------------------------*/
+
+    for (j = 0;  j < image_height;  ++j) {
+        dest = wimage_data + j*wimage_rowbytes;
+        for (i = image_width;  i > 0;  --i) {
+            *dest++ = bg_blue;
+            *dest++ = bg_green;
+            *dest++ = bg_red;
+        }
+    }
+
+/*---------------------------------------------------------------------------
+    Set the window parameters.
+  ---------------------------------------------------------------------------*/
+
+    memset(&wndclass, 0, sizeof(wndclass));
+
+    wndclass.cbSize = sizeof(wndclass);
+    wndclass.style = CS_HREDRAW | CS_VREDRAW;
+    wndclass.lpfnWndProc = rpng_win_wndproc;
+    wndclass.hInstance = hInst;
+    wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
+    wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
+    wndclass.hbrBackground = (HBRUSH)GetStockObject(DKGRAY_BRUSH);
+    wndclass.lpszMenuName = NULL;
+    wndclass.lpszClassName = progname;
+    wndclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
+
+    RegisterClassEx(&wndclass);
+
+/*---------------------------------------------------------------------------
+    Finally, create the window.
+  ---------------------------------------------------------------------------*/
+
+    extra_width  = 2*(GetSystemMetrics(SM_CXBORDER) +
+                      GetSystemMetrics(SM_CXDLGFRAME));
+    extra_height = 2*(GetSystemMetrics(SM_CYBORDER) +
+                      GetSystemMetrics(SM_CYDLGFRAME)) +
+                      GetSystemMetrics(SM_CYCAPTION);
+
+    global_hwnd = CreateWindow(progname, titlebar, WS_OVERLAPPEDWINDOW,
+      CW_USEDEFAULT, CW_USEDEFAULT, image_width+extra_width,
+      image_height+extra_height, NULL, NULL, hInst, NULL);
+
+    ShowWindow(global_hwnd, showmode);
+    UpdateWindow(global_hwnd);
+
+    return 0;
+
+} /* end function rpng_win_create_window() */
+
+
+
+
+
+static int rpng_win_display_image()
+{
+    uch *src, *dest;
+    uch r, g, b, a;
+    ulg i, row, lastrow;
+    RECT rect;
+
+
+    Trace((stderr, "beginning display loop (image_channels == %d)\n",
+      image_channels))
+    Trace((stderr, "(width = %ld, rowbytes = %ld, wimage_rowbytes = %d)\n",
+      image_width, image_rowbytes, wimage_rowbytes))
+
+
+/*---------------------------------------------------------------------------
+    Blast image data to buffer.  This whole routine takes place before the
+    message loop begins, so there's no real point in any pseudo-progressive
+    display...
+  ---------------------------------------------------------------------------*/
+
+    for (lastrow = row = 0;  row < image_height;  ++row) {
+        src = image_data + row*image_rowbytes;
+        dest = wimage_data + row*wimage_rowbytes;
+        if (image_channels == 3) {
+            for (i = image_width;  i > 0;  --i) {
+                r = *src++;
+                g = *src++;
+                b = *src++;
+                *dest++ = b;
+                *dest++ = g;   /* note reverse order */
+                *dest++ = r;
+            }
+        } else /* if (image_channels == 4) */ {
+            for (i = image_width;  i > 0;  --i) {
+                r = *src++;
+                g = *src++;
+                b = *src++;
+                a = *src++;
+                if (a == 255) {
+                    *dest++ = b;
+                    *dest++ = g;
+                    *dest++ = r;
+                } else if (a == 0) {
+                    *dest++ = bg_blue;
+                    *dest++ = bg_green;
+                    *dest++ = bg_red;
+                } else {
+                    /* this macro (copied from png.h) composites the
+                     * foreground and background values and puts the
+                     * result into the first argument; there are no
+                     * side effects with the first argument */
+                    alpha_composite(*dest++, b, a, bg_blue);
+                    alpha_composite(*dest++, g, a, bg_green);
+                    alpha_composite(*dest++, r, a, bg_red);
+                }
+            }
+        }
+        /* display after every 16 lines */
+        if (((row+1) & 0xf) == 0) {
+            rect.left = 0L;
+            rect.top = (LONG)lastrow;
+            rect.right = (LONG)image_width;      /* possibly off by one? */
+            rect.bottom = (LONG)lastrow + 16L;   /* possibly off by one? */
+            InvalidateRect(global_hwnd, &rect, FALSE);
+            UpdateWindow(global_hwnd);     /* similar to XFlush() */
+            lastrow = row + 1;
+        }
+    }
+
+    Trace((stderr, "calling final image-flush routine\n"))
+    if (lastrow < image_height) {
+        rect.left = 0L;
+        rect.top = (LONG)lastrow;
+        rect.right = (LONG)image_width;      /* possibly off by one? */
+        rect.bottom = (LONG)image_height;    /* possibly off by one? */
+        InvalidateRect(global_hwnd, &rect, FALSE);
+        UpdateWindow(global_hwnd);     /* similar to XFlush() */
+    }
+
+/*
+    last param determines whether or not background is wiped before paint
+    InvalidateRect(global_hwnd, NULL, TRUE);
+    UpdateWindow(global_hwnd);
+ */
+
+    return 0;
+}
+
+
+
+
+
+static void rpng_win_cleanup()
+{
+    if (image_data) {
+        free(image_data);
+        image_data = NULL;
+    }
+
+    if (dib) {
+        free(dib);
+        dib = NULL;
+    }
+}
+
+
+
+
+
+LRESULT CALLBACK rpng_win_wndproc(HWND hwnd, UINT iMsg, WPARAM wP, LPARAM lP)
+{
+    HDC         hdc;
+    PAINTSTRUCT ps;
+    int rc;
+
+    switch (iMsg) {
+        case WM_CREATE:
+            /* one-time processing here, if any */
+            return 0;
+
+        case WM_PAINT:
+            hdc = BeginPaint(hwnd, &ps);
+                    /*                    dest                          */
+            rc = StretchDIBits(hdc, 0, 0, image_width, image_height,
+                    /*                    source                        */
+                                    0, 0, image_width, image_height,
+                                    wimage_data, (BITMAPINFO *)bmih,
+                    /*              iUsage: no clue                     */
+                                    0, SRCCOPY);
+            EndPaint(hwnd, &ps);
+            return 0;
+
+        /* wait for the user to tell us when to quit */
+        case WM_CHAR:
+            switch (wP) {      /* only need one, so ignore repeat count */
+                case 'q':
+                case 'Q':
+                case 0x1B:     /* Esc key */
+                    PostQuitMessage(0);
+            }
+            return 0;
+
+        case WM_LBUTTONDOWN:   /* another way of quitting */
+        case WM_DESTROY:
+            PostQuitMessage(0);
+            return 0;
+    }
+
+    return DefWindowProc(hwnd, iMsg, wP, lP);
+}
diff --git a/Engine/lib/lpng/contrib/gregbook/rpng-x.c b/Engine/lib/lpng/contrib/gregbook/rpng-x.c
new file mode 100644
index 000000000..92effaa6d
--- /dev/null
+++ b/Engine/lib/lpng/contrib/gregbook/rpng-x.c
@@ -0,0 +1,911 @@
+/*---------------------------------------------------------------------------
+
+   rpng - simple PNG display program                               rpng-x.c
+
+   This program decodes and displays PNG images, with gamma correction and
+   optionally with a user-specified background color (in case the image has
+   transparency).  It is very nearly the most basic PNG viewer possible.
+   This version is for the X Window System (tested by author under Unix and
+   by Martin Zinser under OpenVMS; may work under OS/2 with some tweaking).
+
+   to do:
+    - 8-bit (colormapped) X support
+    - use %.1023s to simplify truncation of title-bar string?
+
+  ---------------------------------------------------------------------------
+
+   Changelog:
+    - 1.01:  initial public release
+    - 1.02:  modified to allow abbreviated options; fixed long/ulong mis-
+              match; switched to png_jmpbuf() macro
+    - 1.10:  added support for non-default visuals; fixed X pixel-conversion
+    - 1.11:  added extra set of parentheses to png_jmpbuf() macro; fixed
+              command-line parsing bug
+    - 1.12:  fixed some small X memory leaks (thanks to François Petitjean)
+    - 1.13:  fixed XFreeGC() crash bug (thanks to Patrick Welche)
+    - 1.14:  added support for X resources (thanks to Gerhard Niklasch)
+    - 2.00:  dual-licensed (added GNU GPL)
+    - 2.01:  fixed improper display of usage screen on PNG error(s)
+    - 2.02:  Added "void(argc);" statement to quiet pedantic compiler warnings
+             about unused variable (GR-P)
+    - 2.03:  check for integer overflow (Glenn R-P)
+
+  ---------------------------------------------------------------------------
+
+      Copyright (c) 1998-2008, 2017 Greg Roelofs.  All rights reserved.
+
+      This software is provided "as is," without warranty of any kind,
+      express or implied.  In no event shall the author or contributors
+      be held liable for any damages arising in any way from the use of
+      this software.
+
+      The contents of this file are DUAL-LICENSED.  You may modify and/or
+      redistribute this software according to the terms of one of the
+      following two licenses (at your option):
+
+
+      LICENSE 1 ("BSD-like with advertising clause"):
+
+      Permission is granted to anyone to use this software for any purpose,
+      including commercial applications, and to alter it and redistribute
+      it freely, subject to the following restrictions:
+
+      1. Redistributions of source code must retain the above copyright
+         notice, disclaimer, and this list of conditions.
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, disclaimer, and this list of conditions in the documenta-
+         tion and/or other materials provided with the distribution.
+      3. All advertising materials mentioning features or use of this
+         software must display the following acknowledgment:
+
+            This product includes software developed by Greg Roelofs
+            and contributors for the book, "PNG: The Definitive Guide,"
+            published by O'Reilly and Associates.
+
+
+      LICENSE 2 (GNU GPL v2 or later):
+
+      This program is free software; you can redistribute it and/or modify
+      it under the terms of the GNU General Public License as published by
+      the Free Software Foundation; either version 2 of the License, or
+      (at your option) any later version.
+
+      This program is distributed in the hope that it will be useful,
+      but WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+      GNU General Public License for more details.
+
+      You should have received a copy of the GNU General Public License
+      along with this program; if not, write to the Free Software Foundation,
+      Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  ---------------------------------------------------------------------------*/
+
+#define PROGNAME  "rpng-x"
+#define LONGNAME  "Simple PNG Viewer for X"
+#define VERSION   "2.02 of 15 June 2014"
+#define RESNAME   "rpng"        /* our X resource application name */
+#define RESCLASS  "Rpng"        /* our X resource class name */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xos.h>
+#include <X11/keysym.h>
+
+/* #define DEBUG  :  this enables the Trace() macros */
+
+#include "readpng.h"   /* typedefs, common macros, readpng prototypes */
+
+
+/* could just include png.h, but this macro is the only thing we need
+ * (name and typedefs changed to local versions); note that side effects
+ * only happen with alpha (which could easily be avoided with
+ * "ush acopy = (alpha);") */
+
+#define alpha_composite(composite, fg, alpha, bg) {               \
+    ush temp = ((ush)(fg)*(ush)(alpha) +                          \
+                (ush)(bg)*(ush)(255 - (ush)(alpha)) + (ush)128);  \
+    (composite) = (uch)((temp + (temp >> 8)) >> 8);               \
+}
+
+
+/* local prototypes */
+static int  rpng_x_create_window(void);
+static int  rpng_x_display_image(void);
+static void rpng_x_cleanup(void);
+static int  rpng_x_msb(ulg u32val);
+
+
+static char titlebar[1024], *window_name = titlebar;
+static char *appname = LONGNAME;
+static char *icon_name = PROGNAME;
+static char *res_name = RESNAME;
+static char *res_class = RESCLASS;
+static char *filename;
+static FILE *infile;
+
+static char *bgstr;
+static uch bg_red=0, bg_green=0, bg_blue=0;
+
+static double display_exponent;
+
+static ulg image_width, image_height, image_rowbytes;
+static int image_channels;
+static uch *image_data;
+
+/* X-specific variables */
+static char *displayname;
+static XImage *ximage;
+static Display *display;
+static int depth;
+static Visual *visual;
+static XVisualInfo *visual_list;
+static int RShift, GShift, BShift;
+static ulg RMask, GMask, BMask;
+static Window window;
+static GC gc;
+static Colormap colormap;
+
+static int have_nondefault_visual = FALSE;
+static int have_colormap = FALSE;
+static int have_window = FALSE;
+static int have_gc = FALSE;
+/*
+ulg numcolors=0, pixels[256];
+ush reds[256], greens[256], blues[256];
+ */
+
+
+
+
+int main(int argc, char **argv)
+{
+#ifdef sgi
+    char tmpline[80];
+#endif
+    char *p;
+    int rc, alen, flen;
+    int error = 0;
+    int have_bg = FALSE;
+    double LUT_exponent;               /* just the lookup table */
+    double CRT_exponent = 2.2;         /* just the monitor */
+    double default_display_exponent;   /* whole display system */
+    XEvent e;
+    KeySym k;
+
+
+    displayname = (char *)NULL;
+    filename = (char *)NULL;
+
+
+    /* First set the default value for our display-system exponent, i.e.,
+     * the product of the CRT exponent and the exponent corresponding to
+     * the frame-buffer's lookup table (LUT), if any.  This is not an
+     * exhaustive list of LUT values (e.g., OpenStep has a lot of weird
+     * ones), but it should cover 99% of the current possibilities. */
+
+#if defined(NeXT)
+    LUT_exponent = 1.0 / 2.2;
+    /*
+    if (some_next_function_that_returns_gamma(&next_gamma))
+        LUT_exponent = 1.0 / next_gamma;
+     */
+#elif defined(sgi)
+    LUT_exponent = 1.0 / 1.7;
+    /* there doesn't seem to be any documented function to get the
+     * "gamma" value, so we do it the hard way */
+    infile = fopen("/etc/config/system.glGammaVal", "r");
+    if (infile) {
+        double sgi_gamma;
+
+        fgets(tmpline, 80, infile);
+        fclose(infile);
+        sgi_gamma = atof(tmpline);
+        if (sgi_gamma > 0.0)
+            LUT_exponent = 1.0 / sgi_gamma;
+    }
+#elif defined(Macintosh)
+    LUT_exponent = 1.8 / 2.61;
+    /*
+    if (some_mac_function_that_returns_gamma(&mac_gamma))
+        LUT_exponent = mac_gamma / 2.61;
+     */
+#else
+    LUT_exponent = 1.0;   /* assume no LUT:  most PCs */
+#endif
+
+    /* the defaults above give 1.0, 1.3, 1.5 and 2.2, respectively: */
+    default_display_exponent = LUT_exponent * CRT_exponent;
+
+
+    /* If the user has set the SCREEN_GAMMA environment variable as suggested
+     * (somewhat imprecisely) in the libpng documentation, use that; otherwise
+     * use the default value we just calculated.  Either way, the user may
+     * override this via a command-line option. */
+
+    if ((p = getenv("SCREEN_GAMMA")) != NULL)
+        display_exponent = atof(p);
+    else
+        display_exponent = default_display_exponent;
+
+
+    /* Now parse the command line for options and the PNG filename. */
+
+    while (*++argv && !error) {
+        if (!strncmp(*argv, "-display", 2)) {
+            if (!*++argv)
+                ++error;
+            else
+                displayname = *argv;
+        } else if (!strncmp(*argv, "-gamma", 2)) {
+            if (!*++argv)
+                ++error;
+            else {
+                display_exponent = atof(*argv);
+                if (display_exponent <= 0.0)
+                    ++error;
+            }
+        } else if (!strncmp(*argv, "-bgcolor", 2)) {
+            if (!*++argv)
+                ++error;
+            else {
+                bgstr = *argv;
+                if (strlen(bgstr) != 7 || bgstr[0] != '#')
+                    ++error;
+                else
+                    have_bg = TRUE;
+            }
+        } else {
+            if (**argv != '-') {
+                filename = *argv;
+                if (argv[1])   /* shouldn't be any more args after filename */
+                    ++error;
+            } else
+                ++error;   /* not expecting any other options */
+        }
+    }
+
+    if (!filename)
+        ++error;
+
+
+    /* print usage screen if any errors up to this point */
+
+    if (error) {
+        fprintf(stderr, "\n%s %s:  %s\n", PROGNAME, VERSION, appname);
+        readpng_version_info();
+        fprintf(stderr, "\n"
+          "Usage:  %s [-display xdpy] [-gamma exp] [-bgcolor bg] file.png\n"
+          "    xdpy\tname of the target X display (e.g., ``hostname:0'')\n"
+          "    exp \ttransfer-function exponent (``gamma'') of the display\n"
+          "\t\t  system in floating-point format (e.g., ``%.1f''); equal\n",
+          PROGNAME, default_display_exponent);
+
+        fprintf(stderr, "\n"
+          "\t\t  to the product of the lookup-table exponent (varies)\n"
+          "\t\t  and the CRT exponent (usually 2.2); must be positive\n"
+          "    bg  \tdesired background color in 7-character hex RGB format\n"
+          "\t\t  (e.g., ``#ff7700'' for orange:  same as HTML colors);\n"
+          "\t\t  used with transparent images\n"
+          "\nPress Q, Esc or mouse button 1 (within image window, after image\n"
+          "is displayed) to quit.\n");
+        exit(1);
+    }
+
+
+    if (!(infile = fopen(filename, "rb"))) {
+        fprintf(stderr, PROGNAME ":  can't open PNG file [%s]\n", filename);
+        ++error;
+    } else {
+        if ((rc = readpng_init(infile, &image_width, &image_height)) != 0) {
+            switch (rc) {
+                case 1:
+                    fprintf(stderr, PROGNAME
+                      ":  [%s] is not a PNG file: incorrect signature\n",
+                      filename);
+                    break;
+                case 2:
+                    fprintf(stderr, PROGNAME
+                      ":  [%s] has bad IHDR (libpng longjmp)\n", filename);
+                    break;
+                case 4:
+                    fprintf(stderr, PROGNAME ":  insufficient memory\n");
+                    break;
+                default:
+                    fprintf(stderr, PROGNAME
+                      ":  unknown readpng_init() error\n");
+                    break;
+            }
+            ++error;
+        } else {
+            display = XOpenDisplay(displayname);
+            if (!display) {
+                readpng_cleanup(TRUE);
+                fprintf(stderr, PROGNAME ":  can't open X display [%s]\n",
+                  displayname? displayname : "default");
+                ++error;
+            }
+        }
+        if (error)
+            fclose(infile);
+    }
+
+
+    if (error) {
+        fprintf(stderr, PROGNAME ":  aborting.\n");
+        exit(2);
+    }
+
+
+    /* set the title-bar string, but make sure buffer doesn't overflow */
+
+    alen = strlen(appname);
+    flen = strlen(filename);
+    if (alen + flen + 3 > 1023)
+        sprintf(titlebar, "%s:  ...%s", appname, filename+(alen+flen+6-1023));
+    else
+        sprintf(titlebar, "%s:  %s", appname, filename);
+
+
+    /* if the user didn't specify a background color on the command line,
+     * check for one in the PNG file--if not, the initialized values of 0
+     * (black) will be used */
+
+    if (have_bg) {
+        unsigned r, g, b;   /* this approach quiets compiler warnings */
+
+        sscanf(bgstr+1, "%2x%2x%2x", &r, &g, &b);
+        bg_red   = (uch)r;
+        bg_green = (uch)g;
+        bg_blue  = (uch)b;
+    } else if (readpng_get_bgcolor(&bg_red, &bg_green, &bg_blue) > 1) {
+        readpng_cleanup(TRUE);
+        fprintf(stderr, PROGNAME
+          ":  libpng error while checking for background color\n");
+        exit(2);
+    }
+
+
+    /* do the basic X initialization stuff, make the window and fill it
+     * with the background color */
+
+    if (rpng_x_create_window())
+        exit(2);
+
+
+    /* decode the image, all at once */
+
+    Trace((stderr, "calling readpng_get_image()\n"))
+    image_data = readpng_get_image(display_exponent, &image_channels,
+      &image_rowbytes);
+    Trace((stderr, "done with readpng_get_image()\n"))
+
+
+    /* done with PNG file, so clean up to minimize memory usage (but do NOT
+     * nuke image_data!) */
+
+    readpng_cleanup(FALSE);
+    fclose(infile);
+
+    if (!image_data) {
+        fprintf(stderr, PROGNAME ":  unable to decode PNG image\n");
+        exit(3);
+    }
+
+
+    /* display image (composite with background if requested) */
+
+    Trace((stderr, "calling rpng_x_display_image()\n"))
+    if (rpng_x_display_image()) {
+        free(image_data);
+        exit(4);
+    }
+    Trace((stderr, "done with rpng_x_display_image()\n"))
+
+
+    /* wait for the user to tell us when to quit */
+
+    printf(
+      "Done.  Press Q, Esc or mouse button 1 (within image window) to quit.\n");
+    fflush(stdout);
+
+    do
+        XNextEvent(display, &e);
+    while (!(e.type == ButtonPress && e.xbutton.button == Button1) &&
+           !(e.type == KeyPress &&    /*  v--- or 1 for shifted keys */
+             ((k = XLookupKeysym(&e.xkey, 0)) == XK_q || k == XK_Escape) ));
+
+
+    /* OK, we're done:  clean up all image and X resources and go away */
+
+    rpng_x_cleanup();
+
+    (void)argc; /* Unused */
+
+    return 0;
+}
+
+
+
+
+
+static int rpng_x_create_window(void)
+{
+    uch *xdata;
+    int need_colormap = FALSE;
+    int screen, pad;
+    ulg bg_pixel = 0L;
+    ulg attrmask;
+    Window root;
+    XEvent e;
+    XGCValues gcvalues;
+    XSetWindowAttributes attr;
+    XTextProperty windowName, *pWindowName = &windowName;
+    XTextProperty iconName, *pIconName = &iconName;
+    XVisualInfo visual_info;
+    XSizeHints *size_hints;
+    XWMHints *wm_hints;
+    XClassHint *class_hints;
+
+
+    screen = DefaultScreen(display);
+    depth = DisplayPlanes(display, screen);
+    root = RootWindow(display, screen);
+
+#ifdef DEBUG
+    XSynchronize(display, True);
+#endif
+
+#if 0
+/* GRR:  add 8-bit support */
+    if (/* depth != 8 && */ depth != 16 && depth != 24 && depth != 32) {
+        fprintf(stderr,
+          "screen depth %d not supported (only 16-, 24- or 32-bit TrueColor)\n",
+          depth);
+        return 2;
+    }
+
+    XMatchVisualInfo(display, screen, depth,
+      (depth == 8)? PseudoColor : TrueColor, &visual_info);
+    visual = visual_info.visual;
+#else
+    if (depth != 16 && depth != 24 && depth != 32) {
+        int visuals_matched = 0;
+
+        Trace((stderr, "default depth is %d:  checking other visuals\n",
+          depth))
+
+        /* 24-bit first */
+        visual_info.screen = screen;
+        visual_info.depth = 24;
+        visual_list = XGetVisualInfo(display,
+          VisualScreenMask | VisualDepthMask, &visual_info, &visuals_matched);
+        if (visuals_matched == 0) {
+/* GRR:  add 15-, 16- and 32-bit TrueColor visuals (also DirectColor?) */
+            fprintf(stderr, "default screen depth %d not supported, and no"
+              " 24-bit visuals found\n", depth);
+            return 2;
+        }
+        Trace((stderr, "XGetVisualInfo() returned %d 24-bit visuals\n",
+          visuals_matched))
+        visual = visual_list[0].visual;
+        depth = visual_list[0].depth;
+/*
+        colormap_size = visual_list[0].colormap_size;
+        visual_class = visual->class;
+        visualID = XVisualIDFromVisual(visual);
+ */
+        have_nondefault_visual = TRUE;
+        need_colormap = TRUE;
+    } else {
+        XMatchVisualInfo(display, screen, depth, TrueColor, &visual_info);
+        visual = visual_info.visual;
+    }
+#endif
+
+    RMask = visual->red_mask;
+    GMask = visual->green_mask;
+    BMask = visual->blue_mask;
+
+/* GRR:  add/check 8-bit support */
+    if (depth == 8 || need_colormap) {
+        colormap = XCreateColormap(display, root, visual, AllocNone);
+        if (!colormap) {
+            fprintf(stderr, "XCreateColormap() failed\n");
+            return 2;
+        }
+        have_colormap = TRUE;
+    }
+    if (depth == 15 || depth == 16) {
+        RShift = 15 - rpng_x_msb(RMask);    /* these are right-shifts */
+        GShift = 15 - rpng_x_msb(GMask);
+        BShift = 15 - rpng_x_msb(BMask);
+    } else if (depth > 16) {
+#define NO_24BIT_MASKS
+#ifdef NO_24BIT_MASKS
+        RShift = rpng_x_msb(RMask) - 7;     /* these are left-shifts */
+        GShift = rpng_x_msb(GMask) - 7;
+        BShift = rpng_x_msb(BMask) - 7;
+#else
+        RShift = 7 - rpng_x_msb(RMask);     /* these are right-shifts, too */
+        GShift = 7 - rpng_x_msb(GMask);
+        BShift = 7 - rpng_x_msb(BMask);
+#endif
+    }
+    if (depth >= 15 && (RShift < 0 || GShift < 0 || BShift < 0)) {
+        fprintf(stderr, "rpng internal logic error:  negative X shift(s)!\n");
+        return 2;
+    }
+
+/*---------------------------------------------------------------------------
+    Finally, create the window.
+  ---------------------------------------------------------------------------*/
+
+    attr.backing_store = Always;
+    attr.event_mask = ExposureMask | KeyPressMask | ButtonPressMask;
+    attrmask = CWBackingStore | CWEventMask;
+    if (have_nondefault_visual) {
+        attr.colormap = colormap;
+        attr.background_pixel = 0;
+        attr.border_pixel = 1;
+        attrmask |= CWColormap | CWBackPixel | CWBorderPixel;
+    }
+
+    window = XCreateWindow(display, root, 0, 0, image_width, image_height, 0,
+      depth, InputOutput, visual, attrmask, &attr);
+
+    if (window == None) {
+        fprintf(stderr, "XCreateWindow() failed\n");
+        return 2;
+    } else
+        have_window = TRUE;
+
+    if (depth == 8)
+        XSetWindowColormap(display, window, colormap);
+
+    if (!XStringListToTextProperty(&window_name, 1, pWindowName))
+        pWindowName = NULL;
+    if (!XStringListToTextProperty(&icon_name, 1, pIconName))
+        pIconName = NULL;
+
+    /* OK if any hints allocation fails; XSetWMProperties() allows NULLs */
+
+    if ((size_hints = XAllocSizeHints()) != NULL) {
+        /* window will not be resizable */
+        size_hints->flags = PMinSize | PMaxSize;
+        size_hints->min_width = size_hints->max_width = (int)image_width;
+        size_hints->min_height = size_hints->max_height = (int)image_height;
+    }
+
+    if ((wm_hints = XAllocWMHints()) != NULL) {
+        wm_hints->initial_state = NormalState;
+        wm_hints->input = True;
+     /* wm_hints->icon_pixmap = icon_pixmap; */
+        wm_hints->flags = StateHint | InputHint  /* | IconPixmapHint */ ;
+    }
+
+    if ((class_hints = XAllocClassHint()) != NULL) {
+        class_hints->res_name = res_name;
+        class_hints->res_class = res_class;
+    }
+
+    XSetWMProperties(display, window, pWindowName, pIconName, NULL, 0,
+      size_hints, wm_hints, class_hints);
+
+    /* various properties and hints no longer needed; free memory */
+    if (pWindowName)
+       XFree(pWindowName->value);
+    if (pIconName)
+       XFree(pIconName->value);
+    if (size_hints)
+        XFree(size_hints);
+    if (wm_hints)
+       XFree(wm_hints);
+    if (class_hints)
+       XFree(class_hints);
+
+    XMapWindow(display, window);
+
+    gc = XCreateGC(display, window, 0, &gcvalues);
+    have_gc = TRUE;
+
+/*---------------------------------------------------------------------------
+    Fill window with the specified background color.
+  ---------------------------------------------------------------------------*/
+
+    if (depth == 24 || depth == 32) {
+        bg_pixel = ((ulg)bg_red   << RShift) |
+                   ((ulg)bg_green << GShift) |
+                   ((ulg)bg_blue  << BShift);
+    } else if (depth == 16) {
+        bg_pixel = ((((ulg)bg_red   << 8) >> RShift) & RMask) |
+                   ((((ulg)bg_green << 8) >> GShift) & GMask) |
+                   ((((ulg)bg_blue  << 8) >> BShift) & BMask);
+    } else /* depth == 8 */ {
+
+        /* GRR:  add 8-bit support */
+
+    }
+
+    XSetForeground(display, gc, bg_pixel);
+    XFillRectangle(display, window, gc, 0, 0, image_width, image_height);
+
+/*---------------------------------------------------------------------------
+    Wait for first Expose event to do any drawing, then flush.
+  ---------------------------------------------------------------------------*/
+
+    do
+        XNextEvent(display, &e);
+    while (e.type != Expose || e.xexpose.count);
+
+    XFlush(display);
+
+/*---------------------------------------------------------------------------
+    Allocate memory for the X- and display-specific version of the image.
+  ---------------------------------------------------------------------------*/
+
+    if (depth == 24 || depth == 32) {
+        xdata = (uch *)malloc(4*image_width*image_height);
+        pad = 32;
+    } else if (depth == 16) {
+        xdata = (uch *)malloc(2*image_width*image_height);
+        pad = 16;
+    } else /* depth == 8 */ {
+        xdata = (uch *)malloc(image_width*image_height);
+        pad = 8;
+    }
+
+    if (!xdata) {
+        fprintf(stderr, PROGNAME ":  unable to allocate image memory\n");
+        return 4;
+    }
+
+    ximage = XCreateImage(display, visual, depth, ZPixmap, 0,
+      (char *)xdata, image_width, image_height, pad, 0);
+
+    if (!ximage) {
+        fprintf(stderr, PROGNAME ":  XCreateImage() failed\n");
+        free(xdata);
+        return 3;
+    }
+
+    /* to avoid testing the byte order every pixel (or doubling the size of
+     * the drawing routine with a giant if-test), we arbitrarily set the byte
+     * order to MSBFirst and let Xlib worry about inverting things on little-
+     * endian machines (like Linux/x86, old VAXen, etc.)--this is not the most
+     * efficient approach (the giant if-test would be better), but in the
+     * interest of clarity, we take the easy way out... */
+
+    ximage->byte_order = MSBFirst;
+
+    return 0;
+
+} /* end function rpng_x_create_window() */
+
+
+
+
+
+static int rpng_x_display_image(void)
+{
+    uch *src;
+    char *dest;
+    uch r, g, b, a;
+    ulg i, row, lastrow = 0;
+    ulg pixel;
+    int ximage_rowbytes = ximage->bytes_per_line;
+/*  int bpp = ximage->bits_per_pixel;  */
+
+
+    Trace((stderr, "beginning display loop (image_channels == %d)\n",
+      image_channels))
+    Trace((stderr, "   (width = %ld, rowbytes = %ld, ximage_rowbytes = %d)\n",
+      image_width, image_rowbytes, ximage_rowbytes))
+    Trace((stderr, "   (bpp = %d)\n", ximage->bits_per_pixel))
+    Trace((stderr, "   (byte_order = %s)\n", ximage->byte_order == MSBFirst?
+      "MSBFirst" : (ximage->byte_order == LSBFirst? "LSBFirst" : "unknown")))
+
+    if (depth == 24 || depth == 32) {
+        ulg red, green, blue;
+
+        for (lastrow = row = 0;  row < image_height;  ++row) {
+            src = image_data + row*image_rowbytes;
+            dest = ximage->data + row*ximage_rowbytes;
+            if (image_channels == 3) {
+                for (i = image_width;  i > 0;  --i) {
+                    red   = *src++;
+                    green = *src++;
+                    blue  = *src++;
+#ifdef NO_24BIT_MASKS
+                    pixel = (red   << RShift) |
+                            (green << GShift) |
+                            (blue  << BShift);
+                    /* recall that we set ximage->byte_order = MSBFirst above */
+                    /* GRR BUG:  this assumes bpp == 32, but may be 24: */
+                    *dest++ = (char)((pixel >> 24) & 0xff);
+                    *dest++ = (char)((pixel >> 16) & 0xff);
+                    *dest++ = (char)((pixel >>  8) & 0xff);
+                    *dest++ = (char)( pixel        & 0xff);
+#else
+                    red   = (RShift < 0)? red   << (-RShift) : red   >> RShift;
+                    green = (GShift < 0)? green << (-GShift) : green >> GShift;
+                    blue  = (BShift < 0)? blue  << (-BShift) : blue  >> BShift;
+                    pixel = (red & RMask) | (green & GMask) | (blue & BMask);
+                    /* recall that we set ximage->byte_order = MSBFirst above */
+                    *dest++ = (char)((pixel >> 24) & 0xff);
+                    *dest++ = (char)((pixel >> 16) & 0xff);
+                    *dest++ = (char)((pixel >>  8) & 0xff);
+                    *dest++ = (char)( pixel        & 0xff);
+#endif
+                }
+            } else /* if (image_channels == 4) */ {
+                for (i = image_width;  i > 0;  --i) {
+                    r = *src++;
+                    g = *src++;
+                    b = *src++;
+                    a = *src++;
+                    if (a == 255) {
+                        red   = r;
+                        green = g;
+                        blue  = b;
+                    } else if (a == 0) {
+                        red   = bg_red;
+                        green = bg_green;
+                        blue  = bg_blue;
+                    } else {
+                        /* this macro (from png.h) composites the foreground
+                         * and background values and puts the result into the
+                         * first argument */
+                        alpha_composite(red,   r, a, bg_red);
+                        alpha_composite(green, g, a, bg_green);
+                        alpha_composite(blue,  b, a, bg_blue);
+                    }
+                    pixel = (red   << RShift) |
+                            (green << GShift) |
+                            (blue  << BShift);
+                    /* recall that we set ximage->byte_order = MSBFirst above */
+                    *dest++ = (char)((pixel >> 24) & 0xff);
+                    *dest++ = (char)((pixel >> 16) & 0xff);
+                    *dest++ = (char)((pixel >>  8) & 0xff);
+                    *dest++ = (char)( pixel        & 0xff);
+                }
+            }
+            /* display after every 16 lines */
+            if (((row+1) & 0xf) == 0) {
+                XPutImage(display, window, gc, ximage, 0, (int)lastrow, 0,
+                  (int)lastrow, image_width, 16);
+                XFlush(display);
+                lastrow = row + 1;
+            }
+        }
+
+    } else if (depth == 16) {
+        ush red, green, blue;
+
+        for (lastrow = row = 0;  row < image_height;  ++row) {
+            src = image_data + row*image_rowbytes;
+            dest = ximage->data + row*ximage_rowbytes;
+            if (image_channels == 3) {
+                for (i = image_width;  i > 0;  --i) {
+                    red   = ((ush)(*src) << 8);
+                    ++src;
+                    green = ((ush)(*src) << 8);
+                    ++src;
+                    blue  = ((ush)(*src) << 8);
+                    ++src;
+                    pixel = ((red   >> RShift) & RMask) |
+                            ((green >> GShift) & GMask) |
+                            ((blue  >> BShift) & BMask);
+                    /* recall that we set ximage->byte_order = MSBFirst above */
+                    *dest++ = (char)((pixel >>  8) & 0xff);
+                    *dest++ = (char)( pixel        & 0xff);
+                }
+            } else /* if (image_channels == 4) */ {
+                for (i = image_width;  i > 0;  --i) {
+                    r = *src++;
+                    g = *src++;
+                    b = *src++;
+                    a = *src++;
+                    if (a == 255) {
+                        red   = ((ush)r << 8);
+                        green = ((ush)g << 8);
+                        blue  = ((ush)b << 8);
+                    } else if (a == 0) {
+                        red   = ((ush)bg_red   << 8);
+                        green = ((ush)bg_green << 8);
+                        blue  = ((ush)bg_blue  << 8);
+                    } else {
+                        /* this macro (from png.h) composites the foreground
+                         * and background values and puts the result back into
+                         * the first argument (== fg byte here:  safe) */
+                        alpha_composite(r, r, a, bg_red);
+                        alpha_composite(g, g, a, bg_green);
+                        alpha_composite(b, b, a, bg_blue);
+                        red   = ((ush)r << 8);
+                        green = ((ush)g << 8);
+                        blue  = ((ush)b << 8);
+                    }
+                    pixel = ((red   >> RShift) & RMask) |
+                            ((green >> GShift) & GMask) |
+                            ((blue  >> BShift) & BMask);
+                    /* recall that we set ximage->byte_order = MSBFirst above */
+                    *dest++ = (char)((pixel >>  8) & 0xff);
+                    *dest++ = (char)( pixel        & 0xff);
+                }
+            }
+            /* display after every 16 lines */
+            if (((row+1) & 0xf) == 0) {
+                XPutImage(display, window, gc, ximage, 0, (int)lastrow, 0,
+                  (int)lastrow, image_width, 16);
+                XFlush(display);
+                lastrow = row + 1;
+            }
+        }
+
+    } else /* depth == 8 */ {
+
+        /* GRR:  add 8-bit support */
+
+    }
+
+    Trace((stderr, "calling final XPutImage()\n"))
+    if (lastrow < image_height) {
+        XPutImage(display, window, gc, ximage, 0, (int)lastrow, 0,
+          (int)lastrow, image_width, image_height-lastrow);
+        XFlush(display);
+    }
+
+    return 0;
+}
+
+
+
+
+static void rpng_x_cleanup(void)
+{
+    if (image_data) {
+        free(image_data);
+        image_data = NULL;
+    }
+
+    if (ximage) {
+        if (ximage->data) {
+            free(ximage->data);           /* we allocated it, so we free it */
+            ximage->data = (char *)NULL;  /*  instead of XDestroyImage() */
+        }
+        XDestroyImage(ximage);
+        ximage = NULL;
+    }
+
+    if (have_gc)
+        XFreeGC(display, gc);
+
+    if (have_window)
+        XDestroyWindow(display, window);
+
+    if (have_colormap)
+        XFreeColormap(display, colormap);
+
+    if (have_nondefault_visual)
+        XFree(visual_list);
+}
+
+
+
+
+
+static int rpng_x_msb(ulg u32val)
+{
+    int i;
+
+    for (i = 31;  i >= 0;  --i) {
+        if (u32val & 0x80000000L)
+            break;
+        u32val <<= 1;
+    }
+    return i;
+}
diff --git a/Engine/lib/lpng/contrib/gregbook/rpng2-win.c b/Engine/lib/lpng/contrib/gregbook/rpng2-win.c
new file mode 100644
index 000000000..ed6b526ec
--- /dev/null
+++ b/Engine/lib/lpng/contrib/gregbook/rpng2-win.c
@@ -0,0 +1,1261 @@
+/*---------------------------------------------------------------------------
+
+   rpng2 - progressive-model PNG display program                rpng2-win.c
+
+   This program decodes and displays PNG files progressively, as if it were
+   a web browser (though the front end is only set up to read from files).
+   It supports gamma correction, user-specified background colors, and user-
+   specified background patterns (for transparent images).  This version is
+   for 32-bit Windows; it may compile under 16-bit Windows with a little
+   tweaking (or maybe not).  Thanks to Adam Costello and Pieter S. van der
+   Meulen for the "diamond" and "radial waves" patterns, respectively.
+
+   to do (someday, maybe):
+    - handle quoted command-line args (especially filenames with spaces)
+    - finish resizable checkerboard-gradient (sizes 4-128?)
+    - use %.1023s to simplify truncation of title-bar string?
+    - have minimum window width:  oh well
+
+  ---------------------------------------------------------------------------
+
+   Changelog:
+    - 1.01:  initial public release
+    - 1.02:  fixed cut-and-paste error in usage screen (oops...)
+    - 1.03:  modified to allow abbreviated options
+    - 1.04:  removed bogus extra argument from usage fprintf() [Glenn R-P?];
+              fixed command-line parsing bug
+    - 1.10:  enabled "message window"/console (thanks to David Geldreich)
+    - 1.20:  added runtime MMX-enabling/disabling and new -mmx* options
+    - 1.21:  made minor tweak to usage screen to fit within 25-line console
+    - 1.22:  added AMD64/EM64T support (__x86_64__)
+    - 2.00:  dual-licensed (added GNU GPL)
+    - 2.01:  fixed 64-bit typo in readpng2.c
+    - 2.02:  fixed improper display of usage screen on PNG error(s); fixed
+              unexpected-EOF and file-read-error cases
+    - 2.03:  removed runtime MMX-enabling/disabling and obsolete -mmx* options
+    - 2.04:  check for integer overflow (Glenn R-P)
+
+  ---------------------------------------------------------------------------
+
+      Copyright (c) 1998-2008, 2017 Greg Roelofs.  All rights reserved.
+
+      This software is provided "as is," without warranty of any kind,
+      express or implied.  In no event shall the author or contributors
+      be held liable for any damages arising in any way from the use of
+      this software.
+
+      The contents of this file are DUAL-LICENSED.  You may modify and/or
+      redistribute this software according to the terms of one of the
+      following two licenses (at your option):
+
+
+      LICENSE 1 ("BSD-like with advertising clause"):
+
+      Permission is granted to anyone to use this software for any purpose,
+      including commercial applications, and to alter it and redistribute
+      it freely, subject to the following restrictions:
+
+      1. Redistributions of source code must retain the above copyright
+         notice, disclaimer, and this list of conditions.
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, disclaimer, and this list of conditions in the documenta-
+         tion and/or other materials provided with the distribution.
+      3. All advertising materials mentioning features or use of this
+         software must display the following acknowledgment:
+
+            This product includes software developed by Greg Roelofs
+            and contributors for the book, "PNG: The Definitive Guide,"
+            published by O'Reilly and Associates.
+
+
+      LICENSE 2 (GNU GPL v2 or later):
+
+      This program is free software; you can redistribute it and/or modify
+      it under the terms of the GNU General Public License as published by
+      the Free Software Foundation; either version 2 of the License, or
+      (at your option) any later version.
+
+      This program is distributed in the hope that it will be useful,
+      but WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+      GNU General Public License for more details.
+
+      You should have received a copy of the GNU General Public License
+      along with this program; if not, write to the Free Software Foundation,
+      Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  ---------------------------------------------------------------------------*/
+
+#define PROGNAME  "rpng2-win"
+#define LONGNAME  "Progressive PNG Viewer for Windows"
+#define VERSION   "2.02 of 16 March 2008"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <setjmp.h>    /* for jmpbuf declaration in readpng2.h */
+#include <time.h>
+#include <math.h>      /* only for PvdM background code */
+#include <windows.h>
+#ifdef __CYGWIN__
+/* getch replacement. Turns out, we don't really need this,
+ * but leave it here if we ever enable any of the uses of
+ * _getch in the main code
+ */
+#include <unistd.h>
+#include <termio.h>
+#include <sys/ioctl.h>
+int repl_getch( void )
+{
+  char ch;
+  int fd = fileno(stdin);
+  struct termio old_tty, new_tty;
+
+  ioctl(fd, TCGETA, &old_tty);
+  new_tty = old_tty;
+  new_tty.c_lflag &= ~(ICANON | ECHO | ISIG);
+  ioctl(fd, TCSETA, &new_tty);
+  fread(&ch, 1, sizeof(ch), stdin);
+  ioctl(fd, TCSETA, &old_tty);
+
+  return ch;
+}
+#define _getch repl_getch
+#else
+#include <conio.h>     /* only for _getch() */
+#endif
+
+/* all for PvdM background code: */
+#ifndef PI
+#  define PI             3.141592653589793238
+#endif
+#define PI_2             (PI*0.5)
+#define INV_PI_360       (360.0 / PI)
+#define MAX(a,b)         (a>b?a:b)
+#define MIN(a,b)         (a<b?a:b)
+#define CLIP(a,min,max)  MAX(min,MIN((a),max))
+#define ABS(a)           ((a)<0?-(a):(a))
+#define CLIP8P(c)        MAX(0,(MIN((c),255)))   /* 8-bit pos. integer (uch) */
+#define ROUNDF(f)        ((int)(f + 0.5))
+
+#define rgb1_max   bg_freq
+#define rgb1_min   bg_gray
+#define rgb2_max   bg_bsat
+#define rgb2_min   bg_brot
+
+/* #define DEBUG */     /* this enables the Trace() macros */
+
+#include "readpng2.h"   /* typedefs, common macros, readpng2 prototypes */
+
+
+/* could just include png.h, but this macro is the only thing we need
+ * (name and typedefs changed to local versions); note that side effects
+ * only happen with alpha (which could easily be avoided with
+ * "ush acopy = (alpha);") */
+
+#define alpha_composite(composite, fg, alpha, bg) {               \
+    ush temp = ((ush)(fg)*(ush)(alpha) +                          \
+                (ush)(bg)*(ush)(255 - (ush)(alpha)) + (ush)128);  \
+    (composite) = (uch)((temp + (temp >> 8)) >> 8);               \
+}
+
+
+#define INBUFSIZE 4096   /* with pseudo-timing on (1 sec delay/block), this
+                          *  block size corresponds roughly to a download
+                          *  speed 10% faster than theoretical 33.6K maximum
+                          *  (assuming 8 data bits, 1 stop bit and no other
+                          *  overhead) */
+
+/* local prototypes */
+static void       rpng2_win_init(void);
+static int        rpng2_win_create_window(void);
+static int        rpng2_win_load_bg_image(void);
+static void       rpng2_win_display_row(ulg row);
+static void       rpng2_win_finish_display(void);
+static void       rpng2_win_cleanup(void);
+LRESULT CALLBACK  rpng2_win_wndproc(HWND, UINT, WPARAM, LPARAM);
+
+
+static char titlebar[1024];
+static char *progname = PROGNAME;
+static char *appname = LONGNAME;
+static char *filename;
+static FILE *infile;
+
+static mainprog_info rpng2_info;
+
+static uch inbuf[INBUFSIZE];
+static int incount;
+
+static int pat = 6;         /* must be less than num_bgpat */
+static int bg_image = 0;
+static int bgscale = 16;
+static ulg bg_rowbytes;
+static uch *bg_data;
+
+static struct rgb_color {
+    uch r, g, b;
+} rgb[] = {
+    {  0,   0,   0},    /*  0:  black */
+    {255, 255, 255},    /*  1:  white */
+    {173, 132,  57},    /*  2:  tan */
+    { 64, 132,   0},    /*  3:  medium green */
+    {189, 117,   1},    /*  4:  gold */
+    {253, 249,   1},    /*  5:  yellow */
+    {  0,   0, 255},    /*  6:  blue */
+    {  0,   0, 120},    /*  7:  medium blue */
+    {255,   0, 255},    /*  8:  magenta */
+    { 64,   0,  64},    /*  9:  dark magenta */
+    {255,   0,   0},    /* 10:  red */
+    { 64,   0,   0},    /* 11:  dark red */
+    {255, 127,   0},    /* 12:  orange */
+    {192,  96,   0},    /* 13:  darker orange */
+    { 24,  60,   0},    /* 14:  dark green-yellow */
+    { 85, 125, 200}     /* 15:  ice blue */
+};
+/* not used for now, but should be for error-checking:
+static int num_rgb = sizeof(rgb) / sizeof(struct rgb_color);
+ */
+
+/*
+    This whole struct is a fairly cheesy way to keep the number of
+    command-line options to a minimum.  The radial-waves background
+    type is a particularly poor fit to the integer elements of the
+    struct...but a few macros and a little fixed-point math will do
+    wonders for ya.
+
+    type bits:
+       F E D C B A 9 8 7 6 5 4 3 2 1 0
+                             | | | | |
+                             | | +-+-+-- 0 = sharp-edged checkerboard
+                             | |         1 = soft diamonds
+                             | |         2 = radial waves
+                             | |       3-7 = undefined
+                             | +-- gradient #2 inverted?
+                             +-- alternating columns inverted?
+ */
+static struct background_pattern {
+    ush type;
+    int rgb1_max, rgb1_min;     /* or bg_freq, bg_gray */
+    int rgb2_max, rgb2_min;     /* or bg_bsat, bg_brot (both scaled by 10)*/
+} bg[] = {
+    {0+8,   2,0,  1,15},        /* checkered:  tan/black vs. white/ice blue */
+    {0+24,  2,0,  1,0},         /* checkered:  tan/black vs. white/black */
+    {0+8,   4,5,  0,2},         /* checkered:  gold/yellow vs. black/tan */
+    {0+8,   4,5,  0,6},         /* checkered:  gold/yellow vs. black/blue */
+    {0,     7,0,  8,9},         /* checkered:  deep blue/black vs. magenta */
+    {0+8,  13,0,  5,14},        /* checkered:  orange/black vs. yellow */
+    {0+8,  12,0, 10,11},        /* checkered:  orange/black vs. red */
+    {1,     7,0,  8,0},         /* diamonds:  deep blue/black vs. magenta */
+    {1,    12,0, 11,0},         /* diamonds:  orange vs. dark red */
+    {1,    10,0,  7,0},         /* diamonds:  red vs. medium blue */
+    {1,     4,0,  5,0},         /* diamonds:  gold vs. yellow */
+    {1,     3,0,  0,0},         /* diamonds:  medium green vs. black */
+    {2,    16, 100,  20,   0},  /* radial:  ~hard radial color-beams */
+    {2,    18, 100,  10,   2},  /* radial:  soft, curved radial color-beams */
+    {2,    16, 256, 100, 250},  /* radial:  very tight spiral */
+    {2, 10000, 256,  11,   0}   /* radial:  dipole-moire' (almost fractal) */
+};
+static int num_bgpat = sizeof(bg) / sizeof(struct background_pattern);
+
+
+/* Windows-specific global variables (could go in struct, but messy...) */
+static ulg wimage_rowbytes;
+static uch *dib;
+static uch *wimage_data;
+static BITMAPINFOHEADER *bmih;
+
+static HWND global_hwnd;
+static HINSTANCE global_hInst;
+static int global_showmode;
+
+
+
+
+int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, PSTR cmd, int showmode)
+{
+    char *args[1024];                 /* arbitrary limit, but should suffice */
+    char **argv = args;
+    char *p, *q, *bgstr = NULL;
+    int argc = 0;
+    int rc, alen, flen;
+    int error = 0;
+    int timing = FALSE;
+    int have_bg = FALSE;
+    double LUT_exponent;              /* just the lookup table */
+    double CRT_exponent = 2.2;        /* just the monitor */
+    double default_display_exponent;  /* whole display system */
+    MSG msg;
+
+
+    /* First initialize a few things, just to be sure--memset takes care of
+     * default background color (black), booleans (FALSE), pointers (NULL),
+     * etc. */
+
+    global_hInst = hInst;
+    global_showmode = showmode;
+    filename = (char *)NULL;
+    memset(&rpng2_info, 0, sizeof(mainprog_info));
+
+#ifndef __CYGWIN__
+    /* Next reenable console output, which normally goes to the bit bucket
+     * for windowed apps.  Closing the console window will terminate the
+     * app.  Thanks to David.Geldreich at realviz.com for supplying the magical
+     * incantation. */
+
+    AllocConsole();
+    freopen("CONOUT$", "a", stderr);
+    freopen("CONOUT$", "a", stdout);
+#endif
+
+    /* Set the default value for our display-system exponent, i.e., the
+     * product of the CRT exponent and the exponent corresponding to
+     * the frame-buffer's lookup table (LUT), if any.  This is not an
+     * exhaustive list of LUT values (e.g., OpenStep has a lot of weird
+     * ones), but it should cover 99% of the current possibilities.  And
+     * yes, these ifdefs are completely wasted in a Windows program... */
+
+#if defined(NeXT)
+    /* third-party utilities can modify the default LUT exponent */
+    LUT_exponent = 1.0 / 2.2;
+    /*
+    if (some_next_function_that_returns_gamma(&next_gamma))
+        LUT_exponent = 1.0 / next_gamma;
+     */
+#elif defined(sgi)
+    LUT_exponent = 1.0 / 1.7;
+    /* there doesn't seem to be any documented function to
+     * get the "gamma" value, so we do it the hard way */
+    infile = fopen("/etc/config/system.glGammaVal", "r");
+    if (infile) {
+        double sgi_gamma;
+
+        fgets(tmpline, 80, infile);
+        fclose(infile);
+        sgi_gamma = atof(tmpline);
+        if (sgi_gamma > 0.0)
+            LUT_exponent = 1.0 / sgi_gamma;
+    }
+#elif defined(Macintosh)
+    LUT_exponent = 1.8 / 2.61;
+    /*
+    if (some_mac_function_that_returns_gamma(&mac_gamma))
+        LUT_exponent = mac_gamma / 2.61;
+     */
+#else
+    LUT_exponent = 1.0;   /* assume no LUT:  most PCs */
+#endif
+
+    /* the defaults above give 1.0, 1.3, 1.5 and 2.2, respectively: */
+    default_display_exponent = LUT_exponent * CRT_exponent;
+
+
+    /* If the user has set the SCREEN_GAMMA environment variable as suggested
+     * (somewhat imprecisely) in the libpng documentation, use that; otherwise
+     * use the default value we just calculated.  Either way, the user may
+     * override this via a command-line option. */
+
+    if ((p = getenv("SCREEN_GAMMA")) != NULL)
+        rpng2_info.display_exponent = atof(p);
+    else
+        rpng2_info.display_exponent = default_display_exponent;
+
+
+    /* Windows really hates command lines, so we have to set up our own argv.
+     * Note that we do NOT bother with quoted arguments here, so don't use
+     * filenames with spaces in 'em! */
+
+    argv[argc++] = PROGNAME;
+    p = cmd;
+    for (;;) {
+        if (*p == ' ')
+            while (*++p == ' ')
+                ;
+        /* now p points at the first non-space after some spaces */
+        if (*p == '\0')
+            break;    /* nothing after the spaces:  done */
+        argv[argc++] = q = p;
+        while (*q && *q != ' ')
+            ++q;
+        /* now q points at a space or the end of the string */
+        if (*q == '\0')
+            break;    /* last argv already terminated; quit */
+        *q = '\0';    /* change space to terminator */
+        p = q + 1;
+    }
+    argv[argc] = NULL;   /* terminate the argv array itself */
+
+
+    /* Now parse the command line for options and the PNG filename. */
+
+    while (*++argv && !error) {
+        if (!strncmp(*argv, "-gamma", 2)) {
+            if (!*++argv)
+                ++error;
+            else {
+                rpng2_info.display_exponent = atof(*argv);
+                if (rpng2_info.display_exponent <= 0.0)
+                    ++error;
+            }
+        } else if (!strncmp(*argv, "-bgcolor", 4)) {
+            if (!*++argv)
+                ++error;
+            else {
+                bgstr = *argv;
+                if (strlen(bgstr) != 7 || bgstr[0] != '#')
+                    ++error;
+                else {
+                    have_bg = TRUE;
+                    bg_image = FALSE;
+                }
+            }
+        } else if (!strncmp(*argv, "-bgpat", 4)) {
+            if (!*++argv)
+                ++error;
+            else {
+                pat = atoi(*argv) - 1;
+                if (pat < 0 || pat >= num_bgpat)
+                    ++error;
+                else {
+                    bg_image = TRUE;
+                    have_bg = FALSE;
+                }
+            }
+        } else if (!strncmp(*argv, "-timing", 2)) {
+            timing = TRUE;
+        } else {
+            if (**argv != '-') {
+                filename = *argv;
+                if (argv[1])   /* shouldn't be any more args after filename */
+                    ++error;
+            } else
+                ++error;   /* not expecting any other options */
+        }
+    }
+
+    if (!filename)
+        ++error;
+
+
+    /* print usage screen if any errors up to this point */
+
+    if (error) {
+#ifndef __CYGWIN__
+        int ch;
+#endif
+
+        fprintf(stderr, "\n%s %s:  %s\n\n", PROGNAME, VERSION, appname);
+        readpng2_version_info();
+        fprintf(stderr, "\n"
+          "Usage:  %s [-gamma exp] [-bgcolor bg | -bgpat pat] [-timing]\n"
+          "        %*s file.png\n\n"
+          "    exp \ttransfer-function exponent (``gamma'') of the display\n"
+          "\t\t  system in floating-point format (e.g., ``%.1f''); equal\n"
+          "\t\t  to the product of the lookup-table exponent (varies)\n"
+          "\t\t  and the CRT exponent (usually 2.2); must be positive\n"
+          "    bg  \tdesired background color in 7-character hex RGB format\n"
+          "\t\t  (e.g., ``#ff7700'' for orange:  same as HTML colors);\n"
+          "\t\t  used with transparent images; overrides -bgpat option\n"
+          "    pat \tdesired background pattern number (1-%d); used with\n"
+          "\t\t  transparent images; overrides -bgcolor option\n"
+          "    -timing\tenables delay for every block read, to simulate modem\n"
+          "\t\t  download of image (~36 Kbps)\n"
+          "\nPress Q, Esc or mouse button 1 after image is displayed to quit.\n"
+#ifndef __CYGWIN__
+          "Press Q or Esc to quit this usage screen. ",
+#else
+          ,
+#endif
+          PROGNAME,
+#if (defined(__i386__) || defined(_M_IX86) || defined(__x86_64__)) && \
+    !(defined(__CYGWIN__) || defined(__MINGW32__))
+          (int)strlen(PROGNAME), " ",
+#endif
+          (int)strlen(PROGNAME), " ", default_display_exponent, num_bgpat);
+        fflush(stderr);
+#ifndef __CYGWIN__
+        do
+            ch = _getch();
+        while (ch != 'q' && ch != 'Q' && ch != 0x1B);
+#endif
+        exit(1);
+    }
+
+
+    if (!(infile = fopen(filename, "rb"))) {
+        fprintf(stderr, PROGNAME ":  can't open PNG file [%s]\n", filename);
+        ++error;
+    } else {
+        incount = fread(inbuf, 1, INBUFSIZE, infile);
+        if (incount < 8 || !readpng2_check_sig(inbuf, 8)) {
+            fprintf(stderr, PROGNAME
+              ":  [%s] is not a PNG file: incorrect signature\n",
+              filename);
+            ++error;
+        } else if ((rc = readpng2_init(&rpng2_info)) != 0) {
+            switch (rc) {
+                case 2:
+                    fprintf(stderr, PROGNAME
+                      ":  [%s] has bad IHDR (libpng longjmp)\n", filename);
+                    break;
+                case 4:
+                    fprintf(stderr, PROGNAME ":  insufficient memory\n");
+                    break;
+                default:
+                    fprintf(stderr, PROGNAME
+                      ":  unknown readpng2_init() error\n");
+                    break;
+            }
+            ++error;
+        }
+        if (error)
+            fclose(infile);
+    }
+
+
+    if (error) {
+#ifndef __CYGWIN__
+        int ch;
+#endif
+
+        fprintf(stderr, PROGNAME ":  aborting.\n");
+#ifndef __CYGWIN__
+        do
+            ch = _getch();
+        while (ch != 'q' && ch != 'Q' && ch != 0x1B);
+#endif
+        exit(2);
+    } else {
+        fprintf(stderr, "\n%s %s:  %s\n", PROGNAME, VERSION, appname);
+#ifndef __CYGWIN__
+        fprintf(stderr,
+          "\n   [console window:  closing this window will terminate %s]\n\n",
+          PROGNAME);
+#endif
+        fflush(stderr);
+    }
+
+
+    /* set the title-bar string, but make sure buffer doesn't overflow */
+
+    alen = strlen(appname);
+    flen = strlen(filename);
+    if (alen + flen + 3 > 1023)
+        sprintf(titlebar, "%s:  ...%s", appname, filename+(alen+flen+6-1023));
+    else
+        sprintf(titlebar, "%s:  %s", appname, filename);
+
+
+    /* set some final rpng2_info variables before entering main data loop */
+
+    if (have_bg) {
+        unsigned r, g, b;   /* this approach quiets compiler warnings */
+
+        sscanf(bgstr+1, "%2x%2x%2x", &r, &g, &b);
+        rpng2_info.bg_red   = (uch)r;
+        rpng2_info.bg_green = (uch)g;
+        rpng2_info.bg_blue  = (uch)b;
+    } else
+        rpng2_info.need_bgcolor = TRUE;
+
+    rpng2_info.state = kPreInit;
+    rpng2_info.mainprog_init = rpng2_win_init;
+    rpng2_info.mainprog_display_row = rpng2_win_display_row;
+    rpng2_info.mainprog_finish_display = rpng2_win_finish_display;
+
+
+    /* OK, this is the fun part:  call readpng2_decode_data() at the start of
+     * the loop to deal with our first buffer of data (read in above to verify
+     * that the file is a PNG image), then loop through the file and continue
+     * calling the same routine to handle each chunk of data.  It in turn
+     * passes the data to libpng, which will invoke one or more of our call-
+     * backs as decoded data become available.  We optionally call Sleep() for
+     * one second per iteration to simulate downloading the image via an analog
+     * modem. */
+
+    for (;;) {
+        Trace((stderr, "about to call readpng2_decode_data()\n"))
+        if (readpng2_decode_data(&rpng2_info, inbuf, incount))
+            ++error;
+        Trace((stderr, "done with readpng2_decode_data()\n"))
+
+        if (error || incount != INBUFSIZE || rpng2_info.state == kDone) {
+            if (rpng2_info.state == kDone) {
+                Trace((stderr, "done decoding PNG image\n"))
+            } else if (ferror(infile)) {
+                fprintf(stderr, PROGNAME
+                  ":  error while reading PNG image file\n");
+                exit(3);
+            } else if (feof(infile)) {
+                fprintf(stderr, PROGNAME ":  end of file reached "
+                  "(unexpectedly) while reading PNG image file\n");
+                exit(3);
+            } else /* if (error) */ {
+                /* will print error message below */
+            }
+            break;
+        }
+
+        if (timing)
+            Sleep(1000L);
+
+        incount = fread(inbuf, 1, INBUFSIZE, infile);
+    }
+
+
+    /* clean up PNG stuff and report any decoding errors */
+
+    fclose(infile);
+    Trace((stderr, "about to call readpng2_cleanup()\n"))
+    readpng2_cleanup(&rpng2_info);
+
+    if (error) {
+        fprintf(stderr, PROGNAME ":  libpng error while decoding PNG image\n");
+        exit(3);
+    }
+
+
+    /* wait for the user to tell us when to quit */
+
+    while (GetMessage(&msg, NULL, 0, 0)) {
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+    }
+
+
+    /* we're done:  clean up all image and Windows resources and go away */
+
+    Trace((stderr, "about to call rpng2_win_cleanup()\n"))
+    rpng2_win_cleanup();
+
+    return msg.wParam;
+}
+
+
+
+
+
+/* this function is called by readpng2_info_callback() in readpng2.c, which
+ * in turn is called by libpng after all of the pre-IDAT chunks have been
+ * read and processed--i.e., we now have enough info to finish initializing */
+
+static void rpng2_win_init()
+{
+    ulg i;
+    ulg rowbytes = rpng2_info.rowbytes;
+
+    Trace((stderr, "beginning rpng2_win_init()\n"))
+    Trace((stderr, "  rowbytes = %d\n", rpng2_info.rowbytes))
+    Trace((stderr, "  width  = %ld\n", rpng2_info.width))
+    Trace((stderr, "  height = %ld\n", rpng2_info.height))
+
+    /* Guard against integer overflow */
+    if (rpng2_info.height > ((size_t)(-1))/rowbytes) {
+        fprintf(stderr, PROGNAME ":  image_data buffer would be too large\n",
+        readpng2_cleanup(&rpng2_info);
+        return;
+    }
+
+    rpng2_info.image_data = (uch *)malloc(rowbytes * rpng2_info.height);
+    if (!rpng2_info.image_data) {
+        readpng2_cleanup(&rpng2_info);
+        return;
+    }
+
+    rpng2_info.row_pointers = (uch **)malloc(rpng2_info.height * sizeof(uch *));
+    if (!rpng2_info.row_pointers) {
+        free(rpng2_info.image_data);
+        rpng2_info.image_data = NULL;
+        readpng2_cleanup(&rpng2_info);
+        return;
+    }
+
+    for (i = 0;  i < rpng2_info.height;  ++i)
+        rpng2_info.row_pointers[i] = rpng2_info.image_data + i*rowbytes;
+
+/*---------------------------------------------------------------------------
+    Do the basic Windows initialization stuff, make the window, and fill it
+    with the user-specified, file-specified or default background color.
+  ---------------------------------------------------------------------------*/
+
+    if (rpng2_win_create_window()) {
+        readpng2_cleanup(&rpng2_info);
+        return;
+    }
+
+    rpng2_info.state = kWindowInit;
+}
+
+
+
+
+
+static int rpng2_win_create_window()
+{
+    uch bg_red   = rpng2_info.bg_red;
+    uch bg_green = rpng2_info.bg_green;
+    uch bg_blue  = rpng2_info.bg_blue;
+    uch *dest;
+    int extra_width, extra_height;
+    ulg i, j;
+    WNDCLASSEX wndclass;
+    RECT rect;
+
+
+/*---------------------------------------------------------------------------
+    Allocate memory for the display-specific version of the image (round up
+    to multiple of 4 for Windows DIB).
+  ---------------------------------------------------------------------------*/
+
+    wimage_rowbytes = ((3*rpng2_info.width + 3L) >> 2) << 2;
+
+    if (!(dib = (uch *)malloc(sizeof(BITMAPINFOHEADER) +
+                              wimage_rowbytes*rpng2_info.height)))
+    {
+        return 4;   /* fail */
+    }
+
+/*---------------------------------------------------------------------------
+    Initialize the DIB.  Negative height means to use top-down BMP ordering
+    (must be uncompressed, but that's what we want).  Bit count of 1, 4 or 8
+    implies a colormap of RGBX quads, but 24-bit BMPs just use B,G,R values
+    directly => wimage_data begins immediately after BMP header.
+  ---------------------------------------------------------------------------*/
+
+    memset(dib, 0, sizeof(BITMAPINFOHEADER));
+    bmih = (BITMAPINFOHEADER *)dib;
+    bmih->biSize = sizeof(BITMAPINFOHEADER);
+    bmih->biWidth = rpng2_info.width;
+    bmih->biHeight = -((long)rpng2_info.height);
+    bmih->biPlanes = 1;
+    bmih->biBitCount = 24;
+    bmih->biCompression = 0;
+    wimage_data = dib + sizeof(BITMAPINFOHEADER);
+
+/*---------------------------------------------------------------------------
+    Fill window with the specified background color (default is black), but
+    defer loading faked "background image" until window is displayed (may be
+    slow to compute).  Data are in BGR order.
+  ---------------------------------------------------------------------------*/
+
+    if (bg_image) {   /* just fill with black for now */
+        memset(wimage_data, 0, wimage_rowbytes*rpng2_info.height);
+    } else {
+        for (j = 0;  j < rpng2_info.height;  ++j) {
+            dest = wimage_data + j*wimage_rowbytes;
+            for (i = rpng2_info.width;  i > 0;  --i) {
+                *dest++ = bg_blue;
+                *dest++ = bg_green;
+                *dest++ = bg_red;
+            }
+        }
+    }
+
+/*---------------------------------------------------------------------------
+    Set the window parameters.
+  ---------------------------------------------------------------------------*/
+
+    memset(&wndclass, 0, sizeof(wndclass));
+
+    wndclass.cbSize = sizeof(wndclass);
+    wndclass.style = CS_HREDRAW | CS_VREDRAW;
+    wndclass.lpfnWndProc = rpng2_win_wndproc;
+    wndclass.hInstance = global_hInst;
+    wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
+    wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
+    wndclass.hbrBackground = (HBRUSH)GetStockObject(DKGRAY_BRUSH);
+    wndclass.lpszMenuName = NULL;
+    wndclass.lpszClassName = progname;
+    wndclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
+
+    RegisterClassEx(&wndclass);
+
+/*---------------------------------------------------------------------------
+    Finally, create the window.
+  ---------------------------------------------------------------------------*/
+
+    extra_width  = 2*(GetSystemMetrics(SM_CXBORDER) +
+                      GetSystemMetrics(SM_CXDLGFRAME));
+    extra_height = 2*(GetSystemMetrics(SM_CYBORDER) +
+                      GetSystemMetrics(SM_CYDLGFRAME)) +
+                      GetSystemMetrics(SM_CYCAPTION);
+
+    global_hwnd = CreateWindow(progname, titlebar, WS_OVERLAPPEDWINDOW,
+      CW_USEDEFAULT, CW_USEDEFAULT, rpng2_info.width+extra_width,
+      rpng2_info.height+extra_height, NULL, NULL, global_hInst, NULL);
+
+    ShowWindow(global_hwnd, global_showmode);
+    UpdateWindow(global_hwnd);
+
+/*---------------------------------------------------------------------------
+    Now compute the background image and display it.  If it fails (memory
+    allocation), revert to a plain background color.
+  ---------------------------------------------------------------------------*/
+
+    if (bg_image) {
+        static const char *msg = "Computing background image...";
+        int x, y, len = strlen(msg);
+        HDC hdc = GetDC(global_hwnd);
+        TEXTMETRIC tm;
+
+        GetTextMetrics(hdc, &tm);
+        x = (rpng2_info.width - len*tm.tmAveCharWidth)/2;
+        y = (rpng2_info.height - tm.tmHeight)/2;
+        SetBkMode(hdc, TRANSPARENT);
+        SetTextColor(hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
+        /* this can still begin out of bounds even if x is positive (???): */
+        TextOut(hdc, ((x < 0)? 0 : x), ((y < 0)? 0 : y), msg, len);
+        ReleaseDC(global_hwnd, hdc);
+
+        rpng2_win_load_bg_image();   /* resets bg_image if fails */
+    }
+
+    if (!bg_image) {
+        for (j = 0;  j < rpng2_info.height;  ++j) {
+            dest = wimage_data + j*wimage_rowbytes;
+            for (i = rpng2_info.width;  i > 0;  --i) {
+                *dest++ = bg_blue;
+                *dest++ = bg_green;
+                *dest++ = bg_red;
+            }
+        }
+    }
+
+    rect.left = 0L;
+    rect.top = 0L;
+    rect.right = (LONG)rpng2_info.width;       /* possibly off by one? */
+    rect.bottom = (LONG)rpng2_info.height;     /* possibly off by one? */
+    InvalidateRect(global_hwnd, &rect, FALSE);
+    UpdateWindow(global_hwnd);                 /* similar to XFlush() */
+
+    return 0;
+
+} /* end function rpng2_win_create_window() */
+
+
+
+
+
+static int rpng2_win_load_bg_image()
+{
+    uch *src, *dest;
+    uch r1, r2, g1, g2, b1, b2;
+    uch r1_inv, r2_inv, g1_inv, g2_inv, b1_inv, b2_inv;
+    int k, hmax, max;
+    int xidx, yidx, yidx_max = (bgscale-1);
+    int even_odd_vert, even_odd_horiz, even_odd;
+    int invert_gradient2 = (bg[pat].type & 0x08);
+    int invert_column;
+    ulg i, row;
+
+/*---------------------------------------------------------------------------
+    Allocate buffer for fake background image to be used with transparent
+    images; if this fails, revert to plain background color.
+  ---------------------------------------------------------------------------*/
+
+    bg_rowbytes = 3 * rpng2_info.width;
+    bg_data = (uch *)malloc(bg_rowbytes * rpng2_info.height);
+    if (!bg_data) {
+        fprintf(stderr, PROGNAME
+          ":  unable to allocate memory for background image\n");
+        bg_image = 0;
+        return 1;
+    }
+
+/*---------------------------------------------------------------------------
+    Vertical gradients (ramps) in NxN squares, alternating direction and
+    colors (N == bgscale).
+  ---------------------------------------------------------------------------*/
+
+    if ((bg[pat].type & 0x07) == 0) {
+        uch r1_min  = rgb[bg[pat].rgb1_min].r;
+        uch g1_min  = rgb[bg[pat].rgb1_min].g;
+        uch b1_min  = rgb[bg[pat].rgb1_min].b;
+        uch r2_min  = rgb[bg[pat].rgb2_min].r;
+        uch g2_min  = rgb[bg[pat].rgb2_min].g;
+        uch b2_min  = rgb[bg[pat].rgb2_min].b;
+        int r1_diff = rgb[bg[pat].rgb1_max].r - r1_min;
+        int g1_diff = rgb[bg[pat].rgb1_max].g - g1_min;
+        int b1_diff = rgb[bg[pat].rgb1_max].b - b1_min;
+        int r2_diff = rgb[bg[pat].rgb2_max].r - r2_min;
+        int g2_diff = rgb[bg[pat].rgb2_max].g - g2_min;
+        int b2_diff = rgb[bg[pat].rgb2_max].b - b2_min;
+
+        for (row = 0;  row < rpng2_info.height;  ++row) {
+            yidx = row % bgscale;
+            even_odd_vert = (row / bgscale) & 1;
+
+            r1 = r1_min + (r1_diff * yidx) / yidx_max;
+            g1 = g1_min + (g1_diff * yidx) / yidx_max;
+            b1 = b1_min + (b1_diff * yidx) / yidx_max;
+            r1_inv = r1_min + (r1_diff * (yidx_max-yidx)) / yidx_max;
+            g1_inv = g1_min + (g1_diff * (yidx_max-yidx)) / yidx_max;
+            b1_inv = b1_min + (b1_diff * (yidx_max-yidx)) / yidx_max;
+
+            r2 = r2_min + (r2_diff * yidx) / yidx_max;
+            g2 = g2_min + (g2_diff * yidx) / yidx_max;
+            b2 = b2_min + (b2_diff * yidx) / yidx_max;
+            r2_inv = r2_min + (r2_diff * (yidx_max-yidx)) / yidx_max;
+            g2_inv = g2_min + (g2_diff * (yidx_max-yidx)) / yidx_max;
+            b2_inv = b2_min + (b2_diff * (yidx_max-yidx)) / yidx_max;
+
+            dest = bg_data + row*bg_rowbytes;
+            for (i = 0;  i < rpng2_info.width;  ++i) {
+                even_odd_horiz = (i / bgscale) & 1;
+                even_odd = even_odd_vert ^ even_odd_horiz;
+                invert_column =
+                  (even_odd_horiz && (bg[pat].type & 0x10));
+                if (even_odd == 0) {         /* gradient #1 */
+                    if (invert_column) {
+                        *dest++ = r1_inv;
+                        *dest++ = g1_inv;
+                        *dest++ = b1_inv;
+                    } else {
+                        *dest++ = r1;
+                        *dest++ = g1;
+                        *dest++ = b1;
+                    }
+                } else {                     /* gradient #2 */
+                    if ((invert_column && invert_gradient2) ||
+                        (!invert_column && !invert_gradient2))
+                    {
+                        *dest++ = r2;        /* not inverted or */
+                        *dest++ = g2;        /*  doubly inverted */
+                        *dest++ = b2;
+                    } else {
+                        *dest++ = r2_inv;
+                        *dest++ = g2_inv;    /* singly inverted */
+                        *dest++ = b2_inv;
+                    }
+                }
+            }
+        }
+
+/*---------------------------------------------------------------------------
+    Soft gradient-diamonds with scale = bgscale.  Code contributed by Adam
+    M. Costello.
+  ---------------------------------------------------------------------------*/
+
+    } else if ((bg[pat].type & 0x07) == 1) {
+
+        hmax = (bgscale-1)/2;   /* half the max weight of a color */
+        max = 2*hmax;           /* the max weight of a color */
+
+        r1 = rgb[bg[pat].rgb1_max].r;
+        g1 = rgb[bg[pat].rgb1_max].g;
+        b1 = rgb[bg[pat].rgb1_max].b;
+        r2 = rgb[bg[pat].rgb2_max].r;
+        g2 = rgb[bg[pat].rgb2_max].g;
+        b2 = rgb[bg[pat].rgb2_max].b;
+
+        for (row = 0;  row < rpng2_info.height;  ++row) {
+            yidx = row % bgscale;
+            if (yidx > hmax)
+                yidx = bgscale-1 - yidx;
+            dest = bg_data + row*bg_rowbytes;
+            for (i = 0;  i < rpng2_info.width;  ++i) {
+                xidx = i % bgscale;
+                if (xidx > hmax)
+                    xidx = bgscale-1 - xidx;
+                k = xidx + yidx;
+                *dest++ = (k*r1 + (max-k)*r2) / max;
+                *dest++ = (k*g1 + (max-k)*g2) / max;
+                *dest++ = (k*b1 + (max-k)*b2) / max;
+            }
+        }
+
+/*---------------------------------------------------------------------------
+    Radial "starburst" with azimuthal sinusoids; [eventually number of sinu-
+    soids will equal bgscale?].  This one is slow but very cool.  Code con-
+    tributed by Pieter S. van der Meulen (originally in Smalltalk).
+  ---------------------------------------------------------------------------*/
+
+    } else if ((bg[pat].type & 0x07) == 2) {
+        uch ch;
+        int ii, x, y, hw, hh, grayspot;
+        double freq, rotate, saturate, gray, intensity;
+        double angle=0.0, aoffset=0.0, maxDist, dist;
+        double red=0.0, green=0.0, blue=0.0, hue, s, v, f, p, q, t;
+
+        fprintf(stderr, "%s:  computing radial background...",
+          PROGNAME);
+        fflush(stderr);
+
+        hh = rpng2_info.height / 2;
+        hw = rpng2_info.width / 2;
+
+        /* variables for radial waves:
+         *   aoffset:  number of degrees to rotate hue [CURRENTLY NOT USED]
+         *   freq:  number of color beams originating from the center
+         *   grayspot:  size of the graying center area (anti-alias)
+         *   rotate:  rotation of the beams as a function of radius
+         *   saturate:  saturation of beams' shape azimuthally
+         */
+        angle = CLIP(angle, 0.0, 360.0);
+        grayspot = CLIP(bg[pat].bg_gray, 1, (hh + hw));
+        freq = MAX((double)bg[pat].bg_freq, 0.0);
+        saturate = (double)bg[pat].bg_bsat * 0.1;
+        rotate = (double)bg[pat].bg_brot * 0.1;
+        gray = 0.0;
+        intensity = 0.0;
+        maxDist = (double)((hw*hw) + (hh*hh));
+
+        for (row = 0;  row < rpng2_info.height;  ++row) {
+            y = row - hh;
+            dest = bg_data + row*bg_rowbytes;
+            for (i = 0;  i < rpng2_info.width;  ++i) {
+                x = i - hw;
+                angle = (x == 0)? PI_2 : atan((double)y / (double)x);
+                gray = (double)MAX(ABS(y), ABS(x)) / grayspot;
+                gray = MIN(1.0, gray);
+                dist = (double)((x*x) + (y*y)) / maxDist;
+                intensity = cos((angle+(rotate*dist*PI)) * freq) *
+                  gray * saturate;
+                intensity = (MAX(MIN(intensity,1.0),-1.0) + 1.0) * 0.5;
+                hue = (angle + PI) * INV_PI_360 + aoffset;
+                s = gray * ((double)(ABS(x)+ABS(y)) / (double)(hw + hh));
+                s = MIN(MAX(s,0.0), 1.0);
+                v = MIN(MAX(intensity,0.0), 1.0);
+
+                if (s == 0.0) {
+                    ch = (uch)(v * 255.0);
+                    *dest++ = ch;
+                    *dest++ = ch;
+                    *dest++ = ch;
+                } else {
+                    if ((hue < 0.0) || (hue >= 360.0))
+                        hue -= (((int)(hue / 360.0)) * 360.0);
+                    hue /= 60.0;
+                    ii = (int)hue;
+                    f = hue - (double)ii;
+                    p = (1.0 - s) * v;
+                    q = (1.0 - (s * f)) * v;
+                    t = (1.0 - (s * (1.0 - f))) * v;
+                    if      (ii == 0) { red = v; green = t; blue = p; }
+                    else if (ii == 1) { red = q; green = v; blue = p; }
+                    else if (ii == 2) { red = p; green = v; blue = t; }
+                    else if (ii == 3) { red = p; green = q; blue = v; }
+                    else if (ii == 4) { red = t; green = p; blue = v; }
+                    else if (ii == 5) { red = v; green = p; blue = q; }
+                    *dest++ = (uch)(red * 255.0);
+                    *dest++ = (uch)(green * 255.0);
+                    *dest++ = (uch)(blue * 255.0);
+                }
+            }
+        }
+        fprintf(stderr, "done.\n");
+        fflush(stderr);
+    }
+
+/*---------------------------------------------------------------------------
+    Blast background image to display buffer before beginning PNG decode;
+    calling function will handle invalidation and UpdateWindow() call.
+  ---------------------------------------------------------------------------*/
+
+    for (row = 0;  row < rpng2_info.height;  ++row) {
+        src = bg_data + row*bg_rowbytes;
+        dest = wimage_data + row*wimage_rowbytes;
+        for (i = rpng2_info.width;  i > 0;  --i) {
+            r1 = *src++;
+            g1 = *src++;
+            b1 = *src++;
+            *dest++ = b1;
+            *dest++ = g1;   /* note reverse order */
+            *dest++ = r1;
+        }
+    }
+
+    return 0;
+
+} /* end function rpng2_win_load_bg_image() */
+
+
+
+
+
+static void rpng2_win_display_row(ulg row)
+{
+    uch bg_red   = rpng2_info.bg_red;
+    uch bg_green = rpng2_info.bg_green;
+    uch bg_blue  = rpng2_info.bg_blue;
+    uch *src, *src2=NULL, *dest;
+    uch r, g, b, a;
+    ulg i;
+    static int rows=0;
+    static ulg firstrow;
+
+/*---------------------------------------------------------------------------
+    rows and firstrow simply track how many rows (and which ones) have not
+    yet been displayed; alternatively, we could call InvalidateRect() for
+    every row and not bother with the records-keeping.
+  ---------------------------------------------------------------------------*/
+
+    Trace((stderr, "beginning rpng2_win_display_row()\n"))
+
+    if (rows == 0)
+        firstrow = row;   /* first row not yet displayed */
+
+    ++rows;   /* count of rows received but not yet displayed */
+
+/*---------------------------------------------------------------------------
+    Aside from the use of the rpng2_info struct and the lack of an outer
+    loop (over rows), this routine is identical to rpng_win_display_image()
+    in the non-progressive version of the program.
+  ---------------------------------------------------------------------------*/
+
+    src = rpng2_info.image_data + row*rpng2_info.rowbytes;
+    if (bg_image)
+        src2 = bg_data + row*bg_rowbytes;
+    dest = wimage_data + row*wimage_rowbytes;
+
+    if (rpng2_info.channels == 3) {
+        for (i = rpng2_info.width;  i > 0;  --i) {
+            r = *src++;
+            g = *src++;
+            b = *src++;
+            *dest++ = b;
+            *dest++ = g;   /* note reverse order */
+            *dest++ = r;
+        }
+    } else /* if (rpng2_info.channels == 4) */ {
+        for (i = rpng2_info.width;  i > 0;  --i) {
+            r = *src++;
+            g = *src++;
+            b = *src++;
+            a = *src++;
+            if (bg_image) {
+                bg_red   = *src2++;
+                bg_green = *src2++;
+                bg_blue  = *src2++;
+            }
+            if (a == 255) {
+                *dest++ = b;
+                *dest++ = g;
+                *dest++ = r;
+            } else if (a == 0) {
+                *dest++ = bg_blue;
+                *dest++ = bg_green;
+                *dest++ = bg_red;
+            } else {
+                /* this macro (copied from png.h) composites the
+                 * foreground and background values and puts the
+                 * result into the first argument; there are no
+                 * side effects with the first argument */
+                alpha_composite(*dest++, b, a, bg_blue);
+                alpha_composite(*dest++, g, a, bg_green);
+                alpha_composite(*dest++, r, a, bg_red);
+            }
+        }
+    }
+
+/*---------------------------------------------------------------------------
+    Display after every 16 rows or when on last row.  (Region may include
+    previously displayed lines due to interlacing--i.e., not contiguous.)
+  ---------------------------------------------------------------------------*/
+
+    if ((rows & 0xf) == 0 || row == rpng2_info.height-1) {
+        RECT rect;
+
+        rect.left = 0L;
+        rect.top = (LONG)firstrow;
+        rect.right = (LONG)rpng2_info.width;       /* possibly off by one? */
+        rect.bottom = (LONG)row + 1L;              /* possibly off by one? */
+        InvalidateRect(global_hwnd, &rect, FALSE);
+        UpdateWindow(global_hwnd);                 /* similar to XFlush() */
+        rows = 0;
+    }
+
+} /* end function rpng2_win_display_row() */
+
+
+
+
+
+static void rpng2_win_finish_display()
+{
+    Trace((stderr, "beginning rpng2_win_finish_display()\n"))
+
+    /* last row has already been displayed by rpng2_win_display_row(), so
+     * we have nothing to do here except set a flag and let the user know
+     * that the image is done */
+
+    rpng2_info.state = kDone;
+    printf(
+#ifndef __CYGWIN__
+      "Done.  Press Q, Esc or mouse button 1 (within image window) to quit.\n"
+#else
+      "Done.  Press mouse button 1 (within image window) to quit.\n"
+#endif
+    );
+    fflush(stdout);
+}
+
+
+
+
+
+static void rpng2_win_cleanup()
+{
+    if (bg_image && bg_data) {
+        free(bg_data);
+        bg_data = NULL;
+    }
+
+    if (rpng2_info.image_data) {
+        free(rpng2_info.image_data);
+        rpng2_info.image_data = NULL;
+    }
+
+    if (rpng2_info.row_pointers) {
+        free(rpng2_info.row_pointers);
+        rpng2_info.row_pointers = NULL;
+    }
+
+    if (dib) {
+        free(dib);
+        dib = NULL;
+    }
+}
+
+
+
+
+
+LRESULT CALLBACK rpng2_win_wndproc(HWND hwnd, UINT iMsg, WPARAM wP, LPARAM lP)
+{
+    HDC         hdc;
+    PAINTSTRUCT ps;
+    int rc;
+
+    switch (iMsg) {
+        case WM_CREATE:
+            /* one-time processing here, if any */
+            return 0;
+
+        case WM_PAINT:
+            hdc = BeginPaint(hwnd, &ps);
+            rc = StretchDIBits(hdc, 0, 0, rpng2_info.width, rpng2_info.height,
+                                    0, 0, rpng2_info.width, rpng2_info.height,
+                                    wimage_data, (BITMAPINFO *)bmih,
+                                    0, SRCCOPY);
+            EndPaint(hwnd, &ps);
+            return 0;
+
+        /* wait for the user to tell us when to quit */
+        case WM_CHAR:
+            switch (wP) {       /* only need one, so ignore repeat count */
+                case 'q':
+                case 'Q':
+                case 0x1B:      /* Esc key */
+                    PostQuitMessage(0);
+            }
+            return 0;
+
+        case WM_LBUTTONDOWN:    /* another way of quitting */
+        case WM_DESTROY:
+            PostQuitMessage(0);
+            return 0;
+    }
+
+    return DefWindowProc(hwnd, iMsg, wP, lP);
+}
diff --git a/Engine/lib/lpng/contrib/gregbook/rpng2-x.c b/Engine/lib/lpng/contrib/gregbook/rpng2-x.c
new file mode 100644
index 000000000..af944c0f2
--- /dev/null
+++ b/Engine/lib/lpng/contrib/gregbook/rpng2-x.c
@@ -0,0 +1,2143 @@
+/*---------------------------------------------------------------------------
+
+   rpng2 - progressive-model PNG display program                  rpng2-x.c
+
+   This program decodes and displays PNG files progressively, as if it were
+   a web browser (though the front end is only set up to read from files).
+   It supports gamma correction, user-specified background colors, and user-
+   specified background patterns (for transparent images).  This version is
+   for the X Window System (tested by the author under Unix and by Martin
+   Zinser under OpenVMS; may work under OS/2 with a little tweaking).
+
+   Thanks to Adam Costello and Pieter S. van der Meulen for the "diamond"
+   and "radial waves" patterns, respectively.
+
+   to do (someday, maybe):
+    - fix expose/redraw code:  don't draw entire row if only part exposed
+    - 8-bit (colormapped) X support
+    - finish resizable checkerboard-gradient (sizes 4-128?)
+    - use %.1023s to simplify truncation of title-bar string?
+
+  ---------------------------------------------------------------------------
+
+   Changelog:
+    - 1.01:  initial public release
+    - 1.02:  modified to allow abbreviated options; fixed char/uchar mismatch
+    - 1.10:  added support for non-default visuals; fixed X pixel-conversion
+    - 1.11:  added -usleep option for demos; fixed command-line parsing bug
+    - 1.12:  added -pause option for demos and testing
+    - 1.20:  added runtime MMX-enabling/disabling and new -mmx* options
+    - 1.21:  fixed some small X memory leaks (thanks to François Petitjean)
+    - 1.22:  fixed XFreeGC() crash bug (thanks to Patrick Welche)
+    - 1.23:  added -bgpat 0 mode (std white/gray checkerboard, 8x8 squares)
+    - 1.30:  added -loop option for -bgpat (ifdef FEATURE_LOOP); fixed bpp =
+              24; added support for X resources (thanks to Gerhard Niklasch)
+    - 1.31:  added code to skip unused chunks (thanks to Glenn Randers-Pehrson)
+    - 1.32:  added AMD64/EM64T support (__x86_64__); added basic expose/redraw
+              handling
+    - 2.00:  dual-licensed (added GNU GPL)
+    - 2.01:  fixed 64-bit typo in readpng2.c; fixed -pause usage description
+    - 2.02:  fixed improper display of usage screen on PNG error(s); fixed
+              unexpected-EOF and file-read-error cases; fixed Trace() cut-and-
+              paste bugs
+    - 2.03:  deleted runtime MMX-enabling/disabling and obsolete -mmx* options
+    - 2.04:  Added "void(foo);" statements to quiet pedantic compiler warnings
+             about unused variables (GR-P)
+    - 2.05:  Use nanosleep() instead of usleep(), which is deprecated (GR-P).
+    - 2.06:  check for integer overflow (Glenn R-P)
+  ---------------------------------------------------------------------------
+
+      Copyright (c) 1998-2010, 2014-2015, 2017 Greg Roelofs.  All rights
+      reserved.
+
+      This software is provided "as is," without warranty of any kind,
+      express or implied.  In no event shall the author or contributors
+      be held liable for any damages arising in any way from the use of
+      this software.
+
+      The contents of this file are DUAL-LICENSED.  You may modify and/or
+      redistribute this software according to the terms of one of the
+      following two licenses (at your option):
+
+
+      LICENSE 1 ("BSD-like with advertising clause"):
+
+      Permission is granted to anyone to use this software for any purpose,
+      including commercial applications, and to alter it and redistribute
+      it freely, subject to the following restrictions:
+
+      1. Redistributions of source code must retain the above copyright
+         notice, disclaimer, and this list of conditions.
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, disclaimer, and this list of conditions in the documenta-
+         tion and/or other materials provided with the distribution.
+      3. All advertising materials mentioning features or use of this
+         software must display the following acknowledgment:
+
+            This product includes software developed by Greg Roelofs
+            and contributors for the book, "PNG: The Definitive Guide,"
+            published by O'Reilly and Associates.
+
+
+      LICENSE 2 (GNU GPL v2 or later):
+
+      This program is free software; you can redistribute it and/or modify
+      it under the terms of the GNU General Public License as published by
+      the Free Software Foundation; either version 2 of the License, or
+      (at your option) any later version.
+
+      This program is distributed in the hope that it will be useful,
+      but WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+      GNU General Public License for more details.
+
+      You should have received a copy of the GNU General Public License
+      along with this program; if not, write to the Free Software Foundation,
+      Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  ---------------------------------------------------------------------------*/
+
+#define PROGNAME  "rpng2-x"
+#define LONGNAME  "Progressive PNG Viewer for X"
+#define VERSION   "2.04 of 15 June 2014"
+#define RESNAME   "rpng2"       /* our X resource application name */
+#define RESCLASS  "Rpng"       /* our X resource class name */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+#include <setjmp.h>       /* for jmpbuf declaration in readpng2.h */
+#include <time.h>
+#include <math.h>         /* only for PvdM background code */
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xos.h>
+#include <X11/keysym.h>   /* defines XK_* macros */
+
+#if _POSIX_C_SOURCE >= 199309L /* have nanosleep() */
+# undef usleep
+# define usleep(usec) {        \
+   struct timespec ts;         \
+   ts.tv_sec = 0;              \
+   ts.tv_nsec = (usec) * 1000; \
+   nanosleep(&ts, NULL); }
+#  endif
+
+#ifndef usleep /* have neither nanosleep() nor usleep() */
+#  define usleep(x) sleep(((x)+499999)/1000000)
+#endif
+
+#ifdef VMS
+#  include <unistd.h>
+#endif
+
+/* all for PvdM background code: */
+#ifndef PI
+#  define PI             3.141592653589793238
+#endif
+#define PI_2             (PI*0.5)
+#define INV_PI_360       (360.0 / PI)
+#define MAX(a,b)         (a>b?a:b)
+#define MIN(a,b)         (a<b?a:b)
+#define CLIP(a,min,max)  MAX(min,MIN((a),max))
+#define ABS(a)           ((a)<0?-(a):(a))
+#define CLIP8P(c)        MAX(0,(MIN((c),255)))   /* 8-bit pos. integer (uch) */
+#define ROUNDF(f)        ((int)(f + 0.5))
+
+#define QUIT(e,k) ((e.type == ButtonPress && e.xbutton.button == Button1) ||  \
+                  (e.type == KeyPress &&   /*  v--- or 1 for shifted keys */  \
+                  ((k = XLookupKeysym(&e.xkey, 0)) == XK_q || k == XK_Escape)))
+
+#define NO_24BIT_MASKS /* undef case not fully written--only for redisplay() */
+
+#define rgb1_max   bg_freq
+#define rgb1_min   bg_gray
+#define rgb2_max   bg_bsat
+#define rgb2_min   bg_brot
+
+/* #define DEBUG */     /* this enables the Trace() macros */
+
+#include "readpng2.h"   /* typedefs, common macros, readpng2 prototypes */
+
+
+/* could just include png.h, but this macro is the only thing we need
+ * (name and typedefs changed to local versions); note that side effects
+ * only happen with alpha (which could easily be avoided with
+ * "ush acopy = (alpha);") */
+
+#define alpha_composite(composite, fg, alpha, bg) {               \
+    ush temp = ((ush)(fg)*(ush)(alpha) +                          \
+                (ush)(bg)*(ush)(255 - (ush)(alpha)) + (ush)128);  \
+    (composite) = (uch)((temp + (temp >> 8)) >> 8);               \
+}
+
+
+#define INBUFSIZE 4096   /* with pseudo-timing on (1 sec delay/block), this
+                          *  block size corresponds roughly to a download
+                          *  speed 10% faster than theoretical 33.6K maximum
+                          *  (assuming 8 data bits, 1 stop bit and no other
+                          *  overhead) */
+
+/* local prototypes */
+static void rpng2_x_init (void);
+static int  rpng2_x_create_window (void);
+static int  rpng2_x_load_bg_image (void);
+static void rpng2_x_display_row (ulg row);
+static void rpng2_x_finish_display (void);
+static void rpng2_x_redisplay_image (ulg startcol, ulg startrow,
+                                     ulg width, ulg height);
+#ifdef FEATURE_LOOP
+static void rpng2_x_reload_bg_image (void);
+static int  is_number (char *p);
+#endif
+static void rpng2_x_cleanup (void);
+static int  rpng2_x_msb (ulg u32val);
+
+
+static char titlebar[1024], *window_name = titlebar;
+static char *appname = LONGNAME;
+static char *icon_name = PROGNAME;
+static char *res_name = RESNAME;
+static char *res_class = RESCLASS;
+static char *filename;
+static FILE *infile;
+
+static mainprog_info rpng2_info;
+
+static uch inbuf[INBUFSIZE];
+static int incount;
+
+static int pat = 6;        /* must be less than num_bgpat */
+static int bg_image = 0;
+static int bgscale, bgscale_default = 16;
+static ulg bg_rowbytes;
+static uch *bg_data;
+
+int pause_after_pass = FALSE;
+int demo_timing = FALSE;
+ulg usleep_duration = 0L;
+
+static struct rgb_color {
+    uch r, g, b;
+} rgb[] = {
+    {  0,   0,   0},    /*  0:  black */
+    {255, 255, 255},    /*  1:  white */
+    {173, 132,  57},    /*  2:  tan */
+    { 64, 132,   0},    /*  3:  medium green */
+    {189, 117,   1},    /*  4:  gold */
+    {253, 249,   1},    /*  5:  yellow */
+    {  0,   0, 255},    /*  6:  blue */
+    {  0,   0, 120},    /*  7:  medium blue */
+    {255,   0, 255},    /*  8:  magenta */
+    { 64,   0,  64},    /*  9:  dark magenta */
+    {255,   0,   0},    /* 10:  red */
+    { 64,   0,   0},    /* 11:  dark red */
+    {255, 127,   0},    /* 12:  orange */
+    {192,  96,   0},    /* 13:  darker orange */
+    { 24,  60,   0},    /* 14:  dark green-yellow */
+    { 85, 125, 200},    /* 15:  ice blue */
+    {192, 192, 192}     /* 16:  Netscape/Mosaic gray */
+};
+/* not used for now, but should be for error-checking:
+static int num_rgb = sizeof(rgb) / sizeof(struct rgb_color);
+ */
+
+/*
+    This whole struct is a fairly cheesy way to keep the number of
+    command-line options to a minimum.  The radial-waves background
+    type is a particularly poor fit to the integer elements of the
+    struct...but a few macros and a little fixed-point math will do
+    wonders for ya.
+
+    type bits:
+       F E D C B A 9 8 7 6 5 4 3 2 1 0
+                             | | | | |
+                             | | +-+-+-- 0 = sharp-edged checkerboard
+                             | |         1 = soft diamonds
+                             | |         2 = radial waves
+                             | |       3-7 = undefined
+                             | +-- gradient #2 inverted?
+                             +-- alternating columns inverted?
+ */
+static struct background_pattern {
+    ush type;
+    int rgb1_max, rgb1_min;     /* or bg_freq, bg_gray */
+    int rgb2_max, rgb2_min;     /* or bg_bsat, bg_brot (both scaled by 10)*/
+} bg[] = {
+    {0,     1,1, 16,16},        /* checkered:  white vs. light gray (basic) */
+    {0+8,   2,0,  1,15},        /* checkered:  tan/black vs. white/ice blue */
+    {0+24,  2,0,  1,0},         /* checkered:  tan/black vs. white/black */
+    {0+8,   4,5,  0,2},         /* checkered:  gold/yellow vs. black/tan */
+    {0+8,   4,5,  0,6},         /* checkered:  gold/yellow vs. black/blue */
+    {0,     7,0,  8,9},         /* checkered:  deep blue/black vs. magenta */
+    {0+8,  13,0,  5,14},        /* checkered:  orange/black vs. yellow */
+    {0+8,  12,0, 10,11},        /* checkered:  orange/black vs. red */
+    {1,     7,0,  8,0},         /* diamonds:  deep blue/black vs. magenta */
+    {1,    12,0, 11,0},         /* diamonds:  orange vs. dark red */
+    {1,    10,0,  7,0},         /* diamonds:  red vs. medium blue */
+    {1,     4,0,  5,0},         /* diamonds:  gold vs. yellow */
+    {1,     3,0,  0,0},         /* diamonds:  medium green vs. black */
+    {2,    16, 100,  20,   0},  /* radial:  ~hard radial color-beams */
+    {2,    18, 100,  10,   2},  /* radial:  soft, curved radial color-beams */
+    {2,    16, 256, 100, 250},  /* radial:  very tight spiral */
+    {2, 10000, 256,  11,   0}   /* radial:  dipole-moire' (almost fractal) */
+};
+static int num_bgpat = sizeof(bg) / sizeof(struct background_pattern);
+
+
+/* X-specific variables */
+static char *displayname;
+static XImage *ximage;
+static Display *display;
+static int depth;
+static Visual *visual;
+static XVisualInfo *visual_list;
+static int RShift, GShift, BShift;
+static ulg RMask, GMask, BMask;
+static Window window;
+static GC gc;
+static Colormap colormap;
+
+static int have_nondefault_visual = FALSE;
+static int have_colormap = FALSE;
+static int have_window = FALSE;
+static int have_gc = FALSE;
+
+
+
+
+int main(int argc, char **argv)
+{
+#ifdef sgi
+    char tmpline[80];
+#endif
+    char *p, *bgstr = NULL;
+    int rc, alen, flen;
+    int error = 0;
+    int timing = FALSE;
+    int have_bg = FALSE;
+#ifdef FEATURE_LOOP
+    int loop = FALSE;
+    long loop_interval = -1;            /* seconds (100,000 max) */
+#endif
+    double LUT_exponent;                /* just the lookup table */
+    double CRT_exponent = 2.2;          /* just the monitor */
+    double default_display_exponent;    /* whole display system */
+    XEvent e;
+    KeySym k;
+
+
+    /* First initialize a few things, just to be sure--memset takes care of
+     * default background color (black), booleans (FALSE), pointers (NULL),
+     * etc. */
+
+    displayname = (char *)NULL;
+    filename = (char *)NULL;
+    memset(&rpng2_info, 0, sizeof(mainprog_info));
+
+
+    /* Set the default value for our display-system exponent, i.e., the
+     * product of the CRT exponent and the exponent corresponding to
+     * the frame-buffer's lookup table (LUT), if any.  This is not an
+     * exhaustive list of LUT values (e.g., OpenStep has a lot of weird
+     * ones), but it should cover 99% of the current possibilities. */
+
+#if defined(NeXT)
+    /* third-party utilities can modify the default LUT exponent */
+    LUT_exponent = 1.0 / 2.2;
+    /*
+    if (some_next_function_that_returns_gamma(&next_gamma))
+        LUT_exponent = 1.0 / next_gamma;
+     */
+#elif defined(sgi)
+    LUT_exponent = 1.0 / 1.7;
+    /* there doesn't seem to be any documented function to
+     * get the "gamma" value, so we do it the hard way */
+    infile = fopen("/etc/config/system.glGammaVal", "r");
+    if (infile) {
+        double sgi_gamma;
+
+        fgets(tmpline, 80, infile);
+        fclose(infile);
+        sgi_gamma = atof(tmpline);
+        if (sgi_gamma > 0.0)
+            LUT_exponent = 1.0 / sgi_gamma;
+    }
+#elif defined(Macintosh)
+    LUT_exponent = 1.8 / 2.61;
+    /*
+    if (some_mac_function_that_returns_gamma(&mac_gamma))
+        LUT_exponent = mac_gamma / 2.61;
+     */
+#else
+    LUT_exponent = 1.0;   /* assume no LUT:  most PCs */
+#endif
+
+    /* the defaults above give 1.0, 1.3, 1.5 and 2.2, respectively: */
+    default_display_exponent = LUT_exponent * CRT_exponent;
+
+
+    /* If the user has set the SCREEN_GAMMA environment variable as suggested
+     * (somewhat imprecisely) in the libpng documentation, use that; otherwise
+     * use the default value we just calculated.  Either way, the user may
+     * override this via a command-line option. */
+
+    if ((p = getenv("SCREEN_GAMMA")) != NULL)
+        rpng2_info.display_exponent = atof(p);
+    else
+        rpng2_info.display_exponent = default_display_exponent;
+
+
+    /* Now parse the command line for options and the PNG filename. */
+
+    while (*++argv && !error) {
+        if (!strncmp(*argv, "-display", 2)) {
+            if (!*++argv)
+                ++error;
+            else
+                displayname = *argv;
+        } else if (!strncmp(*argv, "-gamma", 2)) {
+            if (!*++argv)
+                ++error;
+            else {
+                rpng2_info.display_exponent = atof(*argv);
+                if (rpng2_info.display_exponent <= 0.0)
+                    ++error;
+            }
+        } else if (!strncmp(*argv, "-bgcolor", 4)) {
+            if (!*++argv)
+                ++error;
+            else {
+                bgstr = *argv;
+                if (strlen(bgstr) != 7 || bgstr[0] != '#')
+                    ++error;
+                else {
+                    have_bg = TRUE;
+                    bg_image = FALSE;
+                }
+            }
+        } else if (!strncmp(*argv, "-bgpat", 4)) {
+            if (!*++argv)
+                ++error;
+            else {
+                pat = atoi(*argv);
+                if (pat >= 0 && pat < num_bgpat) {
+                    bg_image = TRUE;
+                    have_bg = FALSE;
+                } else
+                    ++error;
+            }
+        } else if (!strncmp(*argv, "-usleep", 2)) {
+            if (!*++argv)
+                ++error;
+            else {
+                usleep_duration = (ulg)atol(*argv);
+                demo_timing = TRUE;
+            }
+        } else if (!strncmp(*argv, "-pause", 2)) {
+            pause_after_pass = TRUE;
+        } else if (!strncmp(*argv, "-timing", 2)) {
+            timing = TRUE;
+#ifdef FEATURE_LOOP
+        } else if (!strncmp(*argv, "-loop", 2)) {
+            loop = TRUE;
+            if (!argv[1] || !is_number(argv[1]))
+                loop_interval = 2;
+            else {
+                ++argv;
+                loop_interval = atol(*argv);
+                if (loop_interval < 0)
+                    loop_interval = 2;
+                else if (loop_interval > 100000)   /* bit more than one day */
+                    loop_interval = 100000;
+            }
+#endif
+        } else {
+            if (**argv != '-') {
+                filename = *argv;
+                if (argv[1])   /* shouldn't be any more args after filename */
+                    ++error;
+            } else
+                ++error;   /* not expecting any other options */
+        }
+    }
+
+    if (!filename)
+        ++error;
+
+
+    /* print usage screen if any errors up to this point */
+
+    if (error) {
+        fprintf(stderr, "\n%s %s:  %s\n\n", PROGNAME, VERSION, appname);
+        readpng2_version_info();
+        fprintf(stderr, "\n"
+          "Usage:   ");
+        fprintf(stderr,
+          "%s [-display xdpy] [-gamma exp] [-bgcolor bg | -bgpat pat]\n"
+          "        %*s [-usleep dur | -timing] [-pause]\n",
+          PROGNAME, (int)strlen(PROGNAME), " ");
+        fprintf(stderr,
+#ifdef FEATURE_LOOP
+          "        [-loop [sec]]"
+#endif
+          " file.png\n\n");
+        fprintf(stderr,
+          "    xdpy\tname of the target X display (e.g., ``hostname:0'')\n"
+          "    exp \ttransfer-function exponent (``gamma'') of the display\n"
+          "\t\t  system in floating-point format (e.g., ``%.1f''); equal\n"
+          "\t\t  to the product of the lookup-table exponent (varies)\n",
+          default_display_exponent);
+        fprintf(stderr,
+          "\t\t  and the CRT exponent (usually 2.2); must be positive\n"
+          "    bg  \tdesired background color in 7-character hex RGB format\n"
+          "\t\t  (e.g., ``#ff7700'' for orange:  same as HTML colors);\n"
+          "\t\t  used with transparent images; overrides -bgpat\n"
+          "    pat \tdesired background pattern number (0-%d); used with\n"
+          "\t\t  transparent images; overrides -bgcolor\n",
+          num_bgpat-1);
+#ifdef FEATURE_LOOP
+        fprintf(stderr,
+          "    -loop\tloops through background images after initial display\n"
+          "\t\t  is complete (depends on -bgpat)\n"
+          "    sec \tseconds to display each background image (default = 2)\n");
+#endif
+        fprintf(stderr,
+          "    dur \tduration in microseconds to wait after displaying each\n"
+          "\t\t  row (for demo purposes)\n"
+          "    -timing\tenables delay for every block read, to simulate modem\n"
+          "\t\t  download of image (~36 Kbps)\n"
+          "    -pause\tpauses after displaying each pass until mouse clicked\n"
+          "\nPress Q, Esc or mouse button 1 (within image window, after image\n"
+          "is displayed) to quit.\n");
+        exit(1);
+    }
+
+    if (!(infile = fopen(filename, "rb"))) {
+        fprintf(stderr, PROGNAME ":  can't open PNG file [%s]\n", filename);
+        ++error;
+    } else {
+        incount = fread(inbuf, 1, INBUFSIZE, infile);
+        if (incount < 8 || !readpng2_check_sig(inbuf, 8)) {
+            fprintf(stderr, PROGNAME
+              ":  [%s] is not a PNG file: incorrect signature\n",
+              filename);
+            ++error;
+        } else if ((rc = readpng2_init(&rpng2_info)) != 0) {
+            switch (rc) {
+                case 2:
+                    fprintf(stderr, PROGNAME
+                      ":  [%s] has bad IHDR (libpng longjmp)\n", filename);
+                    break;
+                case 4:
+                    fprintf(stderr, PROGNAME ":  insufficient memory\n");
+                    break;
+                default:
+                    fprintf(stderr, PROGNAME
+                      ":  unknown readpng2_init() error\n");
+                    break;
+            }
+            ++error;
+        } else {
+            Trace((stderr, "about to call XOpenDisplay()\n"))
+            display = XOpenDisplay(displayname);
+            if (!display) {
+                readpng2_cleanup(&rpng2_info);
+                fprintf(stderr, PROGNAME ":  can't open X display [%s]\n",
+                  displayname? displayname : "default");
+                ++error;
+            }
+        }
+        if (error)
+            fclose(infile);
+    }
+
+
+    if (error) {
+        fprintf(stderr, PROGNAME ":  aborting.\n");
+        exit(2);
+    }
+
+
+    /* set the title-bar string, but make sure buffer doesn't overflow */
+
+    alen = strlen(appname);
+    flen = strlen(filename);
+    if (alen + flen + 3 > 1023)
+        sprintf(titlebar, "%s:  ...%s", appname, filename+(alen+flen+6-1023));
+    else
+        sprintf(titlebar, "%s:  %s", appname, filename);
+
+
+    /* set some final rpng2_info variables before entering main data loop */
+
+    if (have_bg) {
+        unsigned r, g, b;   /* this approach quiets compiler warnings */
+
+        sscanf(bgstr+1, "%2x%2x%2x", &r, &g, &b);
+        rpng2_info.bg_red   = (uch)r;
+        rpng2_info.bg_green = (uch)g;
+        rpng2_info.bg_blue  = (uch)b;
+    } else
+        rpng2_info.need_bgcolor = TRUE;
+
+    rpng2_info.state = kPreInit;
+    rpng2_info.mainprog_init = rpng2_x_init;
+    rpng2_info.mainprog_display_row = rpng2_x_display_row;
+    rpng2_info.mainprog_finish_display = rpng2_x_finish_display;
+
+
+    /* OK, this is the fun part:  call readpng2_decode_data() at the start of
+     * the loop to deal with our first buffer of data (read in above to verify
+     * that the file is a PNG image), then loop through the file and continue
+     * calling the same routine to handle each chunk of data.  It in turn
+     * passes the data to libpng, which will invoke one or more of our call-
+     * backs as decoded data become available.  We optionally call sleep() for
+     * one second per iteration to simulate downloading the image via an analog
+     * modem. */
+
+    for (;;) {
+        Trace((stderr, "about to call readpng2_decode_data()\n"))
+        if (readpng2_decode_data(&rpng2_info, inbuf, incount))
+            ++error;
+        Trace((stderr, "done with readpng2_decode_data()\n"))
+
+        if (error || incount != INBUFSIZE || rpng2_info.state == kDone) {
+            if (rpng2_info.state == kDone) {
+                Trace((stderr, "done decoding PNG image\n"))
+            } else if (ferror(infile)) {
+                fprintf(stderr, PROGNAME
+                  ":  error while reading PNG image file\n");
+                exit(3);
+            } else if (feof(infile)) {
+                fprintf(stderr, PROGNAME ":  end of file reached "
+                  "(unexpectedly) while reading PNG image file\n");
+                exit(3);
+            } else /* if (error) */ {
+                /* will print error message below */
+            }
+            break;
+        }
+
+        if (timing)
+            sleep(1);
+
+        incount = fread(inbuf, 1, INBUFSIZE, infile);
+    }
+
+
+    /* clean up PNG stuff and report any decoding errors */
+
+    fclose(infile);
+    Trace((stderr, "about to call readpng2_cleanup()\n"))
+    readpng2_cleanup(&rpng2_info);
+
+    if (error) {
+        fprintf(stderr, PROGNAME ":  libpng error while decoding PNG image\n");
+        exit(3);
+    }
+
+
+#ifdef FEATURE_LOOP
+
+    if (loop && bg_image) {
+        Trace((stderr, "entering -loop loop (FEATURE_LOOP)\n"))
+        for (;;) {
+            int i, use_sleep;
+            struct timeval now, then;
+
+            /* get current time and add loop_interval to get target time */
+            if (gettimeofday(&then, NULL) == 0) {
+                then.tv_sec += loop_interval;
+                use_sleep = FALSE;
+            } else
+                use_sleep = TRUE;
+
+            /* do quick check for a quit event but don't wait for it */
+            /* GRR BUG:  should also check for Expose events and redraw... */
+            if (XCheckMaskEvent(display, KeyPressMask | ButtonPressMask, &e))
+                if (QUIT(e,k))
+                    break;
+
+            /* generate next background image */
+            if (++pat >= num_bgpat)
+                pat = 0;
+            rpng2_x_reload_bg_image();
+
+            /* wait for timeout, using whatever means are available */
+            if (use_sleep || gettimeofday(&now, NULL) != 0) {
+                for (i = loop_interval;  i > 0;  --i) {
+                    sleep(1);
+                    /* GRR BUG:  also need to check for Expose (and redraw!) */
+                    if (XCheckMaskEvent(display, KeyPressMask | ButtonPressMask,
+                        &e) && QUIT(e,k))
+                        break;
+                }
+            } else {
+                /* Y2038 BUG! */
+                if (now.tv_sec < then.tv_sec ||
+                    (now.tv_sec == then.tv_sec && now.tv_usec < then.tv_usec))
+                {
+                    int quit = FALSE;
+                    long seconds_to_go = then.tv_sec - now.tv_sec;
+                    long usleep_usec;
+
+                    /* basically chew up most of remaining loop-interval with
+                     *  calls to sleep(1) interleaved with checks for quit
+                     *  events, but also recalc time-to-go periodically; when
+                     *  done, clean up any remaining time with usleep() call
+                     *  (could also use SIGALRM, but signals are a pain...) */
+                    while (seconds_to_go-- > 1) {
+                        int seconds_done = 0;
+
+                        for (i = seconds_to_go;  i > 0 && !quit;  --i) {
+                            sleep(1);
+                            /* GRR BUG:  need to check for Expose and redraw */
+                            if (XCheckMaskEvent(display, KeyPressMask |
+                                ButtonPressMask, &e) && QUIT(e,k))
+                                quit = TRUE;
+                            if (++seconds_done > 1000)
+                                break;   /* time to redo seconds_to_go meas. */
+                        }
+                        if (quit)
+                            break;
+
+                        /* OK, more than 1000 seconds since last check:
+                         *  correct the time-to-go measurement for drift */
+                        if (gettimeofday(&now, NULL) == 0) {
+                            if (now.tv_sec >= then.tv_sec)
+                                break;
+                            seconds_to_go = then.tv_sec - now.tv_sec;
+                        } else
+                            ++seconds_to_go;  /* restore what we subtracted */
+                    }
+                    if (quit)
+                        break;   /* breaks outer do-loop, skips redisplay */
+
+                    /* since difference between "now" and "then" is already
+                     *  eaten up to within a couple of seconds, don't need to
+                     *  worry about overflow--but might have overshot (neg.) */
+                    if (gettimeofday(&now, NULL) == 0) {
+                        usleep_usec = 1000000L*(then.tv_sec - now.tv_sec) +
+                          then.tv_usec - now.tv_usec;
+                        if (usleep_usec > 0)
+                            usleep((ulg)usleep_usec);
+                    }
+                }
+            }
+
+            /* composite image against new background and display (note that
+             *  we do not take into account the time spent doing this...) */
+            rpng2_x_redisplay_image (0, 0, rpng2_info.width, rpng2_info.height);
+        }
+
+    } else /* FALL THROUGH and do the normal thing */
+
+#endif /* FEATURE_LOOP */
+
+    /* wait for the user to tell us when to quit */
+
+    if (rpng2_info.state >= kWindowInit) {
+        Trace((stderr, "entering final wait-for-quit-event loop\n"))
+        do {
+            XNextEvent(display, &e);
+            if (e.type == Expose) {
+                XExposeEvent *ex = (XExposeEvent *)&e;
+                rpng2_x_redisplay_image (ex->x, ex->y, ex->width, ex->height);
+            }
+        } while (!QUIT(e,k));
+    } else {
+        fprintf(stderr, PROGNAME ":  init callback never called:  probable "
+          "libpng error while decoding PNG metadata\n");
+        exit(4);
+    }
+
+
+    /* we're done:  clean up all image and X resources and go away */
+
+    Trace((stderr, "about to call rpng2_x_cleanup()\n"))
+    rpng2_x_cleanup();
+
+    (void)argc; /* Unused */
+
+    return 0;
+}
+
+
+
+
+
+/* this function is called by readpng2_info_callback() in readpng2.c, which
+ * in turn is called by libpng after all of the pre-IDAT chunks have been
+ * read and processed--i.e., we now have enough info to finish initializing */
+
+static void rpng2_x_init(void)
+{
+    ulg i;
+    ulg rowbytes = rpng2_info.rowbytes;
+
+    Trace((stderr, "beginning rpng2_x_init()\n"))
+    Trace((stderr, "  rowbytes = %d\n", rpng2_info.rowbytes))
+    Trace((stderr, "  width  = %ld\n", rpng2_info.width))
+    Trace((stderr, "  height = %ld\n", rpng2_info.height))
+
+    /* Guard against integer overflow */
+    if (rpng2_info.height > ((size_t)(-1))/rpng2_info.rowbytes) {
+        fprintf(stderr, PROGNAME ":  image_data buffer would be too large\n");
+        readpng2_cleanup(&rpng2_info);
+        return;
+    }
+
+    rpng2_info.image_data = (uch *)malloc(rowbytes * rpng2_info.height);
+    if (!rpng2_info.image_data) {
+        readpng2_cleanup(&rpng2_info);
+        return;
+    }
+
+    rpng2_info.row_pointers = (uch **)malloc(rpng2_info.height * sizeof(uch *));
+    if (!rpng2_info.row_pointers) {
+        free(rpng2_info.image_data);
+        rpng2_info.image_data = NULL;
+        readpng2_cleanup(&rpng2_info);
+        return;
+    }
+
+    for (i = 0;  i < rpng2_info.height;  ++i)
+        rpng2_info.row_pointers[i] = rpng2_info.image_data + i*rowbytes;
+
+
+    /* do the basic X initialization stuff, make the window, and fill it with
+     * the user-specified, file-specified or default background color or
+     * pattern */
+
+    if (rpng2_x_create_window()) {
+
+        /* GRR TEMPORARY HACK:  this is fundamentally no different from cases
+         * above; libpng should call our error handler to longjmp() back to us
+         * when png_ptr goes away.  If we/it segfault instead, seems like a
+         * libpng bug... */
+
+        /* we're here via libpng callback, so if window fails, clean and bail */
+        readpng2_cleanup(&rpng2_info);
+        rpng2_x_cleanup();
+        exit(2);
+    }
+
+    rpng2_info.state = kWindowInit;
+}
+
+
+
+
+
+static int rpng2_x_create_window(void)
+{
+    ulg bg_red   = rpng2_info.bg_red;
+    ulg bg_green = rpng2_info.bg_green;
+    ulg bg_blue  = rpng2_info.bg_blue;
+    ulg bg_pixel = 0L;
+    ulg attrmask;
+    int need_colormap = FALSE;
+    int screen, pad;
+    uch *xdata;
+    Window root;
+    XEvent e;
+    XGCValues gcvalues;
+    XSetWindowAttributes attr;
+    XTextProperty windowName, *pWindowName = &windowName;
+    XTextProperty iconName, *pIconName = &iconName;
+    XVisualInfo visual_info;
+    XSizeHints *size_hints;
+    XWMHints *wm_hints;
+    XClassHint *class_hints;
+
+
+    Trace((stderr, "beginning rpng2_x_create_window()\n"))
+
+    screen = DefaultScreen(display);
+    depth = DisplayPlanes(display, screen);
+    root = RootWindow(display, screen);
+
+#ifdef DEBUG
+    XSynchronize(display, True);
+#endif
+
+    if (depth != 16 && depth != 24 && depth != 32) {
+        int visuals_matched = 0;
+
+        Trace((stderr, "default depth is %d:  checking other visuals\n",
+          depth))
+
+        /* 24-bit first */
+        visual_info.screen = screen;
+        visual_info.depth = 24;
+        visual_list = XGetVisualInfo(display,
+          VisualScreenMask | VisualDepthMask, &visual_info, &visuals_matched);
+        if (visuals_matched == 0) {
+/* GRR:  add 15-, 16- and 32-bit TrueColor visuals (also DirectColor?) */
+            fprintf(stderr, "default screen depth %d not supported, and no"
+              " 24-bit visuals found\n", depth);
+            return 2;
+        }
+        Trace((stderr, "XGetVisualInfo() returned %d 24-bit visuals\n",
+          visuals_matched))
+        visual = visual_list[0].visual;
+        depth = visual_list[0].depth;
+/*
+        colormap_size = visual_list[0].colormap_size;
+        visual_class = visual->class;
+        visualID = XVisualIDFromVisual(visual);
+ */
+        have_nondefault_visual = TRUE;
+        need_colormap = TRUE;
+    } else {
+        XMatchVisualInfo(display, screen, depth, TrueColor, &visual_info);
+        visual = visual_info.visual;
+    }
+
+    RMask = visual->red_mask;
+    GMask = visual->green_mask;
+    BMask = visual->blue_mask;
+
+/* GRR:  add/check 8-bit support */
+    if (depth == 8 || need_colormap) {
+        colormap = XCreateColormap(display, root, visual, AllocNone);
+        if (!colormap) {
+            fprintf(stderr, "XCreateColormap() failed\n");
+            return 2;
+        }
+        have_colormap = TRUE;
+        if (depth == 8)
+            bg_image = FALSE;   /* gradient just wastes palette entries */
+    }
+    if (depth == 15 || depth == 16) {
+        RShift = 15 - rpng2_x_msb(RMask);    /* these are right-shifts */
+        GShift = 15 - rpng2_x_msb(GMask);
+        BShift = 15 - rpng2_x_msb(BMask);
+    } else if (depth > 16) {
+        RShift = rpng2_x_msb(RMask) - 7;     /* these are left-shifts */
+        GShift = rpng2_x_msb(GMask) - 7;
+        BShift = rpng2_x_msb(BMask) - 7;
+    }
+    if (depth >= 15 && (RShift < 0 || GShift < 0 || BShift < 0)) {
+        fprintf(stderr, "rpng2 internal logic error:  negative X shift(s)!\n");
+        return 2;
+    }
+
+/*---------------------------------------------------------------------------
+    Finally, create the window.
+  ---------------------------------------------------------------------------*/
+
+    attr.backing_store = Always;
+    attr.event_mask = ExposureMask | KeyPressMask | ButtonPressMask;
+    attrmask = CWBackingStore | CWEventMask;
+    if (have_nondefault_visual) {
+        attr.colormap = colormap;
+        attr.background_pixel = 0;
+        attr.border_pixel = 1;
+        attrmask |= CWColormap | CWBackPixel | CWBorderPixel;
+    }
+
+    window = XCreateWindow(display, root, 0, 0, rpng2_info.width,
+      rpng2_info.height, 0, depth, InputOutput, visual, attrmask, &attr);
+
+    if (window == None) {
+        fprintf(stderr, "XCreateWindow() failed\n");
+        return 2;
+    } else
+        have_window = TRUE;
+
+    if (depth == 8)
+        XSetWindowColormap(display, window, colormap);
+
+    if (!XStringListToTextProperty(&window_name, 1, pWindowName))
+        pWindowName = NULL;
+    if (!XStringListToTextProperty(&icon_name, 1, pIconName))
+        pIconName = NULL;
+
+    /* OK if either hints allocation fails; XSetWMProperties() allows NULLs */
+
+    if ((size_hints = XAllocSizeHints()) != NULL) {
+        /* window will not be resizable */
+        size_hints->flags = PMinSize | PMaxSize;
+        size_hints->min_width = size_hints->max_width = (int)rpng2_info.width;
+        size_hints->min_height = size_hints->max_height =
+          (int)rpng2_info.height;
+    }
+
+    if ((wm_hints = XAllocWMHints()) != NULL) {
+        wm_hints->initial_state = NormalState;
+        wm_hints->input = True;
+     /* wm_hints->icon_pixmap = icon_pixmap; */
+        wm_hints->flags = StateHint | InputHint  /* | IconPixmapHint */ ;
+    }
+
+    if ((class_hints = XAllocClassHint()) != NULL) {
+        class_hints->res_name = res_name;
+        class_hints->res_class = res_class;
+    }
+
+    XSetWMProperties(display, window, pWindowName, pIconName, NULL, 0,
+      size_hints, wm_hints, class_hints);
+
+    /* various properties and hints no longer needed; free memory */
+    if (pWindowName)
+       XFree(pWindowName->value);
+    if (pIconName)
+       XFree(pIconName->value);
+    if (size_hints)
+        XFree(size_hints);
+    if (wm_hints)
+       XFree(wm_hints);
+    if (class_hints)
+       XFree(class_hints);
+
+    XMapWindow(display, window);
+
+    gc = XCreateGC(display, window, 0, &gcvalues);
+    have_gc = TRUE;
+
+/*---------------------------------------------------------------------------
+    Allocate memory for the X- and display-specific version of the image.
+  ---------------------------------------------------------------------------*/
+
+    if (depth == 24 || depth == 32) {
+        xdata = (uch *)malloc(4*rpng2_info.width*rpng2_info.height);
+        pad = 32;
+    } else if (depth == 16) {
+        xdata = (uch *)malloc(2*rpng2_info.width*rpng2_info.height);
+        pad = 16;
+    } else /* depth == 8 */ {
+        xdata = (uch *)malloc(rpng2_info.width*rpng2_info.height);
+        pad = 8;
+    }
+
+    if (!xdata) {
+        fprintf(stderr, PROGNAME ":  unable to allocate image memory\n");
+        return 4;
+    }
+
+    ximage = XCreateImage(display, visual, depth, ZPixmap, 0,
+      (char *)xdata, rpng2_info.width, rpng2_info.height, pad, 0);
+
+    if (!ximage) {
+        fprintf(stderr, PROGNAME ":  XCreateImage() failed\n");
+        free(xdata);
+        return 3;
+    }
+
+    /* to avoid testing the byte order every pixel (or doubling the size of
+     * the drawing routine with a giant if-test), we arbitrarily set the byte
+     * order to MSBFirst and let Xlib worry about inverting things on little-
+     * endian machines (e.g., Linux/x86, old VAXen, etc.)--this is not the
+     * most efficient approach (the giant if-test would be better), but in
+     * the interest of clarity, we'll take the easy way out... */
+
+    ximage->byte_order = MSBFirst;
+
+/*---------------------------------------------------------------------------
+    Fill window with the specified background color (default is black) or
+    faked "background image" (but latter is disabled if 8-bit; gradients
+    just waste palette entries).
+  ---------------------------------------------------------------------------*/
+
+    if (bg_image)
+        rpng2_x_load_bg_image();    /* resets bg_image if fails */
+
+    if (!bg_image) {
+        if (depth == 24 || depth == 32) {
+            bg_pixel = (bg_red   << RShift) |
+                       (bg_green << GShift) |
+                       (bg_blue  << BShift);
+        } else if (depth == 16) {
+            bg_pixel = (((bg_red   << 8) >> RShift) & RMask) |
+                       (((bg_green << 8) >> GShift) & GMask) |
+                       (((bg_blue  << 8) >> BShift) & BMask);
+        } else /* depth == 8 */ {
+
+            /* GRR:  add 8-bit support */
+
+        }
+        XSetForeground(display, gc, bg_pixel);
+        XFillRectangle(display, window, gc, 0, 0, rpng2_info.width,
+          rpng2_info.height);
+    }
+
+/*---------------------------------------------------------------------------
+    Wait for first Expose event to do any drawing, then flush and return.
+  ---------------------------------------------------------------------------*/
+
+    do
+        XNextEvent(display, &e);
+    while (e.type != Expose || e.xexpose.count);
+
+    XFlush(display);
+
+    return 0;
+
+} /* end function rpng2_x_create_window() */
+
+
+
+
+
+static int rpng2_x_load_bg_image(void)
+{
+    uch *src;
+    char *dest;
+    uch r1, r2, g1, g2, b1, b2;
+    uch r1_inv, r2_inv, g1_inv, g2_inv, b1_inv, b2_inv;
+    int k, hmax, max;
+    int xidx, yidx, yidx_max;
+    int even_odd_vert, even_odd_horiz, even_odd;
+    int invert_gradient2 = (bg[pat].type & 0x08);
+    int invert_column;
+    int ximage_rowbytes = ximage->bytes_per_line;
+    ulg i, row;
+    ulg pixel;
+
+/*---------------------------------------------------------------------------
+    Allocate buffer for fake background image to be used with transparent
+    images; if this fails, revert to plain background color.
+  ---------------------------------------------------------------------------*/
+
+    bg_rowbytes = 3 * rpng2_info.width;
+    bg_data = (uch *)malloc(bg_rowbytes * rpng2_info.height);
+    if (!bg_data) {
+        fprintf(stderr, PROGNAME
+          ":  unable to allocate memory for background image\n");
+        bg_image = 0;
+        return 1;
+    }
+
+    bgscale = (pat == 0)? 8 : bgscale_default;
+    yidx_max = bgscale - 1;
+
+/*---------------------------------------------------------------------------
+    Vertical gradients (ramps) in NxN squares, alternating direction and
+    colors (N == bgscale).
+  ---------------------------------------------------------------------------*/
+
+    if ((bg[pat].type & 0x07) == 0) {
+        uch r1_min  = rgb[bg[pat].rgb1_min].r;
+        uch g1_min  = rgb[bg[pat].rgb1_min].g;
+        uch b1_min  = rgb[bg[pat].rgb1_min].b;
+        uch r2_min  = rgb[bg[pat].rgb2_min].r;
+        uch g2_min  = rgb[bg[pat].rgb2_min].g;
+        uch b2_min  = rgb[bg[pat].rgb2_min].b;
+        int r1_diff = rgb[bg[pat].rgb1_max].r - r1_min;
+        int g1_diff = rgb[bg[pat].rgb1_max].g - g1_min;
+        int b1_diff = rgb[bg[pat].rgb1_max].b - b1_min;
+        int r2_diff = rgb[bg[pat].rgb2_max].r - r2_min;
+        int g2_diff = rgb[bg[pat].rgb2_max].g - g2_min;
+        int b2_diff = rgb[bg[pat].rgb2_max].b - b2_min;
+
+        for (row = 0;  row < rpng2_info.height;  ++row) {
+            yidx = (int)(row % bgscale);
+            even_odd_vert = (int)((row / bgscale) & 1);
+
+            r1 = r1_min + (r1_diff * yidx) / yidx_max;
+            g1 = g1_min + (g1_diff * yidx) / yidx_max;
+            b1 = b1_min + (b1_diff * yidx) / yidx_max;
+            r1_inv = r1_min + (r1_diff * (yidx_max-yidx)) / yidx_max;
+            g1_inv = g1_min + (g1_diff * (yidx_max-yidx)) / yidx_max;
+            b1_inv = b1_min + (b1_diff * (yidx_max-yidx)) / yidx_max;
+
+            r2 = r2_min + (r2_diff * yidx) / yidx_max;
+            g2 = g2_min + (g2_diff * yidx) / yidx_max;
+            b2 = b2_min + (b2_diff * yidx) / yidx_max;
+            r2_inv = r2_min + (r2_diff * (yidx_max-yidx)) / yidx_max;
+            g2_inv = g2_min + (g2_diff * (yidx_max-yidx)) / yidx_max;
+            b2_inv = b2_min + (b2_diff * (yidx_max-yidx)) / yidx_max;
+
+            dest = (char *)bg_data + row*bg_rowbytes;
+            for (i = 0;  i < rpng2_info.width;  ++i) {
+                even_odd_horiz = (int)((i / bgscale) & 1);
+                even_odd = even_odd_vert ^ even_odd_horiz;
+                invert_column =
+                  (even_odd_horiz && (bg[pat].type & 0x10));
+                if (even_odd == 0) {        /* gradient #1 */
+                    if (invert_column) {
+                        *dest++ = r1_inv;
+                        *dest++ = g1_inv;
+                        *dest++ = b1_inv;
+                    } else {
+                        *dest++ = r1;
+                        *dest++ = g1;
+                        *dest++ = b1;
+                    }
+                } else {                    /* gradient #2 */
+                    if ((invert_column && invert_gradient2) ||
+                        (!invert_column && !invert_gradient2))
+                    {
+                        *dest++ = r2;       /* not inverted or */
+                        *dest++ = g2;       /*  doubly inverted */
+                        *dest++ = b2;
+                    } else {
+                        *dest++ = r2_inv;
+                        *dest++ = g2_inv;   /* singly inverted */
+                        *dest++ = b2_inv;
+                    }
+                }
+            }
+        }
+
+/*---------------------------------------------------------------------------
+    Soft gradient-diamonds with scale = bgscale.  Code contributed by Adam
+    M. Costello.
+  ---------------------------------------------------------------------------*/
+
+    } else if ((bg[pat].type & 0x07) == 1) {
+
+        hmax = (bgscale-1)/2;   /* half the max weight of a color */
+        max = 2*hmax;           /* the max weight of a color */
+
+        r1 = rgb[bg[pat].rgb1_max].r;
+        g1 = rgb[bg[pat].rgb1_max].g;
+        b1 = rgb[bg[pat].rgb1_max].b;
+        r2 = rgb[bg[pat].rgb2_max].r;
+        g2 = rgb[bg[pat].rgb2_max].g;
+        b2 = rgb[bg[pat].rgb2_max].b;
+
+        for (row = 0;  row < rpng2_info.height;  ++row) {
+            yidx = (int)(row % bgscale);
+            if (yidx > hmax)
+                yidx = bgscale-1 - yidx;
+            dest = (char *)bg_data + row*bg_rowbytes;
+            for (i = 0;  i < rpng2_info.width;  ++i) {
+                xidx = (int)(i % bgscale);
+                if (xidx > hmax)
+                    xidx = bgscale-1 - xidx;
+                k = xidx + yidx;
+                *dest++ = (k*r1 + (max-k)*r2) / max;
+                *dest++ = (k*g1 + (max-k)*g2) / max;
+                *dest++ = (k*b1 + (max-k)*b2) / max;
+            }
+        }
+
+/*---------------------------------------------------------------------------
+    Radial "starburst" with azimuthal sinusoids; [eventually number of sinu-
+    soids will equal bgscale?].  This one is slow but very cool.  Code con-
+    tributed by Pieter S. van der Meulen (originally in Smalltalk).
+  ---------------------------------------------------------------------------*/
+
+    } else if ((bg[pat].type & 0x07) == 2) {
+        uch ch;
+        int ii, x, y, hw, hh, grayspot;
+        double freq, rotate, saturate, gray, intensity;
+        double angle=0.0, aoffset=0.0, maxDist, dist;
+        double red=0.0, green=0.0, blue=0.0, hue, s, v, f, p, q, t;
+
+        fprintf(stderr, "%s:  computing radial background...",
+          PROGNAME);
+        fflush(stderr);
+
+        hh = (int)(rpng2_info.height / 2);
+        hw = (int)(rpng2_info.width / 2);
+
+        /* variables for radial waves:
+         *   aoffset:  number of degrees to rotate hue [CURRENTLY NOT USED]
+         *   freq:  number of color beams originating from the center
+         *   grayspot:  size of the graying center area (anti-alias)
+         *   rotate:  rotation of the beams as a function of radius
+         *   saturate:  saturation of beams' shape azimuthally
+         */
+        angle = CLIP(angle, 0.0, 360.0);
+        grayspot = CLIP(bg[pat].bg_gray, 1, (hh + hw));
+        freq = MAX((double)bg[pat].bg_freq, 0.0);
+        saturate = (double)bg[pat].bg_bsat * 0.1;
+        rotate = (double)bg[pat].bg_brot * 0.1;
+        gray = 0.0;
+        intensity = 0.0;
+        maxDist = (double)((hw*hw) + (hh*hh));
+
+        for (row = 0;  row < rpng2_info.height;  ++row) {
+            y = (int)(row - hh);
+            dest = (char *)bg_data + row*bg_rowbytes;
+            for (i = 0;  i < rpng2_info.width;  ++i) {
+                x = (int)(i - hw);
+                angle = (x == 0)? PI_2 : atan((double)y / (double)x);
+                gray = (double)MAX(ABS(y), ABS(x)) / grayspot;
+                gray = MIN(1.0, gray);
+                dist = (double)((x*x) + (y*y)) / maxDist;
+                intensity = cos((angle+(rotate*dist*PI)) * freq) *
+                  gray * saturate;
+                intensity = (MAX(MIN(intensity,1.0),-1.0) + 1.0) * 0.5;
+                hue = (angle + PI) * INV_PI_360 + aoffset;
+                s = gray * ((double)(ABS(x)+ABS(y)) / (double)(hw + hh));
+                s = MIN(MAX(s,0.0), 1.0);
+                v = MIN(MAX(intensity,0.0), 1.0);
+
+                if (s == 0.0) {
+                    ch = (uch)(v * 255.0);
+                    *dest++ = ch;
+                    *dest++ = ch;
+                    *dest++ = ch;
+                } else {
+                    if ((hue < 0.0) || (hue >= 360.0))
+                        hue -= (((int)(hue / 360.0)) * 360.0);
+                    hue /= 60.0;
+                    ii = (int)hue;
+                    f = hue - (double)ii;
+                    p = (1.0 - s) * v;
+                    q = (1.0 - (s * f)) * v;
+                    t = (1.0 - (s * (1.0 - f))) * v;
+                    if      (ii == 0) { red = v; green = t; blue = p; }
+                    else if (ii == 1) { red = q; green = v; blue = p; }
+                    else if (ii == 2) { red = p; green = v; blue = t; }
+                    else if (ii == 3) { red = p; green = q; blue = v; }
+                    else if (ii == 4) { red = t; green = p; blue = v; }
+                    else if (ii == 5) { red = v; green = p; blue = q; }
+                    *dest++ = (uch)(red * 255.0);
+                    *dest++ = (uch)(green * 255.0);
+                    *dest++ = (uch)(blue * 255.0);
+                }
+            }
+        }
+        fprintf(stderr, "done.\n");
+        fflush(stderr);
+    }
+
+/*---------------------------------------------------------------------------
+    Blast background image to display buffer before beginning PNG decode.
+  ---------------------------------------------------------------------------*/
+
+    if (depth == 24 || depth == 32) {
+        ulg red, green, blue;
+        int bpp = ximage->bits_per_pixel;
+
+        for (row = 0;  row < rpng2_info.height;  ++row) {
+            src = bg_data + row*bg_rowbytes;
+            dest = ximage->data + row*ximage_rowbytes;
+            if (bpp == 32) {    /* slightly optimized version */
+                for (i = rpng2_info.width;  i > 0;  --i) {
+                    red   = *src++;
+                    green = *src++;
+                    blue  = *src++;
+                    pixel = (red   << RShift) |
+                            (green << GShift) |
+                            (blue  << BShift);
+                    /* recall that we set ximage->byte_order = MSBFirst above */
+                    *dest++ = (char)((pixel >> 24) & 0xff);
+                    *dest++ = (char)((pixel >> 16) & 0xff);
+                    *dest++ = (char)((pixel >>  8) & 0xff);
+                    *dest++ = (char)( pixel        & 0xff);
+                }
+            } else {
+                for (i = rpng2_info.width;  i > 0;  --i) {
+                    red   = *src++;
+                    green = *src++;
+                    blue  = *src++;
+                    pixel = (red   << RShift) |
+                            (green << GShift) |
+                            (blue  << BShift);
+                    /* recall that we set ximage->byte_order = MSBFirst above */
+                    /* GRR BUG?  this assumes bpp == 24 & bits are packed low */
+                    /*           (probably need to use RShift, RMask, etc.) */
+                    *dest++ = (char)((pixel >> 16) & 0xff);
+                    *dest++ = (char)((pixel >>  8) & 0xff);
+                    *dest++ = (char)( pixel        & 0xff);
+                }
+            }
+        }
+
+    } else if (depth == 16) {
+        ush red, green, blue;
+
+        for (row = 0;  row < rpng2_info.height;  ++row) {
+            src = bg_data + row*bg_rowbytes;
+            dest = ximage->data + row*ximage_rowbytes;
+            for (i = rpng2_info.width;  i > 0;  --i) {
+                red   = ((ush)(*src) << 8);  ++src;
+                green = ((ush)(*src) << 8);  ++src;
+                blue  = ((ush)(*src) << 8);  ++src;
+                pixel = ((red   >> RShift) & RMask) |
+                        ((green >> GShift) & GMask) |
+                        ((blue  >> BShift) & BMask);
+                /* recall that we set ximage->byte_order = MSBFirst above */
+                *dest++ = (char)((pixel >>  8) & 0xff);
+                *dest++ = (char)( pixel        & 0xff);
+            }
+        }
+
+    } else /* depth == 8 */ {
+
+        /* GRR:  add 8-bit support */
+
+    }
+
+    XPutImage(display, window, gc, ximage, 0, 0, 0, 0, rpng2_info.width,
+      rpng2_info.height);
+
+    return 0;
+
+} /* end function rpng2_x_load_bg_image() */
+
+
+
+
+
+static void rpng2_x_display_row(ulg row)
+{
+    uch bg_red   = rpng2_info.bg_red;
+    uch bg_green = rpng2_info.bg_green;
+    uch bg_blue  = rpng2_info.bg_blue;
+    uch *src, *src2=NULL;
+    char *dest;
+    uch r, g, b, a;
+    int ximage_rowbytes = ximage->bytes_per_line;
+    ulg i, pixel;
+    static int rows=0, prevpass=(-1);
+    static ulg firstrow;
+
+/*---------------------------------------------------------------------------
+    rows and firstrow simply track how many rows (and which ones) have not
+    yet been displayed; alternatively, we could call XPutImage() for every
+    row and not bother with the records-keeping.
+  ---------------------------------------------------------------------------*/
+
+    Trace((stderr, "beginning rpng2_x_display_row()\n"))
+
+    if (rpng2_info.pass != prevpass) {
+        if (pause_after_pass && rpng2_info.pass > 0) {
+            XEvent e;
+            KeySym k;
+
+            fprintf(stderr,
+              "%s:  end of pass %d of 7; click in image window to continue\n",
+              PROGNAME, prevpass + 1);
+            do
+                XNextEvent(display, &e);
+            while (!QUIT(e,k));
+        }
+        fprintf(stderr, "%s:  pass %d of 7\r", PROGNAME, rpng2_info.pass + 1);
+        fflush(stderr);
+        prevpass = rpng2_info.pass;
+    }
+
+    if (rows == 0)
+        firstrow = row;   /* first row that is not yet displayed */
+
+    ++rows;   /* count of rows received but not yet displayed */
+
+/*---------------------------------------------------------------------------
+    Aside from the use of the rpng2_info struct, the lack of an outer loop
+    (over rows) and moving the XPutImage() call outside the "if (depth)"
+    tests, this routine is identical to rpng_x_display_image() in the non-
+    progressive version of the program.
+  ---------------------------------------------------------------------------*/
+
+    if (depth == 24 || depth == 32) {
+        ulg red, green, blue;
+        int bpp = ximage->bits_per_pixel;
+
+        src = rpng2_info.image_data + row*rpng2_info.rowbytes;
+        if (bg_image)
+            src2 = bg_data + row*bg_rowbytes;
+        dest = ximage->data + row*ximage_rowbytes;
+        if (rpng2_info.channels == 3) {
+            for (i = rpng2_info.width;  i > 0;  --i) {
+                red   = *src++;
+                green = *src++;
+                blue  = *src++;
+                pixel = (red   << RShift) |
+                        (green << GShift) |
+                        (blue  << BShift);
+                /* recall that we set ximage->byte_order = MSBFirst above */
+                if (bpp == 32) {
+                    *dest++ = (char)((pixel >> 24) & 0xff);
+                    *dest++ = (char)((pixel >> 16) & 0xff);
+                    *dest++ = (char)((pixel >>  8) & 0xff);
+                    *dest++ = (char)( pixel        & 0xff);
+                } else {
+                    /* GRR BUG?  this assumes bpp == 24 & bits are packed low */
+                    /*           (probably need to use RShift, RMask, etc.) */
+                    *dest++ = (char)((pixel >> 16) & 0xff);
+                    *dest++ = (char)((pixel >>  8) & 0xff);
+                    *dest++ = (char)( pixel        & 0xff);
+                }
+            }
+        } else /* if (rpng2_info.channels == 4) */ {
+            for (i = rpng2_info.width;  i > 0;  --i) {
+                r = *src++;
+                g = *src++;
+                b = *src++;
+                a = *src++;
+                if (bg_image) {
+                    bg_red   = *src2++;
+                    bg_green = *src2++;
+                    bg_blue  = *src2++;
+                }
+                if (a == 255) {
+                    red   = r;
+                    green = g;
+                    blue  = b;
+                } else if (a == 0) {
+                    red   = bg_red;
+                    green = bg_green;
+                    blue  = bg_blue;
+                } else {
+                    /* this macro (from png.h) composites the foreground
+                     * and background values and puts the result into the
+                     * first argument */
+                    alpha_composite(red,   r, a, bg_red);
+                    alpha_composite(green, g, a, bg_green);
+                    alpha_composite(blue,  b, a, bg_blue);
+                }
+                pixel = (red   << RShift) |
+                        (green << GShift) |
+                        (blue  << BShift);
+                /* recall that we set ximage->byte_order = MSBFirst above */
+                if (bpp == 32) {
+                    *dest++ = (char)((pixel >> 24) & 0xff);
+                    *dest++ = (char)((pixel >> 16) & 0xff);
+                    *dest++ = (char)((pixel >>  8) & 0xff);
+                    *dest++ = (char)( pixel        & 0xff);
+                } else {
+                    /* GRR BUG?  this assumes bpp == 24 & bits are packed low */
+                    /*           (probably need to use RShift, RMask, etc.) */
+                    *dest++ = (char)((pixel >> 16) & 0xff);
+                    *dest++ = (char)((pixel >>  8) & 0xff);
+                    *dest++ = (char)( pixel        & 0xff);
+                }
+            }
+        }
+
+    } else if (depth == 16) {
+        ush red, green, blue;
+
+        src = rpng2_info.row_pointers[row];
+        if (bg_image)
+            src2 = bg_data + row*bg_rowbytes;
+        dest = ximage->data + row*ximage_rowbytes;
+        if (rpng2_info.channels == 3) {
+            for (i = rpng2_info.width;  i > 0;  --i) {
+                red   = ((ush)(*src) << 8);
+                ++src;
+                green = ((ush)(*src) << 8);
+                ++src;
+                blue  = ((ush)(*src) << 8);
+                ++src;
+                pixel = ((red   >> RShift) & RMask) |
+                        ((green >> GShift) & GMask) |
+                        ((blue  >> BShift) & BMask);
+                /* recall that we set ximage->byte_order = MSBFirst above */
+                *dest++ = (char)((pixel >>  8) & 0xff);
+                *dest++ = (char)( pixel        & 0xff);
+            }
+        } else /* if (rpng2_info.channels == 4) */ {
+            for (i = rpng2_info.width;  i > 0;  --i) {
+                r = *src++;
+                g = *src++;
+                b = *src++;
+                a = *src++;
+                if (bg_image) {
+                    bg_red   = *src2++;
+                    bg_green = *src2++;
+                    bg_blue  = *src2++;
+                }
+                if (a == 255) {
+                    red   = ((ush)r << 8);
+                    green = ((ush)g << 8);
+                    blue  = ((ush)b << 8);
+                } else if (a == 0) {
+                    red   = ((ush)bg_red   << 8);
+                    green = ((ush)bg_green << 8);
+                    blue  = ((ush)bg_blue  << 8);
+                } else {
+                    /* this macro (from png.h) composites the foreground
+                     * and background values and puts the result back into
+                     * the first argument (== fg byte here:  safe) */
+                    alpha_composite(r, r, a, bg_red);
+                    alpha_composite(g, g, a, bg_green);
+                    alpha_composite(b, b, a, bg_blue);
+                    red   = ((ush)r << 8);
+                    green = ((ush)g << 8);
+                    blue  = ((ush)b << 8);
+                }
+                pixel = ((red   >> RShift) & RMask) |
+                        ((green >> GShift) & GMask) |
+                        ((blue  >> BShift) & BMask);
+                /* recall that we set ximage->byte_order = MSBFirst above */
+                *dest++ = (char)((pixel >>  8) & 0xff);
+                *dest++ = (char)( pixel        & 0xff);
+            }
+        }
+
+    } else /* depth == 8 */ {
+
+        /* GRR:  add 8-bit support */
+
+    }
+
+
+/*---------------------------------------------------------------------------
+    Display after every 16 rows or when on one of last two rows.  (Region
+    may include previously displayed lines due to interlacing--i.e., not
+    contiguous.  Also, second-to-last row is final one in interlaced images
+    with odd number of rows.)  For demos, flush (and delay) after every 16th
+    row so "sparse" passes don't go twice as fast.
+  ---------------------------------------------------------------------------*/
+
+    if (demo_timing && (row - firstrow >= 16 || row >= rpng2_info.height-2)) {
+        XPutImage(display, window, gc, ximage, 0, (int)firstrow, 0,
+          (int)firstrow, rpng2_info.width, row - firstrow + 1);
+        XFlush(display);
+        rows = 0;
+        usleep(usleep_duration);
+    } else
+    if (!demo_timing && ((rows & 0xf) == 0 || row >= rpng2_info.height-2)) {
+        XPutImage(display, window, gc, ximage, 0, (int)firstrow, 0,
+          (int)firstrow, rpng2_info.width, row - firstrow + 1);
+        XFlush(display);
+        rows = 0;
+    }
+
+}
+
+
+
+
+
+static void rpng2_x_finish_display(void)
+{
+    Trace((stderr, "beginning rpng2_x_finish_display()\n"))
+
+    /* last row has already been displayed by rpng2_x_display_row(), so we
+     * have nothing to do here except set a flag and let the user know that
+     * the image is done */
+
+    rpng2_info.state = kDone;
+    printf(
+      "Done.  Press Q, Esc or mouse button 1 (within image window) to quit.\n");
+    fflush(stdout);
+}
+
+
+
+
+
+static void rpng2_x_redisplay_image(ulg startcol, ulg startrow,
+                                    ulg width, ulg height)
+{
+    uch bg_red   = rpng2_info.bg_red;
+    uch bg_green = rpng2_info.bg_green;
+    uch bg_blue  = rpng2_info.bg_blue;
+    uch *src, *src2=NULL;
+    char *dest;
+    uch r, g, b, a;
+    ulg i, row, lastrow = 0;
+    ulg pixel;
+    int ximage_rowbytes = ximage->bytes_per_line;
+
+
+    Trace((stderr, "beginning display loop (image_channels == %d)\n",
+      rpng2_info.channels))
+    Trace((stderr, "   (width = %ld, rowbytes = %d, ximage_rowbytes = %d)\n",
+      rpng2_info.width, rpng2_info.rowbytes, ximage_rowbytes))
+    Trace((stderr, "   (bpp = %d)\n", ximage->bits_per_pixel))
+    Trace((stderr, "   (byte_order = %s)\n", ximage->byte_order == MSBFirst?
+      "MSBFirst" : (ximage->byte_order == LSBFirst? "LSBFirst" : "unknown")))
+
+/*---------------------------------------------------------------------------
+    Aside from the use of the rpng2_info struct and of src2 (for background
+    image), this routine is identical to rpng_x_display_image() in the non-
+    progressive version of the program--for the simple reason that redisplay
+    of the image against a new background happens after the image is fully
+    decoded and therefore is, by definition, non-progressive.
+  ---------------------------------------------------------------------------*/
+
+    if (depth == 24 || depth == 32) {
+        ulg red, green, blue;
+        int bpp = ximage->bits_per_pixel;
+
+        for (lastrow = row = startrow;  row < startrow+height;  ++row) {
+            src = rpng2_info.image_data + row*rpng2_info.rowbytes;
+            if (bg_image)
+                src2 = bg_data + row*bg_rowbytes;
+            dest = ximage->data + row*ximage_rowbytes;
+            if (rpng2_info.channels == 3) {
+                for (i = rpng2_info.width;  i > 0;  --i) {
+                    red   = *src++;
+                    green = *src++;
+                    blue  = *src++;
+#ifdef NO_24BIT_MASKS
+                    pixel = (red   << RShift) |
+                            (green << GShift) |
+                            (blue  << BShift);
+                    /* recall that we set ximage->byte_order = MSBFirst above */
+                    if (bpp == 32) {
+                        *dest++ = (char)((pixel >> 24) & 0xff);
+                        *dest++ = (char)((pixel >> 16) & 0xff);
+                        *dest++ = (char)((pixel >>  8) & 0xff);
+                        *dest++ = (char)( pixel        & 0xff);
+                    } else {
+                        /* this assumes bpp == 24 & bits are packed low */
+                        /* (probably need to use RShift, RMask, etc.) */
+                        *dest++ = (char)((pixel >> 16) & 0xff);
+                        *dest++ = (char)((pixel >>  8) & 0xff);
+                        *dest++ = (char)( pixel        & 0xff);
+                    }
+#else
+                    red   = (RShift < 0)? red   << (-RShift) : red   >> RShift;
+                    green = (GShift < 0)? green << (-GShift) : green >> GShift;
+                    blue  = (BShift < 0)? blue  << (-BShift) : blue  >> BShift;
+                    pixel = (red & RMask) | (green & GMask) | (blue & BMask);
+                    /* recall that we set ximage->byte_order = MSBFirst above */
+                    if (bpp == 32) {
+                        *dest++ = (char)((pixel >> 24) & 0xff);
+                        *dest++ = (char)((pixel >> 16) & 0xff);
+                        *dest++ = (char)((pixel >>  8) & 0xff);
+                        *dest++ = (char)( pixel        & 0xff);
+                    } else {
+                        /* GRR BUG */
+                        /* this assumes bpp == 24 & bits are packed low */
+                        /* (probably need to use RShift/RMask/etc. here, too) */
+                        *dest++ = (char)((pixel >> 16) & 0xff);
+                        *dest++ = (char)((pixel >>  8) & 0xff);
+                        *dest++ = (char)( pixel        & 0xff);
+                    }
+#endif
+                }
+
+            } else /* if (rpng2_info.channels == 4) */ {
+                for (i = rpng2_info.width;  i > 0;  --i) {
+                    r = *src++;
+                    g = *src++;
+                    b = *src++;
+                    a = *src++;
+                    if (bg_image) {
+                        bg_red   = *src2++;
+                        bg_green = *src2++;
+                        bg_blue  = *src2++;
+                    }
+                    if (a == 255) {
+                        red   = r;
+                        green = g;
+                        blue  = b;
+                    } else if (a == 0) {
+                        red   = bg_red;
+                        green = bg_green;
+                        blue  = bg_blue;
+                    } else {
+                        /* this macro (from png.h) composites the foreground
+                         * and background values and puts the result into the
+                         * first argument */
+                        alpha_composite(red,   r, a, bg_red);
+                        alpha_composite(green, g, a, bg_green);
+                        alpha_composite(blue,  b, a, bg_blue);
+                    }
+#ifdef NO_24BIT_MASKS
+                    pixel = (red   << RShift) |
+                            (green << GShift) |
+                            (blue  << BShift);
+                    /* recall that we set ximage->byte_order = MSBFirst above */
+                    if (bpp == 32) {
+                        *dest++ = (char)((pixel >> 24) & 0xff);
+                        *dest++ = (char)((pixel >> 16) & 0xff);
+                        *dest++ = (char)((pixel >>  8) & 0xff);
+                        *dest++ = (char)( pixel        & 0xff);
+                    } else {
+                        /* this assumes bpp == 24 & bits are packed low */
+                        /* (probably need to use RShift, RMask, etc.) */
+                        *dest++ = (char)((pixel >> 16) & 0xff);
+                        *dest++ = (char)((pixel >>  8) & 0xff);
+                        *dest++ = (char)( pixel        & 0xff);
+                    }
+#else
+                    red   = (RShift < 0)? red   << (-RShift) : red   >> RShift;
+                    green = (GShift < 0)? green << (-GShift) : green >> GShift;
+                    blue  = (BShift < 0)? blue  << (-BShift) : blue  >> BShift;
+                    pixel = (red & RMask) | (green & GMask) | (blue & BMask);
+                    /* recall that we set ximage->byte_order = MSBFirst above */
+                    if (bpp == 32) {
+                        *dest++ = (char)((pixel >> 24) & 0xff);
+                        *dest++ = (char)((pixel >> 16) & 0xff);
+                        *dest++ = (char)((pixel >>  8) & 0xff);
+                        *dest++ = (char)( pixel        & 0xff);
+                    } else {
+                        /* GRR BUG */
+                        /* this assumes bpp == 24 & bits are packed low */
+                        /* (probably need to use RShift/RMask/etc. here, too) */
+                        *dest++ = (char)((pixel >> 16) & 0xff);
+                        *dest++ = (char)((pixel >>  8) & 0xff);
+                        *dest++ = (char)( pixel        & 0xff);
+                    }
+#endif
+                }
+            }
+            /* display after every 16 lines */
+            if (((row+1) & 0xf) == 0) {
+                XPutImage(display, window, gc, ximage, 0, (int)lastrow, 0,
+                  (int)lastrow, rpng2_info.width, 16);
+                XFlush(display);
+                lastrow = row + 1;
+            }
+        }
+
+    } else if (depth == 16) {
+        ush red, green, blue;
+
+        for (lastrow = row = startrow;  row < startrow+height;  ++row) {
+            src = rpng2_info.row_pointers[row];
+            if (bg_image)
+                src2 = bg_data + row*bg_rowbytes;
+            dest = ximage->data + row*ximage_rowbytes;
+            if (rpng2_info.channels == 3) {
+                for (i = rpng2_info.width;  i > 0;  --i) {
+                    red   = ((ush)(*src) << 8);
+                    ++src;
+                    green = ((ush)(*src) << 8);
+                    ++src;
+                    blue  = ((ush)(*src) << 8);
+                    ++src;
+                    pixel = ((red   >> RShift) & RMask) |
+                            ((green >> GShift) & GMask) |
+                            ((blue  >> BShift) & BMask);
+                    /* recall that we set ximage->byte_order = MSBFirst above */
+                    *dest++ = (char)((pixel >>  8) & 0xff);
+                    *dest++ = (char)( pixel        & 0xff);
+                }
+            } else /* if (rpng2_info.channels == 4) */ {
+                for (i = rpng2_info.width;  i > 0;  --i) {
+                    r = *src++;
+                    g = *src++;
+                    b = *src++;
+                    a = *src++;
+                    if (bg_image) {
+                        bg_red   = *src2++;
+                        bg_green = *src2++;
+                        bg_blue  = *src2++;
+                    }
+                    if (a == 255) {
+                        red   = ((ush)r << 8);
+                        green = ((ush)g << 8);
+                        blue  = ((ush)b << 8);
+                    } else if (a == 0) {
+                        red   = ((ush)bg_red   << 8);
+                        green = ((ush)bg_green << 8);
+                        blue  = ((ush)bg_blue  << 8);
+                    } else {
+                        /* this macro (from png.h) composites the foreground
+                         * and background values and puts the result back into
+                         * the first argument (== fg byte here:  safe) */
+                        alpha_composite(r, r, a, bg_red);
+                        alpha_composite(g, g, a, bg_green);
+                        alpha_composite(b, b, a, bg_blue);
+                        red   = ((ush)r << 8);
+                        green = ((ush)g << 8);
+                        blue  = ((ush)b << 8);
+                    }
+                    pixel = ((red   >> RShift) & RMask) |
+                            ((green >> GShift) & GMask) |
+                            ((blue  >> BShift) & BMask);
+                    /* recall that we set ximage->byte_order = MSBFirst above */
+                    *dest++ = (char)((pixel >>  8) & 0xff);
+                    *dest++ = (char)( pixel        & 0xff);
+                }
+            }
+            /* display after every 16 lines */
+            if (((row+1) & 0xf) == 0) {
+                XPutImage(display, window, gc, ximage, 0, (int)lastrow, 0,
+                  (int)lastrow, rpng2_info.width, 16);
+                XFlush(display);
+                lastrow = row + 1;
+            }
+        }
+
+    } else /* depth == 8 */ {
+
+        /* GRR:  add 8-bit support */
+
+    }
+
+    Trace((stderr, "calling final XPutImage()\n"))
+    if (lastrow < startrow+height) {
+        XPutImage(display, window, gc, ximage, 0, (int)lastrow, 0,
+          (int)lastrow, rpng2_info.width, rpng2_info.height-lastrow);
+        XFlush(display);
+    }
+
+    (void)startcol;
+    (void)width;
+
+} /* end function rpng2_x_redisplay_image() */
+
+
+
+
+
+#ifdef FEATURE_LOOP
+
+static void rpng2_x_reload_bg_image(void)
+{
+    char *dest;
+    uch r1, r2, g1, g2, b1, b2;
+    uch r1_inv, r2_inv, g1_inv, g2_inv, b1_inv, b2_inv;
+    int k, hmax, max;
+    int xidx, yidx, yidx_max;
+    int even_odd_vert, even_odd_horiz, even_odd;
+    int invert_gradient2 = (bg[pat].type & 0x08);
+    int invert_column;
+    ulg i, row;
+
+
+    bgscale = (pat == 0)? 8 : bgscale_default;
+    yidx_max = bgscale - 1;
+
+/*---------------------------------------------------------------------------
+    Vertical gradients (ramps) in NxN squares, alternating direction and
+    colors (N == bgscale).
+  ---------------------------------------------------------------------------*/
+
+    if ((bg[pat].type & 0x07) == 0) {
+        uch r1_min  = rgb[bg[pat].rgb1_min].r;
+        uch g1_min  = rgb[bg[pat].rgb1_min].g;
+        uch b1_min  = rgb[bg[pat].rgb1_min].b;
+        uch r2_min  = rgb[bg[pat].rgb2_min].r;
+        uch g2_min  = rgb[bg[pat].rgb2_min].g;
+        uch b2_min  = rgb[bg[pat].rgb2_min].b;
+        int r1_diff = rgb[bg[pat].rgb1_max].r - r1_min;
+        int g1_diff = rgb[bg[pat].rgb1_max].g - g1_min;
+        int b1_diff = rgb[bg[pat].rgb1_max].b - b1_min;
+        int r2_diff = rgb[bg[pat].rgb2_max].r - r2_min;
+        int g2_diff = rgb[bg[pat].rgb2_max].g - g2_min;
+        int b2_diff = rgb[bg[pat].rgb2_max].b - b2_min;
+
+        for (row = 0;  row < rpng2_info.height;  ++row) {
+            yidx = (int)(row % bgscale);
+            even_odd_vert = (int)((row / bgscale) & 1);
+
+            r1 = r1_min + (r1_diff * yidx) / yidx_max;
+            g1 = g1_min + (g1_diff * yidx) / yidx_max;
+            b1 = b1_min + (b1_diff * yidx) / yidx_max;
+            r1_inv = r1_min + (r1_diff * (yidx_max-yidx)) / yidx_max;
+            g1_inv = g1_min + (g1_diff * (yidx_max-yidx)) / yidx_max;
+            b1_inv = b1_min + (b1_diff * (yidx_max-yidx)) / yidx_max;
+
+            r2 = r2_min + (r2_diff * yidx) / yidx_max;
+            g2 = g2_min + (g2_diff * yidx) / yidx_max;
+            b2 = b2_min + (b2_diff * yidx) / yidx_max;
+            r2_inv = r2_min + (r2_diff * (yidx_max-yidx)) / yidx_max;
+            g2_inv = g2_min + (g2_diff * (yidx_max-yidx)) / yidx_max;
+            b2_inv = b2_min + (b2_diff * (yidx_max-yidx)) / yidx_max;
+
+            dest = (char *)bg_data + row*bg_rowbytes;
+            for (i = 0;  i < rpng2_info.width;  ++i) {
+                even_odd_horiz = (int)((i / bgscale) & 1);
+                even_odd = even_odd_vert ^ even_odd_horiz;
+                invert_column =
+                  (even_odd_horiz && (bg[pat].type & 0x10));
+                if (even_odd == 0) {        /* gradient #1 */
+                    if (invert_column) {
+                        *dest++ = r1_inv;
+                        *dest++ = g1_inv;
+                        *dest++ = b1_inv;
+                    } else {
+                        *dest++ = r1;
+                        *dest++ = g1;
+                        *dest++ = b1;
+                    }
+                } else {                    /* gradient #2 */
+                    if ((invert_column && invert_gradient2) ||
+                        (!invert_column && !invert_gradient2))
+                    {
+                        *dest++ = r2;       /* not inverted or */
+                        *dest++ = g2;       /*  doubly inverted */
+                        *dest++ = b2;
+                    } else {
+                        *dest++ = r2_inv;
+                        *dest++ = g2_inv;   /* singly inverted */
+                        *dest++ = b2_inv;
+                    }
+                }
+            }
+        }
+
+/*---------------------------------------------------------------------------
+    Soft gradient-diamonds with scale = bgscale.  Code contributed by Adam
+    M. Costello.
+  ---------------------------------------------------------------------------*/
+
+    } else if ((bg[pat].type & 0x07) == 1) {
+
+        hmax = (bgscale-1)/2;   /* half the max weight of a color */
+        max = 2*hmax;           /* the max weight of a color */
+
+        r1 = rgb[bg[pat].rgb1_max].r;
+        g1 = rgb[bg[pat].rgb1_max].g;
+        b1 = rgb[bg[pat].rgb1_max].b;
+        r2 = rgb[bg[pat].rgb2_max].r;
+        g2 = rgb[bg[pat].rgb2_max].g;
+        b2 = rgb[bg[pat].rgb2_max].b;
+
+        for (row = 0;  row < rpng2_info.height;  ++row) {
+            yidx = (int)(row % bgscale);
+            if (yidx > hmax)
+                yidx = bgscale-1 - yidx;
+            dest = (char *)bg_data + row*bg_rowbytes;
+            for (i = 0;  i < rpng2_info.width;  ++i) {
+                xidx = (int)(i % bgscale);
+                if (xidx > hmax)
+                    xidx = bgscale-1 - xidx;
+                k = xidx + yidx;
+                *dest++ = (k*r1 + (max-k)*r2) / max;
+                *dest++ = (k*g1 + (max-k)*g2) / max;
+                *dest++ = (k*b1 + (max-k)*b2) / max;
+            }
+        }
+
+/*---------------------------------------------------------------------------
+    Radial "starburst" with azimuthal sinusoids; [eventually number of sinu-
+    soids will equal bgscale?].  This one is slow but very cool.  Code con-
+    tributed by Pieter S. van der Meulen (originally in Smalltalk).
+  ---------------------------------------------------------------------------*/
+
+    } else if ((bg[pat].type & 0x07) == 2) {
+        uch ch;
+        int ii, x, y, hw, hh, grayspot;
+        double freq, rotate, saturate, gray, intensity;
+        double angle=0.0, aoffset=0.0, maxDist, dist;
+        double red=0.0, green=0.0, blue=0.0, hue, s, v, f, p, q, t;
+
+        hh = (int)(rpng2_info.height / 2);
+        hw = (int)(rpng2_info.width / 2);
+
+        /* variables for radial waves:
+         *   aoffset:  number of degrees to rotate hue [CURRENTLY NOT USED]
+         *   freq:  number of color beams originating from the center
+         *   grayspot:  size of the graying center area (anti-alias)
+         *   rotate:  rotation of the beams as a function of radius
+         *   saturate:  saturation of beams' shape azimuthally
+         */
+        angle = CLIP(angle, 0.0, 360.0);
+        grayspot = CLIP(bg[pat].bg_gray, 1, (hh + hw));
+        freq = MAX((double)bg[pat].bg_freq, 0.0);
+        saturate = (double)bg[pat].bg_bsat * 0.1;
+        rotate = (double)bg[pat].bg_brot * 0.1;
+        gray = 0.0;
+        intensity = 0.0;
+        maxDist = (double)((hw*hw) + (hh*hh));
+
+        for (row = 0;  row < rpng2_info.height;  ++row) {
+            y = (int)(row - hh);
+            dest = (char *)bg_data + row*bg_rowbytes;
+            for (i = 0;  i < rpng2_info.width;  ++i) {
+                x = (int)(i - hw);
+                angle = (x == 0)? PI_2 : atan((double)y / (double)x);
+                gray = (double)MAX(ABS(y), ABS(x)) / grayspot;
+                gray = MIN(1.0, gray);
+                dist = (double)((x*x) + (y*y)) / maxDist;
+                intensity = cos((angle+(rotate*dist*PI)) * freq) *
+                  gray * saturate;
+                intensity = (MAX(MIN(intensity,1.0),-1.0) + 1.0) * 0.5;
+                hue = (angle + PI) * INV_PI_360 + aoffset;
+                s = gray * ((double)(ABS(x)+ABS(y)) / (double)(hw + hh));
+                s = MIN(MAX(s,0.0), 1.0);
+                v = MIN(MAX(intensity,0.0), 1.0);
+
+                if (s == 0.0) {
+                    ch = (uch)(v * 255.0);
+                    *dest++ = ch;
+                    *dest++ = ch;
+                    *dest++ = ch;
+                } else {
+                    if ((hue < 0.0) || (hue >= 360.0))
+                        hue -= (((int)(hue / 360.0)) * 360.0);
+                    hue /= 60.0;
+                    ii = (int)hue;
+                    f = hue - (double)ii;
+                    p = (1.0 - s) * v;
+                    q = (1.0 - (s * f)) * v;
+                    t = (1.0 - (s * (1.0 - f))) * v;
+                    if      (ii == 0) { red = v; green = t; blue = p; }
+                    else if (ii == 1) { red = q; green = v; blue = p; }
+                    else if (ii == 2) { red = p; green = v; blue = t; }
+                    else if (ii == 3) { red = p; green = q; blue = v; }
+                    else if (ii == 4) { red = t; green = p; blue = v; }
+                    else if (ii == 5) { red = v; green = p; blue = q; }
+                    *dest++ = (uch)(red * 255.0);
+                    *dest++ = (uch)(green * 255.0);
+                    *dest++ = (uch)(blue * 255.0);
+                }
+            }
+        }
+    }
+
+} /* end function rpng2_x_reload_bg_image() */
+
+
+
+
+
+static int is_number(char *p)
+{
+    while (*p) {
+        if (!isdigit(*p))
+            return FALSE;
+        ++p;
+    }
+    return TRUE;
+}
+
+#endif /* FEATURE_LOOP */
+
+
+
+
+
+static void rpng2_x_cleanup(void)
+{
+    if (bg_image && bg_data) {
+        free(bg_data);
+        bg_data = NULL;
+    }
+
+    if (rpng2_info.image_data) {
+        free(rpng2_info.image_data);
+        rpng2_info.image_data = NULL;
+    }
+
+    if (rpng2_info.row_pointers) {
+        free(rpng2_info.row_pointers);
+        rpng2_info.row_pointers = NULL;
+    }
+
+    if (ximage) {
+        if (ximage->data) {
+            free(ximage->data);           /* we allocated it, so we free it */
+            ximage->data = (char *)NULL;  /*  instead of XDestroyImage() */
+        }
+        XDestroyImage(ximage);
+        ximage = NULL;
+    }
+
+    if (have_gc)
+        XFreeGC(display, gc);
+
+    if (have_window)
+        XDestroyWindow(display, window);
+
+    if (have_colormap)
+        XFreeColormap(display, colormap);
+
+    if (have_nondefault_visual)
+        XFree(visual_list);
+}
+
+
+
+
+
+static int rpng2_x_msb(ulg u32val)
+{
+    int i;
+
+    for (i = 31;  i >= 0;  --i) {
+        if (u32val & 0x80000000L)
+            break;
+        u32val <<= 1;
+    }
+    return i;
+}
diff --git a/Engine/lib/lpng/contrib/gregbook/toucan.png b/Engine/lib/lpng/contrib/gregbook/toucan.png
new file mode 100644
index 0000000000000000000000000000000000000000..03960d4939938541ca3f8efee4bf13ffdecbb2f5
GIT binary patch
literal 12901
zcma*NWpo@(vMt(@TFlH07Be$5GlRv<%*<@D#mr!V#mp>=(Xz$NEcMklbI#m(>%AXu
zud1#cJ2EmWGkdMBijHVyMJYr$JU9RVfG8s^uKIZ``aIKNAOHX`!oF1CrvbDSQ4j%u
zMHH|cr5gbN5CCO)b%{^?{|#6GI1B*%zje6(GU5NlRXmX=`N0_(A%xV>KIS3t$)QLv
zQPAKaY!jf6!6DFKA+BP;aS(tXOVE|;Uwp<0CBPx<gdhY=ASnbPaj_s&5?~~tAV{$x
z?!SYd{AT5&W8qaq0s{bkCqss(un;4lvcf_(Mj(IQ10fvj(>ek%2QX+9N}6AR78ggv
z7y<(tDDvfVZh(LUC<bE)7P^08xm_SQ82=GfJ%LDw{}4J(IQKEc^f9RWNoW`_fRPIn
z5jg}J7!Vs8ic=lJegKLF4<d~doQ4I$A_3Wm34#C%^4K1nUkmNCH!v^&9z4WDA2<pG
z1OfsCHu67f_=!)~f8*aRKNaMEEeq6t`N{sJ-~qr<0FeLo{&(PiIO6A4{0s2^75gb5
z{Y(Gci~qFz4?zHcA^dODf5cA$|NkZarvc3Wvwsvw@XtAZ9-sL4q@<yMpX9k0{NLuk
z_5bislb8x<Ywpd(hR7EJ0R|4>aDtRFhN+r_B0_*rDFZ%cgL7s9GZxYKaNytiAy8o<
zK4ankJ;1+)_%uHc3<!wNDPhAwzD+@J5PxY|MikG0d@ci5uR|t-hxoY&En<qn?|}B%
zzfcgIBo9JdcnUE&3@Y3|>!1etPoK|Y|FdGB%Ksn01O8|4J{$jgBVYkwFaQWRFz_wD
zcdvi$%1u>K4FFaS4p9LFfgquvVL)(YupoHQKUfBRfZqSbKFR+@Ea>gi5dR<H15^qE
zEtr5n{Gc*~f3&gxae)36bgiB7X}i5D7C7>;(-VdVC4xLbxrnJC%1@d03#v_sPy`DI
z#TlfBgvIoM42mg1!!%U~fzbW3@x?JfxW%NBWH@-~(jYE^qPPz?TWuREkU7XeRz^L5
z)zI>vp=|&8_%|jKPuzGs^^^~C_x@J`fdc-aA1WYukOQ_TO;%<;MIbQ=x!`vn5GPw2
zDEZULr+>x^0FVG=#6{G-*3W$5xfh>5grL|M$^WKI4*jfQiPuZU9gHbtfkr=&WwSL%
zv5i1cx)_WYB{v`4mr;p<qg0P+hN4`MfaXxov7_E{`?2(E?H1%G)v|teaCZFt_El)M
z=NFEV(WSTlcH8Xh`$t!=s%l_JNR86QFVjTX+1>~|&T`^d9t;6jdFSmVAcQM70jBuR
z?DCrr)rN21M1F^DwpOHf(0Mmq*4qpki|KZmt3(dweY4NV@07ejk{o^Dj1K4fcG!3)
zmiU_>G75d9f^4;3ONXdK8*Syu3Oq-&Fs{+WHBQPe)5^eBia)QXHevUq^>0j=YYxq1
zB+txJ=r8k!mYI=D>GaJw4tvu-T~01;PbspQHcxpxJu_VUW+NH;R(d179U8i_FNCbA
zwTha**o3-x!OATw-r&eCuV9z{C@*n8#^%rlbXQfCAf#?XG)O8QO22baFPc2fG>~X|
zd~hg+BxsqcH*37}8-u?KBY`s-bLaVS8kzFrX8E&GN<CbDM-Re~ku}U;rP%!D!~aL;
zq7yTUx01}z@mCnh^GffTWbB-+-Bc9%mDsA${h!E7<DB|DW{V$dVCP1t6yP-+?WJ_O
zmyK~7Eg$EJhmRY}0?^oqQVyOtxF*a~m;0@0>^6>mDhQ10CbQ3L<H`F;(NSX04XkZE
z8#d(Q+}^!@w+y0B)LOE#0W(ORg1p*hxbIce-+Ru7BNMeYO<wUl_~kk29M#^TZIcy)
zD`odX_s5kSlha=uQwFb&e+@3jm8||2`UwkbS>xi=&_;aGYt|XqdtN;~3<tl1Q(fr%
zjeDYTzR`j?Wu_BjYKT2zpQ)LIV%Atz{%{vp(NPvpNj+j;U?-;@_&Ti+FgK~g@aLPL
zWmeo&|H4y9^W-C5eb~?QtV91AMH>6;Z*~)4-@L|zt7WFJnPXDgMrr8A21>xD4=rh$
zx`f?YYcTI(hX3>x!gd7Bzll48xv8_uIG!QIPa7CH@SCu)u$W9qWmWB{dV;-)lU;gy
zrZ~1WzKNTO9kl4yIfN7!cOx6JS>3&o@MfSeR}o<2s$6g5b~aL{=3Thj#yPk%H&T%k
zMei>yxv*|<cGJIO1yYj_Rt<BAT3^hdvU&i;1WaSP!zup)!MBFOfG-+Zk(Kpi$XySh
z-Jx{u=f{w*3pTU36XQ!BrtxOq{hU}8_j?O~az&4$!8_w4gg=EG?H4D@Gg(;^kul@!
zqmbQm-{*-jC#4+56w^U&_dKKUMa3sJs?A1bE8R0fC`A221eeXTfv@F0VH({&nybo%
z6s1Z0N#zufLk3>_41?~8XXWyxJEjpdU9Ytvo!J9{E6bqAMJ|57^@09uM(LNqjWbvT
z=vO{Z`o4IWFz~a-5L!6QqXIU&K;9!WpZ#muwl3C|aK~E3-!<A2<&n>kGZ^AhQkMD-
zNVB@qHx)LBh%*!J=)fRmn(Md1ij+BYU#uIq!iaudTOu^1NOBc$-e6LMS-%EXuu?gO
zOO8z476;7!Q)fx5+da3Z(6O%^&*3B|=+Q5DhO92EIW?TE&H6}N&MUQ|`=)W~N5d8q
zeZo`dV`JR*KInu?DgHw(6|6s=R?OM@9kyZPjJBuxf^aGV4I3B)NA54~PWJ?oeO+TU
z0{6K^)5-3oX|(o{5Umk8vaAb^um_P!DySz0jftfY9h<A#no8T+q&NB4*(sNqn94U8
ze`?aGZnSW4b#444*w(q8`<CU57Wg1B0q!DMEWy6XL4btcsYy>|BQH<!t+&fd%|965
z`Xo1m?F0;GYY5g9B|Kr>Z>4u};|3qQZ&8o^Qu2Et)yj?hmk6_-CjWtv)m5?}1ryI;
z&^H#i94EsMvA(`WXZqyIvH9nNpGf%$l`VZgv`n88sQFF55!H0Cc~3rg(wXkcGw_{_
zt;m$MVBwIOexEax%UEk}WVC6%5bw}av9fyUw9l{+f9MLhh%5Jj&KmEsm);H3icisL
z+BH8OoOg#*(ZqFs^_+<Y#8Mh@9h)2<XV;wl@o;YU7z1L!NJAF#U6^+@R^gAu`C-#M
zYgf@E@D6kfDpFP7-Ydhx!Zx~e7K`FlacXgPlwGQ(_<vDzv)79(XTpo*NEu9#+UrZ0
z!X6XoY10wW6{K7{zppQ{JULG0-`mSvab{)R;C)G71pl$`I2M4kOk3M5z<M|sZ+YfZ
zvF^eu_q}0t>l!;V2TmCV!|!p*b~q6ndvDZ!*IIy8@s%}mJCUoS%mJZR9PUZ3C~-fq
zNGyCRYe}(mtu>VkSwi7p?PUWz@tDaz?rliToGWq!+wLxr-p|QvBv5N2^h&_+2R>4|
zSwNGJj3cu3rVx(~Wp#6DW4pX2&+z+)@SO;q-lLMB9wnKp<y!hz>&kC;6Z%QCvUGyd
zE!hf*uX~bfZv;Btn7@zV%#}1K^HDQ&bktgdP6xNgWpzIc&LS#DXeMRfB|v;|trpze
z+7MrXq_F-Vi#&&2W9OHI_p1hh)qt~e1~(j;kQ<w!XQ37)UrN}?Ua}*U8bbQBbESN!
zvxwT%iDW~x6Q(H@jc@N-Pai>lT)9V(bPqf)j<iF~zM1T6dV5yeo_5;_7v9&F$2>$z
zh+EL~V@);)wPv${r7UT@SP;d1+<~o}_4oHzha%+wy6OGz4$ceX(s@_LQ_XE+*{_tj
zzY;3hmCedgXs;rJ5L%^xZy81b(eV;PqG5~A8<n+@v7&ZLg3~%?2Wm(wbC(<>ND9{+
znpdmTKs1^HJ!GU-vo_A1TKW3%II9ZohSLBC=bn?VYBVL1=&QKCq~EIRCxQ^MOA4-4
zeyrWs#@9`2y+J3eb%aat*UPFrBZ%EW)7V5IHb?0ySbF1~QoQwTcNMxB`MKSZR)@qj
zr>9I7O6k9U`NfuRLGux8qwmyq03Q48TZB$MnE2Pmo`|4J>K|qsf2ADZi*&y>sTtH`
zgcG#o1~}93vpG(tHbJIM7d27<mK=qX6=WC`8Jfpy+B_$MtWa<&>Ss~Y;g1~`RAcQ1
z6(#w-bz8cbg=P#SG<0NSRAf|4L}K-42a-$7B^L25OH5?LeQ$2^$bIi;6>;V7W6HC^
zhxv2z!)0W!V+Y7@533S}kAfHDw_#;9tA4Q6qLcl^RqBN;suUJJMVm-Hx?4NAn+}g{
zK1BV_n@+Yc<PpQ)n2-P*B|*sT)ig2!)nxs&W^iU0BeDaEim19xEjL*5+{EsB{ar^C
zmZ!~GoM!#9O@bD^@;#J_eHl$l!HJ55l~Yl;5ZEaPe<I)zynZxD9AmW@9y{)Vj#qh@
z-Odv~z%Rv$JcmE}w5@IwlhKfEYGo&eZ2aRo8$*FpVvmpWz}{L0vJ$)0|K59EltAZ*
zh=6Jgb>o90byI|G;J4EXf`D85l{mgB{$JR?;=aC&dGU{>4TNic0e#d01+hgdP$wU^
zcY>MpA`HFEkY|R($Fb`U3ko-P6v;l)B&MWU#?}HjYHFt@j1l-jxWj*IYd8E?i@&Li
zuJ`y`*M5O|v*qA;eOV9Xl1eA^%6t5?x|M{D+)6jQq9c{#!+>Qkeoo@)=61w-{#{{o
zDLyWaUqHb3ZG;eF=Et*v9T@mM;TWHXqmS#Z=v!MLs1s?!oU_wi%JzLfUPXmcii$i2
z^RSRY<=lz9%yw)mPf{o=rE|XQ<fNm+L;eb^&H3ks?VFp(rbxk)+Zb-f*|sts^2uae
zh*jKVG1oOVoNkkWl6ud2D#uPgBBaMEn}CpWy_!Ntyn|_oU%XqR8S9J{LFh4@@giK3
zGzFo0Aq)@C@6BuLM<n7v)B{a#Zg)<bzx%{*<+phbvo2cc`ApLEFZ%cowl%Z3`5fHI
z(K|}3t;vGzoUB>V5LtNCI?n}F3ev)`DlT%IL!%hof=Ts7HQBvf?PV^;fC9Pa#k0m4
z0iVD6JFX>pIW9sid^x`xJhs-2!$YYE)mfh|Af?_y#0ONCv@-Yw)gAR%v=I6+)Zxfe
zZ^`l)`sT|+Evh{0%F9P#Nx%uxO&oo_e8;&7f%pLQL*M|?8y~QWU|4E`ATAMhE#-dO
zv1C7O%XKpi8wN|e%3$_I&7MpsirDxL&C$B@qIq{CBz-L%!J=!)?yu0~t|*vMpQlgO
z{1cg~IZ?$9ECKiM=G6f^lViao;%gCOYinJ(*QGB`Z{xkge&b-gQ1gq@N(g%zlkold
zww4RGYv&)!zlj-sCgSsUZ)KxQ#NF@n?mm;Z(CO=S*u_On(5(5ARFO(rioF-u6!R;m
z-aPhEGlI)Wpl2^IHJ;xGynN_tJ3b}X;$CSnMY7kacWUnLdbU;S-xfV2FQU5wd;42C
zPIfQsOI7$bC)9<ADfVyke<~2wdnbKAKEP_!!h{kmt|=S47gtDYYQ~T^R8bM>7hpYG
zlz*F)g1k>t`XksYBS%+CP{Ey4RI}IPda1}Urf)*4ftq2cwHG+%W>VFu7;#qNxYZ%#
znlV8}R^QxJlmadtQ)<$5Sp!yvk&#x+JBwX{>H46_@7-EGXMp<f<rnMmPBzq?bL^(o
zM^Wz)hz>k0t|X6?c_I}m6lCDQh%|_Wq<qi9kD$G9?1%C7YG>E7pZnbDaOSEZ{Qa1(
zpd{GG8=M>bx!l=@<!G4~NT@vfy~h<=bX*z@E(u1QgH@a8p`OpHH>oF~R*YmSO~1S_
zC6>fb%f*}0tdeFNWXn=PyvU3&vtEjXB%Bab+Rd>=w`srb0lNO1)_R<wDCp%OWb|xA
z^EXU7Nr1{J>YzMWFhYs%Zbe=RE7wLoP2KrX)$=J*zBeGHnyS|-{Vs5h2MHbhaC(}d
z=J@WzX`^$x5?gM86-h$OjheicqVrnZXUH&3!jtBABkcDuSR^r{z%;QGjZ#o@KeGGo
z<U(XY6OD9E?W2+-wYolqw1{0zJQPVl!LxUc`)T?Y6aqIlz-kFa$Mmy^J)JV;^zssy
z*1?vRL5YX5Q(?r1PUFXkN?mujI}ZU4!W;Herzkqu7w(@SqPG`~4SSmsuHsH!3bv8U
z0mCeZwGlT`745O&!2=PBUyNbm3JSF9*>1@=wf31jmag{sS=3!?W%c`i35#roAw>4~
zWct=gq_&#udL!parJql4W&NpZmY((^WuJ;bi12}!p7~Oz%OYv4Z{X5!C%P`7Y#7pX
zFEKqH6=7-KPUBn!7t0|XjOZ98{XHA)^p;(+yWnKWdXT(2E4EMy&+{keYd%b{&Dq}A
zxwCBk?o<CeDxQKa6qMS_3*L7?A96_=;O|CUb36kB1Lcp5AD0|?H~HTK()81AN5_R<
zxh{9WqQt~QX|8n;6N=+D^<{gHRo*s^;3I2Ti#S{L>#7~?dh~Qs{XobY82wh~kBrlN
ze84+V1R&<?k$!xG{oth3b)QyI5Mjh}+l3Vrcy8UAD(0h<0s!mWe_3{g%a)Y{JW1iD
z%UzUr5#aR<b<-95h?nzzsTd-?t9i@IM)th+07;0y#i_;hr(nQ9SJTii{nz3mJO@~F
z_LLW%sL29aL3+yB@<9=bUYk}HD&j01Sz*tphp_<sM6&pg(62(3x17cm1$c*bQ#>0b
zr5x<+928i$UIrogsj|q!-?QbBXXWa+odPX26FTu0A(YisRrR^gd{PSbeX5OI!4S4w
zk<|?j*uhK*7P7N#SbrTl_c11YTh`9fX>8-(G0>0^F~p+ckx5EV|H$P>JeTQ2O!f5W
zA!T5=G`uHqjm4HSs^KtW=D?ulv|U*F4G#n#K-$<lw?Qcx)^=mA-q2}GTwkj_BEOOJ
zjqSQ$=C~f3tAZF-P_yU)78dZ+ygGQ9Z5APKi&LC%txwHV+0L-z)ut}<<dFzg3oR}3
zm15%H{9K;W*3KKUEQv5nZ)f8DnyS6ME@vQKgP*%?<a?Cx6$R>r<eNw?MxXPR_`qyP
zNeOkI%L*C!1I$dxbQ7Y$@|wRweR@#kFf$4PLtal0t~OipSXL&pB0V;hw?rvX?3jk(
zqF}t_-#IJP@kF28rBH~WJJc)hAu6_OT{35e#aHH5)B@o9>jECg!}V?X>oS9N>0FQQ
zrQg9OM@6bAg$Jws@^zH$7w*#o9~#c+f|*Seqb7|lRsU_3q#r*<FHOWB8~n72+c#aU
zTw`ePLs^!@WD}~sP;EQQ3l|=R_MDt>t)&MrGP-)KUYvK|RYU60s1i{L<gH9iJ8HYk
z)*QD-vkW^iEIGbV3D+bLLE6Q~$D@Zza*VFoDJVQ-mX?)9*~pX@Nu<kdZ1n0X*X2>9
z?5aBC9OH!hMVLkH7Rd-49Hc)r7NaY>TKqY30*7EWwf(b}ZSWg0L&4gSxLA4hyc!mv
zHMXW};7c7h>z`=z;s$N1U*&^)*$#X&Yja7})v@x-f;JFXXU6t;b4!vYe>pnY36I|x
z!Hi=^ZJWSk2CvqgX~LgrdwCR>Oije)+2Ix5@#HQFk{hRHY$tzqAYly*4Ux!akc*8%
z%<ikMV#uQGcNUO*JR<OulLW;c{?JHUYVr`+L7P`j2RXywnW*Sc%o3qR53y3lYWK`E
zb6$9z6Z%R5pa%PX6S|-IE3BQ7#F);NiDBnJD;ndNhWhg|BGV#$6Ho{+$9HLCeY2jC
z+NSuL<z}iNkl7}mSyrZ9%!wxBDIjU(=vXCn2rqSQ0E8#$6fYrKwI#xwT3&kRmL`dN
zcY+*}Z95*PyLVrUPtAH1I+1ByuRE<fz7FM8wQaz$jPa~3-O-nuII;lb680hf`6!9i
zUPcbTiM+<%4$yn?tPg4=KJD9{%QiquYizub)!vhORY*jxn~vPv`t{5IVzZr%JWsNX
zmv_vJiUgg&mJ&Y{w4dK1O%YhfaDzjkT3Wgjz_;xVc4ndisR?PFajFz1;GRD_9~F0R
zH(1AFa?k9(A-OKK{>E>k&}il|nti(BY+KQ0vm0dtd?(fdo1|2P<~omUo%no*-)ni9
zZ@YG^EwV_|&kAemd9EHYIiI<EO8WdlS;Xr<zQOwbiafJ)Q(K9Q1;bnVb*}-fqx6+b
zf8g5K+HHM!k&sW9Y36Qt)F_I!^0B@q+N+1|u=uWA0Xz1*2gxY3I1ksP1uV0}!|cqy
zI7gp9K!8d(D5Mzp`69a%t?Y<w$IS<2H#krxrhlqi6oBBKTVq{8JEiix>eCQJzErP}
z7+uU-kDry@itDT}Zgz%OoSzgzl3UQ;szU|`tC}`C&!YE>JTFZ{Al?bzNx-G#S=&pZ
z5N_35&;!qr3iq^sXx;q@Jl)d4^sFv%tTu9wy9n_Ho#|&7Ibrxw>Y8Tuyv;_#mVu5=
z?US|P%N`)<cO9gMo#Uao{i^dX*R7RCd3JY1+%Z4{ICB<7l(~>-Ql_+2e=<VWR-#2~
z#HB`BT6(&M+idL^ystB?(;Ison{`=&eaE4s4?_2z{Ja%9Yq||EOI8m$3z$m{vkL=6
z3;r_*Hkv+|#YZWdl&&$c_R3FIZ*mFF21z&*(BfmJnV5{-EM2#QONGS+qZ5Oj9tXks
z6Mw>SS5(A(r!~@AZ_st85|gSvyNRx;M*ChZ&bETRn=_sC_(31*z+ASq<VB?YSDC`P
z8DDuQQwHqsC2EW&{=Q@LkuIzZc6k-bFH+{gEJ#MI3iX|lvK-&}ICcJnS>xYA5j~!7
zz+Z>95r=MK1&J5-92TeZ3%b?cJl9{4GQcLlhi$U4*St8lbI?cqP1(Zd>^6Jx;j`ax
zBeid(n5O%%*FAC|1;2iO^fTLuc*^WV4TlSyGxPZ(oj!W|ckPt&@K2}QUwGE5^rC*m
zQq2rK1HB)5oHLwA^kM_g;DW3Gm>czJ#{JogNO|<f!`C0hG;IYx%8ycBmS0$sABv?k
z-KR%sq4iG#opKSx3co)4y*w)B)Tr7&{tV<qHh!qqSlx~dsJUo9cYd2n7(bR(P?48x
zUb1ubu_)7v>IIo;_W~FJ^Dg6GCJi(BjjNK6YjH~xxza9vOb~g!o4Mv!P`6MP4{>zw
z3QOeamD+0q;b?H)VE;DzCQqhoc7SYb<=ptC;{xq!<+t-%y8qlaE~lhuZhQ%UZuh-0
zH0QKKc+s<wJa!mwqT3WQYNsg?4-1<K8v1!J{li`?Jw;Vt!$SIG|HX7%M|MJ|la_YE
zh1>{xSX^kk73{>Q+^;8*?$j{3r{!Kf%6@+<_%4DTGPBEfj}qitn~L1$3)xchji99_
z2Agl;!G5)&eh9QjmOZ^N;mbxRR(6Zmx>(Y?p2~#0aQJO+;^1InkN(O~Q$$6?u#%gM
zV&lZb+HXAV>Qy%Xup;y3&E4y!ZeTNpVO-<lMj5}2{!KedFT4aAfs(h07TTtD#0;Zk
zt1~C-)jL78$>uR%VA5Snb-E+a$fW{CSP;2BxjA>oze05R;I6jvp6{YVU|d)H1wqYC
zX<St;Xq>jHVoD>iiFPCZyfWMK23~DDkHEtAH2vAH{N$^uK_)o0VnG?l;%lz0VD+A*
zzdB&N3QJ0G2R$pNzU!x({!3dpr1IEkumm2jh`W}`3)^&s(1jsr>G&=7pC@;w7xZ#G
z|3ReXWgvL)j4?`0<ZB419sqyw!{SI=TN^<vbQ~?^4baDWBqK_Za@`w-clO6v0O9IL
zSc<%y)XbF~fpn3SIVB|p2oAO=Z;1e6GVb6;IePHC5RTM9T26t;_*H%>4TF~lK|)G;
zBccI|GD3!Ob=%)dsQH1cn$Ka-*Ee^JVC)JENl4h^he0a=GP7?&yE!1jqK1csx*%S|
z19T9v^E6c;tz+rWggSS9??Wfx6N+wm{%D*FX8=ekgkyQ|n<D|>*QhBe1cjl@)mJ<r
zitJ=5T)q<NTRX6<dgej5LKHK~71&9}2q$)h5SB4k4qm!s%t6lD;Iknp7<-rj<M!(h
zpNV#r`Q2K*oE)WG-lZ;gI=3WrmrYIqdVbf*)Uobi9*`#E!)p&}n5eLnE2q>Ks&qX+
zb7KdGo|}YsX0RA0q~*Jho^0&aQK+}Jj@Gj6$sQawJyy2Vhdc{e*{_TiD{UQyJS^7u
z9<0x6+ZZiO$W2N?6$uKz<tca(n4s&!H2z>((2WGirarxE?mDEAeoV*Tudz_#7qiwB
z761LabLM+@L|Pz~_;9{~O$_3EQ5I3xo!me3(E=qMYw6`398}Qy>BMP;15DgQBA}#1
zIo%R^dNQqg7J}!6{Lkthp7*5^Mb+M<GMJ1U$O~_SprE1U<cI~=AE}7&vgpU6LXaTD
z^m3F|m&N(F@`~w^UsF&ZuTECAKf)rQlx~J~I8Az7?A+L$zX9l-ahjxUB~yf>!U%9k
zqghj=LxtyYi#e+aKRDqr2z{71Ftf2BC+eare&&PBhmR<O2CMDay}Eu_{OPNtYFyL8
zqPxt@splmI3OL@t6ENadhl>@UM4i|G$zWfw;Opz^B*~J0)8@~4+69)@)}G(p#WrYV
zAwQ^Nb_D9!VvwMMGUtBh+OuYop|wP*1<!=QHsVq!%JcYLoZVS^@u+GuVq6^qZEXqd
z3-)^Y`#V$CmKw6JQZ@ZEdm_HfKAu&2VR;wOwq42bwP1q>>(}+8b6MkB;mX$<;8Pn0
zV>2Ee-+J-4q8J)7qEJw>;Ala=5{(#*t!jgRrg%DBz6!gjdLA#Gc11CaE71a)UfcQL
z)tX%XEUFi*K1p<!8VMg>%^+Fhq97tflx1fRef9SzvdmQgC;xr&yC5#C;9z~wtGXg9
zlQ(GYUi}smg#HCelqykcW}Jo1QSRo}653-Q%W}Aqnr19;H<_9{AA&F+7e`pCqYrHs
z{Mp)Rna4+Db??9eDi<&$rL0t5N<meIr0n5gWo706o-8@e?>^tR7eMWC=pVh>jqw<r
z2PXPnX($~bUZl+roy3NE1@@Wax#&k^BJS~qM>K<&0AOHZLK4bkOc~a}cSBRq@suj`
zerx~C24D9&1$^i&l%?nkt~~{%`;x+<6=q$ORhIn#6p!$}G=1=Z&A1DK4Jk0m6>=jM
z{SFt?oNELK!+_O<M!b?nCHX5xc1JLG(1B!lbpL#Je8(b7DGt=!gqJ~00&}jYgiRq=
z8iev1Z+d(xFgzLbPcZ<79c7_Wqipjn@LGQRknn^SO*n6BQ3yo!_)LQq?H<<+42xns
zLj}?gpjzTRugt*8yTtK>>9@D76pR;Sz_iEq&&{n<`Hval4BX_W;s8kc9<LPKL>3X6
zF?ZzbH=W@o@DoIk2sLkM-^{4Ko$yO<BZMdp|0qv3_w}@BXVRRXVMoh;-Ys{OCZFMQ
z>UVuIzJZgSn3#xxyZLVD@9gNvbd^pDX!Mk(Qzoz~Ll&Lk6^sg%k(opS*J6~8ZC~*@
zX`n#qFn|-vf^Mo8P=?urCp^H$E-NwHKO7R-ySS(;>v#&AN|hj+ce<olQ^XVT^yuh1
zwWO)u$G+Iq`M$s1TlHAu1%pQ9l?6WV9nKC8s0vK>ZC6%C`k04xWV1L`+NyPfpY?5M
z|8pE{@Ysf3zBf9J2u&?QUJiG2bJKJS(|VLCX5QE#lS_{+Z9`<${1}g);tZYH)#STd
zSFVJI_aN@muVsB48|g!eiEkwW0k5k|!VC^xrHBCoIdDTkx<%(Zx^;X7J?jx%Q4WR3
z0Fb{dNBo$Mk}_%3w!)i~Ff5$iP+DA*frpAS4{Z_Pr_Yj?lS4+f@76}bsPru-2^0I>
zBEwJNz-k*3LBgIOI_MNaQE=YBIQYsW!QY9j@ZEn`MguN(XrOSupJ!bi{ZKJmt|7Lx
z?Z=O{F?<xfq<n|78yXhmC%4q)Ib}ztRlNxCoFU<ruZ?Rl?jvvc;iAF9FwEP0m?;5G
zg=cc*(8`pNRLK?Fi^le4`y7YHaA{PyfS|nFpYt*<56fmSJw{8mP<F^ecr1X`4Pd;#
zyn+H`ok7FTFV3H}L{I<J0#twgNt&vS<QIW7?#$W3Lm}Yms<DebUGds%(7cvzWmz?r
zQcZIM-*`3@Kj*W~+|rWZBjVFhrtc7BiZ&o=M{;mo5Gg$)8|PF-<8;2L8!BuC{8Ql!
zPAp3fl!-g4SX-<mb@29m2pCsSf+ENkFZSMc_=TZUG-^dgoOnu~UC6sMG!!;I^x|?K
zf|F2jB95dYNAEoa3FB%b3lH~)j{DMr#10Kjg&IuxamjyPg{3y~amC8^u@Z7;F90`6
zxN-&HzVJPm&;z`$=3;|<i`~@;QeU*#nOo=t?@S3KojJ!0(NN~If~J)jJxu3yc|9F(
zJvS+`8&f34rpC5b7wC&x<G|x0_b@qjJwh;qzvA=ecdyCEGz^T-`hGg%Zpapia5K`P
zXlaRh*D%e!1%*ej>$FVR(wLR0G%_-01}O^zq&eDo|2eylkDZ}MbkgRq^+x3tOcgzb
zOLpmqwIeitcYohla(@T#f8-9$6eDEYujBDVdWs`$d&u9(c`;^A@WD}w+ZK9`Mj0z6
z&cl8Qn$sqe<fa{Kgs-oxl(8<SZ_!_mu#6Qis+S;PR+eCNP3B#N1V)#V%`cRinwoAi
z#)gj#u;lt`=LshX1QeB$S>pL1?06hZ;S!v$PcR}t6^~-ZC;1>Cip<+N{8R;|dG`qc
zv}O9apixC}f+C3=zP>iCVJN_b$6Kn6^kq<GfJ?JO&BauZS<Wx8B=0}r<k%06)Dxvn
zo%adu9A4jvr)mpO)FAN*9}NyA<b3V1d2BpAIx0x1t92V{aHeO^hC;#fiAy{kcoyCo
zNxEK}f?dG*7T|fuoB(DZXa`VAT_`&aT`7428h3Q8f?;q*prXu46k54(1lL;CS=28R
z*diPAc_4Ne!`NXbfmc+C@|6q_JFLi4WlMb3&CYaTv6rWXS=?5qT|ydwNm?_>q*6D|
zh=?F+p`PMSqJfi8Y6!MtVj=BMo-wkppKTyMeEAKrn)GyKdd3I`HMqR@>-mo4n`u(e
z?9srF>*9ppD_#%OzUq<FOY=~jEg>mYzD~{;br8wP=AEtOLzT220VMZBtU5jVaA_O^
zA!DgPg=_t`TT;)Y`DWA_CQb3vv%6n<juT6WO@j8$QswYb@=U_Bs8P_f!@n5Z&KUeR
z{FniQHk`tumo5ljPZ2DH!4^0Ly6f|mMiZ@h7mnZN3&dMF_;6_Jn^a?5tMfR-yXu^M
z!DyGe_Qp2-(sukgmq+o1$u{DBe``z5x!UCY9!^~{Y0HzbNQvt>r?+O$?x>?7>Ar+5
zC!}9KHDTUll=4wl7RJt*H0IMqKlAtV`w7^z$_Of|Y}=N*iPP?%8h(+~S{WhUgL+07
zIJspM`uT!<mX8E+Y&Vq7fa+b(RC-B#<>&#KRSMd3^STKZZP^(-Vsr7Gj;fo*!<tNt
zyPr3>{2M#GzP6UNTqNIU<h%Y{ATuNA({bv)l9<>Qt69f>qXxZ^R7~C`#}tLcUlLm@
z<vH}1rlq)8#OXx{@;!yu_Aw&kbz2m@UPVPy6T9agPk+|kEb;vbwBEj+S++pm6(=fJ
zC@eQ3Z-y_*c5eR$mZi{9IgZj*C@QN!V;C0?i-(=mDxB6dtWAy4;TJZgT-6MuQ&tv)
zLm-t<$*y&yOj1W7{UA}Giq(l%5yrv5XU@$PxGarJRYCY6#<@0h3oQ%7|HyMFuyc9d
z$(MZ=r0(hQP)Tz-qa2v;SW;kYcCe|esh82(&i*wrXb;U4hYMXO78R((k2`v>%iWH^
z!5JZ!+tjH37;J@$zqJ5CcLfDJGf82PGo>Wr?eFj;Q%UopnpXtD#=IkRP&D)fR{<w)
ztWhTMT@2pb&ay@mdx49}%t236kR5Mu75z8xe*VSC`K8o`Em0l?EUqr!=}5ZHLUA(K
zBufT_645)U^!1NZzo<U!4*uoO`(-%JJ4`8k#4Qql3Afu>?`@ZrTF5J2u8d<wr#Wn_
zzggF+%<wC<Q`M|7Nuc~|?~W0F2BGieWLt%l2XR<UkECD32kB_7<$l3&SuVT4@o>8$
z7|V=dAM?Pz?r)gxtUuh_<K86jZF0rk^a#YMjlC~KKSsZ1{yLWb>jK-{Ermi*s63YH
zOoPFjCR)xcE6Z9@)$WPnt2rmhN^1$;bxi9c@JQ6_=l$Z=2nqn7vlO=7;lftqEU>b7
zP`y;QAKt~$3fdMRwQyyrbjoWZ*_-lZTib@b_G^8w>6^xC_zs9hXLyZy@4f?i94Vhg
z`!<fL<rfws7P5UgcjNubx}Gxe)A_HG9=jyfeT{aE@9p$2^Y|s@nY}%J4vjAvxPFkB
zu+lflki2<@Mj3R?=MxFo45cSggj-0j#-*|V9N4_LY5%XI+<&_k)f1co^v}|ov^_{N
z&xe_5u)m`O!+YC#yj89aX=|RX{lJYLt*>BZWtEj3qhtgoyA&>jk`(1$%ouJxvqG!0
z;rmd(r(?L^U<Awv-*`p{R#aVvcsSNg2J@R1#63xeLVM=BCA9wxQW=Y;`mQ=hfh=5x
zHsGDb#fSBmw_h2uKgA9#Aq?fF%kc9-rvYeb)Shz9*4LX}QKwotI{(#ARcU@B?6X#O
zrA|k$;I5j<zLAC_264}th?k%u_pQJIvl$=Li)m8otFf-n6!^?Ql0WQs#pBf>AY)oU
zys`^7JnJTs5R};PJSWaN88C?;PdnmaDM=a!1zoNcbpbaG+hGcl94!OhJ%Vrc24f;U
zn_Ar}JZzz$!0y;;Y1zJn{$^u+&i~oNmc|vEiS2g>$XR~m>#$2Zjz>~vW)L}pVN~0O
zkWxHP3etDfsNc>^j;A<NGN|%o_sp~CR;jD=CS_Vx>TZj0=K3X?K7z4btqW^>3qpOp
zTOSwMqH{g(q$a2*3+opi_FD%d5&FH04&iWLu~Dw?Oh>ut`A!!_rZ|$ly<Au?g2E_{
z5^=&VAxV+HAad}|bwtNa3ChInR%UJXN%8T{{dPIRpj{6rF?wS24(z>(JY0I)s2wqK
zs4lnwlPS|!tHWJv_E^z8kB}JPNDm0hMdTqBB*hvX9_C3Egx|)B7T~n+-zWR51WFF~
zykOM&Gvu7d%$jn>t}qXVw-0sCx)1l4)<ELj841Jw`cUZ$vM1uYO@IV?5-#3M4UIi3
zo*tf!hepJExRY}N0XkqnK8m4|<*UbnM=vvp8g%ZEjOR--6Zp&wc*1$<FvRF2#LSw@
zdj1vq(bJAP+~1QOTHLBw^)zV049BVBvYU>Uvd1>q<OyqP<WPD$t$5wpOuB<i5?_;)
zcc$5Sb<Zg?<9e1p+$5@Je!-6lzIS1>y|xNZ2tzL7cugWy?lA5^(SCVm2*j-lF52V@
z+T%x*`0$QnzCi=sQ)sQE))$@5i!5n_%E;WVC-CQKJ}4QyFA?w54K&f~&R7^d6jIU6
zPj`1xfXC^L*Jscf-{V`m$+~`0;&)~W=mb49C_HNA&mUfMHzy)W1G*D==8R-$N%7Zr
zbF6;+e6*#WbR$n3w-0m&PQ^MyQ7YqO`kFbBryEFO%AgS@5>jnOMe3u_t_d?%4X*TH
z{5+BTylYAX%v=|+#TsxTno;spmmLhP@5DYGb;_LLVILP@C>fFS;v)~!tu~=`PTn(w
z@kq2sccr}peszs_a|jf~@0}a(6)VWFA|VbDn}oBIbW&_Bdy?$OI#a2_7$wSqVNMW8
zQ7moec)LT|o}Km&ELgd(qU71jCs@!EQ?R)buGTAc`(&6qv-!Bwc!oQ3r~BS{UR<7w
zzki8DO>^bD?$zuVE?6~FS0Elv9U$D^?!mf^V8)z$rNjVY<Ergxa#z~C8&<4`*1c=F
z)9>%ID;{EdFzTiE1K=;e9Qk<?4tmEtSmd;9{Kew`eW;$OnB(4&+(Y`SD4?Z%S$iX{
zNMifNM>gXl#UrL)nNm{m6wV0io`SMJnp7jViK_}}T?)OW`2<^`_|QGc(qUi8*gRgx
z{-!?xiX#<PMWk}R905W)-@B~$<z=LxMHZvK#=3z<t0n0axs^62t=gT2#}h&5&I9Y-
zFUQT^yuG3CH_o=#4$p@cj@ZDdedtYVaG~q3U$av48WI@iKP;XBjc}s=(pEn!3dMem
zb5ROivfc6J?K5y_Nr+rYuuNP1&?U{U3K`Wt>CoA7{3v@;VAO`^mfBIAxo(5^u@`?-
z)!O(Kd=k9Yde7M2WlPxo!YWbUs9DH}eX_B<*m^qYN+4D&rZb3)BF-KJ&P71fPk}$O
zJEdAJIYUf+tAU{x<D#`);C5(|^X6Xb!(_EdOvOseG_Hm<dAk?0@|lC=h!<tbSg~HQ
zfiN|F!gRN{HJG@nt*KcXR)}YC(!y@vtv%ofYt6>4?>CGnbMGE@jD1gHO+dQh(lR=O
z91<c)iJMrW9HyMkt`%WGTVh}9FzVJlW&Y6LO~Emu>6my<lCe%xwteIEIfsW;!#4^R
z;hpF+o9;ROko<KI4QGz-ioD6iLrPM6A|Z###*cwZtY%=Op#eeM3gYLF=qUBQPZ4bd
zwnQ93Oaaf!S#mmBZf;D_wc}vnQlZ_mFR<KK^WrYY#iQA)Y8`lGWkju;=ZwtGuINlq
z?-g1&@w2G{lW@EiD)3Ant3-Qc6b;wYIBzKReSbAc6wED6dv1L^UJ9nnqGF<=Vq$fO
zVL=9lVKG)YvMv|RyLM;eD#CAVw7bqR5}ECc9`aIv*ztH!;GPlD3qUPENJxJlsj)B5
f6#07~#Se&Sk-?3tS&oo@%Ijq$6vgXAjYIwqf?o_r

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/gregbook/wpng.c b/Engine/lib/lpng/contrib/gregbook/wpng.c
new file mode 100644
index 000000000..a8f367fb8
--- /dev/null
+++ b/Engine/lib/lpng/contrib/gregbook/wpng.c
@@ -0,0 +1,865 @@
+/*---------------------------------------------------------------------------
+
+   wpng - simple PNG-writing program                                 wpng.c
+
+   This program converts certain NetPBM binary files (grayscale and RGB,
+   maxval = 255) to PNG.  Non-interlaced PNGs are written progressively;
+   interlaced PNGs are read and written in one memory-intensive blast.
+
+   Thanks to Jean-loup Gailly for providing the necessary trick to read
+   interactive text from the keyboard while stdin is redirected.  Thanks
+   to Cosmin Truta for Cygwin fixes.
+
+   NOTE:  includes provisional support for PNM type "8" (portable alphamap)
+          images, presumed to be a 32-bit interleaved RGBA format; no pro-
+          vision for possible interleaved grayscale+alpha (16-bit) format.
+          THIS IS UNLIKELY TO BECOME AN OFFICIAL NETPBM ALPHA FORMAT!
+
+   to do:
+    - delete output file if quit before calling any writepng routines
+    - process backspace with -text option under DOS/Win? (currently get ^H)
+
+  ---------------------------------------------------------------------------
+
+   Changelog:
+    - 1.01:  initial public release
+    - 1.02:  modified to allow abbreviated options
+    - 1.03:  removed extraneous character from usage screen; fixed bug in
+              command-line parsing
+    - 1.04:  fixed DOS/OS2/Win32 detection, including partial Cygwin fix
+              (see http://home.att.net/~perlspinr/diffs/GregBook_cygwin.diff)
+    - 2.00:  dual-licensed (added GNU GPL)
+    - 2.01:  check for integer overflow (Glenn R-P)
+
+        [REPORTED BUG (win32 only):  "contrib/gregbook/wpng.c - cmd line
+         dose not work!  In order to do something useful I needed to redirect
+         both input and output, with cygwin and with bcc32 as well.  Under
+         Linux, the same wpng appears to work fine.  I don't know what is
+         the problem."]
+
+  ---------------------------------------------------------------------------
+
+      Copyright (c) 1998-2007, 2017 Greg Roelofs.  All rights reserved.
+
+      This software is provided "as is," without warranty of any kind,
+      express or implied.  In no event shall the author or contributors
+      be held liable for any damages arising in any way from the use of
+      this software.
+
+      The contents of this file are DUAL-LICENSED.  You may modify and/or
+      redistribute this software according to the terms of one of the
+      following two licenses (at your option):
+
+
+      LICENSE 1 ("BSD-like with advertising clause"):
+
+      Permission is granted to anyone to use this software for any purpose,
+      including commercial applications, and to alter it and redistribute
+      it freely, subject to the following restrictions:
+
+      1. Redistributions of source code must retain the above copyright
+         notice, disclaimer, and this list of conditions.
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, disclaimer, and this list of conditions in the documenta-
+         tion and/or other materials provided with the distribution.
+      3. All advertising materials mentioning features or use of this
+         software must display the following acknowledgment:
+
+            This product includes software developed by Greg Roelofs
+            and contributors for the book, "PNG: The Definitive Guide,"
+            published by O'Reilly and Associates.
+
+
+      LICENSE 2 (GNU GPL v2 or later):
+
+      This program is free software; you can redistribute it and/or modify
+      it under the terms of the GNU General Public License as published by
+      the Free Software Foundation; either version 2 of the License, or
+      (at your option) any later version.
+
+      This program is distributed in the hope that it will be useful,
+      but WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+      GNU General Public License for more details.
+
+      You should have received a copy of the GNU General Public License
+      along with this program; if not, write to the Free Software Foundation,
+      Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  ---------------------------------------------------------------------------*/
+
+#define PROGNAME  "wpng"
+#define VERSION   "2.00 of 2 June 2007"
+#define APPNAME   "Simple PGM/PPM/PAM to PNG Converter"
+
+#if defined(__MSDOS__) || defined(__OS2__)
+#  define DOS_OS2_W32
+#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
+#  ifndef __GNUC__   /* treat Win32 native ports of gcc as Unix environments */
+#    define DOS_OS2_W32
+#  endif
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <setjmp.h>     /* for jmpbuf declaration in writepng.h */
+#include <time.h>
+
+#ifdef DOS_OS2_W32
+#  include <io.h>       /* for isatty(), setmode() prototypes */
+#  include <fcntl.h>    /* O_BINARY for fdopen() without text translation */
+#  ifdef __EMX__
+#    ifndef getch
+#      define getch() _read_kbd(0, 1, 0)    /* need getche() */
+#    endif
+#  else /* !__EMX__ */
+#    ifdef __GO32__
+#      include <pc.h>
+#      define getch() getkey()  /* GRR:  need getche() */
+#    else
+#      include <conio.h>        /* for getche() console input */
+#    endif
+#  endif /* ?__EMX__ */
+#  define FGETS(buf,len,stream)  dos_kbd_gets(buf,len)
+#else
+#  include <unistd.h>           /* for isatty() prototype */
+#  define FGETS fgets
+#endif
+
+/* #define DEBUG  :  this enables the Trace() macros */
+
+/* #define FORBID_LATIN1_CTRL  :  this requires the user to re-enter any
+   text that includes control characters discouraged by the PNG spec; text
+   that includes an escape character (27) must be re-entered regardless */
+
+#include "writepng.h"   /* typedefs, common macros, writepng prototypes */
+
+
+
+/* local prototypes */
+
+static int  wpng_isvalid_latin1(uch *p, int len);
+static void wpng_cleanup(void);
+
+#ifdef DOS_OS2_W32
+   static char *dos_kbd_gets(char *buf, int len);
+#endif
+
+
+
+static mainprog_info wpng_info;   /* lone global */
+
+
+
+int main(int argc, char **argv)
+{
+#ifndef DOS_OS2_W32
+    FILE *keybd;
+#endif
+#ifdef sgi
+    FILE *tmpfile;      /* or we could just use keybd, since no overlap */
+    char tmpline[80];
+#endif
+    char *inname = NULL, outname[256];
+    char *p, pnmchar, pnmline[256];
+    char *bgstr, *textbuf = NULL;
+    ulg rowbytes;
+    int rc, len = 0;
+    int error = 0;
+    int text = FALSE;
+    int maxval;
+    double LUT_exponent;                /* just the lookup table */
+    double CRT_exponent = 2.2;          /* just the monitor */
+    double default_display_exponent;    /* whole display system */
+    double default_gamma = 0.0;
+
+
+    wpng_info.infile = NULL;
+    wpng_info.outfile = NULL;
+    wpng_info.image_data = NULL;
+    wpng_info.row_pointers = NULL;
+    wpng_info.filter = FALSE;
+    wpng_info.interlaced = FALSE;
+    wpng_info.have_bg = FALSE;
+    wpng_info.have_time = FALSE;
+    wpng_info.have_text = 0;
+    wpng_info.gamma = 0.0;
+
+
+    /* First get the default value for our display-system exponent, i.e.,
+     * the product of the CRT exponent and the exponent corresponding to
+     * the frame-buffer's lookup table (LUT), if any.  If the PNM image
+     * looks correct on the user's display system, its file gamma is the
+     * inverse of this value.  (Note that this is not an exhaustive list
+     * of LUT values--e.g., OpenStep has a lot of weird ones--but it should
+     * cover 99% of the current possibilities.  This section must ensure
+     * that default_display_exponent is positive.) */
+
+#if defined(NeXT)
+    /* third-party utilities can modify the default LUT exponent */
+    LUT_exponent = 1.0 / 2.2;
+    /*
+    if (some_next_function_that_returns_gamma(&next_gamma))
+        LUT_exponent = 1.0 / next_gamma;
+     */
+#elif defined(sgi)
+    LUT_exponent = 1.0 / 1.7;
+    /* there doesn't seem to be any documented function to
+     * get the "gamma" value, so we do it the hard way */
+    tmpfile = fopen("/etc/config/system.glGammaVal", "r");
+    if (tmpfile) {
+        double sgi_gamma;
+
+        fgets(tmpline, 80, tmpfile);
+        fclose(tmpfile);
+        sgi_gamma = atof(tmpline);
+        if (sgi_gamma > 0.0)
+            LUT_exponent = 1.0 / sgi_gamma;
+    }
+#elif defined(Macintosh)
+    LUT_exponent = 1.8 / 2.61;
+    /*
+    if (some_mac_function_that_returns_gamma(&mac_gamma))
+        LUT_exponent = mac_gamma / 2.61;
+     */
+#else
+    LUT_exponent = 1.0;   /* assume no LUT:  most PCs */
+#endif
+
+    /* the defaults above give 1.0, 1.3, 1.5 and 2.2, respectively: */
+    default_display_exponent = LUT_exponent * CRT_exponent;
+
+
+    /* If the user has set the SCREEN_GAMMA environment variable as suggested
+     * (somewhat imprecisely) in the libpng documentation, use that; otherwise
+     * use the default value we just calculated.  Either way, the user may
+     * override this via a command-line option. */
+
+    if ((p = getenv("SCREEN_GAMMA")) != NULL) {
+        double exponent = atof(p);
+
+        if (exponent > 0.0)
+            default_gamma = 1.0 / exponent;
+    }
+
+    if (default_gamma == 0.0)
+        default_gamma = 1.0 / default_display_exponent;
+
+
+    /* Now parse the command line for options and the PNM filename. */
+
+    while (*++argv && !error) {
+        if (!strncmp(*argv, "-i", 2)) {
+            wpng_info.interlaced = TRUE;
+        } else if (!strncmp(*argv, "-time", 3)) {
+            wpng_info.modtime = time(NULL);
+            wpng_info.have_time = TRUE;
+        } else if (!strncmp(*argv, "-text", 3)) {
+            text = TRUE;
+        } else if (!strncmp(*argv, "-gamma", 2)) {
+            if (!*++argv)
+                ++error;
+            else {
+                wpng_info.gamma = atof(*argv);
+                if (wpng_info.gamma <= 0.0)
+                    ++error;
+                else if (wpng_info.gamma > 1.01)
+                    fprintf(stderr, PROGNAME
+                      " warning:  file gammas are usually less than 1.0\n");
+            }
+        } else if (!strncmp(*argv, "-bgcolor", 4)) {
+            if (!*++argv)
+                ++error;
+            else {
+                bgstr = *argv;
+                if (strlen(bgstr) != 7 || bgstr[0] != '#')
+                    ++error;
+                else {
+                    unsigned r, g, b;  /* this way quiets compiler warnings */
+
+                    sscanf(bgstr+1, "%2x%2x%2x", &r, &g, &b);
+                    wpng_info.bg_red   = (uch)r;
+                    wpng_info.bg_green = (uch)g;
+                    wpng_info.bg_blue  = (uch)b;
+                    wpng_info.have_bg = TRUE;
+                }
+            }
+        } else {
+            if (**argv != '-') {
+                inname = *argv;
+                if (argv[1])   /* shouldn't be any more args after filename */
+                    ++error;
+            } else
+                ++error;   /* not expecting any other options */
+        }
+    }
+
+
+    /* open the input and output files, or register an error and abort */
+
+    if (!inname) {
+        if (isatty(0)) {
+            fprintf(stderr, PROGNAME
+              ":  must give input filename or provide image data via stdin\n");
+            ++error;
+        } else {
+#ifdef DOS_OS2_W32
+            /* some buggy C libraries require BOTH setmode() and fdopen(bin) */
+            setmode(fileno(stdin), O_BINARY);
+            setmode(fileno(stdout), O_BINARY);
+#endif
+            if ((wpng_info.infile = fdopen(fileno(stdin), "rb")) == NULL) {
+                fprintf(stderr, PROGNAME
+                  ":  unable to reopen stdin in binary mode\n");
+                ++error;
+            } else
+            if ((wpng_info.outfile = fdopen(fileno(stdout), "wb")) == NULL) {
+                fprintf(stderr, PROGNAME
+                  ":  unable to reopen stdout in binary mode\n");
+                fclose(wpng_info.infile);
+                ++error;
+            } else
+                wpng_info.filter = TRUE;
+        }
+    } else if ((len = strlen(inname)) > 250) {
+        fprintf(stderr, PROGNAME ":  input filename is too long [%d chars]\n",
+          len);
+        ++error;
+    } else if (!(wpng_info.infile = fopen(inname, "rb"))) {
+        fprintf(stderr, PROGNAME ":  can't open input file [%s]\n", inname);
+        ++error;
+    }
+
+    if (!error) {
+        fgets(pnmline, 256, wpng_info.infile);
+        if (pnmline[0] != 'P' || ((pnmchar = pnmline[1]) != '5' &&
+            pnmchar != '6' && pnmchar != '8'))
+        {
+            fprintf(stderr, PROGNAME
+              ":  input file [%s] is not a binary PGM, PPM or PAM file\n",
+              inname);
+            ++error;
+        } else {
+            wpng_info.pnmtype = (int)(pnmchar - '0');
+            if (wpng_info.pnmtype != 8)
+                wpng_info.have_bg = FALSE;  /* no need for bg if opaque */
+            do {
+                fgets(pnmline, 256, wpng_info.infile);  /* lose any comments */
+            } while (pnmline[0] == '#');
+            sscanf(pnmline, "%ld %ld", &wpng_info.width, &wpng_info.height);
+            do {
+                fgets(pnmline, 256, wpng_info.infile);  /* more comment lines */
+            } while (pnmline[0] == '#');
+            sscanf(pnmline, "%d", &maxval);
+            if (wpng_info.width <= 0L || wpng_info.height <= 0L ||
+                maxval != 255)
+            {
+                fprintf(stderr, PROGNAME
+                  ":  only positive width/height, maxval == 255 allowed \n");
+                ++error;
+            }
+            wpng_info.sample_depth = 8;  /* <==> maxval 255 */
+
+            if (!wpng_info.filter) {
+                /* make outname from inname */
+                if ((p = strrchr(inname, '.')) == NULL ||
+                    (p - inname) != (len - 4))
+                {
+                    strcpy(outname, inname);
+                    strcpy(outname+len, ".png");
+                } else {
+                    len -= 4;
+                    strncpy(outname, inname, len);
+                    strcpy(outname+len, ".png");
+                }
+                /* check if outname already exists; if not, open */
+                if ((wpng_info.outfile = fopen(outname, "rb")) != NULL) {
+                    fprintf(stderr, PROGNAME ":  output file exists [%s]\n",
+                      outname);
+                    fclose(wpng_info.outfile);
+                    ++error;
+                } else if (!(wpng_info.outfile = fopen(outname, "wb"))) {
+                    fprintf(stderr, PROGNAME ":  can't open output file [%s]\n",
+                      outname);
+                    ++error;
+                }
+            }
+        }
+        if (error) {
+            fclose(wpng_info.infile);
+            wpng_info.infile = NULL;
+            if (wpng_info.filter) {
+                fclose(wpng_info.outfile);
+                wpng_info.outfile = NULL;
+            }
+        }
+    }
+
+
+    /* if we had any errors, print usage and die horrible death...arrr! */
+
+    if (error) {
+        fprintf(stderr, "\n%s %s:  %s\n", PROGNAME, VERSION, APPNAME);
+        writepng_version_info();
+        fprintf(stderr, "\n"
+"Usage:  %s [-gamma exp] [-bgcolor bg] [-text] [-time] [-interlace] pnmfile\n"
+"or: ... | %s [-gamma exp] [-bgcolor bg] [-text] [-time] [-interlace] | ...\n"
+         "    exp \ttransfer-function exponent (``gamma'') of the image in\n"
+         "\t\t  floating-point format (e.g., ``%.5f''); if image looks\n"
+         "\t\t  correct on given display system, image gamma is equal to\n"
+         "\t\t  inverse of display-system exponent, i.e., 1 / (LUT * CRT)\n"
+         "\t\t  (where LUT = lookup-table exponent and CRT = CRT exponent;\n"
+         "\t\t  first varies, second is usually 2.2, all are positive)\n"
+         "    bg  \tdesired background color for alpha-channel images, in\n"
+         "\t\t  7-character hex RGB format (e.g., ``#ff7700'' for orange:\n"
+         "\t\t  same as HTML colors)\n"
+         "    -text\tprompt interactively for text info (tEXt chunks)\n"
+         "    -time\tinclude a tIME chunk (last modification time)\n"
+         "    -interlace\twrite interlaced PNG image\n"
+         "\n"
+"pnmfile or stdin must be a binary PGM (`P5'), PPM (`P6') or (extremely\n"
+"unofficial and unsupported!) PAM (`P8') file.  Currently it is required\n"
+"to have maxval == 255 (i.e., no scaling).  If pnmfile is specified, it\n"
+"is converted to the corresponding PNG file with the same base name but a\n"
+"``.png'' extension; files read from stdin are converted and sent to stdout.\n"
+"The conversion is progressive (low memory usage) unless interlacing is\n"
+"requested; in that case the whole image will be buffered in memory and\n"
+"written in one call.\n"
+         "\n", PROGNAME, PROGNAME, default_gamma);
+        exit(1);
+    }
+
+
+    /* prepare the text buffers for libpng's use; note that even though
+     * PNG's png_text struct includes a length field, we don't have to fill
+     * it out */
+
+    if (text &&
+#ifndef DOS_OS2_W32
+        (keybd = fdopen(fileno(stderr), "r")) != NULL &&
+#endif
+        (textbuf = (char *)malloc((5 + 9)*75)) != NULL)
+    {
+        int i, valid, result;
+
+        fprintf(stderr,
+          "Enter text info (no more than 72 characters per line);\n");
+        fprintf(stderr, "to skip a field, hit the <Enter> key.\n");
+        /* note:  just <Enter> leaves len == 1 */
+
+        do {
+            valid = TRUE;
+            p = textbuf + TEXT_TITLE_OFFSET;
+            fprintf(stderr, "  Title: ");
+            fflush(stderr);
+            if (FGETS(p, 74, keybd) && (len = strlen(p)) > 1) {
+                if (p[len-1] == '\n')
+                    p[--len] = '\0';
+                wpng_info.title = p;
+                wpng_info.have_text |= TEXT_TITLE;
+                if ((result = wpng_isvalid_latin1((uch *)p, len)) >= 0) {
+                    fprintf(stderr, "    " PROGNAME " warning:  character code"
+                      " %u is %sdiscouraged by the PNG\n    specification "
+                      "[first occurrence was at character position #%d]\n",
+                      (unsigned)p[result], (p[result] == 27)? "strongly " : "",
+                      result+1);
+                    fflush(stderr);
+#ifdef FORBID_LATIN1_CTRL
+                    wpng_info.have_text &= ~TEXT_TITLE;
+                    valid = FALSE;
+#else
+                    if (p[result] == 27) {    /* escape character */
+                        wpng_info.have_text &= ~TEXT_TITLE;
+                        valid = FALSE;
+                    }
+#endif
+                }
+            }
+        } while (!valid);
+
+        do {
+            valid = TRUE;
+            p = textbuf + TEXT_AUTHOR_OFFSET;
+            fprintf(stderr, "  Author: ");
+            fflush(stderr);
+            if (FGETS(p, 74, keybd) && (len = strlen(p)) > 1) {
+                if (p[len-1] == '\n')
+                    p[--len] = '\0';
+                wpng_info.author = p;
+                wpng_info.have_text |= TEXT_AUTHOR;
+                if ((result = wpng_isvalid_latin1((uch *)p, len)) >= 0) {
+                    fprintf(stderr, "    " PROGNAME " warning:  character code"
+                      " %u is %sdiscouraged by the PNG\n    specification "
+                      "[first occurrence was at character position #%d]\n",
+                      (unsigned)p[result], (p[result] == 27)? "strongly " : "",
+                      result+1);
+                    fflush(stderr);
+#ifdef FORBID_LATIN1_CTRL
+                    wpng_info.have_text &= ~TEXT_AUTHOR;
+                    valid = FALSE;
+#else
+                    if (p[result] == 27) {    /* escape character */
+                        wpng_info.have_text &= ~TEXT_AUTHOR;
+                        valid = FALSE;
+                    }
+#endif
+                }
+            }
+        } while (!valid);
+
+        do {
+            valid = TRUE;
+            p = textbuf + TEXT_DESC_OFFSET;
+            fprintf(stderr, "  Description (up to 9 lines):\n");
+            for (i = 1;  i < 10;  ++i) {
+                fprintf(stderr, "    [%d] ", i);
+                fflush(stderr);
+                if (FGETS(p, 74, keybd) && (len = strlen(p)) > 1)
+                    p += len;   /* now points at NULL; char before is newline */
+                else
+                    break;
+            }
+            if ((len = p - (textbuf + TEXT_DESC_OFFSET)) > 1) {
+                if (p[-1] == '\n') {
+                    p[-1] = '\0';
+                    --len;
+                }
+                wpng_info.desc = textbuf + TEXT_DESC_OFFSET;
+                wpng_info.have_text |= TEXT_DESC;
+                p = textbuf + TEXT_DESC_OFFSET;
+                if ((result = wpng_isvalid_latin1((uch *)p, len)) >= 0) {
+                    fprintf(stderr, "    " PROGNAME " warning:  character code"
+                      " %u is %sdiscouraged by the PNG\n    specification "
+                      "[first occurrence was at character position #%d]\n",
+                      (unsigned)p[result], (p[result] == 27)? "strongly " : "",
+                      result+1);
+                    fflush(stderr);
+#ifdef FORBID_LATIN1_CTRL
+                    wpng_info.have_text &= ~TEXT_DESC;
+                    valid = FALSE;
+#else
+                    if (p[result] == 27) {    /* escape character */
+                        wpng_info.have_text &= ~TEXT_DESC;
+                        valid = FALSE;
+                    }
+#endif
+                }
+            }
+        } while (!valid);
+
+        do {
+            valid = TRUE;
+            p = textbuf + TEXT_COPY_OFFSET;
+            fprintf(stderr, "  Copyright: ");
+            fflush(stderr);
+            if (FGETS(p, 74, keybd) && (len = strlen(p)) > 1) {
+                if (p[len-1] == '\n')
+                    p[--len] = '\0';
+                wpng_info.copyright = p;
+                wpng_info.have_text |= TEXT_COPY;
+                if ((result = wpng_isvalid_latin1((uch *)p, len)) >= 0) {
+                    fprintf(stderr, "    " PROGNAME " warning:  character code"
+                      " %u is %sdiscouraged by the PNG\n    specification "
+                      "[first occurrence was at character position #%d]\n",
+                      (unsigned)p[result], (p[result] == 27)? "strongly " : "",
+                      result+1);
+                    fflush(stderr);
+#ifdef FORBID_LATIN1_CTRL
+                    wpng_info.have_text &= ~TEXT_COPY;
+                    valid = FALSE;
+#else
+                    if (p[result] == 27) {    /* escape character */
+                        wpng_info.have_text &= ~TEXT_COPY;
+                        valid = FALSE;
+                    }
+#endif
+                }
+            }
+        } while (!valid);
+
+        do {
+            valid = TRUE;
+            p = textbuf + TEXT_EMAIL_OFFSET;
+            fprintf(stderr, "  E-mail: ");
+            fflush(stderr);
+            if (FGETS(p, 74, keybd) && (len = strlen(p)) > 1) {
+                if (p[len-1] == '\n')
+                    p[--len] = '\0';
+                wpng_info.email = p;
+                wpng_info.have_text |= TEXT_EMAIL;
+                if ((result = wpng_isvalid_latin1((uch *)p, len)) >= 0) {
+                    fprintf(stderr, "    " PROGNAME " warning:  character code"
+                      " %u is %sdiscouraged by the PNG\n    specification "
+                      "[first occurrence was at character position #%d]\n",
+                      (unsigned)p[result], (p[result] == 27)? "strongly " : "",
+                      result+1);
+                    fflush(stderr);
+#ifdef FORBID_LATIN1_CTRL
+                    wpng_info.have_text &= ~TEXT_EMAIL;
+                    valid = FALSE;
+#else
+                    if (p[result] == 27) {    /* escape character */
+                        wpng_info.have_text &= ~TEXT_EMAIL;
+                        valid = FALSE;
+                    }
+#endif
+                }
+            }
+        } while (!valid);
+
+        do {
+            valid = TRUE;
+            p = textbuf + TEXT_URL_OFFSET;
+            fprintf(stderr, "  URL: ");
+            fflush(stderr);
+            if (FGETS(p, 74, keybd) && (len = strlen(p)) > 1) {
+                if (p[len-1] == '\n')
+                    p[--len] = '\0';
+                wpng_info.url = p;
+                wpng_info.have_text |= TEXT_URL;
+                if ((result = wpng_isvalid_latin1((uch *)p, len)) >= 0) {
+                    fprintf(stderr, "    " PROGNAME " warning:  character code"
+                      " %u is %sdiscouraged by the PNG\n    specification "
+                      "[first occurrence was at character position #%d]\n",
+                      (unsigned)p[result], (p[result] == 27)? "strongly " : "",
+                      result+1);
+                    fflush(stderr);
+#ifdef FORBID_LATIN1_CTRL
+                    wpng_info.have_text &= ~TEXT_URL;
+                    valid = FALSE;
+#else
+                    if (p[result] == 27) {    /* escape character */
+                        wpng_info.have_text &= ~TEXT_URL;
+                        valid = FALSE;
+                    }
+#endif
+                }
+            }
+        } while (!valid);
+
+#ifndef DOS_OS2_W32
+        fclose(keybd);
+#endif
+
+    } else if (text) {
+        fprintf(stderr, PROGNAME ":  unable to allocate memory for text\n");
+        text = FALSE;
+        wpng_info.have_text = 0;
+    }
+
+
+    /* allocate libpng stuff, initialize transformations, write pre-IDAT data */
+
+    if ((rc = writepng_init(&wpng_info)) != 0) {
+        switch (rc) {
+            case 2:
+                fprintf(stderr, PROGNAME
+                  ":  libpng initialization problem (longjmp)\n");
+                break;
+            case 4:
+                fprintf(stderr, PROGNAME ":  insufficient memory\n");
+                break;
+            case 11:
+                fprintf(stderr, PROGNAME
+                  ":  internal logic error (unexpected PNM type)\n");
+                break;
+            default:
+                fprintf(stderr, PROGNAME
+                  ":  unknown writepng_init() error\n");
+                break;
+        }
+        exit(rc);
+    }
+
+
+    /* free textbuf, since it's a completely local variable and all text info
+     * has just been written to the PNG file */
+
+    if (text && textbuf) {
+        free(textbuf);
+        textbuf = NULL;
+    }
+
+
+    /* calculate rowbytes on basis of image type; note that this becomes much
+     * more complicated if we choose to support PBM type, ASCII PNM types, or
+     * 16-bit-per-sample binary data [currently not an official NetPBM type] */
+
+    if (wpng_info.pnmtype == 5)
+        rowbytes = wpng_info.width;
+    else if (wpng_info.pnmtype == 6)
+        rowbytes = wpng_info.width * 3;
+    else /* if (wpng_info.pnmtype == 8) */
+        rowbytes = wpng_info.width * 4;
+
+
+    /* read and write the image, either in its entirety (if writing interlaced
+     * PNG) or row by row (if non-interlaced) */
+
+    fprintf(stderr, "Encoding image data...\n");
+    fflush(stderr);
+
+    if (wpng_info.interlaced) {
+        long i;
+        ulg bytes;
+        ulg image_bytes;
+
+        /* Guard against integer overflow */
+        if (wpng_info_height > ((size_t)(-1)/rowbytes ||
+            wpng_info_height > ((ulg)(-1)/rowbytes) {
+            fprintf(stderr, PROGNAME ":  image_data buffer too large\n");
+            writepng_cleanup(&wpng_info);
+            wpng_cleanup();
+            exit(5);
+        }
+
+        image_bytes = rowbytes * wpng_info.height;
+
+        wpng_info.image_data = (uch *)malloc(image_bytes);
+        wpng_info.row_pointers = (uch **)malloc(wpng_info.height*sizeof(uch *));
+        if (wpng_info.image_data == NULL || wpng_info.row_pointers == NULL) {
+            fprintf(stderr, PROGNAME ":  insufficient memory for image data\n");
+            writepng_cleanup(&wpng_info);
+            wpng_cleanup();
+            exit(5);
+        }
+        for (i = 0;  i < wpng_info.height;  ++i)
+            wpng_info.row_pointers[i] = wpng_info.image_data + i*rowbytes;
+        bytes = fread(wpng_info.image_data, 1, image_bytes, wpng_info.infile);
+        if (bytes != image_bytes) {
+            fprintf(stderr, PROGNAME ":  expected %lu bytes, got %lu bytes\n",
+              image_bytes, bytes);
+            fprintf(stderr, "  (continuing anyway)\n");
+        }
+        if (writepng_encode_image(&wpng_info) != 0) {
+            fprintf(stderr, PROGNAME
+              ":  libpng problem (longjmp) while writing image data\n");
+            writepng_cleanup(&wpng_info);
+            wpng_cleanup();
+            exit(2);
+        }
+
+    } else /* not interlaced:  write progressively (row by row) */ {
+        long j;
+        ulg bytes;
+
+        wpng_info.image_data = (uch *)malloc(rowbytes);
+        if (wpng_info.image_data == NULL) {
+            fprintf(stderr, PROGNAME ":  insufficient memory for row data\n");
+            writepng_cleanup(&wpng_info);
+            wpng_cleanup();
+            exit(5);
+        }
+        error = 0;
+        for (j = wpng_info.height;  j > 0L;  --j) {
+            bytes = fread(wpng_info.image_data, 1, rowbytes, wpng_info.infile);
+            if (bytes != rowbytes) {
+                fprintf(stderr, PROGNAME
+                  ":  expected %lu bytes, got %lu bytes (row %ld)\n", rowbytes,
+                  bytes, wpng_info.height-j);
+                ++error;
+                break;
+            }
+            if (writepng_encode_row(&wpng_info) != 0) {
+                fprintf(stderr, PROGNAME
+                  ":  libpng problem (longjmp) while writing row %ld\n",
+                  wpng_info.height-j);
+                ++error;
+                break;
+            }
+        }
+        if (error) {
+            writepng_cleanup(&wpng_info);
+            wpng_cleanup();
+            exit(2);
+        }
+        if (writepng_encode_finish(&wpng_info) != 0) {
+            fprintf(stderr, PROGNAME ":  error on final libpng call\n");
+            writepng_cleanup(&wpng_info);
+            wpng_cleanup();
+            exit(2);
+        }
+    }
+
+
+    /* OK, we're done (successfully):  clean up all resources and quit */
+
+    fprintf(stderr, "Done.\n");
+    fflush(stderr);
+
+    writepng_cleanup(&wpng_info);
+    wpng_cleanup();
+
+    return 0;
+}
+
+
+
+
+
+static int wpng_isvalid_latin1(uch *p, int len)
+{
+    int i, result = -1;
+
+    for (i = 0;  i < len;  ++i) {
+        if (p[i] == 10 || (p[i] > 31 && p[i] < 127) || p[i] > 160)
+            continue;           /* character is completely OK */
+        if (result < 0 || (p[result] != 27 && p[i] == 27))
+            result = i;         /* mark location of first questionable one */
+    }                           /*  or of first escape character (bad) */
+
+    return result;
+}
+
+
+
+
+
+static void wpng_cleanup(void)
+{
+    if (wpng_info.outfile) {
+        fclose(wpng_info.outfile);
+        wpng_info.outfile = NULL;
+    }
+
+    if (wpng_info.infile) {
+        fclose(wpng_info.infile);
+        wpng_info.infile = NULL;
+    }
+
+    if (wpng_info.image_data) {
+        free(wpng_info.image_data);
+        wpng_info.image_data = NULL;
+    }
+
+    if (wpng_info.row_pointers) {
+        free(wpng_info.row_pointers);
+        wpng_info.row_pointers = NULL;
+    }
+}
+
+
+
+
+#ifdef DOS_OS2_W32
+
+static char *dos_kbd_gets(char *buf, int len)
+{
+    int ch, count=0;
+
+    do {
+        buf[count++] = ch = getche();
+    } while (ch != '\r' && count < len-1);
+
+    buf[count--] = '\0';        /* terminate string */
+    if (buf[count] == '\r')     /* Enter key makes CR, so change to newline */
+        buf[count] = '\n';
+
+    fprintf(stderr, "\n");      /* Enter key does *not* cause a newline */
+    fflush(stderr);
+
+    return buf;
+}
+
+#endif /* DOS_OS2_W32 */
diff --git a/Engine/lib/lpng/contrib/gregbook/writepng.c b/Engine/lib/lpng/contrib/gregbook/writepng.c
new file mode 100644
index 000000000..055c74374
--- /dev/null
+++ b/Engine/lib/lpng/contrib/gregbook/writepng.c
@@ -0,0 +1,401 @@
+/*---------------------------------------------------------------------------
+
+   wpng - simple PNG-writing program                             writepng.c
+
+  ---------------------------------------------------------------------------
+
+      Copyright (c) 1998-2007, 2017 Greg Roelofs.  All rights reserved.
+
+      This software is provided "as is," without warranty of any kind,
+      express or implied.  In no event shall the author or contributors
+      be held liable for any damages arising in any way from the use of
+      this software.
+
+      The contents of this file are DUAL-LICENSED.  You may modify and/or
+      redistribute this software according to the terms of one of the
+      following two licenses (at your option):
+
+
+      LICENSE 1 ("BSD-like with advertising clause"):
+
+      Permission is granted to anyone to use this software for any purpose,
+      including commercial applications, and to alter it and redistribute
+      it freely, subject to the following restrictions:
+
+      1. Redistributions of source code must retain the above copyright
+         notice, disclaimer, and this list of conditions.
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, disclaimer, and this list of conditions in the documenta-
+         tion and/or other materials provided with the distribution.
+      3. All advertising materials mentioning features or use of this
+         software must display the following acknowledgment:
+
+            This product includes software developed by Greg Roelofs
+            and contributors for the book, "PNG: The Definitive Guide,"
+            published by O'Reilly and Associates.
+
+
+      LICENSE 2 (GNU GPL v2 or later):
+
+      This program is free software; you can redistribute it and/or modify
+      it under the terms of the GNU General Public License as published by
+      the Free Software Foundation; either version 2 of the License, or
+      (at your option) any later version.
+
+      This program is distributed in the hope that it will be useful,
+      but WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+      GNU General Public License for more details.
+
+      You should have received a copy of the GNU General Public License
+      along with this program; if not, write to the Free Software Foundation,
+      Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  ---------------------------------------------------------------------------*/
+
+
+#include <stdlib.h>     /* for exit() prototype */
+#include <zlib.h>
+
+#include "png.h"        /* libpng header, includes setjmp.h */
+#include "writepng.h"   /* typedefs, common macros, public prototypes */
+
+
+/* local prototype */
+
+static void writepng_error_handler(png_structp png_ptr, png_const_charp msg);
+
+
+
+void writepng_version_info(void)
+{
+  fprintf(stderr, "   Compiled with libpng %s; using libpng %s.\n",
+    PNG_LIBPNG_VER_STRING, png_libpng_ver);
+  fprintf(stderr, "   Compiled with zlib %s; using zlib %s.\n",
+    ZLIB_VERSION, zlib_version);
+}
+
+
+
+
+/* returns 0 for success, 2 for libpng problem, 4 for out of memory, 11 for
+ *  unexpected pnmtype; note that outfile might be stdout */
+
+int writepng_init(mainprog_info *mainprog_ptr)
+{
+    png_structp  png_ptr;       /* note:  temporary variables! */
+    png_infop  info_ptr;
+    int color_type, interlace_type;
+
+
+    /* could also replace libpng warning-handler (final NULL), but no need: */
+
+    png_ptr = png_create_write_struct(png_get_libpng_ver(NULL), mainprog_ptr,
+      writepng_error_handler, NULL);
+    if (!png_ptr)
+        return 4;   /* out of memory */
+
+    info_ptr = png_create_info_struct(png_ptr);
+    if (!info_ptr) {
+        png_destroy_write_struct(&png_ptr, NULL);
+        return 4;   /* out of memory */
+    }
+
+
+    /* setjmp() must be called in every function that calls a PNG-writing
+     * libpng function, unless an alternate error handler was installed--
+     * but compatible error handlers must either use longjmp() themselves
+     * (as in this program) or some other method to return control to
+     * application code, so here we go: */
+
+    if (setjmp(mainprog_ptr->jmpbuf)) {
+        png_destroy_write_struct(&png_ptr, &info_ptr);
+        return 2;
+    }
+
+
+    /* make sure outfile is (re)opened in BINARY mode */
+
+    png_init_io(png_ptr, mainprog_ptr->outfile);
+
+
+    /* set the compression levels--in general, always want to leave filtering
+     * turned on (except for palette images) and allow all of the filters,
+     * which is the default; want 32K zlib window, unless entire image buffer
+     * is 16K or smaller (unknown here)--also the default; usually want max
+     * compression (NOT the default); and remaining compression flags should
+     * be left alone */
+
+    png_set_compression_level(png_ptr, Z_BEST_COMPRESSION);
+/*
+    >> this is default for no filtering; Z_FILTERED is default otherwise:
+    png_set_compression_strategy(png_ptr, Z_DEFAULT_STRATEGY);
+    >> these are all defaults:
+    png_set_compression_mem_level(png_ptr, 8);
+    png_set_compression_window_bits(png_ptr, 15);
+    png_set_compression_method(png_ptr, 8);
+ */
+
+
+    /* set the image parameters appropriately */
+
+    if (mainprog_ptr->pnmtype == 5)
+        color_type = PNG_COLOR_TYPE_GRAY;
+    else if (mainprog_ptr->pnmtype == 6)
+        color_type = PNG_COLOR_TYPE_RGB;
+    else if (mainprog_ptr->pnmtype == 8)
+        color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+    else {
+        png_destroy_write_struct(&png_ptr, &info_ptr);
+        return 11;
+    }
+
+    interlace_type = mainprog_ptr->interlaced? PNG_INTERLACE_ADAM7 :
+                                               PNG_INTERLACE_NONE;
+
+    png_set_IHDR(png_ptr, info_ptr, mainprog_ptr->width, mainprog_ptr->height,
+      mainprog_ptr->sample_depth, color_type, interlace_type,
+      PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+
+    if (mainprog_ptr->gamma > 0.0)
+        png_set_gAMA(png_ptr, info_ptr, mainprog_ptr->gamma);
+
+    if (mainprog_ptr->have_bg) {   /* we know it's RGBA, not gray+alpha */
+        png_color_16  background;
+
+        background.red = mainprog_ptr->bg_red;
+        background.green = mainprog_ptr->bg_green;
+        background.blue = mainprog_ptr->bg_blue;
+        png_set_bKGD(png_ptr, info_ptr, &background);
+    }
+
+    if (mainprog_ptr->have_time) {
+        png_time  modtime;
+
+        png_convert_from_time_t(&modtime, mainprog_ptr->modtime);
+        png_set_tIME(png_ptr, info_ptr, &modtime);
+    }
+
+    if (mainprog_ptr->have_text) {
+        png_text  text[6];
+        int  num_text = 0;
+
+        if (mainprog_ptr->have_text & TEXT_TITLE) {
+            text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
+            text[num_text].key = "Title";
+            text[num_text].text = mainprog_ptr->title;
+            ++num_text;
+        }
+        if (mainprog_ptr->have_text & TEXT_AUTHOR) {
+            text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
+            text[num_text].key = "Author";
+            text[num_text].text = mainprog_ptr->author;
+            ++num_text;
+        }
+        if (mainprog_ptr->have_text & TEXT_DESC) {
+            text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
+            text[num_text].key = "Description";
+            text[num_text].text = mainprog_ptr->desc;
+            ++num_text;
+        }
+        if (mainprog_ptr->have_text & TEXT_COPY) {
+            text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
+            text[num_text].key = "Copyright";
+            text[num_text].text = mainprog_ptr->copyright;
+            ++num_text;
+        }
+        if (mainprog_ptr->have_text & TEXT_EMAIL) {
+            text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
+            text[num_text].key = "E-mail";
+            text[num_text].text = mainprog_ptr->email;
+            ++num_text;
+        }
+        if (mainprog_ptr->have_text & TEXT_URL) {
+            text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
+            text[num_text].key = "URL";
+            text[num_text].text = mainprog_ptr->url;
+            ++num_text;
+        }
+        png_set_text(png_ptr, info_ptr, text, num_text);
+    }
+
+
+    /* write all chunks up to (but not including) first IDAT */
+
+    png_write_info(png_ptr, info_ptr);
+
+
+    /* if we wanted to write any more text info *after* the image data, we
+     * would set up text struct(s) here and call png_set_text() again, with
+     * just the new data; png_set_tIME() could also go here, but it would
+     * have no effect since we already called it above (only one tIME chunk
+     * allowed) */
+
+
+    /* set up the transformations:  for now, just pack low-bit-depth pixels
+     * into bytes (one, two or four pixels per byte) */
+
+    png_set_packing(png_ptr);
+/*  png_set_shift(png_ptr, &sig_bit);  to scale low-bit-depth values */
+
+
+    /* make sure we save our pointers for use in writepng_encode_image() */
+
+    mainprog_ptr->png_ptr = png_ptr;
+    mainprog_ptr->info_ptr = info_ptr;
+
+
+    /* OK, that's all we need to do for now; return happy */
+
+    return 0;
+}
+
+
+
+
+
+/* returns 0 for success, 2 for libpng (longjmp) problem */
+
+int writepng_encode_image(mainprog_info *mainprog_ptr)
+{
+    png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
+    png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;
+
+
+    /* as always, setjmp() must be called in every function that calls a
+     * PNG-writing libpng function */
+
+    if (setjmp(mainprog_ptr->jmpbuf)) {
+        png_destroy_write_struct(&png_ptr, &info_ptr);
+        mainprog_ptr->png_ptr = NULL;
+        mainprog_ptr->info_ptr = NULL;
+        return 2;
+    }
+
+
+    /* and now we just write the whole image; libpng takes care of interlacing
+     * for us */
+
+    png_write_image(png_ptr, mainprog_ptr->row_pointers);
+
+
+    /* since that's it, we also close out the end of the PNG file now--if we
+     * had any text or time info to write after the IDATs, second argument
+     * would be info_ptr, but we optimize slightly by sending NULL pointer: */
+
+    png_write_end(png_ptr, NULL);
+
+    return 0;
+}
+
+
+
+
+
+/* returns 0 if succeeds, 2 if libpng problem */
+
+int writepng_encode_row(mainprog_info *mainprog_ptr)  /* NON-interlaced only! */
+{
+    png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
+    png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;
+
+
+    /* as always, setjmp() must be called in every function that calls a
+     * PNG-writing libpng function */
+
+    if (setjmp(mainprog_ptr->jmpbuf)) {
+        png_destroy_write_struct(&png_ptr, &info_ptr);
+        mainprog_ptr->png_ptr = NULL;
+        mainprog_ptr->info_ptr = NULL;
+        return 2;
+    }
+
+
+    /* image_data points at our one row of image data */
+
+    png_write_row(png_ptr, mainprog_ptr->image_data);
+
+    return 0;
+}
+
+
+
+
+
+/* returns 0 if succeeds, 2 if libpng problem */
+
+int writepng_encode_finish(mainprog_info *mainprog_ptr)   /* NON-interlaced! */
+{
+    png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
+    png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;
+
+
+    /* as always, setjmp() must be called in every function that calls a
+     * PNG-writing libpng function */
+
+    if (setjmp(mainprog_ptr->jmpbuf)) {
+        png_destroy_write_struct(&png_ptr, &info_ptr);
+        mainprog_ptr->png_ptr = NULL;
+        mainprog_ptr->info_ptr = NULL;
+        return 2;
+    }
+
+
+    /* close out PNG file; if we had any text or time info to write after
+     * the IDATs, second argument would be info_ptr: */
+
+    png_write_end(png_ptr, NULL);
+
+    return 0;
+}
+
+
+
+
+
+void writepng_cleanup(mainprog_info *mainprog_ptr)
+{
+    png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
+    png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;
+
+    if (png_ptr && info_ptr)
+        png_destroy_write_struct(&png_ptr, &info_ptr);
+}
+
+
+
+
+
+static void writepng_error_handler(png_structp png_ptr, png_const_charp msg)
+{
+    mainprog_info  *mainprog_ptr;
+
+    /* This function, aside from the extra step of retrieving the "error
+     * pointer" (below) and the fact that it exists within the application
+     * rather than within libpng, is essentially identical to libpng's
+     * default error handler.  The second point is critical:  since both
+     * setjmp() and longjmp() are called from the same code, they are
+     * guaranteed to have compatible notions of how big a jmp_buf is,
+     * regardless of whether _BSD_SOURCE or anything else has (or has not)
+     * been defined. */
+
+    fprintf(stderr, "writepng libpng error: %s\n", msg);
+    fflush(stderr);
+
+    mainprog_ptr = png_get_error_ptr(png_ptr);
+    if (mainprog_ptr == NULL) {         /* we are completely hosed now */
+        fprintf(stderr,
+          "writepng severe error:  jmpbuf not recoverable; terminating.\n");
+        fflush(stderr);
+        exit(99);
+    }
+
+    /* Now we have our data structure we can use the information in it
+     * to return control to our own higher level code (all the points
+     * where 'setjmp' is called in this file.)  This will work with other
+     * error handling mechanisms as well - libpng always calls png_error
+     * when it can proceed no further, thus, so long as the error handler
+     * is intercepted, application code can do its own error recovery.
+     */
+    longjmp(mainprog_ptr->jmpbuf, 1);
+}
diff --git a/Engine/lib/lpng/contrib/gregbook/writepng.h b/Engine/lib/lpng/contrib/gregbook/writepng.h
new file mode 100644
index 000000000..78b966b58
--- /dev/null
+++ b/Engine/lib/lpng/contrib/gregbook/writepng.h
@@ -0,0 +1,133 @@
+/*---------------------------------------------------------------------------
+
+   wpng - simple PNG-writing program                             writepng.h
+
+  ---------------------------------------------------------------------------
+
+      Copyright (c) 1998-2007 Greg Roelofs.  All rights reserved.
+
+      This software is provided "as is," without warranty of any kind,
+      express or implied.  In no event shall the author or contributors
+      be held liable for any damages arising in any way from the use of
+      this software.
+
+      The contents of this file are DUAL-LICENSED.  You may modify and/or
+      redistribute this software according to the terms of one of the
+      following two licenses (at your option):
+
+
+      LICENSE 1 ("BSD-like with advertising clause"):
+
+      Permission is granted to anyone to use this software for any purpose,
+      including commercial applications, and to alter it and redistribute
+      it freely, subject to the following restrictions:
+
+      1. Redistributions of source code must retain the above copyright
+         notice, disclaimer, and this list of conditions.
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, disclaimer, and this list of conditions in the documenta-
+         tion and/or other materials provided with the distribution.
+      3. All advertising materials mentioning features or use of this
+         software must display the following acknowledgment:
+
+            This product includes software developed by Greg Roelofs
+            and contributors for the book, "PNG: The Definitive Guide,"
+            published by O'Reilly and Associates.
+
+
+      LICENSE 2 (GNU GPL v2 or later):
+
+      This program is free software; you can redistribute it and/or modify
+      it under the terms of the GNU General Public License as published by
+      the Free Software Foundation; either version 2 of the License, or
+      (at your option) any later version.
+
+      This program is distributed in the hope that it will be useful,
+      but WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+      GNU General Public License for more details.
+
+      You should have received a copy of the GNU General Public License
+      along with this program; if not, write to the Free Software Foundation,
+      Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  ---------------------------------------------------------------------------*/
+
+#ifndef TRUE
+#  define TRUE 1
+#  define FALSE 0
+#endif
+
+#ifndef MAX
+#  define MAX(a,b)  ((a) > (b)? (a) : (b))
+#  define MIN(a,b)  ((a) < (b)? (a) : (b))
+#endif
+
+#ifdef DEBUG
+#  define Trace(x)  {fprintf x ; fflush(stderr); fflush(stdout);}
+#else
+#  define Trace(x)  ;
+#endif
+
+#define TEXT_TITLE    0x01
+#define TEXT_AUTHOR   0x02
+#define TEXT_DESC     0x04
+#define TEXT_COPY     0x08
+#define TEXT_EMAIL    0x10
+#define TEXT_URL      0x20
+
+#define TEXT_TITLE_OFFSET        0
+#define TEXT_AUTHOR_OFFSET      72
+#define TEXT_COPY_OFFSET     (2*72)
+#define TEXT_EMAIL_OFFSET    (3*72)
+#define TEXT_URL_OFFSET      (4*72)
+#define TEXT_DESC_OFFSET     (5*72)
+
+typedef unsigned char   uch;
+typedef unsigned short  ush;
+typedef unsigned long   ulg;
+
+typedef struct _mainprog_info {
+    double gamma;
+    long width;
+    long height;
+    time_t modtime;
+    FILE *infile;
+    FILE *outfile;
+    void *png_ptr;
+    void *info_ptr;
+    uch *image_data;
+    uch **row_pointers;
+    char *title;
+    char *author;
+    char *desc;
+    char *copyright;
+    char *email;
+    char *url;
+    int filter;    /* command-line-filter flag, not PNG row filter! */
+    int pnmtype;
+    int sample_depth;
+    int interlaced;
+    int have_bg;
+    int have_time;
+    int have_text;
+    jmp_buf jmpbuf;
+    uch bg_red;
+    uch bg_green;
+    uch bg_blue;
+} mainprog_info;
+
+
+/* prototypes for public functions in writepng.c */
+
+void writepng_version_info(void);
+
+int writepng_init(mainprog_info *mainprog_ptr);
+
+int writepng_encode_image(mainprog_info *mainprog_ptr);
+
+int writepng_encode_row(mainprog_info *mainprog_ptr);
+
+int writepng_encode_finish(mainprog_info *mainprog_ptr);
+
+void writepng_cleanup(mainprog_info *mainprog_ptr);
diff --git a/Engine/lib/lpng/contrib/libtests/fakepng.c b/Engine/lib/lpng/contrib/libtests/fakepng.c
new file mode 100644
index 000000000..6512c1401
--- /dev/null
+++ b/Engine/lib/lpng/contrib/libtests/fakepng.c
@@ -0,0 +1,65 @@
+/* Fake a PNG - just write it out directly.
+ *
+ * COPYRIGHT: Written by John Cunningham Bowler, 2014.
+ * To the extent possible under law, the author has waived all copyright and
+ * related or neighboring rights to this work.  This work is published from:
+ * United States.
+ *
+ */
+
+#include <stdio.h>
+#include <zlib.h> /* for crc32 */
+
+void
+put_uLong(uLong val)
+{
+   putchar(val >> 24);
+   putchar(val >> 16);
+   putchar(val >>  8);
+   putchar(val >>  0);
+}
+
+void
+put_chunk(const unsigned char *chunk, uInt length)
+{
+   uLong crc;
+
+   put_uLong(length-4); /* Exclude the tag */
+
+   fwrite(chunk, length, 1, stdout);
+
+   crc = crc32(0, Z_NULL, 0);
+   put_uLong(crc32(crc, chunk, length));
+}
+
+const unsigned char signature[] =
+{
+   137, 80, 78, 71, 13, 10, 26, 10
+};
+
+const unsigned char IHDR[] =
+{
+   73, 72, 68, 82, /* IHDR */
+   0, 0, 0, 1, /* width */
+   0, 0, 0, 1, /* height */
+   1, /* bit depth */
+   0, /* color type: greyscale */
+   0, /* compression method */
+   0, /* filter method */
+   0  /* interlace method: none */
+};
+
+const unsigned char unknown[] =
+{
+   'u', 'n', 'K', 'n' /* "unKn" - private safe to copy */
+};
+
+int
+main(void)
+{
+   fwrite(signature, sizeof signature, 1, stdout);
+   put_chunk(IHDR, sizeof IHDR);
+
+   for (;;)
+      put_chunk(unknown, sizeof unknown);
+}
diff --git a/Engine/lib/lpng/contrib/libtests/gentests.sh b/Engine/lib/lpng/contrib/libtests/gentests.sh
new file mode 100755
index 000000000..f0f8d2395
--- /dev/null
+++ b/Engine/lib/lpng/contrib/libtests/gentests.sh
@@ -0,0 +1,102 @@
+#!/bin/sh
+#
+# Copyright (c) 2013 John Cunningham Bowler
+#
+# Last changed in libpng 1.6.0 [February 14, 2013]
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+#
+# Generate a set of PNG test images.  The images are generated in a
+# sub-directory called 'tests' by default, however a command line argument will
+# change that name.  The generation requires a built version of makepng in the
+# current directory.
+#
+usage(){
+   exec >&2
+   echo "$0 [<directory>]"
+   echo '  Generate a set of PNG test files in "directory" ("tests" by default)'
+   exit 1
+}
+
+mp="$PWD/makepng"
+test -x "$mp" || {
+   exec >&2
+   echo "$0: the 'makepng' program must exist"
+   echo "  in the directory within which this program:"
+   echo "    $mp"
+   echo "  is executed"
+   usage
+}
+
+# Just one argument: the directory
+testdir="tests"
+test $# -gt 1 && {
+   testdir="$1"
+   shift
+}
+test $# -eq 0 || usage
+
+# Take care not to clobber something
+if test -e "$testdir"
+then
+   test -d "$testdir" || usage
+else
+   # mkdir -p isn't portable, so do the following
+   mkdir "$testdir" 2>/dev/null || mkdir -p "$testdir" || usage
+fi
+
+# This fails in a very satisfactory way if it's not accessible
+cd "$testdir"
+:>"test$$.png" || {
+   exec >&2
+   echo "$testdir: directory not writable"
+   usage
+}
+rm "test$$.png" || {
+   exec >&2
+   echo "$testdir: you have create but not write privileges here."
+   echo "  This is unexpected.  You have a spurion; "'"'"test$$.png"'"'"."
+   echo "  You need to remove this yourself.  Try a different directory."
+   exit 1
+}
+
+# Now call makepng ($mp) to create every file we can think of with a
+# reasonable name
+doit(){
+   for gamma in "" --sRGB --linear --1.8
+   do
+      case "$gamma" in
+         "")
+            gname=;;
+         --sRGB)
+            gname="-srgb";;
+         --linear)
+            gname="-lin";;
+         --1.8)
+            gname="-18";;
+         *)
+            gname="-$gamma";;
+      esac
+      "$mp" $gamma "$1" "$2" "test-$1-$2$gname.png"
+   done
+}
+#
+for ct in gray palette
+do
+   for bd in 1 2 4 8
+   do
+      doit "$ct" "$bd"
+   done
+done
+#
+doit "gray" "16"
+#
+for ct in gray-alpha rgb rgb-alpha
+do
+   for bd in 8 16
+   do
+      doit "$ct" "$bd"
+   done
+done
diff --git a/Engine/lib/lpng/contrib/libtests/makepng.c b/Engine/lib/lpng/contrib/libtests/makepng.c
new file mode 100644
index 000000000..312062bda
--- /dev/null
+++ b/Engine/lib/lpng/contrib/libtests/makepng.c
@@ -0,0 +1,1941 @@
+/* makepng.c */
+#define _ISOC99_SOURCE
+/* Copyright: */
+#define COPYRIGHT "\251 2013,2015 John Cunningham Bowler"
+/*
+ * Last changed in libpng 1.6.20 [November 24, 2015]
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * Make a test PNG image.  The arguments are as follows:
+ *
+ *    makepng [--sRGB|--linear|--1.8] [--tRNS] [--nofilters] \
+ *       color-type bit-depth [file-name]
+ *
+ * The color-type may be numeric (and must match the numbers used by the PNG
+ * specification) or one of the format names listed below.  The bit-depth is the
+ * component bit depth, or the pixel bit-depth for a color-mapped image.
+ *
+ * Without any options no color-space information is written, with the options
+ * an sRGB or the appropriate gAMA chunk is written.  "1.8" refers to the
+ * display system used on older Apple computers to correct for high ambient
+ * light levels in the viewing environment; it applies a transform of
+ * approximately value^(1/1.45) to the color values and so a gAMA chunk of 65909
+ * is written (1.45/2.2).
+ *
+ * The image data is generated internally.  Unless --color is given the images
+ * used are as follows:
+ *
+ * 1 channel: a square image with a diamond, the least luminous colors are on
+ *    the edge of the image, the most luminous in the center.
+ *
+ * 2 channels: the color channel increases in luminosity from top to bottom, the
+ *    alpha channel increases in opacity from left to right.
+ *
+ * 3 channels: linear combinations of, from the top-left corner clockwise,
+ *    black, green, white, red.
+ *
+ * 4 channels: linear combinations of, from the top-left corner clockwise,
+ *    transparent, red, green, blue.
+ *
+ * For color-mapped images a four channel color-map is used and if --tRNS is
+ * given the PNG file has a tRNS chunk, as follows:
+ *
+ * 1-bit: entry 0 is transparent-red, entry 1 is opaque-white
+ * 2-bit: entry 0: transparent-green
+ *        entry 1: 40%-red
+ *        entry 2: 80%-blue
+ *        entry 3: opaque-white
+ * 4-bit: the 16 combinations of the 2-bit case
+ * 8-bit: the 256 combinations of the 4-bit case
+ *
+ * The palette always has 2^bit-depth entries and the tRNS chunk one fewer.  The
+ * image is the 1-channel diamond, but using palette index, not luminosity.
+ *
+ * For formats other than color-mapped ones if --tRNS is specified a tRNS chunk
+ * is generated with all channels equal to the low bits of 0x0101.
+ *
+ * Image size is determined by the final pixel depth in bits, i.e. channels x
+ * bit-depth, as follows:
+ *
+ * 8 bits or less:    64x64
+ * 16 bits:           256x256
+ * More than 16 bits: 1024x1024
+ *
+ * Row filtering is the libpng default but may be turned off (the 'none' filter
+ * is used on every row) with the --nofilters option.
+ *
+ * The images are not interlaced.
+ *
+ * If file-name is given then the PNG is written to that file, else it is
+ * written to stdout.  Notice that stdout is not supported on systems where, by
+ * default, it assumes text output; this program makes no attempt to change the
+ * text mode of stdout!
+ *
+ *    makepng --color=<color> ...
+ *
+ * If --color is given then the whole image has that color, color-mapped images
+ * will have exactly one palette entry and all image files with be 16x16 in
+ * size.  The color value is 1 to 4 decimal numbers as appropriate for the color
+ * type.
+ *
+ *    makepng --small ...
+ *
+ * If --small is given the images are no larger than required to include every
+ * possible pixel value for the format.
+ *
+ * For formats with pixels 8 bits or fewer in size the images consist of a
+ * single row with 2^pixel-depth pixels, one of every possible value.
+ *
+ * For formats with 16-bit pixels a 256x256 image is generated containing every
+ * possible pixel value.
+ *
+ * For larger pixel sizes a 256x256 image is generated where the first row
+ * consists of each pixel that has identical byte values throughout the pixel
+ * followed by rows where the byte values differ within the pixel.
+ *
+ * In all cases the pixel values are arranged in such a way that the SUB and UP
+ * filters give byte sequences for maximal zlib compression.  By default (if
+ * --nofilters is not given) the SUB filter is used on the first row and the UP
+ * filter on all following rows.
+ *
+ * The --small option is meant to provide good test-case coverage, however the
+ * images are not easy to examine visually.  Without the --small option the
+ * images contain identical color values; the pixel values are adjusted
+ * according to the gamma encoding with no gamma encoding being interpreted as
+ * sRGB.
+ *
+ * LICENSING
+ * =========
+ *
+ * This code is copyright of the authors, see the COPYRIGHT define above.  The
+ * code is licensed as above, using the libpng license.  The code generates
+ * images which are solely the product of the code; the options choose which of
+ * the many possibilities to generate.  The images that result (but not the code
+ * which generates them) are licensed as defined here:
+ *
+ * IMPORTANT: the COPYRIGHT #define must contain ISO-Latin-1 characters, the
+ * IMAGE_LICENSING #define must contain UTF-8 characters.  The 'copyright'
+ * symbol 0xA9U (\251) in ISO-Latin-1 encoding and 0xC20xA9 (\302\251) in UTF-8.
+ */
+#define IMAGE_LICENSING "Dedicated to the public domain per Creative Commons "\
+    "license \"CC0 1.0\"; https://creativecommons.org/publicdomain/zero/1.0/"
+
+#include <stddef.h> /* for offsetof */
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <math.h>
+#include <errno.h>
+#include <assert.h>
+#include <stdint.h>
+
+#if defined(HAVE_CONFIG_H) && !defined(PNG_NO_CONFIG_H)
+#  include <config.h>
+#endif
+
+/* Define the following to use this test against your installed libpng, rather
+ * than the one being built here:
+ */
+#ifdef PNG_FREESTANDING_TESTS
+#  include <png.h>
+#else
+#  include "../../png.h"
+#endif
+
+#include <zlib.h>
+
+/* Work round for GCC complaints about casting a (double) function result to
+ * an unsigned:
+ */
+static unsigned int
+flooru(double d)
+{
+   d = floor(d);
+   return (unsigned int)d;
+}
+
+static png_byte
+floorb(double d)
+{
+   d = floor(d);
+   return (png_byte)d;
+}
+
+/* This structure is used for inserting extra chunks (the --insert argument, not
+ * documented above.)
+ */
+typedef struct chunk_insert
+{
+   struct chunk_insert *next;
+   void               (*insert)(png_structp, png_infop, int, png_charpp);
+   int                  nparams;
+   png_charp            parameters[1];
+} chunk_insert;
+
+static unsigned int
+channels_of_type(int color_type)
+{
+   if (color_type & PNG_COLOR_MASK_PALETTE)
+      return 1;
+
+   else
+   {
+      int channels = 1;
+
+      if (color_type & PNG_COLOR_MASK_COLOR)
+         channels = 3;
+
+      if (color_type & PNG_COLOR_MASK_ALPHA)
+         return channels + 1;
+
+      else
+         return channels;
+   }
+}
+
+static unsigned int
+pixel_depth_of_type(int color_type, int bit_depth)
+{
+   return channels_of_type(color_type) * bit_depth;
+}
+
+static unsigned int
+image_size_of_type(int color_type, int bit_depth, unsigned int *colors,
+   int small)
+{
+   if (*colors)
+      return 16;
+
+   else
+   {
+      int pixel_depth = pixel_depth_of_type(color_type, bit_depth);
+
+      if (small)
+      {
+         if (pixel_depth <= 8) /* there will be one row */
+            return 1 << pixel_depth;
+
+         else
+            return 256;
+      }
+
+      else if (pixel_depth < 8)
+         return 64;
+
+      else if (pixel_depth > 16)
+         return 1024;
+
+      else
+         return 256;
+   }
+}
+
+static void
+set_color(png_colorp color, png_bytep trans, unsigned int red,
+   unsigned int green, unsigned int blue, unsigned int alpha,
+   png_const_bytep gamma_table)
+{
+   color->red = gamma_table[red];
+   color->green = gamma_table[green];
+   color->blue = gamma_table[blue];
+   *trans = (png_byte)alpha;
+}
+
+static int
+generate_palette(png_colorp palette, png_bytep trans, int bit_depth,
+   png_const_bytep gamma_table, unsigned int *colors)
+{
+   /*
+    * 1-bit: entry 0 is transparent-red, entry 1 is opaque-white
+    * 2-bit: entry 0: transparent-green
+    *        entry 1: 40%-red
+    *        entry 2: 80%-blue
+    *        entry 3: opaque-white
+    * 4-bit: the 16 combinations of the 2-bit case
+    * 8-bit: the 256 combinations of the 4-bit case
+    */
+   switch (colors[0])
+   {
+      default:
+         fprintf(stderr, "makepng: --colors=...: invalid count %u\n",
+            colors[0]);
+         exit(1);
+
+      case 1:
+         set_color(palette+0, trans+0, colors[1], colors[1], colors[1], 255,
+            gamma_table);
+         return 1;
+
+      case 2:
+         set_color(palette+0, trans+0, colors[1], colors[1], colors[1],
+            colors[2], gamma_table);
+         return 1;
+
+      case 3:
+         set_color(palette+0, trans+0, colors[1], colors[2], colors[3], 255,
+            gamma_table);
+         return 1;
+
+      case 4:
+         set_color(palette+0, trans+0, colors[1], colors[2], colors[3],
+            colors[4], gamma_table);
+         return 1;
+
+      case 0:
+         if (bit_depth == 1)
+         {
+            set_color(palette+0, trans+0, 255, 0, 0, 0, gamma_table);
+            set_color(palette+1, trans+1, 255, 255, 255, 255, gamma_table);
+            return 2;
+         }
+
+         else
+         {
+            unsigned int size = 1U << (bit_depth/2); /* 2, 4 or 16 */
+            unsigned int x, y;
+            volatile unsigned int ip = 0;
+
+            for (x=0; x<size; ++x) for (y=0; y<size; ++y)
+            {
+               ip = x + (size * y);
+
+               /* size is at most 16, so the scaled value below fits in 16 bits
+                */
+#              define interp(pos, c1, c2) ((pos * c1) + ((size-pos) * c2))
+#              define xyinterp(x, y, c1, c2, c3, c4) (((size * size / 2) +\
+                  (interp(x, c1, c2) * y + (size-y) * interp(x, c3, c4))) /\
+                  (size*size))
+
+               set_color(palette+ip, trans+ip,
+                  /* color:    green, red,blue,white */
+                  xyinterp(x, y,   0, 255,   0, 255),
+                  xyinterp(x, y, 255,   0,   0, 255),
+                  xyinterp(x, y,   0,   0, 255, 255),
+                  /* alpha:        0, 102, 204, 255) */
+                  xyinterp(x, y,   0, 102, 204, 255),
+                  gamma_table);
+            }
+
+            return ip+1;
+         }
+   }
+}
+
+static void
+set_value(png_bytep row, size_t rowbytes, png_uint_32 x, unsigned int bit_depth,
+   png_uint_32 value, png_const_bytep gamma_table, double conv)
+{
+   unsigned int mask = (1U << bit_depth)-1;
+
+   x *= bit_depth;  /* Maximum x is 4*1024, maximum bit_depth is 16 */
+
+   if (value <= mask)
+   {
+      png_uint_32 offset = x >> 3;
+
+      if (offset < rowbytes && (bit_depth < 16 || offset+1 < rowbytes))
+      {
+         row += offset;
+
+         switch (bit_depth)
+         {
+            case 1:
+            case 2:
+            case 4:
+               /* Don't gamma correct - values get smashed */
+               {
+                  unsigned int shift = (8 - bit_depth) - (x & 0x7U);
+
+                  mask <<= shift;
+                  value = (value << shift) & mask;
+                  *row = (png_byte)((*row & ~mask) | value);
+               }
+               return;
+
+            default:
+               fprintf(stderr, "makepng: bad bit depth (internal error)\n");
+               exit(1);
+
+            case 16:
+               value = flooru(65535*pow(value/65535.,conv)+.5);
+               *row++ = (png_byte)(value >> 8);
+               *row = (png_byte)value;
+               return;
+
+            case 8:
+               *row = gamma_table[value];
+               return;
+         }
+      }
+
+      else
+      {
+         fprintf(stderr, "makepng: row buffer overflow (internal error)\n");
+         exit(1);
+      }
+   }
+
+   else
+   {
+      fprintf(stderr, "makepng: component overflow (internal error)\n");
+      exit(1);
+   }
+}
+
+static int /* filter mask for row */
+generate_row(png_bytep row, size_t rowbytes, unsigned int y, int color_type,
+   int bit_depth, png_const_bytep gamma_table, double conv,
+   unsigned int *colors, int small)
+{
+   int filters = 0; /* file *MASK*, 0 means the default, not NONE */
+   png_uint_32 size_max =
+      image_size_of_type(color_type, bit_depth, colors, small)-1;
+   png_uint_32 depth_max = (1U << bit_depth)-1; /* up to 65536 */
+
+   if (colors[0] == 0) if (small)
+   {
+      unsigned int pixel_depth = pixel_depth_of_type(color_type, bit_depth);
+
+      /* For pixel depths less than 16 generate a single row containing all the
+       * possible pixel values.  For 16 generate all 65536 byte pair
+       * combinations in a 256x256 pixel array.
+       */
+      switch (pixel_depth)
+      {
+         case 1:
+            assert(y == 0 && rowbytes == 1 && size_max == 1);
+            row[0] = 0x6CU; /* binary: 01101100, only top 2 bits used */
+            filters = PNG_FILTER_NONE;
+            break;
+
+         case 2:
+            assert(y == 0 && rowbytes == 1 && size_max == 3);
+            row[0] = 0x1BU; /* binary 00011011, all bits used */
+            filters = PNG_FILTER_NONE;
+            break;
+
+         case 4:
+            assert(y == 0 && rowbytes == 8 && size_max == 15);
+            row[0] = 0x01U;
+            row[1] = 0x23U; /* SUB gives 0x22U for all following bytes */
+            row[2] = 0x45U;
+            row[3] = 0x67U;
+            row[4] = 0x89U;
+            row[5] = 0xABU;
+            row[6] = 0xCDU;
+            row[7] = 0xEFU;
+            filters = PNG_FILTER_SUB;
+            break;
+
+         case 8:
+            /* The row will have all the pixel values in order starting with
+             * '1', the SUB filter will change every byte into '1' (including
+             * the last, which generates pixel value '0').  Since the SUB filter
+             * has value 1 this should result in maximum compression.
+             */
+            assert(y == 0 && rowbytes == 256 && size_max == 255);
+            for (;;)
+            {
+               row[size_max] = 0xFFU & (size_max+1);
+               if (size_max == 0)
+                  break;
+               --size_max;
+            }
+            filters = PNG_FILTER_SUB;
+            break;
+
+         case 16:
+            /* Rows are generated such that each row has a constant difference
+             * between the first and second byte of each pixel and so that the
+             * difference increases by 1 at each row.  The rows start with the
+             * first byte value of 0 and the value increases to 255 across the
+             * row.
+             *
+             * The difference starts at 1, so the first row is:
+             *
+             *     0 1 1 2 2 3 3 4 ... 254 255 255 0
+             *
+             * This means that running the SUB filter on the first row produces:
+             *
+             *   [SUB==1] 0 1 0 1 0 1...
+             *
+             * Then the difference is 2 on the next row, giving:
+             *
+             *    0 2 1 3 2 4 3 5 ... 254 0 255 1
+             *
+             * When the UP filter is run on this libpng produces:
+             *
+             *   [UP ==2] 0 1 0 1 0 1...
+             *
+             * And so on for all the remain rows to the final two * rows:
+             *
+             *    row 254: 0 255 1 0 2 1 3 2 4 3 ... 254 253 255 254
+             *    row 255: 0   0 1 1 2 2 3 3 4 4 ... 254 254 255 255
+             */
+            assert(rowbytes == 512 && size_max == 255);
+            for (;;)
+            {
+               row[2*size_max  ] = 0xFFU & size_max;
+               row[2*size_max+1] = 0xFFU & (size_max+y+1);
+               if (size_max == 0)
+                  break;
+               --size_max;
+            }
+            /* The first row must include PNG_FILTER_UP so that libpng knows we
+             * need to keep it for the following row:
+             */
+            filters = (y == 0 ? PNG_FILTER_SUB+PNG_FILTER_UP : PNG_FILTER_UP);
+            break;
+
+         case 24:
+         case 32:
+         case 48:
+         case 64:
+            /* The rows are filled by an alogorithm similar to the above, in the
+             * first row pixel bytes are all equal, increasing from 0 by 1 for
+             * each pixel.  In the second row the bytes within a pixel are
+             * incremented 1,3,5,7,... from the previous row byte.  Using an odd
+             * number ensures all the possible byte values are used.
+             */
+            assert(size_max == 255 && rowbytes == 256*(pixel_depth>>3));
+            pixel_depth >>= 3; /* now in bytes */
+            while (rowbytes > 0)
+            {
+               const size_t pixel_index = --rowbytes/pixel_depth;
+
+               if (y == 0)
+                  row[rowbytes] = 0xFFU & pixel_index;
+
+               else
+               {
+                  const size_t byte_offset =
+                     rowbytes - pixel_index * pixel_depth;
+
+                  row[rowbytes] =
+                     0xFFU & (pixel_index + (byte_offset * 2*y) + 1);
+               }
+            }
+            filters = (y == 0 ? PNG_FILTER_SUB+PNG_FILTER_UP : PNG_FILTER_UP);
+            break;
+
+         default:
+            assert(0/*NOT REACHED*/);
+      }
+   }
+
+   else switch (channels_of_type(color_type))
+   {
+   /* 1 channel: a square image with a diamond, the least luminous colors are on
+    *    the edge of the image, the most luminous in the center.
+    */
+      case 1:
+         {
+            png_uint_32 x;
+            png_uint_32 base = 2*size_max - abs(2*y-size_max);
+
+            for (x=0; x<=size_max; ++x)
+            {
+               png_uint_32 luma = base - abs(2*x-size_max);
+
+               /* 'luma' is now in the range 0..2*size_max, we need
+                * 0..depth_max
+                */
+               luma = (luma*depth_max + size_max) / (2*size_max);
+               set_value(row, rowbytes, x, bit_depth, luma, gamma_table, conv);
+            }
+         }
+         break;
+
+   /* 2 channels: the color channel increases in luminosity from top to bottom,
+    *    the alpha channel increases in opacity from left to right.
+    */
+      case 2:
+         {
+            png_uint_32 alpha = (depth_max * y * 2 + size_max) / (2 * size_max);
+            png_uint_32 x;
+
+            for (x=0; x<=size_max; ++x)
+            {
+               set_value(row, rowbytes, 2*x, bit_depth,
+                  (depth_max * x * 2 + size_max) / (2 * size_max), gamma_table,
+                  conv);
+               set_value(row, rowbytes, 2*x+1, bit_depth, alpha, gamma_table,
+                  conv);
+            }
+         }
+         break;
+
+   /* 3 channels: linear combinations of, from the top-left corner clockwise,
+    *    black, green, white, red.
+    */
+      case 3:
+         {
+            /* x0: the black->red scale (the value of the red component) at the
+             *     start of the row (blue and green are 0).
+             * x1: the green->white scale (the value of the red and blue
+             *     components at the end of the row; green is depth_max).
+             */
+            png_uint_32 Y = (depth_max * y * 2 + size_max) / (2 * size_max);
+            png_uint_32 x;
+
+            /* Interpolate x/depth_max from start to end:
+             *
+             *        start end         difference
+             * red:     Y    Y            0
+             * green:   0   depth_max   depth_max
+             * blue:    0    Y            Y
+             */
+            for (x=0; x<=size_max; ++x)
+            {
+               set_value(row, rowbytes, 3*x+0, bit_depth, /* red */ Y,
+                     gamma_table, conv);
+               set_value(row, rowbytes, 3*x+1, bit_depth, /* green */
+                  (depth_max * x * 2 + size_max) / (2 * size_max),
+                  gamma_table, conv);
+               set_value(row, rowbytes, 3*x+2, bit_depth, /* blue */
+                  (Y * x * 2 + size_max) / (2 * size_max),
+                  gamma_table, conv);
+            }
+         }
+         break;
+
+   /* 4 channels: linear combinations of, from the top-left corner clockwise,
+    *    transparent, red, green, blue.
+    */
+      case 4:
+         {
+            /* x0: the transparent->blue scale (the value of the blue and alpha
+             *     components) at the start of the row (red and green are 0).
+             * x1: the red->green scale (the value of the red and green
+             *     components at the end of the row; blue is 0 and alpha is
+             *     depth_max).
+             */
+            png_uint_32 Y = (depth_max * y * 2 + size_max) / (2 * size_max);
+            png_uint_32 x;
+
+            /* Interpolate x/depth_max from start to end:
+             *
+             *        start    end       difference
+             * red:     0   depth_max-Y depth_max-Y
+             * green:   0       Y             Y
+             * blue:    Y       0            -Y
+             * alpha:   Y    depth_max  depth_max-Y
+             */
+            for (x=0; x<=size_max; ++x)
+            {
+               set_value(row, rowbytes, 4*x+0, bit_depth, /* red */
+                  ((depth_max-Y) * x * 2 + size_max) / (2 * size_max),
+                  gamma_table, conv);
+               set_value(row, rowbytes, 4*x+1, bit_depth, /* green */
+                  (Y * x * 2 + size_max) / (2 * size_max),
+                  gamma_table, conv);
+               set_value(row, rowbytes, 4*x+2, bit_depth, /* blue */
+                  Y - (Y * x * 2 + size_max) / (2 * size_max),
+                  gamma_table, conv);
+               set_value(row, rowbytes, 4*x+3, bit_depth, /* alpha */
+                  Y + ((depth_max-Y) * x * 2 + size_max) / (2 * size_max),
+                  gamma_table, conv);
+            }
+         }
+         break;
+
+      default:
+         fprintf(stderr, "makepng: internal bad channel count\n");
+         exit(2);
+   }
+
+   else if (color_type & PNG_COLOR_MASK_PALETTE)
+   {
+      /* Palette with fixed color: the image rows are all 0 and the image width
+       * is 16.
+       */
+      memset(row, 0, rowbytes);
+   }
+
+   else if (colors[0] == channels_of_type(color_type))
+      switch (channels_of_type(color_type))
+      {
+         case 1:
+            {
+               png_uint_32 luma = colors[1];
+               png_uint_32 x;
+
+               for (x=0; x<=size_max; ++x)
+                  set_value(row, rowbytes, x, bit_depth, luma, gamma_table,
+                     conv);
+            }
+            break;
+
+         case 2:
+            {
+               png_uint_32 luma = colors[1];
+               png_uint_32 alpha = colors[2];
+               png_uint_32 x;
+
+               for (x=0; x<size_max; ++x)
+               {
+                  set_value(row, rowbytes, 2*x, bit_depth, luma, gamma_table,
+                     conv);
+                  set_value(row, rowbytes, 2*x+1, bit_depth, alpha, gamma_table,
+                     conv);
+               }
+            }
+            break;
+
+         case 3:
+            {
+               png_uint_32 red = colors[1];
+               png_uint_32 green = colors[2];
+               png_uint_32 blue = colors[3];
+               png_uint_32 x;
+
+               for (x=0; x<=size_max; ++x)
+               {
+                  set_value(row, rowbytes, 3*x+0, bit_depth, red, gamma_table,
+                     conv);
+                  set_value(row, rowbytes, 3*x+1, bit_depth, green, gamma_table,
+                     conv);
+                  set_value(row, rowbytes, 3*x+2, bit_depth, blue, gamma_table,
+                     conv);
+               }
+            }
+            break;
+
+         case 4:
+            {
+               png_uint_32 red = colors[1];
+               png_uint_32 green = colors[2];
+               png_uint_32 blue = colors[3];
+               png_uint_32 alpha = colors[4];
+               png_uint_32 x;
+
+               for (x=0; x<=size_max; ++x)
+               {
+                  set_value(row, rowbytes, 4*x+0, bit_depth, red, gamma_table,
+                     conv);
+                  set_value(row, rowbytes, 4*x+1, bit_depth, green, gamma_table,
+                     conv);
+                  set_value(row, rowbytes, 4*x+2, bit_depth, blue, gamma_table,
+                     conv);
+                  set_value(row, rowbytes, 4*x+3, bit_depth, alpha, gamma_table,
+                     conv);
+               }
+            }
+         break;
+
+         default:
+            fprintf(stderr, "makepng: internal bad channel count\n");
+            exit(2);
+      }
+
+   else
+   {
+      fprintf(stderr,
+         "makepng: --color: count(%u) does not match channels(%u)\n",
+         colors[0], channels_of_type(color_type));
+      exit(1);
+   }
+
+   return filters;
+}
+
+
+static void PNGCBAPI
+makepng_warning(png_structp png_ptr, png_const_charp message)
+{
+   const char **ep = png_get_error_ptr(png_ptr);
+   const char *name;
+
+   if (ep != NULL && *ep != NULL)
+      name = *ep;
+
+   else
+      name = "makepng";
+
+  fprintf(stderr, "%s: warning: %s\n", name, message);
+}
+
+static void PNGCBAPI
+makepng_error(png_structp png_ptr, png_const_charp message)
+{
+   makepng_warning(png_ptr, message);
+   png_longjmp(png_ptr, 1);
+}
+
+static int /* 0 on success, else an error code */
+write_png(const char **name, FILE *fp, int color_type, int bit_depth,
+   volatile png_fixed_point gamma, chunk_insert * volatile insert,
+   unsigned int filters, unsigned int *colors, int small, int tRNS)
+{
+   png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
+      name, makepng_error, makepng_warning);
+   volatile png_infop info_ptr = NULL;
+   volatile png_bytep row = NULL;
+
+   if (png_ptr == NULL)
+   {
+      fprintf(stderr, "makepng: OOM allocating write structure\n");
+      return 1;
+   }
+
+   if (setjmp(png_jmpbuf(png_ptr)))
+   {
+      png_structp nv_ptr = png_ptr;
+      png_infop nv_info = info_ptr;
+
+      png_ptr = NULL;
+      info_ptr = NULL;
+      png_destroy_write_struct(&nv_ptr, &nv_info);
+      if (row != NULL) free(row);
+      return 1;
+   }
+
+   /* Allow benign errors so that we can write PNGs with errors */
+   png_set_benign_errors(png_ptr, 1/*allowed*/);
+
+   /* Max out the text compression level in an attempt to make the license
+    * small.   If --small then do the same for the IDAT.
+    */
+   if (small)
+      png_set_compression_level(png_ptr, Z_BEST_COMPRESSION);
+
+   png_set_text_compression_level(png_ptr, Z_BEST_COMPRESSION);
+
+   png_init_io(png_ptr, fp);
+
+   info_ptr = png_create_info_struct(png_ptr);
+   if (info_ptr == NULL)
+      png_error(png_ptr, "OOM allocating info structure");
+
+   {
+      unsigned int size =
+         image_size_of_type(color_type, bit_depth, colors, small);
+      unsigned int ysize;
+      png_fixed_point real_gamma = 45455; /* For sRGB */
+      png_byte gamma_table[256];
+      double conv;
+
+      /* Normally images are square, but with 'small' we want to simply generate
+       * all the pixel values, or all that we reasonably can:
+       */
+      if (small)
+      {
+         unsigned int pixel_depth =
+            pixel_depth_of_type(color_type, bit_depth);
+
+         if (pixel_depth <= 8U)
+         {
+            assert(size == (1U<<pixel_depth));
+            ysize = 1U;
+         }
+
+         else
+         {
+            assert(size == 256U);
+            ysize = 256U;
+         }
+      }
+
+      else
+         ysize = size;
+
+      /* This function uses the libpng values used on read to carry extra
+       * information about the gamma:
+       */
+      if (gamma == PNG_GAMMA_MAC_18)
+         gamma = 65909;
+
+      else if (gamma > 0 && gamma < 1000)
+         gamma = PNG_FP_1;
+
+      if (gamma > 0)
+         real_gamma = gamma;
+
+      {
+         unsigned int i;
+
+         if (real_gamma == 45455) for (i=0; i<256; ++i)
+         {
+            gamma_table[i] = (png_byte)i;
+            conv = 1.;
+         }
+
+         else
+         {
+            /* Convert 'i' from sRGB (45455) to real_gamma, this makes
+             * the images look the same regardless of the gAMA chunk.
+             */
+            conv = real_gamma;
+            conv /= 45455;
+
+            gamma_table[0] = 0;
+
+            for (i=1; i<255; ++i)
+               gamma_table[i] = floorb(pow(i/255.,conv) * 255 + .5);
+
+            gamma_table[255] = 255;
+         }
+      }
+
+      png_set_IHDR(png_ptr, info_ptr, size, ysize, bit_depth, color_type,
+         PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
+
+      if (color_type & PNG_COLOR_MASK_PALETTE)
+      {
+         int npalette;
+         png_color palette[256];
+         png_byte trans[256];
+
+         npalette = generate_palette(palette, trans, bit_depth, gamma_table,
+            colors);
+         png_set_PLTE(png_ptr, info_ptr, palette, npalette);
+
+         if (tRNS)
+            png_set_tRNS(png_ptr, info_ptr, trans, npalette-1,
+               NULL/*transparent color*/);
+
+         /* Reset gamma_table to prevent the image rows being changed */
+         for (npalette=0; npalette<256; ++npalette)
+            gamma_table[npalette] = (png_byte)npalette;
+      }
+
+      else if (tRNS)
+      {
+         png_color_16 col;
+
+         col.red = col.green = col.blue = col.gray =
+            0x0101U & ((1U<<bit_depth)-1U);
+         col.index = 0U;
+         png_set_tRNS(png_ptr, info_ptr, NULL/*trans*/, 1U, &col);
+      }
+
+      if (gamma == PNG_DEFAULT_sRGB)
+         png_set_sRGB(png_ptr, info_ptr, PNG_sRGB_INTENT_ABSOLUTE);
+
+      else if (gamma > 0) /* Else don't set color space information */
+      {
+         png_set_gAMA_fixed(png_ptr, info_ptr, real_gamma);
+
+         /* Just use the sRGB values here. */
+         png_set_cHRM_fixed(png_ptr, info_ptr,
+            /* color      x       y */
+            /* white */ 31270, 32900,
+            /* red   */ 64000, 33000,
+            /* green */ 30000, 60000,
+            /* blue  */ 15000,  6000
+         );
+      }
+
+      /* Insert extra information. */
+      while (insert != NULL)
+      {
+         insert->insert(png_ptr, info_ptr, insert->nparams, insert->parameters);
+         insert = insert->next;
+      }
+
+      /* Write the file header. */
+      png_write_info(png_ptr, info_ptr);
+
+      /* Restrict the filters */
+      png_set_filter(png_ptr, PNG_FILTER_TYPE_BASE, filters);
+
+      {
+#        ifdef PNG_WRITE_INTERLACING_SUPPORTED
+            int passes = png_set_interlace_handling(png_ptr);
+#        else /* !WRITE_INTERLACING */
+            int passes = 1;
+#        endif /* !WRITE_INTERLACING */
+         int pass;
+         size_t rowbytes = png_get_rowbytes(png_ptr, info_ptr);
+
+         row = malloc(rowbytes);
+
+         if (row == NULL)
+            png_error(png_ptr, "OOM allocating row buffer");
+
+         for (pass = 0; pass < passes; ++pass)
+         {
+            unsigned int y;
+
+            for (y=0; y<ysize; ++y)
+            {
+               unsigned int row_filters =
+                  generate_row(row, rowbytes, y, color_type, bit_depth,
+                        gamma_table, conv, colors, small);
+
+               if (row_filters != 0 && filters == PNG_ALL_FILTERS)
+                  png_set_filter(png_ptr, PNG_FILTER_TYPE_BASE, row_filters);
+
+               png_write_row(png_ptr, row);
+            }
+         }
+      }
+   }
+
+   /* Finish writing the file. */
+   png_write_end(png_ptr, info_ptr);
+
+   {
+      png_structp nv_ptr = png_ptr;
+      png_infop nv_info = info_ptr;
+
+      png_ptr = NULL;
+      info_ptr = NULL;
+      png_destroy_write_struct(&nv_ptr, &nv_info);
+   }
+   free(row);
+   return 0;
+}
+
+
+static size_t
+load_file(png_const_charp name, png_bytepp result)
+{
+   FILE *fp = tmpfile();
+
+   if (fp != NULL)
+   {
+      FILE *ip = fopen(name, "rb");
+
+      if (ip != NULL)
+      {
+         size_t total = 0;
+         int ch;
+
+         for (;;)
+         {
+            ch = getc(ip);
+            if (ch == EOF) break;
+            putc(ch, fp);
+            ++total;
+         }
+
+         if (ferror(ip))
+         {
+            perror(name);
+            fprintf(stderr, "%s: read error\n", name);
+            (void)fclose(ip);
+         }
+
+         else
+         {
+            (void)fclose(ip);
+
+            if (ferror(fp))
+            {
+               perror("temporary file");
+               fprintf(stderr, "temporary file write error\n");
+            }
+
+            else
+            {
+               rewind(fp);
+
+               if (total > 0)
+               {
+                  /* Round up to a multiple of 4 here to allow an iCCP profile
+                   * to be padded to a 4x boundary.
+                   */
+                  png_bytep data = malloc((total+3)&~3);
+
+                  if (data != NULL)
+                  {
+                     size_t new_size = 0;
+
+                     for (;;)
+                     {
+                        ch = getc(fp);
+                        if (ch == EOF) break;
+                        data[new_size++] = (png_byte)ch;
+                     }
+
+                     if (ferror(fp) || new_size != total)
+                     {
+                        perror("temporary file");
+                        fprintf(stderr, "temporary file read error\n");
+                        free(data);
+                     }
+
+                     else
+                     {
+                        (void)fclose(fp);
+                        *result = data;
+                        return total;
+                     }
+                  }
+
+                  else
+                     fprintf(stderr, "%s: out of memory loading file\n", name);
+               }
+
+               else
+                  fprintf(stderr, "%s: empty file\n", name);
+            }
+         }
+      }
+
+      else
+      {
+         perror(name);
+         fprintf(stderr, "%s: open failed\n", name);
+      }
+
+      fclose(fp);
+   }
+
+   else
+      fprintf(stderr, "makepng: %s: could not open temporary file\n", name);
+
+   exit(1);
+   return 0;
+}
+
+static size_t
+load_fake(png_charp param, png_bytepp profile)
+{
+   char *endptr = NULL;
+   uint64_t size = strtoull(param, &endptr, 0/*base*/);
+
+   /* The 'fake' format is <number>*[string] */
+   if (endptr != NULL && *endptr == '*')
+   {
+      size_t len = strlen(++endptr);
+      size_t result = (size_t)size;
+
+      if (len == 0) len = 1; /* capture the terminating '\0' */
+
+      /* Now repeat that string to fill 'size' bytes. */
+      if (result == size && (*profile = malloc(result)) != NULL)
+      {
+         png_bytep out = *profile;
+
+         if (len == 1)
+            memset(out, *endptr, result);
+
+         else
+         {
+            while (size >= len)
+            {
+               memcpy(out, endptr, len);
+               out += len;
+               size -= len;
+            }
+            memcpy(out, endptr, size);
+         }
+
+         return result;
+      }
+
+      else
+      {
+         fprintf(stderr, "%s: size exceeds system limits\n", param);
+         exit(1);
+      }
+   }
+
+   return 0;
+}
+
+static void
+check_param_count(int nparams, int expect)
+{
+   if (nparams != expect)
+   {
+      fprintf(stderr, "bad parameter count (internal error)\n");
+      exit(1);
+   }
+}
+
+static void
+insert_iCCP(png_structp png_ptr, png_infop info_ptr, int nparams,
+   png_charpp params)
+{
+   png_bytep profile = NULL;
+   png_uint_32 proflen = 0;
+   int result;
+
+   check_param_count(nparams, 2);
+
+   switch (params[1][0])
+   {
+      case '<':
+         {
+            size_t filelen = load_file(params[1]+1, &profile);
+            if (filelen > 0xfffffffc) /* Maximum profile length */
+            {
+               fprintf(stderr, "%s: file too long (%lu) for an ICC profile\n",
+                  params[1]+1, (unsigned long)filelen);
+               exit(1);
+            }
+
+            proflen = (png_uint_32)filelen;
+         }
+         break;
+
+      case '0': case '1': case '2': case '3': case '4':
+      case '5': case '6': case '7': case '8': case '9':
+         {
+            size_t fake_len = load_fake(params[1], &profile);
+
+            if (fake_len > 0) /* else a simple parameter */
+            {
+               if (fake_len > 0xffffffff) /* Maximum profile length */
+               {
+                  fprintf(stderr,
+                     "%s: fake data too long (%lu) for an ICC profile\n",
+                     params[1], (unsigned long)fake_len);
+                  exit(1);
+               }
+               proflen = (png_uint_32)(fake_len & ~3U);
+               /* Always fix up the profile length. */
+               png_save_uint_32(profile, proflen);
+               break;
+            }
+         }
+
+      default:
+         fprintf(stderr, "--insert iCCP \"%s\": unrecognized\n", params[1]);
+         fprintf(stderr, "  use '<' to read a file: \"<filename\"\n");
+         exit(1);
+   }
+
+   result = 1;
+
+   if (proflen & 3)
+   {
+      fprintf(stderr,
+         "makepng: --insert iCCP %s: profile length made a multiple of 4\n",
+         params[1]);
+
+      /* load_file allocates extra space for this padding, the ICC spec requires
+       * padding with zero bytes.
+       */
+      while (proflen & 3)
+         profile[proflen++] = 0;
+   }
+
+   if (profile != NULL && proflen > 3)
+   {
+      png_uint_32 prof_header = png_get_uint_32(profile);
+
+      if (prof_header != proflen)
+      {
+         fprintf(stderr, "--insert iCCP %s: profile length field wrong:\n",
+            params[1]);
+         fprintf(stderr, "  actual %lu, recorded value %lu (corrected)\n",
+            (unsigned long)proflen, (unsigned long)prof_header);
+         png_save_uint_32(profile, proflen);
+      }
+   }
+
+   if (result && profile != NULL && proflen >=4)
+      png_set_iCCP(png_ptr, info_ptr, params[0], PNG_COMPRESSION_TYPE_BASE,
+         profile, proflen);
+
+   if (profile)
+      free(profile);
+
+   if (!result)
+      exit(1);
+}
+
+static void
+clear_text(png_text *text, png_charp keyword)
+{
+   text->compression = -1; /* none */
+   text->key = keyword;
+   text->text = NULL;
+   text->text_length = 0; /* libpng calculates this */
+   text->itxt_length = 0; /* libpng calculates this */
+   text->lang = NULL;
+   text->lang_key = NULL;
+}
+
+static void
+set_text(png_structp png_ptr, png_infop info_ptr, png_textp text,
+   png_charp param)
+{
+   switch (param[0])
+   {
+      case '<':
+         {
+            png_bytep file = NULL;
+
+            text->text_length = load_file(param+1, &file);
+            text->text = (png_charp)file;
+         }
+         break;
+
+      case '0': case '1': case '2': case '3': case '4':
+      case '5': case '6': case '7': case '8': case '9':
+         {
+            png_bytep data = NULL;
+            size_t fake_len = load_fake(param, &data);
+
+            if (fake_len > 0) /* else a simple parameter */
+            {
+               text->text_length = fake_len;
+               text->text = (png_charp)data;
+               break;
+            }
+         }
+
+      default:
+         text->text = param;
+         break;
+   }
+
+   png_set_text(png_ptr, info_ptr, text, 1);
+
+   if (text->text != param)
+      free(text->text);
+}
+
+static void
+insert_tEXt(png_structp png_ptr, png_infop info_ptr, int nparams,
+   png_charpp params)
+{
+   png_text text;
+
+   check_param_count(nparams, 2);
+   clear_text(&text, params[0]);
+   set_text(png_ptr, info_ptr, &text, params[1]);
+}
+
+static void
+insert_zTXt(png_structp png_ptr, png_infop info_ptr, int nparams,
+   png_charpp params)
+{
+   png_text text;
+
+   check_param_count(nparams, 2);
+   clear_text(&text, params[0]);
+   text.compression = 0; /* deflate */
+   set_text(png_ptr, info_ptr, &text, params[1]);
+}
+
+static void
+insert_iTXt(png_structp png_ptr, png_infop info_ptr, int nparams,
+   png_charpp params)
+{
+   png_text text;
+
+   check_param_count(nparams, 4);
+   clear_text(&text, params[0]);
+   text.compression = 2; /* iTXt + deflate */
+   text.lang = params[1];/* language tag */
+   text.lang_key = params[2]; /* translated keyword */
+   set_text(png_ptr, info_ptr, &text, params[3]);
+}
+
+static void
+insert_hIST(png_structp png_ptr, png_infop info_ptr, int nparams,
+      png_charpp params)
+{
+   int i;
+   png_uint_16 freq[256];
+
+   /* libpng takes the count from the PLTE count; we don't check it here but we
+    * do set the array to 0 for unspecified entries.
+    */
+   memset(freq, 0, sizeof freq);
+   for (i=0; i<nparams; ++i)
+   {
+      char *endptr = NULL;
+      unsigned long int l = strtoul(params[i], &endptr, 0/*base*/);
+
+      if (params[i][0] && *endptr == 0 && l <= 65535)
+         freq[i] = (png_uint_16)l;
+
+      else
+      {
+         fprintf(stderr, "hIST[%d]: %s: invalid frequency\n", i, params[i]);
+         exit(1);
+      }
+   }
+
+   png_set_hIST(png_ptr, info_ptr, freq);
+}
+
+static png_byte
+bval(png_const_structrp png_ptr, png_charp param, unsigned int maxval)
+{
+   char *endptr = NULL;
+   unsigned long int l = strtoul(param, &endptr, 0/*base*/);
+
+   if (param[0] && *endptr == 0 && l <= maxval)
+      return (png_byte)l;
+
+   else
+      png_error(png_ptr, "sBIT: invalid sBIT value");
+}
+
+static void
+insert_sBIT(png_structp png_ptr, png_infop info_ptr, int nparams,
+      png_charpp params)
+{
+   int ct = png_get_color_type(png_ptr, info_ptr);
+   int c = (ct & PNG_COLOR_MASK_COLOR ? 3 : 1) +
+      (ct & PNG_COLOR_MASK_ALPHA ? 1 : 0);
+   unsigned int maxval =
+      ct & PNG_COLOR_MASK_PALETTE ? 8U : png_get_bit_depth(png_ptr, info_ptr);
+   png_color_8 sBIT;
+
+   if (nparams != c)
+      png_error(png_ptr, "sBIT: incorrect parameter count");
+
+   if (ct & PNG_COLOR_MASK_COLOR)
+   {
+      sBIT.red = bval(png_ptr, params[0], maxval);
+      sBIT.green = bval(png_ptr, params[1], maxval);
+      sBIT.blue = bval(png_ptr, params[2], maxval);
+      sBIT.gray = 42;
+   }
+
+   else
+   {
+      sBIT.red = sBIT.green = sBIT.blue = 42;
+      sBIT.gray = bval(png_ptr, params[0], maxval);
+   }
+
+   if (ct & PNG_COLOR_MASK_ALPHA)
+      sBIT.alpha = bval(png_ptr, params[nparams-1], maxval);
+
+   else
+      sBIT.alpha = 42;
+
+   png_set_sBIT(png_ptr, info_ptr, &sBIT);
+}
+
+#if 0
+static void
+insert_sPLT(png_structp png_ptr, png_infop info_ptr, int nparams, png_charpp params)
+{
+   fprintf(stderr, "insert sPLT: NYI\n");
+}
+#endif
+
+static int
+find_parameters(png_const_charp what, png_charp param, png_charp *list,
+   int nparams)
+{
+   /* Parameters are separated by '\n' or ':' characters, up to nparams are
+    * accepted (more is an error) and the number found is returned.
+    */
+   int i;
+   for (i=0; *param && i<nparams; ++i)
+   {
+      list[i] = param;
+      while (*++param) if (*param == '\n' || *param == ':')
+      {
+         *param++ = 0; /* Terminate last parameter */
+         break;        /* And start a new one. */
+      }
+   }
+
+   if (*param)
+   {
+      fprintf(stderr, "--insert %s: too many parameters (%s)\n", what, param);
+      exit(1);
+   }
+
+   list[i] = NULL; /* terminates list */
+   return i; /* number of parameters filled in */
+}
+
+static void
+bad_parameter_count(png_const_charp what, int nparams)
+{
+   fprintf(stderr, "--insert %s: bad parameter count %d\n", what, nparams);
+   exit(1);
+}
+
+static chunk_insert *
+make_insert(png_const_charp what,
+   void (*insert)(png_structp, png_infop, int, png_charpp),
+   int nparams, png_charpp list)
+{
+   int i;
+   chunk_insert *cip;
+
+   cip = malloc(offsetof(chunk_insert,parameters) +
+      nparams * sizeof (png_charp));
+
+   if (cip == NULL)
+   {
+      fprintf(stderr, "--insert %s: out of memory allocating %d parameters\n",
+         what, nparams);
+      exit(1);
+   }
+
+   cip->next = NULL;
+   cip->insert = insert;
+   cip->nparams = nparams;
+   for (i=0; i<nparams; ++i)
+      cip->parameters[i] = list[i];
+
+   return cip;
+}
+
+static chunk_insert *
+find_insert(png_const_charp what, png_charp param)
+{
+   png_uint_32 chunk = 0;
+   png_charp parameter_list[1024];
+   int i, nparams;
+
+   /* Assemble the chunk name */
+   for (i=0; i<4; ++i)
+   {
+      char ch = what[i];
+
+      if ((ch >= 65 && ch <= 90) || (ch >= 97 && ch <= 122))
+         chunk = (chunk << 8) + what[i];
+
+      else
+         break;
+   }
+
+   if (i < 4 || what[4] != 0)
+   {
+      fprintf(stderr, "makepng --insert \"%s\": invalid chunk name\n", what);
+      exit(1);
+   }
+
+   /* Assemble the parameter list. */
+   nparams = find_parameters(what, param, parameter_list, 1024);
+
+#  define CHUNK(a,b,c,d) (((a)<<24)+((b)<<16)+((c)<<8)+(d))
+
+   switch (chunk)
+   {
+      case CHUNK(105,67,67,80):  /* iCCP */
+         if (nparams == 2)
+            return make_insert(what, insert_iCCP, nparams, parameter_list);
+         break;
+
+      case CHUNK(116,69,88,116): /* tEXt */
+         if (nparams == 2)
+            return make_insert(what, insert_tEXt, nparams, parameter_list);
+         break;
+
+      case CHUNK(122,84,88,116): /* zTXt */
+         if (nparams == 2)
+            return make_insert(what, insert_zTXt, nparams, parameter_list);
+         break;
+
+      case CHUNK(105,84,88,116): /* iTXt */
+         if (nparams == 4)
+            return make_insert(what, insert_iTXt, nparams, parameter_list);
+         break;
+
+      case CHUNK(104,73,83,84):  /* hIST */
+         if (nparams <= 256)
+            return make_insert(what, insert_hIST, nparams, parameter_list);
+         break;
+
+      case CHUNK(115,66,73,84): /* sBIT */
+         if (nparams <= 4)
+            return make_insert(what, insert_sBIT, nparams, parameter_list);
+         break;
+
+#if 0
+      case CHUNK(115,80,76,84):  /* sPLT */
+         return make_insert(what, insert_sPLT, nparams, parameter_list);
+#endif
+
+      default:
+         fprintf(stderr, "makepng --insert \"%s\": unrecognized chunk name\n",
+            what);
+         exit(1);
+   }
+
+   bad_parameter_count(what, nparams);
+   return NULL;
+}
+
+/* This is necessary because libpng expects writeable strings for things like
+ * text chunks (maybe this should be fixed...)
+ */
+static png_charp
+strstash(png_const_charp foo)
+{
+   /* The program indicates a memory allocation error by crashing, this is by
+    * design.
+    */
+   if (foo != NULL)
+   {
+      png_charp bar = malloc(strlen(foo)+1);
+      return strcpy(bar, foo);
+   }
+
+   return NULL;
+}
+
+static png_charp
+strstash_list(const png_const_charp *text)
+{
+   size_t foo = 0;
+   png_charp result, bar;
+   const png_const_charp *line = text;
+
+   while (*line != NULL)
+      foo += strlen(*line++);
+
+   result = bar = malloc(foo+1);
+
+   line = text;
+   while (*line != NULL)
+   {
+      foo = strlen(*line);
+      memcpy(bar, *line++, foo);
+      bar += foo;
+   }
+
+   *bar = 0;
+   return result;
+}
+
+/* These are used to insert Copyright and Licence fields, they allow the text to
+ * have \n unlike the --insert option.
+ */
+static chunk_insert *
+add_tEXt(const char *key, const png_const_charp *text)
+{
+   static char what[5] = { 116, 69, 88, 116, 0 };
+   png_charp parameter_list[3];
+
+   parameter_list[0] = strstash(key);
+   parameter_list[1] = strstash_list(text);
+   parameter_list[2] = NULL;
+
+   return make_insert(what, insert_tEXt, 2, parameter_list);
+}
+
+static chunk_insert *
+add_iTXt(const char *key, const char *language, const char *language_key,
+      const png_const_charp *text)
+{
+   static char what[5] = { 105, 84, 88, 116, 0 };
+   png_charp parameter_list[5];
+
+   parameter_list[0] = strstash(key);
+   parameter_list[1] = strstash(language);
+   parameter_list[2] = strstash(language_key);
+   parameter_list[3] = strstash_list(text);
+   parameter_list[4] = NULL;
+
+   return make_insert(what, insert_iTXt, 4, parameter_list);
+}
+
+/* This is a not-very-good parser for a sequence of numbers (including 0).  It
+ * doesn't accept some apparently valid things, but it accepts all the sensible
+ * combinations.
+ */
+static void
+parse_color(char *arg, unsigned int *colors)
+{
+   unsigned int ncolors = 0;
+
+   while (*arg && ncolors < 4)
+   {
+      char *ep = arg;
+
+      unsigned long ul = strtoul(arg, &ep, 0);
+
+      if (ul > 65535)
+      {
+         fprintf(stderr, "makepng --color=...'%s': too big\n", arg);
+         exit(1);
+      }
+
+      if (ep == arg)
+      {
+         fprintf(stderr, "makepng --color=...'%s': not a valid color\n", arg);
+         exit(1);
+      }
+
+      if (*ep) ++ep; /* skip a separator */
+      arg = ep;
+
+      colors[++ncolors] = (unsigned int)ul; /* checked above */
+   }
+
+   if (*arg)
+   {
+      fprintf(stderr, "makepng --color=...'%s': too many values\n", arg);
+      exit(1);
+   }
+
+   *colors = ncolors;
+}
+
+int
+main(int argc, char **argv)
+{
+   FILE *fp = stdout;
+   const char *file_name = NULL;
+   int color_type = 8; /* invalid */
+   int bit_depth = 32; /* invalid */
+   int small = 0; /* make full size images */
+   int tRNS = 0; /* don't output a tRNS chunk */
+   unsigned int colors[5];
+   unsigned int filters = PNG_ALL_FILTERS;
+   png_fixed_point gamma = 0; /* not set */
+   chunk_insert *head_insert = NULL;
+   chunk_insert **insert_ptr = &head_insert;
+
+   memset(colors, 0, sizeof colors);
+
+   while (--argc > 0)
+   {
+      char *arg = *++argv;
+
+      if (strcmp(arg, "--small") == 0)
+      {
+         small = 1;
+         continue;
+      }
+
+      if (strcmp(arg, "--tRNS") == 0)
+      {
+         tRNS = 1;
+         continue;
+      }
+
+      if (strcmp(arg, "--sRGB") == 0)
+      {
+         gamma = PNG_DEFAULT_sRGB;
+         continue;
+      }
+
+      if (strcmp(arg, "--linear") == 0)
+      {
+         gamma = PNG_FP_1;
+         continue;
+      }
+
+      if (strcmp(arg, "--1.8") == 0)
+      {
+         gamma = PNG_GAMMA_MAC_18;
+         continue;
+      }
+
+      if (strcmp(arg, "--nofilters") == 0)
+      {
+         filters = PNG_FILTER_NONE;
+         continue;
+      }
+
+      if (strncmp(arg, "--color=", 8) == 0)
+      {
+          parse_color(arg+8, colors);
+          continue;
+      }
+
+      if (argc >= 3 && strcmp(arg, "--insert") == 0)
+      {
+         png_const_charp what = *++argv;
+         png_charp param = *++argv;
+         chunk_insert *new_insert;
+
+         argc -= 2;
+
+         new_insert = find_insert(what, param);
+
+         if (new_insert != NULL)
+         {
+            *insert_ptr = new_insert;
+            insert_ptr = &new_insert->next;
+         }
+
+         continue;
+      }
+
+      if (arg[0] == '-')
+      {
+         fprintf(stderr, "makepng: %s: invalid option\n", arg);
+         exit(1);
+      }
+
+      if (strcmp(arg, "palette") == 0)
+      {
+         color_type = PNG_COLOR_TYPE_PALETTE;
+         continue;
+      }
+
+      if (strncmp(arg, "gray", 4) == 0)
+      {
+         if (arg[4] == 0)
+         {
+            color_type = PNG_COLOR_TYPE_GRAY;
+            continue;
+         }
+
+         else if (strcmp(arg+4, "a") == 0 ||
+            strcmp(arg+4, "alpha") == 0 ||
+            strcmp(arg+4, "-alpha") == 0)
+         {
+            color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
+            continue;
+         }
+      }
+
+      if (strncmp(arg, "rgb", 3) == 0)
+      {
+         if (arg[3] == 0)
+         {
+            color_type = PNG_COLOR_TYPE_RGB;
+            continue;
+         }
+
+         else if (strcmp(arg+3, "a") == 0 ||
+            strcmp(arg+3, "alpha") == 0 ||
+            strcmp(arg+3, "-alpha") == 0)
+         {
+            color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+            continue;
+         }
+      }
+
+      if (color_type == 8 && isdigit(arg[0]))
+      {
+         color_type = atoi(arg);
+         if (color_type < 0 || color_type > 6 || color_type == 1 ||
+            color_type == 5)
+         {
+            fprintf(stderr, "makepng: %s: not a valid color type\n", arg);
+            exit(1);
+         }
+
+         continue;
+      }
+
+      if (bit_depth == 32 && isdigit(arg[0]))
+      {
+         bit_depth = atoi(arg);
+         if (bit_depth <= 0 || bit_depth > 16 ||
+            (bit_depth & -bit_depth) != bit_depth)
+         {
+            fprintf(stderr, "makepng: %s: not a valid bit depth\n", arg);
+            exit(1);
+         }
+
+         continue;
+      }
+
+      if (argc == 1) /* It's the file name */
+      {
+         fp = fopen(arg, "wb");
+         if (fp == NULL)
+         {
+            fprintf(stderr, "%s: %s: could not open\n", arg, strerror(errno));
+            exit(1);
+         }
+
+         file_name = arg;
+         continue;
+      }
+
+      fprintf(stderr, "makepng: %s: unknown argument\n", arg);
+      exit(1);
+   } /* argument while loop */
+
+   if (color_type == 8 || bit_depth == 32)
+   {
+      fprintf(stderr, "usage: makepng [--small] [--sRGB|--linear|--1.8] "
+         "[--color=...] color-type bit-depth [file-name]\n"
+         "  Make a test PNG file, by default writes to stdout.\n"
+         "  Other options are available, UTSL.\n");
+      exit(1);
+   }
+
+   /* Check the colors */
+   {
+      unsigned int lim = (color_type == PNG_COLOR_TYPE_PALETTE ? 255U :
+         (1U<<bit_depth)-1);
+      unsigned int i;
+
+      for (i=1; i<=colors[0]; ++i)
+         if (colors[i] > lim)
+         {
+            fprintf(stderr, "makepng: --color=...: %u out of range [0..%u]\n",
+               colors[i], lim);
+            exit(1);
+         }
+   }
+
+   /* small and colors are incomparible (will probably crash if both are used at
+    * the same time!)
+    */
+   if (small && colors[0] != 0)
+   {
+      fprintf(stderr, "makepng: --color --small: only one at a time!\n");
+      exit(1);
+   }
+
+   /* Restrict the filters for more speed to those we know are used for the
+    * generated images.
+    */
+   if (filters == PNG_ALL_FILTERS && !small/*small provides defaults*/)
+   {
+      if ((color_type & PNG_COLOR_MASK_PALETTE) != 0 || bit_depth < 8)
+         filters = PNG_FILTER_NONE;
+
+      else if (color_type & PNG_COLOR_MASK_COLOR) /* rgb */
+      {
+         if (bit_depth == 8)
+            filters &= ~(PNG_FILTER_NONE | PNG_FILTER_AVG);
+
+         else
+            filters = PNG_FILTER_SUB | PNG_FILTER_PAETH;
+      }
+
+      else /* gray 8 or 16-bit */
+         filters &= ~PNG_FILTER_NONE;
+   }
+
+   /* Insert standard copyright and licence text. */
+   {
+      static png_const_charp copyright[] =
+      {
+         COPYRIGHT, /* ISO-Latin-1 */
+         NULL
+      };
+      static png_const_charp licensing[] =
+      {
+         IMAGE_LICENSING, /* UTF-8 */
+         NULL
+      };
+
+      chunk_insert *new_insert;
+
+      new_insert = add_tEXt("Copyright", copyright);
+      if (new_insert != NULL)
+      {
+         *insert_ptr = new_insert;
+         insert_ptr = &new_insert->next;
+      }
+
+      new_insert = add_iTXt("Licensing", "en", NULL, licensing);
+      if (new_insert != NULL)
+      {
+         *insert_ptr = new_insert;
+         insert_ptr = &new_insert->next;
+      }
+   }
+
+   {
+      int ret = write_png(&file_name, fp, color_type, bit_depth, gamma,
+         head_insert, filters, colors, small, tRNS);
+
+      if (ret != 0 && file_name != NULL)
+         remove(file_name);
+
+      return ret;
+   }
+}
diff --git a/Engine/lib/lpng/contrib/libtests/pngimage.c b/Engine/lib/lpng/contrib/libtests/pngimage.c
new file mode 100644
index 000000000..f130c043d
--- /dev/null
+++ b/Engine/lib/lpng/contrib/libtests/pngimage.c
@@ -0,0 +1,1712 @@
+/* pngimage.c
+ *
+ * Copyright (c) 2015,2016 John Cunningham Bowler
+ *
+ * Last changed in libpng 1.6.24 [August 4, 2016]
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * Test the png_read_png and png_write_png interfaces.  Given a PNG file load it
+ * using png_read_png and then write with png_write_png.  Test all possible
+ * transforms.
+ */
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <stdio.h>
+#include <assert.h>
+
+#if defined(HAVE_CONFIG_H) && !defined(PNG_NO_CONFIG_H)
+#  include <config.h>
+#endif
+
+/* Define the following to use this test against your installed libpng, rather
+ * than the one being built here:
+ */
+#ifdef PNG_FREESTANDING_TESTS
+#  include <png.h>
+#else
+#  include "../../png.h"
+#endif
+
+#ifndef PNG_SETJMP_SUPPORTED
+#  include <setjmp.h> /* because png.h did *not* include this */
+#endif
+
+/* 1.6.1 added support for the configure test harness, which uses 77 to indicate
+ * a skipped test, in earlier versions we need to succeed on a skipped test, so:
+ */
+#if PNG_LIBPNG_VER >= 10601 && defined(HAVE_CONFIG_H)
+#  define SKIP 77
+#else
+#  define SKIP 0
+#endif
+
+#if PNG_LIBPNG_VER < 10700
+   /* READ_PNG and WRITE_PNG were not defined, so: */
+#  ifdef PNG_INFO_IMAGE_SUPPORTED
+#     ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+#        define PNG_READ_PNG_SUPPORTED
+#     endif /* SEQUENTIAL_READ */
+#     ifdef PNG_WRITE_SUPPORTED
+#        define PNG_WRITE_PNG_SUPPORTED
+#     endif /* WRITE */
+#  endif /* INFO_IMAGE */
+#endif /* pre 1.7.0 */
+
+#ifdef PNG_READ_PNG_SUPPORTED
+/* If a transform is valid on both read and write this implies that if the
+ * transform is applied to read it must also be applied on write to produce
+ * meaningful data.  This is because these transforms when performed on read
+ * produce data with a memory format that does not correspond to a PNG format.
+ *
+ * Most of these transforms are invertible; after applying the transform on
+ * write the result is the original PNG data that would have would have been
+ * read if no transform were applied.
+ *
+ * The exception is _SHIFT, which destroys the low order bits marked as not
+ * significant in a PNG with the sBIT chunk.
+ *
+ * The following table lists, for each transform, the conditions under which it
+ * is expected to do anything.  Conditions are defined as follows:
+ *
+ * 1) Color mask bits required - simply a mask to AND with color_type; one of
+ *    these must be present for the transform to fire, except that 0 means
+ *    'always'.
+ * 2) Color mask bits which must be absent - another mask - none of these must
+ *    be present.
+ * 3) Bit depths - a mask of component bit depths for the transform to fire.
+ * 4) 'read' - the transform works in png_read_png.
+ * 5) 'write' - the transform works in png_write_png.
+ * 6) PNG_INFO_chunk; a mask of the chunks that must be present for the
+ *    transform to fire.  All must be present - the requirement is that
+ *    png_get_valid() & mask == mask, so if mask is 0 there is no requirement.
+ *
+ * The condition refers to the original image state - if multiple transforms are
+ * used together it is possible to cause a transform that wouldn't fire on the
+ * original image to fire.
+ */
+static struct transform_info
+{
+   const char *name;
+   int         transform;
+   png_uint_32 valid_chunks;
+#     define CHUNK_NONE 0
+#     define CHUNK_sBIT PNG_INFO_sBIT
+#     define CHUNK_tRNS PNG_INFO_tRNS
+   png_byte    color_mask_required;
+   png_byte    color_mask_absent;
+#     define COLOR_MASK_X   0
+#     define COLOR_MASK_P   PNG_COLOR_MASK_PALETTE
+#     define COLOR_MASK_C   PNG_COLOR_MASK_COLOR
+#     define COLOR_MASK_A   PNG_COLOR_MASK_ALPHA
+#     define COLOR_MASK_ALL (PALETTE+COLOR+ALPHA)  /* absent = gray, no alpha */
+   png_byte    bit_depths;
+#     define BD_ALL  (1 + 2 + 4 + 8 + 16)
+#     define BD_PAL  (1 + 2 + 4 + 8)
+#     define BD_LOW  (1 + 2 + 4)
+#     define BD_16   16
+#     define BD_TRUE (8+16) /* i.e. true-color depths */
+   png_byte    when;
+#     define TRANSFORM_R  1
+#     define TRANSFORM_W  2
+#     define TRANSFORM_RW 3
+   png_byte    tested; /* the transform was tested somewhere */
+} transform_info[] =
+{
+   /* List ALL the PNG_TRANSFORM_ macros here.  Check for support using the READ
+    * macros; even if the transform is supported on write it cannot be tested
+    * without the read support.
+    */
+#  define T(name,chunk,cm_required,cm_absent,bd,when)\
+   {  #name, PNG_TRANSFORM_ ## name, CHUNK_ ## chunk,\
+      COLOR_MASK_ ## cm_required, COLOR_MASK_ ## cm_absent, BD_ ## bd,\
+      TRANSFORM_ ## when, 0/*!tested*/ }
+
+#ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED
+   T(STRIP_16,            NONE, X,   X,   16,  R),
+      /* drops the bottom 8 bits when bit depth is 16 */
+#endif
+#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
+   T(STRIP_ALPHA,         NONE, A,   X,  ALL,  R),
+      /* removes the alpha channel if present */
+#endif
+#ifdef PNG_WRITE_PACK_SUPPORTED
+#  define TRANSFORM_RW_PACK TRANSFORM_RW
+#else
+#  define TRANSFORM_RW_PACK TRANSFORM_R
+#endif
+#ifdef PNG_READ_PACK_SUPPORTED
+   T(PACKING,             NONE, X,   X,  LOW, RW_PACK),
+      /* unpacks low-bit-depth components into 1 byte per component on read,
+       * reverses this on write.
+       */
+#endif
+#ifdef PNG_WRITE_PACKSWAP_SUPPORTED
+#  define TRANSFORM_RW_PACKSWAP TRANSFORM_RW
+#else
+#  define TRANSFORM_RW_PACKSWAP TRANSFORM_R
+#endif
+#ifdef PNG_READ_PACKSWAP_SUPPORTED
+   T(PACKSWAP,            NONE, X,   X,  LOW, RW_PACKSWAP),
+      /* reverses the order of low-bit-depth components packed into a byte */
+#endif
+#ifdef PNG_READ_EXPAND_SUPPORTED
+   T(EXPAND,              NONE, P,   X,  ALL,  R),
+      /* expands PLTE PNG files to RGB (no tRNS) or RGBA (tRNS) *
+       * Note that the 'EXPAND' transform does lots of different things: */
+   T(EXPAND,              NONE, X,   C,  ALL,  R),
+      /* expands grayscale PNG files to RGB, or RGBA */
+   T(EXPAND,              tRNS, X,   A,  ALL,  R),
+      /* expands the tRNS chunk in files without alpha */
+#endif
+#ifdef PNG_WRITE_INVERT_SUPPORTED
+#  define TRANSFORM_RW_INVERT TRANSFORM_RW
+#else
+#  define TRANSFORM_RW_INVERT TRANSFORM_R
+#endif
+#ifdef PNG_READ_INVERT_SUPPORTED
+   T(INVERT_MONO,         NONE, X,   C,  ALL, RW_INVERT),
+      /* converts gray-scale components to 1..0 from 0..1 */
+#endif
+#ifdef PNG_WRITE_SHIFT_SUPPORTED
+#  define TRANSFORM_RW_SHIFT TRANSFORM_RW
+#else
+#  define TRANSFORM_RW_SHIFT TRANSFORM_R
+#endif
+#ifdef PNG_READ_SHIFT_SUPPORTED
+   T(SHIFT,               sBIT, X,   X,  ALL, RW_SHIFT),
+      /* reduces component values to the original range based on the sBIT chunk,
+       * this is only partially reversible - the low bits are lost and cannot be
+       * recovered on write.  In fact write code replicates the bits to generate
+       * new low-order bits.
+       */
+#endif
+#ifdef PNG_WRITE_BGR_SUPPORTED
+#  define TRANSFORM_RW_BGR TRANSFORM_RW
+#else
+#  define TRANSFORM_RW_BGR TRANSFORM_R
+#endif
+#ifdef PNG_READ_BGR_SUPPORTED
+   T(BGR,                 NONE, C,   P, TRUE, RW_BGR),
+      /* reverses the rgb component values of true-color pixels */
+#endif
+#ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED
+#  define TRANSFORM_RW_SWAP_ALPHA TRANSFORM_RW
+#else
+#  define TRANSFORM_RW_SWAP_ALPHA TRANSFORM_R
+#endif
+#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED
+   T(SWAP_ALPHA,          NONE, A,   X, TRUE, RW_SWAP_ALPHA),
+      /* swaps the alpha channel of RGBA or GA pixels to the front - ARGB or
+       * AG, on write reverses the process.
+       */
+#endif
+#ifdef PNG_WRITE_SWAP_SUPPORTED
+#  define TRANSFORM_RW_SWAP TRANSFORM_RW
+#else
+#  define TRANSFORM_RW_SWAP TRANSFORM_R
+#endif
+#ifdef PNG_READ_SWAP_SUPPORTED
+   T(SWAP_ENDIAN,         NONE, X,   P,   16, RW_SWAP),
+      /* byte-swaps 16-bit component values */
+#endif
+#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
+#  define TRANSFORM_RW_INVERT_ALPHA TRANSFORM_RW
+#else
+#  define TRANSFORM_RW_INVERT_ALPHA TRANSFORM_R
+#endif
+#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
+   T(INVERT_ALPHA,        NONE, A,   X, TRUE, RW_INVERT_ALPHA),
+      /* converts an alpha channel from 0..1 to 1..0 */
+#endif
+#ifdef PNG_WRITE_FILLER_SUPPORTED
+   T(STRIP_FILLER_BEFORE, NONE, A,   P, TRUE,  W), /* 'A' for a filler! */
+      /* on write skips a leading filler channel; testing requires data with a
+       * filler channel so this is produced from RGBA or GA images by removing
+       * the 'alpha' flag from the color type in place.
+       */
+   T(STRIP_FILLER_AFTER,  NONE, A,   P, TRUE,  W),
+      /* on write strips a trailing filler channel */
+#endif
+#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
+   T(GRAY_TO_RGB,         NONE, X,   C,  ALL,  R),
+      /* expands grayscale images to RGB, also causes the palette part of
+       * 'EXPAND' to happen.  Low bit depth grayscale images are expanded to
+       * 8-bits per component and no attempt is made to convert the image to a
+       * palette image.  While this transform is partially reversible
+       * png_write_png does not currently support this.
+       */
+   T(GRAY_TO_RGB,         NONE, P,   X,  ALL,  R),
+      /* The 'palette' side effect mentioned above; a bit bogus but this is the
+       * way the libpng code works.
+       */
+#endif
+#ifdef PNG_READ_EXPAND_16_SUPPORTED
+   T(EXPAND_16,           NONE, X,   X,  PAL,  R),
+      /* expands images to 16-bits per component, as a side effect expands
+       * palette images to RGB and expands the tRNS chunk if present, so it can
+       * modify 16-bit per component images as well:
+       */
+   T(EXPAND_16,           tRNS, X,   A,   16,  R),
+      /* side effect of EXPAND_16 - expands the tRNS chunk in an RGB or G 16-bit
+       * image.
+       */
+#endif
+#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
+   T(SCALE_16,            NONE, X,   X,   16,  R),
+      /* scales 16-bit components to 8-bits. */
+#endif
+
+   { NULL /*name*/, 0, 0, 0, 0, 0, 0, 0/*!tested*/ }
+
+#undef T
+};
+
+#define ARRAY_SIZE(a) ((sizeof a)/(sizeof a[0]))
+#define TTABLE_SIZE ARRAY_SIZE(transform_info)
+
+/* Some combinations of options that should be reversible are not; these cases
+ * are bugs.
+ */
+static int known_bad_combos[][2] =
+{
+   /* problem, antidote */
+   { PNG_TRANSFORM_SHIFT | PNG_TRANSFORM_INVERT_ALPHA, 0/*antidote*/ }
+};
+
+static int
+is_combo(int transforms)
+{
+   return transforms & (transforms-1); /* non-zero if more than one set bit */
+}
+
+static int
+first_transform(int transforms)
+{
+   return transforms & -transforms; /* lowest set bit */
+}
+
+static int
+is_bad_combo(int transforms)
+{
+   unsigned int i;
+
+   for (i=0; i<ARRAY_SIZE(known_bad_combos); ++i)
+   {
+      int combo = known_bad_combos[i][0];
+
+      if ((combo & transforms) == combo &&
+         (transforms & known_bad_combos[i][1]) == 0)
+         return 1;
+   }
+
+   return 0; /* combo is ok */
+}
+
+static const char *
+transform_name(int t)
+   /* The name, if 't' has multiple bits set the name of the lowest set bit is
+    * returned.
+    */
+{
+   unsigned int i;
+
+   t &= -t; /* first set bit */
+
+   for (i=0; i<TTABLE_SIZE; ++i) if (transform_info[i].name != NULL)
+   {
+      if ((transform_info[i].transform & t) != 0)
+         return transform_info[i].name;
+   }
+
+   return "invalid transform";
+}
+
+/* Variables calculated by validate_T below and used to record all the supported
+ * transforms.  Need (unsigned int) here because of the places where these
+ * values are used (unsigned compares in the 'exhaustive' iterator.)
+ */
+static unsigned int read_transforms, write_transforms, rw_transforms;
+
+static void
+validate_T(void)
+   /* Validate the above table - this just builds the above values */
+{
+   unsigned int i;
+
+   for (i=0; i<TTABLE_SIZE; ++i) if (transform_info[i].name != NULL)
+   {
+      if (transform_info[i].when & TRANSFORM_R)
+         read_transforms |= transform_info[i].transform;
+
+      if (transform_info[i].when & TRANSFORM_W)
+         write_transforms |= transform_info[i].transform;
+   }
+
+   /* Reversible transforms are those which are supported on both read and
+    * write.
+    */
+   rw_transforms = read_transforms & write_transforms;
+}
+
+/* FILE DATA HANDLING
+ *    The original file is cached in memory.  During write the output file is
+ *    written to memory.
+ *
+ *    In both cases the file data is held in a linked list of buffers - not all
+ *    of these are in use at any time.
+ */
+#define NEW(type) ((type *)malloc(sizeof (type)))
+#define DELETE(ptr) (free(ptr))
+
+struct buffer_list
+{
+   struct buffer_list *next;         /* next buffer in list */
+   png_byte            buffer[1024]; /* the actual buffer */
+};
+
+struct buffer
+{
+   struct buffer_list  *last;       /* last buffer in use */
+   size_t               end_count;  /* bytes in the last buffer */
+   struct buffer_list  *current;    /* current buffer being read */
+   size_t               read_count; /* count of bytes read from current */
+   struct buffer_list   first;      /* the very first buffer */
+};
+
+static void
+buffer_init(struct buffer *buffer)
+   /* Call this only once for a given buffer */
+{
+   buffer->first.next = NULL;
+   buffer->last = NULL;
+   buffer->current = NULL;
+}
+
+static void
+buffer_destroy_list(struct buffer_list *list)
+{
+   if (list != NULL)
+   {
+      struct buffer_list *next = list->next;
+      DELETE(list);
+      buffer_destroy_list(next);
+   }
+}
+
+static void
+buffer_destroy(struct buffer *buffer)
+{
+   struct buffer_list *list = buffer->first.next;
+   buffer_init(buffer);
+   buffer_destroy_list(list);
+}
+
+#ifdef PNG_WRITE_PNG_SUPPORTED
+static void
+buffer_start_write(struct buffer *buffer)
+{
+   buffer->last = &buffer->first;
+   buffer->end_count = 0;
+   buffer->current = NULL;
+}
+#endif
+
+static void
+buffer_start_read(struct buffer *buffer)
+{
+   buffer->current = &buffer->first;
+   buffer->read_count = 0;
+}
+
+#ifdef ENOMEM /* required by POSIX 1003.1 */
+#  define MEMORY ENOMEM
+#else
+#  define MEMORY ERANGE /* required by ANSI-C */
+#endif
+static struct buffer *
+get_buffer(png_structp pp)
+   /* Used from libpng callbacks to get the current buffer */
+{
+   return (struct buffer*)png_get_io_ptr(pp);
+}
+
+static struct buffer_list *
+buffer_extend(struct buffer_list *current)
+{
+   struct buffer_list *add;
+
+   assert(current->next == NULL);
+
+   add = NEW(struct buffer_list);
+   if (add == NULL)
+      return NULL;
+
+   add->next = NULL;
+   current->next = add;
+
+   return add;
+}
+
+/* Load a buffer from a file; does the equivalent of buffer_start_write.  On a
+ * read error returns an errno value, else returns 0.
+ */
+static int
+buffer_from_file(struct buffer *buffer, FILE *fp)
+{
+   struct buffer_list *last = &buffer->first;
+   size_t count = 0;
+
+   for (;;)
+   {
+      size_t r = fread(last->buffer+count, 1/*size*/,
+         (sizeof last->buffer)-count, fp);
+
+      if (r > 0)
+      {
+         count += r;
+
+         if (count >= sizeof last->buffer)
+         {
+            assert(count == sizeof last->buffer);
+            count = 0;
+
+            if (last->next == NULL)
+            {
+               last = buffer_extend(last);
+               if (last == NULL)
+                  return MEMORY;
+            }
+
+            else
+               last = last->next;
+         }
+      }
+
+      else /* fread failed - probably end of file */
+      {
+         if (feof(fp))
+         {
+            buffer->last = last;
+            buffer->end_count = count;
+            return 0; /* no error */
+         }
+
+         /* Some kind of funky error; errno should be non-zero */
+         return errno == 0 ? ERANGE : errno;
+      }
+   }
+}
+
+/* This structure is used to control the test of a single file. */
+typedef enum
+{
+   VERBOSE,        /* switches on all messages */
+   INFORMATION,
+   WARNINGS,       /* switches on warnings */
+   LIBPNG_WARNING,
+   APP_WARNING,
+   ERRORS,         /* just errors */
+   APP_FAIL,       /* continuable error - no need to longjmp */
+   LIBPNG_ERROR,   /* this and higher cause a longjmp */
+   LIBPNG_BUG,     /* erroneous behavior in libpng */
+   APP_ERROR,      /* such as out-of-memory in a callback */
+   QUIET,          /* no normal messages */
+   USER_ERROR,     /* such as file-not-found */
+   INTERNAL_ERROR
+} error_level;
+#define LEVEL_MASK      0xf   /* where the level is in 'options' */
+
+#define EXHAUSTIVE      0x010 /* Test all combinations of active options */
+#define STRICT          0x020 /* Fail on warnings as well as errors */
+#define LOG             0x040 /* Log pass/fail to stdout */
+#define CONTINUE        0x080 /* Continue on APP_FAIL errors */
+#define SKIP_BUGS       0x100 /* Skip over known bugs */
+#define LOG_SKIPPED     0x200 /* Log skipped bugs */
+#define FIND_BAD_COMBOS 0x400 /* Attempt to deduce bad combos */
+#define LIST_COMBOS     0x800 /* List combos by name */
+
+/* Result masks apply to the result bits in the 'results' field below; these
+ * bits are simple 1U<<error_level.  A pass requires either nothing worse than
+ * warnings (--relaxes) or nothing worse than information (--strict)
+ */
+#define RESULT_STRICT(r)   (((r) & ~((1U<<WARNINGS)-1)) == 0)
+#define RESULT_RELAXED(r)  (((r) & ~((1U<<ERRORS)-1)) == 0)
+
+struct display
+{
+   jmp_buf        error_return;      /* Where to go to on error */
+
+   const char    *filename;          /* The name of the original file */
+   const char    *operation;         /* Operation being performed */
+   int            transforms;        /* Transform used in operation */
+   png_uint_32    options;           /* See display_log below */
+   png_uint_32    results;           /* A mask of errors seen */
+
+
+   png_structp    original_pp;       /* used on the original read */
+   png_infop      original_ip;       /* set by the original read */
+
+   size_t         original_rowbytes; /* of the original rows: */
+   png_bytepp     original_rows;     /* from the original read */
+
+   /* Original chunks valid */
+   png_uint_32    chunks;
+
+   /* Original IHDR information */
+   png_uint_32    width;
+   png_uint_32    height;
+   int            bit_depth;
+   int            color_type;
+   int            interlace_method;
+   int            compression_method;
+   int            filter_method;
+
+   /* Derived information for the original image. */
+   int            active_transforms;  /* transforms that do something on read */
+   int            ignored_transforms; /* transforms that should do nothing */
+
+   /* Used on a read, both the original read and when validating a written
+    * image.
+    */
+   png_structp    read_pp;
+   png_infop      read_ip;
+
+#  ifdef PNG_WRITE_PNG_SUPPORTED
+      /* Used to write a new image (the original info_ptr is used) */
+      png_structp   write_pp;
+      struct buffer written_file;   /* where the file gets written */
+#  endif
+
+   struct buffer  original_file;     /* Data read from the original file */
+};
+
+static void
+display_init(struct display *dp)
+   /* Call this only once right at the start to initialize the control
+    * structure, the (struct buffer) lists are maintained across calls - the
+    * memory is not freed.
+    */
+{
+   memset(dp, 0, sizeof *dp);
+   dp->options = WARNINGS; /* default to !verbose, !quiet */
+   dp->filename = NULL;
+   dp->operation = NULL;
+   dp->original_pp = NULL;
+   dp->original_ip = NULL;
+   dp->original_rows = NULL;
+   dp->read_pp = NULL;
+   dp->read_ip = NULL;
+   buffer_init(&dp->original_file);
+
+#  ifdef PNG_WRITE_PNG_SUPPORTED
+      dp->write_pp = NULL;
+      buffer_init(&dp->written_file);
+#  endif
+}
+
+static void
+display_clean_read(struct display *dp)
+{
+   if (dp->read_pp != NULL)
+      png_destroy_read_struct(&dp->read_pp, &dp->read_ip, NULL);
+}
+
+#ifdef PNG_WRITE_PNG_SUPPORTED
+static void
+display_clean_write(struct display *dp)
+{
+      if (dp->write_pp != NULL)
+         png_destroy_write_struct(&dp->write_pp, NULL);
+}
+#endif
+
+static void
+display_clean(struct display *dp)
+{
+#  ifdef PNG_WRITE_PNG_SUPPORTED
+      display_clean_write(dp);
+#  endif
+   display_clean_read(dp);
+
+   dp->original_rowbytes = 0;
+   dp->original_rows = NULL;
+   dp->chunks = 0;
+
+   png_destroy_read_struct(&dp->original_pp, &dp->original_ip, NULL);
+   /* leave the filename for error detection */
+   dp->results = 0; /* reset for next time */
+}
+
+static void
+display_destroy(struct display *dp)
+{
+    /* Release any memory held in the display. */
+#  ifdef PNG_WRITE_PNG_SUPPORTED
+      buffer_destroy(&dp->written_file);
+#  endif
+
+   buffer_destroy(&dp->original_file);
+}
+
+static struct display *
+get_dp(png_structp pp)
+   /* The display pointer is always stored in the png_struct error pointer */
+{
+   struct display *dp = (struct display*)png_get_error_ptr(pp);
+
+   if (dp == NULL)
+   {
+      fprintf(stderr, "pngimage: internal error (no display)\n");
+      exit(99); /* prevents a crash */
+   }
+
+   return dp;
+}
+
+/* error handling */
+#ifdef __GNUC__
+#  define VGATTR __attribute__((__format__ (__printf__,3,4)))
+   /* Required to quiet GNUC warnings when the compiler sees a stdarg function
+    * that calls one of the stdio v APIs.
+    */
+#else
+#  define VGATTR
+#endif
+static void VGATTR
+display_log(struct display *dp, error_level level, const char *fmt, ...)
+   /* 'level' is as above, fmt is a stdio style format string.  This routine
+    * does not return if level is above LIBPNG_WARNING
+    */
+{
+   dp->results |= 1U << level;
+
+   if (level > (error_level)(dp->options & LEVEL_MASK))
+   {
+      const char *lp;
+      va_list ap;
+
+      switch (level)
+      {
+         case INFORMATION:    lp = "information"; break;
+         case LIBPNG_WARNING: lp = "warning(libpng)"; break;
+         case APP_WARNING:    lp = "warning(pngimage)"; break;
+         case APP_FAIL:       lp = "error(continuable)"; break;
+         case LIBPNG_ERROR:   lp = "error(libpng)"; break;
+         case LIBPNG_BUG:     lp = "bug(libpng)"; break;
+         case APP_ERROR:      lp = "error(pngimage)"; break;
+         case USER_ERROR:     lp = "error(user)"; break;
+
+         case INTERNAL_ERROR: /* anything unexpected is an internal error: */
+         case VERBOSE: case WARNINGS: case ERRORS: case QUIET:
+         default:             lp = "bug(pngimage)"; break;
+      }
+
+      fprintf(stderr, "%s: %s: %s",
+         dp->filename != NULL ? dp->filename : "<stdin>", lp, dp->operation);
+
+      if (dp->transforms != 0)
+      {
+         int tr = dp->transforms;
+
+         if (is_combo(tr))
+         {
+            if (dp->options & LIST_COMBOS)
+            {
+               int trx = tr;
+
+               fprintf(stderr, "(");
+               if (trx)
+               {
+                  int start = 0;
+
+                  while (trx)
+                  {
+                     int trz = trx & -trx;
+
+                     if (start) fprintf(stderr, "+");
+                     fprintf(stderr, "%s", transform_name(trz));
+                     start = 1;
+                     trx &= ~trz;
+                  }
+               }
+
+               else
+                  fprintf(stderr, "-");
+               fprintf(stderr, ")");
+            }
+
+            else
+               fprintf(stderr, "(0x%x)", tr);
+         }
+
+         else
+            fprintf(stderr, "(%s)", transform_name(tr));
+      }
+
+      fprintf(stderr, ": ");
+
+      va_start(ap, fmt);
+      vfprintf(stderr, fmt, ap);
+      va_end(ap);
+
+      fputc('\n', stderr);
+   }
+   /* else do not output any message */
+
+   /* Errors cause this routine to exit to the fail code */
+   if (level > APP_FAIL || (level > ERRORS && !(dp->options & CONTINUE)))
+      longjmp(dp->error_return, level);
+}
+
+/* error handler callbacks for libpng */
+static void PNGCBAPI
+display_warning(png_structp pp, png_const_charp warning)
+{
+   display_log(get_dp(pp), LIBPNG_WARNING, "%s", warning);
+}
+
+static void PNGCBAPI
+display_error(png_structp pp, png_const_charp error)
+{
+   struct display *dp = get_dp(pp);
+
+   display_log(dp, LIBPNG_ERROR, "%s", error);
+}
+
+static void
+display_cache_file(struct display *dp, const char *filename)
+   /* Does the initial cache of the file. */
+{
+   FILE *fp;
+   int ret;
+
+   dp->filename = filename;
+
+   if (filename != NULL)
+   {
+      fp = fopen(filename, "rb");
+      if (fp == NULL)
+         display_log(dp, USER_ERROR, "open failed: %s", strerror(errno));
+   }
+
+   else
+      fp = stdin;
+
+   ret = buffer_from_file(&dp->original_file, fp);
+
+   fclose(fp);
+
+   if (ret != 0)
+      display_log(dp, APP_ERROR, "read failed: %s", strerror(ret));
+}
+
+static void
+buffer_read(struct display *dp, struct buffer *bp, png_bytep data,
+   size_t size)
+{
+   struct buffer_list *last = bp->current;
+   size_t read_count = bp->read_count;
+
+   while (size > 0)
+   {
+      size_t avail;
+
+      if (last == NULL ||
+         (last == bp->last && read_count >= bp->end_count))
+      {
+         display_log(dp, USER_ERROR, "file truncated (%lu bytes)",
+            (unsigned long)size);
+         /*NOTREACHED*/
+         break;
+      }
+
+      else if (read_count >= sizeof last->buffer)
+      {
+         /* Move to the next buffer: */
+         last = last->next;
+         read_count = 0;
+         bp->current = last; /* Avoid update outside the loop */
+
+         /* And do a sanity check (the EOF case is caught above) */
+         if (last == NULL)
+         {
+            display_log(dp, INTERNAL_ERROR, "damaged buffer list");
+            /*NOTREACHED*/
+            break;
+         }
+      }
+
+      avail = (sizeof last->buffer) - read_count;
+      if (avail > size)
+         avail = size;
+
+      memcpy(data, last->buffer + read_count, avail);
+      read_count += avail;
+      size -= avail;
+      data += avail;
+   }
+
+   bp->read_count = read_count;
+}
+
+static void PNGCBAPI
+read_function(png_structp pp, png_bytep data, size_t size)
+{
+   buffer_read(get_dp(pp), get_buffer(pp), data, size);
+}
+
+static void
+read_png(struct display *dp, struct buffer *bp, const char *operation,
+   int transforms)
+{
+   png_structp pp;
+   png_infop   ip;
+
+   /* This cleans out any previous read and sets operation and transforms to
+    * empty.
+    */
+   display_clean_read(dp);
+
+   if (operation != NULL) /* else this is a verify and do not overwrite info */
+   {
+      dp->operation = operation;
+      dp->transforms = transforms;
+   }
+
+   dp->read_pp = pp = png_create_read_struct(PNG_LIBPNG_VER_STRING, dp,
+      display_error, display_warning);
+   if (pp == NULL)
+      display_log(dp, LIBPNG_ERROR, "failed to create read struct");
+
+   /* The png_read_png API requires us to make the info struct, but it does the
+    * call to png_read_info.
+    */
+   dp->read_ip = ip = png_create_info_struct(pp);
+   if (ip == NULL)
+      display_log(dp, LIBPNG_ERROR, "failed to create info struct");
+
+#  ifdef PNG_SET_USER_LIMITS_SUPPORTED
+      /* Remove the user limits, if any */
+      png_set_user_limits(pp, 0x7fffffff, 0x7fffffff);
+#  endif
+
+   /* Set the IO handling */
+   buffer_start_read(bp);
+   png_set_read_fn(pp, bp, read_function);
+
+   png_read_png(pp, ip, transforms, NULL/*params*/);
+
+#if 0 /* crazy debugging */
+   {
+      png_bytep pr = png_get_rows(pp, ip)[0];
+      size_t rb = png_get_rowbytes(pp, ip);
+      size_t cb;
+      char c = ' ';
+
+      fprintf(stderr, "%.4x %2d (%3lu bytes):", transforms, png_get_bit_depth(pp,ip), (unsigned long)rb);
+
+      for (cb=0; cb<rb; ++cb)
+         fputc(c, stderr), fprintf(stderr, "%.2x", pr[cb]), c='.';
+
+      fputc('\n', stderr);
+   }
+#endif
+}
+
+static void
+update_display(struct display *dp)
+   /* called once after the first read to update all the info, original_pp and
+    * original_ip must have been filled in.
+    */
+{
+   png_structp pp;
+   png_infop   ip;
+
+   /* Now perform the initial read with a 0 transform. */
+   read_png(dp, &dp->original_file, "original read", 0/*no transform*/);
+
+   /* Move the result to the 'original' fields */
+   dp->original_pp = pp = dp->read_pp, dp->read_pp = NULL;
+   dp->original_ip = ip = dp->read_ip, dp->read_ip = NULL;
+
+   dp->original_rowbytes = png_get_rowbytes(pp, ip);
+   if (dp->original_rowbytes == 0)
+      display_log(dp, LIBPNG_BUG, "png_get_rowbytes returned 0");
+
+   dp->chunks = png_get_valid(pp, ip, 0xffffffff);
+   if ((dp->chunks & PNG_INFO_IDAT) == 0) /* set by png_read_png */
+      display_log(dp, LIBPNG_BUG, "png_read_png did not set IDAT flag");
+
+   dp->original_rows = png_get_rows(pp, ip);
+   if (dp->original_rows == NULL)
+      display_log(dp, LIBPNG_BUG, "png_read_png did not create row buffers");
+
+   if (!png_get_IHDR(pp, ip,
+      &dp->width, &dp->height, &dp->bit_depth, &dp->color_type,
+      &dp->interlace_method, &dp->compression_method, &dp->filter_method))
+      display_log(dp, LIBPNG_BUG, "png_get_IHDR failed");
+
+   /* 'active' transforms are discovered based on the original image format;
+    * running one active transform can activate others.  At present the code
+    * does not attempt to determine the closure.
+    */
+   {
+      png_uint_32 chunks = dp->chunks;
+      int active = 0, inactive = 0;
+      int ct = dp->color_type;
+      int bd = dp->bit_depth;
+      unsigned int i;
+
+      for (i=0; i<TTABLE_SIZE; ++i) if (transform_info[i].name != NULL)
+      {
+         int transform = transform_info[i].transform;
+
+         if ((transform_info[i].valid_chunks == 0 ||
+               (transform_info[i].valid_chunks & chunks) != 0) &&
+            (transform_info[i].color_mask_required & ct) ==
+               transform_info[i].color_mask_required &&
+            (transform_info[i].color_mask_absent & ct) == 0 &&
+            (transform_info[i].bit_depths & bd) != 0 &&
+            (transform_info[i].when & TRANSFORM_R) != 0)
+            active |= transform;
+
+         else if ((transform_info[i].when & TRANSFORM_R) != 0)
+            inactive |= transform;
+      }
+
+      /* Some transforms appear multiple times in the table; the 'active' status
+       * is the logical OR of these and the inactive status must be adjusted to
+       * take this into account.
+       */
+      inactive &= ~active;
+
+      dp->active_transforms = active;
+      dp->ignored_transforms = inactive; /* excluding write-only transforms */
+   }
+}
+
+static int
+compare_read(struct display *dp, int applied_transforms)
+{
+   /* Compare the png_info from read_ip with original_info */
+   size_t rowbytes;
+   png_uint_32 width, height;
+   int bit_depth, color_type;
+   int interlace_method, compression_method, filter_method;
+   const char *e = NULL;
+
+   png_get_IHDR(dp->read_pp, dp->read_ip, &width, &height, &bit_depth,
+      &color_type, &interlace_method, &compression_method, &filter_method);
+
+#  define C(item) if (item != dp->item) \
+      display_log(dp, APP_WARNING, "IHDR " #item "(%lu) changed to %lu",\
+         (unsigned long)dp->item, (unsigned long)item), e = #item
+
+   /* The IHDR should be identical: */
+   C(width);
+   C(height);
+   C(bit_depth);
+   C(color_type);
+   C(interlace_method);
+   C(compression_method);
+   C(filter_method);
+
+   /* 'e' remains set to the name of the last thing changed: */
+   if (e)
+      display_log(dp, APP_ERROR, "IHDR changed (%s)", e);
+
+   /* All the chunks from the original PNG should be preserved in the output PNG
+    * because the PNG format has not been changed.
+    */
+   {
+      unsigned long chunks =
+         png_get_valid(dp->read_pp, dp->read_ip, 0xffffffff);
+
+      if (chunks != dp->chunks)
+         display_log(dp, APP_FAIL, "PNG chunks changed from 0x%lx to 0x%lx",
+            (unsigned long)dp->chunks, chunks);
+   }
+
+   /* rowbytes should be the same */
+   rowbytes = png_get_rowbytes(dp->read_pp, dp->read_ip);
+
+   /* NOTE: on 64-bit systems this may trash the top bits of rowbytes,
+    * which could lead to weird error messages.
+    */
+   if (rowbytes != dp->original_rowbytes)
+      display_log(dp, APP_ERROR, "PNG rowbytes changed from %lu to %lu",
+         (unsigned long)dp->original_rowbytes, (unsigned long)rowbytes);
+
+   /* The rows should be the same too, unless the applied transforms includes
+    * the shift transform, in which case low bits may have been lost.
+    */
+   {
+      png_bytepp rows = png_get_rows(dp->read_pp, dp->read_ip);
+      unsigned int mask;  /* mask (if not zero) for the final byte */
+
+      if (bit_depth < 8)
+      {
+         /* Need the stray bits at the end, this depends only on the low bits
+          * of the image width; overflow does not matter.  If the width is an
+          * exact multiple of 8 bits this gives a mask of 0, not 0xff.
+          */
+         mask = 0xff & (0xff00 >> ((bit_depth * width) & 7));
+      }
+
+      else
+         mask = 0;
+
+      if (rows == NULL)
+         display_log(dp, LIBPNG_BUG, "png_get_rows returned NULL");
+
+      if ((applied_transforms & PNG_TRANSFORM_SHIFT) == 0 ||
+         (dp->active_transforms & PNG_TRANSFORM_SHIFT) == 0 ||
+         color_type == PNG_COLOR_TYPE_PALETTE)
+      {
+         unsigned long y;
+
+         for (y=0; y<height; ++y)
+         {
+            png_bytep row = rows[y];
+            png_bytep orig = dp->original_rows[y];
+
+            if (memcmp(row, orig, rowbytes-(mask != 0)) != 0 || (mask != 0 &&
+               ((row[rowbytes-1] & mask) != (orig[rowbytes-1] & mask))))
+            {
+               size_t x;
+
+               /* Find the first error */
+               for (x=0; x<rowbytes-1; ++x) if (row[x] != orig[x])
+                  break;
+
+               display_log(dp, APP_FAIL,
+                  "byte(%lu,%lu) changed 0x%.2x -> 0x%.2x",
+                  (unsigned long)x, (unsigned long)y, orig[x], row[x]);
+               return 0; /* don't keep reporting failed rows on 'continue' */
+            }
+         }
+      }
+
+      else
+#     ifdef PNG_sBIT_SUPPORTED
+      {
+         unsigned long y;
+         int bpp;   /* bits-per-pixel then bytes-per-pixel */
+         /* components are up to 8 bytes in size */
+         png_byte sig_bits[8];
+         png_color_8p sBIT;
+
+         if (png_get_sBIT(dp->read_pp, dp->read_ip, &sBIT) != PNG_INFO_sBIT)
+            display_log(dp, INTERNAL_ERROR,
+               "active shift transform but no sBIT in file");
+
+         switch (color_type)
+         {
+            case PNG_COLOR_TYPE_GRAY:
+               sig_bits[0] = sBIT->gray;
+               bpp = bit_depth;
+               break;
+
+            case PNG_COLOR_TYPE_GA:
+               sig_bits[0] = sBIT->gray;
+               sig_bits[1] = sBIT->alpha;
+               bpp = 2 * bit_depth;
+               break;
+
+            case PNG_COLOR_TYPE_RGB:
+               sig_bits[0] = sBIT->red;
+               sig_bits[1] = sBIT->green;
+               sig_bits[2] = sBIT->blue;
+               bpp = 3 * bit_depth;
+               break;
+
+            case PNG_COLOR_TYPE_RGBA:
+               sig_bits[0] = sBIT->red;
+               sig_bits[1] = sBIT->green;
+               sig_bits[2] = sBIT->blue;
+               sig_bits[3] = sBIT->alpha;
+               bpp = 4 * bit_depth;
+               break;
+
+            default:
+               display_log(dp, LIBPNG_ERROR, "invalid colour type %d",
+                  color_type);
+               /*NOTREACHED*/
+               bpp = 0;
+               break;
+         }
+
+         {
+            int b;
+
+            for (b=0; 8*b<bpp; ++b)
+            {
+               /* libpng should catch this; if not there is a security issue
+                * because an app (like this one) may overflow an array. In fact
+                * libpng doesn't catch this at present.
+                */
+               if (sig_bits[b] == 0 || sig_bits[b] > bit_depth/*!palette*/)
+                  display_log(dp, LIBPNG_BUG,
+                     "invalid sBIT[%u]  value %d returned for PNG bit depth %d",
+                     b, sig_bits[b], bit_depth);
+            }
+         }
+
+         if (bpp < 8 && bpp != bit_depth)
+         {
+            /* sanity check; this is a grayscale PNG; something is wrong in the
+             * code above.
+             */
+            display_log(dp, INTERNAL_ERROR, "invalid bpp %u for bit_depth %u",
+               bpp, bit_depth);
+         }
+
+         switch (bit_depth)
+         {
+            int b;
+
+            case 16: /* Two bytes per component, big-endian */
+               for (b = (bpp >> 4); b > 0; --b)
+               {
+                  unsigned int sig = (unsigned int)(0xffff0000 >> sig_bits[b]);
+
+                  sig_bits[2*b+1] = (png_byte)sig;
+                  sig_bits[2*b+0] = (png_byte)(sig >> 8); /* big-endian */
+               }
+               break;
+
+            case 8: /* One byte per component */
+               for (b=0; b*8 < bpp; ++b)
+                  sig_bits[b] = (png_byte)(0xff00 >> sig_bits[b]);
+               break;
+
+            case 1: /* allowed, but dumb */
+               /* Value is 1 */
+               sig_bits[0] = 0xff;
+               break;
+
+            case 2: /* Replicate 4 times */
+               /* Value is 1 or 2 */
+               b = 0x3 & ((0x3<<2) >> sig_bits[0]);
+               b |= b << 2;
+               b |= b << 4;
+               sig_bits[0] = (png_byte)b;
+               break;
+
+            case 4: /* Relicate twice */
+               /* Value is 1, 2, 3 or 4 */
+               b = 0xf & ((0xf << 4) >> sig_bits[0]);
+               b |= b << 4;
+               sig_bits[0] = (png_byte)b;
+               break;
+
+            default:
+               display_log(dp, LIBPNG_BUG, "invalid bit depth %d", bit_depth);
+               break;
+         }
+
+         /* Convert bpp to bytes; this gives '1' for low-bit depth grayscale,
+          * where there are multiple pixels per byte.
+          */
+         bpp = (bpp+7) >> 3;
+
+         /* The mask can be combined with sig_bits[0] */
+         if (mask != 0)
+         {
+            mask &= sig_bits[0];
+
+            if (bpp != 1 || mask == 0)
+               display_log(dp, INTERNAL_ERROR, "mask calculation error %u, %u",
+                  bpp, mask);
+         }
+
+         for (y=0; y<height; ++y)
+         {
+            png_bytep row = rows[y];
+            png_bytep orig = dp->original_rows[y];
+            unsigned long x;
+
+            for (x=0; x<(width-(mask!=0)); ++x)
+            {
+               int b;
+
+               for (b=0; b<bpp; ++b)
+               {
+                  if ((*row++ & sig_bits[b]) != (*orig++ & sig_bits[b]))
+                  {
+                     display_log(dp, APP_FAIL,
+                        "significant bits at (%lu[%u],%lu) changed %.2x->%.2x",
+                        x, b, y, orig[-1], row[-1]);
+                     return 0;
+                  }
+               }
+            }
+
+            if (mask != 0 && (*row & mask) != (*orig & mask))
+            {
+               display_log(dp, APP_FAIL,
+                  "significant bits at (%lu[end],%lu) changed", x, y);
+               return 0;
+            }
+         } /* for y */
+      }
+#     else /* !sBIT */
+         display_log(dp, INTERNAL_ERROR,
+               "active shift transform but no sBIT support");
+#     endif /* !sBIT */
+   }
+
+   return 1; /* compare succeeded */
+}
+
+#ifdef PNG_WRITE_PNG_SUPPORTED
+static void
+buffer_write(struct display *dp, struct buffer *buffer, png_bytep data,
+   size_t size)
+   /* Generic write function used both from the write callback provided to
+    * libpng and from the generic read code.
+    */
+{
+   /* Write the data into the buffer, adding buffers as required */
+   struct buffer_list *last = buffer->last;
+   size_t end_count = buffer->end_count;
+
+   while (size > 0)
+   {
+      size_t avail;
+
+      if (end_count >= sizeof last->buffer)
+      {
+         if (last->next == NULL)
+         {
+            last = buffer_extend(last);
+
+            if (last == NULL)
+               display_log(dp, APP_ERROR, "out of memory saving file");
+         }
+
+         else
+            last = last->next;
+
+         buffer->last = last; /* avoid the need to rewrite every time */
+         end_count = 0;
+      }
+
+      avail = (sizeof last->buffer) - end_count;
+      if (avail > size)
+         avail = size;
+
+      memcpy(last->buffer + end_count, data, avail);
+      end_count += avail;
+      size -= avail;
+      data += avail;
+   }
+
+   buffer->end_count = end_count;
+}
+
+static void PNGCBAPI
+write_function(png_structp pp, png_bytep data, size_t size)
+{
+   buffer_write(get_dp(pp), get_buffer(pp), data, size);
+}
+
+static void
+write_png(struct display *dp, png_infop ip, int transforms)
+{
+   display_clean_write(dp); /* safety */
+
+   buffer_start_write(&dp->written_file);
+   dp->operation = "write";
+   dp->transforms = transforms;
+
+   dp->write_pp = png_create_write_struct(PNG_LIBPNG_VER_STRING, dp,
+      display_error, display_warning);
+
+   if (dp->write_pp == NULL)
+      display_log(dp, APP_ERROR, "failed to create write png_struct");
+
+   png_set_write_fn(dp->write_pp, &dp->written_file, write_function,
+      NULL/*flush*/);
+
+#  ifdef PNG_SET_USER_LIMITS_SUPPORTED
+      /* Remove the user limits, if any */
+      png_set_user_limits(dp->write_pp, 0x7fffffff, 0x7fffffff);
+#  endif
+
+   /* Certain transforms require the png_info to be zapped to allow the
+    * transform to work correctly.
+    */
+   if (transforms & (PNG_TRANSFORM_PACKING|
+                     PNG_TRANSFORM_STRIP_FILLER|
+                     PNG_TRANSFORM_STRIP_FILLER_BEFORE))
+   {
+      int ct = dp->color_type;
+
+      if (transforms & (PNG_TRANSFORM_STRIP_FILLER|
+                        PNG_TRANSFORM_STRIP_FILLER_BEFORE))
+         ct &= ~PNG_COLOR_MASK_ALPHA;
+
+      png_set_IHDR(dp->write_pp, ip, dp->width, dp->height, dp->bit_depth, ct,
+         dp->interlace_method, dp->compression_method, dp->filter_method);
+   }
+
+   png_write_png(dp->write_pp, ip, transforms, NULL/*params*/);
+
+   /* Clean it on the way out - if control returns to the caller then the
+    * written_file contains the required data.
+    */
+   display_clean_write(dp);
+}
+#endif /* WRITE_PNG */
+
+static int
+skip_transform(struct display *dp, int tr)
+   /* Helper to test for a bad combo and log it if it is skipped */
+{
+   if ((dp->options & SKIP_BUGS) != 0 && is_bad_combo(tr))
+   {
+      /* Log this to stdout if logging is on, otherwise just do an information
+       * display_log.
+       */
+      if ((dp->options & LOG_SKIPPED) != 0)
+      {
+         printf("SKIP: %s transforms ", dp->filename);
+
+         while (tr != 0)
+         {
+            int next = first_transform(tr);
+            tr &= ~next;
+
+            printf("%s", transform_name(next));
+            if (tr != 0)
+               putchar('+');
+         }
+
+         putchar('\n');
+      }
+
+      else
+         display_log(dp, INFORMATION, "%s: skipped known bad combo 0x%x",
+            dp->filename, tr);
+
+      return 1; /* skip */
+   }
+
+   return 0; /* don't skip */
+}
+
+static void
+test_one_file(struct display *dp, const char *filename)
+{
+   /* First cache the file and update the display original file
+    * information for the new file.
+    */
+   dp->operation = "cache file";
+   dp->transforms = 0;
+   display_cache_file(dp, filename);
+   update_display(dp);
+
+   /* First test: if there are options that should be ignored for this file
+    * verify that they really are ignored.
+    */
+   if (dp->ignored_transforms != 0)
+   {
+      read_png(dp, &dp->original_file, "ignored transforms",
+         dp->ignored_transforms);
+
+      /* The result should be identical to the original_rows */
+      if (!compare_read(dp, 0/*transforms applied*/))
+         return; /* no point testing more */
+   }
+
+#ifdef PNG_WRITE_PNG_SUPPORTED
+   /* Second test: write the original PNG data out to a new file (to test the
+    * write side) then read the result back in and make sure that it hasn't
+    * changed.
+    */
+   dp->operation = "write";
+   write_png(dp, dp->original_ip, 0/*transforms*/);
+   read_png(dp, &dp->written_file, NULL, 0/*transforms*/);
+   if (!compare_read(dp, 0/*transforms applied*/))
+      return;
+#endif
+
+   /* Third test: the active options.  Test each in turn, or, with the
+    * EXHAUSTIVE option, test all possible combinations.
+    */
+   {
+      /* Use unsigned int here because the code below to increment through all
+       * the possibilities exhaustively has to use a compare and that must be
+       * unsigned, because some transforms are negative on a 16-bit system.
+       */
+      unsigned int active = dp->active_transforms;
+      int exhaustive = (dp->options & EXHAUSTIVE) != 0;
+      unsigned int current = first_transform(active);
+      unsigned int bad_transforms = 0;
+      unsigned int bad_combo = ~0U;    /* bitwise AND of failing transforms */
+      unsigned int bad_combo_list = 0; /* bitwise OR of failures */
+
+      for (;;)
+      {
+         read_png(dp, &dp->original_file, "active transforms", current);
+
+         /* If this involved any irreversible transformations then if we write
+          * it out with just the reversible transformations and read it in again
+          * with the same transforms we should get the same thing.  At present
+          * this isn't done - it just seems like a waste of time and it would
+          * require two sets of read png_struct/png_info.
+          *
+          * If there were no irreversible transformations then if we write it
+          * out and read it back in again (without the reversible transforms)
+          * we should get back to the place where we started.
+          */
+#ifdef PNG_WRITE_PNG_SUPPORTED
+         if ((current & write_transforms) == current)
+         {
+            /* All transforms reversible: write the PNG with the transformations
+             * reversed, then read it back in with no transformations.  The
+             * result should be the same as the original apart from the loss of
+             * low order bits because of the SHIFT/sBIT transform.
+             */
+            dp->operation = "reversible transforms";
+            write_png(dp, dp->read_ip, current);
+
+            /* And if this is read back in, because all the transformations were
+             * reversible, the result should be the same.
+             */
+            read_png(dp, &dp->written_file, NULL, 0);
+            if (!compare_read(dp, current/*for the SHIFT/sBIT transform*/))
+            {
+               /* This set of transforms failed.  If a single bit is set - if
+                * there is just one transform - don't include this in further
+                * 'exhaustive' tests.  Notice that each transform is tested on
+                * its own before testing combos in the exhaustive case.
+                */
+               if (is_combo(current))
+               {
+                  bad_combo &= current;
+                  bad_combo_list |= current;
+               }
+
+               else
+                  bad_transforms |= current;
+            }
+         }
+#endif
+
+         /* Now move to the next transform */
+         if (exhaustive) /* all combinations */
+         {
+            unsigned int next = current;
+
+            do
+            {
+               if (next == read_transforms) /* Everything tested */
+                  goto combo;
+
+               ++next;
+            }  /* skip known bad combos if the relevant option is set; skip
+                * combos involving known bad single transforms in all cases.
+                */
+            while (  (next & read_transforms) <= current
+                  || (next & active) == 0 /* skip cases that do nothing */
+                  || (next & bad_transforms) != 0
+                  || skip_transform(dp, next));
+
+            assert((next & read_transforms) == next);
+            current = next;
+         }
+
+         else /* one at a time */
+         {
+            active &= ~current;
+
+            if (active == 0)
+               goto combo;
+
+            current = first_transform(active);
+         }
+      }
+
+combo:
+      if (dp->options & FIND_BAD_COMBOS)
+      {
+         /* bad_combos identifies the combos that occur in all failing cases;
+          * bad_combo_list identifies transforms that do not prevent the
+          * failure.
+          */
+         if (bad_combo != ~0U)
+            printf("%s[0x%x]: PROBLEM: 0x%x[0x%x] ANTIDOTE: 0x%x\n",
+               dp->filename, active, bad_combo, bad_combo_list,
+               rw_transforms & ~bad_combo_list);
+
+         else
+            printf("%s: no %sbad combos found\n", dp->filename,
+               (dp->options & SKIP_BUGS) ? "additional " : "");
+      }
+   }
+}
+
+static int
+do_test(struct display *dp, const char *file)
+   /* Exists solely to isolate the setjmp clobbers */
+{
+   int ret = setjmp(dp->error_return);
+
+   if (ret == 0)
+   {
+      test_one_file(dp, file);
+      return 0;
+   }
+
+   else if (ret < ERRORS) /* shouldn't longjmp on warnings */
+      display_log(dp, INTERNAL_ERROR, "unexpected return code %d", ret);
+
+   return ret;
+}
+
+int
+main(int argc, char **argv)
+{
+   /* For each file on the command line test it with a range of transforms */
+   int option_end, ilog = 0;
+   struct display d;
+
+   validate_T();
+   display_init(&d);
+
+   for (option_end=1; option_end<argc; ++option_end)
+   {
+      const char *name = argv[option_end];
+
+      if (strcmp(name, "--verbose") == 0)
+         d.options = (d.options & ~LEVEL_MASK) | VERBOSE;
+
+      else if (strcmp(name, "--warnings") == 0)
+         d.options = (d.options & ~LEVEL_MASK) | WARNINGS;
+
+      else if (strcmp(name, "--errors") == 0)
+         d.options = (d.options & ~LEVEL_MASK) | ERRORS;
+
+      else if (strcmp(name, "--quiet") == 0)
+         d.options = (d.options & ~LEVEL_MASK) | QUIET;
+
+      else if (strcmp(name, "--exhaustive") == 0)
+         d.options |= EXHAUSTIVE;
+
+      else if (strcmp(name, "--fast") == 0)
+         d.options &= ~EXHAUSTIVE;
+
+      else if (strcmp(name, "--strict") == 0)
+         d.options |= STRICT;
+
+      else if (strcmp(name, "--relaxed") == 0)
+         d.options &= ~STRICT;
+
+      else if (strcmp(name, "--log") == 0)
+      {
+         ilog = option_end; /* prevent display */
+         d.options |= LOG;
+      }
+
+      else if (strcmp(name, "--nolog") == 0)
+         d.options &= ~LOG;
+
+      else if (strcmp(name, "--continue") == 0)
+         d.options |= CONTINUE;
+
+      else if (strcmp(name, "--stop") == 0)
+         d.options &= ~CONTINUE;
+
+      else if (strcmp(name, "--skip-bugs") == 0)
+         d.options |= SKIP_BUGS;
+
+      else if (strcmp(name, "--test-all") == 0)
+         d.options &= ~SKIP_BUGS;
+
+      else if (strcmp(name, "--log-skipped") == 0)
+         d.options |= LOG_SKIPPED;
+
+      else if (strcmp(name, "--nolog-skipped") == 0)
+         d.options &= ~LOG_SKIPPED;
+
+      else if (strcmp(name, "--find-bad-combos") == 0)
+         d.options |= FIND_BAD_COMBOS;
+
+      else if (strcmp(name, "--nofind-bad-combos") == 0)
+         d.options &= ~FIND_BAD_COMBOS;
+
+      else if (strcmp(name, "--list-combos") == 0)
+         d.options |= LIST_COMBOS;
+
+      else if (strcmp(name, "--nolist-combos") == 0)
+         d.options &= ~LIST_COMBOS;
+
+      else if (name[0] == '-' && name[1] == '-')
+      {
+         fprintf(stderr, "pngimage: %s: unknown option\n", name);
+         return 99;
+      }
+
+      else
+         break; /* Not an option */
+   }
+
+   {
+      int i;
+      int errors = 0;
+
+      for (i=option_end; i<argc; ++i)
+      {
+         {
+            int ret = do_test(&d, argv[i]);
+
+            if (ret > QUIET) /* abort on user or internal error */
+               return 99;
+         }
+
+         /* Here on any return, including failures, except user/internal issues
+          */
+         {
+            int pass = (d.options & STRICT) ?
+               RESULT_STRICT(d.results) : RESULT_RELAXED(d.results);
+
+            if (!pass)
+               ++errors;
+
+            if (d.options & LOG)
+            {
+               int j;
+
+               printf("%s: pngimage ", pass ? "PASS" : "FAIL");
+
+               for (j=1; j<option_end; ++j) if (j != ilog)
+                  printf("%s ", argv[j]);
+
+               printf("%s\n", d.filename);
+            }
+         }
+
+         display_clean(&d);
+      }
+
+      /* Release allocated memory */
+      display_destroy(&d);
+
+      return errors != 0;
+   }
+}
+#else /* !READ_PNG */
+int
+main(void)
+{
+   fprintf(stderr, "pngimage: no support for png_read/write_image\n");
+   return SKIP;
+}
+#endif
diff --git a/Engine/lib/lpng/contrib/libtests/pngstest-errors.h b/Engine/lib/lpng/contrib/libtests/pngstest-errors.h
new file mode 100644
index 000000000..3356f1c46
--- /dev/null
+++ b/Engine/lib/lpng/contrib/libtests/pngstest-errors.h
@@ -0,0 +1,165 @@
+/* contrib/libtests/pngstest-errors.h
+ *
+ * BUILT USING: libpng version 1.6.19beta03 - September 25, 2015
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * THIS IS A MACHINE GENERATED FILE: do not edit it directly!
+ * Instead run:
+ *
+ *    pngstest --accumulate
+ *
+ * on as many PNG files as possible; at least PNGSuite and
+ * contrib/libtests/testpngs.
+ */
+static png_uint_16 gpc_error[16/*in*/][16/*out*/][4/*a*/] =
+{
+ { /* input: sRGB-gray */
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 372, 0 }, { 0, 0, 372, 0 }, { 0, 0, 372, 0 }, { 0, 0, 372, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: sRGB-gray+alpha */
+  { 0, 19, 0, 0 }, { 0, 0, 0, 0 }, { 0, 20, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 897, 788, 0 }, { 0, 897, 788, 0 }, { 0, 897, 788, 0 }, { 0, 897, 788, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: sRGB-rgb */
+  { 0, 0, 19, 0 }, { 0, 0, 19, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 893, 0 }, { 0, 0, 893, 0 }, { 0, 0, 811, 0 }, { 0, 0, 811, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: sRGB-rgb+alpha */
+  { 0, 16, 17, 0 }, { 0, 17, 17, 0 }, { 0, 19, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 850, 875, 0 }, { 0, 850, 875, 0 }, { 0, 897, 788, 0 }, { 0, 897, 788, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: linear-gray */
+  { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: linear-gray+alpha */
+  { 0, 74, 9, 0 }, { 0, 20, 9, 0 }, { 0, 74, 9, 0 }, { 0, 20, 9, 0 },
+  { 0, 0, 0, 0 }, { 0, 1, 0, 0 }, { 0, 0, 0, 0 }, { 0, 1, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: linear-rgb */
+  { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 },
+  { 0, 0, 4, 0 }, { 0, 0, 4, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: linear-rgb+alpha */
+  { 0, 126, 143, 0 }, { 0, 11, 7, 0 }, { 0, 74, 9, 0 }, { 0, 17, 9, 0 },
+  { 0, 4, 4, 0 }, { 0, 5, 4, 0 }, { 0, 0, 0, 0 }, { 0, 1, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: color-mapped-sRGB-gray */
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: color-mapped-sRGB-gray+alpha */
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: color-mapped-sRGB-rgb */
+  { 0, 0, 13, 0 }, { 0, 0, 13, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 },
+  { 0, 0, 673, 0 }, { 0, 0, 673, 0 }, { 0, 0, 674, 0 }, { 0, 0, 674, 0 },
+  { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 460, 0 }, { 0, 0, 460, 0 }, { 0, 0, 263, 0 }, { 0, 0, 263, 0 }
+ }, { /* input: color-mapped-sRGB-rgb+alpha */
+  { 0, 6, 8, 0 }, { 0, 7, 8, 0 }, { 0, 75, 9, 0 }, { 0, 9, 9, 0 },
+  { 0, 585, 427, 0 }, { 0, 585, 427, 0 }, { 0, 717, 514, 0 }, { 0, 717, 514, 0 },
+  { 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 13323, 460, 0 }, { 0, 427, 460, 0 }, { 0, 16480, 263, 0 }, { 0, 243, 263, 0 }
+ }, { /* input: color-mapped-linear-gray */
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 282, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: color-mapped-linear-gray+alpha */
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 253, 282, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: color-mapped-linear-rgb */
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 265, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: color-mapped-linear-rgb+alpha */
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 243, 265, 0 }
+ }
+};
+static png_uint_16 gpc_error_via_linear[16][4/*out*/][4] =
+{
+ { /* input: sRGB-gray */
+  { 0, 0, 7, 0 }, { 0, 0, 7, 0 }, { 0, 0, 7, 0 }, { 0, 0, 7, 0 }
+ }, { /* input: sRGB-gray+alpha */
+  { 0, 15, 15, 0 }, { 0, 186, 15, 0 }, { 0, 15, 15, 0 }, { 0, 186, 15, 0 }
+ }, { /* input: sRGB-rgb */
+  { 0, 0, 20, 0 }, { 0, 0, 20, 0 }, { 0, 0, 15, 0 }, { 0, 0, 15, 0 }
+ }, { /* input: sRGB-rgb+alpha */
+  { 0, 16, 17, 0 }, { 0, 187, 17, 0 }, { 0, 15, 15, 0 }, { 0, 186, 15, 0 }
+ }, { /* input: linear-gray */
+  { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }
+ }, { /* input: linear-gray+alpha */
+  { 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 }
+ }, { /* input: linear-rgb */
+  { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }
+ }, { /* input: linear-rgb+alpha */
+  { 0, 1, 1, 0 }, { 0, 9, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 }
+ }, { /* input: color-mapped-sRGB-gray */
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: color-mapped-sRGB-gray+alpha */
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: color-mapped-sRGB-rgb */
+  { 0, 0, 13, 0 }, { 0, 0, 13, 0 }, { 0, 0, 14, 0 }, { 0, 0, 14, 0 }
+ }, { /* input: color-mapped-sRGB-rgb+alpha */
+  { 0, 4, 8, 0 }, { 0, 9, 8, 0 }, { 0, 9, 5, 0 }, { 0, 32, 5, 0 }
+ }, { /* input: color-mapped-linear-gray */
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: color-mapped-linear-gray+alpha */
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: color-mapped-linear-rgb */
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: color-mapped-linear-rgb+alpha */
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }
+};
+static png_uint_16 gpc_error_to_colormap[8/*i*/][8/*o*/][4] =
+{
+ { /* input: sRGB-gray */
+  { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 },
+  { 0, 0, 560, 0 }, { 0, 0, 560, 0 }, { 0, 0, 560, 0 }, { 0, 0, 560, 0 }
+ }, { /* input: sRGB-gray+alpha */
+  { 0, 19, 9, 0 }, { 0, 255, 9, 25 }, { 0, 88, 9, 0 }, { 0, 255, 9, 25 },
+  { 0, 1012, 928, 0 }, { 0, 16026, 928, 6425 }, { 0, 1012, 928, 0 }, { 0, 16026, 928, 6425 }
+ }, { /* input: sRGB-rgb */
+  { 0, 0, 19, 0 }, { 0, 0, 19, 0 }, { 0, 0, 25, 0 }, { 0, 0, 25, 0 },
+  { 0, 0, 962, 0 }, { 0, 0, 962, 0 }, { 0, 0, 13677, 0 }, { 0, 0, 13677, 0 }
+ }, { /* input: sRGB-rgb+alpha */
+  { 0, 63, 77, 0 }, { 0, 255, 19, 25 }, { 0, 225, 25, 0 }, { 0, 255, 25, 67 },
+  { 0, 17534, 18491, 0 }, { 0, 15736, 2824, 6425 }, { 0, 14019, 13677, 0 }, { 0, 50115, 13677, 17219 }
+ }, { /* input: linear-gray */
+  { 0, 0, 73, 0 }, { 0, 0, 73, 0 }, { 0, 0, 73, 0 }, { 0, 0, 73, 0 },
+  { 0, 0, 18817, 0 }, { 0, 0, 18817, 0 }, { 0, 0, 18817, 0 }, { 0, 0, 18817, 0 }
+ }, { /* input: linear-gray+alpha */
+  { 0, 74, 74, 0 }, { 0, 255, 74, 25 }, { 0, 99, 74, 0 }, { 0, 255, 74, 25 },
+  { 0, 18919, 18907, 0 }, { 0, 24549, 18907, 6553 }, { 0, 18919, 18907, 0 }, { 0, 24549, 18907, 6553 }
+ }, { /* input: linear-rgb */
+  { 0, 0, 73, 0 }, { 0, 0, 73, 0 }, { 0, 0, 98, 0 }, { 0, 0, 98, 0 },
+  { 0, 0, 18664, 0 }, { 0, 0, 18664, 0 }, { 0, 0, 24998, 0 }, { 0, 0, 24998, 0 }
+ }, { /* input: linear-rgb+alpha */
+  { 0, 181, 196, 0 }, { 0, 255, 61, 25 }, { 206, 187, 98, 0 }, { 0, 255, 98, 67 },
+  { 0, 18141, 18137, 0 }, { 0, 17494, 17504, 6553 }, { 0, 24979, 24992, 0 }, { 0, 49172, 24992, 17347 }
+ }
+};
+/* END MACHINE GENERATED */
diff --git a/Engine/lib/lpng/contrib/libtests/pngstest.c b/Engine/lib/lpng/contrib/libtests/pngstest.c
new file mode 100644
index 000000000..a368bf0f4
--- /dev/null
+++ b/Engine/lib/lpng/contrib/libtests/pngstest.c
@@ -0,0 +1,3828 @@
+/*-
+ * pngstest.c
+ *
+ * Last changed in libpng 1.6.31 [July 27, 2017]
+ * Copyright (c) 2013-2017 John Cunningham Bowler
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * Test for the PNG 'simplified' APIs.
+ */
+#define _ISOC90_SOURCE 1
+#define MALLOC_CHECK_ 2/*glibc facility: turn on debugging*/
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include <ctype.h>
+#include <math.h>
+
+#if defined(HAVE_CONFIG_H) && !defined(PNG_NO_CONFIG_H)
+#  include <config.h>
+#endif
+
+/* Define the following to use this test against your installed libpng, rather
+ * than the one being built here:
+ */
+#ifdef PNG_FREESTANDING_TESTS
+#  include <png.h>
+#else
+#  include "../../png.h"
+#endif
+
+/* 1.6.1 added support for the configure test harness, which uses 77 to indicate
+ * a skipped test, in earlier versions we need to succeed on a skipped test, so:
+ */
+#if PNG_LIBPNG_VER >= 10601 && defined(HAVE_CONFIG_H)
+#  define SKIP 77
+#else
+#  define SKIP 0
+#endif
+
+#ifdef PNG_SIMPLIFIED_READ_SUPPORTED /* Else nothing can be done */
+#include "../tools/sRGB.h"
+
+/* KNOWN ISSUES
+ *
+ * These defines switch on alternate algorithms for format conversions to match
+ * the current libpng implementation; they are set to allow pngstest to pass
+ * even though libpng is producing answers that are not as correct as they
+ * should be.
+ */
+#define ALLOW_UNUSED_GPC 0
+   /* If true include unused static GPC functions and declare an external array
+    * of them to hide the fact that they are unused.  This is for development
+    * use while testing the correct function to use to take into account libpng
+    * misbehavior, such as using a simple power law to correct sRGB to linear.
+    */
+
+/* The following is to support direct compilation of this file as C++ */
+#ifdef __cplusplus
+#  define voidcast(type, value) static_cast<type>(value)
+#  define aligncastconst(type, value) \
+      static_cast<type>(static_cast<const void*>(value))
+#else
+#  define voidcast(type, value) (value)
+#  define aligncastconst(type, value) ((const void*)(value))
+#endif /* __cplusplus */
+
+/* During parallel runs of pngstest each temporary file needs a unique name,
+ * this is used to permit uniqueness using a command line argument which can be
+ * up to 22 characters long.
+ */
+static char tmpf[23] = "TMP";
+
+/* Generate random bytes.  This uses a boring repeatable algorithm and it
+ * is implemented here so that it gives the same set of numbers on every
+ * architecture.  It's a linear congruential generator (Knuth or Sedgewick
+ * "Algorithms") but it comes from the 'feedback taps' table in Horowitz and
+ * Hill, "The Art of Electronics".
+ */
+static void
+make_random_bytes(png_uint_32* seed, void* pv, size_t size)
+{
+   png_uint_32 u0 = seed[0], u1 = seed[1];
+   png_bytep bytes = voidcast(png_bytep, pv);
+
+   /* There are thirty three bits, the next bit in the sequence is bit-33 XOR
+    * bit-20.  The top 1 bit is in u1, the bottom 32 are in u0.
+    */
+   size_t i;
+   for (i=0; i<size; ++i)
+   {
+      /* First generate 8 new bits then shift them in at the end. */
+      png_uint_32 u = ((u0 >> (20-8)) ^ ((u1 << 7) | (u0 >> (32-7)))) & 0xff;
+      u1 <<= 8;
+      u1 |= u0 >> 24;
+      u0 <<= 8;
+      u0 |= u;
+      *bytes++ = (png_byte)u;
+   }
+
+   seed[0] = u0;
+   seed[1] = u1;
+}
+
+static png_uint_32 color_seed[2];
+
+static void
+reseed(void)
+{
+   color_seed[0] = 0x12345678U;
+   color_seed[1] = 0x9abcdefU;
+}
+
+static void
+random_color(png_colorp color)
+{
+   make_random_bytes(color_seed, color, sizeof *color);
+}
+
+/* Math support - neither Cygwin nor Visual Studio have C99 support and we need
+ * a predictable rounding function, so make one here:
+ */
+static double
+closestinteger(double x)
+{
+   return floor(x + .5);
+}
+
+/* Cast support: remove GCC whines. */
+static png_byte
+u8d(double d)
+{
+   d = closestinteger(d);
+   return (png_byte)d;
+}
+
+static png_uint_16
+u16d(double d)
+{
+   d = closestinteger(d);
+   return (png_uint_16)d;
+}
+
+/* sRGB support: use exact calculations rounded to the nearest int, see the
+ * fesetround() call in main().  sRGB_to_d optimizes the 8 to 16-bit conversion.
+ */
+static double sRGB_to_d[256];
+static double g22_to_d[256];
+
+static void
+init_sRGB_to_d(void)
+{
+   int i;
+
+   sRGB_to_d[0] = 0;
+   for (i=1; i<255; ++i)
+      sRGB_to_d[i] = linear_from_sRGB(i/255.);
+   sRGB_to_d[255] = 1;
+
+   g22_to_d[0] = 0;
+   for (i=1; i<255; ++i)
+      g22_to_d[i] = pow(i/255., 1/.45455);
+   g22_to_d[255] = 1;
+}
+
+static png_byte
+sRGB(double linear /*range 0.0 .. 1.0*/)
+{
+   return u8d(255 * sRGB_from_linear(linear));
+}
+
+static png_byte
+isRGB(int fixed_linear)
+{
+   return sRGB(fixed_linear / 65535.);
+}
+
+#if 0 /* not used */
+static png_byte
+unpremultiply(int component, int alpha)
+{
+   if (alpha <= component)
+      return 255; /* Arbitrary, but consistent with the libpng code */
+
+   else if (alpha >= 65535)
+      return isRGB(component);
+
+   else
+      return sRGB((double)component / alpha);
+}
+#endif
+
+static png_uint_16
+ilinear(int fixed_srgb)
+{
+   return u16d(65535 * sRGB_to_d[fixed_srgb]);
+}
+
+static png_uint_16
+ilineara(int fixed_srgb, int alpha)
+{
+   return u16d((257 * alpha) * sRGB_to_d[fixed_srgb]);
+}
+
+static png_uint_16
+ilinear_g22(int fixed_srgb)
+{
+   return u16d(65535 * g22_to_d[fixed_srgb]);
+}
+
+#if ALLOW_UNUSED_GPC
+static png_uint_16
+ilineara_g22(int fixed_srgb, int alpha)
+{
+   return u16d((257 * alpha) * g22_to_d[fixed_srgb]);
+}
+#endif
+
+static double
+YfromRGBint(int ir, int ig, int ib)
+{
+   double r = ir;
+   double g = ig;
+   double b = ib;
+   return YfromRGB(r, g, b);
+}
+
+#if 0 /* unused */
+/* The error that results from using a 2.2 power law in place of the correct
+ * sRGB transform, given an 8-bit value which might be either sRGB or power-law.
+ */
+static int
+power_law_error8(int value)
+{
+   if (value > 0 && value < 255)
+   {
+      double vd = value / 255.;
+      double e = fabs(
+         pow(sRGB_to_d[value], 1/2.2) - sRGB_from_linear(pow(vd, 2.2)));
+
+      /* Always allow an extra 1 here for rounding errors */
+      e = 1+floor(255 * e);
+      return (int)e;
+   }
+
+   return 0;
+}
+
+static int error_in_sRGB_roundtrip = 56; /* by experiment */
+static int
+power_law_error16(int value)
+{
+   if (value > 0 && value < 65535)
+   {
+      /* Round trip the value through an 8-bit representation but using
+       * non-matching to/from conversions.
+       */
+      double vd = value / 65535.;
+      double e = fabs(
+         pow(sRGB_from_linear(vd), 2.2) - linear_from_sRGB(pow(vd, 1/2.2)));
+
+      /* Always allow an extra 1 here for rounding errors */
+      e = error_in_sRGB_roundtrip+floor(65535 * e);
+      return (int)e;
+   }
+
+   return 0;
+}
+
+static int
+compare_8bit(int v1, int v2, int error_limit, int multiple_algorithms)
+{
+   int e = abs(v1-v2);
+   int ev1, ev2;
+
+   if (e <= error_limit)
+      return 1;
+
+   if (!multiple_algorithms)
+      return 0;
+
+   ev1 = power_law_error8(v1);
+   if (e <= ev1)
+      return 1;
+
+   ev2 = power_law_error8(v2);
+   if (e <= ev2)
+      return 1;
+
+   return 0;
+}
+
+static int
+compare_16bit(int v1, int v2, int error_limit, int multiple_algorithms)
+{
+   int e = abs(v1-v2);
+   int ev1, ev2;
+
+   if (e <= error_limit)
+      return 1;
+
+   /* "multiple_algorithms" in this case means that a color-map has been
+    * involved somewhere, so we can deduce that the values were forced to 8-bit
+    * (like the via_linear case for 8-bit.)
+    */
+   if (!multiple_algorithms)
+      return 0;
+
+   ev1 = power_law_error16(v1);
+   if (e <= ev1)
+      return 1;
+
+   ev2 = power_law_error16(v2);
+   if (e <= ev2)
+      return 1;
+
+   return 0;
+}
+#endif /* unused */
+
+#define USE_FILE 1       /* else memory */
+#define USE_STDIO 2      /* else use file name */
+#define STRICT 4         /* fail on warnings too */
+#define VERBOSE 8
+#define KEEP_TMPFILES 16 /* else delete temporary files */
+#define KEEP_GOING 32
+#define ACCUMULATE 64
+#define FAST_WRITE 128
+#define sRGB_16BIT 256
+#define NO_RESEED  512   /* do not reseed on each new file */
+#define GBG_ERROR 1024   /* do not ignore the gamma+background_rgb_to_gray
+                          * libpng warning. */
+
+static void
+print_opts(png_uint_32 opts)
+{
+   if (opts & USE_FILE)
+      printf(" --file");
+   if (opts & USE_STDIO)
+      printf(" --stdio");
+   if (!(opts & STRICT))
+      printf(" --nostrict");
+   if (opts & VERBOSE)
+      printf(" --verbose");
+   if (opts & KEEP_TMPFILES)
+      printf(" --preserve");
+   if (opts & KEEP_GOING)
+      printf(" --keep-going");
+   if (opts & ACCUMULATE)
+      printf(" --accumulate");
+   if (!(opts & FAST_WRITE)) /* --fast is currently the default */
+      printf(" --slow");
+   if (opts & sRGB_16BIT)
+      printf(" --sRGB-16bit");
+   if (opts & NO_RESEED)
+      printf(" --noreseed");
+#if PNG_LIBPNG_VER < 10700 /* else on by default */
+   if (opts & GBG_ERROR)
+      printf(" --fault-gbg-warning");
+#endif
+}
+
+#define FORMAT_NO_CHANGE 0x80000000 /* additional flag */
+
+/* A name table for all the formats - defines the format of the '+' arguments to
+ * pngstest.
+ */
+#define FORMAT_COUNT 64
+#define FORMAT_MASK 0x3f
+static const char * const format_names[FORMAT_COUNT] =
+{
+   "sRGB-gray",
+   "sRGB-gray+alpha",
+   "sRGB-rgb",
+   "sRGB-rgb+alpha",
+   "linear-gray",
+   "linear-gray+alpha",
+   "linear-rgb",
+   "linear-rgb+alpha",
+
+   "color-mapped-sRGB-gray",
+   "color-mapped-sRGB-gray+alpha",
+   "color-mapped-sRGB-rgb",
+   "color-mapped-sRGB-rgb+alpha",
+   "color-mapped-linear-gray",
+   "color-mapped-linear-gray+alpha",
+   "color-mapped-linear-rgb",
+   "color-mapped-linear-rgb+alpha",
+
+   "sRGB-gray",
+   "sRGB-gray+alpha",
+   "sRGB-bgr",
+   "sRGB-bgr+alpha",
+   "linear-gray",
+   "linear-gray+alpha",
+   "linear-bgr",
+   "linear-bgr+alpha",
+
+   "color-mapped-sRGB-gray",
+   "color-mapped-sRGB-gray+alpha",
+   "color-mapped-sRGB-bgr",
+   "color-mapped-sRGB-bgr+alpha",
+   "color-mapped-linear-gray",
+   "color-mapped-linear-gray+alpha",
+   "color-mapped-linear-bgr",
+   "color-mapped-linear-bgr+alpha",
+
+   "sRGB-gray",
+   "alpha+sRGB-gray",
+   "sRGB-rgb",
+   "alpha+sRGB-rgb",
+   "linear-gray",
+   "alpha+linear-gray",
+   "linear-rgb",
+   "alpha+linear-rgb",
+
+   "color-mapped-sRGB-gray",
+   "color-mapped-alpha+sRGB-gray",
+   "color-mapped-sRGB-rgb",
+   "color-mapped-alpha+sRGB-rgb",
+   "color-mapped-linear-gray",
+   "color-mapped-alpha+linear-gray",
+   "color-mapped-linear-rgb",
+   "color-mapped-alpha+linear-rgb",
+
+   "sRGB-gray",
+   "alpha+sRGB-gray",
+   "sRGB-bgr",
+   "alpha+sRGB-bgr",
+   "linear-gray",
+   "alpha+linear-gray",
+   "linear-bgr",
+   "alpha+linear-bgr",
+
+   "color-mapped-sRGB-gray",
+   "color-mapped-alpha+sRGB-gray",
+   "color-mapped-sRGB-bgr",
+   "color-mapped-alpha+sRGB-bgr",
+   "color-mapped-linear-gray",
+   "color-mapped-alpha+linear-gray",
+   "color-mapped-linear-bgr",
+   "color-mapped-alpha+linear-bgr",
+};
+
+/* Decode an argument to a format number. */
+static png_uint_32
+formatof(const char *arg)
+{
+   char *ep;
+   unsigned long format = strtoul(arg, &ep, 0);
+
+   if (ep > arg && *ep == 0 && format < FORMAT_COUNT)
+      return (png_uint_32)format;
+
+   else for (format=0; format < FORMAT_COUNT; ++format)
+   {
+      if (strcmp(format_names[format], arg) == 0)
+         return (png_uint_32)format;
+   }
+
+   fprintf(stderr, "pngstest: format name '%s' invalid\n", arg);
+   return FORMAT_COUNT;
+}
+
+/* Bitset/test functions for formats */
+#define FORMAT_SET_COUNT (FORMAT_COUNT / 32)
+typedef struct
+{
+   png_uint_32 bits[FORMAT_SET_COUNT];
+}
+format_list;
+
+static void format_init(format_list *pf)
+{
+   int i;
+   for (i=0; i<FORMAT_SET_COUNT; ++i)
+      pf->bits[i] = 0; /* All off */
+}
+
+#if 0 /* currently unused */
+static void format_clear(format_list *pf)
+{
+   int i;
+   for (i=0; i<FORMAT_SET_COUNT; ++i)
+      pf->bits[i] = 0;
+}
+#endif
+
+static int format_is_initial(format_list *pf)
+{
+   int i;
+   for (i=0; i<FORMAT_SET_COUNT; ++i)
+      if (pf->bits[i] != 0)
+         return 0;
+
+   return 1;
+}
+
+static int format_set(format_list *pf, png_uint_32 format)
+{
+   if (format < FORMAT_COUNT)
+      return pf->bits[format >> 5] |= ((png_uint_32)1) << (format & 31);
+
+   return 0;
+}
+
+#if 0 /* currently unused */
+static int format_unset(format_list *pf, png_uint_32 format)
+{
+   if (format < FORMAT_COUNT)
+      return pf->bits[format >> 5] &= ~((png_uint_32)1) << (format & 31);
+
+   return 0;
+}
+#endif
+
+static int format_isset(format_list *pf, png_uint_32 format)
+{
+   return format < FORMAT_COUNT &&
+      (pf->bits[format >> 5] & (((png_uint_32)1) << (format & 31))) != 0;
+}
+
+static void format_default(format_list *pf, int redundant)
+{
+   if (redundant)
+   {
+      int i;
+
+      /* set everything, including flags that are pointless */
+      for (i=0; i<FORMAT_SET_COUNT; ++i)
+         pf->bits[i] = ~(png_uint_32)0;
+   }
+
+   else
+   {
+      png_uint_32 f;
+
+      for (f=0; f<FORMAT_COUNT; ++f)
+      {
+         /* Eliminate redundant and unsupported settings. */
+#        ifdef PNG_FORMAT_BGR_SUPPORTED
+            /* BGR is meaningless if no color: */
+            if ((f & PNG_FORMAT_FLAG_COLOR) == 0 &&
+               (f & PNG_FORMAT_FLAG_BGR) != 0)
+#        else
+            if ((f & 0x10U/*HACK: fixed value*/) != 0)
+#        endif
+            continue;
+
+         /* AFIRST is meaningless if no alpha: */
+#        ifdef PNG_FORMAT_AFIRST_SUPPORTED
+            if ((f & PNG_FORMAT_FLAG_ALPHA) == 0 &&
+               (f & PNG_FORMAT_FLAG_AFIRST) != 0)
+#        else
+            if ((f & 0x20U/*HACK: fixed value*/) != 0)
+#        endif
+            continue;
+
+         format_set(pf, f);
+      }
+   }
+}
+
+/* THE Image STRUCTURE */
+/* The super-class of a png_image, contains the decoded image plus the input
+ * data necessary to re-read the file with a different format.
+ */
+typedef struct
+{
+   png_image   image;
+   png_uint_32 opts;
+   const char *file_name;
+   int         stride_extra;
+   FILE       *input_file;
+   png_voidp   input_memory;
+   size_t      input_memory_size;
+   png_bytep   buffer;
+   ptrdiff_t   stride;
+   size_t      bufsize;
+   size_t      allocsize;
+   char        tmpfile_name[32];
+   png_uint_16 colormap[256*4];
+}
+Image;
+
+/* Initializer: also sets the permitted error limit for 16-bit operations. */
+static void
+newimage(Image *image)
+{
+   memset(image, 0, sizeof *image);
+}
+
+/* Reset the image to be read again - only needs to rewind the FILE* at present.
+ */
+static void
+resetimage(Image *image)
+{
+   if (image->input_file != NULL)
+      rewind(image->input_file);
+}
+
+/* Free the image buffer; the buffer is re-used on a re-read, this is just for
+ * cleanup.
+ */
+static void
+freebuffer(Image *image)
+{
+   if (image->buffer) free(image->buffer);
+   image->buffer = NULL;
+   image->bufsize = 0;
+   image->allocsize = 0;
+}
+
+/* Delete function; cleans out all the allocated data and the temporary file in
+ * the image.
+ */
+static void
+freeimage(Image *image)
+{
+   freebuffer(image);
+   png_image_free(&image->image);
+
+   if (image->input_file != NULL)
+   {
+      fclose(image->input_file);
+      image->input_file = NULL;
+   }
+
+   if (image->input_memory != NULL)
+   {
+      free(image->input_memory);
+      image->input_memory = NULL;
+      image->input_memory_size = 0;
+   }
+
+   if (image->tmpfile_name[0] != 0 && (image->opts & KEEP_TMPFILES) == 0)
+   {
+      (void)remove(image->tmpfile_name);
+      image->tmpfile_name[0] = 0;
+   }
+}
+
+/* This is actually a re-initializer; allows an image structure to be re-used by
+ * freeing everything that relates to an old image.
+ */
+static void initimage(Image *image, png_uint_32 opts, const char *file_name,
+   int stride_extra)
+{
+   freeimage(image);
+   memset(&image->image, 0, sizeof image->image);
+   image->opts = opts;
+   image->file_name = file_name;
+   image->stride_extra = stride_extra;
+}
+
+/* Make sure the image buffer is big enough; allows re-use of the buffer if the
+ * image is re-read.
+ */
+#define BUFFER_INIT8 73
+static void
+allocbuffer(Image *image)
+{
+   size_t size = PNG_IMAGE_BUFFER_SIZE(image->image, image->stride);
+
+   if (size+32 > image->bufsize)
+   {
+      freebuffer(image);
+      image->buffer = voidcast(png_bytep, malloc(size+32));
+      if (image->buffer == NULL)
+      {
+         fflush(stdout);
+         fprintf(stderr,
+            "simpletest: out of memory allocating %lu(+32) byte buffer\n",
+            (unsigned long)size);
+         exit(1);
+      }
+      image->bufsize = size+32;
+   }
+
+   memset(image->buffer, 95, image->bufsize);
+   memset(image->buffer+16, BUFFER_INIT8, size);
+   image->allocsize = size;
+}
+
+/* Make sure 16 bytes match the given byte. */
+static int
+check16(png_const_bytep bp, int b)
+{
+   int i = 16;
+
+   do
+      if (*bp != b) return 1;
+   while (--i);
+
+   return 0;
+}
+
+/* Check for overwrite in the image buffer. */
+static void
+checkbuffer(Image *image, const char *arg)
+{
+   if (check16(image->buffer, 95))
+   {
+      fflush(stdout);
+      fprintf(stderr, "%s: overwrite at start of image buffer\n", arg);
+      exit(1);
+   }
+
+   if (check16(image->buffer+16+image->allocsize, 95))
+   {
+      fflush(stdout);
+      fprintf(stderr, "%s: overwrite at end of image buffer\n", arg);
+      exit(1);
+   }
+}
+
+/* ERROR HANDLING */
+/* Log a terminal error, also frees the libpng part of the image if necessary.
+ */
+static int
+logerror(Image *image, const char *a1, const char *a2, const char *a3)
+{
+   fflush(stdout);
+   if (image->image.warning_or_error)
+      fprintf(stderr, "%s%s%s: %s\n", a1, a2, a3, image->image.message);
+
+   else
+      fprintf(stderr, "%s%s%s\n", a1, a2, a3);
+
+   if (image->image.opaque != NULL)
+   {
+      fprintf(stderr, "%s: image opaque pointer non-NULL on error\n",
+         image->file_name);
+      png_image_free(&image->image);
+   }
+
+   return 0;
+}
+
+/* Log an error and close a file (just a utility to do both things in one
+ * function call.)
+ */
+static int
+logclose(Image *image, FILE *f, const char *name, const char *operation)
+{
+   int e = errno;
+
+   fclose(f);
+   return logerror(image, name, operation, strerror(e));
+}
+
+/* Make sure the png_image has been freed - validates that libpng is doing what
+ * the spec says and freeing the image.
+ */
+static int
+checkopaque(Image *image)
+{
+   if (image->image.opaque != NULL)
+   {
+      png_image_free(&image->image);
+      return logerror(image, image->file_name, ": opaque not NULL", "");
+   }
+
+   /* Separate out the gamma+background_rgb_to_gray warning because it may
+    * produce opaque component errors:
+    */
+   else if (image->image.warning_or_error != 0 &&
+            (strcmp(image->image.message,
+               "libpng does not support gamma+background+rgb_to_gray") == 0 ?
+                  (image->opts & GBG_ERROR) != 0 : (image->opts & STRICT) != 0))
+      return logerror(image, image->file_name, (image->opts & GBG_ERROR) != 0 ?
+                      " --fault-gbg-warning" : " --strict", "");
+
+   else
+      return 1;
+}
+
+/* IMAGE COMPARISON/CHECKING */
+/* Compare the pixels of two images, which should be the same but aren't.  The
+ * images must have been checked for a size match.
+ */
+typedef struct
+{
+   /* The components, for grayscale images the gray value is in 'g' and if alpha
+    * is not present 'a' is set to 255 or 65535 according to format.
+    */
+   int         r, g, b, a;
+} Pixel;
+
+typedef struct
+{
+   /* The background as the original sRGB 8-bit value converted to the final
+    * integer format and as a double precision linear value in the range 0..1
+    * for with partially transparent pixels.
+    */
+   int ir, ig, ib;
+   double dr, dg, db; /* linear r,g,b scaled to 0..1 */
+} Background;
+
+/* Basic image formats; control the data but not the layout thereof. */
+#define BASE_FORMATS\
+   (PNG_FORMAT_FLAG_ALPHA|PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_LINEAR)
+
+/* Read a Pixel from a buffer.  The code below stores the correct routine for
+ * the format in a function pointer, these are the routines:
+ */
+static void
+gp_g8(Pixel *p, png_const_voidp pb)
+{
+   png_const_bytep pp = voidcast(png_const_bytep, pb);
+
+   p->r = p->g = p->b = pp[0];
+   p->a = 255;
+}
+
+static void
+gp_ga8(Pixel *p, png_const_voidp pb)
+{
+   png_const_bytep pp = voidcast(png_const_bytep, pb);
+
+   p->r = p->g = p->b = pp[0];
+   p->a = pp[1];
+}
+
+#ifdef PNG_FORMAT_AFIRST_SUPPORTED
+static void
+gp_ag8(Pixel *p, png_const_voidp pb)
+{
+   png_const_bytep pp = voidcast(png_const_bytep, pb);
+
+   p->r = p->g = p->b = pp[1];
+   p->a = pp[0];
+}
+#endif
+
+static void
+gp_rgb8(Pixel *p, png_const_voidp pb)
+{
+   png_const_bytep pp = voidcast(png_const_bytep, pb);
+
+   p->r = pp[0];
+   p->g = pp[1];
+   p->b = pp[2];
+   p->a = 255;
+}
+
+#ifdef PNG_FORMAT_BGR_SUPPORTED
+static void
+gp_bgr8(Pixel *p, png_const_voidp pb)
+{
+   png_const_bytep pp = voidcast(png_const_bytep, pb);
+
+   p->r = pp[2];
+   p->g = pp[1];
+   p->b = pp[0];
+   p->a = 255;
+}
+#endif
+
+static void
+gp_rgba8(Pixel *p, png_const_voidp pb)
+{
+   png_const_bytep pp = voidcast(png_const_bytep, pb);
+
+   p->r = pp[0];
+   p->g = pp[1];
+   p->b = pp[2];
+   p->a = pp[3];
+}
+
+#ifdef PNG_FORMAT_BGR_SUPPORTED
+static void
+gp_bgra8(Pixel *p, png_const_voidp pb)
+{
+   png_const_bytep pp = voidcast(png_const_bytep, pb);
+
+   p->r = pp[2];
+   p->g = pp[1];
+   p->b = pp[0];
+   p->a = pp[3];
+}
+#endif
+
+#ifdef PNG_FORMAT_AFIRST_SUPPORTED
+static void
+gp_argb8(Pixel *p, png_const_voidp pb)
+{
+   png_const_bytep pp = voidcast(png_const_bytep, pb);
+
+   p->r = pp[1];
+   p->g = pp[2];
+   p->b = pp[3];
+   p->a = pp[0];
+}
+#endif
+
+#if defined(PNG_FORMAT_AFIRST_SUPPORTED) && defined(PNG_FORMAT_BGR_SUPPORTED)
+static void
+gp_abgr8(Pixel *p, png_const_voidp pb)
+{
+   png_const_bytep pp = voidcast(png_const_bytep, pb);
+
+   p->r = pp[3];
+   p->g = pp[2];
+   p->b = pp[1];
+   p->a = pp[0];
+}
+#endif
+
+static void
+gp_g16(Pixel *p, png_const_voidp pb)
+{
+   png_const_uint_16p pp = voidcast(png_const_uint_16p, pb);
+
+   p->r = p->g = p->b = pp[0];
+   p->a = 65535;
+}
+
+static void
+gp_ga16(Pixel *p, png_const_voidp pb)
+{
+   png_const_uint_16p pp = voidcast(png_const_uint_16p, pb);
+
+   p->r = p->g = p->b = pp[0];
+   p->a = pp[1];
+}
+
+#ifdef PNG_FORMAT_AFIRST_SUPPORTED
+static void
+gp_ag16(Pixel *p, png_const_voidp pb)
+{
+   png_const_uint_16p pp = voidcast(png_const_uint_16p, pb);
+
+   p->r = p->g = p->b = pp[1];
+   p->a = pp[0];
+}
+#endif
+
+static void
+gp_rgb16(Pixel *p, png_const_voidp pb)
+{
+   png_const_uint_16p pp = voidcast(png_const_uint_16p, pb);
+
+   p->r = pp[0];
+   p->g = pp[1];
+   p->b = pp[2];
+   p->a = 65535;
+}
+
+#ifdef PNG_FORMAT_BGR_SUPPORTED
+static void
+gp_bgr16(Pixel *p, png_const_voidp pb)
+{
+   png_const_uint_16p pp = voidcast(png_const_uint_16p, pb);
+
+   p->r = pp[2];
+   p->g = pp[1];
+   p->b = pp[0];
+   p->a = 65535;
+}
+#endif
+
+static void
+gp_rgba16(Pixel *p, png_const_voidp pb)
+{
+   png_const_uint_16p pp = voidcast(png_const_uint_16p, pb);
+
+   p->r = pp[0];
+   p->g = pp[1];
+   p->b = pp[2];
+   p->a = pp[3];
+}
+
+#ifdef PNG_FORMAT_BGR_SUPPORTED
+static void
+gp_bgra16(Pixel *p, png_const_voidp pb)
+{
+   png_const_uint_16p pp = voidcast(png_const_uint_16p, pb);
+
+   p->r = pp[2];
+   p->g = pp[1];
+   p->b = pp[0];
+   p->a = pp[3];
+}
+#endif
+
+#ifdef PNG_FORMAT_AFIRST_SUPPORTED
+static void
+gp_argb16(Pixel *p, png_const_voidp pb)
+{
+   png_const_uint_16p pp = voidcast(png_const_uint_16p, pb);
+
+   p->r = pp[1];
+   p->g = pp[2];
+   p->b = pp[3];
+   p->a = pp[0];
+}
+#endif
+
+#if defined(PNG_FORMAT_AFIRST_SUPPORTED) && defined(PNG_FORMAT_BGR_SUPPORTED)
+static void
+gp_abgr16(Pixel *p, png_const_voidp pb)
+{
+   png_const_uint_16p pp = voidcast(png_const_uint_16p, pb);
+
+   p->r = pp[3];
+   p->g = pp[2];
+   p->b = pp[1];
+   p->a = pp[0];
+}
+#endif
+
+/* Given a format, return the correct one of the above functions. */
+static void (*
+get_pixel(png_uint_32 format))(Pixel *p, png_const_voidp pb)
+{
+   /* The color-map flag is irrelevant here - the caller of the function
+    * returned must either pass the buffer or, for a color-mapped image, the
+    * correct entry in the color-map.
+    */
+   if (format & PNG_FORMAT_FLAG_LINEAR)
+   {
+      if (format & PNG_FORMAT_FLAG_COLOR)
+      {
+#        ifdef PNG_FORMAT_BGR_SUPPORTED
+            if (format & PNG_FORMAT_FLAG_BGR)
+            {
+               if (format & PNG_FORMAT_FLAG_ALPHA)
+               {
+#                 ifdef PNG_FORMAT_AFIRST_SUPPORTED
+                     if (format & PNG_FORMAT_FLAG_AFIRST)
+                        return gp_abgr16;
+
+                     else
+#                 endif
+                     return gp_bgra16;
+               }
+
+               else
+                  return gp_bgr16;
+            }
+
+            else
+#        endif
+         {
+            if (format & PNG_FORMAT_FLAG_ALPHA)
+            {
+#              ifdef PNG_FORMAT_AFIRST_SUPPORTED
+                  if (format & PNG_FORMAT_FLAG_AFIRST)
+                     return gp_argb16;
+
+                  else
+#              endif
+                  return gp_rgba16;
+            }
+
+            else
+               return gp_rgb16;
+         }
+      }
+
+      else
+      {
+         if (format & PNG_FORMAT_FLAG_ALPHA)
+         {
+#           ifdef PNG_FORMAT_AFIRST_SUPPORTED
+               if (format & PNG_FORMAT_FLAG_AFIRST)
+                  return gp_ag16;
+
+               else
+#           endif
+               return gp_ga16;
+         }
+
+         else
+            return gp_g16;
+      }
+   }
+
+   else
+   {
+      if (format & PNG_FORMAT_FLAG_COLOR)
+      {
+#        ifdef PNG_FORMAT_BGR_SUPPORTED
+            if (format & PNG_FORMAT_FLAG_BGR)
+            {
+               if (format & PNG_FORMAT_FLAG_ALPHA)
+               {
+#                 ifdef PNG_FORMAT_AFIRST_SUPPORTED
+                     if (format & PNG_FORMAT_FLAG_AFIRST)
+                        return gp_abgr8;
+
+                     else
+#                 endif
+                     return gp_bgra8;
+               }
+
+               else
+                  return gp_bgr8;
+            }
+
+            else
+#        endif
+         {
+            if (format & PNG_FORMAT_FLAG_ALPHA)
+            {
+#              ifdef PNG_FORMAT_AFIRST_SUPPORTED
+                  if (format & PNG_FORMAT_FLAG_AFIRST)
+                     return gp_argb8;
+
+                  else
+#              endif
+                  return gp_rgba8;
+            }
+
+            else
+               return gp_rgb8;
+         }
+      }
+
+      else
+      {
+         if (format & PNG_FORMAT_FLAG_ALPHA)
+         {
+#           ifdef PNG_FORMAT_AFIRST_SUPPORTED
+               if (format & PNG_FORMAT_FLAG_AFIRST)
+                  return gp_ag8;
+
+               else
+#           endif
+               return gp_ga8;
+         }
+
+         else
+            return gp_g8;
+      }
+   }
+}
+
+/* Conversion between pixel formats.  The code above effectively eliminates the
+ * component ordering changes leaving three basic changes:
+ *
+ * 1) Remove an alpha channel by pre-multiplication or compositing on a
+ *    background color.  (Adding an alpha channel is a no-op.)
+ *
+ * 2) Remove color by mapping to grayscale.  (Grayscale to color is a no-op.)
+ *
+ * 3) Convert between 8-bit and 16-bit components.  (Both directtions are
+ *    relevant.)
+ *
+ * This gives the following base format conversion matrix:
+ *
+ *   OUT:    ----- 8-bit -----    ----- 16-bit -----
+ *   IN     G    GA   RGB  RGBA  G    GA   RGB  RGBA
+ *  8 G     .    .    .    .     lin  lin  lin  lin
+ *  8 GA    bckg .    bckc .     pre' pre  pre' pre
+ *  8 RGB   g8   g8   .    .     glin glin lin  lin
+ *  8 RGBA  g8b  g8   bckc .     gpr' gpre pre' pre
+ * 16 G     sRGB sRGB sRGB sRGB  .    .    .    .
+ * 16 GA    b16g unpg b16c unpc  A    .    A    .
+ * 16 RGB   sG   sG   sRGB sRGB  g16  g16  .    .
+ * 16 RGBA  gb16 sGp  cb16 sCp   g16  g16' A    .
+ *
+ *  8-bit to 8-bit:
+ * bckg: composite on gray background
+ * bckc: composite on color background
+ * g8:   convert sRGB components to sRGB grayscale
+ * g8b:  convert sRGB components to grayscale and composite on gray background
+ *
+ *  8-bit to 16-bit:
+ * lin:  make sRGB components linear, alpha := 65535
+ * pre:  make sRGB components linear and premultiply by alpha  (scale alpha)
+ * pre': as 'pre' but alpha := 65535
+ * glin: make sRGB components linear, convert to grayscale, alpha := 65535
+ * gpre: make sRGB components grayscale and linear and premultiply by alpha
+ * gpr': as 'gpre' but alpha := 65535
+ *
+ *  16-bit to 8-bit:
+ * sRGB: convert linear components to sRGB, alpha := 255
+ * unpg: unpremultiply gray component and convert to sRGB (scale alpha)
+ * unpc: unpremultiply color components and convert to sRGB (scale alpha)
+ * b16g: composite linear onto gray background and convert the result to sRGB
+ * b16c: composite linear onto color background and convert the result to sRGB
+ * sG:   convert linear RGB to sRGB grayscale
+ * sGp:  unpremultiply RGB then convert to sRGB grayscale
+ * sCp:  unpremultiply RGB then convert to sRGB
+ * gb16: composite linear onto background and convert to sRGB grayscale
+ *       (order doesn't matter, the composite and grayscale operations permute)
+ * cb16: composite linear onto background and convert to sRGB
+ *
+ *  16-bit to 16-bit:
+ * A:    set alpha to 65535
+ * g16:  convert linear RGB to linear grayscale (alpha := 65535)
+ * g16': as 'g16' but alpha is unchanged
+ */
+/* Simple copy: */
+static void
+gpc_noop(Pixel *out, const Pixel *in, const Background *back)
+{
+   (void)back;
+   out->r = in->r;
+   out->g = in->g;
+   out->b = in->b;
+   out->a = in->a;
+}
+
+#if ALLOW_UNUSED_GPC
+static void
+gpc_nop8(Pixel *out, const Pixel *in, const Background *back)
+{
+   (void)back;
+   if (in->a == 0)
+      out->r = out->g = out->b = 255;
+
+   else
+   {
+      out->r = in->r;
+      out->g = in->g;
+      out->b = in->b;
+   }
+
+   out->a = in->a;
+}
+#endif
+
+#if ALLOW_UNUSED_GPC
+static void
+gpc_nop6(Pixel *out, const Pixel *in, const Background *back)
+{
+   (void)back;
+   if (in->a == 0)
+      out->r = out->g = out->b = 65535;
+
+   else
+   {
+      out->r = in->r;
+      out->g = in->g;
+      out->b = in->b;
+   }
+
+   out->a = in->a;
+}
+#endif
+
+/* 8-bit to 8-bit conversions */
+/* bckg: composite on gray background */
+static void
+gpc_bckg(Pixel *out, const Pixel *in, const Background *back)
+{
+   if (in->a <= 0)
+      out->r = out->g = out->b = back->ig;
+
+   else if (in->a >= 255)
+      out->r = out->g = out->b = in->g;
+
+   else
+   {
+      double a = in->a / 255.;
+
+      out->r = out->g = out->b = sRGB(sRGB_to_d[in->g] * a + back->dg * (1-a));
+   }
+
+   out->a = 255;
+}
+
+/* bckc: composite on color background */
+static void
+gpc_bckc(Pixel *out, const Pixel *in, const Background *back)
+{
+   if (in->a <= 0)
+   {
+      out->r = back->ir;
+      out->g = back->ig;
+      out->b = back->ib;
+   }
+
+   else if (in->a >= 255)
+   {
+      out->r = in->r;
+      out->g = in->g;
+      out->b = in->b;
+   }
+
+   else
+   {
+      double a = in->a / 255.;
+
+      out->r = sRGB(sRGB_to_d[in->r] * a + back->dr * (1-a));
+      out->g = sRGB(sRGB_to_d[in->g] * a + back->dg * (1-a));
+      out->b = sRGB(sRGB_to_d[in->b] * a + back->db * (1-a));
+   }
+
+   out->a = 255;
+}
+
+/* g8: convert sRGB components to sRGB grayscale */
+static void
+gpc_g8(Pixel *out, const Pixel *in, const Background *back)
+{
+   (void)back;
+
+   if (in->r == in->g && in->g == in->b)
+      out->r = out->g = out->b = in->g;
+
+   else
+      out->r = out->g = out->b =
+         sRGB(YfromRGB(sRGB_to_d[in->r], sRGB_to_d[in->g], sRGB_to_d[in->b]));
+
+   out->a = in->a;
+}
+
+/* g8b: convert sRGB components to grayscale and composite on gray background */
+static void
+gpc_g8b(Pixel *out, const Pixel *in, const Background *back)
+{
+   if (in->a <= 0)
+      out->r = out->g = out->b = back->ig;
+
+   else if (in->a >= 255)
+   {
+      if (in->r == in->g && in->g == in->b)
+         out->r = out->g = out->b = in->g;
+
+      else
+         out->r = out->g = out->b = sRGB(YfromRGB(
+            sRGB_to_d[in->r], sRGB_to_d[in->g], sRGB_to_d[in->b]));
+   }
+
+   else
+   {
+      double a = in->a/255.;
+
+      out->r = out->g = out->b = sRGB(a * YfromRGB(sRGB_to_d[in->r],
+         sRGB_to_d[in->g], sRGB_to_d[in->b]) + back->dg * (1-a));
+   }
+
+   out->a = 255;
+}
+
+/* 8-bit to 16-bit conversions */
+/* lin: make sRGB components linear, alpha := 65535 */
+static void
+gpc_lin(Pixel *out, const Pixel *in, const Background *back)
+{
+   (void)back;
+
+   out->r = ilinear(in->r);
+
+   if (in->g == in->r)
+   {
+      out->g = out->r;
+
+      if (in->b == in->r)
+         out->b = out->r;
+
+      else
+         out->b = ilinear(in->b);
+   }
+
+   else
+   {
+      out->g = ilinear(in->g);
+
+      if (in->b == in->r)
+         out->b = out->r;
+
+      else if (in->b == in->g)
+         out->b = out->g;
+
+      else
+         out->b = ilinear(in->b);
+   }
+
+   out->a = 65535;
+}
+
+/* pre: make sRGB components linear and premultiply by alpha (scale alpha) */
+static void
+gpc_pre(Pixel *out, const Pixel *in, const Background *back)
+{
+   (void)back;
+
+   out->r = ilineara(in->r, in->a);
+
+   if (in->g == in->r)
+   {
+      out->g = out->r;
+
+      if (in->b == in->r)
+         out->b = out->r;
+
+      else
+         out->b = ilineara(in->b, in->a);
+   }
+
+   else
+   {
+      out->g = ilineara(in->g, in->a);
+
+      if (in->b == in->r)
+         out->b = out->r;
+
+      else if (in->b == in->g)
+         out->b = out->g;
+
+      else
+         out->b = ilineara(in->b, in->a);
+   }
+
+   out->a = in->a * 257;
+}
+
+/* pre': as 'pre' but alpha := 65535 */
+static void
+gpc_preq(Pixel *out, const Pixel *in, const Background *back)
+{
+   (void)back;
+
+   out->r = ilineara(in->r, in->a);
+
+   if (in->g == in->r)
+   {
+      out->g = out->r;
+
+      if (in->b == in->r)
+         out->b = out->r;
+
+      else
+         out->b = ilineara(in->b, in->a);
+   }
+
+   else
+   {
+      out->g = ilineara(in->g, in->a);
+
+      if (in->b == in->r)
+         out->b = out->r;
+
+      else if (in->b == in->g)
+         out->b = out->g;
+
+      else
+         out->b = ilineara(in->b, in->a);
+   }
+
+   out->a = 65535;
+}
+
+/* glin: make sRGB components linear, convert to grayscale, alpha := 65535 */
+static void
+gpc_glin(Pixel *out, const Pixel *in, const Background *back)
+{
+   (void)back;
+
+   if (in->r == in->g && in->g == in->b)
+      out->r = out->g = out->b = ilinear(in->g);
+
+   else
+      out->r = out->g = out->b = u16d(65535 *
+         YfromRGB(sRGB_to_d[in->r], sRGB_to_d[in->g], sRGB_to_d[in->b]));
+
+   out->a = 65535;
+}
+
+/* gpre: make sRGB components grayscale and linear and premultiply by alpha */
+static void
+gpc_gpre(Pixel *out, const Pixel *in, const Background *back)
+{
+   (void)back;
+
+   if (in->r == in->g && in->g == in->b)
+      out->r = out->g = out->b = ilineara(in->g, in->a);
+
+   else
+      out->r = out->g = out->b = u16d(in->a * 257 *
+         YfromRGB(sRGB_to_d[in->r], sRGB_to_d[in->g], sRGB_to_d[in->b]));
+
+   out->a = 257 * in->a;
+}
+
+/* gpr': as 'gpre' but alpha := 65535 */
+static void
+gpc_gprq(Pixel *out, const Pixel *in, const Background *back)
+{
+   (void)back;
+
+   if (in->r == in->g && in->g == in->b)
+      out->r = out->g = out->b = ilineara(in->g, in->a);
+
+   else
+      out->r = out->g = out->b = u16d(in->a * 257 *
+         YfromRGB(sRGB_to_d[in->r], sRGB_to_d[in->g], sRGB_to_d[in->b]));
+
+   out->a = 65535;
+}
+
+/* 8-bit to 16-bit conversions for gAMA 45455 encoded values */
+/* Lin: make gAMA 45455 components linear, alpha := 65535 */
+static void
+gpc_Lin(Pixel *out, const Pixel *in, const Background *back)
+{
+   (void)back;
+
+   out->r = ilinear_g22(in->r);
+
+   if (in->g == in->r)
+   {
+      out->g = out->r;
+
+      if (in->b == in->r)
+         out->b = out->r;
+
+      else
+         out->b = ilinear_g22(in->b);
+   }
+
+   else
+   {
+      out->g = ilinear_g22(in->g);
+
+      if (in->b == in->r)
+         out->b = out->r;
+
+      else if (in->b == in->g)
+         out->b = out->g;
+
+      else
+         out->b = ilinear_g22(in->b);
+   }
+
+   out->a = 65535;
+}
+
+#if ALLOW_UNUSED_GPC
+/* Pre: make gAMA 45455 components linear and premultiply by alpha (scale alpha)
+ */
+static void
+gpc_Pre(Pixel *out, const Pixel *in, const Background *back)
+{
+   (void)back;
+
+   out->r = ilineara_g22(in->r, in->a);
+
+   if (in->g == in->r)
+   {
+      out->g = out->r;
+
+      if (in->b == in->r)
+         out->b = out->r;
+
+      else
+         out->b = ilineara_g22(in->b, in->a);
+   }
+
+   else
+   {
+      out->g = ilineara_g22(in->g, in->a);
+
+      if (in->b == in->r)
+         out->b = out->r;
+
+      else if (in->b == in->g)
+         out->b = out->g;
+
+      else
+         out->b = ilineara_g22(in->b, in->a);
+   }
+
+   out->a = in->a * 257;
+}
+#endif
+
+#if ALLOW_UNUSED_GPC
+/* Pre': as 'Pre' but alpha := 65535 */
+static void
+gpc_Preq(Pixel *out, const Pixel *in, const Background *back)
+{
+   (void)back;
+
+   out->r = ilineara_g22(in->r, in->a);
+
+   if (in->g == in->r)
+   {
+      out->g = out->r;
+
+      if (in->b == in->r)
+         out->b = out->r;
+
+      else
+         out->b = ilineara_g22(in->b, in->a);
+   }
+
+   else
+   {
+      out->g = ilineara_g22(in->g, in->a);
+
+      if (in->b == in->r)
+         out->b = out->r;
+
+      else if (in->b == in->g)
+         out->b = out->g;
+
+      else
+         out->b = ilineara_g22(in->b, in->a);
+   }
+
+   out->a = 65535;
+}
+#endif
+
+#if ALLOW_UNUSED_GPC
+/* Glin: make gAMA 45455 components linear, convert to grayscale, alpha := 65535
+ */
+static void
+gpc_Glin(Pixel *out, const Pixel *in, const Background *back)
+{
+   (void)back;
+
+   if (in->r == in->g && in->g == in->b)
+      out->r = out->g = out->b = ilinear_g22(in->g);
+
+   else
+      out->r = out->g = out->b = u16d(65535 *
+         YfromRGB(g22_to_d[in->r], g22_to_d[in->g], g22_to_d[in->b]));
+
+   out->a = 65535;
+}
+#endif
+
+#if ALLOW_UNUSED_GPC
+/* Gpre: make gAMA 45455 components grayscale and linear and premultiply by
+ * alpha.
+ */
+static void
+gpc_Gpre(Pixel *out, const Pixel *in, const Background *back)
+{
+   (void)back;
+
+   if (in->r == in->g && in->g == in->b)
+      out->r = out->g = out->b = ilineara_g22(in->g, in->a);
+
+   else
+      out->r = out->g = out->b = u16d(in->a * 257 *
+         YfromRGB(g22_to_d[in->r], g22_to_d[in->g], g22_to_d[in->b]));
+
+   out->a = 257 * in->a;
+}
+#endif
+
+#if ALLOW_UNUSED_GPC
+/* Gpr': as 'Gpre' but alpha := 65535 */
+static void
+gpc_Gprq(Pixel *out, const Pixel *in, const Background *back)
+{
+   (void)back;
+
+   if (in->r == in->g && in->g == in->b)
+      out->r = out->g = out->b = ilineara_g22(in->g, in->a);
+
+   else
+      out->r = out->g = out->b = u16d(in->a * 257 *
+         YfromRGB(g22_to_d[in->r], g22_to_d[in->g], g22_to_d[in->b]));
+
+   out->a = 65535;
+}
+#endif
+
+/* 16-bit to 8-bit conversions */
+/* sRGB: convert linear components to sRGB, alpha := 255 */
+static void
+gpc_sRGB(Pixel *out, const Pixel *in, const Background *back)
+{
+   (void)back;
+
+   out->r = isRGB(in->r);
+
+   if (in->g == in->r)
+   {
+      out->g = out->r;
+
+      if (in->b == in->r)
+         out->b = out->r;
+
+      else
+         out->b = isRGB(in->b);
+   }
+
+   else
+   {
+      out->g = isRGB(in->g);
+
+      if (in->b == in->r)
+         out->b = out->r;
+
+      else if (in->b == in->g)
+         out->b = out->g;
+
+      else
+         out->b = isRGB(in->b);
+   }
+
+   out->a = 255;
+}
+
+/* unpg: unpremultiply gray component and convert to sRGB (scale alpha) */
+static void
+gpc_unpg(Pixel *out, const Pixel *in, const Background *back)
+{
+   (void)back;
+
+   if (in->a <= 128)
+   {
+      out->r = out->g = out->b = 255;
+      out->a = 0;
+   }
+
+   else
+   {
+      out->r = out->g = out->b = sRGB((double)in->g / in->a);
+      out->a = u8d(in->a / 257.);
+   }
+}
+
+/* unpc: unpremultiply color components and convert to sRGB (scale alpha) */
+static void
+gpc_unpc(Pixel *out, const Pixel *in, const Background *back)
+{
+   (void)back;
+
+   if (in->a <= 128)
+   {
+      out->r = out->g = out->b = 255;
+      out->a = 0;
+   }
+
+   else
+   {
+      out->r = sRGB((double)in->r / in->a);
+      out->g = sRGB((double)in->g / in->a);
+      out->b = sRGB((double)in->b / in->a);
+      out->a = u8d(in->a / 257.);
+   }
+}
+
+/* b16g: composite linear onto gray background and convert the result to sRGB */
+static void
+gpc_b16g(Pixel *out, const Pixel *in, const Background *back)
+{
+   if (in->a <= 0)
+      out->r = out->g = out->b = back->ig;
+
+   else
+   {
+      double a = in->a/65535.;
+      double a1 = 1-a;
+
+      a /= 65535;
+      out->r = out->g = out->b = sRGB(in->g * a + back->dg * a1);
+   }
+
+   out->a = 255;
+}
+
+/* b16c: composite linear onto color background and convert the result to sRGB*/
+static void
+gpc_b16c(Pixel *out, const Pixel *in, const Background *back)
+{
+   if (in->a <= 0)
+   {
+      out->r = back->ir;
+      out->g = back->ig;
+      out->b = back->ib;
+   }
+
+   else
+   {
+      double a = in->a/65535.;
+      double a1 = 1-a;
+
+      a /= 65535;
+      out->r = sRGB(in->r * a + back->dr * a1);
+      out->g = sRGB(in->g * a + back->dg * a1);
+      out->b = sRGB(in->b * a + back->db * a1);
+   }
+
+   out->a = 255;
+}
+
+/* sG: convert linear RGB to sRGB grayscale */
+static void
+gpc_sG(Pixel *out, const Pixel *in, const Background *back)
+{
+   (void)back;
+
+   out->r = out->g = out->b = sRGB(YfromRGBint(in->r, in->g, in->b)/65535);
+   out->a = 255;
+}
+
+/* sGp: unpremultiply RGB then convert to sRGB grayscale */
+static void
+gpc_sGp(Pixel *out, const Pixel *in, const Background *back)
+{
+   (void)back;
+
+   if (in->a <= 128)
+   {
+      out->r = out->g = out->b = 255;
+      out->a = 0;
+   }
+
+   else
+   {
+      out->r = out->g = out->b = sRGB(YfromRGBint(in->r, in->g, in->b)/in->a);
+      out->a = u8d(in->a / 257.);
+   }
+}
+
+/* sCp: unpremultiply RGB then convert to sRGB */
+static void
+gpc_sCp(Pixel *out, const Pixel *in, const Background *back)
+{
+   (void)back;
+
+   if (in->a <= 128)
+   {
+      out->r = out->g = out->b = 255;
+      out->a = 0;
+   }
+
+   else
+   {
+      out->r = sRGB((double)in->r / in->a);
+      out->g = sRGB((double)in->g / in->a);
+      out->b = sRGB((double)in->b / in->a);
+      out->a = u8d(in->a / 257.);
+   }
+}
+
+/* gb16: composite linear onto background and convert to sRGB grayscale */
+/*  (order doesn't matter, the composite and grayscale operations permute) */
+static void
+gpc_gb16(Pixel *out, const Pixel *in, const Background *back)
+{
+   if (in->a <= 0)
+      out->r = out->g = out->b = back->ig;
+
+   else if (in->a >= 65535)
+      out->r = out->g = out->b = isRGB(in->g);
+
+   else
+   {
+      double a = in->a / 65535.;
+      double a1 = 1-a;
+
+      a /= 65535;
+      out->r = out->g = out->b = sRGB(in->g * a + back->dg * a1);
+   }
+
+   out->a = 255;
+}
+
+/* cb16: composite linear onto background and convert to sRGB */
+static void
+gpc_cb16(Pixel *out, const Pixel *in, const Background *back)
+{
+   if (in->a <= 0)
+   {
+      out->r = back->ir;
+      out->g = back->ig;
+      out->b = back->ib;
+   }
+
+   else if (in->a >= 65535)
+   {
+      out->r = isRGB(in->r);
+      out->g = isRGB(in->g);
+      out->b = isRGB(in->b);
+   }
+
+   else
+   {
+      double a = in->a / 65535.;
+      double a1 = 1-a;
+
+      a /= 65535;
+      out->r = sRGB(in->r * a + back->dr * a1);
+      out->g = sRGB(in->g * a + back->dg * a1);
+      out->b = sRGB(in->b * a + back->db * a1);
+   }
+
+   out->a = 255;
+}
+
+/* 16-bit to 16-bit conversions */
+/* A:    set alpha to 65535 */
+static void
+gpc_A(Pixel *out, const Pixel *in, const Background *back)
+{
+   (void)back;
+   out->r = in->r;
+   out->g = in->g;
+   out->b = in->b;
+   out->a = 65535;
+}
+
+/* g16:  convert linear RGB to linear grayscale (alpha := 65535) */
+static void
+gpc_g16(Pixel *out, const Pixel *in, const Background *back)
+{
+   (void)back;
+   out->r = out->g = out->b = u16d(YfromRGBint(in->r, in->g, in->b));
+   out->a = 65535;
+}
+
+/* g16': as 'g16' but alpha is unchanged */
+static void
+gpc_g16q(Pixel *out, const Pixel *in, const Background *back)
+{
+   (void)back;
+   out->r = out->g = out->b = u16d(YfromRGBint(in->r, in->g, in->b));
+   out->a = in->a;
+}
+
+#if ALLOW_UNUSED_GPC
+/* Unused functions (to hide them from GCC unused function warnings) */
+void (* const gpc_unused[])
+   (Pixel *out, const Pixel *in, const Background *back) =
+{
+   gpc_Pre, gpc_Preq, gpc_Glin, gpc_Gpre, gpc_Gprq, gpc_nop8, gpc_nop6
+};
+#endif
+
+/*   OUT:    ----- 8-bit -----    ----- 16-bit -----
+ *   IN     G    GA   RGB  RGBA  G    GA   RGB  RGBA
+ *  8 G     .    .    .    .     lin  lin  lin  lin
+ *  8 GA    bckg .    bckc .     pre' pre  pre' pre
+ *  8 RGB   g8   g8   .    .     glin glin lin  lin
+ *  8 RGBA  g8b  g8   bckc .     gpr' gpre pre' pre
+ * 16 G     sRGB sRGB sRGB sRGB  .    .    .    .
+ * 16 GA    b16g unpg b16c unpc  A    .    A    .
+ * 16 RGB   sG   sG   sRGB sRGB  g16  g16  .    .
+ * 16 RGBA  gb16 sGp  cb16 sCp   g16  g16' A    .
+ *
+ * The matrix is held in an array indexed thus:
+ *
+ *   gpc_fn[out_format & BASE_FORMATS][in_format & BASE_FORMATS];
+ */
+/* This will produce a compile time error if the FORMAT_FLAG values don't
+ * match the above matrix!
+ */
+#if PNG_FORMAT_FLAG_ALPHA == 1 && PNG_FORMAT_FLAG_COLOR == 2 &&\
+   PNG_FORMAT_FLAG_LINEAR == 4
+static void (* const gpc_fn[8/*in*/][8/*out*/])
+   (Pixel *out, const Pixel *in, const Background *back) =
+{
+/*out: G-8     GA-8     RGB-8    RGBA-8    G-16     GA-16   RGB-16  RGBA-16 */
+   {gpc_noop,gpc_noop,gpc_noop,gpc_noop, gpc_Lin, gpc_Lin, gpc_Lin, gpc_Lin },
+   {gpc_bckg,gpc_noop,gpc_bckc,gpc_noop, gpc_preq,gpc_pre, gpc_preq,gpc_pre },
+   {gpc_g8,  gpc_g8,  gpc_noop,gpc_noop, gpc_glin,gpc_glin,gpc_lin, gpc_lin },
+   {gpc_g8b, gpc_g8,  gpc_bckc,gpc_noop, gpc_gprq,gpc_gpre,gpc_preq,gpc_pre },
+   {gpc_sRGB,gpc_sRGB,gpc_sRGB,gpc_sRGB, gpc_noop,gpc_noop,gpc_noop,gpc_noop},
+   {gpc_b16g,gpc_unpg,gpc_b16c,gpc_unpc, gpc_A,   gpc_noop,gpc_A,   gpc_noop},
+   {gpc_sG,  gpc_sG,  gpc_sRGB,gpc_sRGB, gpc_g16, gpc_g16, gpc_noop,gpc_noop},
+   {gpc_gb16,gpc_sGp, gpc_cb16,gpc_sCp,  gpc_g16, gpc_g16q,gpc_A,   gpc_noop}
+};
+
+/* The array is repeated for the cases where both the input and output are color
+ * mapped because then different algorithms are used.
+ */
+static void (* const gpc_fn_colormapped[8/*in*/][8/*out*/])
+   (Pixel *out, const Pixel *in, const Background *back) =
+{
+/*out: G-8     GA-8     RGB-8    RGBA-8    G-16     GA-16   RGB-16  RGBA-16 */
+   {gpc_noop,gpc_noop,gpc_noop,gpc_noop, gpc_lin, gpc_lin, gpc_lin, gpc_lin },
+   {gpc_bckg,gpc_noop,gpc_bckc,gpc_noop, gpc_preq,gpc_pre, gpc_preq,gpc_pre },
+   {gpc_g8,  gpc_g8,  gpc_noop,gpc_noop, gpc_glin,gpc_glin,gpc_lin, gpc_lin },
+   {gpc_g8b, gpc_g8,  gpc_bckc,gpc_noop, gpc_gprq,gpc_gpre,gpc_preq,gpc_pre },
+   {gpc_sRGB,gpc_sRGB,gpc_sRGB,gpc_sRGB, gpc_noop,gpc_noop,gpc_noop,gpc_noop},
+   {gpc_b16g,gpc_unpg,gpc_b16c,gpc_unpc, gpc_A,   gpc_noop,gpc_A,   gpc_noop},
+   {gpc_sG,  gpc_sG,  gpc_sRGB,gpc_sRGB, gpc_g16, gpc_g16, gpc_noop,gpc_noop},
+   {gpc_gb16,gpc_sGp, gpc_cb16,gpc_sCp,  gpc_g16, gpc_g16q,gpc_A,   gpc_noop}
+};
+
+/* The error arrays record the error in the same matrix; 64 entries, however
+ * the different algorithms used in libpng for colormap and direct conversions
+ * mean that four separate matrices are used (for each combination of
+ * colormapped and direct.)
+ *
+ * In some cases the conversion between sRGB formats goes via a linear
+ * intermediate; an sRGB to linear conversion (as above) is followed by a simple
+ * linear to sRGB step with no other conversions.  This is done by a separate
+ * error array from an arbitrary 'in' format to one of the four basic outputs
+ * (since final output is always sRGB not colormapped).
+ *
+ * These arrays may be modified if the --accumulate flag is set during the run;
+ * then instead of logging errors they are simply added in.
+ *
+ * The three entries are currently for transparent, partially transparent and
+ * opaque input pixel values.  Notice that alpha should be exact in each case.
+ *
+ * Errors in alpha should only occur when converting from a direct format
+ * to a colormapped format, when alpha is effectively smashed (so large
+ * errors can occur.)  There should be no error in the '0' and 'opaque'
+ * values.  The fourth entry in the array is used for the alpha error (and it
+ * should always be zero for the 'via linear' case since this is never color
+ * mapped.)
+ *
+ * Mapping to a colormap smashes the colors, it is necessary to have separate
+ * values for these cases because they are much larger; it is very much
+ * impossible to obtain a reasonable result, these are held in
+ * gpc_error_to_colormap.
+ */
+#if PNG_FORMAT_FLAG_COLORMAP == 8 /* extra check also required */
+#  include "pngstest-errors.h" /* machine generated */
+#endif /* COLORMAP flag check */
+#endif /* flag checks */
+
+typedef struct
+{
+   /* Basic pixel information: */
+   Image*       in_image;   /* Input image */
+   const Image* out_image;  /* Output image */
+
+   /* 'background' is the value passed to the gpc_ routines, it may be NULL if
+    * it should not be used (*this* program has an error if it crashes as a
+    * result!)
+    */
+   Background        background_color;
+   const Background* background;
+
+   /* Precalculated values: */
+   int          in_opaque;   /* Value of input alpha that is opaque */
+   int          is_palette;  /* Sample values come from the palette */
+   int          accumulate;  /* Accumulate component errors (don't log) */
+   int          output_8bit; /* Output is 8-bit (else 16-bit) */
+
+   void (*in_gp)(Pixel*, png_const_voidp);
+   void (*out_gp)(Pixel*, png_const_voidp);
+
+   void (*transform)(Pixel *out, const Pixel *in, const Background *back);
+      /* A function to perform the required transform */
+
+   void (*from_linear)(Pixel *out, const Pixel *in, const Background *back);
+      /* For 'via_linear' transforms the final, from linear, step, else NULL */
+
+   png_uint_16 error[4];
+      /* Three error values for transparent, partially transparent and opaque
+       * input pixels (in turn).
+       */
+
+   png_uint_16 *error_ptr;
+      /* Where these are stored in the static array (for 'accumulate') */
+}
+Transform;
+
+/* Return a 'transform' as above for the given format conversion. */
+static void
+transform_from_formats(Transform *result, Image *in_image,
+   const Image *out_image, png_const_colorp background, int via_linear)
+{
+   png_uint_32 in_format, out_format;
+   png_uint_32 in_base, out_base;
+
+   memset(result, 0, sizeof *result);
+
+   /* Store the original images for error messages */
+   result->in_image = in_image;
+   result->out_image = out_image;
+
+   in_format = in_image->image.format;
+   out_format = out_image->image.format;
+
+   if (in_format & PNG_FORMAT_FLAG_LINEAR)
+      result->in_opaque = 65535;
+   else
+      result->in_opaque = 255;
+
+   result->output_8bit = (out_format & PNG_FORMAT_FLAG_LINEAR) == 0;
+
+   result->is_palette = 0; /* set by caller if required */
+   result->accumulate = (in_image->opts & ACCUMULATE) != 0;
+
+   /* The loaders (which need the ordering information) */
+   result->in_gp = get_pixel(in_format);
+   result->out_gp = get_pixel(out_format);
+
+   /* Remove the ordering information: */
+   in_format &= BASE_FORMATS | PNG_FORMAT_FLAG_COLORMAP;
+   in_base = in_format & BASE_FORMATS;
+   out_format &= BASE_FORMATS | PNG_FORMAT_FLAG_COLORMAP;
+   out_base = out_format & BASE_FORMATS;
+
+   if (via_linear)
+   {
+      /* Check for an error in this program: */
+      if (out_format & (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_COLORMAP))
+      {
+         fprintf(stderr, "internal transform via linear error 0x%x->0x%x\n",
+            in_format, out_format);
+         exit(1);
+      }
+
+      result->transform = gpc_fn[in_base][out_base | PNG_FORMAT_FLAG_LINEAR];
+      result->from_linear = gpc_fn[out_base | PNG_FORMAT_FLAG_LINEAR][out_base];
+      result->error_ptr = gpc_error_via_linear[in_format][out_format];
+   }
+
+   else if (~in_format & out_format & PNG_FORMAT_FLAG_COLORMAP)
+   {
+      /* The input is not colormapped but the output is, the errors will
+       * typically be large (only the grayscale-no-alpha case permits preserving
+       * even 8-bit values.)
+       */
+      result->transform = gpc_fn[in_base][out_base];
+      result->from_linear = NULL;
+      result->error_ptr = gpc_error_to_colormap[in_base][out_base];
+   }
+
+   else
+   {
+      /* The caller handles the colormap->pixel value conversion, so the
+       * transform function just gets a pixel value, however because libpng
+       * currently contains a different implementation for mapping a colormap if
+       * both input and output are colormapped we need different conversion
+       * functions to deal with errors in the libpng implementation.
+       */
+      if (in_format & out_format & PNG_FORMAT_FLAG_COLORMAP)
+         result->transform = gpc_fn_colormapped[in_base][out_base];
+      else
+         result->transform = gpc_fn[in_base][out_base];
+      result->from_linear = NULL;
+      result->error_ptr = gpc_error[in_format][out_format];
+   }
+
+   /* Follow the libpng simplified API rules to work out what to pass to the gpc
+    * routines as a background value, if one is not required pass NULL so that
+    * this program crashes in the even of a programming error.
+    */
+   result->background = NULL; /* default: not required */
+
+   /* Rule 1: background only need be supplied if alpha is to be removed */
+   if (in_format & ~out_format & PNG_FORMAT_FLAG_ALPHA)
+   {
+      /* The input value is 'NULL' to use the background and (otherwise) an sRGB
+       * background color (to use a solid color).  The code above uses a fixed
+       * byte value, BUFFER_INIT8, for buffer even for 16-bit output.  For
+       * linear (16-bit) output the sRGB background color is ignored; the
+       * composition is always on the background (so BUFFER_INIT8 * 257), except
+       * that for the colormap (i.e. linear colormapped output) black is used.
+       */
+      result->background = &result->background_color;
+
+      if (out_format & PNG_FORMAT_FLAG_LINEAR || via_linear)
+      {
+         if (out_format & PNG_FORMAT_FLAG_COLORMAP)
+         {
+            result->background_color.ir =
+               result->background_color.ig =
+               result->background_color.ib = 0;
+            result->background_color.dr =
+               result->background_color.dg =
+               result->background_color.db = 0;
+         }
+
+         else
+         {
+            result->background_color.ir =
+               result->background_color.ig =
+               result->background_color.ib = BUFFER_INIT8 * 257;
+            result->background_color.dr =
+               result->background_color.dg =
+               result->background_color.db = 0;
+         }
+      }
+
+      else /* sRGB output */
+      {
+         if (background != NULL)
+         {
+            if (out_format & PNG_FORMAT_FLAG_COLOR)
+            {
+               result->background_color.ir = background->red;
+               result->background_color.ig = background->green;
+               result->background_color.ib = background->blue;
+               /* TODO: sometimes libpng uses the power law conversion here, how
+                * to handle this?
+                */
+               result->background_color.dr = sRGB_to_d[background->red];
+               result->background_color.dg = sRGB_to_d[background->green];
+               result->background_color.db = sRGB_to_d[background->blue];
+            }
+
+            else /* grayscale: libpng only looks at 'g' */
+            {
+               result->background_color.ir =
+                  result->background_color.ig =
+                  result->background_color.ib = background->green;
+               /* TODO: sometimes libpng uses the power law conversion here, how
+                * to handle this?
+                */
+               result->background_color.dr =
+                  result->background_color.dg =
+                  result->background_color.db = sRGB_to_d[background->green];
+            }
+         }
+
+         else if ((out_format & PNG_FORMAT_FLAG_COLORMAP) == 0)
+         {
+            result->background_color.ir =
+               result->background_color.ig =
+               result->background_color.ib = BUFFER_INIT8;
+            /* TODO: sometimes libpng uses the power law conversion here, how
+             * to handle this?
+             */
+            result->background_color.dr =
+               result->background_color.dg =
+               result->background_color.db = sRGB_to_d[BUFFER_INIT8];
+         }
+
+         /* Else the output is colormapped and a background color must be
+          * provided; if pngstest crashes then that is a bug in this program
+          * (though libpng should png_error as well.)
+          */
+         else
+            result->background = NULL;
+      }
+   }
+
+   if (result->background == NULL)
+   {
+      result->background_color.ir =
+         result->background_color.ig =
+         result->background_color.ib = -1; /* not used */
+      result->background_color.dr =
+         result->background_color.dg =
+         result->background_color.db = 1E30; /* not used */
+   }
+
+
+   /* Copy the error values into the Transform: */
+   result->error[0] = result->error_ptr[0];
+   result->error[1] = result->error_ptr[1];
+   result->error[2] = result->error_ptr[2];
+   result->error[3] = result->error_ptr[3];
+}
+
+
+/* Compare two pixels.
+ *
+ * OLD error values:
+static int error_to_linear = 811; * by experiment *
+static int error_to_linear_grayscale = 424; * by experiment *
+static int error_to_sRGB = 6; * by experiment *
+static int error_to_sRGB_grayscale = 17; * libpng error by calculation +
+                                            2 by experiment *
+static int error_in_compose = 2; * by experiment *
+static int error_in_premultiply = 1;
+ *
+ * The following is *just* the result of a round trip from 8-bit sRGB to linear
+ * then back to 8-bit sRGB when it is done by libpng.  There are two problems:
+ *
+ * 1) libpng currently uses a 2.2 power law with no linear segment, this results
+ * in instability in the low values and even with 16-bit precision sRGB(1) ends
+ * up mapping to sRGB(0) as a result of rounding in the 16-bit representation.
+ * This gives an error of 1 in the handling of value 1 only.
+ *
+ * 2) libpng currently uses an intermediate 8-bit linear value in gamma
+ * correction of 8-bit values.  This results in many more errors, the worse of
+ * which is mapping sRGB(14) to sRGB(0).
+ *
+ * The general 'error_via_linear' is more complex because of pre-multiplication,
+ * this compounds the 8-bit errors according to the alpha value of the pixel.
+ * As a result 256 values are pre-calculated for error_via_linear.
+ */
+#if 0
+static int error_in_libpng_gamma;
+static int error_via_linear[256]; /* Indexed by 8-bit alpha */
+
+static void
+init_error_via_linear(void)
+{
+   int alpha;
+
+   error_via_linear[0] = 255; /* transparent pixel */
+
+   for (alpha=1; alpha<=255; ++alpha)
+   {
+      /* 16-bit values less than 128.5 get rounded to 8-bit 0 and so the worst
+       * case error arises with 16-bit 128.5, work out what sRGB
+       * (non-associated) value generates 128.5; any value less than this is
+       * going to map to 0, so the worst error is floor(value).
+       *
+       * Note that errors are considerably higher (more than a factor of 2)
+       * because libpng uses a simple power law for sRGB data at present.
+       *
+       * Add .1 for arithmetic errors inside libpng.
+       */
+      double v = floor(255*pow(.5/*(128.5 * 255 / 65535)*/ / alpha, 1/2.2)+.1);
+
+      error_via_linear[alpha] = (int)v;
+   }
+
+   /* This is actually 14.99, but, despite the closeness to 15, 14 seems to work
+    * ok in this case.
+    */
+   error_in_libpng_gamma = 14;
+}
+#endif
+
+static void
+print_pixel(char string[64], const Pixel *pixel, png_uint_32 format)
+{
+   switch (format & (PNG_FORMAT_FLAG_ALPHA|PNG_FORMAT_FLAG_COLOR))
+   {
+      case 0:
+         sprintf(string, "%s(%d)", format_names[format], pixel->g);
+         break;
+
+      case PNG_FORMAT_FLAG_ALPHA:
+         sprintf(string, "%s(%d,%d)", format_names[format], pixel->g,
+            pixel->a);
+         break;
+
+      case PNG_FORMAT_FLAG_COLOR:
+         sprintf(string, "%s(%d,%d,%d)", format_names[format],
+            pixel->r, pixel->g, pixel->b);
+         break;
+
+      case PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_ALPHA:
+         sprintf(string, "%s(%d,%d,%d,%d)", format_names[format],
+            pixel->r, pixel->g, pixel->b, pixel->a);
+         break;
+
+      default:
+         sprintf(string, "invalid-format");
+         break;
+   }
+}
+
+static int
+logpixel(const Transform *transform, png_uint_32 x, png_uint_32 y,
+   const Pixel *in, const Pixel *calc, const Pixel *out, const char *reason)
+{
+   png_uint_32 in_format = transform->in_image->image.format;
+   png_uint_32 out_format = transform->out_image->image.format;
+
+   png_uint_32 back_format = out_format & ~PNG_FORMAT_FLAG_ALPHA;
+   const char *via_linear = "";
+
+   char pixel_in[64], pixel_calc[64], pixel_out[64], pixel_loc[64];
+   char background_info[100];
+
+   print_pixel(pixel_in, in, in_format);
+   print_pixel(pixel_calc, calc, out_format);
+   print_pixel(pixel_out, out, out_format);
+
+   if (transform->is_palette)
+      sprintf(pixel_loc, "palette: %lu", (unsigned long)y);
+   else
+      sprintf(pixel_loc, "%lu,%lu", (unsigned long)x, (unsigned long)y);
+
+   if (transform->from_linear != NULL)
+   {
+      via_linear = " (via linear)";
+      /* And as a result the *read* format which did any background processing
+       * was itself linear, so the background color information is also
+       * linear.
+       */
+      back_format |= PNG_FORMAT_FLAG_LINEAR;
+   }
+
+   if (transform->background != NULL)
+   {
+      Pixel back;
+      char pixel_back[64];
+
+      back.r = transform->background->ir;
+      back.g = transform->background->ig;
+      back.b = transform->background->ib;
+      back.a = -1; /* not used */
+
+      print_pixel(pixel_back, &back, back_format);
+      sprintf(background_info, " on background %s", pixel_back);
+   }
+
+   else
+      background_info[0] = 0;
+
+   if (transform->in_image->file_name != transform->out_image->file_name)
+   {
+      char error_buffer[512];
+      sprintf(error_buffer,
+         "(%s) %s error%s:\n %s%s ->\n       %s\n  not: %s.\n"
+         "Use --preserve and examine: ", pixel_loc, reason, via_linear,
+         pixel_in, background_info, pixel_out, pixel_calc);
+      return logerror(transform->in_image, transform->in_image->file_name,
+         error_buffer, transform->out_image->file_name);
+   }
+
+   else
+   {
+      char error_buffer[512];
+      sprintf(error_buffer,
+         "(%s) %s error%s:\n %s%s ->\n       %s\n  not: %s.\n"
+         " The error happened when reading the original file with this format.",
+         pixel_loc, reason, via_linear, pixel_in, background_info, pixel_out,
+         pixel_calc);
+      return logerror(transform->in_image, transform->in_image->file_name,
+         error_buffer, "");
+   }
+}
+
+static int
+cmppixel(Transform *transform, png_const_voidp in, png_const_voidp out,
+   png_uint_32 x, png_uint_32 y/*or palette index*/)
+{
+   int maxerr;
+   png_const_charp errmsg;
+   Pixel pixel_in, pixel_calc, pixel_out;
+
+   transform->in_gp(&pixel_in, in);
+
+   if (transform->from_linear == NULL)
+      transform->transform(&pixel_calc, &pixel_in, transform->background);
+
+   else
+   {
+      transform->transform(&pixel_out, &pixel_in, transform->background);
+      transform->from_linear(&pixel_calc, &pixel_out, NULL);
+   }
+
+   transform->out_gp(&pixel_out, out);
+
+   /* Eliminate the case where the input and output values match exactly. */
+   if (pixel_calc.a == pixel_out.a && pixel_calc.r == pixel_out.r &&
+      pixel_calc.g == pixel_out.g && pixel_calc.b == pixel_out.b)
+      return 1;
+
+   /* Eliminate the case where the output pixel is transparent and the output
+    * is 8-bit - any component values are valid.  Don't check the input alpha
+    * here to also skip the 16-bit small alpha cases.
+    */
+   if (transform->output_8bit && pixel_calc.a == 0 && pixel_out.a == 0)
+      return 1;
+
+   /* Check for alpha errors first; an alpha error can damage the components too
+    * so avoid spurious checks on components if one is found.
+    */
+   errmsg = NULL;
+   {
+      int err_a = abs(pixel_calc.a-pixel_out.a);
+
+      if (err_a > transform->error[3])
+      {
+         /* If accumulating check the components too */
+         if (transform->accumulate)
+            transform->error[3] = (png_uint_16)err_a;
+
+         else
+            errmsg = "alpha";
+      }
+   }
+
+   /* Now if *either* of the output alphas are 0 but alpha is within tolerance
+    * eliminate the 8-bit component comparison.
+    */
+   if (errmsg == NULL && transform->output_8bit &&
+      (pixel_calc.a == 0 || pixel_out.a == 0))
+      return 1;
+
+   if (errmsg == NULL) /* else just signal an alpha error */
+   {
+      int err_r = abs(pixel_calc.r - pixel_out.r);
+      int err_g = abs(pixel_calc.g - pixel_out.g);
+      int err_b = abs(pixel_calc.b - pixel_out.b);
+      int limit;
+
+      if ((err_r | err_g | err_b) == 0)
+         return 1; /* exact match */
+
+      /* Mismatch on a component, check the input alpha */
+      if (pixel_in.a >= transform->in_opaque)
+      {
+         errmsg = "opaque component";
+         limit = 2; /* opaque */
+      }
+
+      else if (pixel_in.a > 0)
+      {
+         errmsg = "alpha component";
+         limit = 1; /* partially transparent */
+      }
+
+      else
+      {
+         errmsg = "transparent component (background)";
+         limit = 0; /* transparent */
+      }
+
+      maxerr = err_r;
+      if (maxerr < err_g) maxerr = err_g;
+      if (maxerr < err_b) maxerr = err_b;
+
+      if (maxerr <= transform->error[limit])
+         return 1; /* within the error limits */
+
+      /* Handle a component mis-match; log it, just return an error code, or
+       * accumulate it.
+       */
+      if (transform->accumulate)
+      {
+         transform->error[limit] = (png_uint_16)maxerr;
+         return 1; /* to cause the caller to keep going */
+      }
+   }
+
+   /* Failure to match and not accumulating, so the error must be logged. */
+   return logpixel(transform, x, y, &pixel_in, &pixel_calc, &pixel_out, errmsg);
+}
+
+static png_byte
+component_loc(png_byte loc[4], png_uint_32 format)
+{
+   /* Given a format return the number of channels and the location of
+    * each channel.
+    *
+    * The mask 'loc' contains the component offset of the channels in the
+    * following order.  Note that if 'format' is grayscale the entries 1-3 must
+    * all contain the location of the gray channel.
+    *
+    * 0: alpha
+    * 1: red or gray
+    * 2: green or gray
+    * 3: blue or gray
+    */
+   png_byte channels;
+
+   if (format & PNG_FORMAT_FLAG_COLOR)
+   {
+      channels = 3;
+
+      loc[2] = 1;
+
+#     ifdef PNG_FORMAT_BGR_SUPPORTED
+         if (format & PNG_FORMAT_FLAG_BGR)
+         {
+            loc[1] = 2;
+            loc[3] = 0;
+         }
+
+         else
+#     endif
+      {
+         loc[1] = 0;
+         loc[3] = 2;
+      }
+   }
+
+   else
+   {
+      channels = 1;
+      loc[1] = loc[2] = loc[3] = 0;
+   }
+
+   if (format & PNG_FORMAT_FLAG_ALPHA)
+   {
+#     ifdef PNG_FORMAT_AFIRST_SUPPORTED
+         if (format & PNG_FORMAT_FLAG_AFIRST)
+         {
+            loc[0] = 0;
+            ++loc[1];
+            ++loc[2];
+            ++loc[3];
+         }
+
+         else
+#     endif
+         loc[0] = channels;
+
+      ++channels;
+   }
+
+   else
+      loc[0] = 4; /* not present */
+
+   return channels;
+}
+
+/* Compare two images, the original 'a', which was written out then read back in
+ * to * give image 'b'.  The formats may have been changed.
+ */
+static int
+compare_two_images(Image *a, Image *b, int via_linear,
+   png_const_colorp background)
+{
+   ptrdiff_t stridea = a->stride;
+   ptrdiff_t strideb = b->stride;
+   png_const_bytep rowa = a->buffer+16;
+   png_const_bytep rowb = b->buffer+16;
+   png_uint_32 width = a->image.width;
+   png_uint_32 height = a->image.height;
+   png_uint_32 formata = a->image.format;
+   png_uint_32 formatb = b->image.format;
+   unsigned int a_sample = PNG_IMAGE_SAMPLE_SIZE(formata);
+   unsigned int b_sample = PNG_IMAGE_SAMPLE_SIZE(formatb);
+   int alpha_added, alpha_removed;
+   int bchannels;
+   png_uint_32 y;
+   Transform tr;
+   int btoa[4]={0,0,0,0};
+
+   /* This should never happen: */
+   if (width != b->image.width || height != b->image.height)
+      return logerror(a, a->file_name, ": width x height changed: ",
+         b->file_name);
+
+   /* Set up the background and the transform */
+   transform_from_formats(&tr, a, b, background, via_linear);
+
+   /* Find the first row and inter-row space. */
+   if (!(formata & PNG_FORMAT_FLAG_COLORMAP) &&
+      (formata & PNG_FORMAT_FLAG_LINEAR))
+      stridea *= 2;
+
+   if (!(formatb & PNG_FORMAT_FLAG_COLORMAP) &&
+      (formatb & PNG_FORMAT_FLAG_LINEAR))
+      strideb *= 2;
+
+   if (stridea < 0) rowa += (height-1) * (-stridea);
+   if (strideb < 0) rowb += (height-1) * (-strideb);
+
+   /* First shortcut the two colormap case by comparing the image data; if it
+    * matches then we expect the colormaps to match, although this is not
+    * absolutely necessary for an image match.  If the colormaps fail to match
+    * then there is a problem in libpng.
+    */
+   if (formata & formatb & PNG_FORMAT_FLAG_COLORMAP)
+   {
+      /* Only check colormap entries that actually exist; */
+      png_const_bytep ppa, ppb;
+      int match;
+      png_byte in_use[256], amax = 0, bmax = 0;
+
+      memset(in_use, 0, sizeof in_use);
+
+      ppa = rowa;
+      ppb = rowb;
+
+      /* Do this the slow way to accumulate the 'in_use' flags, don't break out
+       * of the loop until the end; this validates the color-mapped data to
+       * ensure all pixels are valid color-map indexes.
+       */
+      for (y=0, match=1; y<height && match; ++y, ppa += stridea, ppb += strideb)
+      {
+         png_uint_32 x;
+
+         for (x=0; x<width; ++x)
+         {
+            png_byte bval = ppb[x];
+            png_byte aval = ppa[x];
+
+            if (bval > bmax)
+               bmax = bval;
+
+            if (bval != aval)
+               match = 0;
+
+            in_use[aval] = 1;
+            if (aval > amax)
+               amax = aval;
+         }
+      }
+
+      /* If the buffers match then the colormaps must too. */
+      if (match)
+      {
+         /* Do the color-maps match, entry by entry?  Only check the 'in_use'
+          * entries.  An error here should be logged as a color-map error.
+          */
+         png_const_bytep a_cmap = (png_const_bytep)a->colormap;
+         png_const_bytep b_cmap = (png_const_bytep)b->colormap;
+         int result = 1; /* match by default */
+
+         /* This is used in logpixel to get the error message correct. */
+         tr.is_palette = 1;
+
+         for (y=0; y<256; ++y, a_cmap += a_sample, b_cmap += b_sample)
+            if (in_use[y])
+         {
+            /* The colormap entries should be valid, but because libpng doesn't
+             * do any checking at present the original image may contain invalid
+             * pixel values.  These cause an error here (at present) unless
+             * accumulating errors in which case the program just ignores them.
+             */
+            if (y >= a->image.colormap_entries)
+            {
+               if ((a->opts & ACCUMULATE) == 0)
+               {
+                  char pindex[9];
+                  sprintf(pindex, "%lu[%lu]", (unsigned long)y,
+                     (unsigned long)a->image.colormap_entries);
+                  logerror(a, a->file_name, ": bad pixel index: ", pindex);
+               }
+               result = 0;
+            }
+
+            else if (y >= b->image.colormap_entries)
+            {
+               if ((b->opts & ACCUMULATE) == 0)
+                  {
+                  char pindex[9];
+                  sprintf(pindex, "%lu[%lu]", (unsigned long)y,
+                     (unsigned long)b->image.colormap_entries);
+                  logerror(b, b->file_name, ": bad pixel index: ", pindex);
+                  }
+               result = 0;
+            }
+
+            /* All the mismatches are logged here; there can only be 256! */
+            else if (!cmppixel(&tr, a_cmap, b_cmap, 0, y))
+               result = 0;
+         }
+
+         /* If requested, copy the error values back from the Transform. */
+         if (a->opts & ACCUMULATE)
+         {
+            tr.error_ptr[0] = tr.error[0];
+            tr.error_ptr[1] = tr.error[1];
+            tr.error_ptr[2] = tr.error[2];
+            tr.error_ptr[3] = tr.error[3];
+            result = 1; /* force a continue */
+         }
+
+         return result;
+      }
+
+      /* else the image buffers don't match pixel-wise so compare sample values
+       * instead, but first validate that the pixel indexes are in range (but
+       * only if not accumulating, when the error is ignored.)
+       */
+      else if ((a->opts & ACCUMULATE) == 0)
+      {
+#        ifdef __GNUC__
+#           define BYTE_CHARS 20 /* 2^32: GCC sprintf warning */
+#        else
+#           define BYTE_CHARS 3 /* 2^8: real maximum value */
+#        endif
+         /* Check the original image first,
+          * TODO: deal with input images with bad pixel values?
+          */
+         if (amax >= a->image.colormap_entries)
+         {
+            char pindex[3+2*BYTE_CHARS];
+            sprintf(pindex, "%d[%u]", amax,
+               (png_byte)/*SAFE*/a->image.colormap_entries);
+            return logerror(a, a->file_name, ": bad pixel index: ", pindex);
+         }
+
+         else if (bmax >= b->image.colormap_entries)
+         {
+            char pindex[3+2*BYTE_CHARS];
+            sprintf(pindex, "%d[%u]", bmax,
+               (png_byte)/*SAFE*/b->image.colormap_entries);
+            return logerror(b, b->file_name, ": bad pixel index: ", pindex);
+         }
+      }
+   }
+
+   /* We can directly compare pixel values without the need to use the read
+    * or transform support (i.e. a memory compare) if:
+    *
+    * 1) The bit depth has not changed.
+    * 2) RGB to grayscale has not been done (the reverse is ok; we just compare
+    *    the three RGB values to the original grayscale.)
+    * 3) An alpha channel has not been removed from an 8-bit format, or the
+    *    8-bit alpha value of the pixel was 255 (opaque).
+    *
+    * If an alpha channel has been *added* then it must have the relevant opaque
+    * value (255 or 65535).
+    *
+    * The fist two the tests (in the order given above) (using the boolean
+    * equivalence !a && !b == !(a || b))
+    */
+   if (!(((formata ^ formatb) & PNG_FORMAT_FLAG_LINEAR) |
+      (formata & (formatb ^ PNG_FORMAT_FLAG_COLOR) & PNG_FORMAT_FLAG_COLOR)))
+   {
+      /* Was an alpha channel changed? */
+      png_uint_32 alpha_changed = (formata ^ formatb) & PNG_FORMAT_FLAG_ALPHA;
+
+      /* Was an alpha channel removed?  (The third test.)  If so the direct
+       * comparison is only possible if the input alpha is opaque.
+       */
+      alpha_removed = (formata & alpha_changed) != 0;
+
+      /* Was an alpha channel added? */
+      alpha_added = (formatb & alpha_changed) != 0;
+
+      /* The channels may have been moved between input and output, this finds
+       * out how, recording the result in the btoa array, which says where in
+       * 'a' to find each channel of 'b'.  If alpha was added then btoa[alpha]
+       * ends up as 4 (and is not used.)
+       */
+      {
+         int i;
+         png_byte aloc[4];
+         png_byte bloc[4];
+
+         /* The following are used only if the formats match, except that
+          * 'bchannels' is a flag for matching formats.  btoa[x] says, for each
+          * channel in b, where to find the corresponding value in a, for the
+          * bchannels.  achannels may be different for a gray to rgb transform
+          * (a will be 1 or 2, b will be 3 or 4 channels.)
+          */
+         (void)component_loc(aloc, formata);
+         bchannels = component_loc(bloc, formatb);
+
+         /* Hence the btoa array. */
+         for (i=0; i<4; ++i) if (bloc[i] < 4)
+            btoa[bloc[i]] = aloc[i]; /* may be '4' for alpha */
+
+         if (alpha_added)
+            alpha_added = bloc[0]; /* location of alpha channel in image b */
+
+         else
+            alpha_added = 4; /* Won't match an image b channel */
+
+         if (alpha_removed)
+            alpha_removed = aloc[0]; /* location of alpha channel in image a */
+
+         else
+            alpha_removed = 4;
+      }
+   }
+
+   else
+   {
+      /* Direct compare is not possible, cancel out all the corresponding local
+       * variables.
+       */
+      bchannels = 0;
+      alpha_removed = alpha_added = 4;
+      btoa[3] = btoa[2] = btoa[1] = btoa[0] = 4; /* 4 == not present */
+   }
+
+   for (y=0; y<height; ++y, rowa += stridea, rowb += strideb)
+   {
+      png_const_bytep ppa, ppb;
+      png_uint_32 x;
+
+      for (x=0, ppa=rowa, ppb=rowb; x<width; ++x)
+      {
+         png_const_bytep psa, psb;
+
+         if (formata & PNG_FORMAT_FLAG_COLORMAP)
+            psa = (png_const_bytep)a->colormap + a_sample * *ppa++;
+         else
+            psa = ppa, ppa += a_sample;
+
+         if (formatb & PNG_FORMAT_FLAG_COLORMAP)
+            psb = (png_const_bytep)b->colormap + b_sample * *ppb++;
+         else
+            psb = ppb, ppb += b_sample;
+
+         /* Do the fast test if possible. */
+         if (bchannels)
+         {
+            /* Check each 'b' channel against either the corresponding 'a'
+             * channel or the opaque alpha value, as appropriate.  If
+             * alpha_removed value is set (not 4) then also do this only if the
+             * 'a' alpha channel (alpha_removed) is opaque; only relevant for
+             * the 8-bit case.
+             */
+            if (formatb & PNG_FORMAT_FLAG_LINEAR) /* 16-bit checks */
+            {
+               png_const_uint_16p pua = aligncastconst(png_const_uint_16p, psa);
+               png_const_uint_16p pub = aligncastconst(png_const_uint_16p, psb);
+
+               switch (bchannels)
+               {
+                  case 4:
+                     if (pua[btoa[3]] != pub[3]) break;
+                     /* FALLTHROUGH */
+                  case 3:
+                     if (pua[btoa[2]] != pub[2]) break;
+                     /* FALLTHROUGH */
+                  case 2:
+                     if (pua[btoa[1]] != pub[1]) break;
+                     /* FALLTHROUGH */
+                  case 1:
+                     if (pua[btoa[0]] != pub[0]) break;
+                     if (alpha_added != 4 && pub[alpha_added] != 65535) break;
+                     continue; /* x loop */
+                  default:
+                     break; /* impossible */
+               }
+            }
+
+            else if (alpha_removed == 4 || psa[alpha_removed] == 255)
+            {
+               switch (bchannels)
+               {
+                  case 4:
+                     if (psa[btoa[3]] != psb[3]) break;
+                     /* FALLTHROUGH */
+                  case 3:
+                     if (psa[btoa[2]] != psb[2]) break;
+                     /* FALLTHROUGH */
+                  case 2:
+                     if (psa[btoa[1]] != psb[1]) break;
+                     /* FALLTHROUGH */
+                  case 1:
+                     if (psa[btoa[0]] != psb[0]) break;
+                     if (alpha_added != 4 && psb[alpha_added] != 255) break;
+                     continue; /* x loop */
+                  default:
+                     break; /* impossible */
+               }
+            }
+         }
+
+         /* If we get to here the fast match failed; do the slow match for this
+          * pixel.
+          */
+         if (!cmppixel(&tr, psa, psb, x, y) && (a->opts & KEEP_GOING) == 0)
+            return 0; /* error case */
+      }
+   }
+
+   /* If requested, copy the error values back from the Transform. */
+   if (a->opts & ACCUMULATE)
+   {
+      tr.error_ptr[0] = tr.error[0];
+      tr.error_ptr[1] = tr.error[1];
+      tr.error_ptr[2] = tr.error[2];
+      tr.error_ptr[3] = tr.error[3];
+   }
+
+   return 1;
+}
+
+/* Read the file; how the read gets done depends on which of input_file and
+ * input_memory have been set.
+ */
+static int
+read_file(Image *image, png_uint_32 format, png_const_colorp background)
+{
+   memset(&image->image, 0, sizeof image->image);
+   image->image.version = PNG_IMAGE_VERSION;
+
+   if (image->input_memory != NULL)
+   {
+      if (!png_image_begin_read_from_memory(&image->image, image->input_memory,
+         image->input_memory_size))
+         return logerror(image, "memory init: ", image->file_name, "");
+   }
+
+#  ifdef PNG_STDIO_SUPPORTED
+      else if (image->input_file != NULL)
+      {
+         if (!png_image_begin_read_from_stdio(&image->image, image->input_file))
+            return logerror(image, "stdio init: ", image->file_name, "");
+      }
+
+      else
+      {
+         if (!png_image_begin_read_from_file(&image->image, image->file_name))
+            return logerror(image, "file init: ", image->file_name, "");
+      }
+#  else
+      else
+      {
+         return logerror(image, "unsupported file/stdio init: ",
+            image->file_name, "");
+      }
+#  endif
+
+   /* This must be set after the begin_read call: */
+   if (image->opts & sRGB_16BIT)
+      image->image.flags |= PNG_IMAGE_FLAG_16BIT_sRGB;
+
+   /* Have an initialized image with all the data we need plus, maybe, an
+    * allocated file (myfile) or buffer (mybuffer) that need to be freed.
+    */
+   {
+      int result;
+      png_uint_32 image_format;
+
+      /* Print both original and output formats. */
+      image_format = image->image.format;
+
+      if (image->opts & VERBOSE)
+      {
+         printf("%s %lu x %lu %s -> %s", image->file_name,
+            (unsigned long)image->image.width,
+            (unsigned long)image->image.height,
+            format_names[image_format & FORMAT_MASK],
+            (format & FORMAT_NO_CHANGE) != 0 || image->image.format == format
+            ? "no change" : format_names[format & FORMAT_MASK]);
+
+         if (background != NULL)
+            printf(" background(%d,%d,%d)\n", background->red,
+               background->green, background->blue);
+         else
+            printf("\n");
+
+         fflush(stdout);
+      }
+
+      /* 'NO_CHANGE' combined with the color-map flag forces the base format
+       * flags to be set on read to ensure that the original representation is
+       * not lost in the pass through a colormap format.
+       */
+      if ((format & FORMAT_NO_CHANGE) != 0)
+      {
+         if ((format & PNG_FORMAT_FLAG_COLORMAP) != 0 &&
+            (image_format & PNG_FORMAT_FLAG_COLORMAP) != 0)
+            format = (image_format & ~BASE_FORMATS) | (format & BASE_FORMATS);
+
+         else
+            format = image_format;
+      }
+
+      image->image.format = format;
+
+      image->stride = PNG_IMAGE_ROW_STRIDE(image->image) + image->stride_extra;
+      allocbuffer(image);
+
+      result = png_image_finish_read(&image->image, background,
+         image->buffer+16, (png_int_32)image->stride, image->colormap);
+
+      checkbuffer(image, image->file_name);
+
+      if (result)
+         return checkopaque(image);
+
+      else
+         return logerror(image, image->file_name, ": image read failed", "");
+   }
+}
+
+/* Reads from a filename, which must be in image->file_name, but uses
+ * image->opts to choose the method.  The file is always read in its native
+ * format (the one the simplified API suggests).
+ */
+static int
+read_one_file(Image *image)
+{
+   if (!(image->opts & USE_FILE) || (image->opts & USE_STDIO))
+   {
+      /* memory or stdio. */
+      FILE *f = fopen(image->file_name, "rb");
+
+      if (f != NULL)
+      {
+         if (image->opts & USE_FILE)
+            image->input_file = f;
+
+         else /* memory */
+         {
+            if (fseek(f, 0, SEEK_END) == 0)
+            {
+               long int cb = ftell(f);
+
+               if (cb > 0)
+               {
+#ifndef __COVERITY__
+                  if ((unsigned long int)cb <= (size_t)~(size_t)0)
+#endif
+                  {
+                     png_bytep b = voidcast(png_bytep, malloc((size_t)cb));
+
+                     if (b != NULL)
+                     {
+                        rewind(f);
+
+                        if (fread(b, (size_t)cb, 1, f) == 1)
+                        {
+                           fclose(f);
+                           image->input_memory_size = cb;
+                           image->input_memory = b;
+                        }
+
+                        else
+                        {
+                           free(b);
+                           return logclose(image, f, image->file_name,
+                              ": read failed: ");
+                        }
+                     }
+
+                     else
+                        return logclose(image, f, image->file_name,
+                           ": out of memory: ");
+                  }
+
+                  else
+                     return logclose(image, f, image->file_name,
+                        ": file too big for this architecture: ");
+                     /* cb is the length of the file as a (long) and
+                      * this is greater than the maximum amount of
+                      * memory that can be requested from malloc.
+                      */
+               }
+
+               else if (cb == 0)
+                  return logclose(image, f, image->file_name,
+                     ": zero length: ");
+
+               else
+                  return logclose(image, f, image->file_name,
+                     ": tell failed: ");
+            }
+
+            else
+               return logclose(image, f, image->file_name, ": seek failed: ");
+         }
+      }
+
+      else
+         return logerror(image, image->file_name, ": open failed: ",
+            strerror(errno));
+   }
+
+   return read_file(image, FORMAT_NO_CHANGE, NULL);
+}
+
+#ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED
+static int
+write_one_file(Image *output, Image *image, int convert_to_8bit)
+{
+   if (image->opts & FAST_WRITE)
+      image->image.flags |= PNG_IMAGE_FLAG_FAST;
+
+   if (image->opts & USE_STDIO)
+   {
+#ifdef PNG_SIMPLIFIED_WRITE_STDIO_SUPPORTED
+#ifndef __COVERITY__
+      FILE *f = tmpfile();
+#else
+      /* Experimental. Coverity says tmpfile() is insecure because it
+       * generates predictable names.
+       *
+       * It is possible to satisfy Coverity by using mkstemp(); however,
+       * any platform supporting mkstemp() undoubtedly has a secure tmpfile()
+       * implementation as well, and doesn't need the fix.  Note that
+       * the fix won't work on platforms that don't support mkstemp().
+       *
+       * https://www.securecoding.cert.org/confluence/display/c/
+       * FIO21-C.+Do+not+create+temporary+files+in+shared+directories
+       * says that most historic implementations of tmpfile() provide
+       * only a limited number of possible temporary file names
+       * (usually 26) before file names are recycled. That article also
+       * provides a secure solution that unfortunately depends upon mkstemp().
+       */
+      char tmpfile[] = "pngstest-XXXXXX";
+      int filedes;
+      FILE *f;
+      umask(0177);
+      filedes = mkstemp(tmpfile);
+      if (filedes < 0)
+        f = NULL;
+      else
+      {
+        f = fdopen(filedes,"w+");
+        /* Hide the filename immediately and ensure that the file does
+         * not exist after the program ends
+         */
+        (void) unlink(tmpfile);
+      }
+#endif
+
+      if (f != NULL)
+      {
+         if (png_image_write_to_stdio(&image->image, f, convert_to_8bit,
+            image->buffer+16, (png_int_32)image->stride, image->colormap))
+         {
+            if (fflush(f) == 0)
+            {
+               rewind(f);
+               initimage(output, image->opts, "tmpfile", image->stride_extra);
+               output->input_file = f;
+               if (!checkopaque(image))
+                  return 0;
+            }
+
+            else
+               return logclose(image, f, "tmpfile", ": flush: ");
+         }
+
+         else
+         {
+            fclose(f);
+            return logerror(image, "tmpfile", ": write failed", "");
+         }
+      }
+
+      else
+         return logerror(image, "tmpfile", ": open: ", strerror(errno));
+#else /* SIMPLIFIED_WRITE_STDIO */
+      return logerror(image, "tmpfile", ": open: unsupported", "");
+#endif /* SIMPLIFIED_WRITE_STDIO */
+   }
+
+   else if (image->opts & USE_FILE)
+   {
+#ifdef PNG_SIMPLIFIED_WRITE_STDIO_SUPPORTED
+      static int counter = 0;
+      char name[32];
+
+      sprintf(name, "%s%d.png", tmpf, ++counter);
+
+      if (png_image_write_to_file(&image->image, name, convert_to_8bit,
+         image->buffer+16, (png_int_32)image->stride, image->colormap))
+      {
+         initimage(output, image->opts, output->tmpfile_name,
+            image->stride_extra);
+         /* Afterwards, or freeimage will delete it! */
+         strcpy(output->tmpfile_name, name);
+
+         if (!checkopaque(image))
+            return 0;
+      }
+
+      else
+         return logerror(image, name, ": write failed", "");
+#else /* SIMPLIFIED_WRITE_STDIO */
+      return logerror(image, "stdio", ": open: unsupported", "");
+#endif /* SIMPLIFIED_WRITE_STDIO */
+   }
+
+   else /* use memory */
+   {
+      png_alloc_size_t size;
+
+      if (png_image_write_get_memory_size(image->image, size, convert_to_8bit,
+               image->buffer+16, (png_int_32)image->stride, image->colormap))
+      {
+         /* This is non-fatal but ignoring it was causing serious problems in
+          * the macro to be ignored:
+          */
+         if (size > PNG_IMAGE_PNG_SIZE_MAX(image->image))
+            return logerror(image, "memory", ": PNG_IMAGE_SIZE_MAX wrong", "");
+
+         initimage(output, image->opts, "memory", image->stride_extra);
+         output->input_memory = malloc(size);
+
+         if (output->input_memory != NULL)
+         {
+            output->input_memory_size = size;
+
+            if (png_image_write_to_memory(&image->image, output->input_memory,
+                  &output->input_memory_size, convert_to_8bit, image->buffer+16,
+                  (png_int_32)image->stride, image->colormap))
+            {
+               /* This is also non-fatal but it safes safer to error out anyway:
+                */
+               if (size != output->input_memory_size)
+                  return logerror(image, "memory", ": memory size wrong", "");
+            }
+
+            else
+               return logerror(image, "memory", ": write failed", "");
+         }
+
+         else
+            return logerror(image, "memory", ": out of memory", "");
+      }
+
+      else
+         return logerror(image, "memory", ": get size:", "");
+   }
+
+   /* 'output' has an initialized temporary image, read this back in and compare
+    * this against the original: there should be no change since the original
+    * format was written unmodified unless 'convert_to_8bit' was specified.
+    * However, if the original image was color-mapped, a simple read will zap
+    * the linear, color and maybe alpha flags, this will cause spurious failures
+    * under some circumstances.
+    */
+   if (read_file(output, image->image.format | FORMAT_NO_CHANGE, NULL))
+   {
+      png_uint_32 original_format = image->image.format;
+
+      if (convert_to_8bit)
+         original_format &= ~PNG_FORMAT_FLAG_LINEAR;
+
+      if ((output->image.format & BASE_FORMATS) !=
+         (original_format & BASE_FORMATS))
+         return logerror(image, image->file_name, ": format changed on read: ",
+            output->file_name);
+
+      return compare_two_images(image, output, 0/*via linear*/, NULL);
+   }
+
+   else
+      return logerror(output, output->tmpfile_name,
+         ": read of new file failed", "");
+}
+#endif
+
+static int
+testimage(Image *image, png_uint_32 opts, format_list *pf)
+{
+   int result;
+   Image copy;
+
+   /* Copy the original data, stealing it from 'image' */
+   checkopaque(image);
+   copy = *image;
+
+   copy.opts = opts;
+   copy.buffer = NULL;
+   copy.bufsize = 0;
+   copy.allocsize = 0;
+
+   image->input_file = NULL;
+   image->input_memory = NULL;
+   image->input_memory_size = 0;
+   image->tmpfile_name[0] = 0;
+
+   {
+      png_uint_32 counter;
+      Image output;
+
+      newimage(&output);
+
+      result = 1;
+
+      /* Use the low bit of 'counter' to indicate whether or not to do alpha
+       * removal with a background color or by composting onto the image; this
+       * step gets skipped if it isn't relevant
+       */
+      for (counter=0; counter<2*FORMAT_COUNT; ++counter)
+         if (format_isset(pf, counter >> 1))
+      {
+         png_uint_32 format = counter >> 1;
+
+         png_color background_color;
+         png_colorp background = NULL;
+
+         /* If there is a format change that removes the alpha channel then
+          * the background is relevant.  If the output is 8-bit color-mapped
+          * then a background color *must* be provided, otherwise there are
+          * two tests to do - one with a color, the other with NULL.  The
+          * NULL test happens second.
+          */
+         if ((counter & 1) == 0)
+         {
+            if ((format & PNG_FORMAT_FLAG_ALPHA) == 0 &&
+               (image->image.format & PNG_FORMAT_FLAG_ALPHA) != 0)
+            {
+               /* Alpha/transparency will be removed, the background is
+                * relevant: make it a color the first time
+                */
+               random_color(&background_color);
+               background = &background_color;
+
+               /* BUT if the output is to a color-mapped 8-bit format then
+                * the background must always be a color, so increment 'counter'
+                * to skip the NULL test.
+                */
+               if ((format & PNG_FORMAT_FLAG_COLORMAP) != 0 &&
+                  (format & PNG_FORMAT_FLAG_LINEAR) == 0)
+                  ++counter;
+            }
+
+            /* Otherwise an alpha channel is not being eliminated, just leave
+             * background NULL and skip the (counter & 1) NULL test.
+             */
+            else
+               ++counter;
+         }
+         /* else just use NULL for background */
+
+         resetimage(&copy);
+         copy.opts = opts; /* in case read_file needs to change it */
+
+         result = read_file(&copy, format, background);
+         if (!result)
+            break;
+
+         /* Make sure the file just read matches the original file. */
+         result = compare_two_images(image, &copy, 0/*via linear*/, background);
+         if (!result)
+            break;
+
+#        ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED
+            /* Write the *copy* just made to a new file to make sure the write
+             * side works ok.  Check the conversion to sRGB if the copy is
+             * linear.
+             */
+            output.opts = opts;
+            result = write_one_file(&output, &copy, 0/*convert to 8bit*/);
+            if (!result)
+               break;
+
+            /* Validate against the original too; the background is needed here
+             * as well so that compare_two_images knows what color was used.
+             */
+            result = compare_two_images(image, &output, 0, background);
+            if (!result)
+               break;
+
+            if ((format & PNG_FORMAT_FLAG_LINEAR) != 0 &&
+               (format & PNG_FORMAT_FLAG_COLORMAP) == 0)
+            {
+               /* 'output' is linear, convert to the corresponding sRGB format.
+                */
+               output.opts = opts;
+               result = write_one_file(&output, &copy, 1/*convert to 8bit*/);
+               if (!result)
+                  break;
+
+               /* This may involve a conversion via linear; in the ideal world
+                * this would round-trip correctly, but libpng 1.5.7 is not the
+                * ideal world so allow a drift (error_via_linear).
+                *
+                * 'image' has an alpha channel but 'output' does not then there
+                * will a strip-alpha-channel operation (because 'output' is
+                * linear), handle this by composing on black when doing the
+                * comparison.
+                */
+               result = compare_two_images(image, &output, 1/*via_linear*/,
+                  background);
+               if (!result)
+                  break;
+            }
+#        endif /* PNG_SIMPLIFIED_WRITE_SUPPORTED */
+      }
+
+      freeimage(&output);
+   }
+
+   freeimage(&copy);
+
+   return result;
+}
+
+static int
+test_one_file(const char *file_name, format_list *formats, png_uint_32 opts,
+   int stride_extra, int log_pass)
+{
+   int result;
+   Image image;
+
+   if (!(opts & NO_RESEED))
+      reseed(); /* ensure that the random numbers don't depend on file order */
+   newimage(&image);
+   initimage(&image, opts, file_name, stride_extra);
+   result = read_one_file(&image);
+   if (result)
+      result = testimage(&image, opts, formats);
+   freeimage(&image);
+
+   /* Ensure that stderr is flushed into any log file */
+   fflush(stderr);
+
+   if (log_pass)
+   {
+      if (result)
+         printf("PASS:");
+
+      else
+         printf("FAIL:");
+
+#     ifndef PNG_SIMPLIFIED_WRITE_SUPPORTED
+         printf(" (no write)");
+#     endif
+
+      print_opts(opts);
+      printf(" %s\n", file_name);
+      /* stdout may not be line-buffered if it is piped to a file, so: */
+      fflush(stdout);
+   }
+
+   else if (!result)
+      exit(1);
+
+   return result;
+}
+
+int
+main(int argc, char **argv)
+{
+   png_uint_32 opts = FAST_WRITE | STRICT;
+   format_list formats;
+   const char *touch = NULL;
+   int log_pass = 0;
+   int redundant = 0;
+   int stride_extra = 0;
+   int retval = 0;
+   int c;
+
+#if PNG_LIBPNG_VER >= 10700
+      /* This error should not exist in 1.7 or later: */
+      opts |= GBG_ERROR;
+#endif
+
+   init_sRGB_to_d();
+#if 0
+   init_error_via_linear();
+#endif
+   format_init(&formats);
+   reseed(); /* initialize random number seeds */
+
+   for (c=1; c<argc; ++c)
+   {
+      const char *arg = argv[c];
+
+      if (strcmp(arg, "--log") == 0)
+         log_pass = 1;
+      else if (strcmp(arg, "--fresh") == 0)
+      {
+         memset(gpc_error, 0, sizeof gpc_error);
+         memset(gpc_error_via_linear, 0, sizeof gpc_error_via_linear);
+      }
+      else if (strcmp(arg, "--file") == 0)
+#        ifdef PNG_STDIO_SUPPORTED
+            opts |= USE_FILE;
+#        else
+            return SKIP; /* skipped: no support */
+#        endif
+      else if (strcmp(arg, "--memory") == 0)
+         opts &= ~USE_FILE;
+      else if (strcmp(arg, "--stdio") == 0)
+#        ifdef PNG_STDIO_SUPPORTED
+            opts |= USE_STDIO;
+#        else
+            return SKIP; /* skipped: no support */
+#        endif
+      else if (strcmp(arg, "--name") == 0)
+         opts &= ~USE_STDIO;
+      else if (strcmp(arg, "--verbose") == 0)
+         opts |= VERBOSE;
+      else if (strcmp(arg, "--quiet") == 0)
+         opts &= ~VERBOSE;
+      else if (strcmp(arg, "--preserve") == 0)
+         opts |= KEEP_TMPFILES;
+      else if (strcmp(arg, "--nopreserve") == 0)
+         opts &= ~KEEP_TMPFILES;
+      else if (strcmp(arg, "--keep-going") == 0)
+         opts |= KEEP_GOING;
+      else if (strcmp(arg, "--fast") == 0)
+         opts |= FAST_WRITE;
+      else if (strcmp(arg, "--slow") == 0)
+         opts &= ~FAST_WRITE;
+      else if (strcmp(arg, "--accumulate") == 0)
+         opts |= ACCUMULATE;
+      else if (strcmp(arg, "--redundant") == 0)
+         redundant = 1;
+      else if (strcmp(arg, "--stop") == 0)
+         opts &= ~KEEP_GOING;
+      else if (strcmp(arg, "--strict") == 0)
+         opts |= STRICT;
+      else if (strcmp(arg, "--nostrict") == 0)
+         opts &= ~STRICT;
+      else if (strcmp(arg, "--sRGB-16bit") == 0)
+         opts |= sRGB_16BIT;
+      else if (strcmp(arg, "--linear-16bit") == 0)
+         opts &= ~sRGB_16BIT;
+      else if (strcmp(arg, "--noreseed") == 0)
+         opts |= NO_RESEED;
+      else if (strcmp(arg, "--fault-gbg-warning") == 0)
+         opts |= GBG_ERROR;
+      else if (strcmp(arg, "--tmpfile") == 0)
+      {
+         if (c+1 < argc)
+         {
+            if (strlen(argv[++c]) >= sizeof tmpf)
+            {
+               fflush(stdout);
+               fprintf(stderr, "%s: %s is too long for a temp file prefix\n",
+                  argv[0], argv[c]);
+               exit(99);
+            }
+
+            /* Safe: checked above */
+            strncpy(tmpf, argv[c], sizeof (tmpf)-1);
+         }
+
+         else
+         {
+            fflush(stdout);
+            fprintf(stderr, "%s: %s requires a temporary file prefix\n",
+               argv[0], arg);
+            exit(99);
+         }
+      }
+      else if (strcmp(arg, "--touch") == 0)
+      {
+         if (c+1 < argc)
+            touch = argv[++c];
+
+         else
+         {
+            fflush(stdout);
+            fprintf(stderr, "%s: %s requires a file name argument\n",
+               argv[0], arg);
+            exit(99);
+         }
+      }
+      else if (arg[0] == '+')
+      {
+         png_uint_32 format = formatof(arg+1);
+
+         if (format > FORMAT_COUNT)
+            exit(99);
+
+         format_set(&formats, format);
+      }
+      else if (arg[0] == '-' && arg[1] != 0 && (arg[1] != '0' || arg[2] != 0))
+      {
+         fflush(stdout);
+         fprintf(stderr, "%s: unknown option: %s\n", argv[0], arg);
+         exit(99);
+      }
+      else
+      {
+         if (format_is_initial(&formats))
+            format_default(&formats, redundant);
+
+         if (arg[0] == '-')
+         {
+            int term = (arg[1] == '0' ? 0 : '\n');
+            unsigned int ich = 0;
+
+            /* Loop reading files, use a static buffer to simplify this and just
+             * stop if the name gets to long.
+             */
+            static char buffer[4096];
+
+            do
+            {
+               int ch = getchar();
+
+               /* Don't allow '\0' in file names, and terminate with '\n' or,
+                * for -0, just '\0' (use -print0 to find to make this work!)
+                */
+               if (ch == EOF || ch == term || ch == 0)
+               {
+                  buffer[ich] = 0;
+
+                  if (ich > 0 && !test_one_file(buffer, &formats, opts,
+                     stride_extra, log_pass))
+                     retval = 1;
+
+                  if (ch == EOF)
+                     break;
+
+                  ich = 0;
+                  --ich; /* so that the increment below sets it to 0 again */
+               }
+
+               else
+                  buffer[ich] = (char)ch;
+            } while (++ich < sizeof buffer);
+
+            if (ich)
+            {
+               buffer[32] = 0;
+               buffer[4095] = 0;
+               fprintf(stderr, "%s...%s: file name too long\n", buffer,
+                  buffer+(4096-32));
+               exit(99);
+            }
+         }
+
+         else if (!test_one_file(arg, &formats, opts, stride_extra, log_pass))
+            retval = 1;
+      }
+   }
+
+   if (opts & ACCUMULATE)
+   {
+      unsigned int in;
+
+      printf("/* contrib/libtests/pngstest-errors.h\n");
+      printf(" *\n");
+      printf(" * BUILT USING:" PNG_HEADER_VERSION_STRING);
+      printf(" *\n");
+      printf(" * This code is released under the libpng license.\n");
+      printf(" * For conditions of distribution and use, see the disclaimer\n");
+      printf(" * and license in png.h\n");
+      printf(" *\n");
+      printf(" * THIS IS A MACHINE GENERATED FILE: do not edit it directly!\n");
+      printf(" * Instead run:\n");
+      printf(" *\n");
+      printf(" *    pngstest --accumulate\n");
+      printf(" *\n");
+      printf(" * on as many PNG files as possible; at least PNGSuite and\n");
+      printf(" * contrib/libtests/testpngs.\n");
+      printf(" */\n");
+
+      printf("static png_uint_16 gpc_error[16/*in*/][16/*out*/][4/*a*/] =\n");
+      printf("{\n");
+      for (in=0; in<16; ++in)
+      {
+         unsigned int out;
+         printf(" { /* input: %s */\n ", format_names[in]);
+         for (out=0; out<16; ++out)
+         {
+            unsigned int alpha;
+            printf(" {");
+            for (alpha=0; alpha<4; ++alpha)
+            {
+               printf(" %d", gpc_error[in][out][alpha]);
+               if (alpha < 3) putchar(',');
+            }
+            printf(" }");
+            if (out < 15)
+            {
+               putchar(',');
+               if (out % 4 == 3) printf("\n ");
+            }
+         }
+         printf("\n }");
+
+         if (in < 15)
+            putchar(',');
+         else
+            putchar('\n');
+      }
+      printf("};\n");
+
+      printf("static png_uint_16 gpc_error_via_linear[16][4/*out*/][4] =\n");
+      printf("{\n");
+      for (in=0; in<16; ++in)
+      {
+         unsigned int out;
+         printf(" { /* input: %s */\n ", format_names[in]);
+         for (out=0; out<4; ++out)
+         {
+            unsigned int alpha;
+            printf(" {");
+            for (alpha=0; alpha<4; ++alpha)
+            {
+               printf(" %d", gpc_error_via_linear[in][out][alpha]);
+               if (alpha < 3) putchar(',');
+            }
+            printf(" }");
+            if (out < 3)
+               putchar(',');
+         }
+         printf("\n }");
+
+         if (in < 15)
+            putchar(',');
+         else
+            putchar('\n');
+      }
+      printf("};\n");
+
+      printf("static png_uint_16 gpc_error_to_colormap[8/*i*/][8/*o*/][4] =\n");
+      printf("{\n");
+      for (in=0; in<8; ++in)
+      {
+         unsigned int out;
+         printf(" { /* input: %s */\n ", format_names[in]);
+         for (out=0; out<8; ++out)
+         {
+            unsigned int alpha;
+            printf(" {");
+            for (alpha=0; alpha<4; ++alpha)
+            {
+               printf(" %d", gpc_error_to_colormap[in][out][alpha]);
+               if (alpha < 3) putchar(',');
+            }
+            printf(" }");
+            if (out < 7)
+            {
+               putchar(',');
+               if (out % 4 == 3) printf("\n ");
+            }
+         }
+         printf("\n }");
+
+         if (in < 7)
+            putchar(',');
+         else
+            putchar('\n');
+      }
+      printf("};\n");
+      printf("/* END MACHINE GENERATED */\n");
+   }
+
+   if (retval == 0 && touch != NULL)
+   {
+      FILE *fsuccess = fopen(touch, "wt");
+
+      if (fsuccess != NULL)
+      {
+         int error = 0;
+         fprintf(fsuccess, "PNG simple API tests succeeded\n");
+         fflush(fsuccess);
+         error = ferror(fsuccess);
+
+         if (fclose(fsuccess) || error)
+         {
+            fflush(stdout);
+            fprintf(stderr, "%s: write failed\n", touch);
+            exit(99);
+         }
+      }
+
+      else
+      {
+         fflush(stdout);
+         fprintf(stderr, "%s: open failed\n", touch);
+         exit(99);
+      }
+   }
+
+   return retval;
+}
+
+#else /* !PNG_SIMPLIFIED_READ_SUPPORTED */
+int main(void)
+{
+   fprintf(stderr, "pngstest: no read support in libpng, test skipped\n");
+   /* So the test is skipped: */
+   return SKIP;
+}
+#endif /* PNG_SIMPLIFIED_READ_SUPPORTED */
diff --git a/Engine/lib/lpng/contrib/libtests/pngunknown.c b/Engine/lib/lpng/contrib/libtests/pngunknown.c
new file mode 100644
index 000000000..05bdd833d
--- /dev/null
+++ b/Engine/lib/lpng/contrib/libtests/pngunknown.c
@@ -0,0 +1,1294 @@
+
+/* pngunknown.c - test the read side unknown chunk handling
+ *
+ * Last changed in libpng 1.6.32 [August 24, 2017]
+ * Copyright (c) 2015,2017 Glenn Randers-Pehrson
+ * Written by John Cunningham Bowler
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * NOTES:
+ *   This is a C program that is intended to be linked against libpng.  It
+ *   allows the libpng unknown handling code to be tested by interpreting
+ *   arguments to save or discard combinations of chunks.  The program is
+ *   currently just a minimal validation for the built-in libpng facilities.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <setjmp.h>
+
+/* Define the following to use this test against your installed libpng, rather
+ * than the one being built here:
+ */
+#ifdef PNG_FREESTANDING_TESTS
+#  include <png.h>
+#else
+#  include "../../png.h"
+#endif
+
+/* 1.6.1 added support for the configure test harness, which uses 77 to indicate
+ * a skipped test, in earlier versions we need to succeed on a skipped test, so:
+ */
+#if PNG_LIBPNG_VER >= 10601 && defined(HAVE_CONFIG_H)
+#  define SKIP 77
+#else
+#  define SKIP 0
+#endif
+
+
+/* Since this program tests the ability to change the unknown chunk handling
+ * these must be defined:
+ */
+#if defined(PNG_SET_UNKNOWN_CHUNKS_SUPPORTED) &&\
+   defined(PNG_STDIO_SUPPORTED) &&\
+   defined(PNG_READ_SUPPORTED)
+
+/* One of these must be defined to allow us to find out what happened.  It is
+ * still useful to set unknown chunk handling without either of these in order
+ * to cause *known* chunks to be discarded.  This can be a significant
+ * efficiency gain, but it can't really be tested here.
+ */
+#if defined(PNG_READ_USER_CHUNKS_SUPPORTED) ||\
+   defined(PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED)
+
+#if PNG_LIBPNG_VER < 10500
+/* This deliberately lacks the const. */
+typedef png_byte *png_const_bytep;
+
+/* This is copied from 1.5.1 png.h: */
+#define PNG_INTERLACE_ADAM7_PASSES 7
+#define PNG_PASS_START_ROW(pass) (((1U&~(pass))<<(3-((pass)>>1)))&7)
+#define PNG_PASS_START_COL(pass) (((1U& (pass))<<(3-(((pass)+1)>>1)))&7)
+#define PNG_PASS_ROW_SHIFT(pass) ((pass)>2?(8-(pass))>>1:3)
+#define PNG_PASS_COL_SHIFT(pass) ((pass)>1?(7-(pass))>>1:3)
+#define PNG_PASS_ROWS(height, pass) (((height)+(((1<<PNG_PASS_ROW_SHIFT(pass))\
+   -1)-PNG_PASS_START_ROW(pass)))>>PNG_PASS_ROW_SHIFT(pass))
+#define PNG_PASS_COLS(width, pass) (((width)+(((1<<PNG_PASS_COL_SHIFT(pass))\
+   -1)-PNG_PASS_START_COL(pass)))>>PNG_PASS_COL_SHIFT(pass))
+#define PNG_ROW_FROM_PASS_ROW(yIn, pass) \
+   (((yIn)<<PNG_PASS_ROW_SHIFT(pass))+PNG_PASS_START_ROW(pass))
+#define PNG_COL_FROM_PASS_COL(xIn, pass) \
+   (((xIn)<<PNG_PASS_COL_SHIFT(pass))+PNG_PASS_START_COL(pass))
+#define PNG_PASS_MASK(pass,off) ( \
+   ((0x110145AFU>>(((7-(off))-(pass))<<2)) & 0xFU) | \
+   ((0x01145AF0U>>(((7-(off))-(pass))<<2)) & 0xF0U))
+#define PNG_ROW_IN_INTERLACE_PASS(y, pass) \
+   ((PNG_PASS_MASK(pass,0) >> ((y)&7)) & 1)
+#define PNG_COL_IN_INTERLACE_PASS(x, pass) \
+   ((PNG_PASS_MASK(pass,1) >> ((x)&7)) & 1)
+
+/* These are needed too for the default build: */
+#define PNG_WRITE_16BIT_SUPPORTED
+#define PNG_READ_16BIT_SUPPORTED
+
+/* This comes from pnglibconf.h after 1.5: */
+#define PNG_FP_1 100000
+#define PNG_GAMMA_THRESHOLD_FIXED\
+   ((png_fixed_point)(PNG_GAMMA_THRESHOLD * PNG_FP_1))
+#endif
+
+#if PNG_LIBPNG_VER < 10600
+   /* 1.6.0 constifies many APIs. The following exists to allow pngvalid to be
+    * compiled against earlier versions.
+    */
+#  define png_const_structp png_structp
+#endif
+
+#if PNG_LIBPNG_VER < 10700
+   /* Copied from libpng 1.7.0 png.h */
+#define PNG_u2(b1, b2) (((unsigned int)(b1) << 8) + (b2))
+
+#define PNG_U16(b1, b2) ((png_uint_16)PNG_u2(b1, b2))
+#define PNG_U32(b1, b2, b3, b4)\
+   (((png_uint_32)PNG_u2(b1, b2) << 16) + PNG_u2(b3, b4))
+
+/* Constants for known chunk types.
+ */
+#define png_IDAT PNG_U32( 73,  68,  65,  84)
+#define png_IEND PNG_U32( 73,  69,  78,  68)
+#define png_IHDR PNG_U32( 73,  72,  68,  82)
+#define png_PLTE PNG_U32( 80,  76,  84,  69)
+#define png_bKGD PNG_U32( 98,  75,  71,  68)
+#define png_cHRM PNG_U32( 99,  72,  82,  77)
+#define png_eXIf PNG_U32(101,  88,  73, 102) /* registered July 2017 */
+#define png_fRAc PNG_U32(102,  82,  65,  99) /* registered, not defined */
+#define png_gAMA PNG_U32(103,  65,  77,  65)
+#define png_gIFg PNG_U32(103,  73,  70, 103)
+#define png_gIFt PNG_U32(103,  73,  70, 116) /* deprecated */
+#define png_gIFx PNG_U32(103,  73,  70, 120)
+#define png_hIST PNG_U32(104,  73,  83,  84)
+#define png_iCCP PNG_U32(105,  67,  67,  80)
+#define png_iTXt PNG_U32(105,  84,  88, 116)
+#define png_oFFs PNG_U32(111,  70,  70, 115)
+#define png_pCAL PNG_U32(112,  67,  65,  76)
+#define png_pHYs PNG_U32(112,  72,  89, 115)
+#define png_sBIT PNG_U32(115,  66,  73,  84)
+#define png_sCAL PNG_U32(115,  67,  65,  76)
+#define png_sPLT PNG_U32(115,  80,  76,  84)
+#define png_sRGB PNG_U32(115,  82,  71,  66)
+#define png_sTER PNG_U32(115,  84,  69,  82)
+#define png_tEXt PNG_U32(116,  69,  88, 116)
+#define png_tIME PNG_U32(116,  73,  77,  69)
+#define png_tRNS PNG_U32(116,  82,  78,  83)
+#define png_zTXt PNG_U32(122,  84,  88, 116)
+
+/* Test on flag values as defined in the spec (section 5.4): */
+#define PNG_CHUNK_ANCILLARY(c)    (1 & ((c) >> 29))
+#define PNG_CHUNK_CRITICAL(c)     (!PNG_CHUNK_ANCILLARY(c))
+#define PNG_CHUNK_PRIVATE(c)      (1 & ((c) >> 21))
+#define PNG_CHUNK_RESERVED(c)     (1 & ((c) >> 13))
+#define PNG_CHUNK_SAFE_TO_COPY(c) (1 & ((c) >>  5))
+
+#endif /* PNG_LIBPNG_VER < 10700 */
+
+#ifdef __cplusplus
+#  define this not_the_cpp_this
+#  define new not_the_cpp_new
+#  define voidcast(type, value) static_cast<type>(value)
+#else
+#  define voidcast(type, value) (value)
+#endif /* __cplusplus */
+
+/* Unused formal parameter errors are removed using the following macro which is
+ * expected to have no bad effects on performance.
+ */
+#ifndef UNUSED
+#  if defined(__GNUC__) || defined(_MSC_VER)
+#     define UNUSED(param) (void)param;
+#  else
+#     define UNUSED(param)
+#  endif
+#endif
+
+/* Types of chunks not known to libpng */
+#define png_vpAg PNG_U32(118, 112, 65, 103)
+
+/* Chunk information */
+#define PNG_INFO_tEXt 0x10000000U
+#define PNG_INFO_iTXt 0x20000000U
+#define PNG_INFO_zTXt 0x40000000U
+
+#define PNG_INFO_sTER 0x01000000U
+#define PNG_INFO_vpAg 0x02000000U
+
+#define ABSENT  0
+#define START   1
+#define END     2
+
+static struct
+{
+   char        name[5];
+   png_uint_32 flag;
+   png_uint_32 tag;
+   int         unknown;    /* Chunk not known to libpng */
+   int         all;        /* Chunk set by the '-1' option */
+   int         position;   /* position in pngtest.png */
+   int         keep;       /* unknown handling setting */
+} chunk_info[] = {
+   /* Critical chunks */
+   { "IDAT", PNG_INFO_IDAT, png_IDAT, 0, 0,  START, 0 }, /* must be [0] */
+   { "PLTE", PNG_INFO_PLTE, png_PLTE, 0, 0, ABSENT, 0 },
+
+   /* Non-critical chunks that libpng handles */
+   /* This is a mess but it seems to be the only way to do it - there is no way
+    * to check for a definition outside a #if.
+    */
+   { "bKGD", PNG_INFO_bKGD, png_bKGD,
+#     ifdef PNG_READ_bKGD_SUPPORTED
+         0,
+#     else
+         1,
+#     endif
+      1,  START, 0 },
+   { "cHRM", PNG_INFO_cHRM, png_cHRM,
+#     ifdef PNG_READ_cHRM_SUPPORTED
+         0,
+#     else
+         1,
+#     endif
+      1,  START, 0 },
+   { "eXIf", PNG_INFO_eXIf, png_eXIf,
+#     ifdef PNG_READ_eXIf_SUPPORTED
+         0,
+#     else
+         1,
+#     endif
+      1,  END, 0 },
+   { "gAMA", PNG_INFO_gAMA, png_gAMA,
+#     ifdef PNG_READ_gAMA_SUPPORTED
+         0,
+#     else
+         1,
+#     endif
+      1,  START, 0 },
+   { "hIST", PNG_INFO_hIST, png_hIST,
+#     ifdef PNG_READ_hIST_SUPPORTED
+         0,
+#     else
+         1,
+#     endif
+      1, ABSENT, 0 },
+   { "iCCP", PNG_INFO_iCCP, png_iCCP,
+#     ifdef PNG_READ_iCCP_SUPPORTED
+         0,
+#     else
+         1,
+#     endif
+      1, ABSENT, 0 },
+   { "iTXt", PNG_INFO_iTXt, png_iTXt,
+#     ifdef PNG_READ_iTXt_SUPPORTED
+         0,
+#     else
+         1,
+#     endif
+      1, ABSENT, 0 },
+   { "oFFs", PNG_INFO_oFFs, png_oFFs,
+#     ifdef PNG_READ_oFFs_SUPPORTED
+         0,
+#     else
+         1,
+#     endif
+      1,  START, 0 },
+   { "pCAL", PNG_INFO_pCAL, png_pCAL,
+#     ifdef PNG_READ_pCAL_SUPPORTED
+         0,
+#     else
+         1,
+#     endif
+      1,  START, 0 },
+   { "pHYs", PNG_INFO_pHYs, png_pHYs,
+#     ifdef PNG_READ_pHYs_SUPPORTED
+         0,
+#     else
+         1,
+#     endif
+      1,  START, 0 },
+   { "sBIT", PNG_INFO_sBIT, png_sBIT,
+#     ifdef PNG_READ_sBIT_SUPPORTED
+         0,
+#     else
+         1,
+#     endif
+      1,  START, 0 },
+   { "sCAL", PNG_INFO_sCAL, png_sCAL,
+#     ifdef PNG_READ_sCAL_SUPPORTED
+         0,
+#     else
+         1,
+#     endif
+      1,  START, 0 },
+   { "sPLT", PNG_INFO_sPLT, png_sPLT,
+#     ifdef PNG_READ_sPLT_SUPPORTED
+         0,
+#     else
+         1,
+#     endif
+      1, ABSENT, 0 },
+   { "sRGB", PNG_INFO_sRGB, png_sRGB,
+#     ifdef PNG_READ_sRGB_SUPPORTED
+         0,
+#     else
+         1,
+#     endif
+      1,  START, 0 },
+   { "tEXt", PNG_INFO_tEXt, png_tEXt,
+#     ifdef PNG_READ_tEXt_SUPPORTED
+         0,
+#     else
+         1,
+#     endif
+      1,  START, 0 },
+   { "tIME", PNG_INFO_tIME, png_tIME,
+#     ifdef PNG_READ_tIME_SUPPORTED
+         0,
+#     else
+         1,
+#     endif
+      1,  START, 0 },
+   { "tRNS", PNG_INFO_tRNS, png_tRNS,
+#     ifdef PNG_READ_tRNS_SUPPORTED
+         0,
+#     else
+         1,
+#     endif
+      0, ABSENT, 0 },
+   { "zTXt", PNG_INFO_zTXt, png_zTXt,
+#     ifdef PNG_READ_zTXt_SUPPORTED
+         0,
+#     else
+         1,
+#     endif
+      1,    END, 0 },
+
+   /* No libpng handling */
+   { "sTER", PNG_INFO_sTER, png_sTER, 1, 1,  START, 0 },
+   { "vpAg", PNG_INFO_vpAg, png_vpAg, 1, 0,  START, 0 },
+};
+
+#define NINFO ((int)((sizeof chunk_info)/(sizeof chunk_info[0])))
+
+static void
+clear_keep(void)
+{
+   int i = NINFO;
+   while (--i >= 0)
+      chunk_info[i].keep = 0;
+}
+
+static int
+find(const char *name)
+{
+   int i = NINFO;
+   while (--i >= 0)
+   {
+      if (memcmp(chunk_info[i].name, name, 4) == 0)
+         break;
+   }
+
+   return i;
+}
+
+static int
+findb(const png_byte *name)
+{
+   int i = NINFO;
+   while (--i >= 0)
+   {
+      if (memcmp(chunk_info[i].name, name, 4) == 0)
+         break;
+   }
+
+   return i;
+}
+
+static int
+find_by_flag(png_uint_32 flag)
+{
+   int i = NINFO;
+
+   while (--i >= 0) if (chunk_info[i].flag == flag) return i;
+
+   fprintf(stderr, "pngunknown: internal error\n");
+   exit(4);
+}
+
+static int
+ancillary(const char *name)
+{
+   return PNG_CHUNK_ANCILLARY(PNG_U32(name[0], name[1], name[2], name[3]));
+}
+
+#ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
+static int
+ancillaryb(const png_byte *name)
+{
+   return PNG_CHUNK_ANCILLARY(PNG_U32(name[0], name[1], name[2], name[3]));
+}
+#endif
+
+/* Type of an error_ptr */
+typedef struct
+{
+   jmp_buf     error_return;
+   png_structp png_ptr;
+   png_infop   info_ptr, end_ptr;
+   png_uint_32 before_IDAT;
+   png_uint_32 after_IDAT;
+   int         error_count;
+   int         warning_count;
+   int         keep; /* the default value */
+   const char *program;
+   const char *file;
+   const char *test;
+} display;
+
+static const char init[] = "initialization";
+static const char cmd[] = "command line";
+
+static void
+init_display(display *d, const char *program)
+{
+   memset(d, 0, sizeof *d);
+   d->png_ptr = NULL;
+   d->info_ptr = d->end_ptr = NULL;
+   d->error_count = d->warning_count = 0;
+   d->program = program;
+   d->file = program;
+   d->test = init;
+}
+
+static void
+clean_display(display *d)
+{
+   png_destroy_read_struct(&d->png_ptr, &d->info_ptr, &d->end_ptr);
+
+   /* This must not happen - it might cause an app crash */
+   if (d->png_ptr != NULL || d->info_ptr != NULL || d->end_ptr != NULL)
+   {
+      fprintf(stderr, "%s(%s): png_destroy_read_struct error\n", d->file,
+         d->test);
+      exit(1);
+   }
+}
+
+PNG_FUNCTION(void, display_exit, (display *d), static PNG_NORETURN)
+{
+   ++(d->error_count);
+
+   if (d->png_ptr != NULL)
+      clean_display(d);
+
+   /* During initialization and if this is a single command line argument set
+    * exit now - there is only one test, otherwise longjmp to do the next test.
+    */
+   if (d->test == init || d->test == cmd)
+      exit(1);
+
+   longjmp(d->error_return, 1);
+}
+
+static int
+display_rc(const display *d, int strict)
+{
+   return d->error_count + (strict ? d->warning_count : 0);
+}
+
+/* libpng error and warning callbacks */
+PNG_FUNCTION(void, (PNGCBAPI error), (png_structp png_ptr, const char *message),
+   static PNG_NORETURN)
+{
+   display *d = (display*)png_get_error_ptr(png_ptr);
+
+   fprintf(stderr, "%s(%s): libpng error: %s\n", d->file, d->test, message);
+   display_exit(d);
+}
+
+static void PNGCBAPI
+warning(png_structp png_ptr, const char *message)
+{
+   display *d = (display*)png_get_error_ptr(png_ptr);
+
+   fprintf(stderr, "%s(%s): libpng warning: %s\n", d->file, d->test, message);
+   ++(d->warning_count);
+}
+
+static png_uint_32
+get_valid(display *d, png_infop info_ptr)
+{
+   png_uint_32 flags = png_get_valid(d->png_ptr, info_ptr, (png_uint_32)~0);
+
+   /* Map the text chunks back into the flags */
+   {
+      png_textp text;
+      png_uint_32 ntext = png_get_text(d->png_ptr, info_ptr, &text, NULL);
+
+      while (ntext > 0) switch (text[--ntext].compression)
+      {
+         case -1:
+            flags |= PNG_INFO_tEXt;
+            break;
+         case 0:
+            flags |= PNG_INFO_zTXt;
+            break;
+         case 1:
+         case 2:
+            flags |= PNG_INFO_iTXt;
+            break;
+         default:
+            fprintf(stderr, "%s(%s): unknown text compression %d\n", d->file,
+               d->test, text[ntext].compression);
+            display_exit(d);
+      }
+   }
+
+   return flags;
+}
+
+#ifdef PNG_READ_USER_CHUNKS_SUPPORTED
+static int PNGCBAPI
+read_callback(png_structp pp, png_unknown_chunkp pc)
+{
+   /* This function mimics the behavior of png_set_keep_unknown_chunks by
+    * returning '0' to keep the chunk and '1' to discard it.
+    */
+   display *d = voidcast(display*, png_get_user_chunk_ptr(pp));
+   int chunk = findb(pc->name);
+   int keep, discard;
+
+   if (chunk < 0) /* not one in our list, so not a known chunk */
+      keep = d->keep;
+
+   else
+   {
+      keep = chunk_info[chunk].keep;
+      if (keep == PNG_HANDLE_CHUNK_AS_DEFAULT)
+      {
+         /* See the comments in png.h - use the default for unknown chunks,
+          * do not keep known chunks.
+          */
+         if (chunk_info[chunk].unknown)
+            keep = d->keep;
+
+         else
+            keep = PNG_HANDLE_CHUNK_NEVER;
+      }
+   }
+
+   switch (keep)
+   {
+      default:
+         fprintf(stderr, "%s(%s): %d: unrecognized chunk option\n", d->file,
+            d->test, chunk_info[chunk].keep);
+         display_exit(d);
+
+      case PNG_HANDLE_CHUNK_AS_DEFAULT:
+      case PNG_HANDLE_CHUNK_NEVER:
+         discard = 1/*handled; discard*/;
+         break;
+
+      case PNG_HANDLE_CHUNK_IF_SAFE:
+      case PNG_HANDLE_CHUNK_ALWAYS:
+         discard = 0/*not handled; keep*/;
+         break;
+   }
+
+   /* Also store information about this chunk in the display, the relevant flag
+    * is set if the chunk is to be kept ('not handled'.)
+    */
+   if (chunk >= 0) if (!discard) /* stupidity to stop a GCC warning */
+   {
+      png_uint_32 flag = chunk_info[chunk].flag;
+
+      if (pc->location & PNG_AFTER_IDAT)
+         d->after_IDAT |= flag;
+
+      else
+         d->before_IDAT |= flag;
+   }
+
+   /* However if there is no support to store unknown chunks don't ask libpng to
+    * do it; there will be an png_error.
+    */
+#  ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
+      return discard;
+#  else
+      return 1; /*handled; discard*/
+#  endif
+}
+#endif /* READ_USER_CHUNKS_SUPPORTED */
+
+#ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
+static png_uint_32
+get_unknown(display *d, png_infop info_ptr, int after_IDAT)
+{
+   /* Create corresponding 'unknown' flags */
+   png_uint_32 flags = 0;
+
+   UNUSED(after_IDAT)
+
+   {
+      png_unknown_chunkp unknown;
+      int num_unknown = png_get_unknown_chunks(d->png_ptr, info_ptr, &unknown);
+
+      while (--num_unknown >= 0)
+      {
+         int chunk = findb(unknown[num_unknown].name);
+
+         /* Chunks not known to pngunknown must be validated here; since they
+          * must also be unknown to libpng the 'display->keep' behavior should
+          * have been used.
+          */
+         if (chunk < 0) switch (d->keep)
+         {
+            default: /* impossible */
+            case PNG_HANDLE_CHUNK_AS_DEFAULT:
+            case PNG_HANDLE_CHUNK_NEVER:
+               fprintf(stderr, "%s(%s): %s: %s: unknown chunk saved\n",
+                  d->file, d->test, d->keep ? "discard" : "default",
+                  unknown[num_unknown].name);
+               ++(d->error_count);
+               break;
+
+            case PNG_HANDLE_CHUNK_IF_SAFE:
+               if (!ancillaryb(unknown[num_unknown].name))
+               {
+                  fprintf(stderr,
+                     "%s(%s): if-safe: %s: unknown critical chunk saved\n",
+                     d->file, d->test, unknown[num_unknown].name);
+                  ++(d->error_count);
+                  break;
+               }
+               /* FALLTHROUGH */ /* (safe) */
+            case PNG_HANDLE_CHUNK_ALWAYS:
+               break;
+         }
+
+         else
+            flags |= chunk_info[chunk].flag;
+      }
+   }
+
+   return flags;
+}
+#else /* SAVE_UNKNOWN_CHUNKS */
+static png_uint_32
+get_unknown(display *d, png_infop info_ptr, int after_IDAT)
+   /* Otherwise this will return the cached values set by any user callback */
+{
+   UNUSED(info_ptr);
+
+   if (after_IDAT)
+      return d->after_IDAT;
+
+   else
+      return d->before_IDAT;
+}
+
+#  ifndef PNG_READ_USER_CHUNKS_SUPPORTED
+      /* The #defines above should mean this is never reached, it's just here as
+       * a check to ensure the logic is correct.
+       */
+#     error No store support and no user chunk support, this will not work
+#  endif /* READ_USER_CHUNKS */
+#endif /* SAVE_UNKNOWN_CHUNKS */
+
+static int
+check(FILE *fp, int argc, const char **argv, png_uint_32p flags/*out*/,
+   display *d, int set_callback)
+{
+   int i, npasses, ipass;
+   png_uint_32 height;
+
+   d->keep = PNG_HANDLE_CHUNK_AS_DEFAULT;
+   d->before_IDAT = 0;
+   d->after_IDAT = 0;
+
+   /* Some of these errors are permanently fatal and cause an exit here, others
+    * are per-test and cause an error return.
+    */
+   d->png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, d, error,
+      warning);
+   if (d->png_ptr == NULL)
+   {
+      fprintf(stderr, "%s(%s): could not allocate png struct\n", d->file,
+         d->test);
+      /* Terminate here, this error is not test specific. */
+      exit(1);
+   }
+
+   d->info_ptr = png_create_info_struct(d->png_ptr);
+   d->end_ptr = png_create_info_struct(d->png_ptr);
+   if (d->info_ptr == NULL || d->end_ptr == NULL)
+   {
+      fprintf(stderr, "%s(%s): could not allocate png info\n", d->file,
+         d->test);
+      clean_display(d);
+      exit(1);
+   }
+
+   png_init_io(d->png_ptr, fp);
+
+#  ifdef PNG_READ_USER_CHUNKS_SUPPORTED
+      /* This is only done if requested by the caller; it interferes with the
+       * standard store/save mechanism.
+       */
+      if (set_callback)
+         png_set_read_user_chunk_fn(d->png_ptr, d, read_callback);
+#  else
+      UNUSED(set_callback)
+#  endif
+
+   /* Handle each argument in turn; multiple settings are possible for the same
+    * chunk and multiple calls will occur (the last one should override all
+    * preceding ones).
+    */
+   for (i=0; i<argc; ++i)
+   {
+      const char *equals = strchr(argv[i], '=');
+
+      if (equals != NULL)
+      {
+         int chunk, option;
+
+         if (strcmp(equals+1, "default") == 0)
+            option = PNG_HANDLE_CHUNK_AS_DEFAULT;
+         else if (strcmp(equals+1, "discard") == 0)
+            option = PNG_HANDLE_CHUNK_NEVER;
+         else if (strcmp(equals+1, "if-safe") == 0)
+            option = PNG_HANDLE_CHUNK_IF_SAFE;
+         else if (strcmp(equals+1, "save") == 0)
+            option = PNG_HANDLE_CHUNK_ALWAYS;
+         else
+         {
+            fprintf(stderr, "%s(%s): %s: unrecognized chunk option\n", d->file,
+               d->test, argv[i]);
+            display_exit(d);
+         }
+
+         switch (equals - argv[i])
+         {
+            case 4: /* chunk name */
+               chunk = find(argv[i]);
+
+               if (chunk >= 0)
+               {
+                  /* These #if tests have the effect of skipping the arguments
+                   * if SAVE support is unavailable - we can't do a useful test
+                   * in this case, so we just check the arguments!  This could
+                   * be improved in the future by using the read callback.
+                   */
+#                 if PNG_LIBPNG_VER >= 10700 &&\
+                     !defined(PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED)
+                     if (option < PNG_HANDLE_CHUNK_IF_SAFE)
+#                 endif /* 1.7+ SAVE_UNKNOWN_CHUNKS */
+                  {
+                     png_byte name[5];
+
+                     memcpy(name, chunk_info[chunk].name, 5);
+                     png_set_keep_unknown_chunks(d->png_ptr, option, name, 1);
+                     chunk_info[chunk].keep = option;
+                  }
+                  continue;
+               }
+
+               break;
+
+            case 7: /* default */
+               if (memcmp(argv[i], "default", 7) == 0)
+               {
+#                 if PNG_LIBPNG_VER >= 10700 &&\
+                     !defined(PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED)
+                     if (option < PNG_HANDLE_CHUNK_IF_SAFE)
+#                 endif /* 1.7+ SAVE_UNKNOWN_CHUNKS */
+                     png_set_keep_unknown_chunks(d->png_ptr, option, NULL, 0);
+
+                  d->keep = option;
+                  continue;
+               }
+
+               break;
+
+            case 3: /* all */
+               if (memcmp(argv[i], "all", 3) == 0)
+               {
+#                 if PNG_LIBPNG_VER >= 10700 &&\
+                     !defined(PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED)
+                     if (option < PNG_HANDLE_CHUNK_IF_SAFE)
+#                 endif /* 1.7+ SAVE_UNKNOWN_CHUNKS */
+                     png_set_keep_unknown_chunks(d->png_ptr, option, NULL, -1);
+
+                  d->keep = option;
+
+                  for (chunk = 0; chunk < NINFO; ++chunk)
+                     if (chunk_info[chunk].all)
+                        chunk_info[chunk].keep = option;
+                  continue;
+               }
+
+               break;
+
+            default: /* some misplaced = */
+
+               break;
+         }
+      }
+
+      fprintf(stderr, "%s(%s): %s: unrecognized chunk argument\n", d->file,
+         d->test, argv[i]);
+      display_exit(d);
+   }
+
+   png_read_info(d->png_ptr, d->info_ptr);
+
+   switch (png_get_interlace_type(d->png_ptr, d->info_ptr))
+   {
+      case PNG_INTERLACE_NONE:
+         npasses = 1;
+         break;
+
+      case PNG_INTERLACE_ADAM7:
+         npasses = PNG_INTERLACE_ADAM7_PASSES;
+         break;
+
+      default:
+         /* Hard error because it is not test specific */
+         fprintf(stderr, "%s(%s): invalid interlace type\n", d->file, d->test);
+         clean_display(d);
+         exit(1);
+   }
+
+   /* Skip the image data, if IDAT is not being handled then don't do this
+    * because it will cause a CRC error.
+    */
+   if (chunk_info[0/*IDAT*/].keep == PNG_HANDLE_CHUNK_AS_DEFAULT)
+   {
+      png_start_read_image(d->png_ptr);
+      height = png_get_image_height(d->png_ptr, d->info_ptr);
+
+      if (npasses > 1)
+      {
+         png_uint_32 width = png_get_image_width(d->png_ptr, d->info_ptr);
+
+         for (ipass=0; ipass<npasses; ++ipass)
+         {
+            png_uint_32 wPass = PNG_PASS_COLS(width, ipass);
+
+            if (wPass > 0)
+            {
+               png_uint_32 y;
+
+               for (y=0; y<height; ++y) if (PNG_ROW_IN_INTERLACE_PASS(y, ipass))
+                  png_read_row(d->png_ptr, NULL, NULL);
+            }
+         }
+      } /* interlaced */
+
+      else /* not interlaced */
+      {
+         png_uint_32 y;
+
+         for (y=0; y<height; ++y)
+            png_read_row(d->png_ptr, NULL, NULL);
+      }
+   }
+
+   png_read_end(d->png_ptr, d->end_ptr);
+
+   flags[0] = get_valid(d, d->info_ptr);
+   flags[1] = get_unknown(d, d->info_ptr, 0/*before IDAT*/);
+
+   /* Only png_read_png sets PNG_INFO_IDAT! */
+   flags[chunk_info[0/*IDAT*/].keep != PNG_HANDLE_CHUNK_AS_DEFAULT] |=
+      PNG_INFO_IDAT;
+
+   flags[2] = get_valid(d, d->end_ptr);
+   flags[3] = get_unknown(d, d->end_ptr, 1/*after IDAT*/);
+
+   clean_display(d);
+
+   return d->keep;
+}
+
+static void
+check_error(display *d, png_uint_32 flags, const char *message)
+{
+   while (flags)
+   {
+      png_uint_32 flag = flags & -(png_int_32)flags;
+      int i = find_by_flag(flag);
+
+      fprintf(stderr, "%s(%s): chunk %s: %s\n", d->file, d->test,
+         chunk_info[i].name, message);
+      ++(d->error_count);
+
+      flags &= ~flag;
+   }
+}
+
+static void
+check_handling(display *d, int def, png_uint_32 chunks, png_uint_32 known,
+   png_uint_32 unknown, const char *position, int set_callback)
+{
+   while (chunks)
+   {
+      png_uint_32 flag = chunks & -(png_int_32)chunks;
+      int i = find_by_flag(flag);
+      int keep = chunk_info[i].keep;
+      const char *type;
+      const char *errorx = NULL;
+
+      if (chunk_info[i].unknown)
+      {
+         if (keep == PNG_HANDLE_CHUNK_AS_DEFAULT)
+         {
+            type = "UNKNOWN (default)";
+            keep = def;
+         }
+
+         else
+            type = "UNKNOWN (specified)";
+
+         if (flag & known)
+            errorx = "chunk processed";
+
+         else switch (keep)
+         {
+            case PNG_HANDLE_CHUNK_AS_DEFAULT:
+               if (flag & unknown)
+                  errorx = "DEFAULT: unknown chunk saved";
+               break;
+
+            case PNG_HANDLE_CHUNK_NEVER:
+               if (flag & unknown)
+                  errorx = "DISCARD: unknown chunk saved";
+               break;
+
+            case PNG_HANDLE_CHUNK_IF_SAFE:
+               if (ancillary(chunk_info[i].name))
+               {
+                  if (!(flag & unknown))
+                     errorx = "IF-SAFE: unknown ancillary chunk lost";
+               }
+
+               else if (flag & unknown)
+                  errorx = "IF-SAFE: unknown critical chunk saved";
+               break;
+
+            case PNG_HANDLE_CHUNK_ALWAYS:
+               if (!(flag & unknown))
+                  errorx = "SAVE: unknown chunk lost";
+               break;
+
+            default:
+               errorx = "internal error: bad keep";
+               break;
+         }
+      } /* unknown chunk */
+
+      else /* known chunk */
+      {
+         type = "KNOWN";
+
+         if (flag & known)
+         {
+            /* chunk was processed, it won't have been saved because that is
+             * caught below when checking for inconsistent processing.
+             */
+            if (keep != PNG_HANDLE_CHUNK_AS_DEFAULT)
+               errorx = "!DEFAULT: known chunk processed";
+         }
+
+         else /* not processed */ switch (keep)
+         {
+            case PNG_HANDLE_CHUNK_AS_DEFAULT:
+               errorx = "DEFAULT: known chunk not processed";
+               break;
+
+            case PNG_HANDLE_CHUNK_NEVER:
+               if (flag & unknown)
+                  errorx = "DISCARD: known chunk saved";
+               break;
+
+            case PNG_HANDLE_CHUNK_IF_SAFE:
+               if (ancillary(chunk_info[i].name))
+               {
+                  if (!(flag & unknown))
+                     errorx = "IF-SAFE: known ancillary chunk lost";
+               }
+
+               else if (flag & unknown)
+                  errorx = "IF-SAFE: known critical chunk saved";
+               break;
+
+            case PNG_HANDLE_CHUNK_ALWAYS:
+               if (!(flag & unknown))
+                  errorx = "SAVE: known chunk lost";
+               break;
+
+            default:
+               errorx = "internal error: bad keep (2)";
+               break;
+         }
+      }
+
+      if (errorx != NULL)
+      {
+         ++(d->error_count);
+         fprintf(stderr, "%s(%s%s): %s %s %s: %s\n", d->file, d->test,
+            set_callback ? ",callback" : "",
+            type, chunk_info[i].name, position, errorx);
+      }
+
+      chunks &= ~flag;
+   }
+}
+
+static void
+perform_one_test(FILE *fp, int argc, const char **argv,
+   png_uint_32 *default_flags, display *d, int set_callback)
+{
+   int def;
+   png_uint_32 flags[2][4];
+
+   rewind(fp);
+   clear_keep();
+   memcpy(flags[0], default_flags, sizeof flags[0]);
+
+   def = check(fp, argc, argv, flags[1], d, set_callback);
+
+   /* If IDAT is being handled as unknown the image read is skipped and all the
+    * IDATs after the first end up in the end info struct, so in this case add
+    * IDAT to the list of unknowns.  (Do this after 'check' above sets the
+    * chunk_info 'keep' fields.)
+    *
+    * Note that the flag setting has to be in the 'known' field to avoid
+    * triggering the consistency check below and the flag must only be set if
+    * there are multiple IDATs, so if the check above did find an unknown IDAT
+    * after IDAT.
+    */
+   if (chunk_info[0/*IDAT*/].keep != PNG_HANDLE_CHUNK_AS_DEFAULT &&
+       (flags[1][3] & PNG_INFO_IDAT) != 0)
+      flags[0][2] |= PNG_INFO_IDAT;
+
+   /* Chunks should either be known or unknown, never both and this should apply
+    * whether the chunk is before or after the IDAT (actually, the app can
+    * probably change this by swapping the handling after the image, but this
+    * test does not do that.)
+    */
+   check_error(d, (flags[0][0]|flags[0][2]) & (flags[0][1]|flags[0][3]),
+      "chunk handled inconsistently in count tests");
+   check_error(d, (flags[1][0]|flags[1][2]) & (flags[1][1]|flags[1][3]),
+      "chunk handled inconsistently in option tests");
+
+   /* Now find out what happened to each chunk before and after the IDAT and
+    * determine if the behavior was correct.  First some basic sanity checks,
+    * any known chunk should be known in the original count, any unknown chunk
+    * should be either known or unknown in the original.
+    */
+   {
+      png_uint_32 test;
+
+      test = flags[1][0] & ~flags[0][0];
+      check_error(d, test, "new known chunk before IDAT");
+      test = flags[1][1] & ~(flags[0][0] | flags[0][1]);
+      check_error(d, test, "new unknown chunk before IDAT");
+      test = flags[1][2] & ~flags[0][2];
+      check_error(d, test, "new known chunk after IDAT");
+      test = flags[1][3] & ~(flags[0][2] | flags[0][3]);
+      check_error(d, test, "new unknown chunk after IDAT");
+   }
+
+   /* Now each chunk in the original list should have been handled according to
+    * the options set for that chunk, regardless of whether libpng knows about
+    * it or not.
+    */
+   check_handling(d, def, flags[0][0] | flags[0][1], flags[1][0], flags[1][1],
+      "before IDAT", set_callback);
+   check_handling(d, def, flags[0][2] | flags[0][3], flags[1][2], flags[1][3],
+      "after IDAT", set_callback);
+}
+
+static void
+perform_one_test_safe(FILE *fp, int argc, const char **argv,
+   png_uint_32 *default_flags, display *d, const char *test)
+{
+   if (setjmp(d->error_return) == 0)
+   {
+      d->test = test; /* allow use of d->error_return */
+#     ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
+         perform_one_test(fp, argc, argv, default_flags, d, 0);
+#     endif
+#     ifdef PNG_READ_USER_CHUNKS_SUPPORTED
+         perform_one_test(fp, argc, argv, default_flags, d, 1);
+#     endif
+      d->test = init; /* prevent use of d->error_return */
+   }
+}
+
+static const char *standard_tests[] =
+{
+ "discard", "default=discard", 0,
+ "save", "default=save", 0,
+ "if-safe", "default=if-safe", 0,
+ "vpAg", "vpAg=if-safe", 0,
+ "sTER", "sTER=if-safe", 0,
+ "IDAT", "default=discard", "IDAT=save", 0,
+ "sAPI", "bKGD=save", "cHRM=save", "gAMA=save", "all=discard", "iCCP=save",
+   "sBIT=save", "sRGB=save", "eXIf=save", 0,
+ 0/*end*/
+};
+
+static PNG_NORETURN void
+usage(const char *program, const char *reason)
+{
+   fprintf(stderr, "pngunknown: %s: usage:\n %s [--strict] "
+      "--default|{(CHNK|default|all)=(default|discard|if-safe|save)} "
+      "testfile.png\n", reason, program);
+   exit(99);
+}
+
+int
+main(int argc, const char **argv)
+{
+   FILE *fp;
+   png_uint_32 default_flags[4/*valid,unknown{before,after}*/];
+   int strict = 0, default_tests = 0;
+   const char *count_argv = "default=save";
+   const char *touch_file = NULL;
+   display d;
+
+   init_display(&d, argv[0]);
+
+   while (++argv, --argc > 0)
+   {
+      if (strcmp(*argv, "--strict") == 0)
+         strict = 1;
+
+      else if (strcmp(*argv, "--default") == 0)
+         default_tests = 1;
+
+      else if (strcmp(*argv, "--touch") == 0)
+      {
+         if (argc > 1)
+            touch_file = *++argv, --argc;
+
+         else
+            usage(d.program, "--touch: missing file name");
+      }
+
+      else
+         break;
+   }
+
+   /* A file name is required, but there should be no other arguments if
+    * --default was specified.
+    */
+   if (argc <= 0)
+      usage(d.program, "missing test file");
+
+   /* GCC BUG: if (default_tests && argc != 1) triggers some weird GCC argc
+    * optimization which causes warnings with -Wstrict-overflow!
+    */
+   else if (default_tests) if (argc != 1)
+      usage(d.program, "extra arguments");
+
+   /* The name of the test file is the last argument; remove it. */
+   d.file = argv[--argc];
+
+   fp = fopen(d.file, "rb");
+   if (fp == NULL)
+   {
+      perror(d.file);
+      exit(99);
+   }
+
+   /* First find all the chunks, known and unknown, in the test file, a failure
+    * here aborts the whole test.
+    *
+    * If 'save' is supported then the normal saving method should happen,
+    * otherwise if 'read' is supported then the read callback will do the
+    * same thing.  If both are supported the 'read' callback won't be
+    * instantiated by default.  If 'save' is *not* supported then a user
+    * callback is required even though we can call png_get_unknown_chunks.
+    */
+   if (check(fp, 1, &count_argv, default_flags, &d,
+#     ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
+         0
+#     else
+         1
+#     endif
+      ) != PNG_HANDLE_CHUNK_ALWAYS)
+   {
+      fprintf(stderr, "%s: %s: internal error\n", d.program, d.file);
+      exit(99);
+   }
+
+   /* Now find what the various supplied options cause to change: */
+   if (!default_tests)
+   {
+      d.test = cmd; /* acts as a flag to say exit, do not longjmp */
+#     ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
+         perform_one_test(fp, argc, argv, default_flags, &d, 0);
+#     endif
+#     ifdef PNG_READ_USER_CHUNKS_SUPPORTED
+         perform_one_test(fp, argc, argv, default_flags, &d, 1);
+#     endif
+      d.test = init;
+   }
+
+   else
+   {
+      const char **test = standard_tests;
+
+      /* Set the exit_test pointer here so we can continue after a libpng error.
+       * NOTE: this leaks memory because the png_struct data from the failing
+       * test is never freed.
+       */
+      while (*test)
+      {
+         const char *this_test = *test++;
+         const char **next = test;
+         int count = display_rc(&d, strict), new_count;
+         const char *result;
+         int arg_count = 0;
+
+         while (*next) ++next, ++arg_count;
+
+         perform_one_test_safe(fp, arg_count, test, default_flags, &d,
+            this_test);
+
+         new_count = display_rc(&d, strict);
+
+         if (new_count == count)
+            result = "PASS";
+
+         else
+            result = "FAIL";
+
+         printf("%s: %s %s\n", result, d.program, this_test);
+
+         test = next+1;
+      }
+   }
+
+   fclose(fp);
+
+   if (display_rc(&d, strict) == 0)
+   {
+      /* Success, touch the success file if appropriate */
+      if (touch_file != NULL)
+      {
+         FILE *fsuccess = fopen(touch_file, "wt");
+
+         if (fsuccess != NULL)
+         {
+            int err = 0;
+            fprintf(fsuccess, "PNG unknown tests succeeded\n");
+            fflush(fsuccess);
+            err = ferror(fsuccess);
+
+            if (fclose(fsuccess) || err)
+            {
+               fprintf(stderr, "%s: write failed\n", touch_file);
+               exit(99);
+            }
+         }
+
+         else
+         {
+            fprintf(stderr, "%s: open failed\n", touch_file);
+            exit(99);
+         }
+      }
+
+      return 0;
+   }
+
+   return 1;
+}
+
+#else /* !(READ_USER_CHUNKS || SAVE_UNKNOWN_CHUNKS) */
+int
+main(void)
+{
+   fprintf(stderr,
+      " test ignored: no support to find out about unknown chunks\n");
+   /* So the test is skipped: */
+   return SKIP;
+}
+#endif /* READ_USER_CHUNKS || SAVE_UNKNOWN_CHUNKS */
+
+#else /* !(SET_UNKNOWN_CHUNKS && READ) */
+int
+main(void)
+{
+   fprintf(stderr,
+      " test ignored: no support to modify unknown chunk handling\n");
+   /* So the test is skipped: */
+   return SKIP;
+}
+#endif /* SET_UNKNOWN_CHUNKS && READ*/
diff --git a/Engine/lib/lpng/contrib/libtests/pngvalid.c b/Engine/lib/lpng/contrib/libtests/pngvalid.c
new file mode 100644
index 000000000..d800110c7
--- /dev/null
+++ b/Engine/lib/lpng/contrib/libtests/pngvalid.c
@@ -0,0 +1,12230 @@
+
+/* pngvalid.c - validate libpng by constructing then reading png files.
+ *
+ * Last changed in libpng 1.6.31 [July 27, 2017]
+ * Copyright (c) 2014-2017 John Cunningham Bowler
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * NOTES:
+ *   This is a C program that is intended to be linked against libpng.  It
+ *   generates bitmaps internally, stores them as PNG files (using the
+ *   sequential write code) then reads them back (using the sequential
+ *   read code) and validates that the result has the correct data.
+ *
+ *   The program can be modified and extended to test the correctness of
+ *   transformations performed by libpng.
+ */
+
+#define _POSIX_SOURCE 1
+#define _ISOC99_SOURCE 1 /* For floating point */
+#define _GNU_SOURCE 1 /* For the floating point exception extension */
+#define _BSD_SOURCE 1 /* For the floating point exception extension */
+
+#include <signal.h>
+#include <stdio.h>
+
+#if defined(HAVE_CONFIG_H) && !defined(PNG_NO_CONFIG_H)
+#  include <config.h>
+#endif
+
+#ifdef HAVE_FEENABLEEXCEPT /* from config.h, if included */
+#  include <fenv.h>
+#endif
+
+#ifndef FE_DIVBYZERO
+#  define FE_DIVBYZERO 0
+#endif
+#ifndef FE_INVALID
+#  define FE_INVALID 0
+#endif
+#ifndef FE_OVERFLOW
+#  define FE_OVERFLOW 0
+#endif
+
+/* Define the following to use this test against your installed libpng, rather
+ * than the one being built here:
+ */
+#ifdef PNG_FREESTANDING_TESTS
+#  include <png.h>
+#else
+#  include "../../png.h"
+#endif
+
+#ifdef PNG_ZLIB_HEADER
+#  include PNG_ZLIB_HEADER
+#else
+#  include <zlib.h>   /* For crc32 */
+#endif
+
+/* 1.6.1 added support for the configure test harness, which uses 77 to indicate
+ * a skipped test, in earlier versions we need to succeed on a skipped test, so:
+ */
+#if PNG_LIBPNG_VER >= 10601 && defined(HAVE_CONFIG_H)
+#  define SKIP 77
+#else
+#  define SKIP 0
+#endif
+
+/* pngvalid requires write support and one of the fixed or floating point APIs.
+ */
+#if defined(PNG_WRITE_SUPPORTED) &&\
+   (defined(PNG_FIXED_POINT_SUPPORTED) || defined(PNG_FLOATING_POINT_SUPPORTED))
+
+#if PNG_LIBPNG_VER < 10500
+/* This deliberately lacks the const. */
+typedef png_byte *png_const_bytep;
+
+/* This is copied from 1.5.1 png.h: */
+#define PNG_INTERLACE_ADAM7_PASSES 7
+#define PNG_PASS_START_ROW(pass) (((1U&~(pass))<<(3-((pass)>>1)))&7)
+#define PNG_PASS_START_COL(pass) (((1U& (pass))<<(3-(((pass)+1)>>1)))&7)
+#define PNG_PASS_ROW_SHIFT(pass) ((pass)>2?(8-(pass))>>1:3)
+#define PNG_PASS_COL_SHIFT(pass) ((pass)>1?(7-(pass))>>1:3)
+#define PNG_PASS_ROWS(height, pass) (((height)+(((1<<PNG_PASS_ROW_SHIFT(pass))\
+   -1)-PNG_PASS_START_ROW(pass)))>>PNG_PASS_ROW_SHIFT(pass))
+#define PNG_PASS_COLS(width, pass) (((width)+(((1<<PNG_PASS_COL_SHIFT(pass))\
+   -1)-PNG_PASS_START_COL(pass)))>>PNG_PASS_COL_SHIFT(pass))
+#define PNG_ROW_FROM_PASS_ROW(yIn, pass) \
+   (((yIn)<<PNG_PASS_ROW_SHIFT(pass))+PNG_PASS_START_ROW(pass))
+#define PNG_COL_FROM_PASS_COL(xIn, pass) \
+   (((xIn)<<PNG_PASS_COL_SHIFT(pass))+PNG_PASS_START_COL(pass))
+#define PNG_PASS_MASK(pass,off) ( \
+   ((0x110145AFU>>(((7-(off))-(pass))<<2)) & 0xFU) | \
+   ((0x01145AF0U>>(((7-(off))-(pass))<<2)) & 0xF0U))
+#define PNG_ROW_IN_INTERLACE_PASS(y, pass) \
+   ((PNG_PASS_MASK(pass,0) >> ((y)&7)) & 1)
+#define PNG_COL_IN_INTERLACE_PASS(x, pass) \
+   ((PNG_PASS_MASK(pass,1) >> ((x)&7)) & 1)
+
+/* These are needed too for the default build: */
+#define PNG_WRITE_16BIT_SUPPORTED
+#define PNG_READ_16BIT_SUPPORTED
+
+/* This comes from pnglibconf.h after 1.5: */
+#define PNG_FP_1 100000
+#define PNG_GAMMA_THRESHOLD_FIXED\
+   ((png_fixed_point)(PNG_GAMMA_THRESHOLD * PNG_FP_1))
+#endif
+
+#if PNG_LIBPNG_VER < 10600
+   /* 1.6.0 constifies many APIs, the following exists to allow pngvalid to be
+    * compiled against earlier versions.
+    */
+#  define png_const_structp png_structp
+#endif
+
+#ifndef RELEASE_BUILD
+   /* RELEASE_BUILD is true for releases and release candidates: */
+#  define RELEASE_BUILD (PNG_LIBPNG_BUILD_BASE_TYPE >= PNG_LIBPNG_BUILD_RC)
+#endif
+#if RELEASE_BUILD
+#   define debugonly(something)
+#else /* !RELEASE_BUILD */
+#   define debugonly(something) something
+#endif /* !RELEASE_BUILD */
+
+#include <float.h>  /* For floating point constants */
+#include <stdlib.h> /* For malloc */
+#include <string.h> /* For memcpy, memset */
+#include <math.h>   /* For floor */
+
+/* Convenience macros. */
+#define CHUNK(a,b,c,d) (((a)<<24)+((b)<<16)+((c)<<8)+(d))
+#define CHUNK_IHDR CHUNK(73,72,68,82)
+#define CHUNK_PLTE CHUNK(80,76,84,69)
+#define CHUNK_IDAT CHUNK(73,68,65,84)
+#define CHUNK_IEND CHUNK(73,69,78,68)
+#define CHUNK_cHRM CHUNK(99,72,82,77)
+#define CHUNK_gAMA CHUNK(103,65,77,65)
+#define CHUNK_sBIT CHUNK(115,66,73,84)
+#define CHUNK_sRGB CHUNK(115,82,71,66)
+
+/* Unused formal parameter errors are removed using the following macro which is
+ * expected to have no bad effects on performance.
+ */
+#ifndef UNUSED
+#  if defined(__GNUC__) || defined(_MSC_VER)
+#     define UNUSED(param) (void)param;
+#  else
+#     define UNUSED(param)
+#  endif
+#endif
+
+/***************************** EXCEPTION HANDLING *****************************/
+#ifdef PNG_FREESTANDING_TESTS
+#  include <cexcept.h>
+#else
+#  include "../visupng/cexcept.h"
+#endif
+
+#ifdef __cplusplus
+#  define this not_the_cpp_this
+#  define new not_the_cpp_new
+#  define voidcast(type, value) static_cast<type>(value)
+#else
+#  define voidcast(type, value) (value)
+#endif /* __cplusplus */
+
+struct png_store;
+define_exception_type(struct png_store*);
+
+/* The following are macros to reduce typing everywhere where the well known
+ * name 'the_exception_context' must be defined.
+ */
+#define anon_context(ps) struct exception_context *the_exception_context = \
+   &(ps)->exception_context
+#define context(ps,fault) anon_context(ps); png_store *fault
+
+/* This macro returns the number of elements in an array as an (unsigned int),
+ * it is necessary to avoid the inability of certain versions of GCC to use
+ * the value of a compile-time constant when performing range checks.  It must
+ * be passed an array name.
+ */
+#define ARRAY_SIZE(a) ((unsigned int)((sizeof (a))/(sizeof (a)[0])))
+
+/* GCC BUG 66447 (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66447) requires
+ * some broken GCC versions to be fixed up to avoid invalid whining about auto
+ * variables that are *not* changed within the scope of a setjmp being changed.
+ *
+ * Feel free to extend the list of broken versions.
+ */
+#define is_gnu(major,minor)\
+   (defined __GNUC__) && __GNUC__ == (major) && __GNUC_MINOR__ == (minor)
+#define is_gnu_patch(major,minor,patch)\
+   is_gnu(major,minor) && __GNUC_PATCHLEVEL__ == 0
+/* For the moment just do it always; all versions of GCC seem to be broken: */
+#ifdef __GNUC__
+   const void * volatile make_volatile_for_gnu;
+#  define gnu_volatile(x) make_volatile_for_gnu = &x;
+#else /* !GNUC broken versions */
+#  define gnu_volatile(x)
+#endif /* !GNUC broken versions */
+
+/******************************* UTILITIES ************************************/
+/* Error handling is particularly problematic in production code - error
+ * handlers often themselves have bugs which lead to programs that detect
+ * minor errors crashing.  The following functions deal with one very
+ * common class of errors in error handlers - attempting to format error or
+ * warning messages into buffers that are too small.
+ */
+static size_t safecat(char *buffer, size_t bufsize, size_t pos,
+   const char *cat)
+{
+   while (pos < bufsize && cat != NULL && *cat != 0)
+      buffer[pos++] = *cat++;
+
+   if (pos >= bufsize)
+      pos = bufsize-1;
+
+   buffer[pos] = 0;
+   return pos;
+}
+
+static size_t safecatn(char *buffer, size_t bufsize, size_t pos, int n)
+{
+   char number[64];
+   sprintf(number, "%d", n);
+   return safecat(buffer, bufsize, pos, number);
+}
+
+#ifdef PNG_READ_TRANSFORMS_SUPPORTED
+static size_t safecatd(char *buffer, size_t bufsize, size_t pos, double d,
+    int precision)
+{
+   char number[64];
+   sprintf(number, "%.*f", precision, d);
+   return safecat(buffer, bufsize, pos, number);
+}
+#endif
+
+static const char invalid[] = "invalid";
+static const char sep[] = ": ";
+
+static const char *colour_types[8] =
+{
+   "grayscale", invalid, "truecolour", "indexed-colour",
+   "grayscale with alpha", invalid, "truecolour with alpha", invalid
+};
+
+#ifdef PNG_READ_TRANSFORMS_SUPPORTED
+/* Convert a double precision value to fixed point. */
+static png_fixed_point
+fix(double d)
+{
+   d = floor(d * PNG_FP_1 + .5);
+   return (png_fixed_point)d;
+}
+#endif /* PNG_READ_SUPPORTED */
+
+/* Generate random bytes.  This uses a boring repeatable algorithm and it
+ * is implemented here so that it gives the same set of numbers on every
+ * architecture.  It's a linear congruential generator (Knuth or Sedgewick
+ * "Algorithms") but it comes from the 'feedback taps' table in Horowitz and
+ * Hill, "The Art of Electronics" (Pseudo-Random Bit Sequences and Noise
+ * Generation.)
+ */
+static void
+make_random_bytes(png_uint_32* seed, void* pv, size_t size)
+{
+   png_uint_32 u0 = seed[0], u1 = seed[1];
+   png_bytep bytes = voidcast(png_bytep, pv);
+
+   /* There are thirty three bits, the next bit in the sequence is bit-33 XOR
+    * bit-20.  The top 1 bit is in u1, the bottom 32 are in u0.
+    */
+   size_t i;
+   for (i=0; i<size; ++i)
+   {
+      /* First generate 8 new bits then shift them in at the end. */
+      png_uint_32 u = ((u0 >> (20-8)) ^ ((u1 << 7) | (u0 >> (32-7)))) & 0xff;
+      u1 <<= 8;
+      u1 |= u0 >> 24;
+      u0 <<= 8;
+      u0 |= u;
+      *bytes++ = (png_byte)u;
+   }
+
+   seed[0] = u0;
+   seed[1] = u1;
+}
+
+static void
+make_four_random_bytes(png_uint_32* seed, png_bytep bytes)
+{
+   make_random_bytes(seed, bytes, 4);
+}
+
+#if defined PNG_READ_SUPPORTED || defined PNG_WRITE_tRNS_SUPPORTED ||\
+    defined PNG_WRITE_FILTER_SUPPORTED
+static void
+randomize(void *pv, size_t size)
+{
+   static png_uint_32 random_seed[2] = {0x56789abc, 0xd};
+   make_random_bytes(random_seed, pv, size);
+}
+
+#define R8(this) randomize(&(this), sizeof (this))
+
+#ifdef PNG_READ_SUPPORTED
+static png_byte
+random_byte(void)
+{
+   unsigned char b1[1];
+   randomize(b1, sizeof b1);
+   return b1[0];
+}
+#endif /* READ */
+
+static png_uint_16
+random_u16(void)
+{
+   unsigned char b2[2];
+   randomize(b2, sizeof b2);
+   return png_get_uint_16(b2);
+}
+
+#if defined PNG_READ_RGB_TO_GRAY_SUPPORTED ||\
+    defined PNG_READ_FILLER_SUPPORTED
+static png_uint_32
+random_u32(void)
+{
+   unsigned char b4[4];
+   randomize(b4, sizeof b4);
+   return png_get_uint_32(b4);
+}
+#endif /* READ_FILLER || READ_RGB_TO_GRAY */
+
+#endif /* READ || WRITE_tRNS || WRITE_FILTER */
+
+#if defined PNG_READ_TRANSFORMS_SUPPORTED ||\
+    defined PNG_WRITE_FILTER_SUPPORTED
+static unsigned int
+random_mod(unsigned int max)
+{
+   return random_u16() % max; /* 0 .. max-1 */
+}
+#endif /* READ_TRANSFORMS || WRITE_FILTER */
+
+#if (defined PNG_READ_RGB_TO_GRAY_SUPPORTED) ||\
+    (defined PNG_READ_FILLER_SUPPORTED)
+static int
+random_choice(void)
+{
+   return random_byte() & 1;
+}
+#endif /* READ_RGB_TO_GRAY || READ_FILLER */
+
+/* A numeric ID based on PNG file characteristics.  The 'do_interlace' field
+ * simply records whether pngvalid did the interlace itself or whether it
+ * was done by libpng.  Width and height must be less than 256.  'palette' is an
+ * index of the palette to use for formats with a palette otherwise a boolean
+ * indicating if a tRNS chunk was generated.
+ */
+#define FILEID(col, depth, palette, interlace, width, height, do_interlace) \
+   ((png_uint_32)((col) + ((depth)<<3) + ((palette)<<8) + ((interlace)<<13) + \
+    (((do_interlace)!=0)<<15) + ((width)<<16) + ((height)<<24)))
+
+#define COL_FROM_ID(id) ((png_byte)((id)& 0x7U))
+#define DEPTH_FROM_ID(id) ((png_byte)(((id) >> 3) & 0x1fU))
+#define PALETTE_FROM_ID(id) (((id) >> 8) & 0x1f)
+#define INTERLACE_FROM_ID(id) ((png_byte)(((id) >> 13) & 0x3))
+#define DO_INTERLACE_FROM_ID(id) ((int)(((id)>>15) & 1))
+#define WIDTH_FROM_ID(id) (((id)>>16) & 0xff)
+#define HEIGHT_FROM_ID(id) (((id)>>24) & 0xff)
+
+/* Utility to construct a standard name for a standard image. */
+static size_t
+standard_name(char *buffer, size_t bufsize, size_t pos, png_byte colour_type,
+    int bit_depth, unsigned int npalette, int interlace_type,
+    png_uint_32 w, png_uint_32 h, int do_interlace)
+{
+   pos = safecat(buffer, bufsize, pos, colour_types[colour_type]);
+   if (colour_type == 3) /* must have a palette */
+   {
+      pos = safecat(buffer, bufsize, pos, "[");
+      pos = safecatn(buffer, bufsize, pos, npalette);
+      pos = safecat(buffer, bufsize, pos, "]");
+   }
+
+   else if (npalette != 0)
+      pos = safecat(buffer, bufsize, pos, "+tRNS");
+
+   pos = safecat(buffer, bufsize, pos, " ");
+   pos = safecatn(buffer, bufsize, pos, bit_depth);
+   pos = safecat(buffer, bufsize, pos, " bit");
+
+   if (interlace_type != PNG_INTERLACE_NONE)
+   {
+      pos = safecat(buffer, bufsize, pos, " interlaced");
+      if (do_interlace)
+         pos = safecat(buffer, bufsize, pos, "(pngvalid)");
+      else
+         pos = safecat(buffer, bufsize, pos, "(libpng)");
+   }
+
+   if (w > 0 || h > 0)
+   {
+      pos = safecat(buffer, bufsize, pos, " ");
+      pos = safecatn(buffer, bufsize, pos, w);
+      pos = safecat(buffer, bufsize, pos, "x");
+      pos = safecatn(buffer, bufsize, pos, h);
+   }
+
+   return pos;
+}
+
+static size_t
+standard_name_from_id(char *buffer, size_t bufsize, size_t pos, png_uint_32 id)
+{
+   return standard_name(buffer, bufsize, pos, COL_FROM_ID(id),
+      DEPTH_FROM_ID(id), PALETTE_FROM_ID(id), INTERLACE_FROM_ID(id),
+      WIDTH_FROM_ID(id), HEIGHT_FROM_ID(id), DO_INTERLACE_FROM_ID(id));
+}
+
+/* Convenience API and defines to list valid formats.  Note that 16 bit read and
+ * write support is required to do 16 bit read tests (we must be able to make a
+ * 16 bit image to test!)
+ */
+#ifdef PNG_WRITE_16BIT_SUPPORTED
+#  define WRITE_BDHI 4
+#  ifdef PNG_READ_16BIT_SUPPORTED
+#     define READ_BDHI 4
+#     define DO_16BIT
+#  endif
+#else
+#  define WRITE_BDHI 3
+#endif
+#ifndef DO_16BIT
+#  define READ_BDHI 3
+#endif
+
+/* The following defines the number of different palettes to generate for
+ * each log bit depth of a colour type 3 standard image.
+ */
+#define PALETTE_COUNT(bit_depth) ((bit_depth) > 4 ? 1U : 16U)
+
+static int
+next_format(png_bytep colour_type, png_bytep bit_depth,
+   unsigned int* palette_number, int low_depth_gray, int tRNS)
+{
+   if (*bit_depth == 0)
+   {
+      *colour_type = 0;
+      if (low_depth_gray)
+         *bit_depth = 1;
+      else
+         *bit_depth = 8;
+      *palette_number = 0;
+      return 1;
+   }
+
+   if  (*colour_type < 4/*no alpha channel*/)
+   {
+      /* Add multiple palettes for colour type 3, one image with tRNS
+       * and one without for other non-alpha formats:
+       */
+      unsigned int pn = ++*palette_number;
+      png_byte ct = *colour_type;
+
+      if (((ct == 0/*GRAY*/ || ct/*RGB*/ == 2) && tRNS && pn < 2) ||
+          (ct == 3/*PALETTE*/ && pn < PALETTE_COUNT(*bit_depth)))
+         return 1;
+
+      /* No: next bit depth */
+      *palette_number = 0;
+   }
+
+   *bit_depth = (png_byte)(*bit_depth << 1);
+
+   /* Palette images are restricted to 8 bit depth */
+   if (*bit_depth <= 8
+#ifdef DO_16BIT
+         || (*colour_type != 3 && *bit_depth <= 16)
+#endif
+      )
+      return 1;
+
+   /* Move to the next color type, or return 0 at the end. */
+   switch (*colour_type)
+   {
+      case 0:
+         *colour_type = 2;
+         *bit_depth = 8;
+         return 1;
+
+      case 2:
+         *colour_type = 3;
+         *bit_depth = 1;
+         return 1;
+
+      case 3:
+         *colour_type = 4;
+         *bit_depth = 8;
+         return 1;
+
+      case 4:
+         *colour_type = 6;
+         *bit_depth = 8;
+         return 1;
+
+      default:
+         return 0;
+   }
+}
+
+#ifdef PNG_READ_TRANSFORMS_SUPPORTED
+static unsigned int
+sample(png_const_bytep row, png_byte colour_type, png_byte bit_depth,
+    png_uint_32 x, unsigned int sample_index, int swap16, int littleendian)
+{
+   png_uint_32 bit_index, result;
+
+   /* Find a sample index for the desired sample: */
+   x *= bit_depth;
+   bit_index = x;
+
+   if ((colour_type & 1) == 0) /* !palette */
+   {
+      if (colour_type & 2)
+         bit_index *= 3;
+
+      if (colour_type & 4)
+         bit_index += x; /* Alpha channel */
+
+      /* Multiple channels; select one: */
+      if (colour_type & (2+4))
+         bit_index += sample_index * bit_depth;
+   }
+
+   /* Return the sample from the row as an integer. */
+   row += bit_index >> 3;
+   result = *row;
+
+   if (bit_depth == 8)
+      return result;
+
+   else if (bit_depth > 8)
+   {
+      if (swap16)
+         return (*++row << 8) + result;
+      else
+         return (result << 8) + *++row;
+   }
+
+   /* Less than 8 bits per sample.  By default PNG has the big end of
+    * the egg on the left of the screen, but if littleendian is set
+    * then the big end is on the right.
+    */
+   bit_index &= 7;
+
+   if (!littleendian)
+      bit_index = 8-bit_index-bit_depth;
+
+   return (result >> bit_index) & ((1U<<bit_depth)-1);
+}
+#endif /* PNG_READ_TRANSFORMS_SUPPORTED */
+
+/* Copy a single pixel, of a given size, from one buffer to another -
+ * while this is basically bit addressed there is an implicit assumption
+ * that pixels 8 or more bits in size are byte aligned and that pixels
+ * do not otherwise cross byte boundaries.  (This is, so far as I know,
+ * universally true in bitmap computer graphics.  [JCB 20101212])
+ *
+ * NOTE: The to and from buffers may be the same.
+ */
+static void
+pixel_copy(png_bytep toBuffer, png_uint_32 toIndex,
+   png_const_bytep fromBuffer, png_uint_32 fromIndex, unsigned int pixelSize,
+   int littleendian)
+{
+   /* Assume we can multiply by 'size' without overflow because we are
+    * just working in a single buffer.
+    */
+   toIndex *= pixelSize;
+   fromIndex *= pixelSize;
+   if (pixelSize < 8) /* Sub-byte */
+   {
+      /* Mask to select the location of the copied pixel: */
+      unsigned int destMask = ((1U<<pixelSize)-1) <<
+         (littleendian ? toIndex&7 : 8-pixelSize-(toIndex&7));
+      /* The following read the entire pixels and clears the extra: */
+      unsigned int destByte = toBuffer[toIndex >> 3] & ~destMask;
+      unsigned int sourceByte = fromBuffer[fromIndex >> 3];
+
+      /* Don't rely on << or >> supporting '0' here, just in case: */
+      fromIndex &= 7;
+      if (littleendian)
+      {
+         if (fromIndex > 0) sourceByte >>= fromIndex;
+         if ((toIndex & 7) > 0) sourceByte <<= toIndex & 7;
+      }
+
+      else
+      {
+         if (fromIndex > 0) sourceByte <<= fromIndex;
+         if ((toIndex & 7) > 0) sourceByte >>= toIndex & 7;
+      }
+
+      toBuffer[toIndex >> 3] = (png_byte)(destByte | (sourceByte & destMask));
+   }
+   else /* One or more bytes */
+      memmove(toBuffer+(toIndex>>3), fromBuffer+(fromIndex>>3), pixelSize>>3);
+}
+
+#ifdef PNG_READ_SUPPORTED
+/* Copy a complete row of pixels, taking into account potential partial
+ * bytes at the end.
+ */
+static void
+row_copy(png_bytep toBuffer, png_const_bytep fromBuffer, unsigned int bitWidth,
+      int littleendian)
+{
+   memcpy(toBuffer, fromBuffer, bitWidth >> 3);
+
+   if ((bitWidth & 7) != 0)
+   {
+      unsigned int mask;
+
+      toBuffer += bitWidth >> 3;
+      fromBuffer += bitWidth >> 3;
+      if (littleendian)
+         mask = 0xff << (bitWidth & 7);
+      else
+         mask = 0xff >> (bitWidth & 7);
+      *toBuffer = (png_byte)((*toBuffer & mask) | (*fromBuffer & ~mask));
+   }
+}
+
+/* Compare pixels - they are assumed to start at the first byte in the
+ * given buffers.
+ */
+static int
+pixel_cmp(png_const_bytep pa, png_const_bytep pb, png_uint_32 bit_width)
+{
+#if PNG_LIBPNG_VER < 10506
+   if (memcmp(pa, pb, bit_width>>3) == 0)
+   {
+      png_uint_32 p;
+
+      if ((bit_width & 7) == 0) return 0;
+
+      /* Ok, any differences? */
+      p = pa[bit_width >> 3];
+      p ^= pb[bit_width >> 3];
+
+      if (p == 0) return 0;
+
+      /* There are, but they may not be significant, remove the bits
+       * after the end (the low order bits in PNG.)
+       */
+      bit_width &= 7;
+      p >>= 8-bit_width;
+
+      if (p == 0) return 0;
+   }
+#else
+   /* From libpng-1.5.6 the overwrite should be fixed, so compare the trailing
+    * bits too:
+    */
+   if (memcmp(pa, pb, (bit_width+7)>>3) == 0)
+      return 0;
+#endif
+
+   /* Return the index of the changed byte. */
+   {
+      png_uint_32 where = 0;
+
+      while (pa[where] == pb[where]) ++where;
+      return 1+where;
+   }
+}
+#endif /* PNG_READ_SUPPORTED */
+
+/*************************** BASIC PNG FILE WRITING ***************************/
+/* A png_store takes data from the sequential writer or provides data
+ * to the sequential reader.  It can also store the result of a PNG
+ * write for later retrieval.
+ */
+#define STORE_BUFFER_SIZE 500 /* arbitrary */
+typedef struct png_store_buffer
+{
+   struct png_store_buffer*  prev;    /* NOTE: stored in reverse order */
+   png_byte                  buffer[STORE_BUFFER_SIZE];
+} png_store_buffer;
+
+#define FILE_NAME_SIZE 64
+
+typedef struct store_palette_entry /* record of a single palette entry */
+{
+   png_byte red;
+   png_byte green;
+   png_byte blue;
+   png_byte alpha;
+} store_palette_entry, store_palette[256];
+
+typedef struct png_store_file
+{
+   struct png_store_file*  next;      /* as many as you like... */
+   char                    name[FILE_NAME_SIZE];
+   unsigned int            IDAT_bits; /* Number of bits in IDAT size */
+   png_uint_32             IDAT_size; /* Total size of IDAT data */
+   png_uint_32             id;        /* must be correct (see FILEID) */
+   size_t                  datacount; /* In this (the last) buffer */
+   png_store_buffer        data;      /* Last buffer in file */
+   int                     npalette;  /* Number of entries in palette */
+   store_palette_entry*    palette;   /* May be NULL */
+} png_store_file;
+
+/* The following is a pool of memory allocated by a single libpng read or write
+ * operation.
+ */
+typedef struct store_pool
+{
+   struct png_store    *store;   /* Back pointer */
+   struct store_memory *list;    /* List of allocated memory */
+   png_byte             mark[4]; /* Before and after data */
+
+   /* Statistics for this run. */
+   png_alloc_size_t     max;     /* Maximum single allocation */
+   png_alloc_size_t     current; /* Current allocation */
+   png_alloc_size_t     limit;   /* Highest current allocation */
+   png_alloc_size_t     total;   /* Total allocation */
+
+   /* Overall statistics (retained across successive runs). */
+   png_alloc_size_t     max_max;
+   png_alloc_size_t     max_limit;
+   png_alloc_size_t     max_total;
+} store_pool;
+
+typedef struct png_store
+{
+   /* For cexcept.h exception handling - simply store one of these;
+    * the context is a self pointer but it may point to a different
+    * png_store (in fact it never does in this program.)
+    */
+   struct exception_context
+                      exception_context;
+
+   unsigned int       verbose :1;
+   unsigned int       treat_warnings_as_errors :1;
+   unsigned int       expect_error :1;
+   unsigned int       expect_warning :1;
+   unsigned int       saw_warning :1;
+   unsigned int       speed :1;
+   unsigned int       progressive :1; /* use progressive read */
+   unsigned int       validated :1;   /* used as a temporary flag */
+   int                nerrors;
+   int                nwarnings;
+   int                noptions;       /* number of options below: */
+   struct {
+      unsigned char   option;         /* option number, 0..30 */
+      unsigned char   setting;        /* setting (unset,invalid,on,off) */
+   }                  options[16];
+   char               test[128];      /* Name of test */
+   char               error[256];
+
+   /* Share fields */
+   png_uint_32        chunklen; /* Length of chunk+overhead (chunkpos >= 8) */
+   png_uint_32        chunktype;/* Type of chunk (valid if chunkpos >= 4) */
+   png_uint_32        chunkpos; /* Position in chunk */
+   png_uint_32        IDAT_size;/* Accumulated IDAT size in .new */
+   unsigned int       IDAT_bits;/* Cache of the file store value */
+
+   /* Read fields */
+   png_structp        pread;    /* Used to read a saved file */
+   png_infop          piread;
+   png_store_file*    current;  /* Set when reading */
+   png_store_buffer*  next;     /* Set when reading */
+   size_t             readpos;  /* Position in *next */
+   png_byte*          image;    /* Buffer for reading interlaced images */
+   size_t             cb_image; /* Size of this buffer */
+   size_t             cb_row;   /* Row size of the image(s) */
+   uLong              IDAT_crc;
+   png_uint_32        IDAT_len; /* Used when re-chunking IDAT chunks */
+   png_uint_32        IDAT_pos; /* Used when re-chunking IDAT chunks */
+   png_uint_32        image_h;  /* Number of rows in a single image */
+   store_pool         read_memory_pool;
+
+   /* Write fields */
+   png_store_file*    saved;
+   png_structp        pwrite;   /* Used when writing a new file */
+   png_infop          piwrite;
+   size_t             writepos; /* Position in .new */
+   char               wname[FILE_NAME_SIZE];
+   png_store_buffer   new;      /* The end of the new PNG file being written. */
+   store_pool         write_memory_pool;
+   store_palette_entry* palette;
+   int                  npalette;
+} png_store;
+
+/* Initialization and cleanup */
+static void
+store_pool_mark(png_bytep mark)
+{
+   static png_uint_32 store_seed[2] = { 0x12345678, 1};
+
+   make_four_random_bytes(store_seed, mark);
+}
+
+#ifdef PNG_READ_TRANSFORMS_SUPPORTED
+/* Use this for random 32 bit values; this function makes sure the result is
+ * non-zero.
+ */
+static png_uint_32
+random_32(void)
+{
+
+   for (;;)
+   {
+      png_byte mark[4];
+      png_uint_32 result;
+
+      store_pool_mark(mark);
+      result = png_get_uint_32(mark);
+
+      if (result != 0)
+         return result;
+   }
+}
+#endif /* PNG_READ_SUPPORTED */
+
+static void
+store_pool_init(png_store *ps, store_pool *pool)
+{
+   memset(pool, 0, sizeof *pool);
+
+   pool->store = ps;
+   pool->list = NULL;
+   pool->max = pool->current = pool->limit = pool->total = 0;
+   pool->max_max = pool->max_limit = pool->max_total = 0;
+   store_pool_mark(pool->mark);
+}
+
+static void
+store_init(png_store* ps)
+{
+   memset(ps, 0, sizeof *ps);
+   init_exception_context(&ps->exception_context);
+   store_pool_init(ps, &ps->read_memory_pool);
+   store_pool_init(ps, &ps->write_memory_pool);
+   ps->verbose = 0;
+   ps->treat_warnings_as_errors = 0;
+   ps->expect_error = 0;
+   ps->expect_warning = 0;
+   ps->saw_warning = 0;
+   ps->speed = 0;
+   ps->progressive = 0;
+   ps->validated = 0;
+   ps->nerrors = ps->nwarnings = 0;
+   ps->pread = NULL;
+   ps->piread = NULL;
+   ps->saved = ps->current = NULL;
+   ps->next = NULL;
+   ps->readpos = 0;
+   ps->image = NULL;
+   ps->cb_image = 0;
+   ps->cb_row = 0;
+   ps->image_h = 0;
+   ps->pwrite = NULL;
+   ps->piwrite = NULL;
+   ps->writepos = 0;
+   ps->chunkpos = 8;
+   ps->chunktype = 0;
+   ps->chunklen = 16;
+   ps->IDAT_size = 0;
+   ps->IDAT_bits = 0;
+   ps->new.prev = NULL;
+   ps->palette = NULL;
+   ps->npalette = 0;
+   ps->noptions = 0;
+}
+
+static void
+store_freebuffer(png_store_buffer* psb)
+{
+   if (psb->prev)
+   {
+      store_freebuffer(psb->prev);
+      free(psb->prev);
+      psb->prev = NULL;
+   }
+}
+
+static void
+store_freenew(png_store *ps)
+{
+   store_freebuffer(&ps->new);
+   ps->writepos = 0;
+   ps->chunkpos = 8;
+   ps->chunktype = 0;
+   ps->chunklen = 16;
+   ps->IDAT_size = 0;
+   ps->IDAT_bits = 0;
+   if (ps->palette != NULL)
+   {
+      free(ps->palette);
+      ps->palette = NULL;
+      ps->npalette = 0;
+   }
+}
+
+static void
+store_storenew(png_store *ps)
+{
+   png_store_buffer *pb;
+
+   pb = voidcast(png_store_buffer*, malloc(sizeof *pb));
+
+   if (pb == NULL)
+      png_error(ps->pwrite, "store new: OOM");
+
+   *pb = ps->new;
+   ps->new.prev = pb;
+   ps->writepos = 0;
+}
+
+static void
+store_freefile(png_store_file **ppf)
+{
+   if (*ppf != NULL)
+   {
+      store_freefile(&(*ppf)->next);
+
+      store_freebuffer(&(*ppf)->data);
+      (*ppf)->datacount = 0;
+      if ((*ppf)->palette != NULL)
+      {
+         free((*ppf)->palette);
+         (*ppf)->palette = NULL;
+         (*ppf)->npalette = 0;
+      }
+      free(*ppf);
+      *ppf = NULL;
+   }
+}
+
+static unsigned int
+bits_of(png_uint_32 num)
+{
+   /* Return the number of bits in 'num' */
+   unsigned int b = 0;
+
+   if (num & 0xffff0000U)  b += 16U, num >>= 16;
+   if (num & 0xff00U)      b += 8U, num >>= 8;
+   if (num & 0xf0U)        b += 4U, num >>= 4;
+   if (num & 0xcU)         b += 2U, num >>= 2;
+   if (num & 0x2U)         ++b, num >>= 1;
+   if (num)                ++b;
+
+   return b; /* 0..32 */
+}
+
+/* Main interface to file storage, after writing a new PNG file (see the API
+ * below) call store_storefile to store the result with the given name and id.
+ */
+static void
+store_storefile(png_store *ps, png_uint_32 id)
+{
+   png_store_file *pf;
+
+   if (ps->chunkpos != 0U || ps->chunktype != 0U || ps->chunklen != 0U ||
+       ps->IDAT_size == 0)
+      png_error(ps->pwrite, "storefile: incomplete write");
+
+   pf = voidcast(png_store_file*, malloc(sizeof *pf));
+   if (pf == NULL)
+      png_error(ps->pwrite, "storefile: OOM");
+   safecat(pf->name, sizeof pf->name, 0, ps->wname);
+   pf->id = id;
+   pf->data = ps->new;
+   pf->datacount = ps->writepos;
+   pf->IDAT_size = ps->IDAT_size;
+   pf->IDAT_bits = bits_of(ps->IDAT_size);
+   /* Because the IDAT always has zlib header stuff this must be true: */
+   if (pf->IDAT_bits == 0U)
+      png_error(ps->pwrite, "storefile: 0 sized IDAT");
+   ps->new.prev = NULL;
+   ps->writepos = 0;
+   ps->chunkpos = 8;
+   ps->chunktype = 0;
+   ps->chunklen = 16;
+   ps->IDAT_size = 0;
+   pf->palette = ps->palette;
+   pf->npalette = ps->npalette;
+   ps->palette = 0;
+   ps->npalette = 0;
+
+   /* And save it. */
+   pf->next = ps->saved;
+   ps->saved = pf;
+}
+
+/* Generate an error message (in the given buffer) */
+static size_t
+store_message(png_store *ps, png_const_structp pp, char *buffer, size_t bufsize,
+   size_t pos, const char *msg)
+{
+   if (pp != NULL && pp == ps->pread)
+   {
+      /* Reading a file */
+      pos = safecat(buffer, bufsize, pos, "read: ");
+
+      if (ps->current != NULL)
+      {
+         pos = safecat(buffer, bufsize, pos, ps->current->name);
+         pos = safecat(buffer, bufsize, pos, sep);
+      }
+   }
+
+   else if (pp != NULL && pp == ps->pwrite)
+   {
+      /* Writing a file */
+      pos = safecat(buffer, bufsize, pos, "write: ");
+      pos = safecat(buffer, bufsize, pos, ps->wname);
+      pos = safecat(buffer, bufsize, pos, sep);
+   }
+
+   else
+   {
+      /* Neither reading nor writing (or a memory error in struct delete) */
+      pos = safecat(buffer, bufsize, pos, "pngvalid: ");
+   }
+
+   if (ps->test[0] != 0)
+   {
+      pos = safecat(buffer, bufsize, pos, ps->test);
+      pos = safecat(buffer, bufsize, pos, sep);
+   }
+   pos = safecat(buffer, bufsize, pos, msg);
+   return pos;
+}
+
+/* Verbose output to the error stream: */
+static void
+store_verbose(png_store *ps, png_const_structp pp, png_const_charp prefix,
+   png_const_charp message)
+{
+   char buffer[512];
+
+   if (prefix)
+      fputs(prefix, stderr);
+
+   (void)store_message(ps, pp, buffer, sizeof buffer, 0, message);
+   fputs(buffer, stderr);
+   fputc('\n', stderr);
+}
+
+/* Log an error or warning - the relevant count is always incremented. */
+static void
+store_log(png_store* ps, png_const_structp pp, png_const_charp message,
+   int is_error)
+{
+   /* The warning is copied to the error buffer if there are no errors and it is
+    * the first warning.  The error is copied to the error buffer if it is the
+    * first error (overwriting any prior warnings).
+    */
+   if (is_error ? (ps->nerrors)++ == 0 :
+       (ps->nwarnings)++ == 0 && ps->nerrors == 0)
+      store_message(ps, pp, ps->error, sizeof ps->error, 0, message);
+
+   if (ps->verbose)
+      store_verbose(ps, pp, is_error ? "error: " : "warning: ", message);
+}
+
+#ifdef PNG_READ_SUPPORTED
+/* Internal error function, called with a png_store but no libpng stuff. */
+static void
+internal_error(png_store *ps, png_const_charp message)
+{
+   store_log(ps, NULL, message, 1 /* error */);
+
+   /* And finally throw an exception. */
+   {
+      struct exception_context *the_exception_context = &ps->exception_context;
+      Throw ps;
+   }
+}
+#endif /* PNG_READ_SUPPORTED */
+
+/* Functions to use as PNG callbacks. */
+static void PNGCBAPI
+store_error(png_structp ppIn, png_const_charp message) /* PNG_NORETURN */
+{
+   png_const_structp pp = ppIn;
+   png_store *ps = voidcast(png_store*, png_get_error_ptr(pp));
+
+   if (!ps->expect_error)
+      store_log(ps, pp, message, 1 /* error */);
+
+   /* And finally throw an exception. */
+   {
+      struct exception_context *the_exception_context = &ps->exception_context;
+      Throw ps;
+   }
+}
+
+static void PNGCBAPI
+store_warning(png_structp ppIn, png_const_charp message)
+{
+   png_const_structp pp = ppIn;
+   png_store *ps = voidcast(png_store*, png_get_error_ptr(pp));
+
+   if (!ps->expect_warning)
+      store_log(ps, pp, message, 0 /* warning */);
+   else
+      ps->saw_warning = 1;
+}
+
+/* These somewhat odd functions are used when reading an image to ensure that
+ * the buffer is big enough, the png_structp is for errors.
+ */
+/* Return a single row from the correct image. */
+static png_bytep
+store_image_row(const png_store* ps, png_const_structp pp, int nImage,
+   png_uint_32 y)
+{
+   size_t coffset = (nImage * ps->image_h + y) * (ps->cb_row + 5) + 2;
+
+   if (ps->image == NULL)
+      png_error(pp, "no allocated image");
+
+   if (coffset + ps->cb_row + 3 > ps->cb_image)
+      png_error(pp, "image too small");
+
+   return ps->image + coffset;
+}
+
+static void
+store_image_free(png_store *ps, png_const_structp pp)
+{
+   if (ps->image != NULL)
+   {
+      png_bytep image = ps->image;
+
+      if (image[-1] != 0xed || image[ps->cb_image] != 0xfe)
+      {
+         if (pp != NULL)
+            png_error(pp, "png_store image overwrite (1)");
+         else
+            store_log(ps, NULL, "png_store image overwrite (2)", 1);
+      }
+
+      ps->image = NULL;
+      ps->cb_image = 0;
+      --image;
+      free(image);
+   }
+}
+
+static void
+store_ensure_image(png_store *ps, png_const_structp pp, int nImages,
+   size_t cbRow, png_uint_32 cRows)
+{
+   size_t cb = nImages * cRows * (cbRow + 5);
+
+   if (ps->cb_image < cb)
+   {
+      png_bytep image;
+
+      store_image_free(ps, pp);
+
+      /* The buffer is deliberately mis-aligned. */
+      image = voidcast(png_bytep, malloc(cb+2));
+      if (image == NULL)
+      {
+         /* Called from the startup - ignore the error for the moment. */
+         if (pp == NULL)
+            return;
+
+         png_error(pp, "OOM allocating image buffer");
+      }
+
+      /* These magic tags are used to detect overwrites above. */
+      ++image;
+      image[-1] = 0xed;
+      image[cb] = 0xfe;
+
+      ps->image = image;
+      ps->cb_image = cb;
+   }
+
+   /* We have an adequate sized image; lay out the rows.  There are 2 bytes at
+    * the start and three at the end of each (this ensures that the row
+    * alignment starts out odd - 2+1 and changes for larger images on each row.)
+    */
+   ps->cb_row = cbRow;
+   ps->image_h = cRows;
+
+   /* For error checking, the whole buffer is set to 10110010 (0xb2 - 178).
+    * This deliberately doesn't match the bits in the size test image which are
+    * outside the image; these are set to 0xff (all 1).  To make the row
+    * comparison work in the 'size' test case the size rows are pre-initialized
+    * to the same value prior to calling 'standard_row'.
+    */
+   memset(ps->image, 178, cb);
+
+   /* Then put in the marks. */
+   while (--nImages >= 0)
+   {
+      png_uint_32 y;
+
+      for (y=0; y<cRows; ++y)
+      {
+         png_bytep row = store_image_row(ps, pp, nImages, y);
+
+         /* The markers: */
+         row[-2] = 190;
+         row[-1] = 239;
+         row[cbRow] = 222;
+         row[cbRow+1] = 173;
+         row[cbRow+2] = 17;
+      }
+   }
+}
+
+#ifdef PNG_READ_SUPPORTED
+static void
+store_image_check(const png_store* ps, png_const_structp pp, int iImage)
+{
+   png_const_bytep image = ps->image;
+
+   if (image[-1] != 0xed || image[ps->cb_image] != 0xfe)
+      png_error(pp, "image overwrite");
+   else
+   {
+      size_t cbRow = ps->cb_row;
+      png_uint_32 rows = ps->image_h;
+
+      image += iImage * (cbRow+5) * ps->image_h;
+
+      image += 2; /* skip image first row markers */
+
+      for (; rows > 0; --rows)
+      {
+         if (image[-2] != 190 || image[-1] != 239)
+            png_error(pp, "row start overwritten");
+
+         if (image[cbRow] != 222 || image[cbRow+1] != 173 ||
+            image[cbRow+2] != 17)
+            png_error(pp, "row end overwritten");
+
+         image += cbRow+5;
+      }
+   }
+}
+#endif /* PNG_READ_SUPPORTED */
+
+static int
+valid_chunktype(png_uint_32 chunktype)
+{
+   /* Each byte in the chunk type must be in one of the ranges 65..90, 97..122
+    * (both inclusive), so:
+    */
+   unsigned int i;
+
+   for (i=0; i<4; ++i)
+   {
+      unsigned int c = chunktype & 0xffU;
+
+      if (!((c >= 65U && c <= 90U) || (c >= 97U && c <= 122U)))
+         return 0;
+
+      chunktype >>= 8;
+   }
+
+   return 1; /* It's valid */
+}
+
+static void PNGCBAPI
+store_write(png_structp ppIn, png_bytep pb, size_t st)
+{
+   png_const_structp pp = ppIn;
+   png_store *ps = voidcast(png_store*, png_get_io_ptr(pp));
+   size_t writepos = ps->writepos;
+   png_uint_32 chunkpos = ps->chunkpos;
+   png_uint_32 chunktype = ps->chunktype;
+   png_uint_32 chunklen = ps->chunklen;
+
+   if (ps->pwrite != pp)
+      png_error(pp, "store state damaged");
+
+   /* Technically this is legal, but in practice libpng never writes more than
+    * the maximum chunk size at once so if it happens something weird has
+    * changed inside libpng (probably).
+    */
+   if (st > 0x7fffffffU)
+      png_error(pp, "unexpected write size");
+
+   /* Now process the bytes to be written.  Do this in units of the space in the
+    * output (write) buffer or, at the start 4 bytes for the chunk type and
+    * length limited in any case by the amount of data.
+    */
+   while (st > 0)
+   {
+      if (writepos >= STORE_BUFFER_SIZE)
+         store_storenew(ps), writepos = 0;
+
+      if (chunkpos < 4)
+      {
+         png_byte b = *pb++;
+         --st;
+         chunklen = (chunklen << 8) + b;
+         ps->new.buffer[writepos++] = b;
+         ++chunkpos;
+      }
+
+      else if (chunkpos < 8)
+      {
+         png_byte b = *pb++;
+         --st;
+         chunktype = (chunktype << 8) + b;
+         ps->new.buffer[writepos++] = b;
+
+         if (++chunkpos == 8)
+         {
+            chunklen &= 0xffffffffU;
+            if (chunklen > 0x7fffffffU)
+               png_error(pp, "chunk length too great");
+
+            chunktype &= 0xffffffffU;
+            if (chunktype == CHUNK_IDAT)
+            {
+               if (chunklen > ~ps->IDAT_size)
+                  png_error(pp, "pngvalid internal image too large");
+
+               ps->IDAT_size += chunklen;
+            }
+
+            else if (!valid_chunktype(chunktype))
+               png_error(pp, "invalid chunk type");
+
+            chunklen += 12; /* for header and CRC */
+         }
+      }
+
+      else /* chunkpos >= 8 */
+      {
+         size_t cb = st;
+
+         if (cb > STORE_BUFFER_SIZE - writepos)
+            cb = STORE_BUFFER_SIZE - writepos;
+
+         if (cb  > chunklen - chunkpos/* bytes left in chunk*/)
+            cb = (size_t)/*SAFE*/(chunklen - chunkpos);
+
+         memcpy(ps->new.buffer + writepos, pb, cb);
+         chunkpos += (png_uint_32)/*SAFE*/cb;
+         pb += cb;
+         writepos += cb;
+         st -= cb;
+
+         if (chunkpos >= chunklen) /* must be equal */
+            chunkpos = chunktype = chunklen = 0;
+      }
+   } /* while (st > 0) */
+
+   ps->writepos = writepos;
+   ps->chunkpos = chunkpos;
+   ps->chunktype = chunktype;
+   ps->chunklen = chunklen;
+}
+
+static void PNGCBAPI
+store_flush(png_structp ppIn)
+{
+   UNUSED(ppIn) /*DOES NOTHING*/
+}
+
+#ifdef PNG_READ_SUPPORTED
+static size_t
+store_read_buffer_size(png_store *ps)
+{
+   /* Return the bytes available for read in the current buffer. */
+   if (ps->next != &ps->current->data)
+      return STORE_BUFFER_SIZE;
+
+   return ps->current->datacount;
+}
+
+/* Return total bytes available for read. */
+static size_t
+store_read_buffer_avail(png_store *ps)
+{
+   if (ps->current != NULL && ps->next != NULL)
+   {
+      png_store_buffer *next = &ps->current->data;
+      size_t cbAvail = ps->current->datacount;
+
+      while (next != ps->next && next != NULL)
+      {
+         next = next->prev;
+         cbAvail += STORE_BUFFER_SIZE;
+      }
+
+      if (next != ps->next)
+         png_error(ps->pread, "buffer read error");
+
+      if (cbAvail > ps->readpos)
+         return cbAvail - ps->readpos;
+   }
+
+   return 0;
+}
+
+static int
+store_read_buffer_next(png_store *ps)
+{
+   png_store_buffer *pbOld = ps->next;
+   png_store_buffer *pbNew = &ps->current->data;
+   if (pbOld != pbNew)
+   {
+      while (pbNew != NULL && pbNew->prev != pbOld)
+         pbNew = pbNew->prev;
+
+      if (pbNew != NULL)
+      {
+         ps->next = pbNew;
+         ps->readpos = 0;
+         return 1;
+      }
+
+      png_error(ps->pread, "buffer lost");
+   }
+
+   return 0; /* EOF or error */
+}
+
+/* Need separate implementation and callback to allow use of the same code
+ * during progressive read, where the io_ptr is set internally by libpng.
+ */
+static void
+store_read_imp(png_store *ps, png_bytep pb, size_t st)
+{
+   if (ps->current == NULL || ps->next == NULL)
+      png_error(ps->pread, "store state damaged");
+
+   while (st > 0)
+   {
+      size_t cbAvail = store_read_buffer_size(ps) - ps->readpos;
+
+      if (cbAvail > 0)
+      {
+         if (cbAvail > st) cbAvail = st;
+         memcpy(pb, ps->next->buffer + ps->readpos, cbAvail);
+         st -= cbAvail;
+         pb += cbAvail;
+         ps->readpos += cbAvail;
+      }
+
+      else if (!store_read_buffer_next(ps))
+         png_error(ps->pread, "read beyond end of file");
+   }
+}
+
+static size_t
+store_read_chunk(png_store *ps, png_bytep pb, size_t max, size_t min)
+{
+   png_uint_32 chunklen = ps->chunklen;
+   png_uint_32 chunktype = ps->chunktype;
+   png_uint_32 chunkpos = ps->chunkpos;
+   size_t st = max;
+
+   if (st > 0) do
+   {
+      if (chunkpos >= chunklen) /* end of last chunk */
+      {
+         png_byte buffer[8];
+
+         /* Read the header of the next chunk: */
+         store_read_imp(ps, buffer, 8U);
+         chunklen = png_get_uint_32(buffer) + 12U;
+         chunktype = png_get_uint_32(buffer+4U);
+         chunkpos = 0U; /* Position read so far */
+      }
+
+      if (chunktype == CHUNK_IDAT)
+      {
+         png_uint_32 IDAT_pos = ps->IDAT_pos;
+         png_uint_32 IDAT_len = ps->IDAT_len;
+         png_uint_32 IDAT_size = ps->IDAT_size;
+
+         /* The IDAT headers are constructed here; skip the input header. */
+         if (chunkpos < 8U)
+            chunkpos = 8U;
+
+         if (IDAT_pos == IDAT_len)
+         {
+            png_byte random = random_byte();
+
+            /* Make a new IDAT chunk, if IDAT_len is 0 this is the first IDAT,
+             * if IDAT_size is 0 this is the end.  At present this is set up
+             * using a random number so that there is a 25% chance before
+             * the start of the first IDAT chunk being 0 length.
+             */
+            if (IDAT_len == 0U) /* First IDAT */
+            {
+               switch (random & 3U)
+               {
+                  case 0U: IDAT_len = 12U; break; /* 0 bytes */
+                  case 1U: IDAT_len = 13U; break; /* 1 byte */
+                  default: IDAT_len = random_u32();
+                           IDAT_len %= IDAT_size;
+                           IDAT_len += 13U; /* 1..IDAT_size bytes */
+                           break;
+               }
+            }
+
+            else if (IDAT_size == 0U) /* all IDAT data read */
+            {
+               /* The last (IDAT) chunk should be positioned at the CRC now: */
+               if (chunkpos != chunklen-4U)
+                  png_error(ps->pread, "internal: IDAT size mismatch");
+
+               /* The only option here is to add a zero length IDAT, this
+                * happens 25% of the time.  Because of the check above
+                * chunklen-4U-chunkpos must be zero, we just need to skip the
+                * CRC now.
+                */
+               if ((random & 3U) == 0U)
+                  IDAT_len = 12U; /* Output another 0 length IDAT */
+
+               else
+               {
+                  /* End of IDATs, skip the CRC to make the code above load the
+                   * next chunk header next time round.
+                   */
+                  png_byte buffer[4];
+
+                  store_read_imp(ps, buffer, 4U);
+                  chunkpos += 4U;
+                  ps->IDAT_pos = IDAT_pos;
+                  ps->IDAT_len = IDAT_len;
+                  ps->IDAT_size = 0U;
+                  continue; /* Read the next chunk */
+               }
+            }
+
+            else
+            {
+               /* Middle of IDATs, use 'random' to determine the number of bits
+                * to use in the IDAT length.
+                */
+               IDAT_len = random_u32();
+               IDAT_len &= (1U << (1U + random % ps->IDAT_bits)) - 1U;
+               if (IDAT_len > IDAT_size)
+                  IDAT_len = IDAT_size;
+               IDAT_len += 12U; /* zero bytes may occur */
+            }
+
+            IDAT_pos = 0U;
+            ps->IDAT_crc = 0x35af061e; /* Ie: crc32(0UL, "IDAT", 4) */
+         } /* IDAT_pos == IDAT_len */
+
+         if (IDAT_pos < 8U) /* Return the header */ do
+         {
+            png_uint_32 b;
+            unsigned int shift;
+
+            if (IDAT_pos < 4U)
+               b = IDAT_len - 12U;
+
+            else
+               b = CHUNK_IDAT;
+
+            shift = 3U & IDAT_pos;
+            ++IDAT_pos;
+
+            if (shift < 3U)
+               b >>= 8U*(3U-shift);
+
+            *pb++ = 0xffU & b;
+         }
+         while (--st > 0 && IDAT_pos < 8);
+
+         else if (IDAT_pos < IDAT_len - 4U) /* I.e not the CRC */
+         {
+            if (chunkpos < chunklen-4U)
+            {
+               uInt avail = (uInt)-1;
+
+               if (avail > (IDAT_len-4U) - IDAT_pos)
+                  avail = (uInt)/*SAFE*/((IDAT_len-4U) - IDAT_pos);
+
+               if (avail > st)
+                  avail = (uInt)/*SAFE*/st;
+
+               if (avail > (chunklen-4U) - chunkpos)
+                  avail = (uInt)/*SAFE*/((chunklen-4U) - chunkpos);
+
+               store_read_imp(ps, pb, avail);
+               ps->IDAT_crc = crc32(ps->IDAT_crc, pb, avail);
+               pb += (size_t)/*SAFE*/avail;
+               st -= (size_t)/*SAFE*/avail;
+               chunkpos += (png_uint_32)/*SAFE*/avail;
+               IDAT_size -= (png_uint_32)/*SAFE*/avail;
+               IDAT_pos += (png_uint_32)/*SAFE*/avail;
+            }
+
+            else /* skip the input CRC */
+            {
+               png_byte buffer[4];
+
+               store_read_imp(ps, buffer, 4U);
+               chunkpos += 4U;
+            }
+         }
+
+         else /* IDAT crc */ do
+         {
+            uLong b = ps->IDAT_crc;
+            unsigned int shift = (IDAT_len - IDAT_pos); /* 4..1 */
+            ++IDAT_pos;
+
+            if (shift > 1U)
+               b >>= 8U*(shift-1U);
+
+            *pb++ = 0xffU & b;
+         }
+         while (--st > 0 && IDAT_pos < IDAT_len);
+
+         ps->IDAT_pos = IDAT_pos;
+         ps->IDAT_len = IDAT_len;
+         ps->IDAT_size = IDAT_size;
+      }
+
+      else /* !IDAT */
+      {
+         /* If there is still some pending IDAT data after the IDAT chunks have
+          * been processed there is a problem:
+          */
+         if (ps->IDAT_len > 0 && ps->IDAT_size > 0)
+            png_error(ps->pread, "internal: missing IDAT data");
+
+         if (chunktype == CHUNK_IEND && ps->IDAT_len == 0U)
+            png_error(ps->pread, "internal: missing IDAT");
+
+         if (chunkpos < 8U) /* Return the header */ do
+         {
+            png_uint_32 b;
+            unsigned int shift;
+
+            if (chunkpos < 4U)
+               b = chunklen - 12U;
+
+            else
+               b = chunktype;
+
+            shift = 3U & chunkpos;
+            ++chunkpos;
+
+            if (shift < 3U)
+               b >>= 8U*(3U-shift);
+
+            *pb++ = 0xffU & b;
+         }
+         while (--st > 0 && chunkpos < 8);
+
+         else /* Return chunk bytes, including the CRC */
+         {
+            size_t avail = st;
+
+            if (avail > chunklen - chunkpos)
+               avail = (size_t)/*SAFE*/(chunklen - chunkpos);
+
+            store_read_imp(ps, pb, avail);
+            pb += avail;
+            st -= avail;
+            chunkpos += (png_uint_32)/*SAFE*/avail;
+
+            /* Check for end of chunk and end-of-file; don't try to read a new
+             * chunk header at this point unless instructed to do so by 'min'.
+             */
+            if (chunkpos >= chunklen && max-st >= min &&
+                     store_read_buffer_avail(ps) == 0)
+               break;
+         }
+      } /* !IDAT */
+   }
+   while (st > 0);
+
+   ps->chunklen = chunklen;
+   ps->chunktype = chunktype;
+   ps->chunkpos = chunkpos;
+
+   return st; /* space left */
+}
+
+static void PNGCBAPI
+store_read(png_structp ppIn, png_bytep pb, size_t st)
+{
+   png_const_structp pp = ppIn;
+   png_store *ps = voidcast(png_store*, png_get_io_ptr(pp));
+
+   if (ps == NULL || ps->pread != pp)
+      png_error(pp, "bad store read call");
+
+   store_read_chunk(ps, pb, st, st);
+}
+
+static void
+store_progressive_read(png_store *ps, png_structp pp, png_infop pi)
+{
+   if (ps->pread != pp || ps->current == NULL || ps->next == NULL)
+      png_error(pp, "store state damaged (progressive)");
+
+   /* This is another Horowitz and Hill random noise generator.  In this case
+    * the aim is to stress the progressive reader with truly horrible variable
+    * buffer sizes in the range 1..500, so a sequence of 9 bit random numbers
+    * is generated.  We could probably just count from 1 to 32767 and get as
+    * good a result.
+    */
+   while (store_read_buffer_avail(ps) > 0)
+   {
+      static png_uint_32 noise = 2;
+      size_t cb;
+      png_byte buffer[512];
+
+      /* Generate 15 more bits of stuff: */
+      noise = (noise << 9) | ((noise ^ (noise >> (9-5))) & 0x1ff);
+      cb = noise & 0x1ff;
+      cb -= store_read_chunk(ps, buffer, cb, 1);
+      png_process_data(pp, pi, buffer, cb);
+   }
+}
+#endif /* PNG_READ_SUPPORTED */
+
+/* The caller must fill this in: */
+static store_palette_entry *
+store_write_palette(png_store *ps, int npalette)
+{
+   if (ps->pwrite == NULL)
+      store_log(ps, NULL, "attempt to write palette without write stream", 1);
+
+   if (ps->palette != NULL)
+      png_error(ps->pwrite, "multiple store_write_palette calls");
+
+   /* This function can only return NULL if called with '0'! */
+   if (npalette > 0)
+   {
+      ps->palette = voidcast(store_palette_entry*, malloc(npalette *
+         sizeof *ps->palette));
+
+      if (ps->palette == NULL)
+         png_error(ps->pwrite, "store new palette: OOM");
+
+      ps->npalette = npalette;
+   }
+
+   return ps->palette;
+}
+
+#ifdef PNG_READ_SUPPORTED
+static store_palette_entry *
+store_current_palette(png_store *ps, int *npalette)
+{
+   /* This is an internal error (the call has been made outside a read
+    * operation.)
+    */
+   if (ps->current == NULL)
+   {
+      store_log(ps, ps->pread, "no current stream for palette", 1);
+      return NULL;
+   }
+
+   /* The result may be null if there is no palette. */
+   *npalette = ps->current->npalette;
+   return ps->current->palette;
+}
+#endif /* PNG_READ_SUPPORTED */
+
+/***************************** MEMORY MANAGEMENT*** ***************************/
+#ifdef PNG_USER_MEM_SUPPORTED
+/* A store_memory is simply the header for an allocated block of memory.  The
+ * pointer returned to libpng is just after the end of the header block, the
+ * allocated memory is followed by a second copy of the 'mark'.
+ */
+typedef struct store_memory
+{
+   store_pool          *pool;    /* Originating pool */
+   struct store_memory *next;    /* Singly linked list */
+   png_alloc_size_t     size;    /* Size of memory allocated */
+   png_byte             mark[4]; /* ID marker */
+} store_memory;
+
+/* Handle a fatal error in memory allocation.  This calls png_error if the
+ * libpng struct is non-NULL, else it outputs a message and returns.  This means
+ * that a memory problem while libpng is running will abort (png_error) the
+ * handling of particular file while one in cleanup (after the destroy of the
+ * struct has returned) will simply keep going and free (or attempt to free)
+ * all the memory.
+ */
+static void
+store_pool_error(png_store *ps, png_const_structp pp, const char *msg)
+{
+   if (pp != NULL)
+      png_error(pp, msg);
+
+   /* Else we have to do it ourselves.  png_error eventually calls store_log,
+    * above.  store_log accepts a NULL png_structp - it just changes what gets
+    * output by store_message.
+    */
+   store_log(ps, pp, msg, 1 /* error */);
+}
+
+static void
+store_memory_free(png_const_structp pp, store_pool *pool, store_memory *memory)
+{
+   /* Note that pp may be NULL (see store_pool_delete below), the caller has
+    * found 'memory' in pool->list *and* unlinked this entry, so this is a valid
+    * pointer (for sure), but the contents may have been trashed.
+    */
+   if (memory->pool != pool)
+      store_pool_error(pool->store, pp, "memory corrupted (pool)");
+
+   else if (memcmp(memory->mark, pool->mark, sizeof memory->mark) != 0)
+      store_pool_error(pool->store, pp, "memory corrupted (start)");
+
+   /* It should be safe to read the size field now. */
+   else
+   {
+      png_alloc_size_t cb = memory->size;
+
+      if (cb > pool->max)
+         store_pool_error(pool->store, pp, "memory corrupted (size)");
+
+      else if (memcmp((png_bytep)(memory+1)+cb, pool->mark, sizeof pool->mark)
+         != 0)
+         store_pool_error(pool->store, pp, "memory corrupted (end)");
+
+      /* Finally give the library a chance to find problems too: */
+      else
+         {
+         pool->current -= cb;
+         free(memory);
+         }
+   }
+}
+
+static void
+store_pool_delete(png_store *ps, store_pool *pool)
+{
+   if (pool->list != NULL)
+   {
+      fprintf(stderr, "%s: %s %s: memory lost (list follows):\n", ps->test,
+         pool == &ps->read_memory_pool ? "read" : "write",
+         pool == &ps->read_memory_pool ? (ps->current != NULL ?
+            ps->current->name : "unknown file") : ps->wname);
+      ++ps->nerrors;
+
+      do
+      {
+         store_memory *next = pool->list;
+         pool->list = next->next;
+         next->next = NULL;
+
+         fprintf(stderr, "\t%lu bytes @ %p\n",
+             (unsigned long)next->size, (const void*)(next+1));
+         /* The NULL means this will always return, even if the memory is
+          * corrupted.
+          */
+         store_memory_free(NULL, pool, next);
+      }
+      while (pool->list != NULL);
+   }
+
+   /* And reset the other fields too for the next time. */
+   if (pool->max > pool->max_max) pool->max_max = pool->max;
+   pool->max = 0;
+   if (pool->current != 0) /* unexpected internal error */
+      fprintf(stderr, "%s: %s %s: memory counter mismatch (internal error)\n",
+         ps->test, pool == &ps->read_memory_pool ? "read" : "write",
+         pool == &ps->read_memory_pool ? (ps->current != NULL ?
+            ps->current->name : "unknown file") : ps->wname);
+   pool->current = 0;
+
+   if (pool->limit > pool->max_limit)
+      pool->max_limit = pool->limit;
+
+   pool->limit = 0;
+
+   if (pool->total > pool->max_total)
+      pool->max_total = pool->total;
+
+   pool->total = 0;
+
+   /* Get a new mark too. */
+   store_pool_mark(pool->mark);
+}
+
+/* The memory callbacks: */
+static png_voidp PNGCBAPI
+store_malloc(png_structp ppIn, png_alloc_size_t cb)
+{
+   png_const_structp pp = ppIn;
+   store_pool *pool = voidcast(store_pool*, png_get_mem_ptr(pp));
+   store_memory *new = voidcast(store_memory*, malloc(cb + (sizeof *new) +
+      (sizeof pool->mark)));
+
+   if (new != NULL)
+   {
+      if (cb > pool->max)
+         pool->max = cb;
+
+      pool->current += cb;
+
+      if (pool->current > pool->limit)
+         pool->limit = pool->current;
+
+      pool->total += cb;
+
+      new->size = cb;
+      memcpy(new->mark, pool->mark, sizeof new->mark);
+      memcpy((png_byte*)(new+1) + cb, pool->mark, sizeof pool->mark);
+      new->pool = pool;
+      new->next = pool->list;
+      pool->list = new;
+      ++new;
+   }
+
+   else
+   {
+      /* NOTE: the PNG user malloc function cannot use the png_ptr it is passed
+       * other than to retrieve the allocation pointer!  libpng calls the
+       * store_malloc callback in two basic cases:
+       *
+       * 1) From png_malloc; png_malloc will do a png_error itself if NULL is
+       *    returned.
+       * 2) From png_struct or png_info structure creation; png_malloc is
+       *    to return so cleanup can be performed.
+       *
+       * To handle this store_malloc can log a message, but can't do anything
+       * else.
+       */
+      store_log(pool->store, pp, "out of memory", 1 /* is_error */);
+   }
+
+   return new;
+}
+
+static void PNGCBAPI
+store_free(png_structp ppIn, png_voidp memory)
+{
+   png_const_structp pp = ppIn;
+   store_pool *pool = voidcast(store_pool*, png_get_mem_ptr(pp));
+   store_memory *this = voidcast(store_memory*, memory), **test;
+
+   /* Because libpng calls store_free with a dummy png_struct when deleting
+    * png_struct or png_info via png_destroy_struct_2 it is necessary to check
+    * the passed in png_structp to ensure it is valid, and not pass it to
+    * png_error if it is not.
+    */
+   if (pp != pool->store->pread && pp != pool->store->pwrite)
+      pp = NULL;
+
+   /* First check that this 'memory' really is valid memory - it must be in the
+    * pool list.  If it is, use the shared memory_free function to free it.
+    */
+   --this;
+   for (test = &pool->list; *test != this; test = &(*test)->next)
+   {
+      if (*test == NULL)
+      {
+         store_pool_error(pool->store, pp, "bad pointer to free");
+         return;
+      }
+   }
+
+   /* Unlink this entry, *test == this. */
+   *test = this->next;
+   this->next = NULL;
+   store_memory_free(pp, pool, this);
+}
+#endif /* PNG_USER_MEM_SUPPORTED */
+
+/* Setup functions. */
+/* Cleanup when aborting a write or after storing the new file. */
+static void
+store_write_reset(png_store *ps)
+{
+   if (ps->pwrite != NULL)
+   {
+      anon_context(ps);
+
+      Try
+         png_destroy_write_struct(&ps->pwrite, &ps->piwrite);
+
+      Catch_anonymous
+      {
+         /* memory corruption: continue. */
+      }
+
+      ps->pwrite = NULL;
+      ps->piwrite = NULL;
+   }
+
+   /* And make sure that all the memory has been freed - this will output
+    * spurious errors in the case of memory corruption above, but this is safe.
+    */
+#  ifdef PNG_USER_MEM_SUPPORTED
+      store_pool_delete(ps, &ps->write_memory_pool);
+#  endif
+
+   store_freenew(ps);
+}
+
+/* The following is the main write function, it returns a png_struct and,
+ * optionally, a png_info suitable for writiing a new PNG file.  Use
+ * store_storefile above to record this file after it has been written.  The
+ * returned libpng structures as destroyed by store_write_reset above.
+ */
+static png_structp
+set_store_for_write(png_store *ps, png_infopp ppi, const char *name)
+{
+   anon_context(ps);
+
+   Try
+   {
+      if (ps->pwrite != NULL)
+         png_error(ps->pwrite, "write store already in use");
+
+      store_write_reset(ps);
+      safecat(ps->wname, sizeof ps->wname, 0, name);
+
+      /* Don't do the slow memory checks if doing a speed test, also if user
+       * memory is not supported we can't do it anyway.
+       */
+#     ifdef PNG_USER_MEM_SUPPORTED
+         if (!ps->speed)
+            ps->pwrite = png_create_write_struct_2(PNG_LIBPNG_VER_STRING,
+               ps, store_error, store_warning, &ps->write_memory_pool,
+               store_malloc, store_free);
+
+         else
+#     endif
+         ps->pwrite = png_create_write_struct(PNG_LIBPNG_VER_STRING,
+            ps, store_error, store_warning);
+
+      png_set_write_fn(ps->pwrite, ps, store_write, store_flush);
+
+#     ifdef PNG_SET_OPTION_SUPPORTED
+         {
+            int opt;
+            for (opt=0; opt<ps->noptions; ++opt)
+               if (png_set_option(ps->pwrite, ps->options[opt].option,
+                  ps->options[opt].setting) == PNG_OPTION_INVALID)
+                  png_error(ps->pwrite, "png option invalid");
+         }
+#     endif
+
+      if (ppi != NULL)
+         *ppi = ps->piwrite = png_create_info_struct(ps->pwrite);
+   }
+
+   Catch_anonymous
+      return NULL;
+
+   return ps->pwrite;
+}
+
+/* Cleanup when finished reading (either due to error or in the success case).
+ * This routine exists even when there is no read support to make the code
+ * tidier (avoid a mass of ifdefs) and so easier to maintain.
+ */
+static void
+store_read_reset(png_store *ps)
+{
+#  ifdef PNG_READ_SUPPORTED
+      if (ps->pread != NULL)
+      {
+         anon_context(ps);
+
+         Try
+            png_destroy_read_struct(&ps->pread, &ps->piread, NULL);
+
+         Catch_anonymous
+         {
+            /* error already output: continue */
+         }
+
+         ps->pread = NULL;
+         ps->piread = NULL;
+      }
+#  endif
+
+#  ifdef PNG_USER_MEM_SUPPORTED
+      /* Always do this to be safe. */
+      store_pool_delete(ps, &ps->read_memory_pool);
+#  endif
+
+   ps->current = NULL;
+   ps->next = NULL;
+   ps->readpos = 0;
+   ps->validated = 0;
+
+   ps->chunkpos = 8;
+   ps->chunktype = 0;
+   ps->chunklen = 16;
+   ps->IDAT_size = 0;
+}
+
+#ifdef PNG_READ_SUPPORTED
+static void
+store_read_set(png_store *ps, png_uint_32 id)
+{
+   png_store_file *pf = ps->saved;
+
+   while (pf != NULL)
+   {
+      if (pf->id == id)
+      {
+         ps->current = pf;
+         ps->next = NULL;
+         ps->IDAT_size = pf->IDAT_size;
+         ps->IDAT_bits = pf->IDAT_bits; /* just a cache */
+         ps->IDAT_len = 0;
+         ps->IDAT_pos = 0;
+         ps->IDAT_crc = 0UL;
+         store_read_buffer_next(ps);
+         return;
+      }
+
+      pf = pf->next;
+   }
+
+   {
+      size_t pos;
+      char msg[FILE_NAME_SIZE+64];
+
+      pos = standard_name_from_id(msg, sizeof msg, 0, id);
+      pos = safecat(msg, sizeof msg, pos, ": file not found");
+      png_error(ps->pread, msg);
+   }
+}
+
+/* The main interface for reading a saved file - pass the id number of the file
+ * to retrieve.  Ids must be unique or the earlier file will be hidden.  The API
+ * returns a png_struct and, optionally, a png_info.  Both of these will be
+ * destroyed by store_read_reset above.
+ */
+static png_structp
+set_store_for_read(png_store *ps, png_infopp ppi, png_uint_32 id,
+   const char *name)
+{
+   /* Set the name for png_error */
+   safecat(ps->test, sizeof ps->test, 0, name);
+
+   if (ps->pread != NULL)
+      png_error(ps->pread, "read store already in use");
+
+   store_read_reset(ps);
+
+   /* Both the create APIs can return NULL if used in their default mode
+    * (because there is no other way of handling an error because the jmp_buf
+    * by default is stored in png_struct and that has not been allocated!)
+    * However, given that store_error works correctly in these circumstances
+    * we don't ever expect NULL in this program.
+    */
+#  ifdef PNG_USER_MEM_SUPPORTED
+      if (!ps->speed)
+         ps->pread = png_create_read_struct_2(PNG_LIBPNG_VER_STRING, ps,
+             store_error, store_warning, &ps->read_memory_pool, store_malloc,
+             store_free);
+
+      else
+#  endif
+   ps->pread = png_create_read_struct(PNG_LIBPNG_VER_STRING, ps, store_error,
+      store_warning);
+
+   if (ps->pread == NULL)
+   {
+      struct exception_context *the_exception_context = &ps->exception_context;
+
+      store_log(ps, NULL, "png_create_read_struct returned NULL (unexpected)",
+         1 /*error*/);
+
+      Throw ps;
+   }
+
+#  ifdef PNG_SET_OPTION_SUPPORTED
+      {
+         int opt;
+         for (opt=0; opt<ps->noptions; ++opt)
+            if (png_set_option(ps->pread, ps->options[opt].option,
+               ps->options[opt].setting) == PNG_OPTION_INVALID)
+                  png_error(ps->pread, "png option invalid");
+      }
+#  endif
+
+   store_read_set(ps, id);
+
+   if (ppi != NULL)
+      *ppi = ps->piread = png_create_info_struct(ps->pread);
+
+   return ps->pread;
+}
+#endif /* PNG_READ_SUPPORTED */
+
+/* The overall cleanup of a store simply calls the above then removes all the
+ * saved files.  This does not delete the store itself.
+ */
+static void
+store_delete(png_store *ps)
+{
+   store_write_reset(ps);
+   store_read_reset(ps);
+   store_freefile(&ps->saved);
+   store_image_free(ps, NULL);
+}
+
+/*********************** PNG FILE MODIFICATION ON READ ************************/
+/* Files may be modified on read.  The following structure contains a complete
+ * png_store together with extra members to handle modification and a special
+ * read callback for libpng.  To use this the 'modifications' field must be set
+ * to a list of png_modification structures that actually perform the
+ * modification, otherwise a png_modifier is functionally equivalent to a
+ * png_store.  There is a special read function, set_modifier_for_read, which
+ * replaces set_store_for_read.
+ */
+typedef enum modifier_state
+{
+   modifier_start,                        /* Initial value */
+   modifier_signature,                    /* Have a signature */
+   modifier_IHDR                          /* Have an IHDR */
+} modifier_state;
+
+typedef struct CIE_color
+{
+   /* A single CIE tristimulus value, representing the unique response of a
+    * standard observer to a variety of light spectra.  The observer recognizes
+    * all spectra that produce this response as the same color, therefore this
+    * is effectively a description of a color.
+    */
+   double X, Y, Z;
+} CIE_color;
+
+typedef struct color_encoding
+{
+   /* A description of an (R,G,B) encoding of color (as defined above); this
+    * includes the actual colors of the (R,G,B) triples (1,0,0), (0,1,0) and
+    * (0,0,1) plus an encoding value that is used to encode the linear
+    * components R, G and B to give the actual values R^gamma, G^gamma and
+    * B^gamma that are stored.
+    */
+   double    gamma;            /* Encoding (file) gamma of space */
+   CIE_color red, green, blue; /* End points */
+} color_encoding;
+
+#ifdef PNG_READ_SUPPORTED
+#if defined PNG_READ_TRANSFORMS_SUPPORTED && defined PNG_READ_cHRM_SUPPORTED
+static double
+chromaticity_x(CIE_color c)
+{
+   return c.X / (c.X + c.Y + c.Z);
+}
+
+static double
+chromaticity_y(CIE_color c)
+{
+   return c.Y / (c.X + c.Y + c.Z);
+}
+
+static CIE_color
+white_point(const color_encoding *encoding)
+{
+   CIE_color white;
+
+   white.X = encoding->red.X + encoding->green.X + encoding->blue.X;
+   white.Y = encoding->red.Y + encoding->green.Y + encoding->blue.Y;
+   white.Z = encoding->red.Z + encoding->green.Z + encoding->blue.Z;
+
+   return white;
+}
+#endif /* READ_TRANSFORMS && READ_cHRM */
+
+#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
+static void
+normalize_color_encoding(color_encoding *encoding)
+{
+   const double whiteY = encoding->red.Y + encoding->green.Y +
+      encoding->blue.Y;
+
+   if (whiteY != 1)
+   {
+      encoding->red.X /= whiteY;
+      encoding->red.Y /= whiteY;
+      encoding->red.Z /= whiteY;
+      encoding->green.X /= whiteY;
+      encoding->green.Y /= whiteY;
+      encoding->green.Z /= whiteY;
+      encoding->blue.X /= whiteY;
+      encoding->blue.Y /= whiteY;
+      encoding->blue.Z /= whiteY;
+   }
+}
+#endif
+
+#ifdef PNG_READ_TRANSFORMS_SUPPORTED
+static size_t
+safecat_color_encoding(char *buffer, size_t bufsize, size_t pos,
+   const color_encoding *e, double encoding_gamma)
+{
+   if (e != 0)
+   {
+      if (encoding_gamma != 0)
+         pos = safecat(buffer, bufsize, pos, "(");
+      pos = safecat(buffer, bufsize, pos, "R(");
+      pos = safecatd(buffer, bufsize, pos, e->red.X, 4);
+      pos = safecat(buffer, bufsize, pos, ",");
+      pos = safecatd(buffer, bufsize, pos, e->red.Y, 4);
+      pos = safecat(buffer, bufsize, pos, ",");
+      pos = safecatd(buffer, bufsize, pos, e->red.Z, 4);
+      pos = safecat(buffer, bufsize, pos, "),G(");
+      pos = safecatd(buffer, bufsize, pos, e->green.X, 4);
+      pos = safecat(buffer, bufsize, pos, ",");
+      pos = safecatd(buffer, bufsize, pos, e->green.Y, 4);
+      pos = safecat(buffer, bufsize, pos, ",");
+      pos = safecatd(buffer, bufsize, pos, e->green.Z, 4);
+      pos = safecat(buffer, bufsize, pos, "),B(");
+      pos = safecatd(buffer, bufsize, pos, e->blue.X, 4);
+      pos = safecat(buffer, bufsize, pos, ",");
+      pos = safecatd(buffer, bufsize, pos, e->blue.Y, 4);
+      pos = safecat(buffer, bufsize, pos, ",");
+      pos = safecatd(buffer, bufsize, pos, e->blue.Z, 4);
+      pos = safecat(buffer, bufsize, pos, ")");
+      if (encoding_gamma != 0)
+         pos = safecat(buffer, bufsize, pos, ")");
+   }
+
+   if (encoding_gamma != 0)
+   {
+      pos = safecat(buffer, bufsize, pos, "^");
+      pos = safecatd(buffer, bufsize, pos, encoding_gamma, 5);
+   }
+
+   return pos;
+}
+#endif /* READ_TRANSFORMS */
+#endif /* PNG_READ_SUPPORTED */
+
+typedef struct png_modifier
+{
+   png_store               this;             /* I am a png_store */
+   struct png_modification *modifications;   /* Changes to make */
+
+   modifier_state           state;           /* My state */
+
+   /* Information from IHDR: */
+   png_byte                 bit_depth;       /* From IHDR */
+   png_byte                 colour_type;     /* From IHDR */
+
+   /* While handling PLTE, IDAT and IEND these chunks may be pended to allow
+    * other chunks to be inserted.
+    */
+   png_uint_32              pending_len;
+   png_uint_32              pending_chunk;
+
+   /* Test values */
+   double                   *gammas;
+   unsigned int              ngammas;
+   unsigned int              ngamma_tests;     /* Number of gamma tests to run*/
+   double                    current_gamma;    /* 0 if not set */
+   const color_encoding *encodings;
+   unsigned int              nencodings;
+   const color_encoding *current_encoding; /* If an encoding has been set */
+   unsigned int              encoding_counter; /* For iteration */
+   int                       encoding_ignored; /* Something overwrote it */
+
+   /* Control variables used to iterate through possible encodings, the
+    * following must be set to 0 and tested by the function that uses the
+    * png_modifier because the modifier only sets it to 1 (true.)
+    */
+   unsigned int              repeat :1;   /* Repeat this transform test. */
+   unsigned int              test_uses_encoding :1;
+
+   /* Lowest sbit to test (pre-1.7 libpng fails for sbit < 8) */
+   png_byte                 sbitlow;
+
+   /* Error control - these are the limits on errors accepted by the gamma tests
+    * below.
+    */
+   double                   maxout8;  /* Maximum output value error */
+   double                   maxabs8;  /* Absolute sample error 0..1 */
+   double                   maxcalc8; /* Absolute sample error 0..1 */
+   double                   maxpc8;   /* Percentage sample error 0..100% */
+   double                   maxout16; /* Maximum output value error */
+   double                   maxabs16; /* Absolute sample error 0..1 */
+   double                   maxcalc16;/* Absolute sample error 0..1 */
+   double                   maxcalcG; /* Absolute sample error 0..1 */
+   double                   maxpc16;  /* Percentage sample error 0..100% */
+
+   /* This is set by transforms that need to allow a higher limit, it is an
+    * internal check on pngvalid to ensure that the calculated error limits are
+    * not ridiculous; without this it is too easy to make a mistake in pngvalid
+    * that allows any value through.
+    *
+    * NOTE: this is not checked in release builds.
+    */
+   double                   limit;    /* limit on error values, normally 4E-3 */
+
+   /* Log limits - values above this are logged, but not necessarily
+    * warned.
+    */
+   double                   log8;     /* Absolute error in 8 bits to log */
+   double                   log16;    /* Absolute error in 16 bits to log */
+
+   /* Logged 8 and 16 bit errors ('output' values): */
+   double                   error_gray_2;
+   double                   error_gray_4;
+   double                   error_gray_8;
+   double                   error_gray_16;
+   double                   error_color_8;
+   double                   error_color_16;
+   double                   error_indexed;
+
+   /* Flags: */
+   /* Whether to call png_read_update_info, not png_read_start_image, and how
+    * many times to call it.
+    */
+   int                      use_update_info;
+
+   /* Whether or not to interlace. */
+   int                      interlace_type :9; /* int, but must store '1' */
+
+   /* Run the standard tests? */
+   unsigned int             test_standard :1;
+
+   /* Run the odd-sized image and interlace read/write tests? */
+   unsigned int             test_size :1;
+
+   /* Run tests on reading with a combination of transforms, */
+   unsigned int             test_transform :1;
+   unsigned int             test_tRNS :1; /* Includes tRNS images */
+
+   /* When to use the use_input_precision option, this controls the gamma
+    * validation code checks.  If set any value that is within the transformed
+    * range input-.5 to input+.5 will be accepted, otherwise the value must be
+    * within the normal limits.  It should not be necessary to set this; the
+    * result should always be exact within the permitted error limits.
+    */
+   unsigned int             use_input_precision :1;
+   unsigned int             use_input_precision_sbit :1;
+   unsigned int             use_input_precision_16to8 :1;
+
+   /* If set assume that the calculation bit depth is set by the input
+    * precision, not the output precision.
+    */
+   unsigned int             calculations_use_input_precision :1;
+
+   /* If set assume that the calculations are done in 16 bits even if the sample
+    * depth is 8 bits.
+    */
+   unsigned int             assume_16_bit_calculations :1;
+
+   /* Which gamma tests to run: */
+   unsigned int             test_gamma_threshold :1;
+   unsigned int             test_gamma_transform :1; /* main tests */
+   unsigned int             test_gamma_sbit :1;
+   unsigned int             test_gamma_scale16 :1;
+   unsigned int             test_gamma_background :1;
+   unsigned int             test_gamma_alpha_mode :1;
+   unsigned int             test_gamma_expand16 :1;
+   unsigned int             test_exhaustive :1;
+
+   /* Whether or not to run the low-bit-depth grayscale tests.  This fails on
+    * gamma images in some cases because of gross inaccuracies in the grayscale
+    * gamma handling for low bit depth.
+    */
+   unsigned int             test_lbg :1;
+   unsigned int             test_lbg_gamma_threshold :1;
+   unsigned int             test_lbg_gamma_transform :1;
+   unsigned int             test_lbg_gamma_sbit :1;
+   unsigned int             test_lbg_gamma_composition :1;
+
+   unsigned int             log :1;   /* Log max error */
+
+   /* Buffer information, the buffer size limits the size of the chunks that can
+    * be modified - they must fit (including header and CRC) into the buffer!
+    */
+   size_t                   flush;           /* Count of bytes to flush */
+   size_t                   buffer_count;    /* Bytes in buffer */
+   size_t                   buffer_position; /* Position in buffer */
+   png_byte                 buffer[1024];
+} png_modifier;
+
+/* This returns true if the test should be stopped now because it has already
+ * failed and it is running silently.
+  */
+static int fail(png_modifier *pm)
+{
+   return !pm->log && !pm->this.verbose && (pm->this.nerrors > 0 ||
+       (pm->this.treat_warnings_as_errors && pm->this.nwarnings > 0));
+}
+
+static void
+modifier_init(png_modifier *pm)
+{
+   memset(pm, 0, sizeof *pm);
+   store_init(&pm->this);
+   pm->modifications = NULL;
+   pm->state = modifier_start;
+   pm->sbitlow = 1U;
+   pm->ngammas = 0;
+   pm->ngamma_tests = 0;
+   pm->gammas = 0;
+   pm->current_gamma = 0;
+   pm->encodings = 0;
+   pm->nencodings = 0;
+   pm->current_encoding = 0;
+   pm->encoding_counter = 0;
+   pm->encoding_ignored = 0;
+   pm->repeat = 0;
+   pm->test_uses_encoding = 0;
+   pm->maxout8 = pm->maxpc8 = pm->maxabs8 = pm->maxcalc8 = 0;
+   pm->maxout16 = pm->maxpc16 = pm->maxabs16 = pm->maxcalc16 = 0;
+   pm->maxcalcG = 0;
+   pm->limit = 4E-3;
+   pm->log8 = pm->log16 = 0; /* Means 'off' */
+   pm->error_gray_2 = pm->error_gray_4 = pm->error_gray_8 = 0;
+   pm->error_gray_16 = pm->error_color_8 = pm->error_color_16 = 0;
+   pm->error_indexed = 0;
+   pm->use_update_info = 0;
+   pm->interlace_type = PNG_INTERLACE_NONE;
+   pm->test_standard = 0;
+   pm->test_size = 0;
+   pm->test_transform = 0;
+#  ifdef PNG_WRITE_tRNS_SUPPORTED
+      pm->test_tRNS = 1;
+#  else
+      pm->test_tRNS = 0;
+#  endif
+   pm->use_input_precision = 0;
+   pm->use_input_precision_sbit = 0;
+   pm->use_input_precision_16to8 = 0;
+   pm->calculations_use_input_precision = 0;
+   pm->assume_16_bit_calculations = 0;
+   pm->test_gamma_threshold = 0;
+   pm->test_gamma_transform = 0;
+   pm->test_gamma_sbit = 0;
+   pm->test_gamma_scale16 = 0;
+   pm->test_gamma_background = 0;
+   pm->test_gamma_alpha_mode = 0;
+   pm->test_gamma_expand16 = 0;
+   pm->test_lbg = 1;
+   pm->test_lbg_gamma_threshold = 1;
+   pm->test_lbg_gamma_transform = 1;
+   pm->test_lbg_gamma_sbit = 1;
+   pm->test_lbg_gamma_composition = 1;
+   pm->test_exhaustive = 0;
+   pm->log = 0;
+
+   /* Rely on the memset for all the other fields - there are no pointers */
+}
+
+#ifdef PNG_READ_TRANSFORMS_SUPPORTED
+
+/* This controls use of checks that explicitly know how libpng digitizes the
+ * samples in calculations; setting this circumvents simple error limit checking
+ * in the rgb_to_gray check, replacing it with an exact copy of the libpng 1.5
+ * algorithm.
+ */
+#define DIGITIZE PNG_LIBPNG_VER < 10700
+
+/* If pm->calculations_use_input_precision is set then operations will happen
+ * with the precision of the input, not the precision of the output depth.
+ *
+ * If pm->assume_16_bit_calculations is set then even 8 bit calculations use 16
+ * bit precision.  This only affects those of the following limits that pertain
+ * to a calculation - not a digitization operation - unless the following API is
+ * called directly.
+ */
+#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
+#if DIGITIZE
+static double digitize(double value, int depth, int do_round)
+{
+   /* 'value' is in the range 0 to 1, the result is the same value rounded to a
+    * multiple of the digitization factor - 8 or 16 bits depending on both the
+    * sample depth and the 'assume' setting.  Digitization is normally by
+    * rounding and 'do_round' should be 1, if it is 0 the digitized value will
+    * be truncated.
+    */
+   unsigned int digitization_factor = (1U << depth) - 1;
+
+   /* Limiting the range is done as a convenience to the caller - it's easier to
+    * do it once here than every time at the call site.
+    */
+   if (value <= 0)
+      value = 0;
+
+   else if (value >= 1)
+      value = 1;
+
+   value *= digitization_factor;
+   if (do_round) value += .5;
+   return floor(value)/digitization_factor;
+}
+#endif
+#endif /* RGB_TO_GRAY */
+
+#ifdef PNG_READ_GAMMA_SUPPORTED
+static double abserr(const png_modifier *pm, int in_depth, int out_depth)
+{
+   /* Absolute error permitted in linear values - affected by the bit depth of
+    * the calculations.
+    */
+   if (pm->assume_16_bit_calculations ||
+      (pm->calculations_use_input_precision ? in_depth : out_depth) == 16)
+      return pm->maxabs16;
+   else
+      return pm->maxabs8;
+}
+
+static double calcerr(const png_modifier *pm, int in_depth, int out_depth)
+{
+   /* Error in the linear composition arithmetic - only relevant when
+    * composition actually happens (0 < alpha < 1).
+    */
+   if ((pm->calculations_use_input_precision ? in_depth : out_depth) == 16)
+      return pm->maxcalc16;
+   else if (pm->assume_16_bit_calculations)
+      return pm->maxcalcG;
+   else
+      return pm->maxcalc8;
+}
+
+static double pcerr(const png_modifier *pm, int in_depth, int out_depth)
+{
+   /* Percentage error permitted in the linear values.  Note that the specified
+    * value is a percentage but this routine returns a simple number.
+    */
+   if (pm->assume_16_bit_calculations ||
+      (pm->calculations_use_input_precision ? in_depth : out_depth) == 16)
+      return pm->maxpc16 * .01;
+   else
+      return pm->maxpc8 * .01;
+}
+
+/* Output error - the error in the encoded value.  This is determined by the
+ * digitization of the output so can be +/-0.5 in the actual output value.  In
+ * the expand_16 case with the current code in libpng the expand happens after
+ * all the calculations are done in 8 bit arithmetic, so even though the output
+ * depth is 16 the output error is determined by the 8 bit calculation.
+ *
+ * This limit is not determined by the bit depth of internal calculations.
+ *
+ * The specified parameter does *not* include the base .5 digitization error but
+ * it is added here.
+ */
+static double outerr(const png_modifier *pm, int in_depth, int out_depth)
+{
+   /* There is a serious error in the 2 and 4 bit grayscale transform because
+    * the gamma table value (8 bits) is simply shifted, not rounded, so the
+    * error in 4 bit grayscale gamma is up to the value below.  This is a hack
+    * to allow pngvalid to succeed:
+    *
+    * TODO: fix this in libpng
+    */
+   if (out_depth == 2)
+      return .73182-.5;
+
+   if (out_depth == 4)
+      return .90644-.5;
+
+   if ((pm->calculations_use_input_precision ? in_depth : out_depth) == 16)
+      return pm->maxout16;
+
+   /* This is the case where the value was calculated at 8-bit precision then
+    * scaled to 16 bits.
+    */
+   else if (out_depth == 16)
+      return pm->maxout8 * 257;
+
+   else
+      return pm->maxout8;
+}
+
+/* This does the same thing as the above however it returns the value to log,
+ * rather than raising a warning.  This is useful for debugging to track down
+ * exactly what set of parameters cause high error values.
+ */
+static double outlog(const png_modifier *pm, int in_depth, int out_depth)
+{
+   /* The command line parameters are either 8 bit (0..255) or 16 bit (0..65535)
+    * and so must be adjusted for low bit depth grayscale:
+    */
+   if (out_depth <= 8)
+   {
+      if (pm->log8 == 0) /* switched off */
+         return 256;
+
+      if (out_depth < 8)
+         return pm->log8 / 255 * ((1<<out_depth)-1);
+
+      return pm->log8;
+   }
+
+   if ((pm->calculations_use_input_precision ? in_depth : out_depth) == 16)
+   {
+      if (pm->log16 == 0)
+         return 65536;
+
+      return pm->log16;
+   }
+
+   /* This is the case where the value was calculated at 8-bit precision then
+    * scaled to 16 bits.
+    */
+   if (pm->log8 == 0)
+      return 65536;
+
+   return pm->log8 * 257;
+}
+
+/* This complements the above by providing the appropriate quantization for the
+ * final value.  Normally this would just be quantization to an integral value,
+ * but in the 8 bit calculation case it's actually quantization to a multiple of
+ * 257!
+ */
+static int output_quantization_factor(const png_modifier *pm, int in_depth,
+   int out_depth)
+{
+   if (out_depth == 16 && in_depth != 16 &&
+      pm->calculations_use_input_precision)
+      return 257;
+   else
+      return 1;
+}
+#endif /* PNG_READ_GAMMA_SUPPORTED */
+
+/* One modification structure must be provided for each chunk to be modified (in
+ * fact more than one can be provided if multiple separate changes are desired
+ * for a single chunk.)  Modifications include adding a new chunk when a
+ * suitable chunk does not exist.
+ *
+ * The caller of modify_fn will reset the CRC of the chunk and record 'modified'
+ * or 'added' as appropriate if the modify_fn returns 1 (true).  If the
+ * modify_fn is NULL the chunk is simply removed.
+ */
+typedef struct png_modification
+{
+   struct png_modification *next;
+   png_uint_32              chunk;
+
+   /* If the following is NULL all matching chunks will be removed: */
+   int                    (*modify_fn)(struct png_modifier *pm,
+                               struct png_modification *me, int add);
+
+   /* If the following is set to PLTE, IDAT or IEND and the chunk has not been
+    * found and modified (and there is a modify_fn) the modify_fn will be called
+    * to add the chunk before the relevant chunk.
+    */
+   png_uint_32              add;
+   unsigned int             modified :1;     /* Chunk was modified */
+   unsigned int             added    :1;     /* Chunk was added */
+   unsigned int             removed  :1;     /* Chunk was removed */
+} png_modification;
+
+static void
+modification_reset(png_modification *pmm)
+{
+   if (pmm != NULL)
+   {
+      pmm->modified = 0;
+      pmm->added = 0;
+      pmm->removed = 0;
+      modification_reset(pmm->next);
+   }
+}
+
+static void
+modification_init(png_modification *pmm)
+{
+   memset(pmm, 0, sizeof *pmm);
+   pmm->next = NULL;
+   pmm->chunk = 0;
+   pmm->modify_fn = NULL;
+   pmm->add = 0;
+   modification_reset(pmm);
+}
+
+#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
+static void
+modifier_current_encoding(const png_modifier *pm, color_encoding *ce)
+{
+   if (pm->current_encoding != 0)
+      *ce = *pm->current_encoding;
+
+   else
+      memset(ce, 0, sizeof *ce);
+
+   ce->gamma = pm->current_gamma;
+}
+#endif
+
+#ifdef PNG_READ_TRANSFORMS_SUPPORTED
+static size_t
+safecat_current_encoding(char *buffer, size_t bufsize, size_t pos,
+   const png_modifier *pm)
+{
+   pos = safecat_color_encoding(buffer, bufsize, pos, pm->current_encoding,
+      pm->current_gamma);
+
+   if (pm->encoding_ignored)
+      pos = safecat(buffer, bufsize, pos, "[overridden]");
+
+   return pos;
+}
+#endif
+
+/* Iterate through the usefully testable color encodings.  An encoding is one
+ * of:
+ *
+ * 1) Nothing (no color space, no gamma).
+ * 2) Just a gamma value from the gamma array (including 1.0)
+ * 3) A color space from the encodings array with the corresponding gamma.
+ * 4) The same, but with gamma 1.0 (only really useful with 16 bit calculations)
+ *
+ * The iterator selects these in turn, the randomizer selects one at random,
+ * which is used depends on the setting of the 'test_exhaustive' flag.  Notice
+ * that this function changes the colour space encoding so it must only be
+ * called on completion of the previous test.  This is what 'modifier_reset'
+ * does, below.
+ *
+ * After the function has been called the 'repeat' flag will still be set; the
+ * caller of modifier_reset must reset it at the start of each run of the test!
+ */
+static unsigned int
+modifier_total_encodings(const png_modifier *pm)
+{
+   return 1 +                 /* (1) nothing */
+      pm->ngammas +           /* (2) gamma values to test */
+      pm->nencodings +        /* (3) total number of encodings */
+      /* The following test only works after the first time through the
+       * png_modifier code because 'bit_depth' is set when the IHDR is read.
+       * modifier_reset, below, preserves the setting until after it has called
+       * the iterate function (also below.)
+       *
+       * For this reason do not rely on this function outside a call to
+       * modifier_reset.
+       */
+      ((pm->bit_depth == 16 || pm->assume_16_bit_calculations) ?
+         pm->nencodings : 0); /* (4) encodings with gamma == 1.0 */
+}
+
+static void
+modifier_encoding_iterate(png_modifier *pm)
+{
+   if (!pm->repeat && /* Else something needs the current encoding again. */
+      pm->test_uses_encoding) /* Some transform is encoding dependent */
+   {
+      if (pm->test_exhaustive)
+      {
+         if (++pm->encoding_counter >= modifier_total_encodings(pm))
+            pm->encoding_counter = 0; /* This will stop the repeat */
+      }
+
+      else
+      {
+         /* Not exhaustive - choose an encoding at random; generate a number in
+          * the range 1..(max-1), so the result is always non-zero:
+          */
+         if (pm->encoding_counter == 0)
+            pm->encoding_counter = random_mod(modifier_total_encodings(pm)-1)+1;
+         else
+            pm->encoding_counter = 0;
+      }
+
+      if (pm->encoding_counter > 0)
+         pm->repeat = 1;
+   }
+
+   else if (!pm->repeat)
+      pm->encoding_counter = 0;
+}
+
+static void
+modifier_reset(png_modifier *pm)
+{
+   store_read_reset(&pm->this);
+   pm->limit = 4E-3;
+   pm->pending_len = pm->pending_chunk = 0;
+   pm->flush = pm->buffer_count = pm->buffer_position = 0;
+   pm->modifications = NULL;
+   pm->state = modifier_start;
+   modifier_encoding_iterate(pm);
+   /* The following must be set in the next run.  In particular
+    * test_uses_encodings must be set in the _ini function of each transform
+    * that looks at the encodings.  (Not the 'add' function!)
+    */
+   pm->test_uses_encoding = 0;
+   pm->current_gamma = 0;
+   pm->current_encoding = 0;
+   pm->encoding_ignored = 0;
+   /* These only become value after IHDR is read: */
+   pm->bit_depth = pm->colour_type = 0;
+}
+
+/* The following must be called before anything else to get the encoding set up
+ * on the modifier.  In particular it must be called before the transform init
+ * functions are called.
+ */
+static void
+modifier_set_encoding(png_modifier *pm)
+{
+   /* Set the encoding to the one specified by the current encoding counter,
+    * first clear out all the settings - this corresponds to an encoding_counter
+    * of 0.
+    */
+   pm->current_gamma = 0;
+   pm->current_encoding = 0;
+   pm->encoding_ignored = 0; /* not ignored yet - happens in _ini functions. */
+
+   /* Now, if required, set the gamma and encoding fields. */
+   if (pm->encoding_counter > 0)
+   {
+      /* The gammas[] array is an array of screen gammas, not encoding gammas,
+       * so we need the inverse:
+       */
+      if (pm->encoding_counter <= pm->ngammas)
+         pm->current_gamma = 1/pm->gammas[pm->encoding_counter-1];
+
+      else
+      {
+         unsigned int i = pm->encoding_counter - pm->ngammas;
+
+         if (i >= pm->nencodings)
+         {
+            i %= pm->nencodings;
+            pm->current_gamma = 1; /* Linear, only in the 16 bit case */
+         }
+
+         else
+            pm->current_gamma = pm->encodings[i].gamma;
+
+         pm->current_encoding = pm->encodings + i;
+      }
+   }
+}
+
+/* Enquiry functions to find out what is set.  Notice that there is an implicit
+ * assumption below that the first encoding in the list is the one for sRGB.
+ */
+static int
+modifier_color_encoding_is_sRGB(const png_modifier *pm)
+{
+   return pm->current_encoding != 0 && pm->current_encoding == pm->encodings &&
+      pm->current_encoding->gamma == pm->current_gamma;
+}
+
+static int
+modifier_color_encoding_is_set(const png_modifier *pm)
+{
+   return pm->current_gamma != 0;
+}
+
+/* The guts of modification are performed during a read. */
+static void
+modifier_crc(png_bytep buffer)
+{
+   /* Recalculate the chunk CRC - a complete chunk must be in
+    * the buffer, at the start.
+    */
+   uInt datalen = png_get_uint_32(buffer);
+   uLong crc = crc32(0, buffer+4, datalen+4);
+   /* The cast to png_uint_32 is safe because a crc32 is always a 32 bit value.
+    */
+   png_save_uint_32(buffer+datalen+8, (png_uint_32)crc);
+}
+
+static void
+modifier_setbuffer(png_modifier *pm)
+{
+   modifier_crc(pm->buffer);
+   pm->buffer_count = png_get_uint_32(pm->buffer)+12;
+   pm->buffer_position = 0;
+}
+
+/* Separate the callback into the actual implementation (which is passed the
+ * png_modifier explicitly) and the callback, which gets the modifier from the
+ * png_struct.
+ */
+static void
+modifier_read_imp(png_modifier *pm, png_bytep pb, size_t st)
+{
+   while (st > 0)
+   {
+      size_t cb;
+      png_uint_32 len, chunk;
+      png_modification *mod;
+
+      if (pm->buffer_position >= pm->buffer_count) switch (pm->state)
+      {
+         static png_byte sign[8] = { 137, 80, 78, 71, 13, 10, 26, 10 };
+         case modifier_start:
+            store_read_chunk(&pm->this, pm->buffer, 8, 8); /* signature. */
+            pm->buffer_count = 8;
+            pm->buffer_position = 0;
+
+            if (memcmp(pm->buffer, sign, 8) != 0)
+               png_error(pm->this.pread, "invalid PNG file signature");
+            pm->state = modifier_signature;
+            break;
+
+         case modifier_signature:
+            store_read_chunk(&pm->this, pm->buffer, 13+12, 13+12); /* IHDR */
+            pm->buffer_count = 13+12;
+            pm->buffer_position = 0;
+
+            if (png_get_uint_32(pm->buffer) != 13 ||
+                png_get_uint_32(pm->buffer+4) != CHUNK_IHDR)
+               png_error(pm->this.pread, "invalid IHDR");
+
+            /* Check the list of modifiers for modifications to the IHDR. */
+            mod = pm->modifications;
+            while (mod != NULL)
+            {
+               if (mod->chunk == CHUNK_IHDR && mod->modify_fn &&
+                   (*mod->modify_fn)(pm, mod, 0))
+                  {
+                  mod->modified = 1;
+                  modifier_setbuffer(pm);
+                  }
+
+               /* Ignore removal or add if IHDR! */
+               mod = mod->next;
+            }
+
+            /* Cache information from the IHDR (the modified one.) */
+            pm->bit_depth = pm->buffer[8+8];
+            pm->colour_type = pm->buffer[8+8+1];
+
+            pm->state = modifier_IHDR;
+            pm->flush = 0;
+            break;
+
+         case modifier_IHDR:
+         default:
+            /* Read a new chunk and process it until we see PLTE, IDAT or
+             * IEND.  'flush' indicates that there is still some data to
+             * output from the preceding chunk.
+             */
+            if ((cb = pm->flush) > 0)
+            {
+               if (cb > st) cb = st;
+               pm->flush -= cb;
+               store_read_chunk(&pm->this, pb, cb, cb);
+               pb += cb;
+               st -= cb;
+               if (st == 0) return;
+            }
+
+            /* No more bytes to flush, read a header, or handle a pending
+             * chunk.
+             */
+            if (pm->pending_chunk != 0)
+            {
+               png_save_uint_32(pm->buffer, pm->pending_len);
+               png_save_uint_32(pm->buffer+4, pm->pending_chunk);
+               pm->pending_len = 0;
+               pm->pending_chunk = 0;
+            }
+            else
+               store_read_chunk(&pm->this, pm->buffer, 8, 8);
+
+            pm->buffer_count = 8;
+            pm->buffer_position = 0;
+
+            /* Check for something to modify or a terminator chunk. */
+            len = png_get_uint_32(pm->buffer);
+            chunk = png_get_uint_32(pm->buffer+4);
+
+            /* Terminators first, they may have to be delayed for added
+             * chunks
+             */
+            if (chunk == CHUNK_PLTE || chunk == CHUNK_IDAT ||
+                chunk == CHUNK_IEND)
+            {
+               mod = pm->modifications;
+
+               while (mod != NULL)
+               {
+                  if ((mod->add == chunk ||
+                      (mod->add == CHUNK_PLTE && chunk == CHUNK_IDAT)) &&
+                      mod->modify_fn != NULL && !mod->modified && !mod->added)
+                  {
+                     /* Regardless of what the modify function does do not run
+                      * this again.
+                      */
+                     mod->added = 1;
+
+                     if ((*mod->modify_fn)(pm, mod, 1 /*add*/))
+                     {
+                        /* Reset the CRC on a new chunk */
+                        if (pm->buffer_count > 0)
+                           modifier_setbuffer(pm);
+
+                        else
+                           {
+                           pm->buffer_position = 0;
+                           mod->removed = 1;
+                           }
+
+                        /* The buffer has been filled with something (we assume)
+                         * so output this.  Pend the current chunk.
+                         */
+                        pm->pending_len = len;
+                        pm->pending_chunk = chunk;
+                        break; /* out of while */
+                     }
+                  }
+
+                  mod = mod->next;
+               }
+
+               /* Don't do any further processing if the buffer was modified -
+                * otherwise the code will end up modifying a chunk that was
+                * just added.
+                */
+               if (mod != NULL)
+                  break; /* out of switch */
+            }
+
+            /* If we get to here then this chunk may need to be modified.  To
+             * do this it must be less than 1024 bytes in total size, otherwise
+             * it just gets flushed.
+             */
+            if (len+12 <= sizeof pm->buffer)
+            {
+               size_t s = len+12-pm->buffer_count;
+               store_read_chunk(&pm->this, pm->buffer+pm->buffer_count, s, s);
+               pm->buffer_count = len+12;
+
+               /* Check for a modification, else leave it be. */
+               mod = pm->modifications;
+               while (mod != NULL)
+               {
+                  if (mod->chunk == chunk)
+                  {
+                     if (mod->modify_fn == NULL)
+                     {
+                        /* Remove this chunk */
+                        pm->buffer_count = pm->buffer_position = 0;
+                        mod->removed = 1;
+                        break; /* Terminate the while loop */
+                     }
+
+                     else if ((*mod->modify_fn)(pm, mod, 0))
+                     {
+                        mod->modified = 1;
+                        /* The chunk may have been removed: */
+                        if (pm->buffer_count == 0)
+                        {
+                           pm->buffer_position = 0;
+                           break;
+                        }
+                        modifier_setbuffer(pm);
+                     }
+                  }
+
+                  mod = mod->next;
+               }
+            }
+
+            else
+               pm->flush = len+12 - pm->buffer_count; /* data + crc */
+
+            /* Take the data from the buffer (if there is any). */
+            break;
+      }
+
+      /* Here to read from the modifier buffer (not directly from
+       * the store, as in the flush case above.)
+       */
+      cb = pm->buffer_count - pm->buffer_position;
+
+      if (cb > st)
+         cb = st;
+
+      memcpy(pb, pm->buffer + pm->buffer_position, cb);
+      st -= cb;
+      pb += cb;
+      pm->buffer_position += cb;
+   }
+}
+
+/* The callback: */
+static void PNGCBAPI
+modifier_read(png_structp ppIn, png_bytep pb, size_t st)
+{
+   png_const_structp pp = ppIn;
+   png_modifier *pm = voidcast(png_modifier*, png_get_io_ptr(pp));
+
+   if (pm == NULL || pm->this.pread != pp)
+      png_error(pp, "bad modifier_read call");
+
+   modifier_read_imp(pm, pb, st);
+}
+
+/* Like store_progressive_read but the data is getting changed as we go so we
+ * need a local buffer.
+ */
+static void
+modifier_progressive_read(png_modifier *pm, png_structp pp, png_infop pi)
+{
+   if (pm->this.pread != pp || pm->this.current == NULL ||
+       pm->this.next == NULL)
+      png_error(pp, "store state damaged (progressive)");
+
+   /* This is another Horowitz and Hill random noise generator.  In this case
+    * the aim is to stress the progressive reader with truly horrible variable
+    * buffer sizes in the range 1..500, so a sequence of 9 bit random numbers
+    * is generated.  We could probably just count from 1 to 32767 and get as
+    * good a result.
+    */
+   for (;;)
+   {
+      static png_uint_32 noise = 1;
+      size_t cb, cbAvail;
+      png_byte buffer[512];
+
+      /* Generate 15 more bits of stuff: */
+      noise = (noise << 9) | ((noise ^ (noise >> (9-5))) & 0x1ff);
+      cb = noise & 0x1ff;
+
+      /* Check that this number of bytes are available (in the current buffer.)
+       * (This doesn't quite work - the modifier might delete a chunk; unlikely
+       * but possible, it doesn't happen at present because the modifier only
+       * adds chunks to standard images.)
+       */
+      cbAvail = store_read_buffer_avail(&pm->this);
+      if (pm->buffer_count > pm->buffer_position)
+         cbAvail += pm->buffer_count - pm->buffer_position;
+
+      if (cb > cbAvail)
+      {
+         /* Check for EOF: */
+         if (cbAvail == 0)
+            break;
+
+         cb = cbAvail;
+      }
+
+      modifier_read_imp(pm, buffer, cb);
+      png_process_data(pp, pi, buffer, cb);
+   }
+
+   /* Check the invariants at the end (if this fails it's a problem in this
+    * file!)
+    */
+   if (pm->buffer_count > pm->buffer_position ||
+       pm->this.next != &pm->this.current->data ||
+       pm->this.readpos < pm->this.current->datacount)
+      png_error(pp, "progressive read implementation error");
+}
+
+/* Set up a modifier. */
+static png_structp
+set_modifier_for_read(png_modifier *pm, png_infopp ppi, png_uint_32 id,
+    const char *name)
+{
+   /* Do this first so that the modifier fields are cleared even if an error
+    * happens allocating the png_struct.  No allocation is done here so no
+    * cleanup is required.
+    */
+   pm->state = modifier_start;
+   pm->bit_depth = 0;
+   pm->colour_type = 255;
+
+   pm->pending_len = 0;
+   pm->pending_chunk = 0;
+   pm->flush = 0;
+   pm->buffer_count = 0;
+   pm->buffer_position = 0;
+
+   return set_store_for_read(&pm->this, ppi, id, name);
+}
+
+
+/******************************** MODIFICATIONS *******************************/
+/* Standard modifications to add chunks.  These do not require the _SUPPORTED
+ * macros because the chunks can be there regardless of whether this specific
+ * libpng supports them.
+ */
+typedef struct gama_modification
+{
+   png_modification this;
+   png_fixed_point  gamma;
+} gama_modification;
+
+static int
+gama_modify(png_modifier *pm, png_modification *me, int add)
+{
+   UNUSED(add)
+   /* This simply dumps the given gamma value into the buffer. */
+   png_save_uint_32(pm->buffer, 4);
+   png_save_uint_32(pm->buffer+4, CHUNK_gAMA);
+   png_save_uint_32(pm->buffer+8, ((gama_modification*)me)->gamma);
+   return 1;
+}
+
+static void
+gama_modification_init(gama_modification *me, png_modifier *pm, double gammad)
+{
+   double g;
+
+   modification_init(&me->this);
+   me->this.chunk = CHUNK_gAMA;
+   me->this.modify_fn = gama_modify;
+   me->this.add = CHUNK_PLTE;
+   g = fix(gammad);
+   me->gamma = (png_fixed_point)g;
+   me->this.next = pm->modifications;
+   pm->modifications = &me->this;
+}
+
+typedef struct chrm_modification
+{
+   png_modification          this;
+   const color_encoding *encoding;
+   png_fixed_point           wx, wy, rx, ry, gx, gy, bx, by;
+} chrm_modification;
+
+static int
+chrm_modify(png_modifier *pm, png_modification *me, int add)
+{
+   UNUSED(add)
+   /* As with gAMA this just adds the required cHRM chunk to the buffer. */
+   png_save_uint_32(pm->buffer   , 32);
+   png_save_uint_32(pm->buffer+ 4, CHUNK_cHRM);
+   png_save_uint_32(pm->buffer+ 8, ((chrm_modification*)me)->wx);
+   png_save_uint_32(pm->buffer+12, ((chrm_modification*)me)->wy);
+   png_save_uint_32(pm->buffer+16, ((chrm_modification*)me)->rx);
+   png_save_uint_32(pm->buffer+20, ((chrm_modification*)me)->ry);
+   png_save_uint_32(pm->buffer+24, ((chrm_modification*)me)->gx);
+   png_save_uint_32(pm->buffer+28, ((chrm_modification*)me)->gy);
+   png_save_uint_32(pm->buffer+32, ((chrm_modification*)me)->bx);
+   png_save_uint_32(pm->buffer+36, ((chrm_modification*)me)->by);
+   return 1;
+}
+
+static void
+chrm_modification_init(chrm_modification *me, png_modifier *pm,
+   const color_encoding *encoding)
+{
+   CIE_color white = white_point(encoding);
+
+   /* Original end points: */
+   me->encoding = encoding;
+
+   /* Chromaticities (in fixed point): */
+   me->wx = fix(chromaticity_x(white));
+   me->wy = fix(chromaticity_y(white));
+
+   me->rx = fix(chromaticity_x(encoding->red));
+   me->ry = fix(chromaticity_y(encoding->red));
+   me->gx = fix(chromaticity_x(encoding->green));
+   me->gy = fix(chromaticity_y(encoding->green));
+   me->bx = fix(chromaticity_x(encoding->blue));
+   me->by = fix(chromaticity_y(encoding->blue));
+
+   modification_init(&me->this);
+   me->this.chunk = CHUNK_cHRM;
+   me->this.modify_fn = chrm_modify;
+   me->this.add = CHUNK_PLTE;
+   me->this.next = pm->modifications;
+   pm->modifications = &me->this;
+}
+
+typedef struct srgb_modification
+{
+   png_modification this;
+   png_byte         intent;
+} srgb_modification;
+
+static int
+srgb_modify(png_modifier *pm, png_modification *me, int add)
+{
+   UNUSED(add)
+   /* As above, ignore add and just make a new chunk */
+   png_save_uint_32(pm->buffer, 1);
+   png_save_uint_32(pm->buffer+4, CHUNK_sRGB);
+   pm->buffer[8] = ((srgb_modification*)me)->intent;
+   return 1;
+}
+
+static void
+srgb_modification_init(srgb_modification *me, png_modifier *pm, png_byte intent)
+{
+   modification_init(&me->this);
+   me->this.chunk = CHUNK_sBIT;
+
+   if (intent <= 3) /* if valid, else *delete* sRGB chunks */
+   {
+      me->this.modify_fn = srgb_modify;
+      me->this.add = CHUNK_PLTE;
+      me->intent = intent;
+   }
+
+   else
+   {
+      me->this.modify_fn = 0;
+      me->this.add = 0;
+      me->intent = 0;
+   }
+
+   me->this.next = pm->modifications;
+   pm->modifications = &me->this;
+}
+
+#ifdef PNG_READ_GAMMA_SUPPORTED
+typedef struct sbit_modification
+{
+   png_modification this;
+   png_byte         sbit;
+} sbit_modification;
+
+static int
+sbit_modify(png_modifier *pm, png_modification *me, int add)
+{
+   png_byte sbit = ((sbit_modification*)me)->sbit;
+   if (pm->bit_depth > sbit)
+   {
+      int cb = 0;
+      switch (pm->colour_type)
+      {
+         case 0:
+            cb = 1;
+            break;
+
+         case 2:
+         case 3:
+            cb = 3;
+            break;
+
+         case 4:
+            cb = 2;
+            break;
+
+         case 6:
+            cb = 4;
+            break;
+
+         default:
+            png_error(pm->this.pread,
+               "unexpected colour type in sBIT modification");
+      }
+
+      png_save_uint_32(pm->buffer, cb);
+      png_save_uint_32(pm->buffer+4, CHUNK_sBIT);
+
+      while (cb > 0)
+         (pm->buffer+8)[--cb] = sbit;
+
+      return 1;
+   }
+   else if (!add)
+   {
+      /* Remove the sBIT chunk */
+      pm->buffer_count = pm->buffer_position = 0;
+      return 1;
+   }
+   else
+      return 0; /* do nothing */
+}
+
+static void
+sbit_modification_init(sbit_modification *me, png_modifier *pm, png_byte sbit)
+{
+   modification_init(&me->this);
+   me->this.chunk = CHUNK_sBIT;
+   me->this.modify_fn = sbit_modify;
+   me->this.add = CHUNK_PLTE;
+   me->sbit = sbit;
+   me->this.next = pm->modifications;
+   pm->modifications = &me->this;
+}
+#endif /* PNG_READ_GAMMA_SUPPORTED */
+#endif /* PNG_READ_TRANSFORMS_SUPPORTED */
+
+/***************************** STANDARD PNG FILES *****************************/
+/* Standard files - write and save standard files. */
+/* There are two basic forms of standard images.  Those which attempt to have
+ * all the possible pixel values (not possible for 16bpp images, but a range of
+ * values are produced) and those which have a range of image sizes.  The former
+ * are used for testing transforms, in particular gamma correction and bit
+ * reduction and increase.  The latter are reserved for testing the behavior of
+ * libpng with respect to 'odd' image sizes - particularly small images where
+ * rows become 1 byte and interlace passes disappear.
+ *
+ * The first, most useful, set are the 'transform' images, the second set of
+ * small images are the 'size' images.
+ *
+ * The transform files are constructed with rows which fit into a 1024 byte row
+ * buffer.  This makes allocation easier below.  Further regardless of the file
+ * format every row has 128 pixels (giving 1024 bytes for 64bpp formats).
+ *
+ * Files are stored with no gAMA or sBIT chunks, with a PLTE only when needed
+ * and with an ID derived from the colour type, bit depth and interlace type
+ * as above (FILEID).  The width (128) and height (variable) are not stored in
+ * the FILEID - instead the fields are set to 0, indicating a transform file.
+ *
+ * The size files ar constructed with rows a maximum of 128 bytes wide, allowing
+ * a maximum width of 16 pixels (for the 64bpp case.)  They also have a maximum
+ * height of 16 rows.  The width and height are stored in the FILEID and, being
+ * non-zero, indicate a size file.
+ *
+ * Because the PNG filter code is typically the largest CPU consumer within
+ * libpng itself there is a tendency to attempt to optimize it.  This results in
+ * special case code which needs to be validated.  To cause this to happen the
+ * 'size' images are made to use each possible filter, in so far as this is
+ * possible for smaller images.
+ *
+ * For palette image (colour type 3) multiple transform images are stored with
+ * the same bit depth to allow testing of more colour combinations -
+ * particularly important for testing the gamma code because libpng uses a
+ * different code path for palette images.  For size images a single palette is
+ * used.
+ */
+
+/* Make a 'standard' palette.  Because there are only 256 entries in a palette
+ * (maximum) this actually makes a random palette in the hope that enough tests
+ * will catch enough errors.  (Note that the same palette isn't produced every
+ * time for the same test - it depends on what previous tests have been run -
+ * but a given set of arguments to pngvalid will always produce the same palette
+ * at the same test!  This is why pseudo-random number generators are useful for
+ * testing.)
+ *
+ * The store must be open for write when this is called, otherwise an internal
+ * error will occur.  This routine contains its own magic number seed, so the
+ * palettes generated don't change if there are intervening errors (changing the
+ * calls to the store_mark seed.)
+ */
+static store_palette_entry *
+make_standard_palette(png_store* ps, int npalette, int do_tRNS)
+{
+   static png_uint_32 palette_seed[2] = { 0x87654321, 9 };
+
+   int i = 0;
+   png_byte values[256][4];
+
+   /* Always put in black and white plus the six primary and secondary colors.
+    */
+   for (; i<8; ++i)
+   {
+      values[i][1] = (png_byte)((i&1) ? 255U : 0U);
+      values[i][2] = (png_byte)((i&2) ? 255U : 0U);
+      values[i][3] = (png_byte)((i&4) ? 255U : 0U);
+   }
+
+   /* Then add 62 grays (one quarter of the remaining 256 slots). */
+   {
+      int j = 0;
+      png_byte random_bytes[4];
+      png_byte need[256];
+
+      need[0] = 0; /*got black*/
+      memset(need+1, 1, (sizeof need)-2); /*need these*/
+      need[255] = 0; /*but not white*/
+
+      while (i<70)
+      {
+         png_byte b;
+
+         if (j==0)
+         {
+            make_four_random_bytes(palette_seed, random_bytes);
+            j = 4;
+         }
+
+         b = random_bytes[--j];
+         if (need[b])
+         {
+            values[i][1] = b;
+            values[i][2] = b;
+            values[i++][3] = b;
+         }
+      }
+   }
+
+   /* Finally add 192 colors at random - don't worry about matches to things we
+    * already have, chance is less than 1/65536.  Don't worry about grays,
+    * chance is the same, so we get a duplicate or extra gray less than 1 time
+    * in 170.
+    */
+   for (; i<256; ++i)
+      make_four_random_bytes(palette_seed, values[i]);
+
+   /* Fill in the alpha values in the first byte.  Just use all possible values
+    * (0..255) in an apparently random order:
+    */
+   {
+      store_palette_entry *palette;
+      png_byte selector[4];
+
+      make_four_random_bytes(palette_seed, selector);
+
+      if (do_tRNS)
+         for (i=0; i<256; ++i)
+            values[i][0] = (png_byte)(i ^ selector[0]);
+
+      else
+         for (i=0; i<256; ++i)
+            values[i][0] = 255; /* no transparency/tRNS chunk */
+
+      /* 'values' contains 256 ARGB values, but we only need 'npalette'.
+       * 'npalette' will always be a power of 2: 2, 4, 16 or 256.  In the low
+       * bit depth cases select colors at random, else it is difficult to have
+       * a set of low bit depth palette test with any chance of a reasonable
+       * range of colors.  Do this by randomly permuting values into the low
+       * 'npalette' entries using an XOR mask generated here.  This also
+       * permutes the npalette == 256 case in a potentially useful way (there is
+       * no relationship between palette index and the color value therein!)
+       */
+      palette = store_write_palette(ps, npalette);
+
+      for (i=0; i<npalette; ++i)
+      {
+         palette[i].alpha = values[i ^ selector[1]][0];
+         palette[i].red   = values[i ^ selector[1]][1];
+         palette[i].green = values[i ^ selector[1]][2];
+         palette[i].blue  = values[i ^ selector[1]][3];
+      }
+
+      return palette;
+   }
+}
+
+/* Initialize a standard palette on a write stream.  The 'do_tRNS' argument
+ * indicates whether or not to also set the tRNS chunk.
+ */
+/* TODO: the png_structp here can probably be 'const' in the future */
+static void
+init_standard_palette(png_store *ps, png_structp pp, png_infop pi, int npalette,
+   int do_tRNS)
+{
+   store_palette_entry *ppal = make_standard_palette(ps, npalette, do_tRNS);
+
+   {
+      int i;
+      png_color palette[256];
+
+      /* Set all entries to detect overread errors. */
+      for (i=0; i<npalette; ++i)
+      {
+         palette[i].red = ppal[i].red;
+         palette[i].green = ppal[i].green;
+         palette[i].blue = ppal[i].blue;
+      }
+
+      /* Just in case fill in the rest with detectable values: */
+      for (; i<256; ++i)
+         palette[i].red = palette[i].green = palette[i].blue = 42;
+
+      png_set_PLTE(pp, pi, palette, npalette);
+   }
+
+   if (do_tRNS)
+   {
+      int i, j;
+      png_byte tRNS[256];
+
+      /* Set all the entries, but skip trailing opaque entries */
+      for (i=j=0; i<npalette; ++i)
+         if ((tRNS[i] = ppal[i].alpha) < 255)
+            j = i+1;
+
+      /* Fill in the remainder with a detectable value: */
+      for (; i<256; ++i)
+         tRNS[i] = 24;
+
+#ifdef PNG_WRITE_tRNS_SUPPORTED
+      if (j > 0)
+         png_set_tRNS(pp, pi, tRNS, j, 0/*color*/);
+#endif
+   }
+}
+
+#ifdef PNG_WRITE_tRNS_SUPPORTED
+static void
+set_random_tRNS(png_structp pp, png_infop pi, png_byte colour_type,
+   int bit_depth)
+{
+   /* To make this useful the tRNS color needs to match at least one pixel.
+    * Random values are fine for gray, including the 16-bit case where we know
+    * that the test image contains all the gray values.  For RGB we need more
+    * method as only 65536 different RGB values are generated.
+    */
+   png_color_16 tRNS;
+   png_uint_16 mask = (png_uint_16)((1U << bit_depth)-1);
+
+   R8(tRNS); /* makes unset fields random */
+
+   if (colour_type & 2/*RGB*/)
+   {
+      if (bit_depth == 8)
+      {
+         tRNS.red = random_u16();
+         tRNS.green = random_u16();
+         tRNS.blue = tRNS.red ^ tRNS.green;
+         tRNS.red &= mask;
+         tRNS.green &= mask;
+         tRNS.blue &= mask;
+      }
+
+      else /* bit_depth == 16 */
+      {
+         tRNS.red = random_u16();
+         tRNS.green = (png_uint_16)(tRNS.red * 257);
+         tRNS.blue = (png_uint_16)(tRNS.green * 17);
+      }
+   }
+
+   else
+   {
+      tRNS.gray = random_u16();
+      tRNS.gray &= mask;
+   }
+
+   png_set_tRNS(pp, pi, NULL, 0, &tRNS);
+}
+#endif
+
+/* The number of passes is related to the interlace type. There was no libpng
+ * API to determine this prior to 1.5, so we need an inquiry function:
+ */
+static int
+npasses_from_interlace_type(png_const_structp pp, int interlace_type)
+{
+   switch (interlace_type)
+   {
+   default:
+      png_error(pp, "invalid interlace type");
+
+   case PNG_INTERLACE_NONE:
+      return 1;
+
+   case PNG_INTERLACE_ADAM7:
+      return PNG_INTERLACE_ADAM7_PASSES;
+   }
+}
+
+static unsigned int
+bit_size(png_const_structp pp, png_byte colour_type, png_byte bit_depth)
+{
+   switch (colour_type)
+   {
+      default: png_error(pp, "invalid color type");
+
+      case 0:  return bit_depth;
+
+      case 2:  return 3*bit_depth;
+
+      case 3:  return bit_depth;
+
+      case 4:  return 2*bit_depth;
+
+      case 6:  return 4*bit_depth;
+   }
+}
+
+#define TRANSFORM_WIDTH  128U
+#define TRANSFORM_ROWMAX (TRANSFORM_WIDTH*8U)
+#define SIZE_ROWMAX (16*8U) /* 16 pixels, max 8 bytes each - 128 bytes */
+#define STANDARD_ROWMAX TRANSFORM_ROWMAX /* The larger of the two */
+#define SIZE_HEIGHTMAX 16 /* Maximum range of size images */
+
+static size_t
+transform_rowsize(png_const_structp pp, png_byte colour_type,
+   png_byte bit_depth)
+{
+   return (TRANSFORM_WIDTH * bit_size(pp, colour_type, bit_depth)) / 8;
+}
+
+/* transform_width(pp, colour_type, bit_depth) current returns the same number
+ * every time, so just use a macro:
+ */
+#define transform_width(pp, colour_type, bit_depth) TRANSFORM_WIDTH
+
+static png_uint_32
+transform_height(png_const_structp pp, png_byte colour_type, png_byte bit_depth)
+{
+   switch (bit_size(pp, colour_type, bit_depth))
+   {
+      case 1:
+      case 2:
+      case 4:
+         return 1;   /* Total of 128 pixels */
+
+      case 8:
+         return 2;   /* Total of 256 pixels/bytes */
+
+      case 16:
+         return 512; /* Total of 65536 pixels */
+
+      case 24:
+      case 32:
+         return 512; /* 65536 pixels */
+
+      case 48:
+      case 64:
+         return 2048;/* 4 x 65536 pixels. */
+#        define TRANSFORM_HEIGHTMAX 2048
+
+      default:
+         return 0;   /* Error, will be caught later */
+   }
+}
+
+#ifdef PNG_READ_SUPPORTED
+/* The following can only be defined here, now we have the definitions
+ * of the transform image sizes.
+ */
+static png_uint_32
+standard_width(png_const_structp pp, png_uint_32 id)
+{
+   png_uint_32 width = WIDTH_FROM_ID(id);
+   UNUSED(pp)
+
+   if (width == 0)
+      width = transform_width(pp, COL_FROM_ID(id), DEPTH_FROM_ID(id));
+
+   return width;
+}
+
+static png_uint_32
+standard_height(png_const_structp pp, png_uint_32 id)
+{
+   png_uint_32 height = HEIGHT_FROM_ID(id);
+
+   if (height == 0)
+      height = transform_height(pp, COL_FROM_ID(id), DEPTH_FROM_ID(id));
+
+   return height;
+}
+
+static png_uint_32
+standard_rowsize(png_const_structp pp, png_uint_32 id)
+{
+   png_uint_32 width = standard_width(pp, id);
+
+   /* This won't overflow: */
+   width *= bit_size(pp, COL_FROM_ID(id), DEPTH_FROM_ID(id));
+   return (width + 7) / 8;
+}
+#endif /* PNG_READ_SUPPORTED */
+
+static void
+transform_row(png_const_structp pp, png_byte buffer[TRANSFORM_ROWMAX],
+   png_byte colour_type, png_byte bit_depth, png_uint_32 y)
+{
+   png_uint_32 v = y << 7;
+   png_uint_32 i = 0;
+
+   switch (bit_size(pp, colour_type, bit_depth))
+   {
+      case 1:
+         while (i<128/8) buffer[i] = (png_byte)(v & 0xff), v += 17, ++i;
+         return;
+
+      case 2:
+         while (i<128/4) buffer[i] = (png_byte)(v & 0xff), v += 33, ++i;
+         return;
+
+      case 4:
+         while (i<128/2) buffer[i] = (png_byte)(v & 0xff), v += 65, ++i;
+         return;
+
+      case 8:
+         /* 256 bytes total, 128 bytes in each row set as follows: */
+         while (i<128) buffer[i] = (png_byte)(v & 0xff), ++v, ++i;
+         return;
+
+      case 16:
+         /* Generate all 65536 pixel values in order, which includes the 8 bit
+          * GA case as well as the 16 bit G case.
+          */
+         while (i<128)
+         {
+            buffer[2*i] = (png_byte)((v>>8) & 0xff);
+            buffer[2*i+1] = (png_byte)(v & 0xff);
+            ++v;
+            ++i;
+         }
+
+         return;
+
+      case 24:
+         /* 65535 pixels, but rotate the values. */
+         while (i<128)
+         {
+            /* Three bytes per pixel, r, g, b, make b by r^g */
+            buffer[3*i+0] = (png_byte)((v >> 8) & 0xff);
+            buffer[3*i+1] = (png_byte)(v & 0xff);
+            buffer[3*i+2] = (png_byte)(((v >> 8) ^ v) & 0xff);
+            ++v;
+            ++i;
+         }
+
+         return;
+
+      case 32:
+         /* 65535 pixels, r, g, b, a; just replicate */
+         while (i<128)
+         {
+            buffer[4*i+0] = (png_byte)((v >> 8) & 0xff);
+            buffer[4*i+1] = (png_byte)(v & 0xff);
+            buffer[4*i+2] = (png_byte)((v >> 8) & 0xff);
+            buffer[4*i+3] = (png_byte)(v & 0xff);
+            ++v;
+            ++i;
+         }
+
+         return;
+
+      case 48:
+         /* y is maximum 2047, giving 4x65536 pixels, make 'r' increase by 1 at
+          * each pixel, g increase by 257 (0x101) and 'b' by 0x1111:
+          */
+         while (i<128)
+         {
+            png_uint_32 t = v++;
+            buffer[6*i+0] = (png_byte)((t >> 8) & 0xff);
+            buffer[6*i+1] = (png_byte)(t & 0xff);
+            t *= 257;
+            buffer[6*i+2] = (png_byte)((t >> 8) & 0xff);
+            buffer[6*i+3] = (png_byte)(t & 0xff);
+            t *= 17;
+            buffer[6*i+4] = (png_byte)((t >> 8) & 0xff);
+            buffer[6*i+5] = (png_byte)(t & 0xff);
+            ++i;
+         }
+
+         return;
+
+      case 64:
+         /* As above in the 32 bit case. */
+         while (i<128)
+         {
+            png_uint_32 t = v++;
+            buffer[8*i+0] = (png_byte)((t >> 8) & 0xff);
+            buffer[8*i+1] = (png_byte)(t & 0xff);
+            buffer[8*i+4] = (png_byte)((t >> 8) & 0xff);
+            buffer[8*i+5] = (png_byte)(t & 0xff);
+            t *= 257;
+            buffer[8*i+2] = (png_byte)((t >> 8) & 0xff);
+            buffer[8*i+3] = (png_byte)(t & 0xff);
+            buffer[8*i+6] = (png_byte)((t >> 8) & 0xff);
+            buffer[8*i+7] = (png_byte)(t & 0xff);
+            ++i;
+         }
+         return;
+
+      default:
+         break;
+   }
+
+   png_error(pp, "internal error");
+}
+
+/* This is just to do the right cast - could be changed to a function to check
+ * 'bd' but there isn't much point.
+ */
+#define DEPTH(bd) ((png_byte)(1U << (bd)))
+
+/* This is just a helper for compiling on minimal systems with no write
+ * interlacing support.  If there is no write interlacing we can't generate test
+ * cases with interlace:
+ */
+#ifdef PNG_WRITE_INTERLACING_SUPPORTED
+#  define INTERLACE_LAST PNG_INTERLACE_LAST
+#  define check_interlace_type(type) ((void)(type))
+#  define set_write_interlace_handling(pp,type) png_set_interlace_handling(pp)
+#  define do_own_interlace 0
+#elif PNG_LIBPNG_VER < 10700
+#  define set_write_interlace_handling(pp,type) (1)
+static void
+check_interlace_type(int const interlace_type)
+{
+   /* Prior to 1.7.0 libpng does not support the write of an interlaced image
+    * unless PNG_WRITE_INTERLACING_SUPPORTED, even with do_interlace so the
+    * code here does the pixel interlace itself, so:
+    */
+   if (interlace_type != PNG_INTERLACE_NONE)
+   {
+      /* This is an internal error - --interlace tests should be skipped, not
+       * attempted.
+       */
+      fprintf(stderr, "pngvalid: no interlace support\n");
+      exit(99);
+   }
+}
+#  define INTERLACE_LAST (PNG_INTERLACE_NONE+1)
+#  define do_own_interlace 0
+#else /* libpng 1.7+ */
+#  define set_write_interlace_handling(pp,type)\
+      npasses_from_interlace_type(pp,type)
+#  define check_interlace_type(type) ((void)(type))
+#  define INTERLACE_LAST PNG_INTERLACE_LAST
+#  define do_own_interlace 1
+#endif /* WRITE_INTERLACING tests */
+
+#if PNG_LIBPNG_VER >= 10700 || defined PNG_WRITE_INTERLACING_SUPPORTED
+#   define CAN_WRITE_INTERLACE 1
+#else
+#   define CAN_WRITE_INTERLACE 0
+#endif
+
+/* Do the same thing for read interlacing; this controls whether read tests do
+ * their own de-interlace or use libpng.
+ */
+#ifdef PNG_READ_INTERLACING_SUPPORTED
+#  define do_read_interlace 0
+#else /* no libpng read interlace support */
+#  define do_read_interlace 1
+#endif
+/* The following two routines use the PNG interlace support macros from
+ * png.h to interlace or deinterlace rows.
+ */
+static void
+interlace_row(png_bytep buffer, png_const_bytep imageRow,
+   unsigned int pixel_size, png_uint_32 w, int pass, int littleendian)
+{
+   png_uint_32 xin, xout, xstep;
+
+   /* Note that this can, trivially, be optimized to a memcpy on pass 7, the
+    * code is presented this way to make it easier to understand.  In practice
+    * consult the code in the libpng source to see other ways of doing this.
+    *
+    * It is OK for buffer and imageRow to be identical, because 'xin' moves
+    * faster than 'xout' and we copy up.
+    */
+   xin = PNG_PASS_START_COL(pass);
+   xstep = 1U<<PNG_PASS_COL_SHIFT(pass);
+
+   for (xout=0; xin<w; xin+=xstep)
+   {
+      pixel_copy(buffer, xout, imageRow, xin, pixel_size, littleendian);
+      ++xout;
+   }
+}
+
+#ifdef PNG_READ_SUPPORTED
+static void
+deinterlace_row(png_bytep buffer, png_const_bytep row,
+   unsigned int pixel_size, png_uint_32 w, int pass, int littleendian)
+{
+   /* The inverse of the above, 'row' is part of row 'y' of the output image,
+    * in 'buffer'.  The image is 'w' wide and this is pass 'pass', distribute
+    * the pixels of row into buffer and return the number written (to allow
+    * this to be checked).
+    */
+   png_uint_32 xin, xout, xstep;
+
+   xout = PNG_PASS_START_COL(pass);
+   xstep = 1U<<PNG_PASS_COL_SHIFT(pass);
+
+   for (xin=0; xout<w; xout+=xstep)
+   {
+      pixel_copy(buffer, xout, row, xin, pixel_size, littleendian);
+      ++xin;
+   }
+}
+#endif /* PNG_READ_SUPPORTED */
+
+/* Make a standardized image given an image colour type, bit depth and
+ * interlace type.  The standard images have a very restricted range of
+ * rows and heights and are used for testing transforms rather than image
+ * layout details.  See make_size_images below for a way to make images
+ * that test odd sizes along with the libpng interlace handling.
+ */
+#ifdef PNG_WRITE_FILTER_SUPPORTED
+static void
+choose_random_filter(png_structp pp, int start)
+{
+   /* Choose filters randomly except that on the very first row ensure that
+    * there is at least one previous row filter.
+    */
+   int filters = PNG_ALL_FILTERS & random_mod(256U);
+
+   /* There may be no filters; skip the setting. */
+   if (filters != 0)
+   {
+      if (start && filters < PNG_FILTER_UP)
+         filters |= PNG_FILTER_UP;
+
+      png_set_filter(pp, 0/*method*/, filters);
+   }
+}
+#else /* !WRITE_FILTER */
+#  define choose_random_filter(pp, start) ((void)0)
+#endif /* !WRITE_FILTER */
+
+static void
+make_transform_image(png_store* const ps, png_byte const colour_type,
+    png_byte const bit_depth, unsigned int palette_number,
+    int interlace_type, png_const_charp name)
+{
+   context(ps, fault);
+
+   check_interlace_type(interlace_type);
+
+   Try
+   {
+      png_infop pi;
+      png_structp pp = set_store_for_write(ps, &pi, name);
+      png_uint_32 h, w;
+
+      /* In the event of a problem return control to the Catch statement below
+       * to do the clean up - it is not possible to 'return' directly from a Try
+       * block.
+       */
+      if (pp == NULL)
+         Throw ps;
+
+      w = transform_width(pp, colour_type, bit_depth);
+      h = transform_height(pp, colour_type, bit_depth);
+
+      png_set_IHDR(pp, pi, w, h, bit_depth, colour_type, interlace_type,
+         PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
+
+#ifdef PNG_TEXT_SUPPORTED
+#  if defined(PNG_READ_zTXt_SUPPORTED) && defined(PNG_WRITE_zTXt_SUPPORTED)
+#     define TEXT_COMPRESSION PNG_TEXT_COMPRESSION_zTXt
+#  else
+#     define TEXT_COMPRESSION PNG_TEXT_COMPRESSION_NONE
+#  endif
+      {
+         static char key[] = "image name"; /* must be writeable */
+         size_t pos;
+         png_text text;
+         char copy[FILE_NAME_SIZE];
+
+         /* Use a compressed text string to test the correct interaction of text
+          * compression and IDAT compression.
+          */
+         text.compression = TEXT_COMPRESSION;
+         text.key = key;
+         /* Yuck: the text must be writable! */
+         pos = safecat(copy, sizeof copy, 0, ps->wname);
+         text.text = copy;
+         text.text_length = pos;
+         text.itxt_length = 0;
+         text.lang = 0;
+         text.lang_key = 0;
+
+         png_set_text(pp, pi, &text, 1);
+      }
+#endif
+
+      if (colour_type == 3) /* palette */
+         init_standard_palette(ps, pp, pi, 1U << bit_depth, 1/*do tRNS*/);
+
+#     ifdef PNG_WRITE_tRNS_SUPPORTED
+         else if (palette_number)
+            set_random_tRNS(pp, pi, colour_type, bit_depth);
+#     endif
+
+      png_write_info(pp, pi);
+
+      if (png_get_rowbytes(pp, pi) !=
+          transform_rowsize(pp, colour_type, bit_depth))
+         png_error(pp, "transform row size incorrect");
+
+      else
+      {
+         /* Somewhat confusingly this must be called *after* png_write_info
+          * because if it is called before, the information in *pp has not been
+          * updated to reflect the interlaced image.
+          */
+         int npasses = set_write_interlace_handling(pp, interlace_type);
+         int pass;
+
+         if (npasses != npasses_from_interlace_type(pp, interlace_type))
+            png_error(pp, "write: png_set_interlace_handling failed");
+
+         for (pass=0; pass<npasses; ++pass)
+         {
+            png_uint_32 y;
+
+            /* do_own_interlace is a pre-defined boolean (a #define) which is
+             * set if we have to work out the interlaced rows here.
+             */
+            for (y=0; y<h; ++y)
+            {
+               png_byte buffer[TRANSFORM_ROWMAX];
+
+               transform_row(pp, buffer, colour_type, bit_depth, y);
+
+#              if do_own_interlace
+                  /* If do_own_interlace *and* the image is interlaced we need a
+                   * reduced interlace row; this may be reduced to empty.
+                   */
+                  if (interlace_type == PNG_INTERLACE_ADAM7)
+                  {
+                     /* The row must not be written if it doesn't exist, notice
+                      * that there are two conditions here, either the row isn't
+                      * ever in the pass or the row would be but isn't wide
+                      * enough to contribute any pixels.  In fact the wPass test
+                      * can be used to skip the whole y loop in this case.
+                      */
+                     if (PNG_ROW_IN_INTERLACE_PASS(y, pass) &&
+                         PNG_PASS_COLS(w, pass) > 0)
+                        interlace_row(buffer, buffer,
+                              bit_size(pp, colour_type, bit_depth), w, pass,
+                              0/*data always bigendian*/);
+                     else
+                        continue;
+                  }
+#              endif /* do_own_interlace */
+
+               choose_random_filter(pp, pass == 0 && y == 0);
+               png_write_row(pp, buffer);
+            }
+         }
+      }
+
+#ifdef PNG_TEXT_SUPPORTED
+      {
+         static char key[] = "end marker";
+         static char comment[] = "end";
+         png_text text;
+
+         /* Use a compressed text string to test the correct interaction of text
+          * compression and IDAT compression.
+          */
+         text.compression = TEXT_COMPRESSION;
+         text.key = key;
+         text.text = comment;
+         text.text_length = (sizeof comment)-1;
+         text.itxt_length = 0;
+         text.lang = 0;
+         text.lang_key = 0;
+
+         png_set_text(pp, pi, &text, 1);
+      }
+#endif
+
+      png_write_end(pp, pi);
+
+      /* And store this under the appropriate id, then clean up. */
+      store_storefile(ps, FILEID(colour_type, bit_depth, palette_number,
+         interlace_type, 0, 0, 0));
+
+      store_write_reset(ps);
+   }
+
+   Catch(fault)
+   {
+      /* Use the png_store returned by the exception. This may help the compiler
+       * because 'ps' is not used in this branch of the setjmp.  Note that fault
+       * and ps will always be the same value.
+       */
+      store_write_reset(fault);
+   }
+}
+
+static void
+make_transform_images(png_modifier *pm)
+{
+   png_byte colour_type = 0;
+   png_byte bit_depth = 0;
+   unsigned int palette_number = 0;
+
+   /* This is in case of errors. */
+   safecat(pm->this.test, sizeof pm->this.test, 0, "make standard images");
+
+   /* Use next_format to enumerate all the combinations we test, including
+    * generating multiple low bit depth palette images. Non-A images (palette
+    * and direct) are created with and without tRNS chunks.
+    */
+   while (next_format(&colour_type, &bit_depth, &palette_number, 1, 1))
+   {
+      int interlace_type;
+
+      for (interlace_type = PNG_INTERLACE_NONE;
+           interlace_type < INTERLACE_LAST; ++interlace_type)
+      {
+         char name[FILE_NAME_SIZE];
+
+         standard_name(name, sizeof name, 0, colour_type, bit_depth,
+            palette_number, interlace_type, 0, 0, do_own_interlace);
+         make_transform_image(&pm->this, colour_type, bit_depth, palette_number,
+            interlace_type, name);
+      }
+   }
+}
+
+/* Build a single row for the 'size' test images; this fills in only the
+ * first bit_width bits of the sample row.
+ */
+static void
+size_row(png_byte buffer[SIZE_ROWMAX], png_uint_32 bit_width, png_uint_32 y)
+{
+   /* height is in the range 1 to 16, so: */
+   y = ((y & 1) << 7) + ((y & 2) << 6) + ((y & 4) << 5) + ((y & 8) << 4);
+   /* the following ensures bits are set in small images: */
+   y ^= 0xA5;
+
+   while (bit_width >= 8)
+      *buffer++ = (png_byte)y++, bit_width -= 8;
+
+   /* There may be up to 7 remaining bits, these go in the most significant
+    * bits of the byte.
+    */
+   if (bit_width > 0)
+   {
+      png_uint_32 mask = (1U<<(8-bit_width))-1;
+      *buffer = (png_byte)((*buffer & mask) | (y & ~mask));
+   }
+}
+
+static void
+make_size_image(png_store* const ps, png_byte const colour_type,
+    png_byte const bit_depth, int const interlace_type,
+    png_uint_32 const w, png_uint_32 const h,
+    int const do_interlace)
+{
+   context(ps, fault);
+
+   check_interlace_type(interlace_type);
+
+   Try
+   {
+      png_infop pi;
+      png_structp pp;
+      unsigned int pixel_size;
+
+      /* Make a name and get an appropriate id for the store: */
+      char name[FILE_NAME_SIZE];
+      png_uint_32 id = FILEID(colour_type, bit_depth, 0/*palette*/,
+         interlace_type, w, h, do_interlace);
+
+      standard_name_from_id(name, sizeof name, 0, id);
+      pp = set_store_for_write(ps, &pi, name);
+
+      /* In the event of a problem return control to the Catch statement below
+       * to do the clean up - it is not possible to 'return' directly from a Try
+       * block.
+       */
+      if (pp == NULL)
+         Throw ps;
+
+      png_set_IHDR(pp, pi, w, h, bit_depth, colour_type, interlace_type,
+         PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
+
+#ifdef PNG_TEXT_SUPPORTED
+      {
+         static char key[] = "image name"; /* must be writeable */
+         size_t pos;
+         png_text text;
+         char copy[FILE_NAME_SIZE];
+
+         /* Use a compressed text string to test the correct interaction of text
+          * compression and IDAT compression.
+          */
+         text.compression = TEXT_COMPRESSION;
+         text.key = key;
+         /* Yuck: the text must be writable! */
+         pos = safecat(copy, sizeof copy, 0, ps->wname);
+         text.text = copy;
+         text.text_length = pos;
+         text.itxt_length = 0;
+         text.lang = 0;
+         text.lang_key = 0;
+
+         png_set_text(pp, pi, &text, 1);
+      }
+#endif
+
+      if (colour_type == 3) /* palette */
+         init_standard_palette(ps, pp, pi, 1U << bit_depth, 0/*do tRNS*/);
+
+      png_write_info(pp, pi);
+
+      /* Calculate the bit size, divide by 8 to get the byte size - this won't
+       * overflow because we know the w values are all small enough even for
+       * a system where 'unsigned int' is only 16 bits.
+       */
+      pixel_size = bit_size(pp, colour_type, bit_depth);
+      if (png_get_rowbytes(pp, pi) != ((w * pixel_size) + 7) / 8)
+         png_error(pp, "size row size incorrect");
+
+      else
+      {
+         int npasses = npasses_from_interlace_type(pp, interlace_type);
+         png_uint_32 y;
+         int pass;
+         png_byte image[16][SIZE_ROWMAX];
+
+         /* To help consistent error detection make the parts of this buffer
+          * that aren't set below all '1':
+          */
+         memset(image, 0xff, sizeof image);
+
+         if (!do_interlace &&
+             npasses != set_write_interlace_handling(pp, interlace_type))
+            png_error(pp, "write: png_set_interlace_handling failed");
+
+         /* Prepare the whole image first to avoid making it 7 times: */
+         for (y=0; y<h; ++y)
+            size_row(image[y], w * pixel_size, y);
+
+         for (pass=0; pass<npasses; ++pass)
+         {
+            /* The following two are for checking the macros: */
+            png_uint_32 wPass = PNG_PASS_COLS(w, pass);
+
+            /* If do_interlace is set we don't call png_write_row for every
+             * row because some of them are empty.  In fact, for a 1x1 image,
+             * most of them are empty!
+             */
+            for (y=0; y<h; ++y)
+            {
+               png_const_bytep row = image[y];
+               png_byte tempRow[SIZE_ROWMAX];
+
+               /* If do_interlace *and* the image is interlaced we
+                * need a reduced interlace row; this may be reduced
+                * to empty.
+                */
+               if (do_interlace && interlace_type == PNG_INTERLACE_ADAM7)
+               {
+                  /* The row must not be written if it doesn't exist, notice
+                   * that there are two conditions here, either the row isn't
+                   * ever in the pass or the row would be but isn't wide
+                   * enough to contribute any pixels.  In fact the wPass test
+                   * can be used to skip the whole y loop in this case.
+                   */
+                  if (PNG_ROW_IN_INTERLACE_PASS(y, pass) && wPass > 0)
+                  {
+                     /* Set to all 1's for error detection (libpng tends to
+                      * set unset things to 0).
+                      */
+                     memset(tempRow, 0xff, sizeof tempRow);
+                     interlace_row(tempRow, row, pixel_size, w, pass,
+                           0/*data always bigendian*/);
+                     row = tempRow;
+                  }
+                  else
+                     continue;
+               }
+
+#           ifdef PNG_WRITE_FILTER_SUPPORTED
+               /* Only get to here if the row has some pixels in it, set the
+                * filters to 'all' for the very first row and thereafter to a
+                * single filter.  It isn't well documented, but png_set_filter
+                * does accept a filter number (per the spec) as well as a bit
+                * mask.
+                *
+                * The code now uses filters at random, except that on the first
+                * row of an image it ensures that a previous row filter is in
+                * the set so that libpng allocates the row buffer.
+                */
+               {
+                  int filters = 8 << random_mod(PNG_FILTER_VALUE_LAST);
+
+                  if (pass == 0 && y == 0 &&
+                      (filters < PNG_FILTER_UP || w == 1U))
+                     filters |= PNG_FILTER_UP;
+
+                  png_set_filter(pp, 0/*method*/, filters);
+               }
+#           endif
+
+               png_write_row(pp, row);
+            }
+         }
+      }
+
+#ifdef PNG_TEXT_SUPPORTED
+      {
+         static char key[] = "end marker";
+         static char comment[] = "end";
+         png_text text;
+
+         /* Use a compressed text string to test the correct interaction of text
+          * compression and IDAT compression.
+          */
+         text.compression = TEXT_COMPRESSION;
+         text.key = key;
+         text.text = comment;
+         text.text_length = (sizeof comment)-1;
+         text.itxt_length = 0;
+         text.lang = 0;
+         text.lang_key = 0;
+
+         png_set_text(pp, pi, &text, 1);
+      }
+#endif
+
+      png_write_end(pp, pi);
+
+      /* And store this under the appropriate id, then clean up. */
+      store_storefile(ps, id);
+
+      store_write_reset(ps);
+   }
+
+   Catch(fault)
+   {
+      /* Use the png_store returned by the exception. This may help the compiler
+       * because 'ps' is not used in this branch of the setjmp.  Note that fault
+       * and ps will always be the same value.
+       */
+      store_write_reset(fault);
+   }
+}
+
+static void
+make_size(png_store* const ps, png_byte const colour_type, int bdlo,
+    int const bdhi)
+{
+   for (; bdlo <= bdhi; ++bdlo)
+   {
+      png_uint_32 width;
+
+      for (width = 1; width <= 16; ++width)
+      {
+         png_uint_32 height;
+
+         for (height = 1; height <= 16; ++height)
+         {
+            /* The four combinations of DIY interlace and interlace or not -
+             * no interlace + DIY should be identical to no interlace with
+             * libpng doing it.
+             */
+            make_size_image(ps, colour_type, DEPTH(bdlo), PNG_INTERLACE_NONE,
+               width, height, 0);
+            make_size_image(ps, colour_type, DEPTH(bdlo), PNG_INTERLACE_NONE,
+               width, height, 1);
+#        ifdef PNG_WRITE_INTERLACING_SUPPORTED
+            make_size_image(ps, colour_type, DEPTH(bdlo), PNG_INTERLACE_ADAM7,
+               width, height, 0);
+#        endif
+#        if CAN_WRITE_INTERLACE
+            /* 1.7.0 removes the hack that prevented app write of an interlaced
+             * image if WRITE_INTERLACE was not supported
+             */
+            make_size_image(ps, colour_type, DEPTH(bdlo), PNG_INTERLACE_ADAM7,
+               width, height, 1);
+#        endif
+         }
+      }
+   }
+}
+
+static void
+make_size_images(png_store *ps)
+{
+   /* This is in case of errors. */
+   safecat(ps->test, sizeof ps->test, 0, "make size images");
+
+   /* Arguments are colour_type, low bit depth, high bit depth
+    */
+   make_size(ps, 0, 0, WRITE_BDHI);
+   make_size(ps, 2, 3, WRITE_BDHI);
+   make_size(ps, 3, 0, 3 /*palette: max 8 bits*/);
+   make_size(ps, 4, 3, WRITE_BDHI);
+   make_size(ps, 6, 3, WRITE_BDHI);
+}
+
+#ifdef PNG_READ_SUPPORTED
+/* Return a row based on image id and 'y' for checking: */
+static void
+standard_row(png_const_structp pp, png_byte std[STANDARD_ROWMAX],
+   png_uint_32 id, png_uint_32 y)
+{
+   if (WIDTH_FROM_ID(id) == 0)
+      transform_row(pp, std, COL_FROM_ID(id), DEPTH_FROM_ID(id), y);
+   else
+      size_row(std, WIDTH_FROM_ID(id) * bit_size(pp, COL_FROM_ID(id),
+         DEPTH_FROM_ID(id)), y);
+}
+#endif /* PNG_READ_SUPPORTED */
+
+/* Tests - individual test cases */
+/* Like 'make_standard' but errors are deliberately introduced into the calls
+ * to ensure that they get detected - it should not be possible to write an
+ * invalid image with libpng!
+ */
+/* TODO: the 'set' functions can probably all be made to take a
+ * png_const_structp rather than a modifiable one.
+ */
+#ifdef PNG_WARNINGS_SUPPORTED
+static void
+sBIT0_error_fn(png_structp pp, png_infop pi)
+{
+   /* 0 is invalid... */
+   png_color_8 bad;
+   bad.red = bad.green = bad.blue = bad.gray = bad.alpha = 0;
+   png_set_sBIT(pp, pi, &bad);
+}
+
+static void
+sBIT_error_fn(png_structp pp, png_infop pi)
+{
+   png_byte bit_depth;
+   png_color_8 bad;
+
+   if (png_get_color_type(pp, pi) == PNG_COLOR_TYPE_PALETTE)
+      bit_depth = 8;
+
+   else
+      bit_depth = png_get_bit_depth(pp, pi);
+
+   /* Now we know the bit depth we can easily generate an invalid sBIT entry */
+   bad.red = bad.green = bad.blue = bad.gray = bad.alpha =
+      (png_byte)(bit_depth+1);
+   png_set_sBIT(pp, pi, &bad);
+}
+
+static const struct
+{
+   void          (*fn)(png_structp, png_infop);
+   const char *msg;
+   unsigned int    warning :1; /* the error is a warning... */
+} error_test[] =
+    {
+       /* no warnings makes these errors undetectable prior to 1.7.0 */
+       { sBIT0_error_fn, "sBIT(0): failed to detect error",
+         PNG_LIBPNG_VER < 10700 },
+
+       { sBIT_error_fn, "sBIT(too big): failed to detect error",
+         PNG_LIBPNG_VER < 10700 },
+    };
+
+static void
+make_error(png_store* const ps, png_byte const colour_type,
+    png_byte bit_depth, int interlace_type, int test, png_const_charp name)
+{
+   context(ps, fault);
+
+   check_interlace_type(interlace_type);
+
+   Try
+   {
+      png_infop pi;
+      png_structp pp = set_store_for_write(ps, &pi, name);
+      png_uint_32 w, h;
+      gnu_volatile(pp)
+
+      if (pp == NULL)
+         Throw ps;
+
+      w = transform_width(pp, colour_type, bit_depth);
+      gnu_volatile(w)
+      h = transform_height(pp, colour_type, bit_depth);
+      gnu_volatile(h)
+      png_set_IHDR(pp, pi, w, h, bit_depth, colour_type, interlace_type,
+            PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
+
+      if (colour_type == 3) /* palette */
+         init_standard_palette(ps, pp, pi, 1U << bit_depth, 0/*do tRNS*/);
+
+      /* Time for a few errors; these are in various optional chunks, the
+       * standard tests test the standard chunks pretty well.
+       */
+#     define exception__prev exception_prev_1
+#     define exception__env exception_env_1
+      Try
+      {
+         gnu_volatile(exception__prev)
+
+         /* Expect this to throw: */
+         ps->expect_error = !error_test[test].warning;
+         ps->expect_warning = error_test[test].warning;
+         ps->saw_warning = 0;
+         error_test[test].fn(pp, pi);
+
+         /* Normally the error is only detected here: */
+         png_write_info(pp, pi);
+
+         /* And handle the case where it was only a warning: */
+         if (ps->expect_warning && ps->saw_warning)
+            Throw ps;
+
+         /* If we get here there is a problem, we have success - no error or
+          * no warning - when we shouldn't have success.  Log an error.
+          */
+         store_log(ps, pp, error_test[test].msg, 1 /*error*/);
+      }
+
+      Catch (fault)
+      { /* expected exit */
+      }
+#undef exception__prev
+#undef exception__env
+
+      /* And clear these flags */
+      ps->expect_warning = 0;
+
+      if (ps->expect_error)
+         ps->expect_error = 0;
+
+      else
+      {
+         /* Now write the whole image, just to make sure that the detected, or
+          * undetected, error has not created problems inside libpng.  This
+          * doesn't work if there was a png_error in png_write_info because that
+          * can abort before PLTE was written.
+          */
+         if (png_get_rowbytes(pp, pi) !=
+             transform_rowsize(pp, colour_type, bit_depth))
+            png_error(pp, "row size incorrect");
+
+         else
+         {
+            int npasses = set_write_interlace_handling(pp, interlace_type);
+            int pass;
+
+            if (npasses != npasses_from_interlace_type(pp, interlace_type))
+               png_error(pp, "write: png_set_interlace_handling failed");
+
+            for (pass=0; pass<npasses; ++pass)
+            {
+               png_uint_32 y;
+
+               for (y=0; y<h; ++y)
+               {
+                  png_byte buffer[TRANSFORM_ROWMAX];
+
+                  transform_row(pp, buffer, colour_type, bit_depth, y);
+
+#                 if do_own_interlace
+                     /* If do_own_interlace *and* the image is interlaced we
+                      * need a reduced interlace row; this may be reduced to
+                      * empty.
+                      */
+                     if (interlace_type == PNG_INTERLACE_ADAM7)
+                     {
+                        /* The row must not be written if it doesn't exist,
+                         * notice that there are two conditions here, either the
+                         * row isn't ever in the pass or the row would be but
+                         * isn't wide enough to contribute any pixels.  In fact
+                         * the wPass test can be used to skip the whole y loop
+                         * in this case.
+                         */
+                        if (PNG_ROW_IN_INTERLACE_PASS(y, pass) &&
+                            PNG_PASS_COLS(w, pass) > 0)
+                           interlace_row(buffer, buffer,
+                                 bit_size(pp, colour_type, bit_depth), w, pass,
+                                 0/*data always bigendian*/);
+                        else
+                           continue;
+                     }
+#                 endif /* do_own_interlace */
+
+                  png_write_row(pp, buffer);
+               }
+            }
+         } /* image writing */
+
+         png_write_end(pp, pi);
+      }
+
+      /* The following deletes the file that was just written. */
+      store_write_reset(ps);
+   }
+
+   Catch(fault)
+   {
+      store_write_reset(fault);
+   }
+}
+
+static int
+make_errors(png_modifier* const pm, png_byte const colour_type,
+    int bdlo, int const bdhi)
+{
+   for (; bdlo <= bdhi; ++bdlo)
+   {
+      int interlace_type;
+
+      for (interlace_type = PNG_INTERLACE_NONE;
+           interlace_type < INTERLACE_LAST; ++interlace_type)
+      {
+         unsigned int test;
+         char name[FILE_NAME_SIZE];
+
+         standard_name(name, sizeof name, 0, colour_type, 1<<bdlo, 0,
+            interlace_type, 0, 0, do_own_interlace);
+
+         for (test=0; test<ARRAY_SIZE(error_test); ++test)
+         {
+            make_error(&pm->this, colour_type, DEPTH(bdlo), interlace_type,
+               test, name);
+
+            if (fail(pm))
+               return 0;
+         }
+      }
+   }
+
+   return 1; /* keep going */
+}
+#endif /* PNG_WARNINGS_SUPPORTED */
+
+static void
+perform_error_test(png_modifier *pm)
+{
+#ifdef PNG_WARNINGS_SUPPORTED /* else there are no cases that work! */
+   /* Need to do this here because we just write in this test. */
+   safecat(pm->this.test, sizeof pm->this.test, 0, "error test");
+
+   if (!make_errors(pm, 0, 0, WRITE_BDHI))
+      return;
+
+   if (!make_errors(pm, 2, 3, WRITE_BDHI))
+      return;
+
+   if (!make_errors(pm, 3, 0, 3))
+      return;
+
+   if (!make_errors(pm, 4, 3, WRITE_BDHI))
+      return;
+
+   if (!make_errors(pm, 6, 3, WRITE_BDHI))
+      return;
+#else
+   UNUSED(pm)
+#endif
+}
+
+/* This is just to validate the internal PNG formatting code - if this fails
+ * then the warning messages the library outputs will probably be garbage.
+ */
+static void
+perform_formatting_test(png_store *ps)
+{
+#ifdef PNG_TIME_RFC1123_SUPPORTED
+   /* The handle into the formatting code is the RFC1123 support; this test does
+    * nothing if that is compiled out.
+    */
+   context(ps, fault);
+
+   Try
+   {
+      png_const_charp correct = "29 Aug 2079 13:53:60 +0000";
+      png_const_charp result;
+#     if PNG_LIBPNG_VER >= 10600
+         char timestring[29];
+#     endif
+      png_structp pp;
+      png_time pt;
+
+      pp = set_store_for_write(ps, NULL, "libpng formatting test");
+
+      if (pp == NULL)
+         Throw ps;
+
+
+      /* Arbitrary settings: */
+      pt.year = 2079;
+      pt.month = 8;
+      pt.day = 29;
+      pt.hour = 13;
+      pt.minute = 53;
+      pt.second = 60; /* a leap second */
+
+#     if PNG_LIBPNG_VER < 10600
+         result = png_convert_to_rfc1123(pp, &pt);
+#     else
+         if (png_convert_to_rfc1123_buffer(timestring, &pt))
+            result = timestring;
+
+         else
+            result = NULL;
+#     endif
+
+      if (result == NULL)
+         png_error(pp, "png_convert_to_rfc1123 failed");
+
+      if (strcmp(result, correct) != 0)
+      {
+         size_t pos = 0;
+         char msg[128];
+
+         pos = safecat(msg, sizeof msg, pos, "png_convert_to_rfc1123(");
+         pos = safecat(msg, sizeof msg, pos, correct);
+         pos = safecat(msg, sizeof msg, pos, ") returned: '");
+         pos = safecat(msg, sizeof msg, pos, result);
+         pos = safecat(msg, sizeof msg, pos, "'");
+
+         png_error(pp, msg);
+      }
+
+      store_write_reset(ps);
+   }
+
+   Catch(fault)
+   {
+      store_write_reset(fault);
+   }
+#else
+   UNUSED(ps)
+#endif
+}
+
+#ifdef PNG_READ_SUPPORTED
+/* Because we want to use the same code in both the progressive reader and the
+ * sequential reader it is necessary to deal with the fact that the progressive
+ * reader callbacks only have one parameter (png_get_progressive_ptr()), so this
+ * must contain all the test parameters and all the local variables directly
+ * accessible to the sequential reader implementation.
+ *
+ * The technique adopted is to reinvent part of what Dijkstra termed a
+ * 'display'; an array of pointers to the stack frames of enclosing functions so
+ * that a nested function definition can access the local (C auto) variables of
+ * the functions that contain its definition.  In fact C provides the first
+ * pointer (the local variables - the stack frame pointer) and the last (the
+ * global variables - the BCPL global vector typically implemented as global
+ * addresses), this code requires one more pointer to make the display - the
+ * local variables (and function call parameters) of the function that actually
+ * invokes either the progressive or sequential reader.
+ *
+ * Perhaps confusingly this technique is confounded with classes - the
+ * 'standard_display' defined here is sub-classed as the 'gamma_display' below.
+ * A gamma_display is a standard_display, taking advantage of the ANSI-C
+ * requirement that the pointer to the first member of a structure must be the
+ * same as the pointer to the structure.  This allows us to reuse standard_
+ * functions in the gamma test code; something that could not be done with
+ * nested functions!
+ */
+typedef struct standard_display
+{
+   png_store*  ps;             /* Test parameters (passed to the function) */
+   png_byte    colour_type;
+   png_byte    bit_depth;
+   png_byte    red_sBIT;       /* Input data sBIT values. */
+   png_byte    green_sBIT;
+   png_byte    blue_sBIT;
+   png_byte    alpha_sBIT;
+   png_byte    interlace_type;
+   png_byte    filler;         /* Output has a filler */
+   png_uint_32 id;             /* Calculated file ID */
+   png_uint_32 w;              /* Width of image */
+   png_uint_32 h;              /* Height of image */
+   int         npasses;        /* Number of interlaced passes */
+   png_uint_32 pixel_size;     /* Width of one pixel in bits */
+   png_uint_32 bit_width;      /* Width of output row in bits */
+   size_t      cbRow;          /* Bytes in a row of the output image */
+   int         do_interlace;   /* Do interlacing internally */
+   int         littleendian;   /* App (row) data is little endian */
+   int         is_transparent; /* Transparency information was present. */
+   int         has_tRNS;       /* color type GRAY or RGB with a tRNS chunk. */
+   int         speed;          /* Doing a speed test */
+   int         use_update_info;/* Call update_info, not start_image */
+   struct
+   {
+      png_uint_16 red;
+      png_uint_16 green;
+      png_uint_16 blue;
+   }           transparent;    /* The transparent color, if set. */
+   int         npalette;       /* Number of entries in the palette. */
+   store_palette
+               palette;
+} standard_display;
+
+static void
+standard_display_init(standard_display *dp, png_store* ps, png_uint_32 id,
+   int do_interlace, int use_update_info)
+{
+   memset(dp, 0, sizeof *dp);
+
+   dp->ps = ps;
+   dp->colour_type = COL_FROM_ID(id);
+   dp->bit_depth = DEPTH_FROM_ID(id);
+   if (dp->bit_depth < 1 || dp->bit_depth > 16)
+      internal_error(ps, "internal: bad bit depth");
+   if (dp->colour_type == 3)
+      dp->red_sBIT = dp->blue_sBIT = dp->green_sBIT = dp->alpha_sBIT = 8;
+   else
+      dp->red_sBIT = dp->blue_sBIT = dp->green_sBIT = dp->alpha_sBIT =
+         dp->bit_depth;
+   dp->interlace_type = INTERLACE_FROM_ID(id);
+   check_interlace_type(dp->interlace_type);
+   dp->id = id;
+   /* All the rest are filled in after the read_info: */
+   dp->w = 0;
+   dp->h = 0;
+   dp->npasses = 0;
+   dp->pixel_size = 0;
+   dp->bit_width = 0;
+   dp->cbRow = 0;
+   dp->do_interlace = do_interlace;
+   dp->littleendian = 0;
+   dp->is_transparent = 0;
+   dp->speed = ps->speed;
+   dp->use_update_info = use_update_info;
+   dp->npalette = 0;
+   /* Preset the transparent color to black: */
+   memset(&dp->transparent, 0, sizeof dp->transparent);
+   /* Preset the palette to full intensity/opaque throughout: */
+   memset(dp->palette, 0xff, sizeof dp->palette);
+}
+
+/* Initialize the palette fields - this must be done later because the palette
+ * comes from the particular png_store_file that is selected.
+ */
+static void
+standard_palette_init(standard_display *dp)
+{
+   store_palette_entry *palette = store_current_palette(dp->ps, &dp->npalette);
+
+   /* The remaining entries remain white/opaque. */
+   if (dp->npalette > 0)
+   {
+      int i = dp->npalette;
+      memcpy(dp->palette, palette, i * sizeof *palette);
+
+      /* Check for a non-opaque palette entry: */
+      while (--i >= 0)
+         if (palette[i].alpha < 255)
+            break;
+
+#     ifdef __GNUC__
+         /* GCC can't handle the more obviously optimizable version. */
+         if (i >= 0)
+            dp->is_transparent = 1;
+         else
+            dp->is_transparent = 0;
+#     else
+         dp->is_transparent = (i >= 0);
+#     endif
+   }
+}
+
+/* Utility to read the palette from the PNG file and convert it into
+ * store_palette format.  This returns 1 if there is any transparency in the
+ * palette (it does not check for a transparent colour in the non-palette case.)
+ */
+static int
+read_palette(store_palette palette, int *npalette, png_const_structp pp,
+   png_infop pi)
+{
+   png_colorp pal;
+   png_bytep trans_alpha;
+   int num;
+
+   pal = 0;
+   *npalette = -1;
+
+   if (png_get_PLTE(pp, pi, &pal, npalette) & PNG_INFO_PLTE)
+   {
+      int i = *npalette;
+
+      if (i <= 0 || i > 256)
+         png_error(pp, "validate: invalid PLTE count");
+
+      while (--i >= 0)
+      {
+         palette[i].red = pal[i].red;
+         palette[i].green = pal[i].green;
+         palette[i].blue = pal[i].blue;
+      }
+
+      /* Mark the remainder of the entries with a flag value (other than
+       * white/opaque which is the flag value stored above.)
+       */
+      memset(palette + *npalette, 126, (256-*npalette) * sizeof *palette);
+   }
+
+   else /* !png_get_PLTE */
+   {
+      if (*npalette != (-1))
+         png_error(pp, "validate: invalid PLTE result");
+      /* But there is no palette, so record this: */
+      *npalette = 0;
+      memset(palette, 113, sizeof (store_palette));
+   }
+
+   trans_alpha = 0;
+   num = 2; /* force error below */
+   if ((png_get_tRNS(pp, pi, &trans_alpha, &num, 0) & PNG_INFO_tRNS) != 0 &&
+      (trans_alpha != NULL || num != 1/*returns 1 for a transparent color*/) &&
+      /* Oops, if a palette tRNS gets expanded png_read_update_info (at least so
+       * far as 1.5.4) does not remove the trans_alpha pointer, only num_trans,
+       * so in the above call we get a success, we get a pointer (who knows what
+       * to) and we get num_trans == 0:
+       */
+      !(trans_alpha != NULL && num == 0)) /* TODO: fix this in libpng. */
+   {
+      int i;
+
+      /* Any of these are crash-worthy - given the implementation of
+       * png_get_tRNS up to 1.5 an app won't crash if it just checks the
+       * result above and fails to check that the variables it passed have
+       * actually been filled in!  Note that if the app were to pass the
+       * last, png_color_16p, variable too it couldn't rely on this.
+       */
+      if (trans_alpha == NULL || num <= 0 || num > 256 || num > *npalette)
+         png_error(pp, "validate: unexpected png_get_tRNS (palette) result");
+
+      for (i=0; i<num; ++i)
+         palette[i].alpha = trans_alpha[i];
+
+      for (num=*npalette; i<num; ++i)
+         palette[i].alpha = 255;
+
+      for (; i<256; ++i)
+         palette[i].alpha = 33; /* flag value */
+
+      return 1; /* transparency */
+   }
+
+   else
+   {
+      /* No palette transparency - just set the alpha channel to opaque. */
+      int i;
+
+      for (i=0, num=*npalette; i<num; ++i)
+         palette[i].alpha = 255;
+
+      for (; i<256; ++i)
+         palette[i].alpha = 55; /* flag value */
+
+      return 0; /* no transparency */
+   }
+}
+
+/* Utility to validate the palette if it should not have changed (the
+ * non-transform case).
+ */
+static void
+standard_palette_validate(standard_display *dp, png_const_structp pp,
+   png_infop pi)
+{
+   int npalette;
+   store_palette palette;
+
+   if (read_palette(palette, &npalette, pp, pi) != dp->is_transparent)
+      png_error(pp, "validate: palette transparency changed");
+
+   if (npalette != dp->npalette)
+   {
+      size_t pos = 0;
+      char msg[64];
+
+      pos = safecat(msg, sizeof msg, pos, "validate: palette size changed: ");
+      pos = safecatn(msg, sizeof msg, pos, dp->npalette);
+      pos = safecat(msg, sizeof msg, pos, " -> ");
+      pos = safecatn(msg, sizeof msg, pos, npalette);
+      png_error(pp, msg);
+   }
+
+   {
+      int i = npalette; /* npalette is aliased */
+
+      while (--i >= 0)
+         if (palette[i].red != dp->palette[i].red ||
+            palette[i].green != dp->palette[i].green ||
+            palette[i].blue != dp->palette[i].blue ||
+            palette[i].alpha != dp->palette[i].alpha)
+            png_error(pp, "validate: PLTE or tRNS chunk changed");
+   }
+}
+
+/* By passing a 'standard_display' the progressive callbacks can be used
+ * directly by the sequential code, the functions suffixed "_imp" are the
+ * implementations, the functions without the suffix are the callbacks.
+ *
+ * The code for the info callback is split into two because this callback calls
+ * png_read_update_info or png_start_read_image and what gets called depends on
+ * whether the info needs updating (we want to test both calls in pngvalid.)
+ */
+static void
+standard_info_part1(standard_display *dp, png_structp pp, png_infop pi)
+{
+   if (png_get_bit_depth(pp, pi) != dp->bit_depth)
+      png_error(pp, "validate: bit depth changed");
+
+   if (png_get_color_type(pp, pi) != dp->colour_type)
+      png_error(pp, "validate: color type changed");
+
+   if (png_get_filter_type(pp, pi) != PNG_FILTER_TYPE_BASE)
+      png_error(pp, "validate: filter type changed");
+
+   if (png_get_interlace_type(pp, pi) != dp->interlace_type)
+      png_error(pp, "validate: interlacing changed");
+
+   if (png_get_compression_type(pp, pi) != PNG_COMPRESSION_TYPE_BASE)
+      png_error(pp, "validate: compression type changed");
+
+   dp->w = png_get_image_width(pp, pi);
+
+   if (dp->w != standard_width(pp, dp->id))
+      png_error(pp, "validate: image width changed");
+
+   dp->h = png_get_image_height(pp, pi);
+
+   if (dp->h != standard_height(pp, dp->id))
+      png_error(pp, "validate: image height changed");
+
+   /* Record (but don't check at present) the input sBIT according to the colour
+    * type information.
+    */
+   {
+      png_color_8p sBIT = 0;
+
+      if (png_get_sBIT(pp, pi, &sBIT) & PNG_INFO_sBIT)
+      {
+         int sBIT_invalid = 0;
+
+         if (sBIT == 0)
+            png_error(pp, "validate: unexpected png_get_sBIT result");
+
+         if (dp->colour_type & PNG_COLOR_MASK_COLOR)
+         {
+            if (sBIT->red == 0 || sBIT->red > dp->bit_depth)
+               sBIT_invalid = 1;
+            else
+               dp->red_sBIT = sBIT->red;
+
+            if (sBIT->green == 0 || sBIT->green > dp->bit_depth)
+               sBIT_invalid = 1;
+            else
+               dp->green_sBIT = sBIT->green;
+
+            if (sBIT->blue == 0 || sBIT->blue > dp->bit_depth)
+               sBIT_invalid = 1;
+            else
+               dp->blue_sBIT = sBIT->blue;
+         }
+
+         else /* !COLOR */
+         {
+            if (sBIT->gray == 0 || sBIT->gray > dp->bit_depth)
+               sBIT_invalid = 1;
+            else
+               dp->blue_sBIT = dp->green_sBIT = dp->red_sBIT = sBIT->gray;
+         }
+
+         /* All 8 bits in tRNS for a palette image are significant - see the
+          * spec.
+          */
+         if (dp->colour_type & PNG_COLOR_MASK_ALPHA)
+         {
+            if (sBIT->alpha == 0 || sBIT->alpha > dp->bit_depth)
+               sBIT_invalid = 1;
+            else
+               dp->alpha_sBIT = sBIT->alpha;
+         }
+
+         if (sBIT_invalid)
+            png_error(pp, "validate: sBIT value out of range");
+      }
+   }
+
+   /* Important: this is validating the value *before* any transforms have been
+    * put in place.  It doesn't matter for the standard tests, where there are
+    * no transforms, but it does for other tests where rowbytes may change after
+    * png_read_update_info.
+    */
+   if (png_get_rowbytes(pp, pi) != standard_rowsize(pp, dp->id))
+      png_error(pp, "validate: row size changed");
+
+   /* Validate the colour type 3 palette (this can be present on other color
+    * types.)
+    */
+   standard_palette_validate(dp, pp, pi);
+
+   /* In any case always check for a transparent color (notice that the
+    * colour type 3 case must not give a successful return on the get_tRNS call
+    * with these arguments!)
+    */
+   {
+      png_color_16p trans_color = 0;
+
+      if (png_get_tRNS(pp, pi, 0, 0, &trans_color) & PNG_INFO_tRNS)
+      {
+         if (trans_color == 0)
+            png_error(pp, "validate: unexpected png_get_tRNS (color) result");
+
+         switch (dp->colour_type)
+         {
+         case 0:
+            dp->transparent.red = dp->transparent.green = dp->transparent.blue =
+               trans_color->gray;
+            dp->has_tRNS = 1;
+            break;
+
+         case 2:
+            dp->transparent.red = trans_color->red;
+            dp->transparent.green = trans_color->green;
+            dp->transparent.blue = trans_color->blue;
+            dp->has_tRNS = 1;
+            break;
+
+         case 3:
+            /* Not expected because it should result in the array case
+             * above.
+             */
+            png_error(pp, "validate: unexpected png_get_tRNS result");
+            break;
+
+         default:
+            png_error(pp, "validate: invalid tRNS chunk with alpha image");
+         }
+      }
+   }
+
+   /* Read the number of passes - expected to match the value used when
+    * creating the image (interlaced or not).  This has the side effect of
+    * turning on interlace handling (if do_interlace is not set.)
+    */
+   dp->npasses = npasses_from_interlace_type(pp, dp->interlace_type);
+   if (!dp->do_interlace)
+   {
+#     ifdef PNG_READ_INTERLACING_SUPPORTED
+         if (dp->npasses != png_set_interlace_handling(pp))
+            png_error(pp, "validate: file changed interlace type");
+#     else /* !READ_INTERLACING */
+         /* This should never happen: the relevant tests (!do_interlace) should
+          * not be run.
+          */
+         if (dp->npasses > 1)
+            png_error(pp, "validate: no libpng interlace support");
+#     endif /* !READ_INTERLACING */
+   }
+
+   /* Caller calls png_read_update_info or png_start_read_image now, then calls
+    * part2.
+    */
+}
+
+/* This must be called *after* the png_read_update_info call to get the correct
+ * 'rowbytes' value, otherwise png_get_rowbytes will refer to the untransformed
+ * image.
+ */
+static void
+standard_info_part2(standard_display *dp, png_const_structp pp,
+    png_const_infop pi, int nImages)
+{
+   /* Record cbRow now that it can be found. */
+   {
+      png_byte ct = png_get_color_type(pp, pi);
+      png_byte bd = png_get_bit_depth(pp, pi);
+
+      if (bd >= 8 && (ct == PNG_COLOR_TYPE_RGB || ct == PNG_COLOR_TYPE_GRAY) &&
+          dp->filler)
+          ct |= 4; /* handle filler as faked alpha channel */
+
+      dp->pixel_size = bit_size(pp, ct, bd);
+   }
+   dp->bit_width = png_get_image_width(pp, pi) * dp->pixel_size;
+   dp->cbRow = png_get_rowbytes(pp, pi);
+
+   /* Validate the rowbytes here again. */
+   if (dp->cbRow != (dp->bit_width+7)/8)
+      png_error(pp, "bad png_get_rowbytes calculation");
+
+   /* Then ensure there is enough space for the output image(s). */
+   store_ensure_image(dp->ps, pp, nImages, dp->cbRow, dp->h);
+}
+
+static void
+standard_info_imp(standard_display *dp, png_structp pp, png_infop pi,
+    int nImages)
+{
+   /* Note that the validation routine has the side effect of turning on
+    * interlace handling in the subsequent code.
+    */
+   standard_info_part1(dp, pp, pi);
+
+   /* And the info callback has to call this (or png_read_update_info - see
+    * below in the png_modifier code for that variant.
+    */
+   if (dp->use_update_info)
+   {
+      /* For debugging the effect of multiple calls: */
+      int i = dp->use_update_info;
+      while (i-- > 0)
+         png_read_update_info(pp, pi);
+   }
+
+   else
+      png_start_read_image(pp);
+
+   /* Validate the height, width and rowbytes plus ensure that sufficient buffer
+    * exists for decoding the image.
+    */
+   standard_info_part2(dp, pp, pi, nImages);
+}
+
+static void PNGCBAPI
+standard_info(png_structp pp, png_infop pi)
+{
+   standard_display *dp = voidcast(standard_display*,
+      png_get_progressive_ptr(pp));
+
+   /* Call with nImages==1 because the progressive reader can only produce one
+    * image.
+    */
+   standard_info_imp(dp, pp, pi, 1 /*only one image*/);
+}
+
+static void PNGCBAPI
+progressive_row(png_structp ppIn, png_bytep new_row, png_uint_32 y, int pass)
+{
+   png_const_structp pp = ppIn;
+   const standard_display *dp = voidcast(standard_display*,
+      png_get_progressive_ptr(pp));
+
+   /* When handling interlacing some rows will be absent in each pass, the
+    * callback still gets called, but with a NULL pointer.  This is checked
+    * in the 'else' clause below.  We need our own 'cbRow', but we can't call
+    * png_get_rowbytes because we got no info structure.
+    */
+   if (new_row != NULL)
+   {
+      png_bytep row;
+
+      /* In the case where the reader doesn't do the interlace it gives
+       * us the y in the sub-image:
+       */
+      if (dp->do_interlace && dp->interlace_type == PNG_INTERLACE_ADAM7)
+      {
+#ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED
+         /* Use this opportunity to validate the png 'current' APIs: */
+         if (y != png_get_current_row_number(pp))
+            png_error(pp, "png_get_current_row_number is broken");
+
+         if (pass != png_get_current_pass_number(pp))
+            png_error(pp, "png_get_current_pass_number is broken");
+#endif /* USER_TRANSFORM_INFO */
+
+         y = PNG_ROW_FROM_PASS_ROW(y, pass);
+      }
+
+      /* Validate this just in case. */
+      if (y >= dp->h)
+         png_error(pp, "invalid y to progressive row callback");
+
+      row = store_image_row(dp->ps, pp, 0, y);
+
+      /* Combine the new row into the old: */
+#ifdef PNG_READ_INTERLACING_SUPPORTED
+      if (dp->do_interlace)
+#endif /* READ_INTERLACING */
+      {
+         if (dp->interlace_type == PNG_INTERLACE_ADAM7)
+            deinterlace_row(row, new_row, dp->pixel_size, dp->w, pass,
+                  dp->littleendian);
+         else
+            row_copy(row, new_row, dp->pixel_size * dp->w, dp->littleendian);
+      }
+#ifdef PNG_READ_INTERLACING_SUPPORTED
+      else
+         png_progressive_combine_row(pp, row, new_row);
+#endif /* PNG_READ_INTERLACING_SUPPORTED */
+   }
+
+   else if (dp->interlace_type == PNG_INTERLACE_ADAM7 &&
+       PNG_ROW_IN_INTERLACE_PASS(y, pass) &&
+       PNG_PASS_COLS(dp->w, pass) > 0)
+      png_error(pp, "missing row in progressive de-interlacing");
+}
+
+static void
+sequential_row(standard_display *dp, png_structp pp, png_infop pi,
+    int iImage, int iDisplay)
+{
+   int npasses = dp->npasses;
+   int do_interlace = dp->do_interlace &&
+      dp->interlace_type == PNG_INTERLACE_ADAM7;
+   png_uint_32 height = standard_height(pp, dp->id);
+   png_uint_32 width = standard_width(pp, dp->id);
+   const png_store* ps = dp->ps;
+   int pass;
+
+   for (pass=0; pass<npasses; ++pass)
+   {
+      png_uint_32 y;
+      png_uint_32 wPass = PNG_PASS_COLS(width, pass);
+
+      for (y=0; y<height; ++y)
+      {
+         if (do_interlace)
+         {
+            /* wPass may be zero or this row may not be in this pass.
+             * png_read_row must not be called in either case.
+             */
+            if (wPass > 0 && PNG_ROW_IN_INTERLACE_PASS(y, pass))
+            {
+               /* Read the row into a pair of temporary buffers, then do the
+                * merge here into the output rows.
+                */
+               png_byte row[STANDARD_ROWMAX], display[STANDARD_ROWMAX];
+
+               /* The following aids (to some extent) error detection - we can
+                * see where png_read_row wrote.  Use opposite values in row and
+                * display to make this easier.  Don't use 0xff (which is used in
+                * the image write code to fill unused bits) or 0 (which is a
+                * likely value to overwrite unused bits with).
+                */
+               memset(row, 0xc5, sizeof row);
+               memset(display, 0x5c, sizeof display);
+
+               png_read_row(pp, row, display);
+
+               if (iImage >= 0)
+                  deinterlace_row(store_image_row(ps, pp, iImage, y), row,
+                     dp->pixel_size, dp->w, pass, dp->littleendian);
+
+               if (iDisplay >= 0)
+                  deinterlace_row(store_image_row(ps, pp, iDisplay, y), display,
+                     dp->pixel_size, dp->w, pass, dp->littleendian);
+            }
+         }
+         else
+            png_read_row(pp,
+               iImage >= 0 ? store_image_row(ps, pp, iImage, y) : NULL,
+               iDisplay >= 0 ? store_image_row(ps, pp, iDisplay, y) : NULL);
+      }
+   }
+
+   /* And finish the read operation (only really necessary if the caller wants
+    * to find additional data in png_info from chunks after the last IDAT.)
+    */
+   png_read_end(pp, pi);
+}
+
+#ifdef PNG_TEXT_SUPPORTED
+static void
+standard_check_text(png_const_structp pp, png_const_textp tp,
+   png_const_charp keyword, png_const_charp text)
+{
+   char msg[1024];
+   size_t pos = safecat(msg, sizeof msg, 0, "text: ");
+   size_t ok;
+
+   pos = safecat(msg, sizeof msg, pos, keyword);
+   pos = safecat(msg, sizeof msg, pos, ": ");
+   ok = pos;
+
+   if (tp->compression != TEXT_COMPRESSION)
+   {
+      char buf[64];
+
+      sprintf(buf, "compression [%d->%d], ", TEXT_COMPRESSION,
+         tp->compression);
+      pos = safecat(msg, sizeof msg, pos, buf);
+   }
+
+   if (tp->key == NULL || strcmp(tp->key, keyword) != 0)
+   {
+      pos = safecat(msg, sizeof msg, pos, "keyword \"");
+      if (tp->key != NULL)
+      {
+         pos = safecat(msg, sizeof msg, pos, tp->key);
+         pos = safecat(msg, sizeof msg, pos, "\", ");
+      }
+
+      else
+         pos = safecat(msg, sizeof msg, pos, "null, ");
+   }
+
+   if (tp->text == NULL)
+      pos = safecat(msg, sizeof msg, pos, "text lost, ");
+
+   else
+   {
+      if (tp->text_length != strlen(text))
+      {
+         char buf[64];
+         sprintf(buf, "text length changed[%lu->%lu], ",
+            (unsigned long)strlen(text), (unsigned long)tp->text_length);
+         pos = safecat(msg, sizeof msg, pos, buf);
+      }
+
+      if (strcmp(tp->text, text) != 0)
+      {
+         pos = safecat(msg, sizeof msg, pos, "text becomes \"");
+         pos = safecat(msg, sizeof msg, pos, tp->text);
+         pos = safecat(msg, sizeof msg, pos, "\" (was \"");
+         pos = safecat(msg, sizeof msg, pos, text);
+         pos = safecat(msg, sizeof msg, pos, "\"), ");
+      }
+   }
+
+   if (tp->itxt_length != 0)
+      pos = safecat(msg, sizeof msg, pos, "iTXt length set, ");
+
+   if (tp->lang != NULL)
+   {
+      pos = safecat(msg, sizeof msg, pos, "iTXt language \"");
+      pos = safecat(msg, sizeof msg, pos, tp->lang);
+      pos = safecat(msg, sizeof msg, pos, "\", ");
+   }
+
+   if (tp->lang_key != NULL)
+   {
+      pos = safecat(msg, sizeof msg, pos, "iTXt keyword \"");
+      pos = safecat(msg, sizeof msg, pos, tp->lang_key);
+      pos = safecat(msg, sizeof msg, pos, "\", ");
+   }
+
+   if (pos > ok)
+   {
+      msg[pos-2] = '\0'; /* Remove the ", " at the end */
+      png_error(pp, msg);
+   }
+}
+
+static void
+standard_text_validate(standard_display *dp, png_const_structp pp,
+   png_infop pi, int check_end)
+{
+   png_textp tp = NULL;
+   png_uint_32 num_text = png_get_text(pp, pi, &tp, NULL);
+
+   if (num_text == 2 && tp != NULL)
+   {
+      standard_check_text(pp, tp, "image name", dp->ps->current->name);
+
+      /* This exists because prior to 1.5.18 the progressive reader left the
+       * png_struct z_stream unreset at the end of the image, so subsequent
+       * attempts to use it simply returns Z_STREAM_END.
+       */
+      if (check_end)
+         standard_check_text(pp, tp+1, "end marker", "end");
+   }
+
+   else
+   {
+      char msg[64];
+
+      sprintf(msg, "expected two text items, got %lu",
+         (unsigned long)num_text);
+      png_error(pp, msg);
+   }
+}
+#else
+#  define standard_text_validate(dp,pp,pi,check_end) ((void)0)
+#endif
+
+static void
+standard_row_validate(standard_display *dp, png_const_structp pp,
+   int iImage, int iDisplay, png_uint_32 y)
+{
+   int where;
+   png_byte std[STANDARD_ROWMAX];
+
+   /* The row must be pre-initialized to the magic number here for the size
+    * tests to pass:
+    */
+   memset(std, 178, sizeof std);
+   standard_row(pp, std, dp->id, y);
+
+   /* At the end both the 'row' and 'display' arrays should end up identical.
+    * In earlier passes 'row' will be partially filled in, with only the pixels
+    * that have been read so far, but 'display' will have those pixels
+    * replicated to fill the unread pixels while reading an interlaced image.
+    */
+   if (iImage >= 0 &&
+      (where = pixel_cmp(std, store_image_row(dp->ps, pp, iImage, y),
+            dp->bit_width)) != 0)
+   {
+      char msg[64];
+      sprintf(msg, "PNG image row[%lu][%d] changed from %.2x to %.2x",
+         (unsigned long)y, where-1, std[where-1],
+         store_image_row(dp->ps, pp, iImage, y)[where-1]);
+      png_error(pp, msg);
+   }
+
+   if (iDisplay >= 0 &&
+      (where = pixel_cmp(std, store_image_row(dp->ps, pp, iDisplay, y),
+         dp->bit_width)) != 0)
+   {
+      char msg[64];
+      sprintf(msg, "display row[%lu][%d] changed from %.2x to %.2x",
+         (unsigned long)y, where-1, std[where-1],
+         store_image_row(dp->ps, pp, iDisplay, y)[where-1]);
+      png_error(pp, msg);
+   }
+}
+
+static void
+standard_image_validate(standard_display *dp, png_const_structp pp, int iImage,
+    int iDisplay)
+{
+   png_uint_32 y;
+
+   if (iImage >= 0)
+      store_image_check(dp->ps, pp, iImage);
+
+   if (iDisplay >= 0)
+      store_image_check(dp->ps, pp, iDisplay);
+
+   for (y=0; y<dp->h; ++y)
+      standard_row_validate(dp, pp, iImage, iDisplay, y);
+
+   /* This avoids false positives if the validation code is never called! */
+   dp->ps->validated = 1;
+}
+
+static void PNGCBAPI
+standard_end(png_structp ppIn, png_infop pi)
+{
+   png_const_structp pp = ppIn;
+   standard_display *dp = voidcast(standard_display*,
+      png_get_progressive_ptr(pp));
+
+   UNUSED(pi)
+
+   /* Validate the image - progressive reading only produces one variant for
+    * interlaced images.
+    */
+   standard_text_validate(dp, pp, pi,
+      PNG_LIBPNG_VER >= 10518/*check_end: see comments above*/);
+   standard_image_validate(dp, pp, 0, -1);
+}
+
+/* A single test run checking the standard image to ensure it is not damaged. */
+static void
+standard_test(png_store* const psIn, png_uint_32 const id,
+   int do_interlace, int use_update_info)
+{
+   standard_display d;
+   context(psIn, fault);
+
+   /* Set up the display (stack frame) variables from the arguments to the
+    * function and initialize the locals that are filled in later.
+    */
+   standard_display_init(&d, psIn, id, do_interlace, use_update_info);
+
+   /* Everything is protected by a Try/Catch.  The functions called also
+    * typically have local Try/Catch blocks.
+    */
+   Try
+   {
+      png_structp pp;
+      png_infop pi;
+
+      /* Get a png_struct for reading the image. This will throw an error if it
+       * fails, so we don't need to check the result.
+       */
+      pp = set_store_for_read(d.ps, &pi, d.id,
+         d.do_interlace ?  (d.ps->progressive ?
+            "pngvalid progressive deinterlacer" :
+            "pngvalid sequential deinterlacer") : (d.ps->progressive ?
+               "progressive reader" : "sequential reader"));
+
+      /* Initialize the palette correctly from the png_store_file. */
+      standard_palette_init(&d);
+
+      /* Introduce the correct read function. */
+      if (d.ps->progressive)
+      {
+         png_set_progressive_read_fn(pp, &d, standard_info, progressive_row,
+            standard_end);
+
+         /* Now feed data into the reader until we reach the end: */
+         store_progressive_read(d.ps, pp, pi);
+      }
+      else
+      {
+         /* Note that this takes the store, not the display. */
+         png_set_read_fn(pp, d.ps, store_read);
+
+         /* Check the header values: */
+         png_read_info(pp, pi);
+
+         /* The code tests both versions of the images that the sequential
+          * reader can produce.
+          */
+         standard_info_imp(&d, pp, pi, 2 /*images*/);
+
+         /* Need the total bytes in the image below; we can't get to this point
+          * unless the PNG file values have been checked against the expected
+          * values.
+          */
+         {
+            sequential_row(&d, pp, pi, 0, 1);
+
+            /* After the last pass loop over the rows again to check that the
+             * image is correct.
+             */
+            if (!d.speed)
+            {
+               standard_text_validate(&d, pp, pi, 1/*check_end*/);
+               standard_image_validate(&d, pp, 0, 1);
+            }
+            else
+               d.ps->validated = 1;
+         }
+      }
+
+      /* Check for validation. */
+      if (!d.ps->validated)
+         png_error(pp, "image read failed silently");
+
+      /* Successful completion. */
+   }
+
+   Catch(fault)
+      d.ps = fault; /* make sure this hasn't been clobbered. */
+
+   /* In either case clean up the store. */
+   store_read_reset(d.ps);
+}
+
+static int
+test_standard(png_modifier* const pm, png_byte const colour_type,
+    int bdlo, int const bdhi)
+{
+   for (; bdlo <= bdhi; ++bdlo)
+   {
+      int interlace_type;
+
+      for (interlace_type = PNG_INTERLACE_NONE;
+           interlace_type < INTERLACE_LAST; ++interlace_type)
+      {
+         standard_test(&pm->this, FILEID(colour_type, DEPTH(bdlo), 0/*palette*/,
+            interlace_type, 0, 0, 0), do_read_interlace, pm->use_update_info);
+
+         if (fail(pm))
+            return 0;
+      }
+   }
+
+   return 1; /* keep going */
+}
+
+static void
+perform_standard_test(png_modifier *pm)
+{
+   /* Test each colour type over the valid range of bit depths (expressed as
+    * log2(bit_depth) in turn, stop as soon as any error is detected.
+    */
+   if (!test_standard(pm, 0, 0, READ_BDHI))
+      return;
+
+   if (!test_standard(pm, 2, 3, READ_BDHI))
+      return;
+
+   if (!test_standard(pm, 3, 0, 3))
+      return;
+
+   if (!test_standard(pm, 4, 3, READ_BDHI))
+      return;
+
+   if (!test_standard(pm, 6, 3, READ_BDHI))
+      return;
+}
+
+
+/********************************** SIZE TESTS ********************************/
+static int
+test_size(png_modifier* const pm, png_byte const colour_type,
+    int bdlo, int const bdhi)
+{
+   /* Run the tests on each combination.
+    *
+    * NOTE: on my 32 bit x86 each of the following blocks takes
+    * a total of 3.5 seconds if done across every combo of bit depth
+    * width and height.  This is a waste of time in practice, hence the
+    * hinc and winc stuff:
+    */
+   static const png_byte hinc[] = {1, 3, 11, 1, 5};
+   static const png_byte winc[] = {1, 9, 5, 7, 1};
+   int save_bdlo = bdlo;
+
+   for (; bdlo <= bdhi; ++bdlo)
+   {
+      png_uint_32 h, w;
+
+      for (h=1; h<=16; h+=hinc[bdlo]) for (w=1; w<=16; w+=winc[bdlo])
+      {
+         /* First test all the 'size' images against the sequential
+          * reader using libpng to deinterlace (where required.)  This
+          * validates the write side of libpng.  There are four possibilities
+          * to validate.
+          */
+         standard_test(&pm->this, FILEID(colour_type, DEPTH(bdlo), 0/*palette*/,
+            PNG_INTERLACE_NONE, w, h, 0), 0/*do_interlace*/,
+            pm->use_update_info);
+
+         if (fail(pm))
+            return 0;
+
+         standard_test(&pm->this, FILEID(colour_type, DEPTH(bdlo), 0/*palette*/,
+            PNG_INTERLACE_NONE, w, h, 1), 0/*do_interlace*/,
+            pm->use_update_info);
+
+         if (fail(pm))
+            return 0;
+
+         /* Now validate the interlaced read side - do_interlace true,
+          * in the progressive case this does actually make a difference
+          * to the code used in the non-interlaced case too.
+          */
+         standard_test(&pm->this, FILEID(colour_type, DEPTH(bdlo), 0/*palette*/,
+            PNG_INTERLACE_NONE, w, h, 0), 1/*do_interlace*/,
+            pm->use_update_info);
+
+         if (fail(pm))
+            return 0;
+
+#     if CAN_WRITE_INTERLACE
+         /* Validate the pngvalid code itself: */
+         standard_test(&pm->this, FILEID(colour_type, DEPTH(bdlo), 0/*palette*/,
+            PNG_INTERLACE_ADAM7, w, h, 1), 1/*do_interlace*/,
+            pm->use_update_info);
+
+         if (fail(pm))
+            return 0;
+#     endif
+      }
+   }
+
+   /* Now do the tests of libpng interlace handling, after we have made sure
+    * that the pngvalid version works:
+    */
+   for (bdlo = save_bdlo; bdlo <= bdhi; ++bdlo)
+   {
+      png_uint_32 h, w;
+
+      for (h=1; h<=16; h+=hinc[bdlo]) for (w=1; w<=16; w+=winc[bdlo])
+      {
+#     ifdef PNG_READ_INTERLACING_SUPPORTED
+         /* Test with pngvalid generated interlaced images first; we have
+          * already verify these are ok (unless pngvalid has self-consistent
+          * read/write errors, which is unlikely), so this detects errors in the
+          * read side first:
+          */
+#     if CAN_WRITE_INTERLACE
+         standard_test(&pm->this, FILEID(colour_type, DEPTH(bdlo), 0/*palette*/,
+            PNG_INTERLACE_ADAM7, w, h, 1), 0/*do_interlace*/,
+            pm->use_update_info);
+
+         if (fail(pm))
+            return 0;
+#     endif
+#     endif /* READ_INTERLACING */
+
+#     ifdef PNG_WRITE_INTERLACING_SUPPORTED
+         /* Test the libpng write side against the pngvalid read side: */
+         standard_test(&pm->this, FILEID(colour_type, DEPTH(bdlo), 0/*palette*/,
+            PNG_INTERLACE_ADAM7, w, h, 0), 1/*do_interlace*/,
+            pm->use_update_info);
+
+         if (fail(pm))
+            return 0;
+#     endif
+
+#     ifdef PNG_READ_INTERLACING_SUPPORTED
+#     ifdef PNG_WRITE_INTERLACING_SUPPORTED
+         /* Test both together: */
+         standard_test(&pm->this, FILEID(colour_type, DEPTH(bdlo), 0/*palette*/,
+            PNG_INTERLACE_ADAM7, w, h, 0), 0/*do_interlace*/,
+            pm->use_update_info);
+
+         if (fail(pm))
+            return 0;
+#     endif
+#     endif /* READ_INTERLACING */
+      }
+   }
+
+   return 1; /* keep going */
+}
+
+static void
+perform_size_test(png_modifier *pm)
+{
+   /* Test each colour type over the valid range of bit depths (expressed as
+    * log2(bit_depth) in turn, stop as soon as any error is detected.
+    */
+   if (!test_size(pm, 0, 0, READ_BDHI))
+      return;
+
+   if (!test_size(pm, 2, 3, READ_BDHI))
+      return;
+
+   /* For the moment don't do the palette test - it's a waste of time when
+    * compared to the grayscale test.
+    */
+#if 0
+   if (!test_size(pm, 3, 0, 3))
+      return;
+#endif
+
+   if (!test_size(pm, 4, 3, READ_BDHI))
+      return;
+
+   if (!test_size(pm, 6, 3, READ_BDHI))
+      return;
+}
+
+
+/******************************* TRANSFORM TESTS ******************************/
+#ifdef PNG_READ_TRANSFORMS_SUPPORTED
+/* A set of tests to validate libpng image transforms.  The possibilities here
+ * are legion because the transforms can be combined in a combinatorial
+ * fashion.  To deal with this some measure of restraint is required, otherwise
+ * the tests would take forever.
+ */
+typedef struct image_pixel
+{
+   /* A local (pngvalid) representation of a PNG pixel, in all its
+    * various forms.
+    */
+   unsigned int red, green, blue, alpha; /* For non-palette images. */
+   unsigned int palette_index;           /* For a palette image. */
+   png_byte     colour_type;             /* As in the spec. */
+   png_byte     bit_depth;               /* Defines bit size in row */
+   png_byte     sample_depth;            /* Scale of samples */
+   unsigned int have_tRNS :1;            /* tRNS chunk may need processing */
+   unsigned int swap_rgb :1;             /* RGB swapped to BGR */
+   unsigned int alpha_first :1;          /* Alpha at start, not end */
+   unsigned int alpha_inverted :1;       /* Alpha channel inverted */
+   unsigned int mono_inverted :1;        /* Gray channel inverted */
+   unsigned int swap16 :1;               /* Byte swap 16-bit components */
+   unsigned int littleendian :1;         /* High bits on right */
+   unsigned int sig_bits :1;             /* Pixel shifted (sig bits only) */
+
+   /* For checking the code calculates double precision floating point values
+    * along with an error value, accumulated from the transforms.  Because an
+    * sBIT setting allows larger error bounds (indeed, by the spec, apparently
+    * up to just less than +/-1 in the scaled value) the *lowest* sBIT for each
+    * channel is stored.  This sBIT value is folded in to the stored error value
+    * at the end of the application of the transforms to the pixel.
+    *
+    * If sig_bits is set above the red, green, blue and alpha values have been
+    * scaled so they only contain the significant bits of the component values.
+    */
+   double   redf, greenf, bluef, alphaf;
+   double   rede, greene, bluee, alphae;
+   png_byte red_sBIT, green_sBIT, blue_sBIT, alpha_sBIT;
+} image_pixel;
+
+/* Shared utility function, see below. */
+static void
+image_pixel_setf(image_pixel *this, unsigned int rMax, unsigned int gMax,
+        unsigned int bMax, unsigned int aMax)
+{
+   this->redf = this->red / (double)rMax;
+   this->greenf = this->green / (double)gMax;
+   this->bluef = this->blue / (double)bMax;
+   this->alphaf = this->alpha / (double)aMax;
+
+   if (this->red < rMax)
+      this->rede = this->redf * DBL_EPSILON;
+   else
+      this->rede = 0;
+   if (this->green < gMax)
+      this->greene = this->greenf * DBL_EPSILON;
+   else
+      this->greene = 0;
+   if (this->blue < bMax)
+      this->bluee = this->bluef * DBL_EPSILON;
+   else
+      this->bluee = 0;
+   if (this->alpha < aMax)
+      this->alphae = this->alphaf * DBL_EPSILON;
+   else
+      this->alphae = 0;
+}
+
+/* Initialize the structure for the next pixel - call this before doing any
+ * transforms and call it for each pixel since all the fields may need to be
+ * reset.
+ */
+static void
+image_pixel_init(image_pixel *this, png_const_bytep row, png_byte colour_type,
+    png_byte bit_depth, png_uint_32 x, store_palette palette,
+    const image_pixel *format /*from pngvalid transform of input*/)
+{
+   png_byte sample_depth =
+      (png_byte)(colour_type == PNG_COLOR_TYPE_PALETTE ? 8 : bit_depth);
+   unsigned int max = (1U<<sample_depth)-1;
+   int swap16 = (format != 0 && format->swap16);
+   int littleendian = (format != 0 && format->littleendian);
+   int sig_bits = (format != 0 && format->sig_bits);
+
+   /* Initially just set everything to the same number and the alpha to opaque.
+    * Note that this currently assumes a simple palette where entry x has colour
+    * rgb(x,x,x)!
+    */
+   this->palette_index = this->red = this->green = this->blue =
+      sample(row, colour_type, bit_depth, x, 0, swap16, littleendian);
+   this->alpha = max;
+   this->red_sBIT = this->green_sBIT = this->blue_sBIT = this->alpha_sBIT =
+      sample_depth;
+
+   /* Then override as appropriate: */
+   if (colour_type == 3) /* palette */
+   {
+      /* This permits the caller to default to the sample value. */
+      if (palette != 0)
+      {
+         unsigned int i = this->palette_index;
+
+         this->red = palette[i].red;
+         this->green = palette[i].green;
+         this->blue = palette[i].blue;
+         this->alpha = palette[i].alpha;
+      }
+   }
+
+   else /* not palette */
+   {
+      unsigned int i = 0;
+
+      if ((colour_type & 4) != 0 && format != 0 && format->alpha_first)
+      {
+         this->alpha = this->red;
+         /* This handles the gray case for 'AG' pixels */
+         this->palette_index = this->red = this->green = this->blue =
+            sample(row, colour_type, bit_depth, x, 1, swap16, littleendian);
+         i = 1;
+      }
+
+      if (colour_type & 2)
+      {
+         /* Green is second for both BGR and RGB: */
+         this->green = sample(row, colour_type, bit_depth, x, ++i, swap16,
+                 littleendian);
+
+         if (format != 0 && format->swap_rgb) /* BGR */
+             this->red = sample(row, colour_type, bit_depth, x, ++i, swap16,
+                     littleendian);
+         else
+             this->blue = sample(row, colour_type, bit_depth, x, ++i, swap16,
+                     littleendian);
+      }
+
+      else /* grayscale */ if (format != 0 && format->mono_inverted)
+         this->red = this->green = this->blue = this->red ^ max;
+
+      if ((colour_type & 4) != 0) /* alpha */
+      {
+         if (format == 0 || !format->alpha_first)
+             this->alpha = sample(row, colour_type, bit_depth, x, ++i, swap16,
+                     littleendian);
+
+         if (format != 0 && format->alpha_inverted)
+            this->alpha ^= max;
+      }
+   }
+
+   /* Calculate the scaled values, these are simply the values divided by
+    * 'max' and the error is initialized to the double precision epsilon value
+    * from the header file.
+    */
+   image_pixel_setf(this,
+      sig_bits ? (1U << format->red_sBIT)-1 : max,
+      sig_bits ? (1U << format->green_sBIT)-1 : max,
+      sig_bits ? (1U << format->blue_sBIT)-1 : max,
+      sig_bits ? (1U << format->alpha_sBIT)-1 : max);
+
+   /* Store the input information for use in the transforms - these will
+    * modify the information.
+    */
+   this->colour_type = colour_type;
+   this->bit_depth = bit_depth;
+   this->sample_depth = sample_depth;
+   this->have_tRNS = 0;
+   this->swap_rgb = 0;
+   this->alpha_first = 0;
+   this->alpha_inverted = 0;
+   this->mono_inverted = 0;
+   this->swap16 = 0;
+   this->littleendian = 0;
+   this->sig_bits = 0;
+}
+
+#if defined PNG_READ_EXPAND_SUPPORTED || defined PNG_READ_GRAY_TO_RGB_SUPPORTED\
+   || defined PNG_READ_EXPAND_SUPPORTED || defined PNG_READ_EXPAND_16_SUPPORTED\
+   || defined PNG_READ_BACKGROUND_SUPPORTED
+/* Convert a palette image to an rgb image.  This necessarily converts the tRNS
+ * chunk at the same time, because the tRNS will be in palette form.  The way
+ * palette validation works means that the original palette is never updated,
+ * instead the image_pixel value from the row contains the RGB of the
+ * corresponding palette entry and *this* is updated.  Consequently this routine
+ * only needs to change the colour type information.
+ */
+static void
+image_pixel_convert_PLTE(image_pixel *this)
+{
+   if (this->colour_type == PNG_COLOR_TYPE_PALETTE)
+   {
+      if (this->have_tRNS)
+      {
+         this->colour_type = PNG_COLOR_TYPE_RGB_ALPHA;
+         this->have_tRNS = 0;
+      }
+      else
+         this->colour_type = PNG_COLOR_TYPE_RGB;
+
+      /* The bit depth of the row changes at this point too (notice that this is
+       * the row format, not the sample depth, which is separate.)
+       */
+      this->bit_depth = 8;
+   }
+}
+
+/* Add an alpha channel; this will import the tRNS information because tRNS is
+ * not valid in an alpha image.  The bit depth will invariably be set to at
+ * least 8 prior to 1.7.0.  Palette images will be converted to alpha (using
+ * the above API).  With png_set_background the alpha channel is never expanded
+ * but this routine is used by pngvalid to simplify code; 'for_background'
+ * records this.
+ */
+static void
+image_pixel_add_alpha(image_pixel *this, const standard_display *display,
+   int for_background)
+{
+   if (this->colour_type == PNG_COLOR_TYPE_PALETTE)
+      image_pixel_convert_PLTE(this);
+
+   if ((this->colour_type & PNG_COLOR_MASK_ALPHA) == 0)
+   {
+      if (this->colour_type == PNG_COLOR_TYPE_GRAY)
+      {
+#        if PNG_LIBPNG_VER < 10700
+            if (!for_background && this->bit_depth < 8)
+               this->bit_depth = this->sample_depth = 8;
+#        endif
+
+         if (this->have_tRNS)
+         {
+            /* After 1.7 the expansion of bit depth only happens if there is a
+             * tRNS chunk to expand at this point.
+             */
+#           if PNG_LIBPNG_VER >= 10700
+               if (!for_background && this->bit_depth < 8)
+                  this->bit_depth = this->sample_depth = 8;
+#           endif
+
+            this->have_tRNS = 0;
+
+            /* Check the input, original, channel value here against the
+             * original tRNS gray chunk valie.
+             */
+            if (this->red == display->transparent.red)
+               this->alphaf = 0;
+            else
+               this->alphaf = 1;
+         }
+         else
+            this->alphaf = 1;
+
+         this->colour_type = PNG_COLOR_TYPE_GRAY_ALPHA;
+      }
+
+      else if (this->colour_type == PNG_COLOR_TYPE_RGB)
+      {
+         if (this->have_tRNS)
+         {
+            this->have_tRNS = 0;
+
+            /* Again, check the exact input values, not the current transformed
+             * value!
+             */
+            if (this->red == display->transparent.red &&
+               this->green == display->transparent.green &&
+               this->blue == display->transparent.blue)
+               this->alphaf = 0;
+            else
+               this->alphaf = 1;
+         }
+         else
+            this->alphaf = 1;
+
+         this->colour_type = PNG_COLOR_TYPE_RGB_ALPHA;
+      }
+
+      /* The error in the alpha is zero and the sBIT value comes from the
+       * original sBIT data (actually it will always be the original bit depth).
+       */
+      this->alphae = 0;
+      this->alpha_sBIT = display->alpha_sBIT;
+   }
+}
+#endif /* transforms that need image_pixel_add_alpha */
+
+struct transform_display;
+typedef struct image_transform
+{
+   /* The name of this transform: a string. */
+   const char *name;
+
+   /* Each transform can be disabled from the command line: */
+   int enable;
+
+   /* The global list of transforms; read only. */
+   struct image_transform *const list;
+
+   /* The global count of the number of times this transform has been set on an
+    * image.
+    */
+   unsigned int global_use;
+
+   /* The local count of the number of times this transform has been set. */
+   unsigned int local_use;
+
+   /* The next transform in the list, each transform must call its own next
+    * transform after it has processed the pixel successfully.
+    */
+   const struct image_transform *next;
+
+   /* A single transform for the image, expressed as a series of function
+    * callbacks and some space for values.
+    *
+    * First a callback to add any required modifications to the png_modifier;
+    * this gets called just before the modifier is set up for read.
+    */
+   void (*ini)(const struct image_transform *this,
+      struct transform_display *that);
+
+   /* And a callback to set the transform on the current png_read_struct:
+    */
+   void (*set)(const struct image_transform *this,
+      struct transform_display *that, png_structp pp, png_infop pi);
+
+   /* Then a transform that takes an input pixel in one PNG format or another
+    * and modifies it by a pngvalid implementation of the transform (thus
+    * duplicating the libpng intent without, we hope, duplicating the bugs
+    * in the libpng implementation!)  The png_structp is solely to allow error
+    * reporting via png_error and png_warning.
+    */
+   void (*mod)(const struct image_transform *this, image_pixel *that,
+      png_const_structp pp, const struct transform_display *display);
+
+   /* Add this transform to the list and return true if the transform is
+    * meaningful for this colour type and bit depth - if false then the
+    * transform should have no effect on the image so there's not a lot of
+    * point running it.
+    */
+   int (*add)(struct image_transform *this,
+      const struct image_transform **that, png_byte colour_type,
+      png_byte bit_depth);
+} image_transform;
+
+typedef struct transform_display
+{
+   standard_display this;
+
+   /* Parameters */
+   png_modifier*              pm;
+   const image_transform* transform_list;
+   unsigned int max_gamma_8;
+
+   /* Local variables */
+   png_byte output_colour_type;
+   png_byte output_bit_depth;
+   png_byte unpacked;
+
+   /* Modifications (not necessarily used.) */
+   gama_modification gama_mod;
+   chrm_modification chrm_mod;
+   srgb_modification srgb_mod;
+} transform_display;
+
+/* Set sRGB, cHRM and gAMA transforms as required by the current encoding. */
+static void
+transform_set_encoding(transform_display *this)
+{
+   /* Set up the png_modifier '_current' fields then use these to determine how
+    * to add appropriate chunks.
+    */
+   png_modifier *pm = this->pm;
+
+   modifier_set_encoding(pm);
+
+   if (modifier_color_encoding_is_set(pm))
+   {
+      if (modifier_color_encoding_is_sRGB(pm))
+         srgb_modification_init(&this->srgb_mod, pm, PNG_sRGB_INTENT_ABSOLUTE);
+
+      else
+      {
+         /* Set gAMA and cHRM separately. */
+         gama_modification_init(&this->gama_mod, pm, pm->current_gamma);
+
+         if (pm->current_encoding != 0)
+            chrm_modification_init(&this->chrm_mod, pm, pm->current_encoding);
+      }
+   }
+}
+
+/* Three functions to end the list: */
+static void
+image_transform_ini_end(const image_transform *this,
+   transform_display *that)
+{
+   UNUSED(this)
+   UNUSED(that)
+}
+
+static void
+image_transform_set_end(const image_transform *this,
+   transform_display *that, png_structp pp, png_infop pi)
+{
+   UNUSED(this)
+   UNUSED(that)
+   UNUSED(pp)
+   UNUSED(pi)
+}
+
+/* At the end of the list recalculate the output image pixel value from the
+ * double precision values set up by the preceding 'mod' calls:
+ */
+static unsigned int
+sample_scale(double sample_value, unsigned int scale)
+{
+   sample_value = floor(sample_value * scale + .5);
+
+   /* Return NaN as 0: */
+   if (!(sample_value > 0))
+      sample_value = 0;
+   else if (sample_value > scale)
+      sample_value = scale;
+
+   return (unsigned int)sample_value;
+}
+
+static void
+image_transform_mod_end(const image_transform *this, image_pixel *that,
+    png_const_structp pp, const transform_display *display)
+{
+   unsigned int scale = (1U<<that->sample_depth)-1;
+   int sig_bits = that->sig_bits;
+
+   UNUSED(this)
+   UNUSED(pp)
+   UNUSED(display)
+
+   /* At the end recalculate the digitized red green and blue values according
+    * to the current sample_depth of the pixel.
+    *
+    * The sample value is simply scaled to the maximum, checking for over
+    * and underflow (which can both happen for some image transforms,
+    * including simple size scaling, though libpng doesn't do that at present.
+    */
+   that->red = sample_scale(that->redf, scale);
+
+   /* This is a bit bogus; really the above calculation should use the red_sBIT
+    * value, not sample_depth, but because libpng does png_set_shift by just
+    * shifting the bits we get errors if we don't do it the same way.
+    */
+   if (sig_bits && that->red_sBIT < that->sample_depth)
+      that->red >>= that->sample_depth - that->red_sBIT;
+
+   /* The error value is increased, at the end, according to the lowest sBIT
+    * value seen.  Common sense tells us that the intermediate integer
+    * representations are no more accurate than +/- 0.5 in the integral values,
+    * the sBIT allows the implementation to be worse than this.  In addition the
+    * PNG specification actually permits any error within the range (-1..+1),
+    * but that is ignored here.  Instead the final digitized value is compared,
+    * below to the digitized value of the error limits - this has the net effect
+    * of allowing (almost) +/-1 in the output value.  It's difficult to see how
+    * any algorithm that digitizes intermediate results can be more accurate.
+    */
+   that->rede += 1./(2*((1U<<that->red_sBIT)-1));
+
+   if (that->colour_type & PNG_COLOR_MASK_COLOR)
+   {
+      that->green = sample_scale(that->greenf, scale);
+      if (sig_bits && that->green_sBIT < that->sample_depth)
+         that->green >>= that->sample_depth - that->green_sBIT;
+
+      that->blue = sample_scale(that->bluef, scale);
+      if (sig_bits && that->blue_sBIT < that->sample_depth)
+         that->blue >>= that->sample_depth - that->blue_sBIT;
+
+      that->greene += 1./(2*((1U<<that->green_sBIT)-1));
+      that->bluee += 1./(2*((1U<<that->blue_sBIT)-1));
+   }
+   else
+   {
+      that->blue = that->green = that->red;
+      that->bluef = that->greenf = that->redf;
+      that->bluee = that->greene = that->rede;
+   }
+
+   if ((that->colour_type & PNG_COLOR_MASK_ALPHA) ||
+      that->colour_type == PNG_COLOR_TYPE_PALETTE)
+   {
+      that->alpha = sample_scale(that->alphaf, scale);
+      that->alphae += 1./(2*((1U<<that->alpha_sBIT)-1));
+   }
+   else
+   {
+      that->alpha = scale; /* opaque */
+      that->alphaf = 1;    /* Override this. */
+      that->alphae = 0;    /* It's exact ;-) */
+   }
+
+   if (sig_bits && that->alpha_sBIT < that->sample_depth)
+      that->alpha >>= that->sample_depth - that->alpha_sBIT;
+}
+
+/* Static 'end' structure: */
+static image_transform image_transform_end =
+{
+   "(end)", /* name */
+   1, /* enable */
+   0, /* list */
+   0, /* global_use */
+   0, /* local_use */
+   0, /* next */
+   image_transform_ini_end,
+   image_transform_set_end,
+   image_transform_mod_end,
+   0 /* never called, I want it to crash if it is! */
+};
+
+/* Reader callbacks and implementations, where they differ from the standard
+ * ones.
+ */
+static void
+transform_display_init(transform_display *dp, png_modifier *pm, png_uint_32 id,
+    const image_transform *transform_list)
+{
+   memset(dp, 0, sizeof *dp);
+
+   /* Standard fields */
+   standard_display_init(&dp->this, &pm->this, id, do_read_interlace,
+      pm->use_update_info);
+
+   /* Parameter fields */
+   dp->pm = pm;
+   dp->transform_list = transform_list;
+   dp->max_gamma_8 = 16;
+
+   /* Local variable fields */
+   dp->output_colour_type = 255; /* invalid */
+   dp->output_bit_depth = 255;  /* invalid */
+   dp->unpacked = 0; /* not unpacked */
+}
+
+static void
+transform_info_imp(transform_display *dp, png_structp pp, png_infop pi)
+{
+   /* Reuse the standard stuff as appropriate. */
+   standard_info_part1(&dp->this, pp, pi);
+
+   /* Now set the list of transforms. */
+   dp->transform_list->set(dp->transform_list, dp, pp, pi);
+
+   /* Update the info structure for these transforms: */
+   {
+      int i = dp->this.use_update_info;
+      /* Always do one call, even if use_update_info is 0. */
+      do
+         png_read_update_info(pp, pi);
+      while (--i > 0);
+   }
+
+   /* And get the output information into the standard_display */
+   standard_info_part2(&dp->this, pp, pi, 1/*images*/);
+
+   /* Plus the extra stuff we need for the transform tests: */
+   dp->output_colour_type = png_get_color_type(pp, pi);
+   dp->output_bit_depth = png_get_bit_depth(pp, pi);
+
+   /* If png_set_filler is in action then fake the output color type to include
+    * an alpha channel where appropriate.
+    */
+   if (dp->output_bit_depth >= 8 &&
+       (dp->output_colour_type == PNG_COLOR_TYPE_RGB ||
+        dp->output_colour_type == PNG_COLOR_TYPE_GRAY) && dp->this.filler)
+       dp->output_colour_type |= 4;
+
+   /* Validate the combination of colour type and bit depth that we are getting
+    * out of libpng; the semantics of something not in the PNG spec are, at
+    * best, unclear.
+    */
+   switch (dp->output_colour_type)
+   {
+   case PNG_COLOR_TYPE_PALETTE:
+      if (dp->output_bit_depth > 8) goto error;
+      /* FALLTHROUGH */
+   case PNG_COLOR_TYPE_GRAY:
+      if (dp->output_bit_depth == 1 || dp->output_bit_depth == 2 ||
+         dp->output_bit_depth == 4)
+         break;
+      /* FALLTHROUGH */
+   default:
+      if (dp->output_bit_depth == 8 || dp->output_bit_depth == 16)
+         break;
+      /* FALLTHROUGH */
+   error:
+      {
+         char message[128];
+         size_t pos;
+
+         pos = safecat(message, sizeof message, 0,
+            "invalid final bit depth: colour type(");
+         pos = safecatn(message, sizeof message, pos, dp->output_colour_type);
+         pos = safecat(message, sizeof message, pos, ") with bit depth: ");
+         pos = safecatn(message, sizeof message, pos, dp->output_bit_depth);
+
+         png_error(pp, message);
+      }
+   }
+
+   /* Use a test pixel to check that the output agrees with what we expect -
+    * this avoids running the whole test if the output is unexpected.  This also
+    * checks for internal errors.
+    */
+   {
+      image_pixel test_pixel;
+
+      memset(&test_pixel, 0, sizeof test_pixel);
+      test_pixel.colour_type = dp->this.colour_type; /* input */
+      test_pixel.bit_depth = dp->this.bit_depth;
+      if (test_pixel.colour_type == PNG_COLOR_TYPE_PALETTE)
+         test_pixel.sample_depth = 8;
+      else
+         test_pixel.sample_depth = test_pixel.bit_depth;
+      /* Don't need sBIT here, but it must be set to non-zero to avoid
+       * arithmetic overflows.
+       */
+      test_pixel.have_tRNS = dp->this.is_transparent != 0;
+      test_pixel.red_sBIT = test_pixel.green_sBIT = test_pixel.blue_sBIT =
+         test_pixel.alpha_sBIT = test_pixel.sample_depth;
+
+      dp->transform_list->mod(dp->transform_list, &test_pixel, pp, dp);
+
+      if (test_pixel.colour_type != dp->output_colour_type)
+      {
+         char message[128];
+         size_t pos = safecat(message, sizeof message, 0, "colour type ");
+
+         pos = safecatn(message, sizeof message, pos, dp->output_colour_type);
+         pos = safecat(message, sizeof message, pos, " expected ");
+         pos = safecatn(message, sizeof message, pos, test_pixel.colour_type);
+
+         png_error(pp, message);
+      }
+
+      if (test_pixel.bit_depth != dp->output_bit_depth)
+      {
+         char message[128];
+         size_t pos = safecat(message, sizeof message, 0, "bit depth ");
+
+         pos = safecatn(message, sizeof message, pos, dp->output_bit_depth);
+         pos = safecat(message, sizeof message, pos, " expected ");
+         pos = safecatn(message, sizeof message, pos, test_pixel.bit_depth);
+
+         png_error(pp, message);
+      }
+
+      /* If both bit depth and colour type are correct check the sample depth.
+       */
+      if (test_pixel.colour_type == PNG_COLOR_TYPE_PALETTE &&
+          test_pixel.sample_depth != 8) /* oops - internal error! */
+         png_error(pp, "pngvalid: internal: palette sample depth not 8");
+      else if (dp->unpacked && test_pixel.bit_depth != 8)
+         png_error(pp, "pngvalid: internal: bad unpacked pixel depth");
+      else if (!dp->unpacked && test_pixel.colour_type != PNG_COLOR_TYPE_PALETTE
+              && test_pixel.bit_depth != test_pixel.sample_depth)
+      {
+         char message[128];
+         size_t pos = safecat(message, sizeof message, 0,
+            "internal: sample depth ");
+
+         /* Because unless something has set 'unpacked' or the image is palette
+          * mapped we expect the transform to keep sample depth and bit depth
+          * the same.
+          */
+         pos = safecatn(message, sizeof message, pos, test_pixel.sample_depth);
+         pos = safecat(message, sizeof message, pos, " expected ");
+         pos = safecatn(message, sizeof message, pos, test_pixel.bit_depth);
+
+         png_error(pp, message);
+      }
+      else if (test_pixel.bit_depth != dp->output_bit_depth)
+      {
+         /* This could be a libpng error too; libpng has not produced what we
+          * expect for the output bit depth.
+          */
+         char message[128];
+         size_t pos = safecat(message, sizeof message, 0,
+            "internal: bit depth ");
+
+         pos = safecatn(message, sizeof message, pos, dp->output_bit_depth);
+         pos = safecat(message, sizeof message, pos, " expected ");
+         pos = safecatn(message, sizeof message, pos, test_pixel.bit_depth);
+
+         png_error(pp, message);
+      }
+   }
+}
+
+static void PNGCBAPI
+transform_info(png_structp pp, png_infop pi)
+{
+   transform_info_imp(voidcast(transform_display*, png_get_progressive_ptr(pp)),
+      pp, pi);
+}
+
+static void
+transform_range_check(png_const_structp pp, unsigned int r, unsigned int g,
+   unsigned int b, unsigned int a, unsigned int in_digitized, double in,
+   unsigned int out, png_byte sample_depth, double err, double limit,
+   const char *name, double digitization_error)
+{
+   /* Compare the scaled, digitzed, values of our local calculation (in+-err)
+    * with the digitized values libpng produced;  'sample_depth' is the actual
+    * digitization depth of the libpng output colors (the bit depth except for
+    * palette images where it is always 8.)  The check on 'err' is to detect
+    * internal errors in pngvalid itself.
+    */
+   unsigned int max = (1U<<sample_depth)-1;
+   double in_min = ceil((in-err)*max - digitization_error);
+   double in_max = floor((in+err)*max + digitization_error);
+   if (debugonly(err > limit ||) !(out >= in_min && out <= in_max))
+   {
+      char message[256];
+      size_t pos;
+
+      pos = safecat(message, sizeof message, 0, name);
+      pos = safecat(message, sizeof message, pos, " output value error: rgba(");
+      pos = safecatn(message, sizeof message, pos, r);
+      pos = safecat(message, sizeof message, pos, ",");
+      pos = safecatn(message, sizeof message, pos, g);
+      pos = safecat(message, sizeof message, pos, ",");
+      pos = safecatn(message, sizeof message, pos, b);
+      pos = safecat(message, sizeof message, pos, ",");
+      pos = safecatn(message, sizeof message, pos, a);
+      pos = safecat(message, sizeof message, pos, "): ");
+      pos = safecatn(message, sizeof message, pos, out);
+      pos = safecat(message, sizeof message, pos, " expected: ");
+      pos = safecatn(message, sizeof message, pos, in_digitized);
+      pos = safecat(message, sizeof message, pos, " (");
+      pos = safecatd(message, sizeof message, pos, (in-err)*max, 3);
+      pos = safecat(message, sizeof message, pos, "..");
+      pos = safecatd(message, sizeof message, pos, (in+err)*max, 3);
+      pos = safecat(message, sizeof message, pos, ")");
+
+      png_error(pp, message);
+   }
+
+   UNUSED(limit)
+}
+
+static void
+transform_image_validate(transform_display *dp, png_const_structp pp,
+   png_infop pi)
+{
+   /* Constants for the loop below: */
+   const png_store* const ps = dp->this.ps;
+   png_byte in_ct = dp->this.colour_type;
+   png_byte in_bd = dp->this.bit_depth;
+   png_uint_32 w = dp->this.w;
+   png_uint_32 h = dp->this.h;
+   png_byte out_ct = dp->output_colour_type;
+   png_byte out_bd = dp->output_bit_depth;
+   png_byte sample_depth =
+      (png_byte)(out_ct == PNG_COLOR_TYPE_PALETTE ? 8 : out_bd);
+   png_byte red_sBIT = dp->this.red_sBIT;
+   png_byte green_sBIT = dp->this.green_sBIT;
+   png_byte blue_sBIT = dp->this.blue_sBIT;
+   png_byte alpha_sBIT = dp->this.alpha_sBIT;
+   int have_tRNS = dp->this.is_transparent;
+   double digitization_error;
+
+   store_palette out_palette;
+   png_uint_32 y;
+
+   UNUSED(pi)
+
+   /* Check for row overwrite errors */
+   store_image_check(dp->this.ps, pp, 0);
+
+   /* Read the palette corresponding to the output if the output colour type
+    * indicates a palette, otherwise set out_palette to garbage.
+    */
+   if (out_ct == PNG_COLOR_TYPE_PALETTE)
+   {
+      /* Validate that the palette count itself has not changed - this is not
+       * expected.
+       */
+      int npalette = (-1);
+
+      (void)read_palette(out_palette, &npalette, pp, pi);
+      if (npalette != dp->this.npalette)
+         png_error(pp, "unexpected change in palette size");
+
+      digitization_error = .5;
+   }
+   else
+   {
+      png_byte in_sample_depth;
+
+      memset(out_palette, 0x5e, sizeof out_palette);
+
+      /* use-input-precision means assume that if the input has 8 bit (or less)
+       * samples and the output has 16 bit samples the calculations will be done
+       * with 8 bit precision, not 16.
+       */
+      if (in_ct == PNG_COLOR_TYPE_PALETTE || in_bd < 16)
+         in_sample_depth = 8;
+      else
+         in_sample_depth = in_bd;
+
+      if (sample_depth != 16 || in_sample_depth > 8 ||
+         !dp->pm->calculations_use_input_precision)
+         digitization_error = .5;
+
+      /* Else calculations are at 8 bit precision, and the output actually
+       * consists of scaled 8-bit values, so scale .5 in 8 bits to the 16 bits:
+       */
+      else
+         digitization_error = .5 * 257;
+   }
+
+   for (y=0; y<h; ++y)
+   {
+      png_const_bytep const pRow = store_image_row(ps, pp, 0, y);
+      png_uint_32 x;
+
+      /* The original, standard, row pre-transforms. */
+      png_byte std[STANDARD_ROWMAX];
+
+      transform_row(pp, std, in_ct, in_bd, y);
+
+      /* Go through each original pixel transforming it and comparing with what
+       * libpng did to the same pixel.
+       */
+      for (x=0; x<w; ++x)
+      {
+         image_pixel in_pixel, out_pixel;
+         unsigned int r, g, b, a;
+
+         /* Find out what we think the pixel should be: */
+         image_pixel_init(&in_pixel, std, in_ct, in_bd, x, dp->this.palette,
+                 NULL);
+
+         in_pixel.red_sBIT = red_sBIT;
+         in_pixel.green_sBIT = green_sBIT;
+         in_pixel.blue_sBIT = blue_sBIT;
+         in_pixel.alpha_sBIT = alpha_sBIT;
+         in_pixel.have_tRNS = have_tRNS != 0;
+
+         /* For error detection, below. */
+         r = in_pixel.red;
+         g = in_pixel.green;
+         b = in_pixel.blue;
+         a = in_pixel.alpha;
+
+         /* This applies the transforms to the input data, including output
+          * format operations which must be used when reading the output
+          * pixel that libpng produces.
+          */
+         dp->transform_list->mod(dp->transform_list, &in_pixel, pp, dp);
+
+         /* Read the output pixel and compare it to what we got, we don't
+          * use the error field here, so no need to update sBIT.  in_pixel
+          * says whether we expect libpng to change the output format.
+          */
+         image_pixel_init(&out_pixel, pRow, out_ct, out_bd, x, out_palette,
+                 &in_pixel);
+
+         /* We don't expect changes to the index here even if the bit depth is
+          * changed.
+          */
+         if (in_ct == PNG_COLOR_TYPE_PALETTE &&
+            out_ct == PNG_COLOR_TYPE_PALETTE)
+         {
+            if (in_pixel.palette_index != out_pixel.palette_index)
+               png_error(pp, "unexpected transformed palette index");
+         }
+
+         /* Check the colours for palette images too - in fact the palette could
+          * be separately verified itself in most cases.
+          */
+         if (in_pixel.red != out_pixel.red)
+            transform_range_check(pp, r, g, b, a, in_pixel.red, in_pixel.redf,
+               out_pixel.red, sample_depth, in_pixel.rede,
+               dp->pm->limit + 1./(2*((1U<<in_pixel.red_sBIT)-1)), "red/gray",
+               digitization_error);
+
+         if ((out_ct & PNG_COLOR_MASK_COLOR) != 0 &&
+            in_pixel.green != out_pixel.green)
+            transform_range_check(pp, r, g, b, a, in_pixel.green,
+               in_pixel.greenf, out_pixel.green, sample_depth, in_pixel.greene,
+               dp->pm->limit + 1./(2*((1U<<in_pixel.green_sBIT)-1)), "green",
+               digitization_error);
+
+         if ((out_ct & PNG_COLOR_MASK_COLOR) != 0 &&
+            in_pixel.blue != out_pixel.blue)
+            transform_range_check(pp, r, g, b, a, in_pixel.blue, in_pixel.bluef,
+               out_pixel.blue, sample_depth, in_pixel.bluee,
+               dp->pm->limit + 1./(2*((1U<<in_pixel.blue_sBIT)-1)), "blue",
+               digitization_error);
+
+         if ((out_ct & PNG_COLOR_MASK_ALPHA) != 0 &&
+            in_pixel.alpha != out_pixel.alpha)
+            transform_range_check(pp, r, g, b, a, in_pixel.alpha,
+               in_pixel.alphaf, out_pixel.alpha, sample_depth, in_pixel.alphae,
+               dp->pm->limit + 1./(2*((1U<<in_pixel.alpha_sBIT)-1)), "alpha",
+               digitization_error);
+      } /* pixel (x) loop */
+   } /* row (y) loop */
+
+   /* Record that something was actually checked to avoid a false positive. */
+   dp->this.ps->validated = 1;
+}
+
+static void PNGCBAPI
+transform_end(png_structp ppIn, png_infop pi)
+{
+   png_const_structp pp = ppIn;
+   transform_display *dp = voidcast(transform_display*,
+      png_get_progressive_ptr(pp));
+
+   if (!dp->this.speed)
+      transform_image_validate(dp, pp, pi);
+   else
+      dp->this.ps->validated = 1;
+}
+
+/* A single test run. */
+static void
+transform_test(png_modifier *pmIn, png_uint_32 idIn,
+    const image_transform* transform_listIn, const char * const name)
+{
+   transform_display d;
+   context(&pmIn->this, fault);
+
+   transform_display_init(&d, pmIn, idIn, transform_listIn);
+
+   Try
+   {
+      size_t pos = 0;
+      png_structp pp;
+      png_infop pi;
+      char full_name[256];
+
+      /* Make sure the encoding fields are correct and enter the required
+       * modifications.
+       */
+      transform_set_encoding(&d);
+
+      /* Add any modifications required by the transform list. */
+      d.transform_list->ini(d.transform_list, &d);
+
+      /* Add the color space information, if any, to the name. */
+      pos = safecat(full_name, sizeof full_name, pos, name);
+      pos = safecat_current_encoding(full_name, sizeof full_name, pos, d.pm);
+
+      /* Get a png_struct for reading the image. */
+      pp = set_modifier_for_read(d.pm, &pi, d.this.id, full_name);
+      standard_palette_init(&d.this);
+
+#     if 0
+         /* Logging (debugging only) */
+         {
+            char buffer[256];
+
+            (void)store_message(&d.pm->this, pp, buffer, sizeof buffer, 0,
+               "running test");
+
+            fprintf(stderr, "%s\n", buffer);
+         }
+#     endif
+
+      /* Introduce the correct read function. */
+      if (d.pm->this.progressive)
+      {
+         /* Share the row function with the standard implementation. */
+         png_set_progressive_read_fn(pp, &d, transform_info, progressive_row,
+            transform_end);
+
+         /* Now feed data into the reader until we reach the end: */
+         modifier_progressive_read(d.pm, pp, pi);
+      }
+      else
+      {
+         /* modifier_read expects a png_modifier* */
+         png_set_read_fn(pp, d.pm, modifier_read);
+
+         /* Check the header values: */
+         png_read_info(pp, pi);
+
+         /* Process the 'info' requirements. Only one image is generated */
+         transform_info_imp(&d, pp, pi);
+
+         sequential_row(&d.this, pp, pi, -1, 0);
+
+         if (!d.this.speed)
+            transform_image_validate(&d, pp, pi);
+         else
+            d.this.ps->validated = 1;
+      }
+
+      modifier_reset(d.pm);
+   }
+
+   Catch(fault)
+   {
+      modifier_reset(voidcast(png_modifier*,(void*)fault));
+   }
+}
+
+/* The transforms: */
+#define ITSTRUCT(name) image_transform_##name
+#define ITDATA(name) image_transform_data_##name
+#define image_transform_ini image_transform_default_ini
+#define IT(name)\
+static image_transform ITSTRUCT(name) =\
+{\
+   #name,\
+   1, /*enable*/\
+   &PT, /*list*/\
+   0, /*global_use*/\
+   0, /*local_use*/\
+   0, /*next*/\
+   image_transform_ini,\
+   image_transform_png_set_##name##_set,\
+   image_transform_png_set_##name##_mod,\
+   image_transform_png_set_##name##_add\
+}
+#define PT ITSTRUCT(end) /* stores the previous transform */
+
+/* To save code: */
+extern void image_transform_default_ini(const image_transform *this,
+   transform_display *that); /* silence GCC warnings */
+
+void /* private, but almost always needed */
+image_transform_default_ini(const image_transform *this,
+    transform_display *that)
+{
+   this->next->ini(this->next, that);
+}
+
+#ifdef PNG_READ_BACKGROUND_SUPPORTED
+static int
+image_transform_default_add(image_transform *this,
+    const image_transform **that, png_byte colour_type, png_byte bit_depth)
+{
+   UNUSED(colour_type)
+   UNUSED(bit_depth)
+
+   this->next = *that;
+   *that = this;
+
+   return 1;
+}
+#endif
+
+#ifdef PNG_READ_EXPAND_SUPPORTED
+/* png_set_palette_to_rgb */
+static void
+image_transform_png_set_palette_to_rgb_set(const image_transform *this,
+    transform_display *that, png_structp pp, png_infop pi)
+{
+   png_set_palette_to_rgb(pp);
+   this->next->set(this->next, that, pp, pi);
+}
+
+static void
+image_transform_png_set_palette_to_rgb_mod(const image_transform *this,
+    image_pixel *that, png_const_structp pp,
+    const transform_display *display)
+{
+   if (that->colour_type == PNG_COLOR_TYPE_PALETTE)
+      image_pixel_convert_PLTE(that);
+
+   this->next->mod(this->next, that, pp, display);
+}
+
+static int
+image_transform_png_set_palette_to_rgb_add(image_transform *this,
+    const image_transform **that, png_byte colour_type, png_byte bit_depth)
+{
+   UNUSED(bit_depth)
+
+   this->next = *that;
+   *that = this;
+
+   return colour_type == PNG_COLOR_TYPE_PALETTE;
+}
+
+IT(palette_to_rgb);
+#undef PT
+#define PT ITSTRUCT(palette_to_rgb)
+#endif /* PNG_READ_EXPAND_SUPPORTED */
+
+#ifdef PNG_READ_EXPAND_SUPPORTED
+/* png_set_tRNS_to_alpha */
+static void
+image_transform_png_set_tRNS_to_alpha_set(const image_transform *this,
+   transform_display *that, png_structp pp, png_infop pi)
+{
+   png_set_tRNS_to_alpha(pp);
+
+   /* If there was a tRNS chunk that would get expanded and add an alpha
+    * channel is_transparent must be updated:
+    */
+   if (that->this.has_tRNS)
+      that->this.is_transparent = 1;
+
+   this->next->set(this->next, that, pp, pi);
+}
+
+static void
+image_transform_png_set_tRNS_to_alpha_mod(const image_transform *this,
+   image_pixel *that, png_const_structp pp,
+   const transform_display *display)
+{
+#if PNG_LIBPNG_VER < 10700
+   /* LIBPNG BUG: this always forces palette images to RGB. */
+   if (that->colour_type == PNG_COLOR_TYPE_PALETTE)
+      image_pixel_convert_PLTE(that);
+#endif
+
+   /* This effectively does an 'expand' only if there is some transparency to
+    * convert to an alpha channel.
+    */
+   if (that->have_tRNS)
+#     if PNG_LIBPNG_VER >= 10700
+         if (that->colour_type != PNG_COLOR_TYPE_PALETTE &&
+             (that->colour_type & PNG_COLOR_MASK_ALPHA) == 0)
+#     endif
+      image_pixel_add_alpha(that, &display->this, 0/*!for background*/);
+
+#if PNG_LIBPNG_VER < 10700
+   /* LIBPNG BUG: otherwise libpng still expands to 8 bits! */
+   else
+   {
+      if (that->bit_depth < 8)
+         that->bit_depth =8;
+      if (that->sample_depth < 8)
+         that->sample_depth = 8;
+   }
+#endif
+
+   this->next->mod(this->next, that, pp, display);
+}
+
+static int
+image_transform_png_set_tRNS_to_alpha_add(image_transform *this,
+    const image_transform **that, png_byte colour_type, png_byte bit_depth)
+{
+   UNUSED(bit_depth)
+
+   this->next = *that;
+   *that = this;
+
+   /* We don't know yet whether there will be a tRNS chunk, but we know that
+    * this transformation should do nothing if there already is an alpha
+    * channel.  In addition, after the bug fix in 1.7.0, there is no longer
+    * any action on a palette image.
+    */
+   return
+#  if PNG_LIBPNG_VER >= 10700
+      colour_type != PNG_COLOR_TYPE_PALETTE &&
+#  endif
+   (colour_type & PNG_COLOR_MASK_ALPHA) == 0;
+}
+
+IT(tRNS_to_alpha);
+#undef PT
+#define PT ITSTRUCT(tRNS_to_alpha)
+#endif /* PNG_READ_EXPAND_SUPPORTED */
+
+#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
+/* png_set_gray_to_rgb */
+static void
+image_transform_png_set_gray_to_rgb_set(const image_transform *this,
+    transform_display *that, png_structp pp, png_infop pi)
+{
+   png_set_gray_to_rgb(pp);
+   /* NOTE: this doesn't result in tRNS expansion. */
+   this->next->set(this->next, that, pp, pi);
+}
+
+static void
+image_transform_png_set_gray_to_rgb_mod(const image_transform *this,
+    image_pixel *that, png_const_structp pp,
+    const transform_display *display)
+{
+   /* NOTE: we can actually pend the tRNS processing at this point because we
+    * can correctly recognize the original pixel value even though we have
+    * mapped the one gray channel to the three RGB ones, but in fact libpng
+    * doesn't do this, so we don't either.
+    */
+   if ((that->colour_type & PNG_COLOR_MASK_COLOR) == 0 && that->have_tRNS)
+      image_pixel_add_alpha(that, &display->this, 0/*!for background*/);
+
+   /* Simply expand the bit depth and alter the colour type as required. */
+   if (that->colour_type == PNG_COLOR_TYPE_GRAY)
+   {
+      /* RGB images have a bit depth at least equal to '8' */
+      if (that->bit_depth < 8)
+         that->sample_depth = that->bit_depth = 8;
+
+      /* And just changing the colour type works here because the green and blue
+       * channels are being maintained in lock-step with the red/gray:
+       */
+      that->colour_type = PNG_COLOR_TYPE_RGB;
+   }
+
+   else if (that->colour_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+      that->colour_type = PNG_COLOR_TYPE_RGB_ALPHA;
+
+   this->next->mod(this->next, that, pp, display);
+}
+
+static int
+image_transform_png_set_gray_to_rgb_add(image_transform *this,
+    const image_transform **that, png_byte colour_type, png_byte bit_depth)
+{
+   UNUSED(bit_depth)
+
+   this->next = *that;
+   *that = this;
+
+   return (colour_type & PNG_COLOR_MASK_COLOR) == 0;
+}
+
+IT(gray_to_rgb);
+#undef PT
+#define PT ITSTRUCT(gray_to_rgb)
+#endif /* PNG_READ_GRAY_TO_RGB_SUPPORTED */
+
+#ifdef PNG_READ_EXPAND_SUPPORTED
+/* png_set_expand */
+static void
+image_transform_png_set_expand_set(const image_transform *this,
+    transform_display *that, png_structp pp, png_infop pi)
+{
+   png_set_expand(pp);
+
+   if (that->this.has_tRNS)
+      that->this.is_transparent = 1;
+
+   this->next->set(this->next, that, pp, pi);
+}
+
+static void
+image_transform_png_set_expand_mod(const image_transform *this,
+    image_pixel *that, png_const_structp pp,
+    const transform_display *display)
+{
+   /* The general expand case depends on what the colour type is: */
+   if (that->colour_type == PNG_COLOR_TYPE_PALETTE)
+      image_pixel_convert_PLTE(that);
+   else if (that->bit_depth < 8) /* grayscale */
+      that->sample_depth = that->bit_depth = 8;
+
+   if (that->have_tRNS)
+      image_pixel_add_alpha(that, &display->this, 0/*!for background*/);
+
+   this->next->mod(this->next, that, pp, display);
+}
+
+static int
+image_transform_png_set_expand_add(image_transform *this,
+    const image_transform **that, png_byte colour_type, png_byte bit_depth)
+{
+   UNUSED(bit_depth)
+
+   this->next = *that;
+   *that = this;
+
+   /* 'expand' should do nothing for RGBA or GA input - no tRNS and the bit
+    * depth is at least 8 already.
+    */
+   return (colour_type & PNG_COLOR_MASK_ALPHA) == 0;
+}
+
+IT(expand);
+#undef PT
+#define PT ITSTRUCT(expand)
+#endif /* PNG_READ_EXPAND_SUPPORTED */
+
+#ifdef PNG_READ_EXPAND_SUPPORTED
+/* png_set_expand_gray_1_2_4_to_8
+ * Pre 1.7.0 LIBPNG BUG: this just does an 'expand'
+ */
+static void
+image_transform_png_set_expand_gray_1_2_4_to_8_set(
+    const image_transform *this, transform_display *that, png_structp pp,
+    png_infop pi)
+{
+   png_set_expand_gray_1_2_4_to_8(pp);
+   /* NOTE: don't expect this to expand tRNS */
+   this->next->set(this->next, that, pp, pi);
+}
+
+static void
+image_transform_png_set_expand_gray_1_2_4_to_8_mod(
+    const image_transform *this, image_pixel *that, png_const_structp pp,
+    const transform_display *display)
+{
+#if PNG_LIBPNG_VER < 10700
+   image_transform_png_set_expand_mod(this, that, pp, display);
+#else
+   /* Only expand grayscale of bit depth less than 8: */
+   if (that->colour_type == PNG_COLOR_TYPE_GRAY &&
+       that->bit_depth < 8)
+      that->sample_depth = that->bit_depth = 8;
+
+   this->next->mod(this->next, that, pp, display);
+#endif /* 1.7 or later */
+}
+
+static int
+image_transform_png_set_expand_gray_1_2_4_to_8_add(image_transform *this,
+    const image_transform **that, png_byte colour_type, png_byte bit_depth)
+{
+#if PNG_LIBPNG_VER < 10700
+   return image_transform_png_set_expand_add(this, that, colour_type,
+      bit_depth);
+#else
+   UNUSED(bit_depth)
+
+   this->next = *that;
+   *that = this;
+
+   /* This should do nothing unless the color type is gray and the bit depth is
+    * less than 8:
+    */
+   return colour_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8;
+#endif /* 1.7 or later */
+}
+
+IT(expand_gray_1_2_4_to_8);
+#undef PT
+#define PT ITSTRUCT(expand_gray_1_2_4_to_8)
+#endif /* PNG_READ_EXPAND_SUPPORTED */
+
+#ifdef PNG_READ_EXPAND_16_SUPPORTED
+/* png_set_expand_16 */
+static void
+image_transform_png_set_expand_16_set(const image_transform *this,
+    transform_display *that, png_structp pp, png_infop pi)
+{
+   png_set_expand_16(pp);
+
+   /* NOTE: prior to 1.7 libpng does SET_EXPAND as well, so tRNS is expanded. */
+#  if PNG_LIBPNG_VER < 10700
+      if (that->this.has_tRNS)
+         that->this.is_transparent = 1;
+#  endif
+
+   this->next->set(this->next, that, pp, pi);
+}
+
+static void
+image_transform_png_set_expand_16_mod(const image_transform *this,
+    image_pixel *that, png_const_structp pp,
+    const transform_display *display)
+{
+   /* Expect expand_16 to expand everything to 16 bits as a result of also
+    * causing 'expand' to happen.
+    */
+   if (that->colour_type == PNG_COLOR_TYPE_PALETTE)
+      image_pixel_convert_PLTE(that);
+
+   if (that->have_tRNS)
+      image_pixel_add_alpha(that, &display->this, 0/*!for background*/);
+
+   if (that->bit_depth < 16)
+      that->sample_depth = that->bit_depth = 16;
+
+   this->next->mod(this->next, that, pp, display);
+}
+
+static int
+image_transform_png_set_expand_16_add(image_transform *this,
+    const image_transform **that, png_byte colour_type, png_byte bit_depth)
+{
+   UNUSED(colour_type)
+
+   this->next = *that;
+   *that = this;
+
+   /* expand_16 does something unless the bit depth is already 16. */
+   return bit_depth < 16;
+}
+
+IT(expand_16);
+#undef PT
+#define PT ITSTRUCT(expand_16)
+#endif /* PNG_READ_EXPAND_16_SUPPORTED */
+
+#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED  /* API added in 1.5.4 */
+/* png_set_scale_16 */
+static void
+image_transform_png_set_scale_16_set(const image_transform *this,
+    transform_display *that, png_structp pp, png_infop pi)
+{
+   png_set_scale_16(pp);
+#  if PNG_LIBPNG_VER < 10700
+      /* libpng will limit the gamma table size: */
+      that->max_gamma_8 = PNG_MAX_GAMMA_8;
+#  endif
+   this->next->set(this->next, that, pp, pi);
+}
+
+static void
+image_transform_png_set_scale_16_mod(const image_transform *this,
+    image_pixel *that, png_const_structp pp,
+    const transform_display *display)
+{
+   if (that->bit_depth == 16)
+   {
+      that->sample_depth = that->bit_depth = 8;
+      if (that->red_sBIT > 8) that->red_sBIT = 8;
+      if (that->green_sBIT > 8) that->green_sBIT = 8;
+      if (that->blue_sBIT > 8) that->blue_sBIT = 8;
+      if (that->alpha_sBIT > 8) that->alpha_sBIT = 8;
+   }
+
+   this->next->mod(this->next, that, pp, display);
+}
+
+static int
+image_transform_png_set_scale_16_add(image_transform *this,
+    const image_transform **that, png_byte colour_type, png_byte bit_depth)
+{
+   UNUSED(colour_type)
+
+   this->next = *that;
+   *that = this;
+
+   return bit_depth > 8;
+}
+
+IT(scale_16);
+#undef PT
+#define PT ITSTRUCT(scale_16)
+#endif /* PNG_READ_SCALE_16_TO_8_SUPPORTED (1.5.4 on) */
+
+#ifdef PNG_READ_16_TO_8_SUPPORTED /* the default before 1.5.4 */
+/* png_set_strip_16 */
+static void
+image_transform_png_set_strip_16_set(const image_transform *this,
+    transform_display *that, png_structp pp, png_infop pi)
+{
+   png_set_strip_16(pp);
+#  if PNG_LIBPNG_VER < 10700
+      /* libpng will limit the gamma table size: */
+      that->max_gamma_8 = PNG_MAX_GAMMA_8;
+#  endif
+   this->next->set(this->next, that, pp, pi);
+}
+
+static void
+image_transform_png_set_strip_16_mod(const image_transform *this,
+    image_pixel *that, png_const_structp pp,
+    const transform_display *display)
+{
+   if (that->bit_depth == 16)
+   {
+      that->sample_depth = that->bit_depth = 8;
+      if (that->red_sBIT > 8) that->red_sBIT = 8;
+      if (that->green_sBIT > 8) that->green_sBIT = 8;
+      if (that->blue_sBIT > 8) that->blue_sBIT = 8;
+      if (that->alpha_sBIT > 8) that->alpha_sBIT = 8;
+
+      /* Prior to 1.5.4 png_set_strip_16 would use an 'accurate' method if this
+       * configuration option is set.  From 1.5.4 the flag is never set and the
+       * 'scale' API (above) must be used.
+       */
+#     ifdef PNG_READ_ACCURATE_SCALE_SUPPORTED
+#        if PNG_LIBPNG_VER >= 10504
+#           error PNG_READ_ACCURATE_SCALE should not be set
+#        endif
+
+         /* The strip 16 algorithm drops the low 8 bits rather than calculating
+          * 1/257, so we need to adjust the permitted errors appropriately:
+          * Notice that this is only relevant prior to the addition of the
+          * png_set_scale_16 API in 1.5.4 (but 1.5.4+ always defines the above!)
+          */
+         {
+            const double d = (255-128.5)/65535;
+            that->rede += d;
+            that->greene += d;
+            that->bluee += d;
+            that->alphae += d;
+         }
+#     endif
+   }
+
+   this->next->mod(this->next, that, pp, display);
+}
+
+static int
+image_transform_png_set_strip_16_add(image_transform *this,
+    const image_transform **that, png_byte colour_type, png_byte bit_depth)
+{
+   UNUSED(colour_type)
+
+   this->next = *that;
+   *that = this;
+
+   return bit_depth > 8;
+}
+
+IT(strip_16);
+#undef PT
+#define PT ITSTRUCT(strip_16)
+#endif /* PNG_READ_16_TO_8_SUPPORTED */
+
+#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
+/* png_set_strip_alpha */
+static void
+image_transform_png_set_strip_alpha_set(const image_transform *this,
+    transform_display *that, png_structp pp, png_infop pi)
+{
+   png_set_strip_alpha(pp);
+   this->next->set(this->next, that, pp, pi);
+}
+
+static void
+image_transform_png_set_strip_alpha_mod(const image_transform *this,
+    image_pixel *that, png_const_structp pp,
+    const transform_display *display)
+{
+   if (that->colour_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+      that->colour_type = PNG_COLOR_TYPE_GRAY;
+   else if (that->colour_type == PNG_COLOR_TYPE_RGB_ALPHA)
+      that->colour_type = PNG_COLOR_TYPE_RGB;
+
+   that->have_tRNS = 0;
+   that->alphaf = 1;
+
+   this->next->mod(this->next, that, pp, display);
+}
+
+static int
+image_transform_png_set_strip_alpha_add(image_transform *this,
+    const image_transform **that, png_byte colour_type, png_byte bit_depth)
+{
+   UNUSED(bit_depth)
+
+   this->next = *that;
+   *that = this;
+
+   return (colour_type & PNG_COLOR_MASK_ALPHA) != 0;
+}
+
+IT(strip_alpha);
+#undef PT
+#define PT ITSTRUCT(strip_alpha)
+#endif /* PNG_READ_STRIP_ALPHA_SUPPORTED */
+
+#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
+/* png_set_rgb_to_gray(png_structp, int err_action, double red, double green)
+ * png_set_rgb_to_gray_fixed(png_structp, int err_action, png_fixed_point red,
+ *    png_fixed_point green)
+ * png_get_rgb_to_gray_status
+ *
+ * The 'default' test here uses values known to be used inside libpng prior to
+ * 1.7.0:
+ *
+ *   red:    6968
+ *   green: 23434
+ *   blue:   2366
+ *
+ * These values are being retained for compatibility, along with the somewhat
+ * broken truncation calculation in the fast-and-inaccurate code path.  Older
+ * versions of libpng will fail the accuracy tests below because they use the
+ * truncation algorithm everywhere.
+ */
+#define data ITDATA(rgb_to_gray)
+static struct
+{
+   double gamma;      /* File gamma to use in processing */
+
+   /* The following are the parameters for png_set_rgb_to_gray: */
+#  ifdef PNG_FLOATING_POINT_SUPPORTED
+      double red_to_set;
+      double green_to_set;
+#  else
+      png_fixed_point red_to_set;
+      png_fixed_point green_to_set;
+#  endif
+
+   /* The actual coefficients: */
+   double red_coefficient;
+   double green_coefficient;
+   double blue_coefficient;
+
+   /* Set if the coeefficients have been overridden. */
+   int coefficients_overridden;
+} data;
+
+#undef image_transform_ini
+#define image_transform_ini image_transform_png_set_rgb_to_gray_ini
+static void
+image_transform_png_set_rgb_to_gray_ini(const image_transform *this,
+    transform_display *that)
+{
+   png_modifier *pm = that->pm;
+   const color_encoding *e = pm->current_encoding;
+
+   UNUSED(this)
+
+   /* Since we check the encoding this flag must be set: */
+   pm->test_uses_encoding = 1;
+
+   /* If 'e' is not NULL chromaticity information is present and either a cHRM
+    * or an sRGB chunk will be inserted.
+    */
+   if (e != 0)
+   {
+      /* Coefficients come from the encoding, but may need to be normalized to a
+       * white point Y of 1.0
+       */
+      const double whiteY = e->red.Y + e->green.Y + e->blue.Y;
+
+      data.red_coefficient = e->red.Y;
+      data.green_coefficient = e->green.Y;
+      data.blue_coefficient = e->blue.Y;
+
+      if (whiteY != 1)
+      {
+         data.red_coefficient /= whiteY;
+         data.green_coefficient /= whiteY;
+         data.blue_coefficient /= whiteY;
+      }
+   }
+
+   else
+   {
+      /* The default (built in) coeffcients, as above: */
+#     if PNG_LIBPNG_VER < 10700
+         data.red_coefficient = 6968 / 32768.;
+         data.green_coefficient = 23434 / 32768.;
+         data.blue_coefficient = 2366 / 32768.;
+#     else
+         data.red_coefficient = .2126;
+         data.green_coefficient = .7152;
+         data.blue_coefficient = .0722;
+#     endif
+   }
+
+   data.gamma = pm->current_gamma;
+
+   /* If not set then the calculations assume linear encoding (implicitly): */
+   if (data.gamma == 0)
+      data.gamma = 1;
+
+   /* The arguments to png_set_rgb_to_gray can override the coefficients implied
+    * by the color space encoding.  If doing exhaustive checks do the override
+    * in each case, otherwise do it randomly.
+    */
+   if (pm->test_exhaustive)
+   {
+      /* First time in coefficients_overridden is 0, the following sets it to 1,
+       * so repeat if it is set.  If a test fails this may mean we subsequently
+       * skip a non-override test, ignore that.
+       */
+      data.coefficients_overridden = !data.coefficients_overridden;
+      pm->repeat = data.coefficients_overridden != 0;
+   }
+
+   else
+      data.coefficients_overridden = random_choice();
+
+   if (data.coefficients_overridden)
+   {
+      /* These values override the color encoding defaults, simply use random
+       * numbers.
+       */
+      png_uint_32 ru;
+      double total;
+
+      ru = random_u32();
+      data.green_coefficient = total = (ru & 0xffff) / 65535.;
+      ru >>= 16;
+      data.red_coefficient = (1 - total) * (ru & 0xffff) / 65535.;
+      total += data.red_coefficient;
+      data.blue_coefficient = 1 - total;
+
+#     ifdef PNG_FLOATING_POINT_SUPPORTED
+         data.red_to_set = data.red_coefficient;
+         data.green_to_set = data.green_coefficient;
+#     else
+         data.red_to_set = fix(data.red_coefficient);
+         data.green_to_set = fix(data.green_coefficient);
+#     endif
+
+      /* The following just changes the error messages: */
+      pm->encoding_ignored = 1;
+   }
+
+   else
+   {
+      data.red_to_set = -1;
+      data.green_to_set = -1;
+   }
+
+   /* Adjust the error limit in the png_modifier because of the larger errors
+    * produced in the digitization during the gamma handling.
+    */
+   if (data.gamma != 1) /* Use gamma tables */
+   {
+      if (that->this.bit_depth == 16 || pm->assume_16_bit_calculations)
+      {
+         /* The computations have the form:
+          *
+          *    r * rc + g * gc + b * bc
+          *
+          *  Each component of which is +/-1/65535 from the gamma_to_1 table
+          *  lookup, resulting in a base error of +/-6.  The gamma_from_1
+          *  conversion adds another +/-2 in the 16-bit case and
+          *  +/-(1<<(15-PNG_MAX_GAMMA_8)) in the 8-bit case.
+          */
+#        if PNG_LIBPNG_VER < 10700
+            if (that->this.bit_depth < 16)
+               that->max_gamma_8 = PNG_MAX_GAMMA_8;
+#        endif
+         that->pm->limit += pow(
+            (that->this.bit_depth == 16 || that->max_gamma_8 > 14 ?
+               8. :
+               6. + (1<<(15-that->max_gamma_8))
+            )/65535, data.gamma);
+      }
+
+      else
+      {
+         /* Rounding to 8 bits in the linear space causes massive errors which
+          * will trigger the error check in transform_range_check.  Fix that
+          * here by taking the gamma encoding into account.
+          *
+          * When DIGITIZE is set because a pre-1.7 version of libpng is being
+          * tested allow a bigger slack.
+          *
+          * NOTE: this number only affects the internal limit check in pngvalid,
+          * it has no effect on the limits applied to the libpng values.
+          */
+#if DIGITIZE
+          that->pm->limit += pow( 2.0/255, data.gamma);
+#else
+          that->pm->limit += pow( 1.0/255, data.gamma);
+#endif
+      }
+   }
+
+   else
+   {
+      /* With no gamma correction a large error comes from the truncation of the
+       * calculation in the 8 bit case, allow for that here.
+       */
+      if (that->this.bit_depth != 16 && !pm->assume_16_bit_calculations)
+         that->pm->limit += 4E-3;
+   }
+}
+
+static void
+image_transform_png_set_rgb_to_gray_set(const image_transform *this,
+    transform_display *that, png_structp pp, png_infop pi)
+{
+   int error_action = 1; /* no error, no defines in png.h */
+
+#  ifdef PNG_FLOATING_POINT_SUPPORTED
+      png_set_rgb_to_gray(pp, error_action, data.red_to_set, data.green_to_set);
+#  else
+      png_set_rgb_to_gray_fixed(pp, error_action, data.red_to_set,
+         data.green_to_set);
+#  endif
+
+#  ifdef PNG_READ_cHRM_SUPPORTED
+      if (that->pm->current_encoding != 0)
+      {
+         /* We have an encoding so a cHRM chunk may have been set; if so then
+          * check that the libpng APIs give the correct (X,Y,Z) values within
+          * some margin of error for the round trip through the chromaticity
+          * form.
+          */
+#        ifdef PNG_FLOATING_POINT_SUPPORTED
+#           define API_function png_get_cHRM_XYZ
+#           define API_form "FP"
+#           define API_type double
+#           define API_cvt(x) (x)
+#        else
+#           define API_function png_get_cHRM_XYZ_fixed
+#           define API_form "fixed"
+#           define API_type png_fixed_point
+#           define API_cvt(x) ((double)(x)/PNG_FP_1)
+#        endif
+
+         API_type rX, gX, bX;
+         API_type rY, gY, bY;
+         API_type rZ, gZ, bZ;
+
+         if ((API_function(pp, pi, &rX, &rY, &rZ, &gX, &gY, &gZ, &bX, &bY, &bZ)
+               & PNG_INFO_cHRM) != 0)
+         {
+            double maxe;
+            const char *el;
+            color_encoding e, o;
+
+            /* Expect libpng to return a normalized result, but the original
+             * color space encoding may not be normalized.
+             */
+            modifier_current_encoding(that->pm, &o);
+            normalize_color_encoding(&o);
+
+            /* Sanity check the pngvalid code - the coefficients should match
+             * the normalized Y values of the encoding unless they were
+             * overridden.
+             */
+            if (data.red_to_set == -1 && data.green_to_set == -1 &&
+               (fabs(o.red.Y - data.red_coefficient) > DBL_EPSILON ||
+               fabs(o.green.Y - data.green_coefficient) > DBL_EPSILON ||
+               fabs(o.blue.Y - data.blue_coefficient) > DBL_EPSILON))
+               png_error(pp, "internal pngvalid cHRM coefficient error");
+
+            /* Generate a colour space encoding. */
+            e.gamma = o.gamma; /* not used */
+            e.red.X = API_cvt(rX);
+            e.red.Y = API_cvt(rY);
+            e.red.Z = API_cvt(rZ);
+            e.green.X = API_cvt(gX);
+            e.green.Y = API_cvt(gY);
+            e.green.Z = API_cvt(gZ);
+            e.blue.X = API_cvt(bX);
+            e.blue.Y = API_cvt(bY);
+            e.blue.Z = API_cvt(bZ);
+
+            /* This should match the original one from the png_modifier, within
+             * the range permitted by the libpng fixed point representation.
+             */
+            maxe = 0;
+            el = "-"; /* Set to element name with error */
+
+#           define CHECK(col,x)\
+            {\
+               double err = fabs(o.col.x - e.col.x);\
+               if (err > maxe)\
+               {\
+                  maxe = err;\
+                  el = #col "(" #x ")";\
+               }\
+            }
+
+            CHECK(red,X)
+            CHECK(red,Y)
+            CHECK(red,Z)
+            CHECK(green,X)
+            CHECK(green,Y)
+            CHECK(green,Z)
+            CHECK(blue,X)
+            CHECK(blue,Y)
+            CHECK(blue,Z)
+
+            /* Here in both fixed and floating cases to check the values read
+             * from the cHRm chunk.  PNG uses fixed point in the cHRM chunk, so
+             * we can't expect better than +/-.5E-5 on the result, allow 1E-5.
+             */
+            if (maxe >= 1E-5)
+            {
+               size_t pos = 0;
+               char buffer[256];
+
+               pos = safecat(buffer, sizeof buffer, pos, API_form);
+               pos = safecat(buffer, sizeof buffer, pos, " cHRM ");
+               pos = safecat(buffer, sizeof buffer, pos, el);
+               pos = safecat(buffer, sizeof buffer, pos, " error: ");
+               pos = safecatd(buffer, sizeof buffer, pos, maxe, 7);
+               pos = safecat(buffer, sizeof buffer, pos, " ");
+               /* Print the color space without the gamma value: */
+               pos = safecat_color_encoding(buffer, sizeof buffer, pos, &o, 0);
+               pos = safecat(buffer, sizeof buffer, pos, " -> ");
+               pos = safecat_color_encoding(buffer, sizeof buffer, pos, &e, 0);
+
+               png_error(pp, buffer);
+            }
+         }
+      }
+#  endif /* READ_cHRM */
+
+   this->next->set(this->next, that, pp, pi);
+}
+
+static void
+image_transform_png_set_rgb_to_gray_mod(const image_transform *this,
+    image_pixel *that, png_const_structp pp,
+    const transform_display *display)
+{
+   if ((that->colour_type & PNG_COLOR_MASK_COLOR) != 0)
+   {
+      double gray, err;
+
+#     if PNG_LIBPNG_VER < 10700
+         if (that->colour_type == PNG_COLOR_TYPE_PALETTE)
+            image_pixel_convert_PLTE(that);
+#     endif
+
+      /* Image now has RGB channels... */
+#  if DIGITIZE
+      {
+         png_modifier *pm = display->pm;
+         unsigned int sample_depth = that->sample_depth;
+         unsigned int calc_depth = (pm->assume_16_bit_calculations ? 16 :
+            sample_depth);
+         unsigned int gamma_depth =
+            (sample_depth == 16 ?
+               display->max_gamma_8 :
+               (pm->assume_16_bit_calculations ?
+                  display->max_gamma_8 :
+                  sample_depth));
+         int isgray;
+         double r, g, b;
+         double rlo, rhi, glo, ghi, blo, bhi, graylo, grayhi;
+
+         /* Do this using interval arithmetic, otherwise it is too difficult to
+          * handle the errors correctly.
+          *
+          * To handle the gamma correction work out the upper and lower bounds
+          * of the digitized value.  Assume rounding here - normally the values
+          * will be identical after this operation if there is only one
+          * transform, feel free to delete the png_error checks on this below in
+          * the future (this is just me trying to ensure it works!)
+          *
+          * Interval arithmetic is exact, but to implement it it must be
+          * possible to control the floating point implementation rounding mode.
+          * This cannot be done in ANSI-C, so instead I reduce the 'lo' values
+          * by DBL_EPSILON and increase the 'hi' values by the same.
+          */
+#        define DD(v,d,r) (digitize(v*(1-DBL_EPSILON), d, r) * (1-DBL_EPSILON))
+#        define DU(v,d,r) (digitize(v*(1+DBL_EPSILON), d, r) * (1+DBL_EPSILON))
+
+         r = rlo = rhi = that->redf;
+         rlo -= that->rede;
+         rlo = DD(rlo, calc_depth, 1/*round*/);
+         rhi += that->rede;
+         rhi = DU(rhi, calc_depth, 1/*round*/);
+
+         g = glo = ghi = that->greenf;
+         glo -= that->greene;
+         glo = DD(glo, calc_depth, 1/*round*/);
+         ghi += that->greene;
+         ghi = DU(ghi, calc_depth, 1/*round*/);
+
+         b = blo = bhi = that->bluef;
+         blo -= that->bluee;
+         blo = DD(blo, calc_depth, 1/*round*/);
+         bhi += that->bluee;
+         bhi = DU(bhi, calc_depth, 1/*round*/);
+
+         isgray = r==g && g==b;
+
+         if (data.gamma != 1)
+         {
+            const double power = 1/data.gamma;
+            const double abse = .5/(sample_depth == 16 ? 65535 : 255);
+
+            /* If a gamma calculation is done it is done using lookup tables of
+             * precision gamma_depth, so the already digitized value above may
+             * need to be further digitized here.
+             */
+            if (gamma_depth != calc_depth)
+            {
+               rlo = DD(rlo, gamma_depth, 0/*truncate*/);
+               rhi = DU(rhi, gamma_depth, 0/*truncate*/);
+               glo = DD(glo, gamma_depth, 0/*truncate*/);
+               ghi = DU(ghi, gamma_depth, 0/*truncate*/);
+               blo = DD(blo, gamma_depth, 0/*truncate*/);
+               bhi = DU(bhi, gamma_depth, 0/*truncate*/);
+            }
+
+            /* 'abse' is the error in the gamma table calculation itself. */
+            r = pow(r, power);
+            rlo = DD(pow(rlo, power)-abse, calc_depth, 1);
+            rhi = DU(pow(rhi, power)+abse, calc_depth, 1);
+
+            g = pow(g, power);
+            glo = DD(pow(glo, power)-abse, calc_depth, 1);
+            ghi = DU(pow(ghi, power)+abse, calc_depth, 1);
+
+            b = pow(b, power);
+            blo = DD(pow(blo, power)-abse, calc_depth, 1);
+            bhi = DU(pow(bhi, power)+abse, calc_depth, 1);
+         }
+
+         /* Now calculate the actual gray values.  Although the error in the
+          * coefficients depends on whether they were specified on the command
+          * line (in which case truncation to 15 bits happened) or not (rounding
+          * was used) the maximum error in an individual coefficient is always
+          * 2/32768, because even in the rounding case the requirement that
+          * coefficients add up to 32768 can cause a larger rounding error.
+          *
+          * The only time when rounding doesn't occur in 1.5.5 and later is when
+          * the non-gamma code path is used for less than 16 bit data.
+          */
+         gray = r * data.red_coefficient + g * data.green_coefficient +
+            b * data.blue_coefficient;
+
+         {
+            int do_round = data.gamma != 1 || calc_depth == 16;
+            const double ce = 2. / 32768;
+
+            graylo = DD(rlo * (data.red_coefficient-ce) +
+               glo * (data.green_coefficient-ce) +
+               blo * (data.blue_coefficient-ce), calc_depth, do_round);
+            if (graylo > gray) /* always accept the right answer */
+               graylo = gray;
+
+            grayhi = DU(rhi * (data.red_coefficient+ce) +
+               ghi * (data.green_coefficient+ce) +
+               bhi * (data.blue_coefficient+ce), calc_depth, do_round);
+            if (grayhi < gray)
+               grayhi = gray;
+         }
+
+         /* And invert the gamma. */
+         if (data.gamma != 1)
+         {
+            const double power = data.gamma;
+
+            /* And this happens yet again, shifting the values once more. */
+            if (gamma_depth != sample_depth)
+            {
+               rlo = DD(rlo, gamma_depth, 0/*truncate*/);
+               rhi = DU(rhi, gamma_depth, 0/*truncate*/);
+               glo = DD(glo, gamma_depth, 0/*truncate*/);
+               ghi = DU(ghi, gamma_depth, 0/*truncate*/);
+               blo = DD(blo, gamma_depth, 0/*truncate*/);
+               bhi = DU(bhi, gamma_depth, 0/*truncate*/);
+            }
+
+            gray = pow(gray, power);
+            graylo = DD(pow(graylo, power), sample_depth, 1);
+            grayhi = DU(pow(grayhi, power), sample_depth, 1);
+         }
+
+#        undef DD
+#        undef DU
+
+         /* Now the error can be calculated.
+          *
+          * If r==g==b because there is no overall gamma correction libpng
+          * currently preserves the original value.
+          */
+         if (isgray)
+            err = (that->rede + that->greene + that->bluee)/3;
+
+         else
+         {
+            err = fabs(grayhi-gray);
+
+            if (fabs(gray - graylo) > err)
+               err = fabs(graylo-gray);
+
+#if !RELEASE_BUILD
+            /* Check that this worked: */
+            if (err > pm->limit)
+            {
+               size_t pos = 0;
+               char buffer[128];
+
+               pos = safecat(buffer, sizeof buffer, pos, "rgb_to_gray error ");
+               pos = safecatd(buffer, sizeof buffer, pos, err, 6);
+               pos = safecat(buffer, sizeof buffer, pos, " exceeds limit ");
+               pos = safecatd(buffer, sizeof buffer, pos, pm->limit, 6);
+               png_warning(pp, buffer);
+               pm->limit = err;
+            }
+#endif /* !RELEASE_BUILD */
+         }
+      }
+#  else  /* !DIGITIZE */
+      {
+         double r = that->redf;
+         double re = that->rede;
+         double g = that->greenf;
+         double ge = that->greene;
+         double b = that->bluef;
+         double be = that->bluee;
+
+#        if PNG_LIBPNG_VER < 10700
+            /* The true gray case involves no math in earlier versions (not
+             * true, there was some if gamma correction was happening too.)
+             */
+            if (r == g && r == b)
+            {
+               gray = r;
+               err = re;
+               if (err < ge) err = ge;
+               if (err < be) err = be;
+            }
+
+            else
+#        endif /* before 1.7 */
+         if (data.gamma == 1)
+         {
+            /* There is no need to do the conversions to and from linear space,
+             * so the calculation should be a lot more accurate.  There is a
+             * built in error in the coefficients because they only have 15 bits
+             * and are adjusted to make sure they add up to 32768.  This
+             * involves a integer calculation with truncation of the form:
+             *
+             *     ((int)(coefficient * 100000) * 32768)/100000
+             *
+             * This is done to the red and green coefficients (the ones
+             * provided to the API) then blue is calculated from them so the
+             * result adds up to 32768.  In the worst case this can result in
+             * a -1 error in red and green and a +2 error in blue.  Consequently
+             * the worst case in the calculation below is 2/32768 error.
+             *
+             * TODO: consider fixing this in libpng by rounding the calculation
+             * limiting the error to 1/32768.
+             *
+             * Handling this by adding 2/32768 here avoids needing to increase
+             * the global error limits to take this into account.)
+             */
+            gray = r * data.red_coefficient + g * data.green_coefficient +
+               b * data.blue_coefficient;
+            err = re * data.red_coefficient + ge * data.green_coefficient +
+               be * data.blue_coefficient + 2./32768 + gray * 5 * DBL_EPSILON;
+         }
+
+         else
+         {
+            /* The calculation happens in linear space, and this produces much
+             * wider errors in the encoded space.  These are handled here by
+             * factoring the errors in to the calculation.  There are two table
+             * lookups in the calculation and each introduces a quantization
+             * error defined by the table size.
+             */
+            png_modifier *pm = display->pm;
+            double in_qe = (that->sample_depth > 8 ? .5/65535 : .5/255);
+            double out_qe = (that->sample_depth > 8 ? .5/65535 :
+               (pm->assume_16_bit_calculations ? .5/(1<<display->max_gamma_8) :
+               .5/255));
+            double rhi, ghi, bhi, grayhi;
+            double g1 = 1/data.gamma;
+
+            rhi = r + re + in_qe; if (rhi > 1) rhi = 1;
+            r -= re + in_qe; if (r < 0) r = 0;
+            ghi = g + ge + in_qe; if (ghi > 1) ghi = 1;
+            g -= ge + in_qe; if (g < 0) g = 0;
+            bhi = b + be + in_qe; if (bhi > 1) bhi = 1;
+            b -= be + in_qe; if (b < 0) b = 0;
+
+            r = pow(r, g1)*(1-DBL_EPSILON); rhi = pow(rhi, g1)*(1+DBL_EPSILON);
+            g = pow(g, g1)*(1-DBL_EPSILON); ghi = pow(ghi, g1)*(1+DBL_EPSILON);
+            b = pow(b, g1)*(1-DBL_EPSILON); bhi = pow(bhi, g1)*(1+DBL_EPSILON);
+
+            /* Work out the lower and upper bounds for the gray value in the
+             * encoded space, then work out an average and error.  Remove the
+             * previously added input quantization error at this point.
+             */
+            gray = r * data.red_coefficient + g * data.green_coefficient +
+               b * data.blue_coefficient - 2./32768 - out_qe;
+            if (gray <= 0)
+               gray = 0;
+            else
+            {
+               gray *= (1 - 6 * DBL_EPSILON);
+               gray = pow(gray, data.gamma) * (1-DBL_EPSILON);
+            }
+
+            grayhi = rhi * data.red_coefficient + ghi * data.green_coefficient +
+               bhi * data.blue_coefficient + 2./32768 + out_qe;
+            grayhi *= (1 + 6 * DBL_EPSILON);
+            if (grayhi >= 1)
+               grayhi = 1;
+            else
+               grayhi = pow(grayhi, data.gamma) * (1+DBL_EPSILON);
+
+            err = (grayhi - gray) / 2;
+            gray = (grayhi + gray) / 2;
+
+            if (err <= in_qe)
+               err = gray * DBL_EPSILON;
+
+            else
+               err -= in_qe;
+
+#if !RELEASE_BUILD
+            /* Validate that the error is within limits (this has caused
+             * problems before, it's much easier to detect them here.)
+             */
+            if (err > pm->limit)
+            {
+               size_t pos = 0;
+               char buffer[128];
+
+               pos = safecat(buffer, sizeof buffer, pos, "rgb_to_gray error ");
+               pos = safecatd(buffer, sizeof buffer, pos, err, 6);
+               pos = safecat(buffer, sizeof buffer, pos, " exceeds limit ");
+               pos = safecatd(buffer, sizeof buffer, pos, pm->limit, 6);
+               png_warning(pp, buffer);
+               pm->limit = err;
+            }
+#endif /* !RELEASE_BUILD */
+         }
+      }
+#  endif /* !DIGITIZE */
+
+      that->bluef = that->greenf = that->redf = gray;
+      that->bluee = that->greene = that->rede = err;
+
+      /* The sBIT is the minimum of the three colour channel sBITs. */
+      if (that->red_sBIT > that->green_sBIT)
+         that->red_sBIT = that->green_sBIT;
+      if (that->red_sBIT > that->blue_sBIT)
+         that->red_sBIT = that->blue_sBIT;
+      that->blue_sBIT = that->green_sBIT = that->red_sBIT;
+
+      /* And remove the colour bit in the type: */
+      if (that->colour_type == PNG_COLOR_TYPE_RGB)
+         that->colour_type = PNG_COLOR_TYPE_GRAY;
+      else if (that->colour_type == PNG_COLOR_TYPE_RGB_ALPHA)
+         that->colour_type = PNG_COLOR_TYPE_GRAY_ALPHA;
+   }
+
+   this->next->mod(this->next, that, pp, display);
+}
+
+static int
+image_transform_png_set_rgb_to_gray_add(image_transform *this,
+    const image_transform **that, png_byte colour_type, png_byte bit_depth)
+{
+   UNUSED(bit_depth)
+
+   this->next = *that;
+   *that = this;
+
+   return (colour_type & PNG_COLOR_MASK_COLOR) != 0;
+}
+
+#undef data
+IT(rgb_to_gray);
+#undef PT
+#define PT ITSTRUCT(rgb_to_gray)
+#undef image_transform_ini
+#define image_transform_ini image_transform_default_ini
+#endif /* PNG_READ_RGB_TO_GRAY_SUPPORTED */
+
+#ifdef PNG_READ_BACKGROUND_SUPPORTED
+/* png_set_background(png_structp, png_const_color_16p background_color,
+ *    int background_gamma_code, int need_expand, double background_gamma)
+ * png_set_background_fixed(png_structp, png_const_color_16p background_color,
+ *    int background_gamma_code, int need_expand,
+ *    png_fixed_point background_gamma)
+ *
+ * This ignores the gamma (at present.)
+*/
+#define data ITDATA(background)
+static image_pixel data;
+
+static void
+image_transform_png_set_background_set(const image_transform *this,
+    transform_display *that, png_structp pp, png_infop pi)
+{
+   png_byte colour_type, bit_depth;
+   png_byte random_bytes[8]; /* 8 bytes - 64 bits - the biggest pixel */
+   int expand;
+   png_color_16 back;
+
+   /* We need a background colour, because we don't know exactly what transforms
+    * have been set we have to supply the colour in the original file format and
+    * so we need to know what that is!  The background colour is stored in the
+    * transform_display.
+    */
+   R8(random_bytes);
+
+   /* Read the random value, for colour type 3 the background colour is actually
+    * expressed as a 24bit rgb, not an index.
+    */
+   colour_type = that->this.colour_type;
+   if (colour_type == 3)
+   {
+      colour_type = PNG_COLOR_TYPE_RGB;
+      bit_depth = 8;
+      expand = 0; /* passing in an RGB not a pixel index */
+   }
+
+   else
+   {
+      if (that->this.has_tRNS)
+         that->this.is_transparent = 1;
+
+      bit_depth = that->this.bit_depth;
+      expand = 1;
+   }
+
+   image_pixel_init(&data, random_bytes, colour_type,
+      bit_depth, 0/*x*/, 0/*unused: palette*/, NULL/*format*/);
+
+   /* Extract the background colour from this image_pixel, but make sure the
+    * unused fields of 'back' are garbage.
+    */
+   R8(back);
+
+   if (colour_type & PNG_COLOR_MASK_COLOR)
+   {
+      back.red = (png_uint_16)data.red;
+      back.green = (png_uint_16)data.green;
+      back.blue = (png_uint_16)data.blue;
+   }
+
+   else
+      back.gray = (png_uint_16)data.red;
+
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+   png_set_background(pp, &back, PNG_BACKGROUND_GAMMA_FILE, expand, 0);
+#else
+   png_set_background_fixed(pp, &back, PNG_BACKGROUND_GAMMA_FILE, expand, 0);
+#endif
+
+   this->next->set(this->next, that, pp, pi);
+}
+
+static void
+image_transform_png_set_background_mod(const image_transform *this,
+    image_pixel *that, png_const_structp pp,
+    const transform_display *display)
+{
+   /* Check for tRNS first: */
+   if (that->have_tRNS && that->colour_type != PNG_COLOR_TYPE_PALETTE)
+      image_pixel_add_alpha(that, &display->this, 1/*for background*/);
+
+   /* This is only necessary if the alpha value is less than 1. */
+   if (that->alphaf < 1)
+   {
+      /* Now we do the background calculation without any gamma correction. */
+      if (that->alphaf <= 0)
+      {
+         that->redf = data.redf;
+         that->greenf = data.greenf;
+         that->bluef = data.bluef;
+
+         that->rede = data.rede;
+         that->greene = data.greene;
+         that->bluee = data.bluee;
+
+         that->red_sBIT= data.red_sBIT;
+         that->green_sBIT= data.green_sBIT;
+         that->blue_sBIT= data.blue_sBIT;
+      }
+
+      else /* 0 < alpha < 1 */
+      {
+         double alf = 1 - that->alphaf;
+
+         that->redf = that->redf * that->alphaf + data.redf * alf;
+         that->rede = that->rede * that->alphaf + data.rede * alf +
+            DBL_EPSILON;
+         that->greenf = that->greenf * that->alphaf + data.greenf * alf;
+         that->greene = that->greene * that->alphaf + data.greene * alf +
+            DBL_EPSILON;
+         that->bluef = that->bluef * that->alphaf + data.bluef * alf;
+         that->bluee = that->bluee * that->alphaf + data.bluee * alf +
+            DBL_EPSILON;
+      }
+
+      /* Remove the alpha type and set the alpha (not in that order.) */
+      that->alphaf = 1;
+      that->alphae = 0;
+   }
+
+   if (that->colour_type == PNG_COLOR_TYPE_RGB_ALPHA)
+      that->colour_type = PNG_COLOR_TYPE_RGB;
+   else if (that->colour_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+      that->colour_type = PNG_COLOR_TYPE_GRAY;
+   /* PNG_COLOR_TYPE_PALETTE is not changed */
+
+   this->next->mod(this->next, that, pp, display);
+}
+
+#define image_transform_png_set_background_add image_transform_default_add
+
+#undef data
+IT(background);
+#undef PT
+#define PT ITSTRUCT(background)
+#endif /* PNG_READ_BACKGROUND_SUPPORTED */
+
+/* png_set_quantize(png_structp, png_colorp palette, int num_palette,
+ *    int maximum_colors, png_const_uint_16p histogram, int full_quantize)
+ *
+ * Very difficult to validate this!
+ */
+/*NOTE: TBD NYI */
+
+/* The data layout transforms are handled by swapping our own channel data,
+ * necessarily these need to happen at the end of the transform list because the
+ * semantic of the channels changes after these are executed.  Some of these,
+ * like set_shift and set_packing, can't be done at present because they change
+ * the layout of the data at the sub-sample level so sample() won't get the
+ * right answer.
+ */
+/* png_set_invert_alpha */
+#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
+/* Invert the alpha channel
+ *
+ *  png_set_invert_alpha(png_structrp png_ptr)
+ */
+static void
+image_transform_png_set_invert_alpha_set(const image_transform *this,
+    transform_display *that, png_structp pp, png_infop pi)
+{
+   png_set_invert_alpha(pp);
+   this->next->set(this->next, that, pp, pi);
+}
+
+static void
+image_transform_png_set_invert_alpha_mod(const image_transform *this,
+    image_pixel *that, png_const_structp pp,
+    const transform_display *display)
+{
+   if (that->colour_type & 4)
+      that->alpha_inverted = 1;
+
+   this->next->mod(this->next, that, pp, display);
+}
+
+static int
+image_transform_png_set_invert_alpha_add(image_transform *this,
+    const image_transform **that, png_byte colour_type, png_byte bit_depth)
+{
+   UNUSED(bit_depth)
+
+   this->next = *that;
+   *that = this;
+
+   /* Only has an effect on pixels with alpha: */
+   return (colour_type & 4) != 0;
+}
+
+IT(invert_alpha);
+#undef PT
+#define PT ITSTRUCT(invert_alpha)
+
+#endif /* PNG_READ_INVERT_ALPHA_SUPPORTED */
+
+/* png_set_bgr */
+#ifdef PNG_READ_BGR_SUPPORTED
+/* Swap R,G,B channels to order B,G,R.
+ *
+ *  png_set_bgr(png_structrp png_ptr)
+ *
+ * This only has an effect on RGB and RGBA pixels.
+ */
+static void
+image_transform_png_set_bgr_set(const image_transform *this,
+    transform_display *that, png_structp pp, png_infop pi)
+{
+   png_set_bgr(pp);
+   this->next->set(this->next, that, pp, pi);
+}
+
+static void
+image_transform_png_set_bgr_mod(const image_transform *this,
+    image_pixel *that, png_const_structp pp,
+    const transform_display *display)
+{
+   if (that->colour_type == PNG_COLOR_TYPE_RGB ||
+       that->colour_type == PNG_COLOR_TYPE_RGBA)
+       that->swap_rgb = 1;
+
+   this->next->mod(this->next, that, pp, display);
+}
+
+static int
+image_transform_png_set_bgr_add(image_transform *this,
+    const image_transform **that, png_byte colour_type, png_byte bit_depth)
+{
+   UNUSED(bit_depth)
+
+   this->next = *that;
+   *that = this;
+
+   return colour_type == PNG_COLOR_TYPE_RGB ||
+       colour_type == PNG_COLOR_TYPE_RGBA;
+}
+
+IT(bgr);
+#undef PT
+#define PT ITSTRUCT(bgr)
+
+#endif /* PNG_READ_BGR_SUPPORTED */
+
+/* png_set_swap_alpha */
+#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED
+/* Put the alpha channel first.
+ *
+ *  png_set_swap_alpha(png_structrp png_ptr)
+ *
+ * This only has an effect on GA and RGBA pixels.
+ */
+static void
+image_transform_png_set_swap_alpha_set(const image_transform *this,
+    transform_display *that, png_structp pp, png_infop pi)
+{
+   png_set_swap_alpha(pp);
+   this->next->set(this->next, that, pp, pi);
+}
+
+static void
+image_transform_png_set_swap_alpha_mod(const image_transform *this,
+    image_pixel *that, png_const_structp pp,
+    const transform_display *display)
+{
+   if (that->colour_type == PNG_COLOR_TYPE_GA ||
+       that->colour_type == PNG_COLOR_TYPE_RGBA)
+      that->alpha_first = 1;
+
+   this->next->mod(this->next, that, pp, display);
+}
+
+static int
+image_transform_png_set_swap_alpha_add(image_transform *this,
+    const image_transform **that, png_byte colour_type, png_byte bit_depth)
+{
+   UNUSED(bit_depth)
+
+   this->next = *that;
+   *that = this;
+
+   return colour_type == PNG_COLOR_TYPE_GA ||
+       colour_type == PNG_COLOR_TYPE_RGBA;
+}
+
+IT(swap_alpha);
+#undef PT
+#define PT ITSTRUCT(swap_alpha)
+
+#endif /* PNG_READ_SWAP_ALPHA_SUPPORTED */
+
+/* png_set_swap */
+#ifdef PNG_READ_SWAP_SUPPORTED
+/* Byte swap 16-bit components.
+ *
+ *  png_set_swap(png_structrp png_ptr)
+ */
+static void
+image_transform_png_set_swap_set(const image_transform *this,
+    transform_display *that, png_structp pp, png_infop pi)
+{
+   png_set_swap(pp);
+   this->next->set(this->next, that, pp, pi);
+}
+
+static void
+image_transform_png_set_swap_mod(const image_transform *this,
+    image_pixel *that, png_const_structp pp,
+    const transform_display *display)
+{
+   if (that->bit_depth == 16)
+      that->swap16 = 1;
+
+   this->next->mod(this->next, that, pp, display);
+}
+
+static int
+image_transform_png_set_swap_add(image_transform *this,
+    const image_transform **that, png_byte colour_type, png_byte bit_depth)
+{
+   UNUSED(colour_type)
+
+   this->next = *that;
+   *that = this;
+
+   return bit_depth == 16;
+}
+
+IT(swap);
+#undef PT
+#define PT ITSTRUCT(swap)
+
+#endif /* PNG_READ_SWAP_SUPPORTED */
+
+#ifdef PNG_READ_FILLER_SUPPORTED
+/* Add a filler byte to 8-bit Gray or 24-bit RGB images.
+ *
+ *  png_set_filler, (png_structp png_ptr, png_uint_32 filler, int flags));
+ *
+ * Flags:
+ *
+ *  PNG_FILLER_BEFORE
+ *  PNG_FILLER_AFTER
+ */
+#define data ITDATA(filler)
+static struct
+{
+   png_uint_32 filler;
+   int         flags;
+} data;
+
+static void
+image_transform_png_set_filler_set(const image_transform *this,
+    transform_display *that, png_structp pp, png_infop pi)
+{
+   /* Need a random choice for 'before' and 'after' as well as for the
+    * filler.  The 'filler' value has all 32 bits set, but only bit_depth
+    * will be used.  At this point we don't know bit_depth.
+    */
+   data.filler = random_u32();
+   data.flags = random_choice();
+
+   png_set_filler(pp, data.filler, data.flags);
+
+   /* The standard display handling stuff also needs to know that
+    * there is a filler, so set that here.
+    */
+   that->this.filler = 1;
+
+   this->next->set(this->next, that, pp, pi);
+}
+
+static void
+image_transform_png_set_filler_mod(const image_transform *this,
+    image_pixel *that, png_const_structp pp,
+    const transform_display *display)
+{
+   if (that->bit_depth >= 8 &&
+       (that->colour_type == PNG_COLOR_TYPE_RGB ||
+        that->colour_type == PNG_COLOR_TYPE_GRAY))
+   {
+      unsigned int max = (1U << that->bit_depth)-1;
+      that->alpha = data.filler & max;
+      that->alphaf = ((double)that->alpha) / max;
+      that->alphae = 0;
+
+      /* The filler has been stored in the alpha channel, we must record
+       * that this has been done for the checking later on, the color
+       * type is faked to have an alpha channel, but libpng won't report
+       * this; the app has to know the extra channel is there and this
+       * was recording in standard_display::filler above.
+       */
+      that->colour_type |= 4; /* alpha added */
+      that->alpha_first = data.flags == PNG_FILLER_BEFORE;
+   }
+
+   this->next->mod(this->next, that, pp, display);
+}
+
+static int
+image_transform_png_set_filler_add(image_transform *this,
+    const image_transform **that, png_byte colour_type, png_byte bit_depth)
+{
+   this->next = *that;
+   *that = this;
+
+   return bit_depth >= 8 && (colour_type == PNG_COLOR_TYPE_RGB ||
+           colour_type == PNG_COLOR_TYPE_GRAY);
+}
+
+#undef data
+IT(filler);
+#undef PT
+#define PT ITSTRUCT(filler)
+
+/* png_set_add_alpha, (png_structp png_ptr, png_uint_32 filler, int flags)); */
+/* Add an alpha byte to 8-bit Gray or 24-bit RGB images. */
+#define data ITDATA(add_alpha)
+static struct
+{
+   png_uint_32 filler;
+   int         flags;
+} data;
+
+static void
+image_transform_png_set_add_alpha_set(const image_transform *this,
+    transform_display *that, png_structp pp, png_infop pi)
+{
+   /* Need a random choice for 'before' and 'after' as well as for the
+    * filler.  The 'filler' value has all 32 bits set, but only bit_depth
+    * will be used.  At this point we don't know bit_depth.
+    */
+   data.filler = random_u32();
+   data.flags = random_choice();
+
+   png_set_add_alpha(pp, data.filler, data.flags);
+   this->next->set(this->next, that, pp, pi);
+}
+
+static void
+image_transform_png_set_add_alpha_mod(const image_transform *this,
+    image_pixel *that, png_const_structp pp,
+    const transform_display *display)
+{
+   if (that->bit_depth >= 8 &&
+       (that->colour_type == PNG_COLOR_TYPE_RGB ||
+        that->colour_type == PNG_COLOR_TYPE_GRAY))
+   {
+      unsigned int max = (1U << that->bit_depth)-1;
+      that->alpha = data.filler & max;
+      that->alphaf = ((double)that->alpha) / max;
+      that->alphae = 0;
+
+      that->colour_type |= 4; /* alpha added */
+      that->alpha_first = data.flags == PNG_FILLER_BEFORE;
+   }
+
+   this->next->mod(this->next, that, pp, display);
+}
+
+static int
+image_transform_png_set_add_alpha_add(image_transform *this,
+    const image_transform **that, png_byte colour_type, png_byte bit_depth)
+{
+   this->next = *that;
+   *that = this;
+
+   return bit_depth >= 8 && (colour_type == PNG_COLOR_TYPE_RGB ||
+           colour_type == PNG_COLOR_TYPE_GRAY);
+}
+
+#undef data
+IT(add_alpha);
+#undef PT
+#define PT ITSTRUCT(add_alpha)
+
+#endif /* PNG_READ_FILLER_SUPPORTED */
+
+/* png_set_packing */
+#ifdef PNG_READ_PACK_SUPPORTED
+/* Use 1 byte per pixel in 1, 2, or 4-bit depth files.
+ *
+ *  png_set_packing(png_structrp png_ptr)
+ *
+ * This should only affect grayscale and palette images with less than 8 bits
+ * per pixel.
+ */
+static void
+image_transform_png_set_packing_set(const image_transform *this,
+    transform_display *that, png_structp pp, png_infop pi)
+{
+   png_set_packing(pp);
+   that->unpacked = 1;
+   this->next->set(this->next, that, pp, pi);
+}
+
+static void
+image_transform_png_set_packing_mod(const image_transform *this,
+    image_pixel *that, png_const_structp pp,
+    const transform_display *display)
+{
+   /* The general expand case depends on what the colour type is,
+    * low bit-depth pixel values are unpacked into bytes without
+    * scaling, so sample_depth is not changed.
+    */
+   if (that->bit_depth < 8) /* grayscale or palette */
+      that->bit_depth = 8;
+
+   this->next->mod(this->next, that, pp, display);
+}
+
+static int
+image_transform_png_set_packing_add(image_transform *this,
+    const image_transform **that, png_byte colour_type, png_byte bit_depth)
+{
+   UNUSED(colour_type)
+
+   this->next = *that;
+   *that = this;
+
+   /* Nothing should happen unless the bit depth is less than 8: */
+   return bit_depth < 8;
+}
+
+IT(packing);
+#undef PT
+#define PT ITSTRUCT(packing)
+
+#endif /* PNG_READ_PACK_SUPPORTED */
+
+/* png_set_packswap */
+#ifdef PNG_READ_PACKSWAP_SUPPORTED
+/* Swap pixels packed into bytes; reverses the order on screen so that
+ * the high order bits correspond to the rightmost pixels.
+ *
+ *  png_set_packswap(png_structrp png_ptr)
+ */
+static void
+image_transform_png_set_packswap_set(const image_transform *this,
+    transform_display *that, png_structp pp, png_infop pi)
+{
+   png_set_packswap(pp);
+   that->this.littleendian = 1;
+   this->next->set(this->next, that, pp, pi);
+}
+
+static void
+image_transform_png_set_packswap_mod(const image_transform *this,
+    image_pixel *that, png_const_structp pp,
+    const transform_display *display)
+{
+   if (that->bit_depth < 8)
+      that->littleendian = 1;
+
+   this->next->mod(this->next, that, pp, display);
+}
+
+static int
+image_transform_png_set_packswap_add(image_transform *this,
+    const image_transform **that, png_byte colour_type, png_byte bit_depth)
+{
+   UNUSED(colour_type)
+
+   this->next = *that;
+   *that = this;
+
+   return bit_depth < 8;
+}
+
+IT(packswap);
+#undef PT
+#define PT ITSTRUCT(packswap)
+
+#endif /* PNG_READ_PACKSWAP_SUPPORTED */
+
+
+/* png_set_invert_mono */
+#ifdef PNG_READ_INVERT_MONO_SUPPORTED
+/* Invert the gray channel
+ *
+ *  png_set_invert_mono(png_structrp png_ptr)
+ */
+static void
+image_transform_png_set_invert_mono_set(const image_transform *this,
+    transform_display *that, png_structp pp, png_infop pi)
+{
+   png_set_invert_mono(pp);
+   this->next->set(this->next, that, pp, pi);
+}
+
+static void
+image_transform_png_set_invert_mono_mod(const image_transform *this,
+    image_pixel *that, png_const_structp pp,
+    const transform_display *display)
+{
+   if (that->colour_type & 4)
+      that->mono_inverted = 1;
+
+   this->next->mod(this->next, that, pp, display);
+}
+
+static int
+image_transform_png_set_invert_mono_add(image_transform *this,
+    const image_transform **that, png_byte colour_type, png_byte bit_depth)
+{
+   UNUSED(bit_depth)
+
+   this->next = *that;
+   *that = this;
+
+   /* Only has an effect on pixels with no colour: */
+   return (colour_type & 2) == 0;
+}
+
+IT(invert_mono);
+#undef PT
+#define PT ITSTRUCT(invert_mono)
+
+#endif /* PNG_READ_INVERT_MONO_SUPPORTED */
+
+#ifdef PNG_READ_SHIFT_SUPPORTED
+/* png_set_shift(png_structp, png_const_color_8p true_bits)
+ *
+ * The output pixels will be shifted by the given true_bits
+ * values.
+ */
+#define data ITDATA(shift)
+static png_color_8 data;
+
+static void
+image_transform_png_set_shift_set(const image_transform *this,
+    transform_display *that, png_structp pp, png_infop pi)
+{
+   /* Get a random set of shifts.  The shifts need to do something
+    * to test the transform, so they are limited to the bit depth
+    * of the input image.  Notice that in the following the 'gray'
+    * field is randomized independently.  This acts as a check that
+    * libpng does use the correct field.
+    */
+   unsigned int depth = that->this.bit_depth;
+
+   data.red = (png_byte)/*SAFE*/(random_mod(depth)+1);
+   data.green = (png_byte)/*SAFE*/(random_mod(depth)+1);
+   data.blue = (png_byte)/*SAFE*/(random_mod(depth)+1);
+   data.gray = (png_byte)/*SAFE*/(random_mod(depth)+1);
+   data.alpha = (png_byte)/*SAFE*/(random_mod(depth)+1);
+
+   png_set_shift(pp, &data);
+   this->next->set(this->next, that, pp, pi);
+}
+
+static void
+image_transform_png_set_shift_mod(const image_transform *this,
+    image_pixel *that, png_const_structp pp,
+    const transform_display *display)
+{
+   /* Copy the correct values into the sBIT fields, libpng does not do
+    * anything to palette data:
+    */
+   if (that->colour_type != PNG_COLOR_TYPE_PALETTE)
+   {
+       that->sig_bits = 1;
+
+       /* The sBIT fields are reset to the values previously sent to
+        * png_set_shift according to the colour type.
+        * does.
+        */
+       if (that->colour_type & 2) /* RGB channels */
+       {
+          that->red_sBIT = data.red;
+          that->green_sBIT = data.green;
+          that->blue_sBIT = data.blue;
+       }
+
+       else /* One grey channel */
+          that->red_sBIT = that->green_sBIT = that->blue_sBIT = data.gray;
+
+       that->alpha_sBIT = data.alpha;
+   }
+
+   this->next->mod(this->next, that, pp, display);
+}
+
+static int
+image_transform_png_set_shift_add(image_transform *this,
+    const image_transform **that, png_byte colour_type, png_byte bit_depth)
+{
+   UNUSED(bit_depth)
+
+   this->next = *that;
+   *that = this;
+
+   return colour_type != PNG_COLOR_TYPE_PALETTE;
+}
+
+IT(shift);
+#undef PT
+#define PT ITSTRUCT(shift)
+
+#endif /* PNG_READ_SHIFT_SUPPORTED */
+
+#ifdef THIS_IS_THE_PROFORMA
+static void
+image_transform_png_set_@_set(const image_transform *this,
+    transform_display *that, png_structp pp, png_infop pi)
+{
+   png_set_@(pp);
+   this->next->set(this->next, that, pp, pi);
+}
+
+static void
+image_transform_png_set_@_mod(const image_transform *this,
+    image_pixel *that, png_const_structp pp,
+    const transform_display *display)
+{
+   this->next->mod(this->next, that, pp, display);
+}
+
+static int
+image_transform_png_set_@_add(image_transform *this,
+    const image_transform **that, png_byte colour_type, png_byte bit_depth)
+{
+   this->next = *that;
+   *that = this;
+
+   return 1;
+}
+
+IT(@);
+#endif
+
+
+/* This may just be 'end' if all the transforms are disabled! */
+static image_transform *const image_transform_first = &PT;
+
+static void
+transform_enable(const char *name)
+{
+   /* Everything starts out enabled, so if we see an 'enable' disabled
+    * everything else the first time round.
+    */
+   static int all_disabled = 0;
+   int found_it = 0;
+   image_transform *list = image_transform_first;
+
+   while (list != &image_transform_end)
+   {
+      if (strcmp(list->name, name) == 0)
+      {
+         list->enable = 1;
+         found_it = 1;
+      }
+      else if (!all_disabled)
+         list->enable = 0;
+
+      list = list->list;
+   }
+
+   all_disabled = 1;
+
+   if (!found_it)
+   {
+      fprintf(stderr, "pngvalid: --transform-enable=%s: unknown transform\n",
+         name);
+      exit(99);
+   }
+}
+
+static void
+transform_disable(const char *name)
+{
+   image_transform *list = image_transform_first;
+
+   while (list != &image_transform_end)
+   {
+      if (strcmp(list->name, name) == 0)
+      {
+         list->enable = 0;
+         return;
+      }
+
+      list = list->list;
+   }
+
+   fprintf(stderr, "pngvalid: --transform-disable=%s: unknown transform\n",
+      name);
+   exit(99);
+}
+
+static void
+image_transform_reset_count(void)
+{
+   image_transform *next = image_transform_first;
+   int count = 0;
+
+   while (next != &image_transform_end)
+   {
+      next->local_use = 0;
+      next->next = 0;
+      next = next->list;
+      ++count;
+   }
+
+   /* This can only happen if we every have more than 32 transforms (excluding
+    * the end) in the list.
+    */
+   if (count > 32) abort();
+}
+
+static int
+image_transform_test_counter(png_uint_32 counter, unsigned int max)
+{
+   /* Test the list to see if there is any point contining, given a current
+    * counter and a 'max' value.
+    */
+   image_transform *next = image_transform_first;
+
+   while (next != &image_transform_end)
+   {
+      /* For max 0 or 1 continue until the counter overflows: */
+      counter >>= 1;
+
+      /* Continue if any entry hasn't reacked the max. */
+      if (max > 1 && next->local_use < max)
+         return 1;
+      next = next->list;
+   }
+
+   return max <= 1 && counter == 0;
+}
+
+static png_uint_32
+image_transform_add(const image_transform **this, unsigned int max,
+   png_uint_32 counter, char *name, size_t sizeof_name, size_t *pos,
+   png_byte colour_type, png_byte bit_depth)
+{
+   for (;;) /* until we manage to add something */
+   {
+      png_uint_32 mask;
+      image_transform *list;
+
+      /* Find the next counter value, if the counter is zero this is the start
+       * of the list.  This routine always returns the current counter (not the
+       * next) so it returns 0 at the end and expects 0 at the beginning.
+       */
+      if (counter == 0) /* first time */
+      {
+         image_transform_reset_count();
+         if (max <= 1)
+            counter = 1;
+         else
+            counter = random_32();
+      }
+      else /* advance the counter */
+      {
+         switch (max)
+         {
+            case 0:  ++counter; break;
+            case 1:  counter <<= 1; break;
+            default: counter = random_32(); break;
+         }
+      }
+
+      /* Now add all these items, if possible */
+      *this = &image_transform_end;
+      list = image_transform_first;
+      mask = 1;
+
+      /* Go through the whole list adding anything that the counter selects: */
+      while (list != &image_transform_end)
+      {
+         if ((counter & mask) != 0 && list->enable &&
+             (max == 0 || list->local_use < max))
+         {
+            /* Candidate to add: */
+            if (list->add(list, this, colour_type, bit_depth) || max == 0)
+            {
+               /* Added, so add to the name too. */
+               *pos = safecat(name, sizeof_name, *pos, " +");
+               *pos = safecat(name, sizeof_name, *pos, list->name);
+            }
+
+            else
+            {
+               /* Not useful and max>0, so remove it from *this: */
+               *this = list->next;
+               list->next = 0;
+
+               /* And, since we know it isn't useful, stop it being added again
+                * in this run:
+                */
+               list->local_use = max;
+            }
+         }
+
+         mask <<= 1;
+         list = list->list;
+      }
+
+      /* Now if anything was added we have something to do. */
+      if (*this != &image_transform_end)
+         return counter;
+
+      /* Nothing added, but was there anything in there to add? */
+      if (!image_transform_test_counter(counter, max))
+         return 0;
+   }
+}
+
+static void
+perform_transform_test(png_modifier *pm)
+{
+   png_byte colour_type = 0;
+   png_byte bit_depth = 0;
+   unsigned int palette_number = 0;
+
+   while (next_format(&colour_type, &bit_depth, &palette_number, pm->test_lbg,
+            pm->test_tRNS))
+   {
+      png_uint_32 counter = 0;
+      size_t base_pos;
+      char name[64];
+
+      base_pos = safecat(name, sizeof name, 0, "transform:");
+
+      for (;;)
+      {
+         size_t pos = base_pos;
+         const image_transform *list = 0;
+
+         /* 'max' is currently hardwired to '1'; this should be settable on the
+          * command line.
+          */
+         counter = image_transform_add(&list, 1/*max*/, counter,
+            name, sizeof name, &pos, colour_type, bit_depth);
+
+         if (counter == 0)
+            break;
+
+         /* The command line can change this to checking interlaced images. */
+         do
+         {
+            pm->repeat = 0;
+            transform_test(pm, FILEID(colour_type, bit_depth, palette_number,
+               pm->interlace_type, 0, 0, 0), list, name);
+
+            if (fail(pm))
+               return;
+         }
+         while (pm->repeat);
+      }
+   }
+}
+#endif /* PNG_READ_TRANSFORMS_SUPPORTED */
+
+/********************************* GAMMA TESTS ********************************/
+#ifdef PNG_READ_GAMMA_SUPPORTED
+/* Reader callbacks and implementations, where they differ from the standard
+ * ones.
+ */
+typedef struct gamma_display
+{
+   standard_display this;
+
+   /* Parameters */
+   png_modifier*    pm;
+   double           file_gamma;
+   double           screen_gamma;
+   double           background_gamma;
+   png_byte         sbit;
+   int              threshold_test;
+   int              use_input_precision;
+   int              scale16;
+   int              expand16;
+   int              do_background;
+   png_color_16     background_color;
+
+   /* Local variables */
+   double       maxerrout;
+   double       maxerrpc;
+   double       maxerrabs;
+} gamma_display;
+
+#define ALPHA_MODE_OFFSET 4
+
+static void
+gamma_display_init(gamma_display *dp, png_modifier *pm, png_uint_32 id,
+    double file_gamma, double screen_gamma, png_byte sbit, int threshold_test,
+    int use_input_precision, int scale16, int expand16,
+    int do_background, const png_color_16 *pointer_to_the_background_color,
+    double background_gamma)
+{
+   /* Standard fields */
+   standard_display_init(&dp->this, &pm->this, id, do_read_interlace,
+      pm->use_update_info);
+
+   /* Parameter fields */
+   dp->pm = pm;
+   dp->file_gamma = file_gamma;
+   dp->screen_gamma = screen_gamma;
+   dp->background_gamma = background_gamma;
+   dp->sbit = sbit;
+   dp->threshold_test = threshold_test;
+   dp->use_input_precision = use_input_precision;
+   dp->scale16 = scale16;
+   dp->expand16 = expand16;
+   dp->do_background = do_background;
+   if (do_background && pointer_to_the_background_color != 0)
+      dp->background_color = *pointer_to_the_background_color;
+   else
+      memset(&dp->background_color, 0, sizeof dp->background_color);
+
+   /* Local variable fields */
+   dp->maxerrout = dp->maxerrpc = dp->maxerrabs = 0;
+}
+
+static void
+gamma_info_imp(gamma_display *dp, png_structp pp, png_infop pi)
+{
+   /* Reuse the standard stuff as appropriate. */
+   standard_info_part1(&dp->this, pp, pi);
+
+   /* If requested strip 16 to 8 bits - this is handled automagically below
+    * because the output bit depth is read from the library.  Note that there
+    * are interactions with sBIT but, internally, libpng makes sbit at most
+    * PNG_MAX_GAMMA_8 prior to 1.7 when doing the following.
+    */
+   if (dp->scale16)
+#     ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
+         png_set_scale_16(pp);
+#     else
+         /* The following works both in 1.5.4 and earlier versions: */
+#        ifdef PNG_READ_16_TO_8_SUPPORTED
+            png_set_strip_16(pp);
+#        else
+            png_error(pp, "scale16 (16 to 8 bit conversion) not supported");
+#        endif
+#     endif
+
+   if (dp->expand16)
+#     ifdef PNG_READ_EXPAND_16_SUPPORTED
+         png_set_expand_16(pp);
+#     else
+         png_error(pp, "expand16 (8 to 16 bit conversion) not supported");
+#     endif
+
+   if (dp->do_background >= ALPHA_MODE_OFFSET)
+   {
+#     ifdef PNG_READ_ALPHA_MODE_SUPPORTED
+      {
+         /* This tests the alpha mode handling, if supported. */
+         int mode = dp->do_background - ALPHA_MODE_OFFSET;
+
+         /* The gamma value is the output gamma, and is in the standard,
+          * non-inverted, representation.  It provides a default for the PNG file
+          * gamma, but since the file has a gAMA chunk this does not matter.
+          */
+         const double sg = dp->screen_gamma;
+#        ifndef PNG_FLOATING_POINT_SUPPORTED
+            png_fixed_point g = fix(sg);
+#        endif
+
+#        ifdef PNG_FLOATING_POINT_SUPPORTED
+            png_set_alpha_mode(pp, mode, sg);
+#        else
+            png_set_alpha_mode_fixed(pp, mode, g);
+#        endif
+
+         /* However, for the standard Porter-Duff algorithm the output defaults
+          * to be linear, so if the test requires non-linear output it must be
+          * corrected here.
+          */
+         if (mode == PNG_ALPHA_STANDARD && sg != 1)
+         {
+#           ifdef PNG_FLOATING_POINT_SUPPORTED
+               png_set_gamma(pp, sg, dp->file_gamma);
+#           else
+               png_fixed_point f = fix(dp->file_gamma);
+               png_set_gamma_fixed(pp, g, f);
+#           endif
+         }
+      }
+#     else
+         png_error(pp, "alpha mode handling not supported");
+#     endif
+   }
+
+   else
+   {
+      /* Set up gamma processing. */
+#     ifdef PNG_FLOATING_POINT_SUPPORTED
+         png_set_gamma(pp, dp->screen_gamma, dp->file_gamma);
+#     else
+      {
+         png_fixed_point s = fix(dp->screen_gamma);
+         png_fixed_point f = fix(dp->file_gamma);
+         png_set_gamma_fixed(pp, s, f);
+      }
+#     endif
+
+      if (dp->do_background)
+      {
+#     ifdef PNG_READ_BACKGROUND_SUPPORTED
+         /* NOTE: this assumes the caller provided the correct background gamma!
+          */
+         const double bg = dp->background_gamma;
+#        ifndef PNG_FLOATING_POINT_SUPPORTED
+            png_fixed_point g = fix(bg);
+#        endif
+
+#        ifdef PNG_FLOATING_POINT_SUPPORTED
+            png_set_background(pp, &dp->background_color, dp->do_background,
+               0/*need_expand*/, bg);
+#        else
+            png_set_background_fixed(pp, &dp->background_color,
+               dp->do_background, 0/*need_expand*/, g);
+#        endif
+#     else
+         png_error(pp, "png_set_background not supported");
+#     endif
+      }
+   }
+
+   {
+      int i = dp->this.use_update_info;
+      /* Always do one call, even if use_update_info is 0. */
+      do
+         png_read_update_info(pp, pi);
+      while (--i > 0);
+   }
+
+   /* Now we may get a different cbRow: */
+   standard_info_part2(&dp->this, pp, pi, 1 /*images*/);
+}
+
+static void PNGCBAPI
+gamma_info(png_structp pp, png_infop pi)
+{
+   gamma_info_imp(voidcast(gamma_display*, png_get_progressive_ptr(pp)), pp,
+      pi);
+}
+
+/* Validate a single component value - the routine gets the input and output
+ * sample values as unscaled PNG component values along with a cache of all the
+ * information required to validate the values.
+ */
+typedef struct validate_info
+{
+   png_const_structp  pp;
+   gamma_display *dp;
+   png_byte sbit;
+   int use_input_precision;
+   int do_background;
+   int scale16;
+   unsigned int sbit_max;
+   unsigned int isbit_shift;
+   unsigned int outmax;
+
+   double gamma_correction; /* Overall correction required. */
+   double file_inverse;     /* Inverse of file gamma. */
+   double screen_gamma;
+   double screen_inverse;   /* Inverse of screen gamma. */
+
+   double background_red;   /* Linear background value, red or gray. */
+   double background_green;
+   double background_blue;
+
+   double maxabs;
+   double maxpc;
+   double maxcalc;
+   double maxout;
+   double maxout_total;     /* Total including quantization error */
+   double outlog;
+   int    outquant;
+}
+validate_info;
+
+static void
+init_validate_info(validate_info *vi, gamma_display *dp, png_const_structp pp,
+    int in_depth, int out_depth)
+{
+   unsigned int outmax = (1U<<out_depth)-1;
+
+   vi->pp = pp;
+   vi->dp = dp;
+
+   if (dp->sbit > 0 && dp->sbit < in_depth)
+   {
+      vi->sbit = dp->sbit;
+      vi->isbit_shift = in_depth - dp->sbit;
+   }
+
+   else
+   {
+      vi->sbit = (png_byte)in_depth;
+      vi->isbit_shift = 0;
+   }
+
+   vi->sbit_max = (1U << vi->sbit)-1;
+
+   /* This mimics the libpng threshold test, '0' is used to prevent gamma
+    * correction in the validation test.
+    */
+   vi->screen_gamma = dp->screen_gamma;
+   if (fabs(vi->screen_gamma-1) < PNG_GAMMA_THRESHOLD)
+      vi->screen_gamma = vi->screen_inverse = 0;
+   else
+      vi->screen_inverse = 1/vi->screen_gamma;
+
+   vi->use_input_precision = dp->use_input_precision;
+   vi->outmax = outmax;
+   vi->maxabs = abserr(dp->pm, in_depth, out_depth);
+   vi->maxpc = pcerr(dp->pm, in_depth, out_depth);
+   vi->maxcalc = calcerr(dp->pm, in_depth, out_depth);
+   vi->maxout = outerr(dp->pm, in_depth, out_depth);
+   vi->outquant = output_quantization_factor(dp->pm, in_depth, out_depth);
+   vi->maxout_total = vi->maxout + vi->outquant * .5;
+   vi->outlog = outlog(dp->pm, in_depth, out_depth);
+
+   if ((dp->this.colour_type & PNG_COLOR_MASK_ALPHA) != 0 ||
+      (dp->this.colour_type == 3 && dp->this.is_transparent) ||
+      ((dp->this.colour_type == 0 || dp->this.colour_type == 2) &&
+       dp->this.has_tRNS))
+   {
+      vi->do_background = dp->do_background;
+
+      if (vi->do_background != 0)
+      {
+         const double bg_inverse = 1/dp->background_gamma;
+         double r, g, b;
+
+         /* Caller must at least put the gray value into the red channel */
+         r = dp->background_color.red; r /= outmax;
+         g = dp->background_color.green; g /= outmax;
+         b = dp->background_color.blue; b /= outmax;
+
+#     if 0
+         /* libpng doesn't do this optimization, if we do pngvalid will fail.
+          */
+         if (fabs(bg_inverse-1) >= PNG_GAMMA_THRESHOLD)
+#     endif
+         {
+            r = pow(r, bg_inverse);
+            g = pow(g, bg_inverse);
+            b = pow(b, bg_inverse);
+         }
+
+         vi->background_red = r;
+         vi->background_green = g;
+         vi->background_blue = b;
+      }
+   }
+   else /* Do not expect any background processing */
+      vi->do_background = 0;
+
+   if (vi->do_background == 0)
+      vi->background_red = vi->background_green = vi->background_blue = 0;
+
+   vi->gamma_correction = 1/(dp->file_gamma*dp->screen_gamma);
+   if (fabs(vi->gamma_correction-1) < PNG_GAMMA_THRESHOLD)
+      vi->gamma_correction = 0;
+
+   vi->file_inverse = 1/dp->file_gamma;
+   if (fabs(vi->file_inverse-1) < PNG_GAMMA_THRESHOLD)
+      vi->file_inverse = 0;
+
+   vi->scale16 = dp->scale16;
+}
+
+/* This function handles composition of a single non-alpha component.  The
+ * argument is the input sample value, in the range 0..1, and the alpha value.
+ * The result is the composed, linear, input sample.  If alpha is less than zero
+ * this is the alpha component and the function should not be called!
+ */
+static double
+gamma_component_compose(int do_background, double input_sample, double alpha,
+   double background, int *compose)
+{
+   switch (do_background)
+   {
+#ifdef PNG_READ_BACKGROUND_SUPPORTED
+      case PNG_BACKGROUND_GAMMA_SCREEN:
+      case PNG_BACKGROUND_GAMMA_FILE:
+      case PNG_BACKGROUND_GAMMA_UNIQUE:
+         /* Standard PNG background processing. */
+         if (alpha < 1)
+         {
+            if (alpha > 0)
+            {
+               input_sample = input_sample * alpha + background * (1-alpha);
+               if (compose != NULL)
+                  *compose = 1;
+            }
+
+            else
+               input_sample = background;
+         }
+         break;
+#endif
+
+#ifdef PNG_READ_ALPHA_MODE_SUPPORTED
+      case ALPHA_MODE_OFFSET + PNG_ALPHA_STANDARD:
+      case ALPHA_MODE_OFFSET + PNG_ALPHA_BROKEN:
+         /* The components are premultiplied in either case and the output is
+          * gamma encoded (to get standard Porter-Duff we expect the output
+          * gamma to be set to 1.0!)
+          */
+      case ALPHA_MODE_OFFSET + PNG_ALPHA_OPTIMIZED:
+         /* The optimization is that the partial-alpha entries are linear
+          * while the opaque pixels are gamma encoded, but this only affects the
+          * output encoding.
+          */
+         if (alpha < 1)
+         {
+            if (alpha > 0)
+            {
+               input_sample *= alpha;
+               if (compose != NULL)
+                  *compose = 1;
+            }
+
+            else
+               input_sample = 0;
+         }
+         break;
+#endif
+
+      default:
+         /* Standard cases where no compositing is done (so the component
+          * value is already correct.)
+          */
+         UNUSED(alpha)
+         UNUSED(background)
+         UNUSED(compose)
+         break;
+   }
+
+   return input_sample;
+}
+
+/* This API returns the encoded *input* component, in the range 0..1 */
+static double
+gamma_component_validate(const char *name, const validate_info *vi,
+    unsigned int id, unsigned int od,
+    const double alpha /* <0 for the alpha channel itself */,
+    const double background /* component background value */)
+{
+   unsigned int isbit = id >> vi->isbit_shift;
+   unsigned int sbit_max = vi->sbit_max;
+   unsigned int outmax = vi->outmax;
+   int do_background = vi->do_background;
+
+   double i;
+
+   /* First check on the 'perfect' result obtained from the digitized input
+    * value, id, and compare this against the actual digitized result, 'od'.
+    * 'i' is the input result in the range 0..1:
+    */
+   i = isbit; i /= sbit_max;
+
+   /* Check for the fast route: if we don't do any background composition or if
+    * this is the alpha channel ('alpha' < 0) or if the pixel is opaque then
+    * just use the gamma_correction field to correct to the final output gamma.
+    */
+   if (alpha == 1 /* opaque pixel component */ || !do_background
+#ifdef PNG_READ_ALPHA_MODE_SUPPORTED
+      || do_background == ALPHA_MODE_OFFSET + PNG_ALPHA_PNG
+#endif
+      || (alpha < 0 /* alpha channel */
+#ifdef PNG_READ_ALPHA_MODE_SUPPORTED
+      && do_background != ALPHA_MODE_OFFSET + PNG_ALPHA_BROKEN
+#endif
+      ))
+   {
+      /* Then get the gamma corrected version of 'i' and compare to 'od', any
+       * error less than .5 is insignificant - just quantization of the output
+       * value to the nearest digital value (nevertheless the error is still
+       * recorded - it's interesting ;-)
+       */
+      double encoded_sample = i;
+      double encoded_error;
+
+      /* alpha less than 0 indicates the alpha channel, which is always linear
+       */
+      if (alpha >= 0 && vi->gamma_correction > 0)
+         encoded_sample = pow(encoded_sample, vi->gamma_correction);
+      encoded_sample *= outmax;
+
+      encoded_error = fabs(od-encoded_sample);
+
+      if (encoded_error > vi->dp->maxerrout)
+         vi->dp->maxerrout = encoded_error;
+
+      if (encoded_error < vi->maxout_total && encoded_error < vi->outlog)
+         return i;
+   }
+
+   /* The slow route - attempt to do linear calculations. */
+   /* There may be an error, or background processing is required, so calculate
+    * the actual sample values - unencoded light intensity values.  Note that in
+    * practice these are not completely unencoded because they include a
+    * 'viewing correction' to decrease or (normally) increase the perceptual
+    * contrast of the image.  There's nothing we can do about this - we don't
+    * know what it is - so assume the unencoded value is perceptually linear.
+    */
+   {
+      double input_sample = i; /* In range 0..1 */
+      double output, error, encoded_sample, encoded_error;
+      double es_lo, es_hi;
+      int compose = 0;           /* Set to one if composition done */
+      int output_is_encoded;     /* Set if encoded to screen gamma */
+      int log_max_error = 1;     /* Check maximum error values */
+      png_const_charp pass = 0;  /* Reason test passes (or 0 for fail) */
+
+      /* Convert to linear light (with the above caveat.)  The alpha channel is
+       * already linear.
+       */
+      if (alpha >= 0)
+      {
+         int tcompose;
+
+         if (vi->file_inverse > 0)
+            input_sample = pow(input_sample, vi->file_inverse);
+
+         /* Handle the compose processing: */
+         tcompose = 0;
+         input_sample = gamma_component_compose(do_background, input_sample,
+            alpha, background, &tcompose);
+
+         if (tcompose)
+            compose = 1;
+      }
+
+      /* And similarly for the output value, but we need to check the background
+       * handling to linearize it correctly.
+       */
+      output = od;
+      output /= outmax;
+
+      output_is_encoded = vi->screen_gamma > 0;
+
+      if (alpha < 0) /* The alpha channel */
+      {
+#ifdef PNG_READ_ALPHA_MODE_SUPPORTED
+         if (do_background != ALPHA_MODE_OFFSET + PNG_ALPHA_BROKEN)
+#endif
+         {
+            /* In all other cases the output alpha channel is linear already,
+             * don't log errors here, they are much larger in linear data.
+             */
+            output_is_encoded = 0;
+            log_max_error = 0;
+         }
+      }
+
+#ifdef PNG_READ_ALPHA_MODE_SUPPORTED
+      else /* A component */
+      {
+         if (do_background == ALPHA_MODE_OFFSET + PNG_ALPHA_OPTIMIZED &&
+            alpha < 1) /* the optimized case - linear output */
+         {
+            if (alpha > 0) log_max_error = 0;
+            output_is_encoded = 0;
+         }
+      }
+#endif
+
+      if (output_is_encoded)
+         output = pow(output, vi->screen_gamma);
+
+      /* Calculate (or recalculate) the encoded_sample value and repeat the
+       * check above (unnecessary if we took the fast route, but harmless.)
+       */
+      encoded_sample = input_sample;
+      if (output_is_encoded)
+         encoded_sample = pow(encoded_sample, vi->screen_inverse);
+      encoded_sample *= outmax;
+
+      encoded_error = fabs(od-encoded_sample);
+
+      /* Don't log errors in the alpha channel, or the 'optimized' case,
+       * neither are significant to the overall perception.
+       */
+      if (log_max_error && encoded_error > vi->dp->maxerrout)
+         vi->dp->maxerrout = encoded_error;
+
+      if (encoded_error < vi->maxout_total)
+      {
+         if (encoded_error < vi->outlog)
+            return i;
+
+         /* Test passed but error is bigger than the log limit, record why the
+          * test passed:
+          */
+         pass = "less than maxout:\n";
+      }
+
+      /* i: the original input value in the range 0..1
+       *
+       * pngvalid calculations:
+       *  input_sample: linear result; i linearized and composed, range 0..1
+       *  encoded_sample: encoded result; input_sample scaled to output bit depth
+       *
+       * libpng calculations:
+       *  output: linear result; od scaled to 0..1 and linearized
+       *  od: encoded result from libpng
+       */
+
+      /* Now we have the numbers for real errors, both absolute values as as a
+       * percentage of the correct value (output):
+       */
+      error = fabs(input_sample-output);
+
+      if (log_max_error && error > vi->dp->maxerrabs)
+         vi->dp->maxerrabs = error;
+
+      /* The following is an attempt to ignore the tendency of quantization to
+       * dominate the percentage errors for lower result values:
+       */
+      if (log_max_error && input_sample > .5)
+      {
+         double percentage_error = error/input_sample;
+         if (percentage_error > vi->dp->maxerrpc)
+            vi->dp->maxerrpc = percentage_error;
+      }
+
+      /* Now calculate the digitization limits for 'encoded_sample' using the
+       * 'max' values.  Note that maxout is in the encoded space but maxpc and
+       * maxabs are in linear light space.
+       *
+       * First find the maximum error in linear light space, range 0..1:
+       */
+      {
+         double tmp = input_sample * vi->maxpc;
+         if (tmp < vi->maxabs) tmp = vi->maxabs;
+         /* If 'compose' is true the composition was done in linear space using
+          * integer arithmetic.  This introduces an extra error of +/- 0.5 (at
+          * least) in the integer space used.  'maxcalc' records this, taking
+          * into account the possibility that even for 16 bit output 8 bit space
+          * may have been used.
+          */
+         if (compose && tmp < vi->maxcalc) tmp = vi->maxcalc;
+
+         /* The 'maxout' value refers to the encoded result, to compare with
+          * this encode input_sample adjusted by the maximum error (tmp) above.
+          */
+         es_lo = encoded_sample - vi->maxout;
+
+         if (es_lo > 0 && input_sample-tmp > 0)
+         {
+            double low_value = input_sample-tmp;
+            if (output_is_encoded)
+               low_value = pow(low_value, vi->screen_inverse);
+            low_value *= outmax;
+            if (low_value < es_lo) es_lo = low_value;
+
+            /* Quantize this appropriately: */
+            es_lo = ceil(es_lo / vi->outquant - .5) * vi->outquant;
+         }
+
+         else
+            es_lo = 0;
+
+         es_hi = encoded_sample + vi->maxout;
+
+         if (es_hi < outmax && input_sample+tmp < 1)
+         {
+            double high_value = input_sample+tmp;
+            if (output_is_encoded)
+               high_value = pow(high_value, vi->screen_inverse);
+            high_value *= outmax;
+            if (high_value > es_hi) es_hi = high_value;
+
+            es_hi = floor(es_hi / vi->outquant + .5) * vi->outquant;
+         }
+
+         else
+            es_hi = outmax;
+      }
+
+      /* The primary test is that the final encoded value returned by the
+       * library should be between the two limits (inclusive) that were
+       * calculated above.
+       */
+      if (od >= es_lo && od <= es_hi)
+      {
+         /* The value passes, but we may need to log the information anyway. */
+         if (encoded_error < vi->outlog)
+            return i;
+
+         if (pass == 0)
+            pass = "within digitization limits:\n";
+      }
+
+      {
+         /* There has been an error in processing, or we need to log this
+          * value.
+          */
+         double is_lo, is_hi;
+
+         /* pass is set at this point if either of the tests above would have
+          * passed.  Don't do these additional tests here - just log the
+          * original [es_lo..es_hi] values.
+          */
+         if (pass == 0 && vi->use_input_precision && vi->dp->sbit)
+         {
+            /* Ok, something is wrong - this actually happens in current libpng
+             * 16-to-8 processing.  Assume that the input value (id, adjusted
+             * for sbit) can be anywhere between value-.5 and value+.5 - quite a
+             * large range if sbit is low.
+             *
+             * NOTE: at present because the libpng gamma table stuff has been
+             * changed to use a rounding algorithm to correct errors in 8-bit
+             * calculations the precise sbit calculation (a shift) has been
+             * lost.  This can result in up to a +/-1 error in the presence of
+             * an sbit less than the bit depth.
+             */
+#           if PNG_LIBPNG_VER < 10700
+#              define SBIT_ERROR .5
+#           else
+#              define SBIT_ERROR 1.
+#           endif
+            double tmp = (isbit - SBIT_ERROR)/sbit_max;
+
+            if (tmp <= 0)
+               tmp = 0;
+
+            else if (alpha >= 0 && vi->file_inverse > 0 && tmp < 1)
+               tmp = pow(tmp, vi->file_inverse);
+
+            tmp = gamma_component_compose(do_background, tmp, alpha, background,
+               NULL);
+
+            if (output_is_encoded && tmp > 0 && tmp < 1)
+               tmp = pow(tmp, vi->screen_inverse);
+
+            is_lo = ceil(outmax * tmp - vi->maxout_total);
+
+            if (is_lo < 0)
+               is_lo = 0;
+
+            tmp = (isbit + SBIT_ERROR)/sbit_max;
+
+            if (tmp >= 1)
+               tmp = 1;
+
+            else if (alpha >= 0 && vi->file_inverse > 0 && tmp < 1)
+               tmp = pow(tmp, vi->file_inverse);
+
+            tmp = gamma_component_compose(do_background, tmp, alpha, background,
+               NULL);
+
+            if (output_is_encoded && tmp > 0 && tmp < 1)
+               tmp = pow(tmp, vi->screen_inverse);
+
+            is_hi = floor(outmax * tmp + vi->maxout_total);
+
+            if (is_hi > outmax)
+               is_hi = outmax;
+
+            if (!(od < is_lo || od > is_hi))
+            {
+               if (encoded_error < vi->outlog)
+                  return i;
+
+               pass = "within input precision limits:\n";
+            }
+
+            /* One last chance.  If this is an alpha channel and the 16to8
+             * option has been used and 'inaccurate' scaling is used then the
+             * bit reduction is obtained by simply using the top 8 bits of the
+             * value.
+             *
+             * This is only done for older libpng versions when the 'inaccurate'
+             * (chop) method of scaling was used.
+             */
+#           ifndef PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED
+#              if PNG_LIBPNG_VER < 10504
+                  /* This may be required for other components in the future,
+                   * but at present the presence of gamma correction effectively
+                   * prevents the errors in the component scaling (I don't quite
+                   * understand why, but since it's better this way I care not
+                   * to ask, JB 20110419.)
+                   */
+                  if (pass == 0 && alpha < 0 && vi->scale16 && vi->sbit > 8 &&
+                     vi->sbit + vi->isbit_shift == 16)
+                  {
+                     tmp = ((id >> 8) - .5)/255;
+
+                     if (tmp > 0)
+                     {
+                        is_lo = ceil(outmax * tmp - vi->maxout_total);
+                        if (is_lo < 0) is_lo = 0;
+                     }
+
+                     else
+                        is_lo = 0;
+
+                     tmp = ((id >> 8) + .5)/255;
+
+                     if (tmp < 1)
+                     {
+                        is_hi = floor(outmax * tmp + vi->maxout_total);
+                        if (is_hi > outmax) is_hi = outmax;
+                     }
+
+                     else
+                        is_hi = outmax;
+
+                     if (!(od < is_lo || od > is_hi))
+                     {
+                        if (encoded_error < vi->outlog)
+                           return i;
+
+                        pass = "within 8 bit limits:\n";
+                     }
+                  }
+#              endif
+#           endif
+         }
+         else /* !use_input_precision */
+            is_lo = es_lo, is_hi = es_hi;
+
+         /* Attempt to output a meaningful error/warning message: the message
+          * output depends on the background/composite operation being performed
+          * because this changes what parameters were actually used above.
+          */
+         {
+            size_t pos = 0;
+            /* Need either 1/255 or 1/65535 precision here; 3 or 6 decimal
+             * places.  Just use outmax to work out which.
+             */
+            int precision = (outmax >= 1000 ? 6 : 3);
+            int use_input=1, use_background=0, do_compose=0;
+            char msg[256];
+
+            if (pass != 0)
+               pos = safecat(msg, sizeof msg, pos, "\n\t");
+
+            /* Set up the various flags, the output_is_encoded flag above
+             * is also used below.  do_compose is just a double check.
+             */
+            switch (do_background)
+            {
+#           ifdef PNG_READ_BACKGROUND_SUPPORTED
+               case PNG_BACKGROUND_GAMMA_SCREEN:
+               case PNG_BACKGROUND_GAMMA_FILE:
+               case PNG_BACKGROUND_GAMMA_UNIQUE:
+                  use_background = (alpha >= 0 && alpha < 1);
+#           endif
+#           ifdef PNG_READ_ALPHA_MODE_SUPPORTED
+               /* FALLTHROUGH */
+               case ALPHA_MODE_OFFSET + PNG_ALPHA_STANDARD:
+               case ALPHA_MODE_OFFSET + PNG_ALPHA_BROKEN:
+               case ALPHA_MODE_OFFSET + PNG_ALPHA_OPTIMIZED:
+#           endif /* ALPHA_MODE_SUPPORTED */
+               do_compose = (alpha > 0 && alpha < 1);
+               use_input = (alpha != 0);
+               break;
+
+            default:
+               break;
+            }
+
+            /* Check the 'compose' flag */
+            if (compose != do_compose)
+               png_error(vi->pp, "internal error (compose)");
+
+            /* 'name' is the component name */
+            pos = safecat(msg, sizeof msg, pos, name);
+            pos = safecat(msg, sizeof msg, pos, "(");
+            pos = safecatn(msg, sizeof msg, pos, id);
+            if (use_input || pass != 0/*logging*/)
+            {
+               if (isbit != id)
+               {
+                  /* sBIT has reduced the precision of the input: */
+                  pos = safecat(msg, sizeof msg, pos, ", sbit(");
+                  pos = safecatn(msg, sizeof msg, pos, vi->sbit);
+                  pos = safecat(msg, sizeof msg, pos, "): ");
+                  pos = safecatn(msg, sizeof msg, pos, isbit);
+               }
+               pos = safecat(msg, sizeof msg, pos, "/");
+               /* The output is either "id/max" or "id sbit(sbit): isbit/max" */
+               pos = safecatn(msg, sizeof msg, pos, vi->sbit_max);
+            }
+            pos = safecat(msg, sizeof msg, pos, ")");
+
+            /* A component may have been multiplied (in linear space) by the
+             * alpha value, 'compose' says whether this is relevant.
+             */
+            if (compose || pass != 0)
+            {
+               /* If any form of composition is being done report our
+                * calculated linear value here (the code above doesn't record
+                * the input value before composition is performed, so what
+                * gets reported is the value after composition.)
+                */
+               if (use_input || pass != 0)
+               {
+                  if (vi->file_inverse > 0)
+                  {
+                     pos = safecat(msg, sizeof msg, pos, "^");
+                     pos = safecatd(msg, sizeof msg, pos, vi->file_inverse, 2);
+                  }
+
+                  else
+                     pos = safecat(msg, sizeof msg, pos, "[linear]");
+
+                  pos = safecat(msg, sizeof msg, pos, "*(alpha)");
+                  pos = safecatd(msg, sizeof msg, pos, alpha, precision);
+               }
+
+               /* Now record the *linear* background value if it was used
+                * (this function is not passed the original, non-linear,
+                * value but it is contained in the test name.)
+                */
+               if (use_background)
+               {
+                  pos = safecat(msg, sizeof msg, pos, use_input ? "+" : " ");
+                  pos = safecat(msg, sizeof msg, pos, "(background)");
+                  pos = safecatd(msg, sizeof msg, pos, background, precision);
+                  pos = safecat(msg, sizeof msg, pos, "*");
+                  pos = safecatd(msg, sizeof msg, pos, 1-alpha, precision);
+               }
+            }
+
+            /* Report the calculated value (input_sample) and the linearized
+             * libpng value (output) unless this is just a component gamma
+             * correction.
+             */
+            if (compose || alpha < 0 || pass != 0)
+            {
+               pos = safecat(msg, sizeof msg, pos,
+                  pass != 0 ? " =\n\t" : " = ");
+               pos = safecatd(msg, sizeof msg, pos, input_sample, precision);
+               pos = safecat(msg, sizeof msg, pos, " (libpng: ");
+               pos = safecatd(msg, sizeof msg, pos, output, precision);
+               pos = safecat(msg, sizeof msg, pos, ")");
+
+               /* Finally report the output gamma encoding, if any. */
+               if (output_is_encoded)
+               {
+                  pos = safecat(msg, sizeof msg, pos, " ^");
+                  pos = safecatd(msg, sizeof msg, pos, vi->screen_inverse, 2);
+                  pos = safecat(msg, sizeof msg, pos, "(to screen) =");
+               }
+
+               else
+                  pos = safecat(msg, sizeof msg, pos, " [screen is linear] =");
+            }
+
+            if ((!compose && alpha >= 0) || pass != 0)
+            {
+               if (pass != 0) /* logging */
+                  pos = safecat(msg, sizeof msg, pos, "\n\t[overall:");
+
+               /* This is the non-composition case, the internal linear
+                * values are irrelevant (though the log below will reveal
+                * them.)  Output a much shorter warning/error message and report
+                * the overall gamma correction.
+                */
+               if (vi->gamma_correction > 0)
+               {
+                  pos = safecat(msg, sizeof msg, pos, " ^");
+                  pos = safecatd(msg, sizeof msg, pos, vi->gamma_correction, 2);
+                  pos = safecat(msg, sizeof msg, pos, "(gamma correction) =");
+               }
+
+               else
+                  pos = safecat(msg, sizeof msg, pos,
+                     " [no gamma correction] =");
+
+               if (pass != 0)
+                  pos = safecat(msg, sizeof msg, pos, "]");
+            }
+
+            /* This is our calculated encoded_sample which should (but does
+             * not) match od:
+             */
+            pos = safecat(msg, sizeof msg, pos, pass != 0 ? "\n\t" : " ");
+            pos = safecatd(msg, sizeof msg, pos, is_lo, 1);
+            pos = safecat(msg, sizeof msg, pos, " < ");
+            pos = safecatd(msg, sizeof msg, pos, encoded_sample, 1);
+            pos = safecat(msg, sizeof msg, pos, " (libpng: ");
+            pos = safecatn(msg, sizeof msg, pos, od);
+            pos = safecat(msg, sizeof msg, pos, ")");
+            pos = safecat(msg, sizeof msg, pos, "/");
+            pos = safecatn(msg, sizeof msg, pos, outmax);
+            pos = safecat(msg, sizeof msg, pos, " < ");
+            pos = safecatd(msg, sizeof msg, pos, is_hi, 1);
+
+            if (pass == 0) /* The error condition */
+            {
+#              ifdef PNG_WARNINGS_SUPPORTED
+                  png_warning(vi->pp, msg);
+#              else
+                  store_warning(vi->pp, msg);
+#              endif
+            }
+
+            else /* logging this value */
+               store_verbose(&vi->dp->pm->this, vi->pp, pass, msg);
+         }
+      }
+   }
+
+   return i;
+}
+
+static void
+gamma_image_validate(gamma_display *dp, png_const_structp pp,
+   png_infop pi)
+{
+   /* Get some constants derived from the input and output file formats: */
+   const png_store* const ps = dp->this.ps;
+   png_byte in_ct = dp->this.colour_type;
+   png_byte in_bd = dp->this.bit_depth;
+   png_uint_32 w = dp->this.w;
+   png_uint_32 h = dp->this.h;
+   const size_t cbRow = dp->this.cbRow;
+   png_byte out_ct = png_get_color_type(pp, pi);
+   png_byte out_bd = png_get_bit_depth(pp, pi);
+
+   /* There are three sources of error, firstly the quantization in the
+    * file encoding, determined by sbit and/or the file depth, secondly
+    * the output (screen) gamma and thirdly the output file encoding.
+    *
+    * Since this API receives the screen and file gamma in double
+    * precision it is possible to calculate an exact answer given an input
+    * pixel value.  Therefore we assume that the *input* value is exact -
+    * sample/maxsample - calculate the corresponding gamma corrected
+    * output to the limits of double precision arithmetic and compare with
+    * what libpng returns.
+    *
+    * Since the library must quantize the output to 8 or 16 bits there is
+    * a fundamental limit on the accuracy of the output of +/-.5 - this
+    * quantization limit is included in addition to the other limits
+    * specified by the parameters to the API.  (Effectively, add .5
+    * everywhere.)
+    *
+    * The behavior of the 'sbit' parameter is defined by section 12.5
+    * (sample depth scaling) of the PNG spec.  That section forces the
+    * decoder to assume that the PNG values have been scaled if sBIT is
+    * present:
+    *
+    *     png-sample = floor( input-sample * (max-out/max-in) + .5);
+    *
+    * This means that only a subset of the possible PNG values should
+    * appear in the input. However, the spec allows the encoder to use a
+    * variety of approximations to the above and doesn't require any
+    * restriction of the values produced.
+    *
+    * Nevertheless the spec requires that the upper 'sBIT' bits of the
+    * value stored in a PNG file be the original sample bits.
+    * Consequently the code below simply scales the top sbit bits by
+    * (1<<sbit)-1 to obtain an original sample value.
+    *
+    * Because there is limited precision in the input it is arguable that
+    * an acceptable result is any valid result from input-.5 to input+.5.
+    * The basic tests below do not do this, however if 'use_input_precision'
+    * is set a subsequent test is performed above.
+    */
+   unsigned int samples_per_pixel = (out_ct & 2U) ? 3U : 1U;
+   int processing;
+   png_uint_32 y;
+   const store_palette_entry *in_palette = dp->this.palette;
+   int in_is_transparent = dp->this.is_transparent;
+   int process_tRNS;
+   int out_npalette = -1;
+   int out_is_transparent = 0; /* Just refers to the palette case */
+   store_palette out_palette;
+   validate_info vi;
+
+   /* Check for row overwrite errors */
+   store_image_check(dp->this.ps, pp, 0);
+
+   /* Supply the input and output sample depths here - 8 for an indexed image,
+    * otherwise the bit depth.
+    */
+   init_validate_info(&vi, dp, pp, in_ct==3?8:in_bd, out_ct==3?8:out_bd);
+
+   processing = (vi.gamma_correction > 0 && !dp->threshold_test)
+      || in_bd != out_bd || in_ct != out_ct || vi.do_background;
+   process_tRNS = dp->this.has_tRNS && vi.do_background;
+
+   /* TODO: FIX THIS: MAJOR BUG!  If the transformations all happen inside
+    * the palette there is no way of finding out, because libpng fails to
+    * update the palette on png_read_update_info.  Indeed, libpng doesn't
+    * even do the required work until much later, when it doesn't have any
+    * info pointer.  Oops.  For the moment 'processing' is turned off if
+    * out_ct is palette.
+    */
+   if (in_ct == 3 && out_ct == 3)
+      processing = 0;
+
+   if (processing && out_ct == 3)
+      out_is_transparent = read_palette(out_palette, &out_npalette, pp, pi);
+
+   for (y=0; y<h; ++y)
+   {
+      png_const_bytep pRow = store_image_row(ps, pp, 0, y);
+      png_byte std[STANDARD_ROWMAX];
+
+      transform_row(pp, std, in_ct, in_bd, y);
+
+      if (processing)
+      {
+         unsigned int x;
+
+         for (x=0; x<w; ++x)
+         {
+            double alpha = 1; /* serves as a flag value */
+
+            /* Record the palette index for index images. */
+            unsigned int in_index =
+               in_ct == 3 ? sample(std, 3, in_bd, x, 0, 0, 0) : 256;
+            unsigned int out_index =
+               out_ct == 3 ? sample(std, 3, out_bd, x, 0, 0, 0) : 256;
+
+            /* Handle input alpha - png_set_background will cause the output
+             * alpha to disappear so there is nothing to check.
+             */
+            if ((in_ct & PNG_COLOR_MASK_ALPHA) != 0 ||
+                (in_ct == 3 && in_is_transparent))
+            {
+               unsigned int input_alpha = in_ct == 3 ?
+                  dp->this.palette[in_index].alpha :
+                  sample(std, in_ct, in_bd, x, samples_per_pixel, 0, 0);
+
+               unsigned int output_alpha = 65536 /* as a flag value */;
+
+               if (out_ct == 3)
+               {
+                  if (out_is_transparent)
+                     output_alpha = out_palette[out_index].alpha;
+               }
+
+               else if ((out_ct & PNG_COLOR_MASK_ALPHA) != 0)
+                  output_alpha = sample(pRow, out_ct, out_bd, x,
+                     samples_per_pixel, 0, 0);
+
+               if (output_alpha != 65536)
+                  alpha = gamma_component_validate("alpha", &vi, input_alpha,
+                     output_alpha, -1/*alpha*/, 0/*background*/);
+
+               else /* no alpha in output */
+               {
+                  /* This is a copy of the calculation of 'i' above in order to
+                   * have the alpha value to use in the background calculation.
+                   */
+                  alpha = input_alpha >> vi.isbit_shift;
+                  alpha /= vi.sbit_max;
+               }
+            }
+
+            else if (process_tRNS)
+            {
+               /* alpha needs to be set appropriately for this pixel, it is
+                * currently 1 and needs to be 0 for an input pixel which matches
+                * the values in tRNS.
+                */
+               switch (in_ct)
+               {
+                  case 0: /* gray */
+                     if (sample(std, in_ct, in_bd, x, 0, 0, 0) ==
+                           dp->this.transparent.red)
+                        alpha = 0;
+                     break;
+
+                  case 2: /* RGB */
+                     if (sample(std, in_ct, in_bd, x, 0, 0, 0) ==
+                           dp->this.transparent.red &&
+                         sample(std, in_ct, in_bd, x, 1, 0, 0) ==
+                           dp->this.transparent.green &&
+                         sample(std, in_ct, in_bd, x, 2, 0, 0) ==
+                           dp->this.transparent.blue)
+                        alpha = 0;
+                     break;
+
+                  default:
+                     break;
+               }
+            }
+
+            /* Handle grayscale or RGB components. */
+            if ((in_ct & PNG_COLOR_MASK_COLOR) == 0) /* grayscale */
+               (void)gamma_component_validate("gray", &vi,
+                  sample(std, in_ct, in_bd, x, 0, 0, 0),
+                  sample(pRow, out_ct, out_bd, x, 0, 0, 0),
+                  alpha/*component*/, vi.background_red);
+            else /* RGB or palette */
+            {
+               (void)gamma_component_validate("red", &vi,
+                  in_ct == 3 ? in_palette[in_index].red :
+                     sample(std, in_ct, in_bd, x, 0, 0, 0),
+                  out_ct == 3 ? out_palette[out_index].red :
+                     sample(pRow, out_ct, out_bd, x, 0, 0, 0),
+                  alpha/*component*/, vi.background_red);
+
+               (void)gamma_component_validate("green", &vi,
+                  in_ct == 3 ? in_palette[in_index].green :
+                     sample(std, in_ct, in_bd, x, 1, 0, 0),
+                  out_ct == 3 ? out_palette[out_index].green :
+                     sample(pRow, out_ct, out_bd, x, 1, 0, 0),
+                  alpha/*component*/, vi.background_green);
+
+               (void)gamma_component_validate("blue", &vi,
+                  in_ct == 3 ? in_palette[in_index].blue :
+                     sample(std, in_ct, in_bd, x, 2, 0, 0),
+                  out_ct == 3 ? out_palette[out_index].blue :
+                     sample(pRow, out_ct, out_bd, x, 2, 0, 0),
+                  alpha/*component*/, vi.background_blue);
+            }
+         }
+      }
+
+      else if (memcmp(std, pRow, cbRow) != 0)
+      {
+         char msg[64];
+
+         /* No transform is expected on the threshold tests. */
+         sprintf(msg, "gamma: below threshold row %lu changed",
+            (unsigned long)y);
+
+         png_error(pp, msg);
+      }
+   } /* row (y) loop */
+
+   dp->this.ps->validated = 1;
+}
+
+static void PNGCBAPI
+gamma_end(png_structp ppIn, png_infop pi)
+{
+   png_const_structp pp = ppIn;
+   gamma_display *dp = voidcast(gamma_display*, png_get_progressive_ptr(pp));
+
+   if (!dp->this.speed)
+      gamma_image_validate(dp, pp, pi);
+   else
+      dp->this.ps->validated = 1;
+}
+
+/* A single test run checking a gamma transformation.
+ *
+ * maxabs: maximum absolute error as a fraction
+ * maxout: maximum output error in the output units
+ * maxpc:  maximum percentage error (as a percentage)
+ */
+static void
+gamma_test(png_modifier *pmIn, png_byte colour_typeIn,
+    png_byte bit_depthIn, int palette_numberIn,
+    int interlace_typeIn,
+    const double file_gammaIn, const double screen_gammaIn,
+    png_byte sbitIn, int threshold_testIn,
+    const char *name,
+    int use_input_precisionIn, int scale16In,
+    int expand16In, int do_backgroundIn,
+    const png_color_16 *bkgd_colorIn, double bkgd_gammaIn)
+{
+   gamma_display d;
+   context(&pmIn->this, fault);
+
+   gamma_display_init(&d, pmIn, FILEID(colour_typeIn, bit_depthIn,
+      palette_numberIn, interlace_typeIn, 0, 0, 0),
+      file_gammaIn, screen_gammaIn, sbitIn,
+      threshold_testIn, use_input_precisionIn, scale16In,
+      expand16In, do_backgroundIn, bkgd_colorIn, bkgd_gammaIn);
+
+   Try
+   {
+      png_structp pp;
+      png_infop pi;
+      gama_modification gama_mod;
+      srgb_modification srgb_mod;
+      sbit_modification sbit_mod;
+
+      /* For the moment don't use the png_modifier support here. */
+      d.pm->encoding_counter = 0;
+      modifier_set_encoding(d.pm); /* Just resets everything */
+      d.pm->current_gamma = d.file_gamma;
+
+      /* Make an appropriate modifier to set the PNG file gamma to the
+       * given gamma value and the sBIT chunk to the given precision.
+       */
+      d.pm->modifications = NULL;
+      gama_modification_init(&gama_mod, d.pm, d.file_gamma);
+      srgb_modification_init(&srgb_mod, d.pm, 127 /*delete*/);
+      if (d.sbit > 0)
+         sbit_modification_init(&sbit_mod, d.pm, d.sbit);
+
+      modification_reset(d.pm->modifications);
+
+      /* Get a png_struct for reading the image. */
+      pp = set_modifier_for_read(d.pm, &pi, d.this.id, name);
+      standard_palette_init(&d.this);
+
+      /* Introduce the correct read function. */
+      if (d.pm->this.progressive)
+      {
+         /* Share the row function with the standard implementation. */
+         png_set_progressive_read_fn(pp, &d, gamma_info, progressive_row,
+            gamma_end);
+
+         /* Now feed data into the reader until we reach the end: */
+         modifier_progressive_read(d.pm, pp, pi);
+      }
+      else
+      {
+         /* modifier_read expects a png_modifier* */
+         png_set_read_fn(pp, d.pm, modifier_read);
+
+         /* Check the header values: */
+         png_read_info(pp, pi);
+
+         /* Process the 'info' requirements. Only one image is generated */
+         gamma_info_imp(&d, pp, pi);
+
+         sequential_row(&d.this, pp, pi, -1, 0);
+
+         if (!d.this.speed)
+            gamma_image_validate(&d, pp, pi);
+         else
+            d.this.ps->validated = 1;
+      }
+
+      modifier_reset(d.pm);
+
+      if (d.pm->log && !d.threshold_test && !d.this.speed)
+         fprintf(stderr, "%d bit %s %s: max error %f (%.2g, %2g%%)\n",
+            d.this.bit_depth, colour_types[d.this.colour_type], name,
+            d.maxerrout, d.maxerrabs, 100*d.maxerrpc);
+
+      /* Log the summary values too. */
+      if (d.this.colour_type == 0 || d.this.colour_type == 4)
+      {
+         switch (d.this.bit_depth)
+         {
+         case 1:
+            break;
+
+         case 2:
+            if (d.maxerrout > d.pm->error_gray_2)
+               d.pm->error_gray_2 = d.maxerrout;
+
+            break;
+
+         case 4:
+            if (d.maxerrout > d.pm->error_gray_4)
+               d.pm->error_gray_4 = d.maxerrout;
+
+            break;
+
+         case 8:
+            if (d.maxerrout > d.pm->error_gray_8)
+               d.pm->error_gray_8 = d.maxerrout;
+
+            break;
+
+         case 16:
+            if (d.maxerrout > d.pm->error_gray_16)
+               d.pm->error_gray_16 = d.maxerrout;
+
+            break;
+
+         default:
+            png_error(pp, "bad bit depth (internal: 1)");
+         }
+      }
+
+      else if (d.this.colour_type == 2 || d.this.colour_type == 6)
+      {
+         switch (d.this.bit_depth)
+         {
+         case 8:
+
+            if (d.maxerrout > d.pm->error_color_8)
+               d.pm->error_color_8 = d.maxerrout;
+
+            break;
+
+         case 16:
+
+            if (d.maxerrout > d.pm->error_color_16)
+               d.pm->error_color_16 = d.maxerrout;
+
+            break;
+
+         default:
+            png_error(pp, "bad bit depth (internal: 2)");
+         }
+      }
+
+      else if (d.this.colour_type == 3)
+      {
+         if (d.maxerrout > d.pm->error_indexed)
+            d.pm->error_indexed = d.maxerrout;
+      }
+   }
+
+   Catch(fault)
+      modifier_reset(voidcast(png_modifier*,(void*)fault));
+}
+
+static void gamma_threshold_test(png_modifier *pm, png_byte colour_type,
+    png_byte bit_depth, int interlace_type, double file_gamma,
+    double screen_gamma)
+{
+   size_t pos = 0;
+   char name[64];
+   pos = safecat(name, sizeof name, pos, "threshold ");
+   pos = safecatd(name, sizeof name, pos, file_gamma, 3);
+   pos = safecat(name, sizeof name, pos, "/");
+   pos = safecatd(name, sizeof name, pos, screen_gamma, 3);
+
+   (void)gamma_test(pm, colour_type, bit_depth, 0/*palette*/, interlace_type,
+      file_gamma, screen_gamma, 0/*sBIT*/, 1/*threshold test*/, name,
+      0 /*no input precision*/,
+      0 /*no scale16*/, 0 /*no expand16*/, 0 /*no background*/, 0 /*hence*/,
+      0 /*no background gamma*/);
+}
+
+static void
+perform_gamma_threshold_tests(png_modifier *pm)
+{
+   png_byte colour_type = 0;
+   png_byte bit_depth = 0;
+   unsigned int palette_number = 0;
+
+   /* Don't test more than one instance of each palette - it's pointless, in
+    * fact this test is somewhat excessive since libpng doesn't make this
+    * decision based on colour type or bit depth!
+    *
+    * CHANGED: now test two palettes and, as a side effect, images with and
+    * without tRNS.
+    */
+   while (next_format(&colour_type, &bit_depth, &palette_number,
+                      pm->test_lbg_gamma_threshold, pm->test_tRNS))
+      if (palette_number < 2)
+   {
+      double test_gamma = 1.0;
+      while (test_gamma >= .4)
+      {
+         /* There's little point testing the interlacing vs non-interlacing,
+          * but this can be set from the command line.
+          */
+         gamma_threshold_test(pm, colour_type, bit_depth, pm->interlace_type,
+            test_gamma, 1/test_gamma);
+         test_gamma *= .95;
+      }
+
+      /* And a special test for sRGB */
+      gamma_threshold_test(pm, colour_type, bit_depth, pm->interlace_type,
+          .45455, 2.2);
+
+      if (fail(pm))
+         return;
+   }
+}
+
+static void gamma_transform_test(png_modifier *pm,
+   png_byte colour_type, png_byte bit_depth,
+   int palette_number,
+   int interlace_type, const double file_gamma,
+   const double screen_gamma, png_byte sbit,
+   int use_input_precision, int scale16)
+{
+   size_t pos = 0;
+   char name[64];
+
+   if (sbit != bit_depth && sbit != 0)
+   {
+      pos = safecat(name, sizeof name, pos, "sbit(");
+      pos = safecatn(name, sizeof name, pos, sbit);
+      pos = safecat(name, sizeof name, pos, ") ");
+   }
+
+   else
+      pos = safecat(name, sizeof name, pos, "gamma ");
+
+   if (scale16)
+      pos = safecat(name, sizeof name, pos, "16to8 ");
+
+   pos = safecatd(name, sizeof name, pos, file_gamma, 3);
+   pos = safecat(name, sizeof name, pos, "->");
+   pos = safecatd(name, sizeof name, pos, screen_gamma, 3);
+
+   gamma_test(pm, colour_type, bit_depth, palette_number, interlace_type,
+      file_gamma, screen_gamma, sbit, 0, name, use_input_precision,
+      scale16, pm->test_gamma_expand16, 0 , 0, 0);
+}
+
+static void perform_gamma_transform_tests(png_modifier *pm)
+{
+   png_byte colour_type = 0;
+   png_byte bit_depth = 0;
+   unsigned int palette_number = 0;
+
+   while (next_format(&colour_type, &bit_depth, &palette_number,
+                      pm->test_lbg_gamma_transform, pm->test_tRNS))
+   {
+      unsigned int i, j;
+
+      for (i=0; i<pm->ngamma_tests; ++i) for (j=0; j<pm->ngamma_tests; ++j)
+         if (i != j)
+         {
+            gamma_transform_test(pm, colour_type, bit_depth, palette_number,
+               pm->interlace_type, 1/pm->gammas[i], pm->gammas[j], 0/*sBIT*/,
+               pm->use_input_precision, 0 /*do not scale16*/);
+
+            if (fail(pm))
+               return;
+         }
+   }
+}
+
+static void perform_gamma_sbit_tests(png_modifier *pm)
+{
+   png_byte sbit;
+
+   /* The only interesting cases are colour and grayscale, alpha is ignored here
+    * for overall speed.  Only bit depths where sbit is less than the bit depth
+    * are tested.
+    */
+   for (sbit=pm->sbitlow; sbit<(1<<READ_BDHI); ++sbit)
+   {
+      png_byte colour_type = 0, bit_depth = 0;
+      unsigned int npalette = 0;
+
+      while (next_format(&colour_type, &bit_depth, &npalette,
+                         pm->test_lbg_gamma_sbit, pm->test_tRNS))
+         if ((colour_type & PNG_COLOR_MASK_ALPHA) == 0 &&
+            ((colour_type == 3 && sbit < 8) ||
+            (colour_type != 3 && sbit < bit_depth)))
+      {
+         unsigned int i;
+
+         for (i=0; i<pm->ngamma_tests; ++i)
+         {
+            unsigned int j;
+
+            for (j=0; j<pm->ngamma_tests; ++j) if (i != j)
+            {
+               gamma_transform_test(pm, colour_type, bit_depth, npalette,
+                  pm->interlace_type, 1/pm->gammas[i], pm->gammas[j],
+                  sbit, pm->use_input_precision_sbit, 0 /*scale16*/);
+
+               if (fail(pm))
+                  return;
+            }
+         }
+      }
+   }
+}
+
+/* Note that this requires a 16 bit source image but produces 8 bit output, so
+ * we only need the 16bit write support, but the 16 bit images are only
+ * generated if DO_16BIT is defined.
+ */
+#ifdef DO_16BIT
+static void perform_gamma_scale16_tests(png_modifier *pm)
+{
+#  ifndef PNG_MAX_GAMMA_8
+#     define PNG_MAX_GAMMA_8 11
+#  endif
+#  if defined PNG_MAX_GAMMA_8 || PNG_LIBPNG_VER < 10700
+#     define SBIT_16_TO_8 PNG_MAX_GAMMA_8
+#  else
+#     define SBIT_16_TO_8 16
+#  endif
+   /* Include the alpha cases here. Note that sbit matches the internal value
+    * used by the library - otherwise we will get spurious errors from the
+    * internal sbit style approximation.
+    *
+    * The threshold test is here because otherwise the 16 to 8 conversion will
+    * proceed *without* gamma correction, and the tests above will fail (but not
+    * by much) - this could be fixed, it only appears with the -g option.
+    */
+   unsigned int i, j;
+   for (i=0; i<pm->ngamma_tests; ++i)
+   {
+      for (j=0; j<pm->ngamma_tests; ++j)
+      {
+         if (i != j &&
+             fabs(pm->gammas[j]/pm->gammas[i]-1) >= PNG_GAMMA_THRESHOLD)
+         {
+            gamma_transform_test(pm, 0, 16, 0, pm->interlace_type,
+               1/pm->gammas[i], pm->gammas[j], SBIT_16_TO_8,
+               pm->use_input_precision_16to8, 1 /*scale16*/);
+
+            if (fail(pm))
+               return;
+
+            gamma_transform_test(pm, 2, 16, 0, pm->interlace_type,
+               1/pm->gammas[i], pm->gammas[j], SBIT_16_TO_8,
+               pm->use_input_precision_16to8, 1 /*scale16*/);
+
+            if (fail(pm))
+               return;
+
+            gamma_transform_test(pm, 4, 16, 0, pm->interlace_type,
+               1/pm->gammas[i], pm->gammas[j], SBIT_16_TO_8,
+               pm->use_input_precision_16to8, 1 /*scale16*/);
+
+            if (fail(pm))
+               return;
+
+            gamma_transform_test(pm, 6, 16, 0, pm->interlace_type,
+               1/pm->gammas[i], pm->gammas[j], SBIT_16_TO_8,
+               pm->use_input_precision_16to8, 1 /*scale16*/);
+
+            if (fail(pm))
+               return;
+         }
+      }
+   }
+}
+#endif /* 16 to 8 bit conversion */
+
+#if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\
+   defined(PNG_READ_ALPHA_MODE_SUPPORTED)
+static void gamma_composition_test(png_modifier *pm,
+   png_byte colour_type, png_byte bit_depth,
+   int palette_number,
+   int interlace_type, const double file_gamma,
+   const double screen_gamma,
+   int use_input_precision, int do_background,
+   int expand_16)
+{
+   size_t pos = 0;
+   png_const_charp base;
+   double bg;
+   char name[128];
+   png_color_16 background;
+
+   /* Make up a name and get an appropriate background gamma value. */
+   switch (do_background)
+   {
+      default:
+         base = "";
+         bg = 4; /* should not be used */
+         break;
+      case PNG_BACKGROUND_GAMMA_SCREEN:
+         base = " bckg(Screen):";
+         bg = 1/screen_gamma;
+         break;
+      case PNG_BACKGROUND_GAMMA_FILE:
+         base = " bckg(File):";
+         bg = file_gamma;
+         break;
+      case PNG_BACKGROUND_GAMMA_UNIQUE:
+         base = " bckg(Unique):";
+         /* This tests the handling of a unique value, the math is such that the
+          * value tends to be <1, but is neither screen nor file (even if they
+          * match!)
+          */
+         bg = (file_gamma + screen_gamma) / 3;
+         break;
+#ifdef PNG_READ_ALPHA_MODE_SUPPORTED
+      case ALPHA_MODE_OFFSET + PNG_ALPHA_PNG:
+         base = " alpha(PNG)";
+         bg = 4; /* should not be used */
+         break;
+      case ALPHA_MODE_OFFSET + PNG_ALPHA_STANDARD:
+         base = " alpha(Porter-Duff)";
+         bg = 4; /* should not be used */
+         break;
+      case ALPHA_MODE_OFFSET + PNG_ALPHA_OPTIMIZED:
+         base = " alpha(Optimized)";
+         bg = 4; /* should not be used */
+         break;
+      case ALPHA_MODE_OFFSET + PNG_ALPHA_BROKEN:
+         base = " alpha(Broken)";
+         bg = 4; /* should not be used */
+         break;
+#endif
+   }
+
+   /* Use random background values - the background is always presented in the
+    * output space (8 or 16 bit components).
+    */
+   if (expand_16 || bit_depth == 16)
+   {
+      png_uint_32 r = random_32();
+
+      background.red = (png_uint_16)r;
+      background.green = (png_uint_16)(r >> 16);
+      r = random_32();
+      background.blue = (png_uint_16)r;
+      background.gray = (png_uint_16)(r >> 16);
+
+      /* In earlier libpng versions, those where DIGITIZE is set, any background
+       * gamma correction in the expand16 case was done using 8-bit gamma
+       * correction tables, resulting in larger errors.  To cope with those
+       * cases use a 16-bit background value which will handle this gamma
+       * correction.
+       */
+#     if DIGITIZE
+         if (expand_16 && (do_background == PNG_BACKGROUND_GAMMA_UNIQUE ||
+                           do_background == PNG_BACKGROUND_GAMMA_FILE) &&
+            fabs(bg*screen_gamma-1) > PNG_GAMMA_THRESHOLD)
+         {
+            /* The background values will be looked up in an 8-bit table to do
+             * the gamma correction, so only select values which are an exact
+             * match for the 8-bit table entries:
+             */
+            background.red = (png_uint_16)((background.red >> 8) * 257);
+            background.green = (png_uint_16)((background.green >> 8) * 257);
+            background.blue = (png_uint_16)((background.blue >> 8) * 257);
+            background.gray = (png_uint_16)((background.gray >> 8) * 257);
+         }
+#     endif
+   }
+
+   else /* 8 bit colors */
+   {
+      png_uint_32 r = random_32();
+
+      background.red = (png_byte)r;
+      background.green = (png_byte)(r >> 8);
+      background.blue = (png_byte)(r >> 16);
+      background.gray = (png_byte)(r >> 24);
+   }
+
+   background.index = 193; /* rgb(193,193,193) to detect errors */
+
+   if (!(colour_type & PNG_COLOR_MASK_COLOR))
+   {
+      /* Because, currently, png_set_background is always called with
+       * 'need_expand' false in this case and because the gamma test itself
+       * doesn't cause an expand to 8-bit for lower bit depths the colour must
+       * be reduced to the correct range.
+       */
+      if (bit_depth < 8)
+         background.gray &= (png_uint_16)((1U << bit_depth)-1);
+
+      /* Grayscale input, we do not convert to RGB (TBD), so we must set the
+       * background to gray - else libpng seems to fail.
+       */
+      background.red = background.green = background.blue = background.gray;
+   }
+
+   pos = safecat(name, sizeof name, pos, "gamma ");
+   pos = safecatd(name, sizeof name, pos, file_gamma, 3);
+   pos = safecat(name, sizeof name, pos, "->");
+   pos = safecatd(name, sizeof name, pos, screen_gamma, 3);
+
+   pos = safecat(name, sizeof name, pos, base);
+   if (do_background < ALPHA_MODE_OFFSET)
+   {
+      /* Include the background color and gamma in the name: */
+      pos = safecat(name, sizeof name, pos, "(");
+      /* This assumes no expand gray->rgb - the current code won't handle that!
+       */
+      if (colour_type & PNG_COLOR_MASK_COLOR)
+      {
+         pos = safecatn(name, sizeof name, pos, background.red);
+         pos = safecat(name, sizeof name, pos, ",");
+         pos = safecatn(name, sizeof name, pos, background.green);
+         pos = safecat(name, sizeof name, pos, ",");
+         pos = safecatn(name, sizeof name, pos, background.blue);
+      }
+      else
+         pos = safecatn(name, sizeof name, pos, background.gray);
+      pos = safecat(name, sizeof name, pos, ")^");
+      pos = safecatd(name, sizeof name, pos, bg, 3);
+   }
+
+   gamma_test(pm, colour_type, bit_depth, palette_number, interlace_type,
+      file_gamma, screen_gamma, 0/*sBIT*/, 0, name, use_input_precision,
+      0/*strip 16*/, expand_16, do_background, &background, bg);
+}
+
+
+static void
+perform_gamma_composition_tests(png_modifier *pm, int do_background,
+   int expand_16)
+{
+   png_byte colour_type = 0;
+   png_byte bit_depth = 0;
+   unsigned int palette_number = 0;
+
+   /* Skip the non-alpha cases - there is no setting of a transparency colour at
+    * present.
+    *
+    * TODO: incorrect; the palette case sets tRNS and, now RGB and gray do,
+    * however the palette case fails miserably so is commented out below.
+    */
+   while (next_format(&colour_type, &bit_depth, &palette_number,
+                      pm->test_lbg_gamma_composition, pm->test_tRNS))
+      if ((colour_type & PNG_COLOR_MASK_ALPHA) != 0
+#if 0 /* TODO: FIXME */
+          /*TODO: FIXME: this should work */
+          || colour_type == 3
+#endif
+          || (colour_type != 3 && palette_number != 0))
+   {
+      unsigned int i, j;
+
+      /* Don't skip the i==j case here - it's relevant. */
+      for (i=0; i<pm->ngamma_tests; ++i) for (j=0; j<pm->ngamma_tests; ++j)
+      {
+         gamma_composition_test(pm, colour_type, bit_depth, palette_number,
+            pm->interlace_type, 1/pm->gammas[i], pm->gammas[j],
+            pm->use_input_precision, do_background, expand_16);
+
+         if (fail(pm))
+            return;
+      }
+   }
+}
+#endif /* READ_BACKGROUND || READ_ALPHA_MODE */
+
+static void
+init_gamma_errors(png_modifier *pm)
+{
+   /* Use -1 to catch tests that were not actually run */
+   pm->error_gray_2 = pm->error_gray_4 = pm->error_gray_8 = -1.;
+   pm->error_color_8 = -1.;
+   pm->error_indexed = -1.;
+   pm->error_gray_16 = pm->error_color_16 = -1.;
+}
+
+static void
+print_one(const char *leader, double err)
+{
+   if (err != -1.)
+      printf(" %s %.5f\n", leader, err);
+}
+
+static void
+summarize_gamma_errors(png_modifier *pm, png_const_charp who, int low_bit_depth,
+   int indexed)
+{
+   fflush(stderr);
+
+   if (who)
+      printf("\nGamma correction with %s:\n", who);
+
+   else
+      printf("\nBasic gamma correction:\n");
+
+   if (low_bit_depth)
+   {
+      print_one(" 2 bit gray: ", pm->error_gray_2);
+      print_one(" 4 bit gray: ", pm->error_gray_4);
+      print_one(" 8 bit gray: ", pm->error_gray_8);
+      print_one(" 8 bit color:", pm->error_color_8);
+      if (indexed)
+         print_one(" indexed:    ", pm->error_indexed);
+   }
+
+   print_one("16 bit gray: ", pm->error_gray_16);
+   print_one("16 bit color:", pm->error_color_16);
+
+   fflush(stdout);
+}
+
+static void
+perform_gamma_test(png_modifier *pm, int summary)
+{
+   /*TODO: remove this*/
+   /* Save certain values for the temporary overrides below. */
+   unsigned int calculations_use_input_precision =
+      pm->calculations_use_input_precision;
+#  ifdef PNG_READ_BACKGROUND_SUPPORTED
+      double maxout8 = pm->maxout8;
+#  endif
+
+   /* First some arbitrary no-transform tests: */
+   if (!pm->this.speed && pm->test_gamma_threshold)
+   {
+      perform_gamma_threshold_tests(pm);
+
+      if (fail(pm))
+         return;
+   }
+
+   /* Now some real transforms. */
+   if (pm->test_gamma_transform)
+   {
+      if (summary)
+      {
+         fflush(stderr);
+         printf("Gamma correction error summary\n\n");
+         printf("The printed value is the maximum error in the pixel values\n");
+         printf("calculated by the libpng gamma correction code.  The error\n");
+         printf("is calculated as the difference between the output pixel\n");
+         printf("value (always an integer) and the ideal value from the\n");
+         printf("libpng specification (typically not an integer).\n\n");
+
+         printf("Expect this value to be less than .5 for 8 bit formats,\n");
+         printf("less than 1 for formats with fewer than 8 bits and a small\n");
+         printf("number (typically less than 5) for the 16 bit formats.\n");
+         printf("For performance reasons the value for 16 bit formats\n");
+         printf("increases when the image file includes an sBIT chunk.\n");
+         fflush(stdout);
+      }
+
+      init_gamma_errors(pm);
+      /*TODO: remove this.  Necessary because the current libpng
+       * implementation works in 8 bits:
+       */
+      if (pm->test_gamma_expand16)
+         pm->calculations_use_input_precision = 1;
+      perform_gamma_transform_tests(pm);
+      if (!calculations_use_input_precision)
+         pm->calculations_use_input_precision = 0;
+
+      if (summary)
+         summarize_gamma_errors(pm, 0/*who*/, 1/*low bit depth*/, 1/*indexed*/);
+
+      if (fail(pm))
+         return;
+   }
+
+   /* The sbit tests produce much larger errors: */
+   if (pm->test_gamma_sbit)
+   {
+      init_gamma_errors(pm);
+      perform_gamma_sbit_tests(pm);
+
+      if (summary)
+         summarize_gamma_errors(pm, "sBIT", pm->sbitlow < 8U, 1/*indexed*/);
+
+      if (fail(pm))
+         return;
+   }
+
+#ifdef DO_16BIT /* Should be READ_16BIT_SUPPORTED */
+   if (pm->test_gamma_scale16)
+   {
+      /* The 16 to 8 bit strip operations: */
+      init_gamma_errors(pm);
+      perform_gamma_scale16_tests(pm);
+
+      if (summary)
+      {
+         fflush(stderr);
+         printf("\nGamma correction with 16 to 8 bit reduction:\n");
+         printf(" 16 bit gray:  %.5f\n", pm->error_gray_16);
+         printf(" 16 bit color: %.5f\n", pm->error_color_16);
+         fflush(stdout);
+      }
+
+      if (fail(pm))
+         return;
+   }
+#endif
+
+#ifdef PNG_READ_BACKGROUND_SUPPORTED
+   if (pm->test_gamma_background)
+   {
+      init_gamma_errors(pm);
+
+      /*TODO: remove this.  Necessary because the current libpng
+       * implementation works in 8 bits:
+       */
+      if (pm->test_gamma_expand16)
+      {
+         pm->calculations_use_input_precision = 1;
+         pm->maxout8 = .499; /* because the 16 bit background is smashed */
+      }
+      perform_gamma_composition_tests(pm, PNG_BACKGROUND_GAMMA_UNIQUE,
+         pm->test_gamma_expand16);
+      if (!calculations_use_input_precision)
+         pm->calculations_use_input_precision = 0;
+      pm->maxout8 = maxout8;
+
+      if (summary)
+         summarize_gamma_errors(pm, "background", 1, 0/*indexed*/);
+
+      if (fail(pm))
+         return;
+   }
+#endif
+
+#ifdef PNG_READ_ALPHA_MODE_SUPPORTED
+   if (pm->test_gamma_alpha_mode)
+   {
+      int do_background;
+
+      init_gamma_errors(pm);
+
+      /*TODO: remove this.  Necessary because the current libpng
+       * implementation works in 8 bits:
+       */
+      if (pm->test_gamma_expand16)
+         pm->calculations_use_input_precision = 1;
+      for (do_background = ALPHA_MODE_OFFSET + PNG_ALPHA_STANDARD;
+         do_background <= ALPHA_MODE_OFFSET + PNG_ALPHA_BROKEN && !fail(pm);
+         ++do_background)
+         perform_gamma_composition_tests(pm, do_background,
+            pm->test_gamma_expand16);
+      if (!calculations_use_input_precision)
+         pm->calculations_use_input_precision = 0;
+
+      if (summary)
+         summarize_gamma_errors(pm, "alpha mode", 1, 0/*indexed*/);
+
+      if (fail(pm))
+         return;
+   }
+#endif
+}
+#endif /* PNG_READ_GAMMA_SUPPORTED */
+#endif /* PNG_READ_SUPPORTED */
+
+/* INTERLACE MACRO VALIDATION */
+/* This is copied verbatim from the specification, it is simply the pass
+ * number in which each pixel in each 8x8 tile appears.  The array must
+ * be indexed adam7[y][x] and notice that the pass numbers are based at
+ * 1, not 0 - the base libpng uses.
+ */
+static const
+png_byte adam7[8][8] =
+{
+   { 1,6,4,6,2,6,4,6 },
+   { 7,7,7,7,7,7,7,7 },
+   { 5,6,5,6,5,6,5,6 },
+   { 7,7,7,7,7,7,7,7 },
+   { 3,6,4,6,3,6,4,6 },
+   { 7,7,7,7,7,7,7,7 },
+   { 5,6,5,6,5,6,5,6 },
+   { 7,7,7,7,7,7,7,7 }
+};
+
+/* This routine validates all the interlace support macros in png.h for
+ * a variety of valid PNG widths and heights.  It uses a number of similarly
+ * named internal routines that feed off the above array.
+ */
+static png_uint_32
+png_pass_start_row(int pass)
+{
+   int x, y;
+   ++pass;
+   for (y=0; y<8; ++y) for (x=0; x<8; ++x) if (adam7[y][x] == pass)
+      return y;
+   return 0xf;
+}
+
+static png_uint_32
+png_pass_start_col(int pass)
+{
+   int x, y;
+   ++pass;
+   for (x=0; x<8; ++x) for (y=0; y<8; ++y) if (adam7[y][x] == pass)
+      return x;
+   return 0xf;
+}
+
+static int
+png_pass_row_shift(int pass)
+{
+   int x, y, base=(-1), inc=8;
+   ++pass;
+   for (y=0; y<8; ++y) for (x=0; x<8; ++x) if (adam7[y][x] == pass)
+   {
+      if (base == (-1))
+         base = y;
+      else if (base == y)
+         {}
+      else if (inc == y-base)
+         base=y;
+      else if (inc == 8)
+         inc = y-base, base=y;
+      else if (inc != y-base)
+         return 0xff; /* error - more than one 'inc' value! */
+   }
+
+   if (base == (-1)) return 0xfe; /* error - no row in pass! */
+
+   /* The shift is always 1, 2 or 3 - no pass has all the rows! */
+   switch (inc)
+   {
+case 2: return 1;
+case 4: return 2;
+case 8: return 3;
+default: break;
+   }
+
+   /* error - unrecognized 'inc' */
+   return (inc << 8) + 0xfd;
+}
+
+static int
+png_pass_col_shift(int pass)
+{
+   int x, y, base=(-1), inc=8;
+   ++pass;
+   for (x=0; x<8; ++x) for (y=0; y<8; ++y) if (adam7[y][x] == pass)
+   {
+      if (base == (-1))
+         base = x;
+      else if (base == x)
+         {}
+      else if (inc == x-base)
+         base=x;
+      else if (inc == 8)
+         inc = x-base, base=x;
+      else if (inc != x-base)
+         return 0xff; /* error - more than one 'inc' value! */
+   }
+
+   if (base == (-1)) return 0xfe; /* error - no row in pass! */
+
+   /* The shift is always 1, 2 or 3 - no pass has all the rows! */
+   switch (inc)
+   {
+case 1: return 0; /* pass 7 has all the columns */
+case 2: return 1;
+case 4: return 2;
+case 8: return 3;
+default: break;
+   }
+
+   /* error - unrecognized 'inc' */
+   return (inc << 8) + 0xfd;
+}
+
+static png_uint_32
+png_row_from_pass_row(png_uint_32 yIn, int pass)
+{
+   /* By examination of the array: */
+   switch (pass)
+   {
+case 0: return yIn * 8;
+case 1: return yIn * 8;
+case 2: return yIn * 8 + 4;
+case 3: return yIn * 4;
+case 4: return yIn * 4 + 2;
+case 5: return yIn * 2;
+case 6: return yIn * 2 + 1;
+default: break;
+   }
+
+   return 0xff; /* bad pass number */
+}
+
+static png_uint_32
+png_col_from_pass_col(png_uint_32 xIn, int pass)
+{
+   /* By examination of the array: */
+   switch (pass)
+   {
+case 0: return xIn * 8;
+case 1: return xIn * 8 + 4;
+case 2: return xIn * 4;
+case 3: return xIn * 4 + 2;
+case 4: return xIn * 2;
+case 5: return xIn * 2 + 1;
+case 6: return xIn;
+default: break;
+   }
+
+   return 0xff; /* bad pass number */
+}
+
+static int
+png_row_in_interlace_pass(png_uint_32 y, int pass)
+{
+   /* Is row 'y' in pass 'pass'? */
+   int x;
+   y &= 7;
+   ++pass;
+   for (x=0; x<8; ++x) if (adam7[y][x] == pass)
+      return 1;
+
+   return 0;
+}
+
+static int
+png_col_in_interlace_pass(png_uint_32 x, int pass)
+{
+   /* Is column 'x' in pass 'pass'? */
+   int y;
+   x &= 7;
+   ++pass;
+   for (y=0; y<8; ++y) if (adam7[y][x] == pass)
+      return 1;
+
+   return 0;
+}
+
+static png_uint_32
+png_pass_rows(png_uint_32 height, int pass)
+{
+   png_uint_32 tiles = height>>3;
+   png_uint_32 rows = 0;
+   unsigned int x, y;
+
+   height &= 7;
+   ++pass;
+   for (y=0; y<8; ++y) for (x=0; x<8; ++x) if (adam7[y][x] == pass)
+   {
+      rows += tiles;
+      if (y < height) ++rows;
+      break; /* i.e. break the 'x', column, loop. */
+   }
+
+   return rows;
+}
+
+static png_uint_32
+png_pass_cols(png_uint_32 width, int pass)
+{
+   png_uint_32 tiles = width>>3;
+   png_uint_32 cols = 0;
+   unsigned int x, y;
+
+   width &= 7;
+   ++pass;
+   for (x=0; x<8; ++x) for (y=0; y<8; ++y) if (adam7[y][x] == pass)
+   {
+      cols += tiles;
+      if (x < width) ++cols;
+      break; /* i.e. break the 'y', row, loop. */
+   }
+
+   return cols;
+}
+
+static void
+perform_interlace_macro_validation(void)
+{
+   /* The macros to validate, first those that depend only on pass:
+    *
+    * PNG_PASS_START_ROW(pass)
+    * PNG_PASS_START_COL(pass)
+    * PNG_PASS_ROW_SHIFT(pass)
+    * PNG_PASS_COL_SHIFT(pass)
+    */
+   int pass;
+
+   for (pass=0; pass<7; ++pass)
+   {
+      png_uint_32 m, f, v;
+
+      m = PNG_PASS_START_ROW(pass);
+      f = png_pass_start_row(pass);
+      if (m != f)
+      {
+         fprintf(stderr, "PNG_PASS_START_ROW(%d) = %u != %x\n", pass, m, f);
+         exit(99);
+      }
+
+      m = PNG_PASS_START_COL(pass);
+      f = png_pass_start_col(pass);
+      if (m != f)
+      {
+         fprintf(stderr, "PNG_PASS_START_COL(%d) = %u != %x\n", pass, m, f);
+         exit(99);
+      }
+
+      m = PNG_PASS_ROW_SHIFT(pass);
+      f = png_pass_row_shift(pass);
+      if (m != f)
+      {
+         fprintf(stderr, "PNG_PASS_ROW_SHIFT(%d) = %u != %x\n", pass, m, f);
+         exit(99);
+      }
+
+      m = PNG_PASS_COL_SHIFT(pass);
+      f = png_pass_col_shift(pass);
+      if (m != f)
+      {
+         fprintf(stderr, "PNG_PASS_COL_SHIFT(%d) = %u != %x\n", pass, m, f);
+         exit(99);
+      }
+
+      /* Macros that depend on the image or sub-image height too:
+       *
+       * PNG_PASS_ROWS(height, pass)
+       * PNG_PASS_COLS(width, pass)
+       * PNG_ROW_FROM_PASS_ROW(yIn, pass)
+       * PNG_COL_FROM_PASS_COL(xIn, pass)
+       * PNG_ROW_IN_INTERLACE_PASS(y, pass)
+       * PNG_COL_IN_INTERLACE_PASS(x, pass)
+       */
+      for (v=0;;)
+      {
+         /* The first two tests overflow if the pass row or column is outside
+          * the possible range for a 32-bit result.  In fact the values should
+          * never be outside the range for a 31-bit result, but checking for 32
+          * bits here ensures that if an app uses a bogus pass row or column
+          * (just so long as it fits in a 32 bit integer) it won't get a
+          * possibly dangerous overflow.
+          */
+         /* First the base 0 stuff: */
+         if (v < png_pass_rows(0xFFFFFFFFU, pass))
+         {
+            m = PNG_ROW_FROM_PASS_ROW(v, pass);
+            f = png_row_from_pass_row(v, pass);
+            if (m != f)
+            {
+               fprintf(stderr, "PNG_ROW_FROM_PASS_ROW(%u, %d) = %u != %x\n",
+                  v, pass, m, f);
+               exit(99);
+            }
+         }
+
+         if (v < png_pass_cols(0xFFFFFFFFU, pass))
+         {
+            m = PNG_COL_FROM_PASS_COL(v, pass);
+            f = png_col_from_pass_col(v, pass);
+            if (m != f)
+            {
+               fprintf(stderr, "PNG_COL_FROM_PASS_COL(%u, %d) = %u != %x\n",
+                  v, pass, m, f);
+               exit(99);
+            }
+         }
+
+         m = PNG_ROW_IN_INTERLACE_PASS(v, pass);
+         f = png_row_in_interlace_pass(v, pass);
+         if (m != f)
+         {
+            fprintf(stderr, "PNG_ROW_IN_INTERLACE_PASS(%u, %d) = %u != %x\n",
+               v, pass, m, f);
+            exit(99);
+         }
+
+         m = PNG_COL_IN_INTERLACE_PASS(v, pass);
+         f = png_col_in_interlace_pass(v, pass);
+         if (m != f)
+         {
+            fprintf(stderr, "PNG_COL_IN_INTERLACE_PASS(%u, %d) = %u != %x\n",
+               v, pass, m, f);
+            exit(99);
+         }
+
+         /* Then the base 1 stuff: */
+         ++v;
+         m = PNG_PASS_ROWS(v, pass);
+         f = png_pass_rows(v, pass);
+         if (m != f)
+         {
+            fprintf(stderr, "PNG_PASS_ROWS(%u, %d) = %u != %x\n",
+               v, pass, m, f);
+            exit(99);
+         }
+
+         m = PNG_PASS_COLS(v, pass);
+         f = png_pass_cols(v, pass);
+         if (m != f)
+         {
+            fprintf(stderr, "PNG_PASS_COLS(%u, %d) = %u != %x\n",
+               v, pass, m, f);
+            exit(99);
+         }
+
+         /* Move to the next v - the stepping algorithm starts skipping
+          * values above 1024.
+          */
+         if (v > 1024)
+         {
+            if (v == PNG_UINT_31_MAX)
+               break;
+
+            v = (v << 1) ^ v;
+            if (v >= PNG_UINT_31_MAX)
+               v = PNG_UINT_31_MAX-1;
+         }
+      }
+   }
+}
+
+/* Test color encodings. These values are back-calculated from the published
+ * chromaticities.  The values are accurate to about 14 decimal places; 15 are
+ * given.  These values are much more accurate than the ones given in the spec,
+ * which typically don't exceed 4 decimal places.  This allows testing of the
+ * libpng code to its theoretical accuracy of 4 decimal places.  (If pngvalid
+ * used the published errors the 'slack' permitted would have to be +/-.5E-4 or
+ * more.)
+ *
+ * The png_modifier code assumes that encodings[0] is sRGB and treats it
+ * specially: do not change the first entry in this list!
+ */
+static const color_encoding test_encodings[] =
+{
+/* sRGB: must be first in this list! */
+/*gamma:*/ { 1/2.2,
+/*red:  */ { 0.412390799265959, 0.212639005871510, 0.019330818715592 },
+/*green:*/ { 0.357584339383878, 0.715168678767756, 0.119194779794626 },
+/*blue: */ { 0.180480788401834, 0.072192315360734, 0.950532152249660} },
+/* Kodak ProPhoto (wide gamut) */
+/*gamma:*/ { 1/1.6 /*approximate: uses 1.8 power law compared to sRGB 2.4*/,
+/*red:  */ { 0.797760489672303, 0.288071128229293, 0.000000000000000 },
+/*green:*/ { 0.135185837175740, 0.711843217810102, 0.000000000000000 },
+/*blue: */ { 0.031349349581525, 0.000085653960605, 0.825104602510460} },
+/* Adobe RGB (1998) */
+/*gamma:*/ { 1/(2+51./256),
+/*red:  */ { 0.576669042910131, 0.297344975250536, 0.027031361386412 },
+/*green:*/ { 0.185558237906546, 0.627363566255466, 0.070688852535827 },
+/*blue: */ { 0.188228646234995, 0.075291458493998, 0.991337536837639} },
+/* Adobe Wide Gamut RGB */
+/*gamma:*/ { 1/(2+51./256),
+/*red:  */ { 0.716500716779386, 0.258728243040113, 0.000000000000000 },
+/*green:*/ { 0.101020574397477, 0.724682314948566, 0.051211818965388 },
+/*blue: */ { 0.146774385252705, 0.016589442011321, 0.773892783545073} },
+/* Fake encoding which selects just the green channel */
+/*gamma:*/ { 1.45/2.2, /* the 'Mac' gamma */
+/*red:  */ { 0.716500716779386, 0.000000000000000, 0.000000000000000 },
+/*green:*/ { 0.101020574397477, 1.000000000000000, 0.051211818965388 },
+/*blue: */ { 0.146774385252705, 0.000000000000000, 0.773892783545073} },
+};
+
+/* signal handler
+ *
+ * This attempts to trap signals and escape without crashing.  It needs a
+ * context pointer so that it can throw an exception (call longjmp) to recover
+ * from the condition; this is handled by making the png_modifier used by 'main'
+ * into a global variable.
+ */
+static png_modifier pm;
+
+static void signal_handler(int signum)
+{
+
+   size_t pos = 0;
+   char msg[64];
+
+   pos = safecat(msg, sizeof msg, pos, "caught signal: ");
+
+   switch (signum)
+   {
+      case SIGABRT:
+         pos = safecat(msg, sizeof msg, pos, "abort");
+         break;
+
+      case SIGFPE:
+         pos = safecat(msg, sizeof msg, pos, "floating point exception");
+         break;
+
+      case SIGILL:
+         pos = safecat(msg, sizeof msg, pos, "illegal instruction");
+         break;
+
+      case SIGINT:
+         pos = safecat(msg, sizeof msg, pos, "interrupt");
+         break;
+
+      case SIGSEGV:
+         pos = safecat(msg, sizeof msg, pos, "invalid memory access");
+         break;
+
+      case SIGTERM:
+         pos = safecat(msg, sizeof msg, pos, "termination request");
+         break;
+
+      default:
+         pos = safecat(msg, sizeof msg, pos, "unknown ");
+         pos = safecatn(msg, sizeof msg, pos, signum);
+         break;
+   }
+
+   store_log(&pm.this, NULL/*png_structp*/, msg, 1/*error*/);
+
+   /* And finally throw an exception so we can keep going, unless this is
+    * SIGTERM in which case stop now.
+    */
+   if (signum != SIGTERM)
+   {
+      struct exception_context *the_exception_context =
+         &pm.this.exception_context;
+
+      Throw &pm.this;
+   }
+
+   else
+      exit(1);
+}
+
+/* main program */
+int main(int argc, char **argv)
+{
+   int summary = 1;  /* Print the error summary at the end */
+   int memstats = 0; /* Print memory statistics at the end */
+
+   /* Create the given output file on success: */
+   const char *touch = NULL;
+
+   /* This is an array of standard gamma values (believe it or not I've seen
+    * every one of these mentioned somewhere.)
+    *
+    * In the following list the most useful values are first!
+    */
+   static double
+      gammas[]={2.2, 1.0, 2.2/1.45, 1.8, 1.5, 2.4, 2.5, 2.62, 2.9};
+
+   /* This records the command and arguments: */
+   size_t cp = 0;
+   char command[1024];
+
+   anon_context(&pm.this);
+
+   gnu_volatile(summary)
+   gnu_volatile(memstats)
+   gnu_volatile(touch)
+
+   /* Add appropriate signal handlers, just the ANSI specified ones: */
+   signal(SIGABRT, signal_handler);
+   signal(SIGFPE, signal_handler);
+   signal(SIGILL, signal_handler);
+   signal(SIGINT, signal_handler);
+   signal(SIGSEGV, signal_handler);
+   signal(SIGTERM, signal_handler);
+
+#ifdef HAVE_FEENABLEEXCEPT
+   /* Only required to enable FP exceptions on platforms where they start off
+    * disabled; this is not necessary but if it is not done pngvalid will likely
+    * end up ignoring FP conditions that other platforms fault.
+    */
+   feenableexcept(FE_DIVBYZERO | FE_INVALID | FE_OVERFLOW);
+#endif
+
+   modifier_init(&pm);
+
+   /* Preallocate the image buffer, because we know how big it needs to be,
+    * note that, for testing purposes, it is deliberately mis-aligned by tag
+    * bytes either side.  All rows have an additional five bytes of padding for
+    * overwrite checking.
+    */
+   store_ensure_image(&pm.this, NULL, 2, TRANSFORM_ROWMAX, TRANSFORM_HEIGHTMAX);
+
+   /* Don't give argv[0], it's normally some horrible libtool string: */
+   cp = safecat(command, sizeof command, cp, "pngvalid");
+
+   /* Default to error on warning: */
+   pm.this.treat_warnings_as_errors = 1;
+
+   /* Default assume_16_bit_calculations appropriately; this tells the checking
+    * code that 16-bit arithmetic is used for 8-bit samples when it would make a
+    * difference.
+    */
+   pm.assume_16_bit_calculations = PNG_LIBPNG_VER >= 10700;
+
+   /* Currently 16 bit expansion happens at the end of the pipeline, so the
+    * calculations are done in the input bit depth not the output.
+    *
+    * TODO: fix this
+    */
+   pm.calculations_use_input_precision = 1U;
+
+   /* Store the test gammas */
+   pm.gammas = gammas;
+   pm.ngammas = ARRAY_SIZE(gammas);
+   pm.ngamma_tests = 0; /* default to off */
+
+   /* Low bit depth gray images don't do well in the gamma tests, until
+    * this is fixed turn them off for some gamma cases:
+    */
+#  ifdef PNG_WRITE_tRNS_SUPPORTED
+      pm.test_tRNS = 1;
+#  endif
+   pm.test_lbg = PNG_LIBPNG_VER >= 10600;
+   pm.test_lbg_gamma_threshold = 1;
+   pm.test_lbg_gamma_transform = PNG_LIBPNG_VER >= 10600;
+   pm.test_lbg_gamma_sbit = 1;
+   pm.test_lbg_gamma_composition = PNG_LIBPNG_VER >= 10700;
+
+   /* And the test encodings */
+   pm.encodings = test_encodings;
+   pm.nencodings = ARRAY_SIZE(test_encodings);
+
+#  if PNG_LIBPNG_VER < 10700
+      pm.sbitlow = 8U; /* because libpng doesn't do sBIT below 8! */
+#  else
+      pm.sbitlow = 1U;
+#  endif
+
+   /* The following allows results to pass if they correspond to anything in the
+    * transformed range [input-.5,input+.5]; this is is required because of the
+    * way libpng treates the 16_TO_8 flag when building the gamma tables in
+    * releases up to 1.6.0.
+    *
+    * TODO: review this
+    */
+   pm.use_input_precision_16to8 = 1U;
+   pm.use_input_precision_sbit = 1U; /* because libpng now rounds sBIT */
+
+   /* Some default values (set the behavior for 'make check' here).
+    * These values simply control the maximum error permitted in the gamma
+    * transformations.  The practical limits for human perception are described
+    * below (the setting for maxpc16), however for 8 bit encodings it isn't
+    * possible to meet the accepted capabilities of human vision - i.e. 8 bit
+    * images can never be good enough, regardless of encoding.
+    */
+   pm.maxout8 = .1;     /* Arithmetic error in *encoded* value */
+   pm.maxabs8 = .00005; /* 1/20000 */
+   pm.maxcalc8 = 1./255;  /* +/-1 in 8 bits for compose errors */
+   pm.maxpc8 = .499;    /* I.e., .499% fractional error */
+   pm.maxout16 = .499;  /* Error in *encoded* value */
+   pm.maxabs16 = .00005;/* 1/20000 */
+   pm.maxcalc16 =1./65535;/* +/-1 in 16 bits for compose errors */
+#  if PNG_LIBPNG_VER < 10700
+      pm.maxcalcG = 1./((1<<PNG_MAX_GAMMA_8)-1);
+#  else
+      pm.maxcalcG = 1./((1<<16)-1);
+#  endif
+
+   /* NOTE: this is a reasonable perceptual limit. We assume that humans can
+    * perceive light level differences of 1% over a 100:1 range, so we need to
+    * maintain 1 in 10000 accuracy (in linear light space), which is what the
+    * following guarantees.  It also allows significantly higher errors at
+    * higher 16 bit values, which is important for performance.  The actual
+    * maximum 16 bit error is about +/-1.9 in the fixed point implementation but
+    * this is only allowed for values >38149 by the following:
+    */
+   pm.maxpc16 = .005;   /* I.e., 1/200% - 1/20000 */
+
+   /* Now parse the command line options. */
+   while (--argc >= 1)
+   {
+      int catmore = 0; /* Set if the argument has an argument. */
+
+      /* Record each argument for posterity: */
+      cp = safecat(command, sizeof command, cp, " ");
+      cp = safecat(command, sizeof command, cp, *++argv);
+
+      if (strcmp(*argv, "-v") == 0)
+         pm.this.verbose = 1;
+
+      else if (strcmp(*argv, "-l") == 0)
+         pm.log = 1;
+
+      else if (strcmp(*argv, "-q") == 0)
+         summary = pm.this.verbose = pm.log = 0;
+
+      else if (strcmp(*argv, "-w") == 0 ||
+               strcmp(*argv, "--strict") == 0)
+         pm.this.treat_warnings_as_errors = 1; /* NOTE: this is the default! */
+
+      else if (strcmp(*argv, "--nostrict") == 0)
+         pm.this.treat_warnings_as_errors = 0;
+
+      else if (strcmp(*argv, "--speed") == 0)
+         pm.this.speed = 1, pm.ngamma_tests = pm.ngammas, pm.test_standard = 0,
+            summary = 0;
+
+      else if (strcmp(*argv, "--memory") == 0)
+         memstats = 1;
+
+      else if (strcmp(*argv, "--size") == 0)
+         pm.test_size = 1;
+
+      else if (strcmp(*argv, "--nosize") == 0)
+         pm.test_size = 0;
+
+      else if (strcmp(*argv, "--standard") == 0)
+         pm.test_standard = 1;
+
+      else if (strcmp(*argv, "--nostandard") == 0)
+         pm.test_standard = 0;
+
+      else if (strcmp(*argv, "--transform") == 0)
+         pm.test_transform = 1;
+
+      else if (strcmp(*argv, "--notransform") == 0)
+         pm.test_transform = 0;
+
+#ifdef PNG_READ_TRANSFORMS_SUPPORTED
+      else if (strncmp(*argv, "--transform-disable=",
+         sizeof "--transform-disable") == 0)
+         {
+         pm.test_transform = 1;
+         transform_disable(*argv + sizeof "--transform-disable");
+         }
+
+      else if (strncmp(*argv, "--transform-enable=",
+         sizeof "--transform-enable") == 0)
+         {
+         pm.test_transform = 1;
+         transform_enable(*argv + sizeof "--transform-enable");
+         }
+#endif /* PNG_READ_TRANSFORMS_SUPPORTED */
+
+      else if (strcmp(*argv, "--gamma") == 0)
+         {
+         /* Just do two gamma tests here (2.2 and linear) for speed: */
+         pm.ngamma_tests = 2U;
+         pm.test_gamma_threshold = 1;
+         pm.test_gamma_transform = 1;
+         pm.test_gamma_sbit = 1;
+         pm.test_gamma_scale16 = 1;
+         pm.test_gamma_background = 1; /* composition */
+         pm.test_gamma_alpha_mode = 1;
+         }
+
+      else if (strcmp(*argv, "--nogamma") == 0)
+         pm.ngamma_tests = 0;
+
+      else if (strcmp(*argv, "--gamma-threshold") == 0)
+         pm.ngamma_tests = 2U, pm.test_gamma_threshold = 1;
+
+      else if (strcmp(*argv, "--nogamma-threshold") == 0)
+         pm.test_gamma_threshold = 0;
+
+      else if (strcmp(*argv, "--gamma-transform") == 0)
+         pm.ngamma_tests = 2U, pm.test_gamma_transform = 1;
+
+      else if (strcmp(*argv, "--nogamma-transform") == 0)
+         pm.test_gamma_transform = 0;
+
+      else if (strcmp(*argv, "--gamma-sbit") == 0)
+         pm.ngamma_tests = 2U, pm.test_gamma_sbit = 1;
+
+      else if (strcmp(*argv, "--nogamma-sbit") == 0)
+         pm.test_gamma_sbit = 0;
+
+      else if (strcmp(*argv, "--gamma-16-to-8") == 0)
+         pm.ngamma_tests = 2U, pm.test_gamma_scale16 = 1;
+
+      else if (strcmp(*argv, "--nogamma-16-to-8") == 0)
+         pm.test_gamma_scale16 = 0;
+
+      else if (strcmp(*argv, "--gamma-background") == 0)
+         pm.ngamma_tests = 2U, pm.test_gamma_background = 1;
+
+      else if (strcmp(*argv, "--nogamma-background") == 0)
+         pm.test_gamma_background = 0;
+
+      else if (strcmp(*argv, "--gamma-alpha-mode") == 0)
+         pm.ngamma_tests = 2U, pm.test_gamma_alpha_mode = 1;
+
+      else if (strcmp(*argv, "--nogamma-alpha-mode") == 0)
+         pm.test_gamma_alpha_mode = 0;
+
+      else if (strcmp(*argv, "--expand16") == 0)
+         pm.test_gamma_expand16 = 1;
+
+      else if (strcmp(*argv, "--noexpand16") == 0)
+         pm.test_gamma_expand16 = 0;
+
+      else if (strcmp(*argv, "--low-depth-gray") == 0)
+         pm.test_lbg = pm.test_lbg_gamma_threshold =
+            pm.test_lbg_gamma_transform = pm.test_lbg_gamma_sbit =
+            pm.test_lbg_gamma_composition = 1;
+
+      else if (strcmp(*argv, "--nolow-depth-gray") == 0)
+         pm.test_lbg = pm.test_lbg_gamma_threshold =
+            pm.test_lbg_gamma_transform = pm.test_lbg_gamma_sbit =
+            pm.test_lbg_gamma_composition = 0;
+
+#     ifdef PNG_WRITE_tRNS_SUPPORTED
+         else if (strcmp(*argv, "--tRNS") == 0)
+            pm.test_tRNS = 1;
+#     endif
+
+      else if (strcmp(*argv, "--notRNS") == 0)
+         pm.test_tRNS = 0;
+
+      else if (strcmp(*argv, "--more-gammas") == 0)
+         pm.ngamma_tests = 3U;
+
+      else if (strcmp(*argv, "--all-gammas") == 0)
+         pm.ngamma_tests = pm.ngammas;
+
+      else if (strcmp(*argv, "--progressive-read") == 0)
+         pm.this.progressive = 1;
+
+      else if (strcmp(*argv, "--use-update-info") == 0)
+         ++pm.use_update_info; /* Can call multiple times */
+
+      else if (strcmp(*argv, "--interlace") == 0)
+      {
+#        if CAN_WRITE_INTERLACE
+            pm.interlace_type = PNG_INTERLACE_ADAM7;
+#        else /* !CAN_WRITE_INTERLACE */
+            fprintf(stderr, "pngvalid: no write interlace support\n");
+            return SKIP;
+#        endif /* !CAN_WRITE_INTERLACE */
+      }
+
+      else if (strcmp(*argv, "--use-input-precision") == 0)
+         pm.use_input_precision = 1U;
+
+      else if (strcmp(*argv, "--use-calculation-precision") == 0)
+         pm.use_input_precision = 0;
+
+      else if (strcmp(*argv, "--calculations-use-input-precision") == 0)
+         pm.calculations_use_input_precision = 1U;
+
+      else if (strcmp(*argv, "--assume-16-bit-calculations") == 0)
+         pm.assume_16_bit_calculations = 1U;
+
+      else if (strcmp(*argv, "--calculations-follow-bit-depth") == 0)
+         pm.calculations_use_input_precision =
+            pm.assume_16_bit_calculations = 0;
+
+      else if (strcmp(*argv, "--exhaustive") == 0)
+         pm.test_exhaustive = 1;
+
+      else if (argc > 1 && strcmp(*argv, "--sbitlow") == 0)
+         --argc, pm.sbitlow = (png_byte)atoi(*++argv), catmore = 1;
+
+      else if (argc > 1 && strcmp(*argv, "--touch") == 0)
+         --argc, touch = *++argv, catmore = 1;
+
+      else if (argc > 1 && strncmp(*argv, "--max", 5) == 0)
+      {
+         --argc;
+
+         if (strcmp(5+*argv, "abs8") == 0)
+            pm.maxabs8 = atof(*++argv);
+
+         else if (strcmp(5+*argv, "abs16") == 0)
+            pm.maxabs16 = atof(*++argv);
+
+         else if (strcmp(5+*argv, "calc8") == 0)
+            pm.maxcalc8 = atof(*++argv);
+
+         else if (strcmp(5+*argv, "calc16") == 0)
+            pm.maxcalc16 = atof(*++argv);
+
+         else if (strcmp(5+*argv, "out8") == 0)
+            pm.maxout8 = atof(*++argv);
+
+         else if (strcmp(5+*argv, "out16") == 0)
+            pm.maxout16 = atof(*++argv);
+
+         else if (strcmp(5+*argv, "pc8") == 0)
+            pm.maxpc8 = atof(*++argv);
+
+         else if (strcmp(5+*argv, "pc16") == 0)
+            pm.maxpc16 = atof(*++argv);
+
+         else
+         {
+            fprintf(stderr, "pngvalid: %s: unknown 'max' option\n", *argv);
+            exit(99);
+         }
+
+         catmore = 1;
+      }
+
+      else if (strcmp(*argv, "--log8") == 0)
+         --argc, pm.log8 = atof(*++argv), catmore = 1;
+
+      else if (strcmp(*argv, "--log16") == 0)
+         --argc, pm.log16 = atof(*++argv), catmore = 1;
+
+#ifdef PNG_SET_OPTION_SUPPORTED
+      else if (strncmp(*argv, "--option=", 9) == 0)
+      {
+         /* Syntax of the argument is <option>:{on|off} */
+         const char *arg = 9+*argv;
+         unsigned char option=0, setting=0;
+
+#ifdef PNG_ARM_NEON
+         if (strncmp(arg, "arm-neon:", 9) == 0)
+            option = PNG_ARM_NEON, arg += 9;
+
+         else
+#endif
+#ifdef PNG_EXTENSIONS
+         if (strncmp(arg, "extensions:", 11) == 0)
+            option = PNG_EXTENSIONS, arg += 11;
+
+         else
+#endif
+#ifdef PNG_MAXIMUM_INFLATE_WINDOW
+         if (strncmp(arg, "max-inflate-window:", 19) == 0)
+            option = PNG_MAXIMUM_INFLATE_WINDOW, arg += 19;
+
+         else
+#endif
+         {
+            fprintf(stderr, "pngvalid: %s: %s: unknown option\n", *argv, arg);
+            exit(99);
+         }
+
+         if (strcmp(arg, "off") == 0)
+            setting = PNG_OPTION_OFF;
+
+         else if (strcmp(arg, "on") == 0)
+            setting = PNG_OPTION_ON;
+
+         else
+         {
+            fprintf(stderr,
+               "pngvalid: %s: %s: unknown setting (use 'on' or 'off')\n",
+               *argv, arg);
+            exit(99);
+         }
+
+         pm.this.options[pm.this.noptions].option = option;
+         pm.this.options[pm.this.noptions++].setting = setting;
+      }
+#endif /* PNG_SET_OPTION_SUPPORTED */
+
+      else
+      {
+         fprintf(stderr, "pngvalid: %s: unknown argument\n", *argv);
+         exit(99);
+      }
+
+      if (catmore) /* consumed an extra *argv */
+      {
+         cp = safecat(command, sizeof command, cp, " ");
+         cp = safecat(command, sizeof command, cp, *argv);
+      }
+   }
+
+   /* If pngvalid is run with no arguments default to a reasonable set of the
+    * tests.
+    */
+   if (pm.test_standard == 0 && pm.test_size == 0 && pm.test_transform == 0 &&
+      pm.ngamma_tests == 0)
+   {
+      /* Make this do all the tests done in the test shell scripts with the same
+       * parameters, where possible.  The limitation is that all the progressive
+       * read and interlace stuff has to be done in separate runs, so only the
+       * basic 'standard' and 'size' tests are done.
+       */
+      pm.test_standard = 1;
+      pm.test_size = 1;
+      pm.test_transform = 1;
+      pm.ngamma_tests = 2U;
+   }
+
+   if (pm.ngamma_tests > 0 &&
+      pm.test_gamma_threshold == 0 && pm.test_gamma_transform == 0 &&
+      pm.test_gamma_sbit == 0 && pm.test_gamma_scale16 == 0 &&
+      pm.test_gamma_background == 0 && pm.test_gamma_alpha_mode == 0)
+   {
+      pm.test_gamma_threshold = 1;
+      pm.test_gamma_transform = 1;
+      pm.test_gamma_sbit = 1;
+      pm.test_gamma_scale16 = 1;
+      pm.test_gamma_background = 1;
+      pm.test_gamma_alpha_mode = 1;
+   }
+
+   else if (pm.ngamma_tests == 0)
+   {
+      /* Nothing to test so turn everything off: */
+      pm.test_gamma_threshold = 0;
+      pm.test_gamma_transform = 0;
+      pm.test_gamma_sbit = 0;
+      pm.test_gamma_scale16 = 0;
+      pm.test_gamma_background = 0;
+      pm.test_gamma_alpha_mode = 0;
+   }
+
+   Try
+   {
+      /* Make useful base images */
+      make_transform_images(&pm);
+
+      /* Perform the standard and gamma tests. */
+      if (pm.test_standard)
+      {
+         perform_interlace_macro_validation();
+         perform_formatting_test(&pm.this);
+#        ifdef PNG_READ_SUPPORTED
+            perform_standard_test(&pm);
+#        endif
+         perform_error_test(&pm);
+      }
+
+      /* Various oddly sized images: */
+      if (pm.test_size)
+      {
+         make_size_images(&pm.this);
+#        ifdef PNG_READ_SUPPORTED
+            perform_size_test(&pm);
+#        endif
+      }
+
+#ifdef PNG_READ_TRANSFORMS_SUPPORTED
+      /* Combinatorial transforms: */
+      if (pm.test_transform)
+         perform_transform_test(&pm);
+#endif /* PNG_READ_TRANSFORMS_SUPPORTED */
+
+#ifdef PNG_READ_GAMMA_SUPPORTED
+      if (pm.ngamma_tests > 0)
+         perform_gamma_test(&pm, summary);
+#endif
+   }
+
+   Catch_anonymous
+   {
+      fprintf(stderr, "pngvalid: test aborted (probably failed in cleanup)\n");
+      if (!pm.this.verbose)
+      {
+         if (pm.this.error[0] != 0)
+            fprintf(stderr, "pngvalid: first error: %s\n", pm.this.error);
+
+         fprintf(stderr, "pngvalid: run with -v to see what happened\n");
+      }
+      exit(1);
+   }
+
+   if (summary)
+   {
+      printf("%s: %s (%s point arithmetic)\n",
+         (pm.this.nerrors || (pm.this.treat_warnings_as_errors &&
+            pm.this.nwarnings)) ? "FAIL" : "PASS",
+         command,
+#if defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) || PNG_LIBPNG_VER < 10500
+         "floating"
+#else
+         "fixed"
+#endif
+         );
+   }
+
+   if (memstats)
+   {
+      printf("Allocated memory statistics (in bytes):\n"
+         "\tread  %lu maximum single, %lu peak, %lu total\n"
+         "\twrite %lu maximum single, %lu peak, %lu total\n",
+         (unsigned long)pm.this.read_memory_pool.max_max,
+         (unsigned long)pm.this.read_memory_pool.max_limit,
+         (unsigned long)pm.this.read_memory_pool.max_total,
+         (unsigned long)pm.this.write_memory_pool.max_max,
+         (unsigned long)pm.this.write_memory_pool.max_limit,
+         (unsigned long)pm.this.write_memory_pool.max_total);
+   }
+
+   /* Do this here to provoke memory corruption errors in memory not directly
+    * allocated by libpng - not a complete test, but better than nothing.
+    */
+   store_delete(&pm.this);
+
+   /* Error exit if there are any errors, and maybe if there are any
+    * warnings.
+    */
+   if (pm.this.nerrors || (pm.this.treat_warnings_as_errors &&
+       pm.this.nwarnings))
+   {
+      if (!pm.this.verbose)
+         fprintf(stderr, "pngvalid: %s\n", pm.this.error);
+
+      fprintf(stderr, "pngvalid: %d errors, %d warnings\n", pm.this.nerrors,
+          pm.this.nwarnings);
+
+      exit(1);
+   }
+
+   /* Success case. */
+   if (touch != NULL)
+   {
+      FILE *fsuccess = fopen(touch, "wt");
+
+      if (fsuccess != NULL)
+      {
+         int error = 0;
+         fprintf(fsuccess, "PNG validation succeeded\n");
+         fflush(fsuccess);
+         error = ferror(fsuccess);
+
+         if (fclose(fsuccess) || error)
+         {
+            fprintf(stderr, "%s: write failed\n", touch);
+            exit(1);
+         }
+      }
+
+      else
+      {
+         fprintf(stderr, "%s: open failed\n", touch);
+         exit(1);
+      }
+   }
+
+   /* This is required because some very minimal configurations do not use it:
+    */
+   UNUSED(fail)
+   return 0;
+}
+#else /* write or low level APIs not supported */
+int main(void)
+{
+   fprintf(stderr,
+      "pngvalid: no low level write support in libpng, all tests skipped\n");
+   /* So the test is skipped: */
+   return SKIP;
+}
+#endif
diff --git a/Engine/lib/lpng/contrib/libtests/readpng.c b/Engine/lib/lpng/contrib/libtests/readpng.c
new file mode 100644
index 000000000..60a2d46c5
--- /dev/null
+++ b/Engine/lib/lpng/contrib/libtests/readpng.c
@@ -0,0 +1,115 @@
+/* readpng.c
+ *
+ * Copyright (c) 2013 John Cunningham Bowler
+ *
+ * Last changed in libpng 1.6.1 [March 28, 2013]
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * Load an arbitrary number of PNG files (from the command line, or, if there
+ * are no arguments on the command line, from stdin) then run a time test by
+ * reading each file by row.  The test does nothing with the read result and
+ * does no transforms.  The only output is a time as a floating point number of
+ * seconds with 9 decimal digits.
+ */
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#if defined(HAVE_CONFIG_H) && !defined(PNG_NO_CONFIG_H)
+#  include <config.h>
+#endif
+
+/* Define the following to use this test against your installed libpng, rather
+ * than the one being built here:
+ */
+#ifdef PNG_FREESTANDING_TESTS
+#  include <png.h>
+#else
+#  include "../../png.h"
+#endif
+
+static int
+read_png(FILE *fp)
+{
+   png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,0,0,0);
+   png_infop info_ptr = NULL;
+   png_bytep row = NULL, display = NULL;
+
+   if (png_ptr == NULL)
+      return 0;
+
+   if (setjmp(png_jmpbuf(png_ptr)))
+   {
+      png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+      if (row != NULL) free(row);
+      if (display != NULL) free(display);
+      return 0;
+   }
+
+   png_init_io(png_ptr, fp);
+
+   info_ptr = png_create_info_struct(png_ptr);
+   if (info_ptr == NULL)
+      png_error(png_ptr, "OOM allocating info structure");
+
+   png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_ALWAYS, NULL, 0);
+
+   png_read_info(png_ptr, info_ptr);
+
+   {
+      size_t rowbytes = png_get_rowbytes(png_ptr, info_ptr);
+
+      /* Failure to initialize these is harmless */
+      row = malloc(rowbytes);
+      display = malloc(rowbytes);
+
+      if (row == NULL || display == NULL)
+         png_error(png_ptr, "OOM allocating row buffers");
+
+      {
+         png_uint_32 height = png_get_image_height(png_ptr, info_ptr);
+#        ifdef PNG_READ_INTERLACING_SUPPORTED
+            int passes = png_set_interlace_handling(png_ptr);
+#        else /* !READ_INTERLACING */
+            int passes = png_get_interlace_type(png_ptr, info_ptr) ==
+               PNG_INTERLACE_ADAM7 ? PNG_INTERLACE_ADAM7_PASSES : 1;
+#        endif /* !READ_INTERLACING */
+         int pass;
+
+         png_start_read_image(png_ptr);
+
+         for (pass = 0; pass < passes; ++pass)
+         {
+            png_uint_32 y = height;
+
+#           ifndef PNG_READ_INTERLACING_SUPPORTED
+               if (passes == PNG_INTERLACE_ADAM7_PASSES)
+                  y = PNG_PASS_ROWS(y, pass);
+#           endif /* READ_INTERLACING */
+
+            /* NOTE: this trashes the row each time; interlace handling won't
+             * work, but this avoids memory thrashing for speed testing.
+             */
+            while (y-- > 0)
+               png_read_row(png_ptr, row, display);
+         }
+      }
+   }
+
+   /* Make sure to read to the end of the file: */
+   png_read_end(png_ptr, info_ptr);
+   png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+   free(row);
+   free(display);
+   return 1;
+}
+
+int
+main(void)
+{
+   /* Exit code 0 on success. */
+   return !read_png(stdin);
+}
diff --git a/Engine/lib/lpng/contrib/libtests/tarith.c b/Engine/lib/lpng/contrib/libtests/tarith.c
new file mode 100644
index 000000000..c03f05a80
--- /dev/null
+++ b/Engine/lib/lpng/contrib/libtests/tarith.c
@@ -0,0 +1,999 @@
+
+/* tarith.c
+ *
+ * Copyright (c) 2011-2013 John Cunningham Bowler
+ *
+ * Last changed in libpng 1.6.0 [February 14, 2013]
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * Test internal arithmetic functions of libpng.
+ *
+ * This code must be linked against a math library (-lm), but does not require
+ * libpng or zlib to work.  Because it includes the complete source of 'png.c'
+ * it tests the code with whatever compiler options are used to build it.
+ * Changing these options can substantially change the errors in the
+ * calculations that the compiler chooses!
+ */
+#define _POSIX_SOURCE 1
+#define _ISOC99_SOURCE 1
+
+/* Obtain a copy of the code to be tested (plus other things), disabling
+ * stuff that is not required.
+ */
+#include <math.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+#include <assert.h>
+
+#include "../../pngpriv.h"
+
+#define png_error png_warning
+
+void png_warning(png_const_structrp png_ptr, png_const_charp msg)
+{
+   fprintf(stderr, "validation: %s\n", msg);
+}
+
+#define png_fixed_error png_fixed_warning
+
+void png_fixed_warning(png_const_structrp png_ptr, png_const_charp msg)
+{
+   fprintf(stderr, "overflow in: %s\n", msg);
+}
+
+#define png_set_error_fn(pp, ep, efp, wfp) ((void)0)
+#define png_malloc(pp, s) malloc(s)
+#define png_malloc_warn(pp, s) malloc(s)
+#define png_malloc_base(pp, s) malloc(s)
+#define png_calloc(pp, s) calloc(1, (s))
+#define png_free(pp, s) free(s)
+
+#define png_safecat(b, sb, pos, str) (pos)
+#define png_format_number(start, end, format, number) (start)
+
+#define crc32(crc, pp, s) (crc)
+#define inflateReset(zs) Z_OK
+
+#define png_create_struct(type) (0)
+#define png_destroy_struct(pp) ((void)0)
+#define png_create_struct_2(type, m, mm) (0)
+#define png_destroy_struct_2(pp, f, mm) ((void)0)
+
+#undef PNG_SIMPLIFIED_READ_SUPPORTED
+#undef PNG_SIMPLIFIED_WRITE_SUPPORTED
+#undef PNG_USER_MEM_SUPPORTED
+
+#include "../../png.c"
+
+/* Validate ASCII to fp routines. */
+static int verbose = 0;
+
+int validation_ascii_to_fp(int count, int argc, char **argv)
+{
+   int    showall = 0;
+   double max_error=2;      /* As a percentage error-in-last-digit/.5 */
+   double max_error_abs=17; /* Used when precision is DBL_DIG */
+   double max = 0;
+   double max_abs = 0;
+   double test = 0; /* Important to test this. */
+   int    precision = 5;
+   int    nonfinite = 0;
+   int    finite = 0;
+   int    ok = 0;
+   int    failcount = 0;
+   int    minorarith = 0;
+
+   while (--argc > 0)
+      if (strcmp(*++argv, "-a") == 0)
+         showall = 1;
+      else if (strcmp(*argv, "-e") == 0 && argc > 0)
+      {
+         --argc;
+         max_error = atof(*++argv);
+      }
+      else if (strcmp(*argv, "-E") == 0 && argc > 0)
+      {
+         --argc;
+         max_error_abs = atof(*++argv);
+      }
+      else
+      {
+         fprintf(stderr, "unknown argument %s\n", *argv);
+         return 1;
+      }
+
+   do
+   {
+      size_t index;
+      int state, failed = 0;
+      char buffer[64];
+
+      if (isfinite(test))
+         ++finite;
+      else
+         ++nonfinite;
+
+      if (verbose)
+         fprintf(stderr, "%.*g %d\n", DBL_DIG, test, precision);
+
+      /* Check for overflow in the buffer by setting a marker. */
+      memset(buffer, 71, sizeof buffer);
+
+      png_ascii_from_fp(0, buffer, precision+10, test, precision);
+
+      /* Allow for a three digit exponent, this stuff will fail if
+       * the exponent is bigger than this!
+       */
+      if (buffer[precision+7] != 71)
+      {
+         fprintf(stderr, "%g[%d] -> '%s'[%lu] buffer overflow\n", test,
+            precision, buffer, (unsigned long)strlen(buffer));
+         failed = 1;
+      }
+
+      /* Following are used for the number parser below and must be
+       * initialized to zero.
+       */
+      state = 0;
+      index = 0;
+      if (!isfinite(test))
+      {
+         /* Expect 'inf' */
+         if (test >= 0 && strcmp(buffer, "inf") ||
+             test <  0 && strcmp(buffer, "-inf"))
+         {
+            fprintf(stderr, "%g[%d] -> '%s' but expected 'inf'\n", test,
+               precision, buffer);
+            failed = 1;
+         }
+      }
+      else if (!png_check_fp_number(buffer, precision+10, &state, &index) ||
+          buffer[index] != 0)
+      {
+         fprintf(stderr, "%g[%d] -> '%s' but has bad format ('%c')\n", test,
+         precision, buffer, buffer[index]);
+         failed = 1;
+      }
+      else if (PNG_FP_IS_NEGATIVE(state) && !(test < 0))
+      {
+         fprintf(stderr, "%g[%d] -> '%s' but negative value not so reported\n",
+            test, precision, buffer);
+         failed = 1;
+         assert(!PNG_FP_IS_ZERO(state));
+         assert(!PNG_FP_IS_POSITIVE(state));
+      }
+      else if (PNG_FP_IS_ZERO(state) && !(test == 0))
+      {
+         fprintf(stderr, "%g[%d] -> '%s' but zero value not so reported\n",
+            test, precision, buffer);
+         failed = 1;
+         assert(!PNG_FP_IS_NEGATIVE(state));
+         assert(!PNG_FP_IS_POSITIVE(state));
+      }
+      else if (PNG_FP_IS_POSITIVE(state) && !(test > 0))
+      {
+         fprintf(stderr, "%g[%d] -> '%s' but positive value not so reported\n",
+            test, precision, buffer);
+         failed = 1;
+         assert(!PNG_FP_IS_NEGATIVE(state));
+         assert(!PNG_FP_IS_ZERO(state));
+      }
+      else
+      {
+         /* Check the result against the original. */
+         double out = atof(buffer);
+         double change = fabs((out - test)/test);
+         double allow = .5/pow(10,
+            (precision >= DBL_DIG) ? DBL_DIG-1 : precision-1);
+
+         /* NOTE: if you hit this error case are you compiling with gcc
+          * and -O0?  Try -O2 - the errors can accumulate if the FP
+          * code above is not optimized and may drift outside the .5 in
+          * DBL_DIG allowed.  In any case a small number of errors may
+          * occur (very small ones - 1 or 2%) because of rounding in the
+          * calculations, either in the conversion API or in atof.
+          */
+         if (change >= allow && (isfinite(out) ||
+             fabs(test/DBL_MAX) <= 1-allow))
+         {
+            double percent = (precision >= DBL_DIG) ? max_error_abs : max_error;
+            double allowp = (change-allow)*100/allow;
+
+            if (precision >= DBL_DIG)
+            {
+               if (max_abs < allowp) max_abs = allowp;
+            }
+
+            else
+            {
+               if (max < allowp) max = allowp;
+            }
+
+            if (showall || allowp >= percent)
+            {
+               fprintf(stderr,
+                  "%.*g[%d] -> '%s' -> %.*g number changed (%g > %g (%d%%))\n",
+                  DBL_DIG, test, precision, buffer, DBL_DIG, out, change, allow,
+                  (int)round(allowp));
+               failed = 1;
+            }
+            else
+               ++minorarith;
+         }
+      }
+
+      if (failed)
+         ++failcount;
+      else
+         ++ok;
+
+skip:
+      /* Generate a new number and precision. */
+      precision = rand();
+      if (precision & 1) test = -test;
+      precision >>= 1;
+
+      /* Generate random numbers. */
+      if (test == 0 || !isfinite(test))
+         test = precision+1;
+      else
+      {
+         /* Derive the exponent from the previous rand() value. */
+         int exponent = precision % (DBL_MAX_EXP - DBL_MIN_EXP) + DBL_MIN_EXP;
+         int tmp;
+         test = frexp(test * rand(), &tmp);
+         test = ldexp(test, exponent);
+         precision >>= 8; /* arbitrary */
+      }
+
+      /* This limits the precision to 32 digits, enough for standard
+       * IEEE implementations which have at most 15 digits.
+       */
+      precision = (precision & 0x1f) + 1;
+   }
+   while (--count);
+
+   printf("Tested %d finite values, %d non-finite, %d OK (%d failed) %d minor "
+      "arithmetic errors\n", finite, nonfinite, ok, failcount, minorarith);
+   printf(" Error with >=%d digit precision %.2f%%\n", DBL_DIG, max_abs);
+   printf(" Error with < %d digit precision %.2f%%\n", DBL_DIG, max);
+
+   return 0;
+}
+
+/* Observe that valid FP numbers have the forms listed in the PNG extensions
+ * specification:
+ *
+ * [+,-]{integer,integer.fraction,.fraction}[{e,E}[+,-]integer]
+ *
+ * Test each of these in turn, including invalid cases.
+ */
+typedef enum checkfp_state
+{
+   start, fraction, exponent, states
+} checkfp_state;
+
+/* The characters (other than digits) that characterize the states: */
+static const char none[] = "";
+static const char hexdigits[16] = "0123456789ABCDEF";
+
+static const struct
+{
+   const char *start; /* Characters valid at the start */
+   const char *end;   /* Valid characters that end the state */
+   const char *tests; /* Characters to test after 2 digits seen */
+}
+state_characters[states] =
+{
+   /* start:    */ { "+-.", ".eE", "+-.e*0369" },
+   /* fraction: */ { none, "eE",  "+-.E#0147" },
+   /* exponent: */ { "+-", none,  "+-.eE^0258" }
+};
+
+typedef struct
+{
+   char number[1024];  /* Buffer for number being tested */
+   int  limit;         /* Command line limit */
+   int  verbose;       /* Shadows global variable */
+   int  ctimes;        /* Number of numbers tested */
+   int  cmillions;     /* Count of millions of numbers */
+   int  cinvalid;      /* Invalid strings checked */
+   int  cnoaccept;     /* Characters not accepted */
+}
+checkfp_command;
+
+typedef struct
+{
+   int           cnumber;          /* Index into number string */
+   checkfp_state check_state;      /* Current number state */
+   int           at_start;         /* At start (first character) of state */
+   int           cdigits_in_state; /* Digits seen in that state */
+   int           limit;            /* Limit on same for checking all chars */
+   int           state;            /* Current parser state */
+   int           is_negative;      /* Number is negative */
+   int           is_zero;          /* Number is (still) zero */
+   int           number_was_valid; /* Previous character validity */
+}
+checkfp_control;
+
+static int check_all_characters(checkfp_command *co, checkfp_control c);
+
+static int check_some_characters(checkfp_command *co, checkfp_control c,
+   const char *tests);
+
+static int check_one_character(checkfp_command *co, checkfp_control c, int ch)
+{
+   /* Test this character (ch) to ensure the parser does the correct thing.
+    */
+   size_t index = 0;
+   const char test = (char)ch;
+   int number_is_valid = png_check_fp_number(&test, 1, &c.state, &index);
+   int character_accepted = (index == 1);
+
+   if (c.check_state != exponent && isdigit(ch) && ch != '0')
+      c.is_zero = 0;
+
+   if (c.check_state == start && c.at_start && ch == '-')
+      c.is_negative = 1;
+
+   if (isprint(ch))
+      co->number[c.cnumber++] = (char)ch;
+   else
+   {
+      co->number[c.cnumber++] = '<';
+      co->number[c.cnumber++] = hexdigits[(ch >> 4) & 0xf];
+      co->number[c.cnumber++] = hexdigits[ch & 0xf];
+      co->number[c.cnumber++] = '>';
+   }
+   co->number[c.cnumber] = 0;
+
+   if (co->verbose > 1)
+      fprintf(stderr, "%s\n", co->number);
+
+   if (++(co->ctimes) == 1000000)
+   {
+      if (co->verbose == 1)
+         fputc('.', stderr);
+      co->ctimes = 0;
+      ++(co->cmillions);
+   }
+
+   if (!number_is_valid)
+      ++(co->cinvalid);
+
+   if (!character_accepted)
+      ++(co->cnoaccept);
+
+   /* This should never fail (it's a serious bug if it does): */
+   if (index != 0 && index != 1)
+   {
+      fprintf(stderr, "%s: read beyond end of string (%lu)\n", co->number,
+         (unsigned long)index);
+      return 0;
+   }
+
+   /* Validate the new state, note that the PNG_FP_IS_ macros all return
+    * false unless the number is valid.
+    */
+   if (PNG_FP_IS_NEGATIVE(c.state) !=
+      (number_is_valid && !c.is_zero && c.is_negative))
+   {
+      fprintf(stderr, "%s: negative when it is not\n", co->number);
+      return 0;
+   }
+
+   if (PNG_FP_IS_ZERO(c.state) != (number_is_valid && c.is_zero))
+   {
+      fprintf(stderr, "%s: zero when it is not\n", co->number);
+      return 0;
+   }
+
+   if (PNG_FP_IS_POSITIVE(c.state) !=
+      (number_is_valid && !c.is_zero && !c.is_negative))
+   {
+      fprintf(stderr, "%s: positive when it is not\n", co->number);
+      return 0;
+   }
+
+   /* Testing a digit */
+   if (isdigit(ch))
+   {
+      if (!character_accepted)
+      {
+         fprintf(stderr, "%s: digit '%c' not accepted\n", co->number, ch);
+         return 0;
+      }
+
+      if (!number_is_valid)
+      {
+         fprintf(stderr, "%s: saw a digit (%c) but number not valid\n",
+            co->number, ch);
+         return 0;
+      }
+
+      ++c.cdigits_in_state;
+      c.at_start = 0;
+      c.number_was_valid = 1;
+
+      /* Continue testing characters in this state.  Either test all of
+       * them or, if we have already seen one digit in this state, just test a
+       * limited set.
+       */
+      if (c.cdigits_in_state < 1)
+         return check_all_characters(co, c);
+
+      else
+         return check_some_characters(co, c,
+            state_characters[c.check_state].tests);
+   }
+
+   /* A non-digit; is it allowed here? */
+   else if (((ch == '+' || ch == '-') && c.check_state != fraction &&
+               c.at_start) ||
+            (ch == '.' && c.check_state == start) ||
+            ((ch == 'e' || ch == 'E') && c.number_was_valid &&
+               c.check_state != exponent))
+   {
+      if (!character_accepted)
+      {
+         fprintf(stderr, "%s: character '%c' not accepted\n", co->number, ch);
+         return 0;
+      }
+
+      /* The number remains valid after start of fraction but nowhere else. */
+      if (number_is_valid && (c.check_state != start || ch != '.'))
+      {
+         fprintf(stderr, "%s: saw a non-digit (%c) but number valid\n",
+            co->number, ch);
+         return 0;
+      }
+
+      c.number_was_valid = number_is_valid;
+
+      /* Check for a state change.  When changing to 'fraction' if the number
+       * is valid at this point set the at_start to false to allow an exponent
+       * 'e' to come next.
+       */
+      if (c.check_state == start && ch == '.')
+      {
+         c.check_state = fraction;
+         c.at_start = !number_is_valid;
+         c.cdigits_in_state = 0;
+         c.limit = co->limit;
+         return check_all_characters(co, c);
+      }
+
+      else if (c.check_state < exponent && (ch == 'e' || ch == 'E'))
+      {
+         c.check_state = exponent;
+         c.at_start = 1;
+         c.cdigits_in_state = 0;
+         c.limit = co->limit;
+         return check_all_characters(co, c);
+      }
+
+      /* Else it was a sign, and the state doesn't change. */
+      else
+      {
+         if (ch != '-' && ch != '+')
+         {
+            fprintf(stderr, "checkfp: internal error (1)\n");
+            return 0;
+         }
+
+         c.at_start = 0;
+         return check_all_characters(co, c);
+      }
+   }
+
+   /* Testing an invalid character */
+   else
+   {
+      if (character_accepted)
+      {
+         fprintf(stderr, "%s: character '%c' [0x%.2x] accepted\n", co->number,
+            ch, ch);
+         return 0;
+      }
+
+      if (number_is_valid != c.number_was_valid)
+      {
+         fprintf(stderr,
+            "%s: character '%c' [0x%.2x] changed number validity\n", co->number,
+            ch, ch);
+         return 0;
+      }
+
+      /* Do nothing - the parser has stuck; return success and keep going with
+       * the next character.
+       */
+   }
+
+   /* Successful return (the caller will try the next character.) */
+   return 1;
+}
+
+static int check_all_characters(checkfp_command *co, checkfp_control c)
+{
+   int ch;
+
+   if (c.cnumber+4 < sizeof co->number) for (ch=0; ch<256; ++ch)
+   {
+      if (!check_one_character(co, c, ch))
+         return 0;
+   }
+
+   return 1;
+}
+
+static int check_some_characters(checkfp_command *co, checkfp_control c,
+   const char *tests)
+{
+   int i;
+
+   --(c.limit);
+
+   if (c.cnumber+4 < sizeof co->number && c.limit >= 0)
+   {
+      if (c.limit > 0) for (i=0; tests[i]; ++i)
+      {
+         if (!check_one_character(co, c, tests[i]))
+               return 0;
+      }
+
+      /* At the end check all the characters. */
+      else
+         return check_all_characters(co, c);
+   }
+
+   return 1;
+}
+
+int validation_checkfp(int count, int argc, char **argv)
+{
+   int result;
+   checkfp_command command;
+   checkfp_control control;
+
+   command.number[0] = 0;
+   command.limit = 3;
+   command.verbose = verbose;
+   command.ctimes = 0;
+   command.cmillions = 0;
+   command.cinvalid = 0;
+   command.cnoaccept = 0;
+
+   while (--argc > 0)
+   {
+      ++argv;
+      if (argc > 1 && strcmp(*argv, "-l") == 0)
+      {
+         --argc;
+         command.limit = atoi(*++argv);
+      }
+
+      else
+      {
+         fprintf(stderr, "unknown argument %s\n", *argv);
+         return 1;
+      }
+   }
+
+   control.cnumber = 0;
+   control.check_state = start;
+   control.at_start = 1;
+   control.cdigits_in_state = 0;
+   control.limit = command.limit;
+   control.state = 0;
+   control.is_negative = 0;
+   control.is_zero = 1;
+   control.number_was_valid = 0;
+
+   result = check_all_characters(&command, control);
+
+   printf("checkfp: %s: checked %d,%.3d,%.3d,%.3d strings (%d invalid)\n",
+      result ? "pass" : "FAIL", command.cmillions / 1000,
+      command.cmillions % 1000, command.ctimes / 1000, command.ctimes % 1000,
+      command.cinvalid);
+
+   return result;
+}
+
+int validation_muldiv(int count, int argc, char **argv)
+{
+   int tested = 0;
+   int overflow = 0;
+   int error = 0;
+   int error64 = 0;
+   int passed = 0;
+   int randbits = 0;
+   png_uint_32 randbuffer;
+   png_fixed_point a;
+   png_int_32 times, div;
+
+   while (--argc > 0)
+      {
+         fprintf(stderr, "unknown argument %s\n", *++argv);
+         return 1;
+      }
+
+   /* Find out about the random number generator. */
+   randbuffer = RAND_MAX;
+   while (randbuffer != 0) ++randbits, randbuffer >>= 1;
+   printf("Using random number generator that makes %d bits\n", randbits);
+   for (div=0; div<32; div += randbits)
+      randbuffer = (randbuffer << randbits) ^ rand();
+
+   a = 0;
+   times = div = 0;
+   do
+   {
+      png_fixed_point result;
+      /* NOTE: your mileage may vary, a type is required below that can
+       * hold 64 bits or more, if floating point is used a 64-bit or
+       * better mantissa is required.
+       */
+      long long int fp, fpround;
+      unsigned long hi, lo;
+      int ok;
+
+      /* Check the values, png_64bit_product can only handle positive
+       * numbers, so correct for that here.
+       */
+      {
+         long u1, u2;
+         int n = 0;
+         if (a < 0) u1 = -a, n = 1; else u1 = a;
+         if (times < 0) u2 = -times, n = !n; else u2 = times;
+         png_64bit_product(u1, u2, &hi, &lo);
+         if (n)
+         {
+            /* -x = ~x+1 */
+            lo = ((~lo) + 1) & 0xffffffff;
+            hi = ~hi;
+            if (lo == 0) ++hi;
+         }
+      }
+
+      fp = a;
+      fp *= times;
+      if ((fp & 0xffffffff) != lo || ((fp >> 32) & 0xffffffff) != hi)
+      {
+         fprintf(stderr, "png_64bit_product %d * %d -> %lx|%.8lx not %llx\n",
+            a, times, hi, lo, fp);
+         ++error64;
+      }
+
+      if (div != 0)
+      {
+         /* Round - this is C round to zero. */
+         if ((fp < 0) != (div < 0))
+           fp -= div/2;
+         else
+           fp += div/2;
+
+         fp /= div;
+         fpround = fp;
+         /* Assume 2's complement here: */
+         ok = fpround <= PNG_UINT_31_MAX &&
+              fpround >= -1-(long long int)PNG_UINT_31_MAX;
+         if (!ok) ++overflow;
+      }
+      else
+        ok = 0, ++overflow, fpround = fp/*misleading*/;
+
+      if (verbose)
+         fprintf(stderr, "TEST %d * %d / %d -> %lld (%s)\n", a, times, div,
+            fp, ok ? "ok" : "overflow");
+
+      ++tested;
+      if (png_muldiv(&result, a, times, div) != ok)
+      {
+         ++error;
+         if (ok)
+             fprintf(stderr, "%d * %d / %d -> overflow (expected %lld)\n", a,
+                times, div, fp);
+         else
+             fprintf(stderr, "%d * %d / %d -> %d (expected overflow %lld)\n", a,
+                times, div, result, fp);
+      }
+      else if (ok && result != fpround)
+      {
+         ++error;
+         fprintf(stderr, "%d * %d / %d -> %d not %lld\n", a, times, div, result,
+            fp);
+      }
+      else
+         ++passed;
+
+      /* Generate three new values, this uses rand() and rand() only returns
+       * up to RAND_MAX.
+       */
+      /* CRUDE */
+      a += times;
+      times += div;
+      div = randbuffer;
+      randbuffer = (randbuffer << randbits) ^ rand();
+   }
+   while (--count > 0);
+
+   printf("%d tests including %d overflows, %d passed, %d failed (%d 64-bit "
+      "errors)\n", tested, overflow, passed, error, error64);
+   return 0;
+}
+
+/* When FP is on this just becomes a speed test - compile without FP to get real
+ * validation.
+ */
+#ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
+#define LN2 .000010576586617430806112933839 /* log(2)/65536 */
+#define L2INV 94548.46219969910586572651    /* 65536/log(2) */
+
+/* For speed testing, need the internal functions too: */
+static png_uint_32 png_log8bit(unsigned x)
+{
+   if (x > 0)
+      return (png_uint_32)floor(.5-log(x/255.)*L2INV);
+
+   return 0xffffffff;
+}
+
+static png_uint_32 png_log16bit(png_uint_32 x)
+{
+   if (x > 0)
+      return (png_uint_32)floor(.5-log(x/65535.)*L2INV);
+
+   return 0xffffffff;
+}
+
+static png_uint_32 png_exp(png_uint_32 x)
+{
+   return (png_uint_32)floor(.5 + exp(x * -LN2) * 0xffffffffU);
+}
+
+static png_byte png_exp8bit(png_uint_32 log)
+{
+   return (png_byte)floor(.5 + exp(log * -LN2) * 255);
+}
+
+static png_uint_16 png_exp16bit(png_uint_32 log)
+{
+   return (png_uint_16)floor(.5 + exp(log * -LN2) * 65535);
+}
+#endif /* FLOATING_ARITHMETIC */
+
+int validation_gamma(int argc, char **argv)
+{
+   double gamma[9] = { 2.2, 1.8, 1.52, 1.45, 1., 1/1.45, 1/1.52, 1/1.8, 1/2.2 };
+   double maxerr;
+   int i, silent=0, onlygamma=0;
+
+   /* Silence the output with -s, just test the gamma functions with -g: */
+   while (--argc > 0)
+      if (strcmp(*++argv, "-s") == 0)
+         silent = 1;
+      else if (strcmp(*argv, "-g") == 0)
+         onlygamma = 1;
+      else
+      {
+         fprintf(stderr, "unknown argument %s\n", *argv);
+         return 1;
+      }
+
+   if (!onlygamma)
+   {
+      /* First validate the log functions: */
+      maxerr = 0;
+      for (i=0; i<256; ++i)
+      {
+         double correct = -log(i/255.)/log(2.)*65536;
+         double error = png_log8bit(i) - correct;
+
+         if (i != 0 && fabs(error) > maxerr)
+            maxerr = fabs(error);
+
+         if (i == 0 && png_log8bit(i) != 0xffffffff ||
+             i != 0 && png_log8bit(i) != floor(correct+.5))
+         {
+            fprintf(stderr, "8-bit log error: %d: got %u, expected %f\n",
+               i, png_log8bit(i), correct);
+         }
+      }
+
+      if (!silent)
+         printf("maximum 8-bit log error = %f\n", maxerr);
+
+      maxerr = 0;
+      for (i=0; i<65536; ++i)
+      {
+         double correct = -log(i/65535.)/log(2.)*65536;
+         double error = png_log16bit(i) - correct;
+
+         if (i != 0 && fabs(error) > maxerr)
+            maxerr = fabs(error);
+
+         if (i == 0 && png_log16bit(i) != 0xffffffff ||
+             i != 0 && png_log16bit(i) != floor(correct+.5))
+         {
+            if (error > .68) /* By experiment error is less than .68 */
+            {
+               fprintf(stderr, "16-bit log error: %d: got %u, expected %f"
+                  " error: %f\n", i, png_log16bit(i), correct, error);
+            }
+         }
+      }
+
+      if (!silent)
+         printf("maximum 16-bit log error = %f\n", maxerr);
+
+      /* Now exponentiations. */
+      maxerr = 0;
+      for (i=0; i<=0xfffff; ++i)
+      {
+         double correct = exp(-i/65536. * log(2.)) * (65536. * 65536);
+         double error = png_exp(i) - correct;
+
+         if (fabs(error) > maxerr)
+            maxerr = fabs(error);
+         if (fabs(error) > 1883) /* By experiment. */
+         {
+            fprintf(stderr, "32-bit exp error: %d: got %u, expected %f"
+                  " error: %f\n", i, png_exp(i), correct, error);
+         }
+      }
+
+      if (!silent)
+         printf("maximum 32-bit exp error = %f\n", maxerr);
+
+      maxerr = 0;
+      for (i=0; i<=0xfffff; ++i)
+      {
+         double correct = exp(-i/65536. * log(2.)) * 255;
+         double error = png_exp8bit(i) - correct;
+
+         if (fabs(error) > maxerr)
+            maxerr = fabs(error);
+         if (fabs(error) > .50002) /* By experiment */
+         {
+            fprintf(stderr, "8-bit exp error: %d: got %u, expected %f"
+                  " error: %f\n", i, png_exp8bit(i), correct, error);
+         }
+      }
+
+      if (!silent)
+         printf("maximum 8-bit exp error = %f\n", maxerr);
+
+      maxerr = 0;
+      for (i=0; i<=0xfffff; ++i)
+      {
+         double correct = exp(-i/65536. * log(2.)) * 65535;
+         double error = png_exp16bit(i) - correct;
+
+         if (fabs(error) > maxerr)
+            maxerr = fabs(error);
+         if (fabs(error) > .524) /* By experiment */
+         {
+            fprintf(stderr, "16-bit exp error: %d: got %u, expected %f"
+                  " error: %f\n", i, png_exp16bit(i), correct, error);
+         }
+      }
+
+      if (!silent)
+         printf("maximum 16-bit exp error = %f\n", maxerr);
+   } /* !onlygamma */
+
+   /* Test the overall gamma correction. */
+   for (i=0; i<9; ++i)
+   {
+      unsigned j;
+      double g = gamma[i];
+      png_fixed_point gfp = floor(g * PNG_FP_1 + .5);
+
+      if (!silent)
+         printf("Test gamma %f\n", g);
+
+      maxerr = 0;
+      for (j=0; j<256; ++j)
+      {
+         double correct = pow(j/255., g) * 255;
+         png_byte out = png_gamma_8bit_correct(j, gfp);
+         double error = out - correct;
+
+         if (fabs(error) > maxerr)
+            maxerr = fabs(error);
+         if (out != floor(correct+.5))
+         {
+            fprintf(stderr, "8bit %d ^ %f: got %d expected %f error %f\n",
+               j, g, out, correct, error);
+         }
+      }
+
+      if (!silent)
+         printf("gamma %f: maximum 8-bit error %f\n", g, maxerr);
+
+      maxerr = 0;
+      for (j=0; j<65536; ++j)
+      {
+         double correct = pow(j/65535., g) * 65535;
+         png_uint_16 out = png_gamma_16bit_correct(j, gfp);
+         double error = out - correct;
+
+         if (fabs(error) > maxerr)
+            maxerr = fabs(error);
+         if (fabs(error) > 1.62)
+         {
+            fprintf(stderr, "16bit %d ^ %f: got %d expected %f error %f\n",
+               j, g, out, correct, error);
+         }
+      }
+
+      if (!silent)
+         printf("gamma %f: maximum 16-bit error %f\n", g, maxerr);
+   }
+
+   return 0;
+}
+
+/**************************** VALIDATION TESTS ********************************/
+/* Various validation routines are included herein, they require some
+ * definition for png_warning and png_error, seetings of VALIDATION:
+ *
+ * 1: validates the ASCII to floating point conversions
+ * 2: validates png_muldiv
+ * 3: accuracy test of fixed point gamma tables
+ */
+
+/* The following COUNT (10^8) takes about 1 hour on a 1GHz Pentium IV
+ * processor.
+ */
+#define COUNT 1000000000
+
+int main(int argc, char **argv)
+{
+   int count = COUNT;
+
+   while (argc > 1)
+   {
+      if (argc > 2 && strcmp(argv[1], "-c") == 0)
+      {
+         count = atoi(argv[2]);
+         argc -= 2;
+         argv += 2;
+      }
+
+      else if (strcmp(argv[1], "-v") == 0)
+      {
+         ++verbose;
+         --argc;
+         ++argv;
+      }
+
+      else
+         break;
+   }
+
+   if (count > 0 && argc > 1)
+   {
+      if (strcmp(argv[1], "ascii") == 0)
+         return validation_ascii_to_fp(count, argc-1, argv+1);
+      else if (strcmp(argv[1], "checkfp") == 0)
+         return validation_checkfp(count, argc-1, argv+1);
+      else if (strcmp(argv[1], "muldiv") == 0)
+         return validation_muldiv(count, argc-1, argv+1);
+      else if (strcmp(argv[1], "gamma") == 0)
+         return validation_gamma(argc-1, argv+1);
+   }
+
+   /* Bad argument: */
+   fprintf(stderr,
+      "usage: tarith [-v] [-c count] {ascii,muldiv,gamma} [args]\n");
+   fprintf(stderr, " arguments: ascii [-a (all results)] [-e error%%]\n");
+   fprintf(stderr, "            checkfp [-l max-number-chars]\n");
+   fprintf(stderr, "            muldiv\n");
+   fprintf(stderr, "            gamma -s (silent) -g (only gamma; no log)\n");
+   return 1;
+}
diff --git a/Engine/lib/lpng/contrib/libtests/timepng.c b/Engine/lib/lpng/contrib/libtests/timepng.c
new file mode 100644
index 000000000..23d8b17b1
--- /dev/null
+++ b/Engine/lib/lpng/contrib/libtests/timepng.c
@@ -0,0 +1,608 @@
+/* timepng.c
+ *
+ * Copyright (c) 2013,2016 John Cunningham Bowler
+ *
+ * Last changed in libpng 1.6.22 [May 26, 2016]
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * Load an arbitrary number of PNG files (from the command line, or, if there
+ * are no arguments on the command line, from stdin) then run a time test by
+ * reading each file by row or by image (possibly with transforms in the latter
+ * case).  The only output is a time as a floating point number of seconds with
+ * 9 decimal digits.
+ */
+#define _POSIX_C_SOURCE 199309L /* for clock_gettime */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <limits.h>
+
+#include <time.h>
+
+#if defined(HAVE_CONFIG_H) && !defined(PNG_NO_CONFIG_H)
+#  include <config.h>
+#endif
+
+/* Define the following to use this test against your installed libpng, rather
+ * than the one being built here:
+ */
+#ifdef PNG_FREESTANDING_TESTS
+#  include <png.h>
+#else
+#  include "../../png.h"
+#endif
+
+/* The following is to support direct compilation of this file as C++ */
+#ifdef __cplusplus
+#  define voidcast(type, value) static_cast<type>(value)
+#else
+#  define voidcast(type, value) (value)
+#endif /* __cplusplus */
+
+/* 'CLOCK_PROCESS_CPUTIME_ID' is one of the clock timers for clock_gettime.  It
+ * need not be supported even when clock_gettime is available.  It returns the
+ * 'CPU' time the process has consumed.  'CPU' time is assumed to include time
+ * when the CPU is actually blocked by a pending cache fill but not time
+ * waiting for page faults.  The attempt is to get a measure of the actual time
+ * the implementation takes to read a PNG ignoring the potentially very large IO
+ * overhead.
+ */
+#if defined (CLOCK_PROCESS_CPUTIME_ID) && defined(PNG_STDIO_SUPPORTED) &&\
+    defined(PNG_EASY_ACCESS_SUPPORTED) &&\
+    (PNG_LIBPNG_VER >= 10700 ? defined(PNG_READ_PNG_SUPPORTED) :\
+     defined (PNG_SEQUENTIAL_READ_SUPPORTED) &&\
+     defined(PNG_INFO_IMAGE_SUPPORTED))
+
+typedef struct
+{
+   FILE *input;
+   FILE *output;
+}  io_data;
+
+static PNG_CALLBACK(void, read_and_copy,
+      (png_structp png_ptr, png_bytep buffer, size_t cb))
+{
+   io_data *io = (io_data*)png_get_io_ptr(png_ptr);
+
+   if (fread(buffer, cb, 1, io->input) != 1)
+      png_error(png_ptr, strerror(errno));
+
+   if (fwrite(buffer, cb, 1, io->output) != 1)
+   {
+      perror("temporary file");
+      fprintf(stderr, "temporary file PNG write failed\n");
+      exit(1);
+   }
+}
+
+static void read_by_row(png_structp png_ptr, png_infop info_ptr,
+      FILE *write_ptr, FILE *read_ptr)
+{
+   /* These don't get freed on error, this is fine; the program immediately
+    * exits.
+    */
+   png_bytep row = NULL, display = NULL;
+   io_data io_copy;
+
+   if (write_ptr != NULL)
+   {
+      /* Set up for a copy to the temporary file: */
+      io_copy.input = read_ptr;
+      io_copy.output = write_ptr;
+      png_set_read_fn(png_ptr, &io_copy, read_and_copy);
+   }
+
+   png_read_info(png_ptr, info_ptr);
+
+   {
+      size_t rowbytes = png_get_rowbytes(png_ptr, info_ptr);
+
+      row = voidcast(png_bytep,malloc(rowbytes));
+      display = voidcast(png_bytep,malloc(rowbytes));
+
+      if (row == NULL || display == NULL)
+         png_error(png_ptr, "OOM allocating row buffers");
+
+      {
+         png_uint_32 height = png_get_image_height(png_ptr, info_ptr);
+         int passes = png_set_interlace_handling(png_ptr);
+         int pass;
+
+         png_start_read_image(png_ptr);
+
+         for (pass = 0; pass < passes; ++pass)
+         {
+            png_uint_32 y = height;
+
+            /* NOTE: this trashes the row each time; interlace handling won't
+             * work, but this avoids memory thrashing for speed testing and is
+             * somewhat representative of an application that works row-by-row.
+             */
+            while (y-- > 0)
+               png_read_row(png_ptr, row, display);
+         }
+      }
+   }
+
+   /* Make sure to read to the end of the file: */
+   png_read_end(png_ptr, info_ptr);
+
+   /* Free this up: */
+   free(row);
+   free(display);
+}
+
+static PNG_CALLBACK(void, no_warnings, (png_structp png_ptr,
+         png_const_charp warning))
+{
+   (void)png_ptr;
+   (void)warning;
+}
+
+static int read_png(FILE *fp, png_int_32 transforms, FILE *write_file)
+{
+   png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,0,0,
+         no_warnings);
+   png_infop info_ptr = NULL;
+
+   if (png_ptr == NULL)
+      return 0;
+
+   if (setjmp(png_jmpbuf(png_ptr)))
+   {
+      png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+      return 0;
+   }
+
+#  ifdef PNG_BENIGN_ERRORS_SUPPORTED
+      png_set_benign_errors(png_ptr, 1/*allowed*/);
+#  endif
+   png_init_io(png_ptr, fp);
+
+   info_ptr = png_create_info_struct(png_ptr);
+
+   if (info_ptr == NULL)
+      png_error(png_ptr, "OOM allocating info structure");
+
+   if (transforms < 0)
+      read_by_row(png_ptr, info_ptr, write_file, fp);
+
+   else
+      png_read_png(png_ptr, info_ptr, transforms, NULL/*params*/);
+
+   png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+   return 1;
+}
+
+static int mytime(struct timespec *t)
+{
+   /* Do the timing using clock_gettime and the per-process timer. */
+   if (!clock_gettime(CLOCK_PROCESS_CPUTIME_ID, t))
+      return 1;
+
+   perror("CLOCK_PROCESS_CPUTIME_ID");
+   fprintf(stderr, "timepng: could not get the time\n");
+   return 0;
+}
+
+static int perform_one_test(FILE *fp, int nfiles, png_int_32 transforms)
+{
+   int i;
+   struct timespec before, after;
+
+   /* Clear out all errors: */
+   rewind(fp);
+
+   if (mytime(&before))
+   {
+      for (i=0; i<nfiles; ++i)
+      {
+         if (read_png(fp, transforms, NULL/*write*/))
+         {
+            if (ferror(fp))
+            {
+               perror("temporary file");
+               fprintf(stderr, "file %d: error reading PNG data\n", i);
+               return 0;
+            }
+         }
+
+         else
+         {
+            perror("temporary file");
+            fprintf(stderr, "file %d: error from libpng\n", i);
+            return 0;
+         }
+      }
+   }
+
+   else
+      return 0;
+
+   if (mytime(&after))
+   {
+      /* Work out the time difference and print it - this is the only output,
+       * so flush it immediately.
+       */
+      unsigned long s = after.tv_sec - before.tv_sec;
+      long ns = after.tv_nsec - before.tv_nsec;
+
+      if (ns < 0)
+      {
+         --s;
+         ns += 1000000000;
+
+         if (ns < 0)
+         {
+            fprintf(stderr, "timepng: bad clock from kernel\n");
+            return 0;
+         }
+      }
+
+      printf("%lu.%.9ld\n", s, ns);
+      fflush(stdout);
+      if (ferror(stdout))
+      {
+         fprintf(stderr, "timepng: error writing output\n");
+         return 0;
+      }
+
+      /* Successful return */
+      return 1;
+   }
+
+   else
+      return 0;
+}
+
+static int add_one_file(FILE *fp, char *name)
+{
+   FILE *ip = fopen(name, "rb");
+
+   if (ip != NULL)
+   {
+      /* Read the file using libpng; this detects errors and also deals with
+       * files which contain data beyond the end of the file.
+       */
+      int ok = 0;
+      fpos_t pos;
+
+      if (fgetpos(fp, &pos))
+      {
+         /* Fatal error reading the start: */
+         perror("temporary file");
+         fprintf(stderr, "temporary file fgetpos error\n");
+         exit(1);
+      }
+
+      if (read_png(ip, -1/*by row*/, fp/*output*/))
+      {
+         if (ferror(ip))
+         {
+            perror(name);
+            fprintf(stderr, "%s: read error\n", name);
+         }
+
+         else
+            ok = 1; /* read ok */
+      }
+
+      else
+         fprintf(stderr, "%s: file not added\n", name);
+
+      (void)fclose(ip);
+
+      /* An error in the output is fatal; exit immediately: */
+      if (ferror(fp))
+      {
+         perror("temporary file");
+         fprintf(stderr, "temporary file write error\n");
+         exit(1);
+      }
+
+      if (ok)
+         return 1;
+
+      /* Did not read the file successfully, simply rewind the temporary
+       * file.  This must happen after the ferror check above to avoid clearing
+       * the error.
+       */
+      if (fsetpos(fp, &pos))
+      {
+         perror("temporary file");
+         fprintf(stderr, "temporary file fsetpos error\n");
+         exit(1);
+      }
+   }
+
+   else
+   {
+      /* file open error: */
+      perror(name);
+      fprintf(stderr, "%s: open failed\n", name);
+   }
+
+   return 0; /* file not added */
+}
+
+static void
+usage(FILE *fp)
+{
+   if (fp != NULL) fclose(fp);
+
+   fprintf(stderr,
+"Usage:\n"
+" timepng --assemble <assembly> {files}\n"
+"  Read the files into <assembly>, output the count.  Options are ignored.\n"
+" timepng --dissemble <assembly> <count> [options]\n"
+"  Time <count> files from <assembly>, additional files may not be given.\n"
+" Otherwise:\n"
+"  Read the files into a temporary file and time the decode\n"
+"Transforms:\n"
+"  --by-image: read by image with png_read_png\n"
+"  --<transform>: implies by-image, use PNG_TRANSFORM_<transform>\n"
+"  Otherwise: read by row using png_read_row (to a single row buffer)\n"
+   /* ISO C90 string length max 509 */);fprintf(stderr,
+"{files}:\n"
+"  PNG files to copy into the assembly and time.  Invalid files are skipped\n"
+"  with appropriate error messages.  If no files are given the list of files\n"
+"  is read from stdin with each file name terminated by a newline\n"
+"Output:\n"
+"  For --assemble the output is the name of the assembly file followed by the\n"
+"  count of the files it contains; the arguments for --dissemble.  Otherwise\n"
+"  the output is the total decode time in seconds.\n");
+
+   exit(99);
+}
+
+int main(int argc, char **argv)
+{
+   int ok = 0;
+   int err = 0;
+   int nfiles = 0;
+   int transforms = -1; /* by row */
+   const char *assembly = NULL;
+   FILE *fp;
+
+   if (argc > 2 && strcmp(argv[1], "--assemble") == 0)
+   {
+      /* Just build the test file, argv[2] is the file name. */
+      assembly = argv[2];
+      fp = fopen(assembly, "wb");
+      if (fp == NULL)
+      {
+         perror(assembly);
+         fprintf(stderr, "timepng --assemble %s: could not open for write\n",
+               assembly);
+         usage(NULL);
+      }
+
+      argv += 2;
+      argc -= 2;
+   }
+
+   else if (argc > 3 && strcmp(argv[1], "--dissemble") == 0)
+   {
+      fp = fopen(argv[2], "rb");
+
+      if (fp == NULL)
+      {
+         perror(argv[2]);
+         fprintf(stderr, "timepng --dissemble %s: could not open for read\n",
+               argv[2]);
+         usage(NULL);
+      }
+
+      nfiles = atoi(argv[3]);
+      if (nfiles <= 0)
+      {
+         fprintf(stderr,
+               "timepng --dissemble <file> <count>: %s is not a count\n",
+               argv[3]);
+         exit(99);
+      }
+#ifdef __COVERITY__
+      else
+      {
+         nfiles &= PNG_UINT_31_MAX;
+      }
+#endif
+
+      argv += 3;
+      argc -= 3;
+   }
+
+   else /* Else use a temporary file */
+   {
+#ifndef __COVERITY__
+      fp = tmpfile();
+#else
+      /* Experimental. Coverity says tmpfile() is insecure because it
+       * generates predictable names.
+       *
+       * It is possible to satisfy Coverity by using mkstemp(); however,
+       * any platform supporting mkstemp() undoubtedly has a secure tmpfile()
+       * implementation as well, and doesn't need the fix.  Note that
+       * the fix won't work on platforms that don't support mkstemp().
+       *
+       * https://www.securecoding.cert.org/confluence/display/c/
+       * FIO21-C.+Do+not+create+temporary+files+in+shared+directories
+       * says that most historic implementations of tmpfile() provide
+       * only a limited number of possible temporary file names
+       * (usually 26) before file names are recycled. That article also
+       * provides a secure solution that unfortunately depends upon mkstemp().
+       */
+      char tmpfile[] = "timepng-XXXXXX";
+      int filedes;
+      umask(0177);
+      filedes = mkstemp(tmpfile);
+      if (filedes < 0)
+        fp = NULL;
+      else
+      {
+        fp = fdopen(filedes,"w+");
+        /* Hide the filename immediately and ensure that the file does
+         * not exist after the program ends
+         */
+        (void) unlink(tmpfile);
+      }
+#endif
+
+      if (fp == NULL)
+      {
+         perror("tmpfile");
+         fprintf(stderr, "timepng: could not open the temporary file\n");
+         exit(1); /* not a user error */
+      }
+   }
+
+   /* Handle the transforms: */
+   while (argc > 1 && argv[1][0] == '-' && argv[1][1] == '-')
+   {
+      const char *opt = *++argv + 2;
+
+      --argc;
+
+      /* Transforms turn on the by-image processing and maybe set some
+       * transforms:
+       */
+      if (transforms == -1)
+         transforms = PNG_TRANSFORM_IDENTITY;
+
+      if (strcmp(opt, "by-image") == 0)
+      {
+         /* handled above */
+      }
+
+#        define OPT(name) else if (strcmp(opt, #name) == 0)\
+         transforms |= PNG_TRANSFORM_ ## name
+
+      OPT(STRIP_16);
+      OPT(STRIP_ALPHA);
+      OPT(PACKING);
+      OPT(PACKSWAP);
+      OPT(EXPAND);
+      OPT(INVERT_MONO);
+      OPT(SHIFT);
+      OPT(BGR);
+      OPT(SWAP_ALPHA);
+      OPT(SWAP_ENDIAN);
+      OPT(INVERT_ALPHA);
+      OPT(STRIP_FILLER);
+      OPT(STRIP_FILLER_BEFORE);
+      OPT(STRIP_FILLER_AFTER);
+      OPT(GRAY_TO_RGB);
+      OPT(EXPAND_16);
+      OPT(SCALE_16);
+
+      else
+      {
+         fprintf(stderr, "timepng %s: unrecognized transform\n", opt);
+         usage(fp);
+      }
+   }
+
+   /* Handle the files: */
+   if (argc > 1 && nfiles > 0)
+      usage(fp); /* Additional files not valid with --dissemble */
+
+   else if (argc > 1)
+   {
+      int i;
+
+      for (i=1; i<argc; ++i)
+      {
+         if (nfiles == INT_MAX)
+         {
+            fprintf(stderr, "%s: skipped, too many files\n", argv[i]);
+            break;
+         }
+
+         else if (add_one_file(fp, argv[i]))
+            ++nfiles;
+      }
+   }
+
+   else if (nfiles == 0) /* Read from stdin withoout --dissemble */
+   {
+      char filename[FILENAME_MAX+1];
+
+      while (fgets(filename, FILENAME_MAX+1, stdin))
+      {
+         size_t len = strlen(filename);
+
+         if (filename[len-1] == '\n')
+         {
+            filename[len-1] = 0;
+            if (nfiles == INT_MAX)
+            {
+               fprintf(stderr, "%s: skipped, too many files\n", filename);
+               break;
+            }
+
+            else if (add_one_file(fp, filename))
+               ++nfiles;
+         }
+
+         else
+         {
+            fprintf(stderr, "timepng: file name too long: ...%s\n",
+               filename+len-32);
+            err = 1;
+            break;
+         }
+      }
+
+      if (ferror(stdin))
+      {
+         fprintf(stderr, "timepng: stdin: read error\n");
+         err = 1;
+      }
+   }
+
+   /* Perform the test, or produce the --assemble output: */
+   if (!err)
+   {
+      if (nfiles > 0)
+      {
+         if (assembly != NULL)
+         {
+            if (fflush(fp) && !ferror(fp) && fclose(fp))
+            {
+               perror(assembly);
+               fprintf(stderr, "%s: close failed\n", assembly);
+            }
+
+            else
+            {
+               printf("%s %d\n", assembly, nfiles);
+               fflush(stdout);
+               ok = !ferror(stdout);
+            }
+         }
+
+         else
+         {
+            ok = perform_one_test(fp, nfiles, transforms);
+            (void)fclose(fp);
+         }
+      }
+
+      else
+         usage(fp);
+   }
+
+   else
+      (void)fclose(fp);
+
+   /* Exit code 0 on success. */
+   return ok == 0;
+}
+#else /* !sufficient support */
+int main(void) { return 77; }
+#endif /* !sufficient support */
diff --git a/Engine/lib/lpng/contrib/mips-msa/README b/Engine/lib/lpng/contrib/mips-msa/README
new file mode 100644
index 000000000..10acc9364
--- /dev/null
+++ b/Engine/lib/lpng/contrib/mips-msa/README
@@ -0,0 +1,83 @@
+OPERATING SYSTEM SPECIFIC MIPS MSA DETECTION
+--------------------------------------------
+
+Detection of the ability to execute MIPS MSA on an MIPS processor requires
+operating system support.  (The information is not available in user mode.)
+
+HOW TO USE THIS
+---------------
+
+This directory contains C code fragments that can be included in mips/mips_init.c
+by setting the macro PNG_MIPS_MSA_FILE to the file name in "" or <> at build
+time.  This setting is not recorded in pnglibconf.h and can be changed simply by
+rebuilding mips/msa_init.o with the required macro definition.
+
+For any of this code to be used the MIPS MSA code must be enabled and run time
+checks must be supported.  I.e.:
+
+#if PNG_MIPS_MSA_OPT > 0
+#ifdef PNG_MIPS_MSA_CHECK_SUPPORTED
+
+This is done in a 'configure' build by passing configure the argument:
+
+   --enable-mips-msa=check
+
+Apart from the basic Linux implementation in contrib/mips-msa/linux.c this code
+is unsupported.  That means that it is not even compiled on a regular basis and
+may be broken in any given minor release.
+
+FILE FORMAT
+-----------
+
+Each file documents its testing status as of the last time it was tested (which
+may have been a long time ago):
+
+STATUS: one of:
+   SUPPORTED: This indicates that the file is included in the regularly
+         performed test builds and bugs are fixed when discovered.
+   COMPILED: This indicates that the code did compile at least once.  See the
+         more detailed description for the extent to which the result was
+         successful.
+   TESTED: This means the code was fully compiled into the libpng test programs
+         and these were run at least once.
+
+BUG REPORTS: an email address to which to send reports of problems
+
+The file is a fragment of C code. It should not define any 'extern' symbols;
+everything should be static.  It must define the function:
+
+static int png_have_msa(png_structp png_ptr);
+
+That function must return 1 if MIPS MSA instructions are supported, 0 if not.
+It must not execute png_error unless it detects a bug.  A png_error will prevent
+the reading of the PNG and in the future, writing too.
+
+BUG REPORTS
+-----------
+
+If you mail a bug report for any file that is not SUPPORTED there may only be
+limited response.  Consider fixing it and sending a patch to fix the problem -
+this is more likely to result in action.
+
+CONTRIBUTIONS
+-------------
+
+You may send contributions of new implementations to
+png-mng-implement@sourceforge.net.  Please write code in strict C90 C where
+possible.  Obviously OS dependencies are to be expected.  If you submit code you
+must have the authors permission and it must have a license that is acceptable
+to the current maintainer; in particular that license must permit modification
+and redistribution.
+
+Please try to make the contribution a single file and give the file a clear and
+unambiguous name that identifies the target OS.  If multiple files really are
+required put them all in a sub-directory.
+
+You must also be prepared to handle bug reports from users of the code, either
+by joining the png-mng-implement mailing list or by providing an email for the
+"BUG REPORTS" entry or both.  Please make sure that the header of the file
+contains the STATUS and BUG REPORTS fields as above.
+
+Please list the OS requirements as precisely as possible.  Ideally you should
+also list the environment in which the code has been tested and certainly list
+any environments where you suspect it might not work.
diff --git a/Engine/lib/lpng/contrib/mips-msa/linux.c b/Engine/lib/lpng/contrib/mips-msa/linux.c
new file mode 100644
index 000000000..140215c4e
--- /dev/null
+++ b/Engine/lib/lpng/contrib/mips-msa/linux.c
@@ -0,0 +1,64 @@
+/* contrib/mips-msa/linux.c
+ *
+ * Copyright (c) 2016 Glenn Randers-Pehrson
+ * Written by Mandar Sahastrabuddhe, 2016.
+ * Last changed in libpng 1.6.25beta03 [August 29, 2016]
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * SEE contrib/mips-msa/README before reporting bugs
+ *
+ * STATUS: SUPPORTED
+ * BUG REPORTS: png-mng-implement@sourceforge.net
+ *
+ * png_have_msa implemented for Linux by reading the widely available
+ * pseudo-file /proc/cpuinfo.
+ *
+ * This code is strict ANSI-C and is probably moderately portable; it does
+ * however use <stdio.h> and it assumes that /proc/cpuinfo is never localized.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+static int
+png_have_msa(png_structp png_ptr)
+{
+   FILE *f = fopen("/proc/cpuinfo", "rb");
+
+   char *string = "msa";
+   char word[10];
+
+   if (f != NULL)
+   {
+      while(!feof(f))
+      {
+         int ch = fgetc(f);
+         static int i = 0;
+
+         while(!(ch <= 32))
+         {
+            word[i++] = ch;
+            ch = fgetc(f);
+         }
+
+         int val = strcmp(string, word);
+
+         if (val == 0)
+            return 1;
+
+         i = 0;
+         memset(word, 0, 10);
+      }
+
+      fclose(f);
+   }
+#ifdef PNG_WARNINGS_SUPPORTED
+   else
+      png_warning(png_ptr, "/proc/cpuinfo open failed");
+#endif
+   return 0;
+}
diff --git a/Engine/lib/lpng/contrib/oss-fuzz/Dockerfile b/Engine/lib/lpng/contrib/oss-fuzz/Dockerfile
new file mode 100644
index 000000000..f5bc1a985
--- /dev/null
+++ b/Engine/lib/lpng/contrib/oss-fuzz/Dockerfile
@@ -0,0 +1,25 @@
+# Copyright 2016 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+FROM gcr.io/oss-fuzz-base/base-builder
+MAINTAINER glennrp@gmail.com
+RUN apt-get update && \
+    apt-get install -y make autoconf automake libtool
+
+RUN git clone --depth 1 https://github.com/madler/zlib.git
+RUN git clone --depth 1 https://github.com/glennrp/libpng.git
+RUN cp libpng/contrib/oss-fuzz/build.sh $SRC
+WORKDIR libpng
diff --git a/Engine/lib/lpng/contrib/oss-fuzz/README.txt b/Engine/lib/lpng/contrib/oss-fuzz/README.txt
new file mode 100644
index 000000000..3b3656fbb
--- /dev/null
+++ b/Engine/lib/lpng/contrib/oss-fuzz/README.txt
@@ -0,0 +1,37 @@
+Last changed in libpng 1.6.33 [September 28, 2017]
+Copyright (c) 2017 Glenn Randers-Pehrson
+
+This code is released under the libpng license.
+For conditions of distribution and use, see the disclaimer
+and license in png.h
+
+Files in this directory are used by the oss-fuzz project
+(https://github.com/google/oss-fuzz/tree/master/projects/libpng).
+for "fuzzing" libpng.
+
+They were licensed by Google Inc, using the BSD-like Chromium license,
+which may be found at https://cs.chromium.org/chromium/src/LICENSE, or, if
+noted in the source, under the Apache-2.0 license, which may
+be found at http://www.apache.org/licenses/LICENSE-2.0 .
+If they have been modified, the derivatives are copyright Glenn Randers-Pehrson
+and are released under the same licenses as the originals.  Several of
+the original files (libpng_read_fuzzer.options, png.dict, project.yaml)
+had no licensing information; we assumed that these were under the Chromium
+license. Any new files are released under the libpng license (see png.h).
+
+The files are
+                            Original
+ Filename                   or derived   Copyright          License
+ =========================  ==========   ================   ==========
+ Dockerfile*                derived      2017, Glenn R-P    Apache 2.0
+ build.sh                   derived      2017, Glenn R-P    Apache 2.0
+ libpng_read_fuzzer.cc      derived      2017, Glenn R-P    Chromium
+ libpng_read_fuzzer.options original     2015, Chrome Devs  Chromium
+ png.dict                   original     2015, Chrome Devs  Chromium
+ README.txt (this file)     original     2017, Glenn R-P    libpng
+
+ * Dockerfile is a copy of the file used by oss-fuzz. build.sh,
+   png.dict and libpng_read_fuzzer.* are the actual files used by oss-fuzz,
+   which retrieves them from the libpng repository at Github.
+
+To do: exercise the progressive reader and the png encoder.
diff --git a/Engine/lib/lpng/contrib/oss-fuzz/build.sh b/Engine/lib/lpng/contrib/oss-fuzz/build.sh
new file mode 100755
index 000000000..f9e1b0776
--- /dev/null
+++ b/Engine/lib/lpng/contrib/oss-fuzz/build.sh
@@ -0,0 +1,51 @@
+#!/bin/bash -eu
+# Copyright 2017-2018 Glenn Randers-Pehrson
+# Copyright 2016 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Last changed in libpng 1.6.35 [July 15, 2018]
+#
+# Revisions by Glenn Randers-Pehrson, 2017:
+# 1. Build only the library, not the tools (changed "make -j$(nproc) all" to
+#     "make -j$(nproc) libpng16.la").
+# 2. Disabled WARNING and WRITE options in pnglibconf.dfa.
+# 3. Build zlib alongside libpng
+################################################################################
+
+# Disable logging via library build configuration control.
+cat scripts/pnglibconf.dfa | \
+  sed -e "s/option STDIO/option STDIO disabled/" \
+      -e "s/option WARNING /option WARNING disabled/" \
+      -e "s/option WRITE enables WRITE_INT_FUNCTIONS/option WRITE disabled/" \
+> scripts/pnglibconf.dfa.temp
+mv scripts/pnglibconf.dfa.temp scripts/pnglibconf.dfa
+
+# build the libpng library.
+autoreconf -f -i
+./configure --with-libpng-prefix=OSS_FUZZ_
+make -j$(nproc) clean
+make -j$(nproc) libpng16.la
+
+# build libpng_read_fuzzer.
+$CXX $CXXFLAGS -std=c++11 -I. \
+     $SRC/libpng/contrib/oss-fuzz/libpng_read_fuzzer.cc \
+     -o $OUT/libpng_read_fuzzer \
+     -lFuzzingEngine .libs/libpng16.a -lz
+
+# add seed corpus.
+find $SRC/libpng -name "*.png" | grep -v crashers | \
+     xargs zip $OUT/libpng_read_fuzzer_seed_corpus.zip
+
+cp $SRC/libpng/contrib/oss-fuzz/*.dict \
+     $SRC/libpng/contrib/oss-fuzz/*.options $OUT/
diff --git a/Engine/lib/lpng/contrib/oss-fuzz/libpng_read_fuzzer.cc b/Engine/lib/lpng/contrib/oss-fuzz/libpng_read_fuzzer.cc
new file mode 100644
index 000000000..7b305509c
--- /dev/null
+++ b/Engine/lib/lpng/contrib/oss-fuzz/libpng_read_fuzzer.cc
@@ -0,0 +1,190 @@
+
+// libpng_read_fuzzer.cc
+// Copyright 2017-2018 Glenn Randers-Pehrson
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that may
+// be found in the LICENSE file https://cs.chromium.org/chromium/src/LICENSE
+
+// Last changed in libpng 1.6.35 [July 15, 2018]
+
+// The modifications in 2017 by Glenn Randers-Pehrson include
+// 1. addition of a PNG_CLEANUP macro,
+// 2. setting the option to ignore ADLER32 checksums,
+// 3. adding "#include <string.h>" which is needed on some platforms
+//    to provide memcpy().
+// 4. adding read_end_info() and creating an end_info structure.
+// 5. adding calls to png_set_*() transforms commonly used by browsers.
+
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include <vector>
+
+#define PNG_INTERNAL
+#include "png.h"
+
+#define PNG_CLEANUP \
+  if(png_handler.png_ptr) \
+  { \
+    if (png_handler.row_ptr) \
+      png_free(png_handler.png_ptr, png_handler.row_ptr); \
+    if (png_handler.end_info_ptr) \
+      png_destroy_read_struct(&png_handler.png_ptr, &png_handler.info_ptr,\
+        &png_handler.end_info_ptr); \
+    else if (png_handler.info_ptr) \
+      png_destroy_read_struct(&png_handler.png_ptr, &png_handler.info_ptr,\
+        nullptr); \
+    else \
+      png_destroy_read_struct(&png_handler.png_ptr, nullptr, nullptr); \
+    png_handler.png_ptr = nullptr; \
+    png_handler.row_ptr = nullptr; \
+    png_handler.info_ptr = nullptr; \
+    png_handler.end_info_ptr = nullptr; \
+  }
+
+struct BufState {
+  const uint8_t* data;
+  size_t bytes_left;
+};
+
+struct PngObjectHandler {
+  png_infop info_ptr = nullptr;
+  png_structp png_ptr = nullptr;
+  png_infop end_info_ptr = nullptr;
+  png_voidp row_ptr = nullptr;
+  BufState* buf_state = nullptr;
+
+  ~PngObjectHandler() {
+    if (row_ptr)
+      png_free(png_ptr, row_ptr);
+    if (end_info_ptr)
+      png_destroy_read_struct(&png_ptr, &info_ptr, &end_info_ptr);
+    else if (info_ptr) 
+      png_destroy_read_struct(&png_ptr, &info_ptr, nullptr);
+    else
+      png_destroy_read_struct(&png_ptr, nullptr, nullptr);
+    delete buf_state;
+  }
+};
+
+void user_read_data(png_structp png_ptr, png_bytep data, size_t length) {
+  BufState* buf_state = static_cast<BufState*>(png_get_io_ptr(png_ptr));
+  if (length > buf_state->bytes_left) {
+    png_error(png_ptr, "read error");
+  }
+  memcpy(data, buf_state->data, length);
+  buf_state->bytes_left -= length;
+  buf_state->data += length;
+}
+
+static const int kPngHeaderSize = 8;
+
+// Entry point for LibFuzzer.
+// Roughly follows the libpng book example:
+// http://www.libpng.org/pub/png/book/chapter13.html
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  if (size < kPngHeaderSize) {
+    return 0;
+  }
+
+  std::vector<unsigned char> v(data, data + size);
+  if (png_sig_cmp(v.data(), 0, kPngHeaderSize)) {
+    // not a PNG.
+    return 0;
+  }
+
+  PngObjectHandler png_handler;
+  png_handler.png_ptr = nullptr;
+  png_handler.row_ptr = nullptr;
+  png_handler.info_ptr = nullptr;
+  png_handler.end_info_ptr = nullptr;
+
+  png_handler.png_ptr = png_create_read_struct
+    (PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
+  if (!png_handler.png_ptr) {
+    return 0;
+  }
+
+  png_handler.info_ptr = png_create_info_struct(png_handler.png_ptr);
+  if (!png_handler.info_ptr) {
+    PNG_CLEANUP
+    return 0;
+  }
+
+  png_handler.end_info_ptr = png_create_info_struct(png_handler.png_ptr);
+  if (!png_handler.end_info_ptr) {
+    PNG_CLEANUP
+    return 0;
+  }
+
+  png_set_crc_action(png_handler.png_ptr, PNG_CRC_QUIET_USE, PNG_CRC_QUIET_USE);
+#ifdef PNG_IGNORE_ADLER32
+  png_set_option(png_handler.png_ptr, PNG_IGNORE_ADLER32, PNG_OPTION_ON);
+#endif
+
+  // Setting up reading from buffer.
+  png_handler.buf_state = new BufState();
+  png_handler.buf_state->data = data + kPngHeaderSize;
+  png_handler.buf_state->bytes_left = size - kPngHeaderSize;
+  png_set_read_fn(png_handler.png_ptr, png_handler.buf_state, user_read_data);
+  png_set_sig_bytes(png_handler.png_ptr, kPngHeaderSize);
+
+  if (setjmp(png_jmpbuf(png_handler.png_ptr))) {
+    PNG_CLEANUP
+    return 0;
+  }
+
+  // Reading.
+  png_read_info(png_handler.png_ptr, png_handler.info_ptr);
+
+  // reset error handler to put png_deleter into scope.
+  if (setjmp(png_jmpbuf(png_handler.png_ptr))) {
+    PNG_CLEANUP
+    return 0;
+  }
+
+  png_uint_32 width, height;
+  int bit_depth, color_type, interlace_type, compression_type;
+  int filter_type;
+
+  if (!png_get_IHDR(png_handler.png_ptr, png_handler.info_ptr, &width,
+                    &height, &bit_depth, &color_type, &interlace_type,
+                    &compression_type, &filter_type)) {
+    PNG_CLEANUP
+    return 0;
+  }
+
+  // This is going to be too slow.
+  if (width && height > 100000000 / width) {
+    PNG_CLEANUP
+    return 0;
+  }
+
+  // Set several transforms that browsers typically use:
+  png_set_gray_to_rgb(png_handler.png_ptr);
+  png_set_expand(png_handler.png_ptr);
+  png_set_packing(png_handler.png_ptr);
+  png_set_scale_16(png_handler.png_ptr);
+  png_set_tRNS_to_alpha(png_handler.png_ptr);
+
+  int passes = png_set_interlace_handling(png_handler.png_ptr);
+
+  png_read_update_info(png_handler.png_ptr, png_handler.info_ptr);
+
+  png_handler.row_ptr = png_malloc(
+      png_handler.png_ptr, png_get_rowbytes(png_handler.png_ptr,
+                                            png_handler.info_ptr));
+
+  for (int pass = 0; pass < passes; ++pass) {
+    for (png_uint_32 y = 0; y < height; ++y) {
+      png_read_row(png_handler.png_ptr,
+                   static_cast<png_bytep>(png_handler.row_ptr), nullptr);
+    }
+  }
+
+  png_read_end(png_handler.png_ptr, png_handler.end_info_ptr);
+
+  PNG_CLEANUP
+  return 0;
+}
diff --git a/Engine/lib/lpng/contrib/oss-fuzz/libpng_read_fuzzer.options b/Engine/lib/lpng/contrib/oss-fuzz/libpng_read_fuzzer.options
new file mode 100644
index 000000000..2005291a0
--- /dev/null
+++ b/Engine/lib/lpng/contrib/oss-fuzz/libpng_read_fuzzer.options
@@ -0,0 +1,2 @@
+[libfuzzer]
+dict = png.dict
diff --git a/Engine/lib/lpng/contrib/oss-fuzz/png.dict b/Engine/lib/lpng/contrib/oss-fuzz/png.dict
new file mode 100644
index 000000000..3a8a11383
--- /dev/null
+++ b/Engine/lib/lpng/contrib/oss-fuzz/png.dict
@@ -0,0 +1,39 @@
+#
+# AFL dictionary for PNG images
+# -----------------------------
+#
+# Just the basic, standard-originating sections; does not include vendor
+# extensions.
+#
+# Created by Michal Zalewski <lcamtuf@google.com>
+#
+
+header_png="\x89PNG\x0d\x0a\x1a\x0a"
+
+section_IDAT="IDAT"
+section_IEND="IEND"
+section_IHDR="IHDR"
+section_PLTE="PLTE"
+section_bKGD="bKGD"
+section_cHRM="cHRM"
+section_eXIf="eXIf"
+section_fRAc="fRAc"
+section_gAMA="gAMA"
+section_gIFg="gIFg"
+section_gIFt="gIFt"
+section_gIFx="gIFx"
+section_hIST="hIST"
+section_iCCP="iCCP"
+section_iTXt="iTXt"
+section_oFFs="oFFs"
+section_pCAL="pCAL"
+section_pHYs="pHYs"
+section_sBIT="sBIT"
+section_sCAL="sCAL"
+section_sPLT="sPLT"
+section_sRGB="sRGB"
+section_sTER="sTER"
+section_tEXt="tEXt"
+section_tIME="tIME"
+section_tRNS="tRNS"
+section_zTXt="zTXt"
diff --git a/Engine/lib/lpng/contrib/pngminim/README b/Engine/lib/lpng/contrib/pngminim/README
new file mode 100644
index 000000000..e17fe35b6
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngminim/README
@@ -0,0 +1,5 @@
+
+This demonstrates the use of PNG_USER_CONFIG, pngusr.h and pngusr.dfa
+to build minimal decoder, encoder, and progressive reader applications.
+
+See the individual README and pngusr.dfa files for more explanation.
diff --git a/Engine/lib/lpng/contrib/pngminim/decoder/README b/Engine/lib/lpng/contrib/pngminim/decoder/README
new file mode 100644
index 000000000..fa979fcb7
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngminim/decoder/README
@@ -0,0 +1,10 @@
+This demonstrates the use of PNG_USER_CONFIG, pngusr.h and pngusr.dfa
+
+The makefile builds a minimal read-only decoder with embedded libpng
+and zlib.
+
+Specify the location of the zlib source (1.2.1 or later) as ZLIBSRC
+on the make command line.
+
+If you prefer to use the shared libraries, go to contrib/pngminus
+and build the png2pnm application there.
diff --git a/Engine/lib/lpng/contrib/pngminim/decoder/makefile b/Engine/lib/lpng/contrib/pngminim/decoder/makefile
new file mode 100644
index 000000000..4acf3c177
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngminim/decoder/makefile
@@ -0,0 +1,151 @@
+# Makefile for PngMinus (pngm2pnm)
+# Linux / Unix
+
+#CC=cc
+CC=gcc
+LD=$(CC)
+
+# If awk fails try
+# make AWK=nawk
+
+# If cpp fails try
+# make CPP=/lib/cpp
+
+RM=rm -f
+COPY=cp
+
+CPPFLAGS=-I. -DPNG_USER_CONFIG -DNO_GZCOMPRESS -DZ_SOLO -DNO_GZIP
+CFLAGS=-O1 -Wall
+
+C=.c
+O=.o
+L=.a
+E=
+
+# Where to find the source code:
+PNGSRC =../../..
+ZLIBSRC=$(PNGSRC)/../zlib
+PROGSRC=$(PNGSRC)/contrib/pngminus
+
+# Zlib (minimal inflate requirements - crc32 is used by libpng)
+# zutil can be eliminated if you provide your own zcalloc and zcfree
+ZSRCS  = adler32$(C) crc32$(C) \
+	 inffast$(C) inflate$(C) inftrees$(C) \
+	 zutil$(C)
+
+# Standard headers
+ZH     = zlib.h crc32.h inffast.h inffixed.h \
+	 inflate.h inftrees.h zutil.h
+
+# Machine generated headers
+ZCONF  = zconf.h
+
+# Headers callers use
+ZINC   = zlib.h $(ZCONF)
+
+# Headers the Zlib source uses
+ZHDRS  = $(ZH) $(ZCONF)
+
+ZOBJS  = adler32$(O) crc32$(O) \
+	 inffast$(O) inflate$(O) inftrees$(O) \
+	 zutil$(O)
+
+# libpng
+PNGSRCS=png$(C) pngerror$(C) pngget$(C) pngmem$(C) \
+	pngread$(C) pngrio$(C) pngrtran$(C) pngrutil$(C) \
+	pngset$(C) pngtrans$(C)
+	
+# Standard headers
+PNGH   =png.h pngconf.h pngdebug.h pnginfo.h pngpriv.h pngstruct.h
+
+# Machine generated headers
+PNGCONF=pnglibconf.h
+
+# Headers callers use
+PNGINC= png.h pngconf.h pngusr.h $(PNGCONF)
+
+# Headers the PNG library uses
+PNGHDRS=$(PNGH) $(PNGCONF) pngusr.h
+
+PNGOBJS=png$(O) pngerror$(O) pngget$(O) pngmem$(O) \
+	pngread$(O) pngrio$(O) pngrtran$(O) pngrutil$(O) \
+	pngset$(O) pngtrans$(O)
+
+PROGSRCS= pngm2pnm$(C)
+PROGHDRS=
+PROGDOCS=
+PROGOBJS= pngm2pnm$(O)
+
+OBJS    = $(PROGOBJS) $(PNGOBJS) $(ZOBJS)
+
+# implicit make rules -------------------------------------------------------
+
+# note: dependencies do not work on implicit rule lines
+.c$(O):
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) $<
+
+# dependencies
+
+all: pngm2pnm$(E)
+
+pngm2pnm$(E): $(OBJS)
+	$(LD) -o pngm2pnm$(E) $(OBJS)
+
+# The DFA_XTRA setting turns all libpng options off then
+# turns on those required for this minimal build.
+# The CPP_FLAGS setting causes pngusr.h to be included in
+# both the build of pnglibconf.h and, subsequently, when
+# building libpng itself.
+$(PNGCONF): $(PNGSRC)/scripts/pnglibconf.mak $(ZH)\
+	$(PNGSRC)/scripts/pnglibconf.dfa \
+	$(PNGSRC)/scripts/options.awk pngusr.h pngusr.dfa
+	$(RM) pnglibconf.h pnglibconf.dfn
+	$(MAKE) -f $(PNGSRC)/scripts/pnglibconf.mak $(MAKEFLAGS)\
+	    srcdir=$(PNGSRC) CPPFLAGS="-DPNG_USER_CONFIG -I."\
+	    DFA_XTRA="pngusr.dfa" $@
+
+clean:
+	$(MAKE) -f $(PNGSRC)/scripts/pnglibconf.mak $(MAKEFLAGS)\
+	    srcdir=$(PNGSRC) clean
+	$(RM) pngm2pnm$(O)
+	$(RM) pngm2pnm$(E)
+	$(RM) $(OBJS)
+
+# distclean also removes the copied source and headers
+distclean: clean
+	$(RM) -r scripts # historical reasons
+	$(RM) $(PNGSRCS) $(PNGH)
+	$(RM) $(ZSRCS) $(ZH) $(ZCONF)
+	$(RM) $(PROGSRCS) $(PROGHDRS) $(PROGDOCS)
+
+# Header file dependencies:
+$(PROGOBJS): $(PROGHDRS) $(PNGINC) $(ZINC)
+$(PNGOBJS): $(PNGHDRS) $(ZINC)
+$(ZOBJS): $(ZHDRS)
+
+# Gather the source code from the respective directories
+$(PNGSRCS) $(PNGH): $(PNGSRC)/$@
+	$(RM) $@
+	$(COPY) $(PNGSRC)/$@ $@
+
+# No dependency on the ZLIBSRC target so that it only needs
+# to be specified once.
+$(ZSRCS) $(ZH):
+	$(RM) $@
+	$(COPY) $(ZLIBSRC)/$@ $@
+
+# The unconfigured zconf.h varies in name according to the
+# zlib release
+$(ZCONF):
+	$(RM) $@
+	@for f in zconf.h.in zconf.in.h zconf.h; do\
+	    test -r $(ZLIBSRC)/$$f &&\
+	    echo $(COPY) $(ZLIBSRC)/$$f $@ &&\
+	    $(COPY) $(ZLIBSRC)/$$f $@ && exit 0;\
+	done; echo copy: $(ZLIBSRC)/zconf.h not found; exit 1
+
+pngm2pnm.c: $(PROGSRC)/png2pnm.c
+	$(RM) $@
+	$(COPY) $(PROGSRC)/png2pnm.c $@
+
+# End of makefile for pngm2pnm
diff --git a/Engine/lib/lpng/contrib/pngminim/decoder/pngusr.dfa b/Engine/lib/lpng/contrib/pngminim/decoder/pngusr.dfa
new file mode 100644
index 000000000..4f402721a
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngminim/decoder/pngusr.dfa
@@ -0,0 +1,40 @@
+# pngminim/decoder/pngusr.dfa
+#
+# Copyright (c) 2010-2013 Glenn Randers-Pehrson
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# First all the build options off:
+
+everything = off
+
+# All that is required is some read code. This example switches
+# on the sequential read code (see ../preader for a progressive
+# read example).
+
+option SEQUENTIAL_READ on
+
+# You must choose fixed or floating point arithmetic:
+# option FLOATING_POINT on
+
+option FIXED_POINT on
+
+# You must chose the internal fixed point implementation or to
+# use the system floating point.  The latter is considerably
+# smaller (by about 1kbyte on an x86 system):
+# option FLOATING_ARITHMETIC on
+
+option FLOATING_ARITHMETIC off
+
+# Your program will probably need other options.  The example
+# program here, pngm2pnm, requires the following.  Take a look
+# at pnglibconf.h to find out the full set of what has to be
+# enabled to make the following work.
+
+option SETJMP on
+option STDIO on
+option READ_EXPAND on
+option READ_STRIP_16_TO_8 on
+option USER_LIMITS on
diff --git a/Engine/lib/lpng/contrib/pngminim/decoder/pngusr.h b/Engine/lib/lpng/contrib/pngminim/decoder/pngusr.h
new file mode 100644
index 000000000..cbd7890c7
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngminim/decoder/pngusr.h
@@ -0,0 +1,23 @@
+/* minrdpngconf.h: headers to make a minimal png-read-only library
+ *
+ * Copyright (c) 2007, 2010-2013 Glenn Randers-Pehrson
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * Derived from pngcrush.h, Copyright 1998-2007, Glenn Randers-Pehrson
+ */
+
+#ifndef MINRDPNGCONF_H
+#define MINRDPNGCONF_H
+
+/* To include pngusr.h set -DPNG_USER_CONFIG in CPPFLAGS */
+
+/* List options to turn off features of the build that do not
+ * affect the API (so are not recorded in pnglibconf.h)
+ */
+
+#define PNG_ALIGN_TYPE PNG_ALIGN_NONE
+
+#endif /* MINRDPNGCONF_H */
diff --git a/Engine/lib/lpng/contrib/pngminim/encoder/README b/Engine/lib/lpng/contrib/pngminim/encoder/README
new file mode 100644
index 000000000..d8d9a6466
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngminim/encoder/README
@@ -0,0 +1,10 @@
+This demonstrates the use of PNG_USER_CONFIG and pngusr.h
+
+The makefile builds a minimal write-only encoder with embedded libpng
+and zlib.
+
+Specify the location of the zlib source (1.2.1 or later) as ZLIBSRC
+on the make command line.
+
+If you prefer to use the shared libraries, go to contrib/pngminus
+and build the pnm2png application there.
diff --git a/Engine/lib/lpng/contrib/pngminim/encoder/makefile b/Engine/lib/lpng/contrib/pngminim/encoder/makefile
new file mode 100644
index 000000000..41b205c28
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngminim/encoder/makefile
@@ -0,0 +1,150 @@
+# Makefile for PngMinus (pnm2pngm)
+# Linux / Unix
+
+#CC=cc
+CC=gcc
+LD=$(CC)
+
+# If awk fails try
+# make AWK=nawk
+
+# If cpp fails try
+# make CPP=/lib/cpp
+
+RM=rm -f
+COPY=cp
+
+CPPFLAGS=-I. -DPNG_USER_CONFIG -DNO_GZCOMPRESS -DZ_SOLO -DNO_GZIP
+CFLAGS=-O1 -Wall
+
+C=.c
+O=.o
+L=.a
+E=
+
+# Where to find the source code:
+PNGSRC =../../..
+ZLIBSRC=$(PNGSRC)/../zlib
+PROGSRC=$(PNGSRC)/contrib/pngminus
+
+# Zlib
+ZSRCS  = adler32$(C) compress$(C) crc32$(C) deflate$(C) \
+	 trees$(C) zutil$(C)
+
+# Standard headers
+#ZH     = zlib.h crc32.h deflate.h trees.h zutil.h
+ZH     = zlib.h crc32.h deflate.h trees.h zutil.h
+
+# Machine generated headers
+ZCONF  = zconf.h
+
+# Headers callers use
+ZINC   = zlib.h $(ZCONF)
+
+# Headers the Zlib source uses
+ZHDRS  = $(ZH) $(ZCONF)
+
+# compress is not required; it is needed to link the zlib
+# code because deflate defines an unused API function deflateBound
+# which itself calls compressBound from compress.
+ZOBJS  = adler32$(O) compress$(O) crc32$(O) deflate$(O) \
+	 trees$(O) zutil$(O)
+
+# libpng
+PNGSRCS=png$(C) pngerror$(C) pngget$(C) pngmem$(C) \
+	pngset$(C) pngtrans$(C) pngwio$(C) pngwrite$(C) \
+	pngwtran$(C) pngwutil$(C)
+
+# Standard headers
+PNGH   =png.h pngconf.h pngdebug.h pnginfo.h pngpriv.h pngstruct.h
+
+# Machine generated headers
+PNGCONF=pnglibconf.h
+
+# Headers callers use
+PNGINC= png.h pngconf.h pngusr.h $(PNGCONF)
+
+# Headers the PNG library uses
+PNGHDRS=$(PNGH) $(PNGCONF) pngusr.h
+
+PNGOBJS=png$(O) pngerror$(O) pngget$(O) pngmem$(O) \
+	pngset$(O) pngtrans$(O) pngwio$(O) pngwrite$(O) \
+	pngwtran$(O) pngwutil$(O)
+
+PROGSRCS= pnm2pngm$(C)
+PROGHDRS=
+PROGDOCS=
+PROGOBJS= pnm2pngm$(O)
+
+OBJS    = $(PROGOBJS) $(PNGOBJS) $(ZOBJS)
+
+# implicit make rules -------------------------------------------------------
+
+.c$(O):
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) $<
+
+# dependencies
+
+all: pnm2pngm$(E)
+
+pnm2pngm$(E): $(OBJS)
+	$(LD) -o pnm2pngm$(E) $(OBJS)
+
+# The DFA_XTRA setting turns all libpng options off then
+# turns on those required for this minimal build.
+# The CPP_FLAGS setting causes pngusr.h to be included in
+# both the build of pnglibconf.h and, subsequently, when
+# building libpng itself.
+$(PNGCONF): $(PNGSRC)/scripts/pnglibconf.mak $(ZH)\
+	$(PNGSRC)/scripts/pnglibconf.dfa \
+	$(PNGSRC)/scripts/options.awk pngusr.h pngusr.dfa
+	$(RM) pnglibconf.h pnglibconf.dfn
+	$(MAKE) -f $(PNGSRC)/scripts/pnglibconf.mak $(MAKEFLAGS)\
+	    srcdir=$(PNGSRC) CPPFLAGS="-DPNG_USER_CONFIG -I."\
+	    DFA_XTRA="pngusr.dfa" $@
+
+clean:
+	$(MAKE) -f $(PNGSRC)/scripts/pnglibconf.mak $(MAKEFLAGS)\
+	    srcdir=$(PNGSRC) clean
+	$(RM) pnm2pngm$(O)
+	$(RM) pnm2pngm$(E)
+	$(RM) $(OBJS)
+
+# distclean also removes the copied source and headers
+distclean: clean
+	$(RM) -r scripts # historical reasons
+	$(RM) $(PNGSRCS) $(PNGH)
+	$(RM) $(ZSRCS) $(ZH) $(ZCONF)
+	$(RM) $(PROGSRCS) $(PROGHDRS) $(PROGDOCS)
+
+# Header file dependencies:
+$(PROGOBJS): $(PROGHDRS) $(PNGINC) $(ZINC)
+$(PNGOBJS): $(PNGHDRS) $(ZINC)
+$(ZOBJS): $(ZHDRS)
+
+# Gather the source code from the respective directories
+$(PNGSRCS) $(PNGH): $(PNGSRC)/$@
+	$(RM) $@
+	$(COPY) $(PNGSRC)/$@ $@
+
+# No dependency on the ZLIBSRC target so that it only needs
+# to be specified once.
+$(ZSRCS) $(ZH):
+	$(RM) $@
+	$(COPY) $(ZLIBSRC)/$@ $@
+
+# The unconfigured zconf.h varies in name according to the
+# zlib release
+$(ZCONF):
+	$(RM) $@
+	@for f in zconf.h.in zconf.in.h zconf.h; do\
+	    test -r $(ZLIBSRC)/$$f &&\
+	    echo $(COPY) $(ZLIBSRC)/$$f $@ &&\
+	    $(COPY) $(ZLIBSRC)/$$f $@ && exit 0;\
+	done; echo copy: $(ZLIBSRC)/zconf.h not found; exit 1
+
+pnm2pngm.c: $(PROGSRC)/pnm2png.c
+	$(RM) $@
+	$(COPY) $(PROGSRC)/pnm2png.c $@
+
+# End of makefile for pnm2pngm
diff --git a/Engine/lib/lpng/contrib/pngminim/encoder/pngusr.dfa b/Engine/lib/lpng/contrib/pngminim/encoder/pngusr.dfa
new file mode 100644
index 000000000..1fc24f3f2
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngminim/encoder/pngusr.dfa
@@ -0,0 +1,39 @@
+# pngminim/encoder/pngusr.dfa
+#
+# Copyright (c) 2010-2013 Glenn Randers-Pehrson
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# First all the build options off:
+
+everything = off
+
+# Switch on the write code - this makes a minimalist encoder
+
+option WRITE on
+
+# These 2 options are required if you need to read PBM (P1 or P4) files.
+option WRITE_INVERT on
+option WRITE_PACK on
+
+# You must choose fixed or floating point arithmetic:
+# option FLOATING_POINT on
+
+option FIXED_POINT on
+
+# You must chose the internal fixed point implementation or to
+# use the system floating point.  The latter is considerably
+# smaller (by about 1kbyte on an x86 system):
+# option FLOATING_ARITHMETIC on
+
+option FLOATING_ARITHMETIC off
+
+# Your program will probably need other options.  The example
+# program here, pnm2pngm, requires the following.  Take a look
+# at pnglibconf.h to find out the full set of what has to be
+# enabled to make the following work.
+
+option SETJMP on
+option STDIO on
diff --git a/Engine/lib/lpng/contrib/pngminim/encoder/pngusr.h b/Engine/lib/lpng/contrib/pngminim/encoder/pngusr.h
new file mode 100644
index 000000000..997d44fe9
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngminim/encoder/pngusr.h
@@ -0,0 +1,23 @@
+/* minwrpngconf.h: headers to make a minimal png-write-only library
+ *
+ * Copyright (c) 2007, 2010-2013 Glenn Randers-Pehrson
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * Derived from pngcrush.h, Copyright 1998-2007, Glenn Randers-Pehrson
+ */
+
+#ifndef MINWRPNGCONF_H
+#define MINWRPNGCONF_H
+
+/* To include pngusr.h set -DPNG_USER_CONFIG in CPPFLAGS */
+
+/* List options to turn off features of the build that do not
+ * affect the API (so are not recorded in pnglibconf.h)
+ */
+
+#define PNG_ALIGN_TYPE PNG_ALIGN_NONE
+
+#endif /* MINWRPNGCONF_H */
diff --git a/Engine/lib/lpng/contrib/pngminim/preader/README b/Engine/lib/lpng/contrib/pngminim/preader/README
new file mode 100644
index 000000000..faa83560a
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngminim/preader/README
@@ -0,0 +1,15 @@
+This demonstrates the use of PNG_USER_CONFIG and pngusr.h
+
+The makefile builds a minimal read-only progressive decoder with
+embedded libpng, zlib and your system's X library.
+
+Specify the location of the zlib source (1.2.1 or later) as ZLIBSRC
+on the make command line.
+
+Edit makefile if required, to find your X library and include files,
+then
+
+    make ZLIBSRC=directory
+
+If you prefer to use the shared libraries, go to contrib/gregbook
+and build the rpng2-x application there.
diff --git a/Engine/lib/lpng/contrib/pngminim/preader/makefile b/Engine/lib/lpng/contrib/pngminim/preader/makefile
new file mode 100644
index 000000000..b62519911
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngminim/preader/makefile
@@ -0,0 +1,166 @@
+# Makefile for PngMinus (rpng2)
+# Linux / Unix
+
+#CC=cc
+CC=gcc
+LD=$(CC)
+
+# If awk fails try
+# make AWK=nawk
+
+# If cpp fails try
+# make CPP=/lib/cpp
+
+RM=rm -f
+COPY=cp
+
+#XINC = -I/usr/include			# old-style, stock X distributions
+#XLIB = -L/usr/lib/X11 -lX11		#  (including SGI IRIX)
+
+#XINC = -I/usr/openwin/include		# Sun workstations (OpenWindows)
+#XLIB = -L/usr/openwin/lib -lX11
+
+XINC = -I/usr/X11R6/include		# new X distributions (X.org, etc.)
+XLIB = -L/usr/X11R6/lib -lX11
+#XLIB = -L/usr/X11R6/lib64 -lX11	# e.g., Red Hat on AMD64
+
+#XINC = -I/usr/local/include   		# FreeBSD
+#XLIB = -L/usr/local/lib -lX11
+
+#LIBS = $(XLIB)
+LIBS = $(XLIB) -lm                      #platforms that need libm
+
+CPPFLAGS=-I. $(XINC) -DPNG_USER_CONFIG -DNO_GZCOMPRESS -DZ_SOLO -DNO_GZIP
+CFLAGS=-O1 -Wall
+
+C=.c
+O=.o
+L=.a
+E=
+
+# Where to find the source code:
+PNGSRC =../../..
+ZLIBSRC=$(PNGSRC)/../zlib
+PROGSRC=$(PNGSRC)/contrib/gregbook
+
+# Zlib (minimal inflate requirements - crc32 is used by libpng)
+# zutil can be eliminated if you provide your own zcalloc and zcfree
+ZSRCS  = adler32$(C) crc32$(C) \
+	 inffast$(C) inflate$(C) inftrees$(C) \
+	 zutil$(C)
+
+# Standard headers
+ZH     = zlib.h crc32.h inffast.h inffixed.h \
+	 inflate.h inftrees.h zutil.h
+
+# Machine generated headers
+ZCONF  = zconf.h
+
+# Headers callers use
+ZINC   = zlib.h $(ZCONF)
+
+# Headers the Zlib source uses
+ZHDRS  = $(ZH) $(ZCONF)
+
+ZOBJS  = adler32$(O) crc32$(O) \
+	 inffast$(O) inflate$(O) inftrees$(O) \
+	 zutil$(O)
+
+# libpng
+PNGSRCS=png$(C) pngerror$(C) pngget$(C) pngmem$(C) \
+	pngpread$(C) pngread$(C) pngrio$(C) pngrtran$(C) pngrutil$(C) \
+	pngset$(C) pngtrans$(C)
+
+# Standard headers
+PNGH   =png.h pngconf.h pngdebug.h pnginfo.h pngpriv.h pngstruct.h
+
+# Machine generated headers
+PNGCONF=pnglibconf.h
+
+# Headers callers use
+PNGINC= png.h pngconf.h pngusr.h $(PNGCONF)
+
+# Headers the PNG library uses
+PNGHDRS=$(PNGH) $(PNGCONF) pngusr.h
+
+PNGOBJS=png$(O) pngerror$(O) pngget$(O) pngmem$(O) \
+	pngpread$(O) pngread$(O) pngrio$(O) pngrtran$(O) pngrutil$(O) \
+	pngset$(O) pngtrans$(O)
+
+PROGSRCS= rpng2-x$(C) readpng2$(C)
+PROGHDRS= readpng2.h
+PROGDOCS= COPYING LICENSE
+PROGOBJS= rpng2-x$(O) readpng2$(O)
+
+OBJS    = $(PROGOBJS) $(PNGOBJS) $(ZOBJS)
+
+# implicit make rules -------------------------------------------------------
+
+.c$(O):
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) $<
+
+# dependencies
+
+all: $(PROGDOCS) rpng2-x$(E)
+
+rpng2-x$(E): $(OBJS)
+	$(LD) -o rpng2-x$(E) $(OBJS) $(LIBS)
+
+# The DFA_XTRA setting turns all libpng options off then
+# turns on those required for this minimal build.
+# The CPP_FLAGS setting causes pngusr.h to be included in
+# both the build of pnglibconf.h and, subsequently, when
+# building libpng itself.
+$(PNGCONF): $(PNGSRC)/scripts/pnglibconf.mak $(ZH)\
+	$(PNGSRC)/scripts/pnglibconf.dfa \
+	$(PNGSRC)/scripts/options.awk pngusr.h pngusr.dfa
+	$(RM) pnglibconf.h pnglibconf.dfn
+	$(MAKE) -f $(PNGSRC)/scripts/pnglibconf.mak $(MAKEFLAGS)\
+	    srcdir=$(PNGSRC) CPPFLAGS="-DPNG_USER_CONFIG -I."\
+	    DFA_XTRA="pngusr.dfa" $@
+
+clean:
+	$(MAKE) -f $(PNGSRC)/scripts/pnglibconf.mak $(MAKEFLAGS)\
+	    srcdir=$(PNGSRC) clean
+	$(RM) rpng2-x$(O)
+	$(RM) rpng2-x$(E)
+	$(RM) $(OBJS)
+
+# distclean also removes the copied source and headers
+distclean: clean
+	$(RM) -r scripts # historical reasons
+	$(RM) $(PNGSRCS) $(PNGH)
+	$(RM) $(ZSRCS) $(ZH) $(ZCONF)
+	$(RM) $(PROGSRCS) $(PROGHDRS) $(PROGDOCS)
+
+# Header file dependencies:
+$(PROGOBJS): $(PROGHDRS) $(PNGINC) $(ZINC)
+$(PNGOBJS): $(PNGHDRS) $(ZINC)
+$(ZOBJS): $(ZHDRS)
+
+# Gather the source code from the respective directories
+$(PNGSRCS) $(PNGH): $(PNGSRC)/$@
+	$(RM) $@
+	$(COPY) $(PNGSRC)/$@ $@
+
+# No dependency on the ZLIBSRC target so that it only needs
+# to be specified once.
+$(ZSRCS) $(ZH):
+	$(RM) $@
+	$(COPY) $(ZLIBSRC)/$@ $@
+
+# The unconfigured zconf.h varies in name according to the
+# zlib release
+$(ZCONF):
+	$(RM) $@
+	@for f in zconf.h.in zconf.in.h zconf.h; do\
+	    test -r $(ZLIBSRC)/$$f &&\
+	    echo $(COPY) $(ZLIBSRC)/$$f $@ &&\
+	    $(COPY) $(ZLIBSRC)/$$f $@ && exit 0;\
+	done; echo copy: $(ZLIBSRC)/zconf.h not found; exit 1
+
+$(PROGSRCS) $(PROGHDRS) $(PROGDOCS): $(PROGSRC)/$@
+	$(RM) $@
+	$(COPY) $(PROGSRC)/$@ $@
+
+# End of makefile for rpng2-x
diff --git a/Engine/lib/lpng/contrib/pngminim/preader/pngusr.dfa b/Engine/lib/lpng/contrib/pngminim/preader/pngusr.dfa
new file mode 100644
index 000000000..ac297f41b
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngminim/preader/pngusr.dfa
@@ -0,0 +1,40 @@
+# pngminim/preader/pngusr.dfa
+#
+# Copyright (c) 2010-2013 Glenn Randers-Pehrson
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# First all the build options off:
+
+everything = off
+
+# Just switch on the progressive read code
+
+option PROGRESSIVE_READ on
+
+# You may choose fixed or floating point APIs:
+# option FLOATING_POINT on
+
+option FIXED_POINT on
+
+# You must chose the internal fixed point implementation or to
+# use the system floating point.  The latter is considerably
+# smaller (by about 1kbyte on an x86 system):
+
+option FLOATING_ARITHMETIC on
+# option FLOATING_ARITHMETIC off
+
+# Your program will probably need other options.  The example
+# program here, rpng2-x, requires the following.  Take a look
+# at pnglibconf.h to find out the full set of what has to be
+# enabled to make the following work.
+
+option SETJMP on
+option STDIO on
+option READ_bKGD on
+option READ_GAMMA on
+option READ_EXPAND on
+option READ_STRIP_16_TO_8 on
+option READ_GRAY_TO_RGB on
diff --git a/Engine/lib/lpng/contrib/pngminim/preader/pngusr.h b/Engine/lib/lpng/contrib/pngminim/preader/pngusr.h
new file mode 100644
index 000000000..80db3bb17
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngminim/preader/pngusr.h
@@ -0,0 +1,23 @@
+/* minrdpngconf.h: headers to make a minimal png-read-only library
+ *
+ * Copyright (c) 2009, 2010-2013 Glenn Randers-Pehrson
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * Derived from pngcrush.h, Copyright 1998-2007, Glenn Randers-Pehrson
+ */
+
+#ifndef MINPRDPNGCONF_H
+#define MINPRDPNGCONF_H
+
+/* To include pngusr.h set -DPNG_USER_CONFIG in CPPFLAGS */
+
+/* List options to turn off features of the build that do not
+ * affect the API (so are not recorded in pnglibconf.h)
+ */
+
+#define PNG_ALIGN_TYPE PNG_ALIGN_NONE
+
+#endif /* MINPRDPNGCONF_H */
diff --git a/Engine/lib/lpng/contrib/pngminus/CHANGES.txt b/Engine/lib/lpng/contrib/pngminus/CHANGES.txt
new file mode 100644
index 000000000..4e64e5ee6
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngminus/CHANGES.txt
@@ -0,0 +1,13 @@
+
+pnm2png / png2pnm --- conversion from PBM/PGM/PPM-file to PNG-file
+copyright (C) 1999-2019 by Willem van Schaik <willem at schaik dot com>
+
+version 1.0 - 1999.10.15 - First version.
+        1.1 - 2015.07.29 - Fixed leaks (Glenn Randers-Pehrson)
+        1.2 - 2017.04.22 - Add buffer-size check
+        1.3 - 2017.08.24 - Fix potential overflow in buffer-size check
+                           (Glenn Randers-Pehrson)
+        1.4 - 2017.08.28 - Add PNGMINUS_UNUSED (Christian Hesse)
+        1.5 - 2018.08.05 - Fix buffer overflow in tokenizer (Cosmin Truta)
+        1.6 - 2018.08.05 - Improve portability and fix style (Cosmin Truta)
+        1.7 - 2019.01.22 - Change license to MIT (Willem van Schaik)
diff --git a/Engine/lib/lpng/contrib/pngminus/CMakeLists.txt b/Engine/lib/lpng/contrib/pngminus/CMakeLists.txt
new file mode 100644
index 000000000..1f815a582
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngminus/CMakeLists.txt
@@ -0,0 +1,24 @@
+cmake_minimum_required(VERSION 3.1)
+cmake_policy(VERSION 3.1)
+
+project(PNGMINUS C)
+
+option(PNGMINUS_USE_STATIC_LIBRARIES "Use the static library builds" ON)
+
+# libpng
+add_subdirectory(../.. libpng)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../..)
+include_directories(${CMAKE_CURRENT_BINARY_DIR}/libpng)
+if(PNGMINUS_USE_STATIC_LIBRARIES)
+  set(PNGMINUS_PNG_LIBRARY png_static)
+else()
+  set(PNGMINUS_PNG_LIBRARY png)
+endif()
+
+# png2pnm
+add_executable(png2pnm png2pnm.c)
+target_link_libraries(png2pnm ${PNGMINUS_PNG_LIBRARY})
+
+# pnm2png
+add_executable(pnm2png pnm2png.c)
+target_link_libraries(pnm2png ${PNGMINUS_PNG_LIBRARY})
diff --git a/Engine/lib/lpng/contrib/pngminus/LICENSE.txt b/Engine/lib/lpng/contrib/pngminus/LICENSE.txt
new file mode 100644
index 000000000..00878a9a6
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngminus/LICENSE.txt
@@ -0,0 +1,22 @@
+
+pnm2png / png2pnm --- conversion from PBM/PGM/PPM-file to PNG-file
+
+copyright (C) 1999-2019 by Willem van Schaik <willem at schaik dot com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+The software is provided "as is", without warranty of any kind, express or
+implied, including but not limited to the warranties of merchantability,
+fitness for a particular purpose and noninfringement. In no event shall the
+authors or copyight holders be liable for any claim, damages or other
+liability, whether in an action of contract, tort or otherwise, arising from,
+out of or in connection with the software or the use or other dealings in the
+software.
diff --git a/Engine/lib/lpng/contrib/pngminus/Makefile b/Engine/lib/lpng/contrib/pngminus/Makefile
new file mode 100644
index 000000000..4bba07961
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngminus/Makefile
@@ -0,0 +1,62 @@
+# Makefile for PngMinus (png2pnm and pnm2png)
+# Linux / Unix
+
+#CC = cc
+CC = gcc
+LD = $(CC)
+
+RM = rm -f
+
+PNGINC = -I../..
+PNGLIB_SHARED = -L../.. -lpng
+PNGLIB_STATIC = ../../libpng.a
+
+# Uncomment the following if you have a custom zlib build at ../../../zlib
+#ZINC = -I../../../zlib
+#ZLIB_SHARED = -L../../../zlib -lz
+#ZLIB_STATIC = ../../../zlib/libz.a
+
+# Use the system zlib otherwise
+ZLIB_SHARED = -lz
+ZLIB_STATIC = -lz
+
+CPPFLAGS = $(PNGINC) $(ZINC)
+CFLAGS =
+LDFLAGS =
+LIBS_SHARED = $(PNGLIB_SHARED) $(ZLIB_SHARED)
+LIBS_STATIC = $(PNGLIB_STATIC) $(ZLIB_STATIC)
+
+EXEEXT =
+#EXEEXT = .exe
+
+# dependencies
+
+all: png2pnm$(EXEEXT) pnm2png$(EXEEXT) png2pnm-static$(EXEEXT) pnm2png-static$(EXEEXT)
+
+png2pnm.o: png2pnm.c
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) png2pnm.c
+
+pnm2png.o: pnm2png.c
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) pnm2png.c
+
+png2pnm$(EXEEXT): png2pnm.o
+	$(LD) $(LDFLAGS) -o png2pnm$(EXEEXT) png2pnm.o $(LIBS_SHARED) -lm
+
+pnm2png$(EXEEXT): pnm2png.o
+	$(LD) $(LDFLAGS) -o pnm2png$(EXEEXT) pnm2png.o $(LIBS_SHARED) -lm
+
+png2pnm-static$(EXEEXT): png2pnm.o
+	$(LD) $(LDFLAGS) -o png2pnm-static$(EXEEXT) png2pnm.o $(LIBS_STATIC) -lm
+
+pnm2png-static$(EXEEXT): pnm2png.o
+	$(LD) $(LDFLAGS) -o pnm2png-static$(EXEEXT) pnm2png.o $(LIBS_STATIC) -lm
+
+clean:
+	$(RM) png2pnm.o
+	$(RM) pnm2png.o
+	$(RM) png2pnm$(EXEEXT)
+	$(RM) pnm2png$(EXEEXT)
+	$(RM) png2pnm-static$(EXEEXT)
+	$(RM) pnm2png-static$(EXEEXT)
+
+# End of makefile for png2pnm / pnm2png
diff --git a/Engine/lib/lpng/contrib/pngminus/README.txt b/Engine/lib/lpng/contrib/pngminus/README.txt
new file mode 100644
index 000000000..f7f6ecb3a
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngminus/README.txt
@@ -0,0 +1,120 @@
+PngMinus
+--------
+(copyright Willem van Schaik, 1999-2019)
+
+
+
+Some history
+------------
+Soon after the creation of PNG in 1995, the need was felt for a set of
+pnmtopng / pngtopnm utilities. Independently Alexander Lehmann and I
+(Willem van Schaik) started such a project. Luckily we discovered this
+and merged the two, which later became part of NetPBM, available from
+SourceForge.
+
+These two utilities have many, many options and make use of most of the
+features of PNG, like gamma, alpha, sbit, text-chunks, etc. This makes
+the utilities quite complex and by now not anymore very maintainable.
+When we wrote these programs, libpng was still in an early stage.
+Therefore, lots of the functionality that we put in our software can now
+be done using transform-functions in libpng.
+
+Finally, to compile these programs, you need to have installed and
+compiled three libraries: libpng, zlib and netpbm. Especially the latter
+makes the whole setup a bit bulky. But that's unavoidable given the many
+features of pnmtopng.
+
+
+What now (1999)
+---------------
+At this moment libpng is in a very stable state and can do much of the
+work done in pnmtopng. Also, pnmtopng needs to be upgraded to the new
+interface of libpng. Hence, it is time for a rewrite from the ground up
+of pnmtopng and pngtopnm. This will happen in the near future (stay
+tuned). The new package will get a different name to distinguish it from
+the old one: PngPlus.
+
+To experiment a bit with the new interface of libpng, I started off with
+a small prototype that contains only the basic functionality. It doesn't
+have any of the options to read or write special chunks and it will do
+no gamma correction. But this makes it also a simple program that is
+quite easy to understand and can serve well as a template for other
+software developments. By now there are of course a couple of programs,
+like Greg Roelofs' rpng/wpng, that can be used just as good.
+
+
+Can and can not
+---------------
+As this is the small brother of the future PngPlus, I called this fellow
+PngMinus. Because I started this development in good-old Turbo-C, I
+avoided the use the netpbm library, which requires DOS extenders. Again,
+another reason to call it PngMinus (minus netpbm :-). So, part of the
+program are some elementary routines to read / write pgm- and ppm-files.
+It does not handle B&W pbm-files, but instead you could do pgm with bit-
+depth 1.
+
+The downside of this approach is that you can not use them on images
+that require blocks of memory bigger than 64k (the DOS version). For
+larger images you will get an out-of-memory error.
+
+As said before, PngMinus doesn't correct for gamma. When reading
+png-files you can do this just as well by piping the output of png2pnm
+to pnmgamma, one of the standard PbmPlus tools. This same scenario will
+most probably also be followed in the full-blown future PngPlus, with
+the addition of course of the possibility to create gamma-chunks when
+writing png-files.
+
+On the other hand it supports alpha-channels. When reading a png-image
+you can write the alpha-channel into a pgm-file. And when creating an
+RGB+A png-image, you just combine a ppm-file with a corresponding
+pgm-file containing the alpha-channel. When reading, transparency chunks
+are converted into an alpha-channel and from there on treated the same
+way.
+
+Finally you can opt for writing ascii or binary pgm- and ppm-files. When
+the bit-depth is 16, the format will always be ascii.
+
+
+Using it
+--------
+To distinguish them from pnmtopng and PngPlus, the utilities are named
+png2pnm and pnm2png (2 instead of to). The input- and output-files can
+be given as parameters or through redirection. Therefore the programs
+can be part of a pipe.
+
+To list the options type "png2pnm -h" or "pnm2png -h".
+
+
+Just like Scandinavian furniture
+--------------------------------
+You have to put it together yourself. I developed the software on MS-DOS
+with Turbo-C 3.0 and RedHat Linux 4.2 with gcc. In both cases I used
+libpng-1.0.4 and zlib-1.1.3. By now (2019) it is twenty years later and
+more current versions are OK.
+
+The makefile assumes that the libpng libraries can be found in ../.. and
+libz in ../../../zlib. But you can change this to for example ../libpng
+and ../zlib. The makefile creates two versions of each program, one with
+static library support and the other using shared libraries.
+
+If you create a ../pngsuite directory and then store the basn####.png
+files from PngSuite (http://www.schaik.com/pngsuite/) in there, you can
+test the proper functioning of PngMinus by running pngminus.sh.
+
+
+Warranty
+-------
+Please, remember that this was just a small experiment to learn a few
+things. It will have many unforeseen features <vbg> ... who said bugs? Use
+it when you are in need for something simple or when you want a starting
+point for developing your own stuff.
+
+
+The end
+-------
+Willem van Schaik
+mailto:willem at schaik dot com
+http://www.schaik.com/png/
+
+Oct 1999, Jan 2019
+
diff --git a/Engine/lib/lpng/contrib/pngminus/makevms.com b/Engine/lib/lpng/contrib/pngminus/makevms.com
new file mode 100644
index 000000000..00561bcd0
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngminus/makevms.com
@@ -0,0 +1,92 @@
+$!------------------------------------------------------------------------------
+$! make Contrib programs of libpng under OpenVMS
+$!
+$!
+$! Look for the compiler used
+$!
+$ zlibsrc = "[---.zlib]"
+$ ccopt="/include=(''zlibsrc',[--])"
+$ if f$getsyi("HW_MODEL").ge.1024
+$ then
+$  ccopt = "/prefix=all"+ccopt
+$  comp  = "__decc__=1"
+$  if f$trnlnm("SYS").eqs."" then define sys sys$library:
+$ else
+$  if f$search("SYS$SYSTEM:DECC$COMPILER.EXE").eqs.""
+$   then
+$    if f$trnlnm("SYS").eqs."" then define sys sys$library:
+$    if f$search("SYS$SYSTEM:VAXC.EXE").eqs.""
+$     then
+$      comp  = "__gcc__=1"
+$      CC :== GCC
+$     else
+$      comp = "__vaxc__=1"
+$     endif
+$   else
+$    if f$trnlnm("SYS").eqs."" then define sys decc$library_include:
+$    ccopt = "/decc/prefix=all"+ccopt
+$    comp  = "__decc__=1"
+$  endif
+$ endif
+$ open/write lopt lib.opt
+$ write lopt "[--]libpng.olb/lib"
+$ write lopt "''zlibsrc'libz.olb/lib"
+$ close lopt
+$ open/write xopt x11.opt
+$ write xopt "sys$library:decw$xlibshr.exe/share"
+$ close xopt
+$ write sys$output "Compiling PNG contrib programs ..."
+$   write sys$output "Building pnm2png..."
+$   CALL MAKE pnm2png.OBJ "cc ''CCOPT' pnm2png" -
+	pnm2png.c
+$   call make pnm2png.exe -
+	"LINK pnm2png,lib.opt/opt" -
+	pnm2png.obj
+$   write sys$output "Building png2pnm..."
+$   CALL MAKE png2pnm.OBJ "cc ''CCOPT' png2pnm" -
+	png2pnm.c
+$   call make png2pnm.exe -
+	"LINK png2pnm,lib.opt/opt" -
+	png2pnm.obj
+$ exit
+$!
+$!
+$MAKE: SUBROUTINE   !SUBROUTINE TO CHECK DEPENDENCIES
+$ V = 'F$Verify(0)
+$! P1 = What we are trying to make
+$! P2 = Command to make it
+$! P3 - P8  What it depends on
+$
+$ If F$Search(P1) .Eqs. "" Then Goto Makeit
+$ Time = F$CvTime(F$File(P1,"RDT"))
+$arg=3
+$Loop:
+$       Argument = P'arg
+$       If Argument .Eqs. "" Then Goto Exit
+$       El=0
+$Loop2:
+$       File = F$Element(El," ",Argument)
+$       If File .Eqs. " " Then Goto Endl
+$       AFile = ""
+$Loop3:
+$       OFile = AFile
+$       AFile = F$Search(File)
+$       If AFile .Eqs. "" .Or. AFile .Eqs. OFile Then Goto NextEl
+$       If F$CvTime(F$File(AFile,"RDT")) .Ges. Time Then Goto Makeit
+$       Goto Loop3
+$NextEL:
+$       El = El + 1
+$       Goto Loop2
+$EndL:
+$ arg=arg+1
+$ If arg .Le. 8 Then Goto Loop
+$ Goto Exit
+$
+$Makeit:
+$ VV=F$VERIFY(0)
+$ write sys$output P2
+$ 'P2
+$ VV='F$Verify(VV)
+$Exit:
+$ If V Then Set Verify
+$ENDSUBROUTINE
diff --git a/Engine/lib/lpng/contrib/pngminus/png2pnm.bat b/Engine/lib/lpng/contrib/pngminus/png2pnm.bat
new file mode 100755
index 000000000..a2798c340
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngminus/png2pnm.bat
@@ -0,0 +1,41 @@
+REM -- grayscale
+png2pnm.exe -noraw ..\pngsuite\basn0g01.png basn0g01.pgm
+png2pnm.exe -noraw ..\pngsuite\basn0g02.png basn0g02.pgm
+png2pnm.exe -noraw ..\pngsuite\basn0g04.png basn0g04.pgm
+png2pnm.exe -noraw ..\pngsuite\basn0g08.png basn0g08.pgm
+png2pnm.exe -noraw ..\pngsuite\basn0g16.png basn0g16.pgm
+REM -- full-color
+png2pnm.exe -noraw ..\pngsuite\basn2c08.png basn2c08.ppm
+png2pnm.exe -noraw ..\pngsuite\basn2c16.png basn2c16.ppm
+REM -- paletted
+png2pnm.exe -noraw ..\pngsuite\basn3p01.png basn3p01.ppm
+png2pnm.exe -noraw ..\pngsuite\basn3p02.png basn3p02.ppm
+png2pnm.exe -noraw ..\pngsuite\basn3p04.png basn3p04.ppm
+png2pnm.exe -noraw ..\pngsuite\basn3p08.png basn3p08.ppm
+REM -- gray with alpha-channel
+png2pnm.exe -noraw ..\pngsuite\basn4a08.png basn4a08.pgm
+png2pnm.exe -noraw ..\pngsuite\basn4a16.png basn4a16.pgm
+REM -- color with alpha-channel
+png2pnm.exe -noraw -alpha basn6a08.pgm ..\pngsuite\basn6a08.png basn6a08.ppm
+png2pnm.exe -noraw -alpha basn6a16.pgm ..\pngsuite\basn6a16.png basn6a16.ppm
+REM -- grayscale
+png2pnm.exe -raw ..\pngsuite\basn0g01.png rawn0g01.pgm
+png2pnm.exe -raw ..\pngsuite\basn0g02.png rawn0g02.pgm
+png2pnm.exe -raw ..\pngsuite\basn0g04.png rawn0g04.pgm
+png2pnm.exe -raw ..\pngsuite\basn0g08.png rawn0g08.pgm
+png2pnm.exe -raw ..\pngsuite\basn0g16.png rawn0g16.pgm
+REM -- full-color
+png2pnm.exe -raw ..\pngsuite\basn2c08.png rawn2c08.ppm
+png2pnm.exe -raw ..\pngsuite\basn2c16.png rawn2c16.ppm
+REM -- paletted
+png2pnm.exe -raw ..\pngsuite\basn3p01.png rawn3p01.ppm
+png2pnm.exe -raw ..\pngsuite\basn3p02.png rawn3p02.ppm
+png2pnm.exe -raw ..\pngsuite\basn3p04.png rawn3p04.ppm
+png2pnm.exe -raw ..\pngsuite\basn3p08.png rawn3p08.ppm
+REM -- gray with alpha-channel
+png2pnm.exe -raw ..\pngsuite\basn4a08.png rawn4a08.pgm
+png2pnm.exe -raw ..\pngsuite\basn4a16.png rawn4a16.pgm
+REM -- color with alpha-channel
+png2pnm.exe -noraw -alpha rawn6a08.pgm ..\pngsuite\basn6a08.png rawn6a08.ppm
+png2pnm.exe -noraw -alpha rawn6a16.pgm ..\pngsuite\basn6a16.png rawn6a16.ppm
+
diff --git a/Engine/lib/lpng/contrib/pngminus/png2pnm.c b/Engine/lib/lpng/contrib/pngminus/png2pnm.c
new file mode 100644
index 000000000..5fef7ed14
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngminus/png2pnm.c
@@ -0,0 +1,427 @@
+/*
+ *  png2pnm.c --- conversion from PNG-file to PGM/PPM-file
+ *  copyright (C) 1999-2019 by Willem van Schaik <willem at schaik dot com>
+ *
+ *  This software is released under the MIT license. For conditions of
+ *  distribution and use, see the LICENSE file part of this package.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+
+#ifndef BOOL
+#define BOOL unsigned char
+#endif
+#ifndef TRUE
+#define TRUE (BOOL) 1
+#endif
+#ifndef FALSE
+#define FALSE (BOOL) 0
+#endif
+
+/* make png2pnm verbose so we can find problems (needs to be before png.h) */
+#ifndef PNG_DEBUG
+#define PNG_DEBUG 0
+#endif
+
+#include "png.h"
+
+/* function prototypes */
+
+int main (int argc, char *argv[]);
+void usage ();
+BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file,
+              BOOL raw, BOOL alpha);
+
+/*
+ *  main
+ */
+
+int main (int argc, char *argv[])
+{
+  FILE *fp_rd = stdin;
+  FILE *fp_wr = stdout;
+  FILE *fp_al = NULL;
+  BOOL raw = TRUE;
+  BOOL alpha = FALSE;
+  int argi;
+
+  for (argi = 1; argi < argc; argi++)
+  {
+    if (argv[argi][0] == '-')
+    {
+      switch (argv[argi][1])
+      {
+        case 'n':
+          raw = FALSE;
+          break;
+        case 'r':
+          raw = TRUE;
+          break;
+        case 'a':
+          alpha = TRUE;
+          argi++;
+          if ((fp_al = fopen (argv[argi], "wb")) == NULL)
+          {
+            fprintf (stderr, "PNM2PNG\n");
+            fprintf (stderr, "Error:  cannot create alpha-channel file %s\n",
+                     argv[argi]);
+            exit (1);
+          }
+          break;
+        case 'h':
+        case '?':
+          usage ();
+          exit (0);
+          break;
+        default:
+          fprintf (stderr, "PNG2PNM\n");
+          fprintf (stderr, "Error:  unknown option %s\n", argv[argi]);
+          usage ();
+          exit (1);
+          break;
+      } /* end switch */
+    }
+    else if (fp_rd == stdin)
+    {
+      if ((fp_rd = fopen (argv[argi], "rb")) == NULL)
+      {
+        fprintf (stderr, "PNG2PNM\n");
+        fprintf (stderr, "Error:  file %s does not exist\n", argv[argi]);
+        exit (1);
+      }
+    }
+    else if (fp_wr == stdout)
+    {
+      if ((fp_wr = fopen (argv[argi], "wb")) == NULL)
+      {
+        fprintf (stderr, "PNG2PNM\n");
+        fprintf (stderr, "Error:  cannot create file %s\n", argv[argi]);
+        exit (1);
+      }
+    }
+    else
+    {
+      fprintf (stderr, "PNG2PNM\n");
+      fprintf (stderr, "Error:  too many parameters\n");
+      usage ();
+      exit (1);
+    }
+  } /* end for */
+
+#if defined(O_BINARY) && (O_BINARY != 0)
+  /* set stdin/stdout if required to binary */
+  if (fp_rd == stdin)
+    setmode (fileno (stdin), O_BINARY);
+  if ((raw) && (fp_wr == stdout))
+    setmode (fileno (stdout), O_BINARY);
+#endif
+
+  /* call the conversion program itself */
+  if (png2pnm (fp_rd, fp_wr, fp_al, raw, alpha) == FALSE)
+  {
+    fprintf (stderr, "PNG2PNM\n");
+    fprintf (stderr, "Error:  unsuccessful conversion of PNG-image\n");
+    exit (1);
+  }
+
+  /* close input file */
+  fclose (fp_rd);
+  /* close output file */
+  fclose (fp_wr);
+  /* close alpha file */
+  if (alpha)
+    fclose (fp_al);
+
+  return 0;
+}
+
+/*
+ *  usage
+ */
+
+void usage ()
+{
+  fprintf (stderr, "PNG2PNM\n");
+  fprintf (stderr, "   by Willem van Schaik, 1999\n");
+  fprintf (stderr, "Usage:  png2pnm [options] <file>.png [<file>.pnm]\n");
+  fprintf (stderr, "   or:  ... | png2pnm [options]\n");
+  fprintf (stderr, "Options:\n");
+  fprintf (stderr,
+      "   -r[aw]   write pnm-file in binary format (P4/P5/P6) (default)\n");
+  fprintf (stderr, "   -n[oraw] write pnm-file in ascii format (P1/P2/P3)\n");
+  fprintf (stderr,
+      "   -a[lpha] <file>.pgm write PNG alpha channel as pgm-file\n");
+  fprintf (stderr, "   -h | -?  print this help-information\n");
+}
+
+/*
+ *  png2pnm
+ */
+
+BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file,
+              BOOL raw, BOOL alpha)
+{
+  png_struct    *png_ptr = NULL;
+  png_info      *info_ptr = NULL;
+  png_byte      buf[8];
+  png_byte      *png_pixels = NULL;
+  png_byte      **row_pointers = NULL;
+  png_byte      *pix_ptr = NULL;
+  png_uint_32   row_bytes;
+
+  png_uint_32   width;
+  png_uint_32   height;
+  int           bit_depth;
+  int           channels;
+  int           color_type;
+  int           alpha_present;
+  int           row, col;
+  int           ret;
+  int           i;
+  long          dep_16;
+
+  /* read and check signature in PNG file */
+  ret = fread (buf, 1, 8, png_file);
+  if (ret != 8)
+    return FALSE;
+
+  ret = png_sig_cmp (buf, 0, 8);
+  if (ret != 0)
+    return FALSE;
+
+  /* create png and info structures */
+
+  png_ptr = png_create_read_struct (png_get_libpng_ver(NULL),
+                                    NULL, NULL, NULL);
+  if (!png_ptr)
+    return FALSE; /* out of memory */
+
+  info_ptr = png_create_info_struct (png_ptr);
+  if (!info_ptr)
+  {
+    png_destroy_read_struct (&png_ptr, NULL, NULL);
+    return FALSE; /* out of memory */
+  }
+
+  if (setjmp (png_jmpbuf (png_ptr)))
+  {
+    png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
+    return FALSE;
+  }
+
+  /* set up the input control for C streams */
+  png_init_io (png_ptr, png_file);
+  png_set_sig_bytes (png_ptr, 8); /* we already read the 8 signature bytes */
+
+  /* read the file information */
+  png_read_info (png_ptr, info_ptr);
+
+  /* get size and bit-depth of the PNG-image */
+  png_get_IHDR (png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
+                NULL, NULL, NULL);
+
+  /* set-up the transformations */
+
+  /* transform paletted images into full-color rgb */
+  if (color_type == PNG_COLOR_TYPE_PALETTE)
+    png_set_expand (png_ptr);
+  /* expand images to bit-depth 8 (only applicable for grayscale images) */
+  if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
+    png_set_expand (png_ptr);
+  /* transform transparency maps into full alpha-channel */
+  if (png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS))
+    png_set_expand (png_ptr);
+
+#ifdef NJET
+  /* downgrade 16-bit images to 8-bit */
+  if (bit_depth == 16)
+    png_set_strip_16 (png_ptr);
+  /* transform grayscale images into full-color */
+  if (color_type == PNG_COLOR_TYPE_GRAY ||
+      color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+    png_set_gray_to_rgb (png_ptr);
+  /* only if file has a file gamma, we do a correction */
+  if (png_get_gAMA (png_ptr, info_ptr, &file_gamma))
+    png_set_gamma (png_ptr, (double) 2.2, file_gamma);
+#endif
+
+  /* all transformations have been registered; now update info_ptr data,
+   * get rowbytes and channels, and allocate image memory */
+
+  png_read_update_info (png_ptr, info_ptr);
+
+  /* get the new color-type and bit-depth (after expansion/stripping) */
+  png_get_IHDR (png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
+                NULL, NULL, NULL);
+
+  /* check for 16-bit files */
+  if (bit_depth == 16)
+  {
+    raw = FALSE;
+#if defined(O_BINARY) && (O_BINARY != 0)
+    setmode (fileno (pnm_file), O_BINARY);
+#endif
+  }
+
+  /* calculate new number of channels and store alpha-presence */
+  if (color_type == PNG_COLOR_TYPE_GRAY)
+    channels = 1;
+  else if (color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+    channels = 2;
+  else if (color_type == PNG_COLOR_TYPE_RGB)
+    channels = 3;
+  else if (color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+    channels = 4;
+  else
+    channels = 0; /* should never happen */
+  alpha_present = (channels - 1) % 2;
+
+  /* check if alpha is expected to be present in file */
+  if (alpha && !alpha_present)
+  {
+    fprintf (stderr, "PNG2PNM\n");
+    fprintf (stderr, "Error:  PNG-file doesn't contain alpha channel\n");
+    exit (1);
+  }
+
+  /* row_bytes is the width x number of channels x (bit-depth / 8) */
+  row_bytes = png_get_rowbytes (png_ptr, info_ptr);
+
+  if ((row_bytes == 0) ||
+      ((size_t) height > (size_t) (-1) / (size_t) row_bytes))
+  {
+    /* too big */
+    png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
+    return FALSE;
+  }
+  if ((png_pixels = (png_byte *)
+       malloc ((size_t) row_bytes * (size_t) height)) == NULL)
+  {
+    png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
+    return FALSE;
+  }
+
+  if ((row_pointers = (png_byte **)
+       malloc ((size_t) height * sizeof (png_byte *))) == NULL)
+  {
+    png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
+    free (png_pixels);
+    return FALSE;
+  }
+
+  /* set the individual row_pointers to point at the correct offsets */
+  for (i = 0; i < ((int) height); i++)
+    row_pointers[i] = png_pixels + i * row_bytes;
+
+  /* now we can go ahead and just read the whole image */
+  png_read_image (png_ptr, row_pointers);
+
+  /* read rest of file, and get additional chunks in info_ptr - REQUIRED */
+  png_read_end (png_ptr, info_ptr);
+
+  /* clean up after the read, and free any memory allocated - REQUIRED */
+  png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
+
+  /* write header of PNM file */
+
+  if ((color_type == PNG_COLOR_TYPE_GRAY) ||
+      (color_type == PNG_COLOR_TYPE_GRAY_ALPHA))
+  {
+    fprintf (pnm_file, "%s\n", (raw) ? "P5" : "P2");
+    fprintf (pnm_file, "%d %d\n", (int) width, (int) height);
+    fprintf (pnm_file, "%ld\n", ((1L << (int) bit_depth) - 1L));
+  }
+  else if ((color_type == PNG_COLOR_TYPE_RGB) ||
+           (color_type == PNG_COLOR_TYPE_RGB_ALPHA))
+  {
+    fprintf (pnm_file, "%s\n", (raw) ? "P6" : "P3");
+    fprintf (pnm_file, "%d %d\n", (int) width, (int) height);
+    fprintf (pnm_file, "%ld\n", ((1L << (int) bit_depth) - 1L));
+  }
+
+  /* write header of PGM file with alpha channel */
+
+  if ((alpha) &&
+      ((color_type == PNG_COLOR_TYPE_GRAY_ALPHA) ||
+       (color_type == PNG_COLOR_TYPE_RGB_ALPHA)))
+  {
+    fprintf (alpha_file, "%s\n", (raw) ? "P5" : "P2");
+    fprintf (alpha_file, "%d %d\n", (int) width, (int) height);
+    fprintf (alpha_file, "%ld\n", ((1L << (int) bit_depth) - 1L));
+  }
+
+  /* write data to PNM file */
+  pix_ptr = png_pixels;
+
+  for (row = 0; row < (int) height; row++)
+  {
+    for (col = 0; col < (int) width; col++)
+    {
+      for (i = 0; i < (channels - alpha_present); i++)
+      {
+        if (raw)
+        {
+          fputc ((int) *pix_ptr++, pnm_file);
+        }
+        else
+        {
+          if (bit_depth == 16)
+          {
+            dep_16 = (long) *pix_ptr++;
+            fprintf (pnm_file, "%ld ", (dep_16 << 8) + ((long) *pix_ptr++));
+          }
+          else
+          {
+            fprintf (pnm_file, "%ld ", (long) *pix_ptr++);
+          }
+        }
+      }
+      if (alpha_present)
+      {
+        if (!alpha)
+        {
+          pix_ptr++; /* alpha */
+          if (bit_depth == 16)
+            pix_ptr++;
+        }
+        else /* output alpha-channel as pgm file */
+        {
+          if (raw)
+          {
+            fputc ((int) *pix_ptr++, alpha_file);
+          }
+          else
+          {
+            if (bit_depth == 16)
+            {
+              dep_16 = (long) *pix_ptr++;
+              fprintf (alpha_file, "%ld ", (dep_16 << 8) + (long) *pix_ptr++);
+            }
+            else
+            {
+              fprintf (alpha_file, "%ld ", (long) *pix_ptr++);
+            }
+          }
+        }
+      } /* end if alpha_present */
+
+      if (!raw)
+        if (col % 4 == 3)
+          fprintf (pnm_file, "\n");
+    } /* end for col */
+
+    if (!raw)
+      if (col % 4 != 0)
+        fprintf (pnm_file, "\n");
+  } /* end for row */
+
+  if (row_pointers != NULL)
+    free (row_pointers);
+  if (png_pixels != NULL)
+    free (png_pixels);
+
+  return TRUE;
+
+} /* end of source */
diff --git a/Engine/lib/lpng/contrib/pngminus/png2pnm.sh b/Engine/lib/lpng/contrib/pngminus/png2pnm.sh
new file mode 100755
index 000000000..756126a53
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngminus/png2pnm.sh
@@ -0,0 +1,42 @@
+#!/bin/sh
+# -- grayscale
+./png2pnm -noraw ../pngsuite/basn0g01.png basn0g01.pgm
+./png2pnm -noraw ../pngsuite/basn0g02.png basn0g02.pgm
+./png2pnm -noraw ../pngsuite/basn0g04.png basn0g04.pgm
+./png2pnm -noraw ../pngsuite/basn0g08.png basn0g08.pgm
+./png2pnm -noraw ../pngsuite/basn0g16.png basn0g16.pgm
+# -- full-color
+./png2pnm -noraw ../pngsuite/basn2c08.png basn2c08.ppm
+./png2pnm -noraw ../pngsuite/basn2c16.png basn2c16.ppm
+# -- paletted
+./png2pnm -noraw ../pngsuite/basn3p01.png basn3p01.ppm
+./png2pnm -noraw ../pngsuite/basn3p02.png basn3p02.ppm
+./png2pnm -noraw ../pngsuite/basn3p04.png basn3p04.ppm
+./png2pnm -noraw ../pngsuite/basn3p08.png basn3p08.ppm
+# -- gray with alpha-channel
+./png2pnm -noraw ../pngsuite/basn4a08.png basn4a08.pgm
+./png2pnm -noraw ../pngsuite/basn4a16.png basn4a16.pgm
+# -- color with alpha-channel
+./png2pnm -noraw -alpha basn6a08.pgm ../pngsuite/basn6a08.png basn6a08.ppm
+./png2pnm -noraw -alpha basn6a16.pgm ../pngsuite/basn6a16.png basn6a16.ppm
+# -- grayscale
+./png2pnm -raw ../pngsuite/basn0g01.png rawn0g01.pgm
+./png2pnm -raw ../pngsuite/basn0g02.png rawn0g02.pgm
+./png2pnm -raw ../pngsuite/basn0g04.png rawn0g04.pgm
+./png2pnm -raw ../pngsuite/basn0g08.png rawn0g08.pgm
+./png2pnm -raw ../pngsuite/basn0g16.png rawn0g16.pgm
+# -- full-color
+./png2pnm -raw ../pngsuite/basn2c08.png rawn2c08.ppm
+./png2pnm -raw ../pngsuite/basn2c16.png rawn2c16.ppm
+# -- paletted
+./png2pnm -raw ../pngsuite/basn3p01.png rawn3p01.ppm
+./png2pnm -raw ../pngsuite/basn3p02.png rawn3p02.ppm
+./png2pnm -raw ../pngsuite/basn3p04.png rawn3p04.ppm
+./png2pnm -raw ../pngsuite/basn3p08.png rawn3p08.ppm
+# -- gray with alpha-channel
+./png2pnm -raw ../pngsuite/basn4a08.png rawn4a08.pgm
+./png2pnm -raw ../pngsuite/basn4a16.png rawn4a16.pgm
+# -- color with alpha-channel
+./png2pnm -noraw -alpha rawn6a08.pgm ../pngsuite/basn6a08.png rawn6a08.ppm
+./png2pnm -noraw -alpha rawn6a16.pgm ../pngsuite/basn6a16.png rawn6a16.ppm
+
diff --git a/Engine/lib/lpng/contrib/pngminus/pngminus.bat b/Engine/lib/lpng/contrib/pngminus/pngminus.bat
new file mode 100755
index 000000000..fa60e7de0
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngminus/pngminus.bat
@@ -0,0 +1,4 @@
+make
+call png2pnm.bat
+call pnm2png.bat
+
diff --git a/Engine/lib/lpng/contrib/pngminus/pngminus.sh b/Engine/lib/lpng/contrib/pngminus/pngminus.sh
new file mode 100755
index 000000000..cc9b4a56e
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngminus/pngminus.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+make
+sh png2pnm.sh
+sh pnm2png.sh
+
diff --git a/Engine/lib/lpng/contrib/pngminus/pnm2png.bat b/Engine/lib/lpng/contrib/pngminus/pnm2png.bat
new file mode 100755
index 000000000..c02b80bec
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngminus/pnm2png.bat
@@ -0,0 +1,41 @@
+REM -- grayscale
+pnm2png.exe basn0g01.pgm basn0g01.png
+pnm2png.exe basn0g02.pgm basn0g02.png
+pnm2png.exe basn0g04.pgm basn0g04.png
+pnm2png.exe basn0g08.pgm basn0g08.png
+pnm2png.exe basn0g16.pgm basn0g16.png
+REM -- full-color
+pnm2png.exe basn2c08.ppm basn2c08.png
+pnm2png.exe basn2c16.ppm basn2c16.png
+REM -- paletted
+pnm2png.exe basn3p01.ppm basn3p01.png
+pnm2png.exe basn3p02.ppm basn3p02.png
+pnm2png.exe basn3p04.ppm basn3p04.png
+pnm2png.exe basn3p08.ppm basn3p08.png
+REM -- gray with alpha-channel
+pnm2png.exe -alpha basn6a08.pgm basn4a08.pgm basn4a08.png
+pnm2png.exe -alpha basn6a16.pgm basn4a16.pgm basn4a16.png
+REM -- color with alpha-channel
+pnm2png.exe -alpha basn6a08.pgm basn6a08.ppm basn6a08.png
+pnm2png.exe -alpha basn6a16.pgm basn6a16.ppm basn6a16.png
+REM -- grayscale
+pnm2png.exe rawn0g01.pgm rawn0g01.png
+pnm2png.exe rawn0g02.pgm rawn0g02.png
+pnm2png.exe rawn0g04.pgm rawn0g04.png
+pnm2png.exe rawn0g08.pgm rawn0g08.png
+pnm2png.exe rawn0g16.pgm rawn0g16.png
+REM -- full-color
+pnm2png.exe rawn2c08.ppm rawn2c08.png
+pnm2png.exe rawn2c16.ppm rawn2c16.png
+REM -- paletted
+pnm2png.exe rawn3p01.ppm rawn3p01.png
+pnm2png.exe rawn3p02.ppm rawn3p02.png
+pnm2png.exe rawn3p04.ppm rawn3p04.png
+pnm2png.exe rawn3p08.ppm rawn3p08.png
+REM -- gray with alpha-channel
+pnm2png.exe -alpha rawn6a08.pgm rawn4a08.pgm rawn4a08.png
+pnm2png.exe -alpha rawn6a16.pgm rawn4a16.pgm rawn4a16.png
+REM -- color with alpha-channel
+pnm2png.exe -alpha rawn6a08.pgm rawn6a08.ppm rawn6a08.png
+pnm2png.exe -alpha rawn6a16.pgm rawn6a16.ppm rawn6a16.png
+
diff --git a/Engine/lib/lpng/contrib/pngminus/pnm2png.c b/Engine/lib/lpng/contrib/pngminus/pnm2png.c
new file mode 100644
index 000000000..a2c2551da
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngminus/pnm2png.c
@@ -0,0 +1,620 @@
+/*
+ *  pnm2png.c --- conversion from PBM/PGM/PPM-file to PNG-file
+ *  copyright (C) 1999-2019 by Willem van Schaik <willem at schaik dot com>
+ *
+ *  This software is released under the MIT license. For conditions of
+ *  distribution and use, see the LICENSE file part of this package.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+
+#ifndef BOOL
+#define BOOL unsigned char
+#endif
+#ifndef TRUE
+#define TRUE (BOOL) 1
+#endif
+#ifndef FALSE
+#define FALSE (BOOL) 0
+#endif
+
+/* make pnm2png verbose so we can find problems (needs to be before png.h) */
+#ifndef PNG_DEBUG
+#define PNG_DEBUG 0
+#endif
+
+#include "png.h"
+
+/* function prototypes */
+
+int main (int argc, char *argv[]);
+void usage ();
+BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file,
+              BOOL interlace, BOOL alpha);
+void get_token (FILE *pnm_file, char *token_buf, size_t token_buf_size);
+png_uint_32 get_data (FILE *pnm_file, int depth);
+png_uint_32 get_value (FILE *pnm_file, int depth);
+
+/*
+ *  main
+ */
+
+int main (int argc, char *argv[])
+{
+  FILE *fp_rd = stdin;
+  FILE *fp_al = NULL;
+  FILE *fp_wr = stdout;
+  BOOL interlace = FALSE;
+  BOOL alpha = FALSE;
+  int argi;
+
+  for (argi = 1; argi < argc; argi++)
+  {
+    if (argv[argi][0] == '-')
+    {
+      switch (argv[argi][1])
+      {
+        case 'i':
+          interlace = TRUE;
+          break;
+        case 'a':
+          alpha = TRUE;
+          argi++;
+          if ((fp_al = fopen (argv[argi], "rb")) == NULL)
+          {
+            fprintf (stderr, "PNM2PNG\n");
+            fprintf (stderr, "Error:  alpha-channel file %s does not exist\n",
+                     argv[argi]);
+            exit (1);
+          }
+          break;
+        case 'h':
+        case '?':
+          usage ();
+          exit (0);
+          break;
+        default:
+          fprintf (stderr, "PNM2PNG\n");
+          fprintf (stderr, "Error:  unknown option %s\n", argv[argi]);
+          usage ();
+          exit (1);
+          break;
+      } /* end switch */
+    }
+    else if (fp_rd == stdin)
+    {
+      if ((fp_rd = fopen (argv[argi], "rb")) == NULL)
+      {
+        fprintf (stderr, "PNM2PNG\n");
+        fprintf (stderr, "Error:  file %s does not exist\n", argv[argi]);
+        exit (1);
+      }
+    }
+    else if (fp_wr == stdout)
+    {
+      if ((fp_wr = fopen (argv[argi], "wb")) == NULL)
+      {
+        fprintf (stderr, "PNM2PNG\n");
+        fprintf (stderr, "Error:  cannot create PNG-file %s\n", argv[argi]);
+        exit (1);
+      }
+    }
+    else
+    {
+      fprintf (stderr, "PNM2PNG\n");
+      fprintf (stderr, "Error:  too many parameters\n");
+      usage ();
+      exit (1);
+    }
+  } /* end for */
+
+#if defined(O_BINARY) && (O_BINARY != 0)
+  /* set stdin/stdout to binary,
+   * we're reading the PNM always! in binary format
+   */
+  if (fp_rd == stdin)
+    setmode (fileno (stdin), O_BINARY);
+  if (fp_wr == stdout)
+    setmode (fileno (stdout), O_BINARY);
+#endif
+
+  /* call the conversion program itself */
+  if (pnm2png (fp_rd, fp_wr, fp_al, interlace, alpha) == FALSE)
+  {
+    fprintf (stderr, "PNM2PNG\n");
+    fprintf (stderr, "Error:  unsuccessful converting to PNG-image\n");
+    exit (1);
+  }
+
+  /* close input file */
+  fclose (fp_rd);
+  /* close output file */
+  fclose (fp_wr);
+  /* close alpha file */
+  if (alpha)
+    fclose (fp_al);
+
+  return 0;
+}
+
+/*
+ *  usage
+ */
+
+void usage ()
+{
+  fprintf (stderr, "PNM2PNG\n");
+  fprintf (stderr, "   by Willem van Schaik, 1999\n");
+  fprintf (stderr, "Usage:  pnm2png [options] <file>.<pnm> [<file>.png]\n");
+  fprintf (stderr, "   or:  ... | pnm2png [options]\n");
+  fprintf (stderr, "Options:\n");
+  fprintf (stderr, "   -i[nterlace]   write png-file with interlacing on\n");
+  fprintf (stderr,
+      "   -a[lpha] <file>.pgm read PNG alpha channel as pgm-file\n");
+  fprintf (stderr, "   -h | -?  print this help-information\n");
+}
+
+/*
+ *  pnm2png
+ */
+
+BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file,
+              BOOL interlace, BOOL alpha)
+{
+  png_struct    *png_ptr = NULL;
+  png_info      *info_ptr = NULL;
+  png_byte      *png_pixels = NULL;
+  png_byte      **row_pointers = NULL;
+  png_byte      *pix_ptr = NULL;
+  volatile png_uint_32 row_bytes;
+
+  char          type_token[16];
+  char          width_token[16];
+  char          height_token[16];
+  char          maxval_token[16];
+  volatile int  color_type = 1;
+  unsigned long ul_width = 0, ul_alpha_width = 0;
+  unsigned long ul_height = 0, ul_alpha_height = 0;
+  unsigned long ul_maxval = 0;
+  volatile png_uint_32 width = 0, height = 0;
+  volatile png_uint_32 alpha_width = 0, alpha_height = 0;
+  png_uint_32   maxval;
+  volatile int  bit_depth = 0;
+  int           channels = 0;
+  int           alpha_depth = 0;
+  int           alpha_present = 0;
+  int           row, col;
+  BOOL          raw, alpha_raw = FALSE;
+#if defined(PNG_WRITE_INVERT_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
+  BOOL          packed_bitmap = FALSE;
+#endif
+  png_uint_32   tmp16;
+  int           i;
+
+  /* read header of PNM file */
+
+  get_token (pnm_file, type_token, sizeof (type_token));
+  if (type_token[0] != 'P')
+  {
+    return FALSE;
+  }
+  else if ((type_token[1] == '1') || (type_token[1] == '4'))
+  {
+#if defined(PNG_WRITE_INVERT_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
+    raw = (type_token[1] == '4');
+    color_type = PNG_COLOR_TYPE_GRAY;
+    get_token (pnm_file, width_token, sizeof (width_token));
+    sscanf (width_token, "%lu", &ul_width);
+    width = (png_uint_32) ul_width;
+    get_token (pnm_file, height_token, sizeof (height_token));
+    sscanf (height_token, "%lu", &ul_height);
+    height = (png_uint_32) ul_height;
+    bit_depth = 1;
+    packed_bitmap = TRUE;
+#else
+    fprintf (stderr, "PNM2PNG built without PNG_WRITE_INVERT_SUPPORTED and\n");
+    fprintf (stderr, "PNG_WRITE_PACK_SUPPORTED can't read PBM (P1,P4) files\n");
+    return FALSE;
+#endif
+  }
+  else if ((type_token[1] == '2') || (type_token[1] == '5'))
+  {
+    raw = (type_token[1] == '5');
+    color_type = PNG_COLOR_TYPE_GRAY;
+    get_token (pnm_file, width_token, sizeof (width_token));
+    sscanf (width_token, "%lu", &ul_width);
+    width = (png_uint_32) ul_width;
+    get_token (pnm_file, height_token, sizeof (height_token));
+    sscanf (height_token, "%lu", &ul_height);
+    height = (png_uint_32) ul_height;
+    get_token (pnm_file, maxval_token, sizeof (maxval_token));
+    sscanf (maxval_token, "%lu", &ul_maxval);
+    maxval = (png_uint_32) ul_maxval;
+
+    if (maxval <= 1)
+      bit_depth = 1;
+    else if (maxval <= 3)
+      bit_depth = 2;
+    else if (maxval <= 15)
+      bit_depth = 4;
+    else if (maxval <= 255)
+      bit_depth = 8;
+    else if (maxval <= 65535U)
+      bit_depth = 16;
+    else /* maxval > 65535U */
+      return FALSE;
+  }
+  else if ((type_token[1] == '3') || (type_token[1] == '6'))
+  {
+    raw = (type_token[1] == '6');
+    color_type = PNG_COLOR_TYPE_RGB;
+    get_token (pnm_file, width_token, sizeof (width_token));
+    sscanf (width_token, "%lu", &ul_width);
+    width = (png_uint_32) ul_width;
+    get_token (pnm_file, height_token, sizeof (height_token));
+    sscanf (height_token, "%lu", &ul_height);
+    height = (png_uint_32) ul_height;
+    get_token (pnm_file, maxval_token, sizeof (maxval_token));
+    sscanf (maxval_token, "%lu", &ul_maxval);
+    maxval = (png_uint_32) ul_maxval;
+    if (maxval <= 1)
+      bit_depth = 1;
+    else if (maxval <= 3)
+      bit_depth = 2;
+    else if (maxval <= 15)
+      bit_depth = 4;
+    else if (maxval <= 255)
+      bit_depth = 8;
+    else if (maxval <= 65535U)
+      bit_depth = 16;
+    else /* maxval > 65535U */
+      return FALSE;
+  }
+  else
+  {
+    return FALSE;
+  }
+
+  /* read header of PGM file with alpha channel */
+
+  if (alpha)
+  {
+    if (color_type == PNG_COLOR_TYPE_GRAY)
+      color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
+    if (color_type == PNG_COLOR_TYPE_RGB)
+      color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+
+    get_token (alpha_file, type_token, sizeof (type_token));
+    if (type_token[0] != 'P')
+    {
+      return FALSE;
+    }
+    else if ((type_token[1] == '2') || (type_token[1] == '5'))
+    {
+      alpha_raw = (type_token[1] == '5');
+      get_token (alpha_file, width_token, sizeof (width_token));
+      sscanf (width_token, "%lu", &ul_alpha_width);
+      alpha_width = (png_uint_32) ul_alpha_width;
+      if (alpha_width != width)
+        return FALSE;
+      get_token (alpha_file, height_token, sizeof (height_token));
+      sscanf (height_token, "%lu", &ul_alpha_height);
+      alpha_height = (png_uint_32) ul_alpha_height;
+      if (alpha_height != height)
+        return FALSE;
+      get_token (alpha_file, maxval_token, sizeof (maxval_token));
+      sscanf (maxval_token, "%lu", &ul_maxval);
+      maxval = (png_uint_32) ul_maxval;
+      if (maxval <= 1)
+        alpha_depth = 1;
+      else if (maxval <= 3)
+        alpha_depth = 2;
+      else if (maxval <= 15)
+        alpha_depth = 4;
+      else if (maxval <= 255)
+        alpha_depth = 8;
+      else if (maxval <= 65535U)
+        alpha_depth = 16;
+      else /* maxval > 65535U */
+        return FALSE;
+      if (alpha_depth != bit_depth)
+        return FALSE;
+    }
+    else
+    {
+      return FALSE;
+    }
+  } /* end if alpha */
+
+  /* calculate the number of channels and store alpha-presence */
+  if (color_type == PNG_COLOR_TYPE_GRAY)
+    channels = 1;
+  else if (color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+    channels = 2;
+  else if (color_type == PNG_COLOR_TYPE_RGB)
+    channels = 3;
+  else if (color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+    channels = 4;
+#if 0
+  else
+    channels = 0; /* cannot happen */
+#endif
+
+  alpha_present = (channels - 1) % 2;
+
+#if defined(PNG_WRITE_INVERT_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
+  if (packed_bitmap)
+  {
+    /* row data is as many bytes as can fit width x channels x bit_depth */
+    row_bytes = (width * channels * bit_depth + 7) / 8;
+  }
+  else
+#endif
+  {
+    /* row_bytes is the width x number of channels x (bit-depth / 8) */
+    row_bytes = width * channels * ((bit_depth <= 8) ? 1 : 2);
+  }
+
+  if ((row_bytes == 0) ||
+      ((size_t) height > (size_t) (-1) / (size_t) row_bytes))
+  {
+    /* too big */
+    return FALSE;
+  }
+  if ((png_pixels = (png_byte *)
+       malloc ((size_t) row_bytes * (size_t) height)) == NULL)
+  {
+    /* out of memory */
+    return FALSE;
+  }
+
+  /* read data from PNM file */
+  pix_ptr = png_pixels;
+
+  for (row = 0; row < (int) height; row++)
+  {
+#if defined(PNG_WRITE_INVERT_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
+    if (packed_bitmap)
+    {
+      for (i = 0; i < (int) row_bytes; i++)
+      {
+        /* png supports this format natively so no conversion is needed */
+        *pix_ptr++ = get_data (pnm_file, 8);
+      }
+    }
+    else
+#endif
+    {
+      for (col = 0; col < (int) width; col++)
+      {
+        for (i = 0; i < (channels - alpha_present); i++)
+        {
+          if (raw)
+          {
+            *pix_ptr++ = get_data (pnm_file, bit_depth);
+          }
+          else
+          {
+            if (bit_depth <= 8)
+            {
+              *pix_ptr++ = get_value (pnm_file, bit_depth);
+            }
+            else
+            {
+              tmp16 = get_value (pnm_file, bit_depth);
+              *pix_ptr = (png_byte) ((tmp16 >> 8) & 0xFF);
+              pix_ptr++;
+              *pix_ptr = (png_byte) (tmp16 & 0xFF);
+              pix_ptr++;
+            }
+          }
+        }
+
+        if (alpha) /* read alpha-channel from pgm file */
+        {
+          if (alpha_raw)
+          {
+            *pix_ptr++ = get_data (alpha_file, alpha_depth);
+          }
+          else
+          {
+            if (alpha_depth <= 8)
+            {
+              *pix_ptr++ = get_value (alpha_file, bit_depth);
+            }
+            else
+            {
+              tmp16 = get_value (alpha_file, bit_depth);
+              *pix_ptr++ = (png_byte) ((tmp16 >> 8) & 0xFF);
+              *pix_ptr++ = (png_byte) (tmp16 & 0xFF);
+            }
+          }
+        } /* end if alpha */
+      } /* end if packed_bitmap */
+    } /* end for col */
+  } /* end for row */
+
+  /* prepare the standard PNG structures */
+  png_ptr = png_create_write_struct (png_get_libpng_ver(NULL),
+                                     NULL, NULL, NULL);
+  if (!png_ptr)
+  {
+    free (png_pixels);
+    return FALSE;
+  }
+  info_ptr = png_create_info_struct (png_ptr);
+  if (!info_ptr)
+  {
+    png_destroy_write_struct (&png_ptr, NULL);
+    free (png_pixels);
+    return FALSE;
+  }
+
+#if defined(PNG_WRITE_INVERT_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
+  if (packed_bitmap == TRUE)
+  {
+    png_set_packing (png_ptr);
+    png_set_invert_mono (png_ptr);
+  }
+#endif
+
+  if (setjmp (png_jmpbuf (png_ptr)))
+  {
+    png_destroy_write_struct (&png_ptr, &info_ptr);
+    free (png_pixels);
+    return FALSE;
+  }
+
+  /* initialize the png structure */
+  png_init_io (png_ptr, png_file);
+
+  /* we're going to write more or less the same PNG as the input file */
+  png_set_IHDR (png_ptr, info_ptr, width, height, bit_depth, color_type,
+                (!interlace) ? PNG_INTERLACE_NONE : PNG_INTERLACE_ADAM7,
+                PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
+
+  /* write the file header information */
+  png_write_info (png_ptr, info_ptr);
+
+  /* if needed we will allocate memory for an new array of row-pointers */
+  if (row_pointers == NULL)
+  {
+    if ((row_pointers = (png_byte **)
+         malloc (height * sizeof (png_byte *))) == NULL)
+    {
+      png_destroy_write_struct (&png_ptr, &info_ptr);
+      free (png_pixels);
+      return FALSE;
+    }
+  }
+
+  /* set the individual row_pointers to point at the correct offsets */
+  for (i = 0; i < (int) height; i++)
+    row_pointers[i] = png_pixels + i * row_bytes;
+
+  /* write out the entire image data in one call */
+  png_write_image (png_ptr, row_pointers);
+
+  /* write the additional chunks to the PNG file (not really needed) */
+  png_write_end (png_ptr, info_ptr);
+
+  /* clean up after the write, and free any memory allocated */
+  png_destroy_write_struct (&png_ptr, &info_ptr);
+
+  if (row_pointers != NULL)
+    free (row_pointers);
+  if (png_pixels != NULL)
+    free (png_pixels);
+
+  return TRUE;
+} /* end of pnm2png */
+
+/*
+ * get_token - gets the first string after whitespace
+ */
+
+void get_token (FILE *pnm_file, char *token_buf, size_t token_buf_size)
+{
+  size_t i = 0;
+  int ret;
+
+  /* remove white-space and comment lines */
+  do
+  {
+    ret = fgetc (pnm_file);
+    if (ret == '#')
+    {
+      /* the rest of this line is a comment */
+      do
+      {
+        ret = fgetc (pnm_file);
+      }
+      while ((ret != '\n') && (ret != '\r') && (ret != EOF));
+    }
+    if (ret == EOF) break;
+    token_buf[i] = (char) ret;
+  }
+  while ((ret == '\n') || (ret == '\r') || (ret == ' '));
+
+  /* read string */
+  do
+  {
+    ret = fgetc (pnm_file);
+    if (ret == EOF) break;
+    if (++i == token_buf_size - 1) break;
+    token_buf[i] = (char) ret;
+  }
+  while ((ret != '\n') && (ret != '\r') && (ret != ' '));
+
+  token_buf[i] = '\0';
+
+  return;
+}
+
+/*
+ *  get_data - takes first byte and converts into next pixel value,
+ *             taking as much bits as defined by bit-depth and
+ *             using the bit-depth to fill up a byte (0Ah -> AAh)
+ */
+
+png_uint_32 get_data (FILE *pnm_file, int depth)
+{
+  static int bits_left = 0;
+  static int old_value = 0;
+  static int mask = 0;
+  int i;
+  png_uint_32 ret_value;
+
+  if (mask == 0)
+    for (i = 0; i < depth; i++)
+      mask = (mask >> 1) | 0x80;
+
+  if (bits_left <= 0)
+  {
+    old_value = fgetc (pnm_file);
+    bits_left = 8;
+  }
+
+  ret_value = old_value & mask;
+  for (i = 1; i < (8 / depth); i++)
+    ret_value = ret_value || (ret_value >> depth);
+
+  old_value = (old_value << depth) & 0xFF;
+  bits_left -= depth;
+
+  return ret_value;
+}
+
+/*
+ *  get_value - takes first (numeric) string and converts into number,
+ *              using the bit-depth to fill up a byte (0Ah -> AAh)
+ */
+
+png_uint_32 get_value (FILE *pnm_file, int depth)
+{
+  static png_uint_32 mask = 0;
+  char token[16];
+  unsigned long ul_ret_value;
+  png_uint_32 ret_value;
+  int i = 0;
+
+  if (mask == 0)
+    for (i = 0; i < depth; i++)
+      mask = (mask << 1) | 0x01;
+
+  get_token (pnm_file, token, sizeof (token));
+  sscanf (token, "%lu", &ul_ret_value);
+  ret_value = (png_uint_32) ul_ret_value;
+
+  ret_value &= mask;
+
+  if (depth < 8)
+    for (i = 0; i < (8 / depth); i++)
+      ret_value = (ret_value << depth) || ret_value;
+
+  return ret_value;
+}
+
+/* end of source */
diff --git a/Engine/lib/lpng/contrib/pngminus/pnm2png.sh b/Engine/lib/lpng/contrib/pngminus/pnm2png.sh
new file mode 100755
index 000000000..2ad17a608
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngminus/pnm2png.sh
@@ -0,0 +1,42 @@
+#!/bin/sh
+# -- grayscale
+./pnm2png basn0g01.pgm basn0g01.png
+./pnm2png basn0g02.pgm basn0g02.png
+./pnm2png basn0g04.pgm basn0g04.png
+./pnm2png basn0g08.pgm basn0g08.png
+./pnm2png basn0g16.pgm basn0g16.png
+# -- full-color
+./pnm2png basn2c08.ppm basn2c08.png
+./pnm2png basn2c16.ppm basn2c16.png
+# -- paletted
+./pnm2png basn3p01.ppm basn3p01.png
+./pnm2png basn3p02.ppm basn3p02.png
+./pnm2png basn3p04.ppm basn3p04.png
+./pnm2png basn3p08.ppm basn3p08.png
+# -- gray with alpha-channel
+./pnm2png -alpha basn6a08.pgm basn4a08.pgm basn4a08.png
+./pnm2png -alpha basn6a16.pgm basn4a16.pgm basn4a16.png
+# -- color with alpha-channel
+./pnm2png -alpha basn6a08.pgm basn6a08.ppm basn6a08.png
+./pnm2png -alpha basn6a16.pgm basn6a16.ppm basn6a16.png
+# -- grayscale
+./pnm2png rawn0g01.pgm rawn0g01.png
+./pnm2png rawn0g02.pgm rawn0g02.png
+./pnm2png rawn0g04.pgm rawn0g04.png
+./pnm2png rawn0g08.pgm rawn0g08.png
+./pnm2png rawn0g16.pgm rawn0g16.png
+# -- full-color
+./pnm2png rawn2c08.ppm rawn2c08.png
+./pnm2png rawn2c16.ppm rawn2c16.png
+# -- paletted
+./pnm2png rawn3p01.ppm rawn3p01.png
+./pnm2png rawn3p02.ppm rawn3p02.png
+./pnm2png rawn3p04.ppm rawn3p04.png
+./pnm2png rawn3p08.ppm rawn3p08.png
+# -- gray with alpha-channel
+./pnm2png -alpha rawn6a08.pgm rawn4a08.pgm rawn4a08.png
+./pnm2png -alpha rawn6a16.pgm rawn4a16.pgm rawn4a16.png
+# -- color with alpha-channel
+./pnm2png -alpha rawn6a08.pgm rawn6a08.ppm rawn6a08.png
+./pnm2png -alpha rawn6a16.pgm rawn6a16.ppm rawn6a16.png
+
diff --git a/Engine/lib/lpng/contrib/pngsuite/README b/Engine/lib/lpng/contrib/pngsuite/README
new file mode 100644
index 000000000..d236b02e7
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngsuite/README
@@ -0,0 +1,107 @@
+
+pngsuite
+--------
+Copyright (c) Willem van Schaik, 1999, 2011, 2012
+Two images (ftbbn0g01.png and ftbbn0g02.png) are by Glenn Randers-Pehrson, 2012
+
+Permission to use, copy, modify, and distribute these images for any
+purpose and without fee is hereby granted.
+
+The 15 "bas*.png" images are part of the much larger PngSuite test-set of
+images, available for developers of PNG supporting software. The
+complete set, available at http:/www.schaik.com/pngsuite/, contains
+a variety of images to test interlacing, gamma settings, ancillary
+chunks, etc.
+
+The "ft*.png" images are "free/libre" replacements for the transparent
+corresponding t*.png images in the PngSuite.
+
+The "i*.png" images are the same images, but interlaced.
+
+The images in this directory represent the basic PNG color-types:
+grayscale (1-16 bit deep), full color (8 or 16 bit), paletted
+(1-8 bit) and grayscale or color images with alpha channel. You
+can use them to test the proper functioning of PNG software.
+
+    filename       depth type
+    ------------ ------ --------------
+    basn0g01.png   1-bit grayscale
+    basn0g02.png   2-bit grayscale
+    basn0g04.png   4-bit grayscale
+    basn0g08.png   8-bit grayscale
+    basn0g16.png  16-bit grayscale
+    basn2c08.png   8-bit truecolor
+    basn2c16.png  16-bit truecolor
+    basn3p01.png   1-bit paletted
+    basn3p02.png   2-bit paletted
+    basn3p04.png   4-bit paletted
+    basn3p08.png   8-bit paletted
+    basn4a08.png   8-bit gray with alpha
+    basn4a16.png  16-bit gray with alpha
+    basn6a08.png   8-bit RGBA
+    basn6a16.png  16-bit RGBA
+
+    ftbbn0g01.png  1-bit grayscale, black bKGD
+    ftbbn0g02.png  2-bit grayscale, black bKGD
+    ftbbn0g04.png  4-bit grayscale, black bKGD
+    ftbbn2c16.png 16-bit truecolor, black bKGD
+    ftbbn3p08.png  8-bit paletted, black bKGD
+    ftbgn2c16.png 16-bit truecolor, gray bKGD
+    ftbgn3p08.png  8-bit paletted, gray bKGD
+    ftbrn2c08.png  8-bit truecolor, red bKGD
+    ftbwn0g16.png 16-bit gray, white bKGD
+    ftbwn3p08.png  8-bit paletted, white bKGD
+    ftbyn3p08.png  8-bit paletted, yellow bKGD
+    ftp0n0g08.png  8-bit grayscale, opaque
+    ftp0n2c08.png  8-bit truecolor, opaque
+    ftp0n3p08.png  8-bit paletted, opaque
+    ftp1n3p08.png  8-bit paletted, no bKGD
+
+Here is the correct result of typing "pngtest -m bas*.png" in
+this directory:
+
+Testing basn0g01.png: PASS (524 zero samples)
+ Filter 0 was used 32 times
+Testing basn0g02.png: PASS (448 zero samples)
+ Filter 0 was used 32 times
+Testing basn0g04.png: PASS (520 zero samples)
+ Filter 0 was used 32 times
+Testing basn0g08.png: PASS (3 zero samples)
+ Filter 1 was used 9 times
+ Filter 4 was used 23 times
+Testing basn0g16.png: PASS (1 zero samples)
+ Filter 1 was used 1 times
+ Filter 2 was used 31 times
+Testing basn2c08.png: PASS (6 zero samples)
+ Filter 1 was used 5 times
+ Filter 4 was used 27 times
+Testing basn2c16.png: PASS (592 zero samples)
+ Filter 1 was used 1 times
+ Filter 4 was used 31 times
+Testing basn3p01.png: PASS (512 zero samples)
+ Filter 0 was used 32 times
+Testing basn3p02.png: PASS (448 zero samples)
+ Filter 0 was used 32 times
+Testing basn3p04.png: PASS (544 zero samples)
+ Filter 0 was used 32 times
+Testing basn3p08.png: PASS (4 zero samples)
+ Filter 0 was used 32 times
+Testing basn4a08.png: PASS (32 zero samples)
+ Filter 1 was used 1 times
+ Filter 4 was used 31 times
+Testing basn4a16.png: PASS (64 zero samples)
+ Filter 0 was used 1 times
+ Filter 1 was used 2 times
+ Filter 2 was used 1 times
+ Filter 4 was used 28 times
+Testing basn6a08.png: PASS (160 zero samples)
+ Filter 1 was used 1 times
+ Filter 4 was used 31 times
+Testing basn6a16.png: PASS (1072 zero samples)
+ Filter 1 was used 4 times
+ Filter 4 was used 28 times
+libpng passes test
+
+Willem van Schaik
+<willem at schaik.com>
+October 1999
diff --git a/Engine/lib/lpng/contrib/pngsuite/bad_interlace_conversions.txt b/Engine/lib/lpng/contrib/pngsuite/bad_interlace_conversions.txt
new file mode 100644
index 000000000..8afbde790
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngsuite/bad_interlace_conversions.txt
@@ -0,0 +1,9 @@
+basn0g01.png
+basn0g02.png
+basn0g04.png
+basn3p01.png
+basn3p02.png
+basn3p04.png
+ftbbn0g01.png
+ftbbn0g02.png
+ftbbn0g04.png
diff --git a/Engine/lib/lpng/contrib/pngsuite/basn0g01.png b/Engine/lib/lpng/contrib/pngsuite/basn0g01.png
new file mode 100644
index 0000000000000000000000000000000000000000..e31e1c7a635b50e22b6d02ab8ba21f8099b39faa
GIT binary patch
literal 164
zcmeAS@N?(olHy`uVBq!ia0vp^3Lwk~Bp9L@-6Me%OS+@4BLidG0>c;6;z7cmE{-7_
zGj-2w<YYGBVZHeJ63Zqp1@0=7{0X8qO$U3q5?$E?KR)QvU-jzJl9rrvD^-Kpo(G$R
z3q2Ctq`2Q(%~sl}SXDKy`_`s;`B|q7GWF(aCg#1&H%R@kUtXZyQ-A4{ifEAap00i_
I>zopr084i?r2qf`

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/basn0g02.png b/Engine/lib/lpng/contrib/pngsuite/basn0g02.png
new file mode 100644
index 0000000000000000000000000000000000000000..68809dd8fc0993ddebce8aa9c7bf9bbecbd36cfc
GIT binary patch
literal 104
zcmeAS@N?(olHy`uVBq!ia0vp^3Lwk`Bp75C+I9jdmUKs7M+U~W1%@xC#RK{Bo-U3d
y5>t~CIAXub_k1+y2sp$L+}6)%%qgEdVJADoUeEf*_U-^?kP)7)elF{r5}E*i=NeZ4

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/basn0g04.png b/Engine/lib/lpng/contrib/pngsuite/basn0g04.png
new file mode 100644
index 0000000000000000000000000000000000000000..6fa089cb8a4ba0e8421ea05d33676856f0cac93c
GIT binary patch
literal 145
zcmeAS@N?(olHy`uVBq!ia0vp^3Lwk^Bp4<?JfR7sSkfJR9T^zg78t&m77yfmc)B=-
zXiQ8_NDvSS2{JM(E9B($_14x;S8!&Sdi$bdAA?r;GoK=sfSs$uCMq|ay1RF_3}eW<
qnZ{2z78Jd|r|Qly_4hkjNhSt)k#~&ox|xn3yF6X}T-G@yGywpLM=Kuy

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/basn0g08.png b/Engine/lib/lpng/contrib/pngsuite/basn0g08.png
new file mode 100644
index 0000000000000000000000000000000000000000..bf522eef0018ae60539ee1b50e98d97906101f2a
GIT binary patch
literal 138
zcmeAS@N?(olHy`uVBq!ia0vp^3Lwk@BpAX3RW*PVOS+@4BLidG0>c;6;(>fePZ!4!
zi{9jv1QiAmjuV@CSXq1cIW&KKm$y%-G>{Q7I3+kCJ!Mg43=bP?PydHg|Nfu<(f+K^
hPy#6PU}|a#3q!!ue}#oBxm7@xc)I$ztaD0e0szfSD4qZS

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/basn0g16.png b/Engine/lib/lpng/contrib/pngsuite/basn0g16.png
new file mode 100644
index 0000000000000000000000000000000000000000..318ebcadf4fd0b64fb9b824e81c0cc8e3dfd2d82
GIT binary patch
literal 167
zcmeAS@N?(olHy`uVBq!ia0vp^3Lq>1BpBEle`W(ImUKs7M+U~W1%@xC#RK_qo-U3d
z9-UV&8FC#k;BgMLjDBB#?9PJ82Q;dUu4=I?zS(bY(Xf0+xUg{Y0;{G3S&o?ucbmRB
zoML$)c8ASL&0+fj+X+UDyI8k3PT;(to58=tC&50S{f++@NsIIK3}QFDZ^ZA8J8=o*
N0#8>zmvv4FO#l#XIHLdn

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/basn2c08.png b/Engine/lib/lpng/contrib/pngsuite/basn2c08.png
new file mode 100644
index 0000000000000000000000000000000000000000..21d2f91a868fc637fdae4fba6c87bfd09b158815
GIT binary patch
literal 145
zcmeAS@N?(olHy`uVBq!ia0vp^3LwnE1SJ1Ryj={WSkfJR9T^zg78t&m77yfmc)B=-
zcyzwKdXSUBfQQMU_07b;+lz#)U9`U}{BiD~_7+|i>jo~7A2JKxKB@JoaA;)W_iC3v
r)WR;J@nJ!Uh4M;=#@z+wiw`h1ZTuN$cYX2<pqUJwu6{1-oD!M<;Mp+-

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/basn2c16.png b/Engine/lib/lpng/contrib/pngsuite/basn2c16.png
new file mode 100644
index 0000000000000000000000000000000000000000..1bd4a4d0e2c2c6dd8a2e63a63b26f166b8ef5353
GIT binary patch
literal 302
zcmV+}0nz@6P)<h;3K|Lk000e1NJLTq001BW001Bm0ssI2tcWq-00004XF*Lt00D-e
zG3b_G0002xNkl<ZScTP=!3u*g5JacoL4V7BxBad5mL3KJl7=Q`lgxS;hDGE()}W6N
zLI6H5;F|Aba&vwdJts3?&f@c0ceeuT&U7enqBEEC?ecJ4(E(udvVmXd?D7J6bf&Pt
zKXj(#87M>NTx<h1=<G5A_2^6ifxGC;sb`=Ko%2Z>us~-YE?|ew94KIo9tHTv?hhRR
zwrA%J^h9UxCeR<fo4_daC}8&;7>myPjW#d?oxNFL9(uFDZ1gBle+D$rIj`J+5;}Xa
zfF63WfGT<v$e#gibj~vy@PN*q2>3xy1iYa$zve>zUQQss#Q*>R07*qoM6N<$g1`fR
ASpWb4

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/basn3p01.png b/Engine/lib/lpng/contrib/pngsuite/basn3p01.png
new file mode 100644
index 0000000000000000000000000000000000000000..a21db5977462c4c0985a0ca1ac2d67ec572d3d17
GIT binary patch
literal 112
zcmeAS@N?(olHy`uVBq!ia0vp^3LwnL3?x0byx0z;SkfJR9T^zg78t&m77ygJ1^9%x
zzWcAFl=eSI>XI5zMAXy8F@$4g@&k4zHj_up0t<whm+&#{mbX7R;pmxWpaKR@S3j3^
HP6<r_p<o@S

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/basn3p02.png b/Engine/lib/lpng/contrib/pngsuite/basn3p02.png
new file mode 100644
index 0000000000000000000000000000000000000000..1d0ab6197cc8c4dd61e4440cbe98b2149eeafafb
GIT binary patch
literal 146
zcmeAS@N?(olHy`uVBq!ia0vp^3LwnH3?%tPCZz)@mUKs7M+U~W1%@xC#RK`w#ZI0f
zjEsymdgV<(E>D0@h%3W?AY}Lt#0>va?X`CSX(dk=#}J9B$v@<GbuqR`elYlO@}R`(
l1v)i6D=z*2A<=xsmSL}FePgcHsoy}=44$rjF6*2UngFeOD%1b~

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/basn3p04.png b/Engine/lib/lpng/contrib/pngsuite/basn3p04.png
new file mode 100644
index 0000000000000000000000000000000000000000..6dc6eac83f3cf984a4d121e27a8e60454117e12c
GIT binary patch
literal 216
zcmeAS@N?(olHy`uVBq!ia0vp^3LwnF3?v&v(vJfvmUKs7M+U~W1%@xC#RK`w#ZI0f
zEG#VLKejFga&-fILR^&?{xkgl-@))-=|2O*%>Vz>816FsF9(VN75txh7sS~8e>Vez
z3y|e<X@loppt!rIi(`n!#N-z*ICyP~)2^=iRFwR<{C(QF6a{C7soEMIeGFRHkG9G%
zhP=DG`w7Q_Ldg??4o|f-Cn`6b^7U4BXPCOX+FX)};lYtt7kN|r4*-p1@O1TaS?83{
F1OO|$P0RoQ

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/basn3p08.png b/Engine/lib/lpng/contrib/pngsuite/basn3p08.png
new file mode 100644
index 0000000000000000000000000000000000000000..0e07f483c0edad13e60e0d475c33a7ca5b8919ba
GIT binary patch
literal 1286
zcmWku4NMkw7=I2$3}y17=z>5zLEEca@?OO&kPSTILuD+yid<Q#FBz^`v>i?7W^Q<V
zIS@4tAr;W@A_~TqUM#;}3_1KtXTxr_B{JH)rI15Q@9Fox&)&QL{{R2;{63y%S5;J)
z8x<KBNkmckdGhOcCx!kqr{O7gRA0nvdTG|WED|b@rj8%lNHmR#)~?SHWqQbt%Bsce
ziKKLuL=h|Y5EjH;N`Mgo7FdiSn|YXZS!Plck;t-GmPuj7vPg;}zGpkkqinHl%Pb>F
z0=7twg95}IGPB`0p){BIDdQnXEGb?R1lBYr!w>|Li8PIP)G{}a$YQ`p%(`K)LO3UD
z6M@=IHq>+iwp~U6B7p@ho9?k)W)s^cNfJ5alp|5o3vi!RBHkmgX}UWIuw)VII#g=d
z$04w7jssURBxceP_z6C6HW{SZU_uGkHHZpyqy!k&kY2+c1*akQFoehhD3_nQ9ng;b
z0F#8v3ad!gP>4LFqCR|KhXmq>PACHhpyFVSOH8CTvPiZqN$iqqnyfQJ&?bvale$n1
zTv^)Th9oKqsKIPjfKCD1Cd3{VRFz%0i$*94z+D%LEeH_80824wD<EX~FiU(BniO4!
zA7qm0RfsLC57ZCC3DY1WTccuw7}f(2Y%mutuw>Gaq4ThALK_0kH^LL!W!ET%TWXjP
zf+UjIVU&gj2dkjg55o;~Er9W|;Xj52QG;=_Fb4{JL{~@@LhLOJ3noJ*c>^l+tMCGO
zCYz+H<xYr*gusT%U}V4yNF|R*Vi3J`9LR!U1igI$4|yUz#2$~0IY8@K6EHXupWb)l
z12nrQU(Q<ZuZubtK{KaE)7jk4+PuxnGNfm=l)bg3^zYc}Yu`_Ky)S;)6!p!vq2JqU
zD_aki_<E;)`myQ!)V#4b|Ly(qgq@N&D$FR~^Hu-A=iPI+=3QF7_O3U>e>Pl<|Ld_f
zqkm1#%jMM-%}evv+<)~($raC^D<>wy%g2N5PX<@DWeyA$O75|=jlHcE2YqXoq<-r^
zSF~%<yLZB?@6Y}3WUhKEdR^zx^4q^O#rBn^T(7Llyn1z8dvsJuUe}4|7q1+8<Iwiz
zk>HYo3ID?48vDt>55dBr2eB{o9GWV*`fG5Jx3PvhgDLYTpZ#Qi+|CPMFK>V8kJOfm
z#*Z=w{NC;LVI4^y_wGIZ+0l95T|3etXWUAydp~nc!u}QYkLn)pJU@Hlx;E!j?tzqu
zY2yX+->z>?3??Uzz4BVazO+Xz%j8eHAEZy_UHonH-GsLIpF6E1$sG&stX%!v*c@Yf
zL&of5NeNZAyW0FGPYv%K9`*NV3kUPJUh!4N^d%dUzFDUR&e(zJm#a=^UXXnc(yA(I
z-;o2p70nAqE-$V<zA9DQ_0J;VOk=~+k?fZCS*@3>851jZH`@`r<K1ZCKu_pPNBKF0
Ka(DK7U;GbG9AWPO

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/basn4a08.png b/Engine/lib/lpng/contrib/pngsuite/basn4a08.png
new file mode 100644
index 0000000000000000000000000000000000000000..3bb0dd06b510cb42855ce91f1600540f4503ea34
GIT binary patch
literal 126
zcmeAS@N?(olHy`uVBq!ia0vp^3LwnE0wix1Z>k4UEa{HEjtq=#3k+XOiwE*eJzX3_
zJUWyAoIh}Yv2{*{iJ{UQo%@m+%sTdM`xqA|8c4B)7$%qqxF2rNV(Vdhlpzstn1SKG
XmO|}<{e=-g0~kDA{an^LB{Ts5zRx3;

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/basn4a16.png b/Engine/lib/lpng/contrib/pngsuite/basn4a16.png
new file mode 100644
index 0000000000000000000000000000000000000000..6dbee9fbdb93f3535be23326a52fb4d3ac60711e
GIT binary patch
literal 2206
zcmV;P2x0e$P)<h;3K|Lk000e1NJLTq001BW001Bm1ONa4iQ{fO00004XF*Lt00D-e
zG3b_G000P8Nkl<ZScS!xUuawB8ODE>kEEkx>-b1@Qb$y-ohUek5*oTfx-A#6y^c`Q
zE+sS)yU66wLTO83iFXm5i(N>*n3Idp^rFd-7Fe(v0)u8Hg(Rko(t3o_;+1WoY3fR?
z;u%**k?mvsIhJ?vei@;3*EJZKPsh^xKJW8B&+`FbWnox{J*QyQf)~!hu>m;#N5~Gr
z*+0X@UGUyz_~;4v=U?IOURb{_zjyb_*+);vGZ%Ns|73^cGmZ_&XO3F(9mBeOCxB*U
zp=MjTt{LzZp}PWF5dym*a0v7!gx-ecb!ZpC(_mu+I?n=c$cJ>2a^`8!UXW*-DOjHb
z_YkaIf>i_R6{x46R)AUxtZXgQHLOFeVC9@tBpY?%Ar~H6|39xka0c+50pEqb_xeL;
z>a}V>WX7?rbS<M<S?RpXg{om?eJ7zi1OC$x$bfzlLK*1EKr;jF40tD@lYz~QLLdiT
z4%$=D%t0duZVuLRurdYp9Mp2)<e)kQQMYDCQeb95i)00Mp9{W|usjvX`sP3z1OJzx
zUxd&i^o&8ngVu-OoraCWu=$7-uyI(<S|7?Y?o+V#I;`A)d&j`p0@Z`CJPZ9N9XsMe
z-wc>B#R07d+ApMY-yAH>T3O$tpzVWT4D`KV9D#5e8fT$B0UQ0W`4d&ZJhZPsBM<Ap
zgVh4m*P!+<sJ3AFHZ0A;*3p_B&45(}^Ihn@k3e8I_<ts_Yh&Ph6c!7StnUo?KY-v0
z7$pdwfb}{w-vVz1Hm^zn-iVy7`(gD2)Jx#J0Lw>V$%MrM45S^qKLL>pn6E&%2tD%(
zfxsaMlx61rFQs$e8K{_6R*OS$5R5?x4}vuajX`MdfzF^5&@Mrv1ZyRz{~eqXESKOv
zC8(4kR<GGxKZ9rh`gTD0Tj-eq<1Y#Uy$SjrA)J0uVE2CjS{zE{NLJH8*P*u;EDKy0
zS}o{wq<~gS&gyljR$*xgDitV|VKDC457(i80;~#ze+@lpFp3bGRtSXNhR`lyduUN+
z9$b;mH4W~3Wo7;Q!8i)m1Z+75jZx_QMha-;VPzJo1z5~OIS+Sk!1m#q9g9K#3PjRi
z&dD|zUqYw|!TTI&UI*h-d9!Cs2xpW8c3lVmez=v7WP^`EUk$cw19ud>Q&NCC3e`!t
zTZ4s<;Z`0-CLBBdHEi7qkvf<Y(Axt>2J|EZXCOGP5NH>n6_-74c*6GZ37L6suXG-K
z4CW`TtWk#kGCXQS`*SIvW<w<oUwi`dao9awvxlCBfeR3gg1G{{X$buR^k*RW4+s>&
ze;)x)gZ678GOZ6~)z<4mILi{)`)Xj6VJ;rYMiMZbfJQ<JSiA=Rz72D?VQ<;7cRmT*
zEQqGTG@+*sp)}}Y5coOxp9g;tG*2P0F#;RcMB%*CvgggWgzc^?GvBgJI*%ma>TN3<
z-w!`MDg}Ig4z9ir2NE@VR~cfbAbJ<VLtq%7e+R)=!G936<DlJy?iuL5r4Z;m3mrq`
zb>pyzjJG1I)@lji+);sjI05nfaPE90J3cN2oI4LMzvS4Dmtmj`)-)Kipf5lm0R9Eg
z($KwIiQO+n{(bK$1b72BlcMdLkBGu;UX?xXbcF5RDVcdAA)Swp!;446R4=_#v$t=D
zz6+p#1O8K>O@QxD;PZj64qX$_)dyW8(DgUyDgtM~$B+D@)ok(ejv=nLaagq78xe(T
zwPerTQDOVyHJSOj^U^uMi$~z)m*DX-4D18zgc`veH3Ac~yc)q}HG(AgY|tG00TSjE
z39l#;mV|^Wv$E%vxUl`|`!e(G+og+_Uy_0jBw$w@Vv`WfKS07T1Ph9UIYq+fpnH!(
z;D2j4rPeSn#<EsY@>&p)`Qj5<wF8No{dies4$}F71YErhP8@dr>U(Rr4MKU)UxPqX
ztzk;7p<_#oYK2so@RX&V5M!xUMP3&^7LnOocI;h>?fN%Tz`#D~+=;_n9NcNR_n;7s
zK<_CC-2h!vLX-smkV2q&9h#r2B=eN=^OCsQ(voQVt-L7Q&L?Hht!ZI9$joDt(z!bg
z^OMk=0QYNHU4=*(%mVbj1IA4y#YrW_j;#XZ?^TR?UBZO(f>>&$BE~W@;n+h@D`@Wu
z$+QV6z?hYpZ?mNH=7bd79)?B(Toc^9GNU(@8Kod-D+Jaj!40VlcSDlQ@=@{gQdwLr
z{<VTME#%S{WY0m^9v+hS1};eF?P0j{6?h&r!_X{1qXOZavg0I#?r(v62-eCHAnzTM
z7`0?dm>7&Zb}S~Y7L5w23`5q-r&J^mkTcViXI59GbI+3oJQLb^Xa=CM0~+5#BMC-O
zA+UA{R^F8K>THn=w^)!Q^Kf1Hd0kwsr!Ly=Ul4@@*>gQCY&S<_=B_E7dnQy&=%m3*
zDCd0zS}ADFD+E>zs2dWUs|O`O4x}A>>t~W=B5CF4X>qmStD@~)iUV3+_B@mqwwnc+
zd9xs$chb^OXB50E(5^x|39aW80`&^qb0xPgtMuBRkPK&4ggm`H%Fo9{P`Y=EwuAib
zKPY=1x*=>g=Va#1fOOs&mBu<b*!V4YN$_F{fqDv@8M!p{pLFbKM$&8F4wd0DD#<(}
zey$xCSL+&41zZ+|3p8cVjhn*ua8734E=uQ}94t>k$A(S{Hf;FuuV#)d7sbeoV@Fcz
z#`3Pp?K3L97A3<4ijriy)kU_eC<XYEqV4{aC|ocpdu}9!?X8r|+)GO5n={~~U^A;Y
zU}b9=D=l|5GbT5do_Wdbp=n94!Eu%0JV`RX_kc6109zT0C-NE`7m*3svTCh)A)FTz
g*gI+Y@|q3*1t0>)4|}U(UH||907*qoM6N<$f-(OD1poj5

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/basn6a08.png b/Engine/lib/lpng/contrib/pngsuite/basn6a08.png
new file mode 100644
index 0000000000000000000000000000000000000000..61062308548bc3a5255e3e8dbb7f97932f00eb1c
GIT binary patch
literal 184
zcmeAS@N?(olHy`uVBq!ia0vp^3LwnE1|*BCs=fdzmUKs7M+U~W1%@xC#RK{Io-U3d
z5v^~p8FDok@VGrxPs#9K_}xB~rC;&L-J`A*vOzBbH2%o@YTWE%G>EINoAZB{akFeG
zt2^^4wiQ2lBNnjxnaU~EHpDcAJeJ<z#2<4<kD*ebW77Xe3mDB7R6DRwu@PXo$sieE
f=1|Wl{edA!L2Aym{+H=Ms~J39{an^LB{Ts5#DqLo

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/basn6a16.png b/Engine/lib/lpng/contrib/pngsuite/basn6a16.png
new file mode 100644
index 0000000000000000000000000000000000000000..a9bf3cb461231de29905eaa02f3a8a66f9fc5477
GIT binary patch
literal 3435
zcmZu!c{tPy7yiwHA^TDknhJAO5;JmTFJcJU8M34%B>R?S{LDp`Fk}h0vV{=c>|`0F
zY}t2XhO#pw*@@4+-}ija_s93gIp?4AJnwVP`=0Zh6Lm*li-YYn8vp<tSZxiX<B0s*
zxS5arg{8cz;{boCuBQ$_A~IzbQf!a&&SN#yO&mihX|^uHBR*{*KjX`EJ@u~4;^K7S
znZ-}x2|!2r#AusQ6tq*1JMtvb@`}-*EUt-U)gGM$wek3M?{Wn*u05Llx2t!WJfnfi
z*&A7X5|P#el2N}!iKN3dU<8r|CRs$6RIMxBPMJPfZc*@iYif##R~J1={rXbTkM2jW
zpAVXUmYnCr)*EyRNatG}eNi2}f3`FDlHQr4b0KIdIQ7?@MDW@Xd2WtcN<E7U8Q@B1
z;46o2QRJ-FF00|Mpjmc3aVc%yx39|V$P<5fkhLdT8c%s|j`z*KbYsP-nhfr*7-1M=
z**hcG4-NP?2^$+yj6jVaB)hdon)Os+Q_M)n*!c!YuPhvKP8%=mDyvp_jdy9xs1ja3
z>unKbAURdar&!F_@9SoS%FU_nL5v4bhxdo;qYV}(%9Z85QFC@Q_IDD58Vx)&SPd#1
z&_z21b`BlfZb@Z16}%Yv2Xg?CHRMe7qkJ)iJY&NQ*3GZeU+ur74iHv1P36E6yN%N5
zpV$8~7z8Rae`?A#-PAcaas4$5zYproUQo8+k=bWG?@3hw>tAT`15|X+#pzBR<JY!n
z@~!3)iYJD6F`s2~fbPC7LAABQBa;bEZSPfF#@)xL!MbbSkHIO=+5*2LT@-F4%BC-h
zkjs~0c=Mp{^gT0<tkslzg{x6EpQ97VPm`-{Sc-IZYI)<5=ZG}Vn4R_6l29D$Y2z_y
zu@G{UX3K2xa$$5B5Bk5>*EFaZTfujS2W+R%rAX5GszY`8KG_1tm1wxz^bYuH^_iu1
z#`8Dkd|UXn0~66IH5Y)%1^wg@FJA3z<g-qfYfZ)1vJ{D1ST3x<9QE-L5F&MF8wPLO
zIub@6gjSVOfP8)*<8))!Yju`hS+5im6`}RB-x-6zb+Y@i6yG6A-Mn<Qo;bXJJzX^X
zyQzp)kGua)ipSxNsO8P|M#QkHeCx87*C!ln3WL7Kp2_o21hngr2H>9$T7YRh1FE(o
z&iHoiEcavc!3({fssSC{c=<<H1_J{E0+6=)8^yO0XoX{i9O^xM-okR=8)j`EZ%T)K
zK`V?Lq0;!V7~^v?MrtM|M%m9q_r3MvMQHKLsuD+U*MlYbGf3edZIEWYDPcALuM<<1
zu=AS`iA<qJ*U1cpS$tWB+^MDAAQi6TYOo@j_1?xFnti6_zJ(Cq1;@6c<)0k&Hb&Ma
z#c_f&L(UCVX2byHRG7tE?~{;pxBFWF{MVrXIMg0z54v}qVTvTs2^`3D_laQ80s11U
zybZZD5*vulpLFppo4XNAnOL5R2vWG7A7*0$Tj+SA(>uH$6|lJ`Cw^#7+?<C$8fV;!
z*@+cdZaXGIsn3hs?nzD2iA>9Oeh5*sk;TrZA_s<KS2~MK_mYQb7}S*lt$g}*5SP0r
zF4*4|lZSNg_<Wn{TEt{fifiuJHU|IlU66X}<qT~0R~!viP0o0v>xq|m5T=dEMGV0i
z^PYDhxn{(1ZN~3SMiq)&y^i<G0J7l`qG{=-$UG$bDa97hNSzFXWE;~}!0OMt!pPl+
z`)(6K;Jf@$NBRGSl$8GmlA$^nf>@u;6U{BWs8VI#ZOVtSIoPu#Uy>G@F^}60slpM%
z4fg4f0@c(&o=lnNB5(wh%7VCL!-EVW2Z|!o{aAn*D%&65S@(Uw9aQtxwD)dfkbS0D
zN4fECZ9%?vJvB6eQZ4WGA92VxeEjiXK}uR*cR55gZ_cQBgwFlZzlpoCI^<hBj<w`<
zy%$QYUb+hC-FdL34$>@-;A(;$?Ag&)@JLm6Q6RE$C5WB$XVqD_cH4>}=w0RmK|UFq
zqT&JFo{xshQhkO07xrmHL<G{dAqdMbW6D>>wC3kOr5B~p#zX7$p_c_}QIK>i^mAbP
z(RxI|(i~*Q0#6E}svt<kWp03&ZAAzZN#C*sSQNKUa{Vv|^s^QPv#jZ9#_r#Gcc#y|
zJR{+%L}CVrKdAL^n@h^*b{)1ZU=V_~zx7%Xg5u8+=DI0$&f*1TKc9fK&xiV8fy9N@
z(B}~CTPq&mM)9VgT6zb2f3zu_rYPIuJ#`wei-xN070L$a3LPf7Rqg^N6BX-dWvEnz
zYk7+Ee@WalYbf})N*@hA2&2?}{m4q{(d9Z)b2noD?ZWT*GY^3kPb27iQQaP>MT(M}
zh+aH!wG#=NVm~3Dv%@S5-kh)W{c#dFYEqq2IfIFM+s<@5JzKFU(kzGaEKDY05{~)y
z&m>r1+fS3X-!8#9ZC}|9nR|zJTO|nFEi^1Tfpt@Ll^mIY?oP}|^w=aDO<B^-y~t3s
z$>Tn=uec<16y1Ij2viXQ-skm0LAjJTsD=F!#DdRhpGW%{rtjIu<QM4&UAdPEhpn=Q
z{w>duzuQ<{wdf>RTZ$_*JNG)(wu0^Ec6<FISH7z7Y3Qi``V0Y7^y@&>FbT<6xqSx?
z_!3zIUUfCS)6fLwA!%9Yvs}RFb1bBZaM#FX`Dt@6LHtQA1;AaBd4qVKP{nI32V#wJ
z&Xh<q3glMv3+*eA)fvL5{|B>LUx0p{l^jo|vK~SZ`ptJ4<ci1df8=h|`_pDZW2Ir3
zc{B_N-u@C<b841jjNHZ!GCJ8mI!tc^ALm<60h675%m6BylEFc9iIWCKvG=M*V4N52
zjsK9T0S$L0Wa`CL(SPISP&AsY6*zxU-=&ni4p;PRHiFcmKB24Y*JGS}l@Yq={`oyi
z)>mne>h=EQ)IBapSiJu{K;#J#&J6T*;znj93+*IlB6?-&YMGi|#xn!fR)W?0*~Y-v
zJb%t6l>}jz9_AsI@@RuRW(OUfTdY%wuhTG}3Ve9pnfH+Qw4C3B8)Pv=6}W4d99_e^
z#9AT03q=Y1K=%(%UJPCeUhitoH`-hON*?knX(%Hos$uAK073oP!1*Xq-mClxyor$@
z<Qr7JCjc<`>}heD;=s0m{le|mRTbo3Wp+E$278tBRf$HlP|fM)?++96CPyL1+wsjf
zVk53I^h-S=*7nAhx<|s)bJ8<VnbTJ&F|j<nRK1cj_D?0_5Kbb`+UIkpS^QWg1#4tJ
z&>w@jBPCFcgym*E9ryTcW-vs2fn~wpR?z?3`C&?_rYej3k<^}V2IPiv-8;{mgi2hH
ztlSGT$s1@-?Cm1cFWbX9F{sRW<Ym(=MXp$(FPu7y9jXvRfk~y@hvb0UghfmDBJSBY
z25ZGi12019mKLYO)|A&8II+^BrUk==a(yST_a@%w!E*-aHedmL4#>v(?cibljVBrb
znh0Bb)h@WE8=d#nxg!?mgZ_jv{v*Mtb>{rWq@mQ%GO4pYbYY3NhtwS%vk@F6@Cv0q
z;32kUm2%K;GCpIm7nY^O2baB-b57D+>*@DbC6}<(k6UKuV_t7>0Ad1l2vQK9%E7Iu
z&(5t^!vq|;yR##&(?y9Bxh>PK;x24md0z_`OZ&EXN0znDnHMLgT<SGV3huKE!!yZh
zBI1Z48uud1lP(gi!oKg@oee98n(-9pkVGMMP%O_Rn}+6EocfOP+9huOb6))ERcA_}
zzC26G0pfmeqzHd^`o`D^;75`%5ZS5E+C&w$1|qi=R2|Vxh1bbu5AJ^Z__j=^#>0vE
z_yTz|TbH$rwir9{GXE3${#InnMxfp1xrN`krccn6rI*N0fJ7fVs@lf)c+k@Bj%@7x
zn2jh^(!=IcnGPq-s=mA+pAQRc3WQ}3(CFdc(eD`%-gjE}`d9j0woiiIO||T#+v6=j
zd(Vm%BvEfmcrs6v+tJ!B*r>Oomj6Yn^vw~qcjX^|m%*OM51be;(%YN8T!+aSl}jzO
z!y8LjI?!s%Jnta+*LWjuuoDMp8d{FnQWAsFx^5}~^aqjGKt--Tz&i+DWSigz|HVB-
z?p9v``EK^JY(aBjc6TFYcV~A?IDo|@Q%5w24{w**chBHLlrK0ny!nC(PsT1>Hqnih
z{Bkl=fi=xu0ZFjuFh^xM2sQ&sXR~!_Q<r2rcF&8=lL>d=m2&L2Axw6>g3OQD`iWxG
zSjeA<d*&T7hR`V#FG+DKwVGd#sCe1=la!hglRhL7`~K;sGLuCbE^R5v#l0)h+oFto
zWXg4wiDNf%@VA@3<z~)t>Ufi`M4@n+JdMglmRaM{EnaIoCk%7r&sK1kSNCR{49-Ta
zj?6y#Lz!(+99uqME>10f)qmtbigTu-hI=Xb4zcPc{eH2<Ss@m4ys2bK^>y_7vv*s(
z*^3PwpUJg-5C=DiVuy>>a!|8$e5K?M)}J02FLf0O{QRMti|gU9y<b_IZm!I`n3S>M
zpsH)mY4<C4uiUSU5^`;8gWq=>IMnhuI<uzwV05L0!*0Un_<I7dn)(_gH|&W20{+#9
AwEzGB

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/ftbbn0g01.png b/Engine/lib/lpng/contrib/pngsuite/ftbbn0g01.png
new file mode 100644
index 0000000000000000000000000000000000000000..ba746ffb2f5e834db9e061b213a9c8fb38a80707
GIT binary patch
literal 176
zcmeAS@N?(olHy`uVBq!ia0vp^3Lwk~Bp9L@-6Me%Q%R6tFatx`<g*qaUXr)F3j@Qd
zUS%VY5>FS$5RU7~2?v;79du#tuwYQ>a&%Fgu_O4vfdD?GSMM7;DjgQN$$5yJ5Wm9E
z+5bP`$n$a@o=x-l8#oqN8qI&s(D|rVAxZ9n%ri5ALOz#2%tAd1O%M6amNPJH^j176
T`tP7S&>99$S3j3^P6<r_yB0Pc

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/ftbbn0g02.png b/Engine/lib/lpng/contrib/pngsuite/ftbbn0g02.png
new file mode 100644
index 0000000000000000000000000000000000000000..3d83bd6900baf4866450babb403ea2b0cbefc02e
GIT binary patch
literal 197
zcmeAS@N?(olHy`uVBq!ia0vp^3Lwk`Bp75C+I9jdmUKs7M+SzC{oH>NS%G|}k|4ie
z28Oc9XDvXyByV>Y28LC=%0@t5f~SjPh{WaI^M+gp3^-T=3csiv4Q}hPY)zR|f6C0w
zxJ2XcWoMTCF7}HoGFZJm8u^!HI&jaJ_kuGy=R#8y15dr<o%y=+ZlsGXVw7GI?T}ir
p==VB>w_Xvx6CN;KWxv0ZanUbL``{xlqk(oYc)I$ztaD0e0sz+MK9T?c

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/ftbbn0g04.png b/Engine/lib/lpng/contrib/pngsuite/ftbbn0g04.png
new file mode 100644
index 0000000000000000000000000000000000000000..39a7050d27af28f3bcb7bfc6b071cae91f8c091b
GIT binary patch
literal 429
zcmV;e0aE^nP)<h;3K|Lk000e1NJLTq001BW001Ba00000li|oI00004XF*Lt00D-e
zG3b_G00002bW%=J01xIY(5V0b00Lr5M??Sss*NKu0003<Nkl<ZD3Nv1F;Buk6u@yl
zf=5|QT&^T8CMJcdlS^9}9W3QS9GLE%Ca&~ga-tj)lfotX85|wmBrdWtn6R2Suxioj
zU2POdc-#G^ckiG3UYXoFc$qCha!)I_3-A`vl3A>eGf1AoYPn=%bN?oV&q3&xZP#{-
zd#wGeV8okcyH@o)cboHb1rrf^jB^?sG2T2?@G1n)CJc@hyhCf)&E8%^0~1oF;v>7S
z;6sBJiji@r0Yq=mmR;)Ojr>$W46R-Sau7HO7xZFtI1{|4z%-nLbW<Q*PUN+ZZM>=B
z3o0EAC)h$;8WIR1rohQ#w444G0#1m$Dj66xet|L#R>4C36e7xMM0T)(aSAa2XfV)D
zcEU#my$(kCaRx~QL^LgQ_;=)3gHxFOXBZJd{maEJLqY3H<>rDuET^1Yth7z0>+1gi
X<C0d-TPjWW00000NkvXXu0mjfX5*|Z

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/ftbbn2c16.png b/Engine/lib/lpng/contrib/pngsuite/ftbbn2c16.png
new file mode 100644
index 0000000000000000000000000000000000000000..dd3168e5c864a81f3284856f2b00fd1e52eb312e
GIT binary patch
literal 2041
zcmV<V2L||wP)<h;3K|Lk000e1NJLTq001BW001Bm0ssI2tcWq-00004XF*Lt00D-e
zG3b_G00006bW%=J|NsC0|Nox7OELfe00v@9M??Ss00960M`fvi000M!Nkl<ZScTQt
z3rrhj902g|lt(c5h;B@c8Wto`5z*MhVpEu6z!sLFwWDPtp>{l69U>r1pj4E?y3$fw
z3LPC~5Eu?Ow>bx*PBc1kWIARHF=os}<8u$TxvBB}f1oy5P`W{kzl6)>j^6kGfA2f-
z`~RHyuLHPP3zER+<N!HM7NQh34+(rt_L4eMKuSs;26c6JfUR58z}T1z96L4zF1}nA
zasnsGD6x?uVlw4{>gr^$apTp%;SiD#R;vJ2Rd{S@z+-2p1bTZD!RV+NOifLIU&uTs
zaE81?yrhgg@q`IfRXqTjnr;GKFNW3KjX}4zVxZ4FgXd*s(ZFE9a5b7MKz26X)$9LG
z&+U!?)zyVy3pqr7Bq1d50~sfsq>_}A+FGpRrY7tX9#13)1Tctg+c1b-yYP7603Ht=
z!sEyY-tFzh#G0G016J#8z+$-u)Ys$P_ICWwmKHpkOd3!^xI`}9Pq-4f{bx<!Ah8hs
z@l!$C+mpa6uVBG1zl=o=4dMBY9azV0ZTAAVI~$CQ#DU4lOTcHJ;r~oe<Nts46&^qN
zWF|?t{_3lEZZ>0*+^SE_VlClnoi%|Y#7Z`h22w+;)<?kbFxKC;Z8rjkV+B~h9t)^C
zPklWGG&p!4n4F9S$B$nHzWD|do|wRK(%*jzsHxF`^Pf;kR+ERxJ~C?p-x3bGo?s$Y
ztCR4M<@R}c!EnnP$s;72WRWk)tO@X-u~-@!ESC8Aj*j^Fu(1CAu(0IhzP{vSyS=T=
zZugKD@*JtTAk{%QbnYZMBsgdl(UX4}#B3vxq&<5i=%w$zi+%OX8JstUhV*(j;Tfre
zw2>xK8=@ykF38Wv&SbTQ0gnee+4}W(MW;&#YW1^ZP6=>`(a|rw5FIVVzI~X$*|S2#
z#!gMe#<mg;niJSWc&^}cJK@e&7sO1se?Lla-pS9$(eTC_SkA$NJgve(dh9VgFDk;B
zORL>Z=9B;j7ZcOd6B9%84Llg;62WOyR`&K*R&qyjI668Uj`Z|E0BdPrAU)mb3<U5G
zZ6-W^I05b?xdb~(Ztk_<{r9niQ>U<mEn9Hr%FoAHNvXu^1_MqPdi^AsQv!Wt=~AC>
z=~5vE2k|lQz4vDV3dQ)iLcy)1R&U>~RtxF%*YPf{2T4htok>Yuq?_=<#C@GZ=iYo5
z=;^^{Ll6SH>ZM@SDqJsaz8SmF;>CE>Y861E`I*cqfgzHR(9)8SfC~}N^;pQUV?snm
zo;VR1X|s8~Hd|WSz(87>ka+ppv`GlL-0PLgx$e0gIE@Ozq2ur@DhdbZ&T-vi=%uA{
zke>b^i2=#U2|%mmwg3D$XH8&?$YhO;GMNy&cVi*2uK^!^h{x}~6Cx|i@6XCoC;|b6
zLP%p{c-`j{LaA(PQ!05pa651syuNY*7#3BC#C5-QYdp~Fal5x-1%_T%hj+WXu_HO1
zSQ$M%AtdlINl7uAQ&Rp+pr!_kf>jutJ}tzOC3gFgB?`sn&6ohpRG^~+6YzMHN?tF6
z)8Gvs_ItfP3Y<KNA)Y#gbB@V$H^|M!&56r}Pl7E9+^wy>9OUJ3g@%v-FJ~DU6%`p7
z)Olt$T~Sd!UsRM3M~+}20|P?D#rb@3aYB0gZM=f}n$%RcJ2lluI1TPj268{JSpMqw
z(#Xj5ATJMVU8TZja7CF+c-LgQ0jykkmV}T1Z)>x&AAcP8jW9H!K(AMb#Kfwq#6%(9
zdJ7BLzaPqwJRVppB))>Rmzmkxnwc3qy>c2ne6jQN_2Kir{~kkZY{cD_MuP+Q&O34b
zF&gnn<>h$S?_Ul|OJ@sx)&y8_ad~-hu@GD!97Re>K|xB&qDB4vixvs-(MMR6-Hvxh
zNAcY06hf_bxzy_5Wv-p@`ik|vcQ5|p=ur%@xHuJLW+o7vbJnfHC+*q8Ezk(u?h8zy
znS_T20^#98!p*WwR#+&LEn8-_E?XwV`1nk}hj4frZEhAqrE)q|DqbZx4c>IDBv*pr
zVf@9&2+ll(g&73fVa*!eeB+b4x^SH6bo<E#Ch!w+xpwVxxnwe{RVFhS)~qoYjK;NV
zjmC(GojW5Ugn02q4rit{ghu0VXf(W9a~iw_)RN1<^Uvciy1H=48jUirdNmGZzaOvf
z-i@uad^x_JzV_NbhyE`K1e+l12*2+pCbqQTczEe0EEe7ifXya^R%^FwwOs3*2JdP)
zfyDr(NC{sqaf&P`z$3h9(pwx3*^-hEz{JE{q6#4acAPX4ovyT0rxRl5PAr`Itk|#t
zTfk<+RzREvufe=Az8$DkI9Pd}fo=ng##=!}#i!tlFXkRk$O$l>qXx;$c0=OV$;L(@
za&nrQa&mYx$7%2ytRYH*og^*}=lHZV906rzC&2V{sF7S?0>KU+o}4^<ST6Vb<#L{6
z&F1=gvzg!KI1TQ2{64jU+(URz$|LP!Vwi{TLeqpdZTyPE-Hg-VHTWUIuPOYWzmkhD
zecryz{YKs-{8r6r@EXi5FihsFM7AKG7LO7a;aQ8ncPvC%3;1#O9O3Vz3s=hj{_FG~
Xn+*9L`l4YP00000NkvXXu0mjf<{8y)

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/ftbbn3p08.png b/Engine/lib/lpng/contrib/pngsuite/ftbbn3p08.png
new file mode 100644
index 0000000000000000000000000000000000000000..0ede3574db0fd51fa9266fb1cb91df3888dc8dbf
GIT binary patch
literal 1499
zcmWlXdpOg39LGN{C5sa2Bt0E^MASS96&*cI%O#g#Op9f6Tda`V#zwgtX^qWXhM`=#
zI1#55hvk;s&XW|W)v?OmN^($fe!kE1{l1^if1mH`{bIW~+p3~=p#VVD-VW=Aq|W-?
zq=3BGn;D%*C{i&_7?4X9nM~yR0LYKIIJ%!+TU)zIAT%^Qs<O5&DJiMd(aF@*EGjC}
z)+QDf76K&a=jU@OIRb%z&*$gl<QN(fxLhtkA&0}s<YyWiS7v2pT?NR@%xnZ;v)L*t
zLyV}Xw6rvUx|EcZTL2P(goK1ESFQjQ$Hm0~bTgUEn3$NOM+tN~Jt`_HA|k@B+U`2C
zlDt2FFM&<izn_KA#IxBPDwP@#5J0*_()gs2s;?i4Mq{~H3WajK=s1>*waT#qxC!3?
zz5<a*^z`)f@bJLn@n$JzuCA_n0zDiKXK9I1Q+r&ubt`lMbimJ_KcNj26$Ky$G#$ON
zvH~p#n+wnkZ(hDsQ)4RMQ(jtH0^~CfK`1O;TwGKsRe=WpwV=jTgF7%kKM&Oal`uCq
zH#0K>0+^bb0-!+_LIFVlkOn3uCR$oXN=hfy)oYZM=LTO5_V)JX0F)aUb#`{Px3~8K
z45Cm8G#cZ?2?d2q03|3C!N$f8gK>%=kzAFOs;a7HXJsOhsJOUTC=>!T78DfJ0p#W7
zO#|fS<`x6+csvb_-PzgMH*VaxejVY*&B(||Pfw37i%v;TNli^nPEKZQ-I|z~7@ruA
z92Sce8ykD3^-OehbYx^?czAeNSXdrFNJvO<Sa57$U~q77GNMZv)*;t{;!pAQ^@RmE
zmUqnC+xy(PbMP4{h-A&MCJ+b!UyOOiwij$oOvo?{Zf<TaE-ugyx_P?Ww_k#1;OOZ1
z>(?(>_pT_EMw{BQ#m>$Sn!qg3OkVyw9#4k*05u5X^#Wxw8I%DBhvS=>0kTjoKsJnz
zkHa;PN~LfWvNvv&lMD4H5CQz1ooNFD1Ml8_0AO}^ckkGN(bYw&Ct|UTmX?<3ckj?>
zcNB^Yu-39J8}w6t>_9>;(#;tUCqEAdt`EKrw%G5dUucga(q-6VG498*{K%rij4wv2
zoEfW%jzHYO{1#TLQQ`9W=k@mzoI;b9QinWz_A0mp3<fU|ii7Uo6?z-~-FmyZIj*fd
ziZtLyt~2>_C3m`>c%tC$KR#Xus#^maPqG>$Ip&r<7PP}+lo3xrqrK0bX_;b9>)$CG
zYiDOPWRFqn6UcGDpA~Oj9{Dz;6-NwxejzAm$n<rQm6vD7CjXi@@e@{OG5xGtjixtw
z<}TuSbWIxWZPFtOcih}-Tl~MvQ-|(HR(Hk<+6?+FPLV7QO!B04L98aczu=_!`K%4b
zRUW;$6jgEB_F{vY@M%w9H@dWmQG5GUuEU97)3&w^mLgPzp8o7x%QPSVa$_8Q;9AEt
zy@@Xwt-sTLwS4z&k@UjU*Lyt`lf}6AUHvZ_BGVpBP#Z`c_(F4vxVv7~$uDx=tIc^Y
zc{SKq_jGxrqd7}5etz@a<P8B0%y7xJE~mfZAI@5gJb4YOVT{3DLuRIXDs;l>^KEA<
zw~yjS7UP676`?(gNA_%Ti&?JTRiQ)ukN>niNvk-4K4Y-(eYokz+n%p00U^e=@{X9+
z)rI4_;#GQ*EM)A{+^B9WciOLZ)vuJAK75`z`)0L0X_*pJxWq7M<jtvuqAm3Wv_u!3
zXzBchC(@B|nb)^(%CfJML!lNQ!X7v7D%Ih2#XTS{@P}D`n0Uk2F9u7tD0W{yRH|1!
zPU~IV*P*!+wb`iA=JI4j-ye&+(e{CTrY%Bu@<IKkm*4%Qc!l!cR3>yp(uq&jr<7|o
zLnIyhWR@l$6GSYpXJsSmv@J23K`FjDRPrN<`4!1UJg1FhP}`#*W-iAZNy`g6qae<l
k4AflusI^ml&j&%5BB<7^af|q)t%#yvf7%&aV@*!{AM<IOUjP6A

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/ftbgn2c16.png b/Engine/lib/lpng/contrib/pngsuite/ftbgn2c16.png
new file mode 100644
index 0000000000000000000000000000000000000000..85cec395c01b305335172fe781aad11e485f45e1
GIT binary patch
literal 2041
zcmV<V2L||wP)<h;3K|Lk000e1NJLTq001BW001Bm0ssI2tcWq-00004XF*Lt00D-e
zG3b_G00006bW%=J|NsC0|Nox7OELfe00v@9M??Ss|Nj60ncj(G000M!Nkl<ZScTQt
z3rrhj902g|lt(c5h;B@c8Wto`5z*MhVpEu6z!sLFwWDPtp>{l69U>r1pj4E?y3$fw
z3LPC~5Eu?Ow>bx*PBc1kWIARHF=os}<8u$TxvBB}f1oy5P`W{kzl6)>j^6kGfA2f-
z`~RHyuLHPP3zER+<N!HM7NQh34+(rt_L4eMKuSs;26c6JfUR58z}T1z96L4zF1}nA
zasnsGD6x?uVlw4{>gr^$apTp%;SiD#R;vJ2Rd{S@z+-2p1bTZD!RV+NOifLIU&uTs
zaE81?yrhgg@q`IfRXqTjnr;GKFNW3KjX}4zVxZ4FgXd*s(ZFE9a5b7MKz26X)$9LG
z&+U!?)zyVy3pqr7Bq1d50~sfsq>_}A+FGpRrY7tX9#13)1Tctg+c1b-yYP7603Ht=
z!sEyY-tFzh#G0G016J#8z+$-u)Ys$P_ICWwmKHpkOd3!^xI`}9Pq-4f{bx<!Ah8hs
z@l!$C+mpa6uVBG1zl=o=4dMBY9azV0ZTAAVI~$CQ#DU4lOTcHJ;r~oe<Nts46&^qN
zWF|?t{_3lEZZ>0*+^SE_VlClnoi%|Y#7Z`h22w+;)<?kbFxKC;Z8rjkV+B~h9t)^C
zPklWGG&p!4n4F9S$B$nHzWD|do|wRK(%*jzsHxF`^Pf;kR+ERxJ~C?p-x3bGo?s$Y
ztCR4M<@R}c!EnnP$s;72WRWk)tO@X-u~-@!ESC8Aj*j^Fu(1CAu(0IhzP{vSyS=T=
zZugKD@*JtTAk{%QbnYZMBsgdl(UX4}#B3vxq&<5i=%w$zi+%OX8JstUhV*(j;Tfre
zw2>xK8=@ykF38Wv&SbTQ0gnee+4}W(MW;&#YW1^ZP6=>`(a|rw5FIVVzI~X$*|S2#
z#!gMe#<mg;niJSWc&^}cJK@e&7sO1se?Lla-pS9$(eTC_SkA$NJgve(dh9VgFDk;B
zORL>Z=9B;j7ZcOd6B9%84Llg;62WOyR`&K*R&qyjI668Uj`Z|E0BdPrAU)mb3<U5G
zZ6-W^I05b?xdb~(Ztk_<{r9niQ>U<mEn9Hr%FoAHNvXu^1_MqPdi^AsQv!Wt=~AC>
z=~5vE2k|lQz4vDV3dQ)iLcy)1R&U>~RtxF%*YPf{2T4htok>Yuq?_=<#C@GZ=iYo5
z=;^^{Ll6SH>ZM@SDqJsaz8SmF;>CE>Y861E`I*cqfgzHR(9)8SfC~}N^;pQUV?snm
zo;VR1X|s8~Hd|WSz(87>ka+ppv`GlL-0PLgx$e0gIE@Ozq2ur@DhdbZ&T-vi=%uA{
zke>b^i2=#U2|%mmwg3D$XH8&?$YhO;GMNy&cVi*2uK^!^h{x}~6Cx|i@6XCoC;|b6
zLP%p{c-`j{LaA(PQ!05pa651syuNY*7#3BC#C5-QYdp~Fal5x-1%_T%hj+WXu_HO1
zSQ$M%AtdlINl7uAQ&Rp+pr!_kf>jutJ}tzOC3gFgB?`sn&6ohpRG^~+6YzMHN?tF6
z)8Gvs_ItfP3Y<KNA)Y#gbB@V$H^|M!&56r}Pl7E9+^wy>9OUJ3g@%v-FJ~DU6%`p7
z)Olt$T~Sd!UsRM3M~+}20|P?D#rb@3aYB0gZM=f}n$%RcJ2lluI1TPj268{JSpMqw
z(#Xj5ATJMVU8TZja7CF+c-LgQ0jykkmV}T1Z)>x&AAcP8jW9H!K(AMb#Kfwq#6%(9
zdJ7BLzaPqwJRVppB))>Rmzmkxnwc3qy>c2ne6jQN_2Kir{~kkZY{cD_MuP+Q&O34b
zF&gnn<>h$S?_Ul|OJ@sx)&y8_ad~-hu@GD!97Re>K|xB&qDB4vixvs-(MMR6-Hvxh
zNAcY06hf_bxzy_5Wv-p@`ik|vcQ5|p=ur%@xHuJLW+o7vbJnfHC+*q8Ezk(u?h8zy
znS_T20^#98!p*WwR#+&LEn8-_E?XwV`1nk}hj4frZEhAqrE)q|DqbZx4c>IDBv*pr
zVf@9&2+ll(g&73fVa*!eeB+b4x^SH6bo<E#Ch!w+xpwVxxnwe{RVFhS)~qoYjK;NV
zjmC(GojW5Ugn02q4rit{ghu0VXf(W9a~iw_)RN1<^Uvciy1H=48jUirdNmGZzaOvf
z-i@uad^x_JzV_NbhyE`K1e+l12*2+pCbqQTczEe0EEe7ifXya^R%^FwwOs3*2JdP)
zfyDr(NC{sqaf&P`z$3h9(pwx3*^-hEz{JE{q6#4acAPX4ovyT0rxRl5PAr`Itk|#t
zTfk<+RzREvufe=Az8$DkI9Pd}fo=ng##=!}#i!tlFXkRk$O$l>qXx;$c0=OV$;L(@
za&nrQa&mYx$7%2ytRYH*og^*}=lHZV906rzC&2V{sF7S?0>KU+o}4^<ST6Vb<#L{6
z&F1=gvzg!KI1TQ2{64jU+(URz$|LP!Vwi{TLeqpdZTyPE-Hg-VHTWUIuPOYWzmkhD
zecryz{YKs-{8r6r@EXi5FihsFM7AKG7LO7a;aQ8ncPvC%3;1#O9O3Vz3s=hj{_FG~
Xn+*9L`l4YP00000NkvXXu0mjfDX!K0

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/ftbgn3p08.png b/Engine/lib/lpng/contrib/pngsuite/ftbgn3p08.png
new file mode 100644
index 0000000000000000000000000000000000000000..8cf2e6fb6aabf7c58efda0a953857b318607af30
GIT binary patch
literal 1499
zcmWlXdpOez7{_0ij?5*IPSn$xo>J622^AeZriDs|F)fz44lCrgvCaK9(i)p7!%%LO
z6LCs$SZ>MfJV}wPPOIFlR1QvYe%|MK-}ia{df)f+{c@b0>@`sOC;-qn<$!ZVI(j`f
zDj^kjGph?}%2e!GEGVRlO(*lc0TkamJGz}*TU$#c5*r&IR@vH?l$6w=(b>AXMMXv1
zx04DB3jtEEU%$?+<O+pCfk2R#muF-|<ned_g<LK-TaayHQkj#JlL(NVo!tb$;c(Q|
zhZ)h)85tP>^=WBow*aI7Nl8fw2?+qjY&IL9hsk8d#>O5wLZs8_(b3V7k&zD74p)(r
z6#W5wi5%j-eJnyYfy3casnmdg0P-cW&PSbeL&Go(2FJts`1l+vI)>xmtn;h^Zo*f9
zFF+!ZJUl$y-Q5WUf_a*`i;K%{;ch%0Z)Jtm(t1?CX%ln<bi$7xKcF3ym4zSy3>~ww
zvI4CLn;>X`*DqdZX)#srsxB=p0rJcP5Q$0`7Z=q_)!{xs9cb~i;5IBQEI>6tCCtyy
z&(6+*5T>W60ceneP(Tm>WPquush*y(ii(Z4cCD)F{LssxzP`RZfO2EwuCA_*j*dQn
zArvZ!Mq?a5uB3Dcpag{?+Sxf^v1cR6WET~cs;a8FIk{LYE-o$>i9`TRH*Vah2Ph~g
zm;uPo&o2hx^Z7bDJ92Y#uU)%#^(w-Tmz9;3nVA_=7L%5lmY$xTnwrYkv?)0`IX*ca
z2^NbL7Z-QB?Q~2`OjJ}<L_|b*cz6LoXlQ6ict~7eU`R+vDq@#1+?o6{KK?$wzP|7c
zjussC^71-={ycm_1R~oqY>7l7z-JS_iG7g0sVN0Uz}3~&+1VKez@Wfj%a%*<6dWBL
zfByUl>%J=rqtT`{H60urpc%{q%@q~D69^Qz2T+SJUKda<mqQtF@pyr`IUon+1LVTQ
z!~|RcnM?+Wko(Io3JPKVL=u3%lM`)laBzJ59RRbZr)TR{tbqX{Jqd?nw6?a+jE`e5
zZYUH5V6BzSuBoYE1Xx=jTNI*Pod{s_X(Vuc@I7OX`+oBI_A$hCS*LJVx1%|J6!9U(
zXJZZStaU|aApXGhR#uyF;qrxN4R@2yhNUc}54(HsQgRL$3Rxl+2j9CR@-q6Xt)``g
z-CiC|9`vKsoBpwqKhr=ue&f#H-k$rb+X9<xSdG#=3#(pB+93(bm@lN!-saA>PBUi=
zZ<oFA;AA!CzNa=MQP{tolc+6^ejV0hlfs?_1qTnCy(+Ty^yu8^U;8?K()t{BfOV_M
z>?YsBS+ans&A`7&dFaENu<+a*|IhOD!Fy5FU2($py#tmf$d>!3__F$7Rx`n0Xd`(x
zXNPrB#Hf{`Do)y8Y}67x>Fw{qlr}T!YF_4_IUZux-oC*~jH=jeIQPaX!`r{y1WzBl
z(m6wK7D&e$Zg(V>@2C;Wf~LRR?X8$9#=q?zc-|P5aetE9NbV#QTKGtM8suGqBBx#3
zxo@Q}hx+TEERS}!<VYtjsNG535YWhskZ$fi`)B-vIm^+<uRtT5F{D3iZnm=m9YJ4c
zKUcYBj4-;$7R^?K^)4RXxzROtxmv#hP5oE!q$5SIIEg;H_uKc8=KtRGepv|!HL+K8
z#I~(|J7yqRrKiY4-+!DRGl=8O_|>iYl~OZDE->d_uXdy?`@|M5G4?j`=QYAGR)#`a
zvNJkHwy@!`Y;;2I`Sq)+{L9pEnB}|hM@{;rXnr^QKIxlagyn~gH+uDas6<n_=kmeQ
z-PIGczQsMAy4z4{#!YsYry~1*U)+H?71(dqDsrP7Fl>JD-A_hPD*sh|5-pZZezZNI
zTBjQ-?c5``GX0PwW_dm>8`Y+1#_9&A`Q}k652Y3f(u)LcJ9%$iuabnh9D6vUApEqF
nBzr1Qcj<%PHtn77gx$)ZQM<+~5{$JW7KKwMop80bl;r;b+-;m}

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/ftbrn2c08.png b/Engine/lib/lpng/contrib/pngsuite/ftbrn2c08.png
new file mode 100644
index 0000000000000000000000000000000000000000..5cca0d621047cacf1637cf7d77e997d51cc6b15a
GIT binary patch
literal 1633
zcmV-n2A=teP)<h;3K|Lk000e1NJLTq001BW001Be0ssI2{21+{00004XF*Lt00D-e
zG3b_G00006bW%=J0RI600RJ~w8+`x(00v@9M??Vs00000GbeoW000H_Nkl<ZNQups
z3ry2@5XZm&Qfx3q4QQ1H42F>)6_}Akuqmh*5X4X^rIbM;BH-v?$kU01p_ErCl=u4~
zL7fbz&H-~9!(}3aFu`RZW&unzb50QkgK2!RYsr=o3t~2tT^d3tzx&+X@9uj)%)Vj6
z{|IpB&Yj-g-pR?y{}^!Z-o3WAwzRagh=_<-fB!T`$I~7jJzDL9k&%A|7#|<+>gvkP
z&5eqRQiO&cb#=`%Gt&SnAO*+-su`xq!J$j392p#Z_UzeG0aH^`SFc_zD=UkSkAGjG
zNZGY3d;R({hG_tbfDeIqE;r1<L9$|n7?A6E#mkl*jf`w;Y#bOEc>MUWVZftDkNW!h
zs;jG$lamt?5{`w2W;;5Ta5(kAS>OWD3k(34fhLB@x3Eyz+ozkGX8`3uA)t^*Vq;_J
zARVu%si6?50P_I-{r&0b>GXAy-pZYvJ_kMn+JSRiZt1pd#bWVg8=D~(>oza}`~v)>
zM}7e)8HRFA`iDhFM^mix0K>z>DwQfHCnqyAGc`3;6%f#2ZhqFvO5^8uBq=H7FUwFU
zT6XLhvbG*uwdz+cchJo2l$~8_P|)B15EmC05)$I?@88+kIS+9E{(W+tk&&UwQ56&v
z(A`o(AH0rH_Tk~-0RaJGvDnww_wL=h^8j=?>6z)a6}IeCY}aO2b*Z|fq@=L0@WhD|
zsSDdty^(jSiA*M&bM5WzEtks;bWvVj9&?GoHDC(zc6o7eG4)bKMMY_8X?Aw@u?6h#
z;lshf`|a#hY<3Bkd&JHz$kWs3`0?Wg0OXPTF&CY{G^|Igi;9ZKH36!ss;DvOr&_J1
zx~1t&sZ>(M4;(lkk?c1!`x@w{b_L!AqU`OZt*xyF0OXE$lBa8(+d4*aQ!-UaQ=##!
z_w+pDSx{e4UteEaTT3@Y0IErFaIj1kyl&n1z;8e!i?yF&L_nC8m3(Mu$N-?Zxp_n7
z2DAX*=>Wn$A?4)L>VvOzv*1+iR99Em(9l2wMRh0dROro{PXe>RH6x>UEG*vQa@TOV
zQlU`t^yyOrfcExwL7@Om)cL>za2|4U%W^%=c<5%V3NB?X6h0+EjKsu5@-7xf85_?~
z_(n!?E-s$Cckkx$Tm=FtNq~V#ChO_xan5qaMSv9N2jF-3*7yqRh3Ek)Au1KoO;8fV
zprIvzKyXeU{%KoVxrc`zkCz5CFib&h?McIcn>TN|Dcy8{RDkAq5^L3Kg|$LmUsXU<
zBBJ4(W03sGWO5UeaSET!R&3c4%;9JOl9gkorlAz5VF1mVSE84$J}Q`0nqU|>1Di@4
ze5+F&_hR?T%1UBTp~Aw#cJ55qhku#R59RT^^+74<V`&*UJw0t0K$0tdPps3nGB~6-
z;2WSDObMg=MT<Q}d*)h}7<9t|K{N0Nkmckgv9NfX#R>-!fSSE~<7VgEJh?uUa0qm;
z8Ez47t52=QkANEJ0t(=x^_iQy^73*TT0XxG7zGZwyYCSQ1YB+maEUU=$|_zAke{D#
zTyIS3>>TO5U9}y3y6WrNG#}mt-ZU1(ApHmo3|zUggX&{s6zS#V<>Yh_y5_4hF$wDK
z?p_S=<jE851+BBnIqYCqcy#!(^ULswehH`{(MV{vi9tFjl}eW{|A;(tIN{FDA#8RH
zaFNg7+t&8w>`P`~WeyGw#>B+X26iZPz^D41kPE3=O0g4z6qf*N)=*PsGE4-+(Dp2{
zw2Zxeeeh*hh5=+_V`EuaSwV3@IIpj54kWn}jYdNZ8e`JrO`E(~ENUAnPWZ-+iMMY3
zY|zhwfLVQ0wY0S8#Df-Q7G&8n5<6nh7)vA)kx0bn+nAbqczMM?d^oX?lf?jYc4O#<
zON|S4tujMN`;Hh?Jz7|PetuiGZY4pbYg^pItKUTv6B8tGw0Wp##Go<Ww{IWq7W(7!
z=g(hxd`U067cX91xpIY;HZf?7DT9uVj-?!2Dqzk=M@O|<Ep-<?L6&~%^&Y=7Gc)u;
feXS#J{B`{&ejxm6UY$v!00000NkvXXu0mjf$4>?l

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/ftbwn0g16.png b/Engine/lib/lpng/contrib/pngsuite/ftbwn0g16.png
new file mode 100644
index 0000000000000000000000000000000000000000..99bdeed2b3b8564302d449e6578c4aca0f6261f5
GIT binary patch
literal 1313
zcmV++1>X9JP)<h;3K|Lk000e1NJLTq001BW001Bm0000027&o&00004XF*Lt00D-e
zG3b_G00002bW%=J|NqFf-^Ty|00Lr5M@0Ys6ss}K000EMNkl<ZNQq<kPa$BSsR554
zpFH{TBUuK#c(HYBU0rHw)J`}3gdYn99|;g`z`J+*_jh)trzcME*<~i86`=l7d8_&y
zy;lLA6TPo&|MLfr0iQk{IWl!>QBlsk;7PU%bhGrgYd5Q9YAv@pu5?I(QEIFDO9PIa
zv;_;!pa1a#&4BOUPo0`ItE{ZJIBk{3V?$2;ETe5E7i<FTWX)R)1FdJfRv1^SZPR7e
zdKuN8msea|RyKR~kt6Tk!3{WbroO(ctP}|R#Ldmkn9b(e#Dv<U$OWi5&Ue1(zTGv@
zG0RTQ{DPWU&b(46$jX{E3vR%jJFTr99W5=@)yW(#p6>FAugap!!JvpW;c(dAAQ8V<
zZ&BY>NjD*)1qCrNK|y=>!VP%!s->l|vE8$;ud}nhz7j7eD@#re2?+@B@p<+PZorQp
zO@$fmNmnXtCft}jxxc@;xf%mh0YPPDR#td8NVBJBWF$%~baiE3DVf#RJVAESq^VP<
zPoFZSy}bqv6c$Ev8{HHsktow$<F==%3B`a(lQP%k`}S|_&z(4N%9QETXU?2Gd*;mU
z?)v&VAgHY^FHcGexukksyjb7_j}Z5Ded#r8Pz;zdCH-R-L#ufI#tHG0Cr>V{lB`di
z{%hX6Idl5@>guwxqN2jr>pYX5E|kJ^f&DqRx(f5PYbXXRS(0v=B3pVK=!U{clUf+^
zwk5aa8O@zLfBu36RaH?@k&$+SvH@a;con5$c|}DEZ2$iLjbgyIZE5`R>8TI9Qu-<<
z%&Jo_i;I%V`!i?Gym|BImy|?C27OhSEj^vT%kqkchm?%||Dqzaq<s8%N?nFcFlY7Z
zeyOTUr5&Y)k<A5_vuDqpJ8xcIUSy<|jBJ3gsJ6Vz5+yDncR{nc`e+8+xRD%@VdIgX
z6W#kJI=v*SWLCtR{7189fs9B`51*tQ1GN9P`FgQqLYjPzV)n<6qZ#n(RpRl~hkn7a
z_Kkf>5gD9C*CIj-6lTnrHEYhC#6(Y5*#J=&#dFf1`ILEld3=?QfBAxDz@I+}XOr8)
z_eUHoTv5Ut_PcOJ$k~z>P;}0k6%}PEBIC}VVH_mAk5_}&Lhw>xFqZ6`_b6dX!jw?c
z%!-;Dfwv2)g69`EgOb#=Y2o48uO(Z#zd9_?))qGsnatzc{v3+|Jw5UA=}QBbWjreT
z8u2D?TToHq>&cU+PVMgx3sZ_0b>T~KcQ<txnlHp7BzN>E76X3$TAY#mJXtlpDYGZ7
zBIi@!?b7Or6DLpZ><kT+F&5$xoMmxVG+rc9{`<DH|NpTV00I{-<mRTPrajKMoUIqI
zu2iYNf8xZ(#?Vkjb$(r*1_1$q)vBH6IsgC1X~6&gZ{D=ErB$W#Wo8D57c2Dk_V-s+
zg@oug@`-TQb0->}crfArf4l~O;$zjSbkp>uelLq>cX#*pmXrhs+uBMi3p@E(ywgBe
zjiXq<a=559;$Z!aj*jl`+}xlbe}8lH^73E5u&KpSFT8)hU_o<pTU$p*dU{}BK)`|p
zfB#}viL++<_wT@g*4DPR#KfSW?b~swB2cy6yEkD%YU-IY_|y=nT)%#O{20Fqifd;8
X;LMiQGdCU+00000NkvXXu0mjf3u}w^

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/ftbwn3p08.png b/Engine/lib/lpng/contrib/pngsuite/ftbwn3p08.png
new file mode 100644
index 0000000000000000000000000000000000000000..eacab7a144cb54be28f7a5952a2fc63fd883766e
GIT binary patch
literal 1496
zcmWlXeK^w#6vvOZ$|54&sN1DSM9q^>(d99%ke6YZ7R$UYR><4NHs#$&Yi#Ca7>ZQf
zh+9gR<t=%;Pf{e)ZIyS6%Ec}2uk$?Toag*?&iQ=5Y&TbXRg?}208||vupUU){h6B-
zkcz#L*@-ko3dRKka%m#d$vj^G`EfVr(<j!~*RK!=jg1d)+1Ztrme%R&W@%{^7Z>l`
zNh~TV0!S$+DBx6a1Ofq{&(F=xH8LV_xm<uE4u_M)&oVKo%FfQd0+5xJ)daw1vsF}v
z=rJ+r>FEIVsi~<q0VDv4iHVmlUj`^)u~-1z3<e`EF7C(?0*ywCiHV7digKuSxQ3i0
z9|+)2U=#N3W8$;$Y&M5Np#%j5kuH)nKWe5K7=)wIST5Gj&+l0AF)SNvoofwn1HJ$(
z0Fg-a^78WZ^u*)w=BeiH?(X^meH;#FWra~!e^jrg23-Ih@csLDXahw>0f+%jL$9u`
zLJPv?JUoFnFJG#wGn8wTmzS3TdFBBKg=I@iODbh5a37!!)Vb<#2No9>p&FnH=I7^U
zXJ<hG)6>%cRLDjsAP4}`!PL}LTibZ!Mq3SyT4m+=!B>O5y}h{r6~@M$ot^FN?Y#hl
zC{!YqO1H65P`C(Cib4@io^-%qT%t%M_l+BG-MTe5CliT8B_$<7p%9>{u&}TmAU{8U
z1|TmluLOX{<7sN{%E`&Oe*OBjYY0DXW@ctaMn-ITY-&boT3T94N(x;~Eh#A}At?a~
zCX*Q-AAhR#RBUW)baZrNWMo7{L_R=RSXgL8Xnb&RXlQ5(VwZBPQ=XGwpr60LKYWFw
z`A2<xe9oRd3!e~yNOp8P0)YVV*@S0ef8O5Ilnle*;o;%t<_7(sm#?>N+eLT=&d$z1
ze*A!+zAFx=Qm40Uad2>eW-t#nmzV#B$CKe6KrO=fr+_k<49bCn!|~0{0XZlSAO|KU
zCg3VarBb*8IU6>}$%O|Jhya1EuGE2nfw8f70F3VL?(N$#dU}ZTL@bux($X?BHikx@
zMxn?6>n$vn+TI5>$O^e=4_7?cei{z`Irux-V<AK7R|mv#nT}Y@>7&^JWYHn|XJb{)
ztaW8aFz!G>3$xX@Xyx4VhMGi|@Z{yRAy3~u3T{Dzq05Alkb8H9K1P4F-hT3g)m9Nh
z8VDfQoBpwyH`740DZKl)ulN4y*5D>vW}_t6!m7uTdPs~i<_W0O@toO~X~vAfo$~kX
z?99fT_mqZ2GV8Z9;>{}~Uxu_<#PH|mLqdkkUKd+?dv$CItbLO(X?+IM&%D`Wc7tc(
zCSF9>rsLiwKlI~HSa@$u_-AGM;JxVT&UitaVZY^ZlI8v>p0qxM*^Cbq*ovReoy54y
zqc@kKDo@y7XjB(I?dj`Amo?MtZokTNvI#Y7Yg4ikp(^za=H6PR`vz8+;AjI^J7#Fj
ze936To%SmgyKal5=cgBHdMc+%aN}M5FB+rM?@v-1Ngeni3qNspgRGNZ?7C+sXI%1X
zu&@5<%1FnPY{|sA&399jf*Ki-lC51Xe<nPbvmAN+8dM|bgE~XzX1gnOBWa6mXR5Z1
z;zyQP!r993o~6UPH+jUZRO?jgQvT&XZBN!NNu<phe*HGw{NLN2h1H-i6MK1QOzYa$
zV|wB>TCyzc{m1!Hy?E|SK;2qE86{)*9AoayT6^+}UtG~L-LQ!_uNscFG7wOc+;n55
zi%O5BBNH<3FJF{p3sXbkmhU1SHR+V;^14{}iC_7{%m7S+(d!q3rCSucFC8q?ub!ax
zF755m+JV|^+;sBNR8-&ZOS{mH!F^^e!qemf2F)+O1xWD<6~CxV>WZY3AMK7S*J*`G
zI`+z}Og|)wnBLFIM>MEg;<Q3i{c|bghZ2j+k_&iF8_BS)M?uV3i94L0A8|@SoHZ4!
iwfsSQhsN%Af-Xf+tzG99^G90|i-O|`S8S~vIq82KKA5Bc

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/ftbyn3p08.png b/Engine/lib/lpng/contrib/pngsuite/ftbyn3p08.png
new file mode 100644
index 0000000000000000000000000000000000000000..656db0989ad8403c040f91caa6d1a79d11713715
GIT binary patch
literal 1499
zcmWlXdpOez7{_0iP8lN7N%eH-5mECbRCIVu6LJ}*)zWIN!wR`=Y?C{)w8m!2%up^}
zoQPA3!*WZM^CU&GI<0cIayvMc^YcE>`+lGIzxVxozicm0XHC>L6aZ+tx?p_}HCXEn
zD#*m%$mv8xm4flWfKsN!VyxgCfbvH#cVDN~)zxGIp`qbnm7`-xNlC4N0Y^`-xVU)x
zc4ARc5kUI2YuC7yT%k}X5D4<~^G!_&JRT3Ah|A@21RQho%G})CWB?9_(+I$3vo$mZ
z=y7pbSy=#e85tQj0b~FvDJhpOT>=oZSS)~U27{51kZ|Y_fkvan#l^+M#JE(uTtQA!
z4gv@uunBwiF!3Bbo6V(AD8a$Oqzfe7&$^k$#*t_=mWTEC_dim61k1+S<=X+=fH{C~
zKqL}Ro;-Qt#0fkeZ<S%??d@$OG{WI<wze2;?MHQ5TF?d10pGuWhc-}E6@nDdH1x{K
z3bY_>LZKPnzIvst%}~3mwzRYa$TJT>Br088T+}GlfcpTopv}{U+b}yj3)KLXFf%hV
zH8ll7n3$LVph7M}0YLze1r`<-`ub+;*E{Iw)TpV=^uO-!?d{D6C^s|f?CflBZ|?=@
zN1;-vRJy&ripm9m5)_JX?3fD%;}Jt5d9PnzRaG@Tt&m70VzF2x5&<+`zka<Aps=uT
z5}=@<Kn%d=^L2H1<mKgEy?XV^6@(uzCnqO6J3GECJ|jCLGcz+iJ)N$lm71EGl$wMT
zlgUg>Og!FtJU%`?Ha0doIyx#Ust_O|A|gC0JTW9BJUl!diAx#Qt-#Gc$Uh(;0OsLv
z;o&o9&YV7d8onR~ksRrc1Ofrzt2y7?In>$0f((P;<KyGy<pnRmu+VVx<_qu?+}+)O
z{P+QDxhsyOQYSWUba8QkCa?;zQdVBT<H>Ljpax;QW}rf$fHL6XZ~`kUKn^MZ$b-?*
zQMe3pxg3%q@0VYclp=!&M1UYqPikLZ-^j=Z07iFr_m(XfLqo)RA{I+;X=#}p89}3c
zQ7AINY72|Cx(f1<1BfS}6zk)O2Zt|%A!|#3n=^L7>E-reBy>5hSd8!C+(5GA0R5|(
zCU?rNq9X*i?^+A9)vRdw?6dm2DISq&OPK>F&h1k13hobIB8bE8-4UHJ{j2p>b2F>0
zJdV^CNUpQ^W2IoSo@jsl&fn+!_ExusG&(RFWck*%JvP(>Qj{5ANTt5dn`)V0Od8)V
z``FITX~_FXsZSxZemf;qUmltp&}R`NpM{2n4OqS@w(~pLu_37DZPJ+CDa;Gz%|^=`
zd}}Z1EV?EO_b%<BKX269Z&T7g%M<(W#a4GF3foLx*c>I<>>cOJ>%y2#_#mN!^x5<=
zjJGmcy%bg9<b1wCTlA#oc{jSWiC%l_b%C3GxMf@0I$H^<!pL~~oo&{+pmK8@t?zQj
zB&|sx8?L|Io?O1;mP8&p@$GI;#kd&vzU#%yhS;q8W0VF`2foPKU)o)-=oA!t?%K|M
zFMHkpyza^JP)BpFZ1k-9o%D6V4UA~nrY?^^lO9al3_X4Wno;!rZ39-8J1Y#LX|rvo
zDmM?~hZb3)sfx&+#e+LH_#`Y>Z>un%{403Uo~AEOp-q|0FAO&Q_payLN^pd^v$8v;
z_2>K%L+MXinj+%k=b2%{MBZdz?a#ncO7`Gc#`N2t?P<&Y2}MhElSclGW+d9ySV&Fv
zGKiPYu6ryW8ddns&8aEAjSocHe299~xUJNH-^IF5oEHo-12IXaZ(jD7Y*g*OxWCk>
zdX(C`xVuAdD@xt0@z}-jnCHJQ?m)YSJhyBS`I7e;H@#X2l;c&(f7KW>kjTeAJ04Z5
z)r*jI>{i%Xd`gip{hpQ$=}<Q&=!Inj<WtBGW!9Hu=keS&l1Xikij=XOa4@Sd>bQ!O
lGajP1^htlK&dv|QE>+O1S>+WAhFg({f~%7!w#Jd1`acy)otOXs

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/ftp0n0g08.png b/Engine/lib/lpng/contrib/pngsuite/ftp0n0g08.png
new file mode 100644
index 0000000000000000000000000000000000000000..333465fcdc9f10f7f25b2d999b558f5421983ecc
GIT binary patch
literal 719
zcmV;=0x<oFP)<h;3K|Lk000e1NJLTq001BW001Be00000RuLsA00004XF*Lt00D-e
zG3b_G0007pNkl<ZIE`bdCjb~oRPgxZM?4B%Y^_U;a!XwJ5UYZB`#aMUea*BqR5bJh
zCSLi2s^HU+sYN-#c6tUn>e{x-64Dw5ISbDJfGPNXYF1fsnx~<Gv8j!ng`thBvAV8y
zR9<n}>?7~M3eMD*m6rOMo0;2$rUW>-c(^**S*Ycd0zuX+u!1|S9WB+#F78QX<>lo?
ziQz$h-hRnIW<gBQUa*2!EsgDco%NNdpe#8gz~>oQ!H=elq>2fX`<ts_psK1eD?Gr*
zGZN~HuFR6Y{z+4(Pie1#g2HHH5eZ$lCa8i*nfd+w6Q@j{IeTVzeO+B`c~Xd~xF8RY
z{u-!)De0Ll{SzinuBx9tZ%$ubR#dpIv=A=`x5_oBf+guGrTzVrn)8zL=FVSG6%}bG
zE5<9uD`NK>s$g4Md}>$Ugu1e*ygBpcmqZ3DNb_5HNEsBtg8Fz$MsRgsRcUEt!R)#7
z@*=Hdg|%Ijgaqfp6x>M8@W|<nE-8t~pEY}KdbqN*fVsF3pV)Djf>(*DezA>78ATBV
zGiJ?6^pq7<lHudwQT_r`@FyWTJfg5TyfCC>`pj8TmNNXtGQ7M(fr#kNOGpUKtO+a#
zE}lAlTDXoRkAt?j2v0jgK~H>oU`AO)UQprWsr_L}qI~YALPA1E5ej}SPEJnGOv?!@
zojAEOR7Ob9QdC4?8%mP9keiy8ksVOlKd~`Xk)KCEK=mA2ntaoimYx|<+}mFjqR+?8
zZTJ8q(f(PLp6*}V-CGiDD=qBv7F)8vQWR0&(VZLQZ(jZjd%k$Tpt-FhJuqOwUu^jT
z1pXapZA%Q=jx2<p_3lkbJyVZQLH*aq_4pNF008$!%u(56)m;Dp002ovPDHLkV1f>U
BP!RwC

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/ftp0n2c08.png b/Engine/lib/lpng/contrib/pngsuite/ftp0n2c08.png
new file mode 100644
index 0000000000000000000000000000000000000000..fc6e42cb420fd08ecd78340256157fa5f8a22934
GIT binary patch
literal 1594
zcmV-A2F3Y_P)<h;3K|Lk000e1NJLTq001BW001Be0ssI2{21+{00004XF*Lt00D-e
zG3b_G000H?Nkl<ZNQups3rv$&6vzJ`6dKHj8c>u542F>)wJ;-zU<0Ta5X4X^rIbM;
zBH-v?$kU01p_ErCl=u4~L7fbz&H-~9!(}3aFu`RZW&unzb50QkgK2zirzKlPEQpyV
zJ88Z&UwhB*+;h+QpNot)Z1^7mZr{G$*Vi{SHT9YSckkY9Z*NaePmhd@j0*@zcXT}E
z>DjB%+#enNPk@PuiSF+1yu7^V=xBLZ*b!IPd^0mOpafEZETD#AngxPxg<^DQ=;_m^
zO9f0%PhYumrM$d6AtB*?xjc2}&YX4Y${D5+C<Z<R5?D4|AP_HKE&^maUWu{sk*KJq
zrl!Hc!AFlC=?6S~_^`jfzow=pB_$;>G4W_vSdOD(DVN&-oB_@QeZU}a320`R0!vG!
zgF}Y7c_vT+6ajLvI4&-Z7Si(C+FA;c5-<-iFfc$*`Z-x=6;4i{1D^pMz*&|p+q$(x
zB)Vj4J8WQZ3z!6c0e;dUzW@{rLwimBm&L@yP^|L+BO@b9r7|}+H!CYEEiFwM7}#lU
ze#Y8b?eBj$IXU%j%aqGow{IV|u^C^v@>iA}GBZ1AZ=V(%{Ldfa<Ksg^LjwW=y1KgN
z0q)(qN3Jt7GnKi@!oos2TYCAys~GJ*A|fI%Fi<2C`T6<XxpQY8Kzle@8FrO+oRb{a
z7FSi7s<gDUsHo`p@#AR=+Yz0Scgl%WDxGuf<KrWf$@ElFettf4k-=498nO;qNl6LS
zQe|ajSy@?5PR`K<?9ib@AtC$h?Ufu(Da#(Vw-5I6@;!F!m>vLmWItxn1<b%^)TX$&
zm|PQ}y1JSQgPtmtivE_aGlfDy8Q;HuzgWD_%<OAmfXWqk7l?LnkhHb6=>d>CixU>w
z(z&H&q%@~cmeiGMuLdu#(_V!Qg$)f2b#--gLIj|kgoK1hr6FtAeh>TxG#MD|V;DCe
z+}c_;JUpxi(9+VfzG^*Mf$y{cVZV^}<lE+pue813RO3`%U*Fi+NDW1KC-0Q#O`A>t
ze*#wx4d1b}e2ZmQv#dlY6hC?LL=T{&qk~_>M>ADEa39<U+`RHU&(ogT9;=2+xeJ9)
zn;=F~QWAL=iK2~+W+{9_!*~}LuU)%#Sy;I8`4W-<J)KO}+uQ4$?TiZmDb5eT@9?Yj
z6E+CZ3sk|a%#BWhHbD$(S_1I-XLaG9va^$Udiq;fqyvo%Q&?AbLO<ZfjT`O?cP$_d
zpgx|$8r2$Molsj>m2fL{qvo7rko-xdG82;t3ZKJ~Z{8fj<!S(um7}JnVHBu-0QH)8
zlD9TLN|;ocU<5b~+bUapt5qD25|65?Dq>Kg!o$ON?8wlCe~HHnv#{{d1tq7Cl~vHp
z%#3~jNv`NUkyhKvAxIVA8=wbFDWm<O!S3SSb0td*I$=J)1^5HVc5)J1TE1;y5CJ3t
zwR`r&XUw;Ga(yuIAZTF=+#}srom_<<0Ts{<6v9{IJJ)v=6&2L9JYG961|0P8*v;qj
zSvD59NIS^RE?EpvP*7mhU_|Qd9Ob-Cxefi=>}$)k06v92)E2}b{Rj#QTCt*&@?&Ti
z<?Ze5<a7Yq;;T0?3GV6XSq$*_@ng+-jkD4@{6Kg_OoZ_{V|=0;0xF2rV(M*TkPb>D
zl4Z+2B9B~dgtK!fhf@n&;PLjfw||-Og6SEVLqkKcv9UCP1w{gUs+$RUkf<aSJ26Oc
z39x!K6=fE~L^2Fb&tfa9xNFyjUUa1&KsG);o}HZ?93PBxy4>bMoF`VR)x@ASCQaVB
z(Z|4m%7&5?v0+2f&6_{#^|K%#LswL-t*u(|pn;hUX^xb{ju_O&VzJoG&5g&iH8u70
z_D*>4U~(ZRivi~B`tWs^S{JHXMW%x09Wf|-G_d^r{kLq{LV`-iwz!9v--{+ECrRLF
z@=(%<L2bNu?_QcM^zzxWXD?m8q?_II=g%)+zDz@#7}UnJgU-&*r7T=3V9v(I#xxoY
sRoC1V<n;r{W@l&VhWbiN-uUhMFIDPP%w_<`9{>OV07*qoM6N<$f`h#14gdfE

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/ftp0n3p08.png b/Engine/lib/lpng/contrib/pngsuite/ftp0n3p08.png
new file mode 100644
index 0000000000000000000000000000000000000000..69a69e5872234d96cab4cbb017a0933fbfedba81
GIT binary patch
literal 1476
zcmWlXc~H^`6vv-Om}J3dn5OOMOgg5aIm=3#R<M+qH<wwuc|s$3EM6p8%6K6u9;kSr
zW`|a0q1&OE)~;HVyY8fRxoAa*<$-H!x*ps9dNc36f8YCjKcb)j@6G7#XaLykL#5D=
zZS$=+8X%K$sc-;Uh8&VV3H0(BU8gEf0O(Hy`7sV{-5Q_8V%@%duZ2u*XlPK_*objB
zxm<2#6<S+c3y@P?T`g&rR8>_~R8*9gm+#ueDlIJqsFg@0;tH{|b8}HqQ5Jw$Ebasl
zi9{wQqx{s={QP`?_T1du%K+m5+1c6W&Yc6O&&<pOPznTs)2B}piLCVW^wiYU<m6=P
zRcbMEl70+86idW%a5zI3(?uc)hr@}DjSY_vH`AEq+1n@L@sv_ZWMt$%`96w>;#KYi
za0xyG{0*U@p&=n5OeT{~rxS7s!NI{ht9Awk26}jqu-LA43<e$p^uyZP8vF)^hE?zg
z@ag!Kl@;hk*qnq1@MdHLixn8(FkW6>2IQH$P*->1%a<=E7fhf7KmpiNEL?|$g$1|@
z&<t~Pb2BqDPz9epeFES@5kdh$0FV!^uCA7rjz&fYO-<X3jpv463=a+tmIGXLbQ~BM
z=<Dkn1Q<r6v$<UU{{039@c<2IH0$tTDv9Ku93CEQWYp5qGCQklY;3Hrudl1C1L&-&
zsc8q0$z;<2m6etC08**c%*?v1tgNJ@q_`O2S6WzDSWr-q)|8f8keip6my?sj$6$m)
z;aTBXq|Tf<laY~e<l&LDw6v6z6dsS4l$0a`NJvPCONz^2v*Y68au8jbD87}xkui}`
zQBm*@?3L{e3ky4T>=;ZU0fm$KWEP7BFz+mN_CD$D>KXyBfJUPQ1qHz$U@Noz`t>V3
z0Y5*#_4Rf5=AAr|%l))v3zbTRZXmD;`udA>dIa18XhRr(3s9%iK@&&<11kswKn|(|
zC<Col3+F+tRznt)p-_5yi7~8DfS7;)?$FSXO7#{%pj0Z&%}KVlNc5o;3ct6vcUq;w
z;~8jl1i;tc%uGrY>Kfuzi4TRu*jp4GWDgcp#{666_U|?<$;@lL6fyrT=v@~MF43;U
zZ$6b_)kkb?TQRlFx@L1DFHuvCdiGRV@qSb5o3SyX=dqWIo~SD}lgtU8-0hinIc|l^
zwZpyIy{+Kp3qku~jyuQS{wOJTffqk}ylg!rGf@@8WYp~qR<LMm=iRWaIs+%Z?EyiL
z$3>TEe@i_6M#f}U2WR@4MfM<b4D-Oq=}GlXLVBLG9p!kmr+;x?B)}4PFLbk=es%FY
zu>)1<JbF~eTkdn`w79VC<h(GqB1wATjH$!XPL+ehk;YhC#-m@R3T~JS>HJRjPCMx~
z7uM(-p3*y>&A)fhi1A3;cS(L+J1;&pqWL&it>CX0-+eBqO{=g-lKzNGvG(`sNqtRF
zeg3%mDzvL|F3Eho_0DyETn8H%dc!?dA!#0>Q=Vr9#{-Ga&|1#6CAW+Q0sfY$`N-&;
z^0c=#@%4)8jy6X3lL6u3JAW=?c#tm>K2a$#(Q?|Uz}T^+pWADD@MB|q8>&Xr948aj
zsY1|Z7&ad@u4wr4W%TE{WS7U&Rh^yI#(OsCtq$vQ3|A*M_uLm%-A~M)I@BiVUy<b2
z+cpViZ*y18Fq8S3`1fl02U-`g`*s1z`K957gEIq~O=*uih9>S#YR$&g!`CNx58tIE
z|3D@=NLJY$Q%;J12ZU?1w#&^2c5EzDN05DZLoa2szJ*SEwwg0|Mem<$Yn1cWcz^cq
z-}lxrB6iz%k1R&3=>`|KS%};k)l(YskH!jI!g#-(&O>3hx)5(GX8X3fe_&q16?&Zr
z)72bEymR&OySDOI3mZ0C3tSEiO=8X3u^BG}uBukDWrMyZ$LQ%Y4sr7@il=hRi%!IK
N0G~qvls0mN@PBi2fm#3n

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/ftp1n3p08.png b/Engine/lib/lpng/contrib/pngsuite/ftp1n3p08.png
new file mode 100644
index 0000000000000000000000000000000000000000..a6c9f35a86271c056e955f637a8769381eb03827
GIT binary patch
literal 1483
zcmWlXdpOez7{_0ijw~Xj6ZLfH5mEEBP|@KrEtkTuS}m>SI;>1?8{6D(v$V!$$}kk^
z;zXQM92O%H=ShmnbXw(ZQ8_r3^Xq+{_x=9)zVGMz<@$KL>7tBL0HEvPj`Ks*<Y%we
zKql^LZYLs|RIC>k)Uu?Q@xn6z>Z3lMM-Q#6tfUZ$jg9xOySS8<mDQP;@C*%0N=i0w
zCKVSK17uvje3@U(7mLLrk*J`cz|xW^5C{N@`FuW4#Iv@p&dbY70pRg?O#oajS4U@%
z85ftGoefZ*nVESFKmm}Nnwp%P3{cA9Z~(elELK87!oGb(27?h77Z(!~<6h%_5jjac
z7$A_yCGOb4Ch!PcE}u%JhJ=KW&ym-ESf6EXPDi700$e~qz=4tjI4;hyz!Bgod<K{U
z5{Y#D`0-=Mju8k1+e}+uUtcq^86J;!aKP&8Kd9H!gDwC$eEaqd+CfuO3^G77(96rq
z(2B4LgBE!8{JFk9OZ&F=;^HD8&)frvq<mpvL8n{??gG?-zCa&t!u<R^)Bse&?Ck9H
z^fZWJa&i)Y26+et1OY%cU@#aXBP%T}X9I&;ZSC2C7X!V$y#)Z3R#u&zogEz=y#NC!
zR4R?ebaK+rI0sOMLJ?hE-LY7&7&6&cOY8de>oYSdsZ?58S}Ku90Gh5`xl#{MR8%wt
zP*_-43Lq2;*RS7_pPzr}(xr<R5q^T)+}xa;ocN0P%$&@utgMWT45pr5T3T9CS`t!h
zHajsf@o?MW`1ttP*x2ak=%}cuB7n%q$cU(j#L&=)h=>d%E)}>Vg+~H{0|EmB;S209
z+JEZQsgoy9!bij)vJ2CNNF)M$vKCsqg}Grc6c_?OKR+KIALs+qBGU~U&cS2w^z{7x
z{X6{3T?w5=n_Ror-Q69U!8X)ZUHvP8K!G~|wFu*%2C7slr~p15FS4}-<e)-;d>9)W
zgA1TkDj@~(fB8jCjUG%S0R(${)B5}SM@HTPu)4duH*Un5nj+Sda5!dbYwOg=2pWA9
zg`xngv~oCl+wa{*R;b1Lc@x0-<4`CPvRn@w_UQh+Ac}Mk^OKb>f7-E19*W;}xs}~!
zRlIciNyF__FM9f7*5I)-+cbPa1|k-TrQvsONlsb*)pnz$h0|UcNA3@z)MNfwE}Uv0
zIbFH+_Zk14HEp3y&g@1-ft^E-J#CK+WhE5TXruYlt&^-N^P3g#I=H!w`R}L=sT9s{
zCuD1uhCdG)aY*zhVd3F}HZMyY{g2C62iLwz8h1Q_?PFhSvbid>^O4P?YqRlh((eZd
z#_aspCH=EBx%*CRO=qIG-J;L_AlZKBgiu)@&Tb|Ii=AapW?Zqp>gYA)sH#J5XB+h;
zk9wYVqsyC_bvIrV9&w7WX>VWUAVpP~na{j&$UYNXX^m&}Uyx5RnnjA&4L3VdD!1H_
zD#Iq{ZueA8l;TIb`kpn$X5SsBHj?FpV!HrYcY~@^RN}pDGk;X^V&G~0qorYaOP*rv
z^qN~4t3n!C(Ta6lUVkRto3S5$_!4xZm;=Uxwl-U<Orja{?I)@?ye14Ua3s@J^qz&i
zTUYxfEY%oSnNa@~J?cm|DotffTYULC)coI@p1I|aNNYEBPi)(dF9%FzKN#t%$af!R
zUz;Whrh@8z1eH^BhEB6)Uj67uUkXSlUSwJ{31@ZbXa{pKEzQRyUOB(&p>lXk<^TD!
zwrXx-kZ%7r>OqrnxrwlgbC>i*G{g?VCRx6GHc+-!v-|w+a<iH-TJOSkx#1?%8mlJP
z^Aj;oe_z;w_6U7y(<(Vi*=64R{A-Yspi%j&&bWzGIsU=rpmv>Mq(Z)3<$!sgDrNgW
zt{66;txYft&kQV}Qtm74k`-qO{C2WMU5|#0wUn?oyC~|ghKx56YPk5`Xp_O#x8g2M
X(5+n&l!#upArS?SL*BSr7fRay;V71Q

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/ibasn0g08.png b/Engine/lib/lpng/contrib/pngsuite/ibasn0g08.png
new file mode 100644
index 0000000000000000000000000000000000000000..90b5305e651e5ced5480c9883807cb953dd4b631
GIT binary patch
literal 237
zcmV<J022R+P)<h;3K|Lk000e1NJLTq001BW001Be00001Ar=+B0002ANkl<ZILoz=
zT?)c55QLq&$Q(k%d-y}oB|eCFu&Ngk4<SojQ(uyY?n6Q;ou|n+n_*cjNFu5#8j>(o
zg^)y0Rjf!tRTURWiXSsGGZ7{d5<!yyuGv@;&e`M|+_DKdI%U%~L!om(qQ!x59KNH7
z?|Ar*;J#q*0sNP?25|S_=NId000$42<M()a@EyO$&Vwz=l6L9<UbTkUmnGfQ0c<L{
n$ozMB7t_9%F#jFa#T57ho4Nl*2CDy+00000NkvXXu0mjfFB4z4

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/ibasn0g16.png b/Engine/lib/lpng/contrib/pngsuite/ibasn0g16.png
new file mode 100644
index 0000000000000000000000000000000000000000..c82f230eef51b9fa7c7c2340b83c43fabed1e764
GIT binary patch
literal 274
zcmeAS@N?(olHy`uVBq!ia0vp^3Lq>1Bp3_ZPW}bbH$7b(Lp+XeooL9{<RIYspQ$xW
zE3WZyfkgjv%@sQuMNg{Dy5Qrq@L9A%hxAQDpA-3Nlc#UD-^`~GxX5Lb`}~58PA2s^
zA0^Dh_q9tseqg4dW?6KFC1bv9vum%E-v6SQnK=f%?lq2V-2JZH(-r5RZ48Z2)_Lmd
z;LZA>(AgbGFk3R@N$)&7S#%Q5XTcM@9Nbw2&L*&W0Lcwj7XlewjB6OCC+s#bH_Ldm
zU-opY^%k+OJs$&hKidCZUu201*O6NXG+tzgbgVr%*RAn})C3R#6n^3!7dGQv=g;l8
Ri-4YF@O1TaS?83{1OOm-Y9Rms

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/ibasn2c08.png b/Engine/lib/lpng/contrib/pngsuite/ibasn2c08.png
new file mode 100644
index 0000000000000000000000000000000000000000..05d4688853e9fccdffdda84797d221bed4af81f8
GIT binary patch
literal 299
zcmV+`0o4A9P)<h;3K|Lk000e1NJLTq001BW001Be0ssI3iyz%J0002;Nkl<ZNXONa
zL8=5H3`DEIdw3H)S<`bfy@}UoXtie14D@GO_*rBzQVTIYE5wA7fa4M+efFTF&mI8)
zj^h%g^TwPv=KRC-erI-|e~a4nbPn#)(>VfOFZBK`N@L-nZ4np?b8U;jSY*X*6&Pdm
zr^RjCo&!<==Kn=08-XIreNfp56v=WQ%vPY3GA)ZaXB%M5Xa=DA0+f;wn6{4##*FL$
zm5jYKjUN$=8QB3QYqy#@Z_XKNt-b(LO4fO3fc$ig!!H|9ip~a2p6_4d{L=<h^eqva
x<oP~=bA|j37@bSR)|xz5sI~sK0b`7=25;X@3NdM=1<(Kh002ovPDHLkV1i^HevkkF

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/ibasn2c16.png b/Engine/lib/lpng/contrib/pngsuite/ibasn2c16.png
new file mode 100644
index 0000000000000000000000000000000000000000..399f1be5edd952a3eb0f2f6806a3ba7f1f9e2001
GIT binary patch
literal 558
zcmV+}0@3}6P)<h;3K|Lk000e1NJLTq001BW001Bm0ssI3+m8Wu0005?Nkl<ZSi{wp
zA#>v}6okLb7}(5Vp@D&gM_pFfzi>a{U<!TgVByiigM|r9|3P679!#0T_JFHIj_pK>
zrN$M|yxDo$x2v_so=6g`-vQQJFm+;z=1Pmi^c^68BDYQ$2%wlw-YTydi@Vm0#a(NL
zfj(wPZx#IA!O>o|ke#v7F}rPSp4NLyQ&*F<XRZ6_YO;~Zb}6}gfW#DTYqoJdFx%`+
zpF3b$4+ko@){_&uTKCu5Jka0TnsBc5BL``_g!c!4?E{>xmkvGqIxReNb6NEhmX`q2
zGSGk~DL|eAOkJJ}f70UtRcKPH&Kw;0lLF+~$txO0+LJ*z(nejaB>4ADg4bsWHa8MH
z|B>KnA;II51m#?UAHOB|K9k`7QGz0u;O3VE^HhSolmH}1%*zpH<z-^tyYSTYRY!2p
zNHMH~CUsB;UDSab^ivOZaE|)mU>S!RVEWV3fe*E32L9B}8C**3;9wZ_Ne3aQdmMzL
zZaD}|UDp$-TET7&&An<N7vifxJe_!2ME>5ySoN3P?9skwF+~Gpb-fvJ0{x-^(z3=!
zmVldR8y`Ue{-SOCN(l@TZR4MqKseDhe$oHXwM7GDw*cu&gaqP?K29KjfzK6f_YX+m
wdZGs;Fb>h435-v)LjvO#-IKuA5pCoD0i+b(v&J0Mc>n+a07*qoM6N<$g29LcCjbBd

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/ibasn3p08.png b/Engine/lib/lpng/contrib/pngsuite/ibasn3p08.png
new file mode 100644
index 0000000000000000000000000000000000000000..6df8370aaf812fad2c960360b5889449d79a8c7c
GIT binary patch
literal 1492
zcmXApdrXsO6o=2pMHIA93RYUVmAC~48?^)H1sAadH5)X;P7HA|GCL8R?bzrtWM;!l
z0V$$USC|?ZZt@KsWq_`f5i^N#MJ#H<+&(q&lFUh6!AORVo}G7Z@;v!HCwc#V>kI|?
z^TJi(05EUu8vQ%8NzB>70D|rtmjNIc3~#N^6X*^CL4Y7u1Xqv)$iqP{hj3N|SFQoj
zM1w{H(X0rrMhBo%fldc1Rs>h42heLkuLlh)f~z+I7}LOLgfvzJ*JuJTEe4Yb7PBI_
zCM$q-8Cb2bj1|GP+5l|1V6#CkD}rlt065lx!vX795nP7|AQpirLJ=#1E4lz&CE#*F
z2`hr@@&I^B!Q+8aRs`200Z8Q_Nl?y;;7UFKUnTf_P|1qm`T_ufY6t|Nniatfpdeta
zfGE_mBDjchIX1{?8dworM2!XyYiJI$BDjb;9k%LdT3HcXM7<u{^)&6Q2ri=0h@D27
zPF4gL(PY9N6HN~*f{SRiqT5R2W<_ujZ8p4Qqq)S2;37I4IP9PqW<_ujMG<d`G&flh
zTtt@(B^Qmvir^x8Jovyv^MDn>MU*5QmuSXW5nM!{51;vHp0Oghh=Bmk1ZZYh5nOC?
z-~SUJsA;W!)%rI)TfKS3u@JR)^wbU^w4$s+xF}PVjKBN8%b|bUcu2)*XWpWUvhm!m
z`*)q6evqTPJCM@WDZZLrB`dh6jEd2umc?ysYj68Dxo^roaxZbg!nBS@j$3UzH*b5t
zV$1fI&VBeK;lz7)Rz}Cg#w*mylSzB?h8CUP`Y=|r?$<PN`(LW8U$XnEreyYlk*t!>
z1Hu=pE+(JKdYsx(_9)J=@m7}g^{n2Wo?dm<cBwc&f5V2t!r`kK>FF8$A3M9d`=0#X
zTe8GriCekrlC3!<zfqO*+3;7+(xEZy9ryH8WqR=i^Jv>p!?E<{vnA(uL_|bHHramr
zx#qI{`0|H0J8pb;?dzr0*;;LC>e6Xx>6I%#?Z%6>`y(qWpH5CbjR=204^9s5>gfFU
zd9NtCp8v7r)WJjD-SzdN*wW&1?c28{v!*6Ec=hU(l+sd#qNqrx8*0za?(3_nnwpZy
z?Dm3!k&*h*O`C2@((RlTD{=<h?tz+JG5!BcPrnEY37Iu3G&F4go;~~0jy4=PP+xDi
z*VQ#PHZ(L9t}#@!9y-+0a`fnl6V1&I$B`q)&lV4Mb)7kL;X-?RPfus3+ufEsk=Scc
ze_~KRGbGOQMqLkidvxyA(V&dc@UzJ~yz_nDgm|y~xHs;4e2!N!;8oXnl`}~*S_sz8
zuGNOD*3MllyRQ`#+Bt`{p+(6zGUIibiXSu8m6^)!7*E&2SGuCV?^2Z~l{;mRor2mq
zr_~wS9ntR$t9C}dus~Sye)EESbIfJ)!k5j_A0;Tw@?++>4d&Rfq%lkI5=+E+OPJLX
zIXSy&BBXF)?zM@a*OGtmt9JV5|Lspm^vfsX-}Ea6{p#I*CHfP`>H<+}h4~=;*|0XR
LKz}ZG^Oyety+*k>

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/ibasn4a08.png b/Engine/lib/lpng/contrib/pngsuite/ibasn4a08.png
new file mode 100644
index 0000000000000000000000000000000000000000..bda8e3c651733475ea99f7f70f919fec04dcc369
GIT binary patch
literal 198
zcmeAS@N?(olHy`uVBq!ia0vp^3LwnE!oa||uB7QDkkjkw;uzv_{B6G@SBn9UYy1N4
zyQO&-<c`YSS!_|vRQhzA-W0CVHlB_}NlqCa|NsA-$RXO8khLtrTu9dOu*riD-pk~R
zUYu`qnf-&W-~9cYq7x2L8zSN&m*yRHn0$xv!_C^(Bad!>^`7Y$eKEVi{h^gwYD3aF
yqw4=Nr@Ug*y&@gbC~dLhAZLHGvBeE71Ex3rww&tW&n$orWAJqKb6Mw<&;$U)flfyN

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/ibasn4a16.png b/Engine/lib/lpng/contrib/pngsuite/ibasn4a16.png
new file mode 100644
index 0000000000000000000000000000000000000000..500f9128e6e7e864b3a931849907a290825979bd
GIT binary patch
literal 2839
zcmV+y3+VKTP)<h;3K|Lk000e1NJLTq001BW001Bm1ONa5{^VY&000W!Nkl<ZSi_B%
ze{fXSb;mziJxOnO(dzB45JEB%Pl(@ypcot+ga#Hh(9~uL;~H=V6VaMxrZf(YViNS6
z={Qf+HFii`;;Hc<#zPaZV>g!L)UG2f4l6J=4p4#(2+)EAvXHcTS1ax6t#q~OA5Tm&
zZ9J1dzH`ppKkj_bx#xV(x!C~bO!&>~VAnvFITMT<ralmdB}*)Wkro(;n>viN3hTRv
zvh5o9_Li#WZ{Cau%@5fj4SqfkHXeXW_kl8PG~_?ADWrA$H!S0goyyC9fY0`aG<BY3
z1eU&WLs{Pk56ypLXJ;qk$^ys=X%G=1{}vBy@j~b{98JQ}6kK@AG8A(r^xuY0p9pE|
ze-P5H?uSFWE#uK>L_B#ZB3zaMcUqyN1D1DLhN@e}=^4=334M)_RrMTn4OBh9u@5%(
z!^-c#e@=DqtErHss}R!u2+M$o_#+hMmhS%WC0(uX!iWbF{{dH%(3XVCx6jrq541zu
zHeEfwO;^`G1Dyr%>+i$8*=Os&bQqyL&<;y_pydy`dg>`%ediiHlykOz>5mY_`#`zB
z3#1Fy9)S}=SASGt88e?o<jn?U1eCYuz_lP8I|oMD+4`T4VPD@3wR@nf4wSd&LQ4g#
zI&`*v-d7QxPB`-nH2n+QzYwwlDc!wrk7jP{gN=Poa_;6~?2(wArK=FLb@%Lkm=pj1
z2&SMtIElhP@q;kYY#B;OgPz~P&6jlbHx0VldkaRh!7~OWLr`EtzsHH=;}ZC&6f%!n
z#=?S_UHYkID<KUM?J(el?hoP0HeLN$tF9)BVEQ!hKL_XTI7vwV!ZKEk#O(4PTXs=B
z6f}Vn(m=MuSU#jbg5)zWupKU!>greD)z#MoT#Z_WQ5&;MzG>OMZg4k3ZXYOzL9q-N
z?F2gl!|Pz618#l~B2UAP$1J0w0uH_m-a1&+1k)Bk!C`Q}4|y6W5dmT@^t}T&zYG_?
z205!OBkZzRzZWrcI~@8~XwJa?-B7&(X77RNQz5t&vNj%o?y&Ce*ruzla?PxY!jdRd
zoq(z+6mN&~E8*Oq;Cv0tOUCT7S7Wvk5s=kp8MEHDsN8^<wF_pAL-9WFghAN~+Ic8z
zhOuT)zXe52aQzW@uNks56Lj_SAq<GwpARK#mezPP>^Jk`FeMKDI3)X>#7@LP{w<6I
zArXXl5PE{p6@*wJ=xS`lH7g7*Q!_iZ>FO<8SNndVtAq1()jpxCnMZVWEMHfX-_zBB
z>$=)gtE)F(*VU_qx;nexVW?DY0QUm8TCSOw7x+!zvoP(p^Q4($koJM~5_FfswRX68
z4=ieo+2wI4RzaB+2H$y@5`|9|YUTySZx+=;Wi7~WL9zorYk@02gEOtL>{iUKoCC$H
zA$a$K!c!28g8vEly<0O+&+(hH(=hrm4AjFXcc7&gYS+Z<xwoNYF9hP?Q^8fa0p_Qi
zcdxF7a2t3wYi8tWT^;(hu3j$H)g!&Sy0r*uYvI1z@P$UFQ}w$HWE4iDF!C5Iei)WU
zpk=jYo?GcRzkL8+SQoSB-G)FdcuzxKBjm(EQ9%hDgUpMN$%pYWkdH$7DyY~2OP6Wp
zYp)8UDhm0#Ah!aP_rSFoT)%)U6O?OjLR!GcN*Fu_cdFsy{jh%-e0(NmA3TV0_&7%B
zJ}7U2Kq*XV0JR2kZOC3*uCBSg(67WU`;|{d{YqP{UwLJPU)gm^$iF%%WbP6nk3VJC
z{Qg5bGI~bH<X40oUMFNSDP%Gur0aS!T=F<g($)rVRm1wWn7t?(v)%8<?2=H-u2~ba
z)0ZrxrNvRCiw%yv#car)bxvJ#Bgd~?^7xgHp7tx%D}=n)7IMM8Le6|#Nc)zMi4q}Y
zhmbdJ*fm|>w<DSPLXP=_9PJcRx!w$&o8WQ{EIARgXGftV3IzusI|}Y5C|n8UKL%?h
zoO>MO;!TXyD==(>a=jU@Z+H4zPr>vu@P8fLNpKB8ZaesHL(y9>V>JwW;nH%9_8>;u
zhHUGKx@J~bNL>n9HebklHVIjrE#%ZCLI$@Anf@Cghd&ZBbx6qcppddn$jpmE4m8^}
zR-YZo(o7JB*62S9fn#vj{-r*^z-9;5mcQJ$wt!}e21QpP5e6&lH?MEe%t8}}8(`!D
zq%$yn9wv@}Yd7RHfO--<!m0kuiw*(V2<df@ngK&!gTdVpKLY)Y(DyL(FMz&H&~HM2
zGX#zbV^-KQd@3lq3d3PY#6cus;6cB6*{hkN4u&p)eH_MS!o+isT?ct};9Uiybx!vH
zjLw0PRgh=`>j~&R3_VTIa~wXq1U-Y$<AtJ-Fy<vKLyLni3{z5*1X5v0cEOMegL`3M
z6ndBV&GSCZ9GC$^{{`ubF!4oD`oVJy3d)?;1xEu0*Ft|Mbbk>#pKz9>&NOt^KuJOv
zOX@5mkP8JV$d7|J44z+25=d`=k$;Ai2FXT9EC*{U^sj*KZok=fQZwhyh2aMwvmNsO
z4z%TtZh#Z{op<5JA-LQGSDN6;NvP0;QN6-43U7ly3cl0e{WtK$!TnE=_Yac<#=<b#
z59#S(H^Ru1F#KgmRKvgk^lXD0ANb9;sx`B>3&y%2KjMfMKz9T#u7nRBfzvZ!@jhX!
zZ?lZzS0E5@+Gt7?+|PoVg1mmn4MWb|8W<15_-{cbK|T*-QAlqFyBbm{7&-|9)1mtm
zTwd)r_g~Y@<YSIv0<;`-wuis26vnPomQivI0w*EA7CatMZ$VxZa`uAqT~OkX9fs^H
zlLXiR6PsZo1rv=h@gz*V1DP;nGLZQu$el3u0odzca2s@V_|2uuG!x*pSB0@-hh-GJ
z0_q2lvj~)5g6r?W<pS4>kQIfj0?4`rS#ikP0Q?jbVL)axWIT{*gz<-9`~t|iFxCm9
zqhL2dD&*`4J->yElM%o6sxSZ^-UK@ygGF6Xyb`o}@I*lEfZSZj@qy9=*^43jb#Sen
zoGAt<F&ktvjO~OmFN`*TeE>#sAlU|q1PmO8&jeik3Y^~Lr22(*f~u(V1TU<EcaCEm
zyavl(hS_&u`U(itfzJotQg9c6x)XA%AtwkqM?sO31kx>#J_oi3QVlR%1Bp(sehIz3
z&{geJ_Tpp0*jgl5{6m<x&zX_{^Xeh}Lny3=|2c+nq!;Es05e*ks0jSu0biLj2t8*&
z4MN_VkXJiNV5AvRRgm<+&>j#6p#Oci(*~VgPCM1E5mdB8#V#n%gFurrqQUXYJ79bl
zxZ9y<4RjpGXo*4D44AghnMhhU<bMOaLGUz#+nywlY=)s)NO-|&fc|UHbB`k+%Myap
zAt+5i=@3j$Kp^2P7s`7M0k01N`7kmUGRq(*AEx*qm=Cvo7-xJ?TnB}f;O_%p5b~SB
zdzV1sO&Cmp<$?YNM=}>R3W`33X(1<~qBSrz1pX~BWewzooI(P~YlSKAg1;3;TVWys
zN-MZq9lZ!NLT@X^#lujz2mC=OcoTdjlfOlASZlPl_{~7d`4t66KF9u<Gk~}U;_m-r
z|J>Q69q@qvsAXt%q9I#IP^;|7^ix6>=L<RQAt9%h3ORMVkimIE1|AnuyH7~%DItBe
zLgqg!r1$GWdjDNW_ckH3W(YZYK*+HNg&f~2<oGHfCw?F#UlP*wk3zaCg;X9DGH05Q
pc^ibxa|`J{A>_yx>`2dh@V`j`6FKV(<2(QW002ovPDHLkV1gU3F8Tlf

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/ibasn6a08.png b/Engine/lib/lpng/contrib/pngsuite/ibasn6a08.png
new file mode 100644
index 0000000000000000000000000000000000000000..258f94050cc0829903c7ebb7224f4f6177559f1c
GIT binary patch
literal 339
zcmV-Z0j&OsP)<h;3K|Lk000e1NJLTq001BW001Be1^@s71bs?k0003RNkl<ZSi{wo
zK}y6x5Jg`@i9Ne<?ZS8sHxuVrZjzt}OVEo9cnSwnZgiN8AtnAmV?ooT^7H%it5Thu
z4Dbl-fxY1)=V4cTOcNtMNhBv%-{1e4qqzpCfcv>+T|4Ex414Bj88CM3A|N?=J9G9)
zlhOF{5wroIBLKW`Tn0Ez1ZV?5xA>mqy9}`XS~tP|BNy5bg$=bx&>|AN@}Ln!Wrzue
zS|rc}ker<PWzFYyW2Y%F)IOjttzgguV7=PPy{h0Xm`Ndli;ZB2bu?EAbOmA~7`;f~
zB0=)I43IC@CU{;8vyuO1HRNfqf`Gyf9IC<&sN--20cE4S1Ml3H6`)RYS%7*Q{C@}h
lP?Z&+UWd8^r3I9B;1hyMQ}iYNCDs4{002ovPDHLkV1jJljxqoM

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/ibasn6a16.png b/Engine/lib/lpng/contrib/pngsuite/ibasn6a16.png
new file mode 100644
index 0000000000000000000000000000000000000000..e4de69fef1d63a762c4d8d782ee68e9fd7c33d62
GIT binary patch
literal 4164
zcmV-K5WDY*P)<h;3K|Lk000e1NJLTq001BW001Bm1^@s7RPB}_000mRNkl<ZXx`nK
ze{@vUoxnfyi}{sF<|ROANWh7pcp4~>qYEO?h7x~t1+;=e_qam4wu-PS&<c6yY<rxb
zdr+i;u38C{vq%<Eq1x32lU+cN?HX`}wo)-qAch2zyq8R7<_`1Y?H~7!B<y<JJ>5U{
z>>qPJ=iYbUz29H=`+fJ0!?tZ3pv44$7HcT6?dD!d+lFZ5r$3Pd%PJ~dxyALfpH=)w
z4&C<@)M#^S=hoWx%2xmzS}bgP`Y`~@f}+BeTOR)@Jh^V=7CGz6EsnN?lEL~)8BVN$
z8g2hRxpwu`ybK?HSUq*hGj7-!2l(#X*gH@YZmo5PH%v2i@Rub!UjN(;I}-rEdE2<{
zd$+y*@J%z|`ZZYZAD$2&UJDM}ZcE6;B7UgRPOg=$6ZMk+sjX<dk~kQcY3lCF;s$a6
zRqI9^ftqj?-<=CJ;T5;Yr*D<EZzzA%)ZyQ+`PQix3(Tvvwiav91TmLn$KwF)8(M42
zA2oINba?Co`Q*_J05{Ee|9yZFdoC^jhi#8K0+2Y^d1GMalxO}BgzMt)hX7oc7{n|3
zKMBHw1USsK(hr7Ey8RF74mb4rA>tq1T%3f6&s0WpD`TY;dsP2f)fPraw5<NvDmVPG
z1YqQxF(HWfuG(1^gNX0+emSsjg5)0`l8jrYmydhy*eW=G^c&N#ocRghx1#|nD?eTZ
z5nn|OKu!4gEJ@Qk+&!Zt9EIaEryK-0y=UA4a9^Gv=a4+y1#s*5GYcW&JAI9&z4W4~
zL->I8Z7gsd$j%0EzLC3g$OOFs6)NWeUfb2Rf8kxnR!utxlb%2vt+;ln<_4&o*>(t^
zsIsq3PB2`)*roxTI1$@EvFg~W?rs=99INst(Dt{`QE{sArkQZ|T;Gx@?*WuQ-@a^+
z1ZQtfHjH`q*s6{ol*O@90q`cEpa2F2VC?td%<GT{bZ)&a0p06TwO7vvhi&H_7jA%v
zzt^warWES=Q`=wBpKK6Sz7wYIz8q2oB>=_AqFoU26*F=UM0~-JeCo0#(@wQ<yhB}=
z@C@}thkEaeLN)%$f#U^}O&xk4FMi4p(7&f}fhh(F;8o7_D~p8M0m@<}haloBqp}hr
zKJO|u;cCgxRr|bZpH%Ix?LG5K_L@3$G?djF0{Uha9Wn*PYlHg$#9rTg7$ksG3E*6#
z_EJ>Rqqc;90l=iEhxbFoH;G%vL&Ud8y}kcit*zBlO&!`ktE@Bx#BK_`Zwg2q^4<iH
zndv?RkPWyJ0J*)+p#o%;02#GeFO5^)dQZ}tE@>P9Xl*@xP4!e$*ED$G0r}*C9|24|
zceET}<md|>00qwvJOtpKnK}gE`8+)qz_lm4V2A)h2@t<mvhT1m<_>_KdFJkty{7(2
zBTQIoa;h1wor4uV0M@r*-uv+D8E~rcXvMWZhf|F(?FRs3D$bq-D1NZ_MS#%7*a!gs
z-sDgV#KuaR^#B9M<3_<`Q}1kqQA<raTVPZT*7+9r#&;n8&k+0$xDG&eHk33%&r+y7
z2yL^#e-M&0p>ylmbEB3(=hm~cCLaPAzP7soplEO3U;#vxc-D8q)O+ioxXDBk%RCC&
zH0b>~6#oqj%z%O;klqZQ<=}h+a(9C7#~@yWq65%38?vXtH4fa*LuMHSdm&y7y>;E|
zicf&KxSOl%f#iF#9-N;h`TMsek4%>Q&2GsZ6C^kPy=3$%$(652{$P~kotq_V!je;-
zmW=o$!%<spXi0}{C%*~dhGf)t613=_nqa=JozD|s)rX@-(ha?J0De7u5W-QdEienT
zXu4U2=DR91RokuTXpzjRc7A+P^$+Y;p{)9QTk;F{`im2WfWF?MVsO~@iBDx3E?fo?
z9~3_Y5npUw!4%M<`Aqi36`AcT`>$ws6y_Jc&^)rn5YV@%XqO>i;QoSbM$!%DVmTo7
zqU5DUfY90zQ3yv%&7vaEqVYB*|7ViUe^Z*P{sF}v#SSCCa7U=D-w@Edym%A9fWIIK
zkkA8BaOPbAa&tiER!O;gHLYhJgrns>GL*tmN!Mt}<X*`Ow@9`blF-&x8IiUa-LEV#
zM@B<Q0>IM4Lj|~~1UTQQ1UMu4Nh3gMZTkiYM<cW40^V08y9*^hUY%d~<5iQ^gG|ZN
zDWhWmT`i?GGAv7y0H&@*VUP=)V<cTYD%@_D?E1Yj<y8RVHdVGlI67)qbv0<wcka%c
z`kha29cKvWUOjw0Kyr_NK0vzA(+`kocFzIG1)Q=L=uRm>-U9ab6jh<MH>x;)Q+a!v
z<a;jxEL`;RFCiS|?uB>l`UgvgQA?%sysxJ20dSRNzW{KCaxnl$vpomE;kT0j=nNGg
z`?y-@DixGxRd^|vT&R#d`b&V9UxEkz$`I94U)x=IHG1o@akHk3Lx;#}V?99l2}=j?
z7bg1whP7O(0dSAaoB?p@*`Y2-?T{3z>cvV`Y$yRvH3A$hhiT^w5wC#YIjF3Jw$Gqz
z_URSVBk1kV#^z4C9UaPh+Dib!Rn|#>KyzXafNz=D4B*kz|Mf2TG6>HOUij1&xOS-_
zE{uhdXAF_v2A=y35sE<Ub3=^X4rlH&M9JQ+{qD`C4sC5igK*F;NM7CrgIqA6!pVAA
zZO3zYF~(FF;^MV1;uH)#1O?AS?hSC>0p1v-3LyMvU>$|Bdgy3?OrdFwaiaJ2X9`F6
zqeH62TLVxS=uZFy9!YEj=VccR%>$i{Flvb*dhdne9fpXNLa56Sso#OO$`JN1!10J7
z-18vwmLUQGNF)qV^a1ouH^hi2T+|IwFgf<5<5p82WC8zR3k-I_y1W>}*BZil7{Z$k
z5xWyYZx}*M2j2&VNRI{2=Z3Jo;7A$5)dSfQLwHX@YN8>6`ygIxh@x%KcfTQupMu`U
z4H1|bHyrJzemN0ckq68=&~_T4uMUcuV8Dg~2P8iR|0Efr-g_at7+gESt^-Gt%pSS3
z;OU2SA@~l1m;r$oA@O4<Tnzm?AyWtLCdj>zY$$F*7ZdFd!oQ&2VcYp{KHnS&H;5|P
zN`4K+#Q)y7|7+v(<3Kd~YOH#PZJ(beJG^6MRrXbZ76rc!;b`KZe403<cttz@75(}4
zS3b|b|Gzc=*Q^7{sK4IQL7enenL4D-c*k1xZZLH@U|3oiLe+C$13+Mwe=%s$z^q^;
zgrftusnN$J-P<HxA4xh?e@-!@m{yfFU+5eu$$Z_(pGm$f1M2oFpOxcko`DgHm5M57
z4dkDHlvg<37K~UrBzO83n>vVqF9DFM^ELro@(fFZ8!Tl2&nJo-lp$2Vcci5MUjPcG
z1Uo^C7EB4Pg>ba5PZ>nfrAU`Dg!%$ae^V(`t_(0s8DOI_lzK0vm{6Bj`Et~!43S^&
zOZMj#j;#x=v2=)!3U-=0B(r`OK&ru850HAsyAmM1*s~KLJ;C#dOhQUg_uGm}WRFVA
z!_>E|w_QbssuzK?07XTi5NOe&B29yEv}c}rYraxcF{>yPop&k&sqrb*KkyflmTGrj
z!Jhefg-ufnTROyIp^&LVqA<`8Ah!CJ0Hn&L#FrX|)dQpho&-Rq&fNr%`E&Q%Ln6Sr
zai|a7$^dS48{t;x)L}=IK~$yot5Zk8M*t<i4p)E{Eupj)!qK3LCzsj+sjHOd?pKkq
zP5DoayPyuI?e{4@tMqN`+E+T)(!n|xt}t~Nm@HRJCZz<akT(W!sd3m+fXoajab~}J
zE<ol5_k#f0I#&}w?h)t4AratI1=+D(wUq&!H!2m>hq~)}We}y3M_tQ!)hCQUCK>7l
zD1U7D9iT<a9~-v`!ckAF@}Dw5T+Q01GEZwo-ovMtk9*G2q5I9@cbGcFisg*SkX#}4
z*WQf)>9mv}Q|Rso$ZmBl0mwGH<mc}Z=X8Kvz?lTF7dv(W<Tg2%4~YQO2LWmeIM%85
zW2&tbWR7a9oZ)Z`eeV3NGSmyoP^XoFUIM7D)-=$f)zu3ZK{%R!8(!PB@GeUS)6_Im
zhtz5BIDkxr`y4>_Avt622DyU$regtsZOb|A8yxbO*2q!-yVN1`&<3f2z16Wq>DdHa
z{v6LofIVJOdDK=BVDFO5DPQH(u`{Q(KsGCx*&><#m84K<E}xe#ysUhDOsdP>3-7Y@
zg?GWih49*LShxtFdTMJcz{vg!g#ZPUWrp{y5>Eqo{!*^swlYNkE|-+RIVaZw;M|&9
z0^t0++=Bp)2D=_EpF<pVb`yZ3+HM^Z0XenTv;U~t$^coVXhs#R^b?AzKcxy<QYji!
z=bGLQ$@bkcpkdr|mj3Aq82_9_=T;cC6h^Ip&gbCPkKmmt@ac-yW8=4>pI!mgn*hph
zZ+{D*cy;f3fY4KN1^?vaaR9GZO5iC>_XBv=r&j^En=^9&T%Tsg12~&<bpWp0q=wF1
z&N(CkvT7G*R8q?*1EfbwUQ&fDU#NsKKs+wlr?!C1(_Q<Zbgrd$?Ss-<i>?DuIvcum
z7#@YxJ>Y#+{!;hA@P6nngv@MkAArDmNUVaceeKVd)}nXqZ)ehD03~~6r73!(ZzDi3
zC?)WPL=3>YHMJCA*zcsoo-d>ZZhs~T;I7Lw0k|r&Z9^g;y-zV;xs?G@-&YE&y`8vU
zDXt74E3s)ZUkh8hX@aI%m?fa~fO#`$?}Bv$g#Q(id%!;*vL?7RaFs#!3)z?41K}s6
zM79YI4Ll~Kiy;_+cpI2z&wTAy=%&>}r3O$`D8C7Uh4FrXz}CbP0AEam0KBhD4Lp0(
z^8q|{=_UYAZF-+Pjwu7=k7fDGw2LYUUQl;ioyx=VswuXvuRpZL(mO&>)^CWe9Z-6&
zA$n#)$st2nCm~#Ah=Ju$u-Onv5BM{NNN)kp4-JvK9-JQ<!ucWOt~Z3|hmhW42!95W
z9zzsthJodV2v>o1(hwzwpl7BbO7DfP9fm0DhmMdTLTmc^ozGi3bQG4wq@1IcO1b6n
z@8Y@<Yo%W5HfFK569%2e@)3|)sXVPBK&S|iU(@k62u3VDZa^?%5g!4;ix6K9!A%f9
z48a)?FNa_|Bv#8XP8#5kz@;`ARtXth-u>Gr!BHiD_DR{7(P5YYmm=V=hGZ*b4RA%k
zHoy@9=M2al2KOe&EC=sJNR0r04J4Z(ZVY@BjG)Jj0Y**%2&CozC%%6YHv{<UL=%8l
zPeq4BK>l1TuTPWF#36sZrT6-wIAI8L4`>Sv(YFYSb{V2S1BGrw3~Yyj`wS7k1%mGy
zB58tOGlbX-zGa3;-w2)~hRB=&_gF*Zo&@I_L)a6+al#Oe6JSp?gmVq#o-~AeEM(3Y
z!gB=DHyXmX48&$b_%%qHh6uh3@mma0a32h8H$<Tu`ZI<o+68@!452LmbB`g46VU57
zgugy<$Z^opp*K*RlzJ97U5)@p{<2y$gRcfe%TOj;q;;?C|9|m(4*Ulh3-3uN?&8n@
O0000<MNUMnLSTX;;lBz1

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/iftbbn2c16.png b/Engine/lib/lpng/contrib/pngsuite/iftbbn2c16.png
new file mode 100644
index 0000000000000000000000000000000000000000..64a9cdf2f7fb4015cfededee285d015f96330cc7
GIT binary patch
literal 2624
zcmW;Odpy&79{}+0hMu{k(M};WMJ>4<_rok=GIGCPva%4Wg9urf`~5cIkuc<zP$W+&
zCC6D(%#mv@r?Z^7-{lsb@4R2H{eJ&!-+g|c%RWoAvbb<iKtccjaFAqTWCQP5?hB2C
z*Cz?T{ta&jf@~~o_x2UOF;fMAe~n~hVCU4<=hXT8VaKEA)TAx(=^L4YT|CUh!_2NW
z8Gf1At2`$526on^j})ph<R$p4o|YynIbH3Dpbb8~Vy!QK$lhK)#^@ho#KV6tiR!+n
zn$w}Mz46lN%)-qhxu_-?U*z2Sny#Rq`oJsBx-KWAOD{x)XpJF8?zy(@4S?Nj-uK`9
zwI%QUm>p{H?yeuYu9?5XL7|Vg@G%1<nPJ?M)U>#crW%*_;D~afi81aAE1Og)sZ&`U
zR~u4OQc?!zPC~{MKR>^j_;9AM3s04ue732g5?6`X_RhVx<Cf@6Dxt0yUW(k`wzRa=
z+Q`{<TrCCy;G;pX2A~b4ToEhp`JbDTqiyfx<YZ-^4uL=z8<`D!=?0G~v)Q@9`=W^}
zH-`&7`FUTUGlpng>P#k+2WGT1H8r0PTj4MzK71Itd_F#GHc|+i?<t;RUIrgaG5_w`
zbYFGgZ~33S&IqW0TtN(N+LtcdQBxy$RLRX>J1#yxK760<zUs$ZKZp!?q(JP%zF024
zqHfO0=En&bTY06E!V$`U+uPfTIhSA*-eS*iNkTjVAh3r8fIc07XJVIuWIQ6S-D3?Z
zxuzl})P4fyHtjS$F{Xo8fQCbY4JsRw?<+Qp7q05_ZFEVk?-}Dt`w$e&B`$Ozx^+<)
zX~H~ooIu@JEXJauuy(b>*KMJinq;%&<T6nl&=wY>VV??h8kfey_bGIGH4M!LDJd%}
zYiaNyBSGiKBn3yuXrvX6@dODL@t47pHV*Xmip5<Snk_TSRmzk#?_HfYS;2R&P~pRn
z$>Z(GN0r@QCyebCC#>Ch<6d`~M3*HcmEe;0i^88tDjWX#_3JNklEU#}h2=gvl7ztT
zA2LHnU{7KAm`hrEilPBJ1r`swV6wWp8XFrma?hesyr2FJ(kbYlf^|Jp1dmK%e)ei`
z&e`7D+ESOu@f<S6!*3|r*jk$zs3XHvQwih!TrVnO{#gpeOTP_Z|CxGBE8{w<<Z%)f
zmn3_}6oy4-8Mk{pb5f9g<T^W$F>Z7s(?nJ^@8YSfGxlQd`&ld&?T@Vrp=*sUH4bM<
zfF88{Vu-qZ8_VcBfQ*h#Qq|Vh%&|yM6;D;ap<XfvYpaxNn0?ENksWE+jZ%tA^GJV<
zH8qjSW{n$wKHatq*|rVpk>u_QTw|lar><9S4GoHlYHEs#hK7W37Mh;db4^_$^#fws
z(WGiyhIR!ed2&yZ8Bq1*=g*(i@MhRT!MA<YCCp{HF}E^c*}WPn6G9eN(xNYxaz7k*
z1|xPV_i&8lAsQPrG+1zEXP4OS3rp<mB||Bm%&L6`70MsG=S@y-%DnVa%}Y@@7q<Mp
z<0x6yw&Rh5puoHCbDY562w7p9%M)e=!pwlzZpJ&_TEihJqS|R}ZHwMbyg3gF3G`L@
z(L()we9@T+t>{E7ZWFIhh*&6exw|k{psNth5$>+;!;@XPzJB3~u}Qyeyo`!HUu>1Y
z32U+PZyuemduvfn?>KouAK~QO8X#Fz#8eS-Z~#2GBiy;={|E49n8k_k#vwj%5a8b4
zUGKiR`APp~kw|8`c{ww^;$FQ=MR|F-Kh<}-zs6>&U-5a;EA5Z`Hn(5{RrFp9rcfyC
z)hWfBeu4&MSKBJP$3^!ZS65f(=fT{DZPGoRG;<qVYWh7y3Jz?apt=3^9Lrj@SV%Jh
zR+{dwula>9ok!cr8=#3K(e?rnnSuih9H|87nJY8I@HRm6*4*~=^qg4fMgUcD_=B@G
z-`om?zJ{R>+^q0<@ZxJegh-Rpz5V269(VqJ5JAB$j2sHX$LK`>-e>@Na5NnK5zfLg
z>-%aDoY7b$P2prLPi0?HiNgXB%q_qfDx#hs*(8=5AU3|m!<KePqlm>7S8hV-grs(l
zrMeaunB`*<(_C|-)#9_H%cprh&^wyW(>-aN?%pX*_t|2{-4m>Oh0gkvLTlIip3Vmr
zw|91JE39Vuqp%}4YaFWEpXNcf6|lFSl<|Sfx3WB)f8>&1H8(d)rSYKkMTa}|t9XHa
zFTngFWP{Pi3%?6EBFMaPBiq!~6-+D(2T3|&B<o^!IbCdj6rX{9)~At&a5;E46kFl$
zn<kdv{$v9neF*5wm-S8sl??WBtw{3<#5VD+-T}>e=%-&prdxga7PsX(7REaapP}B>
zC%v!FW{HU3N5I~*OQ>uL!^0hNzq{H_-d;V4t=-bd2N*p7tgfxCudi!qstUEKd_tfY
z^VVdty*>F5mINwAh2pOMby-EC?MkW08|(Y$4G>mng!67`Xoh`ZIb1uj9_h5*ANlTe
z14jikAi7bnE@h-63jjeuLntD6YG}pOr%6kFaLzaQS>-7}ai&qF+m^#}&x!@TyghtY
zq9r4Sd*n$3Cfq266DEC->RxAB_TJMOPNk__6gHu_ShA?|pfD2r;ejFgh$bFBZShb{
zEYuR2t4wa8ZZ5CQXlM-79hY*tq<80e#f6;kJHx{#GGA!YQ;bYR8MX6@2qJ>vLoA*$
zMP?tgqsyMjLI6}eEFFvGrCL*4TPv*_r#d<~IJmL19<ng@W_u#HZQlY397H+RQhy9(
zpVj*P-qzITd<8RWg=988hHc@kG8u$qbp6!i(N^lzC8j(H`~q9c*_8(*7$>)Th%oh}
z(<@3#?Ub^Y!#ZV>CzjY3(xvqtJj92?-JgCg?(Seqiz!2JtkG|v_EIxk9oIEoL)NPu
zM@My8<6in>p4p<@aSPv-WcuSJ>@gGO?YzhWse*!H)+(emz6y)BFuFFL1yt3)xxKl=
z-L@1;TN{O<d5k&a0>bkVQ5l|5gJ$R9GRx@f8yFba+n@voYaBy8B;4J4ZlR^7rnWNI
zqzI*^ZZo52-xb+grR#*ukG#CadDumc2-Z1$YGgi<zp(pi=-4-gPkgD{pJN%rFYRTJ
zl?EqGPg@q^!&WE1bIH<Y3^K90i{9CzamLTL*B8d$MjSVPkRbcOmnTvmi%#IK3ZYF2
zDK5Q;-JhE)oSq26AKT;lKzx`p)mvd%L<nvkz1ei^lJjfWPBX+N#USx>xBmT<r{+x<
zVUJ&A{AKm!I6ido@7CzPeTn-bp|{gBdjiN0thIC8{X>H3f9AByue^ti+)LZ}&)tId
WtY3e({0;sk1SFz`QSJH5QU3=T4Dpo!

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/iftbbn3p08.png b/Engine/lib/lpng/contrib/pngsuite/iftbbn3p08.png
new file mode 100644
index 0000000000000000000000000000000000000000..47d6eeb3c0f2f0133d6a3e248e9d6103398177da
GIT binary patch
literal 1507
zcmW;KX*d)J7{Kv&W-uA7DMyEPqok;zaV*hTJcA)2!_1D@MNA?`%;6jn!<c2<_mw6|
zB2zl79=94%TW&3t7Ex%CY<TR{hxd6uydT~Vzdz5}(N+Po2Lk{Kb|j*UWUGIhZ72YQ
z!PO>b0OV_D2UqK@t*v+O-igKHrKP2rnVH7M2OJK^&(F`7LgQ*_Ra;rL#KwLYA75Bl
zXlZHT@p$LXoeTH$j4(IntEi*{Bm!IlC;+&sqcb)zu(7ex+1Z(!n;RAu77`ek4NwLU
zp{N*w!<|N>vt(qV==6$;is#RtudS^W6&0~qtnl#gYXBmEUVw)H!NI}B#l^k7y>W4I
zOeQne(D1(Gs;DS%a%xalp8)s(5D*YBKK>>tDJdl-B{4BEIy(9ig%ZJJvf1qTz`%YC
zX6}a{LPJA6JUm=nT;}HH;^X6!Qj*fs(<37zeSCb}+}xa<ogEw;I0+ohd`%F7S*aO6
zm!F-TEf5HzqN1o&Dv3m*(P*iusc;9N8(<miTkW&5vhwrub8>Q$lapg&Vh$gUk&?>C
zVxzUSDK<8wgoFgyTe9#7U<H(>lrl3j3kwVRe12?fESc<u#Wn$m0WtyntE;Q!ugJqR
zuqs)^N+Rh7NpM|IR#sM0QsVCJPNmZ1<p%*i0hA+=o@lfMfRCCQt$(Orqd)_00z3g|
z2DkybIl85#rRC-2y1Lf^ws!B<QBvBA!BC8iDNqSe2k`GV8<PSP27}?~7>GoEMxlaC
zO)XVbExWtB4U-I^0U!<F8Jx^J36Fu0O#l#TXwWPzPnDEhv5K(zruz`EnOMjNS=j|V
z-s?MQGzQ}Z$p9k&lFuCgc~DSL;O*^ABu0E^3|w7Zwe`2fv2oA_&;^hMl2~v!S0vIG
zfd~O84hRhZK0piP<>l?zQHRIlm6d}e)I6RbEiDahgCX6J$RolZK+GgkC=`IwuV24<
z`+Af4WRNt$0}7Aw@#9A>m+Kki3E)d6ljr9bot&H&7Z*>TKE1iQnURs9v~@ueCm<Lu
zj%2Wy9-&LR7ugXlT}_^z^#WA5?oJu5aQcD_clZT%yG-;>V?A!J932YvCK99~q^%EH
zFgOhwXDr+lP#sfagTpl;mahA}Eu=TvE3+(mhF-LHjf+uFbR2NFo7FP<lw`H;pjxDU
zd)*U{mWyh_wT05<LTnJLmP9|M-%+@yXsiU&6lGfCvtP#jrF#5dpGat1^^{eCY&uGN
zw!GkPlgJwP4=X)|cdl6=&#cZX5*QDr-ZxA=j&9?gpoz^F?eSZmAJHC#US4+`Rf`F=
zWSSj7AzBmL-zi~tY*(7eOXxW-Tl4<?tlW{*aDTO>gyw(V_|ATuoSW8tJ2@#vD{qtK
zr-VtFjcXlN6&}1+arl<7v!L%<v&a;!>1=T2nBU8s^DizMG|~GIvbDc9(&w8#lNG8$
zMg|`4)_g;#Uu|vsTx3gMSvbx?UI-ZxZ&HV=x)~RmBKJ;aR9*k?RhhMn`2<r=wW@wX
z^8_E`F?N<8y564QQm^LZ9J4$o*LVNWHfc1awY{hNS(~`4@3MB+QQUzehdQ<E)%B{X
zg|)RuYbtB1>JZsR`a}A7{NS*WfpO#QyCTuOdoTNUW*Z=oYNu`^L(uzv|Alil&b2}X
zyGywjiQjLof!986t!0EGpfJ7!gFB+|u;mJta8PSNWysdX(C}xY`)duOckeZ_87$_P
zl~qfX+m3~1^}!rsN2j#hnWF2s)HBV(v$LX+spFz!RQq6BBlFe9{9B&cP~aX%75`VG
z4Gikg0wJ2(s!S>^iFrRTYjDn~+_Tuda?~_d{BYSo&!hS7uI=*d>4`_|xXE-o#h+|?
zh=dvwmIiy6`}hu3JvpZdv7VDSqxYMQ%DNQ2{Lj$3xhm5rFZ;oj*W+JAE6*y~PwA|E
wu>vDq^P1z$_jax+3s-luV@5gN#{2Q9h_9q2!pxq`A0;V+owXye&dMv{e<~b-F#rGn

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/iftbgn2c16.png b/Engine/lib/lpng/contrib/pngsuite/iftbgn2c16.png
new file mode 100644
index 0000000000000000000000000000000000000000..64a9cdf2f7fb4015cfededee285d015f96330cc7
GIT binary patch
literal 2624
zcmW;Odpy&79{}+0hMu{k(M};WMJ>4<_rok=GIGCPva%4Wg9urf`~5cIkuc<zP$W+&
zCC6D(%#mv@r?Z^7-{lsb@4R2H{eJ&!-+g|c%RWoAvbb<iKtccjaFAqTWCQP5?hB2C
z*Cz?T{ta&jf@~~o_x2UOF;fMAe~n~hVCU4<=hXT8VaKEA)TAx(=^L4YT|CUh!_2NW
z8Gf1At2`$526on^j})ph<R$p4o|YynIbH3Dpbb8~Vy!QK$lhK)#^@ho#KV6tiR!+n
zn$w}Mz46lN%)-qhxu_-?U*z2Sny#Rq`oJsBx-KWAOD{x)XpJF8?zy(@4S?Nj-uK`9
zwI%QUm>p{H?yeuYu9?5XL7|Vg@G%1<nPJ?M)U>#crW%*_;D~afi81aAE1Og)sZ&`U
zR~u4OQc?!zPC~{MKR>^j_;9AM3s04ue732g5?6`X_RhVx<Cf@6Dxt0yUW(k`wzRa=
z+Q`{<TrCCy;G;pX2A~b4ToEhp`JbDTqiyfx<YZ-^4uL=z8<`D!=?0G~v)Q@9`=W^}
zH-`&7`FUTUGlpng>P#k+2WGT1H8r0PTj4MzK71Itd_F#GHc|+i?<t;RUIrgaG5_w`
zbYFGgZ~33S&IqW0TtN(N+LtcdQBxy$RLRX>J1#yxK760<zUs$ZKZp!?q(JP%zF024
zqHfO0=En&bTY06E!V$`U+uPfTIhSA*-eS*iNkTjVAh3r8fIc07XJVIuWIQ6S-D3?Z
zxuzl})P4fyHtjS$F{Xo8fQCbY4JsRw?<+Qp7q05_ZFEVk?-}Dt`w$e&B`$Ozx^+<)
zX~H~ooIu@JEXJauuy(b>*KMJinq;%&<T6nl&=wY>VV??h8kfey_bGIGH4M!LDJd%}
zYiaNyBSGiKBn3yuXrvX6@dODL@t47pHV*Xmip5<Snk_TSRmzk#?_HfYS;2R&P~pRn
z$>Z(GN0r@QCyebCC#>Ch<6d`~M3*HcmEe;0i^88tDjWX#_3JNklEU#}h2=gvl7ztT
zA2LHnU{7KAm`hrEilPBJ1r`swV6wWp8XFrma?hesyr2FJ(kbYlf^|Jp1dmK%e)ei`
z&e`7D+ESOu@f<S6!*3|r*jk$zs3XHvQwih!TrVnO{#gpeOTP_Z|CxGBE8{w<<Z%)f
zmn3_}6oy4-8Mk{pb5f9g<T^W$F>Z7s(?nJ^@8YSfGxlQd`&ld&?T@Vrp=*sUH4bM<
zfF88{Vu-qZ8_VcBfQ*h#Qq|Vh%&|yM6;D;ap<XfvYpaxNn0?ENksWE+jZ%tA^GJV<
zH8qjSW{n$wKHatq*|rVpk>u_QTw|lar><9S4GoHlYHEs#hK7W37Mh;db4^_$^#fws
z(WGiyhIR!ed2&yZ8Bq1*=g*(i@MhRT!MA<YCCp{HF}E^c*}WPn6G9eN(xNYxaz7k*
z1|xPV_i&8lAsQPrG+1zEXP4OS3rp<mB||Bm%&L6`70MsG=S@y-%DnVa%}Y@@7q<Mp
z<0x6yw&Rh5puoHCbDY562w7p9%M)e=!pwlzZpJ&_TEihJqS|R}ZHwMbyg3gF3G`L@
z(L()we9@T+t>{E7ZWFIhh*&6exw|k{psNth5$>+;!;@XPzJB3~u}Qyeyo`!HUu>1Y
z32U+PZyuemduvfn?>KouAK~QO8X#Fz#8eS-Z~#2GBiy;={|E49n8k_k#vwj%5a8b4
zUGKiR`APp~kw|8`c{ww^;$FQ=MR|F-Kh<}-zs6>&U-5a;EA5Z`Hn(5{RrFp9rcfyC
z)hWfBeu4&MSKBJP$3^!ZS65f(=fT{DZPGoRG;<qVYWh7y3Jz?apt=3^9Lrj@SV%Jh
zR+{dwula>9ok!cr8=#3K(e?rnnSuih9H|87nJY8I@HRm6*4*~=^qg4fMgUcD_=B@G
z-`om?zJ{R>+^q0<@ZxJegh-Rpz5V269(VqJ5JAB$j2sHX$LK`>-e>@Na5NnK5zfLg
z>-%aDoY7b$P2prLPi0?HiNgXB%q_qfDx#hs*(8=5AU3|m!<KePqlm>7S8hV-grs(l
zrMeaunB`*<(_C|-)#9_H%cprh&^wyW(>-aN?%pX*_t|2{-4m>Oh0gkvLTlIip3Vmr
zw|91JE39Vuqp%}4YaFWEpXNcf6|lFSl<|Sfx3WB)f8>&1H8(d)rSYKkMTa}|t9XHa
zFTngFWP{Pi3%?6EBFMaPBiq!~6-+D(2T3|&B<o^!IbCdj6rX{9)~At&a5;E46kFl$
zn<kdv{$v9neF*5wm-S8sl??WBtw{3<#5VD+-T}>e=%-&prdxga7PsX(7REaapP}B>
zC%v!FW{HU3N5I~*OQ>uL!^0hNzq{H_-d;V4t=-bd2N*p7tgfxCudi!qstUEKd_tfY
z^VVdty*>F5mINwAh2pOMby-EC?MkW08|(Y$4G>mng!67`Xoh`ZIb1uj9_h5*ANlTe
z14jikAi7bnE@h-63jjeuLntD6YG}pOr%6kFaLzaQS>-7}ai&qF+m^#}&x!@TyghtY
zq9r4Sd*n$3Cfq266DEC->RxAB_TJMOPNk__6gHu_ShA?|pfD2r;ejFgh$bFBZShb{
zEYuR2t4wa8ZZ5CQXlM-79hY*tq<80e#f6;kJHx{#GGA!YQ;bYR8MX6@2qJ>vLoA*$
zMP?tgqsyMjLI6}eEFFvGrCL*4TPv*_r#d<~IJmL19<ng@W_u#HZQlY397H+RQhy9(
zpVj*P-qzITd<8RWg=988hHc@kG8u$qbp6!i(N^lzC8j(H`~q9c*_8(*7$>)Th%oh}
z(<@3#?Ub^Y!#ZV>CzjY3(xvqtJj92?-JgCg?(Seqiz!2JtkG|v_EIxk9oIEoL)NPu
zM@My8<6in>p4p<@aSPv-WcuSJ>@gGO?YzhWse*!H)+(emz6y)BFuFFL1yt3)xxKl=
z-L@1;TN{O<d5k&a0>bkVQ5l|5gJ$R9GRx@f8yFba+n@voYaBy8B;4J4ZlR^7rnWNI
zqzI*^ZZo52-xb+grR#*ukG#CadDumc2-Z1$YGgi<zp(pi=-4-gPkgD{pJN%rFYRTJ
zl?EqGPg@q^!&WE1bIH<Y3^K90i{9CzamLTL*B8d$MjSVPkRbcOmnTvmi%#IK3ZYF2
zDK5Q;-JhE)oSq26AKT;lKzx`p)mvd%L<nvkz1ei^lJjfWPBX+N#USx>xBmT<r{+x<
zVUJ&A{AKm!I6ido@7CzPeTn-bp|{gBdjiN0thIC8{X>H3f9AByue^ti+)LZ}&)tId
WtY3e({0;sk1SFz`QSJH5QU3=T4Dpo!

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/iftbgn3p08.png b/Engine/lib/lpng/contrib/pngsuite/iftbgn3p08.png
new file mode 100644
index 0000000000000000000000000000000000000000..47d6eeb3c0f2f0133d6a3e248e9d6103398177da
GIT binary patch
literal 1507
zcmW;KX*d)J7{Kv&W-uA7DMyEPqok;zaV*hTJcA)2!_1D@MNA?`%;6jn!<c2<_mw6|
zB2zl79=94%TW&3t7Ex%CY<TR{hxd6uydT~Vzdz5}(N+Po2Lk{Kb|j*UWUGIhZ72YQ
z!PO>b0OV_D2UqK@t*v+O-igKHrKP2rnVH7M2OJK^&(F`7LgQ*_Ra;rL#KwLYA75Bl
zXlZHT@p$LXoeTH$j4(IntEi*{Bm!IlC;+&sqcb)zu(7ex+1Z(!n;RAu77`ek4NwLU
zp{N*w!<|N>vt(qV==6$;is#RtudS^W6&0~qtnl#gYXBmEUVw)H!NI}B#l^k7y>W4I
zOeQne(D1(Gs;DS%a%xalp8)s(5D*YBKK>>tDJdl-B{4BEIy(9ig%ZJJvf1qTz`%YC
zX6}a{LPJA6JUm=nT;}HH;^X6!Qj*fs(<37zeSCb}+}xa<ogEw;I0+ohd`%F7S*aO6
zm!F-TEf5HzqN1o&Dv3m*(P*iusc;9N8(<miTkW&5vhwrub8>Q$lapg&Vh$gUk&?>C
zVxzUSDK<8wgoFgyTe9#7U<H(>lrl3j3kwVRe12?fESc<u#Wn$m0WtyntE;Q!ugJqR
zuqs)^N+Rh7NpM|IR#sM0QsVCJPNmZ1<p%*i0hA+=o@lfMfRCCQt$(Orqd)_00z3g|
z2DkybIl85#rRC-2y1Lf^ws!B<QBvBA!BC8iDNqSe2k`GV8<PSP27}?~7>GoEMxlaC
zO)XVbExWtB4U-I^0U!<F8Jx^J36Fu0O#l#TXwWPzPnDEhv5K(zruz`EnOMjNS=j|V
z-s?MQGzQ}Z$p9k&lFuCgc~DSL;O*^ABu0E^3|w7Zwe`2fv2oA_&;^hMl2~v!S0vIG
zfd~O84hRhZK0piP<>l?zQHRIlm6d}e)I6RbEiDahgCX6J$RolZK+GgkC=`IwuV24<
z`+Af4WRNt$0}7Aw@#9A>m+Kki3E)d6ljr9bot&H&7Z*>TKE1iQnURs9v~@ueCm<Lu
zj%2Wy9-&LR7ugXlT}_^z^#WA5?oJu5aQcD_clZT%yG-;>V?A!J932YvCK99~q^%EH
zFgOhwXDr+lP#sfagTpl;mahA}Eu=TvE3+(mhF-LHjf+uFbR2NFo7FP<lw`H;pjxDU
zd)*U{mWyh_wT05<LTnJLmP9|M-%+@yXsiU&6lGfCvtP#jrF#5dpGat1^^{eCY&uGN
zw!GkPlgJwP4=X)|cdl6=&#cZX5*QDr-ZxA=j&9?gpoz^F?eSZmAJHC#US4+`Rf`F=
zWSSj7AzBmL-zi~tY*(7eOXxW-Tl4<?tlW{*aDTO>gyw(V_|ATuoSW8tJ2@#vD{qtK
zr-VtFjcXlN6&}1+arl<7v!L%<v&a;!>1=T2nBU8s^DizMG|~GIvbDc9(&w8#lNG8$
zMg|`4)_g;#Uu|vsTx3gMSvbx?UI-ZxZ&HV=x)~RmBKJ;aR9*k?RhhMn`2<r=wW@wX
z^8_E`F?N<8y564QQm^LZ9J4$o*LVNWHfc1awY{hNS(~`4@3MB+QQUzehdQ<E)%B{X
zg|)RuYbtB1>JZsR`a}A7{NS*WfpO#QyCTuOdoTNUW*Z=oYNu`^L(uzv|Alil&b2}X
zyGywjiQjLof!986t!0EGpfJ7!gFB+|u;mJta8PSNWysdX(C}xY`)duOckeZ_87$_P
zl~qfX+m3~1^}!rsN2j#hnWF2s)HBV(v$LX+spFz!RQq6BBlFe9{9B&cP~aX%75`VG
z4Gikg0wJ2(s!S>^iFrRTYjDn~+_Tuda?~_d{BYSo&!hS7uI=*d>4`_|xXE-o#h+|?
zh=dvwmIiy6`}hu3JvpZdv7VDSqxYMQ%DNQ2{Lj$3xhm5rFZ;oj*W+JAE6*y~PwA|E
wu>vDq^P1z$_jax+3s-luV@5gN#{2Q9h_9q2!pxq`A0;V+owXye&dMv{e<~b-F#rGn

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/iftbrn2c08.png b/Engine/lib/lpng/contrib/pngsuite/iftbrn2c08.png
new file mode 100644
index 0000000000000000000000000000000000000000..08ebbae2c8cc7ba70c0104a0abefd746475fe44b
GIT binary patch
literal 1624
zcmV-e2B-OnP)<h;3K|Lk000e1NJLTq001BW001Be0ssI2{21+{00006bW%=J0RI60
z0RJ~w8+`x(1`SC>K~zY`wU*CM8)q8Fzcb^pJwL!dFa}aXFkpy@smTvEg-cUu)kIxI
zi<0J;s?v%@s<i1XJ@k-6j{Of%FTM28AJQhNRx4IfrGPgIso6LLHUtNgH56>ezdbXa
z@yxt?m?R{-rjSbgYAz$q`~5u6^FHr84@C&UZz=jWb$>I!=H}+Y!a}7|c_V;r-!C$m
zOgtXHd-v}4_BNN#yOYTy?d`#H=LXK5^Y!)ZyPVo<4~oTNB9T~FSXf_Qx5=_AnRKtN
zGKE4Nr~oa1pQ4<RNcZGq&xH$zBN2vS4g{!Hs}CMLNF)+Zo;)#B)w#Ore*CyKo#qLt
z07al8ip5~C^7N@usc=99XtCROKK^)cVj>!ihQncp!_fp#uh*BBmhRubpG+nV!{D-6
zA(0SQR|QoS00+<o*nupNp{Q(Ur|R)&nGBuJw*xAWyl{be>n)aL8HNdkLg8?DczD?3
z@$3TP@%YV~Hx)&(UW2o<eTjq)(10R}+i$;Z`u#&oOWmoIXqqiR9jF2lkOSr@s`AMv
zcAkG3wIoTSqoY$(Q@fk&cDwC%JI8Ult}BXC428(%ro{7`$B*X*2MJ9B*cuw*Yqjvo
zN+gx?mr5>Om+khP-*1kNIz`d)QC0QXvuCm__xJa|R-#-kH#0M17>3PZ<Lq3c(U4_X
z)3k%PqhT2Ne7;;R>$<M%`pnEsS6A0=2Cc2F4K%*?f1PSgjghhQrSm@Cr|WvHR;$<R
zdzo6n5kku4az39|RaMt@!!X=#x8=SIa5x--T}TF!q>bE(-07X~9Z!zi?RKBfXBbAc
zT9qWJNefbxBuSY}ad9z}OopA#tw3O-r>7DQhnpNUr_(9ag_=?WjXOhk-dTIc3Xo-4
zpU>y@dMlMmtyX&(wWevgT&`R;fBf;ILZKD-XRTI#^vFfi#_;g)OWWP6f~IL+=Ai%u
zY;<gFdA0~4GUV^s@4pqll~}2*t*yJe+wFD($mjFvbXt<?vDjY<h2y|OnqH)+hk#bC
z+L{C0ZnvNakb$28Aa*212)WgMYqn>0mY)4e|B4X8FpSsh)pfm8DiJ~+KR&awa~xP<
zn16J1%nQOJQLOd!XrWN33Bc?1@(PbSumvdissAU1QPhTt7N7*K!I2lzG>s6VD6J14
zeh8Eq=9{sxTr@hs^8<$u<J76cHk+*pz~k|73I`Xk0c=CHt8@0bx>AP;5U_-O6#!su
z?fpiB2maRAmk|VRaq)NA?4MUw#)pTauQtMK0AAq%paA>~n7CKEXSrJsA;dIILWruW
zriu0S_kgm^7He&#=I7tbW_y7rqWG_)M+ch&yk0M-aL@rB+y;jnGJ(vFz5@dwpb2fc
zzv!PqMezW4{r*ZiT~yT^5C@7bmpU>svNxd4K?mFzNDW{M=)rnp9VVbbB%<YRnx?9%
znM?>!fOvbm%rM(Dy#qLb(PPIB34+iZz%WdwqZ19l1y8}_+w{Q&QYSD0^Lc$t)3nZN
zvFHJIfd9DNb+5O<^E_}GxIaGrzrUc@ewhPZ1FXhEgiOhijR<5w1Ps6gF`oleRV9Q-
z5)G^|jOldhHrsfuHU?xlF8}VkCw>WV`SRs2ykDGLJ~?8J^l$asx9sSEwFf-mEr8Xd
zjYb*RwAqY&zI}Q56yQ2^=&#>>_os=8iC+S+Ec@vnKmGC#Uy7VaH|U{_A=sX0K%2A$
zu<kxVSOK;*jgH5U=(-#T-1^~%Yae{@`~SbMnoJeZX!PpUtHEIK=+mPxo@ZdbkX53N
zj(aq{O$Z?*6%ME8<~}=iEQ)4oKDM;AwOzS#<^06?U?yl~U^8v6mdN9&b$0%}r6qOd
zjB9@W^WNS=*h71cEeyk4ym)cw-$T=}X{js?@`DCt0I)LfdcB&aoj!f?+O=ye%VKX)
z`;LyKQtA5j>*;iwVHldGQ>j!on<a!yPEKCBbcv?-8Qt~=03d|izI{6ui%}G{wzgI-
zm#3zt&YnHH@4|xuETvMZ8#it&FE39|PoFq(;()8(002Oi<wBtl2m}tk<jnxTLjMK6
WUtVfYto9oK0000<MNUMnLSTZmiXtBX

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/iftbwn0g16.png b/Engine/lib/lpng/contrib/pngsuite/iftbwn0g16.png
new file mode 100644
index 0000000000000000000000000000000000000000..4b7537e30508560b833f3d2da7dc8c620a34c301
GIT binary patch
literal 1448
zcmV;Z1y}lsP)<h;3K|Lk000e1NJLTq001BW001Bm00001afZqL00002bW%=J|NqFf
z-^Ty|1z|}<K~zY`rBi84lXo2c_3c{<MM_Z-iy}-^VDp+_P+(3ooWpA*%(!e*=bTg*
z6OGPu$=v3xb9gPzdd&lMMp*y_r!&MMLqK$*4I0bUmR3rkFKyqq$NN9_fr@}kKkWJR
zKc3(7yCswY006K6(`OFd6mbP8&51m5Vz`0@aIa|9*YT1r&aPc{`=b-`cUZl^_p3=Y
zTn0)rBZ4<m3Y1dX-oAKWTuWvKrIbo2{p$C4qe5XcnoN1w$4m@>Ea|c38asIKZwJ|`
ztSq3EQc4L~ytwn!<>xsV0D#@Qlf&bW>#hL+Nc8%XC(SDd?R|P&Ri-?glOv&YUqPVR
z<#ISKd}0PyJOgn1<N6MjO0N(2AYc&y0}!%DpXKw_9Dsi7@&P220xSz1wfVG*nQ<=}
zz#qr9ZN<fX#$hrkl}csz7Z$+dIdkU86WuDy4q3Khjx%XsT+<XbF@0NL;M}>XsS--P
z-c=u}_#yK-&g1E{qLkA5dY%snId_f)kjrU1K7cMta-MBZiI7UKUpEy$&S#JM)RsN|
z)O`n@{OE`>1@ZSq5g~hPZKCXL2dA9Rvi>wgad{hilnSj&rWScT2QTs(woLI$V<3Q^
z&<Wk`tz>+8bF;w^AHQ>FR~obzjK-e#m-^8gOwVg&<x7m`QY9rC&Ft%MX2xC}Yu!H!
zp>8g!sxDpPlByO-E-SQR5*y)Z^z9t8Rc(up&&mo5V*qa4P%81lL4(qBQ{z&<A2NK1
zA?AD($FjF>-M<eYp>)gY#wBA}T5PkuaLaLKv)5Zx1i%8Q-U!)9V`Oo|h5?w(lzP2&
zpO&8D|B4OrXVJeu{|}@SqKncUiHSkTV5s<3$dgEw20tM-mW{Ugo=ug1!^|MW<!UMw
z%96LpCVW1ji-2<thn{W6xo{q1r_-3E{G)QSFJOL|pAa4{7J7up@5ou{5{v}_O^mJy
z3Izxb?yBT_kCa^76|{lzAVi3Fhi43qyQuC~>dy}ED#z`3J;_CgQWW^`(B0&WBb|h9
z&04cPB&%Oxd3kelX{k)sN3-^Bn)XZ-0q)#+@!dlK06-8Fik{7U?L52=Y~Rl<E!EW(
z6&4Hsk!@XM#WeLa8fEXB*)0O6v!>?3gStB3Xp76L<SLmt=&opHr}U38i^99im5`*M
z=(L4NDdWZ^B*^7G1gfhG3*Bx?0iK+0iJ^Bv8&INd3^mvSJ2o;CSToTgHNN64uxG!&
zEU32AkmtvbU%J#U(AuiiVjOTsK3x<A!RLEb&KS3~b#x$vkXEZ!`)d#$9uUwlGguwj
zBG(43l}Z@~W2ckndz$jRRa<+{aFiVoo}pHy{jFAaE22U{qJ(UBghEU5BuPYXxgeW8
z<Y)O=LL3f`v)MQf&(kH_N4fX-R)`VKsc!wghdl;i_;5Om*ECj&g(MQoTZ_>2r&ntk
zLKr42Oc3mL&(R8-J>TVwTa~t9z{C-c=dMgh=p}$Nf^^283~suns#-`SX{1JCCIn+b
zoK7<Nfks5G^!Sl=j>;z2NXyiD^LmZqh!J?LI5RZUmTme|eavtQD^Zi|G{%Hr>~tD_
z@V2@hj9709b$=m-O82J@oHVJIfK)oV1RYVCz0K|v#=&%8CCSAagb?C+gj!~KF+~IU
z$X&AavPY8HU$1^q+OB0-v*y>v<!=ow$6L5|l?87gX>2k=2ss>-(mTEuGPI)N>6Zhn
zH*s52O3EvC0pq;9n|olDC4FSUV2)udmWBqawchNBo-CZ^!fIbJ%H6?n`T0hpRLU?7
z4OT0qnVAa~Fic;}S8iiNLqUN~r_m%P{x|1;uk*j3h8*&ox4E1E0000<MNUMnLSTaV
CsI&(F

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/iftbwn3p08.png b/Engine/lib/lpng/contrib/pngsuite/iftbwn3p08.png
new file mode 100644
index 0000000000000000000000000000000000000000..47d6eeb3c0f2f0133d6a3e248e9d6103398177da
GIT binary patch
literal 1507
zcmW;KX*d)J7{Kv&W-uA7DMyEPqok;zaV*hTJcA)2!_1D@MNA?`%;6jn!<c2<_mw6|
zB2zl79=94%TW&3t7Ex%CY<TR{hxd6uydT~Vzdz5}(N+Po2Lk{Kb|j*UWUGIhZ72YQ
z!PO>b0OV_D2UqK@t*v+O-igKHrKP2rnVH7M2OJK^&(F`7LgQ*_Ra;rL#KwLYA75Bl
zXlZHT@p$LXoeTH$j4(IntEi*{Bm!IlC;+&sqcb)zu(7ex+1Z(!n;RAu77`ek4NwLU
zp{N*w!<|N>vt(qV==6$;is#RtudS^W6&0~qtnl#gYXBmEUVw)H!NI}B#l^k7y>W4I
zOeQne(D1(Gs;DS%a%xalp8)s(5D*YBKK>>tDJdl-B{4BEIy(9ig%ZJJvf1qTz`%YC
zX6}a{LPJA6JUm=nT;}HH;^X6!Qj*fs(<37zeSCb}+}xa<ogEw;I0+ohd`%F7S*aO6
zm!F-TEf5HzqN1o&Dv3m*(P*iusc;9N8(<miTkW&5vhwrub8>Q$lapg&Vh$gUk&?>C
zVxzUSDK<8wgoFgyTe9#7U<H(>lrl3j3kwVRe12?fESc<u#Wn$m0WtyntE;Q!ugJqR
zuqs)^N+Rh7NpM|IR#sM0QsVCJPNmZ1<p%*i0hA+=o@lfMfRCCQt$(Orqd)_00z3g|
z2DkybIl85#rRC-2y1Lf^ws!B<QBvBA!BC8iDNqSe2k`GV8<PSP27}?~7>GoEMxlaC
zO)XVbExWtB4U-I^0U!<F8Jx^J36Fu0O#l#TXwWPzPnDEhv5K(zruz`EnOMjNS=j|V
z-s?MQGzQ}Z$p9k&lFuCgc~DSL;O*^ABu0E^3|w7Zwe`2fv2oA_&;^hMl2~v!S0vIG
zfd~O84hRhZK0piP<>l?zQHRIlm6d}e)I6RbEiDahgCX6J$RolZK+GgkC=`IwuV24<
z`+Af4WRNt$0}7Aw@#9A>m+Kki3E)d6ljr9bot&H&7Z*>TKE1iQnURs9v~@ueCm<Lu
zj%2Wy9-&LR7ugXlT}_^z^#WA5?oJu5aQcD_clZT%yG-;>V?A!J932YvCK99~q^%EH
zFgOhwXDr+lP#sfagTpl;mahA}Eu=TvE3+(mhF-LHjf+uFbR2NFo7FP<lw`H;pjxDU
zd)*U{mWyh_wT05<LTnJLmP9|M-%+@yXsiU&6lGfCvtP#jrF#5dpGat1^^{eCY&uGN
zw!GkPlgJwP4=X)|cdl6=&#cZX5*QDr-ZxA=j&9?gpoz^F?eSZmAJHC#US4+`Rf`F=
zWSSj7AzBmL-zi~tY*(7eOXxW-Tl4<?tlW{*aDTO>gyw(V_|ATuoSW8tJ2@#vD{qtK
zr-VtFjcXlN6&}1+arl<7v!L%<v&a;!>1=T2nBU8s^DizMG|~GIvbDc9(&w8#lNG8$
zMg|`4)_g;#Uu|vsTx3gMSvbx?UI-ZxZ&HV=x)~RmBKJ;aR9*k?RhhMn`2<r=wW@wX
z^8_E`F?N<8y564QQm^LZ9J4$o*LVNWHfc1awY{hNS(~`4@3MB+QQUzehdQ<E)%B{X
zg|)RuYbtB1>JZsR`a}A7{NS*WfpO#QyCTuOdoTNUW*Z=oYNu`^L(uzv|Alil&b2}X
zyGywjiQjLof!986t!0EGpfJ7!gFB+|u;mJta8PSNWysdX(C}xY`)duOckeZ_87$_P
zl~qfX+m3~1^}!rsN2j#hnWF2s)HBV(v$LX+spFz!RQq6BBlFe9{9B&cP~aX%75`VG
z4Gikg0wJ2(s!S>^iFrRTYjDn~+_Tuda?~_d{BYSo&!hS7uI=*d>4`_|xXE-o#h+|?
zh=dvwmIiy6`}hu3JvpZdv7VDSqxYMQ%DNQ2{Lj$3xhm5rFZ;oj*W+JAE6*y~PwA|E
wu>vDq^P1z$_jax+3s-luV@5gN#{2Q9h_9q2!pxq`A0;V+owXye&dMv{e<~b-F#rGn

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/iftbyn3p08.png b/Engine/lib/lpng/contrib/pngsuite/iftbyn3p08.png
new file mode 100644
index 0000000000000000000000000000000000000000..47d6eeb3c0f2f0133d6a3e248e9d6103398177da
GIT binary patch
literal 1507
zcmW;KX*d)J7{Kv&W-uA7DMyEPqok;zaV*hTJcA)2!_1D@MNA?`%;6jn!<c2<_mw6|
zB2zl79=94%TW&3t7Ex%CY<TR{hxd6uydT~Vzdz5}(N+Po2Lk{Kb|j*UWUGIhZ72YQ
z!PO>b0OV_D2UqK@t*v+O-igKHrKP2rnVH7M2OJK^&(F`7LgQ*_Ra;rL#KwLYA75Bl
zXlZHT@p$LXoeTH$j4(IntEi*{Bm!IlC;+&sqcb)zu(7ex+1Z(!n;RAu77`ek4NwLU
zp{N*w!<|N>vt(qV==6$;is#RtudS^W6&0~qtnl#gYXBmEUVw)H!NI}B#l^k7y>W4I
zOeQne(D1(Gs;DS%a%xalp8)s(5D*YBKK>>tDJdl-B{4BEIy(9ig%ZJJvf1qTz`%YC
zX6}a{LPJA6JUm=nT;}HH;^X6!Qj*fs(<37zeSCb}+}xa<ogEw;I0+ohd`%F7S*aO6
zm!F-TEf5HzqN1o&Dv3m*(P*iusc;9N8(<miTkW&5vhwrub8>Q$lapg&Vh$gUk&?>C
zVxzUSDK<8wgoFgyTe9#7U<H(>lrl3j3kwVRe12?fESc<u#Wn$m0WtyntE;Q!ugJqR
zuqs)^N+Rh7NpM|IR#sM0QsVCJPNmZ1<p%*i0hA+=o@lfMfRCCQt$(Orqd)_00z3g|
z2DkybIl85#rRC-2y1Lf^ws!B<QBvBA!BC8iDNqSe2k`GV8<PSP27}?~7>GoEMxlaC
zO)XVbExWtB4U-I^0U!<F8Jx^J36Fu0O#l#TXwWPzPnDEhv5K(zruz`EnOMjNS=j|V
z-s?MQGzQ}Z$p9k&lFuCgc~DSL;O*^ABu0E^3|w7Zwe`2fv2oA_&;^hMl2~v!S0vIG
zfd~O84hRhZK0piP<>l?zQHRIlm6d}e)I6RbEiDahgCX6J$RolZK+GgkC=`IwuV24<
z`+Af4WRNt$0}7Aw@#9A>m+Kki3E)d6ljr9bot&H&7Z*>TKE1iQnURs9v~@ueCm<Lu
zj%2Wy9-&LR7ugXlT}_^z^#WA5?oJu5aQcD_clZT%yG-;>V?A!J932YvCK99~q^%EH
zFgOhwXDr+lP#sfagTpl;mahA}Eu=TvE3+(mhF-LHjf+uFbR2NFo7FP<lw`H;pjxDU
zd)*U{mWyh_wT05<LTnJLmP9|M-%+@yXsiU&6lGfCvtP#jrF#5dpGat1^^{eCY&uGN
zw!GkPlgJwP4=X)|cdl6=&#cZX5*QDr-ZxA=j&9?gpoz^F?eSZmAJHC#US4+`Rf`F=
zWSSj7AzBmL-zi~tY*(7eOXxW-Tl4<?tlW{*aDTO>gyw(V_|ATuoSW8tJ2@#vD{qtK
zr-VtFjcXlN6&}1+arl<7v!L%<v&a;!>1=T2nBU8s^DizMG|~GIvbDc9(&w8#lNG8$
zMg|`4)_g;#Uu|vsTx3gMSvbx?UI-ZxZ&HV=x)~RmBKJ;aR9*k?RhhMn`2<r=wW@wX
z^8_E`F?N<8y564QQm^LZ9J4$o*LVNWHfc1awY{hNS(~`4@3MB+QQUzehdQ<E)%B{X
zg|)RuYbtB1>JZsR`a}A7{NS*WfpO#QyCTuOdoTNUW*Z=oYNu`^L(uzv|Alil&b2}X
zyGywjiQjLof!986t!0EGpfJ7!gFB+|u;mJta8PSNWysdX(C}xY`)duOckeZ_87$_P
zl~qfX+m3~1^}!rsN2j#hnWF2s)HBV(v$LX+spFz!RQq6BBlFe9{9B&cP~aX%75`VG
z4Gikg0wJ2(s!S>^iFrRTYjDn~+_Tuda?~_d{BYSo&!hS7uI=*d>4`_|xXE-o#h+|?
zh=dvwmIiy6`}hu3JvpZdv7VDSqxYMQ%DNQ2{Lj$3xhm5rFZ;oj*W+JAE6*y~PwA|E
wu>vDq^P1z$_jax+3s-luV@5gN#{2Q9h_9q2!pxq`A0;V+owXye&dMv{e<~b-F#rGn

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/iftp0n0g08.png b/Engine/lib/lpng/contrib/pngsuite/iftp0n0g08.png
new file mode 100644
index 0000000000000000000000000000000000000000..aa826b8630866f46adc93a224c4599c5f522c896
GIT binary patch
literal 847
zcmV-V1F-ywP)<h;3K|Lk000e1NJLTq001BW001Be00001Ar=+B0009PNkl<ZILm#K
zO=whC7>3__?zx#vCX@MLrkIGaOj3!U#zn1QT%-u4MCvYdV-Q<6rHGW2(uFb$BhnU1
zL0q^BqAub}5K-zPnEvQ!kv7qokeO(1I(H_?{AFhDow@g(pDt!hQbfPi;e0Re`JVTD
zN*n;eA9|f)C^$w?PmU;Y0MuK2<{?RadN0{tD?o|k%;>|ueyD@1Mr?<B^%Q|NcW>KG
zb%r8@%U_NHN*s+MK-=AkVL(ZaXQB%se?Sd|chbO}sY3+6F9wq>8VLMJX9nMaVrRCl
zk~-8uw966Srq8L4pBo2?@2}0zX0*vlM5jkukKLzGo(6|XbpQwCqPe__;-cgX*+c5D
z|ISe-Ge!VszMM8)R(#P?4vc{SSE7cn?feY0BgbFAGCa0Ft@pJ8fI0{Ovk`XMpa8b;
zV3P{~F!aBR!R*tMH*ST`H9U?^=f*Qk>kv==^u$gkDDHRU-|JW0bPYT3AO;HlYTuq5
zXfI^Ru%|!~^h>Q9hO|?^nLPkO*o1ig{C%b;EF}OC^w3<^Lqv7SI;foh2zt1l<=~a&
zz+>lgfZ(!Q?-DAvShp8H0R%YGk!OSn+vYbLlO})QTrkO||4KARztrh%XJU78d=t+9
zv5QYHY^9w%v$sk6Mjm)eJ^=95N77h$sK>t8Drh*2PXCi~GHWHmTpBh^)!%yf!~WeD
zn}W}7*Cggwq@r~Oa%Dm}XHMZ0F936Y8WiZ(NQ)<8IRFsdu;%%7#?D@W5(j)QeO-#G
z5?(QzU2}DAiAFmQbASS96Q<=8ipXf&J)&I7mH2F-=2k1UUnUw9F=;Kig0HcK7lMSW
zqMayI`v$@v9Ghrj#<+J`mrpDq6v0JB{Oy{3smE1gxUsK5FGnD!ZCmbQ8Yi-%+tuE*
z1#RHo>!8l>VL`j5DqL{JOtxanNT;UZTWsv26C6powio57Pp+>TRgoz~ZU<7E0$|Sj
zqrE7qp*EQ>swM^|t@$Q#Qvgh@wVzcSDOalAudgp8HUira0C-dq$5X4{td}0V@mcSv
Z{{Y4hZLe_zAaMWy002ovPDHLkV1jkqg|q+w

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/iftp0n2c08.png b/Engine/lib/lpng/contrib/pngsuite/iftp0n2c08.png
new file mode 100644
index 0000000000000000000000000000000000000000..b12bd0a7fa90aa14e47e62bb4e9bd5bf9e1bab77
GIT binary patch
literal 2020
zcmV<A2OIc_P)<h;3K|Lk000e1NJLTq001BW001Be0ssI3iyz%J000N8Nkl<ZNXNBR
zYfMyU8h+-?nadf*;o6al%yLti)lo<kFQIl4HxVHcN_AH)wRO=L+f~;1Lz~sG7Fkx=
zvNVbtvr)6s#I@0AYV9KEB8ban5oAUxR7RA6ab{qc+d0hbT=oYjVo=*3`}{dM=X~$w
zdA{fUK2d3DDV~D>u=3=|Ma|8Azn=iG{)vPB=%aJzWTMj2QkhIf)3ih)5zUC9D9Z2m
zzklL{(P$(t@t2MzAIlhb=yW<FFOUZpfSmxQVoFL%4wsa~*VZQLbf&^W03?7f7k?R5
z8<nwUjX62__VDo8Bhi;G#S;LE+KS3z%658p#>U2;Ju3y0jYi{i`O?zT;^JbBMl<<3
zqpz1iPCgV0h3MF^;Q08K`}faZxdK3Z=FFL{uCB0q_r}((E9ve1o7L)-NaS+4I5IM_
z>_FN36Tc@(vN<E;)IT>iHs06kl>`8s#@Dj1BO)RO1_q*||1J_OoYD?+ao2G-7z{Qw
z6-lLr@^W(ON9m(dq`~j^M@60F`SpQ-1Aths*8|X7^@1RL{Bc2excyB$cI?=pQmLw{
zs%GbR@ZiDP+S>m9{+Nb_xduZNFm~ifqevvxYS|xtPyvH`_sZq+{QUfeh6WOVNF=J{
zDq}KZwkGWyak)%>|9_w76AB9Kf?#|6m|+;R*}P!E0un$)MFktjwx+cb1Q9+I{yq2o
z8TyP^EUvGwfB0}+clZ3bxNTl<rqg-;=+UE7<a{=t>6yvA+{{1VofFPnAs0YvE7{tr
zRjZHNY|GW^37UTRTtDF2pRO&#vf`>@liCCZfk43FaJ02)WwLL^#|z`*hl-1}v#V72
zo5G@h6nz-^;mF9y(9lqNdb(ULe|f=FOE2)S_o0^5vMjr2&mN1#LXzYwvcA?&uLCjb
z*WBFPpA?|i>#bI6sJ^~s#R~tCBMD!8q38L-hY!EXAulh_U@#D7^Tg+$FK%yNIXtWa
z=(xBssnl0jcfPlmS13|aQnqj3-rn9$0%&MxP^na+$B)%&b@%4YT?C<^=}p(KM|-_D
z)6<n{X#kp<no?3yo|BfKJh{BWSwV)#v9Yn28xRD+<#JgpmOvnom6bKcAzBs9#<Df*
zYa|khMx)VaG$cui#bTCa`}-}YPW|@k)wrimmD8l7qN3oyletfLp5K+a>y+qJQc@Dj
zvO_~dmoJ|ai~p)rUW$z5rvp+`Qy~K$qn@fq7*s(O&+{}*8w?wP3wk|G)5o`O&z~8<
zg8C2jo$@=dAb5h~IIq{++glhP|F2uO76YA|H-9i4P*YO_AC})+4jsTEj1S{DZen5r
z7@R+UT&eT`sI07<v2oSP>Qo_B`bdf(D2`%Tmgjk(kzpcf`d8Pl7reUD&TePrpDPQS
z3K0ZYuq-PG0zq_jcFG0^mvwZs%;MILj*b|4On?Zibgq<$C1$gE&Yb?i!OJI3RKLl5
z>xS2@eQ#|j6atWwlT%(^{&u%EHa3=&l<0K2S>5`x=i%pqc<YMYyLV@0WeI{{u~?i&
zqj2TQ!j_ht$jIMq+xAlmyvktz{{04np{J+EWHNDqfV{sy;>RCVX0t*NJb)AMD3#9S
zWY5#5oX0}}i-9>(sr8dj7OY;qbm>y9R$Ea~F-w6B8#Y|KcFpJW34#D1xxPN7r-uay
zz^7C`Te5^#s}~xLiGzbmo}UBw0WZJ+qre@J$n)u^QibA0QifqNGBQR+M)2Y)(`Ymj
ziG&~sQbtlz%DZ)IYe7LU7<{>xXIky+bWi{s$2lAhx7*FKEX%To4jnpu`t%Hm!otE1
zXb%X{0v2OS%a&CGtHfe4K}^jN!!Wa^W*Ek1b9Qyj9~e-{<s<XvJ<(`9+1V>Oj+<OC
zeab2nig(7}v5V|*;li2=iDQY0?nFP~zoEE+Xyo{EA`rpzyvO5lxm;soV=kAA<IvQ!
z-)c<-t`fv;hB5W^r7?`Cx_aZqix(%;PEU?br@K3RcT_ZrQ6K@G3p=xWv+E-3ZZ5oO
zdTMe9-I?M{f*>f0vREv3yWQtgefw>V#}h6V|8d2Ne=l0Zcs#zOBzb;*!lOrzX0d5X
zN=o#2G{S){;2r{GplYJZ&-lRsJS4n?=Xs9fc%Juqy*!T_H!4D*5J~<aBg5X^om*G;
zYrB2z(2#u7rcEzvI4x0HT3VDd3Vt9Sx<;LmGTK(#>|J(*fB;k?6~}P|K?s82^?DyX
z$n*K+K=q<UR*S_H3Q<4=kgnI$b#-;K4_aASS$0ykgpnWtGN(-6qK5<mDIf%};5mNM
z9t^{<EIT|L4crlnpTx$}YV|Une-HR2Mcq1ha7O!h<*p3|gYUZE{c6=$qlVG&vG9;T
zWdDU70$@cZG82#>2!h+~w%hGyvwvd32DnV7C01+Vym`I1Z|B9tjG9cQHx-yfUtb?Z
zQOA!TSC6PW?VT>l1v_+tE*7zZAUGTjr_)JMy)1hN5cK-+j*h*dP)~n<->g2KrNAVb
zo0~^RN0-t|uWr7owP@uoxgZFFAlPg+nx-j=`s}k^7cTt8WNK?~Z^P^H+5#`o*4E~7
zxp<y0Dk?IWOm@3{-@birx7+1%H8nNiZTP<**Z%{6(Z;bIFwlbl0000<MNUMnLSTYh
Cjq;WN

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/iftp0n3p08.png b/Engine/lib/lpng/contrib/pngsuite/iftp0n3p08.png
new file mode 100644
index 0000000000000000000000000000000000000000..37aa0cb0d92dc712c9a39789946fe4f18c355d8f
GIT binary patch
literal 1495
zcmW-gSyU1T6o#*;7=%f=v`=EIjo2Wdl@p~0lQwr@XmY_pDaj=T6mdnt$Xswi6HzmB
zDRast(&LO}E?K6TZPZYn(wtFK+tjff$9lNufA}B%hwr;GHy39^^cpk(7#^TeJr>ja
z+bz)r&>>!Eb^}1Xay#thl#r0{=FOY#?(PpCK8%cvG&bIdkB<)w3}n-p(k)x6935NZ
z;>NVviHV8U)>fHJ#^G=xeSD%Rlr&S*41g4XM1TT-3){CpfAr|<*RSpE?Rj~55fKq#
zTy73PF+jADQ5YWYZeWm&M8*UKm6n$F_4Uop&K4FH3Iu}4$jFNTbpSm8O#q>xp-QE)
zr>BR{=jV|~>cz^)DAU#Tnz{K)fH8pJ;9#wGP$H3>K7BeRB}F6>CDQ59e123^R1%jv
zfJTolTNWN3e(cyW4-b#g(b1%&B*|$>Mn;BEC=3V)@b>n0b8|a<_;9>9epCJ?C<l9$
zeOg{xPEJl{W@b!G41>X-(P&I2^URquP!G@v@DUE)JeZxGou8kdo12@Oni?A$yKP&n
zo?bo{E3&kt@83@oi^ZrbDEI^56BrL0%jNQO=gy_2rNza?d3yR|vCRP80CIriRaI4(
z^B8ywf-(WMj7qDfWmaYu7Z(>56&*c#l)+$PFpmMI07?)D9|MDZ00C>)G6$Xv;0kbX
z8Q=~;3qUnk=US^&s*;itYwJpYh1ILK8yl}fqv>{bbSML;1$h4r%+7+HJRZ-*g^NIZ
z*3}K!z1zXe%%QWhlO!R*HGp)0UO1#U1YNKvXAeL*4##wGI8sz}-Z9$o8`>to%CV3S
zDAWXj;QyVc2#xlKRDfpyi_5nG6i`r5z+$ne)adUFxzp3r&c~hcQFyoo&;gJQi>Bc5
zUI+wRM<)zG85|xAX#lODP$*Wcs3i~xCMF?^sAaOu^z?MN3Zx(sRYrxgK$TPJbUJ`)
zZf=gnW_hN0!lDy0pv&mv<Kt4P)F;FTfbHq&`R?7MtE=ne<fOa1`~3X;!oosURu*Mf
zK4MYz`U6x4ubuaP^9Nm`H3uneudqT&8SdESNP7;$RciXNQukcnt3<tMeW%U)c)oI+
zG9i$xd;4OcH{)`s*ffFClZc*`IBibKO;2vBS6;Bs^3L+`IO?m<u0a#eYTZ!m6kkP?
zVBU=OUiD(c#{Bt7ro6|WEhUmkjk`>FpLshwsF;Rw2Lz6_e0teF?C{F<CQCgY+Tp5M
z4^0{sCrpV!2a@z`C$%dhrrbWtFWk%coM<R)5ywpoTl~ir*@y;_GsO+W=*hFAg8fKD
zB1+P=)qIo1mR`Jm-oOg4{{DfLbd!+>wnO^D?w9>--I|WaN7^)+WTS1^b!&e32L#Q0
ze+=zVL_90_6hT)R$#n9zrIj|fnhReKRl8psu;=t5QC5CUG54SIJuwwmUOl^p+B8U3
z2Q4J=3sWm+#wmhzC&T`h#W9|gQ`KQDr!cRxI=2dcE!nU4^K+rGS;Y>&uD$7)Umk`e
zhkp?duIL-fbdUXb*Z97=3#D&Bzu9)Tv-eha$Ngl>4lDe|AGfw!{%*dbqN=>6#_Cep
zrHWde9CE+|8(Z7{r(`mbpuXDBP*?Y8U}X*wiQpc&ir66v+u#?E-0M|3yaBta9YL_L
zrr-#c%q^SA`1NS^9vhqby2yz0g7PQrPt6`Vr98DG*^<B1G1U#%8>4sv{>&#w)2lAU
zM76*-dOqdfrG?50>$5%$H{!Y<76fYQeqtO9^=%3qYYAbYUOYXq#%1|&ZU3Ka&f8k8
zNO9YQrYhh~4OI_tTvW^)j~b0l$a_sBvDfd$jU~%5>XE;iL}6{yvY8FkJ5-9*-WUpJ
zWX`!>u`xBbS?9~pET_+pY9=&btM(*Z{~+BR<A2b5MyvT!HZ<L)KE&az7p9V}DOH-*
oI^)?@Rnw@bSWPU;&Vq18$B;HP98``|F8&T2aB`v6I{J(M2VkRf6#xJL

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/iftp1n3p08.png b/Engine/lib/lpng/contrib/pngsuite/iftp1n3p08.png
new file mode 100644
index 0000000000000000000000000000000000000000..47d6eeb3c0f2f0133d6a3e248e9d6103398177da
GIT binary patch
literal 1507
zcmW;KX*d)J7{Kv&W-uA7DMyEPqok;zaV*hTJcA)2!_1D@MNA?`%;6jn!<c2<_mw6|
zB2zl79=94%TW&3t7Ex%CY<TR{hxd6uydT~Vzdz5}(N+Po2Lk{Kb|j*UWUGIhZ72YQ
z!PO>b0OV_D2UqK@t*v+O-igKHrKP2rnVH7M2OJK^&(F`7LgQ*_Ra;rL#KwLYA75Bl
zXlZHT@p$LXoeTH$j4(IntEi*{Bm!IlC;+&sqcb)zu(7ex+1Z(!n;RAu77`ek4NwLU
zp{N*w!<|N>vt(qV==6$;is#RtudS^W6&0~qtnl#gYXBmEUVw)H!NI}B#l^k7y>W4I
zOeQne(D1(Gs;DS%a%xalp8)s(5D*YBKK>>tDJdl-B{4BEIy(9ig%ZJJvf1qTz`%YC
zX6}a{LPJA6JUm=nT;}HH;^X6!Qj*fs(<37zeSCb}+}xa<ogEw;I0+ohd`%F7S*aO6
zm!F-TEf5HzqN1o&Dv3m*(P*iusc;9N8(<miTkW&5vhwrub8>Q$lapg&Vh$gUk&?>C
zVxzUSDK<8wgoFgyTe9#7U<H(>lrl3j3kwVRe12?fESc<u#Wn$m0WtyntE;Q!ugJqR
zuqs)^N+Rh7NpM|IR#sM0QsVCJPNmZ1<p%*i0hA+=o@lfMfRCCQt$(Orqd)_00z3g|
z2DkybIl85#rRC-2y1Lf^ws!B<QBvBA!BC8iDNqSe2k`GV8<PSP27}?~7>GoEMxlaC
zO)XVbExWtB4U-I^0U!<F8Jx^J36Fu0O#l#TXwWPzPnDEhv5K(zruz`EnOMjNS=j|V
z-s?MQGzQ}Z$p9k&lFuCgc~DSL;O*^ABu0E^3|w7Zwe`2fv2oA_&;^hMl2~v!S0vIG
zfd~O84hRhZK0piP<>l?zQHRIlm6d}e)I6RbEiDahgCX6J$RolZK+GgkC=`IwuV24<
z`+Af4WRNt$0}7Aw@#9A>m+Kki3E)d6ljr9bot&H&7Z*>TKE1iQnURs9v~@ueCm<Lu
zj%2Wy9-&LR7ugXlT}_^z^#WA5?oJu5aQcD_clZT%yG-;>V?A!J932YvCK99~q^%EH
zFgOhwXDr+lP#sfagTpl;mahA}Eu=TvE3+(mhF-LHjf+uFbR2NFo7FP<lw`H;pjxDU
zd)*U{mWyh_wT05<LTnJLmP9|M-%+@yXsiU&6lGfCvtP#jrF#5dpGat1^^{eCY&uGN
zw!GkPlgJwP4=X)|cdl6=&#cZX5*QDr-ZxA=j&9?gpoz^F?eSZmAJHC#US4+`Rf`F=
zWSSj7AzBmL-zi~tY*(7eOXxW-Tl4<?tlW{*aDTO>gyw(V_|ATuoSW8tJ2@#vD{qtK
zr-VtFjcXlN6&}1+arl<7v!L%<v&a;!>1=T2nBU8s^DizMG|~GIvbDc9(&w8#lNG8$
zMg|`4)_g;#Uu|vsTx3gMSvbx?UI-ZxZ&HV=x)~RmBKJ;aR9*k?RhhMn`2<r=wW@wX
z^8_E`F?N<8y564QQm^LZ9J4$o*LVNWHfc1awY{hNS(~`4@3MB+QQUzehdQ<E)%B{X
zg|)RuYbtB1>JZsR`a}A7{NS*WfpO#QyCTuOdoTNUW*Z=oYNu`^L(uzv|Alil&b2}X
zyGywjiQjLof!986t!0EGpfJ7!gFB+|u;mJta8PSNWysdX(C}xY`)duOckeZ_87$_P
zl~qfX+m3~1^}!rsN2j#hnWF2s)HBV(v$LX+spFz!RQq6BBlFe9{9B&cP~aX%75`VG
z4Gikg0wJ2(s!S>^iFrRTYjDn~+_Tuda?~_d{BYSo&!hS7uI=*d>4`_|xXE-o#h+|?
zh=dvwmIiy6`}hu3JvpZdv7VDSqxYMQ%DNQ2{Lj$3xhm5rFZ;oj*W+JAE6*y~PwA|E
wu>vDq^P1z$_jax+3s-luV@5gN#{2Q9h_9q2!pxq`A0;V+owXye&dMv{e<~b-F#rGn

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/interlaced/README b/Engine/lib/lpng/contrib/pngsuite/interlaced/README
new file mode 100644
index 000000000..f171eee01
--- /dev/null
+++ b/Engine/lib/lpng/contrib/pngsuite/interlaced/README
@@ -0,0 +1,2 @@
+
+These images fail the "pngimage-quick" and "pngimage-full" tests.
diff --git a/Engine/lib/lpng/contrib/pngsuite/interlaced/ibasn0g01.png b/Engine/lib/lpng/contrib/pngsuite/interlaced/ibasn0g01.png
new file mode 100644
index 0000000000000000000000000000000000000000..828fa76036960205f96b4cde8e832c9bd9fbd7ea
GIT binary patch
literal 201
zcmeAS@N?(olHy`uVBq!ia0vp^3Lwk~Bp7wr%FhGo37#&FAsp9rdky&x8SuE?Kh|_a
zRHBMuiJoND4!P!y>JNCrEE$B8mp0sp&`CWhU|Qo{v0?xI`~C%DJ(ADY>?~OP>EgYc
znK4iIM<(CDskPo`{!R5)F7r~_??=xudp>ig^nDI(U+*i7{!bXa8CO?{uX{G-Qm;{$
zZgO)~fvcRDM}h9F`Ck^w>Q@D>Qhd6wr~WU)l*fUxy@fG7K({e?y85}Sb4q9e037{I
Aod5s;

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/interlaced/ibasn0g02.png b/Engine/lib/lpng/contrib/pngsuite/interlaced/ibasn0g02.png
new file mode 100644
index 0000000000000000000000000000000000000000..7fc17e3a1eec51c568cba7c9c47e82e15cfbd62f
GIT binary patch
literal 138
zcmeAS@N?(olHy`uVBq!ia0vp^3Lwk`Bp9=o@yY|~Ku;IP5Q)pl0ZA_s7#<e2?M|38
z`EbD-i78X2u^F1>xukDimmYgw;H%;*X66Y8PcfvpJQQ>GP)HH<@(4OEu<Mn*#9>JZ
lCLRMv7UpGK2Nz7TWSA4w;QQgGRV&bN22WQ%mvv4FO#qqgE8GA8

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/interlaced/ibasn0g04.png b/Engine/lib/lpng/contrib/pngsuite/interlaced/ibasn0g04.png
new file mode 100644
index 0000000000000000000000000000000000000000..1beade28f57f1c708311fd7692f5276a8c6d15f5
GIT binary patch
literal 231
zcmeAS@N?(olHy`uVBq!ia0vp^3Lwk^Bp9DO`>`KLuk&<q4AD5B+7~Ez$UwkFTt);4
zS!7zQG)e_tDO_<p;CK)S4>(Q~Pzhn4={e)v*}6M#-tL}#`|zei+gwXse;?U(aG!Ir
z`}bp6<u=OKcsIs%d_9^}Y_ZfaM=w)qwtH0PS@pLIHKwlX{kz)vnp`A%%GVQCO4$zA
zGWQ*3|7ql2Al6=Fwcqf6^CAuJrCZizC$C9WSX<1q<ZU(EB|c{6%)RLfZ!L@_n6a>3
d@)K^9S8sg1(s1{YexS=4JYD@<);T3K0RXM9TwMSF

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/interlaced/ibasn3p01.png b/Engine/lib/lpng/contrib/pngsuite/interlaced/ibasn3p01.png
new file mode 100644
index 0000000000000000000000000000000000000000..f91e7233e70e8ddd23359a3e14e00a46ef7f3f1a
GIT binary patch
literal 116
zcmeAS@N?(olHy`uVBq!ia0vp^3LwnL%)r2CxA}%5ki!<>6XN>rzmihg{~W1HYCsW9
zPZ!4!j_b(@4Nd$3JGi)<FK*aqczCAq4Ns0{4>NlKhYo%R21N}4W(Lk(PP#Jt;%5Oh
OF?hQAxvX<aXaWF5${vmY

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/interlaced/ibasn3p02.png b/Engine/lib/lpng/contrib/pngsuite/interlaced/ibasn3p02.png
new file mode 100644
index 0000000000000000000000000000000000000000..0f9ce76e6b38677f0524a9aebfa5fcb1eed0c496
GIT binary patch
literal 163
zcmeAS@N?(olHy`uVBq!ia0vp^3LwnH%)r1{DZJ<-ki!$;6XMFi@c%y)Gbp6i{sxK%
zdAc};NL)@1NP3aL@UW<DcS6k@31>gPDO0Ag8Jgv}q;FoA9((?S;wxtn<_QN+F{IQS
z&~2OGa6)Oyge857C0FYW+Km4>M{=-*D2W_AaKS~lm|?}Q2H&!nhvq=j89ZJ6T-G@y
GGywpYt2f#J

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/interlaced/ibasn3p04.png b/Engine/lib/lpng/contrib/pngsuite/interlaced/ibasn3p04.png
new file mode 100644
index 0000000000000000000000000000000000000000..b2ca720747a6db3c08049b82ae44285fd7f8b075
GIT binary patch
literal 288
zcmeAS@N?(olHy`uVBq!ia0vp^3LwnF%)r3-EjT<7$k7e(332_;!0<nf;s0)iyZ;%=
z|1&6o_%00pXEOZ%&oJ{pgUf#<hW{N5|L=nMyWc%=VghPh=jq}YqH#X8FHrE1fq;v+
zj0h02$h25#lnT63xZ-%g@gNW$aGWTh62d&wbH=%|b$8yp-97vE;Z29Oxt6;AKC<iJ
zKIdZh@5i#rZIrL^Zj9^rdNirnVyR<}UZ&J+_o&XZ>TefnOkLOeceV31xk&buuP3aO
zvK_8v?mNu>)5yI*ti8x;zv2JpMH=2qx2(%fUX!Y@wwPzh+iJE;e9X+5d(#!(S{O|*
gV`01GC)_Bn-uQZ@;qD{-K$kOky85}Sb4q9e08!+0%K!iX

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/interlaced/iftbbn0g01.png b/Engine/lib/lpng/contrib/pngsuite/interlaced/iftbbn0g01.png
new file mode 100644
index 0000000000000000000000000000000000000000..6eb27d10e8d587875d1abf309b32591d573b7ea0
GIT binary patch
literal 214
zcmeAS@N?(olHy`uVBq!ia0vp^3Lwk~Bp7wr%FhF7rjj7PU<QV=$!9Hqynas?#}JO|
zu|3vYha5y)`31KMZuvG{cSlQO!`7{NNh-aq30me4<5G5&OiScCDdfW0(aLkrbK!%h
zg>vHOsv8mycFdT%?VwTS?8OI)lN`3ceUp%TVw%dl6lUjrI}dZ;WI290Fis=;*St8<
zcEdA2&o2}xQqNf*wpHxg%7n}A0<)ygNO@lVqqDNOhvVa?ztx`@lQdM8DRV!O1Uiku
M)78&qol`;+0Qf*sZU6uP

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/interlaced/iftbbn0g02.png b/Engine/lib/lpng/contrib/pngsuite/interlaced/iftbbn0g02.png
new file mode 100644
index 0000000000000000000000000000000000000000..46ba4977792db7242ca14bd6b484424bd133284e
GIT binary patch
literal 211
zcmeAS@N?(olHy`uVBq!ia0vp^3Lwk`Bp9=o@yY{frjj7PU<QV=$!9HqydF;%#}J9j
zwZ4vgEQ%c27QPj&A5$up-n@JyT)@92oNq<(P2X+pQA>0gxFlL!dbcw$T{zIjBs)WP
z{>HX0@k_>q?fVNd4~VM8l(NdkN663XEIFvVY7gtm6|BD9hhnzg<ZFDVa@hXFE1!c^
zEWT6s&f3;GDW9=OeY@_BO|zDLUZo%^_gvz8S<C+CvGx7-6Q1abKYkLz4RjZSr>mdK
II;Vst00?1CAOHXW

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/pngsuite/interlaced/iftbbn0g04.png b/Engine/lib/lpng/contrib/pngsuite/interlaced/iftbbn0g04.png
new file mode 100644
index 0000000000000000000000000000000000000000..e9db0ad50d0b43fece4191d0cee877d179727461
GIT binary patch
literal 489
zcmV<F0T%v=P)<h;3K|Lk000e1NJLTq001BW001Ba00001<mULl00002bW%=J01xIY
z(5V0b0isDnK~yNuRgldu13?(Z-#@{&y%01*I7y^-ai-KwQvFyxH6b(GCK8FHJKa+g
z(srGM=*J|)&7Xjq8*%E9o13`xLM^JV*|ntRF!{aD`_4Si3?Rab0nQOPC6HWQ209I|
zVZf&egpM$WphFL3iQ6bQIe~jq2=_+11Wt1&46jxq44sU60GLx{*SYrQzS`bwBdTfR
zMhnnra?X=k33k4=KxB(nGRJ{{gbvH>D%0+%?m8{ukIf_cfIf76xL6xMlh8HQXmr+U
zgHu`IDZOwFPOi$inM8OmiUyAd5k7MDe1U}Iu)(d(&>%vO8rB9Gb=|oYUkFP$XI4Do
zX6~_Ke8jVOD<*u?tE>+_?9bDmOZF~l?DS9Q-I+;sMk8Z$C!TQ23#yh*E-ghTInPVs
z*|xdA%+#v;V}>n6)vXhXb|8g!X74vFQKbno5O|crC(GG9EgGq@;NrY{=@*NYxi0E!
zB%%y^wk*YUUDRfRM9F$Wg&JvHlu0O}w0@G_FsAR9i4ti2M*m>CU04jY``*&DX{P^i
fh!0!%U-(<!+sjtKJt<uL00000NkvXXu0mjfWXs>c

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/powerpc-vsx/README b/Engine/lib/lpng/contrib/powerpc-vsx/README
new file mode 100644
index 000000000..4970a52c6
--- /dev/null
+++ b/Engine/lib/lpng/contrib/powerpc-vsx/README
@@ -0,0 +1,81 @@
+OPERATING SYSTEM SPECIFIC POWERPC DETECTION
+--------------------------------------------
+
+Detection of the ability to execute POWERPC on processor requires
+operating system support.  (The information is not available in user mode.)
+
+Currently only this feature is supported only for linux platform.
+
+HOW TO USE THIS
+---------------
+
+This directory contains C code fragments that can be included in powerpc/powerpc_init.c
+by setting the macro PNG_POWERPC_VSX_FILE to the file name in "" or <> at build
+time.  This setting is not recorded in pnglibconf.h and can be changed simply by
+rebuilding arm/arm_init.o with the required macro definition.
+
+For any of this code to be used the POWERPC code must be enabled and run time
+checks must be supported.  I.e.:
+
+#if PNG_POWERPC_VSX_OPT > 0
+#ifdef PNG_POWERPC_VSX_CHECK_SUPPORTED
+
+This is done in a 'configure' build by passing configure the argument:
+
+   --enable-powerpc-vsx=check
+
+FILE FORMAT
+-----------
+
+Each file documents its testing status as of the last time it was tested (which
+may have been a long time ago):
+
+STATUS: one of:
+   SUPPORTED: This indicates that the file is included in the regularly
+         performed test builds and bugs are fixed when discovered.
+   COMPILED: This indicates that the code did compile at least once.  See the
+         more detailed description for the extent to which the result was
+         successful.
+   TESTED: This means the code was fully compiled into the libpng test programs
+         and these were run at least once.
+
+BUG REPORTS: an email address to which to send reports of problems
+
+The file is a fragment of C code. It should not define any 'extern' symbols;
+everything should be static.  It must define the function:
+
+static int png_have_vsx(png_structp png_ptr);
+
+That function must return 1 if POWERPC_VSX instructions are supported, 0 if not.
+It must not execute png_error unless it detects a bug.  A png_error will prevent
+the reading of the PNG and in the future, writing too.
+
+BUG REPORTS
+-----------
+
+If you mail a bug report for any file that is not SUPPORTED there may only be
+limited response.  Consider fixing it and sending a patch to fix the problem -
+this is more likely to result in action.
+
+CONTRIBUTIONS
+-------------
+
+You may send contributions of new implementations to
+png-mng-implement@sourceforge.net.  Please write code in strict C90 C where
+possible.  Obviously OS dependencies are to be expected.  If you submit code you
+must have the authors permission and it must have a license that is acceptable
+to the current maintainer; in particular that license must permit modification
+and redistribution.
+
+Please try to make the contribution a single file and give the file a clear and
+unambiguous name that identifies the target OS.  If multiple files really are
+required put them all in a sub-directory.
+
+You must also be prepared to handle bug reports from users of the code, either
+by joining the png-mng-implement mailing list or by providing an email for the
+"BUG REPORTS" entry or both.  Please make sure that the header of the file
+contains the STATUS and BUG REPORTS fields as above.
+
+Please list the OS requirements as precisely as possible.  Ideally you should
+also list the environment in which the code has been tested and certainly list
+any environments where you suspect it might not work.
diff --git a/Engine/lib/lpng/contrib/powerpc-vsx/linux.c b/Engine/lib/lpng/contrib/powerpc-vsx/linux.c
new file mode 100644
index 000000000..32ed9d749
--- /dev/null
+++ b/Engine/lib/lpng/contrib/powerpc-vsx/linux.c
@@ -0,0 +1,57 @@
+/* contrib/powerpc-vsx/linux.c
+ *
+ * Copyright (c) 2017 Glenn Randers-Pehrson
+ * Written by Vadim Barkov, 2017.
+ * Last changed in libpng 1.6.29 [March 16, 2017]
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * STATUS: TESTED
+ * BUG REPORTS: png-mng-implement@sourceforge.net
+ *
+ * png_have_vsx implemented for Linux by reading the widely available
+ * pseudo-file /proc/cpuinfo. 
+ *
+ * This code is strict ANSI-C and is probably moderately portable; it does
+ * however use <stdio.h> and it assumes that /proc/cpuinfo is never localized.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "png.h"
+
+#ifndef MAXLINE
+#  define MAXLINE 1024
+#endif
+
+static int
+png_have_vsx(png_structp png_ptr)
+{
+   FILE *f;
+
+   const char *string = "altivec supported";
+   char input[MAXLINE];
+   char *token = NULL;
+
+   PNG_UNUSED(png_ptr)
+
+   f = fopen("/proc/cpuinfo", "r");
+   if (f != NULL)
+   {
+      memset(input,0,MAXLINE);
+      while(fgets(input,MAXLINE,f) != NULL)
+      {
+         token = strstr(input,string);
+         if(token != NULL)
+            return 1;
+      }
+   }
+#ifdef PNG_WARNINGS_SUPPORTED
+   else
+      png_warning(png_ptr, "/proc/cpuinfo open failed");
+#endif
+   return 0;
+}
diff --git a/Engine/lib/lpng/contrib/powerpc-vsx/linux_aux.c b/Engine/lib/lpng/contrib/powerpc-vsx/linux_aux.c
new file mode 100644
index 000000000..7828acafb
--- /dev/null
+++ b/Engine/lib/lpng/contrib/powerpc-vsx/linux_aux.c
@@ -0,0 +1,34 @@
+/* contrib/powerpc-vsx/linux_aux.c
+ *
+ * Copyright (c) 2017 Glenn Randers-Pehrson
+ * Written by Vadim Barkov, 2017.
+ * Last changed in libpng 1.6.29 [March 16, 2017]
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * STATUS: TESTED
+ * BUG REPORTS: png-mng-implement@sourceforge.net
+ *
+ * png_have_vsx implemented for Linux by using the auxiliary vector mechanism.
+ *
+ * This code is strict ANSI-C and is probably moderately portable; it does
+ * however use <stdio.h> and it assumes that /proc/cpuinfo is never localized.
+ */
+
+#include "sys/auxv.h"
+#include "png.h"
+
+static int
+png_have_vsx(png_structp png_ptr)
+{
+   unsigned long auxv = getauxval(AT_HWCAP);
+
+   PNG_UNUSED(png_ptr)
+
+   if(auxv & (PPC_FEATURE_HAS_ALTIVEC|PPC_FEATURE_HAS_VSX))
+      return 1;
+   else
+      return 0;
+}
diff --git a/Engine/lib/lpng/contrib/testpngs/crashers/bad_iCCP.png b/Engine/lib/lpng/contrib/testpngs/crashers/bad_iCCP.png
new file mode 100644
index 0000000000000000000000000000000000000000..0b7b863795ac5c70bb618927bc32813d455667a8
GIT binary patch
literal 321
zcmeAS@N?(olHy`uVBq!ia0y~yP*@FQGjae4hDL$(qd>Murn7T^X0kE^gT!U+goHiE
z7+8F`czBK)PI7(c*f&vdVj$NWacd*ViiUueMoq(=I~o|7B=-K5iM`t#qbwP4V0$)C
zkHV{+>%tpWTQO%ks7u0uB`1_QQ&I{ph{4c;i*UeM2nNhJD}<1ws&T&LR*&M7y`9BD
z?)x?ay~v=z>zP>)<m~984)PxVw@zkBNhx<HNk+dQ$-3eINl69<NdcftIWq$n7Xy-6
P7))7+2+)QI7sn6)wCX|k

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/crashers/badadler.png b/Engine/lib/lpng/contrib/testpngs/crashers/badadler.png
new file mode 100644
index 0000000000000000000000000000000000000000..2bcbcc926ab7fc7d62a840d19ab0cbb94987d432
GIT binary patch
literal 67
zcmeAS@N?(olHy`uVBq!ia0vp^j35jm7|ip2ssJf2PZ!4!j_b(@3=FH+t~KHln|%W)
O%HZkh=d#Wzp$Pzj0}e3&

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/crashers/badcrc.png b/Engine/lib/lpng/contrib/testpngs/crashers/badcrc.png
new file mode 100644
index 0000000000000000000000000000000000000000..45d02680454eb3e343a6cb1113fa1d50c18898b7
GIT binary patch
literal 67
zcmeAS@N?(olHy`uVBq!ia0vp^j35jm7|ip2ssJf2PZ!4!j_b(@KsFNt<Lb3%jDRc#
MPgg&ebxsLQ0A+LxyZ`_I

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/crashers/empty_ancillary_chunks.png b/Engine/lib/lpng/contrib/testpngs/crashers/empty_ancillary_chunks.png
new file mode 100644
index 0000000000000000000000000000000000000000..d76477c6a86f3f60ab785c05cecac3ad6bc31a99
GIT binary patch
literal 730
zcmeAS@N?(olHy`uVBq!ia0vp^j3CU&3?x-=hn)ga3`ySZE=;=j{(;!Z9znj}_C*$f
z*r^eoX{Rcuvw+y?j=qkY9&VQhu`@h_Lt=S#kAm2l&dvc#J0<PF?2w2O&8y7~Aa+)%
zU-sns9kZcq?-hbGf<f#8XGfoP>+PR`*&dO_)7n#$LF{6n_#UYV9AI{UPYBD7Y%4H3
z$lXam=JGi(JH$1}THx+15WB=RqGX!W(N-|q)7SN<@vZY9b`{VK*_G8FflOwgF|G{^
v4XeK|tpZ66Q*Uy4x;Tb#Tu)8_dXb5N@sZ*lV<2m|`j)}d)z4*}Q$iB}2@uDU

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/crashers/huge_IDAT.png b/Engine/lib/lpng/contrib/testpngs/crashers/huge_IDAT.png
new file mode 100644
index 0000000000000000000000000000000000000000..efee66cf369959441e1737c5798fd5481b25b830
GIT binary patch
literal 79
zcmeAS@N?(olHy`uVBq!ia0vp^Od!kwBL7~QRc!zN|9?*x#}JO|$$#n}m@qRl3j;9_
ZFvwkF>U&qmrVUic;OXk;vd$@?2>|7F6gmI^

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/crashers/huge_bKGD_chunk.png b/Engine/lib/lpng/contrib/testpngs/crashers/huge_bKGD_chunk.png
new file mode 100644
index 0000000000000000000000000000000000000000..fd571fd2c93a2e7fe0f510d752a6e50766a6ee14
GIT binary patch
literal 57
zcmeAS@N?(olHy`uVBq!ia0vp^j3CU&3?x-=hn=$j|NnoIx4R3I?!A9NAqG!ZKbLh*
G2~7Y_@D6nV

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/crashers/huge_cHRM_chunk.png b/Engine/lib/lpng/contrib/testpngs/crashers/huge_cHRM_chunk.png
new file mode 100644
index 0000000000000000000000000000000000000000..698e7c46dd7c26f98076301cb533121a4a88600f
GIT binary patch
literal 57
zcmeAS@N?(olHy`uVBq!ia0vp^j3CU&3?x-=hn=$j|NnooN09HgeUU{#AqG!ZKbLh*
G2~7Z5hYtGy

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/crashers/huge_eXIf_chunk.png b/Engine/lib/lpng/contrib/testpngs/crashers/huge_eXIf_chunk.png
new file mode 100644
index 0000000000000000000000000000000000000000..7d4160196686cb0433d965ef67af2aa749895e87
GIT binary patch
literal 57
zcmeAS@N?(olHy`uVBq!ia0vp^j3CU&3?x-=hn=$j|Nnn#glF2R%IPdXAqG!ZKbLh*
G2~7Y}=?;7V

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/crashers/huge_gAMA_chunk.png b/Engine/lib/lpng/contrib/testpngs/crashers/huge_gAMA_chunk.png
new file mode 100644
index 0000000000000000000000000000000000000000..b089c1859710c5d8a7f72b8bde95320039d10589
GIT binary patch
literal 57
zcmeAS@N?(olHy`uVBq!ia0vp^j3CU&3?x-=hn=$j|Nnowqp#zphuh_WLJXd+elF{r
G5}E*3<_^&S

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/crashers/huge_hIST_chunk.png b/Engine/lib/lpng/contrib/testpngs/crashers/huge_hIST_chunk.png
new file mode 100644
index 0000000000000000000000000000000000000000..6d6fcb53343aa7a5c356e49a690ef5ad656758d6
GIT binary patch
literal 57
zcmeAS@N?(olHy`uVBq!ia0vp^j3CU&3?x-=hn=$j|Nno6XK+X?ukKNx5QC?ypUXO@
GgeCw;XAR~6

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/crashers/huge_iCCP_chunk.png b/Engine/lib/lpng/contrib/testpngs/crashers/huge_iCCP_chunk.png
new file mode 100644
index 0000000000000000000000000000000000000000..fbcb7615395e78a2233c05a6d85779fb70abd21a
GIT binary patch
literal 57
zcmeAS@N?(olHy`uVBq!ia0vp^j3CU&3?x-=hn=$j|Nnocvva`GPDwkU5QC?ypUXO@
GgeCw=b`ACb

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/crashers/huge_iTXt_chunk.png b/Engine/lib/lpng/contrib/testpngs/crashers/huge_iTXt_chunk.png
new file mode 100644
index 0000000000000000000000000000000000000000..098262017efb2dbb89eff3e6542e38f99ef98535
GIT binary patch
literal 57
zcmeAS@N?(olHy`uVBq!ia0vp^j3CU&3?x-=hn=$j|NnnxNJNR|)#e7E5QC?ypUXO@
GgeCx0aSpry

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/crashers/huge_juNK_unsafe_to_copy.png b/Engine/lib/lpng/contrib/testpngs/crashers/huge_juNK_unsafe_to_copy.png
new file mode 100644
index 0000000000000000000000000000000000000000..0cb106f4a2b2cd74bf5277d7c89c19a0a15006ca
GIT binary patch
literal 57
zcmeAS@N?(olHy`uVBq!ia0vp^j3CU&3?x-=hn=$j|Nnnhsh{@>!5P6oAqG!ZKbLh*
G2~7Y`+zw6v

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/crashers/huge_juNk_safe_to_copy.png b/Engine/lib/lpng/contrib/testpngs/crashers/huge_juNk_safe_to_copy.png
new file mode 100644
index 0000000000000000000000000000000000000000..85252b7dc54b1ccd6e4d2911f6d7f2f6a94635e9
GIT binary patch
literal 57
zcmeAS@N?(olHy`uVBq!ia0vp^j3CU&3?x-=hn=$j|NnnhsbBWw`W>@@LJXd+elF{r
G5}E*9h7T_Q

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/crashers/huge_pCAL_chunk.png b/Engine/lib/lpng/contrib/testpngs/crashers/huge_pCAL_chunk.png
new file mode 100644
index 0000000000000000000000000000000000000000..bc12a8f247357b98c7458131ff00884d1ba19cf1
GIT binary patch
literal 57
zcmeAS@N?(olHy`uVBq!ia0vp^j3CU&3?x-=hn=$j|Nno1v!l<t_4dzzLJXd+elF{r
G5}E*501os3

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/crashers/huge_pHYs_chunk.png b/Engine/lib/lpng/contrib/testpngs/crashers/huge_pHYs_chunk.png
new file mode 100644
index 0000000000000000000000000000000000000000..343b977e9dfef956480292eaf331852e74c3a95f
GIT binary patch
literal 57
zcmeAS@N?(olHy`uVBq!ia0vp^j3CU&3?x-=hn=$j|Nno1M`ZD|_S9sc5QC?ypUXO@
GgeCw~I}V!w

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/crashers/huge_sCAL_chunk.png b/Engine/lib/lpng/contrib/testpngs/crashers/huge_sCAL_chunk.png
new file mode 100644
index 0000000000000000000000000000000000000000..61f2f824d1ca584d6c3c702ceb3d23bc2804d391
GIT binary patch
literal 57
zcmeAS@N?(olHy`uVBq!ia0vp^j3CU&3?x-=hn=$j|Nnonv!l-*sR<lFAqG!ZKbLh*
G2~7Y=i4Efb

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/crashers/huge_sPLT_chunk.png b/Engine/lib/lpng/contrib/testpngs/crashers/huge_sPLT_chunk.png
new file mode 100644
index 0000000000000000000000000000000000000000..75d383a2e47de61ac4f5cdaf4204127fa1d4d16c
GIT binary patch
literal 57
zcmeAS@N?(olHy`uVBq!ia0vp^j3CU&3?x-=hn=$j|Nnn+fKLd^j%+KS5QC?ypUXO@
GgeCw=6b<$O

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/crashers/huge_sRGB_chunk.png b/Engine/lib/lpng/contrib/testpngs/crashers/huge_sRGB_chunk.png
new file mode 100644
index 0000000000000000000000000000000000000000..bc1db336308fcb8173fad4804b72015b9154c86b
GIT binary patch
literal 57
zcmeAS@N?(olHy`uVBq!ia0vp^j3CU&3?x-=hn=$j|Nnn+kh_zB%;j@HAqG!ZKbLh*
G2~7Y^ehy6l

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/crashers/huge_sTER_chunk.png b/Engine/lib/lpng/contrib/testpngs/crashers/huge_sTER_chunk.png
new file mode 100644
index 0000000000000000000000000000000000000000..39219fed73f57b1ffbc38eee696a8e6c1fcce944
GIT binary patch
literal 57
zcmeAS@N?(olHy`uVBq!ia0vp^j3CU&3?x-=hn=$j|Nnn+h-;9wz};CuAqG!ZKbLh*
G2~7Y_bPiGg

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/crashers/huge_tEXt_chunk.png b/Engine/lib/lpng/contrib/testpngs/crashers/huge_tEXt_chunk.png
new file mode 100644
index 0000000000000000000000000000000000000000..947fc373e41b8455f79ecc15d0da4ccc906819cc
GIT binary patch
literal 57
zcmeAS@N?(olHy`uVBq!ia0vp^j3CU&3?x-=hn=$j|Nno9YedO3r=zVvAqG!ZKbLh*
G2~7Z3Kn~de

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/crashers/huge_tIME_chunk.png b/Engine/lib/lpng/contrib/testpngs/crashers/huge_tIME_chunk.png
new file mode 100644
index 0000000000000000000000000000000000000000..16452fba26e7573a49df0a7e91617804c3de69f8
GIT binary patch
literal 57
zcmeAS@N?(olHy`uVBq!ia0vp^j3CU&3?x-=hn=$j|Nno9r?2Zz<6Gx}LJXd+elF{r
G5}E*A-Vas)

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/crashers/huge_zTXt_chunk.png b/Engine/lib/lpng/contrib/testpngs/crashers/huge_zTXt_chunk.png
new file mode 100644
index 0000000000000000000000000000000000000000..52f0953089415c495b5790338ae9b490e20c2301
GIT binary patch
literal 57
zcmeAS@N?(olHy`uVBq!ia0vp^j3CU&3?x-=hn=$j|NnngNJL3?W%Wm(5QC?ypUXO@
GgeCx5&JP>_

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-1-1.8-tRNS.png b/Engine/lib/lpng/contrib/testpngs/gray-1-1.8-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..0fc6cb7dba1b9907a4f4973940cd7e6718c83924
GIT binary patch
literal 325
zcmeAS@N?(olHy`uVBq!ia0vp^OhC-Y2qYNpL^`PhDVB6cUq_%&>E_A%I)HqIWRD<U
z28Jp%28M<f28Lfip@tU>45bDP46hOx7_4S6Fo+k-*%fF5lwc|e@(Tv)o$_}bkf&4P
z8d2h$Ur<?;nVwO?uu{Ruz|dF+NSG>k<!9t6IG5(-W#*-4B<3nO<(KEA7S)y%{{!kP
z$qb1o@ySe1%_{~<GcYow<}omET-WXK<!e?DXkGv55u?oR-02m9Ez`Y}cp5iy`>*GW
zt+&@s=DH`5$aTB3D$kv(V^*!!ikyPpdzbnPW^JC<*S@(VsVMJYcHA=lvdy>dD?NPQ
zw(#7oeMWuB8sf80T|U8UY^2q6W5!ybFB!NzT^vI=t|y-W21_18Zp4STD}bU5p00i_
I>zopr07Fe_=>Px#

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-1-1.8.png b/Engine/lib/lpng/contrib/testpngs/gray-1-1.8.png
new file mode 100644
index 0000000000000000000000000000000000000000..5db4d7915c600289a83979832b122d4989cf398d
GIT binary patch
literal 311
zcmeAS@N?(olHy`uVBq!ia0vp^OhC-Y2qYNpL^`PhDVB6cUq_%&>E_A%I)HqIWRD<U
z28Jp%28M<f28Lfip@tU>45bDP46hOx7_4S6Fo+k-*%fF5l+Y=0jVN)>FQ_caOwTA`
zSgBxSU}&rZBuo{&@-y-joJ;faGV{_i5_1)t^2>8li)u@X{{i)tWQIhP_+%!h<`n~_
z85kK-^B5R7uIu*r@--_6w66d3h*4&D?(_=5mg!zfJdGQ<{nvBG*4t|*bKR3j<htEi
zmFLdYF{@T<MNUEQy-WQCvo=rbYu{XwRFroxJ8l_&+2&jKl^(utTX^o)KBK;54e{Bh
wE}!5vHqvUkF=H*zUkqHHE{-7_*ON~G10s(hH{!$F6+lr2Pgg&ebxsLQ00i4+KL7v#

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-1-linear-tRNS.png b/Engine/lib/lpng/contrib/testpngs/gray-1-linear-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..5beb9d1df2026d6a63ecbf733dd86ff238e41aea
GIT binary patch
literal 325
zcmeAS@N?(olHy`uVBq!ia0vp^OhC-Y2qYNpL^`PhDVB6cUq=SUwgrYSro{vK3dtTp
zz6=aiY77hwEes65fI<x~7#K<o7#Ln9FfdrnU|<k0n6oR;1}MQ)666;QG;Ye@bwHj@
ziEBiObACZ(QD%BZ3ByVSBLhQY9Ux(<;FX_|r{G+gmzSBBo{^ZV;FMpUlUh_;Qv467
zuOu@hqQoaNIW?~sD9ymgkebK9z;Ru-$Cs~JL7;X0r$>x3yK|>k2)0c3QsQac$nC$L
zGq&DdJDKaAL?YMi&Z<0ju8vu?S}Sr2dhcE8FPOD?T3`F-lBA-%gV}M*_{%omy07%`
zecQrwxAqzJC2NS!K6Uv7ud$I<(~TKxfxcwm@^o<w;kcfB0vIfL47m{>-mU<OGI+ZB
KxvX<aXaWFxsA?Mk

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-1-linear.png b/Engine/lib/lpng/contrib/testpngs/gray-1-linear.png
new file mode 100644
index 0000000000000000000000000000000000000000..36a89a5abb65bc26902168e4354f9b7a0a058129
GIT binary patch
literal 311
zcmeAS@N?(olHy`uVBq!ia0vp^OhC-Y2qYNpL^`PhDVB6cUq=SUwgrYSro{vK3dtTp
zz6=aiY77hwEes65fI<x~7#K<o7#Ln9FfdrnU|<k0n6oR;1}LFZ;u=xnoL^8`l$oAU
z!mv`o$iUE82S}JIc;#p0DL9wr<z?ojXC&q-IOUh;q!!hd6#oP2E6EIrDDlZmPR%O@
zN;5Drq~<X&a9r2z@#Sk)5NKWh=@FyM?%e4Wf-Td%lz199a{I66jIFoVPUgBNk;rws
zvntP>t7BHJ){2~h-g}q&3ubMe*4MtdB&jIxV0PRx{<6)t?khcf-?s4Ft$jv)$r|Fb
xPhCF2Yiy*|bYsR^puZTnJY5_^IIbt300u-JLvF-}w=00644$rjF6*2UngBX_W^n)j

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-1-sRGB-tRNS.png b/Engine/lib/lpng/contrib/testpngs/gray-1-sRGB-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..80cec4b5eda87dbb62339094799b5ee2992cc539
GIT binary patch
literal 278
zcmeAS@N?(olHy`uVBq!ia0vp^OhC-Y2qYNpL^`R1IK@HkPR!=VeS?7<rjj7PV4(bz
zzw3ZJof6lG66gGa%A(Blj1q>G3PuKo#yUX4RKY7hBTvD(G%qhRFFhkMSHUU2JSVlN
zwxswUP+v)ANJNQGW^!s?F;JR;ks&pYfq~<?ZjUctvw}eD`cID-Wp?LIuMljR?xn=j
zxRKj`J!fpay>>F!J&8oF+nrT;?pz(SYPDA66!hM^)L$@b^R&M9%_T`ic?YxOmhqQu
zzI9*e;rq6Q=WgvY>PyxTpMC1`30`9(t)?3@)~W&R=kj!M4B@z*d;;jtJcite4{uih
PMHxI@{an^LB{Ts56k%Qg

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-1-sRGB.png b/Engine/lib/lpng/contrib/testpngs/gray-1-sRGB.png
new file mode 100644
index 0000000000000000000000000000000000000000..484fd18c4f64f1166bc8d27840187c7334471fde
GIT binary patch
literal 264
zcmeAS@N?(olHy`uVBq!ia0vp^OhC-Y2qYNpL^`R1IK@HkPR!=VeS?7<of6lG66gGa
z%A(Blj1q>G3PuKo#yUX4RKY7hBTvD(G%qhRFFhkMSHUU2JSVlNwxswUP+v)ANJNQG
zW^!s?F;JR;ks&pYfq~<?ZjUctvw}eD`cID-Wp?LIuMljR?xn=jxRKj`J!fpay>>F!
zJ&8oF+nrT;?pz(SYPDA66!hM^)L$@b^R&M9%_T`ic?YxOmhqQuzI9*e;rq6Q=WgvY
z>PyxTpMC1`30`9(t)?3@)~W&R=kj!M4B@z*d;;jRJcite4{uihMHxI@{an^LB{Ts5
De4koZ

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-1-tRNS.png b/Engine/lib/lpng/contrib/testpngs/gray-1-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..a988db9686e25a1abbc150bc6cc92c62e5647a50
GIT binary patch
literal 265
zcmeAS@N?(olHy`uVBq!ia0vp^OhC-Y2qYNpL^`R11WJPZf`LL){;mV^bV^(!N}Tfx
zDvL7HGfEg%Di|3U8tVWFQw6X5j64PB(!9LPy!4F3Tm`56@|@J7+LGdbKz${dArU1$
znaQbn#XxBWMuyZp1_qAnx;?&p%?bjo>pwkWl-Zp-y+W{Mx|b49<3?`(^_;Qw_S(r@
z_aqXzZg*DYxpQ^Qs?}PNQ_y?wQh&j$&C~kYH<u(8<sHn9TgG3u`PO}<hws}Kp1ZZr
zs4rPVeD<l!CwPsGw3=?rSgQuKpUcz5F@)oK@(G~V@)&X>KD=E46lL&q^>bP0l+XkK
DA>~^U

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-1.png b/Engine/lib/lpng/contrib/testpngs/gray-1.png
new file mode 100644
index 0000000000000000000000000000000000000000..71e37a336385e6432e94a7d9ff63ee51450e082a
GIT binary patch
literal 251
zcmeAS@N?(olHy`uVBq!ia0vp^OhC-Y2qYNpL^`PhDV-A6h!W@gg36-I^o$aQl?p}%
zhQ>NT!c@U4KO;}Uxil{?GcP?OF;~GUzdR?ksJ5i|A5dROW=KSdPiAszUNKObfsr9K
zkAZ>Xx^9mzU$cTh>-tZR7-e?nPOlJbneL^;)3}k_e?4bxy}foa*FA|uuG^hedG1^t
zvud?g<P`MYyVPGWYxA_e_RS?pMR^Ca<CgK4ZN7D1>EZjfh39VVGwMs$5TAYO@(EsJ
sBdw+zGuEmB?dS4zaSY+Oo_qr6nLLKvh!1a907V%*UHx3vIVCg!0JB3^X8-^I

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-16-1.8-tRNS.png b/Engine/lib/lpng/contrib/testpngs/gray-16-1.8-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..06cc0c138e80cf81da4acfe4e1dcfacf5a392c0e
GIT binary patch
literal 744
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K583ceNgJ!4pPawsT?&#~tz{ps-dGfvvAYUQb
zBgmJ5p-PQ`p`nF=;TKS-;RORjsR0ASs{{rHs~HRo;stYd1=;{5bV^(!N}TfxDvL7H
zGfEg%Di|3U8tVWFQw6X5j64PB(!9LPy!4F3Tm`56@|@J7+LGdbKz${dArU1$naQbn
z#XxDGgHrPt7&xx$_W1HOD+si%|MZAaW_RxN3c;4?UP?TT8@c`0bH>)&YbSHvlSt&c
z-C33A&ebuiR%=C0LGQgw{ROi&PwQ*nT#{6jcQ89{8GqU4TlbY7zHeK2?$$n|zGMyY
z*{3d_;59bVYPvCFEzn<#yFFbTLn>~)y<`Xs501kdc>gb|{OBOXoxAG1@2PY)0|vGO
v3=#~?2@E_9j04OW6pnxd!vKc_*b&#6jwCVjmF-a8!2krFu6{1-oD!M<TJNvD

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-16-1.8.png b/Engine/lib/lpng/contrib/testpngs/gray-16-1.8.png
new file mode 100644
index 0000000000000000000000000000000000000000..06cc0c138e80cf81da4acfe4e1dcfacf5a392c0e
GIT binary patch
literal 744
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K583ceNgJ!4pPawsT?&#~tz{ps-dGfvvAYUQb
zBgmJ5p-PQ`p`nF=;TKS-;RORjsR0ASs{{rHs~HRo;stYd1=;{5bV^(!N}TfxDvL7H
zGfEg%Di|3U8tVWFQw6X5j64PB(!9LPy!4F3Tm`56@|@J7+LGdbKz${dArU1$naQbn
z#XxDGgHrPt7&xx$_W1HOD+si%|MZAaW_RxN3c;4?UP?TT8@c`0bH>)&YbSHvlSt&c
z-C33A&ebuiR%=C0LGQgw{ROi&PwQ*nT#{6jcQ89{8GqU4TlbY7zHeK2?$$n|zGMyY
z*{3d_;59bVYPvCFEzn<#yFFbTLn>~)y<`Xs501kdc>gb|{OBOXoxAG1@2PY)0|vGO
v3=#~?2@E_9j04OW6pnxd!vKc_*b&#6jwCVjmF-a8!2krFu6{1-oD!M<TJNvD

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-16-linear-tRNS.png b/Engine/lib/lpng/contrib/testpngs/gray-16-linear-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..beb4e96e25f70241098b8427adadfbdbe2c4bdf0
GIT binary patch
literal 744
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K583ceNgJ!4pPawsT?&#~tz}U9H@Wr%vAYUQb
zBgmJ5p-PQ`p`nF=;TKS-;RORjsR0ASs{{rHs~HRo;stYd1=;{5bV^(!N}TfxDvL7H
zGfEg%Di|3U8tVWFQw6X5j64PB(!9LPy!4F3Tm`56@|@J7+LGdbKz${dArU1$naQbn
z#XxDGgHrPt7&xx$_W1HOD+si%|MZAaW_RxN3c;4?UP?TT8@c`0bH>)&YbSHvlSt&c
z-C33A&ebuiR%=C0LGQgw{ROi&PwQ*nT#{6jcQ89{8GqU4TlbY7zHeK2?$$n|zGMyY
z*{3d_;59bVYPvCFEzn<#yFFbTLn>~)y<`Xs501kdc>gb|{OBOXoxAG1@2PY)0|vGO
v3=#~?2@E_9j04OW6pnxd!vKc_*b&#6jwCVjmF-a8!2krFu6{1-oD!M<<sh%`

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-16-linear.png b/Engine/lib/lpng/contrib/testpngs/gray-16-linear.png
new file mode 100644
index 0000000000000000000000000000000000000000..beb4e96e25f70241098b8427adadfbdbe2c4bdf0
GIT binary patch
literal 744
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K583ceNgJ!4pPawsT?&#~tz}U9H@Wr%vAYUQb
zBgmJ5p-PQ`p`nF=;TKS-;RORjsR0ASs{{rHs~HRo;stYd1=;{5bV^(!N}TfxDvL7H
zGfEg%Di|3U8tVWFQw6X5j64PB(!9LPy!4F3Tm`56@|@J7+LGdbKz${dArU1$naQbn
z#XxDGgHrPt7&xx$_W1HOD+si%|MZAaW_RxN3c;4?UP?TT8@c`0bH>)&YbSHvlSt&c
z-C33A&ebuiR%=C0LGQgw{ROi&PwQ*nT#{6jcQ89{8GqU4TlbY7zHeK2?$$n|zGMyY
z*{3d_;59bVYPvCFEzn<#yFFbTLn>~)y<`Xs501kdc>gb|{OBOXoxAG1@2PY)0|vGO
v3=#~?2@E_9j04OW6pnxd!vKc_*b&#6jwCVjmF-a8!2krFu6{1-oD!M<<sh%`

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-16-sRGB-tRNS.png b/Engine/lib/lpng/contrib/testpngs/gray-16-sRGB-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..315db86a6ad80b29e14ab131535c2839cb919124
GIT binary patch
literal 697
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K583ceNgJ!4pPY|y-$lZzA{J3v0kfT%L8d2h$
zUr<?;nVwO?uu{Ruz|dF+NSG>k<!9t6IG5(-W#*-4B<3nO<(KEA7S)y%{{!kP$qb1o
z@ySe1%_{~<18qpnV_@L8uG{0w*Q_AWy8hE6Mw#8Y(<=m9rh6&zG;ZYfU(Xp^Z?B!q
zbx$IZ>vm^Vo;z2^tXi!VIR(A<F7+48+B~hVeRD}tQQpDqxMlohn{VA$dicI=;kjG;
zjQWx_#Alzne1g~5NUQ0_jJ0Y&KkW8&aSW-r_4bk>(1RR@H}L*nRQb_CiaU4JdEZm%
zYz7Q$2N)z6m=hRy8W;zdGbkJZ35Ed<39uusGaX4{<}2Hwyn_J<JYD@<);T3K0RW*z
BqtyTa

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-16-sRGB.png b/Engine/lib/lpng/contrib/testpngs/gray-16-sRGB.png
new file mode 100644
index 0000000000000000000000000000000000000000..315db86a6ad80b29e14ab131535c2839cb919124
GIT binary patch
literal 697
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K583ceNgJ!4pPY|y-$lZzA{J3v0kfT%L8d2h$
zUr<?;nVwO?uu{Ruz|dF+NSG>k<!9t6IG5(-W#*-4B<3nO<(KEA7S)y%{{!kP$qb1o
z@ySe1%_{~<18qpnV_@L8uG{0w*Q_AWy8hE6Mw#8Y(<=m9rh6&zG;ZYfU(Xp^Z?B!q
zbx$IZ>vm^Vo;z2^tXi!VIR(A<F7+48+B~hVeRD}tQQpDqxMlohn{VA$dicI=;kjG;
zjQWx_#Alzne1g~5NUQ0_jJ0Y&KkW8&aSW-r_4bk>(1RR@H}L*nRQb_CiaU4JdEZm%
zYz7Q$2N)z6m=hRy8W;zdGbkJZ35Ed<39uusGaX4{<}2Hwyn_J<JYD@<);T3K0RW*z
BqtyTa

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-16-tRNS.png b/Engine/lib/lpng/contrib/testpngs/gray-16-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..4826d61eb7fab6977de0135762596f6220847a51
GIT binary patch
literal 684
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K583ceNgJ!4pPavgJ;u=xnoL^8`l$oAU!mv`o
z$iUE82S}JIc;#p0DL9wr<z?ojXC&q-IOUh;q!!hd6#oP2E6EIrDDlZmPR%O@N&^i|
z&0}ETxUSpd%h#+R(7OK9BSx9sxzj5ITc&#{@icDa_FvB#TW_zO%ymy9k?VG6Rh~On
z$E;ed6*&dH_b&Ap%-TGyuYGe#Qc>Q)?6_t8Wt(r^S9<uqZQ;3F`;7XMHN<D1x_pAy
z*hs7C#*DRUKu_%Uba4!+xb^muA<$18hd1#4UsU<gL5e$f)p_4j>1+lJYzG)57?=|n
qcp4Z7m@_CG0SSfy4hgU$t}`7;V&*H`p}d0u2s~Z=T-G@yGywqIAfV*{

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-16.png b/Engine/lib/lpng/contrib/testpngs/gray-16.png
new file mode 100644
index 0000000000000000000000000000000000000000..4826d61eb7fab6977de0135762596f6220847a51
GIT binary patch
literal 684
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K583ceNgJ!4pPavgJ;u=xnoL^8`l$oAU!mv`o
z$iUE82S}JIc;#p0DL9wr<z?ojXC&q-IOUh;q!!hd6#oP2E6EIrDDlZmPR%O@N&^i|
z&0}ETxUSpd%h#+R(7OK9BSx9sxzj5ITc&#{@icDa_FvB#TW_zO%ymy9k?VG6Rh~On
z$E;ed6*&dH_b&Ap%-TGyuYGe#Qc>Q)?6_t8Wt(r^S9<uqZQ;3F`;7XMHN<D1x_pAy
z*hs7C#*DRUKu_%Uba4!+xb^muA<$18hd1#4UsU<gL5e$f)p_4j>1+lJYzG)57?=|n
qcp4Z7m@_CG0SSfy4hgU$t}`7;V&*H`p}d0u2s~Z=T-G@yGywqIAfV*{

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-2-1.8-tRNS.png b/Engine/lib/lpng/contrib/testpngs/gray-2-1.8-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..a1c6854c96cac7f43c66695fcb529ede2d6d5d34
GIT binary patch
literal 325
zcmeAS@N?(olHy`uVBq!ia0vp^EI`c21SA-yJ@?oE5=eLSb!1><EZsbLUk8w{kn9oU
z%fL{j#=y|f!octgDAe$RfuYoZf#FpG1B2BJ1_tqhIlBUFfD%k4L4LtNy;J_K1M+lA
zTq8=H^9w4AGSf3k7*;A685kPt00~nCul$TW1?SSdyv)4xjKo|8r~LAq)S}vw;(tJW
zC7B@+B|e$Ssd>dfX$D4y)I0_Tj_bNTzI@FJ0<G&mJz|vEojbikuw}ZJ5>MksZvXY1
zvGw-a$z1m&61i@7R^_>Kb<C>OT9H%Gd+$<z!K}^G`r0>_Bo*Zy%#K^eU$*(yeWi!*
z+ZLX?wa=(8SwnpGsmmvLjg7RLZp>H<^d$qAr;B3<$Mxh1Yzz#t3^FQJZ<B$d44$rj
JF6*2UngAcCX#W5J

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-2-1.8.png b/Engine/lib/lpng/contrib/testpngs/gray-2-1.8.png
new file mode 100644
index 0000000000000000000000000000000000000000..4cc811cdf7eacddc22bbae8eca6813c5783418ac
GIT binary patch
literal 311
zcmeAS@N?(olHy`uVBq!ia0vp^EI`c21SA-yJ@?oE5=eLSb!1><EZsbLUk8w{kn9oU
z%fL{j#=y|f!octgDAe$RfuYoZf#FpG1B2BJ1_tqhIlBUFfD$?-t`Q~9`303lnduoN
z3@a6k3=EBRfP|@nSAIsGf^%tJUS?i;Mq;jlQ+|0)YEf-T@jsxxlFX2Z5}(ZE)VyM#
zGy@|;Y90dv$93HvU%qAqf!6h(9x=-7&YfN%*fQNqiKlTRxBq(1*m`^IWUhM>iCnik
ztMc5rI%d^st;i|py?3d<VAkeoeeIh|l8W*UX2&h#FWY?UzS6_@Z41xc+Go_4tRX)8
x)a4Vr#ztCAH)gB_`ip_f)5S4_<9hN0HU<V+1{syAx5+?J22WQ%mvv4FO#sz8WmNzG

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-2-linear-tRNS.png b/Engine/lib/lpng/contrib/testpngs/gray-2-linear-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..3c29ec6d97ac694615d5081ad650a348a1ead652
GIT binary patch
literal 325
zcmeAS@N?(olHy`uVBq!ia0vp^EI`c21SA-yJ@?oE5=eLSb!1>{TVVKNT0D@ikn9oU
z%fL{j#=y|f!octgDAe$RfuYoZf#FpG1B2BJ1_tqhIlBUFfD%k4L4LsujEqzMt^@LP
zN?apKobwARi!#$QN*Gou7#SEE>i`K;1+V;!JO$^{yu8f3^o+z@1*iP-oYbP)lHz|r
zeI=P85hXsE$*Fn8Kxqa>hSWR;29E2xJ-&R+3IeU`KRsfU*_}JRLa=4Jml99oMsEN0
zoU!%x+R0q^Boeu9cUI-Ob9KzB)mo8L(0lJvf5EKH)B4&smn0SC9n6kf#$UGi)_tXi
z@7orhyS2}#FIhu;_NmJ!c#Vy;nr_Tk3-l!em#2$k2*>s032Y1uvJ5gRRd17lq70s{
KelF{r5}E*50%<V-

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-2-linear.png b/Engine/lib/lpng/contrib/testpngs/gray-2-linear.png
new file mode 100644
index 0000000000000000000000000000000000000000..6ca6fb74dd865fdc8272190027938252c613254a
GIT binary patch
literal 311
zcmeAS@N?(olHy`uVBq!ia0vp^EI`c21SA-yJ@?oE5=eLSb!1>{TVVKNT0D@ikn9oU
z%fL{j#=y|f!octgDAe$RfuYoZf#FpG1B2BJ1_tqhIlBUFfD$?-t`Q~9`303lnduoN
z3@a6k3=EBRfP|@nSAIsGf^%tJUS?i;Mq;jlQ+|0)YEf-T@jsxxlFX2Z5}(ZE)VyM#
zGy@|;Y90dv$93HvU%qAqf!6h(9x=-7&YfN%*fQNqiKlTRxBq(1*m`^IWUhM>iCnik
ztMc5rI%d^st;i|py?3d<VAkeoeeIh|l8W*UX2&h#FWY?UzS6_@Z41xc+Go_4tRX)8
x)a4Vr#ztCAH)gB_`ip_f)5S4_<9hN0HU<V+1{syAx5+?J22WQ%mvv4FO#lk$WrqL&

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-2-sRGB-tRNS.png b/Engine/lib/lpng/contrib/testpngs/gray-2-sRGB-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..b418c8fbb600a1991f4e19147c95c5f2856e1310
GIT binary patch
literal 278
zcmeAS@N?(olHy`uVBq!ia0vp^EI`c21SA-yJ@?oE;uHtDJ29Id_YDSem`Z~Df*BYY
zr~F+9<mr^SMwB?`7gQEyre~BetW+>EFf`Ty5~d1X`5Ac%&ZT*InR)3MiMa|+`Q<sO
zMYScx|A6{RGD9Ltd@_?$^NNAe42%q^c?=93*L8b*`I;33TGxMi#3-{ncY1|j%XBX#
zp2m&b{_8no>+Q9Zx$a3Ma^3E%%5&%Hm{qH_BB!AD-lhJ6S(~TzwQnv-D#|;U9k-0X
zZ1b)AN)O++Ej)K?pHW}3hWPALmrw8-8)-G&n6Xw3Xg`;yi(?4K_2da`3=FaiGAdPX
QlYycPp00i_>zopr0LZ3Y7XSbN

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-2-sRGB.png b/Engine/lib/lpng/contrib/testpngs/gray-2-sRGB.png
new file mode 100644
index 0000000000000000000000000000000000000000..a6bde60afe4a37ac48cac5461c8e7ffd015c4940
GIT binary patch
literal 264
zcmeAS@N?(olHy`uVBq!ia0vp^EI`c21SA-yJ@?oE;uHtDJ29Id_YDSebV^(!N}Tfx
zDvL7HGfEg%Di|3U8tVWFQw6X5j64PB(!9LPy!4F3Tm`56@|@J7+LGdbKz${dArU1$
znaQbn#XxBWMuyZp1_qAnx;?&p%?bjo>pwkWl-Zp-y+W{Mx|b49<3?`(^_;Qw_S(r@
z_aqXzZg*DYxpQ^Qs?}PNQ_y?wQh&j$&C~kYH<u(8<sHn9TgG3u`PO}<hws}Kp1ZZr
zs4rPVeD<l!CwPsGw3=?rSgQuKpUcz5F@)oK@&q;p23ZCfm8!SNKv4!yS3j3^P6<r_
DB?nn;

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-2-tRNS.png b/Engine/lib/lpng/contrib/testpngs/gray-2-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..8e04cb5020cc1ecf62544cb32d5b79c80db9eb55
GIT binary patch
literal 265
zcmeAS@N?(olHy`uVBq!ia0vp^EI`c21SA-yJ@?oEq?k&A{DK)68K?YR2juCLxJHyX
z=ND8KWu|A8FsxKCGB7mO0TQMPUile$3eKf@d6{|X8Hu?HPWk0IsYSIV#s7f%N-{$t
zN_;YtQ}c>}(hQ6Ysd)?x9M^SweEFIc1X|aBdc-KRJ9m18V9RtbC7#BO-2Ur1W9#j;
zlez9mBy!#Etjcre>X=olwIZjW_ui%cf?1oV^|fy<Nh-=am>su_zijiZ`$`Yrw=Fz(
zYoAeHvWEEVQ<qQh8XIXf-I%df4QM}?r;B3<$Mxh1Yzz#t3^FQJZ<B$d44$rjF6*2U
FngGifS|<Pi

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-2.png b/Engine/lib/lpng/contrib/testpngs/gray-2.png
new file mode 100644
index 0000000000000000000000000000000000000000..9d85a2ace35065acf576c22c315e50366f4fd264
GIT binary patch
literal 251
zcmeAS@N?(olHy`uVBq!ia0vp^EI`c21SA-yJ@?oEq;yJLBTAg}3o45;(=$pKRw@`7
z7#iyU2~!2H{ER#W=hD2q%)IoB#9RfZ{PLXCqS}(;e?WaDnIRD+KAFj>dBs3!21bU|
zJO&1i>$*L@e9a01t?NHMVwBmPJH0}%WxAIVPvb^z|Mi@)_4eAyT=ygrxo&q><+*cp
z%&OH|kyFrn?^1uktj*K<+BcUZ73Cewj$6iGw)xh5rHAj^7M{Dc&!{h1LwxqB%O`k^
sjkKC>%vh@iw4ck<#W95Adh!G|1_oIM8I`KH$v{yCPgg&ebxsLQ08p7$eE<Le

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-4-1.8-tRNS.png b/Engine/lib/lpng/contrib/testpngs/gray-4-1.8-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..402d699fbc58d06f5dd278de7237e76ed57d2095
GIT binary patch
literal 327
zcmeAS@N?(olHy`uVBq!ia0vp^0zk~j0wfsBAI)h3QY`6?zK#rxjHR0=@9O~a6_P!I
zd>I(3)EF2VS{N990fib~Fff!FFfhDIU|_JC!N4G1FlSew4N!uqB*-rqsCUZWbwHj@
ziEBiObACZ(QD%BZ3ByVSBLhQY9Ux(<;FX_|r{G+gmzSBBo{^ZV;FMpUlUh_;Qv467
zuOu@hqQoaNIW?~sD9ymgkebK9z;Ru-$Cs~JL7;X0r$>x3yK|>k2)0c3QsQac$nC$L
zGq&DdJDKaAL?YMi&Z<0ju8vu?S}Sr2dhcE8FPOD?T3`F-lBA-%gV}M*_{%omy07%`
zecQrwxAqzJC2NS!K6Uv7ud$I<(~TKxfxcwm@pN$v;kcfh5&{el=1UA8Pv&%-2Z}Rz
My85}Sb4q9e0OT}lpa1{>

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-4-1.8.png b/Engine/lib/lpng/contrib/testpngs/gray-4-1.8.png
new file mode 100644
index 0000000000000000000000000000000000000000..bc8da98761cf9ecf3b9e0f1195b58a19f672ae5a
GIT binary patch
literal 313
zcmeAS@N?(olHy`uVBq!ia0vp^0zk~j0wfsBAI)h3QY`6?zK#rxjHR0=@9O~a6_P!I
zd>I(3)EF2VS{N990fib~Fff!FFfhDIU|_JC!N4G1FlSew4NyX-#5JPCIlrK?C^J2y
zgkhzEk%6JH4v;Wa@XF7~Q*bWL%gfA5&q&NwaLO;wNiC`^DgFo4SCSbLQR0)CoSIh*
zlxARLNX=tl;JB{a<IC5qAke!0(<4Ti-MP~%1Y4$iDe*LJ<n~|B8C!3!oy>JlB9ZHM
zXH}j%SI4Yctra;1z4tEl7tGo`t*?D^Nm5bX!R)wY{AHVO-B)_}zHQ;TTl<Xqk~PF<
zpSpa4*Vss_>Bfw;Kz}jtc)B=-a9mGL2?2%x^CgClCv!T^1H~CUUHx3vIVCg!0F@$V
A_5c6?

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-4-linear-tRNS.png b/Engine/lib/lpng/contrib/testpngs/gray-4-linear-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..45c063d8542ccc7429dc4709fa8487244748d9fb
GIT binary patch
literal 327
zcmeAS@N?(olHy`uVBq!ia0vp^0zk~j0wfsBAI)h3QY`6?zK#rxZ3_%vOp6Ed6_P!I
zd>I(3)EF2VS{N990fib~Fff!FFfhDIU|_JC!N4G1FlSew4N!uqB*-tAfst{_-*rHq
zPKj$oiF1BIWl?5&MhU}81tSAPV;vx2s^FEMk*DBXnwOWEm!6TBtKgJho|9TsTT=WF
zsIMe5B%;J8GdVS{7%0ua$dH=Hz`$``x5t;SSwWz6{ijEaGP`r9R|vLD_fq0%+{o>}
zo-?-IUOSoVo<t(o?arz^cdm|EwOT833VQEd>MxkJd0Jol=8~kMyo1?s%lOMS-@32#
z@O|6DbGP;x^(AYF&pvhe1h27?R@03cYk|IG;PG^E4B@z*oDu>I59Uh@A5Z3VoCk_C
Nc)I$ztaD0e0stKXYtjG!

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-4-linear.png b/Engine/lib/lpng/contrib/testpngs/gray-4-linear.png
new file mode 100644
index 0000000000000000000000000000000000000000..0bd068d73fe1cb710b6f1eeed6c34dae1de8d718
GIT binary patch
literal 313
zcmeAS@N?(olHy`uVBq!ia0vp^0zk~j0wfsBAI)h3QY`6?zK#rxZ3_%vOp6Ed6_P!I
zd>I(3)EF2VS{N990fib~Fff!FFfhDIU|_JC!N4G1FlSew4NyX-#5JPCIlrK?C^J2y
zgkhzEk%6JH4v;Wa@XF7~Q*bWL%gfA5&q&NwaLO;wNiC`^DgFo4SCSbLQR0)CoSIh*
zlxARLNX=tl;JB{a<IC5qAke!0(<4Ti-MP~%1Y4$iDe*LJ<n~|B8C!3!oy>JlB9ZHM
zXH}j%SI4Yctra;1z4tEl7tGo`t*?D^Nm5bX!R)wY{AHVO-B)_}zHQ;TTl<Xqk~PF<
zpSpa4*Vss_>Bfw;Kz}jtc)B=-a9mGL2?2%x^CgClCv!T^1H~CUUHx3vIVCg!0Lvw4
AC;$Ke

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-4-sRGB-tRNS.png b/Engine/lib/lpng/contrib/testpngs/gray-4-sRGB-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..be8521049c4bd55335297e587ad8679808c193df
GIT binary patch
literal 280
zcmeAS@N?(olHy`uVBq!ia0vp^0zk~j0wfsBAI)h3af*Z7otVv!`vwC!OeH~n!3>Oy
zQ~s_4@^ngEBTAg}3o45;(=$pKRw@`77#iyU2~!2H{ER#W=hD2q%)IoB#9RfZ{PLXC
zqS}(;e?WaDnIRD+KAFj>dBs3!21bU|JO&1i>$*L@e9a01t?NHMVwBmPJH0}%WxAIV
zPvb^z|Mi@)_4eAyT=ygrxo&q><+*cp%&OH|kyFrn?^1uktj*K<+BcUZ73Cewj$6iG
zw)xh5rHAj^7M{Dc&!{h1LwxqB%O`k^jkKC>%vh@iw4cY*#W95AdU8q#(1XmE7(SlN
S={OG*XYh3Ob6Mw<&;$T}LSMK5

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-4-sRGB.png b/Engine/lib/lpng/contrib/testpngs/gray-4-sRGB.png
new file mode 100644
index 0000000000000000000000000000000000000000..38a79228d93ba2f043ba3edb84d78cd58ea7a6a3
GIT binary patch
literal 266
zcmeAS@N?(olHy`uVBq!ia0vp^0zk~j0wfsBAI)h3af*Z7otVv!`vwC!Iwh_VCC>Q;
zl|`B986^xW6^slFjdg&8se)I2MxKImX<lAtUV27iu7Xp3c}{9kZAtMzpuUpKkcbkW
z%;eO(VxTkwBSUH)0|Uo(-5y`QW(9%P^`9Ow%IwaaULn{r-Ajq5aU-|?dd}E-d+lVd
zdlHFUw>zuy+_^et)oQKCDd@d-slQ;>=4pNHn@f_4@(yOlE#oiSeCxi_!}o0q&)wQ*
z)R(LwKKs<=6THSoT1_`*tW^Wr&*SOh7{YNqIVA+>CFV;EA5Z3VoCk_Cc)I$ztaD0e
F0sz(ETn+#L

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-4-tRNS.png b/Engine/lib/lpng/contrib/testpngs/gray-4-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..14c4f1fb3aadad1b986d1ff32b99ae5eb50421e5
GIT binary patch
literal 267
zcmeAS@N?(olHy`uVBq!ia0vp^0zk~j0wfsBAI)h3QcNX5e!&ckj8p!u1M+lATq8=H
z^9w4AGSf3k7*;A685kPt00~nCul$TW1?SSdyv)4xjKo|8r~LAq)S}vw;(tJWC7B@+
zB|e$Ssd>dfX$D4y)I0_Tj_bNTzI@FJ0<G&mJz|vEojbikuw}ZJ5>MksZvXY1vGw-a
z$z1m&61i@7R^_>Kb<C>OT9H%Gd+$<z!K}^G`r0>_Bo*Zy%#K^eU$*(yeWi!*+ZLX?
zwa=(8SwnpGsmmvLjg7RLZp>J#2DG2Y)5S4_<9c#R2+&W=ml!^t%;`7}6ld^s^>bP0
Hl+XkKeMDTy

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-4.png b/Engine/lib/lpng/contrib/testpngs/gray-4.png
new file mode 100644
index 0000000000000000000000000000000000000000..16bcada820e9317d7b3815e635f35201d0574d92
GIT binary patch
literal 253
zcmeAS@N?(olHy`uVBq!ia0vp^0zk~j0wfsBAI)h3QaUBB5hc#~1(ija=@}&qD;10k
z42^YwgsFm8eny^xb7@{)W?p(mVy=QyetAx6QEf@_KcK#n%#er@pUmXcykej<10zFf
z9s>i%b=@9czGel1*7ctrG0N=Don9f>GTlpwr*R{<|9Z~YdVB3;u6q)RT(>)`^4z&P
zX4Pt~$SLT(cd5T%*5+w_?VC%Iit-L-$1US8+kET3(!=*{3(wu!XVjOhAwK)m<rBQd
uMp{ibW~@~M+Rx+Z;uyklJvk)==nLjc3?EPCbeso@GkCiCxvX<aXaWHK0$Cma

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-8-1.8-tRNS.png b/Engine/lib/lpng/contrib/testpngs/gray-8-1.8-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..2b3892458a430c374e0025e7ef87642065aa5600
GIT binary patch
literal 327
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K57&$<sh>`wkAjOjI=<CS9$XL30^1corUm@8e
z$d`ekN{xY`p@o6r7f`6-1p`B=0RzLU1O^7H84L{K1#@-<+5jb(N`m}?fqJL>T?gdp
zl(<HeIOi8s7G<VqlrXGRFfuSS)&UZx3SRjcc?!;@d3l+6=^2T+3QqauIjKdpCB^@M
z`bsiGB1(KRlT-7Gfzm)Hrsgp)a9r2z@#Sk)5NKWh=@FyM?%e4Wf-Td%lz199a{I66
zjIFoVPUgBNk;rwsvntP>t7BHJ){2~h-g}q&3ubMe*4MtdB&jIxV0PRx{<6)t?khcf
z-?s4Ft$jv)$r|FbPhCF2Yiy*|bYsR^pf4GCJY5_^BrYeX$UJ0VXli0)GOYaq^d$p>
Mr>mdKI;Vst0EUNYpa1{>

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-8-1.8.png b/Engine/lib/lpng/contrib/testpngs/gray-8-1.8.png
new file mode 100644
index 0000000000000000000000000000000000000000..4bba74cfa63e2e81fb6b7bc7ad83282cd9b94f8f
GIT binary patch
literal 313
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K57&$<sh>`wkAjOjI=<CS9$XL30^1corUm@8e
z$d`ekN{xY`p@o6r7f`6-1p`B=0RzLU1O^7H84L{K1#@-<+5jbVN?apKobwARi!#$Q
zN*Gou7#SEE>i`K;1+V;!JO$^{yu8f3^o+z@1*iP-oYbP)lHz|reI=P85hXsE$*Fn8
zKxv?(Qu7!XIIipV`0_O?2(+&M^oUVrckc8G!ItS>N<57lx&7C3#@5?wCv)ACNaVWR
zS(WF`)iJA9Yeh~$@4ZX?1+z9!>ucX!l2nv;FgtD;f7#|+_mv*LZ(Dfo);^=YWDW7z
zr!Jr1H8#>}x-nxd&|eHZo-U3d5|@)xWF9gwG&M0Y8P<LQ`ip_V)78&qol`;+07p?}
A_5c6?

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-8-linear-tRNS.png b/Engine/lib/lpng/contrib/testpngs/gray-8-linear-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..a801abdaaa756477768c6fcc56a679b597235a2c
GIT binary patch
literal 327
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K57&$<sh>`wkAjOjI=<CS9*tWp%#k6=JUm@8e
z$d`ekN{xY`p@o6r7f`6-1p`B=0RzLU1O^7H84L{K1#@-<+5jb(N`m}?85kL-{9Om+
z>6ExelsM-XR2F5XXOu9kR4_6yG}ZwUrV3v98F>oMrFnUodFdI6xe8AC<vFQEwI#*>
zfci=@Ln2CiGLuvDih<HVC#L2xFmPPg?eXPnRuE`i|LGB<%<kOj6@o3(y_9$wH*)*0
z=Zvkl*G}fTCy~f?yR$0KovUM3t=5X1g5G<V`U_@lp4QjCxg@D5?_hS^GXAp7x9%%F
zeBZY4+^u~^eaRZ)vrk<<!E0=!)pTRVTA(i(csyMkLnJOIr^q~HU}$P$WHPM%0`w&V
NgQu&X%Q~loCIG)iY0>}y

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-8-linear.png b/Engine/lib/lpng/contrib/testpngs/gray-8-linear.png
new file mode 100644
index 0000000000000000000000000000000000000000..91be367ee5c1ac540bc68888aa4253292636f31d
GIT binary patch
literal 313
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K57&$<sh>`wkAjOjI=<CS9*tWp%#k6=JUm@8e
z$d`ekN{xY`p@o6r7f`6-1p`B=0RzLU1O^7H84L{K1#@-<+5jbVN?apKobwARi!#$Q
zN*Gou7#SEE>i`K;1+V;!JO$^{yu8f3^o+z@1*iP-oYbP)lHz|reI=P85hXsE$*Fn8
zKxv?(Qu7!XIIipV`0_O?2(+&M^oUVrckc8G!ItS>N<57lx&7C3#@5?wCv)ACNaVWR
zS(WF`)iJA9Yeh~$@4ZX?1+z9!>ucX!l2nv;FgtD;f7#|+_mv*LZ(Dfo);^=YWDW7z
zr!Jr1H8#>}x-nxd&|eHZo-U3d5|@)xWF9gwG&M0Y8P<LQ`ip_V)78&qol`;+0DV+u
AC;$Ke

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-8-sRGB-tRNS.png b/Engine/lib/lpng/contrib/testpngs/gray-8-sRGB-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..f54f23d6bc86096cf0268208b903275a35790707
GIT binary patch
literal 280
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K57&$<sh>`wk5T`iE-HF-!xNk6!!&DOF7tFxO
zIOXp;AWx^nHKN2hzo4=xGd-h(VWonRfuXSukT6y7%FoDCa4yZu%gjs9NX%7m$}i7J
zEvhXk{s+`ok{J?F;**)2npX^z2HKgL$H2gGUAM=VuUSE$b^WJDj551(r&kEJO!rda
zY23)|zn(L;-d;PI>z+g+*X_=#Ja?{+S+!a#ateCyUFt8GwRu`!`{t6QqP&CIam)D2
zHs89h^zeP#!gIIw8TBP=h|fNC`2?@Akyg`<8Ee&m_VakUIEF}EPEL_|$iUFl#K>e=
S`(*}DoWax8&t;ucLK6U0(_Od#

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-8-sRGB.png b/Engine/lib/lpng/contrib/testpngs/gray-8-sRGB.png
new file mode 100644
index 0000000000000000000000000000000000000000..2ae6377ff956395a0e6b948f0236e057db3d3a9e
GIT binary patch
literal 266
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K57&$<sh>`wk5T`iE-HF-!xNk6!qf_D<QR19m
zP+63jo>9WEQo+c;&{zjZm@0VXXXGh3m*(YV=A~yO<|;Vlm*=Dw)s__h1L`Zu42dZ5
z$xKeoD+WpfZAr~zVBol}+vCgEtRT?3{?j8ynccb5D+F7ndnxfWZshh~&ly{9ubs?w
zPa=`)c4t+dJ6Ff7TCEj11-<t!^%u<AJgu*Nb4gNB-ofm+W&CBEZ{1gV_`Yr7xm){;
z`jR!oXP>%!g4ftctLes!wQ4~7c|2VlLnJOIr^q~HU}$P$WHPM%G6N{i;OXk;vd$@?
F2>`uKS`GjJ

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-8-tRNS.png b/Engine/lib/lpng/contrib/testpngs/gray-8-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..842245f1d9f192857edd85f43f2d8d6ca8874c01
GIT binary patch
literal 267
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K57&$<sh>`wkAjMP?<QL4q$T;QiIv`J{#5JPC
zIlrK?C^J2ygkhzEk%6JH4v;Wa@XF7~Q*bWL%gfA5&q&NwaLO;wNiC`^DgFo4SCSbL
zQR0)CoSIh*lm=Rpn#aJvab35^m#<ktpmqJHM~pJNbEj7bwoLa@;%VH-?Z2Kgw%%Sl
znd_cJBG>KCsyuhDj#;%@D{=~Y?_KIIn6-IYU;E~gq@uio*>TJG%QoM-uk`SJ+ro3V
z_8IjhYlzQ2b@>FZv5{8OjTvjzfcEovx;TbNTux4rdC0)f)WpbSSo>uLP@KWj)z4*}
HQ$iB}V~<+M

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-8.png b/Engine/lib/lpng/contrib/testpngs/gray-8.png
new file mode 100644
index 0000000000000000000000000000000000000000..23af27e141a5f6a6dbd411dc738418a087997bb2
GIT binary patch
literal 253
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K57&$<sh>`wkAf;2{8d2h$Ur<?;nVwO?uu{Ru
zz|dF+NSG>k<!9t6IG5(-W#*-4B<3nO<(KEA7S)y%{{!kP$qb1o@ySe1%_{~<0}W2i
zV_@L8uG{0w*Q_AWy8hE6Mw#8Y(<=m9rh6&zG;ZYfU(Xp^Z?B!qbx$IZ>vm^Vo;z2^
ztXi!VIR(A<F7+48+B~hVeRD}tQQpDqxMlohn{VA$dicI=;kjG;jQWx_#Alzne1g~5
uNUQ0_jJ0Y&`*}QF977~7C#T3fWMF7&Vq`L`{W1e6&fw|l=d#Wzp$P!=DOVl<

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-alpha-16-1.8.png b/Engine/lib/lpng/contrib/testpngs/gray-alpha-16-1.8.png
new file mode 100644
index 0000000000000000000000000000000000000000..e0d36b7f09cae81f51467da2b57256438c80f5a5
GIT binary patch
literal 919
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K583b5>)Uwxm)&VJ&bVpxD21drx&6D?a0Qm~Z
z9znhg3{`3j3=J&|48MRv4KElNN(~qoUL`OvSj}Ky5HFasE6@fgp;O`-QR19mP+63j
zo>9WEQo+c;&{zjZm@0VXXXGh3m*(YV=A~yO<|;Vlm*=Dw)s__h1L`Zu42dZ5$xKeo
zD+Wpf9h92Kz`$``x5t;SSwWz6{ijEaGP`r9R|vLD_fq0%+{o>}o-?-IUOSoVo<t(o
z?arz^cdm|EwOT833VQEd>MxkJd0Jol=8~kMyo1?s%lOMS-@32#@O|6DbGP;x^(AYF
z&pvhe1h27?R@03cYk~e^%JOt^45_&F_R3D)0}edQj$Zqg|L?nd=&2ObWrpUpDw@X9
zJJ;pMCoJ<@&wNIOL4lzGsE2`rY7CABVFyq&urLTPP>UhJpiX61DggcKM`c$!0R1b&
mNX@VWMGn<HPAwxpJYe6a@^9h76YFIdfWXt$&t;ucLK6U^^PtuM

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-alpha-16-linear.png b/Engine/lib/lpng/contrib/testpngs/gray-alpha-16-linear.png
new file mode 100644
index 0000000000000000000000000000000000000000..26aa32cee157628a4d03895aadbd4d112d52dfd7
GIT binary patch
literal 919
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K583b5>)Uwxm)&VJ&bVpxD2FA7phA*bY1NjQc
z9znhg3{`3j3=J&|48MRv4KElNN(~qoUL`OvSj}Ky5HFasE6@fgp;O`-QR19mP+63j
zo>9WEQo+c;&{zjZm@0VXXXGh3m*(YV=A~yO<|;Vlm*=Dw)s__h1L`Zu42dZ5$xKeo
zD+Wpf9h92Kz`$``x5t;SSwWz6{ijEaGP`r9R|vLD_fq0%+{o>}o-?-IUOSoVo<t(o
z?arz^cdm|EwOT833VQEd>MxkJd0Jol=8~kMyo1?s%lOMS-@32#@O|6DbGP;x^(AYF
z&pvhe1h27?R@03cYk~e^%JOt^45_&F_R3D)0}edQj$Zqg|L?nd=&2ObWrpUpDw@X9
zJJ;pMCoJ<@&wNIOL4lzGsE2`rY7CABVFyq&urLTPP>UhJpiX61DggcKM`c$!0R1b&
mNX@VWMGn<HPAwxpJYe6a@^9h76YFIdfWXt$&t;ucLK6T`VW9{B

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-alpha-16-sRGB.png b/Engine/lib/lpng/contrib/testpngs/gray-alpha-16-sRGB.png
new file mode 100644
index 0000000000000000000000000000000000000000..f1e811ba342aa8d90406fb1f1014764b2b7b6a71
GIT binary patch
literal 872
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K583b5>)Uwxm)`57%LGDh>=Er@5fgGI@*N775
z{DR7&%=C;BhLs9N28PBuK*ChPD?cMo!MQXqFEcMaBQaOODZe}?wWzkF_#aSTNoGhy
ziBD#7YF;r=8fZgm9s>i%b=@9czGel1*7ctrG0N=Don9f>GTlpwr*R{<|9Z~YdVB3;
zu6q)RT(>)`^4z&PX4Pt~$SLT(cd5T%*5+w_?VC%Iit-L-$1US8+kET3(!=*{3(wu!
zXVjOhAwK)m<rBQdMp{ibW~^0XU|`Dfba4!+xb^nRPTm6!Jj{+>`<DOjyL;%V6w_sf
z=CvxC#?m|2<;N#1^IOk+MukCvp#i9efrDxcjs{@|P`I)%2ry8KA;6$cWmhTy{p&|%
sS2_UwE5k_5umnX8)jduvBR@P~->33#;ldN^Wf*|K)78&qol`;+0FSbi?f?J)

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-alpha-16.png b/Engine/lib/lpng/contrib/testpngs/gray-alpha-16.png
new file mode 100644
index 0000000000000000000000000000000000000000..689879737fc6df3cb65e3b210067b9ddbac53a38
GIT binary patch
literal 859
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K583b5>)Uwxm)&VJ<64!_l=lp`oqRjM+5{8uu
zMh1q)IzYly!7D!_Pr<n~FE2AMJtHw!!70ByC$*@yr1&3DUrA<2M2Syka%x^NP#S1x
zY90dv$93HvU%qAqf!6h(9x=-7&YfN%*fQNqiKlTRxBq(1*m`^IWUhM>iCniktMc5r
zI%d^st;i|py?3d<VAkeoeeIh|l8W*UX2&h#FWY?UzS6_@Z41xc+Go_4tRX)8)a4Vr
z#ztCAH)gC=V_;y)@^o<wskrs_%1+(`4m`|`Ui+5+@4I{GsT9*?hUT>@n#R&Q*X742
zEc08>d`5*qfuRAYhk=7?42}k22T)M5FbFVEiy^?EPGwgr0R8JnWmh@?{VT&r&9DST
h4%IzQEh9fXVBe?mZ{fld>tz^#z|+;wWt~$(69BnNk^TSx

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-alpha-8-1.8.png b/Engine/lib/lpng/contrib/testpngs/gray-alpha-8-1.8.png
new file mode 100644
index 0000000000000000000000000000000000000000..68883a52d5c6828f5389a43634f81e7ad5f158ef
GIT binary patch
literal 744
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K588}#g)VJz{w?K*|-O<;PfswIv^W=RUK)yn<
zN02WALzNl>LqiJ#!!Mvv!wUw6QUeBtR|yOZRx=nF#0%!^3bX-A=#;odlsM-XR2F5X
zXOu9kR4_6yG}ZwUrV3v98F>oMrFnUodFdI6xe8AC<vFQEwI#*>fci=@Ln2CiGLuvD
zih<HV2c_mQFmPPg?eXPnRuE`i|LGB<%<kOj6@o3(y_9$wH*)*0=Zvkl*G}fTCy~f?
zyR$0KovUM3t=5X1g5G<V`U_@lp4QjCxg@D5?_hS^GXAp7x9%%FeBZY4+^u~^eaRZ)
zvrk<<!E0=!)pTRVTA;recYC@xhE&{od&v+O9vp`^@cv&^`O!g&J9pK2-&5&q1`KQm
w7$g{&6Bu|J7zda$C>#L^h5-%<up_QB9Z6#5E8C&Gg8>LUUHx3vIVCg!0N07Ip#T5?

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-alpha-8-linear.png b/Engine/lib/lpng/contrib/testpngs/gray-alpha-8-linear.png
new file mode 100644
index 0000000000000000000000000000000000000000..cdc07031d7faddef7b738b60f3035a067bf1a3c4
GIT binary patch
literal 744
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K588}#g)VJz{w?K*|-O<;Pfw66Y;frbUK)yn<
zN02WALzNl>LqiJ#!!Mvv!wUw6QUeBtR|yOZRx=nF#0%!^3bX-A=#;odlsM-XR2F5X
zXOu9kR4_6yG}ZwUrV3v98F>oMrFnUodFdI6xe8AC<vFQEwI#*>fci=@Ln2CiGLuvD
zih<HV2c_mQFmPPg?eXPnRuE`i|LGB<%<kOj6@o3(y_9$wH*)*0=Zvkl*G}fTCy~f?
zyR$0KovUM3t=5X1g5G<V`U_@lp4QjCxg@D5?_hS^GXAp7x9%%FeBZY4+^u~^eaRZ)
zvrk<<!E0=!)pTRVTA;recYC@xhE&{od&v+O9vp`^@cv&^`O!g&J9pK2-&5&q1`KQm
w7$g{&6Bu|J7zda$C>#L^h5-%<up_QB9Z6#5E8C&Gg8>LUUHx3vIVCg!0Ab0n(*OVf

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-alpha-8-sRGB.png b/Engine/lib/lpng/contrib/testpngs/gray-alpha-8-sRGB.png
new file mode 100644
index 0000000000000000000000000000000000000000..7c37c88836fcb80c0470388e24ff7eae95d7c223
GIT binary patch
literal 697
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K588}#g)VJz{w;*0|kh>GJ`ElQ1AV;UfHKN2h
zzo4=xGd-h(VWonRfuXSukT6y7%FoDCa4yZu%gjs9NX%7m$}i7JEvhXk{s+`ok{J?F
z;**)2npX^z2HKFC$H2gGUAM=VuUSE$b^WJDj551(r&kEJO!rdaY23)|zn(L;-d;PI
z>z+g+*X_=#Ja?{+S+!a#ateCyUFt8GwRu`!`{t6QqP&CIam)D2Hs89h^zeP#!gIIw
z8TBP=h|fNC`2?@Akyg`<8Ee&me%S5l;uunK>+K~&pa(e)Z{YpEsPdzO6nE~b^S-Cj
z*$f!i4lqbCFefnZG%yY@XHYl-5)1<z5@1JMXF8I^%vZKUc?Sa!c)I$ztaD0e0s!;_
Bq`3e9

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/gray-alpha-8.png b/Engine/lib/lpng/contrib/testpngs/gray-alpha-8.png
new file mode 100644
index 0000000000000000000000000000000000000000..eb0a92499810b1da4ca73787f7ca610339f40ddc
GIT binary patch
literal 684
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K588}#g)VJz{w?Im##5JPCIlrK?C^J2ygkhzE
zk%6JH4v;Wa@XF7~Q*bWL%gfA5&q&NwaLO;wNiC`^DgFo4SCSbLQR0)CoSIh*lm;4_
zn#aJvab35^m#<ktpmqJHM~pJNbEj7bwoLa@;%VH-?Z2Kgw%%Slnd_cJBG>KCsyuhD
zj#;%@D{=~Y?_KIIn6-IYU;E~gq@uio*>TJG%QoM-uk`SJ+ro3V_8IjhYlzQ2b@>FZ
zv5{8OjTvjzfS%ax>EaktaqI0RL!h5H4sYQ7zo_z~gA{k}s`I|5(%B3c*bXpAFfb=D
q@H8+EFlSIW0ul@Z91>thTxU9x#LQQ=LwN@S5O})!xvX<aXaWEuS)s`Q

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/makepngs.sh b/Engine/lib/lpng/contrib/testpngs/makepngs.sh
new file mode 100755
index 000000000..eb1c15fc9
--- /dev/null
+++ b/Engine/lib/lpng/contrib/testpngs/makepngs.sh
@@ -0,0 +1,94 @@
+#!/bin/sh
+#
+# Make a set of test PNG files, MAKEPNG is the name of the makepng executable
+# built from contrib/libtests/makepng.c
+
+# Copyright (c) 2015 John Cunningham Bowler
+
+# Last changed in libpng 1.6.20 [December 3, 2015]
+
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# The arguments say whether to build all the files or whether just to build the
+# ones that extend the code-coverage of libpng from the existing test files in
+# contrib/pngsuite.
+test -n "$MAKEPNG" || MAKEPNG=./makepng
+opts=
+
+mp(){
+   ${MAKEPNG} $opts $1 "$3" "$4" "$3-$4$2.png"
+}
+
+mpg(){
+   if test "$1" = "none"
+   then
+      mp "" "" "$2" "$3"
+   else
+      mp "--$1" "-$1" "$2" "$3"
+   fi
+}
+
+mptrans(){
+   if test "$1" = "none"
+   then
+      mp "--tRNS" "-tRNS" "$2" "$3"
+   else
+      mp "--tRNS --$1" "-$1-tRNS" "$2" "$3"
+   fi
+}
+
+case "$1" in
+   --small)
+      opts="--small";;&
+
+   --all|--small)
+      for g in none sRGB linear 1.8
+      do
+         for c in gray palette
+         do
+            for b in 1 2 4
+            do
+               mpg "$g" "$c" "$b"
+               mptrans "$g" "$c" "$b"
+            done
+         done
+
+         mpg "$g" palette 8
+         mptrans "$g" palette 8
+
+         for b in 8 16
+         do
+            for c in gray gray-alpha rgb rgb-alpha
+            do
+               mpg "$g" "$c" "$b"
+            done
+            for c in gray rgb
+            do
+               mptrans "$g" "$c" "$b"
+            done
+         done
+      done;;
+
+   --coverage)
+      # Comments below indicate cases known to be required and not duplicated
+      # in other (required) cases; the aim is to get a minimal set that gives
+      # the maximum code coverage.
+      mpg none gray-alpha 8 # required: code coverage, sRGB opaque component
+      mpg none palette 8 # required: basic palette read
+      mpg 1.8 gray 2 # required: tests gamma threshold code
+      mpg 1.8 palette 2 # required: code coverage
+      mpg 1.8 palette 4 # required: code coverage
+      mpg 1.8 palette 8 # error limits only
+      mpg linear palette 8 # error limits only
+      mpg linear rgb-alpha 16 # error limits only
+      mpg sRGB palette 1 # required: code coverage
+      mpg sRGB rgb-alpha 16 # required: code coverage: pngread.c:2422 untested
+      :;;
+
+   *)
+      echo "$0 $1: unknown argument, usage:" >&2
+      echo "  $0 [--all|--coverage|--small]" >&2
+      exit 1
+esac
diff --git a/Engine/lib/lpng/contrib/testpngs/palette-1-1.8-tRNS.png b/Engine/lib/lpng/contrib/testpngs/palette-1-1.8-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..7bf60410d52879bca6b5a3965f040f06e0465630
GIT binary patch
literal 342
zcmeAS@N?(olHy`uVBq!ia0vp^OhC-Y$P6UUy?J{QNU@|l`Z@xIN;gm5*8$`!Bzpw;
zGB8xBF)%c=FfjZA3N^f7U???UV0e|lz+g3lfkC`r&aOZkpaffhPl)S(28RFt|2xW>
z2m(bIOM?7@862M7NCR?oN?apKobwARi!#$QN*Gou7#SEE>i`K;1+V;!JO$^{yu8f3
z^o+z@1*iP-oYbP)lHz|reI=P85hXsE$*Fn8Kxqa>hSWR;29E2xJ-&R+3IeU`KRsfU
z*_}JRLa=4Jml99oMsEN0oU!%x+R0q^Boeu9cUI-Ob9KzB)mo8L(0lJvf5EKH)B4&s
zmn0SC9n6kf#$UGi)_tXi@7orhyS2}#FIhu;_NmJ!c#Vy;nr_Tk3-mSvm#2$k2*>s0
b6O0TDc?`J`AKtD2iZXb*`njxgN@xNASRHY?

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-1-1.8.png b/Engine/lib/lpng/contrib/testpngs/palette-1-1.8.png
new file mode 100644
index 0000000000000000000000000000000000000000..73965b724e48d70cfff04a965f847929ea97a08e
GIT binary patch
literal 329
zcmeAS@N?(olHy`uVBq!ia0vp^OhC-Y$P6UUy?J{QNU@|l`Z@xIN;gm5*8$`!Bzpw;
zGB8xBF)%c=FfjZA3N^f7U???UV0e|lz+g3lfkC`r&aOZkpaffhPl)S(28RFt|2xW>
z2m(cPN?apKobwARi!#$QN*Gou7#SEE>i`K;1+V;!JO$^{yu8f3^o+z@1*iP-oYbP)
zlHz|reI=P85hXsE$*Fn8Kxqa>hSWR;29E2xJ-&R+3IeU`KRsfU*_}JRLa=4Jml99o
zMsEN0oU!%x+R0q^Boeu9cUI-Ob9KzB)mo8L(0lJvf5EKH)B4&smn0SC9n6kf#$UGi
z)_tXi@7orhyS2}#FIhu;_NmJ!c#Vy;nr_Tk3-l=im#2$k2*>s06O0TDc?`J`AKtD2
PiZXb*`njxgN@xNAtTk=!

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-1-linear-tRNS.png b/Engine/lib/lpng/contrib/testpngs/palette-1-linear-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..9b0133dc9f55261e271d8a4fc5f1dde99b272bc8
GIT binary patch
literal 342
zcmeAS@N?(olHy`uVBq!ia0vp^OhC-Y$P6UUy?J{QNU@|l`Z_W&wk<GxF)bd*S4j2<
z@?~JCQe$9fXklRZ1r%y{!N5>zz`*b-fq}tl1_Oh5!JJ)zHb4os0G|-o{|pTO|NnQC
zH4y}gFqQ=Q1v5B2yO9Ru=#;odlsM-XR2F5XXOu9kR4_6yG}ZwUrV3v98F>oMrFnUo
zdFdI6xe8AC<vFQEwI#*>fci=@Ln2CiGLuvDih<G$j0~xH3=ACCb$fjIniT|E*MEA%
zD6>0vdWB%ibT1{I#*N(m>p5fV?X{D+?nxwa-R`W)bLZ-qRjaikr=a)VrT&6ho2T`)
zZ!SqH$~%}Hw~W7R^R4?z58t;fJa=oKQD3r#`0P`cPw*NWX*J!Lu@>lU1};w*#}JO|
c$tM^Y81fi$BR;%c0TgBMboFyt=akR{0F%mb>;M1&

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-1-linear.png b/Engine/lib/lpng/contrib/testpngs/palette-1-linear.png
new file mode 100644
index 0000000000000000000000000000000000000000..bf232fd33cf07bbb08474c875067fb4497539830
GIT binary patch
literal 329
zcmeAS@N?(olHy`uVBq!ia0vp^OhC-Y$P6UUy?J{QNU@|l`Z_W&wk<GxF)bd*S4j2<
z@?~JCQe$9fXklRZ1r%y{!N5>zz`*b-fq}tl1_Oh5!JJ)zHb4os0G|-o{|pTO|NnQC
zH4y}g=#;odlsM-XR2F5XXOu9kR4_6yG}ZwUrV3v98F>oMrFnUodFdI6xe8AC<vFQE
zwI#*>fci=@Ln2CiGLuvDih<G$j0~xH3=ACCb$fjIniT|E*MEA%D6>0vdWB%ibT1{I
z#*N(m>p5fV?X{D+?nxwa-R`W)bLZ-qRjaikr=a)VrT&6ho2T`)Z!SqH$~%}Hw~W7R
z^R4?z58t;fJa=oKQD3r#`0P`cPw*NWX*J!Lu@>l41};w*#}JO|$tM^Y81fi$BR;%c
Q0TgBMboFyt=akR{0OeS2AOHXW

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-1-sRGB-tRNS.png b/Engine/lib/lpng/contrib/testpngs/palette-1-sRGB-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..1c6f262b336f2e797050c858469769bc7417361d
GIT binary patch
literal 295
zcmeAS@N?(olHy`uVBq!ia0vp^OhC-Y$P6UUy?J{Q#3>GPcVad_?i&o`um$*pxc+Bg
z`2YXEqpXP_NV+7*FPOpM*^M+HN2kO!qQp7Bpt2}4J)?wSrGk-xp|K8-Fjer%&&X47
zF3ro!%uCNm%vEs8FV9IWsx2x02h>-R84^+AlbM{FR}7S9U}Q+mV_@L8uG{0w*Q_AW
zy8hE6Mw#8Y(<=m9rh6&zG;ZYfU(Xp^Z?B!qbx$IZ>vm^Vo;z2^tXi!VIR(A<F7+48
z+B~hVeRD}tQQpDqxMlohn{VA$dicI=;kjG;jQWx_#Alzne1g~5NUQ0_jJ0Y&`?)+_
g978y+C!b(sV8~<0jrj0(1yGd1)78&qol`;+00^ID(f|Me

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-1-sRGB.png b/Engine/lib/lpng/contrib/testpngs/palette-1-sRGB.png
new file mode 100644
index 0000000000000000000000000000000000000000..fbadc097fff199cc4de801210542c2ed3f930c19
GIT binary patch
literal 282
zcmeAS@N?(olHy`uVBq!ia0vp^OhC-Y$P6UUy?J{Q#3>GPcVad_?i&o`um$*pxc+Bg
z`2YXEqpXP_P(-K1HKN2hzo4=xGd-h(VWonRfuXSukT6y7%FoDCa4yZu%gjs9NX%7m
z$}i7JEvhXk{s+`ok{J?F;**)2npX^zW?*DU&0}ETxUSpd%h#+R(7OK9BSx9sxzj5I
zTc&#{@icDa_FvB#TW_zO%ymy9k?VG6Rh~On$E;ed6*&dH_b&Ap%-TGyuYGe#Qc>Q)
z?6_t8Wt(r^S9<uqZQ;3F`;7XMHN<D1x_pAy*hs7C#*DRUK>N8oT^vI=t|y;hWMIf+
V$c^~$b_GzB!PC{xWt~$(69D&rVg>*J

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-1-tRNS.png b/Engine/lib/lpng/contrib/testpngs/palette-1-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..8f1642b7b01c30ced4d2aef6cf0823d80e79e8ef
GIT binary patch
literal 282
zcmeAS@N?(olHy`uVBq!ia0vp^OhC-Y$P6UUy?J{QNU;U@gt-1^VEF(4zoV>)AV|6-
z$S;_|;n|HeAV;UfHKN2hzo4=xGd-h(VWonRfuXSukT6y7%FoDCa4yZu%gjs9NX%7m
z$}i7JEvhXk{s+`ok{J?F;**)2npX^zW?*DU&0}ETxUSpd%h#+R(7OK9BSx9sxzj5I
zTc&#{@icDa_FvB#TW_zO%ymy9k?VG6Rh~On$E;ed6*&dH_b&Ap%-TGyuYGe#Qc>Q)
z?6_t8Wt(r^S9<uqZQ;3F`;7XMHN<D1x_pAy*hs7C#*DRUK>N8oT^vI=t|y;hWMIf+
V$c^~$b_GzB!PC{xWt~$(69CLpV&VV*

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-1.png b/Engine/lib/lpng/contrib/testpngs/palette-1.png
new file mode 100644
index 0000000000000000000000000000000000000000..a27d1362a2b59c6f76ed0188be16f8eff02e3ca6
GIT binary patch
literal 269
zcmeAS@N?(olHy`uVBq!ia0vp^OhC-Y$P6UUy?J{QNU;U@gt-1^VEF(4zoV>)AW%f7
z#5JPCIlrK?C^J2ygkhzEk%6JH4v;Wa@XF7~Q*bWL%gfA5&q&NwaLO;wNiC`^DgFo4
zSCSbLQR0)CoSIh*lxARLNX=tl;JB{a<IC5qAke!0(<4Ti-MP~%1Y4$iDe*LJ<n~|B
z8C!3!oy>JlB9ZHMXH}j%SI4Yctra;1z4tEl7tGo`t*?D^Nm5bX!R)wY{AHVO-B)_}
zzHQ;TTl<Xqk~PF<pSpa4*Vss_>Bfw;YC!wBJY5_^IIbt3U}Rv(W5|v8@OA}Il)=;0
K&t;ucLK6Vta$gnz

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-2-1.8-tRNS.png b/Engine/lib/lpng/contrib/testpngs/palette-2-1.8-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..9d2ab16564ab7c7bbdc84d1b8907946bc4912751
GIT binary patch
literal 350
zcmeAS@N?(olHy`uVBq!ia0vp^EI`c2#0(@`f}Y2L1kxRS9T^xIOE*v6*8$`!Bzpw;
zGB8xBF)%c=FfjZA3N^f7U???UV0e|lz+g3lfkC`r&aOZkpaf5VPl)UP|NrCSKo|(b
zs^)P5#hFWj{DS{K+bp-pEg#6$DRGS`an3KOEXqvJC}CKsU}RuutOF!W6}<8@@)Vp)
z^YSwD(lZis6`b<Rb5e_HON##i^_66XM3nesCa2~V1Em=l8B+5Y7&xx$_W1HOD+si%
z|MZAaW_RxN3c;4?UP?TT8@c`0bH>)&YbSHvlSt&c-C33A&ebuiR%=C0LGQgw{ROi&
zPwQ*nT#{6jcQ89{8GqU4TlbY7zHeK2?$$n|zGMyY*{3d_;59bVYPvCFEztW6T%InD
fAsp9}C$KRv$TG;NRJ~0GiZXb*`njxgN@xNA)(Lca

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-2-1.8.png b/Engine/lib/lpng/contrib/testpngs/palette-2-1.8.png
new file mode 100644
index 0000000000000000000000000000000000000000..cdcf28329b96889057f6c9c10da21423ee4f9203
GIT binary patch
literal 335
zcmeAS@N?(olHy`uVBq!ia0vp^EI`c2#0(@`f}Y2L1kxRS9T^xIOE*v6*8$`!Bzpw;
zGB8xBF)%c=FfjZA3N^f7U???UV0e|lz+g3lfkC`r&aOZkpaf5VPl)UP|NrCSKo|(b
zs^)P5#dS(tBTAg}3o45;(=$pKRw@`77#iyU2~!2H{ER#W=hD2q%)IoB#9RfZ{PLXC
zqS}(;e?WaDnIRD+KAFj>dBs3!21bU|JO&1i>$*L@e9a01t?NHMVwBmPJH0}%WxAIV
zPvb^z|Mi@)_4eAyT=ygrxo&q><+*cp%&OH|kyFrn?^1uktj*K<+BcUZ73Cewj$6iG
zw)xh5rHAj^7M{Dc&!{h1LwxqB%O`k^jkKC>%vcNbF9VmSi(?4K_2da`3=FaiGAdPX
QlYycPp00i_>zopr08LtN0{{R3

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-2-linear-tRNS.png b/Engine/lib/lpng/contrib/testpngs/palette-2-linear-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..d346d40071c738076bd4864327c3be3bb087da7b
GIT binary patch
literal 350
zcmeAS@N?(olHy`uVBq!ia0vp^EI`c2#0(@`f}Y2L1kxRS9T^zg78t&m77yerBzpw;
zGB8xBF)%c=FfjZA3N^f7U???UV0e|lz+g3lfkC`r&aOZkpaf5VPl)UP|Nkv4Ko|)A
zOo{pq6lX38@(cd|Y_r@Vw|pR1r^Gd)#5up9vM4h>ql96lf{}rtu?~<hRq)Es$Ww4G
z&CAQoOV3EmRdC8L&q*z+Eh+v7)K`)j5>eulnVgze43uVIWJt|pVBol}+vCgEtRT?3
z{?j8ynccb5D+F7ndnxfWZshh~&ly{9ubs?wPa=`)c4t+dJ6Ff7TCEj11-<t!^%u<A
zJgu*Nb4gNB-ofm+W&CBEZ{1gV_`Yr7xm){;`jR!oXP>%!g4ftctLes!wLtGPaCy2o
fhHzX@p1{VyAj=@5QuQ_&D9YgJ>gTe~DWM4fpjmZH

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-2-linear.png b/Engine/lib/lpng/contrib/testpngs/palette-2-linear.png
new file mode 100644
index 0000000000000000000000000000000000000000..5c2f6d335dfb5ce156a6541631014175b0e2506f
GIT binary patch
literal 335
zcmeAS@N?(olHy`uVBq!ia0vp^EI`c2#0(@`f}Y2L1kxRS9T^zg78t&m77yerBzpw;
zGB8xBF)%c=FfjZA3N^f7U???UV0e|lz+g3lfkC`r&aOZkpaf5VPl)UP|Nkv4Ko|)A
zOo{pq6xS(njVN)>FQ_caOwTA`SgBxSU}&rZBuo{&@-y-joJ;faGV{_i5_1)t^2>8l
zi)u@X{{i)tWQIhP_+%!h<`n~_85kK-^B5R7uIu*r@--_6w66d3h*4&D?(_=5mg!zf
zJdGQ<{nvBG*4t|*bKR3j<htEimFLdYF{@T<MNUEQy-WQCvo=rbYu{XwRFroxJ8l_&
z+2&jKl^(utTX^o)KBK;54e{BhE}!5vHqvUkF=H*zzYJWSE{-7_*OMo(F)+w7$f#7k
RO$LfGc)I$ztaD0e0ssqKZ`A+*

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-2-sRGB-tRNS.png b/Engine/lib/lpng/contrib/testpngs/palette-2-sRGB-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..e5a491a7139b9db671d71c463f8acacf8c5175dc
GIT binary patch
literal 303
zcmeAS@N?(olHy`uVBq!ia0vp^EI`c2#0(@`f}Y2LIK@HkPR!=VeS?7<o&cW^*Z=?j
zH#C4S5L{T8kOmZIE(!7r{{L*V+#<JpAXlfvHKN2hzo4=xGd-h(VWonRfuXSukT6y7
z%FoDCa4yZu%gjs9NX%7m$}i7JEvhXk{s+`ok{J?F;**)2npX^zW?*DU&0}ETxUSpd
z%h#+R(7OK9BSx9sxzj5ITc&#{@icDa_FvB#TW_zO%ymy9k?VG6Rh~On$E;ed6*&dH
z_b&Ap%-TGyuYGe#Qc>Q)?6_t8Wt(r^S9<uqZQ;3F`;7XMHN<D1x_pAy*hs7C#*DRU
lK>N8oT^vI=t|w1mV_=YFkWs06n+z0X@O1TaS?83{1OPHiYJdO$

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-2-sRGB.png b/Engine/lib/lpng/contrib/testpngs/palette-2-sRGB.png
new file mode 100644
index 0000000000000000000000000000000000000000..a3bf9a2f3b0e5c39cec1140880877246e0a78fc5
GIT binary patch
literal 288
zcmeAS@N?(olHy`uVBq!ia0vp^EI`c2#0(@`f}Y2LIK@HkPR!=VeS?7<o&cW^*Z=?j
zH#C4S5L{T8kOmajDRGS`an3KOEXqvJC}CKsU}RuutOF!W6}<8@@)Vp)^YSwD(lZis
z6`b<Rb5e_HON##i^_66XM3nesCa2~V1Em=l8B+5Y7&xx$_W1HOD+si%|MZAaW_RxN
z3c;4?UP?TT8@c`0bH>)&YbSHvlSt&c-C33A&ebuiR%=C0LGQgw{ROi&PwQ*nT#{6j
zcQ89{8GqU4TlbY7zHeK2?$$n|zGMyY*{3d_;59bVYPvCFts2mNE>9Q75RU7~6WACS
XWEo^ss@^68MHxI@{an^LB{Ts5KSE^*

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-2-tRNS.png b/Engine/lib/lpng/contrib/testpngs/palette-2-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..c34a6986d008247f312c147f0f368941cdc4fdc7
GIT binary patch
literal 290
zcmeAS@N?(olHy`uVBq!ia0vp^EI`c2#0(@`f}Y0#DV_kI5ZC|z|2H&%Fc4f=n2-h(
zXD$iy3;zFXv)m%Ld>~h+#5JPCIlrK?C^J2ygkhzEk%6JH4v;Wa@XF7~Q*bWL%gfA5
z&q&NwaLO;wNiC`^DgFo4SCSbLQR0)CoSIh*lxARLNX=tl;JB{a<IC5qAke!0(<4Ti
z-MP~%1Y4$iDe*LJ<n~|B8C!3!oy>JlB9ZHMXH}j%SI4Yctra;1z4tEl7tGo`t*?D^
zNm5bX!R)wY{AHVO-B)_}zHQ;TTl<Xqk~PF<pSpa4*Vss_>Bfw;YC!wBJY5_^IIbs8
aU}IpAWsp&+dYcRsW$<+Mb6Mw<&;$VQsb`P?

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-2.png b/Engine/lib/lpng/contrib/testpngs/palette-2.png
new file mode 100644
index 0000000000000000000000000000000000000000..eaf4536e09bed285c717cf5babbee81b156b7d78
GIT binary patch
literal 275
zcmeAS@N?(olHy`uVBq!ia0vp^EI`c2#0(@`f}Y0#DV_kI5ZC|z|2H&%Fc4f=n2-h(
z*C}z0C~?j&s4U7%&nRJ7sbFMaXsiPyOclKHGx8LiOY`zF^U^aCa}}KO%X3nTYD<d$
z0riz+hD4P3WG1KP6$7Oi7#ULY7#KLN>-PBaH7f|TuK)CiQD%4U^a{b2>0U}ajT^cB
z*K@|!+iNFt-IGY<y4_io=g!qJt5$18PC@UzOZ^42Hc#to-&~SZly@*YZW({s=3Dob
z9=>l|c<$CdqrPMf@!6*?pWrn%(rUUfW33v{elAZJ#}JO|$rIQZ7-Sh_RI1)414S7;
MUHx3vIVCg!04Tp=82|tP

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-4-1.8-tRNS.png b/Engine/lib/lpng/contrib/testpngs/palette-4-1.8-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..20cb465cece78b066cfdb2a5c972b870bdabf3f6
GIT binary patch
literal 400
zcmeAS@N?(olHy`uVBq!ia0vp^0zk~j!VDx;!;N!*6id3JuOkB^W9jC}`#OMpg=CK)
zUj~LMH3o);76yi2K%s^g3=E|P3=FRl7#OT(FffQ0%-I!a1C%fb@CkAK|NsAr760Sn
z{wpbgSSuP=#Ko;pvI7YLSwNr!mRn&5q?ME!m6Vbhp8@sqmjw9*|Nr#t=FO8kS8kr)
zQ`u9NFz?wfZlIJ-iEBiObACZ(QD%BZ3ByVSBLhQY9Ux(<;FX_|r{G+gmzSBBo{^ZV
z;FMpUlUh_;Qv467uOu@hqQoaNIW?~sD9ymgkebK9z;Ru-$Cs~JL7;X0r$>x3yK|>k
z2)0c3QsQac$nC$LGq&DdJDKaAL?YMi&Z<0ju8vu?S}Sr2dhcE8FPOD?T3`F-lBA-%
zgV}M*_{%omy07%`ecQrwxAqzJC2NS!K6Uv7ud$I<(~TKxfx*SV<LTlU!f`!0C8UXg
Yf%y`{$CEi7=Yir3p00i_>zopr00W|r^#A|>

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-4-1.8.png b/Engine/lib/lpng/contrib/testpngs/palette-4-1.8.png
new file mode 100644
index 0000000000000000000000000000000000000000..c2318ff82ed838af1bbb7bae3422588947958c9b
GIT binary patch
literal 373
zcmeAS@N?(olHy`uVBq!ia0vp^0zk~j!VDx;!;N!*6id3JuOkB^W9jC}`#OMpg=CK)
zUj~LMH3o);76yi2K%s^g3=E|P3=FRl7#OT(FffQ0%-I!a1C%fb@CkAK|NsAr760Sn
z{wpbgSSuP=#Ko;pvI7YLSwNr!mRn&5q?ME!m6Vbhp8@sil(<HeIOi8s7G<VqlrXGR
zFfuSS)&UZx3SRjcc?!;@d3l+6=^2T+3QqauIjKdpCB^@M`bsiGB1(KRlT-7Gfzk|&
z45@hx3>?>Wdwltt6$Dz>e|p3yvpaWsg<#8cFD0JFjokk0Ib-YXwUfE-NhEUJ?ySml
z=jxbMtF<Dhp!eRT{(@PXr}edOE=elNJD44}jK6I2t@}z3-?uG1cWa+fU$Tby>{FLd
x@ERLwHQku878oWBJf1F&Asp9}Q$m^;7?>|Hd_0-caULkn;OXk;vd$@?2>>5Lfr$VB

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-4-linear-tRNS.png b/Engine/lib/lpng/contrib/testpngs/palette-4-linear-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..4d96a47241327d17d0c749411ec888d23a267554
GIT binary patch
literal 400
zcmeAS@N?(olHy`uVBq!ia0vp^0zk~j!VDx;!;N!*6id3JuOkCv+XBNE)8c`Ag=CK)
zUj~LMH3o);76yi2K%s^g3=E|P3=FRl7#OT(FffQ0%-I!a1C%fb@CkAK|Nnn``+p0I
z|2#Y(R(n*tg+)7$97qVr0s<beT)P~Q=HZFr5lX-D6R4NJB*-uL|EFg+Z=T$_a`XJ2
z%AT@>dCz`v1Eq9ITq8=H^9w4AGSf3k7*;A685kPt00~nCul$TW1?SSdyv)4xjKo|8
zr~LAq)S}vw;(tJWC7B@+B|e$Ssd>dfX$D4y)I0_Tj_bNTzI@FJ0<G&mJz|vEojbik
zuw}ZJ5>MksZvXY1vGw-a$z1m&61i@7R^_>Kb<C>OT9H%Gd+$<z!K}^G`r0>_Bo*Zy
z%#K^eU$*(yeWi!*+ZLX?wa=(8SwnpGsmmvLjg7RLZp>H<3@!#9PZ!4!j_b)OAx#Vn
Y%$FEGp3Lbu4-{wcboFyt=akR{0N?727XSbN

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-4-linear.png b/Engine/lib/lpng/contrib/testpngs/palette-4-linear.png
new file mode 100644
index 0000000000000000000000000000000000000000..dfc5a868ee2413ffd6e34fa8d2e389db674af3a7
GIT binary patch
literal 373
zcmeAS@N?(olHy`uVBq!ia0vp^0zk~j!VDx;!;N!*6id3JuOkCv+XBNE)8c`Ag=CK)
zUj~LMH3o);76yi2K%s^g3=E|P3=FRl7#OT(FffQ0%-I!a1C%fb@CkAK|Nnn``+p0I
z|2#Y(R(n*tg+)7$97qVr0s<beT)P~Q=HZFr5lX-D6R20G#5JPCIlrK?C^J2ygkhzE
zk%6JH4v;Wa@XF7~Q*bWL%gfA5&q&NwaLO;wNiC`^DgFo4SCSbLQR0)CoSIh*lxARL
zNX=tl;JB{a<IC5qAke!0(<4Ti-MP~%1Y4$iDe*LJ<n~|B8C!3!oy>JlB9ZHMXH}j%
zSI4Yctra;1z4tEl7tGo`t*?D^Nm5bX!R)wY{AHVO-B)_}zHQ;TTl<Xqk~PF<pSpa4
w*Vss_>Bfw;z%XIp@pN$v;kcfh64J!Lz<i0}<H?+k^FVP1Pgg&ebxsLQ0AvGws{jB1

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-4-sRGB-tRNS.png b/Engine/lib/lpng/contrib/testpngs/palette-4-sRGB-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..92d23e7ddab4ee1ce549e649de08b5a03fff0976
GIT binary patch
literal 353
zcmeAS@N?(olHy`uVBq!ia0vp^0zk~j!VDx;!;N!5oZ=vNCuZ~GzQI6_L4Z$)>;M1%
z_wWDT(D2{E0mRxre}6;6euo5*5Re4~4q&<c2|(JxVZMW$$>cnsUjC9Gzu^C$p5458
za_7p;^Lr|L$`a;1`^62E(kXF`C~?j&s4U7%&nRJ7sbFMaXsiPyOclKHGx8LiOY`zF
z^U^aCa}}KO%X3nTYD<d$0riz+hD4P3WG1KP6$7Oi7#UK57I9qH?eXPnRuE`i|LGB<
z%<kOj6@o3(y_9$wH*)*0=Zvkl*G}fTCy~f?yR$0KovUM3t=5X1g5G<V`U_@lp4QjC
zxg@D5?_hS^GXAp7x9%%FeBZY4+^u~^eaRZ)vrk<<!E0=!)pTRVS~Z~kJf1F&Asp9}
dQ$m^;7?>|Hd_0-caULkn;OXk;vd$@?2>>lMh=c$D

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-4-sRGB.png b/Engine/lib/lpng/contrib/testpngs/palette-4-sRGB.png
new file mode 100644
index 0000000000000000000000000000000000000000..26ea9e5ab1490f215d2039b6ba673694ffbcaac2
GIT binary patch
literal 326
zcmeAS@N?(olHy`uVBq!ia0vp^0zk~j!VDx;!;N!5oZ=vNCuZ~GzQI6_L4Z$)>;M1%
z_wWDT(D2{E0mRxre}6;6euo5*5Re4~4q&<c2|(JxVZMW$$>cnsUY!!xh!W@gg36-I
z^o$aQl?p}%hQ>NT!c@U4KO;}Uxil{?GcP?OF;~GUzdR?ksJ5i|A5dROW=KSdPiAsz
zUNKObfsr8<Xd1_L-5y`QW(9%P^`9Ow%IwaaULn{r-Ajq5aU-|?dd}E-d+lVddlHFU
zw>zuy+_^et)oQKCDd@d-slQ;>=4pNHn@f_4@(yOlE#oiSeCxi_!}o0q&)wQ*)R(Lw
zKKs<=6THSoT1_`*tW^Wr&*SOh7{YNqIVGftfr0rF!^e|39p{1K44$rjF6*2Ung9{c
BdKdrz

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-4-tRNS.png b/Engine/lib/lpng/contrib/testpngs/palette-4-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..429f6b95394f3cefa274d8235a861b8f6b8ece3c
GIT binary patch
literal 340
zcmeAS@N?(olHy`uVBq!ia0vp^0zk~j!VDx;!;N!*ltF+`i0l9V|M&0z-_Y>i!2!hD
zKYxEi!+wVZkPwgs1P)-i{Ru$Y!C}6GoXO-opkDrxAiv=MpPt>kd2;8<&GUOId&&~#
zJ^RHCl+r12jVN)>FQ_caOwTA`SgBxSU}&rZBuo{&@-y-joJ;faGV{_i5_1)t^2>8l
zi)u@X{{i)tWQIhP_+%!h<`n~_85kK-ffjLG*X{A;YgQ0wUH|D3qs;Ey=@o)4)4h~<
z8aHzLujh=dx7SYQx+jsyb-S}F&z-AdR;|{GoPyqam--84ZJyTGzPTi+DDPl)+%o>M
z&A09=J$&D`@Z7C^Mt#W|;<Ha(KEZ2jq}6m|##%L?{XCv7jv*Y^lT$*P7#Nr@F?>9k
S({Uas&fw|l=d#Wzp$PzE{e_eO

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-4.png b/Engine/lib/lpng/contrib/testpngs/palette-4.png
new file mode 100644
index 0000000000000000000000000000000000000000..82f3489940e4916a1a78a74bc85ccc370b9d33fa
GIT binary patch
literal 313
zcmeAS@N?(olHy`uVBq!ia0vp^0zk~j!VDx;!;N!*ltF+`i0l9V|M&0z-_Y>i!2!hD
zKYxEi!+wVZkPwgs1P)-i{Ru$Y!C}6GoXO-opkAF4*N775{DR7&%=C;BhLs9N28PBu
zK*ChPD?cMo!MQXqFEcMaBQaOODZe}?wWzkF_#aSTNoGhyiBD#7YF;r=nt_oa6=)jA
zb=@9czGel1*7ctrG0N=Don9f>GTlpwr*R{<|9Z~YdVB3;u6q)RT(>)`^4z&PX4Pt~
z$SLT(cd5T%*5+w_?VC%Iit-L-$1US8+kET3(!=*{3(wu!XVjOhAwK)m<rBQdMp{ib
qW~@~M+Rx+Z;uyklJvk+$iGhLn62r%nIUVPL;tZayelF{r5}E*)=XWRo

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-8-1.8-tRNS.png b/Engine/lib/lpng/contrib/testpngs/palette-8-1.8-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..c10bb56973957489e019a3bd11a4f50318d59c9f
GIT binary patch
literal 1360
zcmW-he{2**6vwCH8Z3-Ik|u+uDa|A_@<Rqnnrfp%DZRi^hI0K8ngUDfdG=b`;cO31
zu&td!Db#`xhJpoaNd2*3ph6WD2V#pNsE7^%0tNz!W)u<<qJL<N>umRr+5PN$`|{rR
zy?tAkE?EH6pG*e;!0^K2G62%-BS;%R&Yll-cZBTi!Mb^D9!N`DJG|@E7R%Yug=GwY
z4LJaGYy#jP`>MkLuyz&zf7Ad_uonQ7*ncAO9023M(!~`a-}jC2wf2?rJ<pfY7sBV<
zcU_+`pHiO?A7dXOA41=80&jE4=uxAFj5lCpuMw?=HyYP9tklpVL-GusYEYJe8OE6q
zgf^pEAJb}3ds53TEmE2{XxG&&qG?Ez0*#4AIT~haCnLzi3@JURRG;#Clx$a`Me(?D
zUB${34J%TpaK1t_70gjiR*<wA@U-+)kLL+braZwt9`jt+W0f9d9tnAvdMMw6#B-(w
z6`EeDyQFHDUP{V@6b+I`rRz#oC22&G5{W|+6-rnjoxDH}(<*dIs21UIAsd8<30^B)
zSFmb9D+P%N%mfMx7!poVpq**tx`C@W_hMW|xv1rQ6?a|ER&ZL)NfpPH9F=nz;ZA8F
zwAIeaVJoyr+dOP&>uoRQy3}=v>tfeMt_xk)8S9EEWjexCIrA!+tYV^?@fFsWu~m%L
zG7@Dt#!#HW2Ie#dEi^?`ho}luk5L(+qLT7z8<?_MN@J8XP|PW6p)f_A)}Y@ekLUuT
z3W*mYvV@2T;Z-&Z!lHyW5RxD`MNm6|UBu}PhQmz7nqZZWJ&I)r3x;{6O&PNorW}(L
z#sZ@r3?+63f=M!2Nar9m6M6Ya79tTwyxi7@SRBz7MA{MVL8uSGLF5btV`nm;&V(ul
zdIZV>C_<1&tQe3rK$?Q23t|b;AcV)DGaAgOnc(OQM`bzQR7d7HqR8Q;Ryl_?I<(ax
zy$&95(2xU19p{qsK<G}f{Ym^}*^+Yq-@pI5fA8+^zumt1%hk*Jf`vQg*IPHPUHR#U
z^XJZ-zB>k&FJAcW?3W`aPaMB}^ZJ!B_(Fa5@zKMFu3q}_{JF12P6lxB-2-o3`1b45
zr%oI{cI1$SH+SziGjj6Nk3Rh1{lS6$-8;8!*`z)h4ov&^?AqSb)zO+7K63D#xA*n!
z?CsvzzCM{)ZK;3vj@LJf)>Ly-JnD{7SI4XCUT%D;cEz%?K5Mg-SRJcbUb(a+)Y~mu
z$EdoZG+a!d-Po40o;3l@fBu==8S7h`>S~u)29!U0`jp9u`sm7Kk&<F+ZBr&cF*kpg
zYo(Zx3{@rPuSu+LuCI$H!NKg@S+nQNut#3@qBU`zJ%26d^}H@#+mv0jCe;{gZcDcO
zXTM9<S5zez*GFT##hUG|ig5tOUwOKhJ+d+Tv96)}x6?8|Z`$+9<D2#@!V|^O38h01
zuY7Ip^l18xNww+Mw{GAI(zo=tP4gNP+ivJL68*z{+q;L8FEsO!)$V(bt{c8~6W_YG
z`M~$rPUUWoK85yubMY*klRK^R=e>vRx&sr##q%mAU5vh%c?*Ef&a?++xBY3?9RT6b
LlHwypHJ$$h>0Uyi

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-8-1.8.png b/Engine/lib/lpng/contrib/testpngs/palette-8-1.8.png
new file mode 100644
index 0000000000000000000000000000000000000000..cc09ee60f1e7c375ded9e848697ac5e746d1afbd
GIT binary patch
literal 1093
zcmW+#O=z4&7@ln%shf^J5SSt%EOQ8^)=rxe0zt-Pn~!$ePSb6&u!K78x-QwQ+sTsM
zxLT5!iCx=<SPu?qsS=QYj0at8ZtYMoC-LB6N>M6Q>S@q}Af7z<IiGWw-*;Y~_j#Y^
z#<{a6Q2OOG008AqPMilI6}BL?Z*Q2Ny|x;K<(b)WJ`Pf;#hp(dTo30=`Q&*Hz?A_2
zR<8o^Pq<q304yE>;P*=ajNS$SH$K0Ye;t6m;M|$%D2`+AW9MRPV`E~iW2Is#V<BSB
zW5!}iV?tt#V}xP|lW70QyIpU)-fVfj;nk9tbuWbHlb&Tg9rk3<<9?5NJ?u$R`(5Ym
zI=k(RcDmzK+sT>}!tuOgk)xxIP=^N`>T|F+!Qs2sZCkr(&AQbqRyD1xS|Kc-vMgum
zm?a|?AGT<~!u|xb-!e`cyKam!x^0v+vSNfVykHnNG%|!4JYo<va4@ORZ)n%ic14@E
z)(x#{T9&mCnin<8YkFFfNaHb$Ml~Ex=<rL*wUuouBbBZxRZ+5}giw4&v4Wy`MYzH_
zg(3yB33t9OT}|4mG!?1KQkA5<D20&xf@Cw279}Z2JS9<H!pVf_z+IptR2V=993gdx
z4ucE9grGtYA+Qig2>5?j{3LgIZl|~@a9!kThRX{fmh+38l{hVPQsKDDQH{fT(n6nQ
zE@C#v3}-seRDsEvkeKljV--egj7Wx?47C|tO8V`GsT-wsjGBn*(^TcDECv*mmno}J
z+MuLO@d`y93O5pQ_(9?*u_MGVq9dX>k%a)6@Csp)&^958;B|sDfm?}^d_Q&r*dE4a
z1nV)Za#&7<`Y^9z*2HuLlXZ+YG1|tko5;@hBG-rP05TNmQKTXy^MMS+YlyWG?I5BN
z-bUyyg1d=EeGhcK(Dp+!2=y>jStut1bCA~|TY_{0k}Zh45bZ+v2=0mgm<T30)QXC&
z<MWO87v^TGE$~%l=*ZDyhr%?RIW=FEnd6I6&dJ$o>2fAJ->z2{mRrq#!@t(tbg^}2
zu3VAL@Ei<UkpS%b>9r01{D+wrJKev2OZDBqeCxfJuHHID_N#AuCcDqQ`N12nmeWrT
zl+wT4xFS!auisfdXzGoRpSVvNcXl>!UfXHCwIIKHM|}ChyE~76B~SnS=!+j8KNz}M
zeg%K_!^7{<v7v)&Ki~d3cpU7{O^i<;cvybB?<oLlYpFd)m;VkP2Ot-no%kkuY3)Br
C;i|6y

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-8-linear-tRNS.png b/Engine/lib/lpng/contrib/testpngs/palette-8-linear-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..27f5a3336cffd32e8d290509aa4c6ababd82c32b
GIT binary patch
literal 1360
zcmW-he^6CL6vubnxTCL?XxtejoD0Yp&f*(<NP3O%4L;tiApUp+BeSMJKo3S?37?W8
z1^8pN)MQjNv>!YDLK`)stW0-8%d|2}OH;c#I#Xlij5ALCQB&Raa{t(SKlhw_=A7?2
z_iSD`pN$PX6aWB>EuB+R0RS|Q0FFlHv}AYG-0q7P&npIS<7=VY{WXR&>*rL=17OX=
z0CcYh;BWJ)`!)b8rvmU>EdY=10U)()-?7+Z03fiiyfW%}p6hyAdrEmydO~=ddyILG
z<5B9_wnvDEv1eHxLLP*^w|mmngRbgxWv46RF0XP~)O8$}=DK#4OHy5&;#vV0CAn~v
zAKD$%dZ$)BS_&;{G>>T((T<~OP}|v>q-#vHm8{Vi4U_yl+&-mylxkP9L5XU`%M~kD
zj-zOvvU3#4P&iFl;}l9(FyJTcc1kUzYLJpk5tE!r7M6}9X-L{sl5B}>X{AX-Buw!u
zbmKzT2vsd)Oo%eUBZ3tP#}PDN*g-)i3!E*i41v-GO!eh(tGJGFRn8^jBEor?vqJ7T
zoEC69#7U52%B>uZvN_E1wR59PN0=&RGR#B~<AsdPWRAn=bY>SYlFx96S$PZv8O-&C
zHrg3EOob+ClZOdyyv;=&$95dzIM{J4$3cz*N4nzXQXQl!kIE1g`IHw>Hr@DAI+NOk
zloU}MrdBaU5elPz3*9VRXWJ^rmedwOn}=*xU;^8;(6+-iiP)IgR=JI0Hmvgd?WPi)
zPE-bw*+fhxJV;o+$%4=#Vn+xmBREE^YJzGAjQhjkreIC5O2g8|A{%pxS;(Y}X&BoK
zlNiPvTMZZq3_JZvas!r5w$wOFrdcAx;yD(}Gxb@t*s{wlQf=V|%WAh!j|Kbuv2&A<
z9)naek_3r##Iq3#8Zi)!AUlRg4Z;FhJqYbYaL}JocNEk~Pz9h&fg%<1EXZ<=a*#%$
zT?I)T;!bGwK{N>ANtiNg(ZA*=@e&pDANT(G>(6_4@BI49ts6gGxpd*Yf!}ZceDnI%
z%in){?(FGPcShjS#q(dE`E2;av7@(cT)R91pC14CgChqIT>0U<b7wyvKH<auH`UAM
zzxv{oK6doILkA4Jv}^n6;S(Rd|L!|)zy8X=uD-3C)*t_H$T#iVy<^++8@kta3?174
z#;be#`?kn+&#q3iEi*K*Yx@fud)9Wew=~r+9ia`~ovWT+{#4x)iz@n!%~0F2#@fYI
z3+G0+$ey($#48t+mdu*DuB*d%*7_7Fa`LCFUeOY-TU_PSj8N{RjJD?bC5vKnOJ*6{
zq>Qxij2%mj6jKt>>O@4et!{6QHzmOS%>1dLX;aMcNM@O6YR!zSY;A3BjW^Y`WX={H
z%NyIf5-a{Q-zAzWs}tqT^^L77jM?m}##R7EUk+}Wm%J`BWy9fnx8Q_NT6RD4;QHNV
z6LHUx`xhJ@v*fvOZhheT_`1Ng&1+g&VADVs9bDeF_4<Vu+XjaEx5=TzlkKg;%a*?N
zz^b9EHzwY^yHR~}Rp)Q3pPah)%Zq2mPRpmgKkhkb)*Zm5CB>EFFV;6qxCuaSFB}!>
S`opX{07|3tOAgJh?foBkCGgw;

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-8-linear.png b/Engine/lib/lpng/contrib/testpngs/palette-8-linear.png
new file mode 100644
index 0000000000000000000000000000000000000000..40d413cd660350acbc6346e5894d196db7ccc59e
GIT binary patch
literal 1093
zcmW+#O=z4&7@o<Pp;;&EN(Z(vWwPml36n1AZey7m<Ffs-OcOS>TM}FbbX$|K3AQ_7
zyY;6bn8ez#pp`&rOZDJfBp$R#ZVChTBpy82gHoAFJrys4coOt;KIbsM@4P(k^FGhD
z)2C#A>X{S(pnvA%^cetP*aEl@g&CX8YFM6VRpu%HUj4NA_+~SlbBia>%mHxuSpYV#
z0PuIX+I$Sar6U0Reine|Zv&8B`{e8T3jiQ+x;9^p<JkMyx!Bs+m{{vrsaVQbh?w)3
zv6#}BkQn0_p%}s>+TZhT*V`R$*1c|dwcusd3*q^gXTzRmJ;`{S@~GFto+P#3b?%0<
zTh3^wn@-i8jGPdT7aYqwI_L;>IPFlMgS`n3zhm8&wH<4gtZrCUv$A4^uzcLI5le?G
z8L)W2MQICD3247=oHlmJ7-e+bC~0Kb2w`~9Fm7nx5N7azLDaxZQlW2Y*VMM5O<n6*
zts*U_v=Ew?G%IL2s!3ksA&mw#%qDdB1?B3>)|8P-M@p5IoK!+6KA~7q(Sjme;Sq)M
z3JxdS`Kol0v=wQ}Qcp=WDdlk~gyhF0n~=05Nm1f)i3$>qB}51A0v(~k06O3ZsY7%a
zTnHuv6@mzXg+M~U|GVPHxGQiw&P|c)5?2#k9t*LYALne6(<x5M99KAsIIJcu^ux^M
znH^z<GhJY+$mB#w%=jc@Wkw@LB*Qg^>I^O<{q|Yv2B{sQCQtP!RRt<b0R`n#ltq-z
zQc|b5K~a;!Rw53cA&wF|Knx=~PZTGz7$6f~CQK4qCqxmvM35$MJyDWRVVA~sKQ;qc
z4`DTe<#?zM^9p7)OdFUiVcfxJ3&Wj6cD@(6K4jC#P^1Tu$|G3_WFQ_PR!6jnh(>q|
zp&JP9CK~lU(Dg!_f+hoX7OG(=#{zSZS0P(~v<1mJ#5)k}LU<2mUVQnVV3Nb#YNH$J
zwYNK~t(7kLJXbnWJbE}x&*f(IN;?-_YPVP0t(9{Zawqhg=a)Mh-HZQ*f8EvjMz^-Q
zxZJ)No`XS`+W_qQsqn#E`rTaSy}N(@1`mF7;nrJEU%54Vh-`iJ<V$z^UU{cHwwQW&
z;9TmLYnR(H_5Pg=zI%S{!-qe9w039j=5@2zeXY~}_Vrgkd+Lq72frSA^v6~E!vj~k
zzBrow`1||c^&c(q?VoRd5j+ma%yeb`!2QLggO32%-iAHJjlY7&0hp<tn*Q>{+3o)T
D7Ij$p

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-8-sRGB-tRNS.png b/Engine/lib/lpng/contrib/testpngs/palette-8-sRGB-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..b8863ec2b8ffe01421c1fd561ddf880de73af07e
GIT binary patch
literal 1313
zcmW-hZEO`q6ozjlF<3#zU!ox}A;B1^$xvdzCc+4}q2;5DrIbbrnSRM_XfNaK+Lqel
zw543?r3_7l3$1lRs@7s)tW~NMSQ{(_6-TLpfMHS+jYg75i2g7!uCv`AlYRD_J^P+_
z&Q2#OST{HG>C8wZGB-ajS{R9BxZ6m^>{)JoILUKEs4HBzX4Z<yO<N+7SrM|aC^rZK
zYXf5ftpnc=lnSH_ga|kf7z-#32njF_5DFj+00^_~v^7&!PgsA{sv#@;tmv|wTb8i2
z(vo6}^DN4-Fw24kVQD*M%%ss{##crS7@0OAWjHs?Gc;yMslmjcsDUdD$O?7X32nx-
z9@hS#R{dJ`Xwj)T*Q{RC8coVIF43q!!>9&1p=dkm8|CXk-<Q5h`%?HK>2vP0MxQdD
z#C%MBRN_P8gS@aqJEY8j(*4R$E7h%JN{J4|xnfO<dWysqjww{GV5tJdp&hnQnzYnC
z(ic*tq)bZDE;*O1S<*&HJc*e^H4?@os0_WcUBaY<?i7Afs1709g=iI=3${<tW<i<+
zZWO3qKu>@~XteXr+2J~LqMZ&`+GV?oaZWiWoMX-r=a6$Svnw{ijK_36^Bb9JVzQZu
zeJ+==Rz}+y>0mg?P$z>a2D-v6w3XDvsIH+tqspVQk&0$ln6h?Cla!<=78LbRn5LjF
z+;3Y<OexXj#E%gbC(<LL$*CZ$gU}Qq-2|rz>L+l3fT3_WY#ufQ>k{l!tYTO)EE=6;
z%#xT2Owt%jj0Q1O7>tIKWOI;-B3*#|5~RwJtU;pQ^@ms|qCJT8BRq)EFoI(UOoU@+
zv!GcCbrkvps!}LpP<YM^$WoA|AsK*JK{N*8Bm`68jM@djWC5K6{5+tFfvf}~;hY1k
z3(!75h5#M~Xac|~0H(p)neqAV#|XT_f-S+n|NQ;H-v8sbd*+v0H?C_3fBydK^xfMx
zfBgR1)ytRe&%li-{q2>n#xI;Zd(YgtIRjsw|KhXZ)2D9z^ux8Q6XO>`7<&I?zy4<O
z(#3OUKRI*C!HJ_sE{|XM{L_y=8XS1H_h@(5!Tsk)N5arM>7K)Hb@1kfkuyW@$-ZOV
zhm!64_Ihl$qu!%OQU_X_8xpm#ik&mm!QZHVt>)FT(rtyuT+9*MT}8KVB^z=NC0m<k
z=#`?)`O#G`w6`?4Od8VK7guIy?X9cbRknR=NGp~tUA&N0SM1pK@`mUt7hAmWsnsib
zb~-DvyxbCR?H;x_QN1hXMTTHDTDCmPEziUCdt!08_VswYI=(AbRtwkcX{f16w0L#@
zx%a&4q7rXobwyRY&V}9KQx%UyX5W17(5A=QA?Q#K?q$p$t4%jPu|K_j(VW)dM>nfS
zcD%WIX+`GUd1aY*I-BC_G7t8)Ecvj8b=|!#SntTO!^sh^JP{w?z4L>|>ql;zMbq}c
z$?tAo%syQ4?2~<8PhFY2JbOvo&&N+c<Gw#9Kl)P9ys3)H`O}d|TU*9M%Ub?A?w&{T
Ma|@zp*3h>90bVtOvj6}9

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-8-sRGB.png b/Engine/lib/lpng/contrib/testpngs/palette-8-sRGB.png
new file mode 100644
index 0000000000000000000000000000000000000000..90f8912043164c8a6cc451a6c74183cea0e6498c
GIT binary patch
literal 1046
zcmW+#&uiR86#vG6)V0y^WRXyY9z^O2(-g7f;+Ss8rnGUWA?zW_bhDw~;P#tg^L1U9
zq)xJ~>#}Z#5^+nHFi60-2OUBVIV?DM2oVnsxCf;|hxiW+h-bgf*Eu}q$9r!+@AE#d
zO%~=RGOuKUAeflX=WYkVnBN9t=f=H#w#8@D!^Z8onen$yZ@m`;;{mz3IGZGibBVQy
zF^SfRQi+s_5DDiAV+o}RAqmC_LJ5Qk0I9b-b9Us+iPOhU4V>&d(RG|VR&liC$dbc(
zho&9OI&d*f?MBv~S~Ij-S+#Fv&x(%a+_Kox(2`|~iA6aJuUU{yakvv>hsGQlePGm{
zk-J8;4d;ec4J{i|G`L{Uf`K^$rc==FSX-sdf!0#1o|Zz3mgZcunx;&XP-Ci5K|`WJ
zKCRFVl-*ZmPwAdg50&gF(Nvr(R#!AuBvLq3sHotw0!t|!t}ks*nq8@dR2?Z>QZyvz
zl5I*_lO&dyNmQ0Fl%SMy=eojnglP-i5~?X=Lx^p`xnTDN-4vuQa8019fUy9TlxWYL
zr^8q1L3<oNwfFXmaZWiWoMX-r=a6&oe^*?E*_fFs(>12*Ol~r9-}^GQ&1i#>Cc`a;
z+6;CW=%y`nC2B)z%2YF|Vk&D?Z2H8MH7IRS(xF&Tv`b-+f_~a>w?ynRF-4+7q9P(=
zBI+ImVNF6igghj;N6;RD`veS9akxCT1e*fZ6sr(RhDFUo#;k>@z@&$<#OMG+g~4&E
zBsYz04w(g{3rH1_EF)3%^&!?qbQh65gbxrpL~w|}Nh&*+h4vaWIj9L#%TR_;#GVYu
zI*|4t*@sv`G=%UJf>EkbcM;euFw;Qifm#Bx1VqI%2Ur)-J|F{tj{!OXa0I{^_$m`k
z`oYM?vxWHjI{T!ub~lWJ0h~ftu4cV?6W&-4BY6FzC|Zl|hIj74ne~s$tCg*I<6j>a
zuPqkhn`<kp(T0Ea6So=#!MWex`0~~Z4G5a*@4v<-hxdB5mp<#=xO9H|@cDPubMJrp
z_UkK|rx)&I{%qHyxy%=jw=REIX5FX13HJEt>j$l)xLApP`tXBqU#uQIv6s%==imJL
z<j1K8E3duW|7G;^#MP<GJAXX-{#F0~`T5*Cix);KrOC4(*x4C-=E~MTkNkZwKf93o
IVTSJf2i)iD!2kdN

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-8-tRNS.png b/Engine/lib/lpng/contrib/testpngs/palette-8-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..9660e67765d96cc9f0f521d480ecff9529a1a1e0
GIT binary patch
literal 1300
zcmW-hZEO`q6o$8w7_6Y<FVPT~kYEhdWGFFU6Jdqh&;phbOKGH#>6hGw_A*}9w$v7<
zE#*=#WoRl~Xsr`cwH5<otx~1H*kJikag-_u7$zmrXe610=noU)I@|p**=Nt$v+sH5
z>~!LyHM6sy%=SEQc40wmqvvJ0TQ6(o47Wa*V)>po!^7)~^TRN-HZ&&GI#eo@G87`@
zJY+1SG$bU%IQ0Dxp%B6lfGFEeSu<(%gjJ(f4q4G>d6#9((xfF-7MEDRz@j`0b1aw_
zm9~?{TrzshC~4$?5gEhNhA~3}L*fRP86O)IGjO>9Igt)Kq0N}q!&(h$*{?;9=AD``
zP3twO)wn|Yr5Y7!7}Fpx5^YD7kxCCLC6vr4!4*#_#uRN-gen|YK2fMtL99SQ)S(@c
zW<ctGsWMV_OOckmLoz05lO%z}3F*frs*tcuf|AG%+b2v$=pLcCkZB=Og0~CC1Z@_i
zQQ$!MRG?Y`;{sGg-q|j0(p-0PmEy94i+0XiIb)pe;iQ@4Chj+KRL^0+K{7JhdFSkK
z9XioYhb!%}-9;HAjA6!n#t>tWF)+O=Hc3rDbv;#$R5nr3O!*#{OKB@5?G$%VKSfa|
zg=q@9qAj#l#KeiNC5jRm5Yb3@vnxz!J0U58)5PZl^$?gLpfB2QTY^m)))iRAu}okQ
zVBX|ZVA_F68sl#4XE5r=Z~%j$XgF+vZ?LaReMNj3_XYKNqm%5@lux*iGrli;H0VR=
zgVAV`Y#uT(q>GR$MX~~kTEy#Je~5M>(t~h6@&^$bMsN&)iD>L>4m8W5jzNW?EQ2Br
zdEm@|G!01x;sNMOh{hni1i@r9qjnxJIY8$DRRClO5LJLDopXS80n!KX5b#F<ngDPT
zfGO~Hc4DskCBk51(aYh#|NMR5-uvUXyXKdh*RN>@fBydK)SX*5e*FIGm5UedO~ds`
z{q5zi#?PHOeb?N+F%4gy{o=FXlP7Ne^uyIF6XWM17<&JBzy9XZh4W`le{$-CgJXve
zT^v96`KKR$G&t~X@8RyQ{d>=jjzpn%GCc?1>R`<cBd3Pm6MaXz52V`n><;J-N4<v+
zrT4WqHze!gmD{GNgS}DzTJ5XlWt%r1aWO}9M>W~939rjPkZNt7rdNtL6vkFO*WS|L
zGD$?MpI@GvvwK(F_VO*8B3ia&@xuAErgH1%m)6BrxY)w^Ppn+lv&~tN6Xcf$t9R1f
z$(rr)z#D?OXvxwXw>%5i?u;kk>emyAn#A^ac^zD}v!S*+*%Ivf&%GDa6qg3;YbvV~
zyIk0vH`NKxn|b4z11~<(4nc>!e>ZFHSY4*^vAvnK3ud(rKfFOcwDrxEiz~D5%qh>l
z-Px2_lfA#UWzmPVwCm0_PJ2g=988S_70JZ-j%^=2T0e5jESR$Uj(>OSeD1-@ryuY8
zdh+t@rMZjRem;8gDfj(Zg|Qck=S)^s&7JbRwzjMXmbCnJ)IIkK^NV7qR*|;<0gfDi
A!vFvP

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/palette-8.png b/Engine/lib/lpng/contrib/testpngs/palette-8.png
new file mode 100644
index 0000000000000000000000000000000000000000..2502d305b57df2ce24deb63bae3c39a1d9629fc7
GIT binary patch
literal 1033
zcmW+#!E0Pa7=N)Kb!~J!StOL92a&qMG({-6IBhp{Q)(O}ggr!=ZZ`CVZeND&>vmm|
zI?1}O%eoy(#8<k6K?24-=n!(qVZp&esCaO|J+xHl5dVPz@$7S+bNCo$zWL4X`+dK!
zOXjam=HAK$K`=R2EPNaU6Mh>^oIK&<%N;%&1SbM=ePK3DQ|D4^Q)5!CQ>9WVQz25$
zQ^rzCQ$kXVQ-o3oQvkATckJxgnIoqUof<khaH8)xcdX`U#gRpaiw?~=n0Mez2JOby
zKCxzGwX$m0%EXGE<=nE^($JD6i-|=A3olxb&v>{aV@Jm98@*@Lj*;6&bPeZ*)eWs0
zQZ~3`(7b^K17<SP?oeB$&7Rg$t3*qoMMrb4SwmB%NvJW^sH7p$pqN$YhRW_Lv!isP
z)I%kEO0*T{iZvCD6^RrM6)G#Zq`+b(hZ{(nNV6@qkg6wTM~ar@T(WgZ8<NBlGl{Aa
zh7wdV?Ob2jo-kdZJ3_UEYzeU`I2Y``pzDG(1#Spb7cdr}mI>{(^K$qKJ!#LwL;GyM
z80VC8!a3#~aSk~L|98dJn2njKGu>dS$>cf{_kAv7n~b&?X*1kmsLNoFfqvFPSD`kf
zrb;!VDyFhQ#kvQktVL;uk{-o^qHPKj3I<uf-6F9|#FU8+iHeAfiD-HjgtZCn5%Q4W
zgrFS)cL^9~=5R%92{t9HDOMqt42y=Rj9CX$fk}d~#Apvgg~4IwBsYU>0hxKEOGuTG
ztRhkO^&!?pbQ_T!g!d5IM{tC|QD!@rhxQ^g1*i#BOHhVT#9j=@dXOfN>_V&{8bSC3
zf^p_icLvxzFf%|Gfm#Hz0z}O#2Us7_0U$$w4*@y?a16jP_$C)k`H{%Sv!(dT8vCra
zdNYiJA)H3%FXVlAA6{DvBY5R*6s<-#!yC8Z<+Xd&mD)yp=U@LWUR@}~*H@QUqC5WD
z57|l-1Sg-q_w|RbwIFD#zyF$;8r@DBZ+wwlJ9}z#|J9GwE1!J+!Mn@37pHIJ{_HlR
ztGTZpZ=Cy~%K9(<5bW{6w+}i8ak&=#a_iIYU#}lLw`Y&tm*4&V{O9Qh%kR87_-*{_
w<b~;TThAW-__qK5)Lh}x!s+pHW$HKxwzei-I=}JHBYz&u&CVBox=gqJ107oE(EtDd

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/rgb-16-1.8-tRNS.png b/Engine/lib/lpng/contrib/testpngs/rgb-16-1.8-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..03251b12ef08a06018bc3a411f6f02265ba3e14e
GIT binary patch
literal 1211
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K583dSsRCB}QA|S<*?&#~tz{ps-dGfvvAYUQb
zBgmJ5p-PQ`p`nF=;TKS-;RORjsR0ASs{{rHs~HRo;stYd1=;{5bV^(!N}TfxDvL7H
zGfEg%Di|3U8tVWFQw6X5j64PB(!9LPy!4F3Tm`56@|@J7+LGdbKz${dArU1$naQbn
z#XxDGgHrPt7&xx$_W1HOD+si%|MZAaW_RxN3c;4?UP?TT8@c`0bH>)&YbSHvlSt&c
z-C33A&ebuiR%=C0LGQgw{ROi&PwQ*nT#{6jcQ89{8GqU4TlbY7zHeK2?$$n|zGMyY
z*{3d_;59bVYPvCFEzn=geV#6kAr-gYUfs@kz=4O^(2MW=hX4ES9b9{WiFw0LuSrYJ
zoXNSdYg_VNeb1s<bMKvht?20&%-|8k;4z8GVUh^Lq$La!R9G8SG#OMp85KOa7(B_4
zVk}@GQzth2SP!sL<{WfGso_P0nM@Bjs1<GyL&*qmgljNjkh*aJOcoTS40MMsVX$bT
vIJu!1iV*-PvLr@*5QB^(`T63{OZH%uk898Ey)zeBGB9|$`njxgN@xNAtJFa=

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/rgb-16-1.8.png b/Engine/lib/lpng/contrib/testpngs/rgb-16-1.8.png
new file mode 100644
index 0000000000000000000000000000000000000000..03251b12ef08a06018bc3a411f6f02265ba3e14e
GIT binary patch
literal 1211
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K583dSsRCB}QA|S<*?&#~tz{ps-dGfvvAYUQb
zBgmJ5p-PQ`p`nF=;TKS-;RORjsR0ASs{{rHs~HRo;stYd1=;{5bV^(!N}TfxDvL7H
zGfEg%Di|3U8tVWFQw6X5j64PB(!9LPy!4F3Tm`56@|@J7+LGdbKz${dArU1$naQbn
z#XxDGgHrPt7&xx$_W1HOD+si%|MZAaW_RxN3c;4?UP?TT8@c`0bH>)&YbSHvlSt&c
z-C33A&ebuiR%=C0LGQgw{ROi&PwQ*nT#{6jcQ89{8GqU4TlbY7zHeK2?$$n|zGMyY
z*{3d_;59bVYPvCFEzn=geV#6kAr-gYUfs@kz=4O^(2MW=hX4ES9b9{WiFw0LuSrYJ
zoXNSdYg_VNeb1s<bMKvht?20&%-|8k;4z8GVUh^Lq$La!R9G8SG#OMp85KOa7(B_4
zVk}@GQzth2SP!sL<{WfGso_P0nM@Bjs1<GyL&*qmgljNjkh*aJOcoTS40MMsVX$bT
vIJu!1iV*-PvLr@*5QB^(`T63{OZH%uk898Ey)zeBGB9|$`njxgN@xNAtJFa=

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/rgb-16-linear-tRNS.png b/Engine/lib/lpng/contrib/testpngs/rgb-16-linear-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..3dfa6a6ad044993b59cec8ff49f078d1b9cd1d91
GIT binary patch
literal 1211
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K583dSsRCB}QA|S<*?&#~tz}U9H@Wr%vAYUQb
zBgmJ5p-PQ`p`nF=;TKS-;RORjsR0ASs{{rHs~HRo;stYd1=;{5bV^(!N}TfxDvL7H
zGfEg%Di|3U8tVWFQw6X5j64PB(!9LPy!4F3Tm`56@|@J7+LGdbKz${dArU1$naQbn
z#XxDGgHrPt7&xx$_W1HOD+si%|MZAaW_RxN3c;4?UP?TT8@c`0bH>)&YbSHvlSt&c
z-C33A&ebuiR%=C0LGQgw{ROi&PwQ*nT#{6jcQ89{8GqU4TlbY7zHeK2?$$n|zGMyY
z*{3d_;59bVYPvCFEzn=geV#6kAr-gYUfs@kz=4O^(2MW=hX4ES9b9{WiFw0LuSrYJ
zoXNSdYg_VNeb1s<bMKvht?20&%-|8k;4z8GVUh^Lq$La!R9G8SG#OMp85KOa7(B_4
zVk}@GQzth2SP!sL<{WfGso_P0nM@Bjs1<GyL&*qmgljNjkh*aJOcoTS40MMsVX$bT
vIJu!1iV*-PvLr@*5QB^(`T63{OZH%uk898Ey)zeBGB9|$`njxgN@xNAkxD^j

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/rgb-16-linear.png b/Engine/lib/lpng/contrib/testpngs/rgb-16-linear.png
new file mode 100644
index 0000000000000000000000000000000000000000..3dfa6a6ad044993b59cec8ff49f078d1b9cd1d91
GIT binary patch
literal 1211
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K583dSsRCB}QA|S<*?&#~tz}U9H@Wr%vAYUQb
zBgmJ5p-PQ`p`nF=;TKS-;RORjsR0ASs{{rHs~HRo;stYd1=;{5bV^(!N}TfxDvL7H
zGfEg%Di|3U8tVWFQw6X5j64PB(!9LPy!4F3Tm`56@|@J7+LGdbKz${dArU1$naQbn
z#XxDGgHrPt7&xx$_W1HOD+si%|MZAaW_RxN3c;4?UP?TT8@c`0bH>)&YbSHvlSt&c
z-C33A&ebuiR%=C0LGQgw{ROi&PwQ*nT#{6jcQ89{8GqU4TlbY7zHeK2?$$n|zGMyY
z*{3d_;59bVYPvCFEzn=geV#6kAr-gYUfs@kz=4O^(2MW=hX4ES9b9{WiFw0LuSrYJ
zoXNSdYg_VNeb1s<bMKvht?20&%-|8k;4z8GVUh^Lq$La!R9G8SG#OMp85KOa7(B_4
zVk}@GQzth2SP!sL<{WfGso_P0nM@Bjs1<GyL&*qmgljNjkh*aJOcoTS40MMsVX$bT
vIJu!1iV*-PvLr@*5QB^(`T63{OZH%uk898Ey)zeBGB9|$`njxgN@xNAkxD^j

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/rgb-16-sRGB-tRNS.png b/Engine/lib/lpng/contrib/testpngs/rgb-16-sRGB-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..2cf2209e01d6eb8253a77f91f1de55fa8a4900fd
GIT binary patch
literal 1164
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K583dSsRCB}QA`q`Q$lZzA{J3v0kfT%L8d2h$
zUr<?;nVwO?uu{Ruz|dF+NSG>k<!9t6IG5(-W#*-4B<3nO<(KEA7S)y%{{!kP$qb1o
z@ySe1%_{~<18qpnV_@L8uG{0w*Q_AWy8hE6Mw#8Y(<=m9rh6&zG;ZYfU(Xp^Z?B!q
zbx$IZ>vm^Vo;z2^tXi!VIR(A<F7+48+B~hVeRD}tQQpDqxMlohn{VA$dicI=;kjG;
zjQWx_#Alzne1g~5NUQ0_jJ0YE49tC=E{-7;x87de&UnCqhuP4J@BN1V`|cfFdw_{~
z!%nYBOU|6hxv^_o@?Cw;qFHnAoqw(9=@-o45yapziOFG-2*ac$3=>pX8&otIR6H3K
zJh>P=$&g|!U?Ec{Hv3o)uu|q6bVI4(MTD754>+h5ZV*Gs2yldJFk+CpaRE#g6r~Jw
zhc02TXref|p%{u004TB~Mtu;2j3fE^;?GO=V3m(+&+WZ47g#bdc)I$ztaD0e0stU;
BHA?^h

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/rgb-16-sRGB.png b/Engine/lib/lpng/contrib/testpngs/rgb-16-sRGB.png
new file mode 100644
index 0000000000000000000000000000000000000000..2cf2209e01d6eb8253a77f91f1de55fa8a4900fd
GIT binary patch
literal 1164
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K583dSsRCB}QA`q`Q$lZzA{J3v0kfT%L8d2h$
zUr<?;nVwO?uu{Ruz|dF+NSG>k<!9t6IG5(-W#*-4B<3nO<(KEA7S)y%{{!kP$qb1o
z@ySe1%_{~<18qpnV_@L8uG{0w*Q_AWy8hE6Mw#8Y(<=m9rh6&zG;ZYfU(Xp^Z?B!q
zbx$IZ>vm^Vo;z2^tXi!VIR(A<F7+48+B~hVeRD}tQQpDqxMlohn{VA$dicI=;kjG;
zjQWx_#Alzne1g~5NUQ0_jJ0YE49tC=E{-7;x87de&UnCqhuP4J@BN1V`|cfFdw_{~
z!%nYBOU|6hxv^_o@?Cw;qFHnAoqw(9=@-o45yapziOFG-2*ac$3=>pX8&otIR6H3K
zJh>P=$&g|!U?Ec{Hv3o)uu|q6bVI4(MTD754>+h5ZV*Gs2yldJFk+CpaRE#g6r~Jw
zhc02TXref|p%{u004TB~Mtu;2j3fE^;?GO=V3m(+&+WZ47g#bdc)I$ztaD0e0stU;
BHA?^h

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/rgb-16-tRNS.png b/Engine/lib/lpng/contrib/testpngs/rgb-16-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..28643528d6bc2fbfd8c9da72c9fb60eec0d23e48
GIT binary patch
literal 1151
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K583dSsRCB}QA|Rzx;u=xnoL^8`l$oAU!mv`o
z$iUE82S}JIc;#p0DL9wr<z?ojXC&q-IOUh;q!!hd6#oP2E6EIrDDlZmPR%O@N&^i|
z&0}ETxUSpd%h#+R(7OK9BSx9sxzj5ITc&#{@icDa_FvB#TW_zO%ymy9k?VG6Rh~On
z$E;ed6*&dH_b&Ap%-TGyuYGe#Qc>Q)?6_t8Wt(r^S9<uqZQ;3F`;7XMHN<D1x_pAy
z*hs7C#*DRU3=GVDo-U3d6}R4A-OhNxfrr`9i|_r0|NHJ8Tzi0tdBaYxNlVV0$+@v>
zTk>6f&!Sm#@11|G=;;^C;1R^&F^S1xk_f}3B@7c(SQ}I{8B{zO6+F2ZJjsw^EMOs1
zCpP<753o|^9CSme;YEa*Ob<Ay6>bni$p~<SYcOJvx^V$a78IonbcZfsuxO$<xuF<}
q5dbK%Bu0G@gN!5j`Qpz@_F$EdYtQYyGZ$DgFnGH9xvX<aXaWHEcrsf6

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/rgb-16.png b/Engine/lib/lpng/contrib/testpngs/rgb-16.png
new file mode 100644
index 0000000000000000000000000000000000000000..28643528d6bc2fbfd8c9da72c9fb60eec0d23e48
GIT binary patch
literal 1151
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K583dSsRCB}QA|Rzx;u=xnoL^8`l$oAU!mv`o
z$iUE82S}JIc;#p0DL9wr<z?ojXC&q-IOUh;q!!hd6#oP2E6EIrDDlZmPR%O@N&^i|
z&0}ETxUSpd%h#+R(7OK9BSx9sxzj5ITc&#{@icDa_FvB#TW_zO%ymy9k?VG6Rh~On
z$E;ed6*&dH_b&Ap%-TGyuYGe#Qc>Q)?6_t8Wt(r^S9<uqZQ;3F`;7XMHN<D1x_pAy
z*hs7C#*DRU3=GVDo-U3d6}R4A-OhNxfrr`9i|_r0|NHJ8Tzi0tdBaYxNlVV0$+@v>
zTk>6f&!Sm#@11|G=;;^C;1R^&F^S1xk_f}3B@7c(SQ}I{8B{zO6+F2ZJjsw^EMOs1
zCpP<753o|^9CSme;YEa*Ob<Ay6>bni$p~<SYcOJvx^V$a78IonbcZfsuxO$<xuF<}
q5dbK%Bu0G@gN!5j`Qpz@_F$EdYtQYyGZ$DgFnGH9xvX<aXaWHEcrsf6

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/rgb-8-1.8-tRNS.png b/Engine/lib/lpng/contrib/testpngs/rgb-8-1.8-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..afff9df22663f6a555f7c11dbfcbe68c3ed02654
GIT binary patch
literal 837
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K58911L)MWvCLm<VH?&#~tz{ps-dGfvvAYUQb
zBgmJ5p-PQ`p`nF=;TKS-;RORjsR0ASs{{rHs~HRo;stYd1=;{5*h+%@f`R4%p(=Ap
z15iY##5JPCIlrK?C^J2ygkhzEk%6JH4v;Wa@XF7~Q*bWL%gfA5&q&NwaLO;wNiC`^
zDgFo4SCSbLQR0)CoSIh*lm;4@n#aJvab35^m#<ktpmqJHM~pJNbEj7bwoLa@;%VH-
z?Z2Kgw%%Slnd_cJBG>KCsyuhDj#;%@D{=~Y?_KIIn6-IYU;E~gq@uio*>TJG%QoM-
zuk`SJ+ro3V_8IjhYlzQ2b@>FZv5{8OjTvi!K4oI_ba4!+xb^ljBQJvj5A(sihWgVQ
zGn!(Hxn|X<YHnWp+KT_$t1qovSsEA|7!();7&sVM7?>Cssm^72z)Bl~;ZCNd>p_+<
q?w~=iz+DdtaE=4qv<Uu$FO2aInZkd^%IpHBNCr<=KbLh*2~7ah7n$?`

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/rgb-8-1.8.png b/Engine/lib/lpng/contrib/testpngs/rgb-8-1.8.png
new file mode 100644
index 0000000000000000000000000000000000000000..d4bb12afa1101bf338bf992d67761ea1a8f0ef66
GIT binary patch
literal 819
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K58911L)MWvCLm<VH?&#~tz{ps-dGfvvAYUQb
zBgmJ5p-PQ`p`nF=;TKS-;RORjsR0ASs{{rHs~HRo;stYd1=;{5bV^(!N}TfxDvL7H
zGfEg%Di|3U8tVWFQw6X5j64PB(!9LPy!4F3Tm`56@|@J7+LGdbKz${dArU1$naQbn
z#XxDGgHrPt7&xx$_W1HOD+si%|MZAaW_RxN3c;4?UP?TT8@c`0bH>)&YbSHvlSt&c
z-C33A&ebuiR%=C0LGQgw{ROi&PwQ*nT#{6jcQ89{8GqU4TlbY7zHeK2?$$n|zGMyY
z*{3d_;59bVYPvCFEzn;~Y@RNTAr-gYUS{NFP~c%cnAcE$T4P32Y%$lY8dc5BYhPRO
zUwieXbt_8)g9C#Cg8%~u0}BHa10&VBEDu;|V=&ywv~)el62=`g2o|{OK>^NjfSVS<
cpYVk-{vlKN?^u~#z!b^g>FVdQ&MBb@050yAXaE2J

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/rgb-8-linear-tRNS.png b/Engine/lib/lpng/contrib/testpngs/rgb-8-linear-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..5a2ed9f009af9200ffa7c6485accbfe524a6d056
GIT binary patch
literal 837
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K58911L)MWvCLm<VH?&#~tz}U9H@Wr%vAYUQb
zBgmJ5p-PQ`p`nF=;TKS-;RORjsR0ASs{{rHs~HRo;stYd1=;{5*h+%@f`R4%p(=Ap
z15iY##5JPCIlrK?C^J2ygkhzEk%6JH4v;Wa@XF7~Q*bWL%gfA5&q&NwaLO;wNiC`^
zDgFo4SCSbLQR0)CoSIh*lm;4@n#aJvab35^m#<ktpmqJHM~pJNbEj7bwoLa@;%VH-
z?Z2Kgw%%Slnd_cJBG>KCsyuhDj#;%@D{=~Y?_KIIn6-IYU;E~gq@uio*>TJG%QoM-
zuk`SJ+ro3V_8IjhYlzQ2b@>FZv5{8OjTvi!K4oI_ba4!+xb^ljBQJvj5A(sihWgVQ
zGn!(Hxn|X<YHnWp+KT_$t1qovSsEA|7!();7&sVM7?>Cssm^72z)Bl~;ZCNd>p_+<
q?w~=iz+DdtaE=4qv<Uu$FO2aInZkd^%IpHBNCr<=KbLh*2~7ZSftn@&

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/rgb-8-linear.png b/Engine/lib/lpng/contrib/testpngs/rgb-8-linear.png
new file mode 100644
index 0000000000000000000000000000000000000000..7c42b0840831216f7818e8b71a39e1e30b40db97
GIT binary patch
literal 819
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K58911L)MWvCLm<VH?&#~tz}U9H@Wr%vAYUQb
zBgmJ5p-PQ`p`nF=;TKS-;RORjsR0ASs{{rHs~HRo;stYd1=;{5bV^(!N}TfxDvL7H
zGfEg%Di|3U8tVWFQw6X5j64PB(!9LPy!4F3Tm`56@|@J7+LGdbKz${dArU1$naQbn
z#XxDGgHrPt7&xx$_W1HOD+si%|MZAaW_RxN3c;4?UP?TT8@c`0bH>)&YbSHvlSt&c
z-C33A&ebuiR%=C0LGQgw{ROi&PwQ*nT#{6jcQ89{8GqU4TlbY7zHeK2?$$n|zGMyY
z*{3d_;59bVYPvCFEzn;~Y@RNTAr-gYUS{NFP~c%cnAcE$T4P32Y%$lY8dc5BYhPRO
zUwieXbt_8)g9C#Cg8%~u0}BHa10&VBEDu;|V=&ywv~)el62=`g2o|{OK>^NjfSVS<
cpYVk-{vlKN?^u~#z!b^g>FVdQ&MBb@0LR6bng9R*

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/rgb-8-sRGB-tRNS.png b/Engine/lib/lpng/contrib/testpngs/rgb-8-sRGB-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..f8b4ecbdc69d05e45b655031ea6856ebcf5cb672
GIT binary patch
literal 790
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K58911L)MWvCLlCbx$lZzA{J3v0ki%9I<QEK7
z0EDW{B@I9kof6lG66gGa%A(Blj1q>G3PuKo#yUX4RKY7hBTvD(G%qhRFFhkMSHUU2
zJSVlNwxswUP+v)ANJNQGW^!s?F;E(4U}_!%1IKmU9$&s@1%cM}pB^#F?9QEDA=onA
zONpm(Be(y0&e(c;?PRWd5{X>5JFD{CxjJUmYOTmA=)HHTzhKtpX?^XROOlH64ra$K
z<1gEM>%P*%_iYQ$-P&i=m#iT^`_$zVyv9aaO*dw&RbyaaV)Jxy45_&F_A(<cg8~op
z!Muk0(;73HVvD(E)u?K2Ui;dL|JtiBty@_d7#tWB7z7wN7+4sX7#OL}WqH6#8-w9a
wrlspamN4$1L9oDG4+?OO1KhL-{)8`#@ei58f5*z~0;Wg?Pgg&ebxsLQ0N@ag3;+NC

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/rgb-8-sRGB.png b/Engine/lib/lpng/contrib/testpngs/rgb-8-sRGB.png
new file mode 100644
index 0000000000000000000000000000000000000000..4acae649d387ee0a259428e9e210d2dc3e4f98a4
GIT binary patch
literal 772
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K58911L)MWvCLlCbx$lZzA{J3v0kfT%L8d2h$
zUr<?;nVwO?uu{Ruz|dF+NSG>k<!9t6IG5(-W#*-4B<3nO<(KEA7S)y%{{!kP$qb1o
z@ySe1%_{~<18qpnV_@L8uG{0w*Q_AWy8hE6Mw#8Y(<=m9rh6&zG;ZYfU(Xp^Z?B!q
zbx$IZ>vm^Vo;z2^tXi!VIR(A<F7+48+B~hVeRD}tQQpDqxMlohn{VA$dicI=;kjG;
zjQWx_#Alzne1g~5NUQ0_jJ0YE3`}gEE{-7;x87c6<YiFcVLq7GP=8uuMpJAt*Q^><
z&CP3HTk&6e^`&(yO9O)gg93v90|x^O0}}%y)wwJWSZQN0+{v_bJ;)Nq9W)3Qxa&ay
i&T)X77QvtJg)#miQ~2*#nO(pX$>8bg=d#Wzp$PyHMvH&|

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/rgb-8-tRNS.png b/Engine/lib/lpng/contrib/testpngs/rgb-8-tRNS.png
new file mode 100644
index 0000000000000000000000000000000000000000..cdb1642ebad2e8e697f0e48a7ff5b2376ad51661
GIT binary patch
literal 777
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K58911L)MWvCLm<Ug666;Q6azw4=8^`Wh)#)X
zM2T~LL1j^9dPWJuN(CbWLt`BvVXEMjpOL5FT$-1cnU|iCn5*EFU!Id%R9jN~52&vs
zGbEzKCo?%UuNWu|G%z)ffq~<?ZjUctvw}eD`cID-Wp?LIuMljR?xn=jxRKj`J!fpa
zy>>F!J&8oF+nrT;?pz(SYPDA66!hM^)L$@b^R&M9%_T`ic?YxOmhqQuzI9*e;rq6Q
z=WgvY>PyxTpMC1`30`9(t)?3@)~YcuFtK^MIEGZ*dV86XmqCGt`Cwi{{b`LEO|ivX
zvuac|H?Mtd#eeP9m)5N;4Gazp3Jd}a91JWBObm=v=dwItrH#RGC)3jPAWIl`&>&dg
lt_KA;#{q6y1b@O8#`uR!;lE>Lb^%i)gQu&X%Q~loCIAqyiyQy|

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/rgb-8.png b/Engine/lib/lpng/contrib/testpngs/rgb-8.png
new file mode 100644
index 0000000000000000000000000000000000000000..e69c71bfd57998b71aba94b56dee8a0d20265ec7
GIT binary patch
literal 759
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K58911L)MWvCLm;J7;u=xnoL^8`l$oAU!mv`o
z$iUE82S}JIc;#p0DL9wr<z?ojXC&q-IOUh;q!!hd6#oP2E6EIrDDlZmPR%O@N&^i|
z&0}ETxUSpd%h#+R(7OK9BSx9sxzj5ITc&#{@icDa_FvB#TW_zO%ymy9k?VG6Rh~On
z$E;ed6*&dH_b&Ap%-TGyuYGe#Qc>Q)?6_t8Wt(r^S9<uqZQ;3F`;7XMHN<D1x_pAy
z*hs7C#*DRU3=B+co-U3d6}R4AX5?j1;9)+P*HC|2V@6YKG1sgbRn5(7Ut95Cd-bJt
zD@y}|1A_vC00RdD3j-4aBh|Sq4_IkqFx<(sbUnxt#vL>W7P#v{0nTxNn-;;J@P#q{
XAyfG8SeaeG6v^P}>gTe~DWM4fcDIO-

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/rgb-alpha-16-1.8.png b/Engine/lib/lpng/contrib/testpngs/rgb-alpha-16-1.8.png
new file mode 100644
index 0000000000000000000000000000000000000000..ad65d150e23f08e419facaa791faa5d17c4784d4
GIT binary patch
literal 1437
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K583fpX6wjj)RUpNZ?&#~tz{ps-dGfvvAYUQb
zBgmJ5p-PQ`p`nF=;TKS-;RORjsR0ASs{{rHs~HRo;stYd1=;{5bV^(!N}TfxDvL7H
zGfEg%Di|3U8tVWFQw6X5j64PB(!9LPy!4F3Tm`56@|@J7+LGdbKz${dArU1$naQbn
z#XxDGgHrPt7&xx$_W1HOD+si%|MZAaW_RxN3c;4?UP?TT8@c`0bH>)&YbSHvlSt&c
z-C33A&ebuiR%=C0LGQgw{ROi&PwQ*nT#{6jcQ89{8GqU4TlbY7zHeK2?$$n|zGMyY
z*{3d_;59bVYPvCFEzn;q1)eUBAr-gYUR%j{z<`Iv(fjAz<A2MgCkY)gac`5qm2v;j
znKNfj=_E&Od%TC;bJCjRZF8>gjpqll7BeV#1~E)f@nm$Eq{7PJIZ1>;g<Jtm29HTg
zfaXnNYEbdyVwj{trT_&_K=B3_gZl(>-GJf`)&^w{N&*JWRb&SYs-q~2EV!E}j4ZgD
z7$0y@oPt1(TEbAkLU9s8xQg;*4RI9Z$r|J)>SZ+<M=IsDK9XJa=c0It`CY>uQAKNj
PWgmm5tDnm{r-UW|VN`y;

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/rgb-alpha-16-linear.png b/Engine/lib/lpng/contrib/testpngs/rgb-alpha-16-linear.png
new file mode 100644
index 0000000000000000000000000000000000000000..1f399003173a558a55e7a0312f4a796b39cf99a2
GIT binary patch
literal 1437
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K583fpX6wjj)RUpNZ?&#~tz}U9H@Wr%vAYUQb
zBgmJ5p-PQ`p`nF=;TKS-;RORjsR0ASs{{rHs~HRo;stYd1=;{5bV^(!N}TfxDvL7H
zGfEg%Di|3U8tVWFQw6X5j64PB(!9LPy!4F3Tm`56@|@J7+LGdbKz${dArU1$naQbn
z#XxDGgHrPt7&xx$_W1HOD+si%|MZAaW_RxN3c;4?UP?TT8@c`0bH>)&YbSHvlSt&c
z-C33A&ebuiR%=C0LGQgw{ROi&PwQ*nT#{6jcQ89{8GqU4TlbY7zHeK2?$$n|zGMyY
z*{3d_;59bVYPvCFEzn;q1)eUBAr-gYUR%j{z<`Iv(fjAz<A2MgCkY)gac`5qm2v;j
znKNfj=_E&Od%TC;bJCjRZF8>gjpqll7BeV#1~E)f@nm$Eq{7PJIZ1>;g<Jtm29HTg
zfaXnNYEbdyVwj{trT_&_K=B3_gZl(>-GJf`)&^w{N&*JWRb&SYs-q~2EV!E}j4ZgD
z7$0y@oPt1(TEbAkLU9s8xQg;*4RI9Z$r|J)>SZ+<M=IsDK9XJa=c0It`CY>uQAKNj
PWgmm5tDnm{r-UW|a_)Zc

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/rgb-alpha-16-sRGB.png b/Engine/lib/lpng/contrib/testpngs/rgb-alpha-16-sRGB.png
new file mode 100644
index 0000000000000000000000000000000000000000..d9cea633a5e781eedf91a5bc4ffdad0e9f16e799
GIT binary patch
literal 1390
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K583fpX6wjj)RS>T@$lZzA{J3v0kfT%L8d2h$
zUr<?;nVwO?uu{Ruz|dF+NSG>k<!9t6IG5(-W#*-4B<3nO<(KEA7S)y%{{!kP$qb1o
z@ySe1%_{~<18qpnV_@L8uG{0w*Q_AWy8hE6Mw#8Y(<=m9rh6&zG;ZYfU(Xp^Z?B!q
zbx$IZ>vm^Vo;z2^tXi!VIR(A<F7+48+B~hVeRD}tQQpDqxMlohn{VA$dicI=;kjG;
zjQWx_#Alzne1g~5NUQ0_jJ0YE3@innE{-7;x87b`$#}qkhsDwR=iK9e%cUm?9Wrrm
zlfRX5|InE;XHMxPM{Rq&huw41n&fSBuJ4WK2eKA3D0l`jOi=M;beN>V%HTOkgh7Q|
z0Zj&vNlSp{O=4<L@#JEdq(Y_u1x`Tm1{Z_-1ajSg;t$paWe-XM2F+Du2MnsCD2pt(
zn<$JdxSJRsa8R6rK#p3%P{2ZQ5<<9&@?;Hh6y?bp<R<E6H5o@L<+VPNUG?Xpc!~L4
V!yQpYYk*}RgQu&X%Q~loCIEOTa@GI<

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/rgb-alpha-16.png b/Engine/lib/lpng/contrib/testpngs/rgb-alpha-16.png
new file mode 100644
index 0000000000000000000000000000000000000000..59262397eb5b4adc3e833e066f0cc19323a53d88
GIT binary patch
literal 1377
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K583fpX6wjj)RUoBP;u=xnoL^8`l$oAU!mv`o
z$iUE82S}JIc;#p0DL9wr<z?ojXC&q-IOUh;q!!hd6#oP2E6EIrDDlZmPR%O@N&^i|
z&0}ETxUSpd%h#+R(7OK9BSx9sxzj5ITc&#{@icDa_FvB#TW_zO%ymy9k?VG6Rh~On
z$E;ed6*&dH_b&Ap%-TGyuYGe#Qc>Q)?6_t8Wt(r^S9<uqZQ;3F`;7XMHN<D1x_pAy
z*hs7C#*DRU3=Av<o-U3d6}R4ATgiC9fQQA=`{&%_f6JvO2^}(VZ<D{3asSYnGiOfe
zBu8y~yocR$(wgLLbFS}==LfPDGbnflF-%bLWOSIM!ph(|NrXX#Tmel6k4Z~_=1pR1
zQ1Rqqn506c00mA!@dg)z`vh{`fZ`9<24xRQ0tU@hWCskYqbQ3kxSJ@9EV!E(A8=5d
zf<TU1!cf3MaS}qfit=O)aTMjr8ssMGWi=T`D&@64l3n%ZqIik<UBewwMQea%AA_f>
KpUXO@geCyOk#FVz

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/rgb-alpha-8-1.8.png b/Engine/lib/lpng/contrib/testpngs/rgb-alpha-8-1.8.png
new file mode 100644
index 0000000000000000000000000000000000000000..f4d08ec04714b59ce33cb9cdf731e898561b42a2
GIT binary patch
literal 919
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K5893O0R7}x|G$6&2?&#~tz{ps-dGfvvAYUQb
zBgmJ5p-PQ`p`nF=;TKS-;RORjsR0ASs{{rHs~HRo;stYd1=;{5bV^(!N}TfxDvL7H
zGfEg%Di|3U8tVWFQw6X5j64PB(!9LPy!4F3Tm`56@|@J7+LGdbKz${dArU1$naQbn
z#XxDGgHrPt7&xx$_W1HOD+si%|MZAaW_RxN3c;4?UP?TT8@c`0bH>)&YbSHvlSt&c
z-C33A&ebuiR%=C0LGQgw{ROi&PwQ*nT#{6jcQ89{8GqU4TlbY7zHeK2?$$n|zGMyY
z*{3d_;59bVYPvCFEzn;~S)MMAAr-gYUfIcez=4O^(QDuG|9y84J(Xg*%+S16MblV%
z=eqp(gk^r~na`*&C@?et^)PTyjlt0%>;Q@e76t(ZYB2;D)T!)B1)zWZsO(Aypnqi;
msTr1_$f3H&sb%Dc2kiS){w-X1V!aFl5O})!xvX<aXaWGLZlAFL

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/rgb-alpha-8-linear.png b/Engine/lib/lpng/contrib/testpngs/rgb-alpha-8-linear.png
new file mode 100644
index 0000000000000000000000000000000000000000..b4f8bc8294125cd98722d86e7b950ccfdbfbfe37
GIT binary patch
literal 919
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K5893O0R7}x|G$6&2?&#~tz}U9H@Wr%vAYUQb
zBgmJ5p-PQ`p`nF=;TKS-;RORjsR0ASs{{rHs~HRo;stYd1=;{5bV^(!N}TfxDvL7H
zGfEg%Di|3U8tVWFQw6X5j64PB(!9LPy!4F3Tm`56@|@J7+LGdbKz${dArU1$naQbn
z#XxDGgHrPt7&xx$_W1HOD+si%|MZAaW_RxN3c;4?UP?TT8@c`0bH>)&YbSHvlSt&c
z-C33A&ebuiR%=C0LGQgw{ROi&PwQ*nT#{6jcQ89{8GqU4TlbY7zHeK2?$$n|zGMyY
z*{3d_;59bVYPvCFEzn;~S)MMAAr-gYUfIcez=4O^(QDuG|9y84J(Xg*%+S16MblV%
z=eqp(gk^r~na`*&C@?et^)PTyjlt0%>;Q@e76t(ZYB2;D)T!)B1)zWZsO(Aypnqi;
msTr1_$f3H&sb%Dc2kiS){w-X1V!aFl5O})!xvX<aXaWFM+@IqB

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/rgb-alpha-8-sRGB.png b/Engine/lib/lpng/contrib/testpngs/rgb-alpha-8-sRGB.png
new file mode 100644
index 0000000000000000000000000000000000000000..f06e7f837cb38310c26d85b53f719fac7533281e
GIT binary patch
literal 872
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K5893O0R7}x|G!U;i$lZzA{J3v0kfT%L8d2h$
zUr<?;nVwO?uu{Ruz|dF+NSG>k<!9t6IG5(-W#*-4B<3nO<(KEA7S)y%{{!kP$qb1o
z@ySe1%_{~<18qpnV_@L8uG{0w*Q_AWy8hE6Mw#8Y(<=m9rh6&zG;ZYfU(Xp^Z?B!q
zbx$IZ>vm^Vo;z2^tXi!VIR(A<F7+48+B~hVeRD}tQQpDqxMlohn{VA$dicI=;kjG;
zjQWx_#Alzne1g~5NUQ0_jJ0YE3`|*`E{-7;x87da$$P+ohuP6<-}3)`cMm<4V!F)G
zyjDfiSbFEW{P=`re(Rafs4yrnGywH5a8QlG(ID&q3Re~e0S0O@1Q^t*>`DcofBmTJ
sN(Z2SWf-X$mY~R?y2q(y<cA0B`&9ldTzF!=3<D5&y85}Sb4q9e0L%E3$p8QV

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/testpngs/rgb-alpha-8.png b/Engine/lib/lpng/contrib/testpngs/rgb-alpha-8.png
new file mode 100644
index 0000000000000000000000000000000000000000..e15d4913f2d3df822129e6a771df02f0b31434f3
GIT binary patch
literal 859
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K5893O0R7}x|G$5r@;u=xnoL^8`l$oAU!mv`o
z$iUE82S}JIc;#p0DL9wr<z?ojXC&q-IOUh;q!!hd6#oP2E6EIrDDlZmPR%O@N&^i|
z&0}ETxUSpd%h#+R(7OK9BSx9sxzj5ITc&#{@icDa_FvB#TW_zO%ymy9k?VG6Rh~On
z$E;ed6*&dH_b&Ap%-TGyuYGe#Qc>Q)?6_t8Wt(r^S9<uqZQ;3F`;7XMHN<D1x_pAy
z*hs7C#*DRU3=B+Jo-U3d6}R4A*~xprfrr`AYv1z!eRmH%m14Tg(7aYf(^z`vy8QTr
zWq#|K&!{jcFf;)5FmO<f!O<Y>018SL1_1_YF$5UYsq9Jxpnv_S>`Diqe`Oe{8J3{P
hp}NPZW#oqk?E6&yEnIkFy$k~oc)I$ztaD0e0ssVnkl6qL

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/tools/README.txt b/Engine/lib/lpng/contrib/tools/README.txt
new file mode 100644
index 000000000..f53be6df9
--- /dev/null
+++ b/Engine/lib/lpng/contrib/tools/README.txt
@@ -0,0 +1,27 @@
+This directory (contrib/tools) contains tools used by the authors of libpng.
+
+Code and data placed in this directory is not required to build libpng,
+however the code in this directory has been used to generate data or code in
+the body of the libpng source.  The source code identifies where this has
+been done.  Code in this directory may not compile on all operating systems
+that libpng supports.
+
+NO COPYRIGHT RIGHTS ARE CLAIMED TO ANY OF THE FILES IN THIS DIRECTORY.
+
+To the extent possible under law, the authors have waived all copyright and
+related or neighboring rights to this work.  This work is published from:
+United States.
+
+The files may be used freely in any way.
+
+The source code and comments in this directory are the original work of the
+people named below.  No other person or organization has made contributions to
+the work in this directory.
+
+ORIGINAL AUTHORS
+    The following people have contributed to the code in this directory.  None
+    of the people below claim any rights with regard to the contents of this
+    directory.
+
+    John Bowler <jbowler at acm.org>
+    Glenn Randers-Pehrson <glennrp at users.sourceforge.net>
diff --git a/Engine/lib/lpng/contrib/tools/checksum-icc.c b/Engine/lib/lpng/contrib/tools/checksum-icc.c
new file mode 100644
index 000000000..581e7088a
--- /dev/null
+++ b/Engine/lib/lpng/contrib/tools/checksum-icc.c
@@ -0,0 +1,102 @@
+/* checksum-icc.c
+ *
+ * Copyright (c) 2013 John Cunningham Bowler
+ *
+ * Last changed in libpng 1.6.0 [February 14, 2013]
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * Generate crc32 and adler32 checksums of the given input files, used to
+ * generate check-codes for use when matching ICC profiles within libpng.
+ */
+#include <stdio.h>
+
+#include <zlib.h>
+
+static int
+read_one_file(FILE *ip, const char *name)
+{
+   uLong length = 0;
+   uLong a32 = adler32(0, NULL, 0);
+   uLong c32 = crc32(0, NULL, 0);
+   Byte header[132];
+
+   for (;;)
+   {
+      int ch = getc(ip);
+      Byte b;
+
+      if (ch == EOF) break;
+
+      b = (Byte)ch;
+
+      if (length < sizeof header)
+         header[length] = b;
+
+      ++length;
+      a32 = adler32(a32, &b, 1);
+      c32 = crc32(c32, &b, 1);
+   }
+
+   if (ferror(ip))
+      return 0;
+
+   /* Success */
+   printf("PNG_ICC_CHECKSUM(0x%8.8lx, 0x%8.8lx,\n   PNG_MD5("
+      "0x%2.2x%2.2x%2.2x%2.2x, 0x%2.2x%2.2x%2.2x%2.2x, 0x%2.2x%2.2x%2.2x%2.2x,"
+      " 0x%2.2x%2.2x%2.2x%2.2x), %d,\n"
+      "   \"%4.4d/%2.2d/%2.2d %2.2d:%2.2d:%2.2d\", %lu, \"%s\")\n",
+      (unsigned long)a32, (unsigned long)c32,
+      header[84], header[85], header[86], header[87],
+      header[88], header[89], header[90], header[91],
+      header[92], header[93], header[94], header[95],
+      header[96], header[97], header[98], header[99],
+#     define u16(x) (header[x] * 256 + header[x+1])
+#     define u32(x) (u16(x) * 65536 + u16(x+2))
+      u32(64), u16(24), u16(26), u16(28), u16(30), u16(32), u16(34),
+      (unsigned long)length, name);
+
+   return 1;
+}
+
+int main(int argc, char **argv)
+{
+   int err = 0;
+
+   printf("/* adler32, crc32, MD5[16], intent, date, length, file-name */\n");
+
+   if (argc > 1)
+   {
+      int i;
+
+      for (i=1; i<argc; ++i)
+      {
+         FILE *ip = fopen(argv[i], "rb");
+
+         if (ip == NULL || !read_one_file(ip, argv[i]))
+         {
+            err = 1;
+            perror(argv[i]);
+            fprintf(stderr, "%s: read error\n", argv[i]);
+            printf("/* ERROR: %s */\n", argv[i]);
+         }
+
+         (void)fclose(ip);
+      }
+   }
+
+   else
+   {
+      if (!read_one_file(stdin, "-"))
+      {
+         err = 1;
+         perror("stdin");
+         fprintf(stderr, "stdin: read error\n");
+         printf("/* ERROR: stdin */\n");
+      }
+   }
+
+   return err;
+}
diff --git a/Engine/lib/lpng/contrib/tools/chkfmt b/Engine/lib/lpng/contrib/tools/chkfmt
new file mode 100755
index 000000000..95181fde2
--- /dev/null
+++ b/Engine/lib/lpng/contrib/tools/chkfmt
@@ -0,0 +1,144 @@
+#!/bin/sh
+
+# chkfmt
+#
+# COPYRIGHT: Written by John Cunningham Bowler, 2010.
+# To the extent possible under law, the author has waived all copyright and
+# related or neighboring rights to this work.  This work is published from:
+# United States.
+#
+# Check the format of the source files in the current directory - checks for a
+# line length of 80 characters max and no tab characters.
+#
+# Optionally arguments are files or directories to check.
+#
+# -v: output the long lines (makes fixing them easier)
+# -e: spawn an editor for each file that needs a change ($EDITOR must be
+#     defined).  When using -e the script MUST be run from an interactive
+#     command line.
+verbose=
+edit=
+vers=
+test "$1" = "-v" && {
+   shift
+   verbose=yes
+}
+test "$1" = "-e" && {
+   shift
+   if test -n "$EDITOR"
+   then
+      edit=yes
+
+      # Copy the standard streams for the editor
+      exec 3>&0 4>&1 5>&2
+   else
+      echo "chkfmt -e: EDITOR must be defined" >&2
+      exit 1
+   fi
+}
+
+# Function to edit a single file - if the file isn't changed ask the user
+# whether or not to continue.  This stuff only works if the script is run from
+# the command line (otherwise, don't specify -e or you will be sorry).
+doed(){
+   cp "$file" "$file".orig
+   "$EDITOR" "$file" 0>&3 1>&4 2>&5 3>&- 4>&- 5>&- || exit 1
+   if cmp -s "$file".orig "$file"
+   then
+      rm "$file".orig
+      echo -n "$file: file not changed, type anything to continue: " >&5
+      read ans 0>&3
+      test -n "$ans" || return 1
+   fi
+   return 0
+}
+
+# In beta versions the version string which appears in files can be a little
+# long and cause spuriously overlong lines.  To avoid this substitute the version
+# string with a 'standard' version a.b.cc before checking for long lines.
+if test -r png.h
+then
+   vers="`sed -n -e \
+   's/^#define PNG_LIBPNG_VER_STRING .\([0-9]\.[0-9]\.[0-9][0-9a-z]*\).$/\1/p' \
+   png.h`"
+   echo "chkfmt: checking version $vers"
+fi
+if test -z "$vers"
+then
+   echo "chkfmt: png.h not found, ignoring version number" >&2
+fi
+
+test -n "$1" || set -- .
+find "$@" \( -type d \( -name '.git' -o -name '.libs' -o -name 'projects' \) \
+   -prune \) -o \( -type f \
+   ! -name '*.[oa]' ! -name '*.l[oa]' !  -name '*.png' ! -name '*.out' \
+   ! -name '*.jpg' ! -name '*.patch' ! -name '*.obj' ! -name '*.exe' \
+   ! -name '*.com' ! -name '*.tar.*' ! -name '*.zip' ! -name '*.ico' \
+   ! -name '*.res' ! -name '*.rc' ! -name '*.mms' ! -name '*.rej' \
+   ! -name '*.dsp' ! -name '*.orig' ! -name '*.dfn' ! -name '*.swp' \
+   ! -name '~*' ! -name '*.3' \
+   ! -name 'missing' ! -name 'mkinstalldirs' ! -name 'depcomp' \
+   ! -name 'aclocal.m4' ! -name 'install-sh' ! -name 'Makefile.in' \
+   ! -name 'ltmain.sh' ! -name 'config*' -print \) | {
+   st=0
+   while read file
+   do
+      case "$file" in
+      *.mak|*[Mm]akefile.*|*[Mm]akefile)
+         # Makefiles require tabs, dependency lines can be this long.
+         check_tabs=
+         line_length=100;;
+      *.awk)
+         # Includes literal tabs
+         check_tabs=
+         # The following is arbitrary
+         line_length=132;;
+      *contrib/*/*.[ch])
+         check_tabs=yes
+         line_length=96;;
+      *)
+         check_tabs=yes
+         line_length=80;;
+      esac
+
+      # Note that vers can only contain 0-9, . and a-z
+      if test -n "$vers"
+      then
+         sed -e "s/$vers/a.b.cc/g" "$file" >"$file".$$
+      else
+         cp "$file" "$file".$$
+      fi
+      splt="`fold -$line_length "$file".$$ | diff -c "$file".$$ -`"
+      rm "$file".$$
+
+      if test -n "$splt"
+      then
+         echo "$file: lines too long"
+         st=1
+         if test -n "$EDITOR" -a -n "$edit"
+         then
+            doed "$file" || exit 1
+         elif test -n "$verbose"
+         then
+            echo "$splt"
+         fi
+      fi
+      if test -n "$check_tabs"
+      then
+         tab="`tr -c -d '\t' <"$file"`"
+         if test -n "$tab"
+         then
+            echo "$file: file contains tab characters"
+            st=1
+            if test -n "$EDITOR" -a -n "$edit"
+            then
+               doed "$file" || exit 1
+            elif test -n "$verbose"
+            then
+               echo "$splt"
+            fi
+         fi
+      fi
+   done
+   exit $st
+}
diff --git a/Engine/lib/lpng/contrib/tools/cvtcolor.c b/Engine/lib/lpng/contrib/tools/cvtcolor.c
new file mode 100644
index 000000000..e6793c7d5
--- /dev/null
+++ b/Engine/lib/lpng/contrib/tools/cvtcolor.c
@@ -0,0 +1,188 @@
+/*-
+ * convert.c
+ *
+ * Last changed in libpng 1.6.0 [February 14, 2013]
+ *
+ * COPYRIGHT: Written by John Cunningham Bowler, 2013.
+ * To the extent possible under law, the author has waived all copyright and
+ * related or neighboring rights to this work.  This work is published from:
+ * United States.
+ *
+ * Convert 8-bit sRGB or 16-bit linear values to another format.
+ */
+#define _ISOC99_SOURCE 1
+
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <stdio.h>
+
+#include <fenv.h>
+
+#include "sRGB.h"
+
+static void
+usage(const char *prog)
+{
+   fprintf(stderr,
+      "%s: usage: %s [-linear|-sRGB] [-gray|-color] component{1,4}\n",
+      prog, prog);
+   exit(1);
+}
+
+unsigned long
+component(const char *prog, const char *arg, int issRGB)
+{
+   char *ep;
+   unsigned long c = strtoul(arg, &ep, 0);
+
+   if (ep <= arg || *ep || c > 65535 || (issRGB && c > 255))
+   {
+      fprintf(stderr, "%s: %s: invalid component value (%lu)\n", prog, arg, c);
+      usage(prog);
+   }
+
+   return c;
+}
+
+int
+main(int argc, const char **argv)
+{
+   const char *prog = *argv++;
+   int to_linear = 0, to_gray = 0, to_color = 0;
+   int channels = 0;
+   double c[4];
+
+   /* FE_TONEAREST is the IEEE754 round to nearest, preferring even, mode; i.e.
+    * everything rounds to the nearest value except that '.5' rounds to the
+    * nearest even value.
+    */
+   fesetround(FE_TONEAREST);
+
+   c[3] = c[2] = c[1] = c[0] = 0;
+
+   while (--argc > 0 && **argv == '-')
+   {
+      const char *arg = 1+*argv++;
+
+      if (strcmp(arg, "sRGB") == 0)
+         to_linear = 0;
+
+      else if (strcmp(arg, "linear") == 0)
+         to_linear = 1;
+
+      else if (strcmp(arg, "gray") == 0)
+         to_gray = 1, to_color = 0;
+
+      else if (strcmp(arg, "color") == 0)
+         to_gray = 0, to_color = 1;
+
+      else
+         usage(prog);
+   }
+
+   switch (argc)
+   {
+      default:
+         usage(prog);
+         break;
+
+      case 4:
+         c[3] = component(prog, argv[3], to_linear);
+         ++channels;
+      case 3:
+         c[2] = component(prog, argv[2], to_linear);
+         ++channels;
+      case 2:
+         c[1] = component(prog, argv[1], to_linear);
+         ++channels;
+      case 1:
+         c[0] = component(prog, argv[0], to_linear);
+         ++channels;
+         break;
+      }
+
+   if (to_linear)
+   {
+      int i;
+      int components = channels;
+
+      if ((components & 1) == 0)
+         --components;
+
+      for (i=0; i<components; ++i) c[i] = linear_from_sRGB(c[i] / 255);
+      if (components < channels)
+         c[components] = c[components] / 255;
+   }
+
+   else
+   {
+      int i;
+      for (i=0; i<4; ++i) c[i] /= 65535;
+
+      if ((channels & 1) == 0)
+      {
+         double alpha = c[channels-1];
+
+         if (alpha > 0)
+            for (i=0; i<channels-1; ++i) c[i] /= alpha;
+         else
+            for (i=0; i<channels-1; ++i) c[i] = 1;
+      }
+   }
+
+   if (to_gray)
+   {
+      if (channels < 3)
+      {
+         fprintf(stderr, "%s: too few channels (%d) for -gray\n",
+            prog, channels);
+         usage(prog);
+      }
+
+      c[0] = YfromRGB(c[0], c[1], c[2]);
+      channels -= 2;
+   }
+
+   if (to_color)
+   {
+      if (channels > 2)
+      {
+         fprintf(stderr, "%s: too many channels (%d) for -color\n",
+            prog, channels);
+         usage(prog);
+      }
+
+      c[3] = c[1]; /* alpha, if present */
+      c[2] = c[1] = c[0];
+   }
+
+   if (to_linear)
+   {
+      int i;
+      if ((channels & 1) == 0)
+      {
+         double alpha = c[channels-1];
+         for (i=0; i<channels-1; ++i) c[i] *= alpha;
+      }
+
+      for (i=0; i<channels; ++i) c[i] = nearbyint(c[i] * 65535);
+   }
+
+   else /* to sRGB */
+   {
+      int i = (channels+1)&~1;
+      while (--i >= 0)
+         c[i] = sRGB_from_linear(c[i]);
+
+      for (i=0; i<channels; ++i) c[i] = nearbyint(c[i] * 255);
+   }
+
+   {
+      int i;
+      for (i=0; i<channels; ++i) printf(" %g", c[i]);
+   }
+   printf("\n");
+
+   return 0;
+}
diff --git a/Engine/lib/lpng/contrib/tools/genpng.c b/Engine/lib/lpng/contrib/tools/genpng.c
new file mode 100644
index 000000000..0b3f98196
--- /dev/null
+++ b/Engine/lib/lpng/contrib/tools/genpng.c
@@ -0,0 +1,881 @@
+/*- genpng
+ *
+ * COPYRIGHT: Written by John Cunningham Bowler, 2015.
+ * Revised by Glenn Randers-Pehrson, 2017, to add buffer-size check.
+ * To the extent possible under law, the authors have waived all copyright and
+ * related or neighboring rights to this work.  This work is published from:
+ * United States.
+ *
+ * Generate a PNG with an alpha channel, correctly.
+ *
+ * This is a test case generator; the resultant PNG files are only of interest
+ * to those of us who care about whether the edges of circles are green, red,
+ * or yellow.
+ *
+ * The program generates an RGB+Alpha PNG of a given size containing the given
+ * shapes on a transparent background:
+ *
+ *  genpng width height { shape }
+ *    shape ::= color width shape x1 y1 x2 y2
+ *
+ * 'color' is:
+ *
+ *  black white red green yellow blue brown purple pink orange gray cyan
+ *
+ * The point is to have colors that are linguistically meaningful plus that old
+ * bugbear of the department store dress murders, Cyan, the only color we argue
+ * about.
+ *
+ * 'shape' is:
+ *
+ *  circle: an ellipse
+ *  square: a rectangle
+ *  line: a straight line
+ *
+ * Each shape is followed by four numbers, these are two points in the output
+ * coordinate space (as real numbers) which describe the circle, square, or
+ * line.  The shape is filled if it is preceded by 'filled' (not valid for
+ * 'line') or is drawn with a line, in which case the width of the line must
+ * precede the shape.
+ *
+ * The whole set of information can be repeated as many times as desired:
+ *
+ *    shape ::= color width shape x1 y1 x2 y2
+ *
+ *    color ::= black|white|red|green|yellow|blue
+ *    color ::= brown|purple|pink|orange|gray|cyan
+ *    width ::= filled
+ *    width ::= <number>
+ *    shape ::= circle|square|line
+ *    x1    ::= <number>
+ *    x2    ::= <number>
+ *    y1    ::= <number>
+ *    y2    ::= <number>
+ *
+ * The output PNG is generated by down-sampling a 4x supersampled image using
+ * a bi-cubic filter.  The bi-cubic has a 2 (output) pixel width, so an 8x8
+ * array of super-sampled points contribute to each output pixel.  The value of
+ * a super-sampled point is found using an unfiltered, aliased, infinite
+ * precision image: Each shape from the last to the first is checked to see if
+ * the point is in the drawn area and, if it is, the color of the point is the
+ * color of the shape and the alpha is 1, if not the previous shape is checked.
+ *
+ * This is an aliased algorithm because no filtering is done; a point is either
+ * inside or outside each shape and 'close' points do not contribute to the
+ * sample.  The down-sampling is relied on to correct the error of not using
+ * a filter.
+ *
+ * The line end-caps are 'flat'; they go through the points.  The square line
+ * joins are mitres; the outside of the lines are continued to the point of
+ * intersection.
+ */
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <math.h>
+
+/* Normally use <png.h> here to get the installed libpng, but this is done to
+ * ensure the code picks up the local libpng implementation:
+ */
+#include "../../png.h"
+
+#if defined(PNG_SIMPLIFIED_WRITE_SUPPORTED) && defined(PNG_STDIO_SUPPORTED)
+
+static const struct color
+{
+   const char *name;
+   double      red;
+   double      green;
+   double      blue;
+} colors[] =
+/* color ::= black|white|red|green|yellow|blue
+ * color ::= brown|purple|pink|orange|gray|cyan
+ */
+{
+   { "black",   0,    0,  0 },
+   { "white",   1,    1,  1 },
+   { "red",     1,    0,  0 },
+   { "green",   0,    1,  0 },
+   { "yellow",  1,    1,  0 },
+   { "blue",    0,    0,  1 },
+   { "brown",  .5, .125,  0 },
+   { "purple",  1,    0,  1 },
+   { "pink",    1,   .5, .5 },
+   { "orange",  1,   .5,  0 },
+   { "gray",    0,   .5, .5 },
+   { "cyan",    0,    1,  1 }
+};
+#define color_count ((sizeof colors)/(sizeof colors[0]))
+
+static const struct color *
+color_of(const char *arg)
+{
+   int icolor = color_count;
+
+   while (--icolor >= 0)
+   {
+      if (strcmp(colors[icolor].name, arg) == 0)
+         return colors+icolor;
+   }
+
+   fprintf(stderr, "genpng: invalid color %s\n", arg);
+   exit(1);
+}
+
+static double
+width_of(const char *arg)
+{
+   if (strcmp(arg, "filled") == 0)
+      return 0;
+
+   else
+   {
+      char *ep = NULL;
+      double w = strtod(arg, &ep);
+
+      if (ep != NULL && *ep == 0 && w > 0)
+         return w;
+   }
+
+   fprintf(stderr, "genpng: invalid line width %s\n", arg);
+   exit(1);
+}
+
+static double
+coordinate_of(const char *arg)
+{
+   char *ep = NULL;
+   double w = strtod(arg, &ep);
+
+   if (ep != NULL && *ep == 0)
+      return w;
+
+   fprintf(stderr, "genpng: invalid coordinate value %s\n", arg);
+   exit(1);
+}
+
+struct arg; /* forward declaration */
+
+typedef int (*shape_fn_ptr)(const struct arg *arg, double x, double y);
+   /* A function to determine if (x,y) is inside the shape.
+    *
+    * There are two implementations:
+    *
+    *    inside_fn: returns true if the point is inside
+    *    check_fn:  returns;
+    *       -1: the point is outside the shape by more than the filter width (2)
+    *        0: the point may be inside the shape
+    *       +1: the point is inside the shape by more than the filter width
+    */
+#define OUTSIDE (-1)
+#define INSIDE  (1)
+
+struct arg
+{
+   const struct color *color;
+   shape_fn_ptr        inside_fn;
+   shape_fn_ptr        check_fn;
+   double              width; /* line width, 0 for 'filled' */
+   double              x1, y1, x2, y2;
+};
+
+/* IMPLEMENTATION NOTE:
+ *
+ * We want the contribution of each shape to the sample corresponding to each
+ * pixel.  This could be obtained by super sampling the image to infinite
+ * dimensions, finding each point within the shape and assigning that a value
+ * '1' while leaving every point outside the shape with value '0' then
+ * downsampling to the image size with sinc; computationally very expensive.
+ *
+ * Approximations are as follows:
+ *
+ * 1) If the pixel coordinate is within the shape assume the sample has the
+ *    shape color and is opaque, else assume there is no contribution from
+ *    the shape.
+ *
+ *    This is the equivalent of aliased rendering or resampling an image with
+ *    a block filter.  The maximum error in the calculated alpha (which will
+ *    always be 0 or 1) is 0.5.
+ *
+ * 2) If the shape is within a square of size 1x1 centered on the pixel assume
+ *    that the shape obscures an amount of the pixel equal to its area within
+ *    that square.
+ *
+ *    This is the equivalent of 'pixel coverage' alpha calculation or resampling
+ *    an image with a bi-linear filter.  The maximum error is over 0.2, but the
+ *    results are often acceptable.
+ *
+ *    This can be approximated by applying (1) to a super-sampled image then
+ *    downsampling with a bi-linear filter.  The error in the super-sampled
+ *    image is 0.5 per sample, but the resampling reduces this.
+ *
+ * 3) Use a better filter with a super-sampled image; in the limit this is the
+ *    sinc() approach.
+ *
+ * 4) Do the geometric calculation; a bivariate definite integral across the
+ *    shape, unfortunately this means evaluating Si(x), the integral of sinc(x),
+ *    which is still a lot of math.
+ *
+ * This code uses approach (3) with a bi-cubic filter and 8x super-sampling
+ * and method (1) for the super-samples.  This means that the sample is either
+ * 0 or 1, depending on whether the sub-pixel is within or outside the shape.
+ * The bi-cubic weights are also fixed and the 16 required weights are
+ * pre-computed here (note that the 'scale' setting will need to be changed if
+ * 'super' is increased).
+ *
+ * The code also calculates a sum to the edge of the filter. This is not
+ * currently used by could be used to optimize the calculation.
+ */
+#if 0 /* bc code */
+scale=10
+super=8
+define bicubic(x) {
+   if (x <= 1) return (1.5*x - 2.5)*x*x + 1;
+   if (x <  2) return (((2.5 - 0.5*x)*x - 4)*x + 2);
+   return 0;
+}
+define sum(x) {
+   auto s;
+   s = 0;
+   while (x < 2*super) {
+      s = s + bicubic(x/super);
+      x = x + 1;
+   }
+   return s;
+}
+define results(x) {
+   auto b, s;
+   b = bicubic(x/super);
+   s = sum(x);
+
+   print "   /*", x, "*/ { ", b, ", ", s, " }";
+   return 1;
+}
+x=0
+while (x<2*super) {
+   x = x + results(x)
+   if (x < 2*super) print ","
+   print "\n"
+}
+quit
+#endif
+
+#define BICUBIC1(x) /*     |x| <= 1 */ ((1.5*(x)* - 2.5)*(x)*(x) + 1)
+#define BICUBIC2(x) /* 1 < |x| <  2 */ (((2.5 - 0.5*(x))*(x) - 4)*(x) + 2)
+#define FILTER_WEIGHT 9 /* Twice the first sum below */
+#define FILTER_WIDTH  2 /* Actually half the width; -2..+2 */
+#define FILTER_STEPS  8 /* steps per filter unit */
+static const double
+bicubic[16][2] =
+{
+   /* These numbers are exact; the weight for the filter is 1/9, but this
+    * would make the numbers inexact, so it is not included here.
+    */
+   /*          bicubic      sum        */
+   /* 0*/ { 1.0000000000, 4.5000000000 },
+   /* 1*/ {  .9638671875, 3.5000000000 },
+   /* 2*/ {  .8671875000, 2.5361328125 },
+   /* 3*/ {  .7275390625, 1.6689453125 },
+   /* 4*/ {  .5625000000,  .9414062500 },
+   /* 5*/ {  .3896484375,  .3789062500 },
+   /* 6*/ {  .2265625000, -.0107421875 },
+   /* 7*/ {  .0908203125, -.2373046875 },
+   /* 8*/ {            0, -.3281250000 },
+   /* 9*/ { -.0478515625, -.3281250000 },
+   /*10*/ { -.0703125000, -.2802734375 },
+   /*11*/ { -.0732421875, -.2099609375 },
+   /*12*/ { -.0625000000, -.1367187500 },
+   /*13*/ { -.0439453125, -.0742187500 },
+   /*14*/ { -.0234375000, -.0302734375 },
+   /*15*/ { -.0068359375, -.0068359375 }
+};
+
+static double
+alpha_calc(const struct arg *arg, double x, double y)
+{
+   /* For [x-2..x+2],[y-2,y+2] calculate the weighted bicubic given a function
+    * which tells us whether a point is inside or outside the shape.  First
+    * check if we need to do this at all:
+    */
+   switch (arg->check_fn(arg, x, y))
+   {
+      case OUTSIDE:
+         return 0; /* all samples outside the shape */
+
+      case INSIDE:
+         return 1; /* all samples inside the shape */
+
+      default:
+      {
+         int dy;
+         double alpha = 0;
+
+#        define FILTER_D (FILTER_WIDTH*FILTER_STEPS-1)
+         for (dy=-FILTER_D; dy<=FILTER_D; ++dy)
+         {
+            double wy = bicubic[abs(dy)][0];
+
+            if (wy != 0)
+            {
+               double alphay = 0;
+               int dx;
+
+               for (dx=-FILTER_D; dx<=FILTER_D; ++dx)
+               {
+                  double wx = bicubic[abs(dx)][0];
+
+                  if (wx != 0 && arg->inside_fn(arg, x+dx/16, y+dy/16))
+                     alphay += wx;
+               }
+
+               alpha += wy * alphay;
+            }
+         }
+
+         /* This needs to be weighted for each dimension: */
+         return alpha / (FILTER_WEIGHT*FILTER_WEIGHT);
+      }
+   }
+}
+
+/* These are the shape functions. */
+/* "square",
+ * { inside_square_filled, check_square_filled },
+ * { inside_square, check_square }
+ */
+static int
+square_check(double x, double y, double x1, double y1, double x2, double y2)
+   /* Is x,y inside the square (x1,y1)..(x2,y2)? */
+{
+   /* Do a modified Cohen-Sutherland on one point, bit patterns that indicate
+    * 'outside' are:
+    *
+    *   x<x1 | x<y1 | x<x2 | x<y2
+    *    0      x      0      x     To the right
+    *    1      x      1      x     To the left
+    *    x      0      x      0     Below
+    *    x      1      x      1     Above
+    *
+    * So 'inside' is (x<x1) != (x<x2) && (y<y1) != (y<y2);
+    */
+   return ((x<x1) ^ (x<x2)) & ((y<y1) ^ (y<y2));
+}
+
+static int
+inside_square_filled(const struct arg *arg, double x, double y)
+{
+   return square_check(x, y, arg->x1, arg->y1, arg->x2, arg->y2);
+}
+
+static int
+square_check_line(const struct arg *arg, double x, double y, double w)
+   /* Check for a point being inside the boundaries implied by the given arg
+    * and assuming a width 2*w each side of the boundaries.  This returns the
+    * 'check' INSIDE/OUTSIDE/0 result but note the semantics:
+    *
+    *          +--------------+
+    *          |              |   OUTSIDE
+    *          |   INSIDE     |
+    *          |              |
+    *          +--------------+
+    *
+    * And '0' means within the line boundaries.
+    */
+{
+   double cx = (arg->x1+arg->x2)/2;
+   double wx = fabs(arg->x1-arg->x2)/2;
+   double cy = (arg->y1+arg->y2)/2;
+   double wy = fabs(arg->y1-arg->y2)/2;
+
+   if (square_check(x, y, cx-wx-w, cy-wy-w, cx+wx+w, cy+wy+w))
+   {
+      /* Inside, but maybe too far; check for the redundant case where
+       * the lines overlap:
+       */
+      wx -= w;
+      wy -= w;
+      if (wx > 0 && wy > 0 && square_check(x, y, cx-wx, cy-wy, cx+wx, cy+wy))
+         return INSIDE; /* between (inside) the boundary lines. */
+
+      return 0; /* inside the lines themselves. */
+   }
+
+   return OUTSIDE; /* outside the boundary lines. */
+}
+
+static int
+check_square_filled(const struct arg *arg, double x, double y)
+{
+   /* The filter extends +/-FILTER_WIDTH each side of each output point, so
+    * the check has to expand and contract the square by that amount; '0'
+    * means close enough to the edge of the square that the bicubic filter has
+    * to be run, OUTSIDE means alpha==0, INSIDE means alpha==1.
+    */
+   return square_check_line(arg, x, y, FILTER_WIDTH);
+}
+
+static int
+inside_square(const struct arg *arg, double x, double y)
+{
+   /* Return true if within the drawn lines, else false, no need to distinguish
+    * INSIDE vs OUTSIDE here:
+    */
+   return square_check_line(arg, x, y, arg->width/2) == 0;
+}
+
+static int
+check_square(const struct arg *arg, double x, double y)
+{
+   /* So for this function a result of 'INSIDE' means inside the actual lines.
+    */
+   double w = arg->width/2;
+
+   if (square_check_line(arg, x, y, w+FILTER_WIDTH) == 0)
+   {
+      /* Somewhere close to the boundary lines. If far enough inside one of
+       * them then we can return INSIDE:
+       */
+      w -= FILTER_WIDTH;
+
+      if (w > 0 && square_check_line(arg, x, y, w) == 0)
+         return INSIDE;
+
+      /* Point is somewhere in the filter region: */
+      return 0;
+   }
+
+   else /* Inside or outside the square by more than w+FILTER_WIDTH. */
+      return OUTSIDE;
+}
+
+/* "circle",
+ * { inside_circle_filled, check_circle_filled },
+ * { inside_circle, check_circle }
+ *
+ * The functions here are analoguous to the square ones; however, they check
+ * the corresponding ellipse as opposed to the rectangle.
+ */
+static int
+circle_check(double x, double y, double x1, double y1, double x2, double y2)
+{
+   if (square_check(x, y, x1, y1, x2, y2))
+   {
+      /* Inside the square, so maybe inside the circle too: */
+      const double cx = (x1 + x2)/2;
+      const double cy = (y1 + y2)/2;
+      const double dx = x1 - x2;
+      const double dy = y1 - y2;
+
+      x = (x - cx)/dx;
+      y = (y - cy)/dy;
+
+      /* It is outside if the distance from the center is more than half the
+       * diameter:
+       */
+      return x*x+y*y < .25;
+   }
+
+   return 0; /* outside */
+}
+
+static int
+inside_circle_filled(const struct arg *arg, double x, double y)
+{
+   return circle_check(x, y, arg->x1, arg->y1, arg->x2, arg->y2);
+}
+
+static int
+circle_check_line(const struct arg *arg, double x, double y, double w)
+   /* Check for a point being inside the boundaries implied by the given arg
+    * and assuming a width 2*w each side of the boundaries.  This function has
+    * the same semantic as square_check_line but tests the circle.
+    */
+{
+   double cx = (arg->x1+arg->x2)/2;
+   double wx = fabs(arg->x1-arg->x2)/2;
+   double cy = (arg->y1+arg->y2)/2;
+   double wy = fabs(arg->y1-arg->y2)/2;
+
+   if (circle_check(x, y, cx-wx-w, cy-wy-w, cx+wx+w, cy+wy+w))
+   {
+      /* Inside, but maybe too far; check for the redundant case where
+       * the lines overlap:
+       */
+      wx -= w;
+      wy -= w;
+      if (wx > 0 && wy > 0 && circle_check(x, y, cx-wx, cy-wy, cx+wx, cy+wy))
+         return INSIDE; /* between (inside) the boundary lines. */
+
+      return 0; /* inside the lines themselves. */
+   }
+
+   return OUTSIDE; /* outside the boundary lines. */
+}
+
+static int
+check_circle_filled(const struct arg *arg, double x, double y)
+{
+   return circle_check_line(arg, x, y, FILTER_WIDTH);
+}
+
+static int
+inside_circle(const struct arg *arg, double x, double y)
+{
+   return circle_check_line(arg, x, y, arg->width/2) == 0;
+}
+
+static int
+check_circle(const struct arg *arg, double x, double y)
+{
+   /* Exactly as the 'square' code.  */
+   double w = arg->width/2;
+
+   if (circle_check_line(arg, x, y, w+FILTER_WIDTH) == 0)
+   {
+      w -= FILTER_WIDTH;
+
+      if (w > 0 && circle_check_line(arg, x, y, w) == 0)
+         return INSIDE;
+
+      /* Point is somewhere in the filter region: */
+      return 0;
+   }
+
+   else /* Inside or outside the square by more than w+FILTER_WIDTH. */
+      return OUTSIDE;
+}
+
+/* "line",
+ * { NULL, NULL },  There is no 'filled' line.
+ * { inside_line, check_line }
+ */
+static int
+line_check(double x, double y, double x1, double y1, double x2, double y2,
+   double w, double expand)
+{
+   /* Shift all the points to (arg->x1, arg->y1) */
+   double lx = x2 - x1;
+   double ly = y2 - y1;
+   double len2 = lx*lx + ly*ly;
+   double cross, dot;
+
+   x -= x1;
+   y -= y1;
+
+   /* The dot product is the distance down the line, the cross product is
+    * the distance away from the line:
+    *
+    *    distance = |cross| / sqrt(len2)
+    */
+   cross = x * ly - y * lx;
+
+   /* If 'distance' is more than w the point is definitely outside the line:
+    *
+    *     distance >= w
+    *     |cross|  >= w * sqrt(len2)
+    *     cross^2  >= w^2 * len2:
+    */
+   if (cross*cross >= (w+expand)*(w+expand)*len2)
+      return 0; /* outside */
+
+   /* Now find the distance *along* the line; this comes from the dot product
+    * lx.x+ly.y. The actual distance (in pixels) is:
+    *
+    *   distance = dot / sqrt(len2)
+    */
+   dot = lx * x + ly * y;
+
+   /* The test for 'outside' is:
+    *
+    *    distance < 0 || distance > sqrt(len2)
+    *                 -> dot / sqrt(len2) > sqrt(len2)
+    *                 -> dot > len2
+    *
+    * But 'expand' is used for the filter width and needs to be handled too:
+    */
+   return dot > -expand && dot < len2+expand;
+}
+
+static int
+inside_line(const struct arg *arg, double x, double y)
+{
+   return line_check(x, y, arg->x1, arg->y1, arg->x2, arg->y2, arg->width/2, 0);
+}
+
+static int
+check_line(const struct arg *arg, double x, double y)
+{
+   /* The end caps of the line must be checked too; it's not enough just to
+    * widen the line by FILTER_WIDTH; 'expand' exists for this purpose:
+    */
+   if (line_check(x, y, arg->x1, arg->y1, arg->x2, arg->y2, arg->width/2,
+       FILTER_WIDTH))
+   {
+      /* Inside the line+filter; far enough inside that the filter isn't
+       * required?
+       */
+      if (arg->width > 2*FILTER_WIDTH &&
+          line_check(x, y, arg->x1, arg->y1, arg->x2, arg->y2, arg->width/2,
+             -FILTER_WIDTH))
+         return INSIDE;
+
+      return 0;
+   }
+
+   return OUTSIDE;
+}
+
+static const struct
+{
+   const char    *name;
+   shape_fn_ptr   function[2/*fill,line*/][2];
+#  define         FN_INSIDE 0
+#  define         FN_CHECK 1
+} shape_defs[] =
+{
+   {  "square",
+      {  { inside_square_filled, check_square_filled },
+         { inside_square, check_square } }
+   },
+   {  "circle",
+      {  { inside_circle_filled, check_circle_filled },
+         { inside_circle, check_circle } }
+   },
+   {  "line",
+      {  { NULL, NULL },
+         { inside_line, check_line } }
+   }
+};
+
+#define shape_count ((sizeof shape_defs)/(sizeof shape_defs[0]))
+
+static shape_fn_ptr
+shape_of(const char *arg, double width, int f)
+{
+   unsigned int i;
+
+   for (i=0; i<shape_count; ++i) if (strcmp(shape_defs[i].name, arg) == 0)
+   {
+      shape_fn_ptr fn = shape_defs[i].function[width != 0][f];
+
+      if (fn != NULL)
+         return fn;
+
+      fprintf(stderr, "genpng: %s %s not supported\n",
+         width == 0 ? "filled" : "unfilled", arg);
+      exit(1);
+   }
+
+   fprintf(stderr, "genpng: %s: not a valid shape name\n", arg);
+   exit(1);
+}
+
+static void
+parse_arg(struct arg *arg, const char **argv/*7 arguments*/)
+{
+   /* shape ::= color width shape x1 y1 x2 y2 */
+   arg->color = color_of(argv[0]);
+   arg->width = width_of(argv[1]);
+   arg->inside_fn = shape_of(argv[2], arg->width, FN_INSIDE);
+   arg->check_fn = shape_of(argv[2], arg->width, FN_CHECK);
+   arg->x1 = coordinate_of(argv[3]);
+   arg->y1 = coordinate_of(argv[4]);
+   arg->x2 = coordinate_of(argv[5]);
+   arg->y2 = coordinate_of(argv[6]);
+}
+
+static png_uint_32
+read_wh(const char *name, const char *str)
+   /* read a PNG width or height */
+{
+   char *ep = NULL;
+   unsigned long ul = strtoul(str, &ep, 10);
+
+   if (ep != NULL && *ep == 0 && ul > 0 && ul <= 0x7fffffff)
+      return (png_uint_32)/*SAFE*/ul;
+
+   fprintf(stderr, "genpng: %s: invalid number %s\n", name, str);
+   exit(1);
+}
+
+static void
+pixel(png_uint_16p p, struct arg *args, int nargs, double x, double y)
+{
+   /* Fill in the pixel by checking each shape (args[nargs]) for effects on
+    * the corresponding sample:
+    */
+   double r=0, g=0, b=0, a=0;
+
+   while (--nargs >= 0 && a != 1)
+   {
+      /* NOTE: alpha_calc can return a value outside the range 0..1 with the
+       * bicubic filter.
+       */
+      const double alpha = alpha_calc(args+nargs, x, y) * (1-a);
+
+      r += alpha * args[nargs].color->red;
+      g += alpha * args[nargs].color->green;
+      b += alpha * args[nargs].color->blue;
+      a += alpha;
+   }
+
+   /* 'a' may be negative or greater than 1; if it is, negative clamp the
+    * pixel to 0 if >1 clamp r/g/b:
+    */
+   if (a > 0)
+   {
+      if (a > 1)
+      {
+         if (r > 1) r = 1;
+         if (g > 1) g = 1;
+         if (b > 1) b = 1;
+         a = 1;
+      }
+
+      /* And fill in the pixel: */
+      p[0] = (png_uint_16)/*SAFE*/round(r * 65535);
+      p[1] = (png_uint_16)/*SAFE*/round(g * 65535);
+      p[2] = (png_uint_16)/*SAFE*/round(b * 65535);
+      p[3] = (png_uint_16)/*SAFE*/round(a * 65535);
+   }
+
+   else
+      p[3] = p[2] = p[1] = p[0] = 0;
+}
+
+int
+main(int argc, const char **argv)
+{
+   int convert_to_8bit = 0;
+
+   /* There is one option: --8bit: */
+   if (argc > 1 && strcmp(argv[1], "--8bit") == 0)
+      --argc, ++argv, convert_to_8bit = 1;
+
+   if (argc >= 3)
+   {
+      png_uint_16p buffer;
+      int nshapes;
+      png_image image;
+#     define max_shapes 256
+      struct arg arg_list[max_shapes];
+
+      /* The libpng Simplified API write code requires a fully initialized
+       * structure.
+       */
+      memset(&image, 0, sizeof image);
+      image.version = PNG_IMAGE_VERSION;
+      image.opaque = NULL;
+      image.width = read_wh("width", argv[1]);
+      image.height = read_wh("height", argv[2]);
+      image.format = PNG_FORMAT_LINEAR_RGB_ALPHA;
+      image.flags = 0;
+      image.colormap_entries = 0;
+
+      /* Check the remainder of the arguments */
+      for (nshapes=0; 3+7*(nshapes+1) <= argc && nshapes < max_shapes;
+           ++nshapes)
+         parse_arg(arg_list+nshapes, argv+3+7*nshapes);
+
+      if (3+7*nshapes != argc)
+      {
+         fprintf(stderr, "genpng: %s: too many arguments\n", argv[3+7*nshapes]);
+         return 1;
+      }
+
+#if 1
+     /* TO do: determine whether this guard against overflow is necessary.
+      * This comment in png.h indicates that it should be safe: "libpng will
+      * refuse to process an image where such an overflow would occur", but
+      * I don't see where the image gets rejected when the buffer is too
+      * large before the malloc is attempted.
+      */
+      if (image.height > ((size_t)(-1))/(8*image.width)) {
+         fprintf(stderr, "genpng: image buffer would be too big");
+         return 1;
+      }
+#endif
+
+      /* Create the buffer: */
+      buffer = malloc(PNG_IMAGE_SIZE(image));
+
+      if (buffer != NULL)
+      {
+         png_uint_32 y;
+
+         /* Write each row... */
+         for (y=0; y<image.height; ++y)
+         {
+            png_uint_32 x;
+
+            /* Each pixel in each row: */
+            for (x=0; x<image.width; ++x)
+               pixel(buffer + 4*(x + y*image.width), arg_list, nshapes, x, y);
+         }
+
+         /* Write the result (to stdout) */
+         if (png_image_write_to_stdio(&image, stdout, convert_to_8bit,
+             buffer, 0/*row_stride*/, NULL/*colormap*/))
+         {
+            free(buffer);
+            return 0; /* success */
+         }
+
+         else
+            fprintf(stderr, "genpng: write stdout: %s\n", image.message);
+
+         free(buffer);
+      }
+
+      else
+         fprintf(stderr, "genpng: out of memory: %lu bytes\n",
+               (unsigned long)PNG_IMAGE_SIZE(image));
+   }
+
+   else
+   {
+      /* Wrong number of arguments */
+      fprintf(stderr, "genpng: usage: genpng [--8bit] width height {shape}\n"
+         " Generate a transparent PNG in RGBA (truecolor+alpha) format\n"
+         " containing the given shape or shapes.  Shapes are defined:\n"
+         "\n"
+         "  shape ::= color width shape x1 y1 x2 y2\n"
+         "  color ::= black|white|red|green|yellow|blue\n"
+         "  color ::= brown|purple|pink|orange|gray|cyan\n"
+         "  width ::= filled|<number>\n"
+         "  shape ::= circle|square|line\n"
+         "  x1,x2 ::= <number>\n"
+         "  y1,y2 ::= <number>\n"
+         "\n"
+         " Numbers are floating point numbers describing points relative to\n"
+         " the top left of the output PNG as pixel coordinates.  The 'width'\n"
+         " parameter is either the width of the line (in output pixels) used\n"
+         " to draw the shape or 'filled' to indicate that the shape should\n"
+         " be filled with the color.\n"
+         "\n"
+         " Colors are interpreted loosely to give access to the eight full\n"
+         " intensity RGB values:\n"
+         "\n"
+         "  black, red, green, blue, yellow, cyan, purple, white,\n"
+         "\n"
+         " Cyan is full intensity blue+green; RGB(0,1,1), plus the following\n"
+         " lower intensity values:\n"
+         "\n"
+         "  brown:  red+orange:  RGB(0.5, 0.125, 0) (dark red+orange)\n"
+         "  pink:   red+white:   RGB(1.0, 0.5,   0.5)\n"
+         "  orange: red+yellow:  RGB(1.0, 0.5,   0)\n"
+         "  gray:   black+white: RGB(0.5, 0.5,   0.5)\n"
+         "\n"
+         " The RGB values are selected to make detection of aliasing errors\n"
+         " easy. The names are selected to make the description of errors\n"
+         " easy.\n"
+         "\n"
+         " The PNG is written to stdout, if --8bit is given a 32bpp RGBA sRGB\n"
+         " file is produced, otherwise a 64bpp RGBA linear encoded file is\n"
+         " written.\n");
+   }
+
+   return 1;
+}
+#endif /* SIMPLIFIED_WRITE && STDIO */
diff --git a/Engine/lib/lpng/contrib/tools/intgamma.sh b/Engine/lib/lpng/contrib/tools/intgamma.sh
new file mode 100755
index 000000000..41c5d6dd2
--- /dev/null
+++ b/Engine/lib/lpng/contrib/tools/intgamma.sh
@@ -0,0 +1,110 @@
+#!/bin/sh
+#
+# intgamma.sh
+#
+# Last changed in libpng 1.6.0 [February 14, 2013]
+#
+# COPYRIGHT: Written by John Cunningham Bowler, 2013.
+# To the extent possible under law, the author has waived all copyright and
+# related or neighboring rights to this work.  This work is published from:
+# United States.
+#
+# Shell script to generate png.c 8-bit and 16-bit log tables (see the code in
+# png.c for details).
+#
+# This script uses the "bc" arbitrary precision calculator to calculate 32-bit
+# fixed point values of logarithms appropriate to finding the log of an 8-bit
+# (0..255) value and a similar table for the exponent calculation.
+#
+# "bc" must be on the path when the script is executed, and the math library
+# (-lm) must be available
+#
+# function to print out a list of numbers as integers; the function truncates
+# the integers which must be one-per-line
+function print(){
+   awk 'BEGIN{
+      str = ""
+   }
+   {
+      sub("\\.[0-9]*$", "")
+      if ($0 == "")
+         $0 = "0"
+
+      if (str == "")
+         t = "   " $0 "U"
+      else
+         t = str ", " $0 "U"
+
+      if (length(t) >= 80) {
+         print str ","
+         str = "   " $0 "U"
+      } else
+         str = t
+   }
+   END{
+      print str
+   }'
+}
+#
+# The logarithm table.
+cat <<END
+/* 8-bit log table: png_8bit_l2[128]
+ * This is a table of -log(value/255)/log(2) for 'value' in the range 128 to
+ * 255, so it's the base 2 logarithm of a normalized 8-bit floating point
+ * mantissa.  The numbers are 32-bit fractions.
+ */
+static const png_uint_32
+png_8bit_l2[128] =
+{
+END
+#
+bc -lqws <<END | print
+f=65536*65536/l(2)
+for (i=128;i<256;++i) { .5 - l(i/255)*f; }
+END
+echo '};'
+echo
+#
+# The exponent table.
+cat <<END
+/* The 'exp()' case must invert the above, taking a 20-bit fixed point
+ * logarithmic value and returning a 16 or 8-bit number as appropriate.  In
+ * each case only the low 16 bits are relevant - the fraction - since the
+ * integer bits (the top 4) simply determine a shift.
+ *
+ * The worst case is the 16-bit distinction between 65535 and 65534; this
+ * requires perhaps spurious accuracy in the decoding of the logarithm to
+ * distinguish log2(65535/65534.5) - 10^-5 or 17 bits.  There is little chance
+ * of getting this accuracy in practice.
+ *
+ * To deal with this the following exp() function works out the exponent of the
+ * frational part of the logarithm by using an accurate 32-bit value from the
+ * top four fractional bits then multiplying in the remaining bits.
+ */
+static const png_uint_32
+png_32bit_exp[16] =
+{
+END
+#
+bc -lqws <<END | print
+f=l(2)/16
+for (i=0;i<16;++i) {
+   x = .5 + e(-i*f)*2^32;
+   if (x >= 2^32) x = 2^32-1;
+   x;
+}
+END
+echo '};'
+echo
+#
+# And the table of adjustment values.
+cat <<END
+/* Adjustment table; provided to explain the numbers in the code below. */
+#if 0
+END
+bc -lqws <<END | awk '{ printf "%5d %s\n", 12-NR, $0 }'
+for (i=11;i>=0;--i){
+   (1 - e(-(2^i)/65536*l(2))) * 2^(32-i)
+}
+END
+echo '#endif'
diff --git a/Engine/lib/lpng/contrib/tools/makesRGB.c b/Engine/lib/lpng/contrib/tools/makesRGB.c
new file mode 100644
index 000000000..d0c0ca931
--- /dev/null
+++ b/Engine/lib/lpng/contrib/tools/makesRGB.c
@@ -0,0 +1,430 @@
+/* makesRGB.c -- build sRGB-to-linear and linear-to-sRGB conversion tables
+ *
+ * Last changed in libpng 1.6.0 [February 14, 2013]
+ *
+ * COPYRIGHT: Written by John Cunningham Bowler, 2013.
+ * To the extent possible under law, the author has waived all copyright and
+ * related or neighboring rights to this work.  This work is published from:
+ * United States.
+ *
+ * Make a table to convert 8-bit sRGB encoding values into the closest 16-bit
+ * linear value.
+ *
+ * Make two tables to take a linear value scaled to 255*65535 and return an
+ * approximation to the 8-bit sRGB encoded value.  Calculate the error in these
+ * tables and display it.
+ */
+#define _C99_SOURCE 1
+#include <stdio.h>
+#include <math.h>
+#include <stdlib.h>
+
+/* pngpriv.h includes the definition of 'PNG_sRGB_FROM_LINEAR' which is required
+ * to verify the actual code.
+ */
+#include "../../pngpriv.h"
+
+#include "sRGB.h"
+
+/* The tables are declared 'const' in pngpriv.h, so this redefines the tables to
+ * be used.
+ */
+#define png_sRGB_table sRGB_table
+#define png_sRGB_base sRGB_base
+#define png_sRGB_delta sRGB_delta
+
+static png_uint_16 png_sRGB_table[256];
+static png_uint_16 png_sRGB_base[512];
+static png_byte png_sRGB_delta[512];
+
+static const unsigned int max_input = 255*65535;
+
+double
+fsRGB(double l)
+{
+   return sRGB_from_linear(l/max_input);
+}
+
+double
+sRGB(unsigned int i)
+{
+   return fsRGB(i);
+}
+
+double
+finvsRGB(unsigned int i)
+{
+   return 65535 * linear_from_sRGB(i/255.);
+}
+
+png_uint_16
+invsRGB(unsigned int i)
+{
+   unsigned int x = nearbyint(finvsRGB(i));
+
+   if (x > 65535)
+   {
+      fprintf(stderr, "invsRGB(%u) overflows to %u\n", i, x);
+      exit(1);
+   }
+
+   return (png_uint_16)x;
+}
+
+int
+main(int argc, char **argv)
+{
+   unsigned int i, i16, ibase;
+   double min_error = 0;
+   double max_error = 0;
+   double min_error16 = 0;
+   double max_error16 = 0;
+   double adjust;
+   double adjust_lo = 0.4, adjust_hi = 0.6, adjust_mid = 0.5;
+   unsigned int ec_lo = 0, ec_hi = 0, ec_mid = 0;
+   unsigned int error_count = 0;
+   unsigned int error_count16 = 0;
+   int test_only = 0;
+
+   if (argc > 1)
+      test_only = strcmp("--test", argv[1]) == 0;
+
+   /* Initialize the encoding table first. */
+   for (i=0; i<256; ++i)
+   {
+      png_sRGB_table[i] = invsRGB(i);
+   }
+
+   /* Now work out the decoding tables (this is where the error comes in because
+    * there are 512 set points and 512 straight lines between them.)
+    */
+   for (;;)
+   {
+      if (ec_lo == 0)
+         adjust = adjust_lo;
+
+      else if (ec_hi == 0)
+         adjust = adjust_hi;
+
+      else if (ec_mid == 0)
+         adjust = adjust_mid;
+
+      else if (ec_mid < ec_hi)
+         adjust = (adjust_mid + adjust_hi)/2;
+
+      else if (ec_mid < ec_lo)
+         adjust = (adjust_mid + adjust_lo)/2;
+
+      else
+      {
+         fprintf(stderr, "not reached: %u .. %u .. %u\n", ec_lo, ec_mid, ec_hi);
+         exit(1);
+      }
+
+      /* Calculate the table using the current 'adjust' */
+      for (i=0; i<=511; ++i)
+      {
+         double lo = 255 * sRGB(i << 15);
+         double hi = 255 * sRGB((i+1) << 15);
+         unsigned int calc;
+
+         calc = nearbyint((lo+adjust) * 256);
+         if (calc > 65535)
+         {
+            fprintf(stderr, "table[%d][0]: overflow %08x (%d)\n", i, calc,
+               calc);
+            exit(1);
+         }
+         png_sRGB_base[i] = calc;
+
+         calc = nearbyint((hi-lo) * 32);
+         if (calc > 255)
+         {
+            fprintf(stderr, "table[%d][1]: overflow %08x (%d)\n", i, calc,
+               calc);
+            exit(1);
+         }
+         png_sRGB_delta[i] = calc;
+      }
+
+      /* Check the 16-bit linear values alone: */
+      error_count16 = 0;
+      for (i16=0; i16 <= 65535; ++i16)
+      {
+         unsigned int i = 255*i16;
+         unsigned int iexact = nearbyint(255*sRGB(i));
+         unsigned int icalc = PNG_sRGB_FROM_LINEAR(i);
+
+         if (icalc != iexact)
+            ++error_count16;
+      }
+
+      /* Now try changing the adjustment. */
+      if (ec_lo == 0)
+         ec_lo = error_count16;
+
+      else if (ec_hi == 0)
+         ec_hi = error_count16;
+
+      else if (ec_mid == 0)
+      {
+         ec_mid = error_count16;
+         printf("/* initial error counts: %u .. %u .. %u */\n", ec_lo, ec_mid,
+            ec_hi);
+      }
+
+      else if (error_count16 < ec_mid)
+      {
+         printf("/* adjust (mid ): %f: %u -> %u */\n", adjust, ec_mid,
+            error_count16);
+         ec_mid = error_count16;
+         adjust_mid = adjust;
+      }
+
+      else if (adjust < adjust_mid && error_count16 < ec_lo)
+      {
+         printf("/* adjust (low ): %f: %u -> %u */\n", adjust, ec_lo,
+            error_count16);
+         ec_lo = error_count16;
+         adjust_lo = adjust;
+      }
+
+      else if (adjust > adjust_mid && error_count16 < ec_hi)
+      {
+         printf("/* adjust (high): %f: %u -> %u */\n", adjust, ec_hi,
+            error_count16);
+         ec_hi = error_count16;
+         adjust_hi = adjust;
+      }
+
+      else
+      {
+         adjust = adjust_mid;
+         printf("/* adjust: %f: %u */\n", adjust, ec_mid);
+         break;
+      }
+   }
+
+   /* For each entry in the table try to adjust it to minimize the error count
+    * in that entry.  Each entry corresponds to 128 input values.
+    */
+   for (ibase=0; ibase<65536; ibase+=128)
+   {
+      png_uint_16 base = png_sRGB_base[ibase >> 7], trybase = base, ob=base;
+      png_byte delta = png_sRGB_delta[ibase >> 7], trydelta = delta, od=delta;
+      unsigned int ecbase = 0, eco;
+
+      for (;;)
+      {
+         png_sRGB_base[ibase >> 7] = trybase;
+         png_sRGB_delta[ibase >> 7] = trydelta;
+
+         /* Check the 16-bit linear values alone: */
+         error_count16 = 0;
+         for (i16=ibase; i16 < ibase+128; ++i16)
+         {
+            unsigned int i = 255*i16;
+            unsigned int iexact = nearbyint(255*sRGB(i));
+            unsigned int icalc = PNG_sRGB_FROM_LINEAR(i);
+
+            if (icalc != iexact)
+               ++error_count16;
+         }
+
+         if (error_count16 == 0)
+            break;
+
+         if (ecbase == 0)
+         {
+            eco = ecbase = error_count16;
+            ++trybase; /* First test */
+         }
+
+         else if (error_count16 < ecbase)
+         {
+            if (trybase > base)
+            {
+               base = trybase;
+               ++trybase;
+            }
+            else if (trybase < base)
+            {
+               base = trybase;
+               --trybase;
+            }
+            else if (trydelta > delta)
+            {
+               delta = trydelta;
+               ++trydelta;
+            }
+            else if (trydelta < delta)
+            {
+               delta = trydelta;
+               --trydelta;
+            }
+            else
+            {
+               fprintf(stderr, "makesRGB: impossible\n");
+               exit(1);
+            }
+            ecbase = error_count16;
+         }
+
+         else
+         {
+            if (trybase > base)
+               trybase = base-1;
+            else if (trybase < base)
+            {
+               trybase = base;
+               ++trydelta;
+            }
+            else if (trydelta > delta)
+               trydelta = delta-1;
+            else if (trydelta < delta)
+               break; /* end of tests */
+         }
+      }
+
+      png_sRGB_base[ibase >> 7] = base;
+      png_sRGB_delta[ibase >> 7] = delta;
+      if (base != ob || delta != od)
+      {
+         printf("/* table[%u]={%u,%u} -> {%u,%u} %u -> %u errors */\n",
+            ibase>>7, ob, od, base, delta, eco, ecbase);
+      }
+      else if (0)
+         printf("/* table[%u]={%u,%u} %u errors */\n", ibase>>7, ob, od,
+            ecbase);
+   }
+
+   /* Only do the full (slow) test at the end: */
+   min_error = -.4999;
+   max_error = .4999;
+   error_count = 0;
+
+   for (i=0; i <= max_input; ++i)
+   {
+      unsigned int iexact = nearbyint(255*sRGB(i));
+      unsigned int icalc = PNG_sRGB_FROM_LINEAR(i);
+
+      if (icalc != iexact)
+      {
+         double err = 255*sRGB(i) - icalc;
+
+         if (err > (max_error+.001) || err < (min_error-.001))
+         {
+            printf(
+               "/* 0x%08x: exact: %3d, got: %3d [tables: %08x, %08x] (%f) */\n",
+               i, iexact, icalc, png_sRGB_base[i>>15],
+               png_sRGB_delta[i>>15], err);
+         }
+
+         ++error_count;
+         if (err > max_error)
+            max_error = err;
+         else if (err < min_error)
+            min_error = err;
+      }
+   }
+
+   /* Re-check the 16-bit cases too, including the warning if there is an error
+    * bigger than 1.
+    */
+   error_count16 = 0;
+   max_error16 = 0;
+   min_error16 = 0;
+   for (i16=0; i16 <= 65535; ++i16)
+   {
+      unsigned int i = 255*i16;
+      unsigned int iexact = nearbyint(255*sRGB(i));
+      unsigned int icalc = PNG_sRGB_FROM_LINEAR(i);
+
+      if (icalc != iexact)
+      {
+         double err = 255*sRGB(i) - icalc;
+
+         ++error_count16;
+         if (err > max_error16)
+            max_error16 = err;
+         else if (err < min_error16)
+            min_error16 = err;
+
+         if (abs(icalc - iexact) > 1)
+            printf(
+               "/* 0x%04x: exact: %3d, got: %3d [tables: %08x, %08x] (%f) */\n",
+               i16, iexact, icalc, png_sRGB_base[i>>15],
+               png_sRGB_delta[i>>15], err);
+      }
+   }
+
+   /* Check the round trip for each 8-bit sRGB value. */
+   for (i16=0; i16 <= 255; ++i16)
+   {
+      unsigned int i = 255 * png_sRGB_table[i16];
+      unsigned int iexact = nearbyint(255*sRGB(i));
+      unsigned int icalc = PNG_sRGB_FROM_LINEAR(i);
+
+      if (i16 != iexact)
+      {
+         fprintf(stderr, "8-bit rounding error: %d -> %d\n", i16, iexact);
+         exit(1);
+      }
+
+      if (icalc != i16)
+      {
+         double finv = finvsRGB(i16);
+
+         printf("/* 8-bit roundtrip error: %d -> %f -> %d(%f) */\n",
+            i16, finv, icalc, fsRGB(255*finv));
+      }
+   }
+
+
+   printf("/* error: %g - %g, %u (%g%%) of readings inexact */\n",
+      min_error, max_error, error_count, (100.*error_count)/max_input);
+   printf("/* 16-bit error: %g - %g, %u (%g%%) of readings inexact */\n",
+      min_error16, max_error16, error_count16, (100.*error_count16)/65535);
+
+   if (!test_only)
+   {
+      printf("const png_uint_16 png_sRGB_table[256] =\n{\n   ");
+      for (i=0; i<255; )
+      {
+         do
+         {
+            printf("%d,", png_sRGB_table[i++]);
+         }
+         while ((i & 0x7) != 0 && i<255);
+         if (i<255) printf("\n   ");
+      }
+      printf("%d\n};\n\n", png_sRGB_table[i]);
+
+
+      printf("const png_uint_16 png_sRGB_base[512] =\n{\n   ");
+      for (i=0; i<511; )
+      {
+         do
+         {
+            printf("%d,", png_sRGB_base[i++]);
+         }
+         while ((i & 0x7) != 0 && i<511);
+         if (i<511) printf("\n   ");
+      }
+      printf("%d\n};\n\n", png_sRGB_base[i]);
+
+      printf("const png_byte png_sRGB_delta[512] =\n{\n   ");
+      for (i=0; i<511; )
+      {
+         do
+         {
+            printf("%d,", png_sRGB_delta[i++]);
+         }
+         while ((i & 0xf) != 0 && i<511);
+         if (i<511) printf("\n   ");
+      }
+      printf("%d\n};\n\n", png_sRGB_delta[i]);
+   }
+
+   return 0;
+}
diff --git a/Engine/lib/lpng/contrib/tools/png-fix-itxt.c b/Engine/lib/lpng/contrib/tools/png-fix-itxt.c
new file mode 100644
index 000000000..c7654c113
--- /dev/null
+++ b/Engine/lib/lpng/contrib/tools/png-fix-itxt.c
@@ -0,0 +1,164 @@
+
+/* png-fix-itxt version 1.0.0
+ *
+ * Copyright 2015 Glenn Randers-Pehrson
+ * Last changed in libpng 1.6.18 [July 23, 2015]
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * Usage:
+ *
+ *     png-fix-itxt.exe < bad.png > good.png
+ *
+ * Fixes a PNG file written with libpng-1.6.0 or 1.6.1 that has one or more
+ * uncompressed iTXt chunks.  Assumes that the actual length is greater
+ * than or equal to the value in the length byte, and that the CRC is
+ * correct for the actual length.  This program hunts for the CRC and
+ * adjusts the length byte accordingly.  It is not an error to process a
+ * PNG file that has no iTXt chunks or one that has valid iTXt chunks;
+ * such files will simply be copied.
+ *
+ * Requires zlib (for crc32 and Z_NULL); build with
+ *
+ *     gcc -O -o png-fix-itxt png-fix-itxt.c -lz
+ *
+ * If you need to handle iTXt chunks larger than 500000 kbytes you must
+ * rebuild png-fix-itxt with a larger values of MAX_LENGTH (or a smaller value
+ * if you know you will never encounter such huge iTXt chunks).
+ */
+
+#include <stdio.h>
+#include <zlib.h>
+
+#define MAX_LENGTH 500000
+
+/* Read one character (inchar), also return octet (c), break if EOF */
+#define GETBREAK inchar=getchar(); \
+                 c=(inchar & 0xffU);\
+                 if (inchar != c) break
+int
+main(void)
+{
+   unsigned int i;
+   unsigned char buf[MAX_LENGTH];
+   unsigned long crc;
+   unsigned char c;
+   int inchar;
+
+/* Skip 8-byte signature */
+   for (i=8; i; i--)
+   {
+      GETBREAK;
+      putchar(c);
+   }
+
+if (inchar == c) /* !EOF */
+for (;;)
+ {
+   /* Read the length */
+   unsigned long length; /* must be 32 bits! */
+   GETBREAK; buf[0] = c; length  = c; length <<= 8;
+   GETBREAK; buf[1] = c; length += c; length <<= 8;
+   GETBREAK; buf[2] = c; length += c; length <<= 8;
+   GETBREAK; buf[3] = c; length += c;
+
+   /* Read the chunkname */
+   GETBREAK; buf[4] = c;
+   GETBREAK; buf[5] = c;
+   GETBREAK; buf[6] = c;
+   GETBREAK; buf[7] = c;
+
+
+   /* The iTXt chunk type expressed as integers is (105, 84, 88, 116) */
+   if (buf[4] == 105 && buf[5] == 84 && buf[6] == 88 && buf[7] == 116)
+   {
+      if (length >= MAX_LENGTH-12)
+         break;  /* To do: handle this more gracefully */
+
+      /* Initialize the CRC */
+      crc = crc32(0, Z_NULL, 0);
+
+      /* Copy the data bytes */
+      for (i=8; i < length + 12; i++)
+      {
+         GETBREAK; buf[i] = c;
+      }
+
+      if (inchar != c) /* EOF */
+         break;
+
+      /* Calculate the CRC */
+      crc = crc32(crc, buf+4, (uInt)length+4);
+
+      for (;;)
+      {
+        /* Check the CRC */
+        if (((crc >> 24) & 0xffU) == buf[length+8] &&
+            ((crc >> 16) & 0xffU) == buf[length+9] &&
+            ((crc >>  8) & 0xffU) == buf[length+10] &&
+            ((crc      ) & 0xffU) == buf[length+11])
+           break;
+
+        length++;
+
+        if (length >= MAX_LENGTH-12)
+           break;
+
+        GETBREAK;
+        buf[length+11] = c;
+
+        /* Update the CRC */
+        crc = crc32(crc, buf+7+length, 1);
+      }
+
+      if (inchar != c) /* EOF */
+         break;
+
+      /* Update length bytes */
+      buf[0] = (unsigned char)((length >> 24) & 0xffU);
+      buf[1] = (unsigned char)((length >> 16) & 0xffU);
+      buf[2] = (unsigned char)((length >>  8) & 0xffU);
+      buf[3] = (unsigned char)((length      ) & 0xffU);
+
+      /* Write the fixed iTXt chunk (length, name, data, crc) */
+      for (i=0; i<length+12; i++)
+         putchar(buf[i]);
+   }
+
+   else
+   {
+      if (inchar != c) /* EOF */
+         break;
+
+      /* Copy bytes that were already read (length and chunk name) */
+      for (i=0; i<8; i++)
+         putchar(buf[i]);
+
+      /* Copy data bytes and CRC */
+      for (i=8; i< length+12; i++)
+      {
+         GETBREAK;
+         putchar(c);
+      }
+
+      if (inchar != c) /* EOF */
+      {
+         break;
+      }
+
+   /* The IEND chunk type expressed as integers is (73, 69, 78, 68) */
+      if (buf[4] == 73 && buf[5] == 69 && buf[6] == 78 && buf[7] == 68)
+         break;
+   }
+
+   if (inchar != c) /* EOF */
+      break;
+
+   if (buf[4] == 73 && buf[5] == 69 && buf[6] == 78 && buf[7] == 68)
+     break;
+ }
+
+ return 0;
+}
diff --git a/Engine/lib/lpng/contrib/tools/pngcp.c b/Engine/lib/lpng/contrib/tools/pngcp.c
new file mode 100644
index 000000000..16d4e7f4d
--- /dev/null
+++ b/Engine/lib/lpng/contrib/tools/pngcp.c
@@ -0,0 +1,2453 @@
+/* pngcp.c
+ *
+ * Copyright (c) 2016 John Cunningham Bowler
+ *
+ * Last changed in libpng 1.6.24 [August 4, 2016]
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * This is an example of copying a PNG without changes using the png_read_png
+ * and png_write_png interfaces.  A considerable number of options are provided
+ * to manipulate the compression of the PNG data and other compressed chunks.
+ *
+ * For a more extensive example that uses the transforms see
+ * contrib/libtests/pngimage.c in the libpng distribution.
+ */
+#include "pnglibconf.h" /* To find how libpng was configured. */
+
+#ifdef PNG_PNGCP_TIMING_SUPPORTED
+   /* WARNING:
+    *
+    * This test is here to allow POSIX.1b extensions to be used if enabled in
+    * the compile; specifically the code requires_POSIX_C_SOURCE support of
+    * 199309L or later to enable clock_gettime use.
+    *
+    * IF this causes problems THEN compile with a strict ANSI C compiler and let
+    * this code turn on the POSIX features that it minimally requires.
+    *
+    * IF this does not work there is probably a bug in your ANSI C compiler or
+    * your POSIX implementation.
+    */
+#  define _POSIX_C_SOURCE 199309L
+#else /* No timing support required */
+#  define _POSIX_SOURCE 1
+#endif
+
+#if defined(HAVE_CONFIG_H) && !defined(PNG_NO_CONFIG_H)
+#  include <config.h>
+#endif
+
+#include <stdio.h>
+
+/* Define the following to use this test against your installed libpng, rather
+ * than the one being built here:
+ */
+#ifdef PNG_FREESTANDING_TESTS
+#  include <png.h>
+#else
+#  include "../../png.h"
+#endif
+
+#if PNG_LIBPNG_VER < 10700
+   /* READ_PNG and WRITE_PNG were not defined, so: */
+#  ifdef PNG_INFO_IMAGE_SUPPORTED
+#     ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+#        define PNG_READ_PNG_SUPPORTED
+#     endif /* SEQUENTIAL_READ */
+#     ifdef PNG_WRITE_SUPPORTED
+#        define PNG_WRITE_PNG_SUPPORTED
+#     endif /* WRITE */
+#  endif /* INFO_IMAGE */
+#endif /* pre 1.7.0 */
+
+#if (defined(PNG_READ_PNG_SUPPORTED)) && (defined(PNG_WRITE_PNG_SUPPORTED))
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <limits.h>
+#include <assert.h>
+
+#include <unistd.h>
+#include <sys/stat.h>
+
+#include <zlib.h>
+
+#ifndef PNG_SETJMP_SUPPORTED
+#  include <setjmp.h> /* because png.h did *not* include this */
+#endif
+
+#ifdef __cplusplus
+#  define voidcast(type, value) static_cast<type>(value)
+#else
+#  define voidcast(type, value) (value)
+#endif /* __cplusplus */
+
+#ifdef __GNUC__
+   /* Many versions of GCC erroneously report that local variables unmodified
+    * within the scope of a setjmp may be clobbered.  This hacks round the
+    * problem (sometimes) without harming other compilers.
+    */
+#  define gv volatile
+#else
+#  define gv
+#endif
+
+/* 'CLOCK_PROCESS_CPUTIME_ID' is one of the clock timers for clock_gettime.  It
+ * need not be supported even when clock_gettime is available.  It returns the
+ * 'CPU' time the process has consumed.  'CPU' time is assumed to include time
+ * when the CPU is actually blocked by a pending cache fill but not time
+ * waiting for page faults.  The attempt is to get a measure of the actual time
+ * the implementation takes to read a PNG ignoring the potentially very large IO
+ * overhead.
+ */
+#ifdef PNG_PNGCP_TIMING_SUPPORTED
+#  include <time.h>   /* clock_gettime and associated definitions */
+#  ifndef CLOCK_PROCESS_CPUTIME_ID
+      /* Prevent inclusion of the spurious code: */
+#     undef PNG_PNGCP_TIMING_SUPPORTED
+#  endif
+#endif /* PNGCP_TIMING */
+
+/* So if the timing feature has been activated: */
+
+/* This structure is used to control the test of a single file. */
+typedef enum
+{
+   VERBOSE,        /* switches on all messages */
+   INFORMATION,
+   WARNINGS,       /* switches on warnings */
+   LIBPNG_WARNING,
+   APP_WARNING,
+   ERRORS,         /* just errors */
+   APP_FAIL,       /* continuable error - no need to longjmp */
+   LIBPNG_ERROR,   /* this and higher cause a longjmp */
+   LIBPNG_BUG,     /* erroneous behavior in libpng */
+   APP_ERROR,      /* such as out-of-memory in a callback */
+   QUIET,          /* no normal messages */
+   USER_ERROR,     /* such as file-not-found */
+   INTERNAL_ERROR
+} error_level;
+#define LEVEL_MASK      0xf   /* where the level is in 'options' */
+
+#define STRICT          0x010 /* Fail on warnings as well as errors */
+#define LOG             0x020 /* Log pass/fail to stdout */
+#define CONTINUE        0x040 /* Continue on APP_FAIL errors */
+#define SIZES           0x080 /* Report input and output sizes */
+#define SEARCH          0x100 /* Search IDAT compression options */
+#define NOWRITE         0x200 /* Do not write an output file */
+#ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
+#  define IGNORE_INDEX  0x400 /* Ignore out of range palette indices (BAD!) */
+#  ifdef PNG_GET_PALETTE_MAX_SUPPORTED
+#     define FIX_INDEX  0x800 /* 'Fix' out of range palette indices (OK) */
+#  endif /* GET_PALETTE_MAX */
+#endif /* CHECK_FOR_INVALID_INDEX */
+#define OPTION     0x80000000 /* Used for handling options */
+#define LIST       0x80000001 /* Used for handling options */
+
+/* Result masks apply to the result bits in the 'results' field below; these
+ * bits are simple 1U<<error_level.  A pass requires either nothing worse than
+ * warnings (--relaxes) or nothing worse than information (--strict)
+ */
+#define RESULT_STRICT(r)   (((r) & ~((1U<<WARNINGS)-1)) == 0)
+#define RESULT_RELAXED(r)  (((r) & ~((1U<<ERRORS)-1)) == 0)
+
+/* OPTION DEFINITIONS */
+static const char range_lo[] = "low";
+static const char range_hi[] = "high";
+static const char all[] = "all";
+#define RANGE(lo,hi) { range_lo, lo }, { range_hi, hi }
+typedef struct value_list
+{
+   const char *name;  /* the command line name of the value */
+   int         value; /* the actual value to use */
+}  value_list;
+
+static const value_list
+#ifdef PNG_SW_COMPRESS_png_level
+vl_compression[] =
+{
+   /* Overall compression control.  The order controls the search order for
+    * 'all'.  Since the search is for the smallest the order used is low memory
+    * then high speed.
+    */
+   { "low-memory",      PNG_COMPRESSION_LOW_MEMORY },
+   { "high-speed",      PNG_COMPRESSION_HIGH_SPEED },
+   { "high-read-speed", PNG_COMPRESSION_HIGH_READ_SPEED },
+   { "low",             PNG_COMPRESSION_LOW },
+   { "medium",          PNG_COMPRESSION_MEDIUM },
+   { "old",             PNG_COMPRESSION_COMPAT },
+   { "high",            PNG_COMPRESSION_HIGH },
+   { all, 0 }
+},
+#endif /* SW_COMPRESS_png_level */
+
+#if defined(PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED) ||\
+    defined(PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED)
+vl_strategy[] =
+{
+   /* This controls the order of search. */
+   { "huffman", Z_HUFFMAN_ONLY },
+   { "RLE", Z_RLE },
+   { "fixed", Z_FIXED }, /* the remainder do window searches */
+   { "filtered", Z_FILTERED },
+   { "default", Z_DEFAULT_STRATEGY },
+   { all, 0 }
+},
+#ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
+vl_windowBits_text[] =
+{
+   { "default", MAX_WBITS/*from zlib*/ },
+   { "minimum", 8 },
+   RANGE(8, MAX_WBITS/*from zlib*/),
+   { all, 0 }
+},
+#endif /* text compression */
+vl_level[] =
+{
+   { "default", Z_DEFAULT_COMPRESSION /* this is -1 */ },
+   { "none", Z_NO_COMPRESSION },
+   { "speed", Z_BEST_SPEED },
+   { "best", Z_BEST_COMPRESSION },
+   { "0", Z_NO_COMPRESSION },
+   RANGE(1, 9), /* this deliberately excludes '0' */
+   { all, 0 }
+},
+vl_memLevel[] =
+{
+   { "max", MAX_MEM_LEVEL }, /* zlib maximum */
+   { "1", 1 }, /* zlib minimum */
+   { "default", 8 }, /* zlib default */
+   { "2", 2 },
+   { "3", 3 },
+   { "4", 4 },
+   { "5", 5 }, /* for explicit testing */
+   RANGE(6, MAX_MEM_LEVEL/*zlib*/), /* exclude 5 and below: zlib bugs */
+   { all, 0 }
+},
+#endif /* WRITE_CUSTOMIZE_*COMPRESSION */
+#ifdef PNG_WRITE_FILTER_SUPPORTED
+vl_filter[] =
+{
+   { all,      PNG_ALL_FILTERS   },
+   { "off",    PNG_NO_FILTERS    },
+   { "none",   PNG_FILTER_NONE   },
+   { "sub",    PNG_FILTER_SUB    },
+   { "up",     PNG_FILTER_UP     },
+   { "avg",    PNG_FILTER_AVG    },
+   { "paeth",  PNG_FILTER_PAETH  }
+},
+#endif /* WRITE_FILTER */
+#ifdef PNG_PNGCP_TIMING_SUPPORTED
+#  define PNGCP_TIME_READ  1
+#  define PNGCP_TIME_WRITE 2
+vl_time[] =
+{
+   { "both",  PNGCP_TIME_READ+PNGCP_TIME_WRITE },
+   { "off",   0 },
+   { "read",  PNGCP_TIME_READ },
+   { "write", PNGCP_TIME_WRITE }
+},
+#endif /* PNGCP_TIMING */
+vl_IDAT_size[] = /* for png_set_IDAT_size */
+{
+   { "default", 0x7FFFFFFF },
+   { "minimal", 1 },
+   RANGE(1, 0x7FFFFFFF)
+},
+#ifndef PNG_SW_IDAT_size
+   /* Pre 1.7 API: */
+#  define png_set_IDAT_size(p,v) png_set_compression_buffer_size(p, v)
+#endif /* !SW_IDAT_size */
+#define SL 8 /* stack limit in display, below */
+vl_log_depth[] = { { "on", 1 }, { "off", 0 }, RANGE(0, SL) },
+vl_on_off[] = { { "on", 1 }, { "off", 0 } };
+
+#ifdef PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED
+static value_list
+vl_windowBits_IDAT[] =
+{
+   { "default", MAX_WBITS },
+   { "small", 9 },
+   RANGE(8, MAX_WBITS), /* modified by set_windowBits_hi */
+   { all, 0 }
+};
+#endif /* IDAT compression */
+
+typedef struct option
+{
+   const char       *name;         /* name of the option */
+   png_uint_32       opt;          /* an option, or OPTION or LIST */
+   png_byte          search;       /* Search on --search */
+   png_byte          value_count;  /* length of the list of values: */
+   const value_list *values;       /* values for OPTION or LIST */
+}  option;
+
+static const option options[] =
+{
+   /* struct display options, these are set when the command line is read */
+#  define S(n,v) { #n, v, 0, 2, vl_on_off },
+   S(verbose,  VERBOSE)
+   S(warnings, WARNINGS)
+   S(errors,   ERRORS)
+   S(quiet,    QUIET)
+   S(strict,   STRICT)
+   S(log,      LOG)
+   S(continue, CONTINUE)
+   S(sizes,    SIZES)
+   S(search,   SEARCH)
+   S(nowrite,  NOWRITE)
+#  ifdef IGNORE_INDEX
+      S(ignore-palette-index, IGNORE_INDEX)
+#  endif /* IGNORE_INDEX */
+#  ifdef FIX_INDEX
+      S(fix-palette-index, FIX_INDEX)
+#  endif /* FIX_INDEX */
+#  undef S
+
+   /* OPTION settings, these and LIST settings are read on demand */
+#  define VLNAME(name) vl_ ## name
+#  define VLSIZE(name) voidcast(png_byte,\
+                           (sizeof VLNAME(name))/(sizeof VLNAME(name)[0]))
+#  define VL(oname, name, type, search)\
+   { oname, type, search, VLSIZE(name), VLNAME(name) },
+#  define VLO(oname, name, search) VL(oname, name, OPTION, search)
+
+#  ifdef PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED
+#     define VLCIDAT(name) VLO(#name, name, 1/*search*/)
+#     ifdef PNG_SW_COMPRESS_level
+#        define VLCiCCP(name) VLO("ICC-profile-" #name, name, 0/*search*/)
+#     else
+#        define VLCiCCP(name)
+#     endif
+#  else
+#     define VLCIDAT(name)
+#     define VLCiCCP(name)
+#  endif /* WRITE_CUSTOMIZE_COMPRESSION */
+
+#  ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
+#     define VLCzTXt(name) VLO("text-" #name, name, 0/*search*/)
+#  else
+#     define VLCzTXt(name)
+#  endif /* WRITE_CUSTOMIZE_ZTXT_COMPRESSION */
+
+#  define VLC(name) VLCIDAT(name) VLCiCCP(name) VLCzTXt(name)
+
+#  ifdef PNG_SW_COMPRESS_png_level
+      /* The libpng compression level isn't searched because it justs sets the
+       * other things that are searched!
+       */
+      VLO("compression", compression, 0)
+      VLO("text-compression", compression, 0)
+      VLO("ICC-profile-compression", compression, 0)
+#  endif /* SW_COMPRESS_png_level */
+   VLC(strategy)
+   VLO("windowBits", windowBits_IDAT, 1)
+#  ifdef PNG_SW_COMPRESS_windowBits
+      VLO("ICC-profile-windowBits", windowBits_text/*sic*/, 0)
+#  endif
+   VLO("text-windowBits", windowBits_text, 0)
+   VLC(level)
+   VLC(memLevel)
+   VLO("IDAT-size", IDAT_size, 0)
+   VLO("log-depth", log_depth, 0)
+
+#  undef VLO
+
+   /* LIST settings */
+#  define VLL(name, search) VL(#name, name, LIST, search)
+#ifdef PNG_WRITE_FILTER_SUPPORTED
+   VLL(filter, 0)
+#endif /* WRITE_FILTER */
+#ifdef PNG_PNGCP_TIMING_SUPPORTED
+   VLL(time, 0)
+#endif /* PNGCP_TIMING */
+#  undef VLL
+#  undef VL
+};
+
+#ifdef __cplusplus
+   static const size_t option_count((sizeof options)/(sizeof options[0]));
+#else /* !__cplusplus */
+#  define option_count ((sizeof options)/(sizeof options[0]))
+#endif /* !__cplusplus */
+
+static const char *
+cts(int ct)
+{
+   switch (ct)
+   {
+      case PNG_COLOR_TYPE_PALETTE:     return "P";
+      case PNG_COLOR_TYPE_GRAY:        return "G";
+      case PNG_COLOR_TYPE_GRAY_ALPHA:  return "GA";
+      case PNG_COLOR_TYPE_RGB:         return "RGB";
+      case PNG_COLOR_TYPE_RGB_ALPHA:   return "RGBA";
+      default:                         return "INVALID";
+   }
+}
+
+struct display
+{
+   jmp_buf          error_return;      /* Where to go to on error */
+   unsigned int     errset;            /* error_return is set */
+
+   const char      *operation;         /* What is happening */
+   const char      *filename;          /* The name of the original file */
+   const char      *output_file;       /* The name of the output file */
+
+   /* Used on both read and write: */
+   FILE            *fp;
+
+   /* Used on a read, both the original read and when validating a written
+    * image.
+    */
+   png_alloc_size_t read_size;
+   png_structp      read_pp;
+   png_infop        ip;
+#  if PNG_LIBPNG_VER < 10700 && defined PNG_TEXT_SUPPORTED
+      png_textp     text_ptr; /* stash of text chunks */
+      int           num_text;
+      int           text_stashed;
+#  endif /* pre 1.7 */
+
+#  ifdef PNG_PNGCP_TIMING_SUPPORTED
+      struct timespec   read_time;
+      struct timespec   read_time_total;
+      struct timespec   write_time;
+      struct timespec   write_time_total;
+#  endif /* PNGCP_TIMING */
+
+   /* Used to write a new image (the original info_ptr is used) */
+#  define MAX_SIZE ((png_alloc_size_t)(-1))
+   png_alloc_size_t write_size;
+   png_alloc_size_t best_size;
+   png_structp      write_pp;
+
+   /* Base file information */
+   png_alloc_size_t size;
+   png_uint_32      w;
+   png_uint_32      h;
+   int              bpp;
+   png_byte         ct;
+   int              no_warnings;       /* Do not output libpng warnings */
+   int              min_windowBits;    /* The windowBits range is 8..8 */
+
+   /* Options handling */
+   png_uint_32      results;             /* A mask of errors seen */
+   png_uint_32      options;             /* See display_log below */
+   png_byte         entry[option_count]; /* The selected entry+1 of an option
+                                          * that appears on the command line, or
+                                          * 0 if it was not given. */
+   int              value[option_count]; /* Corresponding value */
+
+   /* Compression exhaustive testing */
+   /* Temporary variables used only while testing a single collection of
+    * settings:
+    */
+   unsigned int     csp;               /* next stack entry to use */
+   unsigned int     nsp;               /* highest active entry+1 found so far */
+
+   /* Values used while iterating through all the combinations of settings for a
+    * single file:
+    */
+   unsigned int     tsp;               /* nsp from the last run; this is the
+                                        * index+1 of the highest active entry on
+                                        * this run; this entry will be advanced.
+                                        */
+   int              opt_string_start;  /* Position in buffer for the first
+                                        * searched option; non-zero if earlier
+                                        * options were set on the command line.
+                                        */
+   struct stack
+   {
+      png_alloc_size_t best_size;      /* Best so far for this option */
+      png_alloc_size_t lo_size;
+      png_alloc_size_t hi_size;
+      int              lo, hi;         /* For binary chop of a range */
+      int              best_val;       /* Best value found so far */
+      int              opt_string_end; /* End of the option string in 'curr' */
+      png_byte         opt;            /* The option being tested */
+      png_byte         entry;          /* The next value entry to be tested */
+      png_byte         end;            /* This is the last entry */
+   }                stack[SL];         /* Stack of entries being tested */
+   char             curr[32*SL];       /* current options being tested */
+   char             best[32*SL];       /* best options */
+
+   char             namebuf[FILENAME_MAX]; /* output file name */
+};
+
+static void
+display_init(struct display *dp)
+   /* Call this only once right at the start to initialize the control
+    * structure, the (struct buffer) lists are maintained across calls - the
+    * memory is not freed.
+    */
+{
+   memset(dp, 0, sizeof *dp);
+   dp->operation = "internal error";
+   dp->filename = "command line";
+   dp->output_file = "no output file";
+   dp->options = WARNINGS; /* default to !verbose, !quiet */
+   dp->fp = NULL;
+   dp->read_pp = NULL;
+   dp->ip = NULL;
+   dp->write_pp = NULL;
+   dp->min_windowBits = -1; /* this is an OPTIND, so -1 won't match anything */
+#  if PNG_LIBPNG_VER < 10700 && defined PNG_TEXT_SUPPORTED
+      dp->text_ptr = NULL;
+      dp->num_text = 0;
+      dp->text_stashed = 0;
+#  endif /* pre 1.7 */
+}
+
+static void
+display_clean_read(struct display *dp)
+{
+   if (dp->read_pp != NULL)
+      png_destroy_read_struct(&dp->read_pp, NULL, NULL);
+
+   if (dp->fp != NULL)
+   {
+      FILE *fp = dp->fp;
+      dp->fp = NULL;
+      (void)fclose(fp);
+   }
+}
+
+static void
+display_clean_write(struct display *dp)
+{
+   if (dp->fp != NULL)
+   {
+      FILE *fp = dp->fp;
+      dp->fp = NULL;
+      (void)fclose(fp);
+   }
+
+   if (dp->write_pp != NULL)
+      png_destroy_write_struct(&dp->write_pp, dp->tsp > 0 ? NULL : &dp->ip);
+}
+
+static void
+display_clean(struct display *dp)
+{
+   display_clean_read(dp);
+   display_clean_write(dp);
+   dp->output_file = NULL;
+
+#  if PNG_LIBPNG_VER < 10700 && defined PNG_TEXT_SUPPORTED
+      /* This is actually created and used by the write code, but only
+       * once; it has to be retained for subsequent writes of the same file.
+       */
+      if (dp->text_stashed)
+      {
+         dp->text_stashed = 0;
+         dp->num_text = 0;
+         free(dp->text_ptr);
+         dp->text_ptr = NULL;
+      }
+#  endif /* pre 1.7 */
+
+   /* leave the filename for error detection */
+   dp->results = 0; /* reset for next time */
+}
+
+static void
+display_destroy(struct display *dp)
+{
+   /* Release any memory held in the display. */
+   display_clean(dp);
+}
+
+static struct display *
+get_dp(png_structp pp)
+   /* The display pointer is always stored in the png_struct error pointer */
+{
+   struct display *dp = (struct display*)png_get_error_ptr(pp);
+
+   if (dp == NULL)
+   {
+      fprintf(stderr, "pngcp: internal error (no display)\n");
+      exit(99); /* prevents a crash */
+   }
+
+   return dp;
+}
+
+/* error handling */
+#ifdef __GNUC__
+#  define VGATTR __attribute__((__format__ (__printf__,3,4)))
+   /* Required to quiet GNUC warnings when the compiler sees a stdarg function
+    * that calls one of the stdio v APIs.
+    */
+#else
+#  define VGATTR
+#endif
+static void VGATTR
+display_log(struct display *dp, error_level level, const char *fmt, ...)
+   /* 'level' is as above, fmt is a stdio style format string.  This routine
+    * does not return if level is above LIBPNG_WARNING
+    */
+{
+   dp->results |= 1U << level;
+
+   if (level > (error_level)(dp->options & LEVEL_MASK))
+   {
+      const char *lp;
+      va_list ap;
+
+      switch (level)
+      {
+         case INFORMATION:    lp = "information"; break;
+         case LIBPNG_WARNING: lp = "warning(libpng)"; break;
+         case APP_WARNING:    lp = "warning(pngcp)"; break;
+         case APP_FAIL:       lp = "error(continuable)"; break;
+         case LIBPNG_ERROR:   lp = "error(libpng)"; break;
+         case LIBPNG_BUG:     lp = "bug(libpng)"; break;
+         case APP_ERROR:      lp = "error(pngcp)"; break;
+         case USER_ERROR:     lp = "error(user)"; break;
+
+         case INTERNAL_ERROR: /* anything unexpected is an internal error: */
+         case VERBOSE: case WARNINGS: case ERRORS: case QUIET:
+         default:             lp = "bug(pngcp)"; break;
+      }
+
+      fprintf(stderr, "%s: %s: %s",
+         dp->filename != NULL ? dp->filename : "<stdin>", lp, dp->operation);
+
+      fprintf(stderr, ": ");
+
+      va_start(ap, fmt);
+      vfprintf(stderr, fmt, ap);
+      va_end(ap);
+
+      fputc('\n', stderr);
+   }
+   /* else do not output any message */
+
+   /* Errors cause this routine to exit to the fail code */
+   if (level > APP_FAIL || (level > ERRORS && !(dp->options & CONTINUE)))
+   {
+      if (dp->errset)
+         longjmp(dp->error_return, level);
+
+      else
+         exit(99);
+   }
+}
+
+#if PNG_LIBPNG_VER < 10700 && defined PNG_TEXT_SUPPORTED
+static void
+text_stash(struct display *dp)
+{
+   /* libpng 1.6 and earlier fixed a bug whereby text chunks were written
+    * multiple times by png_write_png; the issue was that png_write_png passed
+    * the same png_info to both png_write_info and png_write_end.  Rather than
+    * fixing it by recording the information in the png_struct, or by recording
+    * where to write the chunks, the fix made was to change the 'compression'
+    * field of the chunk to invalid values, rendering the png_info somewhat
+    * useless.
+    *
+    * The only fix for this given that we use the png_info more than once is to
+    * make a copy of the text chunks and png_set_text it each time.  This adds a
+    * text chunks, so they get replicated, but only the new set gets written
+    * each time.  This uses memory like crazy but there is no way to delete the
+    * useless chunks from the png_info.
+    *
+    * To make this slightly more efficient only the top level structure is
+    * copied; since the old strings are actually preserved (in 1.6 and earlier)
+    * this happens to work.
+    */
+   png_textp chunks = NULL;
+
+   dp->num_text = png_get_text(dp->write_pp, dp->ip, &chunks, NULL);
+
+   if (dp->num_text > 0)
+   {
+      dp->text_ptr = voidcast(png_textp, malloc(dp->num_text * sizeof *chunks));
+
+      if (dp->text_ptr == NULL)
+         display_log(dp, APP_ERROR, "text chunks: stash malloc failed");
+
+      else
+         memcpy(dp->text_ptr, chunks, dp->num_text * sizeof *chunks);
+   }
+
+   dp->text_stashed = 1; /* regardless of whether there are chunks or not */
+}
+
+#define text_stash(dp) if (!dp->text_stashed) text_stash(dp)
+
+static void
+text_restore(struct display *dp)
+{
+   /* libpng makes a copy, so this is fine: */
+   if (dp->text_ptr != NULL)
+      png_set_text(dp->write_pp, dp->ip, dp->text_ptr, dp->num_text);
+}
+
+#define text_restore(dp) if (dp->text_stashed) text_restore(dp)
+
+#else
+#define text_stash(dp) ((void)0)
+#define text_restore(dp) ((void)0)
+#endif /* pre 1.7 */
+
+/* OPTIONS:
+ *
+ * The command handles options of the forms:
+ *
+ *    --option
+ *       Turn an option on (Option)
+ *    --no-option
+ *       Turn an option off (Option)
+ *    --option=value
+ *       Set an option to a value (Value)
+ *    --option=val1,val2,val3
+ *       Set an option to a bitmask constructed from the values (List)
+ */
+static png_byte
+option_index(struct display *dp, const char *opt, size_t len)
+   /* Return the index (in options[]) of the given option, outputs an error if
+    * it does not exist.  Takes the name of the option and a length (number of
+    * characters in the name).
+    */
+{
+   png_byte j;
+
+   for (j=0; j<option_count; ++j)
+      if (strncmp(options[j].name, opt, len) == 0 && options[j].name[len] == 0)
+         return j;
+
+   /* If the setjmp buffer is set the code is asking for an option index; this
+    * is bad.  Otherwise this is the command line option parsing.
+    */
+   display_log(dp, dp->errset ? INTERNAL_ERROR : USER_ERROR,
+         "%.*s: unknown option", (int)/*SAFE*/len, opt);
+   abort(); /* NOT REACHED */
+}
+
+/* This works for an option name (no quotes): */
+#define OPTIND(dp, name) option_index(dp, #name, (sizeof #name)-1)
+
+static int
+get_option(struct display *dp, const char *opt, int *value)
+{
+   png_byte i = option_index(dp, opt, strlen(opt));
+
+   if (dp->entry[i]) /* option was set on command line */
+   {
+      *value = dp->value[i];
+      return 1;
+   }
+
+   else
+      return 0;
+}
+
+static int
+set_opt_string_(struct display *dp, unsigned int sp, png_byte opt,
+      const char *entry_name)
+   /* Add the appropriate option string to dp->curr. */
+{
+   int offset, add;
+
+   if (sp > 0)
+      offset = dp->stack[sp-1].opt_string_end;
+
+   else
+      offset = dp->opt_string_start;
+
+   if (entry_name == range_lo)
+      add = sprintf(dp->curr+offset, " --%s=%d", options[opt].name,
+            dp->value[opt]);
+
+   else
+      add = sprintf(dp->curr+offset, " --%s=%s", options[opt].name, entry_name);
+
+   if (add < 0)
+      display_log(dp, INTERNAL_ERROR, "sprintf failed");
+
+   assert(offset+add < (int)/*SAFE*/sizeof dp->curr);
+   return offset+add;
+}
+
+static void
+set_opt_string(struct display *dp, unsigned int sp)
+   /* Add the appropriate option string to dp->curr. */
+{
+   dp->stack[sp].opt_string_end = set_opt_string_(dp, sp, dp->stack[sp].opt, 
+      options[dp->stack[sp].opt].values[dp->stack[sp].entry].name);
+}
+
+static void
+record_opt(struct display *dp, png_byte opt, const char *entry_name)
+   /* Record this option in dp->curr; called for an option not being searched,
+    * the caller passes in the name of the value, or range_lo to use the
+    * numerical value.
+    */
+{
+   unsigned int sp = dp->csp; /* stack entry of next searched option */
+
+   if (sp >= dp->tsp)
+   {
+      /* At top of stack; add the opt string for this entry to the previous
+       * searched entry or the start of the dp->curr buffer if there is nothing
+       * on the stack yet (sp == 0).
+       */
+      int offset = set_opt_string_(dp, sp, opt, entry_name);
+
+      if (sp > 0)
+         dp->stack[sp-1].opt_string_end = offset;
+
+      else
+         dp->opt_string_start = offset;
+   }
+
+   /* else do nothing: option already recorded */
+}
+
+static int
+opt_list_end(struct display *dp, png_byte opt, png_byte entry)
+{
+   if (options[opt].values[entry].name == range_lo)
+      return entry+1U >= options[opt].value_count /* missing range_hi */ ||
+         options[opt].values[entry+1U].name != range_hi /* likewise */ ||
+         options[opt].values[entry+1U].value <= dp->value[opt] /* range end */;
+
+   else
+      return entry+1U >= options[opt].value_count /* missing 'all' */ ||
+         options[opt].values[entry+1U].name == all /* last entry */;
+}
+
+static void
+push_opt(struct display *dp, unsigned int sp, png_byte opt, int search)
+   /* Push a new option onto the stack, initializing the new stack entry
+    * appropriately; this does all the work of next_opt (setting end/nsp) for
+    * the first entry in the list.
+    */
+{
+   png_byte entry;
+   const char *entry_name;
+
+   assert(sp == dp->tsp && sp < SL);
+
+   /* The starting entry is entry 0 unless there is a range in which case it is
+    * the entry corresponding to range_lo:
+    */
+   entry = options[opt].value_count;
+   assert(entry > 0U);
+
+   do
+   {
+      entry_name = options[opt].values[--entry].name;
+      if (entry_name == range_lo)
+         break;
+   }
+   while (entry > 0U);
+
+   dp->tsp = sp+1U;
+   dp->stack[sp].best_size =
+      dp->stack[sp].lo_size =
+      dp->stack[sp].hi_size = MAX_SIZE;
+
+   if (search && entry_name == range_lo) /* search this range */
+   {
+      dp->stack[sp].lo = options[opt].values[entry].value;
+      /* check for a mal-formed RANGE above: */
+      assert(entry+1 < options[opt].value_count &&
+             options[opt].values[entry+1].name == range_hi);
+      dp->stack[sp].hi = options[opt].values[entry+1].value;
+   }
+
+   else
+   {
+      /* next_opt will just iterate over the range. */
+      dp->stack[sp].lo = INT_MAX;
+      dp->stack[sp].hi = INT_MIN; /* Prevent range chop */
+   }
+
+   dp->stack[sp].opt = opt;
+   dp->stack[sp].entry = entry;
+   dp->stack[sp].best_val = dp->value[opt] = options[opt].values[entry].value;
+
+   set_opt_string(dp, sp);
+
+   /* This works for the search case too; if the range has only one entry 'end'
+    * will be marked here.
+    */
+   if (opt_list_end(dp, opt, entry))
+   {
+      dp->stack[sp].end = 1;
+      /* Skip the warning if pngcp did this itself.  See the code in
+       * set_windowBits_hi.
+       */
+      if (opt != dp->min_windowBits)
+         display_log(dp, APP_WARNING, "%s: only testing one value",
+               options[opt].name);
+   }
+
+   else
+   {
+      dp->stack[sp].end = 0;
+      dp->nsp = dp->tsp;
+   }
+
+   /* Do a lazy cache of the text chunks for libpng 1.6 and earlier; this is
+    * because they can only be written once(!) so if we are going to re-use the
+    * png_info we need a copy.
+    */
+   text_stash(dp);
+}
+
+static void
+next_opt(struct display *dp, unsigned int sp)
+   /* Return the next value for this option.  When called 'sp' is expected to be
+    * the topmost stack entry - only the topmost entry changes each time round -
+    * and there must be a valid entry to return.  next_opt will set dp->nsp to
+    * sp+1 if more entries are available, otherwise it will not change it and
+    * set dp->stack[s].end to true.
+    */
+{
+   int search = 0;
+   png_byte entry, opt;
+   const char *entry_name;
+
+   /* dp->stack[sp] must be the top stack entry and it must be active: */
+   assert(sp+1U == dp->tsp && !dp->stack[sp].end);
+
+   opt = dp->stack[sp].opt;
+   entry = dp->stack[sp].entry;
+   assert(entry+1U < options[opt].value_count);
+   entry_name = options[opt].values[entry].name;
+   assert(entry_name != NULL);
+
+   /* For ranges increment the value but don't change the entry, for all other
+    * cases move to the next entry and load its value:
+    */
+   if (entry_name == range_lo) /* a range */
+   {
+      /* A range can be iterated over or searched.  The default iteration option
+       * is indicated by hi < lo on the stack, otherwise the range being search
+       * is [lo..hi] (inclusive).
+       */
+      if (dp->stack[sp].lo > dp->stack[sp].hi)
+         dp->value[opt]++;
+
+      else
+      {
+         /* This is the best size found for this option value: */
+         png_alloc_size_t best_size = dp->stack[sp].best_size;
+         int lo = dp->stack[sp].lo;
+         int hi = dp->stack[sp].hi;
+         int val = dp->value[opt];
+
+         search = 1; /* end is determined here */
+         assert(best_size < MAX_SIZE);
+
+         if (val == lo)
+         {
+            /* Finding the best for the low end of the range: */
+            dp->stack[sp].lo_size = best_size;
+            assert(hi > val);
+
+            if (hi == val+1) /* only 2 entries */
+               dp->stack[sp].end = 1;
+
+            val = hi;
+         }
+
+         else if (val == hi)
+         {
+            dp->stack[sp].hi_size = best_size;
+            assert(val > lo+1); /* else 'end' set above */
+
+            if (val == lo+2) /* only three entries to test */
+               dp->stack[sp].end = 1;
+
+            val = (lo + val)/2;
+         }
+
+         else
+         {
+            png_alloc_size_t lo_size = dp->stack[sp].lo_size;
+            png_alloc_size_t hi_size = dp->stack[sp].hi_size;
+
+            /* lo and hi should have been tested. */
+            assert(lo_size < MAX_SIZE && hi_size < MAX_SIZE);
+
+            /* These cases arise with the 'probe' handling below when there is a
+             * dip or peak in the size curve.
+             */
+            if (val < lo) /* probing a new lo */
+            {
+               /* Swap lo and val: */
+               dp->stack[sp].lo = val;
+               dp->stack[sp].lo_size = best_size;
+               val = lo;
+               best_size = lo_size;
+               lo = dp->stack[sp].lo;
+               lo_size = dp->stack[sp].lo_size;
+            }
+
+            else if (val > hi) /* probing a new hi */
+            {
+               /* Swap hi and val: */
+               dp->stack[sp].hi = val;
+               dp->stack[sp].hi_size = best_size;
+               val = hi;
+               best_size = hi_size;
+               hi = dp->stack[sp].hi;
+               hi_size = dp->stack[sp].hi_size;
+            }
+
+            /* The following should be true or something got messed up above. */
+            assert(lo < val && val < hi);
+
+            /* If there are only four entries (lo, val, hi plus one more) just
+             * test the remaining entry.
+             */
+            if (hi == lo+3)
+            {
+               /* Because of the 'probe' code val can either be lo+1 or hi-1; we
+                * need to test the other.
+                */
+               val = lo + ((val == lo+1) ? 2 : 1);
+               assert(lo < val && val < hi);
+               dp->stack[sp].end = 1;
+            }
+
+            else
+            {
+               /* There are at least 2 entries still untested between lo and hi,
+                * i.e. hi >= lo+4.  'val' is the midpoint +/- 0.5
+                *
+                * Separate out the four easy cases when lo..val..hi are
+                * monotonically decreased or (more weird) increasing:
+                */
+               assert(hi > lo+3);
+
+               if (lo_size <= best_size && best_size <= hi_size)
+               {
+                  /* Select the low range; testing this first favours the low
+                   * range over the high range when everything comes out equal.
+                   * Because of the probing 'val' may be lo+1.  In that case end
+                   * the search and set 'val' to lo+2.
+                   */
+                  if (val == lo+1)
+                  {
+                     ++val;
+                     dp->stack[sp].end = 1;
+                  }
+
+                  else
+                  {
+                     dp->stack[sp].hi = hi = val;
+                     dp->stack[sp].hi_size = best_size;
+                     val = (lo + val) / 2;
+                  }
+               }
+
+               else if (lo_size >= best_size && best_size >= hi_size)
+               {
+                  /* Monotonically decreasing size; this is the expected case.
+                   * Select the high end of the range.  As above, val may be
+                   * hi-1.
+                   */
+                  if (val == hi-1)
+                  {
+                     --val;
+                     dp->stack[sp].end = 1;
+                  }
+
+                  else
+                  {
+                     dp->stack[sp].lo = lo = val;
+                     dp->stack[sp].lo_size = best_size;
+                     val = (val + hi) / 2;
+                  }
+               }
+
+               /* If both those tests failed 'best_size' is either greater than
+                * or less than both lo_size and hi_size.  There is a peak or dip
+                * in the curve of sizes from lo to hi and val is on the peak or
+                * dip.
+                *
+                * Because the ranges being searched as so small (level is 1..9,
+                * windowBits 8..15, memLevel 1..9) there will only be at most
+                * three untested values between lo..val and val..hi, so solve
+                * the problem by probing down from hi or up from lo, whichever
+                * is the higher.
+                *
+                * This is the place where 'val' is set to outside the range
+                * lo..hi, described as 'probing', though maybe 'narrowing' would
+                * be more accurate.
+                */
+               else if (lo_size <= hi_size) /* down from hi */
+               {
+                  dp->stack[sp].hi = val;
+                  dp->stack[sp].hi_size = best_size;
+                  val = --hi;
+               }
+
+               else /* up from low */
+               {
+                  dp->stack[sp].lo = val;
+                  dp->stack[sp].lo_size = best_size;
+                  val = ++lo;
+               }
+
+               /* lo and hi are still the true range limits, check for the end
+                * condition.
+                */
+               assert(hi > lo+1);
+               if (hi <= lo+2)
+                  dp->stack[sp].end = 1;
+            }
+         }
+
+         assert(val != dp->stack[sp].best_val); /* should be a new value */
+         dp->value[opt] = val;
+         dp->stack[sp].best_size = MAX_SIZE;
+      }
+   }
+
+   else
+   {
+      /* Increment 'entry' */
+      dp->value[opt] = options[opt].values[++entry].value;
+      dp->stack[sp].entry = entry;
+   }
+
+   set_opt_string(dp, sp);
+
+   if (!search && opt_list_end(dp, opt, entry)) /* end of list */
+      dp->stack[sp].end = 1;
+
+   else if (!dp->stack[sp].end) /* still active after all these tests */
+      dp->nsp = dp->tsp;
+}
+
+static int
+compare_option(const struct display *dp, unsigned int sp)
+{
+   int opt = dp->stack[sp].opt;
+
+   /* If the best so far is numerically less than the current value the
+    * current set of options is invariably worse.
+    */
+   if (dp->stack[sp].best_val < dp->value[opt])
+      return -1;
+
+   /* Lists of options are searched out of numerical order (currently only
+    * strategy), so only return +1 here when a range is being searched.
+    */
+   else if (dp->stack[sp].best_val > dp->value[opt])
+   {
+      if (dp->stack[sp].lo <= dp->stack[sp].hi /*searching*/)
+         return 1;
+
+      else
+         return -1;
+   }
+
+   else
+      return 0; /* match; current value is the best one */
+}
+
+static int
+advance_opt(struct display *dp, png_byte opt, int search)
+{
+   unsigned int sp = dp->csp++; /* my stack entry */
+
+   assert(sp >= dp->nsp); /* nsp starts off zero */
+
+   /* If the entry was active in the previous run dp->stack[sp] is already
+    * set up and dp->tsp will be greater than sp, otherwise a new entry
+    * needs to be created.
+    *
+    * dp->nsp is handled this way:
+    *
+    * 1) When an option is pushed onto the stack dp->nsp and dp->tsp are
+    *    both set (by push_opt) to the next stack entry *unless* there is
+    *    only one entry in the new list, in which case dp->stack[sp].end
+    *    is set.
+    *
+    * 2) For the top stack entry next_opt is called.  The entry must be
+    *    active (dp->stack[sp].end is not set) and either 'nsp' or 'end'
+    *    will be updated as appropriate.
+    *
+    * 3) For lower stack entries nsp is set unless the stack entry is
+    *    already at the end.  This means that when all the higher entries
+    *    are popped this entry will be too.
+    */
+   if (sp >= dp->tsp)
+   {
+      push_opt(dp, sp, opt, search); /* This sets tsp to sp+1 */
+      return 1; /* initialized */
+   }
+
+   else
+   {
+      int ret = 0; /* unchanged */
+
+      /* An option that is already on the stack; update best_size and best_val
+       * if appropriate.  On the first run there are no previous values and
+       * dp->write_size will be MAX_SIZE, however on the first run dp->tsp
+       * starts off as 0.
+       */
+      assert(dp->write_size > 0U && dp->write_size < MAX_SIZE);
+
+      if (dp->stack[sp].best_size > dp->write_size ||
+          (dp->stack[sp].best_size == dp->write_size &&
+           compare_option(dp, sp) > 0))
+      {
+         dp->stack[sp].best_size = dp->write_size;
+         dp->stack[sp].best_val = dp->value[opt];
+      }
+
+      if (sp+1U >= dp->tsp)
+      {
+         next_opt(dp, sp);
+         ret = 1; /* advanced */
+      }
+
+      else if (!dp->stack[sp].end) /* Active, not at top of stack */
+         dp->nsp = sp+1U;
+
+      return ret; /* advanced || unchanged */
+   }
+}
+
+static int
+getallopts_(struct display *dp, png_byte opt, int *value, int record)
+   /* Like getop but iterate over all the values if the option was set to "all".
+    */
+{
+   if (dp->entry[opt]) /* option was set on command line */
+   {
+      /* Simple, single value, entries don't have a stack frame and have a fixed
+       * value (it doesn't change once set on the command line).  Otherwise the
+       * value (entry) selected from the command line is 'all':
+       */
+      const char *entry_name = options[opt].values[dp->entry[opt]-1].name;
+
+      if (entry_name == all)
+         (void)advance_opt(dp, opt, 0/*do not search; iterate*/);
+
+      else if (record)
+         record_opt(dp, opt, entry_name);
+
+      *value = dp->value[opt];
+      return 1; /* set */
+   }
+
+   else
+      return 0; /* not set */
+}
+
+static int
+getallopts(struct display *dp, const char *opt_str, int *value)
+{
+   return getallopts_(dp, option_index(dp, opt_str, strlen(opt_str)), value, 0);
+}
+
+static int
+getsearchopts(struct display *dp, const char *opt_str, int *value)
+   /* As above except that if the option was not set try a search */
+{
+   png_byte istrat;
+   png_byte opt = option_index(dp, opt_str, strlen(opt_str));
+   int record = options[opt].search;
+   const char *entry_name;
+
+   /* If it was set on the command line honour the setting, including 'all'
+    * which will override the built in search:
+    */
+   if (getallopts_(dp, opt, value, record))
+      return 1;
+
+   else if (!record) /* not a search option */
+      return 0; /* unset and not searched */
+
+   /* Otherwise decide what to do here. */
+   istrat = OPTIND(dp, strategy);
+   entry_name = range_lo; /* record the value, not the name */
+
+   if (opt == istrat) /* search all strategies */
+      (void)advance_opt(dp, opt, 0/*iterate*/), record=0;
+
+   else if (opt == OPTIND(dp, level))
+   {
+      /* Both RLE and HUFFMAN don't benefit from level increases */
+      if (dp->value[istrat] == Z_RLE || dp->value[istrat] == Z_HUFFMAN_ONLY)
+         dp->value[opt] = 1;
+
+      else /* fixed, filtered or default */
+         (void)advance_opt(dp, opt, 1/*search*/), record=0;
+   }
+
+   else if (opt == OPTIND(dp, windowBits))
+   {
+      /* Changing windowBits for strategies that do not search the window is
+       * pointless.  Huffman-only does not search, RLE only searches backwards
+       * one byte, so given that the maximum string length is 258, a windowBits
+       * of 9 is always sufficient.
+       */
+      if (dp->value[istrat] == Z_HUFFMAN_ONLY)
+         dp->value[opt] = 8;
+
+      else if (dp->value[istrat] == Z_RLE)
+         dp->value[opt] = 9;
+
+      else /* fixed, filtered or default */
+         (void)advance_opt(dp, opt, 1/*search*/), record=0;
+   }
+
+   else if (opt == OPTIND(dp, memLevel))
+   {
+#     if 0
+         (void)advance_opt(dp, opt, 0/*all*/), record=0;
+#     else
+         dp->value[opt] = MAX_MEM_LEVEL;
+#     endif
+   }
+
+   else /* something else */
+      assert(0=="reached");
+
+   if (record)
+      record_opt(dp, opt, entry_name);
+
+   /* One of the above searched options: */
+   *value = dp->value[opt];
+   return 1;
+}
+
+static int
+find_val(struct display *dp, png_byte opt, const char *str, size_t len)
+   /* Like option_index but sets (index+i) of the entry in options[opt] that
+    * matches str[0..len-1] into dp->entry[opt] as well as returning the actual
+    * value.
+    */
+{
+   int rlo = INT_MAX, rhi = INT_MIN;
+   png_byte j, irange = 0;
+
+   for (j=1U; j<=options[opt].value_count; ++j)
+   {
+      if (strncmp(options[opt].values[j-1U].name, str, len) == 0 &&
+          options[opt].values[j-1U].name[len] == 0)
+      {
+         dp->entry[opt] = j;
+         return options[opt].values[j-1U].value;
+      }
+      else if (options[opt].values[j-1U].name == range_lo)
+         rlo = options[opt].values[j-1U].value, irange = j;
+      else if (options[opt].values[j-1U].name == range_hi)
+         rhi = options[opt].values[j-1U].value;
+   }
+
+   /* No match on the name, but there may be a range. */
+   if (irange > 0)
+   {
+      char *ep = NULL;
+      long l = strtol(str, &ep, 0);
+
+      if (ep == str+len && l >= rlo && l <= rhi)
+      {
+         dp->entry[opt] = irange; /* range_lo */
+         return (int)/*SAFE*/l;
+      }
+   }
+
+   display_log(dp, dp->errset ? INTERNAL_ERROR : USER_ERROR,
+         "%s: unknown value setting '%.*s'", options[opt].name,
+         (int)/*SAFE*/len, str);
+   abort(); /* NOT REACHED */
+}
+
+static int
+opt_check(struct display *dp, const char *arg)
+{
+   assert(dp->errset == 0);
+
+   if (arg != NULL && arg[0] == '-' && arg[1] == '-')
+   {
+      int i = 0, negate = (strncmp(arg+2, "no-", 3) == 0), val;
+      png_byte j;
+
+      if (negate)
+         arg += 5; /* --no- */
+
+      else
+         arg += 2; /* -- */
+
+      /* Find the length (expect arg\0 or arg=) */
+      while (arg[i] != 0 && arg[i] != '=') ++i;
+
+      /* So arg[0..i-1] is the argument name, this does not return if this isn't
+       * a valid option name.
+       */
+      j = option_index(dp, arg, i);
+
+      /* It matcheth an option; check the remainder. */
+      if (arg[i] == 0) /* no specified value, use the default */
+      {
+         val = options[j].values[negate].value;
+         dp->entry[j] = (png_byte)/*SAFE*/(negate + 1U);
+      }
+
+      else
+      {
+         const char *list = arg + (i+1);
+
+         /* Expect a single value here unless this is a list, in which case
+          * multiple values are combined.
+          */
+         if (options[j].opt != LIST)
+         {
+            /* find_val sets 'dp->entry[j]' to a non-zero value: */
+            val = find_val(dp, j, list, strlen(list));
+
+            if (negate)
+            {
+               if (options[j].opt < OPTION)
+                  val = !val;
+
+               else
+               {
+                  display_log(dp, USER_ERROR,
+                        "%.*s: option=arg cannot be negated", i, arg);
+                  abort(); /* NOT REACHED */
+               }
+            }
+         }
+
+         else /* multiple options separated by ',' characters */
+         {
+            /* --no-option negates list values from the default, which should
+             * therefore be 'all'.  Notice that if the option list is empty in
+             * this case nothing will be removed and therefore --no-option= is
+             * the same as --option.
+             */
+            if (negate)
+               val = options[j].values[0].value;
+
+            else
+               val = 0;
+
+            while (*list != 0) /* allows option= which sets 0 */
+            {
+               /* A value is terminated by the end of the list or a ','
+                * character.
+                */
+               int v, iv;
+
+               iv = 0; /* an index into 'list' */
+               while (list[++iv] != 0 && list[iv] != ',') {}
+
+               v = find_val(dp, j, list, iv);
+
+               if (negate)
+                  val &= ~v;
+
+               else
+                  val |= v;
+
+               list += iv;
+               if (*list != 0)
+                  ++list; /* skip the ',' */
+            }
+         }
+      }
+
+      /* 'val' is the new value, store it for use later and debugging: */
+      dp->value[j] = val;
+
+      if (options[j].opt < LEVEL_MASK)
+      {
+         /* The handling for error levels is to set the level. */
+         if (val) /* Set this level */
+            dp->options = (dp->options & ~LEVEL_MASK) | options[j].opt;
+
+         else
+            display_log(dp, USER_ERROR,
+      "%.*s: messages cannot be turned off individually; set a message level",
+                  i, arg);
+      }
+
+      else if (options[j].opt < OPTION)
+      {
+         if (val)
+            dp->options |= options[j].opt;
+
+         else
+            dp->options &= ~options[j].opt;
+      }
+
+      return 1; /* this is an option */
+   }
+
+   else
+      return 0; /* not an option */
+}
+
+#ifdef PNG_PNGCP_TIMING_SUPPORTED
+static void
+set_timer(struct display *dp, struct timespec *timer)
+{
+   /* Do the timing using clock_gettime and the per-process timer. */
+   if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, timer))
+   {
+      display_log(dp, APP_ERROR,
+            "CLOCK_PROCESS_CPUTIME_ID: %s: timing disabled\n", strerror(errno));
+      dp->value[OPTIND(dp,time)] = 0; /* i.e. off */
+   }
+}
+
+static void
+start_timer(struct display *dp, int what)
+{
+   if ((dp->value[OPTIND(dp,time)] & what) != 0)
+      set_timer(dp, what == PNGCP_TIME_READ ? &dp->read_time : &dp->write_time);
+}
+
+static void
+end_timer(struct display *dp, int what)
+{
+   if ((dp->value[OPTIND(dp,time)] & what) != 0)
+   {
+      struct timespec t, tmp;
+
+      set_timer(dp, &t);
+
+      if (what == PNGCP_TIME_READ)
+         tmp = dp->read_time;
+
+      else
+         tmp = dp->write_time;
+
+      t.tv_sec -= tmp.tv_sec;
+      t.tv_nsec -= tmp.tv_nsec;
+
+      if (t.tv_nsec < 0)
+      {
+         --(t.tv_sec);
+         t.tv_nsec += 1000000000L;
+      }
+
+      if (what == PNGCP_TIME_READ)
+         dp->read_time = t, tmp = dp->read_time_total;
+
+      else
+         dp->write_time = t, tmp = dp->write_time_total;
+
+      tmp.tv_sec += t.tv_sec;
+      tmp.tv_nsec += t.tv_nsec;
+
+      if (tmp.tv_nsec >= 1000000000L)
+      {
+         ++(tmp.tv_sec);
+         tmp.tv_nsec -= 1000000000L;
+      }
+
+      if (what == PNGCP_TIME_READ)
+         dp->read_time_total = tmp;
+
+      else
+         dp->write_time_total = tmp;
+   }
+}
+
+static void
+print_time(const char *what, struct timespec t)
+{
+   printf("%s %.2lu.%.9ld", what, (unsigned long)t.tv_sec, t.tv_nsec);
+}
+#else /* !PNGCP_TIMING */
+#define start_timer(dp, what) ((void)0)
+#define end_timer(dp, what) ((void)0)
+#endif /* !PNGCP_TIMING */
+
+/* The following is used in main to verify that the final argument is a
+ * directory:
+ */
+static int
+checkdir(const char *pathname)
+{
+   struct stat buf;
+   return stat(pathname, &buf) == 0 && S_ISDIR(buf.st_mode);
+}
+
+/* Work out whether a path is valid (if not a display_log occurs), a directory
+ * (1 is returned) or a file *or* non-existent (0 is returned).
+ *
+ * Used for a write path.
+ */
+static int
+isdir(struct display *dp, const char *pathname)
+{
+   if (pathname == NULL)
+      return 0; /* stdout */
+
+   else if (pathname[0] == 0)
+      return 1; /* empty string */
+
+   else
+   {
+      struct stat buf;
+      int ret = stat(pathname, &buf);
+
+      if (ret == 0) /* the entry exists */
+      {
+         if (S_ISDIR(buf.st_mode))
+            return 1;
+
+         /* Else expect an object that exists and can be written: */
+         if (access(pathname, W_OK) != 0)
+            display_log(dp, USER_ERROR, "%s: cannot be written (%s)", pathname,
+                  strerror(errno));
+
+         return 0; /* file (exists, can be written) */
+      }
+
+      else /* an error */
+      {
+         /* Non-existence is fine, other errors are not: */
+         if (errno != ENOENT)
+            display_log(dp, USER_ERROR, "%s: invalid output name (%s)",
+                  pathname, strerror(errno));
+
+         return 0; /* file (does not exist) */
+      }
+   }
+}
+
+static void
+makename(struct display *dp, const char *dir, const char *infile)
+{
+   /* Make a name for an output file (and check it). */
+   dp->namebuf[0] = 0;
+
+   if (dir == NULL || infile == NULL)
+      display_log(dp, INTERNAL_ERROR, "NULL name to makename");
+
+   else
+   {
+      size_t dsize = strlen(dir);
+
+      if (dsize <= (sizeof dp->namebuf)-2) /* Allow for name + '/' + '\0' */
+      {
+         size_t isize = strlen(infile);
+         size_t istart = isize-1;
+
+         /* This should fail before here: */
+         if (infile[istart] == '/')
+            display_log(dp, INTERNAL_ERROR, "infile with trailing /");
+
+         memcpy(dp->namebuf, dir, dsize);
+         if (dsize > 0 && dp->namebuf[dsize-1] != '/')
+            dp->namebuf[dsize++] = '/';
+
+         /* Find the rightmost non-/ character: */
+         while (istart > 0 && infile[istart-1] != '/')
+            --istart;
+
+         isize -= istart;
+         infile += istart;
+
+         if (dsize+isize < (sizeof dp->namebuf)) /* dsize + infile + '\0' */
+         {
+            memcpy(dp->namebuf+dsize, infile, isize+1);
+
+            if (isdir(dp, dp->namebuf))
+               display_log(dp, USER_ERROR, "%s: output file is a directory",
+                     dp->namebuf);
+         }
+
+         else
+         {
+            dp->namebuf[dsize] = 0; /* allowed for: -2 at start */
+            display_log(dp, USER_ERROR, "%s%s: output file name too long",
+                  dp->namebuf, infile);
+         }
+      }
+
+      else
+         display_log(dp, USER_ERROR, "%s: output directory name too long", dir);
+   }
+}
+
+/* error handler callbacks for libpng */
+static void PNGCBAPI
+display_warning(png_structp pp, png_const_charp warning)
+{
+   struct display *dp = get_dp(pp);
+
+   /* This is used to prevent repeated warnings while searching */
+   if (!dp->no_warnings)
+      display_log(get_dp(pp), LIBPNG_WARNING, "%s", warning);
+}
+
+static void PNGCBAPI
+display_error(png_structp pp, png_const_charp error)
+{
+   struct display *dp = get_dp(pp);
+
+   display_log(dp, LIBPNG_ERROR, "%s", error);
+}
+
+static void
+display_start_read(struct display *dp, const char *filename)
+{
+   if (filename != NULL)
+   {
+      dp->filename = filename;
+      dp->fp = fopen(filename, "rb");
+   }
+
+   else
+   {
+      dp->filename = "<stdin>";
+      dp->fp = stdin;
+   }
+
+   dp->w = dp->h = 0U;
+   dp->bpp = 0U;
+   dp->size = 0U;
+   dp->read_size = 0U;
+
+   if (dp->fp == NULL)
+      display_log(dp, USER_ERROR, "file open failed (%s)", strerror(errno));
+}
+
+static void PNGCBAPI
+read_function(png_structp pp, png_bytep data, size_t size)
+{
+   struct display *dp = get_dp(pp);
+
+   if (size == 0U || fread(data, size, 1U, dp->fp) == 1U)
+      dp->read_size += size;
+
+   else
+   {
+      if (feof(dp->fp))
+         display_log(dp, LIBPNG_ERROR, "PNG file truncated");
+      else
+         display_log(dp, LIBPNG_ERROR, "PNG file read failed (%s)",
+               strerror(errno));
+   }
+}
+
+static void
+read_png(struct display *dp, const char *filename)
+{
+   display_clean_read(dp); /* safety */
+   display_start_read(dp, filename);
+
+   dp->read_pp = png_create_read_struct(PNG_LIBPNG_VER_STRING, dp,
+      display_error, display_warning);
+   if (dp->read_pp == NULL)
+      display_log(dp, LIBPNG_ERROR, "failed to create read struct");
+
+#  ifdef PNG_BENIGN_ERRORS_SUPPORTED
+      png_set_benign_errors(dp->read_pp, 1/*allowed*/);
+#  endif /* BENIGN_ERRORS */
+
+#  ifdef FIX_INDEX
+      if ((dp->options & FIX_INDEX) != 0)
+         png_set_check_for_invalid_index(dp->read_pp, 1/*on, no warning*/);
+#     ifdef IGNORE_INDEX
+         else
+#     endif /* IGNORE_INDEX */
+#  endif /* FIX_INDEX */
+#  ifdef IGNORE_INDEX
+      if ((dp->options & IGNORE_INDEX) != 0) /* DANGEROUS */
+         png_set_check_for_invalid_index(dp->read_pp, -1/*off completely*/);
+#  endif /* IGNORE_INDEX */
+
+   /* The png_read_png API requires us to make the info struct, but it does the
+    * call to png_read_info.
+    */
+   dp->ip = png_create_info_struct(dp->read_pp);
+   if (dp->ip == NULL)
+      png_error(dp->read_pp, "failed to create info struct");
+
+   /* Set the IO handling */
+   png_set_read_fn(dp->read_pp, dp, read_function);
+
+#  ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+      png_set_keep_unknown_chunks(dp->read_pp, PNG_HANDLE_CHUNK_ALWAYS, NULL,
+            0);
+#  endif /* HANDLE_AS_UNKNOWN */
+
+#  ifdef PNG_SET_USER_LIMITS_SUPPORTED
+      /* Remove the user limits, if any */
+      png_set_user_limits(dp->read_pp, 0x7fffffff, 0x7fffffff);
+#  endif /* SET_USER_LIMITS */
+
+   /* Now read the PNG. */
+   start_timer(dp, PNGCP_TIME_READ);
+   png_read_png(dp->read_pp, dp->ip, 0U/*transforms*/, NULL/*params*/);
+   end_timer(dp, PNGCP_TIME_READ);
+   dp->w = png_get_image_width(dp->read_pp, dp->ip);
+   dp->h = png_get_image_height(dp->read_pp, dp->ip);
+   dp->ct = png_get_color_type(dp->read_pp, dp->ip);
+   dp->bpp = png_get_bit_depth(dp->read_pp, dp->ip) *
+             png_get_channels(dp->read_pp, dp->ip);
+   {
+      /* png_get_rowbytes should never return 0 because the value is set by the
+       * first call to png_set_IHDR, which should have happened by now, but just
+       * in case:
+       */
+      png_alloc_size_t rb = png_get_rowbytes(dp->read_pp, dp->ip);
+
+      if (rb == 0)
+         png_error(dp->read_pp, "invalid row byte count from libpng");
+
+      /* The size calc can overflow. */
+      if ((MAX_SIZE-dp->h)/rb < dp->h)
+         png_error(dp->read_pp, "image too large");
+
+      dp->size = rb * dp->h + dp->h/*filter byte*/;
+   }
+
+#ifdef FIX_INDEX
+   if (dp->ct == PNG_COLOR_TYPE_PALETTE && (dp->options & FIX_INDEX) != 0)
+   {
+      int max = png_get_palette_max(dp->read_pp, dp->ip);
+      png_colorp palette = NULL;
+      int num = -1;
+
+      if (png_get_PLTE(dp->read_pp, dp->ip, &palette, &num) != PNG_INFO_PLTE
+          || max < 0 || num <= 0 || palette == NULL)
+         display_log(dp, LIBPNG_ERROR, "invalid png_get_PLTE result");
+
+      if (max >= num)
+      {
+         /* 'Fix' the palette. */
+         int i;
+         png_color newpal[256];
+
+         for (i=0; i<num; ++i)
+            newpal[i] = palette[i];
+
+         /* Fill in any remainder with a warning color: */
+         for (; i<=max; ++i)
+         {
+            newpal[i].red = 0xbe;
+            newpal[i].green = 0xad;
+            newpal[i].blue = 0xed;
+         }
+
+         png_set_PLTE(dp->read_pp, dp->ip, newpal, i);
+      }
+   }
+#endif /* FIX_INDEX */
+
+   display_clean_read(dp);
+   dp->operation = "none";
+}
+
+static void
+display_start_write(struct display *dp, const char *filename)
+{
+   assert(dp->fp == NULL);
+
+   if ((dp->options & NOWRITE) != 0)
+      dp->output_file = "<no write>";
+
+   else
+   {
+      if (filename != NULL)
+      {
+         dp->output_file = filename;
+         dp->fp = fopen(filename, "wb");
+      }
+
+      else
+      {
+         dp->output_file = "<stdout>";
+         dp->fp = stdout;
+      }
+
+      if (dp->fp == NULL)
+         display_log(dp, USER_ERROR, "%s: file open failed (%s)",
+               dp->output_file, strerror(errno));
+   }
+}
+
+static void PNGCBAPI
+write_function(png_structp pp, png_bytep data, size_t size)
+{
+   struct display *dp = get_dp(pp);
+
+   /* The write fail is classed as a USER_ERROR, so --quiet does not turn it
+    * off, this seems more likely to be correct.
+    */
+   if (dp->fp == NULL || fwrite(data, size, 1U, dp->fp) == 1U)
+   {
+      dp->write_size += size;
+      if (dp->write_size < size || dp->write_size == MAX_SIZE)
+         png_error(pp, "IDAT size overflow");
+   }
+
+   else
+      display_log(dp, USER_ERROR, "%s: PNG file write failed (%s)",
+            dp->output_file, strerror(errno));
+}
+
+/* Compression option, 'method' is never set: there is no choice.
+ *
+ * IMPORTANT: the order of the entries in this macro determines the preference
+ * order when two different combos of two of these options produce an IDAT of
+ * the same size.  The logic here is to put the things that affect the decoding
+ * of the PNG image ahead of those that are relevant only to the encoding.
+ */
+#define SET_COMPRESSION\
+   SET(strategy, strategy);\
+   SET(windowBits, window_bits);\
+   SET(level, level);\
+   SET(memLevel, mem_level);
+
+#ifdef PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED
+static void
+search_compression(struct display *dp)
+{
+   /* Like set_compression below but use a more restricted search than 'all' */
+   int val;
+
+#  define SET(name, func) if (getsearchopts(dp, #name, &val))\
+      png_set_compression_ ## func(dp->write_pp, val);
+   SET_COMPRESSION
+#  undef SET
+}
+
+static void
+set_compression(struct display *dp)
+{
+   int val;
+
+#  define SET(name, func) if (getallopts(dp, #name, &val))\
+      png_set_compression_ ## func(dp->write_pp, val);
+   SET_COMPRESSION
+#  undef SET
+}
+
+#ifdef PNG_SW_COMPRESS_level /* 1.7.0+ */
+static void
+set_ICC_profile_compression(struct display *dp)
+{
+   int val;
+
+#  define SET(name, func) if (getallopts(dp, "ICC-profile-" #name, &val))\
+      png_set_ICC_profile_compression_ ## func(dp->write_pp, val);
+   SET_COMPRESSION
+#  undef SET
+}
+#else
+#  define set_ICC_profile_compression(dp) ((void)0)
+#endif
+#else
+#  define search_compression(dp) ((void)0)
+#  define set_compression(dp) ((void)0)
+#  define set_ICC_profile_compression(dp) ((void)0)
+#endif /* WRITE_CUSTOMIZE_COMPRESSION */
+
+#ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
+static void
+set_text_compression(struct display *dp)
+{
+   int val;
+
+#  define SET(name, func) if (getallopts(dp, "text-" #name, &val))\
+      png_set_text_compression_ ## func(dp->write_pp, val);
+   SET_COMPRESSION
+#  undef SET
+}
+#else
+#  define set_text_compression(dp) ((void)0)
+#endif /* WRITE_CUSTOMIZE_ZTXT_COMPRESSION */
+
+static void
+write_png(struct display *dp, const char *destname)
+{
+   display_clean_write(dp); /* safety */
+   display_start_write(dp, destname);
+
+   dp->write_pp = png_create_write_struct(PNG_LIBPNG_VER_STRING, dp,
+      display_error, display_warning);
+
+   if (dp->write_pp == NULL)
+      display_log(dp, LIBPNG_ERROR, "failed to create write png_struct");
+
+#  ifdef PNG_BENIGN_ERRORS_SUPPORTED
+      png_set_benign_errors(dp->write_pp, 1/*allowed*/);
+#  endif /* BENIGN_ERRORS */
+
+   png_set_write_fn(dp->write_pp, dp, write_function, NULL/*flush*/);
+
+#ifdef IGNORE_INDEX
+   if ((dp->options & IGNORE_INDEX) != 0) /* DANGEROUS */
+      png_set_check_for_invalid_index(dp->write_pp, -1/*off completely*/);
+#endif /* IGNORE_INDEX */
+
+   /* Restore the text chunks when using libpng 1.6 or less; this is a macro
+    * which expands to nothing in 1.7+  In earlier versions it tests
+    * dp->text_stashed, which is only set (below) *after* the first write.
+    */
+   text_restore(dp);
+
+#  ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+      png_set_keep_unknown_chunks(dp->write_pp, PNG_HANDLE_CHUNK_ALWAYS, NULL,
+            0);
+#  endif /* HANDLE_AS_UNKNOWN */
+
+#  ifdef PNG_SET_USER_LIMITS_SUPPORTED
+      /* Remove the user limits, if any */
+      png_set_user_limits(dp->write_pp, 0x7fffffff, 0x7fffffff);
+#  endif
+
+   /* OPTION HANDLING */
+   /* compression outputs, IDAT and zTXt/iTXt: */
+   dp->tsp = dp->nsp;
+   dp->nsp = dp->csp = 0;
+#  ifdef PNG_SW_COMPRESS_png_level
+      {
+         int val;
+
+         /* This sets everything, but then the following options just override
+          * the specific settings for ICC profiles and text.
+          */
+         if (getallopts(dp, "compression", &val))
+            png_set_compression(dp->write_pp, val);
+
+         if (getallopts(dp, "ICC-profile-compression", &val))
+            png_set_ICC_profile_compression(dp->write_pp, val);
+
+         if (getallopts(dp, "text-compression", &val))
+            png_set_text_compression(dp->write_pp, val);
+      }
+#  endif /* png_level support */
+   if (dp->options & SEARCH)
+      search_compression(dp);
+   else
+      set_compression(dp);
+   set_ICC_profile_compression(dp);
+   set_text_compression(dp);
+
+   {
+      int val;
+
+      /* The permitted range is 1..0x7FFFFFFF, so the cast is safe */
+      if (get_option(dp, "IDAT-size", &val))
+         png_set_IDAT_size(dp->write_pp, val);
+   }
+
+   /* filter handling */
+#  ifdef PNG_WRITE_FILTER_SUPPORTED
+      {
+         int val;
+
+         if (get_option(dp, "filter", &val))
+            png_set_filter(dp->write_pp, PNG_FILTER_TYPE_BASE, val);
+      }
+#  endif /* WRITE_FILTER */
+
+   /* This just uses the 'read' info_struct directly, it contains the image. */
+   dp->write_size = 0U;
+   start_timer(dp, PNGCP_TIME_WRITE);
+   png_write_png(dp->write_pp, dp->ip, 0U/*transforms*/, NULL/*params*/);
+   end_timer(dp, PNGCP_TIME_WRITE);
+
+   /* Make sure the file was written ok: */
+   if (dp->fp != NULL)
+   {
+      FILE *fp = dp->fp;
+      dp->fp = NULL;
+      if (fclose(fp))
+         display_log(dp, APP_ERROR, "%s: write failed (%s)",
+               destname == NULL ? "stdout" : destname, strerror(errno));
+   }
+
+   /* Clean it on the way out - if control returns to the caller then the
+    * written_file contains the required data.
+    */
+   display_clean_write(dp);
+   dp->operation = "none";
+}
+
+static void
+set_windowBits_hi(struct display *dp)
+{
+   /* windowBits is in the range 8..15 but zlib maps '8' to '9' so it is only
+    * worth using if the data size is 256 byte or less.
+    */
+   int wb = MAX_WBITS; /* for large images */
+   int i = VLSIZE(windowBits_IDAT);
+
+   while (wb > 8 && dp->size <= 1U<<(wb-1)) --wb;
+
+   while (--i >= 0) if (VLNAME(windowBits_IDAT)[i].name == range_hi) break;
+
+   assert(i > 1); /* vl_windowBits_IDAT always has a RANGE() */
+   VLNAME(windowBits_IDAT)[i].value = wb;
+
+   assert(VLNAME(windowBits_IDAT)[--i].name == range_lo);
+   VLNAME(windowBits_IDAT)[i].value = wb > 8 ? 9 : 8;
+
+   /* If wb == 8 then any search has been restricted to just one windowBits
+    * entry.  Record that here to avoid producing a spurious app-level warning
+    * above.
+    */
+   if (wb == 8)
+      dp->min_windowBits = OPTIND(dp, windowBits);
+}
+
+static int
+better_options(const struct display *dp)
+{
+   /* Are these options better than the best found so far?  Normally the
+    * options are tested in preference order, best first, however when doing a
+    * search operation on a range the range values are tested out of order.  In
+    * that case preferable options will get tested later.
+    *
+    * This function looks through the stack from the bottom up looking for an
+    * option that does not match the current best value.  When it finds one it
+    * checks to see if it is more or less desirable and returns true or false
+    * as appropriate.
+    *
+    * Notice that this means that the order options are pushed onto the stack
+    * conveys a priority; lower/earlier options are more important than later
+    * ones.
+    */
+   unsigned int sp;
+
+   for (sp=0; sp<dp->csp; ++sp)
+   {
+      int c = compare_option(dp, sp);
+
+      if (c < 0)
+         return 0; /* worse */
+
+      else if (c > 0)
+         return 1; /* better */
+   }
+
+   assert(0 && "unreached");
+}
+
+static void
+print_search_results(struct display *dp)
+{
+   assert(dp->filename != NULL);
+   printf("%s [%ld x %ld %d bpp %s, %lu bytes] %lu -> %lu with '%s'\n",
+      dp->filename, (unsigned long)dp->w, (unsigned long)dp->h, dp->bpp,
+      cts(dp->ct), (unsigned long)dp->size, (unsigned long)dp->read_size,
+      (unsigned long)dp->best_size, dp->best);
+   fflush(stdout);
+}
+
+static void
+log_search(struct display *dp, unsigned int log_depth)
+{
+   /* Log, and reset, the search so far: */
+   if (dp->nsp/*next entry to change*/ <= log_depth)
+   {
+      print_search_results(dp);
+      /* Start again with this entry: */
+      dp->best_size = MAX_SIZE;
+   }
+}
+
+static void
+cp_one_file(struct display *dp, const char *filename, const char *destname)
+{
+   unsigned int log_depth;
+
+   dp->filename = filename;
+   dp->operation = "read";
+   dp->no_warnings = 0;
+
+   /* Read it then write it: */
+   if (filename != NULL && access(filename, R_OK) != 0)
+      display_log(dp, USER_ERROR, "%s: invalid file name (%s)",
+            filename, strerror(errno));
+
+   read_png(dp, filename);
+
+   /* But 'destname' may be a directory. */
+   dp->operation = "write";
+
+   /* Limit the upper end of the windowBits range for this file */
+   set_windowBits_hi(dp);
+
+   /* For logging, depth to log: */
+   {
+      int val;
+
+      if (get_option(dp, "log-depth", &val) && val >= 0)
+         log_depth = (unsigned int)/*SAFE*/val;
+
+      else
+         log_depth = 0U;
+   }
+
+   if (destname != NULL) /* else stdout */
+   {
+      if (isdir(dp, destname))
+      {
+         makename(dp, destname, filename);
+         destname = dp->namebuf;
+      }
+
+      else if (access(destname, W_OK) != 0 && errno != ENOENT)
+         display_log(dp, USER_ERROR, "%s: invalid output name (%s)", destname,
+               strerror(errno));
+   }
+
+   dp->nsp = 0;
+   dp->curr[0] = 0; /* acts as a flag for the caller */
+   dp->opt_string_start = 0;
+   dp->best[0] = 0; /* safety */
+   dp->best_size = MAX_SIZE;
+   write_png(dp, destname);
+
+   /* Initialize the 'best' fields: */
+   strcpy(dp->best, dp->curr);
+   dp->best_size = dp->write_size;
+
+   if (dp->nsp > 0) /* iterating over lists */
+   {
+      char *tmpname, tmpbuf[(sizeof dp->namebuf) + 4];
+      assert(dp->curr[0] == ' ' && dp->tsp > 0);
+
+      /* Cancel warnings on subsequent writes */
+      log_search(dp, log_depth);
+      dp->no_warnings = 1;
+
+      /* Make a temporary name for the subsequent tests: */
+      if (destname != NULL)
+      {
+         strcpy(tmpbuf, destname);
+         strcat(tmpbuf, ".tmp"); /* space for .tmp allocated above */
+         tmpname = tmpbuf;
+      }
+
+      else
+         tmpname = NULL; /* stdout */
+
+      /* Loop to find the best option. */
+      do
+      {
+         write_png(dp, tmpname);
+
+         /* And compare the sizes (the write function makes sure write_size
+          * doesn't overflow.)
+          */
+         assert(dp->csp > 0);
+
+         if (dp->write_size < dp->best_size ||
+             (dp->write_size == dp->best_size && better_options(dp)))
+         {
+            if (destname != NULL && rename(tmpname, destname) != 0)
+               display_log(dp, APP_ERROR, "rename %s %s failed (%s)", tmpname,
+                     destname, strerror(errno));
+
+            strcpy(dp->best, dp->curr);
+            dp->best_size = dp->write_size;
+         }
+
+         else if (tmpname != NULL && unlink(tmpname) != 0)
+            display_log(dp, APP_WARNING, "unlink %s failed (%s)", tmpname,
+                  strerror(errno));
+
+         log_search(dp, log_depth);
+      }
+      while (dp->nsp > 0);
+
+      /* Do this for the 'sizes' option so that it reports the correct size. */
+      dp->write_size = dp->best_size;
+   }
+}
+
+static int
+cppng(struct display *dp, const char *file, const char *gv dest)
+   /* Exists solely to isolate the setjmp clobbers which some versions of GCC
+    * erroneously generate.
+    */
+{
+   int ret = setjmp(dp->error_return);
+
+   if (ret == 0)
+   {
+      dp->errset = 1;
+      cp_one_file(dp, file, dest);
+      dp->errset = 0;
+      return 0;
+   }
+
+   else
+   {
+      dp->errset = 0;
+
+      if (ret < ERRORS) /* shouldn't longjmp on warnings */
+         display_log(dp, INTERNAL_ERROR, "unexpected return code %d", ret);
+
+      return ret;
+   }
+}
+
+int
+main(int argc, char **argv)
+{
+   /* For each file on the command line test it with a range of transforms */
+   int option_end;
+   struct display d;
+
+   display_init(&d);
+
+   d.operation = "options";
+   for (option_end = 1;
+        option_end < argc && opt_check(&d, argv[option_end]);
+        ++option_end)
+   {
+   }
+
+   /* Do a quick check on the directory target case; when there are more than
+    * two arguments the last one must be a directory.
+    */
+   if (!(d.options & NOWRITE) && option_end+2 < argc && !checkdir(argv[argc-1]))
+   {
+      fprintf(stderr,
+            "pngcp: %s: directory required with more than two arguments\n",
+            argv[argc-1]);
+      return 99;
+   }
+
+   {
+      int errors = 0;
+      int i = option_end;
+
+      /* Do this at least once; if there are no arguments stdin/stdout are used.
+       */
+      d.operation = "files";
+      do
+      {
+         const char *infile = NULL;
+         const char *outfile = NULL;
+         int ret;
+
+         if (i < argc)
+         {
+            infile = argv[i++];
+            if (!(d.options & NOWRITE) && i < argc)
+               outfile = argv[argc-1];
+         }
+
+         ret = cppng(&d, infile, outfile);
+
+         if (ret)
+         {
+            if (ret > QUIET) /* abort on user or internal error */
+               return 99;
+
+            /* An error: the output is meaningless */
+         }
+
+         else if (d.best[0] != 0)
+         {
+            /* This result may already have been output, in which case best_size
+             * has been reset.
+             */
+            if (d.best_size < MAX_SIZE)
+               print_search_results(&d);
+         }
+
+         else if (d.options & SIZES)
+         {
+            printf("%s [%ld x %ld %d bpp %s, %lu bytes] %lu -> %lu [0x%lx]\n",
+                  infile, (unsigned long)d.w, (unsigned long)d.h, d.bpp,
+                  cts(d.ct), (unsigned long)d.size, (unsigned long)d.read_size,
+                  (unsigned long)d.write_size, (unsigned long)d.results);
+            fflush(stdout);
+         }
+
+         /* Here on any return, including failures, except user/internal issues
+          */
+         {
+            int pass = (d.options & STRICT) ?
+               RESULT_STRICT(d.results) : RESULT_RELAXED(d.results);
+
+            if (!pass)
+               ++errors;
+
+            if (d.options & LOG)
+            {
+               int j;
+
+               printf("%s: pngcp", pass ? "PASS" : "FAIL");
+
+               for (j=1; j<option_end; ++j)
+                  printf(" %s", argv[j]);
+
+               if (infile != NULL)
+                  printf(" %s", infile);
+
+#              ifdef PNG_PNGCP_TIMING_SUPPORTED
+                  /* When logging output the files for each file, if enabled. */
+                  if ((d.value[OPTIND(&d,time)] & PNGCP_TIME_READ) != 0)
+                     print_time(" read", d.read_time);
+
+                  if ((d.value[OPTIND(&d,time)] & PNGCP_TIME_WRITE) != 0)
+                     print_time(" write", d.write_time);
+#              endif /* PNGCP_TIMING */
+
+               printf("\n");
+               fflush(stdout);
+            }
+         }
+
+         display_clean(&d);
+      }
+      while (i+!(d.options & NOWRITE) < argc);
+         /* I.e. for write cases after the first time through the loop require
+          * there to be at least two arguments left and for the last one to be a
+          * directory (this was checked above).
+          */
+
+      /* Release allocated memory */
+      display_destroy(&d);
+
+#     ifdef PNG_PNGCP_TIMING_SUPPORTED
+         {
+            int output = 0;
+
+            if ((d.value[OPTIND(&d,time)] & PNGCP_TIME_READ) != 0)
+               print_time("read", d.read_time_total), output = 1;
+
+            if ((d.value[OPTIND(&d,time)] & PNGCP_TIME_WRITE) != 0)
+            {
+               if (output) putchar(' ');
+               print_time("write", d.write_time_total);
+               output = 1;
+            }
+
+            if (output) putchar('\n');
+         }
+#     endif /* PNGCP_TIMING */
+
+      return errors != 0;
+   }
+}
+#else /* !READ_PNG || !WRITE_PNG */
+int
+main(void)
+{
+   fprintf(stderr, "pngcp: no support for png_read/write_image\n");
+   return 77;
+}
+#endif /* !READ_PNG || !WRITE_PNG */
diff --git a/Engine/lib/lpng/contrib/tools/pngfix.c b/Engine/lib/lpng/contrib/tools/pngfix.c
new file mode 100644
index 000000000..2fa5d13ea
--- /dev/null
+++ b/Engine/lib/lpng/contrib/tools/pngfix.c
@@ -0,0 +1,4049 @@
+/* pngfix.c
+ *
+ * Last changed in libpng 1.6.31 [July 27, 2017]
+ * Copyright (c) 2014-2017 John Cunningham Bowler
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * Tool to check and fix the zlib inflate 'too far back' problem.
+ * See the usage message for more information.
+ */
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <limits.h>
+#include <errno.h>
+#include <assert.h>
+
+#define implies(x,y) assert(!(x) || (y))
+
+#ifdef __GNUC__
+   /* This is used to fix the error:
+    *
+    * pngfix.c:
+    * In function 'zlib_advance':
+    * pngfix.c:181:13: error: assuming signed overflow does not
+    *   occur when simplifying conditional to constant [-Werror=strict-overflow]
+    */
+#  define FIX_GCC volatile
+#else
+#  define FIX_GCC
+#endif
+
+#define PROGRAM_NAME "pngfix"
+
+/* Define the following to use this program against your installed libpng,
+ * rather than the one being built here:
+ */
+#ifdef PNG_FREESTANDING_TESTS
+#  include <png.h>
+#else
+#  include "../../png.h"
+#endif
+
+#if PNG_LIBPNG_VER < 10603 /* 1.6.3 */
+#  error "pngfix will not work with libpng prior to 1.6.3"
+#endif
+
+#ifdef PNG_SETJMP_SUPPORTED
+#include <setjmp.h>
+
+#if defined(PNG_READ_SUPPORTED) && defined(PNG_EASY_ACCESS_SUPPORTED) &&\
+   (defined(PNG_READ_DEINTERLACE_SUPPORTED) ||\
+    defined(PNG_READ_INTERLACING_SUPPORTED))
+
+/* zlib.h defines the structure z_stream, an instance of which is included
+ * in this structure and is required for decompressing the LZ compressed
+ * data in PNG files.
+ */
+#ifndef ZLIB_CONST
+   /* We must ensure that zlib uses 'const' in declarations. */
+#  define ZLIB_CONST
+#endif
+#include <zlib.h>
+#ifdef const
+   /* zlib.h sometimes #defines const to nothing, undo this. */
+#  undef const
+#endif
+
+/* zlib.h has mediocre z_const use before 1.2.6, this stuff is for compatibility
+ * with older builds.
+ */
+#if ZLIB_VERNUM < 0x1260
+#  define PNGZ_MSG_CAST(s) constcast(char*,s)
+#  define PNGZ_INPUT_CAST(b) constcast(png_bytep,b)
+#else
+#  define PNGZ_MSG_CAST(s) (s)
+#  define PNGZ_INPUT_CAST(b) (b)
+#endif
+
+#ifndef PNG_MAXIMUM_INFLATE_WINDOW
+#  error "pngfix not supported in this libpng version"
+#endif
+
+#if ZLIB_VERNUM >= 0x1240
+
+/* Copied from pngpriv.h */
+#ifdef __cplusplus
+#  define voidcast(type, value) static_cast<type>(value)
+#  define constcast(type, value) const_cast<type>(value)
+#  define aligncast(type, value) \
+   static_cast<type>(static_cast<void*>(value))
+#  define aligncastconst(type, value) \
+   static_cast<type>(static_cast<const void*>(value))
+#else
+#  define voidcast(type, value) (value)
+#  define constcast(type, value) ((type)(value))
+#  define aligncast(type, value) ((void*)(value))
+#  define aligncastconst(type, value) ((const void*)(value))
+#endif /* __cplusplus */
+
+#if PNG_LIBPNG_VER < 10700
+/* Chunk tags (copied from pngpriv.h) */
+#define PNG_32b(b,s) ((png_uint_32)(b) << (s))
+#define PNG_U32(b1,b2,b3,b4) \
+   (PNG_32b(b1,24) | PNG_32b(b2,16) | PNG_32b(b3,8) | PNG_32b(b4,0))
+
+/* Constants for known chunk types. */
+#define png_IDAT PNG_U32( 73,  68,  65,  84)
+#define png_IEND PNG_U32( 73,  69,  78,  68)
+#define png_IHDR PNG_U32( 73,  72,  68,  82)
+#define png_PLTE PNG_U32( 80,  76,  84,  69)
+#define png_bKGD PNG_U32( 98,  75,  71,  68)
+#define png_cHRM PNG_U32( 99,  72,  82,  77)
+#define png_fRAc PNG_U32(102,  82,  65,  99) /* registered, not defined */
+#define png_gAMA PNG_U32(103,  65,  77,  65)
+#define png_gIFg PNG_U32(103,  73,  70, 103)
+#define png_gIFt PNG_U32(103,  73,  70, 116) /* deprecated */
+#define png_gIFx PNG_U32(103,  73,  70, 120)
+#define png_hIST PNG_U32(104,  73,  83,  84)
+#define png_iCCP PNG_U32(105,  67,  67,  80)
+#define png_iTXt PNG_U32(105,  84,  88, 116)
+#define png_oFFs PNG_U32(111,  70,  70, 115)
+#define png_pCAL PNG_U32(112,  67,  65,  76)
+#define png_pHYs PNG_U32(112,  72,  89, 115)
+#define png_sBIT PNG_U32(115,  66,  73,  84)
+#define png_sCAL PNG_U32(115,  67,  65,  76)
+#define png_sPLT PNG_U32(115,  80,  76,  84)
+#define png_sRGB PNG_U32(115,  82,  71,  66)
+#define png_sTER PNG_U32(115,  84,  69,  82)
+#define png_tEXt PNG_U32(116,  69,  88, 116)
+#define png_tIME PNG_U32(116,  73,  77,  69)
+#define png_tRNS PNG_U32(116,  82,  78,  83)
+#define png_zTXt PNG_U32(122,  84,  88, 116)
+#endif
+
+/* The 8-byte signature as a pair of 32-bit quantities */
+#define sig1 PNG_U32(137,  80,  78,  71)
+#define sig2 PNG_U32( 13,  10,  26,  10)
+
+/* Is the chunk critical? */
+#define CRITICAL(chunk) (((chunk) & PNG_U32(32,0,0,0)) == 0)
+
+/* Is it safe to copy? */
+#define SAFE_TO_COPY(chunk) (((chunk) & PNG_U32(0,0,0,32)) != 0)
+
+/* Fix ups for builds with limited read support */
+#ifndef PNG_ERROR_TEXT_SUPPORTED
+#  define png_error(a,b) png_err(a)
+#endif
+
+/********************************* UTILITIES **********************************/
+/* UNREACHED is a value to cause an assert to fail. Because of the way the
+ * assert macro is written the string "UNREACHED" is produced in the error
+ * message.
+ */
+#define UNREACHED 0
+
+/* 80-bit number handling - a PNG image can be up to (2^31-1)x(2^31-1) 8-byte
+ * (16-bit RGBA) pixels in size; that's less than 2^65 bytes or 2^68 bits, so
+ * arithmetic of 80-bit numbers is sufficient.  This representation uses an
+ * arbitrary length array of png_uint_16 digits (0..65535).  The representation
+ * is little endian.
+ *
+ * The arithmetic functions take zero to two uarb values together with the
+ * number of digits in those values and write the result to the given uarb
+ * (always the first argument) returning the number of digits in the result.
+ * If the result is negative the return value is also negative (this would
+ * normally be an error).
+ */
+typedef png_uint_16  udigit; /* A 'unum' is an array of these */
+typedef png_uint_16p uarb;
+typedef png_const_uint_16p uarbc;
+
+#define UDIGITS(unum) ((sizeof unum)/(sizeof (udigit))
+   /* IMPORTANT: only apply this to an array, applied to a pointer the result
+    * will typically be '2', which is not useful.
+    */
+
+static int
+uarb_set(uarb result, png_alloc_size_t val)
+   /* Set (initialize) 'result' to 'val'.  The size required for 'result' must
+    * be determined by the caller from a knowledge of the maximum for 'val'.
+    */
+{
+   int ndigits = 0;
+
+   while (val > 0)
+   {
+      result[ndigits++] = (png_uint_16)(val & 0xffff);
+      val >>= 16;
+   }
+
+   return ndigits;
+}
+
+static int
+uarb_copy(uarb to, uarb from, int idigits)
+   /* Copy a uarb, may reduce the digit count */
+{
+   int d, odigits;
+
+   for (d=odigits=0; d<idigits; ++d)
+      if ((to[d] = from[d]) != 0)
+         odigits = d+1;
+
+   return odigits;
+}
+
+static int
+uarb_inc(uarb num, int in_digits, png_int_32 add)
+   /* This is a signed 32-bit add, except that to avoid overflow the value added
+    * or subtracted must be no more than 2^31-65536.  A negative result
+    * indicates a negative number (which is an error below).  The size of
+    * 'num' should be max(in_digits+1,2) for arbitrary 'add' but can be just
+    * in_digits+1 if add is known to be in the range -65535..65535.
+    */
+{
+   FIX_GCC int out_digits = 0;
+
+   while (out_digits < in_digits)
+   {
+      add += num[out_digits];
+      num[out_digits++] = (png_uint_16)(add & 0xffff);
+      add >>= 16;
+   }
+
+   while (add != 0 && add != (-1))
+   {
+      num[out_digits++] = (png_uint_16)(add & 0xffff);
+      add >>= 16;
+   }
+
+   if (add == 0)
+   {
+      while (out_digits > 0 && num[out_digits-1] == 0)
+         --out_digits;
+      return out_digits; /* may be 0 */
+   }
+
+   else /* negative result */
+   {
+      while (out_digits > 1 && num[out_digits-1] == 0xffff)
+         --out_digits;
+
+      return -out_digits;
+   }
+}
+
+static int
+uarb_add32(uarb num, int in_digits, png_uint_32 add)
+   /* As above but this works with any 32-bit value and only does 'add' */
+{
+   if (in_digits > 0)
+   {
+      in_digits = uarb_inc(num, in_digits, add & 0xffff);
+      return uarb_inc(num+1, in_digits-1, add >> 16)+1;
+   }
+
+   return uarb_set(num, add);
+}
+
+static int
+uarb_mult_digit(uarb acc, int a_digits, uarb num, FIX_GCC int n_digits,
+   png_uint_16 val)
+   /* Primitive one-digit multiply - 'val' must be 0..65535. Note that this
+    * primitive is a multiply and accumulate - the result of *num * val is added
+    * to *acc.
+    *
+    * This is a one-digit multiply, so the product may be up to one digit longer
+    * than 'num', however the add to 'acc' means that the caller must ensure
+    * that 'acc' is at least one digit longer than this *and* at least one digit
+    * longer than the current length of 'acc'.  (Or the caller must otherwise
+    * ensure 'adigits' is adequate from knowledge of the values.)
+    */
+{
+   /* The digits in *acc, *num and val are in the range 0..65535, so the
+    * result below is at most (65535*65535)+2*65635 = 65535*(65535+2), which is
+    * exactly 0xffffffff.
+    */
+   if (val > 0 && n_digits > 0) /* Else the product is 0 */
+   {
+      png_uint_32 carry = 0;
+      int out_digits = 0;
+
+      while (out_digits < n_digits || carry > 0)
+      {
+         if (out_digits < a_digits)
+            carry += acc[out_digits];
+
+         if (out_digits < n_digits)
+            carry += (png_uint_32)num[out_digits] * val;
+
+         acc[out_digits++] = (png_uint_16)(carry & 0xffff);
+         carry >>= 16;
+      }
+
+      /* So carry is 0 and all the input digits have been consumed. This means
+       * that it is possible to skip any remaining digits in acc.
+       */
+      if (out_digits > a_digits)
+         return out_digits;
+   }
+
+   return a_digits;
+}
+
+static int
+uarb_mult32(uarb acc, int a_digits, uarb num, int n_digits, png_uint_32 val)
+   /* calculate acc += num * val, 'val' may be any 32-bit value, 'acc' and 'num'
+    * may be any value, returns the number of digits in 'acc'.
+    */
+{
+   if (n_digits > 0 && val > 0)
+   {
+      a_digits = uarb_mult_digit(acc, a_digits, num, n_digits,
+         (png_uint_16)(val & 0xffff));
+
+      val >>= 16;
+      if (val > 0)
+         a_digits = uarb_mult_digit(acc+1, a_digits-1, num, n_digits,
+            (png_uint_16)val) + 1;
+
+      /* Because n_digits and val are >0 the following must be true: */
+      assert(a_digits > 0);
+   }
+
+   return a_digits;
+}
+
+static int
+uarb_shift(uarb inout, int ndigits, unsigned int right_shift)
+   /* Shift inout right by right_shift bits, right_shift must be in the range
+    * 1..15
+    */
+{
+   FIX_GCC int i = ndigits;
+   png_uint_16 carry = 0;
+
+   assert(right_shift >= 1 && right_shift <= 15);
+
+   while (--i >= 0)
+   {
+      png_uint_16 temp = (png_uint_16)(carry | (inout[i] >> right_shift));
+
+      /* Bottom bits to top bits of carry */
+      carry = (png_uint_16)((inout[i] << (16-right_shift)) & 0xffff);
+
+      inout[i] = temp;
+
+      /* The shift may reduce ndigits */
+      if (i == ndigits-1 && temp == 0)
+         ndigits = i;
+   }
+
+   return ndigits;
+}
+
+static int
+uarb_cmp(uarb a, int adigits, uarb b, int bdigits)
+   /* Return -1/0/+1 according as a<b/a==b/a>b */
+{
+   if (adigits < bdigits)
+      return -1;
+
+   if (adigits > bdigits)
+      return 1;
+
+   while (adigits-- > 0)
+      if (a[adigits] < b[adigits])
+         return -1;
+
+      else if (a[adigits] > b[adigits])
+         return 1;
+
+   return 0;
+}
+
+#if 0 /*UNUSED*/
+static int
+uarb_eq32(uarb num, int digits, png_uint_32 val)
+   /* Return true if the uarb is equal to 'val' */
+{
+   switch (digits)
+   {
+      case 0:  return val == 0;
+      case 1:  return val == num[0];
+      case 2:  return (val & 0xffff) == num[0] && (val >> 16) == num[1];
+      default: return 0;
+   }
+}
+#endif
+
+static void
+uarb_printx(uarb num, int digits, FILE *out)
+   /* Print 'num' as a hexadecimal number (easier than decimal!) */
+{
+   while (digits > 0)
+      if (num[--digits] > 0)
+      {
+         fprintf(out, "0x%x", num[digits]);
+
+         while (digits > 0)
+            fprintf(out, "%.4x", num[--digits]);
+      }
+
+      else if (digits == 0) /* the number is 0 */
+         fputs("0x0", out);
+}
+
+static void
+uarb_print(uarb num, int digits, FILE *out)
+   /* Prints 'num' as a decimal if it will fit in an unsigned long, else as a
+    * hexadecimal number.  Notice that the results vary for images over 4GByte
+    * in a system dependent way, and the hexadecimal form doesn't work very well
+    * in awk script input.
+    *
+    *
+    * TODO: write uarb_div10
+    */
+{
+   if (digits * sizeof (udigit) > sizeof (unsigned long))
+      uarb_printx(num, digits, out);
+
+   else
+   {
+      unsigned long n = 0;
+
+      while (digits > 0)
+         n = (n << 16) + num[--digits];
+
+      fprintf(out, "%lu", n);
+   }
+}
+
+/* Generate random bytes.  This uses a boring repeatable algorithm and it
+ * is implemented here so that it gives the same set of numbers on every
+ * architecture.  It's a linear congruential generator (Knuth or Sedgewick
+ * "Algorithms") but it comes from the 'feedback taps' table in Horowitz and
+ * Hill, "The Art of Electronics" (Pseudo-Random Bit Sequences and Noise
+ * Generation.)
+ *
+ * (Copied from contrib/libtests/pngvalid.c)
+ */
+static void
+make_random_bytes(png_uint_32* seed, void* pv, size_t size)
+{
+   png_uint_32 u0 = seed[0], u1 = seed[1];
+   png_bytep bytes = voidcast(png_bytep, pv);
+
+   /* There are thirty-three bits; the next bit in the sequence is bit-33 XOR
+    * bit-20.  The top 1 bit is in u1, the bottom 32 are in u0.
+    */
+   size_t i;
+   for (i=0; i<size; ++i)
+   {
+      /* First generate 8 new bits then shift them in at the end. */
+      png_uint_32 u = ((u0 >> (20-8)) ^ ((u1 << 7) | (u0 >> (32-7)))) & 0xff;
+      u1 <<= 8;
+      u1 |= u0 >> 24;
+      u0 <<= 8;
+      u0 |= u;
+      *bytes++ = (png_byte)u;
+   }
+
+   seed[0] = u0;
+   seed[1] = u1;
+}
+
+/* Clear an object to a random value. */
+static void
+clear(void *pv, size_t size)
+{
+   static png_uint_32 clear_seed[2] = { 0x12345678, 0x9abcdef0 };
+   make_random_bytes(clear_seed, pv, size);
+}
+
+#define CLEAR(object) clear(&(object), sizeof (object))
+
+/* Copied from unreleased 1.7 code.
+ *
+ * CRC checking uses a local pre-built implementation of the Ethernet CRC32.
+ * This is to avoid a function call to the zlib DLL and to optimize the
+ * byte-by-byte case.
+ */
+static png_uint_32 crc_table[256] =
+{
+   0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
+   0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
+   0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
+   0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
+   0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
+   0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
+   0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
+   0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
+   0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
+   0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
+   0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
+   0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+   0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
+   0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
+   0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
+   0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
+   0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
+   0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
+   0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
+   0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
+   0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
+   0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
+   0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
+   0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+   0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
+   0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
+   0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
+   0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
+   0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
+   0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
+   0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
+   0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
+   0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
+   0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
+   0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
+   0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+   0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
+   0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
+   0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
+   0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
+   0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
+   0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
+   0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
+   0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
+   0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
+   0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
+   0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
+   0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+   0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
+   0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
+   0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
+   0x2d02ef8d
+};
+
+/* The CRC calculated here *IS* conditioned, the corresponding value used by
+ * zlib and the result value is obtained by XORing with CRC_INIT, which is also
+ * the first value that must be passed in (for the first byte) to crc_one_byte.
+ */
+#define CRC_INIT 0xffffffff
+
+static png_uint_32
+crc_one_byte(png_uint_32 crc, int b)
+{
+   return crc_table[(crc ^ b) & 0xff] ^ (crc >> 8);
+}
+
+static png_uint_32
+crc_init_4(png_uint_32 value)
+{
+   /* This is an alternative to the algorithm used in zlib, which requires four
+    * separate tables to parallelize the four byte operations, it only works for
+    * a CRC of the first four bytes of the stream, but this is what happens in
+    * the parser below where length+chunk-name is read and chunk-name used to
+    * initialize the CRC.  Notice that the calculation here avoids repeated
+    * conditioning (xor with 0xffffffff) by storing the conditioned value.
+    */
+   png_uint_32 crc = crc_table[(~value >> 24)] ^ 0xffffff;
+
+   crc = crc_table[(crc ^ (value >> 16)) & 0xff] ^ (crc >> 8);
+   crc = crc_table[(crc ^ (value >> 8)) & 0xff] ^ (crc >> 8);
+   return crc_table[(crc ^ value) & 0xff] ^ (crc >> 8);
+}
+
+static int
+chunk_type_valid(png_uint_32 c)
+   /* Bit whacking approach to chunk name validation that is intended to avoid
+    * branches.  The cost is that it uses a lot of 32-bit constants, which might
+    * be bad on some architectures.
+    */
+{
+   png_uint_32 t;
+
+   /* Remove bit 5 from all but the reserved byte; this means every
+    * 8-bit unit must be in the range 65-90 to be valid.  So bit 5
+    * must be zero, bit 6 must be set and bit 7 zero.
+    */
+   c &= ~PNG_U32(32,32,0,32);
+   t = (c & ~0x1f1f1f1f) ^ 0x40404040;
+
+   /* Subtract 65 for each 8-bit quantity, this must not overflow
+    * and each byte must then be in the range 0-25.
+    */
+   c -= PNG_U32(65,65,65,65);
+   t |=c ;
+
+   /* Subtract 26, handling the overflow which should set the top
+    * three bits of each byte.
+    */
+   c -= PNG_U32(25,25,25,26);
+   t |= ~c;
+
+   return (t & 0xe0e0e0e0) == 0;
+}
+
+/**************************** CONTROL INFORMATION *****************************/
+
+/* Information about a sequence of IDAT chunks, the chunks have been re-synced
+ * using sync_stream below and the new lengths are recorded here.  Because the
+ * number of chunks is unlimited this is handled using a linked list of these
+ * structures.
+ */
+struct IDAT_list
+{
+   struct IDAT_list *next;     /* Linked list */
+   unsigned int      length;   /* Actual length of the array below */
+   unsigned int      count;    /* Number of entries that are valid */
+#     define IDAT_INIT_LENGTH 16
+   png_uint_32       lengths[IDAT_INIT_LENGTH];
+};
+
+static void
+IDAT_list_init(struct IDAT_list *list)
+{
+   CLEAR(*list);
+
+   list->next = NULL;
+   list->length = IDAT_INIT_LENGTH;
+}
+
+static size_t
+IDAT_list_size(struct IDAT_list *list, unsigned int length)
+   /* Return the size in bytes of an IDAT_list of the given length. */
+{
+   if (list != NULL)
+      length = list->length;
+
+   return sizeof *list - sizeof list->lengths +
+      length * sizeof list->lengths[0];
+}
+
+static void
+IDAT_list_end(struct IDAT_list *IDAT_list)
+{
+   struct IDAT_list *list = IDAT_list->next;
+
+   CLEAR(*IDAT_list);
+
+   while (list != NULL)
+   {
+      struct IDAT_list *next = list->next;
+
+      clear(list, IDAT_list_size(list, 0));
+      free(list);
+      list = next;
+   }
+}
+
+static struct IDAT_list *
+IDAT_list_extend(struct IDAT_list *tail)
+{
+   /* Use the previous cached value if available. */
+   struct IDAT_list *next = tail->next;
+
+   if (next == NULL)
+   {
+      /* Insert a new, malloc'ed, block of IDAT information buffers, this
+       * one twice as large as the previous one:
+       */
+      unsigned int length = 2 * tail->length;
+
+      if (length < tail->length) /* arithmetic overflow */
+         length = tail->length;
+
+      next = voidcast(IDAT_list*, malloc(IDAT_list_size(NULL, length)));
+      CLEAR(*next);
+
+      /* The caller must handle this: */
+      if (next == NULL)
+         return NULL;
+
+      next->next = NULL;
+      next->length = length;
+      tail->next = next;
+   }
+
+   return next;
+}
+
+/* GLOBAL CONTROL STRUCTURE */
+struct global
+{
+   /* PUBLIC GLOBAL VARIABLES: OWNER INITIALIZE */
+   unsigned int   errors        :1; /* print file errors to stderr */
+   unsigned int   warnings      :1; /* print libpng warnings to stderr */
+   unsigned int   optimize_zlib :1; /* Run optimization search */
+   unsigned int   quiet         :2; /* don't output summaries */
+   unsigned int   verbose       :3; /* various internal tracking */
+   unsigned int   skip          :3; /* Non-critical chunks to skip */
+#     define SKIP_NONE      0
+#     define SKIP_BAD_CRC   1    /* Chunks with a bad CRC */
+#     define SKIP_UNSAFE    2    /* Chunks not safe to copy */
+#     define SKIP_UNUSED    3    /* Chunks not used by libpng */
+#     define SKIP_TRANSFORM 4    /* Chunks only used in transforms */
+#     define SKIP_COLOR     5    /* Everything but tRNS, sBIT, gAMA and sRGB */
+#     define SKIP_ALL       6    /* Everything but tRNS and sBIT */
+
+   png_uint_32    idat_max;         /* 0 to perform no re-chunking */
+
+   int            status_code;      /* Accumulated status code */
+#     define TOO_FAR_BACK   0x01 /* found a too-far-back error */
+#     define CRC_ERROR      0x02 /* fixed an invalid CRC */
+#     define STREAM_ERROR   0x04 /* damaged PNG stream (may be fixable) */
+#     define TRUNCATED      0x08 /* truncated but still readable */
+#     define FILE_ERROR     0x10 /* could not read the file */
+#     define WRITE_ERROR    0x20 /* write error (this terminates the read) */
+#     define INTERNAL_ERROR 0x40 /* internal limits/errors encountered */
+
+   /* PUBLIC GLOBAL VARIABLES: USED INTERNALLY BY IDAT READ CODE */
+   struct IDAT_list idat_cache;  /* Cache of file IDAT information buffers */
+      /* The structure is shared across all uses of this global control
+       * structure to avoid reallocation between IDAT streams.
+       */
+};
+
+static int
+global_end(struct global *global)
+{
+
+   int rc;
+
+   IDAT_list_end(&global->idat_cache);
+   rc = global->status_code;
+   CLEAR(*global);
+   return rc;
+}
+
+static void
+global_init(struct global *global)
+   /* Call this once (and only once) to initialize the control */
+{
+   CLEAR(*global);
+
+   /* Globals */
+   global->errors        = 0;
+   global->warnings      = 0;
+   global->quiet         = 0;
+   global->verbose       = 0;
+   global->idat_max      = 0;         /* no re-chunking of IDAT */
+   global->optimize_zlib = 0;
+   global->skip          = SKIP_NONE;
+   global->status_code   = 0;
+
+   IDAT_list_init(&global->idat_cache);
+}
+
+static int
+skip_chunk_type(const struct global *global, png_uint_32 type)
+   /* Return true if this chunk is to be skipped according to the --strip
+    * option.  This code needs to recognize all known ancillary chunks in order
+    * to handle the --strip=unsafe option.
+    */
+{
+   /* Never strip critical chunks: */
+   if (CRITICAL(type))
+      return 0;
+
+   switch (type)
+   {
+      /* Chunks that are treated as, effectively, critical because they affect
+       * correct interpretation of the pixel values:
+       */
+      case png_tRNS: case png_sBIT:
+         return 0;
+
+      /* Chunks that specify gamma encoding which should therefore only be
+       * removed if the user insists:
+       */
+      case png_gAMA: case png_sRGB:
+         if (global->skip >= SKIP_ALL)
+            return 1;
+         return 0;
+
+      /* Chunks that affect color interpretation - not used by libpng and rarely
+       * used by applications, but technically still required for correct
+       * interpretation of the image data:
+       */
+      case png_cHRM: case png_iCCP:
+         if (global->skip >= SKIP_COLOR)
+            return 1;
+         return 0;
+
+      /* Other chunks that are used by libpng in image transformations (as
+       * opposed to known chunks that have get/set APIs but are not otherwise
+       * used.)
+       */
+      case png_bKGD:
+         if (global->skip >= SKIP_TRANSFORM)
+            return 1;
+         return 0;
+
+      /* All other chunks that libpng knows about and affect neither image
+       * interpretation nor libpng transforms - chunks that are effectively
+       * unused by libpng even though libpng might recognize and store them.
+       */
+      case png_fRAc: case png_gIFg: case png_gIFt: case png_gIFx: case png_hIST:
+      case png_iTXt: case png_oFFs: case png_pCAL: case png_pHYs: case png_sCAL:
+      case png_sPLT: case png_sTER: case png_tEXt: case png_tIME: case png_zTXt:
+         if (global->skip >= SKIP_UNUSED)
+            return 1;
+         return 0;
+
+      /* Chunks that libpng does not know about (notice that this depends on the
+       * list above including all known chunks!)  The decision here depends on
+       * whether the safe-to-copy bit is set in the chunk type.
+       */
+      default:
+         if (SAFE_TO_COPY(type))
+         {
+            if (global->skip >= SKIP_UNUSED) /* as above */
+               return 1;
+         }
+
+         else if (global->skip >= SKIP_UNSAFE)
+            return 1;
+
+         return 0;
+   }
+}
+
+/* PER-FILE CONTROL STRUCTURE */
+struct chunk;
+struct IDAT;
+struct file
+{
+   /* ANCESTORS */
+   struct global *global;
+
+   /* PUBLIC PER-FILE VARIABLES: CALLER INITIALIZE */
+   const char *   file_name;
+   const char *   out_name;      /* Name of output file (if required) */
+
+   /* PUBLIC PER-FILE VARIABLES: SET BY PNG READ CODE */
+   /* File specific result codes */
+   int            status_code;   /* Set to a bit mask of the following: */
+   int            read_errno;    /* Records a read error errno */
+   int            write_errno;   /* Records a write error errno */
+
+   /* IHDR information */
+   png_uint_32    width;
+   png_uint_32    height;
+   png_byte       bit_depth;
+   png_byte       color_type;
+   png_byte       compression_method;
+   png_byte       filter_method;
+   png_byte       interlace_method;
+
+   udigit         image_bytes[5];
+   int            image_digits;
+
+   /* PROTECTED PER-FILE VARIABLES: USED BY THE READ CODE */
+   FILE *         file;          /* Original PNG file */
+   FILE *         out;           /* If a new one is being written */
+   jmp_buf        jmpbuf;        /* Set while reading a PNG */
+
+   /* PROTECTED CHUNK SPECIFIC VARIABLES: USED BY CHUNK CODE */
+   /* The following variables are used during reading to record the length, type
+    * and data position of the *next* chunk or, right at the start, the
+    * signature (in length,type).
+    *
+    * When a chunk control structure is instantiated these values are copied
+    * into the structure and can then be overritten with the data for the next
+    * chunk.
+    */
+   fpos_t         data_pos;      /* Position of first byte of chunk data */
+   png_uint_32    length;        /* First word (length or signature start) */
+   png_uint_32    type;          /* Second word (type or signature end) */
+   png_uint_32    crc;           /* Running chunk CRC (used by read_chunk) */
+
+   /* These counts are maintained by the read and write routines below and are
+    * reset by the chunk handling code.  They record the total number of bytes
+    * read or written for the chunk, including the header (length,type) bytes.
+    */
+   png_uint_32    read_count;    /* Count of bytes read (in the chunk) */
+   png_uint_32    write_count;   /* Count of bytes written (in the chunk) */
+   int            state;         /* As defined here: */
+#     define STATE_SIGNATURE  0  /* The signature is being written */
+#     define STATE_CHUNKS     1  /* Non-IDAT chunks are being written */
+#     define STATE_IDAT       2  /* An IDAT stream is being written */
+
+   /* Two pointers used to enable clean-up in the event of fatal errors and to
+    * hold state about the parser process (only one of each at present.)
+    */
+   struct chunk * chunk;
+   struct IDAT *  idat;
+
+   /* Interface to allocate a new chunk or IDAT control structure.  The result
+    * is returned by setting one or other of the above variables.  Note that the
+    * relevant initializer is called by the allocator function.  The alloc_ptr
+    * is used only by the implementation of the allocate function.
+    */
+   void *         alloc_ptr;
+   void         (*alloc)(struct file*,int idat);
+                                  /* idat: allocate IDAT not chunk */
+};
+
+/* Valid longjmp (stop) codes are: */
+#define LIBPNG_WARNING_CODE   1 /* generic png_error */
+#define LIBPNG_ERROR_CODE     2 /* generic png_error */
+#define ZLIB_ERROR_CODE       3 /* generic zlib error */
+#define INVALID_ERROR_CODE    4 /* detected an invalid PNG */
+#define READ_ERROR_CODE       5 /* read failed */
+#define WRITE_ERROR_CODE      6 /* error in write */
+#define UNEXPECTED_ERROR_CODE 7 /* unexpected (internal?) error */
+
+static void
+emit_string(const char *str, FILE *out)
+   /* Print a string with spaces replaced by '_' and non-printing characters by
+    * an octal escape.
+    */
+{
+   for (; *str; ++str)
+      if (isgraph(UCHAR_MAX & *str))
+         putc(*str, out);
+
+      else if (isspace(UCHAR_MAX & *str))
+         putc('_', out);
+
+      else
+         fprintf(out, "\\%.3o", *str);
+}
+
+static const char *
+strcode(int code)
+{
+   switch (code)
+   {
+      case LIBPNG_WARNING_CODE:   return "warning";
+      case LIBPNG_ERROR_CODE:     return "libpng";
+      case ZLIB_ERROR_CODE:       return "zlib";
+      case INVALID_ERROR_CODE:    return "invalid";
+      case READ_ERROR_CODE:       return "read";
+      case WRITE_ERROR_CODE:      return "write";
+      case UNEXPECTED_ERROR_CODE: return "unexpected";
+      default:                    return "INVALID";
+   }
+}
+
+static void
+emit_error(struct file *file, int code, const char *what)
+   /* Generic error message routine, takes a 'stop' code but can be used
+    * elsewhere.  Always outputs a message.
+    */
+{
+   const char *reason;
+   int err = 0;
+
+   switch (code)
+   {
+      case LIBPNG_WARNING_CODE:   reason = "libpng warning:"; break;
+      case LIBPNG_ERROR_CODE:     reason = "libpng error:"; break;
+      case ZLIB_ERROR_CODE:       reason = "zlib error:"; break;
+      case INVALID_ERROR_CODE:    reason = "invalid"; break;
+      case READ_ERROR_CODE:       reason = "read failure:";
+                                  err = file->read_errno;
+                                  break;
+      case WRITE_ERROR_CODE:      reason = "write error";
+                                  err = file->write_errno;
+                                  break;
+      case UNEXPECTED_ERROR_CODE: reason = "unexpected error:";
+                                  err = file->read_errno;
+                                  if (err == 0)
+                                     err = file->write_errno;
+                                  break;
+      default:                    reason = "INVALID (internal error):"; break;
+   }
+
+   if (err != 0)
+      fprintf(stderr, "%s: %s %s [%s]\n", file->file_name, reason, what,
+         strerror(err));
+
+   else
+      fprintf(stderr, "%s: %s %s\n", file->file_name, reason, what);
+}
+
+static void chunk_end(struct chunk **);
+static void IDAT_end(struct IDAT **);
+
+static int
+file_end(struct file *file)
+{
+   int rc;
+
+   /* If either of the chunk pointers are set end them here, the IDAT structure
+    * must be deallocated first as it may deallocate the chunk structure.
+    */
+   if (file->idat != NULL)
+      IDAT_end(&file->idat);
+
+   if (file->chunk != NULL)
+      chunk_end(&file->chunk);
+
+   rc = file->status_code;
+
+   if (file->file != NULL)
+      (void)fclose(file->file);
+
+   if (file->out != NULL)
+   {
+      /* NOTE: this is bitwise |, all the following functions must execute and
+       * must succeed.
+       */
+      if (ferror(file->out) | fflush(file->out) | fclose(file->out))
+      {
+         perror(file->out_name);
+         emit_error(file, READ_ERROR_CODE, "output write error");
+         rc |= WRITE_ERROR;
+      }
+   }
+
+   /* Accumulate the result codes */
+   file->global->status_code |= rc;
+
+   CLEAR(*file);
+
+   return rc; /* status code: non-zero on read or write error */
+}
+
+static int
+file_init(struct file *file, struct global *global, const char *file_name,
+   const char *out_name, void *alloc_ptr, void (*alloc)(struct file*,int))
+   /* Initialize a file control structure.  This will open the given files as
+    * well.  The status code returned is 0 on success, non zero (using the flags
+    * above) on a file open error.
+    */
+{
+   CLEAR(*file);
+   file->global = global;
+
+   file->file_name = file_name;
+   file->out_name = out_name;
+   file->status_code = 0;
+   file->read_errno = 0;
+   file->write_errno = 0;
+
+   file->file = NULL;
+   file->out = NULL;
+   /* jmpbuf is garbage: must be set by read_png */
+
+   file->read_count = 0;
+   file->state = STATE_SIGNATURE;
+
+   file->chunk = NULL;
+   file->idat = NULL;
+
+   file->alloc_ptr = alloc_ptr;
+   file->alloc = alloc;
+
+   /* Open the files: */
+   assert(file_name != NULL);
+   file->file = fopen(file_name, "rb");
+
+   if (file->file == NULL)
+   {
+      file->read_errno = errno;
+      file->status_code |= FILE_ERROR;
+      /* Always output: please give a readable file! */
+      perror(file_name);
+      return FILE_ERROR;
+   }
+
+   if (out_name != NULL)
+   {
+      file->out = fopen(out_name, "wb");
+
+      if (file->out == NULL)
+      {
+         file->write_errno = errno;
+         file->status_code |= WRITE_ERROR;
+         perror(out_name);
+         return WRITE_ERROR;
+      }
+   }
+
+   return 0;
+}
+
+static void
+log_error(struct file *file, int code, const char *what)
+   /* Like emit_error but checks the global 'errors' flag */
+{
+   if (file->global->errors)
+      emit_error(file, code, what);
+}
+
+static char
+type_char(png_uint_32 v)
+{
+   /* In fact because chunk::chunk_type is validated prior to any call to this
+    * function it will always return a-zA-Z, but the extra codes are just there
+    * to help in finding internal (programming) errors.  Note that the code only
+    * ever considers the low 7 bits of the value (so it is not necessary for the
+    * type_name function to mask of the byte.)
+    */
+   if (v & 32)
+      return "!abcdefghijklmnopqrstuvwxyz56789"[(v-96)&31];
+
+   else
+      return "@ABCDEFGHIJKLMNOPQRSTUVWXYZ01234"[(v-64)&31];
+}
+
+static void
+type_name(png_uint_32 type, FILE *out)
+{
+   putc(type_char(type >> 24), out);
+   putc(type_char(type >> 16), out);
+   putc(type_char(type >>  8), out);
+   putc(type_char(type      ), out);
+}
+
+static void
+type_sep(FILE *out)
+{
+   putc(':', out);
+   putc(' ', out);
+}
+
+static png_uint_32 current_type(struct file *file, int code);
+
+PNG_NORETURN static void
+stop(struct file *file, int code, const char *what)
+   /* Return control when a PNG file cannot be read. This outputs an 'ERR'
+    * summary line too.
+    */
+{
+   log_error(file, code, what);
+
+   /* The chunk being read is typically identified by file->chunk or, if this is
+    * NULL, by file->type.  This may be wrong if libpng reads ahead, but this
+    * only happens with IDAT where libpng reads the header then jumps around
+    * finding errors in the previous chunks.  We know that is happening because
+    * we are at the start of the IDAT (i.e. no IDAT data has yet been written.)
+    *
+    * SUMMARY FORMAT (stop):
+    *
+    * IDAT ERR status code read-errno write-errno message file
+    *
+    * 'uncompressed' will be 0 if there was a problem in the IHDR.  The errno
+    * values are emit_string(strerror(errno)).
+    */
+   if (file->global->quiet < 2) /* need two quiets to stop this. */
+   {
+      png_uint_32 type;
+
+      if (file->chunk != NULL)
+         type = current_type(file, code); /* Gropes in struct chunk and IDAT */
+
+      else
+         type = file->type;
+
+      if (type)
+         type_name(type, stdout);
+
+      else /* magic: an IDAT header, produces bogons for too many IDATs */
+         fputs("HEAD", stdout); /* not a registered chunk! */
+
+      printf(" ERR %.2x %s ", file->status_code, strcode(code));
+      /* This only works one strerror at a time, because of the way strerror is
+       * implemented.
+       */
+      emit_string(strerror(file->read_errno), stdout);
+      putc(' ', stdout);
+      emit_string(strerror(file->write_errno), stdout);
+      putc(' ', stdout);
+      emit_string(what, stdout);
+      putc(' ', stdout);
+      fputs(file->file_name, stdout);
+      putc('\n', stdout);
+   }
+
+   file->status_code |= FILE_ERROR;
+   longjmp(file->jmpbuf, code);
+}
+
+PNG_NORETURN static void
+stop_invalid(struct file *file, const char *what)
+{
+   stop(file, INVALID_ERROR_CODE, what);
+}
+
+static void
+type_message(struct file *file, png_uint_32 type, const char *what)
+   /* Error message for a chunk; the chunk name comes from 'type' */
+{
+   if (file->global->errors)
+   {
+      fputs(file->file_name, stderr);
+      type_sep(stderr);
+      type_name(type, stderr);
+      type_sep(stderr);
+      fputs(what, stderr);
+      putc('\n', stderr);
+   }
+}
+
+/* Input file positioning - we jump around in the input file while reading
+ * stuff, these wrappers deal with the error handling.
+ */
+static void
+file_getpos(struct file *file, fpos_t *pos)
+{
+   if (fgetpos(file->file, pos))
+   {
+      /* This is unexpected, so perror it */
+      perror(file->file_name);
+      stop(file, READ_ERROR_CODE, "fgetpos");
+   }
+}
+
+static void
+file_setpos(struct file *file, const fpos_t *pos)
+{
+   if (fsetpos(file->file, pos))
+   {
+      perror(file->file_name);
+      stop(file, READ_ERROR_CODE, "fsetpos");
+   }
+}
+
+static void
+getpos(struct file *file)
+   /* Get the current position and store it in 'data_pos'.  The corresponding
+    * setpos() function is chunk specific because it uses the copy of the
+    * position for the specific chunk.
+    */
+{
+   file_getpos(file, &file->data_pos);
+}
+
+
+/* Read utility - read a single byte, returns a value in the range 0..255 or EOF
+ * on a read error.  In the latter case status_code and read_errno are updated
+ * appropriately.
+ */
+static int
+read_byte(struct file *file)
+{
+   int ch = getc(file->file);
+
+   if (ch >= 0 && ch <= 255)
+   {
+      ++(file->read_count);
+      return ch;
+   }
+
+   else if (ch != EOF)
+   {
+      file->status_code |= INTERNAL_ERROR;
+      file->read_errno = ERANGE; /* out of range character */
+
+      /* This is very unexpected; an error message is always output: */
+      emit_error(file, UNEXPECTED_ERROR_CODE, "file read");
+   }
+
+#  ifdef EINTR
+      else if (errno == EINTR) /* Interrupted, try again */
+      {
+         errno = 0;
+         return read_byte(file);
+      }
+#  endif
+
+   else
+   {
+      /* An error, it doesn't really matter what the error is but it gets
+       * recorded anyway.
+       */
+      if (ferror(file->file))
+         file->read_errno = errno;
+
+      else if (feof(file->file))
+         file->read_errno = 0; /* I.e. a regular EOF, no error */
+
+      else /* unexpected */
+         file->read_errno = EDOM;
+   }
+
+   /* 'TRUNCATED' is used for all cases of failure to read a byte, because of
+    * the way libpng works a byte read is never attempted unless the byte is
+    * expected to be there, so EOF should not occur.
+    */
+   file->status_code |= TRUNCATED;
+   return EOF;
+}
+
+static png_byte
+reread_byte(struct file *file)
+   /* Read a byte when an error is not expected to happen because the byte has
+    * been read before without error.
+    */
+{
+   int ch = getc(file->file);
+
+   if (errno != 0)
+      file->read_errno = errno;
+
+   if (ch < 0 || ch > 255)
+      stop(file, UNEXPECTED_ERROR_CODE, "reread");
+
+   return (png_byte)ch;
+}
+
+static png_uint_32
+reread_4(struct file *file)
+   /* The same but for a four byte quantity */
+{
+   png_uint_32 result = 0;
+   int i = 0;
+
+   while (++i <= 4)
+      result = (result << 8) + reread_byte(file);
+
+   return result;
+}
+
+static void
+skip_12(struct file *file)
+   /* Skip exactly 12 bytes in the input stream - used to skip a CRC and chunk
+    * header that has been read before.
+    */
+{
+   /* Since the chunks were read before this shouldn't fail: */
+   if (fseek(file->file, 12, SEEK_CUR) != 0)
+   {
+      if (errno != 0)
+         file->read_errno = errno;
+
+      stop(file, UNEXPECTED_ERROR_CODE, "reskip");
+   }
+}
+
+static void
+write_byte(struct file *file, int b)
+   /* Write one byte to the output - this causes a fatal error if the write
+    * fails and the read of this PNG file immediately terminates.  Just
+    * increments the write count if there is no output file.
+    */
+{
+   if (file->out != NULL)
+   {
+      if (putc(b, file->out) != b)
+      {
+         file->write_errno = errno;
+         file->status_code |= WRITE_ERROR;
+         stop(file, WRITE_ERROR_CODE, "write byte");
+      }
+   }
+
+   ++(file->write_count);
+}
+
+/* Derivatives of the read/write functions. */
+static unsigned int
+read_4(struct file *file, png_uint_32 *pu)
+   /* Read four bytes, returns the number of bytes read successfully and, if all
+    * four bytes are read, assigns the result to *pu.
+    */
+{
+   unsigned int i = 0;
+   png_uint_32 val = 0;
+
+   do
+   {
+      int ch = read_byte(file);
+
+      if (ch == EOF)
+         return i;
+
+      val = (val << 8) + ch;
+   } while (++i < 4);
+
+   *pu = val;
+   return i;
+}
+
+/* CRC handling - read but calculate the CRC while doing so. */
+static int
+crc_read_many(struct file *file, png_uint_32 length)
+   /* Reads 'length' bytes and updates the CRC, returns true on success, false
+    * if the input is truncated.
+    */
+{
+   if (length > 0)
+   {
+      png_uint_32 crc = file->crc;
+
+      do
+      {
+         int ch = read_byte(file);
+
+         if (ch == EOF)
+            return 0; /* Truncated */
+
+         crc = crc_one_byte(crc, ch);
+      }
+      while (--length > 0);
+
+      file->crc = crc;
+   }
+
+   return 1; /* OK */
+}
+
+static int
+calc_image_size(struct file *file)
+   /* Fill in the image_bytes field given the IHDR information, calls stop on
+    * error.
+    */
+{
+   png_uint_16 pd = file->bit_depth;
+
+   switch (file->color_type)
+   {
+      default:
+         stop_invalid(file, "IHDR: colour type");
+
+      invalid_bit_depth:
+         stop_invalid(file, "IHDR: bit depth");
+
+      case 0: /* g */
+         if (pd != 1 && pd != 2 && pd != 4 && pd != 8 && pd != 16)
+            goto invalid_bit_depth;
+         break;
+
+      case 3:
+         if (pd != 1 && pd != 2 && pd != 4 && pd != 8)
+            goto invalid_bit_depth;
+         break;
+
+      case 2: /* rgb */
+         if (pd != 8 && pd != 16)
+            goto invalid_bit_depth;
+
+         pd = (png_uint_16)(pd * 3);
+         break;
+
+      case 4: /* ga */
+         if (pd != 8 && pd != 16)
+            goto invalid_bit_depth;
+
+         pd = (png_uint_16)(pd * 2);
+         break;
+
+      case 6: /* rgba */
+         if (pd != 8 && pd != 16)
+            goto invalid_bit_depth;
+
+         pd = (png_uint_16)(pd * 4);
+         break;
+   }
+
+   if (file->width < 1 || file->width > 0x7fffffff)
+      stop_invalid(file, "IHDR: width");
+
+   else if (file->height < 1 || file->height > 0x7fffffff)
+      stop_invalid(file, "IHDR: height");
+
+   else if (file->compression_method != 0)
+      stop_invalid(file, "IHDR: compression method");
+
+   else if (file->filter_method != 0)
+      stop_invalid(file, "IHDR: filter method");
+
+   else switch (file->interlace_method)
+   {
+      case PNG_INTERLACE_ADAM7:
+         /* Interlacing makes the image larger because of the replication of
+          * both the filter byte and the padding to a byte boundary.
+          */
+         {
+            int pass;
+            int image_digits = 0;
+            udigit row_width[2], row_bytes[3];
+
+            for (pass=0; pass<=6; ++pass)
+            {
+               png_uint_32 pw = PNG_PASS_COLS(file->width, pass);
+
+               if (pw > 0)
+               {
+                  int  digits;
+
+                  /* calculate 1+((pw*pd+7)>>3) in row_bytes */
+                  digits = uarb_mult_digit(row_bytes, uarb_set(row_bytes, 7),
+                     row_width, uarb_set(row_width, pw), pd);
+                  digits = uarb_shift(row_bytes, digits, 3);
+                  digits = uarb_inc(row_bytes, digits, 1);
+
+                  /* Add row_bytes * pass-height to the file image_bytes field
+                   */
+                  image_digits = uarb_mult32(file->image_bytes, image_digits,
+                     row_bytes, digits,
+                     PNG_PASS_ROWS(file->height, pass));
+               }
+            }
+
+            file->image_digits = image_digits;
+         }
+         break;
+
+      case PNG_INTERLACE_NONE:
+         {
+            int  digits;
+            udigit row_width[2], row_bytes[3];
+
+            /* As above, but use image_width in place of the pass width: */
+            digits = uarb_mult_digit(row_bytes, uarb_set(row_bytes, 7),
+               row_width, uarb_set(row_width, file->width), pd);
+            digits = uarb_shift(row_bytes, digits, 3);
+            digits = uarb_inc(row_bytes, digits, 1);
+
+            /* Set row_bytes * image-height to the file image_bytes field */
+            file->image_digits = uarb_mult32(file->image_bytes, 0,
+               row_bytes, digits, file->height);
+         }
+         break;
+
+      default:
+         stop_invalid(file, "IHDR: interlace method");
+   }
+
+   assert(file->image_digits >= 1 && file->image_digits <= 5);
+   return 1;
+}
+
+/* PER-CHUNK CONTROL STRUCTURE
+ * This structure is instantiated for each chunk, except for the IDAT chunks
+ * where one chunk control structure is used for the whole of a single stream of
+ * IDAT chunks (see the IDAT control structure below).
+ */
+struct chunk
+{
+   /* ANCESTORS */
+   struct file *         file;
+   struct global *       global;
+
+   /* PUBLIC IDAT INFORMATION: SET BY THE ZLIB CODE */
+   udigit         uncompressed_bytes[5];
+   int            uncompressed_digits;
+   udigit         compressed_bytes[5];
+   int            compressed_digits;
+
+   /* PUBLIC PER-CHUNK INFORMATION: USED BY CHUNK READ CODE */
+   /* This information is filled in by chunk_init from the data in the file
+    * control structure, but chunk_length may be changed later.
+    */
+   fpos_t         chunk_data_pos;    /* Position of first byte of chunk data */
+   png_uint_32    chunk_length;      /* From header (or modified below) */
+   png_uint_32    chunk_type;        /* From header */
+
+   /* PUBLIC PER-CHUNK INFORMATION: FOR THE CHUNK WRITE CODE */
+   png_uint_32    write_crc;         /* Output CRC (may differ from read_crc) */
+   png_uint_32    rewrite_offset;    /* Count of bytes before rewrite. */
+   int            rewrite_length;    /* Number of bytes left to change */
+   png_byte       rewrite_buffer[2]; /* Buffer of new byte values */
+};
+
+static void
+chunk_message(struct chunk *chunk, const char *message)
+{
+   type_message(chunk->file, chunk->chunk_type, message);
+}
+
+static void
+chunk_end(struct chunk **chunk_var)
+{
+   struct chunk *chunk = *chunk_var;
+
+   *chunk_var = NULL;
+   CLEAR(*chunk);
+}
+
+static void
+chunk_init(struct chunk * const chunk, struct file * const file)
+   /* When a chunk is initialized the file length/type/pos are copied into the
+    * corresponding chunk fields and the new chunk is registered in the file
+    * structure.  There can only be one chunk at a time.
+    *
+    * NOTE: this routine must onely be called from the file alloc routine!
+    */
+{
+   assert(file->chunk == NULL);
+
+   CLEAR(*chunk);
+
+   chunk->file = file;
+   chunk->global = file->global;
+
+   chunk->chunk_data_pos = file->data_pos;
+   chunk->chunk_length = file->length;
+   chunk->chunk_type = file->type;
+
+   /* Compresssed/uncompressed size information (from the zlib control structure
+    * that is used to check the compressed data in a chunk.)
+    */
+   chunk->uncompressed_digits = 0;
+   chunk->compressed_digits = 0;
+
+   file->chunk = chunk;
+}
+
+static png_uint_32
+current_type(struct file *file, int code)
+   /* Guess the actual chunk type that causes a stop() */
+{
+   /* This may return png_IDAT for errors detected (late) in the header; that
+    * includes any inter-chunk consistency check that libpng performs.  Assume
+    * that if the chunk_type is png_IDAT and the file write count is 8 this is
+    * what is happening.
+    */
+   if (file->chunk != NULL)
+   {
+      png_uint_32 type = file->chunk->chunk_type;
+
+      /* This is probably wrong for the excess IDATs case, because then libpng
+       * whines about too many of them (apparently in some cases erroneously)
+       * when the header is read.
+       */
+      if (code <= LIBPNG_ERROR_CODE && type == png_IDAT &&
+         file->write_count == 8)
+         type = 0; /* magic */
+
+      return type;
+   }
+
+   else
+      return file->type;
+}
+
+static void
+setpos(struct chunk *chunk)
+   /* Reset the position to 'chunk_data_pos' - the start of the data for this
+    * chunk.  As a side effect the read_count in the file is reset to 8, just
+    * after the length/type header.
+    */
+{
+   chunk->file->read_count = 8;
+   file_setpos(chunk->file, &chunk->chunk_data_pos);
+}
+
+/* Specific chunk handling - called for each chunk header, all special chunk
+ * processing is initiated in these functions.
+ */
+/* The next functions handle special processing for those chunks with LZ data,
+ * the data is identified and checked for validity.  If there are problems which
+ * cannot be corrected the routines return false, otherwise true (although
+ * modification to the zlib header may be required.)
+ *
+ * The compressed data is in zlib format (RFC1950) and consequently has a
+ * minimum length of 7 bytes.
+ */
+static int zlib_check(struct file *file, png_uint_32 offset);
+
+static int
+process_zTXt_iCCP(struct file *file)
+   /* zTXt and iCCP have exactly the same form - keyword, null, compression
+    * method then compressed data.
+    */
+{
+   struct chunk *chunk = file->chunk;
+   png_uint_32 length;
+   png_uint_32 index = 0;
+
+   assert(chunk != NULL && file->idat == NULL);
+   length = chunk->chunk_length;
+   setpos(chunk);
+
+   while (length >= 9)
+   {
+      --length;
+      ++index;
+      if (reread_byte(file) == 0) /* keyword null terminator */
+      {
+         --length;
+         ++index;
+         (void)reread_byte(file); /* compression method */
+         return zlib_check(file, index);
+      }
+   }
+
+   chunk_message(chunk, "too short");
+   return 0; /* skip */
+}
+
+static int
+process_iTXt(struct file *file)
+{
+   /* Like zTXt but more fields. */
+   struct chunk *chunk = file->chunk;
+   png_uint_32 length;
+   png_uint_32 index = 0;
+
+   assert(chunk != NULL && file->idat == NULL);
+   length = chunk->chunk_length;
+   setpos(chunk);
+
+   while (length >= 5)
+   {
+      --length;
+      ++index;
+      if (reread_byte(file) == 0) /* keyword null terminator */
+      {
+         --length;
+         ++index;
+         if (reread_byte(file) == 0) /* uncompressed text */
+            return 1; /* nothing to check */
+
+         --length;
+         ++index;
+         (void)reread_byte(file); /* compression method */
+
+         /* Skip the language tag (null terminated). */
+         while (length >= 9)
+         {
+            --length;
+            ++index;
+            if (reread_byte(file) == 0) /* terminator */
+            {
+               /* Skip the translated keyword */
+               while (length >= 8)
+               {
+                  --length;
+                  ++index;
+                  if (reread_byte(file) == 0) /* terminator */
+                     return zlib_check(file, index);
+               }
+            }
+         }
+
+         /* Ran out of bytes in the compressed case. */
+         break;
+      }
+   }
+
+   log_error(file, INVALID_ERROR_CODE, "iTXt chunk length");
+
+   return 0; /* skip */
+}
+
+/* IDAT READ/WRITE CONTROL STRUCTURE */
+struct IDAT
+{
+   /* ANCESTORS */
+   struct file *         file;
+   struct global *       global;
+
+   /* PROTECTED IDAT INFORMATION: SET BY THE IDAT READ CODE */
+   struct IDAT_list *idat_list_head; /* START of the list of IDAT information */
+   struct IDAT_list *idat_list_tail; /* *END* of the list of IDAT information */
+
+   /* PROTECTED IDAT INFORMATION: USED BY THE IDAT WRITE CODE */
+   struct IDAT_list *idat_cur;       /* Current list entry */
+   unsigned int      idat_count;     /* And the *current* index into the list */
+   png_uint_32       idat_index;     /* Index of *next* input byte to write */
+   png_uint_32       idat_length;    /* Cache of current chunk length */
+};
+
+/* NOTE: there is currently no IDAT_reset, so a stream cannot contain more than
+ * one IDAT sequence (i.e. MNG is not supported).
+ */
+
+static void
+IDAT_end(struct IDAT **idat_var)
+{
+   struct IDAT *idat = *idat_var;
+   struct file *file = idat->file;
+
+   *idat_var = NULL;
+
+   CLEAR(*idat);
+
+   assert(file->chunk != NULL);
+   chunk_end(&file->chunk);
+
+   /* Regardless of why the IDAT was killed set the state back to CHUNKS (it may
+    * already be CHUNKS because the state isn't changed until process_IDAT
+    * returns; a stop will cause IDAT_end to be entered in state CHUNKS!)
+    */
+   file->state = STATE_CHUNKS;
+}
+
+static void
+IDAT_init(struct IDAT * const idat, struct file * const file)
+   /* When the chunk is png_IDAT instantiate an IDAT control structure in place
+    * of a chunk control structure.  The IDAT will instantiate a chunk control
+    * structure using the file alloc routine.
+    *
+    * NOTE: this routine must only be called from the file alloc routine!
+    */
+{
+   assert(file->chunk == NULL);
+   assert(file->idat == NULL);
+
+   CLEAR(*idat);
+
+   idat->file = file;
+   idat->global = file->global;
+
+   /* Initialize the tail to the pre-allocated buffer and set the count to 0
+    * (empty.)
+    */
+   idat->global->idat_cache.count = 0;
+   idat->idat_list_head = idat->idat_list_tail = &idat->global->idat_cache;
+
+   /* Now the chunk.  The allocator calls the initializer of the new chunk and
+    * stores the result in file->chunk:
+    */
+   file->alloc(file, 0/*chunk*/);
+   assert(file->chunk != NULL);
+
+   /* And store this for cleanup (and to check for double alloc or failure to
+    * free.)
+    */
+   file->idat = idat;
+}
+
+static png_uint_32
+rechunk_length(struct IDAT *idat, int start)
+   /* Return the length for the next IDAT chunk, taking into account
+    * rechunking.
+    */
+{
+   png_uint_32 len = idat->global->idat_max;
+
+   if (len == 0) /* use original chunk lengths */
+   {
+      const struct IDAT_list *cur;
+      unsigned int count;
+
+      if (start)
+         return idat->idat_length; /* use the cache */
+
+      /* Otherwise rechunk_length is called at the end of a chunk for the length
+       * of the next one.
+       */
+      cur = idat->idat_cur;
+      count = idat->idat_count;
+
+      assert(idat->idat_index == idat->idat_length &&
+         idat->idat_length == cur->lengths[count]);
+
+      /* Return length of the *next* chunk */
+      if (++count < cur->count)
+         return cur->lengths[count];
+
+      /* End of this list */
+      assert(cur != idat->idat_list_tail);
+      cur = cur->next;
+      assert(cur != NULL && cur->count > 0);
+      return cur->lengths[0];
+   }
+
+   else /* rechunking */
+   {
+      /* The chunk size is the lesser of file->idat_max and the number
+       * of remaining bytes.
+       */
+      png_uint_32 have = idat->idat_length - idat->idat_index;
+
+      if (len > have)
+      {
+         struct IDAT_list *cur = idat->idat_cur;
+         unsigned int j = idat->idat_count+1; /* the next IDAT in the list */
+
+         do
+         {
+            /* Add up the remaining bytes.  This can't overflow because the
+             * individual lengths are always <= 0x7fffffff, so when we add two
+             * of them overflow is not possible.
+             */
+            assert(cur != NULL);
+
+            for (;;)
+            {
+               /* NOTE: IDAT_list::count here, not IDAT_list::length */
+               for (; j < cur->count; ++j)
+               {
+                  have += cur->lengths[j];
+                  if (len <= have)
+                     return len;
+               }
+
+               /* If this was the end return the count of the available bytes */
+               if (cur == idat->idat_list_tail)
+                  return have;
+
+               cur = cur->next;
+               j = 0;
+            }
+         }
+         while (len > have);
+      }
+
+      return len;
+   }
+}
+
+static int
+process_IDAT(struct file *file)
+   /* Process the IDAT stream, this is the more complex than the preceding
+    * cases because the compressed data is spread across multiple IDAT chunks
+    * (typically).  Rechunking of the data is not handled here; all this
+    * function does is establish whether the zlib header needs to be modified.
+    *
+    * Initially the function returns false, indicating that the chunk should not
+    * be written.  It does this until the last IDAT chunk is passed in, then it
+    * checks the zlib data and returns true.
+    *
+    * It does not return false on a fatal error; it calls stop instead.
+    *
+    * The caller must have an instantiated (IDAT) control structure and it must
+    * have extent over the whole read of the IDAT stream.  For a PNG this means
+    * the whole PNG read, for MNG it could have lesser extent.
+    */
+{
+   struct IDAT_list *list;
+
+   assert(file->idat != NULL && file->chunk != NULL);
+
+   /* We need to first check the entire sequence of IDAT chunks to ensure the
+    * stream is in sync.  Do this by building a list of all the chunks and
+    * recording the length of each because the length may have been fixed up by
+    * sync_stream below.
+    *
+    * At the end of the list of chunks, where the type of the next chunk is not
+    * png_IDAT, process the whole stream using the list data to check validity
+    * then return control to the start and rewrite everything.
+    */
+   list = file->idat->idat_list_tail;
+
+   if (list->count == list->length)
+   {
+      list = IDAT_list_extend(list);
+
+      if (list == NULL)
+         stop(file, READ_ERROR_CODE, "out of memory");
+
+      /* Move to the next block */
+      list->count = 0;
+      file->idat->idat_list_tail = list;
+   }
+
+   /* And fill in the next IDAT information buffer. */
+   list->lengths[(list->count)++] = file->chunk->chunk_length;
+
+   /* The type of the next chunk was recorded in the file control structure by
+    * the caller, if this is png_IDAT return 'skip' to the caller.
+    */
+   if (file->type == png_IDAT)
+      return 0; /* skip this for the moment */
+
+   /* This is the final IDAT chunk, so run the tests to check for the too far
+    * back error and possibly optimize the window bits.  This means going back
+    * to the start of the first chunk data, which is stored in the original
+    * chunk allocation.
+    */
+   setpos(file->chunk);
+
+   if (zlib_check(file, 0))
+   {
+      struct IDAT *idat;
+      int cmp;
+
+      /* The IDAT stream was successfully uncompressed; see whether it
+       * contained the correct number of bytes of image data.
+       */
+      cmp = uarb_cmp(file->image_bytes, file->image_digits,
+         file->chunk->uncompressed_bytes, file->chunk->uncompressed_digits);
+
+      if (cmp < 0)
+         type_message(file, png_IDAT, "extra uncompressed data");
+
+      else if (cmp > 0)
+         stop(file, LIBPNG_ERROR_CODE, "IDAT: uncompressed data too small");
+
+      /* Return the stream to the start of the first IDAT chunk; the length
+       * is set in the write case below but the input chunk variables must be
+       * set (once) here:
+       */
+      setpos(file->chunk);
+
+      idat = file->idat;
+      idat->idat_cur = idat->idat_list_head;
+      idat->idat_length = idat->idat_cur->lengths[0];
+      idat->idat_count = 0; /* Count of chunks read in current list */
+      idat->idat_index = 0; /* Index into chunk data */
+
+      /* Update the chunk length to the correct value for the IDAT chunk: */
+      file->chunk->chunk_length = rechunk_length(idat, 1/*start*/);
+
+      /* Change the state to writing IDAT chunks */
+      file->state = STATE_IDAT;
+
+      return 1;
+   }
+
+   else /* Failure to decompress the IDAT stream; give up. */
+      stop(file, ZLIB_ERROR_CODE, "could not uncompress IDAT");
+}
+
+/* ZLIB CONTROL STRUCTURE */
+struct zlib
+{
+   /* ANCESTORS */
+   struct IDAT *  idat;          /* NOTE: May be NULL */
+   struct chunk * chunk;
+   struct file *  file;
+   struct global *global;
+
+   /* GLOBAL ZLIB INFORMATION: SET BY THE CALLER */
+   png_uint_32    rewrite_offset;
+
+   /* GLOBAL ZLIB INFORMATION: SET BY THE ZLIB READ CODE */
+   udigit         compressed_bytes[5];
+   int            compressed_digits;
+   udigit         uncompressed_bytes[5];
+   int            uncompressed_digits;
+   int            file_bits;             /* window bits from the file */
+   int            ok_bits;               /* Set <16 on a successful read */
+   int            cksum;                 /* Set on a checksum error */
+
+   /* PROTECTED ZLIB INFORMATION: USED BY THE ZLIB ROUTINES */
+   z_stream       z;
+   png_uint_32    extra_bytes;   /* Count of extra compressed bytes */
+   int            state;
+   int            rc;            /* Last return code */
+   int            window_bits;   /* 0 if no change */
+   png_byte       header[2];
+};
+
+static const char *
+zlib_flevel(struct zlib *zlib)
+{
+   switch (zlib->header[1] >> 6)
+   {
+      case 0:  return "supfast";
+      case 1:  return "stdfast";
+      case 2:  return "default";
+      case 3:  return "maximum";
+      default: assert(UNREACHED);
+   }
+
+   return "COMPILER BUG";
+}
+
+static const char *
+zlib_rc(struct zlib *zlib)
+   /* Return a string for the zlib return code */
+{
+   switch (zlib->rc)
+   {
+      case Z_OK:              return "Z_OK";
+      case Z_STREAM_END:      return "Z_STREAM_END";
+      case Z_NEED_DICT:       return "Z_NEED_DICT";
+      case Z_ERRNO:           return "Z_ERRNO";
+      case Z_STREAM_ERROR:    return "Z_STREAM_ERROR";
+      case Z_DATA_ERROR:      return "Z_DATA_ERROR";
+      case Z_MEM_ERROR:       return "Z_MEM_ERROR";
+      case Z_BUF_ERROR:       return "Z_BUF_ERROR";
+      case Z_VERSION_ERROR:   return "Z_VERSION_ERROR";
+      default:                return "Z_*INVALID_RC*";
+   }
+}
+
+static void
+zlib_message(struct zlib *zlib, int unexpected)
+   /* Output a message given a zlib rc */
+{
+   if (zlib->global->errors)
+   {
+      const char *reason = zlib->z.msg;
+
+      if (reason == NULL)
+         reason = "[no message]";
+
+      fputs(zlib->file->file_name, stderr);
+      type_sep(stderr);
+      type_name(zlib->chunk->chunk_type, stderr);
+      fprintf(stderr, ": %szlib error: %d (%s) (%s)\n",
+         unexpected ? "unexpected " : "", zlib->rc, zlib_rc(zlib), reason);
+   }
+}
+
+static void
+zlib_end(struct zlib *zlib)
+{
+   /* Output the summary line now; this ensures a summary line always gets
+    * output regardless of the manner of exit.
+    */
+   if (!zlib->global->quiet)
+   {
+      if (zlib->ok_bits < 16) /* stream was read ok */
+      {
+         const char *reason;
+
+         if (zlib->cksum)
+            reason = "CHK"; /* checksum error */
+
+         else if (zlib->ok_bits > zlib->file_bits)
+            reason = "TFB"; /* fixing a too-far-back error */
+
+         else if (zlib->ok_bits == zlib->file_bits)
+            reason = "OK ";
+
+         else
+            reason = "OPT"; /* optimizing window bits */
+
+         /* SUMMARY FORMAT (for a successful zlib inflate):
+          *
+          * IDAT reason flevel file-bits ok-bits compressed uncompressed file
+          */
+         type_name(zlib->chunk->chunk_type, stdout);
+         printf(" %s %s %d %d ", reason, zlib_flevel(zlib), zlib->file_bits,
+            zlib->ok_bits);
+         uarb_print(zlib->compressed_bytes, zlib->compressed_digits, stdout);
+         putc(' ', stdout);
+         uarb_print(zlib->uncompressed_bytes, zlib->uncompressed_digits,
+            stdout);
+         putc(' ', stdout);
+         fputs(zlib->file->file_name, stdout);
+         putc('\n', stdout);
+      }
+
+      else
+      {
+         /* This is a zlib read error; the chunk will be skipped.  For an IDAT
+          * stream this will also cause a fatal read error (via stop()).
+          *
+          * SUMMARY FORMAT:
+          *
+          * IDAT SKP flevel file-bits z-rc compressed message file
+          *
+          * z-rc is the zlib failure code; message is the error message with
+          * spaces replaced by '-'.  The compressed byte count indicates where
+          * in the zlib stream the error occurred.
+          */
+         type_name(zlib->chunk->chunk_type, stdout);
+         printf(" SKP %s %d %s ", zlib_flevel(zlib), zlib->file_bits,
+            zlib_rc(zlib));
+         uarb_print(zlib->compressed_bytes, zlib->compressed_digits, stdout);
+         putc(' ', stdout);
+         emit_string(zlib->z.msg ? zlib->z.msg : "[no_message]", stdout);
+         putc(' ', stdout);
+         fputs(zlib->file->file_name, stdout);
+         putc('\n', stdout);
+      }
+   }
+
+   if (zlib->state >= 0)
+   {
+      zlib->rc = inflateEnd(&zlib->z);
+
+      if (zlib->rc != Z_OK)
+         zlib_message(zlib, 1/*unexpected*/);
+   }
+
+   CLEAR(*zlib);
+}
+
+static int
+zlib_reset(struct zlib *zlib, int window_bits)
+   /* Reinitializes a zlib with a different window_bits */
+{
+   assert(zlib->state >= 0); /* initialized by zlib_init */
+
+   zlib->z.next_in = Z_NULL;
+   zlib->z.avail_in = 0;
+   zlib->z.next_out = Z_NULL;
+   zlib->z.avail_out = 0;
+
+   zlib->window_bits = window_bits;
+   zlib->compressed_digits = 0;
+   zlib->uncompressed_digits = 0;
+
+   zlib->state = 0; /* initialized, once */
+   zlib->rc = inflateReset2(&zlib->z, 0);
+   if (zlib->rc != Z_OK)
+   {
+      zlib_message(zlib, 1/*unexpected*/);
+      return 0;
+   }
+
+   return 1;
+}
+
+static int
+zlib_init(struct zlib *zlib, struct IDAT *idat, struct chunk *chunk,
+   int window_bits, png_uint_32 offset)
+   /* Initialize a zlib_control; the result is true/false */
+{
+   CLEAR(*zlib);
+
+   zlib->idat = idat;
+   zlib->chunk = chunk;
+   zlib->file = chunk->file;
+   zlib->global = chunk->global;
+   zlib->rewrite_offset = offset; /* never changed for this zlib */
+
+   /* *_out does not need to be set: */
+   zlib->z.next_in = Z_NULL;
+   zlib->z.avail_in = 0;
+   zlib->z.zalloc = Z_NULL;
+   zlib->z.zfree = Z_NULL;
+   zlib->z.opaque = Z_NULL;
+
+   zlib->state = -1;
+   zlib->window_bits = window_bits;
+
+   zlib->compressed_digits = 0;
+   zlib->uncompressed_digits = 0;
+
+   /* These values are sticky across reset (in addition to the stuff in the
+    * first block, which is actually constant.)
+    */
+   zlib->file_bits = 24;
+   zlib->ok_bits = 16; /* unset */
+   zlib->cksum = 0; /* set when a checksum error is detected */
+
+   /* '0' means use the header; inflateInit2 should always succeed because it
+    * does nothing apart from allocating the internal zstate.
+    */
+   zlib->rc = inflateInit2(&zlib->z, 0);
+   if (zlib->rc != Z_OK)
+   {
+      zlib_message(zlib, 1/*unexpected*/);
+      return 0;
+   }
+
+   else
+   {
+      zlib->state = 0; /* initialized */
+      return 1;
+   }
+}
+
+static int
+max_window_bits(uarbc size, int ndigits)
+   /* Return the zlib stream window bits required for data of the given size. */
+{
+   png_uint_16 cb;
+
+   if (ndigits > 1)
+      return 15;
+
+   cb = size[0];
+
+   if (cb > 16384) return 15;
+   if (cb >  8192) return 14;
+   if (cb >  4096) return 13;
+   if (cb >  2048) return 12;
+   if (cb >  1024) return 11;
+   if (cb >   512) return 10;
+   if (cb >   256) return  9;
+   return 8;
+}
+
+static int
+zlib_advance(struct zlib *zlib, png_uint_32 nbytes)
+   /* Read nbytes compressed bytes; the stream will be initialized if required.
+    * Bytes are always being reread and errors are fatal.  The return code is as
+    * follows:
+    *
+    *    -1: saw the "too far back" error
+    *     0: ok, keep going
+    *     1: saw Z_STREAM_END (zlib->extra_bytes indicates too much data)
+    *     2: a zlib error that cannot be corrected (error message already
+    *        output if required.)
+    */
+#  define ZLIB_TOO_FAR_BACK (-1)
+#  define ZLIB_OK           0
+#  define ZLIB_STREAM_END   1
+#  define ZLIB_FATAL        2
+{
+   int state = zlib->state;
+   int endrc = ZLIB_OK;
+   png_uint_32 in_bytes = 0;
+   struct file *file = zlib->file;
+
+   assert(state >= 0);
+
+   while (in_bytes < nbytes && endrc == ZLIB_OK)
+   {
+      png_uint_32 out_bytes;
+      int flush;
+      png_byte bIn = reread_byte(file);
+      png_byte bOut;
+
+      switch (state)
+      {
+         case 0: /* first header byte */
+            {
+               int file_bits = 8+(bIn >> 4);
+               int new_bits = zlib->window_bits;
+
+               zlib->file_bits = file_bits;
+
+               /* Check against the existing value - it may not need to be
+                * changed.  Note that a bogus file_bits is allowed through once,
+                * to see if it works, but the window_bits value is set to 15,
+                * the maximum.
+                */
+               if (new_bits == 0) /* no change */
+                  zlib->window_bits = ((file_bits > 15) ? 15 : file_bits);
+
+               else if (new_bits != file_bits) /* rewrite required */
+                  bIn = (png_byte)((bIn & 0xf) + ((new_bits-8) << 4));
+            }
+
+            zlib->header[0] = bIn;
+            zlib->state = state = 1;
+            break;
+
+         case 1: /* second header byte */
+            {
+               int b2 = bIn & 0xe0; /* top 3 bits */
+
+               /* The checksum calculation, on the first 11 bits: */
+               b2 += 0x1f - ((zlib->header[0] << 8) + b2) % 0x1f;
+
+               /* Update the checksum byte if required: */
+               if (bIn != b2)
+               {
+                  /* If the first byte wasn't changed this indicates an error in
+                   * the checksum calculation; signal this by setting 'cksum'.
+                   */
+                  if (zlib->file_bits == zlib->window_bits)
+                     zlib->cksum = 1;
+
+                  bIn = (png_byte)b2;
+               }
+            }
+
+            zlib->header[1] = bIn;
+            zlib->state = state = 2;
+            break;
+
+         default: /* After the header bytes */
+            break;
+      }
+
+      /* For some streams, perhaps only those compressed with 'superfast
+       * compression' (which results in a lot of copying) Z_BUF_ERROR can happen
+       * immediately after all output has been flushed on the next input byte.
+       * This is handled below when Z_BUF_ERROR is detected by adding an output
+       * byte.
+       */
+      zlib->z.next_in = &bIn;
+      zlib->z.avail_in = 1;
+      zlib->z.next_out = &bOut;
+      zlib->z.avail_out = 0;     /* Initially */
+
+      /* Initially use Z_NO_FLUSH in an attempt to persuade zlib to look at this
+       * byte without confusing what is going on with output.
+       */
+      flush = Z_NO_FLUSH;
+      out_bytes = 0;
+
+      /* NOTE: expression 3 is only evaluated on 'continue', because of the
+       * 'break' at the end of this loop below.
+       */
+      for (;endrc == ZLIB_OK;
+         flush = Z_SYNC_FLUSH,
+         zlib->z.next_out = &bOut,
+         zlib->z.avail_out = 1,
+         ++out_bytes)
+      {
+         zlib->rc = inflate(&zlib->z, flush);
+         out_bytes -= zlib->z.avail_out;
+
+         switch (zlib->rc)
+         {
+            case Z_BUF_ERROR:
+               if (zlib->z.avail_out == 0)
+                  continue; /* Try another output byte. */
+
+               if (zlib->z.avail_in == 0)
+                  break; /* Try another input byte */
+
+               /* Both avail_out and avail_in are 1 yet zlib returned a code
+                * indicating no progress was possible.  This is unexpected.
+                */
+               zlib_message(zlib, 1/*unexpected*/);
+               endrc = ZLIB_FATAL; /* stop processing */
+               break;
+
+            case Z_OK:
+               /* Zlib is supposed to have made progress: */
+               assert(zlib->z.avail_out == 0 || zlib->z.avail_in == 0);
+               continue;
+
+            case Z_STREAM_END:
+               /* This is the successful end. */
+               zlib->state = 3; /* end of stream */
+               endrc = ZLIB_STREAM_END;
+               break;
+
+            case Z_NEED_DICT:
+               zlib_message(zlib, 0/*stream error*/);
+               endrc = ZLIB_FATAL;
+               break;
+
+            case Z_DATA_ERROR:
+               /* The too far back error can be corrected, others cannot: */
+               if (zlib->z.msg != NULL &&
+                  strcmp(zlib->z.msg, "invalid distance too far back") == 0)
+               {
+                  endrc = ZLIB_TOO_FAR_BACK;
+                  break;
+               }
+               /* FALLTHROUGH */
+
+            default:
+               zlib_message(zlib, 0/*stream error*/);
+               endrc = ZLIB_FATAL;
+               break;
+         } /* switch (inflate rc) */
+
+         /* Control gets here when further output is not possible; endrc may
+          * still be ZLIB_OK if more input is required.
+          */
+         break;
+      } /* for (output bytes) */
+
+      /* Keep a running count of output byte produced: */
+      zlib->uncompressed_digits = uarb_add32(zlib->uncompressed_bytes,
+         zlib->uncompressed_digits, out_bytes);
+
+      /* Keep going, the loop will terminate when endrc is no longer set to
+       * ZLIB_OK or all the input bytes have been consumed; meanwhile keep
+       * adding input bytes.
+       */
+      assert(zlib->z.avail_in == 0 || endrc != ZLIB_OK);
+
+      in_bytes += 1 - zlib->z.avail_in;
+   } /* while (input bytes) */
+
+   assert(in_bytes == nbytes || endrc != ZLIB_OK);
+
+   /* Update the running total of input bytes consumed */
+   zlib->compressed_digits = uarb_add32(zlib->compressed_bytes,
+      zlib->compressed_digits, in_bytes - zlib->z.avail_in);
+
+   /* At the end of the stream update the chunk with the accumulated
+    * information if it is an improvement:
+    */
+   if (endrc == ZLIB_STREAM_END && zlib->window_bits < zlib->ok_bits)
+   {
+      struct chunk *chunk = zlib->chunk;
+
+      chunk->uncompressed_digits = uarb_copy(chunk->uncompressed_bytes,
+         zlib->uncompressed_bytes, zlib->uncompressed_digits);
+      chunk->compressed_digits = uarb_copy(chunk->compressed_bytes,
+         zlib->compressed_bytes, zlib->compressed_digits);
+      chunk->rewrite_buffer[0] = zlib->header[0];
+      chunk->rewrite_buffer[1] = zlib->header[1];
+
+      if (zlib->window_bits != zlib->file_bits || zlib->cksum)
+      {
+         /* A rewrite is required */
+         chunk->rewrite_offset = zlib->rewrite_offset;
+         chunk->rewrite_length = 2;
+      }
+
+      else
+      {
+         chunk->rewrite_offset = 0;
+         chunk->rewrite_length = 0;
+      }
+
+      if (in_bytes < nbytes)
+         chunk_message(chunk, "extra compressed data");
+
+      zlib->extra_bytes = nbytes - in_bytes;
+      zlib->ok_bits = zlib->window_bits;
+   }
+
+   return endrc;
+}
+
+static int
+zlib_run(struct zlib *zlib)
+   /* Like zlib_advance but also handles a stream of IDAT chunks. */
+{
+   /* The 'extra_bytes' field is set by zlib_advance if there is extra
+    * compressed data in the chunk it handles (if it sees Z_STREAM_END before
+    * all the input data has been used.)  This function uses the value to update
+    * the correct chunk length, so the problem should only ever be detected once
+    * for each chunk.  zlib_advance outputs the error message, though see the
+    * IDAT specific check below.
+    */
+   zlib->extra_bytes = 0;
+
+   if (zlib->idat != NULL)
+   {
+      struct IDAT_list *list = zlib->idat->idat_list_head;
+      struct IDAT_list *last = zlib->idat->idat_list_tail;
+      int        skip = 0;
+
+      /* 'rewrite_offset' is the offset of the LZ data within the chunk, for
+       * IDAT it should be 0:
+       */
+      assert(zlib->rewrite_offset == 0);
+
+      /* Process each IDAT_list in turn; the caller has left the stream
+       * positioned at the start of the first IDAT chunk data.
+       */
+      for (;;)
+      {
+         unsigned int count = list->count;
+         unsigned int i;
+
+         for (i = 0; i<count; ++i)
+         {
+            int rc;
+
+            if (skip > 0) /* Skip CRC and next IDAT header */
+               skip_12(zlib->file);
+
+            skip = 12; /* for the next time */
+
+            rc = zlib_advance(zlib, list->lengths[i]);
+
+            switch (rc)
+            {
+               case ZLIB_OK: /* keep going */
+                  break;
+
+               case ZLIB_STREAM_END: /* stop */
+                  /* There may be extra chunks; if there are and one of them is
+                   * not zero length output the 'extra data' message.  Only do
+                   * this check if errors are being output.
+                   */
+                  if (zlib->global->errors && zlib->extra_bytes == 0)
+                  {
+                     struct IDAT_list *check = list;
+                     int j = i+1, jcount = count;
+
+                     for (;;)
+                     {
+                        for (; j<jcount; ++j)
+                           if (check->lengths[j] > 0)
+                           {
+                              chunk_message(zlib->chunk,
+                                 "extra compressed data");
+                              goto end_check;
+                           }
+
+                        if (check == last)
+                           break;
+
+                        check = check->next;
+                        jcount = check->count;
+                        j = 0;
+                     }
+                  }
+
+               end_check:
+                  /* Terminate the list at the current position, reducing the
+                   * length of the last IDAT too if required.
+                   */
+                  list->lengths[i] -= zlib->extra_bytes;
+                  list->count = i+1;
+                  zlib->idat->idat_list_tail = list;
+                  /* FALLTHROUGH */
+
+               default:
+                  return rc;
+            }
+         }
+
+         /* At the end of the compressed data and Z_STREAM_END was not seen. */
+         if (list == last)
+            return ZLIB_OK;
+
+         list = list->next;
+      }
+   }
+
+   else
+   {
+      struct chunk *chunk = zlib->chunk;
+      int rc;
+
+      assert(zlib->rewrite_offset < chunk->chunk_length);
+
+      rc = zlib_advance(zlib, chunk->chunk_length - zlib->rewrite_offset);
+
+      /* The extra bytes in the chunk are handled now by adjusting the chunk
+       * length to exclude them; the zlib data is always stored at the end of
+       * the PNG chunk (although clearly this is not necessary.)  zlib_advance
+       * has already output a warning message.
+       */
+      chunk->chunk_length -= zlib->extra_bytes;
+      return rc;
+   }
+}
+
+static int /* global function; not a member function */
+zlib_check(struct file *file, png_uint_32 offset)
+   /* Check the stream of zlib compressed data in either idat (if given) or (if
+    * not) chunk.  In fact it is zlib_run that handles the difference in reading
+    * a single chunk and a list of IDAT chunks.
+    *
+    * In either case the input file must be positioned at the first byte of zlib
+    * compressed data (the first header byte).
+    *
+    * The return value is true on success, including the case where the zlib
+    * header may need to be rewritten, and false on an unrecoverable error.
+    *
+    * In the case of IDAT chunks 'offset' should be 0.
+    */
+{
+   fpos_t start_pos;
+   struct zlib zlib;
+
+   /* Record the start of the LZ data to allow a re-read. */
+   file_getpos(file, &start_pos);
+
+   /* First test the existing (file) window bits: */
+   if (zlib_init(&zlib, file->idat, file->chunk, 0/*window bits*/, offset))
+   {
+      int min_bits, max_bits, rc;
+
+      /* The first run using the existing window bits. */
+      rc = zlib_run(&zlib);
+
+      switch (rc)
+      {
+         case ZLIB_TOO_FAR_BACK:
+            /* too far back error */
+            file->status_code |= TOO_FAR_BACK;
+            min_bits = zlib.window_bits + 1;
+            max_bits = 15;
+            break;
+
+         case ZLIB_STREAM_END:
+            if (!zlib.global->optimize_zlib &&
+               zlib.window_bits == zlib.file_bits && !zlib.cksum)
+            {
+               /* The trivial case where the stream is ok and optimization was
+                * not requested.
+                */
+               zlib_end(&zlib);
+               return 1;
+            }
+
+            max_bits = max_window_bits(zlib.uncompressed_bytes,
+               zlib.uncompressed_digits);
+            if (zlib.ok_bits < max_bits)
+               max_bits = zlib.ok_bits;
+            min_bits = 8;
+
+            /* cksum is set if there is an error in the zlib header checksum
+             * calculation in the original file (and this may be the only reason
+             * a rewrite is required).  We can't rely on the file window bits in
+             * this case, so do the optimization anyway.
+             */
+            if (zlib.cksum)
+               chunk_message(zlib.chunk, "zlib checksum");
+            break;
+
+
+         case ZLIB_OK:
+            /* Truncated stream; unrecoverable, gets converted to ZLIB_FATAL */
+            zlib.z.msg = PNGZ_MSG_CAST("[truncated]");
+            zlib_message(&zlib, 0/*expected*/);
+            /* FALLTHROUGH */
+
+         default:
+            /* Unrecoverable error; skip the chunk; a zlib_message has already
+             * been output.
+             */
+            zlib_end(&zlib);
+            return 0;
+      }
+
+      /* Optimize window bits or fix a too-far-back error.  min_bits and
+       * max_bits have been set appropriately, ok_bits records the bit value
+       * known to work.
+       */
+      while (min_bits < max_bits || max_bits < zlib.ok_bits/*if 16*/)
+      {
+         int test_bits = (min_bits + max_bits) >> 1;
+
+         if (zlib_reset(&zlib, test_bits))
+         {
+            file_setpos(file, &start_pos);
+            rc = zlib_run(&zlib);
+
+            switch (rc)
+            {
+               case ZLIB_TOO_FAR_BACK:
+                  min_bits = test_bits+1;
+                  if (min_bits > max_bits)
+                  {
+                     /* This happens when the stream really is damaged and it
+                      * contains a distance code that addresses bytes before
+                      * the start of the uncompressed data.
+                      */
+                     assert(test_bits == 15);
+
+                     /* Output the error that wasn't output before: */
+                     if (zlib.z.msg == NULL)
+                        zlib.z.msg = PNGZ_MSG_CAST(
+                           "invalid distance too far back");
+                     zlib_message(&zlib, 0/*stream error*/);
+                     zlib_end(&zlib);
+                     return 0;
+                  }
+                  break;
+
+               case ZLIB_STREAM_END: /* success */
+                  max_bits = test_bits;
+                  break;
+
+               default:
+                  /* A fatal error; this happens if a too-far-back error was
+                   * hiding a more serious error, zlib_advance has already
+                   * output a zlib_message.
+                   */
+                  zlib_end(&zlib);
+                  return 0;
+            }
+         }
+
+         else /* inflateReset2 failed */
+         {
+            zlib_end(&zlib);
+            return 0;
+         }
+      }
+
+      /* The loop guarantees this */
+      assert(zlib.ok_bits == max_bits);
+      zlib_end(&zlib);
+      return 1;
+   }
+
+   else /* zlib initialization failed - skip the chunk */
+   {
+      zlib_end(&zlib);
+      return 0;
+   }
+}
+
+/***************************** LIBPNG CALLBACKS *******************************/
+/* The strategy here is to run a regular libpng PNG file read but examine the
+ * input data (from the file) before passing it to libpng so as to be aware of
+ * the state we expect libpng to be in.  Warning and error callbacks are also
+ * intercepted so that they can be quieted and interpreted.  Interpretation
+ * depends on a somewhat risky string match for known error messages; let us
+ * hope that this can be fixed in the next version of libpng.
+ *
+ * The control structure is pointed to by the libpng error pointer.  It contains
+ * that set of structures which must persist across multiple read callbacks,
+ * which is pretty much everything except the 'zlib' control structure.
+ *
+ * The file structure is instantiated in the caller of the per-file routine, but
+ * the per-file routine contains the chunk and IDAT control structures.
+ */
+/* The three routines read_chunk, process_chunk and sync_stream can only be
+ * called via a call to read_chunk and only exit at a return from process_chunk.
+ * These routines could have been written as one confusing large routine,
+ * instead this code relies on the compiler to do tail call elimination.  The
+ * possible calls are as follows:
+ *
+ * read_chunk
+ *    -> sync_stream
+ *       -> process_chunk
+ *    -> process_chunk
+ *       -> read_chunk
+ *       returns
+ */
+static void read_chunk(struct file *file);
+static void
+process_chunk(struct file *file, png_uint_32 file_crc, png_uint_32 next_length,
+   png_uint_32 next_type)
+   /* Called when the chunk data has been read, next_length and next_type
+    * will be set for the next chunk (or 0 if this is IEND).
+    *
+    * When this routine returns, chunk_length and chunk_type will be set for the
+    * next chunk to write because if a chunk is skipped this return calls back
+    * to read_chunk.
+    */
+{
+   png_uint_32 type = file->type;
+
+   if (file->global->verbose > 1)
+   {
+      fputs("  ", stderr);
+      type_name(file->type, stderr);
+      fprintf(stderr, " %lu 0x%.8x 0x%.8x\n", (unsigned long)file->length,
+         file->crc ^ 0xffffffff, file_crc);
+   }
+
+   /* The basic structure seems correct but the CRC may not match, in this
+    * case assume that it is simply a bad CRC, either wrongly calculated or
+    * because of damaged stream data.
+    */
+   if ((file->crc ^ 0xffffffff) != file_crc)
+   {
+      /* The behavior is set by the 'skip' setting; if it is anything other
+       * than SKIP_BAD_CRC ignore the bad CRC and return the chunk, with a
+       * corrected CRC and possibly processed, to libpng.  Otherwise skip the
+       * chunk, which will result in a fatal error if the chunk is critical.
+       */
+      file->status_code |= CRC_ERROR;
+
+      /* Ignore the bad CRC  */
+      if (file->global->skip != SKIP_BAD_CRC)
+         type_message(file, type, "bad CRC");
+
+      /* This will cause an IEND with a bad CRC to stop */
+      else if (CRITICAL(type))
+         stop(file, READ_ERROR_CODE, "bad CRC in critical chunk");
+
+      else
+      {
+         type_message(file, type, "skipped: bad CRC");
+
+         /* NOTE: this cannot be reached for IEND because it is critical. */
+         goto skip_chunk;
+      }
+   }
+
+   /* Check for other 'skip' cases and handle these; these only apply to
+    * ancillary chunks (and not tRNS, which should probably have been a critical
+    * chunk.)
+    */
+   if (skip_chunk_type(file->global, type))
+      goto skip_chunk;
+
+   /* The chunk may still be skipped if problems are detected in the LZ data,
+    * however the LZ data check requires a chunk.  Handle this by instantiating
+    * a chunk unless an IDAT is already instantiated (IDAT control structures
+    * instantiate their own chunk.)
+    */
+   if (type != png_IDAT)
+      file->alloc(file, 0/*chunk*/);
+
+   else if (file->idat == NULL)
+      file->alloc(file, 1/*IDAT*/);
+
+   else
+   {
+      /* The chunk length must be updated for process_IDAT */
+      assert(file->chunk != NULL);
+      assert(file->chunk->chunk_type == png_IDAT);
+      file->chunk->chunk_length = file->length;
+   }
+
+   /* Record the 'next' information too, now that the original values for
+    * this chunk have been copied.  Notice that the IDAT chunks only make a
+    * copy of the position of the first chunk, this is fine - process_IDAT does
+    * not need the position of this chunk.
+    */
+   file->length = next_length;
+   file->type = next_type;
+   getpos(file);
+
+   /* Do per-type processing, note that if this code does not return from the
+    * function the chunk will be skipped.  The rewrite is cancelled here so that
+    * it can be set in the per-chunk processing.
+    */
+   file->chunk->rewrite_length = 0;
+   file->chunk->rewrite_offset = 0;
+   switch (type)
+   {
+      default:
+         return;
+
+      case png_IHDR:
+         /* Read this now and update the control structure with the information
+          * it contains.  The header is validated completely to ensure this is a
+          * PNG.
+          */
+         {
+            struct chunk *chunk = file->chunk;
+
+            if (chunk->chunk_length != 13)
+               stop_invalid(file, "IHDR length");
+
+            /* Read all the IHDR information and validate it. */
+            setpos(chunk);
+            file->width = reread_4(file);
+            file->height = reread_4(file);
+            file->bit_depth = reread_byte(file);
+            file->color_type = reread_byte(file);
+            file->compression_method = reread_byte(file);
+            file->filter_method = reread_byte(file);
+            file->interlace_method = reread_byte(file);
+
+            /* This validates all the fields, and calls stop_invalid if
+             * there is a problem.
+             */
+            calc_image_size(file);
+         }
+         return;
+
+         /* Ancillary chunks that require further processing: */
+      case png_zTXt: case png_iCCP:
+         if (process_zTXt_iCCP(file))
+            return;
+         chunk_end(&file->chunk);
+         file_setpos(file, &file->data_pos);
+         break;
+
+      case png_iTXt:
+         if (process_iTXt(file))
+            return;
+         chunk_end(&file->chunk);
+         file_setpos(file, &file->data_pos);
+         break;
+
+      case png_IDAT:
+         if (process_IDAT(file))
+            return;
+         /* First pass: */
+         assert(next_type == png_IDAT);
+         break;
+   }
+
+   /* Control reaches this point if the chunk must be skipped.  For chunks other
+    * than IDAT this means that the zlib compressed data is fatally damanged and
+    * the chunk will not be passed to libpng.  For IDAT it means that the end of
+    * the IDAT stream has not yet been reached and we must handle the next
+    * (IDAT) chunk.  If the LZ data in an IDAT stream cannot be read 'stop' must
+    * be used to halt parsing of the PNG.
+    */
+   read_chunk(file);
+   return;
+
+   /* This is the generic code to skip the current chunk; simply jump to the
+    * next one.
+    */
+skip_chunk:
+   file->length = next_length;
+   file->type = next_type;
+   getpos(file);
+   read_chunk(file);
+}
+
+static png_uint_32
+get32(png_bytep buffer, int offset)
+   /* Read a 32-bit value from an 8-byte circular buffer (used only below).
+    */
+{
+   return
+      (buffer[ offset    & 7] << 24) +
+      (buffer[(offset+1) & 7] << 16) +
+      (buffer[(offset+2) & 7] <<  8) +
+      (buffer[(offset+3) & 7]      );
+}
+
+static void
+sync_stream(struct file *file)
+   /* The stream seems to be messed up, attempt to resync from the current chunk
+    * header.  Executes stop on a fatal error, otherwise calls process_chunk.
+    */
+{
+   png_uint_32 file_crc;
+
+   file->status_code |= STREAM_ERROR;
+
+   if (file->global->verbose)
+   {
+      fputs(" SYNC ", stderr);
+      type_name(file->type, stderr);
+      putc('\n', stderr);
+   }
+
+   /* Return to the start of the chunk data */
+   file_setpos(file, &file->data_pos);
+   file->read_count = 8;
+
+   if (read_4(file, &file_crc) == 4) /* else completely truncated */
+   {
+      /* Ignore the recorded chunk length, proceed through the data looking for
+       * a leading sequence of bytes that match the CRC in the following four
+       * bytes.  Each time a match is found check the next 8 bytes for a valid
+       * length, chunk-type pair.
+       */
+      png_uint_32 length;
+      png_uint_32 type = file->type;
+      png_uint_32 crc = crc_init_4(type);
+      png_byte buffer[8];
+      unsigned int nread = 0, nused = 0;
+
+      for (length=0; length <= 0x7fffffff; ++length)
+      {
+         int ch;
+
+         if ((crc ^ 0xffffffff) == file_crc)
+         {
+            /* A match on the CRC; for IEND this is sufficient, but for anything
+             * else expect a following chunk header.
+             */
+            if (type == png_IEND)
+            {
+               file->length = length;
+               process_chunk(file, file_crc, 0, 0);
+               return;
+            }
+
+            else
+            {
+               /* Need 8 bytes */
+               while (nread < 8+nused)
+               {
+                  ch = read_byte(file);
+                  if (ch == EOF)
+                     goto truncated;
+                  buffer[(nread++) & 7] = (png_byte)ch;
+               }
+
+               /* Prevent overflow */
+               nread -= nused & ~7;
+               nused -= nused & ~7; /* or, nused &= 7 ;-) */
+
+               /* Examine the 8 bytes for a valid chunk header. */
+               {
+                  png_uint_32 next_length = get32(buffer, nused);
+
+                  if (next_length < 0x7fffffff)
+                  {
+                     png_uint_32 next_type = get32(buffer, nused+4);
+
+                     if (chunk_type_valid(next_type))
+                     {
+                        file->read_count -= 8;
+                        process_chunk(file, file_crc, next_length, next_type);
+                        return;
+                     }
+                  }
+
+                  /* Not valid, keep going. */
+               }
+            }
+         }
+
+         /* This catches up with the circular buffer which gets filled above
+          * while checking a chunk header.  This code is slightly tricky - if
+          * the chunk_type is IEND the buffer will never be used, if it is not
+          * the code will always read ahead exactly 8 bytes and pass this on to
+          * process_chunk.  So the invariant that IEND leaves the file position
+          * after the IEND CRC and other chunk leave it after the *next* chunk
+          * header is not broken.
+          */
+         if (nread <= nused)
+         {
+            ch = read_byte(file);
+
+            if (ch == EOF)
+               goto truncated;
+         }
+
+         else
+            ch = buffer[(++nused) & 7];
+
+         crc = crc_one_byte(crc, file_crc >> 24);
+         file_crc = (file_crc << 8) + ch;
+      }
+
+      /* Control gets to here if when 0x7fffffff bytes (plus 8) have been read,
+       * ok, treat this as a damaged stream too:
+       */
+   }
+
+truncated:
+   stop(file, READ_ERROR_CODE, "damaged PNG stream");
+}
+
+static void
+read_chunk(struct file *file)
+   /* On entry file::data_pos must be set to the position of the first byte
+    * of the chunk data *and* the input file must be at this position.  This
+    * routine (via process_chunk) instantiates a chunk or IDAT control structure
+    * based on file::length and file::type and also resets these fields and
+    * file::data_pos for the chunk after this one.  For an IDAT chunk the whole
+    * stream of IDATs will be read, until something other than an IDAT is
+    * encountered, and the file fields will be set for the chunk after the end
+    * of the stream of IDATs.
+    *
+    * For IEND the file::type field will be set to 0, and nothing beyond the end
+    * of the IEND chunk will have been read.
+    */
+{
+   png_uint_32 length = file->length;
+   png_uint_32 type = file->type;
+
+   /* After IEND file::type is set to 0, if libpng attempts to read
+    * more data at this point this is a bug in libpng.
+    */
+   if (type == 0)
+      stop(file, UNEXPECTED_ERROR_CODE, "read beyond IEND");
+
+   if (file->global->verbose > 2)
+   {
+      fputs("   ", stderr);
+      type_name(type, stderr);
+      fprintf(stderr, " %lu\n", (unsigned long)length);
+   }
+
+   /* Start the read_crc calculation with the chunk type, then read to the end
+    * of the chunk data (without processing it in any way) to check that it is
+    * all there and calculate the CRC.
+    */
+   file->crc = crc_init_4(type);
+   if (crc_read_many(file, length)) /* else it was truncated */
+   {
+      png_uint_32 file_crc; /* CRC read from file */
+      unsigned int nread = read_4(file, &file_crc);
+
+      if (nread == 4)
+      {
+         if (type != png_IEND) /* do not read beyond IEND */
+         {
+            png_uint_32 next_length;
+
+            nread += read_4(file, &next_length);
+            if (nread == 8 && next_length <= 0x7fffffff)
+            {
+               png_uint_32 next_type;
+
+               nread += read_4(file, &next_type);
+
+               if (nread == 12 && chunk_type_valid(next_type))
+               {
+                  /* Adjust the read count back to the correct value for this
+                   * chunk.
+                   */
+                  file->read_count -= 8;
+                  process_chunk(file, file_crc, next_length, next_type);
+                  return;
+               }
+            }
+         }
+
+         else /* IEND */
+         {
+            process_chunk(file, file_crc, 0, 0);
+            return;
+         }
+      }
+   }
+
+   /* Control gets to here if the stream seems invalid or damaged in some
+    * way.  Either there was a problem reading all the expected data (this
+    * chunk's data, its CRC and the length and type of the next chunk) or the
+    * next chunk length/type are invalid.  Notice that the cases that end up
+    * here all correspond to cases that would otherwise terminate the read of
+    * the PNG file.
+    */
+   sync_stream(file);
+}
+
+/* This returns a file* from a png_struct in an implementation specific way. */
+static struct file *get_control(png_const_structrp png_ptr);
+
+static void PNGCBAPI
+error_handler(png_structp png_ptr, png_const_charp message)
+{
+   stop(get_control(png_ptr),  LIBPNG_ERROR_CODE, message);
+}
+
+static void PNGCBAPI
+warning_handler(png_structp png_ptr, png_const_charp message)
+{
+   struct file *file = get_control(png_ptr);
+
+   if (file->global->warnings)
+      emit_error(file, LIBPNG_WARNING_CODE, message);
+}
+
+/* Read callback - this is where the work gets done to check the stream before
+ * passing it to libpng
+ */
+static void PNGCBAPI
+read_callback(png_structp png_ptr, png_bytep buffer, size_t count)
+   /* Return 'count' bytes to libpng in 'buffer' */
+{
+   struct file *file = get_control(png_ptr);
+   png_uint_32 type, length; /* For the chunk be *WRITTEN* */
+   struct chunk *chunk;
+
+   /* libpng should always ask for at least one byte */
+   if (count == 0)
+      stop(file, UNEXPECTED_ERROR_CODE, "read callback for 0 bytes");
+
+   /* The callback always reads ahead by 8 bytes - the signature or chunk header
+    * - these bytes are stored in chunk_length and chunk_type.  This block is
+    * executed once for the signature and once for the first chunk right at the
+    * start.
+    */
+   if (file->read_count < 8)
+   {
+      assert(file->read_count == 0);
+      assert((file->status_code & TRUNCATED) == 0);
+
+      (void)read_4(file, &file->length);
+
+      if (file->read_count == 4)
+         (void)read_4(file, &file->type);
+
+      if (file->read_count < 8)
+      {
+         assert((file->status_code & TRUNCATED) != 0);
+         stop(file, READ_ERROR_CODE, "not a PNG (too short)");
+      }
+
+      if (file->state == STATE_SIGNATURE)
+      {
+         if (file->length != sig1 || file->type != sig2)
+            stop(file, LIBPNG_ERROR_CODE, "not a PNG (signature)");
+
+         /* Else write it (this is the initialization of write_count, prior to
+          * this it contains CLEAR garbage.)
+          */
+         file->write_count = 0;
+      }
+
+      else
+      {
+         assert(file->state == STATE_CHUNKS);
+
+         /* The first chunk must be a well formed IHDR (this could be relaxed to
+          * use the checks in process_chunk, but that seems unnecessary.)
+          */
+         if (file->length != 13 || file->type != png_IHDR)
+            stop(file, LIBPNG_ERROR_CODE, "not a PNG (IHDR)");
+
+         /* The position of the data must be stored too */
+         getpos(file);
+      }
+   }
+
+   /* Retrieve previous state (because the read callbacks are made pretty much
+    * byte-by-byte in the sequential reader prior to 1.7).
+    */
+   chunk = file->chunk;
+
+   if (chunk != NULL)
+   {
+      length = chunk->chunk_length;
+      type = chunk->chunk_type;
+   }
+
+   else
+   {
+      /* This is the signature case; for IDAT and other chunks these values will
+       * be overwritten when read_chunk is called below.
+       */
+      length = file->length;
+      type = file->type;
+   }
+
+   do
+   {
+      png_uint_32 b;
+
+      /* Complete the read of a chunk; as a side effect this also instantiates
+       * a chunk control structure and sets the file length/type/data_pos fields
+       * for the *NEXT* chunk header.
+       *
+       * NOTE: at an IDAT any following IDAT chunks will also be read and the
+       * next_ fields will refer to the chunk after the last IDAT.
+       *
+       * NOTE: read_chunk only returns when it has read a chunk that must now be
+       * written.
+       */
+      if (file->state != STATE_SIGNATURE && chunk == NULL)
+      {
+         assert(file->read_count == 8);
+         assert(file->idat == NULL);
+         read_chunk(file);
+         chunk = file->chunk;
+         assert(chunk != NULL);
+
+         /* Do the initialization that was not done before. */
+         length = chunk->chunk_length;
+         type = chunk->chunk_type;
+
+         /* And start writing the new chunk. */
+         file->write_count = 0;
+      }
+
+      /* The chunk_ fields describe a chunk that must be written, or hold the
+       * signature.  Write the header first.  In the signature case this
+       * rewrites the signature.
+       */
+      switch (file->write_count)
+      {
+         case 0: b = length >> 24; break;
+         case 1: b = length >> 16; break;
+         case 2: b = length >>  8; break;
+         case 3: b = length      ; break;
+
+         case 4: b = type >> 24; break;
+         case 5: b = type >> 16; break;
+         case 6: b = type >>  8; break;
+         case 7: b = type      ; break;
+
+         case 8:
+            /* The header has been written.  If this is really the signature
+             * that's all that is required and we can go to normal chunk
+             * processing.
+             */
+            if (file->state == STATE_SIGNATURE)
+            {
+               /* The signature has been written, the tail call to read_callback
+                * below (it's just a goto to the start with a decent compiler)
+                * will read the IHDR header ahead and validate it.
+                */
+               assert(length == sig1 && type == sig2);
+               file->read_count = 0; /* Forces a header read */
+               file->state = STATE_CHUNKS; /* IHDR: checked above */
+               read_callback(png_ptr, buffer, count);
+               return;
+            }
+
+            else
+            {
+               assert(chunk != NULL);
+
+               /* Set up for write, notice that repositioning the input stream
+                * is only necessary if something is to be read from it.  Also
+                * notice that for the IDAT stream this must only happen once -
+                * on the first IDAT - to get back to the start of the list and
+                * this is done inside process_IDAT:
+                */
+               chunk->write_crc = crc_init_4(type);
+               if (file->state != STATE_IDAT && length > 0)
+                  setpos(chunk);
+            }
+            /* FALLTHROUGH */
+
+         default:
+            assert(chunk != NULL);
+
+            /* NOTE: the arithmetic below overflows and gives a large positive
+             * png_uint_32 value until the whole chunk data has been written.
+             */
+            switch (file->write_count - length)
+            {
+               /* Write the chunk data, normally this just comes from
+                * the file.  The only exception is for that part of a
+                * chunk which is zlib data and which must be rewritten,
+                * and IDAT chunks which can be completely
+                * reconstructed.
+                */
+               default:
+                  if (file->state == STATE_IDAT)
+                  {
+                     struct IDAT *idat = file->idat;
+
+                     assert(idat != NULL);
+
+                     /* Read an IDAT byte from the input stream of IDAT chunks.
+                      * Because the IDAT stream can be re-chunked this stream is
+                      * held in the struct IDAT members.  The chunk members, in
+                      * particular chunk_length (and therefore the length local)
+                      * refer to the output chunk.
+                      */
+                     while (idat->idat_index >= idat->idat_length)
+                     {
+                        /* Advance one chunk */
+                        struct IDAT_list *cur = idat->idat_cur;
+
+                        assert(idat->idat_index == idat->idat_length);
+                        assert(cur != NULL && cur->count > 0);
+
+                        /* NOTE: IDAT_list::count here, not IDAT_list::length */
+                        if (++(idat->idat_count) >= cur->count)
+                        {
+                           assert(idat->idat_count == cur->count);
+
+                           /* Move on to the next IDAT_list: */
+                           cur = cur->next;
+
+                           /* This is an internal error - read beyond the end of
+                            * the pre-calculated stream.
+                            */
+                           if (cur == NULL || cur->count == 0)
+                              stop(file, UNEXPECTED_ERROR_CODE,
+                                 "read beyond end of IDAT");
+
+                           idat->idat_count = 0;
+                           idat->idat_cur = cur;
+                        }
+
+                        idat->idat_index = 0;
+                        /* Zero length IDAT chunks are permitted, so the length
+                         * here may be 0.
+                         */
+                        idat->idat_length = cur->lengths[idat->idat_count];
+
+                        /* And skip 12 bytes to the next chunk data */
+                        skip_12(file);
+                     }
+
+                     /* The index is always that of the next byte, the rest of
+                      * the information is always the current IDAT chunk and the
+                      * current list.
+                      */
+                     ++(idat->idat_index);
+                  }
+
+                  /* Read the byte from the stream. */
+                  b = reread_byte(file);
+
+                  /* If the byte must be rewritten handle that here */
+                  if (chunk->rewrite_length > 0)
+                  {
+                     if (chunk->rewrite_offset > 0)
+                        --(chunk->rewrite_offset);
+
+                     else
+                     {
+                        b = chunk->rewrite_buffer[0];
+                        memmove(chunk->rewrite_buffer, chunk->rewrite_buffer+1,
+                           (sizeof chunk->rewrite_buffer)-
+                              (sizeof chunk->rewrite_buffer[0]));
+
+                        --(chunk->rewrite_length);
+                     }
+                  }
+
+                  chunk->write_crc = crc_one_byte(chunk->write_crc, b);
+                  break;
+
+               /* The CRC is written at:
+                *
+                *    chunk_write == chunk_length+8..chunk_length+11
+                *
+                * so 8 to 11.  The CRC is not (yet) conditioned.
+                */
+               case  8: b = chunk->write_crc >> 24; goto write_crc;
+               case  9: b = chunk->write_crc >> 16; goto write_crc;
+               case 10: b = chunk->write_crc >>  8; goto write_crc;
+               case 11:
+                  /* This must happen before the chunk_end below: */
+                  b = chunk->write_crc;
+
+                  if (file->global->verbose > 2)
+                  {
+                     fputs("   ", stderr);
+                     type_name(type, stderr);
+                     fprintf(stderr, " %lu 0x%.8x\n", (unsigned long)length,
+                        chunk->write_crc ^ 0xffffffff);
+                  }
+
+                  /* The IDAT stream is written without a call to read_chunk
+                   * until the end is reached.  rechunk_length() calculates the
+                   * length of the output chunks.  Control gets to this point at
+                   * the end of an *output* chunk - the length calculated by
+                   * rechunk_length.  If this corresponds to the end of the
+                   * input stream stop writing IDAT chunks, otherwise continue.
+                   */
+                  if (file->state == STATE_IDAT &&
+                     (file->idat->idat_index < file->idat->idat_length ||
+                      1+file->idat->idat_count < file->idat->idat_cur->count ||
+                      file->idat->idat_cur != file->idat->idat_list_tail))
+                  {
+                     /* Write another IDAT chunk.  Call rechunk_length to
+                      * calculate the length required.
+                      */
+                     length = chunk->chunk_length =
+                         rechunk_length(file->idat, 0/*end*/);
+                     assert(type == png_IDAT);
+                     file->write_count = 0; /* for the new chunk */
+                     --(file->write_count); /* fake out the increment below */
+                  }
+
+                  else
+                  {
+                     /* Entered at the end of a non-IDAT chunk and at the end of
+                      * the IDAT stream.  The rewrite should have been cleared.
+                      */
+                     if (chunk->rewrite_length > 0 || chunk->rewrite_offset > 0)
+                        stop(file, UNEXPECTED_ERROR_CODE, "pending rewrite");
+
+                     /* This is the last byte so reset chunk_read for the next
+                      * chunk and move the input file to the position after the
+                      * *next* chunk header if required.
+                      */
+                     file->read_count = 8;
+                     file_setpos(file, &file->data_pos);
+
+                     if (file->idat == NULL)
+                        chunk_end(&file->chunk);
+
+                     else
+                        IDAT_end(&file->idat);
+                  }
+
+               write_crc:
+                  b ^= 0xff; /* conditioning */
+                  break;
+            }
+            break;
+      }
+
+      /* Write one byte */
+      b &= 0xff;
+      *buffer++ = (png_byte)b;
+      --count;
+      write_byte(file, (png_byte)b); /* increments chunk_write */
+   }
+   while (count > 0);
+}
+
+/* Bundle the file and an uninitialized chunk and IDAT control structure
+ * together to allow implementation of the chunk/IDAT allocate routine.
+ */
+struct control
+{
+   struct file  file;
+   struct chunk chunk;
+   struct IDAT  idat;
+};
+
+static int
+control_end(struct control *control)
+{
+   return file_end(&control->file);
+}
+
+static struct file *
+get_control(png_const_structrp png_ptr)
+{
+   /* This just returns the (file*).  The chunk and idat control structures
+    * don't always exist.
+    */
+   struct control *control = voidcast(struct control*,
+      png_get_error_ptr(png_ptr));
+   return &control->file;
+}
+
+static void
+allocate(struct file *file, int allocate_idat)
+{
+   struct control *control = voidcast(struct control*, file->alloc_ptr);
+
+   if (allocate_idat)
+   {
+      assert(file->idat == NULL);
+      IDAT_init(&control->idat, file);
+   }
+
+   else /* chunk */
+   {
+      assert(file->chunk == NULL);
+      chunk_init(&control->chunk, file);
+   }
+}
+
+static int
+control_init(struct control *control, struct global *global,
+   const char *file_name, const char *out_name)
+   /* This wraps file_init(&control::file) and simply returns the result from
+    * file_init.
+    */
+{
+   return file_init(&control->file, global, file_name, out_name, control,
+      allocate);
+}
+
+static int
+read_png(struct control *control)
+   /* Read a PNG, return 0 on success else an error (status) code; a bit mask as
+    * defined for file::status_code as above.
+    */
+{
+   png_structp png_ptr;
+   png_infop info_ptr = NULL;
+   volatile int rc;
+
+   png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, control,
+      error_handler, warning_handler);
+
+   if (png_ptr == NULL)
+   {
+      /* This is not really expected. */
+      log_error(&control->file, LIBPNG_ERROR_CODE, "OOM allocating png_struct");
+      control->file.status_code |= INTERNAL_ERROR;
+      return LIBPNG_ERROR_CODE;
+   }
+
+   rc = setjmp(control->file.jmpbuf);
+   if (rc == 0)
+   {
+#     ifdef PNG_SET_USER_LIMITS_SUPPORTED
+         /* Remove any limits on the size of PNG files that can be read,
+          * without this we may reject files based on built-in safety
+          * limits.
+          */
+         png_set_user_limits(png_ptr, 0x7fffffff, 0x7fffffff);
+         png_set_chunk_cache_max(png_ptr, 0);
+         png_set_chunk_malloc_max(png_ptr, 0);
+#     endif
+
+      png_set_read_fn(png_ptr, control, read_callback);
+
+      info_ptr = png_create_info_struct(png_ptr);
+      if (info_ptr == NULL)
+         png_error(png_ptr, "OOM allocating info structure");
+
+      if (control->file.global->verbose)
+         fprintf(stderr, " INFO\n");
+
+      png_read_info(png_ptr, info_ptr);
+
+      {
+        png_uint_32 height = png_get_image_height(png_ptr, info_ptr);
+        int passes = png_set_interlace_handling(png_ptr);
+        int pass;
+
+        png_start_read_image(png_ptr);
+
+        for (pass = 0; pass < passes; ++pass)
+        {
+           png_uint_32 y = height;
+
+           /* NOTE: this skips asking libpng to return either version of
+            * the image row, but libpng still reads the rows.
+            */
+           while (y-- > 0)
+              png_read_row(png_ptr, NULL, NULL);
+        }
+      }
+
+      if (control->file.global->verbose)
+         fprintf(stderr, " END\n");
+
+      /* Make sure to read to the end of the file: */
+      png_read_end(png_ptr, info_ptr);
+   }
+
+   png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+   return rc;
+}
+
+static int
+one_file(struct global *global, const char *file_name, const char *out_name)
+{
+   int rc;
+   struct control control;
+
+   if (global->verbose)
+      fprintf(stderr, "FILE %s -> %s\n", file_name,
+         out_name ? out_name : "<none>");
+
+   /* Although control_init can return a failure code the structure is always
+    * initialized, so control_end can be used to accumulate any status codes.
+    */
+   rc = control_init(&control, global, file_name, out_name);
+
+   if (rc == 0)
+      rc = read_png(&control);
+
+   rc |= control_end(&control);
+
+   return rc;
+}
+
+static void
+usage(const char *prog)
+{
+   /* ANSI C-90 limits strings to 509 characters, so use a string array: */
+   size_t i;
+   static const char *usage_string[] = {
+"  Tests, optimizes and optionally fixes the zlib header in PNG files.",
+"  Optionally, when fixing, strips ancillary chunks from the file.",
+0,
+"OPTIONS",
+"  OPERATION",
+"      By default files are just checked for readability with a summary of the",
+"      of zlib issues founds for each compressed chunk and the IDAT stream in",
+"      the file.",
+"    --optimize (-o):",
+"      Find the smallest deflate window size for the compressed data.",
+"    --strip=[none|crc|unsafe|unused|transform|color|all]:",
+"        none (default):   Retain all chunks.",
+"        crc:    Remove chunks with a bad CRC.",
+"        unsafe: Remove chunks that may be unsafe to retain if the image data",
+"                is modified.  This is set automatically if --max is given but",
+"                may be cancelled by a later --strip=none.",
+"        unused: Remove chunks not used by libpng when decoding an image.",
+"                This retains any chunks that might be used by libpng image",
+"                transformations.",
+"        transform: unused+bKGD.",
+"        color:  transform+iCCP and cHRM.",
+"        all:    color+gAMA and sRGB.",
+"      Only ancillary chunks are ever removed.  In addition the tRNS and sBIT",
+"      chunks are never removed as they affect exact interpretation of the",
+"      image pixel values.  The following known chunks are treated specially",
+"      by the above options:",
+"        gAMA, sRGB [all]: These specify the gamma encoding used for the pixel",
+"            values.",
+"        cHRM, iCCP [color]: These specify how colors are encoded.  iCCP also",
+"            specifies the exact encoding of a pixel value; however, in",
+"            practice most programs will ignore it.",
+"        bKGD [transform]: This is used by libpng transforms."
+"    --max=<number>:",
+"      Use IDAT chunks sized <number>.  If no number is given the IDAT",
+"      chunks will be the maximum size permitted; 2^31-1 bytes.  If the option",
+"      is omitted the original chunk sizes will not be changed.  When the",
+"      option is given --strip=unsafe is set automatically. This may be",
+"      cancelled if you know that all unknown unsafe-to-copy chunks really are",
+"      safe to copy across an IDAT size change.  This is true of all chunks",
+"      that have ever been formally proposed as PNG extensions.",
+"  MESSAGES",
+"      By default the program only outputs summaries for each file.",
+"    --quiet (-q):",
+"      Do not output the summaries except for files that cannot be read. With",
+"      two --quiets these are not output either.",
+"    --errors (-e):",
+"      Output errors from libpng and the program (except too-far-back).",
+"    --warnings (-w):",
+"      Output warnings from libpng.",
+"  OUTPUT",
+"      By default nothing is written.",
+"    --out=<file>:",
+"      Write the optimized/corrected version of the next PNG to <file>.  This",
+"      overrides the following two options",
+"    --suffix=<suffix>:",
+"      Set --out=<name><suffix> for all following files unless overridden on",
+"      a per-file basis by explicit --out.",
+"    --prefix=<prefix>:",
+"      Set --out=<prefix><name> for all the following files unless overridden",
+"      on a per-file basis by explicit --out.",
+"      These two options can be used together to produce a suffix and prefix.",
+"  INTERNAL OPTIONS",
+#if 0 /*NYI*/
+#ifdef PNG_MAXIMUM_INFLATE_WINDOW
+"    --test:",
+"      Test the PNG_MAXIMUM_INFLATE_WINDOW option.  Setting this disables",
+"      output as this would produce a broken file.",
+#endif
+#endif
+0,
+"EXIT CODES",
+"  *** SUBJECT TO CHANGE ***",
+"  The program exit code is value in the range 0..127 holding a bit mask of",
+"  the following codes.  Notice that the results for each file are combined",
+"  together - check one file at a time to get a meaningful error code!",
+"    0x01: The zlib too-far-back error existed in at least one chunk.",
+"    0x02: At least one chunk had a CRC error.",
+"    0x04: A chunk length was incorrect.",
+"    0x08: The file was truncated.",
+"  Errors less than 16 are potentially recoverable, for a single file if the",
+"  exit code is less than 16 the file could be read (with corrections if a",
+"  non-zero code is returned).",
+"    0x10: The file could not be read, even with corrections.",
+"    0x20: The output file could not be written.",
+"    0x40: An unexpected, potentially internal, error occurred.",
+"  If the command line arguments are incorrect the program exits with exit",
+"  255.  Some older operating systems only support 7-bit exit codes, on those",
+"  systems it is suggested that this program is first tested by supplying",
+"  invalid arguments.",
+0,
+"DESCRIPTION",
+"  " PROGRAM_NAME ":",
+"  checks each PNG file on the command line for errors.  By default errors are",
+"  not output and the program just returns an exit code and prints a summary.",
+"  With the --quiet (-q) option the summaries are suppressed too and the",
+"  program only outputs unexpected errors (internal errors and file open",
+"  errors).",
+"  Various known problems in PNG files are fixed while the file is being read",
+"  The exit code says what problems were fixed.  In particular the zlib error:",
+0,
+"        \"invalid distance too far back\"",
+0,
+"  caused by an incorrect optimization of a zlib stream is fixed in any",
+"  compressed chunk in which it is encountered.  An integrity problem of the",
+"  PNG stream caused by a bug in libpng which wrote an incorrect chunk length",
+"  is also fixed.  Chunk CRC errors are automatically fixed up.",
+0,
+"  Setting one of the \"OUTPUT\" options causes the possibly modified file to",
+"  be written to a new file.",
+0,
+"  Notice that some PNG files with the zlib optimization problem can still be",
+"  read by libpng under some circumstances.  This program will still detect",
+"  and, if requested, correct the error.",
+0,
+"  The program will reliably process all files on the command line unless",
+"  either an invalid argument causes the usage message (this message) to be",
+"  produced or the program crashes.",
+0,
+"  The summary lines describe issues encountered with the zlib compressed",
+"  stream of a chunk.  They have the following format, which is SUBJECT TO",
+"  CHANGE in the future:",
+0,
+"     chunk reason comp-level p1 p2 p3 p4 file",
+0,
+"  p1 through p4 vary according to the 'reason'.  There are always 8 space",
+"  separated fields.  Reasons specific formats are:",
+0,
+"     chunk ERR status code read-errno write-errno message file",
+"     chunk SKP comp-level file-bits zlib-rc compressed message file",
+"     chunk ??? comp-level file-bits ok-bits compressed uncompress file",
+0,
+"  The various fields are",
+0,
+"$1 chunk:      The chunk type of a chunk in the file or 'HEAD' if a problem",
+"               is reported by libpng at the start of the IDAT stream.",
+"$2 reason:     One of:",
+"          CHK: A zlib header checksum was detected and fixed.",
+"          TFB: The zlib too far back error was detected and fixed.",
+"          OK : No errors were detected in the zlib stream and optimization",
+"               was not requested, or was not possible.",
+"          OPT: The zlib stream window bits value could be improved (and was).",
+"          SKP: The chunk was skipped because of a zlib issue (zlib-rc) with",
+"               explanation 'message'",
+"          ERR: The read of the file was aborted.  The parameters explain why.",
+"$3 status:     For 'ERR' the accumulated status code from 'EXIT CODES' above.",
+"               This is printed as a 2 digit hexadecimal value",
+"   comp-level: The recorded compression level (FLEVEL) of a zlib stream",
+"               expressed as a string {supfast,stdfast,default,maximum}",
+"$4 code:       The file exit code; where stop was called, as a fairly terse",
+"               string {warning,libpng,zlib,invalid,read,write,unexpected}.",
+"   file-bits:  The zlib window bits recorded in the file.",
+"$5 read-errno: A system errno value from a read translated by strerror(3).",
+"   zlib-rc:    A zlib return code as a string (see zlib.h).",
+"   ok-bits:    The smallest zlib window bits value that works.",
+"$6 write-errno:A system errno value from a write translated by strerror(3).",
+"   compressed: The count of compressed bytes in the zlib stream, when the",
+"               reason is 'SKP'; this is a count of the bytes read from the",
+"               stream when the fatal error was encountered.",
+"$7 message:    An error message (spaces replaced by _, as in all parameters),",
+"   uncompress: The count of bytes from uncompressing the zlib stream; this",
+"               may not be the same as the number of bytes in the image.",
+"$8 file:       The name of the file (this may contain spaces).",
+};
+
+   fprintf(stderr, "Usage: %s {[options] png-file}\n", prog);
+
+   for (i=0; i < (sizeof usage_string)/(sizeof usage_string[0]); ++i)
+   {
+      if (usage_string[i] != 0)
+         fputs(usage_string[i], stderr);
+
+      fputc('\n', stderr);
+   }
+
+   exit(255);
+}
+
+int
+main(int argc, const char **argv)
+{
+   char temp_name[FILENAME_MAX+1];
+   const char *  prog = *argv;
+   const char *  outfile = NULL;
+   const char *  suffix = NULL;
+   const char *  prefix = NULL;
+   int           done = 0; /* if at least one file is processed */
+   struct global global;
+
+   global_init(&global);
+
+   while (--argc > 0)
+   {
+      ++argv;
+
+      if (strcmp(*argv, "--debug") == 0)
+      {
+         /* To help debugging problems: */
+         global.errors = global.warnings = 1;
+         global.quiet = 0;
+         global.verbose = 7;
+      }
+
+      else if (strncmp(*argv, "--max=", 6) == 0)
+      {
+         global.idat_max = (png_uint_32)atol(6+*argv);
+
+         if (global.skip < SKIP_UNSAFE)
+            global.skip = SKIP_UNSAFE;
+      }
+
+      else if (strcmp(*argv, "--max") == 0)
+      {
+         global.idat_max = 0x7fffffff;
+
+         if (global.skip < SKIP_UNSAFE)
+            global.skip = SKIP_UNSAFE;
+      }
+
+      else if (strcmp(*argv, "--optimize") == 0 || strcmp(*argv, "-o") == 0)
+         global.optimize_zlib = 1;
+
+      else if (strncmp(*argv, "--out=", 6) == 0)
+         outfile = 6+*argv;
+
+      else if (strncmp(*argv, "--suffix=", 9) == 0)
+         suffix = 9+*argv;
+
+      else if (strncmp(*argv, "--prefix=", 9) == 0)
+         prefix = 9+*argv;
+
+      else if (strcmp(*argv, "--strip=none") == 0)
+         global.skip = SKIP_NONE;
+
+      else if (strcmp(*argv, "--strip=crc") == 0)
+         global.skip = SKIP_BAD_CRC;
+
+      else if (strcmp(*argv, "--strip=unsafe") == 0)
+         global.skip = SKIP_UNSAFE;
+
+      else if (strcmp(*argv, "--strip=unused") == 0)
+         global.skip = SKIP_UNUSED;
+
+      else if (strcmp(*argv, "--strip=transform") == 0)
+         global.skip = SKIP_TRANSFORM;
+
+      else if (strcmp(*argv, "--strip=color") == 0)
+         global.skip = SKIP_COLOR;
+
+      else if (strcmp(*argv, "--strip=all") == 0)
+         global.skip = SKIP_ALL;
+
+      else if (strcmp(*argv, "--errors") == 0 || strcmp(*argv, "-e") == 0)
+         global.errors = 1;
+
+      else if (strcmp(*argv, "--warnings") == 0 || strcmp(*argv, "-w") == 0)
+         global.warnings = 1;
+
+      else if (strcmp(*argv, "--quiet") == 0 || strcmp(*argv, "-q") == 0)
+      {
+         if (global.quiet)
+            global.quiet = 2;
+
+         else
+            global.quiet = 1;
+      }
+
+      else if (strcmp(*argv, "--verbose") == 0 || strcmp(*argv, "-v") == 0)
+         ++global.verbose;
+
+#if 0
+      /* NYI */
+#     ifdef PNG_MAXIMUM_INFLATE_WINDOW
+         else if (strcmp(*argv, "--test") == 0)
+            ++set_option;
+#     endif
+#endif
+
+      else if ((*argv)[0] == '-')
+         usage(prog);
+
+      else
+      {
+         size_t outlen = strlen(*argv);
+
+         if (outfile == NULL) /* else this takes precedence */
+         {
+            /* Consider the prefix/suffix options */
+            if (prefix != NULL)
+            {
+               size_t prefixlen = strlen(prefix);
+
+               if (prefixlen+outlen > FILENAME_MAX)
+               {
+                  fprintf(stderr, "%s: output file name too long: %s%s%s\n",
+                     prog, prefix, *argv, suffix ? suffix : "");
+                  global.status_code |= WRITE_ERROR;
+                  continue;
+               }
+
+               memcpy(temp_name, prefix, prefixlen);
+               memcpy(temp_name+prefixlen, *argv, outlen);
+               outlen += prefixlen;
+               outfile = temp_name;
+            }
+
+            else if (suffix != NULL)
+               memcpy(temp_name, *argv, outlen);
+
+            temp_name[outlen] = 0;
+
+            if (suffix != NULL)
+            {
+               size_t suffixlen = strlen(suffix);
+
+               if (outlen+suffixlen > FILENAME_MAX)
+               {
+                  fprintf(stderr, "%s: output file name too long: %s%s\n",
+                     prog, *argv, suffix);
+                  global.status_code |= WRITE_ERROR;
+                  continue;
+               }
+
+               memcpy(temp_name+outlen, suffix, suffixlen);
+               outlen += suffixlen;
+               temp_name[outlen] = 0;
+               outfile = temp_name;
+            }
+         }
+
+         (void)one_file(&global, *argv, outfile);
+         ++done;
+         outfile = NULL;
+      }
+   }
+
+   if (!done)
+      usage(prog);
+
+   return global_end(&global);
+}
+
+#else /* ZLIB_VERNUM < 0x1240 */
+int
+main(void)
+{
+   fprintf(stderr,
+      "pngfix needs libpng with a zlib >=1.2.4 (not 0x%x)\n",
+      ZLIB_VERNUM);
+   return 77;
+}
+#endif /* ZLIB_VERNUM */
+
+#else /* No read support */
+
+int
+main(void)
+{
+   fprintf(stderr, "pngfix does not work without read deinterlace support\n");
+   return 77;
+}
+#endif /* PNG_READ_SUPPORTED && PNG_EASY_ACCESS_SUPPORTED */
+#else /* No setjmp support */
+int
+main(void)
+{
+   fprintf(stderr, "pngfix does not work without setjmp support\n");
+   return 77;
+}
+#endif /* PNG_SETJMP_SUPPORTED */
+
diff --git a/Engine/lib/lpng/contrib/tools/reindent b/Engine/lib/lpng/contrib/tools/reindent
new file mode 100755
index 000000000..f4df309b6
--- /dev/null
+++ b/Engine/lib/lpng/contrib/tools/reindent
@@ -0,0 +1,25 @@
+#!/bin/sh
+
+# reindent a libpng C source
+
+# COPYRIGHT: Written by Glenn Randers-Pehrson, 2016.
+# To the extent possible under law, the author has waived all copyright and
+# related or neighboring rights to this work.  This work is published from:
+# United States.
+
+# Usage:
+# reindent inputtabsize outputtabsize inputcontinuestring outputcontinuestring
+#
+# Assumes that continued lines begin with indentation plus one space, and
+# that continued comments begin with indentation plus " *".
+#
+# eg, to change libpng coding style from 3-space indentation with 4-space
+# continuations to 4-space indentation with 2-space continuations:
+#
+#  reindent 3 4 "\t " "  " < example.c > example.c_4_2
+# and to restore the file back to libpng coding style
+#  reindent 4 3 "  " "    " < example.c_4_2 > example.c_3_4
+
+unexpand --first-only --t $1 | \
+   sed -e "/^	*$3[^\*]/{s/$3/$4/}" | \
+   expand -t $2
diff --git a/Engine/lib/lpng/contrib/tools/sRGB.h b/Engine/lib/lpng/contrib/tools/sRGB.h
new file mode 100644
index 000000000..d1ece5129
--- /dev/null
+++ b/Engine/lib/lpng/contrib/tools/sRGB.h
@@ -0,0 +1,48 @@
+/*-
+ * sRGB.h
+ *
+ * Last changed in libpng 1.6.0 [February 14, 2013]
+ *
+ * COPYRIGHT: Written by John Cunningham Bowler, 2013.
+ * To the extent possible under law, the author has waived all copyright and
+ * related or neighboring rights to this work.  This work is published from:
+ * United States.
+ *
+ * Utility file; not actually a header, this contains definitions of sRGB
+ * calculation functions for inclusion in those test programs that need them.
+ *
+ * All routines take and return a floating point value in the range
+ * 0 to 1.0, doing a calculation according to the sRGB specification
+ * (in fact the source of the numbers is the wikipedia article at
+ * https://en.wikipedia.org/wiki/SRGB).
+ */
+static double
+sRGB_from_linear(double l)
+{
+   if (l <= 0.0031308)
+      l *= 12.92;
+
+   else
+      l = 1.055 * pow(l, 1/2.4) - 0.055;
+
+   return l;
+}
+
+static double
+linear_from_sRGB(double s)
+{
+   if (s <= 0.04045)
+      return s / 12.92;
+
+   else
+      return pow((s+0.055)/1.055, 2.4);
+}
+
+static double
+YfromRGB(double r, double g, double b)
+{
+   /* Use the sRGB (rounded) coefficients for Rlinear, Glinear, Blinear to get
+    * the CIE Y value (also linear).
+    */
+   return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
diff --git a/Engine/lib/lpng/contrib/visupng/PngFile.c b/Engine/lib/lpng/contrib/visupng/PngFile.c
new file mode 100644
index 000000000..cf943f32a
--- /dev/null
+++ b/Engine/lib/lpng/contrib/visupng/PngFile.c
@@ -0,0 +1,454 @@
+/*-------------------------------------
+ *  PNGFILE.C -- Image File Functions
+ *-------------------------------------
+ *
+ * Copyright 2000,2017 Willem van Schaik.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+#include <windows.h>
+#include <commdlg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <zlib.h>
+
+#include "png.h"
+#include "pngfile.h"
+#include "cexcept.h"
+
+define_exception_type(const char *);
+extern struct exception_context the_exception_context[1];
+struct exception_context the_exception_context[1];
+png_const_charp msg;
+
+static OPENFILENAME ofn;
+
+static png_structp png_ptr = NULL;
+static png_infop info_ptr = NULL;
+
+
+/* cexcept interface */
+
+static void
+png_cexcept_error(png_structp png_ptr, png_const_charp msg)
+{
+   if(png_ptr)
+     ;
+#ifdef PNG_CONSOLE_IO_SUPPORTED
+   fprintf(stderr, "libpng error: %s\n", msg);
+#endif
+   {
+      Throw msg;
+   }
+}
+
+/* Windows open-file functions */
+
+void PngFileInitialize (HWND hwnd)
+{
+    static TCHAR szFilter[] = TEXT ("PNG Files (*.PNG)\0*.png\0")
+        TEXT ("All Files (*.*)\0*.*\0\0");
+
+    ofn.lStructSize       = sizeof (OPENFILENAME);
+    ofn.hwndOwner         = hwnd;
+    ofn.hInstance         = NULL;
+    ofn.lpstrFilter       = szFilter;
+    ofn.lpstrCustomFilter = NULL;
+    ofn.nMaxCustFilter    = 0;
+    ofn.nFilterIndex      = 0;
+    ofn.lpstrFile         = NULL;          /* Set in Open and Close functions */
+    ofn.nMaxFile          = MAX_PATH;
+    ofn.lpstrFileTitle    = NULL;          /* Set in Open and Close functions */
+    ofn.nMaxFileTitle     = MAX_PATH;
+    ofn.lpstrInitialDir   = NULL;
+    ofn.lpstrTitle        = NULL;
+    ofn.Flags             = 0;             /* Set in Open and Close functions */
+    ofn.nFileOffset       = 0;
+    ofn.nFileExtension    = 0;
+    ofn.lpstrDefExt       = TEXT ("png");
+    ofn.lCustData         = 0;
+    ofn.lpfnHook          = NULL;
+    ofn.lpTemplateName    = NULL;
+}
+
+BOOL PngFileOpenDlg (HWND hwnd, PTSTR pstrFileName, PTSTR pstrTitleName)
+{
+    ofn.hwndOwner         = hwnd;
+    ofn.lpstrFile         = pstrFileName;
+    ofn.lpstrFileTitle    = pstrTitleName;
+    ofn.Flags             = OFN_HIDEREADONLY;
+
+    return GetOpenFileName (&ofn);
+}
+
+BOOL PngFileSaveDlg (HWND hwnd, PTSTR pstrFileName, PTSTR pstrTitleName)
+{
+    ofn.hwndOwner         = hwnd;
+    ofn.lpstrFile         = pstrFileName;
+    ofn.lpstrFileTitle    = pstrTitleName;
+    ofn.Flags             = OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT;
+
+    return GetSaveFileName (&ofn);
+}
+
+/* PNG image handler functions */
+
+BOOL PngLoadImage (PTSTR pstrFileName, png_byte **ppbImageData,
+                   int *piWidth, int *piHeight, int *piChannels, png_color *pBkgColor)
+{
+    static FILE        *pfFile;
+    png_byte            pbSig[8];
+    int                 iBitDepth;
+    int                 iColorType;
+    double              dGamma;
+    png_color_16       *pBackground;
+    png_uint_32         ulChannels;
+    png_uint_32         ulRowBytes;
+    png_byte           *pbImageData = *ppbImageData;
+    static png_byte   **ppbRowPointers = NULL;
+    int                 i;
+
+    /* open the PNG input file */
+
+    if (!pstrFileName)
+    {
+        *ppbImageData = pbImageData = NULL;
+        return FALSE;
+    }
+
+    if (!(pfFile = fopen(pstrFileName, "rb")))
+    {
+        *ppbImageData = pbImageData = NULL;
+        return FALSE;
+    }
+
+    /* first check the eight byte PNG signature */
+
+    fread(pbSig, 1, 8, pfFile);
+    if (png_sig_cmp(pbSig, 0, 8))
+    {
+        *ppbImageData = pbImageData = NULL;
+        return FALSE;
+    }
+
+    /* create the two png(-info) structures */
+
+    png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL,
+      (png_error_ptr)png_cexcept_error, (png_error_ptr)NULL);
+    if (!png_ptr)
+    {
+        *ppbImageData = pbImageData = NULL;
+        return FALSE;
+    }
+
+    info_ptr = png_create_info_struct(png_ptr);
+    if (!info_ptr)
+    {
+        png_destroy_read_struct(&png_ptr, NULL, NULL);
+        *ppbImageData = pbImageData = NULL;
+        return FALSE;
+    }
+
+    Try
+    {
+
+        /* initialize the png structure */
+
+#ifdef PNG_STDIO_SUPPORTED
+        png_init_io(png_ptr, pfFile);
+#else
+        png_set_read_fn(png_ptr, (png_voidp)pfFile, png_read_data);
+#endif
+
+        png_set_sig_bytes(png_ptr, 8);
+
+        /* read all PNG info up to image data */
+
+        png_read_info(png_ptr, info_ptr);
+
+        /* get width, height, bit-depth and color-type */
+
+        png_get_IHDR(png_ptr, info_ptr, piWidth, piHeight, &iBitDepth,
+            &iColorType, NULL, NULL, NULL);
+
+        /* expand images of all color-type and bit-depth to 3x8-bit RGB */
+        /* let the library process alpha, transparency, background, etc. */
+
+#ifdef PNG_READ_16_TO_8_SUPPORTED
+    if (iBitDepth == 16)
+#  ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
+        png_set_scale_16(png_ptr);
+#  else
+        png_set_strip_16(png_ptr);
+#  endif
+#endif
+        if (iColorType == PNG_COLOR_TYPE_PALETTE)
+            png_set_expand(png_ptr);
+        if (iBitDepth < 8)
+            png_set_expand(png_ptr);
+        if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
+            png_set_expand(png_ptr);
+        if (iColorType == PNG_COLOR_TYPE_GRAY ||
+            iColorType == PNG_COLOR_TYPE_GRAY_ALPHA)
+            png_set_gray_to_rgb(png_ptr);
+
+        /* set the background color to draw transparent and alpha images over */
+        if (png_get_bKGD(png_ptr, info_ptr, &pBackground))
+        {
+            png_set_background(png_ptr, pBackground, PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
+            pBkgColor->red   = (byte) pBackground->red;
+            pBkgColor->green = (byte) pBackground->green;
+            pBkgColor->blue  = (byte) pBackground->blue;
+        }
+        else
+        {
+            pBkgColor = NULL;
+        }
+
+        /* if required set gamma conversion */
+        if (png_get_gAMA(png_ptr, info_ptr, &dGamma))
+            png_set_gamma(png_ptr, (double) 2.2, dGamma);
+
+        /* after the transformations are registered, update info_ptr data */
+
+        png_read_update_info(png_ptr, info_ptr);
+
+        /* get again width, height and the new bit-depth and color-type */
+
+        png_get_IHDR(png_ptr, info_ptr, piWidth, piHeight, &iBitDepth,
+            &iColorType, NULL, NULL, NULL);
+
+
+        /* row_bytes is the width x number of channels */
+
+        ulRowBytes = png_get_rowbytes(png_ptr, info_ptr);
+        ulChannels = png_get_channels(png_ptr, info_ptr);
+
+        *piChannels = ulChannels;
+
+        /* now we can allocate memory to store the image */
+
+        if (pbImageData)
+        {
+            free (pbImageData);
+            pbImageData = NULL;
+        }
+        if ((*piHeight) > ((size_t)(-1))/ulRowBytes) {
+        {
+            png_error(png_ptr, "Visual PNG: image is too big");
+        }
+        if ((pbImageData = (png_byte *) malloc(ulRowBytes * (*piHeight)
+                            * sizeof(png_byte))) == NULL)
+        {
+            png_error(png_ptr, "Visual PNG: out of memory");
+        }
+        *ppbImageData = pbImageData;
+
+        /* and allocate memory for an array of row-pointers */
+
+        if ((ppbRowPointers = (png_bytepp) malloc((*piHeight)
+                            * sizeof(png_bytep))) == NULL)
+        {
+            png_error(png_ptr, "Visual PNG: out of memory");
+        }
+
+        /* set the individual row-pointers to point at the correct offsets */
+
+        for (i = 0; i < (*piHeight); i++)
+            ppbRowPointers[i] = pbImageData + i * ulRowBytes;
+
+        /* now we can go ahead and just read the whole image */
+
+        png_read_image(png_ptr, ppbRowPointers);
+
+        /* read the additional chunks in the PNG file (not really needed) */
+
+        png_read_end(png_ptr, NULL);
+
+        /* and we're done */
+
+        free (ppbRowPointers);
+        ppbRowPointers = NULL;
+
+        /* yepp, done */
+    }
+
+    Catch (msg)
+    {
+        png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+
+        *ppbImageData = pbImageData = NULL;
+
+        if(ppbRowPointers)
+            free (ppbRowPointers);
+
+        fclose(pfFile);
+
+        return FALSE;
+    }
+
+    fclose (pfFile);
+
+    return TRUE;
+}
+
+
+BOOL PngSaveImage (PTSTR pstrFileName, png_byte *pDiData,
+                   int iWidth, int iHeight, png_color bkgColor)
+{
+    const int           ciBitDepth = 8;
+    const int           ciChannels = 3;
+
+    static FILE        *pfFile;
+    png_uint_32         ulRowBytes;
+    static png_byte   **ppbRowPointers = NULL;
+    int                 i;
+
+    /* open the PNG output file */
+
+    if (!pstrFileName)
+        return FALSE;
+
+    if (!(pfFile = fopen(pstrFileName, "wb")))
+        return FALSE;
+
+    /* prepare the standard PNG structures */
+
+    png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL,
+      (png_error_ptr)png_cexcept_error, (png_error_ptr)NULL);
+    if (!png_ptr)
+    {
+        fclose(pfFile);
+        return FALSE;
+    }
+
+    info_ptr = png_create_info_struct(png_ptr);
+    if (!info_ptr) {
+        fclose(pfFile);
+        png_destroy_write_struct(&png_ptr, (png_infopp) NULL);
+        return FALSE;
+    }
+
+    Try
+    {
+        /* initialize the png structure */
+
+#ifdef PNG_STDIO_SUPPORTED
+        png_init_io(png_ptr, pfFile);
+#else
+        png_set_write_fn(png_ptr, (png_voidp)pfFile, png_write_data, png_flush);
+#endif
+
+        /* we're going to write a very simple 3x8-bit RGB image */
+
+        png_set_IHDR(png_ptr, info_ptr, iWidth, iHeight, ciBitDepth,
+            PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE,
+            PNG_FILTER_TYPE_BASE);
+
+        /* write the file header information */
+
+        png_write_info(png_ptr, info_ptr);
+
+        /* swap the BGR pixels in the DiData structure to RGB */
+
+        png_set_bgr(png_ptr);
+
+        /* row_bytes is the width x number of channels */
+
+        ulRowBytes = iWidth * ciChannels;
+
+        /* we can allocate memory for an array of row-pointers */
+
+        if ((ppbRowPointers = (png_bytepp) malloc(iHeight * sizeof(png_bytep))) == NULL)
+            Throw "Visualpng: Out of memory";
+
+        /* set the individual row-pointers to point at the correct offsets */
+
+        for (i = 0; i < iHeight; i++)
+            ppbRowPointers[i] = pDiData + i * (((ulRowBytes + 3) >> 2) << 2);
+
+        /* write out the entire image data in one call */
+
+        png_write_image (png_ptr, ppbRowPointers);
+
+        /* write the additional chunks to the PNG file (not really needed) */
+
+        png_write_end(png_ptr, info_ptr);
+
+        /* and we're done */
+
+        free (ppbRowPointers);
+        ppbRowPointers = NULL;
+
+        /* clean up after the write, and free any memory allocated */
+
+        png_destroy_write_struct(&png_ptr, (png_infopp) NULL);
+
+        /* yepp, done */
+    }
+
+    Catch (msg)
+    {
+        png_destroy_write_struct(&png_ptr, (png_infopp) NULL);
+
+        if(ppbRowPointers)
+            free (ppbRowPointers);
+
+        fclose(pfFile);
+
+        return FALSE;
+    }
+
+    fclose (pfFile);
+
+    return TRUE;
+}
+
+#ifndef PNG_STDIO_SUPPORTED
+
+static void
+png_read_data(png_structp png_ptr, png_bytep data, size_t length)
+{
+   size_t check;
+
+   /* fread() returns 0 on error, so it is OK to store this in a size_t
+    * instead of an int, which is what fread() actually returns.
+    */
+   check = fread(data, 1, length, (FILE *)png_ptr->io_ptr);
+
+   if (check != length)
+   {
+      png_error(png_ptr, "Read Error");
+   }
+}
+
+static void
+png_write_data(png_structp png_ptr, png_bytep data, size_t length)
+{
+   png_uint_32 check;
+
+   check = fwrite(data, 1, length, (FILE *)(png_ptr->io_ptr));
+   if (check != length)
+   {
+      png_error(png_ptr, "Write Error");
+   }
+}
+
+static void
+png_flush(png_structp png_ptr)
+{
+   FILE *io_ptr;
+   io_ptr = (FILE *)CVT_PTR((png_ptr->io_ptr));
+   if (io_ptr != NULL)
+      fflush(io_ptr);
+}
+
+#endif
+
+/*-----------------
+ *  end of source
+ *-----------------
+ */
diff --git a/Engine/lib/lpng/contrib/visupng/PngFile.h b/Engine/lib/lpng/contrib/visupng/PngFile.h
new file mode 100644
index 000000000..1b7b9be3c
--- /dev/null
+++ b/Engine/lib/lpng/contrib/visupng/PngFile.h
@@ -0,0 +1,30 @@
+/*------------------------------------------*/
+/*  PNGFILE.H -- Header File for pngfile.c*/
+/*------------------------------------------*/
+
+/* Copyright 2000, Willem van Schaik.*/
+
+/* This code is released under the libpng license.*/
+/* For conditions of distribution and use, see the disclaimer*/
+/* and license in png.h*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <windows.h>
+
+void PngFileInitialize (HWND hwnd) ;
+BOOL PngFileOpenDlg (HWND hwnd, PTSTR pstrFileName, PTSTR pstrTitleName) ;
+BOOL PngFileSaveDlg (HWND hwnd, PTSTR pstrFileName, PTSTR pstrTitleName) ;
+
+BOOL PngLoadImage (PTSTR pstrFileName, png_byte **ppbImageData,
+                   int *piWidth, int *piHeight, int *piChannels, png_color *pBkgColor);
+BOOL PngSaveImage (PTSTR pstrFileName, png_byte *pDiData,
+                   int iWidth, int iHeight, png_color BkgColor);
+
+#ifndef PNG_STDIO_SUPPORTED
+static void png_read_data(png_structp png_ptr, png_bytep data, size_t length);
+static void png_write_data(png_structp png_ptr, png_bytep data, size_t length);
+static void png_flush(png_structp png_ptr);
+#endif
+
diff --git a/Engine/lib/lpng/contrib/visupng/README.txt b/Engine/lib/lpng/contrib/visupng/README.txt
new file mode 100644
index 000000000..72c5cba17
--- /dev/null
+++ b/Engine/lib/lpng/contrib/visupng/README.txt
@@ -0,0 +1,61 @@
+Microsoft Developer Studio Build File, Format Version 6.00 for VisualPng
+------------------------------------------------------------------------
+
+Copyright 2000, Willem van Schaik.
+
+This code is released under the libpng license.
+For conditions of distribution and use, see the disclaimer
+and license in png.h
+
+As a PNG .dll demo VisualPng is finished. More features would only hinder
+the program's objective. However, further extensions (like support for other
+graphics formats) are in development. To get these, or for pre-compiled
+binaries, go to "http://www.schaik.com/png/visualpng.html".
+
+------------------------------------------------------------------------
+
+Assumes that
+
+   libpng DLLs and LIBs are in ..\..\projects\msvc\win32\libpng
+   zlib DLLs and LIBs are in   ..\..\projects\msvc\win32\zlib
+   libpng header files are in  ..\..\..\libpng
+   zlib header files are in    ..\..\..\zlib
+   the pngsuite images are in  ..\pngsuite
+
+To build:
+
+1) On the main menu Select "Build|Set Active configuration".
+   Choose the configuration that corresponds to the library you want to test.
+   This library must have been built using the libpng MS project located in
+   the "..\..\mscv" subdirectory.
+
+2) Select "Build|Clean"
+
+3) Select "Build|Rebuild All"
+
+4) After compiling and linking VisualPng will be started to view an image
+   from the PngSuite directory.  Press Ctrl-N (and Ctrl-V) for other images.
+
+
+To install:
+
+When distributing VisualPng (or a further development) the following options
+are available:
+
+1) Build the program with the configuration "Win32 LIB" and you only need to
+   include the executable from the ./lib directory in your distribution.
+
+2) Build the program with the configuration "Win32 DLL" and you need to put
+   in your distribution the executable from the ./dll directory and the dll's
+   libpng1.dll, zlib.dll and msvcrt.dll.  These need to be in the user's PATH.
+
+
+Willem van Schaik
+Calgary, June 6th 2000
+
+P.S. VisualPng was written based on preliminary work of:
+
+    - Simon-Pierre Cadieux
+    - Glenn Randers-Pehrson
+    - Greg Roelofs
+
diff --git a/Engine/lib/lpng/contrib/visupng/VisualPng.c b/Engine/lib/lpng/contrib/visupng/VisualPng.c
new file mode 100644
index 000000000..6baa3b663
--- /dev/null
+++ b/Engine/lib/lpng/contrib/visupng/VisualPng.c
@@ -0,0 +1,978 @@
+/*------------------------------------
+ *  VisualPng.C -- Shows a PNG image
+ *------------------------------------
+ *
+ * Copyright 2000,2017 Willem van Schaik.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+/* switches */
+
+/* defines */
+
+#define PROGNAME  "VisualPng"
+#define LONGNAME  "Win32 Viewer for PNG-files"
+#define VERSION   "1.0 of 2000 June 07"
+
+/* constants */
+
+#define MARGIN 8
+
+/* standard includes */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <windows.h>
+#include <zlib.h>
+
+/* application includes */
+
+#include "png.h"
+#include "pngfile.h"
+#include "resource.h"
+
+/* macros */
+
+/* function prototypes */
+
+LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM);
+BOOL    CALLBACK AboutDlgProc (HWND, UINT, WPARAM, LPARAM) ;
+
+BOOL CenterAbout (HWND hwndChild, HWND hwndParent);
+
+BOOL BuildPngList (PTSTR pstrPathName, TCHAR **ppFileList, int *pFileCount,
+        int *pFileIndex);
+
+BOOL SearchPngList (TCHAR *pFileList, int FileCount, int *pFileIndex,
+        PTSTR pstrPrevName, PTSTR pstrNextName);
+
+BOOL LoadImageFile(HWND hwnd, PTSTR pstrPathName,
+        png_byte **ppbImage, int *pxImgSize, int *pyImgSize, int *piChannels,
+        png_color *pBkgColor);
+
+BOOL DisplayImage (HWND hwnd, BYTE **ppDib,
+        BYTE **ppDiData, int cxWinSize, int cyWinSize,
+        BYTE *pbImage, int cxImgSize, int cyImgSize, int cImgChannels,
+        BOOL bStretched);
+
+BOOL InitBitmap (
+        BYTE *pDiData, int cxWinSize, int cyWinSize);
+
+BOOL FillBitmap (
+        BYTE *pDiData, int cxWinSize, int cyWinSize,
+        BYTE *pbImage, int cxImgSize, int cyImgSize, int cImgChannels,
+        BOOL bStretched);
+
+/* a few global variables */
+
+static char *szProgName = PROGNAME;
+static char *szAppName = LONGNAME;
+static char *szIconName = PROGNAME;
+static char szCmdFileName [MAX_PATH];
+
+/* MAIN routine */
+
+int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
+                    PSTR szCmdLine, int iCmdShow)
+{
+    HACCEL   hAccel;
+    HWND     hwnd;
+    MSG      msg;
+    WNDCLASS wndclass;
+    int ixBorders, iyBorders;
+
+    wndclass.style         = CS_HREDRAW | CS_VREDRAW;
+    wndclass.lpfnWndProc   = WndProc;
+    wndclass.cbClsExtra    = 0;
+    wndclass.cbWndExtra    = 0;
+    wndclass.hInstance     = hInstance;
+    wndclass.hIcon         = LoadIcon (hInstance, szIconName) ;
+    wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
+    wndclass.hbrBackground = NULL; /* (HBRUSH) GetStockObject (GRAY_BRUSH); */
+    wndclass.lpszMenuName  = szProgName;
+    wndclass.lpszClassName = szProgName;
+
+    if (!RegisterClass (&wndclass))
+    {
+        MessageBox (NULL, TEXT ("Error: this program requires Windows NT!"),
+            szProgName, MB_ICONERROR);
+        return 0;
+    }
+
+    /* if filename given on commandline, store it */
+    if ((szCmdLine != NULL) && (*szCmdLine != '\0'))
+        if (szCmdLine[0] == '"')
+            strncpy (szCmdFileName, szCmdLine + 1, strlen(szCmdLine) - 2);
+        else
+            strcpy (szCmdFileName, szCmdLine);
+    else
+        strcpy (szCmdFileName, "");
+
+    /* calculate size of window-borders */
+    ixBorders = 2 * (GetSystemMetrics (SM_CXBORDER) +
+                     GetSystemMetrics (SM_CXDLGFRAME));
+    iyBorders = 2 * (GetSystemMetrics (SM_CYBORDER) +
+                     GetSystemMetrics (SM_CYDLGFRAME)) +
+                     GetSystemMetrics (SM_CYCAPTION) +
+                     GetSystemMetrics (SM_CYMENUSIZE) +
+                     1; /* WvS: don't ask me why?  */
+
+    hwnd = CreateWindow (szProgName, szAppName,
+        WS_OVERLAPPEDWINDOW,
+        CW_USEDEFAULT, CW_USEDEFAULT,
+        512 + 2 * MARGIN + ixBorders, 384 + 2 * MARGIN + iyBorders,
+/*      CW_USEDEFAULT, CW_USEDEFAULT, */
+        NULL, NULL, hInstance, NULL);
+
+    ShowWindow (hwnd, iCmdShow);
+    UpdateWindow (hwnd);
+
+    hAccel = LoadAccelerators (hInstance, szProgName);
+
+    while (GetMessage (&msg, NULL, 0, 0))
+    {
+        if (!TranslateAccelerator (hwnd, hAccel, &msg))
+        {
+            TranslateMessage (&msg);
+            DispatchMessage (&msg);
+        }
+    }
+    return msg.wParam;
+}
+
+LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam,
+        LPARAM lParam)
+{
+    static HINSTANCE          hInstance ;
+    static HDC                hdc;
+    static PAINTSTRUCT        ps;
+    static HMENU              hMenu;
+
+    static BITMAPFILEHEADER  *pbmfh;
+    static BITMAPINFOHEADER  *pbmih;
+    static BYTE              *pbImage;
+    static int                cxWinSize, cyWinSize;
+    static int                cxImgSize, cyImgSize;
+    static int                cImgChannels;
+    static png_color          bkgColor = {127, 127, 127};
+
+    static BOOL               bStretched = TRUE;
+
+    static BYTE              *pDib = NULL;
+    static BYTE              *pDiData = NULL;
+
+    static TCHAR              szImgPathName [MAX_PATH];
+    static TCHAR              szTitleName [MAX_PATH];
+
+    static TCHAR             *pPngFileList = NULL;
+    static int                iPngFileCount;
+    static int                iPngFileIndex;
+
+    BOOL                      bOk;
+
+    switch (message)
+    {
+    case WM_CREATE:
+        hInstance = ((LPCREATESTRUCT) lParam)->hInstance ;
+        PngFileInitialize (hwnd);
+
+        strcpy (szImgPathName, "");
+
+        /* in case we process file given on command-line */
+
+        if (szCmdFileName[0] != '\0')
+        {
+            strcpy (szImgPathName, szCmdFileName);
+
+            /* read the other png-files in the directory for later */
+            /* next/previous commands */
+
+            BuildPngList (szImgPathName, &pPngFileList, &iPngFileCount,
+                          &iPngFileIndex);
+
+            /* load the image from file */
+
+            if (!LoadImageFile (hwnd, szImgPathName,
+                &pbImage, &cxImgSize, &cyImgSize, &cImgChannels, &bkgColor))
+                return 0;
+
+            /* invalidate the client area for later update */
+
+            InvalidateRect (hwnd, NULL, TRUE);
+
+            /* display the PNG into the DIBitmap */
+
+            DisplayImage (hwnd, &pDib, &pDiData, cxWinSize, cyWinSize,
+                pbImage, cxImgSize, cyImgSize, cImgChannels, bStretched);
+        }
+
+        return 0;
+
+    case WM_SIZE:
+        cxWinSize = LOWORD (lParam);
+        cyWinSize = HIWORD (lParam);
+
+        /* invalidate the client area for later update */
+
+        InvalidateRect (hwnd, NULL, TRUE);
+
+        /* display the PNG into the DIBitmap */
+
+        DisplayImage (hwnd, &pDib, &pDiData, cxWinSize, cyWinSize,
+            pbImage, cxImgSize, cyImgSize, cImgChannels, bStretched);
+
+        return 0;
+
+    case WM_INITMENUPOPUP:
+        hMenu = GetMenu (hwnd);
+
+        if (pbImage)
+            EnableMenuItem (hMenu, IDM_FILE_SAVE, MF_ENABLED);
+        else
+            EnableMenuItem (hMenu, IDM_FILE_SAVE, MF_GRAYED);
+
+        return 0;
+
+    case WM_COMMAND:
+        hMenu = GetMenu (hwnd);
+
+        switch (LOWORD (wParam))
+        {
+        case IDM_FILE_OPEN:
+
+            /* show the File Open dialog box */
+
+            if (!PngFileOpenDlg (hwnd, szImgPathName, szTitleName))
+                return 0;
+
+            /* read the other png-files in the directory for later */
+            /* next/previous commands */
+
+            BuildPngList (szImgPathName, &pPngFileList, &iPngFileCount,
+                          &iPngFileIndex);
+
+            /* load the image from file */
+
+            if (!LoadImageFile (hwnd, szImgPathName,
+                &pbImage, &cxImgSize, &cyImgSize, &cImgChannels, &bkgColor))
+                return 0;
+
+            /* invalidate the client area for later update */
+
+            InvalidateRect (hwnd, NULL, TRUE);
+
+            /* display the PNG into the DIBitmap */
+
+            DisplayImage (hwnd, &pDib, &pDiData, cxWinSize, cyWinSize,
+                pbImage, cxImgSize, cyImgSize, cImgChannels, bStretched);
+
+            return 0;
+
+        case IDM_FILE_SAVE:
+
+            /* show the File Save dialog box */
+
+            if (!PngFileSaveDlg (hwnd, szImgPathName, szTitleName))
+                return 0;
+
+            /* save the PNG to a disk file */
+
+            SetCursor (LoadCursor (NULL, IDC_WAIT));
+            ShowCursor (TRUE);
+
+            bOk = PngSaveImage (szImgPathName, pDiData, cxWinSize, cyWinSize,
+                  bkgColor);
+
+            ShowCursor (FALSE);
+            SetCursor (LoadCursor (NULL, IDC_ARROW));
+
+            if (!bOk)
+                MessageBox (hwnd, TEXT ("Error in saving the PNG image"),
+                szProgName, MB_ICONEXCLAMATION | MB_OK);
+            return 0;
+
+        case IDM_FILE_NEXT:
+
+            /* read next entry in the directory */
+
+            if (SearchPngList (pPngFileList, iPngFileCount, &iPngFileIndex,
+                NULL, szImgPathName))
+            {
+                if (strcmp (szImgPathName, "") == 0)
+                    return 0;
+
+                /* load the image from file */
+
+                if (!LoadImageFile (hwnd, szImgPathName, &pbImage,
+                        &cxImgSize, &cyImgSize, &cImgChannels, &bkgColor))
+                    return 0;
+
+                /* invalidate the client area for later update */
+
+                InvalidateRect (hwnd, NULL, TRUE);
+
+                /* display the PNG into the DIBitmap */
+
+                DisplayImage (hwnd, &pDib, &pDiData, cxWinSize, cyWinSize,
+                    pbImage, cxImgSize, cyImgSize, cImgChannels, bStretched);
+            }
+
+            return 0;
+
+        case IDM_FILE_PREVIOUS:
+
+            /* read previous entry in the directory */
+
+            if (SearchPngList (pPngFileList, iPngFileCount, &iPngFileIndex,
+                szImgPathName, NULL))
+            {
+
+                if (strcmp (szImgPathName, "") == 0)
+                    return 0;
+
+                /* load the image from file */
+
+                if (!LoadImageFile (hwnd, szImgPathName, &pbImage, &cxImgSize,
+                    &cyImgSize, &cImgChannels, &bkgColor))
+                    return 0;
+
+                /* invalidate the client area for later update */
+
+                InvalidateRect (hwnd, NULL, TRUE);
+
+                /* display the PNG into the DIBitmap */
+
+                DisplayImage (hwnd, &pDib, &pDiData, cxWinSize, cyWinSize,
+                    pbImage, cxImgSize, cyImgSize, cImgChannels, bStretched);
+            }
+
+            return 0;
+
+        case IDM_FILE_EXIT:
+
+            /* more cleanup needed... */
+
+            /* free image buffer */
+
+            if (pDib != NULL)
+            {
+                free (pDib);
+                pDib = NULL;
+            }
+
+            /* free file-list */
+
+            if (pPngFileList != NULL)
+            {
+                free (pPngFileList);
+                pPngFileList = NULL;
+            }
+
+            /* let's go ... */
+
+            exit (0);
+
+            return 0;
+
+        case IDM_OPTIONS_STRETCH:
+            bStretched = !bStretched;
+            if (bStretched)
+                CheckMenuItem (hMenu, IDM_OPTIONS_STRETCH, MF_CHECKED);
+            else
+                CheckMenuItem (hMenu, IDM_OPTIONS_STRETCH, MF_UNCHECKED);
+
+            /* invalidate the client area for later update */
+
+            InvalidateRect (hwnd, NULL, TRUE);
+
+            /* display the PNG into the DIBitmap */
+
+            DisplayImage (hwnd, &pDib, &pDiData, cxWinSize, cyWinSize,
+                pbImage, cxImgSize, cyImgSize, cImgChannels, bStretched);
+
+            return 0;
+
+        case IDM_HELP_ABOUT:
+            DialogBox (hInstance, TEXT ("AboutBox"), hwnd, AboutDlgProc) ;
+            return 0;
+
+        } /* end switch */
+
+        break;
+
+    case WM_PAINT:
+        hdc = BeginPaint (hwnd, &ps);
+
+        if (pDib)
+            SetDIBitsToDevice (hdc, 0, 0, cxWinSize, cyWinSize, 0, 0,
+                0, cyWinSize, pDiData, (BITMAPINFO *) pDib, DIB_RGB_COLORS);
+
+        EndPaint (hwnd, &ps);
+        return 0;
+
+    case WM_DESTROY:
+        if (pbmfh)
+        {
+            free (pbmfh);
+            pbmfh = NULL;
+        }
+
+        PostQuitMessage (0);
+        return 0;
+    }
+
+    return DefWindowProc (hwnd, message, wParam, lParam);
+}
+
+BOOL CALLBACK AboutDlgProc (HWND hDlg, UINT message,
+                            WPARAM wParam, LPARAM lParam)
+{
+     switch (message)
+     {
+     case WM_INITDIALOG :
+          ShowWindow (hDlg, SW_HIDE);
+          CenterAbout (hDlg, GetWindow (hDlg, GW_OWNER));
+          ShowWindow (hDlg, SW_SHOW);
+          return TRUE ;
+
+     case WM_COMMAND :
+          switch (LOWORD (wParam))
+          {
+          case IDOK :
+          case IDCANCEL :
+               EndDialog (hDlg, 0) ;
+               return TRUE ;
+          }
+          break ;
+     }
+     return FALSE ;
+}
+
+/*---------------
+ *  CenterAbout
+ *---------------
+ */
+BOOL CenterAbout (HWND hwndChild, HWND hwndParent)
+{
+   RECT    rChild, rParent, rWorkArea;
+   int     wChild, hChild, wParent, hParent;
+   int     xNew, yNew;
+   BOOL  bResult;
+
+   /* Get the Height and Width of the child window */
+   GetWindowRect (hwndChild, &rChild);
+   wChild = rChild.right - rChild.left;
+   hChild = rChild.bottom - rChild.top;
+
+   /* Get the Height and Width of the parent window */
+   GetWindowRect (hwndParent, &rParent);
+   wParent = rParent.right - rParent.left;
+   hParent = rParent.bottom - rParent.top;
+
+   /* Get the limits of the 'workarea' */
+   bResult = SystemParametersInfo(
+      SPI_GETWORKAREA,  /* system parameter to query or set */
+      sizeof(RECT),
+      &rWorkArea,
+      0);
+   if (!bResult) {
+      rWorkArea.left = rWorkArea.top = 0;
+      rWorkArea.right = GetSystemMetrics(SM_CXSCREEN);
+      rWorkArea.bottom = GetSystemMetrics(SM_CYSCREEN);
+   }
+
+   /* Calculate new X position, then adjust for workarea */
+   xNew = rParent.left + ((wParent - wChild) /2);
+   if (xNew < rWorkArea.left) {
+      xNew = rWorkArea.left;
+   } else if ((xNew+wChild) > rWorkArea.right) {
+      xNew = rWorkArea.right - wChild;
+   }
+
+   /* Calculate new Y position, then adjust for workarea */
+   yNew = rParent.top  + ((hParent - hChild) /2);
+   if (yNew < rWorkArea.top) {
+      yNew = rWorkArea.top;
+   } else if ((yNew+hChild) > rWorkArea.bottom) {
+      yNew = rWorkArea.bottom - hChild;
+   }
+
+   /* Set it, and return */
+   return SetWindowPos (hwndChild, NULL, xNew, yNew, 0, 0, SWP_NOSIZE |
+          SWP_NOZORDER);
+}
+
+/*----------------
+ *  BuildPngList
+ *----------------
+ */
+BOOL BuildPngList (PTSTR pstrPathName, TCHAR **ppFileList, int *pFileCount,
+     int *pFileIndex)
+{
+    static TCHAR              szImgPathName [MAX_PATH];
+    static TCHAR              szImgFileName [MAX_PATH];
+    static TCHAR              szImgFindName [MAX_PATH];
+
+    WIN32_FIND_DATA           finddata;
+    HANDLE                    hFind;
+
+    static TCHAR              szTmp [MAX_PATH];
+    BOOL                      bOk;
+    int                       i, ii;
+    int                       j, jj;
+
+    /* free previous file-list */
+
+    if (*ppFileList != NULL)
+    {
+        free (*ppFileList);
+        *ppFileList = NULL;
+    }
+
+    /* extract foldername, filename and search-name */
+
+    strcpy (szImgPathName, pstrPathName);
+    strcpy (szImgFileName, strrchr (pstrPathName, '\\') + 1);
+
+    strcpy (szImgFindName, szImgPathName);
+    *(strrchr (szImgFindName, '\\') + 1) = '\0';
+    strcat (szImgFindName, "*.png");
+
+    /* first cycle: count number of files in directory for memory allocation */
+
+    *pFileCount = 0;
+
+    hFind = FindFirstFile(szImgFindName, &finddata);
+    bOk = (hFind != (HANDLE) -1);
+
+    while (bOk)
+    {
+        *pFileCount += 1;
+        bOk = FindNextFile(hFind, &finddata);
+    }
+    FindClose(hFind);
+
+    /* allocation memory for file-list */
+
+    *ppFileList = (TCHAR *) malloc (*pFileCount * MAX_PATH);
+
+    /* second cycle: read directory and store filenames in file-list */
+
+    hFind = FindFirstFile(szImgFindName, &finddata);
+    bOk = (hFind != (HANDLE) -1);
+
+    i = 0;
+    ii = 0;
+    while (bOk)
+    {
+        strcpy (*ppFileList + ii, szImgPathName);
+        strcpy (strrchr(*ppFileList + ii, '\\') + 1, finddata.cFileName);
+
+        if (strcmp(pstrPathName, *ppFileList + ii) == 0)
+            *pFileIndex = i;
+
+        ii += MAX_PATH;
+        i++;
+
+        bOk = FindNextFile(hFind, &finddata);
+    }
+    FindClose(hFind);
+
+    /* finally we must sort the file-list */
+
+    for (i = 0; i < *pFileCount - 1; i++)
+    {
+        ii = i * MAX_PATH;
+        for (j = i+1; j < *pFileCount; j++)
+        {
+            jj = j * MAX_PATH;
+            if (strcmp (*ppFileList + ii, *ppFileList + jj) > 0)
+            {
+                strcpy (szTmp, *ppFileList + jj);
+                strcpy (*ppFileList + jj, *ppFileList + ii);
+                strcpy (*ppFileList + ii, szTmp);
+
+                /* check if this was the current image that we moved */
+
+                if (*pFileIndex == i)
+                    *pFileIndex = j;
+                else
+                    if (*pFileIndex == j)
+                        *pFileIndex = i;
+            }
+        }
+    }
+
+    return TRUE;
+}
+
+/*----------------
+ *  SearchPngList
+ *----------------
+ */
+
+BOOL SearchPngList (
+        TCHAR *pFileList, int FileCount, int *pFileIndex,
+        PTSTR pstrPrevName, PTSTR pstrNextName)
+{
+    if (FileCount > 0)
+    {
+        /* get previous entry */
+
+        if (pstrPrevName != NULL)
+        {
+            if (*pFileIndex > 0)
+                *pFileIndex -= 1;
+            else
+                *pFileIndex = FileCount - 1;
+
+            strcpy (pstrPrevName, pFileList + (*pFileIndex * MAX_PATH));
+        }
+
+        /* get next entry */
+
+        if (pstrNextName != NULL)
+        {
+            if (*pFileIndex < FileCount - 1)
+                *pFileIndex += 1;
+            else
+                *pFileIndex = 0;
+
+            strcpy (pstrNextName, pFileList + (*pFileIndex * MAX_PATH));
+        }
+
+        return TRUE;
+    }
+    else
+    {
+        return FALSE;
+    }
+}
+
+/*-----------------
+ *  LoadImageFile
+ *-----------------
+ */
+
+BOOL LoadImageFile (HWND hwnd, PTSTR pstrPathName,
+                png_byte **ppbImage, int *pxImgSize, int *pyImgSize,
+                int *piChannels, png_color *pBkgColor)
+{
+    static TCHAR szTmp [MAX_PATH];
+
+    /* if there's an existing PNG, free the memory */
+
+    if (*ppbImage)
+    {
+        free (*ppbImage);
+        *ppbImage = NULL;
+    }
+
+    /* Load the entire PNG into memory */
+
+    SetCursor (LoadCursor (NULL, IDC_WAIT));
+    ShowCursor (TRUE);
+
+    PngLoadImage (pstrPathName, ppbImage, pxImgSize, pyImgSize, piChannels,
+                  pBkgColor);
+
+    ShowCursor (FALSE);
+    SetCursor (LoadCursor (NULL, IDC_ARROW));
+
+    if (*ppbImage != NULL)
+    {
+        sprintf (szTmp, "VisualPng - %s", strrchr(pstrPathName, '\\') + 1);
+        SetWindowText (hwnd, szTmp);
+    }
+    else
+    {
+        MessageBox (hwnd, TEXT ("Error in loading the PNG image"),
+            szProgName, MB_ICONEXCLAMATION | MB_OK);
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+/*----------------
+ *  DisplayImage
+ *----------------
+ */
+BOOL DisplayImage (HWND hwnd, BYTE **ppDib,
+        BYTE **ppDiData, int cxWinSize, int cyWinSize,
+        BYTE *pbImage, int cxImgSize, int cyImgSize, int cImgChannels,
+        BOOL bStretched)
+{
+    BYTE                       *pDib = *ppDib;
+    BYTE                       *pDiData = *ppDiData;
+    /* BITMAPFILEHEADER        *pbmfh; */
+    BITMAPINFOHEADER           *pbmih;
+    WORD                        wDIRowBytes;
+    png_color                   bkgBlack = {0, 0, 0};
+    png_color                   bkgGray  = {127, 127, 127};
+    png_color                   bkgWhite = {255, 255, 255};
+
+    /* allocate memory for the Device Independent bitmap */
+
+    wDIRowBytes = (WORD) ((3 * cxWinSize + 3L) >> 2) << 2;
+
+    if (pDib)
+    {
+        free (pDib);
+        pDib = NULL;
+    }
+
+    if (cyWinSize > ((size_t)(-1))/wDIRowBytes) {
+    {
+        MessageBox (hwnd, TEXT ("Visual PNG: image is too big");
+    }
+    if (!(pDib = (BYTE *) malloc (sizeof(BITMAPINFOHEADER) +
+        wDIRowBytes * cyWinSize)))
+    {
+        MessageBox (hwnd, TEXT ("Error in displaying the PNG image"),
+            szProgName, MB_ICONEXCLAMATION | MB_OK);
+        *ppDib = pDib = NULL;
+        return FALSE;
+    }
+    *ppDib = pDib;
+    memset (pDib, 0, sizeof(BITMAPINFOHEADER));
+
+    /* initialize the dib-structure */
+
+    pbmih = (BITMAPINFOHEADER *) pDib;
+    pbmih->biSize = sizeof(BITMAPINFOHEADER);
+    pbmih->biWidth = cxWinSize;
+    pbmih->biHeight = -((long) cyWinSize);
+    pbmih->biPlanes = 1;
+    pbmih->biBitCount = 24;
+    pbmih->biCompression = 0;
+    pDiData = pDib + sizeof(BITMAPINFOHEADER);
+    *ppDiData = pDiData;
+
+    /* first fill bitmap with gray and image border */
+
+    InitBitmap (pDiData, cxWinSize, cyWinSize);
+
+    /* then fill bitmap with image */
+
+    if (pbImage)
+    {
+        FillBitmap (
+            pDiData, cxWinSize, cyWinSize,
+            pbImage, cxImgSize, cyImgSize, cImgChannels,
+            bStretched);
+    }
+
+    return TRUE;
+}
+
+/*--------------
+ *  InitBitmap
+ *--------------
+ */
+BOOL InitBitmap (BYTE *pDiData, int cxWinSize, int cyWinSize)
+{
+    BYTE *dst;
+    int x, y, col;
+
+    /* initialize the background with gray */
+
+    dst = pDiData;
+    for (y = 0; y < cyWinSize; y++)
+    {
+        col = 0;
+        for (x = 0; x < cxWinSize; x++)
+        {
+            /* fill with GRAY */
+            *dst++ = 127;
+            *dst++ = 127;
+            *dst++ = 127;
+            col += 3;
+        }
+        /* rows start on 4 byte boundaries */
+        while ((col % 4) != 0)
+        {
+            dst++;
+            col++;
+        }
+    }
+
+    return TRUE;
+}
+
+/*--------------
+ *  FillBitmap
+ *--------------
+ */
+BOOL FillBitmap (
+        BYTE *pDiData, int cxWinSize, int cyWinSize,
+        BYTE *pbImage, int cxImgSize, int cyImgSize, int cImgChannels,
+        BOOL bStretched)
+{
+    BYTE *pStretchedImage;
+    BYTE *pImg;
+    BYTE *src, *dst;
+    BYTE r, g, b, a;
+    const int cDIChannels = 3;
+    WORD wImgRowBytes;
+    WORD wDIRowBytes;
+    int cxNewSize, cyNewSize;
+    int cxImgPos, cyImgPos;
+    int xImg, yImg;
+    int xWin, yWin;
+    int xOld, yOld;
+    int xNew, yNew;
+
+    if (bStretched)
+    {
+        cxNewSize = cxWinSize - 2 * MARGIN;
+        cyNewSize = cyWinSize - 2 * MARGIN;
+
+        /* stretch the image to it's window determined size */
+
+        /* the following two are mathematically the same, but the first
+         * has side-effects because of rounding
+         */
+/*      if ((cyNewSize / cxNewSize) > (cyImgSize / cxImgSize)) */
+        if ((cyNewSize * cxImgSize) > (cyImgSize * cxNewSize))
+        {
+            cyNewSize = cxNewSize * cyImgSize / cxImgSize;
+            cxImgPos = MARGIN;
+            cyImgPos = (cyWinSize - cyNewSize) / 2;
+        }
+        else
+        {
+            cxNewSize = cyNewSize * cxImgSize / cyImgSize;
+            cyImgPos = MARGIN;
+            cxImgPos = (cxWinSize - cxNewSize) / 2;
+        }
+
+        if (cyNewSize > ((size_t)(-1))/(cImgChannels * cxNewSize)) {
+        {
+            MessageBox (hwnd, TEXT ("Visual PNG: stretched image is too big");
+        }
+        pStretchedImage = malloc (cImgChannels * cxNewSize * cyNewSize);
+        pImg = pStretchedImage;
+
+        for (yNew = 0; yNew < cyNewSize; yNew++)
+        {
+            yOld = yNew * cyImgSize / cyNewSize;
+            for (xNew = 0; xNew < cxNewSize; xNew++)
+            {
+                xOld = xNew * cxImgSize / cxNewSize;
+
+                r = *(pbImage + cImgChannels * ((yOld * cxImgSize) + xOld) + 0);
+                g = *(pbImage + cImgChannels * ((yOld * cxImgSize) + xOld) + 1);
+                b = *(pbImage + cImgChannels * ((yOld * cxImgSize) + xOld) + 2);
+                *pImg++ = r;
+                *pImg++ = g;
+                *pImg++ = b;
+                if (cImgChannels == 4)
+                {
+                    a = *(pbImage + cImgChannels * ((yOld * cxImgSize) + xOld)
+                        + 3);
+                    *pImg++ = a;
+                }
+            }
+        }
+
+        /* calculate row-bytes */
+
+        wImgRowBytes = cImgChannels * cxNewSize;
+        wDIRowBytes = (WORD) ((cDIChannels * cxWinSize + 3L) >> 2) << 2;
+
+        /* copy image to screen */
+
+        for (yImg = 0, yWin = cyImgPos; yImg < cyNewSize; yImg++, yWin++)
+        {
+            if (yWin >= cyWinSize - cyImgPos)
+                break;
+            src = pStretchedImage + yImg * wImgRowBytes;
+            dst = pDiData + yWin * wDIRowBytes + cxImgPos * cDIChannels;
+
+            for (xImg = 0, xWin = cxImgPos; xImg < cxNewSize; xImg++, xWin++)
+            {
+                if (xWin >= cxWinSize - cxImgPos)
+                    break;
+                r = *src++;
+                g = *src++;
+                b = *src++;
+                *dst++ = b; /* note the reverse order  */
+                *dst++ = g;
+                *dst++ = r;
+                if (cImgChannels == 4)
+                {
+                    a = *src++;
+                }
+            }
+        }
+
+        /* free memory */
+
+        if (pStretchedImage != NULL)
+        {
+            free (pStretchedImage);
+            pStretchedImage = NULL;
+        }
+
+    }
+
+    /* process the image not-stretched */
+
+    else
+    {
+        /* calculate the central position */
+
+        cxImgPos = (cxWinSize - cxImgSize) / 2;
+        cyImgPos = (cyWinSize - cyImgSize) / 2;
+
+        /* check for image larger than window */
+
+        if (cxImgPos < MARGIN)
+            cxImgPos = MARGIN;
+        if (cyImgPos < MARGIN)
+            cyImgPos = MARGIN;
+
+        /* calculate both row-bytes */
+
+        wImgRowBytes = cImgChannels * cxImgSize;
+        wDIRowBytes = (WORD) ((cDIChannels * cxWinSize + 3L) >> 2) << 2;
+
+        /* copy image to screen */
+
+        for (yImg = 0, yWin = cyImgPos; yImg < cyImgSize; yImg++, yWin++)
+        {
+            if (yWin >= cyWinSize - MARGIN)
+                break;
+            src = pbImage + yImg * wImgRowBytes;
+            dst = pDiData + yWin * wDIRowBytes + cxImgPos * cDIChannels;
+
+            for (xImg = 0, xWin = cxImgPos; xImg < cxImgSize; xImg++, xWin++)
+            {
+                if (xWin >= cxWinSize - MARGIN)
+                    break;
+                r = *src++;
+                g = *src++;
+                b = *src++;
+                *dst++ = b; /* note the reverse order  */
+                *dst++ = g;
+                *dst++ = r;
+                if (cImgChannels == 4)
+                {
+                    a = *src++;
+                }
+            }
+        }
+    }
+
+    return TRUE;
+}
+
+/*-----------------
+ *  end of source
+ *-----------------
+ */
diff --git a/Engine/lib/lpng/contrib/visupng/VisualPng.dsp b/Engine/lib/lpng/contrib/visupng/VisualPng.dsp
new file mode 100644
index 000000000..76afbe601
--- /dev/null
+++ b/Engine/lib/lpng/contrib/visupng/VisualPng.dsp
@@ -0,0 +1,147 @@
+# Microsoft Developer Studio Project File - Name="VisualPng" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Application" 0x0101
+
+CFG=VisualPng - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "VisualPng.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "VisualPng.mak" CFG="VisualPng - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "VisualPng - Win32 Release" (based on "Win32 (x86) Application")
+!MESSAGE "VisualPng - Win32 Debug" (based on "Win32 (x86) Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "VisualPng - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /O2 /I "..\.." /I "..\..\..\zlib" /D "WIN32" /D "NDEBUG" /D "PNG_NO_STDIO" /FD /c
+# SUBTRACT BASE CPP /YX
+# ADD CPP /nologo /MD /W3 /O2 /I "..\.." /I "..\..\..\zlib" /D "WIN32" /D "NDEBUG" /D "PNG_NO_STDIO" /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 ..\..\projects\visualc6\Win32_LIB_Release\libpng.lib ..\..\..\zlib\projects\visualc6\Win32_LIB_Release\zlib.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+# Begin Special Build Tool
+OutDir=.\Release
+SOURCE="$(InputPath)"
+PostBuild_Cmds=$(outdir)\VisualPng.exe ..\..\contrib\pngsuite\basn6a16.png
+# End Special Build Tool
+
+!ELSEIF  "$(CFG)" == "VisualPng - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /ZI /Od /I "..\.." /I "..\..\..\zlib" /D "WIN32" /D "_DEBUG" /D "PNG_NO_STDIO" /FD /GZ /c
+# SUBTRACT BASE CPP /YX
+# ADD CPP /nologo /MDd /W3 /Gm /ZI /Od /I "..\.." /I "..\..\..\zlib" /D "WIN32" /D "_DEBUG" /D "PNG_NO_STDIO" /FD /GZ /c
+# SUBTRACT CPP /YX
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 ..\..\projects\visualc6\Win32_LIB_Release\libpng.lib ..\..\..\zlib\projects\visualc6\Win32_LIB_Release\zlib.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /nodefaultlib:"msvcrt.lib" /pdbtype:sept
+# Begin Special Build Tool
+OutDir=.\Debug
+SOURCE="$(InputPath)"
+PostBuild_Cmds=$(outdir)\VisualPng.exe ..\..\contrib\pngsuite\basn6a16.png
+# End Special Build Tool
+
+!ENDIF 
+
+# Begin Target
+
+# Name "VisualPng - Win32 Release"
+# Name "VisualPng - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=.\PngFile.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\VisualPng.c
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=.\cexcept.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\PngFile.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\resource.h
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# Begin Source File
+
+SOURCE=.\VisualPng.ico
+# End Source File
+# Begin Source File
+
+SOURCE=.\VisualPng.rc
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/Engine/lib/lpng/contrib/visupng/VisualPng.dsw b/Engine/lib/lpng/contrib/visupng/VisualPng.dsw
new file mode 100644
index 000000000..17ad83ad3
--- /dev/null
+++ b/Engine/lib/lpng/contrib/visupng/VisualPng.dsw
@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "VisualPng"=.\VisualPng.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/Engine/lib/lpng/contrib/visupng/VisualPng.ico b/Engine/lib/lpng/contrib/visupng/VisualPng.ico
new file mode 100644
index 0000000000000000000000000000000000000000..68aa3719fb523eccd4c4a706e4198ca1be2b4c62
GIT binary patch
literal 766
zcmb_ayGjE=6ul!BJ4Il&5f%%#i;YeE0sqBX?6q(TQ7j^}<v?10VbiXK*cmJrWrHY0
zA!dpc7D2{ycPG(^jp(^^ALqVy29`)b(o_-Sd4*^VeiNEPcc6k+VFA>Bh9<%xts4i6
zkcy&!=Yp>fdCw6P!YMX?g~S3@L(=jS0+)s|N<R6S5r&)Qb!)g04N`MXQq7T*R)b~W
znk>iKlEgL>VOVf)WTfR)85V$RN>JwSV-vWY^X3AQl6o~-A`A21P`H#(L`ua<kb=M>
zC6p2|SPTx|B;lEdR<4J97z(@|!YJx7#d!1r3hTe|MU4Yo<afY7umtC-4d;3T=aM()
z)~BP%-RxmpUOv5)v&rtgAGNEa$M$f0ygxi$8VsbmKHjRzi|)-;zIT4xZ=DSC*L>P<
Ob-aH+fF44>&V2wPTAUpK

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/visupng/VisualPng.png b/Engine/lib/lpng/contrib/visupng/VisualPng.png
new file mode 100644
index 0000000000000000000000000000000000000000..c6aa80a9bfa275137e429498bc785cb2dbcdb382
GIT binary patch
literal 208
zcmeAS@N?(olHy`uVBq!ia0vp^3LwnL3?x0byx0z;SkfJR9T^xl_H+M9WCils0(?ST
zf%J9`j>RRx2|yNONswPKgTu2MX+Tbfr;B5V#O34!2UcDl9v_~y3Xga?K0NvO<H!Nc
z2bxC$Ry>|~WI+Z?ismL3#z>)ClO+n69&&Pt@)((moHOva6OfZ2FlX_Z0}8s!jvZ1^
zUz2uRL2<>QLkbEXTG%~o9y17?WOH!($Y?g1Vbg3Ozf`fCd_X%HJYD@<);T3K0RUGo
BL5BbU

literal 0
HcmV?d00001

diff --git a/Engine/lib/lpng/contrib/visupng/VisualPng.rc b/Engine/lib/lpng/contrib/visupng/VisualPng.rc
new file mode 100644
index 000000000..151c68c47
--- /dev/null
+++ b/Engine/lib/lpng/contrib/visupng/VisualPng.rc
@@ -0,0 +1,152 @@
+//Microsoft Developer Studio generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "afxres.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "#include ""afxres.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Menu
+//
+
+VISUALPNG MENU DISCARDABLE 
+BEGIN
+    POPUP "&File"
+    BEGIN
+        MENUITEM "&Open Image...\tCtrl+O",      IDM_FILE_OPEN
+        MENUITEM "Save &As...",                 IDM_FILE_SAVE
+        MENUITEM SEPARATOR
+        MENUITEM "&Next Image\tCtrl+N",         IDM_FILE_NEXT
+        MENUITEM "Pre&vious Image\tCtrl+V",     IDM_FILE_PREVIOUS
+        MENUITEM SEPARATOR
+        MENUITEM "E&xit\tAlt+X",                IDM_FILE_EXIT
+    END
+    POPUP "&Options"
+    BEGIN
+        MENUITEM "&Stretch",                    IDM_OPTIONS_STRETCH, CHECKED
+    END
+    POPUP "&Help"
+    BEGIN
+        MENUITEM "&About",                      IDM_HELP_ABOUT
+    END
+END
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Accelerator
+//
+
+VISUALPNG ACCELERATORS DISCARDABLE 
+BEGIN
+    "N",            IDM_FILE_NEXT,          VIRTKEY, CONTROL, NOINVERT
+    "O",            IDM_FILE_OPEN,          VIRTKEY, CONTROL, NOINVERT
+    "P",            IDM_FILE_PREVIOUS,      VIRTKEY, CONTROL, NOINVERT
+    "V",            IDM_FILE_PREVIOUS,      VIRTKEY, CONTROL, NOINVERT
+    "X",            IDM_FILE_EXIT,          VIRTKEY, ALT, NOINVERT
+END
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Icon
+//
+
+// Icon with lowest ID value placed first to ensure application icon
+// remains consistent on all systems.
+VISUALPNG               ICON    DISCARDABLE     "VisualPng.ico"
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Dialog
+//
+
+ABOUTBOX DIALOG DISCARDABLE  0, 0, 186, 94
+STYLE DS_MODALFRAME | WS_POPUP
+FONT 8, "MS Sans Serif"
+BEGIN
+    DEFPUSHBUTTON   "OK",IDOK,68,67,50,14
+    CTEXT           "VisualPng 1.0  -  June 2000",IDC_STATIC,49,14,88,8
+    LTEXT           "a PNG image viewer",IDC_STATIC,60,30,66,8
+    LTEXT           "(c) Willem van Schaik, 2000",IDC_STATIC,48,52,90,8
+    LTEXT           "to demonstrate the use of libpng in Visual C",
+                    IDC_STATIC,25,38,136,8
+END
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// DESIGNINFO
+//
+
+#ifdef APSTUDIO_INVOKED
+GUIDELINES DESIGNINFO DISCARDABLE 
+BEGIN
+    "ABOUTBOX", DIALOG
+    BEGIN
+        LEFTMARGIN, 7
+        RIGHTMARGIN, 179
+        TOPMARGIN, 7
+        BOTTOMMARGIN, 87
+    END
+END
+#endif    // APSTUDIO_INVOKED
+
+#endif    // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+
diff --git a/Engine/lib/lpng/contrib/visupng/cexcept.h b/Engine/lib/lpng/contrib/visupng/cexcept.h
new file mode 100644
index 000000000..5f45d7697
--- /dev/null
+++ b/Engine/lib/lpng/contrib/visupng/cexcept.h
@@ -0,0 +1,248 @@
+/*===
+cexcept.h 2.0.1 (2008-Jul-19-Sat)
+http://www.nicemice.net/cexcept/
+Adam M. Costello
+http://www.nicemice.net/amc/
+
+An interface for exception-handling in ANSI C (C89 and subsequent ISO
+standards), developed jointly with Cosmin Truta.
+
+    Copyright (c) 2000-2008 Adam M. Costello and Cosmin Truta.
+    This software may be modified only if its author and version
+    information is updated accurately, and may be redistributed
+    only if accompanied by this unaltered notice.  Subject to those
+    restrictions, permission is granted to anyone to do anything
+    with this software.  The copyright holders make no guarantees
+    regarding this software, and are not responsible for any damage
+    resulting from its use.
+
+The cexcept interface is not compatible with and cannot interact
+with system exceptions (like division by zero or memory segmentation
+violation), compiler-generated exceptions (like C++ exceptions), or
+other exception-handling interfaces.
+
+When using this interface across multiple .c files, do not include
+this header file directly.  Instead, create a wrapper header file that
+includes this header file and then invokes the define_exception_type
+macro (see below).  The .c files should then include that header file.
+
+The interface consists of one type, one well-known name, and six macros.
+
+
+define_exception_type(type_name);
+
+    This macro is used like an external declaration.  It specifies
+    the type of object that gets copied from the exception thrower to
+    the exception catcher.  The type_name can be any type that can be
+    assigned to, that is, a non-constant arithmetic type, struct, union,
+    or pointer.  Examples:
+
+        define_exception_type(int);
+
+        enum exception { out_of_memory, bad_arguments, disk_full };
+        define_exception_type(enum exception);
+
+        struct exception { int code; const char *msg; };
+        define_exception_type(struct exception);
+
+    Because throwing an exception causes the object to be copied (not
+    just once, but twice), programmers may wish to consider size when
+    choosing the exception type.
+
+
+struct exception_context;
+
+    This type may be used after the define_exception_type() macro has
+    been invoked.  A struct exception_context must be known to both
+    the thrower and the catcher.  It is expected that there be one
+    context for each thread that uses exceptions.  It would certainly
+    be dangerous for multiple threads to access the same context.
+    One thread can use multiple contexts, but that is likely to be
+    confusing and not typically useful.  The application can allocate
+    this structure in any way it pleases--automatic, static, or dynamic.
+    The application programmer should pretend not to know the structure
+    members, which are subject to change.
+
+
+struct exception_context *the_exception_context;
+
+    The Try/Catch and Throw statements (described below) implicitly
+    refer to a context, using the name the_exception_context.  It is
+    the application's responsibility to make sure that this name yields
+    the address of a mutable (non-constant) struct exception_context
+    wherever those statements are used.  Subject to that constraint, the
+    application may declare a variable of this name anywhere it likes
+    (inside a function, in a parameter list, or externally), and may
+    use whatever storage class specifiers (static, extern, etc) or type
+    qualifiers (const, volatile, etc) it likes.  Examples:
+
+        static struct exception_context
+          * const the_exception_context = &foo;
+
+        { struct exception_context *the_exception_context = bar; ... }
+
+        int blah(struct exception_context *the_exception_context, ...);
+
+        extern struct exception_context the_exception_context[1];
+
+    The last example illustrates a trick that avoids creating a pointer
+    object separate from the structure object.
+
+    The name could even be a macro, for example:
+
+        struct exception_context ec_array[numthreads];
+        #define the_exception_context (ec_array + thread_id)
+
+    Be aware that the_exception_context is used several times by the
+    Try/Catch/Throw macros, so it shouldn't be expensive or have side
+    effects.  The expansion must be a drop-in replacement for an
+    identifier, so it's safest to put parentheses around it.
+
+
+void init_exception_context(struct exception_context *ec);
+
+    For context structures allocated statically (by an external
+    definition or using the "static" keyword), the implicit
+    initialization to all zeros is sufficient, but contexts allocated
+    by other means must be initialized using this macro before they
+    are used by a Try/Catch statement.  It does no harm to initialize
+    a context more than once (by using this macro on a statically
+    allocated context, or using this macro twice on the same context),
+    but a context must not be re-initialized after it has been used by a
+    Try/Catch statement.
+
+
+Try statement
+Catch (expression) statement
+
+    The Try/Catch/Throw macros are capitalized in order to avoid
+    confusion with the C++ keywords, which have subtly different
+    semantics.
+
+    A Try/Catch statement has a syntax similar to an if/else statement,
+    except that the parenthesized expression goes after the second
+    keyword rather than the first.  As with if/else, there are two
+    clauses, each of which may be a simple statement ending with a
+    semicolon or a brace-enclosed compound statement.  But whereas
+    the else clause is optional, the Catch clause is required.  The
+    expression must be a modifiable lvalue (something capable of being
+    assigned to) of the same type (disregarding type qualifiers) that
+    was passed to define_exception_type().
+
+    If a Throw that uses the same exception context as the Try/Catch is
+    executed within the Try clause (typically within a function called
+    by the Try clause), and the exception is not caught by a nested
+    Try/Catch statement, then a copy of the exception will be assigned
+    to the expression, and control will jump to the Catch clause.  If no
+    such Throw is executed, then the assignment is not performed, and
+    the Catch clause is not executed.
+
+    The expression is not evaluated unless and until the exception is
+    caught, which is significant if it has side effects, for example:
+
+        Try foo();
+        Catch (p[++i].e) { ... }
+
+    IMPORTANT: Jumping into or out of a Try clause (for example via
+    return, break, continue, goto, longjmp) is forbidden--the compiler
+    will not complain, but bad things will happen at run-time.  Jumping
+    into or out of a Catch clause is okay, and so is jumping around
+    inside a Try clause.  In many cases where one is tempted to return
+    from a Try clause, it will suffice to use Throw, and then return
+    from the Catch clause.  Another option is to set a flag variable and
+    use goto to jump to the end of the Try clause, then check the flag
+    after the Try/Catch statement.
+
+    IMPORTANT: The values of any non-volatile automatic variables
+    changed within the Try clause are undefined after an exception is
+    caught.  Therefore, variables modified inside the Try block whose
+    values are needed later outside the Try block must either use static
+    storage or be declared with the "volatile" type qualifier.
+
+
+Throw expression;
+
+    A Throw statement is very much like a return statement, except that
+    the expression is required.  Whereas return jumps back to the place
+    where the current function was called, Throw jumps back to the Catch
+    clause of the innermost enclosing Try clause.  The expression must
+    be compatible with the type passed to define_exception_type().  The
+    exception must be caught, otherwise the program may crash.
+
+    Slight limitation:  If the expression is a comma-expression, it must
+    be enclosed in parentheses.
+
+
+Try statement
+Catch_anonymous statement
+
+    When the value of the exception is not needed, a Try/Catch statement
+    can use Catch_anonymous instead of Catch (expression).
+
+
+Everything below this point is for the benefit of the compiler.  The
+application programmer should pretend not to know any of it, because it
+is subject to change.
+
+===*/
+
+
+#ifndef CEXCEPT_H
+#define CEXCEPT_H
+
+
+#include <setjmp.h>
+
+#define define_exception_type(etype) \
+struct exception_context { \
+  jmp_buf *penv; \
+  int caught; \
+  volatile struct { etype etmp; } v; \
+}
+
+/* etmp must be volatile because the application might use automatic */
+/* storage for the_exception_context, and etmp is modified between   */
+/* the calls to setjmp() and longjmp().  A wrapper struct is used to */
+/* avoid warnings about a duplicate volatile qualifier in case etype */
+/* already includes it.                                              */
+
+#define init_exception_context(ec) ((void)((ec)->penv = 0))
+
+#define Try \
+  { \
+    jmp_buf *exception__prev, exception__env; \
+    exception__prev = the_exception_context->penv; \
+    the_exception_context->penv = &exception__env; \
+    if (setjmp(exception__env) == 0) { \
+      do
+
+#define exception__catch(action) \
+      while (the_exception_context->caught = 0, \
+             the_exception_context->caught); \
+    } \
+    else { \
+      the_exception_context->caught = 1; \
+    } \
+    the_exception_context->penv = exception__prev; \
+  } \
+  if (!the_exception_context->caught || action) { } \
+  else
+
+#define Catch(e) exception__catch(((e) = the_exception_context->v.etmp, 0))
+#define Catch_anonymous exception__catch(0)
+
+/* Try ends with do, and Catch begins with while(0) and ends with     */
+/* else, to ensure that Try/Catch syntax is similar to if/else        */
+/* syntax.                                                            */
+/*                                                                    */
+/* The 0 in while(0) is expressed as x=0,x in order to appease        */
+/* compilers that warn about constant expressions inside while().     */
+/* Most compilers should still recognize that the condition is always */
+/* false and avoid generating code for it.                            */
+
+#define Throw \
+  for (;; longjmp(*the_exception_context->penv, 1)) \
+    the_exception_context->v.etmp =
+
+
+#endif /* CEXCEPT_H */
diff --git a/Engine/lib/lpng/contrib/visupng/resource.h b/Engine/lib/lpng/contrib/visupng/resource.h
new file mode 100644
index 000000000..b62176d1d
--- /dev/null
+++ b/Engine/lib/lpng/contrib/visupng/resource.h
@@ -0,0 +1,23 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Developer Studio generated include file.
+// Used by VisualPng.rc
+//
+#define IDM_FILE_OPEN                   40001
+#define IDM_FILE_SAVE                   40002
+#define IDM_FILE_NEXT                   40003
+#define IDM_FILE_PREVIOUS               40004
+#define IDM_FILE_EXIT                   40005
+#define IDM_OPTIONS_BACKGROUND          40006
+#define IDM_OPTIONS_STRETCH             40007
+#define IDM_HELP_ABOUT                  40008
+
+// Next default values for new objects
+//
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        113
+#define _APS_NEXT_COMMAND_VALUE         40009
+#define _APS_NEXT_CONTROL_VALUE         1001
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif
diff --git a/Engine/lib/lpng/depcomp b/Engine/lib/lpng/depcomp
new file mode 100755
index 000000000..65cbf7093
--- /dev/null
+++ b/Engine/lib/lpng/depcomp
@@ -0,0 +1,791 @@
+#! /bin/sh
+# depcomp - compile a program generating dependencies as side-effects
+
+scriptversion=2018-03-07.03; # UTC
+
+# Copyright (C) 1999-2018 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# Originally written by Alexandre Oliva <oliva@dcc.unicamp.br>.
+
+case $1 in
+  '')
+    echo "$0: No command.  Try '$0 --help' for more information." 1>&2
+    exit 1;
+    ;;
+  -h | --h*)
+    cat <<\EOF
+Usage: depcomp [--help] [--version] PROGRAM [ARGS]
+
+Run PROGRAMS ARGS to compile a file, generating dependencies
+as side-effects.
+
+Environment variables:
+  depmode     Dependency tracking mode.
+  source      Source file read by 'PROGRAMS ARGS'.
+  object      Object file output by 'PROGRAMS ARGS'.
+  DEPDIR      directory where to store dependencies.
+  depfile     Dependency file to output.
+  tmpdepfile  Temporary file to use when outputting dependencies.
+  libtool     Whether libtool is used (yes/no).
+
+Report bugs to <bug-automake@gnu.org>.
+EOF
+    exit $?
+    ;;
+  -v | --v*)
+    echo "depcomp $scriptversion"
+    exit $?
+    ;;
+esac
+
+# Get the directory component of the given path, and save it in the
+# global variables '$dir'.  Note that this directory component will
+# be either empty or ending with a '/' character.  This is deliberate.
+set_dir_from ()
+{
+  case $1 in
+    */*) dir=`echo "$1" | sed -e 's|/[^/]*$|/|'`;;
+      *) dir=;;
+  esac
+}
+
+# Get the suffix-stripped basename of the given path, and save it the
+# global variable '$base'.
+set_base_from ()
+{
+  base=`echo "$1" | sed -e 's|^.*/||' -e 's/\.[^.]*$//'`
+}
+
+# If no dependency file was actually created by the compiler invocation,
+# we still have to create a dummy depfile, to avoid errors with the
+# Makefile "include basename.Plo" scheme.
+make_dummy_depfile ()
+{
+  echo "#dummy" > "$depfile"
+}
+
+# Factor out some common post-processing of the generated depfile.
+# Requires the auxiliary global variable '$tmpdepfile' to be set.
+aix_post_process_depfile ()
+{
+  # If the compiler actually managed to produce a dependency file,
+  # post-process it.
+  if test -f "$tmpdepfile"; then
+    # Each line is of the form 'foo.o: dependency.h'.
+    # Do two passes, one to just change these to
+    #   $object: dependency.h
+    # and one to simply output
+    #   dependency.h:
+    # which is needed to avoid the deleted-header problem.
+    { sed -e "s,^.*\.[$lower]*:,$object:," < "$tmpdepfile"
+      sed -e "s,^.*\.[$lower]*:[$tab ]*,," -e 's,$,:,' < "$tmpdepfile"
+    } > "$depfile"
+    rm -f "$tmpdepfile"
+  else
+    make_dummy_depfile
+  fi
+}
+
+# A tabulation character.
+tab='	'
+# A newline character.
+nl='
+'
+# Character ranges might be problematic outside the C locale.
+# These definitions help.
+upper=ABCDEFGHIJKLMNOPQRSTUVWXYZ
+lower=abcdefghijklmnopqrstuvwxyz
+digits=0123456789
+alpha=${upper}${lower}
+
+if test -z "$depmode" || test -z "$source" || test -z "$object"; then
+  echo "depcomp: Variables source, object and depmode must be set" 1>&2
+  exit 1
+fi
+
+# Dependencies for sub/bar.o or sub/bar.obj go into sub/.deps/bar.Po.
+depfile=${depfile-`echo "$object" |
+  sed 's|[^\\/]*$|'${DEPDIR-.deps}'/&|;s|\.\([^.]*\)$|.P\1|;s|Pobj$|Po|'`}
+tmpdepfile=${tmpdepfile-`echo "$depfile" | sed 's/\.\([^.]*\)$/.T\1/'`}
+
+rm -f "$tmpdepfile"
+
+# Avoid interferences from the environment.
+gccflag= dashmflag=
+
+# Some modes work just like other modes, but use different flags.  We
+# parameterize here, but still list the modes in the big case below,
+# to make depend.m4 easier to write.  Note that we *cannot* use a case
+# here, because this file can only contain one case statement.
+if test "$depmode" = hp; then
+  # HP compiler uses -M and no extra arg.
+  gccflag=-M
+  depmode=gcc
+fi
+
+if test "$depmode" = dashXmstdout; then
+  # This is just like dashmstdout with a different argument.
+  dashmflag=-xM
+  depmode=dashmstdout
+fi
+
+cygpath_u="cygpath -u -f -"
+if test "$depmode" = msvcmsys; then
+  # This is just like msvisualcpp but w/o cygpath translation.
+  # Just convert the backslash-escaped backslashes to single forward
+  # slashes to satisfy depend.m4
+  cygpath_u='sed s,\\\\,/,g'
+  depmode=msvisualcpp
+fi
+
+if test "$depmode" = msvc7msys; then
+  # This is just like msvc7 but w/o cygpath translation.
+  # Just convert the backslash-escaped backslashes to single forward
+  # slashes to satisfy depend.m4
+  cygpath_u='sed s,\\\\,/,g'
+  depmode=msvc7
+fi
+
+if test "$depmode" = xlc; then
+  # IBM C/C++ Compilers xlc/xlC can output gcc-like dependency information.
+  gccflag=-qmakedep=gcc,-MF
+  depmode=gcc
+fi
+
+case "$depmode" in
+gcc3)
+## gcc 3 implements dependency tracking that does exactly what
+## we want.  Yay!  Note: for some reason libtool 1.4 doesn't like
+## it if -MD -MP comes after the -MF stuff.  Hmm.
+## Unfortunately, FreeBSD c89 acceptance of flags depends upon
+## the command line argument order; so add the flags where they
+## appear in depend2.am.  Note that the slowdown incurred here
+## affects only configure: in makefiles, %FASTDEP% shortcuts this.
+  for arg
+  do
+    case $arg in
+    -c) set fnord "$@" -MT "$object" -MD -MP -MF "$tmpdepfile" "$arg" ;;
+    *)  set fnord "$@" "$arg" ;;
+    esac
+    shift # fnord
+    shift # $arg
+  done
+  "$@"
+  stat=$?
+  if test $stat -ne 0; then
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  mv "$tmpdepfile" "$depfile"
+  ;;
+
+gcc)
+## Note that this doesn't just cater to obsosete pre-3.x GCC compilers.
+## but also to in-use compilers like IMB xlc/xlC and the HP C compiler.
+## (see the conditional assignment to $gccflag above).
+## There are various ways to get dependency output from gcc.  Here's
+## why we pick this rather obscure method:
+## - Don't want to use -MD because we'd like the dependencies to end
+##   up in a subdir.  Having to rename by hand is ugly.
+##   (We might end up doing this anyway to support other compilers.)
+## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like
+##   -MM, not -M (despite what the docs say).  Also, it might not be
+##   supported by the other compilers which use the 'gcc' depmode.
+## - Using -M directly means running the compiler twice (even worse
+##   than renaming).
+  if test -z "$gccflag"; then
+    gccflag=-MD,
+  fi
+  "$@" -Wp,"$gccflag$tmpdepfile"
+  stat=$?
+  if test $stat -ne 0; then
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  rm -f "$depfile"
+  echo "$object : \\" > "$depfile"
+  # The second -e expression handles DOS-style file names with drive
+  # letters.
+  sed -e 's/^[^:]*: / /' \
+      -e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile"
+## This next piece of magic avoids the "deleted header file" problem.
+## The problem is that when a header file which appears in a .P file
+## is deleted, the dependency causes make to die (because there is
+## typically no way to rebuild the header).  We avoid this by adding
+## dummy dependencies for each header file.  Too bad gcc doesn't do
+## this for us directly.
+## Some versions of gcc put a space before the ':'.  On the theory
+## that the space means something, we add a space to the output as
+## well.  hp depmode also adds that space, but also prefixes the VPATH
+## to the object.  Take care to not repeat it in the output.
+## Some versions of the HPUX 10.20 sed can't process this invocation
+## correctly.  Breaking it into two sed invocations is a workaround.
+  tr ' ' "$nl" < "$tmpdepfile" \
+    | sed -e 's/^\\$//' -e '/^$/d' -e "s|.*$object$||" -e '/:$/d' \
+    | sed -e 's/$/ :/' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+hp)
+  # This case exists only to let depend.m4 do its work.  It works by
+  # looking at the text of this script.  This case will never be run,
+  # since it is checked for above.
+  exit 1
+  ;;
+
+sgi)
+  if test "$libtool" = yes; then
+    "$@" "-Wp,-MDupdate,$tmpdepfile"
+  else
+    "$@" -MDupdate "$tmpdepfile"
+  fi
+  stat=$?
+  if test $stat -ne 0; then
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  rm -f "$depfile"
+
+  if test -f "$tmpdepfile"; then  # yes, the sourcefile depend on other files
+    echo "$object : \\" > "$depfile"
+    # Clip off the initial element (the dependent).  Don't try to be
+    # clever and replace this with sed code, as IRIX sed won't handle
+    # lines with more than a fixed number of characters (4096 in
+    # IRIX 6.2 sed, 8192 in IRIX 6.5).  We also remove comment lines;
+    # the IRIX cc adds comments like '#:fec' to the end of the
+    # dependency line.
+    tr ' ' "$nl" < "$tmpdepfile" \
+      | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' \
+      | tr "$nl" ' ' >> "$depfile"
+    echo >> "$depfile"
+    # The second pass generates a dummy entry for each header file.
+    tr ' ' "$nl" < "$tmpdepfile" \
+      | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \
+      >> "$depfile"
+  else
+    make_dummy_depfile
+  fi
+  rm -f "$tmpdepfile"
+  ;;
+
+xlc)
+  # This case exists only to let depend.m4 do its work.  It works by
+  # looking at the text of this script.  This case will never be run,
+  # since it is checked for above.
+  exit 1
+  ;;
+
+aix)
+  # The C for AIX Compiler uses -M and outputs the dependencies
+  # in a .u file.  In older versions, this file always lives in the
+  # current directory.  Also, the AIX compiler puts '$object:' at the
+  # start of each line; $object doesn't have directory information.
+  # Version 6 uses the directory in both cases.
+  set_dir_from "$object"
+  set_base_from "$object"
+  if test "$libtool" = yes; then
+    tmpdepfile1=$dir$base.u
+    tmpdepfile2=$base.u
+    tmpdepfile3=$dir.libs/$base.u
+    "$@" -Wc,-M
+  else
+    tmpdepfile1=$dir$base.u
+    tmpdepfile2=$dir$base.u
+    tmpdepfile3=$dir$base.u
+    "$@" -M
+  fi
+  stat=$?
+  if test $stat -ne 0; then
+    rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+    exit $stat
+  fi
+
+  for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+  do
+    test -f "$tmpdepfile" && break
+  done
+  aix_post_process_depfile
+  ;;
+
+tcc)
+  # tcc (Tiny C Compiler) understand '-MD -MF file' since version 0.9.26
+  # FIXME: That version still under development at the moment of writing.
+  #        Make that this statement remains true also for stable, released
+  #        versions.
+  # It will wrap lines (doesn't matter whether long or short) with a
+  # trailing '\', as in:
+  #
+  #   foo.o : \
+  #    foo.c \
+  #    foo.h \
+  #
+  # It will put a trailing '\' even on the last line, and will use leading
+  # spaces rather than leading tabs (at least since its commit 0394caf7
+  # "Emit spaces for -MD").
+  "$@" -MD -MF "$tmpdepfile"
+  stat=$?
+  if test $stat -ne 0; then
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  rm -f "$depfile"
+  # Each non-empty line is of the form 'foo.o : \' or ' dep.h \'.
+  # We have to change lines of the first kind to '$object: \'.
+  sed -e "s|.*:|$object :|" < "$tmpdepfile" > "$depfile"
+  # And for each line of the second kind, we have to emit a 'dep.h:'
+  # dummy dependency, to avoid the deleted-header problem.
+  sed -n -e 's|^  *\(.*\) *\\$|\1:|p' < "$tmpdepfile" >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+## The order of this option in the case statement is important, since the
+## shell code in configure will try each of these formats in the order
+## listed in this file.  A plain '-MD' option would be understood by many
+## compilers, so we must ensure this comes after the gcc and icc options.
+pgcc)
+  # Portland's C compiler understands '-MD'.
+  # Will always output deps to 'file.d' where file is the root name of the
+  # source file under compilation, even if file resides in a subdirectory.
+  # The object file name does not affect the name of the '.d' file.
+  # pgcc 10.2 will output
+  #    foo.o: sub/foo.c sub/foo.h
+  # and will wrap long lines using '\' :
+  #    foo.o: sub/foo.c ... \
+  #     sub/foo.h ... \
+  #     ...
+  set_dir_from "$object"
+  # Use the source, not the object, to determine the base name, since
+  # that's sadly what pgcc will do too.
+  set_base_from "$source"
+  tmpdepfile=$base.d
+
+  # For projects that build the same source file twice into different object
+  # files, the pgcc approach of using the *source* file root name can cause
+  # problems in parallel builds.  Use a locking strategy to avoid stomping on
+  # the same $tmpdepfile.
+  lockdir=$base.d-lock
+  trap "
+    echo '$0: caught signal, cleaning up...' >&2
+    rmdir '$lockdir'
+    exit 1
+  " 1 2 13 15
+  numtries=100
+  i=$numtries
+  while test $i -gt 0; do
+    # mkdir is a portable test-and-set.
+    if mkdir "$lockdir" 2>/dev/null; then
+      # This process acquired the lock.
+      "$@" -MD
+      stat=$?
+      # Release the lock.
+      rmdir "$lockdir"
+      break
+    else
+      # If the lock is being held by a different process, wait
+      # until the winning process is done or we timeout.
+      while test -d "$lockdir" && test $i -gt 0; do
+        sleep 1
+        i=`expr $i - 1`
+      done
+    fi
+    i=`expr $i - 1`
+  done
+  trap - 1 2 13 15
+  if test $i -le 0; then
+    echo "$0: failed to acquire lock after $numtries attempts" >&2
+    echo "$0: check lockdir '$lockdir'" >&2
+    exit 1
+  fi
+
+  if test $stat -ne 0; then
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  rm -f "$depfile"
+  # Each line is of the form `foo.o: dependent.h',
+  # or `foo.o: dep1.h dep2.h \', or ` dep3.h dep4.h \'.
+  # Do two passes, one to just change these to
+  # `$object: dependent.h' and one to simply `dependent.h:'.
+  sed "s,^[^:]*:,$object :," < "$tmpdepfile" > "$depfile"
+  # Some versions of the HPUX 10.20 sed can't process this invocation
+  # correctly.  Breaking it into two sed invocations is a workaround.
+  sed 's,^[^:]*: \(.*\)$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" \
+    | sed -e 's/$/ :/' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+hp2)
+  # The "hp" stanza above does not work with aCC (C++) and HP's ia64
+  # compilers, which have integrated preprocessors.  The correct option
+  # to use with these is +Maked; it writes dependencies to a file named
+  # 'foo.d', which lands next to the object file, wherever that
+  # happens to be.
+  # Much of this is similar to the tru64 case; see comments there.
+  set_dir_from  "$object"
+  set_base_from "$object"
+  if test "$libtool" = yes; then
+    tmpdepfile1=$dir$base.d
+    tmpdepfile2=$dir.libs/$base.d
+    "$@" -Wc,+Maked
+  else
+    tmpdepfile1=$dir$base.d
+    tmpdepfile2=$dir$base.d
+    "$@" +Maked
+  fi
+  stat=$?
+  if test $stat -ne 0; then
+     rm -f "$tmpdepfile1" "$tmpdepfile2"
+     exit $stat
+  fi
+
+  for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2"
+  do
+    test -f "$tmpdepfile" && break
+  done
+  if test -f "$tmpdepfile"; then
+    sed -e "s,^.*\.[$lower]*:,$object:," "$tmpdepfile" > "$depfile"
+    # Add 'dependent.h:' lines.
+    sed -ne '2,${
+               s/^ *//
+               s/ \\*$//
+               s/$/:/
+               p
+             }' "$tmpdepfile" >> "$depfile"
+  else
+    make_dummy_depfile
+  fi
+  rm -f "$tmpdepfile" "$tmpdepfile2"
+  ;;
+
+tru64)
+  # The Tru64 compiler uses -MD to generate dependencies as a side
+  # effect.  'cc -MD -o foo.o ...' puts the dependencies into 'foo.o.d'.
+  # At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put
+  # dependencies in 'foo.d' instead, so we check for that too.
+  # Subdirectories are respected.
+  set_dir_from  "$object"
+  set_base_from "$object"
+
+  if test "$libtool" = yes; then
+    # Libtool generates 2 separate objects for the 2 libraries.  These
+    # two compilations output dependencies in $dir.libs/$base.o.d and
+    # in $dir$base.o.d.  We have to check for both files, because
+    # one of the two compilations can be disabled.  We should prefer
+    # $dir$base.o.d over $dir.libs/$base.o.d because the latter is
+    # automatically cleaned when .libs/ is deleted, while ignoring
+    # the former would cause a distcleancheck panic.
+    tmpdepfile1=$dir$base.o.d          # libtool 1.5
+    tmpdepfile2=$dir.libs/$base.o.d    # Likewise.
+    tmpdepfile3=$dir.libs/$base.d      # Compaq CCC V6.2-504
+    "$@" -Wc,-MD
+  else
+    tmpdepfile1=$dir$base.d
+    tmpdepfile2=$dir$base.d
+    tmpdepfile3=$dir$base.d
+    "$@" -MD
+  fi
+
+  stat=$?
+  if test $stat -ne 0; then
+    rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+    exit $stat
+  fi
+
+  for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+  do
+    test -f "$tmpdepfile" && break
+  done
+  # Same post-processing that is required for AIX mode.
+  aix_post_process_depfile
+  ;;
+
+msvc7)
+  if test "$libtool" = yes; then
+    showIncludes=-Wc,-showIncludes
+  else
+    showIncludes=-showIncludes
+  fi
+  "$@" $showIncludes > "$tmpdepfile"
+  stat=$?
+  grep -v '^Note: including file: ' "$tmpdepfile"
+  if test $stat -ne 0; then
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  rm -f "$depfile"
+  echo "$object : \\" > "$depfile"
+  # The first sed program below extracts the file names and escapes
+  # backslashes for cygpath.  The second sed program outputs the file
+  # name when reading, but also accumulates all include files in the
+  # hold buffer in order to output them again at the end.  This only
+  # works with sed implementations that can handle large buffers.
+  sed < "$tmpdepfile" -n '
+/^Note: including file:  *\(.*\)/ {
+  s//\1/
+  s/\\/\\\\/g
+  p
+}' | $cygpath_u | sort -u | sed -n '
+s/ /\\ /g
+s/\(.*\)/'"$tab"'\1 \\/p
+s/.\(.*\) \\/\1:/
+H
+$ {
+  s/.*/'"$tab"'/
+  G
+  p
+}' >> "$depfile"
+  echo >> "$depfile" # make sure the fragment doesn't end with a backslash
+  rm -f "$tmpdepfile"
+  ;;
+
+msvc7msys)
+  # This case exists only to let depend.m4 do its work.  It works by
+  # looking at the text of this script.  This case will never be run,
+  # since it is checked for above.
+  exit 1
+  ;;
+
+#nosideeffect)
+  # This comment above is used by automake to tell side-effect
+  # dependency tracking mechanisms from slower ones.
+
+dashmstdout)
+  # Important note: in order to support this mode, a compiler *must*
+  # always write the preprocessed file to stdout, regardless of -o.
+  "$@" || exit $?
+
+  # Remove the call to Libtool.
+  if test "$libtool" = yes; then
+    while test "X$1" != 'X--mode=compile'; do
+      shift
+    done
+    shift
+  fi
+
+  # Remove '-o $object'.
+  IFS=" "
+  for arg
+  do
+    case $arg in
+    -o)
+      shift
+      ;;
+    $object)
+      shift
+      ;;
+    *)
+      set fnord "$@" "$arg"
+      shift # fnord
+      shift # $arg
+      ;;
+    esac
+  done
+
+  test -z "$dashmflag" && dashmflag=-M
+  # Require at least two characters before searching for ':'
+  # in the target name.  This is to cope with DOS-style filenames:
+  # a dependency such as 'c:/foo/bar' could be seen as target 'c' otherwise.
+  "$@" $dashmflag |
+    sed "s|^[$tab ]*[^:$tab ][^:][^:]*:[$tab ]*|$object: |" > "$tmpdepfile"
+  rm -f "$depfile"
+  cat < "$tmpdepfile" > "$depfile"
+  # Some versions of the HPUX 10.20 sed can't process this sed invocation
+  # correctly.  Breaking it into two sed invocations is a workaround.
+  tr ' ' "$nl" < "$tmpdepfile" \
+    | sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \
+    | sed -e 's/$/ :/' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+dashXmstdout)
+  # This case only exists to satisfy depend.m4.  It is never actually
+  # run, as this mode is specially recognized in the preamble.
+  exit 1
+  ;;
+
+makedepend)
+  "$@" || exit $?
+  # Remove any Libtool call
+  if test "$libtool" = yes; then
+    while test "X$1" != 'X--mode=compile'; do
+      shift
+    done
+    shift
+  fi
+  # X makedepend
+  shift
+  cleared=no eat=no
+  for arg
+  do
+    case $cleared in
+    no)
+      set ""; shift
+      cleared=yes ;;
+    esac
+    if test $eat = yes; then
+      eat=no
+      continue
+    fi
+    case "$arg" in
+    -D*|-I*)
+      set fnord "$@" "$arg"; shift ;;
+    # Strip any option that makedepend may not understand.  Remove
+    # the object too, otherwise makedepend will parse it as a source file.
+    -arch)
+      eat=yes ;;
+    -*|$object)
+      ;;
+    *)
+      set fnord "$@" "$arg"; shift ;;
+    esac
+  done
+  obj_suffix=`echo "$object" | sed 's/^.*\././'`
+  touch "$tmpdepfile"
+  ${MAKEDEPEND-makedepend} -o"$obj_suffix" -f"$tmpdepfile" "$@"
+  rm -f "$depfile"
+  # makedepend may prepend the VPATH from the source file name to the object.
+  # No need to regex-escape $object, excess matching of '.' is harmless.
+  sed "s|^.*\($object *:\)|\1|" "$tmpdepfile" > "$depfile"
+  # Some versions of the HPUX 10.20 sed can't process the last invocation
+  # correctly.  Breaking it into two sed invocations is a workaround.
+  sed '1,2d' "$tmpdepfile" \
+    | tr ' ' "$nl" \
+    | sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \
+    | sed -e 's/$/ :/' >> "$depfile"
+  rm -f "$tmpdepfile" "$tmpdepfile".bak
+  ;;
+
+cpp)
+  # Important note: in order to support this mode, a compiler *must*
+  # always write the preprocessed file to stdout.
+  "$@" || exit $?
+
+  # Remove the call to Libtool.
+  if test "$libtool" = yes; then
+    while test "X$1" != 'X--mode=compile'; do
+      shift
+    done
+    shift
+  fi
+
+  # Remove '-o $object'.
+  IFS=" "
+  for arg
+  do
+    case $arg in
+    -o)
+      shift
+      ;;
+    $object)
+      shift
+      ;;
+    *)
+      set fnord "$@" "$arg"
+      shift # fnord
+      shift # $arg
+      ;;
+    esac
+  done
+
+  "$@" -E \
+    | sed -n -e '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
+             -e '/^#line [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
+    | sed '$ s: \\$::' > "$tmpdepfile"
+  rm -f "$depfile"
+  echo "$object : \\" > "$depfile"
+  cat < "$tmpdepfile" >> "$depfile"
+  sed < "$tmpdepfile" '/^$/d;s/^ //;s/ \\$//;s/$/ :/' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+msvisualcpp)
+  # Important note: in order to support this mode, a compiler *must*
+  # always write the preprocessed file to stdout.
+  "$@" || exit $?
+
+  # Remove the call to Libtool.
+  if test "$libtool" = yes; then
+    while test "X$1" != 'X--mode=compile'; do
+      shift
+    done
+    shift
+  fi
+
+  IFS=" "
+  for arg
+  do
+    case "$arg" in
+    -o)
+      shift
+      ;;
+    $object)
+      shift
+      ;;
+    "-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI")
+        set fnord "$@"
+        shift
+        shift
+        ;;
+    *)
+        set fnord "$@" "$arg"
+        shift
+        shift
+        ;;
+    esac
+  done
+  "$@" -E 2>/dev/null |
+  sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::\1:p' | $cygpath_u | sort -u > "$tmpdepfile"
+  rm -f "$depfile"
+  echo "$object : \\" > "$depfile"
+  sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::'"$tab"'\1 \\:p' >> "$depfile"
+  echo "$tab" >> "$depfile"
+  sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::\1\::p' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+msvcmsys)
+  # This case exists only to let depend.m4 do its work.  It works by
+  # looking at the text of this script.  This case will never be run,
+  # since it is checked for above.
+  exit 1
+  ;;
+
+none)
+  exec "$@"
+  ;;
+
+*)
+  echo "Unknown depmode $depmode" 1>&2
+  exit 1
+  ;;
+esac
+
+exit 0
+
+# Local Variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'before-save-hook 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC0"
+# time-stamp-end: "; # UTC"
+# End:
diff --git a/Engine/lib/lpng/example.c b/Engine/lib/lpng/example.c
index 99d2f054a..2e2afaafb 100644
--- a/Engine/lib/lpng/example.c
+++ b/Engine/lib/lpng/example.c
@@ -2,18 +2,20 @@
 #if 0 /* in case someone actually tries to compile this */
 
 /* example.c - an example of using libpng
- * Last changed in libpng 1.6.24 [August 4, 2016]
+ *
+ * Maintained 2018 Cosmin Truta
  * Maintained 1998-2016 Glenn Randers-Pehrson
- * Maintained 1996, 1997 Andreas Dilger)
- * Written 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ * Maintained 1996-1997 Andreas Dilger
+ * Written 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
  * To the extent possible under law, the authors have waived
  * all copyright and related or neighboring rights to this file.
- * This work is published from: United States.
+ * This work is published from: United States, Canada.
  */
 
 /* This is an example of how to use libpng to read and write PNG files.
- * The file libpng-manual.txt is much more verbose then this.  If you have not
- * read it, do so first.  This was designed to be a starting point of an
+ * The file libpng-manual.txt is much more verbose then this.  If you have
+ * not read it, do so first.  This was designed to be a starting point of an
  * implementation.  This is not officially part of libpng, is hereby placed
  * in the public domain, and therefore does not require a copyright notice.
  *
@@ -24,16 +26,17 @@
  * see also the programs in the contrib directory.
  */
 
-/* The simple, but restricted, approach to reading a PNG file or data stream
- * just requires two function calls, as in the following complete program.
- * Writing a file just needs one function call, so long as the data has an
+/* The simple, but restricted approach to reading a PNG file or data stream
+ * requires just two function calls, as in the following complete program.
+ * Writing a file needs just one function call, so long as the data has an
  * appropriate layout.
  *
  * The following code reads PNG image data from a file and writes it, in a
- * potentially new format, to a new file.  While this code will compile there is
- * minimal (insufficient) error checking; for a more realistic version look at
- * contrib/examples/pngtopng.c
+ * potentially new format, to a new file.  While this code will compile, there
+ * is minimal (insufficient) error checking.  For a more realistic version,
+ * see contrib/examples/pngtopng.c
  */
+
 #include <stddef.h>
 #include <stdlib.h>
 #include <string.h>
@@ -68,28 +71,28 @@ int main(int argc, const char **argv)
           */
          buffer = malloc(PNG_IMAGE_SIZE(image));
 
-         /* If enough memory was available read the image in the desired format
-          * then write the result out to the new file.  'background' is not
-          * necessary when reading the image because the alpha channel is
+         /* If enough memory was available, read the image in the desired
+          * format, then write the result out to the new file.  'background' is
+          * not necessary when reading the image, because the alpha channel is
           * preserved; if it were to be removed, for example if we requested
           * PNG_FORMAT_RGB, then either a solid background color would have to
-          * be supplied or the output buffer would have to be initialized to the
-          * actual background of the image.
+          * be supplied, or the output buffer would have to be initialized to
+          * the actual background of the image.
           *
           * The fourth argument to png_image_finish_read is the 'row_stride' -
           * this is the number of components allocated for the image in each
           * row.  It has to be at least as big as the value returned by
           * PNG_IMAGE_ROW_STRIDE, but if you just allocate space for the
-          * default, minimum, size using PNG_IMAGE_SIZE as above you can pass
+          * default, minimum size, using PNG_IMAGE_SIZE as above, you can pass
           * zero.
           *
           * The final argument is a pointer to a buffer for the colormap;
-          * colormaps have exactly the same format as a row of image pixels (so
-          * you choose what format to make the colormap by setting
+          * colormaps have exactly the same format as a row of image pixels
+          * (so you choose what format to make the colormap by setting
           * image.format).  A colormap is only returned if
           * PNG_FORMAT_FLAG_COLORMAP is also set in image.format, so in this
           * case NULL is passed as the final argument.  If you do want to force
-          * all images into an index/color-mapped format then you can use:
+          * all images into an index/color-mapped format, then you can use:
           *
           *    PNG_IMAGE_COLORMAP_SIZE(image)
           *
@@ -111,17 +114,15 @@ int main(int argc, const char **argv)
                exit(0);
             }
          }
-
          else
          {
             /* Calling png_image_free is optional unless the simplified API was
-             * not run to completion.  In this case if there wasn't enough
-             * memory for 'buffer' we didn't complete the read, so we must free
-             * the image:
+             * not run to completion.  In this case, if there wasn't enough
+             * memory for 'buffer', we didn't complete the read, so we must
+             * free the image:
              */
             if (buffer == NULL)
                png_image_free(&image);
-
             else
                free(buffer);
       }
@@ -130,65 +131,67 @@ int main(int argc, const char **argv)
        * textual message in the 'png_image' structure:
        */
       fprintf(stderr, "pngtopng: error: %s\n", image.message);
-      exit (1);
+      exit(1);
    }
 
    fprintf(stderr, "pngtopng: usage: pngtopng input-file output-file\n");
-   exit(1);
+   exit(2);
 }
 
 /* That's it ;-)  Of course you probably want to do more with PNG files than
  * just converting them all to 32-bit RGBA PNG files; you can do that between
  * the call to png_image_finish_read and png_image_write_to_file.  You can also
- * ask for the image data to be presented in a number of different formats.  You
- * do this by simply changing the 'format' parameter set before allocating the
- * buffer.
+ * ask for the image data to be presented in a number of different formats.
+ * You do this by simply changing the 'format' parameter set before allocating
+ * the buffer.
  *
  * The format parameter consists of five flags that define various aspects of
- * the image, you can simply add these together to get the format or you can use
- * one of the predefined macros from png.h (as above):
+ * the image.  You can simply add these together to get the format, or you can
+ * use one of the predefined macros from png.h (as above):
  *
- * PNG_FORMAT_FLAG_COLOR: if set the image will have three color components per
- *    pixel (red, green and blue), if not set the image will just have one
+ * PNG_FORMAT_FLAG_COLOR: if set, the image will have three color components
+ *    per pixel (red, green and blue); if not set, the image will just have one
  *    luminance (grayscale) component.
  *
- * PNG_FORMAT_FLAG_ALPHA: if set each pixel in the image will have an additional
- *    alpha value; a linear value that describes the degree the image pixel
- *    covers (overwrites) the contents of the existing pixel on the display.
+ * PNG_FORMAT_FLAG_ALPHA: if set, each pixel in the image will have an
+ *    additional alpha value; a linear value that describes the degree the
+ *    image pixel covers (overwrites) the contents of the existing pixel on the
+ *    display.
  *
- * PNG_FORMAT_FLAG_LINEAR: if set the components of each pixel will be returned
- *    as a series of 16-bit linear values, if not set the components will be
- *    returned as a series of 8-bit values encoded according to the 'sRGB'
- *    standard.  The 8-bit format is the normal format for images intended for
- *    direct display, because almost all display devices do the inverse of the
- *    sRGB transformation to the data they receive.  The 16-bit format is more
- *    common for scientific data and image data that must be further processed;
- *    because it is linear simple math can be done on the component values.
- *    Regardless of the setting of this flag the alpha channel is always linear,
- *    although it will be 8 bits or 16 bits wide as specified by the flag.
+ * PNG_FORMAT_FLAG_LINEAR: if set, the components of each pixel will be
+ *    returned as a series of 16-bit linear values; if not set, the components
+ *    will be returned as a series of 8-bit values encoded according to the
+ *    sRGB standard.  The 8-bit format is the normal format for images intended
+ *    for direct display, because almost all display devices do the inverse of
+ *    the sRGB transformation to the data they receive.  The 16-bit format is
+ *    more common for scientific data and image data that must be further
+ *    processed; because it is linear, simple math can be done on the component
+ *    values.  Regardless of the setting of this flag, the alpha channel is
+ *    always linear, although it will be 8 bits or 16 bits wide as specified by
+ *    the flag.
  *
- * PNG_FORMAT_FLAG_BGR: if set the components of a color pixel will be returned
- *    in the order blue, then green, then red.  If not set the pixel components
- *    are in the order red, then green, then blue.
+ * PNG_FORMAT_FLAG_BGR: if set, the components of a color pixel will be
+ *    returned in the order blue, then green, then red.  If not set, the pixel
+ *    components are in the order red, then green, then blue.
  *
- * PNG_FORMAT_FLAG_AFIRST: if set the alpha channel (if present) precedes the
- *    color or grayscale components.  If not set the alpha channel follows the
+ * PNG_FORMAT_FLAG_AFIRST: if set, the alpha channel (if present) precedes the
+ *    color or grayscale components.  If not set, the alpha channel follows the
  *    components.
  *
  * You do not have to read directly from a file.  You can read from memory or,
  * on systems that support it, from a <stdio.h> FILE*.  This is controlled by
- * the particular png_image_read_from_ function you call at the start.  Likewise
- * on write you can write to a FILE* if your system supports it.  Check the
- * macro PNG_STDIO_SUPPORTED to see if stdio support has been included in your
- * libpng build.
+ * the particular png_image_read_from_ function you call at the start.
+ * Likewise, on write, you can write to a FILE* if your system supports it.
+ * Check the macro PNG_STDIO_SUPPORTED to see if stdio support has been
+ * included in your libpng build.
  *
- * If you read 16-bit (PNG_FORMAT_FLAG_LINEAR) data you may need to write it in
- * the 8-bit format for display.  You do this by setting the convert_to_8bit
+ * If you read 16-bit (PNG_FORMAT_FLAG_LINEAR) data, you may need to write it
+ * in the 8-bit format for display.  You do this by setting the convert_to_8bit
  * flag to 'true'.
  *
  * Don't repeatedly convert between the 8-bit and 16-bit forms.  There is
- * significant data loss when 16-bit data is converted to the 8-bit encoding and
- * the current libpng implementation of conversion to 16-bit is also
+ * significant data loss when 16-bit data is converted to the 8-bit encoding,
+ * and the current libpng implementation of conversion to 16-bit is also
  * significantly lossy.  The latter will be fixed in the future, but the former
  * is unavoidable - the 8-bit format just doesn't have enough resolution.
  */
@@ -199,10 +202,10 @@ int main(int argc, const char **argv)
  * interfaces.
  *
  * All these interfaces require that you do your own error handling - your
- * program must be able to arrange for control to return to your own code any
- * time libpng encounters a problem.  There are several ways to do this, but the
- * standard way is to use the ANSI-C (C90) <setjmp.h> interface to establish a
- * return point within your own code.  You must do this if you do not use the
+ * program must be able to arrange for control to return to your own code, any
+ * time libpng encounters a problem.  There are several ways to do this, but
+ * the standard way is to use the <setjmp.h> interface to establish a return
+ * point within your own code.  You must do this if you do not use the
  * simplified interface (above).
  *
  * The first step is to include the header files you need, including the libpng
@@ -214,7 +217,7 @@ int main(int argc, const char **argv)
  /* The png_jmpbuf() macro, used in error handling, became available in
   * libpng version 1.0.6.  If you want to be able to run your code with older
   * versions of libpng, you must define the macro yourself (but only if it
-  * is not already defined by libpng!).
+  * is not already defined by libpng!)
   */
 
 #ifndef png_jmpbuf
@@ -222,10 +225,10 @@ int main(int argc, const char **argv)
 #endif
 
 /* Check to see if a file is a PNG file using png_sig_cmp().  png_sig_cmp()
- * returns zero if the image is a PNG and nonzero if it isn't a PNG.
+ * returns zero if the image is a PNG, and nonzero otherwise.
  *
  * The function check_if_png() shown here, but not used, returns nonzero (true)
- * if the file can be opened and is a PNG, 0 (false) otherwise.
+ * if the file can be opened and is a PNG, and 0 (false) otherwise.
  *
  * If this call is successful, and you are going to keep the file open,
  * you should call png_set_sig_bytes(png_ptr, PNG_BYTES_TO_CHECK); once
@@ -238,7 +241,7 @@ int main(int argc, const char **argv)
  *
  * Many applications already read the first 2 or 4 bytes from the start
  * of the image to determine the file type, so it would be easiest just
- * to pass the bytes to png_sig_cmp() or even skip that if you know
+ * to pass the bytes to png_sig_cmp(), or even skip that if you know
  * you have a PNG file, and call png_set_sig_bytes().
  */
 #define PNG_BYTES_TO_CHECK 4
@@ -250,14 +253,14 @@ int check_if_png(char *file_name, FILE **fp)
    if ((*fp = fopen(file_name, "rb")) == NULL)
       return 0;
 
-   /* Read in some of the signature bytes */
+   /* Read in some of the signature bytes. */
    if (fread(buf, 1, PNG_BYTES_TO_CHECK, *fp) != PNG_BYTES_TO_CHECK)
       return 0;
 
    /* Compare the first PNG_BYTES_TO_CHECK bytes of the signature.
-      Return nonzero (true) if they match */
-
-   return(!png_sig_cmp(buf, (png_size_t)0, PNG_BYTES_TO_CHECK));
+    * Return nonzero (true) if they match.
+    */
+   return(!png_sig_cmp(buf, 0, PNG_BYTES_TO_CHECK));
 }
 
 /* Read a PNG file.  You may want to return an error code if the read
@@ -267,7 +270,7 @@ int check_if_png(char *file_name, FILE **fp)
  * some or all of the magic bytes read - see comments above).
  */
 #ifdef open_file /* prototype 1 */
-void read_png(char *file_name)  /* We need to open the file */
+void read_png(char *file_name) /* We need to open the file */
 {
    png_structp png_ptr;
    png_infop info_ptr;
@@ -280,7 +283,7 @@ void read_png(char *file_name)  /* We need to open the file */
       return (ERROR);
 
 #else no_open_file /* prototype 2 */
-void read_png(FILE *fp, int sig_read)  /* File is already open */
+void read_png(FILE *fp, int sig_read) /* File is already open */
 {
    png_structp png_ptr;
    png_infop info_ptr;
@@ -292,7 +295,7 @@ void read_png(FILE *fp, int sig_read)  /* File is already open */
     * functions.  If you want to use the default stderr and longjump method,
     * you can supply NULL for the last three parameters.  We also supply the
     * the compiler header file version, so that we know if the application
-    * was compiled with a compatible version of the library.  REQUIRED
+    * was compiled with a compatible version of the library.  REQUIRED.
     */
    png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
        png_voidp user_error_ptr, user_error_fn, user_warning_fn);
@@ -316,35 +319,33 @@ void read_png(FILE *fp, int sig_read)  /* File is already open */
     * the normal method of doing things with libpng).  REQUIRED unless you
     * set up your own error handlers in the png_create_read_struct() earlier.
     */
-
    if (setjmp(png_jmpbuf(png_ptr)))
    {
-      /* Free all of the memory associated with the png_ptr and info_ptr */
+      /* Free all of the memory associated with the png_ptr and info_ptr. */
       png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
       fclose(fp);
-      /* If we get here, we had a problem reading the file */
+      /* If we get here, we had a problem reading the file. */
       return (ERROR);
    }
 
-   /* One of the following I/O initialization methods is REQUIRED */
+   /* One of the following I/O initialization methods is REQUIRED. */
 #ifdef streams /* PNG file I/O method 1 */
-   /* Set up the input control if you are using standard C streams */
+   /* Set up the input control if you are using standard C streams. */
    png_init_io(png_ptr, fp);
 
 #else no_streams /* PNG file I/O method 2 */
    /* If you are using replacement read functions, instead of calling
-    * png_init_io() here you would call:
+    * png_init_io(), you would call:
     */
    png_set_read_fn(png_ptr, (void *)user_io_ptr, user_read_fn);
-   /* where user_io_ptr is a structure you want available to the callbacks */
+   /* where user_io_ptr is a structure you want available to the callbacks. */
 #endif no_streams /* Use only one I/O method! */
 
    /* If we have already read some of the signature */
    png_set_sig_bytes(png_ptr, sig_read);
 
 #ifdef hilevel
-   /*
-    * If you have enough memory to read in the entire image at once,
+   /* If you have enough memory to read in the entire image at once,
     * and you need to specify only transforms that can be controlled
     * with one of the PNG_TRANSFORM_* bits (this presently excludes
     * quantizing, filling, setting background, and doing gamma
@@ -354,10 +355,10 @@ void read_png(FILE *fp, int sig_read)  /* File is already open */
    png_read_png(png_ptr, info_ptr, png_transforms, NULL);
 
 #else
-   /* OK, you're doing it the hard way, with the lower-level functions */
+   /* OK, you're doing it the hard way, with the lower-level functions. */
 
    /* The call to png_read_info() gives us all of the information from the
-    * PNG file before the first IDAT (image data chunk).  REQUIRED
+    * PNG file before the first IDAT (image data chunk).  REQUIRED.
     */
    png_read_info(png_ptr, info_ptr);
 
@@ -385,20 +386,21 @@ void read_png(FILE *fp, int sig_read)  /* File is already open */
     */
    png_set_strip_alpha(png_ptr);
 
-   /* Extract multiple pixels with bit depths of 1, 2, and 4 from a single
+   /* Extract multiple pixels with bit depths of 1, 2 or 4 from a single
     * byte into separate bytes (useful for paletted and grayscale images).
     */
    png_set_packing(png_ptr);
 
    /* Change the order of packed pixels to least significant bit first
-    * (not useful if you are using png_set_packing). */
+    * (not useful if you are using png_set_packing).
+    */
    png_set_packswap(png_ptr);
 
-   /* Expand paletted colors into true RGB triplets */
+   /* Expand paletted colors into true RGB triplets. */
    if (color_type == PNG_COLOR_TYPE_PALETTE)
       png_set_palette_to_rgb(png_ptr);
 
-   /* Expand grayscale images to the full 8 bits from 1, 2, or 4 bits/pixel */
+   /* Expand grayscale images to the full 8 bits from 1, 2 or 4 bits/pixel. */
    if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
       png_set_expand_gray_1_2_4_to_8(png_ptr);
 
@@ -409,12 +411,11 @@ void read_png(FILE *fp, int sig_read)  /* File is already open */
       png_set_tRNS_to_alpha(png_ptr);
 
    /* Set the background color to draw transparent and alpha images over.
-    * It is possible to set the red, green, and blue components directly
-    * for paletted images instead of supplying a palette index.  Note that
+    * It is possible to set the red, green and blue components directly
+    * for paletted images, instead of supplying a palette index.  Note that,
     * even if the PNG file supplies a background, you are not required to
     * use it - you should use the (solid) application background if it has one.
     */
-
    png_color_16 my_background, *image_background;
 
    if (png_get_bKGD(png_ptr, info_ptr, &image_background) != 0)
@@ -424,32 +425,29 @@ void read_png(FILE *fp, int sig_read)  /* File is already open */
       png_set_background(png_ptr, &my_background,
           PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
 
-   /* Some suggestions as to how to get a screen gamma value
+   /* Some suggestions as to how to get a screen gamma value.
     *
     * Note that screen gamma is the display_exponent, which includes
-    * the CRT_exponent and any correction for viewing conditions
+    * the CRT_exponent and any correction for viewing conditions.
     */
    if (/* We have a user-defined screen gamma value */)
-   {
       screen_gamma = user-defined screen_gamma;
-   }
-   /* This is one way that applications share the same screen gamma value */
+   /* This is one way that applications share the same screen gamma value. */
    else if ((gamma_str = getenv("SCREEN_GAMMA")) != NULL)
-   {
       screen_gamma = atof(gamma_str);
-   }
    /* If we don't have another value */
    else
    {
-      screen_gamma = PNG_DEFAULT_sRGB;  /* A good guess for a PC monitor
-                                           in a dimly lit room */
-      screen_gamma = PNG_GAMMA_MAC_18 or 1.0; /* Good guesses for Mac systems */
+      screen_gamma = PNG_DEFAULT_sRGB; /* A good guess for a PC monitor
+                                          in a dimly lit room */
+      screen_gamma = PNG_GAMMA_MAC_18 or 1.0; /* Good guesses for Mac
+                                                 systems */
    }
 
    /* Tell libpng to handle the gamma conversion for you.  The final call
     * is a good guess for PC generated images, but it should be configurable
-    * by the user at run time by the user.  It is strongly suggested that
-    * your application support gamma correction.
+    * by the user at run time.  Gamma correction support in your application
+    * is strongly recommended.
     */
 
    int intent;
@@ -466,7 +464,7 @@ void read_png(FILE *fp, int sig_read)  /* File is already open */
    }
 
 #ifdef PNG_READ_QUANTIZE_SUPPORTED
-   /* Quantize RGB files down to 8-bit palette or reduce palettes
+   /* Quantize RGB files down to 8-bit palette, or reduce palettes
     * to the number of colors available on your screen.
     */
    if ((color_type & PNG_COLOR_MASK_COLOR) != 0)
@@ -474,29 +472,26 @@ void read_png(FILE *fp, int sig_read)  /* File is already open */
       int num_palette;
       png_colorp palette;
 
-      /* This reduces the image to the application supplied palette */
+      /* This reduces the image to the application-supplied palette. */
       if (/* We have our own palette */)
       {
-         /* An array of colors to which the image should be quantized */
+         /* An array of colors to which the image should be quantized. */
          png_color std_color_cube[MAX_SCREEN_COLORS];
-
          png_set_quantize(png_ptr, std_color_cube, MAX_SCREEN_COLORS,
              MAX_SCREEN_COLORS, NULL, 0);
       }
-      /* This reduces the image to the palette supplied in the file */
+      /* This reduces the image to the palette supplied in the file. */
       else if (png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette) != 0)
       {
          png_uint_16p histogram = NULL;
-
          png_get_hIST(png_ptr, info_ptr, &histogram);
-
          png_set_quantize(png_ptr, palette, num_palette,
              max_screen_colors, histogram, 0);
       }
    }
 #endif /* READ_QUANTIZE */
 
-   /* Invert monochrome files to have 0 as white and 1 as black */
+   /* Invert monochrome files to have 0 as white and 1 as black. */
    png_set_invert_mono(png_ptr);
 
    /* If you want to shift the pixel values from the range [0,255] or
@@ -506,22 +501,21 @@ void read_png(FILE *fp, int sig_read)  /* File is already open */
    if (png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT) != 0)
    {
       png_color_8p sig_bit_p;
-
       png_get_sBIT(png_ptr, info_ptr, &sig_bit_p);
       png_set_shift(png_ptr, sig_bit_p);
    }
 
-   /* Flip the RGB pixels to BGR (or RGBA to BGRA) */
+   /* Flip the RGB pixels to BGR (or RGBA to BGRA). */
    if ((color_type & PNG_COLOR_MASK_COLOR) != 0)
       png_set_bgr(png_ptr);
 
-   /* Swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) */
+   /* Swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR). */
    png_set_swap_alpha(png_ptr);
 
-   /* Swap bytes of 16-bit files to least significant byte first */
+   /* Swap bytes of 16-bit files to least significant byte first. */
    png_set_swap(png_ptr);
 
-   /* Add filler (or alpha) byte (before/after each RGB triplet) */
+   /* Add filler (or alpha) byte (before/after each RGB triplet). */
    png_set_filler(png_ptr, 0xffff, PNG_FILLER_AFTER);
 
 #ifdef PNG_READ_INTERLACING_SUPPORTED
@@ -534,40 +528,31 @@ void read_png(FILE *fp, int sig_read)  /* File is already open */
    number_passes = 1;
 #endif /* READ_INTERLACING */
 
-
    /* Optional call to gamma correct and add the background to the palette
     * and update info structure.  REQUIRED if you are expecting libpng to
-    * update the palette for you (ie you selected such a transform above).
+    * update the palette for you (i.e. you selected such a transform above).
     */
    png_read_update_info(png_ptr, info_ptr);
 
    /* Allocate the memory to hold the image using the fields of info_ptr. */
-
-   /* The easiest way to read the image: */
    png_bytep row_pointers[height];
-
-   /* Clear the pointer array */
    for (row = 0; row < height; row++)
-      row_pointers[row] = NULL;
-
+      row_pointers[row] = NULL; /* Clear the pointer array */
    for (row = 0; row < height; row++)
       row_pointers[row] = png_malloc(png_ptr, png_get_rowbytes(png_ptr,
           info_ptr));
 
-   /* Now it's time to read the image.  One of these methods is REQUIRED */
+   /* Now it's time to read the image.  One of these methods is REQUIRED. */
 #ifdef entire /* Read the entire image in one go */
    png_read_image(png_ptr, row_pointers);
 
 #else no_entire /* Read the image one or more scanlines at a time */
    /* The other way to read images - deal with interlacing: */
-
    for (pass = 0; pass < number_passes; pass++)
    {
 #ifdef single /* Read the image a single row at a time */
       for (y = 0; y < height; y++)
-      {
          png_read_rows(png_ptr, &row_pointers[y], NULL, 1);
-      }
 
 #else no_single /* Read the image several rows at a time */
       for (y = 0; y < height; y += number_of_rows)
@@ -581,24 +566,24 @@ void read_png(FILE *fp, int sig_read)  /* File is already open */
 #endif no_sparkle /* Use only one of these two methods */
       }
 
-      /* If you want to display the image after every pass, do so here */
+      /* If you want to display the image after every pass, do so here. */
 #endif no_single /* Use only one of these two methods */
    }
 #endif no_entire /* Use only one of these two methods */
 
-   /* Read rest of file, and get additional chunks in info_ptr - REQUIRED */
+   /* Read rest of file, and get additional chunks in info_ptr.  REQUIRED. */
    png_read_end(png_ptr, info_ptr);
 #endif hilevel
 
-   /* At this point you have read the entire image */
+   /* At this point you have read the entire image. */
 
-   /* Clean up after the read, and free any memory allocated - REQUIRED */
+   /* Clean up after the read, and free any memory allocated.  REQUIRED. */
    png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
 
-   /* Close the file */
+   /* Close the file. */
    fclose(fp);
 
-   /* That's it */
+   /* That's it! */
    return (OK);
 }
 
@@ -610,34 +595,30 @@ initialize_png_reader(png_structp *png_ptr, png_infop *info_ptr)
    /* Create and initialize the png_struct with the desired error handler
     * functions.  If you want to use the default stderr and longjump method,
     * you can supply NULL for the last three parameters.  We also check that
-    * the library version is compatible in case we are using dynamically
+    * the library version is compatible, in case we are using dynamically
     * linked libraries.
     */
    *png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
         png_voidp user_error_ptr, user_error_fn, user_warning_fn);
-
    if (*png_ptr == NULL)
    {
       *info_ptr = NULL;
       return (ERROR);
    }
-
    *info_ptr = png_create_info_struct(png_ptr);
-
    if (*info_ptr == NULL)
    {
       png_destroy_read_struct(png_ptr, info_ptr, NULL);
       return (ERROR);
    }
-
    if (setjmp(png_jmpbuf((*png_ptr))))
    {
       png_destroy_read_struct(png_ptr, info_ptr, NULL);
       return (ERROR);
    }
 
-   /* This one's new.  You will need to provide all three
-    * function callbacks, even if you aren't using them all.
+   /* You will need to provide all three function callbacks,
+    * even if you aren't using all of them.
     * If you aren't using all functions, you can specify NULL
     * parameters.  Even when all three functions are NULL,
     * you need to call png_set_progressive_read_fn().
@@ -650,7 +631,6 @@ initialize_png_reader(png_structp *png_ptr, png_infop *info_ptr)
     */
    png_set_progressive_read_fn(*png_ptr, (void *)stream_data,
        info_callback, row_callback, end_callback);
-
    return (OK);
 }
 
@@ -660,18 +640,18 @@ process_data(png_structp *png_ptr, png_infop *info_ptr,
 {
    if (setjmp(png_jmpbuf((*png_ptr))))
    {
-      /* Free the png_ptr and info_ptr memory on error */
+      /* Free the png_ptr and info_ptr memory on error. */
       png_destroy_read_struct(png_ptr, info_ptr, NULL);
       return (ERROR);
    }
 
-   /* This one's new also.  Simply give it chunks of data as
-    * they arrive from the data stream (in order, of course).
+   /* Give chunks of data as they arrive from the data stream
+    * (in order, of course).
     * On segmented machines, don't give it any more than 64K.
     * The library seems to run fine with sizes of 4K, although
-    * you can give it much less if necessary (I assume you can
+    * you can give it much less if necessary. (I assume you can
     * give it chunks of 1 byte, but I haven't tried with less
-    * than 256 bytes yet).  When this function returns, you may
+    * than 256 bytes yet.)  When this function returns, you may
     * want to display any rows that were generated in the row
     * callback, if you aren't already displaying them there.
     */
@@ -693,8 +673,7 @@ info_callback(png_structp png_ptr, png_infop info)
 row_callback(png_structp png_ptr, png_bytep new_row,
     png_uint_32 row_num, int pass)
 {
-   /*
-    * This function is called for every row in the image.  If the
+   /* This function is called for every row in the image.  If the
     * image is interlaced, and you turned on the interlace handler,
     * this function will be called for every row in every pass.
     *
@@ -705,25 +684,22 @@ row_callback(png_structp png_ptr, png_bytep new_row,
     * The new row data pointer "new_row" may be NULL, indicating there is
     * no new data to be replaced (in cases of interlace loading).
     *
-    * If new_row is not NULL then you need to call
-    * png_progressive_combine_row() to replace the corresponding row as
+    * If new_row is not NULL, then you need to call
+    * png_progressive_combine_row(), to replace the corresponding row as
     * shown below:
     */
 
-   /* Get pointer to corresponding row in our
-    * PNG read buffer.
-    */
+   /* Get pointer to corresponding row in our PNG read buffer. */
    png_bytep old_row = ((png_bytep *)our_data)[row_num];
 
 #ifdef PNG_READ_INTERLACING_SUPPORTED
-   /* If both rows are allocated then copy the new row
+   /* If both rows are allocated, then copy the new row
     * data to the corresponding row data.
     */
-   if ((old_row != NULL) && (new_row != NULL))
-   png_progressive_combine_row(png_ptr, old_row, new_row);
+   if (old_row != NULL && new_row != NULL)
+      png_progressive_combine_row(png_ptr, old_row, new_row);
 
-   /*
-    * The rows and passes are called in order, so you don't really
+   /* The rows and passes are called in order, so you don't really
     * need the row_num and pass, but I'm supplying them because it
     * may make your life easier.
     *
@@ -734,7 +710,6 @@ row_callback(png_structp png_ptr, png_bytep new_row,
     * (it just does the memcpy for you) if it will make the code
     * easier.  Thus, you can just do this for all cases:
     */
-
    png_progressive_combine_row(png_ptr, old_row, new_row);
 
    /* where old_row is what was displayed for previous rows.  Note
@@ -781,14 +756,13 @@ void write_png(char *file_name /* , ... other image information ... */)
     */
    png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
        png_voidp user_error_ptr, user_error_fn, user_warning_fn);
-
    if (png_ptr == NULL)
    {
       fclose(fp);
       return (ERROR);
    }
 
-   /* Allocate/initialize the image information data.  REQUIRED */
+   /* Allocate/initialize the image information data.  REQUIRED. */
    info_ptr = png_create_info_struct(png_ptr);
    if (info_ptr == NULL)
    {
@@ -797,30 +771,30 @@ void write_png(char *file_name /* , ... other image information ... */)
       return (ERROR);
    }
 
-   /* Set error handling.  REQUIRED if you aren't supplying your own
+   /* Set up error handling.  REQUIRED if you aren't supplying your own
     * error handling functions in the png_create_write_struct() call.
     */
    if (setjmp(png_jmpbuf(png_ptr)))
    {
-      /* If we get here, we had a problem writing the file */
+      /* If we get here, we had a problem writing the file. */
       fclose(fp);
       png_destroy_write_struct(&png_ptr, &info_ptr);
       return (ERROR);
    }
 
-   /* One of the following I/O initialization functions is REQUIRED */
+   /* One of the following I/O initialization functions is REQUIRED. */
 
 #ifdef streams /* I/O initialization method 1 */
-   /* Set up the output control if you are using standard C streams */
+   /* Set up the output control if you are using standard C streams. */
    png_init_io(png_ptr, fp);
 
 #else no_streams /* I/O initialization method 2 */
    /* If you are using replacement write functions, instead of calling
-    * png_init_io() here you would call
+    * png_init_io(), you would call:
     */
    png_set_write_fn(png_ptr, (void *)user_io_ptr, user_write_fn,
        user_IO_flush_function);
-   /* where user_io_ptr is a structure you want available to the callbacks */
+   /* where user_io_ptr is a structure you want available to the callbacks. */
 #endif no_streams /* Only use one initialization method */
 
 #ifdef hilevel
@@ -831,30 +805,32 @@ void write_png(char *file_name /* , ... other image information ... */)
    png_write_png(png_ptr, info_ptr, png_transforms, NULL);
 
 #else
-   /* This is the hard way */
+   /* This is the hard way. */
 
    /* Set the image information here.  Width and height are up to 2^31,
-    * bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on
-    * the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY,
+    * bit_depth is one of 1, 2, 4, 8 or 16, but valid values also depend on
+    * the color_type selected.  color_type is one of PNG_COLOR_TYPE_GRAY,
     * PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB,
     * or PNG_COLOR_TYPE_RGB_ALPHA.  interlace is either PNG_INTERLACE_NONE or
     * PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST
-    * currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE. REQUIRED
+    * currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE.
+    * REQUIRED.
     */
-   png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, PNG_COLOR_TYPE_???,
-       PNG_INTERLACE_????, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
+   png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth,
+       PNG_COLOR_TYPE_???, PNG_INTERLACE_????,
+       PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
 
-   /* Set the palette if there is one.  REQUIRED for indexed-color images */
-   palette = (png_colorp)png_malloc(png_ptr, PNG_MAX_PALETTE_LENGTH
-             * (sizeof (png_color)));
+   /* Set the palette if there is one.  REQUIRED for indexed-color images. */
+   palette = (png_colorp)png_malloc(png_ptr,
+       PNG_MAX_PALETTE_LENGTH * (sizeof (png_color)));
    /* ... Set palette colors ... */
    png_set_PLTE(png_ptr, info_ptr, palette, PNG_MAX_PALETTE_LENGTH);
-   /* You must not free palette here, because png_set_PLTE only makes a link to
-    * the palette that you malloced.  Wait until you are about to destroy
+   /* You must not free palette here, because png_set_PLTE only makes a link
+    * to the palette that you allocated.  Wait until you are about to destroy
     * the png structure.
     */
 
-   /* Optional significant bit (sBIT) chunk */
+   /* Optional significant bit (sBIT) chunk. */
    png_color_8 sig_bit;
 
    /* If we are dealing with a grayscale image then */
@@ -870,18 +846,17 @@ void write_png(char *file_name /* , ... other image information ... */)
 
    png_set_sBIT(png_ptr, info_ptr, &sig_bit);
 
-
    /* Optional gamma chunk is strongly suggested if you have any guess
     * as to the correct gamma of the image.
     */
    png_set_gAMA(png_ptr, info_ptr, gamma);
 
-   /* Optionally write comments into the image */
+   /* Optionally write comments into the image. */
    {
       png_text text_ptr[3];
 
-      char key0[]="Title";
-      char text0[]="Mona Lisa";
+      char key0[] = "Title";
+      char text0[] = "Mona Lisa";
       text_ptr[0].key = key0;
       text_ptr[0].text = text0;
       text_ptr[0].compression = PNG_TEXT_COMPRESSION_NONE;
@@ -889,8 +864,8 @@ void write_png(char *file_name /* , ... other image information ... */)
       text_ptr[0].lang = NULL;
       text_ptr[0].lang_key = NULL;
 
-      char key1[]="Author";
-      char text1[]="Leonardo DaVinci";
+      char key1[] = "Author";
+      char text1[] = "Leonardo DaVinci";
       text_ptr[1].key = key1;
       text_ptr[1].text = text1;
       text_ptr[1].compression = PNG_TEXT_COMPRESSION_NONE;
@@ -898,8 +873,8 @@ void write_png(char *file_name /* , ... other image information ... */)
       text_ptr[1].lang = NULL;
       text_ptr[1].lang_key = NULL;
 
-      char key2[]="Description";
-      char text2[]="<long text>";
+      char key2[] = "Description";
+      char text2[] = "<long text>";
       text_ptr[2].key = key2;
       text_ptr[2].text = text2;
       text_ptr[2].compression = PNG_TEXT_COMPRESSION_zTXt;
@@ -910,14 +885,14 @@ void write_png(char *file_name /* , ... other image information ... */)
       png_set_text(write_ptr, write_info_ptr, text_ptr, 3);
    }
 
-   /* Other optional chunks like cHRM, bKGD, tRNS, tIME, oFFs, pHYs */
+   /* Other optional chunks like cHRM, bKGD, tRNS, tIME, oFFs, pHYs. */
 
-   /* Note that if sRGB is present the gAMA and cHRM chunks must be ignored
+   /* Note that if sRGB is present, the gAMA and cHRM chunks must be ignored
     * on read and, if your application chooses to write them, they must
-    * be written in accordance with the sRGB profile
+    * be written in accordance with the sRGB profile.
     */
 
-   /* Write the file header information.  REQUIRED */
+   /* Write the file header information.  REQUIRED. */
    png_write_info(png_ptr, info_ptr);
 
    /* If you want, you can write the info in two steps, in case you need to
@@ -941,7 +916,7 @@ void write_png(char *file_name /* , ... other image information ... */)
     * all optional.  Only call them if you want them.
     */
 
-   /* Invert monochrome pixels */
+   /* Invert monochrome pixels. */
    png_set_invert_mono(png_ptr);
 
    /* Shift the pixels up to a legal bit depth and fill in
@@ -949,30 +924,29 @@ void write_png(char *file_name /* , ... other image information ... */)
     */
    png_set_shift(png_ptr, &sig_bit);
 
-   /* Pack pixels into bytes */
+   /* Pack pixels into bytes. */
    png_set_packing(png_ptr);
 
-   /* Swap location of alpha bytes from ARGB to RGBA */
+   /* Swap location of alpha bytes from ARGB to RGBA. */
    png_set_swap_alpha(png_ptr);
 
    /* Get rid of filler (OR ALPHA) bytes, pack XRGB/RGBX/ARGB/RGBA into
-    * RGB (4 channels -> 3 channels). The second parameter is not used.
+    * RGB (4 channels -> 3 channels).  The second parameter is not used.
     */
    png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);
 
-   /* Flip BGR pixels to RGB */
+   /* Flip BGR pixels to RGB. */
    png_set_bgr(png_ptr);
 
-   /* Swap bytes of 16-bit files to most significant byte first */
+   /* Swap bytes of 16-bit files to most significant byte first. */
    png_set_swap(png_ptr);
 
-   /* Swap bits of 1-bit, 2-bit, 4-bit packed pixel formats */
+   /* Swap bits of 1-bit, 2-bit, 4-bit packed pixel formats. */
    png_set_packswap(png_ptr);
 
-   /* Turn on interlace handling if you are not using png_write_image() */
+   /* Turn on interlace handling if you are not using png_write_image(). */
    if (interlacing != 0)
       number_passes = png_set_interlace_handling(png_ptr);
-
    else
       number_passes = 1;
 
@@ -982,29 +956,28 @@ void write_png(char *file_name /* , ... other image information ... */)
     */
    png_uint_32 k, height, width;
 
-   /* In this example, "image" is a one-dimensional array of bytes */
+   /* In this example, "image" is a one-dimensional array of bytes. */
 
-   /* Guard against integer overflow */
-   if (height > PNG_SIZE_MAX/(width*bytes_per_pixel)) {
-      png_error(png_ptr, "Image_data buffer would be too large");
-   }
-   png_byte image[height*width*bytes_per_pixel];
+   /* Guard against integer overflow. */
+   if (height > PNG_SIZE_MAX / (width * bytes_per_pixel))
+      png_error(png_ptr, "Image data buffer would be too large");
 
+   png_byte image[height * width * bytes_per_pixel];
    png_bytep row_pointers[height];
 
-   if (height > PNG_UINT_32_MAX/(sizeof (png_bytep)))
-      png_error (png_ptr, "Image is too tall to process in memory");
+   if (height > PNG_UINT_32_MAX / (sizeof (png_bytep)))
+      png_error(png_ptr, "Image is too tall to process in memory");
 
-   /* Set up pointers into your "image" byte array */
+   /* Set up pointers into your "image" byte array. */
    for (k = 0; k < height; k++)
-      row_pointers[k] = image + k*width*bytes_per_pixel;
+      row_pointers[k] = image + k * width * bytes_per_pixel;
 
-   /* One of the following output methods is REQUIRED */
+   /* One of the following output methods is REQUIRED. */
 
 #ifdef entire /* Write out the entire image data in one call */
    png_write_image(png_ptr, row_pointers);
 
-   /* The other way to write the image - deal with interlacing */
+   /* The other way to write the image - deal with interlacing. */
 
 #else no_entire /* Write out the image data by one or more scanlines */
 
@@ -1016,27 +989,27 @@ void write_png(char *file_name /* , ... other image information ... */)
       /* Write a few rows at a time. */
       png_write_rows(png_ptr, &row_pointers[first_row], number_of_rows);
 
-      /* If you are only writing one row at a time, this works */
+      /* If you are only writing one row at a time, this works. */
       for (y = 0; y < height; y++)
          png_write_rows(png_ptr, &row_pointers[y], 1);
    }
 #endif no_entire /* Use only one output method */
 
    /* You can write optional chunks like tEXt, zTXt, and tIME at the end
-    * as well.  Shouldn't be necessary in 1.2.0 and up as all the public
-    * chunks are supported and you can use png_set_unknown_chunks() to
+    * as well.  Shouldn't be necessary in 1.2.0 and up, as all the public
+    * chunks are supported, and you can use png_set_unknown_chunks() to
     * register unknown chunks into the info structure to be written out.
     */
 
-   /* It is REQUIRED to call this to finish writing the rest of the file */
+   /* It is REQUIRED to call this to finish writing the rest of the file. */
    png_write_end(png_ptr, info_ptr);
 #endif hilevel
 
-   /* If you png_malloced a palette, free it here (don't free info_ptr->palette,
-    * as recommended in versions 1.0.5m and earlier of this example; if
-    * libpng mallocs info_ptr->palette, libpng will free it).  If you
-    * allocated it with malloc() instead of png_malloc(), use free() instead
-    * of png_free().
+   /* If you png_malloced a palette, free it here.
+    * (Don't free info_ptr->palette, as shown in versions 1.0.5m and earlier of
+    * this example; if libpng mallocs info_ptr->palette, libpng will free it).
+    * If you allocated it with malloc() instead of png_malloc(), use free()
+    * instead of png_free().
     */
    png_free(png_ptr, palette);
    palette = NULL;
@@ -1047,19 +1020,20 @@ void write_png(char *file_name /* , ... other image information ... */)
     */
    png_free(png_ptr, trans);
    trans = NULL;
-   /* Whenever you use png_free() it is a good idea to set the pointer to
+
+   /* Whenever you use png_free(), it is a good idea to set the pointer to
     * NULL in case your application inadvertently tries to png_free() it
-    * again.  When png_free() sees a NULL it returns without action, thus
-    * avoiding the double-free security problem.
+    * again.  When png_free() sees a NULL it returns without action, avoiding
+    * the double-free problem.
     */
 
-   /* Clean up after the write, and free any memory allocated */
+   /* Clean up after the write, and free any allocated memory. */
    png_destroy_write_struct(&png_ptr, &info_ptr);
 
-   /* Close the file */
+   /* Close the file. */
    fclose(fp);
 
-   /* That's it */
+   /* That's it! */
    return (OK);
 }
 
diff --git a/Engine/lib/lpng/install-sh b/Engine/lib/lpng/install-sh
new file mode 100755
index 000000000..8175c640f
--- /dev/null
+++ b/Engine/lib/lpng/install-sh
@@ -0,0 +1,518 @@
+#!/bin/sh
+# install - install a program, script, or datafile
+
+scriptversion=2018-03-11.20; # UTC
+
+# This originates from X11R5 (mit/util/scripts/install.sh), which was
+# later released in X11R6 (xc/config/util/install.sh) with the
+# following copyright and license.
+#
+# Copyright (C) 1994 X Consortium
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC-
+# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+# Except as contained in this notice, the name of the X Consortium shall not
+# be used in advertising or otherwise to promote the sale, use or other deal-
+# ings in this Software without prior written authorization from the X Consor-
+# tium.
+#
+#
+# FSF changes to this file are in the public domain.
+#
+# Calling this script install-sh is preferred over install.sh, to prevent
+# 'make' implicit rules from creating a file called install from it
+# when there is no Makefile.
+#
+# This script is compatible with the BSD install script, but was written
+# from scratch.
+
+tab='	'
+nl='
+'
+IFS=" $tab$nl"
+
+# Set DOITPROG to "echo" to test this script.
+
+doit=${DOITPROG-}
+doit_exec=${doit:-exec}
+
+# Put in absolute file names if you don't have them in your path;
+# or use environment vars.
+
+chgrpprog=${CHGRPPROG-chgrp}
+chmodprog=${CHMODPROG-chmod}
+chownprog=${CHOWNPROG-chown}
+cmpprog=${CMPPROG-cmp}
+cpprog=${CPPROG-cp}
+mkdirprog=${MKDIRPROG-mkdir}
+mvprog=${MVPROG-mv}
+rmprog=${RMPROG-rm}
+stripprog=${STRIPPROG-strip}
+
+posix_mkdir=
+
+# Desired mode of installed file.
+mode=0755
+
+chgrpcmd=
+chmodcmd=$chmodprog
+chowncmd=
+mvcmd=$mvprog
+rmcmd="$rmprog -f"
+stripcmd=
+
+src=
+dst=
+dir_arg=
+dst_arg=
+
+copy_on_change=false
+is_target_a_directory=possibly
+
+usage="\
+Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE
+   or: $0 [OPTION]... SRCFILES... DIRECTORY
+   or: $0 [OPTION]... -t DIRECTORY SRCFILES...
+   or: $0 [OPTION]... -d DIRECTORIES...
+
+In the 1st form, copy SRCFILE to DSTFILE.
+In the 2nd and 3rd, copy all SRCFILES to DIRECTORY.
+In the 4th, create DIRECTORIES.
+
+Options:
+     --help     display this help and exit.
+     --version  display version info and exit.
+
+  -c            (ignored)
+  -C            install only if different (preserve the last data modification time)
+  -d            create directories instead of installing files.
+  -g GROUP      $chgrpprog installed files to GROUP.
+  -m MODE       $chmodprog installed files to MODE.
+  -o USER       $chownprog installed files to USER.
+  -s            $stripprog installed files.
+  -t DIRECTORY  install into DIRECTORY.
+  -T            report an error if DSTFILE is a directory.
+
+Environment variables override the default commands:
+  CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG
+  RMPROG STRIPPROG
+"
+
+while test $# -ne 0; do
+  case $1 in
+    -c) ;;
+
+    -C) copy_on_change=true;;
+
+    -d) dir_arg=true;;
+
+    -g) chgrpcmd="$chgrpprog $2"
+        shift;;
+
+    --help) echo "$usage"; exit $?;;
+
+    -m) mode=$2
+        case $mode in
+          *' '* | *"$tab"* | *"$nl"* | *'*'* | *'?'* | *'['*)
+            echo "$0: invalid mode: $mode" >&2
+            exit 1;;
+        esac
+        shift;;
+
+    -o) chowncmd="$chownprog $2"
+        shift;;
+
+    -s) stripcmd=$stripprog;;
+
+    -t)
+        is_target_a_directory=always
+        dst_arg=$2
+        # Protect names problematic for 'test' and other utilities.
+        case $dst_arg in
+          -* | [=\(\)!]) dst_arg=./$dst_arg;;
+        esac
+        shift;;
+
+    -T) is_target_a_directory=never;;
+
+    --version) echo "$0 $scriptversion"; exit $?;;
+
+    --) shift
+        break;;
+
+    -*) echo "$0: invalid option: $1" >&2
+        exit 1;;
+
+    *)  break;;
+  esac
+  shift
+done
+
+# We allow the use of options -d and -T together, by making -d
+# take the precedence; this is for compatibility with GNU install.
+
+if test -n "$dir_arg"; then
+  if test -n "$dst_arg"; then
+    echo "$0: target directory not allowed when installing a directory." >&2
+    exit 1
+  fi
+fi
+
+if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then
+  # When -d is used, all remaining arguments are directories to create.
+  # When -t is used, the destination is already specified.
+  # Otherwise, the last argument is the destination.  Remove it from $@.
+  for arg
+  do
+    if test -n "$dst_arg"; then
+      # $@ is not empty: it contains at least $arg.
+      set fnord "$@" "$dst_arg"
+      shift # fnord
+    fi
+    shift # arg
+    dst_arg=$arg
+    # Protect names problematic for 'test' and other utilities.
+    case $dst_arg in
+      -* | [=\(\)!]) dst_arg=./$dst_arg;;
+    esac
+  done
+fi
+
+if test $# -eq 0; then
+  if test -z "$dir_arg"; then
+    echo "$0: no input file specified." >&2
+    exit 1
+  fi
+  # It's OK to call 'install-sh -d' without argument.
+  # This can happen when creating conditional directories.
+  exit 0
+fi
+
+if test -z "$dir_arg"; then
+  if test $# -gt 1 || test "$is_target_a_directory" = always; then
+    if test ! -d "$dst_arg"; then
+      echo "$0: $dst_arg: Is not a directory." >&2
+      exit 1
+    fi
+  fi
+fi
+
+if test -z "$dir_arg"; then
+  do_exit='(exit $ret); exit $ret'
+  trap "ret=129; $do_exit" 1
+  trap "ret=130; $do_exit" 2
+  trap "ret=141; $do_exit" 13
+  trap "ret=143; $do_exit" 15
+
+  # Set umask so as not to create temps with too-generous modes.
+  # However, 'strip' requires both read and write access to temps.
+  case $mode in
+    # Optimize common cases.
+    *644) cp_umask=133;;
+    *755) cp_umask=22;;
+
+    *[0-7])
+      if test -z "$stripcmd"; then
+        u_plus_rw=
+      else
+        u_plus_rw='% 200'
+      fi
+      cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
+    *)
+      if test -z "$stripcmd"; then
+        u_plus_rw=
+      else
+        u_plus_rw=,u+rw
+      fi
+      cp_umask=$mode$u_plus_rw;;
+  esac
+fi
+
+for src
+do
+  # Protect names problematic for 'test' and other utilities.
+  case $src in
+    -* | [=\(\)!]) src=./$src;;
+  esac
+
+  if test -n "$dir_arg"; then
+    dst=$src
+    dstdir=$dst
+    test -d "$dstdir"
+    dstdir_status=$?
+  else
+
+    # Waiting for this to be detected by the "$cpprog $src $dsttmp" command
+    # might cause directories to be created, which would be especially bad
+    # if $src (and thus $dsttmp) contains '*'.
+    if test ! -f "$src" && test ! -d "$src"; then
+      echo "$0: $src does not exist." >&2
+      exit 1
+    fi
+
+    if test -z "$dst_arg"; then
+      echo "$0: no destination specified." >&2
+      exit 1
+    fi
+    dst=$dst_arg
+
+    # If destination is a directory, append the input filename.
+    if test -d "$dst"; then
+      if test "$is_target_a_directory" = never; then
+        echo "$0: $dst_arg: Is a directory" >&2
+        exit 1
+      fi
+      dstdir=$dst
+      dstbase=`basename "$src"`
+      case $dst in
+	*/) dst=$dst$dstbase;;
+	*)  dst=$dst/$dstbase;;
+      esac
+      dstdir_status=0
+    else
+      dstdir=`dirname "$dst"`
+      test -d "$dstdir"
+      dstdir_status=$?
+    fi
+  fi
+
+  case $dstdir in
+    */) dstdirslash=$dstdir;;
+    *)  dstdirslash=$dstdir/;;
+  esac
+
+  obsolete_mkdir_used=false
+
+  if test $dstdir_status != 0; then
+    case $posix_mkdir in
+      '')
+        # Create intermediate dirs using mode 755 as modified by the umask.
+        # This is like FreeBSD 'install' as of 1997-10-28.
+        umask=`umask`
+        case $stripcmd.$umask in
+          # Optimize common cases.
+          *[2367][2367]) mkdir_umask=$umask;;
+          .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;;
+
+          *[0-7])
+            mkdir_umask=`expr $umask + 22 \
+              - $umask % 100 % 40 + $umask % 20 \
+              - $umask % 10 % 4 + $umask % 2
+            `;;
+          *) mkdir_umask=$umask,go-w;;
+        esac
+
+        # With -d, create the new directory with the user-specified mode.
+        # Otherwise, rely on $mkdir_umask.
+        if test -n "$dir_arg"; then
+          mkdir_mode=-m$mode
+        else
+          mkdir_mode=
+        fi
+
+        posix_mkdir=false
+        case $umask in
+          *[123567][0-7][0-7])
+            # POSIX mkdir -p sets u+wx bits regardless of umask, which
+            # is incompatible with FreeBSD 'install' when (umask & 300) != 0.
+            ;;
+          *)
+            # Note that $RANDOM variable is not portable (e.g. dash);  Use it
+            # here however when possible just to lower collision chance.
+            tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
+
+            trap 'ret=$?; rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" 2>/dev/null; exit $ret' 0
+
+            # Because "mkdir -p" follows existing symlinks and we likely work
+            # directly in world-writeable /tmp, make sure that the '$tmpdir'
+            # directory is successfully created first before we actually test
+            # 'mkdir -p' feature.
+            if (umask $mkdir_umask &&
+                $mkdirprog $mkdir_mode "$tmpdir" &&
+                exec $mkdirprog $mkdir_mode -p -- "$tmpdir/a/b") >/dev/null 2>&1
+            then
+              if test -z "$dir_arg" || {
+                   # Check for POSIX incompatibilities with -m.
+                   # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
+                   # other-writable bit of parent directory when it shouldn't.
+                   # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
+                   test_tmpdir="$tmpdir/a"
+                   ls_ld_tmpdir=`ls -ld "$test_tmpdir"`
+                   case $ls_ld_tmpdir in
+                     d????-?r-*) different_mode=700;;
+                     d????-?--*) different_mode=755;;
+                     *) false;;
+                   esac &&
+                   $mkdirprog -m$different_mode -p -- "$test_tmpdir" && {
+                     ls_ld_tmpdir_1=`ls -ld "$test_tmpdir"`
+                     test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
+                   }
+                 }
+              then posix_mkdir=:
+              fi
+              rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir"
+            else
+              # Remove any dirs left behind by ancient mkdir implementations.
+              rmdir ./$mkdir_mode ./-p ./-- "$tmpdir" 2>/dev/null
+            fi
+            trap '' 0;;
+        esac;;
+    esac
+
+    if
+      $posix_mkdir && (
+        umask $mkdir_umask &&
+        $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
+      )
+    then :
+    else
+
+      # The umask is ridiculous, or mkdir does not conform to POSIX,
+      # or it failed possibly due to a race condition.  Create the
+      # directory the slow way, step by step, checking for races as we go.
+
+      case $dstdir in
+        /*) prefix='/';;
+        [-=\(\)!]*) prefix='./';;
+        *)  prefix='';;
+      esac
+
+      oIFS=$IFS
+      IFS=/
+      set -f
+      set fnord $dstdir
+      shift
+      set +f
+      IFS=$oIFS
+
+      prefixes=
+
+      for d
+      do
+        test X"$d" = X && continue
+
+        prefix=$prefix$d
+        if test -d "$prefix"; then
+          prefixes=
+        else
+          if $posix_mkdir; then
+            (umask=$mkdir_umask &&
+             $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
+            # Don't fail if two instances are running concurrently.
+            test -d "$prefix" || exit 1
+          else
+            case $prefix in
+              *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
+              *) qprefix=$prefix;;
+            esac
+            prefixes="$prefixes '$qprefix'"
+          fi
+        fi
+        prefix=$prefix/
+      done
+
+      if test -n "$prefixes"; then
+        # Don't fail if two instances are running concurrently.
+        (umask $mkdir_umask &&
+         eval "\$doit_exec \$mkdirprog $prefixes") ||
+          test -d "$dstdir" || exit 1
+        obsolete_mkdir_used=true
+      fi
+    fi
+  fi
+
+  if test -n "$dir_arg"; then
+    { test -z "$chowncmd" || $doit $chowncmd "$dst"; } &&
+    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } &&
+    { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false ||
+      test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1
+  else
+
+    # Make a couple of temp file names in the proper directory.
+    dsttmp=${dstdirslash}_inst.$$_
+    rmtmp=${dstdirslash}_rm.$$_
+
+    # Trap to clean up those temp files at exit.
+    trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0
+
+    # Copy the file name to the temp name.
+    (umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") &&
+
+    # and set any options; do chmod last to preserve setuid bits.
+    #
+    # If any of these fail, we abort the whole thing.  If we want to
+    # ignore errors from any of these, just make sure not to ignore
+    # errors from the above "$doit $cpprog $src $dsttmp" command.
+    #
+    { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } &&
+    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } &&
+    { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } &&
+    { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } &&
+
+    # If -C, don't bother to copy if it wouldn't change the file.
+    if $copy_on_change &&
+       old=`LC_ALL=C ls -dlL "$dst"     2>/dev/null` &&
+       new=`LC_ALL=C ls -dlL "$dsttmp"  2>/dev/null` &&
+       set -f &&
+       set X $old && old=:$2:$4:$5:$6 &&
+       set X $new && new=:$2:$4:$5:$6 &&
+       set +f &&
+       test "$old" = "$new" &&
+       $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
+    then
+      rm -f "$dsttmp"
+    else
+      # Rename the file to the real destination.
+      $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null ||
+
+      # The rename failed, perhaps because mv can't rename something else
+      # to itself, or perhaps because mv is so ancient that it does not
+      # support -f.
+      {
+        # Now remove or move aside any old file at destination location.
+        # We try this two ways since rm can't unlink itself on some
+        # systems and the destination file might be busy for other
+        # reasons.  In this case, the final cleanup might fail but the new
+        # file should still install successfully.
+        {
+          test ! -f "$dst" ||
+          $doit $rmcmd -f "$dst" 2>/dev/null ||
+          { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
+            { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; }
+          } ||
+          { echo "$0: cannot unlink or rename $dst" >&2
+            (exit 1); exit 1
+          }
+        } &&
+
+        # Now rename the file to the real destination.
+        $doit $mvcmd "$dsttmp" "$dst"
+      }
+    fi || exit 1
+
+    trap '' 0
+  fi
+done
+
+# Local variables:
+# eval: (add-hook 'before-save-hook 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC0"
+# time-stamp-end: "; # UTC"
+# End:
diff --git a/Engine/lib/lpng/intel/filter_sse2_intrinsics.c b/Engine/lib/lpng/intel/filter_sse2_intrinsics.c
index 5e8553fbb..f52aaa800 100644
--- a/Engine/lib/lpng/intel/filter_sse2_intrinsics.c
+++ b/Engine/lib/lpng/intel/filter_sse2_intrinsics.c
@@ -1,12 +1,11 @@
 
 /* filter_sse2_intrinsics.c - SSE2 optimized filter functions
  *
+ * Copyright (c) 2018 Cosmin Truta
  * Copyright (c) 2016-2017 Glenn Randers-Pehrson
  * Written by Mike Klein and Matt Sarett
  * Derived from arm/filter_neon_intrinsics.c
  *
- * Last changed in libpng 1.6.31 [July 27, 2017]
- *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
  * and license in png.h
@@ -29,39 +28,25 @@
  */
 
 static __m128i load4(const void* p) {
-   return _mm_cvtsi32_si128(*(const int*)p);
+   int tmp;
+   memcpy(&tmp, p, sizeof(tmp));
+   return _mm_cvtsi32_si128(tmp);
 }
 
 static void store4(void* p, __m128i v) {
-   *(int*)p = _mm_cvtsi128_si32(v);
+   int tmp = _mm_cvtsi128_si32(v);
+   memcpy(p, &tmp, sizeof(int));
 }
 
 static __m128i load3(const void* p) {
-   /* We'll load 2 bytes, then 1 byte,
-    * then mask them together, and finally load into SSE.
-    */
-   const png_uint_16* p01 = (png_const_uint_16p)p;
-   const png_byte*    p2  = (const png_byte*)(p01+1);
-
-   png_uint_32 v012 = (png_uint_32)(*p01)
-                    | (png_uint_32)(*p2) << 16;
-   return load4(&v012);
+   png_uint_32 tmp = 0;
+   memcpy(&tmp, p, 3);
+   return _mm_cvtsi32_si128(tmp);
 }
 
 static void store3(void* p, __m128i v) {
-   /* We'll pull from SSE as a 32-bit int, then write
-    * its bottom two bytes, then its third byte.
-    */
-   png_uint_32 v012;
-   png_uint_16* p01;
-   png_byte*    p2;
-
-   store4(&v012, v);
-
-   p01 = (png_uint_16p)p;
-   p2  = (png_byte*)(p01+1);
-   *p01 = (png_uint_16)v012;
-   *p2  = (png_byte)(v012 >> 16);
+   int tmp = _mm_cvtsi128_si32(v);
+   memcpy(p, &tmp, 3);
 }
 
 void png_read_filter_row_sub3_sse2(png_row_infop row_info, png_bytep row,
@@ -71,7 +56,7 @@ void png_read_filter_row_sub3_sse2(png_row_infop row_info, png_bytep row,
     * There is no pixel to the left of the first pixel.  It's encoded directly.
     * That works with our main loop if we just say that left pixel was zero.
     */
-   png_size_t rb;
+   size_t rb;
 
    __m128i a, d = _mm_setzero_si128();
 
@@ -104,7 +89,7 @@ void png_read_filter_row_sub4_sse2(png_row_infop row_info, png_bytep row,
     * There is no pixel to the left of the first pixel.  It's encoded directly.
     * That works with our main loop if we just say that left pixel was zero.
     */
-   png_size_t rb;
+   size_t rb;
 
    __m128i a, d = _mm_setzero_si128();
 
@@ -131,7 +116,7 @@ void png_read_filter_row_avg3_sse2(png_row_infop row_info, png_bytep row,
     * perfectly with our loop if we make sure a starts at zero.
     */
 
-   png_size_t rb;
+   size_t rb;
 
    const __m128i zero = _mm_setzero_si128();
 
@@ -185,7 +170,7 @@ void png_read_filter_row_avg4_sse2(png_row_infop row_info, png_bytep row,
     * predicted to be half of the pixel above it.  So again, this works
     * perfectly with our loop if we make sure a starts at zero.
     */
-   png_size_t rb;
+   size_t rb;
    const __m128i zero = _mm_setzero_si128();
    __m128i    b;
    __m128i a, d = zero;
@@ -257,7 +242,7 @@ void png_read_filter_row_paeth3_sse2(png_row_infop row_info, png_bytep row,
     * Here we zero b and d, which become c and a respectively at the start of
     * the loop.
     */
-   png_size_t rb;
+   size_t rb;
    const __m128i zero = _mm_setzero_si128();
    __m128i c, b = zero,
            a, d = zero;
@@ -356,7 +341,7 @@ void png_read_filter_row_paeth4_sse2(png_row_infop row_info, png_bytep row,
     * Here we zero b and d, which become c and a respectively at the start of
     * the loop.
     */
-   png_size_t rb;
+   size_t rb;
    const __m128i zero = _mm_setzero_si128();
    __m128i pa,pb,pc,smallest,nearest;
    __m128i c, b = zero,
diff --git a/Engine/lib/lpng/intel/intel_init.c b/Engine/lib/lpng/intel/intel_init.c
index 8f08baf8c..2f8168b7c 100644
--- a/Engine/lib/lpng/intel/intel_init.c
+++ b/Engine/lib/lpng/intel/intel_init.c
@@ -1,12 +1,11 @@
 
 /* intel_init.c - SSE2 optimized filter functions
  *
+ * Copyright (c) 2018 Cosmin Truta
  * Copyright (c) 2016-2017 Glenn Randers-Pehrson
  * Written by Mike Klein and Matt Sarett, Google, Inc.
  * Derived from arm/arm_init.c
  *
- * Last changed in libpng 1.6.29 [March 16, 2017]
- *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
  * and license in png.h
diff --git a/Engine/lib/lpng/libpng-manual.txt b/Engine/lib/lpng/libpng-manual.txt
index d4407ef2e..5dad92fbf 100644
--- a/Engine/lib/lpng/libpng-manual.txt
+++ b/Engine/lib/lpng/libpng-manual.txt
@@ -1,9 +1,7 @@
 libpng-manual.txt - A description on how to use and modify libpng
 
- libpng version 1.6.34 - September 29, 2017
- Updated and distributed by Glenn Randers-Pehrson
- <glennrp at users.sourceforge.net>
- Copyright (c) 1998-2017 Glenn Randers-Pehrson
+ Copyright (c) 2018-2019 Cosmin Truta
+ Copyright (c) 1998-2018 Glenn Randers-Pehrson
 
  This document is released under the libpng license.
  For conditions of distribution and use, see the disclaimer
@@ -11,9 +9,13 @@ libpng-manual.txt - A description on how to use and modify libpng
 
  Based on:
 
- libpng versions 0.97, January 1998, through 1.6.34 - September 29, 2017
+ libpng version 1.6.36, December 2018, through 1.6.37 - April 2019
+ Updated and distributed by Cosmin Truta
+ Copyright (c) 2018-2019 Cosmin Truta
+
+ libpng versions 0.97, January 1998, through 1.6.35 - July 2018
  Updated and distributed by Glenn Randers-Pehrson
- Copyright (c) 1998-2017 Glenn Randers-Pehrson
+ Copyright (c) 1998-2018 Glenn Randers-Pehrson
 
  libpng 1.0 beta 6 - version 0.96 - May 28, 1997
  Updated and distributed by Andreas Dilger
@@ -45,7 +47,6 @@ libpng-manual.txt - A description on how to use and modify libpng
  XIII. Detecting libpng
   XIV. Source code repository
    XV. Coding style
-  XVI. Y2K Compliance in libpng
 
 I. Introduction
 
@@ -66,7 +67,7 @@ file format in application programs.
 
 The PNG specification (second edition), November 2003, is available as
 a W3C Recommendation and as an ISO Standard (ISO/IEC 15948:2004 (E)) at
-<https://www.w3.org/TR/2003/REC-PNG-20031110/
+<https://www.w3.org/TR/2003/REC-PNG-20031110/>.
 The W3C and ISO documents have identical technical content.
 
 The PNG-1.2 specification is available at
@@ -74,9 +75,9 @@ The PNG-1.2 specification is available at
 It is technically equivalent
 to the PNG specification (second edition) but has some additional material.
 
-The PNG-1.0 specification is available as RFC 2083
+The PNG-1.0 specification is available as RFC 2083 at
 <https://png-mng.sourceforge.io/pub/png/spec/1.0/> and as a
-W3C Recommendation <https://www.w3.org/TR/REC-png-961001>.
+W3C Recommendation at <https://www.w3.org/TR/REC-png-961001>.
 
 Some additional chunks are described in the special-purpose public chunks
 documents at <http://www.libpng.org/pub/png/spec/register/>
@@ -348,18 +349,18 @@ Customizing libpng.
     FILE *fp = fopen(file_name, "rb");
     if (!fp)
     {
-       return (ERROR);
+       return ERROR;
     }
 
     if (fread(header, 1, number, fp) != number)
     {
-       return (ERROR);
+       return ERROR;
     }
 
     is_png = !png_sig_cmp(header, 0, number);
     if (!is_png)
     {
-       return (NOT_PNG);
+       return NOT_PNG;
     }
 
 Next, png_struct and png_info need to be allocated and initialized.  In
@@ -378,7 +379,7 @@ create the structure, so your application should check for that.
         user_error_fn, user_warning_fn);
 
     if (!png_ptr)
-       return (ERROR);
+       return ERROR;
 
     png_infop info_ptr = png_create_info_struct(png_ptr);
 
@@ -386,7 +387,7 @@ create the structure, so your application should check for that.
     {
        png_destroy_read_struct(&png_ptr,
            (png_infopp)NULL, (png_infopp)NULL);
-       return (ERROR);
+       return ERROR;
     }
 
 If you want to use your own memory allocation routines,
@@ -421,7 +422,7 @@ free any memory.
        png_destroy_read_struct(&png_ptr, &info_ptr,
            &end_info);
        fclose(fp);
-       return (ERROR);
+       return ERROR;
     }
 
 Pass (png_infopp)NULL instead of &end_info if you didn't create
@@ -503,7 +504,7 @@ input stream. You must supply the function
 
            png_byte name[5];
            png_byte *data;
-           png_size_t size;
+           size_t size;
 
        /* Note that libpng has already taken care of
           the CRC handling */
@@ -512,9 +513,9 @@ input stream. You must supply the function
           unknown chunk structure, process it, and return one
           of the following: */
 
-       return (-n); /* chunk had an error */
-       return (0); /* did not recognize */
-       return (n); /* success */
+       return -n; /* chunk had an error */
+       return 0; /* did not recognize */
+       return n; /* success */
     }
 
 (You can give your function another name that you like instead of
@@ -1003,7 +1004,7 @@ chunks to be assumed to be encoded using sRGB.
     png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC);
 
 In this case the output is assumed to be something like an sRGB conformant
-display preceeded by a power-law lookup table of power 1.45.  This is how
+display preceded by a power-law lookup table of power 1.45.  This is how
 early Mac systems behaved.
 
     png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_GAMMA_LINEAR);
@@ -1055,7 +1056,7 @@ faster.)
 
 When the default gamma of PNG files doesn't match the output gamma.
 If you have PNG files with no gamma information png_set_alpha_mode allows
-you to provide a default gamma, but it also sets the ouput gamma to the
+you to provide a default gamma, but it also sets the output gamma to the
 matching value.  If you know your PNG files have a gamma that doesn't
 match the output you can take advantage of the fact that
 png_set_alpha_mode always sets the output gamma but only sets the PNG
@@ -2409,7 +2410,7 @@ separate.
     {
        png_destroy_read_struct(&png_ptr, &info_ptr,
            (png_infopp)NULL);
-       return (ERROR);
+       return ERROR;
     }
 
    png_read_end(png_ptr, end_info);
@@ -2549,7 +2550,7 @@ png_infop info_ptr;
          user_error_fn, user_warning_fn);
 
     if (!png_ptr)
-        return (ERROR);
+        return ERROR;
 
     info_ptr = png_create_info_struct(png_ptr);
 
@@ -2557,14 +2558,14 @@ png_infop info_ptr;
     {
        png_destroy_read_struct(&png_ptr,
           (png_infopp)NULL, (png_infopp)NULL);
-       return (ERROR);
+       return ERROR;
     }
 
     if (setjmp(png_jmpbuf(png_ptr)))
     {
        png_destroy_read_struct(&png_ptr, &info_ptr,
           (png_infopp)NULL);
-       return (ERROR);
+       return ERROR;
     }
 
     /* This one's new.  You can provide functions
@@ -2598,7 +2599,7 @@ png_infop info_ptr;
     {
        png_destroy_read_struct(&png_ptr, &info_ptr,
            (png_infopp)NULL);
-       return (ERROR);
+       return ERROR;
     }
 
     /* This one's new also.  Simply give it a chunk
@@ -2742,7 +2743,7 @@ custom writing functions.  See the discussion under Customizing libpng.
     FILE *fp = fopen(file_name, "wb");
 
     if (!fp)
-       return (ERROR);
+       return ERROR;
 
 Next, png_struct and png_info need to be allocated and initialized.
 As these can be both relatively large, you may not want to store these
@@ -2757,14 +2758,14 @@ both "png_ptr"; you can call them anything you like, such as
         user_error_fn, user_warning_fn);
 
     if (!png_ptr)
-       return (ERROR);
+       return ERROR;
 
     png_infop info_ptr = png_create_info_struct(png_ptr);
     if (!info_ptr)
     {
        png_destroy_write_struct(&png_ptr,
            (png_infopp)NULL);
-       return (ERROR);
+       return ERROR;
     }
 
 If you want to use your own memory allocation routines,
@@ -2791,7 +2792,7 @@ section below for more information on the libpng error handling.
     {
     png_destroy_write_struct(&png_ptr, &info_ptr);
        fclose(fp);
-       return (ERROR);
+       return ERROR;
     }
     ...
     return;
@@ -3779,7 +3780,7 @@ in-memory bitmap formats or to be written from the same formats.  If these
 formats do not accommodate your needs then you can, and should, use the more
 sophisticated APIs above - these support a wide variety of in-memory formats
 and a wide variety of sophisticated transformations to those formats as well
-as a wide variety of APIs to manipulate ancilliary information.
+as a wide variety of APIs to manipulate ancillary information.
 
 To read a PNG file using the simplified API:
 
@@ -4055,7 +4056,7 @@ Flags containing additional information about the image are held in
 the 'flags' field of png_image.
 
   PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB == 0x01
-    This indicates the the RGB values of the in-memory bitmap do not
+    This indicates that the RGB values of the in-memory bitmap do not
     correspond to the red, green and blue end-points defined by sRGB.
 
   PNG_IMAGE_FLAG_FAST == 0x02
@@ -4102,7 +4103,7 @@ READ APIs
       The PNG header is read from the stdio FILE object.
 
    int png_image_begin_read_from_memory(png_imagep image,
-      png_const_voidp memory, png_size_t size)
+      png_const_voidp memory, size_t size)
 
       The PNG header is read from the given memory buffer.
 
@@ -4255,10 +4256,10 @@ png_get_io_ptr().  For example:
 The replacement I/O functions must have prototypes as follows:
 
     void user_read_data(png_structp png_ptr,
-        png_bytep data, png_size_t length);
+        png_bytep data, size_t length);
 
     void user_write_data(png_structp png_ptr,
-        png_bytep data, png_size_t length);
+        png_bytep data, size_t length);
 
     void user_flush_data(png_structp png_ptr);
 
@@ -4521,7 +4522,7 @@ When PNG_DEBUG = 1, the macros are defined, but only png_debug statements
 having level = 0 will be printed.  There aren't any such statements in
 this version of libpng, but if you insert some they will be printed.
 
-VII.  MNG support
+VII. MNG support
 
 The MNG specification (available at http://www.libpng.org/pub/mng) allows
 certain extensions to PNG for PNG images that are embedded in MNG datastreams.
@@ -4548,7 +4549,7 @@ or any other MNG chunks; your application must provide its own support for
 them.  You may wish to consider using libmng (available at
 https://www.libmng.com/) instead.
 
-VIII.  Changes to Libpng from version 0.88
+VIII. Changes to Libpng from version 0.88
 
 It should be noted that versions of libpng later than 0.96 are not
 distributed by the original libpng author, Guy Schalnat, nor by
@@ -4603,7 +4604,7 @@ application:
 
    png_uint_32 application_vn = PNG_LIBPNG_VER;
 
-IX.  Changes to Libpng from version 1.0.x to 1.2.x
+IX. Changes to Libpng from version 1.0.x to 1.2.x
 
 Support for user memory management was enabled by default.  To
 accomplish this, the functions png_create_read_struct_2(),
@@ -4700,7 +4701,7 @@ which also expands tRNS to alpha was replaced with
     png_set_expand_gray_1_2_4_to_8()
 which does not. It has been deprecated since libpng-1.0.18 and 1.2.9.
 
-X.  Changes to Libpng from version 1.0.x/1.2.x to 1.4.x
+X. Changes to Libpng from version 1.0.x/1.2.x to 1.4.x
 
 Private libpng prototypes and macro definitions were moved from
 png.h and pngconf.h into a new pngpriv.h header file.
@@ -4784,7 +4785,7 @@ behavior in case the application runs out of memory part-way through
 the process.
 
 We changed the prototypes of png_get_compression_buffer_size() and
-png_set_compression_buffer_size() to work with png_size_t instead of
+png_set_compression_buffer_size() to work with size_t instead of
 png_uint_32.
 
 Support for numbered error messages was removed by default, since we
@@ -4810,7 +4811,7 @@ was renamed to PNG_READ_QUANTIZE_SUPPORTED.
 
 We removed the trailing '.' from the warning and error messages.
 
-XI.  Changes to Libpng from version 1.4.x to 1.5.x
+XI. Changes to Libpng from version 1.4.x to 1.5.x
 
 From libpng-1.4.0 until 1.4.4, the png_get_uint_16 macro (but not the
 function) incorrectly returned a value of type png_uint_32.
@@ -4873,7 +4874,7 @@ to png_bytepp, and in png_set_iCCP, from png_charp to png_const_bytep.
 There are changes of form in png.h, including new and changed macros to
 declare parts of the API.  Some API functions with arguments that are
 pointers to data not modified within the function have been corrected to
-declare these arguments with PNG_CONST.
+declare these arguments with const.
 
 Much of the internal use of C macros to control the library build has also
 changed and some of this is visible in the exported header files, in
@@ -5068,7 +5069,7 @@ even though the default is to use the macros - this allows applications
 to choose at app buildtime whether or not to use macros (previously
 impossible because the functions weren't in the default build.)
 
-XII.  Changes to Libpng from version 1.5.x to 1.6.x
+XII. Changes to Libpng from version 1.5.x to 1.6.x
 
 A "simplified API" has been added (see documentation in png.h and a simple
 example in contrib/examples/pngtopng.c).  The new publicly visible API
@@ -5231,7 +5232,7 @@ attempt to decode the Exif profile; it simply returns a byte array
 containing the profile to the calling application which must do its own
 decoding.
 
-XIII.  Detecting libpng
+XIII. Detecting libpng
 
 The png_get_io_ptr() function has been present since libpng-0.88, has never
 changed, and is unaffected by conditional compilation macros.  It is the
@@ -5255,9 +5256,8 @@ or you can browse it with a web browser at
     https://github.com/glennrp/libpng or
     https://sourceforge.net/p/libpng/code/ci/libpng16/tree/
 
-Patches can be sent to glennrp at users.sourceforge.net or to
-png-mng-implement at lists.sourceforge.net or you can upload them to
-the libpng bug tracker at
+Patches can be sent to png-mng-implement at lists.sourceforge.net or
+uploaded to the libpng bug tracker at
 
     https://libpng.sourceforge.io/
 
@@ -5266,9 +5266,9 @@ or as a "pull request" to
     https://github.com/glennrp/libpng/pulls
 
 We also accept patches built from the tar or zip distributions, and
-simple verbal discriptions of bug fixes, reported either to the
+simple verbal descriptions of bug fixes, reported either to the
 SourceForge bug tracker, to the png-mng-implement at lists.sf.net
-mailing list, as github issues, or directly to glennrp.
+mailing list, as github issues.
 
 XV. Coding style
 
@@ -5289,7 +5289,7 @@ braces on separate lines:
 The braces can be omitted from simple one-line actions:
 
     if (condition)
-       return (0);
+       return 0;
 
 We use 3-space indentation, except for continued statements which
 are usually indented the same as the first line of the statement
@@ -5407,58 +5407,3 @@ We do not use the TAB character for indentation in the C sources.
 Lines do not exceed 80 characters.
 
 Other rules can be inferred by inspecting the libpng source.
-
-XVI. Y2K Compliance in libpng
-
-Since the PNG Development group is an ad-hoc body, we can't make
-an official declaration.
-
-This is your unofficial assurance that libpng from version 0.71 and
-upward through 1.6.34 are Y2K compliant.  It is my belief that earlier
-versions were also Y2K compliant.
-
-Libpng only has two year fields.  One is a 2-byte unsigned integer
-that will hold years up to 65535.  The other, which is deprecated,
-holds the date in text format, and will hold years up to 9999.
-
-The integer is
-    "png_uint_16 year" in png_time_struct.
-
-The string is
-    "char time_buffer[29]" in png_struct.  This is no longer used
-in libpng-1.6.x and will be removed from libpng-1.7.0.
-
-There are seven time-related functions:
-
-    png_convert_to_rfc_1123_buffer() in png.c
-      (formerly png_convert_to_rfc_1152() in error, and
-      also formerly png_convert_to_rfc_1123())
-    png_convert_from_struct_tm() in pngwrite.c, called
-      in pngwrite.c
-    png_convert_from_time_t() in pngwrite.c
-    png_get_tIME() in pngget.c
-    png_handle_tIME() in pngrutil.c, called in pngread.c
-    png_set_tIME() in pngset.c
-    png_write_tIME() in pngwutil.c, called in pngwrite.c
-
-All appear to handle dates properly in a Y2K environment.  The
-png_convert_from_time_t() function calls gmtime() to convert from system
-clock time, which returns (year - 1900), which we properly convert to
-the full 4-digit year.  There is a possibility that applications using
-libpng are not passing 4-digit years into the png_convert_to_rfc_1123()
-function, or that they are incorrectly passing only a 2-digit year
-instead of "year - 1900" into the png_convert_from_struct_tm() function,
-but this is not under our control.  The libpng documentation has always
-stated that it works with 4-digit years, and the APIs have been
-documented as such.
-
-The tIME chunk itself is also Y2K compliant.  It uses a 2-byte unsigned
-integer to hold the year, and can hold years as large as 65535.
-
-zlib, upon which libpng depends, is also Y2K compliant.  It contains
-no date-related code.
-
-
-   Glenn Randers-Pehrson
-   libpng maintainer
-   PNG Development Group
diff --git a/Engine/lib/lpng/libpng.3 b/Engine/lib/lpng/libpng.3
index 3c8d62ab2..f37423540 100644
--- a/Engine/lib/lpng/libpng.3
+++ b/Engine/lib/lpng/libpng.3
@@ -1,11 +1,11 @@
-.TH LIBPNG 3 "September 29, 2017"
+.TH LIBPNG 3 "April 14, 2019"
 .SH NAME
-libpng \- Portable Network Graphics (PNG) Reference Library 1.6.34
-.SH SYNOPSIS
-\fB
-#include <png.h>\fP
+libpng \- Portable Network Graphics (PNG) Reference Library 1.6.37
 
-\fBpng_uint_32 png_access_version_number \fI(void\fP\fB);\fP
+.SH SYNOPSIS
+\fB#include <png.h>\fP
+
+\fBpng_uint_32 png_access_version_number (void);\fP
 
 \fBvoid png_benign_error (png_structp \fP\fIpng_ptr\fP\fB, png_const_charp \fIerror\fP\fB);\fP
 
@@ -35,7 +35,7 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.6.34
 
 \fBpng_structp png_create_write_struct_2 (png_const_charp \fP\fIuser_png_ver\fP\fB, png_voidp \fP\fIerror_ptr\fP\fB, png_error_ptr \fP\fIerror_fn\fP\fB, png_error_ptr \fP\fIwarn_fn\fP\fB, png_voidp \fP\fImem_ptr\fP\fB, png_malloc_ptr \fP\fImalloc_fn\fP\fB, png_free_ptr \fIfree_fn\fP\fB);\fP
 
-\fBvoid png_data_freer (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, int \fP\fIfreer\fP\fB, png_uint_32 \fImask)\fP\fB);\fP
+\fBvoid png_data_freer (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, int \fP\fIfreer\fP\fB, png_uint_32 \fImask\fP\fB);\fP
 
 \fBvoid png_destroy_info_struct (png_structp \fP\fIpng_ptr\fP\fB, png_infopp \fIinfo_ptr_ptr\fP\fB);\fP
 
@@ -225,7 +225,7 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.6.34
 
 \fBint png_image_begin_read_from_stdio (png_imagep \fP\fIimage\fP\fB, FILE* \fIfile\fP\fB);\fP
 
-\fBint, png_image_begin_read_from_memory (png_imagep \fP\fIimage\fP\fB, png_const_voidp \fP\fImemory\fP\fB, png_size_t \fIsize\fP\fB);\fP
+\fBint, png_image_begin_read_from_memory (png_imagep \fP\fIimage\fP\fB, png_const_voidp \fP\fImemory\fP\fB, size_t \fIsize\fP\fB);\fP
 
 \fBint png_image_finish_read (png_imagep \fP\fIimage\fP\fB, png_colorp \fP\fIbackground\fP\fB, void \fP\fI*buffer\fP\fB, png_int_32 \fP\fIrow_stride\fP\fB, void \fI*colormap\fP\fB);\fP
 
@@ -233,11 +233,11 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.6.34
 
 \fBint png_image_write_to_file (png_imagep \fP\fIimage\fP\fB, const char \fP\fI*file\fP\fB, int \fP\fIconvert_to_8bit\fP\fB, const void \fP\fI*buffer\fP\fB, png_int_32 \fP\fIrow_stride\fP\fB, void \fI*colormap\fP\fB);\fP
 
-\fBint png_image_write_to_memory (png_imagep \fP\fIimage\fP\fB, void \fP\fI*memory\fP\fB, png_alloc_size_t * PNG_RESTRICT \fP\fImemory_bytes\fP\fB, int \fP\fIconvert_to_8_bit\fP\fB, const void \fP\fI*buffer\fP\fB, png_int_32 \fP\fIrow_stride\fP\fB, const void \fI*colormap)\fP\fB);\fP
+\fBint png_image_write_to_memory (png_imagep \fP\fIimage\fP\fB, void \fP\fI*memory\fP\fB, png_alloc_size_t * PNG_RESTRICT \fP\fImemory_bytes\fP\fB, int \fP\fIconvert_to_8_bit\fP\fB, const void \fP\fI*buffer\fP\fB, png_int_32 \fP\fIrow_stride\fP\fB, const void \fI*colormap\fP\fB);\fP
 
-\fBint png_image_write_to_stdio (png_imagep \fP\fIimage\fP\fB, FILE \fP\fI*file\fP\fB, int \fP\fIconvert_to_8_bit\fP\fB, const void \fP\fI*buffer\fP\fB, png_int_32 \fP\fIrow_stride\fP\fB, void \fI*colormap)\fP\fB);\fP
+\fBint png_image_write_to_stdio (png_imagep \fP\fIimage\fP\fB, FILE \fP\fI*file\fP\fB, int \fP\fIconvert_to_8_bit\fP\fB, const void \fP\fI*buffer\fP\fB, png_int_32 \fP\fIrow_stride\fP\fB, void \fI*colormap\fP\fB);\fP
 
-\fBvoid png_info_init_3 (png_infopp \fP\fIinfo_ptr\fP\fB, png_size_t \fIpng_info_struct_size\fP\fB);\fP
+\fBvoid png_info_init_3 (png_infopp \fP\fIinfo_ptr\fP\fB, size_t \fIpng_info_struct_size\fP\fB);\fP
 
 \fBvoid png_init_io (png_structp \fP\fIpng_ptr\fP\fB, FILE \fI*fp\fP\fB);\fP
 
@@ -251,11 +251,11 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.6.34
 
 \fBpng_uint_32 png_permit_mng_features (png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fImng_features_permitted\fP\fB);\fP
 
-\fBvoid png_process_data (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_bytep \fP\fIbuffer\fP\fB, png_size_t \fIbuffer_size\fP\fB);\fP
+\fBvoid png_process_data (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_bytep \fP\fIbuffer\fP\fB, size_t \fIbuffer_size\fP\fB);\fP
 
-\fBpng_size_t png_process_data_pause \fP\fI(png_structp\fP\fB, int \fIsave\fP\fB);\fP
+\fBsize_t png_process_data_pause (png_structp \fP\fIpng_ptr\fP\fB, int \fIsave\fP\fB);\fP
 
-\fBpng_uint_32 png_process_data_skip \fI(png_structp\fP\fB);\fP
+\fBpng_uint_32 png_process_data_skip (png_structp \fP\fIpng_ptr\fP\fB);\fP
 
 \fBvoid png_progressive_combine_row (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIold_row\fP\fB, png_bytep \fInew_row\fP\fB);\fP
 
@@ -297,7 +297,7 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.6.34
 
 \fBvoid png_set_bKGD (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_color_16p \fIbackground\fP\fB);\fP
 
-\fBvoid png_set_check_for_invalid_index(png_structrp \fP\fIpng_ptr\fP\fB, int \fIallowed\fP\fB);\fP
+\fBvoid png_set_check_for_invalid_index (png_structrp \fP\fIpng_ptr\fP\fB, int \fIallowed\fP\fB);\fP
 
 \fBvoid png_set_cHRM (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, double \fP\fIwhite_x\fP\fB, double \fP\fIwhite_y\fP\fB, double \fP\fIred_x\fP\fB, double \fP\fIred_y\fP\fB, double \fP\fIgreen_x\fP\fB, double \fP\fIgreen_y\fP\fB, double \fP\fIblue_x\fP\fB, double \fIblue_y\fP\fB);\fP
 
@@ -353,7 +353,7 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.6.34
 
 \fBvoid png_set_eXIf (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_bytep \fIexif\fP\fB);\fP
 
-\fBvoid png_set_eXIf_1 (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, const png_uint_32 \fP\fInum_exif\fP\fB, png_bytep \fIexif\fP\fB);\fP
+\fBvoid png_set_eXIf_1 (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fP\fInum_exif\fP\fB, png_bytep \fIexif\fP\fB);\fP
 
 \fBvoid png_set_hIST (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_16p \fIhist\fP\fB);\fP
 
@@ -453,7 +453,7 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.6.34
 
 \fBvoid png_set_text_compression_window_bits (png_structp \fP\fIpng_ptr\fP\fB, int \fIwindow_bits\fP\fB);\fP
 
-\fBvoid \fP\fIpng_set_text_compression_method\fP\fB, (png_structp \fP\fIpng_ptr\fP\fB, int \fImethod)\fP\fB);\fP
+\fBvoid png_set_text_compression_method (png_structp \fP\fIpng_ptr\fP\fB, int \fImethod\fP\fB);\fP
 
 \fBvoid png_set_tIME (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_timep \fImod_time\fP\fB);\fP
 
@@ -475,15 +475,15 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.6.34
 
 \fBvoid png_set_write_user_transform_fn (png_structp \fP\fIpng_ptr\fP\fB, png_user_transform_ptr \fIwrite_user_transform_fn\fP\fB);\fP
 
-\fBint png_sig_cmp (png_bytep \fP\fIsig\fP\fB, png_size_t \fP\fIstart\fP\fB, png_size_t \fInum_to_check\fP\fB);\fP
+\fBint png_sig_cmp (png_bytep \fP\fIsig\fP\fB, size_t \fP\fIstart\fP\fB, size_t \fInum_to_check\fP\fB);\fP
 
 \fBvoid png_start_read_image (png_structp \fIpng_ptr\fP\fB);\fP
 
 \fBvoid png_warning (png_structp \fP\fIpng_ptr\fP\fB, png_const_charp \fImessage\fP\fB);\fP
 
-\fBvoid png_write_chunk (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIchunk_name\fP\fB, png_bytep \fP\fIdata\fP\fB, png_size_t \fIlength\fP\fB);\fP
+\fBvoid png_write_chunk (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIchunk_name\fP\fB, png_bytep \fP\fIdata\fP\fB, size_t \fIlength\fP\fB);\fP
 
-\fBvoid png_write_chunk_data (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIdata\fP\fB, png_size_t \fIlength\fP\fB);\fP
+\fBvoid png_write_chunk_data (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIdata\fP\fB, size_t \fIlength\fP\fB);\fP
 
 \fBvoid png_write_chunk_end (png_structp \fIpng_ptr\fP\fB);\fP
 
@@ -515,13 +515,12 @@ the Portable Network Graphics (PNG) format image files.  It uses the
 .IR zlib(3)
 compression library.
 Following is a copy of the libpng-manual.txt file that accompanies libpng.
+
 .SH LIBPNG.TXT
 libpng-manual.txt - A description on how to use and modify libpng
 
- libpng version 1.6.34 - September 29, 2017
- Updated and distributed by Glenn Randers-Pehrson
- <glennrp at users.sourceforge.net>
- Copyright (c) 1998-2017 Glenn Randers-Pehrson
+ Copyright (c) 2018-2019 Cosmin Truta
+ Copyright (c) 1998-2018 Glenn Randers-Pehrson
 
  This document is released under the libpng license.
  For conditions of distribution and use, see the disclaimer
@@ -529,9 +528,13 @@ libpng-manual.txt - A description on how to use and modify libpng
 
  Based on:
 
- libpng versions 0.97, January 1998, through 1.6.34 - September 29, 2017
+ libpng version 1.6.36, December 2018, through 1.6.37 - April 2019
+ Updated and distributed by Cosmin Truta
+ Copyright (c) 2018-2019 Cosmin Truta
+
+ libpng versions 0.97, January 1998, through 1.6.35 - July 2018
  Updated and distributed by Glenn Randers-Pehrson
- Copyright (c) 1998-2017 Glenn Randers-Pehrson
+ Copyright (c) 1998-2018 Glenn Randers-Pehrson
 
  libpng 1.0 beta 6 - version 0.96 - May 28, 1997
  Updated and distributed by Andreas Dilger
@@ -563,7 +566,6 @@ libpng-manual.txt - A description on how to use and modify libpng
  XIII. Detecting libpng
   XIV. Source code repository
    XV. Coding style
-  XVI. Y2K Compliance in libpng
 
 .SH I. Introduction
 
@@ -584,7 +586,7 @@ file format in application programs.
 
 The PNG specification (second edition), November 2003, is available as
 a W3C Recommendation and as an ISO Standard (ISO/IEC 15948:2004 (E)) at
-<https://www.w3.org/TR/2003/REC-PNG-20031110/
+<https://www.w3.org/TR/2003/REC-PNG-20031110/>.
 The W3C and ISO documents have identical technical content.
 
 The PNG-1.2 specification is available at
@@ -592,9 +594,9 @@ The PNG-1.2 specification is available at
 It is technically equivalent
 to the PNG specification (second edition) but has some additional material.
 
-The PNG-1.0 specification is available as RFC 2083
+The PNG-1.0 specification is available as RFC 2083 at
 <https://png-mng.sourceforge.io/pub/png/spec/1.0/> and as a
-W3C Recommendation <https://www.w3.org/TR/REC-png-961001>.
+W3C Recommendation at <https://www.w3.org/TR/REC-png-961001>.
 
 Some additional chunks are described in the special-purpose public chunks
 documents at <http://www.libpng.org/pub/png/spec/register/>
@@ -866,18 +868,18 @@ Customizing libpng.
     FILE *fp = fopen(file_name, "rb");
     if (!fp)
     {
-       return (ERROR);
+       return ERROR;
     }
 
     if (fread(header, 1, number, fp) != number)
     {
-       return (ERROR);
+       return ERROR;
     }
 
     is_png = !png_sig_cmp(header, 0, number);
     if (!is_png)
     {
-       return (NOT_PNG);
+       return NOT_PNG;
     }
 
 Next, png_struct and png_info need to be allocated and initialized.  In
@@ -896,7 +898,7 @@ create the structure, so your application should check for that.
         user_error_fn, user_warning_fn);
 
     if (!png_ptr)
-       return (ERROR);
+       return ERROR;
 
     png_infop info_ptr = png_create_info_struct(png_ptr);
 
@@ -904,7 +906,7 @@ create the structure, so your application should check for that.
     {
        png_destroy_read_struct(&png_ptr,
            (png_infopp)NULL, (png_infopp)NULL);
-       return (ERROR);
+       return ERROR;
     }
 
 If you want to use your own memory allocation routines,
@@ -939,7 +941,7 @@ free any memory.
        png_destroy_read_struct(&png_ptr, &info_ptr,
            &end_info);
        fclose(fp);
-       return (ERROR);
+       return ERROR;
     }
 
 Pass (png_infopp)NULL instead of &end_info if you didn't create
@@ -1021,7 +1023,7 @@ input stream. You must supply the function
 
            png_byte name[5];
            png_byte *data;
-           png_size_t size;
+           size_t size;
 
        /* Note that libpng has already taken care of
           the CRC handling */
@@ -1030,9 +1032,9 @@ input stream. You must supply the function
           unknown chunk structure, process it, and return one
           of the following: */
 
-       return (\-n); /* chunk had an error */
-       return (0); /* did not recognize */
-       return (n); /* success */
+       return \-n; /* chunk had an error */
+       return 0; /* did not recognize */
+       return n; /* success */
     }
 
 (You can give your function another name that you like instead of
@@ -1521,7 +1523,7 @@ chunks to be assumed to be encoded using sRGB.
     png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC);
 
 In this case the output is assumed to be something like an sRGB conformant
-display preceeded by a power-law lookup table of power 1.45.  This is how
+display preceded by a power-law lookup table of power 1.45.  This is how
 early Mac systems behaved.
 
     png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_GAMMA_LINEAR);
@@ -1573,7 +1575,7 @@ faster.)
 
 When the default gamma of PNG files doesn't match the output gamma.
 If you have PNG files with no gamma information png_set_alpha_mode allows
-you to provide a default gamma, but it also sets the ouput gamma to the
+you to provide a default gamma, but it also sets the output gamma to the
 matching value.  If you know your PNG files have a gamma that doesn't
 match the output you can take advantage of the fact that
 png_set_alpha_mode always sets the output gamma but only sets the PNG
@@ -2927,7 +2929,7 @@ separate.
     {
        png_destroy_read_struct(&png_ptr, &info_ptr,
            (png_infopp)NULL);
-       return (ERROR);
+       return ERROR;
     }
 
    png_read_end(png_ptr, end_info);
@@ -3067,7 +3069,7 @@ png_infop info_ptr;
          user_error_fn, user_warning_fn);
 
     if (!png_ptr)
-        return (ERROR);
+        return ERROR;
 
     info_ptr = png_create_info_struct(png_ptr);
 
@@ -3075,14 +3077,14 @@ png_infop info_ptr;
     {
        png_destroy_read_struct(&png_ptr,
           (png_infopp)NULL, (png_infopp)NULL);
-       return (ERROR);
+       return ERROR;
     }
 
     if (setjmp(png_jmpbuf(png_ptr)))
     {
        png_destroy_read_struct(&png_ptr, &info_ptr,
           (png_infopp)NULL);
-       return (ERROR);
+       return ERROR;
     }
 
     /* This one's new.  You can provide functions
@@ -3116,7 +3118,7 @@ png_infop info_ptr;
     {
        png_destroy_read_struct(&png_ptr, &info_ptr,
            (png_infopp)NULL);
-       return (ERROR);
+       return ERROR;
     }
 
     /* This one's new also.  Simply give it a chunk
@@ -3260,7 +3262,7 @@ custom writing functions.  See the discussion under Customizing libpng.
     FILE *fp = fopen(file_name, "wb");
 
     if (!fp)
-       return (ERROR);
+       return ERROR;
 
 Next, png_struct and png_info need to be allocated and initialized.
 As these can be both relatively large, you may not want to store these
@@ -3275,14 +3277,14 @@ both "png_ptr"; you can call them anything you like, such as
         user_error_fn, user_warning_fn);
 
     if (!png_ptr)
-       return (ERROR);
+       return ERROR;
 
     png_infop info_ptr = png_create_info_struct(png_ptr);
     if (!info_ptr)
     {
        png_destroy_write_struct(&png_ptr,
            (png_infopp)NULL);
-       return (ERROR);
+       return ERROR;
     }
 
 If you want to use your own memory allocation routines,
@@ -3309,7 +3311,7 @@ section below for more information on the libpng error handling.
     {
     png_destroy_write_struct(&png_ptr, &info_ptr);
        fclose(fp);
-       return (ERROR);
+       return ERROR;
     }
     ...
     return;
@@ -4297,7 +4299,7 @@ in-memory bitmap formats or to be written from the same formats.  If these
 formats do not accommodate your needs then you can, and should, use the more
 sophisticated APIs above - these support a wide variety of in-memory formats
 and a wide variety of sophisticated transformations to those formats as well
-as a wide variety of APIs to manipulate ancilliary information.
+as a wide variety of APIs to manipulate ancillary information.
 
 To read a PNG file using the simplified API:
 
@@ -4573,7 +4575,7 @@ Flags containing additional information about the image are held in
 the 'flags' field of png_image.
 
   PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB == 0x01
-    This indicates the the RGB values of the in-memory bitmap do not
+    This indicates that the RGB values of the in-memory bitmap do not
     correspond to the red, green and blue end-points defined by sRGB.
 
   PNG_IMAGE_FLAG_FAST == 0x02
@@ -4620,7 +4622,7 @@ READ APIs
       The PNG header is read from the stdio FILE object.
 
    int png_image_begin_read_from_memory(png_imagep image,
-      png_const_voidp memory, png_size_t size)
+      png_const_voidp memory, size_t size)
 
       The PNG header is read from the given memory buffer.
 
@@ -4773,10 +4775,10 @@ png_get_io_ptr().  For example:
 The replacement I/O functions must have prototypes as follows:
 
     void user_read_data(png_structp png_ptr,
-        png_bytep data, png_size_t length);
+        png_bytep data, size_t length);
 
     void user_write_data(png_structp png_ptr,
-        png_bytep data, png_size_t length);
+        png_bytep data, size_t length);
 
     void user_flush_data(png_structp png_ptr);
 
@@ -5039,7 +5041,7 @@ When PNG_DEBUG = 1, the macros are defined, but only png_debug statements
 having level = 0 will be printed.  There aren't any such statements in
 this version of libpng, but if you insert some they will be printed.
 
-.SH VII.  MNG support
+.SH VII. MNG support
 
 The MNG specification (available at http://www.libpng.org/pub/mng) allows
 certain extensions to PNG for PNG images that are embedded in MNG datastreams.
@@ -5066,7 +5068,7 @@ or any other MNG chunks; your application must provide its own support for
 them.  You may wish to consider using libmng (available at
 https://www.libmng.com/) instead.
 
-.SH VIII.  Changes to Libpng from version 0.88
+.SH VIII. Changes to Libpng from version 0.88
 
 It should be noted that versions of libpng later than 0.96 are not
 distributed by the original libpng author, Guy Schalnat, nor by
@@ -5121,7 +5123,7 @@ application:
 
    png_uint_32 application_vn = PNG_LIBPNG_VER;
 
-.SH IX.  Changes to Libpng from version 1.0.x to 1.2.x
+.SH IX. Changes to Libpng from version 1.0.x to 1.2.x
 
 Support for user memory management was enabled by default.  To
 accomplish this, the functions png_create_read_struct_2(),
@@ -5218,7 +5220,7 @@ which also expands tRNS to alpha was replaced with
     png_set_expand_gray_1_2_4_to_8()
 which does not. It has been deprecated since libpng-1.0.18 and 1.2.9.
 
-.SH X.  Changes to Libpng from version 1.0.x/1.2.x to 1.4.x
+.SH X. Changes to Libpng from version 1.0.x/1.2.x to 1.4.x
 
 Private libpng prototypes and macro definitions were moved from
 png.h and pngconf.h into a new pngpriv.h header file.
@@ -5302,7 +5304,7 @@ behavior in case the application runs out of memory part-way through
 the process.
 
 We changed the prototypes of png_get_compression_buffer_size() and
-png_set_compression_buffer_size() to work with png_size_t instead of
+png_set_compression_buffer_size() to work with size_t instead of
 png_uint_32.
 
 Support for numbered error messages was removed by default, since we
@@ -5328,7 +5330,7 @@ was renamed to PNG_READ_QUANTIZE_SUPPORTED.
 
 We removed the trailing '.' from the warning and error messages.
 
-.SH XI.  Changes to Libpng from version 1.4.x to 1.5.x
+.SH XI. Changes to Libpng from version 1.4.x to 1.5.x
 
 From libpng-1.4.0 until 1.4.4, the png_get_uint_16 macro (but not the
 function) incorrectly returned a value of type png_uint_32.
@@ -5391,7 +5393,7 @@ to png_bytepp, and in png_set_iCCP, from png_charp to png_const_bytep.
 There are changes of form in png.h, including new and changed macros to
 declare parts of the API.  Some API functions with arguments that are
 pointers to data not modified within the function have been corrected to
-declare these arguments with PNG_CONST.
+declare these arguments with const.
 
 Much of the internal use of C macros to control the library build has also
 changed and some of this is visible in the exported header files, in
@@ -5586,7 +5588,7 @@ even though the default is to use the macros - this allows applications
 to choose at app buildtime whether or not to use macros (previously
 impossible because the functions weren't in the default build.)
 
-.SH XII.  Changes to Libpng from version 1.5.x to 1.6.x
+.SH XII. Changes to Libpng from version 1.5.x to 1.6.x
 
 A "simplified API" has been added (see documentation in png.h and a simple
 example in contrib/examples/pngtopng.c).  The new publicly visible API
@@ -5749,7 +5751,7 @@ attempt to decode the Exif profile; it simply returns a byte array
 containing the profile to the calling application which must do its own
 decoding.
 
-.SH XIII.  Detecting libpng
+.SH XIII. Detecting libpng
 
 The png_get_io_ptr() function has been present since libpng-0.88, has never
 changed, and is unaffected by conditional compilation macros.  It is the
@@ -5773,9 +5775,8 @@ or you can browse it with a web browser at
     https://github.com/glennrp/libpng or
     https://sourceforge.net/p/libpng/code/ci/libpng16/tree/
 
-Patches can be sent to glennrp at users.sourceforge.net or to
-png-mng-implement at lists.sourceforge.net or you can upload them to
-the libpng bug tracker at
+Patches can be sent to png-mng-implement at lists.sourceforge.net or
+uploaded to the libpng bug tracker at
 
     https://libpng.sourceforge.io/
 
@@ -5784,9 +5785,9 @@ or as a "pull request" to
     https://github.com/glennrp/libpng/pulls
 
 We also accept patches built from the tar or zip distributions, and
-simple verbal discriptions of bug fixes, reported either to the
+simple verbal descriptions of bug fixes, reported either to the
 SourceForge bug tracker, to the png-mng-implement at lists.sf.net
-mailing list, as github issues, or directly to glennrp.
+mailing list, as github issues.
 
 .SH XV. Coding style
 
@@ -5807,7 +5808,7 @@ braces on separate lines:
 The braces can be omitted from simple one-line actions:
 
     if (condition)
-       return (0);
+       return 0;
 
 We use 3-space indentation, except for continued statements which
 are usually indented the same as the first line of the statement
@@ -5926,61 +5927,6 @@ Lines do not exceed 80 characters.
 
 Other rules can be inferred by inspecting the libpng source.
 
-.SH XVI. Y2K Compliance in libpng
-
-Since the PNG Development group is an ad-hoc body, we can't make
-an official declaration.
-
-This is your unofficial assurance that libpng from version 0.71 and
-upward through 1.6.34 are Y2K compliant.  It is my belief that earlier
-versions were also Y2K compliant.
-
-Libpng only has two year fields.  One is a 2-byte unsigned integer
-that will hold years up to 65535.  The other, which is deprecated,
-holds the date in text format, and will hold years up to 9999.
-
-The integer is
-    "png_uint_16 year" in png_time_struct.
-
-The string is
-    "char time_buffer[29]" in png_struct.  This is no longer used
-in libpng-1.6.x and will be removed from libpng-1.7.0.
-
-There are seven time-related functions:
-
-    png_convert_to_rfc_1123_buffer() in png.c
-      (formerly png_convert_to_rfc_1152() in error, and
-      also formerly png_convert_to_rfc_1123())
-    png_convert_from_struct_tm() in pngwrite.c, called
-      in pngwrite.c
-    png_convert_from_time_t() in pngwrite.c
-    png_get_tIME() in pngget.c
-    png_handle_tIME() in pngrutil.c, called in pngread.c
-    png_set_tIME() in pngset.c
-    png_write_tIME() in pngwutil.c, called in pngwrite.c
-
-All appear to handle dates properly in a Y2K environment.  The
-png_convert_from_time_t() function calls gmtime() to convert from system
-clock time, which returns (year - 1900), which we properly convert to
-the full 4-digit year.  There is a possibility that applications using
-libpng are not passing 4-digit years into the png_convert_to_rfc_1123()
-function, or that they are incorrectly passing only a 2-digit year
-instead of "year - 1900" into the png_convert_from_struct_tm() function,
-but this is not under our control.  The libpng documentation has always
-stated that it works with 4-digit years, and the APIs have been
-documented as such.
-
-The tIME chunk itself is also Y2K compliant.  It uses a 2-byte unsigned
-integer to hold the year, and can hold years as large as 65535.
-
-zlib, upon which libpng depends, is also Y2K compliant.  It contains
-no date-related code.
-
-
-   Glenn Randers-Pehrson
-   libpng maintainer
-   PNG Development Group
-
 .SH NOTE
 
 Note about libpng version numbers:
@@ -5991,9 +5937,9 @@ on the library has not always been consistent and straightforward.
 The following table summarizes matters since version 0.89c, which was
 the first widely used release:
 
- source             png.h  png.h  shared-lib
- version            string   int  version
- -------            ------  ----- ----------
+ source               png.h    png.h  shared-lib
+ version              string   int    version
+ -------              ------   -----  ----------
  0.89c "1.0 beta 3"     0.89      89  1.0.89
  0.90  "1.0 beta 4"     0.90      90  0.90  [should have been 2.0.90]
  0.95  "1.0 beta 5"     0.95      95  0.95  [should have been 2.0.95]
@@ -6028,23 +5974,25 @@ the first widely used release:
  1.0.7rc1-2               1    10007  2.1.0.7rc1-2 (binary compatible)
  1.0.7                    1    10007  (still compatible)
  ...
- 1.0.19                  10    10019  10.so.0.19[.0]
+ 1.0.69                  10    10069  10.so.0.69[.0]
  ...
  1.2.59                  13    10259  12.so.0.59[.0]
  ...
+ 1.4.20                  14    10420  14.so.0.20[.0]
+ ...
  1.5.30                  15    10530  15.so.15.30[.0]
  ...
- 1.6.34                  16    10634  16.so.16.34[.0]
+ 1.6.35                  16    10635  16.so.16.35[.0]
 
-Henceforth the source version will match the shared-library minor
-and patch numbers; the shared-library major version number will be
-used for changes in backward compatibility, as it is intended.  The
-PNG_PNGLIB_VER macro, which is not used within libpng but is available
-for applications, is an unsigned integer of the form xyyzz corresponding
-to the source version x.y.z (leading zeros in y and z).  Beta versions
-were given the previous public release number plus a letter, until
-version 1.0.6j; from then on they were given the upcoming public
-release number plus "betaNN" or "rcNN".
+Henceforth the source version will match the shared-library minor and
+patch numbers; the shared-library major version number will be used for
+changes in backward compatibility, as it is intended.
+The PNG_PNGLIB_VER macro, which is not used within libpng but is
+available for applications, is an unsigned integer of the form XYYZZ
+corresponding to the source version X.Y.Z (leading zeros in Y and Z).
+Beta versions were given the previous public release number plus a
+letter, until version 1.0.6j; from then on they were given the upcoming
+public release number plus "betaNN" or "rcNN".
 
 .SH "SEE ALSO"
 .IR libpngpf(3) ", " png(5)
@@ -6081,8 +6029,9 @@ In the case of any inconsistency between the PNG specification
 and this library, the specification takes precedence.
 
 .SH AUTHORS
-This man page: Glenn Randers-Pehrson
-<glennrp at users.sourceforge.net>
+This man page:
+Initially created by Glenn Randers-Pehrson.
+Maintained by Cosmin Truta.
 
 The contributing authors would like to thank all those who helped
 with testing, bug fixes, and patience.  This wouldn't have been
@@ -6090,160 +6039,14 @@ possible without all of you.
 
 Thanks to Frank J. T. Wojcik for helping with the documentation.
 
-Libpng version 1.6.34 - September 29, 2017:
+Libpng:
 Initially created in 1995 by Guy Eric Schalnat, then of Group 42, Inc.
-Currently maintained by Glenn Randers-Pehrson (glennrp at users.sourceforge.net).
+Maintained by Cosmin Truta.
 
 Supported by the PNG development group
 .br
-png-mng-implement at lists.sf.net
-(subscription required; visit
 png-mng-implement at lists.sourceforge.net (subscription required; visit
 https://lists.sourceforge.net/lists/listinfo/png-mng-implement
 to subscribe).
 
-.SH NOTICES:
-
-This copy of the libpng notices is provided for your convenience.  In case of
-any discrepancy between this copy and the notices in the file png.h that is
-included in the libpng distribution, the latter shall prevail.
-
-COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:
-
-If you modify libpng you may insert additional notices immediately following
-this sentence.
-
-This code is released under the libpng license.
-
-libpng versions 1.0.7, July 1, 2000 through 1.6.34, September 29, 2017 are
-Copyright (c) 2000-2002, 2004, 2006-2017 Glenn Randers-Pehrson, are
-derived from libpng-1.0.6, and are distributed according to the same
-disclaimer and license as libpng-1.0.6 with the following individuals
-added to the list of Contributing Authors:
-
-   Simon-Pierre Cadieux
-   Eric S. Raymond
-   Mans Rullgard
-   Cosmin Truta
-   Gilles Vollant
-   James Yu
-   Mandar Sahastrabuddhe
-   Google Inc.
-   Vadim Barkov
-
-and with the following additions to the disclaimer:
-
-   There is no warranty against interference with your enjoyment of the
-   library or against infringement.  There is no warranty that our
-   efforts or the library will fulfill any of your particular purposes
-   or needs.  This library is provided with all faults, and the entire
-   risk of satisfactory quality, performance, accuracy, and effort is with
-   the user.
-
-Some files in the "contrib" directory and some configure-generated
-files that are distributed with libpng have other copyright owners and
-are released under other open source licenses.
-
-libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are
-Copyright (c) 1998-2000 Glenn Randers-Pehrson, are derived from
-libpng-0.96, and are distributed according to the same disclaimer and
-license as libpng-0.96, with the following individuals added to the list
-of Contributing Authors:
-
-   Tom Lane
-   Glenn Randers-Pehrson
-   Willem van Schaik
-
-libpng versions 0.89, June 1996, through 0.96, May 1997, are
-Copyright (c) 1996-1997 Andreas Dilger, are derived from libpng-0.88,
-and are distributed according to the same disclaimer and license as
-libpng-0.88, with the following individuals added to the list of
-Contributing Authors:
-
-   John Bowler
-   Kevin Bracey
-   Sam Bushell
-   Magnus Holmgren
-   Greg Roelofs
-   Tom Tanner
-
-Some files in the "scripts" directory have other copyright owners
-but are released under this license.
-
-libpng versions 0.5, May 1995, through 0.88, January 1996, are
-Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
-
-For the purposes of this copyright and license, "Contributing Authors"
-is defined as the following set of individuals:
-
-   Andreas Dilger
-   Dave Martindale
-   Guy Eric Schalnat
-   Paul Schmidt
-   Tim Wegner
-
-The PNG Reference Library is supplied "AS IS".  The Contributing Authors
-and Group 42, Inc. disclaim all warranties, expressed or implied,
-including, without limitation, the warranties of merchantability and of
-fitness for any purpose.  The Contributing Authors and Group 42, Inc.
-assume no liability for direct, indirect, incidental, special, exemplary,
-or consequential damages, which may result from the use of the PNG
-Reference Library, even if advised of the possibility of such damage.
-
-Permission is hereby granted to use, copy, modify, and distribute this
-source code, or portions hereof, for any purpose, without fee, subject
-to the following restrictions:
-
-  1. The origin of this source code must not be misrepresented.
-
-  2. Altered versions must be plainly marked as such and must not
-     be misrepresented as being the original source.
-
-  3. This Copyright notice may not be removed or altered from any
-     source or altered source distribution.
-
-The Contributing Authors and Group 42, Inc. specifically permit, without
-fee, and encourage the use of this source code as a component to
-supporting the PNG file format in commercial products.  If you use this
-source code in a product, acknowledgment is not required but would be
-appreciated.
-
-END OF COPYRIGHT NOTICE, DISCLAIMER, and LICENSE.
-
-TRADEMARK:
-
-The name "libpng" has not been registered by the Copyright owner
-as a trademark in any jurisdiction.  However, because libpng has
-been distributed and maintained world-wide, continually since 1995,
-the Copyright owner claims "common-law trademark protection" in any
-jurisdiction where common-law trademark is recognized.
-
-OSI CERTIFICATION:
-
-Libpng is OSI Certified Open Source Software.  OSI Certified Open Source is
-a certification mark of the Open Source Initiative. OSI has not addressed
-the additional disclaimers inserted at version 1.0.7.
-
-EXPORT CONTROL:
-
-The Copyright owner believes that the Export Control Classification
-Number (ECCN) for libpng is EAR99, which means not subject to export
-controls or International Traffic in Arms Regulations (ITAR) because
-it is open source, publicly available software, that does not contain
-any encryption software.  See the EAR, paragraphs 734.3(b)(3) and
-734.7(b).
-
-A "png_get_copyright" function is available, for convenient use in "about"
-boxes and the like:
-
-   printf("%s", png_get_copyright(NULL));
-
-Also, the PNG logo (in PNG format, of course) is supplied in the
-files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31).
-
-Glenn Randers-Pehrson
-glennrp at users.sourceforge.net
-September 29, 2017
-
 .\" end of man page
-
diff --git a/Engine/lib/lpng/libpngpf.3 b/Engine/lib/lpng/libpngpf.3
index 8cea87a71..6909c70a3 100644
--- a/Engine/lib/lpng/libpngpf.3
+++ b/Engine/lib/lpng/libpngpf.3
@@ -1,18 +1,24 @@
-.TH LIBPNGPF 3 "April 1, 2017"
+.TH LIBPNGPF 3 "April 14, 2019"
 .SH NAME
-libpng \- Portable Network Graphics (PNG) Reference Library 1.6.34
+libpng \- Portable Network Graphics (PNG) Reference Library 1.6.37
 (private functions)
-.SH SYNOPSIS
-\fB\fB#include \fI\fI"pngpriv.h"
 
-\fB\fBAs of libpng version \fP\fI\fP\fI1.5.1\fP\fB\fP\fB, this section is no longer \fP\fI\fP\fImaintained\fP\fB\fP\fB, now that the private function prototypes are hidden in pngpriv.h and not accessible to applications. Look in pngpriv.h for the prototypes and a short description of each \fI\fIfunction.
+.SH SYNOPSIS
+\fB#include \fI"pngpriv.h"
+
+\fBAs of libpng version \fP\fI1.5.1\fP\fB, this section is no longer
+\fP\fImaintained\fP\fB, now that the private function prototypes are hidden in
+\fP\fIpngpriv.h\fP\fB and not accessible to applications. Look in
+\fP\fIpngpriv.h\fP\fB for the prototypes and a short description of each
+function.
 
 .SH DESCRIPTION
 The functions previously listed here are used privately by libpng and are not
 available for use by applications.  They are not "exported" to applications
 using shared libraries.
 
-.SH SEE ALSO
+.SH "SEE ALSO"
 .BR "png"(5), " libpng"(3), " zlib"(3), " deflate"(5), " " and " zlib"(5)
-.SH AUTHOR
-Glenn Randers-Pehrson
+
+.SH AUTHORS
+Cosmin Truta, Glenn Randers-Pehrson
diff --git a/Engine/lib/lpng/ltmain.sh b/Engine/lib/lpng/ltmain.sh
new file mode 100755
index 000000000..0f0a2da3f
--- /dev/null
+++ b/Engine/lib/lpng/ltmain.sh
@@ -0,0 +1,11147 @@
+#! /bin/sh
+## DO NOT EDIT - This file generated from ./build-aux/ltmain.in
+##               by inline-source v2014-01-03.01
+
+# libtool (GNU libtool) 2.4.6
+# Provide generalized library-building support services.
+# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
+
+# Copyright (C) 1996-2015 Free Software Foundation, Inc.
+# This is free software; see the source for copying conditions.  There is NO
+# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+# GNU Libtool is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# As a special exception to the GNU General Public License,
+# if you distribute this file as part of a program or library that
+# is built using GNU Libtool, you may include this file under the
+# same distribution terms that you use for the rest of that program.
+#
+# GNU Libtool is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+PROGRAM=libtool
+PACKAGE=libtool
+VERSION=2.4.6
+package_revision=2.4.6
+
+
+## ------ ##
+## Usage. ##
+## ------ ##
+
+# Run './libtool --help' for help with using this script from the
+# command line.
+
+
+## ------------------------------- ##
+## User overridable command paths. ##
+## ------------------------------- ##
+
+# After configure completes, it has a better idea of some of the
+# shell tools we need than the defaults used by the functions shared
+# with bootstrap, so set those here where they can still be over-
+# ridden by the user, but otherwise take precedence.
+
+: ${AUTOCONF="autoconf"}
+: ${AUTOMAKE="automake"}
+
+
+## -------------------------- ##
+## Source external libraries. ##
+## -------------------------- ##
+
+# Much of our low-level functionality needs to be sourced from external
+# libraries, which are installed to $pkgauxdir.
+
+# Set a version string for this script.
+scriptversion=2015-01-20.17; # UTC
+
+# General shell script boiler plate, and helper functions.
+# Written by Gary V. Vaughan, 2004
+
+# Copyright (C) 2004-2015 Free Software Foundation, Inc.
+# This is free software; see the source for copying conditions.  There is NO
+# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+
+# As a special exception to the GNU General Public License, if you distribute
+# this file as part of a program or library that is built using GNU Libtool,
+# you may include this file under the same distribution terms that you use
+# for the rest of that program.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNES FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+# Please report bugs or propose patches to gary@gnu.org.
+
+
+## ------ ##
+## Usage. ##
+## ------ ##
+
+# Evaluate this file near the top of your script to gain access to
+# the functions and variables defined here:
+#
+#   . `echo "$0" | ${SED-sed} 's|[^/]*$||'`/build-aux/funclib.sh
+#
+# If you need to override any of the default environment variable
+# settings, do that before evaluating this file.
+
+
+## -------------------- ##
+## Shell normalisation. ##
+## -------------------- ##
+
+# Some shells need a little help to be as Bourne compatible as possible.
+# Before doing anything else, make sure all that help has been provided!
+
+DUALCASE=1; export DUALCASE # for MKS sh
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+  setopt NO_GLOB_SUBST
+else
+  case `(set -o) 2>/dev/null` in *posix*) set -o posix ;; esac
+fi
+
+# NLS nuisances: We save the old values in case they are required later.
+_G_user_locale=
+_G_safe_locale=
+for _G_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
+do
+  eval "if test set = \"\${$_G_var+set}\"; then
+          save_$_G_var=\$$_G_var
+          $_G_var=C
+	  export $_G_var
+	  _G_user_locale=\"$_G_var=\\\$save_\$_G_var; \$_G_user_locale\"
+	  _G_safe_locale=\"$_G_var=C; \$_G_safe_locale\"
+	fi"
+done
+
+# CDPATH.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+# Make sure IFS has a sensible default
+sp=' '
+nl='
+'
+IFS="$sp	$nl"
+
+# There are apparently some retarded systems that use ';' as a PATH separator!
+if test "${PATH_SEPARATOR+set}" != set; then
+  PATH_SEPARATOR=:
+  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
+    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
+      PATH_SEPARATOR=';'
+  }
+fi
+
+
+
+## ------------------------- ##
+## Locate command utilities. ##
+## ------------------------- ##
+
+
+# func_executable_p FILE
+# ----------------------
+# Check that FILE is an executable regular file.
+func_executable_p ()
+{
+    test -f "$1" && test -x "$1"
+}
+
+
+# func_path_progs PROGS_LIST CHECK_FUNC [PATH]
+# --------------------------------------------
+# Search for either a program that responds to --version with output
+# containing "GNU", or else returned by CHECK_FUNC otherwise, by
+# trying all the directories in PATH with each of the elements of
+# PROGS_LIST.
+#
+# CHECK_FUNC should accept the path to a candidate program, and
+# set $func_check_prog_result if it truncates its output less than
+# $_G_path_prog_max characters.
+func_path_progs ()
+{
+    _G_progs_list=$1
+    _G_check_func=$2
+    _G_PATH=${3-"$PATH"}
+
+    _G_path_prog_max=0
+    _G_path_prog_found=false
+    _G_save_IFS=$IFS; IFS=${PATH_SEPARATOR-:}
+    for _G_dir in $_G_PATH; do
+      IFS=$_G_save_IFS
+      test -z "$_G_dir" && _G_dir=.
+      for _G_prog_name in $_G_progs_list; do
+        for _exeext in '' .EXE; do
+          _G_path_prog=$_G_dir/$_G_prog_name$_exeext
+          func_executable_p "$_G_path_prog" || continue
+          case `"$_G_path_prog" --version 2>&1` in
+            *GNU*) func_path_progs_result=$_G_path_prog _G_path_prog_found=: ;;
+            *)     $_G_check_func $_G_path_prog
+		   func_path_progs_result=$func_check_prog_result
+		   ;;
+          esac
+          $_G_path_prog_found && break 3
+        done
+      done
+    done
+    IFS=$_G_save_IFS
+    test -z "$func_path_progs_result" && {
+      echo "no acceptable sed could be found in \$PATH" >&2
+      exit 1
+    }
+}
+
+
+# We want to be able to use the functions in this file before configure
+# has figured out where the best binaries are kept, which means we have
+# to search for them ourselves - except when the results are already set
+# where we skip the searches.
+
+# Unless the user overrides by setting SED, search the path for either GNU
+# sed, or the sed that truncates its output the least.
+test -z "$SED" && {
+  _G_sed_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
+  for _G_i in 1 2 3 4 5 6 7; do
+    _G_sed_script=$_G_sed_script$nl$_G_sed_script
+  done
+  echo "$_G_sed_script" 2>/dev/null | sed 99q >conftest.sed
+  _G_sed_script=
+
+  func_check_prog_sed ()
+  {
+    _G_path_prog=$1
+
+    _G_count=0
+    printf 0123456789 >conftest.in
+    while :
+    do
+      cat conftest.in conftest.in >conftest.tmp
+      mv conftest.tmp conftest.in
+      cp conftest.in conftest.nl
+      echo '' >> conftest.nl
+      "$_G_path_prog" -f conftest.sed <conftest.nl >conftest.out 2>/dev/null || break
+      diff conftest.out conftest.nl >/dev/null 2>&1 || break
+      _G_count=`expr $_G_count + 1`
+      if test "$_G_count" -gt "$_G_path_prog_max"; then
+        # Best one so far, save it but keep looking for a better one
+        func_check_prog_result=$_G_path_prog
+        _G_path_prog_max=$_G_count
+      fi
+      # 10*(2^10) chars as input seems more than enough
+      test 10 -lt "$_G_count" && break
+    done
+    rm -f conftest.in conftest.tmp conftest.nl conftest.out
+  }
+
+  func_path_progs "sed gsed" func_check_prog_sed $PATH:/usr/xpg4/bin
+  rm -f conftest.sed
+  SED=$func_path_progs_result
+}
+
+
+# Unless the user overrides by setting GREP, search the path for either GNU
+# grep, or the grep that truncates its output the least.
+test -z "$GREP" && {
+  func_check_prog_grep ()
+  {
+    _G_path_prog=$1
+
+    _G_count=0
+    _G_path_prog_max=0
+    printf 0123456789 >conftest.in
+    while :
+    do
+      cat conftest.in conftest.in >conftest.tmp
+      mv conftest.tmp conftest.in
+      cp conftest.in conftest.nl
+      echo 'GREP' >> conftest.nl
+      "$_G_path_prog" -e 'GREP$' -e '-(cannot match)-' <conftest.nl >conftest.out 2>/dev/null || break
+      diff conftest.out conftest.nl >/dev/null 2>&1 || break
+      _G_count=`expr $_G_count + 1`
+      if test "$_G_count" -gt "$_G_path_prog_max"; then
+        # Best one so far, save it but keep looking for a better one
+        func_check_prog_result=$_G_path_prog
+        _G_path_prog_max=$_G_count
+      fi
+      # 10*(2^10) chars as input seems more than enough
+      test 10 -lt "$_G_count" && break
+    done
+    rm -f conftest.in conftest.tmp conftest.nl conftest.out
+  }
+
+  func_path_progs "grep ggrep" func_check_prog_grep $PATH:/usr/xpg4/bin
+  GREP=$func_path_progs_result
+}
+
+
+## ------------------------------- ##
+## User overridable command paths. ##
+## ------------------------------- ##
+
+# All uppercase variable names are used for environment variables.  These
+# variables can be overridden by the user before calling a script that
+# uses them if a suitable command of that name is not already available
+# in the command search PATH.
+
+: ${CP="cp -f"}
+: ${ECHO="printf %s\n"}
+: ${EGREP="$GREP -E"}
+: ${FGREP="$GREP -F"}
+: ${LN_S="ln -s"}
+: ${MAKE="make"}
+: ${MKDIR="mkdir"}
+: ${MV="mv -f"}
+: ${RM="rm -f"}
+: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
+
+
+## -------------------- ##
+## Useful sed snippets. ##
+## -------------------- ##
+
+sed_dirname='s|/[^/]*$||'
+sed_basename='s|^.*/||'
+
+# Sed substitution that helps us do robust quoting.  It backslashifies
+# metacharacters that are still active within double-quoted strings.
+sed_quote_subst='s|\([`"$\\]\)|\\\1|g'
+
+# Same as above, but do not quote variable references.
+sed_double_quote_subst='s/\(["`\\]\)/\\\1/g'
+
+# Sed substitution that turns a string into a regex matching for the
+# string literally.
+sed_make_literal_regex='s|[].[^$\\*\/]|\\&|g'
+
+# Sed substitution that converts a w32 file name or path
+# that contains forward slashes, into one that contains
+# (escaped) backslashes.  A very naive implementation.
+sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
+
+# Re-'\' parameter expansions in output of sed_double_quote_subst that
+# were '\'-ed in input to the same.  If an odd number of '\' preceded a
+# '$' in input to sed_double_quote_subst, that '$' was protected from
+# expansion.  Since each input '\' is now two '\'s, look for any number
+# of runs of four '\'s followed by two '\'s and then a '$'.  '\' that '$'.
+_G_bs='\\'
+_G_bs2='\\\\'
+_G_bs4='\\\\\\\\'
+_G_dollar='\$'
+sed_double_backslash="\
+  s/$_G_bs4/&\\
+/g
+  s/^$_G_bs2$_G_dollar/$_G_bs&/
+  s/\\([^$_G_bs]\\)$_G_bs2$_G_dollar/\\1$_G_bs2$_G_bs$_G_dollar/g
+  s/\n//g"
+
+
+## ----------------- ##
+## Global variables. ##
+## ----------------- ##
+
+# Except for the global variables explicitly listed below, the following
+# functions in the '^func_' namespace, and the '^require_' namespace
+# variables initialised in the 'Resource management' section, sourcing
+# this file will not pollute your global namespace with anything
+# else. There's no portable way to scope variables in Bourne shell
+# though, so actually running these functions will sometimes place
+# results into a variable named after the function, and often use
+# temporary variables in the '^_G_' namespace. If you are careful to
+# avoid using those namespaces casually in your sourcing script, things
+# should continue to work as you expect. And, of course, you can freely
+# overwrite any of the functions or variables defined here before
+# calling anything to customize them.
+
+EXIT_SUCCESS=0
+EXIT_FAILURE=1
+EXIT_MISMATCH=63  # $? = 63 is used to indicate version mismatch to missing.
+EXIT_SKIP=77	  # $? = 77 is used to indicate a skipped test to automake.
+
+# Allow overriding, eg assuming that you follow the convention of
+# putting '$debug_cmd' at the start of all your functions, you can get
+# bash to show function call trace with:
+#
+#    debug_cmd='eval echo "${FUNCNAME[0]} $*" >&2' bash your-script-name
+debug_cmd=${debug_cmd-":"}
+exit_cmd=:
+
+# By convention, finish your script with:
+#
+#    exit $exit_status
+#
+# so that you can set exit_status to non-zero if you want to indicate
+# something went wrong during execution without actually bailing out at
+# the point of failure.
+exit_status=$EXIT_SUCCESS
+
+# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
+# is ksh but when the shell is invoked as "sh" and the current value of
+# the _XPG environment variable is not equal to 1 (one), the special
+# positional parameter $0, within a function call, is the name of the
+# function.
+progpath=$0
+
+# The name of this program.
+progname=`$ECHO "$progpath" |$SED "$sed_basename"`
+
+# Make sure we have an absolute progpath for reexecution:
+case $progpath in
+  [\\/]*|[A-Za-z]:\\*) ;;
+  *[\\/]*)
+     progdir=`$ECHO "$progpath" |$SED "$sed_dirname"`
+     progdir=`cd "$progdir" && pwd`
+     progpath=$progdir/$progname
+     ;;
+  *)
+     _G_IFS=$IFS
+     IFS=${PATH_SEPARATOR-:}
+     for progdir in $PATH; do
+       IFS=$_G_IFS
+       test -x "$progdir/$progname" && break
+     done
+     IFS=$_G_IFS
+     test -n "$progdir" || progdir=`pwd`
+     progpath=$progdir/$progname
+     ;;
+esac
+
+
+## ----------------- ##
+## Standard options. ##
+## ----------------- ##
+
+# The following options affect the operation of the functions defined
+# below, and should be set appropriately depending on run-time para-
+# meters passed on the command line.
+
+opt_dry_run=false
+opt_quiet=false
+opt_verbose=false
+
+# Categories 'all' and 'none' are always available.  Append any others
+# you will pass as the first argument to func_warning from your own
+# code.
+warning_categories=
+
+# By default, display warnings according to 'opt_warning_types'.  Set
+# 'warning_func'  to ':' to elide all warnings, or func_fatal_error to
+# treat the next displayed warning as a fatal error.
+warning_func=func_warn_and_continue
+
+# Set to 'all' to display all warnings, 'none' to suppress all
+# warnings, or a space delimited list of some subset of
+# 'warning_categories' to display only the listed warnings.
+opt_warning_types=all
+
+
+## -------------------- ##
+## Resource management. ##
+## -------------------- ##
+
+# This section contains definitions for functions that each ensure a
+# particular resource (a file, or a non-empty configuration variable for
+# example) is available, and if appropriate to extract default values
+# from pertinent package files. Call them using their associated
+# 'require_*' variable to ensure that they are executed, at most, once.
+#
+# It's entirely deliberate that calling these functions can set
+# variables that don't obey the namespace limitations obeyed by the rest
+# of this file, in order that that they be as useful as possible to
+# callers.
+
+
+# require_term_colors
+# -------------------
+# Allow display of bold text on terminals that support it.
+require_term_colors=func_require_term_colors
+func_require_term_colors ()
+{
+    $debug_cmd
+
+    test -t 1 && {
+      # COLORTERM and USE_ANSI_COLORS environment variables take
+      # precedence, because most terminfo databases neglect to describe
+      # whether color sequences are supported.
+      test -n "${COLORTERM+set}" && : ${USE_ANSI_COLORS="1"}
+
+      if test 1 = "$USE_ANSI_COLORS"; then
+        # Standard ANSI escape sequences
+        tc_reset=''
+        tc_bold='';   tc_standout=''
+        tc_red='';   tc_green=''
+        tc_blue='';  tc_cyan=''
+      else
+        # Otherwise trust the terminfo database after all.
+        test -n "`tput sgr0 2>/dev/null`" && {
+          tc_reset=`tput sgr0`
+          test -n "`tput bold 2>/dev/null`" && tc_bold=`tput bold`
+          tc_standout=$tc_bold
+          test -n "`tput smso 2>/dev/null`" && tc_standout=`tput smso`
+          test -n "`tput setaf 1 2>/dev/null`" && tc_red=`tput setaf 1`
+          test -n "`tput setaf 2 2>/dev/null`" && tc_green=`tput setaf 2`
+          test -n "`tput setaf 4 2>/dev/null`" && tc_blue=`tput setaf 4`
+          test -n "`tput setaf 5 2>/dev/null`" && tc_cyan=`tput setaf 5`
+        }
+      fi
+    }
+
+    require_term_colors=:
+}
+
+
+## ----------------- ##
+## Function library. ##
+## ----------------- ##
+
+# This section contains a variety of useful functions to call in your
+# scripts. Take note of the portable wrappers for features provided by
+# some modern shells, which will fall back to slower equivalents on
+# less featureful shells.
+
+
+# func_append VAR VALUE
+# ---------------------
+# Append VALUE onto the existing contents of VAR.
+
+  # We should try to minimise forks, especially on Windows where they are
+  # unreasonably slow, so skip the feature probes when bash or zsh are
+  # being used:
+  if test set = "${BASH_VERSION+set}${ZSH_VERSION+set}"; then
+    : ${_G_HAVE_ARITH_OP="yes"}
+    : ${_G_HAVE_XSI_OPS="yes"}
+    # The += operator was introduced in bash 3.1
+    case $BASH_VERSION in
+      [12].* | 3.0 | 3.0*) ;;
+      *)
+        : ${_G_HAVE_PLUSEQ_OP="yes"}
+        ;;
+    esac
+  fi
+
+  # _G_HAVE_PLUSEQ_OP
+  # Can be empty, in which case the shell is probed, "yes" if += is
+  # useable or anything else if it does not work.
+  test -z "$_G_HAVE_PLUSEQ_OP" \
+    && (eval 'x=a; x+=" b"; test "a b" = "$x"') 2>/dev/null \
+    && _G_HAVE_PLUSEQ_OP=yes
+
+if test yes = "$_G_HAVE_PLUSEQ_OP"
+then
+  # This is an XSI compatible shell, allowing a faster implementation...
+  eval 'func_append ()
+  {
+    $debug_cmd
+
+    eval "$1+=\$2"
+  }'
+else
+  # ...otherwise fall back to using expr, which is often a shell builtin.
+  func_append ()
+  {
+    $debug_cmd
+
+    eval "$1=\$$1\$2"
+  }
+fi
+
+
+# func_append_quoted VAR VALUE
+# ----------------------------
+# Quote VALUE and append to the end of shell variable VAR, separated
+# by a space.
+if test yes = "$_G_HAVE_PLUSEQ_OP"; then
+  eval 'func_append_quoted ()
+  {
+    $debug_cmd
+
+    func_quote_for_eval "$2"
+    eval "$1+=\\ \$func_quote_for_eval_result"
+  }'
+else
+  func_append_quoted ()
+  {
+    $debug_cmd
+
+    func_quote_for_eval "$2"
+    eval "$1=\$$1\\ \$func_quote_for_eval_result"
+  }
+fi
+
+
+# func_append_uniq VAR VALUE
+# --------------------------
+# Append unique VALUE onto the existing contents of VAR, assuming
+# entries are delimited by the first character of VALUE.  For example:
+#
+#   func_append_uniq options " --another-option option-argument"
+#
+# will only append to $options if " --another-option option-argument "
+# is not already present somewhere in $options already (note spaces at
+# each end implied by leading space in second argument).
+func_append_uniq ()
+{
+    $debug_cmd
+
+    eval _G_current_value='`$ECHO $'$1'`'
+    _G_delim=`expr "$2" : '\(.\)'`
+
+    case $_G_delim$_G_current_value$_G_delim in
+      *"$2$_G_delim"*) ;;
+      *) func_append "$@" ;;
+    esac
+}
+
+
+# func_arith TERM...
+# ------------------
+# Set func_arith_result to the result of evaluating TERMs.
+  test -z "$_G_HAVE_ARITH_OP" \
+    && (eval 'test 2 = $(( 1 + 1 ))') 2>/dev/null \
+    && _G_HAVE_ARITH_OP=yes
+
+if test yes = "$_G_HAVE_ARITH_OP"; then
+  eval 'func_arith ()
+  {
+    $debug_cmd
+
+    func_arith_result=$(( $* ))
+  }'
+else
+  func_arith ()
+  {
+    $debug_cmd
+
+    func_arith_result=`expr "$@"`
+  }
+fi
+
+
+# func_basename FILE
+# ------------------
+# Set func_basename_result to FILE with everything up to and including
+# the last / stripped.
+if test yes = "$_G_HAVE_XSI_OPS"; then
+  # If this shell supports suffix pattern removal, then use it to avoid
+  # forking. Hide the definitions single quotes in case the shell chokes
+  # on unsupported syntax...
+  _b='func_basename_result=${1##*/}'
+  _d='case $1 in
+        */*) func_dirname_result=${1%/*}$2 ;;
+        *  ) func_dirname_result=$3        ;;
+      esac'
+
+else
+  # ...otherwise fall back to using sed.
+  _b='func_basename_result=`$ECHO "$1" |$SED "$sed_basename"`'
+  _d='func_dirname_result=`$ECHO "$1"  |$SED "$sed_dirname"`
+      if test "X$func_dirname_result" = "X$1"; then
+        func_dirname_result=$3
+      else
+        func_append func_dirname_result "$2"
+      fi'
+fi
+
+eval 'func_basename ()
+{
+    $debug_cmd
+
+    '"$_b"'
+}'
+
+
+# func_dirname FILE APPEND NONDIR_REPLACEMENT
+# -------------------------------------------
+# Compute the dirname of FILE.  If nonempty, add APPEND to the result,
+# otherwise set result to NONDIR_REPLACEMENT.
+eval 'func_dirname ()
+{
+    $debug_cmd
+
+    '"$_d"'
+}'
+
+
+# func_dirname_and_basename FILE APPEND NONDIR_REPLACEMENT
+# --------------------------------------------------------
+# Perform func_basename and func_dirname in a single function
+# call:
+#   dirname:  Compute the dirname of FILE.  If nonempty,
+#             add APPEND to the result, otherwise set result
+#             to NONDIR_REPLACEMENT.
+#             value returned in "$func_dirname_result"
+#   basename: Compute filename of FILE.
+#             value retuned in "$func_basename_result"
+# For efficiency, we do not delegate to the functions above but instead
+# duplicate the functionality here.
+eval 'func_dirname_and_basename ()
+{
+    $debug_cmd
+
+    '"$_b"'
+    '"$_d"'
+}'
+
+
+# func_echo ARG...
+# ----------------
+# Echo program name prefixed message.
+func_echo ()
+{
+    $debug_cmd
+
+    _G_message=$*
+
+    func_echo_IFS=$IFS
+    IFS=$nl
+    for _G_line in $_G_message; do
+      IFS=$func_echo_IFS
+      $ECHO "$progname: $_G_line"
+    done
+    IFS=$func_echo_IFS
+}
+
+
+# func_echo_all ARG...
+# --------------------
+# Invoke $ECHO with all args, space-separated.
+func_echo_all ()
+{
+    $ECHO "$*"
+}
+
+
+# func_echo_infix_1 INFIX ARG...
+# ------------------------------
+# Echo program name, followed by INFIX on the first line, with any
+# additional lines not showing INFIX.
+func_echo_infix_1 ()
+{
+    $debug_cmd
+
+    $require_term_colors
+
+    _G_infix=$1; shift
+    _G_indent=$_G_infix
+    _G_prefix="$progname: $_G_infix: "
+    _G_message=$*
+
+    # Strip color escape sequences before counting printable length
+    for _G_tc in "$tc_reset" "$tc_bold" "$tc_standout" "$tc_red" "$tc_green" "$tc_blue" "$tc_cyan"
+    do
+      test -n "$_G_tc" && {
+        _G_esc_tc=`$ECHO "$_G_tc" | $SED "$sed_make_literal_regex"`
+        _G_indent=`$ECHO "$_G_indent" | $SED "s|$_G_esc_tc||g"`
+      }
+    done
+    _G_indent="$progname: "`echo "$_G_indent" | $SED 's|.| |g'`"  " ## exclude from sc_prohibit_nested_quotes
+
+    func_echo_infix_1_IFS=$IFS
+    IFS=$nl
+    for _G_line in $_G_message; do
+      IFS=$func_echo_infix_1_IFS
+      $ECHO "$_G_prefix$tc_bold$_G_line$tc_reset" >&2
+      _G_prefix=$_G_indent
+    done
+    IFS=$func_echo_infix_1_IFS
+}
+
+
+# func_error ARG...
+# -----------------
+# Echo program name prefixed message to standard error.
+func_error ()
+{
+    $debug_cmd
+
+    $require_term_colors
+
+    func_echo_infix_1 "  $tc_standout${tc_red}error$tc_reset" "$*" >&2
+}
+
+
+# func_fatal_error ARG...
+# -----------------------
+# Echo program name prefixed message to standard error, and exit.
+func_fatal_error ()
+{
+    $debug_cmd
+
+    func_error "$*"
+    exit $EXIT_FAILURE
+}
+
+
+# func_grep EXPRESSION FILENAME
+# -----------------------------
+# Check whether EXPRESSION matches any line of FILENAME, without output.
+func_grep ()
+{
+    $debug_cmd
+
+    $GREP "$1" "$2" >/dev/null 2>&1
+}
+
+
+# func_len STRING
+# ---------------
+# Set func_len_result to the length of STRING. STRING may not
+# start with a hyphen.
+  test -z "$_G_HAVE_XSI_OPS" \
+    && (eval 'x=a/b/c;
+      test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \
+    && _G_HAVE_XSI_OPS=yes
+
+if test yes = "$_G_HAVE_XSI_OPS"; then
+  eval 'func_len ()
+  {
+    $debug_cmd
+
+    func_len_result=${#1}
+  }'
+else
+  func_len ()
+  {
+    $debug_cmd
+
+    func_len_result=`expr "$1" : ".*" 2>/dev/null || echo $max_cmd_len`
+  }
+fi
+
+
+# func_mkdir_p DIRECTORY-PATH
+# ---------------------------
+# Make sure the entire path to DIRECTORY-PATH is available.
+func_mkdir_p ()
+{
+    $debug_cmd
+
+    _G_directory_path=$1
+    _G_dir_list=
+
+    if test -n "$_G_directory_path" && test : != "$opt_dry_run"; then
+
+      # Protect directory names starting with '-'
+      case $_G_directory_path in
+        -*) _G_directory_path=./$_G_directory_path ;;
+      esac
+
+      # While some portion of DIR does not yet exist...
+      while test ! -d "$_G_directory_path"; do
+        # ...make a list in topmost first order.  Use a colon delimited
+	# list incase some portion of path contains whitespace.
+        _G_dir_list=$_G_directory_path:$_G_dir_list
+
+        # If the last portion added has no slash in it, the list is done
+        case $_G_directory_path in */*) ;; *) break ;; esac
+
+        # ...otherwise throw away the child directory and loop
+        _G_directory_path=`$ECHO "$_G_directory_path" | $SED -e "$sed_dirname"`
+      done
+      _G_dir_list=`$ECHO "$_G_dir_list" | $SED 's|:*$||'`
+
+      func_mkdir_p_IFS=$IFS; IFS=:
+      for _G_dir in $_G_dir_list; do
+	IFS=$func_mkdir_p_IFS
+        # mkdir can fail with a 'File exist' error if two processes
+        # try to create one of the directories concurrently.  Don't
+        # stop in that case!
+        $MKDIR "$_G_dir" 2>/dev/null || :
+      done
+      IFS=$func_mkdir_p_IFS
+
+      # Bail out if we (or some other process) failed to create a directory.
+      test -d "$_G_directory_path" || \
+        func_fatal_error "Failed to create '$1'"
+    fi
+}
+
+
+# func_mktempdir [BASENAME]
+# -------------------------
+# Make a temporary directory that won't clash with other running
+# libtool processes, and avoids race conditions if possible.  If
+# given, BASENAME is the basename for that directory.
+func_mktempdir ()
+{
+    $debug_cmd
+
+    _G_template=${TMPDIR-/tmp}/${1-$progname}
+
+    if test : = "$opt_dry_run"; then
+      # Return a directory name, but don't create it in dry-run mode
+      _G_tmpdir=$_G_template-$$
+    else
+
+      # If mktemp works, use that first and foremost
+      _G_tmpdir=`mktemp -d "$_G_template-XXXXXXXX" 2>/dev/null`
+
+      if test ! -d "$_G_tmpdir"; then
+        # Failing that, at least try and use $RANDOM to avoid a race
+        _G_tmpdir=$_G_template-${RANDOM-0}$$
+
+        func_mktempdir_umask=`umask`
+        umask 0077
+        $MKDIR "$_G_tmpdir"
+        umask $func_mktempdir_umask
+      fi
+
+      # If we're not in dry-run mode, bomb out on failure
+      test -d "$_G_tmpdir" || \
+        func_fatal_error "cannot create temporary directory '$_G_tmpdir'"
+    fi
+
+    $ECHO "$_G_tmpdir"
+}
+
+
+# func_normal_abspath PATH
+# ------------------------
+# Remove doubled-up and trailing slashes, "." path components,
+# and cancel out any ".." path components in PATH after making
+# it an absolute path.
+func_normal_abspath ()
+{
+    $debug_cmd
+
+    # These SED scripts presuppose an absolute path with a trailing slash.
+    _G_pathcar='s|^/\([^/]*\).*$|\1|'
+    _G_pathcdr='s|^/[^/]*||'
+    _G_removedotparts=':dotsl
+		s|/\./|/|g
+		t dotsl
+		s|/\.$|/|'
+    _G_collapseslashes='s|/\{1,\}|/|g'
+    _G_finalslash='s|/*$|/|'
+
+    # Start from root dir and reassemble the path.
+    func_normal_abspath_result=
+    func_normal_abspath_tpath=$1
+    func_normal_abspath_altnamespace=
+    case $func_normal_abspath_tpath in
+      "")
+        # Empty path, that just means $cwd.
+        func_stripname '' '/' "`pwd`"
+        func_normal_abspath_result=$func_stripname_result
+        return
+        ;;
+      # The next three entries are used to spot a run of precisely
+      # two leading slashes without using negated character classes;
+      # we take advantage of case's first-match behaviour.
+      ///*)
+        # Unusual form of absolute path, do nothing.
+        ;;
+      //*)
+        # Not necessarily an ordinary path; POSIX reserves leading '//'
+        # and for example Cygwin uses it to access remote file shares
+        # over CIFS/SMB, so we conserve a leading double slash if found.
+        func_normal_abspath_altnamespace=/
+        ;;
+      /*)
+        # Absolute path, do nothing.
+        ;;
+      *)
+        # Relative path, prepend $cwd.
+        func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
+        ;;
+    esac
+
+    # Cancel out all the simple stuff to save iterations.  We also want
+    # the path to end with a slash for ease of parsing, so make sure
+    # there is one (and only one) here.
+    func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
+          -e "$_G_removedotparts" -e "$_G_collapseslashes" -e "$_G_finalslash"`
+    while :; do
+      # Processed it all yet?
+      if test / = "$func_normal_abspath_tpath"; then
+        # If we ascended to the root using ".." the result may be empty now.
+        if test -z "$func_normal_abspath_result"; then
+          func_normal_abspath_result=/
+        fi
+        break
+      fi
+      func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
+          -e "$_G_pathcar"`
+      func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
+          -e "$_G_pathcdr"`
+      # Figure out what to do with it
+      case $func_normal_abspath_tcomponent in
+        "")
+          # Trailing empty path component, ignore it.
+          ;;
+        ..)
+          # Parent dir; strip last assembled component from result.
+          func_dirname "$func_normal_abspath_result"
+          func_normal_abspath_result=$func_dirname_result
+          ;;
+        *)
+          # Actual path component, append it.
+          func_append func_normal_abspath_result "/$func_normal_abspath_tcomponent"
+          ;;
+      esac
+    done
+    # Restore leading double-slash if one was found on entry.
+    func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
+}
+
+
+# func_notquiet ARG...
+# --------------------
+# Echo program name prefixed message only when not in quiet mode.
+func_notquiet ()
+{
+    $debug_cmd
+
+    $opt_quiet || func_echo ${1+"$@"}
+
+    # A bug in bash halts the script if the last line of a function
+    # fails when set -e is in force, so we need another command to
+    # work around that:
+    :
+}
+
+
+# func_relative_path SRCDIR DSTDIR
+# --------------------------------
+# Set func_relative_path_result to the relative path from SRCDIR to DSTDIR.
+func_relative_path ()
+{
+    $debug_cmd
+
+    func_relative_path_result=
+    func_normal_abspath "$1"
+    func_relative_path_tlibdir=$func_normal_abspath_result
+    func_normal_abspath "$2"
+    func_relative_path_tbindir=$func_normal_abspath_result
+
+    # Ascend the tree starting from libdir
+    while :; do
+      # check if we have found a prefix of bindir
+      case $func_relative_path_tbindir in
+        $func_relative_path_tlibdir)
+          # found an exact match
+          func_relative_path_tcancelled=
+          break
+          ;;
+        $func_relative_path_tlibdir*)
+          # found a matching prefix
+          func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
+          func_relative_path_tcancelled=$func_stripname_result
+          if test -z "$func_relative_path_result"; then
+            func_relative_path_result=.
+          fi
+          break
+          ;;
+        *)
+          func_dirname $func_relative_path_tlibdir
+          func_relative_path_tlibdir=$func_dirname_result
+          if test -z "$func_relative_path_tlibdir"; then
+            # Have to descend all the way to the root!
+            func_relative_path_result=../$func_relative_path_result
+            func_relative_path_tcancelled=$func_relative_path_tbindir
+            break
+          fi
+          func_relative_path_result=../$func_relative_path_result
+          ;;
+      esac
+    done
+
+    # Now calculate path; take care to avoid doubling-up slashes.
+    func_stripname '' '/' "$func_relative_path_result"
+    func_relative_path_result=$func_stripname_result
+    func_stripname '/' '/' "$func_relative_path_tcancelled"
+    if test -n "$func_stripname_result"; then
+      func_append func_relative_path_result "/$func_stripname_result"
+    fi
+
+    # Normalisation. If bindir is libdir, return '.' else relative path.
+    if test -n "$func_relative_path_result"; then
+      func_stripname './' '' "$func_relative_path_result"
+      func_relative_path_result=$func_stripname_result
+    fi
+
+    test -n "$func_relative_path_result" || func_relative_path_result=.
+
+    :
+}
+
+
+# func_quote_for_eval ARG...
+# --------------------------
+# Aesthetically quote ARGs to be evaled later.
+# This function returns two values:
+#   i) func_quote_for_eval_result
+#      double-quoted, suitable for a subsequent eval
+#  ii) func_quote_for_eval_unquoted_result
+#      has all characters that are still active within double
+#      quotes backslashified.
+func_quote_for_eval ()
+{
+    $debug_cmd
+
+    func_quote_for_eval_unquoted_result=
+    func_quote_for_eval_result=
+    while test 0 -lt $#; do
+      case $1 in
+        *[\\\`\"\$]*)
+	  _G_unquoted_arg=`printf '%s\n' "$1" |$SED "$sed_quote_subst"` ;;
+        *)
+          _G_unquoted_arg=$1 ;;
+      esac
+      if test -n "$func_quote_for_eval_unquoted_result"; then
+	func_append func_quote_for_eval_unquoted_result " $_G_unquoted_arg"
+      else
+        func_append func_quote_for_eval_unquoted_result "$_G_unquoted_arg"
+      fi
+
+      case $_G_unquoted_arg in
+        # Double-quote args containing shell metacharacters to delay
+        # word splitting, command substitution and variable expansion
+        # for a subsequent eval.
+        # Many Bourne shells cannot handle close brackets correctly
+        # in scan sets, so we specify it separately.
+        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+          _G_quoted_arg=\"$_G_unquoted_arg\"
+          ;;
+        *)
+          _G_quoted_arg=$_G_unquoted_arg
+	  ;;
+      esac
+
+      if test -n "$func_quote_for_eval_result"; then
+	func_append func_quote_for_eval_result " $_G_quoted_arg"
+      else
+        func_append func_quote_for_eval_result "$_G_quoted_arg"
+      fi
+      shift
+    done
+}
+
+
+# func_quote_for_expand ARG
+# -------------------------
+# Aesthetically quote ARG to be evaled later; same as above,
+# but do not quote variable references.
+func_quote_for_expand ()
+{
+    $debug_cmd
+
+    case $1 in
+      *[\\\`\"]*)
+	_G_arg=`$ECHO "$1" | $SED \
+	    -e "$sed_double_quote_subst" -e "$sed_double_backslash"` ;;
+      *)
+        _G_arg=$1 ;;
+    esac
+
+    case $_G_arg in
+      # Double-quote args containing shell metacharacters to delay
+      # word splitting and command substitution for a subsequent eval.
+      # Many Bourne shells cannot handle close brackets correctly
+      # in scan sets, so we specify it separately.
+      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+        _G_arg=\"$_G_arg\"
+        ;;
+    esac
+
+    func_quote_for_expand_result=$_G_arg
+}
+
+
+# func_stripname PREFIX SUFFIX NAME
+# ---------------------------------
+# strip PREFIX and SUFFIX from NAME, and store in func_stripname_result.
+# PREFIX and SUFFIX must not contain globbing or regex special
+# characters, hashes, percent signs, but SUFFIX may contain a leading
+# dot (in which case that matches only a dot).
+if test yes = "$_G_HAVE_XSI_OPS"; then
+  eval 'func_stripname ()
+  {
+    $debug_cmd
+
+    # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are
+    # positional parameters, so assign one to ordinary variable first.
+    func_stripname_result=$3
+    func_stripname_result=${func_stripname_result#"$1"}
+    func_stripname_result=${func_stripname_result%"$2"}
+  }'
+else
+  func_stripname ()
+  {
+    $debug_cmd
+
+    case $2 in
+      .*) func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%\\\\$2\$%%"`;;
+      *)  func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%$2\$%%"`;;
+    esac
+  }
+fi
+
+
+# func_show_eval CMD [FAIL_EXP]
+# -----------------------------
+# Unless opt_quiet is true, then output CMD.  Then, if opt_dryrun is
+# not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
+# is given, then evaluate it.
+func_show_eval ()
+{
+    $debug_cmd
+
+    _G_cmd=$1
+    _G_fail_exp=${2-':'}
+
+    func_quote_for_expand "$_G_cmd"
+    eval "func_notquiet $func_quote_for_expand_result"
+
+    $opt_dry_run || {
+      eval "$_G_cmd"
+      _G_status=$?
+      if test 0 -ne "$_G_status"; then
+	eval "(exit $_G_status); $_G_fail_exp"
+      fi
+    }
+}
+
+
+# func_show_eval_locale CMD [FAIL_EXP]
+# ------------------------------------
+# Unless opt_quiet is true, then output CMD.  Then, if opt_dryrun is
+# not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
+# is given, then evaluate it.  Use the saved locale for evaluation.
+func_show_eval_locale ()
+{
+    $debug_cmd
+
+    _G_cmd=$1
+    _G_fail_exp=${2-':'}
+
+    $opt_quiet || {
+      func_quote_for_expand "$_G_cmd"
+      eval "func_echo $func_quote_for_expand_result"
+    }
+
+    $opt_dry_run || {
+      eval "$_G_user_locale
+	    $_G_cmd"
+      _G_status=$?
+      eval "$_G_safe_locale"
+      if test 0 -ne "$_G_status"; then
+	eval "(exit $_G_status); $_G_fail_exp"
+      fi
+    }
+}
+
+
+# func_tr_sh
+# ----------
+# Turn $1 into a string suitable for a shell variable name.
+# Result is stored in $func_tr_sh_result.  All characters
+# not in the set a-zA-Z0-9_ are replaced with '_'. Further,
+# if $1 begins with a digit, a '_' is prepended as well.
+func_tr_sh ()
+{
+    $debug_cmd
+
+    case $1 in
+    [0-9]* | *[!a-zA-Z0-9_]*)
+      func_tr_sh_result=`$ECHO "$1" | $SED -e 's/^\([0-9]\)/_\1/' -e 's/[^a-zA-Z0-9_]/_/g'`
+      ;;
+    * )
+      func_tr_sh_result=$1
+      ;;
+    esac
+}
+
+
+# func_verbose ARG...
+# -------------------
+# Echo program name prefixed message in verbose mode only.
+func_verbose ()
+{
+    $debug_cmd
+
+    $opt_verbose && func_echo "$*"
+
+    :
+}
+
+
+# func_warn_and_continue ARG...
+# -----------------------------
+# Echo program name prefixed warning message to standard error.
+func_warn_and_continue ()
+{
+    $debug_cmd
+
+    $require_term_colors
+
+    func_echo_infix_1 "${tc_red}warning$tc_reset" "$*" >&2
+}
+
+
+# func_warning CATEGORY ARG...
+# ----------------------------
+# Echo program name prefixed warning message to standard error. Warning
+# messages can be filtered according to CATEGORY, where this function
+# elides messages where CATEGORY is not listed in the global variable
+# 'opt_warning_types'.
+func_warning ()
+{
+    $debug_cmd
+
+    # CATEGORY must be in the warning_categories list!
+    case " $warning_categories " in
+      *" $1 "*) ;;
+      *) func_internal_error "invalid warning category '$1'" ;;
+    esac
+
+    _G_category=$1
+    shift
+
+    case " $opt_warning_types " in
+      *" $_G_category "*) $warning_func ${1+"$@"} ;;
+    esac
+}
+
+
+# func_sort_ver VER1 VER2
+# -----------------------
+# 'sort -V' is not generally available.
+# Note this deviates from the version comparison in automake
+# in that it treats 1.5 < 1.5.0, and treats 1.4.4a < 1.4-p3a
+# but this should suffice as we won't be specifying old
+# version formats or redundant trailing .0 in bootstrap.conf.
+# If we did want full compatibility then we should probably
+# use m4_version_compare from autoconf.
+func_sort_ver ()
+{
+    $debug_cmd
+
+    printf '%s\n%s\n' "$1" "$2" \
+      | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n -k 5,5n -k 6,6n -k 7,7n -k 8,8n -k 9,9n
+}
+
+# func_lt_ver PREV CURR
+# ---------------------
+# Return true if PREV and CURR are in the correct order according to
+# func_sort_ver, otherwise false.  Use it like this:
+#
+#  func_lt_ver "$prev_ver" "$proposed_ver" || func_fatal_error "..."
+func_lt_ver ()
+{
+    $debug_cmd
+
+    test "x$1" = x`func_sort_ver "$1" "$2" | $SED 1q`
+}
+
+
+# Local variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'before-save-hook 'time-stamp)
+# time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC"
+# time-stamp-time-zone: "UTC"
+# End:
+#! /bin/sh
+
+# Set a version string for this script.
+scriptversion=2014-01-07.03; # UTC
+
+# A portable, pluggable option parser for Bourne shell.
+# Written by Gary V. Vaughan, 2010
+
+# Copyright (C) 2010-2015 Free Software Foundation, Inc.
+# This is free software; see the source for copying conditions.  There is NO
+# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# Please report bugs or propose patches to gary@gnu.org.
+
+
+## ------ ##
+## Usage. ##
+## ------ ##
+
+# This file is a library for parsing options in your shell scripts along
+# with assorted other useful supporting features that you can make use
+# of too.
+#
+# For the simplest scripts you might need only:
+#
+#   #!/bin/sh
+#   . relative/path/to/funclib.sh
+#   . relative/path/to/options-parser
+#   scriptversion=1.0
+#   func_options ${1+"$@"}
+#   eval set dummy "$func_options_result"; shift
+#   ...rest of your script...
+#
+# In order for the '--version' option to work, you will need to have a
+# suitably formatted comment like the one at the top of this file
+# starting with '# Written by ' and ending with '# warranty; '.
+#
+# For '-h' and '--help' to work, you will also need a one line
+# description of your script's purpose in a comment directly above the
+# '# Written by ' line, like the one at the top of this file.
+#
+# The default options also support '--debug', which will turn on shell
+# execution tracing (see the comment above debug_cmd below for another
+# use), and '--verbose' and the func_verbose function to allow your script
+# to display verbose messages only when your user has specified
+# '--verbose'.
+#
+# After sourcing this file, you can plug processing for additional
+# options by amending the variables from the 'Configuration' section
+# below, and following the instructions in the 'Option parsing'
+# section further down.
+
+## -------------- ##
+## Configuration. ##
+## -------------- ##
+
+# You should override these variables in your script after sourcing this
+# file so that they reflect the customisations you have added to the
+# option parser.
+
+# The usage line for option parsing errors and the start of '-h' and
+# '--help' output messages. You can embed shell variables for delayed
+# expansion at the time the message is displayed, but you will need to
+# quote other shell meta-characters carefully to prevent them being
+# expanded when the contents are evaled.
+usage='$progpath [OPTION]...'
+
+# Short help message in response to '-h' and '--help'.  Add to this or
+# override it after sourcing this library to reflect the full set of
+# options your script accepts.
+usage_message="\
+       --debug        enable verbose shell tracing
+   -W, --warnings=CATEGORY
+                      report the warnings falling in CATEGORY [all]
+   -v, --verbose      verbosely report processing
+       --version      print version information and exit
+   -h, --help         print short or long help message and exit
+"
+
+# Additional text appended to 'usage_message' in response to '--help'.
+long_help_message="
+Warning categories include:
+       'all'          show all warnings
+       'none'         turn off all the warnings
+       'error'        warnings are treated as fatal errors"
+
+# Help message printed before fatal option parsing errors.
+fatal_help="Try '\$progname --help' for more information."
+
+
+
+## ------------------------- ##
+## Hook function management. ##
+## ------------------------- ##
+
+# This section contains functions for adding, removing, and running hooks
+# to the main code.  A hook is just a named list of of function, that can
+# be run in order later on.
+
+# func_hookable FUNC_NAME
+# -----------------------
+# Declare that FUNC_NAME will run hooks added with
+# 'func_add_hook FUNC_NAME ...'.
+func_hookable ()
+{
+    $debug_cmd
+
+    func_append hookable_fns " $1"
+}
+
+
+# func_add_hook FUNC_NAME HOOK_FUNC
+# ---------------------------------
+# Request that FUNC_NAME call HOOK_FUNC before it returns.  FUNC_NAME must
+# first have been declared "hookable" by a call to 'func_hookable'.
+func_add_hook ()
+{
+    $debug_cmd
+
+    case " $hookable_fns " in
+      *" $1 "*) ;;
+      *) func_fatal_error "'$1' does not accept hook functions." ;;
+    esac
+
+    eval func_append ${1}_hooks '" $2"'
+}
+
+
+# func_remove_hook FUNC_NAME HOOK_FUNC
+# ------------------------------------
+# Remove HOOK_FUNC from the list of functions called by FUNC_NAME.
+func_remove_hook ()
+{
+    $debug_cmd
+
+    eval ${1}_hooks='`$ECHO "\$'$1'_hooks" |$SED "s| '$2'||"`'
+}
+
+
+# func_run_hooks FUNC_NAME [ARG]...
+# ---------------------------------
+# Run all hook functions registered to FUNC_NAME.
+# It is assumed that the list of hook functions contains nothing more
+# than a whitespace-delimited list of legal shell function names, and
+# no effort is wasted trying to catch shell meta-characters or preserve
+# whitespace.
+func_run_hooks ()
+{
+    $debug_cmd
+
+    case " $hookable_fns " in
+      *" $1 "*) ;;
+      *) func_fatal_error "'$1' does not support hook funcions.n" ;;
+    esac
+
+    eval _G_hook_fns=\$$1_hooks; shift
+
+    for _G_hook in $_G_hook_fns; do
+      eval $_G_hook '"$@"'
+
+      # store returned options list back into positional
+      # parameters for next 'cmd' execution.
+      eval _G_hook_result=\$${_G_hook}_result
+      eval set dummy "$_G_hook_result"; shift
+    done
+
+    func_quote_for_eval ${1+"$@"}
+    func_run_hooks_result=$func_quote_for_eval_result
+}
+
+
+
+## --------------- ##
+## Option parsing. ##
+## --------------- ##
+
+# In order to add your own option parsing hooks, you must accept the
+# full positional parameter list in your hook function, remove any
+# options that you action, and then pass back the remaining unprocessed
+# options in '<hooked_function_name>_result', escaped suitably for
+# 'eval'.  Like this:
+#
+#    my_options_prep ()
+#    {
+#        $debug_cmd
+#
+#        # Extend the existing usage message.
+#        usage_message=$usage_message'
+#      -s, --silent       don'\''t print informational messages
+#    '
+#
+#        func_quote_for_eval ${1+"$@"}
+#        my_options_prep_result=$func_quote_for_eval_result
+#    }
+#    func_add_hook func_options_prep my_options_prep
+#
+#
+#    my_silent_option ()
+#    {
+#        $debug_cmd
+#
+#        # Note that for efficiency, we parse as many options as we can
+#        # recognise in a loop before passing the remainder back to the
+#        # caller on the first unrecognised argument we encounter.
+#        while test $# -gt 0; do
+#          opt=$1; shift
+#          case $opt in
+#            --silent|-s) opt_silent=: ;;
+#            # Separate non-argument short options:
+#            -s*)         func_split_short_opt "$_G_opt"
+#                         set dummy "$func_split_short_opt_name" \
+#                             "-$func_split_short_opt_arg" ${1+"$@"}
+#                         shift
+#                         ;;
+#            *)            set dummy "$_G_opt" "$*"; shift; break ;;
+#          esac
+#        done
+#
+#        func_quote_for_eval ${1+"$@"}
+#        my_silent_option_result=$func_quote_for_eval_result
+#    }
+#    func_add_hook func_parse_options my_silent_option
+#
+#
+#    my_option_validation ()
+#    {
+#        $debug_cmd
+#
+#        $opt_silent && $opt_verbose && func_fatal_help "\
+#    '--silent' and '--verbose' options are mutually exclusive."
+#
+#        func_quote_for_eval ${1+"$@"}
+#        my_option_validation_result=$func_quote_for_eval_result
+#    }
+#    func_add_hook func_validate_options my_option_validation
+#
+# You'll alse need to manually amend $usage_message to reflect the extra
+# options you parse.  It's preferable to append if you can, so that
+# multiple option parsing hooks can be added safely.
+
+
+# func_options [ARG]...
+# ---------------------
+# All the functions called inside func_options are hookable. See the
+# individual implementations for details.
+func_hookable func_options
+func_options ()
+{
+    $debug_cmd
+
+    func_options_prep ${1+"$@"}
+    eval func_parse_options \
+        ${func_options_prep_result+"$func_options_prep_result"}
+    eval func_validate_options \
+        ${func_parse_options_result+"$func_parse_options_result"}
+
+    eval func_run_hooks func_options \
+        ${func_validate_options_result+"$func_validate_options_result"}
+
+    # save modified positional parameters for caller
+    func_options_result=$func_run_hooks_result
+}
+
+
+# func_options_prep [ARG]...
+# --------------------------
+# All initialisations required before starting the option parse loop.
+# Note that when calling hook functions, we pass through the list of
+# positional parameters.  If a hook function modifies that list, and
+# needs to propogate that back to rest of this script, then the complete
+# modified list must be put in 'func_run_hooks_result' before
+# returning.
+func_hookable func_options_prep
+func_options_prep ()
+{
+    $debug_cmd
+
+    # Option defaults:
+    opt_verbose=false
+    opt_warning_types=
+
+    func_run_hooks func_options_prep ${1+"$@"}
+
+    # save modified positional parameters for caller
+    func_options_prep_result=$func_run_hooks_result
+}
+
+
+# func_parse_options [ARG]...
+# ---------------------------
+# The main option parsing loop.
+func_hookable func_parse_options
+func_parse_options ()
+{
+    $debug_cmd
+
+    func_parse_options_result=
+
+    # this just eases exit handling
+    while test $# -gt 0; do
+      # Defer to hook functions for initial option parsing, so they
+      # get priority in the event of reusing an option name.
+      func_run_hooks func_parse_options ${1+"$@"}
+
+      # Adjust func_parse_options positional parameters to match
+      eval set dummy "$func_run_hooks_result"; shift
+
+      # Break out of the loop if we already parsed every option.
+      test $# -gt 0 || break
+
+      _G_opt=$1
+      shift
+      case $_G_opt in
+        --debug|-x)   debug_cmd='set -x'
+                      func_echo "enabling shell trace mode"
+                      $debug_cmd
+                      ;;
+
+        --no-warnings|--no-warning|--no-warn)
+                      set dummy --warnings none ${1+"$@"}
+                      shift
+		      ;;
+
+        --warnings|--warning|-W)
+                      test $# = 0 && func_missing_arg $_G_opt && break
+                      case " $warning_categories $1" in
+                        *" $1 "*)
+                          # trailing space prevents matching last $1 above
+                          func_append_uniq opt_warning_types " $1"
+                          ;;
+                        *all)
+                          opt_warning_types=$warning_categories
+                          ;;
+                        *none)
+                          opt_warning_types=none
+                          warning_func=:
+                          ;;
+                        *error)
+                          opt_warning_types=$warning_categories
+                          warning_func=func_fatal_error
+                          ;;
+                        *)
+                          func_fatal_error \
+                             "unsupported warning category: '$1'"
+                          ;;
+                      esac
+                      shift
+                      ;;
+
+        --verbose|-v) opt_verbose=: ;;
+        --version)    func_version ;;
+        -\?|-h)       func_usage ;;
+        --help)       func_help ;;
+
+	# Separate optargs to long options (plugins may need this):
+	--*=*)        func_split_equals "$_G_opt"
+	              set dummy "$func_split_equals_lhs" \
+                          "$func_split_equals_rhs" ${1+"$@"}
+                      shift
+                      ;;
+
+       # Separate optargs to short options:
+        -W*)
+                      func_split_short_opt "$_G_opt"
+                      set dummy "$func_split_short_opt_name" \
+                          "$func_split_short_opt_arg" ${1+"$@"}
+                      shift
+                      ;;
+
+        # Separate non-argument short options:
+        -\?*|-h*|-v*|-x*)
+                      func_split_short_opt "$_G_opt"
+                      set dummy "$func_split_short_opt_name" \
+                          "-$func_split_short_opt_arg" ${1+"$@"}
+                      shift
+                      ;;
+
+        --)           break ;;
+        -*)           func_fatal_help "unrecognised option: '$_G_opt'" ;;
+        *)            set dummy "$_G_opt" ${1+"$@"}; shift; break ;;
+      esac
+    done
+
+    # save modified positional parameters for caller
+    func_quote_for_eval ${1+"$@"}
+    func_parse_options_result=$func_quote_for_eval_result
+}
+
+
+# func_validate_options [ARG]...
+# ------------------------------
+# Perform any sanity checks on option settings and/or unconsumed
+# arguments.
+func_hookable func_validate_options
+func_validate_options ()
+{
+    $debug_cmd
+
+    # Display all warnings if -W was not given.
+    test -n "$opt_warning_types" || opt_warning_types=" $warning_categories"
+
+    func_run_hooks func_validate_options ${1+"$@"}
+
+    # Bail if the options were screwed!
+    $exit_cmd $EXIT_FAILURE
+
+    # save modified positional parameters for caller
+    func_validate_options_result=$func_run_hooks_result
+}
+
+
+
+## ----------------- ##
+## Helper functions. ##
+## ----------------- ##
+
+# This section contains the helper functions used by the rest of the
+# hookable option parser framework in ascii-betical order.
+
+
+# func_fatal_help ARG...
+# ----------------------
+# Echo program name prefixed message to standard error, followed by
+# a help hint, and exit.
+func_fatal_help ()
+{
+    $debug_cmd
+
+    eval \$ECHO \""Usage: $usage"\"
+    eval \$ECHO \""$fatal_help"\"
+    func_error ${1+"$@"}
+    exit $EXIT_FAILURE
+}
+
+
+# func_help
+# ---------
+# Echo long help message to standard output and exit.
+func_help ()
+{
+    $debug_cmd
+
+    func_usage_message
+    $ECHO "$long_help_message"
+    exit 0
+}
+
+
+# func_missing_arg ARGNAME
+# ------------------------
+# Echo program name prefixed message to standard error and set global
+# exit_cmd.
+func_missing_arg ()
+{
+    $debug_cmd
+
+    func_error "Missing argument for '$1'."
+    exit_cmd=exit
+}
+
+
+# func_split_equals STRING
+# ------------------------
+# Set func_split_equals_lhs and func_split_equals_rhs shell variables after
+# splitting STRING at the '=' sign.
+test -z "$_G_HAVE_XSI_OPS" \
+    && (eval 'x=a/b/c;
+      test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \
+    && _G_HAVE_XSI_OPS=yes
+
+if test yes = "$_G_HAVE_XSI_OPS"
+then
+  # This is an XSI compatible shell, allowing a faster implementation...
+  eval 'func_split_equals ()
+  {
+      $debug_cmd
+
+      func_split_equals_lhs=${1%%=*}
+      func_split_equals_rhs=${1#*=}
+      test "x$func_split_equals_lhs" = "x$1" \
+        && func_split_equals_rhs=
+  }'
+else
+  # ...otherwise fall back to using expr, which is often a shell builtin.
+  func_split_equals ()
+  {
+      $debug_cmd
+
+      func_split_equals_lhs=`expr "x$1" : 'x\([^=]*\)'`
+      func_split_equals_rhs=
+      test "x$func_split_equals_lhs" = "x$1" \
+        || func_split_equals_rhs=`expr "x$1" : 'x[^=]*=\(.*\)$'`
+  }
+fi #func_split_equals
+
+
+# func_split_short_opt SHORTOPT
+# -----------------------------
+# Set func_split_short_opt_name and func_split_short_opt_arg shell
+# variables after splitting SHORTOPT after the 2nd character.
+if test yes = "$_G_HAVE_XSI_OPS"
+then
+  # This is an XSI compatible shell, allowing a faster implementation...
+  eval 'func_split_short_opt ()
+  {
+      $debug_cmd
+
+      func_split_short_opt_arg=${1#??}
+      func_split_short_opt_name=${1%"$func_split_short_opt_arg"}
+  }'
+else
+  # ...otherwise fall back to using expr, which is often a shell builtin.
+  func_split_short_opt ()
+  {
+      $debug_cmd
+
+      func_split_short_opt_name=`expr "x$1" : 'x-\(.\)'`
+      func_split_short_opt_arg=`expr "x$1" : 'x-.\(.*\)$'`
+  }
+fi #func_split_short_opt
+
+
+# func_usage
+# ----------
+# Echo short help message to standard output and exit.
+func_usage ()
+{
+    $debug_cmd
+
+    func_usage_message
+    $ECHO "Run '$progname --help |${PAGER-more}' for full usage"
+    exit 0
+}
+
+
+# func_usage_message
+# ------------------
+# Echo short help message to standard output.
+func_usage_message ()
+{
+    $debug_cmd
+
+    eval \$ECHO \""Usage: $usage"\"
+    echo
+    $SED -n 's|^# ||
+        /^Written by/{
+          x;p;x
+        }
+	h
+	/^Written by/q' < "$progpath"
+    echo
+    eval \$ECHO \""$usage_message"\"
+}
+
+
+# func_version
+# ------------
+# Echo version message to standard output and exit.
+func_version ()
+{
+    $debug_cmd
+
+    printf '%s\n' "$progname $scriptversion"
+    $SED -n '
+        /(C)/!b go
+        :more
+        /\./!{
+          N
+          s|\n# | |
+          b more
+        }
+        :go
+        /^# Written by /,/# warranty; / {
+          s|^# ||
+          s|^# *$||
+          s|\((C)\)[ 0-9,-]*[ ,-]\([1-9][0-9]* \)|\1 \2|
+          p
+        }
+        /^# Written by / {
+          s|^# ||
+          p
+        }
+        /^warranty; /q' < "$progpath"
+
+    exit $?
+}
+
+
+# Local variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'before-save-hook 'time-stamp)
+# time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC"
+# time-stamp-time-zone: "UTC"
+# End:
+
+# Set a version string.
+scriptversion='(GNU libtool) 2.4.6'
+
+
+# func_echo ARG...
+# ----------------
+# Libtool also displays the current mode in messages, so override
+# funclib.sh func_echo with this custom definition.
+func_echo ()
+{
+    $debug_cmd
+
+    _G_message=$*
+
+    func_echo_IFS=$IFS
+    IFS=$nl
+    for _G_line in $_G_message; do
+      IFS=$func_echo_IFS
+      $ECHO "$progname${opt_mode+: $opt_mode}: $_G_line"
+    done
+    IFS=$func_echo_IFS
+}
+
+
+# func_warning ARG...
+# -------------------
+# Libtool warnings are not categorized, so override funclib.sh
+# func_warning with this simpler definition.
+func_warning ()
+{
+    $debug_cmd
+
+    $warning_func ${1+"$@"}
+}
+
+
+## ---------------- ##
+## Options parsing. ##
+## ---------------- ##
+
+# Hook in the functions to make sure our own options are parsed during
+# the option parsing loop.
+
+usage='$progpath [OPTION]... [MODE-ARG]...'
+
+# Short help message in response to '-h'.
+usage_message="Options:
+       --config             show all configuration variables
+       --debug              enable verbose shell tracing
+   -n, --dry-run            display commands without modifying any files
+       --features           display basic configuration information and exit
+       --mode=MODE          use operation mode MODE
+       --no-warnings        equivalent to '-Wnone'
+       --preserve-dup-deps  don't remove duplicate dependency libraries
+       --quiet, --silent    don't print informational messages
+       --tag=TAG            use configuration variables from tag TAG
+   -v, --verbose            print more informational messages than default
+       --version            print version information
+   -W, --warnings=CATEGORY  report the warnings falling in CATEGORY [all]
+   -h, --help, --help-all   print short, long, or detailed help message
+"
+
+# Additional text appended to 'usage_message' in response to '--help'.
+func_help ()
+{
+    $debug_cmd
+
+    func_usage_message
+    $ECHO "$long_help_message
+
+MODE must be one of the following:
+
+       clean           remove files from the build directory
+       compile         compile a source file into a libtool object
+       execute         automatically set library path, then run a program
+       finish          complete the installation of libtool libraries
+       install         install libraries or executables
+       link            create a library or an executable
+       uninstall       remove libraries from an installed directory
+
+MODE-ARGS vary depending on the MODE.  When passed as first option,
+'--mode=MODE' may be abbreviated as 'MODE' or a unique abbreviation of that.
+Try '$progname --help --mode=MODE' for a more detailed description of MODE.
+
+When reporting a bug, please describe a test case to reproduce it and
+include the following information:
+
+       host-triplet:   $host
+       shell:          $SHELL
+       compiler:       $LTCC
+       compiler flags: $LTCFLAGS
+       linker:         $LD (gnu? $with_gnu_ld)
+       version:        $progname (GNU libtool) 2.4.6
+       automake:       `($AUTOMAKE --version) 2>/dev/null |$SED 1q`
+       autoconf:       `($AUTOCONF --version) 2>/dev/null |$SED 1q`
+
+Report bugs to <bug-libtool@gnu.org>.
+GNU libtool home page: <http://www.gnu.org/software/libtool/>.
+General help using GNU software: <http://www.gnu.org/gethelp/>."
+    exit 0
+}
+
+
+# func_lo2o OBJECT-NAME
+# ---------------------
+# Transform OBJECT-NAME from a '.lo' suffix to the platform specific
+# object suffix.
+
+lo2o=s/\\.lo\$/.$objext/
+o2lo=s/\\.$objext\$/.lo/
+
+if test yes = "$_G_HAVE_XSI_OPS"; then
+  eval 'func_lo2o ()
+  {
+    case $1 in
+      *.lo) func_lo2o_result=${1%.lo}.$objext ;;
+      *   ) func_lo2o_result=$1               ;;
+    esac
+  }'
+
+  # func_xform LIBOBJ-OR-SOURCE
+  # ---------------------------
+  # Transform LIBOBJ-OR-SOURCE from a '.o' or '.c' (or otherwise)
+  # suffix to a '.lo' libtool-object suffix.
+  eval 'func_xform ()
+  {
+    func_xform_result=${1%.*}.lo
+  }'
+else
+  # ...otherwise fall back to using sed.
+  func_lo2o ()
+  {
+    func_lo2o_result=`$ECHO "$1" | $SED "$lo2o"`
+  }
+
+  func_xform ()
+  {
+    func_xform_result=`$ECHO "$1" | $SED 's|\.[^.]*$|.lo|'`
+  }
+fi
+
+
+# func_fatal_configuration ARG...
+# -------------------------------
+# Echo program name prefixed message to standard error, followed by
+# a configuration failure hint, and exit.
+func_fatal_configuration ()
+{
+    func__fatal_error ${1+"$@"} \
+      "See the $PACKAGE documentation for more information." \
+      "Fatal configuration error."
+}
+
+
+# func_config
+# -----------
+# Display the configuration for all the tags in this script.
+func_config ()
+{
+    re_begincf='^# ### BEGIN LIBTOOL'
+    re_endcf='^# ### END LIBTOOL'
+
+    # Default configuration.
+    $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
+
+    # Now print the configurations for the tags.
+    for tagname in $taglist; do
+      $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
+    done
+
+    exit $?
+}
+
+
+# func_features
+# -------------
+# Display the features supported by this script.
+func_features ()
+{
+    echo "host: $host"
+    if test yes = "$build_libtool_libs"; then
+      echo "enable shared libraries"
+    else
+      echo "disable shared libraries"
+    fi
+    if test yes = "$build_old_libs"; then
+      echo "enable static libraries"
+    else
+      echo "disable static libraries"
+    fi
+
+    exit $?
+}
+
+
+# func_enable_tag TAGNAME
+# -----------------------
+# Verify that TAGNAME is valid, and either flag an error and exit, or
+# enable the TAGNAME tag.  We also add TAGNAME to the global $taglist
+# variable here.
+func_enable_tag ()
+{
+    # Global variable:
+    tagname=$1
+
+    re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
+    re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
+    sed_extractcf=/$re_begincf/,/$re_endcf/p
+
+    # Validate tagname.
+    case $tagname in
+      *[!-_A-Za-z0-9,/]*)
+        func_fatal_error "invalid tag name: $tagname"
+        ;;
+    esac
+
+    # Don't test for the "default" C tag, as we know it's
+    # there but not specially marked.
+    case $tagname in
+        CC) ;;
+    *)
+        if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
+	  taglist="$taglist $tagname"
+
+	  # Evaluate the configuration.  Be careful to quote the path
+	  # and the sed script, to avoid splitting on whitespace, but
+	  # also don't use non-portable quotes within backquotes within
+	  # quotes we have to do it in 2 steps:
+	  extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
+	  eval "$extractedcf"
+        else
+	  func_error "ignoring unknown tag $tagname"
+        fi
+        ;;
+    esac
+}
+
+
+# func_check_version_match
+# ------------------------
+# Ensure that we are using m4 macros, and libtool script from the same
+# release of libtool.
+func_check_version_match ()
+{
+    if test "$package_revision" != "$macro_revision"; then
+      if test "$VERSION" != "$macro_version"; then
+        if test -z "$macro_version"; then
+          cat >&2 <<_LT_EOF
+$progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
+$progname: definition of this LT_INIT comes from an older release.
+$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
+$progname: and run autoconf again.
+_LT_EOF
+        else
+          cat >&2 <<_LT_EOF
+$progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
+$progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
+$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
+$progname: and run autoconf again.
+_LT_EOF
+        fi
+      else
+        cat >&2 <<_LT_EOF
+$progname: Version mismatch error.  This is $PACKAGE $VERSION, revision $package_revision,
+$progname: but the definition of this LT_INIT comes from revision $macro_revision.
+$progname: You should recreate aclocal.m4 with macros from revision $package_revision
+$progname: of $PACKAGE $VERSION and run autoconf again.
+_LT_EOF
+      fi
+
+      exit $EXIT_MISMATCH
+    fi
+}
+
+
+# libtool_options_prep [ARG]...
+# -----------------------------
+# Preparation for options parsed by libtool.
+libtool_options_prep ()
+{
+    $debug_mode
+
+    # Option defaults:
+    opt_config=false
+    opt_dlopen=
+    opt_dry_run=false
+    opt_help=false
+    opt_mode=
+    opt_preserve_dup_deps=false
+    opt_quiet=false
+
+    nonopt=
+    preserve_args=
+
+    # Shorthand for --mode=foo, only valid as the first argument
+    case $1 in
+    clean|clea|cle|cl)
+      shift; set dummy --mode clean ${1+"$@"}; shift
+      ;;
+    compile|compil|compi|comp|com|co|c)
+      shift; set dummy --mode compile ${1+"$@"}; shift
+      ;;
+    execute|execut|execu|exec|exe|ex|e)
+      shift; set dummy --mode execute ${1+"$@"}; shift
+      ;;
+    finish|finis|fini|fin|fi|f)
+      shift; set dummy --mode finish ${1+"$@"}; shift
+      ;;
+    install|instal|insta|inst|ins|in|i)
+      shift; set dummy --mode install ${1+"$@"}; shift
+      ;;
+    link|lin|li|l)
+      shift; set dummy --mode link ${1+"$@"}; shift
+      ;;
+    uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
+      shift; set dummy --mode uninstall ${1+"$@"}; shift
+      ;;
+    esac
+
+    # Pass back the list of options.
+    func_quote_for_eval ${1+"$@"}
+    libtool_options_prep_result=$func_quote_for_eval_result
+}
+func_add_hook func_options_prep libtool_options_prep
+
+
+# libtool_parse_options [ARG]...
+# ---------------------------------
+# Provide handling for libtool specific options.
+libtool_parse_options ()
+{
+    $debug_cmd
+
+    # Perform our own loop to consume as many options as possible in
+    # each iteration.
+    while test $# -gt 0; do
+      _G_opt=$1
+      shift
+      case $_G_opt in
+        --dry-run|--dryrun|-n)
+                        opt_dry_run=:
+                        ;;
+
+        --config)       func_config ;;
+
+        --dlopen|-dlopen)
+                        opt_dlopen="${opt_dlopen+$opt_dlopen
+}$1"
+                        shift
+                        ;;
+
+        --preserve-dup-deps)
+                        opt_preserve_dup_deps=: ;;
+
+        --features)     func_features ;;
+
+        --finish)       set dummy --mode finish ${1+"$@"}; shift ;;
+
+        --help)         opt_help=: ;;
+
+        --help-all)     opt_help=': help-all' ;;
+
+        --mode)         test $# = 0 && func_missing_arg $_G_opt && break
+                        opt_mode=$1
+                        case $1 in
+                          # Valid mode arguments:
+                          clean|compile|execute|finish|install|link|relink|uninstall) ;;
+
+                          # Catch anything else as an error
+                          *) func_error "invalid argument for $_G_opt"
+                             exit_cmd=exit
+                             break
+                             ;;
+                        esac
+                        shift
+                        ;;
+
+        --no-silent|--no-quiet)
+                        opt_quiet=false
+                        func_append preserve_args " $_G_opt"
+                        ;;
+
+        --no-warnings|--no-warning|--no-warn)
+                        opt_warning=false
+                        func_append preserve_args " $_G_opt"
+                        ;;
+
+        --no-verbose)
+                        opt_verbose=false
+                        func_append preserve_args " $_G_opt"
+                        ;;
+
+        --silent|--quiet)
+                        opt_quiet=:
+                        opt_verbose=false
+                        func_append preserve_args " $_G_opt"
+                        ;;
+
+        --tag)          test $# = 0 && func_missing_arg $_G_opt && break
+                        opt_tag=$1
+                        func_append preserve_args " $_G_opt $1"
+                        func_enable_tag "$1"
+                        shift
+                        ;;
+
+        --verbose|-v)   opt_quiet=false
+                        opt_verbose=:
+                        func_append preserve_args " $_G_opt"
+                        ;;
+
+	# An option not handled by this hook function:
+        *)		set dummy "$_G_opt" ${1+"$@"};	shift; break  ;;
+      esac
+    done
+
+
+    # save modified positional parameters for caller
+    func_quote_for_eval ${1+"$@"}
+    libtool_parse_options_result=$func_quote_for_eval_result
+}
+func_add_hook func_parse_options libtool_parse_options
+
+
+
+# libtool_validate_options [ARG]...
+# ---------------------------------
+# Perform any sanity checks on option settings and/or unconsumed
+# arguments.
+libtool_validate_options ()
+{
+    # save first non-option argument
+    if test 0 -lt $#; then
+      nonopt=$1
+      shift
+    fi
+
+    # preserve --debug
+    test : = "$debug_cmd" || func_append preserve_args " --debug"
+
+    case $host in
+      # Solaris2 added to fix http://debbugs.gnu.org/cgi/bugreport.cgi?bug=16452
+      # see also: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=59788
+      *cygwin* | *mingw* | *pw32* | *cegcc* | *solaris2* | *os2*)
+        # don't eliminate duplications in $postdeps and $predeps
+        opt_duplicate_compiler_generated_deps=:
+        ;;
+      *)
+        opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
+        ;;
+    esac
+
+    $opt_help || {
+      # Sanity checks first:
+      func_check_version_match
+
+      test yes != "$build_libtool_libs" \
+        && test yes != "$build_old_libs" \
+        && func_fatal_configuration "not configured to build any kind of library"
+
+      # Darwin sucks
+      eval std_shrext=\"$shrext_cmds\"
+
+      # Only execute mode is allowed to have -dlopen flags.
+      if test -n "$opt_dlopen" && test execute != "$opt_mode"; then
+        func_error "unrecognized option '-dlopen'"
+        $ECHO "$help" 1>&2
+        exit $EXIT_FAILURE
+      fi
+
+      # Change the help message to a mode-specific one.
+      generic_help=$help
+      help="Try '$progname --help --mode=$opt_mode' for more information."
+    }
+
+    # Pass back the unparsed argument list
+    func_quote_for_eval ${1+"$@"}
+    libtool_validate_options_result=$func_quote_for_eval_result
+}
+func_add_hook func_validate_options libtool_validate_options
+
+
+# Process options as early as possible so that --help and --version
+# can return quickly.
+func_options ${1+"$@"}
+eval set dummy "$func_options_result"; shift
+
+
+
+## ----------- ##
+##    Main.    ##
+## ----------- ##
+
+magic='%%%MAGIC variable%%%'
+magic_exe='%%%MAGIC EXE variable%%%'
+
+# Global variables.
+extracted_archives=
+extracted_serial=0
+
+# If this variable is set in any of the actions, the command in it
+# will be execed at the end.  This prevents here-documents from being
+# left over by shells.
+exec_cmd=
+
+
+# A function that is used when there is no print builtin or printf.
+func_fallback_echo ()
+{
+  eval 'cat <<_LTECHO_EOF
+$1
+_LTECHO_EOF'
+}
+
+# func_generated_by_libtool
+# True iff stdin has been generated by Libtool. This function is only
+# a basic sanity check; it will hardly flush out determined imposters.
+func_generated_by_libtool_p ()
+{
+  $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
+}
+
+# func_lalib_p file
+# True iff FILE is a libtool '.la' library or '.lo' object file.
+# This function is only a basic sanity check; it will hardly flush out
+# determined imposters.
+func_lalib_p ()
+{
+    test -f "$1" &&
+      $SED -e 4q "$1" 2>/dev/null | func_generated_by_libtool_p
+}
+
+# func_lalib_unsafe_p file
+# True iff FILE is a libtool '.la' library or '.lo' object file.
+# This function implements the same check as func_lalib_p without
+# resorting to external programs.  To this end, it redirects stdin and
+# closes it afterwards, without saving the original file descriptor.
+# As a safety measure, use it only where a negative result would be
+# fatal anyway.  Works if 'file' does not exist.
+func_lalib_unsafe_p ()
+{
+    lalib_p=no
+    if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
+	for lalib_p_l in 1 2 3 4
+	do
+	    read lalib_p_line
+	    case $lalib_p_line in
+		\#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
+	    esac
+	done
+	exec 0<&5 5<&-
+    fi
+    test yes = "$lalib_p"
+}
+
+# func_ltwrapper_script_p file
+# True iff FILE is a libtool wrapper script
+# This function is only a basic sanity check; it will hardly flush out
+# determined imposters.
+func_ltwrapper_script_p ()
+{
+    test -f "$1" &&
+      $lt_truncate_bin < "$1" 2>/dev/null | func_generated_by_libtool_p
+}
+
+# func_ltwrapper_executable_p file
+# True iff FILE is a libtool wrapper executable
+# This function is only a basic sanity check; it will hardly flush out
+# determined imposters.
+func_ltwrapper_executable_p ()
+{
+    func_ltwrapper_exec_suffix=
+    case $1 in
+    *.exe) ;;
+    *) func_ltwrapper_exec_suffix=.exe ;;
+    esac
+    $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
+}
+
+# func_ltwrapper_scriptname file
+# Assumes file is an ltwrapper_executable
+# uses $file to determine the appropriate filename for a
+# temporary ltwrapper_script.
+func_ltwrapper_scriptname ()
+{
+    func_dirname_and_basename "$1" "" "."
+    func_stripname '' '.exe' "$func_basename_result"
+    func_ltwrapper_scriptname_result=$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper
+}
+
+# func_ltwrapper_p file
+# True iff FILE is a libtool wrapper script or wrapper executable
+# This function is only a basic sanity check; it will hardly flush out
+# determined imposters.
+func_ltwrapper_p ()
+{
+    func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
+}
+
+
+# func_execute_cmds commands fail_cmd
+# Execute tilde-delimited COMMANDS.
+# If FAIL_CMD is given, eval that upon failure.
+# FAIL_CMD may read-access the current command in variable CMD!
+func_execute_cmds ()
+{
+    $debug_cmd
+
+    save_ifs=$IFS; IFS='~'
+    for cmd in $1; do
+      IFS=$sp$nl
+      eval cmd=\"$cmd\"
+      IFS=$save_ifs
+      func_show_eval "$cmd" "${2-:}"
+    done
+    IFS=$save_ifs
+}
+
+
+# func_source file
+# Source FILE, adding directory component if necessary.
+# Note that it is not necessary on cygwin/mingw to append a dot to
+# FILE even if both FILE and FILE.exe exist: automatic-append-.exe
+# behavior happens only for exec(3), not for open(2)!  Also, sourcing
+# 'FILE.' does not work on cygwin managed mounts.
+func_source ()
+{
+    $debug_cmd
+
+    case $1 in
+    */* | *\\*)	. "$1" ;;
+    *)		. "./$1" ;;
+    esac
+}
+
+
+# func_resolve_sysroot PATH
+# Replace a leading = in PATH with a sysroot.  Store the result into
+# func_resolve_sysroot_result
+func_resolve_sysroot ()
+{
+  func_resolve_sysroot_result=$1
+  case $func_resolve_sysroot_result in
+  =*)
+    func_stripname '=' '' "$func_resolve_sysroot_result"
+    func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
+    ;;
+  esac
+}
+
+# func_replace_sysroot PATH
+# If PATH begins with the sysroot, replace it with = and
+# store the result into func_replace_sysroot_result.
+func_replace_sysroot ()
+{
+  case $lt_sysroot:$1 in
+  ?*:"$lt_sysroot"*)
+    func_stripname "$lt_sysroot" '' "$1"
+    func_replace_sysroot_result='='$func_stripname_result
+    ;;
+  *)
+    # Including no sysroot.
+    func_replace_sysroot_result=$1
+    ;;
+  esac
+}
+
+# func_infer_tag arg
+# Infer tagged configuration to use if any are available and
+# if one wasn't chosen via the "--tag" command line option.
+# Only attempt this if the compiler in the base compile
+# command doesn't match the default compiler.
+# arg is usually of the form 'gcc ...'
+func_infer_tag ()
+{
+    $debug_cmd
+
+    if test -n "$available_tags" && test -z "$tagname"; then
+      CC_quoted=
+      for arg in $CC; do
+	func_append_quoted CC_quoted "$arg"
+      done
+      CC_expanded=`func_echo_all $CC`
+      CC_quoted_expanded=`func_echo_all $CC_quoted`
+      case $@ in
+      # Blanks in the command may have been stripped by the calling shell,
+      # but not from the CC environment variable when configure was run.
+      " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
+      " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
+      # Blanks at the start of $base_compile will cause this to fail
+      # if we don't check for them as well.
+      *)
+	for z in $available_tags; do
+	  if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
+	    # Evaluate the configuration.
+	    eval "`$SED -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
+	    CC_quoted=
+	    for arg in $CC; do
+	      # Double-quote args containing other shell metacharacters.
+	      func_append_quoted CC_quoted "$arg"
+	    done
+	    CC_expanded=`func_echo_all $CC`
+	    CC_quoted_expanded=`func_echo_all $CC_quoted`
+	    case "$@ " in
+	    " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
+	    " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
+	      # The compiler in the base compile command matches
+	      # the one in the tagged configuration.
+	      # Assume this is the tagged configuration we want.
+	      tagname=$z
+	      break
+	      ;;
+	    esac
+	  fi
+	done
+	# If $tagname still isn't set, then no tagged configuration
+	# was found and let the user know that the "--tag" command
+	# line option must be used.
+	if test -z "$tagname"; then
+	  func_echo "unable to infer tagged configuration"
+	  func_fatal_error "specify a tag with '--tag'"
+#	else
+#	  func_verbose "using $tagname tagged configuration"
+	fi
+	;;
+      esac
+    fi
+}
+
+
+
+# func_write_libtool_object output_name pic_name nonpic_name
+# Create a libtool object file (analogous to a ".la" file),
+# but don't create it if we're doing a dry run.
+func_write_libtool_object ()
+{
+    write_libobj=$1
+    if test yes = "$build_libtool_libs"; then
+      write_lobj=\'$2\'
+    else
+      write_lobj=none
+    fi
+
+    if test yes = "$build_old_libs"; then
+      write_oldobj=\'$3\'
+    else
+      write_oldobj=none
+    fi
+
+    $opt_dry_run || {
+      cat >${write_libobj}T <<EOF
+# $write_libobj - a libtool object file
+# Generated by $PROGRAM (GNU $PACKAGE) $VERSION
+#
+# Please DO NOT delete this file!
+# It is necessary for linking the library.
+
+# Name of the PIC object.
+pic_object=$write_lobj
+
+# Name of the non-PIC object
+non_pic_object=$write_oldobj
+
+EOF
+      $MV "${write_libobj}T" "$write_libobj"
+    }
+}
+
+
+##################################################
+# FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
+##################################################
+
+# func_convert_core_file_wine_to_w32 ARG
+# Helper function used by file name conversion functions when $build is *nix,
+# and $host is mingw, cygwin, or some other w32 environment. Relies on a
+# correctly configured wine environment available, with the winepath program
+# in $build's $PATH.
+#
+# ARG is the $build file name to be converted to w32 format.
+# Result is available in $func_convert_core_file_wine_to_w32_result, and will
+# be empty on error (or when ARG is empty)
+func_convert_core_file_wine_to_w32 ()
+{
+  $debug_cmd
+
+  func_convert_core_file_wine_to_w32_result=$1
+  if test -n "$1"; then
+    # Unfortunately, winepath does not exit with a non-zero error code, so we
+    # are forced to check the contents of stdout. On the other hand, if the
+    # command is not found, the shell will set an exit code of 127 and print
+    # *an error message* to stdout. So we must check for both error code of
+    # zero AND non-empty stdout, which explains the odd construction:
+    func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
+    if test "$?" -eq 0 && test -n "$func_convert_core_file_wine_to_w32_tmp"; then
+      func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
+        $SED -e "$sed_naive_backslashify"`
+    else
+      func_convert_core_file_wine_to_w32_result=
+    fi
+  fi
+}
+# end: func_convert_core_file_wine_to_w32
+
+
+# func_convert_core_path_wine_to_w32 ARG
+# Helper function used by path conversion functions when $build is *nix, and
+# $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
+# configured wine environment available, with the winepath program in $build's
+# $PATH. Assumes ARG has no leading or trailing path separator characters.
+#
+# ARG is path to be converted from $build format to win32.
+# Result is available in $func_convert_core_path_wine_to_w32_result.
+# Unconvertible file (directory) names in ARG are skipped; if no directory names
+# are convertible, then the result may be empty.
+func_convert_core_path_wine_to_w32 ()
+{
+  $debug_cmd
+
+  # unfortunately, winepath doesn't convert paths, only file names
+  func_convert_core_path_wine_to_w32_result=
+  if test -n "$1"; then
+    oldIFS=$IFS
+    IFS=:
+    for func_convert_core_path_wine_to_w32_f in $1; do
+      IFS=$oldIFS
+      func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
+      if test -n "$func_convert_core_file_wine_to_w32_result"; then
+        if test -z "$func_convert_core_path_wine_to_w32_result"; then
+          func_convert_core_path_wine_to_w32_result=$func_convert_core_file_wine_to_w32_result
+        else
+          func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
+        fi
+      fi
+    done
+    IFS=$oldIFS
+  fi
+}
+# end: func_convert_core_path_wine_to_w32
+
+
+# func_cygpath ARGS...
+# Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
+# when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
+# $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
+# (2), returns the Cygwin file name or path in func_cygpath_result (input
+# file name or path is assumed to be in w32 format, as previously converted
+# from $build's *nix or MSYS format). In case (3), returns the w32 file name
+# or path in func_cygpath_result (input file name or path is assumed to be in
+# Cygwin format). Returns an empty string on error.
+#
+# ARGS are passed to cygpath, with the last one being the file name or path to
+# be converted.
+#
+# Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
+# environment variable; do not put it in $PATH.
+func_cygpath ()
+{
+  $debug_cmd
+
+  if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
+    func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
+    if test "$?" -ne 0; then
+      # on failure, ensure result is empty
+      func_cygpath_result=
+    fi
+  else
+    func_cygpath_result=
+    func_error "LT_CYGPATH is empty or specifies non-existent file: '$LT_CYGPATH'"
+  fi
+}
+#end: func_cygpath
+
+
+# func_convert_core_msys_to_w32 ARG
+# Convert file name or path ARG from MSYS format to w32 format.  Return
+# result in func_convert_core_msys_to_w32_result.
+func_convert_core_msys_to_w32 ()
+{
+  $debug_cmd
+
+  # awkward: cmd appends spaces to result
+  func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
+    $SED -e 's/[ ]*$//' -e "$sed_naive_backslashify"`
+}
+#end: func_convert_core_msys_to_w32
+
+
+# func_convert_file_check ARG1 ARG2
+# Verify that ARG1 (a file name in $build format) was converted to $host
+# format in ARG2. Otherwise, emit an error message, but continue (resetting
+# func_to_host_file_result to ARG1).
+func_convert_file_check ()
+{
+  $debug_cmd
+
+  if test -z "$2" && test -n "$1"; then
+    func_error "Could not determine host file name corresponding to"
+    func_error "  '$1'"
+    func_error "Continuing, but uninstalled executables may not work."
+    # Fallback:
+    func_to_host_file_result=$1
+  fi
+}
+# end func_convert_file_check
+
+
+# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
+# Verify that FROM_PATH (a path in $build format) was converted to $host
+# format in TO_PATH. Otherwise, emit an error message, but continue, resetting
+# func_to_host_file_result to a simplistic fallback value (see below).
+func_convert_path_check ()
+{
+  $debug_cmd
+
+  if test -z "$4" && test -n "$3"; then
+    func_error "Could not determine the host path corresponding to"
+    func_error "  '$3'"
+    func_error "Continuing, but uninstalled executables may not work."
+    # Fallback.  This is a deliberately simplistic "conversion" and
+    # should not be "improved".  See libtool.info.
+    if test "x$1" != "x$2"; then
+      lt_replace_pathsep_chars="s|$1|$2|g"
+      func_to_host_path_result=`echo "$3" |
+        $SED -e "$lt_replace_pathsep_chars"`
+    else
+      func_to_host_path_result=$3
+    fi
+  fi
+}
+# end func_convert_path_check
+
+
+# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
+# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
+# and appending REPL if ORIG matches BACKPAT.
+func_convert_path_front_back_pathsep ()
+{
+  $debug_cmd
+
+  case $4 in
+  $1 ) func_to_host_path_result=$3$func_to_host_path_result
+    ;;
+  esac
+  case $4 in
+  $2 ) func_append func_to_host_path_result "$3"
+    ;;
+  esac
+}
+# end func_convert_path_front_back_pathsep
+
+
+##################################################
+# $build to $host FILE NAME CONVERSION FUNCTIONS #
+##################################################
+# invoked via '$to_host_file_cmd ARG'
+#
+# In each case, ARG is the path to be converted from $build to $host format.
+# Result will be available in $func_to_host_file_result.
+
+
+# func_to_host_file ARG
+# Converts the file name ARG from $build format to $host format. Return result
+# in func_to_host_file_result.
+func_to_host_file ()
+{
+  $debug_cmd
+
+  $to_host_file_cmd "$1"
+}
+# end func_to_host_file
+
+
+# func_to_tool_file ARG LAZY
+# converts the file name ARG from $build format to toolchain format. Return
+# result in func_to_tool_file_result.  If the conversion in use is listed
+# in (the comma separated) LAZY, no conversion takes place.
+func_to_tool_file ()
+{
+  $debug_cmd
+
+  case ,$2, in
+    *,"$to_tool_file_cmd",*)
+      func_to_tool_file_result=$1
+      ;;
+    *)
+      $to_tool_file_cmd "$1"
+      func_to_tool_file_result=$func_to_host_file_result
+      ;;
+  esac
+}
+# end func_to_tool_file
+
+
+# func_convert_file_noop ARG
+# Copy ARG to func_to_host_file_result.
+func_convert_file_noop ()
+{
+  func_to_host_file_result=$1
+}
+# end func_convert_file_noop
+
+
+# func_convert_file_msys_to_w32 ARG
+# Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
+# conversion to w32 is not available inside the cwrapper.  Returns result in
+# func_to_host_file_result.
+func_convert_file_msys_to_w32 ()
+{
+  $debug_cmd
+
+  func_to_host_file_result=$1
+  if test -n "$1"; then
+    func_convert_core_msys_to_w32 "$1"
+    func_to_host_file_result=$func_convert_core_msys_to_w32_result
+  fi
+  func_convert_file_check "$1" "$func_to_host_file_result"
+}
+# end func_convert_file_msys_to_w32
+
+
+# func_convert_file_cygwin_to_w32 ARG
+# Convert file name ARG from Cygwin to w32 format.  Returns result in
+# func_to_host_file_result.
+func_convert_file_cygwin_to_w32 ()
+{
+  $debug_cmd
+
+  func_to_host_file_result=$1
+  if test -n "$1"; then
+    # because $build is cygwin, we call "the" cygpath in $PATH; no need to use
+    # LT_CYGPATH in this case.
+    func_to_host_file_result=`cygpath -m "$1"`
+  fi
+  func_convert_file_check "$1" "$func_to_host_file_result"
+}
+# end func_convert_file_cygwin_to_w32
+
+
+# func_convert_file_nix_to_w32 ARG
+# Convert file name ARG from *nix to w32 format.  Requires a wine environment
+# and a working winepath. Returns result in func_to_host_file_result.
+func_convert_file_nix_to_w32 ()
+{
+  $debug_cmd
+
+  func_to_host_file_result=$1
+  if test -n "$1"; then
+    func_convert_core_file_wine_to_w32 "$1"
+    func_to_host_file_result=$func_convert_core_file_wine_to_w32_result
+  fi
+  func_convert_file_check "$1" "$func_to_host_file_result"
+}
+# end func_convert_file_nix_to_w32
+
+
+# func_convert_file_msys_to_cygwin ARG
+# Convert file name ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
+# Returns result in func_to_host_file_result.
+func_convert_file_msys_to_cygwin ()
+{
+  $debug_cmd
+
+  func_to_host_file_result=$1
+  if test -n "$1"; then
+    func_convert_core_msys_to_w32 "$1"
+    func_cygpath -u "$func_convert_core_msys_to_w32_result"
+    func_to_host_file_result=$func_cygpath_result
+  fi
+  func_convert_file_check "$1" "$func_to_host_file_result"
+}
+# end func_convert_file_msys_to_cygwin
+
+
+# func_convert_file_nix_to_cygwin ARG
+# Convert file name ARG from *nix to Cygwin format.  Requires Cygwin installed
+# in a wine environment, working winepath, and LT_CYGPATH set.  Returns result
+# in func_to_host_file_result.
+func_convert_file_nix_to_cygwin ()
+{
+  $debug_cmd
+
+  func_to_host_file_result=$1
+  if test -n "$1"; then
+    # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
+    func_convert_core_file_wine_to_w32 "$1"
+    func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
+    func_to_host_file_result=$func_cygpath_result
+  fi
+  func_convert_file_check "$1" "$func_to_host_file_result"
+}
+# end func_convert_file_nix_to_cygwin
+
+
+#############################################
+# $build to $host PATH CONVERSION FUNCTIONS #
+#############################################
+# invoked via '$to_host_path_cmd ARG'
+#
+# In each case, ARG is the path to be converted from $build to $host format.
+# The result will be available in $func_to_host_path_result.
+#
+# Path separators are also converted from $build format to $host format.  If
+# ARG begins or ends with a path separator character, it is preserved (but
+# converted to $host format) on output.
+#
+# All path conversion functions are named using the following convention:
+#   file name conversion function    : func_convert_file_X_to_Y ()
+#   path conversion function         : func_convert_path_X_to_Y ()
+# where, for any given $build/$host combination the 'X_to_Y' value is the
+# same.  If conversion functions are added for new $build/$host combinations,
+# the two new functions must follow this pattern, or func_init_to_host_path_cmd
+# will break.
+
+
+# func_init_to_host_path_cmd
+# Ensures that function "pointer" variable $to_host_path_cmd is set to the
+# appropriate value, based on the value of $to_host_file_cmd.
+to_host_path_cmd=
+func_init_to_host_path_cmd ()
+{
+  $debug_cmd
+
+  if test -z "$to_host_path_cmd"; then
+    func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
+    to_host_path_cmd=func_convert_path_$func_stripname_result
+  fi
+}
+
+
+# func_to_host_path ARG
+# Converts the path ARG from $build format to $host format. Return result
+# in func_to_host_path_result.
+func_to_host_path ()
+{
+  $debug_cmd
+
+  func_init_to_host_path_cmd
+  $to_host_path_cmd "$1"
+}
+# end func_to_host_path
+
+
+# func_convert_path_noop ARG
+# Copy ARG to func_to_host_path_result.
+func_convert_path_noop ()
+{
+  func_to_host_path_result=$1
+}
+# end func_convert_path_noop
+
+
+# func_convert_path_msys_to_w32 ARG
+# Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
+# conversion to w32 is not available inside the cwrapper.  Returns result in
+# func_to_host_path_result.
+func_convert_path_msys_to_w32 ()
+{
+  $debug_cmd
+
+  func_to_host_path_result=$1
+  if test -n "$1"; then
+    # Remove leading and trailing path separator characters from ARG.  MSYS
+    # behavior is inconsistent here; cygpath turns them into '.;' and ';.';
+    # and winepath ignores them completely.
+    func_stripname : : "$1"
+    func_to_host_path_tmp1=$func_stripname_result
+    func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
+    func_to_host_path_result=$func_convert_core_msys_to_w32_result
+    func_convert_path_check : ";" \
+      "$func_to_host_path_tmp1" "$func_to_host_path_result"
+    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
+  fi
+}
+# end func_convert_path_msys_to_w32
+
+
+# func_convert_path_cygwin_to_w32 ARG
+# Convert path ARG from Cygwin to w32 format.  Returns result in
+# func_to_host_file_result.
+func_convert_path_cygwin_to_w32 ()
+{
+  $debug_cmd
+
+  func_to_host_path_result=$1
+  if test -n "$1"; then
+    # See func_convert_path_msys_to_w32:
+    func_stripname : : "$1"
+    func_to_host_path_tmp1=$func_stripname_result
+    func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
+    func_convert_path_check : ";" \
+      "$func_to_host_path_tmp1" "$func_to_host_path_result"
+    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
+  fi
+}
+# end func_convert_path_cygwin_to_w32
+
+
+# func_convert_path_nix_to_w32 ARG
+# Convert path ARG from *nix to w32 format.  Requires a wine environment and
+# a working winepath.  Returns result in func_to_host_file_result.
+func_convert_path_nix_to_w32 ()
+{
+  $debug_cmd
+
+  func_to_host_path_result=$1
+  if test -n "$1"; then
+    # See func_convert_path_msys_to_w32:
+    func_stripname : : "$1"
+    func_to_host_path_tmp1=$func_stripname_result
+    func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
+    func_to_host_path_result=$func_convert_core_path_wine_to_w32_result
+    func_convert_path_check : ";" \
+      "$func_to_host_path_tmp1" "$func_to_host_path_result"
+    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
+  fi
+}
+# end func_convert_path_nix_to_w32
+
+
+# func_convert_path_msys_to_cygwin ARG
+# Convert path ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
+# Returns result in func_to_host_file_result.
+func_convert_path_msys_to_cygwin ()
+{
+  $debug_cmd
+
+  func_to_host_path_result=$1
+  if test -n "$1"; then
+    # See func_convert_path_msys_to_w32:
+    func_stripname : : "$1"
+    func_to_host_path_tmp1=$func_stripname_result
+    func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
+    func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
+    func_to_host_path_result=$func_cygpath_result
+    func_convert_path_check : : \
+      "$func_to_host_path_tmp1" "$func_to_host_path_result"
+    func_convert_path_front_back_pathsep ":*" "*:" : "$1"
+  fi
+}
+# end func_convert_path_msys_to_cygwin
+
+
+# func_convert_path_nix_to_cygwin ARG
+# Convert path ARG from *nix to Cygwin format.  Requires Cygwin installed in a
+# a wine environment, working winepath, and LT_CYGPATH set.  Returns result in
+# func_to_host_file_result.
+func_convert_path_nix_to_cygwin ()
+{
+  $debug_cmd
+
+  func_to_host_path_result=$1
+  if test -n "$1"; then
+    # Remove leading and trailing path separator characters from
+    # ARG. msys behavior is inconsistent here, cygpath turns them
+    # into '.;' and ';.', and winepath ignores them completely.
+    func_stripname : : "$1"
+    func_to_host_path_tmp1=$func_stripname_result
+    func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
+    func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
+    func_to_host_path_result=$func_cygpath_result
+    func_convert_path_check : : \
+      "$func_to_host_path_tmp1" "$func_to_host_path_result"
+    func_convert_path_front_back_pathsep ":*" "*:" : "$1"
+  fi
+}
+# end func_convert_path_nix_to_cygwin
+
+
+# func_dll_def_p FILE
+# True iff FILE is a Windows DLL '.def' file.
+# Keep in sync with _LT_DLL_DEF_P in libtool.m4
+func_dll_def_p ()
+{
+  $debug_cmd
+
+  func_dll_def_p_tmp=`$SED -n \
+    -e 's/^[	 ]*//' \
+    -e '/^\(;.*\)*$/d' \
+    -e 's/^\(EXPORTS\|LIBRARY\)\([	 ].*\)*$/DEF/p' \
+    -e q \
+    "$1"`
+  test DEF = "$func_dll_def_p_tmp"
+}
+
+
+# func_mode_compile arg...
+func_mode_compile ()
+{
+    $debug_cmd
+
+    # Get the compilation command and the source file.
+    base_compile=
+    srcfile=$nonopt  #  always keep a non-empty value in "srcfile"
+    suppress_opt=yes
+    suppress_output=
+    arg_mode=normal
+    libobj=
+    later=
+    pie_flag=
+
+    for arg
+    do
+      case $arg_mode in
+      arg  )
+	# do not "continue".  Instead, add this to base_compile
+	lastarg=$arg
+	arg_mode=normal
+	;;
+
+      target )
+	libobj=$arg
+	arg_mode=normal
+	continue
+	;;
+
+      normal )
+	# Accept any command-line options.
+	case $arg in
+	-o)
+	  test -n "$libobj" && \
+	    func_fatal_error "you cannot specify '-o' more than once"
+	  arg_mode=target
+	  continue
+	  ;;
+
+	-pie | -fpie | -fPIE)
+          func_append pie_flag " $arg"
+	  continue
+	  ;;
+
+	-shared | -static | -prefer-pic | -prefer-non-pic)
+	  func_append later " $arg"
+	  continue
+	  ;;
+
+	-no-suppress)
+	  suppress_opt=no
+	  continue
+	  ;;
+
+	-Xcompiler)
+	  arg_mode=arg  #  the next one goes into the "base_compile" arg list
+	  continue      #  The current "srcfile" will either be retained or
+	  ;;            #  replaced later.  I would guess that would be a bug.
+
+	-Wc,*)
+	  func_stripname '-Wc,' '' "$arg"
+	  args=$func_stripname_result
+	  lastarg=
+	  save_ifs=$IFS; IFS=,
+	  for arg in $args; do
+	    IFS=$save_ifs
+	    func_append_quoted lastarg "$arg"
+	  done
+	  IFS=$save_ifs
+	  func_stripname ' ' '' "$lastarg"
+	  lastarg=$func_stripname_result
+
+	  # Add the arguments to base_compile.
+	  func_append base_compile " $lastarg"
+	  continue
+	  ;;
+
+	*)
+	  # Accept the current argument as the source file.
+	  # The previous "srcfile" becomes the current argument.
+	  #
+	  lastarg=$srcfile
+	  srcfile=$arg
+	  ;;
+	esac  #  case $arg
+	;;
+      esac    #  case $arg_mode
+
+      # Aesthetically quote the previous argument.
+      func_append_quoted base_compile "$lastarg"
+    done # for arg
+
+    case $arg_mode in
+    arg)
+      func_fatal_error "you must specify an argument for -Xcompile"
+      ;;
+    target)
+      func_fatal_error "you must specify a target with '-o'"
+      ;;
+    *)
+      # Get the name of the library object.
+      test -z "$libobj" && {
+	func_basename "$srcfile"
+	libobj=$func_basename_result
+      }
+      ;;
+    esac
+
+    # Recognize several different file suffixes.
+    # If the user specifies -o file.o, it is replaced with file.lo
+    case $libobj in
+    *.[cCFSifmso] | \
+    *.ada | *.adb | *.ads | *.asm | \
+    *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
+    *.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup)
+      func_xform "$libobj"
+      libobj=$func_xform_result
+      ;;
+    esac
+
+    case $libobj in
+    *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
+    *)
+      func_fatal_error "cannot determine name of library object from '$libobj'"
+      ;;
+    esac
+
+    func_infer_tag $base_compile
+
+    for arg in $later; do
+      case $arg in
+      -shared)
+	test yes = "$build_libtool_libs" \
+	  || func_fatal_configuration "cannot build a shared library"
+	build_old_libs=no
+	continue
+	;;
+
+      -static)
+	build_libtool_libs=no
+	build_old_libs=yes
+	continue
+	;;
+
+      -prefer-pic)
+	pic_mode=yes
+	continue
+	;;
+
+      -prefer-non-pic)
+	pic_mode=no
+	continue
+	;;
+      esac
+    done
+
+    func_quote_for_eval "$libobj"
+    test "X$libobj" != "X$func_quote_for_eval_result" \
+      && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"'	 &()|`$[]' \
+      && func_warning "libobj name '$libobj' may not contain shell special characters."
+    func_dirname_and_basename "$obj" "/" ""
+    objname=$func_basename_result
+    xdir=$func_dirname_result
+    lobj=$xdir$objdir/$objname
+
+    test -z "$base_compile" && \
+      func_fatal_help "you must specify a compilation command"
+
+    # Delete any leftover library objects.
+    if test yes = "$build_old_libs"; then
+      removelist="$obj $lobj $libobj ${libobj}T"
+    else
+      removelist="$lobj $libobj ${libobj}T"
+    fi
+
+    # On Cygwin there's no "real" PIC flag so we must build both object types
+    case $host_os in
+    cygwin* | mingw* | pw32* | os2* | cegcc*)
+      pic_mode=default
+      ;;
+    esac
+    if test no = "$pic_mode" && test pass_all != "$deplibs_check_method"; then
+      # non-PIC code in shared libraries is not supported
+      pic_mode=default
+    fi
+
+    # Calculate the filename of the output object if compiler does
+    # not support -o with -c
+    if test no = "$compiler_c_o"; then
+      output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.$objext
+      lockfile=$output_obj.lock
+    else
+      output_obj=
+      need_locks=no
+      lockfile=
+    fi
+
+    # Lock this critical section if it is needed
+    # We use this script file to make the link, it avoids creating a new file
+    if test yes = "$need_locks"; then
+      until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
+	func_echo "Waiting for $lockfile to be removed"
+	sleep 2
+      done
+    elif test warn = "$need_locks"; then
+      if test -f "$lockfile"; then
+	$ECHO "\
+*** ERROR, $lockfile exists and contains:
+`cat $lockfile 2>/dev/null`
+
+This indicates that another process is trying to use the same
+temporary object file, and libtool could not work around it because
+your compiler does not support '-c' and '-o' together.  If you
+repeat this compilation, it may succeed, by chance, but you had better
+avoid parallel builds (make -j) in this platform, or get a better
+compiler."
+
+	$opt_dry_run || $RM $removelist
+	exit $EXIT_FAILURE
+      fi
+      func_append removelist " $output_obj"
+      $ECHO "$srcfile" > "$lockfile"
+    fi
+
+    $opt_dry_run || $RM $removelist
+    func_append removelist " $lockfile"
+    trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
+
+    func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
+    srcfile=$func_to_tool_file_result
+    func_quote_for_eval "$srcfile"
+    qsrcfile=$func_quote_for_eval_result
+
+    # Only build a PIC object if we are building libtool libraries.
+    if test yes = "$build_libtool_libs"; then
+      # Without this assignment, base_compile gets emptied.
+      fbsd_hideous_sh_bug=$base_compile
+
+      if test no != "$pic_mode"; then
+	command="$base_compile $qsrcfile $pic_flag"
+      else
+	# Don't build PIC code
+	command="$base_compile $qsrcfile"
+      fi
+
+      func_mkdir_p "$xdir$objdir"
+
+      if test -z "$output_obj"; then
+	# Place PIC objects in $objdir
+	func_append command " -o $lobj"
+      fi
+
+      func_show_eval_locale "$command"	\
+          'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
+
+      if test warn = "$need_locks" &&
+	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
+	$ECHO "\
+*** ERROR, $lockfile contains:
+`cat $lockfile 2>/dev/null`
+
+but it should contain:
+$srcfile
+
+This indicates that another process is trying to use the same
+temporary object file, and libtool could not work around it because
+your compiler does not support '-c' and '-o' together.  If you
+repeat this compilation, it may succeed, by chance, but you had better
+avoid parallel builds (make -j) in this platform, or get a better
+compiler."
+
+	$opt_dry_run || $RM $removelist
+	exit $EXIT_FAILURE
+      fi
+
+      # Just move the object if needed, then go on to compile the next one
+      if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
+	func_show_eval '$MV "$output_obj" "$lobj"' \
+	  'error=$?; $opt_dry_run || $RM $removelist; exit $error'
+      fi
+
+      # Allow error messages only from the first compilation.
+      if test yes = "$suppress_opt"; then
+	suppress_output=' >/dev/null 2>&1'
+      fi
+    fi
+
+    # Only build a position-dependent object if we build old libraries.
+    if test yes = "$build_old_libs"; then
+      if test yes != "$pic_mode"; then
+	# Don't build PIC code
+	command="$base_compile $qsrcfile$pie_flag"
+      else
+	command="$base_compile $qsrcfile $pic_flag"
+      fi
+      if test yes = "$compiler_c_o"; then
+	func_append command " -o $obj"
+      fi
+
+      # Suppress compiler output if we already did a PIC compilation.
+      func_append command "$suppress_output"
+      func_show_eval_locale "$command" \
+        '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
+
+      if test warn = "$need_locks" &&
+	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
+	$ECHO "\
+*** ERROR, $lockfile contains:
+`cat $lockfile 2>/dev/null`
+
+but it should contain:
+$srcfile
+
+This indicates that another process is trying to use the same
+temporary object file, and libtool could not work around it because
+your compiler does not support '-c' and '-o' together.  If you
+repeat this compilation, it may succeed, by chance, but you had better
+avoid parallel builds (make -j) in this platform, or get a better
+compiler."
+
+	$opt_dry_run || $RM $removelist
+	exit $EXIT_FAILURE
+      fi
+
+      # Just move the object if needed
+      if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
+	func_show_eval '$MV "$output_obj" "$obj"' \
+	  'error=$?; $opt_dry_run || $RM $removelist; exit $error'
+      fi
+    fi
+
+    $opt_dry_run || {
+      func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
+
+      # Unlock the critical section if it was locked
+      if test no != "$need_locks"; then
+	removelist=$lockfile
+        $RM "$lockfile"
+      fi
+    }
+
+    exit $EXIT_SUCCESS
+}
+
+$opt_help || {
+  test compile = "$opt_mode" && func_mode_compile ${1+"$@"}
+}
+
+func_mode_help ()
+{
+    # We need to display help for each of the modes.
+    case $opt_mode in
+      "")
+        # Generic help is extracted from the usage comments
+        # at the start of this file.
+        func_help
+        ;;
+
+      clean)
+        $ECHO \
+"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
+
+Remove files from the build directory.
+
+RM is the name of the program to use to delete files associated with each FILE
+(typically '/bin/rm').  RM-OPTIONS are options (such as '-f') to be passed
+to RM.
+
+If FILE is a libtool library, object or program, all the files associated
+with it are deleted. Otherwise, only FILE itself is deleted using RM."
+        ;;
+
+      compile)
+      $ECHO \
+"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
+
+Compile a source file into a libtool library object.
+
+This mode accepts the following additional options:
+
+  -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
+  -no-suppress      do not suppress compiler output for multiple passes
+  -prefer-pic       try to build PIC objects only
+  -prefer-non-pic   try to build non-PIC objects only
+  -shared           do not build a '.o' file suitable for static linking
+  -static           only build a '.o' file suitable for static linking
+  -Wc,FLAG          pass FLAG directly to the compiler
+
+COMPILE-COMMAND is a command to be used in creating a 'standard' object file
+from the given SOURCEFILE.
+
+The output file name is determined by removing the directory component from
+SOURCEFILE, then substituting the C source code suffix '.c' with the
+library object suffix, '.lo'."
+        ;;
+
+      execute)
+        $ECHO \
+"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
+
+Automatically set library path, then run a program.
+
+This mode accepts the following additional options:
+
+  -dlopen FILE      add the directory containing FILE to the library path
+
+This mode sets the library path environment variable according to '-dlopen'
+flags.
+
+If any of the ARGS are libtool executable wrappers, then they are translated
+into their corresponding uninstalled binary, and any of their required library
+directories are added to the library path.
+
+Then, COMMAND is executed, with ARGS as arguments."
+        ;;
+
+      finish)
+        $ECHO \
+"Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
+
+Complete the installation of libtool libraries.
+
+Each LIBDIR is a directory that contains libtool libraries.
+
+The commands that this mode executes may require superuser privileges.  Use
+the '--dry-run' option if you just want to see what would be executed."
+        ;;
+
+      install)
+        $ECHO \
+"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
+
+Install executables or libraries.
+
+INSTALL-COMMAND is the installation command.  The first component should be
+either the 'install' or 'cp' program.
+
+The following components of INSTALL-COMMAND are treated specially:
+
+  -inst-prefix-dir PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
+
+The rest of the components are interpreted as arguments to that command (only
+BSD-compatible install options are recognized)."
+        ;;
+
+      link)
+        $ECHO \
+"Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
+
+Link object files or libraries together to form another library, or to
+create an executable program.
+
+LINK-COMMAND is a command using the C compiler that you would use to create
+a program from several object files.
+
+The following components of LINK-COMMAND are treated specially:
+
+  -all-static       do not do any dynamic linking at all
+  -avoid-version    do not add a version suffix if possible
+  -bindir BINDIR    specify path to binaries directory (for systems where
+                    libraries must be found in the PATH setting at runtime)
+  -dlopen FILE      '-dlpreopen' FILE if it cannot be dlopened at runtime
+  -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
+  -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
+  -export-symbols SYMFILE
+                    try to export only the symbols listed in SYMFILE
+  -export-symbols-regex REGEX
+                    try to export only the symbols matching REGEX
+  -LLIBDIR          search LIBDIR for required installed libraries
+  -lNAME            OUTPUT-FILE requires the installed library libNAME
+  -module           build a library that can dlopened
+  -no-fast-install  disable the fast-install mode
+  -no-install       link a not-installable executable
+  -no-undefined     declare that a library does not refer to external symbols
+  -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
+  -objectlist FILE  use a list of object files found in FILE to specify objects
+  -os2dllname NAME  force a short DLL name on OS/2 (no effect on other OSes)
+  -precious-files-regex REGEX
+                    don't remove output files matching REGEX
+  -release RELEASE  specify package release information
+  -rpath LIBDIR     the created library will eventually be installed in LIBDIR
+  -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
+  -shared           only do dynamic linking of libtool libraries
+  -shrext SUFFIX    override the standard shared library file extension
+  -static           do not do any dynamic linking of uninstalled libtool libraries
+  -static-libtool-libs
+                    do not do any dynamic linking of libtool libraries
+  -version-info CURRENT[:REVISION[:AGE]]
+                    specify library version info [each variable defaults to 0]
+  -weak LIBNAME     declare that the target provides the LIBNAME interface
+  -Wc,FLAG
+  -Xcompiler FLAG   pass linker-specific FLAG directly to the compiler
+  -Wl,FLAG
+  -Xlinker FLAG     pass linker-specific FLAG directly to the linker
+  -XCClinker FLAG   pass link-specific FLAG to the compiler driver (CC)
+
+All other options (arguments beginning with '-') are ignored.
+
+Every other argument is treated as a filename.  Files ending in '.la' are
+treated as uninstalled libtool libraries, other files are standard or library
+object files.
+
+If the OUTPUT-FILE ends in '.la', then a libtool library is created,
+only library objects ('.lo' files) may be specified, and '-rpath' is
+required, except when creating a convenience library.
+
+If OUTPUT-FILE ends in '.a' or '.lib', then a standard library is created
+using 'ar' and 'ranlib', or on Windows using 'lib'.
+
+If OUTPUT-FILE ends in '.lo' or '.$objext', then a reloadable object file
+is created, otherwise an executable program is created."
+        ;;
+
+      uninstall)
+        $ECHO \
+"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
+
+Remove libraries from an installation directory.
+
+RM is the name of the program to use to delete files associated with each FILE
+(typically '/bin/rm').  RM-OPTIONS are options (such as '-f') to be passed
+to RM.
+
+If FILE is a libtool library, all the files associated with it are deleted.
+Otherwise, only FILE itself is deleted using RM."
+        ;;
+
+      *)
+        func_fatal_help "invalid operation mode '$opt_mode'"
+        ;;
+    esac
+
+    echo
+    $ECHO "Try '$progname --help' for more information about other modes."
+}
+
+# Now that we've collected a possible --mode arg, show help if necessary
+if $opt_help; then
+  if test : = "$opt_help"; then
+    func_mode_help
+  else
+    {
+      func_help noexit
+      for opt_mode in compile link execute install finish uninstall clean; do
+	func_mode_help
+      done
+    } | $SED -n '1p; 2,$s/^Usage:/  or: /p'
+    {
+      func_help noexit
+      for opt_mode in compile link execute install finish uninstall clean; do
+	echo
+	func_mode_help
+      done
+    } |
+    $SED '1d
+      /^When reporting/,/^Report/{
+	H
+	d
+      }
+      $x
+      /information about other modes/d
+      /more detailed .*MODE/d
+      s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
+  fi
+  exit $?
+fi
+
+
+# func_mode_execute arg...
+func_mode_execute ()
+{
+    $debug_cmd
+
+    # The first argument is the command name.
+    cmd=$nonopt
+    test -z "$cmd" && \
+      func_fatal_help "you must specify a COMMAND"
+
+    # Handle -dlopen flags immediately.
+    for file in $opt_dlopen; do
+      test -f "$file" \
+	|| func_fatal_help "'$file' is not a file"
+
+      dir=
+      case $file in
+      *.la)
+	func_resolve_sysroot "$file"
+	file=$func_resolve_sysroot_result
+
+	# Check to see that this really is a libtool archive.
+	func_lalib_unsafe_p "$file" \
+	  || func_fatal_help "'$lib' is not a valid libtool archive"
+
+	# Read the libtool library.
+	dlname=
+	library_names=
+	func_source "$file"
+
+	# Skip this library if it cannot be dlopened.
+	if test -z "$dlname"; then
+	  # Warn if it was a shared library.
+	  test -n "$library_names" && \
+	    func_warning "'$file' was not linked with '-export-dynamic'"
+	  continue
+	fi
+
+	func_dirname "$file" "" "."
+	dir=$func_dirname_result
+
+	if test -f "$dir/$objdir/$dlname"; then
+	  func_append dir "/$objdir"
+	else
+	  if test ! -f "$dir/$dlname"; then
+	    func_fatal_error "cannot find '$dlname' in '$dir' or '$dir/$objdir'"
+	  fi
+	fi
+	;;
+
+      *.lo)
+	# Just add the directory containing the .lo file.
+	func_dirname "$file" "" "."
+	dir=$func_dirname_result
+	;;
+
+      *)
+	func_warning "'-dlopen' is ignored for non-libtool libraries and objects"
+	continue
+	;;
+      esac
+
+      # Get the absolute pathname.
+      absdir=`cd "$dir" && pwd`
+      test -n "$absdir" && dir=$absdir
+
+      # Now add the directory to shlibpath_var.
+      if eval "test -z \"\$$shlibpath_var\""; then
+	eval "$shlibpath_var=\"\$dir\""
+      else
+	eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
+      fi
+    done
+
+    # This variable tells wrapper scripts just to set shlibpath_var
+    # rather than running their programs.
+    libtool_execute_magic=$magic
+
+    # Check if any of the arguments is a wrapper script.
+    args=
+    for file
+    do
+      case $file in
+      -* | *.la | *.lo ) ;;
+      *)
+	# Do a test to see if this is really a libtool program.
+	if func_ltwrapper_script_p "$file"; then
+	  func_source "$file"
+	  # Transform arg to wrapped name.
+	  file=$progdir/$program
+	elif func_ltwrapper_executable_p "$file"; then
+	  func_ltwrapper_scriptname "$file"
+	  func_source "$func_ltwrapper_scriptname_result"
+	  # Transform arg to wrapped name.
+	  file=$progdir/$program
+	fi
+	;;
+      esac
+      # Quote arguments (to preserve shell metacharacters).
+      func_append_quoted args "$file"
+    done
+
+    if $opt_dry_run; then
+      # Display what would be done.
+      if test -n "$shlibpath_var"; then
+	eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
+	echo "export $shlibpath_var"
+      fi
+      $ECHO "$cmd$args"
+      exit $EXIT_SUCCESS
+    else
+      if test -n "$shlibpath_var"; then
+	# Export the shlibpath_var.
+	eval "export $shlibpath_var"
+      fi
+
+      # Restore saved environment variables
+      for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
+      do
+	eval "if test \"\${save_$lt_var+set}\" = set; then
+                $lt_var=\$save_$lt_var; export $lt_var
+	      else
+		$lt_unset $lt_var
+	      fi"
+      done
+
+      # Now prepare to actually exec the command.
+      exec_cmd=\$cmd$args
+    fi
+}
+
+test execute = "$opt_mode" && func_mode_execute ${1+"$@"}
+
+
+# func_mode_finish arg...
+func_mode_finish ()
+{
+    $debug_cmd
+
+    libs=
+    libdirs=
+    admincmds=
+
+    for opt in "$nonopt" ${1+"$@"}
+    do
+      if test -d "$opt"; then
+	func_append libdirs " $opt"
+
+      elif test -f "$opt"; then
+	if func_lalib_unsafe_p "$opt"; then
+	  func_append libs " $opt"
+	else
+	  func_warning "'$opt' is not a valid libtool archive"
+	fi
+
+      else
+	func_fatal_error "invalid argument '$opt'"
+      fi
+    done
+
+    if test -n "$libs"; then
+      if test -n "$lt_sysroot"; then
+        sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
+        sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
+      else
+        sysroot_cmd=
+      fi
+
+      # Remove sysroot references
+      if $opt_dry_run; then
+        for lib in $libs; do
+          echo "removing references to $lt_sysroot and '=' prefixes from $lib"
+        done
+      else
+        tmpdir=`func_mktempdir`
+        for lib in $libs; do
+	  $SED -e "$sysroot_cmd s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
+	    > $tmpdir/tmp-la
+	  mv -f $tmpdir/tmp-la $lib
+	done
+        ${RM}r "$tmpdir"
+      fi
+    fi
+
+    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
+      for libdir in $libdirs; do
+	if test -n "$finish_cmds"; then
+	  # Do each command in the finish commands.
+	  func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
+'"$cmd"'"'
+	fi
+	if test -n "$finish_eval"; then
+	  # Do the single finish_eval.
+	  eval cmds=\"$finish_eval\"
+	  $opt_dry_run || eval "$cmds" || func_append admincmds "
+       $cmds"
+	fi
+      done
+    fi
+
+    # Exit here if they wanted silent mode.
+    $opt_quiet && exit $EXIT_SUCCESS
+
+    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
+      echo "----------------------------------------------------------------------"
+      echo "Libraries have been installed in:"
+      for libdir in $libdirs; do
+	$ECHO "   $libdir"
+      done
+      echo
+      echo "If you ever happen to want to link against installed libraries"
+      echo "in a given directory, LIBDIR, you must either use libtool, and"
+      echo "specify the full pathname of the library, or use the '-LLIBDIR'"
+      echo "flag during linking and do at least one of the following:"
+      if test -n "$shlibpath_var"; then
+	echo "   - add LIBDIR to the '$shlibpath_var' environment variable"
+	echo "     during execution"
+      fi
+      if test -n "$runpath_var"; then
+	echo "   - add LIBDIR to the '$runpath_var' environment variable"
+	echo "     during linking"
+      fi
+      if test -n "$hardcode_libdir_flag_spec"; then
+	libdir=LIBDIR
+	eval flag=\"$hardcode_libdir_flag_spec\"
+
+	$ECHO "   - use the '$flag' linker flag"
+      fi
+      if test -n "$admincmds"; then
+	$ECHO "   - have your system administrator run these commands:$admincmds"
+      fi
+      if test -f /etc/ld.so.conf; then
+	echo "   - have your system administrator add LIBDIR to '/etc/ld.so.conf'"
+      fi
+      echo
+
+      echo "See any operating system documentation about shared libraries for"
+      case $host in
+	solaris2.[6789]|solaris2.1[0-9])
+	  echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
+	  echo "pages."
+	  ;;
+	*)
+	  echo "more information, such as the ld(1) and ld.so(8) manual pages."
+	  ;;
+      esac
+      echo "----------------------------------------------------------------------"
+    fi
+    exit $EXIT_SUCCESS
+}
+
+test finish = "$opt_mode" && func_mode_finish ${1+"$@"}
+
+
+# func_mode_install arg...
+func_mode_install ()
+{
+    $debug_cmd
+
+    # There may be an optional sh(1) argument at the beginning of
+    # install_prog (especially on Windows NT).
+    if test "$SHELL" = "$nonopt" || test /bin/sh = "$nonopt" ||
+       # Allow the use of GNU shtool's install command.
+       case $nonopt in *shtool*) :;; *) false;; esac
+    then
+      # Aesthetically quote it.
+      func_quote_for_eval "$nonopt"
+      install_prog="$func_quote_for_eval_result "
+      arg=$1
+      shift
+    else
+      install_prog=
+      arg=$nonopt
+    fi
+
+    # The real first argument should be the name of the installation program.
+    # Aesthetically quote it.
+    func_quote_for_eval "$arg"
+    func_append install_prog "$func_quote_for_eval_result"
+    install_shared_prog=$install_prog
+    case " $install_prog " in
+      *[\\\ /]cp\ *) install_cp=: ;;
+      *) install_cp=false ;;
+    esac
+
+    # We need to accept at least all the BSD install flags.
+    dest=
+    files=
+    opts=
+    prev=
+    install_type=
+    isdir=false
+    stripme=
+    no_mode=:
+    for arg
+    do
+      arg2=
+      if test -n "$dest"; then
+	func_append files " $dest"
+	dest=$arg
+	continue
+      fi
+
+      case $arg in
+      -d) isdir=: ;;
+      -f)
+	if $install_cp; then :; else
+	  prev=$arg
+	fi
+	;;
+      -g | -m | -o)
+	prev=$arg
+	;;
+      -s)
+	stripme=" -s"
+	continue
+	;;
+      -*)
+	;;
+      *)
+	# If the previous option needed an argument, then skip it.
+	if test -n "$prev"; then
+	  if test X-m = "X$prev" && test -n "$install_override_mode"; then
+	    arg2=$install_override_mode
+	    no_mode=false
+	  fi
+	  prev=
+	else
+	  dest=$arg
+	  continue
+	fi
+	;;
+      esac
+
+      # Aesthetically quote the argument.
+      func_quote_for_eval "$arg"
+      func_append install_prog " $func_quote_for_eval_result"
+      if test -n "$arg2"; then
+	func_quote_for_eval "$arg2"
+      fi
+      func_append install_shared_prog " $func_quote_for_eval_result"
+    done
+
+    test -z "$install_prog" && \
+      func_fatal_help "you must specify an install program"
+
+    test -n "$prev" && \
+      func_fatal_help "the '$prev' option requires an argument"
+
+    if test -n "$install_override_mode" && $no_mode; then
+      if $install_cp; then :; else
+	func_quote_for_eval "$install_override_mode"
+	func_append install_shared_prog " -m $func_quote_for_eval_result"
+      fi
+    fi
+
+    if test -z "$files"; then
+      if test -z "$dest"; then
+	func_fatal_help "no file or destination specified"
+      else
+	func_fatal_help "you must specify a destination"
+      fi
+    fi
+
+    # Strip any trailing slash from the destination.
+    func_stripname '' '/' "$dest"
+    dest=$func_stripname_result
+
+    # Check to see that the destination is a directory.
+    test -d "$dest" && isdir=:
+    if $isdir; then
+      destdir=$dest
+      destname=
+    else
+      func_dirname_and_basename "$dest" "" "."
+      destdir=$func_dirname_result
+      destname=$func_basename_result
+
+      # Not a directory, so check to see that there is only one file specified.
+      set dummy $files; shift
+      test "$#" -gt 1 && \
+	func_fatal_help "'$dest' is not a directory"
+    fi
+    case $destdir in
+    [\\/]* | [A-Za-z]:[\\/]*) ;;
+    *)
+      for file in $files; do
+	case $file in
+	*.lo) ;;
+	*)
+	  func_fatal_help "'$destdir' must be an absolute directory name"
+	  ;;
+	esac
+      done
+      ;;
+    esac
+
+    # This variable tells wrapper scripts just to set variables rather
+    # than running their programs.
+    libtool_install_magic=$magic
+
+    staticlibs=
+    future_libdirs=
+    current_libdirs=
+    for file in $files; do
+
+      # Do each installation.
+      case $file in
+      *.$libext)
+	# Do the static libraries later.
+	func_append staticlibs " $file"
+	;;
+
+      *.la)
+	func_resolve_sysroot "$file"
+	file=$func_resolve_sysroot_result
+
+	# Check to see that this really is a libtool archive.
+	func_lalib_unsafe_p "$file" \
+	  || func_fatal_help "'$file' is not a valid libtool archive"
+
+	library_names=
+	old_library=
+	relink_command=
+	func_source "$file"
+
+	# Add the libdir to current_libdirs if it is the destination.
+	if test "X$destdir" = "X$libdir"; then
+	  case "$current_libdirs " in
+	  *" $libdir "*) ;;
+	  *) func_append current_libdirs " $libdir" ;;
+	  esac
+	else
+	  # Note the libdir as a future libdir.
+	  case "$future_libdirs " in
+	  *" $libdir "*) ;;
+	  *) func_append future_libdirs " $libdir" ;;
+	  esac
+	fi
+
+	func_dirname "$file" "/" ""
+	dir=$func_dirname_result
+	func_append dir "$objdir"
+
+	if test -n "$relink_command"; then
+	  # Determine the prefix the user has applied to our future dir.
+	  inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
+
+	  # Don't allow the user to place us outside of our expected
+	  # location b/c this prevents finding dependent libraries that
+	  # are installed to the same prefix.
+	  # At present, this check doesn't affect windows .dll's that
+	  # are installed into $libdir/../bin (currently, that works fine)
+	  # but it's something to keep an eye on.
+	  test "$inst_prefix_dir" = "$destdir" && \
+	    func_fatal_error "error: cannot install '$file' to a directory not ending in $libdir"
+
+	  if test -n "$inst_prefix_dir"; then
+	    # Stick the inst_prefix_dir data into the link command.
+	    relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
+	  else
+	    relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
+	  fi
+
+	  func_warning "relinking '$file'"
+	  func_show_eval "$relink_command" \
+	    'func_fatal_error "error: relink '\''$file'\'' with the above command before installing it"'
+	fi
+
+	# See the names of the shared library.
+	set dummy $library_names; shift
+	if test -n "$1"; then
+	  realname=$1
+	  shift
+
+	  srcname=$realname
+	  test -n "$relink_command" && srcname=${realname}T
+
+	  # Install the shared library and build the symlinks.
+	  func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
+	      'exit $?'
+	  tstripme=$stripme
+	  case $host_os in
+	  cygwin* | mingw* | pw32* | cegcc*)
+	    case $realname in
+	    *.dll.a)
+	      tstripme=
+	      ;;
+	    esac
+	    ;;
+	  os2*)
+	    case $realname in
+	    *_dll.a)
+	      tstripme=
+	      ;;
+	    esac
+	    ;;
+	  esac
+	  if test -n "$tstripme" && test -n "$striplib"; then
+	    func_show_eval "$striplib $destdir/$realname" 'exit $?'
+	  fi
+
+	  if test "$#" -gt 0; then
+	    # Delete the old symlinks, and create new ones.
+	    # Try 'ln -sf' first, because the 'ln' binary might depend on
+	    # the symlink we replace!  Solaris /bin/ln does not understand -f,
+	    # so we also need to try rm && ln -s.
+	    for linkname
+	    do
+	      test "$linkname" != "$realname" \
+		&& func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
+	    done
+	  fi
+
+	  # Do each command in the postinstall commands.
+	  lib=$destdir/$realname
+	  func_execute_cmds "$postinstall_cmds" 'exit $?'
+	fi
+
+	# Install the pseudo-library for information purposes.
+	func_basename "$file"
+	name=$func_basename_result
+	instname=$dir/${name}i
+	func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
+
+	# Maybe install the static library, too.
+	test -n "$old_library" && func_append staticlibs " $dir/$old_library"
+	;;
+
+      *.lo)
+	# Install (i.e. copy) a libtool object.
+
+	# Figure out destination file name, if it wasn't already specified.
+	if test -n "$destname"; then
+	  destfile=$destdir/$destname
+	else
+	  func_basename "$file"
+	  destfile=$func_basename_result
+	  destfile=$destdir/$destfile
+	fi
+
+	# Deduce the name of the destination old-style object file.
+	case $destfile in
+	*.lo)
+	  func_lo2o "$destfile"
+	  staticdest=$func_lo2o_result
+	  ;;
+	*.$objext)
+	  staticdest=$destfile
+	  destfile=
+	  ;;
+	*)
+	  func_fatal_help "cannot copy a libtool object to '$destfile'"
+	  ;;
+	esac
+
+	# Install the libtool object if requested.
+	test -n "$destfile" && \
+	  func_show_eval "$install_prog $file $destfile" 'exit $?'
+
+	# Install the old object if enabled.
+	if test yes = "$build_old_libs"; then
+	  # Deduce the name of the old-style object file.
+	  func_lo2o "$file"
+	  staticobj=$func_lo2o_result
+	  func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
+	fi
+	exit $EXIT_SUCCESS
+	;;
+
+      *)
+	# Figure out destination file name, if it wasn't already specified.
+	if test -n "$destname"; then
+	  destfile=$destdir/$destname
+	else
+	  func_basename "$file"
+	  destfile=$func_basename_result
+	  destfile=$destdir/$destfile
+	fi
+
+	# If the file is missing, and there is a .exe on the end, strip it
+	# because it is most likely a libtool script we actually want to
+	# install
+	stripped_ext=
+	case $file in
+	  *.exe)
+	    if test ! -f "$file"; then
+	      func_stripname '' '.exe' "$file"
+	      file=$func_stripname_result
+	      stripped_ext=.exe
+	    fi
+	    ;;
+	esac
+
+	# Do a test to see if this is really a libtool program.
+	case $host in
+	*cygwin* | *mingw*)
+	    if func_ltwrapper_executable_p "$file"; then
+	      func_ltwrapper_scriptname "$file"
+	      wrapper=$func_ltwrapper_scriptname_result
+	    else
+	      func_stripname '' '.exe' "$file"
+	      wrapper=$func_stripname_result
+	    fi
+	    ;;
+	*)
+	    wrapper=$file
+	    ;;
+	esac
+	if func_ltwrapper_script_p "$wrapper"; then
+	  notinst_deplibs=
+	  relink_command=
+
+	  func_source "$wrapper"
+
+	  # Check the variables that should have been set.
+	  test -z "$generated_by_libtool_version" && \
+	    func_fatal_error "invalid libtool wrapper script '$wrapper'"
+
+	  finalize=:
+	  for lib in $notinst_deplibs; do
+	    # Check to see that each library is installed.
+	    libdir=
+	    if test -f "$lib"; then
+	      func_source "$lib"
+	    fi
+	    libfile=$libdir/`$ECHO "$lib" | $SED 's%^.*/%%g'`
+	    if test -n "$libdir" && test ! -f "$libfile"; then
+	      func_warning "'$lib' has not been installed in '$libdir'"
+	      finalize=false
+	    fi
+	  done
+
+	  relink_command=
+	  func_source "$wrapper"
+
+	  outputname=
+	  if test no = "$fast_install" && test -n "$relink_command"; then
+	    $opt_dry_run || {
+	      if $finalize; then
+	        tmpdir=`func_mktempdir`
+		func_basename "$file$stripped_ext"
+		file=$func_basename_result
+	        outputname=$tmpdir/$file
+	        # Replace the output file specification.
+	        relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
+
+	        $opt_quiet || {
+	          func_quote_for_expand "$relink_command"
+		  eval "func_echo $func_quote_for_expand_result"
+	        }
+	        if eval "$relink_command"; then :
+	          else
+		  func_error "error: relink '$file' with the above command before installing it"
+		  $opt_dry_run || ${RM}r "$tmpdir"
+		  continue
+	        fi
+	        file=$outputname
+	      else
+	        func_warning "cannot relink '$file'"
+	      fi
+	    }
+	  else
+	    # Install the binary that we compiled earlier.
+	    file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
+	  fi
+	fi
+
+	# remove .exe since cygwin /usr/bin/install will append another
+	# one anyway
+	case $install_prog,$host in
+	*/usr/bin/install*,*cygwin*)
+	  case $file:$destfile in
+	  *.exe:*.exe)
+	    # this is ok
+	    ;;
+	  *.exe:*)
+	    destfile=$destfile.exe
+	    ;;
+	  *:*.exe)
+	    func_stripname '' '.exe' "$destfile"
+	    destfile=$func_stripname_result
+	    ;;
+	  esac
+	  ;;
+	esac
+	func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
+	$opt_dry_run || if test -n "$outputname"; then
+	  ${RM}r "$tmpdir"
+	fi
+	;;
+      esac
+    done
+
+    for file in $staticlibs; do
+      func_basename "$file"
+      name=$func_basename_result
+
+      # Set up the ranlib parameters.
+      oldlib=$destdir/$name
+      func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
+      tool_oldlib=$func_to_tool_file_result
+
+      func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
+
+      if test -n "$stripme" && test -n "$old_striplib"; then
+	func_show_eval "$old_striplib $tool_oldlib" 'exit $?'
+      fi
+
+      # Do each command in the postinstall commands.
+      func_execute_cmds "$old_postinstall_cmds" 'exit $?'
+    done
+
+    test -n "$future_libdirs" && \
+      func_warning "remember to run '$progname --finish$future_libdirs'"
+
+    if test -n "$current_libdirs"; then
+      # Maybe just do a dry run.
+      $opt_dry_run && current_libdirs=" -n$current_libdirs"
+      exec_cmd='$SHELL "$progpath" $preserve_args --finish$current_libdirs'
+    else
+      exit $EXIT_SUCCESS
+    fi
+}
+
+test install = "$opt_mode" && func_mode_install ${1+"$@"}
+
+
+# func_generate_dlsyms outputname originator pic_p
+# Extract symbols from dlprefiles and create ${outputname}S.o with
+# a dlpreopen symbol table.
+func_generate_dlsyms ()
+{
+    $debug_cmd
+
+    my_outputname=$1
+    my_originator=$2
+    my_pic_p=${3-false}
+    my_prefix=`$ECHO "$my_originator" | $SED 's%[^a-zA-Z0-9]%_%g'`
+    my_dlsyms=
+
+    if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
+      if test -n "$NM" && test -n "$global_symbol_pipe"; then
+	my_dlsyms=${my_outputname}S.c
+      else
+	func_error "not configured to extract global symbols from dlpreopened files"
+      fi
+    fi
+
+    if test -n "$my_dlsyms"; then
+      case $my_dlsyms in
+      "") ;;
+      *.c)
+	# Discover the nlist of each of the dlfiles.
+	nlist=$output_objdir/$my_outputname.nm
+
+	func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
+
+	# Parse the name list into a source file.
+	func_verbose "creating $output_objdir/$my_dlsyms"
+
+	$opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
+/* $my_dlsyms - symbol resolution table for '$my_outputname' dlsym emulation. */
+/* Generated by $PROGRAM (GNU $PACKAGE) $VERSION */
+
+#ifdef __cplusplus
+extern \"C\" {
+#endif
+
+#if defined __GNUC__ && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
+#pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
+#endif
+
+/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
+#if defined _WIN32 || defined __CYGWIN__ || defined _WIN32_WCE
+/* DATA imports from DLLs on WIN32 can't be const, because runtime
+   relocations are performed -- see ld's documentation on pseudo-relocs.  */
+# define LT_DLSYM_CONST
+#elif defined __osf__
+/* This system does not cope well with relocations in const data.  */
+# define LT_DLSYM_CONST
+#else
+# define LT_DLSYM_CONST const
+#endif
+
+#define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0)
+
+/* External symbol declarations for the compiler. */\
+"
+
+	if test yes = "$dlself"; then
+	  func_verbose "generating symbol list for '$output'"
+
+	  $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
+
+	  # Add our own program objects to the symbol list.
+	  progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
+	  for progfile in $progfiles; do
+	    func_to_tool_file "$progfile" func_convert_file_msys_to_w32
+	    func_verbose "extracting global C symbols from '$func_to_tool_file_result'"
+	    $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
+	  done
+
+	  if test -n "$exclude_expsyms"; then
+	    $opt_dry_run || {
+	      eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
+	      eval '$MV "$nlist"T "$nlist"'
+	    }
+	  fi
+
+	  if test -n "$export_symbols_regex"; then
+	    $opt_dry_run || {
+	      eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
+	      eval '$MV "$nlist"T "$nlist"'
+	    }
+	  fi
+
+	  # Prepare the list of exported symbols
+	  if test -z "$export_symbols"; then
+	    export_symbols=$output_objdir/$outputname.exp
+	    $opt_dry_run || {
+	      $RM $export_symbols
+	      eval "$SED -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
+	      case $host in
+	      *cygwin* | *mingw* | *cegcc* )
+                eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
+                eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
+	        ;;
+	      esac
+	    }
+	  else
+	    $opt_dry_run || {
+	      eval "$SED -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
+	      eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
+	      eval '$MV "$nlist"T "$nlist"'
+	      case $host in
+	        *cygwin* | *mingw* | *cegcc* )
+	          eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
+	          eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
+	          ;;
+	      esac
+	    }
+	  fi
+	fi
+
+	for dlprefile in $dlprefiles; do
+	  func_verbose "extracting global C symbols from '$dlprefile'"
+	  func_basename "$dlprefile"
+	  name=$func_basename_result
+          case $host in
+	    *cygwin* | *mingw* | *cegcc* )
+	      # if an import library, we need to obtain dlname
+	      if func_win32_import_lib_p "$dlprefile"; then
+	        func_tr_sh "$dlprefile"
+	        eval "curr_lafile=\$libfile_$func_tr_sh_result"
+	        dlprefile_dlbasename=
+	        if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
+	          # Use subshell, to avoid clobbering current variable values
+	          dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
+	          if test -n "$dlprefile_dlname"; then
+	            func_basename "$dlprefile_dlname"
+	            dlprefile_dlbasename=$func_basename_result
+	          else
+	            # no lafile. user explicitly requested -dlpreopen <import library>.
+	            $sharedlib_from_linklib_cmd "$dlprefile"
+	            dlprefile_dlbasename=$sharedlib_from_linklib_result
+	          fi
+	        fi
+	        $opt_dry_run || {
+	          if test -n "$dlprefile_dlbasename"; then
+	            eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
+	          else
+	            func_warning "Could not compute DLL name from $name"
+	            eval '$ECHO ": $name " >> "$nlist"'
+	          fi
+	          func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
+	          eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
+	            $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
+	        }
+	      else # not an import lib
+	        $opt_dry_run || {
+	          eval '$ECHO ": $name " >> "$nlist"'
+	          func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
+	          eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
+	        }
+	      fi
+	    ;;
+	    *)
+	      $opt_dry_run || {
+	        eval '$ECHO ": $name " >> "$nlist"'
+	        func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
+	        eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
+	      }
+	    ;;
+          esac
+	done
+
+	$opt_dry_run || {
+	  # Make sure we have at least an empty file.
+	  test -f "$nlist" || : > "$nlist"
+
+	  if test -n "$exclude_expsyms"; then
+	    $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
+	    $MV "$nlist"T "$nlist"
+	  fi
+
+	  # Try sorting and uniquifying the output.
+	  if $GREP -v "^: " < "$nlist" |
+	      if sort -k 3 </dev/null >/dev/null 2>&1; then
+		sort -k 3
+	      else
+		sort +2
+	      fi |
+	      uniq > "$nlist"S; then
+	    :
+	  else
+	    $GREP -v "^: " < "$nlist" > "$nlist"S
+	  fi
+
+	  if test -f "$nlist"S; then
+	    eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
+	  else
+	    echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
+	  fi
+
+	  func_show_eval '$RM "${nlist}I"'
+	  if test -n "$global_symbol_to_import"; then
+	    eval "$global_symbol_to_import"' < "$nlist"S > "$nlist"I'
+	  fi
+
+	  echo >> "$output_objdir/$my_dlsyms" "\
+
+/* The mapping between symbol names and symbols.  */
+typedef struct {
+  const char *name;
+  void *address;
+} lt_dlsymlist;
+extern LT_DLSYM_CONST lt_dlsymlist
+lt_${my_prefix}_LTX_preloaded_symbols[];\
+"
+
+	  if test -s "$nlist"I; then
+	    echo >> "$output_objdir/$my_dlsyms" "\
+static void lt_syminit(void)
+{
+  LT_DLSYM_CONST lt_dlsymlist *symbol = lt_${my_prefix}_LTX_preloaded_symbols;
+  for (; symbol->name; ++symbol)
+    {"
+	    $SED 's/.*/      if (STREQ (symbol->name, \"&\")) symbol->address = (void *) \&&;/' < "$nlist"I >> "$output_objdir/$my_dlsyms"
+	    echo >> "$output_objdir/$my_dlsyms" "\
+    }
+}"
+	  fi
+	  echo >> "$output_objdir/$my_dlsyms" "\
+LT_DLSYM_CONST lt_dlsymlist
+lt_${my_prefix}_LTX_preloaded_symbols[] =
+{ {\"$my_originator\", (void *) 0},"
+
+	  if test -s "$nlist"I; then
+	    echo >> "$output_objdir/$my_dlsyms" "\
+  {\"@INIT@\", (void *) &lt_syminit},"
+	  fi
+
+	  case $need_lib_prefix in
+	  no)
+	    eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
+	    ;;
+	  *)
+	    eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
+	    ;;
+	  esac
+	  echo >> "$output_objdir/$my_dlsyms" "\
+  {0, (void *) 0}
+};
+
+/* This works around a problem in FreeBSD linker */
+#ifdef FREEBSD_WORKAROUND
+static const void *lt_preloaded_setup() {
+  return lt_${my_prefix}_LTX_preloaded_symbols;
+}
+#endif
+
+#ifdef __cplusplus
+}
+#endif\
+"
+	} # !$opt_dry_run
+
+	pic_flag_for_symtable=
+	case "$compile_command " in
+	*" -static "*) ;;
+	*)
+	  case $host in
+	  # compiling the symbol table file with pic_flag works around
+	  # a FreeBSD bug that causes programs to crash when -lm is
+	  # linked before any other PIC object.  But we must not use
+	  # pic_flag when linking with -static.  The problem exists in
+	  # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
+	  *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
+	    pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
+	  *-*-hpux*)
+	    pic_flag_for_symtable=" $pic_flag"  ;;
+	  *)
+	    $my_pic_p && pic_flag_for_symtable=" $pic_flag"
+	    ;;
+	  esac
+	  ;;
+	esac
+	symtab_cflags=
+	for arg in $LTCFLAGS; do
+	  case $arg in
+	  -pie | -fpie | -fPIE) ;;
+	  *) func_append symtab_cflags " $arg" ;;
+	  esac
+	done
+
+	# Now compile the dynamic symbol file.
+	func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
+
+	# Clean up the generated files.
+	func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T" "${nlist}I"'
+
+	# Transform the symbol file into the correct name.
+	symfileobj=$output_objdir/${my_outputname}S.$objext
+	case $host in
+	*cygwin* | *mingw* | *cegcc* )
+	  if test -f "$output_objdir/$my_outputname.def"; then
+	    compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
+	    finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
+	  else
+	    compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
+	    finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
+	  fi
+	  ;;
+	*)
+	  compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
+	  finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
+	  ;;
+	esac
+	;;
+      *)
+	func_fatal_error "unknown suffix for '$my_dlsyms'"
+	;;
+      esac
+    else
+      # We keep going just in case the user didn't refer to
+      # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
+      # really was required.
+
+      # Nullify the symbol file.
+      compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
+      finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
+    fi
+}
+
+# func_cygming_gnu_implib_p ARG
+# This predicate returns with zero status (TRUE) if
+# ARG is a GNU/binutils-style import library. Returns
+# with nonzero status (FALSE) otherwise.
+func_cygming_gnu_implib_p ()
+{
+  $debug_cmd
+
+  func_to_tool_file "$1" func_convert_file_msys_to_w32
+  func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'`
+  test -n "$func_cygming_gnu_implib_tmp"
+}
+
+# func_cygming_ms_implib_p ARG
+# This predicate returns with zero status (TRUE) if
+# ARG is an MS-style import library. Returns
+# with nonzero status (FALSE) otherwise.
+func_cygming_ms_implib_p ()
+{
+  $debug_cmd
+
+  func_to_tool_file "$1" func_convert_file_msys_to_w32
+  func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
+  test -n "$func_cygming_ms_implib_tmp"
+}
+
+# func_win32_libid arg
+# return the library type of file 'arg'
+#
+# Need a lot of goo to handle *both* DLLs and import libs
+# Has to be a shell function in order to 'eat' the argument
+# that is supplied when $file_magic_command is called.
+# Despite the name, also deal with 64 bit binaries.
+func_win32_libid ()
+{
+  $debug_cmd
+
+  win32_libid_type=unknown
+  win32_fileres=`file -L $1 2>/dev/null`
+  case $win32_fileres in
+  *ar\ archive\ import\ library*) # definitely import
+    win32_libid_type="x86 archive import"
+    ;;
+  *ar\ archive*) # could be an import, or static
+    # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
+    if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
+       $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
+      case $nm_interface in
+      "MS dumpbin")
+	if func_cygming_ms_implib_p "$1" ||
+	   func_cygming_gnu_implib_p "$1"
+	then
+	  win32_nmres=import
+	else
+	  win32_nmres=
+	fi
+	;;
+      *)
+	func_to_tool_file "$1" func_convert_file_msys_to_w32
+	win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
+	  $SED -n -e '
+	    1,100{
+		/ I /{
+		    s|.*|import|
+		    p
+		    q
+		}
+	    }'`
+	;;
+      esac
+      case $win32_nmres in
+      import*)  win32_libid_type="x86 archive import";;
+      *)        win32_libid_type="x86 archive static";;
+      esac
+    fi
+    ;;
+  *DLL*)
+    win32_libid_type="x86 DLL"
+    ;;
+  *executable*) # but shell scripts are "executable" too...
+    case $win32_fileres in
+    *MS\ Windows\ PE\ Intel*)
+      win32_libid_type="x86 DLL"
+      ;;
+    esac
+    ;;
+  esac
+  $ECHO "$win32_libid_type"
+}
+
+# func_cygming_dll_for_implib ARG
+#
+# Platform-specific function to extract the
+# name of the DLL associated with the specified
+# import library ARG.
+# Invoked by eval'ing the libtool variable
+#    $sharedlib_from_linklib_cmd
+# Result is available in the variable
+#    $sharedlib_from_linklib_result
+func_cygming_dll_for_implib ()
+{
+  $debug_cmd
+
+  sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
+}
+
+# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
+#
+# The is the core of a fallback implementation of a
+# platform-specific function to extract the name of the
+# DLL associated with the specified import library LIBNAME.
+#
+# SECTION_NAME is either .idata$6 or .idata$7, depending
+# on the platform and compiler that created the implib.
+#
+# Echos the name of the DLL associated with the
+# specified import library.
+func_cygming_dll_for_implib_fallback_core ()
+{
+  $debug_cmd
+
+  match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
+  $OBJDUMP -s --section "$1" "$2" 2>/dev/null |
+    $SED '/^Contents of section '"$match_literal"':/{
+      # Place marker at beginning of archive member dllname section
+      s/.*/====MARK====/
+      p
+      d
+    }
+    # These lines can sometimes be longer than 43 characters, but
+    # are always uninteresting
+    /:[	 ]*file format pe[i]\{,1\}-/d
+    /^In archive [^:]*:/d
+    # Ensure marker is printed
+    /^====MARK====/p
+    # Remove all lines with less than 43 characters
+    /^.\{43\}/!d
+    # From remaining lines, remove first 43 characters
+    s/^.\{43\}//' |
+    $SED -n '
+      # Join marker and all lines until next marker into a single line
+      /^====MARK====/ b para
+      H
+      $ b para
+      b
+      :para
+      x
+      s/\n//g
+      # Remove the marker
+      s/^====MARK====//
+      # Remove trailing dots and whitespace
+      s/[\. \t]*$//
+      # Print
+      /./p' |
+    # we now have a list, one entry per line, of the stringified
+    # contents of the appropriate section of all members of the
+    # archive that possess that section. Heuristic: eliminate
+    # all those that have a first or second character that is
+    # a '.' (that is, objdump's representation of an unprintable
+    # character.) This should work for all archives with less than
+    # 0x302f exports -- but will fail for DLLs whose name actually
+    # begins with a literal '.' or a single character followed by
+    # a '.'.
+    #
+    # Of those that remain, print the first one.
+    $SED -e '/^\./d;/^.\./d;q'
+}
+
+# func_cygming_dll_for_implib_fallback ARG
+# Platform-specific function to extract the
+# name of the DLL associated with the specified
+# import library ARG.
+#
+# This fallback implementation is for use when $DLLTOOL
+# does not support the --identify-strict option.
+# Invoked by eval'ing the libtool variable
+#    $sharedlib_from_linklib_cmd
+# Result is available in the variable
+#    $sharedlib_from_linklib_result
+func_cygming_dll_for_implib_fallback ()
+{
+  $debug_cmd
+
+  if func_cygming_gnu_implib_p "$1"; then
+    # binutils import library
+    sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
+  elif func_cygming_ms_implib_p "$1"; then
+    # ms-generated import library
+    sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
+  else
+    # unknown
+    sharedlib_from_linklib_result=
+  fi
+}
+
+
+# func_extract_an_archive dir oldlib
+func_extract_an_archive ()
+{
+    $debug_cmd
+
+    f_ex_an_ar_dir=$1; shift
+    f_ex_an_ar_oldlib=$1
+    if test yes = "$lock_old_archive_extraction"; then
+      lockfile=$f_ex_an_ar_oldlib.lock
+      until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
+	func_echo "Waiting for $lockfile to be removed"
+	sleep 2
+      done
+    fi
+    func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
+		   'stat=$?; rm -f "$lockfile"; exit $stat'
+    if test yes = "$lock_old_archive_extraction"; then
+      $opt_dry_run || rm -f "$lockfile"
+    fi
+    if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
+     :
+    else
+      func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
+    fi
+}
+
+
+# func_extract_archives gentop oldlib ...
+func_extract_archives ()
+{
+    $debug_cmd
+
+    my_gentop=$1; shift
+    my_oldlibs=${1+"$@"}
+    my_oldobjs=
+    my_xlib=
+    my_xabs=
+    my_xdir=
+
+    for my_xlib in $my_oldlibs; do
+      # Extract the objects.
+      case $my_xlib in
+	[\\/]* | [A-Za-z]:[\\/]*) my_xabs=$my_xlib ;;
+	*) my_xabs=`pwd`"/$my_xlib" ;;
+      esac
+      func_basename "$my_xlib"
+      my_xlib=$func_basename_result
+      my_xlib_u=$my_xlib
+      while :; do
+        case " $extracted_archives " in
+	*" $my_xlib_u "*)
+	  func_arith $extracted_serial + 1
+	  extracted_serial=$func_arith_result
+	  my_xlib_u=lt$extracted_serial-$my_xlib ;;
+	*) break ;;
+	esac
+      done
+      extracted_archives="$extracted_archives $my_xlib_u"
+      my_xdir=$my_gentop/$my_xlib_u
+
+      func_mkdir_p "$my_xdir"
+
+      case $host in
+      *-darwin*)
+	func_verbose "Extracting $my_xabs"
+	# Do not bother doing anything if just a dry run
+	$opt_dry_run || {
+	  darwin_orig_dir=`pwd`
+	  cd $my_xdir || exit $?
+	  darwin_archive=$my_xabs
+	  darwin_curdir=`pwd`
+	  func_basename "$darwin_archive"
+	  darwin_base_archive=$func_basename_result
+	  darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
+	  if test -n "$darwin_arches"; then
+	    darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
+	    darwin_arch=
+	    func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
+	    for darwin_arch in  $darwin_arches; do
+	      func_mkdir_p "unfat-$$/$darwin_base_archive-$darwin_arch"
+	      $LIPO -thin $darwin_arch -output "unfat-$$/$darwin_base_archive-$darwin_arch/$darwin_base_archive" "$darwin_archive"
+	      cd "unfat-$$/$darwin_base_archive-$darwin_arch"
+	      func_extract_an_archive "`pwd`" "$darwin_base_archive"
+	      cd "$darwin_curdir"
+	      $RM "unfat-$$/$darwin_base_archive-$darwin_arch/$darwin_base_archive"
+	    done # $darwin_arches
+            ## Okay now we've a bunch of thin objects, gotta fatten them up :)
+	    darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$sed_basename" | sort -u`
+	    darwin_file=
+	    darwin_files=
+	    for darwin_file in $darwin_filelist; do
+	      darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
+	      $LIPO -create -output "$darwin_file" $darwin_files
+	    done # $darwin_filelist
+	    $RM -rf unfat-$$
+	    cd "$darwin_orig_dir"
+	  else
+	    cd $darwin_orig_dir
+	    func_extract_an_archive "$my_xdir" "$my_xabs"
+	  fi # $darwin_arches
+	} # !$opt_dry_run
+	;;
+      *)
+        func_extract_an_archive "$my_xdir" "$my_xabs"
+	;;
+      esac
+      my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
+    done
+
+    func_extract_archives_result=$my_oldobjs
+}
+
+
+# func_emit_wrapper [arg=no]
+#
+# Emit a libtool wrapper script on stdout.
+# Don't directly open a file because we may want to
+# incorporate the script contents within a cygwin/mingw
+# wrapper executable.  Must ONLY be called from within
+# func_mode_link because it depends on a number of variables
+# set therein.
+#
+# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
+# variable will take.  If 'yes', then the emitted script
+# will assume that the directory where it is stored is
+# the $objdir directory.  This is a cygwin/mingw-specific
+# behavior.
+func_emit_wrapper ()
+{
+	func_emit_wrapper_arg1=${1-no}
+
+	$ECHO "\
+#! $SHELL
+
+# $output - temporary wrapper script for $objdir/$outputname
+# Generated by $PROGRAM (GNU $PACKAGE) $VERSION
+#
+# The $output program cannot be directly executed until all the libtool
+# libraries that it depends on are installed.
+#
+# This wrapper script should never be moved out of the build directory.
+# If it is, it will not operate correctly.
+
+# Sed substitution that helps us do robust quoting.  It backslashifies
+# metacharacters that are still active within double-quoted strings.
+sed_quote_subst='$sed_quote_subst'
+
+# Be Bourne compatible
+if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
+  emulate sh
+  NULLCMD=:
+  # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '\${1+\"\$@\"}'='\"\$@\"'
+  setopt NO_GLOB_SUBST
+else
+  case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
+fi
+BIN_SH=xpg4; export BIN_SH # for Tru64
+DUALCASE=1; export DUALCASE # for MKS sh
+
+# The HP-UX ksh and POSIX shell print the target directory to stdout
+# if CDPATH is set.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+relink_command=\"$relink_command\"
+
+# This environment variable determines our operation mode.
+if test \"\$libtool_install_magic\" = \"$magic\"; then
+  # install mode needs the following variables:
+  generated_by_libtool_version='$macro_version'
+  notinst_deplibs='$notinst_deplibs'
+else
+  # When we are sourced in execute mode, \$file and \$ECHO are already set.
+  if test \"\$libtool_execute_magic\" != \"$magic\"; then
+    file=\"\$0\""
+
+    qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
+    $ECHO "\
+
+# A function that is used when there is no print builtin or printf.
+func_fallback_echo ()
+{
+  eval 'cat <<_LTECHO_EOF
+\$1
+_LTECHO_EOF'
+}
+    ECHO=\"$qECHO\"
+  fi
+
+# Very basic option parsing. These options are (a) specific to
+# the libtool wrapper, (b) are identical between the wrapper
+# /script/ and the wrapper /executable/ that is used only on
+# windows platforms, and (c) all begin with the string "--lt-"
+# (application programs are unlikely to have options that match
+# this pattern).
+#
+# There are only two supported options: --lt-debug and
+# --lt-dump-script. There is, deliberately, no --lt-help.
+#
+# The first argument to this parsing function should be the
+# script's $0 value, followed by "$@".
+lt_option_debug=
+func_parse_lt_options ()
+{
+  lt_script_arg0=\$0
+  shift
+  for lt_opt
+  do
+    case \"\$lt_opt\" in
+    --lt-debug) lt_option_debug=1 ;;
+    --lt-dump-script)
+        lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
+        test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
+        lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
+        cat \"\$lt_dump_D/\$lt_dump_F\"
+        exit 0
+      ;;
+    --lt-*)
+        \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
+        exit 1
+      ;;
+    esac
+  done
+
+  # Print the debug banner immediately:
+  if test -n \"\$lt_option_debug\"; then
+    echo \"$outputname:$output:\$LINENO: libtool wrapper (GNU $PACKAGE) $VERSION\" 1>&2
+  fi
+}
+
+# Used when --lt-debug. Prints its arguments to stdout
+# (redirection is the responsibility of the caller)
+func_lt_dump_args ()
+{
+  lt_dump_args_N=1;
+  for lt_arg
+  do
+    \$ECHO \"$outputname:$output:\$LINENO: newargv[\$lt_dump_args_N]: \$lt_arg\"
+    lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
+  done
+}
+
+# Core function for launching the target application
+func_exec_program_core ()
+{
+"
+  case $host in
+  # Backslashes separate directories on plain windows
+  *-*-mingw | *-*-os2* | *-cegcc*)
+    $ECHO "\
+      if test -n \"\$lt_option_debug\"; then
+        \$ECHO \"$outputname:$output:\$LINENO: newargv[0]: \$progdir\\\\\$program\" 1>&2
+        func_lt_dump_args \${1+\"\$@\"} 1>&2
+      fi
+      exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
+"
+    ;;
+
+  *)
+    $ECHO "\
+      if test -n \"\$lt_option_debug\"; then
+        \$ECHO \"$outputname:$output:\$LINENO: newargv[0]: \$progdir/\$program\" 1>&2
+        func_lt_dump_args \${1+\"\$@\"} 1>&2
+      fi
+      exec \"\$progdir/\$program\" \${1+\"\$@\"}
+"
+    ;;
+  esac
+  $ECHO "\
+      \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
+      exit 1
+}
+
+# A function to encapsulate launching the target application
+# Strips options in the --lt-* namespace from \$@ and
+# launches target application with the remaining arguments.
+func_exec_program ()
+{
+  case \" \$* \" in
+  *\\ --lt-*)
+    for lt_wr_arg
+    do
+      case \$lt_wr_arg in
+      --lt-*) ;;
+      *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
+      esac
+      shift
+    done ;;
+  esac
+  func_exec_program_core \${1+\"\$@\"}
+}
+
+  # Parse options
+  func_parse_lt_options \"\$0\" \${1+\"\$@\"}
+
+  # Find the directory that this script lives in.
+  thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
+  test \"x\$thisdir\" = \"x\$file\" && thisdir=.
+
+  # Follow symbolic links until we get to the real thisdir.
+  file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
+  while test -n \"\$file\"; do
+    destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
+
+    # If there was a directory component, then change thisdir.
+    if test \"x\$destdir\" != \"x\$file\"; then
+      case \"\$destdir\" in
+      [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
+      *) thisdir=\"\$thisdir/\$destdir\" ;;
+      esac
+    fi
+
+    file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
+    file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
+  done
+
+  # Usually 'no', except on cygwin/mingw when embedded into
+  # the cwrapper.
+  WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
+  if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
+    # special case for '.'
+    if test \"\$thisdir\" = \".\"; then
+      thisdir=\`pwd\`
+    fi
+    # remove .libs from thisdir
+    case \"\$thisdir\" in
+    *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
+    $objdir )   thisdir=. ;;
+    esac
+  fi
+
+  # Try to get the absolute directory name.
+  absdir=\`cd \"\$thisdir\" && pwd\`
+  test -n \"\$absdir\" && thisdir=\"\$absdir\"
+"
+
+	if test yes = "$fast_install"; then
+	  $ECHO "\
+  program=lt-'$outputname'$exeext
+  progdir=\"\$thisdir/$objdir\"
+
+  if test ! -f \"\$progdir/\$program\" ||
+     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | $SED 1q\`; \\
+       test \"X\$file\" != \"X\$progdir/\$program\"; }; then
+
+    file=\"\$\$-\$program\"
+
+    if test ! -d \"\$progdir\"; then
+      $MKDIR \"\$progdir\"
+    else
+      $RM \"\$progdir/\$file\"
+    fi"
+
+	  $ECHO "\
+
+    # relink executable if necessary
+    if test -n \"\$relink_command\"; then
+      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
+      else
+	\$ECHO \"\$relink_command_output\" >&2
+	$RM \"\$progdir/\$file\"
+	exit 1
+      fi
+    fi
+
+    $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
+    { $RM \"\$progdir/\$program\";
+      $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
+    $RM \"\$progdir/\$file\"
+  fi"
+	else
+	  $ECHO "\
+  program='$outputname'
+  progdir=\"\$thisdir/$objdir\"
+"
+	fi
+
+	$ECHO "\
+
+  if test -f \"\$progdir/\$program\"; then"
+
+	# fixup the dll searchpath if we need to.
+	#
+	# Fix the DLL searchpath if we need to.  Do this before prepending
+	# to shlibpath, because on Windows, both are PATH and uninstalled
+	# libraries must come first.
+	if test -n "$dllsearchpath"; then
+	  $ECHO "\
+    # Add the dll search path components to the executable PATH
+    PATH=$dllsearchpath:\$PATH
+"
+	fi
+
+	# Export our shlibpath_var if we have one.
+	if test yes = "$shlibpath_overrides_runpath" && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
+	  $ECHO "\
+    # Add our own library path to $shlibpath_var
+    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
+
+    # Some systems cannot cope with colon-terminated $shlibpath_var
+    # The second colon is a workaround for a bug in BeOS R4 sed
+    $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
+
+    export $shlibpath_var
+"
+	fi
+
+	$ECHO "\
+    if test \"\$libtool_execute_magic\" != \"$magic\"; then
+      # Run the actual program with our arguments.
+      func_exec_program \${1+\"\$@\"}
+    fi
+  else
+    # The program doesn't exist.
+    \$ECHO \"\$0: error: '\$progdir/\$program' does not exist\" 1>&2
+    \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
+    \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
+    exit 1
+  fi
+fi\
+"
+}
+
+
+# func_emit_cwrapperexe_src
+# emit the source code for a wrapper executable on stdout
+# Must ONLY be called from within func_mode_link because
+# it depends on a number of variable set therein.
+func_emit_cwrapperexe_src ()
+{
+	cat <<EOF
+
+/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
+   Generated by $PROGRAM (GNU $PACKAGE) $VERSION
+
+   The $output program cannot be directly executed until all the libtool
+   libraries that it depends on are installed.
+
+   This wrapper executable should never be moved out of the build directory.
+   If it is, it will not operate correctly.
+*/
+EOF
+	    cat <<"EOF"
+#ifdef _MSC_VER
+# define _CRT_SECURE_NO_DEPRECATE 1
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _MSC_VER
+# include <direct.h>
+# include <process.h>
+# include <io.h>
+#else
+# include <unistd.h>
+# include <stdint.h>
+# ifdef __CYGWIN__
+#  include <io.h>
+# endif
+#endif
+#include <malloc.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+
+#define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0)
+
+/* declarations of non-ANSI functions */
+#if defined __MINGW32__
+# ifdef __STRICT_ANSI__
+int _putenv (const char *);
+# endif
+#elif defined __CYGWIN__
+# ifdef __STRICT_ANSI__
+char *realpath (const char *, char *);
+int putenv (char *);
+int setenv (const char *, const char *, int);
+# endif
+/* #elif defined other_platform || defined ... */
+#endif
+
+/* portability defines, excluding path handling macros */
+#if defined _MSC_VER
+# define setmode _setmode
+# define stat    _stat
+# define chmod   _chmod
+# define getcwd  _getcwd
+# define putenv  _putenv
+# define S_IXUSR _S_IEXEC
+#elif defined __MINGW32__
+# define setmode _setmode
+# define stat    _stat
+# define chmod   _chmod
+# define getcwd  _getcwd
+# define putenv  _putenv
+#elif defined __CYGWIN__
+# define HAVE_SETENV
+# define FOPEN_WB "wb"
+/* #elif defined other platforms ... */
+#endif
+
+#if defined PATH_MAX
+# define LT_PATHMAX PATH_MAX
+#elif defined MAXPATHLEN
+# define LT_PATHMAX MAXPATHLEN
+#else
+# define LT_PATHMAX 1024
+#endif
+
+#ifndef S_IXOTH
+# define S_IXOTH 0
+#endif
+#ifndef S_IXGRP
+# define S_IXGRP 0
+#endif
+
+/* path handling portability macros */
+#ifndef DIR_SEPARATOR
+# define DIR_SEPARATOR '/'
+# define PATH_SEPARATOR ':'
+#endif
+
+#if defined _WIN32 || defined __MSDOS__ || defined __DJGPP__ || \
+  defined __OS2__
+# define HAVE_DOS_BASED_FILE_SYSTEM
+# define FOPEN_WB "wb"
+# ifndef DIR_SEPARATOR_2
+#  define DIR_SEPARATOR_2 '\\'
+# endif
+# ifndef PATH_SEPARATOR_2
+#  define PATH_SEPARATOR_2 ';'
+# endif
+#endif
+
+#ifndef DIR_SEPARATOR_2
+# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
+#else /* DIR_SEPARATOR_2 */
+# define IS_DIR_SEPARATOR(ch) \
+	(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
+#endif /* DIR_SEPARATOR_2 */
+
+#ifndef PATH_SEPARATOR_2
+# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
+#else /* PATH_SEPARATOR_2 */
+# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
+#endif /* PATH_SEPARATOR_2 */
+
+#ifndef FOPEN_WB
+# define FOPEN_WB "w"
+#endif
+#ifndef _O_BINARY
+# define _O_BINARY 0
+#endif
+
+#define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
+#define XFREE(stale) do { \
+  if (stale) { free (stale); stale = 0; } \
+} while (0)
+
+#if defined LT_DEBUGWRAPPER
+static int lt_debug = 1;
+#else
+static int lt_debug = 0;
+#endif
+
+const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
+
+void *xmalloc (size_t num);
+char *xstrdup (const char *string);
+const char *base_name (const char *name);
+char *find_executable (const char *wrapper);
+char *chase_symlinks (const char *pathspec);
+int make_executable (const char *path);
+int check_executable (const char *path);
+char *strendzap (char *str, const char *pat);
+void lt_debugprintf (const char *file, int line, const char *fmt, ...);
+void lt_fatal (const char *file, int line, const char *message, ...);
+static const char *nonnull (const char *s);
+static const char *nonempty (const char *s);
+void lt_setenv (const char *name, const char *value);
+char *lt_extend_str (const char *orig_value, const char *add, int to_end);
+void lt_update_exe_path (const char *name, const char *value);
+void lt_update_lib_path (const char *name, const char *value);
+char **prepare_spawn (char **argv);
+void lt_dump_script (FILE *f);
+EOF
+
+	    cat <<EOF
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5)
+# define externally_visible volatile
+#else
+# define externally_visible __attribute__((externally_visible)) volatile
+#endif
+externally_visible const char * MAGIC_EXE = "$magic_exe";
+const char * LIB_PATH_VARNAME = "$shlibpath_var";
+EOF
+
+	    if test yes = "$shlibpath_overrides_runpath" && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
+              func_to_host_path "$temp_rpath"
+	      cat <<EOF
+const char * LIB_PATH_VALUE   = "$func_to_host_path_result";
+EOF
+	    else
+	      cat <<"EOF"
+const char * LIB_PATH_VALUE   = "";
+EOF
+	    fi
+
+	    if test -n "$dllsearchpath"; then
+              func_to_host_path "$dllsearchpath:"
+	      cat <<EOF
+const char * EXE_PATH_VARNAME = "PATH";
+const char * EXE_PATH_VALUE   = "$func_to_host_path_result";
+EOF
+	    else
+	      cat <<"EOF"
+const char * EXE_PATH_VARNAME = "";
+const char * EXE_PATH_VALUE   = "";
+EOF
+	    fi
+
+	    if test yes = "$fast_install"; then
+	      cat <<EOF
+const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
+EOF
+	    else
+	      cat <<EOF
+const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
+EOF
+	    fi
+
+
+	    cat <<"EOF"
+
+#define LTWRAPPER_OPTION_PREFIX         "--lt-"
+
+static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
+static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";
+static const char *debug_opt            = LTWRAPPER_OPTION_PREFIX "debug";
+
+int
+main (int argc, char *argv[])
+{
+  char **newargz;
+  int  newargc;
+  char *tmp_pathspec;
+  char *actual_cwrapper_path;
+  char *actual_cwrapper_name;
+  char *target_name;
+  char *lt_argv_zero;
+  int rval = 127;
+
+  int i;
+
+  program_name = (char *) xstrdup (base_name (argv[0]));
+  newargz = XMALLOC (char *, (size_t) argc + 1);
+
+  /* very simple arg parsing; don't want to rely on getopt
+   * also, copy all non cwrapper options to newargz, except
+   * argz[0], which is handled differently
+   */
+  newargc=0;
+  for (i = 1; i < argc; i++)
+    {
+      if (STREQ (argv[i], dumpscript_opt))
+	{
+EOF
+	    case $host in
+	      *mingw* | *cygwin* )
+		# make stdout use "unix" line endings
+		echo "          setmode(1,_O_BINARY);"
+		;;
+	      esac
+
+	    cat <<"EOF"
+	  lt_dump_script (stdout);
+	  return 0;
+	}
+      if (STREQ (argv[i], debug_opt))
+	{
+          lt_debug = 1;
+          continue;
+	}
+      if (STREQ (argv[i], ltwrapper_option_prefix))
+        {
+          /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
+             namespace, but it is not one of the ones we know about and
+             have already dealt with, above (inluding dump-script), then
+             report an error. Otherwise, targets might begin to believe
+             they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
+             namespace. The first time any user complains about this, we'll
+             need to make LTWRAPPER_OPTION_PREFIX a configure-time option
+             or a configure.ac-settable value.
+           */
+          lt_fatal (__FILE__, __LINE__,
+		    "unrecognized %s option: '%s'",
+                    ltwrapper_option_prefix, argv[i]);
+        }
+      /* otherwise ... */
+      newargz[++newargc] = xstrdup (argv[i]);
+    }
+  newargz[++newargc] = NULL;
+
+EOF
+	    cat <<EOF
+  /* The GNU banner must be the first non-error debug message */
+  lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE) $VERSION\n");
+EOF
+	    cat <<"EOF"
+  lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
+  lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
+
+  tmp_pathspec = find_executable (argv[0]);
+  if (tmp_pathspec == NULL)
+    lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
+  lt_debugprintf (__FILE__, __LINE__,
+                  "(main) found exe (before symlink chase) at: %s\n",
+		  tmp_pathspec);
+
+  actual_cwrapper_path = chase_symlinks (tmp_pathspec);
+  lt_debugprintf (__FILE__, __LINE__,
+                  "(main) found exe (after symlink chase) at: %s\n",
+		  actual_cwrapper_path);
+  XFREE (tmp_pathspec);
+
+  actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
+  strendzap (actual_cwrapper_path, actual_cwrapper_name);
+
+  /* wrapper name transforms */
+  strendzap (actual_cwrapper_name, ".exe");
+  tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
+  XFREE (actual_cwrapper_name);
+  actual_cwrapper_name = tmp_pathspec;
+  tmp_pathspec = 0;
+
+  /* target_name transforms -- use actual target program name; might have lt- prefix */
+  target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
+  strendzap (target_name, ".exe");
+  tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
+  XFREE (target_name);
+  target_name = tmp_pathspec;
+  tmp_pathspec = 0;
+
+  lt_debugprintf (__FILE__, __LINE__,
+		  "(main) libtool target name: %s\n",
+		  target_name);
+EOF
+
+	    cat <<EOF
+  newargz[0] =
+    XMALLOC (char, (strlen (actual_cwrapper_path) +
+		    strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
+  strcpy (newargz[0], actual_cwrapper_path);
+  strcat (newargz[0], "$objdir");
+  strcat (newargz[0], "/");
+EOF
+
+	    cat <<"EOF"
+  /* stop here, and copy so we don't have to do this twice */
+  tmp_pathspec = xstrdup (newargz[0]);
+
+  /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
+  strcat (newargz[0], actual_cwrapper_name);
+
+  /* DO want the lt- prefix here if it exists, so use target_name */
+  lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
+  XFREE (tmp_pathspec);
+  tmp_pathspec = NULL;
+EOF
+
+	    case $host_os in
+	      mingw*)
+	    cat <<"EOF"
+  {
+    char* p;
+    while ((p = strchr (newargz[0], '\\')) != NULL)
+      {
+	*p = '/';
+      }
+    while ((p = strchr (lt_argv_zero, '\\')) != NULL)
+      {
+	*p = '/';
+      }
+  }
+EOF
+	    ;;
+	    esac
+
+	    cat <<"EOF"
+  XFREE (target_name);
+  XFREE (actual_cwrapper_path);
+  XFREE (actual_cwrapper_name);
+
+  lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
+  lt_setenv ("DUALCASE", "1");  /* for MSK sh */
+  /* Update the DLL searchpath.  EXE_PATH_VALUE ($dllsearchpath) must
+     be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
+     because on Windows, both *_VARNAMEs are PATH but uninstalled
+     libraries must come first. */
+  lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
+  lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
+
+  lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
+		  nonnull (lt_argv_zero));
+  for (i = 0; i < newargc; i++)
+    {
+      lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
+		      i, nonnull (newargz[i]));
+    }
+
+EOF
+
+	    case $host_os in
+	      mingw*)
+		cat <<"EOF"
+  /* execv doesn't actually work on mingw as expected on unix */
+  newargz = prepare_spawn (newargz);
+  rval = (int) _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
+  if (rval == -1)
+    {
+      /* failed to start process */
+      lt_debugprintf (__FILE__, __LINE__,
+		      "(main) failed to launch target \"%s\": %s\n",
+		      lt_argv_zero, nonnull (strerror (errno)));
+      return 127;
+    }
+  return rval;
+EOF
+		;;
+	      *)
+		cat <<"EOF"
+  execv (lt_argv_zero, newargz);
+  return rval; /* =127, but avoids unused variable warning */
+EOF
+		;;
+	    esac
+
+	    cat <<"EOF"
+}
+
+void *
+xmalloc (size_t num)
+{
+  void *p = (void *) malloc (num);
+  if (!p)
+    lt_fatal (__FILE__, __LINE__, "memory exhausted");
+
+  return p;
+}
+
+char *
+xstrdup (const char *string)
+{
+  return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
+			  string) : NULL;
+}
+
+const char *
+base_name (const char *name)
+{
+  const char *base;
+
+#if defined HAVE_DOS_BASED_FILE_SYSTEM
+  /* Skip over the disk name in MSDOS pathnames. */
+  if (isalpha ((unsigned char) name[0]) && name[1] == ':')
+    name += 2;
+#endif
+
+  for (base = name; *name; name++)
+    if (IS_DIR_SEPARATOR (*name))
+      base = name + 1;
+  return base;
+}
+
+int
+check_executable (const char *path)
+{
+  struct stat st;
+
+  lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
+                  nonempty (path));
+  if ((!path) || (!*path))
+    return 0;
+
+  if ((stat (path, &st) >= 0)
+      && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
+    return 1;
+  else
+    return 0;
+}
+
+int
+make_executable (const char *path)
+{
+  int rval = 0;
+  struct stat st;
+
+  lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
+                  nonempty (path));
+  if ((!path) || (!*path))
+    return 0;
+
+  if (stat (path, &st) >= 0)
+    {
+      rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
+    }
+  return rval;
+}
+
+/* Searches for the full path of the wrapper.  Returns
+   newly allocated full path name if found, NULL otherwise
+   Does not chase symlinks, even on platforms that support them.
+*/
+char *
+find_executable (const char *wrapper)
+{
+  int has_slash = 0;
+  const char *p;
+  const char *p_next;
+  /* static buffer for getcwd */
+  char tmp[LT_PATHMAX + 1];
+  size_t tmp_len;
+  char *concat_name;
+
+  lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
+                  nonempty (wrapper));
+
+  if ((wrapper == NULL) || (*wrapper == '\0'))
+    return NULL;
+
+  /* Absolute path? */
+#if defined HAVE_DOS_BASED_FILE_SYSTEM
+  if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
+    {
+      concat_name = xstrdup (wrapper);
+      if (check_executable (concat_name))
+	return concat_name;
+      XFREE (concat_name);
+    }
+  else
+    {
+#endif
+      if (IS_DIR_SEPARATOR (wrapper[0]))
+	{
+	  concat_name = xstrdup (wrapper);
+	  if (check_executable (concat_name))
+	    return concat_name;
+	  XFREE (concat_name);
+	}
+#if defined HAVE_DOS_BASED_FILE_SYSTEM
+    }
+#endif
+
+  for (p = wrapper; *p; p++)
+    if (*p == '/')
+      {
+	has_slash = 1;
+	break;
+      }
+  if (!has_slash)
+    {
+      /* no slashes; search PATH */
+      const char *path = getenv ("PATH");
+      if (path != NULL)
+	{
+	  for (p = path; *p; p = p_next)
+	    {
+	      const char *q;
+	      size_t p_len;
+	      for (q = p; *q; q++)
+		if (IS_PATH_SEPARATOR (*q))
+		  break;
+	      p_len = (size_t) (q - p);
+	      p_next = (*q == '\0' ? q : q + 1);
+	      if (p_len == 0)
+		{
+		  /* empty path: current directory */
+		  if (getcwd (tmp, LT_PATHMAX) == NULL)
+		    lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
+                              nonnull (strerror (errno)));
+		  tmp_len = strlen (tmp);
+		  concat_name =
+		    XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
+		  memcpy (concat_name, tmp, tmp_len);
+		  concat_name[tmp_len] = '/';
+		  strcpy (concat_name + tmp_len + 1, wrapper);
+		}
+	      else
+		{
+		  concat_name =
+		    XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
+		  memcpy (concat_name, p, p_len);
+		  concat_name[p_len] = '/';
+		  strcpy (concat_name + p_len + 1, wrapper);
+		}
+	      if (check_executable (concat_name))
+		return concat_name;
+	      XFREE (concat_name);
+	    }
+	}
+      /* not found in PATH; assume curdir */
+    }
+  /* Relative path | not found in path: prepend cwd */
+  if (getcwd (tmp, LT_PATHMAX) == NULL)
+    lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
+              nonnull (strerror (errno)));
+  tmp_len = strlen (tmp);
+  concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
+  memcpy (concat_name, tmp, tmp_len);
+  concat_name[tmp_len] = '/';
+  strcpy (concat_name + tmp_len + 1, wrapper);
+
+  if (check_executable (concat_name))
+    return concat_name;
+  XFREE (concat_name);
+  return NULL;
+}
+
+char *
+chase_symlinks (const char *pathspec)
+{
+#ifndef S_ISLNK
+  return xstrdup (pathspec);
+#else
+  char buf[LT_PATHMAX];
+  struct stat s;
+  char *tmp_pathspec = xstrdup (pathspec);
+  char *p;
+  int has_symlinks = 0;
+  while (strlen (tmp_pathspec) && !has_symlinks)
+    {
+      lt_debugprintf (__FILE__, __LINE__,
+		      "checking path component for symlinks: %s\n",
+		      tmp_pathspec);
+      if (lstat (tmp_pathspec, &s) == 0)
+	{
+	  if (S_ISLNK (s.st_mode) != 0)
+	    {
+	      has_symlinks = 1;
+	      break;
+	    }
+
+	  /* search backwards for last DIR_SEPARATOR */
+	  p = tmp_pathspec + strlen (tmp_pathspec) - 1;
+	  while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
+	    p--;
+	  if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
+	    {
+	      /* no more DIR_SEPARATORS left */
+	      break;
+	    }
+	  *p = '\0';
+	}
+      else
+	{
+	  lt_fatal (__FILE__, __LINE__,
+		    "error accessing file \"%s\": %s",
+		    tmp_pathspec, nonnull (strerror (errno)));
+	}
+    }
+  XFREE (tmp_pathspec);
+
+  if (!has_symlinks)
+    {
+      return xstrdup (pathspec);
+    }
+
+  tmp_pathspec = realpath (pathspec, buf);
+  if (tmp_pathspec == 0)
+    {
+      lt_fatal (__FILE__, __LINE__,
+		"could not follow symlinks for %s", pathspec);
+    }
+  return xstrdup (tmp_pathspec);
+#endif
+}
+
+char *
+strendzap (char *str, const char *pat)
+{
+  size_t len, patlen;
+
+  assert (str != NULL);
+  assert (pat != NULL);
+
+  len = strlen (str);
+  patlen = strlen (pat);
+
+  if (patlen <= len)
+    {
+      str += len - patlen;
+      if (STREQ (str, pat))
+	*str = '\0';
+    }
+  return str;
+}
+
+void
+lt_debugprintf (const char *file, int line, const char *fmt, ...)
+{
+  va_list args;
+  if (lt_debug)
+    {
+      (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
+      va_start (args, fmt);
+      (void) vfprintf (stderr, fmt, args);
+      va_end (args);
+    }
+}
+
+static void
+lt_error_core (int exit_status, const char *file,
+	       int line, const char *mode,
+	       const char *message, va_list ap)
+{
+  fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
+  vfprintf (stderr, message, ap);
+  fprintf (stderr, ".\n");
+
+  if (exit_status >= 0)
+    exit (exit_status);
+}
+
+void
+lt_fatal (const char *file, int line, const char *message, ...)
+{
+  va_list ap;
+  va_start (ap, message);
+  lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
+  va_end (ap);
+}
+
+static const char *
+nonnull (const char *s)
+{
+  return s ? s : "(null)";
+}
+
+static const char *
+nonempty (const char *s)
+{
+  return (s && !*s) ? "(empty)" : nonnull (s);
+}
+
+void
+lt_setenv (const char *name, const char *value)
+{
+  lt_debugprintf (__FILE__, __LINE__,
+		  "(lt_setenv) setting '%s' to '%s'\n",
+                  nonnull (name), nonnull (value));
+  {
+#ifdef HAVE_SETENV
+    /* always make a copy, for consistency with !HAVE_SETENV */
+    char *str = xstrdup (value);
+    setenv (name, str, 1);
+#else
+    size_t len = strlen (name) + 1 + strlen (value) + 1;
+    char *str = XMALLOC (char, len);
+    sprintf (str, "%s=%s", name, value);
+    if (putenv (str) != EXIT_SUCCESS)
+      {
+        XFREE (str);
+      }
+#endif
+  }
+}
+
+char *
+lt_extend_str (const char *orig_value, const char *add, int to_end)
+{
+  char *new_value;
+  if (orig_value && *orig_value)
+    {
+      size_t orig_value_len = strlen (orig_value);
+      size_t add_len = strlen (add);
+      new_value = XMALLOC (char, add_len + orig_value_len + 1);
+      if (to_end)
+        {
+          strcpy (new_value, orig_value);
+          strcpy (new_value + orig_value_len, add);
+        }
+      else
+        {
+          strcpy (new_value, add);
+          strcpy (new_value + add_len, orig_value);
+        }
+    }
+  else
+    {
+      new_value = xstrdup (add);
+    }
+  return new_value;
+}
+
+void
+lt_update_exe_path (const char *name, const char *value)
+{
+  lt_debugprintf (__FILE__, __LINE__,
+		  "(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
+                  nonnull (name), nonnull (value));
+
+  if (name && *name && value && *value)
+    {
+      char *new_value = lt_extend_str (getenv (name), value, 0);
+      /* some systems can't cope with a ':'-terminated path #' */
+      size_t len = strlen (new_value);
+      while ((len > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
+        {
+          new_value[--len] = '\0';
+        }
+      lt_setenv (name, new_value);
+      XFREE (new_value);
+    }
+}
+
+void
+lt_update_lib_path (const char *name, const char *value)
+{
+  lt_debugprintf (__FILE__, __LINE__,
+		  "(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
+                  nonnull (name), nonnull (value));
+
+  if (name && *name && value && *value)
+    {
+      char *new_value = lt_extend_str (getenv (name), value, 0);
+      lt_setenv (name, new_value);
+      XFREE (new_value);
+    }
+}
+
+EOF
+	    case $host_os in
+	      mingw*)
+		cat <<"EOF"
+
+/* Prepares an argument vector before calling spawn().
+   Note that spawn() does not by itself call the command interpreter
+     (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
+      ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+         GetVersionEx(&v);
+         v.dwPlatformId == VER_PLATFORM_WIN32_NT;
+      }) ? "cmd.exe" : "command.com").
+   Instead it simply concatenates the arguments, separated by ' ', and calls
+   CreateProcess().  We must quote the arguments since Win32 CreateProcess()
+   interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
+   special way:
+   - Space and tab are interpreted as delimiters. They are not treated as
+     delimiters if they are surrounded by double quotes: "...".
+   - Unescaped double quotes are removed from the input. Their only effect is
+     that within double quotes, space and tab are treated like normal
+     characters.
+   - Backslashes not followed by double quotes are not special.
+   - But 2*n+1 backslashes followed by a double quote become
+     n backslashes followed by a double quote (n >= 0):
+       \" -> "
+       \\\" -> \"
+       \\\\\" -> \\"
+ */
+#define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
+#define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
+char **
+prepare_spawn (char **argv)
+{
+  size_t argc;
+  char **new_argv;
+  size_t i;
+
+  /* Count number of arguments.  */
+  for (argc = 0; argv[argc] != NULL; argc++)
+    ;
+
+  /* Allocate new argument vector.  */
+  new_argv = XMALLOC (char *, argc + 1);
+
+  /* Put quoted arguments into the new argument vector.  */
+  for (i = 0; i < argc; i++)
+    {
+      const char *string = argv[i];
+
+      if (string[0] == '\0')
+	new_argv[i] = xstrdup ("\"\"");
+      else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
+	{
+	  int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
+	  size_t length;
+	  unsigned int backslashes;
+	  const char *s;
+	  char *quoted_string;
+	  char *p;
+
+	  length = 0;
+	  backslashes = 0;
+	  if (quote_around)
+	    length++;
+	  for (s = string; *s != '\0'; s++)
+	    {
+	      char c = *s;
+	      if (c == '"')
+		length += backslashes + 1;
+	      length++;
+	      if (c == '\\')
+		backslashes++;
+	      else
+		backslashes = 0;
+	    }
+	  if (quote_around)
+	    length += backslashes + 1;
+
+	  quoted_string = XMALLOC (char, length + 1);
+
+	  p = quoted_string;
+	  backslashes = 0;
+	  if (quote_around)
+	    *p++ = '"';
+	  for (s = string; *s != '\0'; s++)
+	    {
+	      char c = *s;
+	      if (c == '"')
+		{
+		  unsigned int j;
+		  for (j = backslashes + 1; j > 0; j--)
+		    *p++ = '\\';
+		}
+	      *p++ = c;
+	      if (c == '\\')
+		backslashes++;
+	      else
+		backslashes = 0;
+	    }
+	  if (quote_around)
+	    {
+	      unsigned int j;
+	      for (j = backslashes; j > 0; j--)
+		*p++ = '\\';
+	      *p++ = '"';
+	    }
+	  *p = '\0';
+
+	  new_argv[i] = quoted_string;
+	}
+      else
+	new_argv[i] = (char *) string;
+    }
+  new_argv[argc] = NULL;
+
+  return new_argv;
+}
+EOF
+		;;
+	    esac
+
+            cat <<"EOF"
+void lt_dump_script (FILE* f)
+{
+EOF
+	    func_emit_wrapper yes |
+	      $SED -n -e '
+s/^\(.\{79\}\)\(..*\)/\1\
+\2/
+h
+s/\([\\"]\)/\\\1/g
+s/$/\\n/
+s/\([^\n]*\).*/  fputs ("\1", f);/p
+g
+D'
+            cat <<"EOF"
+}
+EOF
+}
+# end: func_emit_cwrapperexe_src
+
+# func_win32_import_lib_p ARG
+# True if ARG is an import lib, as indicated by $file_magic_cmd
+func_win32_import_lib_p ()
+{
+    $debug_cmd
+
+    case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
+    *import*) : ;;
+    *) false ;;
+    esac
+}
+
+# func_suncc_cstd_abi
+# !!ONLY CALL THIS FOR SUN CC AFTER $compile_command IS FULLY EXPANDED!!
+# Several compiler flags select an ABI that is incompatible with the
+# Cstd library. Avoid specifying it if any are in CXXFLAGS.
+func_suncc_cstd_abi ()
+{
+    $debug_cmd
+
+    case " $compile_command " in
+    *" -compat=g "*|*\ -std=c++[0-9][0-9]\ *|*" -library=stdcxx4 "*|*" -library=stlport4 "*)
+      suncc_use_cstd_abi=no
+      ;;
+    *)
+      suncc_use_cstd_abi=yes
+      ;;
+    esac
+}
+
+# func_mode_link arg...
+func_mode_link ()
+{
+    $debug_cmd
+
+    case $host in
+    *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
+      # It is impossible to link a dll without this setting, and
+      # we shouldn't force the makefile maintainer to figure out
+      # what system we are compiling for in order to pass an extra
+      # flag for every libtool invocation.
+      # allow_undefined=no
+
+      # FIXME: Unfortunately, there are problems with the above when trying
+      # to make a dll that has undefined symbols, in which case not
+      # even a static library is built.  For now, we need to specify
+      # -no-undefined on the libtool link line when we can be certain
+      # that all symbols are satisfied, otherwise we get a static library.
+      allow_undefined=yes
+      ;;
+    *)
+      allow_undefined=yes
+      ;;
+    esac
+    libtool_args=$nonopt
+    base_compile="$nonopt $@"
+    compile_command=$nonopt
+    finalize_command=$nonopt
+
+    compile_rpath=
+    finalize_rpath=
+    compile_shlibpath=
+    finalize_shlibpath=
+    convenience=
+    old_convenience=
+    deplibs=
+    old_deplibs=
+    compiler_flags=
+    linker_flags=
+    dllsearchpath=
+    lib_search_path=`pwd`
+    inst_prefix_dir=
+    new_inherited_linker_flags=
+
+    avoid_version=no
+    bindir=
+    dlfiles=
+    dlprefiles=
+    dlself=no
+    export_dynamic=no
+    export_symbols=
+    export_symbols_regex=
+    generated=
+    libobjs=
+    ltlibs=
+    module=no
+    no_install=no
+    objs=
+    os2dllname=
+    non_pic_objects=
+    precious_files_regex=
+    prefer_static_libs=no
+    preload=false
+    prev=
+    prevarg=
+    release=
+    rpath=
+    xrpath=
+    perm_rpath=
+    temp_rpath=
+    thread_safe=no
+    vinfo=
+    vinfo_number=no
+    weak_libs=
+    single_module=$wl-single_module
+    func_infer_tag $base_compile
+
+    # We need to know -static, to get the right output filenames.
+    for arg
+    do
+      case $arg in
+      -shared)
+	test yes != "$build_libtool_libs" \
+	  && func_fatal_configuration "cannot build a shared library"
+	build_old_libs=no
+	break
+	;;
+      -all-static | -static | -static-libtool-libs)
+	case $arg in
+	-all-static)
+	  if test yes = "$build_libtool_libs" && test -z "$link_static_flag"; then
+	    func_warning "complete static linking is impossible in this configuration"
+	  fi
+	  if test -n "$link_static_flag"; then
+	    dlopen_self=$dlopen_self_static
+	  fi
+	  prefer_static_libs=yes
+	  ;;
+	-static)
+	  if test -z "$pic_flag" && test -n "$link_static_flag"; then
+	    dlopen_self=$dlopen_self_static
+	  fi
+	  prefer_static_libs=built
+	  ;;
+	-static-libtool-libs)
+	  if test -z "$pic_flag" && test -n "$link_static_flag"; then
+	    dlopen_self=$dlopen_self_static
+	  fi
+	  prefer_static_libs=yes
+	  ;;
+	esac
+	build_libtool_libs=no
+	build_old_libs=yes
+	break
+	;;
+      esac
+    done
+
+    # See if our shared archives depend on static archives.
+    test -n "$old_archive_from_new_cmds" && build_old_libs=yes
+
+    # Go through the arguments, transforming them on the way.
+    while test "$#" -gt 0; do
+      arg=$1
+      shift
+      func_quote_for_eval "$arg"
+      qarg=$func_quote_for_eval_unquoted_result
+      func_append libtool_args " $func_quote_for_eval_result"
+
+      # If the previous option needs an argument, assign it.
+      if test -n "$prev"; then
+	case $prev in
+	output)
+	  func_append compile_command " @OUTPUT@"
+	  func_append finalize_command " @OUTPUT@"
+	  ;;
+	esac
+
+	case $prev in
+	bindir)
+	  bindir=$arg
+	  prev=
+	  continue
+	  ;;
+	dlfiles|dlprefiles)
+	  $preload || {
+	    # Add the symbol object into the linking commands.
+	    func_append compile_command " @SYMFILE@"
+	    func_append finalize_command " @SYMFILE@"
+	    preload=:
+	  }
+	  case $arg in
+	  *.la | *.lo) ;;  # We handle these cases below.
+	  force)
+	    if test no = "$dlself"; then
+	      dlself=needless
+	      export_dynamic=yes
+	    fi
+	    prev=
+	    continue
+	    ;;
+	  self)
+	    if test dlprefiles = "$prev"; then
+	      dlself=yes
+	    elif test dlfiles = "$prev" && test yes != "$dlopen_self"; then
+	      dlself=yes
+	    else
+	      dlself=needless
+	      export_dynamic=yes
+	    fi
+	    prev=
+	    continue
+	    ;;
+	  *)
+	    if test dlfiles = "$prev"; then
+	      func_append dlfiles " $arg"
+	    else
+	      func_append dlprefiles " $arg"
+	    fi
+	    prev=
+	    continue
+	    ;;
+	  esac
+	  ;;
+	expsyms)
+	  export_symbols=$arg
+	  test -f "$arg" \
+	    || func_fatal_error "symbol file '$arg' does not exist"
+	  prev=
+	  continue
+	  ;;
+	expsyms_regex)
+	  export_symbols_regex=$arg
+	  prev=
+	  continue
+	  ;;
+	framework)
+	  case $host in
+	    *-*-darwin*)
+	      case "$deplibs " in
+		*" $qarg.ltframework "*) ;;
+		*) func_append deplibs " $qarg.ltframework" # this is fixed later
+		   ;;
+	      esac
+	      ;;
+	  esac
+	  prev=
+	  continue
+	  ;;
+	inst_prefix)
+	  inst_prefix_dir=$arg
+	  prev=
+	  continue
+	  ;;
+	mllvm)
+	  # Clang does not use LLVM to link, so we can simply discard any
+	  # '-mllvm $arg' options when doing the link step.
+	  prev=
+	  continue
+	  ;;
+	objectlist)
+	  if test -f "$arg"; then
+	    save_arg=$arg
+	    moreargs=
+	    for fil in `cat "$save_arg"`
+	    do
+#	      func_append moreargs " $fil"
+	      arg=$fil
+	      # A libtool-controlled object.
+
+	      # Check to see that this really is a libtool object.
+	      if func_lalib_unsafe_p "$arg"; then
+		pic_object=
+		non_pic_object=
+
+		# Read the .lo file
+		func_source "$arg"
+
+		if test -z "$pic_object" ||
+		   test -z "$non_pic_object" ||
+		   test none = "$pic_object" &&
+		   test none = "$non_pic_object"; then
+		  func_fatal_error "cannot find name of object for '$arg'"
+		fi
+
+		# Extract subdirectory from the argument.
+		func_dirname "$arg" "/" ""
+		xdir=$func_dirname_result
+
+		if test none != "$pic_object"; then
+		  # Prepend the subdirectory the object is found in.
+		  pic_object=$xdir$pic_object
+
+		  if test dlfiles = "$prev"; then
+		    if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; then
+		      func_append dlfiles " $pic_object"
+		      prev=
+		      continue
+		    else
+		      # If libtool objects are unsupported, then we need to preload.
+		      prev=dlprefiles
+		    fi
+		  fi
+
+		  # CHECK ME:  I think I busted this.  -Ossama
+		  if test dlprefiles = "$prev"; then
+		    # Preload the old-style object.
+		    func_append dlprefiles " $pic_object"
+		    prev=
+		  fi
+
+		  # A PIC object.
+		  func_append libobjs " $pic_object"
+		  arg=$pic_object
+		fi
+
+		# Non-PIC object.
+		if test none != "$non_pic_object"; then
+		  # Prepend the subdirectory the object is found in.
+		  non_pic_object=$xdir$non_pic_object
+
+		  # A standard non-PIC object
+		  func_append non_pic_objects " $non_pic_object"
+		  if test -z "$pic_object" || test none = "$pic_object"; then
+		    arg=$non_pic_object
+		  fi
+		else
+		  # If the PIC object exists, use it instead.
+		  # $xdir was prepended to $pic_object above.
+		  non_pic_object=$pic_object
+		  func_append non_pic_objects " $non_pic_object"
+		fi
+	      else
+		# Only an error if not doing a dry-run.
+		if $opt_dry_run; then
+		  # Extract subdirectory from the argument.
+		  func_dirname "$arg" "/" ""
+		  xdir=$func_dirname_result
+
+		  func_lo2o "$arg"
+		  pic_object=$xdir$objdir/$func_lo2o_result
+		  non_pic_object=$xdir$func_lo2o_result
+		  func_append libobjs " $pic_object"
+		  func_append non_pic_objects " $non_pic_object"
+	        else
+		  func_fatal_error "'$arg' is not a valid libtool object"
+		fi
+	      fi
+	    done
+	  else
+	    func_fatal_error "link input file '$arg' does not exist"
+	  fi
+	  arg=$save_arg
+	  prev=
+	  continue
+	  ;;
+	os2dllname)
+	  os2dllname=$arg
+	  prev=
+	  continue
+	  ;;
+	precious_regex)
+	  precious_files_regex=$arg
+	  prev=
+	  continue
+	  ;;
+	release)
+	  release=-$arg
+	  prev=
+	  continue
+	  ;;
+	rpath | xrpath)
+	  # We need an absolute path.
+	  case $arg in
+	  [\\/]* | [A-Za-z]:[\\/]*) ;;
+	  *)
+	    func_fatal_error "only absolute run-paths are allowed"
+	    ;;
+	  esac
+	  if test rpath = "$prev"; then
+	    case "$rpath " in
+	    *" $arg "*) ;;
+	    *) func_append rpath " $arg" ;;
+	    esac
+	  else
+	    case "$xrpath " in
+	    *" $arg "*) ;;
+	    *) func_append xrpath " $arg" ;;
+	    esac
+	  fi
+	  prev=
+	  continue
+	  ;;
+	shrext)
+	  shrext_cmds=$arg
+	  prev=
+	  continue
+	  ;;
+	weak)
+	  func_append weak_libs " $arg"
+	  prev=
+	  continue
+	  ;;
+	xcclinker)
+	  func_append linker_flags " $qarg"
+	  func_append compiler_flags " $qarg"
+	  prev=
+	  func_append compile_command " $qarg"
+	  func_append finalize_command " $qarg"
+	  continue
+	  ;;
+	xcompiler)
+	  func_append compiler_flags " $qarg"
+	  prev=
+	  func_append compile_command " $qarg"
+	  func_append finalize_command " $qarg"
+	  continue
+	  ;;
+	xlinker)
+	  func_append linker_flags " $qarg"
+	  func_append compiler_flags " $wl$qarg"
+	  prev=
+	  func_append compile_command " $wl$qarg"
+	  func_append finalize_command " $wl$qarg"
+	  continue
+	  ;;
+	*)
+	  eval "$prev=\"\$arg\""
+	  prev=
+	  continue
+	  ;;
+	esac
+      fi # test -n "$prev"
+
+      prevarg=$arg
+
+      case $arg in
+      -all-static)
+	if test -n "$link_static_flag"; then
+	  # See comment for -static flag below, for more details.
+	  func_append compile_command " $link_static_flag"
+	  func_append finalize_command " $link_static_flag"
+	fi
+	continue
+	;;
+
+      -allow-undefined)
+	# FIXME: remove this flag sometime in the future.
+	func_fatal_error "'-allow-undefined' must not be used because it is the default"
+	;;
+
+      -avoid-version)
+	avoid_version=yes
+	continue
+	;;
+
+      -bindir)
+	prev=bindir
+	continue
+	;;
+
+      -dlopen)
+	prev=dlfiles
+	continue
+	;;
+
+      -dlpreopen)
+	prev=dlprefiles
+	continue
+	;;
+
+      -export-dynamic)
+	export_dynamic=yes
+	continue
+	;;
+
+      -export-symbols | -export-symbols-regex)
+	if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
+	  func_fatal_error "more than one -exported-symbols argument is not allowed"
+	fi
+	if test X-export-symbols = "X$arg"; then
+	  prev=expsyms
+	else
+	  prev=expsyms_regex
+	fi
+	continue
+	;;
+
+      -framework)
+	prev=framework
+	continue
+	;;
+
+      -inst-prefix-dir)
+	prev=inst_prefix
+	continue
+	;;
+
+      # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
+      # so, if we see these flags be careful not to treat them like -L
+      -L[A-Z][A-Z]*:*)
+	case $with_gcc/$host in
+	no/*-*-irix* | /*-*-irix*)
+	  func_append compile_command " $arg"
+	  func_append finalize_command " $arg"
+	  ;;
+	esac
+	continue
+	;;
+
+      -L*)
+	func_stripname "-L" '' "$arg"
+	if test -z "$func_stripname_result"; then
+	  if test "$#" -gt 0; then
+	    func_fatal_error "require no space between '-L' and '$1'"
+	  else
+	    func_fatal_error "need path for '-L' option"
+	  fi
+	fi
+	func_resolve_sysroot "$func_stripname_result"
+	dir=$func_resolve_sysroot_result
+	# We need an absolute path.
+	case $dir in
+	[\\/]* | [A-Za-z]:[\\/]*) ;;
+	*)
+	  absdir=`cd "$dir" && pwd`
+	  test -z "$absdir" && \
+	    func_fatal_error "cannot determine absolute directory name of '$dir'"
+	  dir=$absdir
+	  ;;
+	esac
+	case "$deplibs " in
+	*" -L$dir "* | *" $arg "*)
+	  # Will only happen for absolute or sysroot arguments
+	  ;;
+	*)
+	  # Preserve sysroot, but never include relative directories
+	  case $dir in
+	    [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
+	    *) func_append deplibs " -L$dir" ;;
+	  esac
+	  func_append lib_search_path " $dir"
+	  ;;
+	esac
+	case $host in
+	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
+	  testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
+	  case :$dllsearchpath: in
+	  *":$dir:"*) ;;
+	  ::) dllsearchpath=$dir;;
+	  *) func_append dllsearchpath ":$dir";;
+	  esac
+	  case :$dllsearchpath: in
+	  *":$testbindir:"*) ;;
+	  ::) dllsearchpath=$testbindir;;
+	  *) func_append dllsearchpath ":$testbindir";;
+	  esac
+	  ;;
+	esac
+	continue
+	;;
+
+      -l*)
+	if test X-lc = "X$arg" || test X-lm = "X$arg"; then
+	  case $host in
+	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
+	    # These systems don't actually have a C or math library (as such)
+	    continue
+	    ;;
+	  *-*-os2*)
+	    # These systems don't actually have a C library (as such)
+	    test X-lc = "X$arg" && continue
+	    ;;
+	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig*)
+	    # Do not include libc due to us having libc/libc_r.
+	    test X-lc = "X$arg" && continue
+	    ;;
+	  *-*-rhapsody* | *-*-darwin1.[012])
+	    # Rhapsody C and math libraries are in the System framework
+	    func_append deplibs " System.ltframework"
+	    continue
+	    ;;
+	  *-*-sco3.2v5* | *-*-sco5v6*)
+	    # Causes problems with __ctype
+	    test X-lc = "X$arg" && continue
+	    ;;
+	  *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
+	    # Compiler inserts libc in the correct place for threads to work
+	    test X-lc = "X$arg" && continue
+	    ;;
+	  esac
+	elif test X-lc_r = "X$arg"; then
+	 case $host in
+	 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig*)
+	   # Do not include libc_r directly, use -pthread flag.
+	   continue
+	   ;;
+	 esac
+	fi
+	func_append deplibs " $arg"
+	continue
+	;;
+
+      -mllvm)
+	prev=mllvm
+	continue
+	;;
+
+      -module)
+	module=yes
+	continue
+	;;
+
+      # Tru64 UNIX uses -model [arg] to determine the layout of C++
+      # classes, name mangling, and exception handling.
+      # Darwin uses the -arch flag to determine output architecture.
+      -model|-arch|-isysroot|--sysroot)
+	func_append compiler_flags " $arg"
+	func_append compile_command " $arg"
+	func_append finalize_command " $arg"
+	prev=xcompiler
+	continue
+	;;
+
+      -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
+      |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
+	func_append compiler_flags " $arg"
+	func_append compile_command " $arg"
+	func_append finalize_command " $arg"
+	case "$new_inherited_linker_flags " in
+	    *" $arg "*) ;;
+	    * ) func_append new_inherited_linker_flags " $arg" ;;
+	esac
+	continue
+	;;
+
+      -multi_module)
+	single_module=$wl-multi_module
+	continue
+	;;
+
+      -no-fast-install)
+	fast_install=no
+	continue
+	;;
+
+      -no-install)
+	case $host in
+	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
+	  # The PATH hackery in wrapper scripts is required on Windows
+	  # and Darwin in order for the loader to find any dlls it needs.
+	  func_warning "'-no-install' is ignored for $host"
+	  func_warning "assuming '-no-fast-install' instead"
+	  fast_install=no
+	  ;;
+	*) no_install=yes ;;
+	esac
+	continue
+	;;
+
+      -no-undefined)
+	allow_undefined=no
+	continue
+	;;
+
+      -objectlist)
+	prev=objectlist
+	continue
+	;;
+
+      -os2dllname)
+	prev=os2dllname
+	continue
+	;;
+
+      -o) prev=output ;;
+
+      -precious-files-regex)
+	prev=precious_regex
+	continue
+	;;
+
+      -release)
+	prev=release
+	continue
+	;;
+
+      -rpath)
+	prev=rpath
+	continue
+	;;
+
+      -R)
+	prev=xrpath
+	continue
+	;;
+
+      -R*)
+	func_stripname '-R' '' "$arg"
+	dir=$func_stripname_result
+	# We need an absolute path.
+	case $dir in
+	[\\/]* | [A-Za-z]:[\\/]*) ;;
+	=*)
+	  func_stripname '=' '' "$dir"
+	  dir=$lt_sysroot$func_stripname_result
+	  ;;
+	*)
+	  func_fatal_error "only absolute run-paths are allowed"
+	  ;;
+	esac
+	case "$xrpath " in
+	*" $dir "*) ;;
+	*) func_append xrpath " $dir" ;;
+	esac
+	continue
+	;;
+
+      -shared)
+	# The effects of -shared are defined in a previous loop.
+	continue
+	;;
+
+      -shrext)
+	prev=shrext
+	continue
+	;;
+
+      -static | -static-libtool-libs)
+	# The effects of -static are defined in a previous loop.
+	# We used to do the same as -all-static on platforms that
+	# didn't have a PIC flag, but the assumption that the effects
+	# would be equivalent was wrong.  It would break on at least
+	# Digital Unix and AIX.
+	continue
+	;;
+
+      -thread-safe)
+	thread_safe=yes
+	continue
+	;;
+
+      -version-info)
+	prev=vinfo
+	continue
+	;;
+
+      -version-number)
+	prev=vinfo
+	vinfo_number=yes
+	continue
+	;;
+
+      -weak)
+        prev=weak
+	continue
+	;;
+
+      -Wc,*)
+	func_stripname '-Wc,' '' "$arg"
+	args=$func_stripname_result
+	arg=
+	save_ifs=$IFS; IFS=,
+	for flag in $args; do
+	  IFS=$save_ifs
+          func_quote_for_eval "$flag"
+	  func_append arg " $func_quote_for_eval_result"
+	  func_append compiler_flags " $func_quote_for_eval_result"
+	done
+	IFS=$save_ifs
+	func_stripname ' ' '' "$arg"
+	arg=$func_stripname_result
+	;;
+
+      -Wl,*)
+	func_stripname '-Wl,' '' "$arg"
+	args=$func_stripname_result
+	arg=
+	save_ifs=$IFS; IFS=,
+	for flag in $args; do
+	  IFS=$save_ifs
+          func_quote_for_eval "$flag"
+	  func_append arg " $wl$func_quote_for_eval_result"
+	  func_append compiler_flags " $wl$func_quote_for_eval_result"
+	  func_append linker_flags " $func_quote_for_eval_result"
+	done
+	IFS=$save_ifs
+	func_stripname ' ' '' "$arg"
+	arg=$func_stripname_result
+	;;
+
+      -Xcompiler)
+	prev=xcompiler
+	continue
+	;;
+
+      -Xlinker)
+	prev=xlinker
+	continue
+	;;
+
+      -XCClinker)
+	prev=xcclinker
+	continue
+	;;
+
+      # -msg_* for osf cc
+      -msg_*)
+	func_quote_for_eval "$arg"
+	arg=$func_quote_for_eval_result
+	;;
+
+      # Flags to be passed through unchanged, with rationale:
+      # -64, -mips[0-9]      enable 64-bit mode for the SGI compiler
+      # -r[0-9][0-9]*        specify processor for the SGI compiler
+      # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
+      # +DA*, +DD*           enable 64-bit mode for the HP compiler
+      # -q*                  compiler args for the IBM compiler
+      # -m*, -t[45]*, -txscale* architecture-specific flags for GCC
+      # -F/path              path to uninstalled frameworks, gcc on darwin
+      # -p, -pg, --coverage, -fprofile-*  profiling flags for GCC
+      # -fstack-protector*   stack protector flags for GCC
+      # @file                GCC response files
+      # -tp=*                Portland pgcc target processor selection
+      # --sysroot=*          for sysroot support
+      # -O*, -g*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
+      # -stdlib=*            select c++ std lib with clang
+      -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
+      -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
+      -O*|-g*|-flto*|-fwhopr*|-fuse-linker-plugin|-fstack-protector*|-stdlib=*)
+        func_quote_for_eval "$arg"
+	arg=$func_quote_for_eval_result
+        func_append compile_command " $arg"
+        func_append finalize_command " $arg"
+        func_append compiler_flags " $arg"
+        continue
+        ;;
+
+      -Z*)
+        if test os2 = "`expr $host : '.*\(os2\)'`"; then
+          # OS/2 uses -Zxxx to specify OS/2-specific options
+	  compiler_flags="$compiler_flags $arg"
+	  func_append compile_command " $arg"
+	  func_append finalize_command " $arg"
+	  case $arg in
+	  -Zlinker | -Zstack)
+	    prev=xcompiler
+	    ;;
+	  esac
+	  continue
+        else
+	  # Otherwise treat like 'Some other compiler flag' below
+	  func_quote_for_eval "$arg"
+	  arg=$func_quote_for_eval_result
+        fi
+	;;
+
+      # Some other compiler flag.
+      -* | +*)
+        func_quote_for_eval "$arg"
+	arg=$func_quote_for_eval_result
+	;;
+
+      *.$objext)
+	# A standard object.
+	func_append objs " $arg"
+	;;
+
+      *.lo)
+	# A libtool-controlled object.
+
+	# Check to see that this really is a libtool object.
+	if func_lalib_unsafe_p "$arg"; then
+	  pic_object=
+	  non_pic_object=
+
+	  # Read the .lo file
+	  func_source "$arg"
+
+	  if test -z "$pic_object" ||
+	     test -z "$non_pic_object" ||
+	     test none = "$pic_object" &&
+	     test none = "$non_pic_object"; then
+	    func_fatal_error "cannot find name of object for '$arg'"
+	  fi
+
+	  # Extract subdirectory from the argument.
+	  func_dirname "$arg" "/" ""
+	  xdir=$func_dirname_result
+
+	  test none = "$pic_object" || {
+	    # Prepend the subdirectory the object is found in.
+	    pic_object=$xdir$pic_object
+
+	    if test dlfiles = "$prev"; then
+	      if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; then
+		func_append dlfiles " $pic_object"
+		prev=
+		continue
+	      else
+		# If libtool objects are unsupported, then we need to preload.
+		prev=dlprefiles
+	      fi
+	    fi
+
+	    # CHECK ME:  I think I busted this.  -Ossama
+	    if test dlprefiles = "$prev"; then
+	      # Preload the old-style object.
+	      func_append dlprefiles " $pic_object"
+	      prev=
+	    fi
+
+	    # A PIC object.
+	    func_append libobjs " $pic_object"
+	    arg=$pic_object
+	  }
+
+	  # Non-PIC object.
+	  if test none != "$non_pic_object"; then
+	    # Prepend the subdirectory the object is found in.
+	    non_pic_object=$xdir$non_pic_object
+
+	    # A standard non-PIC object
+	    func_append non_pic_objects " $non_pic_object"
+	    if test -z "$pic_object" || test none = "$pic_object"; then
+	      arg=$non_pic_object
+	    fi
+	  else
+	    # If the PIC object exists, use it instead.
+	    # $xdir was prepended to $pic_object above.
+	    non_pic_object=$pic_object
+	    func_append non_pic_objects " $non_pic_object"
+	  fi
+	else
+	  # Only an error if not doing a dry-run.
+	  if $opt_dry_run; then
+	    # Extract subdirectory from the argument.
+	    func_dirname "$arg" "/" ""
+	    xdir=$func_dirname_result
+
+	    func_lo2o "$arg"
+	    pic_object=$xdir$objdir/$func_lo2o_result
+	    non_pic_object=$xdir$func_lo2o_result
+	    func_append libobjs " $pic_object"
+	    func_append non_pic_objects " $non_pic_object"
+	  else
+	    func_fatal_error "'$arg' is not a valid libtool object"
+	  fi
+	fi
+	;;
+
+      *.$libext)
+	# An archive.
+	func_append deplibs " $arg"
+	func_append old_deplibs " $arg"
+	continue
+	;;
+
+      *.la)
+	# A libtool-controlled library.
+
+	func_resolve_sysroot "$arg"
+	if test dlfiles = "$prev"; then
+	  # This library was specified with -dlopen.
+	  func_append dlfiles " $func_resolve_sysroot_result"
+	  prev=
+	elif test dlprefiles = "$prev"; then
+	  # The library was specified with -dlpreopen.
+	  func_append dlprefiles " $func_resolve_sysroot_result"
+	  prev=
+	else
+	  func_append deplibs " $func_resolve_sysroot_result"
+	fi
+	continue
+	;;
+
+      # Some other compiler argument.
+      *)
+	# Unknown arguments in both finalize_command and compile_command need
+	# to be aesthetically quoted because they are evaled later.
+	func_quote_for_eval "$arg"
+	arg=$func_quote_for_eval_result
+	;;
+      esac # arg
+
+      # Now actually substitute the argument into the commands.
+      if test -n "$arg"; then
+	func_append compile_command " $arg"
+	func_append finalize_command " $arg"
+      fi
+    done # argument parsing loop
+
+    test -n "$prev" && \
+      func_fatal_help "the '$prevarg' option requires an argument"
+
+    if test yes = "$export_dynamic" && test -n "$export_dynamic_flag_spec"; then
+      eval arg=\"$export_dynamic_flag_spec\"
+      func_append compile_command " $arg"
+      func_append finalize_command " $arg"
+    fi
+
+    oldlibs=
+    # calculate the name of the file, without its directory
+    func_basename "$output"
+    outputname=$func_basename_result
+    libobjs_save=$libobjs
+
+    if test -n "$shlibpath_var"; then
+      # get the directories listed in $shlibpath_var
+      eval shlib_search_path=\`\$ECHO \"\$$shlibpath_var\" \| \$SED \'s/:/ /g\'\`
+    else
+      shlib_search_path=
+    fi
+    eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
+    eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
+
+    # Definition is injected by LT_CONFIG during libtool generation.
+    func_munge_path_list sys_lib_dlsearch_path "$LT_SYS_LIBRARY_PATH"
+
+    func_dirname "$output" "/" ""
+    output_objdir=$func_dirname_result$objdir
+    func_to_tool_file "$output_objdir/"
+    tool_output_objdir=$func_to_tool_file_result
+    # Create the object directory.
+    func_mkdir_p "$output_objdir"
+
+    # Determine the type of output
+    case $output in
+    "")
+      func_fatal_help "you must specify an output file"
+      ;;
+    *.$libext) linkmode=oldlib ;;
+    *.lo | *.$objext) linkmode=obj ;;
+    *.la) linkmode=lib ;;
+    *) linkmode=prog ;; # Anything else should be a program.
+    esac
+
+    specialdeplibs=
+
+    libs=
+    # Find all interdependent deplibs by searching for libraries
+    # that are linked more than once (e.g. -la -lb -la)
+    for deplib in $deplibs; do
+      if $opt_preserve_dup_deps; then
+	case "$libs " in
+	*" $deplib "*) func_append specialdeplibs " $deplib" ;;
+	esac
+      fi
+      func_append libs " $deplib"
+    done
+
+    if test lib = "$linkmode"; then
+      libs="$predeps $libs $compiler_lib_search_path $postdeps"
+
+      # Compute libraries that are listed more than once in $predeps
+      # $postdeps and mark them as special (i.e., whose duplicates are
+      # not to be eliminated).
+      pre_post_deps=
+      if $opt_duplicate_compiler_generated_deps; then
+	for pre_post_dep in $predeps $postdeps; do
+	  case "$pre_post_deps " in
+	  *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
+	  esac
+	  func_append pre_post_deps " $pre_post_dep"
+	done
+      fi
+      pre_post_deps=
+    fi
+
+    deplibs=
+    newdependency_libs=
+    newlib_search_path=
+    need_relink=no # whether we're linking any uninstalled libtool libraries
+    notinst_deplibs= # not-installed libtool libraries
+    notinst_path= # paths that contain not-installed libtool libraries
+
+    case $linkmode in
+    lib)
+	passes="conv dlpreopen link"
+	for file in $dlfiles $dlprefiles; do
+	  case $file in
+	  *.la) ;;
+	  *)
+	    func_fatal_help "libraries can '-dlopen' only libtool libraries: $file"
+	    ;;
+	  esac
+	done
+	;;
+    prog)
+	compile_deplibs=
+	finalize_deplibs=
+	alldeplibs=false
+	newdlfiles=
+	newdlprefiles=
+	passes="conv scan dlopen dlpreopen link"
+	;;
+    *)  passes="conv"
+	;;
+    esac
+
+    for pass in $passes; do
+      # The preopen pass in lib mode reverses $deplibs; put it back here
+      # so that -L comes before libs that need it for instance...
+      if test lib,link = "$linkmode,$pass"; then
+	## FIXME: Find the place where the list is rebuilt in the wrong
+	##        order, and fix it there properly
+        tmp_deplibs=
+	for deplib in $deplibs; do
+	  tmp_deplibs="$deplib $tmp_deplibs"
+	done
+	deplibs=$tmp_deplibs
+      fi
+
+      if test lib,link = "$linkmode,$pass" ||
+	 test prog,scan = "$linkmode,$pass"; then
+	libs=$deplibs
+	deplibs=
+      fi
+      if test prog = "$linkmode"; then
+	case $pass in
+	dlopen) libs=$dlfiles ;;
+	dlpreopen) libs=$dlprefiles ;;
+	link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
+	esac
+      fi
+      if test lib,dlpreopen = "$linkmode,$pass"; then
+	# Collect and forward deplibs of preopened libtool libs
+	for lib in $dlprefiles; do
+	  # Ignore non-libtool-libs
+	  dependency_libs=
+	  func_resolve_sysroot "$lib"
+	  case $lib in
+	  *.la)	func_source "$func_resolve_sysroot_result" ;;
+	  esac
+
+	  # Collect preopened libtool deplibs, except any this library
+	  # has declared as weak libs
+	  for deplib in $dependency_libs; do
+	    func_basename "$deplib"
+            deplib_base=$func_basename_result
+	    case " $weak_libs " in
+	    *" $deplib_base "*) ;;
+	    *) func_append deplibs " $deplib" ;;
+	    esac
+	  done
+	done
+	libs=$dlprefiles
+      fi
+      if test dlopen = "$pass"; then
+	# Collect dlpreopened libraries
+	save_deplibs=$deplibs
+	deplibs=
+      fi
+
+      for deplib in $libs; do
+	lib=
+	found=false
+	case $deplib in
+	-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
+        |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
+	  if test prog,link = "$linkmode,$pass"; then
+	    compile_deplibs="$deplib $compile_deplibs"
+	    finalize_deplibs="$deplib $finalize_deplibs"
+	  else
+	    func_append compiler_flags " $deplib"
+	    if test lib = "$linkmode"; then
+		case "$new_inherited_linker_flags " in
+		    *" $deplib "*) ;;
+		    * ) func_append new_inherited_linker_flags " $deplib" ;;
+		esac
+	    fi
+	  fi
+	  continue
+	  ;;
+	-l*)
+	  if test lib != "$linkmode" && test prog != "$linkmode"; then
+	    func_warning "'-l' is ignored for archives/objects"
+	    continue
+	  fi
+	  func_stripname '-l' '' "$deplib"
+	  name=$func_stripname_result
+	  if test lib = "$linkmode"; then
+	    searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
+	  else
+	    searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
+	  fi
+	  for searchdir in $searchdirs; do
+	    for search_ext in .la $std_shrext .so .a; do
+	      # Search the libtool library
+	      lib=$searchdir/lib$name$search_ext
+	      if test -f "$lib"; then
+		if test .la = "$search_ext"; then
+		  found=:
+		else
+		  found=false
+		fi
+		break 2
+	      fi
+	    done
+	  done
+	  if $found; then
+	    # deplib is a libtool library
+	    # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
+	    # We need to do some special things here, and not later.
+	    if test yes = "$allow_libtool_libs_with_static_runtimes"; then
+	      case " $predeps $postdeps " in
+	      *" $deplib "*)
+		if func_lalib_p "$lib"; then
+		  library_names=
+		  old_library=
+		  func_source "$lib"
+		  for l in $old_library $library_names; do
+		    ll=$l
+		  done
+		  if test "X$ll" = "X$old_library"; then # only static version available
+		    found=false
+		    func_dirname "$lib" "" "."
+		    ladir=$func_dirname_result
+		    lib=$ladir/$old_library
+		    if test prog,link = "$linkmode,$pass"; then
+		      compile_deplibs="$deplib $compile_deplibs"
+		      finalize_deplibs="$deplib $finalize_deplibs"
+		    else
+		      deplibs="$deplib $deplibs"
+		      test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs"
+		    fi
+		    continue
+		  fi
+		fi
+		;;
+	      *) ;;
+	      esac
+	    fi
+	  else
+	    # deplib doesn't seem to be a libtool library
+	    if test prog,link = "$linkmode,$pass"; then
+	      compile_deplibs="$deplib $compile_deplibs"
+	      finalize_deplibs="$deplib $finalize_deplibs"
+	    else
+	      deplibs="$deplib $deplibs"
+	      test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs"
+	    fi
+	    continue
+	  fi
+	  ;; # -l
+	*.ltframework)
+	  if test prog,link = "$linkmode,$pass"; then
+	    compile_deplibs="$deplib $compile_deplibs"
+	    finalize_deplibs="$deplib $finalize_deplibs"
+	  else
+	    deplibs="$deplib $deplibs"
+	    if test lib = "$linkmode"; then
+		case "$new_inherited_linker_flags " in
+		    *" $deplib "*) ;;
+		    * ) func_append new_inherited_linker_flags " $deplib" ;;
+		esac
+	    fi
+	  fi
+	  continue
+	  ;;
+	-L*)
+	  case $linkmode in
+	  lib)
+	    deplibs="$deplib $deplibs"
+	    test conv = "$pass" && continue
+	    newdependency_libs="$deplib $newdependency_libs"
+	    func_stripname '-L' '' "$deplib"
+	    func_resolve_sysroot "$func_stripname_result"
+	    func_append newlib_search_path " $func_resolve_sysroot_result"
+	    ;;
+	  prog)
+	    if test conv = "$pass"; then
+	      deplibs="$deplib $deplibs"
+	      continue
+	    fi
+	    if test scan = "$pass"; then
+	      deplibs="$deplib $deplibs"
+	    else
+	      compile_deplibs="$deplib $compile_deplibs"
+	      finalize_deplibs="$deplib $finalize_deplibs"
+	    fi
+	    func_stripname '-L' '' "$deplib"
+	    func_resolve_sysroot "$func_stripname_result"
+	    func_append newlib_search_path " $func_resolve_sysroot_result"
+	    ;;
+	  *)
+	    func_warning "'-L' is ignored for archives/objects"
+	    ;;
+	  esac # linkmode
+	  continue
+	  ;; # -L
+	-R*)
+	  if test link = "$pass"; then
+	    func_stripname '-R' '' "$deplib"
+	    func_resolve_sysroot "$func_stripname_result"
+	    dir=$func_resolve_sysroot_result
+	    # Make sure the xrpath contains only unique directories.
+	    case "$xrpath " in
+	    *" $dir "*) ;;
+	    *) func_append xrpath " $dir" ;;
+	    esac
+	  fi
+	  deplibs="$deplib $deplibs"
+	  continue
+	  ;;
+	*.la)
+	  func_resolve_sysroot "$deplib"
+	  lib=$func_resolve_sysroot_result
+	  ;;
+	*.$libext)
+	  if test conv = "$pass"; then
+	    deplibs="$deplib $deplibs"
+	    continue
+	  fi
+	  case $linkmode in
+	  lib)
+	    # Linking convenience modules into shared libraries is allowed,
+	    # but linking other static libraries is non-portable.
+	    case " $dlpreconveniencelibs " in
+	    *" $deplib "*) ;;
+	    *)
+	      valid_a_lib=false
+	      case $deplibs_check_method in
+		match_pattern*)
+		  set dummy $deplibs_check_method; shift
+		  match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
+		  if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
+		    | $EGREP "$match_pattern_regex" > /dev/null; then
+		    valid_a_lib=:
+		  fi
+		;;
+		pass_all)
+		  valid_a_lib=:
+		;;
+	      esac
+	      if $valid_a_lib; then
+		echo
+		$ECHO "*** Warning: Linking the shared library $output against the"
+		$ECHO "*** static library $deplib is not portable!"
+		deplibs="$deplib $deplibs"
+	      else
+		echo
+		$ECHO "*** Warning: Trying to link with static lib archive $deplib."
+		echo "*** I have the capability to make that library automatically link in when"
+		echo "*** you link to this library.  But I can only do this if you have a"
+		echo "*** shared version of the library, which you do not appear to have"
+		echo "*** because the file extensions .$libext of this argument makes me believe"
+		echo "*** that it is just a static archive that I should not use here."
+	      fi
+	      ;;
+	    esac
+	    continue
+	    ;;
+	  prog)
+	    if test link != "$pass"; then
+	      deplibs="$deplib $deplibs"
+	    else
+	      compile_deplibs="$deplib $compile_deplibs"
+	      finalize_deplibs="$deplib $finalize_deplibs"
+	    fi
+	    continue
+	    ;;
+	  esac # linkmode
+	  ;; # *.$libext
+	*.lo | *.$objext)
+	  if test conv = "$pass"; then
+	    deplibs="$deplib $deplibs"
+	  elif test prog = "$linkmode"; then
+	    if test dlpreopen = "$pass" || test yes != "$dlopen_support" || test no = "$build_libtool_libs"; then
+	      # If there is no dlopen support or we're linking statically,
+	      # we need to preload.
+	      func_append newdlprefiles " $deplib"
+	      compile_deplibs="$deplib $compile_deplibs"
+	      finalize_deplibs="$deplib $finalize_deplibs"
+	    else
+	      func_append newdlfiles " $deplib"
+	    fi
+	  fi
+	  continue
+	  ;;
+	%DEPLIBS%)
+	  alldeplibs=:
+	  continue
+	  ;;
+	esac # case $deplib
+
+	$found || test -f "$lib" \
+	  || func_fatal_error "cannot find the library '$lib' or unhandled argument '$deplib'"
+
+	# Check to see that this really is a libtool archive.
+	func_lalib_unsafe_p "$lib" \
+	  || func_fatal_error "'$lib' is not a valid libtool archive"
+
+	func_dirname "$lib" "" "."
+	ladir=$func_dirname_result
+
+	dlname=
+	dlopen=
+	dlpreopen=
+	libdir=
+	library_names=
+	old_library=
+	inherited_linker_flags=
+	# If the library was installed with an old release of libtool,
+	# it will not redefine variables installed, or shouldnotlink
+	installed=yes
+	shouldnotlink=no
+	avoidtemprpath=
+
+
+	# Read the .la file
+	func_source "$lib"
+
+	# Convert "-framework foo" to "foo.ltframework"
+	if test -n "$inherited_linker_flags"; then
+	  tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
+	  for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
+	    case " $new_inherited_linker_flags " in
+	      *" $tmp_inherited_linker_flag "*) ;;
+	      *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
+	    esac
+	  done
+	fi
+	dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
+	if test lib,link = "$linkmode,$pass" ||
+	   test prog,scan = "$linkmode,$pass" ||
+	   { test prog != "$linkmode" && test lib != "$linkmode"; }; then
+	  test -n "$dlopen" && func_append dlfiles " $dlopen"
+	  test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
+	fi
+
+	if test conv = "$pass"; then
+	  # Only check for convenience libraries
+	  deplibs="$lib $deplibs"
+	  if test -z "$libdir"; then
+	    if test -z "$old_library"; then
+	      func_fatal_error "cannot find name of link library for '$lib'"
+	    fi
+	    # It is a libtool convenience library, so add in its objects.
+	    func_append convenience " $ladir/$objdir/$old_library"
+	    func_append old_convenience " $ladir/$objdir/$old_library"
+	  elif test prog != "$linkmode" && test lib != "$linkmode"; then
+	    func_fatal_error "'$lib' is not a convenience library"
+	  fi
+	  tmp_libs=
+	  for deplib in $dependency_libs; do
+	    deplibs="$deplib $deplibs"
+	    if $opt_preserve_dup_deps; then
+	      case "$tmp_libs " in
+	      *" $deplib "*) func_append specialdeplibs " $deplib" ;;
+	      esac
+	    fi
+	    func_append tmp_libs " $deplib"
+	  done
+	  continue
+	fi # $pass = conv
+
+
+	# Get the name of the library we link against.
+	linklib=
+	if test -n "$old_library" &&
+	   { test yes = "$prefer_static_libs" ||
+	     test built,no = "$prefer_static_libs,$installed"; }; then
+	  linklib=$old_library
+	else
+	  for l in $old_library $library_names; do
+	    linklib=$l
+	  done
+	fi
+	if test -z "$linklib"; then
+	  func_fatal_error "cannot find name of link library for '$lib'"
+	fi
+
+	# This library was specified with -dlopen.
+	if test dlopen = "$pass"; then
+	  test -z "$libdir" \
+	    && func_fatal_error "cannot -dlopen a convenience library: '$lib'"
+	  if test -z "$dlname" ||
+	     test yes != "$dlopen_support" ||
+	     test no = "$build_libtool_libs"
+	  then
+	    # If there is no dlname, no dlopen support or we're linking
+	    # statically, we need to preload.  We also need to preload any
+	    # dependent libraries so libltdl's deplib preloader doesn't
+	    # bomb out in the load deplibs phase.
+	    func_append dlprefiles " $lib $dependency_libs"
+	  else
+	    func_append newdlfiles " $lib"
+	  fi
+	  continue
+	fi # $pass = dlopen
+
+	# We need an absolute path.
+	case $ladir in
+	[\\/]* | [A-Za-z]:[\\/]*) abs_ladir=$ladir ;;
+	*)
+	  abs_ladir=`cd "$ladir" && pwd`
+	  if test -z "$abs_ladir"; then
+	    func_warning "cannot determine absolute directory name of '$ladir'"
+	    func_warning "passing it literally to the linker, although it might fail"
+	    abs_ladir=$ladir
+	  fi
+	  ;;
+	esac
+	func_basename "$lib"
+	laname=$func_basename_result
+
+	# Find the relevant object directory and library name.
+	if test yes = "$installed"; then
+	  if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
+	    func_warning "library '$lib' was moved."
+	    dir=$ladir
+	    absdir=$abs_ladir
+	    libdir=$abs_ladir
+	  else
+	    dir=$lt_sysroot$libdir
+	    absdir=$lt_sysroot$libdir
+	  fi
+	  test yes = "$hardcode_automatic" && avoidtemprpath=yes
+	else
+	  if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
+	    dir=$ladir
+	    absdir=$abs_ladir
+	    # Remove this search path later
+	    func_append notinst_path " $abs_ladir"
+	  else
+	    dir=$ladir/$objdir
+	    absdir=$abs_ladir/$objdir
+	    # Remove this search path later
+	    func_append notinst_path " $abs_ladir"
+	  fi
+	fi # $installed = yes
+	func_stripname 'lib' '.la' "$laname"
+	name=$func_stripname_result
+
+	# This library was specified with -dlpreopen.
+	if test dlpreopen = "$pass"; then
+	  if test -z "$libdir" && test prog = "$linkmode"; then
+	    func_fatal_error "only libraries may -dlpreopen a convenience library: '$lib'"
+	  fi
+	  case $host in
+	    # special handling for platforms with PE-DLLs.
+	    *cygwin* | *mingw* | *cegcc* )
+	      # Linker will automatically link against shared library if both
+	      # static and shared are present.  Therefore, ensure we extract
+	      # symbols from the import library if a shared library is present
+	      # (otherwise, the dlopen module name will be incorrect).  We do
+	      # this by putting the import library name into $newdlprefiles.
+	      # We recover the dlopen module name by 'saving' the la file
+	      # name in a special purpose variable, and (later) extracting the
+	      # dlname from the la file.
+	      if test -n "$dlname"; then
+	        func_tr_sh "$dir/$linklib"
+	        eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
+	        func_append newdlprefiles " $dir/$linklib"
+	      else
+	        func_append newdlprefiles " $dir/$old_library"
+	        # Keep a list of preopened convenience libraries to check
+	        # that they are being used correctly in the link pass.
+	        test -z "$libdir" && \
+	          func_append dlpreconveniencelibs " $dir/$old_library"
+	      fi
+	    ;;
+	    * )
+	      # Prefer using a static library (so that no silly _DYNAMIC symbols
+	      # are required to link).
+	      if test -n "$old_library"; then
+	        func_append newdlprefiles " $dir/$old_library"
+	        # Keep a list of preopened convenience libraries to check
+	        # that they are being used correctly in the link pass.
+	        test -z "$libdir" && \
+	          func_append dlpreconveniencelibs " $dir/$old_library"
+	      # Otherwise, use the dlname, so that lt_dlopen finds it.
+	      elif test -n "$dlname"; then
+	        func_append newdlprefiles " $dir/$dlname"
+	      else
+	        func_append newdlprefiles " $dir/$linklib"
+	      fi
+	    ;;
+	  esac
+	fi # $pass = dlpreopen
+
+	if test -z "$libdir"; then
+	  # Link the convenience library
+	  if test lib = "$linkmode"; then
+	    deplibs="$dir/$old_library $deplibs"
+	  elif test prog,link = "$linkmode,$pass"; then
+	    compile_deplibs="$dir/$old_library $compile_deplibs"
+	    finalize_deplibs="$dir/$old_library $finalize_deplibs"
+	  else
+	    deplibs="$lib $deplibs" # used for prog,scan pass
+	  fi
+	  continue
+	fi
+
+
+	if test prog = "$linkmode" && test link != "$pass"; then
+	  func_append newlib_search_path " $ladir"
+	  deplibs="$lib $deplibs"
+
+	  linkalldeplibs=false
+	  if test no != "$link_all_deplibs" || test -z "$library_names" ||
+	     test no = "$build_libtool_libs"; then
+	    linkalldeplibs=:
+	  fi
+
+	  tmp_libs=
+	  for deplib in $dependency_libs; do
+	    case $deplib in
+	    -L*) func_stripname '-L' '' "$deplib"
+	         func_resolve_sysroot "$func_stripname_result"
+	         func_append newlib_search_path " $func_resolve_sysroot_result"
+		 ;;
+	    esac
+	    # Need to link against all dependency_libs?
+	    if $linkalldeplibs; then
+	      deplibs="$deplib $deplibs"
+	    else
+	      # Need to hardcode shared library paths
+	      # or/and link against static libraries
+	      newdependency_libs="$deplib $newdependency_libs"
+	    fi
+	    if $opt_preserve_dup_deps; then
+	      case "$tmp_libs " in
+	      *" $deplib "*) func_append specialdeplibs " $deplib" ;;
+	      esac
+	    fi
+	    func_append tmp_libs " $deplib"
+	  done # for deplib
+	  continue
+	fi # $linkmode = prog...
+
+	if test prog,link = "$linkmode,$pass"; then
+	  if test -n "$library_names" &&
+	     { { test no = "$prefer_static_libs" ||
+	         test built,yes = "$prefer_static_libs,$installed"; } ||
+	       test -z "$old_library"; }; then
+	    # We need to hardcode the library path
+	    if test -n "$shlibpath_var" && test -z "$avoidtemprpath"; then
+	      # Make sure the rpath contains only unique directories.
+	      case $temp_rpath: in
+	      *"$absdir:"*) ;;
+	      *) func_append temp_rpath "$absdir:" ;;
+	      esac
+	    fi
+
+	    # Hardcode the library path.
+	    # Skip directories that are in the system default run-time
+	    # search path.
+	    case " $sys_lib_dlsearch_path " in
+	    *" $absdir "*) ;;
+	    *)
+	      case "$compile_rpath " in
+	      *" $absdir "*) ;;
+	      *) func_append compile_rpath " $absdir" ;;
+	      esac
+	      ;;
+	    esac
+	    case " $sys_lib_dlsearch_path " in
+	    *" $libdir "*) ;;
+	    *)
+	      case "$finalize_rpath " in
+	      *" $libdir "*) ;;
+	      *) func_append finalize_rpath " $libdir" ;;
+	      esac
+	      ;;
+	    esac
+	  fi # $linkmode,$pass = prog,link...
+
+	  if $alldeplibs &&
+	     { test pass_all = "$deplibs_check_method" ||
+	       { test yes = "$build_libtool_libs" &&
+		 test -n "$library_names"; }; }; then
+	    # We only need to search for static libraries
+	    continue
+	  fi
+	fi
+
+	link_static=no # Whether the deplib will be linked statically
+	use_static_libs=$prefer_static_libs
+	if test built = "$use_static_libs" && test yes = "$installed"; then
+	  use_static_libs=no
+	fi
+	if test -n "$library_names" &&
+	   { test no = "$use_static_libs" || test -z "$old_library"; }; then
+	  case $host in
+	  *cygwin* | *mingw* | *cegcc* | *os2*)
+	      # No point in relinking DLLs because paths are not encoded
+	      func_append notinst_deplibs " $lib"
+	      need_relink=no
+	    ;;
+	  *)
+	    if test no = "$installed"; then
+	      func_append notinst_deplibs " $lib"
+	      need_relink=yes
+	    fi
+	    ;;
+	  esac
+	  # This is a shared library
+
+	  # Warn about portability, can't link against -module's on some
+	  # systems (darwin).  Don't bleat about dlopened modules though!
+	  dlopenmodule=
+	  for dlpremoduletest in $dlprefiles; do
+	    if test "X$dlpremoduletest" = "X$lib"; then
+	      dlopenmodule=$dlpremoduletest
+	      break
+	    fi
+	  done
+	  if test -z "$dlopenmodule" && test yes = "$shouldnotlink" && test link = "$pass"; then
+	    echo
+	    if test prog = "$linkmode"; then
+	      $ECHO "*** Warning: Linking the executable $output against the loadable module"
+	    else
+	      $ECHO "*** Warning: Linking the shared library $output against the loadable module"
+	    fi
+	    $ECHO "*** $linklib is not portable!"
+	  fi
+	  if test lib = "$linkmode" &&
+	     test yes = "$hardcode_into_libs"; then
+	    # Hardcode the library path.
+	    # Skip directories that are in the system default run-time
+	    # search path.
+	    case " $sys_lib_dlsearch_path " in
+	    *" $absdir "*) ;;
+	    *)
+	      case "$compile_rpath " in
+	      *" $absdir "*) ;;
+	      *) func_append compile_rpath " $absdir" ;;
+	      esac
+	      ;;
+	    esac
+	    case " $sys_lib_dlsearch_path " in
+	    *" $libdir "*) ;;
+	    *)
+	      case "$finalize_rpath " in
+	      *" $libdir "*) ;;
+	      *) func_append finalize_rpath " $libdir" ;;
+	      esac
+	      ;;
+	    esac
+	  fi
+
+	  if test -n "$old_archive_from_expsyms_cmds"; then
+	    # figure out the soname
+	    set dummy $library_names
+	    shift
+	    realname=$1
+	    shift
+	    libname=`eval "\\$ECHO \"$libname_spec\""`
+	    # use dlname if we got it. it's perfectly good, no?
+	    if test -n "$dlname"; then
+	      soname=$dlname
+	    elif test -n "$soname_spec"; then
+	      # bleh windows
+	      case $host in
+	      *cygwin* | mingw* | *cegcc* | *os2*)
+	        func_arith $current - $age
+		major=$func_arith_result
+		versuffix=-$major
+		;;
+	      esac
+	      eval soname=\"$soname_spec\"
+	    else
+	      soname=$realname
+	    fi
+
+	    # Make a new name for the extract_expsyms_cmds to use
+	    soroot=$soname
+	    func_basename "$soroot"
+	    soname=$func_basename_result
+	    func_stripname 'lib' '.dll' "$soname"
+	    newlib=libimp-$func_stripname_result.a
+
+	    # If the library has no export list, then create one now
+	    if test -f "$output_objdir/$soname-def"; then :
+	    else
+	      func_verbose "extracting exported symbol list from '$soname'"
+	      func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
+	    fi
+
+	    # Create $newlib
+	    if test -f "$output_objdir/$newlib"; then :; else
+	      func_verbose "generating import library for '$soname'"
+	      func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
+	    fi
+	    # make sure the library variables are pointing to the new library
+	    dir=$output_objdir
+	    linklib=$newlib
+	  fi # test -n "$old_archive_from_expsyms_cmds"
+
+	  if test prog = "$linkmode" || test relink != "$opt_mode"; then
+	    add_shlibpath=
+	    add_dir=
+	    add=
+	    lib_linked=yes
+	    case $hardcode_action in
+	    immediate | unsupported)
+	      if test no = "$hardcode_direct"; then
+		add=$dir/$linklib
+		case $host in
+		  *-*-sco3.2v5.0.[024]*) add_dir=-L$dir ;;
+		  *-*-sysv4*uw2*) add_dir=-L$dir ;;
+		  *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
+		    *-*-unixware7*) add_dir=-L$dir ;;
+		  *-*-darwin* )
+		    # if the lib is a (non-dlopened) module then we cannot
+		    # link against it, someone is ignoring the earlier warnings
+		    if /usr/bin/file -L $add 2> /dev/null |
+			 $GREP ": [^:]* bundle" >/dev/null; then
+		      if test "X$dlopenmodule" != "X$lib"; then
+			$ECHO "*** Warning: lib $linklib is a module, not a shared library"
+			if test -z "$old_library"; then
+			  echo
+			  echo "*** And there doesn't seem to be a static archive available"
+			  echo "*** The link will probably fail, sorry"
+			else
+			  add=$dir/$old_library
+			fi
+		      elif test -n "$old_library"; then
+			add=$dir/$old_library
+		      fi
+		    fi
+		esac
+	      elif test no = "$hardcode_minus_L"; then
+		case $host in
+		*-*-sunos*) add_shlibpath=$dir ;;
+		esac
+		add_dir=-L$dir
+		add=-l$name
+	      elif test no = "$hardcode_shlibpath_var"; then
+		add_shlibpath=$dir
+		add=-l$name
+	      else
+		lib_linked=no
+	      fi
+	      ;;
+	    relink)
+	      if test yes = "$hardcode_direct" &&
+	         test no = "$hardcode_direct_absolute"; then
+		add=$dir/$linklib
+	      elif test yes = "$hardcode_minus_L"; then
+		add_dir=-L$absdir
+		# Try looking first in the location we're being installed to.
+		if test -n "$inst_prefix_dir"; then
+		  case $libdir in
+		    [\\/]*)
+		      func_append add_dir " -L$inst_prefix_dir$libdir"
+		      ;;
+		  esac
+		fi
+		add=-l$name
+	      elif test yes = "$hardcode_shlibpath_var"; then
+		add_shlibpath=$dir
+		add=-l$name
+	      else
+		lib_linked=no
+	      fi
+	      ;;
+	    *) lib_linked=no ;;
+	    esac
+
+	    if test yes != "$lib_linked"; then
+	      func_fatal_configuration "unsupported hardcode properties"
+	    fi
+
+	    if test -n "$add_shlibpath"; then
+	      case :$compile_shlibpath: in
+	      *":$add_shlibpath:"*) ;;
+	      *) func_append compile_shlibpath "$add_shlibpath:" ;;
+	      esac
+	    fi
+	    if test prog = "$linkmode"; then
+	      test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
+	      test -n "$add" && compile_deplibs="$add $compile_deplibs"
+	    else
+	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
+	      test -n "$add" && deplibs="$add $deplibs"
+	      if test yes != "$hardcode_direct" &&
+		 test yes != "$hardcode_minus_L" &&
+		 test yes = "$hardcode_shlibpath_var"; then
+		case :$finalize_shlibpath: in
+		*":$libdir:"*) ;;
+		*) func_append finalize_shlibpath "$libdir:" ;;
+		esac
+	      fi
+	    fi
+	  fi
+
+	  if test prog = "$linkmode" || test relink = "$opt_mode"; then
+	    add_shlibpath=
+	    add_dir=
+	    add=
+	    # Finalize command for both is simple: just hardcode it.
+	    if test yes = "$hardcode_direct" &&
+	       test no = "$hardcode_direct_absolute"; then
+	      add=$libdir/$linklib
+	    elif test yes = "$hardcode_minus_L"; then
+	      add_dir=-L$libdir
+	      add=-l$name
+	    elif test yes = "$hardcode_shlibpath_var"; then
+	      case :$finalize_shlibpath: in
+	      *":$libdir:"*) ;;
+	      *) func_append finalize_shlibpath "$libdir:" ;;
+	      esac
+	      add=-l$name
+	    elif test yes = "$hardcode_automatic"; then
+	      if test -n "$inst_prefix_dir" &&
+		 test -f "$inst_prefix_dir$libdir/$linklib"; then
+		add=$inst_prefix_dir$libdir/$linklib
+	      else
+		add=$libdir/$linklib
+	      fi
+	    else
+	      # We cannot seem to hardcode it, guess we'll fake it.
+	      add_dir=-L$libdir
+	      # Try looking first in the location we're being installed to.
+	      if test -n "$inst_prefix_dir"; then
+		case $libdir in
+		  [\\/]*)
+		    func_append add_dir " -L$inst_prefix_dir$libdir"
+		    ;;
+		esac
+	      fi
+	      add=-l$name
+	    fi
+
+	    if test prog = "$linkmode"; then
+	      test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
+	      test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
+	    else
+	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
+	      test -n "$add" && deplibs="$add $deplibs"
+	    fi
+	  fi
+	elif test prog = "$linkmode"; then
+	  # Here we assume that one of hardcode_direct or hardcode_minus_L
+	  # is not unsupported.  This is valid on all known static and
+	  # shared platforms.
+	  if test unsupported != "$hardcode_direct"; then
+	    test -n "$old_library" && linklib=$old_library
+	    compile_deplibs="$dir/$linklib $compile_deplibs"
+	    finalize_deplibs="$dir/$linklib $finalize_deplibs"
+	  else
+	    compile_deplibs="-l$name -L$dir $compile_deplibs"
+	    finalize_deplibs="-l$name -L$dir $finalize_deplibs"
+	  fi
+	elif test yes = "$build_libtool_libs"; then
+	  # Not a shared library
+	  if test pass_all != "$deplibs_check_method"; then
+	    # We're trying link a shared library against a static one
+	    # but the system doesn't support it.
+
+	    # Just print a warning and add the library to dependency_libs so
+	    # that the program can be linked against the static library.
+	    echo
+	    $ECHO "*** Warning: This system cannot link to static lib archive $lib."
+	    echo "*** I have the capability to make that library automatically link in when"
+	    echo "*** you link to this library.  But I can only do this if you have a"
+	    echo "*** shared version of the library, which you do not appear to have."
+	    if test yes = "$module"; then
+	      echo "*** But as you try to build a module library, libtool will still create "
+	      echo "*** a static module, that should work as long as the dlopening application"
+	      echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
+	      if test -z "$global_symbol_pipe"; then
+		echo
+		echo "*** However, this would only work if libtool was able to extract symbol"
+		echo "*** lists from a program, using 'nm' or equivalent, but libtool could"
+		echo "*** not find such a program.  So, this module is probably useless."
+		echo "*** 'nm' from GNU binutils and a full rebuild may help."
+	      fi
+	      if test no = "$build_old_libs"; then
+		build_libtool_libs=module
+		build_old_libs=yes
+	      else
+		build_libtool_libs=no
+	      fi
+	    fi
+	  else
+	    deplibs="$dir/$old_library $deplibs"
+	    link_static=yes
+	  fi
+	fi # link shared/static library?
+
+	if test lib = "$linkmode"; then
+	  if test -n "$dependency_libs" &&
+	     { test yes != "$hardcode_into_libs" ||
+	       test yes = "$build_old_libs" ||
+	       test yes = "$link_static"; }; then
+	    # Extract -R from dependency_libs
+	    temp_deplibs=
+	    for libdir in $dependency_libs; do
+	      case $libdir in
+	      -R*) func_stripname '-R' '' "$libdir"
+	           temp_xrpath=$func_stripname_result
+		   case " $xrpath " in
+		   *" $temp_xrpath "*) ;;
+		   *) func_append xrpath " $temp_xrpath";;
+		   esac;;
+	      *) func_append temp_deplibs " $libdir";;
+	      esac
+	    done
+	    dependency_libs=$temp_deplibs
+	  fi
+
+	  func_append newlib_search_path " $absdir"
+	  # Link against this library
+	  test no = "$link_static" && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
+	  # ... and its dependency_libs
+	  tmp_libs=
+	  for deplib in $dependency_libs; do
+	    newdependency_libs="$deplib $newdependency_libs"
+	    case $deplib in
+              -L*) func_stripname '-L' '' "$deplib"
+                   func_resolve_sysroot "$func_stripname_result";;
+              *) func_resolve_sysroot "$deplib" ;;
+            esac
+	    if $opt_preserve_dup_deps; then
+	      case "$tmp_libs " in
+	      *" $func_resolve_sysroot_result "*)
+                func_append specialdeplibs " $func_resolve_sysroot_result" ;;
+	      esac
+	    fi
+	    func_append tmp_libs " $func_resolve_sysroot_result"
+	  done
+
+	  if test no != "$link_all_deplibs"; then
+	    # Add the search paths of all dependency libraries
+	    for deplib in $dependency_libs; do
+	      path=
+	      case $deplib in
+	      -L*) path=$deplib ;;
+	      *.la)
+	        func_resolve_sysroot "$deplib"
+	        deplib=$func_resolve_sysroot_result
+	        func_dirname "$deplib" "" "."
+		dir=$func_dirname_result
+		# We need an absolute path.
+		case $dir in
+		[\\/]* | [A-Za-z]:[\\/]*) absdir=$dir ;;
+		*)
+		  absdir=`cd "$dir" && pwd`
+		  if test -z "$absdir"; then
+		    func_warning "cannot determine absolute directory name of '$dir'"
+		    absdir=$dir
+		  fi
+		  ;;
+		esac
+		if $GREP "^installed=no" $deplib > /dev/null; then
+		case $host in
+		*-*-darwin*)
+		  depdepl=
+		  eval deplibrary_names=`$SED -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
+		  if test -n "$deplibrary_names"; then
+		    for tmp in $deplibrary_names; do
+		      depdepl=$tmp
+		    done
+		    if test -f "$absdir/$objdir/$depdepl"; then
+		      depdepl=$absdir/$objdir/$depdepl
+		      darwin_install_name=`$OTOOL -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
+                      if test -z "$darwin_install_name"; then
+                          darwin_install_name=`$OTOOL64 -L $depdepl  | awk '{if (NR == 2) {print $1;exit}}'`
+                      fi
+		      func_append compiler_flags " $wl-dylib_file $wl$darwin_install_name:$depdepl"
+		      func_append linker_flags " -dylib_file $darwin_install_name:$depdepl"
+		      path=
+		    fi
+		  fi
+		  ;;
+		*)
+		  path=-L$absdir/$objdir
+		  ;;
+		esac
+		else
+		  eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
+		  test -z "$libdir" && \
+		    func_fatal_error "'$deplib' is not a valid libtool archive"
+		  test "$absdir" != "$libdir" && \
+		    func_warning "'$deplib' seems to be moved"
+
+		  path=-L$absdir
+		fi
+		;;
+	      esac
+	      case " $deplibs " in
+	      *" $path "*) ;;
+	      *) deplibs="$path $deplibs" ;;
+	      esac
+	    done
+	  fi # link_all_deplibs != no
+	fi # linkmode = lib
+      done # for deplib in $libs
+      if test link = "$pass"; then
+	if test prog = "$linkmode"; then
+	  compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
+	  finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
+	else
+	  compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
+	fi
+      fi
+      dependency_libs=$newdependency_libs
+      if test dlpreopen = "$pass"; then
+	# Link the dlpreopened libraries before other libraries
+	for deplib in $save_deplibs; do
+	  deplibs="$deplib $deplibs"
+	done
+      fi
+      if test dlopen != "$pass"; then
+	test conv = "$pass" || {
+	  # Make sure lib_search_path contains only unique directories.
+	  lib_search_path=
+	  for dir in $newlib_search_path; do
+	    case "$lib_search_path " in
+	    *" $dir "*) ;;
+	    *) func_append lib_search_path " $dir" ;;
+	    esac
+	  done
+	  newlib_search_path=
+	}
+
+	if test prog,link = "$linkmode,$pass"; then
+	  vars="compile_deplibs finalize_deplibs"
+	else
+	  vars=deplibs
+	fi
+	for var in $vars dependency_libs; do
+	  # Add libraries to $var in reverse order
+	  eval tmp_libs=\"\$$var\"
+	  new_libs=
+	  for deplib in $tmp_libs; do
+	    # FIXME: Pedantically, this is the right thing to do, so
+	    #        that some nasty dependency loop isn't accidentally
+	    #        broken:
+	    #new_libs="$deplib $new_libs"
+	    # Pragmatically, this seems to cause very few problems in
+	    # practice:
+	    case $deplib in
+	    -L*) new_libs="$deplib $new_libs" ;;
+	    -R*) ;;
+	    *)
+	      # And here is the reason: when a library appears more
+	      # than once as an explicit dependence of a library, or
+	      # is implicitly linked in more than once by the
+	      # compiler, it is considered special, and multiple
+	      # occurrences thereof are not removed.  Compare this
+	      # with having the same library being listed as a
+	      # dependency of multiple other libraries: in this case,
+	      # we know (pedantically, we assume) the library does not
+	      # need to be listed more than once, so we keep only the
+	      # last copy.  This is not always right, but it is rare
+	      # enough that we require users that really mean to play
+	      # such unportable linking tricks to link the library
+	      # using -Wl,-lname, so that libtool does not consider it
+	      # for duplicate removal.
+	      case " $specialdeplibs " in
+	      *" $deplib "*) new_libs="$deplib $new_libs" ;;
+	      *)
+		case " $new_libs " in
+		*" $deplib "*) ;;
+		*) new_libs="$deplib $new_libs" ;;
+		esac
+		;;
+	      esac
+	      ;;
+	    esac
+	  done
+	  tmp_libs=
+	  for deplib in $new_libs; do
+	    case $deplib in
+	    -L*)
+	      case " $tmp_libs " in
+	      *" $deplib "*) ;;
+	      *) func_append tmp_libs " $deplib" ;;
+	      esac
+	      ;;
+	    *) func_append tmp_libs " $deplib" ;;
+	    esac
+	  done
+	  eval $var=\"$tmp_libs\"
+	done # for var
+      fi
+
+      # Add Sun CC postdeps if required:
+      test CXX = "$tagname" && {
+        case $host_os in
+        linux*)
+          case `$CC -V 2>&1 | sed 5q` in
+          *Sun\ C*) # Sun C++ 5.9
+            func_suncc_cstd_abi
+
+            if test no != "$suncc_use_cstd_abi"; then
+              func_append postdeps ' -library=Cstd -library=Crun'
+            fi
+            ;;
+          esac
+          ;;
+
+        solaris*)
+          func_cc_basename "$CC"
+          case $func_cc_basename_result in
+          CC* | sunCC*)
+            func_suncc_cstd_abi
+
+            if test no != "$suncc_use_cstd_abi"; then
+              func_append postdeps ' -library=Cstd -library=Crun'
+            fi
+            ;;
+          esac
+          ;;
+        esac
+      }
+
+      # Last step: remove runtime libs from dependency_libs
+      # (they stay in deplibs)
+      tmp_libs=
+      for i in $dependency_libs; do
+	case " $predeps $postdeps $compiler_lib_search_path " in
+	*" $i "*)
+	  i=
+	  ;;
+	esac
+	if test -n "$i"; then
+	  func_append tmp_libs " $i"
+	fi
+      done
+      dependency_libs=$tmp_libs
+    done # for pass
+    if test prog = "$linkmode"; then
+      dlfiles=$newdlfiles
+    fi
+    if test prog = "$linkmode" || test lib = "$linkmode"; then
+      dlprefiles=$newdlprefiles
+    fi
+
+    case $linkmode in
+    oldlib)
+      if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
+	func_warning "'-dlopen' is ignored for archives"
+      fi
+
+      case " $deplibs" in
+      *\ -l* | *\ -L*)
+	func_warning "'-l' and '-L' are ignored for archives" ;;
+      esac
+
+      test -n "$rpath" && \
+	func_warning "'-rpath' is ignored for archives"
+
+      test -n "$xrpath" && \
+	func_warning "'-R' is ignored for archives"
+
+      test -n "$vinfo" && \
+	func_warning "'-version-info/-version-number' is ignored for archives"
+
+      test -n "$release" && \
+	func_warning "'-release' is ignored for archives"
+
+      test -n "$export_symbols$export_symbols_regex" && \
+	func_warning "'-export-symbols' is ignored for archives"
+
+      # Now set the variables for building old libraries.
+      build_libtool_libs=no
+      oldlibs=$output
+      func_append objs "$old_deplibs"
+      ;;
+
+    lib)
+      # Make sure we only generate libraries of the form 'libNAME.la'.
+      case $outputname in
+      lib*)
+	func_stripname 'lib' '.la' "$outputname"
+	name=$func_stripname_result
+	eval shared_ext=\"$shrext_cmds\"
+	eval libname=\"$libname_spec\"
+	;;
+      *)
+	test no = "$module" \
+	  && func_fatal_help "libtool library '$output' must begin with 'lib'"
+
+	if test no != "$need_lib_prefix"; then
+	  # Add the "lib" prefix for modules if required
+	  func_stripname '' '.la' "$outputname"
+	  name=$func_stripname_result
+	  eval shared_ext=\"$shrext_cmds\"
+	  eval libname=\"$libname_spec\"
+	else
+	  func_stripname '' '.la' "$outputname"
+	  libname=$func_stripname_result
+	fi
+	;;
+      esac
+
+      if test -n "$objs"; then
+	if test pass_all != "$deplibs_check_method"; then
+	  func_fatal_error "cannot build libtool library '$output' from non-libtool objects on this host:$objs"
+	else
+	  echo
+	  $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
+	  $ECHO "*** objects $objs is not portable!"
+	  func_append libobjs " $objs"
+	fi
+      fi
+
+      test no = "$dlself" \
+	|| func_warning "'-dlopen self' is ignored for libtool libraries"
+
+      set dummy $rpath
+      shift
+      test 1 -lt "$#" \
+	&& func_warning "ignoring multiple '-rpath's for a libtool library"
+
+      install_libdir=$1
+
+      oldlibs=
+      if test -z "$rpath"; then
+	if test yes = "$build_libtool_libs"; then
+	  # Building a libtool convenience library.
+	  # Some compilers have problems with a '.al' extension so
+	  # convenience libraries should have the same extension an
+	  # archive normally would.
+	  oldlibs="$output_objdir/$libname.$libext $oldlibs"
+	  build_libtool_libs=convenience
+	  build_old_libs=yes
+	fi
+
+	test -n "$vinfo" && \
+	  func_warning "'-version-info/-version-number' is ignored for convenience libraries"
+
+	test -n "$release" && \
+	  func_warning "'-release' is ignored for convenience libraries"
+      else
+
+	# Parse the version information argument.
+	save_ifs=$IFS; IFS=:
+	set dummy $vinfo 0 0 0
+	shift
+	IFS=$save_ifs
+
+	test -n "$7" && \
+	  func_fatal_help "too many parameters to '-version-info'"
+
+	# convert absolute version numbers to libtool ages
+	# this retains compatibility with .la files and attempts
+	# to make the code below a bit more comprehensible
+
+	case $vinfo_number in
+	yes)
+	  number_major=$1
+	  number_minor=$2
+	  number_revision=$3
+	  #
+	  # There are really only two kinds -- those that
+	  # use the current revision as the major version
+	  # and those that subtract age and use age as
+	  # a minor version.  But, then there is irix
+	  # that has an extra 1 added just for fun
+	  #
+	  case $version_type in
+	  # correct linux to gnu/linux during the next big refactor
+	  darwin|freebsd-elf|linux|osf|windows|none)
+	    func_arith $number_major + $number_minor
+	    current=$func_arith_result
+	    age=$number_minor
+	    revision=$number_revision
+	    ;;
+	  freebsd-aout|qnx|sunos)
+	    current=$number_major
+	    revision=$number_minor
+	    age=0
+	    ;;
+	  irix|nonstopux)
+	    func_arith $number_major + $number_minor
+	    current=$func_arith_result
+	    age=$number_minor
+	    revision=$number_minor
+	    lt_irix_increment=no
+	    ;;
+	  esac
+	  ;;
+	no)
+	  current=$1
+	  revision=$2
+	  age=$3
+	  ;;
+	esac
+
+	# Check that each of the things are valid numbers.
+	case $current in
+	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
+	*)
+	  func_error "CURRENT '$current' must be a nonnegative integer"
+	  func_fatal_error "'$vinfo' is not valid version information"
+	  ;;
+	esac
+
+	case $revision in
+	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
+	*)
+	  func_error "REVISION '$revision' must be a nonnegative integer"
+	  func_fatal_error "'$vinfo' is not valid version information"
+	  ;;
+	esac
+
+	case $age in
+	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
+	*)
+	  func_error "AGE '$age' must be a nonnegative integer"
+	  func_fatal_error "'$vinfo' is not valid version information"
+	  ;;
+	esac
+
+	if test "$age" -gt "$current"; then
+	  func_error "AGE '$age' is greater than the current interface number '$current'"
+	  func_fatal_error "'$vinfo' is not valid version information"
+	fi
+
+	# Calculate the version variables.
+	major=
+	versuffix=
+	verstring=
+	case $version_type in
+	none) ;;
+
+	darwin)
+	  # Like Linux, but with the current version available in
+	  # verstring for coding it into the library header
+	  func_arith $current - $age
+	  major=.$func_arith_result
+	  versuffix=$major.$age.$revision
+	  # Darwin ld doesn't like 0 for these options...
+	  func_arith $current + 1
+	  minor_current=$func_arith_result
+	  xlcverstring="$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision"
+	  verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
+          # On Darwin other compilers
+          case $CC in
+              nagfor*)
+                  verstring="$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision"
+                  ;;
+              *)
+                  verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
+                  ;;
+          esac
+	  ;;
+
+	freebsd-aout)
+	  major=.$current
+	  versuffix=.$current.$revision
+	  ;;
+
+	freebsd-elf)
+	  func_arith $current - $age
+	  major=.$func_arith_result
+	  versuffix=$major.$age.$revision
+	  ;;
+
+	irix | nonstopux)
+	  if test no = "$lt_irix_increment"; then
+	    func_arith $current - $age
+	  else
+	    func_arith $current - $age + 1
+	  fi
+	  major=$func_arith_result
+
+	  case $version_type in
+	    nonstopux) verstring_prefix=nonstopux ;;
+	    *)         verstring_prefix=sgi ;;
+	  esac
+	  verstring=$verstring_prefix$major.$revision
+
+	  # Add in all the interfaces that we are compatible with.
+	  loop=$revision
+	  while test 0 -ne "$loop"; do
+	    func_arith $revision - $loop
+	    iface=$func_arith_result
+	    func_arith $loop - 1
+	    loop=$func_arith_result
+	    verstring=$verstring_prefix$major.$iface:$verstring
+	  done
+
+	  # Before this point, $major must not contain '.'.
+	  major=.$major
+	  versuffix=$major.$revision
+	  ;;
+
+	linux) # correct to gnu/linux during the next big refactor
+	  func_arith $current - $age
+	  major=.$func_arith_result
+	  versuffix=$major.$age.$revision
+	  ;;
+
+	osf)
+	  func_arith $current - $age
+	  major=.$func_arith_result
+	  versuffix=.$current.$age.$revision
+	  verstring=$current.$age.$revision
+
+	  # Add in all the interfaces that we are compatible with.
+	  loop=$age
+	  while test 0 -ne "$loop"; do
+	    func_arith $current - $loop
+	    iface=$func_arith_result
+	    func_arith $loop - 1
+	    loop=$func_arith_result
+	    verstring=$verstring:$iface.0
+	  done
+
+	  # Make executables depend on our current version.
+	  func_append verstring ":$current.0"
+	  ;;
+
+	qnx)
+	  major=.$current
+	  versuffix=.$current
+	  ;;
+
+	sco)
+	  major=.$current
+	  versuffix=.$current
+	  ;;
+
+	sunos)
+	  major=.$current
+	  versuffix=.$current.$revision
+	  ;;
+
+	windows)
+	  # Use '-' rather than '.', since we only want one
+	  # extension on DOS 8.3 file systems.
+	  func_arith $current - $age
+	  major=$func_arith_result
+	  versuffix=-$major
+	  ;;
+
+	*)
+	  func_fatal_configuration "unknown library version type '$version_type'"
+	  ;;
+	esac
+
+	# Clear the version info if we defaulted, and they specified a release.
+	if test -z "$vinfo" && test -n "$release"; then
+	  major=
+	  case $version_type in
+	  darwin)
+	    # we can't check for "0.0" in archive_cmds due to quoting
+	    # problems, so we reset it completely
+	    verstring=
+	    ;;
+	  *)
+	    verstring=0.0
+	    ;;
+	  esac
+	  if test no = "$need_version"; then
+	    versuffix=
+	  else
+	    versuffix=.0.0
+	  fi
+	fi
+
+	# Remove version info from name if versioning should be avoided
+	if test yes,no = "$avoid_version,$need_version"; then
+	  major=
+	  versuffix=
+	  verstring=
+	fi
+
+	# Check to see if the archive will have undefined symbols.
+	if test yes = "$allow_undefined"; then
+	  if test unsupported = "$allow_undefined_flag"; then
+	    if test yes = "$build_old_libs"; then
+	      func_warning "undefined symbols not allowed in $host shared libraries; building static only"
+	      build_libtool_libs=no
+	    else
+	      func_fatal_error "can't build $host shared library unless -no-undefined is specified"
+	    fi
+	  fi
+	else
+	  # Don't allow undefined symbols.
+	  allow_undefined_flag=$no_undefined_flag
+	fi
+
+      fi
+
+      func_generate_dlsyms "$libname" "$libname" :
+      func_append libobjs " $symfileobj"
+      test " " = "$libobjs" && libobjs=
+
+      if test relink != "$opt_mode"; then
+	# Remove our outputs, but don't remove object files since they
+	# may have been created when compiling PIC objects.
+	removelist=
+	tempremovelist=`$ECHO "$output_objdir/*"`
+	for p in $tempremovelist; do
+	  case $p in
+	    *.$objext | *.gcno)
+	       ;;
+	    $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/$libname$release.*)
+	       if test -n "$precious_files_regex"; then
+		 if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
+		 then
+		   continue
+		 fi
+	       fi
+	       func_append removelist " $p"
+	       ;;
+	    *) ;;
+	  esac
+	done
+	test -n "$removelist" && \
+	  func_show_eval "${RM}r \$removelist"
+      fi
+
+      # Now set the variables for building old libraries.
+      if test yes = "$build_old_libs" && test convenience != "$build_libtool_libs"; then
+	func_append oldlibs " $output_objdir/$libname.$libext"
+
+	# Transform .lo files to .o files.
+	oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.$libext$/d; $lo2o" | $NL2SP`
+      fi
+
+      # Eliminate all temporary directories.
+      #for path in $notinst_path; do
+      #	lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
+      #	deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
+      #	dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
+      #done
+
+      if test -n "$xrpath"; then
+	# If the user specified any rpath flags, then add them.
+	temp_xrpath=
+	for libdir in $xrpath; do
+	  func_replace_sysroot "$libdir"
+	  func_append temp_xrpath " -R$func_replace_sysroot_result"
+	  case "$finalize_rpath " in
+	  *" $libdir "*) ;;
+	  *) func_append finalize_rpath " $libdir" ;;
+	  esac
+	done
+	if test yes != "$hardcode_into_libs" || test yes = "$build_old_libs"; then
+	  dependency_libs="$temp_xrpath $dependency_libs"
+	fi
+      fi
+
+      # Make sure dlfiles contains only unique files that won't be dlpreopened
+      old_dlfiles=$dlfiles
+      dlfiles=
+      for lib in $old_dlfiles; do
+	case " $dlprefiles $dlfiles " in
+	*" $lib "*) ;;
+	*) func_append dlfiles " $lib" ;;
+	esac
+      done
+
+      # Make sure dlprefiles contains only unique files
+      old_dlprefiles=$dlprefiles
+      dlprefiles=
+      for lib in $old_dlprefiles; do
+	case "$dlprefiles " in
+	*" $lib "*) ;;
+	*) func_append dlprefiles " $lib" ;;
+	esac
+      done
+
+      if test yes = "$build_libtool_libs"; then
+	if test -n "$rpath"; then
+	  case $host in
+	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
+	    # these systems don't actually have a c library (as such)!
+	    ;;
+	  *-*-rhapsody* | *-*-darwin1.[012])
+	    # Rhapsody C library is in the System framework
+	    func_append deplibs " System.ltframework"
+	    ;;
+	  *-*-netbsd*)
+	    # Don't link with libc until the a.out ld.so is fixed.
+	    ;;
+	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
+	    # Do not include libc due to us having libc/libc_r.
+	    ;;
+	  *-*-sco3.2v5* | *-*-sco5v6*)
+	    # Causes problems with __ctype
+	    ;;
+	  *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
+	    # Compiler inserts libc in the correct place for threads to work
+	    ;;
+	  *)
+	    # Add libc to deplibs on all other systems if necessary.
+	    if test yes = "$build_libtool_need_lc"; then
+	      func_append deplibs " -lc"
+	    fi
+	    ;;
+	  esac
+	fi
+
+	# Transform deplibs into only deplibs that can be linked in shared.
+	name_save=$name
+	libname_save=$libname
+	release_save=$release
+	versuffix_save=$versuffix
+	major_save=$major
+	# I'm not sure if I'm treating the release correctly.  I think
+	# release should show up in the -l (ie -lgmp5) so we don't want to
+	# add it in twice.  Is that correct?
+	release=
+	versuffix=
+	major=
+	newdeplibs=
+	droppeddeps=no
+	case $deplibs_check_method in
+	pass_all)
+	  # Don't check for shared/static.  Everything works.
+	  # This might be a little naive.  We might want to check
+	  # whether the library exists or not.  But this is on
+	  # osf3 & osf4 and I'm not really sure... Just
+	  # implementing what was already the behavior.
+	  newdeplibs=$deplibs
+	  ;;
+	test_compile)
+	  # This code stresses the "libraries are programs" paradigm to its
+	  # limits. Maybe even breaks it.  We compile a program, linking it
+	  # against the deplibs as a proxy for the library.  Then we can check
+	  # whether they linked in statically or dynamically with ldd.
+	  $opt_dry_run || $RM conftest.c
+	  cat > conftest.c <<EOF
+	  int main() { return 0; }
+EOF
+	  $opt_dry_run || $RM conftest
+	  if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
+	    ldd_output=`ldd conftest`
+	    for i in $deplibs; do
+	      case $i in
+	      -l*)
+		func_stripname -l '' "$i"
+		name=$func_stripname_result
+		if test yes = "$allow_libtool_libs_with_static_runtimes"; then
+		  case " $predeps $postdeps " in
+		  *" $i "*)
+		    func_append newdeplibs " $i"
+		    i=
+		    ;;
+		  esac
+		fi
+		if test -n "$i"; then
+		  libname=`eval "\\$ECHO \"$libname_spec\""`
+		  deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
+		  set dummy $deplib_matches; shift
+		  deplib_match=$1
+		  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0; then
+		    func_append newdeplibs " $i"
+		  else
+		    droppeddeps=yes
+		    echo
+		    $ECHO "*** Warning: dynamic linker does not accept needed library $i."
+		    echo "*** I have the capability to make that library automatically link in when"
+		    echo "*** you link to this library.  But I can only do this if you have a"
+		    echo "*** shared version of the library, which I believe you do not have"
+		    echo "*** because a test_compile did reveal that the linker did not use it for"
+		    echo "*** its dynamic dependency list that programs get resolved with at runtime."
+		  fi
+		fi
+		;;
+	      *)
+		func_append newdeplibs " $i"
+		;;
+	      esac
+	    done
+	  else
+	    # Error occurred in the first compile.  Let's try to salvage
+	    # the situation: Compile a separate program for each library.
+	    for i in $deplibs; do
+	      case $i in
+	      -l*)
+		func_stripname -l '' "$i"
+		name=$func_stripname_result
+		$opt_dry_run || $RM conftest
+		if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
+		  ldd_output=`ldd conftest`
+		  if test yes = "$allow_libtool_libs_with_static_runtimes"; then
+		    case " $predeps $postdeps " in
+		    *" $i "*)
+		      func_append newdeplibs " $i"
+		      i=
+		      ;;
+		    esac
+		  fi
+		  if test -n "$i"; then
+		    libname=`eval "\\$ECHO \"$libname_spec\""`
+		    deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
+		    set dummy $deplib_matches; shift
+		    deplib_match=$1
+		    if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0; then
+		      func_append newdeplibs " $i"
+		    else
+		      droppeddeps=yes
+		      echo
+		      $ECHO "*** Warning: dynamic linker does not accept needed library $i."
+		      echo "*** I have the capability to make that library automatically link in when"
+		      echo "*** you link to this library.  But I can only do this if you have a"
+		      echo "*** shared version of the library, which you do not appear to have"
+		      echo "*** because a test_compile did reveal that the linker did not use this one"
+		      echo "*** as a dynamic dependency that programs can get resolved with at runtime."
+		    fi
+		  fi
+		else
+		  droppeddeps=yes
+		  echo
+		  $ECHO "*** Warning!  Library $i is needed by this library but I was not able to"
+		  echo "*** make it link in!  You will probably need to install it or some"
+		  echo "*** library that it depends on before this library will be fully"
+		  echo "*** functional.  Installing it before continuing would be even better."
+		fi
+		;;
+	      *)
+		func_append newdeplibs " $i"
+		;;
+	      esac
+	    done
+	  fi
+	  ;;
+	file_magic*)
+	  set dummy $deplibs_check_method; shift
+	  file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
+	  for a_deplib in $deplibs; do
+	    case $a_deplib in
+	    -l*)
+	      func_stripname -l '' "$a_deplib"
+	      name=$func_stripname_result
+	      if test yes = "$allow_libtool_libs_with_static_runtimes"; then
+		case " $predeps $postdeps " in
+		*" $a_deplib "*)
+		  func_append newdeplibs " $a_deplib"
+		  a_deplib=
+		  ;;
+		esac
+	      fi
+	      if test -n "$a_deplib"; then
+		libname=`eval "\\$ECHO \"$libname_spec\""`
+		if test -n "$file_magic_glob"; then
+		  libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
+		else
+		  libnameglob=$libname
+		fi
+		test yes = "$want_nocaseglob" && nocaseglob=`shopt -p nocaseglob`
+		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
+		  if test yes = "$want_nocaseglob"; then
+		    shopt -s nocaseglob
+		    potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
+		    $nocaseglob
+		  else
+		    potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
+		  fi
+		  for potent_lib in $potential_libs; do
+		      # Follow soft links.
+		      if ls -lLd "$potent_lib" 2>/dev/null |
+			 $GREP " -> " >/dev/null; then
+			continue
+		      fi
+		      # The statement above tries to avoid entering an
+		      # endless loop below, in case of cyclic links.
+		      # We might still enter an endless loop, since a link
+		      # loop can be closed while we follow links,
+		      # but so what?
+		      potlib=$potent_lib
+		      while test -h "$potlib" 2>/dev/null; do
+			potliblink=`ls -ld $potlib | $SED 's/.* -> //'`
+			case $potliblink in
+			[\\/]* | [A-Za-z]:[\\/]*) potlib=$potliblink;;
+			*) potlib=`$ECHO "$potlib" | $SED 's|[^/]*$||'`"$potliblink";;
+			esac
+		      done
+		      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
+			 $SED -e 10q |
+			 $EGREP "$file_magic_regex" > /dev/null; then
+			func_append newdeplibs " $a_deplib"
+			a_deplib=
+			break 2
+		      fi
+		  done
+		done
+	      fi
+	      if test -n "$a_deplib"; then
+		droppeddeps=yes
+		echo
+		$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
+		echo "*** I have the capability to make that library automatically link in when"
+		echo "*** you link to this library.  But I can only do this if you have a"
+		echo "*** shared version of the library, which you do not appear to have"
+		echo "*** because I did check the linker path looking for a file starting"
+		if test -z "$potlib"; then
+		  $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
+		else
+		  $ECHO "*** with $libname and none of the candidates passed a file format test"
+		  $ECHO "*** using a file magic. Last file checked: $potlib"
+		fi
+	      fi
+	      ;;
+	    *)
+	      # Add a -L argument.
+	      func_append newdeplibs " $a_deplib"
+	      ;;
+	    esac
+	  done # Gone through all deplibs.
+	  ;;
+	match_pattern*)
+	  set dummy $deplibs_check_method; shift
+	  match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
+	  for a_deplib in $deplibs; do
+	    case $a_deplib in
+	    -l*)
+	      func_stripname -l '' "$a_deplib"
+	      name=$func_stripname_result
+	      if test yes = "$allow_libtool_libs_with_static_runtimes"; then
+		case " $predeps $postdeps " in
+		*" $a_deplib "*)
+		  func_append newdeplibs " $a_deplib"
+		  a_deplib=
+		  ;;
+		esac
+	      fi
+	      if test -n "$a_deplib"; then
+		libname=`eval "\\$ECHO \"$libname_spec\""`
+		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
+		  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
+		  for potent_lib in $potential_libs; do
+		    potlib=$potent_lib # see symlink-check above in file_magic test
+		    if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
+		       $EGREP "$match_pattern_regex" > /dev/null; then
+		      func_append newdeplibs " $a_deplib"
+		      a_deplib=
+		      break 2
+		    fi
+		  done
+		done
+	      fi
+	      if test -n "$a_deplib"; then
+		droppeddeps=yes
+		echo
+		$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
+		echo "*** I have the capability to make that library automatically link in when"
+		echo "*** you link to this library.  But I can only do this if you have a"
+		echo "*** shared version of the library, which you do not appear to have"
+		echo "*** because I did check the linker path looking for a file starting"
+		if test -z "$potlib"; then
+		  $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
+		else
+		  $ECHO "*** with $libname and none of the candidates passed a file format test"
+		  $ECHO "*** using a regex pattern. Last file checked: $potlib"
+		fi
+	      fi
+	      ;;
+	    *)
+	      # Add a -L argument.
+	      func_append newdeplibs " $a_deplib"
+	      ;;
+	    esac
+	  done # Gone through all deplibs.
+	  ;;
+	none | unknown | *)
+	  newdeplibs=
+	  tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
+	  if test yes = "$allow_libtool_libs_with_static_runtimes"; then
+	    for i in $predeps $postdeps; do
+	      # can't use Xsed below, because $i might contain '/'
+	      tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s|$i||"`
+	    done
+	  fi
+	  case $tmp_deplibs in
+	  *[!\	\ ]*)
+	    echo
+	    if test none = "$deplibs_check_method"; then
+	      echo "*** Warning: inter-library dependencies are not supported in this platform."
+	    else
+	      echo "*** Warning: inter-library dependencies are not known to be supported."
+	    fi
+	    echo "*** All declared inter-library dependencies are being dropped."
+	    droppeddeps=yes
+	    ;;
+	  esac
+	  ;;
+	esac
+	versuffix=$versuffix_save
+	major=$major_save
+	release=$release_save
+	libname=$libname_save
+	name=$name_save
+
+	case $host in
+	*-*-rhapsody* | *-*-darwin1.[012])
+	  # On Rhapsody replace the C library with the System framework
+	  newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
+	  ;;
+	esac
+
+	if test yes = "$droppeddeps"; then
+	  if test yes = "$module"; then
+	    echo
+	    echo "*** Warning: libtool could not satisfy all declared inter-library"
+	    $ECHO "*** dependencies of module $libname.  Therefore, libtool will create"
+	    echo "*** a static module, that should work as long as the dlopening"
+	    echo "*** application is linked with the -dlopen flag."
+	    if test -z "$global_symbol_pipe"; then
+	      echo
+	      echo "*** However, this would only work if libtool was able to extract symbol"
+	      echo "*** lists from a program, using 'nm' or equivalent, but libtool could"
+	      echo "*** not find such a program.  So, this module is probably useless."
+	      echo "*** 'nm' from GNU binutils and a full rebuild may help."
+	    fi
+	    if test no = "$build_old_libs"; then
+	      oldlibs=$output_objdir/$libname.$libext
+	      build_libtool_libs=module
+	      build_old_libs=yes
+	    else
+	      build_libtool_libs=no
+	    fi
+	  else
+	    echo "*** The inter-library dependencies that have been dropped here will be"
+	    echo "*** automatically added whenever a program is linked with this library"
+	    echo "*** or is declared to -dlopen it."
+
+	    if test no = "$allow_undefined"; then
+	      echo
+	      echo "*** Since this library must not contain undefined symbols,"
+	      echo "*** because either the platform does not support them or"
+	      echo "*** it was explicitly requested with -no-undefined,"
+	      echo "*** libtool will only create a static version of it."
+	      if test no = "$build_old_libs"; then
+		oldlibs=$output_objdir/$libname.$libext
+		build_libtool_libs=module
+		build_old_libs=yes
+	      else
+		build_libtool_libs=no
+	      fi
+	    fi
+	  fi
+	fi
+	# Done checking deplibs!
+	deplibs=$newdeplibs
+      fi
+      # Time to change all our "foo.ltframework" stuff back to "-framework foo"
+      case $host in
+	*-*-darwin*)
+	  newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
+	  new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
+	  deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
+	  ;;
+      esac
+
+      # move library search paths that coincide with paths to not yet
+      # installed libraries to the beginning of the library search list
+      new_libs=
+      for path in $notinst_path; do
+	case " $new_libs " in
+	*" -L$path/$objdir "*) ;;
+	*)
+	  case " $deplibs " in
+	  *" -L$path/$objdir "*)
+	    func_append new_libs " -L$path/$objdir" ;;
+	  esac
+	  ;;
+	esac
+      done
+      for deplib in $deplibs; do
+	case $deplib in
+	-L*)
+	  case " $new_libs " in
+	  *" $deplib "*) ;;
+	  *) func_append new_libs " $deplib" ;;
+	  esac
+	  ;;
+	*) func_append new_libs " $deplib" ;;
+	esac
+      done
+      deplibs=$new_libs
+
+      # All the library-specific variables (install_libdir is set above).
+      library_names=
+      old_library=
+      dlname=
+
+      # Test again, we may have decided not to build it any more
+      if test yes = "$build_libtool_libs"; then
+	# Remove $wl instances when linking with ld.
+	# FIXME: should test the right _cmds variable.
+	case $archive_cmds in
+	  *\$LD\ *) wl= ;;
+        esac
+	if test yes = "$hardcode_into_libs"; then
+	  # Hardcode the library paths
+	  hardcode_libdirs=
+	  dep_rpath=
+	  rpath=$finalize_rpath
+	  test relink = "$opt_mode" || rpath=$compile_rpath$rpath
+	  for libdir in $rpath; do
+	    if test -n "$hardcode_libdir_flag_spec"; then
+	      if test -n "$hardcode_libdir_separator"; then
+		func_replace_sysroot "$libdir"
+		libdir=$func_replace_sysroot_result
+		if test -z "$hardcode_libdirs"; then
+		  hardcode_libdirs=$libdir
+		else
+		  # Just accumulate the unique libdirs.
+		  case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
+		  *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
+		    ;;
+		  *)
+		    func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
+		    ;;
+		  esac
+		fi
+	      else
+		eval flag=\"$hardcode_libdir_flag_spec\"
+		func_append dep_rpath " $flag"
+	      fi
+	    elif test -n "$runpath_var"; then
+	      case "$perm_rpath " in
+	      *" $libdir "*) ;;
+	      *) func_append perm_rpath " $libdir" ;;
+	      esac
+	    fi
+	  done
+	  # Substitute the hardcoded libdirs into the rpath.
+	  if test -n "$hardcode_libdir_separator" &&
+	     test -n "$hardcode_libdirs"; then
+	    libdir=$hardcode_libdirs
+	    eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
+	  fi
+	  if test -n "$runpath_var" && test -n "$perm_rpath"; then
+	    # We should set the runpath_var.
+	    rpath=
+	    for dir in $perm_rpath; do
+	      func_append rpath "$dir:"
+	    done
+	    eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
+	  fi
+	  test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
+	fi
+
+	shlibpath=$finalize_shlibpath
+	test relink = "$opt_mode" || shlibpath=$compile_shlibpath$shlibpath
+	if test -n "$shlibpath"; then
+	  eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
+	fi
+
+	# Get the real and link names of the library.
+	eval shared_ext=\"$shrext_cmds\"
+	eval library_names=\"$library_names_spec\"
+	set dummy $library_names
+	shift
+	realname=$1
+	shift
+
+	if test -n "$soname_spec"; then
+	  eval soname=\"$soname_spec\"
+	else
+	  soname=$realname
+	fi
+	if test -z "$dlname"; then
+	  dlname=$soname
+	fi
+
+	lib=$output_objdir/$realname
+	linknames=
+	for link
+	do
+	  func_append linknames " $link"
+	done
+
+	# Use standard objects if they are pic
+	test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
+	test "X$libobjs" = "X " && libobjs=
+
+	delfiles=
+	if test -n "$export_symbols" && test -n "$include_expsyms"; then
+	  $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
+	  export_symbols=$output_objdir/$libname.uexp
+	  func_append delfiles " $export_symbols"
+	fi
+
+	orig_export_symbols=
+	case $host_os in
+	cygwin* | mingw* | cegcc*)
+	  if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
+	    # exporting using user supplied symfile
+	    func_dll_def_p "$export_symbols" || {
+	      # and it's NOT already a .def file. Must figure out
+	      # which of the given symbols are data symbols and tag
+	      # them as such. So, trigger use of export_symbols_cmds.
+	      # export_symbols gets reassigned inside the "prepare
+	      # the list of exported symbols" if statement, so the
+	      # include_expsyms logic still works.
+	      orig_export_symbols=$export_symbols
+	      export_symbols=
+	      always_export_symbols=yes
+	    }
+	  fi
+	  ;;
+	esac
+
+	# Prepare the list of exported symbols
+	if test -z "$export_symbols"; then
+	  if test yes = "$always_export_symbols" || test -n "$export_symbols_regex"; then
+	    func_verbose "generating symbol list for '$libname.la'"
+	    export_symbols=$output_objdir/$libname.exp
+	    $opt_dry_run || $RM $export_symbols
+	    cmds=$export_symbols_cmds
+	    save_ifs=$IFS; IFS='~'
+	    for cmd1 in $cmds; do
+	      IFS=$save_ifs
+	      # Take the normal branch if the nm_file_list_spec branch
+	      # doesn't work or if tool conversion is not needed.
+	      case $nm_file_list_spec~$to_tool_file_cmd in
+		*~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)
+		  try_normal_branch=yes
+		  eval cmd=\"$cmd1\"
+		  func_len " $cmd"
+		  len=$func_len_result
+		  ;;
+		*)
+		  try_normal_branch=no
+		  ;;
+	      esac
+	      if test yes = "$try_normal_branch" \
+		 && { test "$len" -lt "$max_cmd_len" \
+		      || test "$max_cmd_len" -le -1; }
+	      then
+		func_show_eval "$cmd" 'exit $?'
+		skipped_export=false
+	      elif test -n "$nm_file_list_spec"; then
+		func_basename "$output"
+		output_la=$func_basename_result
+		save_libobjs=$libobjs
+		save_output=$output
+		output=$output_objdir/$output_la.nm
+		func_to_tool_file "$output"
+		libobjs=$nm_file_list_spec$func_to_tool_file_result
+		func_append delfiles " $output"
+		func_verbose "creating $NM input file list: $output"
+		for obj in $save_libobjs; do
+		  func_to_tool_file "$obj"
+		  $ECHO "$func_to_tool_file_result"
+		done > "$output"
+		eval cmd=\"$cmd1\"
+		func_show_eval "$cmd" 'exit $?'
+		output=$save_output
+		libobjs=$save_libobjs
+		skipped_export=false
+	      else
+		# The command line is too long to execute in one step.
+		func_verbose "using reloadable object file for export list..."
+		skipped_export=:
+		# Break out early, otherwise skipped_export may be
+		# set to false by a later but shorter cmd.
+		break
+	      fi
+	    done
+	    IFS=$save_ifs
+	    if test -n "$export_symbols_regex" && test : != "$skipped_export"; then
+	      func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
+	      func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
+	    fi
+	  fi
+	fi
+
+	if test -n "$export_symbols" && test -n "$include_expsyms"; then
+	  tmp_export_symbols=$export_symbols
+	  test -n "$orig_export_symbols" && tmp_export_symbols=$orig_export_symbols
+	  $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
+	fi
+
+	if test : != "$skipped_export" && test -n "$orig_export_symbols"; then
+	  # The given exports_symbols file has to be filtered, so filter it.
+	  func_verbose "filter symbol list for '$libname.la' to tag DATA exports"
+	  # FIXME: $output_objdir/$libname.filter potentially contains lots of
+	  # 's' commands, which not all seds can handle. GNU sed should be fine
+	  # though. Also, the filter scales superlinearly with the number of
+	  # global variables. join(1) would be nice here, but unfortunately
+	  # isn't a blessed tool.
+	  $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
+	  func_append delfiles " $export_symbols $output_objdir/$libname.filter"
+	  export_symbols=$output_objdir/$libname.def
+	  $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
+	fi
+
+	tmp_deplibs=
+	for test_deplib in $deplibs; do
+	  case " $convenience " in
+	  *" $test_deplib "*) ;;
+	  *)
+	    func_append tmp_deplibs " $test_deplib"
+	    ;;
+	  esac
+	done
+	deplibs=$tmp_deplibs
+
+	if test -n "$convenience"; then
+	  if test -n "$whole_archive_flag_spec" &&
+	    test yes = "$compiler_needs_object" &&
+	    test -z "$libobjs"; then
+	    # extract the archives, so we have objects to list.
+	    # TODO: could optimize this to just extract one archive.
+	    whole_archive_flag_spec=
+	  fi
+	  if test -n "$whole_archive_flag_spec"; then
+	    save_libobjs=$libobjs
+	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
+	    test "X$libobjs" = "X " && libobjs=
+	  else
+	    gentop=$output_objdir/${outputname}x
+	    func_append generated " $gentop"
+
+	    func_extract_archives $gentop $convenience
+	    func_append libobjs " $func_extract_archives_result"
+	    test "X$libobjs" = "X " && libobjs=
+	  fi
+	fi
+
+	if test yes = "$thread_safe" && test -n "$thread_safe_flag_spec"; then
+	  eval flag=\"$thread_safe_flag_spec\"
+	  func_append linker_flags " $flag"
+	fi
+
+	# Make a backup of the uninstalled library when relinking
+	if test relink = "$opt_mode"; then
+	  $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
+	fi
+
+	# Do each of the archive commands.
+	if test yes = "$module" && test -n "$module_cmds"; then
+	  if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
+	    eval test_cmds=\"$module_expsym_cmds\"
+	    cmds=$module_expsym_cmds
+	  else
+	    eval test_cmds=\"$module_cmds\"
+	    cmds=$module_cmds
+	  fi
+	else
+	  if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
+	    eval test_cmds=\"$archive_expsym_cmds\"
+	    cmds=$archive_expsym_cmds
+	  else
+	    eval test_cmds=\"$archive_cmds\"
+	    cmds=$archive_cmds
+	  fi
+	fi
+
+	if test : != "$skipped_export" &&
+	   func_len " $test_cmds" &&
+	   len=$func_len_result &&
+	   test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
+	  :
+	else
+	  # The command line is too long to link in one step, link piecewise
+	  # or, if using GNU ld and skipped_export is not :, use a linker
+	  # script.
+
+	  # Save the value of $output and $libobjs because we want to
+	  # use them later.  If we have whole_archive_flag_spec, we
+	  # want to use save_libobjs as it was before
+	  # whole_archive_flag_spec was expanded, because we can't
+	  # assume the linker understands whole_archive_flag_spec.
+	  # This may have to be revisited, in case too many
+	  # convenience libraries get linked in and end up exceeding
+	  # the spec.
+	  if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
+	    save_libobjs=$libobjs
+	  fi
+	  save_output=$output
+	  func_basename "$output"
+	  output_la=$func_basename_result
+
+	  # Clear the reloadable object creation command queue and
+	  # initialize k to one.
+	  test_cmds=
+	  concat_cmds=
+	  objlist=
+	  last_robj=
+	  k=1
+
+	  if test -n "$save_libobjs" && test : != "$skipped_export" && test yes = "$with_gnu_ld"; then
+	    output=$output_objdir/$output_la.lnkscript
+	    func_verbose "creating GNU ld script: $output"
+	    echo 'INPUT (' > $output
+	    for obj in $save_libobjs
+	    do
+	      func_to_tool_file "$obj"
+	      $ECHO "$func_to_tool_file_result" >> $output
+	    done
+	    echo ')' >> $output
+	    func_append delfiles " $output"
+	    func_to_tool_file "$output"
+	    output=$func_to_tool_file_result
+	  elif test -n "$save_libobjs" && test : != "$skipped_export" && test -n "$file_list_spec"; then
+	    output=$output_objdir/$output_la.lnk
+	    func_verbose "creating linker input file list: $output"
+	    : > $output
+	    set x $save_libobjs
+	    shift
+	    firstobj=
+	    if test yes = "$compiler_needs_object"; then
+	      firstobj="$1 "
+	      shift
+	    fi
+	    for obj
+	    do
+	      func_to_tool_file "$obj"
+	      $ECHO "$func_to_tool_file_result" >> $output
+	    done
+	    func_append delfiles " $output"
+	    func_to_tool_file "$output"
+	    output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
+	  else
+	    if test -n "$save_libobjs"; then
+	      func_verbose "creating reloadable object files..."
+	      output=$output_objdir/$output_la-$k.$objext
+	      eval test_cmds=\"$reload_cmds\"
+	      func_len " $test_cmds"
+	      len0=$func_len_result
+	      len=$len0
+
+	      # Loop over the list of objects to be linked.
+	      for obj in $save_libobjs
+	      do
+		func_len " $obj"
+		func_arith $len + $func_len_result
+		len=$func_arith_result
+		if test -z "$objlist" ||
+		   test "$len" -lt "$max_cmd_len"; then
+		  func_append objlist " $obj"
+		else
+		  # The command $test_cmds is almost too long, add a
+		  # command to the queue.
+		  if test 1 -eq "$k"; then
+		    # The first file doesn't have a previous command to add.
+		    reload_objs=$objlist
+		    eval concat_cmds=\"$reload_cmds\"
+		  else
+		    # All subsequent reloadable object files will link in
+		    # the last one created.
+		    reload_objs="$objlist $last_robj"
+		    eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
+		  fi
+		  last_robj=$output_objdir/$output_la-$k.$objext
+		  func_arith $k + 1
+		  k=$func_arith_result
+		  output=$output_objdir/$output_la-$k.$objext
+		  objlist=" $obj"
+		  func_len " $last_robj"
+		  func_arith $len0 + $func_len_result
+		  len=$func_arith_result
+		fi
+	      done
+	      # Handle the remaining objects by creating one last
+	      # reloadable object file.  All subsequent reloadable object
+	      # files will link in the last one created.
+	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
+	      reload_objs="$objlist $last_robj"
+	      eval concat_cmds=\"\$concat_cmds$reload_cmds\"
+	      if test -n "$last_robj"; then
+	        eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
+	      fi
+	      func_append delfiles " $output"
+
+	    else
+	      output=
+	    fi
+
+	    ${skipped_export-false} && {
+	      func_verbose "generating symbol list for '$libname.la'"
+	      export_symbols=$output_objdir/$libname.exp
+	      $opt_dry_run || $RM $export_symbols
+	      libobjs=$output
+	      # Append the command to create the export file.
+	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
+	      eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
+	      if test -n "$last_robj"; then
+		eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
+	      fi
+	    }
+
+	    test -n "$save_libobjs" &&
+	      func_verbose "creating a temporary reloadable object file: $output"
+
+	    # Loop through the commands generated above and execute them.
+	    save_ifs=$IFS; IFS='~'
+	    for cmd in $concat_cmds; do
+	      IFS=$save_ifs
+	      $opt_quiet || {
+		  func_quote_for_expand "$cmd"
+		  eval "func_echo $func_quote_for_expand_result"
+	      }
+	      $opt_dry_run || eval "$cmd" || {
+		lt_exit=$?
+
+		# Restore the uninstalled library and exit
+		if test relink = "$opt_mode"; then
+		  ( cd "$output_objdir" && \
+		    $RM "${realname}T" && \
+		    $MV "${realname}U" "$realname" )
+		fi
+
+		exit $lt_exit
+	      }
+	    done
+	    IFS=$save_ifs
+
+	    if test -n "$export_symbols_regex" && ${skipped_export-false}; then
+	      func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
+	      func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
+	    fi
+	  fi
+
+          ${skipped_export-false} && {
+	    if test -n "$export_symbols" && test -n "$include_expsyms"; then
+	      tmp_export_symbols=$export_symbols
+	      test -n "$orig_export_symbols" && tmp_export_symbols=$orig_export_symbols
+	      $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
+	    fi
+
+	    if test -n "$orig_export_symbols"; then
+	      # The given exports_symbols file has to be filtered, so filter it.
+	      func_verbose "filter symbol list for '$libname.la' to tag DATA exports"
+	      # FIXME: $output_objdir/$libname.filter potentially contains lots of
+	      # 's' commands, which not all seds can handle. GNU sed should be fine
+	      # though. Also, the filter scales superlinearly with the number of
+	      # global variables. join(1) would be nice here, but unfortunately
+	      # isn't a blessed tool.
+	      $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
+	      func_append delfiles " $export_symbols $output_objdir/$libname.filter"
+	      export_symbols=$output_objdir/$libname.def
+	      $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
+	    fi
+	  }
+
+	  libobjs=$output
+	  # Restore the value of output.
+	  output=$save_output
+
+	  if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
+	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
+	    test "X$libobjs" = "X " && libobjs=
+	  fi
+	  # Expand the library linking commands again to reset the
+	  # value of $libobjs for piecewise linking.
+
+	  # Do each of the archive commands.
+	  if test yes = "$module" && test -n "$module_cmds"; then
+	    if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
+	      cmds=$module_expsym_cmds
+	    else
+	      cmds=$module_cmds
+	    fi
+	  else
+	    if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
+	      cmds=$archive_expsym_cmds
+	    else
+	      cmds=$archive_cmds
+	    fi
+	  fi
+	fi
+
+	if test -n "$delfiles"; then
+	  # Append the command to remove temporary files to $cmds.
+	  eval cmds=\"\$cmds~\$RM $delfiles\"
+	fi
+
+	# Add any objects from preloaded convenience libraries
+	if test -n "$dlprefiles"; then
+	  gentop=$output_objdir/${outputname}x
+	  func_append generated " $gentop"
+
+	  func_extract_archives $gentop $dlprefiles
+	  func_append libobjs " $func_extract_archives_result"
+	  test "X$libobjs" = "X " && libobjs=
+	fi
+
+	save_ifs=$IFS; IFS='~'
+	for cmd in $cmds; do
+	  IFS=$sp$nl
+	  eval cmd=\"$cmd\"
+	  IFS=$save_ifs
+	  $opt_quiet || {
+	    func_quote_for_expand "$cmd"
+	    eval "func_echo $func_quote_for_expand_result"
+	  }
+	  $opt_dry_run || eval "$cmd" || {
+	    lt_exit=$?
+
+	    # Restore the uninstalled library and exit
+	    if test relink = "$opt_mode"; then
+	      ( cd "$output_objdir" && \
+	        $RM "${realname}T" && \
+		$MV "${realname}U" "$realname" )
+	    fi
+
+	    exit $lt_exit
+	  }
+	done
+	IFS=$save_ifs
+
+	# Restore the uninstalled library and exit
+	if test relink = "$opt_mode"; then
+	  $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
+
+	  if test -n "$convenience"; then
+	    if test -z "$whole_archive_flag_spec"; then
+	      func_show_eval '${RM}r "$gentop"'
+	    fi
+	  fi
+
+	  exit $EXIT_SUCCESS
+	fi
+
+	# Create links to the real library.
+	for linkname in $linknames; do
+	  if test "$realname" != "$linkname"; then
+	    func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
+	  fi
+	done
+
+	# If -module or -export-dynamic was specified, set the dlname.
+	if test yes = "$module" || test yes = "$export_dynamic"; then
+	  # On all known operating systems, these are identical.
+	  dlname=$soname
+	fi
+      fi
+      ;;
+
+    obj)
+      if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
+	func_warning "'-dlopen' is ignored for objects"
+      fi
+
+      case " $deplibs" in
+      *\ -l* | *\ -L*)
+	func_warning "'-l' and '-L' are ignored for objects" ;;
+      esac
+
+      test -n "$rpath" && \
+	func_warning "'-rpath' is ignored for objects"
+
+      test -n "$xrpath" && \
+	func_warning "'-R' is ignored for objects"
+
+      test -n "$vinfo" && \
+	func_warning "'-version-info' is ignored for objects"
+
+      test -n "$release" && \
+	func_warning "'-release' is ignored for objects"
+
+      case $output in
+      *.lo)
+	test -n "$objs$old_deplibs" && \
+	  func_fatal_error "cannot build library object '$output' from non-libtool objects"
+
+	libobj=$output
+	func_lo2o "$libobj"
+	obj=$func_lo2o_result
+	;;
+      *)
+	libobj=
+	obj=$output
+	;;
+      esac
+
+      # Delete the old objects.
+      $opt_dry_run || $RM $obj $libobj
+
+      # Objects from convenience libraries.  This assumes
+      # single-version convenience libraries.  Whenever we create
+      # different ones for PIC/non-PIC, this we'll have to duplicate
+      # the extraction.
+      reload_conv_objs=
+      gentop=
+      # if reload_cmds runs $LD directly, get rid of -Wl from
+      # whole_archive_flag_spec and hope we can get by with turning comma
+      # into space.
+      case $reload_cmds in
+        *\$LD[\ \$]*) wl= ;;
+      esac
+      if test -n "$convenience"; then
+	if test -n "$whole_archive_flag_spec"; then
+	  eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
+	  test -n "$wl" || tmp_whole_archive_flags=`$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
+	  reload_conv_objs=$reload_objs\ $tmp_whole_archive_flags
+	else
+	  gentop=$output_objdir/${obj}x
+	  func_append generated " $gentop"
+
+	  func_extract_archives $gentop $convenience
+	  reload_conv_objs="$reload_objs $func_extract_archives_result"
+	fi
+      fi
+
+      # If we're not building shared, we need to use non_pic_objs
+      test yes = "$build_libtool_libs" || libobjs=$non_pic_objects
+
+      # Create the old-style object.
+      reload_objs=$objs$old_deplibs' '`$ECHO "$libobjs" | $SP2NL | $SED "/\.$libext$/d; /\.lib$/d; $lo2o" | $NL2SP`' '$reload_conv_objs
+
+      output=$obj
+      func_execute_cmds "$reload_cmds" 'exit $?'
+
+      # Exit if we aren't doing a library object file.
+      if test -z "$libobj"; then
+	if test -n "$gentop"; then
+	  func_show_eval '${RM}r "$gentop"'
+	fi
+
+	exit $EXIT_SUCCESS
+      fi
+
+      test yes = "$build_libtool_libs" || {
+	if test -n "$gentop"; then
+	  func_show_eval '${RM}r "$gentop"'
+	fi
+
+	# Create an invalid libtool object if no PIC, so that we don't
+	# accidentally link it into a program.
+	# $show "echo timestamp > $libobj"
+	# $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
+	exit $EXIT_SUCCESS
+      }
+
+      if test -n "$pic_flag" || test default != "$pic_mode"; then
+	# Only do commands if we really have different PIC objects.
+	reload_objs="$libobjs $reload_conv_objs"
+	output=$libobj
+	func_execute_cmds "$reload_cmds" 'exit $?'
+      fi
+
+      if test -n "$gentop"; then
+	func_show_eval '${RM}r "$gentop"'
+      fi
+
+      exit $EXIT_SUCCESS
+      ;;
+
+    prog)
+      case $host in
+	*cygwin*) func_stripname '' '.exe' "$output"
+	          output=$func_stripname_result.exe;;
+      esac
+      test -n "$vinfo" && \
+	func_warning "'-version-info' is ignored for programs"
+
+      test -n "$release" && \
+	func_warning "'-release' is ignored for programs"
+
+      $preload \
+	&& test unknown,unknown,unknown = "$dlopen_support,$dlopen_self,$dlopen_self_static" \
+	&& func_warning "'LT_INIT([dlopen])' not used. Assuming no dlopen support."
+
+      case $host in
+      *-*-rhapsody* | *-*-darwin1.[012])
+	# On Rhapsody replace the C library is the System framework
+	compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
+	finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
+	;;
+      esac
+
+      case $host in
+      *-*-darwin*)
+	# Don't allow lazy linking, it breaks C++ global constructors
+	# But is supposedly fixed on 10.4 or later (yay!).
+	if test CXX = "$tagname"; then
+	  case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
+	    10.[0123])
+	      func_append compile_command " $wl-bind_at_load"
+	      func_append finalize_command " $wl-bind_at_load"
+	    ;;
+	  esac
+	fi
+	# Time to change all our "foo.ltframework" stuff back to "-framework foo"
+	compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
+	finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
+	;;
+      esac
+
+
+      # move library search paths that coincide with paths to not yet
+      # installed libraries to the beginning of the library search list
+      new_libs=
+      for path in $notinst_path; do
+	case " $new_libs " in
+	*" -L$path/$objdir "*) ;;
+	*)
+	  case " $compile_deplibs " in
+	  *" -L$path/$objdir "*)
+	    func_append new_libs " -L$path/$objdir" ;;
+	  esac
+	  ;;
+	esac
+      done
+      for deplib in $compile_deplibs; do
+	case $deplib in
+	-L*)
+	  case " $new_libs " in
+	  *" $deplib "*) ;;
+	  *) func_append new_libs " $deplib" ;;
+	  esac
+	  ;;
+	*) func_append new_libs " $deplib" ;;
+	esac
+      done
+      compile_deplibs=$new_libs
+
+
+      func_append compile_command " $compile_deplibs"
+      func_append finalize_command " $finalize_deplibs"
+
+      if test -n "$rpath$xrpath"; then
+	# If the user specified any rpath flags, then add them.
+	for libdir in $rpath $xrpath; do
+	  # This is the magic to use -rpath.
+	  case "$finalize_rpath " in
+	  *" $libdir "*) ;;
+	  *) func_append finalize_rpath " $libdir" ;;
+	  esac
+	done
+      fi
+
+      # Now hardcode the library paths
+      rpath=
+      hardcode_libdirs=
+      for libdir in $compile_rpath $finalize_rpath; do
+	if test -n "$hardcode_libdir_flag_spec"; then
+	  if test -n "$hardcode_libdir_separator"; then
+	    if test -z "$hardcode_libdirs"; then
+	      hardcode_libdirs=$libdir
+	    else
+	      # Just accumulate the unique libdirs.
+	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
+	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
+		;;
+	      *)
+		func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
+		;;
+	      esac
+	    fi
+	  else
+	    eval flag=\"$hardcode_libdir_flag_spec\"
+	    func_append rpath " $flag"
+	  fi
+	elif test -n "$runpath_var"; then
+	  case "$perm_rpath " in
+	  *" $libdir "*) ;;
+	  *) func_append perm_rpath " $libdir" ;;
+	  esac
+	fi
+	case $host in
+	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
+	  testbindir=`$ECHO "$libdir" | $SED -e 's*/lib$*/bin*'`
+	  case :$dllsearchpath: in
+	  *":$libdir:"*) ;;
+	  ::) dllsearchpath=$libdir;;
+	  *) func_append dllsearchpath ":$libdir";;
+	  esac
+	  case :$dllsearchpath: in
+	  *":$testbindir:"*) ;;
+	  ::) dllsearchpath=$testbindir;;
+	  *) func_append dllsearchpath ":$testbindir";;
+	  esac
+	  ;;
+	esac
+      done
+      # Substitute the hardcoded libdirs into the rpath.
+      if test -n "$hardcode_libdir_separator" &&
+	 test -n "$hardcode_libdirs"; then
+	libdir=$hardcode_libdirs
+	eval rpath=\" $hardcode_libdir_flag_spec\"
+      fi
+      compile_rpath=$rpath
+
+      rpath=
+      hardcode_libdirs=
+      for libdir in $finalize_rpath; do
+	if test -n "$hardcode_libdir_flag_spec"; then
+	  if test -n "$hardcode_libdir_separator"; then
+	    if test -z "$hardcode_libdirs"; then
+	      hardcode_libdirs=$libdir
+	    else
+	      # Just accumulate the unique libdirs.
+	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
+	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
+		;;
+	      *)
+		func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
+		;;
+	      esac
+	    fi
+	  else
+	    eval flag=\"$hardcode_libdir_flag_spec\"
+	    func_append rpath " $flag"
+	  fi
+	elif test -n "$runpath_var"; then
+	  case "$finalize_perm_rpath " in
+	  *" $libdir "*) ;;
+	  *) func_append finalize_perm_rpath " $libdir" ;;
+	  esac
+	fi
+      done
+      # Substitute the hardcoded libdirs into the rpath.
+      if test -n "$hardcode_libdir_separator" &&
+	 test -n "$hardcode_libdirs"; then
+	libdir=$hardcode_libdirs
+	eval rpath=\" $hardcode_libdir_flag_spec\"
+      fi
+      finalize_rpath=$rpath
+
+      if test -n "$libobjs" && test yes = "$build_old_libs"; then
+	# Transform all the library objects into standard objects.
+	compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
+	finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
+      fi
+
+      func_generate_dlsyms "$outputname" "@PROGRAM@" false
+
+      # template prelinking step
+      if test -n "$prelink_cmds"; then
+	func_execute_cmds "$prelink_cmds" 'exit $?'
+      fi
+
+      wrappers_required=:
+      case $host in
+      *cegcc* | *mingw32ce*)
+        # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
+        wrappers_required=false
+        ;;
+      *cygwin* | *mingw* )
+        test yes = "$build_libtool_libs" || wrappers_required=false
+        ;;
+      *)
+        if test no = "$need_relink" || test yes != "$build_libtool_libs"; then
+          wrappers_required=false
+        fi
+        ;;
+      esac
+      $wrappers_required || {
+	# Replace the output file specification.
+	compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
+	link_command=$compile_command$compile_rpath
+
+	# We have no uninstalled library dependencies, so finalize right now.
+	exit_status=0
+	func_show_eval "$link_command" 'exit_status=$?'
+
+	if test -n "$postlink_cmds"; then
+	  func_to_tool_file "$output"
+	  postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
+	  func_execute_cmds "$postlink_cmds" 'exit $?'
+	fi
+
+	# Delete the generated files.
+	if test -f "$output_objdir/${outputname}S.$objext"; then
+	  func_show_eval '$RM "$output_objdir/${outputname}S.$objext"'
+	fi
+
+	exit $exit_status
+      }
+
+      if test -n "$compile_shlibpath$finalize_shlibpath"; then
+	compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
+      fi
+      if test -n "$finalize_shlibpath"; then
+	finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
+      fi
+
+      compile_var=
+      finalize_var=
+      if test -n "$runpath_var"; then
+	if test -n "$perm_rpath"; then
+	  # We should set the runpath_var.
+	  rpath=
+	  for dir in $perm_rpath; do
+	    func_append rpath "$dir:"
+	  done
+	  compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
+	fi
+	if test -n "$finalize_perm_rpath"; then
+	  # We should set the runpath_var.
+	  rpath=
+	  for dir in $finalize_perm_rpath; do
+	    func_append rpath "$dir:"
+	  done
+	  finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
+	fi
+      fi
+
+      if test yes = "$no_install"; then
+	# We don't need to create a wrapper script.
+	link_command=$compile_var$compile_command$compile_rpath
+	# Replace the output file specification.
+	link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
+	# Delete the old output file.
+	$opt_dry_run || $RM $output
+	# Link the executable and exit
+	func_show_eval "$link_command" 'exit $?'
+
+	if test -n "$postlink_cmds"; then
+	  func_to_tool_file "$output"
+	  postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
+	  func_execute_cmds "$postlink_cmds" 'exit $?'
+	fi
+
+	exit $EXIT_SUCCESS
+      fi
+
+      case $hardcode_action,$fast_install in
+        relink,*)
+	  # Fast installation is not supported
+	  link_command=$compile_var$compile_command$compile_rpath
+	  relink_command=$finalize_var$finalize_command$finalize_rpath
+
+	  func_warning "this platform does not like uninstalled shared libraries"
+	  func_warning "'$output' will be relinked during installation"
+	  ;;
+        *,yes)
+	  link_command=$finalize_var$compile_command$finalize_rpath
+	  relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
+          ;;
+	*,no)
+	  link_command=$compile_var$compile_command$compile_rpath
+	  relink_command=$finalize_var$finalize_command$finalize_rpath
+          ;;
+	*,needless)
+	  link_command=$finalize_var$compile_command$finalize_rpath
+	  relink_command=
+          ;;
+      esac
+
+      # Replace the output file specification.
+      link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
+
+      # Delete the old output files.
+      $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
+
+      func_show_eval "$link_command" 'exit $?'
+
+      if test -n "$postlink_cmds"; then
+	func_to_tool_file "$output_objdir/$outputname"
+	postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
+	func_execute_cmds "$postlink_cmds" 'exit $?'
+      fi
+
+      # Now create the wrapper script.
+      func_verbose "creating $output"
+
+      # Quote the relink command for shipping.
+      if test -n "$relink_command"; then
+	# Preserve any variables that may affect compiler behavior
+	for var in $variables_saved_for_relink; do
+	  if eval test -z \"\${$var+set}\"; then
+	    relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
+	  elif eval var_value=\$$var; test -z "$var_value"; then
+	    relink_command="$var=; export $var; $relink_command"
+	  else
+	    func_quote_for_eval "$var_value"
+	    relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
+	  fi
+	done
+	relink_command="(cd `pwd`; $relink_command)"
+	relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
+      fi
+
+      # Only actually do things if not in dry run mode.
+      $opt_dry_run || {
+	# win32 will think the script is a binary if it has
+	# a .exe suffix, so we strip it off here.
+	case $output in
+	  *.exe) func_stripname '' '.exe' "$output"
+	         output=$func_stripname_result ;;
+	esac
+	# test for cygwin because mv fails w/o .exe extensions
+	case $host in
+	  *cygwin*)
+	    exeext=.exe
+	    func_stripname '' '.exe' "$outputname"
+	    outputname=$func_stripname_result ;;
+	  *) exeext= ;;
+	esac
+	case $host in
+	  *cygwin* | *mingw* )
+	    func_dirname_and_basename "$output" "" "."
+	    output_name=$func_basename_result
+	    output_path=$func_dirname_result
+	    cwrappersource=$output_path/$objdir/lt-$output_name.c
+	    cwrapper=$output_path/$output_name.exe
+	    $RM $cwrappersource $cwrapper
+	    trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
+
+	    func_emit_cwrapperexe_src > $cwrappersource
+
+	    # The wrapper executable is built using the $host compiler,
+	    # because it contains $host paths and files. If cross-
+	    # compiling, it, like the target executable, must be
+	    # executed on the $host or under an emulation environment.
+	    $opt_dry_run || {
+	      $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
+	      $STRIP $cwrapper
+	    }
+
+	    # Now, create the wrapper script for func_source use:
+	    func_ltwrapper_scriptname $cwrapper
+	    $RM $func_ltwrapper_scriptname_result
+	    trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
+	    $opt_dry_run || {
+	      # note: this script will not be executed, so do not chmod.
+	      if test "x$build" = "x$host"; then
+		$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
+	      else
+		func_emit_wrapper no > $func_ltwrapper_scriptname_result
+	      fi
+	    }
+	  ;;
+	  * )
+	    $RM $output
+	    trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
+
+	    func_emit_wrapper no > $output
+	    chmod +x $output
+	  ;;
+	esac
+      }
+      exit $EXIT_SUCCESS
+      ;;
+    esac
+
+    # See if we need to build an old-fashioned archive.
+    for oldlib in $oldlibs; do
+
+      case $build_libtool_libs in
+        convenience)
+	  oldobjs="$libobjs_save $symfileobj"
+	  addlibs=$convenience
+	  build_libtool_libs=no
+	  ;;
+	module)
+	  oldobjs=$libobjs_save
+	  addlibs=$old_convenience
+	  build_libtool_libs=no
+          ;;
+	*)
+	  oldobjs="$old_deplibs $non_pic_objects"
+	  $preload && test -f "$symfileobj" \
+	    && func_append oldobjs " $symfileobj"
+	  addlibs=$old_convenience
+	  ;;
+      esac
+
+      if test -n "$addlibs"; then
+	gentop=$output_objdir/${outputname}x
+	func_append generated " $gentop"
+
+	func_extract_archives $gentop $addlibs
+	func_append oldobjs " $func_extract_archives_result"
+      fi
+
+      # Do each command in the archive commands.
+      if test -n "$old_archive_from_new_cmds" && test yes = "$build_libtool_libs"; then
+	cmds=$old_archive_from_new_cmds
+      else
+
+	# Add any objects from preloaded convenience libraries
+	if test -n "$dlprefiles"; then
+	  gentop=$output_objdir/${outputname}x
+	  func_append generated " $gentop"
+
+	  func_extract_archives $gentop $dlprefiles
+	  func_append oldobjs " $func_extract_archives_result"
+	fi
+
+	# POSIX demands no paths to be encoded in archives.  We have
+	# to avoid creating archives with duplicate basenames if we
+	# might have to extract them afterwards, e.g., when creating a
+	# static archive out of a convenience library, or when linking
+	# the entirety of a libtool archive into another (currently
+	# not supported by libtool).
+	if (for obj in $oldobjs
+	    do
+	      func_basename "$obj"
+	      $ECHO "$func_basename_result"
+	    done | sort | sort -uc >/dev/null 2>&1); then
+	  :
+	else
+	  echo "copying selected object files to avoid basename conflicts..."
+	  gentop=$output_objdir/${outputname}x
+	  func_append generated " $gentop"
+	  func_mkdir_p "$gentop"
+	  save_oldobjs=$oldobjs
+	  oldobjs=
+	  counter=1
+	  for obj in $save_oldobjs
+	  do
+	    func_basename "$obj"
+	    objbase=$func_basename_result
+	    case " $oldobjs " in
+	    " ") oldobjs=$obj ;;
+	    *[\ /]"$objbase "*)
+	      while :; do
+		# Make sure we don't pick an alternate name that also
+		# overlaps.
+		newobj=lt$counter-$objbase
+		func_arith $counter + 1
+		counter=$func_arith_result
+		case " $oldobjs " in
+		*[\ /]"$newobj "*) ;;
+		*) if test ! -f "$gentop/$newobj"; then break; fi ;;
+		esac
+	      done
+	      func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
+	      func_append oldobjs " $gentop/$newobj"
+	      ;;
+	    *) func_append oldobjs " $obj" ;;
+	    esac
+	  done
+	fi
+	func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
+	tool_oldlib=$func_to_tool_file_result
+	eval cmds=\"$old_archive_cmds\"
+
+	func_len " $cmds"
+	len=$func_len_result
+	if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
+	  cmds=$old_archive_cmds
+	elif test -n "$archiver_list_spec"; then
+	  func_verbose "using command file archive linking..."
+	  for obj in $oldobjs
+	  do
+	    func_to_tool_file "$obj"
+	    $ECHO "$func_to_tool_file_result"
+	  done > $output_objdir/$libname.libcmd
+	  func_to_tool_file "$output_objdir/$libname.libcmd"
+	  oldobjs=" $archiver_list_spec$func_to_tool_file_result"
+	  cmds=$old_archive_cmds
+	else
+	  # the command line is too long to link in one step, link in parts
+	  func_verbose "using piecewise archive linking..."
+	  save_RANLIB=$RANLIB
+	  RANLIB=:
+	  objlist=
+	  concat_cmds=
+	  save_oldobjs=$oldobjs
+	  oldobjs=
+	  # Is there a better way of finding the last object in the list?
+	  for obj in $save_oldobjs
+	  do
+	    last_oldobj=$obj
+	  done
+	  eval test_cmds=\"$old_archive_cmds\"
+	  func_len " $test_cmds"
+	  len0=$func_len_result
+	  len=$len0
+	  for obj in $save_oldobjs
+	  do
+	    func_len " $obj"
+	    func_arith $len + $func_len_result
+	    len=$func_arith_result
+	    func_append objlist " $obj"
+	    if test "$len" -lt "$max_cmd_len"; then
+	      :
+	    else
+	      # the above command should be used before it gets too long
+	      oldobjs=$objlist
+	      if test "$obj" = "$last_oldobj"; then
+		RANLIB=$save_RANLIB
+	      fi
+	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
+	      eval concat_cmds=\"\$concat_cmds$old_archive_cmds\"
+	      objlist=
+	      len=$len0
+	    fi
+	  done
+	  RANLIB=$save_RANLIB
+	  oldobjs=$objlist
+	  if test -z "$oldobjs"; then
+	    eval cmds=\"\$concat_cmds\"
+	  else
+	    eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
+	  fi
+	fi
+      fi
+      func_execute_cmds "$cmds" 'exit $?'
+    done
+
+    test -n "$generated" && \
+      func_show_eval "${RM}r$generated"
+
+    # Now create the libtool archive.
+    case $output in
+    *.la)
+      old_library=
+      test yes = "$build_old_libs" && old_library=$libname.$libext
+      func_verbose "creating $output"
+
+      # Preserve any variables that may affect compiler behavior
+      for var in $variables_saved_for_relink; do
+	if eval test -z \"\${$var+set}\"; then
+	  relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
+	elif eval var_value=\$$var; test -z "$var_value"; then
+	  relink_command="$var=; export $var; $relink_command"
+	else
+	  func_quote_for_eval "$var_value"
+	  relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
+	fi
+      done
+      # Quote the link command for shipping.
+      relink_command="(cd `pwd`; $SHELL \"$progpath\" $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
+      relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
+      if test yes = "$hardcode_automatic"; then
+	relink_command=
+      fi
+
+      # Only create the output if not a dry run.
+      $opt_dry_run || {
+	for installed in no yes; do
+	  if test yes = "$installed"; then
+	    if test -z "$install_libdir"; then
+	      break
+	    fi
+	    output=$output_objdir/${outputname}i
+	    # Replace all uninstalled libtool libraries with the installed ones
+	    newdependency_libs=
+	    for deplib in $dependency_libs; do
+	      case $deplib in
+	      *.la)
+		func_basename "$deplib"
+		name=$func_basename_result
+		func_resolve_sysroot "$deplib"
+		eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result`
+		test -z "$libdir" && \
+		  func_fatal_error "'$deplib' is not a valid libtool archive"
+		func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
+		;;
+	      -L*)
+		func_stripname -L '' "$deplib"
+		func_replace_sysroot "$func_stripname_result"
+		func_append newdependency_libs " -L$func_replace_sysroot_result"
+		;;
+	      -R*)
+		func_stripname -R '' "$deplib"
+		func_replace_sysroot "$func_stripname_result"
+		func_append newdependency_libs " -R$func_replace_sysroot_result"
+		;;
+	      *) func_append newdependency_libs " $deplib" ;;
+	      esac
+	    done
+	    dependency_libs=$newdependency_libs
+	    newdlfiles=
+
+	    for lib in $dlfiles; do
+	      case $lib in
+	      *.la)
+	        func_basename "$lib"
+		name=$func_basename_result
+		eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
+		test -z "$libdir" && \
+		  func_fatal_error "'$lib' is not a valid libtool archive"
+		func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
+		;;
+	      *) func_append newdlfiles " $lib" ;;
+	      esac
+	    done
+	    dlfiles=$newdlfiles
+	    newdlprefiles=
+	    for lib in $dlprefiles; do
+	      case $lib in
+	      *.la)
+		# Only pass preopened files to the pseudo-archive (for
+		# eventual linking with the app. that links it) if we
+		# didn't already link the preopened objects directly into
+		# the library:
+		func_basename "$lib"
+		name=$func_basename_result
+		eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
+		test -z "$libdir" && \
+		  func_fatal_error "'$lib' is not a valid libtool archive"
+		func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
+		;;
+	      esac
+	    done
+	    dlprefiles=$newdlprefiles
+	  else
+	    newdlfiles=
+	    for lib in $dlfiles; do
+	      case $lib in
+		[\\/]* | [A-Za-z]:[\\/]*) abs=$lib ;;
+		*) abs=`pwd`"/$lib" ;;
+	      esac
+	      func_append newdlfiles " $abs"
+	    done
+	    dlfiles=$newdlfiles
+	    newdlprefiles=
+	    for lib in $dlprefiles; do
+	      case $lib in
+		[\\/]* | [A-Za-z]:[\\/]*) abs=$lib ;;
+		*) abs=`pwd`"/$lib" ;;
+	      esac
+	      func_append newdlprefiles " $abs"
+	    done
+	    dlprefiles=$newdlprefiles
+	  fi
+	  $RM $output
+	  # place dlname in correct position for cygwin
+	  # In fact, it would be nice if we could use this code for all target
+	  # systems that can't hard-code library paths into their executables
+	  # and that have no shared library path variable independent of PATH,
+	  # but it turns out we can't easily determine that from inspecting
+	  # libtool variables, so we have to hard-code the OSs to which it
+	  # applies here; at the moment, that means platforms that use the PE
+	  # object format with DLL files.  See the long comment at the top of
+	  # tests/bindir.at for full details.
+	  tdlname=$dlname
+	  case $host,$output,$installed,$module,$dlname in
+	    *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
+	      # If a -bindir argument was supplied, place the dll there.
+	      if test -n "$bindir"; then
+		func_relative_path "$install_libdir" "$bindir"
+		tdlname=$func_relative_path_result/$dlname
+	      else
+		# Otherwise fall back on heuristic.
+		tdlname=../bin/$dlname
+	      fi
+	      ;;
+	  esac
+	  $ECHO > $output "\
+# $outputname - a libtool library file
+# Generated by $PROGRAM (GNU $PACKAGE) $VERSION
+#
+# Please DO NOT delete this file!
+# It is necessary for linking the library.
+
+# The name that we can dlopen(3).
+dlname='$tdlname'
+
+# Names of this library.
+library_names='$library_names'
+
+# The name of the static archive.
+old_library='$old_library'
+
+# Linker flags that cannot go in dependency_libs.
+inherited_linker_flags='$new_inherited_linker_flags'
+
+# Libraries that this one depends upon.
+dependency_libs='$dependency_libs'
+
+# Names of additional weak libraries provided by this library
+weak_library_names='$weak_libs'
+
+# Version information for $libname.
+current=$current
+age=$age
+revision=$revision
+
+# Is this an already installed library?
+installed=$installed
+
+# Should we warn about portability when linking against -modules?
+shouldnotlink=$module
+
+# Files to dlopen/dlpreopen
+dlopen='$dlfiles'
+dlpreopen='$dlprefiles'
+
+# Directory that this library needs to be installed in:
+libdir='$install_libdir'"
+	  if test no,yes = "$installed,$need_relink"; then
+	    $ECHO >> $output "\
+relink_command=\"$relink_command\""
+	  fi
+	done
+      }
+
+      # Do a symbolic link so that the libtool archive can be found in
+      # LD_LIBRARY_PATH before the program is installed.
+      func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
+      ;;
+    esac
+    exit $EXIT_SUCCESS
+}
+
+if test link = "$opt_mode" || test relink = "$opt_mode"; then
+  func_mode_link ${1+"$@"}
+fi
+
+
+# func_mode_uninstall arg...
+func_mode_uninstall ()
+{
+    $debug_cmd
+
+    RM=$nonopt
+    files=
+    rmforce=false
+    exit_status=0
+
+    # This variable tells wrapper scripts just to set variables rather
+    # than running their programs.
+    libtool_install_magic=$magic
+
+    for arg
+    do
+      case $arg in
+      -f) func_append RM " $arg"; rmforce=: ;;
+      -*) func_append RM " $arg" ;;
+      *) func_append files " $arg" ;;
+      esac
+    done
+
+    test -z "$RM" && \
+      func_fatal_help "you must specify an RM program"
+
+    rmdirs=
+
+    for file in $files; do
+      func_dirname "$file" "" "."
+      dir=$func_dirname_result
+      if test . = "$dir"; then
+	odir=$objdir
+      else
+	odir=$dir/$objdir
+      fi
+      func_basename "$file"
+      name=$func_basename_result
+      test uninstall = "$opt_mode" && odir=$dir
+
+      # Remember odir for removal later, being careful to avoid duplicates
+      if test clean = "$opt_mode"; then
+	case " $rmdirs " in
+	  *" $odir "*) ;;
+	  *) func_append rmdirs " $odir" ;;
+	esac
+      fi
+
+      # Don't error if the file doesn't exist and rm -f was used.
+      if { test -L "$file"; } >/dev/null 2>&1 ||
+	 { test -h "$file"; } >/dev/null 2>&1 ||
+	 test -f "$file"; then
+	:
+      elif test -d "$file"; then
+	exit_status=1
+	continue
+      elif $rmforce; then
+	continue
+      fi
+
+      rmfiles=$file
+
+      case $name in
+      *.la)
+	# Possibly a libtool archive, so verify it.
+	if func_lalib_p "$file"; then
+	  func_source $dir/$name
+
+	  # Delete the libtool libraries and symlinks.
+	  for n in $library_names; do
+	    func_append rmfiles " $odir/$n"
+	  done
+	  test -n "$old_library" && func_append rmfiles " $odir/$old_library"
+
+	  case $opt_mode in
+	  clean)
+	    case " $library_names " in
+	    *" $dlname "*) ;;
+	    *) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
+	    esac
+	    test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
+	    ;;
+	  uninstall)
+	    if test -n "$library_names"; then
+	      # Do each command in the postuninstall commands.
+	      func_execute_cmds "$postuninstall_cmds" '$rmforce || exit_status=1'
+	    fi
+
+	    if test -n "$old_library"; then
+	      # Do each command in the old_postuninstall commands.
+	      func_execute_cmds "$old_postuninstall_cmds" '$rmforce || exit_status=1'
+	    fi
+	    # FIXME: should reinstall the best remaining shared library.
+	    ;;
+	  esac
+	fi
+	;;
+
+      *.lo)
+	# Possibly a libtool object, so verify it.
+	if func_lalib_p "$file"; then
+
+	  # Read the .lo file
+	  func_source $dir/$name
+
+	  # Add PIC object to the list of files to remove.
+	  if test -n "$pic_object" && test none != "$pic_object"; then
+	    func_append rmfiles " $dir/$pic_object"
+	  fi
+
+	  # Add non-PIC object to the list of files to remove.
+	  if test -n "$non_pic_object" && test none != "$non_pic_object"; then
+	    func_append rmfiles " $dir/$non_pic_object"
+	  fi
+	fi
+	;;
+
+      *)
+	if test clean = "$opt_mode"; then
+	  noexename=$name
+	  case $file in
+	  *.exe)
+	    func_stripname '' '.exe' "$file"
+	    file=$func_stripname_result
+	    func_stripname '' '.exe' "$name"
+	    noexename=$func_stripname_result
+	    # $file with .exe has already been added to rmfiles,
+	    # add $file without .exe
+	    func_append rmfiles " $file"
+	    ;;
+	  esac
+	  # Do a test to see if this is a libtool program.
+	  if func_ltwrapper_p "$file"; then
+	    if func_ltwrapper_executable_p "$file"; then
+	      func_ltwrapper_scriptname "$file"
+	      relink_command=
+	      func_source $func_ltwrapper_scriptname_result
+	      func_append rmfiles " $func_ltwrapper_scriptname_result"
+	    else
+	      relink_command=
+	      func_source $dir/$noexename
+	    fi
+
+	    # note $name still contains .exe if it was in $file originally
+	    # as does the version of $file that was added into $rmfiles
+	    func_append rmfiles " $odir/$name $odir/${name}S.$objext"
+	    if test yes = "$fast_install" && test -n "$relink_command"; then
+	      func_append rmfiles " $odir/lt-$name"
+	    fi
+	    if test "X$noexename" != "X$name"; then
+	      func_append rmfiles " $odir/lt-$noexename.c"
+	    fi
+	  fi
+	fi
+	;;
+      esac
+      func_show_eval "$RM $rmfiles" 'exit_status=1'
+    done
+
+    # Try to remove the $objdir's in the directories where we deleted files
+    for dir in $rmdirs; do
+      if test -d "$dir"; then
+	func_show_eval "rmdir $dir >/dev/null 2>&1"
+      fi
+    done
+
+    exit $exit_status
+}
+
+if test uninstall = "$opt_mode" || test clean = "$opt_mode"; then
+  func_mode_uninstall ${1+"$@"}
+fi
+
+test -z "$opt_mode" && {
+  help=$generic_help
+  func_fatal_help "you must specify a MODE"
+}
+
+test -z "$exec_cmd" && \
+  func_fatal_help "invalid operation mode '$opt_mode'"
+
+if test -n "$exec_cmd"; then
+  eval exec "$exec_cmd"
+  exit $EXIT_FAILURE
+fi
+
+exit $exit_status
+
+
+# The TAGs below are defined such that we never get into a situation
+# where we disable both kinds of libraries.  Given conflicting
+# choices, we go for a static library, that is the most portable,
+# since we can't tell whether shared libraries were disabled because
+# the user asked for that or because the platform doesn't support
+# them.  This is particularly important on AIX, because we don't
+# support having both static and shared libraries enabled at the same
+# time on that platform, so we default to a shared-only configuration.
+# If a disable-shared tag is given, we'll fallback to a static-only
+# configuration.  But we'll never go from static-only to shared-only.
+
+# ### BEGIN LIBTOOL TAG CONFIG: disable-shared
+build_libtool_libs=no
+build_old_libs=yes
+# ### END LIBTOOL TAG CONFIG: disable-shared
+
+# ### BEGIN LIBTOOL TAG CONFIG: disable-static
+build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
+# ### END LIBTOOL TAG CONFIG: disable-static
+
+# Local Variables:
+# mode:shell-script
+# sh-indentation:2
+# End:
diff --git a/Engine/lib/lpng/mips/filter_msa_intrinsics.c b/Engine/lib/lpng/mips/filter_msa_intrinsics.c
new file mode 100644
index 000000000..a57917942
--- /dev/null
+++ b/Engine/lib/lpng/mips/filter_msa_intrinsics.c
@@ -0,0 +1,808 @@
+
+/* filter_msa_intrinsics.c - MSA optimised filter functions
+ *
+ * Copyright (c) 2018 Cosmin Truta
+ * Copyright (c) 2016 Glenn Randers-Pehrson
+ * Written by Mandar Sahastrabuddhe, August 2016.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+#include "../pngpriv.h"
+
+#ifdef PNG_READ_SUPPORTED
+
+/* This code requires -mfpu=msa on the command line: */
+#if PNG_MIPS_MSA_IMPLEMENTATION == 1 /* intrinsics code from pngpriv.h */
+
+#include <msa.h>
+
+/* libpng row pointers are not necessarily aligned to any particular boundary,
+ * however this code will only work with appropriate alignment. mips/mips_init.c
+ * checks for this (and will not compile unless it is done). This code uses
+ * variants of png_aligncast to avoid compiler warnings.
+ */
+#define png_ptr(type,pointer) png_aligncast(type *,pointer)
+#define png_ptrc(type,pointer) png_aligncastconst(const type *,pointer)
+
+/* The following relies on a variable 'temp_pointer' being declared with type
+ * 'type'.  This is written this way just to hide the GCC strict aliasing
+ * warning; note that the code is safe because there never is an alias between
+ * the input and output pointers.
+ */
+#define png_ldr(type,pointer)\
+   (temp_pointer = png_ptr(type,pointer), *temp_pointer)
+
+#if PNG_MIPS_MSA_OPT > 0
+
+#ifdef CLANG_BUILD
+   #define MSA_SRLI_B(a, b)   __msa_srli_b((v16i8) a, b)
+
+   #define LW(psrc)                              \
+   ( {                                           \
+       uint8_t *psrc_lw_m = (uint8_t *) (psrc);  \
+       uint32_t val_m;                           \
+                                                 \
+       asm volatile (                            \
+           "lw  %[val_m],  %[psrc_lw_m]  \n\t"   \
+                                                 \
+           : [val_m] "=r" (val_m)                \
+           : [psrc_lw_m] "m" (*psrc_lw_m)        \
+       );                                        \
+                                                 \
+       val_m;                                    \
+   } )
+
+   #define SH(val, pdst)                         \
+   {                                             \
+       uint8_t *pdst_sh_m = (uint8_t *) (pdst);  \
+       uint16_t val_m = (val);                   \
+                                                 \
+       asm volatile (                            \
+           "sh  %[val_m],  %[pdst_sh_m]  \n\t"   \
+                                                 \
+           : [pdst_sh_m] "=m" (*pdst_sh_m)       \
+           : [val_m] "r" (val_m)                 \
+       );                                        \
+   }
+
+   #define SW(val, pdst)                         \
+   {                                             \
+       uint8_t *pdst_sw_m = (uint8_t *) (pdst);  \
+       uint32_t val_m = (val);                   \
+                                                 \
+       asm volatile (                            \
+           "sw  %[val_m],  %[pdst_sw_m]  \n\t"   \
+                                                 \
+           : [pdst_sw_m] "=m" (*pdst_sw_m)       \
+           : [val_m] "r" (val_m)                 \
+       );                                        \
+   }
+
+       #if (__mips == 64)
+        #define SD(val, pdst)                         \
+        {                                             \
+            uint8_t *pdst_sd_m = (uint8_t *) (pdst);  \
+            uint64_t val_m = (val);                   \
+                                                      \
+            asm volatile (                            \
+                "sd  %[val_m],  %[pdst_sd_m]  \n\t"   \
+                                                      \
+                : [pdst_sd_m] "=m" (*pdst_sd_m)       \
+                : [val_m] "r" (val_m)                 \
+            );                                        \
+        }
+    #else
+        #define SD(val, pdst)                                          \
+        {                                                              \
+            uint8_t *pdst_sd_m = (uint8_t *) (pdst);                   \
+            uint32_t val0_m, val1_m;                                   \
+                                                                       \
+            val0_m = (uint32_t) ((val) & 0x00000000FFFFFFFF);          \
+            val1_m = (uint32_t) (((val) >> 32) & 0x00000000FFFFFFFF);  \
+                                                                       \
+            SW(val0_m, pdst_sd_m);                                     \
+            SW(val1_m, pdst_sd_m + 4);                                 \
+        }
+    #endif
+#else
+   #define MSA_SRLI_B(a, b)   (a >> b)
+
+#if (__mips_isa_rev >= 6)
+   #define LW(psrc)                              \
+   ( {                                           \
+       uint8_t *psrc_lw_m = (uint8_t *) (psrc);  \
+       uint32_t val_m;                           \
+                                                 \
+       asm volatile (                            \
+           "lw  %[val_m],  %[psrc_lw_m]  \n\t"   \
+                                                 \
+           : [val_m] "=r" (val_m)                \
+           : [psrc_lw_m] "m" (*psrc_lw_m)        \
+       );                                        \
+                                                 \
+       val_m;                                    \
+   } )
+
+   #define SH(val, pdst)                         \
+   {                                             \
+       uint8_t *pdst_sh_m = (uint8_t *) (pdst);  \
+       uint16_t val_m = (val);                   \
+                                                 \
+       asm volatile (                            \
+           "sh  %[val_m],  %[pdst_sh_m]  \n\t"   \
+                                                 \
+           : [pdst_sh_m] "=m" (*pdst_sh_m)       \
+           : [val_m] "r" (val_m)                 \
+       );                                        \
+   }
+
+   #define SW(val, pdst)                         \
+   {                                             \
+       uint8_t *pdst_sw_m = (uint8_t *) (pdst);  \
+       uint32_t val_m = (val);                   \
+                                                 \
+       asm volatile (                            \
+           "sw  %[val_m],  %[pdst_sw_m]  \n\t"   \
+                                                 \
+           : [pdst_sw_m] "=m" (*pdst_sw_m)       \
+           : [val_m] "r" (val_m)                 \
+       );                                        \
+   }
+
+   #if (__mips == 64)
+        #define SD(val, pdst)                         \
+        {                                             \
+            uint8_t *pdst_sd_m = (uint8_t *) (pdst);  \
+            uint64_t val_m = (val);                   \
+                                                      \
+            asm volatile (                            \
+                "sd  %[val_m],  %[pdst_sd_m]  \n\t"   \
+                                                      \
+                : [pdst_sd_m] "=m" (*pdst_sd_m)       \
+                : [val_m] "r" (val_m)                 \
+            );                                        \
+        }
+    #else
+        #define SD(val, pdst)                                          \
+        {                                                              \
+            uint8_t *pdst_sd_m = (uint8_t *) (pdst);                   \
+            uint32_t val0_m, val1_m;                                   \
+                                                                       \
+            val0_m = (uint32_t) ((val) & 0x00000000FFFFFFFF);          \
+            val1_m = (uint32_t) (((val) >> 32) & 0x00000000FFFFFFFF);  \
+                                                                       \
+            SW(val0_m, pdst_sd_m);                                     \
+            SW(val1_m, pdst_sd_m + 4);                                 \
+        }
+    #endif
+#else  // !(__mips_isa_rev >= 6)
+   #define LW(psrc)                              \
+   ( {                                           \
+       uint8_t *psrc_lw_m = (uint8_t *) (psrc);  \
+       uint32_t val_m;                           \
+                                                 \
+       asm volatile (                            \
+           "ulw  %[val_m],  %[psrc_lw_m]  \n\t"  \
+                                                 \
+           : [val_m] "=r" (val_m)                \
+           : [psrc_lw_m] "m" (*psrc_lw_m)        \
+       );                                        \
+                                                 \
+       val_m;                                    \
+   } )
+
+   #define SH(val, pdst)                         \
+   {                                             \
+       uint8_t *pdst_sh_m = (uint8_t *) (pdst);  \
+       uint16_t val_m = (val);                   \
+                                                 \
+       asm volatile (                            \
+           "ush  %[val_m],  %[pdst_sh_m]  \n\t"  \
+                                                 \
+           : [pdst_sh_m] "=m" (*pdst_sh_m)       \
+           : [val_m] "r" (val_m)                 \
+       );                                        \
+   }
+
+   #define SW(val, pdst)                         \
+   {                                             \
+       uint8_t *pdst_sw_m = (uint8_t *) (pdst);  \
+       uint32_t val_m = (val);                   \
+                                                 \
+       asm volatile (                            \
+           "usw  %[val_m],  %[pdst_sw_m]  \n\t"  \
+                                                 \
+           : [pdst_sw_m] "=m" (*pdst_sw_m)       \
+           : [val_m] "r" (val_m)                 \
+       );                                        \
+   }
+
+   #define SD(val, pdst)                                          \
+    {                                                              \
+        uint8_t *pdst_sd_m = (uint8_t *) (pdst);                   \
+        uint32_t val0_m, val1_m;                                   \
+                                                                   \
+        val0_m = (uint32_t) ((val) & 0x00000000FFFFFFFF);          \
+        val1_m = (uint32_t) (((val) >> 32) & 0x00000000FFFFFFFF);  \
+                                                                   \
+        SW(val0_m, pdst_sd_m);                                     \
+        SW(val1_m, pdst_sd_m + 4);                                 \
+    }
+
+    #define SW_ZERO(pdst)                      \
+    {                                          \
+        uint8_t *pdst_m = (uint8_t *) (pdst);  \
+                                               \
+        asm volatile (                         \
+            "usw  $0,  %[pdst_m]  \n\t"        \
+                                               \
+            : [pdst_m] "=m" (*pdst_m)          \
+            :                                  \
+        );                                     \
+    }
+#endif  // (__mips_isa_rev >= 6)
+#endif
+
+#define LD_B(RTYPE, psrc) *((RTYPE *) (psrc))
+#define LD_UB(...) LD_B(v16u8, __VA_ARGS__)
+#define LD_B2(RTYPE, psrc, stride, out0, out1)  \
+{                                               \
+    out0 = LD_B(RTYPE, (psrc));                 \
+    out1 = LD_B(RTYPE, (psrc) + stride);        \
+}
+#define LD_UB2(...) LD_B2(v16u8, __VA_ARGS__)
+#define LD_B4(RTYPE, psrc, stride, out0, out1, out2, out3)   \
+{                                                            \
+    LD_B2(RTYPE, (psrc), stride, out0, out1);                \
+    LD_B2(RTYPE, (psrc) + 2 * stride , stride, out2, out3);  \
+}
+#define LD_UB4(...) LD_B4(v16u8, __VA_ARGS__)
+
+#define ST_B(RTYPE, in, pdst) *((RTYPE *) (pdst)) = (in)
+#define ST_UB(...) ST_B(v16u8, __VA_ARGS__)
+#define ST_B2(RTYPE, in0, in1, pdst, stride)  \
+{                                             \
+    ST_B(RTYPE, in0, (pdst));                 \
+    ST_B(RTYPE, in1, (pdst) + stride);        \
+}
+#define ST_UB2(...) ST_B2(v16u8, __VA_ARGS__)
+#define ST_B4(RTYPE, in0, in1, in2, in3, pdst, stride)    \
+{                                                         \
+    ST_B2(RTYPE, in0, in1, (pdst), stride);               \
+    ST_B2(RTYPE, in2, in3, (pdst) + 2 * stride, stride);  \
+}
+#define ST_UB4(...) ST_B4(v16u8, __VA_ARGS__)
+
+#define ADD2(in0, in1, in2, in3, out0, out1)  \
+{                                             \
+    out0 = in0 + in1;                         \
+    out1 = in2 + in3;                         \
+}
+#define ADD3(in0, in1, in2, in3, in4, in5,  \
+             out0, out1, out2)              \
+{                                           \
+    ADD2(in0, in1, in2, in3, out0, out1);   \
+    out2 = in4 + in5;                       \
+}
+#define ADD4(in0, in1, in2, in3, in4, in5, in6, in7,  \
+             out0, out1, out2, out3)                  \
+{                                                     \
+    ADD2(in0, in1, in2, in3, out0, out1);             \
+    ADD2(in4, in5, in6, in7, out2, out3);             \
+}
+
+#define ILVR_B2(RTYPE, in0, in1, in2, in3, out0, out1)      \
+{                                                           \
+    out0 = (RTYPE) __msa_ilvr_b((v16i8) in0, (v16i8) in1);  \
+    out1 = (RTYPE) __msa_ilvr_b((v16i8) in2, (v16i8) in3);  \
+}
+#define ILVR_B2_SH(...) ILVR_B2(v8i16, __VA_ARGS__)
+
+#define HSUB_UB2(RTYPE, in0, in1, out0, out1)                 \
+{                                                             \
+    out0 = (RTYPE) __msa_hsub_u_h((v16u8) in0, (v16u8) in0);  \
+    out1 = (RTYPE) __msa_hsub_u_h((v16u8) in1, (v16u8) in1);  \
+}
+#define HSUB_UB2_SH(...) HSUB_UB2(v8i16, __VA_ARGS__)
+
+#define SLDI_B2_0(RTYPE, in0, in1, out0, out1, slide_val)                 \
+{                                                                         \
+    v16i8 zero_m = { 0 };                                                 \
+    out0 = (RTYPE) __msa_sldi_b((v16i8) zero_m, (v16i8) in0, slide_val);  \
+    out1 = (RTYPE) __msa_sldi_b((v16i8) zero_m, (v16i8) in1, slide_val);  \
+}
+#define SLDI_B2_0_UB(...) SLDI_B2_0(v16u8, __VA_ARGS__)
+
+#define SLDI_B3_0(RTYPE, in0, in1, in2, out0, out1, out2,  slide_val)     \
+{                                                                         \
+    v16i8 zero_m = { 0 };                                                 \
+    SLDI_B2_0(RTYPE, in0, in1, out0, out1, slide_val);                    \
+    out2 = (RTYPE) __msa_sldi_b((v16i8) zero_m, (v16i8) in2, slide_val);  \
+}
+#define SLDI_B3_0_UB(...) SLDI_B3_0(v16u8, __VA_ARGS__)
+
+#define ILVEV_W2(RTYPE, in0, in1, in2, in3, out0, out1)      \
+{                                                            \
+    out0 = (RTYPE) __msa_ilvev_w((v4i32) in1, (v4i32) in0);  \
+    out1 = (RTYPE) __msa_ilvev_w((v4i32) in3, (v4i32) in2);  \
+}
+#define ILVEV_W2_UB(...) ILVEV_W2(v16u8, __VA_ARGS__)
+
+#define ADD_ABS_H3(RTYPE, in0, in1, in2, out0, out1, out2)  \
+{                                                           \
+    RTYPE zero = {0};                                       \
+                                                            \
+    out0 = __msa_add_a_h((v8i16) zero, in0);                \
+    out1 = __msa_add_a_h((v8i16) zero, in1);                \
+    out2 = __msa_add_a_h((v8i16) zero, in2);                \
+}
+#define ADD_ABS_H3_SH(...) ADD_ABS_H3(v8i16, __VA_ARGS__)
+
+#define VSHF_B2(RTYPE, in0, in1, in2, in3, mask0, mask1, out0, out1)       \
+{                                                                          \
+    out0 = (RTYPE) __msa_vshf_b((v16i8) mask0, (v16i8) in1, (v16i8) in0);  \
+    out1 = (RTYPE) __msa_vshf_b((v16i8) mask1, (v16i8) in3, (v16i8) in2);  \
+}
+#define VSHF_B2_UB(...) VSHF_B2(v16u8, __VA_ARGS__)
+
+#define CMP_AND_SELECT(inp0, inp1, inp2, inp3, inp4, inp5, out0)              \
+{                                                                             \
+   v8i16 _sel_h0, _sel_h1;                                                    \
+   v16u8 _sel_b0, _sel_b1;                                                    \
+   _sel_h0 = (v8i16) __msa_clt_u_h((v8u16) inp1, (v8u16) inp0);               \
+   _sel_b0 = (v16u8) __msa_pckev_b((v16i8) _sel_h0, (v16i8) _sel_h0);         \
+   inp0 = (v8i16) __msa_bmnz_v((v16u8) inp0, (v16u8) inp1, (v16u8) _sel_h0);  \
+   inp4 = (v16u8) __msa_bmnz_v(inp3, inp4, _sel_b0);                          \
+   _sel_h1 = (v8i16) __msa_clt_u_h((v8u16) inp2, (v8u16) inp0);               \
+   _sel_b1 = (v16u8) __msa_pckev_b((v16i8) _sel_h1, (v16i8) _sel_h1);         \
+   inp4 = (v16u8) __msa_bmnz_v(inp4, inp5, _sel_b1);                          \
+   out0 += inp4;                                                              \
+}
+
+void png_read_filter_row_up_msa(png_row_infop row_info, png_bytep row,
+                                png_const_bytep prev_row)
+{
+   size_t i, cnt, cnt16, cnt32;
+   size_t istop = row_info->rowbytes;
+   png_bytep rp = row;
+   png_const_bytep pp = prev_row;
+   v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
+
+   for (i = 0; i < (istop >> 6); i++)
+   {
+      LD_UB4(rp, 16, src0, src1, src2, src3);
+      LD_UB4(pp, 16, src4, src5, src6, src7);
+      pp += 64;
+
+	  ADD4(src0, src4, src1, src5, src2, src6, src3, src7,
+	       src0, src1, src2, src3);
+
+      ST_UB4(src0, src1, src2, src3, rp, 16);
+      rp += 64;
+   }
+
+   if (istop & 0x3F)
+   {
+      cnt32 = istop & 0x20;
+      cnt16 = istop & 0x10;
+      cnt = istop & 0xF;
+
+      if(cnt32)
+      {
+         if (cnt16 && cnt)
+         {
+            LD_UB4(rp, 16, src0, src1, src2, src3);
+            LD_UB4(pp, 16, src4, src5, src6, src7);
+
+            ADD4(src0, src4, src1, src5, src2, src6, src3, src7,
+	             src0, src1, src2, src3);
+
+            ST_UB4(src0, src1, src2, src3, rp, 16);
+            rp += 64;
+         }
+         else if (cnt16 || cnt)
+         {
+            LD_UB2(rp, 16, src0, src1);
+            LD_UB2(pp, 16, src4, src5);
+            pp += 32;
+            src2 = LD_UB(rp + 32);
+            src6 = LD_UB(pp);
+
+            ADD3(src0, src4, src1, src5, src2, src6, src0, src1, src2);
+
+            ST_UB2(src0, src1, rp, 16);
+            rp += 32;
+            ST_UB(src2, rp);
+            rp += 16;
+         }
+         else
+         {
+            LD_UB2(rp, 16, src0, src1);
+            LD_UB2(pp, 16, src4, src5);
+
+			ADD2(src0, src4, src1, src5, src0, src1);
+
+            ST_UB2(src0, src1, rp, 16);
+            rp += 32;
+         }
+      }
+      else if (cnt16 && cnt)
+      {
+         LD_UB2(rp, 16, src0, src1);
+         LD_UB2(pp, 16, src4, src5);
+
+         ADD2(src0, src4, src1, src5, src0, src1);
+
+         ST_UB2(src0, src1, rp, 16);
+         rp += 32;
+      }
+      else if (cnt16 || cnt)
+      {
+         src0 = LD_UB(rp);
+         src4 = LD_UB(pp);
+         pp += 16;
+
+         src0 += src4;
+
+         ST_UB(src0, rp);
+         rp += 16;
+      }
+   }
+}
+
+void png_read_filter_row_sub4_msa(png_row_infop row_info, png_bytep row,
+                                  png_const_bytep prev_row)
+{
+   size_t count;
+   size_t istop = row_info->rowbytes;
+   png_bytep src = row;
+   png_bytep nxt = row + 4;
+   int32_t inp0;
+   v16u8 src0, src1, src2, src3, src4;
+   v16u8 dst0, dst1;
+   v16u8 zero = { 0 };
+
+   istop -= 4;
+
+   inp0 = LW(src);
+   src += 4;
+   src0 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp0);
+
+   for (count = 0; count < istop; count += 16)
+   {
+      src1 = LD_UB(src);
+      src += 16;
+
+      src2 = (v16u8) __msa_sldi_b((v16i8) zero, (v16i8) src1, 4);
+      src3 = (v16u8) __msa_sldi_b((v16i8) zero, (v16i8) src1, 8);
+      src4 = (v16u8) __msa_sldi_b((v16i8) zero, (v16i8) src1, 12);
+      src1 += src0;
+      src2 += src1;
+      src3 += src2;
+      src4 += src3;
+      src0 = src4;
+      ILVEV_W2_UB(src1, src2, src3, src4, dst0, dst1);
+      dst0 = (v16u8) __msa_pckev_d((v2i64) dst1, (v2i64) dst0);
+
+      ST_UB(dst0, nxt);
+      nxt += 16;
+   }
+}
+
+void png_read_filter_row_sub3_msa(png_row_infop row_info, png_bytep row,
+                                  png_const_bytep prev_row)
+{
+   size_t count;
+   size_t istop = row_info->rowbytes;
+   png_bytep src = row;
+   png_bytep nxt = row + 3;
+   int64_t out0;
+   int32_t inp0, out1;
+   v16u8 src0, src1, src2, src3, src4, dst0, dst1;
+   v16u8 zero = { 0 };
+   v16i8 mask0 = { 0, 1, 2, 16, 17, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+   v16i8 mask1 = { 0, 1, 2, 3, 4, 5, 16, 17, 18, 19, 20, 21, 0, 0, 0, 0 };
+
+   istop -= 3;
+
+   inp0 = LW(src);
+   src += 3;
+   src0 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp0);
+
+   for (count = 0; count < istop; count += 12)
+   {
+      src1 = LD_UB(src);
+      src += 12;
+
+      src2 = (v16u8) __msa_sldi_b((v16i8) zero, (v16i8) src1, 3);
+      src3 = (v16u8) __msa_sldi_b((v16i8) zero, (v16i8) src1, 6);
+      src4 = (v16u8) __msa_sldi_b((v16i8) zero, (v16i8) src1, 9);
+      src1 += src0;
+      src2 += src1;
+      src3 += src2;
+      src4 += src3;
+      src0 = src4;
+      VSHF_B2_UB(src1, src2, src3, src4, mask0, mask0, dst0, dst1);
+      dst0 = (v16u8) __msa_vshf_b(mask1, (v16i8) dst1, (v16i8) dst0);
+      out0 = __msa_copy_s_d((v2i64) dst0, 0);
+      out1 = __msa_copy_s_w((v4i32) dst0, 2);
+
+      SD(out0, nxt);
+      nxt += 8;
+      SW(out1, nxt);
+      nxt += 4;
+   }
+}
+
+void png_read_filter_row_avg4_msa(png_row_infop row_info, png_bytep row,
+                                  png_const_bytep prev_row)
+{
+   size_t i;
+   png_bytep src = row;
+   png_bytep nxt = row;
+   png_const_bytep pp = prev_row;
+   size_t istop = row_info->rowbytes - 4;
+   int32_t inp0, inp1, out0;
+   v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, dst0, dst1;
+   v16u8 zero = { 0 };
+
+   inp0 = LW(pp);
+   pp += 4;
+   inp1 = LW(src);
+   src += 4;
+   src0 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp0);
+   src1 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp1);
+   src0 = (v16u8) MSA_SRLI_B(src0, 1);
+   src1 += src0;
+   out0 = __msa_copy_s_w((v4i32) src1, 0);
+   SW(out0, nxt);
+   nxt += 4;
+
+   for (i = 0; i < istop; i += 16)
+   {
+      src2 = LD_UB(pp);
+      pp += 16;
+      src6 = LD_UB(src);
+      src += 16;
+
+      SLDI_B2_0_UB(src2, src6, src3, src7, 4);
+      SLDI_B2_0_UB(src2, src6, src4, src8, 8);
+      SLDI_B2_0_UB(src2, src6, src5, src9, 12);
+      src2 = __msa_ave_u_b(src2, src1);
+      src6 += src2;
+      src3 = __msa_ave_u_b(src3, src6);
+      src7 += src3;
+      src4 = __msa_ave_u_b(src4, src7);
+      src8 += src4;
+      src5 = __msa_ave_u_b(src5, src8);
+      src9 += src5;
+      src1 = src9;
+      ILVEV_W2_UB(src6, src7, src8, src9, dst0, dst1);
+      dst0 = (v16u8) __msa_pckev_d((v2i64) dst1, (v2i64) dst0);
+
+      ST_UB(dst0, nxt);
+      nxt += 16;
+   }
+}
+
+void png_read_filter_row_avg3_msa(png_row_infop row_info, png_bytep row,
+                                  png_const_bytep prev_row)
+{
+   size_t i;
+   png_bytep src = row;
+   png_bytep nxt = row;
+   png_const_bytep pp = prev_row;
+   size_t istop = row_info->rowbytes - 3;
+   int64_t out0;
+   int32_t inp0, inp1, out1;
+   int16_t out2;
+   v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, dst0, dst1;
+   v16u8 zero = { 0 };
+   v16i8 mask0 = { 0, 1, 2, 16, 17, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+   v16i8 mask1 = { 0, 1, 2, 3, 4, 5, 16, 17, 18, 19, 20, 21, 0, 0, 0, 0 };
+
+   inp0 = LW(pp);
+   pp += 3;
+   inp1 = LW(src);
+   src += 3;
+   src0 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp0);
+   src1 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp1);
+   src0 = (v16u8) MSA_SRLI_B(src0, 1);
+   src1 += src0;
+   out2 = __msa_copy_s_h((v8i16) src1, 0);
+   SH(out2, nxt);
+   nxt += 2;
+   nxt[0] = src1[2];
+   nxt++;
+
+   for (i = 0; i < istop; i += 12)
+   {
+      src2 = LD_UB(pp);
+      pp += 12;
+      src6 = LD_UB(src);
+      src += 12;
+
+      SLDI_B2_0_UB(src2, src6, src3, src7, 3);
+      SLDI_B2_0_UB(src2, src6, src4, src8, 6);
+      SLDI_B2_0_UB(src2, src6, src5, src9, 9);
+      src2 = __msa_ave_u_b(src2, src1);
+      src6 += src2;
+      src3 = __msa_ave_u_b(src3, src6);
+      src7 += src3;
+      src4 = __msa_ave_u_b(src4, src7);
+      src8 += src4;
+      src5 = __msa_ave_u_b(src5, src8);
+      src9 += src5;
+      src1 = src9;
+      VSHF_B2_UB(src6, src7, src8, src9, mask0, mask0, dst0, dst1);
+      dst0 = (v16u8) __msa_vshf_b(mask1, (v16i8) dst1, (v16i8) dst0);
+      out0 = __msa_copy_s_d((v2i64) dst0, 0);
+      out1 = __msa_copy_s_w((v4i32) dst0, 2);
+
+      SD(out0, nxt);
+      nxt += 8;
+      SW(out1, nxt);
+      nxt += 4;
+   }
+}
+
+void png_read_filter_row_paeth4_msa(png_row_infop row_info,
+                                    png_bytep row,
+                                    png_const_bytep prev_row)
+{
+   int32_t count, rp_end;
+   png_bytep nxt;
+   png_const_bytep prev_nxt;
+   int32_t inp0, inp1, res0;
+   v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9;
+   v16u8 src10, src11, src12, src13, dst0, dst1;
+   v8i16 vec0, vec1, vec2;
+   v16u8 zero = { 0 };
+
+   nxt = row;
+   prev_nxt = prev_row;
+
+   inp0 = LW(nxt);
+   inp1 = LW(prev_nxt);
+   prev_nxt += 4;
+   src0 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp0);
+   src1 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp1);
+
+   src1 += src0;
+   res0 = __msa_copy_s_w((v4i32) src1, 0);
+
+   SW(res0, nxt);
+   nxt += 4;
+
+   /* Remainder */
+   rp_end = row_info->rowbytes - 4;
+
+   for (count = 0; count < rp_end; count += 16)
+   {
+      src2 = LD_UB(prev_nxt);
+      prev_nxt += 16;
+      src6 = LD_UB(prev_row);
+      prev_row += 16;
+      src10 = LD_UB(nxt);
+
+      SLDI_B3_0_UB(src2, src6, src10, src3, src7, src11, 4);
+      SLDI_B3_0_UB(src2, src6, src10, src4, src8, src12, 8);
+      SLDI_B3_0_UB(src2, src6, src10, src5, src9, src13, 12);
+      ILVR_B2_SH(src2, src6, src1, src6, vec0, vec1);
+      HSUB_UB2_SH(vec0, vec1, vec0, vec1);
+      vec2 = vec0 + vec1;
+      ADD_ABS_H3_SH(vec0, vec1, vec2, vec0, vec1, vec2);
+      CMP_AND_SELECT(vec0, vec1, vec2, src1, src2, src6, src10);
+      ILVR_B2_SH(src3, src7, src10, src7, vec0, vec1);
+      HSUB_UB2_SH(vec0, vec1, vec0, vec1);
+      vec2 = vec0 + vec1;
+      ADD_ABS_H3_SH(vec0, vec1, vec2, vec0, vec1, vec2);
+      CMP_AND_SELECT(vec0, vec1, vec2, src10, src3, src7, src11);
+      ILVR_B2_SH(src4, src8, src11, src8, vec0, vec1);
+      HSUB_UB2_SH(vec0, vec1, vec0, vec1);
+      vec2 = vec0 + vec1;
+      ADD_ABS_H3_SH(vec0, vec1, vec2, vec0, vec1, vec2);
+      CMP_AND_SELECT(vec0, vec1, vec2, src11, src4, src8, src12);
+      ILVR_B2_SH(src5, src9, src12, src9, vec0, vec1);
+      HSUB_UB2_SH(vec0, vec1, vec0, vec1);
+      vec2 = vec0 + vec1;
+      ADD_ABS_H3_SH(vec0, vec1, vec2, vec0, vec1, vec2);
+      CMP_AND_SELECT(vec0, vec1, vec2, src12, src5, src9, src13);
+      src1 = src13;
+      ILVEV_W2_UB(src10, src11, src12, src1, dst0, dst1);
+      dst0 = (v16u8) __msa_pckev_d((v2i64) dst1, (v2i64) dst0);
+
+      ST_UB(dst0, nxt);
+      nxt += 16;
+   }
+}
+
+void png_read_filter_row_paeth3_msa(png_row_infop row_info,
+                                    png_bytep row,
+                                    png_const_bytep prev_row)
+{
+   int32_t count, rp_end;
+   png_bytep nxt;
+   png_const_bytep prev_nxt;
+   int64_t out0;
+   int32_t inp0, inp1, out1;
+   int16_t out2;
+   v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, dst0, dst1;
+   v16u8 src10, src11, src12, src13;
+   v8i16 vec0, vec1, vec2;
+   v16u8 zero = { 0 };
+   v16i8 mask0 = { 0, 1, 2, 16, 17, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+   v16i8 mask1 = { 0, 1, 2, 3, 4, 5, 16, 17, 18, 19, 20, 21, 0, 0, 0, 0 };
+
+   nxt = row;
+   prev_nxt = prev_row;
+
+   inp0 = LW(nxt);
+   inp1 = LW(prev_nxt);
+   prev_nxt += 3;
+   src0 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp0);
+   src1 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp1);
+
+   src1 += src0;
+   out2 = __msa_copy_s_h((v8i16) src1, 0);
+
+   SH(out2, nxt);
+   nxt += 2;
+   nxt[0] = src1[2];
+   nxt++;
+
+   /* Remainder */
+   rp_end = row_info->rowbytes - 3;
+
+   for (count = 0; count < rp_end; count += 12)
+   {
+      src2 = LD_UB(prev_nxt);
+      prev_nxt += 12;
+      src6 = LD_UB(prev_row);
+      prev_row += 12;
+      src10 = LD_UB(nxt);
+
+      SLDI_B3_0_UB(src2, src6, src10, src3, src7, src11, 3);
+      SLDI_B3_0_UB(src2, src6, src10, src4, src8, src12, 6);
+      SLDI_B3_0_UB(src2, src6, src10, src5, src9, src13, 9);
+      ILVR_B2_SH(src2, src6, src1, src6, vec0, vec1);
+      HSUB_UB2_SH(vec0, vec1, vec0, vec1);
+      vec2 = vec0 + vec1;
+      ADD_ABS_H3_SH(vec0, vec1, vec2, vec0, vec1, vec2);
+      CMP_AND_SELECT(vec0, vec1, vec2, src1, src2, src6, src10);
+      ILVR_B2_SH(src3, src7, src10, src7, vec0, vec1);
+      HSUB_UB2_SH(vec0, vec1, vec0, vec1);
+      vec2 = vec0 + vec1;
+      ADD_ABS_H3_SH(vec0, vec1, vec2, vec0, vec1, vec2);
+      CMP_AND_SELECT(vec0, vec1, vec2, src10, src3, src7, src11);
+      ILVR_B2_SH(src4, src8, src11, src8, vec0, vec1);
+      HSUB_UB2_SH(vec0, vec1, vec0, vec1);
+      vec2 = vec0 + vec1;
+      ADD_ABS_H3_SH(vec0, vec1, vec2, vec0, vec1, vec2);
+      CMP_AND_SELECT(vec0, vec1, vec2, src11, src4, src8, src12);
+      ILVR_B2_SH(src5, src9, src12, src9, vec0, vec1);
+      HSUB_UB2_SH(vec0, vec1, vec0, vec1);
+      vec2 = vec0 + vec1;
+      ADD_ABS_H3_SH(vec0, vec1, vec2, vec0, vec1, vec2);
+      CMP_AND_SELECT(vec0, vec1, vec2, src12, src5, src9, src13);
+      src1 = src13;
+      VSHF_B2_UB(src10, src11, src12, src13, mask0, mask0, dst0, dst1);
+      dst0 = (v16u8) __msa_vshf_b(mask1, (v16i8) dst1, (v16i8) dst0);
+      out0 = __msa_copy_s_d((v2i64) dst0, 0);
+      out1 = __msa_copy_s_w((v4i32) dst0, 2);
+
+      SD(out0, nxt);
+      nxt += 8;
+      SW(out1, nxt);
+      nxt += 4;
+   }
+}
+
+#endif /* PNG_MIPS_MSA_OPT > 0 */
+#endif /* PNG_MIPS_MSA_IMPLEMENTATION == 1 (intrinsics) */
+#endif /* READ */
diff --git a/Engine/lib/lpng/mips/mips_init.c b/Engine/lib/lpng/mips/mips_init.c
new file mode 100644
index 000000000..8dd283dee
--- /dev/null
+++ b/Engine/lib/lpng/mips/mips_init.c
@@ -0,0 +1,130 @@
+
+/* mips_init.c - MSA optimised filter functions
+ *
+ * Copyright (c) 2018 Cosmin Truta
+ * Copyright (c) 2016 Glenn Randers-Pehrson
+ * Written by Mandar Sahastrabuddhe, 2016.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+/* Below, after checking __linux__, various non-C90 POSIX 1003.1 functions are
+ * called.
+ */
+#define _POSIX_SOURCE 1
+
+#include <stdio.h>
+#include "../pngpriv.h"
+
+#ifdef PNG_READ_SUPPORTED
+
+#if PNG_MIPS_MSA_OPT > 0
+#ifdef PNG_MIPS_MSA_CHECK_SUPPORTED /* Do run-time checks */
+/* WARNING: it is strongly recommended that you do not build libpng with
+ * run-time checks for CPU features if at all possible.  In the case of the MIPS
+ * MSA instructions there is no processor-specific way of detecting the
+ * presence of the required support, therefore run-time detection is extremely
+ * OS specific.
+ *
+ * You may set the macro PNG_MIPS_MSA_FILE to the file name of file containing
+ * a fragment of C source code which defines the png_have_msa function.  There
+ * are a number of implementations in contrib/mips-msa, but the only one that
+ * has partial support is contrib/mips-msa/linux.c - a generic Linux
+ * implementation which reads /proc/cpufino.
+ */
+#ifndef PNG_MIPS_MSA_FILE
+#  ifdef __linux__
+#     define PNG_MIPS_MSA_FILE "contrib/mips-msa/linux.c"
+#  endif
+#endif
+
+#ifdef PNG_MIPS_MSA_FILE
+
+#include <signal.h> /* for sig_atomic_t */
+static int png_have_msa(png_structp png_ptr);
+#include PNG_MIPS_MSA_FILE
+
+#else  /* PNG_MIPS_MSA_FILE */
+#  error "PNG_MIPS_MSA_FILE undefined: no support for run-time MIPS MSA checks"
+#endif /* PNG_MIPS_MSA_FILE */
+#endif /* PNG_MIPS_MSA_CHECK_SUPPORTED */
+
+#ifndef PNG_ALIGNED_MEMORY_SUPPORTED
+#  error "ALIGNED_MEMORY is required; set: -DPNG_ALIGNED_MEMORY_SUPPORTED"
+#endif
+
+void
+png_init_filter_functions_msa(png_structp pp, unsigned int bpp)
+{
+   /* The switch statement is compiled in for MIPS_MSA_API, the call to
+    * png_have_msa is compiled in for MIPS_MSA_CHECK. If both are defined
+    * the check is only performed if the API has not set the MSA option on
+    * or off explicitly. In this case the check controls what happens.
+    */
+
+#ifdef PNG_MIPS_MSA_API_SUPPORTED
+   switch ((pp->options >> PNG_MIPS_MSA) & 3)
+   {
+      case PNG_OPTION_UNSET:
+         /* Allow the run-time check to execute if it has been enabled -
+          * thus both API and CHECK can be turned on.  If it isn't supported
+          * this case will fall through to the 'default' below, which just
+          * returns.
+          */
+#endif /* PNG_MIPS_MSA_API_SUPPORTED */
+#ifdef PNG_MIPS_MSA_CHECK_SUPPORTED
+         {
+            static volatile sig_atomic_t no_msa = -1; /* not checked */
+
+            if (no_msa < 0)
+               no_msa = !png_have_msa(pp);
+
+            if (no_msa)
+               return;
+         }
+#ifdef PNG_MIPS_MSA_API_SUPPORTED
+         break;
+#endif
+#endif /* PNG_MIPS_MSA_CHECK_SUPPORTED */
+
+#ifdef PNG_MIPS_MSA_API_SUPPORTED
+      default: /* OFF or INVALID */
+         return;
+
+      case PNG_OPTION_ON:
+         /* Option turned on */
+         break;
+   }
+#endif
+
+   /* IMPORTANT: any new external functions used here must be declared using
+    * PNG_INTERNAL_FUNCTION in ../pngpriv.h.  This is required so that the
+    * 'prefix' option to configure works:
+    *
+    *    ./configure --with-libpng-prefix=foobar_
+    *
+    * Verify you have got this right by running the above command, doing a build
+    * and examining pngprefix.h; it must contain a #define for every external
+    * function you add.  (Notice that this happens automatically for the
+    * initialization function.)
+    */
+   pp->read_filter[PNG_FILTER_VALUE_UP-1] = png_read_filter_row_up_msa;
+
+   if (bpp == 3)
+   {
+      pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub3_msa;
+      pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg3_msa;
+      pp->read_filter[PNG_FILTER_VALUE_PAETH-1] = png_read_filter_row_paeth3_msa;
+   }
+
+   else if (bpp == 4)
+   {
+      pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub4_msa;
+      pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg4_msa;
+      pp->read_filter[PNG_FILTER_VALUE_PAETH-1] = png_read_filter_row_paeth4_msa;
+   }
+}
+#endif /* PNG_MIPS_MSA_OPT > 0 */
+#endif /* READ */
diff --git a/Engine/lib/lpng/missing b/Engine/lib/lpng/missing
new file mode 100755
index 000000000..625aeb118
--- /dev/null
+++ b/Engine/lib/lpng/missing
@@ -0,0 +1,215 @@
+#! /bin/sh
+# Common wrapper for a few potentially missing GNU programs.
+
+scriptversion=2018-03-07.03; # UTC
+
+# Copyright (C) 1996-2018 Free Software Foundation, Inc.
+# Originally written by Fran,cois Pinard <pinard@iro.umontreal.ca>, 1996.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+if test $# -eq 0; then
+  echo 1>&2 "Try '$0 --help' for more information"
+  exit 1
+fi
+
+case $1 in
+
+  --is-lightweight)
+    # Used by our autoconf macros to check whether the available missing
+    # script is modern enough.
+    exit 0
+    ;;
+
+  --run)
+    # Back-compat with the calling convention used by older automake.
+    shift
+    ;;
+
+  -h|--h|--he|--hel|--help)
+    echo "\
+$0 [OPTION]... PROGRAM [ARGUMENT]...
+
+Run 'PROGRAM [ARGUMENT]...', returning a proper advice when this fails due
+to PROGRAM being missing or too old.
+
+Options:
+  -h, --help      display this help and exit
+  -v, --version   output version information and exit
+
+Supported PROGRAM values:
+  aclocal   autoconf  autoheader   autom4te  automake  makeinfo
+  bison     yacc      flex         lex       help2man
+
+Version suffixes to PROGRAM as well as the prefixes 'gnu-', 'gnu', and
+'g' are ignored when checking the name.
+
+Send bug reports to <bug-automake@gnu.org>."
+    exit $?
+    ;;
+
+  -v|--v|--ve|--ver|--vers|--versi|--versio|--version)
+    echo "missing $scriptversion (GNU Automake)"
+    exit $?
+    ;;
+
+  -*)
+    echo 1>&2 "$0: unknown '$1' option"
+    echo 1>&2 "Try '$0 --help' for more information"
+    exit 1
+    ;;
+
+esac
+
+# Run the given program, remember its exit status.
+"$@"; st=$?
+
+# If it succeeded, we are done.
+test $st -eq 0 && exit 0
+
+# Also exit now if we it failed (or wasn't found), and '--version' was
+# passed; such an option is passed most likely to detect whether the
+# program is present and works.
+case $2 in --version|--help) exit $st;; esac
+
+# Exit code 63 means version mismatch.  This often happens when the user
+# tries to use an ancient version of a tool on a file that requires a
+# minimum version.
+if test $st -eq 63; then
+  msg="probably too old"
+elif test $st -eq 127; then
+  # Program was missing.
+  msg="missing on your system"
+else
+  # Program was found and executed, but failed.  Give up.
+  exit $st
+fi
+
+perl_URL=https://www.perl.org/
+flex_URL=https://github.com/westes/flex
+gnu_software_URL=https://www.gnu.org/software
+
+program_details ()
+{
+  case $1 in
+    aclocal|automake)
+      echo "The '$1' program is part of the GNU Automake package:"
+      echo "<$gnu_software_URL/automake>"
+      echo "It also requires GNU Autoconf, GNU m4 and Perl in order to run:"
+      echo "<$gnu_software_URL/autoconf>"
+      echo "<$gnu_software_URL/m4/>"
+      echo "<$perl_URL>"
+      ;;
+    autoconf|autom4te|autoheader)
+      echo "The '$1' program is part of the GNU Autoconf package:"
+      echo "<$gnu_software_URL/autoconf/>"
+      echo "It also requires GNU m4 and Perl in order to run:"
+      echo "<$gnu_software_URL/m4/>"
+      echo "<$perl_URL>"
+      ;;
+  esac
+}
+
+give_advice ()
+{
+  # Normalize program name to check for.
+  normalized_program=`echo "$1" | sed '
+    s/^gnu-//; t
+    s/^gnu//; t
+    s/^g//; t'`
+
+  printf '%s\n' "'$1' is $msg."
+
+  configure_deps="'configure.ac' or m4 files included by 'configure.ac'"
+  case $normalized_program in
+    autoconf*)
+      echo "You should only need it if you modified 'configure.ac',"
+      echo "or m4 files included by it."
+      program_details 'autoconf'
+      ;;
+    autoheader*)
+      echo "You should only need it if you modified 'acconfig.h' or"
+      echo "$configure_deps."
+      program_details 'autoheader'
+      ;;
+    automake*)
+      echo "You should only need it if you modified 'Makefile.am' or"
+      echo "$configure_deps."
+      program_details 'automake'
+      ;;
+    aclocal*)
+      echo "You should only need it if you modified 'acinclude.m4' or"
+      echo "$configure_deps."
+      program_details 'aclocal'
+      ;;
+   autom4te*)
+      echo "You might have modified some maintainer files that require"
+      echo "the 'autom4te' program to be rebuilt."
+      program_details 'autom4te'
+      ;;
+    bison*|yacc*)
+      echo "You should only need it if you modified a '.y' file."
+      echo "You may want to install the GNU Bison package:"
+      echo "<$gnu_software_URL/bison/>"
+      ;;
+    lex*|flex*)
+      echo "You should only need it if you modified a '.l' file."
+      echo "You may want to install the Fast Lexical Analyzer package:"
+      echo "<$flex_URL>"
+      ;;
+    help2man*)
+      echo "You should only need it if you modified a dependency" \
+           "of a man page."
+      echo "You may want to install the GNU Help2man package:"
+      echo "<$gnu_software_URL/help2man/>"
+    ;;
+    makeinfo*)
+      echo "You should only need it if you modified a '.texi' file, or"
+      echo "any other file indirectly affecting the aspect of the manual."
+      echo "You might want to install the Texinfo package:"
+      echo "<$gnu_software_URL/texinfo/>"
+      echo "The spurious makeinfo call might also be the consequence of"
+      echo "using a buggy 'make' (AIX, DU, IRIX), in which case you might"
+      echo "want to install GNU make:"
+      echo "<$gnu_software_URL/make/>"
+      ;;
+    *)
+      echo "You might have modified some files without having the proper"
+      echo "tools for further handling them.  Check the 'README' file, it"
+      echo "often tells you about the needed prerequisites for installing"
+      echo "this package.  You may also peek at any GNU archive site, in"
+      echo "case some other package contains this missing '$1' program."
+      ;;
+  esac
+}
+
+give_advice "$1" | sed -e '1s/^/WARNING: /' \
+                       -e '2,$s/^/         /' >&2
+
+# Propagate the correct exit status (expected to be 127 for a program
+# not found, 63 for a program that failed due to version mismatch).
+exit $st
+
+# Local variables:
+# eval: (add-hook 'before-save-hook 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC0"
+# time-stamp-end: "; # UTC"
+# End:
diff --git a/Engine/lib/lpng/png.5 b/Engine/lib/lpng/png.5
index b0cbd2cfa..c2da95c45 100644
--- a/Engine/lib/lpng/png.5
+++ b/Engine/lib/lpng/png.5
@@ -1,47 +1,49 @@
-.TH PNG 5 "April 1, 2017"
+.TH PNG 5 "April 14, 2019"
 .SH NAME
 png \- Portable Network Graphics (PNG) format
+
 .SH DESCRIPTION
 PNG (Portable Network Graphics) is an extensible file format for the
-lossless, portable, well-compressed storage of raster images. PNG provides
-a patent-free replacement for GIF and can also replace many
+lossless, portable, well-compressed storage of raster images.  PNG
+provides a patent-free replacement for GIF, and can also replace many
 common uses of TIFF. Indexed-color, grayscale, and truecolor images are
-supported, plus an optional alpha channel. Sample depths range from
+supported, plus an optional alpha channel.  Sample depths range from
 1 to 16 bits.
 .br
-
-PNG is designed to work well in online viewing applications, such as the
-World Wide Web, so it is fully streamable with a progressive display
-option. PNG is robust, providing both full file integrity checking and
-fast, simple detection of common transmission errors. Also, PNG can store
-gamma and chromaticity data for improved color matching on heterogeneous
-platforms.
+PNG is designed to work well in online viewing applications, such
+as the World Wide Web, so it is fully streamable with a progressive
+display option.  PNG is robust, providing both full file integrity
+checking and fast, simple detection of common transmission errors.
+Also, PNG can store gamma and chromaticity data for improved color
+matching on heterogeneous platforms.
 
 .SH "SEE ALSO"
 .BR "libpng"(3), " libpngpf"(3), " zlib"(3), " deflate"(5), " " and " zlib"(5)
 .LP
-PNG specification (second edition), November 2003:
+PNG Specification (Second Edition), November 2003:
 .IP
 .br
-  <https://www.w3.org/TR/2003/REC-PNG-20031110/
-PNG 1.2 specification, July 1999:
+https://www.w3.org/TR/2003/REC-PNG-20031110/
+.LP
+PNG 1.2 Specification, July 1999:
 .IP
 .br
 https://png-mng.sourceforge.io/pub/png/spec/1.2/
 .LP
-PNG 1.0 specification, October 1996:
+PNG 1.0 Specification, October 1996:
 .IP
 .br
 RFC 2083
-.IP
 .br
 https://www.ietf.org/rfc/rfc2083.txt
+.IP
 .br
-or (as a W3C Recommendation) at
+or W3C Recommendation
 .br
 https://www.w3.org/TR/REC-png-961001
+
 .SH AUTHORS
-This man page: Glenn Randers-Pehrson
+This man page: Cosmin Truta, Glenn Randers-Pehrson
 .LP
 Portable Network Graphics (PNG) Specification (Second Edition)
 Information technology - Computer graphics and image processing -
@@ -53,22 +55,30 @@ Glenn Randers-Pehrson and others (png-list).
 .LP
 Portable Network Graphics (PNG) Specification Version 1.0 (October 1, 1996):
 Thomas Boutell and others (png-list).
-.LP
 
-
-.SH COPYRIGHT NOTICE
+.SH COPYRIGHT
 .LP
-This man page is Copyright (c) 1998-2006 Glenn Randers-Pehrson.  See png.h
-for conditions of use and distribution.
+This man page is
+.br
+Copyright (c) 2018-2019 Cosmin Truta.
+.br
+Copyright (c) 1998-2006 Glenn Randers-Pehrson.
+.br
+See png.h for conditions of use and distribution.
 .LP
 The PNG Specification (Second Edition) is
+.br
 Copyright (c) 2003 W3C. (MIT, ERCIM, Keio), All Rights Reserved.
 .LP
-The PNG-1.2 specification is copyright (c) 1999 Glenn Randers-Pehrson.
+The PNG-1.2 Specification is
+.br
+Copyright (c) 1999 Glenn Randers-Pehrson.
+.br
 See the specification for conditions of use and distribution.
 .LP
-The PNG-1.0 specification is copyright (c) 1996 Massachusetts Institute of
-Technology.  See the specification for conditions of use and distribution.
-.LP
+The PNG-1.0 Specification is
+.br
+Copyright (c) 1996 Massachusetts Institute of Technology.
+.br
+See the specification for conditions of use and distribution.
 .\" end of man page
-
diff --git a/Engine/lib/lpng/png.c b/Engine/lib/lpng/png.c
index ff02c5651..757c755f9 100644
--- a/Engine/lib/lpng/png.c
+++ b/Engine/lib/lpng/png.c
@@ -1,10 +1,10 @@
 
 /* png.c - location for general purpose libpng functions
  *
- * Last changed in libpng 1.6.33 [September 28, 2017]
- * Copyright (c) 1998-2002,2004,2006-2017 Glenn Randers-Pehrson
- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ * Copyright (c) 2018-2019 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -14,7 +14,7 @@
 #include "pngpriv.h"
 
 /* Generate a compiler error if there is an old png.h in the search path. */
-typedef png_libpng_version_1_6_34 Your_png_h_is_not_version_1_6_34;
+typedef png_libpng_version_1_6_37 Your_png_h_is_not_version_1_6_37;
 
 #ifdef __GNUC__
 /* The version tests may need to be added to, but the problem warning has
@@ -71,7 +71,7 @@ png_set_sig_bytes(png_structrp png_ptr, int num_bytes)
  * PNG signature (this is the same behavior as strcmp, memcmp, etc).
  */
 int PNGAPI
-png_sig_cmp(png_const_bytep sig, png_size_t start, png_size_t num_to_check)
+png_sig_cmp(png_const_bytep sig, size_t start, size_t num_to_check)
 {
    png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
 
@@ -136,7 +136,7 @@ png_reset_crc(png_structrp png_ptr)
  * trouble of calculating it.
  */
 void /* PRIVATE */
-png_calculate_crc(png_structrp png_ptr, png_const_bytep ptr, png_size_t length)
+png_calculate_crc(png_structrp png_ptr, png_const_bytep ptr, size_t length)
 {
    int need_crc = 1;
 
@@ -421,7 +421,7 @@ png_destroy_info_struct(png_const_structrp png_ptr, png_infopp info_ptr_ptr)
  * those cases where it does anything other than a memset.
  */
 PNG_FUNCTION(void,PNGAPI
-png_info_init_3,(png_infopp ptr_ptr, png_size_t png_info_struct_size),
+png_info_init_3,(png_infopp ptr_ptr, size_t png_info_struct_size),
     PNG_DEPRECATED)
 {
    png_inforp info_ptr = *ptr_ptr;
@@ -736,7 +736,7 @@ png_save_int_32(png_bytep buf, png_int_32 i)
 int PNGAPI
 png_convert_to_rfc1123_buffer(char out[29], png_const_timep ptime)
 {
-   static PNG_CONST char short_months[12][4] =
+   static const char short_months[12][4] =
         {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
          "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
 
@@ -814,20 +814,14 @@ png_get_copyright(png_const_structrp png_ptr)
 #ifdef PNG_STRING_COPYRIGHT
    return PNG_STRING_COPYRIGHT
 #else
-#  ifdef __STDC__
    return PNG_STRING_NEWLINE \
-      "libpng version 1.6.34 - September 29, 2017" PNG_STRING_NEWLINE \
-      "Copyright (c) 1998-2002,2004,2006-2017 Glenn Randers-Pehrson" \
+      "libpng version 1.6.37" PNG_STRING_NEWLINE \
+      "Copyright (c) 2018-2019 Cosmin Truta" PNG_STRING_NEWLINE \
+      "Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson" \
       PNG_STRING_NEWLINE \
       "Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \
       "Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \
       PNG_STRING_NEWLINE;
-#  else
-   return "libpng version 1.6.34 - September 29, 2017\
-      Copyright (c) 1998-2002,2004,2006-2017 Glenn Randers-Pehrson\
-      Copyright (c) 1996-1997 Andreas Dilger\
-      Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.";
-#  endif
 #endif
 }
 
@@ -942,7 +936,7 @@ png_handle_as_unknown(png_const_structrp png_ptr, png_const_bytep chunk_name)
 
    /* The code is the fifth byte after each four byte string.  Historically this
     * code was always searched from the end of the list, this is no longer
-    * necessary because the 'set' routine handles duplicate entries correcty.
+    * necessary because the 'set' routine handles duplicate entries correctly.
     */
    do /* num_chunk_list > 0, so at least one */
    {
@@ -1121,7 +1115,7 @@ png_colorspace_set_gamma(png_const_structrp png_ptr,
     png_colorspacerp colorspace, png_fixed_point gAMA)
 {
    /* Changed in libpng-1.5.4 to limit the values to ensure overflow can't
-    * occur.  Since the fixed point representation is asymetrical it is
+    * occur.  Since the fixed point representation is asymmetrical it is
     * possible for 1/gamma to overflow the limit of 21474 and this means the
     * gamma value must be at least 5/100000 and hence at most 20000.0.  For
     * safety the limits here are a little narrower.  The values are 0.00016 to
@@ -2067,7 +2061,7 @@ png_icc_check_header(png_const_structrp png_ptr, png_colorspacerp colorspace,
     */
 
    /* Data checks (could be skipped).  These checks must be independent of the
-    * version number; however, the version number doesn't accomodate changes in
+    * version number; however, the version number doesn't accommodate changes in
     * the header fields (just the known tags and the interpretation of the
     * data.)
     */
@@ -2707,7 +2701,7 @@ png_check_IHDR(png_const_structrp png_ptr,
 
 #if defined(PNG_sCAL_SUPPORTED) || defined(PNG_pCAL_SUPPORTED)
 /* ASCII to fp functions */
-/* Check an ASCII formated floating point value, see the more detailed
+/* Check an ASCII formatted floating point value, see the more detailed
  * comments in pngpriv.h
  */
 /* The following is used internally to preserve the sticky flags */
@@ -2715,11 +2709,11 @@ png_check_IHDR(png_const_structrp png_ptr,
 #define png_fp_set(state, value) ((state) = (value) | ((state) & PNG_FP_STICKY))
 
 int /* PRIVATE */
-png_check_fp_number(png_const_charp string, png_size_t size, int *statep,
+png_check_fp_number(png_const_charp string, size_t size, int *statep,
     png_size_tp whereami)
 {
    int state = *statep;
-   png_size_t i = *whereami;
+   size_t i = *whereami;
 
    while (i < size)
    {
@@ -2842,10 +2836,10 @@ PNG_FP_End:
 
 /* The same but for a complete string. */
 int
-png_check_fp_string(png_const_charp string, png_size_t size)
+png_check_fp_string(png_const_charp string, size_t size)
 {
    int        state=0;
-   png_size_t char_index=0;
+   size_t char_index=0;
 
    if (png_check_fp_number(string, size, &state, &char_index) != 0 &&
       (char_index == size || string[char_index] == 0))
@@ -2906,7 +2900,7 @@ png_pow10(int power)
 #pragma GCC diagnostic warning "-Wstrict-overflow=2"
 #endif /* GCC_STRICT_OVERFLOW */
 void /* PRIVATE */
-png_ascii_from_fp(png_const_structrp png_ptr, png_charp ascii, png_size_t size,
+png_ascii_from_fp(png_const_structrp png_ptr, png_charp ascii, size_t size,
     double fp, unsigned int precision)
 {
    /* We use standard functions from math.h, but not printf because
@@ -3134,11 +3128,11 @@ png_ascii_from_fp(png_const_structrp png_ptr, png_charp ascii, png_size_t size,
             /* The total output count (max) is now 4+precision */
 
             /* Check for an exponent, if we don't need one we are
-             * done and just need to terminate the string.  At
-             * this point exp_b10==(-1) is effectively a flag - it got
-             * to '-1' because of the decrement after outputting
-             * the decimal point above (the exponent required is
-             * *not* -1!)
+             * done and just need to terminate the string.  At this
+             * point, exp_b10==(-1) is effectively a flag: it got
+             * to '-1' because of the decrement, after outputting
+             * the decimal point above. (The exponent required is
+             * *not* -1.)
              */
             if (exp_b10 >= (-1) && exp_b10 <= 2)
             {
@@ -3237,7 +3231,7 @@ png_ascii_from_fp(png_const_structrp png_ptr, png_charp ascii, png_size_t size,
  */
 void /* PRIVATE */
 png_ascii_from_fixed(png_const_structrp png_ptr, png_charp ascii,
-    png_size_t size, png_fixed_point fp)
+    size_t size, png_fixed_point fp)
 {
    /* Require space for 10 decimal digits, a decimal point, a minus sign and a
     * trailing \0, 13 characters:
@@ -3976,18 +3970,18 @@ png_gamma_correct(png_structrp png_ptr, unsigned int value,
  */
 static void
 png_build_16bit_table(png_structrp png_ptr, png_uint_16pp *ptable,
-    PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val)
+    unsigned int shift, png_fixed_point gamma_val)
 {
    /* Various values derived from 'shift': */
-   PNG_CONST unsigned int num = 1U << (8U - shift);
+   unsigned int num = 1U << (8U - shift);
 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
    /* CSE the division and work round wacky GCC warnings (see the comments
     * in png_gamma_8bit_correct for where these come from.)
     */
-   PNG_CONST double fmax = 1./(((png_int_32)1 << (16U - shift))-1);
+   double fmax = 1.0 / (((png_int_32)1 << (16U - shift)) - 1);
 #endif
-   PNG_CONST unsigned int max = (1U << (16U - shift))-1U;
-   PNG_CONST unsigned int max_by_2 = 1U << (15U-shift);
+   unsigned int max = (1U << (16U - shift)) - 1U;
+   unsigned int max_by_2 = 1U << (15U - shift);
    unsigned int i;
 
    png_uint_16pp table = *ptable =
@@ -4053,10 +4047,10 @@ png_build_16bit_table(png_structrp png_ptr, png_uint_16pp *ptable,
  */
 static void
 png_build_16to8_table(png_structrp png_ptr, png_uint_16pp *ptable,
-    PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val)
+    unsigned int shift, png_fixed_point gamma_val)
 {
-   PNG_CONST unsigned int num = 1U << (8U - shift);
-   PNG_CONST unsigned int max = (1U << (16U - shift))-1U;
+   unsigned int num = 1U << (8U - shift);
+   unsigned int max = (1U << (16U - shift))-1U;
    unsigned int i;
    png_uint_32 last;
 
@@ -4121,7 +4115,7 @@ png_build_16to8_table(png_structrp png_ptr, png_uint_16pp *ptable,
  */
 static void
 png_build_8bit_table(png_structrp png_ptr, png_bytepp ptable,
-    PNG_CONST png_fixed_point gamma_val)
+    png_fixed_point gamma_val)
 {
    unsigned int i;
    png_bytep table = *ptable = (png_bytep)png_malloc(png_ptr, 256);
@@ -4344,7 +4338,7 @@ png_set_option(png_structrp png_ptr, int option, int onoff)
       png_uint_32 setting = (2U + (onoff != 0)) << option;
       png_uint_32 current = png_ptr->options;
 
-      png_ptr->options = (png_uint_32)(((current & ~mask) | setting) & 0xff);
+      png_ptr->options = (png_uint_32)((current & ~mask) | setting);
 
       return (int)(current & mask) >> option;
    }
@@ -4594,8 +4588,7 @@ png_image_free(png_imagep image)
    if (image != NULL && image->opaque != NULL &&
       image->opaque->error_buf == NULL)
    {
-      /* Ignore errors here: */
-      (void)png_safe_execute(image, png_image_free_function, image);
+      png_image_free_function(image);
       image->opaque = NULL;
    }
 }
diff --git a/Engine/lib/lpng/png.h b/Engine/lib/lpng/png.h
index 4c873f5c2..139eb0dc0 100644
--- a/Engine/lib/lpng/png.h
+++ b/Engine/lib/lpng/png.h
@@ -1,68 +1,105 @@
 
 /* png.h - header file for PNG reference library
  *
- * libpng version 1.6.34, September 29, 2017
+ * libpng version 1.6.37 - April 14, 2019
  *
- * Copyright (c) 1998-2002,2004,2006-2017 Glenn Randers-Pehrson
- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ * Copyright (c) 2018-2019 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
  *
- * This code is released under the libpng license (See LICENSE, below)
+ * This code is released under the libpng license. (See LICENSE, below.)
  *
  * Authors and maintainers:
  *   libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat
  *   libpng versions 0.89, June 1996, through 0.96, May 1997: Andreas Dilger
- *   libpng versions 0.97, January 1998, through 1.6.34, September 29, 2017:
- *     Glenn Randers-Pehrson.
+ *   libpng versions 0.97, January 1998, through 1.6.35, July 2018:
+ *     Glenn Randers-Pehrson
+ *   libpng versions 1.6.36, December 2018, through 1.6.37, April 2019:
+ *     Cosmin Truta
  *   See also "Contributing Authors", below.
  */
 
 /*
- * COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:
+ * COPYRIGHT NOTICE, DISCLAIMER, and LICENSE
+ * =========================================
  *
- * If you modify libpng you may insert additional notices immediately following
- * this sentence.
+ * PNG Reference Library License version 2
+ * ---------------------------------------
  *
- * This code is released under the libpng license.
+ *  * Copyright (c) 1995-2019 The PNG Reference Library Authors.
+ *  * Copyright (c) 2018-2019 Cosmin Truta.
+ *  * Copyright (c) 2000-2002, 2004, 2006-2018 Glenn Randers-Pehrson.
+ *  * Copyright (c) 1996-1997 Andreas Dilger.
+ *  * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
  *
- * libpng versions 1.0.7, July 1, 2000 through 1.6.34, September 29, 2017 are
- * Copyright (c) 2000-2002, 2004, 2006-2017 Glenn Randers-Pehrson, are
+ * The software is supplied "as is", without warranty of any kind,
+ * express or implied, including, without limitation, the warranties
+ * of merchantability, fitness for a particular purpose, title, and
+ * non-infringement.  In no event shall the Copyright owners, or
+ * anyone distributing the software, be liable for any damages or
+ * other liability, whether in contract, tort or otherwise, arising
+ * from, out of, or in connection with the software, or the use or
+ * other dealings in the software, even if advised of the possibility
+ * of such damage.
+ *
+ * Permission is hereby granted to use, copy, modify, and distribute
+ * this software, or portions hereof, for any purpose, without fee,
+ * subject to the following restrictions:
+ *
+ *  1. The origin of this software must not be misrepresented; you
+ *     must not claim that you wrote the original software.  If you
+ *     use this software in a product, an acknowledgment in the product
+ *     documentation would be appreciated, but is not required.
+ *
+ *  2. Altered source versions must be plainly marked as such, and must
+ *     not be misrepresented as being the original software.
+ *
+ *  3. This Copyright notice may not be removed or altered from any
+ *     source or altered source distribution.
+ *
+ *
+ * PNG Reference Library License version 1 (for libpng 0.5 through 1.6.35)
+ * -----------------------------------------------------------------------
+ *
+ * libpng versions 1.0.7, July 1, 2000, through 1.6.35, July 15, 2018 are
+ * Copyright (c) 2000-2002, 2004, 2006-2018 Glenn Randers-Pehrson, are
  * derived from libpng-1.0.6, and are distributed according to the same
  * disclaimer and license as libpng-1.0.6 with the following individuals
  * added to the list of Contributing Authors:
  *
- *    Simon-Pierre Cadieux
- *    Eric S. Raymond
- *    Mans Rullgard
- *    Cosmin Truta
- *    Gilles Vollant
- *    James Yu
- *    Mandar Sahastrabuddhe
- *    Google Inc.
- *    Vadim Barkov
+ *     Simon-Pierre Cadieux
+ *     Eric S. Raymond
+ *     Mans Rullgard
+ *     Cosmin Truta
+ *     Gilles Vollant
+ *     James Yu
+ *     Mandar Sahastrabuddhe
+ *     Google Inc.
+ *     Vadim Barkov
  *
  * and with the following additions to the disclaimer:
  *
- *    There is no warranty against interference with your enjoyment of the
- *    library or against infringement.  There is no warranty that our
- *    efforts or the library will fulfill any of your particular purposes
- *    or needs.  This library is provided with all faults, and the entire
- *    risk of satisfactory quality, performance, accuracy, and effort is with
- *    the user.
+ *     There is no warranty against interference with your enjoyment of
+ *     the library or against infringement.  There is no warranty that our
+ *     efforts or the library will fulfill any of your particular purposes
+ *     or needs.  This library is provided with all faults, and the entire
+ *     risk of satisfactory quality, performance, accuracy, and effort is
+ *     with the user.
  *
  * Some files in the "contrib" directory and some configure-generated
- * files that are distributed with libpng have other copyright owners and
+ * files that are distributed with libpng have other copyright owners, and
  * are released under other open source licenses.
  *
  * libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are
  * Copyright (c) 1998-2000 Glenn Randers-Pehrson, are derived from
  * libpng-0.96, and are distributed according to the same disclaimer and
- * license as libpng-0.96, with the following individuals added to the list
- * of Contributing Authors:
+ * license as libpng-0.96, with the following individuals added to the
+ * list of Contributing Authors:
  *
- *    Tom Lane
- *    Glenn Randers-Pehrson
- *    Willem van Schaik
+ *     Tom Lane
+ *     Glenn Randers-Pehrson
+ *     Willem van Schaik
  *
  * libpng versions 0.89, June 1996, through 0.96, May 1997, are
  * Copyright (c) 1996-1997 Andreas Dilger, are derived from libpng-0.88,
@@ -70,14 +107,14 @@
  * libpng-0.88, with the following individuals added to the list of
  * Contributing Authors:
  *
- *    John Bowler
- *    Kevin Bracey
- *    Sam Bushell
- *    Magnus Holmgren
- *    Greg Roelofs
- *    Tom Tanner
+ *     John Bowler
+ *     Kevin Bracey
+ *     Sam Bushell
+ *     Magnus Holmgren
+ *     Greg Roelofs
+ *     Tom Tanner
  *
- * Some files in the "scripts" directory have other copyright owners
+ * Some files in the "scripts" directory have other copyright owners,
  * but are released under this license.
  *
  * libpng versions 0.5, May 1995, through 0.88, January 1996, are
@@ -86,62 +123,49 @@
  * For the purposes of this copyright and license, "Contributing Authors"
  * is defined as the following set of individuals:
  *
- *    Andreas Dilger
- *    Dave Martindale
- *    Guy Eric Schalnat
- *    Paul Schmidt
- *    Tim Wegner
+ *     Andreas Dilger
+ *     Dave Martindale
+ *     Guy Eric Schalnat
+ *     Paul Schmidt
+ *     Tim Wegner
  *
- * The PNG Reference Library is supplied "AS IS".  The Contributing Authors
- * and Group 42, Inc. disclaim all warranties, expressed or implied,
- * including, without limitation, the warranties of merchantability and of
- * fitness for any purpose.  The Contributing Authors and Group 42, Inc.
- * assume no liability for direct, indirect, incidental, special, exemplary,
- * or consequential damages, which may result from the use of the PNG
- * Reference Library, even if advised of the possibility of such damage.
+ * The PNG Reference Library is supplied "AS IS".  The Contributing
+ * Authors and Group 42, Inc. disclaim all warranties, expressed or
+ * implied, including, without limitation, the warranties of
+ * merchantability and of fitness for any purpose.  The Contributing
+ * Authors and Group 42, Inc. assume no liability for direct, indirect,
+ * incidental, special, exemplary, or consequential damages, which may
+ * result from the use of the PNG Reference Library, even if advised of
+ * the possibility of such damage.
  *
  * Permission is hereby granted to use, copy, modify, and distribute this
  * source code, or portions hereof, for any purpose, without fee, subject
  * to the following restrictions:
  *
- *   1. The origin of this source code must not be misrepresented.
+ *  1. The origin of this source code must not be misrepresented.
  *
- *   2. Altered versions must be plainly marked as such and must not
- *      be misrepresented as being the original source.
+ *  2. Altered versions must be plainly marked as such and must not
+ *     be misrepresented as being the original source.
  *
- *   3. This Copyright notice may not be removed or altered from any
- *      source or altered source distribution.
+ *  3. This Copyright notice may not be removed or altered from any
+ *     source or altered source distribution.
  *
- * The Contributing Authors and Group 42, Inc. specifically permit, without
- * fee, and encourage the use of this source code as a component to
- * supporting the PNG file format in commercial products.  If you use this
- * source code in a product, acknowledgment is not required but would be
- * appreciated.
+ * The Contributing Authors and Group 42, Inc. specifically permit,
+ * without fee, and encourage the use of this source code as a component
+ * to supporting the PNG file format in commercial products.  If you use
+ * this source code in a product, acknowledgment is not required but would
+ * be appreciated.
  *
  * END OF COPYRIGHT NOTICE, DISCLAIMER, and LICENSE.
  *
- * TRADEMARK:
+ * TRADEMARK
+ * =========
  *
- * The name "libpng" has not been registered by the Copyright owner
+ * The name "libpng" has not been registered by the Copyright owners
  * as a trademark in any jurisdiction.  However, because libpng has
  * been distributed and maintained world-wide, continually since 1995,
- * the Copyright owner claims "common-law trademark protection" in any
+ * the Copyright owners claim "common-law trademark protection" in any
  * jurisdiction where common-law trademark is recognized.
- *
- * OSI CERTIFICATION:
- *
- * Libpng is OSI Certified Open Source Software.  OSI Certified Open Source is
- * a certification mark of the Open Source Initiative. OSI has not addressed
- * the additional disclaimers inserted at version 1.0.7.
- *
- * EXPORT CONTROL:
- *
- * The Copyright owner believes that the Export Control Classification
- * Number (ECCN) for libpng is EAR99, which means not subject to export
- * controls or International Traffic in Arms Regulations (ITAR) because
- * it is open source, publicly available software, that does not contain
- * any encryption software.  See the EAR, paragraphs 734.3(b)(3) and
- * 734.7(b).
  */
 
 /*
@@ -207,23 +231,25 @@
  *    1.0.7rc1-2               1    10007  2.1.0.7rc1-2 (binary compatible)
  *    1.0.7                    1    10007  (still compatible)
  *    ...
- *    1.0.19                  10    10019  10.so.0.19[.0]
+ *    1.0.69                  10    10069  10.so.0.69[.0]
  *    ...
- *    1.2.59                  13    10257  12.so.0.59[.0]
+ *    1.2.59                  13    10259  12.so.0.59[.0]
  *    ...
- *    1.5.30                  15    10527  15.so.15.30[.0]
+ *    1.4.20                  14    10420  14.so.0.20[.0]
  *    ...
- *    1.6.34                  16    10633  16.so.16.34[.0]
+ *    1.5.30                  15    10530  15.so.15.30[.0]
+ *    ...
+ *    1.6.37                  16    10637  16.so.16.37[.0]
  *
- *    Henceforth the source version will match the shared-library major
- *    and minor numbers; the shared-library major version number will be
- *    used for changes in backward compatibility, as it is intended.  The
- *    PNG_LIBPNG_VER macro, which is not used within libpng but is available
- *    for applications, is an unsigned integer of the form xyyzz corresponding
- *    to the source version x.y.z (leading zeros in y and z).  Beta versions
- *    were given the previous public release number plus a letter, until
- *    version 1.0.6j; from then on they were given the upcoming public
- *    release number plus "betaNN" or "rcNN".
+ *    Henceforth the source version will match the shared-library major and
+ *    minor numbers; the shared-library major version number will be used for
+ *    changes in backward compatibility, as it is intended.
+ *    The PNG_LIBPNG_VER macro, which is not used within libpng but is
+ *    available for applications, is an unsigned integer of the form XYYZZ
+ *    corresponding to the source version X.Y.Z (leading zeros in Y and Z).
+ *    Beta versions were given the previous public release number plus a
+ *    letter, until version 1.0.6j; from then on they were given the upcoming
+ *    public release number plus "betaNN" or "rcNN".
  *
  *    Binary incompatibility exists only when applications make direct access
  *    to the info_ptr or png_ptr members through png.h, and the compiled
@@ -233,65 +259,8 @@
  *    in binary compatibility (e.g., when a new feature is added).
  *
  * See libpng.txt or libpng.3 for more information.  The PNG specification
- * is available as a W3C Recommendation and as an ISO Specification,
- * <https://www.w3.org/TR/2003/REC-PNG-20031110/
- */
-
-/*
- * Y2K compliance in libpng:
- * =========================
- *
- *    September 29, 2017
- *
- *    Since the PNG Development group is an ad-hoc body, we can't make
- *    an official declaration.
- *
- *    This is your unofficial assurance that libpng from version 0.71 and
- *    upward through 1.6.34 are Y2K compliant.  It is my belief that
- *    earlier versions were also Y2K compliant.
- *
- *    Libpng only has two year fields.  One is a 2-byte unsigned integer
- *    that will hold years up to 65535.  The other, which is deprecated,
- *    holds the date in text format, and will hold years up to 9999.
- *
- *    The integer is
- *        "png_uint_16 year" in png_time_struct.
- *
- *    The string is
- *        "char time_buffer[29]" in png_struct.  This is no longer used
- *    in libpng-1.6.x and will be removed from libpng-1.7.0.
- *
- *    There are seven time-related functions:
- *        png.c: png_convert_to_rfc_1123_buffer() in png.c
- *          (formerly png_convert_to_rfc_1123() prior to libpng-1.5.x and
- *          png_convert_to_rfc_1152() in error prior to libpng-0.98)
- *        png_convert_from_struct_tm() in pngwrite.c, called in pngwrite.c
- *        png_convert_from_time_t() in pngwrite.c
- *        png_get_tIME() in pngget.c
- *        png_handle_tIME() in pngrutil.c, called in pngread.c
- *        png_set_tIME() in pngset.c
- *        png_write_tIME() in pngwutil.c, called in pngwrite.c
- *
- *    All handle dates properly in a Y2K environment.  The
- *    png_convert_from_time_t() function calls gmtime() to convert from system
- *    clock time, which returns (year - 1900), which we properly convert to
- *    the full 4-digit year.  There is a possibility that libpng applications
- *    are not passing 4-digit years into the png_convert_to_rfc_1123_buffer()
- *    function, or that they are incorrectly passing only a 2-digit year
- *    instead of "year - 1900" into the png_convert_from_struct_tm() function,
- *    but this is not under our control.  The libpng documentation has always
- *    stated that it works with 4-digit years, and the APIs have been
- *    documented as such.
- *
- *    The tIME chunk itself is also Y2K compliant.  It uses a 2-byte unsigned
- *    integer to hold the year, and can hold years as large as 65535.
- *
- *    zlib, upon which libpng depends, is also Y2K compliant.  It contains
- *    no date-related code.
- *
- *       Glenn Randers-Pehrson
- *       libpng maintainer
- *       PNG Development Group
+ * is available as a W3C Recommendation and as an ISO/IEC Standard; see
+ * <https://www.w3.org/TR/2003/REC-PNG-20031110/>
  */
 
 #ifndef PNG_H
@@ -309,8 +278,8 @@
  */
 
 /* Version information for png.h - this should match the version in png.c */
-#define PNG_LIBPNG_VER_STRING "1.6.34"
-#define PNG_HEADER_VERSION_STRING " libpng version 1.6.34 - September 29, 2017\n"
+#define PNG_LIBPNG_VER_STRING "1.6.37"
+#define PNG_HEADER_VERSION_STRING " libpng version 1.6.37 - April 14, 2019\n"
 
 #define PNG_LIBPNG_VER_SONUM   16
 #define PNG_LIBPNG_VER_DLLNUM  16
@@ -318,12 +287,11 @@
 /* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */
 #define PNG_LIBPNG_VER_MAJOR   1
 #define PNG_LIBPNG_VER_MINOR   6
-#define PNG_LIBPNG_VER_RELEASE 34
+#define PNG_LIBPNG_VER_RELEASE 37
 
-/* This should match the numeric part of the final component of
- * PNG_LIBPNG_VER_STRING, omitting any leading zero:
+/* This should be zero for a public release, or non-zero for a
+ * development version.  [Deprecated]
  */
-
 #define PNG_LIBPNG_VER_BUILD  0
 
 /* Release Status */
@@ -343,13 +311,14 @@
 
 #define PNG_LIBPNG_BUILD_BASE_TYPE PNG_LIBPNG_BUILD_STABLE
 
-/* Careful here.  At one time, Guy wanted to use 082, but that would be octal.
- * We must not include leading zeros.
- * Versions 0.7 through 1.0.0 were in the range 0 to 100 here (only
- * version 1.0.0 was mis-numbered 100 instead of 10000).  From
- * version 1.0.1 it's    xxyyzz, where x=major, y=minor, z=release
+/* Careful here.  At one time, Guy wanted to use 082, but that
+ * would be octal.  We must not include leading zeros.
+ * Versions 0.7 through 1.0.0 were in the range 0 to 100 here
+ * (only version 1.0.0 was mis-numbered 100 instead of 10000).
+ * From version 1.0.1 it is:
+ * XXYYZZ, where XX=major, YY=minor, ZZ=release
  */
-#define PNG_LIBPNG_VER 10634 /* 1.6.34 */
+#define PNG_LIBPNG_VER 10637 /* 1.6.37 */
 
 /* Library configuration: these options cannot be changed after
  * the library has been built.
@@ -459,7 +428,7 @@ extern "C" {
 /* This triggers a compiler error in png.c, if png.c and png.h
  * do not agree upon the version number.
  */
-typedef char* png_libpng_version_1_6_34;
+typedef char* png_libpng_version_1_6_37;
 
 /* Basic control structions.  Read libpng-manual.txt or libpng.3 for more info.
  *
@@ -600,8 +569,8 @@ typedef struct png_text_struct
    png_charp key;          /* keyword, 1-79 character description of "text" */
    png_charp text;         /* comment, may be an empty string (ie "")
                               or a NULL pointer */
-   png_size_t text_length; /* length of the text string */
-   png_size_t itxt_length; /* length of the itxt string */
+   size_t text_length;     /* length of the text string */
+   size_t itxt_length;     /* length of the itxt string */
    png_charp lang;         /* language code, 0-79 characters
                               or a NULL pointer */
    png_charp lang_key;     /* keyword translated UTF-8 string, 0 or more
@@ -654,7 +623,7 @@ typedef struct png_unknown_chunk_t
 {
    png_byte name[5]; /* Textual chunk name with '\0' terminator */
    png_byte *data;   /* Data, should not be modified on read! */
-   png_size_t size;
+   size_t size;
 
    /* On write 'location' must be set using the flag values listed below.
     * Notice that on read it is set by libpng however the values stored have
@@ -679,7 +648,7 @@ typedef png_unknown_chunk * * png_unknown_chunkpp;
 /* Maximum positive integer used in PNG is (2^31)-1 */
 #define PNG_UINT_31_MAX ((png_uint_32)0x7fffffffL)
 #define PNG_UINT_32_MAX ((png_uint_32)(-1))
-#define PNG_SIZE_MAX ((png_size_t)(-1))
+#define PNG_SIZE_MAX ((size_t)(-1))
 
 /* These are constants for fixed point values encoded in the
  * PNG specification manner (x100000)
@@ -785,7 +754,7 @@ typedef png_unknown_chunk * * png_unknown_chunkpp;
 typedef struct png_row_info_struct
 {
    png_uint_32 width;    /* width of row */
-   png_size_t rowbytes;  /* number of bytes in row */
+   size_t rowbytes;      /* number of bytes in row */
    png_byte color_type;  /* color type of row */
    png_byte bit_depth;   /* bit depth of row */
    png_byte channels;    /* number of channels (1, 2, 3, or 4) */
@@ -804,7 +773,7 @@ typedef png_row_info * * png_row_infopp;
  * expected to return the read data in the buffer.
  */
 typedef PNG_CALLBACK(void, *png_error_ptr, (png_structp, png_const_charp));
-typedef PNG_CALLBACK(void, *png_rw_ptr, (png_structp, png_bytep, png_size_t));
+typedef PNG_CALLBACK(void, *png_rw_ptr, (png_structp, png_bytep, size_t));
 typedef PNG_CALLBACK(void, *png_flush_ptr, (png_structp));
 typedef PNG_CALLBACK(void, *png_read_status_ptr, (png_structp, png_uint_32,
     int));
@@ -941,8 +910,8 @@ PNG_EXPORT(2, void, png_set_sig_bytes, (png_structrp png_ptr, int num_bytes));
  * signature, and non-zero otherwise.  Having num_to_check == 0 or
  * start > 7 will always fail (ie return non-zero).
  */
-PNG_EXPORT(3, int, png_sig_cmp, (png_const_bytep sig, png_size_t start,
-    png_size_t num_to_check));
+PNG_EXPORT(3, int, png_sig_cmp, (png_const_bytep sig, size_t start,
+    size_t num_to_check));
 
 /* Simple signature checking function.  This is the same as calling
  * png_check_sig(sig, n) := !png_sig_cmp(sig, 0, n).
@@ -961,11 +930,11 @@ PNG_EXPORTA(5, png_structp, png_create_write_struct,
     png_error_ptr warn_fn),
     PNG_ALLOCATED);
 
-PNG_EXPORT(6, png_size_t, png_get_compression_buffer_size,
+PNG_EXPORT(6, size_t, png_get_compression_buffer_size,
     (png_const_structrp png_ptr));
 
 PNG_EXPORT(7, void, png_set_compression_buffer_size, (png_structrp png_ptr,
-    png_size_t size));
+    size_t size));
 
 /* Moved from pngconf.h in 1.4.0 and modified to ensure setjmp/longjmp
  * match up.
@@ -1018,7 +987,7 @@ PNG_EXPORT(13, void, png_write_sig, (png_structrp png_ptr));
 
 /* Write a PNG chunk - size, type, (optional) data, CRC. */
 PNG_EXPORT(14, void, png_write_chunk, (png_structrp png_ptr, png_const_bytep
-    chunk_name, png_const_bytep data, png_size_t length));
+    chunk_name, png_const_bytep data, size_t length));
 
 /* Write the start of a PNG chunk - length and chunk name. */
 PNG_EXPORT(15, void, png_write_chunk_start, (png_structrp png_ptr,
@@ -1026,7 +995,7 @@ PNG_EXPORT(15, void, png_write_chunk_start, (png_structrp png_ptr,
 
 /* Write the data of a PNG chunk started with png_write_chunk_start(). */
 PNG_EXPORT(16, void, png_write_chunk_data, (png_structrp png_ptr,
-    png_const_bytep data, png_size_t length));
+    png_const_bytep data, size_t length));
 
 /* Finish a chunk started with png_write_chunk_start() (includes CRC). */
 PNG_EXPORT(17, void, png_write_chunk_end, (png_structrp png_ptr));
@@ -1040,7 +1009,7 @@ PNG_EXPORTA(18, png_infop, png_create_info_struct, (png_const_structrp png_ptr),
  * the API will be removed in the future.
  */
 PNG_EXPORTA(19, void, png_info_init_3, (png_infopp info_ptr,
-    png_size_t png_info_struct_size), PNG_DEPRECATED);
+    size_t png_info_struct_size), PNG_DEPRECATED);
 
 /* Writes all the PNG information before the image. */
 PNG_EXPORT(20, void, png_write_info_before_PLTE,
@@ -1137,7 +1106,7 @@ PNG_EXPORT(35, void, png_build_grayscale_palette, (int bit_depth,
  * corresponding composited pixel, and the color channels are unassociated
  * (not premultiplied).  The gamma encoded color channels must be scaled
  * according to the contribution and to do this it is necessary to undo
- * the encoding, scale the color values, perform the composition and reencode
+ * the encoding, scale the color values, perform the composition and re-encode
  * the values.  This is the 'PNG' mode.
  *
  * The alternative is to 'associate' the alpha with the color information by
@@ -1193,7 +1162,7 @@ PNG_FIXED_EXPORT(228, void, png_set_alpha_mode_fixed, (png_structrp png_ptr,
  *
  * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC);
  *    In this case the output is assumed to be something like an sRGB conformant
- *    display preceeded by a power-law lookup table of power 1.45.  This is how
+ *    display preceded by a power-law lookup table of power 1.45.  This is how
  *    early Mac systems behaved.
  *
  * png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_GAMMA_LINEAR);
@@ -1240,7 +1209,7 @@ PNG_FIXED_EXPORT(228, void, png_set_alpha_mode_fixed, (png_structrp png_ptr,
  *
  * When the default gamma of PNG files doesn't match the output gamma.
  *    If you have PNG files with no gamma information png_set_alpha_mode allows
- *    you to provide a default gamma, but it also sets the ouput gamma to the
+ *    you to provide a default gamma, but it also sets the output gamma to the
  *    matching value.  If you know your PNG files have a gamma that doesn't
  *    match the output you can take advantage of the fact that
  *    png_set_alpha_mode always sets the output gamma but only sets the PNG
@@ -1691,7 +1660,7 @@ PNG_EXPORT(218, png_byte, png_get_current_pass_number, (png_const_structrp));
  *           chunk will cause an error at this point unless it is to be saved.
  * positive: The chunk was handled, libpng will ignore/discard it.
  *
- * See "INTERACTION WTIH USER CHUNK CALLBACKS" below for important notes about
+ * See "INTERACTION WITH USER CHUNK CALLBACKS" below for important notes about
  * how this behavior will change in libpng 1.7
  */
 PNG_EXPORT(88, void, png_set_read_user_chunk_fn, (png_structrp png_ptr,
@@ -1716,7 +1685,7 @@ PNG_EXPORT(91, png_voidp, png_get_progressive_ptr,
 
 /* Function to be called when data becomes available */
 PNG_EXPORT(92, void, png_process_data, (png_structrp png_ptr,
-    png_inforp info_ptr, png_bytep buffer, png_size_t buffer_size));
+    png_inforp info_ptr, png_bytep buffer, size_t buffer_size));
 
 /* A function which may be called *only* within png_process_data to stop the
  * processing of any more data.  The function returns the number of bytes
@@ -1725,7 +1694,7 @@ PNG_EXPORT(92, void, png_process_data, (png_structrp png_ptr,
  * 'save' is set to true the routine will first save all the pending data and
  * will always return 0.
  */
-PNG_EXPORT(219, png_size_t, png_process_data_pause, (png_structrp, int save));
+PNG_EXPORT(219, size_t, png_process_data_pause, (png_structrp, int save));
 
 /* A function which may be called *only* outside (after) a call to
  * png_process_data.  It returns the number of bytes of data to skip in the
@@ -1870,7 +1839,7 @@ PNG_EXPORT(110, png_uint_32, png_get_valid, (png_const_structrp png_ptr,
     png_const_inforp info_ptr, png_uint_32 flag));
 
 /* Returns number of bytes needed to hold a transformed row. */
-PNG_EXPORT(111, png_size_t, png_get_rowbytes, (png_const_structrp png_ptr,
+PNG_EXPORT(111, size_t, png_get_rowbytes, (png_const_structrp png_ptr,
     png_const_inforp info_ptr));
 
 #ifdef PNG_INFO_IMAGE_SUPPORTED
@@ -2013,12 +1982,12 @@ PNG_FIXED_EXPORT(233, void, png_set_cHRM_XYZ_fixed, (png_const_structrp png_ptr,
 PNG_EXPORT(246, png_uint_32, png_get_eXIf, (png_const_structrp png_ptr,
     png_inforp info_ptr, png_bytep *exif));
 PNG_EXPORT(247, void, png_set_eXIf, (png_const_structrp png_ptr,
-    png_inforp info_ptr, const png_bytep exif));
+    png_inforp info_ptr, png_bytep exif));
 
 PNG_EXPORT(248, png_uint_32, png_get_eXIf_1, (png_const_structrp png_ptr,
     png_const_inforp info_ptr, png_uint_32 *num_exif, png_bytep *exif));
 PNG_EXPORT(249, void, png_set_eXIf_1, (png_const_structrp png_ptr,
-    png_inforp info_ptr, const png_uint_32 num_exif, const png_bytep exif));
+    png_inforp info_ptr, png_uint_32 num_exif, png_bytep exif));
 #endif
 
 #ifdef PNG_gAMA_SUPPORTED
@@ -2239,7 +2208,7 @@ PNG_EXPORT(171, void, png_set_sCAL_s, (png_const_structrp png_ptr,
  * to specifying "NEVER", however when "AS_DEFAULT" is used for specific chunks
  * it simply resets the behavior to the libpng default.
  *
- * INTERACTION WTIH USER CHUNK CALLBACKS:
+ * INTERACTION WITH USER CHUNK CALLBACKS:
  * The per-chunk handling is always used when there is a png_user_chunk_ptr
  * callback and the callback returns 0; the chunk is then always stored *unless*
  * it is critical and the per-chunk setting is other than ALWAYS.  Notice that
@@ -2658,7 +2627,7 @@ PNG_EXPORT(243, int, png_get_palette_max, (png_const_structp png_ptr,
  * The simplified API hides the details of both libpng and the PNG file format
  * itself.  It allows PNG files to be read into a very limited number of
  * in-memory bitmap formats or to be written from the same formats.  If these
- * formats do not accomodate your needs then you can, and should, use the more
+ * formats do not accommodate your needs then you can, and should, use the more
  * sophisticated APIs above - these support a wide variety of in-memory formats
  * and a wide variety of sophisticated transformations to those formats as well
  * as a wide variety of APIs to manipulate ancillary information.
@@ -2764,7 +2733,7 @@ typedef struct
  *
  * When the simplified API needs to convert between sRGB and linear colorspaces,
  * the actual sRGB transfer curve defined in the sRGB specification (see the
- * article at https://en.wikipedia.org/wiki/SRGB) is used, not the gamma=1/2.2
+ * article at <https://en.wikipedia.org/wiki/SRGB>) is used, not the gamma=1/2.2
  * approximation used elsewhere in libpng.
  *
  * When an alpha channel is present it is expected to denote pixel coverage
@@ -2967,7 +2936,7 @@ typedef struct
  * 'flags' field of png_image.
  */
 #define PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB 0x01
-   /* This indicates the the RGB values of the in-memory bitmap do not
+   /* This indicates that the RGB values of the in-memory bitmap do not
     * correspond to the red, green and blue end-points defined by sRGB.
     */
 
@@ -3020,7 +2989,7 @@ PNG_EXPORT(235, int, png_image_begin_read_from_stdio, (png_imagep image,
 #endif /* STDIO */
 
 PNG_EXPORT(236, int, png_image_begin_read_from_memory, (png_imagep image,
-   png_const_voidp memory, png_size_t size));
+   png_const_voidp memory, size_t size));
    /* The PNG header is read from the given memory buffer. */
 
 PNG_EXPORT(237, int, png_image_finish_read, (png_imagep image,
@@ -3133,7 +3102,7 @@ PNG_EXPORT(245, int, png_image_write_to_memory, (png_imagep image, void *memory,
     * than or equal to the original value.
     *
     * If the function returns false and *memory_bytes was not changed an error
-    * occured during write.  If *memory_bytes was changed, or is not 0 if
+    * occurred during write.  If *memory_bytes was changed, or is not 0 if
     * 'memory' was NULL, the write would have succeeded but for the memory
     * buffer being too small.  *memory_bytes contains the required number of
     * bytes and will be bigger that the original value.
@@ -3217,7 +3186,7 @@ PNG_EXPORT(245, int, png_image_write_to_memory, (png_imagep image, void *memory,
  * option and 'onoff' is 0 (off) or non-0 (on).  The value returned is given
  * by the PNG_OPTION_ defines below.
  *
- * HARDWARE: normally hardware capabilites, such as the Intel SSE instructions,
+ * HARDWARE: normally hardware capabilities, such as the Intel SSE instructions,
  *           are detected at run time, however sometimes it may be impossible
  *           to do this in user mode, in which case it is necessary to discover
  *           the capabilities in an OS specific way.  Such capabilities are
diff --git a/Engine/lib/lpng/pngconf.h b/Engine/lib/lpng/pngconf.h
index c0f15547b..927a769db 100644
--- a/Engine/lib/lpng/pngconf.h
+++ b/Engine/lib/lpng/pngconf.h
@@ -1,11 +1,12 @@
 
-/* pngconf.h - machine configurable file for libpng
+/* pngconf.h - machine-configurable file for libpng
  *
- * libpng version 1.6.32, August 24, 2017
+ * libpng version 1.6.37
  *
- * Copyright (c) 1998-2002,2004,2006-2016 Glenn Randers-Pehrson
- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ * Copyright (c) 2018-2019 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2016,2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -57,14 +58,13 @@
 
 #endif /* PNG_BUILDING_SYMBOL_TABLE */
 
-/* Prior to 1.6.0 it was possible to turn off 'const' in declarations using
- * PNG_NO_CONST; this is no longer supported except for data declarations which
- * apparently still cause problems in 2011 on some compilers.
+/* Prior to 1.6.0, it was possible to turn off 'const' in declarations,
+ * using PNG_NO_CONST.  This is no longer supported.
  */
 #define PNG_CONST const /* backward compatibility only */
 
-/* This controls optimization of the reading of 16-bit and 32-bit values
- * from PNG files.  It can be set on a per-app-file basis - it
+/* This controls optimization of the reading of 16-bit and 32-bit
+ * values from PNG files.  It can be set on a per-app-file basis: it
  * just changes whether a macro is used when the function is called.
  * The library builder sets the default; if read functions are not
  * built into the library the macro implementation is forced on.
@@ -127,7 +127,7 @@
  *
  * These cases only differ if the operating system does not use the C
  * calling convention, at present this just means the above cases
- * (x86 DOS/Windows sytems) and, even then, this does not apply to
+ * (x86 DOS/Windows systems) and, even then, this does not apply to
  * Cygwin running on those systems.
  *
  * Note that the value must be defined in pnglibconf.h so that what
@@ -515,8 +515,10 @@
 #  error "libpng requires an unsigned 32-bit (or more) type"
 #endif
 
-/* Prior to 1.6.0 it was possible to disable the use of size_t, 1.6.0, however,
- * requires an ISOC90 compiler and relies on consistent behavior of sizeof.
+/* Prior to 1.6.0, it was possible to disable the use of size_t and ptrdiff_t.
+ * From 1.6.0 onwards, an ISO C90 compiler, as well as a standard-compliant
+ * behavior of sizeof and ptrdiff_t are required.
+ * The legacy typedefs are provided here for backwards compatibility.
  */
 typedef size_t png_size_t;
 typedef ptrdiff_t png_ptrdiff_t;
@@ -537,13 +539,12 @@ typedef ptrdiff_t png_ptrdiff_t;
 #  endif
 #endif
 
-/* png_alloc_size_t is guaranteed to be no smaller than png_size_t, and no
- * smaller than png_uint_32.  Casts from png_size_t or png_uint_32 to
- * png_alloc_size_t are not necessary; in fact, it is recommended not to use
- * them at all so that the compiler can complain when something turns out to be
- * problematic.
+/* png_alloc_size_t is guaranteed to be no smaller than size_t, and no smaller
+ * than png_uint_32.  Casts from size_t or png_uint_32 to png_alloc_size_t are
+ * not necessary; in fact, it is recommended not to use them at all, so that
+ * the compiler can complain when something turns out to be problematic.
  *
- * Casts in the other direction (from png_alloc_size_t to png_size_t or
+ * Casts in the other direction (from png_alloc_size_t to size_t or
  * png_uint_32) should be explicitly applied; however, we do not expect to
  * encounter practical situations that require such conversions.
  *
@@ -553,7 +554,7 @@ typedef ptrdiff_t png_ptrdiff_t;
 #ifdef PNG_SMALL_SIZE_T
    typedef png_uint_32 png_alloc_size_t;
 #else
-   typedef png_size_t png_alloc_size_t;
+   typedef size_t png_alloc_size_t;
 #endif
 
 /* Prior to 1.6.0 libpng offered limited support for Microsoft C compiler
@@ -589,8 +590,8 @@ typedef char                  * png_charp;
 typedef const char            * png_const_charp;
 typedef png_fixed_point       * png_fixed_point_p;
 typedef const png_fixed_point * png_const_fixed_point_p;
-typedef png_size_t            * png_size_tp;
-typedef const png_size_t      * png_const_size_tp;
+typedef size_t                * png_size_tp;
+typedef const size_t          * png_const_size_tp;
 
 #ifdef PNG_STDIO_SUPPORTED
 typedef FILE            * png_FILE_p;
diff --git a/Engine/lib/lpng/pngdebug.h b/Engine/lib/lpng/pngdebug.h
index 15a7ed0c9..00d5a4569 100644
--- a/Engine/lib/lpng/pngdebug.h
+++ b/Engine/lib/lpng/pngdebug.h
@@ -1,10 +1,10 @@
 
 /* pngdebug.h - Debugging macros for libpng, also used in pngtest.c
  *
- * Last changed in libpng 1.6.8 [December 19, 2013]
+ * Copyright (c) 2018 Cosmin Truta
  * Copyright (c) 1998-2002,2004,2006-2013 Glenn Randers-Pehrson
- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
diff --git a/Engine/lib/lpng/pngerror.c b/Engine/lib/lpng/pngerror.c
index ad48bfb98..ec3a709b9 100644
--- a/Engine/lib/lpng/pngerror.c
+++ b/Engine/lib/lpng/pngerror.c
@@ -1,10 +1,10 @@
 
 /* pngerror.c - stub functions for i/o and memory allocation
  *
- * Last changed in libpng 1.6.31 [July 27, 2017]
+ * Copyright (c) 2018 Cosmin Truta
  * Copyright (c) 1998-2002,2004,2006-2017 Glenn Randers-Pehrson
- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -425,7 +425,7 @@ png_app_error(png_const_structrp png_ptr, png_const_charp error_message)
  * if the character is invalid.
  */
 #define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))
-static PNG_CONST char png_digit[16] = {
+static const char png_digit[16] = {
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    'A', 'B', 'C', 'D', 'E', 'F'
 };
@@ -885,7 +885,7 @@ PNG_FUNCTION(void /* PRIVATE */, (PNGCBAPI
 png_safe_error),(png_structp png_nonconst_ptr, png_const_charp error_message),
     PNG_NORETURN)
 {
-   const png_const_structrp png_ptr = png_nonconst_ptr;
+   png_const_structrp png_ptr = png_nonconst_ptr;
    png_imagep image = png_voidcast(png_imagep, png_ptr->error_ptr);
 
    /* An error is always logged here, overwriting anything (typically a warning)
@@ -920,7 +920,7 @@ png_safe_error),(png_structp png_nonconst_ptr, png_const_charp error_message),
 void /* PRIVATE */ PNGCBAPI
 png_safe_warning(png_structp png_nonconst_ptr, png_const_charp warning_message)
 {
-   const png_const_structrp png_ptr = png_nonconst_ptr;
+   png_const_structrp png_ptr = png_nonconst_ptr;
    png_imagep image = png_voidcast(png_imagep, png_ptr->error_ptr);
 
    /* A warning is only logged if there is no prior warning or error. */
diff --git a/Engine/lib/lpng/pngget.c b/Engine/lib/lpng/pngget.c
index 26e9fb1c3..5abf1efd9 100644
--- a/Engine/lib/lpng/pngget.c
+++ b/Engine/lib/lpng/pngget.c
@@ -1,10 +1,10 @@
 
 /* pngget.c - retrieval of values from info struct
  *
- * Last changed in libpng 1.6.32 [August 24, 2017]
- * Copyright (c) 1998-2002,2004,2006-2017 Glenn Randers-Pehrson
- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ * Copyright (c) 2018 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -26,7 +26,7 @@ png_get_valid(png_const_structrp png_ptr, png_const_inforp info_ptr,
    return(0);
 }
 
-png_size_t PNGAPI
+size_t PNGAPI
 png_get_rowbytes(png_const_structrp png_ptr, png_const_inforp info_ptr)
 {
    if (png_ptr != NULL && info_ptr != NULL)
@@ -367,7 +367,7 @@ png_get_y_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr)
 static png_fixed_point
 png_fixed_inches_from_microns(png_const_structrp png_ptr, png_int_32 microns)
 {
-   /* Convert from metres * 1,000,000 to inches * 100,000, meters to
+   /* Convert from meters * 1,000,000 to inches * 100,000, meters to
     * inches is simply *(100/2.54), so we want *(10/2.54) == 500/127.
     * Notice that this can overflow - a warning is output and 0 is
     * returned.
@@ -741,8 +741,7 @@ png_get_iCCP(png_const_structrp png_ptr, png_inforp info_ptr,
 
    if (png_ptr != NULL && info_ptr != NULL &&
        (info_ptr->valid & PNG_INFO_iCCP) != 0 &&
-       name != NULL && compression_type != NULL && profile != NULL &&
-           proflen != NULL)
+       name != NULL && profile != NULL && proflen != NULL)
    {
       *name = info_ptr->iccp_name;
       *profile = info_ptr->iccp_profile;
@@ -750,11 +749,13 @@ png_get_iCCP(png_const_structrp png_ptr, png_inforp info_ptr,
       /* This is somewhat irrelevant since the profile data returned has
        * actually been uncompressed.
        */
-      *compression_type = PNG_COMPRESSION_TYPE_BASE;
+      if (compression_type != NULL)
+         *compression_type = PNG_COMPRESSION_TYPE_BASE;
       return (PNG_INFO_iCCP);
    }
 
    return (0);
+
 }
 #endif
 
@@ -1164,7 +1165,7 @@ png_get_user_chunk_ptr(png_const_structrp png_ptr)
 }
 #endif
 
-png_size_t PNGAPI
+size_t PNGAPI
 png_get_compression_buffer_size(png_const_structrp png_ptr)
 {
    if (png_ptr == NULL)
diff --git a/Engine/lib/lpng/pnginfo.h b/Engine/lib/lpng/pnginfo.h
index d5f6149db..1f98dedc4 100644
--- a/Engine/lib/lpng/pnginfo.h
+++ b/Engine/lib/lpng/pnginfo.h
@@ -1,10 +1,10 @@
 
 /* pnginfo.h - header file for PNG reference library
  *
- * Last changed in libpng 1.6.1 [March 28, 2013]
- * Copyright (c) 1998-2002,2004,2006-2013 Glenn Randers-Pehrson
- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ * Copyright (c) 2018 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2013,2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -55,10 +55,10 @@
 struct png_info_def
 {
    /* The following are necessary for every PNG file */
-   png_uint_32 width;  /* width of image in pixels (from IHDR) */
-   png_uint_32 height; /* height of image in pixels (from IHDR) */
-   png_uint_32 valid;  /* valid chunk data (see PNG_INFO_ below) */
-   png_size_t rowbytes; /* bytes needed to hold an untransformed row */
+   png_uint_32 width;       /* width of image in pixels (from IHDR) */
+   png_uint_32 height;      /* height of image in pixels (from IHDR) */
+   png_uint_32 valid;       /* valid chunk data (see PNG_INFO_ below) */
+   size_t rowbytes;         /* bytes needed to hold an untransformed row */
    png_colorp palette;      /* array of color values (valid & PNG_INFO_PLTE) */
    png_uint_16 num_palette; /* number of color entries in "palette" (PLTE) */
    png_uint_16 num_trans;   /* number of transparent palette color (tRNS) */
@@ -247,7 +247,7 @@ defined(PNG_READ_BACKGROUND_SUPPORTED)
    /* The sCAL chunk describes the actual physical dimensions of the
     * subject matter of the graphic.  The chunk contains a unit specification
     * a byte value, and two ASCII strings representing floating-point
-    * values.  The values are width and height corresponsing to one pixel
+    * values.  The values are width and height corresponding to one pixel
     * in the image.  Data values are valid if (valid & PNG_INFO_sCAL) is
     * non-zero.
     */
diff --git a/Engine/lib/lpng/pngmem.c b/Engine/lib/lpng/pngmem.c
index ff3ef7e88..09ed9c1c9 100644
--- a/Engine/lib/lpng/pngmem.c
+++ b/Engine/lib/lpng/pngmem.c
@@ -1,10 +1,10 @@
 
 /* pngmem.c - stub functions for memory allocation
  *
- * Last changed in libpng 1.6.26 [October 20, 2016]
+ * Copyright (c) 2018 Cosmin Truta
  * Copyright (c) 1998-2002,2004,2006-2014,2016 Glenn Randers-Pehrson
- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
diff --git a/Engine/lib/lpng/pngpread.c b/Engine/lib/lpng/pngpread.c
index fbe361dc3..e283627b7 100644
--- a/Engine/lib/lpng/pngpread.c
+++ b/Engine/lib/lpng/pngpread.c
@@ -1,10 +1,10 @@
 
 /* pngpread.c - read a png file in push mode
  *
- * Last changed in libpng 1.6.32 [August 24, 2017]
- * Copyright (c) 1998-2002,2004,2006-2017 Glenn Randers-Pehrson
- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ * Copyright (c) 2018 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -34,7 +34,7 @@ if (png_ptr->buffer_size < N) \
 
 void PNGAPI
 png_process_data(png_structrp png_ptr, png_inforp info_ptr,
-    png_bytep buffer, png_size_t buffer_size)
+    png_bytep buffer, size_t buffer_size)
 {
    if (png_ptr == NULL || info_ptr == NULL)
       return;
@@ -47,7 +47,7 @@ png_process_data(png_structrp png_ptr, png_inforp info_ptr,
    }
 }
 
-png_size_t PNGAPI
+size_t PNGAPI
 png_process_data_pause(png_structrp png_ptr, int save)
 {
    if (png_ptr != NULL)
@@ -60,7 +60,7 @@ png_process_data_pause(png_structrp png_ptr, int save)
       else
       {
          /* This includes any pending saved bytes: */
-         png_size_t remaining = png_ptr->buffer_size;
+         size_t remaining = png_ptr->buffer_size;
          png_ptr->buffer_size = 0;
 
          /* So subtract the saved buffer size, unless all the data
@@ -133,8 +133,8 @@ png_process_some_data(png_structrp png_ptr, png_inforp info_ptr)
 void /* PRIVATE */
 png_push_read_sig(png_structrp png_ptr, png_inforp info_ptr)
 {
-   png_size_t num_checked = png_ptr->sig_bytes, /* SAFE, does not exceed 8 */
-       num_to_check = 8 - num_checked;
+   size_t num_checked = png_ptr->sig_bytes; /* SAFE, does not exceed 8 */
+   size_t num_to_check = 8 - num_checked;
 
    if (png_ptr->buffer_size < num_to_check)
    {
@@ -418,7 +418,7 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
 }
 
 void PNGCBAPI
-png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)
+png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, size_t length)
 {
    png_bytep ptr;
 
@@ -428,7 +428,7 @@ png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)
    ptr = buffer;
    if (png_ptr->save_buffer_size != 0)
    {
-      png_size_t save_size;
+      size_t save_size;
 
       if (length < png_ptr->save_buffer_size)
          save_size = length;
@@ -445,7 +445,7 @@ png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)
    }
    if (length != 0 && png_ptr->current_buffer_size != 0)
    {
-      png_size_t save_size;
+      size_t save_size;
 
       if (length < png_ptr->current_buffer_size)
          save_size = length;
@@ -467,7 +467,7 @@ png_push_save_buffer(png_structrp png_ptr)
    {
       if (png_ptr->save_buffer_ptr != png_ptr->save_buffer)
       {
-         png_size_t i, istop;
+         size_t i, istop;
          png_bytep sp;
          png_bytep dp;
 
@@ -482,7 +482,7 @@ png_push_save_buffer(png_structrp png_ptr)
    if (png_ptr->save_buffer_size + png_ptr->current_buffer_size >
        png_ptr->save_buffer_max)
    {
-      png_size_t new_max;
+      size_t new_max;
       png_bytep old_buffer;
 
       if (png_ptr->save_buffer_size > PNG_SIZE_MAX -
@@ -494,7 +494,7 @@ png_push_save_buffer(png_structrp png_ptr)
       new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256;
       old_buffer = png_ptr->save_buffer;
       png_ptr->save_buffer = (png_bytep)png_malloc_warn(png_ptr,
-          (png_size_t)new_max);
+          (size_t)new_max);
 
       if (png_ptr->save_buffer == NULL)
       {
@@ -522,7 +522,7 @@ png_push_save_buffer(png_structrp png_ptr)
 
 void /* PRIVATE */
 png_push_restore_buffer(png_structrp png_ptr, png_bytep buffer,
-    png_size_t buffer_length)
+    size_t buffer_length)
 {
    png_ptr->current_buffer = buffer;
    png_ptr->current_buffer_size = buffer_length;
@@ -562,7 +562,7 @@ png_push_read_IDAT(png_structrp png_ptr)
 
    if (png_ptr->idat_size != 0 && png_ptr->save_buffer_size != 0)
    {
-      png_size_t save_size = png_ptr->save_buffer_size;
+      size_t save_size = png_ptr->save_buffer_size;
       png_uint_32 idat_size = png_ptr->idat_size;
 
       /* We want the smaller of 'idat_size' and 'current_buffer_size', but they
@@ -572,7 +572,7 @@ png_push_read_IDAT(png_structrp png_ptr)
        * will break on either 16-bit or 64-bit platforms.
        */
       if (idat_size < save_size)
-         save_size = (png_size_t)idat_size;
+         save_size = (size_t)idat_size;
 
       else
          idat_size = (png_uint_32)save_size;
@@ -589,7 +589,7 @@ png_push_read_IDAT(png_structrp png_ptr)
 
    if (png_ptr->idat_size != 0 && png_ptr->current_buffer_size != 0)
    {
-      png_size_t save_size = png_ptr->current_buffer_size;
+      size_t save_size = png_ptr->current_buffer_size;
       png_uint_32 idat_size = png_ptr->idat_size;
 
       /* We want the smaller of 'idat_size' and 'current_buffer_size', but they
@@ -598,7 +598,7 @@ png_push_read_IDAT(png_structrp png_ptr)
        * larger - this cannot overflow.
        */
       if (idat_size < save_size)
-         save_size = (png_size_t)idat_size;
+         save_size = (size_t)idat_size;
 
       else
          idat_size = (png_uint_32)save_size;
@@ -625,7 +625,7 @@ png_push_read_IDAT(png_structrp png_ptr)
 
 void /* PRIVATE */
 png_process_IDAT_data(png_structrp png_ptr, png_bytep buffer,
-    png_size_t buffer_length)
+    size_t buffer_length)
 {
    /* The caller checks for a non-zero buffer length. */
    if (!(buffer_length > 0) || buffer == NULL)
@@ -972,20 +972,20 @@ png_read_push_finish_row(png_structrp png_ptr)
    /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
 
    /* Start of interlace block */
-   static PNG_CONST png_byte png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
+   static const png_byte png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
 
    /* Offset to next interlace block */
-   static PNG_CONST png_byte png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
+   static const png_byte png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
 
    /* Start of interlace block in the y direction */
-   static PNG_CONST png_byte png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
+   static const png_byte png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
 
    /* Offset to next interlace block in the y direction */
-   static PNG_CONST png_byte png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
+   static const png_byte png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
 
    /* Height of interlace block.  This is not currently used - if you need
     * it, uncomment it here and in png.h
-   static PNG_CONST png_byte png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};
+   static const png_byte png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};
    */
 #endif
 
diff --git a/Engine/lib/lpng/pngpriv.h b/Engine/lib/lpng/pngpriv.h
index 1f2e90f2b..583c26f9b 100644
--- a/Engine/lib/lpng/pngpriv.h
+++ b/Engine/lib/lpng/pngpriv.h
@@ -1,10 +1,10 @@
 
 /* pngpriv.h - private declarations for use inside libpng
  *
- * Last changed in libpng 1.6.32 [August 24, 2017]
- * Copyright (c) 1998-2002,2004,2006-2017 Glenn Randers-Pehrson
- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ * Copyright (c) 2018-2019 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -174,7 +174,10 @@
 #     else /* !defined __ARM_NEON__ */
          /* The 'intrinsics' code simply won't compile without this -mfpu=neon:
           */
-#        define PNG_ARM_NEON_IMPLEMENTATION 2
+#        if !defined(__aarch64__)
+            /* The assembler code currently does not work on ARM64 */
+#          define PNG_ARM_NEON_IMPLEMENTATION 2
+#        endif /* __aarch64__ */
 #     endif /* __ARM_NEON__ */
 #  endif /* !PNG_ARM_NEON_IMPLEMENTATION */
 
@@ -210,7 +213,11 @@
        defined(__SSE2__) || defined(_M_X64) || defined(_M_AMD64) || \
        (defined(_M_IX86_FP) && _M_IX86_FP >= 2)
 #         define PNG_INTEL_SSE_OPT 1
+#      else
+#         define PNG_INTEL_SSE_OPT 0
 #      endif
+#   else
+#      define PNG_INTEL_SSE_OPT 0
 #   endif
 #endif
 
@@ -234,6 +241,8 @@
 #   if PNG_INTEL_SSE_IMPLEMENTATION > 0
 #      define PNG_FILTER_OPTIMIZATIONS png_init_filter_functions_sse2
 #   endif
+#else
+#   define PNG_INTEL_SSE_IMPLEMENTATION 0
 #endif
 
 #if PNG_MIPS_MSA_OPT > 0
@@ -728,8 +737,8 @@
 /* Added to libpng-1.2.6 JB */
 #define PNG_ROWBYTES(pixel_bits, width) \
     ((pixel_bits) >= 8 ? \
-    ((png_size_t)(width) * (((png_size_t)(pixel_bits)) >> 3)) : \
-    (( ((png_size_t)(width) * ((png_size_t)(pixel_bits))) + 7) >> 3) )
+    ((size_t)(width) * (((size_t)(pixel_bits)) >> 3)) : \
+    (( ((size_t)(width) * ((size_t)(pixel_bits))) + 7) >> 3) )
 
 /* This returns the number of trailing bits in the last byte of a row, 0 if the
  * last byte is completely full of pixels.  It is, in principle, (pixel_bits x
@@ -917,7 +926,7 @@
     * PNG files the -I directives must match.
     *
     * The most likely explanation is that you passed a -I in CFLAGS. This will
-    * not work; all the preprocessor directories and in particular all the -I
+    * not work; all the preprocessor directives and in particular all the -I
     * directives must be in CPPFLAGS.
     */
 #endif
@@ -1046,15 +1055,15 @@ PNG_INTERNAL_FUNCTION(void,png_zfree,(voidpf png_ptr, voidpf ptr),PNG_EMPTY);
  */
 
 PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_default_read_data,(png_structp png_ptr,
-    png_bytep data, png_size_t length),PNG_EMPTY);
+    png_bytep data, size_t length),PNG_EMPTY);
 
 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
 PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_push_fill_buffer,(png_structp png_ptr,
-    png_bytep buffer, png_size_t length),PNG_EMPTY);
+    png_bytep buffer, size_t length),PNG_EMPTY);
 #endif
 
 PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_default_write_data,(png_structp png_ptr,
-    png_bytep data, png_size_t length),PNG_EMPTY);
+    png_bytep data, size_t length),PNG_EMPTY);
 
 #ifdef PNG_WRITE_FLUSH_SUPPORTED
 #  ifdef PNG_STDIO_SUPPORTED
@@ -1068,7 +1077,7 @@ PNG_INTERNAL_FUNCTION(void,png_reset_crc,(png_structrp png_ptr),PNG_EMPTY);
 
 /* Write the "data" buffer to whatever output you are using */
 PNG_INTERNAL_FUNCTION(void,png_write_data,(png_structrp png_ptr,
-    png_const_bytep data, png_size_t length),PNG_EMPTY);
+    png_const_bytep data, size_t length),PNG_EMPTY);
 
 /* Read and check the PNG file signature */
 PNG_INTERNAL_FUNCTION(void,png_read_sig,(png_structrp png_ptr,
@@ -1080,7 +1089,7 @@ PNG_INTERNAL_FUNCTION(png_uint_32,png_read_chunk_header,(png_structrp png_ptr),
 
 /* Read data from whatever input you are using into the "data" buffer */
 PNG_INTERNAL_FUNCTION(void,png_read_data,(png_structrp png_ptr, png_bytep data,
-    png_size_t length),PNG_EMPTY);
+    size_t length),PNG_EMPTY);
 
 /* Read bytes into buf, and update png_ptr->crc */
 PNG_INTERNAL_FUNCTION(void,png_crc_read,(png_structrp png_ptr, png_bytep buf,
@@ -1098,7 +1107,7 @@ PNG_INTERNAL_FUNCTION(int,png_crc_error,(png_structrp png_ptr),PNG_EMPTY);
  * since this is the maximum buffer size we can specify.
  */
 PNG_INTERNAL_FUNCTION(void,png_calculate_crc,(png_structrp png_ptr,
-   png_const_bytep ptr, png_size_t length),PNG_EMPTY);
+   png_const_bytep ptr, size_t length),PNG_EMPTY);
 
 #ifdef PNG_WRITE_FLUSH_SUPPORTED
 PNG_INTERNAL_FUNCTION(void,png_flush,(png_structrp png_ptr),PNG_EMPTY);
@@ -1181,7 +1190,7 @@ PNG_INTERNAL_FUNCTION(void,png_write_hIST,(png_structrp png_ptr,
 /* Chunks that have keywords */
 #ifdef PNG_WRITE_tEXt_SUPPORTED
 PNG_INTERNAL_FUNCTION(void,png_write_tEXt,(png_structrp png_ptr,
-   png_const_charp key, png_const_charp text, png_size_t text_len),PNG_EMPTY);
+   png_const_charp key, png_const_charp text, size_t text_len),PNG_EMPTY);
 #endif
 
 #ifdef PNG_WRITE_zTXt_SUPPORTED
@@ -1528,10 +1537,10 @@ PNG_INTERNAL_FUNCTION(void,png_handle_zTXt,(png_structrp png_ptr,
 #endif
 
 PNG_INTERNAL_FUNCTION(void,png_check_chunk_name,(png_const_structrp png_ptr,
-    const png_uint_32 chunk_name),PNG_EMPTY);
+    png_uint_32 chunk_name),PNG_EMPTY);
 
 PNG_INTERNAL_FUNCTION(void,png_check_chunk_length,(png_const_structrp png_ptr,
-    const png_uint_32 chunk_length),PNG_EMPTY);
+    png_uint_32 chunk_length),PNG_EMPTY);
 
 PNG_INTERNAL_FUNCTION(void,png_handle_unknown,(png_structrp png_ptr,
     png_inforp info_ptr, png_uint_32 length, int keep),PNG_EMPTY);
@@ -1574,10 +1583,10 @@ PNG_INTERNAL_FUNCTION(void,png_push_check_crc,(png_structrp png_ptr),PNG_EMPTY);
 PNG_INTERNAL_FUNCTION(void,png_push_save_buffer,(png_structrp png_ptr),
     PNG_EMPTY);
 PNG_INTERNAL_FUNCTION(void,png_push_restore_buffer,(png_structrp png_ptr,
-    png_bytep buffer, png_size_t buffer_length),PNG_EMPTY);
+    png_bytep buffer, size_t buffer_length),PNG_EMPTY);
 PNG_INTERNAL_FUNCTION(void,png_push_read_IDAT,(png_structrp png_ptr),PNG_EMPTY);
 PNG_INTERNAL_FUNCTION(void,png_process_IDAT_data,(png_structrp png_ptr,
-    png_bytep buffer, png_size_t buffer_length),PNG_EMPTY);
+    png_bytep buffer, size_t buffer_length),PNG_EMPTY);
 PNG_INTERNAL_FUNCTION(void,png_push_process_row,(png_structrp png_ptr),
     PNG_EMPTY);
 PNG_INTERNAL_FUNCTION(void,png_push_handle_unknown,(png_structrp png_ptr,
@@ -1847,13 +1856,13 @@ PNG_INTERNAL_FUNCTION(void,png_chunk_report,(png_const_structrp png_ptr,
 
 #ifdef PNG_FLOATING_POINT_SUPPORTED
 PNG_INTERNAL_FUNCTION(void,png_ascii_from_fp,(png_const_structrp png_ptr,
-   png_charp ascii, png_size_t size, double fp, unsigned int precision),
+   png_charp ascii, size_t size, double fp, unsigned int precision),
    PNG_EMPTY);
 #endif /* FLOATING_POINT */
 
 #ifdef PNG_FIXED_POINT_SUPPORTED
 PNG_INTERNAL_FUNCTION(void,png_ascii_from_fixed,(png_const_structrp png_ptr,
-   png_charp ascii, png_size_t size, png_fixed_point fp),PNG_EMPTY);
+   png_charp ascii, size_t size, png_fixed_point fp),PNG_EMPTY);
 #endif /* FIXED_POINT */
 #endif /* sCAL */
 
@@ -1946,7 +1955,7 @@ PNG_INTERNAL_FUNCTION(void,png_ascii_from_fixed,(png_const_structrp png_ptr,
  * the problem character.)  This has not been tested within libpng.
  */
 PNG_INTERNAL_FUNCTION(int,png_check_fp_number,(png_const_charp string,
-   png_size_t size, int *statep, png_size_tp whereami),PNG_EMPTY);
+   size_t size, int *statep, png_size_tp whereami),PNG_EMPTY);
 
 /* This is the same but it checks a complete string and returns true
  * only if it just contains a floating point number.  As of 1.5.4 this
@@ -1955,7 +1964,7 @@ PNG_INTERNAL_FUNCTION(int,png_check_fp_number,(png_const_charp string,
  * for negative or zero values using the sticky flag.
  */
 PNG_INTERNAL_FUNCTION(int,png_check_fp_string,(png_const_charp string,
-   png_size_t size),PNG_EMPTY);
+   size_t size),PNG_EMPTY);
 #endif /* pCAL || sCAL */
 
 #if defined(PNG_GAMMA_SUPPORTED) ||\
@@ -2030,7 +2039,7 @@ typedef struct png_control
    png_voidp   error_buf;           /* Always a jmp_buf at present. */
 
    png_const_bytep memory;          /* Memory buffer. */
-   png_size_t      size;            /* Size of the memory buffer. */
+   size_t          size;            /* Size of the memory buffer. */
 
    unsigned int for_write       :1; /* Otherwise it is a read structure */
    unsigned int owned_file      :1; /* We own the file in io_ptr */
@@ -2108,6 +2117,29 @@ PNG_INTERNAL_FUNCTION(void, png_init_filter_functions_sse2,
 PNG_INTERNAL_FUNCTION(png_uint_32, png_check_keyword, (png_structrp png_ptr,
    png_const_charp key, png_bytep new_key), PNG_EMPTY);
 
+#if PNG_ARM_NEON_IMPLEMENTATION == 1
+PNG_INTERNAL_FUNCTION(void,
+                      png_riffle_palette_neon,
+                      (png_structrp),
+                      PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(int,
+                      png_do_expand_palette_rgba8_neon,
+                      (png_structrp,
+                       png_row_infop,
+                       png_const_bytep,
+                       const png_bytepp,
+                       const png_bytepp),
+                      PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(int,
+                      png_do_expand_palette_rgb8_neon,
+                      (png_structrp,
+                       png_row_infop,
+                       png_const_bytep,
+                       const png_bytepp,
+                       const png_bytepp),
+                      PNG_EMPTY);
+#endif
+
 /* Maintainer: Put new private prototypes here ^ */
 
 #include "pngdebug.h"
diff --git a/Engine/lib/lpng/pngread.c b/Engine/lib/lpng/pngread.c
index da32e9ad9..8fa7d9f16 100644
--- a/Engine/lib/lpng/pngread.c
+++ b/Engine/lib/lpng/pngread.c
@@ -1,10 +1,10 @@
 
 /* pngread.c - read a PNG file
  *
- * Last changed in libpng 1.6.33 [September 28, 2017]
- * Copyright (c) 1998-2002,2004,2006-2017 Glenn Randers-Pehrson
- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ * Copyright (c) 2018-2019 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -994,6 +994,12 @@ png_read_destroy(png_structrp png_ptr)
    png_ptr->chunk_list = NULL;
 #endif
 
+#if defined(PNG_READ_EXPAND_SUPPORTED) && \
+    defined(PNG_ARM_NEON_IMPLEMENTATION)
+   png_free(png_ptr, png_ptr->riffled_palette);
+   png_ptr->riffled_palette = NULL;
+#endif
+
    /* NOTE: the 'setjmp' buffer may still be allocated and the memory and error
     * callbacks are still set at this point.  They are required to complete the
     * destruction of the png_struct itself.
@@ -1532,7 +1538,7 @@ png_image_begin_read_from_file(png_imagep image, const char *file_name)
 #endif /* STDIO */
 
 static void PNGCBAPI
-png_image_memory_read(png_structp png_ptr, png_bytep out, png_size_t need)
+png_image_memory_read(png_structp png_ptr, png_bytep out, size_t need)
 {
    if (png_ptr != NULL)
    {
@@ -1543,7 +1549,7 @@ png_image_memory_read(png_structp png_ptr, png_bytep out, png_size_t need)
          if (cp != NULL)
          {
             png_const_bytep memory = cp->memory;
-            png_size_t size = cp->size;
+            size_t size = cp->size;
 
             if (memory != NULL && size >= need)
             {
@@ -1562,7 +1568,7 @@ png_image_memory_read(png_structp png_ptr, png_bytep out, png_size_t need)
 }
 
 int PNGAPI png_image_begin_read_from_memory(png_imagep image,
-    png_const_voidp memory, png_size_t size)
+    png_const_voidp memory, size_t size)
 {
    if (image != NULL && image->version == PNG_IMAGE_VERSION)
    {
@@ -1621,7 +1627,7 @@ png_image_skip_unused_chunks(png_structrp png_ptr)
     * errors (which are unfortunately quite common.)
     */
    {
-         static PNG_CONST png_byte chunks_to_process[] = {
+         static const png_byte chunks_to_process[] = {
             98,  75,  71,  68, '\0',  /* bKGD */
             99,  72,  82,  77, '\0',  /* cHRM */
            103,  65,  77,  65, '\0',  /* gAMA */
@@ -1758,9 +1764,9 @@ png_create_colormap_entry(png_image_read_control *display,
     png_uint_32 alpha, int encoding)
 {
    png_imagep image = display->image;
-   const int output_encoding = (image->format & PNG_FORMAT_FLAG_LINEAR) != 0 ?
+   int output_encoding = (image->format & PNG_FORMAT_FLAG_LINEAR) != 0 ?
        P_LINEAR : P_sRGB;
-   const int convert_to_Y = (image->format & PNG_FORMAT_FLAG_COLOR) == 0 &&
+   int convert_to_Y = (image->format & PNG_FORMAT_FLAG_COLOR) == 0 &&
        (red != green || green != blue);
 
    if (ip > 255)
@@ -1869,13 +1875,13 @@ png_create_colormap_entry(png_image_read_control *display,
    /* Store the value. */
    {
 #     ifdef PNG_FORMAT_AFIRST_SUPPORTED
-         const int afirst = (image->format & PNG_FORMAT_FLAG_AFIRST) != 0 &&
+         int afirst = (image->format & PNG_FORMAT_FLAG_AFIRST) != 0 &&
             (image->format & PNG_FORMAT_FLAG_ALPHA) != 0;
 #     else
 #        define afirst 0
 #     endif
 #     ifdef PNG_FORMAT_BGR_SUPPORTED
-         const int bgr = (image->format & PNG_FORMAT_FLAG_BGR) != 0 ? 2 : 0;
+         int bgr = (image->format & PNG_FORMAT_FLAG_BGR) != 0 ? 2 : 0;
 #     else
 #        define bgr 0
 #     endif
@@ -2085,11 +2091,11 @@ png_image_read_colormap(png_voidp argument)
 {
    png_image_read_control *display =
       png_voidcast(png_image_read_control*, argument);
-   const png_imagep image = display->image;
+   png_imagep image = display->image;
 
-   const png_structrp png_ptr = image->opaque->png_ptr;
-   const png_uint_32 output_format = image->format;
-   const int output_encoding = (output_format & PNG_FORMAT_FLAG_LINEAR) != 0 ?
+   png_structrp png_ptr = image->opaque->png_ptr;
+   png_uint_32 output_format = image->format;
+   int output_encoding = (output_format & PNG_FORMAT_FLAG_LINEAR) != 0 ?
       P_LINEAR : P_sRGB;
 
    unsigned int cmap_entries;
@@ -2802,7 +2808,7 @@ png_image_read_colormap(png_voidp argument)
             unsigned int num_trans = png_ptr->num_trans;
             png_const_bytep trans = num_trans > 0 ? png_ptr->trans_alpha : NULL;
             png_const_colorp colormap = png_ptr->palette;
-            const int do_background = trans != NULL &&
+            int do_background = trans != NULL &&
                (output_format & PNG_FORMAT_FLAG_ALPHA) == 0;
             unsigned int i;
 
@@ -3946,7 +3952,7 @@ png_image_read_direct(png_voidp argument)
        */
       if (linear != 0)
       {
-         PNG_CONST png_uint_16 le = 0x0001;
+         png_uint_16 le = 0x0001;
 
          if ((*(png_const_bytep) & le) != 0)
             png_set_swap(png_ptr);
@@ -4108,7 +4114,7 @@ png_image_finish_read(png_imagep image, png_const_colorp background,
        * original PNG format because it may not occur in the output PNG format
        * and libpng deals with the issues of reading the original.
        */
-      const unsigned int channels = PNG_IMAGE_PIXEL_CHANNELS(image->format);
+      unsigned int channels = PNG_IMAGE_PIXEL_CHANNELS(image->format);
 
       /* The following checks just the 'row_stride' calculation to ensure it
        * fits in a signed 32-bit value.  Because channels/components can be
@@ -4119,7 +4125,7 @@ png_image_finish_read(png_imagep image, png_const_colorp background,
       if (image->width <= 0x7fffffffU/channels) /* no overflow */
       {
          png_uint_32 check;
-         const png_uint_32 png_row_stride = image->width * channels;
+         png_uint_32 png_row_stride = image->width * channels;
 
          if (row_stride == 0)
             row_stride = (png_int_32)/*SAFE*/png_row_stride;
@@ -4150,7 +4156,7 @@ png_image_finish_read(png_imagep image, png_const_colorp background,
              *
              * NOTE: this will be changed in 1.7 because PNG_IMAGE_BUFFER_SIZE
              * will be changed to use png_alloc_size_t; bigger images can be
-             * accomodated on 64-bit systems.
+             * accommodated on 64-bit systems.
              */
             if (image->height <=
                 0xffffffffU/PNG_IMAGE_PIXEL_COMPONENT_SIZE(image->format)/check)
diff --git a/Engine/lib/lpng/pngrio.c b/Engine/lib/lpng/pngrio.c
index 7e26e855c..794635810 100644
--- a/Engine/lib/lpng/pngrio.c
+++ b/Engine/lib/lpng/pngrio.c
@@ -1,10 +1,10 @@
 
 /* pngrio.c - functions for data input
  *
- * Last changed in libpng 1.6.24 [August 4, 2016]
- * Copyright (c) 1998-2002,2004,2006-2016 Glenn Randers-Pehrson
- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ * Copyright (c) 2018 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2016,2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -29,7 +29,7 @@
  * to read more than 64K on a 16-bit machine.
  */
 void /* PRIVATE */
-png_read_data(png_structrp png_ptr, png_bytep data, png_size_t length)
+png_read_data(png_structrp png_ptr, png_bytep data, size_t length)
 {
    png_debug1(4, "reading %d bytes", (int)length);
 
@@ -47,14 +47,14 @@ png_read_data(png_structrp png_ptr, png_bytep data, png_size_t length)
  * than changing the library.
  */
 void PNGCBAPI
-png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
+png_default_read_data(png_structp png_ptr, png_bytep data, size_t length)
 {
-   png_size_t check;
+   size_t check;
 
    if (png_ptr == NULL)
       return;
 
-   /* fread() returns 0 on error, so it is OK to store this in a png_size_t
+   /* fread() returns 0 on error, so it is OK to store this in a size_t
     * instead of an int, which is what fread() actually returns.
     */
    check = fread(data, 1, length, png_voidcast(png_FILE_p, png_ptr->io_ptr));
diff --git a/Engine/lib/lpng/pngrtran.c b/Engine/lib/lpng/pngrtran.c
index c18965031..9a8fad9f4 100644
--- a/Engine/lib/lpng/pngrtran.c
+++ b/Engine/lib/lpng/pngrtran.c
@@ -1,10 +1,10 @@
 
 /* pngrtran.c - transforms the data in a row for PNG readers
  *
- * Last changed in libpng 1.6.33 [September 28, 2017]
- * Copyright (c) 1998-2002,2004,2006-2017 Glenn Randers-Pehrson
- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ * Copyright (c) 2018-2019 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -18,6 +18,17 @@
 
 #include "pngpriv.h"
 
+#ifdef PNG_ARM_NEON_IMPLEMENTATION
+#  if PNG_ARM_NEON_IMPLEMENTATION == 1
+#    define PNG_ARM_NEON_INTRINSICS_AVAILABLE
+#    if defined(_MSC_VER) && defined(_M_ARM64)
+#      include <arm64_neon.h>
+#    else
+#      include <arm_neon.h>
+#    endif
+#  endif
+#endif
+
 #ifdef PNG_READ_SUPPORTED
 
 /* Set the action on getting a CRC error for an ancillary or critical chunk. */
@@ -292,7 +303,7 @@ png_set_alpha_mode_fixed(png_structrp png_ptr, int mode,
     * who use the inverse of the gamma value accidentally!  Since some of these
     * values are reasonable this may have to be changed:
     *
-    * 1.6.x: changed from 0.07..3 to 0.01..100 (to accomodate the optimal 16-bit
+    * 1.6.x: changed from 0.07..3 to 0.01..100 (to accommodate the optimal 16-bit
     * gamma of 36, and its reciprocal.)
     */
    if (output_gamma < 1000 || output_gamma > 10000000)
@@ -747,7 +758,7 @@ png_set_quantize(png_structrp png_ptr, png_colorp palette,
       int num_red = (1 << PNG_QUANTIZE_RED_BITS);
       int num_green = (1 << PNG_QUANTIZE_GREEN_BITS);
       int num_blue = (1 << PNG_QUANTIZE_BLUE_BITS);
-      png_size_t num_entries = ((png_size_t)1 << total_bits);
+      size_t num_entries = ((size_t)1 << total_bits);
 
       png_ptr->palette_lookup = (png_bytep)png_calloc(png_ptr,
           (png_alloc_size_t)(num_entries * (sizeof (png_byte))));
@@ -1171,20 +1182,20 @@ png_init_palette_transformations(png_structrp png_ptr)
              png_ptr->palette[png_ptr->background.index].blue;
 
 #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
-        if ((png_ptr->transformations & PNG_INVERT_ALPHA) != 0)
-        {
-           if ((png_ptr->transformations & PNG_EXPAND_tRNS) == 0)
-           {
-              /* Invert the alpha channel (in tRNS) unless the pixels are
-               * going to be expanded, in which case leave it for later
-               */
-              int i, istop = png_ptr->num_trans;
+         if ((png_ptr->transformations & PNG_INVERT_ALPHA) != 0)
+         {
+            if ((png_ptr->transformations & PNG_EXPAND_tRNS) == 0)
+            {
+               /* Invert the alpha channel (in tRNS) unless the pixels are
+                * going to be expanded, in which case leave it for later
+                */
+               int i, istop = png_ptr->num_trans;
 
-              for (i=0; i<istop; i++)
-                 png_ptr->trans_alpha[i] = (png_byte)(255 -
-                    png_ptr->trans_alpha[i]);
-           }
-        }
+               for (i = 0; i < istop; i++)
+                  png_ptr->trans_alpha[i] =
+                      (png_byte)(255 - png_ptr->trans_alpha[i]);
+            }
+         }
 #endif /* READ_INVERT_ALPHA */
       }
    } /* background expand and (therefore) no alpha association. */
@@ -1317,7 +1328,7 @@ png_init_read_transformations(png_structrp png_ptr)
 
       else if (png_ptr->screen_gamma != 0)
          /* The converse - assume the file matches the screen, note that this
-          * perhaps undesireable default can (from 1.5.4) be changed by calling
+          * perhaps undesirable default can (from 1.5.4) be changed by calling
           * png_set_alpha_mode (even if the alpha handling mode isn't required
           * or isn't changed from the default.)
           */
@@ -1885,7 +1896,7 @@ png_init_read_transformations(png_structrp png_ptr)
 
       png_ptr->transformations &= ~PNG_SHIFT;
 
-      /* significant bits can be in the range 1 to 7 for a meaninful result, if
+      /* significant bits can be in the range 1 to 7 for a meaningful result, if
        * the number of significant bits is 0 then no shift is done (this is an
        * error condition which is silently ignored.)
        */
@@ -2151,8 +2162,8 @@ png_do_unpack(png_row_infop row_info, png_bytep row)
       {
          case 1:
          {
-            png_bytep sp = row + (png_size_t)((row_width - 1) >> 3);
-            png_bytep dp = row + (png_size_t)row_width - 1;
+            png_bytep sp = row + (size_t)((row_width - 1) >> 3);
+            png_bytep dp = row + (size_t)row_width - 1;
             png_uint_32 shift = 7U - ((row_width + 7U) & 0x07);
             for (i = 0; i < row_width; i++)
             {
@@ -2175,8 +2186,8 @@ png_do_unpack(png_row_infop row_info, png_bytep row)
          case 2:
          {
 
-            png_bytep sp = row + (png_size_t)((row_width - 1) >> 2);
-            png_bytep dp = row + (png_size_t)row_width - 1;
+            png_bytep sp = row + (size_t)((row_width - 1) >> 2);
+            png_bytep dp = row + (size_t)row_width - 1;
             png_uint_32 shift = ((3U - ((row_width + 3U) & 0x03)) << 1);
             for (i = 0; i < row_width; i++)
             {
@@ -2198,8 +2209,8 @@ png_do_unpack(png_row_infop row_info, png_bytep row)
 
          case 4:
          {
-            png_bytep sp = row + (png_size_t)((row_width - 1) >> 1);
-            png_bytep dp = row + (png_size_t)row_width - 1;
+            png_bytep sp = row + (size_t)((row_width - 1) >> 1);
+            png_bytep dp = row + (size_t)row_width - 1;
             png_uint_32 shift = ((1U - ((row_width + 1U) & 0x01)) << 2);
             for (i = 0; i < row_width; i++)
             {
@@ -2463,95 +2474,94 @@ png_do_chop(png_row_infop row_info, png_bytep row)
 static void
 png_do_read_swap_alpha(png_row_infop row_info, png_bytep row)
 {
+   png_uint_32 row_width = row_info->width;
+
    png_debug(1, "in png_do_read_swap_alpha");
 
+   if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
    {
-      png_uint_32 row_width = row_info->width;
-      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+      /* This converts from RGBA to ARGB */
+      if (row_info->bit_depth == 8)
       {
-         /* This converts from RGBA to ARGB */
-         if (row_info->bit_depth == 8)
+         png_bytep sp = row + row_info->rowbytes;
+         png_bytep dp = sp;
+         png_byte save;
+         png_uint_32 i;
+
+         for (i = 0; i < row_width; i++)
          {
-            png_bytep sp = row + row_info->rowbytes;
-            png_bytep dp = sp;
-            png_byte save;
-            png_uint_32 i;
-
-            for (i = 0; i < row_width; i++)
-            {
-               save = *(--sp);
-               *(--dp) = *(--sp);
-               *(--dp) = *(--sp);
-               *(--dp) = *(--sp);
-               *(--dp) = save;
-            }
+            save = *(--sp);
+            *(--dp) = *(--sp);
+            *(--dp) = *(--sp);
+            *(--dp) = *(--sp);
+            *(--dp) = save;
          }
-
-#ifdef PNG_READ_16BIT_SUPPORTED
-         /* This converts from RRGGBBAA to AARRGGBB */
-         else
-         {
-            png_bytep sp = row + row_info->rowbytes;
-            png_bytep dp = sp;
-            png_byte save[2];
-            png_uint_32 i;
-
-            for (i = 0; i < row_width; i++)
-            {
-               save[0] = *(--sp);
-               save[1] = *(--sp);
-               *(--dp) = *(--sp);
-               *(--dp) = *(--sp);
-               *(--dp) = *(--sp);
-               *(--dp) = *(--sp);
-               *(--dp) = *(--sp);
-               *(--dp) = *(--sp);
-               *(--dp) = save[0];
-               *(--dp) = save[1];
-            }
-         }
-#endif
       }
 
-      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+#ifdef PNG_READ_16BIT_SUPPORTED
+      /* This converts from RRGGBBAA to AARRGGBB */
+      else
       {
-         /* This converts from GA to AG */
-         if (row_info->bit_depth == 8)
-         {
-            png_bytep sp = row + row_info->rowbytes;
-            png_bytep dp = sp;
-            png_byte save;
-            png_uint_32 i;
+         png_bytep sp = row + row_info->rowbytes;
+         png_bytep dp = sp;
+         png_byte save[2];
+         png_uint_32 i;
 
-            for (i = 0; i < row_width; i++)
-            {
-               save = *(--sp);
-               *(--dp) = *(--sp);
-               *(--dp) = save;
-            }
+         for (i = 0; i < row_width; i++)
+         {
+            save[0] = *(--sp);
+            save[1] = *(--sp);
+            *(--dp) = *(--sp);
+            *(--dp) = *(--sp);
+            *(--dp) = *(--sp);
+            *(--dp) = *(--sp);
+            *(--dp) = *(--sp);
+            *(--dp) = *(--sp);
+            *(--dp) = save[0];
+            *(--dp) = save[1];
          }
+      }
+#endif
+   }
+
+   else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+   {
+      /* This converts from GA to AG */
+      if (row_info->bit_depth == 8)
+      {
+         png_bytep sp = row + row_info->rowbytes;
+         png_bytep dp = sp;
+         png_byte save;
+         png_uint_32 i;
+
+         for (i = 0; i < row_width; i++)
+         {
+            save = *(--sp);
+            *(--dp) = *(--sp);
+            *(--dp) = save;
+         }
+      }
 
 #ifdef PNG_READ_16BIT_SUPPORTED
-         /* This converts from GGAA to AAGG */
-         else
-         {
-            png_bytep sp = row + row_info->rowbytes;
-            png_bytep dp = sp;
-            png_byte save[2];
-            png_uint_32 i;
+      /* This converts from GGAA to AAGG */
+      else
+      {
+         png_bytep sp = row + row_info->rowbytes;
+         png_bytep dp = sp;
+         png_byte save[2];
+         png_uint_32 i;
 
-            for (i = 0; i < row_width; i++)
-            {
-               save[0] = *(--sp);
-               save[1] = *(--sp);
-               *(--dp) = *(--sp);
-               *(--dp) = *(--sp);
-               *(--dp) = save[0];
-               *(--dp) = save[1];
-            }
+         for (i = 0; i < row_width; i++)
+         {
+            save[0] = *(--sp);
+            save[1] = *(--sp);
+            *(--dp) = *(--sp);
+            *(--dp) = *(--sp);
+            *(--dp) = save[0];
+            *(--dp) = save[1];
          }
-#endif
       }
+#endif
    }
 }
 #endif
@@ -2681,8 +2691,8 @@ png_do_read_filler(png_row_infop row_info, png_bytep row,
          if ((flags & PNG_FLAG_FILLER_AFTER) != 0)
          {
             /* This changes the data from G to GX */
-            png_bytep sp = row + (png_size_t)row_width;
-            png_bytep dp =  sp + (png_size_t)row_width;
+            png_bytep sp = row + (size_t)row_width;
+            png_bytep dp =  sp + (size_t)row_width;
             for (i = 1; i < row_width; i++)
             {
                *(--dp) = lo_filler;
@@ -2697,8 +2707,8 @@ png_do_read_filler(png_row_infop row_info, png_bytep row,
          else
          {
             /* This changes the data from G to XG */
-            png_bytep sp = row + (png_size_t)row_width;
-            png_bytep dp = sp  + (png_size_t)row_width;
+            png_bytep sp = row + (size_t)row_width;
+            png_bytep dp = sp  + (size_t)row_width;
             for (i = 0; i < row_width; i++)
             {
                *(--dp) = *(--sp);
@@ -2716,8 +2726,8 @@ png_do_read_filler(png_row_infop row_info, png_bytep row,
          if ((flags & PNG_FLAG_FILLER_AFTER) != 0)
          {
             /* This changes the data from GG to GGXX */
-            png_bytep sp = row + (png_size_t)row_width * 2;
-            png_bytep dp = sp  + (png_size_t)row_width * 2;
+            png_bytep sp = row + (size_t)row_width * 2;
+            png_bytep dp = sp  + (size_t)row_width * 2;
             for (i = 1; i < row_width; i++)
             {
                *(--dp) = lo_filler;
@@ -2735,8 +2745,8 @@ png_do_read_filler(png_row_infop row_info, png_bytep row,
          else
          {
             /* This changes the data from GG to XXGG */
-            png_bytep sp = row + (png_size_t)row_width * 2;
-            png_bytep dp = sp  + (png_size_t)row_width * 2;
+            png_bytep sp = row + (size_t)row_width * 2;
+            png_bytep dp = sp  + (size_t)row_width * 2;
             for (i = 0; i < row_width; i++)
             {
                *(--dp) = *(--sp);
@@ -2758,8 +2768,8 @@ png_do_read_filler(png_row_infop row_info, png_bytep row,
          if ((flags & PNG_FLAG_FILLER_AFTER) != 0)
          {
             /* This changes the data from RGB to RGBX */
-            png_bytep sp = row + (png_size_t)row_width * 3;
-            png_bytep dp = sp  + (png_size_t)row_width;
+            png_bytep sp = row + (size_t)row_width * 3;
+            png_bytep dp = sp  + (size_t)row_width;
             for (i = 1; i < row_width; i++)
             {
                *(--dp) = lo_filler;
@@ -2776,8 +2786,8 @@ png_do_read_filler(png_row_infop row_info, png_bytep row,
          else
          {
             /* This changes the data from RGB to XRGB */
-            png_bytep sp = row + (png_size_t)row_width * 3;
-            png_bytep dp = sp + (png_size_t)row_width;
+            png_bytep sp = row + (size_t)row_width * 3;
+            png_bytep dp = sp + (size_t)row_width;
             for (i = 0; i < row_width; i++)
             {
                *(--dp) = *(--sp);
@@ -2797,8 +2807,8 @@ png_do_read_filler(png_row_infop row_info, png_bytep row,
          if ((flags & PNG_FLAG_FILLER_AFTER) != 0)
          {
             /* This changes the data from RRGGBB to RRGGBBXX */
-            png_bytep sp = row + (png_size_t)row_width * 6;
-            png_bytep dp = sp  + (png_size_t)row_width * 2;
+            png_bytep sp = row + (size_t)row_width * 6;
+            png_bytep dp = sp  + (size_t)row_width * 2;
             for (i = 1; i < row_width; i++)
             {
                *(--dp) = lo_filler;
@@ -2820,8 +2830,8 @@ png_do_read_filler(png_row_infop row_info, png_bytep row,
          else
          {
             /* This changes the data from RRGGBB to XXRRGGBB */
-            png_bytep sp = row + (png_size_t)row_width * 6;
-            png_bytep dp = sp  + (png_size_t)row_width * 2;
+            png_bytep sp = row + (size_t)row_width * 6;
+            png_bytep dp = sp  + (size_t)row_width * 2;
             for (i = 0; i < row_width; i++)
             {
                *(--dp) = *(--sp);
@@ -2862,8 +2872,8 @@ png_do_gray_to_rgb(png_row_infop row_info, png_bytep row)
          if (row_info->bit_depth == 8)
          {
             /* This changes G to RGB */
-            png_bytep sp = row + (png_size_t)row_width - 1;
-            png_bytep dp = sp  + (png_size_t)row_width * 2;
+            png_bytep sp = row + (size_t)row_width - 1;
+            png_bytep dp = sp  + (size_t)row_width * 2;
             for (i = 0; i < row_width; i++)
             {
                *(dp--) = *sp;
@@ -2875,8 +2885,8 @@ png_do_gray_to_rgb(png_row_infop row_info, png_bytep row)
          else
          {
             /* This changes GG to RRGGBB */
-            png_bytep sp = row + (png_size_t)row_width * 2 - 1;
-            png_bytep dp = sp  + (png_size_t)row_width * 4;
+            png_bytep sp = row + (size_t)row_width * 2 - 1;
+            png_bytep dp = sp  + (size_t)row_width * 4;
             for (i = 0; i < row_width; i++)
             {
                *(dp--) = *sp;
@@ -2894,8 +2904,8 @@ png_do_gray_to_rgb(png_row_infop row_info, png_bytep row)
          if (row_info->bit_depth == 8)
          {
             /* This changes GA to RGBA */
-            png_bytep sp = row + (png_size_t)row_width * 2 - 1;
-            png_bytep dp = sp  + (png_size_t)row_width * 2;
+            png_bytep sp = row + (size_t)row_width * 2 - 1;
+            png_bytep dp = sp  + (size_t)row_width * 2;
             for (i = 0; i < row_width; i++)
             {
                *(dp--) = *(sp--);
@@ -2908,8 +2918,8 @@ png_do_gray_to_rgb(png_row_infop row_info, png_bytep row)
          else
          {
             /* This changes GGAA to RRGGBBAA */
-            png_bytep sp = row + (png_size_t)row_width * 4 - 1;
-            png_bytep dp = sp  + (png_size_t)row_width * 4;
+            png_bytep sp = row + (size_t)row_width * 4 - 1;
+            png_bytep dp = sp  + (size_t)row_width * 4;
             for (i = 0; i < row_width; i++)
             {
                *(dp--) = *(sp--);
@@ -2980,14 +2990,13 @@ png_do_gray_to_rgb(png_row_infop row_info, png_bytep row)
  *  values this results in an implicit assumption that the original PNG RGB
  *  values were linear.
  *
- *  Other integer coefficents can be used via png_set_rgb_to_gray().  Because
+ *  Other integer coefficients can be used via png_set_rgb_to_gray().  Because
  *  the API takes just red and green coefficients the blue coefficient is
  *  calculated to make the sum 32768.  This will result in different rounding
  *  to that used above.
  */
 static int
 png_do_rgb_to_gray(png_structrp png_ptr, png_row_infop row_info, png_bytep row)
-
 {
    int rgb_error = 0;
 
@@ -2996,12 +3005,11 @@ png_do_rgb_to_gray(png_structrp png_ptr, png_row_infop row_info, png_bytep row)
    if ((row_info->color_type & PNG_COLOR_MASK_PALETTE) == 0 &&
        (row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)
    {
-      PNG_CONST png_uint_32 rc = png_ptr->rgb_to_gray_red_coeff;
-      PNG_CONST png_uint_32 gc = png_ptr->rgb_to_gray_green_coeff;
-      PNG_CONST png_uint_32 bc = 32768 - rc - gc;
-      PNG_CONST png_uint_32 row_width = row_info->width;
-      PNG_CONST int have_alpha =
-         (row_info->color_type & PNG_COLOR_MASK_ALPHA) != 0;
+      png_uint_32 rc = png_ptr->rgb_to_gray_red_coeff;
+      png_uint_32 gc = png_ptr->rgb_to_gray_green_coeff;
+      png_uint_32 bc = 32768 - rc - gc;
+      png_uint_32 row_width = row_info->width;
+      int have_alpha = (row_info->color_type & PNG_COLOR_MASK_ALPHA) != 0;
 
       if (row_info->bit_depth == 8)
       {
@@ -3209,419 +3217,229 @@ png_do_compose(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
 
    png_debug(1, "in png_do_compose");
 
+   switch (row_info->color_type)
    {
-      switch (row_info->color_type)
+      case PNG_COLOR_TYPE_GRAY:
       {
-         case PNG_COLOR_TYPE_GRAY:
+         switch (row_info->bit_depth)
          {
-            switch (row_info->bit_depth)
+            case 1:
             {
-               case 1:
+               sp = row;
+               shift = 7;
+               for (i = 0; i < row_width; i++)
                {
-                  sp = row;
-                  shift = 7;
-                  for (i = 0; i < row_width; i++)
+                  if ((png_uint_16)((*sp >> shift) & 0x01)
+                     == png_ptr->trans_color.gray)
                   {
-                     if ((png_uint_16)((*sp >> shift) & 0x01)
-                        == png_ptr->trans_color.gray)
-                     {
-                        unsigned int tmp = *sp & (0x7f7f >> (7 - shift));
-                        tmp |=
-                            (unsigned int)(png_ptr->background.gray << shift);
-                        *sp = (png_byte)(tmp & 0xff);
-                     }
-
-                     if (shift == 0)
-                     {
-                        shift = 7;
-                        sp++;
-                     }
-
-                     else
-                        shift--;
+                     unsigned int tmp = *sp & (0x7f7f >> (7 - shift));
+                     tmp |=
+                         (unsigned int)(png_ptr->background.gray << shift);
+                     *sp = (png_byte)(tmp & 0xff);
                   }
-                  break;
-               }
 
-               case 2:
-               {
-#ifdef PNG_READ_GAMMA_SUPPORTED
-                  if (gamma_table != NULL)
+                  if (shift == 0)
                   {
-                     sp = row;
-                     shift = 6;
-                     for (i = 0; i < row_width; i++)
-                     {
-                        if ((png_uint_16)((*sp >> shift) & 0x03)
-                            == png_ptr->trans_color.gray)
-                        {
-                           unsigned int tmp = *sp & (0x3f3f >> (6 - shift));
-                           tmp |=
-                              (unsigned int)png_ptr->background.gray << shift;
-                           *sp = (png_byte)(tmp & 0xff);
-                        }
-
-                        else
-                        {
-                           unsigned int p = (*sp >> shift) & 0x03;
-                           unsigned int g = (gamma_table [p | (p << 2) |
-                               (p << 4) | (p << 6)] >> 6) & 0x03;
-                           unsigned int tmp = *sp & (0x3f3f >> (6 - shift));
-                           tmp |= (unsigned int)(g << shift);
-                           *sp = (png_byte)(tmp & 0xff);
-                        }
-
-                        if (shift == 0)
-                        {
-                           shift = 6;
-                           sp++;
-                        }
-
-                        else
-                           shift -= 2;
-                     }
+                     shift = 7;
+                     sp++;
                   }
 
                   else
-#endif
-                  {
-                     sp = row;
-                     shift = 6;
-                     for (i = 0; i < row_width; i++)
-                     {
-                        if ((png_uint_16)((*sp >> shift) & 0x03)
-                            == png_ptr->trans_color.gray)
-                        {
-                           unsigned int tmp = *sp & (0x3f3f >> (6 - shift));
-                           tmp |=
-                               (unsigned int)png_ptr->background.gray << shift;
-                           *sp = (png_byte)(tmp & 0xff);
-                        }
-
-                        if (shift == 0)
-                        {
-                           shift = 6;
-                           sp++;
-                        }
-
-                        else
-                           shift -= 2;
-                     }
-                  }
-                  break;
+                     shift--;
                }
-
-               case 4:
-               {
-#ifdef PNG_READ_GAMMA_SUPPORTED
-                  if (gamma_table != NULL)
-                  {
-                     sp = row;
-                     shift = 4;
-                     for (i = 0; i < row_width; i++)
-                     {
-                        if ((png_uint_16)((*sp >> shift) & 0x0f)
-                            == png_ptr->trans_color.gray)
-                        {
-                           unsigned int tmp = *sp & (0x0f0f >> (4 - shift));
-                           tmp |=
-                              (unsigned int)(png_ptr->background.gray << shift);
-                           *sp = (png_byte)(tmp & 0xff);
-                        }
-
-                        else
-                        {
-                           unsigned int p = (*sp >> shift) & 0x0f;
-                           unsigned int g = (gamma_table[p | (p << 4)] >> 4) &
-                              0x0f;
-                           unsigned int tmp = *sp & (0x0f0f >> (4 - shift));
-                           tmp |= (unsigned int)(g << shift);
-                           *sp = (png_byte)(tmp & 0xff);
-                        }
-
-                        if (shift == 0)
-                        {
-                           shift = 4;
-                           sp++;
-                        }
-
-                        else
-                           shift -= 4;
-                     }
-                  }
-
-                  else
-#endif
-                  {
-                     sp = row;
-                     shift = 4;
-                     for (i = 0; i < row_width; i++)
-                     {
-                        if ((png_uint_16)((*sp >> shift) & 0x0f)
-                            == png_ptr->trans_color.gray)
-                        {
-                           unsigned int tmp = *sp & (0x0f0f >> (4 - shift));
-                           tmp |=
-                              (unsigned int)(png_ptr->background.gray << shift);
-                           *sp = (png_byte)(tmp & 0xff);
-                        }
-
-                        if (shift == 0)
-                        {
-                           shift = 4;
-                           sp++;
-                        }
-
-                        else
-                           shift -= 4;
-                     }
-                  }
-                  break;
-               }
-
-               case 8:
-               {
-#ifdef PNG_READ_GAMMA_SUPPORTED
-                  if (gamma_table != NULL)
-                  {
-                     sp = row;
-                     for (i = 0; i < row_width; i++, sp++)
-                     {
-                        if (*sp == png_ptr->trans_color.gray)
-                           *sp = (png_byte)png_ptr->background.gray;
-
-                        else
-                           *sp = gamma_table[*sp];
-                     }
-                  }
-                  else
-#endif
-                  {
-                     sp = row;
-                     for (i = 0; i < row_width; i++, sp++)
-                     {
-                        if (*sp == png_ptr->trans_color.gray)
-                           *sp = (png_byte)png_ptr->background.gray;
-                     }
-                  }
-                  break;
-               }
-
-               case 16:
-               {
-#ifdef PNG_READ_GAMMA_SUPPORTED
-                  if (gamma_16 != NULL)
-                  {
-                     sp = row;
-                     for (i = 0; i < row_width; i++, sp += 2)
-                     {
-                        png_uint_16 v;
-
-                        v = (png_uint_16)(((*sp) << 8) + *(sp + 1));
-
-                        if (v == png_ptr->trans_color.gray)
-                        {
-                           /* Background is already in screen gamma */
-                           *sp = (png_byte)((png_ptr->background.gray >> 8)
-                                & 0xff);
-                           *(sp + 1) = (png_byte)(png_ptr->background.gray
-                                & 0xff);
-                        }
-
-                        else
-                        {
-                           v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
-                           *sp = (png_byte)((v >> 8) & 0xff);
-                           *(sp + 1) = (png_byte)(v & 0xff);
-                        }
-                     }
-                  }
-                  else
-#endif
-                  {
-                     sp = row;
-                     for (i = 0; i < row_width; i++, sp += 2)
-                     {
-                        png_uint_16 v;
-
-                        v = (png_uint_16)(((*sp) << 8) + *(sp + 1));
-
-                        if (v == png_ptr->trans_color.gray)
-                        {
-                           *sp = (png_byte)((png_ptr->background.gray >> 8)
-                                & 0xff);
-                           *(sp + 1) = (png_byte)(png_ptr->background.gray
-                                & 0xff);
-                        }
-                     }
-                  }
-                  break;
-               }
-
-               default:
-                  break;
+               break;
             }
-            break;
-         }
 
-         case PNG_COLOR_TYPE_RGB:
-         {
-            if (row_info->bit_depth == 8)
+            case 2:
             {
 #ifdef PNG_READ_GAMMA_SUPPORTED
                if (gamma_table != NULL)
                {
                   sp = row;
-                  for (i = 0; i < row_width; i++, sp += 3)
+                  shift = 6;
+                  for (i = 0; i < row_width; i++)
                   {
-                     if (*sp == png_ptr->trans_color.red &&
-                         *(sp + 1) == png_ptr->trans_color.green &&
-                         *(sp + 2) == png_ptr->trans_color.blue)
+                     if ((png_uint_16)((*sp >> shift) & 0x03)
+                         == png_ptr->trans_color.gray)
                      {
-                        *sp = (png_byte)png_ptr->background.red;
-                        *(sp + 1) = (png_byte)png_ptr->background.green;
-                        *(sp + 2) = (png_byte)png_ptr->background.blue;
+                        unsigned int tmp = *sp & (0x3f3f >> (6 - shift));
+                        tmp |=
+                           (unsigned int)png_ptr->background.gray << shift;
+                        *sp = (png_byte)(tmp & 0xff);
                      }
 
                      else
                      {
-                        *sp = gamma_table[*sp];
-                        *(sp + 1) = gamma_table[*(sp + 1)];
-                        *(sp + 2) = gamma_table[*(sp + 2)];
+                        unsigned int p = (*sp >> shift) & 0x03;
+                        unsigned int g = (gamma_table [p | (p << 2) |
+                            (p << 4) | (p << 6)] >> 6) & 0x03;
+                        unsigned int tmp = *sp & (0x3f3f >> (6 - shift));
+                        tmp |= (unsigned int)(g << shift);
+                        *sp = (png_byte)(tmp & 0xff);
                      }
+
+                     if (shift == 0)
+                     {
+                        shift = 6;
+                        sp++;
+                     }
+
+                     else
+                        shift -= 2;
+                  }
+               }
+
+               else
+#endif
+               {
+                  sp = row;
+                  shift = 6;
+                  for (i = 0; i < row_width; i++)
+                  {
+                     if ((png_uint_16)((*sp >> shift) & 0x03)
+                         == png_ptr->trans_color.gray)
+                     {
+                        unsigned int tmp = *sp & (0x3f3f >> (6 - shift));
+                        tmp |=
+                            (unsigned int)png_ptr->background.gray << shift;
+                        *sp = (png_byte)(tmp & 0xff);
+                     }
+
+                     if (shift == 0)
+                     {
+                        shift = 6;
+                        sp++;
+                     }
+
+                     else
+                        shift -= 2;
+                  }
+               }
+               break;
+            }
+
+            case 4:
+            {
+#ifdef PNG_READ_GAMMA_SUPPORTED
+               if (gamma_table != NULL)
+               {
+                  sp = row;
+                  shift = 4;
+                  for (i = 0; i < row_width; i++)
+                  {
+                     if ((png_uint_16)((*sp >> shift) & 0x0f)
+                         == png_ptr->trans_color.gray)
+                     {
+                        unsigned int tmp = *sp & (0x0f0f >> (4 - shift));
+                        tmp |=
+                           (unsigned int)(png_ptr->background.gray << shift);
+                        *sp = (png_byte)(tmp & 0xff);
+                     }
+
+                     else
+                     {
+                        unsigned int p = (*sp >> shift) & 0x0f;
+                        unsigned int g = (gamma_table[p | (p << 4)] >> 4) &
+                           0x0f;
+                        unsigned int tmp = *sp & (0x0f0f >> (4 - shift));
+                        tmp |= (unsigned int)(g << shift);
+                        *sp = (png_byte)(tmp & 0xff);
+                     }
+
+                     if (shift == 0)
+                     {
+                        shift = 4;
+                        sp++;
+                     }
+
+                     else
+                        shift -= 4;
+                  }
+               }
+
+               else
+#endif
+               {
+                  sp = row;
+                  shift = 4;
+                  for (i = 0; i < row_width; i++)
+                  {
+                     if ((png_uint_16)((*sp >> shift) & 0x0f)
+                         == png_ptr->trans_color.gray)
+                     {
+                        unsigned int tmp = *sp & (0x0f0f >> (4 - shift));
+                        tmp |=
+                           (unsigned int)(png_ptr->background.gray << shift);
+                        *sp = (png_byte)(tmp & 0xff);
+                     }
+
+                     if (shift == 0)
+                     {
+                        shift = 4;
+                        sp++;
+                     }
+
+                     else
+                        shift -= 4;
+                  }
+               }
+               break;
+            }
+
+            case 8:
+            {
+#ifdef PNG_READ_GAMMA_SUPPORTED
+               if (gamma_table != NULL)
+               {
+                  sp = row;
+                  for (i = 0; i < row_width; i++, sp++)
+                  {
+                     if (*sp == png_ptr->trans_color.gray)
+                        *sp = (png_byte)png_ptr->background.gray;
+
+                     else
+                        *sp = gamma_table[*sp];
                   }
                }
                else
 #endif
                {
                   sp = row;
-                  for (i = 0; i < row_width; i++, sp += 3)
+                  for (i = 0; i < row_width; i++, sp++)
                   {
-                     if (*sp == png_ptr->trans_color.red &&
-                         *(sp + 1) == png_ptr->trans_color.green &&
-                         *(sp + 2) == png_ptr->trans_color.blue)
-                     {
-                        *sp = (png_byte)png_ptr->background.red;
-                        *(sp + 1) = (png_byte)png_ptr->background.green;
-                        *(sp + 2) = (png_byte)png_ptr->background.blue;
-                     }
+                     if (*sp == png_ptr->trans_color.gray)
+                        *sp = (png_byte)png_ptr->background.gray;
                   }
                }
+               break;
             }
-            else /* if (row_info->bit_depth == 16) */
+
+            case 16:
             {
 #ifdef PNG_READ_GAMMA_SUPPORTED
                if (gamma_16 != NULL)
-               {
-                  sp = row;
-                  for (i = 0; i < row_width; i++, sp += 6)
-                  {
-                     png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));
-
-                     png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8)
-                         + *(sp + 3));
-
-                     png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8)
-                         + *(sp + 5));
-
-                     if (r == png_ptr->trans_color.red &&
-                         g == png_ptr->trans_color.green &&
-                         b == png_ptr->trans_color.blue)
-                     {
-                        /* Background is already in screen gamma */
-                        *sp = (png_byte)((png_ptr->background.red >> 8) & 0xff);
-                        *(sp + 1) = (png_byte)(png_ptr->background.red & 0xff);
-                        *(sp + 2) = (png_byte)((png_ptr->background.green >> 8)
-                                & 0xff);
-                        *(sp + 3) = (png_byte)(png_ptr->background.green
-                                & 0xff);
-                        *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8)
-                                & 0xff);
-                        *(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff);
-                     }
-
-                     else
-                     {
-                        png_uint_16 v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
-                        *sp = (png_byte)((v >> 8) & 0xff);
-                        *(sp + 1) = (png_byte)(v & 0xff);
-
-                        v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];
-                        *(sp + 2) = (png_byte)((v >> 8) & 0xff);
-                        *(sp + 3) = (png_byte)(v & 0xff);
-
-                        v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];
-                        *(sp + 4) = (png_byte)((v >> 8) & 0xff);
-                        *(sp + 5) = (png_byte)(v & 0xff);
-                     }
-                  }
-               }
-
-               else
-#endif
-               {
-                  sp = row;
-                  for (i = 0; i < row_width; i++, sp += 6)
-                  {
-                     png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));
-
-                     png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8)
-                         + *(sp + 3));
-
-                     png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8)
-                         + *(sp + 5));
-
-                     if (r == png_ptr->trans_color.red &&
-                         g == png_ptr->trans_color.green &&
-                         b == png_ptr->trans_color.blue)
-                     {
-                        *sp = (png_byte)((png_ptr->background.red >> 8) & 0xff);
-                        *(sp + 1) = (png_byte)(png_ptr->background.red & 0xff);
-                        *(sp + 2) = (png_byte)((png_ptr->background.green >> 8)
-                                & 0xff);
-                        *(sp + 3) = (png_byte)(png_ptr->background.green
-                                & 0xff);
-                        *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8)
-                                & 0xff);
-                        *(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff);
-                     }
-                  }
-               }
-            }
-            break;
-         }
-
-         case PNG_COLOR_TYPE_GRAY_ALPHA:
-         {
-            if (row_info->bit_depth == 8)
-            {
-#ifdef PNG_READ_GAMMA_SUPPORTED
-               if (gamma_to_1 != NULL && gamma_from_1 != NULL &&
-                   gamma_table != NULL)
                {
                   sp = row;
                   for (i = 0; i < row_width; i++, sp += 2)
                   {
-                     png_uint_16 a = *(sp + 1);
+                     png_uint_16 v;
 
-                     if (a == 0xff)
-                        *sp = gamma_table[*sp];
+                     v = (png_uint_16)(((*sp) << 8) + *(sp + 1));
 
-                     else if (a == 0)
+                     if (v == png_ptr->trans_color.gray)
                      {
                         /* Background is already in screen gamma */
-                        *sp = (png_byte)png_ptr->background.gray;
+                        *sp = (png_byte)((png_ptr->background.gray >> 8)
+                             & 0xff);
+                        *(sp + 1) = (png_byte)(png_ptr->background.gray
+                             & 0xff);
                      }
 
                      else
                      {
-                        png_byte v, w;
-
-                        v = gamma_to_1[*sp];
-                        png_composite(w, v, a, png_ptr->background_1.gray);
-                        if (optimize == 0)
-                           w = gamma_from_1[w];
-                        *sp = w;
+                        v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
+                        *sp = (png_byte)((v >> 8) & 0xff);
+                        *(sp + 1) = (png_byte)(v & 0xff);
                      }
                   }
                }
@@ -3631,298 +3449,486 @@ png_do_compose(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
                   sp = row;
                   for (i = 0; i < row_width; i++, sp += 2)
                   {
-                     png_byte a = *(sp + 1);
+                     png_uint_16 v;
 
-                     if (a == 0)
-                        *sp = (png_byte)png_ptr->background.gray;
+                     v = (png_uint_16)(((*sp) << 8) + *(sp + 1));
 
-                     else if (a < 0xff)
-                        png_composite(*sp, *sp, a, png_ptr->background.gray);
-                  }
-               }
-            }
-            else /* if (png_ptr->bit_depth == 16) */
-            {
-#ifdef PNG_READ_GAMMA_SUPPORTED
-               if (gamma_16 != NULL && gamma_16_from_1 != NULL &&
-                   gamma_16_to_1 != NULL)
-               {
-                  sp = row;
-                  for (i = 0; i < row_width; i++, sp += 4)
-                  {
-                     png_uint_16 a = (png_uint_16)(((*(sp + 2)) << 8)
-                         + *(sp + 3));
-
-                     if (a == (png_uint_16)0xffff)
-                     {
-                        png_uint_16 v;
-
-                        v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
-                        *sp = (png_byte)((v >> 8) & 0xff);
-                        *(sp + 1) = (png_byte)(v & 0xff);
-                     }
-
-                     else if (a == 0)
-                     {
-                        /* Background is already in screen gamma */
-                        *sp = (png_byte)((png_ptr->background.gray >> 8)
-                                & 0xff);
-                        *(sp + 1) = (png_byte)(png_ptr->background.gray & 0xff);
-                     }
-
-                     else
-                     {
-                        png_uint_16 g, v, w;
-
-                        g = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];
-                        png_composite_16(v, g, a, png_ptr->background_1.gray);
-                        if (optimize != 0)
-                           w = v;
-                        else
-                           w = gamma_16_from_1[(v & 0xff) >>
-                               gamma_shift][v >> 8];
-                        *sp = (png_byte)((w >> 8) & 0xff);
-                        *(sp + 1) = (png_byte)(w & 0xff);
-                     }
-                  }
-               }
-               else
-#endif
-               {
-                  sp = row;
-                  for (i = 0; i < row_width; i++, sp += 4)
-                  {
-                     png_uint_16 a = (png_uint_16)(((*(sp + 2)) << 8)
-                         + *(sp + 3));
-
-                     if (a == 0)
+                     if (v == png_ptr->trans_color.gray)
                      {
                         *sp = (png_byte)((png_ptr->background.gray >> 8)
-                                & 0xff);
-                        *(sp + 1) = (png_byte)(png_ptr->background.gray & 0xff);
-                     }
-
-                     else if (a < 0xffff)
-                     {
-                        png_uint_16 g, v;
-
-                        g = (png_uint_16)(((*sp) << 8) + *(sp + 1));
-                        png_composite_16(v, g, a, png_ptr->background.gray);
-                        *sp = (png_byte)((v >> 8) & 0xff);
-                        *(sp + 1) = (png_byte)(v & 0xff);
+                             & 0xff);
+                        *(sp + 1) = (png_byte)(png_ptr->background.gray
+                             & 0xff);
                      }
                   }
                }
+               break;
             }
-            break;
+
+            default:
+               break;
          }
-
-         case PNG_COLOR_TYPE_RGB_ALPHA:
-         {
-            if (row_info->bit_depth == 8)
-            {
-#ifdef PNG_READ_GAMMA_SUPPORTED
-               if (gamma_to_1 != NULL && gamma_from_1 != NULL &&
-                   gamma_table != NULL)
-               {
-                  sp = row;
-                  for (i = 0; i < row_width; i++, sp += 4)
-                  {
-                     png_byte a = *(sp + 3);
-
-                     if (a == 0xff)
-                     {
-                        *sp = gamma_table[*sp];
-                        *(sp + 1) = gamma_table[*(sp + 1)];
-                        *(sp + 2) = gamma_table[*(sp + 2)];
-                     }
-
-                     else if (a == 0)
-                     {
-                        /* Background is already in screen gamma */
-                        *sp = (png_byte)png_ptr->background.red;
-                        *(sp + 1) = (png_byte)png_ptr->background.green;
-                        *(sp + 2) = (png_byte)png_ptr->background.blue;
-                     }
-
-                     else
-                     {
-                        png_byte v, w;
-
-                        v = gamma_to_1[*sp];
-                        png_composite(w, v, a, png_ptr->background_1.red);
-                        if (optimize == 0) w = gamma_from_1[w];
-                        *sp = w;
-
-                        v = gamma_to_1[*(sp + 1)];
-                        png_composite(w, v, a, png_ptr->background_1.green);
-                        if (optimize == 0) w = gamma_from_1[w];
-                        *(sp + 1) = w;
-
-                        v = gamma_to_1[*(sp + 2)];
-                        png_composite(w, v, a, png_ptr->background_1.blue);
-                        if (optimize == 0) w = gamma_from_1[w];
-                        *(sp + 2) = w;
-                     }
-                  }
-               }
-               else
-#endif
-               {
-                  sp = row;
-                  for (i = 0; i < row_width; i++, sp += 4)
-                  {
-                     png_byte a = *(sp + 3);
-
-                     if (a == 0)
-                     {
-                        *sp = (png_byte)png_ptr->background.red;
-                        *(sp + 1) = (png_byte)png_ptr->background.green;
-                        *(sp + 2) = (png_byte)png_ptr->background.blue;
-                     }
-
-                     else if (a < 0xff)
-                     {
-                        png_composite(*sp, *sp, a, png_ptr->background.red);
-
-                        png_composite(*(sp + 1), *(sp + 1), a,
-                            png_ptr->background.green);
-
-                        png_composite(*(sp + 2), *(sp + 2), a,
-                            png_ptr->background.blue);
-                     }
-                  }
-               }
-            }
-            else /* if (row_info->bit_depth == 16) */
-            {
-#ifdef PNG_READ_GAMMA_SUPPORTED
-               if (gamma_16 != NULL && gamma_16_from_1 != NULL &&
-                   gamma_16_to_1 != NULL)
-               {
-                  sp = row;
-                  for (i = 0; i < row_width; i++, sp += 8)
-                  {
-                     png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))
-                         << 8) + (png_uint_16)(*(sp + 7)));
-
-                     if (a == (png_uint_16)0xffff)
-                     {
-                        png_uint_16 v;
-
-                        v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
-                        *sp = (png_byte)((v >> 8) & 0xff);
-                        *(sp + 1) = (png_byte)(v & 0xff);
-
-                        v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];
-                        *(sp + 2) = (png_byte)((v >> 8) & 0xff);
-                        *(sp + 3) = (png_byte)(v & 0xff);
-
-                        v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];
-                        *(sp + 4) = (png_byte)((v >> 8) & 0xff);
-                        *(sp + 5) = (png_byte)(v & 0xff);
-                     }
-
-                     else if (a == 0)
-                     {
-                        /* Background is already in screen gamma */
-                        *sp = (png_byte)((png_ptr->background.red >> 8) & 0xff);
-                        *(sp + 1) = (png_byte)(png_ptr->background.red & 0xff);
-                        *(sp + 2) = (png_byte)((png_ptr->background.green >> 8)
-                                & 0xff);
-                        *(sp + 3) = (png_byte)(png_ptr->background.green
-                                & 0xff);
-                        *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8)
-                                & 0xff);
-                        *(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff);
-                     }
-
-                     else
-                     {
-                        png_uint_16 v, w;
-
-                        v = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];
-                        png_composite_16(w, v, a, png_ptr->background_1.red);
-                        if (optimize == 0)
-                           w = gamma_16_from_1[((w & 0xff) >> gamma_shift)][w >>
-                                8];
-                        *sp = (png_byte)((w >> 8) & 0xff);
-                        *(sp + 1) = (png_byte)(w & 0xff);
-
-                        v = gamma_16_to_1[*(sp + 3) >> gamma_shift][*(sp + 2)];
-                        png_composite_16(w, v, a, png_ptr->background_1.green);
-                        if (optimize == 0)
-                           w = gamma_16_from_1[((w & 0xff) >> gamma_shift)][w >>
-                                8];
-
-                        *(sp + 2) = (png_byte)((w >> 8) & 0xff);
-                        *(sp + 3) = (png_byte)(w & 0xff);
-
-                        v = gamma_16_to_1[*(sp + 5) >> gamma_shift][*(sp + 4)];
-                        png_composite_16(w, v, a, png_ptr->background_1.blue);
-                        if (optimize == 0)
-                           w = gamma_16_from_1[((w & 0xff) >> gamma_shift)][w >>
-                                8];
-
-                        *(sp + 4) = (png_byte)((w >> 8) & 0xff);
-                        *(sp + 5) = (png_byte)(w & 0xff);
-                     }
-                  }
-               }
-
-               else
-#endif
-               {
-                  sp = row;
-                  for (i = 0; i < row_width; i++, sp += 8)
-                  {
-                     png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))
-                         << 8) + (png_uint_16)(*(sp + 7)));
-
-                     if (a == 0)
-                     {
-                        *sp = (png_byte)((png_ptr->background.red >> 8) & 0xff);
-                        *(sp + 1) = (png_byte)(png_ptr->background.red & 0xff);
-                        *(sp + 2) = (png_byte)((png_ptr->background.green >> 8)
-                                & 0xff);
-                        *(sp + 3) = (png_byte)(png_ptr->background.green
-                                & 0xff);
-                        *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8)
-                                & 0xff);
-                        *(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff);
-                     }
-
-                     else if (a < 0xffff)
-                     {
-                        png_uint_16 v;
-
-                        png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));
-                        png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8)
-                            + *(sp + 3));
-                        png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8)
-                            + *(sp + 5));
-
-                        png_composite_16(v, r, a, png_ptr->background.red);
-                        *sp = (png_byte)((v >> 8) & 0xff);
-                        *(sp + 1) = (png_byte)(v & 0xff);
-
-                        png_composite_16(v, g, a, png_ptr->background.green);
-                        *(sp + 2) = (png_byte)((v >> 8) & 0xff);
-                        *(sp + 3) = (png_byte)(v & 0xff);
-
-                        png_composite_16(v, b, a, png_ptr->background.blue);
-                        *(sp + 4) = (png_byte)((v >> 8) & 0xff);
-                        *(sp + 5) = (png_byte)(v & 0xff);
-                     }
-                  }
-               }
-            }
-            break;
-         }
-
-         default:
-            break;
+         break;
       }
+
+      case PNG_COLOR_TYPE_RGB:
+      {
+         if (row_info->bit_depth == 8)
+         {
+#ifdef PNG_READ_GAMMA_SUPPORTED
+            if (gamma_table != NULL)
+            {
+               sp = row;
+               for (i = 0; i < row_width; i++, sp += 3)
+               {
+                  if (*sp == png_ptr->trans_color.red &&
+                      *(sp + 1) == png_ptr->trans_color.green &&
+                      *(sp + 2) == png_ptr->trans_color.blue)
+                  {
+                     *sp = (png_byte)png_ptr->background.red;
+                     *(sp + 1) = (png_byte)png_ptr->background.green;
+                     *(sp + 2) = (png_byte)png_ptr->background.blue;
+                  }
+
+                  else
+                  {
+                     *sp = gamma_table[*sp];
+                     *(sp + 1) = gamma_table[*(sp + 1)];
+                     *(sp + 2) = gamma_table[*(sp + 2)];
+                  }
+               }
+            }
+            else
+#endif
+            {
+               sp = row;
+               for (i = 0; i < row_width; i++, sp += 3)
+               {
+                  if (*sp == png_ptr->trans_color.red &&
+                      *(sp + 1) == png_ptr->trans_color.green &&
+                      *(sp + 2) == png_ptr->trans_color.blue)
+                  {
+                     *sp = (png_byte)png_ptr->background.red;
+                     *(sp + 1) = (png_byte)png_ptr->background.green;
+                     *(sp + 2) = (png_byte)png_ptr->background.blue;
+                  }
+               }
+            }
+         }
+         else /* if (row_info->bit_depth == 16) */
+         {
+#ifdef PNG_READ_GAMMA_SUPPORTED
+            if (gamma_16 != NULL)
+            {
+               sp = row;
+               for (i = 0; i < row_width; i++, sp += 6)
+               {
+                  png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));
+
+                  png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8)
+                      + *(sp + 3));
+
+                  png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8)
+                      + *(sp + 5));
+
+                  if (r == png_ptr->trans_color.red &&
+                      g == png_ptr->trans_color.green &&
+                      b == png_ptr->trans_color.blue)
+                  {
+                     /* Background is already in screen gamma */
+                     *sp = (png_byte)((png_ptr->background.red >> 8) & 0xff);
+                     *(sp + 1) = (png_byte)(png_ptr->background.red & 0xff);
+                     *(sp + 2) = (png_byte)((png_ptr->background.green >> 8)
+                             & 0xff);
+                     *(sp + 3) = (png_byte)(png_ptr->background.green
+                             & 0xff);
+                     *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8)
+                             & 0xff);
+                     *(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff);
+                  }
+
+                  else
+                  {
+                     png_uint_16 v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
+                     *sp = (png_byte)((v >> 8) & 0xff);
+                     *(sp + 1) = (png_byte)(v & 0xff);
+
+                     v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];
+                     *(sp + 2) = (png_byte)((v >> 8) & 0xff);
+                     *(sp + 3) = (png_byte)(v & 0xff);
+
+                     v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];
+                     *(sp + 4) = (png_byte)((v >> 8) & 0xff);
+                     *(sp + 5) = (png_byte)(v & 0xff);
+                  }
+               }
+            }
+
+            else
+#endif
+            {
+               sp = row;
+               for (i = 0; i < row_width; i++, sp += 6)
+               {
+                  png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));
+
+                  png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8)
+                      + *(sp + 3));
+
+                  png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8)
+                      + *(sp + 5));
+
+                  if (r == png_ptr->trans_color.red &&
+                      g == png_ptr->trans_color.green &&
+                      b == png_ptr->trans_color.blue)
+                  {
+                     *sp = (png_byte)((png_ptr->background.red >> 8) & 0xff);
+                     *(sp + 1) = (png_byte)(png_ptr->background.red & 0xff);
+                     *(sp + 2) = (png_byte)((png_ptr->background.green >> 8)
+                             & 0xff);
+                     *(sp + 3) = (png_byte)(png_ptr->background.green
+                             & 0xff);
+                     *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8)
+                             & 0xff);
+                     *(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff);
+                  }
+               }
+            }
+         }
+         break;
+      }
+
+      case PNG_COLOR_TYPE_GRAY_ALPHA:
+      {
+         if (row_info->bit_depth == 8)
+         {
+#ifdef PNG_READ_GAMMA_SUPPORTED
+            if (gamma_to_1 != NULL && gamma_from_1 != NULL &&
+                gamma_table != NULL)
+            {
+               sp = row;
+               for (i = 0; i < row_width; i++, sp += 2)
+               {
+                  png_uint_16 a = *(sp + 1);
+
+                  if (a == 0xff)
+                     *sp = gamma_table[*sp];
+
+                  else if (a == 0)
+                  {
+                     /* Background is already in screen gamma */
+                     *sp = (png_byte)png_ptr->background.gray;
+                  }
+
+                  else
+                  {
+                     png_byte v, w;
+
+                     v = gamma_to_1[*sp];
+                     png_composite(w, v, a, png_ptr->background_1.gray);
+                     if (optimize == 0)
+                        w = gamma_from_1[w];
+                     *sp = w;
+                  }
+               }
+            }
+            else
+#endif
+            {
+               sp = row;
+               for (i = 0; i < row_width; i++, sp += 2)
+               {
+                  png_byte a = *(sp + 1);
+
+                  if (a == 0)
+                     *sp = (png_byte)png_ptr->background.gray;
+
+                  else if (a < 0xff)
+                     png_composite(*sp, *sp, a, png_ptr->background.gray);
+               }
+            }
+         }
+         else /* if (png_ptr->bit_depth == 16) */
+         {
+#ifdef PNG_READ_GAMMA_SUPPORTED
+            if (gamma_16 != NULL && gamma_16_from_1 != NULL &&
+                gamma_16_to_1 != NULL)
+            {
+               sp = row;
+               for (i = 0; i < row_width; i++, sp += 4)
+               {
+                  png_uint_16 a = (png_uint_16)(((*(sp + 2)) << 8)
+                      + *(sp + 3));
+
+                  if (a == (png_uint_16)0xffff)
+                  {
+                     png_uint_16 v;
+
+                     v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
+                     *sp = (png_byte)((v >> 8) & 0xff);
+                     *(sp + 1) = (png_byte)(v & 0xff);
+                  }
+
+                  else if (a == 0)
+                  {
+                     /* Background is already in screen gamma */
+                     *sp = (png_byte)((png_ptr->background.gray >> 8)
+                             & 0xff);
+                     *(sp + 1) = (png_byte)(png_ptr->background.gray & 0xff);
+                  }
+
+                  else
+                  {
+                     png_uint_16 g, v, w;
+
+                     g = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];
+                     png_composite_16(v, g, a, png_ptr->background_1.gray);
+                     if (optimize != 0)
+                        w = v;
+                     else
+                        w = gamma_16_from_1[(v & 0xff) >>
+                            gamma_shift][v >> 8];
+                     *sp = (png_byte)((w >> 8) & 0xff);
+                     *(sp + 1) = (png_byte)(w & 0xff);
+                  }
+               }
+            }
+            else
+#endif
+            {
+               sp = row;
+               for (i = 0; i < row_width; i++, sp += 4)
+               {
+                  png_uint_16 a = (png_uint_16)(((*(sp + 2)) << 8)
+                      + *(sp + 3));
+
+                  if (a == 0)
+                  {
+                     *sp = (png_byte)((png_ptr->background.gray >> 8)
+                             & 0xff);
+                     *(sp + 1) = (png_byte)(png_ptr->background.gray & 0xff);
+                  }
+
+                  else if (a < 0xffff)
+                  {
+                     png_uint_16 g, v;
+
+                     g = (png_uint_16)(((*sp) << 8) + *(sp + 1));
+                     png_composite_16(v, g, a, png_ptr->background.gray);
+                     *sp = (png_byte)((v >> 8) & 0xff);
+                     *(sp + 1) = (png_byte)(v & 0xff);
+                  }
+               }
+            }
+         }
+         break;
+      }
+
+      case PNG_COLOR_TYPE_RGB_ALPHA:
+      {
+         if (row_info->bit_depth == 8)
+         {
+#ifdef PNG_READ_GAMMA_SUPPORTED
+            if (gamma_to_1 != NULL && gamma_from_1 != NULL &&
+                gamma_table != NULL)
+            {
+               sp = row;
+               for (i = 0; i < row_width; i++, sp += 4)
+               {
+                  png_byte a = *(sp + 3);
+
+                  if (a == 0xff)
+                  {
+                     *sp = gamma_table[*sp];
+                     *(sp + 1) = gamma_table[*(sp + 1)];
+                     *(sp + 2) = gamma_table[*(sp + 2)];
+                  }
+
+                  else if (a == 0)
+                  {
+                     /* Background is already in screen gamma */
+                     *sp = (png_byte)png_ptr->background.red;
+                     *(sp + 1) = (png_byte)png_ptr->background.green;
+                     *(sp + 2) = (png_byte)png_ptr->background.blue;
+                  }
+
+                  else
+                  {
+                     png_byte v, w;
+
+                     v = gamma_to_1[*sp];
+                     png_composite(w, v, a, png_ptr->background_1.red);
+                     if (optimize == 0) w = gamma_from_1[w];
+                     *sp = w;
+
+                     v = gamma_to_1[*(sp + 1)];
+                     png_composite(w, v, a, png_ptr->background_1.green);
+                     if (optimize == 0) w = gamma_from_1[w];
+                     *(sp + 1) = w;
+
+                     v = gamma_to_1[*(sp + 2)];
+                     png_composite(w, v, a, png_ptr->background_1.blue);
+                     if (optimize == 0) w = gamma_from_1[w];
+                     *(sp + 2) = w;
+                  }
+               }
+            }
+            else
+#endif
+            {
+               sp = row;
+               for (i = 0; i < row_width; i++, sp += 4)
+               {
+                  png_byte a = *(sp + 3);
+
+                  if (a == 0)
+                  {
+                     *sp = (png_byte)png_ptr->background.red;
+                     *(sp + 1) = (png_byte)png_ptr->background.green;
+                     *(sp + 2) = (png_byte)png_ptr->background.blue;
+                  }
+
+                  else if (a < 0xff)
+                  {
+                     png_composite(*sp, *sp, a, png_ptr->background.red);
+
+                     png_composite(*(sp + 1), *(sp + 1), a,
+                         png_ptr->background.green);
+
+                     png_composite(*(sp + 2), *(sp + 2), a,
+                         png_ptr->background.blue);
+                  }
+               }
+            }
+         }
+         else /* if (row_info->bit_depth == 16) */
+         {
+#ifdef PNG_READ_GAMMA_SUPPORTED
+            if (gamma_16 != NULL && gamma_16_from_1 != NULL &&
+                gamma_16_to_1 != NULL)
+            {
+               sp = row;
+               for (i = 0; i < row_width; i++, sp += 8)
+               {
+                  png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))
+                      << 8) + (png_uint_16)(*(sp + 7)));
+
+                  if (a == (png_uint_16)0xffff)
+                  {
+                     png_uint_16 v;
+
+                     v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
+                     *sp = (png_byte)((v >> 8) & 0xff);
+                     *(sp + 1) = (png_byte)(v & 0xff);
+
+                     v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];
+                     *(sp + 2) = (png_byte)((v >> 8) & 0xff);
+                     *(sp + 3) = (png_byte)(v & 0xff);
+
+                     v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];
+                     *(sp + 4) = (png_byte)((v >> 8) & 0xff);
+                     *(sp + 5) = (png_byte)(v & 0xff);
+                  }
+
+                  else if (a == 0)
+                  {
+                     /* Background is already in screen gamma */
+                     *sp = (png_byte)((png_ptr->background.red >> 8) & 0xff);
+                     *(sp + 1) = (png_byte)(png_ptr->background.red & 0xff);
+                     *(sp + 2) = (png_byte)((png_ptr->background.green >> 8)
+                             & 0xff);
+                     *(sp + 3) = (png_byte)(png_ptr->background.green
+                             & 0xff);
+                     *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8)
+                             & 0xff);
+                     *(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff);
+                  }
+
+                  else
+                  {
+                     png_uint_16 v, w;
+
+                     v = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];
+                     png_composite_16(w, v, a, png_ptr->background_1.red);
+                     if (optimize == 0)
+                        w = gamma_16_from_1[((w & 0xff) >> gamma_shift)][w >>
+                             8];
+                     *sp = (png_byte)((w >> 8) & 0xff);
+                     *(sp + 1) = (png_byte)(w & 0xff);
+
+                     v = gamma_16_to_1[*(sp + 3) >> gamma_shift][*(sp + 2)];
+                     png_composite_16(w, v, a, png_ptr->background_1.green);
+                     if (optimize == 0)
+                        w = gamma_16_from_1[((w & 0xff) >> gamma_shift)][w >>
+                             8];
+
+                     *(sp + 2) = (png_byte)((w >> 8) & 0xff);
+                     *(sp + 3) = (png_byte)(w & 0xff);
+
+                     v = gamma_16_to_1[*(sp + 5) >> gamma_shift][*(sp + 4)];
+                     png_composite_16(w, v, a, png_ptr->background_1.blue);
+                     if (optimize == 0)
+                        w = gamma_16_from_1[((w & 0xff) >> gamma_shift)][w >>
+                             8];
+
+                     *(sp + 4) = (png_byte)((w >> 8) & 0xff);
+                     *(sp + 5) = (png_byte)(w & 0xff);
+                  }
+               }
+            }
+
+            else
+#endif
+            {
+               sp = row;
+               for (i = 0; i < row_width; i++, sp += 8)
+               {
+                  png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))
+                      << 8) + (png_uint_16)(*(sp + 7)));
+
+                  if (a == 0)
+                  {
+                     *sp = (png_byte)((png_ptr->background.red >> 8) & 0xff);
+                     *(sp + 1) = (png_byte)(png_ptr->background.red & 0xff);
+                     *(sp + 2) = (png_byte)((png_ptr->background.green >> 8)
+                             & 0xff);
+                     *(sp + 3) = (png_byte)(png_ptr->background.green
+                             & 0xff);
+                     *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8)
+                             & 0xff);
+                     *(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff);
+                  }
+
+                  else if (a < 0xffff)
+                  {
+                     png_uint_16 v;
+
+                     png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));
+                     png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8)
+                         + *(sp + 3));
+                     png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8)
+                         + *(sp + 5));
+
+                     png_composite_16(v, r, a, png_ptr->background.red);
+                     *sp = (png_byte)((v >> 8) & 0xff);
+                     *(sp + 1) = (png_byte)(v & 0xff);
+
+                     png_composite_16(v, g, a, png_ptr->background.green);
+                     *(sp + 2) = (png_byte)((v >> 8) & 0xff);
+                     *(sp + 3) = (png_byte)(v & 0xff);
+
+                     png_composite_16(v, b, a, png_ptr->background.blue);
+                     *(sp + 4) = (png_byte)((v >> 8) & 0xff);
+                     *(sp + 5) = (png_byte)(v & 0xff);
+                  }
+               }
+            }
+         }
+         break;
+      }
+
+      default:
+         break;
    }
 }
 #endif /* READ_BACKGROUND || READ_ALPHA_MODE */
@@ -4146,12 +4152,11 @@ png_do_encode_alpha(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
    {
       if (row_info->bit_depth == 8)
       {
-         PNG_CONST png_bytep table = png_ptr->gamma_from_1;
+         png_bytep table = png_ptr->gamma_from_1;
 
          if (table != NULL)
          {
-            PNG_CONST int step =
-               (row_info->color_type & PNG_COLOR_MASK_COLOR) ? 4 : 2;
+            int step = (row_info->color_type & PNG_COLOR_MASK_COLOR) ? 4 : 2;
 
             /* The alpha channel is the last component: */
             row += step - 1;
@@ -4165,13 +4170,12 @@ png_do_encode_alpha(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
 
       else if (row_info->bit_depth == 16)
       {
-         PNG_CONST png_uint_16pp table = png_ptr->gamma_16_from_1;
-         PNG_CONST int gamma_shift = png_ptr->gamma_shift;
+         png_uint_16pp table = png_ptr->gamma_16_from_1;
+         int gamma_shift = png_ptr->gamma_shift;
 
          if (table != NULL)
          {
-            PNG_CONST int step =
-               (row_info->color_type & PNG_COLOR_MASK_COLOR) ? 8 : 4;
+            int step = (row_info->color_type & PNG_COLOR_MASK_COLOR) ? 8 : 4;
 
             /* The alpha channel is the last component: */
             row += step - 2;
@@ -4202,8 +4206,9 @@ png_do_encode_alpha(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
  * upon whether you supply trans and num_trans.
  */
 static void
-png_do_expand_palette(png_row_infop row_info, png_bytep row,
-    png_const_colorp palette, png_const_bytep trans_alpha, int num_trans)
+png_do_expand_palette(png_structrp png_ptr, png_row_infop row_info,
+    png_bytep row, png_const_colorp palette, png_const_bytep trans_alpha,
+    int num_trans)
 {
    int shift, value;
    png_bytep sp, dp;
@@ -4220,8 +4225,8 @@ png_do_expand_palette(png_row_infop row_info, png_bytep row,
          {
             case 1:
             {
-               sp = row + (png_size_t)((row_width - 1) >> 3);
-               dp = row + (png_size_t)row_width - 1;
+               sp = row + (size_t)((row_width - 1) >> 3);
+               dp = row + (size_t)row_width - 1;
                shift = 7 - (int)((row_width + 7) & 0x07);
                for (i = 0; i < row_width; i++)
                {
@@ -4247,8 +4252,8 @@ png_do_expand_palette(png_row_infop row_info, png_bytep row,
 
             case 2:
             {
-               sp = row + (png_size_t)((row_width - 1) >> 2);
-               dp = row + (png_size_t)row_width - 1;
+               sp = row + (size_t)((row_width - 1) >> 2);
+               dp = row + (size_t)row_width - 1;
                shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);
                for (i = 0; i < row_width; i++)
                {
@@ -4270,8 +4275,8 @@ png_do_expand_palette(png_row_infop row_info, png_bytep row,
 
             case 4:
             {
-               sp = row + (png_size_t)((row_width - 1) >> 1);
-               dp = row + (png_size_t)row_width - 1;
+               sp = row + (size_t)((row_width - 1) >> 1);
+               dp = row + (size_t)row_width - 1;
                shift = (int)((row_width & 0x01) << 2);
                for (i = 0; i < row_width; i++)
                {
@@ -4304,17 +4309,30 @@ png_do_expand_palette(png_row_infop row_info, png_bytep row,
          {
             if (num_trans > 0)
             {
-               sp = row + (png_size_t)row_width - 1;
-               dp = row + ((png_size_t)row_width << 2) - 1;
+               sp = row + (size_t)row_width - 1;
+               dp = row + ((size_t)row_width << 2) - 1;
 
-               for (i = 0; i < row_width; i++)
+               i = 0;
+#ifdef PNG_ARM_NEON_INTRINSICS_AVAILABLE
+               if (png_ptr->riffled_palette != NULL)
+               {
+                  /* The RGBA optimization works with png_ptr->bit_depth == 8
+                   * but sometimes row_info->bit_depth has been changed to 8.
+                   * In these cases, the palette hasn't been riffled.
+                   */
+                  i = png_do_expand_palette_rgba8_neon(png_ptr, row_info, row,
+                      &sp, &dp);
+               }
+#else
+               PNG_UNUSED(png_ptr)
+#endif
+
+               for (; i < row_width; i++)
                {
                   if ((int)(*sp) >= num_trans)
                      *dp-- = 0xff;
-
                   else
                      *dp-- = trans_alpha[*sp];
-
                   *dp-- = palette[*sp].blue;
                   *dp-- = palette[*sp].green;
                   *dp-- = palette[*sp].red;
@@ -4329,10 +4347,17 @@ png_do_expand_palette(png_row_infop row_info, png_bytep row,
 
             else
             {
-               sp = row + (png_size_t)row_width - 1;
-               dp = row + (png_size_t)(row_width * 3) - 1;
+               sp = row + (size_t)row_width - 1;
+               dp = row + (size_t)(row_width * 3) - 1;
+               i = 0;
+#ifdef PNG_ARM_NEON_INTRINSICS_AVAILABLE
+               i = png_do_expand_palette_rgb8_neon(png_ptr, row_info, row,
+                   &sp, &dp);
+#else
+               PNG_UNUSED(png_ptr)
+#endif
 
-               for (i = 0; i < row_width; i++)
+               for (; i < row_width; i++)
                {
                   *dp-- = palette[*sp].blue;
                   *dp-- = palette[*sp].green;
@@ -4365,195 +4390,130 @@ png_do_expand(png_row_infop row_info, png_bytep row,
 
    png_debug(1, "in png_do_expand");
 
+   if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
    {
-      if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
+      unsigned int gray = trans_color != NULL ? trans_color->gray : 0;
+
+      if (row_info->bit_depth < 8)
       {
-         unsigned int gray = trans_color != NULL ? trans_color->gray : 0;
-
-         if (row_info->bit_depth < 8)
+         switch (row_info->bit_depth)
          {
-            switch (row_info->bit_depth)
+            case 1:
             {
-               case 1:
-               {
-                  gray = (gray & 0x01) * 0xff;
-                  sp = row + (png_size_t)((row_width - 1) >> 3);
-                  dp = row + (png_size_t)row_width - 1;
-                  shift = 7 - (int)((row_width + 7) & 0x07);
-                  for (i = 0; i < row_width; i++)
-                  {
-                     if ((*sp >> shift) & 0x01)
-                        *dp = 0xff;
-
-                     else
-                        *dp = 0;
-
-                     if (shift == 7)
-                     {
-                        shift = 0;
-                        sp--;
-                     }
-
-                     else
-                        shift++;
-
-                     dp--;
-                  }
-                  break;
-               }
-
-               case 2:
-               {
-                  gray = (gray & 0x03) * 0x55;
-                  sp = row + (png_size_t)((row_width - 1) >> 2);
-                  dp = row + (png_size_t)row_width - 1;
-                  shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);
-                  for (i = 0; i < row_width; i++)
-                  {
-                     value = (*sp >> shift) & 0x03;
-                     *dp = (png_byte)(value | (value << 2) | (value << 4) |
-                        (value << 6));
-                     if (shift == 6)
-                     {
-                        shift = 0;
-                        sp--;
-                     }
-
-                     else
-                        shift += 2;
-
-                     dp--;
-                  }
-                  break;
-               }
-
-               case 4:
-               {
-                  gray = (gray & 0x0f) * 0x11;
-                  sp = row + (png_size_t)((row_width - 1) >> 1);
-                  dp = row + (png_size_t)row_width - 1;
-                  shift = (int)((1 - ((row_width + 1) & 0x01)) << 2);
-                  for (i = 0; i < row_width; i++)
-                  {
-                     value = (*sp >> shift) & 0x0f;
-                     *dp = (png_byte)(value | (value << 4));
-                     if (shift == 4)
-                     {
-                        shift = 0;
-                        sp--;
-                     }
-
-                     else
-                        shift = 4;
-
-                     dp--;
-                  }
-                  break;
-               }
-
-               default:
-                  break;
-            }
-
-            row_info->bit_depth = 8;
-            row_info->pixel_depth = 8;
-            row_info->rowbytes = row_width;
-         }
-
-         if (trans_color != NULL)
-         {
-            if (row_info->bit_depth == 8)
-            {
-               gray = gray & 0xff;
-               sp = row + (png_size_t)row_width - 1;
-               dp = row + ((png_size_t)row_width << 1) - 1;
-
+               gray = (gray & 0x01) * 0xff;
+               sp = row + (size_t)((row_width - 1) >> 3);
+               dp = row + (size_t)row_width - 1;
+               shift = 7 - (int)((row_width + 7) & 0x07);
                for (i = 0; i < row_width; i++)
                {
-                  if ((*sp & 0xffU) == gray)
-                     *dp-- = 0;
+                  if ((*sp >> shift) & 0x01)
+                     *dp = 0xff;
 
                   else
-                     *dp-- = 0xff;
+                     *dp = 0;
 
-                  *dp-- = *sp--;
-               }
-            }
-
-            else if (row_info->bit_depth == 16)
-            {
-               unsigned int gray_high = (gray >> 8) & 0xff;
-               unsigned int gray_low = gray & 0xff;
-               sp = row + row_info->rowbytes - 1;
-               dp = row + (row_info->rowbytes << 1) - 1;
-               for (i = 0; i < row_width; i++)
-               {
-                  if ((*(sp - 1) & 0xffU) == gray_high &&
-                      (*(sp) & 0xffU) == gray_low)
+                  if (shift == 7)
                   {
-                     *dp-- = 0;
-                     *dp-- = 0;
+                     shift = 0;
+                     sp--;
                   }
 
                   else
-                  {
-                     *dp-- = 0xff;
-                     *dp-- = 0xff;
-                  }
+                     shift++;
 
-                  *dp-- = *sp--;
-                  *dp-- = *sp--;
+                  dp--;
                }
+               break;
             }
 
-            row_info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
-            row_info->channels = 2;
-            row_info->pixel_depth = (png_byte)(row_info->bit_depth << 1);
-            row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,
-                row_width);
+            case 2:
+            {
+               gray = (gray & 0x03) * 0x55;
+               sp = row + (size_t)((row_width - 1) >> 2);
+               dp = row + (size_t)row_width - 1;
+               shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);
+               for (i = 0; i < row_width; i++)
+               {
+                  value = (*sp >> shift) & 0x03;
+                  *dp = (png_byte)(value | (value << 2) | (value << 4) |
+                     (value << 6));
+                  if (shift == 6)
+                  {
+                     shift = 0;
+                     sp--;
+                  }
+
+                  else
+                     shift += 2;
+
+                  dp--;
+               }
+               break;
+            }
+
+            case 4:
+            {
+               gray = (gray & 0x0f) * 0x11;
+               sp = row + (size_t)((row_width - 1) >> 1);
+               dp = row + (size_t)row_width - 1;
+               shift = (int)((1 - ((row_width + 1) & 0x01)) << 2);
+               for (i = 0; i < row_width; i++)
+               {
+                  value = (*sp >> shift) & 0x0f;
+                  *dp = (png_byte)(value | (value << 4));
+                  if (shift == 4)
+                  {
+                     shift = 0;
+                     sp--;
+                  }
+
+                  else
+                     shift = 4;
+
+                  dp--;
+               }
+               break;
+            }
+
+            default:
+               break;
          }
+
+         row_info->bit_depth = 8;
+         row_info->pixel_depth = 8;
+         row_info->rowbytes = row_width;
       }
-      else if (row_info->color_type == PNG_COLOR_TYPE_RGB &&
-          trans_color != NULL)
+
+      if (trans_color != NULL)
       {
          if (row_info->bit_depth == 8)
          {
-            png_byte red = (png_byte)(trans_color->red & 0xff);
-            png_byte green = (png_byte)(trans_color->green & 0xff);
-            png_byte blue = (png_byte)(trans_color->blue & 0xff);
-            sp = row + (png_size_t)row_info->rowbytes - 1;
-            dp = row + ((png_size_t)row_width << 2) - 1;
+            gray = gray & 0xff;
+            sp = row + (size_t)row_width - 1;
+            dp = row + ((size_t)row_width << 1) - 1;
+
             for (i = 0; i < row_width; i++)
             {
-               if (*(sp - 2) == red && *(sp - 1) == green && *(sp) == blue)
+               if ((*sp & 0xffU) == gray)
                   *dp-- = 0;
 
                else
                   *dp-- = 0xff;
 
                *dp-- = *sp--;
-               *dp-- = *sp--;
-               *dp-- = *sp--;
             }
          }
+
          else if (row_info->bit_depth == 16)
          {
-            png_byte red_high = (png_byte)((trans_color->red >> 8) & 0xff);
-            png_byte green_high = (png_byte)((trans_color->green >> 8) & 0xff);
-            png_byte blue_high = (png_byte)((trans_color->blue >> 8) & 0xff);
-            png_byte red_low = (png_byte)(trans_color->red & 0xff);
-            png_byte green_low = (png_byte)(trans_color->green & 0xff);
-            png_byte blue_low = (png_byte)(trans_color->blue & 0xff);
+            unsigned int gray_high = (gray >> 8) & 0xff;
+            unsigned int gray_low = gray & 0xff;
             sp = row + row_info->rowbytes - 1;
-            dp = row + ((png_size_t)row_width << 3) - 1;
+            dp = row + (row_info->rowbytes << 1) - 1;
             for (i = 0; i < row_width; i++)
             {
-               if (*(sp - 5) == red_high &&
-                   *(sp - 4) == red_low &&
-                   *(sp - 3) == green_high &&
-                   *(sp - 2) == green_low &&
-                   *(sp - 1) == blue_high &&
-                   *(sp    ) == blue_low)
+               if ((*(sp - 1) & 0xffU) == gray_high &&
+                   (*(sp) & 0xffU) == gray_low)
                {
                   *dp-- = 0;
                   *dp-- = 0;
@@ -4567,18 +4527,81 @@ png_do_expand(png_row_infop row_info, png_bytep row,
 
                *dp-- = *sp--;
                *dp-- = *sp--;
-               *dp-- = *sp--;
-               *dp-- = *sp--;
-               *dp-- = *sp--;
-               *dp-- = *sp--;
             }
          }
-         row_info->color_type = PNG_COLOR_TYPE_RGB_ALPHA;
-         row_info->channels = 4;
-         row_info->pixel_depth = (png_byte)(row_info->bit_depth << 2);
-         row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
+
+         row_info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
+         row_info->channels = 2;
+         row_info->pixel_depth = (png_byte)(row_info->bit_depth << 1);
+         row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,
+             row_width);
       }
    }
+   else if (row_info->color_type == PNG_COLOR_TYPE_RGB &&
+       trans_color != NULL)
+   {
+      if (row_info->bit_depth == 8)
+      {
+         png_byte red = (png_byte)(trans_color->red & 0xff);
+         png_byte green = (png_byte)(trans_color->green & 0xff);
+         png_byte blue = (png_byte)(trans_color->blue & 0xff);
+         sp = row + (size_t)row_info->rowbytes - 1;
+         dp = row + ((size_t)row_width << 2) - 1;
+         for (i = 0; i < row_width; i++)
+         {
+            if (*(sp - 2) == red && *(sp - 1) == green && *(sp) == blue)
+               *dp-- = 0;
+
+            else
+               *dp-- = 0xff;
+
+            *dp-- = *sp--;
+            *dp-- = *sp--;
+            *dp-- = *sp--;
+         }
+      }
+      else if (row_info->bit_depth == 16)
+      {
+         png_byte red_high = (png_byte)((trans_color->red >> 8) & 0xff);
+         png_byte green_high = (png_byte)((trans_color->green >> 8) & 0xff);
+         png_byte blue_high = (png_byte)((trans_color->blue >> 8) & 0xff);
+         png_byte red_low = (png_byte)(trans_color->red & 0xff);
+         png_byte green_low = (png_byte)(trans_color->green & 0xff);
+         png_byte blue_low = (png_byte)(trans_color->blue & 0xff);
+         sp = row + row_info->rowbytes - 1;
+         dp = row + ((size_t)row_width << 3) - 1;
+         for (i = 0; i < row_width; i++)
+         {
+            if (*(sp - 5) == red_high &&
+                *(sp - 4) == red_low &&
+                *(sp - 3) == green_high &&
+                *(sp - 2) == green_low &&
+                *(sp - 1) == blue_high &&
+                *(sp    ) == blue_low)
+            {
+               *dp-- = 0;
+               *dp-- = 0;
+            }
+
+            else
+            {
+               *dp-- = 0xff;
+               *dp-- = 0xff;
+            }
+
+            *dp-- = *sp--;
+            *dp-- = *sp--;
+            *dp-- = *sp--;
+            *dp-- = *sp--;
+            *dp-- = *sp--;
+            *dp-- = *sp--;
+         }
+      }
+      row_info->color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+      row_info->channels = 4;
+      row_info->pixel_depth = (png_byte)(row_info->bit_depth << 2);
+      row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
+   }
 }
 #endif
 
@@ -4748,7 +4771,19 @@ png_do_read_transformations(png_structrp png_ptr, png_row_infop row_info)
    {
       if (row_info->color_type == PNG_COLOR_TYPE_PALETTE)
       {
-         png_do_expand_palette(row_info, png_ptr->row_buf + 1,
+#ifdef PNG_ARM_NEON_INTRINSICS_AVAILABLE
+         if ((png_ptr->num_trans > 0) && (png_ptr->bit_depth == 8))
+         {
+            if (png_ptr->riffled_palette == NULL)
+            {
+               /* Initialize the accelerated palette expansion. */
+               png_ptr->riffled_palette =
+                   (png_bytep)png_malloc(png_ptr, 256 * 4);
+               png_riffle_palette_neon(png_ptr);
+            }
+         }
+#endif
+         png_do_expand_palette(png_ptr, row_info, png_ptr->row_buf + 1,
              png_ptr->palette, png_ptr->trans_alpha, png_ptr->num_trans);
       }
 
@@ -4760,8 +4795,7 @@ png_do_read_transformations(png_structrp png_ptr, png_row_infop row_info)
                 &(png_ptr->trans_color));
 
          else
-            png_do_expand(row_info, png_ptr->row_buf + 1,
-                NULL);
+            png_do_expand(row_info, png_ptr->row_buf + 1, NULL);
       }
    }
 #endif
@@ -4985,7 +5019,7 @@ png_do_read_transformations(png_structrp png_ptr, png_row_infop row_info)
              (png_ptr,     /* png_ptr */
              row_info,     /* row_info: */
                 /*  png_uint_32 width;       width of row */
-                /*  png_size_t rowbytes;     number of bytes in row */
+                /*  size_t rowbytes;         number of bytes in row */
                 /*  png_byte color_type;     color type of pixels */
                 /*  png_byte bit_depth;      bit depth of samples */
                 /*  png_byte channels;       number of channels (1-4) */
diff --git a/Engine/lib/lpng/pngrutil.c b/Engine/lib/lpng/pngrutil.c
index 8692933bd..d5fa08c39 100644
--- a/Engine/lib/lpng/pngrutil.c
+++ b/Engine/lib/lpng/pngrutil.c
@@ -1,10 +1,10 @@
 
 /* pngrutil.c - utilities to read a PNG file
  *
- * Last changed in libpng 1.6.33 [September 28, 2017]
- * Copyright (c) 1998-2002,2004,2006-2017 Glenn Randers-Pehrson
- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ * Copyright (c) 2018 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -102,7 +102,7 @@ png_get_int_32)(png_const_bytep buf)
 png_uint_16 (PNGAPI
 png_get_uint_16)(png_const_bytep buf)
 {
-   /* ANSI-C requires an int value to accomodate at least 16 bits so this
+   /* ANSI-C requires an int value to accommodate at least 16 bits so this
     * works and allows the compiler not to worry about possible narrowing
     * on 32-bit systems.  (Pre-ANSI systems did not make integers smaller
     * than 16 bits either.)
@@ -120,7 +120,7 @@ png_get_uint_16)(png_const_bytep buf)
 void /* PRIVATE */
 png_read_sig(png_structrp png_ptr, png_inforp info_ptr)
 {
-   png_size_t num_checked, num_to_check;
+   size_t num_checked, num_to_check;
 
    /* Exit if the user application does not expect a signature. */
    if (png_ptr->sig_bytes >= 8)
@@ -1461,8 +1461,7 @@ png_handle_iCCP(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
                {
                   /* We have the ICC profile header; do the basic header checks.
                    */
-                  const png_uint_32 profile_length =
-                     png_get_uint_32(profile_header);
+                  png_uint_32 profile_length = png_get_uint_32(profile_header);
 
                   if (png_icc_check_length(png_ptr, &png_ptr->colorspace,
                       keyword, profile_length) != 0)
@@ -1479,8 +1478,8 @@ png_handle_iCCP(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
                          * profile.  The header check has already validated
                          * that none of this stuff will overflow.
                          */
-                        const png_uint_32 tag_count = png_get_uint_32(
-                            profile_header+128);
+                        png_uint_32 tag_count =
+                           png_get_uint_32(profile_header + 128);
                         png_bytep profile = png_read_buffer(png_ptr,
                             profile_length, 2/*silent*/);
 
@@ -1648,7 +1647,7 @@ png_handle_sPLT(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
    int entry_size, i;
    png_uint_32 skip = 0;
    png_uint_32 dl;
-   png_size_t max_dl;
+   size_t max_dl;
 
    png_debug(1, "in png_handle_sPLT");
 
@@ -1997,6 +1996,15 @@ png_handle_bKGD(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
 
    else if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) == 0) /* GRAY */
    {
+      if (png_ptr->bit_depth <= 8)
+      {
+         if (buf[0] != 0 || buf[1] >= (unsigned int)(1 << png_ptr->bit_depth))
+         {
+            png_chunk_benign_error(png_ptr, "invalid gray level");
+            return;
+         }
+      }
+
       background.index = 0;
       background.red =
       background.green =
@@ -2006,6 +2014,15 @@ png_handle_bKGD(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
 
    else
    {
+      if (png_ptr->bit_depth <= 8)
+      {
+         if (buf[0] != 0 || buf[2] != 0 || buf[4] != 0)
+         {
+            png_chunk_benign_error(png_ptr, "invalid color");
+            return;
+         }
+      }
+
       background.index = 0;
       background.red = png_get_uint_16(buf);
       background.green = png_get_uint_16(buf + 2);
@@ -2359,7 +2376,7 @@ void /* PRIVATE */
 png_handle_sCAL(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
 {
    png_bytep buffer;
-   png_size_t i;
+   size_t i;
    int state;
 
    png_debug(1, "in png_handle_sCAL");
@@ -2429,7 +2446,7 @@ png_handle_sCAL(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
 
    else
    {
-      png_size_t heighti = i;
+      size_t heighti = i;
 
       state = 0;
       if (png_check_fp_number((png_const_charp)buffer, length,
@@ -2867,7 +2884,7 @@ png_cache_unknown_chunk(png_structrp png_ptr, png_uint_32 length)
    {
       PNG_CSTRING_FROM_CHUNK(png_ptr->unknown_chunk.name, png_ptr->chunk_name);
       /* The following is safe because of the PNG_SIZE_MAX init above */
-      png_ptr->unknown_chunk.size = (png_size_t)length/*SAFE*/;
+      png_ptr->unknown_chunk.size = (size_t)length/*SAFE*/;
       /* 'mode' is a flag array, only the bottom four bits matter here */
       png_ptr->unknown_chunk.location = (png_byte)png_ptr->mode/*SAFE*/;
 
@@ -3114,7 +3131,7 @@ png_handle_unknown(png_structrp png_ptr, png_inforp info_ptr,
  */
 
 void /* PRIVATE */
-png_check_chunk_name(png_const_structrp png_ptr, const png_uint_32 chunk_name)
+png_check_chunk_name(png_const_structrp png_ptr, png_uint_32 chunk_name)
 {
    int i;
    png_uint_32 cn=chunk_name;
@@ -3133,7 +3150,7 @@ png_check_chunk_name(png_const_structrp png_ptr, const png_uint_32 chunk_name)
 }
 
 void /* PRIVATE */
-png_check_chunk_length(png_const_structrp png_ptr, const png_uint_32 length)
+png_check_chunk_length(png_const_structrp png_ptr, png_uint_32 length)
 {
    png_alloc_size_t limit = PNG_UINT_31_MAX;
 
@@ -3149,10 +3166,13 @@ png_check_chunk_length(png_const_structrp png_ptr, const png_uint_32 length)
    {
       png_alloc_size_t idat_limit = PNG_UINT_31_MAX;
       size_t row_factor =
-         (png_ptr->width * png_ptr->channels * (png_ptr->bit_depth > 8? 2: 1)
-          + 1 + (png_ptr->interlaced? 6: 0));
+         (size_t)png_ptr->width
+         * (size_t)png_ptr->channels
+         * (png_ptr->bit_depth > 8? 2: 1)
+         + 1
+         + (png_ptr->interlaced? 6: 0);
       if (png_ptr->height > PNG_UINT_32_MAX/row_factor)
-         idat_limit=PNG_UINT_31_MAX;
+         idat_limit = PNG_UINT_31_MAX;
       else
          idat_limit = png_ptr->height * row_factor;
       row_factor = row_factor > 32566? 32566 : row_factor;
@@ -3342,7 +3362,7 @@ png_combine_row(png_const_structrp png_ptr, png_bytep dp, int display)
          /* Hence the pre-compiled masks indexed by PACKSWAP (or not), depth and
           * then pass:
           */
-         static PNG_CONST png_uint_32 row_mask[2/*PACKSWAP*/][3/*depth*/][6] =
+         static const png_uint_32 row_mask[2/*PACKSWAP*/][3/*depth*/][6] =
          {
             /* Little-endian byte masks for PACKSWAP */
             { S_MASKS(1,0), S_MASKS(2,0), S_MASKS(4,0) },
@@ -3353,7 +3373,7 @@ png_combine_row(png_const_structrp png_ptr, png_bytep dp, int display)
          /* display_mask has only three entries for the odd passes, so index by
           * pass>>1.
           */
-         static PNG_CONST png_uint_32 display_mask[2][3][3] =
+         static const png_uint_32 display_mask[2][3][3] =
          {
             /* Little-endian byte masks for PACKSWAP */
             { B_MASKS(1,0), B_MASKS(2,0), B_MASKS(4,0) },
@@ -3666,7 +3686,7 @@ png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
 {
    /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
    /* Offset to next interlace block */
-   static PNG_CONST unsigned int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
+   static const unsigned int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
 
    png_debug(1, "in png_do_read_interlace");
    if (row != NULL && row_info != NULL)
@@ -3679,8 +3699,8 @@ png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
       {
          case 1:
          {
-            png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 3);
-            png_bytep dp = row + (png_size_t)((final_width - 1) >> 3);
+            png_bytep sp = row + (size_t)((row_info->width - 1) >> 3);
+            png_bytep dp = row + (size_t)((final_width - 1) >> 3);
             unsigned int sshift, dshift;
             unsigned int s_start, s_end;
             int s_inc;
@@ -3806,8 +3826,8 @@ png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
 
          case 4:
          {
-            png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 1);
-            png_bytep dp = row + (png_size_t)((final_width - 1) >> 1);
+            png_bytep sp = row + (size_t)((row_info->width - 1) >> 1);
+            png_bytep dp = row + (size_t)((final_width - 1) >> 1);
             unsigned int sshift, dshift;
             unsigned int s_start, s_end;
             int s_inc;
@@ -3869,12 +3889,12 @@ png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
 
          default:
          {
-            png_size_t pixel_bytes = (row_info->pixel_depth >> 3);
+            size_t pixel_bytes = (row_info->pixel_depth >> 3);
 
-            png_bytep sp = row + (png_size_t)(row_info->width - 1)
+            png_bytep sp = row + (size_t)(row_info->width - 1)
                 * pixel_bytes;
 
-            png_bytep dp = row + (png_size_t)(final_width - 1) * pixel_bytes;
+            png_bytep dp = row + (size_t)(final_width - 1) * pixel_bytes;
 
             int jstop = (int)png_pass_inc[pass];
             png_uint_32 i;
@@ -3911,8 +3931,8 @@ static void
 png_read_filter_row_sub(png_row_infop row_info, png_bytep row,
     png_const_bytep prev_row)
 {
-   png_size_t i;
-   png_size_t istop = row_info->rowbytes;
+   size_t i;
+   size_t istop = row_info->rowbytes;
    unsigned int bpp = (row_info->pixel_depth + 7) >> 3;
    png_bytep rp = row + bpp;
 
@@ -3929,8 +3949,8 @@ static void
 png_read_filter_row_up(png_row_infop row_info, png_bytep row,
     png_const_bytep prev_row)
 {
-   png_size_t i;
-   png_size_t istop = row_info->rowbytes;
+   size_t i;
+   size_t istop = row_info->rowbytes;
    png_bytep rp = row;
    png_const_bytep pp = prev_row;
 
@@ -3945,11 +3965,11 @@ static void
 png_read_filter_row_avg(png_row_infop row_info, png_bytep row,
     png_const_bytep prev_row)
 {
-   png_size_t i;
+   size_t i;
    png_bytep rp = row;
    png_const_bytep pp = prev_row;
    unsigned int bpp = (row_info->pixel_depth + 7) >> 3;
-   png_size_t istop = row_info->rowbytes - bpp;
+   size_t istop = row_info->rowbytes - bpp;
 
    for (i = 0; i < bpp; i++)
    {
@@ -4308,16 +4328,16 @@ png_read_finish_row(png_structrp png_ptr)
    /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
 
    /* Start of interlace block */
-   static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
+   static const png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
 
    /* Offset to next interlace block */
-   static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
+   static const png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
 
    /* Start of interlace block in the y direction */
-   static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
+   static const png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
 
    /* Offset to next interlace block in the y direction */
-   static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
+   static const png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
 
    png_debug(1, "in png_read_finish_row");
    png_ptr->row_number++;
@@ -4373,19 +4393,19 @@ png_read_start_row(png_structrp png_ptr)
    /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
 
    /* Start of interlace block */
-   static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
+   static const png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
 
    /* Offset to next interlace block */
-   static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
+   static const png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
 
    /* Start of interlace block in the y direction */
-   static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
+   static const png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
 
    /* Offset to next interlace block in the y direction */
-   static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
+   static const png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
 
    unsigned int max_pixel_depth;
-   png_size_t row_bytes;
+   size_t row_bytes;
 
    png_debug(1, "in png_read_start_row");
 
diff --git a/Engine/lib/lpng/pngset.c b/Engine/lib/lpng/pngset.c
index 6f3a1ee11..ec75dbe36 100644
--- a/Engine/lib/lpng/pngset.c
+++ b/Engine/lib/lpng/pngset.c
@@ -1,10 +1,10 @@
 
 /* pngset.c - storage of image information into info struct
  *
- * Last changed in libpng 1.6.32 [August 24, 2017]
- * Copyright (c) 1998-2017 Glenn Randers-Pehrson
- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ * Copyright (c) 2018 Cosmin Truta
+ * Copyright (c) 1998-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -137,7 +137,7 @@ png_set_cHRM_XYZ(png_const_structrp png_ptr, png_inforp info_ptr, double red_X,
 #ifdef PNG_eXIf_SUPPORTED
 void PNGAPI
 png_set_eXIf(png_const_structrp png_ptr, png_inforp info_ptr,
-    const png_bytep eXIf_buf)
+    png_bytep eXIf_buf)
 {
   png_warning(png_ptr, "png_set_eXIf does not work; use png_set_eXIf_1");
   PNG_UNUSED(info_ptr)
@@ -146,7 +146,7 @@ png_set_eXIf(png_const_structrp png_ptr, png_inforp info_ptr,
 
 void PNGAPI
 png_set_eXIf_1(png_const_structrp png_ptr, png_inforp info_ptr,
-    const png_uint_32 num_exif, const png_bytep eXIf_buf)
+    png_uint_32 num_exif, png_bytep eXIf_buf)
 {
    int i;
 
@@ -313,7 +313,7 @@ png_set_pCAL(png_const_structrp png_ptr, png_inforp info_ptr,
     png_const_charp purpose, png_int_32 X0, png_int_32 X1, int type,
     int nparams, png_const_charp units, png_charpp params)
 {
-   png_size_t length;
+   size_t length;
    int i;
 
    png_debug1(1, "in %s storage function", "pCAL");
@@ -390,7 +390,7 @@ png_set_pCAL(png_const_structrp png_ptr, png_inforp info_ptr,
    memcpy(info_ptr->pcal_units, units, length);
 
    info_ptr->pcal_params = png_voidcast(png_charpp, png_malloc_warn(png_ptr,
-       (png_size_t)(((unsigned int)nparams + 1) * (sizeof (png_charp)))));
+       (size_t)(((unsigned int)nparams + 1) * (sizeof (png_charp)))));
 
    if (info_ptr->pcal_params == NULL)
    {
@@ -430,7 +430,7 @@ void PNGAPI
 png_set_sCAL_s(png_const_structrp png_ptr, png_inforp info_ptr,
     int unit, png_const_charp swidth, png_const_charp sheight)
 {
-   png_size_t lengthw = 0, lengthh = 0;
+   size_t lengthw = 0, lengthh = 0;
 
    png_debug1(1, "in %s storage function", "sCAL");
 
@@ -691,7 +691,7 @@ png_set_iCCP(png_const_structrp png_ptr, png_inforp info_ptr,
 {
    png_charp new_iccp_name;
    png_bytep new_iccp_profile;
-   png_size_t length;
+   size_t length;
 
    png_debug1(1, "in %s storage function", "iCCP");
 
@@ -1018,7 +1018,7 @@ png_set_tRNS(png_structrp png_ptr, png_inforp info_ptr,
          /* Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1 */
           info_ptr->trans_alpha = png_voidcast(png_bytep,
               png_malloc(png_ptr, PNG_MAX_PALETTE_LENGTH));
-          memcpy(info_ptr->trans_alpha, trans_alpha, (png_size_t)num_trans);
+          memcpy(info_ptr->trans_alpha, trans_alpha, (size_t)num_trans);
        }
        png_ptr->trans_alpha = info_ptr->trans_alpha;
    }
@@ -1098,7 +1098,7 @@ png_set_sPLT(png_const_structrp png_ptr,
 
    do
    {
-      png_size_t length;
+      size_t length;
 
       /* Skip invalid input entries */
       if (entries->name == NULL || entries->entries == NULL)
@@ -1399,7 +1399,7 @@ png_set_keep_unknown_chunks(png_structrp png_ptr, int keep,
       /* Ignore all unknown chunks and all chunks recognized by
        * libpng except for IHDR, PLTE, tRNS, IDAT, and IEND
        */
-      static PNG_CONST png_byte chunks_to_ignore[] = {
+      static const png_byte chunks_to_ignore[] = {
          98,  75,  71,  68, '\0',  /* bKGD */
          99,  72,  82,  77, '\0',  /* cHRM */
         101,  88,  73, 102, '\0',  /* eXIf */
@@ -1563,7 +1563,7 @@ png_set_rows(png_const_structrp png_ptr, png_inforp info_ptr,
 #endif
 
 void PNGAPI
-png_set_compression_buffer_size(png_structrp png_ptr, png_size_t size)
+png_set_compression_buffer_size(png_structrp png_ptr, size_t size)
 {
    if (png_ptr == NULL)
       return;
diff --git a/Engine/lib/lpng/pngstruct.h b/Engine/lib/lpng/pngstruct.h
index d83f97125..8bdc7ce46 100644
--- a/Engine/lib/lpng/pngstruct.h
+++ b/Engine/lib/lpng/pngstruct.h
@@ -1,10 +1,10 @@
 
 /* pngstruct.h - header file for PNG reference library
  *
- * Last changed in libpng 1.6.32 [August 24, 2017]
- * Copyright (c) 1998-2002,2004,2006-2017 Glenn Randers-Pehrson
- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ * Copyright (c) 2018-2019 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -47,7 +47,7 @@
 /* zlib.h declares a magic type 'uInt' that limits the amount of data that zlib
  * can handle at once.  This type need be no larger than 16 bits (so maximum of
  * 65535), this define allows us to discover how big it is, but limited by the
- * maximuum for png_size_t.  The value can be overriden in a library build
+ * maximum for size_t.  The value can be overridden in a library build
  * (pngusr.h, or set it in CPPFLAGS) and it works to set it to a considerably
  * lower value (e.g. 255 works).  A lower value may help memory usage (slightly)
  * and may even improve performance on some systems (and degrade it on others.)
@@ -214,7 +214,7 @@ struct png_struct_def
    png_uint_32 height;        /* height of image in pixels */
    png_uint_32 num_rows;      /* number of rows in current pass */
    png_uint_32 usr_width;     /* width of row at start of write */
-   png_size_t rowbytes;       /* size of row in bytes */
+   size_t rowbytes;           /* size of row in bytes */
    png_uint_32 iwidth;        /* width of current interlaced row in pixels */
    png_uint_32 row_number;    /* current row in interlace pass */
    png_uint_32 chunk_name;    /* PNG_CHUNK() id of current chunk */
@@ -232,7 +232,7 @@ struct png_struct_def
    png_bytep try_row;    /* buffer to save trial row when filtering */
    png_bytep tst_row;    /* buffer to save best trial row when filtering */
 #endif
-   png_size_t info_rowbytes;  /* Added in 1.5.4: cache of updated row bytes */
+   size_t info_rowbytes;      /* Added in 1.5.4: cache of updated row bytes */
 
    png_uint_32 idat_size;     /* current IDAT size for read */
    png_uint_32 crc;           /* current chunk CRC value */
@@ -307,7 +307,7 @@ struct png_struct_def
 #endif
 
 #if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
-   png_color_8 shift;         /* shift for significant bit tranformation */
+   png_color_8 shift;         /* shift for significant bit transformation */
 #endif
 
 #if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) \
@@ -328,10 +328,10 @@ struct png_struct_def
    png_bytep current_buffer;         /* buffer for recently used data */
    png_uint_32 push_length;          /* size of current input chunk */
    png_uint_32 skip_length;          /* bytes to skip in input data */
-   png_size_t save_buffer_size;      /* amount of data now in save_buffer */
-   png_size_t save_buffer_max;       /* total size of save_buffer */
-   png_size_t buffer_size;           /* total amount of available input data */
-   png_size_t current_buffer_size;   /* amount of data now in current_buffer */
+   size_t save_buffer_size;          /* amount of data now in save_buffer */
+   size_t save_buffer_max;           /* total size of save_buffer */
+   size_t buffer_size;               /* total amount of available input data */
+   size_t current_buffer_size;       /* amount of data now in current_buffer */
    int process_mode;                 /* what push library is currently doing */
    int cur_palette;                  /* current push library palette index */
 
@@ -392,6 +392,12 @@ struct png_struct_def
    /* deleted in 1.5.5: rgb_to_gray_blue_coeff; */
 #endif
 
+/* New member added in libpng-1.6.36 */
+#if defined(PNG_READ_EXPAND_SUPPORTED) && \
+    defined(PNG_ARM_NEON_IMPLEMENTATION)
+   png_bytep riffled_palette; /* buffer for accelerated palette expansion */
+#endif
+
 /* New member added in libpng-1.0.4 (renamed in 1.0.9) */
 #if defined(PNG_MNG_FEATURES_SUPPORTED)
 /* Changed from png_byte to png_uint_32 at version 1.2.0 */
@@ -451,7 +457,7 @@ struct png_struct_def
 #endif
 
 /* New member added in libpng-1.2.26 */
-  png_size_t old_big_row_buf_size;
+   size_t old_big_row_buf_size;
 
 #ifdef PNG_READ_SUPPORTED
 /* New member added in libpng-1.2.30 */
diff --git a/Engine/lib/lpng/pngtest.c b/Engine/lib/lpng/pngtest.c
index 9d5075791..a715ae112 100644
--- a/Engine/lib/lpng/pngtest.c
+++ b/Engine/lib/lpng/pngtest.c
@@ -1,10 +1,10 @@
 
 /* pngtest.c - a simple test program to test libpng
  *
- * Last changed in libpng 1.6.32 [August 24, 2017]
- * Copyright (c) 1998-2002,2004,2006-2017 Glenn Randers-Pehrson
- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ * Copyright (c) 2018-2019 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -345,10 +345,10 @@ count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data)
 
 #ifdef PNG_IO_STATE_SUPPORTED
 void
-pngtest_check_io_state(png_structp png_ptr, png_size_t data_length,
+pngtest_check_io_state(png_structp png_ptr, size_t data_length,
     png_uint_32 io_op);
 void
-pngtest_check_io_state(png_structp png_ptr, png_size_t data_length,
+pngtest_check_io_state(png_structp png_ptr, size_t data_length,
     png_uint_32 io_op)
 {
    png_uint_32 io_state = png_get_io_state(png_ptr);
@@ -386,12 +386,12 @@ pngtest_check_io_state(png_structp png_ptr, png_size_t data_length,
 #endif
 
 static void PNGCBAPI
-pngtest_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
+pngtest_read_data(png_structp png_ptr, png_bytep data, size_t length)
 {
-   png_size_t check = 0;
+   size_t check = 0;
    png_voidp io_ptr;
 
-   /* fread() returns 0 on error, so it is OK to store this in a png_size_t
+   /* fread() returns 0 on error, so it is OK to store this in a size_t
     * instead of an int, which is what fread() actually returns.
     */
    io_ptr = png_get_io_ptr(png_ptr);
@@ -425,9 +425,9 @@ pngtest_flush(png_structp png_ptr)
  * than changing the library.
  */
 static void PNGCBAPI
-pngtest_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
+pngtest_write_data(png_structp png_ptr, png_bytep data, size_t length)
 {
-   png_size_t check;
+   size_t check;
 
    check = fwrite(data, 1, length, (png_FILE_p)png_get_io_ptr(png_ptr));
 
@@ -449,13 +449,13 @@ pngtest_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
  */
 typedef struct
 {
-   PNG_CONST char *file_name;
+   const char *file_name;
 }  pngtest_error_parameters;
 
 static void PNGCBAPI
 pngtest_warning(png_structp png_ptr, png_const_charp message)
 {
-   PNG_CONST char *name = "UNKNOWN (ERROR!)";
+   const char *name = "UNKNOWN (ERROR!)";
    pngtest_error_parameters *test =
       (pngtest_error_parameters*)png_get_error_ptr(png_ptr);
 
@@ -705,7 +705,7 @@ read_user_chunk_callback(png_struct *png_ptr, png_unknown_chunkp chunk)
     * The unknown chunk structure contains the chunk data:
     * png_byte name[5];
     * png_byte *data;
-    * png_size_t size;
+    * size_t size;
     *
     * Note that libpng has already taken care of the CRC handling.
     */
@@ -850,7 +850,7 @@ pngtest_check_text_support(png_structp png_ptr, png_textp text_ptr,
 
 /* Test one file */
 static int
-test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
+test_one_file(const char *inname, const char *outname)
 {
    static png_FILE_p fpin;
    static png_FILE_p fpout;  /* "static" prevents setjmp corruption */
@@ -957,6 +957,8 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
    if (setjmp(png_jmpbuf(write_ptr)))
    {
       fprintf(STDERR, "%s -> %s: libpng write error\n", inname, outname);
+      png_free(read_ptr, row_buf);
+      row_buf = NULL;
       if (verbose != 0)
         fprintf(STDERR, "   destroying read structs\n");
       png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);
@@ -1436,7 +1438,7 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
    row_buf = (png_bytep)png_malloc(read_ptr,
        png_get_rowbytes(read_ptr, read_info_ptr));
 
-   pngtest_debug1("\t0x%08lx", (unsigned long)row_buf);
+   pngtest_debug1("\t%p", row_buf);
 #endif /* SINGLE_ROWBUF_ALLOC */
    pngtest_debug("Writing row data");
 
@@ -1490,7 +1492,7 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
          row_buf = (png_bytep)png_malloc(read_ptr,
              png_get_rowbytes(read_ptr, read_info_ptr));
 
-         pngtest_debug2("\t0x%08lx (%lu bytes)", (unsigned long)row_buf,
+         pngtest_debug2("\t%p (%lu bytes)", row_buf,
              (unsigned long)png_get_rowbytes(read_ptr, read_info_ptr));
 
 #endif /* !SINGLE_ROWBUF_ALLOC */
@@ -1726,7 +1728,7 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
       for (;;)
       {
          static int wrote_question = 0;
-         png_size_t num_in, num_out;
+         size_t num_in, num_out;
          char inbuf[256], outbuf[256];
 
          num_in = fread(inbuf, 1, sizeof inbuf, fpin);
@@ -1809,11 +1811,11 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
 
 /* Input and output filenames */
 #ifdef RISCOS
-static PNG_CONST char *inname = "pngtest/png";
-static PNG_CONST char *outname = "pngout/png";
+static const char *inname = "pngtest/png";
+static const char *outname = "pngout/png";
 #else
-static PNG_CONST char *inname = "pngtest.png";
-static PNG_CONST char *outname = "pngout.png";
+static const char *inname = "pngtest.png";
+static const char *outname = "pngout.png";
 #endif
 
 int
@@ -2153,4 +2155,4 @@ main(void)
 #endif
 
 /* Generate a compiler error if there is an old png.h in the search path. */
-typedef png_libpng_version_1_6_34 Your_png_h_is_not_version_1_6_34;
+typedef png_libpng_version_1_6_37 Your_png_h_is_not_version_1_6_37;
diff --git a/Engine/lib/lpng/pngtrans.c b/Engine/lib/lpng/pngtrans.c
index 6882f0fd7..1100f46eb 100644
--- a/Engine/lib/lpng/pngtrans.c
+++ b/Engine/lib/lpng/pngtrans.c
@@ -1,10 +1,10 @@
 
 /* pngtrans.c - transforms the data in a row (used by both readers and writers)
  *
- * Last changed in libpng 1.6.33 [September 28, 2017]
- * Copyright (c) 1998-2002,2004,2006-2017 Glenn Randers-Pehrson
- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ * Copyright (c) 2018 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -269,8 +269,8 @@ png_do_invert(png_row_infop row_info, png_bytep row)
    if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
    {
       png_bytep rp = row;
-      png_size_t i;
-      png_size_t istop = row_info->rowbytes;
+      size_t i;
+      size_t istop = row_info->rowbytes;
 
       for (i = 0; i < istop; i++)
       {
@@ -283,8 +283,8 @@ png_do_invert(png_row_infop row_info, png_bytep row)
       row_info->bit_depth == 8)
    {
       png_bytep rp = row;
-      png_size_t i;
-      png_size_t istop = row_info->rowbytes;
+      size_t i;
+      size_t istop = row_info->rowbytes;
 
       for (i = 0; i < istop; i += 2)
       {
@@ -298,8 +298,8 @@ png_do_invert(png_row_infop row_info, png_bytep row)
       row_info->bit_depth == 16)
    {
       png_bytep rp = row;
-      png_size_t i;
-      png_size_t istop = row_info->rowbytes;
+      size_t i;
+      size_t istop = row_info->rowbytes;
 
       for (i = 0; i < istop; i += 4)
       {
@@ -345,7 +345,7 @@ png_do_swap(png_row_infop row_info, png_bytep row)
 #endif
 
 #if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
-static PNG_CONST png_byte onebppswaptable[256] = {
+static const png_byte onebppswaptable[256] = {
    0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,
    0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
    0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,
@@ -380,7 +380,7 @@ static PNG_CONST png_byte onebppswaptable[256] = {
    0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
 };
 
-static PNG_CONST png_byte twobppswaptable[256] = {
+static const png_byte twobppswaptable[256] = {
    0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0,
    0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0,
    0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4,
@@ -415,7 +415,7 @@ static PNG_CONST png_byte twobppswaptable[256] = {
    0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF
 };
 
-static PNG_CONST png_byte fourbppswaptable[256] = {
+static const png_byte fourbppswaptable[256] = {
    0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
    0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0,
    0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71,
@@ -609,7 +609,7 @@ png_do_strip_channel(png_row_infop row_info, png_bytep row, int at_start)
       return; /* The filler channel has gone already */
 
    /* Fix the rowbytes value. */
-   row_info->rowbytes = (png_size_t)(dp-row);
+   row_info->rowbytes = (size_t)(dp-row);
 }
 #endif
 
diff --git a/Engine/lib/lpng/pngusr.dfa b/Engine/lib/lpng/pngusr.dfa
new file mode 100644
index 000000000..83067c38c
--- /dev/null
+++ b/Engine/lib/lpng/pngusr.dfa
@@ -0,0 +1,14 @@
+# pngusr.dfa
+#
+# Build time configuration of libpng
+#
+# Enter build configuration options in this file
+#
+# Security settings: by default these limits are unset, you can change them
+# here by entering the appropriate values as #defines preceded by '@' (to cause,
+# them to be passed through to the build of pnglibconf.h), for example:
+#
+# @# define PNG_USER_WIDTH_MAX 65535
+# @# define PNG_USER_HEIGHT_MAX 65535
+# @# define PNG_USER_CHUNK_CACHE_MAX 256
+# @# define PNG_USER_CHUNK_MALLOC_MAX 640000
diff --git a/Engine/lib/lpng/pngwio.c b/Engine/lib/lpng/pngwio.c
index 37c7c3a7f..10e919dd0 100644
--- a/Engine/lib/lpng/pngwio.c
+++ b/Engine/lib/lpng/pngwio.c
@@ -1,10 +1,10 @@
 
 /* pngwio.c - functions for data output
  *
- * Last changed in libpng 1.6.24 [August 4, 2016]
- * Copyright (c) 1998-2002,2004,2006-2014,2016 Glenn Randers-Pehrson
- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ * Copyright (c) 2018 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2014,2016,2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -30,7 +30,7 @@
  */
 
 void /* PRIVATE */
-png_write_data(png_structrp png_ptr, png_const_bytep data, png_size_t length)
+png_write_data(png_structrp png_ptr, png_const_bytep data, size_t length)
 {
    /* NOTE: write_data_fn must not change the buffer! */
    if (png_ptr->write_data_fn != NULL )
@@ -48,9 +48,9 @@ png_write_data(png_structrp png_ptr, png_const_bytep data, png_size_t length)
  * than changing the library.
  */
 void PNGCBAPI
-png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
+png_default_write_data(png_structp png_ptr, png_bytep data, size_t length)
 {
-   png_size_t check;
+   size_t check;
 
    if (png_ptr == NULL)
       return;
diff --git a/Engine/lib/lpng/pngwrite.c b/Engine/lib/lpng/pngwrite.c
index a16d77ce0..59377a4dd 100644
--- a/Engine/lib/lpng/pngwrite.c
+++ b/Engine/lib/lpng/pngwrite.c
@@ -1,10 +1,10 @@
 
 /* pngwrite.c - general routines to write a PNG file
  *
- * Last changed in libpng 1.6.32 [August 24, 2017]
- * Copyright (c) 1998-2002,2004,2006-2017 Glenn Randers-Pehrson
- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ * Copyright (c) 2018-2019 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -469,7 +469,7 @@ png_write_end(png_structrp png_ptr, png_inforp info_ptr)
 
 #ifdef PNG_CONVERT_tIME_SUPPORTED
 void PNGAPI
-png_convert_from_struct_tm(png_timep ptime, PNG_CONST struct tm * ttime)
+png_convert_from_struct_tm(png_timep ptime, const struct tm * ttime)
 {
    png_debug(1, "in png_convert_from_struct_tm");
 
@@ -1536,7 +1536,7 @@ png_write_image_16bit(png_voidp argument)
        display->first_row);
    png_uint_16p output_row = png_voidcast(png_uint_16p, display->local_row);
    png_uint_16p row_end;
-   const unsigned int channels = (image->format & PNG_FORMAT_FLAG_COLOR) != 0 ?
+   unsigned int channels = (image->format & PNG_FORMAT_FLAG_COLOR) != 0 ?
        3 : 1;
    int aindex = 0;
    png_uint_32 y = image->height;
@@ -1573,7 +1573,7 @@ png_write_image_16bit(png_voidp argument)
 
       while (out_ptr < row_end)
       {
-         const png_uint_16 alpha = in_ptr[aindex];
+         png_uint_16 alpha = in_ptr[aindex];
          png_uint_32 reciprocal = 0;
          int c;
 
@@ -1636,7 +1636,7 @@ png_write_image_16bit(png_voidp argument)
  * calculation can be done to 15 bits of accuracy; however, the output needs to
  * be scaled in the range 0..255*65535, so include that scaling here.
  */
-#   define UNP_RECIPROCAL(alpha) ((((0xffff*0xff)<<7)+(alpha>>1))/alpha)
+#   define UNP_RECIPROCAL(alpha) ((((0xffff*0xff)<<7)+((alpha)>>1))/(alpha))
 
 static png_byte
 png_unpremultiply(png_uint_32 component, png_uint_32 alpha,
@@ -1695,7 +1695,7 @@ png_write_image_8bit(png_voidp argument)
        display->first_row);
    png_bytep output_row = png_voidcast(png_bytep, display->local_row);
    png_uint_32 y = image->height;
-   const unsigned int channels = (image->format & PNG_FORMAT_FLAG_COLOR) != 0 ?
+   unsigned int channels = (image->format & PNG_FORMAT_FLAG_COLOR) != 0 ?
        3 : 1;
 
    if ((image->format & PNG_FORMAT_FLAG_ALPHA) != 0)
@@ -1783,25 +1783,25 @@ png_write_image_8bit(png_voidp argument)
 static void
 png_image_set_PLTE(png_image_write_control *display)
 {
-   const png_imagep image = display->image;
+   png_imagep image = display->image;
    const void *cmap = display->colormap;
-   const int entries = image->colormap_entries > 256 ? 256 :
+   int entries = image->colormap_entries > 256 ? 256 :
        (int)image->colormap_entries;
 
    /* NOTE: the caller must check for cmap != NULL and entries != 0 */
-   const png_uint_32 format = image->format;
-   const unsigned int channels = PNG_IMAGE_SAMPLE_CHANNELS(format);
+   png_uint_32 format = image->format;
+   unsigned int channels = PNG_IMAGE_SAMPLE_CHANNELS(format);
 
 #   if defined(PNG_FORMAT_BGR_SUPPORTED) &&\
       defined(PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED)
-      const int afirst = (format & PNG_FORMAT_FLAG_AFIRST) != 0 &&
+      int afirst = (format & PNG_FORMAT_FLAG_AFIRST) != 0 &&
           (format & PNG_FORMAT_FLAG_ALPHA) != 0;
 #   else
 #     define afirst 0
 #   endif
 
 #   ifdef PNG_FORMAT_BGR_SUPPORTED
-      const int bgr = (format & PNG_FORMAT_FLAG_BGR) != 0 ? 2 : 0;
+      int bgr = (format & PNG_FORMAT_FLAG_BGR) != 0 ? 2 : 0;
 #   else
 #     define bgr 0
 #   endif
@@ -1951,12 +1951,12 @@ png_image_write_main(png_voidp argument)
     * and total image size to ensure that they are within the system limits.
     */
    {
-      const unsigned int channels = PNG_IMAGE_PIXEL_CHANNELS(image->format);
+      unsigned int channels = PNG_IMAGE_PIXEL_CHANNELS(image->format);
 
       if (image->width <= 0x7fffffffU/channels) /* no overflow */
       {
          png_uint_32 check;
-         const png_uint_32 png_row_stride = image->width * channels;
+         png_uint_32 png_row_stride = image->width * channels;
 
          if (display->row_stride == 0)
             display->row_stride = (png_int_32)/*SAFE*/png_row_stride;
@@ -2052,7 +2052,7 @@ png_image_write_main(png_voidp argument)
     */
    if (write_16bit != 0)
    {
-      PNG_CONST png_uint_16 le = 0x0001;
+      png_uint_16 le = 0x0001;
 
       if ((*(png_const_bytep) & le) != 0)
          png_set_swap(png_ptr);
@@ -2162,12 +2162,11 @@ png_image_write_main(png_voidp argument)
 
 
 static void (PNGCBAPI
-image_memory_write)(png_structp png_ptr, png_bytep/*const*/ data,
-    png_size_t size)
+image_memory_write)(png_structp png_ptr, png_bytep/*const*/ data, size_t size)
 {
    png_image_write_control *display = png_voidcast(png_image_write_control*,
        png_ptr->io_ptr/*backdoor: png_get_io_ptr(png_ptr)*/);
-   const png_alloc_size_t ob = display->output_bytes;
+   png_alloc_size_t ob = display->output_bytes;
 
    /* Check for overflow; this should never happen: */
    if (size <= ((png_alloc_size_t)-1) - ob)
diff --git a/Engine/lib/lpng/pngwtran.c b/Engine/lib/lpng/pngwtran.c
index 377b43e5c..49a13c1e9 100644
--- a/Engine/lib/lpng/pngwtran.c
+++ b/Engine/lib/lpng/pngwtran.c
@@ -1,10 +1,10 @@
 
 /* pngwtran.c - transforms the data in a row for PNG writers
  *
- * Last changed in libpng 1.6.26 [October 20, 2016]
- * Copyright (c) 1998-2002,2004,2006-2016 Glenn Randers-Pehrson
- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ * Copyright (c) 2018 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2016,2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -212,9 +212,9 @@ png_do_shift(png_row_infop row_info, png_bytep row,
       if (row_info->bit_depth < 8)
       {
          png_bytep bp = row;
-         png_size_t i;
+         size_t i;
          unsigned int mask;
-         png_size_t row_bytes = row_info->rowbytes;
+         size_t row_bytes = row_info->rowbytes;
 
          if (bit_depth->gray == 1 && row_info->bit_depth == 2)
             mask = 0x55;
@@ -254,8 +254,7 @@ png_do_shift(png_row_infop row_info, png_bytep row,
 
          for (i = 0; i < istop; i++, bp++)
          {
-
-            const unsigned int c = i%channels;
+            unsigned int c = i%channels;
             int j;
             unsigned int v, out;
 
@@ -283,7 +282,7 @@ png_do_shift(png_row_infop row_info, png_bytep row,
 
          for (bp = row, i = 0; i < istop; i++)
          {
-            const unsigned int c = i%channels;
+            unsigned int c = i%channels;
             int j;
             unsigned int value, v;
 
@@ -514,7 +513,7 @@ png_do_write_transformations(png_structrp png_ptr, png_row_infop row_info)
              (png_ptr,  /* png_ptr */
              row_info,  /* row_info: */
                 /*  png_uint_32 width;       width of row */
-                /*  png_size_t rowbytes;     number of bytes in row */
+                /*  size_t rowbytes;         number of bytes in row */
                 /*  png_byte color_type;     color type of pixels */
                 /*  png_byte bit_depth;      bit depth of samples */
                 /*  png_byte channels;       number of channels (1-4) */
diff --git a/Engine/lib/lpng/pngwutil.c b/Engine/lib/lpng/pngwutil.c
index 0d4fb1336..16345e4c0 100644
--- a/Engine/lib/lpng/pngwutil.c
+++ b/Engine/lib/lpng/pngwutil.c
@@ -1,10 +1,10 @@
 
 /* pngwutil.c - utilities to write a PNG file
  *
- * Last changed in libpng 1.6.32 [August 24, 2017]
- * Copyright (c) 1998-2002,2004,2006-2017 Glenn Randers-Pehrson
- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ * Copyright (c) 2018 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -59,7 +59,7 @@ png_write_sig(png_structrp png_ptr)
 
    /* Write the rest of the 8 byte signature */
    png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes],
-       (png_size_t)(8 - png_ptr->sig_bytes));
+       (size_t)(8 - png_ptr->sig_bytes));
 
    if (png_ptr->sig_bytes < 3)
       png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;
@@ -124,8 +124,7 @@ png_write_chunk_start(png_structrp png_ptr, png_const_bytep chunk_string,
  * given to png_write_chunk_header().
  */
 void PNGAPI
-png_write_chunk_data(png_structrp png_ptr, png_const_bytep data,
-    png_size_t length)
+png_write_chunk_data(png_structrp png_ptr, png_const_bytep data, size_t length)
 {
    /* Write the data, and run the CRC over it */
    if (png_ptr == NULL)
@@ -160,7 +159,7 @@ png_write_chunk_end(png_structrp png_ptr)
    /* Write the crc in a single operation */
    png_save_uint_32(buf, png_ptr->crc);
 
-   png_write_data(png_ptr, buf, (png_size_t)4);
+   png_write_data(png_ptr, buf, 4);
 }
 
 /* Write a PNG chunk all at once.  The type is an array of ASCII characters
@@ -174,7 +173,7 @@ png_write_chunk_end(png_structrp png_ptr)
  */
 static void
 png_write_complete_chunk(png_structrp png_ptr, png_uint_32 chunk_name,
-    png_const_bytep data, png_size_t length)
+    png_const_bytep data, size_t length)
 {
    if (png_ptr == NULL)
       return;
@@ -191,7 +190,7 @@ png_write_complete_chunk(png_structrp png_ptr, png_uint_32 chunk_name,
 /* This is the API that calls the internal function above. */
 void PNGAPI
 png_write_chunk(png_structrp png_ptr, png_const_bytep chunk_string,
-    png_const_bytep data, png_size_t length)
+    png_const_bytep data, size_t length)
 {
    png_write_complete_chunk(png_ptr, PNG_CHUNK_FROM_STRING(chunk_string), data,
        length);
@@ -820,7 +819,7 @@ png_write_IHDR(png_structrp png_ptr, png_uint_32 width, png_uint_32 height,
    buf[12] = (png_byte)interlace_type;
 
    /* Write the chunk */
-   png_write_complete_chunk(png_ptr, png_IHDR, buf, (png_size_t)13);
+   png_write_complete_chunk(png_ptr, png_IHDR, buf, 13);
 
    if ((png_ptr->do_filter) == PNG_NO_FILTERS)
    {
@@ -889,7 +888,7 @@ png_write_PLTE(png_structrp png_ptr, png_const_colorp palette,
       buf[0] = pal_ptr->red;
       buf[1] = pal_ptr->green;
       buf[2] = pal_ptr->blue;
-      png_write_chunk_data(png_ptr, buf, (png_size_t)3);
+      png_write_chunk_data(png_ptr, buf, 3);
    }
 
 #else
@@ -903,7 +902,7 @@ png_write_PLTE(png_structrp png_ptr, png_const_colorp palette,
       buf[0] = pal_ptr[i].red;
       buf[1] = pal_ptr[i].green;
       buf[2] = pal_ptr[i].blue;
-      png_write_chunk_data(png_ptr, buf, (png_size_t)3);
+      png_write_chunk_data(png_ptr, buf, 3);
    }
 
 #endif
@@ -1075,7 +1074,7 @@ png_write_IEND(png_structrp png_ptr)
 {
    png_debug(1, "in png_write_IEND");
 
-   png_write_complete_chunk(png_ptr, png_IEND, NULL, (png_size_t)0);
+   png_write_complete_chunk(png_ptr, png_IEND, NULL, 0);
    png_ptr->mode |= PNG_HAVE_IEND;
 }
 
@@ -1090,7 +1089,7 @@ png_write_gAMA_fixed(png_structrp png_ptr, png_fixed_point file_gamma)
 
    /* file_gamma is saved in 1/100,000ths */
    png_save_uint_32(buf, (png_uint_32)file_gamma);
-   png_write_complete_chunk(png_ptr, png_gAMA, buf, (png_size_t)4);
+   png_write_complete_chunk(png_ptr, png_gAMA, buf, 4);
 }
 #endif
 
@@ -1108,7 +1107,7 @@ png_write_sRGB(png_structrp png_ptr, int srgb_intent)
           "Invalid sRGB rendering intent specified");
 
    buf[0]=(png_byte)srgb_intent;
-   png_write_complete_chunk(png_ptr, png_sRGB, buf, (png_size_t)1);
+   png_write_complete_chunk(png_ptr, png_sRGB, buf, 1);
 }
 #endif
 
@@ -1182,8 +1181,8 @@ png_write_sPLT(png_structrp png_ptr, png_const_sPLT_tp spalette)
    png_uint_32 name_len;
    png_byte new_name[80];
    png_byte entrybuf[10];
-   png_size_t entry_size = (spalette->depth == 8 ? 6 : 10);
-   png_size_t palette_size = entry_size * (png_size_t)spalette->nentries;
+   size_t entry_size = (spalette->depth == 8 ? 6 : 10);
+   size_t palette_size = entry_size * (size_t)spalette->nentries;
    png_sPLT_entryp ep;
 #ifndef PNG_POINTER_INDEXING_SUPPORTED
    int i;
@@ -1200,10 +1199,9 @@ png_write_sPLT(png_structrp png_ptr, png_const_sPLT_tp spalette)
    png_write_chunk_header(png_ptr, png_sPLT,
        (png_uint_32)(name_len + 2 + palette_size));
 
-   png_write_chunk_data(png_ptr, (png_bytep)new_name,
-       (png_size_t)(name_len + 1));
+   png_write_chunk_data(png_ptr, (png_bytep)new_name, (size_t)(name_len + 1));
 
-   png_write_chunk_data(png_ptr, &spalette->depth, (png_size_t)1);
+   png_write_chunk_data(png_ptr, &spalette->depth, 1);
 
    /* Loop through each palette entry, writing appropriately */
 #ifdef PNG_POINTER_INDEXING_SUPPORTED
@@ -1265,7 +1263,7 @@ void /* PRIVATE */
 png_write_sBIT(png_structrp png_ptr, png_const_color_8p sbit, int color_type)
 {
    png_byte buf[4];
-   png_size_t size;
+   size_t size;
 
    png_debug(1, "in png_write_sBIT");
 
@@ -1365,7 +1363,7 @@ png_write_tRNS(png_structrp png_ptr, png_const_bytep trans_alpha,
 
       /* Write the chunk out as it is */
       png_write_complete_chunk(png_ptr, png_tRNS, trans_alpha,
-          (png_size_t)num_trans);
+          (size_t)num_trans);
    }
 
    else if (color_type == PNG_COLOR_TYPE_GRAY)
@@ -1380,7 +1378,7 @@ png_write_tRNS(png_structrp png_ptr, png_const_bytep trans_alpha,
       }
 
       png_save_uint_16(buf, tran->gray);
-      png_write_complete_chunk(png_ptr, png_tRNS, buf, (png_size_t)2);
+      png_write_complete_chunk(png_ptr, png_tRNS, buf, 2);
    }
 
    else if (color_type == PNG_COLOR_TYPE_RGB)
@@ -1400,7 +1398,7 @@ png_write_tRNS(png_structrp png_ptr, png_const_bytep trans_alpha,
          return;
       }
 
-      png_write_complete_chunk(png_ptr, png_tRNS, buf, (png_size_t)6);
+      png_write_complete_chunk(png_ptr, png_tRNS, buf, 6);
    }
 
    else
@@ -1433,7 +1431,7 @@ png_write_bKGD(png_structrp png_ptr, png_const_color_16p back, int color_type)
       }
 
       buf[0] = back->index;
-      png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)1);
+      png_write_complete_chunk(png_ptr, png_bKGD, buf, 1);
    }
 
    else if ((color_type & PNG_COLOR_MASK_COLOR) != 0)
@@ -1454,7 +1452,7 @@ png_write_bKGD(png_structrp png_ptr, png_const_color_16p back, int color_type)
          return;
       }
 
-      png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)6);
+      png_write_complete_chunk(png_ptr, png_bKGD, buf, 6);
    }
 
    else
@@ -1468,7 +1466,7 @@ png_write_bKGD(png_structrp png_ptr, png_const_color_16p back, int color_type)
       }
 
       png_save_uint_16(buf, back->gray);
-      png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)2);
+      png_write_complete_chunk(png_ptr, png_bKGD, buf, 2);
    }
 }
 #endif
@@ -1488,7 +1486,7 @@ png_write_eXIf(png_structrp png_ptr, png_bytep exif, int num_exif)
    for (i = 0; i < num_exif; i++)
    {
       buf[0] = exif[i];
-      png_write_chunk_data(png_ptr, buf, (png_size_t)1);
+      png_write_chunk_data(png_ptr, buf, 1);
    }
 
    png_write_chunk_end(png_ptr);
@@ -1519,7 +1517,7 @@ png_write_hIST(png_structrp png_ptr, png_const_uint_16p hist, int num_hist)
    for (i = 0; i < num_hist; i++)
    {
       png_save_uint_16(buf, hist[i]);
-      png_write_chunk_data(png_ptr, buf, (png_size_t)2);
+      png_write_chunk_data(png_ptr, buf, 2);
    }
 
    png_write_chunk_end(png_ptr);
@@ -1530,7 +1528,7 @@ png_write_hIST(png_structrp png_ptr, png_const_uint_16p hist, int num_hist)
 /* Write a tEXt chunk */
 void /* PRIVATE */
 png_write_tEXt(png_structrp png_ptr, png_const_charp key, png_const_charp text,
-    png_size_t text_len)
+    size_t text_len)
 {
    png_uint_32 key_len;
    png_byte new_key[80];
@@ -1627,7 +1625,7 @@ png_write_iTXt(png_structrp png_ptr, int compression, png_const_charp key,
     png_const_charp lang, png_const_charp lang_key, png_const_charp text)
 {
    png_uint_32 key_len, prefix_len;
-   png_size_t lang_len, lang_key_len;
+   size_t lang_len, lang_key_len;
    png_byte new_key[82];
    compression_state comp;
 
@@ -1737,7 +1735,7 @@ png_write_oFFs(png_structrp png_ptr, png_int_32 x_offset, png_int_32 y_offset,
    png_save_int_32(buf + 4, y_offset);
    buf[8] = (png_byte)unit_type;
 
-   png_write_complete_chunk(png_ptr, png_oFFs, buf, (png_size_t)9);
+   png_write_complete_chunk(png_ptr, png_oFFs, buf, 9);
 }
 #endif
 #ifdef PNG_WRITE_pCAL_SUPPORTED
@@ -1748,7 +1746,7 @@ png_write_pCAL(png_structrp png_ptr, png_charp purpose, png_int_32 X0,
     png_charpp params)
 {
    png_uint_32 purpose_len;
-   png_size_t units_len, total_len;
+   size_t units_len, total_len;
    png_size_tp params_len;
    png_byte buf[10];
    png_byte new_purpose[80];
@@ -1772,7 +1770,7 @@ png_write_pCAL(png_structrp png_ptr, png_charp purpose, png_int_32 X0,
    total_len = purpose_len + units_len + 10;
 
    params_len = (png_size_tp)png_malloc(png_ptr,
-       (png_alloc_size_t)((png_alloc_size_t)nparams * (sizeof (png_size_t))));
+       (png_alloc_size_t)((png_alloc_size_t)nparams * (sizeof (size_t))));
 
    /* Find the length of each parameter, making sure we don't count the
     * null terminator for the last parameter.
@@ -1792,8 +1790,8 @@ png_write_pCAL(png_structrp png_ptr, png_charp purpose, png_int_32 X0,
    png_save_int_32(buf + 4, X1);
    buf[8] = (png_byte)type;
    buf[9] = (png_byte)nparams;
-   png_write_chunk_data(png_ptr, buf, (png_size_t)10);
-   png_write_chunk_data(png_ptr, (png_const_bytep)units, (png_size_t)units_len);
+   png_write_chunk_data(png_ptr, buf, 10);
+   png_write_chunk_data(png_ptr, (png_const_bytep)units, (size_t)units_len);
 
    for (i = 0; i < nparams; i++)
    {
@@ -1812,7 +1810,7 @@ png_write_sCAL_s(png_structrp png_ptr, int unit, png_const_charp width,
     png_const_charp height)
 {
    png_byte buf[64];
-   png_size_t wlen, hlen, total_len;
+   size_t wlen, hlen, total_len;
 
    png_debug(1, "in png_write_sCAL_s");
 
@@ -1853,7 +1851,7 @@ png_write_pHYs(png_structrp png_ptr, png_uint_32 x_pixels_per_unit,
    png_save_uint_32(buf + 4, y_pixels_per_unit);
    buf[8] = (png_byte)unit_type;
 
-   png_write_complete_chunk(png_ptr, png_pHYs, buf, (png_size_t)9);
+   png_write_complete_chunk(png_ptr, png_pHYs, buf, 9);
 }
 #endif
 
@@ -1883,7 +1881,7 @@ png_write_tIME(png_structrp png_ptr, png_const_timep mod_time)
    buf[5] = mod_time->minute;
    buf[6] = mod_time->second;
 
-   png_write_complete_chunk(png_ptr, png_tIME, buf, (png_size_t)7);
+   png_write_complete_chunk(png_ptr, png_tIME, buf, 7);
 }
 #endif
 
@@ -1895,16 +1893,16 @@ png_write_start_row(png_structrp png_ptr)
    /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
 
    /* Start of interlace block */
-   static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
+   static const png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
 
    /* Offset to next interlace block */
-   static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
+   static const png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
 
    /* Start of interlace block in the y direction */
-   static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
+   static const png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
 
    /* Offset to next interlace block in the y direction */
-   static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
+   static const png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
 #endif
 
    png_alloc_size_t buf_size;
@@ -2010,16 +2008,16 @@ png_write_finish_row(png_structrp png_ptr)
    /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
 
    /* Start of interlace block */
-   static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
+   static const png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
 
    /* Offset to next interlace block */
-   static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
+   static const png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
 
    /* Start of interlace block in the y direction */
-   static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
+   static const png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
 
    /* Offset to next interlace block in the y direction */
-   static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
+   static const png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
 #endif
 
    png_debug(1, "in png_write_finish_row");
@@ -2073,8 +2071,8 @@ png_write_finish_row(png_structrp png_ptr)
       {
          if (png_ptr->prev_row != NULL)
             memset(png_ptr->prev_row, 0,
-                (png_size_t)(PNG_ROWBYTES(png_ptr->usr_channels*
-                png_ptr->usr_bit_depth, png_ptr->width)) + 1);
+                PNG_ROWBYTES(png_ptr->usr_channels *
+                png_ptr->usr_bit_depth, png_ptr->width) + 1);
 
          return;
       }
@@ -2100,10 +2098,10 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
    /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
 
    /* Start of interlace block */
-   static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
+   static const png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
 
    /* Offset to next interlace block */
-   static PNG_CONST png_byte  png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
+   static const png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
 
    png_debug(1, "in png_do_write_interlace");
 
@@ -2130,7 +2128,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
             for (i = png_pass_start[pass]; i < row_width;
                i += png_pass_inc[pass])
             {
-               sp = row + (png_size_t)(i >> 3);
+               sp = row + (size_t)(i >> 3);
                value = (int)(*sp >> (7 - (int)(i & 0x07))) & 0x01;
                d |= (value << shift);
 
@@ -2168,7 +2166,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
             for (i = png_pass_start[pass]; i < row_width;
                i += png_pass_inc[pass])
             {
-               sp = row + (png_size_t)(i >> 2);
+               sp = row + (size_t)(i >> 2);
                value = (*sp >> ((3 - (int)(i & 0x03)) << 1)) & 0x03;
                d |= (value << shift);
 
@@ -2204,7 +2202,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
             for (i = png_pass_start[pass]; i < row_width;
                 i += png_pass_inc[pass])
             {
-               sp = row + (png_size_t)(i >> 1);
+               sp = row + (size_t)(i >> 1);
                value = (*sp >> ((1 - (int)(i & 0x01)) << 2)) & 0x0f;
                d |= (value << shift);
 
@@ -2230,7 +2228,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
             png_bytep dp;
             png_uint_32 i;
             png_uint_32 row_width = row_info->width;
-            png_size_t pixel_bytes;
+            size_t pixel_bytes;
 
             /* Start at the beginning */
             dp = row;
@@ -2243,7 +2241,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
                i += png_pass_inc[pass])
             {
                /* Find out where the original pixel is */
-               sp = row + (png_size_t)i * pixel_bytes;
+               sp = row + (size_t)i * pixel_bytes;
 
                /* Move the pixel */
                if (dp != sp)
@@ -2274,16 +2272,16 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
  */
 static void /* PRIVATE */
 png_write_filtered_row(png_structrp png_ptr, png_bytep filtered_row,
-    png_size_t row_bytes);
+    size_t row_bytes);
 
 #ifdef PNG_WRITE_FILTER_SUPPORTED
-static png_size_t /* PRIVATE */
-png_setup_sub_row(png_structrp png_ptr, const png_uint_32 bpp,
-    const png_size_t row_bytes, const png_size_t lmins)
+static size_t /* PRIVATE */
+png_setup_sub_row(png_structrp png_ptr, png_uint_32 bpp,
+    size_t row_bytes, size_t lmins)
 {
    png_bytep rp, dp, lp;
-   png_size_t i;
-   png_size_t sum = 0;
+   size_t i;
+   size_t sum = 0;
    unsigned int v;
 
    png_ptr->try_row[0] = PNG_FILTER_VALUE_SUB;
@@ -2317,11 +2315,11 @@ png_setup_sub_row(png_structrp png_ptr, const png_uint_32 bpp,
 }
 
 static void /* PRIVATE */
-png_setup_sub_row_only(png_structrp png_ptr, const png_uint_32 bpp,
-    const png_size_t row_bytes)
+png_setup_sub_row_only(png_structrp png_ptr, png_uint_32 bpp,
+    size_t row_bytes)
 {
    png_bytep rp, dp, lp;
-   png_size_t i;
+   size_t i;
 
    png_ptr->try_row[0] = PNG_FILTER_VALUE_SUB;
 
@@ -2338,13 +2336,12 @@ png_setup_sub_row_only(png_structrp png_ptr, const png_uint_32 bpp,
    }
 }
 
-static png_size_t /* PRIVATE */
-png_setup_up_row(png_structrp png_ptr, const png_size_t row_bytes,
-    const png_size_t lmins)
+static size_t /* PRIVATE */
+png_setup_up_row(png_structrp png_ptr, size_t row_bytes, size_t lmins)
 {
    png_bytep rp, dp, pp;
-   png_size_t i;
-   png_size_t sum = 0;
+   size_t i;
+   size_t sum = 0;
    unsigned int v;
 
    png_ptr->try_row[0] = PNG_FILTER_VALUE_UP;
@@ -2367,10 +2364,10 @@ png_setup_up_row(png_structrp png_ptr, const png_size_t row_bytes,
    return (sum);
 }
 static void /* PRIVATE */
-png_setup_up_row_only(png_structrp png_ptr, const png_size_t row_bytes)
+png_setup_up_row_only(png_structrp png_ptr, size_t row_bytes)
 {
    png_bytep rp, dp, pp;
-   png_size_t i;
+   size_t i;
 
    png_ptr->try_row[0] = PNG_FILTER_VALUE_UP;
 
@@ -2382,13 +2379,13 @@ png_setup_up_row_only(png_structrp png_ptr, const png_size_t row_bytes)
    }
 }
 
-static png_size_t /* PRIVATE */
-png_setup_avg_row(png_structrp png_ptr, const png_uint_32 bpp,
-    const png_size_t row_bytes, const png_size_t lmins)
+static size_t /* PRIVATE */
+png_setup_avg_row(png_structrp png_ptr, png_uint_32 bpp,
+    size_t row_bytes, size_t lmins)
 {
    png_bytep rp, dp, pp, lp;
    png_uint_32 i;
-   png_size_t sum = 0;
+   size_t sum = 0;
    unsigned int v;
 
    png_ptr->try_row[0] = PNG_FILTER_VALUE_AVG;
@@ -2423,8 +2420,8 @@ png_setup_avg_row(png_structrp png_ptr, const png_uint_32 bpp,
    return (sum);
 }
 static void /* PRIVATE */
-png_setup_avg_row_only(png_structrp png_ptr, const png_uint_32 bpp,
-    const png_size_t row_bytes)
+png_setup_avg_row_only(png_structrp png_ptr, png_uint_32 bpp,
+    size_t row_bytes)
 {
    png_bytep rp, dp, pp, lp;
    png_uint_32 i;
@@ -2444,13 +2441,13 @@ png_setup_avg_row_only(png_structrp png_ptr, const png_uint_32 bpp,
    }
 }
 
-static png_size_t /* PRIVATE */
-png_setup_paeth_row(png_structrp png_ptr, const png_uint_32 bpp,
-    const png_size_t row_bytes, const png_size_t lmins)
+static size_t /* PRIVATE */
+png_setup_paeth_row(png_structrp png_ptr, png_uint_32 bpp,
+    size_t row_bytes, size_t lmins)
 {
    png_bytep rp, dp, pp, cp, lp;
-   png_size_t i;
-   png_size_t sum = 0;
+   size_t i;
+   size_t sum = 0;
    unsigned int v;
 
    png_ptr->try_row[0] = PNG_FILTER_VALUE_PAETH;
@@ -2506,11 +2503,11 @@ png_setup_paeth_row(png_structrp png_ptr, const png_uint_32 bpp,
    return (sum);
 }
 static void /* PRIVATE */
-png_setup_paeth_row_only(png_structrp png_ptr, const png_uint_32 bpp,
-    const png_size_t row_bytes)
+png_setup_paeth_row_only(png_structrp png_ptr, png_uint_32 bpp,
+    size_t row_bytes)
 {
    png_bytep rp, dp, pp, cp, lp;
-   png_size_t i;
+   size_t i;
 
    png_ptr->try_row[0] = PNG_FILTER_VALUE_PAETH;
 
@@ -2559,8 +2556,8 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
    png_bytep row_buf;
    png_bytep best_row;
    png_uint_32 bpp;
-   png_size_t mins;
-   png_size_t row_bytes = row_info->rowbytes;
+   size_t mins;
+   size_t row_bytes = row_info->rowbytes;
 
    png_debug(1, "in png_write_find_filter");
 
@@ -2615,8 +2612,8 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
        * 'none' filter.
        */
       png_bytep rp;
-      png_size_t sum = 0;
-      png_size_t i;
+      size_t sum = 0;
+      size_t i;
       unsigned int v;
 
       {
@@ -2644,8 +2641,8 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
 
    else if ((filter_to_do & PNG_FILTER_SUB) != 0)
    {
-      png_size_t sum;
-      png_size_t lmins = mins;
+      size_t sum;
+      size_t lmins = mins;
 
       sum = png_setup_sub_row(png_ptr, bpp, row_bytes, lmins);
 
@@ -2670,8 +2667,8 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
 
    else if ((filter_to_do & PNG_FILTER_UP) != 0)
    {
-      png_size_t sum;
-      png_size_t lmins = mins;
+      size_t sum;
+      size_t lmins = mins;
 
       sum = png_setup_up_row(png_ptr, row_bytes, lmins);
 
@@ -2696,8 +2693,8 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
 
    else if ((filter_to_do & PNG_FILTER_AVG) != 0)
    {
-      png_size_t sum;
-      png_size_t lmins = mins;
+      size_t sum;
+      size_t lmins = mins;
 
       sum= png_setup_avg_row(png_ptr, bpp, row_bytes, lmins);
 
@@ -2722,8 +2719,8 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
 
    else if ((filter_to_do & PNG_FILTER_PAETH) != 0)
    {
-      png_size_t sum;
-      png_size_t lmins = mins;
+      size_t sum;
+      size_t lmins = mins;
 
       sum = png_setup_paeth_row(png_ptr, bpp, row_bytes, lmins);
 
@@ -2748,7 +2745,7 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
 /* Do the actual writing of a previously filtered row. */
 static void
 png_write_filtered_row(png_structrp png_ptr, png_bytep filtered_row,
-    png_size_t full_row_length/*includes filter byte*/)
+    size_t full_row_length/*includes filter byte*/)
 {
    png_debug(1, "in png_write_filtered_row");
 
diff --git a/Engine/lib/lpng/powerpc/filter_vsx_intrinsics.c b/Engine/lib/lpng/powerpc/filter_vsx_intrinsics.c
new file mode 100644
index 000000000..01cf8800d
--- /dev/null
+++ b/Engine/lib/lpng/powerpc/filter_vsx_intrinsics.c
@@ -0,0 +1,768 @@
+/* filter_vsx_intrinsics.c - PowerPC optimised filter functions
+ *
+ * Copyright (c) 2018 Cosmin Truta
+ * Copyright (c) 2017 Glenn Randers-Pehrson
+ * Written by Vadim Barkov, 2017.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+#include "../pngpriv.h"
+
+#ifdef PNG_READ_SUPPORTED
+
+/* This code requires -maltivec and -mvsx on the command line: */
+#if PNG_POWERPC_VSX_IMPLEMENTATION == 1 /* intrinsics code from pngpriv.h */
+
+#include <altivec.h>
+
+#if PNG_POWERPC_VSX_OPT > 0
+
+#ifndef __VSX__
+#  error "This code requires VSX support (POWER7 and later). Please provide -mvsx compiler flag."
+#endif
+
+#define vec_ld_unaligned(vec,data) vec = vec_vsx_ld(0,data)
+#define vec_st_unaligned(vec,data) vec_vsx_st(vec,0,data)
+
+
+/* Functions in this file look at most 3 pixels (a,b,c) to predict the 4th (d).
+ * They're positioned like this:
+ *    prev:  c b
+ *    row:   a d
+ * The Sub filter predicts d=a, Avg d=(a+b)/2, and Paeth predicts d to be
+ * whichever of a, b, or c is closest to p=a+b-c.
+ * ( this is taken from ../intel/filter_sse2_intrinsics.c )
+ */
+
+#define vsx_declare_common_vars(row_info,row,prev_row,offset) \
+   png_byte i;\
+   png_bytep rp = row + offset;\
+   png_const_bytep pp = prev_row;\
+   size_t unaligned_top = 16 - (((size_t)rp % 16));\
+   size_t istop;\
+   if(unaligned_top == 16)\
+      unaligned_top = 0;\
+   istop = row_info->rowbytes;\
+   if((unaligned_top < istop))\
+      istop -= unaligned_top;\
+   else{\
+      unaligned_top = istop;\
+      istop = 0;\
+   }
+
+void png_read_filter_row_up_vsx(png_row_infop row_info, png_bytep row,
+                                png_const_bytep prev_row)
+{
+   vector unsigned char rp_vec;
+   vector unsigned char pp_vec;
+   vsx_declare_common_vars(row_info,row,prev_row,0)
+
+   /* Altivec operations require 16-byte aligned data
+    * but input can be unaligned. So we calculate
+    * unaligned part as usual.
+    */
+   for (i = 0; i < unaligned_top; i++)
+   {
+      *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);
+      rp++;
+   }
+
+   /* Using SIMD while we can */
+   while( istop >= 16 )
+   {
+      rp_vec = vec_ld(0,rp);
+      vec_ld_unaligned(pp_vec,pp);
+
+      rp_vec = vec_add(rp_vec,pp_vec);
+
+      vec_st(rp_vec,0,rp);
+
+      pp += 16;
+      rp += 16;
+      istop -= 16;
+   }
+
+   if(istop > 0)
+   {
+      /* If byte count of row is not divisible by 16
+       * we will process remaining part as usual
+       */
+      for (i = 0; i < istop; i++)
+      {
+         *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);
+         rp++;
+      }
+}
+
+}
+
+static const vector unsigned char VSX_LEFTSHIFTED1_4 = {16,16,16,16, 0, 1, 2, 3,16,16,16,16,16,16,16,16};
+static const vector unsigned char VSX_LEFTSHIFTED2_4 = {16,16,16,16,16,16,16,16, 4, 5, 6, 7,16,16,16,16};
+static const vector unsigned char VSX_LEFTSHIFTED3_4 = {16,16,16,16,16,16,16,16,16,16,16,16, 8, 9,10,11};
+
+static const vector unsigned char VSX_LEFTSHIFTED1_3 = {16,16,16, 0, 1, 2,16,16,16,16,16,16,16,16,16,16};
+static const vector unsigned char VSX_LEFTSHIFTED2_3 = {16,16,16,16,16,16, 3, 4, 5,16,16,16,16,16,16,16};
+static const vector unsigned char VSX_LEFTSHIFTED3_3 = {16,16,16,16,16,16,16,16,16, 6, 7, 8,16,16,16,16};
+static const vector unsigned char VSX_LEFTSHIFTED4_3 = {16,16,16,16,16,16,16,16,16,16,16,16, 9,10,11,16};
+
+static const vector unsigned char VSX_NOT_SHIFTED1_4 = {16,16,16,16, 4, 5, 6, 7,16,16,16,16,16,16,16,16};
+static const vector unsigned char VSX_NOT_SHIFTED2_4 = {16,16,16,16,16,16,16,16, 8, 9,10,11,16,16,16,16};
+static const vector unsigned char VSX_NOT_SHIFTED3_4 = {16,16,16,16,16,16,16,16,16,16,16,16,12,13,14,15};
+
+static const vector unsigned char VSX_NOT_SHIFTED1_3 = {16,16,16, 3, 4, 5,16,16,16,16,16,16,16,16,16,16};
+static const vector unsigned char VSX_NOT_SHIFTED2_3 = {16,16,16,16,16,16, 6, 7, 8,16,16,16,16,16,16,16};
+static const vector unsigned char VSX_NOT_SHIFTED3_3 = {16,16,16,16,16,16,16,16,16, 9,10,11,16,16,16,16};
+static const vector unsigned char VSX_NOT_SHIFTED4_3 = {16,16,16,16,16,16,16,16,16,16,16,16,12,13,14,16};
+
+static const vector unsigned char VSX_CHAR_ZERO = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+#ifdef __LITTLE_ENDIAN__
+
+static const vector unsigned char VSX_CHAR_TO_SHORT1_4 = { 4,16, 5,16, 6,16, 7,16,16,16,16,16,16,16,16,16};
+static const vector unsigned char VSX_CHAR_TO_SHORT2_4 = { 8,16, 9,16,10,16,11,16,16,16,16,16,16,16,16,16};
+static const vector unsigned char VSX_CHAR_TO_SHORT3_4 = {12,16,13,16,14,16,15,16,16,16,16,16,16,16,16,16};
+
+static const vector unsigned char VSX_SHORT_TO_CHAR1_4 = {16,16,16,16, 0, 2, 4, 6,16,16,16,16,16,16,16,16};
+static const vector unsigned char VSX_SHORT_TO_CHAR2_4 = {16,16,16,16,16,16,16,16, 0, 2, 4, 6,16,16,16,16};
+static const vector unsigned char VSX_SHORT_TO_CHAR3_4 = {16,16,16,16,16,16,16,16,16,16,16,16, 0, 2, 4, 6};
+
+static const vector unsigned char VSX_CHAR_TO_SHORT1_3 = { 3,16, 4,16, 5,16,16,16,16,16,16,16,16,16,16,16};
+static const vector unsigned char VSX_CHAR_TO_SHORT2_3 = { 6,16, 7,16, 8,16,16,16,16,16,16,16,16,16,16,16};
+static const vector unsigned char VSX_CHAR_TO_SHORT3_3 = { 9,16,10,16,11,16,16,16,16,16,16,16,16,16,16,16};
+static const vector unsigned char VSX_CHAR_TO_SHORT4_3 = {12,16,13,16,14,16,16,16,16,16,16,16,16,16,16,16};
+
+static const vector unsigned char VSX_SHORT_TO_CHAR1_3 = {16,16,16, 0, 2, 4,16,16,16,16,16,16,16,16,16,16};
+static const vector unsigned char VSX_SHORT_TO_CHAR2_3 = {16,16,16,16,16,16, 0, 2, 4,16,16,16,16,16,16,16};
+static const vector unsigned char VSX_SHORT_TO_CHAR3_3 = {16,16,16,16,16,16,16,16,16, 0, 2, 4,16,16,16,16};
+static const vector unsigned char VSX_SHORT_TO_CHAR4_3 = {16,16,16,16,16,16,16,16,16,16,16,16, 0, 2, 4,16};
+
+#elif defined(__BIG_ENDIAN__)
+
+static const vector unsigned char VSX_CHAR_TO_SHORT1_4 = {16, 4,16, 5,16, 6,16, 7,16,16,16,16,16,16,16,16};
+static const vector unsigned char VSX_CHAR_TO_SHORT2_4 = {16, 8,16, 9,16,10,16,11,16,16,16,16,16,16,16,16};
+static const vector unsigned char VSX_CHAR_TO_SHORT3_4 = {16,12,16,13,16,14,16,15,16,16,16,16,16,16,16,16};
+
+static const vector unsigned char VSX_SHORT_TO_CHAR1_4 = {16,16,16,16, 1, 3, 5, 7,16,16,16,16,16,16,16,16};
+static const vector unsigned char VSX_SHORT_TO_CHAR2_4 = {16,16,16,16,16,16,16,16, 1, 3, 5, 7,16,16,16,16};
+static const vector unsigned char VSX_SHORT_TO_CHAR3_4 = {16,16,16,16,16,16,16,16,16,16,16,16, 1, 3, 5, 7};
+
+static const vector unsigned char VSX_CHAR_TO_SHORT1_3 = {16, 3,16, 4,16, 5,16,16,16,16,16,16,16,16,16,16};
+static const vector unsigned char VSX_CHAR_TO_SHORT2_3 = {16, 6,16, 7,16, 8,16,16,16,16,16,16,16,16,16,16};
+static const vector unsigned char VSX_CHAR_TO_SHORT3_3 = {16, 9,16,10,16,11,16,16,16,16,16,16,16,16,16,16};
+static const vector unsigned char VSX_CHAR_TO_SHORT4_3 = {16,12,16,13,16,14,16,16,16,16,16,16,16,16,16,16};
+
+static const vector unsigned char VSX_SHORT_TO_CHAR1_3 = {16,16,16, 1, 3, 5,16,16,16,16,16,16,16,16,16,16};
+static const vector unsigned char VSX_SHORT_TO_CHAR2_3 = {16,16,16,16,16,16, 1, 3, 5,16,16,16,16,16,16,16};
+static const vector unsigned char VSX_SHORT_TO_CHAR3_3 = {16,16,16,16,16,16,16,16,16, 1, 3, 5,16,16,16,16};
+static const vector unsigned char VSX_SHORT_TO_CHAR4_3 = {16,16,16,16,16,16,16,16,16,16,16,16, 1, 3, 5,16};
+
+#endif
+
+#define vsx_char_to_short(vec,offset,bpp) (vector unsigned short)vec_perm((vec),VSX_CHAR_ZERO,VSX_CHAR_TO_SHORT##offset##_##bpp)
+#define vsx_short_to_char(vec,offset,bpp) vec_perm(((vector unsigned char)(vec)),VSX_CHAR_ZERO,VSX_SHORT_TO_CHAR##offset##_##bpp)
+
+#ifdef PNG_USE_ABS
+#  define vsx_abs(number) abs(number)
+#else
+#  define vsx_abs(number) (number > 0) ? (number) : -(number)
+#endif
+
+void png_read_filter_row_sub4_vsx(png_row_infop row_info, png_bytep row,
+                                  png_const_bytep prev_row)
+{
+   png_byte bpp = 4;
+
+   vector unsigned char rp_vec;
+   vector unsigned char part_vec;
+
+   vsx_declare_common_vars(row_info,row,prev_row,bpp)
+
+   PNG_UNUSED(pp)
+
+   /* Altivec operations require 16-byte aligned data
+    * but input can be unaligned. So we calculate
+    * unaligned part as usual.
+    */
+   for (i = 0; i < unaligned_top; i++)
+   {
+      *rp = (png_byte)(((int)(*rp) + (int)(*(rp-bpp))) & 0xff);
+      rp++;
+   }
+
+   /* Using SIMD while we can */
+   while( istop >= 16 )
+   {
+      for(i=0;i < bpp ; i++)
+      {
+         *rp = (png_byte)(((int)(*rp) + (int)(*(rp-bpp))) & 0xff);
+         rp++;
+      }
+      rp -= bpp;
+
+      rp_vec = vec_ld(0,rp);
+      part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED1_4);
+      rp_vec = vec_add(rp_vec,part_vec);
+
+      part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED2_4);
+      rp_vec = vec_add(rp_vec,part_vec);
+
+      part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED3_4);
+      rp_vec = vec_add(rp_vec,part_vec);
+
+      vec_st(rp_vec,0,rp);
+
+      rp += 16;
+      istop -= 16;
+   }
+
+   if(istop > 0)
+      for (i = 0; i < istop % 16; i++)
+      {
+         *rp = (png_byte)(((int)(*rp) + (int)(*(rp - bpp))) & 0xff);
+         rp++;
+      }
+
+}
+
+void png_read_filter_row_sub3_vsx(png_row_infop row_info, png_bytep row,
+                                  png_const_bytep prev_row)
+{
+   png_byte bpp = 3;
+
+   vector unsigned char rp_vec;
+   vector unsigned char part_vec;
+
+   vsx_declare_common_vars(row_info,row,prev_row,bpp)
+
+   PNG_UNUSED(pp)
+
+   /* Altivec operations require 16-byte aligned data
+    * but input can be unaligned. So we calculate
+    * unaligned part as usual.
+    */
+   for (i = 0; i < unaligned_top; i++)
+   {
+      *rp = (png_byte)(((int)(*rp) + (int)(*(rp-bpp))) & 0xff);
+      rp++;
+   }
+
+   /* Using SIMD while we can */
+   while( istop >= 16 )
+   {
+      for(i=0;i < bpp ; i++)
+      {
+         *rp = (png_byte)(((int)(*rp) + (int)(*(rp-bpp))) & 0xff);
+         rp++;
+      }
+      rp -= bpp;
+
+      rp_vec = vec_ld(0,rp);
+      part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED1_3);
+      rp_vec = vec_add(rp_vec,part_vec);
+
+      part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED2_3);
+      rp_vec = vec_add(rp_vec,part_vec);
+
+      part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED3_3);
+      rp_vec = vec_add(rp_vec,part_vec);
+
+      part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED4_3);
+      rp_vec = vec_add(rp_vec,part_vec);
+
+      vec_st(rp_vec,0,rp);
+      rp += 15;
+      istop -= 16;
+
+      /* Since 16 % bpp = 16 % 3 = 1, last element of array must
+       * be proceeded manually
+       */
+      *rp = (png_byte)(((int)(*rp) + (int)(*(rp-bpp))) & 0xff);
+      rp++;
+   }
+
+   if(istop > 0)
+      for (i = 0; i < istop % 16; i++)
+      {
+         *rp = (png_byte)(((int)(*rp) + (int)(*(rp-bpp))) & 0xff);
+         rp++;
+      }
+}
+
+void png_read_filter_row_avg4_vsx(png_row_infop row_info, png_bytep row,
+                                  png_const_bytep prev_row)
+{
+   png_byte bpp = 4;
+
+   vector unsigned char rp_vec;
+   vector unsigned char pp_vec;
+   vector unsigned char pp_part_vec;
+   vector unsigned char rp_part_vec;
+   vector unsigned char avg_vec;
+
+   vsx_declare_common_vars(row_info,row,prev_row,bpp)
+   rp -= bpp;
+   if(istop >= bpp)
+      istop -= bpp;
+
+   for (i = 0; i < bpp; i++)
+   {
+      *rp = (png_byte)(((int)(*rp) +
+         ((int)(*pp++) / 2 )) & 0xff);
+
+      rp++;
+   }
+
+   /* Altivec operations require 16-byte aligned data
+    * but input can be unaligned. So we calculate
+    * unaligned part as usual.
+    */
+   for (i = 0; i < unaligned_top; i++)
+   {
+      *rp = (png_byte)(((int)(*rp) +
+         (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff);
+
+      rp++;
+   }
+
+   /* Using SIMD while we can */
+   while( istop >= 16 )
+   {
+      for(i=0;i < bpp ; i++)
+      {
+         *rp = (png_byte)(((int)(*rp) +
+            (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff);
+
+         rp++;
+      }
+      rp -= bpp;
+      pp -= bpp;
+
+      vec_ld_unaligned(pp_vec,pp);
+      rp_vec = vec_ld(0,rp);
+
+      rp_part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED1_4);
+      pp_part_vec = vec_perm(pp_vec,VSX_CHAR_ZERO,VSX_NOT_SHIFTED1_4);
+      avg_vec = vec_avg(rp_part_vec,pp_part_vec);
+      avg_vec = vec_sub(avg_vec, vec_and(vec_xor(rp_part_vec,pp_part_vec),vec_splat_u8(1)));
+      rp_vec = vec_add(rp_vec,avg_vec);
+
+      rp_part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED2_4);
+      pp_part_vec = vec_perm(pp_vec,VSX_CHAR_ZERO,VSX_NOT_SHIFTED2_4);
+      avg_vec = vec_avg(rp_part_vec,pp_part_vec);
+      avg_vec = vec_sub(avg_vec, vec_and(vec_xor(rp_part_vec,pp_part_vec),vec_splat_u8(1)));
+      rp_vec = vec_add(rp_vec,avg_vec);
+
+      rp_part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED3_4);
+      pp_part_vec = vec_perm(pp_vec,VSX_CHAR_ZERO,VSX_NOT_SHIFTED3_4);
+      avg_vec = vec_avg(rp_part_vec,pp_part_vec);
+      avg_vec = vec_sub(avg_vec, vec_and(vec_xor(rp_part_vec,pp_part_vec),vec_splat_u8(1)));
+      rp_vec = vec_add(rp_vec,avg_vec);
+
+      vec_st(rp_vec,0,rp);
+
+      rp += 16;
+      pp += 16;
+      istop -= 16;
+   }
+
+   if(istop  > 0)
+      for (i = 0; i < istop % 16; i++)
+      {
+         *rp = (png_byte)(((int)(*rp) +
+            (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff);
+
+         rp++;
+      }
+}
+
+void png_read_filter_row_avg3_vsx(png_row_infop row_info, png_bytep row,
+                                  png_const_bytep prev_row)
+{
+  png_byte bpp = 3;
+
+  vector unsigned char rp_vec;
+  vector unsigned char pp_vec;
+  vector unsigned char pp_part_vec;
+  vector unsigned char rp_part_vec;
+  vector unsigned char avg_vec;
+
+  vsx_declare_common_vars(row_info,row,prev_row,bpp)
+  rp -= bpp;
+  if(istop >= bpp)
+     istop -= bpp;
+
+  for (i = 0; i < bpp; i++)
+  {
+     *rp = (png_byte)(((int)(*rp) +
+        ((int)(*pp++) / 2 )) & 0xff);
+
+     rp++;
+  }
+
+  /* Altivec operations require 16-byte aligned data
+   * but input can be unaligned. So we calculate
+   * unaligned part as usual.
+   */
+  for (i = 0; i < unaligned_top; i++)
+  {
+     *rp = (png_byte)(((int)(*rp) +
+        (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff);
+
+     rp++;
+  }
+
+  /* Using SIMD while we can */
+  while( istop >= 16 )
+  {
+     for(i=0;i < bpp ; i++)
+     {
+        *rp = (png_byte)(((int)(*rp) +
+           (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff);
+
+        rp++;
+     }
+     rp -= bpp;
+     pp -= bpp;
+
+     vec_ld_unaligned(pp_vec,pp);
+     rp_vec = vec_ld(0,rp);
+
+     rp_part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED1_3);
+     pp_part_vec = vec_perm(pp_vec,VSX_CHAR_ZERO,VSX_NOT_SHIFTED1_3);
+     avg_vec = vec_avg(rp_part_vec,pp_part_vec);
+     avg_vec = vec_sub(avg_vec, vec_and(vec_xor(rp_part_vec,pp_part_vec),vec_splat_u8(1)));
+     rp_vec = vec_add(rp_vec,avg_vec);
+
+     rp_part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED2_3);
+     pp_part_vec = vec_perm(pp_vec,VSX_CHAR_ZERO,VSX_NOT_SHIFTED2_3);
+     avg_vec = vec_avg(rp_part_vec,pp_part_vec);
+     avg_vec = vec_sub(avg_vec, vec_and(vec_xor(rp_part_vec,pp_part_vec),vec_splat_u8(1)));
+     rp_vec = vec_add(rp_vec,avg_vec);
+
+     rp_part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED3_3);
+     pp_part_vec = vec_perm(pp_vec,VSX_CHAR_ZERO,VSX_NOT_SHIFTED3_3);
+     avg_vec = vec_avg(rp_part_vec,pp_part_vec);
+     avg_vec = vec_sub(avg_vec, vec_and(vec_xor(rp_part_vec,pp_part_vec),vec_splat_u8(1)));
+     rp_vec = vec_add(rp_vec,avg_vec);
+
+     rp_part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED4_3);
+     pp_part_vec = vec_perm(pp_vec,VSX_CHAR_ZERO,VSX_NOT_SHIFTED4_3);
+     avg_vec = vec_avg(rp_part_vec,pp_part_vec);
+     avg_vec = vec_sub(avg_vec, vec_and(vec_xor(rp_part_vec,pp_part_vec),vec_splat_u8(1)));
+     rp_vec = vec_add(rp_vec,avg_vec);
+
+     vec_st(rp_vec,0,rp);
+
+     rp += 15;
+     pp += 15;
+     istop -= 16;
+
+     /* Since 16 % bpp = 16 % 3 = 1, last element of array must
+      * be proceeded manually
+      */
+     *rp = (png_byte)(((int)(*rp) +
+        (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff);
+     rp++;
+  }
+
+  if(istop  > 0)
+     for (i = 0; i < istop % 16; i++)
+     {
+        *rp = (png_byte)(((int)(*rp) +
+           (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff);
+
+        rp++;
+     }
+}
+
+/* Bytewise c ? t : e. */
+#define if_then_else(c,t,e) vec_sel(e,t,c)
+
+#define vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp) {\
+      c = *(pp - bpp);\
+      a = *(rp - bpp);\
+      b = *pp++;\
+      p = b - c;\
+      pc = a - c;\
+      pa = vsx_abs(p);\
+      pb = vsx_abs(pc);\
+      pc = vsx_abs(p + pc);\
+      if (pb < pa) pa = pb, a = b;\
+      if (pc < pa) a = c;\
+      a += *rp;\
+      *rp++ = (png_byte)a;\
+      }
+
+void png_read_filter_row_paeth4_vsx(png_row_infop row_info, png_bytep row,
+   png_const_bytep prev_row)
+{
+   png_byte bpp = 4;
+
+   int a, b, c, pa, pb, pc, p;
+   vector unsigned char rp_vec;
+   vector unsigned char pp_vec;
+   vector unsigned short a_vec,b_vec,c_vec,nearest_vec;
+   vector signed short pa_vec,pb_vec,pc_vec,smallest_vec;
+
+   vsx_declare_common_vars(row_info,row,prev_row,bpp)
+   rp -= bpp;
+   if(istop >= bpp)
+      istop -= bpp;
+
+   /* Process the first pixel in the row completely (this is the same as 'up'
+    * because there is only one candidate predictor for the first row).
+    */
+   for(i = 0; i < bpp ; i++)
+   {
+      *rp = (png_byte)( *rp + *pp);
+      rp++;
+      pp++;
+   }
+
+   for(i = 0; i < unaligned_top ; i++)
+   {
+      vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp)
+   }
+
+   while( istop >= 16)
+   {
+      for(i = 0; i < bpp ; i++)
+      {
+         vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp)
+      }
+
+      rp -= bpp;
+      pp -= bpp;
+      rp_vec = vec_ld(0,rp);
+      vec_ld_unaligned(pp_vec,pp);
+
+      a_vec = vsx_char_to_short(vec_perm(rp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED1_4),1,4);
+      b_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_NOT_SHIFTED1_4),1,4);
+      c_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED1_4),1,4);
+      pa_vec = (vector signed short) vec_sub(b_vec,c_vec);
+      pb_vec = (vector signed short) vec_sub(a_vec , c_vec);
+      pc_vec = vec_add(pa_vec,pb_vec);
+      pa_vec = vec_abs(pa_vec);
+      pb_vec = vec_abs(pb_vec);
+      pc_vec = vec_abs(pc_vec);
+      smallest_vec = vec_min(pc_vec, vec_min(pa_vec,pb_vec));
+      nearest_vec =  if_then_else(
+            vec_cmpeq(pa_vec,smallest_vec),
+            a_vec,
+            if_then_else(
+              vec_cmpeq(pb_vec,smallest_vec),
+              b_vec,
+              c_vec
+              )
+            );
+      rp_vec = vec_add(rp_vec,(vsx_short_to_char(nearest_vec,1,4)));
+
+      a_vec = vsx_char_to_short(vec_perm(rp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED2_4),2,4);
+      b_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_NOT_SHIFTED2_4),2,4);
+      c_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED2_4),2,4);
+      pa_vec = (vector signed short) vec_sub(b_vec,c_vec);
+      pb_vec = (vector signed short) vec_sub(a_vec , c_vec);
+      pc_vec = vec_add(pa_vec,pb_vec);
+      pa_vec = vec_abs(pa_vec);
+      pb_vec = vec_abs(pb_vec);
+      pc_vec = vec_abs(pc_vec);
+      smallest_vec = vec_min(pc_vec, vec_min(pa_vec,pb_vec));
+      nearest_vec =  if_then_else(
+            vec_cmpeq(pa_vec,smallest_vec),
+            a_vec,
+            if_then_else(
+              vec_cmpeq(pb_vec,smallest_vec),
+              b_vec,
+              c_vec
+              )
+            );
+      rp_vec = vec_add(rp_vec,(vsx_short_to_char(nearest_vec,2,4)));
+
+      a_vec = vsx_char_to_short(vec_perm(rp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED3_4),3,4);
+      b_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_NOT_SHIFTED3_4),3,4);
+      c_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED3_4),3,4);
+      pa_vec = (vector signed short) vec_sub(b_vec,c_vec);
+      pb_vec = (vector signed short) vec_sub(a_vec , c_vec);
+      pc_vec = vec_add(pa_vec,pb_vec);
+      pa_vec = vec_abs(pa_vec);
+      pb_vec = vec_abs(pb_vec);
+      pc_vec = vec_abs(pc_vec);
+      smallest_vec = vec_min(pc_vec, vec_min(pa_vec,pb_vec));
+      nearest_vec =  if_then_else(
+            vec_cmpeq(pa_vec,smallest_vec),
+            a_vec,
+            if_then_else(
+              vec_cmpeq(pb_vec,smallest_vec),
+              b_vec,
+              c_vec
+              )
+            );
+      rp_vec = vec_add(rp_vec,(vsx_short_to_char(nearest_vec,3,4)));
+
+      vec_st(rp_vec,0,rp);
+
+      rp += 16;
+      pp += 16;
+      istop -= 16;
+   }
+
+   if(istop > 0)
+      for (i = 0; i < istop % 16; i++)
+      {
+         vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp)
+      }
+}
+
+void png_read_filter_row_paeth3_vsx(png_row_infop row_info, png_bytep row,
+   png_const_bytep prev_row)
+{
+  png_byte bpp = 3;
+
+  int a, b, c, pa, pb, pc, p;
+  vector unsigned char rp_vec;
+  vector unsigned char pp_vec;
+  vector unsigned short a_vec,b_vec,c_vec,nearest_vec;
+  vector signed short pa_vec,pb_vec,pc_vec,smallest_vec;
+
+  vsx_declare_common_vars(row_info,row,prev_row,bpp)
+  rp -= bpp;
+  if(istop >= bpp)
+     istop -= bpp;
+
+  /* Process the first pixel in the row completely (this is the same as 'up'
+   * because there is only one candidate predictor for the first row).
+   */
+  for(i = 0; i < bpp ; i++)
+  {
+     *rp = (png_byte)( *rp + *pp);
+     rp++;
+     pp++;
+  }
+
+  for(i = 0; i < unaligned_top ; i++)
+  {
+     vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp)
+  }
+
+  while( istop >= 16)
+  {
+     for(i = 0; i < bpp ; i++)
+     {
+        vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp)
+     }
+
+     rp -= bpp;
+     pp -= bpp;
+     rp_vec = vec_ld(0,rp);
+     vec_ld_unaligned(pp_vec,pp);
+
+     a_vec = vsx_char_to_short(vec_perm(rp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED1_3),1,3);
+     b_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_NOT_SHIFTED1_3),1,3);
+     c_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED1_3),1,3);
+     pa_vec = (vector signed short) vec_sub(b_vec,c_vec);
+     pb_vec = (vector signed short) vec_sub(a_vec , c_vec);
+     pc_vec = vec_add(pa_vec,pb_vec);
+     pa_vec = vec_abs(pa_vec);
+     pb_vec = vec_abs(pb_vec);
+     pc_vec = vec_abs(pc_vec);
+     smallest_vec = vec_min(pc_vec, vec_min(pa_vec,pb_vec));
+     nearest_vec =  if_then_else(
+           vec_cmpeq(pa_vec,smallest_vec),
+           a_vec,
+           if_then_else(
+             vec_cmpeq(pb_vec,smallest_vec),
+             b_vec,
+             c_vec
+             )
+           );
+     rp_vec = vec_add(rp_vec,(vsx_short_to_char(nearest_vec,1,3)));
+
+     a_vec = vsx_char_to_short(vec_perm(rp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED2_3),2,3);
+     b_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_NOT_SHIFTED2_3),2,3);
+     c_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED2_3),2,3);
+     pa_vec = (vector signed short) vec_sub(b_vec,c_vec);
+     pb_vec = (vector signed short) vec_sub(a_vec , c_vec);
+     pc_vec = vec_add(pa_vec,pb_vec);
+     pa_vec = vec_abs(pa_vec);
+     pb_vec = vec_abs(pb_vec);
+     pc_vec = vec_abs(pc_vec);
+     smallest_vec = vec_min(pc_vec, vec_min(pa_vec,pb_vec));
+     nearest_vec =  if_then_else(
+           vec_cmpeq(pa_vec,smallest_vec),
+           a_vec,
+           if_then_else(
+             vec_cmpeq(pb_vec,smallest_vec),
+             b_vec,
+             c_vec
+             )
+           );
+     rp_vec = vec_add(rp_vec,(vsx_short_to_char(nearest_vec,2,3)));
+
+     a_vec = vsx_char_to_short(vec_perm(rp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED3_3),3,3);
+     b_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_NOT_SHIFTED3_3),3,3);
+     c_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED3_3),3,3);
+     pa_vec = (vector signed short) vec_sub(b_vec,c_vec);
+     pb_vec = (vector signed short) vec_sub(a_vec , c_vec);
+     pc_vec = vec_add(pa_vec,pb_vec);
+     pa_vec = vec_abs(pa_vec);
+     pb_vec = vec_abs(pb_vec);
+     pc_vec = vec_abs(pc_vec);
+     smallest_vec = vec_min(pc_vec, vec_min(pa_vec,pb_vec));
+     nearest_vec =  if_then_else(
+           vec_cmpeq(pa_vec,smallest_vec),
+           a_vec,
+           if_then_else(
+             vec_cmpeq(pb_vec,smallest_vec),
+             b_vec,
+             c_vec
+             )
+           );
+     rp_vec = vec_add(rp_vec,(vsx_short_to_char(nearest_vec,3,3)));
+
+     a_vec = vsx_char_to_short(vec_perm(rp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED4_3),4,3);
+     b_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_NOT_SHIFTED4_3),4,3);
+     c_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED4_3),4,3);
+     pa_vec = (vector signed short) vec_sub(b_vec,c_vec);
+     pb_vec = (vector signed short) vec_sub(a_vec , c_vec);
+     pc_vec = vec_add(pa_vec,pb_vec);
+     pa_vec = vec_abs(pa_vec);
+     pb_vec = vec_abs(pb_vec);
+     pc_vec = vec_abs(pc_vec);
+     smallest_vec = vec_min(pc_vec, vec_min(pa_vec,pb_vec));
+     nearest_vec =  if_then_else(
+           vec_cmpeq(pa_vec,smallest_vec),
+           a_vec,
+           if_then_else(
+             vec_cmpeq(pb_vec,smallest_vec),
+             b_vec,
+             c_vec
+             )
+           );
+     rp_vec = vec_add(rp_vec,(vsx_short_to_char(nearest_vec,4,3)));
+
+     vec_st(rp_vec,0,rp);
+
+     rp += 15;
+     pp += 15;
+     istop -= 16;
+
+     /* Since 16 % bpp = 16 % 3 = 1, last element of array must
+      * be proceeded manually
+      */
+     vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp)
+  }
+
+  if(istop > 0)
+     for (i = 0; i < istop % 16; i++)
+     {
+        vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp)
+     }
+}
+
+#endif /* PNG_POWERPC_VSX_OPT > 0 */
+#endif /* PNG_POWERPC_VSX_IMPLEMENTATION == 1 (intrinsics) */
+#endif /* READ */
diff --git a/Engine/lib/lpng/powerpc/powerpc_init.c b/Engine/lib/lpng/powerpc/powerpc_init.c
new file mode 100644
index 000000000..54426c558
--- /dev/null
+++ b/Engine/lib/lpng/powerpc/powerpc_init.c
@@ -0,0 +1,126 @@
+
+/* powerpc_init.c - POWERPC optimised filter functions
+ *
+ * Copyright (c) 2018 Cosmin Truta
+ * Copyright (c) 2017 Glenn Randers-Pehrson
+ * Written by Vadim Barkov, 2017.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+/* Below, after checking __linux__, various non-C90 POSIX 1003.1 functions are
+ * called.
+ */
+#define _POSIX_SOURCE 1
+
+#include <stdio.h>
+#include "../pngpriv.h"
+
+#ifdef PNG_READ_SUPPORTED
+
+#if PNG_POWERPC_VSX_OPT > 0
+#ifdef PNG_POWERPC_VSX_CHECK_SUPPORTED /* Do run-time checks */
+/* WARNING: it is strongly recommended that you do not build libpng with
+ * run-time checks for CPU features if at all possible.  In the case of the PowerPC
+ * VSX instructions there is no processor-specific way of detecting the
+ * presence of the required support, therefore run-time detection is extremely
+ * OS specific.
+ *
+ * You may set the macro PNG_POWERPC_VSX_FILE to the file name of file containing
+ * a fragment of C source code which defines the png_have_vsx function.  There
+ * are a number of implementations in contrib/powerpc-vsx, but the only one that
+ * has partial support is contrib/powerpc-vsx/linux.c - a generic Linux
+ * implementation which reads /proc/cpufino.
+ */
+#ifndef PNG_POWERPC_VSX_FILE
+#  ifdef __linux__
+#     define  PNG_POWERPC_VSX_FILE "contrib/powerpc-vsx/linux_aux.c"
+#  endif
+#endif
+
+#ifdef PNG_POWERPC_VSX_FILE
+
+#include <signal.h> /* for sig_atomic_t */
+static int png_have_vsx(png_structp png_ptr);
+#include PNG_POWERPC_VSX_FILE
+
+#else  /* PNG_POWERPC_VSX_FILE */
+#  error "PNG_POWERPC_VSX_FILE undefined: no support for run-time POWERPC VSX checks"
+#endif /* PNG_POWERPC_VSX_FILE */
+#endif /* PNG_POWERPC_VSX_CHECK_SUPPORTED */
+
+void
+png_init_filter_functions_vsx(png_structp pp, unsigned int bpp)
+{
+   /* The switch statement is compiled in for POWERPC_VSX_API, the call to
+    * png_have_vsx is compiled in for POWERPC_VSX_CHECK. If both are defined
+    * the check is only performed if the API has not set the PowerPC option on
+    * or off explicitly. In this case the check controls what happens.
+    */
+
+#ifdef PNG_POWERPC_VSX_API_SUPPORTED
+   switch ((pp->options >> PNG_POWERPC_VSX) & 3)
+   {
+      case PNG_OPTION_UNSET:
+         /* Allow the run-time check to execute if it has been enabled -
+          * thus both API and CHECK can be turned on.  If it isn't supported
+          * this case will fall through to the 'default' below, which just
+          * returns.
+          */
+#endif /* PNG_POWERPC_VSX_API_SUPPORTED */
+#ifdef PNG_POWERPC_VSX_CHECK_SUPPORTED
+         {
+            static volatile sig_atomic_t no_vsx = -1; /* not checked */
+
+            if (no_vsx < 0)
+               no_vsx = !png_have_vsx(pp);
+
+            if (no_vsx)
+               return;
+         }
+#ifdef PNG_POWERPC_VSX_API_SUPPORTED
+         break;
+#endif
+#endif /* PNG_POWERPC_VSX_CHECK_SUPPORTED */
+
+#ifdef PNG_POWERPC_VSX_API_SUPPORTED
+      default: /* OFF or INVALID */
+         return;
+
+      case PNG_OPTION_ON:
+         /* Option turned on */
+         break;
+   }
+#endif
+
+   /* IMPORTANT: any new internal functions used here must be declared using
+    * PNG_INTERNAL_FUNCTION in ../pngpriv.h.  This is required so that the
+    * 'prefix' option to configure works:
+    *
+    *    ./configure --with-libpng-prefix=foobar_
+    *
+    * Verify you have got this right by running the above command, doing a build
+    * and examining pngprefix.h; it must contain a #define for every external
+    * function you add.  (Notice that this happens automatically for the
+    * initialization function.)
+    */
+   pp->read_filter[PNG_FILTER_VALUE_UP-1] = png_read_filter_row_up_vsx;
+
+   if (bpp == 3)
+   {
+      pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub3_vsx;
+      pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg3_vsx;
+      pp->read_filter[PNG_FILTER_VALUE_PAETH-1] = png_read_filter_row_paeth3_vsx;
+   }
+
+   else if (bpp == 4)
+   {
+      pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub4_vsx;
+      pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg4_vsx;
+      pp->read_filter[PNG_FILTER_VALUE_PAETH-1] = png_read_filter_row_paeth4_vsx;
+   }
+}
+#endif /* PNG_POWERPC_VSX_OPT > 0 */
+#endif /* READ */
diff --git a/Engine/lib/lpng/projects/owatcom/libpng.tgt b/Engine/lib/lpng/projects/owatcom/libpng.tgt
new file mode 100644
index 000000000..096b2eef1
--- /dev/null
+++ b/Engine/lib/lpng/projects/owatcom/libpng.tgt
@@ -0,0 +1,383 @@
+40
+targetIdent
+0
+MProject
+1
+MComponent
+0
+2
+WString
+3
+LIB
+3
+WString
+5
+n_2sn
+1
+0
+0
+4
+MCommand
+0
+5
+MCommand
+0
+6
+MItem
+10
+libpng.lib
+7
+WString
+3
+LIB
+8
+WVList
+0
+9
+WVList
+1
+10
+ActionStates
+11
+WString
+5
+&Make
+12
+WVList
+0
+-1
+1
+1
+0
+13
+WPickList
+16
+14
+MItem
+3
+*.c
+15
+WString
+4
+COBJ
+16
+WVList
+2
+17
+MVState
+18
+WString
+3
+WCC
+19
+WString
+25
+n????Include directories:
+1
+20
+WString
+39
+"$(%zlib);$(%watcom)/h;$(%watcom)/h/nt"
+0
+21
+MVState
+22
+WString
+3
+WCC
+23
+WString
+25
+n????Include directories:
+0
+24
+WString
+39
+"$(%zlib);$(%watcom)/h;$(%watcom)/h/nt"
+0
+25
+WVList
+1
+26
+ActionStates
+27
+WString
+5
+&Make
+28
+WVList
+0
+-1
+1
+1
+0
+29
+MItem
+11
+..\..\png.c
+30
+WString
+4
+COBJ
+31
+WVList
+0
+32
+WVList
+0
+14
+1
+1
+0
+33
+MItem
+16
+..\..\pngerror.c
+34
+WString
+4
+COBJ
+35
+WVList
+0
+36
+WVList
+0
+14
+1
+1
+0
+37
+MItem
+14
+..\..\pngget.c
+38
+WString
+4
+COBJ
+39
+WVList
+0
+40
+WVList
+0
+14
+1
+1
+0
+41
+MItem
+14
+..\..\pngmem.c
+42
+WString
+4
+COBJ
+43
+WVList
+0
+44
+WVList
+0
+14
+1
+1
+0
+45
+MItem
+16
+..\..\pngpread.c
+46
+WString
+4
+COBJ
+47
+WVList
+0
+48
+WVList
+0
+14
+1
+1
+0
+49
+MItem
+15
+..\..\pngread.c
+50
+WString
+4
+COBJ
+51
+WVList
+0
+52
+WVList
+0
+14
+1
+1
+0
+53
+MItem
+14
+..\..\pngrio.c
+54
+WString
+4
+COBJ
+55
+WVList
+0
+56
+WVList
+0
+14
+1
+1
+0
+57
+MItem
+16
+..\..\pngrtran.c
+58
+WString
+4
+COBJ
+59
+WVList
+0
+60
+WVList
+0
+14
+1
+1
+0
+61
+MItem
+16
+..\..\pngrutil.c
+62
+WString
+4
+COBJ
+63
+WVList
+0
+64
+WVList
+0
+14
+1
+1
+0
+65
+MItem
+14
+..\..\pngset.c
+66
+WString
+4
+COBJ
+67
+WVList
+0
+68
+WVList
+0
+14
+1
+1
+0
+69
+MItem
+16
+..\..\pngtrans.c
+70
+WString
+4
+COBJ
+71
+WVList
+0
+72
+WVList
+0
+14
+1
+1
+0
+73
+MItem
+14
+..\..\pngwio.c
+74
+WString
+4
+COBJ
+75
+WVList
+0
+76
+WVList
+0
+14
+1
+1
+0
+77
+MItem
+16
+..\..\pngwrite.c
+78
+WString
+4
+COBJ
+79
+WVList
+0
+80
+WVList
+0
+14
+1
+1
+0
+81
+MItem
+16
+..\..\pngwtran.c
+82
+WString
+4
+COBJ
+83
+WVList
+0
+84
+WVList
+0
+14
+1
+1
+0
+85
+MItem
+16
+..\..\pngwutil.c
+86
+WString
+4
+COBJ
+87
+WVList
+0
+88
+WVList
+0
+14
+1
+1
+0
diff --git a/Engine/lib/lpng/projects/owatcom/libpng.wpj b/Engine/lib/lpng/projects/owatcom/libpng.wpj
new file mode 100644
index 000000000..fe7583f01
--- /dev/null
+++ b/Engine/lib/lpng/projects/owatcom/libpng.wpj
@@ -0,0 +1,112 @@
+40
+projectIdent
+0
+VpeMain
+1
+WRect
+256
+0
+8960
+9294
+2
+MProject
+3
+MCommand
+322
+# Locations of zlib and (if required) awk (change as required:)
+set zlib=..\..\..\zlib
+set awk=
+#
+@if not exist pngconfig.dfa $(MAKE) $(__MAKEOPTS__) -f pngconfig.mak defaults
+@if exist config.inf type config.inf
+@echo Checking for the libpng configuration file pnglibconf.h
+$(MAKE) $(__MAKEOPTS__) -f pngconfig.mak
+4
+MCommand
+19
+@type pngconfig.inf
+4
+5
+WFileName
+10
+libpng.tgt
+6
+WFileName
+11
+pngtest.tgt
+7
+WFileName
+12
+pngvalid.tgt
+8
+WFileName
+12
+pngstest.tgt
+9
+WVList
+4
+10
+VComponent
+11
+WRect
+0
+0
+5638
+4174
+0
+0
+12
+WFileName
+10
+libpng.tgt
+0
+0
+13
+VComponent
+14
+WRect
+1280
+1550
+5638
+4174
+0
+0
+15
+WFileName
+11
+pngtest.tgt
+0
+1
+16
+VComponent
+17
+WRect
+524
+497
+5638
+4174
+0
+0
+18
+WFileName
+12
+pngvalid.tgt
+0
+1
+19
+VComponent
+20
+WRect
+2054
+2701
+5674
+4232
+0
+0
+21
+WFileName
+12
+pngstest.tgt
+0
+1
+19
diff --git a/Engine/lib/lpng/projects/owatcom/pngconfig.mak b/Engine/lib/lpng/projects/owatcom/pngconfig.mak
new file mode 100644
index 000000000..7524127b5
--- /dev/null
+++ b/Engine/lib/lpng/projects/owatcom/pngconfig.mak
@@ -0,0 +1,160 @@
+# This is an OpenWatcom make file which builds pnglibconf.h - the libpng
+# configuration header.  You can ignore this file if you don't need to
+# configure libpng; a default configuration will be built.
+#
+# For more information build libpng.wpj under the IDE and then read the
+# generated files:
+#
+#    config.inf: Basic configuration information for a standard build.
+#    pngconfig.dfa: Advanced configuration for non-standard libpng builds.
+#
+DELETE=rm -f
+ECHO=echo
+COPY=copy
+#
+# If your configuration needs to test compiler flags when building
+# pnglibconf.h you may need to override the following on the wmake command
+# line:
+CFLAGS=
+CC=wcl386
+CPP=$(CC) -pw0
+#
+# Read awk from the environment if set, else it can be set on the command
+# line (the default approach is to set the %awk% environment variable in the
+# IDE libpng.wpj 'before' rule - this setting is local.)
+!ifdef %awk
+AWK=$(%awk)
+!endif
+#
+# pnglibconf.h must exist in the source directory, this is the final rule
+# which copies the local built version (and this is the default target for
+# this makefile.)
+..\..\pnglibconf.h: pnglibconf.h
+ $(COPY) pnglibconf.h $@
+
+!ifdef AWK
+# CPPFLAGS should contain the options to control the result,
+# but DEFS and CFLAGS are also supported here, override
+# as appropriate
+DFNFLAGS = $(DEFS) $(CPPFLAGS) $(CFLAGS)
+
+pnglibconf.h: pnglibconf.dfn
+ $(DELETE) $@ dfn.c dfn1.out dfn2.out
+ $(ECHO) $#include "pnglibconf.dfn" >dfn.c
+ $(CPP) $(DFNFLAGS) dfn.c >dfn1.out
+ $(AWK) -f << dfn1.out >dfn2.out
+/^.*PNG_DEFN_MAGIC-.*-PNG_DEFN_END.*$$/{
+ sub(/^.*PNG_DEFN_MAGIC-/, "")
+ sub(/ *-PNG_DEFN_END.*$$/, "")
+ gsub(/ *@@@ */, "")
+ print
+}
+<<
+ $(COPY) dfn2.out $@
+ @type << >pngconfig.inf
+This is a locally configurable build of libpng.lib; for configuration
+instructions consult and edit projects/openwatcom/pngconfig.dfa
+<<
+ $(DELETE) dfn.c dfn1.out dfn2.out
+
+pnglibconf.dfn: ..\..\scripts\pnglibconf.dfa ..\..\scripts\options.awk pngconfig.dfa ..\..\pngconf.h
+ $(DELETE) $@ dfn1.out dfn2.out
+ $(AWK) -f ..\..\scripts\options.awk out=dfn1.out version=search ..\..\pngconf.h ..\..\scripts\pnglibconf.dfa pngconfig.dfa $(DFA_XTRA) 1>&2
+ $(AWK) -f ..\..\scripts\options.awk out=dfn2.out dfn1.out 1>&2
+ $(COPY) dfn2.out $@
+ $(DELETE) dfn1.out dfn2.out
+
+!else
+# The following lines are used to copy scripts\pnglibconf.h.prebuilt and make
+# the required change to the calling convention.
+#
+# By default libpng is built to use the __cdecl calling convention on
+# Windows.  This gives compatibility with MSVC and GCC.  Unfortunately it
+# does not work with OpenWatcom because OpenWatcom implements longjmp using
+# the __watcall convention (compared with both MSVC and GCC which use __cdecl
+# for library functions.)
+#
+# Thus the default must be changed to build on OpenWatcom and, once changed,
+# the result will not be compatible with applications built using other
+# compilers (in fact attempts to build will fail at compile time.)
+#
+pnglibconf.h: ..\..\scripts\pnglibconf.h.prebuilt .existsonly
+ @$(ECHO) .
+ @$(ECHO) .
+ @$(ECHO) $$(AWK) NOT AVAILABLE: COPYING scripts\pnglibconf.h.prebuilt
+ @$(ECHO) .
+ @$(ECHO) .
+ vi -q -k ":1,$$s/PNG_API_RULE 0$$/PNG_API_RULE 2/\n:w! $@\n:q!\n" ..\..\scripts\pnglibconf.h.prebuilt
+ @$(ECHO) .
+ @$(ECHO) .
+ @$(ECHO) YOU HAVE A DEFAULT CONFIGURATION BECAUSE YOU DO NOT HAVE AWK!
+ @$(ECHO) .
+ @$(ECHO) .
+ @type << >pngconfig.inf
+This is the default configuration of libpng.lib, if you wish to
+change the configuration please consult the instructions in
+projects/owatcom/pngconfig.dfa.
+<<
+
+!endif
+
+# Make the default files
+defaults: .symbolic
+ @$(COPY) << config.inf
+$# The libpng project is incompletely configured.  To complete configuration
+$# please complete the following steps:
+$#
+$#   1) Edit the 'before' rule of libpng.wpj (from the IDE) to define the
+$#      locations of the zlib include file zlib.h and the built zlib library,
+$#      zlib.lib.
+$#
+$#   2) If you want to change libpng to a non-standard configuration also
+$#      change the definition of 'awk' in the before rule to the name of your
+$#      awk command.  For more instructions on configuration read
+$#      pngconfig.dfa.
+$#
+$#   3) Delete this file (config.inf).
+<<
+ @$(COPY) << pngconfig.dfa
+$# pngconfig.dfa: this file contains configuration options for libpng.
+$# If empty the standard configuration will be built.  For this file to be
+$# used a working version of the program 'awk' is required and the program
+$# must be identified in the 'before' rule of the project.
+$#
+$# If you don't already have 'awk', or the version of awk you have seems not
+$# to work, download Brian Kernighan's awk (Brian Kernighan is the author of
+$# awk.)  You can find source code and a built executable (called awk95.exe)
+$# here:
+$#
+$#     https://www.cs.princeton.edu/~bwk/btl.mirror/
+$#
+$# The executable works just fine.
+$#
+$# If build issues errors after a change to pngconfig.dfa you have entered
+$# inconsistent feature requests, or even malformed requests, in
+$# pngconfig.dfa.  The error messages from awk should be comprehensible, but
+$# if not simply go back to the start (nothing but comments in this file) and
+$# enter configuration lines one by one until one produces an error.  (Or, of
+$# course, do the standard binary chop.)
+$#
+$# You need to rebuild everything after a change to pnglibconf.dfa - i.e. you
+$# must do Actions/Mark All Targets for Remake.  This is because the compiler
+$# generated dependency information (as of OpenWatcom 1.9) does not record the
+$# dependency on pnglibconf.h correctly.
+$#
+$# If awk isn't set then this file is bypassed.  If you just want the standard
+$# configuration it is automatically produced from the distributed version
+$# (scripts\pnglibconf.h.prebuilt) by editing PNG_API_RULE to 2 (to force use
+$# of the OpenWatcom library calling convention.)
+$#
+<<
+
+clean:: .symbolic
+ $(DELETE) ..\..\pnglibconf.h pnglibconf.* dfn.c *.out pngconfig.inf
+ $(DELETE) *.obj *.mbr *.sym *.err *.pch libpng.mk
+ $(DELETE) libpng.lib libpng.lbr libpng.lb1 libpng.cbr libpng.mk1
+ $(DELETE) pngtest.exe pngtest.map pngtest.lk1 pngtest.mk1
+ $(DELETE) pngvalid.exe pngvalid.map pngvalid.lk1 pngvalid.mk1
+
+distclean:: clean .symbolic
+ $(DELETE) zlib.inf awk.inf config.inf pngconfig.dfa
diff --git a/Engine/lib/lpng/projects/owatcom/pngstest.tgt b/Engine/lib/lpng/projects/owatcom/pngstest.tgt
new file mode 100644
index 000000000..696f7988a
--- /dev/null
+++ b/Engine/lib/lpng/projects/owatcom/pngstest.tgt
@@ -0,0 +1,219 @@
+40
+targetIdent
+0
+MProject
+1
+MComponent
+0
+2
+WString
+4
+NEXE
+3
+WString
+5
+nc2en
+1
+0
+0
+4
+MCommand
+0
+5
+MCommand
+1118
+pngstest --strict --log ../../contrib/pngsuite/basn0g01.png ../../contrib/pngsuite/basn0g02.png ../../contrib/pngsuite/basn0g04.png ../../contrib/pngsuite/basn0g08.png ../../contrib/pngsuite/basn0g16.png ../../contrib/pngsuite/basn2c08.png ../../contrib/pngsuite/basn2c16.png ../../contrib/pngsuite/basn3p01.png ../../contrib/pngsuite/basn3p02.png ../../contrib/pngsuite/basn3p04.png ../../contrib/pngsuite/basn3p08.png ../../contrib/pngsuite/basn4a08.png ../../contrib/pngsuite/basn4a16.png ../../contrib/pngsuite/basn6a08.png ../../contrib/pngsuite/basn6a16.png ../../contrib/pngsuite/ftbbn0g04.png ../../contrib/pngsuite/ftbbn0g01.png ../../contrib/pngsuite/ftbbn0g02.png ../../contrib/pngsuite/ftbbn2c16.png ../../contrib/pngsuite/ftbbn3p08.png ../../contrib/pngsuite/ftbgn2c16.png ../../contrib/pngsuite/ftbgn3p08.png ../../contrib/pngsuite/ftbrn2c08.png ../../contrib/pngsuite/ftbwn0g16.png ../../contrib/pngsuite/ftbwn3p08.png ../../contrib/pngsuite/ftbyn3p08.png ../../contrib/pngsuite/ftp0n0g08.png ../../contrib/pngsuite/ftp0n2c08.png ../../contrib/pngsuite/ftp0n3p08.png ../../contrib/pngsuite/ftp1n3p08.png
+6
+MItem
+12
+pngstest.exe
+7
+WString
+4
+NEXE
+8
+WVList
+6
+9
+MVState
+10
+WString
+7
+WINLINK
+11
+WString
+11
+?????Stack:
+1
+12
+WString
+4
+768k
+0
+13
+MVState
+14
+WString
+7
+WINLINK
+15
+WString
+28
+?????Library directories(;):
+1
+16
+WString
+8
+$(%zlib)
+0
+17
+MVState
+18
+WString
+7
+WINLINK
+19
+WString
+18
+?????Libraries(,):
+1
+20
+WString
+19
+libpng.lib zlib.lib
+0
+21
+MVState
+22
+WString
+7
+WINLINK
+23
+WString
+11
+?????Stack:
+0
+24
+WString
+4
+768k
+0
+25
+MVState
+26
+WString
+7
+WINLINK
+27
+WString
+28
+?????Library directories(;):
+0
+28
+WString
+8
+$(%zlib)
+0
+29
+MVState
+30
+WString
+7
+WINLINK
+31
+WString
+18
+?????Libraries(,):
+0
+32
+WString
+19
+libpng.lib zlib.lib
+0
+33
+WVList
+1
+34
+ActionStates
+35
+WString
+4
+&Run
+36
+WVList
+0
+-1
+1
+1
+0
+37
+WPickList
+2
+38
+MItem
+3
+*.c
+39
+WString
+4
+COBJ
+40
+WVList
+2
+41
+MVState
+42
+WString
+3
+WCC
+43
+WString
+25
+n????Include directories:
+1
+44
+WString
+39
+"$(%zlib);$(%watcom)/h;$(%watcom)/h/nt"
+0
+45
+MVState
+46
+WString
+3
+WCC
+47
+WString
+25
+n????Include directories:
+0
+48
+WString
+39
+"$(%zlib);$(%watcom)/h;$(%watcom)/h/nt"
+0
+49
+WVList
+0
+-1
+1
+1
+0
+50
+MItem
+33
+..\..\contrib\libtests\pngstest.c
+51
+WString
+4
+COBJ
+52
+WVList
+0
+53
+WVList
+0
+38
+1
+1
+0
diff --git a/Engine/lib/lpng/projects/owatcom/pngtest.tgt b/Engine/lib/lpng/projects/owatcom/pngtest.tgt
new file mode 100644
index 000000000..ca3db8c3a
--- /dev/null
+++ b/Engine/lib/lpng/projects/owatcom/pngtest.tgt
@@ -0,0 +1,179 @@
+40
+targetIdent
+0
+MProject
+1
+MComponent
+0
+2
+WString
+4
+NEXE
+3
+WString
+5
+nc2en
+1
+0
+0
+4
+MCommand
+0
+5
+MCommand
+34
+cd ..\..
+projects\owatcom\pngtest
+6
+MItem
+11
+pngtest.exe
+7
+WString
+4
+NEXE
+8
+WVList
+4
+9
+MVState
+10
+WString
+7
+WINLINK
+11
+WString
+28
+?????Library directories(;):
+1
+12
+WString
+8
+$(%zlib)
+0
+13
+MVState
+14
+WString
+7
+WINLINK
+15
+WString
+18
+?????Libraries(,):
+1
+16
+WString
+19
+libpng.lib zlib.lib
+0
+17
+MVState
+18
+WString
+7
+WINLINK
+19
+WString
+28
+?????Library directories(;):
+0
+20
+WString
+8
+$(%zlib)
+0
+21
+MVState
+22
+WString
+7
+WINLINK
+23
+WString
+18
+?????Libraries(,):
+0
+24
+WString
+19
+libpng.lib zlib.lib
+0
+25
+WVList
+0
+-1
+1
+1
+0
+26
+WPickList
+2
+27
+MItem
+3
+*.c
+28
+WString
+4
+COBJ
+29
+WVList
+2
+30
+MVState
+31
+WString
+3
+WCC
+32
+WString
+25
+n????Include directories:
+1
+33
+WString
+39
+"$(%zlib);$(%watcom)/h;$(%watcom)/h/nt"
+0
+34
+MVState
+35
+WString
+3
+WCC
+36
+WString
+25
+n????Include directories:
+0
+37
+WString
+39
+"$(%zlib);$(%watcom)/h;$(%watcom)/h/nt"
+0
+38
+WVList
+0
+-1
+1
+1
+0
+39
+MItem
+15
+..\..\pngtest.c
+40
+WString
+4
+COBJ
+41
+WVList
+0
+42
+WVList
+0
+27
+1
+1
+0
diff --git a/Engine/lib/lpng/projects/owatcom/pngvalid.tgt b/Engine/lib/lpng/projects/owatcom/pngvalid.tgt
new file mode 100644
index 000000000..1cc79085e
--- /dev/null
+++ b/Engine/lib/lpng/projects/owatcom/pngvalid.tgt
@@ -0,0 +1,210 @@
+40
+targetIdent
+0
+MProject
+1
+MComponent
+0
+2
+WString
+4
+NEXE
+3
+WString
+5
+nc2en
+1
+0
+0
+4
+MCommand
+0
+5
+MCommand
+8
+pngvalid
+6
+MItem
+12
+pngvalid.exe
+7
+WString
+4
+NEXE
+8
+WVList
+6
+9
+MVState
+10
+WString
+7
+WINLINK
+11
+WString
+11
+?????Stack:
+1
+12
+WString
+4
+768k
+0
+13
+MVState
+14
+WString
+7
+WINLINK
+15
+WString
+28
+?????Library directories(;):
+1
+16
+WString
+8
+$(%zlib)
+0
+17
+MVState
+18
+WString
+7
+WINLINK
+19
+WString
+18
+?????Libraries(,):
+1
+20
+WString
+19
+libpng.lib zlib.lib
+0
+21
+MVState
+22
+WString
+7
+WINLINK
+23
+WString
+11
+?????Stack:
+0
+24
+WString
+4
+768k
+0
+25
+MVState
+26
+WString
+7
+WINLINK
+27
+WString
+28
+?????Library directories(;):
+0
+28
+WString
+8
+$(%zlib)
+0
+29
+MVState
+30
+WString
+7
+WINLINK
+31
+WString
+18
+?????Libraries(,):
+0
+32
+WString
+19
+libpng.lib zlib.lib
+0
+33
+WVList
+0
+-1
+1
+1
+0
+34
+WPickList
+2
+35
+MItem
+3
+*.c
+36
+WString
+4
+COBJ
+37
+WVList
+2
+38
+MVState
+39
+WString
+3
+WCC
+40
+WString
+25
+n????Include directories:
+1
+41
+WString
+39
+"$(%zlib);$(%watcom)/h;$(%watcom)/h/nt"
+0
+42
+MVState
+43
+WString
+3
+WCC
+44
+WString
+25
+n????Include directories:
+0
+45
+WString
+39
+"$(%zlib);$(%watcom)/h;$(%watcom)/h/nt"
+0
+46
+WVList
+0
+-1
+1
+1
+0
+47
+MItem
+33
+..\..\contrib\libtests\pngvalid.c
+48
+WString
+4
+COBJ
+49
+WVList
+0
+50
+WVList
+0
+35
+1
+1
+0
diff --git a/Engine/lib/lpng/projects/visualc71/PRJ0041.mak b/Engine/lib/lpng/projects/visualc71/PRJ0041.mak
new file mode 100644
index 000000000..c7a68b503
--- /dev/null
+++ b/Engine/lib/lpng/projects/visualc71/PRJ0041.mak
@@ -0,0 +1,21 @@
+# Prevent "Cannot find missing dependency..." warnings while compiling
+# pngwin.rc (PRJ0041).
+
+all: $(IntDir)\alloc.h \
+	 $(IntDir)\fp.h \
+	 $(IntDir)\m68881.h \
+	 $(IntDir)\mem.h \
+	 $(IntDir)\pngusr.h \
+	 $(IntDir)\strings.h \
+	 $(IntDir)\unistd.h \
+	 $(IntDir)\unixio.h
+
+$(IntDir)\alloc.h \
+$(IntDir)\fp.h \
+$(IntDir)\m68881.h \
+$(IntDir)\mem.h \
+$(IntDir)\pngusr.h \
+$(IntDir)\strings.h \
+$(IntDir)\unistd.h \
+$(IntDir)\unixio.h:
+	@!echo.>$@
diff --git a/Engine/lib/lpng/projects/visualc71/README.txt b/Engine/lib/lpng/projects/visualc71/README.txt
new file mode 100644
index 000000000..4e1c8fa1c
--- /dev/null
+++ b/Engine/lib/lpng/projects/visualc71/README.txt
@@ -0,0 +1,58 @@
+Microsoft Developer Studio Project File, Format Version 7.10 for libpng.
+
+Copyright (C) 2004 Simon-Pierre Cadieux.
+
+This code is released under the libpng license.
+For conditions of distribution and use, see copyright notice in png.h
+
+NOTE: This project will be removed from libpng-1.5.0.  It has
+been replaced with the "vstudio" project.
+
+Assumptions:
+* The libpng source files are in ..\..
+* The zlib source files are in ..\..\..\zlib
+* The zlib project file is in . /* Warning: This is until the zlib project
+  files get integrated into the next zlib release. The final zlib project
+  directory will then be ..\..\..\zlib\projects\visualc71. */
+
+To use:
+
+1) On the main menu, select "File | Open Solution".
+   Open "libpng.sln".
+
+2) Display the Solution Explorer view (Ctrl+Alt+L)
+
+3) Set one of the project as the StartUp project. If you just want to build the
+   binaries set "libpng" as the startup project (Select "libpng" tree view
+   item + Project | Set as StartUp project). If you want to build and test the
+   binaries set it to "pngtest" (Select "pngtest" tree view item +
+   Project | Set as StartUp project)
+
+4) Select "Build | Configuration Manager...".
+   Choose the configuration you wish to build.
+
+5) Select "Build | Clean Solution".
+
+6) Select "Build | Build Solution (Ctrl-Shift-B)"
+
+This project builds the libpng binaries as follows:
+
+* Win32_DLL_Release\libpng16.dll      DLL build
+* Win32_DLL_Debug\libpng16d.dll       DLL build (debug version)
+* Win32_DLL_VB\libpng16vb.dll         DLL build for Visual Basic, using stdcall
+* Win32_LIB_Release\libpng.lib        static build
+* Win32_LIB_Debug\libpngd.lib         static build (debug version)
+
+Notes:
+
+If you change anything in the source files, or select different compiler
+settings, please change the DLL name to something different than any of
+the above names. Also, make sure that in your "pngusr.h" you define
+PNG_USER_PRIVATEBUILD and PNG_USER_DLLFNAME_POSTFIX according to the
+instructions provided in "pngconf.h".
+
+All DLLs built by this project use the Microsoft dynamic C runtime library
+MSVCR71.DLL (MSVCR71D.DLL for debug versions).  If you distribute any of the
+above mentioned libraries you may have to include this DLL in your package.
+For a list of files that are redistributable in Visual Studio see
+$(VCINSTALLDIR)\redist.txt.
diff --git a/Engine/lib/lpng/projects/visualc71/README_zlib.txt b/Engine/lib/lpng/projects/visualc71/README_zlib.txt
new file mode 100644
index 000000000..81d11cbb5
--- /dev/null
+++ b/Engine/lib/lpng/projects/visualc71/README_zlib.txt
@@ -0,0 +1,44 @@
+/* WARNING: This file was put in the LibPNG distribution for convenience only.
+            It is expected to be part of the next zlib release under
+            "projects\visualc71\README.txt." */
+
+Microsoft Developer Studio Project File, Format Version 7.10 for zlib.
+
+Copyright (C) 2004 Simon-Pierre Cadieux.
+Copyright (C) 2004 Cosmin Truta.
+
+This code is released under the libpng license.
+For conditions of distribution and use, see copyright notice in zlib.h.
+
+NOTE: This project will be removed from libpng-1.5.0.  It has
+been replaced with the "vstudio" project.
+
+To use:
+
+1) On the main menu, select "File | Open Solution".
+   Open "zlib.sln".
+
+2) Display the Solution Explorer view (Ctrl+Alt+L)
+
+3) Set one of the project as the StartUp project. If you just want to build the
+   binaries set "zlib" as the startup project (Select "zlib" tree view item +
+   Project | Set as StartUp project). If you want to build and test the
+   binaries set it to "example" (Select "example" tree view item + Project |
+   Set as StartUp project), If you want to build the minigzip utility set it to
+   "minigzip" (Select "minigzip" tree view item + Project | Set as StartUp
+   project
+
+4) Select "Build | Configuration Manager...".
+   Choose the configuration you wish to build.
+
+5) Select "Build | Clean Solution".
+
+6) Select "Build | Build Solution (Ctrl-Shift-B)"
+
+This project builds the zlib binaries as follows:
+
+* Win32_DLL_Release\zlib1.dll       DLL build
+* Win32_DLL_Debug\zlib1d.dll        DLL build (debug version)
+* Win32_LIB_Release\zlib.lib        static build
+* Win32_LIB_Debug\zlibd.lib         static build (debug version)
+
diff --git a/Engine/lib/lpng/projects/vstudio/README.txt b/Engine/lib/lpng/projects/vstudio/README.txt
new file mode 100644
index 000000000..e28ec9549
--- /dev/null
+++ b/Engine/lib/lpng/projects/vstudio/README.txt
@@ -0,0 +1,87 @@
+Instructions for building libpng using Microsoft Visual Studio
+==============================================================
+
+Copyright (c) 2018 Cosmin Truta
+Copyright (c) 2010,2013,2015 Glenn Randers-Pehrson
+
+This code is released under the libpng license.
+For conditions of distribution and use, see the disclaimer and license
+in png.h
+
+This directory contains a solution for building libpng under Microsoft
+Visual Studio 2010.  It may also work under later versions of Visual
+Studio.  You should be familiar with Visual Studio before using this
+solution.
+
+Initial preparations
+--------------------
+You must enter some information in zlib.props before attempting to
+build with this 'solution'.  Please read and edit zlib.props first.
+You will probably not be familiar with the contents of zlib.props -
+do not worry, it is mostly harmless.
+
+This is all you need to do to build the 'release' and 'release library'
+configurations.
+
+Debugging
+---------
+The release configurations default to /Ox optimization.  Full debugging
+information is produced (in the .pdb), but if you encounter a problem
+the optimization may make it difficult to debug.  Simply rebuild with a
+lower optimization level (e.g. /Od.)
+
+Linking your application
+------------------------
+Normally you should link against the 'release' configuration.  This
+builds a DLL for libpng with the default runtime options used by Visual
+Studio.  In particular the runtime library is the "MultiThreaded DLL"
+version.  If you use Visual Studio defaults to build your application,
+you should have no problems.
+
+If you don't use the Visual Studio defaults your application must still
+be built with the default runtime option (/MD).  If, for some reason,
+it is not then your application will crash inside libpng16.dll as soon
+as libpng tries to read from a file handle you pass in.
+
+If you do not want to use the DLL, and prefer static linking instead,
+you may choose the 'release library' configuration.  This is built with
+a non-standard runtime library - the "MultiThreaded" version.  When you
+build your application, it must be compiled with this option (/MT),
+otherwise it will not build (if you are lucky) or it will crash (if you
+are not.) See the WARNING file that is distributed with this README.
+
+Stop reading here
+-----------------
+You have enough information to build a working application.
+
+Debug versions have limited support
+-----------------------------------
+This solution includes limited support for debug versions of libpng.
+You do not need these unless your own solution itself uses debug builds
+(it is far more effective to debug on the release builds, there is no
+point building a special debug build unless you have heap corruption
+problems that you can't track down.)
+
+The debug build of libpng is minimally supported.  Support for debug
+builds of zlib is also minimal.  Please keep this in mind, if you want
+to use it.
+
+WARNING
+-------
+Libpng 1.6.x does not use the default run-time library when building
+static library builds of libpng; instead of the shared DLL runtime, it
+uses a static runtime.  If you need to change this, make sure to change
+the setting on all the relevant projects:
+
+    libpng
+    zlib
+    all the test programs
+
+The runtime library settings for each build are as follows:
+
+               Release        Debug
+    DLL         /MD            /MDd
+    Library     /MT            /MTd
+
+Also, be sure to build libpng, zlib, and your project, all for the same
+platform (e.g., 32-bit or 64-bit).
diff --git a/Engine/lib/lpng/projects/vstudio/zlib.props b/Engine/lib/lpng/projects/vstudio/zlib.props
new file mode 100644
index 000000000..878627966
--- /dev/null
+++ b/Engine/lib/lpng/projects/vstudio/zlib.props
@@ -0,0 +1,57 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ * zlib.props - location of zlib source
+ *
+ * Copyright (c) 2018 Cosmin Truta
+ * Copyright (c) 1998-2011 Glenn Randers-Pehrson
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+
+ * You may need to edit this file in order to update the location
+ * of the zlib source code.
+ -->
+
+<Project ToolsVersion="4.0"
+   xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Label="Globals">
+    <!-- Place the name of the directory containing the source of zlib used for
+	 debugging in this property.
+
+         The directory need only contain the '.c' and '.h' files from the
+	 source.
+
+	 If you use a relative directory name (as below) then it must be
+	 relative to the project directories; these are one level deeper than
+	 the directories containing this file.
+
+	 If the version of zlib you use does not match that used when the
+	 distribution was built you will get warnings from pngtest that the zlib
+	 versions do not match.  The zlib version used in this build is recorded
+	 below:
+     -->
+    <ZLibSrcDir>..\..\..\..\zlib</ZLibSrcDir>
+
+    <!-- The following line allows compilation for an ARM target with Visual
+         Studio 2012.  Notice that this is not supported by the Visual Studio
+         2012 IDE and that the programs that result cannot be run unless they
+         signed by Microsoft.  This is therefore untested; only Microsoft can
+         test it:
+     -->
+    <WindowsSDKDesktopARMSupport>true</WindowsSDKDesktopARMSupport>
+
+    <!-- The following lines provide a global (solution level) control of the
+         warnings issued by the compiler, these are used in the individual
+         project files (*/*.vcxproj) with, for zlib, some extra disables.
+
+         Different versions of Visual Studio may require different settings,
+         these settings work with Visual Studio 2013.  Just set
+         TreatWarningAsError to false to check the build without failing on
+         errors.
+     -->
+   <WarningLevel>EnableAllWarnings</WarningLevel>
+   <TreatWarningAsError>true</TreatWarningAsError>
+   <DisableSpecificWarnings>4255;4668;4710;4711;4746;4820;4996</DisableSpecificWarnings>
+  </PropertyGroup>
+</Project>
diff --git a/Engine/lib/lpng/scripts/README.txt b/Engine/lib/lpng/scripts/README.txt
new file mode 100644
index 000000000..3d911ef2f
--- /dev/null
+++ b/Engine/lib/lpng/scripts/README.txt
@@ -0,0 +1,79 @@
+
+Makefiles for libpng
+
+pnglibconf.h.prebuilt  =>  Configuration settings
+ makefile.linux    =>  Linux/ELF makefile
+                       (gcc, creates shared libpng16.so.16.1.6.*)
+ makefile.linux-opt=>  Linux/ELF makefile with hardware optimizations on
+                       (gcc, creates shared libpng16.so.16.1.6.*)
+ makefile.gcc      =>  Generic makefile (gcc, creates static libpng.a)
+ makefile.acorn    =>  Acorn makefile
+ makefile.aix      =>  AIX/gcc makefile
+ makefile.amiga    =>  Amiga makefile
+ makefile.atari    =>  Atari makefile
+ makefile.bc32     =>  32-bit Borland C++ (all modules compiled in C mode)
+ makefile.beos     =>  BeOS makefile
+ makefile.cegcc    =>  minge32ce for Windows CE makefile
+ makefile.darwin   =>  Darwin makefile, for macOS (formerly Mac OS X)
+ makefile.dec      =>  DEC Alpha UNIX makefile
+ makefile.dj2      =>  DJGPP 2 makefile
+ makefile.freebsd  =>  FreeBSD makefile
+ makefile.gcc      =>  Generic gcc makefile
+ makefile.hpgcc    =>  HPUX makefile using gcc
+ makefile.hpux     =>  HPUX (10.20 and 11.00) makefile
+ makefile.hp64     =>  HPUX (10.20 and 11.00) makefile, 64-bit
+ makefile.ibmc     =>  IBM C/C++ version 3.x for Win32 and OS/2 (static)
+ makefile.intel    =>  Intel C/C++ version 4.0 and later
+ makefile.mips     =>  MIPS makefile
+ makefile.netbsd   =>  NetBSD/cc makefile, makes shared libpng.so
+ makefile.openbsd  =>  OpenBSD makefile
+ makefile.sco      =>  SCO OSr5 ELF and Unixware 7 with Native cc
+ makefile.sggcc    =>  Silicon Graphics makefile
+                       (gcc, creates shared libpng16.so.16.1.6.*)
+ makefile.sgi      =>  Silicon Graphics IRIX makefile (cc, creates static lib)
+ makefile.solaris  =>  Solaris 2.X makefile
+                       (gcc, creates shared libpng16.so.16.1.6.*)
+ makefile.so9      =>  Solaris 9 makefile
+                       (gcc, creates shared libpng16.so.16.1.6.*)
+ makefile.std      =>  Generic UNIX makefile (cc, creates static libpng.a)
+ makefile.sunos    =>  Sun makefile
+ makefile.32sunu   =>  Sun Ultra 32-bit makefile
+ makefile.64sunu   =>  Sun Ultra 64-bit makefile
+ makefile.vcwin32  =>  makefile for Microsoft Visual C++ 4.0 and later
+ makevms.com       =>  VMS build script
+ smakefile.ppc     =>  AMIGA smakefile for SAS C V6.58/7.00 PPC compiler
+                       (Requires SCOPTIONS, copied from scripts/SCOPTIONS.ppc)
+
+Other supporting scripts:
+ README.txt        =>  This file
+ descrip.mms       =>  VMS makefile for MMS or MMK
+ libpng-config-body.in => used by several makefiles to create libpng-config
+ libpng-config-head.in => used by several makefiles to create libpng-config
+ libpng.pc.in      =>  Used by several makefiles to create libpng.pc
+ pngwin.rc         =>  Used by the visualc71 project
+ pngwin.def        =>  Used by makefile.os2
+ pngwin.dfn        =>  Used to maintain pngwin.def
+ SCOPTIONS.ppc     =>  Used with smakefile.ppc
+
+ checksym.awk      =>  Used for maintaining pnglibconf.h
+ def.dfn           =>  Used for maintaining pnglibconf.h
+ options.awk       =>  Used for maintaining pnglibconf.h
+ pnglibconf.dfa    =>  Used for maintaining pnglibconf.h
+ pnglibconf.mak    =>  Used for maintaining pnglibconf.h
+ sym.dfn           =>  Used for symbol versioning
+ symbols.def       =>  Used for symbol versioning
+ symbols.dfn       =>  Used for symbol versioning
+ vers.dfn          =>  Used for symbol versioning
+
+ libtool.m4        =>  Used by autoconf tools
+ ltoptions.m4      =>  Used by autoconf tools
+ ltsugar.m4        =>  Used by autoconf tools
+ ltversion.m4      =>  Used by autoconf tools
+ lt~obsolete.m4    =>  Used by autoconf tools
+
+ intprefix.dfn     =>  Used by autoconf tools
+ macro.lst         =>  Used by autoconf tools
+ prefix.dfn        =>  Used by autoconf tools
+
+
+Further information can be found in comments in the individual makefiles.
diff --git a/Engine/lib/lpng/scripts/SCOPTIONS.ppc b/Engine/lib/lpng/scripts/SCOPTIONS.ppc
new file mode 100644
index 000000000..2c3503e9e
--- /dev/null
+++ b/Engine/lib/lpng/scripts/SCOPTIONS.ppc
@@ -0,0 +1,7 @@
+OPTIMIZE
+OPTPEEP
+OPTTIME
+OPTSCHED
+AUTOREGISTER
+PARMS=REGISTERS
+INCLUDEDIR=hlp:ppc/include
diff --git a/Engine/lib/lpng/scripts/checksym.awk b/Engine/lib/lpng/scripts/checksym.awk
new file mode 100755
index 000000000..fe3af55e0
--- /dev/null
+++ b/Engine/lib/lpng/scripts/checksym.awk
@@ -0,0 +1,173 @@
+#!/bin/awk -f
+# Check a list of symbols against the master definition
+# (official) list.  Arguments:
+#
+# awk -f checksym.awk official-def list-to-check
+#
+# Output is a file in the current directory called 'symbols.new',
+# the value of the awk variable "of" (which can be changed on the
+# command line if required.)  stdout holds error messages.  Error
+# code indicates success or failure.
+#
+# NOTE: this is a pure, old fashioned, awk script.  It will
+# work with any awk
+
+BEGIN{
+   err=0
+   master=""        # master file
+   official[1] = "" # defined symbols from master file
+   symbol[1] = ""   # defined symbols from png.h
+   removed[1] = ""  # removed symbols from png.h
+   lasto = 0        # last ordinal value from png.h
+   mastero = 0      # highest ordinal in master file
+   symbolo = 0      # highest ordinal in png.h
+   missing = "error"# log an error on missing symbols
+   of="symbols.new" # default to a fixed name
+}
+
+# Read existing definitions from the master file (the first
+# file on the command line.)  This must be a def file and it
+# has definition lines (others are ignored) of the form:
+#
+#   symbol @ordinal
+#
+master == "" {
+   master = FILENAME
+}
+FILENAME==master && NF==2 && $2~/^@/ && $1!~/^;/ {
+   o=0+substr($2,2)
+   if (o > 0) {
+      if (official[o] == "") {
+         official[o] = $1
+         if (o > mastero) mastero = o
+         next
+      } else
+         print master ": duplicated symbol:", official[o] ":", $0
+   } else
+      print master ": bad export line format:", $0
+   err = 1
+}
+FILENAME==master && $1==";missing" && NF==2{
+   # This allows the master file to control how missing symbols
+   # are handled; symbols that aren't in either the master or
+   # the new file.  Valid values are 'ignore', 'warning' and
+   # 'error'
+   missing = $2
+}
+FILENAME==master {
+   next
+}
+
+# Read new definitions, these are free form but the lines must
+# just be symbol definitions.  Lines will be commented out for
+# 'removed' symbols, introduced in png.h using PNG_REMOVED rather
+# than PNG_EXPORT.  Use symbols.dfn or pngwin.dfn to generate the
+# input file.
+#
+#  symbol @ordinal   # two fields, exported symbol
+#  ; symbol @ordinal # three fields, removed symbol
+#  ; @ordinal        # two fields, the last ordinal
+NF==2 && $1 == ";" && $2 ~ /^@[1-9][0-9]*$/ { # last ordinal
+   o=0+substr($2,2)
+   if (lasto == 0 || lasto == o)
+      lasto=o
+   else {
+      print "png.h: duplicated last ordinal:", lasto, o
+      err = 1
+   }
+   next
+}
+NF==3 && $1 == ";" && $3 ~ /^@[1-9][0-9]*$/ { # removed symbol
+   o=0+substr($3,2)
+   if (removed[o] == "" || removed[o] == $2) {
+      removed[o] = $2
+      if (o > symbolo) symbolo = o
+   } else {
+      print "png.h: duplicated removed symbol", o ": '" removed[o] "' != '" $2 "'"
+      err = 1
+   }
+   next
+}
+NF==2 && $2 ~ /^@[1-9][0-9]*$/ { # exported symbol
+   o=0+substr($2,2)
+   if (symbol[o] == "" || symbol[o] == $1) {
+      symbol[o] = $1
+      if (o > symbolo) symbolo = o
+   } else {
+      print "png.h: duplicated symbol", o ": '" symbol[o] "' != '" $1 "'"
+      err = 1
+   }
+}
+{
+   next # skip all other lines
+}
+
+# At the end check for symbols marked as both duplicated and removed
+END{
+   if (symbolo > lasto) {
+      print "highest symbol ordinal in png.h,", symbolo ", exceeds last ordinal from png.h", lasto
+      err = 1
+   }
+   if (mastero > lasto) {
+      print "highest symbol ordinal in", master ",", mastero ", exceeds last ordinal from png.h", lasto
+      err = 1
+   }
+   unexported=0
+   # Add a standard header to symbols.new:
+   print ";Version INSERT-VERSION-HERE" >of
+   print ";--------------------------------------------------------------" >of
+   print "; LIBPNG symbol list as a Win32 DEF file" >of
+   print "; Contains all the symbols that can be exported from libpng" >of
+   print ";--------------------------------------------------------------" >of
+   print "LIBRARY" >of
+   print "" >of
+   print "EXPORTS" >of
+
+   for (o=1; o<=lasto; ++o) {
+      if (symbol[o] == "" && removed[o] == "") {
+         if (unexported == 0) unexported = o
+         if (official[o] == "") {
+            # missing in export list too, so ok
+            if (o < lasto) continue
+         }
+      }
+      if (unexported != 0) {
+         # Symbols in the .def but not in the new file are errors, but
+         # the 'unexported' symbols aren't in either.  By default this
+         # is an error too (see the setting of 'missing' at the start),
+         # but this can be reset on the command line or by stuff in the
+         # file - see the comments above.
+         if (missing != "ignore") {
+            if (o-1 > unexported)
+               print "png.h:", missing ": missing symbols:", unexported "-" o-1
+            else
+               print "png.h:", missing ": missing symbol:", unexported
+            if (missing != "warning")
+               err = 1
+         }
+         unexported = 0
+      }
+      if (symbol[o] != "" && removed[o] != "") {
+         print "png.h: symbol", o, "both exported as '" symbol[o] "' and removed as '" removed[o] "'"
+         err = 1
+      } else if (symbol[o] != official[o]) {
+         # either the symbol is missing somewhere or it changed
+         err = 1
+         if (symbol[o] == "")
+            print "png.h: symbol", o, "is exported as '" official[o] "' in", master
+         else if (official[o] == "")
+            print "png.h: exported symbol", o, "'" symbol[o] "' not present in", master
+         else
+            print "png.h: exported symbol", o, "'" symbol[o] "' exists as '" official[o] "' in", master
+      }
+
+      # Finally generate symbols.new
+      if (symbol[o] != "")
+         print " " symbol[o], "@" o > of
+   }
+
+   if (err != 0) {
+      print "*** A new list is in", of, "***"
+      exit 1
+   }
+}
diff --git a/Engine/lib/lpng/scripts/descrip.mms b/Engine/lib/lpng/scripts/descrip.mms
new file mode 100644
index 000000000..a3aefbf4c
--- /dev/null
+++ b/Engine/lib/lpng/scripts/descrip.mms
@@ -0,0 +1,52 @@
+
+cc_defs = /inc=$(ZLIBSRC)
+c_deb =
+
+.ifdef __DECC__
+pref = /prefix=all
+.endif
+
+
+
+OBJS = png.obj, pngset.obj, pngget.obj, pngrutil.obj, pngtrans.obj,\
+	pngwutil.obj, pngread.obj, pngmem.obj, pngwrite.obj, pngrtran.obj,\
+	pngwtran.obj, pngrio.obj, pngwio.obj, pngerror.obj, pngpread.obj
+
+
+CFLAGS= $(C_DEB) $(CC_DEFS) $(PREF)
+
+all : pngtest.exe libpng.olb
+	@ write sys$output " pngtest available"
+
+libpng.olb : libpng.olb($(OBJS))
+	@ write sys$output " libpng available"
+
+
+pngtest.exe : pngtest.obj libpng.olb
+              link pngtest,libpng.olb/lib,$(ZLIBSRC)libz.olb/lib
+
+test : pngtest.exe
+   run pngtest
+
+clean :
+	delete *.obj;*,*.exe;
+
+
+# Other dependencies.
+png.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
+pngpread.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
+pngset.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
+pngget.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
+pngread.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
+pngrtran.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
+pngrutil.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
+pngerror.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
+pngmem.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
+pngrio.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
+pngwio.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
+pngtrans.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
+pngwrite.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
+pngwtran.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
+pngwutil.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
+
+pngtest.obj : png.h, pngconf.h, pnglibconf.h
diff --git a/Engine/lib/lpng/scripts/dfn.awk b/Engine/lib/lpng/scripts/dfn.awk
new file mode 100755
index 000000000..346b9db7d
--- /dev/null
+++ b/Engine/lib/lpng/scripts/dfn.awk
@@ -0,0 +1,203 @@
+#!/bin/awk -f
+# scripts/dfn.awk - process a .dfn file
+#
+# last changed in libpng version 1.5.19 - August 21, 2014
+#
+# Copyright (c) 2013-2014 Glenn Randers-Pehrson
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# The output of this script is written to the file given by
+# the variable 'out', which should be set on the command line.
+# Error messages are printed to stdout and if any are printed
+# the script will exit with error code 1.
+
+BEGIN{
+   out="/dev/null"       # as a flag
+   out_count=0           # count of output lines
+   err=0                 # set if an error occurred
+   sort=0                # sort the output
+   array[""]=""
+}
+
+# The output file must be specified before any input:
+NR==1 && out == "/dev/null" {
+   print "out=output.file must be given on the command line"
+   # but continue without setting the error code; this allows the
+   # script to be checked easily
+}
+
+# Output can be sorted; two lines are recognized
+$1 == "PNG_DFN_START_SORT"{
+   sort=0+$2
+   next
+}
+
+$1 ~ /^PNG_DFN_END_SORT/{
+   # Do a very simple, slow, sort; notice that blank lines won't be
+   # output by this
+   for (entry in array) {
+      while (array[entry] != "") {
+         key = entry
+         value = array[key]
+         array[key] = ""
+
+         for (alt in array) {
+            if (array[alt] != "" && alt < key) {
+               array[key] = value
+               value = array[alt]
+               key = alt
+               array[alt] = ""
+            }
+         }
+
+         print value >out
+      }
+   }
+   sort=0
+   next
+}
+
+/^[^"]*PNG_DFN *".*"[^"]*$/{
+   # A definition line, apparently correctly formatted; extract the
+   # definition then replace any doubled "" that remain with a single
+   # double quote.  Notice that the original doubled double quotes
+   # may have been split by tokenization
+   #
+   # Sometimes GCC splits the PNG_DFN lines; we know this has happened
+   # if the quotes aren't closed and must read another line.  In this
+   # case it is essential to reject lines that start with '#' because those
+   # are introduced #line directives.
+   orig=$0
+   line=$0
+   lineno=FNR
+   if (lineno == "") lineno=NR
+
+   if (sub(/^[^"]*PNG_DFN *"/,"",line) != 1) {
+	print "line", lineno ": processing failed:"
+	print orig
+	err=1
+       next
+   } else {
+	++out_count
+   }
+
+   # Now examine quotes within the value:
+   #
+   #   @" - delete this and any following spaces
+   #   "@ - delete this and any preceding spaces
+   #   @' - replace this by a double quote
+   #
+   # This allows macro substitution by the C compiler thus:
+   #
+   #   #define first_name John
+   #   #define last_name Smith
+   #
+   #	PNG_DFN"#define name @'@" first_name "@ @" last_name "@@'"
+   #
+   # Might get C preprocessed to:
+   #
+   #   PNG_DFN "#define foo @'@" John "@ @" Smith "@@'"
+   #
+   # Which this script reduces to:
+   #
+   #	#define name "John Smith"
+   #
+   while (1) {
+      # While there is an @" remove it and the next "@
+      if (line ~ /@"/) {
+         if (line ~ /@".*"@/) {
+            # Do this special case first to avoid swallowing extra spaces
+            # before or after the @ stuff:
+            if (!sub(/@" *"@/, "", line)) {
+               # Ok, do it in pieces - there has to be a non-space between the
+               # two.  NOTE: really weird things happen if a leading @" is
+               # lost - the code will error out below (I believe).
+               if (!sub(/@" */, "", line) || !sub(/ *"@/, "", line)) {
+                  print "line", lineno, ": internal error:", orig
+                  exit 1
+               }
+            }
+         }
+
+         # There is no matching "@.  Assume a split line
+         else while (1) {
+            if (getline nextline) {
+               # If the line starts with '#' it is a preprocesor line directive
+               # from cc -E; skip it:
+               if (nextline !~ /^#/) {
+                  line = line " " nextline
+                  break
+               }
+            } else {
+               # This is end-of-input - probably a missing "@ on the first line:
+               print "line", lineno ": unbalanced @\" ... \"@ pair"
+               err=1
+               next
+            }
+         }
+
+         # Keep going until all the @" have gone
+         continue
+      }
+
+      # Attempt to remove a trailing " (not preceded by '@') - if this can
+      # be done, stop now; if not assume a split line again
+      if (sub(/"[^"]*$/, "", line))
+         break
+
+      # Read another line
+      while (1) {
+         if (getline nextline) {
+            if (nextline !~ /^#/) {
+               line = line " " nextline
+               # Go back to stripping @" "@ pairs
+               break
+            }
+         } else {
+            print "line", lineno ": unterminated PNG_DFN string"
+            err=1
+            next
+         }
+      }
+   }
+
+   # Put any needed double quotes in (at the end, because these would otherwise
+   # interfere with the processing above.)
+   gsub(/@'/,"\"", line)
+
+   # Remove any trailing spaces (not really required, but for
+   # editorial consistency
+   sub(/ *$/, "", line)
+
+   # Remove trailing CR
+   sub(/
$/, "", line)
+
+   if (sort) {
+      if (split(line, parts) < sort) {
+         print "line", lineno ": missing sort field:", line
+         err=1
+      } else
+         array[parts[sort]] = line
+   }
+
+   else
+      print line >out
+   next
+}
+
+/PNG_DFN/{
+   print "line", NR, "incorrectly formatted PNG_DFN line:"
+   print $0
+   err = 1
+}
+
+END{
+   if (out_count > 0 || err > 0)
+	exit err
+
+   print "no definition lines found"
+   exit 1
+}
diff --git a/Engine/lib/lpng/scripts/genchk.cmake.in b/Engine/lib/lpng/scripts/genchk.cmake.in
new file mode 100644
index 000000000..ab3b9d746
--- /dev/null
+++ b/Engine/lib/lpng/scripts/genchk.cmake.in
@@ -0,0 +1,37 @@
+# genchk.cmake.in
+# Generate .chk from .out with awk (generic), based upon the automake logic.
+
+# Copyright (C) 2016 Glenn Randers-Pehrson
+# Written by Roger Leigh, 2016
+
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# Variables substituted from CMakeLists.txt
+set(SRCDIR "@CMAKE_CURRENT_SOURCE_DIR@")
+
+set(AWK "@AWK@")
+
+get_filename_component(INPUTEXT "${INPUT}" EXT)
+get_filename_component(OUTPUTEXT "${OUTPUT}" EXT)
+get_filename_component(INPUTBASE "${INPUT}" NAME_WE)
+get_filename_component(OUTPUTBASE "${OUTPUT}" NAME_WE)
+get_filename_component(INPUTDIR "${INPUT}" PATH)
+get_filename_component(OUTPUTDIR "${OUTPUT}" PATH)
+
+if("${INPUTEXT}" STREQUAL ".out" AND "${OUTPUTEXT}" STREQUAL ".chk")
+  # Generate .chk from .out with awk (generic)
+  file(REMOVE "${OUTPUT}" "${OUTPUTDIR}/${OUTPUTBASE}.new")
+  execute_process(COMMAND "${AWK}" -f "${SRCDIR}/scripts/checksym.awk"
+                          "${SRCDIR}/scripts/${INPUTBASE}.def"
+                          "of=${OUTPUTDIR}/${OUTPUTBASE}.new"
+                          "${INPUT}"
+                  RESULT_VARIABLE AWK_FAIL)
+  if(AWK_FAIL)
+    message(FATAL_ERROR "Failed to generate ${OUTPUTDIR}/${OUTPUTBASE}.new")
+  endif()
+  file(RENAME "${OUTPUTDIR}/${OUTPUTBASE}.new" "${OUTPUT}")
+else()
+  message(FATAL_ERROR "Unsupported conversion: ${INPUTEXT} to ${OUTPUTEXT}")
+endif()
diff --git a/Engine/lib/lpng/scripts/genout.cmake.in b/Engine/lib/lpng/scripts/genout.cmake.in
new file mode 100644
index 000000000..01f12de2f
--- /dev/null
+++ b/Engine/lib/lpng/scripts/genout.cmake.in
@@ -0,0 +1,93 @@
+# genout.cmake.in
+# Generate .out from .c with awk (generic), based upon the automake logic.
+
+# Copyright (C) 2016 Glenn Randers-Pehrson
+# Written by Roger Leigh, 2016
+
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# Variables substituted from CMakeLists.txt
+set(SRCDIR "@CMAKE_CURRENT_SOURCE_DIR@")
+set(BINDIR "@CMAKE_CURRENT_BINARY_DIR@")
+
+set(AWK "@AWK@")
+set(CMAKE_C_COMPILER "@CMAKE_C_COMPILER@")
+set(CMAKE_C_FLAGS @CMAKE_C_FLAGS@)
+set(INCDIR "@CMAKE_CURRENT_BINARY_DIR@")
+set(PNG_PREFIX "@PNG_PREFIX@")
+set(PNGLIB_MAJOR "@PNGLIB_MAJOR@")
+set(PNGLIB_MINOR "@PNGLIB_MINOR@")
+set(PNGLIB_VERSION "@PNGLIB_VERSION@")
+set(ZLIBINCDIR "@ZLIB_INCLUDE_DIR@")
+
+set(PLATFORM_C_FLAGS)
+if(APPLE)
+  set(CMAKE_OSX_ARCHITECTURES "@CMAKE_OSX_ARCHITECTURES@")
+  set(CMAKE_OSX_SYSROOT "@CMAKE_OSX_SYSROOT@")
+  if(CMAKE_OSX_ARCHITECTURES)
+    set(PLATFORM_C_FLAGS ${PLATFORM_C_FLAGS} -arch ${CMAKE_OSX_ARCHITECTURES})
+  endif()
+  if(CMAKE_OSX_SYSROOT)
+    set(PLATFORM_C_FLAGS ${PLATFORM_C_FLAGS} -isysroot ${CMAKE_OSX_SYSROOT})
+  endif()
+endif()
+
+get_filename_component(INPUTEXT "${INPUT}" EXT)
+get_filename_component(OUTPUTEXT "${OUTPUT}" EXT)
+get_filename_component(INPUTBASE "${INPUT}" NAME_WE)
+get_filename_component(OUTPUTBASE "${OUTPUT}" NAME_WE)
+get_filename_component(INPUTDIR "${INPUT}" PATH)
+get_filename_component(OUTPUTDIR "${OUTPUT}" PATH)
+
+if ("${INPUTEXT}" STREQUAL ".c" AND "${OUTPUTEXT}" STREQUAL ".out")
+  get_filename_component(GENDIR "${OUTPUT}" PATH)
+  file(MAKE_DIRECTORY "${GENDIR}")
+
+  file(REMOVE "${OUTPUT}.tf1" "${OUTPUT}.tf2")
+
+  set(INCLUDES "-I${INCDIR}")
+  if(ZLIBINCDIR)
+    foreach(dir ${ZLIBINCDIR})
+      list(APPEND INCLUDES "-I${dir}")
+    endforeach()
+  endif()
+
+  if(PNG_PREFIX)
+    set(PNG_PREFIX_DEF "-DPNG_PREFIX=${PNG_PREFIX}")
+  endif()
+
+  execute_process(COMMAND "${CMAKE_C_COMPILER}" "-E"
+                          ${CMAKE_C_FLAGS}
+                          ${PLATFORM_C_FLAGS}
+                          "-I${SRCDIR}"
+                          "-I${BINDIR}"
+                          ${INCLUDES}
+                          "-DPNGLIB_LIBNAME=PNG${PNGLIB_MAJOR}${PNGLIB_MINOR}_0"
+                          "-DPNGLIB_VERSION=${PNGLIB_VERSION}"
+                          "-DSYMBOL_PREFIX=${SYMBOL_PREFIX}"
+                          "-DPNG_NO_USE_READ_MACROS"
+                          "-DPNG_BUILDING_SYMBOL_TABLE"
+                          ${PNG_PREFIX_DEF}
+                          "${INPUT}"
+                  OUTPUT_FILE "${OUTPUT}.tf1"
+                  WORKING_DIRECTORY "${BINDIR}"
+                  RESULT_VARIABLE CPP_FAIL)
+  if(CPP_FAIL)
+    message(FATAL_ERROR "Failed to generate ${OUTPUT}.tf1")
+  endif()
+
+  execute_process(COMMAND "${AWK}" -f "${SRCDIR}/scripts/dfn.awk"
+                          "out=${OUTPUT}.tf2" "${OUTPUT}.tf1"
+                  WORKING_DIRECTORY "${BINDIR}"
+                  RESULT_VARIABLE AWK_FAIL)
+  if(AWK_FAIL)
+    message(FATAL_ERROR "Failed to generate ${OUTPUT}.tf2")
+  endif()
+
+  file(REMOVE "${OUTPUT}.tf1")
+  file(RENAME "${OUTPUT}.tf2" "${OUTPUT}")
+else()
+  message(FATAL_ERROR "Unsupported conversion: ${INPUTEXT} to ${OUTPUTEXT}")
+endif()
diff --git a/Engine/lib/lpng/scripts/gensrc.cmake.in b/Engine/lib/lpng/scripts/gensrc.cmake.in
new file mode 100644
index 000000000..f28a62266
--- /dev/null
+++ b/Engine/lib/lpng/scripts/gensrc.cmake.in
@@ -0,0 +1,138 @@
+# gensrc.cmake.in
+# Generate source files with awk, based upon the automake logic.
+
+# Copyright (C) 2016 Glenn Randers-Pehrson
+# Written by Roger Leigh, 2016
+
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# Variables substituted from CMakeLists.txt
+set(SRCDIR "@CMAKE_CURRENT_SOURCE_DIR@")
+set(BINDIR "@CMAKE_CURRENT_BINARY_DIR@")
+
+set(AWK "@AWK@")
+set(DFA_XTRA "@DFA_XTRA@")
+set(PNG_PREFIX "@PNG_PREFIX@")
+set(PNGLIB_VERSION "@PNGLIB_VERSION@")
+
+if("${OUTPUT}" STREQUAL "scripts/pnglibconf.c")
+  # Generate scripts/pnglibconf.c
+
+  file(REMOVE "${BINDIR}/pnglibconf.tf6" "${BINDIR}/pnglibconf.tf7")
+
+  execute_process(COMMAND "${CMAKE_COMMAND}" -E echo "com ${PNGLIB_VERSION} STANDARD API DEFINITION"
+                  COMMAND "${AWK}" -f "${SRCDIR}/scripts/options.awk"
+                          "out=pnglibconf.tf6" "logunsupported=1" "version=search"
+                          "${SRCDIR}/pngconf.h" "-"
+                          "${SRCDIR}/scripts/pnglibconf.dfa"
+                  WORKING_DIRECTORY "${BINDIR}"
+                  RESULT_VARIABLE AWK_FAIL)
+  if(AWK_FAIL)
+    message(FATAL_ERROR "Failed to generate pnglibconf.tf6")
+  endif()
+
+  execute_process(COMMAND "${AWK}" -f "${SRCDIR}/scripts/options.awk"
+                  "out=pnglibconf.tf7" "pnglibconf.tf6"
+                  WORKING_DIRECTORY "${BINDIR}"
+                  RESULT_VARIABLE AWK_FAIL)
+  if(AWK_FAIL)
+    message(FATAL_ERROR "Failed to generate pnglibconf.tf7")
+  endif()
+
+  file(REMOVE "pnglibconf.tf6")
+  file(MAKE_DIRECTORY "${BINDIR}/scripts")
+  file(RENAME "pnglibconf.tf7" "${BINDIR}/scripts/pnglibconf.c")
+
+elseif ("${OUTPUT}" STREQUAL "pnglibconf.c")
+  # Generate pnglibconf.c
+
+  file(REMOVE "${BINDIR}/pnglibconf.tf4" "${BINDIR}/pnglibconf.tf5")
+
+  execute_process(COMMAND "${AWK}" -f "${SRCDIR}/scripts/options.awk"
+                  out=pnglibconf.tf4 version=search
+                  ${SRCDIR}/pngconf.h ${SRCDIR}/scripts/pnglibconf.dfa
+                  ${SRCDIR}/pngusr.dfa ${DFA_XTRA}
+                  WORKING_DIRECTORY "${BINDIR}"
+                  RESULT_VARIABLE AWK_FAIL)
+  if(AWK_FAIL)
+    message(FATAL_ERROR "Failed to generate pnglibconf.tf4")
+  endif()
+
+  execute_process(COMMAND "${AWK}" -f "${SRCDIR}/scripts/options.awk"
+                  out=pnglibconf.tf5 pnglibconf.tf4
+                  WORKING_DIRECTORY "${BINDIR}"
+                  RESULT_VARIABLE AWK_FAIL)
+  if(AWK_FAIL)
+    message(FATAL_ERROR "Failed to generate pnglibconf.tf5")
+  endif()
+
+  file(REMOVE "pnglibconf.tf4")
+  file(MAKE_DIRECTORY "${BINDIR}/scripts")
+  file(RENAME "pnglibconf.tf5" "${BINDIR}/pnglibconf.c")
+
+elseif ("${OUTPUT}" STREQUAL "pnglibconf.h")
+  # Generate pnglibconf.h
+
+  file(REMOVE "${BINDIR}/${OUTPUT}")
+  if(PNG_PREFIX)
+    file(REMOVE "pnglibconf.tf8")
+
+    execute_process(COMMAND "${AWK}" "s==0 && NR>1{print prev}
+                             s==0{prev=\$0}
+                             s==1{print \"#define\", \$1, \"${PNG_PREFIX}\" \$1}
+                             s==2{print \"#define ${PNG_PREFIX}png_\" \$1, \"PNG_\" \$1}
+                             END{print prev}" s=0 pnglibconf.out s=1 "${BINDIR}/scripts/prefix.out"
+                             s=2 "${SRCDIR}/scripts/macro.lst"
+                    OUTPUT_FILE pnglibconf.tf8
+                    RESULT_VARIABLE AWK_FAIL)
+    if(AWK_FAIL)
+      message(FATAL_ERROR "Failed to generate pnglibconf.tf8")
+    endif()
+
+    file(RENAME "pnglibconf.tf8" "${BINDIR}/${OUTPUT}")
+  else()
+    execute_process(COMMAND "${CMAKE_COMMAND}" -E copy "${BINDIR}/pnglibconf.out"
+                                                       "${BINDIR}/${OUTPUT}"
+                    RESULT_VARIABLE COPY_FAIL)
+    if(COPY_FAIL)
+      message(FATAL_ERROR "Failed to create pnglibconf.h")
+    endif()
+  endif()
+
+elseif ("${OUTPUT}" STREQUAL "pngprefix.h")
+  # Generate pngprefix.h
+
+  file(REMOVE "${BINDIR}/${OUTPUT}")
+
+  if(PNG_PREFIX)
+    file(REMOVE "pngprefix.tf1")
+
+    execute_process(COMMAND "${AWK}"
+                            "{print \"#define\", \$1, \"${PNG_PREFIX}\" \$1}"
+                            "${BINDIR}/scripts/intprefix.out"
+                    OUTPUT_FILE "pngprefix.tf1"
+                    RESULT_VARIABLE AWK_FAIL)
+    if(AWK_FAIL)
+      message(FATAL_ERROR "Failed to generate pngprefix.tf1")
+    endif()
+
+    file(RENAME "pngprefix.tf1" "${BINDIR}/${OUTPUT}")
+  else()
+    file(WRITE "${BINDIR}/${OUTPUT}" "/* No libpng symbol prefix configured. */")
+  endif()
+
+elseif("${OUTPUT}" STREQUAL "scripts/pnglibconf.h.prebuilt")
+  # Generate scripts/pnglibconf.h.prebuilt (fails build)
+
+  message(STATUS "Attempting to build scripts/pnglibconf.h.prebuilt")
+  message(STATUS "This is a machine generated file, but if you want to make")
+  message(STATUS "a new one simply build the 'genfiles' target, and copy")
+  message(STATUS "scripts/pnglibconf.out to scripts/pnglibconf.h.prebuilt")
+  message(STATUS "AND set PNG_ZLIB_VERNUM to 0 (you MUST do this)")
+  message(FATAL_ERROR "Stopping build")
+
+else()
+  message(FATAL_ERROR "Unsupported output: ${OUTPUT}")
+endif()
diff --git a/Engine/lib/lpng/scripts/intprefix.c b/Engine/lib/lpng/scripts/intprefix.c
new file mode 100644
index 000000000..254f8e94b
--- /dev/null
+++ b/Engine/lib/lpng/scripts/intprefix.c
@@ -0,0 +1,22 @@
+
+/* intprefix.c - generate an unprefixed internal symbol list
+ *
+ * Last changed in libpng version 1.6.16 [December 22, 2014]
+ * Copyright (c) 2013-2014 Glenn Randers-Pehrson
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+#define PNG_INTERNAL_DATA(type, name, array)\
+        PNG_DFN "@" name "@"
+
+#define PNG_INTERNAL_FUNCTION(type, name, args, attributes)\
+        PNG_DFN "@" name "@"
+
+#define PNG_INTERNAL_CALLBACK(type, name, args, attributes)\
+        PNG_DFN "@" name "@"
+
+#define PNGPREFIX_H /* self generation */
+#include "../pngpriv.h"
diff --git a/Engine/lib/lpng/scripts/libpng-config-body.in b/Engine/lib/lpng/scripts/libpng-config-body.in
new file mode 100644
index 000000000..b466432d5
--- /dev/null
+++ b/Engine/lib/lpng/scripts/libpng-config-body.in
@@ -0,0 +1,96 @@
+
+usage()
+{
+    cat <<EOF
+Usage: libpng-config [OPTION] ...
+
+Known values for OPTION are:
+
+  --prefix        print libpng prefix
+  --libdir        print path to directory containing library
+  --libs          print library linking information
+  --ccopts        print compiler options
+  --cppflags      print pre-processor flags
+  --cflags        print preprocessor flags, I_opts, and compiler options
+  --I_opts        print "-I" include options
+  --L_opts        print linker "-L" flags for dynamic linking
+  --R_opts        print dynamic linker "-R" or "-rpath" flags
+  --ldopts        print linker options
+  --ldflags       print linker flags (ldopts, L_opts, R_opts, and libs)
+  --static        revise subsequent outputs for static linking
+  --help          print this help and exit
+  --version       print version information
+EOF
+
+    exit $1
+}
+
+if test $# -eq 0; then
+    usage 1
+fi
+
+while test $# -gt 0; do
+    case "$1" in
+
+    --prefix)
+        echo ${prefix}
+        ;;
+
+    --version)
+        echo ${version}
+        exit 0
+        ;;
+
+    --help)
+        usage 0
+        ;;
+
+    --ccopts)
+        echo ${ccopts}
+        ;;
+
+    --cppflags)
+        echo ${cppflags}
+        ;;
+
+    --cflags)
+        echo ${I_opts} ${cppflags} ${ccopts}
+        ;;
+
+    --libdir)
+        echo ${libdir}
+        ;;
+
+    --libs)
+        echo ${libs}
+        ;;
+
+    --I_opts)
+        echo ${I_opts}
+        ;;
+
+    --L_opts)
+        echo ${L_opts}
+        ;;
+
+    --R_opts)
+        echo ${R_opts}
+        ;;
+
+    --ldflags)
+        echo ${ldflags} ${L_opts} ${R_opts} ${libs}
+        ;;
+
+    --static)
+        R_opts=""
+        ;;
+
+    *)
+        usage
+        exit 1
+        ;;
+    esac
+    shift
+done
+
+exit 0
diff --git a/Engine/lib/lpng/scripts/libpng-config-head.in b/Engine/lib/lpng/scripts/libpng-config-head.in
new file mode 100644
index 000000000..2a5afb46a
--- /dev/null
+++ b/Engine/lib/lpng/scripts/libpng-config-head.in
@@ -0,0 +1,24 @@
+#! /bin/sh
+
+# libpng-config
+# provides configuration info for libpng.
+
+# Copyright (C) 2002 Glenn Randers-Pehrson
+
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# Modeled after libxml-config.
+
+version=1.6.37
+prefix=""
+libdir=""
+libs=""
+I_opts=""
+L_opts=""
+R_opts=""
+cppflags=""
+ccopts=""
+ldopts=""
+
diff --git a/Engine/lib/lpng/scripts/libpng.pc.in b/Engine/lib/lpng/scripts/libpng.pc.in
new file mode 100644
index 000000000..416fefe86
--- /dev/null
+++ b/Engine/lib/lpng/scripts/libpng.pc.in
@@ -0,0 +1,10 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@/libpng16
+
+Name: libpng
+Description: Loads and saves PNG files
+Version: 1.6.37
+Libs: -L${libdir} -lpng16
+Cflags: -I${includedir}
diff --git a/Engine/lib/lpng/scripts/libtool.m4 b/Engine/lib/lpng/scripts/libtool.m4
new file mode 100644
index 000000000..a3bc337b7
--- /dev/null
+++ b/Engine/lib/lpng/scripts/libtool.m4
@@ -0,0 +1,8369 @@
+# libtool.m4 - Configure libtool for the host system. -*-Autoconf-*-
+#
+#   Copyright (C) 1996-2001, 2003-2015 Free Software Foundation, Inc.
+#   Written by Gordon Matzigkeit, 1996
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+m4_define([_LT_COPYING], [dnl
+# Copyright (C) 2014 Free Software Foundation, Inc.
+# This is free software; see the source for copying conditions.  There is NO
+# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+# GNU Libtool is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of of the License, or
+# (at your option) any later version.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program or library that is built
+# using GNU Libtool, you may include this file under the  same
+# distribution terms that you use for the rest of that program.
+#
+# GNU Libtool is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+])
+
+# serial 58 LT_INIT
+
+
+# LT_PREREQ(VERSION)
+# ------------------
+# Complain and exit if this libtool version is less that VERSION.
+m4_defun([LT_PREREQ],
+[m4_if(m4_version_compare(m4_defn([LT_PACKAGE_VERSION]), [$1]), -1,
+       [m4_default([$3],
+		   [m4_fatal([Libtool version $1 or higher is required],
+		             63)])],
+       [$2])])
+
+
+# _LT_CHECK_BUILDDIR
+# ------------------
+# Complain if the absolute build directory name contains unusual characters
+m4_defun([_LT_CHECK_BUILDDIR],
+[case `pwd` in
+  *\ * | *\	*)
+    AC_MSG_WARN([Libtool does not cope well with whitespace in `pwd`]) ;;
+esac
+])
+
+
+# LT_INIT([OPTIONS])
+# ------------------
+AC_DEFUN([LT_INIT],
+[AC_PREREQ([2.62])dnl We use AC_PATH_PROGS_FEATURE_CHECK
+AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
+AC_BEFORE([$0], [LT_LANG])dnl
+AC_BEFORE([$0], [LT_OUTPUT])dnl
+AC_BEFORE([$0], [LTDL_INIT])dnl
+m4_require([_LT_CHECK_BUILDDIR])dnl
+
+dnl Autoconf doesn't catch unexpanded LT_ macros by default:
+m4_pattern_forbid([^_?LT_[A-Z_]+$])dnl
+m4_pattern_allow([^(_LT_EOF|LT_DLGLOBAL|LT_DLLAZY_OR_NOW|LT_MULTI_MODULE)$])dnl
+dnl aclocal doesn't pull ltoptions.m4, ltsugar.m4, or ltversion.m4
+dnl unless we require an AC_DEFUNed macro:
+AC_REQUIRE([LTOPTIONS_VERSION])dnl
+AC_REQUIRE([LTSUGAR_VERSION])dnl
+AC_REQUIRE([LTVERSION_VERSION])dnl
+AC_REQUIRE([LTOBSOLETE_VERSION])dnl
+m4_require([_LT_PROG_LTMAIN])dnl
+
+_LT_SHELL_INIT([SHELL=${CONFIG_SHELL-/bin/sh}])
+
+dnl Parse OPTIONS
+_LT_SET_OPTIONS([$0], [$1])
+
+# This can be used to rebuild libtool when needed
+LIBTOOL_DEPS=$ltmain
+
+# Always use our own libtool.
+LIBTOOL='$(SHELL) $(top_builddir)/libtool'
+AC_SUBST(LIBTOOL)dnl
+
+_LT_SETUP
+
+# Only expand once:
+m4_define([LT_INIT])
+])# LT_INIT
+
+# Old names:
+AU_ALIAS([AC_PROG_LIBTOOL], [LT_INIT])
+AU_ALIAS([AM_PROG_LIBTOOL], [LT_INIT])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_PROG_LIBTOOL], [])
+dnl AC_DEFUN([AM_PROG_LIBTOOL], [])
+
+
+# _LT_PREPARE_CC_BASENAME
+# -----------------------
+m4_defun([_LT_PREPARE_CC_BASENAME], [
+# Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
+func_cc_basename ()
+{
+    for cc_temp in @S|@*""; do
+      case $cc_temp in
+        compile | *[[\\/]]compile | ccache | *[[\\/]]ccache ) ;;
+        distcc | *[[\\/]]distcc | purify | *[[\\/]]purify ) ;;
+        \-*) ;;
+        *) break;;
+      esac
+    done
+    func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
+}
+])# _LT_PREPARE_CC_BASENAME
+
+
+# _LT_CC_BASENAME(CC)
+# -------------------
+# It would be clearer to call AC_REQUIREs from _LT_PREPARE_CC_BASENAME,
+# but that macro is also expanded into generated libtool script, which
+# arranges for $SED and $ECHO to be set by different means.
+m4_defun([_LT_CC_BASENAME],
+[m4_require([_LT_PREPARE_CC_BASENAME])dnl
+AC_REQUIRE([_LT_DECL_SED])dnl
+AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH])dnl
+func_cc_basename $1
+cc_basename=$func_cc_basename_result
+])
+
+
+# _LT_FILEUTILS_DEFAULTS
+# ----------------------
+# It is okay to use these file commands and assume they have been set
+# sensibly after 'm4_require([_LT_FILEUTILS_DEFAULTS])'.
+m4_defun([_LT_FILEUTILS_DEFAULTS],
+[: ${CP="cp -f"}
+: ${MV="mv -f"}
+: ${RM="rm -f"}
+])# _LT_FILEUTILS_DEFAULTS
+
+
+# _LT_SETUP
+# ---------
+m4_defun([_LT_SETUP],
+[AC_REQUIRE([AC_CANONICAL_HOST])dnl
+AC_REQUIRE([AC_CANONICAL_BUILD])dnl
+AC_REQUIRE([_LT_PREPARE_SED_QUOTE_VARS])dnl
+AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH])dnl
+
+_LT_DECL([], [PATH_SEPARATOR], [1], [The PATH separator for the build system])dnl
+dnl
+_LT_DECL([], [host_alias], [0], [The host system])dnl
+_LT_DECL([], [host], [0])dnl
+_LT_DECL([], [host_os], [0])dnl
+dnl
+_LT_DECL([], [build_alias], [0], [The build system])dnl
+_LT_DECL([], [build], [0])dnl
+_LT_DECL([], [build_os], [0])dnl
+dnl
+AC_REQUIRE([AC_PROG_CC])dnl
+AC_REQUIRE([LT_PATH_LD])dnl
+AC_REQUIRE([LT_PATH_NM])dnl
+dnl
+AC_REQUIRE([AC_PROG_LN_S])dnl
+test -z "$LN_S" && LN_S="ln -s"
+_LT_DECL([], [LN_S], [1], [Whether we need soft or hard links])dnl
+dnl
+AC_REQUIRE([LT_CMD_MAX_LEN])dnl
+_LT_DECL([objext], [ac_objext], [0], [Object file suffix (normally "o")])dnl
+_LT_DECL([], [exeext], [0], [Executable file suffix (normally "")])dnl
+dnl
+m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+m4_require([_LT_CHECK_SHELL_FEATURES])dnl
+m4_require([_LT_PATH_CONVERSION_FUNCTIONS])dnl
+m4_require([_LT_CMD_RELOAD])dnl
+m4_require([_LT_CHECK_MAGIC_METHOD])dnl
+m4_require([_LT_CHECK_SHAREDLIB_FROM_LINKLIB])dnl
+m4_require([_LT_CMD_OLD_ARCHIVE])dnl
+m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl
+m4_require([_LT_WITH_SYSROOT])dnl
+m4_require([_LT_CMD_TRUNCATE])dnl
+
+_LT_CONFIG_LIBTOOL_INIT([
+# See if we are running on zsh, and set the options that allow our
+# commands through without removal of \ escapes INIT.
+if test -n "\${ZSH_VERSION+set}"; then
+   setopt NO_GLOB_SUBST
+fi
+])
+if test -n "${ZSH_VERSION+set}"; then
+   setopt NO_GLOB_SUBST
+fi
+
+_LT_CHECK_OBJDIR
+
+m4_require([_LT_TAG_COMPILER])dnl
+
+case $host_os in
+aix3*)
+  # AIX sometimes has problems with the GCC collect2 program.  For some
+  # reason, if we set the COLLECT_NAMES environment variable, the problems
+  # vanish in a puff of smoke.
+  if test set != "${COLLECT_NAMES+set}"; then
+    COLLECT_NAMES=
+    export COLLECT_NAMES
+  fi
+  ;;
+esac
+
+# Global variables:
+ofile=libtool
+can_build_shared=yes
+
+# All known linkers require a '.a' archive for static linking (except MSVC,
+# which needs '.lib').
+libext=a
+
+with_gnu_ld=$lt_cv_prog_gnu_ld
+
+old_CC=$CC
+old_CFLAGS=$CFLAGS
+
+# Set sane defaults for various variables
+test -z "$CC" && CC=cc
+test -z "$LTCC" && LTCC=$CC
+test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS
+test -z "$LD" && LD=ld
+test -z "$ac_objext" && ac_objext=o
+
+_LT_CC_BASENAME([$compiler])
+
+# Only perform the check for file, if the check method requires it
+test -z "$MAGIC_CMD" && MAGIC_CMD=file
+case $deplibs_check_method in
+file_magic*)
+  if test "$file_magic_cmd" = '$MAGIC_CMD'; then
+    _LT_PATH_MAGIC
+  fi
+  ;;
+esac
+
+# Use C for the default configuration in the libtool script
+LT_SUPPORTED_TAG([CC])
+_LT_LANG_C_CONFIG
+_LT_LANG_DEFAULT_CONFIG
+_LT_CONFIG_COMMANDS
+])# _LT_SETUP
+
+
+# _LT_PREPARE_SED_QUOTE_VARS
+# --------------------------
+# Define a few sed substitution that help us do robust quoting.
+m4_defun([_LT_PREPARE_SED_QUOTE_VARS],
+[# Backslashify metacharacters that are still active within
+# double-quoted strings.
+sed_quote_subst='s/\([["`$\\]]\)/\\\1/g'
+
+# Same as above, but do not quote variable references.
+double_quote_subst='s/\([["`\\]]\)/\\\1/g'
+
+# Sed substitution to delay expansion of an escaped shell variable in a
+# double_quote_subst'ed string.
+delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'
+
+# Sed substitution to delay expansion of an escaped single quote.
+delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g'
+
+# Sed substitution to avoid accidental globbing in evaled expressions
+no_glob_subst='s/\*/\\\*/g'
+])
+
+# _LT_PROG_LTMAIN
+# ---------------
+# Note that this code is called both from 'configure', and 'config.status'
+# now that we use AC_CONFIG_COMMANDS to generate libtool.  Notably,
+# 'config.status' has no value for ac_aux_dir unless we are using Automake,
+# so we pass a copy along to make sure it has a sensible value anyway.
+m4_defun([_LT_PROG_LTMAIN],
+[m4_ifdef([AC_REQUIRE_AUX_FILE], [AC_REQUIRE_AUX_FILE([ltmain.sh])])dnl
+_LT_CONFIG_LIBTOOL_INIT([ac_aux_dir='$ac_aux_dir'])
+ltmain=$ac_aux_dir/ltmain.sh
+])# _LT_PROG_LTMAIN
+
+
+## ------------------------------------- ##
+## Accumulate code for creating libtool. ##
+## ------------------------------------- ##
+
+# So that we can recreate a full libtool script including additional
+# tags, we accumulate the chunks of code to send to AC_CONFIG_COMMANDS
+# in macros and then make a single call at the end using the 'libtool'
+# label.
+
+
+# _LT_CONFIG_LIBTOOL_INIT([INIT-COMMANDS])
+# ----------------------------------------
+# Register INIT-COMMANDS to be passed to AC_CONFIG_COMMANDS later.
+m4_define([_LT_CONFIG_LIBTOOL_INIT],
+[m4_ifval([$1],
+          [m4_append([_LT_OUTPUT_LIBTOOL_INIT],
+                     [$1
+])])])
+
+# Initialize.
+m4_define([_LT_OUTPUT_LIBTOOL_INIT])
+
+
+# _LT_CONFIG_LIBTOOL([COMMANDS])
+# ------------------------------
+# Register COMMANDS to be passed to AC_CONFIG_COMMANDS later.
+m4_define([_LT_CONFIG_LIBTOOL],
+[m4_ifval([$1],
+          [m4_append([_LT_OUTPUT_LIBTOOL_COMMANDS],
+                     [$1
+])])])
+
+# Initialize.
+m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS])
+
+
+# _LT_CONFIG_SAVE_COMMANDS([COMMANDS], [INIT_COMMANDS])
+# -----------------------------------------------------
+m4_defun([_LT_CONFIG_SAVE_COMMANDS],
+[_LT_CONFIG_LIBTOOL([$1])
+_LT_CONFIG_LIBTOOL_INIT([$2])
+])
+
+
+# _LT_FORMAT_COMMENT([COMMENT])
+# -----------------------------
+# Add leading comment marks to the start of each line, and a trailing
+# full-stop to the whole comment if one is not present already.
+m4_define([_LT_FORMAT_COMMENT],
+[m4_ifval([$1], [
+m4_bpatsubst([m4_bpatsubst([$1], [^ *], [# ])],
+              [['`$\]], [\\\&])]m4_bmatch([$1], [[!?.]$], [], [.])
+)])
+
+
+
+## ------------------------ ##
+## FIXME: Eliminate VARNAME ##
+## ------------------------ ##
+
+
+# _LT_DECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION], [IS-TAGGED?])
+# -------------------------------------------------------------------
+# CONFIGNAME is the name given to the value in the libtool script.
+# VARNAME is the (base) name used in the configure script.
+# VALUE may be 0, 1 or 2 for a computed quote escaped value based on
+# VARNAME.  Any other value will be used directly.
+m4_define([_LT_DECL],
+[lt_if_append_uniq([lt_decl_varnames], [$2], [, ],
+    [lt_dict_add_subkey([lt_decl_dict], [$2], [libtool_name],
+	[m4_ifval([$1], [$1], [$2])])
+    lt_dict_add_subkey([lt_decl_dict], [$2], [value], [$3])
+    m4_ifval([$4],
+	[lt_dict_add_subkey([lt_decl_dict], [$2], [description], [$4])])
+    lt_dict_add_subkey([lt_decl_dict], [$2],
+	[tagged?], [m4_ifval([$5], [yes], [no])])])
+])
+
+
+# _LT_TAGDECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION])
+# --------------------------------------------------------
+m4_define([_LT_TAGDECL], [_LT_DECL([$1], [$2], [$3], [$4], [yes])])
+
+
+# lt_decl_tag_varnames([SEPARATOR], [VARNAME1...])
+# ------------------------------------------------
+m4_define([lt_decl_tag_varnames],
+[_lt_decl_filter([tagged?], [yes], $@)])
+
+
+# _lt_decl_filter(SUBKEY, VALUE, [SEPARATOR], [VARNAME1..])
+# ---------------------------------------------------------
+m4_define([_lt_decl_filter],
+[m4_case([$#],
+  [0], [m4_fatal([$0: too few arguments: $#])],
+  [1], [m4_fatal([$0: too few arguments: $#: $1])],
+  [2], [lt_dict_filter([lt_decl_dict], [$1], [$2], [], lt_decl_varnames)],
+  [3], [lt_dict_filter([lt_decl_dict], [$1], [$2], [$3], lt_decl_varnames)],
+  [lt_dict_filter([lt_decl_dict], $@)])[]dnl
+])
+
+
+# lt_decl_quote_varnames([SEPARATOR], [VARNAME1...])
+# --------------------------------------------------
+m4_define([lt_decl_quote_varnames],
+[_lt_decl_filter([value], [1], $@)])
+
+
+# lt_decl_dquote_varnames([SEPARATOR], [VARNAME1...])
+# ---------------------------------------------------
+m4_define([lt_decl_dquote_varnames],
+[_lt_decl_filter([value], [2], $@)])
+
+
+# lt_decl_varnames_tagged([SEPARATOR], [VARNAME1...])
+# ---------------------------------------------------
+m4_define([lt_decl_varnames_tagged],
+[m4_assert([$# <= 2])dnl
+_$0(m4_quote(m4_default([$1], [[, ]])),
+    m4_ifval([$2], [[$2]], [m4_dquote(lt_decl_tag_varnames)]),
+    m4_split(m4_normalize(m4_quote(_LT_TAGS)), [ ]))])
+m4_define([_lt_decl_varnames_tagged],
+[m4_ifval([$3], [lt_combine([$1], [$2], [_], $3)])])
+
+
+# lt_decl_all_varnames([SEPARATOR], [VARNAME1...])
+# ------------------------------------------------
+m4_define([lt_decl_all_varnames],
+[_$0(m4_quote(m4_default([$1], [[, ]])),
+     m4_if([$2], [],
+	   m4_quote(lt_decl_varnames),
+	m4_quote(m4_shift($@))))[]dnl
+])
+m4_define([_lt_decl_all_varnames],
+[lt_join($@, lt_decl_varnames_tagged([$1],
+			lt_decl_tag_varnames([[, ]], m4_shift($@))))dnl
+])
+
+
+# _LT_CONFIG_STATUS_DECLARE([VARNAME])
+# ------------------------------------
+# Quote a variable value, and forward it to 'config.status' so that its
+# declaration there will have the same value as in 'configure'.  VARNAME
+# must have a single quote delimited value for this to work.
+m4_define([_LT_CONFIG_STATUS_DECLARE],
+[$1='`$ECHO "$][$1" | $SED "$delay_single_quote_subst"`'])
+
+
+# _LT_CONFIG_STATUS_DECLARATIONS
+# ------------------------------
+# We delimit libtool config variables with single quotes, so when
+# we write them to config.status, we have to be sure to quote all
+# embedded single quotes properly.  In configure, this macro expands
+# each variable declared with _LT_DECL (and _LT_TAGDECL) into:
+#
+#    <var>='`$ECHO "$<var>" | $SED "$delay_single_quote_subst"`'
+m4_defun([_LT_CONFIG_STATUS_DECLARATIONS],
+[m4_foreach([_lt_var], m4_quote(lt_decl_all_varnames),
+    [m4_n([_LT_CONFIG_STATUS_DECLARE(_lt_var)])])])
+
+
+# _LT_LIBTOOL_TAGS
+# ----------------
+# Output comment and list of tags supported by the script
+m4_defun([_LT_LIBTOOL_TAGS],
+[_LT_FORMAT_COMMENT([The names of the tagged configurations supported by this script])dnl
+available_tags='_LT_TAGS'dnl
+])
+
+
+# _LT_LIBTOOL_DECLARE(VARNAME, [TAG])
+# -----------------------------------
+# Extract the dictionary values for VARNAME (optionally with TAG) and
+# expand to a commented shell variable setting:
+#
+#    # Some comment about what VAR is for.
+#    visible_name=$lt_internal_name
+m4_define([_LT_LIBTOOL_DECLARE],
+[_LT_FORMAT_COMMENT(m4_quote(lt_dict_fetch([lt_decl_dict], [$1],
+					   [description])))[]dnl
+m4_pushdef([_libtool_name],
+    m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [libtool_name])))[]dnl
+m4_case(m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [value])),
+    [0], [_libtool_name=[$]$1],
+    [1], [_libtool_name=$lt_[]$1],
+    [2], [_libtool_name=$lt_[]$1],
+    [_libtool_name=lt_dict_fetch([lt_decl_dict], [$1], [value])])[]dnl
+m4_ifval([$2], [_$2])[]m4_popdef([_libtool_name])[]dnl
+])
+
+
+# _LT_LIBTOOL_CONFIG_VARS
+# -----------------------
+# Produce commented declarations of non-tagged libtool config variables
+# suitable for insertion in the LIBTOOL CONFIG section of the 'libtool'
+# script.  Tagged libtool config variables (even for the LIBTOOL CONFIG
+# section) are produced by _LT_LIBTOOL_TAG_VARS.
+m4_defun([_LT_LIBTOOL_CONFIG_VARS],
+[m4_foreach([_lt_var],
+    m4_quote(_lt_decl_filter([tagged?], [no], [], lt_decl_varnames)),
+    [m4_n([_LT_LIBTOOL_DECLARE(_lt_var)])])])
+
+
+# _LT_LIBTOOL_TAG_VARS(TAG)
+# -------------------------
+m4_define([_LT_LIBTOOL_TAG_VARS],
+[m4_foreach([_lt_var], m4_quote(lt_decl_tag_varnames),
+    [m4_n([_LT_LIBTOOL_DECLARE(_lt_var, [$1])])])])
+
+
+# _LT_TAGVAR(VARNAME, [TAGNAME])
+# ------------------------------
+m4_define([_LT_TAGVAR], [m4_ifval([$2], [$1_$2], [$1])])
+
+
+# _LT_CONFIG_COMMANDS
+# -------------------
+# Send accumulated output to $CONFIG_STATUS.  Thanks to the lists of
+# variables for single and double quote escaping we saved from calls
+# to _LT_DECL, we can put quote escaped variables declarations
+# into 'config.status', and then the shell code to quote escape them in
+# for loops in 'config.status'.  Finally, any additional code accumulated
+# from calls to _LT_CONFIG_LIBTOOL_INIT is expanded.
+m4_defun([_LT_CONFIG_COMMANDS],
+[AC_PROVIDE_IFELSE([LT_OUTPUT],
+	dnl If the libtool generation code has been placed in $CONFIG_LT,
+	dnl instead of duplicating it all over again into config.status,
+	dnl then we will have config.status run $CONFIG_LT later, so it
+	dnl needs to know what name is stored there:
+        [AC_CONFIG_COMMANDS([libtool],
+            [$SHELL $CONFIG_LT || AS_EXIT(1)], [CONFIG_LT='$CONFIG_LT'])],
+    dnl If the libtool generation code is destined for config.status,
+    dnl expand the accumulated commands and init code now:
+    [AC_CONFIG_COMMANDS([libtool],
+        [_LT_OUTPUT_LIBTOOL_COMMANDS], [_LT_OUTPUT_LIBTOOL_COMMANDS_INIT])])
+])#_LT_CONFIG_COMMANDS
+
+
+# Initialize.
+m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS_INIT],
+[
+
+# The HP-UX ksh and POSIX shell print the target directory to stdout
+# if CDPATH is set.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+sed_quote_subst='$sed_quote_subst'
+double_quote_subst='$double_quote_subst'
+delay_variable_subst='$delay_variable_subst'
+_LT_CONFIG_STATUS_DECLARATIONS
+LTCC='$LTCC'
+LTCFLAGS='$LTCFLAGS'
+compiler='$compiler_DEFAULT'
+
+# A function that is used when there is no print builtin or printf.
+func_fallback_echo ()
+{
+  eval 'cat <<_LTECHO_EOF
+\$[]1
+_LTECHO_EOF'
+}
+
+# Quote evaled strings.
+for var in lt_decl_all_varnames([[ \
+]], lt_decl_quote_varnames); do
+    case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
+    *[[\\\\\\\`\\"\\\$]]*)
+      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes
+      ;;
+    *)
+      eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
+      ;;
+    esac
+done
+
+# Double-quote double-evaled strings.
+for var in lt_decl_all_varnames([[ \
+]], lt_decl_dquote_varnames); do
+    case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
+    *[[\\\\\\\`\\"\\\$]]*)
+      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes
+      ;;
+    *)
+      eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
+      ;;
+    esac
+done
+
+_LT_OUTPUT_LIBTOOL_INIT
+])
+
+# _LT_GENERATED_FILE_INIT(FILE, [COMMENT])
+# ------------------------------------
+# Generate a child script FILE with all initialization necessary to
+# reuse the environment learned by the parent script, and make the
+# file executable.  If COMMENT is supplied, it is inserted after the
+# '#!' sequence but before initialization text begins.  After this
+# macro, additional text can be appended to FILE to form the body of
+# the child script.  The macro ends with non-zero status if the
+# file could not be fully written (such as if the disk is full).
+m4_ifdef([AS_INIT_GENERATED],
+[m4_defun([_LT_GENERATED_FILE_INIT],[AS_INIT_GENERATED($@)])],
+[m4_defun([_LT_GENERATED_FILE_INIT],
+[m4_require([AS_PREPARE])]dnl
+[m4_pushdef([AS_MESSAGE_LOG_FD])]dnl
+[lt_write_fail=0
+cat >$1 <<_ASEOF || lt_write_fail=1
+#! $SHELL
+# Generated by $as_me.
+$2
+SHELL=\${CONFIG_SHELL-$SHELL}
+export SHELL
+_ASEOF
+cat >>$1 <<\_ASEOF || lt_write_fail=1
+AS_SHELL_SANITIZE
+_AS_PREPARE
+exec AS_MESSAGE_FD>&1
+_ASEOF
+test 0 = "$lt_write_fail" && chmod +x $1[]dnl
+m4_popdef([AS_MESSAGE_LOG_FD])])])# _LT_GENERATED_FILE_INIT
+
+# LT_OUTPUT
+# ---------
+# This macro allows early generation of the libtool script (before
+# AC_OUTPUT is called), incase it is used in configure for compilation
+# tests.
+AC_DEFUN([LT_OUTPUT],
+[: ${CONFIG_LT=./config.lt}
+AC_MSG_NOTICE([creating $CONFIG_LT])
+_LT_GENERATED_FILE_INIT(["$CONFIG_LT"],
+[# Run this file to recreate a libtool stub with the current configuration.])
+
+cat >>"$CONFIG_LT" <<\_LTEOF
+lt_cl_silent=false
+exec AS_MESSAGE_LOG_FD>>config.log
+{
+  echo
+  AS_BOX([Running $as_me.])
+} >&AS_MESSAGE_LOG_FD
+
+lt_cl_help="\
+'$as_me' creates a local libtool stub from the current configuration,
+for use in further configure time tests before the real libtool is
+generated.
+
+Usage: $[0] [[OPTIONS]]
+
+  -h, --help      print this help, then exit
+  -V, --version   print version number, then exit
+  -q, --quiet     do not print progress messages
+  -d, --debug     don't remove temporary files
+
+Report bugs to <bug-libtool@gnu.org>."
+
+lt_cl_version="\
+m4_ifset([AC_PACKAGE_NAME], [AC_PACKAGE_NAME ])config.lt[]dnl
+m4_ifset([AC_PACKAGE_VERSION], [ AC_PACKAGE_VERSION])
+configured by $[0], generated by m4_PACKAGE_STRING.
+
+Copyright (C) 2011 Free Software Foundation, Inc.
+This config.lt script is free software; the Free Software Foundation
+gives unlimited permision to copy, distribute and modify it."
+
+while test 0 != $[#]
+do
+  case $[1] in
+    --version | --v* | -V )
+      echo "$lt_cl_version"; exit 0 ;;
+    --help | --h* | -h )
+      echo "$lt_cl_help"; exit 0 ;;
+    --debug | --d* | -d )
+      debug=: ;;
+    --quiet | --q* | --silent | --s* | -q )
+      lt_cl_silent=: ;;
+
+    -*) AC_MSG_ERROR([unrecognized option: $[1]
+Try '$[0] --help' for more information.]) ;;
+
+    *) AC_MSG_ERROR([unrecognized argument: $[1]
+Try '$[0] --help' for more information.]) ;;
+  esac
+  shift
+done
+
+if $lt_cl_silent; then
+  exec AS_MESSAGE_FD>/dev/null
+fi
+_LTEOF
+
+cat >>"$CONFIG_LT" <<_LTEOF
+_LT_OUTPUT_LIBTOOL_COMMANDS_INIT
+_LTEOF
+
+cat >>"$CONFIG_LT" <<\_LTEOF
+AC_MSG_NOTICE([creating $ofile])
+_LT_OUTPUT_LIBTOOL_COMMANDS
+AS_EXIT(0)
+_LTEOF
+chmod +x "$CONFIG_LT"
+
+# configure is writing to config.log, but config.lt does its own redirection,
+# appending to config.log, which fails on DOS, as config.log is still kept
+# open by configure.  Here we exec the FD to /dev/null, effectively closing
+# config.log, so it can be properly (re)opened and appended to by config.lt.
+lt_cl_success=:
+test yes = "$silent" &&
+  lt_config_lt_args="$lt_config_lt_args --quiet"
+exec AS_MESSAGE_LOG_FD>/dev/null
+$SHELL "$CONFIG_LT" $lt_config_lt_args || lt_cl_success=false
+exec AS_MESSAGE_LOG_FD>>config.log
+$lt_cl_success || AS_EXIT(1)
+])# LT_OUTPUT
+
+
+# _LT_CONFIG(TAG)
+# ---------------
+# If TAG is the built-in tag, create an initial libtool script with a
+# default configuration from the untagged config vars.  Otherwise add code
+# to config.status for appending the configuration named by TAG from the
+# matching tagged config vars.
+m4_defun([_LT_CONFIG],
+[m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+_LT_CONFIG_SAVE_COMMANDS([
+  m4_define([_LT_TAG], m4_if([$1], [], [C], [$1]))dnl
+  m4_if(_LT_TAG, [C], [
+    # See if we are running on zsh, and set the options that allow our
+    # commands through without removal of \ escapes.
+    if test -n "${ZSH_VERSION+set}"; then
+      setopt NO_GLOB_SUBST
+    fi
+
+    cfgfile=${ofile}T
+    trap "$RM \"$cfgfile\"; exit 1" 1 2 15
+    $RM "$cfgfile"
+
+    cat <<_LT_EOF >> "$cfgfile"
+#! $SHELL
+# Generated automatically by $as_me ($PACKAGE) $VERSION
+# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
+# NOTE: Changes made to this file will be lost: look at ltmain.sh.
+
+# Provide generalized library-building support services.
+# Written by Gordon Matzigkeit, 1996
+
+_LT_COPYING
+_LT_LIBTOOL_TAGS
+
+# Configured defaults for sys_lib_dlsearch_path munging.
+: \${LT_SYS_LIBRARY_PATH="$configure_time_lt_sys_library_path"}
+
+# ### BEGIN LIBTOOL CONFIG
+_LT_LIBTOOL_CONFIG_VARS
+_LT_LIBTOOL_TAG_VARS
+# ### END LIBTOOL CONFIG
+
+_LT_EOF
+
+    cat <<'_LT_EOF' >> "$cfgfile"
+
+# ### BEGIN FUNCTIONS SHARED WITH CONFIGURE
+
+_LT_PREPARE_MUNGE_PATH_LIST
+_LT_PREPARE_CC_BASENAME
+
+# ### END FUNCTIONS SHARED WITH CONFIGURE
+
+_LT_EOF
+
+  case $host_os in
+  aix3*)
+    cat <<\_LT_EOF >> "$cfgfile"
+# AIX sometimes has problems with the GCC collect2 program.  For some
+# reason, if we set the COLLECT_NAMES environment variable, the problems
+# vanish in a puff of smoke.
+if test set != "${COLLECT_NAMES+set}"; then
+  COLLECT_NAMES=
+  export COLLECT_NAMES
+fi
+_LT_EOF
+    ;;
+  esac
+
+  _LT_PROG_LTMAIN
+
+  # We use sed instead of cat because bash on DJGPP gets confused if
+  # if finds mixed CR/LF and LF-only lines.  Since sed operates in
+  # text mode, it properly converts lines to CR/LF.  This bash problem
+  # is reportedly fixed, but why not run on old versions too?
+  sed '$q' "$ltmain" >> "$cfgfile" \
+     || (rm -f "$cfgfile"; exit 1)
+
+   mv -f "$cfgfile" "$ofile" ||
+    (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile")
+  chmod +x "$ofile"
+],
+[cat <<_LT_EOF >> "$ofile"
+
+dnl Unfortunately we have to use $1 here, since _LT_TAG is not expanded
+dnl in a comment (ie after a #).
+# ### BEGIN LIBTOOL TAG CONFIG: $1
+_LT_LIBTOOL_TAG_VARS(_LT_TAG)
+# ### END LIBTOOL TAG CONFIG: $1
+_LT_EOF
+])dnl /m4_if
+],
+[m4_if([$1], [], [
+    PACKAGE='$PACKAGE'
+    VERSION='$VERSION'
+    RM='$RM'
+    ofile='$ofile'], [])
+])dnl /_LT_CONFIG_SAVE_COMMANDS
+])# _LT_CONFIG
+
+
+# LT_SUPPORTED_TAG(TAG)
+# ---------------------
+# Trace this macro to discover what tags are supported by the libtool
+# --tag option, using:
+#    autoconf --trace 'LT_SUPPORTED_TAG:$1'
+AC_DEFUN([LT_SUPPORTED_TAG], [])
+
+
+# C support is built-in for now
+m4_define([_LT_LANG_C_enabled], [])
+m4_define([_LT_TAGS], [])
+
+
+# LT_LANG(LANG)
+# -------------
+# Enable libtool support for the given language if not already enabled.
+AC_DEFUN([LT_LANG],
+[AC_BEFORE([$0], [LT_OUTPUT])dnl
+m4_case([$1],
+  [C],			[_LT_LANG(C)],
+  [C++],		[_LT_LANG(CXX)],
+  [Go],			[_LT_LANG(GO)],
+  [Java],		[_LT_LANG(GCJ)],
+  [Fortran 77],		[_LT_LANG(F77)],
+  [Fortran],		[_LT_LANG(FC)],
+  [Windows Resource],	[_LT_LANG(RC)],
+  [m4_ifdef([_LT_LANG_]$1[_CONFIG],
+    [_LT_LANG($1)],
+    [m4_fatal([$0: unsupported language: "$1"])])])dnl
+])# LT_LANG
+
+
+# _LT_LANG(LANGNAME)
+# ------------------
+m4_defun([_LT_LANG],
+[m4_ifdef([_LT_LANG_]$1[_enabled], [],
+  [LT_SUPPORTED_TAG([$1])dnl
+  m4_append([_LT_TAGS], [$1 ])dnl
+  m4_define([_LT_LANG_]$1[_enabled], [])dnl
+  _LT_LANG_$1_CONFIG($1)])dnl
+])# _LT_LANG
+
+
+m4_ifndef([AC_PROG_GO], [
+############################################################
+# NOTE: This macro has been submitted for inclusion into   #
+#  GNU Autoconf as AC_PROG_GO.  When it is available in    #
+#  a released version of Autoconf we should remove this    #
+#  macro and use it instead.                               #
+############################################################
+m4_defun([AC_PROG_GO],
+[AC_LANG_PUSH(Go)dnl
+AC_ARG_VAR([GOC],     [Go compiler command])dnl
+AC_ARG_VAR([GOFLAGS], [Go compiler flags])dnl
+_AC_ARG_VAR_LDFLAGS()dnl
+AC_CHECK_TOOL(GOC, gccgo)
+if test -z "$GOC"; then
+  if test -n "$ac_tool_prefix"; then
+    AC_CHECK_PROG(GOC, [${ac_tool_prefix}gccgo], [${ac_tool_prefix}gccgo])
+  fi
+fi
+if test -z "$GOC"; then
+  AC_CHECK_PROG(GOC, gccgo, gccgo, false)
+fi
+])#m4_defun
+])#m4_ifndef
+
+
+# _LT_LANG_DEFAULT_CONFIG
+# -----------------------
+m4_defun([_LT_LANG_DEFAULT_CONFIG],
+[AC_PROVIDE_IFELSE([AC_PROG_CXX],
+  [LT_LANG(CXX)],
+  [m4_define([AC_PROG_CXX], defn([AC_PROG_CXX])[LT_LANG(CXX)])])
+
+AC_PROVIDE_IFELSE([AC_PROG_F77],
+  [LT_LANG(F77)],
+  [m4_define([AC_PROG_F77], defn([AC_PROG_F77])[LT_LANG(F77)])])
+
+AC_PROVIDE_IFELSE([AC_PROG_FC],
+  [LT_LANG(FC)],
+  [m4_define([AC_PROG_FC], defn([AC_PROG_FC])[LT_LANG(FC)])])
+
+dnl The call to [A][M_PROG_GCJ] is quoted like that to stop aclocal
+dnl pulling things in needlessly.
+AC_PROVIDE_IFELSE([AC_PROG_GCJ],
+  [LT_LANG(GCJ)],
+  [AC_PROVIDE_IFELSE([A][M_PROG_GCJ],
+    [LT_LANG(GCJ)],
+    [AC_PROVIDE_IFELSE([LT_PROG_GCJ],
+      [LT_LANG(GCJ)],
+      [m4_ifdef([AC_PROG_GCJ],
+	[m4_define([AC_PROG_GCJ], defn([AC_PROG_GCJ])[LT_LANG(GCJ)])])
+       m4_ifdef([A][M_PROG_GCJ],
+	[m4_define([A][M_PROG_GCJ], defn([A][M_PROG_GCJ])[LT_LANG(GCJ)])])
+       m4_ifdef([LT_PROG_GCJ],
+	[m4_define([LT_PROG_GCJ], defn([LT_PROG_GCJ])[LT_LANG(GCJ)])])])])])
+
+AC_PROVIDE_IFELSE([AC_PROG_GO],
+  [LT_LANG(GO)],
+  [m4_define([AC_PROG_GO], defn([AC_PROG_GO])[LT_LANG(GO)])])
+
+AC_PROVIDE_IFELSE([LT_PROG_RC],
+  [LT_LANG(RC)],
+  [m4_define([LT_PROG_RC], defn([LT_PROG_RC])[LT_LANG(RC)])])
+])# _LT_LANG_DEFAULT_CONFIG
+
+# Obsolete macros:
+AU_DEFUN([AC_LIBTOOL_CXX], [LT_LANG(C++)])
+AU_DEFUN([AC_LIBTOOL_F77], [LT_LANG(Fortran 77)])
+AU_DEFUN([AC_LIBTOOL_FC], [LT_LANG(Fortran)])
+AU_DEFUN([AC_LIBTOOL_GCJ], [LT_LANG(Java)])
+AU_DEFUN([AC_LIBTOOL_RC], [LT_LANG(Windows Resource)])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_CXX], [])
+dnl AC_DEFUN([AC_LIBTOOL_F77], [])
+dnl AC_DEFUN([AC_LIBTOOL_FC], [])
+dnl AC_DEFUN([AC_LIBTOOL_GCJ], [])
+dnl AC_DEFUN([AC_LIBTOOL_RC], [])
+
+
+# _LT_TAG_COMPILER
+# ----------------
+m4_defun([_LT_TAG_COMPILER],
+[AC_REQUIRE([AC_PROG_CC])dnl
+
+_LT_DECL([LTCC], [CC], [1], [A C compiler])dnl
+_LT_DECL([LTCFLAGS], [CFLAGS], [1], [LTCC compiler flags])dnl
+_LT_TAGDECL([CC], [compiler], [1], [A language specific compiler])dnl
+_LT_TAGDECL([with_gcc], [GCC], [0], [Is the compiler the GNU compiler?])dnl
+
+# If no C compiler was specified, use CC.
+LTCC=${LTCC-"$CC"}
+
+# If no C compiler flags were specified, use CFLAGS.
+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
+
+# Allow CC to be a program name with arguments.
+compiler=$CC
+])# _LT_TAG_COMPILER
+
+
+# _LT_COMPILER_BOILERPLATE
+# ------------------------
+# Check for compiler boilerplate output or warnings with
+# the simple compiler test code.
+m4_defun([_LT_COMPILER_BOILERPLATE],
+[m4_require([_LT_DECL_SED])dnl
+ac_outfile=conftest.$ac_objext
+echo "$lt_simple_compile_test_code" >conftest.$ac_ext
+eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_compiler_boilerplate=`cat conftest.err`
+$RM conftest*
+])# _LT_COMPILER_BOILERPLATE
+
+
+# _LT_LINKER_BOILERPLATE
+# ----------------------
+# Check for linker boilerplate output or warnings with
+# the simple link test code.
+m4_defun([_LT_LINKER_BOILERPLATE],
+[m4_require([_LT_DECL_SED])dnl
+ac_outfile=conftest.$ac_objext
+echo "$lt_simple_link_test_code" >conftest.$ac_ext
+eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_linker_boilerplate=`cat conftest.err`
+$RM -r conftest*
+])# _LT_LINKER_BOILERPLATE
+
+# _LT_REQUIRED_DARWIN_CHECKS
+# -------------------------
+m4_defun_once([_LT_REQUIRED_DARWIN_CHECKS],[
+  case $host_os in
+    rhapsody* | darwin*)
+    AC_CHECK_TOOL([DSYMUTIL], [dsymutil], [:])
+    AC_CHECK_TOOL([NMEDIT], [nmedit], [:])
+    AC_CHECK_TOOL([LIPO], [lipo], [:])
+    AC_CHECK_TOOL([OTOOL], [otool], [:])
+    AC_CHECK_TOOL([OTOOL64], [otool64], [:])
+    _LT_DECL([], [DSYMUTIL], [1],
+      [Tool to manipulate archived DWARF debug symbol files on Mac OS X])
+    _LT_DECL([], [NMEDIT], [1],
+      [Tool to change global to local symbols on Mac OS X])
+    _LT_DECL([], [LIPO], [1],
+      [Tool to manipulate fat objects and archives on Mac OS X])
+    _LT_DECL([], [OTOOL], [1],
+      [ldd/readelf like tool for Mach-O binaries on Mac OS X])
+    _LT_DECL([], [OTOOL64], [1],
+      [ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4])
+
+    AC_CACHE_CHECK([for -single_module linker flag],[lt_cv_apple_cc_single_mod],
+      [lt_cv_apple_cc_single_mod=no
+      if test -z "$LT_MULTI_MODULE"; then
+	# By default we will add the -single_module flag. You can override
+	# by either setting the environment variable LT_MULTI_MODULE
+	# non-empty at configure time, or by adding -multi_module to the
+	# link flags.
+	rm -rf libconftest.dylib*
+	echo "int foo(void){return 1;}" > conftest.c
+	echo "$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
+-dynamiclib -Wl,-single_module conftest.c" >&AS_MESSAGE_LOG_FD
+	$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
+	  -dynamiclib -Wl,-single_module conftest.c 2>conftest.err
+        _lt_result=$?
+	# If there is a non-empty error log, and "single_module"
+	# appears in it, assume the flag caused a linker warning
+        if test -s conftest.err && $GREP single_module conftest.err; then
+	  cat conftest.err >&AS_MESSAGE_LOG_FD
+	# Otherwise, if the output was created with a 0 exit code from
+	# the compiler, it worked.
+	elif test -f libconftest.dylib && test 0 = "$_lt_result"; then
+	  lt_cv_apple_cc_single_mod=yes
+	else
+	  cat conftest.err >&AS_MESSAGE_LOG_FD
+	fi
+	rm -rf libconftest.dylib*
+	rm -f conftest.*
+      fi])
+
+    AC_CACHE_CHECK([for -exported_symbols_list linker flag],
+      [lt_cv_ld_exported_symbols_list],
+      [lt_cv_ld_exported_symbols_list=no
+      save_LDFLAGS=$LDFLAGS
+      echo "_main" > conftest.sym
+      LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym"
+      AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])],
+	[lt_cv_ld_exported_symbols_list=yes],
+	[lt_cv_ld_exported_symbols_list=no])
+	LDFLAGS=$save_LDFLAGS
+    ])
+
+    AC_CACHE_CHECK([for -force_load linker flag],[lt_cv_ld_force_load],
+      [lt_cv_ld_force_load=no
+      cat > conftest.c << _LT_EOF
+int forced_loaded() { return 2;}
+_LT_EOF
+      echo "$LTCC $LTCFLAGS -c -o conftest.o conftest.c" >&AS_MESSAGE_LOG_FD
+      $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&AS_MESSAGE_LOG_FD
+      echo "$AR cru libconftest.a conftest.o" >&AS_MESSAGE_LOG_FD
+      $AR cru libconftest.a conftest.o 2>&AS_MESSAGE_LOG_FD
+      echo "$RANLIB libconftest.a" >&AS_MESSAGE_LOG_FD
+      $RANLIB libconftest.a 2>&AS_MESSAGE_LOG_FD
+      cat > conftest.c << _LT_EOF
+int main() { return 0;}
+_LT_EOF
+      echo "$LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a" >&AS_MESSAGE_LOG_FD
+      $LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a 2>conftest.err
+      _lt_result=$?
+      if test -s conftest.err && $GREP force_load conftest.err; then
+	cat conftest.err >&AS_MESSAGE_LOG_FD
+      elif test -f conftest && test 0 = "$_lt_result" && $GREP forced_load conftest >/dev/null 2>&1; then
+	lt_cv_ld_force_load=yes
+      else
+	cat conftest.err >&AS_MESSAGE_LOG_FD
+      fi
+        rm -f conftest.err libconftest.a conftest conftest.c
+        rm -rf conftest.dSYM
+    ])
+    case $host_os in
+    rhapsody* | darwin1.[[012]])
+      _lt_dar_allow_undefined='$wl-undefined ${wl}suppress' ;;
+    darwin1.*)
+      _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;;
+    darwin*) # darwin 5.x on
+      # if running on 10.5 or later, the deployment target defaults
+      # to the OS version, if on x86, and 10.4, the deployment
+      # target defaults to 10.4. Don't you love it?
+      case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in
+	10.0,*86*-darwin8*|10.0,*-darwin[[91]]*)
+	  _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;;
+	10.[[012]][[,.]]*)
+	  _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;;
+	10.*)
+	  _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;;
+      esac
+    ;;
+  esac
+    if test yes = "$lt_cv_apple_cc_single_mod"; then
+      _lt_dar_single_mod='$single_module'
+    fi
+    if test yes = "$lt_cv_ld_exported_symbols_list"; then
+      _lt_dar_export_syms=' $wl-exported_symbols_list,$output_objdir/$libname-symbols.expsym'
+    else
+      _lt_dar_export_syms='~$NMEDIT -s $output_objdir/$libname-symbols.expsym $lib'
+    fi
+    if test : != "$DSYMUTIL" && test no = "$lt_cv_ld_force_load"; then
+      _lt_dsymutil='~$DSYMUTIL $lib || :'
+    else
+      _lt_dsymutil=
+    fi
+    ;;
+  esac
+])
+
+
+# _LT_DARWIN_LINKER_FEATURES([TAG])
+# ---------------------------------
+# Checks for linker and compiler features on darwin
+m4_defun([_LT_DARWIN_LINKER_FEATURES],
+[
+  m4_require([_LT_REQUIRED_DARWIN_CHECKS])
+  _LT_TAGVAR(archive_cmds_need_lc, $1)=no
+  _LT_TAGVAR(hardcode_direct, $1)=no
+  _LT_TAGVAR(hardcode_automatic, $1)=yes
+  _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
+  if test yes = "$lt_cv_ld_force_load"; then
+    _LT_TAGVAR(whole_archive_flag_spec, $1)='`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience $wl-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`'
+    m4_case([$1], [F77], [_LT_TAGVAR(compiler_needs_object, $1)=yes],
+                  [FC],  [_LT_TAGVAR(compiler_needs_object, $1)=yes])
+  else
+    _LT_TAGVAR(whole_archive_flag_spec, $1)=''
+  fi
+  _LT_TAGVAR(link_all_deplibs, $1)=yes
+  _LT_TAGVAR(allow_undefined_flag, $1)=$_lt_dar_allow_undefined
+  case $cc_basename in
+     ifort*|nagfor*) _lt_dar_can_shared=yes ;;
+     *) _lt_dar_can_shared=$GCC ;;
+  esac
+  if test yes = "$_lt_dar_can_shared"; then
+    output_verbose_link_cmd=func_echo_all
+    _LT_TAGVAR(archive_cmds, $1)="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dsymutil"
+    _LT_TAGVAR(module_cmds, $1)="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dsymutil"
+    _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dar_export_syms$_lt_dsymutil"
+    _LT_TAGVAR(module_expsym_cmds, $1)="sed -e 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dar_export_syms$_lt_dsymutil"
+    m4_if([$1], [CXX],
+[   if test yes != "$lt_cv_apple_cc_single_mod"; then
+      _LT_TAGVAR(archive_cmds, $1)="\$CC -r -keep_private_externs -nostdlib -o \$lib-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$lib-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring$_lt_dsymutil"
+      _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \$lib-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$lib-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring$_lt_dar_export_syms$_lt_dsymutil"
+    fi
+],[])
+  else
+  _LT_TAGVAR(ld_shlibs, $1)=no
+  fi
+])
+
+# _LT_SYS_MODULE_PATH_AIX([TAGNAME])
+# ----------------------------------
+# Links a minimal program and checks the executable
+# for the system default hardcoded library path. In most cases,
+# this is /usr/lib:/lib, but when the MPI compilers are used
+# the location of the communication and MPI libs are included too.
+# If we don't find anything, use the default library path according
+# to the aix ld manual.
+# Store the results from the different compilers for each TAGNAME.
+# Allow to override them for all tags through lt_cv_aix_libpath.
+m4_defun([_LT_SYS_MODULE_PATH_AIX],
+[m4_require([_LT_DECL_SED])dnl
+if test set = "${lt_cv_aix_libpath+set}"; then
+  aix_libpath=$lt_cv_aix_libpath
+else
+  AC_CACHE_VAL([_LT_TAGVAR([lt_cv_aix_libpath_], [$1])],
+  [AC_LINK_IFELSE([AC_LANG_PROGRAM],[
+  lt_aix_libpath_sed='[
+      /Import File Strings/,/^$/ {
+	  /^0/ {
+	      s/^0  *\([^ ]*\) *$/\1/
+	      p
+	  }
+      }]'
+  _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+  # Check for a 64-bit object if we didn't find anything.
+  if test -z "$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])"; then
+    _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+  fi],[])
+  if test -z "$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])"; then
+    _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=/usr/lib:/lib
+  fi
+  ])
+  aix_libpath=$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])
+fi
+])# _LT_SYS_MODULE_PATH_AIX
+
+
+# _LT_SHELL_INIT(ARG)
+# -------------------
+m4_define([_LT_SHELL_INIT],
+[m4_divert_text([M4SH-INIT], [$1
+])])# _LT_SHELL_INIT
+
+
+
+# _LT_PROG_ECHO_BACKSLASH
+# -----------------------
+# Find how we can fake an echo command that does not interpret backslash.
+# In particular, with Autoconf 2.60 or later we add some code to the start
+# of the generated configure script that will find a shell with a builtin
+# printf (that we can use as an echo command).
+m4_defun([_LT_PROG_ECHO_BACKSLASH],
+[ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO
+ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO
+
+AC_MSG_CHECKING([how to print strings])
+# Test print first, because it will be a builtin if present.
+if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \
+   test "X`print -r -- $ECHO 2>/dev/null`" = "X$ECHO"; then
+  ECHO='print -r --'
+elif test "X`printf %s $ECHO 2>/dev/null`" = "X$ECHO"; then
+  ECHO='printf %s\n'
+else
+  # Use this function as a fallback that always works.
+  func_fallback_echo ()
+  {
+    eval 'cat <<_LTECHO_EOF
+$[]1
+_LTECHO_EOF'
+  }
+  ECHO='func_fallback_echo'
+fi
+
+# func_echo_all arg...
+# Invoke $ECHO with all args, space-separated.
+func_echo_all ()
+{
+    $ECHO "$*"
+}
+
+case $ECHO in
+  printf*) AC_MSG_RESULT([printf]) ;;
+  print*) AC_MSG_RESULT([print -r]) ;;
+  *) AC_MSG_RESULT([cat]) ;;
+esac
+
+m4_ifdef([_AS_DETECT_SUGGESTED],
+[_AS_DETECT_SUGGESTED([
+  test -n "${ZSH_VERSION+set}${BASH_VERSION+set}" || (
+    ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+    ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO
+    ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO
+    PATH=/empty FPATH=/empty; export PATH FPATH
+    test "X`printf %s $ECHO`" = "X$ECHO" \
+      || test "X`print -r -- $ECHO`" = "X$ECHO" )])])
+
+_LT_DECL([], [SHELL], [1], [Shell to use when invoking shell scripts])
+_LT_DECL([], [ECHO], [1], [An echo program that protects backslashes])
+])# _LT_PROG_ECHO_BACKSLASH
+
+
+# _LT_WITH_SYSROOT
+# ----------------
+AC_DEFUN([_LT_WITH_SYSROOT],
+[AC_MSG_CHECKING([for sysroot])
+AC_ARG_WITH([sysroot],
+[AS_HELP_STRING([--with-sysroot@<:@=DIR@:>@],
+  [Search for dependent libraries within DIR (or the compiler's sysroot
+   if not specified).])],
+[], [with_sysroot=no])
+
+dnl lt_sysroot will always be passed unquoted.  We quote it here
+dnl in case the user passed a directory name.
+lt_sysroot=
+case $with_sysroot in #(
+ yes)
+   if test yes = "$GCC"; then
+     lt_sysroot=`$CC --print-sysroot 2>/dev/null`
+   fi
+   ;; #(
+ /*)
+   lt_sysroot=`echo "$with_sysroot" | sed -e "$sed_quote_subst"`
+   ;; #(
+ no|'')
+   ;; #(
+ *)
+   AC_MSG_RESULT([$with_sysroot])
+   AC_MSG_ERROR([The sysroot must be an absolute path.])
+   ;;
+esac
+
+ AC_MSG_RESULT([${lt_sysroot:-no}])
+_LT_DECL([], [lt_sysroot], [0], [The root where to search for ]dnl
+[dependent libraries, and where our libraries should be installed.])])
+
+# _LT_ENABLE_LOCK
+# ---------------
+m4_defun([_LT_ENABLE_LOCK],
+[AC_ARG_ENABLE([libtool-lock],
+  [AS_HELP_STRING([--disable-libtool-lock],
+    [avoid locking (might break parallel builds)])])
+test no = "$enable_libtool_lock" || enable_libtool_lock=yes
+
+# Some flags need to be propagated to the compiler or linker for good
+# libtool support.
+case $host in
+ia64-*-hpux*)
+  # Find out what ABI is being produced by ac_compile, and set mode
+  # options accordingly.
+  echo 'int i;' > conftest.$ac_ext
+  if AC_TRY_EVAL(ac_compile); then
+    case `/usr/bin/file conftest.$ac_objext` in
+      *ELF-32*)
+	HPUX_IA64_MODE=32
+	;;
+      *ELF-64*)
+	HPUX_IA64_MODE=64
+	;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+*-*-irix6*)
+  # Find out what ABI is being produced by ac_compile, and set linker
+  # options accordingly.
+  echo '[#]line '$LINENO' "configure"' > conftest.$ac_ext
+  if AC_TRY_EVAL(ac_compile); then
+    if test yes = "$lt_cv_prog_gnu_ld"; then
+      case `/usr/bin/file conftest.$ac_objext` in
+	*32-bit*)
+	  LD="${LD-ld} -melf32bsmip"
+	  ;;
+	*N32*)
+	  LD="${LD-ld} -melf32bmipn32"
+	  ;;
+	*64-bit*)
+	  LD="${LD-ld} -melf64bmip"
+	;;
+      esac
+    else
+      case `/usr/bin/file conftest.$ac_objext` in
+	*32-bit*)
+	  LD="${LD-ld} -32"
+	  ;;
+	*N32*)
+	  LD="${LD-ld} -n32"
+	  ;;
+	*64-bit*)
+	  LD="${LD-ld} -64"
+	  ;;
+      esac
+    fi
+  fi
+  rm -rf conftest*
+  ;;
+
+mips64*-*linux*)
+  # Find out what ABI is being produced by ac_compile, and set linker
+  # options accordingly.
+  echo '[#]line '$LINENO' "configure"' > conftest.$ac_ext
+  if AC_TRY_EVAL(ac_compile); then
+    emul=elf
+    case `/usr/bin/file conftest.$ac_objext` in
+      *32-bit*)
+	emul="${emul}32"
+	;;
+      *64-bit*)
+	emul="${emul}64"
+	;;
+    esac
+    case `/usr/bin/file conftest.$ac_objext` in
+      *MSB*)
+	emul="${emul}btsmip"
+	;;
+      *LSB*)
+	emul="${emul}ltsmip"
+	;;
+    esac
+    case `/usr/bin/file conftest.$ac_objext` in
+      *N32*)
+	emul="${emul}n32"
+	;;
+    esac
+    LD="${LD-ld} -m $emul"
+  fi
+  rm -rf conftest*
+  ;;
+
+x86_64-*kfreebsd*-gnu|x86_64-*linux*|powerpc*-*linux*| \
+s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
+  # Find out what ABI is being produced by ac_compile, and set linker
+  # options accordingly.  Note that the listed cases only cover the
+  # situations where additional linker options are needed (such as when
+  # doing 32-bit compilation for a host where ld defaults to 64-bit, or
+  # vice versa); the common cases where no linker options are needed do
+  # not appear in the list.
+  echo 'int i;' > conftest.$ac_ext
+  if AC_TRY_EVAL(ac_compile); then
+    case `/usr/bin/file conftest.o` in
+      *32-bit*)
+	case $host in
+	  x86_64-*kfreebsd*-gnu)
+	    LD="${LD-ld} -m elf_i386_fbsd"
+	    ;;
+	  x86_64-*linux*)
+	    case `/usr/bin/file conftest.o` in
+	      *x86-64*)
+		LD="${LD-ld} -m elf32_x86_64"
+		;;
+	      *)
+		LD="${LD-ld} -m elf_i386"
+		;;
+	    esac
+	    ;;
+	  powerpc64le-*linux*)
+	    LD="${LD-ld} -m elf32lppclinux"
+	    ;;
+	  powerpc64-*linux*)
+	    LD="${LD-ld} -m elf32ppclinux"
+	    ;;
+	  s390x-*linux*)
+	    LD="${LD-ld} -m elf_s390"
+	    ;;
+	  sparc64-*linux*)
+	    LD="${LD-ld} -m elf32_sparc"
+	    ;;
+	esac
+	;;
+      *64-bit*)
+	case $host in
+	  x86_64-*kfreebsd*-gnu)
+	    LD="${LD-ld} -m elf_x86_64_fbsd"
+	    ;;
+	  x86_64-*linux*)
+	    LD="${LD-ld} -m elf_x86_64"
+	    ;;
+	  powerpcle-*linux*)
+	    LD="${LD-ld} -m elf64lppc"
+	    ;;
+	  powerpc-*linux*)
+	    LD="${LD-ld} -m elf64ppc"
+	    ;;
+	  s390*-*linux*|s390*-*tpf*)
+	    LD="${LD-ld} -m elf64_s390"
+	    ;;
+	  sparc*-*linux*)
+	    LD="${LD-ld} -m elf64_sparc"
+	    ;;
+	esac
+	;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+
+*-*-sco3.2v5*)
+  # On SCO OpenServer 5, we need -belf to get full-featured binaries.
+  SAVE_CFLAGS=$CFLAGS
+  CFLAGS="$CFLAGS -belf"
+  AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf,
+    [AC_LANG_PUSH(C)
+     AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],[[]])],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no])
+     AC_LANG_POP])
+  if test yes != "$lt_cv_cc_needs_belf"; then
+    # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
+    CFLAGS=$SAVE_CFLAGS
+  fi
+  ;;
+*-*solaris*)
+  # Find out what ABI is being produced by ac_compile, and set linker
+  # options accordingly.
+  echo 'int i;' > conftest.$ac_ext
+  if AC_TRY_EVAL(ac_compile); then
+    case `/usr/bin/file conftest.o` in
+    *64-bit*)
+      case $lt_cv_prog_gnu_ld in
+      yes*)
+        case $host in
+        i?86-*-solaris*|x86_64-*-solaris*)
+          LD="${LD-ld} -m elf_x86_64"
+          ;;
+        sparc*-*-solaris*)
+          LD="${LD-ld} -m elf64_sparc"
+          ;;
+        esac
+        # GNU ld 2.21 introduced _sol2 emulations.  Use them if available.
+        if ${LD-ld} -V | grep _sol2 >/dev/null 2>&1; then
+          LD=${LD-ld}_sol2
+        fi
+        ;;
+      *)
+	if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then
+	  LD="${LD-ld} -64"
+	fi
+	;;
+      esac
+      ;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+esac
+
+need_locks=$enable_libtool_lock
+])# _LT_ENABLE_LOCK
+
+
+# _LT_PROG_AR
+# -----------
+m4_defun([_LT_PROG_AR],
+[AC_CHECK_TOOLS(AR, [ar], false)
+: ${AR=ar}
+: ${AR_FLAGS=cru}
+_LT_DECL([], [AR], [1], [The archiver])
+_LT_DECL([], [AR_FLAGS], [1], [Flags to create an archive])
+
+AC_CACHE_CHECK([for archiver @FILE support], [lt_cv_ar_at_file],
+  [lt_cv_ar_at_file=no
+   AC_COMPILE_IFELSE([AC_LANG_PROGRAM],
+     [echo conftest.$ac_objext > conftest.lst
+      lt_ar_try='$AR $AR_FLAGS libconftest.a @conftest.lst >&AS_MESSAGE_LOG_FD'
+      AC_TRY_EVAL([lt_ar_try])
+      if test 0 -eq "$ac_status"; then
+	# Ensure the archiver fails upon bogus file names.
+	rm -f conftest.$ac_objext libconftest.a
+	AC_TRY_EVAL([lt_ar_try])
+	if test 0 -ne "$ac_status"; then
+          lt_cv_ar_at_file=@
+        fi
+      fi
+      rm -f conftest.* libconftest.a
+     ])
+  ])
+
+if test no = "$lt_cv_ar_at_file"; then
+  archiver_list_spec=
+else
+  archiver_list_spec=$lt_cv_ar_at_file
+fi
+_LT_DECL([], [archiver_list_spec], [1],
+  [How to feed a file listing to the archiver])
+])# _LT_PROG_AR
+
+
+# _LT_CMD_OLD_ARCHIVE
+# -------------------
+m4_defun([_LT_CMD_OLD_ARCHIVE],
+[_LT_PROG_AR
+
+AC_CHECK_TOOL(STRIP, strip, :)
+test -z "$STRIP" && STRIP=:
+_LT_DECL([], [STRIP], [1], [A symbol stripping program])
+
+AC_CHECK_TOOL(RANLIB, ranlib, :)
+test -z "$RANLIB" && RANLIB=:
+_LT_DECL([], [RANLIB], [1],
+    [Commands used to install an old-style archive])
+
+# Determine commands to create old-style static archives.
+old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs'
+old_postinstall_cmds='chmod 644 $oldlib'
+old_postuninstall_cmds=
+
+if test -n "$RANLIB"; then
+  case $host_os in
+  bitrig* | openbsd*)
+    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$tool_oldlib"
+    ;;
+  *)
+    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$tool_oldlib"
+    ;;
+  esac
+  old_archive_cmds="$old_archive_cmds~\$RANLIB \$tool_oldlib"
+fi
+
+case $host_os in
+  darwin*)
+    lock_old_archive_extraction=yes ;;
+  *)
+    lock_old_archive_extraction=no ;;
+esac
+_LT_DECL([], [old_postinstall_cmds], [2])
+_LT_DECL([], [old_postuninstall_cmds], [2])
+_LT_TAGDECL([], [old_archive_cmds], [2],
+    [Commands used to build an old-style archive])
+_LT_DECL([], [lock_old_archive_extraction], [0],
+    [Whether to use a lock for old archive extraction])
+])# _LT_CMD_OLD_ARCHIVE
+
+
+# _LT_COMPILER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,
+#		[OUTPUT-FILE], [ACTION-SUCCESS], [ACTION-FAILURE])
+# ----------------------------------------------------------------
+# Check whether the given compiler option works
+AC_DEFUN([_LT_COMPILER_OPTION],
+[m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+m4_require([_LT_DECL_SED])dnl
+AC_CACHE_CHECK([$1], [$2],
+  [$2=no
+   m4_if([$4], , [ac_outfile=conftest.$ac_objext], [ac_outfile=$4])
+   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+   lt_compiler_flag="$3"  ## exclude from sc_useless_quotes_in_assignment
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   # The option is referenced via a variable to avoid confusing sed.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&AS_MESSAGE_LOG_FD)
+   (eval "$lt_compile" 2>conftest.err)
+   ac_status=$?
+   cat conftest.err >&AS_MESSAGE_LOG_FD
+   echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
+   if (exit $ac_status) && test -s "$ac_outfile"; then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings other than the usual output.
+     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp
+     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
+       $2=yes
+     fi
+   fi
+   $RM conftest*
+])
+
+if test yes = "[$]$2"; then
+    m4_if([$5], , :, [$5])
+else
+    m4_if([$6], , :, [$6])
+fi
+])# _LT_COMPILER_OPTION
+
+# Old name:
+AU_ALIAS([AC_LIBTOOL_COMPILER_OPTION], [_LT_COMPILER_OPTION])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_COMPILER_OPTION], [])
+
+
+# _LT_LINKER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,
+#                  [ACTION-SUCCESS], [ACTION-FAILURE])
+# ----------------------------------------------------
+# Check whether the given linker option works
+AC_DEFUN([_LT_LINKER_OPTION],
+[m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+m4_require([_LT_DECL_SED])dnl
+AC_CACHE_CHECK([$1], [$2],
+  [$2=no
+   save_LDFLAGS=$LDFLAGS
+   LDFLAGS="$LDFLAGS $3"
+   echo "$lt_simple_link_test_code" > conftest.$ac_ext
+   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
+     # The linker can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     if test -s conftest.err; then
+       # Append any errors to the config.log.
+       cat conftest.err 1>&AS_MESSAGE_LOG_FD
+       $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp
+       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+       if diff conftest.exp conftest.er2 >/dev/null; then
+         $2=yes
+       fi
+     else
+       $2=yes
+     fi
+   fi
+   $RM -r conftest*
+   LDFLAGS=$save_LDFLAGS
+])
+
+if test yes = "[$]$2"; then
+    m4_if([$4], , :, [$4])
+else
+    m4_if([$5], , :, [$5])
+fi
+])# _LT_LINKER_OPTION
+
+# Old name:
+AU_ALIAS([AC_LIBTOOL_LINKER_OPTION], [_LT_LINKER_OPTION])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_LINKER_OPTION], [])
+
+
+# LT_CMD_MAX_LEN
+#---------------
+AC_DEFUN([LT_CMD_MAX_LEN],
+[AC_REQUIRE([AC_CANONICAL_HOST])dnl
+# find the maximum length of command line arguments
+AC_MSG_CHECKING([the maximum length of command line arguments])
+AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl
+  i=0
+  teststring=ABCD
+
+  case $build_os in
+  msdosdjgpp*)
+    # On DJGPP, this test can blow up pretty badly due to problems in libc
+    # (any single argument exceeding 2000 bytes causes a buffer overrun
+    # during glob expansion).  Even if it were fixed, the result of this
+    # check would be larger than it should be.
+    lt_cv_sys_max_cmd_len=12288;    # 12K is about right
+    ;;
+
+  gnu*)
+    # Under GNU Hurd, this test is not required because there is
+    # no limit to the length of command line arguments.
+    # Libtool will interpret -1 as no limit whatsoever
+    lt_cv_sys_max_cmd_len=-1;
+    ;;
+
+  cygwin* | mingw* | cegcc*)
+    # On Win9x/ME, this test blows up -- it succeeds, but takes
+    # about 5 minutes as the teststring grows exponentially.
+    # Worse, since 9x/ME are not pre-emptively multitasking,
+    # you end up with a "frozen" computer, even though with patience
+    # the test eventually succeeds (with a max line length of 256k).
+    # Instead, let's just punt: use the minimum linelength reported by
+    # all of the supported platforms: 8192 (on NT/2K/XP).
+    lt_cv_sys_max_cmd_len=8192;
+    ;;
+
+  mint*)
+    # On MiNT this can take a long time and run out of memory.
+    lt_cv_sys_max_cmd_len=8192;
+    ;;
+
+  amigaos*)
+    # On AmigaOS with pdksh, this test takes hours, literally.
+    # So we just punt and use a minimum line length of 8192.
+    lt_cv_sys_max_cmd_len=8192;
+    ;;
+
+  bitrig* | darwin* | dragonfly* | freebsd* | netbsd* | openbsd*)
+    # This has been around since 386BSD, at least.  Likely further.
+    if test -x /sbin/sysctl; then
+      lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
+    elif test -x /usr/sbin/sysctl; then
+      lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
+    else
+      lt_cv_sys_max_cmd_len=65536	# usable default for all BSDs
+    fi
+    # And add a safety zone
+    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
+    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
+    ;;
+
+  interix*)
+    # We know the value 262144 and hardcode it with a safety zone (like BSD)
+    lt_cv_sys_max_cmd_len=196608
+    ;;
+
+  os2*)
+    # The test takes a long time on OS/2.
+    lt_cv_sys_max_cmd_len=8192
+    ;;
+
+  osf*)
+    # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure
+    # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not
+    # nice to cause kernel panics so lets avoid the loop below.
+    # First set a reasonable default.
+    lt_cv_sys_max_cmd_len=16384
+    #
+    if test -x /sbin/sysconfig; then
+      case `/sbin/sysconfig -q proc exec_disable_arg_limit` in
+        *1*) lt_cv_sys_max_cmd_len=-1 ;;
+      esac
+    fi
+    ;;
+  sco3.2v5*)
+    lt_cv_sys_max_cmd_len=102400
+    ;;
+  sysv5* | sco5v6* | sysv4.2uw2*)
+    kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null`
+    if test -n "$kargmax"; then
+      lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[[	 ]]//'`
+    else
+      lt_cv_sys_max_cmd_len=32768
+    fi
+    ;;
+  *)
+    lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null`
+    if test -n "$lt_cv_sys_max_cmd_len" && \
+       test undefined != "$lt_cv_sys_max_cmd_len"; then
+      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
+      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
+    else
+      # Make teststring a little bigger before we do anything with it.
+      # a 1K string should be a reasonable start.
+      for i in 1 2 3 4 5 6 7 8; do
+        teststring=$teststring$teststring
+      done
+      SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}
+      # If test is not a shell built-in, we'll probably end up computing a
+      # maximum length that is only half of the actual maximum length, but
+      # we can't tell.
+      while { test X`env echo "$teststring$teststring" 2>/dev/null` \
+	         = "X$teststring$teststring"; } >/dev/null 2>&1 &&
+	      test 17 != "$i" # 1/2 MB should be enough
+      do
+        i=`expr $i + 1`
+        teststring=$teststring$teststring
+      done
+      # Only check the string length outside the loop.
+      lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1`
+      teststring=
+      # Add a significant safety factor because C++ compilers can tack on
+      # massive amounts of additional arguments before passing them to the
+      # linker.  It appears as though 1/2 is a usable value.
+      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`
+    fi
+    ;;
+  esac
+])
+if test -n "$lt_cv_sys_max_cmd_len"; then
+  AC_MSG_RESULT($lt_cv_sys_max_cmd_len)
+else
+  AC_MSG_RESULT(none)
+fi
+max_cmd_len=$lt_cv_sys_max_cmd_len
+_LT_DECL([], [max_cmd_len], [0],
+    [What is the maximum length of a command?])
+])# LT_CMD_MAX_LEN
+
+# Old name:
+AU_ALIAS([AC_LIBTOOL_SYS_MAX_CMD_LEN], [LT_CMD_MAX_LEN])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_SYS_MAX_CMD_LEN], [])
+
+
+# _LT_HEADER_DLFCN
+# ----------------
+m4_defun([_LT_HEADER_DLFCN],
+[AC_CHECK_HEADERS([dlfcn.h], [], [], [AC_INCLUDES_DEFAULT])dnl
+])# _LT_HEADER_DLFCN
+
+
+# _LT_TRY_DLOPEN_SELF (ACTION-IF-TRUE, ACTION-IF-TRUE-W-USCORE,
+#                      ACTION-IF-FALSE, ACTION-IF-CROSS-COMPILING)
+# ----------------------------------------------------------------
+m4_defun([_LT_TRY_DLOPEN_SELF],
+[m4_require([_LT_HEADER_DLFCN])dnl
+if test yes = "$cross_compiling"; then :
+  [$4]
+else
+  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
+  lt_status=$lt_dlunknown
+  cat > conftest.$ac_ext <<_LT_EOF
+[#line $LINENO "configure"
+#include "confdefs.h"
+
+#if HAVE_DLFCN_H
+#include <dlfcn.h>
+#endif
+
+#include <stdio.h>
+
+#ifdef RTLD_GLOBAL
+#  define LT_DLGLOBAL		RTLD_GLOBAL
+#else
+#  ifdef DL_GLOBAL
+#    define LT_DLGLOBAL		DL_GLOBAL
+#  else
+#    define LT_DLGLOBAL		0
+#  endif
+#endif
+
+/* We may have to define LT_DLLAZY_OR_NOW in the command line if we
+   find out it does not work in some platform. */
+#ifndef LT_DLLAZY_OR_NOW
+#  ifdef RTLD_LAZY
+#    define LT_DLLAZY_OR_NOW		RTLD_LAZY
+#  else
+#    ifdef DL_LAZY
+#      define LT_DLLAZY_OR_NOW		DL_LAZY
+#    else
+#      ifdef RTLD_NOW
+#        define LT_DLLAZY_OR_NOW	RTLD_NOW
+#      else
+#        ifdef DL_NOW
+#          define LT_DLLAZY_OR_NOW	DL_NOW
+#        else
+#          define LT_DLLAZY_OR_NOW	0
+#        endif
+#      endif
+#    endif
+#  endif
+#endif
+
+/* When -fvisibility=hidden is used, assume the code has been annotated
+   correspondingly for the symbols needed.  */
+#if defined __GNUC__ && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3))
+int fnord () __attribute__((visibility("default")));
+#endif
+
+int fnord () { return 42; }
+int main ()
+{
+  void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);
+  int status = $lt_dlunknown;
+
+  if (self)
+    {
+      if (dlsym (self,"fnord"))       status = $lt_dlno_uscore;
+      else
+        {
+	  if (dlsym( self,"_fnord"))  status = $lt_dlneed_uscore;
+          else puts (dlerror ());
+	}
+      /* dlclose (self); */
+    }
+  else
+    puts (dlerror ());
+
+  return status;
+}]
+_LT_EOF
+  if AC_TRY_EVAL(ac_link) && test -s "conftest$ac_exeext" 2>/dev/null; then
+    (./conftest; exit; ) >&AS_MESSAGE_LOG_FD 2>/dev/null
+    lt_status=$?
+    case x$lt_status in
+      x$lt_dlno_uscore) $1 ;;
+      x$lt_dlneed_uscore) $2 ;;
+      x$lt_dlunknown|x*) $3 ;;
+    esac
+  else :
+    # compilation failed
+    $3
+  fi
+fi
+rm -fr conftest*
+])# _LT_TRY_DLOPEN_SELF
+
+
+# LT_SYS_DLOPEN_SELF
+# ------------------
+AC_DEFUN([LT_SYS_DLOPEN_SELF],
+[m4_require([_LT_HEADER_DLFCN])dnl
+if test yes != "$enable_dlopen"; then
+  enable_dlopen=unknown
+  enable_dlopen_self=unknown
+  enable_dlopen_self_static=unknown
+else
+  lt_cv_dlopen=no
+  lt_cv_dlopen_libs=
+
+  case $host_os in
+  beos*)
+    lt_cv_dlopen=load_add_on
+    lt_cv_dlopen_libs=
+    lt_cv_dlopen_self=yes
+    ;;
+
+  mingw* | pw32* | cegcc*)
+    lt_cv_dlopen=LoadLibrary
+    lt_cv_dlopen_libs=
+    ;;
+
+  cygwin*)
+    lt_cv_dlopen=dlopen
+    lt_cv_dlopen_libs=
+    ;;
+
+  darwin*)
+    # if libdl is installed we need to link against it
+    AC_CHECK_LIB([dl], [dlopen],
+		[lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl],[
+    lt_cv_dlopen=dyld
+    lt_cv_dlopen_libs=
+    lt_cv_dlopen_self=yes
+    ])
+    ;;
+
+  tpf*)
+    # Don't try to run any link tests for TPF.  We know it's impossible
+    # because TPF is a cross-compiler, and we know how we open DSOs.
+    lt_cv_dlopen=dlopen
+    lt_cv_dlopen_libs=
+    lt_cv_dlopen_self=no
+    ;;
+
+  *)
+    AC_CHECK_FUNC([shl_load],
+	  [lt_cv_dlopen=shl_load],
+      [AC_CHECK_LIB([dld], [shl_load],
+	    [lt_cv_dlopen=shl_load lt_cv_dlopen_libs=-ldld],
+	[AC_CHECK_FUNC([dlopen],
+	      [lt_cv_dlopen=dlopen],
+	  [AC_CHECK_LIB([dl], [dlopen],
+		[lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl],
+	    [AC_CHECK_LIB([svld], [dlopen],
+		  [lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-lsvld],
+	      [AC_CHECK_LIB([dld], [dld_link],
+		    [lt_cv_dlopen=dld_link lt_cv_dlopen_libs=-ldld])
+	      ])
+	    ])
+	  ])
+	])
+      ])
+    ;;
+  esac
+
+  if test no = "$lt_cv_dlopen"; then
+    enable_dlopen=no
+  else
+    enable_dlopen=yes
+  fi
+
+  case $lt_cv_dlopen in
+  dlopen)
+    save_CPPFLAGS=$CPPFLAGS
+    test yes = "$ac_cv_header_dlfcn_h" && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"
+
+    save_LDFLAGS=$LDFLAGS
+    wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\"
+
+    save_LIBS=$LIBS
+    LIBS="$lt_cv_dlopen_libs $LIBS"
+
+    AC_CACHE_CHECK([whether a program can dlopen itself],
+	  lt_cv_dlopen_self, [dnl
+	  _LT_TRY_DLOPEN_SELF(
+	    lt_cv_dlopen_self=yes, lt_cv_dlopen_self=yes,
+	    lt_cv_dlopen_self=no, lt_cv_dlopen_self=cross)
+    ])
+
+    if test yes = "$lt_cv_dlopen_self"; then
+      wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\"
+      AC_CACHE_CHECK([whether a statically linked program can dlopen itself],
+	  lt_cv_dlopen_self_static, [dnl
+	  _LT_TRY_DLOPEN_SELF(
+	    lt_cv_dlopen_self_static=yes, lt_cv_dlopen_self_static=yes,
+	    lt_cv_dlopen_self_static=no,  lt_cv_dlopen_self_static=cross)
+      ])
+    fi
+
+    CPPFLAGS=$save_CPPFLAGS
+    LDFLAGS=$save_LDFLAGS
+    LIBS=$save_LIBS
+    ;;
+  esac
+
+  case $lt_cv_dlopen_self in
+  yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;;
+  *) enable_dlopen_self=unknown ;;
+  esac
+
+  case $lt_cv_dlopen_self_static in
+  yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;;
+  *) enable_dlopen_self_static=unknown ;;
+  esac
+fi
+_LT_DECL([dlopen_support], [enable_dlopen], [0],
+	 [Whether dlopen is supported])
+_LT_DECL([dlopen_self], [enable_dlopen_self], [0],
+	 [Whether dlopen of programs is supported])
+_LT_DECL([dlopen_self_static], [enable_dlopen_self_static], [0],
+	 [Whether dlopen of statically linked programs is supported])
+])# LT_SYS_DLOPEN_SELF
+
+# Old name:
+AU_ALIAS([AC_LIBTOOL_DLOPEN_SELF], [LT_SYS_DLOPEN_SELF])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_DLOPEN_SELF], [])
+
+
+# _LT_COMPILER_C_O([TAGNAME])
+# ---------------------------
+# Check to see if options -c and -o are simultaneously supported by compiler.
+# This macro does not hard code the compiler like AC_PROG_CC_C_O.
+m4_defun([_LT_COMPILER_C_O],
+[m4_require([_LT_DECL_SED])dnl
+m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+m4_require([_LT_TAG_COMPILER])dnl
+AC_CACHE_CHECK([if $compiler supports -c -o file.$ac_objext],
+  [_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)],
+  [_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=no
+   $RM -r conftest 2>/dev/null
+   mkdir conftest
+   cd conftest
+   mkdir out
+   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+   lt_compiler_flag="-o out/conftest2.$ac_objext"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&AS_MESSAGE_LOG_FD)
+   (eval "$lt_compile" 2>out/conftest.err)
+   ac_status=$?
+   cat out/conftest.err >&AS_MESSAGE_LOG_FD
+   echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
+   if (exit $ac_status) && test -s out/conftest2.$ac_objext
+   then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
+     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
+     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
+       _LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes
+     fi
+   fi
+   chmod u+w . 2>&AS_MESSAGE_LOG_FD
+   $RM conftest*
+   # SGI C++ compiler will create directory out/ii_files/ for
+   # template instantiation
+   test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
+   $RM out/* && rmdir out
+   cd ..
+   $RM -r conftest
+   $RM conftest*
+])
+_LT_TAGDECL([compiler_c_o], [lt_cv_prog_compiler_c_o], [1],
+	[Does compiler simultaneously support -c and -o options?])
+])# _LT_COMPILER_C_O
+
+
+# _LT_COMPILER_FILE_LOCKS([TAGNAME])
+# ----------------------------------
+# Check to see if we can do hard links to lock some files if needed
+m4_defun([_LT_COMPILER_FILE_LOCKS],
+[m4_require([_LT_ENABLE_LOCK])dnl
+m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+_LT_COMPILER_C_O([$1])
+
+hard_links=nottested
+if test no = "$_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)" && test no != "$need_locks"; then
+  # do not overwrite the value of need_locks provided by the user
+  AC_MSG_CHECKING([if we can lock with hard links])
+  hard_links=yes
+  $RM conftest*
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  touch conftest.a
+  ln conftest.a conftest.b 2>&5 || hard_links=no
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  AC_MSG_RESULT([$hard_links])
+  if test no = "$hard_links"; then
+    AC_MSG_WARN(['$CC' does not support '-c -o', so 'make -j' may be unsafe])
+    need_locks=warn
+  fi
+else
+  need_locks=no
+fi
+_LT_DECL([], [need_locks], [1], [Must we lock files when doing compilation?])
+])# _LT_COMPILER_FILE_LOCKS
+
+
+# _LT_CHECK_OBJDIR
+# ----------------
+m4_defun([_LT_CHECK_OBJDIR],
+[AC_CACHE_CHECK([for objdir], [lt_cv_objdir],
+[rm -f .libs 2>/dev/null
+mkdir .libs 2>/dev/null
+if test -d .libs; then
+  lt_cv_objdir=.libs
+else
+  # MS-DOS does not allow filenames that begin with a dot.
+  lt_cv_objdir=_libs
+fi
+rmdir .libs 2>/dev/null])
+objdir=$lt_cv_objdir
+_LT_DECL([], [objdir], [0],
+         [The name of the directory that contains temporary libtool files])dnl
+m4_pattern_allow([LT_OBJDIR])dnl
+AC_DEFINE_UNQUOTED([LT_OBJDIR], "$lt_cv_objdir/",
+  [Define to the sub-directory where libtool stores uninstalled libraries.])
+])# _LT_CHECK_OBJDIR
+
+
+# _LT_LINKER_HARDCODE_LIBPATH([TAGNAME])
+# --------------------------------------
+# Check hardcoding attributes.
+m4_defun([_LT_LINKER_HARDCODE_LIBPATH],
+[AC_MSG_CHECKING([how to hardcode library paths into programs])
+_LT_TAGVAR(hardcode_action, $1)=
+if test -n "$_LT_TAGVAR(hardcode_libdir_flag_spec, $1)" ||
+   test -n "$_LT_TAGVAR(runpath_var, $1)" ||
+   test yes = "$_LT_TAGVAR(hardcode_automatic, $1)"; then
+
+  # We can hardcode non-existent directories.
+  if test no != "$_LT_TAGVAR(hardcode_direct, $1)" &&
+     # If the only mechanism to avoid hardcoding is shlibpath_var, we
+     # have to relink, otherwise we might link with an installed library
+     # when we should be linking with a yet-to-be-installed one
+     ## test no != "$_LT_TAGVAR(hardcode_shlibpath_var, $1)" &&
+     test no != "$_LT_TAGVAR(hardcode_minus_L, $1)"; then
+    # Linking always hardcodes the temporary library directory.
+    _LT_TAGVAR(hardcode_action, $1)=relink
+  else
+    # We can link without hardcoding, and we can hardcode nonexisting dirs.
+    _LT_TAGVAR(hardcode_action, $1)=immediate
+  fi
+else
+  # We cannot hardcode anything, or else we can only hardcode existing
+  # directories.
+  _LT_TAGVAR(hardcode_action, $1)=unsupported
+fi
+AC_MSG_RESULT([$_LT_TAGVAR(hardcode_action, $1)])
+
+if test relink = "$_LT_TAGVAR(hardcode_action, $1)" ||
+   test yes = "$_LT_TAGVAR(inherit_rpath, $1)"; then
+  # Fast installation is not supported
+  enable_fast_install=no
+elif test yes = "$shlibpath_overrides_runpath" ||
+     test no = "$enable_shared"; then
+  # Fast installation is not necessary
+  enable_fast_install=needless
+fi
+_LT_TAGDECL([], [hardcode_action], [0],
+    [How to hardcode a shared library path into an executable])
+])# _LT_LINKER_HARDCODE_LIBPATH
+
+
+# _LT_CMD_STRIPLIB
+# ----------------
+m4_defun([_LT_CMD_STRIPLIB],
+[m4_require([_LT_DECL_EGREP])
+striplib=
+old_striplib=
+AC_MSG_CHECKING([whether stripping libraries is possible])
+if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then
+  test -z "$old_striplib" && old_striplib="$STRIP --strip-debug"
+  test -z "$striplib" && striplib="$STRIP --strip-unneeded"
+  AC_MSG_RESULT([yes])
+else
+# FIXME - insert some real tests, host_os isn't really good enough
+  case $host_os in
+  darwin*)
+    if test -n "$STRIP"; then
+      striplib="$STRIP -x"
+      old_striplib="$STRIP -S"
+      AC_MSG_RESULT([yes])
+    else
+      AC_MSG_RESULT([no])
+    fi
+    ;;
+  *)
+    AC_MSG_RESULT([no])
+    ;;
+  esac
+fi
+_LT_DECL([], [old_striplib], [1], [Commands to strip libraries])
+_LT_DECL([], [striplib], [1])
+])# _LT_CMD_STRIPLIB
+
+
+# _LT_PREPARE_MUNGE_PATH_LIST
+# ---------------------------
+# Make sure func_munge_path_list() is defined correctly.
+m4_defun([_LT_PREPARE_MUNGE_PATH_LIST],
+[[# func_munge_path_list VARIABLE PATH
+# -----------------------------------
+# VARIABLE is name of variable containing _space_ separated list of
+# directories to be munged by the contents of PATH, which is string
+# having a format:
+# "DIR[:DIR]:"
+#       string "DIR[ DIR]" will be prepended to VARIABLE
+# ":DIR[:DIR]"
+#       string "DIR[ DIR]" will be appended to VARIABLE
+# "DIRP[:DIRP]::[DIRA:]DIRA"
+#       string "DIRP[ DIRP]" will be prepended to VARIABLE and string
+#       "DIRA[ DIRA]" will be appended to VARIABLE
+# "DIR[:DIR]"
+#       VARIABLE will be replaced by "DIR[ DIR]"
+func_munge_path_list ()
+{
+    case x@S|@2 in
+    x)
+        ;;
+    *:)
+        eval @S|@1=\"`$ECHO @S|@2 | $SED 's/:/ /g'` \@S|@@S|@1\"
+        ;;
+    x:*)
+        eval @S|@1=\"\@S|@@S|@1 `$ECHO @S|@2 | $SED 's/:/ /g'`\"
+        ;;
+    *::*)
+        eval @S|@1=\"\@S|@@S|@1\ `$ECHO @S|@2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
+        eval @S|@1=\"`$ECHO @S|@2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \@S|@@S|@1\"
+        ;;
+    *)
+        eval @S|@1=\"`$ECHO @S|@2 | $SED 's/:/ /g'`\"
+        ;;
+    esac
+}
+]])# _LT_PREPARE_PATH_LIST
+
+
+# _LT_SYS_DYNAMIC_LINKER([TAG])
+# -----------------------------
+# PORTME Fill in your ld.so characteristics
+m4_defun([_LT_SYS_DYNAMIC_LINKER],
+[AC_REQUIRE([AC_CANONICAL_HOST])dnl
+m4_require([_LT_DECL_EGREP])dnl
+m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+m4_require([_LT_DECL_OBJDUMP])dnl
+m4_require([_LT_DECL_SED])dnl
+m4_require([_LT_CHECK_SHELL_FEATURES])dnl
+m4_require([_LT_PREPARE_MUNGE_PATH_LIST])dnl
+AC_MSG_CHECKING([dynamic linker characteristics])
+m4_if([$1],
+	[], [
+if test yes = "$GCC"; then
+  case $host_os in
+    darwin*) lt_awk_arg='/^libraries:/,/LR/' ;;
+    *) lt_awk_arg='/^libraries:/' ;;
+  esac
+  case $host_os in
+    mingw* | cegcc*) lt_sed_strip_eq='s|=\([[A-Za-z]]:\)|\1|g' ;;
+    *) lt_sed_strip_eq='s|=/|/|g' ;;
+  esac
+  lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e $lt_sed_strip_eq`
+  case $lt_search_path_spec in
+  *\;*)
+    # if the path contains ";" then we assume it to be the separator
+    # otherwise default to the standard path separator (i.e. ":") - it is
+    # assumed that no part of a normal pathname contains ";" but that should
+    # okay in the real world where ";" in dirpaths is itself problematic.
+    lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED 's/;/ /g'`
+    ;;
+  *)
+    lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED "s/$PATH_SEPARATOR/ /g"`
+    ;;
+  esac
+  # Ok, now we have the path, separated by spaces, we can step through it
+  # and add multilib dir if necessary...
+  lt_tmp_lt_search_path_spec=
+  lt_multi_os_dir=/`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null`
+  # ...but if some path component already ends with the multilib dir we assume
+  # that all is fine and trust -print-search-dirs as is (GCC 4.2? or newer).
+  case "$lt_multi_os_dir; $lt_search_path_spec " in
+  "/; "* | "/.; "* | "/./; "* | *"$lt_multi_os_dir "* | *"$lt_multi_os_dir/ "*)
+    lt_multi_os_dir=
+    ;;
+  esac
+  for lt_sys_path in $lt_search_path_spec; do
+    if test -d "$lt_sys_path$lt_multi_os_dir"; then
+      lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path$lt_multi_os_dir"
+    elif test -n "$lt_multi_os_dir"; then
+      test -d "$lt_sys_path" && \
+	lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path"
+    fi
+  done
+  lt_search_path_spec=`$ECHO "$lt_tmp_lt_search_path_spec" | awk '
+BEGIN {RS = " "; FS = "/|\n";} {
+  lt_foo = "";
+  lt_count = 0;
+  for (lt_i = NF; lt_i > 0; lt_i--) {
+    if ($lt_i != "" && $lt_i != ".") {
+      if ($lt_i == "..") {
+        lt_count++;
+      } else {
+        if (lt_count == 0) {
+          lt_foo = "/" $lt_i lt_foo;
+        } else {
+          lt_count--;
+        }
+      }
+    }
+  }
+  if (lt_foo != "") { lt_freq[[lt_foo]]++; }
+  if (lt_freq[[lt_foo]] == 1) { print lt_foo; }
+}'`
+  # AWK program above erroneously prepends '/' to C:/dos/paths
+  # for these hosts.
+  case $host_os in
+    mingw* | cegcc*) lt_search_path_spec=`$ECHO "$lt_search_path_spec" |\
+      $SED 's|/\([[A-Za-z]]:\)|\1|g'` ;;
+  esac
+  sys_lib_search_path_spec=`$ECHO "$lt_search_path_spec" | $lt_NL2SP`
+else
+  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
+fi])
+library_names_spec=
+libname_spec='lib$name'
+soname_spec=
+shrext_cmds=.so
+postinstall_cmds=
+postuninstall_cmds=
+finish_cmds=
+finish_eval=
+shlibpath_var=
+shlibpath_overrides_runpath=unknown
+version_type=none
+dynamic_linker="$host_os ld.so"
+sys_lib_dlsearch_path_spec="/lib /usr/lib"
+need_lib_prefix=unknown
+hardcode_into_libs=no
+
+# when you set need_version to no, make sure it does not cause -set_version
+# flags to be left without arguments
+need_version=unknown
+
+AC_ARG_VAR([LT_SYS_LIBRARY_PATH],
+[User-defined run-time library search path.])
+
+case $host_os in
+aix3*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  library_names_spec='$libname$release$shared_ext$versuffix $libname.a'
+  shlibpath_var=LIBPATH
+
+  # AIX 3 has no versioning support, so we append a major version to the name.
+  soname_spec='$libname$release$shared_ext$major'
+  ;;
+
+aix[[4-9]]*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  hardcode_into_libs=yes
+  if test ia64 = "$host_cpu"; then
+    # AIX 5 supports IA64
+    library_names_spec='$libname$release$shared_ext$major $libname$release$shared_ext$versuffix $libname$shared_ext'
+    shlibpath_var=LD_LIBRARY_PATH
+  else
+    # With GCC up to 2.95.x, collect2 would create an import file
+    # for dependence libraries.  The import file would start with
+    # the line '#! .'.  This would cause the generated library to
+    # depend on '.', always an invalid library.  This was fixed in
+    # development snapshots of GCC prior to 3.0.
+    case $host_os in
+      aix4 | aix4.[[01]] | aix4.[[01]].*)
+      if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
+	   echo ' yes '
+	   echo '#endif'; } | $CC -E - | $GREP yes > /dev/null; then
+	:
+      else
+	can_build_shared=no
+      fi
+      ;;
+    esac
+    # Using Import Files as archive members, it is possible to support
+    # filename-based versioning of shared library archives on AIX. While
+    # this would work for both with and without runtime linking, it will
+    # prevent static linking of such archives. So we do filename-based
+    # shared library versioning with .so extension only, which is used
+    # when both runtime linking and shared linking is enabled.
+    # Unfortunately, runtime linking may impact performance, so we do
+    # not want this to be the default eventually. Also, we use the
+    # versioned .so libs for executables only if there is the -brtl
+    # linker flag in LDFLAGS as well, or --with-aix-soname=svr4 only.
+    # To allow for filename-based versioning support, we need to create
+    # libNAME.so.V as an archive file, containing:
+    # *) an Import File, referring to the versioned filename of the
+    #    archive as well as the shared archive member, telling the
+    #    bitwidth (32 or 64) of that shared object, and providing the
+    #    list of exported symbols of that shared object, eventually
+    #    decorated with the 'weak' keyword
+    # *) the shared object with the F_LOADONLY flag set, to really avoid
+    #    it being seen by the linker.
+    # At run time we better use the real file rather than another symlink,
+    # but for link time we create the symlink libNAME.so -> libNAME.so.V
+
+    case $with_aix_soname,$aix_use_runtimelinking in
+    # AIX (on Power*) has no versioning support, so currently we cannot hardcode correct
+    # soname into executable. Probably we can add versioning support to
+    # collect2, so additional links can be useful in future.
+    aix,yes) # traditional libtool
+      dynamic_linker='AIX unversionable lib.so'
+      # If using run time linking (on AIX 4.2 or later) use lib<name>.so
+      # instead of lib<name>.a to let people know that these are not
+      # typical AIX shared libraries.
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+      ;;
+    aix,no) # traditional AIX only
+      dynamic_linker='AIX lib.a[(]lib.so.V[)]'
+      # We preserve .a as extension for shared libraries through AIX4.2
+      # and later when we are not doing run time linking.
+      library_names_spec='$libname$release.a $libname.a'
+      soname_spec='$libname$release$shared_ext$major'
+      ;;
+    svr4,*) # full svr4 only
+      dynamic_linker="AIX lib.so.V[(]$shared_archive_member_spec.o[)]"
+      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
+      # We do not specify a path in Import Files, so LIBPATH fires.
+      shlibpath_overrides_runpath=yes
+      ;;
+    *,yes) # both, prefer svr4
+      dynamic_linker="AIX lib.so.V[(]$shared_archive_member_spec.o[)], lib.a[(]lib.so.V[)]"
+      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
+      # unpreferred sharedlib libNAME.a needs extra handling
+      postinstall_cmds='test -n "$linkname" || linkname="$realname"~func_stripname "" ".so" "$linkname"~$install_shared_prog "$dir/$func_stripname_result.$libext" "$destdir/$func_stripname_result.$libext"~test -z "$tstripme" || test -z "$striplib" || $striplib "$destdir/$func_stripname_result.$libext"'
+      postuninstall_cmds='for n in $library_names $old_library; do :; done~func_stripname "" ".so" "$n"~test "$func_stripname_result" = "$n" || func_append rmfiles " $odir/$func_stripname_result.$libext"'
+      # We do not specify a path in Import Files, so LIBPATH fires.
+      shlibpath_overrides_runpath=yes
+      ;;
+    *,no) # both, prefer aix
+      dynamic_linker="AIX lib.a[(]lib.so.V[)], lib.so.V[(]$shared_archive_member_spec.o[)]"
+      library_names_spec='$libname$release.a $libname.a'
+      soname_spec='$libname$release$shared_ext$major'
+      # unpreferred sharedlib libNAME.so.V and symlink libNAME.so need extra handling
+      postinstall_cmds='test -z "$dlname" || $install_shared_prog $dir/$dlname $destdir/$dlname~test -z "$tstripme" || test -z "$striplib" || $striplib $destdir/$dlname~test -n "$linkname" || linkname=$realname~func_stripname "" ".a" "$linkname"~(cd "$destdir" && $LN_S -f $dlname $func_stripname_result.so)'
+      postuninstall_cmds='test -z "$dlname" || func_append rmfiles " $odir/$dlname"~for n in $old_library $library_names; do :; done~func_stripname "" ".a" "$n"~func_append rmfiles " $odir/$func_stripname_result.so"'
+      ;;
+    esac
+    shlibpath_var=LIBPATH
+  fi
+  ;;
+
+amigaos*)
+  case $host_cpu in
+  powerpc)
+    # Since July 2007 AmigaOS4 officially supports .so libraries.
+    # When compiling the executable, add -use-dynld -Lsobjs: to the compileline.
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    ;;
+  m68k)
+    library_names_spec='$libname.ixlibrary $libname.a'
+    # Create ${libname}_ixlibrary.a entries in /sys/libs.
+    finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([[^/]]*\)\.ixlibrary$%\1%'\''`; $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
+    ;;
+  esac
+  ;;
+
+beos*)
+  library_names_spec='$libname$shared_ext'
+  dynamic_linker="$host_os ld.so"
+  shlibpath_var=LIBRARY_PATH
+  ;;
+
+bsdi[[45]]*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
+  sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"
+  # the default ld.so.conf also contains /usr/contrib/lib and
+  # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow
+  # libtool to hard-code these into programs
+  ;;
+
+cygwin* | mingw* | pw32* | cegcc*)
+  version_type=windows
+  shrext_cmds=.dll
+  need_version=no
+  need_lib_prefix=no
+
+  case $GCC,$cc_basename in
+  yes,*)
+    # gcc
+    library_names_spec='$libname.dll.a'
+    # DLL is installed to $(libdir)/../bin by postinstall_cmds
+    postinstall_cmds='base_file=`basename \$file`~
+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~
+      dldir=$destdir/`dirname \$dlpath`~
+      test -d \$dldir || mkdir -p \$dldir~
+      $install_prog $dir/$dlname \$dldir/$dlname~
+      chmod a+x \$dldir/$dlname~
+      if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
+        eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
+      fi'
+    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
+      dlpath=$dir/\$dldll~
+       $RM \$dlpath'
+    shlibpath_overrides_runpath=yes
+
+    case $host_os in
+    cygwin*)
+      # Cygwin DLLs use 'cyg' prefix rather than 'lib'
+      soname_spec='`echo $libname | sed -e 's/^lib/cyg/'``echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext'
+m4_if([$1], [],[
+      sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/lib/w32api"])
+      ;;
+    mingw* | cegcc*)
+      # MinGW DLLs use traditional 'lib' prefix
+      soname_spec='$libname`echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext'
+      ;;
+    pw32*)
+      # pw32 DLLs use 'pw' prefix rather than 'lib'
+      library_names_spec='`echo $libname | sed -e 's/^lib/pw/'``echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext'
+      ;;
+    esac
+    dynamic_linker='Win32 ld.exe'
+    ;;
+
+  *,cl*)
+    # Native MSVC
+    libname_spec='$name'
+    soname_spec='$libname`echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext'
+    library_names_spec='$libname.dll.lib'
+
+    case $build_os in
+    mingw*)
+      sys_lib_search_path_spec=
+      lt_save_ifs=$IFS
+      IFS=';'
+      for lt_path in $LIB
+      do
+        IFS=$lt_save_ifs
+        # Let DOS variable expansion print the short 8.3 style file name.
+        lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"`
+        sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path"
+      done
+      IFS=$lt_save_ifs
+      # Convert to MSYS style.
+      sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([[a-zA-Z]]\\):| /\\1|g' -e 's|^ ||'`
+      ;;
+    cygwin*)
+      # Convert to unix form, then to dos form, then back to unix form
+      # but this time dos style (no spaces!) so that the unix form looks
+      # like /cygdrive/c/PROGRA~1:/cygdr...
+      sys_lib_search_path_spec=`cygpath --path --unix "$LIB"`
+      sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null`
+      sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
+      ;;
+    *)
+      sys_lib_search_path_spec=$LIB
+      if $ECHO "$sys_lib_search_path_spec" | [$GREP ';[c-zC-Z]:/' >/dev/null]; then
+        # It is most probably a Windows format PATH.
+        sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
+      else
+        sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
+      fi
+      # FIXME: find the short name or the path components, as spaces are
+      # common. (e.g. "Program Files" -> "PROGRA~1")
+      ;;
+    esac
+
+    # DLL is installed to $(libdir)/../bin by postinstall_cmds
+    postinstall_cmds='base_file=`basename \$file`~
+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~
+      dldir=$destdir/`dirname \$dlpath`~
+      test -d \$dldir || mkdir -p \$dldir~
+      $install_prog $dir/$dlname \$dldir/$dlname'
+    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
+      dlpath=$dir/\$dldll~
+       $RM \$dlpath'
+    shlibpath_overrides_runpath=yes
+    dynamic_linker='Win32 link.exe'
+    ;;
+
+  *)
+    # Assume MSVC wrapper
+    library_names_spec='$libname`echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext $libname.lib'
+    dynamic_linker='Win32 ld.exe'
+    ;;
+  esac
+  # FIXME: first we should search . and the directory the executable is in
+  shlibpath_var=PATH
+  ;;
+
+darwin* | rhapsody*)
+  dynamic_linker="$host_os dyld"
+  version_type=darwin
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$major$shared_ext $libname$shared_ext'
+  soname_spec='$libname$release$major$shared_ext'
+  shlibpath_overrides_runpath=yes
+  shlibpath_var=DYLD_LIBRARY_PATH
+  shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'
+m4_if([$1], [],[
+  sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/local/lib"])
+  sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'
+  ;;
+
+dgux*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+freebsd* | dragonfly*)
+  # DragonFly does not have aout.  When/if they implement a new
+  # versioning mechanism, adjust this.
+  if test -x /usr/bin/objformat; then
+    objformat=`/usr/bin/objformat`
+  else
+    case $host_os in
+    freebsd[[23]].*) objformat=aout ;;
+    *) objformat=elf ;;
+    esac
+  fi
+  version_type=freebsd-$objformat
+  case $version_type in
+    freebsd-elf*)
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+      soname_spec='$libname$release$shared_ext$major'
+      need_version=no
+      need_lib_prefix=no
+      ;;
+    freebsd-*)
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
+      need_version=yes
+      ;;
+  esac
+  shlibpath_var=LD_LIBRARY_PATH
+  case $host_os in
+  freebsd2.*)
+    shlibpath_overrides_runpath=yes
+    ;;
+  freebsd3.[[01]]* | freebsdelf3.[[01]]*)
+    shlibpath_overrides_runpath=yes
+    hardcode_into_libs=yes
+    ;;
+  freebsd3.[[2-9]]* | freebsdelf3.[[2-9]]* | \
+  freebsd4.[[0-5]] | freebsdelf4.[[0-5]] | freebsd4.1.1 | freebsdelf4.1.1)
+    shlibpath_overrides_runpath=no
+    hardcode_into_libs=yes
+    ;;
+  *) # from 4.6 on, and DragonFly
+    shlibpath_overrides_runpath=yes
+    hardcode_into_libs=yes
+    ;;
+  esac
+  ;;
+
+haiku*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  dynamic_linker="$host_os runtime_loader"
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib'
+  hardcode_into_libs=yes
+  ;;
+
+hpux9* | hpux10* | hpux11*)
+  # Give a soname corresponding to the major version so that dld.sl refuses to
+  # link against other versions.
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=no
+  case $host_cpu in
+  ia64*)
+    shrext_cmds='.so'
+    hardcode_into_libs=yes
+    dynamic_linker="$host_os dld.so"
+    shlibpath_var=LD_LIBRARY_PATH
+    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
+    if test 32 = "$HPUX_IA64_MODE"; then
+      sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
+      sys_lib_dlsearch_path_spec=/usr/lib/hpux32
+    else
+      sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
+      sys_lib_dlsearch_path_spec=/usr/lib/hpux64
+    fi
+    ;;
+  hppa*64*)
+    shrext_cmds='.sl'
+    hardcode_into_libs=yes
+    dynamic_linker="$host_os dld.sl"
+    shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
+    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
+    sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"
+    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+    ;;
+  *)
+    shrext_cmds='.sl'
+    dynamic_linker="$host_os dld.sl"
+    shlibpath_var=SHLIB_PATH
+    shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
+    ;;
+  esac
+  # HP-UX runs *really* slowly unless shared libraries are mode 555, ...
+  postinstall_cmds='chmod 555 $lib'
+  # or fails outright, so override atomically:
+  install_override_mode=555
+  ;;
+
+interix[[3-9]]*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  ;;
+
+irix5* | irix6* | nonstopux*)
+  case $host_os in
+    nonstopux*) version_type=nonstopux ;;
+    *)
+	if test yes = "$lt_cv_prog_gnu_ld"; then
+		version_type=linux # correct to gnu/linux during the next big refactor
+	else
+		version_type=irix
+	fi ;;
+  esac
+  need_lib_prefix=no
+  need_version=no
+  soname_spec='$libname$release$shared_ext$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$release$shared_ext $libname$shared_ext'
+  case $host_os in
+  irix5* | nonstopux*)
+    libsuff= shlibsuff=
+    ;;
+  *)
+    case $LD in # libtool.m4 will add one of these switches to LD
+    *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")
+      libsuff= shlibsuff= libmagic=32-bit;;
+    *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")
+      libsuff=32 shlibsuff=N32 libmagic=N32;;
+    *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")
+      libsuff=64 shlibsuff=64 libmagic=64-bit;;
+    *) libsuff= shlibsuff= libmagic=never-match;;
+    esac
+    ;;
+  esac
+  shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
+  shlibpath_overrides_runpath=no
+  sys_lib_search_path_spec="/usr/lib$libsuff /lib$libsuff /usr/local/lib$libsuff"
+  sys_lib_dlsearch_path_spec="/usr/lib$libsuff /lib$libsuff"
+  hardcode_into_libs=yes
+  ;;
+
+# No shared lib support for Linux oldld, aout, or coff.
+linux*oldld* | linux*aout* | linux*coff*)
+  dynamic_linker=no
+  ;;
+
+linux*android*)
+  version_type=none # Android doesn't support versioned libraries.
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext'
+  soname_spec='$libname$release$shared_ext'
+  finish_cmds=
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+
+  # This implies no fast_install, which is unacceptable.
+  # Some rework will be needed to allow for fast_install
+  # before this can be enabled.
+  hardcode_into_libs=yes
+
+  dynamic_linker='Android linker'
+  # Don't embed -rpath directories since the linker doesn't support them.
+  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+  ;;
+
+# This must be glibc/ELF.
+linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+
+  # Some binutils ld are patched to set DT_RUNPATH
+  AC_CACHE_VAL([lt_cv_shlibpath_overrides_runpath],
+    [lt_cv_shlibpath_overrides_runpath=no
+    save_LDFLAGS=$LDFLAGS
+    save_libdir=$libdir
+    eval "libdir=/foo; wl=\"$_LT_TAGVAR(lt_prog_compiler_wl, $1)\"; \
+	 LDFLAGS=\"\$LDFLAGS $_LT_TAGVAR(hardcode_libdir_flag_spec, $1)\""
+    AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])],
+      [AS_IF([ ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null],
+	 [lt_cv_shlibpath_overrides_runpath=yes])])
+    LDFLAGS=$save_LDFLAGS
+    libdir=$save_libdir
+    ])
+  shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath
+
+  # This implies no fast_install, which is unacceptable.
+  # Some rework will be needed to allow for fast_install
+  # before this can be enabled.
+  hardcode_into_libs=yes
+
+  # Ideally, we could use ldconfig to report *all* directores which are
+  # searched for libraries, however this is still not possible.  Aside from not
+  # being certain /sbin/ldconfig is available, command
+  # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64,
+  # even though it is searched at run-time.  Try to do the best guess by
+  # appending ld.so.conf contents (and includes) to the search path.
+  if test -f /etc/ld.so.conf; then
+    lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \[$]2)); skip = 1; } { if (!skip) print \[$]0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[	 ]*hwcap[	 ]/d;s/[:,	]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '`
+    sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
+  fi
+
+  # We used to test for /lib/ld.so.1 and disable shared libraries on
+  # powerpc, because MkLinux only supported shared libraries with the
+  # GNU dynamic linker.  Since this was broken with cross compilers,
+  # most powerpc-linux boxes support dynamic linking these days and
+  # people can always --disable-shared, the test was removed, and we
+  # assume the GNU/Linux dynamic linker is in use.
+  dynamic_linker='GNU/Linux ld.so'
+  ;;
+
+netbsd*)
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=no
+  if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
+    finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+    dynamic_linker='NetBSD (a.out) ld.so'
+  else
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
+    dynamic_linker='NetBSD ld.elf_so'
+  fi
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  ;;
+
+newsos6)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  ;;
+
+*nto* | *qnx*)
+  version_type=qnx
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  dynamic_linker='ldqnx.so'
+  ;;
+
+openbsd* | bitrig*)
+  version_type=sunos
+  sys_lib_dlsearch_path_spec=/usr/lib
+  need_lib_prefix=no
+  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then
+    need_version=no
+  else
+    need_version=yes
+  fi
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  ;;
+
+os2*)
+  libname_spec='$name'
+  version_type=windows
+  shrext_cmds=.dll
+  need_version=no
+  need_lib_prefix=no
+  # OS/2 can only load a DLL with a base name of 8 characters or less.
+  soname_spec='`test -n "$os2dllname" && libname="$os2dllname";
+    v=$($ECHO $release$versuffix | tr -d .-);
+    n=$($ECHO $libname | cut -b -$((8 - ${#v})) | tr . _);
+    $ECHO $n$v`$shared_ext'
+  library_names_spec='${libname}_dll.$libext'
+  dynamic_linker='OS/2 ld.exe'
+  shlibpath_var=BEGINLIBPATH
+  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
+  sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+  postinstall_cmds='base_file=`basename \$file`~
+    dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; $ECHO \$dlname'\''`~
+    dldir=$destdir/`dirname \$dlpath`~
+    test -d \$dldir || mkdir -p \$dldir~
+    $install_prog $dir/$dlname \$dldir/$dlname~
+    chmod a+x \$dldir/$dlname~
+    if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
+      eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
+    fi'
+  postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; $ECHO \$dlname'\''`~
+    dlpath=$dir/\$dldll~
+    $RM \$dlpath'
+  ;;
+
+osf3* | osf4* | osf5*)
+  version_type=osf
+  need_lib_prefix=no
+  need_version=no
+  soname_spec='$libname$release$shared_ext$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  shlibpath_var=LD_LIBRARY_PATH
+  sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
+  sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+  ;;
+
+rdos*)
+  dynamic_linker=no
+  ;;
+
+solaris*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  # ldd complains unless libraries are executable
+  postinstall_cmds='chmod +x $lib'
+  ;;
+
+sunos4*)
+  version_type=sunos
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
+  finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  if test yes = "$with_gnu_ld"; then
+    need_lib_prefix=no
+  fi
+  need_version=yes
+  ;;
+
+sysv4 | sysv4.3*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  case $host_vendor in
+    sni)
+      shlibpath_overrides_runpath=no
+      need_lib_prefix=no
+      runpath_var=LD_RUN_PATH
+      ;;
+    siemens)
+      need_lib_prefix=no
+      ;;
+    motorola)
+      need_lib_prefix=no
+      need_version=no
+      shlibpath_overrides_runpath=no
+      sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'
+      ;;
+  esac
+  ;;
+
+sysv4*MP*)
+  if test -d /usr/nec; then
+    version_type=linux # correct to gnu/linux during the next big refactor
+    library_names_spec='$libname$shared_ext.$versuffix $libname$shared_ext.$major $libname$shared_ext'
+    soname_spec='$libname$shared_ext.$major'
+    shlibpath_var=LD_LIBRARY_PATH
+  fi
+  ;;
+
+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
+  version_type=sco
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  if test yes = "$with_gnu_ld"; then
+    sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'
+  else
+    sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'
+    case $host_os in
+      sco3.2v5*)
+        sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"
+	;;
+    esac
+  fi
+  sys_lib_dlsearch_path_spec='/usr/lib'
+  ;;
+
+tpf*)
+  # TPF is a cross-target only.  Preferred cross-host = GNU/Linux.
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  ;;
+
+uts4*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+*)
+  dynamic_linker=no
+  ;;
+esac
+AC_MSG_RESULT([$dynamic_linker])
+test no = "$dynamic_linker" && can_build_shared=no
+
+variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
+if test yes = "$GCC"; then
+  variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
+fi
+
+if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then
+  sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec
+fi
+
+if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then
+  sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec
+fi
+
+# remember unaugmented sys_lib_dlsearch_path content for libtool script decls...
+configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec
+
+# ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code
+func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH"
+
+# to be used as default LT_SYS_LIBRARY_PATH value in generated libtool
+configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH
+
+_LT_DECL([], [variables_saved_for_relink], [1],
+    [Variables whose values should be saved in libtool wrapper scripts and
+    restored at link time])
+_LT_DECL([], [need_lib_prefix], [0],
+    [Do we need the "lib" prefix for modules?])
+_LT_DECL([], [need_version], [0], [Do we need a version for libraries?])
+_LT_DECL([], [version_type], [0], [Library versioning type])
+_LT_DECL([], [runpath_var], [0],  [Shared library runtime path variable])
+_LT_DECL([], [shlibpath_var], [0],[Shared library path variable])
+_LT_DECL([], [shlibpath_overrides_runpath], [0],
+    [Is shlibpath searched before the hard-coded library search path?])
+_LT_DECL([], [libname_spec], [1], [Format of library name prefix])
+_LT_DECL([], [library_names_spec], [1],
+    [[List of archive names.  First name is the real one, the rest are links.
+    The last name is the one that the linker finds with -lNAME]])
+_LT_DECL([], [soname_spec], [1],
+    [[The coded name of the library, if different from the real name]])
+_LT_DECL([], [install_override_mode], [1],
+    [Permission mode override for installation of shared libraries])
+_LT_DECL([], [postinstall_cmds], [2],
+    [Command to use after installation of a shared archive])
+_LT_DECL([], [postuninstall_cmds], [2],
+    [Command to use after uninstallation of a shared archive])
+_LT_DECL([], [finish_cmds], [2],
+    [Commands used to finish a libtool library installation in a directory])
+_LT_DECL([], [finish_eval], [1],
+    [[As "finish_cmds", except a single script fragment to be evaled but
+    not shown]])
+_LT_DECL([], [hardcode_into_libs], [0],
+    [Whether we should hardcode library paths into libraries])
+_LT_DECL([], [sys_lib_search_path_spec], [2],
+    [Compile-time system search path for libraries])
+_LT_DECL([sys_lib_dlsearch_path_spec], [configure_time_dlsearch_path], [2],
+    [Detected run-time system search path for libraries])
+_LT_DECL([], [configure_time_lt_sys_library_path], [2],
+    [Explicit LT_SYS_LIBRARY_PATH set during ./configure time])
+])# _LT_SYS_DYNAMIC_LINKER
+
+
+# _LT_PATH_TOOL_PREFIX(TOOL)
+# --------------------------
+# find a file program that can recognize shared library
+AC_DEFUN([_LT_PATH_TOOL_PREFIX],
+[m4_require([_LT_DECL_EGREP])dnl
+AC_MSG_CHECKING([for $1])
+AC_CACHE_VAL(lt_cv_path_MAGIC_CMD,
+[case $MAGIC_CMD in
+[[\\/*] |  ?:[\\/]*])
+  lt_cv_path_MAGIC_CMD=$MAGIC_CMD # Let the user override the test with a path.
+  ;;
+*)
+  lt_save_MAGIC_CMD=$MAGIC_CMD
+  lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
+dnl $ac_dummy forces splitting on constant user-supplied paths.
+dnl POSIX.2 word splitting is done only on the output of word expansions,
+dnl not every word.  This closes a longstanding sh security hole.
+  ac_dummy="m4_if([$2], , $PATH, [$2])"
+  for ac_dir in $ac_dummy; do
+    IFS=$lt_save_ifs
+    test -z "$ac_dir" && ac_dir=.
+    if test -f "$ac_dir/$1"; then
+      lt_cv_path_MAGIC_CMD=$ac_dir/"$1"
+      if test -n "$file_magic_test_file"; then
+	case $deplibs_check_method in
+	"file_magic "*)
+	  file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
+	  MAGIC_CMD=$lt_cv_path_MAGIC_CMD
+	  if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
+	    $EGREP "$file_magic_regex" > /dev/null; then
+	    :
+	  else
+	    cat <<_LT_EOF 1>&2
+
+*** Warning: the command libtool uses to detect shared libraries,
+*** $file_magic_cmd, produces output that libtool cannot recognize.
+*** The result is that libtool may fail to recognize shared libraries
+*** as such.  This will affect the creation of libtool libraries that
+*** depend on shared libraries, but programs linked with such libtool
+*** libraries will work regardless of this problem.  Nevertheless, you
+*** may want to report the problem to your system manager and/or to
+*** bug-libtool@gnu.org
+
+_LT_EOF
+	  fi ;;
+	esac
+      fi
+      break
+    fi
+  done
+  IFS=$lt_save_ifs
+  MAGIC_CMD=$lt_save_MAGIC_CMD
+  ;;
+esac])
+MAGIC_CMD=$lt_cv_path_MAGIC_CMD
+if test -n "$MAGIC_CMD"; then
+  AC_MSG_RESULT($MAGIC_CMD)
+else
+  AC_MSG_RESULT(no)
+fi
+_LT_DECL([], [MAGIC_CMD], [0],
+	 [Used to examine libraries when file_magic_cmd begins with "file"])dnl
+])# _LT_PATH_TOOL_PREFIX
+
+# Old name:
+AU_ALIAS([AC_PATH_TOOL_PREFIX], [_LT_PATH_TOOL_PREFIX])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_PATH_TOOL_PREFIX], [])
+
+
+# _LT_PATH_MAGIC
+# --------------
+# find a file program that can recognize a shared library
+m4_defun([_LT_PATH_MAGIC],
+[_LT_PATH_TOOL_PREFIX(${ac_tool_prefix}file, /usr/bin$PATH_SEPARATOR$PATH)
+if test -z "$lt_cv_path_MAGIC_CMD"; then
+  if test -n "$ac_tool_prefix"; then
+    _LT_PATH_TOOL_PREFIX(file, /usr/bin$PATH_SEPARATOR$PATH)
+  else
+    MAGIC_CMD=:
+  fi
+fi
+])# _LT_PATH_MAGIC
+
+
+# LT_PATH_LD
+# ----------
+# find the pathname to the GNU or non-GNU linker
+AC_DEFUN([LT_PATH_LD],
+[AC_REQUIRE([AC_PROG_CC])dnl
+AC_REQUIRE([AC_CANONICAL_HOST])dnl
+AC_REQUIRE([AC_CANONICAL_BUILD])dnl
+m4_require([_LT_DECL_SED])dnl
+m4_require([_LT_DECL_EGREP])dnl
+m4_require([_LT_PROG_ECHO_BACKSLASH])dnl
+
+AC_ARG_WITH([gnu-ld],
+    [AS_HELP_STRING([--with-gnu-ld],
+	[assume the C compiler uses GNU ld @<:@default=no@:>@])],
+    [test no = "$withval" || with_gnu_ld=yes],
+    [with_gnu_ld=no])dnl
+
+ac_prog=ld
+if test yes = "$GCC"; then
+  # Check if gcc -print-prog-name=ld gives a path.
+  AC_MSG_CHECKING([for ld used by $CC])
+  case $host in
+  *-*-mingw*)
+    # gcc leaves a trailing carriage return, which upsets mingw
+    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
+  *)
+    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
+  esac
+  case $ac_prog in
+    # Accept absolute paths.
+    [[\\/]]* | ?:[[\\/]]*)
+      re_direlt='/[[^/]][[^/]]*/\.\./'
+      # Canonicalize the pathname of ld
+      ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'`
+      while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do
+	ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"`
+      done
+      test -z "$LD" && LD=$ac_prog
+      ;;
+  "")
+    # If it fails, then pretend we aren't using GCC.
+    ac_prog=ld
+    ;;
+  *)
+    # If it is relative, then search for the first ld in PATH.
+    with_gnu_ld=unknown
+    ;;
+  esac
+elif test yes = "$with_gnu_ld"; then
+  AC_MSG_CHECKING([for GNU ld])
+else
+  AC_MSG_CHECKING([for non-GNU ld])
+fi
+AC_CACHE_VAL(lt_cv_path_LD,
+[if test -z "$LD"; then
+  lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
+  for ac_dir in $PATH; do
+    IFS=$lt_save_ifs
+    test -z "$ac_dir" && ac_dir=.
+    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
+      lt_cv_path_LD=$ac_dir/$ac_prog
+      # Check to see if the program is GNU ld.  I'd rather use --version,
+      # but apparently some variants of GNU ld only accept -v.
+      # Break only if it was the GNU/non-GNU ld that we prefer.
+      case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
+      *GNU* | *'with BFD'*)
+	test no != "$with_gnu_ld" && break
+	;;
+      *)
+	test yes != "$with_gnu_ld" && break
+	;;
+      esac
+    fi
+  done
+  IFS=$lt_save_ifs
+else
+  lt_cv_path_LD=$LD # Let the user override the test with a path.
+fi])
+LD=$lt_cv_path_LD
+if test -n "$LD"; then
+  AC_MSG_RESULT($LD)
+else
+  AC_MSG_RESULT(no)
+fi
+test -z "$LD" && AC_MSG_ERROR([no acceptable ld found in \$PATH])
+_LT_PATH_LD_GNU
+AC_SUBST([LD])
+
+_LT_TAGDECL([], [LD], [1], [The linker used to build libraries])
+])# LT_PATH_LD
+
+# Old names:
+AU_ALIAS([AM_PROG_LD], [LT_PATH_LD])
+AU_ALIAS([AC_PROG_LD], [LT_PATH_LD])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AM_PROG_LD], [])
+dnl AC_DEFUN([AC_PROG_LD], [])
+
+
+# _LT_PATH_LD_GNU
+#- --------------
+m4_defun([_LT_PATH_LD_GNU],
+[AC_CACHE_CHECK([if the linker ($LD) is GNU ld], lt_cv_prog_gnu_ld,
+[# I'd rather use --version here, but apparently some GNU lds only accept -v.
+case `$LD -v 2>&1 </dev/null` in
+*GNU* | *'with BFD'*)
+  lt_cv_prog_gnu_ld=yes
+  ;;
+*)
+  lt_cv_prog_gnu_ld=no
+  ;;
+esac])
+with_gnu_ld=$lt_cv_prog_gnu_ld
+])# _LT_PATH_LD_GNU
+
+
+# _LT_CMD_RELOAD
+# --------------
+# find reload flag for linker
+#   -- PORTME Some linkers may need a different reload flag.
+m4_defun([_LT_CMD_RELOAD],
+[AC_CACHE_CHECK([for $LD option to reload object files],
+  lt_cv_ld_reload_flag,
+  [lt_cv_ld_reload_flag='-r'])
+reload_flag=$lt_cv_ld_reload_flag
+case $reload_flag in
+"" | " "*) ;;
+*) reload_flag=" $reload_flag" ;;
+esac
+reload_cmds='$LD$reload_flag -o $output$reload_objs'
+case $host_os in
+  cygwin* | mingw* | pw32* | cegcc*)
+    if test yes != "$GCC"; then
+      reload_cmds=false
+    fi
+    ;;
+  darwin*)
+    if test yes = "$GCC"; then
+      reload_cmds='$LTCC $LTCFLAGS -nostdlib $wl-r -o $output$reload_objs'
+    else
+      reload_cmds='$LD$reload_flag -o $output$reload_objs'
+    fi
+    ;;
+esac
+_LT_TAGDECL([], [reload_flag], [1], [How to create reloadable object files])dnl
+_LT_TAGDECL([], [reload_cmds], [2])dnl
+])# _LT_CMD_RELOAD
+
+
+# _LT_PATH_DD
+# -----------
+# find a working dd
+m4_defun([_LT_PATH_DD],
+[AC_CACHE_CHECK([for a working dd], [ac_cv_path_lt_DD],
+[printf 0123456789abcdef0123456789abcdef >conftest.i
+cat conftest.i conftest.i >conftest2.i
+: ${lt_DD:=$DD}
+AC_PATH_PROGS_FEATURE_CHECK([lt_DD], [dd],
+[if "$ac_path_lt_DD" bs=32 count=1 <conftest2.i >conftest.out 2>/dev/null; then
+  cmp -s conftest.i conftest.out \
+  && ac_cv_path_lt_DD="$ac_path_lt_DD" ac_path_lt_DD_found=:
+fi])
+rm -f conftest.i conftest2.i conftest.out])
+])# _LT_PATH_DD
+
+
+# _LT_CMD_TRUNCATE
+# ----------------
+# find command to truncate a binary pipe
+m4_defun([_LT_CMD_TRUNCATE],
+[m4_require([_LT_PATH_DD])
+AC_CACHE_CHECK([how to truncate binary pipes], [lt_cv_truncate_bin],
+[printf 0123456789abcdef0123456789abcdef >conftest.i
+cat conftest.i conftest.i >conftest2.i
+lt_cv_truncate_bin=
+if "$ac_cv_path_lt_DD" bs=32 count=1 <conftest2.i >conftest.out 2>/dev/null; then
+  cmp -s conftest.i conftest.out \
+  && lt_cv_truncate_bin="$ac_cv_path_lt_DD bs=4096 count=1"
+fi
+rm -f conftest.i conftest2.i conftest.out
+test -z "$lt_cv_truncate_bin" && lt_cv_truncate_bin="$SED -e 4q"])
+_LT_DECL([lt_truncate_bin], [lt_cv_truncate_bin], [1],
+  [Command to truncate a binary pipe])
+])# _LT_CMD_TRUNCATE
+
+
+# _LT_CHECK_MAGIC_METHOD
+# ----------------------
+# how to check for library dependencies
+#  -- PORTME fill in with the dynamic library characteristics
+m4_defun([_LT_CHECK_MAGIC_METHOD],
+[m4_require([_LT_DECL_EGREP])
+m4_require([_LT_DECL_OBJDUMP])
+AC_CACHE_CHECK([how to recognize dependent libraries],
+lt_cv_deplibs_check_method,
+[lt_cv_file_magic_cmd='$MAGIC_CMD'
+lt_cv_file_magic_test_file=
+lt_cv_deplibs_check_method='unknown'
+# Need to set the preceding variable on all platforms that support
+# interlibrary dependencies.
+# 'none' -- dependencies not supported.
+# 'unknown' -- same as none, but documents that we really don't know.
+# 'pass_all' -- all dependencies passed with no checks.
+# 'test_compile' -- check by making test program.
+# 'file_magic [[regex]]' -- check by looking for files in library path
+# that responds to the $file_magic_cmd with a given extended regex.
+# If you have 'file' or equivalent on your system and you're not sure
+# whether 'pass_all' will *always* work, you probably want this one.
+
+case $host_os in
+aix[[4-9]]*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+beos*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+bsdi[[45]]*)
+  lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib)'
+  lt_cv_file_magic_cmd='/usr/bin/file -L'
+  lt_cv_file_magic_test_file=/shlib/libc.so
+  ;;
+
+cygwin*)
+  # func_win32_libid is a shell function defined in ltmain.sh
+  lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
+  lt_cv_file_magic_cmd='func_win32_libid'
+  ;;
+
+mingw* | pw32*)
+  # Base MSYS/MinGW do not provide the 'file' command needed by
+  # func_win32_libid shell function, so use a weaker test based on 'objdump',
+  # unless we find 'file', for example because we are cross-compiling.
+  if ( file / ) >/dev/null 2>&1; then
+    lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
+    lt_cv_file_magic_cmd='func_win32_libid'
+  else
+    # Keep this pattern in sync with the one in func_win32_libid.
+    lt_cv_deplibs_check_method='file_magic file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)'
+    lt_cv_file_magic_cmd='$OBJDUMP -f'
+  fi
+  ;;
+
+cegcc*)
+  # use the weaker test based on 'objdump'. See mingw*.
+  lt_cv_deplibs_check_method='file_magic file format pe-arm-.*little(.*architecture: arm)?'
+  lt_cv_file_magic_cmd='$OBJDUMP -f'
+  ;;
+
+darwin* | rhapsody*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+freebsd* | dragonfly*)
+  if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
+    case $host_cpu in
+    i*86 )
+      # Not sure whether the presence of OpenBSD here was a mistake.
+      # Let's accept both of them until this is cleared up.
+      lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[[3-9]]86 (compact )?demand paged shared library'
+      lt_cv_file_magic_cmd=/usr/bin/file
+      lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
+      ;;
+    esac
+  else
+    lt_cv_deplibs_check_method=pass_all
+  fi
+  ;;
+
+haiku*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+hpux10.20* | hpux11*)
+  lt_cv_file_magic_cmd=/usr/bin/file
+  case $host_cpu in
+  ia64*)
+    lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|ELF-[[0-9]][[0-9]]) shared object file - IA64'
+    lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
+    ;;
+  hppa*64*)
+    [lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF[ -][0-9][0-9])(-bit)?( [LM]SB)? shared object( file)?[, -]* PA-RISC [0-9]\.[0-9]']
+    lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl
+    ;;
+  *)
+    lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|PA-RISC[[0-9]]\.[[0-9]]) shared library'
+    lt_cv_file_magic_test_file=/usr/lib/libc.sl
+    ;;
+  esac
+  ;;
+
+interix[[3-9]]*)
+  # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here
+  lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|\.a)$'
+  ;;
+
+irix5* | irix6* | nonstopux*)
+  case $LD in
+  *-32|*"-32 ") libmagic=32-bit;;
+  *-n32|*"-n32 ") libmagic=N32;;
+  *-64|*"-64 ") libmagic=64-bit;;
+  *) libmagic=never-match;;
+  esac
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+# This must be glibc/ELF.
+linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+netbsd*)
+  if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
+    lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$'
+  else
+    lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|_pic\.a)$'
+  fi
+  ;;
+
+newos6*)
+  lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (executable|dynamic lib)'
+  lt_cv_file_magic_cmd=/usr/bin/file
+  lt_cv_file_magic_test_file=/usr/lib/libnls.so
+  ;;
+
+*nto* | *qnx*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+openbsd* | bitrig*)
+  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then
+    lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|\.so|_pic\.a)$'
+  else
+    lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$'
+  fi
+  ;;
+
+osf3* | osf4* | osf5*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+rdos*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+solaris*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+sysv4 | sysv4.3*)
+  case $host_vendor in
+  motorola)
+    lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib) M[[0-9]][[0-9]]* Version [[0-9]]'
+    lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
+    ;;
+  ncr)
+    lt_cv_deplibs_check_method=pass_all
+    ;;
+  sequent)
+    lt_cv_file_magic_cmd='/bin/file'
+    lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB (shared object|dynamic lib )'
+    ;;
+  sni)
+    lt_cv_file_magic_cmd='/bin/file'
+    lt_cv_deplibs_check_method="file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB dynamic lib"
+    lt_cv_file_magic_test_file=/lib/libc.so
+    ;;
+  siemens)
+    lt_cv_deplibs_check_method=pass_all
+    ;;
+  pc)
+    lt_cv_deplibs_check_method=pass_all
+    ;;
+  esac
+  ;;
+
+tpf*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+os2*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+esac
+])
+
+file_magic_glob=
+want_nocaseglob=no
+if test "$build" = "$host"; then
+  case $host_os in
+  mingw* | pw32*)
+    if ( shopt | grep nocaseglob ) >/dev/null 2>&1; then
+      want_nocaseglob=yes
+    else
+      file_magic_glob=`echo aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ | $SED -e "s/\(..\)/s\/[[\1]]\/[[\1]]\/g;/g"`
+    fi
+    ;;
+  esac
+fi
+
+file_magic_cmd=$lt_cv_file_magic_cmd
+deplibs_check_method=$lt_cv_deplibs_check_method
+test -z "$deplibs_check_method" && deplibs_check_method=unknown
+
+_LT_DECL([], [deplibs_check_method], [1],
+    [Method to check whether dependent libraries are shared objects])
+_LT_DECL([], [file_magic_cmd], [1],
+    [Command to use when deplibs_check_method = "file_magic"])
+_LT_DECL([], [file_magic_glob], [1],
+    [How to find potential files when deplibs_check_method = "file_magic"])
+_LT_DECL([], [want_nocaseglob], [1],
+    [Find potential files using nocaseglob when deplibs_check_method = "file_magic"])
+])# _LT_CHECK_MAGIC_METHOD
+
+
+# LT_PATH_NM
+# ----------
+# find the pathname to a BSD- or MS-compatible name lister
+AC_DEFUN([LT_PATH_NM],
+[AC_REQUIRE([AC_PROG_CC])dnl
+AC_CACHE_CHECK([for BSD- or MS-compatible name lister (nm)], lt_cv_path_NM,
+[if test -n "$NM"; then
+  # Let the user override the test.
+  lt_cv_path_NM=$NM
+else
+  lt_nm_to_check=${ac_tool_prefix}nm
+  if test -n "$ac_tool_prefix" && test "$build" = "$host"; then
+    lt_nm_to_check="$lt_nm_to_check nm"
+  fi
+  for lt_tmp_nm in $lt_nm_to_check; do
+    lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
+    for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do
+      IFS=$lt_save_ifs
+      test -z "$ac_dir" && ac_dir=.
+      tmp_nm=$ac_dir/$lt_tmp_nm
+      if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext"; then
+	# Check to see if the nm accepts a BSD-compat flag.
+	# Adding the 'sed 1q' prevents false positives on HP-UX, which says:
+	#   nm: unknown option "B" ignored
+	# Tru64's nm complains that /dev/null is an invalid object file
+	# MSYS converts /dev/null to NUL, MinGW nm treats NUL as empty
+	case $build_os in
+	mingw*) lt_bad_file=conftest.nm/nofile ;;
+	*) lt_bad_file=/dev/null ;;
+	esac
+	case `"$tmp_nm" -B $lt_bad_file 2>&1 | sed '1q'` in
+	*$lt_bad_file* | *'Invalid file or object type'*)
+	  lt_cv_path_NM="$tmp_nm -B"
+	  break 2
+	  ;;
+	*)
+	  case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in
+	  */dev/null*)
+	    lt_cv_path_NM="$tmp_nm -p"
+	    break 2
+	    ;;
+	  *)
+	    lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
+	    continue # so that we can try to find one that supports BSD flags
+	    ;;
+	  esac
+	  ;;
+	esac
+      fi
+    done
+    IFS=$lt_save_ifs
+  done
+  : ${lt_cv_path_NM=no}
+fi])
+if test no != "$lt_cv_path_NM"; then
+  NM=$lt_cv_path_NM
+else
+  # Didn't find any BSD compatible name lister, look for dumpbin.
+  if test -n "$DUMPBIN"; then :
+    # Let the user override the test.
+  else
+    AC_CHECK_TOOLS(DUMPBIN, [dumpbin "link -dump"], :)
+    case `$DUMPBIN -symbols -headers /dev/null 2>&1 | sed '1q'` in
+    *COFF*)
+      DUMPBIN="$DUMPBIN -symbols -headers"
+      ;;
+    *)
+      DUMPBIN=:
+      ;;
+    esac
+  fi
+  AC_SUBST([DUMPBIN])
+  if test : != "$DUMPBIN"; then
+    NM=$DUMPBIN
+  fi
+fi
+test -z "$NM" && NM=nm
+AC_SUBST([NM])
+_LT_DECL([], [NM], [1], [A BSD- or MS-compatible name lister])dnl
+
+AC_CACHE_CHECK([the name lister ($NM) interface], [lt_cv_nm_interface],
+  [lt_cv_nm_interface="BSD nm"
+  echo "int some_variable = 0;" > conftest.$ac_ext
+  (eval echo "\"\$as_me:$LINENO: $ac_compile\"" >&AS_MESSAGE_LOG_FD)
+  (eval "$ac_compile" 2>conftest.err)
+  cat conftest.err >&AS_MESSAGE_LOG_FD
+  (eval echo "\"\$as_me:$LINENO: $NM \\\"conftest.$ac_objext\\\"\"" >&AS_MESSAGE_LOG_FD)
+  (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out)
+  cat conftest.err >&AS_MESSAGE_LOG_FD
+  (eval echo "\"\$as_me:$LINENO: output\"" >&AS_MESSAGE_LOG_FD)
+  cat conftest.out >&AS_MESSAGE_LOG_FD
+  if $GREP 'External.*some_variable' conftest.out > /dev/null; then
+    lt_cv_nm_interface="MS dumpbin"
+  fi
+  rm -f conftest*])
+])# LT_PATH_NM
+
+# Old names:
+AU_ALIAS([AM_PROG_NM], [LT_PATH_NM])
+AU_ALIAS([AC_PROG_NM], [LT_PATH_NM])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AM_PROG_NM], [])
+dnl AC_DEFUN([AC_PROG_NM], [])
+
+# _LT_CHECK_SHAREDLIB_FROM_LINKLIB
+# --------------------------------
+# how to determine the name of the shared library
+# associated with a specific link library.
+#  -- PORTME fill in with the dynamic library characteristics
+m4_defun([_LT_CHECK_SHAREDLIB_FROM_LINKLIB],
+[m4_require([_LT_DECL_EGREP])
+m4_require([_LT_DECL_OBJDUMP])
+m4_require([_LT_DECL_DLLTOOL])
+AC_CACHE_CHECK([how to associate runtime and link libraries],
+lt_cv_sharedlib_from_linklib_cmd,
+[lt_cv_sharedlib_from_linklib_cmd='unknown'
+
+case $host_os in
+cygwin* | mingw* | pw32* | cegcc*)
+  # two different shell functions defined in ltmain.sh;
+  # decide which one to use based on capabilities of $DLLTOOL
+  case `$DLLTOOL --help 2>&1` in
+  *--identify-strict*)
+    lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib
+    ;;
+  *)
+    lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib_fallback
+    ;;
+  esac
+  ;;
+*)
+  # fallback: assume linklib IS sharedlib
+  lt_cv_sharedlib_from_linklib_cmd=$ECHO
+  ;;
+esac
+])
+sharedlib_from_linklib_cmd=$lt_cv_sharedlib_from_linklib_cmd
+test -z "$sharedlib_from_linklib_cmd" && sharedlib_from_linklib_cmd=$ECHO
+
+_LT_DECL([], [sharedlib_from_linklib_cmd], [1],
+    [Command to associate shared and link libraries])
+])# _LT_CHECK_SHAREDLIB_FROM_LINKLIB
+
+
+# _LT_PATH_MANIFEST_TOOL
+# ----------------------
+# locate the manifest tool
+m4_defun([_LT_PATH_MANIFEST_TOOL],
+[AC_CHECK_TOOL(MANIFEST_TOOL, mt, :)
+test -z "$MANIFEST_TOOL" && MANIFEST_TOOL=mt
+AC_CACHE_CHECK([if $MANIFEST_TOOL is a manifest tool], [lt_cv_path_mainfest_tool],
+  [lt_cv_path_mainfest_tool=no
+  echo "$as_me:$LINENO: $MANIFEST_TOOL '-?'" >&AS_MESSAGE_LOG_FD
+  $MANIFEST_TOOL '-?' 2>conftest.err > conftest.out
+  cat conftest.err >&AS_MESSAGE_LOG_FD
+  if $GREP 'Manifest Tool' conftest.out > /dev/null; then
+    lt_cv_path_mainfest_tool=yes
+  fi
+  rm -f conftest*])
+if test yes != "$lt_cv_path_mainfest_tool"; then
+  MANIFEST_TOOL=:
+fi
+_LT_DECL([], [MANIFEST_TOOL], [1], [Manifest tool])dnl
+])# _LT_PATH_MANIFEST_TOOL
+
+
+# _LT_DLL_DEF_P([FILE])
+# ---------------------
+# True iff FILE is a Windows DLL '.def' file.
+# Keep in sync with func_dll_def_p in the libtool script
+AC_DEFUN([_LT_DLL_DEF_P],
+[dnl
+  test DEF = "`$SED -n dnl
+    -e '\''s/^[[	 ]]*//'\'' dnl Strip leading whitespace
+    -e '\''/^\(;.*\)*$/d'\'' dnl      Delete empty lines and comments
+    -e '\''s/^\(EXPORTS\|LIBRARY\)\([[	 ]].*\)*$/DEF/p'\'' dnl
+    -e q dnl                          Only consider the first "real" line
+    $1`" dnl
+])# _LT_DLL_DEF_P
+
+
+# LT_LIB_M
+# --------
+# check for math library
+AC_DEFUN([LT_LIB_M],
+[AC_REQUIRE([AC_CANONICAL_HOST])dnl
+LIBM=
+case $host in
+*-*-beos* | *-*-cegcc* | *-*-cygwin* | *-*-haiku* | *-*-pw32* | *-*-darwin*)
+  # These system don't have libm, or don't need it
+  ;;
+*-ncr-sysv4.3*)
+  AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM=-lmw)
+  AC_CHECK_LIB(m, cos, LIBM="$LIBM -lm")
+  ;;
+*)
+  AC_CHECK_LIB(m, cos, LIBM=-lm)
+  ;;
+esac
+AC_SUBST([LIBM])
+])# LT_LIB_M
+
+# Old name:
+AU_ALIAS([AC_CHECK_LIBM], [LT_LIB_M])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_CHECK_LIBM], [])
+
+
+# _LT_COMPILER_NO_RTTI([TAGNAME])
+# -------------------------------
+m4_defun([_LT_COMPILER_NO_RTTI],
+[m4_require([_LT_TAG_COMPILER])dnl
+
+_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=
+
+if test yes = "$GCC"; then
+  case $cc_basename in
+  nvcc*)
+    _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -Xcompiler -fno-builtin' ;;
+  *)
+    _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin' ;;
+  esac
+
+  _LT_COMPILER_OPTION([if $compiler supports -fno-rtti -fno-exceptions],
+    lt_cv_prog_compiler_rtti_exceptions,
+    [-fno-rtti -fno-exceptions], [],
+    [_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)="$_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1) -fno-rtti -fno-exceptions"])
+fi
+_LT_TAGDECL([no_builtin_flag], [lt_prog_compiler_no_builtin_flag], [1],
+	[Compiler flag to turn off builtin functions])
+])# _LT_COMPILER_NO_RTTI
+
+
+# _LT_CMD_GLOBAL_SYMBOLS
+# ----------------------
+m4_defun([_LT_CMD_GLOBAL_SYMBOLS],
+[AC_REQUIRE([AC_CANONICAL_HOST])dnl
+AC_REQUIRE([AC_PROG_CC])dnl
+AC_REQUIRE([AC_PROG_AWK])dnl
+AC_REQUIRE([LT_PATH_NM])dnl
+AC_REQUIRE([LT_PATH_LD])dnl
+m4_require([_LT_DECL_SED])dnl
+m4_require([_LT_DECL_EGREP])dnl
+m4_require([_LT_TAG_COMPILER])dnl
+
+# Check for command to grab the raw symbol name followed by C symbol from nm.
+AC_MSG_CHECKING([command to parse $NM output from $compiler object])
+AC_CACHE_VAL([lt_cv_sys_global_symbol_pipe],
+[
+# These are sane defaults that work on at least a few old systems.
+# [They come from Ultrix.  What could be older than Ultrix?!! ;)]
+
+# Character class describing NM global symbol codes.
+symcode='[[BCDEGRST]]'
+
+# Regexp to match symbols that can be accessed directly from C.
+sympat='\([[_A-Za-z]][[_A-Za-z0-9]]*\)'
+
+# Define system-specific variables.
+case $host_os in
+aix*)
+  symcode='[[BCDT]]'
+  ;;
+cygwin* | mingw* | pw32* | cegcc*)
+  symcode='[[ABCDGISTW]]'
+  ;;
+hpux*)
+  if test ia64 = "$host_cpu"; then
+    symcode='[[ABCDEGRST]]'
+  fi
+  ;;
+irix* | nonstopux*)
+  symcode='[[BCDEGRST]]'
+  ;;
+osf*)
+  symcode='[[BCDEGQRST]]'
+  ;;
+solaris*)
+  symcode='[[BDRT]]'
+  ;;
+sco3.2v5*)
+  symcode='[[DT]]'
+  ;;
+sysv4.2uw2*)
+  symcode='[[DT]]'
+  ;;
+sysv5* | sco5v6* | unixware* | OpenUNIX*)
+  symcode='[[ABDT]]'
+  ;;
+sysv4)
+  symcode='[[DFNSTU]]'
+  ;;
+esac
+
+# If we're using GNU nm, then use its standard symbol codes.
+case `$NM -V 2>&1` in
+*GNU* | *'with BFD'*)
+  symcode='[[ABCDGIRSTW]]' ;;
+esac
+
+if test "$lt_cv_nm_interface" = "MS dumpbin"; then
+  # Gets list of data symbols to import.
+  lt_cv_sys_global_symbol_to_import="sed -n -e 's/^I .* \(.*\)$/\1/p'"
+  # Adjust the below global symbol transforms to fixup imported variables.
+  lt_cdecl_hook=" -e 's/^I .* \(.*\)$/extern __declspec(dllimport) char \1;/p'"
+  lt_c_name_hook=" -e 's/^I .* \(.*\)$/  {\"\1\", (void *) 0},/p'"
+  lt_c_name_lib_hook="\
+  -e 's/^I .* \(lib.*\)$/  {\"\1\", (void *) 0},/p'\
+  -e 's/^I .* \(.*\)$/  {\"lib\1\", (void *) 0},/p'"
+else
+  # Disable hooks by default.
+  lt_cv_sys_global_symbol_to_import=
+  lt_cdecl_hook=
+  lt_c_name_hook=
+  lt_c_name_lib_hook=
+fi
+
+# Transform an extracted symbol line into a proper C declaration.
+# Some systems (esp. on ia64) link data and code symbols differently,
+# so use this general approach.
+lt_cv_sys_global_symbol_to_cdecl="sed -n"\
+$lt_cdecl_hook\
+" -e 's/^T .* \(.*\)$/extern int \1();/p'"\
+" -e 's/^$symcode$symcode* .* \(.*\)$/extern char \1;/p'"
+
+# Transform an extracted symbol line into symbol name and symbol address
+lt_cv_sys_global_symbol_to_c_name_address="sed -n"\
+$lt_c_name_hook\
+" -e 's/^: \(.*\) .*$/  {\"\1\", (void *) 0},/p'"\
+" -e 's/^$symcode$symcode* .* \(.*\)$/  {\"\1\", (void *) \&\1},/p'"
+
+# Transform an extracted symbol line into symbol name with lib prefix and
+# symbol address.
+lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n"\
+$lt_c_name_lib_hook\
+" -e 's/^: \(.*\) .*$/  {\"\1\", (void *) 0},/p'"\
+" -e 's/^$symcode$symcode* .* \(lib.*\)$/  {\"\1\", (void *) \&\1},/p'"\
+" -e 's/^$symcode$symcode* .* \(.*\)$/  {\"lib\1\", (void *) \&\1},/p'"
+
+# Handle CRLF in mingw tool chain
+opt_cr=
+case $build_os in
+mingw*)
+  opt_cr=`$ECHO 'x\{0,1\}' | tr x '\015'` # option cr in regexp
+  ;;
+esac
+
+# Try without a prefix underscore, then with it.
+for ac_symprfx in "" "_"; do
+
+  # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol.
+  symxfrm="\\1 $ac_symprfx\\2 \\2"
+
+  # Write the raw and C identifiers.
+  if test "$lt_cv_nm_interface" = "MS dumpbin"; then
+    # Fake it for dumpbin and say T for any non-static function,
+    # D for any global variable and I for any imported variable.
+    # Also find C++ and __fastcall symbols from MSVC++,
+    # which start with @ or ?.
+    lt_cv_sys_global_symbol_pipe="$AWK ['"\
+"     {last_section=section; section=\$ 3};"\
+"     /^COFF SYMBOL TABLE/{for(i in hide) delete hide[i]};"\
+"     /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\
+"     /^ *Symbol name *: /{split(\$ 0,sn,\":\"); si=substr(sn[2],2)};"\
+"     /^ *Type *: code/{print \"T\",si,substr(si,length(prfx))};"\
+"     /^ *Type *: data/{print \"I\",si,substr(si,length(prfx))};"\
+"     \$ 0!~/External *\|/{next};"\
+"     / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\
+"     {if(hide[section]) next};"\
+"     {f=\"D\"}; \$ 0~/\(\).*\|/{f=\"T\"};"\
+"     {split(\$ 0,a,/\||\r/); split(a[2],s)};"\
+"     s[1]~/^[@?]/{print f,s[1],s[1]; next};"\
+"     s[1]~prfx {split(s[1],t,\"@\"); print f,t[1],substr(t[1],length(prfx))}"\
+"     ' prfx=^$ac_symprfx]"
+  else
+    lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[[	 ]]\($symcode$symcode*\)[[	 ]][[	 ]]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"
+  fi
+  lt_cv_sys_global_symbol_pipe="$lt_cv_sys_global_symbol_pipe | sed '/ __gnu_lto/d'"
+
+  # Check to see that the pipe works correctly.
+  pipe_works=no
+
+  rm -f conftest*
+  cat > conftest.$ac_ext <<_LT_EOF
+#ifdef __cplusplus
+extern "C" {
+#endif
+char nm_test_var;
+void nm_test_func(void);
+void nm_test_func(void){}
+#ifdef __cplusplus
+}
+#endif
+int main(){nm_test_var='a';nm_test_func();return(0);}
+_LT_EOF
+
+  if AC_TRY_EVAL(ac_compile); then
+    # Now try to grab the symbols.
+    nlist=conftest.nm
+    if AC_TRY_EVAL(NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist) && test -s "$nlist"; then
+      # Try sorting and uniquifying the output.
+      if sort "$nlist" | uniq > "$nlist"T; then
+	mv -f "$nlist"T "$nlist"
+      else
+	rm -f "$nlist"T
+      fi
+
+      # Make sure that we snagged all the symbols we need.
+      if $GREP ' nm_test_var$' "$nlist" >/dev/null; then
+	if $GREP ' nm_test_func$' "$nlist" >/dev/null; then
+	  cat <<_LT_EOF > conftest.$ac_ext
+/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
+#if defined _WIN32 || defined __CYGWIN__ || defined _WIN32_WCE
+/* DATA imports from DLLs on WIN32 can't be const, because runtime
+   relocations are performed -- see ld's documentation on pseudo-relocs.  */
+# define LT@&t@_DLSYM_CONST
+#elif defined __osf__
+/* This system does not cope well with relocations in const data.  */
+# define LT@&t@_DLSYM_CONST
+#else
+# define LT@&t@_DLSYM_CONST const
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+_LT_EOF
+	  # Now generate the symbol file.
+	  eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | $GREP -v main >> conftest.$ac_ext'
+
+	  cat <<_LT_EOF >> conftest.$ac_ext
+
+/* The mapping between symbol names and symbols.  */
+LT@&t@_DLSYM_CONST struct {
+  const char *name;
+  void       *address;
+}
+lt__PROGRAM__LTX_preloaded_symbols[[]] =
+{
+  { "@PROGRAM@", (void *) 0 },
+_LT_EOF
+	  $SED "s/^$symcode$symcode* .* \(.*\)$/  {\"\1\", (void *) \&\1},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext
+	  cat <<\_LT_EOF >> conftest.$ac_ext
+  {0, (void *) 0}
+};
+
+/* This works around a problem in FreeBSD linker */
+#ifdef FREEBSD_WORKAROUND
+static const void *lt_preloaded_setup() {
+  return lt__PROGRAM__LTX_preloaded_symbols;
+}
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+_LT_EOF
+	  # Now try linking the two files.
+	  mv conftest.$ac_objext conftstm.$ac_objext
+	  lt_globsym_save_LIBS=$LIBS
+	  lt_globsym_save_CFLAGS=$CFLAGS
+	  LIBS=conftstm.$ac_objext
+	  CFLAGS="$CFLAGS$_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)"
+	  if AC_TRY_EVAL(ac_link) && test -s conftest$ac_exeext; then
+	    pipe_works=yes
+	  fi
+	  LIBS=$lt_globsym_save_LIBS
+	  CFLAGS=$lt_globsym_save_CFLAGS
+	else
+	  echo "cannot find nm_test_func in $nlist" >&AS_MESSAGE_LOG_FD
+	fi
+      else
+	echo "cannot find nm_test_var in $nlist" >&AS_MESSAGE_LOG_FD
+      fi
+    else
+      echo "cannot run $lt_cv_sys_global_symbol_pipe" >&AS_MESSAGE_LOG_FD
+    fi
+  else
+    echo "$progname: failed program was:" >&AS_MESSAGE_LOG_FD
+    cat conftest.$ac_ext >&5
+  fi
+  rm -rf conftest* conftst*
+
+  # Do not use the global_symbol_pipe unless it works.
+  if test yes = "$pipe_works"; then
+    break
+  else
+    lt_cv_sys_global_symbol_pipe=
+  fi
+done
+])
+if test -z "$lt_cv_sys_global_symbol_pipe"; then
+  lt_cv_sys_global_symbol_to_cdecl=
+fi
+if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then
+  AC_MSG_RESULT(failed)
+else
+  AC_MSG_RESULT(ok)
+fi
+
+# Response file support.
+if test "$lt_cv_nm_interface" = "MS dumpbin"; then
+  nm_file_list_spec='@'
+elif $NM --help 2>/dev/null | grep '[[@]]FILE' >/dev/null; then
+  nm_file_list_spec='@'
+fi
+
+_LT_DECL([global_symbol_pipe], [lt_cv_sys_global_symbol_pipe], [1],
+    [Take the output of nm and produce a listing of raw symbols and C names])
+_LT_DECL([global_symbol_to_cdecl], [lt_cv_sys_global_symbol_to_cdecl], [1],
+    [Transform the output of nm in a proper C declaration])
+_LT_DECL([global_symbol_to_import], [lt_cv_sys_global_symbol_to_import], [1],
+    [Transform the output of nm into a list of symbols to manually relocate])
+_LT_DECL([global_symbol_to_c_name_address],
+    [lt_cv_sys_global_symbol_to_c_name_address], [1],
+    [Transform the output of nm in a C name address pair])
+_LT_DECL([global_symbol_to_c_name_address_lib_prefix],
+    [lt_cv_sys_global_symbol_to_c_name_address_lib_prefix], [1],
+    [Transform the output of nm in a C name address pair when lib prefix is needed])
+_LT_DECL([nm_interface], [lt_cv_nm_interface], [1],
+    [The name lister interface])
+_LT_DECL([], [nm_file_list_spec], [1],
+    [Specify filename containing input files for $NM])
+]) # _LT_CMD_GLOBAL_SYMBOLS
+
+
+# _LT_COMPILER_PIC([TAGNAME])
+# ---------------------------
+m4_defun([_LT_COMPILER_PIC],
+[m4_require([_LT_TAG_COMPILER])dnl
+_LT_TAGVAR(lt_prog_compiler_wl, $1)=
+_LT_TAGVAR(lt_prog_compiler_pic, $1)=
+_LT_TAGVAR(lt_prog_compiler_static, $1)=
+
+m4_if([$1], [CXX], [
+  # C++ specific cases for pic, static, wl, etc.
+  if test yes = "$GXX"; then
+    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+    _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
+
+    case $host_os in
+    aix*)
+      # All AIX code is PIC.
+      if test ia64 = "$host_cpu"; then
+	# AIX 5 now supports IA64 processor
+	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      fi
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+      ;;
+
+    amigaos*)
+      case $host_cpu in
+      powerpc)
+            # see comment about AmigaOS4 .so support
+            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+        ;;
+      m68k)
+            # FIXME: we need at least 68020 code to build shared libraries, but
+            # adding the '-m68020' flag to GCC prevents building anything better,
+            # like '-m68040'.
+            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4'
+        ;;
+      esac
+      ;;
+
+    beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
+      # PIC is the default for these OSes.
+      ;;
+    mingw* | cygwin* | os2* | pw32* | cegcc*)
+      # This hack is so that the source file can tell whether it is being
+      # built for inclusion in a dll (and should export symbols for example).
+      # Although the cygwin gcc ignores -fPIC, still need this for old-style
+      # (--disable-auto-import) libraries
+      m4_if([$1], [GCJ], [],
+	[_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'])
+      case $host_os in
+      os2*)
+	_LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-static'
+	;;
+      esac
+      ;;
+    darwin* | rhapsody*)
+      # PIC is the default on this platform
+      # Common symbols not allowed in MH_DYLIB files
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common'
+      ;;
+    *djgpp*)
+      # DJGPP does not support shared libraries at all
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)=
+      ;;
+    haiku*)
+      # PIC is the default for Haiku.
+      # The "-static" flag exists, but is broken.
+      _LT_TAGVAR(lt_prog_compiler_static, $1)=
+      ;;
+    interix[[3-9]]*)
+      # Interix 3.x gcc -fpic/-fPIC options generate broken code.
+      # Instead, we relocate shared libraries at runtime.
+      ;;
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	_LT_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic
+      fi
+      ;;
+    hpux*)
+      # PIC is the default for 64-bit PA HP-UX, but not for 32-bit
+      # PA HP-UX.  On IA64 HP-UX, PIC is the default but the pic flag
+      # sets the default TLS model and affects inlining.
+      case $host_cpu in
+      hppa*64*)
+	;;
+      *)
+	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+	;;
+      esac
+      ;;
+    *qnx* | *nto*)
+      # QNX uses GNU C++, but need to define -shared option too, otherwise
+      # it will coredump.
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared'
+      ;;
+    *)
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+      ;;
+    esac
+  else
+    case $host_os in
+      aix[[4-9]]*)
+	# All AIX code is PIC.
+	if test ia64 = "$host_cpu"; then
+	  # AIX 5 now supports IA64 processor
+	  _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+	else
+	  _LT_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp'
+	fi
+	;;
+      chorus*)
+	case $cc_basename in
+	cxch68*)
+	  # Green Hills C++ Compiler
+	  # _LT_TAGVAR(lt_prog_compiler_static, $1)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a"
+	  ;;
+	esac
+	;;
+      mingw* | cygwin* | os2* | pw32* | cegcc*)
+	# This hack is so that the source file can tell whether it is being
+	# built for inclusion in a dll (and should export symbols for example).
+	m4_if([$1], [GCJ], [],
+	  [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'])
+	;;
+      dgux*)
+	case $cc_basename in
+	  ec++*)
+	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+	    ;;
+	  ghcx*)
+	    # Green Hills C++ Compiler
+	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      freebsd* | dragonfly*)
+	# FreeBSD uses GNU C++
+	;;
+      hpux9* | hpux10* | hpux11*)
+	case $cc_basename in
+	  CC*)
+	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	    _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-a ${wl}archive'
+	    if test ia64 != "$host_cpu"; then
+	      _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z'
+	    fi
+	    ;;
+	  aCC*)
+	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	    _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-a ${wl}archive'
+	    case $host_cpu in
+	    hppa*64*|ia64*)
+	      # +Z the default
+	      ;;
+	    *)
+	      _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z'
+	      ;;
+	    esac
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      interix*)
+	# This is c89, which is MS Visual C++ (no shared libs)
+	# Anyone wants to do a port?
+	;;
+      irix5* | irix6* | nonstopux*)
+	case $cc_basename in
+	  CC*)
+	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+	    # CC pic flag -KPIC is the default.
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+	case $cc_basename in
+	  KCC*)
+	    # KAI C++ Compiler
+	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,'
+	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+	    ;;
+	  ecpc* )
+	    # old Intel C++ for x86_64, which still supported -KPIC.
+	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
+	    ;;
+	  icpc* )
+	    # Intel C++, used to be incompatible with GCC.
+	    # ICC 10 doesn't accept -KPIC any more.
+	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
+	    ;;
+	  pgCC* | pgcpp*)
+	    # Portland Group C++ compiler
+	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic'
+	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+	    ;;
+	  cxx*)
+	    # Compaq C++
+	    # Make sure the PIC flag is empty.  It appears that all Alpha
+	    # Linux and Compaq Tru64 Unix objects are PIC.
+	    _LT_TAGVAR(lt_prog_compiler_pic, $1)=
+	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+	    ;;
+	  xlc* | xlC* | bgxl[[cC]]* | mpixl[[cC]]*)
+	    # IBM XL 8.0, 9.0 on PPC and BlueGene
+	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-qpic'
+	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink'
+	    ;;
+	  *)
+	    case `$CC -V 2>&1 | sed 5q` in
+	    *Sun\ C*)
+	      # Sun C++ 5.9
+	      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+	      _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+	      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '
+	      ;;
+	    esac
+	    ;;
+	esac
+	;;
+      lynxos*)
+	;;
+      m88k*)
+	;;
+      mvs*)
+	case $cc_basename in
+	  cxx*)
+	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-W c,exportall'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      netbsd*)
+	;;
+      *qnx* | *nto*)
+        # QNX uses GNU C++, but need to define -shared option too, otherwise
+        # it will coredump.
+        _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared'
+        ;;
+      osf3* | osf4* | osf5*)
+	case $cc_basename in
+	  KCC*)
+	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,'
+	    ;;
+	  RCC*)
+	    # Rational C++ 2.4.1
+	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
+	    ;;
+	  cxx*)
+	    # Digital/Compaq C++
+	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	    # Make sure the PIC flag is empty.  It appears that all Alpha
+	    # Linux and Compaq Tru64 Unix objects are PIC.
+	    _LT_TAGVAR(lt_prog_compiler_pic, $1)=
+	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      psos*)
+	;;
+      solaris*)
+	case $cc_basename in
+	  CC* | sunCC*)
+	    # Sun C++ 4.2, 5.x and Centerline C++
+	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '
+	    ;;
+	  gcx*)
+	    # Green Hills C++ Compiler
+	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      sunos4*)
+	case $cc_basename in
+	  CC*)
+	    # Sun C++ 4.x
+	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
+	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+	    ;;
+	  lcc*)
+	    # Lucid
+	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
+	case $cc_basename in
+	  CC*)
+	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+	    ;;
+	esac
+	;;
+      tandem*)
+	case $cc_basename in
+	  NCC*)
+	    # NonStop-UX NCC 3.20
+	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      vxworks*)
+	;;
+      *)
+	_LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
+	;;
+    esac
+  fi
+],
+[
+  if test yes = "$GCC"; then
+    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+    _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
+
+    case $host_os in
+      aix*)
+      # All AIX code is PIC.
+      if test ia64 = "$host_cpu"; then
+	# AIX 5 now supports IA64 processor
+	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      fi
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+      ;;
+
+    amigaos*)
+      case $host_cpu in
+      powerpc)
+            # see comment about AmigaOS4 .so support
+            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+        ;;
+      m68k)
+            # FIXME: we need at least 68020 code to build shared libraries, but
+            # adding the '-m68020' flag to GCC prevents building anything better,
+            # like '-m68040'.
+            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4'
+        ;;
+      esac
+      ;;
+
+    beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
+      # PIC is the default for these OSes.
+      ;;
+
+    mingw* | cygwin* | pw32* | os2* | cegcc*)
+      # This hack is so that the source file can tell whether it is being
+      # built for inclusion in a dll (and should export symbols for example).
+      # Although the cygwin gcc ignores -fPIC, still need this for old-style
+      # (--disable-auto-import) libraries
+      m4_if([$1], [GCJ], [],
+	[_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'])
+      case $host_os in
+      os2*)
+	_LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-static'
+	;;
+      esac
+      ;;
+
+    darwin* | rhapsody*)
+      # PIC is the default on this platform
+      # Common symbols not allowed in MH_DYLIB files
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common'
+      ;;
+
+    haiku*)
+      # PIC is the default for Haiku.
+      # The "-static" flag exists, but is broken.
+      _LT_TAGVAR(lt_prog_compiler_static, $1)=
+      ;;
+
+    hpux*)
+      # PIC is the default for 64-bit PA HP-UX, but not for 32-bit
+      # PA HP-UX.  On IA64 HP-UX, PIC is the default but the pic flag
+      # sets the default TLS model and affects inlining.
+      case $host_cpu in
+      hppa*64*)
+	# +Z the default
+	;;
+      *)
+	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+	;;
+      esac
+      ;;
+
+    interix[[3-9]]*)
+      # Interix 3.x gcc -fpic/-fPIC options generate broken code.
+      # Instead, we relocate shared libraries at runtime.
+      ;;
+
+    msdosdjgpp*)
+      # Just because we use GCC doesn't mean we suddenly get shared libraries
+      # on systems that don't support them.
+      _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
+      enable_shared=no
+      ;;
+
+    *nto* | *qnx*)
+      # QNX uses GNU C++, but need to define -shared option too, otherwise
+      # it will coredump.
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared'
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	_LT_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic
+      fi
+      ;;
+
+    *)
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+      ;;
+    esac
+
+    case $cc_basename in
+    nvcc*) # Cuda Compiler Driver 2.2
+      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Xlinker '
+      if test -n "$_LT_TAGVAR(lt_prog_compiler_pic, $1)"; then
+        _LT_TAGVAR(lt_prog_compiler_pic, $1)="-Xcompiler $_LT_TAGVAR(lt_prog_compiler_pic, $1)"
+      fi
+      ;;
+    esac
+  else
+    # PORTME Check for flag to pass linker flags through the system compiler.
+    case $host_os in
+    aix*)
+      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+      if test ia64 = "$host_cpu"; then
+	# AIX 5 now supports IA64 processor
+	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      else
+	_LT_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp'
+      fi
+      ;;
+
+    darwin* | rhapsody*)
+      # PIC is the default on this platform
+      # Common symbols not allowed in MH_DYLIB files
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common'
+      case $cc_basename in
+      nagfor*)
+        # NAG Fortran compiler
+        _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,-Wl,,'
+        _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'
+        _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+        ;;
+      esac
+      ;;
+
+    mingw* | cygwin* | pw32* | os2* | cegcc*)
+      # This hack is so that the source file can tell whether it is being
+      # built for inclusion in a dll (and should export symbols for example).
+      m4_if([$1], [GCJ], [],
+	[_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'])
+      case $host_os in
+      os2*)
+	_LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-static'
+	;;
+      esac
+      ;;
+
+    hpux9* | hpux10* | hpux11*)
+      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
+      # not for PA HP-UX.
+      case $host_cpu in
+      hppa*64*|ia64*)
+	# +Z the default
+	;;
+      *)
+	_LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z'
+	;;
+      esac
+      # Is there a better lt_prog_compiler_static that works with the bundled CC?
+      _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-a ${wl}archive'
+      ;;
+
+    irix5* | irix6* | nonstopux*)
+      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+      # PIC (with -KPIC) is the default.
+      _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+      ;;
+
+    linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+      case $cc_basename in
+      # old Intel for x86_64, which still supported -KPIC.
+      ecc*)
+	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+	_LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
+        ;;
+      # icc used to be incompatible with GCC.
+      # ICC 10 doesn't accept -KPIC any more.
+      icc* | ifort*)
+	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+	_LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
+        ;;
+      # Lahey Fortran 8.1.
+      lf95*)
+	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	_LT_TAGVAR(lt_prog_compiler_pic, $1)='--shared'
+	_LT_TAGVAR(lt_prog_compiler_static, $1)='--static'
+	;;
+      nagfor*)
+	# NAG Fortran compiler
+	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,-Wl,,'
+	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'
+	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+	;;
+      tcc*)
+	# Fabrice Bellard et al's Tiny C Compiler
+	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+	_LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
+	;;
+      pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*)
+        # Portland Group compilers (*not* the Pentium gcc compiler,
+	# which looks to be a dead project)
+	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic'
+	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+        ;;
+      ccc*)
+        _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+        # All Alpha code is PIC.
+        _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+        ;;
+      xl* | bgxl* | bgf* | mpixl*)
+	# IBM XL C 8.0/Fortran 10.1, 11.1 on PPC and BlueGene
+	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-qpic'
+	_LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink'
+	;;
+      *)
+	case `$CC -V 2>&1 | sed 5q` in
+	*Sun\ Ceres\ Fortran* | *Sun*Fortran*\ [[1-7]].* | *Sun*Fortran*\ 8.[[0-3]]*)
+	  # Sun Fortran 8.3 passes all unrecognized flags to the linker
+	  _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+	  _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+	  _LT_TAGVAR(lt_prog_compiler_wl, $1)=''
+	  ;;
+	*Sun\ F* | *Sun*Fortran*)
+	  _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+	  _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+	  _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '
+	  ;;
+	*Sun\ C*)
+	  # Sun C 5.9
+	  _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+	  _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+	  _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	  ;;
+        *Intel*\ [[CF]]*Compiler*)
+	  _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	  _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+	  _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
+	  ;;
+	*Portland\ Group*)
+	  _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	  _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic'
+	  _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+	  ;;
+	esac
+	;;
+      esac
+      ;;
+
+    newsos6)
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+      _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      ;;
+
+    *nto* | *qnx*)
+      # QNX uses GNU C++, but need to define -shared option too, otherwise
+      # it will coredump.
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared'
+      ;;
+
+    osf3* | osf4* | osf5*)
+      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+      # All OSF/1 code is PIC.
+      _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+      ;;
+
+    rdos*)
+      _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+      ;;
+
+    solaris*)
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+      _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      case $cc_basename in
+      f77* | f90* | f95* | sunf77* | sunf90* | sunf95*)
+	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ';;
+      *)
+	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,';;
+      esac
+      ;;
+
+    sunos4*)
+      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'
+      _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      ;;
+
+    sysv4 | sysv4.2uw2* | sysv4.3*)
+      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+      _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-Kconform_pic'
+	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      fi
+      ;;
+
+    sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
+      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+      _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      ;;
+
+    unicos*)
+      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+      _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
+      ;;
+
+    uts4*)
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
+      _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      ;;
+
+    *)
+      _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
+      ;;
+    esac
+  fi
+])
+case $host_os in
+  # For platforms that do not support PIC, -DPIC is meaningless:
+  *djgpp*)
+    _LT_TAGVAR(lt_prog_compiler_pic, $1)=
+    ;;
+  *)
+    _LT_TAGVAR(lt_prog_compiler_pic, $1)="$_LT_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])"
+    ;;
+esac
+
+AC_CACHE_CHECK([for $compiler option to produce PIC],
+  [_LT_TAGVAR(lt_cv_prog_compiler_pic, $1)],
+  [_LT_TAGVAR(lt_cv_prog_compiler_pic, $1)=$_LT_TAGVAR(lt_prog_compiler_pic, $1)])
+_LT_TAGVAR(lt_prog_compiler_pic, $1)=$_LT_TAGVAR(lt_cv_prog_compiler_pic, $1)
+
+#
+# Check to make sure the PIC flag actually works.
+#
+if test -n "$_LT_TAGVAR(lt_prog_compiler_pic, $1)"; then
+  _LT_COMPILER_OPTION([if $compiler PIC flag $_LT_TAGVAR(lt_prog_compiler_pic, $1) works],
+    [_LT_TAGVAR(lt_cv_prog_compiler_pic_works, $1)],
+    [$_LT_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])], [],
+    [case $_LT_TAGVAR(lt_prog_compiler_pic, $1) in
+     "" | " "*) ;;
+     *) _LT_TAGVAR(lt_prog_compiler_pic, $1)=" $_LT_TAGVAR(lt_prog_compiler_pic, $1)" ;;
+     esac],
+    [_LT_TAGVAR(lt_prog_compiler_pic, $1)=
+     _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no])
+fi
+_LT_TAGDECL([pic_flag], [lt_prog_compiler_pic], [1],
+	[Additional compiler flags for building library objects])
+
+_LT_TAGDECL([wl], [lt_prog_compiler_wl], [1],
+	[How to pass a linker flag through the compiler])
+#
+# Check to make sure the static flag actually works.
+#
+wl=$_LT_TAGVAR(lt_prog_compiler_wl, $1) eval lt_tmp_static_flag=\"$_LT_TAGVAR(lt_prog_compiler_static, $1)\"
+_LT_LINKER_OPTION([if $compiler static flag $lt_tmp_static_flag works],
+  _LT_TAGVAR(lt_cv_prog_compiler_static_works, $1),
+  $lt_tmp_static_flag,
+  [],
+  [_LT_TAGVAR(lt_prog_compiler_static, $1)=])
+_LT_TAGDECL([link_static_flag], [lt_prog_compiler_static], [1],
+	[Compiler flag to prevent dynamic linking])
+])# _LT_COMPILER_PIC
+
+
+# _LT_LINKER_SHLIBS([TAGNAME])
+# ----------------------------
+# See if the linker supports building shared libraries.
+m4_defun([_LT_LINKER_SHLIBS],
+[AC_REQUIRE([LT_PATH_LD])dnl
+AC_REQUIRE([LT_PATH_NM])dnl
+m4_require([_LT_PATH_MANIFEST_TOOL])dnl
+m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+m4_require([_LT_DECL_EGREP])dnl
+m4_require([_LT_DECL_SED])dnl
+m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl
+m4_require([_LT_TAG_COMPILER])dnl
+AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries])
+m4_if([$1], [CXX], [
+  _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+  _LT_TAGVAR(exclude_expsyms, $1)=['_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*']
+  case $host_os in
+  aix[[4-9]]*)
+    # If we're using GNU nm, then we don't want the "-C" option.
+    # -C means demangle to GNU nm, but means don't demangle to AIX nm.
+    # Without the "-l" option, or with the "-B" option, AIX nm treats
+    # weak defined symbols like other global defined symbols, whereas
+    # GNU nm marks them as "W".
+    # While the 'weak' keyword is ignored in the Export File, we need
+    # it in the Import File for the 'aix-soname' feature, so we have
+    # to replace the "-B" option with "-P" for AIX nm.
+    if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
+      _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols'
+    else
+      _LT_TAGVAR(export_symbols_cmds, $1)='`func_echo_all $NM | $SED -e '\''s/B\([[^B]]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && ([substr](\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols'
+    fi
+    ;;
+  pw32*)
+    _LT_TAGVAR(export_symbols_cmds, $1)=$ltdll_cmds
+    ;;
+  cygwin* | mingw* | cegcc*)
+    case $cc_basename in
+    cl*)
+      _LT_TAGVAR(exclude_expsyms, $1)='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*'
+      ;;
+    *)
+      _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1 DATA/;s/^.*[[ ]]__nm__\([[^ ]]*\)[[ ]][[^ ]]*/\1 DATA/;/^I[[ ]]/d;/^[[AITW]][[ ]]/s/.* //'\'' | sort | uniq > $export_symbols'
+      _LT_TAGVAR(exclude_expsyms, $1)=['[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname']
+      ;;
+    esac
+    ;;
+  *)
+    _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+    ;;
+  esac
+], [
+  runpath_var=
+  _LT_TAGVAR(allow_undefined_flag, $1)=
+  _LT_TAGVAR(always_export_symbols, $1)=no
+  _LT_TAGVAR(archive_cmds, $1)=
+  _LT_TAGVAR(archive_expsym_cmds, $1)=
+  _LT_TAGVAR(compiler_needs_object, $1)=no
+  _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no
+  _LT_TAGVAR(export_dynamic_flag_spec, $1)=
+  _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+  _LT_TAGVAR(hardcode_automatic, $1)=no
+  _LT_TAGVAR(hardcode_direct, $1)=no
+  _LT_TAGVAR(hardcode_direct_absolute, $1)=no
+  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
+  _LT_TAGVAR(hardcode_libdir_separator, $1)=
+  _LT_TAGVAR(hardcode_minus_L, $1)=no
+  _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
+  _LT_TAGVAR(inherit_rpath, $1)=no
+  _LT_TAGVAR(link_all_deplibs, $1)=unknown
+  _LT_TAGVAR(module_cmds, $1)=
+  _LT_TAGVAR(module_expsym_cmds, $1)=
+  _LT_TAGVAR(old_archive_from_new_cmds, $1)=
+  _LT_TAGVAR(old_archive_from_expsyms_cmds, $1)=
+  _LT_TAGVAR(thread_safe_flag_spec, $1)=
+  _LT_TAGVAR(whole_archive_flag_spec, $1)=
+  # include_expsyms should be a list of space-separated symbols to be *always*
+  # included in the symbol list
+  _LT_TAGVAR(include_expsyms, $1)=
+  # exclude_expsyms can be an extended regexp of symbols to exclude
+  # it will be wrapped by ' (' and ')$', so one must not match beginning or
+  # end of line.  Example: 'a|bc|.*d.*' will exclude the symbols 'a' and 'bc',
+  # as well as any symbol that contains 'd'.
+  _LT_TAGVAR(exclude_expsyms, $1)=['_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*']
+  # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out
+  # platforms (ab)use it in PIC code, but their linkers get confused if
+  # the symbol is explicitly referenced.  Since portable code cannot
+  # rely on this symbol name, it's probably fine to never include it in
+  # preloaded symbol tables.
+  # Exclude shared library initialization/finalization symbols.
+dnl Note also adjust exclude_expsyms for C++ above.
+  extract_expsyms_cmds=
+
+  case $host_os in
+  cygwin* | mingw* | pw32* | cegcc*)
+    # FIXME: the MSVC++ port hasn't been tested in a loooong time
+    # When not using gcc, we currently assume that we are using
+    # Microsoft Visual C++.
+    if test yes != "$GCC"; then
+      with_gnu_ld=no
+    fi
+    ;;
+  interix*)
+    # we just hope/assume this is gcc and not c89 (= MSVC++)
+    with_gnu_ld=yes
+    ;;
+  openbsd* | bitrig*)
+    with_gnu_ld=no
+    ;;
+  esac
+
+  _LT_TAGVAR(ld_shlibs, $1)=yes
+
+  # On some targets, GNU ld is compatible enough with the native linker
+  # that we're better off using the native interface for both.
+  lt_use_gnu_ld_interface=no
+  if test yes = "$with_gnu_ld"; then
+    case $host_os in
+      aix*)
+	# The AIX port of GNU ld has always aspired to compatibility
+	# with the native linker.  However, as the warning in the GNU ld
+	# block says, versions before 2.19.5* couldn't really create working
+	# shared libraries, regardless of the interface used.
+	case `$LD -v 2>&1` in
+	  *\ \(GNU\ Binutils\)\ 2.19.5*) ;;
+	  *\ \(GNU\ Binutils\)\ 2.[[2-9]]*) ;;
+	  *\ \(GNU\ Binutils\)\ [[3-9]]*) ;;
+	  *)
+	    lt_use_gnu_ld_interface=yes
+	    ;;
+	esac
+	;;
+      *)
+	lt_use_gnu_ld_interface=yes
+	;;
+    esac
+  fi
+
+  if test yes = "$lt_use_gnu_ld_interface"; then
+    # If archive_cmds runs LD, not CC, wlarc should be empty
+    wlarc='$wl'
+
+    # Set some defaults for GNU ld with shared library support. These
+    # are reset later if shared libraries are not supported. Putting them
+    # here allows them to be overridden if necessary.
+    runpath_var=LD_RUN_PATH
+    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
+    _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic'
+    # ancient GNU ld didn't support --whole-archive et. al.
+    if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then
+      _LT_TAGVAR(whole_archive_flag_spec, $1)=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive'
+    else
+      _LT_TAGVAR(whole_archive_flag_spec, $1)=
+    fi
+    supports_anon_versioning=no
+    case `$LD -v | $SED -e 's/([^)]\+)\s\+//' 2>&1` in
+      *GNU\ gold*) supports_anon_versioning=yes ;;
+      *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.10.*) ;; # catch versions < 2.11
+      *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
+      *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
+      *\ 2.11.*) ;; # other 2.11 versions
+      *) supports_anon_versioning=yes ;;
+    esac
+
+    # See if GNU ld supports shared libraries.
+    case $host_os in
+    aix[[3-9]]*)
+      # On AIX/PPC, the GNU linker is very broken
+      if test ia64 != "$host_cpu"; then
+	_LT_TAGVAR(ld_shlibs, $1)=no
+	cat <<_LT_EOF 1>&2
+
+*** Warning: the GNU linker, at least up to release 2.19, is reported
+*** to be unable to reliably create shared libraries on AIX.
+*** Therefore, libtool is disabling shared libraries support.  If you
+*** really care for shared libraries, you may want to install binutils
+*** 2.20 or above, or modify your PATH so that a non-GNU linker is found.
+*** You will then need to restart the configuration process.
+
+_LT_EOF
+      fi
+      ;;
+
+    amigaos*)
+      case $host_cpu in
+      powerpc)
+            # see comment about AmigaOS4 .so support
+            _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+            _LT_TAGVAR(archive_expsym_cmds, $1)=''
+        ;;
+      m68k)
+            _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
+            _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+            _LT_TAGVAR(hardcode_minus_L, $1)=yes
+        ;;
+      esac
+      ;;
+
+    beos*)
+      if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+	_LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+	# Joseph Beckenbach <jrb3@best.com> says some releases of gcc
+	# support --undefined.  This deserves some investigation.  FIXME
+	_LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+      else
+	_LT_TAGVAR(ld_shlibs, $1)=no
+      fi
+      ;;
+
+    cygwin* | mingw* | pw32* | cegcc*)
+      # _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless,
+      # as there is no search path for DLLs.
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+      _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-all-symbols'
+      _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+      _LT_TAGVAR(always_export_symbols, $1)=no
+      _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+      _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1 DATA/;s/^.*[[ ]]__nm__\([[^ ]]*\)[[ ]][[^ ]]*/\1 DATA/;/^I[[ ]]/d;/^[[AITW]][[ ]]/s/.* //'\'' | sort | uniq > $export_symbols'
+      _LT_TAGVAR(exclude_expsyms, $1)=['[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname']
+
+      if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
+        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+	# If the export-symbols file already is a .def file, use it as
+	# is; otherwise, prepend EXPORTS...
+	_LT_TAGVAR(archive_expsym_cmds, $1)='if _LT_DLL_DEF_P([$export_symbols]); then
+          cp $export_symbols $output_objdir/$soname.def;
+        else
+          echo EXPORTS > $output_objdir/$soname.def;
+          cat $export_symbols >> $output_objdir/$soname.def;
+        fi~
+        $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+      else
+	_LT_TAGVAR(ld_shlibs, $1)=no
+      fi
+      ;;
+
+    haiku*)
+      _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+      _LT_TAGVAR(link_all_deplibs, $1)=yes
+      ;;
+
+    os2*)
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+      _LT_TAGVAR(hardcode_minus_L, $1)=yes
+      _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+      shrext_cmds=.dll
+      _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      _LT_TAGVAR(archive_expsym_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	prefix_cmds="$SED"~
+	if test EXPORTS = "`$SED 1q $export_symbols`"; then
+	  prefix_cmds="$prefix_cmds -e 1d";
+	fi~
+	prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~
+	cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      _LT_TAGVAR(old_archive_From_new_cmds, $1)='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
+      _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+      ;;
+
+    interix[[3-9]]*)
+      _LT_TAGVAR(hardcode_direct, $1)=no
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir'
+      _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E'
+      # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
+      # Instead, shared libraries are loaded at an image base (0x10000000 by
+      # default) and relocated if they conflict, which is a slow very memory
+      # consuming and fragmenting process.  To avoid this, we pick a random,
+      # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
+      # time.  Moving up from 0x10000000 also allows more sbrk(2) space.
+      _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+      _LT_TAGVAR(archive_expsym_cmds, $1)='sed "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--retain-symbols-file,$output_objdir/$soname.expsym $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+      ;;
+
+    gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu)
+      tmp_diet=no
+      if test linux-dietlibc = "$host_os"; then
+	case $cc_basename in
+	  diet\ *) tmp_diet=yes;;	# linux-dietlibc with static linking (!diet-dyn)
+	esac
+      fi
+      if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \
+	 && test no = "$tmp_diet"
+      then
+	tmp_addflag=' $pic_flag'
+	tmp_sharedflag='-shared'
+	case $cc_basename,$host_cpu in
+        pgcc*)				# Portland Group C compiler
+	  _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
+	  tmp_addflag=' $pic_flag'
+	  ;;
+	pgf77* | pgf90* | pgf95* | pgfortran*)
+					# Portland Group f77 and f90 compilers
+	  _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
+	  tmp_addflag=' $pic_flag -Mnomain' ;;
+	ecc*,ia64* | icc*,ia64*)	# Intel C compiler on ia64
+	  tmp_addflag=' -i_dynamic' ;;
+	efc*,ia64* | ifort*,ia64*)	# Intel Fortran compiler on ia64
+	  tmp_addflag=' -i_dynamic -nofor_main' ;;
+	ifc* | ifort*)			# Intel Fortran compiler
+	  tmp_addflag=' -nofor_main' ;;
+	lf95*)				# Lahey Fortran 8.1
+	  _LT_TAGVAR(whole_archive_flag_spec, $1)=
+	  tmp_sharedflag='--shared' ;;
+        nagfor*)                        # NAGFOR 5.3
+          tmp_sharedflag='-Wl,-shared' ;;
+	xl[[cC]]* | bgxl[[cC]]* | mpixl[[cC]]*) # IBM XL C 8.0 on PPC (deal with xlf below)
+	  tmp_sharedflag='-qmkshrobj'
+	  tmp_addflag= ;;
+	nvcc*)	# Cuda Compiler Driver 2.2
+	  _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
+	  _LT_TAGVAR(compiler_needs_object, $1)=yes
+	  ;;
+	esac
+	case `$CC -V 2>&1 | sed 5q` in
+	*Sun\ C*)			# Sun C 5.9
+	  _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
+	  _LT_TAGVAR(compiler_needs_object, $1)=yes
+	  tmp_sharedflag='-G' ;;
+	*Sun\ F*)			# Sun Fortran 8.3
+	  tmp_sharedflag='-G' ;;
+	esac
+	_LT_TAGVAR(archive_cmds, $1)='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+
+        if test yes = "$supports_anon_versioning"; then
+          _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~
+            cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+            echo "local: *; };" >> $output_objdir/$libname.ver~
+            $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-version-script $wl$output_objdir/$libname.ver -o $lib'
+        fi
+
+	case $cc_basename in
+	tcc*)
+	  _LT_TAGVAR(export_dynamic_flag_spec, $1)='-rdynamic'
+	  ;;
+	xlf* | bgf* | bgxlf* | mpixlf*)
+	  # IBM XL Fortran 10.1 on PPC cannot create shared libs itself
+	  _LT_TAGVAR(whole_archive_flag_spec, $1)='--whole-archive$convenience --no-whole-archive'
+	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
+	  _LT_TAGVAR(archive_cmds, $1)='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib'
+	  if test yes = "$supports_anon_versioning"; then
+	    _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~
+              cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+              echo "local: *; };" >> $output_objdir/$libname.ver~
+              $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib'
+	  fi
+	  ;;
+	esac
+      else
+        _LT_TAGVAR(ld_shlibs, $1)=no
+      fi
+      ;;
+
+    netbsd*)
+      if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+	_LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
+	wlarc=
+      else
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+      fi
+      ;;
+
+    solaris*)
+      if $LD -v 2>&1 | $GREP 'BFD 2\.8' > /dev/null; then
+	_LT_TAGVAR(ld_shlibs, $1)=no
+	cat <<_LT_EOF 1>&2
+
+*** Warning: The releases 2.8.* of the GNU linker cannot reliably
+*** create shared libraries on Solaris systems.  Therefore, libtool
+*** is disabling shared libraries support.  We urge you to upgrade GNU
+*** binutils to release 2.9.1 or newer.  Another option is to modify
+*** your PATH or compiler configuration so that the native linker is
+*** used, and then restart.
+
+_LT_EOF
+      elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+      else
+	_LT_TAGVAR(ld_shlibs, $1)=no
+      fi
+      ;;
+
+    sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)
+      case `$LD -v 2>&1` in
+        *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.1[[0-5]].*)
+	_LT_TAGVAR(ld_shlibs, $1)=no
+	cat <<_LT_EOF 1>&2
+
+*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 cannot
+*** reliably create shared libraries on SCO systems.  Therefore, libtool
+*** is disabling shared libraries support.  We urge you to upgrade GNU
+*** binutils to release 2.16.91.0.3 or newer.  Another option is to modify
+*** your PATH or compiler configuration so that the native linker is
+*** used, and then restart.
+
+_LT_EOF
+	;;
+	*)
+	  # For security reasons, it is highly recommended that you always
+	  # use absolute paths for naming shared libraries, and exclude the
+	  # DT_RUNPATH tag from executables and libraries.  But doing so
+	  # requires that you compile everything twice, which is a pain.
+	  if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
+	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	    _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+	  else
+	    _LT_TAGVAR(ld_shlibs, $1)=no
+	  fi
+	;;
+      esac
+      ;;
+
+    sunos4*)
+      _LT_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+      wlarc=
+      _LT_TAGVAR(hardcode_direct, $1)=yes
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    *)
+      if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+      else
+	_LT_TAGVAR(ld_shlibs, $1)=no
+      fi
+      ;;
+    esac
+
+    if test no = "$_LT_TAGVAR(ld_shlibs, $1)"; then
+      runpath_var=
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
+      _LT_TAGVAR(export_dynamic_flag_spec, $1)=
+      _LT_TAGVAR(whole_archive_flag_spec, $1)=
+    fi
+  else
+    # PORTME fill in a description of your system's linker (not GNU ld)
+    case $host_os in
+    aix3*)
+      _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+      _LT_TAGVAR(always_export_symbols, $1)=yes
+      _LT_TAGVAR(archive_expsym_cmds, $1)='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname'
+      # Note: this linker hardcodes the directories in LIBPATH if there
+      # are no directories specified by -L.
+      _LT_TAGVAR(hardcode_minus_L, $1)=yes
+      if test yes = "$GCC" && test -z "$lt_prog_compiler_static"; then
+	# Neither direct hardcoding nor static linking is supported with a
+	# broken collect2.
+	_LT_TAGVAR(hardcode_direct, $1)=unsupported
+      fi
+      ;;
+
+    aix[[4-9]]*)
+      if test ia64 = "$host_cpu"; then
+	# On IA64, the linker does run time linking by default, so we don't
+	# have to do anything special.
+	aix_use_runtimelinking=no
+	exp_sym_flag='-Bexport'
+	no_entry_flag=
+      else
+	# If we're using GNU nm, then we don't want the "-C" option.
+	# -C means demangle to GNU nm, but means don't demangle to AIX nm.
+	# Without the "-l" option, or with the "-B" option, AIX nm treats
+	# weak defined symbols like other global defined symbols, whereas
+	# GNU nm marks them as "W".
+	# While the 'weak' keyword is ignored in the Export File, we need
+	# it in the Import File for the 'aix-soname' feature, so we have
+	# to replace the "-B" option with "-P" for AIX nm.
+	if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
+	  _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols'
+	else
+	  _LT_TAGVAR(export_symbols_cmds, $1)='`func_echo_all $NM | $SED -e '\''s/B\([[^B]]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && ([substr](\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols'
+	fi
+	aix_use_runtimelinking=no
+
+	# Test if we are trying to use run time linking or normal
+	# AIX style linking. If -brtl is somewhere in LDFLAGS, we
+	# have runtime linking enabled, and use it for executables.
+	# For shared libraries, we enable/disable runtime linking
+	# depending on the kind of the shared library created -
+	# when "with_aix_soname,aix_use_runtimelinking" is:
+	# "aix,no"   lib.a(lib.so.V) shared, rtl:no,  for executables
+	# "aix,yes"  lib.so          shared, rtl:yes, for executables
+	#            lib.a           static archive
+	# "both,no"  lib.so.V(shr.o) shared, rtl:yes
+	#            lib.a(lib.so.V) shared, rtl:no,  for executables
+	# "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables
+	#            lib.a(lib.so.V) shared, rtl:no
+	# "svr4,*"   lib.so.V(shr.o) shared, rtl:yes, for executables
+	#            lib.a           static archive
+	case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*)
+	  for ld_flag in $LDFLAGS; do
+	  if (test x-brtl = "x$ld_flag" || test x-Wl,-brtl = "x$ld_flag"); then
+	    aix_use_runtimelinking=yes
+	    break
+	  fi
+	  done
+	  if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then
+	    # With aix-soname=svr4, we create the lib.so.V shared archives only,
+	    # so we don't have lib.a shared libs to link our executables.
+	    # We have to force runtime linking in this case.
+	    aix_use_runtimelinking=yes
+	    LDFLAGS="$LDFLAGS -Wl,-brtl"
+	  fi
+	  ;;
+	esac
+
+	exp_sym_flag='-bexport'
+	no_entry_flag='-bnoentry'
+      fi
+
+      # When large executables or shared objects are built, AIX ld can
+      # have problems creating the table of contents.  If linking a library
+      # or program results in "error TOC overflow" add -mminimal-toc to
+      # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
+      # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
+
+      _LT_TAGVAR(archive_cmds, $1)=''
+      _LT_TAGVAR(hardcode_direct, $1)=yes
+      _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
+      _LT_TAGVAR(hardcode_libdir_separator, $1)=':'
+      _LT_TAGVAR(link_all_deplibs, $1)=yes
+      _LT_TAGVAR(file_list_spec, $1)='$wl-f,'
+      case $with_aix_soname,$aix_use_runtimelinking in
+      aix,*) ;; # traditional, no import file
+      svr4,* | *,yes) # use import file
+	# The Import File defines what to hardcode.
+	_LT_TAGVAR(hardcode_direct, $1)=no
+	_LT_TAGVAR(hardcode_direct_absolute, $1)=no
+	;;
+      esac
+
+      if test yes = "$GCC"; then
+	case $host_os in aix4.[[012]]|aix4.[[012]].*)
+	# We only want to do this on AIX 4.2 and lower, the check
+	# below for broken collect2 doesn't work under 4.3+
+	  collect2name=`$CC -print-prog-name=collect2`
+	  if test -f "$collect2name" &&
+	   strings "$collect2name" | $GREP resolve_lib_name >/dev/null
+	  then
+	  # We have reworked collect2
+	  :
+	  else
+	  # We have old collect2
+	  _LT_TAGVAR(hardcode_direct, $1)=unsupported
+	  # It fails to find uninstalled libraries when the uninstalled
+	  # path is not listed in the libpath.  Setting hardcode_minus_L
+	  # to unsupported forces relinking
+	  _LT_TAGVAR(hardcode_minus_L, $1)=yes
+	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+	  _LT_TAGVAR(hardcode_libdir_separator, $1)=
+	  fi
+	  ;;
+	esac
+	shared_flag='-shared'
+	if test yes = "$aix_use_runtimelinking"; then
+	  shared_flag="$shared_flag "'$wl-G'
+	fi
+	# Need to ensure runtime linking is disabled for the traditional
+	# shared library, or the linker may eventually find shared libraries
+	# /with/ Import File - we do not want to mix them.
+	shared_flag_aix='-shared'
+	shared_flag_svr4='-shared $wl-G'
+      else
+	# not using gcc
+	if test ia64 = "$host_cpu"; then
+	# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
+	# chokes on -Wl,-G. The following line is correct:
+	  shared_flag='-G'
+	else
+	  if test yes = "$aix_use_runtimelinking"; then
+	    shared_flag='$wl-G'
+	  else
+	    shared_flag='$wl-bM:SRE'
+	  fi
+	  shared_flag_aix='$wl-bM:SRE'
+	  shared_flag_svr4='$wl-G'
+	fi
+      fi
+
+      _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-bexpall'
+      # It seems that -bexpall does not export symbols beginning with
+      # underscore (_), so it is better to generate a list of symbols to export.
+      _LT_TAGVAR(always_export_symbols, $1)=yes
+      if test aix,yes = "$with_aix_soname,$aix_use_runtimelinking"; then
+	# Warning - without using the other runtime loading flags (-brtl),
+	# -berok will link without error, but may produce a broken library.
+	_LT_TAGVAR(allow_undefined_flag, $1)='-berok'
+        # Determine the default libpath from the value encoded in an
+        # empty executable.
+        _LT_SYS_MODULE_PATH_AIX([$1])
+        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-blibpath:$libdir:'"$aix_libpath"
+        _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs $wl'$no_entry_flag' $compiler_flags `if test -n "$allow_undefined_flag"; then func_echo_all "$wl$allow_undefined_flag"; else :; fi` $wl'$exp_sym_flag:\$export_symbols' '$shared_flag
+      else
+	if test ia64 = "$host_cpu"; then
+	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R $libdir:/usr/lib:/lib'
+	  _LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs"
+	  _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\$wl$no_entry_flag"' $compiler_flags $wl$allow_undefined_flag '"\$wl$exp_sym_flag:\$export_symbols"
+	else
+	 # Determine the default libpath from the value encoded in an
+	 # empty executable.
+	 _LT_SYS_MODULE_PATH_AIX([$1])
+	 _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-blibpath:$libdir:'"$aix_libpath"
+	  # Warning - without using the other run time loading flags,
+	  # -berok will link without error, but may produce a broken library.
+	  _LT_TAGVAR(no_undefined_flag, $1)=' $wl-bernotok'
+	  _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-berok'
+	  if test yes = "$with_gnu_ld"; then
+	    # We only use this code for GNU lds that support --whole-archive.
+	    _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive$convenience $wl--no-whole-archive'
+	  else
+	    # Exported symbols can be pulled into shared objects from archives
+	    _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience'
+	  fi
+	  _LT_TAGVAR(archive_cmds_need_lc, $1)=yes
+	  _LT_TAGVAR(archive_expsym_cmds, $1)='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d'
+	  # -brtl affects multiple linker settings, -berok does not and is overridden later
+	  compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\\([[, ]]\\)%-berok\\1%g"`'
+	  if test svr4 != "$with_aix_soname"; then
+	    # This is similar to how AIX traditionally builds its shared libraries.
+	    _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname'
+	  fi
+	  if test aix != "$with_aix_soname"; then
+	    _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp'
+	  else
+	    # used by -dlpreopen to get the symbols
+	    _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$MV  $output_objdir/$realname.d/$soname $output_objdir'
+	  fi
+	  _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$RM -r $output_objdir/$realname.d'
+	fi
+      fi
+      ;;
+
+    amigaos*)
+      case $host_cpu in
+      powerpc)
+            # see comment about AmigaOS4 .so support
+            _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+            _LT_TAGVAR(archive_expsym_cmds, $1)=''
+        ;;
+      m68k)
+            _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
+            _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+            _LT_TAGVAR(hardcode_minus_L, $1)=yes
+        ;;
+      esac
+      ;;
+
+    bsdi[[45]]*)
+      _LT_TAGVAR(export_dynamic_flag_spec, $1)=-rdynamic
+      ;;
+
+    cygwin* | mingw* | pw32* | cegcc*)
+      # When not using gcc, we currently assume that we are using
+      # Microsoft Visual C++.
+      # hardcode_libdir_flag_spec is actually meaningless, as there is
+      # no search path for DLLs.
+      case $cc_basename in
+      cl*)
+	# Native MSVC
+	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' '
+	_LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+	_LT_TAGVAR(always_export_symbols, $1)=yes
+	_LT_TAGVAR(file_list_spec, $1)='@'
+	# Tell ltmain to make .lib files, not .a files.
+	libext=lib
+	# Tell ltmain to make .dll files, not .so files.
+	shrext_cmds=.dll
+	# FIXME: Setting linknames here is a bad hack.
+	_LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames='
+	_LT_TAGVAR(archive_expsym_cmds, $1)='if _LT_DLL_DEF_P([$export_symbols]); then
+            cp "$export_symbols" "$output_objdir/$soname.def";
+            echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp";
+          else
+            $SED -e '\''s/^/-link -EXPORT:/'\'' < $export_symbols > $output_objdir/$soname.exp;
+          fi~
+          $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
+          linknames='
+	# The linker will not automatically build a static lib if we build a DLL.
+	# _LT_TAGVAR(old_archive_from_new_cmds, $1)='true'
+	_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+	_LT_TAGVAR(exclude_expsyms, $1)='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*'
+	_LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1,DATA/'\'' | $SED -e '\''/^[[AITW]][[ ]]/s/.*[[ ]]//'\'' | sort | uniq > $export_symbols'
+	# Don't use ranlib
+	_LT_TAGVAR(old_postinstall_cmds, $1)='chmod 644 $oldlib'
+	_LT_TAGVAR(postlink_cmds, $1)='lt_outputfile="@OUTPUT@"~
+          lt_tool_outputfile="@TOOL_OUTPUT@"~
+          case $lt_outputfile in
+            *.exe|*.EXE) ;;
+            *)
+              lt_outputfile=$lt_outputfile.exe
+              lt_tool_outputfile=$lt_tool_outputfile.exe
+              ;;
+          esac~
+          if test : != "$MANIFEST_TOOL" && test -f "$lt_outputfile.manifest"; then
+            $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;
+            $RM "$lt_outputfile.manifest";
+          fi'
+	;;
+      *)
+	# Assume MSVC wrapper
+	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' '
+	_LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+	# Tell ltmain to make .lib files, not .a files.
+	libext=lib
+	# Tell ltmain to make .dll files, not .so files.
+	shrext_cmds=.dll
+	# FIXME: Setting linknames here is a bad hack.
+	_LT_TAGVAR(archive_cmds, $1)='$CC -o $lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames='
+	# The linker will automatically build a .lib file if we build a DLL.
+	_LT_TAGVAR(old_archive_from_new_cmds, $1)='true'
+	# FIXME: Should let the user specify the lib program.
+	_LT_TAGVAR(old_archive_cmds, $1)='lib -OUT:$oldlib$oldobjs$old_deplibs'
+	_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+	;;
+      esac
+      ;;
+
+    darwin* | rhapsody*)
+      _LT_DARWIN_LINKER_FEATURES($1)
+      ;;
+
+    dgux*)
+      _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor
+    # support.  Future versions do this automatically, but an explicit c++rt0.o
+    # does not break anything, and helps significantly (at the cost of a little
+    # extra space).
+    freebsd2.2*)
+      _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o'
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+      _LT_TAGVAR(hardcode_direct, $1)=yes
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    # Unfortunately, older versions of FreeBSD 2 do not have this feature.
+    freebsd2.*)
+      _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+      _LT_TAGVAR(hardcode_direct, $1)=yes
+      _LT_TAGVAR(hardcode_minus_L, $1)=yes
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    # FreeBSD 3 and greater uses gcc -shared to do shared libraries.
+    freebsd* | dragonfly*)
+      _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+      _LT_TAGVAR(hardcode_direct, $1)=yes
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    hpux9*)
+      if test yes = "$GCC"; then
+	_LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared $pic_flag $wl+b $wl$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
+      else
+	_LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
+      fi
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir'
+      _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+      _LT_TAGVAR(hardcode_direct, $1)=yes
+
+      # hardcode_minus_L: Not really in the search PATH,
+      # but as the default location of the library.
+      _LT_TAGVAR(hardcode_minus_L, $1)=yes
+      _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E'
+      ;;
+
+    hpux10*)
+      if test yes,no = "$GCC,$with_gnu_ld"; then
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	_LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
+      fi
+      if test no = "$with_gnu_ld"; then
+	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir'
+	_LT_TAGVAR(hardcode_libdir_separator, $1)=:
+	_LT_TAGVAR(hardcode_direct, $1)=yes
+	_LT_TAGVAR(hardcode_direct_absolute, $1)=yes
+	_LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E'
+	# hardcode_minus_L: Not really in the search PATH,
+	# but as the default location of the library.
+	_LT_TAGVAR(hardcode_minus_L, $1)=yes
+      fi
+      ;;
+
+    hpux11*)
+      if test yes,no = "$GCC,$with_gnu_ld"; then
+	case $host_cpu in
+	hppa*64*)
+	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl+h $wl$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	ia64*)
+	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $wl+h $wl$soname $wl+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	*)
+	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	esac
+      else
+	case $host_cpu in
+	hppa*64*)
+	  _LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	ia64*)
+	  _LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname $wl+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	*)
+	m4_if($1, [], [
+	  # Older versions of the 11.00 compiler do not understand -b yet
+	  # (HP92453-01 A.11.01.20 doesn't, HP92453-01 B.11.X.35175-35176.GP does)
+	  _LT_LINKER_OPTION([if $CC understands -b],
+	    _LT_TAGVAR(lt_cv_prog_compiler__b, $1), [-b],
+	    [_LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'],
+	    [_LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'])],
+	  [_LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'])
+	  ;;
+	esac
+      fi
+      if test no = "$with_gnu_ld"; then
+	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir'
+	_LT_TAGVAR(hardcode_libdir_separator, $1)=:
+
+	case $host_cpu in
+	hppa*64*|ia64*)
+	  _LT_TAGVAR(hardcode_direct, $1)=no
+	  _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+	  ;;
+	*)
+	  _LT_TAGVAR(hardcode_direct, $1)=yes
+	  _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
+	  _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E'
+
+	  # hardcode_minus_L: Not really in the search PATH,
+	  # but as the default location of the library.
+	  _LT_TAGVAR(hardcode_minus_L, $1)=yes
+	  ;;
+	esac
+      fi
+      ;;
+
+    irix5* | irix6* | nonstopux*)
+      if test yes = "$GCC"; then
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
+	# Try to use the -exported_symbol ld option, if it does not
+	# work, assume that -exports_file does not work either and
+	# implicitly export all symbols.
+	# This should be the same for all languages, so no per-tag cache variable.
+	AC_CACHE_CHECK([whether the $host_os linker accepts -exported_symbol],
+	  [lt_cv_irix_exported_symbol],
+	  [save_LDFLAGS=$LDFLAGS
+	   LDFLAGS="$LDFLAGS -shared $wl-exported_symbol ${wl}foo $wl-update_registry $wl/dev/null"
+	   AC_LINK_IFELSE(
+	     [AC_LANG_SOURCE(
+	        [AC_LANG_CASE([C], [[int foo (void) { return 0; }]],
+			      [C++], [[int foo (void) { return 0; }]],
+			      [Fortran 77], [[
+      subroutine foo
+      end]],
+			      [Fortran], [[
+      subroutine foo
+      end]])])],
+	      [lt_cv_irix_exported_symbol=yes],
+	      [lt_cv_irix_exported_symbol=no])
+           LDFLAGS=$save_LDFLAGS])
+	if test yes = "$lt_cv_irix_exported_symbol"; then
+          _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations $wl-exports_file $wl$export_symbols -o $lib'
+	fi
+      else
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
+	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -exports_file $export_symbols -o $lib'
+      fi
+      _LT_TAGVAR(archive_cmds_need_lc, $1)='no'
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
+      _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+      _LT_TAGVAR(inherit_rpath, $1)=yes
+      _LT_TAGVAR(link_all_deplibs, $1)=yes
+      ;;
+
+    linux*)
+      case $cc_basename in
+      tcc*)
+	# Fabrice Bellard et al's Tiny C Compiler
+	_LT_TAGVAR(ld_shlibs, $1)=yes
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	;;
+      esac
+      ;;
+
+    netbsd*)
+      if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+	_LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out
+      else
+	_LT_TAGVAR(archive_cmds, $1)='$LD -shared -o $lib $libobjs $deplibs $linker_flags'      # ELF
+      fi
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+      _LT_TAGVAR(hardcode_direct, $1)=yes
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    newsos6)
+      _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      _LT_TAGVAR(hardcode_direct, $1)=yes
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
+      _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    *nto* | *qnx*)
+      ;;
+
+    openbsd* | bitrig*)
+      if test -f /usr/libexec/ld.so; then
+	_LT_TAGVAR(hardcode_direct, $1)=yes
+	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+	_LT_TAGVAR(hardcode_direct_absolute, $1)=yes
+	if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then
+	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	  _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags $wl-retain-symbols-file,$export_symbols'
+	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir'
+	  _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E'
+	else
+	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir'
+	fi
+      else
+	_LT_TAGVAR(ld_shlibs, $1)=no
+      fi
+      ;;
+
+    os2*)
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+      _LT_TAGVAR(hardcode_minus_L, $1)=yes
+      _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+      shrext_cmds=.dll
+      _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      _LT_TAGVAR(archive_expsym_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	prefix_cmds="$SED"~
+	if test EXPORTS = "`$SED 1q $export_symbols`"; then
+	  prefix_cmds="$prefix_cmds -e 1d";
+	fi~
+	prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~
+	cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      _LT_TAGVAR(old_archive_From_new_cmds, $1)='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
+      _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+      ;;
+
+    osf3*)
+      if test yes = "$GCC"; then
+	_LT_TAGVAR(allow_undefined_flag, $1)=' $wl-expect_unresolved $wl\*'
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
+      else
+	_LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
+      fi
+      _LT_TAGVAR(archive_cmds_need_lc, $1)='no'
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
+      _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+      ;;
+
+    osf4* | osf5*)	# as osf3* with the addition of -msym flag
+      if test yes = "$GCC"; then
+	_LT_TAGVAR(allow_undefined_flag, $1)=' $wl-expect_unresolved $wl\*'
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_flag $pic_flag $libobjs $deplibs $compiler_flags $wl-msym $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
+	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
+      else
+	_LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
+	_LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~
+          $CC -shared$allow_undefined_flag $wl-input $wl$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib~$RM $lib.exp'
+
+	# Both c and cxx compiler support -rpath directly
+	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
+      fi
+      _LT_TAGVAR(archive_cmds_need_lc, $1)='no'
+      _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+      ;;
+
+    solaris*)
+      _LT_TAGVAR(no_undefined_flag, $1)=' -z defs'
+      if test yes = "$GCC"; then
+	wlarc='$wl'
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $wl-z ${wl}text $wl-h $wl$soname -o $lib $libobjs $deplibs $compiler_flags'
+	_LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+          $CC -shared $pic_flag $wl-z ${wl}text $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
+      else
+	case `$CC -V 2>&1` in
+	*"Compilers 5.0"*)
+	  wlarc=''
+	  _LT_TAGVAR(archive_cmds, $1)='$LD -G$allow_undefined_flag -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	  _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+            $LD -G$allow_undefined_flag -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp'
+	  ;;
+	*)
+	  wlarc='$wl'
+	  _LT_TAGVAR(archive_cmds, $1)='$CC -G$allow_undefined_flag -h $soname -o $lib $libobjs $deplibs $compiler_flags'
+	  _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+            $CC -G$allow_undefined_flag -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
+	  ;;
+	esac
+      fi
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      case $host_os in
+      solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;
+      *)
+	# The compiler driver will combine and reorder linker options,
+	# but understands '-z linker_flag'.  GCC discards it without '$wl',
+	# but is careful enough not to reorder.
+	# Supported since Solaris 2.6 (maybe 2.5.1?)
+	if test yes = "$GCC"; then
+	  _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl-z ${wl}allextract$convenience $wl-z ${wl}defaultextract'
+	else
+	  _LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract'
+	fi
+	;;
+      esac
+      _LT_TAGVAR(link_all_deplibs, $1)=yes
+      ;;
+
+    sunos4*)
+      if test sequent = "$host_vendor"; then
+	# Use $CC to link under sequent, because it throws in some extra .o
+	# files that make .init and .fini sections work.
+	_LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h $soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	_LT_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'
+      fi
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+      _LT_TAGVAR(hardcode_direct, $1)=yes
+      _LT_TAGVAR(hardcode_minus_L, $1)=yes
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    sysv4)
+      case $host_vendor in
+	sni)
+	  _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	  _LT_TAGVAR(hardcode_direct, $1)=yes # is this really true???
+	;;
+	siemens)
+	  ## LD is ld it makes a PLAMLIB
+	  ## CC just makes a GrossModule.
+	  _LT_TAGVAR(archive_cmds, $1)='$LD -G -o $lib $libobjs $deplibs $linker_flags'
+	  _LT_TAGVAR(reload_cmds, $1)='$CC -r -o $output$reload_objs'
+	  _LT_TAGVAR(hardcode_direct, $1)=no
+        ;;
+	motorola)
+	  _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	  _LT_TAGVAR(hardcode_direct, $1)=no #Motorola manual says yes, but my tests say they lie
+	;;
+      esac
+      runpath_var='LD_RUN_PATH'
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    sysv4.3*)
+      _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      _LT_TAGVAR(export_dynamic_flag_spec, $1)='-Bexport'
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	_LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+	runpath_var=LD_RUN_PATH
+	hardcode_runpath_var=yes
+	_LT_TAGVAR(ld_shlibs, $1)=yes
+      fi
+      ;;
+
+    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*)
+      _LT_TAGVAR(no_undefined_flag, $1)='$wl-z,text'
+      _LT_TAGVAR(archive_cmds_need_lc, $1)=no
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      runpath_var='LD_RUN_PATH'
+
+      if test yes = "$GCC"; then
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	_LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      fi
+      ;;
+
+    sysv5* | sco3.2v5* | sco5v6*)
+      # Note: We CANNOT use -z defs as we might desire, because we do not
+      # link with -lc, and that would cause any symbols used from libc to
+      # always be unresolved, which means just about no library would
+      # ever link correctly.  If we're not using GNU ld we use -z text
+      # though, which does catch some bad symbols but isn't as heavy-handed
+      # as -z defs.
+      _LT_TAGVAR(no_undefined_flag, $1)='$wl-z,text'
+      _LT_TAGVAR(allow_undefined_flag, $1)='$wl-z,nodefs'
+      _LT_TAGVAR(archive_cmds_need_lc, $1)=no
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R,$libdir'
+      _LT_TAGVAR(hardcode_libdir_separator, $1)=':'
+      _LT_TAGVAR(link_all_deplibs, $1)=yes
+      _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-Bexport'
+      runpath_var='LD_RUN_PATH'
+
+      if test yes = "$GCC"; then
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	_LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      fi
+      ;;
+
+    uts4*)
+      _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    *)
+      _LT_TAGVAR(ld_shlibs, $1)=no
+      ;;
+    esac
+
+    if test sni = "$host_vendor"; then
+      case $host in
+      sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
+	_LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-Blargedynsym'
+	;;
+      esac
+    fi
+  fi
+])
+AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)])
+test no = "$_LT_TAGVAR(ld_shlibs, $1)" && can_build_shared=no
+
+_LT_TAGVAR(with_gnu_ld, $1)=$with_gnu_ld
+
+_LT_DECL([], [libext], [0], [Old archive suffix (normally "a")])dnl
+_LT_DECL([], [shrext_cmds], [1], [Shared library suffix (normally ".so")])dnl
+_LT_DECL([], [extract_expsyms_cmds], [2],
+    [The commands to extract the exported symbol list from a shared archive])
+
+#
+# Do we need to explicitly link libc?
+#
+case "x$_LT_TAGVAR(archive_cmds_need_lc, $1)" in
+x|xyes)
+  # Assume -lc should be added
+  _LT_TAGVAR(archive_cmds_need_lc, $1)=yes
+
+  if test yes,yes = "$GCC,$enable_shared"; then
+    case $_LT_TAGVAR(archive_cmds, $1) in
+    *'~'*)
+      # FIXME: we may have to deal with multi-command sequences.
+      ;;
+    '$CC '*)
+      # Test whether the compiler implicitly links with -lc since on some
+      # systems, -lgcc has to come before -lc. If gcc already passes -lc
+      # to ld, don't add -lc before -lgcc.
+      AC_CACHE_CHECK([whether -lc should be explicitly linked in],
+	[lt_cv_]_LT_TAGVAR(archive_cmds_need_lc, $1),
+	[$RM conftest*
+	echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+	if AC_TRY_EVAL(ac_compile) 2>conftest.err; then
+	  soname=conftest
+	  lib=conftest
+	  libobjs=conftest.$ac_objext
+	  deplibs=
+	  wl=$_LT_TAGVAR(lt_prog_compiler_wl, $1)
+	  pic_flag=$_LT_TAGVAR(lt_prog_compiler_pic, $1)
+	  compiler_flags=-v
+	  linker_flags=-v
+	  verstring=
+	  output_objdir=.
+	  libname=conftest
+	  lt_save_allow_undefined_flag=$_LT_TAGVAR(allow_undefined_flag, $1)
+	  _LT_TAGVAR(allow_undefined_flag, $1)=
+	  if AC_TRY_EVAL(_LT_TAGVAR(archive_cmds, $1) 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1)
+	  then
+	    lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1)=no
+	  else
+	    lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1)=yes
+	  fi
+	  _LT_TAGVAR(allow_undefined_flag, $1)=$lt_save_allow_undefined_flag
+	else
+	  cat conftest.err 1>&5
+	fi
+	$RM conftest*
+	])
+      _LT_TAGVAR(archive_cmds_need_lc, $1)=$lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1)
+      ;;
+    esac
+  fi
+  ;;
+esac
+
+_LT_TAGDECL([build_libtool_need_lc], [archive_cmds_need_lc], [0],
+    [Whether or not to add -lc for building shared libraries])
+_LT_TAGDECL([allow_libtool_libs_with_static_runtimes],
+    [enable_shared_with_static_runtimes], [0],
+    [Whether or not to disallow shared libs when runtime libs are static])
+_LT_TAGDECL([], [export_dynamic_flag_spec], [1],
+    [Compiler flag to allow reflexive dlopens])
+_LT_TAGDECL([], [whole_archive_flag_spec], [1],
+    [Compiler flag to generate shared objects directly from archives])
+_LT_TAGDECL([], [compiler_needs_object], [1],
+    [Whether the compiler copes with passing no objects directly])
+_LT_TAGDECL([], [old_archive_from_new_cmds], [2],
+    [Create an old-style archive from a shared archive])
+_LT_TAGDECL([], [old_archive_from_expsyms_cmds], [2],
+    [Create a temporary old-style archive to link instead of a shared archive])
+_LT_TAGDECL([], [archive_cmds], [2], [Commands used to build a shared archive])
+_LT_TAGDECL([], [archive_expsym_cmds], [2])
+_LT_TAGDECL([], [module_cmds], [2],
+    [Commands used to build a loadable module if different from building
+    a shared archive.])
+_LT_TAGDECL([], [module_expsym_cmds], [2])
+_LT_TAGDECL([], [with_gnu_ld], [1],
+    [Whether we are building with GNU ld or not])
+_LT_TAGDECL([], [allow_undefined_flag], [1],
+    [Flag that allows shared libraries with undefined symbols to be built])
+_LT_TAGDECL([], [no_undefined_flag], [1],
+    [Flag that enforces no undefined symbols])
+_LT_TAGDECL([], [hardcode_libdir_flag_spec], [1],
+    [Flag to hardcode $libdir into a binary during linking.
+    This must work even if $libdir does not exist])
+_LT_TAGDECL([], [hardcode_libdir_separator], [1],
+    [Whether we need a single "-rpath" flag with a separated argument])
+_LT_TAGDECL([], [hardcode_direct], [0],
+    [Set to "yes" if using DIR/libNAME$shared_ext during linking hardcodes
+    DIR into the resulting binary])
+_LT_TAGDECL([], [hardcode_direct_absolute], [0],
+    [Set to "yes" if using DIR/libNAME$shared_ext during linking hardcodes
+    DIR into the resulting binary and the resulting library dependency is
+    "absolute", i.e impossible to change by setting $shlibpath_var if the
+    library is relocated])
+_LT_TAGDECL([], [hardcode_minus_L], [0],
+    [Set to "yes" if using the -LDIR flag during linking hardcodes DIR
+    into the resulting binary])
+_LT_TAGDECL([], [hardcode_shlibpath_var], [0],
+    [Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR
+    into the resulting binary])
+_LT_TAGDECL([], [hardcode_automatic], [0],
+    [Set to "yes" if building a shared library automatically hardcodes DIR
+    into the library and all subsequent libraries and executables linked
+    against it])
+_LT_TAGDECL([], [inherit_rpath], [0],
+    [Set to yes if linker adds runtime paths of dependent libraries
+    to runtime path list])
+_LT_TAGDECL([], [link_all_deplibs], [0],
+    [Whether libtool must link a program against all its dependency libraries])
+_LT_TAGDECL([], [always_export_symbols], [0],
+    [Set to "yes" if exported symbols are required])
+_LT_TAGDECL([], [export_symbols_cmds], [2],
+    [The commands to list exported symbols])
+_LT_TAGDECL([], [exclude_expsyms], [1],
+    [Symbols that should not be listed in the preloaded symbols])
+_LT_TAGDECL([], [include_expsyms], [1],
+    [Symbols that must always be exported])
+_LT_TAGDECL([], [prelink_cmds], [2],
+    [Commands necessary for linking programs (against libraries) with templates])
+_LT_TAGDECL([], [postlink_cmds], [2],
+    [Commands necessary for finishing linking programs])
+_LT_TAGDECL([], [file_list_spec], [1],
+    [Specify filename containing input files])
+dnl FIXME: Not yet implemented
+dnl _LT_TAGDECL([], [thread_safe_flag_spec], [1],
+dnl    [Compiler flag to generate thread safe objects])
+])# _LT_LINKER_SHLIBS
+
+
+# _LT_LANG_C_CONFIG([TAG])
+# ------------------------
+# Ensure that the configuration variables for a C compiler are suitably
+# defined.  These variables are subsequently used by _LT_CONFIG to write
+# the compiler configuration to 'libtool'.
+m4_defun([_LT_LANG_C_CONFIG],
+[m4_require([_LT_DECL_EGREP])dnl
+lt_save_CC=$CC
+AC_LANG_PUSH(C)
+
+# Source file extension for C test sources.
+ac_ext=c
+
+# Object file extension for compiled C test sources.
+objext=o
+_LT_TAGVAR(objext, $1)=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code="int some_variable = 0;"
+
+# Code to be used in simple link tests
+lt_simple_link_test_code='int main(){return(0);}'
+
+_LT_TAG_COMPILER
+# Save the default compiler, since it gets overwritten when the other
+# tags are being tested, and _LT_TAGVAR(compiler, []) is a NOP.
+compiler_DEFAULT=$CC
+
+# save warnings/boilerplate of simple test code
+_LT_COMPILER_BOILERPLATE
+_LT_LINKER_BOILERPLATE
+
+## CAVEAT EMPTOR:
+## There is no encapsulation within the following macros, do not change
+## the running order or otherwise move them around unless you know exactly
+## what you are doing...
+if test -n "$compiler"; then
+  _LT_COMPILER_NO_RTTI($1)
+  _LT_COMPILER_PIC($1)
+  _LT_COMPILER_C_O($1)
+  _LT_COMPILER_FILE_LOCKS($1)
+  _LT_LINKER_SHLIBS($1)
+  _LT_SYS_DYNAMIC_LINKER($1)
+  _LT_LINKER_HARDCODE_LIBPATH($1)
+  LT_SYS_DLOPEN_SELF
+  _LT_CMD_STRIPLIB
+
+  # Report what library types will actually be built
+  AC_MSG_CHECKING([if libtool supports shared libraries])
+  AC_MSG_RESULT([$can_build_shared])
+
+  AC_MSG_CHECKING([whether to build shared libraries])
+  test no = "$can_build_shared" && enable_shared=no
+
+  # On AIX, shared libraries and static libraries use the same namespace, and
+  # are all built from PIC.
+  case $host_os in
+  aix3*)
+    test yes = "$enable_shared" && enable_static=no
+    if test -n "$RANLIB"; then
+      archive_cmds="$archive_cmds~\$RANLIB \$lib"
+      postinstall_cmds='$RANLIB $lib'
+    fi
+    ;;
+
+  aix[[4-9]]*)
+    if test ia64 != "$host_cpu"; then
+      case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in
+      yes,aix,yes) ;;			# shared object as lib.so file only
+      yes,svr4,*) ;;			# shared object as lib.so archive member only
+      yes,*) enable_static=no ;;	# shared object in lib.a archive as well
+      esac
+    fi
+    ;;
+  esac
+  AC_MSG_RESULT([$enable_shared])
+
+  AC_MSG_CHECKING([whether to build static libraries])
+  # Make sure either enable_shared or enable_static is yes.
+  test yes = "$enable_shared" || enable_static=yes
+  AC_MSG_RESULT([$enable_static])
+
+  _LT_CONFIG($1)
+fi
+AC_LANG_POP
+CC=$lt_save_CC
+])# _LT_LANG_C_CONFIG
+
+
+# _LT_LANG_CXX_CONFIG([TAG])
+# --------------------------
+# Ensure that the configuration variables for a C++ compiler are suitably
+# defined.  These variables are subsequently used by _LT_CONFIG to write
+# the compiler configuration to 'libtool'.
+m4_defun([_LT_LANG_CXX_CONFIG],
+[m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+m4_require([_LT_DECL_EGREP])dnl
+m4_require([_LT_PATH_MANIFEST_TOOL])dnl
+if test -n "$CXX" && ( test no != "$CXX" &&
+    ( (test g++ = "$CXX" && `g++ -v >/dev/null 2>&1` ) ||
+    (test g++ != "$CXX"))); then
+  AC_PROG_CXXCPP
+else
+  _lt_caught_CXX_error=yes
+fi
+
+AC_LANG_PUSH(C++)
+_LT_TAGVAR(archive_cmds_need_lc, $1)=no
+_LT_TAGVAR(allow_undefined_flag, $1)=
+_LT_TAGVAR(always_export_symbols, $1)=no
+_LT_TAGVAR(archive_expsym_cmds, $1)=
+_LT_TAGVAR(compiler_needs_object, $1)=no
+_LT_TAGVAR(export_dynamic_flag_spec, $1)=
+_LT_TAGVAR(hardcode_direct, $1)=no
+_LT_TAGVAR(hardcode_direct_absolute, $1)=no
+_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
+_LT_TAGVAR(hardcode_libdir_separator, $1)=
+_LT_TAGVAR(hardcode_minus_L, $1)=no
+_LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
+_LT_TAGVAR(hardcode_automatic, $1)=no
+_LT_TAGVAR(inherit_rpath, $1)=no
+_LT_TAGVAR(module_cmds, $1)=
+_LT_TAGVAR(module_expsym_cmds, $1)=
+_LT_TAGVAR(link_all_deplibs, $1)=unknown
+_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
+_LT_TAGVAR(reload_flag, $1)=$reload_flag
+_LT_TAGVAR(reload_cmds, $1)=$reload_cmds
+_LT_TAGVAR(no_undefined_flag, $1)=
+_LT_TAGVAR(whole_archive_flag_spec, $1)=
+_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no
+
+# Source file extension for C++ test sources.
+ac_ext=cpp
+
+# Object file extension for compiled C++ test sources.
+objext=o
+_LT_TAGVAR(objext, $1)=$objext
+
+# No sense in running all these tests if we already determined that
+# the CXX compiler isn't working.  Some variables (like enable_shared)
+# are currently assumed to apply to all compilers on this platform,
+# and will be corrupted by setting them based on a non-working compiler.
+if test yes != "$_lt_caught_CXX_error"; then
+  # Code to be used in simple compile tests
+  lt_simple_compile_test_code="int some_variable = 0;"
+
+  # Code to be used in simple link tests
+  lt_simple_link_test_code='int main(int, char *[[]]) { return(0); }'
+
+  # ltmain only uses $CC for tagged configurations so make sure $CC is set.
+  _LT_TAG_COMPILER
+
+  # save warnings/boilerplate of simple test code
+  _LT_COMPILER_BOILERPLATE
+  _LT_LINKER_BOILERPLATE
+
+  # Allow CC to be a program name with arguments.
+  lt_save_CC=$CC
+  lt_save_CFLAGS=$CFLAGS
+  lt_save_LD=$LD
+  lt_save_GCC=$GCC
+  GCC=$GXX
+  lt_save_with_gnu_ld=$with_gnu_ld
+  lt_save_path_LD=$lt_cv_path_LD
+  if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then
+    lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx
+  else
+    $as_unset lt_cv_prog_gnu_ld
+  fi
+  if test -n "${lt_cv_path_LDCXX+set}"; then
+    lt_cv_path_LD=$lt_cv_path_LDCXX
+  else
+    $as_unset lt_cv_path_LD
+  fi
+  test -z "${LDCXX+set}" || LD=$LDCXX
+  CC=${CXX-"c++"}
+  CFLAGS=$CXXFLAGS
+  compiler=$CC
+  _LT_TAGVAR(compiler, $1)=$CC
+  _LT_CC_BASENAME([$compiler])
+
+  if test -n "$compiler"; then
+    # We don't want -fno-exception when compiling C++ code, so set the
+    # no_builtin_flag separately
+    if test yes = "$GXX"; then
+      _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin'
+    else
+      _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=
+    fi
+
+    if test yes = "$GXX"; then
+      # Set up default GNU C++ configuration
+
+      LT_PATH_LD
+
+      # Check if GNU C++ uses GNU ld as the underlying linker, since the
+      # archiving commands below assume that GNU ld is being used.
+      if test yes = "$with_gnu_ld"; then
+        _LT_TAGVAR(archive_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
+        _LT_TAGVAR(archive_expsym_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+
+        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
+        _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic'
+
+        # If archive_cmds runs LD, not CC, wlarc should be empty
+        # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to
+        #     investigate it a little bit more. (MM)
+        wlarc='$wl'
+
+        # ancient GNU ld didn't support --whole-archive et. al.
+        if eval "`$CC -print-prog-name=ld` --help 2>&1" |
+	  $GREP 'no-whole-archive' > /dev/null; then
+          _LT_TAGVAR(whole_archive_flag_spec, $1)=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive'
+        else
+          _LT_TAGVAR(whole_archive_flag_spec, $1)=
+        fi
+      else
+        with_gnu_ld=no
+        wlarc=
+
+        # A generic and very simple default shared library creation
+        # command for GNU C++ for the case where it uses the native
+        # linker, instead of GNU ld.  If possible, this setting should
+        # overridden to take advantage of the native linker features on
+        # the platform it is being used on.
+        _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
+      fi
+
+      # Commands to make compiler produce verbose output that lists
+      # what "hidden" libraries, object files and flags are used when
+      # linking a shared library.
+      output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
+
+    else
+      GXX=no
+      with_gnu_ld=no
+      wlarc=
+    fi
+
+    # PORTME: fill in a description of your system's C++ link characteristics
+    AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries])
+    _LT_TAGVAR(ld_shlibs, $1)=yes
+    case $host_os in
+      aix3*)
+        # FIXME: insert proper C++ library support
+        _LT_TAGVAR(ld_shlibs, $1)=no
+        ;;
+      aix[[4-9]]*)
+        if test ia64 = "$host_cpu"; then
+          # On IA64, the linker does run time linking by default, so we don't
+          # have to do anything special.
+          aix_use_runtimelinking=no
+          exp_sym_flag='-Bexport'
+          no_entry_flag=
+        else
+          aix_use_runtimelinking=no
+
+          # Test if we are trying to use run time linking or normal
+          # AIX style linking. If -brtl is somewhere in LDFLAGS, we
+          # have runtime linking enabled, and use it for executables.
+          # For shared libraries, we enable/disable runtime linking
+          # depending on the kind of the shared library created -
+          # when "with_aix_soname,aix_use_runtimelinking" is:
+          # "aix,no"   lib.a(lib.so.V) shared, rtl:no,  for executables
+          # "aix,yes"  lib.so          shared, rtl:yes, for executables
+          #            lib.a           static archive
+          # "both,no"  lib.so.V(shr.o) shared, rtl:yes
+          #            lib.a(lib.so.V) shared, rtl:no,  for executables
+          # "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables
+          #            lib.a(lib.so.V) shared, rtl:no
+          # "svr4,*"   lib.so.V(shr.o) shared, rtl:yes, for executables
+          #            lib.a           static archive
+          case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*)
+	    for ld_flag in $LDFLAGS; do
+	      case $ld_flag in
+	      *-brtl*)
+	        aix_use_runtimelinking=yes
+	        break
+	        ;;
+	      esac
+	    done
+	    if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then
+	      # With aix-soname=svr4, we create the lib.so.V shared archives only,
+	      # so we don't have lib.a shared libs to link our executables.
+	      # We have to force runtime linking in this case.
+	      aix_use_runtimelinking=yes
+	      LDFLAGS="$LDFLAGS -Wl,-brtl"
+	    fi
+	    ;;
+          esac
+
+          exp_sym_flag='-bexport'
+          no_entry_flag='-bnoentry'
+        fi
+
+        # When large executables or shared objects are built, AIX ld can
+        # have problems creating the table of contents.  If linking a library
+        # or program results in "error TOC overflow" add -mminimal-toc to
+        # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
+        # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
+
+        _LT_TAGVAR(archive_cmds, $1)=''
+        _LT_TAGVAR(hardcode_direct, $1)=yes
+        _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
+        _LT_TAGVAR(hardcode_libdir_separator, $1)=':'
+        _LT_TAGVAR(link_all_deplibs, $1)=yes
+        _LT_TAGVAR(file_list_spec, $1)='$wl-f,'
+        case $with_aix_soname,$aix_use_runtimelinking in
+        aix,*) ;;	# no import file
+        svr4,* | *,yes) # use import file
+          # The Import File defines what to hardcode.
+          _LT_TAGVAR(hardcode_direct, $1)=no
+          _LT_TAGVAR(hardcode_direct_absolute, $1)=no
+          ;;
+        esac
+
+        if test yes = "$GXX"; then
+          case $host_os in aix4.[[012]]|aix4.[[012]].*)
+          # We only want to do this on AIX 4.2 and lower, the check
+          # below for broken collect2 doesn't work under 4.3+
+	  collect2name=`$CC -print-prog-name=collect2`
+	  if test -f "$collect2name" &&
+	     strings "$collect2name" | $GREP resolve_lib_name >/dev/null
+	  then
+	    # We have reworked collect2
+	    :
+	  else
+	    # We have old collect2
+	    _LT_TAGVAR(hardcode_direct, $1)=unsupported
+	    # It fails to find uninstalled libraries when the uninstalled
+	    # path is not listed in the libpath.  Setting hardcode_minus_L
+	    # to unsupported forces relinking
+	    _LT_TAGVAR(hardcode_minus_L, $1)=yes
+	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+	    _LT_TAGVAR(hardcode_libdir_separator, $1)=
+	  fi
+          esac
+          shared_flag='-shared'
+	  if test yes = "$aix_use_runtimelinking"; then
+	    shared_flag=$shared_flag' $wl-G'
+	  fi
+	  # Need to ensure runtime linking is disabled for the traditional
+	  # shared library, or the linker may eventually find shared libraries
+	  # /with/ Import File - we do not want to mix them.
+	  shared_flag_aix='-shared'
+	  shared_flag_svr4='-shared $wl-G'
+        else
+          # not using gcc
+          if test ia64 = "$host_cpu"; then
+	  # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
+	  # chokes on -Wl,-G. The following line is correct:
+	  shared_flag='-G'
+          else
+	    if test yes = "$aix_use_runtimelinking"; then
+	      shared_flag='$wl-G'
+	    else
+	      shared_flag='$wl-bM:SRE'
+	    fi
+	    shared_flag_aix='$wl-bM:SRE'
+	    shared_flag_svr4='$wl-G'
+          fi
+        fi
+
+        _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-bexpall'
+        # It seems that -bexpall does not export symbols beginning with
+        # underscore (_), so it is better to generate a list of symbols to
+	# export.
+        _LT_TAGVAR(always_export_symbols, $1)=yes
+	if test aix,yes = "$with_aix_soname,$aix_use_runtimelinking"; then
+          # Warning - without using the other runtime loading flags (-brtl),
+          # -berok will link without error, but may produce a broken library.
+          # The "-G" linker flag allows undefined symbols.
+          _LT_TAGVAR(no_undefined_flag, $1)='-bernotok'
+          # Determine the default libpath from the value encoded in an empty
+          # executable.
+          _LT_SYS_MODULE_PATH_AIX([$1])
+          _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-blibpath:$libdir:'"$aix_libpath"
+
+          _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs $wl'$no_entry_flag' $compiler_flags `if test -n "$allow_undefined_flag"; then func_echo_all "$wl$allow_undefined_flag"; else :; fi` $wl'$exp_sym_flag:\$export_symbols' '$shared_flag
+        else
+          if test ia64 = "$host_cpu"; then
+	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R $libdir:/usr/lib:/lib'
+	    _LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs"
+	    _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\$wl$no_entry_flag"' $compiler_flags $wl$allow_undefined_flag '"\$wl$exp_sym_flag:\$export_symbols"
+          else
+	    # Determine the default libpath from the value encoded in an
+	    # empty executable.
+	    _LT_SYS_MODULE_PATH_AIX([$1])
+	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-blibpath:$libdir:'"$aix_libpath"
+	    # Warning - without using the other run time loading flags,
+	    # -berok will link without error, but may produce a broken library.
+	    _LT_TAGVAR(no_undefined_flag, $1)=' $wl-bernotok'
+	    _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-berok'
+	    if test yes = "$with_gnu_ld"; then
+	      # We only use this code for GNU lds that support --whole-archive.
+	      _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive$convenience $wl--no-whole-archive'
+	    else
+	      # Exported symbols can be pulled into shared objects from archives
+	      _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience'
+	    fi
+	    _LT_TAGVAR(archive_cmds_need_lc, $1)=yes
+	    _LT_TAGVAR(archive_expsym_cmds, $1)='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d'
+	    # -brtl affects multiple linker settings, -berok does not and is overridden later
+	    compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\\([[, ]]\\)%-berok\\1%g"`'
+	    if test svr4 != "$with_aix_soname"; then
+	      # This is similar to how AIX traditionally builds its shared
+	      # libraries. Need -bnortl late, we may have -brtl in LDFLAGS.
+	      _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname'
+	    fi
+	    if test aix != "$with_aix_soname"; then
+	      _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp'
+	    else
+	      # used by -dlpreopen to get the symbols
+	      _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$MV  $output_objdir/$realname.d/$soname $output_objdir'
+	    fi
+	    _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$RM -r $output_objdir/$realname.d'
+          fi
+        fi
+        ;;
+
+      beos*)
+	if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+	  _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+	  # Joseph Beckenbach <jrb3@best.com> says some releases of gcc
+	  # support --undefined.  This deserves some investigation.  FIXME
+	  _LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	else
+	  _LT_TAGVAR(ld_shlibs, $1)=no
+	fi
+	;;
+
+      chorus*)
+        case $cc_basename in
+          *)
+	  # FIXME: insert proper C++ library support
+	  _LT_TAGVAR(ld_shlibs, $1)=no
+	  ;;
+        esac
+        ;;
+
+      cygwin* | mingw* | pw32* | cegcc*)
+	case $GXX,$cc_basename in
+	,cl* | no,cl*)
+	  # Native MSVC
+	  # hardcode_libdir_flag_spec is actually meaningless, as there is
+	  # no search path for DLLs.
+	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' '
+	  _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+	  _LT_TAGVAR(always_export_symbols, $1)=yes
+	  _LT_TAGVAR(file_list_spec, $1)='@'
+	  # Tell ltmain to make .lib files, not .a files.
+	  libext=lib
+	  # Tell ltmain to make .dll files, not .so files.
+	  shrext_cmds=.dll
+	  # FIXME: Setting linknames here is a bad hack.
+	  _LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames='
+	  _LT_TAGVAR(archive_expsym_cmds, $1)='if _LT_DLL_DEF_P([$export_symbols]); then
+              cp "$export_symbols" "$output_objdir/$soname.def";
+              echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp";
+            else
+              $SED -e '\''s/^/-link -EXPORT:/'\'' < $export_symbols > $output_objdir/$soname.exp;
+            fi~
+            $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
+            linknames='
+	  # The linker will not automatically build a static lib if we build a DLL.
+	  # _LT_TAGVAR(old_archive_from_new_cmds, $1)='true'
+	  _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+	  # Don't use ranlib
+	  _LT_TAGVAR(old_postinstall_cmds, $1)='chmod 644 $oldlib'
+	  _LT_TAGVAR(postlink_cmds, $1)='lt_outputfile="@OUTPUT@"~
+            lt_tool_outputfile="@TOOL_OUTPUT@"~
+            case $lt_outputfile in
+              *.exe|*.EXE) ;;
+              *)
+                lt_outputfile=$lt_outputfile.exe
+                lt_tool_outputfile=$lt_tool_outputfile.exe
+                ;;
+            esac~
+            func_to_tool_file "$lt_outputfile"~
+            if test : != "$MANIFEST_TOOL" && test -f "$lt_outputfile.manifest"; then
+              $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;
+              $RM "$lt_outputfile.manifest";
+            fi'
+	  ;;
+	*)
+	  # g++
+	  # _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless,
+	  # as there is no search path for DLLs.
+	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+	  _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-all-symbols'
+	  _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+	  _LT_TAGVAR(always_export_symbols, $1)=no
+	  _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+
+	  if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
+	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+	    # If the export-symbols file already is a .def file, use it as
+	    # is; otherwise, prepend EXPORTS...
+	    _LT_TAGVAR(archive_expsym_cmds, $1)='if _LT_DLL_DEF_P([$export_symbols]); then
+              cp $export_symbols $output_objdir/$soname.def;
+            else
+              echo EXPORTS > $output_objdir/$soname.def;
+              cat $export_symbols >> $output_objdir/$soname.def;
+            fi~
+            $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+	  else
+	    _LT_TAGVAR(ld_shlibs, $1)=no
+	  fi
+	  ;;
+	esac
+	;;
+      darwin* | rhapsody*)
+        _LT_DARWIN_LINKER_FEATURES($1)
+	;;
+
+      os2*)
+	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+	_LT_TAGVAR(hardcode_minus_L, $1)=yes
+	_LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+	shrext_cmds=.dll
+	_LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	  $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	  $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	  $ECHO EXPORTS >> $output_objdir/$libname.def~
+	  emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
+	  $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	  emximp -o $lib $output_objdir/$libname.def'
+	_LT_TAGVAR(archive_expsym_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	  $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	  $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	  $ECHO EXPORTS >> $output_objdir/$libname.def~
+	  prefix_cmds="$SED"~
+	  if test EXPORTS = "`$SED 1q $export_symbols`"; then
+	    prefix_cmds="$prefix_cmds -e 1d";
+	  fi~
+	  prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~
+	  cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
+	  $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	  emximp -o $lib $output_objdir/$libname.def'
+	_LT_TAGVAR(old_archive_From_new_cmds, $1)='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
+	_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+	;;
+
+      dgux*)
+        case $cc_basename in
+          ec++*)
+	    # FIXME: insert proper C++ library support
+	    _LT_TAGVAR(ld_shlibs, $1)=no
+	    ;;
+          ghcx*)
+	    # Green Hills C++ Compiler
+	    # FIXME: insert proper C++ library support
+	    _LT_TAGVAR(ld_shlibs, $1)=no
+	    ;;
+          *)
+	    # FIXME: insert proper C++ library support
+	    _LT_TAGVAR(ld_shlibs, $1)=no
+	    ;;
+        esac
+        ;;
+
+      freebsd2.*)
+        # C++ shared libraries reported to be fairly broken before
+	# switch to ELF
+        _LT_TAGVAR(ld_shlibs, $1)=no
+        ;;
+
+      freebsd-elf*)
+        _LT_TAGVAR(archive_cmds_need_lc, $1)=no
+        ;;
+
+      freebsd* | dragonfly*)
+        # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF
+        # conventions
+        _LT_TAGVAR(ld_shlibs, $1)=yes
+        ;;
+
+      haiku*)
+        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+        _LT_TAGVAR(link_all_deplibs, $1)=yes
+        ;;
+
+      hpux9*)
+        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir'
+        _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+        _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E'
+        _LT_TAGVAR(hardcode_direct, $1)=yes
+        _LT_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH,
+				             # but as the default
+				             # location of the library.
+
+        case $cc_basename in
+          CC*)
+            # FIXME: insert proper C++ library support
+            _LT_TAGVAR(ld_shlibs, $1)=no
+            ;;
+          aCC*)
+            _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -b $wl+b $wl$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
+            # Commands to make compiler produce verbose output that lists
+            # what "hidden" libraries, object files and flags are used when
+            # linking a shared library.
+            #
+            # There doesn't appear to be a way to prevent this compiler from
+            # explicitly linking system object files so we need to strip them
+            # from the output so that they don't get included in the library
+            # dependencies.
+            output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "\-L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+            ;;
+          *)
+            if test yes = "$GXX"; then
+              _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared -nostdlib $pic_flag $wl+b $wl$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
+            else
+              # FIXME: insert proper C++ library support
+              _LT_TAGVAR(ld_shlibs, $1)=no
+            fi
+            ;;
+        esac
+        ;;
+
+      hpux10*|hpux11*)
+        if test no = "$with_gnu_ld"; then
+	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir'
+	  _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+
+          case $host_cpu in
+            hppa*64*|ia64*)
+              ;;
+            *)
+	      _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E'
+              ;;
+          esac
+        fi
+        case $host_cpu in
+          hppa*64*|ia64*)
+            _LT_TAGVAR(hardcode_direct, $1)=no
+            _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+            ;;
+          *)
+            _LT_TAGVAR(hardcode_direct, $1)=yes
+            _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
+            _LT_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH,
+					         # but as the default
+					         # location of the library.
+            ;;
+        esac
+
+        case $cc_basename in
+          CC*)
+	    # FIXME: insert proper C++ library support
+	    _LT_TAGVAR(ld_shlibs, $1)=no
+	    ;;
+          aCC*)
+	    case $host_cpu in
+	      hppa*64*)
+	        _LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	        ;;
+	      ia64*)
+	        _LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname $wl+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	        ;;
+	      *)
+	        _LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	        ;;
+	    esac
+	    # Commands to make compiler produce verbose output that lists
+	    # what "hidden" libraries, object files and flags are used when
+	    # linking a shared library.
+	    #
+	    # There doesn't appear to be a way to prevent this compiler from
+	    # explicitly linking system object files so we need to strip them
+	    # from the output so that they don't get included in the library
+	    # dependencies.
+	    output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP "\-L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+	    ;;
+          *)
+	    if test yes = "$GXX"; then
+	      if test no = "$with_gnu_ld"; then
+	        case $host_cpu in
+	          hppa*64*)
+	            _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC $wl+h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	            ;;
+	          ia64*)
+	            _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag $wl+h $wl$soname $wl+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	            ;;
+	          *)
+	            _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	            ;;
+	        esac
+	      fi
+	    else
+	      # FIXME: insert proper C++ library support
+	      _LT_TAGVAR(ld_shlibs, $1)=no
+	    fi
+	    ;;
+        esac
+        ;;
+
+      interix[[3-9]]*)
+	_LT_TAGVAR(hardcode_direct, $1)=no
+	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir'
+	_LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E'
+	# Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
+	# Instead, shared libraries are loaded at an image base (0x10000000 by
+	# default) and relocated if they conflict, which is a slow very memory
+	# consuming and fragmenting process.  To avoid this, we pick a random,
+	# 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
+	# time.  Moving up from 0x10000000 also allows more sbrk(2) space.
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+	_LT_TAGVAR(archive_expsym_cmds, $1)='sed "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--retain-symbols-file,$output_objdir/$soname.expsym $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+	;;
+      irix5* | irix6*)
+        case $cc_basename in
+          CC*)
+	    # SGI C++
+	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
+
+	    # Archives containing C++ object files must be created using
+	    # "CC -ar", where "CC" is the IRIX C++ compiler.  This is
+	    # necessary to make sure instantiated templates are included
+	    # in the archive.
+	    _LT_TAGVAR(old_archive_cmds, $1)='$CC -ar -WR,-u -o $oldlib $oldobjs'
+	    ;;
+          *)
+	    if test yes = "$GXX"; then
+	      if test no = "$with_gnu_ld"; then
+	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
+	      else
+	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` -o $lib'
+	      fi
+	    fi
+	    _LT_TAGVAR(link_all_deplibs, $1)=yes
+	    ;;
+        esac
+        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
+        _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+        _LT_TAGVAR(inherit_rpath, $1)=yes
+        ;;
+
+      linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+        case $cc_basename in
+          KCC*)
+	    # Kuck and Associates, Inc. (KAI) C++ Compiler
+
+	    # KCC will only create a shared library if the output file
+	    # ends with ".so" (or ".sl" for HP-UX), so rename the library
+	    # to its proper name (with version) after linking.
+	    _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\$tempext\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
+	    _LT_TAGVAR(archive_expsym_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\$tempext\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib $wl-retain-symbols-file,$export_symbols; mv \$templib $lib'
+	    # Commands to make compiler produce verbose output that lists
+	    # what "hidden" libraries, object files and flags are used when
+	    # linking a shared library.
+	    #
+	    # There doesn't appear to be a way to prevent this compiler from
+	    # explicitly linking system object files so we need to strip them
+	    # from the output so that they don't get included in the library
+	    # dependencies.
+	    output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+
+	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir'
+	    _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic'
+
+	    # Archives containing C++ object files must be created using
+	    # "CC -Bstatic", where "CC" is the KAI C++ compiler.
+	    _LT_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs'
+	    ;;
+	  icpc* | ecpc* )
+	    # Intel C++
+	    with_gnu_ld=yes
+	    # version 8.0 and above of icpc choke on multiply defined symbols
+	    # if we add $predep_objects and $postdep_objects, however 7.1 and
+	    # earlier do not add the objects themselves.
+	    case `$CC -V 2>&1` in
+	      *"Version 7."*)
+	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
+		_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+		;;
+	      *)  # Version 8.0 or newer
+	        tmp_idyn=
+	        case $host_cpu in
+		  ia64*) tmp_idyn=' -i_dynamic';;
+		esac
+	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+		_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+		;;
+	    esac
+	    _LT_TAGVAR(archive_cmds_need_lc, $1)=no
+	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir'
+	    _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic'
+	    _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive$convenience $wl--no-whole-archive'
+	    ;;
+          pgCC* | pgcpp*)
+            # Portland Group C++ compiler
+	    case `$CC -V` in
+	    *pgCC\ [[1-5]].* | *pgcpp\ [[1-5]].*)
+	      _LT_TAGVAR(prelink_cmds, $1)='tpldir=Template.dir~
+               rm -rf $tpldir~
+               $CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~
+               compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"'
+	      _LT_TAGVAR(old_archive_cmds, $1)='tpldir=Template.dir~
+                rm -rf $tpldir~
+                $CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~
+                $AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~
+                $RANLIB $oldlib'
+	      _LT_TAGVAR(archive_cmds, $1)='tpldir=Template.dir~
+                rm -rf $tpldir~
+                $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+                $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
+	      _LT_TAGVAR(archive_expsym_cmds, $1)='tpldir=Template.dir~
+                rm -rf $tpldir~
+                $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+                $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+	      ;;
+	    *) # Version 6 and above use weak symbols
+	      _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
+	      _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+	      ;;
+	    esac
+
+	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl--rpath $wl$libdir'
+	    _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic'
+	    _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
+            ;;
+	  cxx*)
+	    # Compaq C++
+	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
+	    _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname  -o $lib $wl-retain-symbols-file $wl$export_symbols'
+
+	    runpath_var=LD_RUN_PATH
+	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
+	    _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+
+	    # Commands to make compiler produce verbose output that lists
+	    # what "hidden" libraries, object files and flags are used when
+	    # linking a shared library.
+	    #
+	    # There doesn't appear to be a way to prevent this compiler from
+	    # explicitly linking system object files so we need to strip them
+	    # from the output so that they don't get included in the library
+	    # dependencies.
+	    output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "X$list" | $Xsed'
+	    ;;
+	  xl* | mpixl* | bgxl*)
+	    # IBM XL 8.0 on PPC, with GNU ld
+	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
+	    _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic'
+	    _LT_TAGVAR(archive_cmds, $1)='$CC -qmkshrobj $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	    if test yes = "$supports_anon_versioning"; then
+	      _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~
+                cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+                echo "local: *; };" >> $output_objdir/$libname.ver~
+                $CC -qmkshrobj $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-version-script $wl$output_objdir/$libname.ver -o $lib'
+	    fi
+	    ;;
+	  *)
+	    case `$CC -V 2>&1 | sed 5q` in
+	    *Sun\ C*)
+	      # Sun C++ 5.9
+	      _LT_TAGVAR(no_undefined_flag, $1)=' -zdefs'
+	      _LT_TAGVAR(archive_cmds, $1)='$CC -G$allow_undefined_flag -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	      _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G$allow_undefined_flag -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-retain-symbols-file $wl$export_symbols'
+	      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+	      _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
+	      _LT_TAGVAR(compiler_needs_object, $1)=yes
+
+	      # Not sure whether something based on
+	      # $CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1
+	      # would be better.
+	      output_verbose_link_cmd='func_echo_all'
+
+	      # Archives containing C++ object files must be created using
+	      # "CC -xar", where "CC" is the Sun C++ compiler.  This is
+	      # necessary to make sure instantiated templates are included
+	      # in the archive.
+	      _LT_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs'
+	      ;;
+	    esac
+	    ;;
+	esac
+	;;
+
+      lynxos*)
+        # FIXME: insert proper C++ library support
+	_LT_TAGVAR(ld_shlibs, $1)=no
+	;;
+
+      m88k*)
+        # FIXME: insert proper C++ library support
+        _LT_TAGVAR(ld_shlibs, $1)=no
+	;;
+
+      mvs*)
+        case $cc_basename in
+          cxx*)
+	    # FIXME: insert proper C++ library support
+	    _LT_TAGVAR(ld_shlibs, $1)=no
+	    ;;
+	  *)
+	    # FIXME: insert proper C++ library support
+	    _LT_TAGVAR(ld_shlibs, $1)=no
+	    ;;
+	esac
+	;;
+
+      netbsd*)
+        if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+	  _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable  -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags'
+	  wlarc=
+	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+	  _LT_TAGVAR(hardcode_direct, $1)=yes
+	  _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+	fi
+	# Workaround some broken pre-1.5 toolchains
+	output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"'
+	;;
+
+      *nto* | *qnx*)
+        _LT_TAGVAR(ld_shlibs, $1)=yes
+	;;
+
+      openbsd* | bitrig*)
+	if test -f /usr/libexec/ld.so; then
+	  _LT_TAGVAR(hardcode_direct, $1)=yes
+	  _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+	  _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
+	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
+	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir'
+	  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`"; then
+	    _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-retain-symbols-file,$export_symbols -o $lib'
+	    _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E'
+	    _LT_TAGVAR(whole_archive_flag_spec, $1)=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive'
+	  fi
+	  output_verbose_link_cmd=func_echo_all
+	else
+	  _LT_TAGVAR(ld_shlibs, $1)=no
+	fi
+	;;
+
+      osf3* | osf4* | osf5*)
+        case $cc_basename in
+          KCC*)
+	    # Kuck and Associates, Inc. (KAI) C++ Compiler
+
+	    # KCC will only create a shared library if the output file
+	    # ends with ".so" (or ".sl" for HP-UX), so rename the library
+	    # to its proper name (with version) after linking.
+	    _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo "$lib" | $SED -e "s/\$tempext\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
+
+	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir'
+	    _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+
+	    # Archives containing C++ object files must be created using
+	    # the KAI C++ compiler.
+	    case $host in
+	      osf3*) _LT_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs' ;;
+	      *) _LT_TAGVAR(old_archive_cmds, $1)='$CC -o $oldlib $oldobjs' ;;
+	    esac
+	    ;;
+          RCC*)
+	    # Rational C++ 2.4.1
+	    # FIXME: insert proper C++ library support
+	    _LT_TAGVAR(ld_shlibs, $1)=no
+	    ;;
+          cxx*)
+	    case $host in
+	      osf3*)
+	        _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-expect_unresolved $wl\*'
+	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $soname `test -n "$verstring" && func_echo_all "$wl-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
+	        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
+		;;
+	      *)
+	        _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
+	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
+	        _LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~
+                  echo "-hidden">> $lib.exp~
+                  $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname $wl-input $wl$lib.exp  `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib~
+                  $RM $lib.exp'
+	        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
+		;;
+	    esac
+
+	    _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+
+	    # Commands to make compiler produce verbose output that lists
+	    # what "hidden" libraries, object files and flags are used when
+	    # linking a shared library.
+	    #
+	    # There doesn't appear to be a way to prevent this compiler from
+	    # explicitly linking system object files so we need to strip them
+	    # from the output so that they don't get included in the library
+	    # dependencies.
+	    output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+	    ;;
+	  *)
+	    if test yes,no = "$GXX,$with_gnu_ld"; then
+	      _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-expect_unresolved $wl\*'
+	      case $host in
+	        osf3*)
+	          _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
+		  ;;
+	        *)
+	          _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-msym $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
+		  ;;
+	      esac
+
+	      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
+	      _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+
+	      # Commands to make compiler produce verbose output that lists
+	      # what "hidden" libraries, object files and flags are used when
+	      # linking a shared library.
+	      output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
+
+	    else
+	      # FIXME: insert proper C++ library support
+	      _LT_TAGVAR(ld_shlibs, $1)=no
+	    fi
+	    ;;
+        esac
+        ;;
+
+      psos*)
+        # FIXME: insert proper C++ library support
+        _LT_TAGVAR(ld_shlibs, $1)=no
+        ;;
+
+      sunos4*)
+        case $cc_basename in
+          CC*)
+	    # Sun C++ 4.x
+	    # FIXME: insert proper C++ library support
+	    _LT_TAGVAR(ld_shlibs, $1)=no
+	    ;;
+          lcc*)
+	    # Lucid
+	    # FIXME: insert proper C++ library support
+	    _LT_TAGVAR(ld_shlibs, $1)=no
+	    ;;
+          *)
+	    # FIXME: insert proper C++ library support
+	    _LT_TAGVAR(ld_shlibs, $1)=no
+	    ;;
+        esac
+        ;;
+
+      solaris*)
+        case $cc_basename in
+          CC* | sunCC*)
+	    # Sun C++ 4.2, 5.x and Centerline C++
+            _LT_TAGVAR(archive_cmds_need_lc,$1)=yes
+	    _LT_TAGVAR(no_undefined_flag, $1)=' -zdefs'
+	    _LT_TAGVAR(archive_cmds, $1)='$CC -G$allow_undefined_flag -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	    _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+              $CC -G$allow_undefined_flag $wl-M $wl$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
+
+	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+	    _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+	    case $host_os in
+	      solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;
+	      *)
+		# The compiler driver will combine and reorder linker options,
+		# but understands '-z linker_flag'.
+	        # Supported since Solaris 2.6 (maybe 2.5.1?)
+		_LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract'
+	        ;;
+	    esac
+	    _LT_TAGVAR(link_all_deplibs, $1)=yes
+
+	    output_verbose_link_cmd='func_echo_all'
+
+	    # Archives containing C++ object files must be created using
+	    # "CC -xar", where "CC" is the Sun C++ compiler.  This is
+	    # necessary to make sure instantiated templates are included
+	    # in the archive.
+	    _LT_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs'
+	    ;;
+          gcx*)
+	    # Green Hills C++ Compiler
+	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib'
+
+	    # The C++ compiler must be used to create the archive.
+	    _LT_TAGVAR(old_archive_cmds, $1)='$CC $LDFLAGS -archive -o $oldlib $oldobjs'
+	    ;;
+          *)
+	    # GNU C++ compiler with Solaris linker
+	    if test yes,no = "$GXX,$with_gnu_ld"; then
+	      _LT_TAGVAR(no_undefined_flag, $1)=' $wl-z ${wl}defs'
+	      if $CC --version | $GREP -v '^2\.7' > /dev/null; then
+	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib'
+	        _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+                  $CC -shared $pic_flag -nostdlib $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
+
+	        # Commands to make compiler produce verbose output that lists
+	        # what "hidden" libraries, object files and flags are used when
+	        # linking a shared library.
+	        output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
+	      else
+	        # g++ 2.7 appears to require '-G' NOT '-shared' on this
+	        # platform.
+	        _LT_TAGVAR(archive_cmds, $1)='$CC -G -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib'
+	        _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+                  $CC -G -nostdlib $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
+
+	        # Commands to make compiler produce verbose output that lists
+	        # what "hidden" libraries, object files and flags are used when
+	        # linking a shared library.
+	        output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
+	      fi
+
+	      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R $wl$libdir'
+	      case $host_os in
+		solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;
+		*)
+		  _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl-z ${wl}allextract$convenience $wl-z ${wl}defaultextract'
+		  ;;
+	      esac
+	    fi
+	    ;;
+        esac
+        ;;
+
+    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*)
+      _LT_TAGVAR(no_undefined_flag, $1)='$wl-z,text'
+      _LT_TAGVAR(archive_cmds_need_lc, $1)=no
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      runpath_var='LD_RUN_PATH'
+
+      case $cc_basename in
+        CC*)
+	  _LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	*)
+	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+      esac
+      ;;
+
+      sysv5* | sco3.2v5* | sco5v6*)
+	# Note: We CANNOT use -z defs as we might desire, because we do not
+	# link with -lc, and that would cause any symbols used from libc to
+	# always be unresolved, which means just about no library would
+	# ever link correctly.  If we're not using GNU ld we use -z text
+	# though, which does catch some bad symbols but isn't as heavy-handed
+	# as -z defs.
+	_LT_TAGVAR(no_undefined_flag, $1)='$wl-z,text'
+	_LT_TAGVAR(allow_undefined_flag, $1)='$wl-z,nodefs'
+	_LT_TAGVAR(archive_cmds_need_lc, $1)=no
+	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R,$libdir'
+	_LT_TAGVAR(hardcode_libdir_separator, $1)=':'
+	_LT_TAGVAR(link_all_deplibs, $1)=yes
+	_LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-Bexport'
+	runpath_var='LD_RUN_PATH'
+
+	case $cc_basename in
+          CC*)
+	    _LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	    _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	    _LT_TAGVAR(old_archive_cmds, $1)='$CC -Tprelink_objects $oldobjs~
+              '"$_LT_TAGVAR(old_archive_cmds, $1)"
+	    _LT_TAGVAR(reload_cmds, $1)='$CC -Tprelink_objects $reload_objs~
+              '"$_LT_TAGVAR(reload_cmds, $1)"
+	    ;;
+	  *)
+	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	    _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	    ;;
+	esac
+      ;;
+
+      tandem*)
+        case $cc_basename in
+          NCC*)
+	    # NonStop-UX NCC 3.20
+	    # FIXME: insert proper C++ library support
+	    _LT_TAGVAR(ld_shlibs, $1)=no
+	    ;;
+          *)
+	    # FIXME: insert proper C++ library support
+	    _LT_TAGVAR(ld_shlibs, $1)=no
+	    ;;
+        esac
+        ;;
+
+      vxworks*)
+        # FIXME: insert proper C++ library support
+        _LT_TAGVAR(ld_shlibs, $1)=no
+        ;;
+
+      *)
+        # FIXME: insert proper C++ library support
+        _LT_TAGVAR(ld_shlibs, $1)=no
+        ;;
+    esac
+
+    AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)])
+    test no = "$_LT_TAGVAR(ld_shlibs, $1)" && can_build_shared=no
+
+    _LT_TAGVAR(GCC, $1)=$GXX
+    _LT_TAGVAR(LD, $1)=$LD
+
+    ## CAVEAT EMPTOR:
+    ## There is no encapsulation within the following macros, do not change
+    ## the running order or otherwise move them around unless you know exactly
+    ## what you are doing...
+    _LT_SYS_HIDDEN_LIBDEPS($1)
+    _LT_COMPILER_PIC($1)
+    _LT_COMPILER_C_O($1)
+    _LT_COMPILER_FILE_LOCKS($1)
+    _LT_LINKER_SHLIBS($1)
+    _LT_SYS_DYNAMIC_LINKER($1)
+    _LT_LINKER_HARDCODE_LIBPATH($1)
+
+    _LT_CONFIG($1)
+  fi # test -n "$compiler"
+
+  CC=$lt_save_CC
+  CFLAGS=$lt_save_CFLAGS
+  LDCXX=$LD
+  LD=$lt_save_LD
+  GCC=$lt_save_GCC
+  with_gnu_ld=$lt_save_with_gnu_ld
+  lt_cv_path_LDCXX=$lt_cv_path_LD
+  lt_cv_path_LD=$lt_save_path_LD
+  lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld
+  lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld
+fi # test yes != "$_lt_caught_CXX_error"
+
+AC_LANG_POP
+])# _LT_LANG_CXX_CONFIG
+
+
+# _LT_FUNC_STRIPNAME_CNF
+# ----------------------
+# func_stripname_cnf prefix suffix name
+# strip PREFIX and SUFFIX off of NAME.
+# PREFIX and SUFFIX must not contain globbing or regex special
+# characters, hashes, percent signs, but SUFFIX may contain a leading
+# dot (in which case that matches only a dot).
+#
+# This function is identical to the (non-XSI) version of func_stripname,
+# except this one can be used by m4 code that may be executed by configure,
+# rather than the libtool script.
+m4_defun([_LT_FUNC_STRIPNAME_CNF],[dnl
+AC_REQUIRE([_LT_DECL_SED])
+AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH])
+func_stripname_cnf ()
+{
+  case @S|@2 in
+  .*) func_stripname_result=`$ECHO "@S|@3" | $SED "s%^@S|@1%%; s%\\\\@S|@2\$%%"`;;
+  *)  func_stripname_result=`$ECHO "@S|@3" | $SED "s%^@S|@1%%; s%@S|@2\$%%"`;;
+  esac
+} # func_stripname_cnf
+])# _LT_FUNC_STRIPNAME_CNF
+
+
+# _LT_SYS_HIDDEN_LIBDEPS([TAGNAME])
+# ---------------------------------
+# Figure out "hidden" library dependencies from verbose
+# compiler output when linking a shared library.
+# Parse the compiler output and extract the necessary
+# objects, libraries and library flags.
+m4_defun([_LT_SYS_HIDDEN_LIBDEPS],
+[m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+AC_REQUIRE([_LT_FUNC_STRIPNAME_CNF])dnl
+# Dependencies to place before and after the object being linked:
+_LT_TAGVAR(predep_objects, $1)=
+_LT_TAGVAR(postdep_objects, $1)=
+_LT_TAGVAR(predeps, $1)=
+_LT_TAGVAR(postdeps, $1)=
+_LT_TAGVAR(compiler_lib_search_path, $1)=
+
+dnl we can't use the lt_simple_compile_test_code here,
+dnl because it contains code intended for an executable,
+dnl not a library.  It's possible we should let each
+dnl tag define a new lt_????_link_test_code variable,
+dnl but it's only used here...
+m4_if([$1], [], [cat > conftest.$ac_ext <<_LT_EOF
+int a;
+void foo (void) { a = 0; }
+_LT_EOF
+], [$1], [CXX], [cat > conftest.$ac_ext <<_LT_EOF
+class Foo
+{
+public:
+  Foo (void) { a = 0; }
+private:
+  int a;
+};
+_LT_EOF
+], [$1], [F77], [cat > conftest.$ac_ext <<_LT_EOF
+      subroutine foo
+      implicit none
+      integer*4 a
+      a=0
+      return
+      end
+_LT_EOF
+], [$1], [FC], [cat > conftest.$ac_ext <<_LT_EOF
+      subroutine foo
+      implicit none
+      integer a
+      a=0
+      return
+      end
+_LT_EOF
+], [$1], [GCJ], [cat > conftest.$ac_ext <<_LT_EOF
+public class foo {
+  private int a;
+  public void bar (void) {
+    a = 0;
+  }
+};
+_LT_EOF
+], [$1], [GO], [cat > conftest.$ac_ext <<_LT_EOF
+package foo
+func foo() {
+}
+_LT_EOF
+])
+
+_lt_libdeps_save_CFLAGS=$CFLAGS
+case "$CC $CFLAGS " in #(
+*\ -flto*\ *) CFLAGS="$CFLAGS -fno-lto" ;;
+*\ -fwhopr*\ *) CFLAGS="$CFLAGS -fno-whopr" ;;
+*\ -fuse-linker-plugin*\ *) CFLAGS="$CFLAGS -fno-use-linker-plugin" ;;
+esac
+
+dnl Parse the compiler output and extract the necessary
+dnl objects, libraries and library flags.
+if AC_TRY_EVAL(ac_compile); then
+  # Parse the compiler output and extract the necessary
+  # objects, libraries and library flags.
+
+  # Sentinel used to keep track of whether or not we are before
+  # the conftest object file.
+  pre_test_object_deps_done=no
+
+  for p in `eval "$output_verbose_link_cmd"`; do
+    case $prev$p in
+
+    -L* | -R* | -l*)
+       # Some compilers place space between "-{L,R}" and the path.
+       # Remove the space.
+       if test x-L = "$p" ||
+          test x-R = "$p"; then
+	 prev=$p
+	 continue
+       fi
+
+       # Expand the sysroot to ease extracting the directories later.
+       if test -z "$prev"; then
+         case $p in
+         -L*) func_stripname_cnf '-L' '' "$p"; prev=-L; p=$func_stripname_result ;;
+         -R*) func_stripname_cnf '-R' '' "$p"; prev=-R; p=$func_stripname_result ;;
+         -l*) func_stripname_cnf '-l' '' "$p"; prev=-l; p=$func_stripname_result ;;
+         esac
+       fi
+       case $p in
+       =*) func_stripname_cnf '=' '' "$p"; p=$lt_sysroot$func_stripname_result ;;
+       esac
+       if test no = "$pre_test_object_deps_done"; then
+	 case $prev in
+	 -L | -R)
+	   # Internal compiler library paths should come after those
+	   # provided the user.  The postdeps already come after the
+	   # user supplied libs so there is no need to process them.
+	   if test -z "$_LT_TAGVAR(compiler_lib_search_path, $1)"; then
+	     _LT_TAGVAR(compiler_lib_search_path, $1)=$prev$p
+	   else
+	     _LT_TAGVAR(compiler_lib_search_path, $1)="${_LT_TAGVAR(compiler_lib_search_path, $1)} $prev$p"
+	   fi
+	   ;;
+	 # The "-l" case would never come before the object being
+	 # linked, so don't bother handling this case.
+	 esac
+       else
+	 if test -z "$_LT_TAGVAR(postdeps, $1)"; then
+	   _LT_TAGVAR(postdeps, $1)=$prev$p
+	 else
+	   _LT_TAGVAR(postdeps, $1)="${_LT_TAGVAR(postdeps, $1)} $prev$p"
+	 fi
+       fi
+       prev=
+       ;;
+
+    *.lto.$objext) ;; # Ignore GCC LTO objects
+    *.$objext)
+       # This assumes that the test object file only shows up
+       # once in the compiler output.
+       if test "$p" = "conftest.$objext"; then
+	 pre_test_object_deps_done=yes
+	 continue
+       fi
+
+       if test no = "$pre_test_object_deps_done"; then
+	 if test -z "$_LT_TAGVAR(predep_objects, $1)"; then
+	   _LT_TAGVAR(predep_objects, $1)=$p
+	 else
+	   _LT_TAGVAR(predep_objects, $1)="$_LT_TAGVAR(predep_objects, $1) $p"
+	 fi
+       else
+	 if test -z "$_LT_TAGVAR(postdep_objects, $1)"; then
+	   _LT_TAGVAR(postdep_objects, $1)=$p
+	 else
+	   _LT_TAGVAR(postdep_objects, $1)="$_LT_TAGVAR(postdep_objects, $1) $p"
+	 fi
+       fi
+       ;;
+
+    *) ;; # Ignore the rest.
+
+    esac
+  done
+
+  # Clean up.
+  rm -f a.out a.exe
+else
+  echo "libtool.m4: error: problem compiling $1 test program"
+fi
+
+$RM -f confest.$objext
+CFLAGS=$_lt_libdeps_save_CFLAGS
+
+# PORTME: override above test on systems where it is broken
+m4_if([$1], [CXX],
+[case $host_os in
+interix[[3-9]]*)
+  # Interix 3.5 installs completely hosed .la files for C++, so rather than
+  # hack all around it, let's just trust "g++" to DTRT.
+  _LT_TAGVAR(predep_objects,$1)=
+  _LT_TAGVAR(postdep_objects,$1)=
+  _LT_TAGVAR(postdeps,$1)=
+  ;;
+esac
+])
+
+case " $_LT_TAGVAR(postdeps, $1) " in
+*" -lc "*) _LT_TAGVAR(archive_cmds_need_lc, $1)=no ;;
+esac
+ _LT_TAGVAR(compiler_lib_search_dirs, $1)=
+if test -n "${_LT_TAGVAR(compiler_lib_search_path, $1)}"; then
+ _LT_TAGVAR(compiler_lib_search_dirs, $1)=`echo " ${_LT_TAGVAR(compiler_lib_search_path, $1)}" | $SED -e 's! -L! !g' -e 's!^ !!'`
+fi
+_LT_TAGDECL([], [compiler_lib_search_dirs], [1],
+    [The directories searched by this compiler when creating a shared library])
+_LT_TAGDECL([], [predep_objects], [1],
+    [Dependencies to place before and after the objects being linked to
+    create a shared library])
+_LT_TAGDECL([], [postdep_objects], [1])
+_LT_TAGDECL([], [predeps], [1])
+_LT_TAGDECL([], [postdeps], [1])
+_LT_TAGDECL([], [compiler_lib_search_path], [1],
+    [The library search path used internally by the compiler when linking
+    a shared library])
+])# _LT_SYS_HIDDEN_LIBDEPS
+
+
+# _LT_LANG_F77_CONFIG([TAG])
+# --------------------------
+# Ensure that the configuration variables for a Fortran 77 compiler are
+# suitably defined.  These variables are subsequently used by _LT_CONFIG
+# to write the compiler configuration to 'libtool'.
+m4_defun([_LT_LANG_F77_CONFIG],
+[AC_LANG_PUSH(Fortran 77)
+if test -z "$F77" || test no = "$F77"; then
+  _lt_disable_F77=yes
+fi
+
+_LT_TAGVAR(archive_cmds_need_lc, $1)=no
+_LT_TAGVAR(allow_undefined_flag, $1)=
+_LT_TAGVAR(always_export_symbols, $1)=no
+_LT_TAGVAR(archive_expsym_cmds, $1)=
+_LT_TAGVAR(export_dynamic_flag_spec, $1)=
+_LT_TAGVAR(hardcode_direct, $1)=no
+_LT_TAGVAR(hardcode_direct_absolute, $1)=no
+_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
+_LT_TAGVAR(hardcode_libdir_separator, $1)=
+_LT_TAGVAR(hardcode_minus_L, $1)=no
+_LT_TAGVAR(hardcode_automatic, $1)=no
+_LT_TAGVAR(inherit_rpath, $1)=no
+_LT_TAGVAR(module_cmds, $1)=
+_LT_TAGVAR(module_expsym_cmds, $1)=
+_LT_TAGVAR(link_all_deplibs, $1)=unknown
+_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
+_LT_TAGVAR(reload_flag, $1)=$reload_flag
+_LT_TAGVAR(reload_cmds, $1)=$reload_cmds
+_LT_TAGVAR(no_undefined_flag, $1)=
+_LT_TAGVAR(whole_archive_flag_spec, $1)=
+_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no
+
+# Source file extension for f77 test sources.
+ac_ext=f
+
+# Object file extension for compiled f77 test sources.
+objext=o
+_LT_TAGVAR(objext, $1)=$objext
+
+# No sense in running all these tests if we already determined that
+# the F77 compiler isn't working.  Some variables (like enable_shared)
+# are currently assumed to apply to all compilers on this platform,
+# and will be corrupted by setting them based on a non-working compiler.
+if test yes != "$_lt_disable_F77"; then
+  # Code to be used in simple compile tests
+  lt_simple_compile_test_code="\
+      subroutine t
+      return
+      end
+"
+
+  # Code to be used in simple link tests
+  lt_simple_link_test_code="\
+      program t
+      end
+"
+
+  # ltmain only uses $CC for tagged configurations so make sure $CC is set.
+  _LT_TAG_COMPILER
+
+  # save warnings/boilerplate of simple test code
+  _LT_COMPILER_BOILERPLATE
+  _LT_LINKER_BOILERPLATE
+
+  # Allow CC to be a program name with arguments.
+  lt_save_CC=$CC
+  lt_save_GCC=$GCC
+  lt_save_CFLAGS=$CFLAGS
+  CC=${F77-"f77"}
+  CFLAGS=$FFLAGS
+  compiler=$CC
+  _LT_TAGVAR(compiler, $1)=$CC
+  _LT_CC_BASENAME([$compiler])
+  GCC=$G77
+  if test -n "$compiler"; then
+    AC_MSG_CHECKING([if libtool supports shared libraries])
+    AC_MSG_RESULT([$can_build_shared])
+
+    AC_MSG_CHECKING([whether to build shared libraries])
+    test no = "$can_build_shared" && enable_shared=no
+
+    # On AIX, shared libraries and static libraries use the same namespace, and
+    # are all built from PIC.
+    case $host_os in
+      aix3*)
+        test yes = "$enable_shared" && enable_static=no
+        if test -n "$RANLIB"; then
+          archive_cmds="$archive_cmds~\$RANLIB \$lib"
+          postinstall_cmds='$RANLIB $lib'
+        fi
+        ;;
+      aix[[4-9]]*)
+	if test ia64 != "$host_cpu"; then
+	  case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in
+	  yes,aix,yes) ;;		# shared object as lib.so file only
+	  yes,svr4,*) ;;		# shared object as lib.so archive member only
+	  yes,*) enable_static=no ;;	# shared object in lib.a archive as well
+	  esac
+	fi
+        ;;
+    esac
+    AC_MSG_RESULT([$enable_shared])
+
+    AC_MSG_CHECKING([whether to build static libraries])
+    # Make sure either enable_shared or enable_static is yes.
+    test yes = "$enable_shared" || enable_static=yes
+    AC_MSG_RESULT([$enable_static])
+
+    _LT_TAGVAR(GCC, $1)=$G77
+    _LT_TAGVAR(LD, $1)=$LD
+
+    ## CAVEAT EMPTOR:
+    ## There is no encapsulation within the following macros, do not change
+    ## the running order or otherwise move them around unless you know exactly
+    ## what you are doing...
+    _LT_COMPILER_PIC($1)
+    _LT_COMPILER_C_O($1)
+    _LT_COMPILER_FILE_LOCKS($1)
+    _LT_LINKER_SHLIBS($1)
+    _LT_SYS_DYNAMIC_LINKER($1)
+    _LT_LINKER_HARDCODE_LIBPATH($1)
+
+    _LT_CONFIG($1)
+  fi # test -n "$compiler"
+
+  GCC=$lt_save_GCC
+  CC=$lt_save_CC
+  CFLAGS=$lt_save_CFLAGS
+fi # test yes != "$_lt_disable_F77"
+
+AC_LANG_POP
+])# _LT_LANG_F77_CONFIG
+
+
+# _LT_LANG_FC_CONFIG([TAG])
+# -------------------------
+# Ensure that the configuration variables for a Fortran compiler are
+# suitably defined.  These variables are subsequently used by _LT_CONFIG
+# to write the compiler configuration to 'libtool'.
+m4_defun([_LT_LANG_FC_CONFIG],
+[AC_LANG_PUSH(Fortran)
+
+if test -z "$FC" || test no = "$FC"; then
+  _lt_disable_FC=yes
+fi
+
+_LT_TAGVAR(archive_cmds_need_lc, $1)=no
+_LT_TAGVAR(allow_undefined_flag, $1)=
+_LT_TAGVAR(always_export_symbols, $1)=no
+_LT_TAGVAR(archive_expsym_cmds, $1)=
+_LT_TAGVAR(export_dynamic_flag_spec, $1)=
+_LT_TAGVAR(hardcode_direct, $1)=no
+_LT_TAGVAR(hardcode_direct_absolute, $1)=no
+_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
+_LT_TAGVAR(hardcode_libdir_separator, $1)=
+_LT_TAGVAR(hardcode_minus_L, $1)=no
+_LT_TAGVAR(hardcode_automatic, $1)=no
+_LT_TAGVAR(inherit_rpath, $1)=no
+_LT_TAGVAR(module_cmds, $1)=
+_LT_TAGVAR(module_expsym_cmds, $1)=
+_LT_TAGVAR(link_all_deplibs, $1)=unknown
+_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
+_LT_TAGVAR(reload_flag, $1)=$reload_flag
+_LT_TAGVAR(reload_cmds, $1)=$reload_cmds
+_LT_TAGVAR(no_undefined_flag, $1)=
+_LT_TAGVAR(whole_archive_flag_spec, $1)=
+_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no
+
+# Source file extension for fc test sources.
+ac_ext=${ac_fc_srcext-f}
+
+# Object file extension for compiled fc test sources.
+objext=o
+_LT_TAGVAR(objext, $1)=$objext
+
+# No sense in running all these tests if we already determined that
+# the FC compiler isn't working.  Some variables (like enable_shared)
+# are currently assumed to apply to all compilers on this platform,
+# and will be corrupted by setting them based on a non-working compiler.
+if test yes != "$_lt_disable_FC"; then
+  # Code to be used in simple compile tests
+  lt_simple_compile_test_code="\
+      subroutine t
+      return
+      end
+"
+
+  # Code to be used in simple link tests
+  lt_simple_link_test_code="\
+      program t
+      end
+"
+
+  # ltmain only uses $CC for tagged configurations so make sure $CC is set.
+  _LT_TAG_COMPILER
+
+  # save warnings/boilerplate of simple test code
+  _LT_COMPILER_BOILERPLATE
+  _LT_LINKER_BOILERPLATE
+
+  # Allow CC to be a program name with arguments.
+  lt_save_CC=$CC
+  lt_save_GCC=$GCC
+  lt_save_CFLAGS=$CFLAGS
+  CC=${FC-"f95"}
+  CFLAGS=$FCFLAGS
+  compiler=$CC
+  GCC=$ac_cv_fc_compiler_gnu
+
+  _LT_TAGVAR(compiler, $1)=$CC
+  _LT_CC_BASENAME([$compiler])
+
+  if test -n "$compiler"; then
+    AC_MSG_CHECKING([if libtool supports shared libraries])
+    AC_MSG_RESULT([$can_build_shared])
+
+    AC_MSG_CHECKING([whether to build shared libraries])
+    test no = "$can_build_shared" && enable_shared=no
+
+    # On AIX, shared libraries and static libraries use the same namespace, and
+    # are all built from PIC.
+    case $host_os in
+      aix3*)
+        test yes = "$enable_shared" && enable_static=no
+        if test -n "$RANLIB"; then
+          archive_cmds="$archive_cmds~\$RANLIB \$lib"
+          postinstall_cmds='$RANLIB $lib'
+        fi
+        ;;
+      aix[[4-9]]*)
+	if test ia64 != "$host_cpu"; then
+	  case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in
+	  yes,aix,yes) ;;		# shared object as lib.so file only
+	  yes,svr4,*) ;;		# shared object as lib.so archive member only
+	  yes,*) enable_static=no ;;	# shared object in lib.a archive as well
+	  esac
+	fi
+        ;;
+    esac
+    AC_MSG_RESULT([$enable_shared])
+
+    AC_MSG_CHECKING([whether to build static libraries])
+    # Make sure either enable_shared or enable_static is yes.
+    test yes = "$enable_shared" || enable_static=yes
+    AC_MSG_RESULT([$enable_static])
+
+    _LT_TAGVAR(GCC, $1)=$ac_cv_fc_compiler_gnu
+    _LT_TAGVAR(LD, $1)=$LD
+
+    ## CAVEAT EMPTOR:
+    ## There is no encapsulation within the following macros, do not change
+    ## the running order or otherwise move them around unless you know exactly
+    ## what you are doing...
+    _LT_SYS_HIDDEN_LIBDEPS($1)
+    _LT_COMPILER_PIC($1)
+    _LT_COMPILER_C_O($1)
+    _LT_COMPILER_FILE_LOCKS($1)
+    _LT_LINKER_SHLIBS($1)
+    _LT_SYS_DYNAMIC_LINKER($1)
+    _LT_LINKER_HARDCODE_LIBPATH($1)
+
+    _LT_CONFIG($1)
+  fi # test -n "$compiler"
+
+  GCC=$lt_save_GCC
+  CC=$lt_save_CC
+  CFLAGS=$lt_save_CFLAGS
+fi # test yes != "$_lt_disable_FC"
+
+AC_LANG_POP
+])# _LT_LANG_FC_CONFIG
+
+
+# _LT_LANG_GCJ_CONFIG([TAG])
+# --------------------------
+# Ensure that the configuration variables for the GNU Java Compiler compiler
+# are suitably defined.  These variables are subsequently used by _LT_CONFIG
+# to write the compiler configuration to 'libtool'.
+m4_defun([_LT_LANG_GCJ_CONFIG],
+[AC_REQUIRE([LT_PROG_GCJ])dnl
+AC_LANG_SAVE
+
+# Source file extension for Java test sources.
+ac_ext=java
+
+# Object file extension for compiled Java test sources.
+objext=o
+_LT_TAGVAR(objext, $1)=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code="class foo {}"
+
+# Code to be used in simple link tests
+lt_simple_link_test_code='public class conftest { public static void main(String[[]] argv) {}; }'
+
+# ltmain only uses $CC for tagged configurations so make sure $CC is set.
+_LT_TAG_COMPILER
+
+# save warnings/boilerplate of simple test code
+_LT_COMPILER_BOILERPLATE
+_LT_LINKER_BOILERPLATE
+
+# Allow CC to be a program name with arguments.
+lt_save_CC=$CC
+lt_save_CFLAGS=$CFLAGS
+lt_save_GCC=$GCC
+GCC=yes
+CC=${GCJ-"gcj"}
+CFLAGS=$GCJFLAGS
+compiler=$CC
+_LT_TAGVAR(compiler, $1)=$CC
+_LT_TAGVAR(LD, $1)=$LD
+_LT_CC_BASENAME([$compiler])
+
+# GCJ did not exist at the time GCC didn't implicitly link libc in.
+_LT_TAGVAR(archive_cmds_need_lc, $1)=no
+
+_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
+_LT_TAGVAR(reload_flag, $1)=$reload_flag
+_LT_TAGVAR(reload_cmds, $1)=$reload_cmds
+
+## CAVEAT EMPTOR:
+## There is no encapsulation within the following macros, do not change
+## the running order or otherwise move them around unless you know exactly
+## what you are doing...
+if test -n "$compiler"; then
+  _LT_COMPILER_NO_RTTI($1)
+  _LT_COMPILER_PIC($1)
+  _LT_COMPILER_C_O($1)
+  _LT_COMPILER_FILE_LOCKS($1)
+  _LT_LINKER_SHLIBS($1)
+  _LT_LINKER_HARDCODE_LIBPATH($1)
+
+  _LT_CONFIG($1)
+fi
+
+AC_LANG_RESTORE
+
+GCC=$lt_save_GCC
+CC=$lt_save_CC
+CFLAGS=$lt_save_CFLAGS
+])# _LT_LANG_GCJ_CONFIG
+
+
+# _LT_LANG_GO_CONFIG([TAG])
+# --------------------------
+# Ensure that the configuration variables for the GNU Go compiler
+# are suitably defined.  These variables are subsequently used by _LT_CONFIG
+# to write the compiler configuration to 'libtool'.
+m4_defun([_LT_LANG_GO_CONFIG],
+[AC_REQUIRE([LT_PROG_GO])dnl
+AC_LANG_SAVE
+
+# Source file extension for Go test sources.
+ac_ext=go
+
+# Object file extension for compiled Go test sources.
+objext=o
+_LT_TAGVAR(objext, $1)=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code="package main; func main() { }"
+
+# Code to be used in simple link tests
+lt_simple_link_test_code='package main; func main() { }'
+
+# ltmain only uses $CC for tagged configurations so make sure $CC is set.
+_LT_TAG_COMPILER
+
+# save warnings/boilerplate of simple test code
+_LT_COMPILER_BOILERPLATE
+_LT_LINKER_BOILERPLATE
+
+# Allow CC to be a program name with arguments.
+lt_save_CC=$CC
+lt_save_CFLAGS=$CFLAGS
+lt_save_GCC=$GCC
+GCC=yes
+CC=${GOC-"gccgo"}
+CFLAGS=$GOFLAGS
+compiler=$CC
+_LT_TAGVAR(compiler, $1)=$CC
+_LT_TAGVAR(LD, $1)=$LD
+_LT_CC_BASENAME([$compiler])
+
+# Go did not exist at the time GCC didn't implicitly link libc in.
+_LT_TAGVAR(archive_cmds_need_lc, $1)=no
+
+_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
+_LT_TAGVAR(reload_flag, $1)=$reload_flag
+_LT_TAGVAR(reload_cmds, $1)=$reload_cmds
+
+## CAVEAT EMPTOR:
+## There is no encapsulation within the following macros, do not change
+## the running order or otherwise move them around unless you know exactly
+## what you are doing...
+if test -n "$compiler"; then
+  _LT_COMPILER_NO_RTTI($1)
+  _LT_COMPILER_PIC($1)
+  _LT_COMPILER_C_O($1)
+  _LT_COMPILER_FILE_LOCKS($1)
+  _LT_LINKER_SHLIBS($1)
+  _LT_LINKER_HARDCODE_LIBPATH($1)
+
+  _LT_CONFIG($1)
+fi
+
+AC_LANG_RESTORE
+
+GCC=$lt_save_GCC
+CC=$lt_save_CC
+CFLAGS=$lt_save_CFLAGS
+])# _LT_LANG_GO_CONFIG
+
+
+# _LT_LANG_RC_CONFIG([TAG])
+# -------------------------
+# Ensure that the configuration variables for the Windows resource compiler
+# are suitably defined.  These variables are subsequently used by _LT_CONFIG
+# to write the compiler configuration to 'libtool'.
+m4_defun([_LT_LANG_RC_CONFIG],
+[AC_REQUIRE([LT_PROG_RC])dnl
+AC_LANG_SAVE
+
+# Source file extension for RC test sources.
+ac_ext=rc
+
+# Object file extension for compiled RC test sources.
+objext=o
+_LT_TAGVAR(objext, $1)=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code='sample MENU { MENUITEM "&Soup", 100, CHECKED }'
+
+# Code to be used in simple link tests
+lt_simple_link_test_code=$lt_simple_compile_test_code
+
+# ltmain only uses $CC for tagged configurations so make sure $CC is set.
+_LT_TAG_COMPILER
+
+# save warnings/boilerplate of simple test code
+_LT_COMPILER_BOILERPLATE
+_LT_LINKER_BOILERPLATE
+
+# Allow CC to be a program name with arguments.
+lt_save_CC=$CC
+lt_save_CFLAGS=$CFLAGS
+lt_save_GCC=$GCC
+GCC=
+CC=${RC-"windres"}
+CFLAGS=
+compiler=$CC
+_LT_TAGVAR(compiler, $1)=$CC
+_LT_CC_BASENAME([$compiler])
+_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes
+
+if test -n "$compiler"; then
+  :
+  _LT_CONFIG($1)
+fi
+
+GCC=$lt_save_GCC
+AC_LANG_RESTORE
+CC=$lt_save_CC
+CFLAGS=$lt_save_CFLAGS
+])# _LT_LANG_RC_CONFIG
+
+
+# LT_PROG_GCJ
+# -----------
+AC_DEFUN([LT_PROG_GCJ],
+[m4_ifdef([AC_PROG_GCJ], [AC_PROG_GCJ],
+  [m4_ifdef([A][M_PROG_GCJ], [A][M_PROG_GCJ],
+    [AC_CHECK_TOOL(GCJ, gcj,)
+      test set = "${GCJFLAGS+set}" || GCJFLAGS="-g -O2"
+      AC_SUBST(GCJFLAGS)])])[]dnl
+])
+
+# Old name:
+AU_ALIAS([LT_AC_PROG_GCJ], [LT_PROG_GCJ])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([LT_AC_PROG_GCJ], [])
+
+
+# LT_PROG_GO
+# ----------
+AC_DEFUN([LT_PROG_GO],
+[AC_CHECK_TOOL(GOC, gccgo,)
+])
+
+
+# LT_PROG_RC
+# ----------
+AC_DEFUN([LT_PROG_RC],
+[AC_CHECK_TOOL(RC, windres,)
+])
+
+# Old name:
+AU_ALIAS([LT_AC_PROG_RC], [LT_PROG_RC])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([LT_AC_PROG_RC], [])
+
+
+# _LT_DECL_EGREP
+# --------------
+# If we don't have a new enough Autoconf to choose the best grep
+# available, choose the one first in the user's PATH.
+m4_defun([_LT_DECL_EGREP],
+[AC_REQUIRE([AC_PROG_EGREP])dnl
+AC_REQUIRE([AC_PROG_FGREP])dnl
+test -z "$GREP" && GREP=grep
+_LT_DECL([], [GREP], [1], [A grep program that handles long lines])
+_LT_DECL([], [EGREP], [1], [An ERE matcher])
+_LT_DECL([], [FGREP], [1], [A literal string matcher])
+dnl Non-bleeding-edge autoconf doesn't subst GREP, so do it here too
+AC_SUBST([GREP])
+])
+
+
+# _LT_DECL_OBJDUMP
+# --------------
+# If we don't have a new enough Autoconf to choose the best objdump
+# available, choose the one first in the user's PATH.
+m4_defun([_LT_DECL_OBJDUMP],
+[AC_CHECK_TOOL(OBJDUMP, objdump, false)
+test -z "$OBJDUMP" && OBJDUMP=objdump
+_LT_DECL([], [OBJDUMP], [1], [An object symbol dumper])
+AC_SUBST([OBJDUMP])
+])
+
+# _LT_DECL_DLLTOOL
+# ----------------
+# Ensure DLLTOOL variable is set.
+m4_defun([_LT_DECL_DLLTOOL],
+[AC_CHECK_TOOL(DLLTOOL, dlltool, false)
+test -z "$DLLTOOL" && DLLTOOL=dlltool
+_LT_DECL([], [DLLTOOL], [1], [DLL creation program])
+AC_SUBST([DLLTOOL])
+])
+
+# _LT_DECL_SED
+# ------------
+# Check for a fully-functional sed program, that truncates
+# as few characters as possible.  Prefer GNU sed if found.
+m4_defun([_LT_DECL_SED],
+[AC_PROG_SED
+test -z "$SED" && SED=sed
+Xsed="$SED -e 1s/^X//"
+_LT_DECL([], [SED], [1], [A sed program that does not truncate output])
+_LT_DECL([], [Xsed], ["\$SED -e 1s/^X//"],
+    [Sed that helps us avoid accidentally triggering echo(1) options like -n])
+])# _LT_DECL_SED
+
+m4_ifndef([AC_PROG_SED], [
+############################################################
+# NOTE: This macro has been submitted for inclusion into   #
+#  GNU Autoconf as AC_PROG_SED.  When it is available in   #
+#  a released version of Autoconf we should remove this    #
+#  macro and use it instead.                               #
+############################################################
+
+m4_defun([AC_PROG_SED],
+[AC_MSG_CHECKING([for a sed that does not truncate output])
+AC_CACHE_VAL(lt_cv_path_SED,
+[# Loop through the user's path and test for sed and gsed.
+# Then use that list of sed's as ones to test for truncation.
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for lt_ac_prog in sed gsed; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      if $as_executable_p "$as_dir/$lt_ac_prog$ac_exec_ext"; then
+        lt_ac_sed_list="$lt_ac_sed_list $as_dir/$lt_ac_prog$ac_exec_ext"
+      fi
+    done
+  done
+done
+IFS=$as_save_IFS
+lt_ac_max=0
+lt_ac_count=0
+# Add /usr/xpg4/bin/sed as it is typically found on Solaris
+# along with /bin/sed that truncates output.
+for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do
+  test ! -f "$lt_ac_sed" && continue
+  cat /dev/null > conftest.in
+  lt_ac_count=0
+  echo $ECHO_N "0123456789$ECHO_C" >conftest.in
+  # Check for GNU sed and select it if it is found.
+  if "$lt_ac_sed" --version 2>&1 < /dev/null | grep 'GNU' > /dev/null; then
+    lt_cv_path_SED=$lt_ac_sed
+    break
+  fi
+  while true; do
+    cat conftest.in conftest.in >conftest.tmp
+    mv conftest.tmp conftest.in
+    cp conftest.in conftest.nl
+    echo >>conftest.nl
+    $lt_ac_sed -e 's/a$//' < conftest.nl >conftest.out || break
+    cmp -s conftest.out conftest.nl || break
+    # 10000 chars as input seems more than enough
+    test 10 -lt "$lt_ac_count" && break
+    lt_ac_count=`expr $lt_ac_count + 1`
+    if test "$lt_ac_count" -gt "$lt_ac_max"; then
+      lt_ac_max=$lt_ac_count
+      lt_cv_path_SED=$lt_ac_sed
+    fi
+  done
+done
+])
+SED=$lt_cv_path_SED
+AC_SUBST([SED])
+AC_MSG_RESULT([$SED])
+])#AC_PROG_SED
+])#m4_ifndef
+
+# Old name:
+AU_ALIAS([LT_AC_PROG_SED], [AC_PROG_SED])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([LT_AC_PROG_SED], [])
+
+
+# _LT_CHECK_SHELL_FEATURES
+# ------------------------
+# Find out whether the shell is Bourne or XSI compatible,
+# or has some other useful features.
+m4_defun([_LT_CHECK_SHELL_FEATURES],
+[if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
+  lt_unset=unset
+else
+  lt_unset=false
+fi
+_LT_DECL([], [lt_unset], [0], [whether the shell understands "unset"])dnl
+
+# test EBCDIC or ASCII
+case `echo X|tr X '\101'` in
+ A) # ASCII based system
+    # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
+  lt_SP2NL='tr \040 \012'
+  lt_NL2SP='tr \015\012 \040\040'
+  ;;
+ *) # EBCDIC based system
+  lt_SP2NL='tr \100 \n'
+  lt_NL2SP='tr \r\n \100\100'
+  ;;
+esac
+_LT_DECL([SP2NL], [lt_SP2NL], [1], [turn spaces into newlines])dnl
+_LT_DECL([NL2SP], [lt_NL2SP], [1], [turn newlines into spaces])dnl
+])# _LT_CHECK_SHELL_FEATURES
+
+
+# _LT_PATH_CONVERSION_FUNCTIONS
+# -----------------------------
+# Determine what file name conversion functions should be used by
+# func_to_host_file (and, implicitly, by func_to_host_path).  These are needed
+# for certain cross-compile configurations and native mingw.
+m4_defun([_LT_PATH_CONVERSION_FUNCTIONS],
+[AC_REQUIRE([AC_CANONICAL_HOST])dnl
+AC_REQUIRE([AC_CANONICAL_BUILD])dnl
+AC_MSG_CHECKING([how to convert $build file names to $host format])
+AC_CACHE_VAL(lt_cv_to_host_file_cmd,
+[case $host in
+  *-*-mingw* )
+    case $build in
+      *-*-mingw* ) # actually msys
+        lt_cv_to_host_file_cmd=func_convert_file_msys_to_w32
+        ;;
+      *-*-cygwin* )
+        lt_cv_to_host_file_cmd=func_convert_file_cygwin_to_w32
+        ;;
+      * ) # otherwise, assume *nix
+        lt_cv_to_host_file_cmd=func_convert_file_nix_to_w32
+        ;;
+    esac
+    ;;
+  *-*-cygwin* )
+    case $build in
+      *-*-mingw* ) # actually msys
+        lt_cv_to_host_file_cmd=func_convert_file_msys_to_cygwin
+        ;;
+      *-*-cygwin* )
+        lt_cv_to_host_file_cmd=func_convert_file_noop
+        ;;
+      * ) # otherwise, assume *nix
+        lt_cv_to_host_file_cmd=func_convert_file_nix_to_cygwin
+        ;;
+    esac
+    ;;
+  * ) # unhandled hosts (and "normal" native builds)
+    lt_cv_to_host_file_cmd=func_convert_file_noop
+    ;;
+esac
+])
+to_host_file_cmd=$lt_cv_to_host_file_cmd
+AC_MSG_RESULT([$lt_cv_to_host_file_cmd])
+_LT_DECL([to_host_file_cmd], [lt_cv_to_host_file_cmd],
+         [0], [convert $build file names to $host format])dnl
+
+AC_MSG_CHECKING([how to convert $build file names to toolchain format])
+AC_CACHE_VAL(lt_cv_to_tool_file_cmd,
+[#assume ordinary cross tools, or native build.
+lt_cv_to_tool_file_cmd=func_convert_file_noop
+case $host in
+  *-*-mingw* )
+    case $build in
+      *-*-mingw* ) # actually msys
+        lt_cv_to_tool_file_cmd=func_convert_file_msys_to_w32
+        ;;
+    esac
+    ;;
+esac
+])
+to_tool_file_cmd=$lt_cv_to_tool_file_cmd
+AC_MSG_RESULT([$lt_cv_to_tool_file_cmd])
+_LT_DECL([to_tool_file_cmd], [lt_cv_to_tool_file_cmd],
+         [0], [convert $build files to toolchain format])dnl
+])# _LT_PATH_CONVERSION_FUNCTIONS
diff --git a/Engine/lib/lpng/scripts/ltoptions.m4 b/Engine/lib/lpng/scripts/ltoptions.m4
new file mode 100644
index 000000000..94b082976
--- /dev/null
+++ b/Engine/lib/lpng/scripts/ltoptions.m4
@@ -0,0 +1,437 @@
+# Helper functions for option handling.                    -*- Autoconf -*-
+#
+#   Copyright (C) 2004-2005, 2007-2009, 2011-2015 Free Software
+#   Foundation, Inc.
+#   Written by Gary V. Vaughan, 2004
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+# serial 8 ltoptions.m4
+
+# This is to help aclocal find these macros, as it can't see m4_define.
+AC_DEFUN([LTOPTIONS_VERSION], [m4_if([1])])
+
+
+# _LT_MANGLE_OPTION(MACRO-NAME, OPTION-NAME)
+# ------------------------------------------
+m4_define([_LT_MANGLE_OPTION],
+[[_LT_OPTION_]m4_bpatsubst($1__$2, [[^a-zA-Z0-9_]], [_])])
+
+
+# _LT_SET_OPTION(MACRO-NAME, OPTION-NAME)
+# ---------------------------------------
+# Set option OPTION-NAME for macro MACRO-NAME, and if there is a
+# matching handler defined, dispatch to it.  Other OPTION-NAMEs are
+# saved as a flag.
+m4_define([_LT_SET_OPTION],
+[m4_define(_LT_MANGLE_OPTION([$1], [$2]))dnl
+m4_ifdef(_LT_MANGLE_DEFUN([$1], [$2]),
+        _LT_MANGLE_DEFUN([$1], [$2]),
+    [m4_warning([Unknown $1 option '$2'])])[]dnl
+])
+
+
+# _LT_IF_OPTION(MACRO-NAME, OPTION-NAME, IF-SET, [IF-NOT-SET])
+# ------------------------------------------------------------
+# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.
+m4_define([_LT_IF_OPTION],
+[m4_ifdef(_LT_MANGLE_OPTION([$1], [$2]), [$3], [$4])])
+
+
+# _LT_UNLESS_OPTIONS(MACRO-NAME, OPTION-LIST, IF-NOT-SET)
+# -------------------------------------------------------
+# Execute IF-NOT-SET unless all options in OPTION-LIST for MACRO-NAME
+# are set.
+m4_define([_LT_UNLESS_OPTIONS],
+[m4_foreach([_LT_Option], m4_split(m4_normalize([$2])),
+	    [m4_ifdef(_LT_MANGLE_OPTION([$1], _LT_Option),
+		      [m4_define([$0_found])])])[]dnl
+m4_ifdef([$0_found], [m4_undefine([$0_found])], [$3
+])[]dnl
+])
+
+
+# _LT_SET_OPTIONS(MACRO-NAME, OPTION-LIST)
+# ----------------------------------------
+# OPTION-LIST is a space-separated list of Libtool options associated
+# with MACRO-NAME.  If any OPTION has a matching handler declared with
+# LT_OPTION_DEFINE, dispatch to that macro; otherwise complain about
+# the unknown option and exit.
+m4_defun([_LT_SET_OPTIONS],
+[# Set options
+m4_foreach([_LT_Option], m4_split(m4_normalize([$2])),
+    [_LT_SET_OPTION([$1], _LT_Option)])
+
+m4_if([$1],[LT_INIT],[
+  dnl
+  dnl Simply set some default values (i.e off) if boolean options were not
+  dnl specified:
+  _LT_UNLESS_OPTIONS([LT_INIT], [dlopen], [enable_dlopen=no
+  ])
+  _LT_UNLESS_OPTIONS([LT_INIT], [win32-dll], [enable_win32_dll=no
+  ])
+  dnl
+  dnl If no reference was made to various pairs of opposing options, then
+  dnl we run the default mode handler for the pair.  For example, if neither
+  dnl 'shared' nor 'disable-shared' was passed, we enable building of shared
+  dnl archives by default:
+  _LT_UNLESS_OPTIONS([LT_INIT], [shared disable-shared], [_LT_ENABLE_SHARED])
+  _LT_UNLESS_OPTIONS([LT_INIT], [static disable-static], [_LT_ENABLE_STATIC])
+  _LT_UNLESS_OPTIONS([LT_INIT], [pic-only no-pic], [_LT_WITH_PIC])
+  _LT_UNLESS_OPTIONS([LT_INIT], [fast-install disable-fast-install],
+		   [_LT_ENABLE_FAST_INSTALL])
+  _LT_UNLESS_OPTIONS([LT_INIT], [aix-soname=aix aix-soname=both aix-soname=svr4],
+		   [_LT_WITH_AIX_SONAME([aix])])
+  ])
+])# _LT_SET_OPTIONS
+
+
+## --------------------------------- ##
+## Macros to handle LT_INIT options. ##
+## --------------------------------- ##
+
+# _LT_MANGLE_DEFUN(MACRO-NAME, OPTION-NAME)
+# -----------------------------------------
+m4_define([_LT_MANGLE_DEFUN],
+[[_LT_OPTION_DEFUN_]m4_bpatsubst(m4_toupper([$1__$2]), [[^A-Z0-9_]], [_])])
+
+
+# LT_OPTION_DEFINE(MACRO-NAME, OPTION-NAME, CODE)
+# -----------------------------------------------
+m4_define([LT_OPTION_DEFINE],
+[m4_define(_LT_MANGLE_DEFUN([$1], [$2]), [$3])[]dnl
+])# LT_OPTION_DEFINE
+
+
+# dlopen
+# ------
+LT_OPTION_DEFINE([LT_INIT], [dlopen], [enable_dlopen=yes
+])
+
+AU_DEFUN([AC_LIBTOOL_DLOPEN],
+[_LT_SET_OPTION([LT_INIT], [dlopen])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you
+put the 'dlopen' option into LT_INIT's first parameter.])
+])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_DLOPEN], [])
+
+
+# win32-dll
+# ---------
+# Declare package support for building win32 dll's.
+LT_OPTION_DEFINE([LT_INIT], [win32-dll],
+[enable_win32_dll=yes
+
+case $host in
+*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-cegcc*)
+  AC_CHECK_TOOL(AS, as, false)
+  AC_CHECK_TOOL(DLLTOOL, dlltool, false)
+  AC_CHECK_TOOL(OBJDUMP, objdump, false)
+  ;;
+esac
+
+test -z "$AS" && AS=as
+_LT_DECL([], [AS],      [1], [Assembler program])dnl
+
+test -z "$DLLTOOL" && DLLTOOL=dlltool
+_LT_DECL([], [DLLTOOL], [1], [DLL creation program])dnl
+
+test -z "$OBJDUMP" && OBJDUMP=objdump
+_LT_DECL([], [OBJDUMP], [1], [Object dumper program])dnl
+])# win32-dll
+
+AU_DEFUN([AC_LIBTOOL_WIN32_DLL],
+[AC_REQUIRE([AC_CANONICAL_HOST])dnl
+_LT_SET_OPTION([LT_INIT], [win32-dll])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you
+put the 'win32-dll' option into LT_INIT's first parameter.])
+])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_WIN32_DLL], [])
+
+
+# _LT_ENABLE_SHARED([DEFAULT])
+# ----------------------------
+# implement the --enable-shared flag, and supports the 'shared' and
+# 'disable-shared' LT_INIT options.
+# DEFAULT is either 'yes' or 'no'.  If omitted, it defaults to 'yes'.
+m4_define([_LT_ENABLE_SHARED],
+[m4_define([_LT_ENABLE_SHARED_DEFAULT], [m4_if($1, no, no, yes)])dnl
+AC_ARG_ENABLE([shared],
+    [AS_HELP_STRING([--enable-shared@<:@=PKGS@:>@],
+	[build shared libraries @<:@default=]_LT_ENABLE_SHARED_DEFAULT[@:>@])],
+    [p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_shared=yes ;;
+    no) enable_shared=no ;;
+    *)
+      enable_shared=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
+      for pkg in $enableval; do
+	IFS=$lt_save_ifs
+	if test "X$pkg" = "X$p"; then
+	  enable_shared=yes
+	fi
+      done
+      IFS=$lt_save_ifs
+      ;;
+    esac],
+    [enable_shared=]_LT_ENABLE_SHARED_DEFAULT)
+
+    _LT_DECL([build_libtool_libs], [enable_shared], [0],
+	[Whether or not to build shared libraries])
+])# _LT_ENABLE_SHARED
+
+LT_OPTION_DEFINE([LT_INIT], [shared], [_LT_ENABLE_SHARED([yes])])
+LT_OPTION_DEFINE([LT_INIT], [disable-shared], [_LT_ENABLE_SHARED([no])])
+
+# Old names:
+AC_DEFUN([AC_ENABLE_SHARED],
+[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[shared])
+])
+
+AC_DEFUN([AC_DISABLE_SHARED],
+[_LT_SET_OPTION([LT_INIT], [disable-shared])
+])
+
+AU_DEFUN([AM_ENABLE_SHARED], [AC_ENABLE_SHARED($@)])
+AU_DEFUN([AM_DISABLE_SHARED], [AC_DISABLE_SHARED($@)])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AM_ENABLE_SHARED], [])
+dnl AC_DEFUN([AM_DISABLE_SHARED], [])
+
+
+
+# _LT_ENABLE_STATIC([DEFAULT])
+# ----------------------------
+# implement the --enable-static flag, and support the 'static' and
+# 'disable-static' LT_INIT options.
+# DEFAULT is either 'yes' or 'no'.  If omitted, it defaults to 'yes'.
+m4_define([_LT_ENABLE_STATIC],
+[m4_define([_LT_ENABLE_STATIC_DEFAULT], [m4_if($1, no, no, yes)])dnl
+AC_ARG_ENABLE([static],
+    [AS_HELP_STRING([--enable-static@<:@=PKGS@:>@],
+	[build static libraries @<:@default=]_LT_ENABLE_STATIC_DEFAULT[@:>@])],
+    [p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_static=yes ;;
+    no) enable_static=no ;;
+    *)
+     enable_static=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
+      for pkg in $enableval; do
+	IFS=$lt_save_ifs
+	if test "X$pkg" = "X$p"; then
+	  enable_static=yes
+	fi
+      done
+      IFS=$lt_save_ifs
+      ;;
+    esac],
+    [enable_static=]_LT_ENABLE_STATIC_DEFAULT)
+
+    _LT_DECL([build_old_libs], [enable_static], [0],
+	[Whether or not to build static libraries])
+])# _LT_ENABLE_STATIC
+
+LT_OPTION_DEFINE([LT_INIT], [static], [_LT_ENABLE_STATIC([yes])])
+LT_OPTION_DEFINE([LT_INIT], [disable-static], [_LT_ENABLE_STATIC([no])])
+
+# Old names:
+AC_DEFUN([AC_ENABLE_STATIC],
+[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[static])
+])
+
+AC_DEFUN([AC_DISABLE_STATIC],
+[_LT_SET_OPTION([LT_INIT], [disable-static])
+])
+
+AU_DEFUN([AM_ENABLE_STATIC], [AC_ENABLE_STATIC($@)])
+AU_DEFUN([AM_DISABLE_STATIC], [AC_DISABLE_STATIC($@)])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AM_ENABLE_STATIC], [])
+dnl AC_DEFUN([AM_DISABLE_STATIC], [])
+
+
+
+# _LT_ENABLE_FAST_INSTALL([DEFAULT])
+# ----------------------------------
+# implement the --enable-fast-install flag, and support the 'fast-install'
+# and 'disable-fast-install' LT_INIT options.
+# DEFAULT is either 'yes' or 'no'.  If omitted, it defaults to 'yes'.
+m4_define([_LT_ENABLE_FAST_INSTALL],
+[m4_define([_LT_ENABLE_FAST_INSTALL_DEFAULT], [m4_if($1, no, no, yes)])dnl
+AC_ARG_ENABLE([fast-install],
+    [AS_HELP_STRING([--enable-fast-install@<:@=PKGS@:>@],
+    [optimize for fast installation @<:@default=]_LT_ENABLE_FAST_INSTALL_DEFAULT[@:>@])],
+    [p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_fast_install=yes ;;
+    no) enable_fast_install=no ;;
+    *)
+      enable_fast_install=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
+      for pkg in $enableval; do
+	IFS=$lt_save_ifs
+	if test "X$pkg" = "X$p"; then
+	  enable_fast_install=yes
+	fi
+      done
+      IFS=$lt_save_ifs
+      ;;
+    esac],
+    [enable_fast_install=]_LT_ENABLE_FAST_INSTALL_DEFAULT)
+
+_LT_DECL([fast_install], [enable_fast_install], [0],
+	 [Whether or not to optimize for fast installation])dnl
+])# _LT_ENABLE_FAST_INSTALL
+
+LT_OPTION_DEFINE([LT_INIT], [fast-install], [_LT_ENABLE_FAST_INSTALL([yes])])
+LT_OPTION_DEFINE([LT_INIT], [disable-fast-install], [_LT_ENABLE_FAST_INSTALL([no])])
+
+# Old names:
+AU_DEFUN([AC_ENABLE_FAST_INSTALL],
+[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[fast-install])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you put
+the 'fast-install' option into LT_INIT's first parameter.])
+])
+
+AU_DEFUN([AC_DISABLE_FAST_INSTALL],
+[_LT_SET_OPTION([LT_INIT], [disable-fast-install])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you put
+the 'disable-fast-install' option into LT_INIT's first parameter.])
+])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_ENABLE_FAST_INSTALL], [])
+dnl AC_DEFUN([AM_DISABLE_FAST_INSTALL], [])
+
+
+# _LT_WITH_AIX_SONAME([DEFAULT])
+# ----------------------------------
+# implement the --with-aix-soname flag, and support the `aix-soname=aix'
+# and `aix-soname=both' and `aix-soname=svr4' LT_INIT options. DEFAULT
+# is either `aix', `both' or `svr4'.  If omitted, it defaults to `aix'.
+m4_define([_LT_WITH_AIX_SONAME],
+[m4_define([_LT_WITH_AIX_SONAME_DEFAULT], [m4_if($1, svr4, svr4, m4_if($1, both, both, aix))])dnl
+shared_archive_member_spec=
+case $host,$enable_shared in
+power*-*-aix[[5-9]]*,yes)
+  AC_MSG_CHECKING([which variant of shared library versioning to provide])
+  AC_ARG_WITH([aix-soname],
+    [AS_HELP_STRING([--with-aix-soname=aix|svr4|both],
+      [shared library versioning (aka "SONAME") variant to provide on AIX, @<:@default=]_LT_WITH_AIX_SONAME_DEFAULT[@:>@.])],
+    [case $withval in
+    aix|svr4|both)
+      ;;
+    *)
+      AC_MSG_ERROR([Unknown argument to --with-aix-soname])
+      ;;
+    esac
+    lt_cv_with_aix_soname=$with_aix_soname],
+    [AC_CACHE_VAL([lt_cv_with_aix_soname],
+      [lt_cv_with_aix_soname=]_LT_WITH_AIX_SONAME_DEFAULT)
+    with_aix_soname=$lt_cv_with_aix_soname])
+  AC_MSG_RESULT([$with_aix_soname])
+  if test aix != "$with_aix_soname"; then
+    # For the AIX way of multilib, we name the shared archive member
+    # based on the bitwidth used, traditionally 'shr.o' or 'shr_64.o',
+    # and 'shr.imp' or 'shr_64.imp', respectively, for the Import File.
+    # Even when GNU compilers ignore OBJECT_MODE but need '-maix64' flag,
+    # the AIX toolchain works better with OBJECT_MODE set (default 32).
+    if test 64 = "${OBJECT_MODE-32}"; then
+      shared_archive_member_spec=shr_64
+    else
+      shared_archive_member_spec=shr
+    fi
+  fi
+  ;;
+*)
+  with_aix_soname=aix
+  ;;
+esac
+
+_LT_DECL([], [shared_archive_member_spec], [0],
+    [Shared archive member basename, for filename based shared library versioning on AIX])dnl
+])# _LT_WITH_AIX_SONAME
+
+LT_OPTION_DEFINE([LT_INIT], [aix-soname=aix], [_LT_WITH_AIX_SONAME([aix])])
+LT_OPTION_DEFINE([LT_INIT], [aix-soname=both], [_LT_WITH_AIX_SONAME([both])])
+LT_OPTION_DEFINE([LT_INIT], [aix-soname=svr4], [_LT_WITH_AIX_SONAME([svr4])])
+
+
+# _LT_WITH_PIC([MODE])
+# --------------------
+# implement the --with-pic flag, and support the 'pic-only' and 'no-pic'
+# LT_INIT options.
+# MODE is either 'yes' or 'no'.  If omitted, it defaults to 'both'.
+m4_define([_LT_WITH_PIC],
+[AC_ARG_WITH([pic],
+    [AS_HELP_STRING([--with-pic@<:@=PKGS@:>@],
+	[try to use only PIC/non-PIC objects @<:@default=use both@:>@])],
+    [lt_p=${PACKAGE-default}
+    case $withval in
+    yes|no) pic_mode=$withval ;;
+    *)
+      pic_mode=default
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
+      for lt_pkg in $withval; do
+	IFS=$lt_save_ifs
+	if test "X$lt_pkg" = "X$lt_p"; then
+	  pic_mode=yes
+	fi
+      done
+      IFS=$lt_save_ifs
+      ;;
+    esac],
+    [pic_mode=m4_default([$1], [default])])
+
+_LT_DECL([], [pic_mode], [0], [What type of objects to build])dnl
+])# _LT_WITH_PIC
+
+LT_OPTION_DEFINE([LT_INIT], [pic-only], [_LT_WITH_PIC([yes])])
+LT_OPTION_DEFINE([LT_INIT], [no-pic], [_LT_WITH_PIC([no])])
+
+# Old name:
+AU_DEFUN([AC_LIBTOOL_PICMODE],
+[_LT_SET_OPTION([LT_INIT], [pic-only])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you
+put the 'pic-only' option into LT_INIT's first parameter.])
+])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_PICMODE], [])
+
+## ----------------- ##
+## LTDL_INIT Options ##
+## ----------------- ##
+
+m4_define([_LTDL_MODE], [])
+LT_OPTION_DEFINE([LTDL_INIT], [nonrecursive],
+		 [m4_define([_LTDL_MODE], [nonrecursive])])
+LT_OPTION_DEFINE([LTDL_INIT], [recursive],
+		 [m4_define([_LTDL_MODE], [recursive])])
+LT_OPTION_DEFINE([LTDL_INIT], [subproject],
+		 [m4_define([_LTDL_MODE], [subproject])])
+
+m4_define([_LTDL_TYPE], [])
+LT_OPTION_DEFINE([LTDL_INIT], [installable],
+		 [m4_define([_LTDL_TYPE], [installable])])
+LT_OPTION_DEFINE([LTDL_INIT], [convenience],
+		 [m4_define([_LTDL_TYPE], [convenience])])
diff --git a/Engine/lib/lpng/scripts/ltsugar.m4 b/Engine/lib/lpng/scripts/ltsugar.m4
new file mode 100644
index 000000000..48bc9344a
--- /dev/null
+++ b/Engine/lib/lpng/scripts/ltsugar.m4
@@ -0,0 +1,124 @@
+# ltsugar.m4 -- libtool m4 base layer.                         -*-Autoconf-*-
+#
+# Copyright (C) 2004-2005, 2007-2008, 2011-2015 Free Software
+# Foundation, Inc.
+# Written by Gary V. Vaughan, 2004
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+# serial 6 ltsugar.m4
+
+# This is to help aclocal find these macros, as it can't see m4_define.
+AC_DEFUN([LTSUGAR_VERSION], [m4_if([0.1])])
+
+
+# lt_join(SEP, ARG1, [ARG2...])
+# -----------------------------
+# Produce ARG1SEPARG2...SEPARGn, omitting [] arguments and their
+# associated separator.
+# Needed until we can rely on m4_join from Autoconf 2.62, since all earlier
+# versions in m4sugar had bugs.
+m4_define([lt_join],
+[m4_if([$#], [1], [],
+       [$#], [2], [[$2]],
+       [m4_if([$2], [], [], [[$2]_])$0([$1], m4_shift(m4_shift($@)))])])
+m4_define([_lt_join],
+[m4_if([$#$2], [2], [],
+       [m4_if([$2], [], [], [[$1$2]])$0([$1], m4_shift(m4_shift($@)))])])
+
+
+# lt_car(LIST)
+# lt_cdr(LIST)
+# ------------
+# Manipulate m4 lists.
+# These macros are necessary as long as will still need to support
+# Autoconf-2.59, which quotes differently.
+m4_define([lt_car], [[$1]])
+m4_define([lt_cdr],
+[m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])],
+       [$#], 1, [],
+       [m4_dquote(m4_shift($@))])])
+m4_define([lt_unquote], $1)
+
+
+# lt_append(MACRO-NAME, STRING, [SEPARATOR])
+# ------------------------------------------
+# Redefine MACRO-NAME to hold its former content plus 'SEPARATOR''STRING'.
+# Note that neither SEPARATOR nor STRING are expanded; they are appended
+# to MACRO-NAME as is (leaving the expansion for when MACRO-NAME is invoked).
+# No SEPARATOR is output if MACRO-NAME was previously undefined (different
+# than defined and empty).
+#
+# This macro is needed until we can rely on Autoconf 2.62, since earlier
+# versions of m4sugar mistakenly expanded SEPARATOR but not STRING.
+m4_define([lt_append],
+[m4_define([$1],
+	   m4_ifdef([$1], [m4_defn([$1])[$3]])[$2])])
+
+
+
+# lt_combine(SEP, PREFIX-LIST, INFIX, SUFFIX1, [SUFFIX2...])
+# ----------------------------------------------------------
+# Produce a SEP delimited list of all paired combinations of elements of
+# PREFIX-LIST with SUFFIX1 through SUFFIXn.  Each element of the list
+# has the form PREFIXmINFIXSUFFIXn.
+# Needed until we can rely on m4_combine added in Autoconf 2.62.
+m4_define([lt_combine],
+[m4_if(m4_eval([$# > 3]), [1],
+       [m4_pushdef([_Lt_sep], [m4_define([_Lt_sep], m4_defn([lt_car]))])]]dnl
+[[m4_foreach([_Lt_prefix], [$2],
+	     [m4_foreach([_Lt_suffix],
+		]m4_dquote(m4_dquote(m4_shift(m4_shift(m4_shift($@)))))[,
+	[_Lt_sep([$1])[]m4_defn([_Lt_prefix])[$3]m4_defn([_Lt_suffix])])])])])
+
+
+# lt_if_append_uniq(MACRO-NAME, VARNAME, [SEPARATOR], [UNIQ], [NOT-UNIQ])
+# -----------------------------------------------------------------------
+# Iff MACRO-NAME does not yet contain VARNAME, then append it (delimited
+# by SEPARATOR if supplied) and expand UNIQ, else NOT-UNIQ.
+m4_define([lt_if_append_uniq],
+[m4_ifdef([$1],
+	  [m4_if(m4_index([$3]m4_defn([$1])[$3], [$3$2$3]), [-1],
+		 [lt_append([$1], [$2], [$3])$4],
+		 [$5])],
+	  [lt_append([$1], [$2], [$3])$4])])
+
+
+# lt_dict_add(DICT, KEY, VALUE)
+# -----------------------------
+m4_define([lt_dict_add],
+[m4_define([$1($2)], [$3])])
+
+
+# lt_dict_add_subkey(DICT, KEY, SUBKEY, VALUE)
+# --------------------------------------------
+m4_define([lt_dict_add_subkey],
+[m4_define([$1($2:$3)], [$4])])
+
+
+# lt_dict_fetch(DICT, KEY, [SUBKEY])
+# ----------------------------------
+m4_define([lt_dict_fetch],
+[m4_ifval([$3],
+	m4_ifdef([$1($2:$3)], [m4_defn([$1($2:$3)])]),
+    m4_ifdef([$1($2)], [m4_defn([$1($2)])]))])
+
+
+# lt_if_dict_fetch(DICT, KEY, [SUBKEY], VALUE, IF-TRUE, [IF-FALSE])
+# -----------------------------------------------------------------
+m4_define([lt_if_dict_fetch],
+[m4_if(lt_dict_fetch([$1], [$2], [$3]), [$4],
+	[$5],
+    [$6])])
+
+
+# lt_dict_filter(DICT, [SUBKEY], VALUE, [SEPARATOR], KEY, [...])
+# --------------------------------------------------------------
+m4_define([lt_dict_filter],
+[m4_if([$5], [], [],
+  [lt_join(m4_quote(m4_default([$4], [[, ]])),
+           lt_unquote(m4_split(m4_normalize(m4_foreach(_Lt_key, lt_car([m4_shiftn(4, $@)]),
+		      [lt_if_dict_fetch([$1], _Lt_key, [$2], [$3], [_Lt_key ])])))))])[]dnl
+])
diff --git a/Engine/lib/lpng/scripts/ltversion.m4 b/Engine/lib/lpng/scripts/ltversion.m4
new file mode 100644
index 000000000..fa04b52a3
--- /dev/null
+++ b/Engine/lib/lpng/scripts/ltversion.m4
@@ -0,0 +1,23 @@
+# ltversion.m4 -- version numbers			-*- Autoconf -*-
+#
+#   Copyright (C) 2004, 2011-2015 Free Software Foundation, Inc.
+#   Written by Scott James Remnant, 2004
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+# @configure_input@
+
+# serial 4179 ltversion.m4
+# This file is part of GNU Libtool
+
+m4_define([LT_PACKAGE_VERSION], [2.4.6])
+m4_define([LT_PACKAGE_REVISION], [2.4.6])
+
+AC_DEFUN([LTVERSION_VERSION],
+[macro_version='2.4.6'
+macro_revision='2.4.6'
+_LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?])
+_LT_DECL(, macro_revision, 0)
+])
diff --git a/Engine/lib/lpng/scripts/lt~obsolete.m4 b/Engine/lib/lpng/scripts/lt~obsolete.m4
new file mode 100644
index 000000000..c6b26f88f
--- /dev/null
+++ b/Engine/lib/lpng/scripts/lt~obsolete.m4
@@ -0,0 +1,99 @@
+# lt~obsolete.m4 -- aclocal satisfying obsolete definitions.    -*-Autoconf-*-
+#
+#   Copyright (C) 2004-2005, 2007, 2009, 2011-2015 Free Software
+#   Foundation, Inc.
+#   Written by Scott James Remnant, 2004.
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+# serial 5 lt~obsolete.m4
+
+# These exist entirely to fool aclocal when bootstrapping libtool.
+#
+# In the past libtool.m4 has provided macros via AC_DEFUN (or AU_DEFUN),
+# which have later been changed to m4_define as they aren't part of the
+# exported API, or moved to Autoconf or Automake where they belong.
+#
+# The trouble is, aclocal is a bit thick.  It'll see the old AC_DEFUN
+# in /usr/share/aclocal/libtool.m4 and remember it, then when it sees us
+# using a macro with the same name in our local m4/libtool.m4 it'll
+# pull the old libtool.m4 in (it doesn't see our shiny new m4_define
+# and doesn't know about Autoconf macros at all.)
+#
+# So we provide this file, which has a silly filename so it's always
+# included after everything else.  This provides aclocal with the
+# AC_DEFUNs it wants, but when m4 processes it, it doesn't do anything
+# because those macros already exist, or will be overwritten later.
+# We use AC_DEFUN over AU_DEFUN for compatibility with aclocal-1.6.
+#
+# Anytime we withdraw an AC_DEFUN or AU_DEFUN, remember to add it here.
+# Yes, that means every name once taken will need to remain here until
+# we give up compatibility with versions before 1.7, at which point
+# we need to keep only those names which we still refer to.
+
+# This is to help aclocal find these macros, as it can't see m4_define.
+AC_DEFUN([LTOBSOLETE_VERSION], [m4_if([1])])
+
+m4_ifndef([AC_LIBTOOL_LINKER_OPTION],	[AC_DEFUN([AC_LIBTOOL_LINKER_OPTION])])
+m4_ifndef([AC_PROG_EGREP],		[AC_DEFUN([AC_PROG_EGREP])])
+m4_ifndef([_LT_AC_PROG_ECHO_BACKSLASH],	[AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH])])
+m4_ifndef([_LT_AC_SHELL_INIT],		[AC_DEFUN([_LT_AC_SHELL_INIT])])
+m4_ifndef([_LT_AC_SYS_LIBPATH_AIX],	[AC_DEFUN([_LT_AC_SYS_LIBPATH_AIX])])
+m4_ifndef([_LT_PROG_LTMAIN],		[AC_DEFUN([_LT_PROG_LTMAIN])])
+m4_ifndef([_LT_AC_TAGVAR],		[AC_DEFUN([_LT_AC_TAGVAR])])
+m4_ifndef([AC_LTDL_ENABLE_INSTALL],	[AC_DEFUN([AC_LTDL_ENABLE_INSTALL])])
+m4_ifndef([AC_LTDL_PREOPEN],		[AC_DEFUN([AC_LTDL_PREOPEN])])
+m4_ifndef([_LT_AC_SYS_COMPILER],	[AC_DEFUN([_LT_AC_SYS_COMPILER])])
+m4_ifndef([_LT_AC_LOCK],		[AC_DEFUN([_LT_AC_LOCK])])
+m4_ifndef([AC_LIBTOOL_SYS_OLD_ARCHIVE],	[AC_DEFUN([AC_LIBTOOL_SYS_OLD_ARCHIVE])])
+m4_ifndef([_LT_AC_TRY_DLOPEN_SELF],	[AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF])])
+m4_ifndef([AC_LIBTOOL_PROG_CC_C_O],	[AC_DEFUN([AC_LIBTOOL_PROG_CC_C_O])])
+m4_ifndef([AC_LIBTOOL_SYS_HARD_LINK_LOCKS], [AC_DEFUN([AC_LIBTOOL_SYS_HARD_LINK_LOCKS])])
+m4_ifndef([AC_LIBTOOL_OBJDIR],		[AC_DEFUN([AC_LIBTOOL_OBJDIR])])
+m4_ifndef([AC_LTDL_OBJDIR],		[AC_DEFUN([AC_LTDL_OBJDIR])])
+m4_ifndef([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH], [AC_DEFUN([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH])])
+m4_ifndef([AC_LIBTOOL_SYS_LIB_STRIP],	[AC_DEFUN([AC_LIBTOOL_SYS_LIB_STRIP])])
+m4_ifndef([AC_PATH_MAGIC],		[AC_DEFUN([AC_PATH_MAGIC])])
+m4_ifndef([AC_PROG_LD_GNU],		[AC_DEFUN([AC_PROG_LD_GNU])])
+m4_ifndef([AC_PROG_LD_RELOAD_FLAG],	[AC_DEFUN([AC_PROG_LD_RELOAD_FLAG])])
+m4_ifndef([AC_DEPLIBS_CHECK_METHOD],	[AC_DEFUN([AC_DEPLIBS_CHECK_METHOD])])
+m4_ifndef([AC_LIBTOOL_PROG_COMPILER_NO_RTTI], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_NO_RTTI])])
+m4_ifndef([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE], [AC_DEFUN([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE])])
+m4_ifndef([AC_LIBTOOL_PROG_COMPILER_PIC], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_PIC])])
+m4_ifndef([AC_LIBTOOL_PROG_LD_SHLIBS],	[AC_DEFUN([AC_LIBTOOL_PROG_LD_SHLIBS])])
+m4_ifndef([AC_LIBTOOL_POSTDEP_PREDEP],	[AC_DEFUN([AC_LIBTOOL_POSTDEP_PREDEP])])
+m4_ifndef([LT_AC_PROG_EGREP],		[AC_DEFUN([LT_AC_PROG_EGREP])])
+m4_ifndef([LT_AC_PROG_SED],		[AC_DEFUN([LT_AC_PROG_SED])])
+m4_ifndef([_LT_CC_BASENAME],		[AC_DEFUN([_LT_CC_BASENAME])])
+m4_ifndef([_LT_COMPILER_BOILERPLATE],	[AC_DEFUN([_LT_COMPILER_BOILERPLATE])])
+m4_ifndef([_LT_LINKER_BOILERPLATE],	[AC_DEFUN([_LT_LINKER_BOILERPLATE])])
+m4_ifndef([_AC_PROG_LIBTOOL],		[AC_DEFUN([_AC_PROG_LIBTOOL])])
+m4_ifndef([AC_LIBTOOL_SETUP],		[AC_DEFUN([AC_LIBTOOL_SETUP])])
+m4_ifndef([_LT_AC_CHECK_DLFCN],		[AC_DEFUN([_LT_AC_CHECK_DLFCN])])
+m4_ifndef([AC_LIBTOOL_SYS_DYNAMIC_LINKER],	[AC_DEFUN([AC_LIBTOOL_SYS_DYNAMIC_LINKER])])
+m4_ifndef([_LT_AC_TAGCONFIG],		[AC_DEFUN([_LT_AC_TAGCONFIG])])
+m4_ifndef([AC_DISABLE_FAST_INSTALL],	[AC_DEFUN([AC_DISABLE_FAST_INSTALL])])
+m4_ifndef([_LT_AC_LANG_CXX],		[AC_DEFUN([_LT_AC_LANG_CXX])])
+m4_ifndef([_LT_AC_LANG_F77],		[AC_DEFUN([_LT_AC_LANG_F77])])
+m4_ifndef([_LT_AC_LANG_GCJ],		[AC_DEFUN([_LT_AC_LANG_GCJ])])
+m4_ifndef([AC_LIBTOOL_LANG_C_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_C_CONFIG])])
+m4_ifndef([_LT_AC_LANG_C_CONFIG],	[AC_DEFUN([_LT_AC_LANG_C_CONFIG])])
+m4_ifndef([AC_LIBTOOL_LANG_CXX_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_CXX_CONFIG])])
+m4_ifndef([_LT_AC_LANG_CXX_CONFIG],	[AC_DEFUN([_LT_AC_LANG_CXX_CONFIG])])
+m4_ifndef([AC_LIBTOOL_LANG_F77_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_F77_CONFIG])])
+m4_ifndef([_LT_AC_LANG_F77_CONFIG],	[AC_DEFUN([_LT_AC_LANG_F77_CONFIG])])
+m4_ifndef([AC_LIBTOOL_LANG_GCJ_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_GCJ_CONFIG])])
+m4_ifndef([_LT_AC_LANG_GCJ_CONFIG],	[AC_DEFUN([_LT_AC_LANG_GCJ_CONFIG])])
+m4_ifndef([AC_LIBTOOL_LANG_RC_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_RC_CONFIG])])
+m4_ifndef([_LT_AC_LANG_RC_CONFIG],	[AC_DEFUN([_LT_AC_LANG_RC_CONFIG])])
+m4_ifndef([AC_LIBTOOL_CONFIG],		[AC_DEFUN([AC_LIBTOOL_CONFIG])])
+m4_ifndef([_LT_AC_FILE_LTDLL_C],	[AC_DEFUN([_LT_AC_FILE_LTDLL_C])])
+m4_ifndef([_LT_REQUIRED_DARWIN_CHECKS],	[AC_DEFUN([_LT_REQUIRED_DARWIN_CHECKS])])
+m4_ifndef([_LT_AC_PROG_CXXCPP],		[AC_DEFUN([_LT_AC_PROG_CXXCPP])])
+m4_ifndef([_LT_PREPARE_SED_QUOTE_VARS],	[AC_DEFUN([_LT_PREPARE_SED_QUOTE_VARS])])
+m4_ifndef([_LT_PROG_ECHO_BACKSLASH],	[AC_DEFUN([_LT_PROG_ECHO_BACKSLASH])])
+m4_ifndef([_LT_PROG_F77],		[AC_DEFUN([_LT_PROG_F77])])
+m4_ifndef([_LT_PROG_FC],		[AC_DEFUN([_LT_PROG_FC])])
+m4_ifndef([_LT_PROG_CXX],		[AC_DEFUN([_LT_PROG_CXX])])
diff --git a/Engine/lib/lpng/scripts/macro.lst b/Engine/lib/lpng/scripts/macro.lst
new file mode 100644
index 000000000..57124b76a
--- /dev/null
+++ b/Engine/lib/lpng/scripts/macro.lst
@@ -0,0 +1,3 @@
+get_uint_32(buf)
+get_uint_16(buf)
+get_int_32(buf)
diff --git a/Engine/lib/lpng/scripts/makefile.32sunu b/Engine/lib/lpng/scripts/makefile.32sunu
new file mode 100644
index 000000000..c849ecd27
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.32sunu
@@ -0,0 +1,244 @@
+# makefile for libpng on Solaris 2.x with cc
+# Contributed by William L. Sebok, based on makefile.linux
+# Copyright (C) 2002, 2006, 2010-2014 Glenn Randers-Pehrson
+# Copyright (C) 1998 Greg Roelofs
+# Copyright (C) 1996, 1997 Andreas Dilger
+
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# Library name:
+LIBNAME=libpng16
+PNGMAJ = 16
+
+# Shared library names:
+LIBSO=$(LIBNAME).so
+LIBSOMAJ=$(LIBNAME).so.$(PNGMAJ)
+LIBSOREL=$(LIBSOMAJ).$(RELEASE)
+OLDSO=libpng.so
+
+# Utilities:
+CC=cc
+AR_RC=ar rc
+MKDIR_P=mkdir -p
+LN_SF=ln -f -s
+RANLIB=echo
+RM_F=/bin/rm -f
+
+SUN_CC_FLAGS=-fast -xtarget=ultra
+SUN_LD_FLAGS=-fast -xtarget=ultra
+
+# where make install puts libpng.a, libpng16.so and libpng16/png.h
+prefix=/a
+exec_prefix=$(prefix)
+
+# Where the zlib library and include files are located
+# Changing these to ../zlib poses a security risk.  If you want
+# to have zlib in an adjacent directory, specify the full path instead of "..".
+#ZLIBLIB=../zlib
+#ZLIBINC=../zlib
+
+ZLIBLIB=/usr/lib
+ZLIBINC=/usr/include
+
+WARNMORE=-Wwrite-strings -Wpointer-arith -Wshadow \
+	-Wmissing-declarations -Wtraditional -Wcast-align \
+	-Wstrict-prototypes -Wmissing-prototypes #-Wconversion
+CPPFLAGS=-I$(ZLIBINC) # -DPNG_DEBUG=5
+CFLAGS=$(SUN_CC_FLAGS) # $(WARNMORE) -g
+LDFLAGS=$(SUN_LD_FLAGS) -L$(ZLIBLIB) -R$(ZLIBLIB) libpng.a -lz -lm
+
+INCPATH=$(prefix)/include
+LIBPATH=$(exec_prefix)/lib
+MANPATH=$(prefix)/man
+BINPATH=$(exec_prefix)/bin
+
+# override DESTDIR= on the make install command line to easily support
+# installing into a temporary location.  Example:
+#
+#    make install DESTDIR=/tmp/build/libpng
+#
+# If you're going to install into a temporary location
+# via DESTDIR, $(DESTDIR)$(prefix) must already exist before
+# you execute make install.
+DESTDIR=
+
+DB=$(DESTDIR)$(BINPATH)
+DI=$(DESTDIR)$(INCPATH)
+DL=$(DESTDIR)$(LIBPATH)
+DM=$(DESTDIR)$(MANPATH)
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+	pngwtran.o pngmem.o pngerror.o pngpread.o
+
+OBJSDLL = $(OBJS:.o=.pic.o)
+
+.SUFFIXES:      .c .o .pic.o
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -o $@ $<
+
+.c.pic.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -KPIC -o $@ $*.c
+
+all: libpng.a $(LIBSO) pngtest libpng.pc libpng-config
+
+include scripts/pnglibconf.mak
+DELETE = $(RM_F)
+DFNFLAGS = $(DEFS) $(CPPFLAGS)
+
+libpng.a: $(OBJS)
+	$(AR_RC) $@ $(OBJS)
+	$(RANLIB) $@
+
+libpng.pc:
+	cat scripts/libpng.pc.in | sed -e s!@prefix@!$(prefix)! \
+	-e s!@exec_prefix@!$(exec_prefix)! \
+	-e s!@libdir@!$(LIBPATH)! \
+	-e s!@includedir@!$(INCPATH)! \
+	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+
+libpng-config:
+	( cat scripts/libpng-config-head.in; \
+	echo prefix=\"$(prefix)\"; \
+	echo libdir=\"$(LIBPATH)\"; \
+	echo I_opts=\"-I$(INCPATH)/$(LIBNAME)\"; \
+	echo L_opts=\"-L$(LIBPATH)\"; \
+	echo R_opts=\"-R$(LIBPATH)\"; \
+	echo ccopts=\"-fast -xtarget=ultra\"; \
+	echo ldopts=\"-fast -xtarget=ultra\"; \
+	echo libs=\"-lpng16 -lz -lm\"; \
+	cat scripts/libpng-config-body.in ) > libpng-config
+	chmod +x libpng-config
+
+$(LIBSO): $(LIBSOMAJ)
+	$(LN_SF) $(LIBSOMAJ) $(LIBSO)
+
+$(LIBSOMAJ): $(OBJSDLL)
+	@case "`type ld`" in *ucb*) \
+	echo; \
+	echo '## WARNING:'; \
+	echo '## The commands "CC" and "LD" must NOT refer to /usr/ucb/cc'; \
+	echo '## and /usr/ucb/ld.  If they do, you need to adjust your PATH'; \
+	echo '## environment variable to put /usr/ccs/bin ahead of /usr/ucb.'; \
+	echo '## The environment variable LD_LIBRARY_PATH should not be set'; \
+	echo '## at all.  If it is, things are likely to break because of'; \
+	echo '## the libucb dependency that is created.'; \
+	echo; \
+	;; \
+	esac
+	$(LD) -G -L$(ZLIBLIB) -R$(ZLIBLIB) -h $(LIBSOMAJ) \
+	 -o $(LIBSOMAJ) $(OBJSDLL)
+
+pngtest: pngtest.o $(LIBSO)
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
+
+test: pngtest
+	./pngtest
+
+install-headers: png.h pngconf.h pnglibconf.h
+	-@if [ ! -d $(DI) ]; then $(MKDIR_P) $(DI); fi
+	-@if [ ! -d $(DI)/$(LIBNAME) ]; then $(MKDIR_P) $(DI)/$(LIBNAME); fi
+	cp png.h pngconf.h pnglibconf.h $(DI)/$(LIBNAME)
+	chmod 644 $(DI)/$(LIBNAME)/png.h $(DI)/$(LIBNAME)/pngconf.h $(DI)/$(LIBNAME)/pnglibconf.h
+	-@$(RM_F) $(DI)/png.h $(DI)/pngconf.h $(DI)/pnglibconf.h
+	-@$(RM_F) $(DI)/libpng
+	(cd $(DI); $(LN_SF) $(LIBNAME) libpng; $(LN_SF) $(LIBNAME)/* .)
+
+install-static: install-headers libpng.a
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	cp libpng.a $(DL)/$(LIBNAME).a
+	chmod 644 $(DL)/$(LIBNAME).a
+	-@$(RM_F) $(DL)/libpng.a
+	(cd $(DL); $(LN_SF) $(LIBNAME).a libpng.a)
+
+install-shared: install-headers $(LIBSOMAJ) libpng.pc
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	-@$(RM_F) $(DL)/$(LIBSO)
+	-@$(RM_F) $(DL)/$(LIBSOREL)
+	-@$(RM_F) $(DL)/$(OLDSO)
+	cp $(LIBSOMAJ) $(DL)/$(LIBSOREL)
+	chmod 755 $(DL)/$(LIBSOREL)
+	(cd $(DL); \
+	$(LN_SF) $(LIBSOREL) $(LIBSO); \
+	$(LN_SF) $(LIBSO) $(OLDSO))
+	-@if [ ! -d $(DL)/pkgconfig ]; then $(MKDIR_P) $(DL)/pkgconfig; fi
+	-@$(RM_F) $(DL)/pkgconfig/$(LIBNAME).pc
+	-@$(RM_F) $(DL)/pkgconfig/libpng.pc
+	cp libpng.pc $(DL)/pkgconfig/$(LIBNAME).pc
+	chmod 644 $(DL)/pkgconfig/$(LIBNAME).pc
+	(cd $(DL)/pkgconfig; $(LN_SF) $(LIBNAME).pc libpng.pc)
+
+install-man: libpng.3 libpngpf.3 png.5
+	-@if [ ! -d $(DM) ]; then $(MKDIR_P) $(DM); fi
+	-@if [ ! -d $(DM)/man3 ]; then $(MKDIR_P) $(DM)/man3; fi
+	-@$(RM_F) $(DM)/man3/libpng.3
+	-@$(RM_F) $(DM)/man3/libpngpf.3
+	cp libpng.3 $(DM)/man3
+	cp libpngpf.3 $(DM)/man3
+	-@if [ ! -d $(DM)/man5 ]; then $(MKDIR_P) $(DM)/man5; fi
+	-@$(RM_F) $(DM)/man5/png.5
+	cp png.5 $(DM)/man5
+
+install-config: libpng-config
+	-@if [ ! -d $(DB) ]; then $(MKDIR_P) $(DB); fi
+	-@$(RM_F) $(DB)/libpng-config
+	-@$(RM_F) $(DB)/$(LIBNAME)-config
+	cp libpng-config $(DB)/$(LIBNAME)-config
+	chmod 755 $(DB)/$(LIBNAME)-config
+	(cd $(DB); $(LN_SF) $(LIBNAME)-config libpng-config)
+
+install: install-static install-shared install-man install-config
+
+# If you installed in $(DESTDIR), test-installed won't work until you
+# move the library to its final location.  Use test-dd to test it
+# before then.
+
+test-dd:
+	echo
+	echo Testing installed dynamic shared library in $(DL).
+	$(CC) $(SUN_CC_FLAGS) -I$(DI) $(CPPFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -o pngtestd -L$(DL) -R$(DL) `$(BINPATH)/$(LIBNAME)-config --ldflags` \
+	   $(SUN_LD_FLAGS) -L$(ZLIBLIB) -R$(ZLIBLIB)
+	./pngtestd pngtest.png
+
+test-installed:
+	echo
+	echo Testing installed dynamic shared library.
+	$(CC) $(SUN_CC_FLAGS) $(CPPFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -o pngtesti `$(BINPATH)/$(LIBNAME)-config --ldflags` \
+	   $(SUN_LD_FLAGS) -L$(ZLIBLIB) -R$(ZLIBLIB)
+	./pngtesti pngtest.png
+
+clean:
+	$(RM_F) *.o libpng.a pngtest pngtesti pngout.png \
+	libpng-config $(LIBSO) $(LIBSOMAJ)* \
+	libpng.pc
+
+DOCS = ANNOUNCE CHANGES INSTALL KNOWNBUG LICENSE README TODO
+writelock:
+	chmod a-w *.[ch35] $(DOCS) scripts/*
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o png.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngerror.o pngerror.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrio.o pngrio.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwio.o pngwio.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngmem.o pngmem.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngset.o pngset.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngget.o pngget.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngread.o pngread.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrtran.o pngrtran.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrutil.o pngrutil.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngtrans.o pngtrans.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwrite.o pngwrite.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwtran.o pngwtran.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwutil.o pngwutil.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngpread.o pngpread.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+
+pngtest.o: png.h pngconf.h pnglibconf.h
diff --git a/Engine/lib/lpng/scripts/makefile.64sunu b/Engine/lib/lpng/scripts/makefile.64sunu
new file mode 100644
index 000000000..8880fa9b9
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.64sunu
@@ -0,0 +1,244 @@
+# makefile for libpng on Solaris 2.x with cc
+# Contributed by William L. Sebok, based on makefile.linux
+# Copyright (C) 2002, 2006, 2010-2014 Glenn Randers-Pehrson
+# Copyright (C) 1998 Greg Roelofs
+# Copyright (C) 1996, 1997 Andreas Dilger
+
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# Library name:
+LIBNAME=libpng16
+PNGMAJ = 16
+
+# Shared library names:
+LIBSO=$(LIBNAME).so
+LIBSOMAJ=$(LIBNAME).so.$(PNGMAJ)
+LIBSOREL=$(LIBSOMAJ).$(RELEASE)
+OLDSO=libpng.so
+
+# Utilities:
+CC=cc
+AR_RC=ar rc
+MKDIR_P=mkdir -p
+LN_SF=ln -f -s
+RANLIB=echo
+RM_F=/bin/rm -f
+
+SUN_CC_FLAGS=-fast -xtarget=ultra -xarch=v9
+SUN_LD_FLAGS=-fast -xtarget=ultra -xarch=v9
+
+# where make install puts libpng.a, libpng16.so and libpng16/png.h
+prefix=/a
+exec_prefix=$(prefix)
+
+# Where the zlib library and include files are located
+# Changing these to ../zlib poses a security risk.  If you want
+# to have zlib in an adjacent directory, specify the full path instead of "..".
+#ZLIBLIB=../zlib
+#ZLIBINC=../zlib
+
+ZLIBLIB=/usr/lib
+ZLIBINC=/usr/include
+
+WARNMORE=-Wwrite-strings -Wpointer-arith -Wshadow \
+	-Wmissing-declarations -Wtraditional -Wcast-align \
+	-Wstrict-prototypes -Wmissing-prototypes #-Wconversion
+CPPFLAGS=-I$(ZLIBINC) # -DPNG_DEBUG=5
+CFLAGS= $(SUN_CC_FLAGS) # $(WARNMORE) -g
+LDFLAGS=-L. -R. $(SUN_LD_FLAGS) -L$(ZLIBLIB) -R$(ZLIBLIB) -lpng16 -lz -lm
+
+INCPATH=$(prefix)/include
+LIBPATH=$(exec_prefix)/lib
+MANPATH=$(prefix)/man
+BINPATH=$(exec_prefix)/bin
+
+# override DESTDIR= on the make install command line to easily support
+# installing into a temporary location.  Example:
+#
+#    make install DESTDIR=/tmp/build/libpng
+#
+# If you're going to install into a temporary location
+# via DESTDIR, $(DESTDIR)$(prefix) must already exist before
+# you execute make install.
+DESTDIR=
+
+DB=$(DESTDIR)$(BINPATH)
+DI=$(DESTDIR)$(INCPATH)
+DL=$(DESTDIR)$(LIBPATH)
+DM=$(DESTDIR)$(MANPATH)
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+	pngwtran.o pngmem.o pngerror.o pngpread.o
+
+OBJSDLL = $(OBJS:.o=.pic.o)
+
+.SUFFIXES:      .c .o .pic.o
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -o $@ $<
+
+.c.pic.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -KPIC -o $@ $*.c
+
+all: libpng.a $(LIBSO) pngtest libpng.pc libpng-config
+
+include scripts/pnglibconf.mak
+DELETE = $(RM_F)
+DFNFLAGS = $(DEFS) $(CPPFLAGS)
+
+libpng.a: $(OBJS)
+	$(AR_RC) $@ $(OBJS)
+	$(RANLIB) $@
+
+libpng.pc:
+	cat scripts/libpng.pc.in | sed -e s!@prefix@!$(prefix)! \
+	-e s!@exec_prefix@!$(exec_prefix)! \
+	-e s!@libdir@!$(LIBPATH)! \
+	-e s!@includedir@!$(INCPATH)! \
+	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+
+libpng-config:
+	( cat scripts/libpng-config-head.in; \
+	echo prefix=\"$(prefix)\"; \
+	echo libdir=\"$(LIBPATH)\"; \
+	echo I_opts=\"-I$(INCPATH)/$(LIBNAME)\"; \
+	echo L_opts=\"-L$(LIBPATH)\"; \
+	echo R_opts=\"-R$(LIBPATH)\"; \
+	echo ccopts=\"-fast -xtarget=ultra -xarch=v9\"; \
+	echo ldopts=\"-fast -xtarget=ultra -xarch=v9\"; \
+	echo libs=\"-lpng16 -lz -lm\"; \
+	cat scripts/libpng-config-body.in ) > libpng-config
+	chmod +x libpng-config
+
+$(LIBSO): $(LIBSOMAJ)
+	$(LN_SF) $(LIBSOMAJ) $(LIBSO)
+
+$(LIBSOMAJ): $(OBJSDLL)
+	@case "`type ld`" in *ucb*) \
+	echo; \
+	echo '## WARNING:'; \
+	echo '## The commands "CC" and "LD" must NOT refer to /usr/ucb/cc'; \
+	echo '## and /usr/ucb/ld.  If they do, you need to adjust your PATH'; \
+	echo '## environment variable to put /usr/ccs/bin ahead of /usr/ucb.'; \
+	echo '## The environment variable LD_LIBRARY_PATH should not be set'; \
+	echo '## at all.  If it is, things are likely to break because of'; \
+	echo '## the libucb dependency that is created.'; \
+	echo; \
+	;; \
+	esac
+	$(LD) -G -L$(ZLIBLIB) -R$(ZLIBLIB) -h $(LIBSOMAJ) \
+	 -o $(LIBSOMAJ) $(OBJSDLL)
+
+pngtest: pngtest.o $(LIBSO)
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
+
+test: pngtest
+	./pngtest
+
+install-headers: png.h pngconf.h
+	-@if [ ! -d $(DI) ]; then $(MKDIR_P) $(DI); fi
+	-@if [ ! -d $(DI)/$(LIBNAME) ]; then $(MKDIR_P) $(DI)/$(LIBNAME); fi
+	cp png.h pngconf.h pnglibconf.h $(DI)/$(LIBNAME)
+	chmod 644 $(DI)/$(LIBNAME)/png.h $(DI)/$(LIBNAME)/pngconf.h $(DI)/$(LIBNAME)/pnglibconf.h
+	-@$(RM_F) $(DI)/png.h $(DI)/pngconf.h $(DI)/pnglibconf.h
+	-@$(RM_F) $(DI)/libpng
+	(cd $(DI); $(LN_SF) $(LIBNAME) libpng; $(LN_SF) $(LIBNAME)/* .)
+
+install-static: install-headers libpng.a
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	cp libpng.a $(DL)/$(LIBNAME).a
+	chmod 644 $(DL)/$(LIBNAME).a
+	-@$(RM_F) $(DL)/libpng.a
+	(cd $(DL); $(LN_SF) $(LIBNAME).a libpng.a)
+
+install-shared: install-headers $(LIBSOMAJ) libpng.pc
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	-@$(RM_F) $(DL)/$(LIBSO)
+	-@$(RM_F) $(DL)/$(LIBSOREL)
+	-@$(RM_F) $(DL)/$(OLDSO)
+	cp $(LIBSOMAJ) $(DL)/$(LIBSOREL)
+	chmod 755 $(DL)/$(LIBSOREL)
+	(cd $(DL); \
+	$(LN_SF) $(LIBSOREL) $(LIBSO); \
+	$(LN_SF) $(LIBSO) $(OLDSO))
+	-@if [ ! -d $(DL)/pkgconfig ]; then $(MKDIR_P) $(DL)/pkgconfig; fi
+	-@$(RM_F) $(DL)/pkgconfig/$(LIBNAME).pc
+	-@$(RM_F) $(DL)/pkgconfig/libpng.pc
+	cp libpng.pc $(DL)/pkgconfig/$(LIBNAME).pc
+	chmod 644 $(DL)/pkgconfig/$(LIBNAME).pc
+	(cd $(DL)/pkgconfig; $(LN_SF) $(LIBNAME).pc libpng.pc)
+
+install-man: libpng.3 libpngpf.3 png.5
+	-@if [ ! -d $(DM) ]; then $(MKDIR_P) $(DM); fi
+	-@if [ ! -d $(DM)/man3 ]; then $(MKDIR_P) $(DM)/man3; fi
+	-@$(RM_F) $(DM)/man3/libpng.3
+	-@$(RM_F) $(DM)/man3/libpngpf.3
+	cp libpng.3 $(DM)/man3
+	cp libpngpf.3 $(DM)/man3
+	-@if [ ! -d $(DM)/man5 ]; then $(MKDIR_P) $(DM)/man5; fi
+	-@$(RM_F) $(DM)/man5/png.5
+	cp png.5 $(DM)/man5
+
+install-config: libpng-config
+	-@if [ ! -d $(DB) ]; then $(MKDIR_P) $(DB); fi
+	-@$(RM_F) $(DB)/libpng-config
+	-@$(RM_F) $(DB)/$(LIBNAME)-config
+	cp libpng-config $(DB)/$(LIBNAME)-config
+	chmod 755 $(DB)/$(LIBNAME)-config
+	(cd $(DB); $(LN_SF) $(LIBNAME)-config libpng-config)
+
+install: install-static install-shared install-man install-config
+
+# If you installed in $(DESTDIR), test-installed won't work until you
+# move the library to its final location.  Use test-dd to test it
+# before then.
+
+test-dd:
+	echo
+	echo Testing installed dynamic shared library in $(DL).
+	$(CC) $(SUN_CC_FLAGS) -I$(DI) $(CPPFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -o pngtestd -L$(DL) -R$(DL) `$(BINPATH)/$(LIBNAME)-config --ldflags` \
+	   $(SUN_LD_FLAGS) -L$(ZLIBLIB) -R$(ZLIBLIB)
+	./pngtestd pngtest.png
+
+test-installed:
+	echo
+	echo Testing installed dynamic shared library.
+	$(CC) $(SUN_CC_FLAGS) $(CPPFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -o pngtesti `$(BINPATH)/$(LIBNAME)-config --ldflags` \
+	   $(SUN_LD_FLAGS) -L$(ZLIBLIB) -R$(ZLIBLIB)
+	./pngtesti pngtest.png
+
+clean:
+	$(RM_F) *.o libpng.a pngtest pngtesti pngout.png \
+	libpng-config $(LIBSO) $(LIBSOMAJ)* \
+	libpng.pc
+
+DOCS = ANNOUNCE CHANGES INSTALL KNOWNBUG LICENSE README TODO
+writelock:
+	chmod a-w *.[ch35] $(DOCS) scripts/*
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o png.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngerror.o pngerror.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrio.o pngrio.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwio.o pngwio.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngmem.o pngmem.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngset.o pngset.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngget.o pngget.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngread.o pngread.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrtran.o pngrtran.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrutil.o pngrutil.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngtrans.o pngtrans.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwrite.o pngwrite.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwtran.o pngwtran.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwutil.o pngwutil.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngpread.o pngpread.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+
+pngtest.o: png.h pngconf.h pnglibconf.h
diff --git a/Engine/lib/lpng/scripts/makefile.acorn b/Engine/lib/lpng/scripts/makefile.acorn
new file mode 100644
index 000000000..00b8fb5b3
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.acorn
@@ -0,0 +1,57 @@
+# Project:   libpng
+
+
+# Toolflags:
+CCflags = -c -depend !Depend -IC:,Zlib: -g -throwback  -DRISCOS  -fnah
+C++flags = -c -depend !Depend -IC: -throwback
+Linkflags = -aif -c++ -o $@
+ObjAsmflags = -throwback -NoCache -depend !Depend
+CMHGflags =
+LibFileflags = -c -l -o $@
+Squeezeflags = -o $@
+
+# Final targets:
+@.libpng-lib:   @.o.png @.o.pngerror @.o.pngrio @.o.pngwio @.o.pngmem \
+	@.o.pngpread @.o.pngset @.o.pngget @.o.pngread @.o.pngrtran \
+	@.o.pngrutil @.o.pngtrans @.o.pngwrite @.o.pngwtran @.o.pngwutil
+	LibFile $(LibFileflags) @.o.png @.o.pngerror @.o.pngrio @.o.pngrtran \
+	@.o.pngmem @.o.pngpread @.o.pngset @.o.pngget @.o.pngread @.o.pngwio \
+	@.o.pngrutil @.o.pngtrans  @.o.pngwrite @.o.pngwtran @.o.pngwutil
+@.mm-libpng-lib:   @.mm.png @.mm.pngerror @.mm.pngrio @.mm.pngwio @.mm.pngmem \
+	@.mm.pngpread @.mm.pngset @.mm.pngget @.mm.pngread @.mm.pngrtran \
+	@.mm.pngrutil @.mm.pngtrans @.mm.pngwrite @.mm.pngwtran @.mm.pngwutil
+	LibFile $(LibFileflags) @.mm.png @.mm.pngerror @.mm.pngrio \
+	@.mm.pngwio @.mm.pngmem @.mm.pngpread @.mm.pngset @.mm.pngget \
+	@.mm.pngread @.mm.pngrtran @.mm.pngrutil @.mm.pngtrans @.mm.pngwrite \
+	@.mm.pngwtran @.mm.pngwutil
+
+
+# User-editable dependencies:
+# (C) Copyright 1997 Tom Tanner
+Test: @.pngtest
+	<Prefix$Dir>.pngtest
+	@remove <Prefix$Dir>.pngtest
+
+#It would be nice if you could stop "make" listing from here on!
+@.pngtest:   @.o.pngtest @.libpng-lib C:o.Stubs Zlib:zlib_lib
+	Link $(Linkflags) @.o.pngtest @.libpng-lib C:o.Stubs Zlib:zlib_lib
+
+.SUFFIXES: .o .mm .c
+
+.c.mm:
+	MemCheck.CC cc $(ccflags) -o $@ LibPng:$<
+.c.o:
+	cc $(ccflags) -o $@ $<
+
+# See scripts.mak.libpngconf for how to generate this:
+@.h.libpngconf: @.scripts.h.libpngconf
+	copy @.scripts.h.libpngconf $@
+
+# Static dependencies:
+@.o.png @.o.pngerror @.o.pngrio @.o.pngwio @.o.pngmem \
+@.o.pngpread @.o.pngset @.o.pngget @.o.pngread @.o.pngrtran \
+@.o.pngrutil @.o.pngtrans @.o.pngwrite @.o.pngwtran @.o.pngwutil \
+@.o.pngtest: @.h.libpngconf
+
+
+# Dynamic dependencies:
diff --git a/Engine/lib/lpng/scripts/makefile.aix b/Engine/lib/lpng/scripts/makefile.aix
new file mode 100644
index 000000000..5f62d50af
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.aix
@@ -0,0 +1,116 @@
+# makefile for libpng using gcc (generic, static library)
+# Copyright (C) 2002, 2006-2009, 2014 Glenn Randers-Pehrson
+# Copyright (C) 2000 Cosmin Truta
+# Copyright (C) 2000 Marc O. Gloor (AIX support added, from makefile.gcc)
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# Location of the zlib library and include files
+ZLIBINC = ../zlib
+ZLIBLIB = ../zlib
+
+# Compiler, linker, lib and other tools
+CC = gcc
+LD = $(CC)
+AR_RC = ar rcs
+MKDIR_P = mkdir -p
+RANLIB = ranlib
+RM_F = rm -f
+LN_SF = ln -f -s
+
+LIBNAME = libpng16
+PNGMAJ = 16
+
+prefix=/usr/local
+INCPATH=$(prefix)/include
+LIBPATH=$(prefix)/lib
+
+# override DESTDIR= on the make install command line to easily support
+# installing into a temporary location.  Example:
+#
+#    make install DESTDIR=/tmp/build/libpng
+#
+# If you're going to install into a temporary location
+# via DESTDIR, $(DESTDIR)$(prefix) must already exist before
+# you execute make install.
+DESTDIR=
+
+DI=$(DESTDIR)$(INCPATH)
+DL=$(DESTDIR)$(LIBPATH)
+
+WARNMORE =
+CPPFLAGS = -I$(ZLIBINC) # -DPNG_DEBUG=5
+CFLAGS = -W -Wall -O2 # $(WARNMORE) -g
+LDFLAGS = -L. -L$(ZLIBLIB) -lpng16 -lz -lm
+
+# Variables
+OBJS =  png.o pngerror.o pngget.o pngmem.o pngpread.o \
+	pngread.o pngrio.o pngrtran.o pngrutil.o pngset.o \
+	pngtrans.o pngwio.o pngwrite.o pngwtran.o pngwutil.o
+
+# Targets
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -o $@ $<
+
+all: $(LIBNAME).a pngtest$(E)
+
+include scripts/pnglibconf.mak
+REMOVE = $(RM_F)
+DFNFLAGS = $(DEFS) $(CPPFLAGS)
+
+$(LIBNAME).a: $(OBJS)
+	$(AR_RC) $@ $(OBJS)
+	$(RANLIB) $@
+
+test: pngtest$(E)
+	./pngtest$(E)
+
+pngtest$(E): pngtest.o $(LIBNAME).a
+	$(LD) -o $@ pngtest.o $(LDFLAGS)
+
+install: $(LIBNAME).a
+	-@if [ ! -d $(DI)  ]; then $(MKDIR_P) $(DI); fi
+	-@if [ ! -d $(DI)/$(LIBNAME)  ]; then $(MKDIR_P) $(DI)/$(LIBNAME); fi
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	-@$(RM_F) $(DI)/$(LIBNAME)/png.h
+	-@$(RM_F) $(DI)/$(LIBNAME)/pngconf.h
+	-@$(RM_F) $(DI)/$(LIBNAME)/pnglibconf.h
+	-@$(RM_F) $(DI)/png.h
+	-@$(RM_F) $(DI)/pngconf.h
+	-@$(RM_F) $(DI)/pnglibconf.h
+	cp png.h pngconf.h pnglibconf.h $(DI)/$(LIBNAME)
+	chmod 644 $(DI)/$(LIBNAME)/png.h \
+	$(DI)/$(LIBNAME)/pngconf.h \
+	$(DI)/$(LIBNAME)/pnglibconf.h
+	-@$(RM_F) -r $(DI)/libpng
+	(cd $(DI); $(LN_SF) $(LIBNAME) libpng; $(LN_SF) $(LIBNAME)/* .)
+	-@$(RM_F) $(DL)/$(LIBNAME).a
+	-@$(RM_F) $(DL)/libpng.a
+	cp $(LIBNAME).a $(DL)/$(LIBNAME).a
+	chmod 644 $(DL)/$(LIBNAME).a
+	(cd $(DL); $(LN_SF) $(LIBNAME).a libpng.a)
+	(cd $(DI); $(LN_SF) libpng/* .;)
+
+clean:
+	$(RM_F) *.o $(LIBNAME).a pngtest pngout.png pnglibconf.h
+
+png.o:      png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngerror.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngget.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngmem.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngpread.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngread.o:  png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrio.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngset.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngtrans.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwio.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwrite.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+
+pngtest.o:  png.h pngconf.h pnglibconf.h
diff --git a/Engine/lib/lpng/scripts/makefile.amiga b/Engine/lib/lpng/scripts/makefile.amiga
new file mode 100644
index 000000000..16a4bd5d3
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.amiga
@@ -0,0 +1,58 @@
+# Commodore Amiga Makefile
+# makefile for libpng and SAS C V6.5x compiler
+# Copyright (C) 1995-2000 Wolf Faust
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+#
+# Location/path of zlib include files
+ZLIB=/zlib
+#compiler
+CC=sc
+#compiler flags
+# WARNING: a bug in V6.51 causes bad code with OPTGO
+#          So use V6.55 or set NOOPTGO!!!!!!!!!
+CFLAGS= NOSTKCHK PARMS=REG OPTIMIZE OPTGO OPTPEEP OPTINLOCAL OPTINL\
+	OPTLOOP OPTRDEP=4 OPTDEP=4 OPTCOMP=4 INCLUDEDIR=$(ZLIB) \
+	DEFINE=PNG_INTERNAL
+#linker flags
+LDFLAGS= SD ND BATCH
+#link libs
+LDLIBS= libpng.lib libgz.lib LIB:scm.lib LIB:sc.lib Lib:amiga.lib
+# linker
+LN= slink
+# file deletion command
+RM= delete quiet
+# library (.lib) file creation command
+AR= oml
+# make directory command
+MKDIR= makedir
+
+# Pre-built configuration
+# See scripts/pnglibconf.mak for more options
+PNGLIBCONF_H_PREBUILT = scripts/pnglibconf.h.prebuilt
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+	pngwtran.o pngmem.o pngerror.o pngpread.o
+
+all: libpng.lib pngtest
+
+libpng.lib: $(OBJS)
+-$(RM) libpng.lib
+$(AR) libpng.lib r $(OBJS)
+
+$(OBJS): pngpriv.h png.h pngconf.h pnglibconf.h pnginfo.h pngstruct.h pngdebug.h
+
+pnglibconf.h: $(PNGLIBCONF_H_PREBUILT)
+COPY $(PNGLIBCONF_H_PREBUILT) TO pnglibconf.h
+
+pngtest: pngtest.o libpng.lib
+$(LN) <WITH <
+$(LDFLAGS)
+TO pngtest
+FROM LIB:c.o pngtest.o
+LIB $(LDLIBS)
+<
+
diff --git a/Engine/lib/lpng/scripts/makefile.atari b/Engine/lib/lpng/scripts/makefile.atari
new file mode 100644
index 000000000..b5dbd4934
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.atari
@@ -0,0 +1,71 @@
+# makefile for libpng
+# Copyright (C) 2002, 2014 Glenn Randers-Pehrson
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+#
+# Modified for LC56/ATARI assumes libz.lib is in same dir and uses default
+# rules for library management
+#
+CPPFLAGS = -I..\zlib
+CFLAGS = -O
+LBR = png.lib
+LDFLAGS = -L. -L..\zlib -lpng -lz -lm
+
+# where make install puts libpng.a and png.h
+prefix=/usr/local
+INCPATH=$(prefix)/include
+LIBPATH=$(prefix)/lib
+
+# override DESTDIR= on the make install command line to easily support
+# installing into a temporary location.  Example:
+#
+#    make install DESTDIR=/tmp/build/libpng
+#
+# If you're going to install into a temporary location
+# via DESTDIR, $(DESTDIR)$(prefix) must already exist before
+# you execute make install.
+DESTDIR=
+
+# Pre-built configuration
+# See scripts/pnglibconf.mak for more options
+PNGLIBCONF_H_PREBUILT = scripts/pnglibconf.h.prebuilt
+
+OBJS = $(LBR)(png.o) $(LBR)(pngset.o) $(LBR)(pngget.o) $(LBR)(pngrutil.o)\
+	$(LBR)(pngtrans.o) $(LBR)(pngwutil.o)\
+	$(LBR)(pngread.o) $(LBR)(pngerror.o) $(LBR)(pngwrite.o)\
+	$(LBR)(pngrtran.o) $(LBR)(pngwtran.o)\
+	$(LBR)(pngmem.o) $(LBR)(pngrio.o) $(LBR)(pngwio.o) $(LBR)(pngpread.o)
+
+all: $(LBR) pngtest.ttp
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) $<
+
+$(LBR): $(OBJS)
+
+$(OBJS): pngpriv.h png.h pngconf.h pnglibconf.h pnginfo.h pngstruct.h pngdebug.h
+
+pnglibconf.h: $(PNGLIBCONF_H_PREBUILT)
+	cp $(PNGLIBCONF_H_PREBUILT) $@
+
+pngtest.ttp: pngtest.o $(LBR)
+	$(CC) $(CFLAGS) $(LDFLAGS) -o$@ pngtest.o
+
+install: libpng.a
+	-@mkdir $(DESTDIR)$(INCPATH)
+	-@mkdir $(DESTDIR)$(INCPATH)/libpng
+	-@mkdir $(DESTDIR)$(LIBPATH)
+	-@rm -f $(DESTDIR)$(INCPATH)/png.h
+	-@rm -f $(DESTDIR)$(INCPATH)/pngconf.h
+	-@rm -f $(DESTDIR)$(INCPATH)/pnglibconf.h
+	cp png.h $(DESTDIR)$(INCPATH)/libpng
+	cp pngconf.h $(DESTDIR)$(INCPATH)/libpng
+	cp pnglibconf.h $(DESTDIR)$(INCPATH)/libpng
+	chmod 644 $(DESTDIR)$(INCPATH)/libpng/png.h
+	chmod 644 $(DESTDIR)$(INCPATH)/libpng/pngconf.h
+	chmod 644 $(DESTDIR)$(INCPATH)/libpng/pnglibconf.h
+	(cd $(DESTDIR)$(INCPATH); ln -f -s $(LIBNAME) libpng; \
+	ln -f -s $(LIBNAME)/* .)
diff --git a/Engine/lib/lpng/scripts/makefile.bc32 b/Engine/lib/lpng/scripts/makefile.bc32
new file mode 100644
index 000000000..bdbc4cb2f
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.bc32
@@ -0,0 +1,158 @@
+# Makefile for libpng
+# 32-bit Borland C++ (Note: All modules are compiled in C mode)
+# To build the library, do:
+#       "make -fmakefile.bc32"
+#
+# -------------------- 32-bit Borland C++ --------------------
+
+### Absolutely necessary for this makefile to work
+.AUTODEPEND
+
+## Where zlib.h, zconf.h and zlib.lib are
+ZLIB_DIR=..\zlib
+
+## Compiler, linker, librarian and other tools
+CC=bcc32
+LD=bcc32
+LIB=tlib
+CP=copy
+
+# -3 = 386, -4 = 486, -5 = Pentium etc.
+!ifndef TARGET_CPU
+#TARGET_CPU=-6
+!endif
+
+# Use this if you don't want Borland's fancy exception handling
+# (Caution: doesn't work with CBuilderX)
+#NOEHLIB=noeh32.lib
+
+!ifdef DEBUG
+CDEBUG=-v
+LDEBUG=-v
+!else
+CDEBUG=
+LDEBUG=
+!endif
+
+# STACKOFLOW=1
+!ifdef STACKOFLOW
+CDEBUG=$(CDEBUG) -N
+LDEBUG=$(LDEBUG) -N
+!endif
+
+# -O2 optimize for speed
+# -d  merge duplicate strings
+# -k- turn off standard stack frame
+# -w  display all warnings
+CPPFLAGS=-I$(ZLIB_DIR)
+CFLAGS=-O2 -d -k- -w $(TARGET_CPU) $(CDEBUG)
+
+# -M  generate map file
+LDFLAGS=-L$(ZLIB_DIR) -M $(LDEBUG)
+
+# Pre-built configuration
+# See scripts\pnglibconf.mak for more options
+!ifndef PNGLIBCONF_H_PREBUILT
+PNGLIBCONF_H_PREBUILT = scripts\pnglibconf.h.prebuilt
+!endif
+
+## Variables
+OBJS = \
+	png.obj \
+	pngerror.obj \
+	pngget.obj \
+	pngmem.obj \
+	pngpread.obj \
+	pngread.obj \
+	pngrio.obj \
+	pngrtran.obj \
+	pngrutil.obj \
+	pngset.obj \
+	pngtrans.obj \
+	pngwio.obj \
+	pngwrite.obj \
+	pngwtran.obj \
+	pngwutil.obj
+
+LIBOBJS = \
+	+png.obj \
+	+pngerror.obj \
+	+pngget.obj \
+	+pngmem.obj \
+	+pngpread.obj \
+	+pngread.obj \
+	+pngrio.obj \
+	+pngrtran.obj \
+	+pngrutil.obj \
+	+pngset.obj \
+	+pngtrans.obj \
+	+pngwio.obj \
+	+pngwrite.obj \
+	+pngwtran.obj \
+	+pngwutil.obj
+
+LIBNAME=libpng.lib
+
+## Implicit rules
+# Braces let make "batch" calls to the compiler,
+# 2 calls instead of 12; space is important.
+.c.obj:
+	$(CC) $(CPPFLAGS) $(CFLAGS) -c {$*.c }
+
+.c.exe:
+	$(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) $*.c \
+	  $(LIBNAME) zlib.lib $(NOEHLIB)
+
+.obj.exe:
+	$(LD) $(LDFLAGS) $*.obj $(LIBNAME) zlib.lib $(NOEHLIB)
+
+## Major targets
+all: libpng pngtest
+
+libpng: $(LIBNAME)
+
+pngtest: pngtest.exe
+
+test: pngtest.exe
+	pngtest
+
+## Minor Targets
+
+pnglibconf.h: $(PNGLIBCONF_H_PREBUILT)
+	$(CP) $(PNGLIBCONF_H_PREBUILT) $@
+
+png.obj: png.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngerror.obj: pngerror.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngget.obj: pngget.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngmem.obj: pngmem.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngpread.obj: pngpread.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngread.obj: pngread.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrio.obj: pngrio.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrtran.obj: pngrtran.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrutil.obj: pngrutil.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngset.obj: pngset.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngtrans.obj: pngtrans.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwio.obj: pngwio.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwrite.obj: pngwrite.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwtran.obj: pngwtran.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwutil.obj: pngwutil.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngtest.obj: pngtest.c png.h pngconf.h pnglibconf.h
+
+$(LIBNAME): $(OBJS)
+	-del $(LIBNAME)
+	$(LIB) $(LIBNAME) @&&|
+$(LIBOBJS), libpng
+|
+
+# Cleanup
+clean:
+	-del pnglibconf.h
+	-del *.obj
+	-del $(LIBNAME)
+	-del pngtest.exe
+	-del *.lst
+	-del *.map
+	-del *.tds
+	-del pngout.png
+
+# End of makefile for libpng
diff --git a/Engine/lib/lpng/scripts/makefile.beos b/Engine/lib/lpng/scripts/makefile.beos
new file mode 100644
index 000000000..01346f190
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.beos
@@ -0,0 +1,222 @@
+# makefile for libpng on BeOS x86 ELF with gcc
+# modified from makefile.linux by Sander Stoks
+# Copyright (C) 2002, 2006, 2008, 2010-2014 Glenn Randers-Pehrson
+# Copyright (C) 1999 Greg Roelofs
+# Copyright (C) 1996, 1997 Andreas Dilger
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# Library name:
+LIBNAME=libpng16
+PNGMAJ = 16
+
+# Shared library names:
+LIBSO=$(LIBNAME).so
+LIBSOMAJ=$(LIBNAME).so.$(PNGMAJ)
+LIBSOREL=$(LIBSOMAJ).$(RELEASE)
+OLDSO=libpng.so
+
+# Utilities:
+CC=gcc
+AR_RC=ar rc
+MKDIR_P=mkdir -p
+LN_SF=ln -sf
+RANLIB=ranlib
+CP=cp
+RM_F=/bin/rm -f
+
+# Where the zlib library and include files are located
+ZLIBLIB=/usr/local/lib
+ZLIBINC=/usr/local/include
+
+ALIGN=
+# For i386:
+# ALIGN=-malign-loops=2 -malign-functions=2
+
+WARNMORE=-Wwrite-strings -Wpointer-arith -Wshadow \
+	-Wmissing-declarations -Wtraditional -Wcast-align \
+	-Wstrict-prototypes -Wmissing-prototypes #-Wconversion
+
+# On BeOS, -O1 is actually better than -O3.  This is a known bug but it's
+# still here in R4.5
+CPPFLAGS=-I$(ZLIBINC) # -DPNG_DEBUG=5
+CFLAGS=-W -Wall -O1 -funroll-loops $(ALIGN) # $(WARNMORE) -g
+# LDFLAGS=-L. -Wl,-rpath,. -L$(ZLIBLIB) -Wl,-rpath,$(ZLIBLIB) -lpng -lz
+LDFLAGS=-L. -Wl,-soname=$(LIBSOMAJ) -L$(ZLIBLIB) -lz
+
+# where make install puts libpng.a, libpng16.so*, and png.h
+prefix=/usr/local
+exec_prefix=$(prefix)
+INCPATH=$(prefix)/include
+LIBPATH=$(exec_prefix)/lib
+MANPATH=$(prefix)/man
+BINPATH=$(exec_prefix)/bin
+
+# override DESTDIR= on the make install command line to easily support
+# installing into a temporary location.  Example:
+#
+#    make install DESTDIR=/tmp/build/libpng
+#
+# If you're going to install into a temporary location
+# via DESTDIR, $(DESTDIR)$(prefix) must already exist before
+# you execute make install.
+DESTDIR=
+
+DB=$(DESTDIR)$(BINPATH)
+DI=$(DESTDIR)$(INCPATH)
+DL=$(DESTDIR)$(LIBPATH)
+DM=$(DESTDIR)$(MANPATH)
+
+# Pre-built configuration
+# See scripts/pnglibconf.mak for more options
+PNGLIBCONF_H_PREBUILT = scripts/pnglibconf.h.prebuilt
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+	pngwtran.o pngmem.o pngerror.o pngpread.o
+
+OBJSDLL = $(OBJS)
+
+.SUFFIXES:      .c .o
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -o $@ $<
+
+all: libpng.a $(LIBSO) pngtest libpng.pc libpng-config
+
+pnglibconf.h: $(PNGLIBCONF_H_PREBUILT)
+	$(CP) $(PNGLIBCONF_H_PREBUILT) $@
+
+libpng.a: $(OBJS)
+	$(AR_RC) $@ $(OBJS)
+	$(RANLIB) $@
+
+libpng.pc:
+	cat scripts/libpng.pc.in | sed -e s!@prefix@!$(prefix)! \
+	-e s!@exec_prefix@!$(exec_prefix)! \
+	-e s!@libdir@!$(LIBPATH)! \
+	-e s!@includedir@!$(INCPATH)! \
+	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+
+libpng-config:
+	( cat scripts/libpng-config-head.in; \
+	echo prefix=\"$(prefix)\"; \
+	echo I_opts=\"-I$(INCPATH)/$(LIBNAME)\"; \
+	echo libs=\"-lpng16 -lz \"; \
+	cat scripts/libpng-config-body.in ) > libpng-config
+	chmod +x libpng-config
+
+$(LIBSO): $(LIBSOMAJ)
+	$(LN_SF) $(LIBSOMAJ) $(LIBSO)
+	cp $(LIBSO)* /boot/home/config/lib
+
+$(LIBSOMAJ): $(OBJSDLL)
+	$(CC) -nostart -Wl,-soname,$(LIBSOMAJ) -o \
+	$(LIBSOMAJ) $(OBJSDLL) $(LDFLAGS)
+
+pngtest: pngtest.o $(LIBSO)
+	$(CC) -L$(ZLIBLIB) -L. -lz -lpng16 -o pngtest pngtest.o
+
+test: pngtest
+	./pngtest
+
+install-headers: png.h pngconf.h pnglibconf.h
+	-@if [ ! -d $(DI) ]; then $(MKDIR_P) $(DI); fi
+	-@if [ ! -d $(DI)/$(LIBNAME) ]; then $(MKDIR_P) $(DI)/$(LIBNAME); fi
+	cp png.h pngconf.h pnglibconf.h $(DI)/$(LIBNAME)
+	chmod 644 $(DI)/$(LIBNAME)/png.h $(DI)/$(LIBNAME)/pngconf.h $(DI)/$(LIBNAME)/pnglibconf.h
+	-@$(RM_F) $(DI)/png.h $(DI)/pngconf.h $(DI)/pnglibconf.h
+	-@$(RM_F) $(DI)/libpng
+	(cd $(DI); $(LN_SF) $(LIBNAME) libpng; $(LN_SF) $(LIBNAME)/* .)
+
+install-static: install-headers libpng.a
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	cp libpng.a $(DL)/$(LIBNAME).a
+	chmod 644 $(DL)/$(LIBNAME).a
+	-@$(RM_F) $(DL)/libpng.a
+	(cd $(DL); $(LN_SF) $(LIBNAME).a libpng.a)
+
+install-shared: install-headers $(LIBSOMAJ) libpng.pc
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	-@$(RM_F) $(DL)/$(LIBSO)
+	-@$(RM_F) $(DL)/$(LIBSOREL)
+	-@$(RM_F) $(DL)/$(OLDSO)
+	cp $(LIBSOMAJ) $(DL)/$(LIBSOREL)
+	chmod 755 $(DL)/$(LIBSOREL)
+	(cd $(DL); \
+	$(LN_SF) $(LIBSOREL) $(LIBSO); \
+	$(LN_SF) $(LIBSO) $(OLDSO))
+	-@if [ ! -d $(DL)/pkgconfig ]; then $(MKDIR_P) $(DL)/pkgconfig; fi
+	-@$(RM_F) $(DL)/pkgconfig/$(LIBNAME).pc
+	-@$(RM_F) $(DL)/pkgconfig/libpng.pc
+	cp libpng.pc $(DL)/pkgconfig/$(LIBNAME).pc
+	chmod 644 $(DL)/pkgconfig/$(LIBNAME).pc
+	(cd $(DL)/pkgconfig; $(LN_SF) $(LIBNAME).pc libpng.pc)
+
+install-man: libpng.3 libpngpf.3 png.5
+	-@if [ ! -d $(DM) ]; then $(MKDIR_P) $(DM); fi
+	-@if [ ! -d $(DM)/man3 ]; then $(MKDIR_P) $(DM)/man3; fi
+	-@$(RM_F) $(DM)/man3/libpng.3
+	-@$(RM_F) $(DM)/man3/libpngpf.3
+	cp libpng.3 $(DM)/man3
+	cp libpngpf.3 $(DM)/man3
+	-@if [ ! -d $(DM)/man5 ]; then $(MKDIR_P) $(DM)/man5; fi
+	-@$(RM_F) $(DM)/man5/png.5
+	cp png.5 $(DM)/man5
+
+install-config: libpng-config
+	-@if [ ! -d $(DB) ]; then $(MKDIR_P) $(DB); fi
+	-@$(RM_F) $(DB)/libpng-config
+	-@$(RM_F) $(DB)/$(LIBNAME)-config
+	cp libpng-config $(DB)/$(LIBNAME)-config
+	chmod 755 $(DB)/$(LIBNAME)-config
+	(cd $(DB); $(LN_SF) $(LIBNAME)-config libpng-config)
+
+install: install-static install-shared install-man install-config
+
+# If you installed in $(DESTDIR), test-installed won't work until you
+# move the library to its final location.  Use test-dd to test it
+# before then.
+
+test-dd:
+	echo
+	echo Testing installed dynamic shared library in $(DL).
+	$(CC) -I$(DI) $(CPPFLAGS) $(CFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -L$(DL) -L$(ZLIBLIB) -Wl,-rpath $(ZLIBLIB):$(DL) \
+	   -o pngtestd `$(BINPATH)/$(LIBNAME)-config --ldflags`
+	./pngtestd pngtest.png
+
+test-installed:
+	$(CC) $(CPPFLAGS) $(CFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -L$(ZLIBLIB) -Wl,-rpath,$(ZLIBLIB) \
+	   -o pngtesti `$(BINPATH)/$(LIBNAME)-config --ldflags`
+	./pngtesti pngtest.png
+
+clean:
+	$(RM_F) *.o libpng.a pngtest pngout.png libpng-config \
+	$(LIBSO) $(LIBSOMAJ)* pngtesti \
+	pnglibconf.h libpng.pc
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o png.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngerror.o pngerror.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrio.o pngrio.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwio.o pngwio.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngmem.o pngmem.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngset.o pngset.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngget.o pngget.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngread.o pngread.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrtran.o pngrtran.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrutil.o pngrutil.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngtrans.o pngtrans.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwrite.o pngwrite.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwtran.o pngwtran.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwutil.o pngwutil.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngpread.o pngpread.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+
+pngtest.o: png.h pngconf.h pnglibconf.h
diff --git a/Engine/lib/lpng/scripts/makefile.cegcc b/Engine/lib/lpng/scripts/makefile.cegcc
new file mode 100644
index 000000000..6f915c2bf
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.cegcc
@@ -0,0 +1,116 @@
+# Makefile for creating Windows CE release archives, with the
+# mingw32ce compiler.
+
+# Last updated: 22-Jul-2008
+
+# Copyright (C) 2008 Vincent Torri
+
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# To get some help, type
+#
+# make help
+#
+# To create the archives
+#
+# make
+#
+# To remove everything, type:
+#
+# make clean
+
+VERMAJ = 1
+VERMIN = 6
+VERMIC = 37
+VER = $(VERMAJ).$(VERMIN).$(VERMIC)
+NAME = libpng
+PACKAGE = $(NAME)-$(VER)
+
+BIN = libpng16-0.dll
+LIB = libpng16.a libpng16.dll.a libpng.a libpng.dll.a
+INCLUDE = png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+PC = libpng16.pc libpng.pc
+
+MANIFESTVERBIN = "Libpng-$(VER): Binary files"
+MANIFESTVERDEV = "Libpng-$(VER): Developer files"
+MANIFESTVERDESC = "Libpng: the official PNG reference library"
+
+all: $(NAME)
+
+$(NAME): remove-old copy-src compilation copy manifest archive
+	@echo " * Removal of the directories"
+	@rm -rf $(PACKAGE)/ $(PACKAGE)-bin/ $(PACKAGE)-dev/
+
+remove-old:
+	@echo " * Removal of the old files"
+	@rm -rf $(PACKAGE)-bin*
+	@rm -rf $(PACKAGE)-dev*
+
+copy-src:
+	@echo " * Copy of source files"
+	@cp -R ../src/$(PACKAGE) .
+	@echo " * Creation of directories and files"
+	@mkdir -p $(PACKAGE)-bin/bin
+	@mkdir -p $(PACKAGE)-bin/manifest
+	@mkdir -p $(PACKAGE)-dev/lib/pkgconfig
+	@mkdir -p $(PACKAGE)-dev/include/$(NAME)$(VERMAJ)$(VERMIN)
+	@mkdir -p $(PACKAGE)-dev/manifest
+	@touch $(PACKAGE)-bin/manifest/$(PACKAGE)-bin.mft
+	@touch $(PACKAGE)-bin/manifest/$(PACKAGE)-bin.ver
+	@touch $(PACKAGE)-dev/manifest/$(PACKAGE)-dev.mft
+	@touch $(PACKAGE)-dev/manifest/$(PACKAGE)-dev.ver
+
+compilation:
+	@echo " * Compilation of $(PACKAGE)"
+	cd $(PACKAGE) && CPPFLAGS="$(CPPFLAGS) -DPNG_CONSOLE_IO_SUPPORTED -D_WIN32_WCE=0x0420" \
+		CFLAGS="$(CFLAGS) -mms-bitfields -O3 -pipe -fomit-frame-pointer" \
+		LDFLAGS="$(LDFLAGS) -Wl,--enable-auto-import -Wl,-s" \
+		./configure --prefix=/opt/wince --host=arm-mingw32ce && make
+
+copy:
+	@echo " * Copy of binary and development files"
+	@for i in $(BIN); do \
+	  cp $(PACKAGE)/.libs/$$i $(PACKAGE)-bin/bin; \
+	done
+	@for i in $(LIB); do \
+	  cp $(PACKAGE)/.libs/$$i $(PACKAGE)-dev/lib; \
+	done
+	@for i in $(INCLUDE); do \
+	  cp $(PACKAGE)/$$i $(PACKAGE)-dev/include/$(NAME)$(VERMAJ)$(VERMIN); \
+	done
+	@for i in $(PC); do \
+	  cp $(PACKAGE)/$$i $(PACKAGE)-dev/lib/pkgconfig; \
+	done
+
+manifest:
+	@echo " * Creation of the manifest"
+	@cd $(PACKAGE)-bin && find * >> manifest/$(PACKAGE)-bin.mft
+	@cd $(PACKAGE)-bin && \
+	  echo $(MANIFESTVERBIN) >> manifest/$(PACKAGE)-bin.ver && \
+	  echo $(MANIFESTVERDESC) >> manifest/$(PACKAGE)-bin.ver
+	@cd $(PACKAGE)-dev && find * >> manifest/$(PACKAGE)-dev.mft
+	@cd $(PACKAGE)-dev && \
+	  echo $(MANIFESTVERDEV) >> manifest/$(PACKAGE)-dev.ver && \
+	  echo $(MANIFESTVERDESC) >> manifest/$(PACKAGE)-dev.ver
+
+archive:
+	@echo " * Creation of the archives"
+	@tar cf $(PACKAGE)-bin.tar $(PACKAGE)-bin
+	@bzip2 -9 $(PACKAGE)-bin.tar
+	@tar cf $(PACKAGE)-dev.tar $(PACKAGE)-dev
+	@bzip2 -9 $(PACKAGE)-dev.tar
+
+clean:
+	@echo " * Cleaning"
+	@rm -rf $(PACKAGE)*
+
+help:
+	@echo
+	@echo "To create the archives, type:"
+	@echo " make"
+	@echo
+	@echo "To remove everything, type:"
+	@echo " make clean"
+	@echo
diff --git a/Engine/lib/lpng/scripts/makefile.clang b/Engine/lib/lpng/scripts/makefile.clang
new file mode 100644
index 000000000..fcaefae9b
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.clang
@@ -0,0 +1,87 @@
+# makefile for libpng using clang (generic, static library)
+# Copyright (C) 2008, 2014 Glenn Randers-Pehrson
+# Copyright (C) 2000, 2014, 2019 Cosmin Truta
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# Location of the zlib library and include files
+ZLIBINC = ../zlib
+ZLIBLIB = ../zlib
+
+# Compiler, linker, lib and other tools
+CC = clang
+LD = $(CC)
+AR_RC = ar rcs
+RANLIB = ranlib
+CP = cp
+RM_F = rm -f
+
+WARNMORE = -Wwrite-strings -Wpointer-arith -Wshadow \
+	-Wmissing-declarations -Wtraditional -Wcast-align \
+	-Wstrict-prototypes -Wmissing-prototypes # -Wconversion
+CPPFLAGS = -I$(ZLIBINC) # -DPNG_DEBUG=5
+CFLAGS = -W -Wall -O2 # $(WARNMORE) -g
+LDFLAGS = -L$(ZLIBLIB)
+LIBS = -lz -lm
+
+# File extensions
+EXEEXT =
+
+# Pre-built configuration
+# See scripts/pnglibconf.mak for more options
+PNGLIBCONF_H_PREBUILT = scripts/pnglibconf.h.prebuilt
+
+# Variables
+OBJS =  png.o pngerror.o pngget.o pngmem.o pngpread.o \
+	pngread.o pngrio.o pngrtran.o pngrutil.o pngset.o \
+	pngtrans.o pngwio.o pngwrite.o pngwtran.o pngwutil.o
+
+# Targets
+all: static
+
+pnglibconf.h: $(PNGLIBCONF_H_PREBUILT)
+	$(CP) $(PNGLIBCONF_H_PREBUILT) $@
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -o $@ $<
+
+static: libpng.a pngtest$(EXEEXT)
+
+shared:
+	@echo This is a generic makefile that cannot create shared libraries.
+	@echo Please use a configuration that is specific to your platform.
+	@false
+
+libpng.a: $(OBJS)
+	$(AR_RC) $@ $(OBJS)
+	$(RANLIB) $@
+
+test: pngtest$(EXEEXT)
+	./pngtest$(EXEEXT)
+
+pngtest$(EXEEXT): pngtest.o libpng.a
+	$(LD) $(LDFLAGS) -o $@ pngtest.o libpng.a $(LIBS)
+
+clean:
+	$(RM_F) *.o libpng.a pngtest$(EXEEXT) pngout.png pnglibconf.h
+
+png.o:      png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngerror.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngget.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngmem.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngpread.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngread.o:  png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrio.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngset.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngtrans.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwio.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwrite.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+
+pngtest.o:  png.h pngconf.h pnglibconf.h
diff --git a/Engine/lib/lpng/scripts/makefile.clang-asan b/Engine/lib/lpng/scripts/makefile.clang-asan
new file mode 100644
index 000000000..0cab52fd0
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.clang-asan
@@ -0,0 +1,87 @@
+# makefile for libpng using clang + address sanitizer (generic, static library)
+# Copyright (C) 2008, 2014 Glenn Randers-Pehrson
+# Copyright (C) 2000, 2014, 2019 Cosmin Truta
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# Location of the zlib library and include files
+ZLIBINC = ../zlib
+ZLIBLIB = ../zlib
+
+# Compiler, linker, lib and other tools
+CC = clang
+LD = $(CC)
+AR_RC = ar rcs
+RANLIB = ranlib
+CP = cp
+RM_F = rm -f
+
+WARNMORE = -Wwrite-strings -Wpointer-arith -Wshadow \
+	-Wmissing-declarations -Wtraditional -Wcast-align \
+	-Wstrict-prototypes -Wmissing-prototypes # -Wconversion
+CPPFLAGS = -I$(ZLIBINC) # -DPNG_DEBUG=5
+CFLAGS = -W -Wall -O0 -g -fsanitize=address
+LDFLAGS = -L$(ZLIBLIB) -g -fsanitize=address
+LIBS = -lz -lm
+
+# File extensions
+EXEEXT =
+
+# Pre-built configuration
+# See scripts/pnglibconf.mak for more options
+PNGLIBCONF_H_PREBUILT = scripts/pnglibconf.h.prebuilt
+
+# Variables
+OBJS =  png.o pngerror.o pngget.o pngmem.o pngpread.o \
+	pngread.o pngrio.o pngrtran.o pngrutil.o pngset.o \
+	pngtrans.o pngwio.o pngwrite.o pngwtran.o pngwutil.o
+
+# Targets
+all: static
+
+pnglibconf.h: $(PNGLIBCONF_H_PREBUILT)
+	$(CP) $(PNGLIBCONF_H_PREBUILT) $@
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -o $@ $<
+
+static: libpng.a pngtest$(EXEEXT)
+
+shared:
+	@echo This is a generic makefile that cannot create shared libraries.
+	@echo Please use a configuration that is specific to your platform.
+	@false
+
+libpng.a: $(OBJS)
+	$(AR_RC) $@ $(OBJS)
+	$(RANLIB) $@
+
+test: pngtest$(EXEEXT)
+	./pngtest$(EXEEXT)
+
+pngtest$(EXEEXT): pngtest.o libpng.a
+	$(LD) $(LDFLAGS) -o $@ pngtest.o libpng.a $(LIBS)
+
+clean:
+	$(RM_F) *.o libpng.a pngtest$(EXEEXT) pngout.png pnglibconf.h
+
+png.o:      png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngerror.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngget.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngmem.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngpread.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngread.o:  png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrio.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngset.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngtrans.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwio.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwrite.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+
+pngtest.o:  png.h pngconf.h pnglibconf.h
diff --git a/Engine/lib/lpng/scripts/makefile.darwin b/Engine/lib/lpng/scripts/makefile.darwin
new file mode 100644
index 000000000..33c27cc1f
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.darwin
@@ -0,0 +1,225 @@
+# makefile for libpng on Darwin / Mac OS X
+# Copyright (C) 2002, 2004, 2006, 2008, 2010-2014 Glenn Randers-Pehrson
+# Copyright (C) 2001 Christoph Pfisterer
+# derived from makefile.linux:
+#  Copyright (C) 1998, 1999 Greg Roelofs
+#  Copyright (C) 1996, 1997 Andreas Dilger
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# where "make install" puts libpng.a, libpng16.dylib, png.h, pngconf.h,
+# and pnglibconf.h
+prefix=/usr/local
+exec_prefix=$(prefix)
+
+# Where the zlib library and include files are located
+ZLIBLIB=/usr/lib
+ZLIBINC=/usr/include
+
+# Library name:
+LIBNAME = libpng16
+PNGMAJ = 16
+
+# Shared library names:
+LIBSO=$(LIBNAME).dylib
+LIBSOMAJ=$(LIBNAME).$(PNGMAJ).dylib
+LIBSOREL=$(LIBNAME).$(PNGMAJ).$(RELEASE).dylib
+OLDSO=libpng.dylib
+
+# Utilities:
+CC=cc
+AR_RC=ar rc
+MKDIR_P=mkdir -p
+LN_SF=ln -sf
+RANLIB=ranlib
+CP=cp
+RM_F=/bin/rm -f
+
+CPPFLAGS=-I$(ZLIBINC)
+# CFLAGS=-W -Wall -O3 -funroll-loops
+CFLAGS=-W -Wall -O -funroll-loops
+LDFLAGS=-L. -L$(ZLIBLIB) -lpng16 -lz
+
+INCPATH=$(prefix)/include
+LIBPATH=$(exec_prefix)/lib
+MANPATH=$(prefix)/man
+BINPATH=$(exec_prefix)/bin
+
+# override DESTDIR= on the make install command line to easily support
+# installing into a temporary location.  Example:
+#
+#    make install DESTDIR=/tmp/build/libpng
+#
+# If you're going to install into a temporary location
+# via DESTDIR, $(DESTDIR)$(prefix) must already exist before
+# you execute make install.
+DESTDIR=
+
+DB=$(DESTDIR)$(BINPATH)
+DI=$(DESTDIR)$(INCPATH)
+DL=$(DESTDIR)$(LIBPATH)
+DM=$(DESTDIR)$(MANPATH)
+
+# Pre-built configuration
+# See scripts/pnglibconf.mak for more options
+PNGLIBCONF_H_PREBUILT = scripts/pnglibconf.h.prebuilt
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+	pngwtran.o pngmem.o pngerror.o pngpread.o
+
+OBJSDLL = $(OBJS:.o=.pic.o)
+
+.SUFFIXES:      .c .o .pic.o
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -o $@ $<
+
+.c.pic.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -fno-common -o $@ $*.c
+
+all: libpng.a $(LIBSO) pngtest libpng.pc libpng-config
+
+pnglibconf.h: $(PNGLIBCONF_H_PREBUILT)
+	$(CP) $(PNGLIBCONF_H_PREBUILT) $@
+
+libpng.a: $(OBJS)
+	$(AR_RC) $@ $(OBJS)
+	$(RANLIB) $@
+
+libpng.pc:
+	cat scripts/libpng.pc.in | sed -e s!@prefix@!$(prefix)! \
+	-e s!@exec_prefix@!$(exec_prefix)! \
+	-e s!@libdir@!$(LIBPATH)! \
+	-e s!@includedir@!$(INCPATH)! \
+	-e s!-lpng16!-lpng16\ -lz! > libpng.pc
+
+libpng-config:
+	( cat scripts/libpng-config-head.in; \
+	echo prefix=\"$(prefix)\"; \
+	echo I_opts=\"-I$(INCPATH)/$(LIBNAME)\"; \
+	echo L_opts=\"-L$(LIBPATH)\"; \
+	echo libs=\"-lpng16 -lz\"; \
+	cat scripts/libpng-config-body.in ) > libpng-config
+	chmod +x libpng-config
+
+$(LIBSO): $(LIBSOMAJ)
+	$(LN_SF) $(LIBSOMAJ) $(LIBSO)
+
+$(LIBSOMAJ): $(OBJSDLL)
+	$(CC) -dynamiclib \
+	 -install_name $(LIBPATH)/$(LIBSOMAJ) \
+	 -current_version 16 -compatibility_version 16 \
+	 -o $(LIBSOMAJ) \
+	 $(OBJSDLL) -L$(ZLIBLIB) -lz
+
+pngtest: pngtest.o $(LIBSO)
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
+
+test: pngtest
+	./pngtest
+
+install-headers: png.h pngconf.h pnglibconf.h
+	-@if [ ! -d $(DI) ]; then $(MKDIR_P) $(DI); fi
+	-@if [ ! -d $(DI)/$(LIBNAME) ]; then $(MKDIR_P) $(DI)/$(LIBNAME); fi
+	cp png.h pngconf.h pnglibconf.h $(DI)/$(LIBNAME)
+	chmod 644 $(DI)/$(LIBNAME)/png.h $(DI)/$(LIBNAME)/pngconf.h $(DI)/$(LIBNAME)/pnglibconf.h
+	-@$(RM_F) $(DI)/png.h $(DI)/pngconf.h $(DI)/pnglibconf.h
+	-@$(RM_F) $(DI)/libpng
+	(cd $(DI); $(LN_SF) $(LIBNAME) libpng; $(LN_SF) $(LIBNAME)/* .)
+
+install-static: install-headers libpng.a
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	cp libpng.a $(DL)/$(LIBNAME).a
+	chmod 644 $(DL)/$(LIBNAME).a
+	$(RANLIB) $(DL)/$(LIBNAME).a
+	-@$(RM_F) $(DL)/libpng.a
+	(cd $(DL); $(LN_SF) $(LIBNAME).a libpng.a)
+
+install-shared: install-headers $(LIBSOMAJ) libpng.pc
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	-@$(RM_F) $(DL)/$(LIBSO)
+	-@$(RM_F) $(DL)/$(LIBSOMAJ)
+	-@$(RM_F) $(DL)/$(OLDSO)
+	cp $(LIBSOMAJ) $(DL)
+	chmod 755 $(DL)/$(LIBSOMAJ)
+	(cd $(DL); \
+	$(LN_SF) $(LIBSOREL) $(LIBSO); \
+	$(LN_SF) $(LIBSO) $(OLDSO))
+	-@if [ ! -d $(DL)/pkgconfig ]; then $(MKDIR_P) $(DL)/pkgconfig; fi
+	-@$(RM_F) $(DL)/pkgconfig/$(LIBNAME).pc
+	-@$(RM_F) $(DL)/pkgconfig/libpng.pc
+	cp libpng.pc $(DL)/pkgconfig/$(LIBNAME).pc
+	chmod 644 $(DL)/pkgconfig/$(LIBNAME).pc
+	(cd $(DL)/pkgconfig; $(LN_SF) $(LIBNAME).pc libpng.pc)
+
+install-man: libpng.3 libpngpf.3 png.5
+	-@if [ ! -d $(DM) ]; then $(MKDIR_P) $(DM); fi
+	-@if [ ! -d $(DM)/man3 ]; then $(MKDIR_P) $(DM)/man3; fi
+	-@$(RM_F) $(DM)/man3/libpng.3
+	-@$(RM_F) $(DM)/man3/libpngpf.3
+	cp libpng.3 $(DM)/man3
+	cp libpngpf.3 $(DM)/man3
+	-@if [ ! -d $(DM)/man5 ]; then $(MKDIR_P) $(DM)/man5; fi
+	-@$(RM_F) $(DM)/man5/png.5
+	cp png.5 $(DM)/man5
+
+install-config: libpng-config
+	-@if [ ! -d $(DB) ]; then $(MKDIR_P) $(DB); fi
+	-@$(RM_F) $(DB)/libpng-config
+	-@$(RM_F) $(DB)/$(LIBNAME)-config
+	cp libpng-config $(DB)/$(LIBNAME)-config
+	chmod 755 $(DB)/$(LIBNAME)-config
+	(cd $(DB); $(LN_SF) $(LIBNAME)-config libpng-config)
+
+install: install-static install-shared install-man install-config
+
+# If you installed in $(DESTDIR), test-installed won't work until you
+# move the library to its final location.  Use test-dd to test it
+# before then.
+
+test-dd:
+	echo
+	echo Testing installed dynamic shared library in $(DL).
+	$(CC) -I$(DI) $(CPPFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -L$(DL) -L$(ZLIBLIB) \
+	   -o pngtestd `$(BINPATH)/$(LIBNAME)-config --ldflags`
+	./pngtestd pngtest.png
+
+test-installed:
+	$(CC) $(CPPFLAGS) $(CFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -L$(ZLIBLIB) \
+	   -o pngtesti `$(BINPATH)/$(LIBNAME)-config --ldflags`
+	./pngtesti pngtest.png
+
+clean:
+	$(RM_F) *.o libpng.a pngtest pngout.png libpng-config \
+	libpng.pc $(LIBNAME).*dylib pngtesti pnglibconf.h
+
+DOCS = ANNOUNCE CHANGES INSTALL KNOWNBUG LICENSE README TODO
+writelock:
+	chmod a-w *.[ch35] $(DOCS) scripts/*
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o png.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngerror.o pngerror.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrio.o pngrio.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwio.o pngwio.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngmem.o pngmem.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngset.o pngset.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngget.o pngget.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngread.o pngread.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrtran.o pngrtran.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrutil.o pngrutil.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngtrans.o pngtrans.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwrite.o pngwrite.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwtran.o pngwtran.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwutil.o pngwutil.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngpread.o pngpread.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+
+pngtest.o: png.h pngconf.h pnglibconf.h
diff --git a/Engine/lib/lpng/scripts/makefile.dec b/Engine/lib/lpng/scripts/makefile.dec
new file mode 100644
index 000000000..8566a0297
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.dec
@@ -0,0 +1,210 @@
+# makefile for libpng on DEC Alpha Unix
+# Copyright (C) 2000-2002, 2006, 2010-2014 Glenn Randers-Pehrson
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# Library name:
+PNGMAJ = 16
+LIBNAME = libpng16
+
+# Shared library names:
+LIBSO=$(LIBNAME).so
+LIBSOMAJ=$(LIBNAME).so.$(PNGMAJ)
+LIBSOREL=$(LIBSOMAJ).$(RELEASE)
+OLDSO=libpng.so
+
+# Utilities:
+AR_RC=ar rc
+CC=cc
+MKDIR_P=mkdir
+LN_SF=ln -f -s
+RANLIB=ranlib
+CP=cp
+RM_F=/bin/rm -f
+
+# where make install puts libpng.a and png.h
+prefix=/usr/local
+exec_prefix=$(prefix)
+INCPATH=$(prefix)/include
+LIBPATH=$(exec_prefix)/lib
+MANPATH=$(prefix)/man
+BINPATH=$(exec_prefix)/bin
+
+# override DESTDIR= on the make install command line to easily support
+# installing into a temporary location.  Example:
+#
+#    make install DESTDIR=/tmp/build/libpng
+#
+# If you're going to install into a temporary location
+# via DESTDIR, $(DESTDIR)$(prefix) must already exist before
+# you execute make install.
+DESTDIR=
+
+DB=$(DESTDIR)$(BINPATH)
+DI=$(DESTDIR)$(INCPATH)
+DL=$(DESTDIR)$(LIBPATH)
+DM=$(DESTDIR)$(MANPATH)
+
+# Where the zlib library and include files are located
+#ZLIBLIB=/usr/local/lib
+#ZLIBINC=/usr/local/include
+ZLIBLIB=../zlib
+ZLIBINC=../zlib
+
+CPPFLAGS=-I$(ZLIBINC) # -DPNG_DEBUG=5
+CFLAGS=-std -w1 -O # -g
+LDFLAGS=-L$(ZLIBLIB) -rpath $(ZLIBLIB) libpng.a -lz -lm
+
+# Pre-built configuration
+# See scripts/pnglibconf.mak for more options
+PNGLIBCONF_H_PREBUILT = scripts/pnglibconf.h.prebuilt
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+	pngwtran.o pngmem.o pngerror.o pngpread.o
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -o $@ $<
+
+all: $(LIBSO) libpng.a pngtest libpng.pc libpng-config
+
+pnglibconf.h: $(PNGLIBCONF_H_PREBUILT)
+	$(CP) $(PNGLIBCONF_H_PREBUILT) $@
+
+libpng.a: $(OBJS)
+	$(AR_RC) $@  $(OBJS)
+	$(RANLIB) $@
+
+libpng.pc:
+	cat scripts/libpng.pc.in | sed -e s!@prefix@!$(prefix)! \
+	-e s!@exec_prefix@!$(exec_prefix)! \
+	-e s!@libdir@!$(LIBPATH)! \
+	-e s!@includedir@!$(INCPATH)! \
+	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+
+libpng-config:
+	( cat scripts/libpng-config-head.in; \
+	echo prefix=\"$(prefix)\"; \
+	echo I_opts=\"-I$(INCPATH)/$(LIBNAME)\"; \
+	echo ccopts=\"-std\"; \
+	echo L_opts=\"-L$(LIBPATH)\"; \
+	echo libs=\"-lpng16 -lz -lm\"; \
+	cat scripts/libpng-config-body.in ) > libpng-config
+	chmod +x libpng-config
+
+$(LIBSO): $(LIBSOMAJ)
+	$(LN_SF) $(LIBSOMAJ) $(LIBSO)
+
+$(LIBSOMAJ): $(OBJS)
+	$(CC) -shared -o $@ $(OBJS) -L$(ZLIBLIB) \
+	-soname $(LIBSOMAJ)
+
+pngtest: pngtest.o libpng.a
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
+
+test: pngtest
+	./pngtest
+
+install-headers: png.h pngconf.h pnglibconf.h
+	-@if [ ! -d $(DI) ]; then $(MKDIR_P) $(DI); fi
+	-@if [ ! -d $(DI)/$(LIBNAME) ]; then $(MKDIR_P) $(DI)/$(LIBNAME); fi
+	cp png.h pngconf.h pnglibconf.h $(DI)/$(LIBNAME)
+	chmod 644 $(DI)/$(LIBNAME)/png.h $(DI)/$(LIBNAME)/pngconf.h $(DI)/$(LIBNAME)/pnglibconf.h
+	-@/bin/rm -f $(DI)/png.h $(DI)/pngconf.h $(DI)/pnglibconf.h
+	-@/bin/rm -f $(DI)/libpng
+	(cd $(DI); $(LN_SF)(LIBNAME) libpng; $(LN_SF)(LIBNAME)/* .)
+
+install-static: install-headers libpng.a
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	cp libpng.a $(DL)/$(LIBNAME).a
+	chmod 644 $(DL)/$(LIBNAME).a
+	-@/bin/rm -f $(DL)/libpng.a
+	(cd $(DL); $(LN_SF)(LIBNAME).a libpng.a)
+
+install-shared: install-headers $(LIBSOMAJ) libpng.pc
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	-@$(RM_F) $(DL)/$(LIBSO)
+	-@$(RM_F) $(DL)/$(LIBSOREL)
+	-@$(RM_F) $(DL)/$(OLDSO)
+	cp $(LIBSOMAJ) $(DL)/$(LIBSOREL)
+	chmod 755 $(DL)/$(LIBSOREL)
+	(cd $(DL); \
+	$(LN_SF) $(LIBSOREL) $(LIBSO); \
+	$(LN_SF) $(LIBSO) $(OLDSO))
+	-@if [ ! -d $(DL)/pkgconfig ]; then $(MKDIR_P) $(DL)/pkgconfig; fi
+	-@$(RM_F) $(DL)/pkgconfig/$(LIBNAME).pc
+	-@$(RM_F) $(DL)/pkgconfig/libpng.pc
+	cp libpng.pc $(DL)/pkgconfig/$(LIBNAME).pc
+	chmod 644 $(DL)/pkgconfig/$(LIBNAME).pc
+	(cd $(DL)/pkgconfig; $(LN_SF) $(LIBNAME).pc libpng.pc)
+
+install-man: libpng.3 libpngpf.3 png.5
+	-@if [ ! -d $(DM) ]; then $(MKDIR_P) $(DM); fi
+	-@if [ ! -d $(DM)/man3 ]; then $(MKDIR_P) $(DM)/man3; fi
+	-@/bin/rm -f $(DM)/man3/libpng.3
+	-@/bin/rm -f $(DM)/man3/libpngpf.3
+	cp libpng.3 $(DM)/man3
+	cp libpngpf.3 $(DM)/man3
+	-@if [ ! -d $(DM)/man5 ]; then $(MKDIR_P) $(DM)/man5; fi
+	-@/bin/rm -f $(DM)/man5/png.5
+	cp png.5 $(DM)/man5
+
+install-config: libpng-config
+	-@if [ ! -d $(DB) ]; then $(MKDIR_P) $(DB); fi
+	-@/bin/rm -f $(DB)/libpng-config
+	-@/bin/rm -f $(DB)/$(LIBNAME)-config
+	cp libpng-config $(DB)/$(LIBNAME)-config
+	chmod 755 $(DB)/$(LIBNAME)-config
+	(cd $(DB); $(LN_SF)(LIBNAME)-config libpng-config)
+
+install: install-static install-shared install-man install-config
+
+# If you installed in $(DESTDIR), test-installed won't work until you
+# move the library to its final location.  Use test-dd to test it
+# before then.
+
+test-dd:
+	echo
+	echo Testing installed dynamic shared library in $(DL).
+	$(CC) -w1 -I$(DI) $(CPPFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -L$(DL) -L$(ZLIBLIB)  -R$(ZLIBLIB) -R$(DL) \
+	   -o pngtestd `$(BINPATH)/$(LIBNAME)-config --ldflags`
+	./pngtestd pngtest.png
+
+test-installed:
+	echo
+	echo Testing installed dynamic shared library.
+	$(CC) -w1 $(CPPFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -L$(ZLIBLIB) -R$(ZLIBLIB) \
+	   -o pngtesti `$(BINPATH)/$(LIBNAME)-config --ldflags`
+	./pngtesti pngtest.png
+
+clean:
+	$(RM_F) *.o libpng.a pngtest pngtesti pngout.png \
+	libpng-config $(LIBSO) $(LIBSOMAJ)* \
+	libpng.pc pnglibconf.h
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngerror.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrio.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwio.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngmem.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngset.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngget.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngread.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngtrans.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwrite.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngpread.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+
+pngtest.o: png.h pngconf.h pnglibconf.h
diff --git a/Engine/lib/lpng/scripts/makefile.dj2 b/Engine/lib/lpng/scripts/makefile.dj2
new file mode 100644
index 000000000..e59c432b4
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.dj2
@@ -0,0 +1,72 @@
+# DJGPP (DOS gcc) makefile for libpng
+# Copyright (C) 2002, 2006, 2009-2014 Glenn Randers-Pehrson
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# where make install will put libpng.a and png.h
+#prefix=/usr/local
+prefix=.
+INCPATH=$(prefix)/include
+LIBPATH=$(prefix)/lib
+
+CC=gcc
+CPPFLAGS=-I../zlib -DPNG_NO_SNPRINTF
+CFLAGS=-O
+LDFLAGS=-L. -L../zlib/ -lpng -lz -lm
+
+RANLIB=ranlib
+
+CP=cp
+RM_F=rm -f
+
+# Pre-built configuration
+# See scripts/pnglibconf.mak for more options
+PNGLIBCONF_H_PREBUILT = scripts/pnglibconf.h.prebuilt
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o pngwtran.o \
+	pngmem.o pngerror.o pngpread.o
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -o $@ $<
+
+all: libpng.a pngtest
+
+pnglibconf.h: $(PNGLIBCONF_H_PREBUILT)
+	$(CP) $(PNGLIBCONF_H_PREBUILT) $@
+
+libpng.a: $(OBJS)
+	ar rc $@  $(OBJS)
+	$(RANLIB) $@
+
+pngtest: pngtest.o libpng.a
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
+	coff2exe pngtest
+
+test: pngtest
+	./pngtest
+clean:
+	$(RM_F) *.o libpng.a pngtest pngout.png pnglibconf.h
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngerror.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrio.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwio.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngmem.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngset.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngget.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngread.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngpread.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngtrans.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwrite.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+
+pngtest.o: png.h pngconf.h pnglibconf.h
diff --git a/Engine/lib/lpng/scripts/makefile.freebsd b/Engine/lib/lpng/scripts/makefile.freebsd
new file mode 100644
index 000000000..5fec61e35
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.freebsd
@@ -0,0 +1,69 @@
+# makefile for libpng under FreeBSD
+# Copyright (C) 2014 Glenn Randers-Pehrson and Andrey A. Chernov
+# Copyright (C) 2002, 2007, 2009 Glenn Randers-Pehrson and Andrey A. Chernov
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+PREFIX?=        /usr/local
+SHLIB_VER?=     16
+
+LIB=		png
+SHLIB_MAJOR=	${SHLIB_VER}
+SHLIB_MINOR=	0
+NO_PROFILE=	YES
+NO_OBJ=		YES
+
+# where make install puts libpng.a and png.h
+DESTDIR=	${PREFIX}
+LIBDIR=		/lib
+INCS=		png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+INCSDIR=	/include/libpng
+INCDIR=		${INCSDIR}		# for 4.x bsd.lib.mk
+MAN=		libpng.3 libpngpf.3 png.5
+MANDIR=		/man/man
+SYMLINKS=       libpng/png.h ${INCSDIR}/../png.h \
+		libpng/pngconf.h ${INCSDIR}/../pngconf.h \
+		libpng/pnglibconf.h ${INCSDIR}/../pnglibconf.h
+
+# where make install finds libz.a and zlib.h
+ZLIBLIB=	/usr/lib
+ZLIBINC=	/usr/include
+
+LDADD+=		-lm -lz
+#LDADD+=	-lm -lz -lssp_nonshared   # for OSVERSION < 800000 ?
+
+DPADD+=		${LIBM} ${LIBZ}
+
+CPPFLAGS+=	-I. -I${ZLIBINC}
+CFLAGS+=	-W -Wall
+
+# Pre-built configuration
+# See scripts/pnglibconf.mak for more options
+PNGLIBCONF_H_PREBUILT= scripts/pnglibconf.h.prebuilt
+
+SRCS=	png.c pngset.c pngget.c pngrutil.c pngtrans.c pngwutil.c \
+	pngread.c pngrio.c pngwio.c pngwrite.c pngrtran.c \
+	pngwtran.c pngmem.c pngerror.c pngpread.c
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -o $@ $<
+
+pngtest: pngtest.o libpng.a
+	${CC} ${CFLAGS} -L. -static -o pngtest pngtest.o -L${ZLIBLIB} \
+	-lpng ${LDADD}
+
+CLEANFILES= pngtest pngtest.o pngout.png
+
+test: pngtest
+	./pngtest
+
+pnglibconf.h: $(PNGLIBCONF_H_PREBUILT)
+	cp $(PNGLIBCONF_H_PREBUILT) $@
+
+DOCS = ANNOUNCE CHANGES INSTALL KNOWNBUG LICENSE README TODO
+writelock:
+	chmod a-w *.[ch35] $(DOCS) scripts/*
+
+.include <bsd.lib.mk>
diff --git a/Engine/lib/lpng/scripts/makefile.gcc b/Engine/lib/lpng/scripts/makefile.gcc
new file mode 100644
index 000000000..a97731367
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.gcc
@@ -0,0 +1,87 @@
+# makefile for libpng using gcc (generic, static library)
+# Copyright (C) 2008, 2014 Glenn Randers-Pehrson
+# Copyright (C) 2000, 2014, 2019 Cosmin Truta
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# Location of the zlib library and include files
+ZLIBINC = ../zlib
+ZLIBLIB = ../zlib
+
+# Compiler, linker, lib and other tools
+CC = gcc
+LD = $(CC)
+AR_RC = ar rcs
+RANLIB = ranlib
+CP = cp
+RM_F = rm -f
+
+WARNMORE = -Wwrite-strings -Wpointer-arith -Wshadow \
+	-Wmissing-declarations -Wtraditional -Wcast-align \
+	-Wstrict-prototypes -Wmissing-prototypes # -Wconversion
+CPPFLAGS = -I$(ZLIBINC) # -DPNG_DEBUG=5
+CFLAGS = -W -Wall -O2 # $(WARNMORE) -g
+LDFLAGS = -L$(ZLIBLIB)
+LIBS = -lz -lm
+
+# File extensions
+EXEEXT =
+
+# Pre-built configuration
+# See scripts/pnglibconf.mak for more options
+PNGLIBCONF_H_PREBUILT = scripts/pnglibconf.h.prebuilt
+
+# Variables
+OBJS =  png.o pngerror.o pngget.o pngmem.o pngpread.o \
+	pngread.o pngrio.o pngrtran.o pngrutil.o pngset.o \
+	pngtrans.o pngwio.o pngwrite.o pngwtran.o pngwutil.o
+
+# Targets
+all: static
+
+pnglibconf.h: $(PNGLIBCONF_H_PREBUILT)
+	$(CP) $(PNGLIBCONF_H_PREBUILT) $@
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -o $@ $<
+
+static: libpng.a pngtest$(EXEEXT)
+
+shared:
+	@echo This is a generic makefile that cannot create shared libraries.
+	@echo Please use a configuration that is specific to your platform.
+	@false
+
+libpng.a: $(OBJS)
+	$(AR_RC) $@ $(OBJS)
+	$(RANLIB) $@
+
+test: pngtest$(EXEEXT)
+	./pngtest$(EXEEXT)
+
+pngtest$(EXEEXT): pngtest.o libpng.a
+	$(LD) $(LDFLAGS) -o $@ pngtest.o libpng.a $(LIBS)
+
+clean:
+	$(RM_F) *.o libpng.a pngtest$(EXEEXT) pngout.png pnglibconf.h
+
+png.o:      png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngerror.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngget.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngmem.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngpread.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngread.o:  png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrio.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngset.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngtrans.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwio.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwrite.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+
+pngtest.o:  png.h pngconf.h pnglibconf.h
diff --git a/Engine/lib/lpng/scripts/makefile.gcc-asan b/Engine/lib/lpng/scripts/makefile.gcc-asan
new file mode 100644
index 000000000..aae55d638
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.gcc-asan
@@ -0,0 +1,87 @@
+# makefile for libpng using gcc + address sanitizer (generic, static library)
+# Copyright (C) 2008, 2014 Glenn Randers-Pehrson
+# Copyright (C) 2000, 2014, 2019 Cosmin Truta
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# Location of the zlib library and include files
+ZLIBINC = ../zlib
+ZLIBLIB = ../zlib
+
+# Compiler, linker, lib and other tools
+CC = gcc
+LD = $(CC)
+AR_RC = ar rcs
+RANLIB = ranlib
+CP = cp
+RM_F = rm -f
+
+WARNMORE = -Wwrite-strings -Wpointer-arith -Wshadow \
+	-Wmissing-declarations -Wtraditional -Wcast-align \
+	-Wstrict-prototypes -Wmissing-prototypes # -Wconversion
+CPPFLAGS = -I$(ZLIBINC) # -DPNG_DEBUG=5
+CFLAGS = -W -Wall -O0 -g -fsanitize=address
+LDFLAGS = -L$(ZLIBLIB) -g -fsanitize=address
+LIBS = -lz -lm
+
+# File extensions
+EXEEXT =
+
+# Pre-built configuration
+# See scripts/pnglibconf.mak for more options
+PNGLIBCONF_H_PREBUILT = scripts/pnglibconf.h.prebuilt
+
+# Variables
+OBJS =  png.o pngerror.o pngget.o pngmem.o pngpread.o \
+	pngread.o pngrio.o pngrtran.o pngrutil.o pngset.o \
+	pngtrans.o pngwio.o pngwrite.o pngwtran.o pngwutil.o
+
+# Targets
+all: static
+
+pnglibconf.h: $(PNGLIBCONF_H_PREBUILT)
+	$(CP) $(PNGLIBCONF_H_PREBUILT) $@
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -o $@ $<
+
+static: libpng.a pngtest$(EXEEXT)
+
+shared:
+	@echo This is a generic makefile that cannot create shared libraries.
+	@echo Please use a configuration that is specific to your platform.
+	@false
+
+libpng.a: $(OBJS)
+	$(AR_RC) $@ $(OBJS)
+	$(RANLIB) $@
+
+test: pngtest$(EXEEXT)
+	./pngtest$(EXEEXT)
+
+pngtest$(EXEEXT): pngtest.o libpng.a
+	$(LD) $(LDFLAGS) -o $@ pngtest.o libpng.a $(LIBS)
+
+clean:
+	$(RM_F) *.o libpng.a pngtest$(EXEEXT) pngout.png pnglibconf.h
+
+png.o:      png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngerror.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngget.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngmem.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngpread.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngread.o:  png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrio.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngset.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngtrans.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwio.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwrite.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+
+pngtest.o:  png.h pngconf.h pnglibconf.h
diff --git a/Engine/lib/lpng/scripts/makefile.hp64 b/Engine/lib/lpng/scripts/makefile.hp64
new file mode 100644
index 000000000..4421e787d
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.hp64
@@ -0,0 +1,231 @@
+# makefile for libpng, HPUX (10.20 and 11.00) using the ANSI/C product.
+# Copyright (C) 1999-2002, 2006, 2009, 2010-2014 Glenn Randers-Pehrson
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42
+# Contributed by Jim Rice and updated by Chris Schleicher, Hewlett Packard
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# Where the zlib library and include files are located
+ZLIBLIB=/opt/zlib/lib
+ZLIBINC=/opt/zlib/include
+
+# Note that if you plan to build a libpng shared library, zlib must also
+# be a shared library, which zlib's configure does not do.  After running
+# zlib's configure, edit the appropriate lines of makefile to read:
+#   CFLAGS=-O1 -DHAVE_UNISTD -DUSE_MAP -fPIC \
+#   LDSHARED=ld -b
+#   SHAREDLIB=libz.sl
+
+# Library name:
+LIBNAME = libpng16
+PNGMAJ = 16
+
+# Shared library names:
+LIBSO=$(LIBNAME).sl
+LIBSOMAJ=$(LIBNAME).sl.$(PNGMAJ)
+LIBSOREL=$(LIBSOMAJ).$(RELEASE)
+OLDSO=libpng.sl
+
+# Utilities:
+AR_RC=ar rc
+CC=cc
+MKDIR_P=mkdir -p
+LN_SF=ln -sf
+RANLIB=ranlib
+CP=cp
+RM_F=/bin/rm -f
+
+CPPFLAGS=-I$(ZLIBINC) \
+        -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -DHAVE_UNISTD_H -DUSE_MMAP
+CFLAGS=-O -Ae -Wl,+vnocompatwarnings +DD64 +Z
+# Caution: be sure you have built zlib with the same CFLAGS.
+CCFLAGS=-O -Ae -Wl,+vnocompatwarnings +DD64 +Z
+
+LDFLAGS=-L. -L$(ZLIBLIB) -lpng -lz -lm
+
+# where make install puts libpng.a, libpng16.sl, and png.h
+prefix=/opt/libpng
+exec_prefix=$(prefix)
+INCPATH=$(prefix)/include
+LIBPATH=$(exec_prefix)/lib
+MANPATH=$(prefix)/man
+BINPATH=$(exec_prefix)/bin
+
+# override DESTDIR= on the make install command line to easily support
+# installing into a temporary location.  Example:
+#
+#    make install DESTDIR=/tmp/build/libpng
+#
+# If you're going to install into a temporary location
+# via DESTDIR, $(DESTDIR)$(prefix) must already exist before
+# you execute make install.
+DESTDIR=
+
+DB=$(DESTDIR)$(BINPATH)
+DI=$(DESTDIR)$(INCPATH)
+DL=$(DESTDIR)$(LIBPATH)
+DM=$(DESTDIR)$(MANPATH)
+
+# Pre-built configuration
+# See scripts/pnglibconf.mak for more options
+PNGLIBCONF_H_PREBUILT = scripts/pnglibconf.h.prebuilt
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+	pngwtran.o pngmem.o pngerror.o pngpread.o
+
+OBJSDLL = $(OBJS:.o=.pic.o)
+
+.SUFFIXES:	.c .o .pic.o
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -o $@ $<
+
+.c.pic.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) +z -o $@ $*.c
+
+all: libpng.a $(LIBSO) pngtest libpng.pc libpng-config
+
+pnglibconf.h: $(PNGLIBCONF_H_PREBUILT)
+	$(CP) $(PNGLIBCONF_H_PREBUILT) $@
+
+libpng.a: $(OBJS)
+	$(AR_RC) $@ $(OBJS)
+	$(RANLIB) $@
+
+libpng.pc:
+	cat scripts/libpng.pc.in | sed -e s!@prefix@!$(prefix)! \
+	-e s!@exec_prefix@!$(exec_prefix)! \
+	-e s!@libdir@!$(LIBPATH)! \
+	-e s!@includedir@!$(INCPATH)! \
+	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+
+libpng-config:
+	( cat scripts/libpng-config-head.in; \
+	echo prefix=\"$(prefix)\"; \
+	echo I_opts=\"-I$(INCPATH)/$(LIBNAME)\"; \
+	echo ccopts=\"-O -Ae -Wl,+vnocompatwarnings +DD64 +Z\"; \
+	echo L_opts=\"-L$(LIBPATH)\"; \
+	echo libs=\"-lpng16 -lz -lm\"; \
+	cat scripts/libpng-config-body.in ) > libpng-config
+	chmod +x libpng-config
+
+$(LIBSO): $(LIBSOMAJ)
+	$(LN_SF) $(LIBSOMAJ) $(LIBSO)
+
+$(LIBSOMAJ): $(OBJSDLL)
+	$(LD) -b +s \
+	+h $(LIBSOMAJ) -o $(LIBSOMAJ) $(OBJSDLL)
+
+pngtest: pngtest.o libpng.a
+	$(CC) -o pngtest $(CCFLAGS) pngtest.o $(LDFLAGS)
+
+test: pngtest
+	./pngtest
+
+install-headers: png.h pngconf.h pnglibconf.h
+	-@if [ ! -d $(DI) ]; then $(MKDIR_P) $(DI); fi
+	-@if [ ! -d $(DI)/$(LIBNAME) ]; then $(MKDIR_P) $(DI)/$(LIBNAME); fi
+	cp png.h pngconf.h pnglibconf.h $(DI)/$(LIBNAME)
+	chmod 644 $(DI)/$(LIBNAME)/png.h $(DI)/$(LIBNAME)/pngconf.h $(DI)/$(LIBNAME)/pnglibconf.h
+	-@$(RM_F) $(DI)/png.h $(DI)/pngconf.h $(DI)/pnglibconf.h
+	-@$(RM_F) $(DI)/libpng
+	(cd $(DI); $(LN_SF) $(LIBNAME) libpng; $(LN_SF) $(LIBNAME)/* .)
+
+install-static: install-headers libpng.a
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	cp libpng.a $(DL)/$(LIBNAME).a
+	chmod 644 $(DL)/$(LIBNAME).a
+	-@$(RM_F) $(DL)/libpng.a
+	(cd $(DL); $(LN_SF) $(LIBNAME).a libpng.a)
+
+install-shared: install-headers $(LIBSOMAJ) libpng.pc
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	-@$(RM_F) $(DL)/$(LIBSO)
+	-@$(RM_F) $(DL)/$(LIBSOREL)
+	-@$(RM_F) $(DL)/$(OLDSO)
+	cp $(LIBSOMAJ) $(DL)/$(LIBSOREL)
+	chmod 755 $(DL)/$(LIBSOREL)
+	(cd $(DL); \
+	$(LN_SF) $(LIBSOREL) $(LIBSO); \
+	$(LN_SF) $(LIBSO) $(OLDSO))
+	-@if [ ! -d $(DL)/pkgconfig ]; then $(MKDIR_P) $(DL)/pkgconfig; fi
+	-@$(RM_F) $(DL)/pkgconfig/$(LIBNAME).pc
+	-@$(RM_F) $(DL)/pkgconfig/libpng.pc
+	cp libpng.pc $(DL)/pkgconfig/$(LIBNAME).pc
+	chmod 644 $(DL)/pkgconfig/$(LIBNAME).pc
+	(cd $(DL)/pkgconfig; $(LN_SF) $(LIBNAME).pc libpng.pc)
+
+install-man: libpng.3 libpngpf.3 png.5
+	-@if [ ! -d $(DM) ]; then $(MKDIR_P) $(DM); fi
+	-@if [ ! -d $(DM)/man3 ]; then $(MKDIR_P) $(DM)/man3; fi
+	-@$(RM_F) $(DM)/man3/libpng.3
+	-@$(RM_F) $(DM)/man3/libpngpf.3
+	cp libpng.3 $(DM)/man3
+	cp libpngpf.3 $(DM)/man3
+	-@if [ ! -d $(DM)/man5 ]; then $(MKDIR_P) $(DM)/man5; fi
+	-@$(RM_F) $(DM)/man5/png.5
+	cp png.5 $(DM)/man5
+
+install-config: libpng-config
+	-@if [ ! -d $(DB) ]; then $(MKDIR_P) $(DB); fi
+	-@$(RM_F) $(DB)/libpng-config
+	-@$(RM_F) $(DB)/$(LIBNAME)-config
+	cp libpng-config $(DB)/$(LIBNAME)-config
+	chmod 755 $(DB)/$(LIBNAME)-config
+	(cd $(DB); $(LN_SF) $(LIBNAME)-config libpng-config)
+
+install: install-static install-shared install-man install-config
+
+# If you installed in $(DESTDIR), test-installed won't work until you
+# move the library to its final location.  Use test-dd to test it
+# before then.
+
+test-dd:
+	echo
+	echo Testing installed dynamic shared library in $(DL).
+	$(CC) -I$(DI) $(CPPFLAGS) $(CCFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -L$(DL) -L$(ZLIBLIB) \
+	   -o pngtestd `$(BINPATH)/$(LIBNAME)-config --ldflags`
+	./pngtestd pngtest.png
+
+test-installed:
+	echo
+	echo Testing installed dynamic shared library.
+	$(CC) $(CPPFLAGS) $(CCFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -L$(ZLIBLIB) \
+	   -o pngtesti `$(BINPATH)/$(LIBNAME)-config --ldflags`
+	./pngtesti pngtest.png
+
+clean:
+	$(RM_F) *.o libpng.a pngtest pngtesti pngout.png \
+	libpng-config $(LIBSO) $(LIBSOMAJ)* \
+	libpng.pc pnglibconf.h
+
+DOCS = ANNOUNCE CHANGES INSTALL KNOWNBUG LICENSE README TODO
+writelock:
+	chmod a-w *.[ch35] $(DOCS) scripts/*
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngerror.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrio.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwio.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngmem.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngset.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngget.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngread.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngtrans.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwrite.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngpread.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+
+pngtest.o: png.h pngconf.h pnglibconf.h
diff --git a/Engine/lib/lpng/scripts/makefile.hpgcc b/Engine/lib/lpng/scripts/makefile.hpgcc
new file mode 100644
index 000000000..efef1f3fb
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.hpgcc
@@ -0,0 +1,234 @@
+# makefile for libpng on HP-UX using GCC with the HP ANSI/C linker.
+# Copyright (C) 2002, 2006-2008, 2010-2014 Glenn Randers-Pehrson
+# Copyright (C) 2001, Laurent faillie
+# Copyright (C) 1998, 1999 Greg Roelofs
+# Copyright (C) 1996, 1997 Andreas Dilger
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# Library name:
+LIBNAME = libpng16
+PNGMAJ = 16
+
+# Shared library names:
+LIBSO=$(LIBNAME).sl
+LIBSOMAJ=$(LIBNAME).sl.$(PNGMAJ)
+LIBSOREL=$(LIBSOMAJ).$(RELEASE)
+OLDSO=libpng.sl
+
+# Utilities:
+CC=gcc
+LD=ld
+AR_RC=ar rc
+MKDIR_P=mkdir -p
+LN_SF=ln -sf
+RANLIB=ranlib
+CP=cp
+RM_F=/bin/rm -f
+
+# where "make install" puts libpng.a, $(OLDSO)*, png.h, pngconf.h
+# and pnglibconf.h
+prefix=/usr/local
+exec_prefix=$(prefix)
+
+# Where the zlib library and include files are located
+ZLIBLIB=/opt/zlib/lib
+ZLIBINC=/opt/zlib/include
+
+# Note that if you plan to build a libpng shared library, zlib must also
+# be a shared library, which zlib's configure does not do.  After running
+# zlib's configure, edit the appropriate lines of makefile to read:
+#   CFLAGS=-O1 -DHAVE_UNISTD -DUSE_MAP -fPIC \
+#   LDSHARED=ld -b
+#   SHAREDLIB=libz.sl
+
+ALIGN=
+# for i386:
+#ALIGN=-malign-loops=2 -malign-functions=2
+
+WARNMORE=-Wwrite-strings -Wpointer-arith -Wshadow \
+	-Wmissing-declarations -Wtraditional -Wcast-align \
+	-Wstrict-prototypes -Wmissing-prototypes #-Wconversion
+
+# for pgcc version 2.95.1, -O3 is buggy; don't use it.
+
+CPPFLAGS=-I$(ZLIBINC) # -DPNG_DEBUG=5
+CFLAGS=-W -Wall -O3 -funroll-loops $(ALIGN) # $(WARNMORE) -g
+#LDFLAGS=-L. -Wl,-rpath,. -L$(ZLIBLIB) -Wl,-rpath,$(ZLIBLIB) -lpng16 -lz -lm
+LDFLAGS=-L. -L$(ZLIBLIB) -lpng16 -lz -lm
+
+INCPATH=$(prefix)/include
+LIBPATH=$(exec_prefix)/lib
+MANPATH=$(prefix)/man
+BINPATH=$(exec_prefix)/bin
+
+# override DESTDIR= on the make install command line to easily support
+# installing into a temporary location.  Example:
+#
+#    make install DESTDIR=/tmp/build/libpng
+#
+# If you're going to install into a temporary location
+# via DESTDIR, $(DESTDIR)$(prefix) must already exist before
+# you execute make install.
+DESTDIR=
+
+DB=$(DESTDIR)$(BINPATH)
+DI=$(DESTDIR)$(INCPATH)
+DL=$(DESTDIR)$(LIBPATH)
+DM=$(DESTDIR)$(MANPATH)
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+	pngwtran.o pngmem.o pngerror.o pngpread.o
+
+OBJSDLL = $(OBJS:.o=.pic.o)
+
+.SUFFIXES:      .c .o .pic.o
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -o $@ $<
+
+.c.pic.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -fPIC -o $@ $*.c
+
+all: libpng.a $(LIBSO) pngtest libpng.pc libpng-config
+
+libpng.a: $(OBJS)
+	$(AR_RC) $@ $(OBJS)
+	$(RANLIB) $@
+
+libpng.pc:
+	cat scripts/libpng.pc.in | sed -e s!@prefix@!$(prefix)! \
+	-e s!@exec_prefix@!$(exec_prefix)! \
+	-e s!@libdir@!$(LIBPATH)! \
+	-e s!@includedir@!$(INCPATH)! \
+	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+
+libpng-config:
+	( cat scripts/libpng-config-head.in; \
+	echo prefix=\"$(prefix)\"; \
+	echo I_opts=\"-I$(INCPATH)/$(LIBNAME)\"; \
+	echo libs=\"-lpng16 -lz -lm\"; \
+	cat scripts/libpng-config-body.in ) > libpng-config
+	chmod +x libpng-config
+
+$(LIBSO): $(LIBSOMAJ)
+	$(LN_SF) $(LIBSOMAJ) $(LIBSO)
+
+$(LIBSOMAJ): $(OBJSDLL)
+	$(LD) -b +s \
+	+h $(LIBSOMAJ) -o $(LIBSOMAJ) $(OBJSDLL)
+
+pngtest: pngtest.o $(LIBSO)
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
+
+test: pngtest
+	./pngtest
+
+
+install-headers: png.h pngconf.h pnglibconf.h
+	-@if [ ! -d $(DI) ]; then $(MKDIR_P) $(DI); fi
+	-@if [ ! -d $(DI)/$(LIBNAME) ]; then $(MKDIR_P) $(DI)/$(LIBNAME); fi
+	cp png.h pngconf.h pnglibconf.h $(DI)/$(LIBNAME)
+	chmod 644 $(DI)/$(LIBNAME)/png.h $(DI)/$(LIBNAME)/pngconf.h $(DI)/$(LIBNAME)/pnglibconf.h
+	-@$(RM_F) $(DI)/png.h $(DI)/pngconf.h $(DI)/pnglibconf.h
+	-@$(RM_F) $(DI)/libpng
+	(cd $(DI); $(LN_SF) $(LIBNAME) libpng; $(LN_SF) $(LIBNAME)/* .)
+
+install-static: install-headers libpng.a
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	cp libpng.a $(DL)/$(LIBNAME).a
+	chmod 644 $(DL)/$(LIBNAME).a
+	-@$(RM_F) $(DL)/libpng.a
+	(cd $(DL); $(LN_SF) $(LIBNAME).a libpng.a)
+
+install-shared: install-headers $(LIBSOMAJ) libpng.pc
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	-@$(RM_F) $(DL)/$(LIBSO)
+	-@$(RM_F) $(DL)/$(LIBSOREL)
+	-@$(RM_F) $(DL)/$(OLDSO)
+	cp $(LIBSOMAJ) $(DL)/$(LIBSOREL)
+	chmod 755 $(DL)/$(LIBSOREL)
+	(cd $(DL); \
+	$(LN_SF) $(LIBSOREL) $(LIBSO); \
+	$(LN_SF) $(LIBSO) $(OLDSO))
+	-@if [ ! -d $(DL)/pkgconfig ]; then $(MKDIR_P) $(DL)/pkgconfig; fi
+	-@$(RM_F) $(DL)/pkgconfig/$(LIBNAME).pc
+	-@$(RM_F) $(DL)/pkgconfig/libpng.pc
+	cp libpng.pc $(DL)/pkgconfig/$(LIBNAME).pc
+	chmod 644 $(DL)/pkgconfig/$(LIBNAME).pc
+	(cd $(DL)/pkgconfig; $(LN_SF) $(LIBNAME).pc libpng.pc)
+
+install-man: libpng.3 libpngpf.3 png.5
+	-@if [ ! -d $(DM) ]; then $(MKDIR_P) $(DM); fi
+	-@if [ ! -d $(DM)/man3 ]; then $(MKDIR_P) $(DM)/man3; fi
+	-@$(RM_F) $(DM)/man3/libpng.3
+	-@$(RM_F) $(DM)/man3/libpngpf.3
+	cp libpng.3 $(DM)/man3
+	cp libpngpf.3 $(DM)/man3
+	-@if [ ! -d $(DM)/man5 ]; then $(MKDIR_P) $(DM)/man5; fi
+	-@$(RM_F) $(DM)/man5/png.5
+	cp png.5 $(DM)/man5
+
+install-config: libpng-config
+	-@if [ ! -d $(DB) ]; then $(MKDIR_P) $(DB); fi
+	-@$(RM_F) $(DB)/libpng-config
+	-@$(RM_F) $(DB)/$(LIBNAME)-config
+	cp libpng-config $(DB)/$(LIBNAME)-config
+	chmod 755 $(DB)/$(LIBNAME)-config
+	(cd $(DB); $(LN_SF) $(LIBNAME)-config libpng-config)
+
+install: install-static install-shared install-man install-config
+
+# If you installed in $(DESTDIR), test-installed won't work until you
+# move the library to its final location.  Use test-dd to test it
+# before then.
+
+test-dd:
+	echo
+	echo Testing installed dynamic shared library in $(DL).
+	$(CC) -I$(DI) $(CPPFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -L$(DL) -L$(ZLIBLIB) -Wl,-rpath,$(DL) -Wl,-rpath,$(ZLIBLIB) \
+	   -o pngtestd `$(BINPATH)/$(LIBNAME)-config --ldflags`
+	./pngtestd pngtest.png
+
+test-installed:
+	echo
+	echo Testing installed dynamic shared library.
+	$(CC) $(CPPFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -L$(ZLIBLIB) -Wl,-rpath,$(ZLIBLIB) \
+	   -o pngtesti `$(BINPATH)/$(LIBNAME)-config --ldflags`
+	./pngtesti pngtest.png
+
+clean:
+	$(RM_F) *.o libpng.a pngtest pngtesti pngout.png \
+	libpng-config $(LIBSO) $(LIBSOMAJ)* \
+	libpng.pc pnglibconf.h
+
+DOCS = ANNOUNCE CHANGES INSTALL KNOWNBUG LICENSE README TODO
+writelock:
+	chmod a-w *.[ch35] $(DOCS) scripts/*
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o png.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngerror.o pngerror.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrio.o pngrio.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwio.o pngwio.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngmem.o pngmem.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngset.o pngset.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngget.o pngget.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngread.o pngread.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrtran.o pngrtran.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrutil.o pngrutil.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngtrans.o pngtrans.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwrite.o pngwrite.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwtran.o pngwtran.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwutil.o pngwutil.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngpread.o pngpread.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+
+pngtest.o: png.h pngconf.h pnglibconf.h
diff --git a/Engine/lib/lpng/scripts/makefile.hpux b/Engine/lib/lpng/scripts/makefile.hpux
new file mode 100644
index 000000000..27b312a38
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.hpux
@@ -0,0 +1,229 @@
+# makefile for libpng, HPUX (10.20 and 11.00) using the ANSI/C product.
+# Copyright (C) 1999-2002, 2006, 2010-2014 Glenn Randers-Pehrson
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42
+# Contributed by Jim Rice and updated by Chris Schleicher, Hewlett Packard
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# Where the zlib library and include files are located
+ZLIBLIB=/opt/zlib/lib
+ZLIBINC=/opt/zlib/include
+
+# Note that if you plan to build a libpng shared library, zlib must also
+# be a shared library, which zlib's configure does not do.  After running
+# zlib's configure, edit the appropriate lines of makefile to read:
+#   CPPFLAGS=-DHAVE_UNISTD -DUSE_MAP
+#   CFLAGS=-O1 -fPIC
+#   LDSHARED=ld -b
+#   SHAREDLIB=libz.sl
+
+# Library name:
+LIBNAME = libpng16
+PNGMAJ = 16
+
+# Shared library names:
+LIBSO=$(LIBNAME).sl
+LIBSOMAJ=$(LIBNAME).sl.$(PNGMAJ)
+LIBSOREL=$(LIBSOMAJ).$(RELEASE)
+OLDSO=libpng.sl
+
+# Utilities:
+AR_RC=ar rc
+CC=cc
+MKDIR_P=mkdir -p
+LN_SF=ln -sf
+RANLIB=ranlib
+RM_F=/bin/rm -f
+
+# where make install puts libpng.a, libpng16.sl, and png.h
+prefix=/opt/libpng
+exec_prefix=$(prefix)
+INCPATH=$(prefix)/include
+LIBPATH=$(exec_prefix)/lib
+MANPATH=$(prefix)/man
+BINPATH=$(exec_prefix)/bin
+
+CPPFLAGS=-I$(ZLIBINC)
+CFLAGS=-O -Ae +DA1.1 +DS2.0
+# Caution: be sure you have built zlib with the same CFLAGS.
+CCFLAGS=-O -Ae +DA1.1 +DS2.0
+LDFLAGS=-L. -L$(ZLIBLIB) -lpng -lz -lm
+
+# override DESTDIR= on the make install command line to easily support
+# installing into a temporary location.  Example:
+#
+#    make install DESTDIR=/tmp/build/libpng
+#
+# If you're going to install into a temporary location
+# via DESTDIR, $(DESTDIR)$(prefix) must already exist before
+# you execute make install.
+DESTDIR=
+
+DB=$(DESTDIR)$(BINPATH)
+DI=$(DESTDIR)$(INCPATH)
+DL=$(DESTDIR)$(LIBPATH)
+DM=$(DESTDIR)$(MANPATH)
+
+# Pre-built configuration
+# See scripts/pnglibconf.mak for more options
+PNGLIBCONF_H_PREBUILT = scripts/pnglibconf.h.prebuilt
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+	pngwtran.o pngmem.o pngerror.o pngpread.o
+
+OBJSDLL = $(OBJS:.o=.pic.o)
+
+.SUFFIXES:	.c .o .pic.o
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -o $@ $<
+
+.c.pic.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) +z -o $@ $*.c
+
+all: libpng.a $(LIBSO) pngtest libpng.pc libpng-config
+
+pnglibconf.h: $(PNGLIBCONF_H_PREBUILT)
+	$(CP) $(PNGLIBCONF_H_PREBUILT) $@
+
+libpng.a: $(OBJS)
+	$(AR_RC) $@ $(OBJS)
+	$(RANLIB) $@
+
+libpng.pc:
+	cat scripts/libpng.pc.in | sed -e s!@prefix@!$(prefix)! \
+	-e s!@exec_prefix@!$(exec_prefix)! \
+	-e s!@libdir@!$(LIBPATH)! \
+	-e s!@includedir@!$(INCPATH)! \
+	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+
+libpng-config:
+	( cat scripts/libpng-config-head.in; \
+	echo prefix=\"$(prefix)\"; \
+	echo I_opts=\"-I$(INCPATH)/$(LIBNAME)\"; \
+	echo ccopts=\"-O -Ae +DA1.1 +DS2.0\"; \
+	echo L_opts=\"-L$(LIBPATH)\"; \
+	echo libs=\"-lpng16 -lz -lm\"; \
+	cat scripts/libpng-config-body.in ) > libpng-config
+	chmod +x libpng-config
+
+$(LIBSO): $(LIBSOMAJ)
+	$(LN_SF) $(LIBSOMAJ) $(LIBSO)
+
+$(LIBSOMAJ): $(OBJSDLL)
+	$(LD) -b +s \
+	+h $(LIBSOMAJ) -o $(LIBSOMAJ) $(OBJSDLL)
+
+pngtest: pngtest.o libpng.a
+	$(CC) -o pngtest $(CCFLAGS) pngtest.o $(LDFLAGS)
+
+test: pngtest
+	./pngtest
+
+install-headers: png.h pngconf.h pnglibconf.h
+	-@if [ ! -d $(DI) ]; then $(MKDIR_P) $(DI); fi
+	-@if [ ! -d $(DI)/$(LIBNAME) ]; then $(MKDIR_P) $(DI)/$(LIBNAME); fi
+	cp png.h pngconf.h pnglibconf.h $(DI)/$(LIBNAME)
+	chmod 644 $(DI)/$(LIBNAME)/png.h $(DI)/$(LIBNAME)/pngconf.h $(DI)/$(LIBNAME)/pnglibconf.h
+	-@$(RM_F) $(DI)/png.h $(DI)/pngconf.h $(DI)/pnglibconf.h
+	-@$(RM_F) $(DI)/libpng
+	(cd $(DI); $(LN_SF) $(LIBNAME) libpng; $(LN_SF) $(LIBNAME)/* .)
+
+install-static: install-headers libpng.a
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	cp libpng.a $(DL)/$(LIBNAME).a
+	chmod 644 $(DL)/$(LIBNAME).a
+	-@$(RM_F) $(DL)/libpng.a
+	(cd $(DL); $(LN_SF) $(LIBNAME).a libpng.a)
+
+install-shared: install-headers $(LIBSOMAJ) libpng.pc
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	-@$(RM_F) $(DL)/$(LIBSO)
+	-@$(RM_F) $(DL)/$(LIBSOREL)
+	-@$(RM_F) $(DL)/$(OLDSO)
+	cp $(LIBSOMAJ) $(DL)/$(LIBSOREL)
+	chmod 755 $(DL)/$(LIBSOREL)
+	(cd $(DL); \
+	$(LN_SF) $(LIBSOREL) $(LIBSO); \
+	$(LN_SF) $(LIBSO) $(OLDSO))
+	-@if [ ! -d $(DL)/pkgconfig ]; then $(MKDIR_P) $(DL)/pkgconfig; fi
+	-@$(RM_F) $(DL)/pkgconfig/$(LIBNAME).pc
+	-@$(RM_F) $(DL)/pkgconfig/libpng.pc
+	cp libpng.pc $(DL)/pkgconfig/$(LIBNAME).pc
+	chmod 644 $(DL)/pkgconfig/$(LIBNAME).pc
+	(cd $(DL)/pkgconfig; $(LN_SF) $(LIBNAME).pc libpng.pc)
+
+install-man: libpng.3 libpngpf.3 png.5
+	-@if [ ! -d $(DM) ]; then $(MKDIR_P) $(DM); fi
+	-@if [ ! -d $(DM)/man3 ]; then $(MKDIR_P) $(DM)/man3; fi
+	-@$(RM_F) $(DM)/man3/libpng.3
+	-@$(RM_F) $(DM)/man3/libpngpf.3
+	cp libpng.3 $(DM)/man3
+	cp libpngpf.3 $(DM)/man3
+	-@if [ ! -d $(DM)/man5 ]; then $(MKDIR_P) $(DM)/man5; fi
+	-@$(RM_F) $(DM)/man5/png.5
+	cp png.5 $(DM)/man5
+
+install-config: libpng-config
+	-@if [ ! -d $(DB) ]; then $(MKDIR_P) $(DB); fi
+	-@$(RM_F) $(DB)/libpng-config
+	-@$(RM_F) $(DB)/$(LIBNAME)-config
+	cp libpng-config $(DB)/$(LIBNAME)-config
+	chmod 755 $(DB)/$(LIBNAME)-config
+	(cd $(DB); $(LN_SF) $(LIBNAME)-config libpng-config)
+
+install: install-static install-shared install-man install-config
+
+# If you installed in $(DESTDIR), test-installed won't work until you
+# move the library to its final location.  Use test-dd to test it
+# before then.
+
+test-dd:
+	echo
+	echo Testing installed dynamic shared library in $(DL).
+	$(CC) -I$(DI) $(CPPFLAGS) $(CCFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -L$(DL) -L$(ZLIBLIB) \
+	   -o pngtestd `$(BINPATH)/$(LIBNAME)-config --ldflags`
+	./pngtestd pngtest.png
+
+test-installed:
+	echo
+	echo Testing installed dynamic shared library.
+	$(CC) $(CPPFLAGS) $(CCFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -L$(ZLIBLIB) \
+	   -o pngtesti `$(BINPATH)/$(LIBNAME)-config --ldflags`
+	./pngtesti pngtest.png
+
+clean:
+	$(RM_F) *.o libpng.a pngtest pngtesti pngout.png \
+	libpng-config $(LIBSO) $(LIBSOMAJ)* \
+	libpng.pc pnglibconf.h
+
+DOCS = ANNOUNCE CHANGES INSTALL KNOWNBUG LICENSE README TODO
+writelock:
+	chmod a-w *.[ch35] $(DOCS) scripts/*
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngerror.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrio.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwio.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngmem.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngset.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngget.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngread.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngtrans.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwrite.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngpread.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+
+pngtest.o: png.h pngconf.h pnglibconf.h
diff --git a/Engine/lib/lpng/scripts/makefile.ibmc b/Engine/lib/lpng/scripts/makefile.ibmc
new file mode 100644
index 000000000..89b11966b
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.ibmc
@@ -0,0 +1,90 @@
+# Makefile for libpng (static)
+# IBM C version 3.x for Win32 and OS/2
+# Copyright (C) 2006, 2014 Glenn Randers-Pehrson
+# Copyright (C) 2000 Cosmin Truta
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+#
+# Notes:
+#   Derived from makefile.std
+#   All modules are compiled in C mode
+#   Tested under Win32, expected to work under OS/2
+#   Can be easily adapted for IBM VisualAge/C++ for AIX
+
+# Location of the zlib library and include files
+ZLIBINC = ../zlib
+ZLIBLIB = ../zlib
+
+# Compiler, linker, lib and other tools
+CC = icc
+LD = ilink
+AR = ilib
+CP = copy
+RM = del
+
+CPPFLAGS = -I$(ZLIBINC)
+CFLAGS = -Mc -O2 -W3
+LDFLAGS =
+
+# Pre-built configuration
+# See scripts/pnglibconf.mak for more options
+PNGLIBCONF_H_PREBUILT = scripts/pnglibconf.h.prebuilt
+
+# File extensions
+O=.obj
+A=.lib
+E=.exe
+
+# Variables
+OBJS = png$(O) pngerror$(O) pngget$(O) pngmem$(O) pngpread$(O) \
+	pngread$(O) pngrio$(O) pngrtran$(O) pngrutil$(O) pngset$(O) \
+	pngtrans$(O) pngwio$(O) pngwrite$(O) pngwtran$(O) pngwutil$(O)
+
+LIBS = libpng$(A) $(ZLIBLIB)/zlib$(A)
+
+# Targets
+.c$(O):
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) $<
+
+all: libpng$(A) pngtest$(E)
+
+pnglibconf.h: $(PNGLIBCONF_H_PREBUILT)
+	$(CP) $(PNGLIBCONF_H_PREBUILT) $@
+
+libpng$(A): $(OBJS)
+	$(AR) -out:$@ $(OBJS)
+
+test: pngtest$(E)
+	pngtest$(E)
+
+pngtest: pngtest$(E)
+
+pngtest$(E): pngtest$(O) libpng$(A)
+	$(LD) $(LDFLAGS) pngtest$(O) $(LIBS)
+
+clean:
+	$(RM) *$(O)
+	$(RM) libpng$(A)
+	$(RM) pnglibconf.h
+	$(RM) pngtest$(E)
+	$(RM) pngout.png
+
+png$(O):      png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngerror$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngget$(O):   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngmem$(O):   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngpread$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngread$(O):  png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrio$(O):   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrtran$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrutil$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngset$(O):   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngtrans$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwio$(O):   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwrite$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwtran$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwutil$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+
+pngtest$(O):  png.h pngconf.h pnglibconf.h
diff --git a/Engine/lib/lpng/scripts/makefile.intel b/Engine/lib/lpng/scripts/makefile.intel
new file mode 100644
index 000000000..418726159
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.intel
@@ -0,0 +1,115 @@
+# Makefile for libpng
+# Microsoft Visual C++ with Intel C/C++ Compiler 4.0 and later
+
+# Copyright (C) 2006, 2014 Glenn Randers-Pehrson
+# Copyright (C) 2000, Pawel Mrochen, based on makefile.msc which is
+# copyright 1995 Guy Eric Schalnat, Group 42, Inc.
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+#
+# To use, do "nmake /f scripts\makefile.intel"
+#
+# ------------------- Intel C/C++ Compiler 4.0 and later -------------------
+
+# Where the zlib library and include files are located
+ZLIBLIB=..\zlib
+ZLIBINC=..\zlib
+
+# Target CPU
+CPU=6		# Pentium II
+#CPU=5		# Pentium
+
+# Calling convention
+CALLING=r	# __fastcall
+#CALLING=z	# __stdcall
+#CALLING=d	# __cdecl
+
+# Uncomment next to put error messages in a file
+#ERRFILE=>>pngerrs
+
+# --------------------------------------------------------------------------
+
+CC=icl -c
+CPPFLAGS=-I$(ZLIBINC)
+CFLAGS=-O2 -G$(CPU)$(CALLING) -Qip -Qunroll4 -nologo
+LD=link
+LDFLAGS=/SUBSYSTEM:CONSOLE /NOLOGO
+CP=cp
+
+# Pre-built configuration
+# See scripts\pnglibconf.mak for more options
+PNGLIBCONF_H_PREBUILT = scripts\pnglibconf.h.prebuilt
+
+O=.obj
+
+OBJS=png$(O) pngset$(O) pngget$(O) pngrutil$(O) pngtrans$(O) pngwutil$(O) \
+pngmem$(O) pngpread$(O) pngread$(O) pngerror$(O) pngwrite$(O) \
+pngrtran$(O) pngwtran$(O) pngrio$(O) pngwio$(O)
+
+all: test
+
+pnglibconf.h: $(PNGLIBCONF_H_PREBUILT)
+	$(CP) $(PNGLIBCONF_H_PREBUILT) $@
+
+png$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+pngset$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+pngget$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+pngread$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+pngpread$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+pngrtran$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+pngrutil$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+pngerror$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+pngmem$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+pngrio$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+pngwio$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+pngtrans$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+pngwrite$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+pngwtran$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+pngwutil$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+libpng.lib: $(OBJS)
+	if exist libpng.lib del libpng.lib
+	lib /NOLOGO /OUT:libpng.lib $(OBJS)
+
+pngtest.exe: pngtest.obj libpng.lib
+	$(LD) $(LDFLAGS) /OUT:pngtest.exe pngtest.obj libpng.lib $(ZLIBLIB)\zlib.lib
+
+pngtest$(O): png.h pngconf.h pnglibconf.h
+	$(CC) $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+test: pngtest.exe
+	pngtest.exe
+
+
+# End of makefile for libpng
diff --git a/Engine/lib/lpng/scripts/makefile.linux b/Engine/lib/lpng/scripts/makefile.linux
new file mode 100644
index 000000000..f2d8beae2
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.linux
@@ -0,0 +1,246 @@
+# makefile for libpng.a and libpng16.so on Linux ELF with gcc
+# Copyright (C) 1998, 1999, 2002, 2006, 2008, 2010-2014 Greg Roelofs and
+# Glenn Randers-Pehrson
+# Copyright (C) 1996, 1997 Andreas Dilger
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# Library name:
+LIBNAME = libpng16
+PNGMAJ = 16
+RELEASE = 37
+
+# Shared library names:
+LIBSO=$(LIBNAME).so
+LIBSOMAJ=$(LIBNAME).so.$(PNGMAJ)
+LIBSOREL=$(LIBSOMAJ).$(RELEASE)
+OLDSO=libpng.so
+
+# Utilities:
+AR_RC=ar rc
+CC=gcc
+MKDIR_P=mkdir -p
+LN_SF=ln -sf
+RANLIB=ranlib
+CP=cp
+RM_F=/bin/rm -f
+
+# where "make install" puts libpng16.a, libpng16.so*,
+# libpng16/png.h, libpng16/pngconf.h, and libpng16/pnglibconf.h
+# Prefix must be a full pathname.
+prefix=/usr/local
+exec_prefix=$(prefix)
+
+# Where the zlib library and include files are located.
+#ZLIBLIB=/usr/local/lib
+#ZLIBINC=/usr/local/include
+ZLIBLIB=../zlib
+ZLIBINC=../zlib
+
+ALIGN=
+# for i386:
+#ALIGN=-malign-loops=2 -malign-functions=2
+
+WARNMORE=-Wwrite-strings -Wpointer-arith -Wshadow \
+	-Wmissing-declarations -Wtraditional -Wcast-align \
+	-Wstrict-prototypes -Wmissing-prototypes #-Wconversion
+
+# for pgcc version 2.95.1, -O3 is buggy; don't use it.
+
+CPPFLAGS=-I$(ZLIBINC) # -DPNG_DEBUG=5
+CFLAGS=-W -Wall -O3 -funroll-loops $(ALIGN) # $(WARNMORE) -g
+
+LDFLAGS=-L. -Wl,-rpath,. -L$(ZLIBLIB) -Wl,-rpath,$(ZLIBLIB) -lpng16 -lz -lm
+LDFLAGS_A=-L$(ZLIBLIB) -Wl,-rpath,$(ZLIBLIB) libpng.a -lz -lm
+
+INCPATH=$(prefix)/include
+LIBPATH=$(exec_prefix)/lib
+MANPATH=$(prefix)/man
+BINPATH=$(exec_prefix)/bin
+
+# override DESTDIR= on the make install command line to easily support
+# installing into a temporary location.  Example:
+#
+#    make install DESTDIR=/tmp/build/libpng
+#
+# If you're going to install into a temporary location
+# via DESTDIR, $(DESTDIR)$(prefix) must already exist before
+# you execute make install.
+DESTDIR=
+
+DB=$(DESTDIR)$(BINPATH)
+DI=$(DESTDIR)$(INCPATH)
+DL=$(DESTDIR)$(LIBPATH)
+DM=$(DESTDIR)$(MANPATH)
+
+# Pre-built configuration
+# See scripts/pnglibconf.mak for more options
+PNGLIBCONF_H_PREBUILT = scripts/pnglibconf.h.prebuilt
+
+OBJS =  png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+	pngwtran.o pngmem.o pngerror.o pngpread.o
+
+OBJSDLL = $(OBJS:.o=.pic.o)
+
+.SUFFIXES:      .c .o .pic.o
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -o $@ $<
+
+.c.pic.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -fPIC -o $@ $*.c
+
+all: libpng.a $(LIBSO) pngtest pngtest-static libpng.pc libpng-config
+
+pnglibconf.h: $(PNGLIBCONF_H_PREBUILT)
+	$(CP) $(PNGLIBCONF_H_PREBUILT) $@
+
+libpng.a: $(OBJS)
+	$(AR_RC) $@ $(OBJS)
+	$(RANLIB) $@
+
+libpng.pc:
+	cat scripts/libpng.pc.in | sed -e s!@prefix@!$(prefix)! \
+	-e s!@exec_prefix@!$(exec_prefix)! \
+	-e s!@libdir@!$(LIBPATH)! \
+	-e s!@includedir@!$(INCPATH)! \
+	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+
+libpng-config:
+	( cat scripts/libpng-config-head.in; \
+	echo prefix=\"$(prefix)\"; \
+	echo I_opts=\"-I$(INCPATH)/$(LIBNAME)\"; \
+	echo L_opts=\"-L$(LIBPATH)\"; \
+	echo R_opts=\"-Wl,-rpath,$(LIBPATH)\"; \
+	echo libs=\"-lpng16 -lz -lm\"; \
+	cat scripts/libpng-config-body.in ) > libpng-config
+	chmod +x libpng-config
+
+$(LIBSO): $(LIBSOMAJ)
+	$(LN_SF) $(LIBSOMAJ) $(LIBSO)
+
+$(LIBSOMAJ): $(OBJSDLL)
+	$(CC) -shared -Wl,-soname,$(LIBSOMAJ) -o $(LIBSOMAJ) $(OBJSDLL)
+
+pngtest: pngtest.o $(LIBSO)
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
+
+pngtest-static: pngtest.o libpng.a
+	$(CC) -o pngtest-static $(CFLAGS) pngtest.o $(LDFLAGS_A)
+
+test: pngtest pngtest-static
+	@echo ""
+	@echo "   Running pngtest dynamically linked with $(LIBSO):"
+	@echo ""
+	./pngtest
+	@echo ""
+	@echo "   Running pngtest statically linked with libpng.a:"
+	@echo ""
+	./pngtest-static
+
+install-headers: png.h pngconf.h pnglibconf.h
+	-@if [ ! -d $(DI) ]; then $(MKDIR_P) $(DI); fi
+	-@if [ ! -d $(DI)/$(LIBNAME) ]; then $(MKDIR_P) $(DI)/$(LIBNAME); fi
+	cp png.h pngconf.h pnglibconf.h $(DI)/$(LIBNAME)
+	chmod 644 $(DI)/$(LIBNAME)/png.h $(DI)/$(LIBNAME)/pngconf.h $(DI)/$(LIBNAME)/pnglibconf.h
+	-@$(RM_F) $(DI)/png.h $(DI)/pngconf.h $(DI)/pnglibconf.h
+	-@$(RM_F) $(DI)/libpng
+	(cd $(DI); $(LN_SF) $(LIBNAME) libpng; $(LN_SF) $(LIBNAME)/* .)
+
+install-static: install-headers libpng.a
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	cp libpng.a $(DL)/$(LIBNAME).a
+	chmod 644 $(DL)/$(LIBNAME).a
+	-@$(RM_F) $(DL)/libpng.a
+	(cd $(DL); $(LN_SF) $(LIBNAME).a libpng.a)
+
+install-shared: install-headers $(LIBSOMAJ) libpng.pc
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	-@$(RM_F) $(DL)/$(LIBSO)
+	-@$(RM_F) $(DL)/$(LIBSOREL)
+	-@$(RM_F) $(DL)/$(OLDSO)
+	cp $(LIBSOMAJ) $(DL)/$(LIBSOREL)
+	chmod 755 $(DL)/$(LIBSOREL)
+	(cd $(DL); \
+	$(LN_SF) $(LIBSOREL) $(LIBSO); \
+	$(LN_SF) $(LIBSO) $(OLDSO))
+
+	-@if [ ! -d $(DL)/pkgconfig ]; then $(MKDIR_P) $(DL)/pkgconfig; fi
+	-@$(RM_F) $(DL)/pkgconfig/$(LIBNAME).pc
+	-@$(RM_F) $(DL)/pkgconfig/libpng.pc
+	cp libpng.pc $(DL)/pkgconfig/$(LIBNAME).pc
+	chmod 644 $(DL)/pkgconfig/$(LIBNAME).pc
+	(cd $(DL)/pkgconfig; $(LN_SF) $(LIBNAME).pc libpng.pc)
+
+install-man: libpng.3 libpngpf.3 png.5
+	-@if [ ! -d $(DM) ]; then $(MKDIR_P) $(DM); fi
+	-@if [ ! -d $(DM)/man3 ]; then $(MKDIR_P) $(DM)/man3; fi
+	-@$(RM_F) $(DM)/man3/libpng.3
+	-@$(RM_F) $(DM)/man3/libpngpf.3
+	cp libpng.3 $(DM)/man3
+	cp libpngpf.3 $(DM)/man3
+	-@if [ ! -d $(DM)/man5 ]; then $(MKDIR_P) $(DM)/man5; fi
+	-@$(RM_F) $(DM)/man5/png.5
+	cp png.5 $(DM)/man5
+
+install-config: libpng-config
+	-@if [ ! -d $(DB) ]; then $(MKDIR_P) $(DB); fi
+	-@$(RM_F) $(DB)/libpng-config
+	-@$(RM_F) $(DB)/$(LIBNAME)-config
+	cp libpng-config $(DB)/$(LIBNAME)-config
+	chmod 755 $(DB)/$(LIBNAME)-config
+	(cd $(DB); $(LN_SF) $(LIBNAME)-config libpng-config)
+
+install: install-static install-shared install-man install-config
+
+# If you installed in $(DESTDIR), test-installed won't work until you
+# move the library to its final location.  Use test-dd to test it
+# before then.
+
+test-dd:
+	echo
+	echo Testing installed dynamic shared library in $(DL).
+	$(CC) -I$(DI) $(CPPFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -L$(DL) -L$(ZLIBLIB) -Wl, -rpath,$(DL) -Wl,-rpath,$(ZLIBLIB) \
+	   -o pngtestd `$(BINPATH)/$(LIBNAME)-config --ldflags`
+	./pngtestd pngtest.png
+
+test-installed:
+	$(CC) $(CPPFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -L$(ZLIBLIB) -Wl,-rpath,$(ZLIBLIB) \
+	   -o pngtesti `$(BINPATH)/$(LIBNAME)-config --ldflags`
+	./pngtesti pngtest.png
+
+clean:
+	$(RM_F) *.o libpng.a pngtest pngout.png libpng-config \
+	$(LIBSO) $(LIBSOMAJ)* pngtest-static pngtesti \
+	libpng.pc pnglibconf.h
+
+DOCS = ANNOUNCE CHANGES INSTALL KNOWNBUG LICENSE README TODO
+writelock:
+	chmod a-w *.[ch35] $(DOCS) scripts/*
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o png.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngerror.o pngerror.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrio.o pngrio.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwio.o pngwio.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngmem.o pngmem.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngset.o pngset.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngget.o pngget.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngread.o pngread.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrtran.o pngrtran.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrutil.o pngrutil.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngtrans.o pngtrans.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwrite.o pngwrite.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwtran.o pngwtran.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwutil.o pngwutil.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngpread.o pngpread.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+
+pngtest.o: png.h pngconf.h pnglibconf.h
diff --git a/Engine/lib/lpng/scripts/makefile.linux-opt b/Engine/lib/lpng/scripts/makefile.linux-opt
new file mode 100644
index 000000000..327151f0e
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.linux-opt
@@ -0,0 +1,265 @@
+# makefile for libpng.a and libpng16.so on Linux ELF with gcc
+# Copyright (C) 1998,1999,2002,2006,2008,2010-2014,2017 Greg Roelofs and
+# Glenn Randers-Pehrson
+# Copyright (C) 1996,1997 Andreas Dilger
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# Library name:
+LIBNAME = libpng16
+PNGMAJ = 16
+RELEASE = 37
+
+# Shared library names:
+LIBSO=$(LIBNAME).so
+LIBSOMAJ=$(LIBNAME).so.$(PNGMAJ)
+LIBSOREL=$(LIBSOMAJ).$(RELEASE)
+OLDSO=libpng.so
+
+# Utilities:
+AR_RC=ar rc
+CC=gcc
+MKDIR_P=mkdir -p
+LN_SF=ln -sf
+RANLIB=ranlib
+CP=cp
+RM_F=/bin/rm -f
+
+# where "make install" puts libpng16.a, libpng16.so*,
+# libpng16/png.h, libpng16/pngconf.h, and libpng16/pnglibconf.h
+# Prefix must be a full pathname.
+prefix=/usr/local
+exec_prefix=$(prefix)
+
+# Where the zlib library and include files are located.
+#ZLIBLIB=/usr/local/lib
+#ZLIBINC=/usr/local/include
+ZLIBLIB=../zlib
+ZLIBINC=../zlib
+
+ALIGN=
+# for i386:
+#ALIGN=-malign-loops=2 -malign-functions=2
+
+#WARNMORE=-Wwrite-strings -Wpointer-arith \
+#	-Wmissing-declarations -Wtraditional -Wcast-align \
+#	-Wstrict-prototypes -Wmissing-prototypes
+
+# for pgcc version 2.95.1, -O3 is buggy; don't use it.
+
+CPPFLAGS=-I$(ZLIBINC)
+CPPFLAGS += -DPNG_ARM_NEON
+CPPFLAGS += -DPNG_MIPS_MSA
+CPPFLAGS += -DPNG_INTEL_SSE
+CPPFLAGS += -DPNG_POWERPC_VSX
+CPPFLAGS+=-ansi -pedantic -Wextra -Wall -Wshadow -Wno-sign-conversion
+CPPFLAGS+=-W -Wall -Wconversion $(ALIGN)
+# CPPFLAGS+=$(WARNMORE)
+CFLAGS= -O3 -funroll-loops
+
+LDFLAGS=-L. -Wl,-rpath,. -L$(ZLIBLIB) -Wl,-rpath,$(ZLIBLIB) -lpng16 -lz -lm
+LDFLAGS_A=-L$(ZLIBLIB) -Wl,-rpath,$(ZLIBLIB) libpng.a -lz -lm
+
+INCPATH=$(prefix)/include
+LIBPATH=$(exec_prefix)/lib
+MANPATH=$(prefix)/man
+BINPATH=$(exec_prefix)/bin
+
+# override DESTDIR= on the make install command line to easily support
+# installing into a temporary location.  Example:
+#
+#    make install DESTDIR=/tmp/build/libpng
+#
+# If you're going to install into a temporary location
+# via DESTDIR, $(DESTDIR)$(prefix) must already exist before
+# you execute make install.
+DESTDIR=
+
+DB=$(DESTDIR)$(BINPATH)
+DI=$(DESTDIR)$(INCPATH)
+DL=$(DESTDIR)$(LIBPATH)
+DM=$(DESTDIR)$(MANPATH)
+
+# Pre-built configuration
+# See scripts/pnglibconf.mak for more options
+PNGLIBCONF_H_PREBUILT = scripts/pnglibconf.h.prebuilt
+
+OBJS =  png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+	pngwtran.o pngmem.o pngerror.o pngpread.o \
+	arm/arm_init.o arm/filter_neon_intrinsics.o \
+	mips/mips_init.o mips/filter_msa_intrinsics.o \
+	intel/intel_init.o intel/filter_sse2_intrinsics.o\
+	powerpc/powerpc_init.o powerpc/filter_vsx_intrinsics.o
+
+OBJSDLL = $(OBJS:.o=.pic.o)
+
+.SUFFIXES:      .c .o .pic.o
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -o $@ $<
+
+.c.pic.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -fPIC -o $@ $*.c
+
+all: libpng.a $(LIBSO) pngtest pngtest-static libpng.pc libpng-config
+
+pnglibconf.h: $(PNGLIBCONF_H_PREBUILT)
+	$(CP) $(PNGLIBCONF_H_PREBUILT) $@
+
+libpng.a: $(OBJS)
+	$(AR_RC) $@ $(OBJS)
+	$(RANLIB) $@
+
+libpng.pc:
+	cat scripts/libpng.pc.in | sed -e s!@prefix@!$(prefix)! \
+	-e s!@exec_prefix@!$(exec_prefix)! \
+	-e s!@libdir@!$(LIBPATH)! \
+	-e s!@includedir@!$(INCPATH)! \
+	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+
+libpng-config:
+	( cat scripts/libpng-config-head.in; \
+	echo prefix=\"$(prefix)\"; \
+	echo I_opts=\"-I$(INCPATH)/$(LIBNAME)\"; \
+	echo L_opts=\"-L$(LIBPATH)\"; \
+	echo R_opts=\"-Wl,-rpath,$(LIBPATH)\"; \
+	echo libs=\"-lpng16 -lz -lm\"; \
+	cat scripts/libpng-config-body.in ) > libpng-config
+	chmod +x libpng-config
+
+$(LIBSO): $(LIBSOMAJ)
+	$(LN_SF) $(LIBSOMAJ) $(LIBSO)
+
+$(LIBSOMAJ): $(OBJSDLL)
+	$(CC) -shared -Wl,-soname,$(LIBSOMAJ) -o $(LIBSOMAJ) $(OBJSDLL)
+
+pngtest: pngtest.o $(LIBSO)
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
+
+pngtest-static: pngtest.o libpng.a
+	$(CC) -o pngtest-static $(CFLAGS) pngtest.o $(LDFLAGS_A)
+
+test: pngtest pngtest-static
+	@echo ""
+	@echo "   Running pngtest dynamically linked with $(LIBSO):"
+	@echo ""
+	./pngtest
+	@echo ""
+	@echo "   Running pngtest statically linked with libpng.a:"
+	@echo ""
+	./pngtest-static
+
+install-headers: png.h pngconf.h pnglibconf.h
+	-@if [ ! -d $(DI) ]; then $(MKDIR_P) $(DI); fi
+	-@if [ ! -d $(DI)/$(LIBNAME) ]; then $(MKDIR_P) $(DI)/$(LIBNAME); fi
+	cp png.h pngconf.h pnglibconf.h $(DI)/$(LIBNAME)
+	chmod 644 $(DI)/$(LIBNAME)/png.h $(DI)/$(LIBNAME)/pngconf.h $(DI)/$(LIBNAME)/pnglibconf.h
+	-@$(RM_F) $(DI)/png.h $(DI)/pngconf.h $(DI)/pnglibconf.h
+	-@$(RM_F) $(DI)/libpng
+	(cd $(DI); $(LN_SF) $(LIBNAME) libpng; $(LN_SF) $(LIBNAME)/* .)
+
+install-static: install-headers libpng.a
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	cp libpng.a $(DL)/$(LIBNAME).a
+	chmod 644 $(DL)/$(LIBNAME).a
+	-@$(RM_F) $(DL)/libpng.a
+	(cd $(DL); $(LN_SF) $(LIBNAME).a libpng.a)
+
+install-shared: install-headers $(LIBSOMAJ) libpng.pc
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	-@$(RM_F) $(DL)/$(LIBSO)
+	-@$(RM_F) $(DL)/$(LIBSOREL)
+	-@$(RM_F) $(DL)/$(OLDSO)
+	cp $(LIBSOMAJ) $(DL)/$(LIBSOREL)
+	chmod 755 $(DL)/$(LIBSOREL)
+	(cd $(DL); \
+	$(LN_SF) $(LIBSOREL) $(LIBSO); \
+	$(LN_SF) $(LIBSO) $(OLDSO))
+
+	-@if [ ! -d $(DL)/pkgconfig ]; then $(MKDIR_P) $(DL)/pkgconfig; fi
+	-@$(RM_F) $(DL)/pkgconfig/$(LIBNAME).pc
+	-@$(RM_F) $(DL)/pkgconfig/libpng.pc
+	cp libpng.pc $(DL)/pkgconfig/$(LIBNAME).pc
+	chmod 644 $(DL)/pkgconfig/$(LIBNAME).pc
+	(cd $(DL)/pkgconfig; $(LN_SF) $(LIBNAME).pc libpng.pc)
+
+install-man: libpng.3 libpngpf.3 png.5
+	-@if [ ! -d $(DM) ]; then $(MKDIR_P) $(DM); fi
+	-@if [ ! -d $(DM)/man3 ]; then $(MKDIR_P) $(DM)/man3; fi
+	-@$(RM_F) $(DM)/man3/libpng.3
+	-@$(RM_F) $(DM)/man3/libpngpf.3
+	cp libpng.3 $(DM)/man3
+	cp libpngpf.3 $(DM)/man3
+	-@if [ ! -d $(DM)/man5 ]; then $(MKDIR_P) $(DM)/man5; fi
+	-@$(RM_F) $(DM)/man5/png.5
+	cp png.5 $(DM)/man5
+
+install-config: libpng-config
+	-@if [ ! -d $(DB) ]; then $(MKDIR_P) $(DB); fi
+	-@$(RM_F) $(DB)/libpng-config
+	-@$(RM_F) $(DB)/$(LIBNAME)-config
+	cp libpng-config $(DB)/$(LIBNAME)-config
+	chmod 755 $(DB)/$(LIBNAME)-config
+	(cd $(DB); $(LN_SF) $(LIBNAME)-config libpng-config)
+
+install: install-static install-shared install-man install-config
+
+# If you installed in $(DESTDIR), test-installed won't work until you
+# move the library to its final location.  Use test-dd to test it
+# before then.
+
+test-dd:
+	echo
+	echo Testing installed dynamic shared library in $(DL).
+	$(CC) -I$(DI) $(CPPFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -L$(DL) -L$(ZLIBLIB) -Wl, -rpath,$(DL) -Wl,-rpath,$(ZLIBLIB) \
+	   -o pngtestd `$(BINPATH)/$(LIBNAME)-config --ldflags`
+	./pngtestd pngtest.png
+
+test-installed:
+	$(CC) $(CPPFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -L$(ZLIBLIB) -Wl,-rpath,$(ZLIBLIB) \
+	   -o pngtesti `$(BINPATH)/$(LIBNAME)-config --ldflags`
+	./pngtesti pngtest.png
+
+clean:
+	$(RM_F) *.o libpng.a pngtest pngout.png libpng-config \
+	$(LIBSO) $(LIBSOMAJ)* pngtest-static pngtesti \
+	libpng.pc pnglibconf.h
+
+DOCS = ANNOUNCE CHANGES INSTALL KNOWNBUG LICENSE README TODO
+writelock:
+	chmod a-w *.[ch35] $(DOCS) scripts/*
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o png.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngerror.o pngerror.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrio.o pngrio.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwio.o pngwio.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngmem.o pngmem.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngset.o pngset.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngget.o pngget.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngread.o pngread.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrtran.o pngrtran.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrutil.o pngrutil.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngtrans.o pngtrans.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwrite.o pngwrite.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwtran.o pngwtran.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwutil.o pngwutil.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngpread.o pngpread.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+arm/arm_init.o arm/arm_init.o: pngpriv.h
+arm/filter_neon_intrinsics.o arm/filter_neon_intrinsics.pic.o: pngpriv.h
+mips/mips_init.o mips/mips_init.pic.o: pngpriv.h
+mips/filter_msa_intrinsics.o mips/filter_msa_intrinsics.pic.:  pngpriv.h
+intel/intel_init.o intel/intel_init.pic.:  pngpriv.h
+intel/filter_sse2_intrinsics.o intel/filter_sse2_intrinsics.pic.:  pngpriv.h
+powerpc/powerpc_init.o powerpc/powerpc_init.pic.:  pngpriv.h
+powerpc/filter_vsx_intrinsics.o powerpc/filter_vsx_intrinsics.pic.:  pngpriv.h
+
+pngtest.o: png.h pngconf.h pnglibconf.h
diff --git a/Engine/lib/lpng/scripts/makefile.mips b/Engine/lib/lpng/scripts/makefile.mips
new file mode 100644
index 000000000..0357ae81c
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.mips
@@ -0,0 +1,103 @@
+# makefile for libpng
+# Copyright (C) 1998-2014 Glenn Randers-Pehrson
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# where make install puts libpng.a and png.h
+prefix=/usr/local
+INCPATH=$(prefix)/include
+LIBPATH=$(prefix)/lib
+
+# override DESTDIR= on the make install command line to easily support
+# installing into a temporary location.  Example:
+#
+#    make install DESTDIR=/tmp/build/libpng
+#
+# If you're going to install into a temporary location
+# via DESTDIR, $(DESTDIR)$(prefix) must already exist before
+# you execute make install.
+DESTDIR=
+
+CC=cc
+CPPFLAGS=-I../zlib -DSYSV -Dmips
+CFLAGS=-O -systype sysv -w
+#CFLAGS=-O
+LDFLAGS=-L. -L../zlib/ -lpng -lz -lm
+
+#RANLIB=ranlib
+RANLIB=echo
+
+CP=cp
+
+# Pre-built configuration
+# See scripts/pnglibconf.mak for more options
+PNGLIBCONF_H_PREBUILT = scripts/pnglibconf.h.prebuilt
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+	pngwtran.o pngmem.o pngerror.o pngpread.o
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -o $@ $<
+
+all: libpng.a pngtest
+
+pnglibconf.h: $(PNGLIBCONF_H_PREBUILT)
+	$(CP) $(PNGLIBCONF_H_PREBUILT) $@
+
+libpng.a: $(OBJS)
+	ar rc $@  $(OBJS)
+	$(RANLIB) $@
+
+pngtest: pngtest.o libpng.a
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
+
+test: pngtest
+	./pngtest
+
+install: libpng.a
+	-@mkdir $(DESTDIR)$(INCPATH)
+	-@mkdir $(DESTDIR)$(INCPATH)/libpng
+	-@mkdir $(DESTDIR)$(LIBPATH)
+	-@rm -f $(DESTDIR)$(INCPATH)/png.h
+	-@rm -f $(DESTDIR)$(INCPATH)/pngconf.h
+	-@rm -f $(DESTDIR)$(INCPATH)/pnglibconf.h
+	cp png.h $(DESTDIR)$(INCPATH)/libpng
+	cp pngconf.h $(DESTDIR)$(INCPATH)/libpng
+	cp pnglibconf.h $(DESTDIR)$(INCPATH)/libpng
+	chmod 644 $(DESTDIR)$(INCPATH)/libpng/png.h
+	chmod 644 $(DESTDIR)$(INCPATH)/libpng/pngconf.h
+	chmod 644 $(DESTDIR)$(INCPATH)/libpng/pnglibconf.h
+	(cd $(DESTDIR)$(INCPATH); ln -f -s libpng/* .)
+	cp libpng.a $(DESTDIR)$(LIBPATH)
+	chmod 644 $(DESTDIR)$(LIBPATH)/libpng.a
+
+clean:
+	rm -f *.o libpng.a pngtest pngout.png pnglibconf.h
+
+DOCS = ANNOUNCE CHANGES INSTALL KNOWNBUG LICENSE README TODO
+writelock:
+	chmod a-w *.[ch35] $(DOCS) scripts/*
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngerror.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrio.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwio.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngmem.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngset.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngget.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngread.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngpread.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngtrans.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwrite.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+
+pngtest.o: png.h pngconf.h pnglibconf.h
diff --git a/Engine/lib/lpng/scripts/makefile.msys b/Engine/lib/lpng/scripts/makefile.msys
new file mode 100644
index 000000000..6b9daf836
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.msys
@@ -0,0 +1,202 @@
+# makefile for libpng using MSYS/gcc (shared, static library)
+# Copyright (C) 2019 Cosmin Truta
+# Copyright (C) 2012 Glenn Randers-Pehrson and Christopher M. Wheeler
+#
+# Portions taken from makefile.linux and makefile.gcc:
+# Copyright (C) 2000 Cosmin Truta
+# Copyright (C) 1998, 1999, 2002, 2006, 2008, 2010-2014 Greg Roelofs and
+# Glenn Randers-Pehrson
+# Copyright (C) 1996, 1997 Andreas Dilger
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+# # # # # # # # # # # # # # # # #
+prefix=/usr/local
+exec_prefix=$(prefix)
+
+# Library name:
+LIBNAME = libpng16
+PNGMAJ = 16
+RELEASE = 37
+
+# Shared library names:
+LIBSO=$(LIBNAME).dll
+LIBSOMAJ=$(LIBNAME).dll.$(PNGMAJ)
+LIBSOREL=$(PNGMAJ).$(RELEASE)
+OLDSO=libpng.dll
+
+# Where the zlib library and include files are located.
+#ZLIBLIB=../zlib
+#ZLIBINC=../zlib
+ZLIBLIB=/usr/local/lib
+ZLIBINC=/usr/local/include
+
+# Compiler, linker, lib and other tools
+CC = gcc
+LD = $(CC)
+AR_RC = ar rcs
+RANLIB = ranlib
+CP = cp
+RM_F = rm -rf
+MKDIR_P=mkdir -p
+LN_SF=ln -sf
+
+#ARCH = -march=pentium3
+#ARCH = -march=i686
+ARCH =
+CPPFLAGS = # -DPNG_DEBUG=5
+CFLAGS = -W -Wall -O2 $(ARCH) # -g
+LDFLAGS =
+LIBS = -lz -lm
+
+# File extensions
+EXEEXT=.exe
+
+INCPATH=$(prefix)/include
+LIBPATH=$(exec_prefix)/lib
+MANPATH=$(prefix)/man
+BINPATH=$(exec_prefix)/bin
+
+# override DESTDIR= on the make install command line to easily support
+# installing into a temporary location.  Example:
+#
+#    make install DESTDIR=/tmp/build/libpng
+#
+# If you're going to install into a temporary location
+# via DESTDIR, $(DESTDIR)$(prefix) must already exist before
+# you execute make install.
+
+DESTDIR=
+
+DB=$(DESTDIR)$(BINPATH)
+DI=$(DESTDIR)$(INCPATH)
+DL=$(DESTDIR)$(LIBPATH)
+DM=$(DESTDIR)$(MANPATH)
+
+# Pre-built configuration
+# See scripts/pnglibconf.mak for more options
+PNGLIBCONF_H_PREBUILT = scripts/pnglibconf.h.prebuilt
+
+# Variables
+OBJS =  png.o pngerror.o pngget.o pngmem.o pngpread.o \
+	pngread.o pngrio.o pngrtran.o pngrutil.o pngset.o \
+	pngtrans.o pngwio.o pngwrite.o pngwtran.o pngwutil.o
+
+# Targets
+all: static shared
+
+pnglibconf.h: $(PNGLIBCONF_H_PREBUILT)
+	$(CP) $(PNGLIBCONF_H_PREBUILT) $@
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) $<
+
+static: libpng.a pngtest$(EXEEXT)
+
+shared: $(LIBSOMAJ)
+	$(CC) -shared -Wl,-soname,$(LIBSOMAJ) -o $(LIBSO)
+
+$(LIBSO): $(LIBSOMAJ)
+	$(LN_SF) $(LIBSOMAJ) $(LIBSO)
+
+$(LIBSOMAJ):
+	$(CC) -shared -Wl,-soname,$(LIBSOMAJ) -o $(LIBSOMAJ)
+
+libpng.a: $(OBJS)
+	$(AR_RC) $@ $(OBJS)
+	$(RANLIB) $@
+
+install-headers: png.h pngconf.h pnglibconf.h
+	-@if [ ! -d $(DI) ]; then $(MKDIR_P) $(DI); fi
+	-@if [ ! -d $(DI)/$(LIBNAME) ]; then $(MKDIR_P) $(DI)/$(LIBNAME); fi
+	cp png.h pngconf.h pnglibconf.h $(DI)/$(LIBNAME)
+	-@$(RM_F) $(DI)/png.h $(DI)/pngconf.h $(DI)/pnglibconf.h
+	-@$(RM_F) $(DI)/libpng
+	(cd $(DI); $(LN_SF) $(LIBNAME) libpng; $(LN_SF) $(LIBNAME)/* .)
+
+install-static: install-headers libpng.a
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	cp libpng.a $(DL)/$(LIBNAME).a
+	-@$(RM_F) $(DL)/libpng.a
+	(cd $(DL); $(LN_SF) $(LIBNAME).a libpng.a)
+
+libpng.pc:
+	cat scripts/libpng.pc.in | sed -e s!@prefix@!$(prefix)! \
+	-e s!@exec_prefix@!$(exec_prefix)! \
+	-e s!@libdir@!$(LIBPATH)! \
+	-e s!@includedir@!$(INCPATH)! \
+	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+
+libpng-config:
+	( cat scripts/libpng-config-head.in; \
+	echo prefix=\"$(prefix)\"; \
+	echo I_opts=\"-I$(INCPATH)/$(LIBNAME)\"; \
+	echo L_opts=\"-L$(LIBPATH)\"; \
+	echo R_opts=\"-Wl,-rpath,$(LIBPATH)\"; \
+	echo libs=\"-lpng16 -lz -lm\"; \
+	cat scripts/libpng-config-body.in ) > libpng-config
+
+install-shared: install-headers $(LIBSOMAJ) libpng.pc
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	-@$(RM_F) $(DL)/$(LIBSO)
+	-@$(RM_F) $(DL)/$(OLDSO)
+	cp $(LIBSO) $(DL)/$(LIBSOREL)
+	(cd $(DL); \
+	$(LN_SF) $(LIBSOREL) $(LIBSO); \
+	$(LN_SF) $(LIBSO) $(OLDSO))
+
+	-@if [ ! -d $(DL)/pkgconfig ]; then $(MKDIR_P) $(DL)/pkgconfig; fi
+	-@$(RM_F) $(DL)/pkgconfig/$(LIBNAME).pc
+	-@$(RM_F) $(DL)/pkgconfig/libpng.pc
+	cp libpng.pc $(DL)/pkgconfig/$(LIBNAME).pc
+	(cd $(DL)/pkgconfig; $(LN_SF) $(LIBNAME).pc libpng.pc)
+
+install-man: libpng.3 libpngpf.3 png.5
+	-@if [ ! -d $(DM) ]; then $(MKDIR_P) $(DM); fi
+	-@if [ ! -d $(DM)/man3 ]; then $(MKDIR_P) $(DM)/man3; fi
+	-@$(RM_F) $(DM)/man3/libpng.3
+	-@$(RM_F) $(DM)/man3/libpngpf.3
+	cp libpng.3 $(DM)/man3
+	cp libpngpf.3 $(DM)/man3
+	-@if [ ! -d $(DM)/man5 ]; then $(MKDIR_P) $(DM)/man5; fi
+	-@$(RM_F) $(DM)/man5/png.5
+	cp png.5 $(DM)/man5
+
+install-config: libpng-config
+	-@if [ ! -d $(DB) ]; then $(MKDIR_P) $(DB); fi
+	-@$(RM_F) $(DB)/libpng-config
+	-@$(RM_F) $(DB)/$(LIBNAME)-config
+	cp libpng-config $(DB)/$(LIBNAME)-config
+	(cd $(DB); $(LN_SF) $(LIBNAME)-config libpng-config)
+
+install: install-static install-shared install-man install-config
+
+test: pngtest$(EXEEXT)
+	./pngtest$(EXEEXT)
+
+pngtest$(EXEEXT): pngtest.o libpng.a
+	$(LD) $(LDFLAGS) -o $@ pngtest.o libpng.a $(LIBS)
+
+clean:
+	$(RM_F) *.o libpng.a pngtest$(EXEEXT) pngout.png pnglibconf.h $(LIBSO) \
+	$(LIBSOMAJ) libpng-config
+
+png.o:      png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngerror.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngget.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngmem.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngpread.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngread.o:  png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrio.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngset.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngtrans.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwio.o:   png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwrite.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+
+pngtest.o:  png.h pngconf.h pnglibconf.h
diff --git a/Engine/lib/lpng/scripts/makefile.netbsd b/Engine/lib/lpng/scripts/makefile.netbsd
new file mode 100644
index 000000000..9a6b04629
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.netbsd
@@ -0,0 +1,55 @@
+# makefile for libpng for NetBSD for the standard
+# make obj && make depend && make && make test
+# make includes && make install
+# Copyright (C) 2002 Patrick R.L. Welche
+# Copyright (C) 2007-2009, 2014 Glenn Randers-Pehrson
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+LOCALBASE?=/usr/local
+LIBDIR=	${LOCALBASE}/lib
+MANDIR= ${LOCALBASE}/man
+INCSDIR=${LOCALBASE}/include
+
+SHLIB_MAJOR=	16
+SHLIB_MINOR=	1.6.37
+
+LIB=	png
+SRCS=	png.c pngerror.c pngget.c pngmem.c pngpread.c \
+	pngread.c pngrio.c pngrtran.c pngrutil.c pngset.c pngtrans.c \
+	pngwio.c pngwrite.c pngwtran.c pngwutil.c
+INCS=	png.h pngconf.h pnglibconf.h
+MAN=	libpng.3 libpngpf.3 png.5
+
+CPPFLAGS+=-I${.CURDIR}
+
+# Pre-built configuration
+# See scripts/pnglibconf.mak for more options
+PNGLIBCONF_H_PREBUILT= scripts/pnglibconf.h.prebuilt
+
+# We should be able to do something like this instead of the manual
+# uncommenting, but it core dumps for me at the moment:
+# .if ${MACHINE_ARCH} == "i386"
+#   MKLINT= no
+# .endif
+
+CLEANFILES+=pngtest.o pngtest pnglibconf.h
+
+.c.o:
+	${CC} -c ${CPPFLAGS} ${CFLAGS} -o $@ $<
+
+pnglibconf.h: ${PNGLIBCONF_H_PREBUILT}
+	cp ${PNGLIBCONF_H_PREBUILT} $@
+
+pngtest.o:	pngtest.c
+	${CC} -c ${CPPFLAGS} ${CFLAGS} ${.ALLSRC} -o ${.TARGET}
+
+pngtest:	pngtest.o libpng.a
+	${CC} ${LDFLAGS} ${.ALLSRC} -o ${.TARGET} -lz -lm
+
+test:	pngtest
+	cd ${.CURDIR} && ${.OBJDIR}/pngtest
+
+.include <bsd.lib.mk>
diff --git a/Engine/lib/lpng/scripts/makefile.openbsd b/Engine/lib/lpng/scripts/makefile.openbsd
new file mode 100644
index 000000000..ad5ffb3a3
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.openbsd
@@ -0,0 +1,86 @@
+# makefile for libpng
+# Copyright (C) 2007-2009, 2014 Glenn Randers-Pehrson
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+PREFIX?= /usr/local
+LIBDIR=	${PREFIX}/lib
+MANDIR= ${PREFIX}/man/cat
+
+SHLIB_MAJOR=	16
+SHLIB_MINOR=	1.6.37
+
+LIB=	png
+SRCS=	png.c pngerror.c pngget.c pngmem.c pngpread.c \
+	pngread.c pngrio.c pngrtran.c pngrutil.c pngset.c pngtrans.c \
+	pngwio.c pngwrite.c pngwtran.c pngwutil.c
+HDRS=	png.h pngconf.h pnglibconf.h
+MAN=	libpng.3 libpngpf.3 png.5
+DOCS=	ANNOUNCE CHANGES INSTALL KNOWNBUG LICENSE README TODO \
+	libpng-manual.txt
+
+CFLAGS+= -W -Wall
+CPPFLAGS+= -I${.CURDIR}
+
+NOPROFILE= Yes
+
+CLEANFILES+= pngtest.o pngtest pnglibconf.h
+
+# Pre-built configuration
+# See scripts/pnglibconf.mak for more options
+PNGLIBCONF_H_PREBUILT= scripts/pnglibconf.h.prebuilt
+
+.c.o:
+	${CC} -c ${CPPFLAGS} ${CFLAGS} -o $@ $<
+
+pnglibconf.h: ${PNGLIBCONF_H_PREBUILT}
+	cp ${PNGLIBCONF_H_PREBUILT} $@
+
+pngtest.o:	pngtest.c
+	${CC} -c ${CPPFLAGS} ${CFLAGS} ${.ALLSRC} -o ${.TARGET}
+
+pngtest:	pngtest.o
+	${CC} ${LDFLAGS} ${.ALLSRC} -o ${.TARGET} -L${.OBJDIR} -lpng -lz -lm
+
+test:	pngtest
+	cd ${.OBJDIR} && env \
+		LD_LIBRARY_PATH="${.OBJDIR}" ${.OBJDIR}/pngtest
+
+beforeinstall:
+	if [ ! -d ${DESTDIR}${PREFIX}/include/libpng ]; then \
+	  ${INSTALL} -d -o root -g wheel ${DESTDIR}${PREFIX}/include; \
+	fi
+	if [ ! -d ${DESTDIR}${LIBDIR} ]; then \
+	  ${INSTALL} -d -o root -g wheel ${DESTDIR}${LIBDIR}; \
+	fi
+	if [ ! -d ${DESTDIR}${LIBDIR}/debug ]; then \
+	  ${INSTALL} -d -o root -g wheel ${DESTDIR}${LIBDIR}/debug; \
+	fi
+	if [ ! -d ${DESTDIR}${MANDIR}3 ]; then \
+	  ${INSTALL} -d -o root -g wheel ${DESTDIR}${MANDIR}3; \
+	fi
+	if [ ! -d ${DESTDIR}${MANDIR}5 ]; then \
+	  ${INSTALL} -d -o root -g wheel ${DESTDIR}${MANDIR}5; \
+	fi
+	if [ ! -d ${DESTDIR}${PREFIX}/share/doc/png ]; then \
+	  ${INSTALL} -d -o root -g wheel ${DESTDIR}${PREFIX}/share/doc/png; \
+	fi
+
+afterinstall:
+	@rm -f ${DESTDIR}${LIBDIR}/libpng_pic.a
+	@rm -f ${DESTDIR}${LIBDIR}/debug/libpng.a
+	@rm -f ${DESTDIR}${PREFIX}/include/png.h
+	@rm -f ${DESTDIR}${PREFIX}/include/pngconf.h
+	@rm -f ${DESTDIR}${PREFIX}/include/pnglibconf.h
+	@rmdir ${DESTDIR}${LIBDIR}/debug 2>/dev/null || true
+	${INSTALL} ${INSTALL_COPY} -o ${SHAREOWN} -g ${SHAREGRP} \
+		-m ${NONBINMODE} ${HDRS} ${DESTDIR}${PREFIX}/include
+	${INSTALL} ${INSTALL_COPY} -o ${SHAREOWN} -g ${SHAREGRP} \
+		-m ${NONBINMODE} ${HDRS} ${DESTDIR}${PREFIX}/include
+	${INSTALL} ${INSTALL_COPY} -o ${SHAREOWN} -g ${SHAREGRP} \
+		-m ${NONBINMODE} ${DOCS} ${DESTDIR}${PREFIX}/share/doc/png
+
+.include <bsd.lib.mk>
diff --git a/Engine/lib/lpng/scripts/makefile.sco b/Engine/lib/lpng/scripts/makefile.sco
new file mode 100644
index 000000000..01d7eaaaa
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.sco
@@ -0,0 +1,226 @@
+# makefile for SCO OSr5  ELF and Unixware 7 with Native cc
+# Contributed by Mike Hopkirk (hops at sco.com) modified from Makefile.lnx
+#   force ELF build dynamic linking, SONAME setting in lib and RPATH in app
+# Copyright (C) 2002, 2006, 2010-2014 Glenn Randers-Pehrson
+# Copyright (C) 1998 Greg Roelofs
+# Copyright (C) 1996, 1997 Andreas Dilger
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# Library name:
+LIBNAME = libpng16
+PNGMAJ = 16
+
+# Shared library names:
+LIBSO=$(LIBNAME).so
+LIBSOMAJ=$(LIBNAME).so.$(PNGMAJ)
+LIBSOREL=$(LIBSOMAJ).$(RELEASE)
+OLDSO=libpng.so
+
+# Utilities:
+CC=cc
+AR_RC=ar rc
+MKDIR_P=mkdir
+LN_SF=ln -f -s
+RANLIB=echo
+CP=cp
+RM_F=/bin/rm -f
+
+# where make install puts libpng.a, $(OLDSO)*, and png.h
+prefix=/usr/local
+exec_prefix=$(prefix)
+
+# Where the zlib library and include files are located
+#ZLIBLIB=/usr/local/lib
+#ZLIBINC=/usr/local/include
+ZLIBLIB=../zlib
+ZLIBINC=../zlib
+
+CPPFLAGS=-I$(ZLIBINC)
+CFLAGS= -dy -belf -O3
+LDFLAGS=-L. -L$(ZLIBLIB) -lpng16 -lz -lm
+
+INCPATH=$(prefix)/include
+LIBPATH=$(exec_prefix)/lib
+MANPATH=$(prefix)/man
+BINPATH=$(exec_prefix)/bin
+
+# override DESTDIR= on the make install command line to easily support
+# installing into a temporary location.  Example:
+#
+#    make install DESTDIR=/tmp/build/libpng
+#
+# If you're going to install into a temporary location
+# via DESTDIR, $(DESTDIR)$(prefix) must already exist before
+# you execute make install.
+DESTDIR=
+
+DB=$(DESTDIR)$(BINPATH)
+DI=$(DESTDIR)$(INCPATH)
+DL=$(DESTDIR)$(LIBPATH)
+DM=$(DESTDIR)$(MANPATH)
+
+# Pre-built configuration
+# See scripts/pnglibconf.mak for more options
+PNGLIBCONF_H_PREBUILT = scripts/pnglibconf.h.prebuilt
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+	pngwtran.o pngmem.o pngerror.o pngpread.o
+
+OBJSDLL = $(OBJS:.o=.pic.o)
+
+.SUFFIXES:      .c .o .pic.o
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -o $@ $<
+
+.c.pic.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -KPIC -o $@ $*.c
+
+all: libpng.a $(LIBSO) pngtest libpng.pc libpng-config
+
+pnglibconf.h: $(PNGLIBCONF_H_PREBUILT)
+	$(CP) $(PNGLIBCONF_H_PREBUILT) $@
+
+libpng.a: $(OBJS)
+	$(AR_RC) $@ $(OBJS)
+	$(RANLIB) $@
+
+libpng.pc:
+	cat scripts/libpng.pc.in | sed -e s!@prefix@!$(prefix)! \
+	-e s!@exec_prefix@!$(exec_prefix)! \
+	-e s!@libdir@!$(LIBPATH)! \
+	-e s!@includedir@!$(INCPATH)! \
+	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+
+libpng-config:
+	( cat scripts/libpng-config-head.in; \
+	echo prefix=\"$(prefix)\"; \
+	echo I_opts=\"-I$(INCPATH)/$(LIBNAME)\"; \
+	echo ccopts=\"-belf\"; \
+	echo L_opts=\"-L$(LIBPATH)\"; \
+	echo libs=\"-lpng16 -lz -lm\"; \
+	cat scripts/libpng-config-body.in ) > libpng-config
+	chmod +x libpng-config
+
+$(LIBSO): $(LIBSOMAJ)
+	$(LN_SF) $(LIBSOMAJ) $(LIBSO)
+
+$(LIBSOMAJ): $(OBJSDLL)
+	$(CC) -G  -Wl,-h,$(LIBSOMAJ) -o $(LIBSOMAJ) \
+	 $(OBJSDLL)
+
+pngtest: pngtest.o $(LIBSO)
+	LD_RUN_PATH=.:$(ZLIBLIB) $(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
+
+test: pngtest
+	./pngtest
+
+install-headers: png.h pngconf.h pnglibconf.h
+	-@if [ ! -d $(DI) ]; then $(MKDIR_P) $(DI); fi
+	-@if [ ! -d $(DI)/$(LIBNAME) ]; then $(MKDIR_P) $(DI)/$(LIBNAME); fi
+	-@$(RM_F) $(DI)/png.h
+	-@$(RM_F) $(DI)/pngconf.h
+	-@$(RM_F) $(DI)/pnglibconf.h
+	cp png.h pngconf.h pnglibconf.h $(DI)/$(LIBNAME)
+	chmod 644 $(DI)/$(LIBNAME)/png.h $(DI)/$(LIBNAME)/pngconf.h $(DI)/$(LIBNAME)/pnglibconf.h
+	-@$(RM_F) $(DI)/png.h $(DI)/pngconf.h $(DI)/pnglibconf.h
+	-@$(RM_F) $(DI)/libpng
+	(cd $(DI); $(LN_SF) $(LIBNAME) libpng; $(LN_SF) $(LIBNAME)/* .)
+
+install-static: install-headers libpng.a
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	cp libpng.a $(DL)/$(LIBNAME).a
+	chmod 644 $(DL)/$(LIBNAME).a
+	-@$(RM_F) $(DL)/libpng.a
+	(cd $(DL); $(LN_SF) $(LIBNAME).a libpng.a)
+
+install-shared: install-headers $(LIBSOMAJ) libpng.pc
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	-@$(RM_F) $(DL)/$(LIBSO)
+	-@$(RM_F) $(DL)/$(LIBSOREL)
+	-@$(RM_F) $(DL)/$(OLDSO)
+	cp $(LIBSOMAJ) $(DL)/$(LIBSOREL)
+	chmod 755 $(DL)/$(LIBSOREL)
+	(cd $(DL); \
+	$(LN_SF) $(LIBSOREL) $(LIBSO); \
+	$(LN_SF) $(LIBSO) $(OLDSO))
+	-@if [ ! -d $(DL)/pkgconfig ]; then $(MKDIR_P) $(DL)/pkgconfig; fi
+	-@$(RM_F) $(DL)/pkgconfig/$(LIBNAME).pc
+	-@$(RM_F) $(DL)/pkgconfig/libpng.pc
+	cp libpng.pc $(DL)/pkgconfig/$(LIBNAME).pc
+	chmod 644 $(DL)/pkgconfig/$(LIBNAME).pc
+	(cd $(DL)/pkgconfig; $(LN_SF) $(LIBNAME).pc libpng.pc)
+
+install-man: libpng.3 libpngpf.3 png.5
+	-@if [ ! -d $(DM) ]; then $(MKDIR_P) $(DM); fi
+	-@if [ ! -d $(DM)/man3 ]; then $(MKDIR_P) $(DM)/man3; fi
+	-@$(RM_F) $(DM)/man3/libpng.3
+	-@$(RM_F) $(DM)/man3/libpngpf.3
+	cp libpng.3 $(DM)/man3
+	cp libpngpf.3 $(DM)/man3
+	-@if [ ! -d $(DM)/man5 ]; then $(MKDIR_P) $(DM)/man5; fi
+	-@$(RM_F) $(DM)/man5/png.5
+	cp png.5 $(DM)/man5
+
+install-config: libpng-config
+	-@if [ ! -d $(DB) ]; then $(MKDIR_P) $(DB); fi
+	-@$(RM_F) $(DB)/libpng-config
+	-@$(RM_F) $(DB)/$(LIBNAME)-config
+	cp libpng-config $(DB)/$(LIBNAME)-config
+	chmod 755 $(DB)/$(LIBNAME)-config
+	(cd $(DB); $(LN_SF) $(LIBNAME)-config libpng-config)
+
+install: install-static install-shared install-man install-config
+
+# If you installed in $(DESTDIR), test-installed won't work until you
+# move the library to its final location.  Use test-dd to test it
+# before then.
+
+test-dd:
+	echo
+	echo Testing installed dynamic shared library in $(DL).
+	$(CC) -I$(DI) $(CPPFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -L$(DL) -L$(ZLIBLIB) \
+	   -o pngtestd `$(BINPATH)/$(LIBNAME)-config --ldflags`
+	./pngtestd pngtest.png
+
+test-installed:
+	$(CC) $(CPPFLAGS) $(CFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -L$(ZLIBLIB) \
+	   -o pngtesti `$(BINPATH)/$(LIBNAME)-config --ldflags`
+	./pngtesti pngtest.png
+
+clean:
+	$(RM_F) *.o libpng.a pngtest pngout.png libpng-config \
+	$(LIBSO) $(LIBSOMAJ)* pngtest-static pngtesti \
+	pnglibconf.h libpng.pc
+
+DOCS = ANNOUNCE CHANGES INSTALL KNOWNBUG LICENSE README TODO
+writelock:
+	chmod a-w *.[ch35] $(DOCS) scripts/*
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o png.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngerror.o pngerror.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrio.o pngrio.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwio.o pngwio.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngmem.o pngmem.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngset.o pngset.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngget.o pngget.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngread.o pngread.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrtran.o pngrtran.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrutil.o pngrutil.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngtrans.o pngtrans.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwrite.o pngwrite.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwtran.o pngwtran.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwutil.o pngwutil.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngpread.o pngpread.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+
+pngtest.o: png.h pngconf.h pnglibconf.h
diff --git a/Engine/lib/lpng/scripts/makefile.sggcc b/Engine/lib/lpng/scripts/makefile.sggcc
new file mode 100644
index 000000000..82efe7a22
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.sggcc
@@ -0,0 +1,236 @@
+# makefile for libpng.a and libpng16.so, SGI IRIX with 'cc'
+# Copyright (C) 2001-2002, 2006, 2010-2014 Glenn Randers-Pehrson
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# Library name:
+LIBNAME=libpng16
+PNGMAJ = 16
+
+# Shared library names:
+LIBSO=$(LIBNAME).so
+LIBSOMAJ=$(LIBNAME).so.$(PNGMAJ)
+LIBSOREL=$(LIBSOMAJ).$(RELEASE)
+OLDSO=libpng.so
+
+# Utilities:
+AR_RC=ar rc
+CC=gcc
+MKDIR_P=mkdir -p
+LN_SF=ln -sf
+RANLIB=echo
+CP=cp
+RM_F=/bin/rm -f
+
+# Where make install puts libpng.a, libpng16.so, and libpng16/png.h
+# Prefix must be a full pathname.
+
+prefix=/usr/local
+exec_prefix=$(prefix)
+
+# Where the zlib library and include files are located
+#ZLIBLIB=/usr/local/lib32
+#ZLIBINC=/usr/local/include
+#ZLIBLIB=/usr/local/lib
+#ZLIBINC=/usr/local/include
+ZLIBLIB=../zlib
+ZLIBINC=../zlib
+
+# ABI can be blank to use default for your system, -32, -o32, -n32, or -64
+# See "man abi".  zlib must be built with the same ABI.
+ABI=
+
+WARNMORE=
+CPPFLAGS=-I$(ZLIBINC) # -DPNG_DEBUG=5
+CFLAGS=$(ABI) -O $(WARNMORE) -fPIC -mabi=n32 # -g
+LDFLAGS=$(ABI) -L. -L$(ZLIBLIB) -lpng -lz -lm
+LDSHARED=cc $(ABI) -shared -soname $(LIBSOMAJ) \
+	-set_version sgi$(PNGMAJ).0
+# See "man dso" for info about shared objects
+
+INCPATH=$(prefix)/include
+LIBPATH=$(exec_prefix)/lib
+#LIBPATH=$(exec_prefix)/lib32
+MANPATH=$(prefix)/man
+BINPATH=$(exec_prefix)/bin
+
+# override DESTDIR= on the make install command line to easily support
+# installing into a temporary location.  Example:
+#
+#    make install DESTDIR=/tmp/build/libpng
+#
+# If you're going to install into a temporary location
+# via DESTDIR, $(DESTDIR)$(prefix) must already exist before
+# you execute make install.
+DESTDIR=
+
+DB=$(DESTDIR)$(BINPATH)
+DI=$(DESTDIR)$(INCPATH)
+DL=$(DESTDIR)$(LIBPATH)
+DM=$(DESTDIR)$(MANPATH)
+
+# Pre-built configuration
+# See scripts/pnglibconf.mak for more options
+PNGLIBCONF_H_PREBUILT = scripts/pnglibconf.h.prebuilt
+
+OBJS =  png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+	pngwtran.o pngmem.o pngerror.o pngpread.o
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -o $@ $<
+
+all: libpng.a pngtest shared libpng.pc libpng-config
+
+pnglibconf.h: $(PNGLIBCONF_H_PREBUILT)
+	$(CP) $(PNGLIBCONF_H_PREBUILT) $@
+
+libpng.a: $(OBJS)
+	$(AR_RC) $@ $(OBJS)
+	$(RANLIB) $@
+
+shared: $(LIBSOMAJ)
+
+libpng.pc:
+	cat scripts/libpng.pc.in | sed -e s!@prefix@!$(prefix)! \
+	-e s!@exec_prefix@!$(exec_prefix)! \
+	-e s!@libdir@!$(LIBPATH)! \
+	-e s!@includedir@!$(INCPATH)! \
+	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+
+libpng-config:
+	( cat scripts/libpng-config-head.in; \
+	echo prefix=\"$(prefix)\"; \
+	echo I_opts=\"-I$(INCPATH)/$(LIBNAME)\"; \
+	echo ccopts=\"$(ABI)\"; \
+	echo cppflags=\"\"; \
+	echo ldopts=\"$(ABI)\"; \
+	echo L_opts=\"-L$(LIBPATH)\"; \
+	echo libdir=\"$(LIBPATH)\"; \
+	echo libs=\"-lpng16 -lz -lm\"; \
+	cat scripts/libpng-config-body.in ) > libpng-config
+	chmod +x libpng-config
+
+$(LIBSO): $(LIBSOMAJ)
+	$(LN_SF) $(LIBSOMAJ) $(LIBSO)
+
+$(LIBSOMAJ): $(OBJS)
+	$(LDSHARED) -o $@ $(OBJS)
+	$(RM_F) $(LIBSO) $(LIBSOMAJ)
+
+pngtest: pngtest.o libpng.a
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
+
+test: pngtest
+	echo
+	echo Testing local static library.
+	./pngtest
+
+install-headers: png.h pngconf.h pnglibconf.h
+	-@if [ ! -d $(DI) ]; then $(MKDIR_P) $(DI); fi
+	-@if [ ! -d $(DI)/$(LIBNAME) ]; then $(MKDIR_P) $(DI)/$(LIBNAME); fi
+	cp png.h pngconf.h pnglibconf.h $(DI)/$(LIBNAME)
+	chmod 644 $(DI)/$(LIBNAME)/png.h $(DI)/$(LIBNAME)/pngconf.h $(DI)/$(LIBNAME)/pnglibconf.h
+	-@$(RM_F) $(DI)/png.h $(DI)/pngconf.h $(DI)/pnglibconf.h
+	-@$(RM_F) $(DI)/libpng
+	(cd $(DI); $(LN_SF) $(LIBNAME) libpng; $(LN_SF) $(LIBNAME)/* .)
+
+install-static: install-headers libpng.a
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	cp libpng.a $(DL)/$(LIBNAME).a
+	chmod 644 $(DL)/$(LIBNAME).a
+	-@$(RM_F) $(DL)/libpng.a
+	(cd $(DL); $(LN_SF) $(LIBNAME).a libpng.a)
+
+install-shared: install-headers $(LIBSOMAJ) libpng.pc
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	-@$(RM_F) $(DL)/$(LIBSO)
+	-@$(RM_F) $(DL)/$(LIBSOREL)
+	-@$(RM_F) $(DL)/$(OLDSO)
+	cp $(LIBSOMAJ) $(DL)/$(LIBSOREL)
+	chmod 755 $(DL)/$(LIBSOREL)
+	(cd $(DL); \
+	$(LN_SF) $(LIBSOREL) $(LIBSO); \
+	$(LN_SF) $(LIBSO) $(OLDSO))
+	-@if [ ! -d $(DL)/pkgconfig ]; then $(MKDIR_P) $(DL)/pkgconfig; fi
+	-@$(RM_F) $(DL)/pkgconfig/$(LIBNAME).pc
+	-@$(RM_F) $(DL)/pkgconfig/libpng.pc
+	cp libpng.pc $(DL)/pkgconfig/$(LIBNAME).pc
+	chmod 644 $(DL)/pkgconfig/$(LIBNAME).pc
+	(cd $(DL)/pkgconfig; $(LN_SF) $(LIBNAME).pc libpng.pc)
+
+install-man: libpng.3 libpngpf.3 png.5
+	-@if [ ! -d $(DM) ]; then $(MKDIR_P) $(DM); fi
+	-@if [ ! -d $(DM)/man3 ]; then $(MKDIR_P) $(DM)/man3; fi
+	-@$(RM_F) $(DM)/man3/libpng.3
+	-@$(RM_F) $(DM)/man3/libpngpf.3
+	cp libpng.3 $(DM)/man3
+	cp libpngpf.3 $(DM)/man3
+	-@if [ ! -d $(DM)/man5 ]; then $(MKDIR_P) $(DM)/man5; fi
+	-@$(RM_F) $(DM)/man5/png.5
+	cp png.5 $(DM)/man5
+
+install-config: libpng-config
+	-@if [ ! -d $(DB) ]; then $(MKDIR_P) $(DB); fi
+	-@$(RM_F) $(DB)/libpng-config
+	-@$(RM_F) $(DB)/$(LIBNAME)-config
+	cp libpng-config $(DB)/$(LIBNAME)-config
+	chmod 755 $(DB)/$(LIBNAME)-config
+	(cd $(DB); $(LN_SF) $(LIBNAME)-config libpng-config)
+
+install: install-static install-shared install-man install-config
+
+# If you installed in $(DESTDIR), test-installed won't work until you
+# move the library to its final location.  Use test-dd to test it
+# before then.
+
+test-dd:
+	echo
+	echo Testing installed dynamic shared library in $(DL).
+	$(CC) -I$(DI) $(CPPFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -L$(DL) -L$(ZLIBLIB) \
+	   -rpath $(ZLIBLIB):$(DL) \
+	   -o pngtestd `$(BINPATH)/$(LIBNAME)-config --ldflags`
+	./pngtestd pngtest.png
+
+test-installed:
+	echo
+	echo Testing installed dynamic shared library.
+	$(CC) $(CPPFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -L$(ZLIBLIB) \
+	   -rpath $(ZLIBLIB):`$(BINPATH)/$(LIBNAME)-config --libdir` \
+	   -o pngtesti `$(BINPATH)/$(LIBNAME)-config --ldflags`
+	./pngtesti pngtest.png
+
+clean:
+	$(RM_F) libpng.a pngtest pngtesti pngout.png libpng.pc \
+	so_locations libpng-config $(LIBSO) $(LIBSOMAJ)* pnglibconf.h
+
+DOCS = ANNOUNCE CHANGES INSTALL KNOWNBUG LICENSE README TODO
+writelock:
+	chmod a-w *.[ch35] $(DOCS) scripts/*
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngerror.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrio.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwio.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngmem.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngset.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngget.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngread.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngtrans.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwrite.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngpread.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+
+pngtest.o: png.h pngconf.h pnglibconf.h
diff --git a/Engine/lib/lpng/scripts/makefile.sgi b/Engine/lib/lpng/scripts/makefile.sgi
new file mode 100644
index 000000000..5d9c23fa9
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.sgi
@@ -0,0 +1,237 @@
+# makefile for libpng.a and libpng16.so, SGI IRIX with 'cc'
+# Copyright (C) 2001-2002, 2006, 2007, 2010-2014 Glenn Randers-Pehrson
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# Library name:
+LIBNAME=libpng16
+PNGMAJ = 16
+
+# Shared library names:
+LIBSO=$(LIBNAME).so
+LIBSOMAJ=$(LIBNAME).so.$(PNGMAJ)
+LIBSOREL=$(LIBSOMAJ).$(RELEASE)
+OLDSO=libpng.so
+
+# Utilities:
+AR_RC=ar rc
+CC=cc
+MKDIR_P=mkdir -p
+LN_SF=ln -sf
+RANLIB=echo
+CP=cp
+RM_F=/bin/rm -f
+
+# Where make install puts libpng.a, libpng16.so, and libpng16/png.h
+# Prefix must be a full pathname.
+
+prefix=/usr/local
+exec_prefix=$(prefix)
+
+# Where the zlib library and include files are located
+#ZLIBLIB=/usr/local/lib32
+#ZLIBINC=/usr/local/include
+#ZLIBLIB=/usr/local/lib
+#ZLIBINC=/usr/local/include
+ZLIBLIB=../zlib
+ZLIBINC=../zlib
+
+# ABI can be blank to use default for your system, -32, -o32, -n32, or -64
+# See "man abi".  zlib must be built with the same ABI.
+ABI=
+
+WARNMORE=-fullwarn
+# Note: -KPIC is the default anyhow
+CPPFLAGS=-I$(ZLIBINC) # -DPNG_DEBUG=5
+#CFLAGS= $(ABI) -O $(WARNMORE) -KPIC # -g
+CFLAGS=$(ABI) -O $(WARNMORE)
+LDFLAGS_A=$(ABI) -L. -L$(ZLIBLIB) -lpng16 -lz -lm
+LDFLAGS=$(ABI) -L. -L$(ZLIBLIB) -lpng -lz -lm
+LDSHARED=cc $(ABI) -shared -soname $(LIBSOMAJ) \
+	-set_version sgi$(PNGMAJ).0
+# See "man dso" for info about shared objects
+
+INCPATH=$(prefix)/include
+LIBPATH=$(exec_prefix)/lib
+#LIBPATH=$(exec_prefix)/lib32
+MANPATH=$(prefix)/man
+BINPATH=$(exec_prefix)/bin
+
+# override DESTDIR= on the make install command line to easily support
+# installing into a temporary location.  Example:
+#
+#    make install DESTDIR=/tmp/build/libpng
+#
+# If you're going to install into a temporary location
+# via DESTDIR, $(DESTDIR)$(prefix) must already exist before
+# you execute make install.
+DESTDIR=
+
+DB=$(DESTDIR)$(BINPATH)
+DI=$(DESTDIR)$(INCPATH)
+DL=$(DESTDIR)$(LIBPATH)
+DM=$(DESTDIR)$(MANPATH)
+
+# Pre-built configuration
+# See scripts/pnglibconf.mak for more options
+PNGLIBCONF_H_PREBUILT = scripts/pnglibconf.h.prebuilt
+
+OBJS =  png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+	pngwtran.o pngmem.o pngerror.o pngpread.o
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -o $@ $<
+
+all: libpng.a pngtest shared libpng.pc libpng-config
+
+pnglibconf.h: $(PNGLIBCONF_H_PREBUILT)
+	$(CP) $(PNGLIBCONF_H_PREBUILT) $@
+
+libpng.a: $(OBJS)
+	$(AR_RC) $@ $(OBJS)
+	$(RANLIB) $@
+
+libpng.pc:
+	cat scripts/libpng.pc.in | sed -e s!@prefix@!$(prefix)! \
+	-e s!@exec_prefix@!$(exec_prefix)! \
+	-e s!@libdir@!$(LIBPATH)! \
+	-e s!@includedir@!$(INCPATH)! \
+	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+
+libpng-config:
+	( cat scripts/libpng-config-head.in; \
+	echo prefix=\"$(prefix)\"; \
+	echo I_opts=\"-I$(INCPATH)/$(LIBNAME)\"; \
+	echo ccopts=\"$(ABI)\"; \
+	echo ldopts=\"$(ABI)\"; \
+	echo L_opts=\"-L$(LIBPATH)\"; \
+	echo libdir=\"$(LIBPATH)\"; \
+	echo libs=\"-lpng16 -lz -lm\"; \
+	cat scripts/libpng-config-body.in ) > libpng-config
+	chmod +x libpng-config
+
+$(LIBSO): $(LIBSOMAJ)
+	$(LN_SF) $(LIBSOMAJ) $(LIBSO)
+
+$(LIBSOMAJ): $(OBJS)
+	$(LDSHARED) -o $@ $(OBJS)
+	$(RM_F) $(LIBSO) $(LIBSOMAJ)
+
+pngtest: pngtest.o libpng.a
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
+
+test: pngtest
+	echo
+	echo Testing local static library.
+	./pngtest
+
+install-headers: png.h pngconf.h pnglibconf.h
+	-@if [ ! -d $(DI) ]; then $(MKDIR_P) $(DI); fi
+	-@if [ ! -d $(DI)/$(LIBNAME) ]; then $(MKDIR_P) $(DI)/$(LIBNAME); fi
+	cp png.h pngconf.h pnglibconf.h $(DI)/$(LIBNAME)
+	chmod 644 $(DI)/$(LIBNAME)/png.h $(DI)/$(LIBNAME)/pngconf.h $(DI)/$(LIBNAME)/pnglibconf.h
+	-@$(RM_F) $(DI)/png.h $(DI)/pngconf.h $(DI)/pnglibconf.h
+	-@$(RM_F) $(DI)/libpng
+	(cd $(DI); $(LN_SF) $(LIBNAME) libpng; $(LN_SF) $(LIBNAME)/* .)
+
+install-static: install-headers libpng.a
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	cp libpng.a $(DL)/$(LIBNAME).a
+	chmod 644 $(DL)/$(LIBNAME).a
+	-@$(RM_F) $(DL)/libpng.a
+	(cd $(DL); $(LN_SF) $(LIBNAME).a libpng.a)
+
+install-shared: install-headers $(LIBSOMAJ) libpng.pc
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	-@$(RM_F) $(DL)/$(LIBSO)
+	-@$(RM_F) $(DL)/$(LIBSOREL)
+	-@$(RM_F) $(DL)/$(OLDSO)
+	cp $(LIBSOMAJ) $(DL)/$(LIBSOREL)
+	chmod 755 $(DL)/$(LIBSOREL)
+	(cd $(DL); \
+	$(LN_SF) $(LIBSOREL) $(LIBSO); \
+	$(LN_SF) $(LIBSO) $(OLDSO))
+	-@if [ ! -d $(DL)/pkgconfig ]; then $(MKDIR_P) $(DL)/pkgconfig; fi
+	-@$(RM_F) $(DL)/pkgconfig/$(LIBNAME).pc
+	-@$(RM_F) $(DL)/pkgconfig/libpng.pc
+	cp libpng.pc $(DL)/pkgconfig/$(LIBNAME).pc
+	chmod 644 $(DL)/pkgconfig/$(LIBNAME).pc
+	(cd $(DL)/pkgconfig; $(LN_SF) $(LIBNAME).pc libpng.pc)
+
+install-man: libpng.3 libpngpf.3 png.5
+	-@if [ ! -d $(DM) ]; then $(MKDIR_P) $(DM); fi
+	-@if [ ! -d $(DM)/man3 ]; then $(MKDIR_P) $(DM)/man3; fi
+	-@$(RM_F) $(DM)/man3/libpng.3
+	-@$(RM_F) $(DM)/man3/libpngpf.3
+	cp libpng.3 $(DM)/man3
+	cp libpngpf.3 $(DM)/man3
+	-@if [ ! -d $(DM)/man5 ]; then $(MKDIR_P) $(DM)/man5; fi
+	-@$(RM_F) $(DM)/man5/png.5
+	cp png.5 $(DM)/man5
+
+install-config: libpng-config
+	-@if [ ! -d $(DB) ]; then $(MKDIR_P) $(DB); fi
+	-@$(RM_F) $(DB)/libpng-config
+	-@$(RM_F) $(DB)/$(LIBNAME)-config
+	cp libpng-config $(DB)/$(LIBNAME)-config
+	chmod 755 $(DB)/$(LIBNAME)-config
+	(cd $(DB); $(LN_SF) $(LIBNAME)-config libpng-config)
+
+install: install-static install-shared install-man install-config
+
+# If you installed in $(DESTDIR), test-installed won't work until you
+# move the library to its final location.  Use test-dd to test it
+# before then.
+
+test-dd:
+	echo
+	echo Testing installed dynamic shared library in $(DL).
+	$(CC) -I$(DI) $(CPPFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -L$(DL) -L$(ZLIBLIB) \
+	   -rpath $(ZLIBLIB):$(DL) \
+	   -o pngtestd `$(BINPATH)/$(LIBNAME)-config --ldflags`
+	./pngtestd pngtest.png
+
+test-installed:
+	echo
+	echo Testing installed dynamic shared library.
+	$(CC) $(CPPFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -L$(ZLIBLIB) \
+	   -rpath $(ZLIBLIB):`$(BINPATH)/$(LIBNAME)-config --libdir` \
+	   -o pngtesti `$(BINPATH)/$(LIBNAME)-config --ldflags`
+	./pngtesti pngtest.png
+
+clean:
+	$(RM_F) *.o libpng.a pngtest pngtesti pngout.png libpng.pc libpng-config \
+	$(LIBSO) $(LIBSOMAJ)* \
+	so_locations pnglibconf.h
+
+DOCS = ANNOUNCE CHANGES INSTALL KNOWNBUG LICENSE README TODO
+writelock:
+	chmod a-w *.[ch35] $(DOCS) scripts/*
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngerror.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrio.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwio.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngmem.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngset.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngget.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngread.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngtrans.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwrite.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngpread.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+
+pngtest.o: png.h pngconf.h pnglibconf.h
diff --git a/Engine/lib/lpng/scripts/makefile.so9 b/Engine/lib/lpng/scripts/makefile.so9
new file mode 100644
index 000000000..93166f30e
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.so9
@@ -0,0 +1,247 @@
+# makefile for libpng on Solaris 9 (beta) with Forte cc
+# Updated by Chad Schrock for Solaris 9
+# Contributed by William L. Sebok, based on makefile.linux
+# Copyright (C) 2002, 2006, 2008, 2010-2014 Glenn Randers-Pehrson
+# Copyright (C) 1998-2001 Greg Roelofs
+# Copyright (C) 1996-1997 Andreas Dilger
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# Library name:
+PNGMAJ = 16
+LIBNAME = libpng16
+
+# Shared library names:
+LIBSO=$(LIBNAME).so
+LIBSOMAJ=$(LIBNAME).so.$(PNGMAJ)
+LIBSOREL=$(LIBSOMAJ).$(RELEASE)
+OLDSO=libpng.so
+
+# Utilities:
+# gcc 2.95 doesn't work.
+CC=cc
+AR_RC=ar rc
+MKDIR_P=mkdir -p
+LN_SF=ln -f -s
+RANLIB=echo
+CP=cp
+RM_F=/bin/rm -f
+
+# Where make install puts libpng.a, $(OLDSO)*, and png.h
+prefix=/usr/local
+exec_prefix=$(prefix)
+
+# Where the zlib library and include files are located
+# Changing these to ../zlib poses a security risk.  If you want
+# to have zlib in an adjacent directory, specify the full path instead of "..".
+#ZLIBLIB=../zlib
+#ZLIBINC=../zlib
+#ZLIBLIB=/usr/local/lib
+#ZLIBINC=/usr/local/include
+#Use the preinstalled zlib that comes with Solaris 9:
+ZLIBLIB=/usr/lib
+ZLIBINC=/usr/include
+
+#WARNMORE=-Wwrite-strings -Wpointer-arith -Wshadow \
+	-Wmissing-declarations -Wtraditional -Wcast-align \
+	-Wstrict-prototypes -Wmissing-prototypes #-Wconversion
+CPPFLAGS=-I$(ZLIBINC) # -DPNG_DEBUG=5
+#CFLAGS=-W -Wall -O3 $(WARNMORE) -g
+CFLAGS=-O3
+LDFLAGS=-L. -R. -L$(ZLIBLIB) -R$(ZLIBLIB) -lpng16 -lz -lm
+
+INCPATH=$(prefix)/include
+LIBPATH=$(exec_prefix)/lib
+MANPATH=$(prefix)/man
+BINPATH=$(exec_prefix)/bin
+
+# override DESTDIR= on the make install command line to easily support
+# installing into a temporary location.  Example:
+#
+#    make install DESTDIR=/tmp/build/libpng
+#
+# If you're going to install into a temporary location
+# via DESTDIR, $(DESTDIR)$(prefix) must already exist before
+# you execute make install.
+DESTDIR=
+
+DB=$(DESTDIR)$(BINPATH)
+DI=$(DESTDIR)$(INCPATH)
+DL=$(DESTDIR)$(LIBPATH)
+DM=$(DESTDIR)$(MANPATH)
+
+# Pre-built configuration
+# See scripts/pnglibconf.mak for more options
+PNGLIBCONF_H_PREBUILT = scripts/pnglibconf.h.prebuilt
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+	pngwtran.o pngmem.o pngerror.o pngpread.o
+
+OBJSDLL = $(OBJS:.o=.pic.o)
+
+.SUFFIXES:      .c .o .pic.o
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -o $@ $<
+
+.c.pic.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -KPIC -o $@ $*.c
+
+all: libpng.a $(LIBSO) pngtest libpng.pc libpng-config
+
+pnglibconf.h: $(PNGLIBCONF_H_PREBUILT)
+	$(CP) $(PNGLIBCONF_H_PREBUILT) $@
+
+libpng.a: $(OBJS)
+	$(AR_RC) $@ $(OBJS)
+	$(RANLIB) $@
+
+libpng.pc:
+	cat scripts/libpng.pc.in | sed -e s!@prefix@!$(prefix)! \
+	-e s!@exec_prefix@!$(exec_prefix)! \
+	-e s!@libdir@!$(LIBPATH)! \
+	-e s!@includedir@!$(INCPATH)! \
+	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+
+libpng-config:
+	( cat scripts/libpng-config-head.in; \
+	echo prefix=\"$(prefix)\"; \
+	echo I_opts=\"-I$(INCPATH)/$(LIBNAME)\"; \
+	echo L_opts=\"-L$(LIBPATH)\"; \
+	echo R_opts=\"-R$(LIBPATH)\"; \
+	echo libs=\"-lpng16 -lz -lm\"; \
+	cat scripts/libpng-config-body.in ) > libpng-config
+	chmod +x libpng-config
+
+$(LIBSO): $(LIBSOMAJ)
+	$(LN_SF) $(LIBSOMAJ) $(LIBSO)
+
+$(LIBSOMAJ): $(OBJSDLL)
+	@case "`type ld`" in *ucb*) \
+	echo; \
+	echo '## WARNING:'; \
+	echo '## The commands "CC" and "LD" must NOT refer to /usr/ucb/cc'; \
+	echo '## and /usr/ucb/ld.  If they do, you need to adjust your PATH'; \
+	echo '## environment variable to put /usr/ccs/bin ahead of /usr/ucb.'; \
+	echo '## The environment variable LD_LIBRARY_PATH should not be set'; \
+	echo '## at all.  If it is, things are likely to break because of'; \
+	echo '## the libucb dependency that is created.'; \
+	echo; \
+	;; \
+	esac
+	$(LD) -G -h $(LIBSOMAJ) \
+	 -o $(LIBSOMAJ) $(OBJSDLL)
+
+pngtest: pngtest.o $(LIBSO)
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
+
+test: pngtest
+	./pngtest
+
+install-headers: png.h pngconf.h pnglibconf.h
+	-@if [ ! -d $(DI) ]; then $(MKDIR_P) $(DI); fi
+	-@if [ ! -d $(DI)/$(LIBNAME) ]; then $(MKDIR_P) $(DI)/$(LIBNAME); fi
+	cp png.h pngconf.h pnglibconf.h $(DI)/$(LIBNAME)
+	chmod 644 $(DI)/$(LIBNAME)/png.h $(DI)/$(LIBNAME)/pngconf.h $(DI)/$(LIBNAME)/pnglibconf.h
+	-@$(RM_F) $(DI)/png.h $(DI)/pngconf.h $(DI)/pnglibconf.h
+	-@$(RM_F) $(DI)/libpng
+	(cd $(DI); $(LN_SF) $(LIBNAME) libpng; $(LN_SF) $(LIBNAME)/* .)
+
+install-static: install-headers libpng.a
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	cp libpng.a $(DL)/$(LIBNAME).a
+	chmod 644 $(DL)/$(LIBNAME).a
+	-@$(RM_F) $(DL)/libpng.a
+	(cd $(DL); $(LN_SF) $(LIBNAME).a libpng.a)
+
+install-shared: install-headers $(LIBSOMAJ) libpng.pc
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	-@$(RM_F) $(DL)/$(LIBSO)
+	-@$(RM_F) $(DL)/$(LIBSOREL)
+	-@$(RM_F) $(DL)/$(OLDSO)
+	cp $(LIBSOMAJ) $(DL)/$(LIBSOREL)
+	chmod 755 $(DL)/$(LIBSOREL)
+	(cd $(DL); \
+	$(LN_SF) $(LIBSOREL) $(LIBSO); \
+	$(LN_SF) $(LIBSO) $(OLDSO))
+	-@if [ ! -d $(DL)/pkgconfig ]; then $(MKDIR_P) $(DL)/pkgconfig; fi
+	-@$(RM_F) $(DL)/pkgconfig/$(LIBNAME).pc
+	-@$(RM_F) $(DL)/pkgconfig/libpng.pc
+	cp libpng.pc $(DL)/pkgconfig/$(LIBNAME).pc
+	chmod 644 $(DL)/pkgconfig/$(LIBNAME).pc
+	(cd $(DL)/pkgconfig; $(LN_SF) $(LIBNAME).pc libpng.pc)
+
+install-man: libpng.3 libpngpf.3 png.5
+	-@if [ ! -d $(DM) ]; then $(MKDIR_P) $(DM); fi
+	-@if [ ! -d $(DM)/man3 ]; then $(MKDIR_P) $(DM)/man3; fi
+	-@$(RM_F) $(DM)/man3/libpng.3
+	-@$(RM_F) $(DM)/man3/libpngpf.3
+	cp libpng.3 $(DM)/man3
+	cp libpngpf.3 $(DM)/man3
+	-@if [ ! -d $(DM)/man5 ]; then $(MKDIR_P) $(DM)/man5; fi
+	-@$(RM_F) $(DM)/man5/png.5
+	cp png.5 $(DM)/man5
+
+install-config: libpng-config
+	-@if [ ! -d $(DB) ]; then $(MKDIR_P) $(DB); fi
+	-@$(RM_F) $(DB)/libpng-config
+	-@$(RM_F) $(DB)/$(LIBNAME)-config
+	cp libpng-config $(DB)/$(LIBNAME)-config
+	chmod 755 $(DB)/$(LIBNAME)-config
+	(cd $(DB); $(LN_SF) $(LIBNAME)-config libpng-config)
+
+install: install-static install-shared install-man install-config
+
+# If you installed in $(DESTDIR), test-installed won't work until you
+# move the library to its final location.  Use test-dd to test it
+# before then.
+
+test-dd:
+	echo
+	echo Testing installed dynamic shared library in $(DL).
+	$(CC) -I$(DI) $(CPPFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -o pngtestd `$(BINPATH)/$(LIBNAME)-config --ldflags` \
+	   -L$(DL) -L$(ZLIBLIB)  -R$(ZLIBLIB) -R$(DL)
+	./pngtestd pngtest.png
+
+test-installed:
+	echo
+	echo Testing installed dynamic shared library.
+	$(CC) $(CPPFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -o pngtesti `$(BINPATH)/$(LIBNAME)-config --ldflags` \
+	   -L$(ZLIBLIB) -R$(ZLIBLIB)
+	./pngtesti pngtest.png
+
+clean:
+	$(RM_F) *.o libpng.a pngtest pngtesti pngout.png \
+	libpng-config $(LIBSO) $(LIBSOMAJ)* \
+	libpng.pc pnglibconf.h
+
+DOCS = ANNOUNCE CHANGES INSTALL KNOWNBUG LICENSE README TODO
+writelock:
+	chmod a-w *.[ch35] $(DOCS) scripts/*
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o png.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngerror.o pngerror.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrio.o pngrio.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwio.o pngwio.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngmem.o pngmem.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngset.o pngset.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngget.o pngget.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngread.o pngread.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrtran.o pngrtran.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrutil.o pngrutil.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngtrans.o pngtrans.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwrite.o pngwrite.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwtran.o pngwtran.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwutil.o pngwutil.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngpread.o pngpread.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+
+pngtest.o: png.h pngconf.h pnglibconf.h
diff --git a/Engine/lib/lpng/scripts/makefile.solaris b/Engine/lib/lpng/scripts/makefile.solaris
new file mode 100644
index 000000000..f6d7b5860
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.solaris
@@ -0,0 +1,243 @@
+# makefile for libpng on Solaris 2.x with gcc
+# Copyright (C) 2004, 2006-2008, 2010-2014 Glenn Randers-Pehrson
+# Contributed by William L. Sebok, based on makefile.linux
+# Copyright (C) 1998 Greg Roelofs
+# Copyright (C) 1996, 1997 Andreas Dilger
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# Library name:
+LIBNAME = libpng16
+PNGMAJ = 16
+
+# Shared library names:
+LIBSO=$(LIBNAME).so
+LIBSOMAJ=$(LIBNAME).so.$(PNGMAJ)
+LIBSOREL=$(LIBSOMAJ).$(RELEASE)
+OLDSO=libpng.so
+
+# Utilities:
+AR_RC=ar rc
+CC=gcc
+MKDIR_P=mkdir -p
+LN_SF=ln -f -s
+RANLIB=echo
+CP=cp
+RM_F=/bin/rm -f
+
+# Where make install puts libpng.a, libpng16.so*, and png.h
+prefix=/usr/local
+exec_prefix=$(prefix)
+
+# Where the zlib library and include files are located
+# Changing these to ../zlib poses a security risk.  If you want
+# to have zlib in an adjacent directory, specify the full path instead of "..".
+#ZLIBLIB=../zlib
+#ZLIBINC=../zlib
+
+ZLIBLIB=/usr/local/lib
+ZLIBINC=/usr/local/include
+
+WARNMORE=-Wwrite-strings -Wpointer-arith -Wshadow \
+	-Wmissing-declarations -Wtraditional -Wcast-align \
+	-Wstrict-prototypes -Wmissing-prototypes #-Wconversion
+CPPFLAGS=-I$(ZLIBINC) # -DPNG_DEBUG=5
+CFLAGS=-W -Wall -O # $(WARNMORE) -g
+LDFLAGS=-L. -R. -L$(ZLIBLIB) -R$(ZLIBLIB) -lpng16 -lz -lm
+
+INCPATH=$(prefix)/include
+LIBPATH=$(exec_prefix)/lib
+MANPATH=$(prefix)/man
+BINPATH=$(exec_prefix)/bin
+
+# override DESTDIR= on the make install command line to easily support
+# installing into a temporary location.  Example:
+#
+#    make install DESTDIR=/tmp/build/libpng
+#
+# If you're going to install into a temporary location
+# via DESTDIR, $(DESTDIR)$(prefix) must already exist before
+# you execute make install.
+DESTDIR=
+
+DB=$(DESTDIR)$(BINPATH)
+DI=$(DESTDIR)$(INCPATH)
+DL=$(DESTDIR)$(LIBPATH)
+DM=$(DESTDIR)$(MANPATH)
+
+# Pre-built configuration
+# See scripts/pnglibconf.mak for more options
+PNGLIBCONF_H_PREBUILT = scripts/pnglibconf.h.prebuilt
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+	pngwtran.o pngmem.o pngerror.o pngpread.o
+
+OBJSDLL = $(OBJS:.o=.pic.o)
+
+.SUFFIXES:      .c .o .pic.o
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -o $@ $<
+
+.c.pic.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -fPIC -o $@ $*.c
+
+all: libpng.a $(LIBSO) pngtest libpng.pc libpng-config
+
+pnglibconf.h: $(PNGLIBCONF_H_PREBUILT)
+	$(CP) $(PNGLIBCONF_H_PREBUILT) $@
+
+libpng.a: $(OBJS)
+	$(AR_RC) $@ $(OBJS)
+	$(RANLIB) $@
+
+libpng.pc:
+	cat scripts/libpng.pc.in | sed -e s!@prefix@!$(prefix)! \
+	-e s!@exec_prefix@!$(exec_prefix)! \
+	-e s!@libdir@!$(LIBPATH)! \
+	-e s!@includedir@!$(INCPATH)! \
+	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+
+libpng-config:
+	( cat scripts/libpng-config-head.in; \
+	echo prefix=\"$(prefix)\"; \
+	echo I_opts=\"-I$(INCPATH)/$(LIBNAME)\"; \
+	echo cppflags=\"\"; \
+	echo L_opts=\"-L$(LIBPATH)\"; \
+	echo R_opts=\"-R$(LIBPATH)\"; \
+	echo libs=\"-lpng16 -lz -lm\"; \
+	cat scripts/libpng-config-body.in ) > libpng-config
+	chmod +x libpng-config
+
+$(LIBSO): $(LIBSOMAJ)
+	$(LN_SF) $(LIBSOMAJ) $(LIBSO)
+
+$(LIBSOMAJ): $(OBJSDLL)
+	@case "`type ld`" in *ucb*) \
+	echo; \
+	echo '## WARNING:'; \
+	echo '## The commands "CC" and "LD" must NOT refer to /usr/ucb/cc'; \
+	echo '## and /usr/ucb/ld.  If they do, you need to adjust your PATH'; \
+	echo '## environment variable to put /usr/ccs/bin ahead of /usr/ucb.'; \
+	echo '## The environment variable LD_LIBRARY_PATH should not be set'; \
+	echo '## at all.  If it is, things are likely to break because of'; \
+	echo '## the libucb dependency that is created.'; \
+	echo; \
+	;; \
+	esac
+	$(LD) -G -h $(LIBSOMAJ) \
+	 -o $(LIBSOMAJ) $(OBJSDLL)
+
+pngtest: pngtest.o $(LIBSO)
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
+
+test: pngtest
+	./pngtest
+
+install-headers: png.h pngconf.h pnglibconf.h
+	-@if [ ! -d $(DI) ]; then $(MKDIR_P) $(DI); fi
+	-@if [ ! -d $(DI)/$(LIBNAME) ]; then $(MKDIR_P) $(DI)/$(LIBNAME); fi
+	cp png.h pngconf.h pnglibconf.h $(DI)/$(LIBNAME)
+	chmod 644 $(DI)/$(LIBNAME)/png.h $(DI)/$(LIBNAME)/pngconf.h $(DI)/$(LIBNAME)/pnglibconf.h
+	-@$(RM_F) $(DI)/png.h $(DI)/pngconf.h $(DI)/pnglibconf.h
+	-@$(RM_F) $(DI)/libpng
+	(cd $(DI); $(LN_SF) $(LIBNAME) libpng; $(LN_SF) $(LIBNAME)/* .)
+
+install-static: install-headers libpng.a
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	cp libpng.a $(DL)/$(LIBNAME).a
+	chmod 644 $(DL)/$(LIBNAME).a
+	-@$(RM_F) $(DL)/libpng.a
+	(cd $(DL); $(LN_SF) $(LIBNAME).a libpng.a)
+
+install-shared: install-headers $(LIBSOMAJ) libpng.pc
+	-@if [ ! -d $(DL) ]; then $(MKDIR_P) $(DL); fi
+	-@$(RM_F) $(DL)/$(LIBSO)
+	-@$(RM_F) $(DL)/$(LIBSOREL)
+	-@$(RM_F) $(DL)/$(OLDSO)
+	cp $(LIBSOMAJ) $(DL)/$(LIBSOREL)
+	chmod 755 $(DL)/$(LIBSOREL)
+	(cd $(DL); \
+	$(LN_SF) $(LIBSOREL) $(LIBSO); \
+	$(LN_SF) $(LIBSO) $(OLDSO))
+	-@if [ ! -d $(DL)/pkgconfig ]; then $(MKDIR_P) $(DL)/pkgconfig; fi
+	-@$(RM_F) $(DL)/pkgconfig/$(LIBNAME).pc
+	-@$(RM_F) $(DL)/pkgconfig/libpng.pc
+	cp libpng.pc $(DL)/pkgconfig/$(LIBNAME).pc
+	chmod 644 $(DL)/pkgconfig/$(LIBNAME).pc
+	(cd $(DL)/pkgconfig; $(LN_SF) $(LIBNAME).pc libpng.pc)
+
+install-man: libpng.3 libpngpf.3 png.5
+	-@if [ ! -d $(DM) ]; then $(MKDIR_P) $(DM); fi
+	-@if [ ! -d $(DM)/man3 ]; then $(MKDIR_P) $(DM)/man3; fi
+	-@$(RM_F) $(DM)/man3/libpng.3
+	-@$(RM_F) $(DM)/man3/libpngpf.3
+	cp libpng.3 $(DM)/man3
+	cp libpngpf.3 $(DM)/man3
+	-@if [ ! -d $(DM)/man5 ]; then $(MKDIR_P) $(DM)/man5; fi
+	-@$(RM_F) $(DM)/man5/png.5
+	cp png.5 $(DM)/man5
+
+install-config: libpng-config
+	-@if [ ! -d $(DB) ]; then $(MKDIR_P) $(DB); fi
+	-@$(RM_F) $(DB)/libpng-config
+	-@$(RM_F) $(DB)/$(LIBNAME)-config
+	cp libpng-config $(DB)/$(LIBNAME)-config
+	chmod 755 $(DB)/$(LIBNAME)-config
+	(cd $(DB); $(LN_SF) $(LIBNAME)-config libpng-config)
+
+install: install-static install-shared install-man install-config
+
+# If you installed in $(DESTDIR), test-installed won't work until you
+# move the library to its final location.  Use test-dd to test it
+# before then.
+
+test-dd:
+	echo
+	echo Testing installed dynamic shared library in $(DL).
+	$(CC) -I$(DI) $(CPPFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -o pngtestd `$(BINPATH)/$(LIBNAME)-config --ldflags` \
+	   -L$(DL) -L$(ZLIBLIB) -R$(ZLIBLIB) -R$(DL)
+	./pngtestd pngtest.png
+
+test-installed:
+	echo
+	echo Testing installed dynamic shared library.
+	$(CC) $(CPPFLAGS) \
+	   `$(BINPATH)/$(LIBNAME)-config --cflags` pngtest.c \
+	   -o pngtesti `$(BINPATH)/$(LIBNAME)-config --ldflags` \
+	   -L$(ZLIBLIB) -R$(ZLIBLIB)
+	./pngtesti pngtest.png
+
+clean:
+	$(RM_F) *.o libpng.a pngtest pngtesti pngout.png \
+	libpng-config $(LIBSO) $(LIBSOMAJ)* \
+	libpng.pc pnglibconf.h
+
+DOCS = ANNOUNCE CHANGES INSTALL KNOWNBUG LICENSE README TODO
+writelock:
+	chmod a-w *.[ch35] $(DOCS) scripts/*
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o png.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngerror.o pngerror.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrio.o pngrio.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwio.o pngwio.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngmem.o pngmem.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngset.o pngset.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngget.o pngget.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngread.o pngread.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrtran.o pngrtran.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrutil.o pngrutil.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngtrans.o pngtrans.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwrite.o pngwrite.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwtran.o pngwtran.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwutil.o pngwutil.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngpread.o pngpread.pic.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+
+pngtest.o: png.h pngconf.h pnglibconf.h
diff --git a/Engine/lib/lpng/scripts/makefile.std b/Engine/lib/lpng/scripts/makefile.std
new file mode 100644
index 000000000..2f4871df9
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.std
@@ -0,0 +1,134 @@
+# makefile for libpng
+# Copyright (C) 2002, 2006, 2014 Glenn Randers-Pehrson
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# where make install puts libpng.a and png.h
+prefix=/usr/local
+INCPATH=$(prefix)/include
+LIBPATH=$(prefix)/lib
+
+# override DESTDIR= on the make install command line to easily support
+# installing into a temporary location.  Example:
+#
+#    make install DESTDIR=/tmp/build/libpng
+#
+# If you're going to install into a temporary location
+# via DESTDIR, $(DESTDIR)$(prefix) must already exist before
+# you execute make install.
+DESTDIR=
+
+# Where the zlib library and include files are located
+#ZLIBLIB=/usr/local/lib
+#ZLIBINC=/usr/local/include
+ZLIBLIB=../zlib
+ZLIBINC=../zlib
+
+CC = cc
+AR_RC = ar rc
+MKDIR_P = mkdir
+LN_SF = ln -sf
+RANLIB = ranlib
+CP = cp
+RM_F = rm -f
+AWK = awk
+SED = sed
+CPP = $(CC) -E
+ECHO = echo
+
+DFNFLAGS = # DFNFLAGS contains -D options to use in the libpng build
+DFA_EXTRA = # extra files that can be used to control configuration
+CPPFLAGS = -I$(ZLIBINC) # -DPNG_DEBUG=5
+CFLAGS = -O # -g
+LDFLAGS = -L. -L$(ZLIBLIB) -lpng -lz -lm
+
+# Pre-built configuration
+# See scripts/pnglibconf.mak for more options
+PNGLIBCONF_H_PREBUILT = scripts/pnglibconf.h.prebuilt
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+	pngwtran.o pngmem.o pngerror.o pngpread.o
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -o $@ $<
+
+all: libpng.a pngtest
+
+# The standard pnglibconf.h exists as scripts/pnglibconf.h.prebuilt,
+# copy this if the following doesn't work.
+pnglibconf.h: pnglibconf.dfn
+	$(RM_F) $@ pnglibconf.c pnglibconf.out pnglibconf.tmp
+	$(ECHO) '#include "pnglibconf.dfn"' >pnglibconf.c
+	$(ECHO) "If '$(CC) -E' crashes try /lib/cpp (e.g. CPP='/lib/cpp')" >&2
+	$(CPP) $(DFNFLAGS) pnglibconf.c >pnglibconf.out
+	$(AWK) -f "scripts/dfn.awk" out="pnglibconf.tmp" pnglibconf.out 1>&2
+	mv pnglibconf.tmp $@
+
+pnglibconf.dfn: scripts/pnglibconf.dfa scripts/options.awk pngconf.h pngusr.dfa $(DFA_XTRA)
+	$(RM_F) $@ pnglibconf.pre pnglibconf.tmp
+	$(ECHO) "Calling $(AWK) from scripts/pnglibconf.mak" >&2
+	$(ECHO) "If 'awk' crashes try a better awk (e.g. AWK='nawk')" >&2
+	$(AWK) -f scripts/options.awk out="pnglibconf.pre"\
+	    version=search pngconf.h scripts/pnglibconf.dfa\
+	    pngusr.dfa $(DFA_XTRA) 1>&2
+	$(AWK) -f scripts/options.awk out="pnglibconf.tmp" pnglibconf.pre 1>&2
+	mv pnglibconf.tmp $@
+
+libpng.a: $(OBJS)
+	$(AR_RC) $@  $(OBJS)
+	$(RANLIB) $@
+
+pngtest: pngtest.o libpng.a
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
+
+test: pngtest
+	./pngtest
+
+install: libpng.a pnglibconf.h
+	-@$(MKDIR_P) $(DESTDIR)$(INCPATH)
+	-@$(MKDIR_P) $(DESTDIR)$(INCPATH)/libpng
+	-@$(MKDIR_P) $(DESTDIR)$(LIBPATH)
+	-@$(RM_F) $(DESTDIR)$(INCPATH)/png.h
+	-@$(RM_F) $(DESTDIR)$(INCPATH)/pngconf.h
+	-@$(RM_F) $(DESTDIR)$(INCPATH)/pnglibconf.h
+	cp png.h $(DESTDIR)$(INCPATH)/libpng
+	cp pngconf.h $(DESTDIR)$(INCPATH)/libpng
+	cp pnglibconf.h $(DESTDIR)$(INCPATH)/libpng
+	chmod 644 $(DESTDIR)$(INCPATH)/libpng/png.h
+	chmod 644 $(DESTDIR)$(INCPATH)/libpng/pngconf.h
+	chmod 644 $(DESTDIR)$(INCPATH)/libpng/pnglibconf.h
+	(cd $(DESTDIR)$(INCPATH); ln -f -s libpng/* .)
+	cp libpng.a $(DESTDIR)$(LIBPATH)
+	chmod 644 $(DESTDIR)$(LIBPATH)/libpng.a
+
+clean:
+	$(RM_F) *.o libpng.a pngtest pngout.png pnglibconf.h pnglibconf.c \
+	pnglibconf.out
+
+DOCS = ANNOUNCE CHANGES INSTALL KNOWNBUG LICENSE README TODO
+writelock:
+	chmod a-w *.[ch35] $(DOCS) scripts/*
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngerror.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrio.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwio.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngmem.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngset.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngget.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngpread.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngread.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngtrans.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwrite.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+
+pngtest.o: png.h pngconf.h pnglibconf.h
diff --git a/Engine/lib/lpng/scripts/makefile.sunos b/Engine/lib/lpng/scripts/makefile.sunos
new file mode 100644
index 000000000..9a0e28e72
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.sunos
@@ -0,0 +1,115 @@
+# makefile for libpng
+# Copyright (C) 2002, 2006, 2014 Glenn Randers-Pehrson
+# Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# where make install puts libpng.a and png.h
+prefix=/usr/local
+INCPATH=$(prefix)/include
+LIBPATH=$(prefix)/lib
+
+# override DESTDIR= on the make install command line to easily support
+# installing into a temporary location.  Example:
+#
+#    make install DESTDIR=/tmp/build/libpng
+#
+# If you're going to install into a temporary location
+# via DESTDIR, $(DESTDIR)$(prefix) must already exist before
+# you execute make install.
+DESTDIR=
+
+# Where the zlib library and include files are located
+#ZLIBLIB=/usr/local/lib
+#ZLIBINC=/usr/local/include
+ZLIBLIB=../zlib
+ZLIBINC=../zlib
+
+
+WARNMORE=-Wwrite-strings -Wpointer-arith -Wshadow -Wconversion \
+	-Wmissing-declarations -Wtraditional -Wcast-align \
+	-Wstrict-prototypes -Wmissing-prototypes
+
+CC=gcc
+AR_RC=ar rc
+MKDIR_P=mkdir -p
+LN_SF=ln -f -s
+RANLIB=ranlib
+CP=cp
+RM_F=/bin/rm -f
+
+CPPFLAGS=-I$(ZLIBINC) # -DPNG_DEBUG=5
+CFLAGS=-O # $(WARNMORE)
+LDFLAGS=-L. -L$(ZLIBLIB) -lpng -lz -lm
+
+# Pre-built configuration
+# See scripts/pnglibconf.mak for more options
+PNGLIBCONF_H_PREBUILT = scripts/pnglibconf.h.prebuilt
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o \
+	pngread.o pngrio.o pngwio.o pngwrite.o pngrtran.o \
+	pngwtran.o pngmem.o pngerror.o pngpread.o
+
+.c.o:
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) -o $@ $<
+
+all: libpng.a pngtest
+
+pnglibconf.h: $(PNGLIBCONF_H_PREBUILT)
+	$(CP) $(PNGLIBCONF_H_PREBUILT) $@
+
+libpng.a: $(OBJS)
+	$(AR_RC) $@  $(OBJS)
+	$(RANLIB) $@
+
+pngtest: pngtest.o libpng.a
+	$(CC) -o pngtest $(CFLAGS) pngtest.o $(LDFLAGS)
+
+test: pngtest
+	./pngtest
+
+install: libpng.a
+	-@$(MKDIR_P) $(DESTDIR)$(INCPATH)
+	-@$(MKDIR_P) $(DESTDIR)$(INCPATH)/libpng
+	-@$(MKDIR_P) $(DESTDIR)$(LIBPATH)
+	-@$(RM_F) $(DESTDIR)$(INCPATH)/png.h
+	-@$(RM_F) $(DESTDIR)$(INCPATH)/pngconf.h
+	-@$(RM_F) $(DESTDIR)$(INCPATH)/pnglibconf.h
+	cp png.h $(DESTDIR)$(INCPATH)/libpng
+	cp pngconf.h $(DESTDIR)$(INCPATH)/libpng
+	cp pnglibconf.h $(DESTDIR)$(INCPATH)/libpng
+	chmod 644 $(DESTDIR)$(INCPATH)/libpng/png.h
+	chmod 644 $(DESTDIR)$(INCPATH)/libpng/pngconf.h
+	chmod 644 $(DESTDIR)$(INCPATH)/libpng/pnglibconf.h
+	(cd $(DESTDIR)$(INCPATH); $(LN_SF) libpng/* .)
+	cp libpng.a $(DESTDIR)$(LIBPATH)
+	chmod 644 $(DESTDIR)$(LIBPATH)/libpng.a
+
+clean:
+	$(RM_F) *.o libpng.a pngtest pngout.png pnglibconf.h
+
+DOCS = ANNOUNCE CHANGES INSTALL KNOWNBUG LICENSE README TODO
+writelock:
+	chmod a-w *.[ch35] $(DOCS) scripts/*
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+png.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngerror.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrio.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwio.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngmem.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngset.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngget.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngread.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngrutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngtrans.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwrite.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngwutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+pngpread.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+
+pngtest.o: png.h pngconf.h pnglibconf.h
diff --git a/Engine/lib/lpng/scripts/makefile.vcwin32 b/Engine/lib/lpng/scripts/makefile.vcwin32
new file mode 100644
index 000000000..2bd143cc0
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makefile.vcwin32
@@ -0,0 +1,113 @@
+# makefile for libpng
+# Copyright (C) 1998 Tim Wegner
+# Copyright (C) 2006,2009,2011,2014 Glenn Randers-Pehrson
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+#
+# Assumes that zlib.lib, zconf.h, and zlib.h have been copied to ..\zlib
+# To use, do "nmake /f scripts\makefile.vcwin32"
+
+# -------- Microsoft Visual C++ 2.0 and later --------
+
+# Compiler, linker, librarian and other tools
+CC = cl
+LD = link
+AR = lib
+CPPFLAGS = -I..\zlib
+CFLAGS  = -nologo -D_CRT_SECURE_NO_DEPRECATE -D_CRT_SECURE_NO_WARNINGS -MD -O2 -W3
+LDFLAGS = -nologo
+ARFLAGS = -nologo
+CP = copy
+RM = del
+
+# Pre-built configuration
+# See scripts\pnglibconf.mak for more options
+PNGLIBCONF_H_PREBUILT = scripts\pnglibconf.h.prebuilt
+
+# File extensions
+O=.obj
+
+#uncomment next to put error messages in a file
+#ERRFILE= >> pngerrs.log
+
+# Variables
+OBJS1 = png$(O) pngerror$(O) pngget$(O) pngmem$(O) pngpread$(O)
+OBJS2 = pngread$(O) pngrio$(O) pngrtran$(O) pngrutil$(O) pngset$(O)
+OBJS3 = pngtrans$(O) pngwio$(O) pngwrite$(O) pngwtran$(O) pngwutil$(O)
+OBJS  = $(OBJS1) $(OBJS2) $(OBJS3)
+
+# Targets
+all: libpng.lib
+
+pnglibconf.h: $(PNGLIBCONF_H_PREBUILT)
+	$(CP) $(PNGLIBCONF_H_PREBUILT) $@
+
+png$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+pngset$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+pngget$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+pngread$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+pngpread$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+pngrtran$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+pngrutil$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+pngerror$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+pngmem$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+pngrio$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+pngwio$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+pngtrans$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+pngwrite$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+pngwtran$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+pngwutil$(O): png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+libpng.lib: $(OBJS)
+	-$(RM) $@
+	$(AR) $(ARFLAGS) -out:$@ $(OBJS) $(ERRFILE)
+
+pngtest$(O): png.h pngconf.h pnglibconf.h
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) $*.c $(ERRFILE)
+
+pngtest.exe: pngtest$(O) libpng.lib
+	$(LD) $(LDFLAGS) -out:$@ pngtest$(O) libpng.lib ..\zlib\zlib.lib $(ERRFILE)
+
+test: pngtest.exe
+	pngtest
+
+clean:
+	-$(RM) *$(O)
+	-$(RM) libpng.lib
+	-$(RM) pnglibconf.h
+	-$(RM) pngtest.exe
+	-$(RM) pngout.png
+
+# End of makefile for libpng
+
diff --git a/Engine/lib/lpng/scripts/makevms.com b/Engine/lib/lpng/scripts/makevms.com
new file mode 100644
index 000000000..f6c326103
--- /dev/null
+++ b/Engine/lib/lpng/scripts/makevms.com
@@ -0,0 +1,142 @@
+$! make libpng under VMS
+$!
+$!
+$! Check for MMK/MMS
+$!
+$! This procedure accepts one parameter (contrib), which causes it to build
+$! the programs from the contrib directory instead of libpng.
+$!
+$ p1 = f$edit(p1,"UPCASE")
+$ if p1 .eqs. "CONTRIB"
+$ then
+$   set def [.contrib.gregbook]
+$   @makevms
+$   set def [-.pngminus]
+$   @makevms
+$   set def [--]
+$   exit
+$ endif
+$ Make = ""
+$ If F$Search ("Sys$System:MMS.EXE") .nes. "" Then Make = "MMS"
+$ If F$Type (MMK) .eqs. "STRING" Then Make = "MMK"
+$!
+$! Look for the compiler used
+$!
+$ zlibsrc = "[-.zlib]"
+$ ccopt="/include=''zlibsrc'"
+$ if f$getsyi("HW_MODEL").ge.1024
+$ then
+$  ccopt = "/prefix=all"+ccopt
+$  comp  = "__decc__=1"
+$  if f$trnlnm("SYS").eqs."" then define sys sys$library:
+$ else
+$  if f$search("SYS$SYSTEM:DECC$COMPILER.EXE").eqs.""
+$   then
+$    if f$trnlnm("SYS").eqs."" then define sys sys$library:
+$    if f$search("SYS$SYSTEM:VAXC.EXE").eqs.""
+$     then
+$      comp  = "__gcc__=1"
+$      CC :== GCC
+$     else
+$      comp = "__vaxc__=1"
+$     endif
+$   else
+$    if f$trnlnm("SYS").eqs."" then define sys decc$library_include:
+$    ccopt = "/decc/prefix=all"+ccopt
+$    comp  = "__decc__=1"
+$  endif
+$ endif
+$!
+$! Build the thing plain or with mms/mmk
+$!
+$ write sys$output "Compiling Libpng sources ..."
+$ if make.eqs.""
+$  then
+$   dele pngtest.obj;*
+$   CALL MAKE png.OBJ "cc ''CCOPT' png" -
+	png.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+$   CALL MAKE pngset.OBJ "cc ''CCOPT' pngset" -
+	pngset.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+$   CALL MAKE pngget.OBJ "cc ''CCOPT' pngget" -
+	pngget.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+$   CALL MAKE pngread.OBJ "cc ''CCOPT' pngread" -
+	pngread.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+$   CALL MAKE pngpread.OBJ "cc ''CCOPT' pngpread" -
+	pngpread.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+$   CALL MAKE pngrtran.OBJ "cc ''CCOPT' pngrtran" -
+	pngrtran.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+$   CALL MAKE pngrutil.OBJ "cc ''CCOPT' pngrutil" -
+	pngrutil.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+$   CALL MAKE pngerror.OBJ "cc ''CCOPT' pngerror" -
+	pngerror.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+$   CALL MAKE pngmem.OBJ "cc ''CCOPT' pngmem" -
+	pngmem.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+$   CALL MAKE pngrio.OBJ "cc ''CCOPT' pngrio" -
+	pngrio.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+$   CALL MAKE pngwio.OBJ "cc ''CCOPT' pngwio" -
+	pngwio.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+$   CALL MAKE pngtrans.OBJ "cc ''CCOPT' pngtrans" -
+	pngtrans.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+$   CALL MAKE pngwrite.OBJ "cc ''CCOPT' pngwrite" -
+	pngwrite.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+$   CALL MAKE pngwtran.OBJ "cc ''CCOPT' pngwtran" -
+	pngwtran.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+$   CALL MAKE pngwutil.OBJ "cc ''CCOPT' pngwutil" -
+	pngwutil.c png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
+$   write sys$output "Building Libpng ..."
+$   CALL MAKE libpng.OLB "lib/crea libpng.olb *.obj" *.OBJ
+$   write sys$output "Building pngtest..."
+$   CALL MAKE pngtest.OBJ "cc ''CCOPT' pngtest" -
+	pngtest.c png.h pngconf.h pnglibconf.h
+$   call make pngtest.exe -
+	"LINK pngtest,libpng.olb/lib,''zlibsrc'libz.olb/lib" -
+	pngtest.obj libpng.olb
+$   write sys$output "Testing Libpng..."
+$   run pngtest
+$  else
+$   if f$search("DESCRIP.MMS") .eqs. "" then copy/nolog [.SCRIPTS]DESCRIP.MMS []
+$   'make'/macro=('comp',zlibsrc='zlibsrc')
+$  endif
+$ write sys$output "Libpng build completed"
+$ exit
+$!
+$!
+$MAKE: SUBROUTINE   !SUBROUTINE TO CHECK DEPENDENCIES
+$ V = 'F$Verify(0)
+$! P1 = What we are trying to make
+$! P2 = Command to make it
+$! P3 - P8  What it depends on
+$
+$ If F$Search(P1) .Eqs. "" Then Goto Makeit
+$ Time = F$CvTime(F$File(P1,"RDT"))
+$arg=3
+$Loop:
+$       Argument = P'arg
+$       If Argument .Eqs. "" Then Goto Exit
+$       El=0
+$Loop2:
+$       File = F$Element(El," ",Argument)
+$       If File .Eqs. " " Then Goto Endl
+$       AFile = ""
+$Loop3:
+$       OFile = AFile
+$       AFile = F$Search(File)
+$       If AFile .Eqs. "" .Or. AFile .Eqs. OFile Then Goto NextEl
+$       If F$CvTime(F$File(AFile,"RDT")) .Ges. Time Then Goto Makeit
+$       Goto Loop3
+$NextEL:
+$       El = El + 1
+$       Goto Loop2
+$EndL:
+$ arg=arg+1
+$ If arg .Le. 8 Then Goto Loop
+$ Goto Exit
+$
+$Makeit:
+$ VV=F$VERIFY(0)
+$ write sys$output P2
+$ 'P2
+$ VV='F$Verify(VV)
+$Exit:
+$ If V Then Set Verify
+$ENDSUBROUTINE
diff --git a/Engine/lib/lpng/scripts/options.awk b/Engine/lib/lpng/scripts/options.awk
new file mode 100755
index 000000000..fef5dfd78
--- /dev/null
+++ b/Engine/lib/lpng/scripts/options.awk
@@ -0,0 +1,898 @@
+#!/bin/awk -f
+# scripts/options.awk - library build configuration control
+#
+# last changed in libpng version 1.6.11 - June 5, 2014
+#
+# Copyright (c) 1998-2014 Glenn Randers-Pehrson
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+# The output of this script is written to the file given by
+# the variable 'out'.  The script is run twice, once with
+# an intermediate output file, 'options.tmp' then again on
+# that file to produce the final output:
+#
+#  awk -f scripts/options.awk out=options.tmp scripts/options.dfa 1>&2
+#  awk -f scripts/options.awk out=options.dfn options.tmp 1>&2
+#
+# Some options may be specified on the command line:
+#
+#  deb=1            Causes debugging to be output
+#  logunsupported=1 Causes all options to be recorded in the output
+#  everything=off   Causes all options to be disabled by default
+#  everything=on    Causes all options to be enabled by default
+#
+# If awk fails on your platform, try nawk instead.
+#
+# These options may also be specified in the original input file (and
+# are copied to the preprocessed file).
+
+BEGIN{
+   out=""                       # intermediate, preprocessed, file
+   pre=-1                       # preprocess (first line)
+   version="libpng version unknown" # version information
+   version_file=""              # where to find the version
+   err=0                        # in-line exit sets this
+   # The following definitions prevent the C preprocessor noticing the lines
+   # that will be in the final output file.  Some C preprocessors tokenise
+   # the lines, for example by inserting spaces around operators, and all
+   # C preprocessors notice lines that start with '#', most remove comments.
+   # The technique adopted here is to make the final output lines into
+   # C strings (enclosed in double quotes), preceded by PNG_DFN.  As a
+   # consequence the output cannot contain a 'raw' double quote - instead put
+   # @' in, this will be replaced by a single " afterward.  See the parser
+   # script dfn.awk for more capabilities (not required here).  Note that if
+   # you need a " in a 'setting' in pnglibconf.dfa it must also be @'!
+   dq="@'"                      # For a single double quote
+   start=" PNG_DFN \""          # Start stuff to output (can't contain a "!)
+   end="\" "                    # End stuff to output
+   subs="@\" "                  # Substitute start (substitute a C macro)
+   sube=" \"@"                  # Substitute end
+   comment=start "/*"           # Comment start
+   cend="*/" end                # Comment end
+   def=start "#define PNG_"     # Arbitrary define
+   sup="_SUPPORTED" end         # end supported option
+   und=comment "#undef PNG_"    # Unsupported option
+   une="_SUPPORTED" cend        # end unsupported option
+   error=start "ERROR:"         # error message, terminate with 'end'
+
+   # Variables
+   deb=0                        # debug - set on command line
+   everything=""                # do not override defaults
+   logunsupported=0             # write unsupported options too
+
+   # Precreate arrays
+   # for each option:
+   option[""] = ""    # list of all options: default enabled/disabled
+   done[""] = 1       # marks option as having been output
+   requires[""] = ""  # requires by option
+   iffs[""] = ""      # if by option
+   enabledby[""] = "" # options that enable it by option
+   sets[""] = ""      # settings set by each option
+   setval[""] = ""    # value to set (indexed: 'option sets[option]')
+   # for each setting:
+   setting[""] = ""   # requires by setting
+   defaults[""] = ""  # used for a defaulted value
+   doneset[""] = 1    # marks setting as having been output
+   r[""] = ""         # Temporary array
+
+   # For decorating the output file
+   protect = ""
+}
+
+# The output file must be specified before any input:
+out == "" {
+   print "out=output.file must be given on the command line"
+   err = 1
+   exit 1
+}
+
+# The very first line indicates whether we are reading pre-processed
+# input or not, this must come *first* because 'PREPROCESSED' needs
+# to be the very first line in the temporary file.
+pre == -1{
+   if ($0 == "PREPROCESSED") {
+      pre = 0
+      next
+   } else {
+      pre = 1
+      print "PREPROCESSED" >out
+      # And fall through to continue processing
+   }
+}
+
+# While pre-processing if version is set to "search" look for a version string
+# in the following file.
+pre && version == "search" && version_file == ""{
+   version_file = FILENAME
+}
+
+pre && version == "search" && version_file != FILENAME{
+   print "version string not found in", version_file
+   err = 1
+   exit 1
+}
+
+pre && version == "search" && $0 ~ /^ \* libpng version/{
+   version = substr($0, 4)
+   print "version =", version >out
+   next
+}
+
+pre && FILENAME == version_file{
+   next
+}
+
+# variable=value
+#   Sets the given variable to the given value (the syntax is fairly
+#   free form, except for deb (you are expected to understand how to
+#   set the debug variable...)
+#
+#   This happens before the check on 'pre' below skips most of the
+#   rest of the actions, so the variable settings happen during
+#   preprocessing but are recorded in the END action too.  This
+#   allows them to be set on the command line too.
+$0 ~ /^[ 	]*version[ 	]*=/{
+   sub(/^[  ]*version[  ]*=[  ]*/, "")
+   version = $0
+   next
+}
+$0 ~ /^[ 	]*everything[ 	=]*off[ 	]*$/{
+   everything = "off"
+   next
+}
+$0 ~ /^[ 	]*everything[ 	=]*on[ 	]*$/{
+   everything = "on"
+   next
+}
+$0 ~ /^[ 	]*logunsupported[ 	=]*0[ 	]*$/{
+   logunsupported = 0
+   next
+}
+$0 ~ /^[ 	]*logunsupported[ 	=]*1[ 	]*$/{
+   logunsupported = 1
+   next
+}
+$1 == "deb" && $2 == "=" && NF == 3{
+   deb = $3
+   next
+}
+
+# Preprocessing - this just copies the input file with lines
+# that need preprocessing (just chunk at present) expanded
+# The bare "pre" instead of "pre != 0" crashes under Sunos awk
+pre && $1 != "chunk"{
+   print >out
+   next
+}
+
+# The first characters of the line determine how it is processed,
+# leading spaces are ignored.  In general tokens that are not
+# keywords are the names of options.  An option 'name' is
+# controlled by the definition of the corresponding macros:
+#
+#   PNG_name_SUPPORTED    The option is turned on
+#   PNG_NO_name
+#   PNG_NO_name_SUPPORTED If the first macro is not defined
+#                         either of these will turn the option off
+#
+# If none of these macros are defined the option is turned on, unless
+# the keyword 'off' is given in a line relating to the option.  The
+# keyword 'on' can also be given, but it will be ignored (since it is
+# the default.)
+#
+# In the syntax below a 'name' is indicated by "NAME", other macro
+# values are indicated by "MACRO", as with "NAME" the leading "PNG_"
+# is omitted, but in this case the "NO_" prefix and the "_SUPPORTED"
+# suffix are never used.
+#
+# Each line is introduced by a keyword - the first non-space characters
+# on the line.  A line starting with a '#' is a comment - it is totally
+# ignored.  Keywords are as follows, a NAME, is simply a macro name
+# without the leading PNG_, PNG_NO_ or the trailing _SUPPORTED.
+
+$1 ~ /^#/ || $0 ~ /^[ 	]*$/{
+   next
+}
+
+# com <comment>
+#   The whole line is placed in the output file as a comment with
+#   the preceding 'com' removed
+$1 == "com"{
+   if (NF > 1) {
+      # sub(/^[ 	]*com[ 	]*/, "")
+      $1 = ""
+      print comment $0, cend >out
+   } else
+      print start end >out
+   next
+}
+
+# version
+#   Inserts a version comment
+$1 == "version" && NF == 1{
+   if (version == "") {
+      print "ERROR: no version string set"
+      err = 1 # prevent END{} running
+      exit 1
+   }
+
+   print comment, version, cend >out
+   next
+}
+
+# file output input protect
+#   Informational: the official name of the input file (without
+#   make generated local directories), the official name of the
+#   output file and, if required, a name to use in a protection
+#   macro for the contents.
+$1 == "file" && NF >= 2{
+   print comment, $2, cend >out
+   print comment, "Machine generated file: DO NOT EDIT", cend >out
+   if (NF >= 3)
+      print comment, "Derived from:", $3, cend >out
+   protect = $4
+   if (protect != "") {
+      print start "#ifndef", protect end >out
+      print start "#define", protect end >out
+   }
+   next
+}
+
+# option NAME ( (requires|enables|if) NAME* | on | off | disabled |
+#                sets SETTING VALUE+ )*
+#     
+#   Declares an option 'NAME' and describes its default setting (disabled)
+#   and its relationship to other options.  The option is disabled
+#   unless *all* the options listed after 'requires' are set and at
+#   least one of the options listed after 'if' is set.  If the
+#   option is set then it turns on all the options listed after 'enables'.
+#
+#   Note that "enables" takes priority over the required/if/disabled/off
+#   setting of the target option.
+#
+#   The definition file may list an option as 'disabled': off by default,
+#   otherwise the option is enabled: on by default.  A later (and it must
+#   be later) entry may turn an option on or off explicitly.
+
+$1 == "option" && NF >= 2{
+   opt = $2
+   sub(/,$/,"",opt)
+   onoff = option[opt]  # records current (and the default is "", enabled)
+   key = ""
+   istart = 3
+   do {
+      if (istart == 1) {     # continuation line
+         val = getline
+
+         if (val != 1) { # error reading it
+            if (val == 0)
+               print "option", opt ": ERROR: missing continuation line"
+            else
+               print "option", opt ": ERROR: error reading continuation line"
+
+            # This is a hard error
+            err = 1 # prevent END{} running
+            exit 1
+         }
+      }
+
+      for (i=istart; i<=NF; ++i) {
+         val=$(i)
+         sub(/,$/,"",val)
+         if (val == "on" || val == "off" || val == "disabled" || val =="enabled") {
+            key = ""
+            if (onoff != val) {
+               # on or off can zap disabled or enabled:
+               if (onoff == "" || (onoff == "disabled" || onoff == "enabled") &&
+                   (val == "on" || val == "off")) {
+                  # It's easy to mis-spell the option when turning it
+                  # on or off, so warn about it here:
+                  if (onoff == "" && (val == "on" || val == "off")) {
+                     print "option", opt ": ERROR: turning unrecognized option", val
+                     # For the moment error out - it is safer
+                     err = 1 # prevent END{} running
+                     exit 1
+                  }
+                  onoff = val
+               } else {
+                  # Print a message, otherwise the error
+                  # below is incomprehensible
+                  print "option", opt ": currently", onoff ": attempt to turn", val
+                  break
+               }
+            }
+         } else if (val == "requires" || val == "if" || val == "enables" || val =="sets") {
+            key = val
+         } else if (key == "requires") {
+            requires[opt] = requires[opt] " " val
+         } else if (key == "if") {
+            iffs[opt] = iffs[opt] " " val
+         } else if (key == "enables") {
+            enabledby[val] = enabledby[val] " " opt
+         } else if (key == "sets") {
+            sets[opt] = sets[opt] " " val
+            key = "setval"
+            set = val
+         } else if (key == "setval") {
+            setval[opt " " set] = setval[opt " " set] " " val
+         } else
+            break # bad line format
+      }
+
+      istart = 1
+   } while (i > NF && $0 ~ /,$/)
+
+   if (i > NF) {
+      # Set the option, defaulting to 'enabled'
+      if (onoff == "") onoff = "enabled"
+      option[opt] = onoff
+      next
+   }
+   # Else fall through to the error handler
+}
+
+# chunk NAME [requires OPT] [enables LIST] [on|off|disabled]
+#   Expands to the 'option' settings appropriate to the reading and
+#   writing of an ancillary PNG chunk 'NAME':
+#
+#   option READ_NAME requires READ_ANCILLARY_CHUNKS [READ_OPT]
+#   option READ_NAME enables NAME LIST
+#   [option READ_NAME off]
+#   option WRITE_NAME requires WRITE_ANCILLARY_CHUNKS [WRITE_OPT]
+#   option WRITE_NAME enables NAME LIST
+#   [option WRITE_NAME off]
+
+pre != 0 && $1 == "chunk" && NF >= 2{
+   # 'chunk' is handled on the first pass by writing appropriate
+   # 'option' lines into the intermediate file.
+   opt = $2
+   sub(/,$/,"",opt)
+   onoff = ""
+   reqread = ""
+   reqwrite = ""
+   enables = ""
+   req = 0
+   istart = 3
+   do {
+      if (istart == 1) {     # continuation line
+         val = getline
+
+         if (val != 1) { # error reading it
+            if (val == 0)
+               print "chunk", opt ": ERROR: missing continuation line"
+            else
+               print "chunk", opt ": ERROR: error reading continuation line"
+
+            # This is a hard error
+            err = 1 # prevent END{} running
+            exit 1
+         }
+      }
+
+      # read the keywords/additional OPTS
+      for (i=istart; i<=NF; ++i) {
+         val = $(i)
+         sub(/,$/,"",val)
+         if (val == "on" || val == "off" || val == "disabled") {
+            if (onoff != val) {
+               if (onoff == "")
+                  onoff = val
+               else
+                  break # on/off conflict
+            }
+            req = 0
+         } else if (val == "requires")
+            req = 1
+         else if (val == "enables")
+            req = 2
+         else if (req == 1){
+            reqread = reqread " READ_" val
+            reqwrite = reqwrite " WRITE_" val
+         } else if (req == 2)
+            enables = enables " " val
+         else
+            break # bad line: handled below
+      }
+
+      istart = 1
+   } while (i > NF && $0 ~ /,$/)
+
+   if (i > NF) {
+      # Output new 'option' lines to the intermediate file (out)
+      print "option READ_" opt, "requires READ_ANCILLARY_CHUNKS" reqread, "enables", opt enables , onoff >out
+      print "option WRITE_" opt, "requires WRITE_ANCILLARY_CHUNKS" reqwrite, "enables", opt enables, onoff >out
+      next
+   }
+   # Else hit the error handler below - bad line format!
+}
+
+# setting MACRO ( requires MACRO* )* [ default VALUE ]
+#   Behaves in a similar way to 'option' without looking for NO_ or
+#   _SUPPORTED; the macro is enabled if it is defined so long as all
+#   the 'requires' macros are also defined.  The definitions may be
+#   empty, an error will be issued if the 'requires' macros are
+#   *not* defined.  If given the 'default' value is used if the
+#   macro is not defined.  The default value will be re-tokenised.
+#   (BTW: this is somewhat restrictive, it mainly exists for the
+#   support of non-standard configurations and numeric parameters,
+#   see the uses in scripts/options.dat
+
+$1 == "setting" && (NF == 2 || NF >= 3 && ($3 == "requires" || $3 == "default")){
+   reqs = ""
+   deflt = ""
+   isdef = 0
+   key = ""
+   for (i=3; i<=NF; ++i)
+      if ($(i) == "requires" || $(i) == "default") {
+         key = $(i)
+         if (key == "default") isdef = 1
+      } else if (key == "requires")
+         reqs = reqs " " $(i)
+      else if (key == "default")
+         deflt = deflt " " $(i)
+      else
+         break # Format error, handled below
+
+   setting[$2] = reqs
+   # NOTE: this overwrites a previous value silently
+   if (isdef && deflt == "")
+      deflt = " " # as a flag to force output
+   defaults[$2] = deflt
+   next
+}
+
+# The order of the dependency lines (option, chunk, setting) is irrelevant
+# - the 'enables', 'requires' and 'if' settings will be used to determine
+# the correct order in the output and the final values in pnglibconf.h are
+# not order dependent.  'requires' and 'if' entries take precedence over
+# 'enables' from other options; if an option requires another option it
+# won't be set regardless of any options that enable it unless the other
+# option is also enabled.
+#
+# Similarly 'enables' trumps a NO_ definition in CFLAGS or pngusr.h
+#
+# For simplicity cycles in the definitions are regarded as errors,
+# even if they are not ambiguous.
+# A given NAME can be specified in as many 'option' lines as required, the
+# definitions are additive.
+
+# For backwards compatibility equivalent macros may be listed thus:
+#
+# = [NO_]NAME MACRO
+#   Makes -DMACRO equivalent to -DPNG_NO_NAME or -DPNG_NAME_SUPPORTED
+#   as appropriate.
+#
+# The definition is injected into the C compiler input when encountered
+# in the second pass (so all these definitions appear *after* the @
+# lines!)
+#
+# 'NAME' is as above, but 'MACRO' is the full text of the equivalent
+# old, deprecated, macro.
+
+$1 == "=" && NF == 3{
+   print "#ifdef PNG_" $3 >out
+   if ($2 ~ /^NO_/)
+      print "#   define PNG_" $2 >out
+   else
+      print "#   define PNG_" $2 "_SUPPORTED" >out
+   print "#endif" >out
+   next
+}
+
+# Lines may be injected into the C compiler input by preceding them
+# with an "@" character.  The line is copied with just the leading
+# @ removed.
+
+$1 ~ /^@/{
+   # sub(/^[ 	]*@/, "")
+   $1 = substr($1, 2)
+   print >out
+   next
+}
+
+# Check for unrecognized lines, because of the preprocessing chunk
+# format errors will be detected on the first pass independent of
+# any other format errors.
+{
+   print "options.awk: bad line (" NR "):", $0
+   err = 1 # prevent END{} running
+   exit 1
+}
+
+# For checking purposes names that start with "ok_" or "fail_" are
+# not output to pnglibconf.h and must be either enabled or disabled
+# respectively for the build to succeed.  This allows interdependencies
+# between options of the form "at least one of" or "at most one of"
+# to be checked.  For example:
+#
+# option FLOATING_POINT enables ok_math
+# option FIXED_POINT enables ok_math
+#   This ensures that at least one of FLOATING_POINT and FIXED_POINT
+#   must be set for the build to succeed.
+#
+# option fail_math requires FLOATING_POINT FIXED_POINT
+#   This means the build will fail if *both* FLOATING_POINT and
+#   FIXED_POINT are set (this is an example; in fact both are allowed.)
+#
+# If all these options were given the build would require exactly one
+# of the names to be enabled.
+
+END{
+   # END{} gets run on an exit (a traditional awk feature)
+   if (err) exit 1
+
+   if (pre) {
+      # Record the final value of the variables
+      print "deb =", deb >out
+      if (everything != "") {
+         print "everything =", everything >out
+      }
+      print "logunsupported =", logunsupported >out
+      exit 0
+   }
+
+   # Do the options first (allowing options to set settings).  The dependency
+   # tree is thus:
+   #
+   #   name     >     name
+   #   name requires  name
+   #   name if        name
+   #   name enabledby name
+   #
+   # First build a list 'tree' by option of all the things on which
+   # it depends.
+   print "" >out
+   print "/* OPTIONS */" >out
+   print comment, "options", cend >out
+   for (opt in enabledby) tree[opt] = 1  # may not be explicit options
+   for (opt in option) if (opt != "") {
+      o = option[opt]
+      # option should always be one of the following values
+      if (o != "on" && o != "off" && o != "disabled" && o != "enabled") {
+         print "internal option error (" o ")"
+         exit 1
+      }
+      tree[opt] = ""   # so unlisted options marked
+   }
+   for (opt in tree) if (opt != "") {
+      if (tree[opt] == 1) {
+         tree[opt] = ""
+         if (option[opt] != "") {
+            print "internal error (1)"
+            exit 1
+         }
+         # Macros only listed in 'enables' remain off unless
+         # one of the enabling macros is on.
+         option[opt] = "disabled"
+      }
+
+      split("", list) # clear 'list'
+      # Now add every requires, iffs or enabledby entry to 'list'
+      # so that we can add a unique list of requirements to tree[i]
+      split(requires[opt] iffs[opt] enabledby[opt], r)
+      for (i in r) list[r[i]] = 1
+      for (i in list) tree[opt] = tree[opt] " " i
+   }
+
+   # print the tree for extreme debugging
+   if (deb > 2) for (i in tree) if (i != "") print i, "depends-on" tree[i]
+
+   # Ok, now check all options marked explicitly 'on' or 'off':
+   #
+   # If an option[opt] is 'on' then turn on all requires[opt]
+   # If an option[opt] is 'off' then turn off all enabledby[opt]
+   #
+   # Error out if we have to turn 'on' to an 'off' option or vice versa.
+   npending = 0
+   for (opt in option) if (opt != "") {
+      if (option[opt] == "on" || option[opt] == "off") {
+         pending[++npending] = opt
+      }
+   }
+
+   err = 0 # set on error
+   while (npending > 0) {
+      opt = pending[npending--]
+      if (option[opt] == "on") {
+         nreqs = split(requires[opt], r)
+         for (j=1; j<=nreqs; ++j) {
+            if (option[r[j]] == "off") {
+               print "option", opt, "turned on, but requirement", r[j], "is turned off"
+               err = 1
+            } else if (option[r[j]] != "on") {
+               option[r[j]] = "on"
+               pending[++npending] = r[j]
+            }
+         }
+      } else {
+         if (option[opt] != "off") {
+            print "internal error (2)"
+            exit 1
+         }
+         nreqs = split(enabledby[opt], r)
+         for (j=1; j<=nreqs; ++j) {
+            if (option[r[j]] == "on") {
+               print "option", opt, "turned off, but enabled by", r[j], "which is turned on"
+               err = 1
+            } else if (option[r[j]] != "off") {
+               option[r[j]] = "off"
+               pending[++npending] = r[j]
+            }
+         }
+      }
+   }
+   if (err) exit 1
+
+   # Sort options:
+   print "PNG_DFN_START_SORT 2" >out
+
+   # option[i] is now the complete list of all the tokens we may
+   # need to output, go through it as above, depth first.
+   finished = 0
+   while (!finished) {
+      finished = 1
+      movement = 0 # done nothing
+      for (i in option) if (!done[i]) {
+         nreqs = split(tree[i], r)
+         if (nreqs > 0) {
+            for (j=1; j<=nreqs; ++j) if (!done[r[j]]) {
+               break
+            }
+            if (j<=nreqs) {
+               finished = 0
+               continue  # next option
+            }
+         }
+
+         # All the requirements have been processed, output
+         # this option.  An option is _SUPPORTED if:
+         #
+         # all 'requires' are _SUPPORTED AND
+         # at least one of the 'if' options are _SUPPORTED AND
+         # EITHER:
+         #   The name is _SUPPORTED (on the command line)
+         # OR:
+         #   an 'enabledby' is _SUPPORTED
+         # OR:
+         #   NO_name is not defined AND
+         #   the option is not disabled; an option is disabled if:
+         #    option == off
+         #    option == disabled && everything != on
+         #    option == "" && everything == off
+         if (deb) print "option", i
+         print "" >out
+         print "/* option:", i, option[i] >out
+         print " *   requires:  " requires[i] >out
+         print " *   if:        " iffs[i] >out
+         print " *   enabled-by:" enabledby[i] >out
+         print " *   sets:      " sets[i], "*/" >out
+         print "#undef PNG_on" >out
+         print "#define PNG_on 1" >out
+
+         # requires
+         nreqs = split(requires[i], r)
+         for (j=1; j<=nreqs; ++j) {
+            print "#ifndef PNG_" r[j] "_SUPPORTED" >out
+            print "#   undef PNG_on /*!" r[j] "*/" >out
+            # This error appears in the final output if something
+            # was switched 'on' but the processing above to force
+            # the requires did not work
+            if (option[i] == "on") {
+               print error, i, "requires", r[j] end >out
+            }
+            print "#endif" >out
+         }
+
+         # if
+         have_ifs = 0
+         nreqs = split(iffs[i], r)
+         print "#undef PNG_no_if" >out
+         if (nreqs > 0) {
+            have_ifs = 1
+            print "/* if" iffs[i], "*/" >out
+            print "#define PNG_no_if 1" >out
+            for (j=1; j<=nreqs; ++j) {
+               print "#ifdef PNG_" r[j] "_SUPPORTED" >out
+               print "#   undef PNG_no_if /*" r[j] "*/" >out
+               print "#endif" >out
+            }
+            print "#ifdef PNG_no_if /*missing if*/" >out
+            print "#   undef PNG_on" >out
+            # There is no checking above for this, because we
+            # don't know which 'if' to choose, so whine about
+            # it here:
+            if (option[i] == "on") {
+               print error, i, "needs one of:", iffs[i] end >out
+            }
+            print "#endif" >out
+         }
+
+         print "#ifdef PNG_on /*requires, if*/" >out
+         # enables
+         print "#   undef PNG_not_enabled" >out
+         print "#   define PNG_not_enabled 1" >out
+         print "   /* enabled by" enabledby[i], "*/" >out
+         nreqs = split(enabledby[i], r)
+         for (j=1; j<=nreqs; ++j) {
+            print "#ifdef PNG_" r[j] "_SUPPORTED" >out
+            print "#   undef PNG_not_enabled /*" r[j] "*/" >out
+            # Oops, probably not intended (should be factored
+            # out by the checks above).
+            if (option[i] == "off") {
+               print error, i, "enabled by:", r[j] end >out
+            }
+            print "#endif" >out
+         }
+
+         print "#   ifndef PNG_" i "_SUPPORTED /*!command line*/" >out
+         print "#    ifdef PNG_not_enabled /*!enabled*/" >out
+         # 'have_ifs' here means that everything = "off" still allows an 'if' on
+         # an otherwise enabled option to turn it on; otherwise the 'if'
+         # handling is effectively disabled by 'everything = off'
+         if (option[i] == "off" || option[i] == "disabled" && everything != "on" || option[i] == "enabled" && everything == "off" && !have_ifs) {
+            print "#      undef PNG_on /*default off*/" >out
+         } else {
+            print "#      ifdef PNG_NO_" i >out
+            print "#       undef PNG_on /*turned off*/" >out
+            print "#      endif" >out
+            print "#      ifdef PNG_NO_" i "_SUPPORTED" >out
+            print "#       undef PNG_on /*turned off*/" >out
+            print "#      endif" >out
+         }
+         print "#    endif /*!enabled*/" >out
+         print "#    ifdef PNG_on" >out
+         # The _SUPPORTED macro must be defined so that dependent
+         # options output later work.
+         print "#      define PNG_" i "_SUPPORTED" >out
+         print "#    endif" >out
+         print "#   endif /*!command line*/" >out
+         # If PNG_on is still set the option should be defined in
+         # pnglibconf.h
+         print "#   ifdef PNG_on" >out
+         if (i ~ /^fail_/) {
+            print error, i, "is on: enabled by:" iffs[i] enabledby[i] ", requires" requires[i] end >out
+         } else if (i !~ /^ok_/) {
+            print def i sup >out
+            # Supported option, set required settings
+            nreqs = split(sets[i], r)
+            for (j=1; j<=nreqs; ++j) {
+               print "#    ifdef PNG_set_" r[j] >out
+               # Some other option has already set a value:
+               print error, i, "sets", r[j] ": duplicate setting" end >out
+               print error, "   previous value: " end "PNG_set_" r[j] >out
+               print "#    else" >out
+               # Else set the default: note that this won't accept arbitrary
+               # values, the setval string must be acceptable to all the C
+               # compilers we use.  That means it must be VERY simple; a number,
+               # a name or a string.
+               print "#     define PNG_set_" r[j], setval[i " " r[j]] >out
+               print "#    endif" >out
+            }
+         }
+         print "#   endif /* definition */" >out
+         print "#endif /*requires, if*/" >out
+         if (logunsupported || i ~ /^ok_/) {
+            print "#ifndef  PNG_on" >out
+            if (logunsupported) {
+               print und i une >out
+            }
+            if (i ~ /^ok_/) {
+               print error, i, "not enabled: requires:" requires[i] ", enabled by:" iffs[i] enabledby[i] end >out
+            }
+            print "#endif" >out
+         }
+
+         done[i] = 1
+         ++movement
+      }
+
+      if (!finished && !movement) {
+         print "option: loop or missing option in dependency tree, cannot process:"
+         for (i in option) if (!done[i]) {
+            print "  option", i, "depends on" tree[i], "needs:"
+            nreqs = split(tree[i], r)
+            if (nreqs > 0) for (j=1; j<=nreqs; ++j) if (!done[r[j]]) {
+               print "   " r[j]
+            }
+         }
+         exit 1
+      }
+   }
+   print "PNG_DFN_END_SORT" >out
+   print comment, "end of options", cend >out
+
+   # Do the 'setting' values second, the algorithm the standard
+   # tree walk (O(1)) done in an O(2) while/for loop; iterations
+   # settings x depth, outputting the deepest required macros
+   # first.
+   print "" >out
+   print "/* SETTINGS */" >out
+   print comment, "settings", cend >out
+   # Sort (in dfn.awk) on field 2, the setting name
+   print "PNG_DFN_START_SORT 2" >out
+   finished = 0
+   while (!finished) {
+      finished = 1
+      movement = 0 # done nothing
+      for (i in setting) if (!doneset[i]) {
+         nreqs = split(setting[i], r)
+         if (nreqs > 0) {
+            # By default assume the requires values are options, but if there
+            # is no option with that name check for a setting
+            for (j=1; j<=nreqs; ++j) if (option[r[j]] == "" && !doneset[r[j]]) {
+               break
+            }
+            if (j<=nreqs) {
+               finished = 0
+               continue # try a different setting
+            }
+         }
+
+         # All the requirements have been processed, output
+         # this setting.
+         if (deb) print "setting", i
+         deflt = defaults[i]
+         # Remove any spurious trailing spaces
+         sub(/ *$/,"",deflt)
+         # A leading @ means leave it unquoted so the preprocessor
+         # can substitute the build time value
+         if (deflt ~ /^ @/)
+            deflt = " " subs substr(deflt, 3) sube
+         print "" >out
+         print "/* setting: ", i >out
+         print " *   requires:" setting[i] >out
+         print " *   default: ", defaults[i] deflt, "*/" >out
+         for (j=1; j<=nreqs; ++j) {
+            if (option[r[j]] != "")
+               print "#ifndef PNG_" r[j] "_SUPPORTED" >out
+            else
+               print "#ifndef PNG_" r[j] >out
+            print error, i, "requires", r[j] end >out
+            print "# endif" >out
+         }
+         # The precedence is:
+         #
+         #  1) External definition; trumps:
+         #  2) Option 'sets' value; trumps:
+         #  3) Setting 'default'
+         #
+         print "#ifdef PNG_" i >out
+         # PNG_<i> is defined, so substitute the value:
+         print def i, subs "PNG_" i sube end >out
+         print "#else /* use default */" >out
+         print "# ifdef PNG_set_" i >out
+         # Value from an option 'sets' argument
+         print def i, subs "PNG_set_" i sube end >out
+         # This is so that subsequent tests on the setting work:
+         print "#  define PNG_" i, "1" >out
+         if (defaults[i] != "") {
+            print "# else /*default*/" >out
+            print def i deflt end >out
+            print "#  define PNG_" i, "1" >out
+         }
+         print "# endif /* defaults */" >out
+         print "#endif /* setting", i, "*/" >out
+
+         doneset[i] = 1
+         ++movement
+      }
+
+      if (!finished && !movement) {
+         print "setting: loop or missing setting in 'requires', cannot process:"
+         for (i in setting) if (!doneset[i]) {
+            print "  setting", i, "requires" setting[i]
+         }
+         exit 1
+      }
+   }
+   print "PNG_DFN_END_SORT" >out
+   print comment, "end of settings", cend >out
+
+   # Regular end - everything looks ok
+   if (protect != "") {
+      print start "#endif", "/*", protect, "*/" end >out
+   }
+}
diff --git a/Engine/lib/lpng/scripts/pnglibconf.dfa b/Engine/lib/lpng/scripts/pnglibconf.dfa
new file mode 100644
index 000000000..4dcaf7c86
--- /dev/null
+++ b/Engine/lib/lpng/scripts/pnglibconf.dfa
@@ -0,0 +1,920 @@
+# scripts/pnglibconf.dfa - library build configuration control
+#
+@/*- pnglibconf.dfn intermediate file
+@ *  generated from scripts/pnglibconf.dfa
+@ */
+#
+com pnglibconf.h - library build configuration
+com
+version
+com
+com Copyright (c) 2018-2019 Cosmin Truta
+com Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+com
+com This code is released under the libpng license.
+com For conditions of distribution and use, see the disclaimer
+com and license in png.h
+com
+
+file pnglibconf.h scripts/pnglibconf.dfa PNGLCONF_H
+
+# This file is preprocessed by scripts/options.awk and the
+# C compiler to generate 'pnglibconf.h' - a list of all the
+# configuration options.  The file lists the various options
+# that can *only* be specified during the libpng build;
+# pnglibconf.h freezes the definitions selected for the specific
+# build.
+#
+# The syntax is detailed in scripts/options.awk; this is a summary
+# only:
+#
+# setting <name> [requires ...] [default]
+#    #define PNG_<name> <value>  /* value comes from current setting */
+# option <name> [requires ...] [if ...] [enables ...] [disabled]
+#    #define PNG_<name>_SUPPORTED if the requirements are met and
+#    enable the other options listed
+# chunk <name> [requires ...] [enables ...] [disabled]
+#    Enable chunk processing for the given ancillary chunk; any
+#    'requires something' expands to READ_something for read and
+#    WRITE_something for write, but the enables list members are
+#    used as given (e.g. enables GAMMA just expands to that on the
+#    correspond READ_name and WRITE_name lines.)
+#
+# "," may be used to separate options on an 'option' line and is ignored; it
+# doesn't change the meaning of the line.  (NOT setting, where "," becomes
+# part of the setting!)  A comma at the end of an option line causes a
+# continuation (the next line is included in the option too.)
+#
+# Note that the 'on' and 'off' keywords, while valid on both option
+# and chunk, should not be used in this file because they force the
+# relevant options on or off.
+
+#----------------------------------------------------------------------
+
+# The following setting, option and chunk values can all be changed
+# while building libpng:
+#
+# setting: change 'setting' lines to fine tune library performance;
+#   changes to the settings don't affect the libpng API functionally
+#
+# option: change 'option' lines to remove or add capabilities from
+#   or to the library; options change the library API
+#
+# chunk: change 'chunk' lines to remove capabilities to process
+#   optional ('ancillary') chunks.  This does not prevent PNG
+#   decoding but does change the libpng API because some chunks
+#   will be ignored.
+#
+# There are three ways of disabling features, in no particular order:
+#
+# 1) Create 'pngusr.h', enter the required private build information
+# detailed below and #define PNG_NO_<option> for each option you
+# don't want in that file in that file.  You can also turn on options
+# using PNG_<option>_SUPPORTED.  When you have finished rerun
+# configure and rebuild pnglibconf.h file with -DPNG_USER_CONFIG:
+#
+#  make clean
+#  CPPFLAGS='-DPNG_USER_CONFIG' ./configure
+#  make pnglibconf.h
+#
+# pngusr.h is only used during the creation of pnglibconf.h, but it
+# is safer to ensure that -DPNG_USER_CONFIG is specified throughout
+# the build by changing the CPPFLAGS passed to the initial ./configure
+#
+# 2) Add definitions of the settings you want to change to
+# CPPFLAGS; for example:
+#
+#   -DPNG_DEFAULT_READ_MACROS=0
+#
+# (This would change the default to *not* use read macros.)  Be
+# very careful to change only settings that don't alter the API
+# because this approach bypasses the private build checking.  You
+# can also change settings from pngpriv.h (read pngpriv.h) safely
+# without API changes.  Do that in the same way.
+#
+# 3) Write a new '.dfa' file (say 'pngusr.dfa') and in this file
+# provide override values for setting entries and turn option or
+# chunk values explicitly 'on' or 'off':
+#
+#    setting FOO default VALUE
+#    option BAR [on|off]
+#
+# Then add this file to the options.awk command line (the *first*
+# one) after this file.  The make macro DFA_XTRA is provided to make
+# this easier (set it like CPPFLAGS prior to running ./configure).
+# Look at the builds below contrib/pngminim for some extreme examples
+# of how this can be used.
+#
+# Don't edit this file unless you are contributing a patch to
+# libpng and need new or modified options/settings.
+#----------------------------------------------------------------------
+
+# The following causes commented out #undef lines to be written to
+# pnglibconf.h; this can be stopped by logunsupported=0 in a later
+# file or on the command line (after pnglibconf.dfa)
+
+logunsupported = 1
+
+# The following allows the output from configure to modify the contents of
+# pnglibconf.h
+
+@#ifdef HAVE_CONFIG_H
+@#  include "config.h"
+@#endif
+
+# PNG_USER_CONFIG has to be defined on the compiler command line
+# to cause pngusr.h to be read while constructing pnglibconf.h
+#
+# If you create a private DLL you need to define the following
+# macros in the file 'pngusr.h' and set -DPNG_USER_CONFIG for
+# compilation (i.e. in CPPFLAGS.)
+# #define PNG_USER_PRIVATEBUILD \
+#     <Describes by whom and why this version of the DLL was built>
+#  e.g. #define PNG_USER_PRIVATEBUILD "Build by MyCompany for xyz reasons."
+# #define PNG_USER_DLLFNAME_POSTFIX <two-letter postfix that serve to
+#        distinguish your DLL from those of the official release. These
+#        correspond to the trailing letters that come after the version
+#        number and must match your private DLL name>
+#  e.g. // private DLL "libpng13gx.dll"
+#       #define PNG_USER_DLLFNAME_POSTFIX "gx"
+#
+# The following macros are also at your disposal if you want to complete the
+# DLL VERSIONINFO structure.
+# - PNG_USER_VERSIONINFO_COMMENTS
+# - PNG_USER_VERSIONINFO_COMPANYNAME
+# - PNG_USER_VERSIONINFO_LEGALTRADEMARKS
+
+# It is necessary to include configures definitions here so that AC_DEFINE
+# in configure.ac works in a comprehensible way
+@#if defined(HAVE_CONFIG_H) && !defined(PNG_NO_CONFIG_H)
+@#  include "config.h"
+@#endif
+
+@#ifdef PNG_USER_CONFIG
+@#  include "pngusr.h"
+@#endif
+
+# This is a special fixup for the Watcom C compiler on Windows, which has
+# multiple procedure call standards.  Unless PNG_API_RULE is set explicitly
+# (i.e. if it is not defined at this point) it will be forced to '2' here when
+# using Watcom.  This indicates to the other header files that Watcom behaviour
+# is required where appropriate.
+
+@#ifdef __WATCOMC__
+@#  ifndef PNG_API_RULE
+@#     define PNG_API_RULE 2 /* Use Watcom calling conventions */
+@#  endif
+@#endif
+
+# IN DEVELOPMENT
+# These are currently experimental features; define them if you want (NOTE:
+# experimental options must be disabled before they are defined in this file!)
+
+# NONE
+
+# Note that PNG_USER_CONFIG only has an effect when building
+# pnglibconf.h
+
+setting USER_CONFIG
+setting USER_PRIVATEBUILD
+setting USER_DLLFNAME_POSTFIX
+setting USER_VERSIONINFO_COMMENTS
+setting USER_VERSIONINFO_COMPANYNAME
+setting USER_VERSIONINFO_LEGALTRADEMARKS
+
+# Record the 'API rule' used to select calling conventions on
+# those systems that support such things (see all the comments in
+# pngconf.h)
+# Changing this setting has a fundamental affect on the PNG ABI,
+# do not release shared libraries with this changed.
+
+setting API_RULE default 0
+
+# This allows a prefix to be added to the front of every API function name (and
+# therefore every symbol) by redefining all the function names with the prefix
+# at the end of pnglibconf.h.  It also turns on similar internal symbol renaming
+# by causing a similar build-time only file, pngprefix.h, to be generated.
+
+setting PREFIX
+
+# Implementation specific control of the optimizations, enabled by those
+# hardware or software options that need it (typically when run-time choices
+# must be made by the user)
+option SET_OPTION disabled
+
+# These options are specific to the ARM NEON hardware optimizations.  At present
+# these optimizations depend on GCC specific pre-processing of an assembler (.S)
+# file so they probably won't work with other compilers.
+#
+# ARM_NEON_OPT: unset: check at compile time (__ARM_NEON__ must be defined by
+#                      the compiler, typically as a result of specifying
+#                      CC="gcc -mfpu=neon".)
+#                   0: disable (even if the CPU has a NEON FPU.)
+#                   1: check at run time (via ARM_NEON_{API,CHECK})
+#                   2: switch on unconditionally (inadvisable - instead pass
+#                      -mfpu=neon to GCC in CC)
+#           When building libpng avoid using any setting other than '0'; '1' is
+#           set automatically when either 'API' or 'CHECK' are configured in,
+#           '2' should not be necessary as -mfpu=neon will achieve the same
+#           effect as well as applying NEON optimizations to the rest of the
+#           libpng code.
+#           NOTE: any setting other than '0' requires ALIGNED_MEMORY
+# ARM_NEON_API:   (PNG_ARM_NEON == 1) allow the optimization to be switched on
+#                 with png_set_option
+# ARM_NEON_CHECK: (PNG_ARM_NEON == 1) compile a run-time check to see if Neon
+#                 extensions are supported. This is poorly supported and
+#                 deprecated - use the png_set_option API.
+setting ARM_NEON_OPT
+option ARM_NEON_API disabled requires ALIGNED_MEMORY enables SET_OPTION,
+   sets ARM_NEON_OPT 1
+option ARM_NEON_CHECK disabled requires ALIGNED_MEMORY,
+   sets ARM_NEON_OPT 1
+
+# These options are specific to the PowerPC VSX hardware optimizations.
+#
+# POWERPC_VSX_OPT: unset: check at compile time (__PPC64__,__ALTIVEC__,__VSX__
+#                      must be defined by the compiler, typically as a result
+#                      of specifying
+#                      "-mvsx -maltivec" compiler flags)
+#                   0: disable (even if the CPU supports VSX.)
+#                   1: check at run time (via POWERPC_VSX_{API,CHECK})
+#                   2: switch on unconditionally (inadvisable - instead pass
+#                      -mvsx -maltivec to compiler options)
+#           When building libpng avoid using any setting other than '0'; '1' is
+#           set automatically when either 'API' or 'CHECK' are configured in,
+#           '2' should not be necessary as "-mvsx -maltivec" will achieve the same
+#           effect as well as applying VSX optimizations to the rest of the
+#           libpng code.
+# POWERPC_VSX_API:   (PNG_POWERPC_VSX == 1) allow the optimization to be switched on
+#                 with png_set_option
+# POWERPC_VSX_CHECK: (PNG_POWERPC_VSX == 1) compile a run-time check to see if VSX
+#                 extensions are supported. This is supported not for all OSes
+#                 (see contrib/powerpc/README)
+setting POWERPC_VSX_OPT
+option POWERPC_VSX_API disabled enables SET_OPTION,
+  sets POWERPC_VSX_OPT 1
+option POWERPC_VSX_CHECK disabled,
+  sets POWERPC_VSX_OPT 1
+
+
+# These settings configure the default compression level (0-9) and 'strategy';
+# strategy is as defined by the implementors of zlib. It describes the input
+# data and modifies the zlib parameters in an attempt to optimize the balance
+# between search and huffman encoding in the zlib algorithms.  The defaults are
+# the zlib.h defaults - the apparently recursive definition does not arise
+# because the name of the setting is prefixed by PNG_
+#
+# The TEXT values are the defaults when writing compressed text (all forms)
+
+# Include the zlib header so that the defaults below are known
+@#  include <zlib.h>
+
+# The '@' here means to substitute the value when pnglibconf.h is built
+setting Z_DEFAULT_COMPRESSION default @Z_DEFAULT_COMPRESSION
+# TODO: why aren't these Z_RLE; zlib.h says that Z_RLE, specifically, is
+# appropriate for PNG images, maybe it doesn't exist in all versions?
+setting Z_DEFAULT_STRATEGY default @Z_FILTERED
+setting Z_DEFAULT_NOFILTER_STRATEGY default @Z_DEFAULT_STRATEGY
+setting ZLIB_VERNUM default @ZLIB_VERNUM
+
+# Linkage of:
+#
+#  API:      libpng API functions
+#  CALLBACK: internal non-file-local callbacks
+#  FUNCTION: internal non-file-local functions
+#  DATA:     internal non-file-local (const) data
+setting LINKAGE_API default extern
+setting LINKAGE_CALLBACK default extern
+setting LINKAGE_FUNCTION default extern
+setting LINKAGE_DATA default extern
+
+setting TEXT_Z_DEFAULT_COMPRESSION default @Z_DEFAULT_COMPRESSION
+setting TEXT_Z_DEFAULT_STRATEGY default @Z_DEFAULT_STRATEGY
+
+# Default to using the read macros
+
+setting DEFAULT_READ_MACROS default 1
+
+# The alternative is to call functions to read PNG values, if
+# the functions are turned *off* the read macros must always
+# be enabled, so turning this off will actually force the
+# USE_READ_MACROS option on (see pngconf.h)
+
+option READ_INT_FUNCTIONS requires READ
+
+# The same for write  but these can only be switched off if no writing
+# is required at all - hence the use of a 'disabled', not a 'requires'.
+# If these are needed, they are enabled in the 'WRITE options' section
+# below.
+
+option WRITE_INT_FUNCTIONS disabled
+
+# Error controls
+#
+# WARNINGS: normally on, if off no warnings are generated
+# ERROR_TEXT: normally on, if off errors happen but there is no message
+# ERROR_NUMBERS: unimplemented feature, therefore disabled
+# BENIGN_ERRORS: support for just issuing warnings for recoverable errors
+#
+# BENIGN_READ_ERRORS:
+#     By default recoverable errors on read should just generate warnings,
+#     generally safe but PNG files that don't conform to the specification will
+#     be accepted if a meaningful result can be produced.
+#
+# BENIGN_WRITE_ERRORS:
+#     By default recoverable errors on write should just generate warnings,
+#     not generally safe because this allows the application to write invalid
+#     PNG files.  Applications should enable this themselves; it's useful
+#     because it means that a failure to write an ancillary chunk can often be
+#     ignored.
+
+option WARNINGS
+option ERROR_TEXT
+option ERROR_NUMBERS disabled
+
+option BENIGN_ERRORS
+option BENIGN_WRITE_ERRORS requires BENIGN_ERRORS disabled
+option BENIGN_READ_ERRORS requires BENIGN_ERRORS
+
+
+# Generic options - affect both read and write.
+
+option MNG_FEATURES
+
+# Arithmetic options, the first is the big switch that chooses between internal
+# floating and fixed point arithmetic implementations - it does not affect any
+# APIs.  The second two (the _POINT settings) switch off individual APIs.
+#
+# Prior to libpng 1.6.8 one of the API (_POINT) variants had to be selected.  At
+# 1.6.8 this restriction has been removed; the simplified API can be used
+# without enabling any of the low level fixed/floating APIs.
+
+option FLOATING_ARITHMETIC
+option FLOATING_POINT
+option FIXED_POINT
+
+# This protects us against compilers that run on a windowing system
+# and thus don't have or would rather us not use the stdio types:
+# stdin, stdout, and stderr.  The only one currently used is stderr
+# in png_error() and png_warning().  #defining PNG_NO_CONSOLE_IO will
+# prevent these from being compiled and used. #defining PNG_NO_STDIO
+# will also prevent these, plus will prevent the entire set of stdio
+# macros and functions (FILE *, printf, etc.) from being compiled and used,
+# unless (PNG_DEBUG > 0) has been #defined.
+
+option STDIO
+option CONSOLE_IO requires STDIO
+
+# Note: prior to 1.5.0 this option could not be disabled if STDIO
+# was enabled.  Prior to 1.5.3 this option required STDIO
+
+option TIME_RFC1123
+
+# PNG_SETJMP_NOT_SUPPORTED is an old equivalent for NO_SETJMP
+
+option SETJMP
+= NO_SETJMP SETJMP_NOT_SUPPORTED
+
+# If this is disabled it is not possible for apps to get the
+# values from the 'info' structure, this effectively removes
+# quite a lot of the READ API.
+
+option EASY_ACCESS
+
+# Added at libpng-1.2.0
+
+option USER_MEM
+
+# Added at libpng-1.4.0
+
+option IO_STATE
+
+# Libpng limits: limit the size of images and data on read.
+#
+# If this option is disabled all the limit checking code will be disabled:
+
+option USER_LIMITS requires READ
+
+# The default settings given below for the limits mean that libpng will
+# limit the size of images or the size of data in ancillary chunks to less
+# than the specification or implementation limits. Settings have the
+# following interpretations:
+#
+# USER_WIDTH_MAX: maximum width of an image that will be read
+# USER_HEIGHT_MAX: maximum height
+# USER_CHUNK_MALLOC_MAX: maximum in-memory (decompressed) size of a single chunk
+# USER_CHUNK_CACHE_MAX: maximum number of chunks to be cached
+#
+# Only chunks that are variable in number are counted towards the
+
+# Use 0x7fffffff for unlimited
+setting USER_WIDTH_MAX default        1000000
+setting USER_HEIGHT_MAX default       1000000
+
+# Use 0 for unlimited
+setting USER_CHUNK_CACHE_MAX default     1000
+setting USER_CHUNK_MALLOC_MAX default 8000000
+
+# If this option is enabled APIs to set the above limits at run time are added;
+# without this the hardwired (compile time) limits will be used.
+option SET_USER_LIMITS requires USER_LIMITS
+
+# All of the following options relate to code capabilities for
+# processing image data before creating a PNG or after reading one.
+# You can remove these capabilities safely and still be PNG
+# conformant, however the library that results is still non-standard.
+# See the comments above about how to change options and settings.
+
+# READ options
+#
+# WARNING: in libpng 1.5 maintained configuration compatibility with earlier
+# versions.  In some cases turning off an option turned off other options, in
+# others it was ineffective unless dependent options were also turned off.
+# Libpng 1.6 changes this: in general if you turn off an option that affects
+# APIs it stays off and simply disables APIs that depend on it.
+#
+# As a result if you simply port the libpng 1.5 configuration to libpng 1.6 you
+# will probably see build failures due to missing APIs.  Fixing these failures
+# requires some, perhaps considerable, knowledge of what your libpng using
+# applications are doing, fortunately there is no great reason for you to move
+# to libpng 1.6; the new interfaces in 1.6 will take several years to become
+# popular.
+
+option READ enables READ_INTERLACING SET_OPTION
+
+# Disabling READ_16BIT does not disable reading 16-bit PNG files, but it
+# forces them to be chopped down to 8-bit, and disables any 16-bit
+# processing after that has happened.  You need to be sure to enable
+# READ_SCALE_16_TO_8 or READ_STRIP_16_TO_8 when you disable READ_16BIT for
+# this to work properly.  You should disable the other option if you need to
+# ensure a particular conversion (otherwise the app can chose.)
+
+option READ_16BIT requires READ enables 16BIT
+
+option READ_QUANTIZE requires READ
+
+option READ_TRANSFORMS requires READ
+= NO_READ_TRANSFORMS READ_TRANSFORMS_NOT_SUPPORTED
+
+# Read gamma handling.  Gamma processing is a core part of libpng and many of
+# the capabilities are dependent on libpng performing gamma correction.
+#
+# In libpng 1.6 disabling gamma processing (setting PNG_NO_READ_GAMMA)
+# consistently disables those parts of the API that depend on it.  Prior to
+# 1.6.0 this was not true; the results were unpredictable and varied between
+# releases.
+#
+# If you disable gamma processing and your program no longer compiles you need
+# to ask whether you really need the APIs that are missing.  If you do then you
+# almost certainly need the gamma processing.
+#
+# If you handle gamma issues outside libpng then you do not need the libpng
+# gamma processing; and it is an enormous waste of space.  You just need to
+# remove the use of libpng APIs that depend on it.
+option READ_GAMMA requires READ_TRANSFORMS, READ_gAMA, READ_sRGB
+
+option READ_ALPHA_MODE requires READ_TRANSFORMS, READ_GAMMA
+option READ_BACKGROUND requires READ_TRANSFORMS, READ_STRIP_ALPHA, READ_GAMMA
+option READ_BGR requires READ_TRANSFORMS
+option READ_EXPAND_16 requires READ_TRANSFORMS, READ_16BIT, READ_EXPAND
+option READ_EXPAND requires READ_TRANSFORMS
+option READ_FILLER requires READ_TRANSFORMS
+option READ_GRAY_TO_RGB requires READ_TRANSFORMS
+option READ_INVERT_ALPHA requires READ_TRANSFORMS
+option READ_INVERT requires READ_TRANSFORMS
+option READ_PACK requires READ_TRANSFORMS
+option READ_PACKSWAP requires READ_TRANSFORMS
+option READ_RGB_TO_GRAY requires READ_TRANSFORMS, READ_GAMMA enables COLORSPACE
+option READ_SCALE_16_TO_8 requires READ_TRANSFORMS
+option READ_SHIFT requires READ_TRANSFORMS
+option READ_STRIP_16_TO_8 requires READ_TRANSFORMS
+option READ_STRIP_ALPHA requires READ_TRANSFORMS
+option READ_SWAP_ALPHA requires READ_TRANSFORMS
+option READ_SWAP requires READ_TRANSFORMS, READ_16BIT
+option READ_USER_TRANSFORM requires READ_TRANSFORMS
+
+option PROGRESSIVE_READ requires READ
+option SEQUENTIAL_READ requires READ
+
+# You can define PNG_NO_PROGRESSIVE_READ if you don't do progressive reading.
+# This is not talking about interlacing capability!  You'll still have
+# interlacing unless you turn off the following which is required
+# for PNG-compliant decoders.  (In other words, do not do this - in
+# fact it can't be disabled from the command line!)
+#option READ_INTERLACING requires READ
+
+option READ_COMPOSITE_NODIV requires READ
+= NO_READ_COMPOSITE_NODIV NO_READ_COMPOSITED_NODIV
+
+# Inch conversions
+
+option INCH_CONVERSIONS
+= INCH_CONVERSIONS INCH_CONVERSIONS
+
+# API to build a grayscale palette
+# NOTE: this is not used internally by libpng at present.
+
+option BUILD_GRAYSCALE_PALETTE
+
+# WRITE options
+
+option WRITE enables WRITE_INT_FUNCTIONS
+
+# Disabling WRITE_16BIT prevents 16-bit PNG files from being
+# generated.
+option WRITE_16BIT requires WRITE enables 16BIT
+
+option WRITE_TRANSFORMS requires WRITE
+= NO_WRITE_TRANSFORMS WRITE_TRANSFORMS_NOT_SUPPORTED
+
+option WRITE_SHIFT requires WRITE_TRANSFORMS
+option WRITE_PACK requires WRITE_TRANSFORMS
+option WRITE_BGR requires WRITE_TRANSFORMS
+option WRITE_SWAP requires WRITE_TRANSFORMS, WRITE_16BIT
+option WRITE_PACKSWAP requires WRITE_TRANSFORMS
+option WRITE_INVERT requires WRITE_TRANSFORMS
+option WRITE_FILLER requires WRITE_TRANSFORMS
+option WRITE_SWAP_ALPHA requires WRITE_TRANSFORMS
+option WRITE_INVERT_ALPHA requires WRITE_TRANSFORMS
+option WRITE_USER_TRANSFORM requires WRITE_TRANSFORMS
+
+# This is not required for PNG-compliant encoders, but can cause
+# trouble if left undefined
+
+option WRITE_INTERLACING requires WRITE
+
+# Deprecated, will be removed.
+option WRITE_WEIGHTED_FILTER requires WRITE
+
+option WRITE_FLUSH requires WRITE
+
+# Note: these can be turned off explicitly if not required by the
+# apps implementing the user transforms
+option USER_TRANSFORM_PTR if READ_USER_TRANSFORM, WRITE_USER_TRANSFORM
+option USER_TRANSFORM_INFO if READ_USER_TRANSFORM, WRITE_USER_TRANSFORM
+
+# This enables API to set compression parameters for compressing
+# non-IDAT chunks (zTXt, iTXt, iCCP, and unknown chunks).  This feature
+# was added at libpng-1.5.3.
+option WRITE_CUSTOMIZE_ZTXT_COMPRESSION requires WRITE
+option WRITE_CUSTOMIZE_COMPRESSION requires WRITE
+
+# Any chunks you are not interested in, you can undef here.  The
+# ones that allocate memory may be especially important (hIST,
+# tEXt, zTXt, tRNS, pCAL).  Others will just save time and make png_info
+# a bit smaller.
+
+# The size of the png_text structure changed in libpng-1.0.6 when
+# iTXt support was added.  iTXt support was turned off by default through
+# libpng-1.2.x, to support old apps that malloc the png_text structure
+# instead of calling png_set_text() and letting libpng malloc it.  It
+# was turned on by default in libpng-1.4.0.
+
+option READ_ANCILLARY_CHUNKS requires READ
+# PNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED is deprecated.
+= NO_READ_ANCILLARY_CHUNKS READ_ANCILLARY_CHUNKS_NOT_SUPPORTED
+
+option WRITE_ANCILLARY_CHUNKS requires WRITE
+# PNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED is deprecated.
+= NO_WRITE_ANCILLARY_CHUNKS WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED
+
+# These options disable *all* the text chunks if turned off
+
+option TEXT disabled
+option READ_TEXT requires READ_ANCILLARY_CHUNKS enables TEXT
+option WRITE_TEXT requires WRITE_ANCILLARY_CHUNKS enables TEXT
+
+# Moved to pnglibconf.h at libpng-1.5.0
+# Feature support: in 1.4 this was in pngconf.h, but the following
+# features have no affect on the libpng API.  Add library
+# only features to the end of this list.  Add features that
+# affect the API above.  (Note: the list of chunks follows
+# the library-only settings.)
+#
+# BUILD TIME ONLY OPTIONS
+#   These options do not affect the API but rather alter how the
+#   API is implemented, they get recorded in pnglibconf.h, but
+#   can't be changed by the application.
+
+# Colorspace support (enabled as required); just the support for colorant
+# information.  Gamma support, likewise, is just support for the gamma
+# information, READ_GAMMA is required for gamma transformations (so it
+# is possible to read PNG gamma without enabling all the libpng transform
+# code - do this for applications that do their own gamma processing)
+#
+# As of 1.6.0 COLORSPACE is only useful if the application processes the
+# information; this is because the library does not do any colorspace
+# processing, it just validates the data in the PNG file.
+
+option GAMMA disabled
+option COLORSPACE enables GAMMA disabled
+
+# When an ICC profile is read, or png_set, it will be checked for a match
+# against known sRGB profiles if the sRGB handling is enabled.  The
+# PNG_sRGB_PROFILE_CHECKS setting controls how much work is done during the
+# check:
+#
+# -1: Don't do any sRGB profile checking.
+#
+#  0: Just validate the profile MD5 signature if present, otherwise use
+#     the checks in option 1.
+#
+#  1: Additionally check the length, intent and adler32 checksum of the
+#     actual data.   If enabled this will reject known profiles that have
+#     had the rendering intent in the header changed as well as other edits
+#     done without updating the checksum.  See the discussion below.
+#
+#  2: Additionally checksum all the data using the ethernet CRC32 algorithm.
+#     This makes it more difficult to fake profiles and makes it less likely
+#     to get a false positive on profiles with no signature, but is probably
+#     just a waste of time since all currently approved ICC sRGB profiles have
+#     a secure MD5 signature.
+#
+# The rendering intent.  An ICC profile stores an intended rendering intent,
+# but does not include the value in the signature.  The intent is documented
+# as the intent that should be used when combining two profiles.  The sRGB
+# profile is intended, however, to be used with any of the four defined intents.
+# For this reason the sRGB chunk includes an 'intent' to be used when displaying
+# the image (intent is really a property of the image not the profile.)
+#
+# Unfortunately the iCCP chunk does not.  It may therefore be that some
+# applications modify the intent in profiles (including sRGB profiles) to work
+# round this problem.  Selecting an option other than option '0' will cause such
+# modified profiles to be rejected.
+#
+# Security.  The use of Adler32 and CRC32 checksums does not help significantly
+# with any security issues.  It is relatively easy to produce arbitrary profiles
+# with the required checksums on current computer systems.  Nevertheless
+# security does not seem to be an issue because the only consequence of a false
+# positive is a false assertion that the profile is an sRGB profile.  This might
+# be used to hide data from libpng using applications, but it doesn't seem
+# possible to damage them.
+
+setting sRGB_PROFILE_CHECKS default 2
+
+# Artificially align memory - the code typically aligns to 8 byte
+# boundaries if this is switched on, it's a small waste of space
+# but can help (in theory) on some architectures.  Only affects
+# internal structures.  Added at libpng 1.4.0
+
+option ALIGNED_MEMORY
+
+# Buggy compilers (e.g., gcc 2.7.2.2) need PNG_NO_POINTER_INDEXING
+# See png[wr]util.c, normally this should always be *on*
+
+option POINTER_INDEXING
+
+# Other defines for things like memory and the like can go here.
+
+# BUILD TIME SETTINGS
+# Like build time options these do not affect the API, but they
+# may be useful to applications because they record details of
+# how the API will behave particularly with regard to overall
+# accuracy.
+
+# This controls how fine the quantizing gets.  As this allocates
+# a largish chunk of memory (32K), those who are not as concerned
+# with quantizing quality can decrease some or all of these.
+
+setting QUANTIZE_RED_BITS default 5
+setting QUANTIZE_GREEN_BITS default 5
+setting QUANTIZE_BLUE_BITS default 5
+
+# This controls how fine the gamma correction becomes when you
+# are only interested in 8 bits anyway.  Increasing this value
+# results in more memory being used, and more pow() functions
+# being called to fill in the gamma tables.  Don't set this value
+# less than 8, and even that may not work (I haven't tested it).
+
+setting MAX_GAMMA_8 default 11
+
+# This controls how much a difference in gamma we can tolerate before
+# we actually start doing gamma conversion, it's a fixed point value,
+# so the default below is 0.05, meaning libpng ignores corrections in
+# the range 0.95 to 1.05
+
+setting GAMMA_THRESHOLD_FIXED default 5000
+
+# Precision to use when converting a floating point value to a PNG
+# extension format string in an sCAL chunk (only relevant if the
+# floating point API is enabled)
+
+setting sCAL_PRECISION default 5
+
+# This is the size of the compression buffer, and thus the size of
+# an IDAT chunk.  Make this whatever size you feel is best for your
+# machine.  One of these will be allocated per png_struct.  When this
+# is full, it writes the data to the disk, and does some other
+# calculations.  Making this an extremely small size may slow
+# the library down, but you may want to experiment to determine
+# where it becomes significant, if you are concerned with memory
+# usage.  Note that zlib allocates at least 32Kb also.  For readers,
+# this describes the size of the buffer available to read the data in.
+# Unless this gets smaller than the size of a row (compressed),
+# it should not make much difference how big this is.
+
+setting ZBUF_SIZE default 8192
+
+# This is the size of the decompression buffer used when counting or checking
+# the decompressed size of an LZ stream from a compressed ancillary chunk; the
+# decompressed data is never used so a different size may be optimal.  This size
+# was determined using contrib/libtests/timepng.c with compressed zTXt data
+# around 11MByte in size.  Slight speed improvements (up to about 14% in
+# timepng) can be achieved by very large increases (to 32kbyte) on regular data,
+# but highly compressible data shows only around 2% improvement.   The size is
+# chosen to minimize the effects of DoS attacks based on using very large
+# amounts of highly compressible data.
+
+setting INFLATE_BUF_SIZE default 1024
+
+# This is the maximum amount of IDAT data that the sequential reader will
+# process at one time.  The setting does not affect the size of IDAT chunks
+# read, just the amount read at once.  Neither does it affect the progressive
+# reader, which processes just the amount of data the application gives it.
+# The sequential reader is currently unable to process more than one IDAT at
+# once - it has to read and process each one in turn.  There is no point setting
+# this to a value larger than the IDAT chunks typically encountered (it would
+# just waste memory) but there may be some point in reducing it below the value
+# of ZBUF_SIZE (the size of IDAT chunks written by libpng.)
+
+setting IDAT_READ_SIZE default PNG_ZBUF_SIZE
+
+# Ancillary chunks
+chunk bKGD
+chunk cHRM enables COLORSPACE
+chunk eXIf
+chunk gAMA enables GAMMA
+chunk hIST
+chunk iCCP enables COLORSPACE, GAMMA
+chunk iTXt enables TEXT
+chunk oFFs
+chunk pCAL
+chunk pHYs
+chunk sBIT
+chunk sCAL
+chunk sPLT
+chunk sRGB enables COLORSPACE, GAMMA, SET_OPTION
+chunk tEXt requires TEXT
+chunk tIME
+chunk tRNS
+chunk zTXt enables TEXT
+
+# This only affects support of the optional PLTE chunk in RGB and RGBA
+# images.  Notice that READ_ANCILLARY_CHUNKS therefore disables part
+# of the regular chunk reading too.
+
+option READ_OPT_PLTE requires READ_ANCILLARY_CHUNKS
+
+# Unknown chunk handling
+#
+# 'UNKNOWN_CHUNKS' is a global option to disable all unknown chunk handling on
+# read or write; everything else below requires it (directly or indirectly).
+option UNKNOWN_CHUNKS
+
+# There are three main options to control the ability to read and write unknown
+# chunks.  If either read option is turned on then unknown chunks will be read,
+# otherwise they are skipped.  If the write option is turned on unknown chunks
+# set by png_set_unknown_chunks will be written otherwise it is an error to call
+# that API on a write struct.
+option WRITE_UNKNOWN_CHUNKS requires WRITE requires UNKNOWN_CHUNKS
+option WRITE_UNKNOWN_CHUNKS enables STORE_UNKNOWN_CHUNKS
+
+# The first way to read user chunks is to have libpng save them for a later call
+# to png_get_unknown_chunks, the application must call
+# png_set_keep_unknown_chunks to cause this to actually happen (see png.h)
+option SAVE_UNKNOWN_CHUNKS requires READ requires SET_UNKNOWN_CHUNKS
+option SAVE_UNKNOWN_CHUNKS enables READ_UNKNOWN_CHUNKS, STORE_UNKNOWN_CHUNKS
+
+# The second approach is to use an application provided callback to process the
+# chunks, the callback can either handle the chunk entirely itself or request
+# that libpng store the chunk for later retrieval via png_get_unknown_chunks.
+#
+# NOTE: If STORE_UNKNOWN_CHUNKS is not enabled (which is the default if
+# both SAVE_UNKNOWN_CHUNKS and WRITE_UNKNOWN_CHUNKS are disabled) then a
+# 0 result from the callback will be ignored because no support for saving
+# unknown chunks has been compiled in.  The normal symptom is that your app
+# fails to compile because png_get_unknown_chunks is no longer defined in png.h.
+# If you encounter this issue simply enable STORE_UNKNOWN_CHUNKS in your build.
+#
+# Note that there is no 'WRITE_USER_CHUNKS' so the USER_CHUNKS option is always
+# the same as READ_USER_CHUNKS at present
+option READ_USER_CHUNKS requires READ, UNKNOWN_CHUNKS
+option READ_USER_CHUNKS enables READ_UNKNOWN_CHUNKS, USER_CHUNKS
+
+# Two further options are provided to allow detailed control of the handling.
+# The first enables png_set_keep_unknown_chunks; this allows the default to be
+# changed from discarding unknown chunks and allows per-chunk control.  This is
+# required to use the SAVE_UNKNOWN_CHUNKS option.  If enabled this option also
+# applies to write (see png.h), otherwise the write API simply writes all the
+# chunks it is given.
+#
+# The second option extends the unknown handling to allow known chunks to be
+# handled as though they were unknown.  This option doesn't change any APIs, it
+# merely turns on the code to check known as well as unknown chunks.
+#
+# This option no longer affects the write code.  It can be safely disabled and
+# will prevent applications stopping libpng reading known chunks.
+option SET_UNKNOWN_CHUNKS requires UNKNOWN_CHUNKS
+option HANDLE_AS_UNKNOWN requires SET_UNKNOWN_CHUNKS
+
+# The following options are derived from the above and should not be turned on
+# explicitly.
+option READ_UNKNOWN_CHUNKS requires UNKNOWN_CHUNKS disabled
+option STORE_UNKNOWN_CHUNKS requires UNKNOWN_CHUNKS disabled
+
+option CONVERT_tIME requires WRITE_ANCILLARY_CHUNKS
+# The "tm" structure is not supported on WindowsCE
+
+@#ifdef _WIN32_WCE
+@#   define PNG_NO_CONVERT_tIME
+@#endif
+
+option WRITE_FILTER requires WRITE
+
+option SAVE_INT_32 disabled
+# png_save_int_32 is required internally for writing the ancillary chunks oFFs
+# and pCAL and for both reading and writing iCCP (for the generation/checking of
+# the corresponding cHRM/gAMA chunks) if full ICC is supported.
+
+# added at libpng-1.5.4
+
+option WRITE_OPTIMIZE_CMF requires WRITE
+
+option READ_COMPRESSED_TEXT disabled
+option READ_iCCP enables READ_COMPRESSED_TEXT
+option READ_iTXt enables READ_COMPRESSED_TEXT
+option READ_zTXt enables READ_COMPRESSED_TEXT
+
+option WRITE_oFFs enables SAVE_INT_32
+option WRITE_pCAL enables SAVE_INT_32
+option WRITE_cHRM enables SAVE_INT_32
+
+option WRITE_COMPRESSED_TEXT disabled
+option WRITE_iCCP enables WRITE_COMPRESSED_TEXT
+option WRITE_iTXt enables WRITE_COMPRESSED_TEXT
+option WRITE_zTXt enables WRITE_COMPRESSED_TEXT
+
+# Turn this off to disable png_read_png() and png_write_png() and
+# leave the row_pointers member out of the info structure.
+
+option INFO_IMAGE
+
+# added at libpng-1.5.10
+# Turn this off to disable warning about invalid palette index and
+# leave the num_palette_max member out of the png structure.
+
+option CHECK_FOR_INVALID_INDEX enables READ_CHECK_FOR_INVALID_INDEX
+option CHECK_FOR_INVALID_INDEX enables WRITE_CHECK_FOR_INVALID_INDEX
+option READ_CHECK_FOR_INVALID_INDEX requires READ, CHECK_FOR_INVALID_INDEX
+option WRITE_CHECK_FOR_INVALID_INDEX requires WRITE, CHECK_FOR_INVALID_INDEX
+
+# added at libpng-1.5.15
+option GET_PALETTE_MAX enables READ_GET_PALETTE_MAX WRITE_GET_PALETTE_MAX
+option READ_GET_PALETTE_MAX requires READ_CHECK_FOR_INVALID_INDEX disabled
+option WRITE_GET_PALETTE_MAX requires WRITE_CHECK_FOR_INVALID_INDEX disabled
+
+# Simplified API options (added at libpng-1.6.0)
+#  In libpng 1.6.8 the handling of these options was changed to used 'requires'
+#  throughout, so that disabling some of the low level support always disables
+#  the base simplified read/write API.  This much simplifies the handling and
+#  makes 'everything = off' work in a more intuitive way.  It eliminates a
+#  previously reported feature that APIs previously enabled by the simplified
+#  API couldn't be turned off without explicitly turning off the simplified
+#  APIs.
+#
+# Read:
+option SIMPLIFIED_READ,
+   requires SEQUENTIAL_READ, READ_TRANSFORMS, SETJMP, BENIGN_ERRORS,
+      READ_EXPAND, READ_16BIT, READ_EXPAND_16, READ_SCALE_16_TO_8,
+      READ_RGB_TO_GRAY, READ_ALPHA_MODE, READ_BACKGROUND, READ_STRIP_ALPHA,
+      READ_FILLER, READ_SWAP, READ_PACK, READ_GRAY_TO_RGB, READ_GAMMA,
+      READ_tRNS, READ_bKGD, READ_gAMA, READ_cHRM, READ_sRGB, READ_sBIT
+
+# AFIRST and BGR read options:
+#  Prior to libpng 1.6.8 these were disabled but switched on if the low level
+#  libpng routines that do the swaps were enabled.  This worked but was
+#  confusing.  In libpng 1.6.8 the options were changed to simple 'requires'
+#  and are enabled by default.  This should work the same way in practice.
+option SIMPLIFIED_READ_AFIRST enables FORMAT_AFIRST,
+   requires SIMPLIFIED_READ READ_SWAP_ALPHA
+
+option SIMPLIFIED_READ_BGR enables FORMAT_BGR,
+   requires SIMPLIFIED_READ READ_BGR
+
+# Write:
+option SIMPLIFIED_WRITE,
+   requires WRITE, SETJMP, WRITE_SWAP, WRITE_PACK,
+      WRITE_tRNS, WRITE_gAMA, WRITE_sRGB, WRITE_cHRM
+
+# 1.6.22: allow simplified write without stdio support:
+option SIMPLIFIED_WRITE_STDIO requires SIMPLIFIED_WRITE STDIO
+
+option SIMPLIFIED_WRITE_AFIRST enables FORMAT_AFIRST,
+   requires SIMPLIFIED_WRITE WRITE_SWAP_ALPHA
+
+option SIMPLIFIED_WRITE_BGR enables FORMAT_BGR,
+   requires SIMPLIFIED_WRITE WRITE_BGR
+
+# Formats:
+option FORMAT_AFIRST disabled
+option FORMAT_BGR disabled
diff --git a/Engine/lib/lpng/scripts/pnglibconf.h.prebuilt b/Engine/lib/lpng/scripts/pnglibconf.h.prebuilt
new file mode 100644
index 000000000..e1e27e957
--- /dev/null
+++ b/Engine/lib/lpng/scripts/pnglibconf.h.prebuilt
@@ -0,0 +1,219 @@
+/* pnglibconf.h - library build configuration */
+
+/* libpng version 1.6.37 */
+
+/* Copyright (c) 2018-2019 Cosmin Truta */
+/* Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson */
+
+/* This code is released under the libpng license. */
+/* For conditions of distribution and use, see the disclaimer */
+/* and license in png.h */
+
+/* pnglibconf.h */
+/* Machine generated file: DO NOT EDIT */
+/* Derived from: scripts/pnglibconf.dfa */
+#ifndef PNGLCONF_H
+#define PNGLCONF_H
+/* options */
+#define PNG_16BIT_SUPPORTED
+#define PNG_ALIGNED_MEMORY_SUPPORTED
+/*#undef PNG_ARM_NEON_API_SUPPORTED*/
+/*#undef PNG_ARM_NEON_CHECK_SUPPORTED*/
+#define PNG_BENIGN_ERRORS_SUPPORTED
+#define PNG_BENIGN_READ_ERRORS_SUPPORTED
+/*#undef PNG_BENIGN_WRITE_ERRORS_SUPPORTED*/
+#define PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED
+#define PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
+#define PNG_COLORSPACE_SUPPORTED
+#define PNG_CONSOLE_IO_SUPPORTED
+#define PNG_CONVERT_tIME_SUPPORTED
+#define PNG_EASY_ACCESS_SUPPORTED
+/*#undef PNG_ERROR_NUMBERS_SUPPORTED*/
+#define PNG_ERROR_TEXT_SUPPORTED
+#define PNG_FIXED_POINT_SUPPORTED
+#define PNG_FLOATING_ARITHMETIC_SUPPORTED
+#define PNG_FLOATING_POINT_SUPPORTED
+#define PNG_FORMAT_AFIRST_SUPPORTED
+#define PNG_FORMAT_BGR_SUPPORTED
+#define PNG_GAMMA_SUPPORTED
+#define PNG_GET_PALETTE_MAX_SUPPORTED
+#define PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+#define PNG_INCH_CONVERSIONS_SUPPORTED
+#define PNG_INFO_IMAGE_SUPPORTED
+#define PNG_IO_STATE_SUPPORTED
+#define PNG_MNG_FEATURES_SUPPORTED
+#define PNG_POINTER_INDEXING_SUPPORTED
+/*#undef PNG_POWERPC_VSX_API_SUPPORTED*/
+/*#undef PNG_POWERPC_VSX_CHECK_SUPPORTED*/
+#define PNG_PROGRESSIVE_READ_SUPPORTED
+#define PNG_READ_16BIT_SUPPORTED
+#define PNG_READ_ALPHA_MODE_SUPPORTED
+#define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED
+#define PNG_READ_BACKGROUND_SUPPORTED
+#define PNG_READ_BGR_SUPPORTED
+#define PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED
+#define PNG_READ_COMPOSITE_NODIV_SUPPORTED
+#define PNG_READ_COMPRESSED_TEXT_SUPPORTED
+#define PNG_READ_EXPAND_16_SUPPORTED
+#define PNG_READ_EXPAND_SUPPORTED
+#define PNG_READ_FILLER_SUPPORTED
+#define PNG_READ_GAMMA_SUPPORTED
+#define PNG_READ_GET_PALETTE_MAX_SUPPORTED
+#define PNG_READ_GRAY_TO_RGB_SUPPORTED
+#define PNG_READ_INTERLACING_SUPPORTED
+#define PNG_READ_INT_FUNCTIONS_SUPPORTED
+#define PNG_READ_INVERT_ALPHA_SUPPORTED
+#define PNG_READ_INVERT_SUPPORTED
+#define PNG_READ_OPT_PLTE_SUPPORTED
+#define PNG_READ_PACKSWAP_SUPPORTED
+#define PNG_READ_PACK_SUPPORTED
+#define PNG_READ_QUANTIZE_SUPPORTED
+#define PNG_READ_RGB_TO_GRAY_SUPPORTED
+#define PNG_READ_SCALE_16_TO_8_SUPPORTED
+#define PNG_READ_SHIFT_SUPPORTED
+#define PNG_READ_STRIP_16_TO_8_SUPPORTED
+#define PNG_READ_STRIP_ALPHA_SUPPORTED
+#define PNG_READ_SUPPORTED
+#define PNG_READ_SWAP_ALPHA_SUPPORTED
+#define PNG_READ_SWAP_SUPPORTED
+#define PNG_READ_TEXT_SUPPORTED
+#define PNG_READ_TRANSFORMS_SUPPORTED
+#define PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
+#define PNG_READ_USER_CHUNKS_SUPPORTED
+#define PNG_READ_USER_TRANSFORM_SUPPORTED
+#define PNG_READ_bKGD_SUPPORTED
+#define PNG_READ_cHRM_SUPPORTED
+#define PNG_READ_eXIf_SUPPORTED
+#define PNG_READ_gAMA_SUPPORTED
+#define PNG_READ_hIST_SUPPORTED
+#define PNG_READ_iCCP_SUPPORTED
+#define PNG_READ_iTXt_SUPPORTED
+#define PNG_READ_oFFs_SUPPORTED
+#define PNG_READ_pCAL_SUPPORTED
+#define PNG_READ_pHYs_SUPPORTED
+#define PNG_READ_sBIT_SUPPORTED
+#define PNG_READ_sCAL_SUPPORTED
+#define PNG_READ_sPLT_SUPPORTED
+#define PNG_READ_sRGB_SUPPORTED
+#define PNG_READ_tEXt_SUPPORTED
+#define PNG_READ_tIME_SUPPORTED
+#define PNG_READ_tRNS_SUPPORTED
+#define PNG_READ_zTXt_SUPPORTED
+#define PNG_SAVE_INT_32_SUPPORTED
+#define PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
+#define PNG_SEQUENTIAL_READ_SUPPORTED
+#define PNG_SETJMP_SUPPORTED
+#define PNG_SET_OPTION_SUPPORTED
+#define PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
+#define PNG_SET_USER_LIMITS_SUPPORTED
+#define PNG_SIMPLIFIED_READ_AFIRST_SUPPORTED
+#define PNG_SIMPLIFIED_READ_BGR_SUPPORTED
+#define PNG_SIMPLIFIED_READ_SUPPORTED
+#define PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED
+#define PNG_SIMPLIFIED_WRITE_BGR_SUPPORTED
+#define PNG_SIMPLIFIED_WRITE_STDIO_SUPPORTED
+#define PNG_SIMPLIFIED_WRITE_SUPPORTED
+#define PNG_STDIO_SUPPORTED
+#define PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
+#define PNG_TEXT_SUPPORTED
+#define PNG_TIME_RFC1123_SUPPORTED
+#define PNG_UNKNOWN_CHUNKS_SUPPORTED
+#define PNG_USER_CHUNKS_SUPPORTED
+#define PNG_USER_LIMITS_SUPPORTED
+#define PNG_USER_MEM_SUPPORTED
+#define PNG_USER_TRANSFORM_INFO_SUPPORTED
+#define PNG_USER_TRANSFORM_PTR_SUPPORTED
+#define PNG_WARNINGS_SUPPORTED
+#define PNG_WRITE_16BIT_SUPPORTED
+#define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED
+#define PNG_WRITE_BGR_SUPPORTED
+#define PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED
+#define PNG_WRITE_COMPRESSED_TEXT_SUPPORTED
+#define PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED
+#define PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
+#define PNG_WRITE_FILLER_SUPPORTED
+#define PNG_WRITE_FILTER_SUPPORTED
+#define PNG_WRITE_FLUSH_SUPPORTED
+#define PNG_WRITE_GET_PALETTE_MAX_SUPPORTED
+#define PNG_WRITE_INTERLACING_SUPPORTED
+#define PNG_WRITE_INT_FUNCTIONS_SUPPORTED
+#define PNG_WRITE_INVERT_ALPHA_SUPPORTED
+#define PNG_WRITE_INVERT_SUPPORTED
+#define PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
+#define PNG_WRITE_PACKSWAP_SUPPORTED
+#define PNG_WRITE_PACK_SUPPORTED
+#define PNG_WRITE_SHIFT_SUPPORTED
+#define PNG_WRITE_SUPPORTED
+#define PNG_WRITE_SWAP_ALPHA_SUPPORTED
+#define PNG_WRITE_SWAP_SUPPORTED
+#define PNG_WRITE_TEXT_SUPPORTED
+#define PNG_WRITE_TRANSFORMS_SUPPORTED
+#define PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
+#define PNG_WRITE_USER_TRANSFORM_SUPPORTED
+#define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
+#define PNG_WRITE_bKGD_SUPPORTED
+#define PNG_WRITE_cHRM_SUPPORTED
+#define PNG_WRITE_eXIf_SUPPORTED
+#define PNG_WRITE_gAMA_SUPPORTED
+#define PNG_WRITE_hIST_SUPPORTED
+#define PNG_WRITE_iCCP_SUPPORTED
+#define PNG_WRITE_iTXt_SUPPORTED
+#define PNG_WRITE_oFFs_SUPPORTED
+#define PNG_WRITE_pCAL_SUPPORTED
+#define PNG_WRITE_pHYs_SUPPORTED
+#define PNG_WRITE_sBIT_SUPPORTED
+#define PNG_WRITE_sCAL_SUPPORTED
+#define PNG_WRITE_sPLT_SUPPORTED
+#define PNG_WRITE_sRGB_SUPPORTED
+#define PNG_WRITE_tEXt_SUPPORTED
+#define PNG_WRITE_tIME_SUPPORTED
+#define PNG_WRITE_tRNS_SUPPORTED
+#define PNG_WRITE_zTXt_SUPPORTED
+#define PNG_bKGD_SUPPORTED
+#define PNG_cHRM_SUPPORTED
+#define PNG_eXIf_SUPPORTED
+#define PNG_gAMA_SUPPORTED
+#define PNG_hIST_SUPPORTED
+#define PNG_iCCP_SUPPORTED
+#define PNG_iTXt_SUPPORTED
+#define PNG_oFFs_SUPPORTED
+#define PNG_pCAL_SUPPORTED
+#define PNG_pHYs_SUPPORTED
+#define PNG_sBIT_SUPPORTED
+#define PNG_sCAL_SUPPORTED
+#define PNG_sPLT_SUPPORTED
+#define PNG_sRGB_SUPPORTED
+#define PNG_tEXt_SUPPORTED
+#define PNG_tIME_SUPPORTED
+#define PNG_tRNS_SUPPORTED
+#define PNG_zTXt_SUPPORTED
+/* end of options */
+/* settings */
+#define PNG_API_RULE 0
+#define PNG_DEFAULT_READ_MACROS 1
+#define PNG_GAMMA_THRESHOLD_FIXED 5000
+#define PNG_IDAT_READ_SIZE PNG_ZBUF_SIZE
+#define PNG_INFLATE_BUF_SIZE 1024
+#define PNG_LINKAGE_API extern
+#define PNG_LINKAGE_CALLBACK extern
+#define PNG_LINKAGE_DATA extern
+#define PNG_LINKAGE_FUNCTION extern
+#define PNG_MAX_GAMMA_8 11
+#define PNG_QUANTIZE_BLUE_BITS 5
+#define PNG_QUANTIZE_GREEN_BITS 5
+#define PNG_QUANTIZE_RED_BITS 5
+#define PNG_TEXT_Z_DEFAULT_COMPRESSION (-1)
+#define PNG_TEXT_Z_DEFAULT_STRATEGY 0
+#define PNG_USER_CHUNK_CACHE_MAX 1000
+#define PNG_USER_CHUNK_MALLOC_MAX 8000000
+#define PNG_USER_HEIGHT_MAX 1000000
+#define PNG_USER_WIDTH_MAX 1000000
+#define PNG_ZBUF_SIZE 8192
+#define PNG_ZLIB_VERNUM 0 /* unknown */
+#define PNG_Z_DEFAULT_COMPRESSION (-1)
+#define PNG_Z_DEFAULT_NOFILTER_STRATEGY 0
+#define PNG_Z_DEFAULT_STRATEGY 1
+#define PNG_sCAL_PRECISION 5
+#define PNG_sRGB_PROFILE_CHECKS 2
+/* end of settings */
+#endif /* PNGLCONF_H */
diff --git a/Engine/lib/lpng/scripts/pnglibconf.mak b/Engine/lib/lpng/scripts/pnglibconf.mak
new file mode 100755
index 000000000..c125ca2c9
--- /dev/null
+++ b/Engine/lib/lpng/scripts/pnglibconf.mak
@@ -0,0 +1,55 @@
+#!/usr/bin/make -f
+# pnglibconf.mak - standard make lines for pnglibconf.h
+#
+# These lines are copied from Makefile.am, they illustrate
+# how to automate the build of pnglibconf.h from scripts/pnglibconf.dfa
+# given just 'awk', a C preprocessor and standard command line utilities
+
+# Override as appropriate, these definitions can be overridden on
+# the make command line (AWK='nawk' for example).
+AWK = gawk
+AWK = mawk
+AWK = nawk
+AWK = one-true-awk
+AWK = awk  # Crashes on SunOS 5.10 - use 'nawk'
+CPP = $(CC) -E # On SUN OS 5.10 if this causes problems use /lib/cpp
+
+MOVE = mv
+DELETE = rm -f
+ECHO = echo
+DFA_XTRA = # Put your configuration file here, see scripts/pnglibconf.dfa.  Eg:
+# DFA_XTRA = pngusr.dfa
+
+# CPPFLAGS should contain the options to control the result,
+# but DEFS and CFLAGS are also supported here, override
+# as appropriate
+DFNFLAGS = $(DEFS) $(CPPFLAGS) $(CFLAGS)
+
+# srcdir is a defacto standard for the location of the source
+srcdir = .
+
+# The standard pnglibconf.h exists as scripts/pnglibconf.h.prebuilt,
+# copy this if the following doesn't work.
+pnglibconf.h: pnglibconf.dfn
+	$(DELETE) $@ pnglibconf.c pnglibconf.out pnglibconf.tmp
+	$(ECHO) '#include "pnglibconf.dfn"' >pnglibconf.c
+	$(ECHO) "If '$(CC) -E' crashes try /lib/cpp (e.g. CPP='/lib/cpp')" >&2
+	$(CPP) $(DFNFLAGS) pnglibconf.c >pnglibconf.out
+	$(AWK) -f "$(srcdir)/scripts/dfn.awk" out="pnglibconf.tmp" pnglibconf.out 1>&2
+	$(MOVE) pnglibconf.tmp $@
+
+pnglibconf.dfn: $(srcdir)/scripts/pnglibconf.dfa $(srcdir)/scripts/options.awk $(srcdir)/pngconf.h $(srcdir)/pngusr.dfa $(DFA_XTRA)
+	$(DELETE) $@ pnglibconf.pre pnglibconf.tmp
+	$(ECHO) "Calling $(AWK) from scripts/pnglibconf.mak" >&2
+	$(ECHO) "If 'awk' crashes try a better awk (e.g. AWK='nawk')" >&2
+	$(AWK) -f $(srcdir)/scripts/options.awk out="pnglibconf.pre"\
+	    version=search $(srcdir)/pngconf.h $(srcdir)/scripts/pnglibconf.dfa\
+	    $(srcdir)/pngusr.dfa $(DFA_XTRA) 1>&2
+	$(AWK) -f $(srcdir)/scripts/options.awk out="pnglibconf.tmp" pnglibconf.pre 1>&2
+	$(MOVE) pnglibconf.tmp $@
+
+clean-pnglibconf:
+	$(DELETE) pnglibconf.h pnglibconf.c pnglibconf.out pnglibconf.pre \
+	pnglibconf.dfn
+
+clean: clean-pnglibconf
diff --git a/Engine/lib/lpng/scripts/pngwin.rc b/Engine/lib/lpng/scripts/pngwin.rc
new file mode 100644
index 000000000..9335cbbe0
--- /dev/null
+++ b/Engine/lib/lpng/scripts/pngwin.rc
@@ -0,0 +1,112 @@
+#define PNG_VERSION_INFO_ONLY
+
+#include <windows.h>
+#include "../png.h"
+
+#define _QUOTE(x) # x
+#define QUOTE(x) _QUOTE(x)
+
+#define PNG_LIBPNG_DLLFNAME "LIBPNG"
+
+/* Support deprecated PRIVATEBUILD macro */
+#if defined(PRIVATEBUILD) && !defined(PNG_USER_PRIVATEBUILD)
+#  define PNG_USER_PRIVATEBUILD PRIVATEBUILD
+#endif
+
+#if defined(PNG_USER_DLLFNAME_POSTFIX) && !defined(PNG_USER_PRIVATEBUILD)
+#  error "PNG_USER_PRIVATEBUILD must be defined as a string describing the\
+ custom changes made to the library."
+#endif
+
+/* Prioritize PNG_USER_x over PNG_LIBPNG_x */
+#ifdef PNG_USER_DLLFNAME_POSTFIX
+#  undef PNG_LIBPNG_DLLFNAME_POSTFIX
+#  define PNG_LIBPNG_DLLFNAME_POSTFIX PNG_USER_DLLFNAME_POSTFIX
+#endif
+
+#ifdef PNG_USER_VERSIONINFO_COMMENTS
+#  undef PNG_LIBPNG_VERSIONINFO_COMMENTS
+#  define PNG_LIBPNG_VERSIONINFO_COMMENTS PNG_USER_VERSIONINFO_COMMENTS
+#endif
+
+#if defined(PNG_DEBUG) && (PNG_DEBUG > 0)
+#  define VS_DEBUG VS_FF_DEBUG
+#  ifndef PNG_LIBPNG_DLLFNAME_POSTFIX
+#    define PNG_LIBPNG_DLLFNAME_POSTFIX "D"
+#  endif /* PNG_LIBPNG_DLLFNAME_POSTFIX */
+#  ifndef PNG_LIBPNG_VERSIONINFO_COMMENTS
+#    define PNG_LIBPNG_VERSIONINFO_COMMENTS "PNG_DEBUG=" QUOTE(PNG_DEBUG)
+#  endif /* PNG_LIBPNG_VERSIONINFO_COMMENTS */
+#else
+#  define VS_DEBUG 0
+#  ifndef PNG_LIBPNG_DLLFNAME_POSTFIX
+#     define PNG_LIBPNG_DLLFNAME_POSTFIX
+#  endif /* PNG_LIBPNG_DLLFNAME_POSTFIX */
+#endif /* defined(DEBUG)... */
+
+#ifdef PNG_USER_PRIVATEBUILD
+#  define VS_PRIVATEBUILD VS_FF_PRIVATEBUILD
+#else
+#  define VS_PRIVATEBUILD 0
+#endif /* PNG_USER_PRIVATEBUILD */
+
+#ifdef PNG_LIBPNG_SPECIALBUILD
+#  define VS_SPECIALBUILD VS_FF_SPECIALBUILD
+#else
+#  define VS_SPECIALBUILD 0
+#endif /* PNG_LIBPNG_BUILD_SPECIAL */
+
+#if ((PNG_LIBPNG_BUILD_BASE_TYPE & PNG_LIBPNG_RELEASE_STATUS_MASK) !=\
+      PNG_LIBPNG_BUILD_STABLE)
+#  define VS_PRERELEASE VS_FF_PRERELEASE
+#  define VS_PATCHED 0
+#else
+#  define VS_PRERELEASE 0
+#  if (PNG_LIBPNG_BUILD_BASE_TYPE & PNG_LIBPNG_BUILD_PATCHED)
+#    define VS_PATCHED VS_FF_PATCHED
+#  else
+#    define VS_PATCHED 0
+#  endif
+#endif
+
+VS_VERSION_INFO VERSIONINFO
+FILEVERSION PNG_LIBPNG_VER_MAJOR, PNG_LIBPNG_VER_MINOR, PNG_LIBPNG_VER_RELEASE, PNG_LIBPNG_VER_BUILD
+PRODUCTVERSION PNG_LIBPNG_VER_MAJOR, PNG_LIBPNG_VER_MINOR, PNG_LIBPNG_VER_RELEASE, PNG_LIBPNG_VER_BUILD
+FILEFLAGSMASK VS_FFI_FILEFLAGSMASK
+FILEFLAGS VS_DEBUG | VS_PRIVATEBUILD | VS_SPECIALBUILD | VS_PRERELEASE | VS_PATCHED
+FILEOS VOS__WINDOWS32
+FILETYPE VFT_DLL
+FILESUBTYPE VFT2_UNKNOWN
+BEGIN
+  BLOCK "StringFileInfo"
+  BEGIN BLOCK "040904E4" /* Language type = U.S English(0x0409) and Character Set = Windows, Multilingual(0x04E4) */
+    BEGIN
+#ifdef PNG_LIBPNG_VERSIONINFO_COMMENTS
+      VALUE "Comments", PNG_LIBPNG_VERSIONINFO_COMMENTS "\000"
+#endif /* PNG_LIBPNG_VERSIONINFO_COMMENTS */
+#ifdef PNG_USER_VERSIONINFO_COMPANYNAME
+      VALUE "CompanyName", PNG_USER_VERSIONINFO_COMPANYNAME "\000"
+#endif /* PNG_USER_VERSIONINFO_COMPANYNAME */
+      VALUE "FileDescription", "PNG image compression library\000"
+      VALUE "FileVersion", PNG_LIBPNG_VER_STRING "\000"
+      VALUE "InternalName", PNG_LIBPNG_DLLFNAME QUOTE(PNG_LIBPNG_VER_DLLNUM) PNG_LIBPNG_DLLFNAME_POSTFIX " (Windows 32 bit)\000"
+      VALUE "LegalCopyright", "\251 1998-2009 Glenn Randers-Pehrson et al.\000"
+#ifdef PNG_USER_VERSIONINFO_LEGALTRADEMARKS
+      VALUE "LegalTrademarks", PNG_USER_VERSIONINFO_LEGALTRADEMARKS "\000"
+#endif /* PNG_USER_VERSIONINFO_LEGALTRADEMARKS */
+      VALUE "OriginalFilename", PNG_LIBPNG_DLLFNAME QUOTE(PNG_LIBPNG_VER_DLLNUM) PNG_LIBPNG_DLLFNAME_POSTFIX ".DLL\000"
+#ifdef PNG_USER_PRIVATEBUILD
+      VALUE "PrivateBuild", PNG_USER_PRIVATEBUILD "\000"
+#endif /* PNG_USER_PRIVATEBUILD */
+      VALUE "ProductName", "LibPNG\000"
+      VALUE "ProductVersion", "1\000"
+#ifdef PNG_LIBPNG_SPECIALBUILD
+      VALUE "SpecialBuild", PNG_LIBPNG_SPECIALBUILD "\000"
+#endif /* PNG_LIBPNG_SPECIALBUILD */
+    END
+  END
+  BLOCK "VarFileInfo"
+  BEGIN
+    VALUE "Translation", 0x0409, 0x04E4
+  END
+END
diff --git a/Engine/lib/lpng/scripts/prefix.c b/Engine/lib/lpng/scripts/prefix.c
new file mode 100644
index 000000000..8b604a091
--- /dev/null
+++ b/Engine/lib/lpng/scripts/prefix.c
@@ -0,0 +1,24 @@
+
+/* prefix.c - generate an unprefixed symbol list
+ *
+ * Last changed in libpng version 1.6.16 [December 22, 2014]
+ * Copyright (c) 2013-2014 Glenn Randers-Pehrson
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+#define PNG_EXPORTA(ordinal, type, name, args, attributes)\
+        PNG_DFN "@" name "@"
+
+/* The configuration information *before* the additional of symbol renames,
+ * the list is the C name list; no symbol prefix.
+ */
+#include "pnglibconf.out"
+
+PNG_DFN_START_SORT 1
+
+#include "../png.h"
+
+PNG_DFN_END_SORT
diff --git a/Engine/lib/lpng/scripts/smakefile.ppc b/Engine/lib/lpng/scripts/smakefile.ppc
new file mode 100644
index 000000000..2e7380b1f
--- /dev/null
+++ b/Engine/lib/lpng/scripts/smakefile.ppc
@@ -0,0 +1,34 @@
+# Amiga powerUP (TM) Makefile
+# makefile for libpng and SAS C V6.58/7.00 PPC compiler
+# Copyright (C) 1998 by Andreas R. Kleinert
+#
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+CC       = scppc
+CFLAGS   = NOSTKCHK NOSINT OPTIMIZE OPTGO OPTPEEP OPTINLOCAL OPTINL IDIR /zlib \
+           OPTLOOP OPTRDEP=8 OPTDEP=8 OPTCOMP=8
+LIBNAME  = libpng.a
+AR       = ppc-amigaos-ar
+AR_FLAGS = cr
+RANLIB   = ppc-amigaos-ranlib
+LDFLAGS  = -r -o
+LDLIBS   =  ../zlib/libzip.a LIB:scppc.a
+LN       = ppc-amigaos-ld
+RM       = delete quiet
+MKDIR    = makedir
+
+OBJS = png.o pngset.o pngget.o pngrutil.o pngtrans.o pngwutil.o pngread.o \
+       pngerror.o pngpread.o pngwrite.o pngrtran.o pngwtran.o pngrio.o \
+       pngwio.o pngmem.o
+
+all: $(LIBNAME) pngtest
+
+$(LIBNAME): $(OBJS)
+            $(AR) $(AR_FLAGS) $@ $(OBJS)
+            $(RANLIB) $@
+
+pngtest: pngtest.o $(LIBNAME)
+        $(LN) $(LDFLAGS) pngtest LIB:c_ppc.o pngtest.o $(LIBNAME) $(LDLIBS) \
+LIB:end.o
diff --git a/Engine/lib/lpng/scripts/sym.c b/Engine/lib/lpng/scripts/sym.c
new file mode 100644
index 000000000..ea9e4c507
--- /dev/null
+++ b/Engine/lib/lpng/scripts/sym.c
@@ -0,0 +1,15 @@
+
+/* sym.c - define format of libpng.sym
+ *
+ * Last changed in libpng version 1.6.16 [December 22, 2014]
+ * Copyright (c) 2011-2014 Glenn Randers-Pehrson
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+#define PNG_EXPORTA(ordinal, type, name, args, attributes)\
+        PNG_DFN "@" SYMBOL_PREFIX "@@" name "@"
+
+#include "../png.h"
diff --git a/Engine/lib/lpng/scripts/symbols.c b/Engine/lib/lpng/scripts/symbols.c
new file mode 100644
index 000000000..28b841d8b
--- /dev/null
+++ b/Engine/lib/lpng/scripts/symbols.c
@@ -0,0 +1,58 @@
+
+/* symbols.c - find all exported symbols
+ *
+ * Last changed in libpng version 1.6.16 [December 22, 2014]
+ * Copyright (c) 2011-2014 Glenn Randers-Pehrson
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+/* NOTE: making 'symbols.chk' checks both that the exported
+ * symbols in the library don't change and (implicitly) that
+ * scripts/pnglibconf.h.prebuilt is as expected.
+ * If scripts/pnglibconf.h.prebuilt is remade using
+ * scripts/pnglibconf.dfa then this checks the .dfa file too.
+ */
+
+#define PNG_EXPORTA(ordinal, type, name, args, attributes)\
+        PNG_DFN "@" name "@ @@" ordinal "@"
+#define PNG_REMOVED(ordinal, type, name, args, attributes)\
+        PNG_DFN "; @" name "@ @@" ordinal "@"
+#define PNG_EXPORT_LAST_ORDINAL(ordinal)\
+        PNG_DFN "; @@" ordinal "@"
+
+/* Read the defaults, but use scripts/pnglibconf.h.prebuilt; the 'standard'
+ * header file.
+ */
+#include "pnglibconf.h.prebuilt"
+#include "../png.h"
+
+/* Some things are turned off by default.  Turn these things
+ * on here (by hand) to get the APIs they expose and validate
+ * that no harm is done.  This list is the set of options
+ * defaulted to 'off' in scripts/pnglibconf.dfa
+ *
+ * Maintenance: if scripts/pnglibconf.dfa options are changed
+ * from, or to, 'disabled' this needs updating!
+ */
+#define PNG_BENIGN_ERRORS_SUPPORTED
+#define PNG_ERROR_NUMBERS_SUPPORTED
+#define PNG_READ_BIG_ENDIAN_SUPPORTED  /* should do nothing! */
+#define PNG_INCH_CONVERSIONS_SUPPORTED
+#define PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED
+#define PNG_SET_OPTION_SUPPORTED
+
+#undef PNG_H
+#include "../png.h"
+
+/* Finally there are a couple of places where option support
+ * actually changes the APIs revealed using a #if/#else/#endif
+ * test in png.h, test these here.
+ */
+#undef  PNG_FLOATING_POINT_SUPPORTED /* Exposes 'fixed' APIs */
+#undef  PNG_ERROR_TEXT_SUPPORTED     /* Exposes unsupported APIs */
+
+#undef PNG_H
+#include "../png.h"
diff --git a/Engine/lib/lpng/scripts/symbols.def b/Engine/lib/lpng/scripts/symbols.def
new file mode 100644
index 000000000..82494bbf9
--- /dev/null
+++ b/Engine/lib/lpng/scripts/symbols.def
@@ -0,0 +1,255 @@
+;--------------------------------------------------------------
+; LIBPNG symbol list as a Win32 DEF file
+; Contains all the symbols that can be exported from libpng
+;--------------------------------------------------------------
+LIBRARY
+
+EXPORTS
+ png_access_version_number @1
+ png_set_sig_bytes @2
+ png_sig_cmp @3
+ png_create_read_struct @4
+ png_create_write_struct @5
+ png_get_compression_buffer_size @6
+ png_set_compression_buffer_size @7
+ png_set_longjmp_fn @8
+ png_longjmp @9
+ png_reset_zstream @10
+ png_create_read_struct_2 @11
+ png_create_write_struct_2 @12
+ png_write_sig @13
+ png_write_chunk @14
+ png_write_chunk_start @15
+ png_write_chunk_data @16
+ png_write_chunk_end @17
+ png_create_info_struct @18
+ png_info_init_3 @19
+ png_write_info_before_PLTE @20
+ png_write_info @21
+ png_read_info @22
+ png_convert_to_rfc1123 @23
+ png_convert_from_struct_tm @24
+ png_convert_from_time_t @25
+ png_set_expand @26
+ png_set_expand_gray_1_2_4_to_8 @27
+ png_set_palette_to_rgb @28
+ png_set_tRNS_to_alpha @29
+ png_set_bgr @30
+ png_set_gray_to_rgb @31
+ png_set_rgb_to_gray @32
+ png_set_rgb_to_gray_fixed @33
+ png_get_rgb_to_gray_status @34
+ png_build_grayscale_palette @35
+ png_set_strip_alpha @36
+ png_set_swap_alpha @37
+ png_set_invert_alpha @38
+ png_set_filler @39
+ png_set_add_alpha @40
+ png_set_swap @41
+ png_set_packing @42
+ png_set_packswap @43
+ png_set_shift @44
+ png_set_interlace_handling @45
+ png_set_invert_mono @46
+ png_set_background @47
+ png_set_strip_16 @48
+ png_set_quantize @49
+ png_set_gamma @50
+ png_set_flush @51
+ png_write_flush @52
+ png_start_read_image @53
+ png_read_update_info @54
+ png_read_rows @55
+ png_read_row @56
+ png_read_image @57
+ png_write_row @58
+ png_write_rows @59
+ png_write_image @60
+ png_write_end @61
+ png_read_end @62
+ png_destroy_info_struct @63
+ png_destroy_read_struct @64
+ png_destroy_write_struct @65
+ png_set_crc_action @66
+ png_set_filter @67
+ png_set_filter_heuristics @68
+ png_set_compression_level @69
+ png_set_compression_mem_level @70
+ png_set_compression_strategy @71
+ png_set_compression_window_bits @72
+ png_set_compression_method @73
+ png_init_io @74
+ png_set_error_fn @75
+ png_get_error_ptr @76
+ png_set_write_fn @77
+ png_set_read_fn @78
+ png_get_io_ptr @79
+ png_set_read_status_fn @80
+ png_set_write_status_fn @81
+ png_set_mem_fn @82
+ png_get_mem_ptr @83
+ png_set_read_user_transform_fn @84
+ png_set_write_user_transform_fn @85
+ png_set_user_transform_info @86
+ png_get_user_transform_ptr @87
+ png_set_read_user_chunk_fn @88
+ png_get_user_chunk_ptr @89
+ png_set_progressive_read_fn @90
+ png_get_progressive_ptr @91
+ png_process_data @92
+ png_progressive_combine_row @93
+ png_malloc @94
+ png_calloc @95
+ png_malloc_warn @96
+ png_free @97
+ png_free_data @98
+ png_data_freer @99
+ png_malloc_default @100
+ png_free_default @101
+ png_error @102
+ png_chunk_error @103
+ png_err @104
+ png_warning @105
+ png_chunk_warning @106
+ png_benign_error @107
+ png_chunk_benign_error @108
+ png_set_benign_errors @109
+ png_get_valid @110
+ png_get_rowbytes @111
+ png_get_rows @112
+ png_set_rows @113
+ png_get_channels @114
+ png_get_image_width @115
+ png_get_image_height @116
+ png_get_bit_depth @117
+ png_get_color_type @118
+ png_get_filter_type @119
+ png_get_interlace_type @120
+ png_get_compression_type @121
+ png_get_pixels_per_meter @122
+ png_get_x_pixels_per_meter @123
+ png_get_y_pixels_per_meter @124
+ png_get_pixel_aspect_ratio @125
+ png_get_x_offset_pixels @126
+ png_get_y_offset_pixels @127
+ png_get_x_offset_microns @128
+ png_get_y_offset_microns @129
+ png_get_signature @130
+ png_get_bKGD @131
+ png_set_bKGD @132
+ png_get_cHRM @133
+ png_get_cHRM_fixed @134
+ png_set_cHRM @135
+ png_set_cHRM_fixed @136
+ png_get_gAMA @137
+ png_get_gAMA_fixed @138
+ png_set_gAMA @139
+ png_set_gAMA_fixed @140
+ png_get_hIST @141
+ png_set_hIST @142
+ png_get_IHDR @143
+ png_set_IHDR @144
+ png_get_oFFs @145
+ png_set_oFFs @146
+ png_get_pCAL @147
+ png_set_pCAL @148
+ png_get_pHYs @149
+ png_set_pHYs @150
+ png_get_PLTE @151
+ png_set_PLTE @152
+ png_get_sBIT @153
+ png_set_sBIT @154
+ png_get_sRGB @155
+ png_set_sRGB @156
+ png_set_sRGB_gAMA_and_cHRM @157
+ png_get_iCCP @158
+ png_set_iCCP @159
+ png_get_sPLT @160
+ png_set_sPLT @161
+ png_get_text @162
+ png_set_text @163
+ png_get_tIME @164
+ png_set_tIME @165
+ png_get_tRNS @166
+ png_set_tRNS @167
+ png_get_sCAL @168
+ png_get_sCAL_s @169
+ png_set_sCAL @170
+ png_set_sCAL_s @171
+ png_set_keep_unknown_chunks @172
+ png_handle_as_unknown @173
+ png_set_unknown_chunks @174
+ png_set_unknown_chunk_location @175
+ png_get_unknown_chunks @176
+ png_set_invalid @177
+ png_read_png @178
+ png_write_png @179
+ png_get_copyright @180
+ png_get_header_ver @181
+ png_get_header_version @182
+ png_get_libpng_ver @183
+ png_permit_mng_features @184
+ png_set_strip_error_numbers @185
+ png_set_user_limits @186
+ png_get_user_width_max @187
+ png_get_user_height_max @188
+ png_set_chunk_cache_max @189
+ png_get_chunk_cache_max @190
+ png_set_chunk_malloc_max @191
+ png_get_chunk_malloc_max @192
+ png_get_pixels_per_inch @193
+ png_get_x_pixels_per_inch @194
+ png_get_y_pixels_per_inch @195
+ png_get_x_offset_inches @196
+ png_get_y_offset_inches @197
+ png_get_pHYs_dpi @198
+ png_get_io_state @199
+ png_get_uint_32 @201
+ png_get_uint_16 @202
+ png_get_int_32 @203
+ png_get_uint_31 @204
+ png_save_uint_32 @205
+ png_save_int_32 @206
+ png_save_uint_16 @207
+ png_set_gamma_fixed @208
+ png_set_filter_heuristics_fixed @209
+ png_get_pixel_aspect_ratio_fixed @210
+ png_get_x_offset_inches_fixed @211
+ png_get_y_offset_inches_fixed @212
+ png_set_sCAL_fixed @213
+ png_get_sCAL_fixed @214
+ png_set_background_fixed @215
+ png_get_io_chunk_type @216
+ png_get_current_row_number @217
+ png_get_current_pass_number @218
+ png_process_data_pause @219
+ png_process_data_skip @220
+ png_set_expand_16 @221
+ png_set_text_compression_level @222
+ png_set_text_compression_mem_level @223
+ png_set_text_compression_strategy @224
+ png_set_text_compression_window_bits @225
+ png_set_text_compression_method @226
+ png_set_alpha_mode @227
+ png_set_alpha_mode_fixed @228
+ png_set_scale_16 @229
+ png_get_cHRM_XYZ @230
+ png_get_cHRM_XYZ_fixed @231
+ png_set_cHRM_XYZ @232
+ png_set_cHRM_XYZ_fixed @233
+ png_image_begin_read_from_file @234
+ png_image_begin_read_from_stdio @235
+ png_image_begin_read_from_memory @236
+ png_image_finish_read @237
+ png_image_free @238
+ png_image_write_to_file @239
+ png_image_write_to_stdio @240
+ png_convert_to_rfc1123_buffer @241
+ png_set_check_for_invalid_index @242
+ png_get_palette_max @243
+ png_set_option @244
+ png_image_write_to_memory @245
+ png_get_eXIf @246
+ png_set_eXIf @247
+ png_get_eXIf_1 @248
+ png_set_eXIf_1 @249
diff --git a/Engine/lib/lpng/scripts/test.cmake.in b/Engine/lib/lpng/scripts/test.cmake.in
new file mode 100644
index 000000000..fa6a889bb
--- /dev/null
+++ b/Engine/lib/lpng/scripts/test.cmake.in
@@ -0,0 +1,31 @@
+# test.cmake.in
+
+# Copyright (C) 2016 Glenn Randers-Pehrson
+# Written by Roger Leigh, 2016
+
+# This code is released under the libpng license.
+# For conditions of distribution and use, see the disclaimer
+# and license in png.h
+
+set(TEST_OPTIONS "@TEST_OPTIONS@")
+set(TEST_FILES "@TEST_FILES@")
+
+foreach(file ${TEST_FILES})
+  file(TO_NATIVE_PATH "${file}" native_file)
+  list(APPEND NATIVE_TEST_FILES "${native_file}")
+endforeach()
+
+# Add the directory containing libpng to the PATH (Windows only)
+if(WIN32)
+  get_filename_component(LIBPNG_DIR "${LIBPNG}" PATH)
+  file(TO_NATIVE_PATH "${LIBPNG_DIR}" LIBPNG_DIR)
+  set(ENV{PATH} "${LIBPNG_DIR};$ENV{PATH}")
+endif()
+
+execute_process(COMMAND "${CMAKE_COMMAND}" -E echo "Running ${TEST_COMMAND}" ${TEST_OPTIONS} ${NATIVE_TEST_FILES})
+
+execute_process(COMMAND "${TEST_COMMAND}" ${TEST_OPTIONS} ${NATIVE_TEST_FILES}
+                RESULT_VARIABLE TEST_STATUS)
+if(TEST_STATUS)
+  message(FATAL_ERROR "Returned failed status ${TEST_STATUS}!")
+endif()
diff --git a/Engine/lib/lpng/scripts/vers.c b/Engine/lib/lpng/scripts/vers.c
new file mode 100644
index 000000000..de7319716
--- /dev/null
+++ b/Engine/lib/lpng/scripts/vers.c
@@ -0,0 +1,19 @@
+
+/* vers.c - define format of libpng.vers
+ *
+ * Last changed in libpng version 1.6.16 [December 22, 2014]
+ * Copyright (c) 2011-2014 Glenn Randers-Pehrson
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+#define PNG_EXPORTA(ordinal, type, name, args, attributes)\
+        PNG_DFN " @" SYMBOL_PREFIX "@@" name "@;"
+
+PNG_DFN "@" PNGLIB_LIBNAME "@ {global:"
+
+#include "../png.h"
+
+PNG_DFN "local: *; };"
diff --git a/Engine/lib/lpng/test-driver b/Engine/lib/lpng/test-driver
new file mode 100755
index 000000000..b8521a482
--- /dev/null
+++ b/Engine/lib/lpng/test-driver
@@ -0,0 +1,148 @@
+#! /bin/sh
+# test-driver - basic testsuite driver script.
+
+scriptversion=2018-03-07.03; # UTC
+
+# Copyright (C) 2011-2018 Free Software Foundation, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# This file is maintained in Automake, please report
+# bugs to <bug-automake@gnu.org> or send patches to
+# <automake-patches@gnu.org>.
+
+# Make unconditional expansion of undefined variables an error.  This
+# helps a lot in preventing typo-related bugs.
+set -u
+
+usage_error ()
+{
+  echo "$0: $*" >&2
+  print_usage >&2
+  exit 2
+}
+
+print_usage ()
+{
+  cat <<END
+Usage:
+  test-driver --test-name=NAME --log-file=PATH --trs-file=PATH
+              [--expect-failure={yes|no}] [--color-tests={yes|no}]
+              [--enable-hard-errors={yes|no}] [--]
+              TEST-SCRIPT [TEST-SCRIPT-ARGUMENTS]
+The '--test-name', '--log-file' and '--trs-file' options are mandatory.
+END
+}
+
+test_name= # Used for reporting.
+log_file=  # Where to save the output of the test script.
+trs_file=  # Where to save the metadata of the test run.
+expect_failure=no
+color_tests=no
+enable_hard_errors=yes
+while test $# -gt 0; do
+  case $1 in
+  --help) print_usage; exit $?;;
+  --version) echo "test-driver $scriptversion"; exit $?;;
+  --test-name) test_name=$2; shift;;
+  --log-file) log_file=$2; shift;;
+  --trs-file) trs_file=$2; shift;;
+  --color-tests) color_tests=$2; shift;;
+  --expect-failure) expect_failure=$2; shift;;
+  --enable-hard-errors) enable_hard_errors=$2; shift;;
+  --) shift; break;;
+  -*) usage_error "invalid option: '$1'";;
+   *) break;;
+  esac
+  shift
+done
+
+missing_opts=
+test x"$test_name" = x && missing_opts="$missing_opts --test-name"
+test x"$log_file"  = x && missing_opts="$missing_opts --log-file"
+test x"$trs_file"  = x && missing_opts="$missing_opts --trs-file"
+if test x"$missing_opts" != x; then
+  usage_error "the following mandatory options are missing:$missing_opts"
+fi
+
+if test $# -eq 0; then
+  usage_error "missing argument"
+fi
+
+if test $color_tests = yes; then
+  # Keep this in sync with 'lib/am/check.am:$(am__tty_colors)'.
+  red='' # Red.
+  grn='' # Green.
+  lgn='' # Light green.
+  blu='' # Blue.
+  mgn='' # Magenta.
+  std=''     # No color.
+else
+  red= grn= lgn= blu= mgn= std=
+fi
+
+do_exit='rm -f $log_file $trs_file; (exit $st); exit $st'
+trap "st=129; $do_exit" 1
+trap "st=130; $do_exit" 2
+trap "st=141; $do_exit" 13
+trap "st=143; $do_exit" 15
+
+# Test script is run here.
+"$@" >$log_file 2>&1
+estatus=$?
+
+if test $enable_hard_errors = no && test $estatus -eq 99; then
+  tweaked_estatus=1
+else
+  tweaked_estatus=$estatus
+fi
+
+case $tweaked_estatus:$expect_failure in
+  0:yes) col=$red res=XPASS recheck=yes gcopy=yes;;
+  0:*)   col=$grn res=PASS  recheck=no  gcopy=no;;
+  77:*)  col=$blu res=SKIP  recheck=no  gcopy=yes;;
+  99:*)  col=$mgn res=ERROR recheck=yes gcopy=yes;;
+  *:yes) col=$lgn res=XFAIL recheck=no  gcopy=yes;;
+  *:*)   col=$red res=FAIL  recheck=yes gcopy=yes;;
+esac
+
+# Report the test outcome and exit status in the logs, so that one can
+# know whether the test passed or failed simply by looking at the '.log'
+# file, without the need of also peaking into the corresponding '.trs'
+# file (automake bug#11814).
+echo "$res $test_name (exit status: $estatus)" >>$log_file
+
+# Report outcome to console.
+echo "${col}${res}${std}: $test_name"
+
+# Register the test result, and other relevant metadata.
+echo ":test-result: $res" > $trs_file
+echo ":global-test-result: $res" >> $trs_file
+echo ":recheck: $recheck" >> $trs_file
+echo ":copy-in-global-log: $gcopy" >> $trs_file
+
+# Local Variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'before-save-hook 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC0"
+# time-stamp-end: "; # UTC"
+# End:
diff --git a/Engine/lib/lpng/tests/pngimage-full b/Engine/lib/lpng/tests/pngimage-full
new file mode 100755
index 000000000..1198ed05c
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngimage-full
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec ./pngimage --exhaustive --list-combos --log "${srcdir}/contrib/pngsuite/"*.png
diff --git a/Engine/lib/lpng/tests/pngimage-quick b/Engine/lib/lpng/tests/pngimage-quick
new file mode 100755
index 000000000..328dc27b5
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngimage-quick
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec ./pngimage --list-combos --log "${srcdir}/contrib/pngsuite/"*.png
diff --git a/Engine/lib/lpng/tests/pngstest b/Engine/lib/lpng/tests/pngstest
new file mode 100755
index 000000000..9d1b7764e
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngstest
@@ -0,0 +1,54 @@
+#!/bin/sh
+#
+# Usage:
+#
+#  tests/pngstest gamma alpha
+#
+# Run ./pngstest on the PNG files in $srcdir/contrib/testpngs which have the
+# given gamma and opacity:
+#
+#  gamma: one of; linear, 1.8, sRGB, none.
+#  alpha: one of; opaque, tRNS, alpha, none.  'none' is equivalent to !alpha
+#
+# NOTE: the temporary files pngstest generates have the base name gamma-alpha to
+# avoid issues with make -j
+#
+gamma="$1"
+shift
+alpha="$1"
+shift
+args=
+LC_ALL="C" # fix glob sort order to ASCII:
+for f in "${srcdir}/contrib/testpngs/"*.png
+do
+   g=
+   case "$f" in
+      *-linear[.-]*)
+         test "$gamma" = "linear" && g="$f";;
+
+      *-sRGB[.-]*)
+         test "$gamma" = "sRGB" && g="$f";;
+
+      *-1.8[.-]*)
+         test "$gamma" = "1.8" && g="$f";;
+
+      *)
+         test "$gamma" = "none" && g="$f";;
+   esac
+
+   case "$g" in
+      "")
+         :;;
+
+      *-alpha[-.]*)
+         test "$alpha" = "alpha" && args="$args $g";;
+
+      *-tRNS[-.]*)
+         test "$alpha" = "tRNS" -o "$alpha" = "none" && args="$args $g";;
+
+      *)
+         test "$alpha" = "opaque" -o "$alpha" = "none" && args="$args $g";;
+   esac
+done
+# This only works if the arguments don't contain spaces; they don't.
+exec ./pngstest --tmpfile "${gamma}-${alpha}-" --log ${1+"$@"} $args
diff --git a/Engine/lib/lpng/tests/pngstest-1.8 b/Engine/lib/lpng/tests/pngstest-1.8
new file mode 100755
index 000000000..b2ec21bf6
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngstest-1.8
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec "${srcdir}/tests/pngstest" 1.8 none
diff --git a/Engine/lib/lpng/tests/pngstest-1.8-alpha b/Engine/lib/lpng/tests/pngstest-1.8-alpha
new file mode 100755
index 000000000..d00596d55
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngstest-1.8-alpha
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec "${srcdir}/tests/pngstest" 1.8 alpha
diff --git a/Engine/lib/lpng/tests/pngstest-linear b/Engine/lib/lpng/tests/pngstest-linear
new file mode 100755
index 000000000..4a5b3fe8c
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngstest-linear
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec "${srcdir}/tests/pngstest" linear none
diff --git a/Engine/lib/lpng/tests/pngstest-linear-alpha b/Engine/lib/lpng/tests/pngstest-linear-alpha
new file mode 100755
index 000000000..411421036
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngstest-linear-alpha
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec "${srcdir}/tests/pngstest" linear alpha
diff --git a/Engine/lib/lpng/tests/pngstest-none b/Engine/lib/lpng/tests/pngstest-none
new file mode 100755
index 000000000..09ad740b5
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngstest-none
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec "${srcdir}/tests/pngstest" none none
diff --git a/Engine/lib/lpng/tests/pngstest-none-alpha b/Engine/lib/lpng/tests/pngstest-none-alpha
new file mode 100755
index 000000000..af6083ff8
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngstest-none-alpha
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec "${srcdir}/tests/pngstest" none alpha
diff --git a/Engine/lib/lpng/tests/pngstest-sRGB b/Engine/lib/lpng/tests/pngstest-sRGB
new file mode 100755
index 000000000..d8460812c
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngstest-sRGB
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec "${srcdir}/tests/pngstest" sRGB none
diff --git a/Engine/lib/lpng/tests/pngstest-sRGB-alpha b/Engine/lib/lpng/tests/pngstest-sRGB-alpha
new file mode 100755
index 000000000..f1e57d339
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngstest-sRGB-alpha
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec "${srcdir}/tests/pngstest" sRGB alpha
diff --git a/Engine/lib/lpng/tests/pngtest b/Engine/lib/lpng/tests/pngtest
new file mode 100755
index 000000000..813973b23
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngtest
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec ./pngtest --strict ${srcdir}/pngtest.png
diff --git a/Engine/lib/lpng/tests/pngtest-badpngs b/Engine/lib/lpng/tests/pngtest-badpngs
new file mode 100755
index 000000000..77775232b
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngtest-badpngs
@@ -0,0 +1,13 @@
+#!/bin/sh
+
+# various crashers
+# using --relaxed because some come from fuzzers that don't maintain CRC's
+
+./pngtest --relaxed ${srcdir}/contrib/testpngs/crashers/badcrc.png
+./pngtest --relaxed ${srcdir}/contrib/testpngs/crashers/badadler.png
+./pngtest --xfail ${srcdir}/contrib/testpngs/crashers/bad_iCCP.png
+./pngtest --xfail ${srcdir}/contrib/testpngs/crashers/empty_ancillary_chunks.png
+./pngtest --xfail ${srcdir}/contrib/testpngs/crashers/huge_*_chunk.png \
+    ${srcdir}/contrib/testpngs/crashers/huge_*safe_to_copy.png
+
+exec ./pngtest --xfail ${srcdir}/contrib/testpngs/crashers/huge_IDAT.png
diff --git a/Engine/lib/lpng/tests/pngunknown-IDAT b/Engine/lib/lpng/tests/pngunknown-IDAT
new file mode 100755
index 000000000..8e7281aa8
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngunknown-IDAT
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec ./pngunknown --strict default=discard IDAT=save "${srcdir}/pngtest.png"
diff --git a/Engine/lib/lpng/tests/pngunknown-discard b/Engine/lib/lpng/tests/pngunknown-discard
new file mode 100755
index 000000000..c96dab370
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngunknown-discard
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec ./pngunknown --strict default=discard "${srcdir}/pngtest.png"
diff --git a/Engine/lib/lpng/tests/pngunknown-if-safe b/Engine/lib/lpng/tests/pngunknown-if-safe
new file mode 100755
index 000000000..31a4954fb
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngunknown-if-safe
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec ./pngunknown --strict default=if-safe "${srcdir}/pngtest.png"
diff --git a/Engine/lib/lpng/tests/pngunknown-sAPI b/Engine/lib/lpng/tests/pngunknown-sAPI
new file mode 100755
index 000000000..88a1f6be2
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngunknown-sAPI
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec ./pngunknown --strict bKGD=save cHRM=save gAMA=save all=discard iCCP=save sBIT=save sRGB=save eXIf=save "${srcdir}/pngtest.png"
diff --git a/Engine/lib/lpng/tests/pngunknown-sTER b/Engine/lib/lpng/tests/pngunknown-sTER
new file mode 100755
index 000000000..59c5ecd54
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngunknown-sTER
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec ./pngunknown --strict sTER=if-safe "${srcdir}/pngtest.png"
diff --git a/Engine/lib/lpng/tests/pngunknown-save b/Engine/lib/lpng/tests/pngunknown-save
new file mode 100755
index 000000000..21412c42a
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngunknown-save
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec ./pngunknown --strict default=save "${srcdir}/pngtest.png"
diff --git a/Engine/lib/lpng/tests/pngunknown-vpAg b/Engine/lib/lpng/tests/pngunknown-vpAg
new file mode 100755
index 000000000..04f07b69a
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngunknown-vpAg
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec ./pngunknown --strict vpAg=if-safe "${srcdir}/pngtest.png"
diff --git a/Engine/lib/lpng/tests/pngvalid-gamma-16-to-8 b/Engine/lib/lpng/tests/pngvalid-gamma-16-to-8
new file mode 100755
index 000000000..074945d31
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngvalid-gamma-16-to-8
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec ./pngvalid --strict --gamma-16-to-8
diff --git a/Engine/lib/lpng/tests/pngvalid-gamma-alpha-mode b/Engine/lib/lpng/tests/pngvalid-gamma-alpha-mode
new file mode 100755
index 000000000..b16e8abc4
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngvalid-gamma-alpha-mode
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec ./pngvalid --strict --gamma-alpha-mode
diff --git a/Engine/lib/lpng/tests/pngvalid-gamma-background b/Engine/lib/lpng/tests/pngvalid-gamma-background
new file mode 100755
index 000000000..3dbf58d8a
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngvalid-gamma-background
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec ./pngvalid --strict --gamma-background
diff --git a/Engine/lib/lpng/tests/pngvalid-gamma-expand16-alpha-mode b/Engine/lib/lpng/tests/pngvalid-gamma-expand16-alpha-mode
new file mode 100755
index 000000000..4fa10bde2
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngvalid-gamma-expand16-alpha-mode
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec ./pngvalid --strict --gamma-alpha-mode --expand16
diff --git a/Engine/lib/lpng/tests/pngvalid-gamma-expand16-background b/Engine/lib/lpng/tests/pngvalid-gamma-expand16-background
new file mode 100755
index 000000000..ad9a91762
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngvalid-gamma-expand16-background
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec ./pngvalid --strict --gamma-background --expand16
diff --git a/Engine/lib/lpng/tests/pngvalid-gamma-expand16-transform b/Engine/lib/lpng/tests/pngvalid-gamma-expand16-transform
new file mode 100755
index 000000000..5fd1f280b
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngvalid-gamma-expand16-transform
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec ./pngvalid --strict --gamma-transform --expand16
diff --git a/Engine/lib/lpng/tests/pngvalid-gamma-sbit b/Engine/lib/lpng/tests/pngvalid-gamma-sbit
new file mode 100755
index 000000000..6ca08e9e3
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngvalid-gamma-sbit
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec ./pngvalid --strict --gamma-sbit
diff --git a/Engine/lib/lpng/tests/pngvalid-gamma-threshold b/Engine/lib/lpng/tests/pngvalid-gamma-threshold
new file mode 100755
index 000000000..3fe4edf77
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngvalid-gamma-threshold
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec ./pngvalid --strict --gamma-threshold
diff --git a/Engine/lib/lpng/tests/pngvalid-gamma-transform b/Engine/lib/lpng/tests/pngvalid-gamma-transform
new file mode 100755
index 000000000..3fa62c688
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngvalid-gamma-transform
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec ./pngvalid --strict --gamma-transform
diff --git a/Engine/lib/lpng/tests/pngvalid-progressive-interlace-standard b/Engine/lib/lpng/tests/pngvalid-progressive-interlace-standard
new file mode 100755
index 000000000..a8cdf9e1a
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngvalid-progressive-interlace-standard
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec ./pngvalid --strict --standard --progressive-read --interlace
diff --git a/Engine/lib/lpng/tests/pngvalid-progressive-size b/Engine/lib/lpng/tests/pngvalid-progressive-size
new file mode 100755
index 000000000..868d6dcc3
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngvalid-progressive-size
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec ./pngvalid --strict --size --progressive-read
diff --git a/Engine/lib/lpng/tests/pngvalid-progressive-standard b/Engine/lib/lpng/tests/pngvalid-progressive-standard
new file mode 100755
index 000000000..bf7e5c1c2
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngvalid-progressive-standard
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec ./pngvalid --strict --standard --progressive-read
diff --git a/Engine/lib/lpng/tests/pngvalid-standard b/Engine/lib/lpng/tests/pngvalid-standard
new file mode 100755
index 000000000..a89b88424
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngvalid-standard
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec ./pngvalid --strict --standard
diff --git a/Engine/lib/lpng/tests/pngvalid-transform b/Engine/lib/lpng/tests/pngvalid-transform
new file mode 100755
index 000000000..c7536aeb8
--- /dev/null
+++ b/Engine/lib/lpng/tests/pngvalid-transform
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec ./pngvalid --strict --transform

From 80aa9c8c5ecfbd762347b31c2af1add14be550a0 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Tue, 12 Oct 2021 22:08:32 -0500
Subject: [PATCH 186/399] partial rollback of #620 to stop win-side pop ups

---
 Tools/CMake/basics.cmake | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/Tools/CMake/basics.cmake b/Tools/CMake/basics.cmake
index 952826d97..174329713 100644
--- a/Tools/CMake/basics.cmake
+++ b/Tools/CMake/basics.cmake
@@ -364,10 +364,10 @@ macro(finishExecutable)
 endmacro()
 
 macro(setupVersionNumbers)
-    set(TORQUE_APP_VERSION_MAJOR 1 CACHE INTEGER "")
-    set(TORQUE_APP_VERSION_MINOR 0 CACHE INTEGER "")
-    set(TORQUE_APP_VERSION_PATCH 0 CACHE INTEGER "")
-    set(TORQUE_APP_VERSION_TWEAK 0 CACHE INTEGER "")
+    set(TORQUE_APP_VERSION_MAJOR 1 CACHE STRING "")
+    set(TORQUE_APP_VERSION_MINOR 0 CACHE STRING "")
+    set(TORQUE_APP_VERSION_PATCH 0 CACHE STRING "")
+    set(TORQUE_APP_VERSION_TWEAK 0 CACHE STRING "")
     mark_as_advanced(TORQUE_APP_VERSION_TWEAK)
     MATH(EXPR TORQUE_APP_VERSION "${TORQUE_APP_VERSION_MAJOR} * 1000 + ${TORQUE_APP_VERSION_MINOR} * 100 + ${TORQUE_APP_VERSION_PATCH} * 10 + ${TORQUE_APP_VERSION_TWEAK}")
     set(TORQUE_APP_VERSION_STRING "${TORQUE_APP_VERSION_MAJOR}.${TORQUE_APP_VERSION_MINOR}.${TORQUE_APP_VERSION_PATCH}.${TORQUE_APP_VERSION_TWEAK}")
@@ -436,11 +436,11 @@ if(WIN32)
     endif()
 else()
     # TODO: improve default settings on other platforms
-    set(TORQUE_CXX_FLAGS_EXECUTABLES "" CACHE TYPE STRING)
+    set(TORQUE_CXX_FLAGS_EXECUTABLES "" CACHE STRING "")
     mark_as_advanced(TORQUE_CXX_FLAGS_EXECUTABLES)
-    set(TORQUE_CXX_FLAGS_LIBS "" CACHE TYPE STRING)
+    set(TORQUE_CXX_FLAGS_LIBS "" CACHE STRING "")
     mark_as_advanced(TORQUE_CXX_FLAGS_LIBS)
-    set(TORQUE_CXX_FLAGS_COMMON "" CACHE TYPE STRING)
+    set(TORQUE_CXX_FLAGS_COMMON "" CACHE STRING "")
     mark_as_advanced(TORQUE_CXX_FLAGS)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${TORQUE_CXX_FLAGS}")
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_CXX_FLAGS}")

From bd9b3fd55ba27c596653e30cb9b894620c95b8ff Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Wed, 13 Oct 2021 11:40:54 -0400
Subject: [PATCH 187/399] * [Win32] Adjustment: Only trigger the Linux compat
 warning when TORQUE_POSIX_PATH_CASE_INSENSITIVE is disabled.

---
 Engine/source/platformWin32/winVolume.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Engine/source/platformWin32/winVolume.cpp b/Engine/source/platformWin32/winVolume.cpp
index af0bf96bc..5d168ac95 100644
--- a/Engine/source/platformWin32/winVolume.cpp
+++ b/Engine/source/platformWin32/winVolume.cpp
@@ -238,10 +238,12 @@ Win32FileSystem::~Win32FileSystem()
 
 void Win32FileSystem::verifyCompatibility(const Path& _path, WIN32_FIND_DATAW _info)
 {
+#ifndef TORQUE_POSIX_PATH_CASE_INSENSITIVE
    if (_path.getFullFileName().isNotEmpty() && _path.getFullFileName().compare(String(_info.cFileName)) != 0)
    {
       Con::warnf("Linux Compatibility Warning: %s != %s", String(_info.cFileName).c_str(), _path.getFullFileName().c_str());
    }
+#endif
 }
 
 FileNodeRef Win32FileSystem::resolve(const Path& path)

From 9d9db307c736f3a91b7c94b9152b58cba27a558a Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Wed, 13 Oct 2021 17:10:47 -0400
Subject: [PATCH 188/399] * [Build] BugFix: Correct CMake errors on Windows.

---
 Tools/CMake/basics.cmake | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Tools/CMake/basics.cmake b/Tools/CMake/basics.cmake
index 5a9fc0a42..a9004b7ba 100644
--- a/Tools/CMake/basics.cmake
+++ b/Tools/CMake/basics.cmake
@@ -400,17 +400,17 @@ set(TORQUE_STATIC ON)
 #option(TORQUE_STATIC "enables or disable static" OFF)
 
 if(WIN32)
-    set(TORQUE_CXX_FLAGS_EXECUTABLES "/wd4018 /wd4100 /wd4121 /wd4127 /wd4130 /wd4244 /wd4245 /wd4389 /wd4511 /wd4512 /wd4800 /wd4995 " CACHE STRING)
+    set(TORQUE_CXX_FLAGS_EXECUTABLES "/wd4018 /wd4100 /wd4121 /wd4127 /wd4130 /wd4244 /wd4245 /wd4389 /wd4511 /wd4512 /wd4800 /wd4995 " CACHE STRING "")
     mark_as_advanced(TORQUE_CXX_FLAGS_EXECUTABLES)
 
-    set(TORQUE_CXX_FLAGS_LIBS "/W0" CACHE STRING)
+    set(TORQUE_CXX_FLAGS_LIBS "/W0" CACHE STRING "")
     mark_as_advanced(TORQUE_CXX_FLAGS_LIBS)
 
     set(TORQUE_CXX_FLAGS_COMMON_DEFAULT "-DUNICODE -D_UNICODE -D_CRT_SECURE_NO_WARNINGS /MP /O2 /Ob2 /Oi /Ot /Oy /GT /Zi /W4 /nologo /GF /EHsc /GS- /Gy- /Qpar- /fp:precise /fp:except- /GR /Zc:wchar_t-" )
     if( TORQUE_CPU_X32 )
        set(TORQUE_CXX_FLAGS_COMMON_DEFAULT "${TORQUE_CXX_FLAGS_COMMON_DEFAULT} /arch:SSE2")
     endif()
-    set(TORQUE_CXX_FLAGS_COMMON ${TORQUE_CXX_FLAGS_COMMON_DEFAULT} CACHE STRING)
+    set(TORQUE_CXX_FLAGS_COMMON ${TORQUE_CXX_FLAGS_COMMON_DEFAULT} CACHE STRING "")
 
     mark_as_advanced(TORQUE_CXX_FLAGS_COMMON)
 

From 9217c62446c03fa3fc7f0ae542a6e82e0e21873f Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Thu, 14 Oct 2021 15:04:52 -0500
Subject: [PATCH 189/399] sound followups debug spam removal

---
 Engine/source/T3D/player.cpp | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/Engine/source/T3D/player.cpp b/Engine/source/T3D/player.cpp
index 7aabe0384..b1df95f36 100644
--- a/Engine/source/T3D/player.cpp
+++ b/Engine/source/T3D/player.cpp
@@ -477,9 +477,6 @@ bool PlayerData::preload(bool server, String &errorStr)
       {
          if (!getPlayerSoundProfile(i))
             Con::errorf("PlayerData::Preload() - unable to find sfxProfile for asset %d %s", i, mPlayerSoundAssetId[i]);
-
-         const char* enumString = castConsoleTypeToString(static_cast<Sounds>(i));
-            Con::printf("preload: %s = %s", enumString, mPlayerSoundAssetId[i]);
       }
    }
 

From 33210c4a1e8bf06b9464ba4501d339e33b12862d Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Thu, 14 Oct 2021 15:05:49 -0500
Subject: [PATCH 190/399] minor logic cleanups. we want to ensure if we *do*
 set the projectile sound to empty via editor, that gets propagated

---
 Engine/source/T3D/projectile.cpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/Engine/source/T3D/projectile.cpp b/Engine/source/T3D/projectile.cpp
index 4150f1506..e43372720 100644
--- a/Engine/source/T3D/projectile.cpp
+++ b/Engine/source/T3D/projectile.cpp
@@ -367,10 +367,9 @@ bool ProjectileData::preload(bool server, String &errorStr)
          if (Sim::findObject(decalId, decal) == false)
             Con::errorf(ConsoleLogEntry::General, "ProjectileData::preload: Invalid packet, bad datablockId(decal): %d", decalId);
 
+      _setProjectileSound(getProjectileSound());
       if (getProjectileSound() != StringTable->EmptyString())
       {
-         _setProjectileSound(getProjectileSound());
-
          if (!getProjectileSoundProfile())
             Con::errorf(ConsoleLogEntry::General, "SplashData::preload: Cant get an sfxProfile for splash.");
       }
@@ -1101,7 +1100,7 @@ void Projectile::explode( const Point3F &p, const Point3F &n, const U32 collideT
 
 void Projectile::updateSound()
 {
-   if (!mDataBlock->getProjectileSound())
+   if (!mDataBlock->isProjectileSoundValid())
       return;
 
    if ( mSound )

From 00515fffa84bf63de1bac4cc40cd4eb6d54ddd7f Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Thu, 14 Oct 2021 15:06:49 -0500
Subject: [PATCH 191/399] sound asset conversions - afxmagicmissile for a
 datablock case and guimltextcrtl for an object-instance case

---
 Engine/source/afx/afxMagicMissile.cpp        | 28 +++++++++++---------
 Engine/source/afx/afxMagicMissile.h          |  3 ++-
 Engine/source/gui/controls/guiMLTextCtrl.cpp | 11 +++++---
 Engine/source/gui/controls/guiMLTextCtrl.h   |  8 ++++--
 4 files changed, 30 insertions(+), 20 deletions(-)

diff --git a/Engine/source/afx/afxMagicMissile.cpp b/Engine/source/afx/afxMagicMissile.cpp
index a67447248..900a2db05 100644
--- a/Engine/source/afx/afxMagicMissile.cpp
+++ b/Engine/source/afx/afxMagicMissile.cpp
@@ -142,8 +142,7 @@ U32 Projectile::smProjectileWarpTicks = 5;
 afxMagicMissileData::afxMagicMissileData()
 {
    INIT_ASSET(ProjectileShape);
-
-   sound = NULL;
+   INIT_ASSET(ProjectileSound);
 
    /* From stock Projectile code...
    explosion = NULL;
@@ -248,7 +247,7 @@ afxMagicMissileData::afxMagicMissileData(const afxMagicMissileData& other, bool
 {
    CLONE_ASSET(ProjectileShape);
   projectileShape = other.projectileShape; // -- TSShape loads using projectileShapeName
-  sound = other.sound;
+  CLONE_ASSET(ProjectileSound);
   splash = other.splash;
   splashId = other.splashId; // -- for pack/unpack of splash ptr
   lightDesc = other.lightDesc;
@@ -338,7 +337,7 @@ void afxMagicMissileData::initPersistFields()
    INITPERSISTFIELD_SHAPEASSET(ProjectileShape, afxMagicMissileData, "Shape for the projectile");
    addField("scale", TypePoint3F, Offset(scale, afxMagicMissileData));
 
-   addField("sound", TypeSFXTrackName, Offset(sound, afxMagicMissileData));
+   INITPERSISTFIELD_SOUNDASSET(ProjectileSound, afxMagicMissileData, "sound for the projectile");
 
    /* From stock Projectile code...
    addField("explosion", TYPEID< ExplosionData >(), Offset(explosion, ProjectileData));
@@ -533,9 +532,12 @@ bool afxMagicMissileData::preload(bool server, String &errorStr)
             Con::errorf(ConsoleLogEntry::General, "ProjectileData::preload: Invalid packet, bad datablockId(decal): %d", decalId);
       */
 
-      String sfxErrorStr;
-      if( !sfxResolve( &sound, sfxErrorStr) )
-         Con::errorf(ConsoleLogEntry::General, "afxMagicMissileData::preload: Invalid packet: %s", sfxErrorStr.c_str());
+      _setProjectileSound(getProjectileSound());
+      if (getProjectileSound() != StringTable->EmptyString())
+      {
+         if (!getProjectileSoundProfile())
+            Con::errorf(ConsoleLogEntry::General, "afxMagicMissileData::preload: Cant get an sfxProfile for afxMagicMissileData.");
+      }
 
       if (!lightDesc && lightDescId != 0)
          if (Sim::findObject(lightDescId, lightDesc) == false)
@@ -547,7 +549,7 @@ bool afxMagicMissileData::preload(bool server, String &errorStr)
       projectileShape = mProjectileShapeAsset->getShapeResource();
       if (bool(projectileShape) == false)
       {
-         errorStr = String::ToString("afxMagicMissileData::load: Couldn't load shape \"%s\"", mProjectileShapeAssetId);
+         errorStr = String::ToString("afxMagicMissileData::preload: Couldn't load shape \"%s\"", mProjectileShapeAssetId);
          return false;
       }
       /* From stock Projectile code...
@@ -641,7 +643,7 @@ void afxMagicMissileData::packData(BitStream* stream)
                                               DataBlockObjectIdLast);
    */
 
-   sfxWrite( stream, sound );
+   PACKDATA_ASSET(ProjectileSound);
 
    if ( stream->writeFlag(lightDesc != NULL))
       stream->writeRangedU32(lightDesc->getId(), DataBlockObjectIdFirst,
@@ -747,7 +749,7 @@ void afxMagicMissileData::unpackData(BitStream* stream)
       decalId = stream->readRangedU32(DataBlockObjectIdFirst, DataBlockObjectIdLast);
    */
    
-   sfxRead( stream, &sound );
+   UNPACKDATA_ASSET(ProjectileSound);
 
    if (stream->readFlag())
       lightDescId = stream->readRangedU32(DataBlockObjectIdFirst, DataBlockObjectIdLast);
@@ -1170,8 +1172,8 @@ bool afxMagicMissile::onNewDataBlock(GameBaseData* dptr, bool reload)
 
       SFX_DELETE( mSound );
 
-      if ( mDataBlock->sound )
-         mSound = SFX->createSource( mDataBlock->sound );
+      if (mDataBlock->getProjectileSound())
+         mSound = SFX->createSource(mDataBlock->getProjectileSoundProfile());
    }
 
    return true;
@@ -2006,7 +2008,7 @@ void afxMagicMissile::get_launch_data(Point3F& pos, Point3F& vel)
 
 void afxMagicMissile::updateSound()
 {
-  if (!mDataBlock->sound)
+  if (!mDataBlock->isProjectileSoundValid())
     return;
 
   if ( mSound )
diff --git a/Engine/source/afx/afxMagicMissile.h b/Engine/source/afx/afxMagicMissile.h
index 626dfd91d..4b3430918 100644
--- a/Engine/source/afx/afxMagicMissile.h
+++ b/Engine/source/afx/afxMagicMissile.h
@@ -126,7 +126,8 @@ public:
   SplashData* splash;                 // Water Splash Datablock
   S32 splashId;                       // Water splash ID
 
-  SFXTrack* sound;                    // Projectile Sound
+  DECLARE_SOUNDASSET(afxMagicMissileData, ProjectileSound);
+  DECLARE_ASSET_SETGET(afxMagicMissileData, ProjectileSound);
 
   LightDescription *lightDesc;
   S32 lightDescId;   
diff --git a/Engine/source/gui/controls/guiMLTextCtrl.cpp b/Engine/source/gui/controls/guiMLTextCtrl.cpp
index 85d093f26..1b1c3184f 100644
--- a/Engine/source/gui/controls/guiMLTextCtrl.cpp
+++ b/Engine/source/gui/controls/guiMLTextCtrl.cpp
@@ -268,7 +268,7 @@ GuiMLTextCtrl::GuiMLTextCtrl()
 {   
    mActive = true;
    //mInitialText = StringTable->EmptyString();
-   Sim::findObject("InputDeniedSound", mDeniedSound);
+   INIT_ASSET(DeniedSound);
 }
 
 //--------------------------------------------------------------------------
@@ -290,7 +290,7 @@ void GuiMLTextCtrl::initPersistFields()
       addField("lineSpacing",       TypeS32,    Offset(mLineSpacingPixels, GuiMLTextCtrl), "The number of blank pixels to place between each line.\n");
       addField("allowColorChars",   TypeBool,   Offset(mAllowColorChars,   GuiMLTextCtrl), "If true, the control will allow characters to have unique colors.");
       addField("maxChars",          TypeS32,    Offset(mMaxBufferSize,     GuiMLTextCtrl), "Maximum number of characters that the control will display.");
-      addField("deniedSound",       TypeSFXTrackName, Offset(mDeniedSound, GuiMLTextCtrl), "If the text will not fit in the control, the deniedSound is played.");
+      INITPERSISTFIELD_SOUNDASSET(DeniedSound, GuiMLTextCtrl, "If the text will not fit in the control, the deniedSound is played.");
       addField("text",              TypeCaseString,  Offset( mInitialText, GuiMLTextCtrl ), "Text to display in this control.");
       addField("useURLMouseCursor", TypeBool,   Offset(mUseURLMouseCursor,   GuiMLTextCtrl), "If true, the mouse cursor will turn into a hand cursor while over a link in the text.\n"
                                                                       "This is dependant on the markup language used by the GuiMLTextCtrl\n");
@@ -323,6 +323,9 @@ bool GuiMLTextCtrl::onAdd()
 
    if (!mTextBuffer.length() && mInitialText[0] != 0)
       setText(mInitialText, dStrlen(mInitialText)+1);
+
+   _setDeniedSound(getDeniedSound());
+
    return true;
 }
 
@@ -917,8 +920,8 @@ void GuiMLTextCtrl::insertChars(const char* inputChars,
    if (numCharsToInsert <= 0)
    {
       // Play the "Denied" sound:
-      if ( numInputChars > 0 && mDeniedSound )
-         SFX->playOnce(mDeniedSound);
+      if ( numInputChars > 0 && getDeniedSoundProfile())
+         SFX->playOnce(getDeniedSoundProfile());
 
       return;
    }
diff --git a/Engine/source/gui/controls/guiMLTextCtrl.h b/Engine/source/gui/controls/guiMLTextCtrl.h
index 8eb3ff263..177d4e0c4 100644
--- a/Engine/source/gui/controls/guiMLTextCtrl.h
+++ b/Engine/source/gui/controls/guiMLTextCtrl.h
@@ -31,6 +31,10 @@
 #include "core/stringBuffer.h"
 #endif
 
+#ifndef SOUND_ASSET_H
+#include "T3D/assets/SoundAsset.h"
+#endif
+
 class GFont;
 class SFXTrack;
 
@@ -258,8 +262,8 @@ class GuiMLTextCtrl : public GuiControl
    bool mUseURLMouseCursor;
 
    // Too many chars sound:
-   SFXTrack*  mDeniedSound;
-
+   DECLARE_SOUNDASSET(GuiMLTextCtrl, DeniedSound);
+   DECLARE_ASSET_SETGET(GuiMLTextCtrl, DeniedSound);
    //-------------------------------------- Protected interface
   protected:
    // Inserting and deleting character blocks...

From adbd6d07116a146480f613ea53e41b9111274ccd Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Thu, 14 Oct 2021 15:12:50 -0500
Subject: [PATCH 192/399] sound asset conversions importer script updates -
 afxmagicmissile for a datablock case and guimltextcrtl for an object-instance
 case

---
 .../scripts/pre40/T3Dpre4ProjectImporter.tscript             | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
index 119ba6066..e1a4d7c4b 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
@@ -839,7 +839,7 @@ T3Dpre4ProjectImporter::genProcessor("LevelInfo", "accuTexture accuTextureAsset"
 T3Dpre4ProjectImporter::genProcessor("TSStatic", "shape shapeAsset shapeName shapeAsset");
 T3Dpre4ProjectImporter::genProcessor("TSForestItemData", "shape shapeAsset shapeName shapeAsset shapeFile shapeAsset");
 T3Dpre4ProjectImporter::genProcessor("TerrainBlock", "terrainFile terrainAsset");
-T3Dpre4ProjectImporter::genProcessor("afxMagicMissileData", "projectileShapeName projectileShapeAsset sound soundAsset");
+T3Dpre4ProjectImporter::genProcessor("afxMagicMissileData", "projectileShape projectileShapeAsset projectileShapeName projectileShapeAsset sound projectileSoundAsset");
 T3Dpre4ProjectImporter::genProcessor("afxBillboardData", "texture textureAsset");
 T3Dpre4ProjectImporter::genProcessor("afxModelData", "shapeName shapeAsset shapeFile shapeAsset");
 T3Dpre4ProjectImporter::genProcessor("afxZodiacData", "texture textureAsset");
@@ -902,6 +902,7 @@ T3Dpre4ProjectImporter::genProcessor("GuiProgressBitmap", "bitmap bitmapAsset");
 T3Dpre4ProjectImporter::genProcessor("GuiMissionArea", "handleBitmap handleBitmapAsset");
 T3Dpre4ProjectImporter::genProcessor("WorldEditor", "selectHandle selectHandleAsset defaultHandle defaultHandleAsset lockedHandle lockedHandleAsset");
 T3Dpre4ProjectImporter::genProcessor("GuiControlProfile", "bitmap bitmapAsset");
+T3Dpre4ProjectImporter::genProcessor("GuiMLTextCtrl", "deniedSound deniedSoundAsset");
 
 function T3Dpre4ProjectImporter::processGuiBitmapButtonCtrlLine(%this, %line)
 {
@@ -925,7 +926,7 @@ T3Dpre4ProjectImporter::genProcessor("SplashData", "texture textureAsset soundPr
 T3Dpre4ProjectImporter::genProcessor("LightFlareData", "flareTexture flareTextureAsset");
 T3Dpre4ProjectImporter::genProcessor("PhysicsDebrisData", "shape shapeAsset shapeFile shapeAsset");
 T3Dpre4ProjectImporter::genProcessor("PhysicsShapeData", "shape shapeAsset shapeName shapeAsset");
-T3Dpre4ProjectImporter::genProcessor("ProjectileData", "projectileShape projectileShapeAsset projectileShapeName projectileShapeAsset sound soundAsset");
+T3Dpre4ProjectImporter::genProcessor("ProjectileData", "projectileShape projectileShapeAsset projectileShapeName projectileShapeAsset sound projectileSoundAsset");
 T3Dpre4ProjectImporter::genProcessor("ShapeBaseData", "shapeFile shapeAsset shape shapeAsset debrisShape debrisShapeAsset debrisShapeName debrisShapeAsset");
 T3Dpre4ProjectImporter::genProcessor("ShapeBaseImageData", "shape shapeAsset[0] shapeFP shapeAsset[1] shapeFile shapeAsset[0] shapeFileFP shapeAsset[1] stateSound stateSoundAsset");
 T3Dpre4ProjectImporter::genProcessor("ProximityMineData","armingSound ArmSoundAsset TriggerSound TriggerSoundAsset");

From 2586e73145d7f2afa8e51bbc9c4be9f8106b44c7 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Thu, 14 Oct 2021 19:40:16 -0400
Subject: [PATCH 193/399] * BugFix: Correct a few memory leaks.

---
 Engine/source/core/util/str.h                  | 4 +++-
 Engine/source/gfx/bitmap/loaders/bitmapTga.cpp | 1 +
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/Engine/source/core/util/str.h b/Engine/source/core/util/str.h
index abd693dba..8da5b10bb 100644
--- a/Engine/source/core/util/str.h
+++ b/Engine/source/core/util/str.h
@@ -361,7 +361,9 @@ class StringBuilder
       {
          va_list args;
          va_start(args, fmt);
-         return mFormat.formatAppend(fmt, args);
+         const S32 result = mFormat.formatAppend(fmt, args);
+         va_end(args);
+         return result;
       }
 };
 
diff --git a/Engine/source/gfx/bitmap/loaders/bitmapTga.cpp b/Engine/source/gfx/bitmap/loaders/bitmapTga.cpp
index 978532892..08eeacb92 100644
--- a/Engine/source/gfx/bitmap/loaders/bitmapTga.cpp
+++ b/Engine/source/gfx/bitmap/loaders/bitmapTga.cpp
@@ -471,6 +471,7 @@ static bool sReadTGA(Stream &stream, GBitmap *bitmap)
 
    default:
        //Con::errorf( "Unknown image type" );
+      delete[] colormap;
       return false;
    }
 

From c2fdb733fa7281769037fc12e9c1acc112dfa077 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Thu, 14 Oct 2021 19:07:36 -0500
Subject: [PATCH 194/399] make mat editor list and set soundassets

---
 .../scripts/materialEditor.ed.tscript              | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
index 8a21c9907..5deca8a4c 100644
--- a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
@@ -95,11 +95,15 @@ function MaterialEditorGui::open(%this)
 
    %sounds = "<None>" TAB "<Soft>" TAB "<Hard>" TAB "<Metal>" TAB "<Snow>";    // Default sounds
 
-   // Get custom sound datablocks
-   foreach (%db in DataBlockSet)
+   %assetQuery = new AssetQuery();
+   AssetDatabase.findAssetType(%assetQuery, "SoundAsset");
+   
+   %count = %assetQuery.getCount();   
+   // Get custom sound assets
+   for(%i=0; %i < %count; %i++)
    {
-      if (%db.isMemberOfClass("SFXTrack"))
-         %sounds = %sounds TAB %db.getName();
+	   %assetId = %assetQuery.getAsset(%i);
+       %sounds = %sounds TAB %assetId;
    }
 
    %count = getFieldCount(%sounds);
@@ -1504,7 +1508,7 @@ function MaterialEditorGui::updateBehaviorSound(%this, %type, %sound)
    }
 
    %this.updateActiveMaterial(%type @ "SoundId", %defaultId);
-   %this.updateActiveMaterial("custom" @ %type @ "Sound", %customName);
+   %this.updateActiveMaterial("custom" @ %type @ "SoundAsset", %customName);
 }
 
 function MaterialEditorGui::updateSoundPopup(%this, %type, %defaultId, %customName)

From 9af2de3c4b2327afce95872a5212bbd7938836d3 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Thu, 14 Oct 2021 19:07:48 -0500
Subject: [PATCH 195/399] upconverter tweaks

---
 .../pre40/T3Dpre4ProjectImporter.tscript      | 58 +++++--------------
 1 file changed, 14 insertions(+), 44 deletions(-)

diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
index e1a4d7c4b..a80b4362e 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
@@ -938,13 +938,13 @@ T3Dpre4ProjectImporter::genProcessor("HoverVehicleData", "engineSound engineSoun
 //==============================================================================
 // Datablocks - Long Lists
 //==============================================================================
-
+// - RigidShapeData
 $rigidEntriesList = "softImpactSound softImpactSoundAsset hardImpactSound hardImpactSoundAsset";
 $rigidEntriesList = $rigidEntriesList SPC "exitingWater exitingWaterAsset impactWaterEasy impactWaterEasyAsset";
 $rigidEntriesList = $rigidEntriesList SPC "impactWaterMedium impactWaterMediumAsset impactWaterHard impactWaterHardAsset";
 $rigidEntriesList = $rigidEntriesList SPC "waterWakeSound waterWakeSoundAsset";
 T3Dpre4ProjectImporter::genProcessor("RigidShapeData",$rigidEntriesList);
-
+// - PlayerData
 $PlayerEntriesList = "shapeFP shapeFPAsset shapeNameFP shapeFPAsset";
 $PlayerEntriesList = $PlayerEntriesList SPC "FootSoftSound FootSoftAsset FootHardSound FootHardAsset FootMetalSound FootMetal";
 $PlayerEntriesList = $PlayerEntriesList SPC "FootSnowSound FootSnowAsset FootShallowSound FootShallowSplashAsset";
@@ -955,50 +955,21 @@ $PlayerEntriesList = $PlayerEntriesList SPC "impactSoftSound ImpactSoftAsset imp
 $PlayerEntriesList = $PlayerEntriesList SPC "impactMetalSound ImpactMetalAsset impactSnowSound impactSnowAsset";
 $PlayerEntriesList = $PlayerEntriesList SPC "impactWaterEasy impactWaterEasyAsset impactWaterMedium impactWaterMediumAsset impactWaterHard impactWaterHardAsset";
 $PlayerEntriesList = $PlayerEntriesList SPC "exitingWater ExitWaterAsset";
-
-
 T3Dpre4ProjectImporter::genProcessor("PlayerData", $PlayerEntriesList);
+// - Material
+$MaterialEntriesList = "baseTex diffuseMapAsset diffuseMap diffuseMapAsset";
+$MaterialEntriesList = $MaterialEntriesList SPC "lightMap lightMapAsset toneMap toneMapAsset";
+$MaterialEntriesList = $MaterialEntriesList SPC "detailTex detailMapAsset detailMap detailMapAsset detailNormalMap detailNormalMapAsset";
+$MaterialEntriesList = $MaterialEntriesList SPC "overlayTex overlayMapAsset overlayMap overlayMapAsset";
+$MaterialEntriesList = $MaterialEntriesList SPC "bumpTex normalMapAsset normalMap normalMapAsset
+$MaterialEntriesList = $MaterialEntriesList SPC "ormConfigMap ormConfigMapAsset roughMap roughMapAsset";
+$MaterialEntriesList = $MaterialEntriesList SPC "aoMap aoMapAsset metalMap metalMapAsset";
+$MaterialEntriesList = $MaterialEntriesList SPC "glowMap glowMapAsset";
+$MaterialEntriesList = $MaterialEntriesList SPC "customFootstepSound customFootstepSoundAsset customImpactSound customImpactSoundAsset";
+T3Dpre4ProjectImporter::genProcessor("Material", $MaterialEntriesList);
 //==============================================================================
 // Materials
 //==============================================================================
-//long form of the result of T3Dpre4ProjectImporter::genProcessor since that would result in a rediculously long oneliner
-function T3Dpre4ProjectImporter::processMaterialLine(%this, %line)
-{
-   %outLine = processLegacyField(%line, "baseTex", "diffuseMapAsset");
-   if(%outLine !$= %line) return %outLine;
-   %outLine = processLegacyField(%line, "diffuseMap", "diffuseMapAsset");
-   if(%outLine !$= %line) return %outLine;
-   %outLine = processLegacyField(%line, "lightMap", "lightMapAsset");
-   if(%outLine !$= %line) return %outLine;
-   %outLine = processLegacyField(%line, "toneMap", "toneMapAsset");
-   if(%outLine !$= %line) return %outLine;
-   %outLine = processLegacyField(%line, "detailTex", "detailMapAsset");
-   if(%outLine !$= %line) return %outLine;
-   %outLine = processLegacyField(%line, "detailMap", "detailMapAsset");
-   if(%outLine !$= %line) return %outLine;
-   %outLine = processLegacyField(%line, "overlayTex", "overlayMapAsset");
-   if(%outLine !$= %line) return %outLine;
-   %outLine = processLegacyField(%line, "overlayMap", "overlayMapAsset");
-   if(%outLine !$= %line) return %outLine;
-   %outLine = processLegacyField(%line, "bumpTex", "normalMapAsset");
-   if(%outLine !$= %line) return %outLine;
-   %outLine = processLegacyField(%line, "normalMap", "normalMapAsset");
-   if(%outLine !$= %line) return %outLine;
-   %outLine = processLegacyField(%line, "ormConfigMap", "ormConfigMapAsset");
-   if(%outLine !$= %line) return %outLine;
-   %outLine = processLegacyField(%line, "roughMap", "roughMapAsset");
-   if(%outLine !$= %line) return %outLine;
-   %outLine = processLegacyField(%line, "aoMap", "aoMapAsset");
-   if(%outLine !$= %line) return %outLine;
-   %outLine = processLegacyField(%line, "metalMap", "metalMapAsset");
-   if(%outLine !$= %line) return %outLine;
-   %outLine = processLegacyField(%line, "glowMap", "glowMapAsset");
-   if(%outLine !$= %line) return %outLine;
-   %outLine = processLegacyField(%line, "detailNormalMap", "detailNormalMapAsset");
-   if(%outLine !$= %line) return %outLine;
-   return %line;
-}
-
 function T3Dpre4ProjectImporter::processMaterialObject(%this, %file, %objectName)
 {
    %matAsset = MaterialAsset::getAssetIdByMaterialName(%objectName);
@@ -1343,5 +1314,4 @@ function processGuiBitmapButtonCtrlField(%line, %originalFieldName, %newFieldNam
    {
       return %line;  
    }
-}
-
+}
\ No newline at end of file

From f0d919e85900b1b14b247833770f482dd11f9aab Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Thu, 14 Oct 2021 19:09:20 -0500
Subject: [PATCH 196/399] sound asset conversions -  materials

---
 Engine/source/T3D/player.cpp                   | 8 ++++----
 Engine/source/materials/materialDefinition.cpp | 7 ++++---
 Engine/source/materials/materialDefinition.h   | 9 +++++++--
 3 files changed, 15 insertions(+), 9 deletions(-)

diff --git a/Engine/source/T3D/player.cpp b/Engine/source/T3D/player.cpp
index b1df95f36..6ff20e298 100644
--- a/Engine/source/T3D/player.cpp
+++ b/Engine/source/T3D/player.cpp
@@ -7042,11 +7042,11 @@ void Player::playFootstepSound( bool triggeredLeft, Material* contactMaterial, S
          }
       }
    }
-   else if( contactMaterial && contactMaterial->mFootstepSoundCustom )
+   else if( contactMaterial && contactMaterial->getCustomFootstepSoundProfile())
    {
       // Footstep sound defined on material.
 
-      SFX->playOnce( contactMaterial->mFootstepSoundCustom, &footMat );
+      SFX->playOnce( contactMaterial->getCustomFootstepSoundProfile(), &footMat );
    }
    else
    {
@@ -7079,8 +7079,8 @@ void Player:: playImpactSound()
       {
          Material* material = ( rInfo.material ? dynamic_cast< Material* >( rInfo.material->getMaterial() ) : 0 );
 
-         if( material && material->mImpactSoundCustom )
-            SFX->playOnce( material->mImpactSoundCustom, &getTransform() );
+         if( material && material->getCustomImpactSoundProfile() )
+            SFX->playOnce( material->getCustomImpactSoundProfile(), &getTransform() );
          else
          {
             S32 sound = -1;
diff --git a/Engine/source/materials/materialDefinition.cpp b/Engine/source/materials/materialDefinition.cpp
index 07a769ee7..1ed904bee 100644
--- a/Engine/source/materials/materialDefinition.cpp
+++ b/Engine/source/materials/materialDefinition.cpp
@@ -231,7 +231,8 @@ Material::Material()
 
    mFootstepSoundId = -1;     mImpactSoundId = -1;
    mImpactFXIndex = -1;
-   mFootstepSoundCustom = 0;  mImpactSoundCustom = 0;
+   INIT_ASSET(CustomFootstepSound);
+   INIT_ASSET(CustomImpactSound);
    mFriction = 0.0;
 
    mDirectSoundOcclusion = 1.f;
@@ -476,7 +477,7 @@ void Material::initPersistFields()
       "- 16: PlayerData::impactWaterHard\n"
       "- 17: PlayerData::exitingWater\n");
 
-   addField("customFootstepSound", TypeSFXTrackName, Offset(mFootstepSoundCustom, Material),
+   INITPERSISTFIELD_SOUNDASSET(CustomFootstepSound, Material,
       "The sound to play when the player walks over the material.  If this is set, it overrides #footstepSoundId.  This field is "
       "useful for directly assigning custom footstep sounds to materials without having to rely on the PlayerData sound assignment.\n\n"
       "@warn Be aware that materials are client-side objects.  This means that the SFXTracks assigned to materials must be client-side, too.");
@@ -488,7 +489,7 @@ void Material::initPersistFields()
       "What FX to play from the PlayerData sound list when the player impacts on the surface with a velocity equal or greater "
       "than PlayerData::groundImpactMinSpeed.\n\n"
       "For a list of IDs, see #impactFXId");
-   addField("customImpactSound", TypeSFXTrackName, Offset(mImpactSoundCustom, Material),
+   INITPERSISTFIELD_SOUNDASSET(CustomImpactSound, Material,
       "The sound to play when the player impacts on the surface with a velocity equal or greater than PlayerData::groundImpactMinSpeed.  "
       "If this is set, it overrides #impactSoundId.  This field is useful for directly assigning custom impact sounds to materials "
       "without having to rely on the PlayerData sound assignment.\n\n"
diff --git a/Engine/source/materials/materialDefinition.h b/Engine/source/materials/materialDefinition.h
index 0e258e2c5..e29f53695 100644
--- a/Engine/source/materials/materialDefinition.h
+++ b/Engine/source/materials/materialDefinition.h
@@ -47,6 +47,9 @@
 #ifndef _ASSET_PTR_H_
 #include "assets/assetPtr.h"
 #endif
+#ifndef SOUND_ASSET_H
+#include "T3D/assets/SoundAsset.h"
+#endif
 
 class CubemapData;
 class SFXTrack;
@@ -367,8 +370,10 @@ public:
    /// Sound effect to play when walking on surface with this material.
    /// If defined, overrides mFootstepSoundId.
    /// @see mFootstepSoundId
-   SFXTrack* mFootstepSoundCustom;
-   SFXTrack* mImpactSoundCustom;
+   DECLARE_SOUNDASSET(Material, CustomFootstepSound);
+   DECLARE_ASSET_SETGET(Material, CustomFootstepSound);
+   DECLARE_SOUNDASSET(Material, CustomImpactSound);
+   DECLARE_ASSET_SETGET(Material, CustomImpactSound);
 
    F32 mFriction;                   ///< Friction coefficient when moving along surface.
 

From 42b862a54b9e4983715523ca12ec9b15eb0d8170 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Thu, 14 Oct 2021 20:36:00 -0400
Subject: [PATCH 197/399] * [Unix] BugFix: Correct a fatal error that may be
 thrown from functions like isFile is passed a bad path.

---
 Engine/source/platformPOSIX/posixVolume.cpp     |  6 +++---
 Engine/source/platformX86UNIX/x86UNIXFileio.cpp | 16 +++++++++++-----
 2 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/Engine/source/platformPOSIX/posixVolume.cpp b/Engine/source/platformPOSIX/posixVolume.cpp
index b8b070217..6e691dbbc 100644
--- a/Engine/source/platformPOSIX/posixVolume.cpp
+++ b/Engine/source/platformPOSIX/posixVolume.cpp
@@ -42,7 +42,7 @@
 
 
 //#define DEBUG_SPEW
-extern void ResolvePathCaseInsensitive(char* pathName, S32 pathNameSize);
+extern bool ResolvePathCaseInsensitive(char* pathName, S32 pathNameSize, bool requiredAbsolute);
 
 namespace Torque
 {
@@ -160,8 +160,7 @@ FileNodeRef PosixFileSystem::resolve(const Path& path)
    UTF8* caseSensitivePath = new UTF8[fileLength + 1];
    dMemcpy(caseSensitivePath, file.c_str(), fileLength);
    caseSensitivePath[fileLength] = 0x00;
-   ResolvePathCaseInsensitive(caseSensitivePath, fileLength);
-
+   ResolvePathCaseInsensitive(caseSensitivePath, fileLength, false);
    String caseSensitiveFile(caseSensitivePath);
 #else
    String caseSensitiveFile = file;
@@ -181,6 +180,7 @@ FileNodeRef PosixFileSystem::resolve(const Path& path)
 #ifdef TORQUE_POSIX_PATH_CASE_INSENSITIVE
    delete[] caseSensitivePath;
 #endif
+
    return result;
 }
 
diff --git a/Engine/source/platformX86UNIX/x86UNIXFileio.cpp b/Engine/source/platformX86UNIX/x86UNIXFileio.cpp
index 9669638ae..a3d6c2d55 100644
--- a/Engine/source/platformX86UNIX/x86UNIXFileio.cpp
+++ b/Engine/source/platformX86UNIX/x86UNIXFileio.cpp
@@ -183,12 +183,17 @@ bool dPathCopy(const char *fromName, const char *toName, bool nooverwrite)
  // munge the case of the specified pathName.  This means try to find the actual
  // filename in with case-insensitive matching on the specified pathName, and
  // store the actual found name.
- void ResolvePathCaseInsensitive(char* pathName, S32 pathNameSize)
+ bool ResolvePathCaseInsensitive(char* pathName, S32 pathNameSize, bool requiredAbsolute)
  {
     char tempBuf[MaxPath];
     dStrncpy(tempBuf, pathName, pathNameSize);
 
-    AssertFatal(pathName[0] == '/', "PATH must be absolute");
+    // Check if we're an absolute path
+    if (pathName[0] != '/')
+    {
+        AssertFatal(!requiredAbsolute, "PATH must be absolute");
+        return false;
+    }
 
     struct stat filestat;
     const int MaxPathEl = 200;
@@ -196,6 +201,7 @@ bool dPathCopy(const char *fromName, const char *toName, bool nooverwrite)
     char testPath[MaxPath];
     char pathEl[MaxPathEl];
     bool done = false;
+    bool foundMatch = false;
 
     dStrncpy(tempBuf, "/", MaxPath);
     currChar++;
@@ -220,7 +226,6 @@ bool dPathCopy(const char *fromName, const char *toName, bool nooverwrite)
        {
           DIR *dir = opendir(tempBuf);
           struct dirent* ent;
-          bool foundMatch = false;
           while (dir != NULL && (ent = readdir(dir)) != NULL)
           {
              if (dStricmp(pathEl, ent->d_name) == 0)
@@ -247,6 +252,7 @@ bool dPathCopy(const char *fromName, const char *toName, bool nooverwrite)
     }
 
     dStrncpy(pathName, tempBuf, pathNameSize);
+    return foundMatch;
  }
 
  //-----------------------------------------------------------------------------
@@ -296,7 +302,7 @@ bool dPathCopy(const char *fromName, const char *toName, bool nooverwrite)
        return;
 
     // otherwise munge the case of the path
-     ResolvePathCaseInsensitive(dest, destSize);
+     ResolvePathCaseInsensitive(dest, destSize, true);
  }
 
  //-----------------------------------------------------------------------------
@@ -1291,7 +1297,7 @@ bool dPathCopy(const char *fromName, const char *toName, bool nooverwrite)
    // Load path into temporary buffer
    dMemcpy(caseSensitivePath, path, pathLength);
    caseSensitivePath[pathLength] = 0x00;
-   ResolvePathCaseInsensitive(caseSensitivePath, pathLength);
+   ResolvePathCaseInsensitive(caseSensitivePath, pathLength, false);
 #else
    const char* caseSensitivePath = path;
 #endif

From 9ab5f61c39a59fccd38fb88b7b32a09a3635fdf2 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Thu, 14 Oct 2021 22:31:00 -0500
Subject: [PATCH 198/399] sound asset conversions -  ambience

---
 Engine/source/sfx/sfxAmbience.cpp             | 19 ++++++++++++-------
 Engine/source/sfx/sfxAmbience.h               | 11 ++++++-----
 Engine/source/sfx/sfxSoundscape.cpp           |  2 +-
 .../pre40/T3Dpre4ProjectImporter.tscript      |  1 +
 4 files changed, 20 insertions(+), 13 deletions(-)

diff --git a/Engine/source/sfx/sfxAmbience.cpp b/Engine/source/sfx/sfxAmbience.cpp
index e24b5b6e2..fa1d9ed5b 100644
--- a/Engine/source/sfx/sfxAmbience.cpp
+++ b/Engine/source/sfx/sfxAmbience.cpp
@@ -85,10 +85,10 @@ SFXAmbience::ChangeSignal SFXAmbience::smChangeSignal;
 SFXAmbience::SFXAmbience()
    : mDopplerFactor( 0.5f ),
      mRolloffFactor( 1.f ),
-     mSoundTrack( NULL ),
      mEnvironment( NULL )
 {
    dMemset( mState, 0, sizeof( mState ) );
+   INIT_ASSET(SoundTrack);
 }
 
 //-----------------------------------------------------------------------------
@@ -100,7 +100,7 @@ void SFXAmbience::initPersistFields()
       addField( "environment",            TypeSFXEnvironmentName, Offset( mEnvironment, SFXAmbience ),
          "Reverb environment active in the ambience zone.\n"
          "@ref SFX_reverb" );
-      addField( "soundTrack",             TypeSFXTrackName,       Offset( mSoundTrack, SFXAmbience ),
+      INITPERSISTFIELD_SOUNDASSET(SoundTrack, SFXAmbience,
          "Sound track to play in the ambience zone." );
       addField( "rolloffFactor",          TypeF32, Offset( mRolloffFactor, SFXAmbience ),
          "The rolloff factor to apply to distance-based volume attenuation in this space.\n"
@@ -131,7 +131,8 @@ bool SFXAmbience::onAdd()
       return false;
       
    Sim::getSFXAmbienceSet()->addObject( this );
-      
+
+   _setSoundTrack(getSoundTrack());
    return true;
 }
 
@@ -150,9 +151,13 @@ bool SFXAmbience::preload( bool server, String& errorStr )
    {
       if( !sfxResolve( &mEnvironment, errorStr ) )
          return false;
-         
-      if( !sfxResolve( &mSoundTrack, errorStr ) )
+
+      _setSoundTrack(getSoundTrack());
+      if (!getSoundTrackProfile())
+      {
+         Con::errorf("SFXAmbience::Preload() - unable to find sfxProfile for asset %s", mSoundTrackAssetId);
          return false;
+      }
          
       for( U32 i = 0; i < MaxStates; ++ i )
          if( !sfxResolve( &mState[ i ], errorStr ) )
@@ -169,7 +174,7 @@ void SFXAmbience::packData( BitStream* stream )
    Parent::packData( stream );
       
    sfxWrite( stream, mEnvironment );
-   sfxWrite( stream, mSoundTrack );
+   PACKDATA_ASSET(SoundTrack);
    
    stream->write( mRolloffFactor );
    stream->write( mDopplerFactor );
@@ -185,7 +190,7 @@ void SFXAmbience::unpackData( BitStream* stream )
    Parent::unpackData( stream );
       
    sfxRead( stream, &mEnvironment );
-   sfxRead( stream, &mSoundTrack );
+   UNPACKDATA_ASSET(SoundTrack);
    
    stream->read( &mRolloffFactor );
    stream->read( &mDopplerFactor );
diff --git a/Engine/source/sfx/sfxAmbience.h b/Engine/source/sfx/sfxAmbience.h
index 22d91be4e..598d42596 100644
--- a/Engine/source/sfx/sfxAmbience.h
+++ b/Engine/source/sfx/sfxAmbience.h
@@ -33,6 +33,9 @@
    #include "core/util/tSignal.h"
 #endif
 
+#ifndef SOUND_ASSET_H
+#include "T3D/assets/SoundAsset.h"
+#endif
 
 class SFXEnvironment;
 class SFXTrack;
@@ -63,7 +66,8 @@ class SFXAmbience : public SimDataBlock
       F32 mRolloffFactor;
    
       /// Sound track to play when inside the ambient space.
-      SFXTrack* mSoundTrack;
+      DECLARE_SOUNDASSET(SFXAmbience, SoundTrack);
+      DECLARE_ASSET_SETGET(SFXAmbience, SoundTrack);
 
       /// Reverb environment to apply when inside the ambient space.
       SFXEnvironment* mEnvironment;
@@ -89,10 +93,7 @@ class SFXAmbience : public SimDataBlock
             
       /// Return the reverb environment of the ambient space.
       SFXEnvironment* getEnvironment() const { return mEnvironment; }
-      
-      /// Return the ambient soundtrack of this ambient space.
-      SFXTrack* getSoundTrack() const { return mSoundTrack; }
-      
+            
       /// Return the given state bound to this ambient space.
       SFXState* getState( U32 i ) const
       {
diff --git a/Engine/source/sfx/sfxSoundscape.cpp b/Engine/source/sfx/sfxSoundscape.cpp
index 855ebd2be..c90015ffc 100644
--- a/Engine/source/sfx/sfxSoundscape.cpp
+++ b/Engine/source/sfx/sfxSoundscape.cpp
@@ -150,7 +150,7 @@ void SFXSoundscapeManager::update()
          
          if( !soundscape->_isOverridden() )
          {
-            SFXTrack* track = ambience->getSoundTrack();
+            SFXTrack* track = ambience->getSoundTrackProfile();
             if( !soundscape->mSource || soundscape->mSource->getTrack() != track )
             {
                if( soundscape->mSource != NULL )
diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
index a80b4362e..67d683968 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
@@ -1079,6 +1079,7 @@ T3Dpre4ProjectImporter::genProcessor("PostEffect", "texture textureAsset");
 // Using existing SFXProfiles allows us to also injest the descriptions, giving us
 // our meta-properties on the sound asset itself.
 //==============================================================================
+T3Dpre4ProjectImporter::genProcessor("SFXAmbience", "soundTrack soundTrackAsset");
 function T3Dpre4ProjectImporter::processSFXProfileLine(%this, %line)
 {
    return %line;

From 670b246a2acb5cf27365c5c7d6e8eaf36c80c36a Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Thu, 14 Oct 2021 22:33:13 -0500
Subject: [PATCH 199/399] sound asset conversions -  playlist (as a point of
 significance, that no longer uses  mSlots.mTrack[ i ] on the backend. just th
 equivalent of mTrack[i]. While the former was certainly useful for
 clustering, it's actively fighting standarization)

---
 Engine/source/sfx/sfxController.cpp                |  4 ++--
 Engine/source/sfx/sfxPlayList.cpp                  | 14 ++++++++++----
 Engine/source/sfx/sfxPlayList.h                    | 14 ++++++++------
 .../scripts/pre40/T3Dpre4ProjectImporter.tscript   |  2 ++
 4 files changed, 22 insertions(+), 12 deletions(-)

diff --git a/Engine/source/sfx/sfxController.cpp b/Engine/source/sfx/sfxController.cpp
index 6bb5924b9..4946280ff 100644
--- a/Engine/source/sfx/sfxController.cpp
+++ b/Engine/source/sfx/sfxController.cpp
@@ -166,7 +166,7 @@ void SFXController::_compileList( SFXPlayList* playList )
       
       // If there's no track in this slot, ignore it.
       
-      if( !playList->getSlots().mTrack[ slotIndex ] )
+      if( !playList->getTrackProfile(slotIndex))
          continue;
          
       // If this is a looped slot and the list is not set to loop
@@ -393,7 +393,7 @@ bool SFXController::_execInsn()
       case OP_Play:
       {
          SFXPlayList* playList = getPlayList();
-         SFXTrack* track = playList->getSlots().mTrack[ insn.mSlotIndex ];
+         SFXTrack* track = playList->getTrackProfile(insn.mSlotIndex);
          
          // Handle existing sources playing on this slot and find
          // whether we need to start a new source.
diff --git a/Engine/source/sfx/sfxPlayList.cpp b/Engine/source/sfx/sfxPlayList.cpp
index ffbbaf68d..0e56d4607 100644
--- a/Engine/source/sfx/sfxPlayList.cpp
+++ b/Engine/source/sfx/sfxPlayList.cpp
@@ -220,6 +220,8 @@ SFXPlayList::SFXPlayList()
      mTrace( false ),
      mNumSlotsToPlay( NUM_SLOTS )
 {
+   for (U32 i=0;i<NUM_SLOTS;i++)
+      INIT_ASSET_ARRAY(Track, i);
 }
 
 //-----------------------------------------------------------------------------
@@ -247,7 +249,7 @@ void SFXPlayList::initPersistFields()
    
       addArray( "slots", NUM_SLOTS );
       
-         addField( "track",                  TypeSFXTrackName, Offset( mSlots.mTrack, SFXPlayList ), NUM_SLOTS,
+         INITPERSISTFIELD_SOUNDASSET_ARRAY( Track, NUM_SLOTS, SFXPlayList,
             "Track to play in this slot.\n"
             "This must be set for the slot to be considered for playback.  Other settings for a slot "
             "will not take effect except this field is set." );
@@ -350,8 +352,12 @@ bool SFXPlayList::preload( bool server, String& errorStr )
    {
       for( U32 i = 0; i < NUM_SLOTS; ++ i )
       {
-         if( !sfxResolve( &mSlots.mTrack[ i ], errorStr ) )
+         _setTrack(getTrack(i),i);
+         if (!getTrackProfile(i))
+         {
+            Con::errorf("SFXPlayList::Preload() - unable to find sfxProfile for asset %s", mTrackAssetId[i]);
             return false;
+         }
             
          if( !sfxResolve( &mSlots.mState[ i ], errorStr ) )
             return false;
@@ -419,7 +425,7 @@ void SFXPlayList::packData( BitStream* stream )
       stream->write( mSlots.mRepeatCount[ i ] );
       
    FOR_EACH_SLOT sfxWrite( stream, mSlots.mState[ i ] );
-   FOR_EACH_SLOT sfxWrite( stream, mSlots.mTrack[ i ] );
+   FOR_EACH_SLOT PACKDATA_ASSET_ARRAY(Track, i);
 }
 
 //-----------------------------------------------------------------------------
@@ -458,7 +464,7 @@ void SFXPlayList::unpackData( BitStream* stream )
    FOR_EACH_SLOT if(stream->readFlag()){ stream->read( &mSlots.mRepeatCount[ i ] );}
       
    FOR_EACH_SLOT sfxRead( stream, &mSlots.mState[ i ] );
-   FOR_EACH_SLOT sfxRead( stream, &mSlots.mTrack[ i ] );
+   FOR_EACH_SLOT UNPACKDATA_ASSET_ARRAY(Track, i);
    
    #undef FOR_EACH_SLOT
 }
diff --git a/Engine/source/sfx/sfxPlayList.h b/Engine/source/sfx/sfxPlayList.h
index 6bde33734..1043bf988 100644
--- a/Engine/source/sfx/sfxPlayList.h
+++ b/Engine/source/sfx/sfxPlayList.h
@@ -30,6 +30,10 @@
    #include "sfx/sfxTrack.h"
 #endif
 
+#ifndef SOUND_ASSET_H
+#include "T3D/assets/SoundAsset.h"
+#endif
+
 
 class SFXState;
 
@@ -256,10 +260,7 @@ class SFXPlayList : public SFXTrack
          /// Bahavior when state of this slot is deactivated and the slot's track
          /// is playing.
          EStateMode mStateMode[ NUM_SLOTS ];
-         
-         /// Track to play in this slot.
-         SFXTrack* mTrack[ NUM_SLOTS ];
-         
+
          SlotData()
          {
             dMemset( mReplayMode, 0, sizeof( mReplayMode ) );
@@ -267,7 +268,6 @@ class SFXPlayList : public SFXTrack
             dMemset( mTransitionOut, 0, sizeof( mTransitionOut ) );
             dMemset( mRepeatCount, 0, sizeof( mRepeatCount ) );
             dMemset( mState, 0, sizeof( mState ) );
-            dMemset( mTrack, 0, sizeof( mTrack ) );
             dMemset( mStateMode, 0, sizeof( mStateMode ) );
             
             for( U32 i = 0; i < NUM_SLOTS; ++ i )
@@ -282,7 +282,9 @@ class SFXPlayList : public SFXTrack
             }
          }
       };
-                        
+      DECLARE_SOUNDASSET_ARRAY(SFXPlayList, Track, NUM_SLOTS);
+      DECLARE_ASSET_ARRAY_SETGET(SFXPlayList, Track);
+
    protected:
    
       /// Trace interpreter execution.  This field is not networked.
diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
index 67d683968..78cdfecf8 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
@@ -1080,6 +1080,8 @@ T3Dpre4ProjectImporter::genProcessor("PostEffect", "texture textureAsset");
 // our meta-properties on the sound asset itself.
 //==============================================================================
 T3Dpre4ProjectImporter::genProcessor("SFXAmbience", "soundTrack soundTrackAsset");
+T3Dpre4ProjectImporter::genProcessor("SFXPlayList", "track trackAsset");
+
 function T3Dpre4ProjectImporter::processSFXProfileLine(%this, %line)
 {
    return %line;

From 58170a7805bec916f02e029ad20d6f700c03d928 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Sun, 17 Oct 2021 18:21:29 -0400
Subject: [PATCH 200/399] * [AssetBrowser] BugFix: Correct a case where creator
 categories may get shoved into the first module in the tree when entering
 asset select mode.

---
 .../game/tools/assetBrowser/scripts/assetBrowser.tscript       | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
index 660577c78..d3e2996e0 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
@@ -628,7 +628,8 @@ function AssetBrowser::loadDirectories( %this )
    
    %this.loadTags();
    
-   %this.loadCreatorClasses();
+   if (!%this.selectMode)
+      %this.loadCreatorClasses();
    
    //If set to, show core
    if(EditorSettings.value("Assets/Browser/showCoreModule", false) == 1)

From 0b24c728ea74c9f8f06bb90c97a72b2ef8b63a56 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Mon, 18 Oct 2021 09:46:58 -0400
Subject: [PATCH 201/399] * [GLSL] BugFix: Correct invalid relative include
 paths in lightRayOcclude.glsl.

---
 .../game/core/postFX/scripts/LightRays/lightRayOccludeP.glsl  | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Templates/BaseGame/game/core/postFX/scripts/LightRays/lightRayOccludeP.glsl b/Templates/BaseGame/game/core/postFX/scripts/LightRays/lightRayOccludeP.glsl
index 1f5fdf102..02ffe0bac 100644
--- a/Templates/BaseGame/game/core/postFX/scripts/LightRays/lightRayOccludeP.glsl
+++ b/Templates/BaseGame/game/core/postFX/scripts/LightRays/lightRayOccludeP.glsl
@@ -20,9 +20,9 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../../gl/hlslCompat.glsl"
+#include "../../../rendering/shaders/gl/hlslCompat.glsl"
 #include "shadergen:/autogenConditioners.h"
-#include "../../gl/postFx.glsl"
+#include "../../../rendering/shaders/postFX/gl/postFx.glsl"
 
 uniform sampler2D backBuffer;   // The original backbuffer.
 uniform sampler2D deferredTex;   // The pre-pass depth and normals.

From 4293aef8588b88184605d820e283138b16305053 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Tue, 19 Oct 2021 20:34:57 -0400
Subject: [PATCH 202/399] This one slipped through - nextToken can't use local
 variable for its token variable. This was stated as one of the breaking
 changes in the origional PR.

---
 Engine/source/console/consoleFunctions.cpp | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/Engine/source/console/consoleFunctions.cpp b/Engine/source/console/consoleFunctions.cpp
index 9a57c31c1..ceac8de6d 100644
--- a/Engine/source/console/consoleFunctions.cpp
+++ b/Engine/source/console/consoleFunctions.cpp
@@ -1703,12 +1703,7 @@ DefineEngineFunction( nextToken, const char*, ( const char* str1, const char* to
       if (*str)
          *str++ = 0;
 
-      // set local variable if inside a function
-      if (gEvalState.getStackDepth() > 0 && 
-         gEvalState.getCurrentFrame().scopeName)
-         Con::setLocalVariable(token,tmp);
-      else
-         Con::setVariable(token,tmp);
+      Con::setVariable(token,tmp);
 
       // advance str past the 'delim space'
       while (isInSet(*str, delim))

From 4af4d90f4a874cb14d9d2216b5260d81bf136b59 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Tue, 19 Oct 2021 20:38:13 -0400
Subject: [PATCH 203/399] Get rid of setLocalVariable entirely.

---
 Engine/source/console/console.cpp | 6 ------
 Engine/source/console/console.h   | 9 ---------
 2 files changed, 15 deletions(-)

diff --git a/Engine/source/console/console.cpp b/Engine/source/console/console.cpp
index 643f8cbec..750db2a17 100644
--- a/Engine/source/console/console.cpp
+++ b/Engine/source/console/console.cpp
@@ -861,12 +861,6 @@ void setVariable(const char *name, const char *value)
    }
 }
 
-void setLocalVariable(const char *name, const char *value)
-{
-   name = prependPercent(name);
-   gEvalState.getCurrentFrame().setVariable(StringTable->insert(name), value);
-}
-
 void setBoolVariable(const char *varName, bool value)
 {
    SimObject *obj = NULL;
diff --git a/Engine/source/console/console.h b/Engine/source/console/console.h
index 5c72f34e1..8816e4e99 100644
--- a/Engine/source/console/console.h
+++ b/Engine/source/console/console.h
@@ -720,15 +720,6 @@ namespace Con
    ///
    void removeVariableNotify(const char *name, const NotifyDelegate &callback);
 
-   /// Assign a string value to a locally scoped console variable
-   ///
-   /// @note The context of the variable is determined by gEvalState; that is,
-   ///       by the currently executing code.
-   ///
-   /// @param name   Local console variable name to set
-   /// @param value  String value to assign to name
-   void setLocalVariable(const char *name, const char *value);
-
    /// Retrieve the string value to a locally scoped console variable
    ///
    /// @note The context of the variable is determined by gEvalState; that is,

From 4758f7bdaf6347aaee88b7381701a1f3f7f16692 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Thu, 21 Oct 2021 21:14:55 -0400
Subject: [PATCH 204/399] * Adjustment: Update Assimp version to 5.0.1.

---
 Engine/lib/assimp/code/3DS/3DSConverter.cpp   |    4 +-
 Engine/lib/assimp/code/3DS/3DSExporter.cpp    |    2 +-
 Engine/lib/assimp/code/3DS/3DSExporter.h      |    2 +-
 Engine/lib/assimp/code/3DS/3DSHelper.h        |    2 +-
 Engine/lib/assimp/code/3DS/3DSLoader.cpp      |    4 +-
 Engine/lib/assimp/code/3DS/3DSLoader.h        |    2 +-
 Engine/lib/assimp/code/3MF/3MFXmlTags.h       |    2 +-
 Engine/lib/assimp/code/3MF/D3MFExporter.cpp   |    2 +-
 Engine/lib/assimp/code/3MF/D3MFExporter.h     |    2 +-
 Engine/lib/assimp/code/3MF/D3MFImporter.cpp   |    2 +-
 Engine/lib/assimp/code/3MF/D3MFImporter.h     |    2 +-
 Engine/lib/assimp/code/3MF/D3MFOpcPackage.cpp |    2 +-
 Engine/lib/assimp/code/3MF/D3MFOpcPackage.h   |    2 +-
 Engine/lib/assimp/code/AC/ACLoader.cpp        |    2 +-
 Engine/lib/assimp/code/AC/ACLoader.h          |    2 +-
 Engine/lib/assimp/code/AMF/AMFImporter.cpp    |    2 +-
 Engine/lib/assimp/code/AMF/AMFImporter.hpp    |    2 +-
 .../assimp/code/AMF/AMFImporter_Geometry.cpp  |    2 +-
 .../lib/assimp/code/AMF/AMFImporter_Macro.hpp |    2 +-
 .../assimp/code/AMF/AMFImporter_Material.cpp  |    2 +-
 .../lib/assimp/code/AMF/AMFImporter_Node.hpp  |    2 +-
 .../code/AMF/AMFImporter_Postprocess.cpp      |    2 +-
 Engine/lib/assimp/code/ASE/ASELoader.cpp      |    2 +-
 Engine/lib/assimp/code/ASE/ASELoader.h        |    2 +-
 Engine/lib/assimp/code/ASE/ASEParser.cpp      |    2 +-
 Engine/lib/assimp/code/ASE/ASEParser.h        |    2 +-
 .../lib/assimp/code/Assbin/AssbinExporter.cpp |  797 ++-
 .../lib/assimp/code/Assbin/AssbinExporter.h   |    2 +-
 .../assimp/code/Assbin/AssbinFileWriter.cpp   |  858 ---
 .../lib/assimp/code/Assbin/AssbinFileWriter.h |   66 -
 .../lib/assimp/code/Assbin/AssbinLoader.cpp   |    4 +-
 Engine/lib/assimp/code/Assbin/AssbinLoader.h  |    2 +-
 Engine/lib/assimp/code/Assjson/cencode.c      |   10 +-
 .../lib/assimp/code/Assxml/AssxmlExporter.cpp |  603 +-
 .../lib/assimp/code/Assxml/AssxmlExporter.h   |    2 +-
 .../assimp/code/Assxml/AssxmlFileWriter.cpp   |  664 --
 .../lib/assimp/code/Assxml/AssxmlFileWriter.h |   65 -
 Engine/lib/assimp/code/B3D/B3DImporter.cpp    |  185 +-
 Engine/lib/assimp/code/B3D/B3DImporter.h      |    2 +-
 Engine/lib/assimp/code/BVH/BVHLoader.cpp      |    2 +-
 Engine/lib/assimp/code/BVH/BVHLoader.h        |    2 +-
 .../lib/assimp/code/Blender/BlenderBMesh.cpp  |    2 +-
 Engine/lib/assimp/code/Blender/BlenderBMesh.h |    2 +-
 Engine/lib/assimp/code/Blender/BlenderDNA.cpp |    2 +-
 Engine/lib/assimp/code/Blender/BlenderDNA.h   |    2 +-
 Engine/lib/assimp/code/Blender/BlenderDNA.inl |    2 +-
 .../assimp/code/Blender/BlenderIntermediate.h |    2 +-
 .../lib/assimp/code/Blender/BlenderLoader.cpp |    2 +-
 .../lib/assimp/code/Blender/BlenderLoader.h   |    2 +-
 .../assimp/code/Blender/BlenderModifier.cpp   |    2 +-
 .../lib/assimp/code/Blender/BlenderModifier.h |    2 +-
 .../lib/assimp/code/Blender/BlenderScene.cpp  |    2 +-
 Engine/lib/assimp/code/Blender/BlenderScene.h |    2 +-
 .../lib/assimp/code/Blender/BlenderSceneGen.h |    2 +-
 .../code/Blender/BlenderTessellator.cpp       |    2 +-
 .../assimp/code/Blender/BlenderTessellator.h  |    2 +-
 Engine/lib/assimp/code/C4D/C4DImporter.cpp    |    2 +-
 Engine/lib/assimp/code/C4D/C4DImporter.h      |    2 +-
 Engine/lib/assimp/code/CApi/AssimpCExport.cpp |    2 +-
 .../assimp/code/CApi/CInterfaceIOWrapper.cpp  |    2 +-
 .../assimp/code/CApi/CInterfaceIOWrapper.h    |    2 +-
 Engine/lib/assimp/code/CMakeLists.txt         |  346 +-
 Engine/lib/assimp/code/COB/COBLoader.cpp      |    4 +-
 Engine/lib/assimp/code/COB/COBLoader.h        |    2 +-
 Engine/lib/assimp/code/COB/COBScene.h         |    2 +-
 Engine/lib/assimp/code/CSM/CSMLoader.cpp      |    4 +-
 Engine/lib/assimp/code/CSM/CSMLoader.h        |    2 +-
 .../assimp/code/Collada/ColladaExporter.cpp   |  165 +-
 .../lib/assimp/code/Collada/ColladaExporter.h |    2 +-
 .../lib/assimp/code/Collada/ColladaHelper.cpp |  107 -
 .../lib/assimp/code/Collada/ColladaHelper.h   |   42 +-
 .../lib/assimp/code/Collada/ColladaLoader.cpp |   84 +-
 .../lib/assimp/code/Collada/ColladaLoader.h   |    7 +-
 .../lib/assimp/code/Collada/ColladaParser.cpp |  220 +-
 .../lib/assimp/code/Collada/ColladaParser.h   |   12 +-
 Engine/lib/assimp/code/Common/Assimp.cpp      |    2 +-
 .../lib/assimp/code/Common/BaseImporter.cpp   |   24 +-
 Engine/lib/assimp/code/Common/BaseProcess.cpp |   41 +-
 Engine/lib/assimp/code/Common/BaseProcess.h   |  131 +-
 Engine/lib/assimp/code/Common/Bitmap.cpp      |    2 +-
 .../lib/assimp/code/Common/CreateAnimMesh.cpp |    2 +-
 .../assimp/code/Common/DefaultIOStream.cpp    |   35 +-
 .../assimp/code/Common/DefaultIOSystem.cpp    |    2 +-
 .../lib/assimp/code/Common/DefaultLogger.cpp  |    6 +-
 .../code/Common/DefaultProgressHandler.h      |    2 +-
 Engine/lib/assimp/code/Common/Exporter.cpp    |  135 +-
 Engine/lib/assimp/code/Common/FileLogStream.h |    2 +-
 .../lib/assimp/code/Common/FileSystemFilter.h |    2 +-
 Engine/lib/assimp/code/Common/Importer.cpp    |  292 +-
 Engine/lib/assimp/code/Common/Importer.h      |    2 +-
 .../assimp/code/Common/ImporterRegistry.cpp   |    8 +-
 Engine/lib/assimp/code/Common/PolyTools.h     |    2 +-
 .../assimp/code/Common/PostStepRegistry.cpp   |   11 +-
 .../lib/assimp/code/Common/RemoveComments.cpp |    2 +-
 .../lib/assimp/code/Common/SGSpatialSort.cpp  |    2 +-
 .../lib/assimp/code/Common/SceneCombiner.cpp  |   24 +-
 .../assimp/code/Common/ScenePreprocessor.cpp  |   11 +-
 .../assimp/code/Common/ScenePreprocessor.h    |    2 +-
 Engine/lib/assimp/code/Common/ScenePrivate.h  |    2 +-
 .../code/Common/SkeletonMeshBuilder.cpp       |    2 +-
 Engine/lib/assimp/code/Common/SpatialSort.cpp |    2 +-
 .../lib/assimp/code/Common/StandardShapes.cpp |    2 +-
 .../assimp/code/Common/StdOStreamLogStream.h  |    2 +-
 Engine/lib/assimp/code/Common/Subdivision.cpp |    2 +-
 .../assimp/code/Common/TargetAnimation.cpp    |    2 +-
 .../lib/assimp/code/Common/TargetAnimation.h  |    2 +-
 Engine/lib/assimp/code/Common/Version.cpp     |   22 +-
 .../code/Common/VertexTriangleAdjacency.cpp   |    6 +-
 .../code/Common/VertexTriangleAdjacency.h     |    2 +-
 .../assimp/code/Common/Win32DebugLogStream.h  |    2 +-
 .../assimp/code/Common/ZipArchiveIOSystem.cpp |    4 +-
 Engine/lib/assimp/code/Common/assbin_chunks.h |    2 +-
 Engine/lib/assimp/code/Common/material.cpp    |   97 -
 Engine/lib/assimp/code/Common/scene.cpp       |   20 +-
 Engine/lib/assimp/code/Common/simd.cpp        |    2 +-
 Engine/lib/assimp/code/Common/simd.h          |    2 +-
 Engine/lib/assimp/code/DXF/DXFHelper.h        |    2 +-
 Engine/lib/assimp/code/DXF/DXFLoader.cpp      |    2 +-
 Engine/lib/assimp/code/DXF/DXFLoader.h        |    2 +-
 Engine/lib/assimp/code/FBX/FBXAnimation.cpp   |    2 +-
 .../assimp/code/FBX/FBXBinaryTokenizer.cpp    |    2 +-
 Engine/lib/assimp/code/FBX/FBXCommon.h        |    9 +-
 Engine/lib/assimp/code/FBX/FBXCompileConfig.h |   10 +-
 Engine/lib/assimp/code/FBX/FBXConverter.cpp   |  367 +-
 Engine/lib/assimp/code/FBX/FBXConverter.h     |   87 +-
 Engine/lib/assimp/code/FBX/FBXDeformer.cpp    |    2 +-
 Engine/lib/assimp/code/FBX/FBXDocument.cpp    |    2 +-
 Engine/lib/assimp/code/FBX/FBXDocument.h      |   41 +-
 .../lib/assimp/code/FBX/FBXDocumentUtil.cpp   |    2 +-
 Engine/lib/assimp/code/FBX/FBXDocumentUtil.h  |    2 +-
 Engine/lib/assimp/code/FBX/FBXExportNode.cpp  |   16 +-
 Engine/lib/assimp/code/FBX/FBXExportNode.h    |    2 +-
 .../lib/assimp/code/FBX/FBXExportProperty.cpp |    2 +-
 .../lib/assimp/code/FBX/FBXExportProperty.h   |    2 +-
 Engine/lib/assimp/code/FBX/FBXExporter.cpp    |   13 +-
 Engine/lib/assimp/code/FBX/FBXExporter.h      |    2 +-
 .../lib/assimp/code/FBX/FBXImportSettings.h   |    2 +-
 Engine/lib/assimp/code/FBX/FBXImporter.cpp    |  194 +-
 Engine/lib/assimp/code/FBX/FBXImporter.h      |    2 +-
 Engine/lib/assimp/code/FBX/FBXMaterial.cpp    |    2 +-
 .../lib/assimp/code/FBX/FBXMeshGeometry.cpp   |   33 +-
 Engine/lib/assimp/code/FBX/FBXMeshGeometry.h  |    2 +-
 Engine/lib/assimp/code/FBX/FBXModel.cpp       |    2 +-
 .../lib/assimp/code/FBX/FBXNodeAttribute.cpp  |    2 +-
 Engine/lib/assimp/code/FBX/FBXParser.cpp      |   10 +-
 Engine/lib/assimp/code/FBX/FBXParser.h        |    2 +-
 Engine/lib/assimp/code/FBX/FBXProperties.cpp  |    2 +-
 Engine/lib/assimp/code/FBX/FBXProperties.h    |    2 +-
 Engine/lib/assimp/code/FBX/FBXTokenizer.cpp   |    2 +-
 Engine/lib/assimp/code/FBX/FBXTokenizer.h     |    2 +-
 Engine/lib/assimp/code/FBX/FBXUtil.cpp        |    2 +-
 Engine/lib/assimp/code/FBX/FBXUtil.h          |    2 +-
 Engine/lib/assimp/code/HMP/HMPFileData.h      |    2 +-
 Engine/lib/assimp/code/HMP/HMPLoader.cpp      |    2 +-
 Engine/lib/assimp/code/HMP/HMPLoader.h        |    2 +-
 Engine/lib/assimp/code/HMP/HalfLifeFileData.h |    2 +-
 .../assimp/code/Importer/IFC/IFCBoolean.cpp   |    2 +-
 .../lib/assimp/code/Importer/IFC/IFCCurve.cpp |    6 +-
 .../assimp/code/Importer/IFC/IFCGeometry.cpp  |    7 +-
 .../assimp/code/Importer/IFC/IFCLoader.cpp    |    2 +-
 .../lib/assimp/code/Importer/IFC/IFCLoader.h  |    2 +-
 .../assimp/code/Importer/IFC/IFCMaterial.cpp  |    2 +-
 .../assimp/code/Importer/IFC/IFCOpenings.cpp  |    2 +-
 .../assimp/code/Importer/IFC/IFCProfile.cpp   |    2 +-
 .../code/Importer/IFC/IFCReaderGen1_2x3.cpp   |    2 +-
 .../code/Importer/IFC/IFCReaderGen2_2x3.cpp   |    2 +-
 .../code/Importer/IFC/IFCReaderGen_2x3.h      |    2 +-
 .../code/Importer/IFC/IFCReaderGen_4.cpp      |    2 +-
 .../assimp/code/Importer/IFC/IFCReaderGen_4.h |    2 +-
 .../lib/assimp/code/Importer/IFC/IFCUtil.cpp  |    2 +-
 Engine/lib/assimp/code/Importer/IFC/IFCUtil.h |    2 +-
 .../Importer/STEPParser/STEPFileEncoding.cpp  |    2 +-
 .../Importer/STEPParser/STEPFileEncoding.h    |    2 +-
 .../Importer/STEPParser/STEPFileReader.cpp    |    2 +-
 .../code/Importer/STEPParser/STEPFileReader.h |    2 +-
 .../code/Importer/StepFile/StepFileGen1.cpp   |    2 +-
 .../code/Importer/StepFile/StepFileGen2.cpp   |    2 +-
 .../code/Importer/StepFile/StepFileGen3.cpp   |    2 +-
 .../Importer/StepFile/StepFileImporter.cpp    |    2 +-
 .../code/Importer/StepFile/StepFileImporter.h |    2 +-
 .../code/Importer/StepFile/StepReaderGen.h    |    2 +-
 Engine/lib/assimp/code/Irr/IRRLoader.cpp      |    2 +-
 Engine/lib/assimp/code/Irr/IRRLoader.h        |    2 +-
 Engine/lib/assimp/code/Irr/IRRMeshLoader.cpp  |    3 +-
 Engine/lib/assimp/code/Irr/IRRMeshLoader.h    |    2 +-
 Engine/lib/assimp/code/Irr/IRRShared.cpp      |    2 +-
 Engine/lib/assimp/code/LWO/LWOAnimation.cpp   |    2 +-
 Engine/lib/assimp/code/LWO/LWOAnimation.h     |    2 +-
 Engine/lib/assimp/code/LWO/LWOBLoader.cpp     |    2 +-
 Engine/lib/assimp/code/LWO/LWOFileData.h      |    2 +-
 Engine/lib/assimp/code/LWO/LWOLoader.cpp      |    4 +-
 Engine/lib/assimp/code/LWO/LWOLoader.h        |    2 +-
 Engine/lib/assimp/code/LWO/LWOMaterial.cpp    |    2 +-
 Engine/lib/assimp/code/LWS/LWSLoader.cpp      |    2 +-
 Engine/lib/assimp/code/LWS/LWSLoader.h        |    2 +-
 Engine/lib/assimp/code/M3D/M3DExporter.cpp    |  437 --
 Engine/lib/assimp/code/M3D/M3DExporter.h      |   94 -
 Engine/lib/assimp/code/M3D/M3DImporter.cpp    |  806 ---
 Engine/lib/assimp/code/M3D/M3DImporter.h      |  103 -
 Engine/lib/assimp/code/M3D/M3DMaterials.h     |  106 -
 Engine/lib/assimp/code/M3D/M3DWrapper.cpp     |  142 -
 Engine/lib/assimp/code/M3D/M3DWrapper.h       |  101 -
 Engine/lib/assimp/code/M3D/m3d.h              | 5612 -----------------
 Engine/lib/assimp/code/MD2/MD2FileData.h      |    2 +-
 Engine/lib/assimp/code/MD2/MD2Loader.cpp      |    2 +-
 Engine/lib/assimp/code/MD2/MD2Loader.h        |    2 +-
 Engine/lib/assimp/code/MD2/MD2NormalTable.h   |    2 +-
 Engine/lib/assimp/code/MD3/MD3FileData.h      |    2 +-
 Engine/lib/assimp/code/MD3/MD3Loader.cpp      |    4 +-
 Engine/lib/assimp/code/MD3/MD3Loader.h        |    2 +-
 Engine/lib/assimp/code/MD4/MD4FileData.h      |    2 +-
 Engine/lib/assimp/code/MD5/MD5Loader.cpp      |    2 +-
 Engine/lib/assimp/code/MD5/MD5Loader.h        |    2 +-
 Engine/lib/assimp/code/MD5/MD5Parser.cpp      |    2 +-
 Engine/lib/assimp/code/MD5/MD5Parser.h        |    2 +-
 Engine/lib/assimp/code/MDC/MDCFileData.h      |    2 +-
 Engine/lib/assimp/code/MDC/MDCLoader.cpp      |    4 +-
 Engine/lib/assimp/code/MDC/MDCLoader.h        |    2 +-
 .../assimp/code/MDL/HalfLife/HL1FileData.h    |  600 --
 .../code/MDL/HalfLife/HL1ImportDefinitions.h  |   64 -
 .../code/MDL/HalfLife/HL1ImportSettings.h     |   85 -
 .../assimp/code/MDL/HalfLife/HL1MDLLoader.cpp | 1348 ----
 .../assimp/code/MDL/HalfLife/HL1MDLLoader.h   |  241 -
 .../assimp/code/MDL/HalfLife/HL1MeshTrivert.h |  127 -
 .../assimp/code/MDL/HalfLife/LogFunctions.h   |   95 -
 .../code/MDL/HalfLife/UniqueNameGenerator.cpp |  180 -
 .../code/MDL/HalfLife/UniqueNameGenerator.h   |   81 -
 .../lib/assimp/code/MDL/MDLDefaultColorMap.h  |    2 +-
 Engine/lib/assimp/code/MDL/MDLFileData.h      |    2 +-
 Engine/lib/assimp/code/MDL/MDLLoader.cpp      |  200 +-
 Engine/lib/assimp/code/MDL/MDLLoader.h        |   12 +-
 .../lib/assimp/code/MDL/MDLMaterialLoader.cpp |    8 +-
 Engine/lib/assimp/code/MMD/MMDCpp14.h         |    2 +-
 Engine/lib/assimp/code/MMD/MMDImporter.cpp    |    2 +-
 Engine/lib/assimp/code/MMD/MMDImporter.h      |    2 +-
 Engine/lib/assimp/code/MMD/MMDPmdParser.h     |    2 +-
 Engine/lib/assimp/code/MMD/MMDPmxParser.cpp   |    2 +-
 Engine/lib/assimp/code/MMD/MMDPmxParser.h     |    2 +-
 Engine/lib/assimp/code/MMD/MMDVmdParser.h     |    2 +-
 Engine/lib/assimp/code/MS3D/MS3DLoader.cpp    |    2 +-
 Engine/lib/assimp/code/MS3D/MS3DLoader.h      |    2 +-
 .../assimp/code/Material/MaterialSystem.cpp   |   15 +-
 .../lib/assimp/code/Material/MaterialSystem.h |    2 +-
 Engine/lib/assimp/code/NDO/NDOLoader.cpp      |    2 +-
 Engine/lib/assimp/code/NDO/NDOLoader.h        |    2 +-
 Engine/lib/assimp/code/NFF/NFFLoader.cpp      |    2 +-
 Engine/lib/assimp/code/NFF/NFFLoader.h        |    2 +-
 Engine/lib/assimp/code/OFF/OFFLoader.cpp      |    2 +-
 Engine/lib/assimp/code/OFF/OFFLoader.h        |    2 +-
 Engine/lib/assimp/code/Obj/ObjExporter.cpp    |    2 +-
 Engine/lib/assimp/code/Obj/ObjExporter.h      |    2 +-
 Engine/lib/assimp/code/Obj/ObjFileData.h      |   17 +-
 .../lib/assimp/code/Obj/ObjFileImporter.cpp   |   51 +-
 Engine/lib/assimp/code/Obj/ObjFileImporter.h  |    2 +-
 .../assimp/code/Obj/ObjFileMtlImporter.cpp    |    6 +-
 .../lib/assimp/code/Obj/ObjFileMtlImporter.h  |    2 +-
 Engine/lib/assimp/code/Obj/ObjFileParser.cpp  |   50 +-
 Engine/lib/assimp/code/Obj/ObjFileParser.h    |    4 +-
 Engine/lib/assimp/code/Obj/ObjTools.h         |    2 +-
 .../assimp/code/Ogre/OgreBinarySerializer.cpp |    2 +-
 .../assimp/code/Ogre/OgreBinarySerializer.h   |    2 +-
 Engine/lib/assimp/code/Ogre/OgreImporter.cpp  |    2 +-
 Engine/lib/assimp/code/Ogre/OgreImporter.h    |    2 +-
 Engine/lib/assimp/code/Ogre/OgreMaterial.cpp  |    2 +-
 .../lib/assimp/code/Ogre/OgreParsingUtils.h   |    2 +-
 Engine/lib/assimp/code/Ogre/OgreStructs.cpp   |    2 +-
 Engine/lib/assimp/code/Ogre/OgreStructs.h     |    2 +-
 .../assimp/code/Ogre/OgreXmlSerializer.cpp    |    2 +-
 .../lib/assimp/code/Ogre/OgreXmlSerializer.h  |    2 +-
 .../assimp/code/OpenGEX/OpenGEXExporter.cpp   |    2 +-
 .../lib/assimp/code/OpenGEX/OpenGEXExporter.h |    2 +-
 .../assimp/code/OpenGEX/OpenGEXImporter.cpp   |    2 +-
 .../lib/assimp/code/OpenGEX/OpenGEXImporter.h |    2 +-
 .../lib/assimp/code/OpenGEX/OpenGEXStructs.h  |    2 +-
 Engine/lib/assimp/code/Ply/PlyExporter.cpp    |    7 +-
 Engine/lib/assimp/code/Ply/PlyExporter.h      |    2 +-
 Engine/lib/assimp/code/Ply/PlyLoader.cpp      |    3 +-
 Engine/lib/assimp/code/Ply/PlyLoader.h        |    2 +-
 Engine/lib/assimp/code/Ply/PlyParser.cpp      |    2 +-
 Engine/lib/assimp/code/Ply/PlyParser.h        |    2 +-
 .../code/PostProcessing/ArmaturePopulate.cpp  |  262 -
 .../code/PostProcessing/ArmaturePopulate.h    |  112 -
 .../PostProcessing/CalcTangentsProcess.cpp    |    2 +-
 .../code/PostProcessing/CalcTangentsProcess.h |    2 +-
 .../ComputeUVMappingProcess.cpp               |    2 +-
 .../PostProcessing/ComputeUVMappingProcess.h  |    2 +-
 .../PostProcessing/ConvertToLHProcess.cpp     |    2 +-
 .../code/PostProcessing/ConvertToLHProcess.h  |    7 +-
 .../code/PostProcessing/DeboneProcess.cpp     |    2 +-
 .../code/PostProcessing/DeboneProcess.h       |    2 +-
 .../PostProcessing/DropFaceNormalsProcess.cpp |    2 +-
 .../PostProcessing/DropFaceNormalsProcess.h   |    2 +-
 .../PostProcessing/EmbedTexturesProcess.cpp   |    5 +-
 .../PostProcessing/EmbedTexturesProcess.h     |    2 +-
 .../code/PostProcessing/FindDegenerates.cpp   |    2 +-
 .../code/PostProcessing/FindDegenerates.h     |    2 +-
 .../PostProcessing/FindInstancesProcess.cpp   |    2 +-
 .../PostProcessing/FindInstancesProcess.h     |    2 +-
 .../PostProcessing/FindInvalidDataProcess.cpp |    3 +-
 .../PostProcessing/FindInvalidDataProcess.h   |    2 +-
 .../code/PostProcessing/FixNormalsStep.cpp    |    2 +-
 .../code/PostProcessing/FixNormalsStep.h      |    2 +-
 .../GenBoundingBoxesProcess.cpp               |    2 +-
 .../PostProcessing/GenBoundingBoxesProcess.h  |    2 +-
 .../PostProcessing/GenFaceNormalsProcess.cpp  |    2 +-
 .../PostProcessing/GenFaceNormalsProcess.h    |    2 +-
 .../GenVertexNormalsProcess.cpp               |    2 +-
 .../PostProcessing/GenVertexNormalsProcess.h  |    2 +-
 .../PostProcessing/ImproveCacheLocality.cpp   |    2 +-
 .../PostProcessing/ImproveCacheLocality.h     |    2 +-
 .../PostProcessing/JoinVerticesProcess.cpp    |    2 +-
 .../code/PostProcessing/JoinVerticesProcess.h |    2 +-
 .../LimitBoneWeightsProcess.cpp               |    2 +-
 .../PostProcessing/LimitBoneWeightsProcess.h  |    2 +-
 .../code/PostProcessing/MakeVerboseFormat.cpp |    2 +-
 .../code/PostProcessing/MakeVerboseFormat.h   |    2 +-
 .../code/PostProcessing/OptimizeGraph.cpp     |  431 +-
 .../code/PostProcessing/OptimizeGraph.h       |    8 +-
 .../code/PostProcessing/OptimizeMeshes.cpp    |    2 +-
 .../code/PostProcessing/OptimizeMeshes.h      |    2 +-
 .../PostProcessing/PretransformVertices.cpp   | 1040 +--
 .../PostProcessing/PretransformVertices.h     |  144 +-
 .../code/PostProcessing/ProcessHelper.cpp     |   42 +-
 .../code/PostProcessing/ProcessHelper.h       |    8 +-
 .../RemoveRedundantMaterials.cpp              |    2 +-
 .../PostProcessing/RemoveRedundantMaterials.h |    2 +-
 .../code/PostProcessing/RemoveVCProcess.cpp   |    2 +-
 .../code/PostProcessing/RemoveVCProcess.h     |    2 +-
 .../code/PostProcessing/ScaleProcess.cpp      |    2 +-
 .../assimp/code/PostProcessing/ScaleProcess.h |    2 +-
 .../PostProcessing/SortByPTypeProcess.cpp     |    2 +-
 .../code/PostProcessing/SortByPTypeProcess.h  |    2 +-
 .../SplitByBoneCountProcess.cpp               |  447 --
 .../PostProcessing/SplitByBoneCountProcess.h  |  111 -
 .../code/PostProcessing/SplitLargeMeshes.cpp  |    2 +-
 .../code/PostProcessing/SplitLargeMeshes.h    |    2 +-
 .../code/PostProcessing/TextureTransform.cpp  |   10 +-
 .../code/PostProcessing/TextureTransform.h    |    2 +-
 .../PostProcessing/TriangulateProcess.cpp     |    2 +-
 .../code/PostProcessing/TriangulateProcess.h  |    2 +-
 .../PostProcessing/ValidateDataStructure.cpp  |   84 +-
 .../PostProcessing/ValidateDataStructure.h    |   10 +-
 Engine/lib/assimp/code/Q3BSP/Q3BSPFileData.h  |    2 +-
 .../assimp/code/Q3BSP/Q3BSPFileImporter.cpp   |    4 +-
 .../lib/assimp/code/Q3BSP/Q3BSPFileImporter.h |    2 +-
 .../lib/assimp/code/Q3BSP/Q3BSPFileParser.cpp |    2 +-
 .../lib/assimp/code/Q3BSP/Q3BSPFileParser.h   |    2 +-
 Engine/lib/assimp/code/Q3D/Q3DLoader.cpp      |    2 +-
 Engine/lib/assimp/code/Q3D/Q3DLoader.h        |    2 +-
 Engine/lib/assimp/code/Raw/RawLoader.cpp      |    2 +-
 Engine/lib/assimp/code/Raw/RawLoader.h        |    2 +-
 Engine/lib/assimp/code/SIB/SIBImporter.cpp    |    2 +-
 Engine/lib/assimp/code/SIB/SIBImporter.h      |    2 +-
 Engine/lib/assimp/code/SMD/SMDLoader.cpp      |    6 +-
 Engine/lib/assimp/code/SMD/SMDLoader.h        |    2 +-
 Engine/lib/assimp/code/STL/STLExporter.cpp    |    2 +-
 Engine/lib/assimp/code/STL/STLExporter.h      |    2 +-
 Engine/lib/assimp/code/STL/STLLoader.cpp      |    2 +-
 Engine/lib/assimp/code/STL/STLLoader.h        |    2 +-
 Engine/lib/assimp/code/Step/STEPFile.h        |    2 +-
 Engine/lib/assimp/code/Step/StepExporter.cpp  |    2 +-
 Engine/lib/assimp/code/Step/StepExporter.h    |    2 +-
 .../assimp/code/Terragen/TerragenLoader.cpp   |    2 +-
 .../lib/assimp/code/Terragen/TerragenLoader.h |    2 +-
 .../lib/assimp/code/Unreal/UnrealLoader.cpp   |    4 +-
 Engine/lib/assimp/code/Unreal/UnrealLoader.h  |    2 +-
 Engine/lib/assimp/code/X/XFileExporter.cpp    |    2 +-
 Engine/lib/assimp/code/X/XFileExporter.h      |    2 +-
 Engine/lib/assimp/code/X/XFileHelper.h        |    2 +-
 Engine/lib/assimp/code/X/XFileImporter.cpp    |   38 +-
 Engine/lib/assimp/code/X/XFileImporter.h      |    2 +-
 Engine/lib/assimp/code/X/XFileParser.cpp      |    2 +-
 Engine/lib/assimp/code/X/XFileParser.h        |    2 +-
 Engine/lib/assimp/code/X3D/FIReader.cpp       |    2 +-
 Engine/lib/assimp/code/X3D/FIReader.hpp       |    2 +-
 Engine/lib/assimp/code/X3D/X3DImporter.cpp    |    2 +-
 Engine/lib/assimp/code/X3D/X3DImporter.hpp    |    2 +-
 .../code/X3D/X3DImporter_Geometry2D.cpp       |    2 +-
 .../code/X3D/X3DImporter_Geometry3D.cpp       |    2 +-
 .../lib/assimp/code/X3D/X3DImporter_Group.cpp |    2 +-
 .../lib/assimp/code/X3D/X3DImporter_Light.cpp |    2 +-
 .../lib/assimp/code/X3D/X3DImporter_Macro.hpp |    2 +-
 .../assimp/code/X3D/X3DImporter_Metadata.cpp  |    2 +-
 .../code/X3D/X3DImporter_Networking.cpp       |    2 +-
 .../lib/assimp/code/X3D/X3DImporter_Node.hpp  |    2 +-
 .../code/X3D/X3DImporter_Postprocess.cpp      |    2 +-
 .../assimp/code/X3D/X3DImporter_Rendering.cpp |    2 +-
 .../lib/assimp/code/X3D/X3DImporter_Shape.cpp |    2 +-
 .../assimp/code/X3D/X3DImporter_Texturing.cpp |    2 +-
 Engine/lib/assimp/code/X3D/X3DVocabulary.cpp  |    2 +-
 Engine/lib/assimp/code/XGL/XGLLoader.cpp      |    4 +-
 Engine/lib/assimp/code/XGL/XGLLoader.h        |    2 +-
 Engine/lib/assimp/code/glTF/glTFAsset.h       |    9 +-
 Engine/lib/assimp/code/glTF/glTFAsset.inl     |   11 +-
 Engine/lib/assimp/code/glTF/glTFAssetWriter.h |    2 +-
 .../lib/assimp/code/glTF/glTFAssetWriter.inl  |   35 +-
 Engine/lib/assimp/code/glTF/glTFCommon.cpp    |    2 +-
 Engine/lib/assimp/code/glTF/glTFCommon.h      |   19 +-
 Engine/lib/assimp/code/glTF/glTFExporter.cpp  |  123 +-
 Engine/lib/assimp/code/glTF/glTFExporter.h    |    4 +-
 Engine/lib/assimp/code/glTF/glTFImporter.cpp  |   49 +-
 Engine/lib/assimp/code/glTF/glTFImporter.h    |    4 +-
 Engine/lib/assimp/code/glTF2/glTF2Asset.h     |   26 +-
 Engine/lib/assimp/code/glTF2/glTF2Asset.inl   |   82 +-
 .../lib/assimp/code/glTF2/glTF2AssetWriter.h  |    2 +-
 .../assimp/code/glTF2/glTF2AssetWriter.inl    |   63 +-
 .../lib/assimp/code/glTF2/glTF2Exporter.cpp   |  185 +-
 Engine/lib/assimp/code/glTF2/glTF2Exporter.h  |    3 +-
 .../lib/assimp/code/glTF2/glTF2Importer.cpp   | 2097 +++---
 Engine/lib/assimp/code/glTF2/glTF2Importer.h  |    3 +-
 Engine/lib/assimp/code/res/assimp.rc          |    2 +-
 Engine/lib/assimp/contrib/CMakeLists.txt      |    2 +-
 Engine/lib/assimp/contrib/gtest/.gitignore    |    2 -
 .../CMakeDirectoryInformation.cmake           |   16 +
 .../CMakeFiles/IrrXML.dir/DependInfo.cmake    |   19 +
 .../irrXML/CMakeFiles/IrrXML.dir/build.make   |  111 +
 .../CMakeFiles/IrrXML.dir/cmake_clean.cmake   |   11 +
 .../IrrXML.dir/cmake_clean_target.cmake       |    3 +
 .../IrrXML.dir/compiler_depend.make           |    2 +
 .../CMakeFiles/IrrXML.dir/compiler_depend.ts  |    2 +
 .../irrXML/CMakeFiles/IrrXML.dir/depend.make  |    2 +
 .../irrXML/CMakeFiles/IrrXML.dir/flags.make   |   10 +
 .../irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o |  Bin 0 -> 295872 bytes
 .../CMakeFiles/IrrXML.dir/irrXML.cpp.o.d      |   50 +
 .../irrXML/CMakeFiles/IrrXML.dir/link.txt     |    2 +
 .../CMakeFiles/IrrXML.dir/progress.make       |    3 +
 .../contrib/irrXML/CMakeFiles/progress.marks  |    1 +
 .../assimp/contrib/irrXML/CXMLReaderImpl.h    |   10 +-
 Engine/lib/assimp/contrib/irrXML/Makefile     |  231 +
 .../assimp/contrib/irrXML/cmake_install.cmake |   48 +
 Engine/lib/assimp/contrib/zip/.gitignore      |   56 -
 Engine/lib/assimp/contrib/zip/.travis.sh      |    0
 Engine/lib/assimp/contrib/zip/CMakeLists.txt  |   79 +-
 Engine/lib/assimp/contrib/zip/README.md       |   63 +-
 Engine/lib/assimp/contrib/zip/appveyor.yml    |   14 -
 .../lib/assimp/contrib/zip/cmake/asan-wrapper |    0
 Engine/lib/assimp/contrib/zip/src/miniz.h     |  457 +-
 Engine/lib/assimp/contrib/zip/src/zip.c       |   79 +-
 Engine/lib/assimp/contrib/zip/src/zip.h       |  464 +-
 .../assimp/contrib/zip/test/CMakeLists.txt    |   22 +-
 Engine/lib/assimp/contrib/zip/test/test.c     |   42 +-
 .../lib/assimp/contrib/zip/test/test_miniz.c  |   25 +-
 Engine/lib/assimp/contrib/zlib/CMakeLists.txt |  207 +
 Engine/lib/assimp/contrib/zlib/README         |  115 +
 Engine/lib/assimp/contrib/zlib/adler32.c      |  186 +
 Engine/lib/assimp/contrib/zlib/compress.c     |   86 +
 .../contrib/zlib/contrib/README.contrib       |   78 +
 .../contrib/zlib/contrib/ada/buffer_demo.adb  |  106 +
 .../assimp/contrib/zlib/contrib/ada/mtest.adb |  156 +
 .../assimp/contrib/zlib/contrib/ada/read.adb  |  156 +
 .../contrib/zlib/contrib/ada/readme.txt       |   65 +
 .../assimp/contrib/zlib/contrib/ada/test.adb  |  463 ++
 .../contrib/zlib/contrib/ada/zlib-streams.adb |  225 +
 .../contrib/zlib/contrib/ada/zlib-streams.ads |  114 +
 .../contrib/zlib/contrib/ada/zlib-thin.adb    |  141 +
 .../contrib/zlib/contrib/ada/zlib-thin.ads    |  450 ++
 .../assimp/contrib/zlib/contrib/ada/zlib.adb  |  701 ++
 .../assimp/contrib/zlib/contrib/ada/zlib.ads  |  328 +
 .../assimp/contrib/zlib/contrib/ada/zlib.gpr  |   20 +
 .../contrib/zlib/contrib/amd64/amd64-match.S  |  452 ++
 .../contrib/zlib/contrib/asm686/README.686    |   51 +
 .../contrib/zlib/contrib/asm686/match.S       |  357 ++
 .../assimp/contrib/zlib/contrib/blast/README  |    4 +
 .../assimp/contrib/zlib/contrib/blast/blast.c |  466 ++
 .../assimp/contrib/zlib/contrib/blast/blast.h |   83 +
 .../assimp/contrib/zlib/contrib/blast/test.pk |  Bin 0 -> 8 bytes
 .../contrib/zlib/contrib/blast/test.txt       |    1 +
 .../contrib/zlib/contrib/delphi/ZLib.pas      |  557 ++
 .../contrib/zlib/contrib/delphi/ZLibConst.pas |   11 +
 .../contrib/zlib/contrib/delphi/readme.txt    |   76 +
 .../contrib/zlib/contrib/delphi/zlibd32.mak   |   99 +
 .../zlib/contrib/dotzlib/DotZLib.build        |   33 +
 .../contrib/zlib/contrib/dotzlib/DotZLib.chm  |  Bin 0 -> 72726 bytes
 .../contrib/dotzlib/DotZLib/AssemblyInfo.cs   |   58 +
 .../contrib/dotzlib/DotZLib/ChecksumImpl.cs   |  202 +
 .../contrib/dotzlib/DotZLib/CircularBuffer.cs |   83 +
 .../zlib/contrib/dotzlib/DotZLib/CodecBase.cs |  198 +
 .../zlib/contrib/dotzlib/DotZLib/Deflater.cs  |  106 +
 .../zlib/contrib/dotzlib/DotZLib/DotZLib.cs   |  288 +
 .../contrib/dotzlib/DotZLib/DotZLib.csproj    |  141 +
 .../contrib/dotzlib/DotZLib/GZipStream.cs     |  301 +
 .../zlib/contrib/dotzlib/DotZLib/Inflater.cs  |  105 +
 .../zlib/contrib/dotzlib/DotZLib/UnitTests.cs |  274 +
 .../zlib/contrib/dotzlib/LICENSE_1_0.txt      |   23 +
 .../contrib/zlib/contrib/dotzlib/readme.txt   |   58 +
 .../zlib/contrib/gcc_gvmat64/gvmat64.S        |  574 ++
 .../contrib/zlib/contrib/infback9/README      |    1 +
 .../contrib/zlib/contrib/infback9/infback9.c  |  615 ++
 .../contrib/zlib/contrib/infback9/infback9.h  |   37 +
 .../contrib/zlib/contrib/infback9/inffix9.h   |  107 +
 .../contrib/zlib/contrib/infback9/inflate9.h  |   47 +
 .../contrib/zlib/contrib/infback9/inftree9.c  |  324 +
 .../contrib/zlib/contrib/infback9/inftree9.h  |   61 +
 .../contrib/zlib/contrib/inflate86/inffas86.c | 1157 ++++
 .../contrib/zlib/contrib/inflate86/inffast.S  | 1368 ++++
 .../contrib/zlib/contrib/iostream/test.cpp    |   24 +
 .../zlib/contrib/iostream/zfstream.cpp        |  329 +
 .../contrib/zlib/contrib/iostream/zfstream.h  |  128 +
 .../contrib/zlib/contrib/iostream2/zstream.h  |  307 +
 .../zlib/contrib/iostream2/zstream_test.cpp   |   25 +
 .../contrib/zlib/contrib/iostream3/README     |   35 +
 .../contrib/zlib/contrib/iostream3/TODO       |   17 +
 .../contrib/zlib/contrib/iostream3/test.cc    |   50 +
 .../zlib/contrib/iostream3/zfstream.cc        |  479 ++
 .../contrib/zlib/contrib/iostream3/zfstream.h |  466 ++
 .../contrib/zlib/contrib/masmx64/bld_ml64.bat |    2 +
 .../contrib/zlib/contrib/masmx64/gvmat64.asm  |  553 ++
 .../contrib/zlib/contrib/masmx64/inffas8664.c |  186 +
 .../zlib/contrib/masmx64/inffasx64.asm        |  396 ++
 .../contrib/zlib/contrib/masmx64/readme.txt   |   31 +
 .../contrib/zlib/contrib/masmx86/bld_ml32.bat |    2 +
 .../contrib/zlib/contrib/masmx86/inffas32.asm | 1080 ++++
 .../contrib/zlib/contrib/masmx86/match686.asm |  479 ++
 .../contrib/zlib/contrib/masmx86/readme.txt   |   27 +
 .../contrib/zlib/contrib/minizip/Makefile.am  |   45 +
 .../contrib/minizip/MiniZip64_Changes.txt     |    6 +
 .../zlib/contrib/minizip/MiniZip64_info.txt   |   74 +
 .../contrib/zlib/contrib/minizip/configure.ac |   32 +
 .../contrib/zlib/contrib/minizip/crypt.h      |  131 +
 .../contrib/zlib/contrib/minizip/ioapi.c      |  247 +
 .../contrib/zlib/contrib/minizip/ioapi.h      |  208 +
 .../contrib/zlib/contrib/minizip/iowin32.c    |  462 ++
 .../contrib/zlib/contrib/minizip/iowin32.h    |   28 +
 .../contrib/zlib/contrib/minizip/make_vms.com |   25 +
 .../contrib/zlib/contrib/minizip/miniunz.c    |  660 ++
 .../contrib/zlib/contrib/minizip/miniunzip.1  |   63 +
 .../contrib/zlib/contrib/minizip/minizip.1    |   46 +
 .../contrib/zlib/contrib/minizip/minizip.c    |  520 ++
 .../zlib/contrib/minizip/minizip.pc.in        |   12 +
 .../contrib/zlib/contrib/minizip/mztools.c    |  291 +
 .../contrib/zlib/contrib/minizip/mztools.h    |   37 +
 .../contrib/zlib/contrib/minizip/unzip.c      | 2125 +++++++
 .../contrib/zlib/contrib/minizip/unzip.h      |  437 ++
 .../assimp/contrib/zlib/contrib/minizip/zip.c | 2007 ++++++
 .../assimp/contrib/zlib/contrib/minizip/zip.h |  362 ++
 .../contrib/zlib/contrib/pascal/example.pas   |  599 ++
 .../contrib/zlib/contrib/pascal/readme.txt    |   76 +
 .../contrib/zlib/contrib/pascal/zlibd32.mak   |   99 +
 .../contrib/zlib/contrib/pascal/zlibpas.pas   |  276 +
 .../assimp/contrib/zlib/contrib/puff/README   |   63 +
 .../assimp/contrib/zlib/contrib/puff/puff.c   |  840 +++
 .../assimp/contrib/zlib/contrib/puff/puff.h   |   35 +
 .../contrib/zlib/contrib/puff/pufftest.c      |  165 +
 .../contrib/zlib/contrib/puff/zeros.raw       |  Bin 0 -> 2517 bytes
 .../contrib/zlib/contrib/testzlib/testzlib.c  |  275 +
 .../zlib/contrib/testzlib/testzlib.txt        |   10 +
 .../contrib/zlib/contrib/untgz/Makefile.msc   |   17 +
 .../assimp/contrib/zlib/contrib/untgz/untgz.c |  674 ++
 .../contrib/zlib/contrib/vstudio/readme.txt   |   78 +
 .../contrib/zlib/contrib/vstudio/vc10/zlib.rc |   32 +
 .../zlib/contrib/vstudio/vc10/zlibvc.def      |  153 +
 .../contrib/zlib/contrib/vstudio/vc11/zlib.rc |   32 +
 .../zlib/contrib/vstudio/vc11/zlibvc.def      |  153 +
 .../contrib/zlib/contrib/vstudio/vc12/zlib.rc |   32 +
 .../zlib/contrib/vstudio/vc12/zlibvc.def      |  153 +
 .../contrib/zlib/contrib/vstudio/vc14/zlib.rc |   32 +
 .../zlib/contrib/vstudio/vc14/zlibvc.def      |  153 +
 .../contrib/zlib/contrib/vstudio/vc9/zlib.rc  |   32 +
 .../zlib/contrib/vstudio/vc9/zlibvc.def       |  153 +
 Engine/lib/assimp/contrib/zlib/crc32.c        |  442 ++
 Engine/lib/assimp/contrib/zlib/crc32.h        |  441 ++
 Engine/lib/assimp/contrib/zlib/deflate.c      | 2174 +++++++
 Engine/lib/assimp/contrib/zlib/deflate.h      |  349 +
 Engine/lib/assimp/contrib/zlib/gzclose.c      |   25 +
 Engine/lib/assimp/contrib/zlib/gzguts.h       |  218 +
 Engine/lib/assimp/contrib/zlib/gzlib.c        |  637 ++
 Engine/lib/assimp/contrib/zlib/gzread.c       |  652 ++
 Engine/lib/assimp/contrib/zlib/gzwrite.c      |  668 ++
 Engine/lib/assimp/contrib/zlib/infback.c      |  640 ++
 Engine/lib/assimp/contrib/zlib/inffast.c      |  323 +
 Engine/lib/assimp/contrib/zlib/inffast.h      |   11 +
 Engine/lib/assimp/contrib/zlib/inffixed.h     |   94 +
 Engine/lib/assimp/contrib/zlib/inflate.c      | 1563 +++++
 Engine/lib/assimp/contrib/zlib/inflate.h      |  125 +
 Engine/lib/assimp/contrib/zlib/inftrees.c     |  304 +
 Engine/lib/assimp/contrib/zlib/inftrees.h     |   62 +
 Engine/lib/assimp/contrib/zlib/trees.c        | 1203 ++++
 Engine/lib/assimp/contrib/zlib/trees.h        |  128 +
 Engine/lib/assimp/contrib/zlib/uncompr.c      |   93 +
 .../lib/assimp/contrib/zlib/win32/DLL_FAQ.txt |  397 ++
 .../assimp/contrib/zlib/win32/Makefile.bor    |  110 +
 .../assimp/contrib/zlib/win32/Makefile.gcc    |  182 +
 .../assimp/contrib/zlib/win32/Makefile.msc    |  163 +
 .../contrib/zlib/win32/README-WIN32.txt       |  103 +
 .../lib/assimp/contrib/zlib/win32/VisualC.txt |    3 +
 Engine/lib/assimp/contrib/zlib/win32/zlib.def |   94 +
 Engine/lib/assimp/contrib/zlib/win32/zlib1.rc |   40 +
 .../lib/assimp/contrib/zlib/zconf.h.cmakein   |  536 ++
 Engine/lib/assimp/contrib/zlib/zconf.h.in     |  534 ++
 .../lib/assimp/contrib/zlib/zconf.h.included  |  536 ++
 Engine/lib/assimp/contrib/zlib/zlib.h         | 1917 ++++++
 .../lib/assimp/contrib/zlib/zlib.pc.cmakein   |   13 +
 Engine/lib/assimp/contrib/zlib/zutil.c        |  325 +
 Engine/lib/assimp/contrib/zlib/zutil.h        |  263 +
 .../lib/assimp/include/assimp/BaseImporter.h  |   22 +-
 Engine/lib/assimp/include/assimp/Bitmap.h     |    8 +-
 .../lib/assimp/include/assimp/BlobIOSystem.h  |    2 +-
 .../lib/assimp/include/assimp/ByteSwapper.h   |    7 +-
 .../assimp/include/assimp/CreateAnimMesh.h    |   16 +-
 .../assimp/include/assimp/DefaultIOStream.h   |   21 +-
 .../assimp/include/assimp/DefaultIOSystem.h   |    7 +-
 .../assimp/include/assimp/DefaultLogger.hpp   |    2 +-
 Engine/lib/assimp/include/assimp/Defines.h    |   11 +-
 .../lib/assimp/include/assimp/Exceptional.h   |   35 +-
 Engine/lib/assimp/include/assimp/Exporter.hpp |    8 +-
 .../assimp/include/assimp/GenericProperty.h   |   44 +-
 Engine/lib/assimp/include/assimp/Hash.h       |    8 +-
 Engine/lib/assimp/include/assimp/IOStream.hpp |   14 +-
 .../assimp/include/assimp/IOStreamBuffer.h    |   45 +-
 Engine/lib/assimp/include/assimp/IOSystem.hpp |    6 +-
 Engine/lib/assimp/include/assimp/Importer.hpp |   10 +-
 .../lib/assimp/include/assimp/LineSplitter.h  |   40 +-
 Engine/lib/assimp/include/assimp/LogAux.h     |    7 +-
 .../lib/assimp/include/assimp/LogStream.hpp   |    2 +-
 Engine/lib/assimp/include/assimp/Logger.hpp   |    2 +-
 .../assimp/Macros.h}                          |   34 +-
 .../lib/assimp/include/assimp/MathFunctions.h |    6 +-
 .../assimp/include/assimp/MemoryIOWrapper.h   |    8 +-
 .../lib/assimp/include/assimp/NullLogger.hpp  |    2 +-
 .../lib/assimp/include/assimp/ParsingUtils.h  |   11 +-
 Engine/lib/assimp/include/assimp/Profiler.h   |   16 +-
 .../assimp/include/assimp/ProgressHandler.hpp |   10 +-
 .../assimp/include/assimp/RemoveComments.h    |   10 +-
 .../lib/assimp/include/assimp/SGSpatialSort.h |    7 +-
 .../lib/assimp/include/assimp/SceneCombiner.h |   11 +-
 .../include/assimp/SkeletonMeshBuilder.h      |    7 +-
 .../assimp/include/assimp/SmoothingGroups.h   |    8 +-
 .../assimp/include/assimp/SmoothingGroups.inl |    9 +-
 .../lib/assimp/include/assimp/SpatialSort.h   |    7 +-
 .../assimp/include/assimp/StandardShapes.h    |    9 +-
 .../lib/assimp/include/assimp/StreamReader.h  |   12 +-
 .../lib/assimp/include/assimp/StreamWriter.h  |   10 +-
 .../assimp/include/assimp/StringComparison.h  |    9 +-
 .../lib/assimp/include/assimp/StringUtils.h   |    7 +-
 .../lib/assimp/include/assimp/Subdivision.h   |    7 +-
 .../lib/assimp/include/assimp/TinyFormatter.h |   36 +-
 Engine/lib/assimp/include/assimp/Vertex.h     |   69 +-
 Engine/lib/assimp/include/assimp/XMLTools.h   |    7 +-
 .../include/assimp/ZipArchiveIOSystem.h       |   59 +-
 Engine/lib/assimp/include/assimp/aabb.h       |   13 +-
 Engine/lib/assimp/include/assimp/ai_assert.h  |    6 +-
 Engine/lib/assimp/include/assimp/anim.h       |    6 +-
 Engine/lib/assimp/include/assimp/camera.h     |    6 +-
 Engine/lib/assimp/include/assimp/cexport.h    |    6 +-
 Engine/lib/assimp/include/assimp/cfileio.h    |    8 +-
 Engine/lib/assimp/include/assimp/cimport.h    |    8 +-
 Engine/lib/assimp/include/assimp/color4.h     |   15 +-
 Engine/lib/assimp/include/assimp/color4.inl   |   96 +-
 .../assimp/include/assimp/commonMetaData.h    |   67 -
 Engine/lib/assimp/include/assimp/config.h     |    2 +
 Engine/lib/assimp/include/assimp/config.h.in  |   69 +-
 Engine/lib/assimp/include/assimp/defs.h       |   51 +-
 Engine/lib/assimp/include/assimp/fast_atof.h  |    6 +-
 .../lib/assimp/include/assimp/importerdesc.h  |   12 +-
 .../lib/assimp/include/assimp/irrXMLWrapper.h |    2 +-
 Engine/lib/assimp/include/assimp/light.h      |    8 +-
 Engine/lib/assimp/include/assimp/material.h   |   12 +-
 Engine/lib/assimp/include/assimp/material.inl |  267 +-
 Engine/lib/assimp/include/assimp/matrix3x3.h  |   23 +-
 .../lib/assimp/include/assimp/matrix3x3.inl   |   72 +-
 Engine/lib/assimp/include/assimp/matrix4x4.h  |   20 +-
 .../lib/assimp/include/assimp/matrix4x4.inl   |  170 +-
 Engine/lib/assimp/include/assimp/mesh.h       |   42 +-
 Engine/lib/assimp/include/assimp/metadata.h   |   27 +-
 .../lib/assimp/include/assimp/pbrmaterial.h   |    9 +-
 .../port/AndroidJNI/AndroidJNIIOSystem.h      |    2 +-
 .../lib/assimp/include/assimp/postprocess.h   |   23 +-
 Engine/lib/assimp/include/assimp/qnan.h       |   33 +-
 Engine/lib/assimp/include/assimp/quaternion.h |    8 +-
 .../lib/assimp/include/assimp/quaternion.inl  |    8 +-
 Engine/lib/assimp/include/assimp/revision.h   |   10 +-
 Engine/lib/assimp/include/assimp/scene.h      |   44 +-
 Engine/lib/assimp/include/assimp/texture.h    |   18 +-
 Engine/lib/assimp/include/assimp/types.h      |   23 +-
 Engine/lib/assimp/include/assimp/vector2.h    |    6 +-
 Engine/lib/assimp/include/assimp/vector2.inl  |    8 +-
 Engine/lib/assimp/include/assimp/vector3.h    |   14 +-
 Engine/lib/assimp/include/assimp/vector3.inl  |    4 +-
 Engine/lib/assimp/include/assimp/version.h    |   11 +-
 679 files changed, 50502 insertions(+), 19698 deletions(-)
 delete mode 100644 Engine/lib/assimp/code/Assbin/AssbinFileWriter.cpp
 delete mode 100644 Engine/lib/assimp/code/Assbin/AssbinFileWriter.h
 delete mode 100644 Engine/lib/assimp/code/Assxml/AssxmlFileWriter.cpp
 delete mode 100644 Engine/lib/assimp/code/Assxml/AssxmlFileWriter.h
 delete mode 100644 Engine/lib/assimp/code/Collada/ColladaHelper.cpp
 delete mode 100644 Engine/lib/assimp/code/Common/material.cpp
 delete mode 100644 Engine/lib/assimp/code/M3D/M3DExporter.cpp
 delete mode 100644 Engine/lib/assimp/code/M3D/M3DExporter.h
 delete mode 100644 Engine/lib/assimp/code/M3D/M3DImporter.cpp
 delete mode 100644 Engine/lib/assimp/code/M3D/M3DImporter.h
 delete mode 100644 Engine/lib/assimp/code/M3D/M3DMaterials.h
 delete mode 100644 Engine/lib/assimp/code/M3D/M3DWrapper.cpp
 delete mode 100644 Engine/lib/assimp/code/M3D/M3DWrapper.h
 delete mode 100644 Engine/lib/assimp/code/M3D/m3d.h
 delete mode 100644 Engine/lib/assimp/code/MDL/HalfLife/HL1FileData.h
 delete mode 100644 Engine/lib/assimp/code/MDL/HalfLife/HL1ImportDefinitions.h
 delete mode 100644 Engine/lib/assimp/code/MDL/HalfLife/HL1ImportSettings.h
 delete mode 100644 Engine/lib/assimp/code/MDL/HalfLife/HL1MDLLoader.cpp
 delete mode 100644 Engine/lib/assimp/code/MDL/HalfLife/HL1MDLLoader.h
 delete mode 100644 Engine/lib/assimp/code/MDL/HalfLife/HL1MeshTrivert.h
 delete mode 100644 Engine/lib/assimp/code/MDL/HalfLife/LogFunctions.h
 delete mode 100644 Engine/lib/assimp/code/MDL/HalfLife/UniqueNameGenerator.cpp
 delete mode 100644 Engine/lib/assimp/code/MDL/HalfLife/UniqueNameGenerator.h
 delete mode 100644 Engine/lib/assimp/code/PostProcessing/ArmaturePopulate.cpp
 delete mode 100644 Engine/lib/assimp/code/PostProcessing/ArmaturePopulate.h
 delete mode 100644 Engine/lib/assimp/code/PostProcessing/SplitByBoneCountProcess.cpp
 delete mode 100644 Engine/lib/assimp/code/PostProcessing/SplitByBoneCountProcess.h
 delete mode 100644 Engine/lib/assimp/contrib/gtest/.gitignore
 create mode 100644 Engine/lib/assimp/contrib/irrXML/CMakeFiles/CMakeDirectoryInformation.cmake
 create mode 100644 Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/DependInfo.cmake
 create mode 100644 Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/build.make
 create mode 100644 Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/cmake_clean.cmake
 create mode 100644 Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/cmake_clean_target.cmake
 create mode 100644 Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/compiler_depend.make
 create mode 100644 Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/compiler_depend.ts
 create mode 100644 Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/depend.make
 create mode 100644 Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/flags.make
 create mode 100644 Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o
 create mode 100644 Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o.d
 create mode 100644 Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/link.txt
 create mode 100644 Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/progress.make
 create mode 100644 Engine/lib/assimp/contrib/irrXML/CMakeFiles/progress.marks
 create mode 100644 Engine/lib/assimp/contrib/irrXML/Makefile
 create mode 100644 Engine/lib/assimp/contrib/irrXML/cmake_install.cmake
 delete mode 100644 Engine/lib/assimp/contrib/zip/.gitignore
 mode change 100644 => 100755 Engine/lib/assimp/contrib/zip/.travis.sh
 delete mode 100644 Engine/lib/assimp/contrib/zip/appveyor.yml
 mode change 100644 => 100755 Engine/lib/assimp/contrib/zip/cmake/asan-wrapper
 create mode 100644 Engine/lib/assimp/contrib/zlib/CMakeLists.txt
 create mode 100644 Engine/lib/assimp/contrib/zlib/README
 create mode 100644 Engine/lib/assimp/contrib/zlib/adler32.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/compress.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/README.contrib
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/ada/buffer_demo.adb
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/ada/mtest.adb
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/ada/read.adb
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/ada/readme.txt
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/ada/test.adb
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/ada/zlib-streams.adb
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/ada/zlib-streams.ads
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/ada/zlib-thin.adb
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/ada/zlib-thin.ads
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/ada/zlib.adb
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/ada/zlib.ads
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/ada/zlib.gpr
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/amd64/amd64-match.S
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/asm686/README.686
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/asm686/match.S
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/blast/README
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/blast/blast.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/blast/blast.h
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/blast/test.pk
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/blast/test.txt
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/delphi/ZLib.pas
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/delphi/ZLibConst.pas
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/delphi/readme.txt
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/delphi/zlibd32.mak
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib.build
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib.chm
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/AssemblyInfo.cs
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/ChecksumImpl.cs
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/CircularBuffer.cs
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/CodecBase.cs
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/Deflater.cs
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/DotZLib.cs
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/DotZLib.csproj
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/GZipStream.cs
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/Inflater.cs
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/UnitTests.cs
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/dotzlib/LICENSE_1_0.txt
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/dotzlib/readme.txt
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/gcc_gvmat64/gvmat64.S
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/infback9/README
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/infback9/infback9.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/infback9/infback9.h
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/infback9/inffix9.h
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/infback9/inflate9.h
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/infback9/inftree9.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/infback9/inftree9.h
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/inflate86/inffas86.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/inflate86/inffast.S
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/iostream/test.cpp
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/iostream/zfstream.cpp
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/iostream/zfstream.h
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/iostream2/zstream.h
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/iostream2/zstream_test.cpp
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/iostream3/README
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/iostream3/TODO
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/iostream3/test.cc
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/iostream3/zfstream.cc
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/iostream3/zfstream.h
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/masmx64/bld_ml64.bat
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/masmx64/gvmat64.asm
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/masmx64/inffas8664.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/masmx64/inffasx64.asm
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/masmx64/readme.txt
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/masmx86/bld_ml32.bat
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/masmx86/inffas32.asm
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/masmx86/match686.asm
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/masmx86/readme.txt
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/minizip/Makefile.am
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/minizip/MiniZip64_Changes.txt
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/minizip/MiniZip64_info.txt
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/minizip/configure.ac
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/minizip/crypt.h
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/minizip/ioapi.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/minizip/ioapi.h
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/minizip/iowin32.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/minizip/iowin32.h
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/minizip/make_vms.com
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/minizip/miniunz.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/minizip/miniunzip.1
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/minizip/minizip.1
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/minizip/minizip.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/minizip/minizip.pc.in
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/minizip/mztools.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/minizip/mztools.h
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/minizip/unzip.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/minizip/unzip.h
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/minizip/zip.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/minizip/zip.h
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/pascal/example.pas
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/pascal/readme.txt
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/pascal/zlibd32.mak
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/pascal/zlibpas.pas
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/puff/README
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/puff/puff.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/puff/puff.h
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/puff/pufftest.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/puff/zeros.raw
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/testzlib/testzlib.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/testzlib/testzlib.txt
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/untgz/Makefile.msc
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/untgz/untgz.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/vstudio/readme.txt
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc10/zlib.rc
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc10/zlibvc.def
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc11/zlib.rc
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc11/zlibvc.def
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc12/zlib.rc
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc12/zlibvc.def
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc14/zlib.rc
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc14/zlibvc.def
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc9/zlib.rc
 create mode 100644 Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc9/zlibvc.def
 create mode 100644 Engine/lib/assimp/contrib/zlib/crc32.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/crc32.h
 create mode 100644 Engine/lib/assimp/contrib/zlib/deflate.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/deflate.h
 create mode 100644 Engine/lib/assimp/contrib/zlib/gzclose.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/gzguts.h
 create mode 100644 Engine/lib/assimp/contrib/zlib/gzlib.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/gzread.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/gzwrite.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/infback.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/inffast.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/inffast.h
 create mode 100644 Engine/lib/assimp/contrib/zlib/inffixed.h
 create mode 100644 Engine/lib/assimp/contrib/zlib/inflate.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/inflate.h
 create mode 100644 Engine/lib/assimp/contrib/zlib/inftrees.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/inftrees.h
 create mode 100644 Engine/lib/assimp/contrib/zlib/trees.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/trees.h
 create mode 100644 Engine/lib/assimp/contrib/zlib/uncompr.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/win32/DLL_FAQ.txt
 create mode 100644 Engine/lib/assimp/contrib/zlib/win32/Makefile.bor
 create mode 100644 Engine/lib/assimp/contrib/zlib/win32/Makefile.gcc
 create mode 100644 Engine/lib/assimp/contrib/zlib/win32/Makefile.msc
 create mode 100644 Engine/lib/assimp/contrib/zlib/win32/README-WIN32.txt
 create mode 100644 Engine/lib/assimp/contrib/zlib/win32/VisualC.txt
 create mode 100644 Engine/lib/assimp/contrib/zlib/win32/zlib.def
 create mode 100644 Engine/lib/assimp/contrib/zlib/win32/zlib1.rc
 create mode 100644 Engine/lib/assimp/contrib/zlib/zconf.h.cmakein
 create mode 100644 Engine/lib/assimp/contrib/zlib/zconf.h.in
 create mode 100644 Engine/lib/assimp/contrib/zlib/zconf.h.included
 create mode 100644 Engine/lib/assimp/contrib/zlib/zlib.h
 create mode 100644 Engine/lib/assimp/contrib/zlib/zlib.pc.cmakein
 create mode 100644 Engine/lib/assimp/contrib/zlib/zutil.c
 create mode 100644 Engine/lib/assimp/contrib/zlib/zutil.h
 rename Engine/lib/assimp/{code/MDL/HalfLife/HalfLifeMDLBaseHeader.h => include/assimp/Macros.h} (78%)
 delete mode 100644 Engine/lib/assimp/include/assimp/commonMetaData.h

diff --git a/Engine/lib/assimp/code/3DS/3DSConverter.cpp b/Engine/lib/assimp/code/3DS/3DSConverter.cpp
index 3f0e20bb0..2176b75fc 100644
--- a/Engine/lib/assimp/code/3DS/3DSConverter.cpp
+++ b/Engine/lib/assimp/code/3DS/3DSConverter.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -72,7 +72,7 @@ void Discreet3DSImporter::ReplaceDefaultMaterial()
     unsigned int idx( NotSet );
     for (unsigned int i = 0; i < mScene->mMaterials.size();++i)
     {
-        std::string s = mScene->mMaterials[i].mName;
+        std::string &s = mScene->mMaterials[i].mName;
         for ( std::string::iterator it = s.begin(); it != s.end(); ++it ) {
             *it = static_cast< char >( ::tolower( *it ) );
         }
diff --git a/Engine/lib/assimp/code/3DS/3DSExporter.cpp b/Engine/lib/assimp/code/3DS/3DSExporter.cpp
index 14810cbff..1117a52ef 100644
--- a/Engine/lib/assimp/code/3DS/3DSExporter.cpp
+++ b/Engine/lib/assimp/code/3DS/3DSExporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/3DS/3DSExporter.h b/Engine/lib/assimp/code/3DS/3DSExporter.h
index 9dcd92d58..035b562cf 100644
--- a/Engine/lib/assimp/code/3DS/3DSExporter.h
+++ b/Engine/lib/assimp/code/3DS/3DSExporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/3DS/3DSHelper.h b/Engine/lib/assimp/code/3DS/3DSHelper.h
index e483f1a25..8eb4cd97c 100644
--- a/Engine/lib/assimp/code/3DS/3DSHelper.h
+++ b/Engine/lib/assimp/code/3DS/3DSHelper.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/3DS/3DSLoader.cpp b/Engine/lib/assimp/code/3DS/3DSLoader.cpp
index 3e8e08967..96b80c962 100644
--- a/Engine/lib/assimp/code/3DS/3DSLoader.cpp
+++ b/Engine/lib/assimp/code/3DS/3DSLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -50,7 +50,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_3DS_IMPORTER
 
+// internal headers
 #include "3DSLoader.h"
+#include <assimp/Macros.h>
 #include <assimp/IOSystem.hpp>
 #include <assimp/scene.h>
 #include <assimp/DefaultLogger.hpp>
diff --git a/Engine/lib/assimp/code/3DS/3DSLoader.h b/Engine/lib/assimp/code/3DS/3DSLoader.h
index 9181294b3..f57e6a8e3 100644
--- a/Engine/lib/assimp/code/3DS/3DSLoader.h
+++ b/Engine/lib/assimp/code/3DS/3DSLoader.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/3MF/3MFXmlTags.h b/Engine/lib/assimp/code/3MF/3MFXmlTags.h
index 3f1fc01ed..ea6aeede0 100644
--- a/Engine/lib/assimp/code/3MF/3MFXmlTags.h
+++ b/Engine/lib/assimp/code/3MF/3MFXmlTags.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/3MF/D3MFExporter.cpp b/Engine/lib/assimp/code/3MF/D3MFExporter.cpp
index 9d71a54f2..1f388ad3e 100644
--- a/Engine/lib/assimp/code/3MF/D3MFExporter.cpp
+++ b/Engine/lib/assimp/code/3MF/D3MFExporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/3MF/D3MFExporter.h b/Engine/lib/assimp/code/3MF/D3MFExporter.h
index 6a447236b..e82120247 100644
--- a/Engine/lib/assimp/code/3MF/D3MFExporter.h
+++ b/Engine/lib/assimp/code/3MF/D3MFExporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/3MF/D3MFImporter.cpp b/Engine/lib/assimp/code/3MF/D3MFImporter.cpp
index 2f30c4fc0..682de684a 100644
--- a/Engine/lib/assimp/code/3MF/D3MFImporter.cpp
+++ b/Engine/lib/assimp/code/3MF/D3MFImporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/3MF/D3MFImporter.h b/Engine/lib/assimp/code/3MF/D3MFImporter.h
index 638971247..3dbdf07bf 100644
--- a/Engine/lib/assimp/code/3MF/D3MFImporter.h
+++ b/Engine/lib/assimp/code/3MF/D3MFImporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/3MF/D3MFOpcPackage.cpp b/Engine/lib/assimp/code/3MF/D3MFOpcPackage.cpp
index 565790656..873ba8ee8 100644
--- a/Engine/lib/assimp/code/3MF/D3MFOpcPackage.cpp
+++ b/Engine/lib/assimp/code/3MF/D3MFOpcPackage.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/3MF/D3MFOpcPackage.h b/Engine/lib/assimp/code/3MF/D3MFOpcPackage.h
index 291f8ad53..87d172116 100644
--- a/Engine/lib/assimp/code/3MF/D3MFOpcPackage.h
+++ b/Engine/lib/assimp/code/3MF/D3MFOpcPackage.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/AC/ACLoader.cpp b/Engine/lib/assimp/code/AC/ACLoader.cpp
index ea533743f..d4c4bd1a6 100644
--- a/Engine/lib/assimp/code/AC/ACLoader.cpp
+++ b/Engine/lib/assimp/code/AC/ACLoader.cpp
@@ -4,7 +4,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/AC/ACLoader.h b/Engine/lib/assimp/code/AC/ACLoader.h
index 1fc654f3c..cab2c3ae5 100644
--- a/Engine/lib/assimp/code/AC/ACLoader.h
+++ b/Engine/lib/assimp/code/AC/ACLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/AMF/AMFImporter.cpp b/Engine/lib/assimp/code/AMF/AMFImporter.cpp
index df4324d4d..dedb6dcdd 100644
--- a/Engine/lib/assimp/code/AMF/AMFImporter.cpp
+++ b/Engine/lib/assimp/code/AMF/AMFImporter.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/AMF/AMFImporter.hpp b/Engine/lib/assimp/code/AMF/AMFImporter.hpp
index 5994717b8..2b8086a06 100644
--- a/Engine/lib/assimp/code/AMF/AMFImporter.hpp
+++ b/Engine/lib/assimp/code/AMF/AMFImporter.hpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/AMF/AMFImporter_Geometry.cpp b/Engine/lib/assimp/code/AMF/AMFImporter_Geometry.cpp
index e9a50b656..f1538e3fb 100644
--- a/Engine/lib/assimp/code/AMF/AMFImporter_Geometry.cpp
+++ b/Engine/lib/assimp/code/AMF/AMFImporter_Geometry.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/AMF/AMFImporter_Macro.hpp b/Engine/lib/assimp/code/AMF/AMFImporter_Macro.hpp
index ec06cb999..f60c5fbbb 100644
--- a/Engine/lib/assimp/code/AMF/AMFImporter_Macro.hpp
+++ b/Engine/lib/assimp/code/AMF/AMFImporter_Macro.hpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/AMF/AMFImporter_Material.cpp b/Engine/lib/assimp/code/AMF/AMFImporter_Material.cpp
index 64da12dda..2f36df061 100644
--- a/Engine/lib/assimp/code/AMF/AMFImporter_Material.cpp
+++ b/Engine/lib/assimp/code/AMF/AMFImporter_Material.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/AMF/AMFImporter_Node.hpp b/Engine/lib/assimp/code/AMF/AMFImporter_Node.hpp
index b7b7836f3..a1bf9f008 100644
--- a/Engine/lib/assimp/code/AMF/AMFImporter_Node.hpp
+++ b/Engine/lib/assimp/code/AMF/AMFImporter_Node.hpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/AMF/AMFImporter_Postprocess.cpp b/Engine/lib/assimp/code/AMF/AMFImporter_Postprocess.cpp
index 8496d8ded..79b5e15e2 100644
--- a/Engine/lib/assimp/code/AMF/AMFImporter_Postprocess.cpp
+++ b/Engine/lib/assimp/code/AMF/AMFImporter_Postprocess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/ASE/ASELoader.cpp b/Engine/lib/assimp/code/ASE/ASELoader.cpp
index b2155d5e5..8e99214a8 100644
--- a/Engine/lib/assimp/code/ASE/ASELoader.cpp
+++ b/Engine/lib/assimp/code/ASE/ASELoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/ASE/ASELoader.h b/Engine/lib/assimp/code/ASE/ASELoader.h
index bb7707bb6..b497aa48b 100644
--- a/Engine/lib/assimp/code/ASE/ASELoader.h
+++ b/Engine/lib/assimp/code/ASE/ASELoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
diff --git a/Engine/lib/assimp/code/ASE/ASEParser.cpp b/Engine/lib/assimp/code/ASE/ASEParser.cpp
index efc6ecd0d..913e7b118 100644
--- a/Engine/lib/assimp/code/ASE/ASEParser.cpp
+++ b/Engine/lib/assimp/code/ASE/ASEParser.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/ASE/ASEParser.h b/Engine/lib/assimp/code/ASE/ASEParser.h
index e55949f99..988cbda8d 100644
--- a/Engine/lib/assimp/code/ASE/ASEParser.h
+++ b/Engine/lib/assimp/code/ASE/ASEParser.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Assbin/AssbinExporter.cpp b/Engine/lib/assimp/code/Assbin/AssbinExporter.cpp
index 496b39d49..76c823f82 100644
--- a/Engine/lib/assimp/code/Assbin/AssbinExporter.cpp
+++ b/Engine/lib/assimp/code/Assbin/AssbinExporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -46,22 +46,799 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_EXPORT
 #ifndef ASSIMP_BUILD_NO_ASSBIN_EXPORTER
 
-#include "AssbinFileWriter.h"
+#include "Common/assbin_chunks.h"
+#include "PostProcessing/ProcessHelper.h"
 
-#include <assimp/scene.h>
+#include <assimp/version.h>
+#include <assimp/IOStream.hpp>
 #include <assimp/IOSystem.hpp>
 #include <assimp/Exporter.hpp>
+#include <assimp/Exceptional.h>
+
+#ifdef ASSIMP_BUILD_NO_OWN_ZLIB
+#   include <zlib.h>
+#else
+#   include "../contrib/zlib/zlib.h"
+#endif
+
+#include <time.h>
 
 namespace Assimp {
 
+template <typename T>
+size_t Write(IOStream * stream, const T& v) {
+    return stream->Write( &v, sizeof(T), 1 );
+}
+
+// -----------------------------------------------------------------------------------
+// Serialize an aiString
+template <>
+inline
+size_t Write<aiString>(IOStream * stream, const aiString& s) {
+    const size_t s2 = (uint32_t)s.length;
+    stream->Write(&s,4,1);
+    stream->Write(s.data,s2,1);
+
+    return s2+4;
+}
+
+// -----------------------------------------------------------------------------------
+// Serialize an unsigned int as uint32_t
+template <>
+inline
+size_t Write<unsigned int>(IOStream * stream, const unsigned int& w) {
+    const uint32_t t = (uint32_t)w;
+    if (w > t) {
+        // this shouldn't happen, integers in Assimp data structures never exceed 2^32
+        throw DeadlyExportError("loss of data due to 64 -> 32 bit integer conversion");
+    }
+
+    stream->Write(&t,4,1);
+
+    return 4;
+}
+
+// -----------------------------------------------------------------------------------
+// Serialize an unsigned int as uint16_t
+template <>
+inline
+size_t Write<uint16_t>(IOStream * stream, const uint16_t& w) {
+    static_assert(sizeof(uint16_t)==2, "sizeof(uint16_t)==2");
+    stream->Write(&w,2,1);
+
+    return 2;
+}
+
+// -----------------------------------------------------------------------------------
+// Serialize a float
+template <>
+inline
+size_t Write<float>(IOStream * stream, const float& f) {
+    static_assert(sizeof(float)==4, "sizeof(float)==4");
+    stream->Write(&f,4,1);
+
+    return 4;
+}
+
+// -----------------------------------------------------------------------------------
+// Serialize a double
+template <>
+inline
+size_t Write<double>(IOStream * stream, const double& f) {
+    static_assert(sizeof(double)==8, "sizeof(double)==8");
+    stream->Write(&f,8,1);
+
+    return 8;
+}
+
+// -----------------------------------------------------------------------------------
+// Serialize a vec3
+template <>
+inline
+size_t Write<aiVector3D>(IOStream * stream, const aiVector3D& v) {
+    size_t t = Write<float>(stream,v.x);
+    t += Write<float>(stream,v.y);
+    t += Write<float>(stream,v.z);
+
+    return t;
+}
+
+// -----------------------------------------------------------------------------------
+// Serialize a color value
+template <>
+inline
+size_t Write<aiColor3D>(IOStream * stream, const aiColor3D& v) {
+    size_t t = Write<float>(stream,v.r);
+    t += Write<float>(stream,v.g);
+    t += Write<float>(stream,v.b);
+
+    return t;
+}
+
+// -----------------------------------------------------------------------------------
+// Serialize a color value
+template <>
+inline
+size_t Write<aiColor4D>(IOStream * stream, const aiColor4D& v) {
+    size_t t = Write<float>(stream,v.r);
+    t += Write<float>(stream,v.g);
+    t += Write<float>(stream,v.b);
+    t += Write<float>(stream,v.a);
+
+    return t;
+}
+
+// -----------------------------------------------------------------------------------
+// Serialize a quaternion
+template <>
+inline
+size_t Write<aiQuaternion>(IOStream * stream, const aiQuaternion& v) {
+    size_t t = Write<float>(stream,v.w);
+    t += Write<float>(stream,v.x);
+    t += Write<float>(stream,v.y);
+    t += Write<float>(stream,v.z);
+    ai_assert(t == 16);
+
+    return 16;
+}
+
+// -----------------------------------------------------------------------------------
+// Serialize a vertex weight
+template <>
+inline
+size_t Write<aiVertexWeight>(IOStream * stream, const aiVertexWeight& v) {
+    size_t t = Write<unsigned int>(stream,v.mVertexId);
+
+    return t+Write<float>(stream,v.mWeight);
+}
+
+// -----------------------------------------------------------------------------------
+// Serialize a mat4x4
+template <>
+inline
+size_t Write<aiMatrix4x4>(IOStream * stream, const aiMatrix4x4& m) {
+    for (unsigned int i = 0; i < 4;++i) {
+        for (unsigned int i2 = 0; i2 < 4;++i2) {
+            Write<float>(stream,m[i][i2]);
+        }
+    }
+
+    return 64;
+}
+
+// -----------------------------------------------------------------------------------
+// Serialize an aiVectorKey
+template <>
+inline
+size_t Write<aiVectorKey>(IOStream * stream, const aiVectorKey& v) {
+    const size_t t = Write<double>(stream,v.mTime);
+    return t + Write<aiVector3D>(stream,v.mValue);
+}
+
+// -----------------------------------------------------------------------------------
+// Serialize an aiQuatKey
+template <>
+inline
+size_t Write<aiQuatKey>(IOStream * stream, const aiQuatKey& v) {
+    const size_t t = Write<double>(stream,v.mTime);
+    return t + Write<aiQuaternion>(stream,v.mValue);
+}
+
+template <typename T>
+inline
+size_t WriteBounds(IOStream * stream, const T* in, unsigned int size) {
+    T minc, maxc;
+    ArrayBounds(in,size,minc,maxc);
+
+    const size_t t = Write<T>(stream,minc);
+    return t + Write<T>(stream,maxc);
+}
+
+// We use this to write out non-byte arrays so that we write using the specializations.
+// This way we avoid writing out extra bytes that potentially come from struct alignment.
+template <typename T>
+inline
+size_t WriteArray(IOStream * stream, const T* in, unsigned int size) {
+    size_t n = 0;
+    for (unsigned int i=0; i<size; i++) n += Write<T>(stream,in[i]);
+
+    return n;
+}
+
+// ----------------------------------------------------------------------------------
+/** @class  AssbinChunkWriter
+ *  @brief  Chunk writer mechanism for the .assbin file structure
+ *
+ *  This is a standard in-memory IOStream (most of the code is based on BlobIOStream),
+ *  the difference being that this takes another IOStream as a "container" in the
+ *  constructor, and when it is destroyed, it appends the magic number, the chunk size,
+ *  and the chunk contents to the container stream. This allows relatively easy chunk
+ *  chunk construction, even recursively.
+ */
+class AssbinChunkWriter : public IOStream
+{
+private:
+
+    uint8_t* buffer;
+    uint32_t magic;
+    IOStream * container;
+    size_t cur_size, cursor, initial;
+
+private:
+    // -------------------------------------------------------------------
+    void Grow(size_t need = 0)
+    {
+        size_t new_size = std::max(initial, std::max( need, cur_size+(cur_size>>1) ));
+
+        const uint8_t* const old = buffer;
+        buffer = new uint8_t[new_size];
+
+        if (old) {
+            memcpy(buffer,old,cur_size);
+            delete[] old;
+        }
+
+        cur_size = new_size;
+    }
+
+public:
+
+    AssbinChunkWriter( IOStream * container, uint32_t magic, size_t initial = 4096)
+        : buffer(NULL), magic(magic), container(container), cur_size(0), cursor(0), initial(initial)
+    {
+    }
+
+    virtual ~AssbinChunkWriter()
+    {
+        if (container) {
+            container->Write( &magic, sizeof(uint32_t), 1 );
+            container->Write( &cursor, sizeof(uint32_t), 1 );
+            container->Write( buffer, 1, cursor );
+        }
+        if (buffer) delete[] buffer;
+    }
+
+    void * GetBufferPointer() { return buffer; }
+
+    // -------------------------------------------------------------------
+    virtual size_t Read(void* /*pvBuffer*/, size_t /*pSize*/, size_t /*pCount*/) {
+        return 0;
+    }
+    virtual aiReturn Seek(size_t /*pOffset*/, aiOrigin /*pOrigin*/) {
+        return aiReturn_FAILURE;
+    }
+    virtual size_t Tell() const {
+        return cursor;
+    }
+    virtual void Flush() {
+        // not implemented
+    }
+
+    virtual size_t FileSize() const {
+        return cursor;
+    }
+
+    // -------------------------------------------------------------------
+    virtual size_t Write(const void* pvBuffer, size_t pSize, size_t pCount) {
+        pSize *= pCount;
+        if (cursor + pSize > cur_size) {
+            Grow(cursor + pSize);
+        }
+
+        memcpy(buffer+cursor, pvBuffer, pSize);
+        cursor += pSize;
+
+        return pCount;
+    }
+
+};
+
+// ----------------------------------------------------------------------------------
+/** @class  AssbinExport
+ *  @brief  Assbin exporter class
+ *
+ *  This class performs the .assbin exporting, and is responsible for the file layout.
+ */
+class AssbinExport
+{
+private:
+    bool shortened;
+    bool compressed;
+
+protected:
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryNode( IOStream * container, const aiNode* node)
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AINODE );
+
+        unsigned int nb_metadata = (node->mMetaData != NULL ? node->mMetaData->mNumProperties : 0);
+
+        Write<aiString>(&chunk,node->mName);
+        Write<aiMatrix4x4>(&chunk,node->mTransformation);
+        Write<unsigned int>(&chunk,node->mNumChildren);
+        Write<unsigned int>(&chunk,node->mNumMeshes);
+        Write<unsigned int>(&chunk,nb_metadata);
+
+        for (unsigned int i = 0; i < node->mNumMeshes;++i) {
+            Write<unsigned int>(&chunk,node->mMeshes[i]);
+        }
+
+        for (unsigned int i = 0; i < node->mNumChildren;++i) {
+            WriteBinaryNode( &chunk, node->mChildren[i] );
+        }
+
+        for (unsigned int i = 0; i < nb_metadata; ++i) {
+            const aiString& key = node->mMetaData->mKeys[i];
+            aiMetadataType type = node->mMetaData->mValues[i].mType;
+            void* value = node->mMetaData->mValues[i].mData;
+
+            Write<aiString>(&chunk, key);
+            Write<uint16_t>(&chunk, type);
+
+            switch (type) {
+                case AI_BOOL:
+                    Write<bool>(&chunk, *((bool*) value));
+                    break;
+                case AI_INT32:
+                    Write<int32_t>(&chunk, *((int32_t*) value));
+                    break;
+                case AI_UINT64:
+                    Write<uint64_t>(&chunk, *((uint64_t*) value));
+                    break;
+                case AI_FLOAT:
+                    Write<float>(&chunk, *((float*) value));
+                    break;
+                case AI_DOUBLE:
+                    Write<double>(&chunk, *((double*) value));
+                    break;
+                case AI_AISTRING:
+                    Write<aiString>(&chunk, *((aiString*) value));
+                    break;
+                case AI_AIVECTOR3D:
+                    Write<aiVector3D>(&chunk, *((aiVector3D*) value));
+                    break;
+#ifdef SWIG
+                case FORCE_32BIT:
+#endif // SWIG
+                default:
+                    break;
+            }
+        }
+    }
+
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryTexture(IOStream * container, const aiTexture* tex)
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AITEXTURE );
+
+        Write<unsigned int>(&chunk,tex->mWidth);
+        Write<unsigned int>(&chunk,tex->mHeight);
+        chunk.Write( tex->achFormatHint, sizeof(char), 4 );
+
+        if(!shortened) {
+            if (!tex->mHeight) {
+                chunk.Write(tex->pcData,1,tex->mWidth);
+            }
+            else {
+                chunk.Write(tex->pcData,1,tex->mWidth*tex->mHeight*4);
+            }
+        }
+
+    }
+
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryBone(IOStream * container, const aiBone* b)
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIBONE );
+
+        Write<aiString>(&chunk,b->mName);
+        Write<unsigned int>(&chunk,b->mNumWeights);
+        Write<aiMatrix4x4>(&chunk,b->mOffsetMatrix);
+
+        // for the moment we write dumb min/max values for the bones, too.
+        // maybe I'll add a better, hash-like solution later
+        if (shortened) {
+            WriteBounds(&chunk,b->mWeights,b->mNumWeights);
+        } // else write as usual
+        else WriteArray<aiVertexWeight>(&chunk,b->mWeights,b->mNumWeights);
+    }
+
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryMesh(IOStream * container, const aiMesh* mesh)
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIMESH );
+
+        Write<unsigned int>(&chunk,mesh->mPrimitiveTypes);
+        Write<unsigned int>(&chunk,mesh->mNumVertices);
+        Write<unsigned int>(&chunk,mesh->mNumFaces);
+        Write<unsigned int>(&chunk,mesh->mNumBones);
+        Write<unsigned int>(&chunk,mesh->mMaterialIndex);
+
+        // first of all, write bits for all existent vertex components
+        unsigned int c = 0;
+        if (mesh->mVertices) {
+            c |= ASSBIN_MESH_HAS_POSITIONS;
+        }
+        if (mesh->mNormals) {
+            c |= ASSBIN_MESH_HAS_NORMALS;
+        }
+        if (mesh->mTangents && mesh->mBitangents) {
+            c |= ASSBIN_MESH_HAS_TANGENTS_AND_BITANGENTS;
+        }
+        for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n) {
+            if (!mesh->mTextureCoords[n]) {
+                break;
+            }
+            c |= ASSBIN_MESH_HAS_TEXCOORD(n);
+        }
+        for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS;++n) {
+            if (!mesh->mColors[n]) {
+                break;
+            }
+            c |= ASSBIN_MESH_HAS_COLOR(n);
+        }
+        Write<unsigned int>(&chunk,c);
+
+        aiVector3D minVec, maxVec;
+        if (mesh->mVertices) {
+            if (shortened) {
+                WriteBounds(&chunk,mesh->mVertices,mesh->mNumVertices);
+            } // else write as usual
+            else WriteArray<aiVector3D>(&chunk,mesh->mVertices,mesh->mNumVertices);
+        }
+        if (mesh->mNormals) {
+            if (shortened) {
+                WriteBounds(&chunk,mesh->mNormals,mesh->mNumVertices);
+            } // else write as usual
+            else WriteArray<aiVector3D>(&chunk,mesh->mNormals,mesh->mNumVertices);
+        }
+        if (mesh->mTangents && mesh->mBitangents) {
+            if (shortened) {
+                WriteBounds(&chunk,mesh->mTangents,mesh->mNumVertices);
+                WriteBounds(&chunk,mesh->mBitangents,mesh->mNumVertices);
+            } // else write as usual
+            else {
+                WriteArray<aiVector3D>(&chunk,mesh->mTangents,mesh->mNumVertices);
+                WriteArray<aiVector3D>(&chunk,mesh->mBitangents,mesh->mNumVertices);
+            }
+        }
+        for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS;++n) {
+            if (!mesh->mColors[n])
+                break;
+
+            if (shortened) {
+                WriteBounds(&chunk,mesh->mColors[n],mesh->mNumVertices);
+            } // else write as usual
+            else WriteArray<aiColor4D>(&chunk,mesh->mColors[n],mesh->mNumVertices);
+        }
+        for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n) {
+            if (!mesh->mTextureCoords[n])
+                break;
+
+            // write number of UV components
+            Write<unsigned int>(&chunk,mesh->mNumUVComponents[n]);
+
+            if (shortened) {
+                WriteBounds(&chunk,mesh->mTextureCoords[n],mesh->mNumVertices);
+            } // else write as usual
+            else WriteArray<aiVector3D>(&chunk,mesh->mTextureCoords[n],mesh->mNumVertices);
+        }
+
+        // write faces. There are no floating-point calculations involved
+        // in these, so we can write a simple hash over the face data
+        // to the dump file. We generate a single 32 Bit hash for 512 faces
+        // using Assimp's standard hashing function.
+        if (shortened) {
+            unsigned int processed = 0;
+            for (unsigned int job;(job = std::min(mesh->mNumFaces-processed,512u));processed += job) {
+
+                uint32_t hash = 0;
+                for (unsigned int a = 0; a < job;++a) {
+
+                    const aiFace& f = mesh->mFaces[processed+a];
+                    uint32_t tmp = f.mNumIndices;
+                    hash = SuperFastHash(reinterpret_cast<const char*>(&tmp),sizeof tmp,hash);
+                    for (unsigned int i = 0; i < f.mNumIndices; ++i) {
+                        static_assert(AI_MAX_VERTICES <= 0xffffffff, "AI_MAX_VERTICES <= 0xffffffff");
+                        tmp = static_cast<uint32_t>( f.mIndices[i] );
+                        hash = SuperFastHash(reinterpret_cast<const char*>(&tmp),sizeof tmp,hash);
+                    }
+                }
+                Write<unsigned int>(&chunk,hash);
+            }
+        }
+        else // else write as usual
+        {
+            // if there are less than 2^16 vertices, we can simply use 16 bit integers ...
+            for (unsigned int i = 0; i < mesh->mNumFaces;++i) {
+                const aiFace& f = mesh->mFaces[i];
+
+                static_assert(AI_MAX_FACE_INDICES <= 0xffff, "AI_MAX_FACE_INDICES <= 0xffff");
+                Write<uint16_t>(&chunk,f.mNumIndices);
+
+                for (unsigned int a = 0; a < f.mNumIndices;++a) {
+                    if (mesh->mNumVertices < (1u<<16)) {
+                        Write<uint16_t>(&chunk,f.mIndices[a]);
+                    }
+                    else Write<unsigned int>(&chunk,f.mIndices[a]);
+                }
+            }
+        }
+
+        // write bones
+        if (mesh->mNumBones) {
+            for (unsigned int a = 0; a < mesh->mNumBones;++a) {
+                const aiBone* b = mesh->mBones[a];
+                WriteBinaryBone(&chunk,b);
+            }
+        }
+    }
+
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryMaterialProperty(IOStream * container, const aiMaterialProperty* prop)
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIMATERIALPROPERTY );
+
+        Write<aiString>(&chunk,prop->mKey);
+        Write<unsigned int>(&chunk,prop->mSemantic);
+        Write<unsigned int>(&chunk,prop->mIndex);
+
+        Write<unsigned int>(&chunk,prop->mDataLength);
+        Write<unsigned int>(&chunk,(unsigned int)prop->mType);
+        chunk.Write(prop->mData,1,prop->mDataLength);
+    }
+
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryMaterial(IOStream * container, const aiMaterial* mat)
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIMATERIAL);
+
+        Write<unsigned int>(&chunk,mat->mNumProperties);
+        for (unsigned int i = 0; i < mat->mNumProperties;++i) {
+            WriteBinaryMaterialProperty( &chunk, mat->mProperties[i]);
+        }
+    }
+
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryNodeAnim(IOStream * container, const aiNodeAnim* nd)
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AINODEANIM );
+
+        Write<aiString>(&chunk,nd->mNodeName);
+        Write<unsigned int>(&chunk,nd->mNumPositionKeys);
+        Write<unsigned int>(&chunk,nd->mNumRotationKeys);
+        Write<unsigned int>(&chunk,nd->mNumScalingKeys);
+        Write<unsigned int>(&chunk,nd->mPreState);
+        Write<unsigned int>(&chunk,nd->mPostState);
+
+        if (nd->mPositionKeys) {
+            if (shortened) {
+                WriteBounds(&chunk,nd->mPositionKeys,nd->mNumPositionKeys);
+
+            } // else write as usual
+            else WriteArray<aiVectorKey>(&chunk,nd->mPositionKeys,nd->mNumPositionKeys);
+        }
+        if (nd->mRotationKeys) {
+            if (shortened) {
+                WriteBounds(&chunk,nd->mRotationKeys,nd->mNumRotationKeys);
+
+            } // else write as usual
+            else WriteArray<aiQuatKey>(&chunk,nd->mRotationKeys,nd->mNumRotationKeys);
+        }
+        if (nd->mScalingKeys) {
+            if (shortened) {
+                WriteBounds(&chunk,nd->mScalingKeys,nd->mNumScalingKeys);
+
+            } // else write as usual
+            else WriteArray<aiVectorKey>(&chunk,nd->mScalingKeys,nd->mNumScalingKeys);
+        }
+    }
+
+
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryAnim( IOStream * container, const aiAnimation* anim )
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIANIMATION );
+
+        Write<aiString>(&chunk,anim->mName);
+        Write<double>(&chunk,anim->mDuration);
+        Write<double>(&chunk,anim->mTicksPerSecond);
+        Write<unsigned int>(&chunk,anim->mNumChannels);
+
+        for (unsigned int a = 0; a < anim->mNumChannels;++a) {
+            const aiNodeAnim* nd = anim->mChannels[a];
+            WriteBinaryNodeAnim(&chunk,nd);
+        }
+    }
+
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryLight( IOStream * container, const aiLight* l )
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AILIGHT );
+
+        Write<aiString>(&chunk,l->mName);
+        Write<unsigned int>(&chunk,l->mType);
+
+        if (l->mType != aiLightSource_DIRECTIONAL) {
+            Write<float>(&chunk,l->mAttenuationConstant);
+            Write<float>(&chunk,l->mAttenuationLinear);
+            Write<float>(&chunk,l->mAttenuationQuadratic);
+        }
+
+        Write<aiColor3D>(&chunk,l->mColorDiffuse);
+        Write<aiColor3D>(&chunk,l->mColorSpecular);
+        Write<aiColor3D>(&chunk,l->mColorAmbient);
+
+        if (l->mType == aiLightSource_SPOT) {
+            Write<float>(&chunk,l->mAngleInnerCone);
+            Write<float>(&chunk,l->mAngleOuterCone);
+        }
+
+    }
+
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryCamera( IOStream * container, const aiCamera* cam )
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AICAMERA );
+
+        Write<aiString>(&chunk,cam->mName);
+        Write<aiVector3D>(&chunk,cam->mPosition);
+        Write<aiVector3D>(&chunk,cam->mLookAt);
+        Write<aiVector3D>(&chunk,cam->mUp);
+        Write<float>(&chunk,cam->mHorizontalFOV);
+        Write<float>(&chunk,cam->mClipPlaneNear);
+        Write<float>(&chunk,cam->mClipPlaneFar);
+        Write<float>(&chunk,cam->mAspect);
+    }
+
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryScene( IOStream * container, const aiScene* scene)
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AISCENE );
+
+        // basic scene information
+        Write<unsigned int>(&chunk,scene->mFlags);
+        Write<unsigned int>(&chunk,scene->mNumMeshes);
+        Write<unsigned int>(&chunk,scene->mNumMaterials);
+        Write<unsigned int>(&chunk,scene->mNumAnimations);
+        Write<unsigned int>(&chunk,scene->mNumTextures);
+        Write<unsigned int>(&chunk,scene->mNumLights);
+        Write<unsigned int>(&chunk,scene->mNumCameras);
+
+        // write node graph
+        WriteBinaryNode( &chunk, scene->mRootNode );
+
+        // write all meshes
+        for (unsigned int i = 0; i < scene->mNumMeshes;++i) {
+            const aiMesh* mesh = scene->mMeshes[i];
+            WriteBinaryMesh( &chunk,mesh);
+        }
+
+        // write materials
+        for (unsigned int i = 0; i< scene->mNumMaterials; ++i) {
+            const aiMaterial* mat = scene->mMaterials[i];
+            WriteBinaryMaterial(&chunk,mat);
+        }
+
+        // write all animations
+        for (unsigned int i = 0; i < scene->mNumAnimations;++i) {
+            const aiAnimation* anim = scene->mAnimations[i];
+            WriteBinaryAnim(&chunk,anim);
+        }
+
+
+        // write all textures
+        for (unsigned int i = 0; i < scene->mNumTextures;++i) {
+            const aiTexture* mesh = scene->mTextures[i];
+            WriteBinaryTexture(&chunk,mesh);
+        }
+
+        // write lights
+        for (unsigned int i = 0; i < scene->mNumLights;++i) {
+            const aiLight* l = scene->mLights[i];
+            WriteBinaryLight(&chunk,l);
+        }
+
+        // write cameras
+        for (unsigned int i = 0; i < scene->mNumCameras;++i) {
+            const aiCamera* cam = scene->mCameras[i];
+            WriteBinaryCamera(&chunk,cam);
+        }
+
+    }
+
+public:
+    AssbinExport()
+        : shortened(false), compressed(false) // temporary settings until properties are introduced for exporters
+    {
+    }
+
+    // -----------------------------------------------------------------------------------
+    // Write a binary model dump
+    void WriteBinaryDump(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene)
+    {
+        IOStream * out = pIOSystem->Open( pFile, "wb" );
+        if (!out) return;
+
+        time_t tt = time(NULL);
+#if _WIN32
+        tm* p     = gmtime(&tt);
+#else
+        struct tm now;
+        tm* p = gmtime_r(&tt, &now);
+#endif
+
+        // header
+        char s[64];
+        memset( s, 0, 64 );
+#if _MSC_VER >= 1400
+        sprintf_s(s,"ASSIMP.binary-dump.%s",asctime(p));
+#else
+        ai_snprintf(s,64,"ASSIMP.binary-dump.%s",asctime(p));
+#endif
+        out->Write( s, 44, 1 );
+        // == 44 bytes
+
+        Write<unsigned int>( out, ASSBIN_VERSION_MAJOR );
+        Write<unsigned int>( out, ASSBIN_VERSION_MINOR );
+        Write<unsigned int>( out, aiGetVersionRevision() );
+        Write<unsigned int>( out, aiGetCompileFlags() );
+        Write<uint16_t>( out, shortened );
+        Write<uint16_t>( out, compressed );
+        // ==  20 bytes
+
+        char buff[256];
+        strncpy(buff,pFile,256);
+        out->Write(buff,sizeof(char),256);
+
+        char cmd[] = "\0";
+        strncpy(buff,cmd,128);
+        out->Write(buff,sizeof(char),128);
+
+        // leave 64 bytes free for future extensions
+        memset(buff,0xcd,64);
+        out->Write(buff,sizeof(char),64);
+        // == 435 bytes
+
+        // ==== total header size: 512 bytes
+        ai_assert( out->Tell() == ASSBIN_HEADER_LENGTH );
+
+        // Up to here the data is uncompressed. For compressed files, the rest
+        // is compressed using standard DEFLATE from zlib.
+        if (compressed)
+        {
+            AssbinChunkWriter uncompressedStream( NULL, 0 );
+            WriteBinaryScene( &uncompressedStream, pScene );
+
+            uLongf uncompressedSize = static_cast<uLongf>(uncompressedStream.Tell());
+            uLongf compressedSize = (uLongf)compressBound(uncompressedSize);
+            uint8_t* compressedBuffer = new uint8_t[ compressedSize ];
+
+            int res = compress2( compressedBuffer, &compressedSize, (const Bytef*)uncompressedStream.GetBufferPointer(), uncompressedSize, 9 );
+            if(res != Z_OK)
+            {
+                delete [] compressedBuffer;
+                pIOSystem->Close(out);
+                throw DeadlyExportError("Compression failed.");
+            }
+
+            out->Write( &uncompressedSize, sizeof(uint32_t), 1 );
+            out->Write( compressedBuffer, sizeof(char), compressedSize );
+
+            delete[] compressedBuffer;
+        }
+        else
+        {
+            WriteBinaryScene( out, pScene );
+        }
+
+        pIOSystem->Close( out );
+    }
+};
+
 void ExportSceneAssbin(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/) {
-    DumpSceneToAssbin(
-        pFile,
-        "\0", // no command(s).
-        pIOSystem,
-        pScene,
-        false, // shortened?
-        false); // compressed?
+    AssbinExport exporter;
+    exporter.WriteBinaryDump( pFile, pIOSystem, pScene );
 }
 } // end of namespace Assimp
 
diff --git a/Engine/lib/assimp/code/Assbin/AssbinExporter.h b/Engine/lib/assimp/code/Assbin/AssbinExporter.h
index 350ed85e3..3e13639bb 100644
--- a/Engine/lib/assimp/code/Assbin/AssbinExporter.h
+++ b/Engine/lib/assimp/code/Assbin/AssbinExporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Assbin/AssbinFileWriter.cpp b/Engine/lib/assimp/code/Assbin/AssbinFileWriter.cpp
deleted file mode 100644
index 4bc8f7cac..000000000
--- a/Engine/lib/assimp/code/Assbin/AssbinFileWriter.cpp
+++ /dev/null
@@ -1,858 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-/** @file  AssbinFileWriter.cpp
- *  @brief Implementation of Assbin file writer.
- */
-
-#include "AssbinFileWriter.h"
-
-#include "Common/assbin_chunks.h"
-#include "PostProcessing/ProcessHelper.h"
-
-#include <assimp/version.h>
-#include <assimp/IOStream.hpp>
-#include <assimp/Exporter.hpp>
-#include <assimp/Exceptional.h>
-
-#ifdef ASSIMP_BUILD_NO_OWN_ZLIB
-#   include <zlib.h>
-#else
-#   include "../contrib/zlib/zlib.h"
-#endif
-
-#include <time.h>
-
-namespace Assimp {
-
-template <typename T>
-size_t Write(IOStream * stream, const T& v) {
-    return stream->Write( &v, sizeof(T), 1 );
-}
-
-// -----------------------------------------------------------------------------------
-// Serialize an aiString
-template <>
-inline
-size_t Write<aiString>(IOStream * stream, const aiString& s) {
-    const size_t s2 = (uint32_t)s.length;
-    stream->Write(&s,4,1);
-    stream->Write(s.data,s2,1);
-
-    return s2+4;
-}
-
-// -----------------------------------------------------------------------------------
-// Serialize an unsigned int as uint32_t
-template <>
-inline
-size_t Write<unsigned int>(IOStream * stream, const unsigned int& w) {
-    const uint32_t t = (uint32_t)w;
-    if (w > t) {
-        // this shouldn't happen, integers in Assimp data structures never exceed 2^32
-        throw DeadlyExportError("loss of data due to 64 -> 32 bit integer conversion");
-    }
-
-    stream->Write(&t,4,1);
-
-    return 4;
-}
-
-// -----------------------------------------------------------------------------------
-// Serialize an unsigned int as uint16_t
-template <>
-inline
-size_t Write<uint16_t>(IOStream * stream, const uint16_t& w) {
-    static_assert(sizeof(uint16_t)==2, "sizeof(uint16_t)==2");
-    stream->Write(&w,2,1);
-
-    return 2;
-}
-
-// -----------------------------------------------------------------------------------
-// Serialize a float
-template <>
-inline
-size_t Write<float>(IOStream * stream, const float& f) {
-    static_assert(sizeof(float)==4, "sizeof(float)==4");
-    stream->Write(&f,4,1);
-
-    return 4;
-}
-
-// -----------------------------------------------------------------------------------
-// Serialize a double
-template <>
-inline
-size_t Write<double>(IOStream * stream, const double& f) {
-    static_assert(sizeof(double)==8, "sizeof(double)==8");
-    stream->Write(&f,8,1);
-
-    return 8;
-}
-
-// -----------------------------------------------------------------------------------
-// Serialize a vec3
-template <>
-inline
-size_t Write<aiVector3D>(IOStream * stream, const aiVector3D& v) {
-    size_t t = Write<float>(stream,v.x);
-    t += Write<float>(stream,v.y);
-    t += Write<float>(stream,v.z);
-
-    return t;
-}
-
-// -----------------------------------------------------------------------------------
-// Serialize a color value
-template <>
-inline
-size_t Write<aiColor3D>(IOStream * stream, const aiColor3D& v) {
-    size_t t = Write<float>(stream,v.r);
-    t += Write<float>(stream,v.g);
-    t += Write<float>(stream,v.b);
-
-    return t;
-}
-
-// -----------------------------------------------------------------------------------
-// Serialize a color value
-template <>
-inline
-size_t Write<aiColor4D>(IOStream * stream, const aiColor4D& v) {
-    size_t t = Write<float>(stream,v.r);
-    t += Write<float>(stream,v.g);
-    t += Write<float>(stream,v.b);
-    t += Write<float>(stream,v.a);
-
-    return t;
-}
-
-// -----------------------------------------------------------------------------------
-// Serialize a quaternion
-template <>
-inline
-size_t Write<aiQuaternion>(IOStream * stream, const aiQuaternion& v) {
-    size_t t = Write<float>(stream,v.w);
-    t += Write<float>(stream,v.x);
-    t += Write<float>(stream,v.y);
-    t += Write<float>(stream,v.z);
-    ai_assert(t == 16);
-
-    return 16;
-}
-
-// -----------------------------------------------------------------------------------
-// Serialize a vertex weight
-template <>
-inline
-size_t Write<aiVertexWeight>(IOStream * stream, const aiVertexWeight& v) {
-    size_t t = Write<unsigned int>(stream,v.mVertexId);
-
-    return t+Write<float>(stream,v.mWeight);
-}
-
-// -----------------------------------------------------------------------------------
-// Serialize a mat4x4
-template <>
-inline
-size_t Write<aiMatrix4x4>(IOStream * stream, const aiMatrix4x4& m) {
-    for (unsigned int i = 0; i < 4;++i) {
-        for (unsigned int i2 = 0; i2 < 4;++i2) {
-            Write<float>(stream,m[i][i2]);
-        }
-    }
-
-    return 64;
-}
-
-// -----------------------------------------------------------------------------------
-// Serialize an aiVectorKey
-template <>
-inline
-size_t Write<aiVectorKey>(IOStream * stream, const aiVectorKey& v) {
-    const size_t t = Write<double>(stream,v.mTime);
-    return t + Write<aiVector3D>(stream,v.mValue);
-}
-
-// -----------------------------------------------------------------------------------
-// Serialize an aiQuatKey
-template <>
-inline
-size_t Write<aiQuatKey>(IOStream * stream, const aiQuatKey& v) {
-    const size_t t = Write<double>(stream,v.mTime);
-    return t + Write<aiQuaternion>(stream,v.mValue);
-}
-
-template <typename T>
-inline
-size_t WriteBounds(IOStream * stream, const T* in, unsigned int size) {
-    T minc, maxc;
-    ArrayBounds(in,size,minc,maxc);
-
-    const size_t t = Write<T>(stream,minc);
-    return t + Write<T>(stream,maxc);
-}
-
-// We use this to write out non-byte arrays so that we write using the specializations.
-// This way we avoid writing out extra bytes that potentially come from struct alignment.
-template <typename T>
-inline
-size_t WriteArray(IOStream * stream, const T* in, unsigned int size) {
-    size_t n = 0;
-    for (unsigned int i=0; i<size; i++) n += Write<T>(stream,in[i]);
-
-    return n;
-}
-
-// ----------------------------------------------------------------------------------
-/** @class  AssbinChunkWriter
- *  @brief  Chunk writer mechanism for the .assbin file structure
- *
- *  This is a standard in-memory IOStream (most of the code is based on BlobIOStream),
- *  the difference being that this takes another IOStream as a "container" in the
- *  constructor, and when it is destroyed, it appends the magic number, the chunk size,
- *  and the chunk contents to the container stream. This allows relatively easy chunk
- *  chunk construction, even recursively.
- */
-class AssbinChunkWriter : public IOStream
-{
-private:
-
-    uint8_t* buffer;
-    uint32_t magic;
-    IOStream * container;
-    size_t cur_size, cursor, initial;
-
-private:
-    // -------------------------------------------------------------------
-    void Grow(size_t need = 0)
-    {
-        size_t new_size = std::max(initial, std::max( need, cur_size+(cur_size>>1) ));
-
-        const uint8_t* const old = buffer;
-        buffer = new uint8_t[new_size];
-
-        if (old) {
-            memcpy(buffer,old,cur_size);
-            delete[] old;
-        }
-
-        cur_size = new_size;
-    }
-
-public:
-
-    AssbinChunkWriter( IOStream * container, uint32_t magic, size_t initial = 4096)
-        : buffer(NULL), magic(magic), container(container), cur_size(0), cursor(0), initial(initial)
-    {
-    }
-
-    virtual ~AssbinChunkWriter()
-    {
-        if (container) {
-            container->Write( &magic, sizeof(uint32_t), 1 );
-            container->Write( &cursor, sizeof(uint32_t), 1 );
-            container->Write( buffer, 1, cursor );
-        }
-        if (buffer) delete[] buffer;
-    }
-
-    void * GetBufferPointer() { return buffer; }
-
-    // -------------------------------------------------------------------
-    virtual size_t Read(void* /*pvBuffer*/, size_t /*pSize*/, size_t /*pCount*/) {
-        return 0;
-    }
-    virtual aiReturn Seek(size_t /*pOffset*/, aiOrigin /*pOrigin*/) {
-        return aiReturn_FAILURE;
-    }
-    virtual size_t Tell() const {
-        return cursor;
-    }
-    virtual void Flush() {
-        // not implemented
-    }
-
-    virtual size_t FileSize() const {
-        return cursor;
-    }
-
-    // -------------------------------------------------------------------
-    virtual size_t Write(const void* pvBuffer, size_t pSize, size_t pCount) {
-        pSize *= pCount;
-        if (cursor + pSize > cur_size) {
-            Grow(cursor + pSize);
-        }
-
-        memcpy(buffer+cursor, pvBuffer, pSize);
-        cursor += pSize;
-
-        return pCount;
-    }
-
-};
-
-// ----------------------------------------------------------------------------------
-/** @class  AssbinFileWriter
- *  @brief  Assbin file writer class
- *
- *  This class writes an .assbin file, and is responsible for the file layout.
- */
-class AssbinFileWriter
-{
-private:
-    bool shortened;
-    bool compressed;
-
-protected:
-    // -----------------------------------------------------------------------------------
-    void WriteBinaryNode( IOStream * container, const aiNode* node)
-    {
-        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AINODE );
-
-        unsigned int nb_metadata = (node->mMetaData != NULL ? node->mMetaData->mNumProperties : 0);
-
-        Write<aiString>(&chunk,node->mName);
-        Write<aiMatrix4x4>(&chunk,node->mTransformation);
-        Write<unsigned int>(&chunk,node->mNumChildren);
-        Write<unsigned int>(&chunk,node->mNumMeshes);
-        Write<unsigned int>(&chunk,nb_metadata);
-
-        for (unsigned int i = 0; i < node->mNumMeshes;++i) {
-            Write<unsigned int>(&chunk,node->mMeshes[i]);
-        }
-
-        for (unsigned int i = 0; i < node->mNumChildren;++i) {
-            WriteBinaryNode( &chunk, node->mChildren[i] );
-        }
-
-        for (unsigned int i = 0; i < nb_metadata; ++i) {
-            const aiString& key = node->mMetaData->mKeys[i];
-            aiMetadataType type = node->mMetaData->mValues[i].mType;
-            void* value = node->mMetaData->mValues[i].mData;
-
-            Write<aiString>(&chunk, key);
-            Write<uint16_t>(&chunk, type);
-
-            switch (type) {
-                case AI_BOOL:
-                    Write<bool>(&chunk, *((bool*) value));
-                    break;
-                case AI_INT32:
-                    Write<int32_t>(&chunk, *((int32_t*) value));
-                    break;
-                case AI_UINT64:
-                    Write<uint64_t>(&chunk, *((uint64_t*) value));
-                    break;
-                case AI_FLOAT:
-                    Write<float>(&chunk, *((float*) value));
-                    break;
-                case AI_DOUBLE:
-                    Write<double>(&chunk, *((double*) value));
-                    break;
-                case AI_AISTRING:
-                    Write<aiString>(&chunk, *((aiString*) value));
-                    break;
-                case AI_AIVECTOR3D:
-                    Write<aiVector3D>(&chunk, *((aiVector3D*) value));
-                    break;
-#ifdef SWIG
-                case FORCE_32BIT:
-#endif // SWIG
-                default:
-                    break;
-            }
-        }
-    }
-
-    // -----------------------------------------------------------------------------------
-    void WriteBinaryTexture(IOStream * container, const aiTexture* tex)
-    {
-        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AITEXTURE );
-
-        Write<unsigned int>(&chunk,tex->mWidth);
-        Write<unsigned int>(&chunk,tex->mHeight);
-        // Write the texture format, but don't include the null terminator.
-        chunk.Write( tex->achFormatHint, sizeof(char), HINTMAXTEXTURELEN - 1 );
-
-        if(!shortened) {
-            if (!tex->mHeight) {
-                chunk.Write(tex->pcData,1,tex->mWidth);
-            }
-            else {
-                chunk.Write(tex->pcData,1,tex->mWidth*tex->mHeight*4);
-            }
-        }
-
-    }
-
-    // -----------------------------------------------------------------------------------
-    void WriteBinaryBone(IOStream * container, const aiBone* b)
-    {
-        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIBONE );
-
-        Write<aiString>(&chunk,b->mName);
-        Write<unsigned int>(&chunk,b->mNumWeights);
-        Write<aiMatrix4x4>(&chunk,b->mOffsetMatrix);
-
-        // for the moment we write dumb min/max values for the bones, too.
-        // maybe I'll add a better, hash-like solution later
-        if (shortened) {
-            WriteBounds(&chunk,b->mWeights,b->mNumWeights);
-        } // else write as usual
-        else WriteArray<aiVertexWeight>(&chunk,b->mWeights,b->mNumWeights);
-    }
-
-    // -----------------------------------------------------------------------------------
-    void WriteBinaryMesh(IOStream * container, const aiMesh* mesh)
-    {
-        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIMESH );
-
-        Write<unsigned int>(&chunk,mesh->mPrimitiveTypes);
-        Write<unsigned int>(&chunk,mesh->mNumVertices);
-        Write<unsigned int>(&chunk,mesh->mNumFaces);
-        Write<unsigned int>(&chunk,mesh->mNumBones);
-        Write<unsigned int>(&chunk,mesh->mMaterialIndex);
-
-        // first of all, write bits for all existent vertex components
-        unsigned int c = 0;
-        if (mesh->mVertices) {
-            c |= ASSBIN_MESH_HAS_POSITIONS;
-        }
-        if (mesh->mNormals) {
-            c |= ASSBIN_MESH_HAS_NORMALS;
-        }
-        if (mesh->mTangents && mesh->mBitangents) {
-            c |= ASSBIN_MESH_HAS_TANGENTS_AND_BITANGENTS;
-        }
-        for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n) {
-            if (!mesh->mTextureCoords[n]) {
-                break;
-            }
-            c |= ASSBIN_MESH_HAS_TEXCOORD(n);
-        }
-        for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS;++n) {
-            if (!mesh->mColors[n]) {
-                break;
-            }
-            c |= ASSBIN_MESH_HAS_COLOR(n);
-        }
-        Write<unsigned int>(&chunk,c);
-
-        aiVector3D minVec, maxVec;
-        if (mesh->mVertices) {
-            if (shortened) {
-                WriteBounds(&chunk,mesh->mVertices,mesh->mNumVertices);
-            } // else write as usual
-            else WriteArray<aiVector3D>(&chunk,mesh->mVertices,mesh->mNumVertices);
-        }
-        if (mesh->mNormals) {
-            if (shortened) {
-                WriteBounds(&chunk,mesh->mNormals,mesh->mNumVertices);
-            } // else write as usual
-            else WriteArray<aiVector3D>(&chunk,mesh->mNormals,mesh->mNumVertices);
-        }
-        if (mesh->mTangents && mesh->mBitangents) {
-            if (shortened) {
-                WriteBounds(&chunk,mesh->mTangents,mesh->mNumVertices);
-                WriteBounds(&chunk,mesh->mBitangents,mesh->mNumVertices);
-            } // else write as usual
-            else {
-                WriteArray<aiVector3D>(&chunk,mesh->mTangents,mesh->mNumVertices);
-                WriteArray<aiVector3D>(&chunk,mesh->mBitangents,mesh->mNumVertices);
-            }
-        }
-        for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS;++n) {
-            if (!mesh->mColors[n])
-                break;
-
-            if (shortened) {
-                WriteBounds(&chunk,mesh->mColors[n],mesh->mNumVertices);
-            } // else write as usual
-            else WriteArray<aiColor4D>(&chunk,mesh->mColors[n],mesh->mNumVertices);
-        }
-        for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n) {
-            if (!mesh->mTextureCoords[n])
-                break;
-
-            // write number of UV components
-            Write<unsigned int>(&chunk,mesh->mNumUVComponents[n]);
-
-            if (shortened) {
-                WriteBounds(&chunk,mesh->mTextureCoords[n],mesh->mNumVertices);
-            } // else write as usual
-            else WriteArray<aiVector3D>(&chunk,mesh->mTextureCoords[n],mesh->mNumVertices);
-        }
-
-        // write faces. There are no floating-point calculations involved
-        // in these, so we can write a simple hash over the face data
-        // to the dump file. We generate a single 32 Bit hash for 512 faces
-        // using Assimp's standard hashing function.
-        if (shortened) {
-            unsigned int processed = 0;
-            for (unsigned int job;(job = std::min(mesh->mNumFaces-processed,512u));processed += job) {
-
-                uint32_t hash = 0;
-                for (unsigned int a = 0; a < job;++a) {
-
-                    const aiFace& f = mesh->mFaces[processed+a];
-                    uint32_t tmp = f.mNumIndices;
-                    hash = SuperFastHash(reinterpret_cast<const char*>(&tmp),sizeof tmp,hash);
-                    for (unsigned int i = 0; i < f.mNumIndices; ++i) {
-                        static_assert(AI_MAX_VERTICES <= 0xffffffff, "AI_MAX_VERTICES <= 0xffffffff");
-                        tmp = static_cast<uint32_t>( f.mIndices[i] );
-                        hash = SuperFastHash(reinterpret_cast<const char*>(&tmp),sizeof tmp,hash);
-                    }
-                }
-                Write<unsigned int>(&chunk,hash);
-            }
-        }
-        else // else write as usual
-        {
-            // if there are less than 2^16 vertices, we can simply use 16 bit integers ...
-            for (unsigned int i = 0; i < mesh->mNumFaces;++i) {
-                const aiFace& f = mesh->mFaces[i];
-
-                static_assert(AI_MAX_FACE_INDICES <= 0xffff, "AI_MAX_FACE_INDICES <= 0xffff");
-                Write<uint16_t>(&chunk,f.mNumIndices);
-
-                for (unsigned int a = 0; a < f.mNumIndices;++a) {
-                    if (mesh->mNumVertices < (1u<<16)) {
-                        Write<uint16_t>(&chunk,f.mIndices[a]);
-                    }
-                    else Write<unsigned int>(&chunk,f.mIndices[a]);
-                }
-            }
-        }
-
-        // write bones
-        if (mesh->mNumBones) {
-            for (unsigned int a = 0; a < mesh->mNumBones;++a) {
-                const aiBone* b = mesh->mBones[a];
-                WriteBinaryBone(&chunk,b);
-            }
-        }
-    }
-
-    // -----------------------------------------------------------------------------------
-    void WriteBinaryMaterialProperty(IOStream * container, const aiMaterialProperty* prop)
-    {
-        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIMATERIALPROPERTY );
-
-        Write<aiString>(&chunk,prop->mKey);
-        Write<unsigned int>(&chunk,prop->mSemantic);
-        Write<unsigned int>(&chunk,prop->mIndex);
-
-        Write<unsigned int>(&chunk,prop->mDataLength);
-        Write<unsigned int>(&chunk,(unsigned int)prop->mType);
-        chunk.Write(prop->mData,1,prop->mDataLength);
-    }
-
-    // -----------------------------------------------------------------------------------
-    void WriteBinaryMaterial(IOStream * container, const aiMaterial* mat)
-    {
-        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIMATERIAL);
-
-        Write<unsigned int>(&chunk,mat->mNumProperties);
-        for (unsigned int i = 0; i < mat->mNumProperties;++i) {
-            WriteBinaryMaterialProperty( &chunk, mat->mProperties[i]);
-        }
-    }
-
-    // -----------------------------------------------------------------------------------
-    void WriteBinaryNodeAnim(IOStream * container, const aiNodeAnim* nd)
-    {
-        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AINODEANIM );
-
-        Write<aiString>(&chunk,nd->mNodeName);
-        Write<unsigned int>(&chunk,nd->mNumPositionKeys);
-        Write<unsigned int>(&chunk,nd->mNumRotationKeys);
-        Write<unsigned int>(&chunk,nd->mNumScalingKeys);
-        Write<unsigned int>(&chunk,nd->mPreState);
-        Write<unsigned int>(&chunk,nd->mPostState);
-
-        if (nd->mPositionKeys) {
-            if (shortened) {
-                WriteBounds(&chunk,nd->mPositionKeys,nd->mNumPositionKeys);
-
-            } // else write as usual
-            else WriteArray<aiVectorKey>(&chunk,nd->mPositionKeys,nd->mNumPositionKeys);
-        }
-        if (nd->mRotationKeys) {
-            if (shortened) {
-                WriteBounds(&chunk,nd->mRotationKeys,nd->mNumRotationKeys);
-
-            } // else write as usual
-            else WriteArray<aiQuatKey>(&chunk,nd->mRotationKeys,nd->mNumRotationKeys);
-        }
-        if (nd->mScalingKeys) {
-            if (shortened) {
-                WriteBounds(&chunk,nd->mScalingKeys,nd->mNumScalingKeys);
-
-            } // else write as usual
-            else WriteArray<aiVectorKey>(&chunk,nd->mScalingKeys,nd->mNumScalingKeys);
-        }
-    }
-
-
-    // -----------------------------------------------------------------------------------
-    void WriteBinaryAnim( IOStream * container, const aiAnimation* anim )
-    {
-        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIANIMATION );
-
-        Write<aiString>(&chunk,anim->mName);
-        Write<double>(&chunk,anim->mDuration);
-        Write<double>(&chunk,anim->mTicksPerSecond);
-        Write<unsigned int>(&chunk,anim->mNumChannels);
-
-        for (unsigned int a = 0; a < anim->mNumChannels;++a) {
-            const aiNodeAnim* nd = anim->mChannels[a];
-            WriteBinaryNodeAnim(&chunk,nd);
-        }
-    }
-
-    // -----------------------------------------------------------------------------------
-    void WriteBinaryLight( IOStream * container, const aiLight* l )
-    {
-        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AILIGHT );
-
-        Write<aiString>(&chunk,l->mName);
-        Write<unsigned int>(&chunk,l->mType);
-
-        if (l->mType != aiLightSource_DIRECTIONAL) {
-            Write<float>(&chunk,l->mAttenuationConstant);
-            Write<float>(&chunk,l->mAttenuationLinear);
-            Write<float>(&chunk,l->mAttenuationQuadratic);
-        }
-
-        Write<aiColor3D>(&chunk,l->mColorDiffuse);
-        Write<aiColor3D>(&chunk,l->mColorSpecular);
-        Write<aiColor3D>(&chunk,l->mColorAmbient);
-
-        if (l->mType == aiLightSource_SPOT) {
-            Write<float>(&chunk,l->mAngleInnerCone);
-            Write<float>(&chunk,l->mAngleOuterCone);
-        }
-
-    }
-
-    // -----------------------------------------------------------------------------------
-    void WriteBinaryCamera( IOStream * container, const aiCamera* cam )
-    {
-        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AICAMERA );
-
-        Write<aiString>(&chunk,cam->mName);
-        Write<aiVector3D>(&chunk,cam->mPosition);
-        Write<aiVector3D>(&chunk,cam->mLookAt);
-        Write<aiVector3D>(&chunk,cam->mUp);
-        Write<float>(&chunk,cam->mHorizontalFOV);
-        Write<float>(&chunk,cam->mClipPlaneNear);
-        Write<float>(&chunk,cam->mClipPlaneFar);
-        Write<float>(&chunk,cam->mAspect);
-    }
-
-    // -----------------------------------------------------------------------------------
-    void WriteBinaryScene( IOStream * container, const aiScene* scene)
-    {
-        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AISCENE );
-
-        // basic scene information
-        Write<unsigned int>(&chunk,scene->mFlags);
-        Write<unsigned int>(&chunk,scene->mNumMeshes);
-        Write<unsigned int>(&chunk,scene->mNumMaterials);
-        Write<unsigned int>(&chunk,scene->mNumAnimations);
-        Write<unsigned int>(&chunk,scene->mNumTextures);
-        Write<unsigned int>(&chunk,scene->mNumLights);
-        Write<unsigned int>(&chunk,scene->mNumCameras);
-
-        // write node graph
-        WriteBinaryNode( &chunk, scene->mRootNode );
-
-        // write all meshes
-        for (unsigned int i = 0; i < scene->mNumMeshes;++i) {
-            const aiMesh* mesh = scene->mMeshes[i];
-            WriteBinaryMesh( &chunk,mesh);
-        }
-
-        // write materials
-        for (unsigned int i = 0; i< scene->mNumMaterials; ++i) {
-            const aiMaterial* mat = scene->mMaterials[i];
-            WriteBinaryMaterial(&chunk,mat);
-        }
-
-        // write all animations
-        for (unsigned int i = 0; i < scene->mNumAnimations;++i) {
-            const aiAnimation* anim = scene->mAnimations[i];
-            WriteBinaryAnim(&chunk,anim);
-        }
-
-
-        // write all textures
-        for (unsigned int i = 0; i < scene->mNumTextures;++i) {
-            const aiTexture* mesh = scene->mTextures[i];
-            WriteBinaryTexture(&chunk,mesh);
-        }
-
-        // write lights
-        for (unsigned int i = 0; i < scene->mNumLights;++i) {
-            const aiLight* l = scene->mLights[i];
-            WriteBinaryLight(&chunk,l);
-        }
-
-        // write cameras
-        for (unsigned int i = 0; i < scene->mNumCameras;++i) {
-            const aiCamera* cam = scene->mCameras[i];
-            WriteBinaryCamera(&chunk,cam);
-        }
-
-    }
-
-public:
-    AssbinFileWriter(bool shortened, bool compressed)
-        : shortened(shortened), compressed(compressed)
-    {
-    }
-
-    // -----------------------------------------------------------------------------------
-    // Write a binary model dump
-    void WriteBinaryDump(const char* pFile, const char* cmd, IOSystem* pIOSystem, const aiScene* pScene)
-    {
-        IOStream * out = pIOSystem->Open( pFile, "wb" );
-        if (!out)
-            throw std::runtime_error("Unable to open output file " + std::string(pFile) + '\n');
-
-        auto CloseIOStream = [&]() {
-            if (out) {
-                pIOSystem->Close(out);
-                out = nullptr; // Ensure this is only done once.
-            }
-        };
-
-        try {
-            time_t tt = time(NULL);
-#if _WIN32
-            tm* p = gmtime(&tt);
-#else
-            struct tm now;
-            tm* p = gmtime_r(&tt, &now);
-#endif
-
-            // header
-            char s[64];
-            memset(s, 0, 64);
-#if _MSC_VER >= 1400
-            sprintf_s(s, "ASSIMP.binary-dump.%s", asctime(p));
-#else
-            ai_snprintf(s, 64, "ASSIMP.binary-dump.%s", asctime(p));
-#endif
-            out->Write(s, 44, 1);
-            // == 44 bytes
-
-            Write<unsigned int>(out, ASSBIN_VERSION_MAJOR);
-            Write<unsigned int>(out, ASSBIN_VERSION_MINOR);
-            Write<unsigned int>(out, aiGetVersionRevision());
-            Write<unsigned int>(out, aiGetCompileFlags());
-            Write<uint16_t>(out, shortened);
-            Write<uint16_t>(out, compressed);
-            // ==  20 bytes
-
-            char buff[256] = {0};
-            ai_snprintf(buff, 256, "%s", pFile);
-            out->Write(buff, sizeof(char), 256);
-
-            memset(buff, 0, sizeof(buff));
-            ai_snprintf(buff, 128, "%s", cmd);
-            out->Write(buff, sizeof(char), 128);
-            
-            // leave 64 bytes free for future extensions
-            memset(buff, 0xcd, 64);
-            out->Write(buff, sizeof(char), 64);
-            // == 435 bytes
-
-            // ==== total header size: 512 bytes
-            ai_assert(out->Tell() == ASSBIN_HEADER_LENGTH);
-
-            // Up to here the data is uncompressed. For compressed files, the rest
-            // is compressed using standard DEFLATE from zlib.
-            if (compressed)
-            {
-                AssbinChunkWriter uncompressedStream(NULL, 0);
-                WriteBinaryScene(&uncompressedStream, pScene);
-
-                uLongf uncompressedSize = static_cast<uLongf>(uncompressedStream.Tell());
-                uLongf compressedSize = (uLongf)compressBound(uncompressedSize);
-                uint8_t* compressedBuffer = new uint8_t[compressedSize];
-
-                int res = compress2(compressedBuffer, &compressedSize, (const Bytef*)uncompressedStream.GetBufferPointer(), uncompressedSize, 9);
-                if (res != Z_OK)
-                {
-                    delete[] compressedBuffer;
-                    throw DeadlyExportError("Compression failed.");
-                }
-
-                out->Write(&uncompressedSize, sizeof(uint32_t), 1);
-                out->Write(compressedBuffer, sizeof(char), compressedSize);
-
-                delete[] compressedBuffer;
-            }
-            else
-            {
-                WriteBinaryScene(out, pScene);
-            }
-
-            CloseIOStream();
-        }
-        catch (...) {
-            CloseIOStream();
-            throw;
-        }
-    }
-};
-
-void DumpSceneToAssbin(
-    const char* pFile, const char* cmd, IOSystem* pIOSystem,
-    const aiScene* pScene, bool shortened, bool compressed) {
-    AssbinFileWriter fileWriter(shortened, compressed);
-    fileWriter.WriteBinaryDump(pFile, cmd, pIOSystem, pScene);
-}
-
-} // end of namespace Assimp
diff --git a/Engine/lib/assimp/code/Assbin/AssbinFileWriter.h b/Engine/lib/assimp/code/Assbin/AssbinFileWriter.h
deleted file mode 100644
index 25db6db2d..000000000
--- a/Engine/lib/assimp/code/Assbin/AssbinFileWriter.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file AssbinFileWriter.h
- *  @brief Declaration of Assbin file writer.
- */
-
-#ifndef AI_ASSBINFILEWRITER_H_INC
-#define AI_ASSBINFILEWRITER_H_INC
-
-#include <assimp/defs.h>
-#include <assimp/scene.h>
-#include <assimp/IOSystem.hpp>
-
-namespace Assimp {
-
-void ASSIMP_API DumpSceneToAssbin(
-    const char* pFile,
-    const char* cmd,
-    IOSystem* pIOSystem,
-    const aiScene* pScene,
-    bool shortened,
-    bool compressed);
-
-}
-
-#endif // AI_ASSBINFILEWRITER_H_INC
diff --git a/Engine/lib/assimp/code/Assbin/AssbinLoader.cpp b/Engine/lib/assimp/code/Assbin/AssbinLoader.cpp
index 71e35cb6a..becc3f8fc 100644
--- a/Engine/lib/assimp/code/Assbin/AssbinLoader.cpp
+++ b/Engine/lib/assimp/code/Assbin/AssbinLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -535,7 +535,7 @@ void AssbinImporter::ReadBinaryTexture(IOStream * stream, aiTexture* tex) {
 
     tex->mWidth = Read<unsigned int>(stream);
     tex->mHeight = Read<unsigned int>(stream);
-    stream->Read( tex->achFormatHint, sizeof(char), HINTMAXTEXTURELEN - 1 );
+    stream->Read( tex->achFormatHint, sizeof(char), 4 );
 
     if(!shortened) {
         if (!tex->mHeight) {
diff --git a/Engine/lib/assimp/code/Assbin/AssbinLoader.h b/Engine/lib/assimp/code/Assbin/AssbinLoader.h
index e6e99f26e..9f2dde125 100644
--- a/Engine/lib/assimp/code/Assbin/AssbinLoader.h
+++ b/Engine/lib/assimp/code/Assbin/AssbinLoader.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Assjson/cencode.c b/Engine/lib/assimp/code/Assjson/cencode.c
index bd302100b..db99e7efa 100644
--- a/Engine/lib/assimp/code/Assjson/cencode.c
+++ b/Engine/lib/assimp/code/Assjson/cencode.c
@@ -42,7 +42,7 @@ int base64_encode_block(const char* plaintext_in, int length_in, char* code_out,
 			{
 				state_in->result = result;
 				state_in->step = step_A;
-				return (int)(codechar - code_out);
+				return codechar - code_out;
 			}
 			fragment = *plainchar++;
 			result = (fragment & 0x0fc) >> 2;
@@ -53,7 +53,7 @@ int base64_encode_block(const char* plaintext_in, int length_in, char* code_out,
 			{
 				state_in->result = result;
 				state_in->step = step_B;
-				return (int)(codechar - code_out);
+				return codechar - code_out;
 			}
 			fragment = *plainchar++;
 			result |= (fragment & 0x0f0) >> 4;
@@ -64,7 +64,7 @@ int base64_encode_block(const char* plaintext_in, int length_in, char* code_out,
 			{
 				state_in->result = result;
 				state_in->step = step_C;
-				return (int)(codechar - code_out);
+				return codechar - code_out;
 			}
 			fragment = *plainchar++;
 			result |= (fragment & 0x0c0) >> 6;
@@ -81,7 +81,7 @@ int base64_encode_block(const char* plaintext_in, int length_in, char* code_out,
 		}
 	}
 	/* control should not reach here */
-	return (int)(codechar - code_out);
+	return codechar - code_out;
 }
 
 int base64_encode_blockend(char* code_out, base64_encodestate* state_in)
@@ -104,6 +104,6 @@ int base64_encode_blockend(char* code_out, base64_encodestate* state_in)
 	}
 	*codechar++ = '\n';
 	
-	return (int)(codechar - code_out);
+	return codechar - code_out;
 }
 
diff --git a/Engine/lib/assimp/code/Assxml/AssxmlExporter.cpp b/Engine/lib/assimp/code/Assxml/AssxmlExporter.cpp
index 720fd5b40..afdecbaf6 100644
--- a/Engine/lib/assimp/code/Assxml/AssxmlExporter.cpp
+++ b/Engine/lib/assimp/code/Assxml/AssxmlExporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -46,20 +46,607 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_EXPORT
 #ifndef ASSIMP_BUILD_NO_ASSXML_EXPORTER
 
-#include "AssxmlFileWriter.h"
+#include "PostProcessing/ProcessHelper.h"
+
+#include <assimp/version.h>
+#include <assimp/IOStream.hpp>
 #include <assimp/IOSystem.hpp>
 #include <assimp/Exporter.hpp>
 
+#include <stdarg.h>
+
+#ifdef ASSIMP_BUILD_NO_OWN_ZLIB
+#   include <zlib.h>
+#else
+#   include <contrib/zlib/zlib.h>
+#endif
+
+#include <time.h>
+#include <stdio.h>
+
+using namespace Assimp;
+
 namespace Assimp    {
 
+namespace AssxmlExport  {
+
+// -----------------------------------------------------------------------------------
+static int ioprintf( IOStream * io, const char *format, ... ) {
+	using namespace std;
+    if ( nullptr == io ) {
+        return -1;
+    }
+
+    static const int Size = 4096;
+    char sz[ Size ];
+    ::memset( sz, '\0', Size );
+    va_list va;
+    va_start( va, format );
+    const unsigned int nSize = vsnprintf( sz, Size-1, format, va );
+    ai_assert( nSize < Size );
+    va_end( va );
+
+    io->Write( sz, sizeof(char), nSize );
+
+    return nSize;
+}
+
+// -----------------------------------------------------------------------------------
+// Convert a name to standard XML format
+static void ConvertName(aiString& out, const aiString& in) {
+    out.length = 0;
+    for (unsigned int i = 0; i < in.length; ++i)  {
+        switch (in.data[i]) {
+            case '<':
+                out.Append("&lt;");break;
+            case '>':
+                out.Append("&gt;");break;
+            case '&':
+                out.Append("&amp;");break;
+            case '\"':
+                out.Append("&quot;");break;
+            case '\'':
+                out.Append("&apos;");break;
+            default:
+                out.data[out.length++] = in.data[i];
+        }
+    }
+    out.data[out.length] = 0;
+}
+
+// -----------------------------------------------------------------------------------
+// Write a single node as text dump
+static void WriteNode(const aiNode* node, IOStream * io, unsigned int depth) {
+    char prefix[512];
+    for (unsigned int i = 0; i < depth;++i)
+        prefix[i] = '\t';
+    prefix[depth] = '\0';
+
+    const aiMatrix4x4& m = node->mTransformation;
+
+    aiString name;
+    ConvertName(name,node->mName);
+    ioprintf(io,"%s<Node name=\"%s\"> \n"
+        "%s\t<Matrix4> \n"
+        "%s\t\t%0 6f %0 6f %0 6f %0 6f\n"
+        "%s\t\t%0 6f %0 6f %0 6f %0 6f\n"
+        "%s\t\t%0 6f %0 6f %0 6f %0 6f\n"
+        "%s\t\t%0 6f %0 6f %0 6f %0 6f\n"
+        "%s\t</Matrix4> \n",
+        prefix,name.data,prefix,
+        prefix,m.a1,m.a2,m.a3,m.a4,
+        prefix,m.b1,m.b2,m.b3,m.b4,
+        prefix,m.c1,m.c2,m.c3,m.c4,
+        prefix,m.d1,m.d2,m.d3,m.d4,prefix);
+
+    if (node->mNumMeshes) {
+        ioprintf(io, "%s\t<MeshRefs num=\"%i\">\n%s\t",
+            prefix,node->mNumMeshes,prefix);
+
+        for (unsigned int i = 0; i < node->mNumMeshes;++i) {
+            ioprintf(io,"%i ",node->mMeshes[i]);
+        }
+        ioprintf(io,"\n%s\t</MeshRefs>\n",prefix);
+    }
+
+    if (node->mNumChildren) {
+        ioprintf(io,"%s\t<NodeList num=\"%i\">\n",
+            prefix,node->mNumChildren);
+
+        for (unsigned int i = 0; i < node->mNumChildren;++i) {
+            WriteNode(node->mChildren[i],io,depth+2);
+        }
+        ioprintf(io,"%s\t</NodeList>\n",prefix);
+    }
+    ioprintf(io,"%s</Node>\n",prefix);
+}
+
+
+// -----------------------------------------------------------------------------------
+// Some chuncks of text will need to be encoded for XML
+// http://stackoverflow.com/questions/5665231/most-efficient-way-to-escape-xml-html-in-c-string#5665377
+static std::string encodeXML(const std::string& data) {
+    std::string buffer;
+    buffer.reserve(data.size());
+    for(size_t pos = 0; pos != data.size(); ++pos) {
+            switch(data[pos]) {
+                    case '&':  buffer.append("&amp;");              break;
+                    case '\"': buffer.append("&quot;");             break;
+                    case '\'': buffer.append("&apos;");             break;
+                    case '<':  buffer.append("&lt;");                   break;
+                    case '>':  buffer.append("&gt;");                   break;
+                    default:   buffer.append(&data[pos], 1);    break;
+            }
+    }
+    return buffer;
+}
+
+// -----------------------------------------------------------------------------------
+// Write a text model dump
+static
+void WriteDump(const aiScene* scene, IOStream* io, bool shortened) {
+    time_t tt = ::time( NULL );
+#if _WIN32
+    tm* p = gmtime(&tt);
+#else
+    struct tm now;
+    tm* p = gmtime_r(&tt, &now);
+#endif
+    ai_assert(nullptr != p);
+
+    // write header
+    std::string header(
+        "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
+        "<ASSIMP format_id=\"1\">\n\n"
+        "<!-- XML Model dump produced by assimp dump\n"
+        "  Library version: %i.%i.%i\n"
+        "  %s\n"
+        "-->"
+        " \n\n"
+        "<Scene flags=\"%d\" postprocessing=\"%i\">\n"
+    );
+
+    const unsigned int majorVersion( aiGetVersionMajor() );
+    const unsigned int minorVersion( aiGetVersionMinor() );
+    const unsigned int rev( aiGetVersionRevision() );
+    const char *curtime( asctime( p ) );
+    ioprintf( io, header.c_str(), majorVersion, minorVersion, rev, curtime, scene->mFlags, 0 );
+
+    // write the node graph
+    WriteNode(scene->mRootNode, io, 0);
+
+#if 0
+        // write cameras
+    for (unsigned int i = 0; i < scene->mNumCameras;++i) {
+        aiCamera* cam  = scene->mCameras[i];
+        ConvertName(name,cam->mName);
+
+        // camera header
+        ioprintf(io,"\t<Camera parent=\"%s\">\n"
+            "\t\t<Vector3 name=\"up\"        > %0 8f %0 8f %0 8f </Vector3>\n"
+            "\t\t<Vector3 name=\"lookat\"    > %0 8f %0 8f %0 8f </Vector3>\n"
+            "\t\t<Vector3 name=\"pos\"       > %0 8f %0 8f %0 8f </Vector3>\n"
+            "\t\t<Float   name=\"fov\"       > %f </Float>\n"
+            "\t\t<Float   name=\"aspect\"    > %f </Float>\n"
+            "\t\t<Float   name=\"near_clip\" > %f </Float>\n"
+            "\t\t<Float   name=\"far_clip\"  > %f </Float>\n"
+            "\t</Camera>\n",
+            name.data,
+            cam->mUp.x,cam->mUp.y,cam->mUp.z,
+            cam->mLookAt.x,cam->mLookAt.y,cam->mLookAt.z,
+            cam->mPosition.x,cam->mPosition.y,cam->mPosition.z,
+            cam->mHorizontalFOV,cam->mAspect,cam->mClipPlaneNear,cam->mClipPlaneFar,i);
+    }
+
+    // write lights
+    for (unsigned int i = 0; i < scene->mNumLights;++i) {
+        aiLight* l  = scene->mLights[i];
+        ConvertName(name,l->mName);
+
+        // light header
+        ioprintf(io,"\t<Light parent=\"%s\"> type=\"%s\"\n"
+            "\t\t<Vector3 name=\"diffuse\"   > %0 8f %0 8f %0 8f </Vector3>\n"
+            "\t\t<Vector3 name=\"specular\"  > %0 8f %0 8f %0 8f </Vector3>\n"
+            "\t\t<Vector3 name=\"ambient\"   > %0 8f %0 8f %0 8f </Vector3>\n",
+            name.data,
+            (l->mType == aiLightSource_DIRECTIONAL ? "directional" :
+            (l->mType == aiLightSource_POINT ? "point" : "spot" )),
+            l->mColorDiffuse.r, l->mColorDiffuse.g, l->mColorDiffuse.b,
+            l->mColorSpecular.r,l->mColorSpecular.g,l->mColorSpecular.b,
+            l->mColorAmbient.r, l->mColorAmbient.g, l->mColorAmbient.b);
+
+        if (l->mType != aiLightSource_DIRECTIONAL) {
+            ioprintf(io,
+                "\t\t<Vector3 name=\"pos\"       > %0 8f %0 8f %0 8f </Vector3>\n"
+                "\t\t<Float   name=\"atten_cst\" > %f </Float>\n"
+                "\t\t<Float   name=\"atten_lin\" > %f </Float>\n"
+                "\t\t<Float   name=\"atten_sqr\" > %f </Float>\n",
+                l->mPosition.x,l->mPosition.y,l->mPosition.z,
+                l->mAttenuationConstant,l->mAttenuationLinear,l->mAttenuationQuadratic);
+        }
+
+        if (l->mType != aiLightSource_POINT) {
+            ioprintf(io,
+                "\t\t<Vector3 name=\"lookat\"    > %0 8f %0 8f %0 8f </Vector3>\n",
+                l->mDirection.x,l->mDirection.y,l->mDirection.z);
+        }
+
+        if (l->mType == aiLightSource_SPOT) {
+            ioprintf(io,
+                "\t\t<Float   name=\"cone_out\" > %f </Float>\n"
+                "\t\t<Float   name=\"cone_inn\" > %f </Float>\n",
+                l->mAngleOuterCone,l->mAngleInnerCone);
+        }
+        ioprintf(io,"\t</Light>\n");
+    }
+#endif
+    aiString name;
+
+    // write textures
+    if (scene->mNumTextures) {
+        ioprintf(io,"<TextureList num=\"%i\">\n",scene->mNumTextures);
+        for (unsigned int i = 0; i < scene->mNumTextures;++i) {
+            aiTexture* tex  = scene->mTextures[i];
+            bool compressed = (tex->mHeight == 0);
+
+            // mesh header
+            ioprintf(io,"\t<Texture width=\"%i\" height=\"%i\" compressed=\"%s\"> \n",
+                (compressed ? -1 : tex->mWidth),(compressed ? -1 : tex->mHeight),
+                (compressed ? "true" : "false"));
+
+            if (compressed) {
+                ioprintf(io,"\t\t<Data length=\"%i\"> \n",tex->mWidth);
+
+                if (!shortened) {
+                    for (unsigned int n = 0; n < tex->mWidth;++n) {
+                        ioprintf(io,"\t\t\t%2x",reinterpret_cast<uint8_t*>(tex->pcData)[n]);
+                        if (n && !(n % 50)) {
+                            ioprintf(io,"\n");
+                        }
+                    }
+                }
+            }
+            else if (!shortened){
+                ioprintf(io,"\t\t<Data length=\"%i\"> \n",tex->mWidth*tex->mHeight*4);
+
+                // const unsigned int width = (unsigned int)std::log10((double)std::max(tex->mHeight,tex->mWidth))+1;
+                for (unsigned int y = 0; y < tex->mHeight;++y) {
+                    for (unsigned int x = 0; x < tex->mWidth;++x) {
+                        aiTexel* tx = tex->pcData + y*tex->mWidth+x;
+                        unsigned int r = tx->r,g=tx->g,b=tx->b,a=tx->a;
+                        ioprintf(io,"\t\t\t%2x %2x %2x %2x",r,g,b,a);
+
+                        // group by four for readability
+                        if ( 0 == ( x + y*tex->mWidth ) % 4 ) {
+                            ioprintf( io, "\n" );
+                        }
+                    }
+                }
+            }
+            ioprintf(io,"\t\t</Data>\n\t</Texture>\n");
+        }
+        ioprintf(io,"</TextureList>\n");
+    }
+
+    // write materials
+    if (scene->mNumMaterials) {
+        ioprintf(io,"<MaterialList num=\"%i\">\n",scene->mNumMaterials);
+        for (unsigned int i = 0; i< scene->mNumMaterials; ++i) {
+            const aiMaterial* mat = scene->mMaterials[i];
+
+            ioprintf(io,"\t<Material>\n");
+            ioprintf(io,"\t\t<MatPropertyList  num=\"%i\">\n",mat->mNumProperties);
+            for (unsigned int n = 0; n < mat->mNumProperties;++n) {
+
+                const aiMaterialProperty* prop = mat->mProperties[n];
+                const char* sz = "";
+                if (prop->mType == aiPTI_Float) {
+                    sz = "float";
+                }
+                else if (prop->mType == aiPTI_Integer) {
+                    sz = "integer";
+                }
+                else if (prop->mType == aiPTI_String) {
+                    sz = "string";
+                }
+                else if (prop->mType == aiPTI_Buffer) {
+                    sz = "binary_buffer";
+                }
+
+                ioprintf(io,"\t\t\t<MatProperty key=\"%s\" \n\t\t\ttype=\"%s\" tex_usage=\"%s\" tex_index=\"%i\"",
+                    prop->mKey.data, sz,
+                    ::TextureTypeToString((aiTextureType)prop->mSemantic),prop->mIndex);
+
+                if (prop->mType == aiPTI_Float) {
+                    ioprintf(io," size=\"%i\">\n\t\t\t\t",
+                        static_cast<int>(prop->mDataLength/sizeof(float)));
+
+                    for (unsigned int p = 0; p < prop->mDataLength/sizeof(float);++p) {
+                        ioprintf(io,"%f ",*((float*)(prop->mData+p*sizeof(float))));
+                    }
+                }
+                else if (prop->mType == aiPTI_Integer) {
+                    ioprintf(io," size=\"%i\">\n\t\t\t\t",
+                        static_cast<int>(prop->mDataLength/sizeof(int)));
+
+                    for (unsigned int p = 0; p < prop->mDataLength/sizeof(int);++p) {
+                        ioprintf(io,"%i ",*((int*)(prop->mData+p*sizeof(int))));
+                    }
+                }
+                else if (prop->mType == aiPTI_Buffer) {
+                    ioprintf(io," size=\"%i\">\n\t\t\t\t",
+                        static_cast<int>(prop->mDataLength));
+
+                    for (unsigned int p = 0; p < prop->mDataLength;++p) {
+                        ioprintf(io,"%2x ",prop->mData[p]);
+                        if (p && 0 == p%30) {
+                            ioprintf(io,"\n\t\t\t\t");
+                        }
+                    }
+                }
+                else if (prop->mType == aiPTI_String) {
+                    ioprintf(io,">\n\t\t\t\t\"%s\"",encodeXML(prop->mData+4).c_str() /* skip length */);
+                }
+                ioprintf(io,"\n\t\t\t</MatProperty>\n");
+            }
+            ioprintf(io,"\t\t</MatPropertyList>\n");
+            ioprintf(io,"\t</Material>\n");
+        }
+        ioprintf(io,"</MaterialList>\n");
+    }
+
+    // write animations
+    if (scene->mNumAnimations) {
+        ioprintf(io,"<AnimationList num=\"%i\">\n",scene->mNumAnimations);
+        for (unsigned int i = 0; i < scene->mNumAnimations;++i) {
+            aiAnimation* anim = scene->mAnimations[i];
+
+            // anim header
+            ConvertName(name,anim->mName);
+            ioprintf(io,"\t<Animation name=\"%s\" duration=\"%e\" tick_cnt=\"%e\">\n",
+                name.data, anim->mDuration, anim->mTicksPerSecond);
+
+            // write bone animation channels
+            if (anim->mNumChannels) {
+                ioprintf(io,"\t\t<NodeAnimList num=\"%i\">\n",anim->mNumChannels);
+                for (unsigned int n = 0; n < anim->mNumChannels;++n) {
+                    aiNodeAnim* nd = anim->mChannels[n];
+
+                    // node anim header
+                    ConvertName(name,nd->mNodeName);
+                    ioprintf(io,"\t\t\t<NodeAnim node=\"%s\">\n",name.data);
+
+                    if (!shortened) {
+                        // write position keys
+                        if (nd->mNumPositionKeys) {
+                            ioprintf(io,"\t\t\t\t<PositionKeyList num=\"%i\">\n",nd->mNumPositionKeys);
+                            for (unsigned int a = 0; a < nd->mNumPositionKeys;++a) {
+                                aiVectorKey* vc = nd->mPositionKeys+a;
+                                ioprintf(io,"\t\t\t\t\t<PositionKey time=\"%e\">\n"
+                                    "\t\t\t\t\t\t%0 8f %0 8f %0 8f\n\t\t\t\t\t</PositionKey>\n",
+                                    vc->mTime,vc->mValue.x,vc->mValue.y,vc->mValue.z);
+                            }
+                            ioprintf(io,"\t\t\t\t</PositionKeyList>\n");
+                        }
+
+                        // write scaling keys
+                        if (nd->mNumScalingKeys) {
+                            ioprintf(io,"\t\t\t\t<ScalingKeyList num=\"%i\">\n",nd->mNumScalingKeys);
+                            for (unsigned int a = 0; a < nd->mNumScalingKeys;++a) {
+                                aiVectorKey* vc = nd->mScalingKeys+a;
+                                ioprintf(io,"\t\t\t\t\t<ScalingKey time=\"%e\">\n"
+                                    "\t\t\t\t\t\t%0 8f %0 8f %0 8f\n\t\t\t\t\t</ScalingKey>\n",
+                                    vc->mTime,vc->mValue.x,vc->mValue.y,vc->mValue.z);
+                            }
+                            ioprintf(io,"\t\t\t\t</ScalingKeyList>\n");
+                        }
+
+                        // write rotation keys
+                        if (nd->mNumRotationKeys) {
+                            ioprintf(io,"\t\t\t\t<RotationKeyList num=\"%i\">\n",nd->mNumRotationKeys);
+                            for (unsigned int a = 0; a < nd->mNumRotationKeys;++a) {
+                                aiQuatKey* vc = nd->mRotationKeys+a;
+                                ioprintf(io,"\t\t\t\t\t<RotationKey time=\"%e\">\n"
+                                    "\t\t\t\t\t\t%0 8f %0 8f %0 8f %0 8f\n\t\t\t\t\t</RotationKey>\n",
+                                    vc->mTime,vc->mValue.x,vc->mValue.y,vc->mValue.z,vc->mValue.w);
+                            }
+                            ioprintf(io,"\t\t\t\t</RotationKeyList>\n");
+                        }
+                    }
+                    ioprintf(io,"\t\t\t</NodeAnim>\n");
+                }
+                ioprintf(io,"\t\t</NodeAnimList>\n");
+            }
+            ioprintf(io,"\t</Animation>\n");
+        }
+        ioprintf(io,"</AnimationList>\n");
+    }
+
+    // write meshes
+    if (scene->mNumMeshes) {
+        ioprintf(io,"<MeshList num=\"%i\">\n",scene->mNumMeshes);
+        for (unsigned int i = 0; i < scene->mNumMeshes;++i) {
+            aiMesh* mesh = scene->mMeshes[i];
+            // const unsigned int width = (unsigned int)std::log10((double)mesh->mNumVertices)+1;
+
+            // mesh header
+            ioprintf(io,"\t<Mesh types=\"%s %s %s %s\" material_index=\"%i\">\n",
+                (mesh->mPrimitiveTypes & aiPrimitiveType_POINT    ? "points"    : ""),
+                (mesh->mPrimitiveTypes & aiPrimitiveType_LINE     ? "lines"     : ""),
+                (mesh->mPrimitiveTypes & aiPrimitiveType_TRIANGLE ? "triangles" : ""),
+                (mesh->mPrimitiveTypes & aiPrimitiveType_POLYGON  ? "polygons"  : ""),
+                mesh->mMaterialIndex);
+
+            // bones
+            if (mesh->mNumBones) {
+                ioprintf(io,"\t\t<BoneList num=\"%i\">\n",mesh->mNumBones);
+
+                for (unsigned int n = 0; n < mesh->mNumBones;++n) {
+                    aiBone* bone = mesh->mBones[n];
+
+                    ConvertName(name,bone->mName);
+                    // bone header
+                    ioprintf(io,"\t\t\t<Bone name=\"%s\">\n"
+                        "\t\t\t\t<Matrix4> \n"
+                        "\t\t\t\t\t%0 6f %0 6f %0 6f %0 6f\n"
+                        "\t\t\t\t\t%0 6f %0 6f %0 6f %0 6f\n"
+                        "\t\t\t\t\t%0 6f %0 6f %0 6f %0 6f\n"
+                        "\t\t\t\t\t%0 6f %0 6f %0 6f %0 6f\n"
+                        "\t\t\t\t</Matrix4> \n",
+                        name.data,
+                        bone->mOffsetMatrix.a1,bone->mOffsetMatrix.a2,bone->mOffsetMatrix.a3,bone->mOffsetMatrix.a4,
+                        bone->mOffsetMatrix.b1,bone->mOffsetMatrix.b2,bone->mOffsetMatrix.b3,bone->mOffsetMatrix.b4,
+                        bone->mOffsetMatrix.c1,bone->mOffsetMatrix.c2,bone->mOffsetMatrix.c3,bone->mOffsetMatrix.c4,
+                        bone->mOffsetMatrix.d1,bone->mOffsetMatrix.d2,bone->mOffsetMatrix.d3,bone->mOffsetMatrix.d4);
+
+                    if (!shortened && bone->mNumWeights) {
+                        ioprintf(io,"\t\t\t\t<WeightList num=\"%i\">\n",bone->mNumWeights);
+
+                        // bone weights
+                        for (unsigned int a = 0; a < bone->mNumWeights;++a) {
+                            aiVertexWeight* wght = bone->mWeights+a;
+
+                            ioprintf(io,"\t\t\t\t\t<Weight index=\"%i\">\n\t\t\t\t\t\t%f\n\t\t\t\t\t</Weight>\n",
+                                wght->mVertexId,wght->mWeight);
+                        }
+                        ioprintf(io,"\t\t\t\t</WeightList>\n");
+                    }
+                    ioprintf(io,"\t\t\t</Bone>\n");
+                }
+                ioprintf(io,"\t\t</BoneList>\n");
+            }
+
+            // faces
+            if (!shortened && mesh->mNumFaces) {
+                ioprintf(io,"\t\t<FaceList num=\"%i\">\n",mesh->mNumFaces);
+                for (unsigned int n = 0; n < mesh->mNumFaces; ++n) {
+                    aiFace& f = mesh->mFaces[n];
+                    ioprintf(io,"\t\t\t<Face num=\"%i\">\n"
+                        "\t\t\t\t",f.mNumIndices);
+
+                    for (unsigned int j = 0; j < f.mNumIndices;++j)
+                        ioprintf(io,"%i ",f.mIndices[j]);
+
+                    ioprintf(io,"\n\t\t\t</Face>\n");
+                }
+                ioprintf(io,"\t\t</FaceList>\n");
+            }
+
+            // vertex positions
+            if (mesh->HasPositions()) {
+                ioprintf(io,"\t\t<Positions num=\"%i\" set=\"0\" num_components=\"3\"> \n",mesh->mNumVertices);
+                if (!shortened) {
+                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
+                        ioprintf(io,"\t\t%0 8f %0 8f %0 8f\n",
+                            mesh->mVertices[n].x,
+                            mesh->mVertices[n].y,
+                            mesh->mVertices[n].z);
+                    }
+                }
+                ioprintf(io,"\t\t</Positions>\n");
+            }
+
+            // vertex normals
+            if (mesh->HasNormals()) {
+                ioprintf(io,"\t\t<Normals num=\"%i\" set=\"0\" num_components=\"3\"> \n",mesh->mNumVertices);
+                if (!shortened) {
+                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
+                        ioprintf(io,"\t\t%0 8f %0 8f %0 8f\n",
+                            mesh->mNormals[n].x,
+                            mesh->mNormals[n].y,
+                            mesh->mNormals[n].z);
+                    }
+                }
+                ioprintf(io,"\t\t</Normals>\n");
+            }
+
+            // vertex tangents and bitangents
+            if (mesh->HasTangentsAndBitangents()) {
+                ioprintf(io,"\t\t<Tangents num=\"%i\" set=\"0\" num_components=\"3\"> \n",mesh->mNumVertices);
+                if (!shortened) {
+                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
+                        ioprintf(io,"\t\t%0 8f %0 8f %0 8f\n",
+                            mesh->mTangents[n].x,
+                            mesh->mTangents[n].y,
+                            mesh->mTangents[n].z);
+                    }
+                }
+                ioprintf(io,"\t\t</Tangents>\n");
+
+                ioprintf(io,"\t\t<Bitangents num=\"%i\" set=\"0\" num_components=\"3\"> \n",mesh->mNumVertices);
+                if (!shortened) {
+                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
+                        ioprintf(io,"\t\t%0 8f %0 8f %0 8f\n",
+                            mesh->mBitangents[n].x,
+                            mesh->mBitangents[n].y,
+                            mesh->mBitangents[n].z);
+                    }
+                }
+                ioprintf(io,"\t\t</Bitangents>\n");
+            }
+
+            // texture coordinates
+            for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
+                if (!mesh->mTextureCoords[a])
+                    break;
+
+                ioprintf(io,"\t\t<TextureCoords num=\"%i\" set=\"%i\" num_components=\"%i\"> \n",mesh->mNumVertices,
+                    a,mesh->mNumUVComponents[a]);
+
+                if (!shortened) {
+                    if (mesh->mNumUVComponents[a] == 3) {
+                        for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
+                            ioprintf(io,"\t\t%0 8f %0 8f %0 8f\n",
+                                mesh->mTextureCoords[a][n].x,
+                                mesh->mTextureCoords[a][n].y,
+                                mesh->mTextureCoords[a][n].z);
+                        }
+                    }
+                    else {
+                        for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
+                            ioprintf(io,"\t\t%0 8f %0 8f\n",
+                                mesh->mTextureCoords[a][n].x,
+                                mesh->mTextureCoords[a][n].y);
+                        }
+                    }
+                }
+                ioprintf(io,"\t\t</TextureCoords>\n");
+            }
+
+            // vertex colors
+            for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a) {
+                if (!mesh->mColors[a])
+                    break;
+                ioprintf(io,"\t\t<Colors num=\"%i\" set=\"%i\" num_components=\"4\"> \n",mesh->mNumVertices,a);
+                if (!shortened) {
+                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
+                        ioprintf(io,"\t\t%0 8f %0 8f %0 8f %0 8f\n",
+                            mesh->mColors[a][n].r,
+                            mesh->mColors[a][n].g,
+                            mesh->mColors[a][n].b,
+                            mesh->mColors[a][n].a);
+                    }
+                }
+                ioprintf(io,"\t\t</Colors>\n");
+            }
+            ioprintf(io,"\t</Mesh>\n");
+        }
+        ioprintf(io,"</MeshList>\n");
+    }
+    ioprintf(io,"</Scene>\n</ASSIMP>");
+}
+
+} // end of namespace AssxmlExport
+
 void ExportSceneAssxml(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/)
 {
-    DumpSceneToAssxml(
-        pFile,
-        "\0", // command(s)
-        pIOSystem,
-        pScene,
-        false); // shortened?
+    IOStream * out = pIOSystem->Open( pFile, "wt" );
+    if (!out) return;
+
+    bool shortened = false;
+    AssxmlExport::WriteDump( pScene, out, shortened );
+
+    pIOSystem->Close( out );
 }
 
 } // end of namespace Assimp
diff --git a/Engine/lib/assimp/code/Assxml/AssxmlExporter.h b/Engine/lib/assimp/code/Assxml/AssxmlExporter.h
index a2b40ada1..8ca887eea 100644
--- a/Engine/lib/assimp/code/Assxml/AssxmlExporter.h
+++ b/Engine/lib/assimp/code/Assxml/AssxmlExporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Assxml/AssxmlFileWriter.cpp b/Engine/lib/assimp/code/Assxml/AssxmlFileWriter.cpp
deleted file mode 100644
index 0ed59e509..000000000
--- a/Engine/lib/assimp/code/Assxml/AssxmlFileWriter.cpp
+++ /dev/null
@@ -1,664 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file AssxmlFileWriter.cpp
- *  @brief Implementation of Assxml file writer.
- */
-
-#include "AssxmlFileWriter.h"
-
-#include "PostProcessing/ProcessHelper.h"
-
-#include <assimp/version.h>
-#include <assimp/IOStream.hpp>
-#include <assimp/IOSystem.hpp>
-#include <assimp/Exporter.hpp>
-
-#include <stdarg.h>
-
-#ifdef ASSIMP_BUILD_NO_OWN_ZLIB
-#   include <zlib.h>
-#else
-#   include <contrib/zlib/zlib.h>
-#endif
-
-#include <time.h>
-#include <stdio.h>
-#include <memory>
-
-using namespace Assimp;
-
-namespace Assimp {
-
-namespace AssxmlFileWriter  {
-
-// -----------------------------------------------------------------------------------
-static int ioprintf( IOStream * io, const char *format, ... ) {
-    using namespace std;
-    if ( nullptr == io ) {
-        return -1;
-    }
-
-    static const int Size = 4096;
-    char sz[ Size ];
-    ::memset( sz, '\0', Size );
-    va_list va;
-    va_start( va, format );
-    const unsigned int nSize = vsnprintf( sz, Size-1, format, va );
-    ai_assert( nSize < Size );
-    va_end( va );
-
-    io->Write( sz, sizeof(char), nSize );
-
-    return nSize;
-}
-
-// -----------------------------------------------------------------------------------
-// Convert a name to standard XML format
-static void ConvertName(aiString& out, const aiString& in) {
-    out.length = 0;
-    for (unsigned int i = 0; i < in.length; ++i)  {
-        switch (in.data[i]) {
-            case '<':
-                out.Append("&lt;");break;
-            case '>':
-                out.Append("&gt;");break;
-            case '&':
-                out.Append("&amp;");break;
-            case '\"':
-                out.Append("&quot;");break;
-            case '\'':
-                out.Append("&apos;");break;
-            default:
-                out.data[out.length++] = in.data[i];
-        }
-    }
-    out.data[out.length] = 0;
-}
-
-// -----------------------------------------------------------------------------------
-// Write a single node as text dump
-static void WriteNode(const aiNode* node, IOStream * io, unsigned int depth) {
-    char prefix[512];
-    for (unsigned int i = 0; i < depth;++i)
-        prefix[i] = '\t';
-    prefix[depth] = '\0';
-
-    const aiMatrix4x4& m = node->mTransformation;
-
-    aiString name;
-    ConvertName(name,node->mName);
-    ioprintf(io,"%s<Node name=\"%s\"> \n"
-        "%s\t<Matrix4> \n"
-        "%s\t\t%0 6f %0 6f %0 6f %0 6f\n"
-        "%s\t\t%0 6f %0 6f %0 6f %0 6f\n"
-        "%s\t\t%0 6f %0 6f %0 6f %0 6f\n"
-        "%s\t\t%0 6f %0 6f %0 6f %0 6f\n"
-        "%s\t</Matrix4> \n",
-        prefix,name.data,prefix,
-        prefix,m.a1,m.a2,m.a3,m.a4,
-        prefix,m.b1,m.b2,m.b3,m.b4,
-        prefix,m.c1,m.c2,m.c3,m.c4,
-        prefix,m.d1,m.d2,m.d3,m.d4,prefix);
-
-    if (node->mNumMeshes) {
-        ioprintf(io, "%s\t<MeshRefs num=\"%u\">\n%s\t",
-            prefix,node->mNumMeshes,prefix);
-
-        for (unsigned int i = 0; i < node->mNumMeshes;++i) {
-            ioprintf(io,"%u ",node->mMeshes[i]);
-        }
-        ioprintf(io,"\n%s\t</MeshRefs>\n",prefix);
-    }
-
-    if (node->mNumChildren) {
-        ioprintf(io,"%s\t<NodeList num=\"%u\">\n",
-            prefix,node->mNumChildren);
-
-        for (unsigned int i = 0; i < node->mNumChildren;++i) {
-            WriteNode(node->mChildren[i],io,depth+2);
-        }
-        ioprintf(io,"%s\t</NodeList>\n",prefix);
-    }
-    ioprintf(io,"%s</Node>\n",prefix);
-}
-
-
-// -----------------------------------------------------------------------------------
-// Some chuncks of text will need to be encoded for XML
-// http://stackoverflow.com/questions/5665231/most-efficient-way-to-escape-xml-html-in-c-string#5665377
-static std::string encodeXML(const std::string& data) {
-    std::string buffer;
-    buffer.reserve(data.size());
-    for(size_t pos = 0; pos != data.size(); ++pos) {
-            switch(data[pos]) {
-                    case '&':  buffer.append("&amp;");              break;
-                    case '\"': buffer.append("&quot;");             break;
-                    case '\'': buffer.append("&apos;");             break;
-                    case '<':  buffer.append("&lt;");                   break;
-                    case '>':  buffer.append("&gt;");                   break;
-                    default:   buffer.append(&data[pos], 1);    break;
-            }
-    }
-    return buffer;
-}
-
-// -----------------------------------------------------------------------------------
-// Write a text model dump
-static
-void WriteDump(const char* pFile, const char* cmd, const aiScene* scene, IOStream* io, bool shortened) {
-    time_t tt = ::time( NULL );
-#if _WIN32
-    tm* p = gmtime(&tt);
-#else
-    struct tm now;
-    tm* p = gmtime_r(&tt, &now);
-#endif
-    ai_assert(nullptr != p);
-
-    std::string c = cmd;
-    std::string::size_type s; 
-
-    // https://sourceforge.net/tracker/?func=detail&aid=3167364&group_id=226462&atid=1067632
-    // -- not allowed in XML comments
-    while((s = c.find("--")) != std::string::npos) {
-        c[s] = '?';
-    }
-
-    // write header
-    std::string header(
-        "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
-        "<ASSIMP format_id=\"1\">\n\n"
-        "<!-- XML Model dump produced by assimp dump\n"
-        "  Library version: %u.%u.%u\n"
-        "  Source: %s\n"
-        "  Command line: %s\n"
-        "  %s\n"
-        "-->"
-        " \n\n"
-        "<Scene flags=\"%u\" postprocessing=\"%u\">\n"
-    );
-
-    const unsigned int majorVersion( aiGetVersionMajor() );
-    const unsigned int minorVersion( aiGetVersionMinor() );
-    const unsigned int rev( aiGetVersionRevision() );
-    const char *curtime( asctime( p ) );
-    ioprintf( io, header.c_str(), majorVersion, minorVersion, rev, pFile, c.c_str(), curtime, scene->mFlags, 0u );
-
-    // write the node graph
-    WriteNode(scene->mRootNode, io, 0);
-
-#if 0
-    // write cameras
-    for (unsigned int i = 0; i < scene->mNumCameras;++i) {
-        aiCamera* cam  = scene->mCameras[i];
-        ConvertName(name,cam->mName);
-
-        // camera header
-        ioprintf(io,"\t<Camera parent=\"%s\">\n"
-            "\t\t<Vector3 name=\"up\"        > %0 8f %0 8f %0 8f </Vector3>\n"
-            "\t\t<Vector3 name=\"lookat\"    > %0 8f %0 8f %0 8f </Vector3>\n"
-            "\t\t<Vector3 name=\"pos\"       > %0 8f %0 8f %0 8f </Vector3>\n"
-            "\t\t<Float   name=\"fov\"       > %f </Float>\n"
-            "\t\t<Float   name=\"aspect\"    > %f </Float>\n"
-            "\t\t<Float   name=\"near_clip\" > %f </Float>\n"
-            "\t\t<Float   name=\"far_clip\"  > %f </Float>\n"
-            "\t</Camera>\n",
-            name.data,
-            cam->mUp.x,cam->mUp.y,cam->mUp.z,
-            cam->mLookAt.x,cam->mLookAt.y,cam->mLookAt.z,
-            cam->mPosition.x,cam->mPosition.y,cam->mPosition.z,
-            cam->mHorizontalFOV,cam->mAspect,cam->mClipPlaneNear,cam->mClipPlaneFar,i);
-    }
-
-    // write lights
-    for (unsigned int i = 0; i < scene->mNumLights;++i) {
-        aiLight* l  = scene->mLights[i];
-        ConvertName(name,l->mName);
-
-        // light header
-        ioprintf(io,"\t<Light parent=\"%s\"> type=\"%s\"\n"
-            "\t\t<Vector3 name=\"diffuse\"   > %0 8f %0 8f %0 8f </Vector3>\n"
-            "\t\t<Vector3 name=\"specular\"  > %0 8f %0 8f %0 8f </Vector3>\n"
-            "\t\t<Vector3 name=\"ambient\"   > %0 8f %0 8f %0 8f </Vector3>\n",
-            name.data,
-            (l->mType == aiLightSource_DIRECTIONAL ? "directional" :
-            (l->mType == aiLightSource_POINT ? "point" : "spot" )),
-            l->mColorDiffuse.r, l->mColorDiffuse.g, l->mColorDiffuse.b,
-            l->mColorSpecular.r,l->mColorSpecular.g,l->mColorSpecular.b,
-            l->mColorAmbient.r, l->mColorAmbient.g, l->mColorAmbient.b);
-
-        if (l->mType != aiLightSource_DIRECTIONAL) {
-            ioprintf(io,
-                "\t\t<Vector3 name=\"pos\"       > %0 8f %0 8f %0 8f </Vector3>\n"
-                "\t\t<Float   name=\"atten_cst\" > %f </Float>\n"
-                "\t\t<Float   name=\"atten_lin\" > %f </Float>\n"
-                "\t\t<Float   name=\"atten_sqr\" > %f </Float>\n",
-                l->mPosition.x,l->mPosition.y,l->mPosition.z,
-                l->mAttenuationConstant,l->mAttenuationLinear,l->mAttenuationQuadratic);
-        }
-
-        if (l->mType != aiLightSource_POINT) {
-            ioprintf(io,
-                "\t\t<Vector3 name=\"lookat\"    > %0 8f %0 8f %0 8f </Vector3>\n",
-                l->mDirection.x,l->mDirection.y,l->mDirection.z);
-        }
-
-        if (l->mType == aiLightSource_SPOT) {
-            ioprintf(io,
-                "\t\t<Float   name=\"cone_out\" > %f </Float>\n"
-                "\t\t<Float   name=\"cone_inn\" > %f </Float>\n",
-                l->mAngleOuterCone,l->mAngleInnerCone);
-        }
-        ioprintf(io,"\t</Light>\n");
-    }
-#endif
-    aiString name;
-
-    // write textures
-    if (scene->mNumTextures) {
-        ioprintf(io,"<TextureList num=\"%u\">\n",scene->mNumTextures);
-        for (unsigned int i = 0; i < scene->mNumTextures;++i) {
-            aiTexture* tex  = scene->mTextures[i];
-            bool compressed = (tex->mHeight == 0);
-
-            // mesh header
-            ioprintf(io,"\t<Texture width=\"%u\" height=\"%u\" compressed=\"%s\"> \n",
-                (compressed ? -1 : tex->mWidth),(compressed ? -1 : tex->mHeight),
-                (compressed ? "true" : "false"));
-
-            if (compressed) {
-                ioprintf(io,"\t\t<Data length=\"%u\"> \n",tex->mWidth);
-
-                if (!shortened) {
-                    for (unsigned int n = 0; n < tex->mWidth;++n) {
-                        ioprintf(io,"\t\t\t%2x",reinterpret_cast<uint8_t*>(tex->pcData)[n]);
-                        if (n && !(n % 50)) {
-                            ioprintf(io,"\n");
-                        }
-                    }
-                }
-            }
-            else if (!shortened){
-                ioprintf(io,"\t\t<Data length=\"%u\"> \n",tex->mWidth*tex->mHeight*4);
-
-                // const unsigned int width = (unsigned int)std::log10((double)std::max(tex->mHeight,tex->mWidth))+1;
-                for (unsigned int y = 0; y < tex->mHeight;++y) {
-                    for (unsigned int x = 0; x < tex->mWidth;++x) {
-                        aiTexel* tx = tex->pcData + y*tex->mWidth+x;
-                        unsigned int r = tx->r,g=tx->g,b=tx->b,a=tx->a;
-                        ioprintf(io,"\t\t\t%2x %2x %2x %2x",r,g,b,a);
-
-                        // group by four for readability
-                        if ( 0 == ( x + y*tex->mWidth ) % 4 ) {
-                            ioprintf( io, "\n" );
-                        }
-                    }
-                }
-            }
-            ioprintf(io,"\t\t</Data>\n\t</Texture>\n");
-        }
-        ioprintf(io,"</TextureList>\n");
-    }
-
-    // write materials
-    if (scene->mNumMaterials) {
-        ioprintf(io,"<MaterialList num=\"%u\">\n",scene->mNumMaterials);
-        for (unsigned int i = 0; i< scene->mNumMaterials; ++i) {
-            const aiMaterial* mat = scene->mMaterials[i];
-
-            ioprintf(io,"\t<Material>\n");
-            ioprintf(io,"\t\t<MatPropertyList  num=\"%u\">\n",mat->mNumProperties);
-            for (unsigned int n = 0; n < mat->mNumProperties;++n) {
-
-                const aiMaterialProperty* prop = mat->mProperties[n];
-                const char* sz = "";
-                if (prop->mType == aiPTI_Float) {
-                    sz = "float";
-                }
-                else if (prop->mType == aiPTI_Integer) {
-                    sz = "integer";
-                }
-                else if (prop->mType == aiPTI_String) {
-                    sz = "string";
-                }
-                else if (prop->mType == aiPTI_Buffer) {
-                    sz = "binary_buffer";
-                }
-
-                ioprintf(io,"\t\t\t<MatProperty key=\"%s\" \n\t\t\ttype=\"%s\" tex_usage=\"%s\" tex_index=\"%u\"",
-                    prop->mKey.data, sz,
-                    ::TextureTypeToString((aiTextureType)prop->mSemantic),prop->mIndex);
-
-                if (prop->mType == aiPTI_Float) {
-                    ioprintf(io," size=\"%i\">\n\t\t\t\t",
-                        static_cast<int>(prop->mDataLength/sizeof(float)));
-
-                    for (unsigned int p = 0; p < prop->mDataLength/sizeof(float);++p) {
-                        ioprintf(io,"%f ",*((float*)(prop->mData+p*sizeof(float))));
-                    }
-                }
-                else if (prop->mType == aiPTI_Integer) {
-                    ioprintf(io," size=\"%i\">\n\t\t\t\t",
-                        static_cast<int>(prop->mDataLength/sizeof(int)));
-
-                    for (unsigned int p = 0; p < prop->mDataLength/sizeof(int);++p) {
-                        ioprintf(io,"%i ",*((int*)(prop->mData+p*sizeof(int))));
-                    }
-                }
-                else if (prop->mType == aiPTI_Buffer) {
-                    ioprintf(io," size=\"%i\">\n\t\t\t\t",
-                        static_cast<int>(prop->mDataLength));
-
-                    for (unsigned int p = 0; p < prop->mDataLength;++p) {
-                        ioprintf(io,"%2x ",prop->mData[p]);
-                        if (p && 0 == p%30) {
-                            ioprintf(io,"\n\t\t\t\t");
-                        }
-                    }
-                }
-                else if (prop->mType == aiPTI_String) {
-                    ioprintf(io,">\n\t\t\t\t\"%s\"",encodeXML(prop->mData+4).c_str() /* skip length */);
-                }
-                ioprintf(io,"\n\t\t\t</MatProperty>\n");
-            }
-            ioprintf(io,"\t\t</MatPropertyList>\n");
-            ioprintf(io,"\t</Material>\n");
-        }
-        ioprintf(io,"</MaterialList>\n");
-    }
-
-    // write animations
-    if (scene->mNumAnimations) {
-        ioprintf(io,"<AnimationList num=\"%u\">\n",scene->mNumAnimations);
-        for (unsigned int i = 0; i < scene->mNumAnimations;++i) {
-            aiAnimation* anim = scene->mAnimations[i];
-
-            // anim header
-            ConvertName(name,anim->mName);
-            ioprintf(io,"\t<Animation name=\"%s\" duration=\"%e\" tick_cnt=\"%e\">\n",
-                name.data, anim->mDuration, anim->mTicksPerSecond);
-
-            // write bone animation channels
-            if (anim->mNumChannels) {
-                ioprintf(io,"\t\t<NodeAnimList num=\"%u\">\n",anim->mNumChannels);
-                for (unsigned int n = 0; n < anim->mNumChannels;++n) {
-                    aiNodeAnim* nd = anim->mChannels[n];
-
-                    // node anim header
-                    ConvertName(name,nd->mNodeName);
-                    ioprintf(io,"\t\t\t<NodeAnim node=\"%s\">\n",name.data);
-
-                    if (!shortened) {
-                        // write position keys
-                        if (nd->mNumPositionKeys) {
-                            ioprintf(io,"\t\t\t\t<PositionKeyList num=\"%u\">\n",nd->mNumPositionKeys);
-                            for (unsigned int a = 0; a < nd->mNumPositionKeys;++a) {
-                                aiVectorKey* vc = nd->mPositionKeys+a;
-                                ioprintf(io,"\t\t\t\t\t<PositionKey time=\"%e\">\n"
-                                    "\t\t\t\t\t\t%0 8f %0 8f %0 8f\n\t\t\t\t\t</PositionKey>\n",
-                                    vc->mTime,vc->mValue.x,vc->mValue.y,vc->mValue.z);
-                            }
-                            ioprintf(io,"\t\t\t\t</PositionKeyList>\n");
-                        }
-
-                        // write scaling keys
-                        if (nd->mNumScalingKeys) {
-                            ioprintf(io,"\t\t\t\t<ScalingKeyList num=\"%u\">\n",nd->mNumScalingKeys);
-                            for (unsigned int a = 0; a < nd->mNumScalingKeys;++a) {
-                                aiVectorKey* vc = nd->mScalingKeys+a;
-                                ioprintf(io,"\t\t\t\t\t<ScalingKey time=\"%e\">\n"
-                                    "\t\t\t\t\t\t%0 8f %0 8f %0 8f\n\t\t\t\t\t</ScalingKey>\n",
-                                    vc->mTime,vc->mValue.x,vc->mValue.y,vc->mValue.z);
-                            }
-                            ioprintf(io,"\t\t\t\t</ScalingKeyList>\n");
-                        }
-
-                        // write rotation keys
-                        if (nd->mNumRotationKeys) {
-                            ioprintf(io,"\t\t\t\t<RotationKeyList num=\"%u\">\n",nd->mNumRotationKeys);
-                            for (unsigned int a = 0; a < nd->mNumRotationKeys;++a) {
-                                aiQuatKey* vc = nd->mRotationKeys+a;
-                                ioprintf(io,"\t\t\t\t\t<RotationKey time=\"%e\">\n"
-                                    "\t\t\t\t\t\t%0 8f %0 8f %0 8f %0 8f\n\t\t\t\t\t</RotationKey>\n",
-                                    vc->mTime,vc->mValue.x,vc->mValue.y,vc->mValue.z,vc->mValue.w);
-                            }
-                            ioprintf(io,"\t\t\t\t</RotationKeyList>\n");
-                        }
-                    }
-                    ioprintf(io,"\t\t\t</NodeAnim>\n");
-                }
-                ioprintf(io,"\t\t</NodeAnimList>\n");
-            }
-            ioprintf(io,"\t</Animation>\n");
-        }
-        ioprintf(io,"</AnimationList>\n");
-    }
-
-    // write meshes
-    if (scene->mNumMeshes) {
-        ioprintf(io,"<MeshList num=\"%u\">\n",scene->mNumMeshes);
-        for (unsigned int i = 0; i < scene->mNumMeshes;++i) {
-            aiMesh* mesh = scene->mMeshes[i];
-            // const unsigned int width = (unsigned int)std::log10((double)mesh->mNumVertices)+1;
-
-            // mesh header
-            ioprintf(io,"\t<Mesh types=\"%s %s %s %s\" material_index=\"%u\">\n",
-                (mesh->mPrimitiveTypes & aiPrimitiveType_POINT    ? "points"    : ""),
-                (mesh->mPrimitiveTypes & aiPrimitiveType_LINE     ? "lines"     : ""),
-                (mesh->mPrimitiveTypes & aiPrimitiveType_TRIANGLE ? "triangles" : ""),
-                (mesh->mPrimitiveTypes & aiPrimitiveType_POLYGON  ? "polygons"  : ""),
-                mesh->mMaterialIndex);
-
-            // bones
-            if (mesh->mNumBones) {
-                ioprintf(io,"\t\t<BoneList num=\"%u\">\n",mesh->mNumBones);
-
-                for (unsigned int n = 0; n < mesh->mNumBones;++n) {
-                    aiBone* bone = mesh->mBones[n];
-
-                    ConvertName(name,bone->mName);
-                    // bone header
-                    ioprintf(io,"\t\t\t<Bone name=\"%s\">\n"
-                        "\t\t\t\t<Matrix4> \n"
-                        "\t\t\t\t\t%0 6f %0 6f %0 6f %0 6f\n"
-                        "\t\t\t\t\t%0 6f %0 6f %0 6f %0 6f\n"
-                        "\t\t\t\t\t%0 6f %0 6f %0 6f %0 6f\n"
-                        "\t\t\t\t\t%0 6f %0 6f %0 6f %0 6f\n"
-                        "\t\t\t\t</Matrix4> \n",
-                        name.data,
-                        bone->mOffsetMatrix.a1,bone->mOffsetMatrix.a2,bone->mOffsetMatrix.a3,bone->mOffsetMatrix.a4,
-                        bone->mOffsetMatrix.b1,bone->mOffsetMatrix.b2,bone->mOffsetMatrix.b3,bone->mOffsetMatrix.b4,
-                        bone->mOffsetMatrix.c1,bone->mOffsetMatrix.c2,bone->mOffsetMatrix.c3,bone->mOffsetMatrix.c4,
-                        bone->mOffsetMatrix.d1,bone->mOffsetMatrix.d2,bone->mOffsetMatrix.d3,bone->mOffsetMatrix.d4);
-
-                    if (!shortened && bone->mNumWeights) {
-                        ioprintf(io,"\t\t\t\t<WeightList num=\"%u\">\n",bone->mNumWeights);
-
-                        // bone weights
-                        for (unsigned int a = 0; a < bone->mNumWeights;++a) {
-                            aiVertexWeight* wght = bone->mWeights+a;
-
-                            ioprintf(io,"\t\t\t\t\t<Weight index=\"%u\">\n\t\t\t\t\t\t%f\n\t\t\t\t\t</Weight>\n",
-                                wght->mVertexId,wght->mWeight);
-                        }
-                        ioprintf(io,"\t\t\t\t</WeightList>\n");
-                    }
-                    ioprintf(io,"\t\t\t</Bone>\n");
-                }
-                ioprintf(io,"\t\t</BoneList>\n");
-            }
-
-            // faces
-            if (!shortened && mesh->mNumFaces) {
-                ioprintf(io,"\t\t<FaceList num=\"%u\">\n",mesh->mNumFaces);
-                for (unsigned int n = 0; n < mesh->mNumFaces; ++n) {
-                    aiFace& f = mesh->mFaces[n];
-                    ioprintf(io,"\t\t\t<Face num=\"%u\">\n"
-                        "\t\t\t\t",f.mNumIndices);
-
-                    for (unsigned int j = 0; j < f.mNumIndices;++j)
-                        ioprintf(io,"%u ",f.mIndices[j]);
-
-                    ioprintf(io,"\n\t\t\t</Face>\n");
-                }
-                ioprintf(io,"\t\t</FaceList>\n");
-            }
-
-            // vertex positions
-            if (mesh->HasPositions()) {
-                ioprintf(io,"\t\t<Positions num=\"%u\" set=\"0\" num_components=\"3\"> \n",mesh->mNumVertices);
-                if (!shortened) {
-                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
-                        ioprintf(io,"\t\t%0 8f %0 8f %0 8f\n",
-                            mesh->mVertices[n].x,
-                            mesh->mVertices[n].y,
-                            mesh->mVertices[n].z);
-                    }
-                }
-                ioprintf(io,"\t\t</Positions>\n");
-            }
-
-            // vertex normals
-            if (mesh->HasNormals()) {
-                ioprintf(io,"\t\t<Normals num=\"%u\" set=\"0\" num_components=\"3\"> \n",mesh->mNumVertices);
-                if (!shortened) {
-                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
-                        ioprintf(io,"\t\t%0 8f %0 8f %0 8f\n",
-                            mesh->mNormals[n].x,
-                            mesh->mNormals[n].y,
-                            mesh->mNormals[n].z);
-                    }
-                }
-                ioprintf(io,"\t\t</Normals>\n");
-            }
-
-            // vertex tangents and bitangents
-            if (mesh->HasTangentsAndBitangents()) {
-                ioprintf(io,"\t\t<Tangents num=\"%u\" set=\"0\" num_components=\"3\"> \n",mesh->mNumVertices);
-                if (!shortened) {
-                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
-                        ioprintf(io,"\t\t%0 8f %0 8f %0 8f\n",
-                            mesh->mTangents[n].x,
-                            mesh->mTangents[n].y,
-                            mesh->mTangents[n].z);
-                    }
-                }
-                ioprintf(io,"\t\t</Tangents>\n");
-
-                ioprintf(io,"\t\t<Bitangents num=\"%u\" set=\"0\" num_components=\"3\"> \n",mesh->mNumVertices);
-                if (!shortened) {
-                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
-                        ioprintf(io,"\t\t%0 8f %0 8f %0 8f\n",
-                            mesh->mBitangents[n].x,
-                            mesh->mBitangents[n].y,
-                            mesh->mBitangents[n].z);
-                    }
-                }
-                ioprintf(io,"\t\t</Bitangents>\n");
-            }
-
-            // texture coordinates
-            for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
-                if (!mesh->mTextureCoords[a])
-                    break;
-
-                ioprintf(io,"\t\t<TextureCoords num=\"%u\" set=\"%u\" num_components=\"%u\"> \n",mesh->mNumVertices,
-                    a,mesh->mNumUVComponents[a]);
-
-                if (!shortened) {
-                    if (mesh->mNumUVComponents[a] == 3) {
-                        for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
-                            ioprintf(io,"\t\t%0 8f %0 8f %0 8f\n",
-                                mesh->mTextureCoords[a][n].x,
-                                mesh->mTextureCoords[a][n].y,
-                                mesh->mTextureCoords[a][n].z);
-                        }
-                    }
-                    else {
-                        for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
-                            ioprintf(io,"\t\t%0 8f %0 8f\n",
-                                mesh->mTextureCoords[a][n].x,
-                                mesh->mTextureCoords[a][n].y);
-                        }
-                    }
-                }
-                ioprintf(io,"\t\t</TextureCoords>\n");
-            }
-
-            // vertex colors
-            for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a) {
-                if (!mesh->mColors[a])
-                    break;
-                ioprintf(io,"\t\t<Colors num=\"%u\" set=\"%u\" num_components=\"4\"> \n",mesh->mNumVertices,a);
-                if (!shortened) {
-                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
-                        ioprintf(io,"\t\t%0 8f %0 8f %0 8f %0 8f\n",
-                            mesh->mColors[a][n].r,
-                            mesh->mColors[a][n].g,
-                            mesh->mColors[a][n].b,
-                            mesh->mColors[a][n].a);
-                    }
-                }
-                ioprintf(io,"\t\t</Colors>\n");
-            }
-            ioprintf(io,"\t</Mesh>\n");
-        }
-        ioprintf(io,"</MeshList>\n");
-    }
-    ioprintf(io,"</Scene>\n</ASSIMP>");
-}
-
-} // end of namespace AssxmlFileWriter
-
-void DumpSceneToAssxml(
-    const char* pFile, const char* cmd, IOSystem* pIOSystem,
-    const aiScene* pScene, bool shortened) {
-    std::unique_ptr<IOStream> file(pIOSystem->Open(pFile, "wt"));
-    if (!file.get()) {
-        throw std::runtime_error("Unable to open output file " + std::string(pFile) + '\n');
-    }
-
-    AssxmlFileWriter::WriteDump(pFile, cmd, pScene, file.get(), shortened);
-}
-
-} // end of namespace Assimp
diff --git a/Engine/lib/assimp/code/Assxml/AssxmlFileWriter.h b/Engine/lib/assimp/code/Assxml/AssxmlFileWriter.h
deleted file mode 100644
index c10a8a5aa..000000000
--- a/Engine/lib/assimp/code/Assxml/AssxmlFileWriter.h
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file AssxmlFileWriter.h
- *  @brief Declaration of Assxml file writer.
- */
-
-#ifndef AI_ASSXMLFILEWRITER_H_INC
-#define AI_ASSXMLFILEWRITER_H_INC
-
-#include <assimp/defs.h>
-#include <assimp/scene.h>
-#include <assimp/IOSystem.hpp>
-
-namespace Assimp {
-
-void ASSIMP_API DumpSceneToAssxml(
-    const char* pFile,
-    const char* cmd,
-    IOSystem* pIOSystem,
-    const aiScene* pScene,
-    bool shortened);
-
-}
-
-#endif // AI_ASSXMLFILEWRITER_H_INC
diff --git a/Engine/lib/assimp/code/B3D/B3DImporter.cpp b/Engine/lib/assimp/code/B3D/B3DImporter.cpp
index 07336df65..ba484ca00 100644
--- a/Engine/lib/assimp/code/B3D/B3DImporter.cpp
+++ b/Engine/lib/assimp/code/B3D/B3DImporter.cpp
@@ -3,7 +3,9 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
+
+
 
 All rights reserved.
 
@@ -76,6 +78,7 @@ static const aiImporterDesc desc = {
     "b3d"
 };
 
+// (fixme, Aramis) quick workaround to get rid of all those signed to unsigned warnings
 #ifdef _MSC_VER
 #	pragma warning (disable: 4018)
 #endif
@@ -83,8 +86,10 @@ static const aiImporterDesc desc = {
 //#define DEBUG_B3D
 
 template<typename T>
-void DeleteAllBarePointers(std::vector<T>& x) {
-    for(auto p : x) {
+void DeleteAllBarePointers(std::vector<T>& x)
+{
+    for(auto p : x)
+    {
         delete p;
     }
 }
@@ -97,14 +102,10 @@ B3DImporter::~B3DImporter()
 bool B3DImporter::CanRead( const std::string& pFile, IOSystem* /*pIOHandler*/, bool /*checkSig*/) const{
 
     size_t pos=pFile.find_last_of( '.' );
-    if( pos==string::npos ) {
-        return false;
-    }
+    if( pos==string::npos ) return false;
 
     string ext=pFile.substr( pos+1 );
-    if( ext.size()!=3 ) {
-        return false;
-    }
+    if( ext.size()!=3 ) return false;
 
     return (ext[0]=='b' || ext[0]=='B') && (ext[1]=='3') && (ext[2]=='d' || ext[2]=='D');
 }
@@ -116,21 +117,30 @@ const aiImporterDesc* B3DImporter::GetInfo () const
     return &desc;
 }
 
+#ifdef DEBUG_B3D
+    extern "C"{ void _stdcall AllocConsole(); }
+#endif
 // ------------------------------------------------------------------------------------------------
 void B3DImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler){
+
+#ifdef DEBUG_B3D
+    AllocConsole();
+    freopen( "conin$","r",stdin );
+    freopen( "conout$","w",stdout );
+    freopen( "conout$","w",stderr );
+    cout<<"Hello world from the B3DImporter!"<<endl;
+#endif
+
     std::unique_ptr<IOStream> file( pIOHandler->Open( pFile));
 
     // Check whether we can read from the file
-    if( file.get() == nullptr) {
+    if( file.get() == NULL)
         throw DeadlyImportError( "Failed to open B3D file " + pFile + ".");
-    }
 
     // check whether the .b3d file is large enough to contain
     // at least one chunk.
     size_t fileSize = file->FileSize();
-    if( fileSize<8 ) {
-        throw DeadlyImportError( "B3D File is too small.");
-    }
+    if( fileSize<8 ) throw DeadlyImportError( "B3D File is too small.");
 
     _pos=0;
     _buf.resize( fileSize );
@@ -148,17 +158,14 @@ AI_WONT_RETURN void B3DImporter::Oops(){
 // ------------------------------------------------------------------------------------------------
 AI_WONT_RETURN void B3DImporter::Fail( string str ){
 #ifdef DEBUG_B3D
-    ASSIMP_LOG_ERROR_F("Error in B3D file data: ", str);
+    cout<<"Error in B3D file data: "<<str<<endl;
 #endif
     throw DeadlyImportError( "B3D Importer - error in B3D file data: "+str );
 }
 
 // ------------------------------------------------------------------------------------------------
 int B3DImporter::ReadByte(){
-    if( _pos<_buf.size() ) {
-        return _buf[_pos++];
-    }
-    
+    if( _pos<_buf.size() ) return _buf[_pos++];
     Fail( "EOF" );
     return 0;
 }
@@ -217,9 +224,7 @@ string B3DImporter::ReadString(){
     string str;
     while( _pos<_buf.size() ){
         char c=(char)ReadByte();
-        if( !c ) {
-            return str;
-        }
+        if( !c ) return str;
         str+=c;
     }
     Fail( "EOF" );
@@ -233,7 +238,7 @@ string B3DImporter::ReadChunk(){
         tag+=char( ReadByte() );
     }
 #ifdef DEBUG_B3D
-    ASSIMP_LOG_DEBUG_F("ReadChunk: ", tag);
+//	cout<<"ReadChunk:"<<tag<<endl;
 #endif
     unsigned sz=(unsigned)ReadInt();
     _stack.push_back( _pos+sz );
@@ -264,6 +269,7 @@ T *B3DImporter::to_array( const vector<T> &v ){
     return p;
 }
 
+
 // ------------------------------------------------------------------------------------------------
 template<class T>
 T **unique_to_array( vector<std::unique_ptr<T> > &v ){
@@ -277,6 +283,7 @@ T **unique_to_array( vector<std::unique_ptr<T> > &v ){
     return p;
 }
 
+
 // ------------------------------------------------------------------------------------------------
 void B3DImporter::ReadTEXS(){
     while( ChunkSize() ){
@@ -369,13 +376,9 @@ void B3DImporter::ReadVRTS(){
 
         v.vertex=ReadVec3();
 
-        if( _vflags & 1 ) {
-            v.normal=ReadVec3();
-        }
+        if( _vflags & 1 ) v.normal=ReadVec3();
 
-        if( _vflags & 2 ) {
-            ReadQuat();	//skip v 4bytes...
-        }
+        if( _vflags & 2 ) ReadQuat();	//skip v 4bytes...
 
         for( int i=0;i<_tcsets;++i ){
             float t[4]={0,0,0,0};
@@ -383,55 +386,53 @@ void B3DImporter::ReadVRTS(){
                 t[j]=ReadFloat();
             }
             t[1]=1-t[1];
-            if( !i ) {
-                v.texcoords=aiVector3D( t[0],t[1],t[2] );
-            }
+            if( !i ) v.texcoords=aiVector3D( t[0],t[1],t[2] );
         }
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void B3DImporter::ReadTRIS(int v0) {
-	int matid = ReadInt();
-	if (matid == -1) {
-		matid = 0;
-	} else if (matid < 0 || matid >= (int)_materials.size()) {
+void B3DImporter::ReadTRIS( int v0 ){
+    int matid=ReadInt();
+    if( matid==-1 ){
+        matid=0;
+    }else if( matid<0 || matid>=(int)_materials.size() ){
 #ifdef DEBUG_B3D
-		ASSIMP_LOG_ERROR_F("material id=", matid);
+        cout<<"material id="<<matid<<endl;
 #endif
-		Fail("Bad material id");
-	}
+        Fail( "Bad material id" );
+    }
 
-	std::unique_ptr<aiMesh> mesh(new aiMesh);
+    std::unique_ptr<aiMesh> mesh(new aiMesh);
 
-	mesh->mMaterialIndex = matid;
-	mesh->mNumFaces = 0;
-	mesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
+    mesh->mMaterialIndex=matid;
+    mesh->mNumFaces=0;
+    mesh->mPrimitiveTypes=aiPrimitiveType_TRIANGLE;
 
-	int n_tris = ChunkSize() / 12;
-	aiFace *face = mesh->mFaces = new aiFace[n_tris];
+    int n_tris=ChunkSize()/12;
+    aiFace *face=mesh->mFaces=new aiFace[n_tris];
 
-	for (int i = 0; i < n_tris; ++i) {
-		int i0 = ReadInt() + v0;
-		int i1 = ReadInt() + v0;
-		int i2 = ReadInt() + v0;
-		if (i0 < 0 || i0 >= (int)_vertices.size() || i1 < 0 || i1 >= (int)_vertices.size() || i2 < 0 || i2 >= (int)_vertices.size()) {
+    for( int i=0;i<n_tris;++i ){
+        int i0=ReadInt()+v0;
+        int i1=ReadInt()+v0;
+        int i2=ReadInt()+v0;
+        if( i0<0 || i0>=(int)_vertices.size() || i1<0 || i1>=(int)_vertices.size() || i2<0 || i2>=(int)_vertices.size() ){
 #ifdef DEBUG_B3D
-			ASSIMP_LOG_ERROR_F("Bad triangle index: i0=", i0, ", i1=", i1, ", i2=", i2);
+            cout<<"Bad triangle index: i0="<<i0<<", i1="<<i1<<", i2="<<i2<<endl;
 #endif
-			Fail("Bad triangle index");
-			continue;
-		}
-		face->mNumIndices = 3;
-		face->mIndices = new unsigned[3];
-		face->mIndices[0] = i0;
-		face->mIndices[1] = i1;
-		face->mIndices[2] = i2;
-		++mesh->mNumFaces;
-		++face;
-	}
+            Fail( "Bad triangle index" );
+            continue;
+        }
+        face->mNumIndices=3;
+        face->mIndices=new unsigned[3];
+        face->mIndices[0]=i0;
+        face->mIndices[1]=i1;
+        face->mIndices[2]=i2;
+        ++mesh->mNumFaces;
+        ++face;
+    }
 
-	_meshes.emplace_back(std::move(mesh));
+    _meshes.emplace_back( std::move(mesh) );
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -452,23 +453,29 @@ void B3DImporter::ReadMESH(){
 }
 
 // ------------------------------------------------------------------------------------------------
-void B3DImporter::ReadBONE(int id) {
-	while (ChunkSize()) {
-		int vertex = ReadInt();
-		float weight = ReadFloat();
-		if (vertex < 0 || vertex >= (int)_vertices.size()) {
-			Fail("Bad vertex index");
-		}
+void B3DImporter::ReadBONE( int id ){
+    while( ChunkSize() ){
+        int vertex=ReadInt();
+        float weight=ReadFloat();
+        if( vertex<0 || vertex>=(int)_vertices.size() ){
+            Fail( "Bad vertex index" );
+        }
 
-		Vertex &v = _vertices[vertex];
-		for (int i = 0; i < 4; ++i) {
-			if (!v.weights[i]) {
-				v.bones[i] = id;
-				v.weights[i] = weight;
-				break;
-			}
-		}
-	}
+        Vertex &v=_vertices[vertex];
+        int i;
+        for( i=0;i<4;++i ){
+            if( !v.weights[i] ){
+                v.bones[i]=id;
+                v.weights[i]=weight;
+                break;
+            }
+        }
+#ifdef DEBUG_B3D
+        if( i==4 ){
+            cout<<"Too many bone weights"<<endl;
+        }
+#endif
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -626,15 +633,11 @@ void B3DImporter::ReadBB3D( aiScene *scene ){
     }
     ExitChunk();
 
-    if( !_nodes.size() ) {
-        Fail( "No nodes" );
-    }
+    if( !_nodes.size() ) Fail( "No nodes" );
 
-    if( !_meshes.size() ) {
-        Fail( "No meshes" );
-    }
+    if( !_meshes.size() ) Fail( "No meshes" );
 
-    // Fix nodes/meshes/bones
+    //Fix nodes/meshes/bones
     for(size_t i=0;i<_nodes.size();++i ){
         aiNode *node=_nodes[i];
 
@@ -645,12 +648,8 @@ void B3DImporter::ReadBB3D( aiScene *scene ){
             int n_verts=mesh->mNumVertices=n_tris * 3;
 
             aiVector3D *mv=mesh->mVertices=new aiVector3D[ n_verts ],*mn=0,*mc=0;
-            if( _vflags & 1 ) {
-                mn=mesh->mNormals=new aiVector3D[ n_verts ];
-            }
-            if( _tcsets ) {
-                mc=mesh->mTextureCoords[0]=new aiVector3D[ n_verts ];
-            }
+            if( _vflags & 1 ) mn=mesh->mNormals=new aiVector3D[ n_verts ];
+            if( _tcsets ) mc=mesh->mTextureCoords[0]=new aiVector3D[ n_verts ];
 
             aiFace *face=mesh->mFaces;
 
diff --git a/Engine/lib/assimp/code/B3D/B3DImporter.h b/Engine/lib/assimp/code/B3D/B3DImporter.h
index f0568dd16..d52dac34a 100644
--- a/Engine/lib/assimp/code/B3D/B3DImporter.h
+++ b/Engine/lib/assimp/code/B3D/B3DImporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/BVH/BVHLoader.cpp b/Engine/lib/assimp/code/BVH/BVHLoader.cpp
index 1110754c2..cd9ab0843 100644
--- a/Engine/lib/assimp/code/BVH/BVHLoader.cpp
+++ b/Engine/lib/assimp/code/BVH/BVHLoader.cpp
@@ -4,7 +4,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/BVH/BVHLoader.h b/Engine/lib/assimp/code/BVH/BVHLoader.h
index 93a3e5e83..33b4e2453 100644
--- a/Engine/lib/assimp/code/BVH/BVHLoader.h
+++ b/Engine/lib/assimp/code/BVH/BVHLoader.h
@@ -4,7 +4,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Blender/BlenderBMesh.cpp b/Engine/lib/assimp/code/Blender/BlenderBMesh.cpp
index 039302e12..8a13819a6 100644
--- a/Engine/lib/assimp/code/Blender/BlenderBMesh.cpp
+++ b/Engine/lib/assimp/code/Blender/BlenderBMesh.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2013, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
diff --git a/Engine/lib/assimp/code/Blender/BlenderBMesh.h b/Engine/lib/assimp/code/Blender/BlenderBMesh.h
index 893128606..5b65fb503 100644
--- a/Engine/lib/assimp/code/Blender/BlenderBMesh.h
+++ b/Engine/lib/assimp/code/Blender/BlenderBMesh.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2013, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
diff --git a/Engine/lib/assimp/code/Blender/BlenderDNA.cpp b/Engine/lib/assimp/code/Blender/BlenderDNA.cpp
index 53fb84824..f274e02f9 100644
--- a/Engine/lib/assimp/code/Blender/BlenderDNA.cpp
+++ b/Engine/lib/assimp/code/Blender/BlenderDNA.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Blender/BlenderDNA.h b/Engine/lib/assimp/code/Blender/BlenderDNA.h
index 16ce960e2..375d0c4bf 100644
--- a/Engine/lib/assimp/code/Blender/BlenderDNA.h
+++ b/Engine/lib/assimp/code/Blender/BlenderDNA.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Blender/BlenderDNA.inl b/Engine/lib/assimp/code/Blender/BlenderDNA.inl
index fd9993008..65bc1374c 100644
--- a/Engine/lib/assimp/code/Blender/BlenderDNA.inl
+++ b/Engine/lib/assimp/code/Blender/BlenderDNA.inl
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Blender/BlenderIntermediate.h b/Engine/lib/assimp/code/Blender/BlenderIntermediate.h
index 2c480b848..95fdf0f03 100644
--- a/Engine/lib/assimp/code/Blender/BlenderIntermediate.h
+++ b/Engine/lib/assimp/code/Blender/BlenderIntermediate.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Blender/BlenderLoader.cpp b/Engine/lib/assimp/code/Blender/BlenderLoader.cpp
index 93e6d1589..d39cb9699 100644
--- a/Engine/lib/assimp/code/Blender/BlenderLoader.cpp
+++ b/Engine/lib/assimp/code/Blender/BlenderLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Blender/BlenderLoader.h b/Engine/lib/assimp/code/Blender/BlenderLoader.h
index 8110ac946..d85a82842 100644
--- a/Engine/lib/assimp/code/Blender/BlenderLoader.h
+++ b/Engine/lib/assimp/code/Blender/BlenderLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Blender/BlenderModifier.cpp b/Engine/lib/assimp/code/Blender/BlenderModifier.cpp
index 6f8a5d7ee..cc7acc929 100644
--- a/Engine/lib/assimp/code/Blender/BlenderModifier.cpp
+++ b/Engine/lib/assimp/code/Blender/BlenderModifier.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Blender/BlenderModifier.h b/Engine/lib/assimp/code/Blender/BlenderModifier.h
index ad6fad68d..c260ba1f6 100644
--- a/Engine/lib/assimp/code/Blender/BlenderModifier.h
+++ b/Engine/lib/assimp/code/Blender/BlenderModifier.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Blender/BlenderScene.cpp b/Engine/lib/assimp/code/Blender/BlenderScene.cpp
index 1391a2833..39c2793d5 100644
--- a/Engine/lib/assimp/code/Blender/BlenderScene.cpp
+++ b/Engine/lib/assimp/code/Blender/BlenderScene.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (ASSIMP)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, ASSIMP Development Team
+Copyright (c) 2006-2016, ASSIMP Development Team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
diff --git a/Engine/lib/assimp/code/Blender/BlenderScene.h b/Engine/lib/assimp/code/Blender/BlenderScene.h
index afa168d49..dd3f1444c 100644
--- a/Engine/lib/assimp/code/Blender/BlenderScene.h
+++ b/Engine/lib/assimp/code/Blender/BlenderScene.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Blender/BlenderSceneGen.h b/Engine/lib/assimp/code/Blender/BlenderSceneGen.h
index 0c93d17a3..ce94d0dc2 100644
--- a/Engine/lib/assimp/code/Blender/BlenderSceneGen.h
+++ b/Engine/lib/assimp/code/Blender/BlenderSceneGen.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (ASSIMP)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, ASSIMP Development Team
+Copyright (c) 2006-2016, ASSIMP Development Team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
diff --git a/Engine/lib/assimp/code/Blender/BlenderTessellator.cpp b/Engine/lib/assimp/code/Blender/BlenderTessellator.cpp
index 3c1cd6ea8..d98c2e865 100644
--- a/Engine/lib/assimp/code/Blender/BlenderTessellator.cpp
+++ b/Engine/lib/assimp/code/Blender/BlenderTessellator.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Blender/BlenderTessellator.h b/Engine/lib/assimp/code/Blender/BlenderTessellator.h
index 63ea1f828..518e56c72 100644
--- a/Engine/lib/assimp/code/Blender/BlenderTessellator.h
+++ b/Engine/lib/assimp/code/Blender/BlenderTessellator.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/C4D/C4DImporter.cpp b/Engine/lib/assimp/code/C4D/C4DImporter.cpp
index 24fd6f622..6e5b7d39b 100644
--- a/Engine/lib/assimp/code/C4D/C4DImporter.cpp
+++ b/Engine/lib/assimp/code/C4D/C4DImporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
diff --git a/Engine/lib/assimp/code/C4D/C4DImporter.h b/Engine/lib/assimp/code/C4D/C4DImporter.h
index f9406c3e0..f3b1351f6 100644
--- a/Engine/lib/assimp/code/C4D/C4DImporter.h
+++ b/Engine/lib/assimp/code/C4D/C4DImporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
diff --git a/Engine/lib/assimp/code/CApi/AssimpCExport.cpp b/Engine/lib/assimp/code/CApi/AssimpCExport.cpp
index 137cc2894..7557edcfc 100644
--- a/Engine/lib/assimp/code/CApi/AssimpCExport.cpp
+++ b/Engine/lib/assimp/code/CApi/AssimpCExport.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/CApi/CInterfaceIOWrapper.cpp b/Engine/lib/assimp/code/CApi/CInterfaceIOWrapper.cpp
index 91dd07f37..5a3a49565 100644
--- a/Engine/lib/assimp/code/CApi/CInterfaceIOWrapper.cpp
+++ b/Engine/lib/assimp/code/CApi/CInterfaceIOWrapper.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/CApi/CInterfaceIOWrapper.h b/Engine/lib/assimp/code/CApi/CInterfaceIOWrapper.h
index 298847494..216232030 100644
--- a/Engine/lib/assimp/code/CApi/CInterfaceIOWrapper.h
+++ b/Engine/lib/assimp/code/CApi/CInterfaceIOWrapper.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/CMakeLists.txt b/Engine/lib/assimp/code/CMakeLists.txt
index 0dff5d9e4..55538d965 100644
--- a/Engine/lib/assimp/code/CMakeLists.txt
+++ b/Engine/lib/assimp/code/CMakeLists.txt
@@ -1,7 +1,7 @@
 # Open Asset Import Library (assimp)
 # ----------------------------------------------------------------------
 #
-# Copyright (c) 2006-2020, assimp team
+# Copyright (c) 2006-2019, assimp team
 #
 # All rights reserved.
 #
@@ -49,7 +49,7 @@ SET( HEADER_PATH ../include/assimp )
 if(NOT ANDROID AND ASSIMP_ANDROID_JNIIOSYSTEM)
     message(WARNING "Requesting Android JNI I/O-System in non-Android toolchain. Resetting ASSIMP_ANDROID_JNIIOSYSTEM to OFF.")
     set(ASSIMP_ANDROID_JNIIOSYSTEM OFF)
-endif()
+endif(NOT ANDROID AND ASSIMP_ANDROID_JNIIOSYSTEM)
 
 SET( COMPILER_HEADERS
   ${HEADER_PATH}/Compiler/pushpack1.h
@@ -66,7 +66,6 @@ SET( PUBLIC_HEADERS
   ${HEADER_PATH}/color4.h
   ${HEADER_PATH}/color4.inl
   ${CMAKE_CURRENT_BINARY_DIR}/../include/assimp/config.h
-  ${HEADER_PATH}/commonMetaData.h
   ${HEADER_PATH}/defs.h
   ${HEADER_PATH}/Defines.h
   ${HEADER_PATH}/cfileio.h
@@ -138,6 +137,7 @@ SET( PUBLIC_HEADERS
   ${HEADER_PATH}/irrXMLWrapper.h
   ${HEADER_PATH}/BlobIOSystem.h
   ${HEADER_PATH}/MathFunctions.h
+  ${HEADER_PATH}/Macros.h
   ${HEADER_PATH}/Exceptional.h
   ${HEADER_PATH}/ByteSwapper.h
 )
@@ -148,7 +148,7 @@ SET( Core_SRCS
 
 IF(MSVC)
   list(APPEND Core_SRCS "res/assimp.rc")
-ENDIF()
+ENDIF(MSVC)
 
 SET( Logging_SRCS
   ${HEADER_PATH}/DefaultLogger.hpp
@@ -185,6 +185,8 @@ SET( Common_SRCS
   Common/ScenePreprocessor.cpp
   Common/ScenePreprocessor.h
   Common/SkeletonMeshBuilder.cpp
+  Common/SplitByBoneCountProcess.cpp
+  Common/SplitByBoneCountProcess.h
   Common/StandardShapes.cpp
   Common/TargetAnimation.cpp
   Common/TargetAnimation.h
@@ -196,7 +198,6 @@ SET( Common_SRCS
   Common/CreateAnimMesh.cpp
   Common/simd.h
   Common/simd.cpp
-  Common/material.cpp
 )
 SOURCE_GROUP(Common FILES ${Common_SRCS})
 
@@ -220,7 +221,7 @@ IF ( ASSIMP_BUILD_NONFREE_C4D_IMPORTER )
     C4D/C4DImporter.h
   )
   SOURCE_GROUP( C4D FILES ${C4D_SRCS})
-ENDIF ()
+ENDIF ( ASSIMP_BUILD_NONFREE_C4D_IMPORTER )
 
 # if this variable is set to TRUE, the user can manually disable importers by setting
 # ASSIMP_BUILD_XXX_IMPORTER to FALSE for each importer
@@ -250,39 +251,35 @@ MACRO(ADD_ASSIMP_IMPORTER name)
   ENDIF()
 ENDMACRO()
 
-if (NOT ASSIMP_NO_EXPORT)
+# if this variable is set to TRUE, the user can manually disable exporters by setting
+# ASSIMP_BUILD_XXX_EXPORTER to FALSE for each exporter
+# if this variable is set to FALSE, the user can manually enable exporters by setting
+# ASSIMP_BUILD_XXX_EXPORTER to TRUE for each exporter
+OPTION(ASSIMP_BUILD_ALL_EXPORTERS_BY_DEFAULT "default value of all ASSIMP_BUILD_XXX_EXPORTER values" TRUE)
 
-  # if this variable is set to TRUE, the user can manually disable exporters by setting
-  # ASSIMP_BUILD_XXX_EXPORTER to FALSE for each exporter
-  # if this variable is set to FALSE, the user can manually enable exporters by setting
-  # ASSIMP_BUILD_XXX_EXPORTER to TRUE for each exporter
-  OPTION(ASSIMP_BUILD_ALL_EXPORTERS_BY_DEFAULT "default value of all ASSIMP_BUILD_XXX_EXPORTER values" TRUE)
-
-  # macro to add the CMake Option ADD_ASSIMP_IMPORTER_<name> which enables compile of loader
-  # this way selective loaders can be compiled (reduces filesize + compile time)
-  MACRO(ADD_ASSIMP_EXPORTER name)
-    IF (ASSIMP_NO_EXPORT)
+# macro to add the CMake Option ADD_ASSIMP_IMPORTER_<name> which enables compile of loader
+# this way selective loaders can be compiled (reduces filesize + compile time)
+MACRO(ADD_ASSIMP_EXPORTER name)
+  IF (ASSIMP_NO_EXPORT)
+	set(ASSIMP_EXPORTER_ENABLED FALSE)
+  ELSEIF (ASSIMP_BUILD_ALL_EXPORTERS_BY_DEFAULT)
+    set(ASSIMP_EXPORTER_ENABLED TRUE)
+    IF (DEFINED ASSIMP_BUILD_${name}_EXPORTER AND NOT ASSIMP_BUILD_${name}_EXPORTER)
       set(ASSIMP_EXPORTER_ENABLED FALSE)
-    ELSEIF (ASSIMP_BUILD_ALL_EXPORTERS_BY_DEFAULT)
-      set(ASSIMP_EXPORTER_ENABLED TRUE)
-      IF (DEFINED ASSIMP_BUILD_${name}_EXPORTER AND NOT ASSIMP_BUILD_${name}_EXPORTER)
-        set(ASSIMP_EXPORTER_ENABLED FALSE)
-      ENDIF ()
-    ELSE ()
-      set(ASSIMP_EXPORTER_ENABLED ${ASSIMP_BUILD_${name}_EXPORTER})
     ENDIF ()
+  ELSE ()
+    set(ASSIMP_EXPORTER_ENABLED ${ASSIMP_BUILD_${name}_EXPORTER})
+  ENDIF ()
 
-    IF (ASSIMP_EXPORTER_ENABLED)
-      SET(ASSIMP_EXPORTERS_ENABLED "${ASSIMP_EXPORTERS_ENABLED} ${name}")
-      LIST(APPEND ASSIMP_EXPORTER_SRCS ${ARGN})
-      SOURCE_GROUP(${name}_EXPORTER FILES ${ARGN})
-    ELSE()
-      SET(ASSIMP_EXPORTERS_DISABLED "${ASSIMP_EXPORTERS_DISABLED} ${name}")
-      add_definitions(-DASSIMP_BUILD_NO_${name}_EXPORTER)
-    ENDIF()
-  ENDMACRO()
-
-endif()
+  IF (ASSIMP_EXPORTER_ENABLED)
+    SET(ASSIMP_EXPORTERS_ENABLED "${ASSIMP_EXPORTERS_ENABLED} ${name}")
+	LIST(APPEND ASSIMP_EXPORTER_SRCS ${ARGN})
+    SOURCE_GROUP(${name}_EXPORTER FILES ${ARGN})
+  ELSE()
+    SET(ASSIMP_EXPORTERS_DISABLED "${ASSIMP_EXPORTERS_DISABLED} ${name}")
+    add_definitions(-DASSIMP_BUILD_NO_${name}_EXPORTER)
+  ENDIF()
+ENDMACRO()
 
 SET(ASSIMP_LOADER_SRCS "")
 SET(ASSIMP_IMPORTERS_ENABLED "") # list of enabled importers
@@ -309,6 +306,11 @@ ADD_ASSIMP_IMPORTER( 3DS
   3DS/3DSLoader.h
 )
 
+ADD_ASSIMP_EXPORTER( 3DS
+  3DS/3DSExporter.h
+  3DS/3DSExporter.cpp
+)
+
 ADD_ASSIMP_IMPORTER( AC
   AC/ACLoader.cpp
   AC/ACLoader.h
@@ -326,6 +328,16 @@ ADD_ASSIMP_IMPORTER( ASSBIN
   Assbin/AssbinLoader.cpp
 )
 
+ADD_ASSIMP_EXPORTER( ASSBIN
+  Assbin/AssbinExporter.h
+  Assbin/AssbinExporter.cpp
+)
+
+ADD_ASSIMP_EXPORTER( ASSXML
+  Assxml/AssxmlExporter.h
+  Assxml/AssxmlExporter.cpp
+)
+
 ADD_ASSIMP_IMPORTER( B3D
   B3D/B3DImporter.cpp
   B3D/B3DImporter.h
@@ -337,7 +349,6 @@ ADD_ASSIMP_IMPORTER( BVH
 )
 
 ADD_ASSIMP_IMPORTER( COLLADA
-  Collada/ColladaHelper.cpp
   Collada/ColladaHelper.h
   Collada/ColladaLoader.cpp
   Collada/ColladaLoader.h
@@ -345,6 +356,11 @@ ADD_ASSIMP_IMPORTER( COLLADA
   Collada/ColladaParser.h
 )
 
+ADD_ASSIMP_EXPORTER( COLLADA
+  Collada/ColladaExporter.h
+  Collada/ColladaExporter.cpp
+)
+
 ADD_ASSIMP_IMPORTER( DXF
   DXF/DXFLoader.cpp
   DXF/DXFLoader.h
@@ -392,15 +408,6 @@ ADD_ASSIMP_IMPORTER( LWS
   LWS/LWSLoader.h
 )
 
-ADD_ASSIMP_IMPORTER( M3D
-  M3D/M3DMaterials.h
-  M3D/M3DImporter.h
-  M3D/M3DImporter.cpp
-  M3D/M3DWrapper.h
-  M3D/M3DWrapper.cpp
-  M3D/m3d.h
-)
-
 ADD_ASSIMP_IMPORTER( MD2
   MD2/MD2FileData.h
   MD2/MD2Loader.cpp
@@ -434,16 +441,6 @@ ADD_ASSIMP_IMPORTER( MDL
   MDL/MDLLoader.cpp
   MDL/MDLLoader.h
   MDL/MDLMaterialLoader.cpp
-  MDL/HalfLife/HalfLifeMDLBaseHeader.h
-  MDL/HalfLife/HL1FileData.h
-  MDL/HalfLife/HL1MDLLoader.cpp
-  MDL/HalfLife/HL1MDLLoader.h
-  MDL/HalfLife/HL1ImportDefinitions.h
-  MDL/HalfLife/HL1ImportSettings.h
-  MDL/HalfLife/HL1MeshTrivert.h
-  MDL/HalfLife/LogFunctions.h
-  MDL/HalfLife/UniqueNameGenerator.cpp
-  MDL/HalfLife/UniqueNameGenerator.h
 )
 
 SET( MaterialSystem_SRCS
@@ -478,6 +475,11 @@ ADD_ASSIMP_IMPORTER( OBJ
   Obj/ObjTools.h
 )
 
+ADD_ASSIMP_EXPORTER( OBJ
+  Obj/ObjExporter.h
+  Obj/ObjExporter.cpp
+)
+
 ADD_ASSIMP_IMPORTER( OGRE
   Ogre/OgreImporter.h
   Ogre/OgreStructs.h
@@ -497,6 +499,11 @@ ADD_ASSIMP_IMPORTER( OPENGEX
   OpenGEX/OpenGEXStructs.h
 )
 
+ADD_ASSIMP_EXPORTER( OPENGEX
+  OpenGEX/OpenGEXExporter.cpp
+  OpenGEX/OpenGEXExporter.h
+)
+
 ADD_ASSIMP_IMPORTER( PLY
   Ply/PlyLoader.cpp
   Ply/PlyLoader.h
@@ -504,6 +511,11 @@ ADD_ASSIMP_IMPORTER( PLY
   Ply/PlyParser.h
 )
 
+ADD_ASSIMP_EXPORTER( PLY
+  Ply/PlyExporter.cpp
+  Ply/PlyExporter.h
+)
+
 ADD_ASSIMP_IMPORTER( MS3D
   MS3D/MS3DLoader.cpp
   MS3D/MS3DLoader.h
@@ -557,7 +569,7 @@ if (ASSIMP_BUILD_IFC_IMPORTER)
   elseif(CMAKE_COMPILER_IS_MINGW)
     set_source_files_properties(Importer/IFC/IFCReaderGen1_2x3.cpp Importer/IFC/IFCReaderGen2_2x3.cpp PROPERTIES COMPILE_FLAGS "-O2 -Wa,-mbig-obj")
   endif()
-endif ()
+endif (ASSIMP_BUILD_IFC_IMPORTER)
 
 ADD_ASSIMP_IMPORTER( XGL
   XGL/XGLLoader.cpp
@@ -593,86 +605,14 @@ ADD_ASSIMP_IMPORTER( FBX
   FBX/FBXCommon.h
 )
 
-if (NOT ASSIMP_NO_EXPORT)
-
-  ADD_ASSIMP_EXPORTER( OBJ
-    Obj/ObjExporter.h
-    Obj/ObjExporter.cpp)
-
-  ADD_ASSIMP_EXPORTER( OPENGEX
-    OpenGEX/OpenGEXExporter.cpp
-    OpenGEX/OpenGEXExporter.h)
-
-  ADD_ASSIMP_EXPORTER( PLY
-    Ply/PlyExporter.cpp
-    Ply/PlyExporter.h)
-
-  ADD_ASSIMP_EXPORTER( 3DS
-    3DS/3DSExporter.h
-    3DS/3DSExporter.cpp)
-
-  ADD_ASSIMP_EXPORTER( ASSBIN
-    Assbin/AssbinExporter.h
-    Assbin/AssbinExporter.cpp
-    Assbin/AssbinFileWriter.h
-    Assbin/AssbinFileWriter.cpp)
-
-  ADD_ASSIMP_EXPORTER( ASSXML
-    Assxml/AssxmlExporter.h
-    Assxml/AssxmlExporter.cpp
-    Assxml/AssxmlFileWriter.h
-    Assxml/AssxmlFileWriter.cpp)
-
-  ADD_ASSIMP_EXPORTER(M3D
-    M3D/M3DExporter.h
-    M3D/M3DExporter.cpp)
-
-  ADD_ASSIMP_EXPORTER(COLLADA
-    Collada/ColladaExporter.h
-    Collada/ColladaExporter.cpp)
-
-  ADD_ASSIMP_EXPORTER( FBX
-    FBX/FBXExporter.h
-    FBX/FBXExporter.cpp
-    FBX/FBXExportNode.h
-    FBX/FBXExportNode.cpp
-    FBX/FBXExportProperty.h
-    FBX/FBXExportProperty.cpp)
-
-  ADD_ASSIMP_EXPORTER( STL
-    STL/STLExporter.h
-    STL/STLExporter.cpp)
-
-  ADD_ASSIMP_EXPORTER( X
-    X/XFileExporter.h
-    X/XFileExporter.cpp)
-
-  ADD_ASSIMP_EXPORTER( X3D
-    X3D/X3DExporter.cpp
-    X3D/X3DExporter.hpp)
-
-  ADD_ASSIMP_EXPORTER( GLTF
-    glTF/glTFExporter.h
-    glTF/glTFExporter.cpp
-    glTF2/glTF2Exporter.h
-    glTF2/glTF2Exporter.cpp)
-
-  ADD_ASSIMP_EXPORTER( 3MF
-    3MF/D3MFExporter.h
-    3MF/D3MFExporter.cpp)
-
-  ADD_ASSIMP_EXPORTER( ASSJSON
-    Assjson/cencode.c
-    Assjson/cencode.h
-    Assjson/json_exporter.cpp
-    Assjson/mesh_splitter.cpp
-    Assjson/mesh_splitter.h)
-
-  ADD_ASSIMP_EXPORTER( STEP
-    Step/StepExporter.h
-    Step/StepExporter.cpp)
-
-endif()
+ADD_ASSIMP_EXPORTER( FBX
+  FBX/FBXExporter.h
+  FBX/FBXExporter.cpp
+  FBX/FBXExportNode.h
+  FBX/FBXExportNode.cpp
+  FBX/FBXExportProperty.h
+  FBX/FBXExportProperty.cpp
+)
 
 SET( PostProcessing_SRCS
   PostProcessing/CalcTangentsProcess.cpp
@@ -731,12 +671,8 @@ SET( PostProcessing_SRCS
   PostProcessing/MakeVerboseFormat.h
   PostProcessing/ScaleProcess.cpp
   PostProcessing/ScaleProcess.h
-  PostProcessing/ArmaturePopulate.cpp
-  PostProcessing/ArmaturePopulate.h
   PostProcessing/GenBoundingBoxesProcess.cpp
   PostProcessing/GenBoundingBoxesProcess.h
-  PostProcessing/SplitByBoneCountProcess.cpp
-  PostProcessing/SplitByBoneCountProcess.h
 )
 SOURCE_GROUP( PostProcessing FILES ${PostProcessing_SRCS})
 
@@ -776,6 +712,11 @@ ADD_ASSIMP_IMPORTER( STL
   STL/STLLoader.h
 )
 
+ADD_ASSIMP_EXPORTER( STL
+  STL/STLExporter.h
+  STL/STLExporter.cpp
+)
+
 ADD_ASSIMP_IMPORTER( TERRAGEN
   Terragen/TerragenLoader.cpp
   Terragen/TerragenLoader.h
@@ -794,6 +735,11 @@ ADD_ASSIMP_IMPORTER( X
   X/XFileParser.h
 )
 
+ADD_ASSIMP_EXPORTER( X
+  X/XFileExporter.h
+  X/XFileExporter.cpp
+)
+
 ADD_ASSIMP_IMPORTER( X3D
   X3D/X3DImporter.cpp
   X3D/X3DImporter.hpp
@@ -814,6 +760,11 @@ ADD_ASSIMP_IMPORTER( X3D
   X3D/X3DVocabulary.cpp
 )
 
+ADD_ASSIMP_EXPORTER( X3D
+  X3D/X3DExporter.cpp
+  X3D/X3DExporter.hpp
+)
+
 ADD_ASSIMP_IMPORTER( GLTF
   glTF/glTFCommon.h
   glTF/glTFCommon.cpp
@@ -831,6 +782,13 @@ ADD_ASSIMP_IMPORTER( GLTF
   glTF2/glTF2Importer.h
 )
 
+ADD_ASSIMP_EXPORTER( GLTF
+  glTF/glTFExporter.h
+  glTF/glTFExporter.cpp
+  glTF2/glTF2Exporter.h
+  glTF2/glTF2Exporter.cpp
+)
+
 ADD_ASSIMP_IMPORTER( 3MF
   3MF/D3MFImporter.h
   3MF/D3MFImporter.cpp
@@ -839,6 +797,11 @@ ADD_ASSIMP_IMPORTER( 3MF
   3MF/3MFXmlTags.h
 )
 
+ADD_ASSIMP_EXPORTER( 3MF
+  3MF/D3MFExporter.h
+  3MF/D3MFExporter.cpp
+)
+
 ADD_ASSIMP_IMPORTER( MMD
   MMD/MMDCpp14.h
   MMD/MMDImporter.cpp
@@ -849,6 +812,14 @@ ADD_ASSIMP_IMPORTER( MMD
   MMD/MMDVmdParser.h
 )
 
+ADD_ASSIMP_EXPORTER( ASSJSON
+  Assjson/cencode.c
+  Assjson/cencode.h
+  Assjson/json_exporter.cpp
+  Assjson/mesh_splitter.cpp
+  Assjson/mesh_splitter.h
+)
+
 # Workaround for issue #2406 - force problematic large file to be optimized to prevent string table overflow error
 # Used -Os instead of -O2 as previous issues had mentioned, since -Os is roughly speaking -O2, excluding any
 # optimizations that take up extra space. Given that the issue is a string table overflowing, -Os seemed appropriate
@@ -871,6 +842,11 @@ ADD_ASSIMP_IMPORTER( STEP
     Importer/StepFile/StepReaderGen.h
 )
 
+ADD_ASSIMP_EXPORTER( STEP
+    Step/StepExporter.h
+    Step/StepExporter.cpp
+)
+
 if ((NOT ASSIMP_NO_EXPORT) OR (NOT ASSIMP_EXPORTERS_ENABLED STREQUAL ""))
 	SET( Exporter_SRCS
 	  Common/Exporter.cpp
@@ -889,35 +865,35 @@ SOURCE_GROUP( Extra FILES ${Extra_SRCS})
 IF(HUNTER_ENABLED)
   hunter_add_package(irrXML)
   find_package(irrXML CONFIG REQUIRED)
-ELSE()
+ELSE(HUNTER_ENABLED)
   # irrXML already included in contrib directory by parent CMakeLists.txt.
-ENDIF()
+ENDIF(HUNTER_ENABLED)
 
 # utf8
 IF(HUNTER_ENABLED)
   hunter_add_package(utf8)
   find_package(utf8 CONFIG REQUIRED)
-ELSE()
+ELSE(HUNTER_ENABLED)
   # utf8 is header-only, so Assimp doesn't need to do anything.
-ENDIF()
+ENDIF(HUNTER_ENABLED)
 
 # polyclipping
 IF(HUNTER_ENABLED)
   hunter_add_package(polyclipping)
   find_package(polyclipping CONFIG REQUIRED)
-ELSE()
+ELSE(HUNTER_ENABLED)
   SET( Clipper_SRCS
     ../contrib/clipper/clipper.hpp
     ../contrib/clipper/clipper.cpp
   )
   SOURCE_GROUP( Contrib\\Clipper FILES ${Clipper_SRCS})
-ENDIF()
+ENDIF(HUNTER_ENABLED)
 
 # poly2tri
 IF(HUNTER_ENABLED)
   hunter_add_package(poly2tri)
   find_package(poly2tri CONFIG REQUIRED)
-ELSE()
+ELSE(HUNTER_ENABLED)
   SET( Poly2Tri_SRCS
     ../contrib/poly2tri/poly2tri/common/shapes.cc
     ../contrib/poly2tri/poly2tri/common/shapes.h
@@ -932,13 +908,13 @@ ELSE()
     ../contrib/poly2tri/poly2tri/sweep/sweep_context.h
   )
   SOURCE_GROUP( Contrib\\Poly2Tri FILES ${Poly2Tri_SRCS})
-ENDIF()
+ENDIF(HUNTER_ENABLED)
 
 # minizip/unzip
 IF(HUNTER_ENABLED)
   hunter_add_package(minizip)
   find_package(minizip CONFIG REQUIRED)
-ELSE()
+ELSE(HUNTER_ENABLED)
   SET( unzip_SRCS
     ../contrib/unzip/crypt.h
     ../contrib/unzip/ioapi.c
@@ -947,13 +923,13 @@ ELSE()
     ../contrib/unzip/unzip.h
   )
   SOURCE_GROUP(Contrib\\unzip FILES ${unzip_SRCS})
-ENDIF()
+ENDIF(HUNTER_ENABLED)
 
 # zip (https://github.com/kuba--/zip)
 IF(HUNTER_ENABLED)
   hunter_add_package(zip)
   find_package(zip CONFIG REQUIRED)
-ELSE()
+ELSE(HUNTER_ENABLED)
   SET( ziplib_SRCS
     ../contrib/zip/src/miniz.h
     ../contrib/zip/src/zip.c
@@ -968,13 +944,13 @@ ELSE()
   endif()
 
   SOURCE_GROUP( ziplib FILES ${ziplib_SRCS} )
-ENDIF()
+ENDIF(HUNTER_ENABLED)
 
 # openddlparser
 IF(HUNTER_ENABLED)
   hunter_add_package(openddlparser)
   find_package(openddlparser CONFIG REQUIRED)
-ELSE()
+ELSE(HUNTER_ENABLED)
   SET ( openddl_parser_SRCS
     ../contrib/openddlparser/code/OpenDDLParser.cpp
     ../contrib/openddlparser/code/DDLNode.cpp
@@ -991,12 +967,12 @@ ELSE()
     ../contrib/openddlparser/include/openddlparser/Value.h
   )
   SOURCE_GROUP( Contrib\\openddl_parser FILES ${openddl_parser_SRCS})
-ENDIF()
+ENDIF(HUNTER_ENABLED)
 
 # Open3DGC
 IF(HUNTER_ENABLED)
   # Nothing to do, not available in Hunter yet.
-ELSE()
+ELSE(HUNTER_ENABLED)
   SET ( open3dgc_SRCS
     ../contrib/Open3DGC/o3dgcAdjacencyInfo.h
     ../contrib/Open3DGC/o3dgcArithmeticCodec.cpp
@@ -1029,7 +1005,7 @@ ELSE()
     ../contrib/Open3DGC/o3dgcVector.inl
   )
   SOURCE_GROUP( Contrib\\open3dgc FILES ${open3dgc_SRCS})
-ENDIF()
+ENDIF(HUNTER_ENABLED)
 
 # Check dependencies for glTF importer with Open3DGC-compression.
 # RT-extensions is used in "contrib/Open3DGC/o3dgcTimer.h" for collecting statistics. Pointed file
@@ -1048,44 +1024,40 @@ ENDIF ()
 IF(HUNTER_ENABLED)
   hunter_add_package(RapidJSON)
   find_package(RapidJSON CONFIG REQUIRED)
-ELSE()
+ELSE(HUNTER_ENABLED)
   INCLUDE_DIRECTORIES( "../contrib/rapidjson/include" )
   INCLUDE_DIRECTORIES( "../contrib" )
-ENDIF()
+ENDIF(HUNTER_ENABLED)
 
 # VC2010 fixes
 if(MSVC10)
   option( VC10_STDINT_FIX "Fix for VC10 Compiler regarding pstdint.h redefinition errors" OFF )
   if( VC10_STDINT_FIX )
     ADD_DEFINITIONS( -D_STDINT )
-  endif()
-endif()
+  endif( VC10_STDINT_FIX )
+endif(MSVC10)
 
 ADD_DEFINITIONS( -DASSIMP_BUILD_DLL_EXPORT )
 
 if ( MSVC )
   ADD_DEFINITIONS( -D_SCL_SECURE_NO_WARNINGS )
   ADD_DEFINITIONS( -D_CRT_SECURE_NO_WARNINGS )
-endif ()
+endif ( MSVC )
 
 IF(NOT HUNTER_ENABLED)
   if (UNZIP_FOUND)
     SET (unzip_compile_SRCS "")
-  else ()
+  else (UNZIP_FOUND)
     SET (unzip_compile_SRCS ${unzip_SRCS})
     INCLUDE_DIRECTORIES( "../contrib/unzip/" )
-  endif ()
-ENDIF()
+  endif (UNZIP_FOUND)
+ENDIF(NOT HUNTER_ENABLED)
 
 MESSAGE(STATUS "Enabled importer formats:${ASSIMP_IMPORTERS_ENABLED}")
 MESSAGE(STATUS "Disabled importer formats:${ASSIMP_IMPORTERS_DISABLED}")
 
-if (NOT ASSIMP_NO_EXPORT)
-  MESSAGE(STATUS "Enabled exporter formats:${ASSIMP_EXPORTERS_ENABLED}")
-  MESSAGE(STATUS "Disabled exporter formats:${ASSIMP_EXPORTERS_DISABLED}")
-endif()
-
-SOURCE_GROUP( include\\assimp    FILES ${PUBLIC_HEADERS} )
+MESSAGE(STATUS "Enabled exporter formats:${ASSIMP_EXPORTERS_ENABLED}")
+MESSAGE(STATUS "Disabled exporter formats:${ASSIMP_EXPORTERS_DISABLED}")
 
 SET( assimp_src
   # Assimp Files
@@ -1123,12 +1095,12 @@ IF(NOT HUNTER_ENABLED)
       ${IRRXML_INCLUDE_DIR}
       ../contrib/openddlparser/include
   )
-ENDIF()
+ENDIF(NOT HUNTER_ENABLED)
 
 IF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
   SET( assimp_src ${assimp_src} ${C4D_SRCS})
   INCLUDE_DIRECTORIES(${C4D_INCLUDES})
-ENDIF ()
+ENDIF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
 
 ADD_LIBRARY( assimp ${assimp_src} )
 ADD_LIBRARY(assimp::assimp ALIAS assimp)
@@ -1152,21 +1124,21 @@ IF(HUNTER_ENABLED)
       utf8::utf8
       zip::zip
   )
-ELSE()
+ELSE(HUNTER_ENABLED)
   TARGET_LINK_LIBRARIES(assimp ${ZLIB_LIBRARIES} ${OPENDDL_PARSER_LIBRARIES} ${IRRXML_LIBRARY} )
-ENDIF()
+ENDIF(HUNTER_ENABLED)
 
 if(ASSIMP_ANDROID_JNIIOSYSTEM)
   set(ASSIMP_ANDROID_JNIIOSYSTEM_PATH port/AndroidJNI)
   add_subdirectory(../${ASSIMP_ANDROID_JNIIOSYSTEM_PATH}/ ../${ASSIMP_ANDROID_JNIIOSYSTEM_PATH}/)
   target_link_libraries(assimp android_jniiosystem)
-endif()
+endif(ASSIMP_ANDROID_JNIIOSYSTEM)
 
 IF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
   TARGET_LINK_LIBRARIES(assimp optimized ${C4D_RELEASE_LIBRARIES})
   TARGET_LINK_LIBRARIES(assimp debug ${C4D_DEBUG_LIBRARIES})
   TARGET_LINK_LIBRARIES(assimp ${C4D_EXTRA_LIBRARIES})
-ENDIF ()
+ENDIF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
 
 if( MSVC )
   # in order to prevent DLL hell, each of the DLLs have to be suffixed with the major version and msvc prefix
@@ -1212,6 +1184,10 @@ SET_TARGET_PROPERTIES( assimp PROPERTIES
 )
 
 if (APPLE)
+  SET_TARGET_PROPERTIES( assimp PROPERTIES
+    INSTALL_NAME_DIR "${CMAKE_INSTALL_PREFIX}/${ASSIMP_LIB_INSTALL_DIR}"
+  )
+
   if (BUILD_FRAMEWORK)
     SET_TARGET_PROPERTIES( assimp PROPERTIES
       FRAMEWORK TRUE
@@ -1227,8 +1203,8 @@ if (APPLE)
          "../${HEADER_PATH}/Compiler"
          assimp.framework/Headers/Compiler
       COMMENT "Copying public ./Compiler/ header files to framework bundle's Headers/Compiler/")
-  ENDIF()
-ENDIF()
+  ENDIF(BUILD_FRAMEWORK)
+ENDIF(APPLE)
 
 # Build against external unzip, or add ../contrib/unzip so
 # assimp can #include "unzip.h"
@@ -1236,15 +1212,15 @@ IF(NOT HUNTER_ENABLED)
   if (UNZIP_FOUND)
     INCLUDE_DIRECTORIES(${UNZIP_INCLUDE_DIRS})
     TARGET_LINK_LIBRARIES(assimp ${UNZIP_LIBRARIES})
-  else ()
+  else (UNZIP_FOUND)
     INCLUDE_DIRECTORIES("../")
-  endif ()
-ENDIF()
+  endif (UNZIP_FOUND)
+ENDIF(NOT HUNTER_ENABLED)
 
 # Add RT-extension library for glTF importer with Open3DGC-compression.
 IF (RT_FOUND AND ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC)
   TARGET_LINK_LIBRARIES(assimp ${RT_LIBRARY})
-ENDIF ()
+ENDIF (RT_FOUND AND ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC)
 
 IF(HUNTER_ENABLED)
   INSTALL( TARGETS assimp
@@ -1255,14 +1231,14 @@ IF(HUNTER_ENABLED)
     FRAMEWORK DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
     COMPONENT ${LIBASSIMP_COMPONENT}
     INCLUDES DESTINATION "include")
-ELSE()
+ELSE(HUNTER_ENABLED)
 INSTALL( TARGETS assimp
     LIBRARY DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
     ARCHIVE DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
     RUNTIME DESTINATION ${ASSIMP_BIN_INSTALL_DIR}
     FRAMEWORK DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
     COMPONENT ${LIBASSIMP_COMPONENT})
-ENDIF()
+ENDIF(HUNTER_ENABLED)
 INSTALL( FILES ${PUBLIC_HEADERS} DESTINATION ${ASSIMP_INCLUDE_INSTALL_DIR}/assimp COMPONENT assimp-dev)
 INSTALL( FILES ${COMPILER_HEADERS} DESTINATION ${ASSIMP_INCLUDE_INSTALL_DIR}/assimp/Compiler COMPONENT assimp-dev)
 
@@ -1270,7 +1246,7 @@ if (ASSIMP_ANDROID_JNIIOSYSTEM)
   INSTALL(FILES ${HEADER_PATH}/${ASSIMP_ANDROID_JNIIOSYSTEM_PATH}/AndroidJNIIOSystem.h
     DESTINATION ${ASSIMP_INCLUDE_INSTALL_DIR}
     COMPONENT assimp-dev)
-ENDIF()
+ENDIF(ASSIMP_ANDROID_JNIIOSYSTEM)
 
 if(MSVC AND ASSIMP_INSTALL_PDB)
   # When only the static library is built, these properties must
diff --git a/Engine/lib/assimp/code/COB/COBLoader.cpp b/Engine/lib/assimp/code/COB/COBLoader.cpp
index 8e7c81192..19e3cd59e 100644
--- a/Engine/lib/assimp/code/COB/COBLoader.cpp
+++ b/Engine/lib/assimp/code/COB/COBLoader.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
@@ -250,7 +250,7 @@ aiNode* COBImporter::BuildNodes(const Node& root,const Scene& scin,aiScene* fill
         const Mesh& ndmesh = (const Mesh&)(root);
         if (ndmesh.vertex_positions.size() && ndmesh.texture_coords.size()) {
 
-            typedef std::pair<const unsigned int,Mesh::FaceRefList> Entry;
+            typedef std::pair<unsigned int,Mesh::FaceRefList> Entry;
             for(const Entry& reflist : ndmesh.temp_map) {
                 {   // create mesh
                     size_t n = 0;
diff --git a/Engine/lib/assimp/code/COB/COBLoader.h b/Engine/lib/assimp/code/COB/COBLoader.h
index 8b3110a32..40fed324b 100644
--- a/Engine/lib/assimp/code/COB/COBLoader.h
+++ b/Engine/lib/assimp/code/COB/COBLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/COB/COBScene.h b/Engine/lib/assimp/code/COB/COBScene.h
index 87f4f4570..90349be70 100644
--- a/Engine/lib/assimp/code/COB/COBScene.h
+++ b/Engine/lib/assimp/code/COB/COBScene.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/CSM/CSMLoader.cpp b/Engine/lib/assimp/code/CSM/CSMLoader.cpp
index fbabea12e..9dbb38467 100644
--- a/Engine/lib/assimp/code/CSM/CSMLoader.cpp
+++ b/Engine/lib/assimp/code/CSM/CSMLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -178,7 +178,7 @@ void CSMImporter::InternReadFile( const std::string& pFile,
                         *ot++ = *buffer++;
 
                     *ot = '\0';
-                    nda->mNodeName.length = (ai_uint32)(ot-nda->mNodeName.data);
+                    nda->mNodeName.length = (size_t)(ot-nda->mNodeName.data);
                 }
 
                 anim->mNumChannels = static_cast<unsigned int>(anims_temp.size());
diff --git a/Engine/lib/assimp/code/CSM/CSMLoader.h b/Engine/lib/assimp/code/CSM/CSMLoader.h
index 907c7aa43..31a814b52 100644
--- a/Engine/lib/assimp/code/CSM/CSMLoader.h
+++ b/Engine/lib/assimp/code/CSM/CSMLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Collada/ColladaExporter.cpp b/Engine/lib/assimp/code/Collada/ColladaExporter.cpp
index 99cdc097b..6fd31ed3b 100644
--- a/Engine/lib/assimp/code/Collada/ColladaExporter.cpp
+++ b/Engine/lib/assimp/code/Collada/ColladaExporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -45,7 +45,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "ColladaExporter.h"
 #include <assimp/Bitmap.h>
-#include <assimp/commonMetaData.h>
 #include <assimp/MathFunctions.h>
 #include <assimp/fast_atof.h>
 #include <assimp/SceneCombiner.h>
@@ -93,36 +92,6 @@ void ExportSceneCollada(const char* pFile, IOSystem* pIOSystem, const aiScene* p
 
 } // end of namespace Assimp
 
-// ------------------------------------------------------------------------------------------------
-// Encodes a string into a valid XML ID using the xsd:ID schema qualifications.
-static const std::string XMLIDEncode(const std::string& name) {
-    const char XML_ID_CHARS[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_-.";
-    const unsigned int XML_ID_CHARS_COUNT = sizeof(XML_ID_CHARS) / sizeof(char);
-
-    if (name.length() == 0) {
-        return name;
-    }
-
-    std::stringstream idEncoded;
-
-    // xsd:ID must start with letter or underscore
-    if (!((name[0] >= 'A' && name[0] <= 'z') || name[0] == '_')) {
-        idEncoded << '_';
-    }
-
-    for (std::string::const_iterator it = name.begin(); it != name.end(); ++it) {
-        // xsd:ID can only contain letters, digits, underscores, hyphens and periods
-        if (strchr(XML_ID_CHARS, *it) != nullptr) {
-            idEncoded << *it;
-        } else {
-            // Select placeholder character based on invalid character to prevent name collisions 
-            idEncoded << XML_ID_CHARS[(*it) % XML_ID_CHARS_COUNT];
-        }
-    }
-
-    return idEncoded.str();
-}
-
 // ------------------------------------------------------------------------------------------------
 // Constructor for a specific scene to export
 ColladaExporter::ColladaExporter( const aiScene* pScene, IOSystem* pIOSystem, const std::string& path, const std::string& file) 
@@ -177,7 +146,7 @@ void ColladaExporter::WriteFile() {
     // useless Collada fu at the end, just in case we haven't had enough indirections, yet.
     mOutput << startstr << "<scene>" << endstr;
     PushTag();
-    mOutput << startstr << "<instance_visual_scene url=\"#" + XMLIDEncode(mScene->mRootNode->mName.C_Str()) + "\" />" << endstr;
+    mOutput << startstr << "<instance_visual_scene url=\"#" + XMLEscape(mScene->mRootNode->mName.C_Str()) + "\" />" << endstr;
     PopTag();
     mOutput << startstr << "</scene>" << endstr;
     PopTag();
@@ -278,7 +247,7 @@ void ColladaExporter::WriteHeader() {
         mOutput << startstr << "<author>" << XMLEscape(value.C_Str()) << "</author>" << endstr;
     }
 
-    if (nullptr == meta || !meta->Get(AI_METADATA_SOURCE_GENERATOR, value)) {
+    if (nullptr == meta || !meta->Get("AuthoringTool", value)) {
         mOutput << startstr << "<authoring_tool>" << "Assimp Exporter" << "</authoring_tool>" << endstr;
     } else {
         mOutput << startstr << "<authoring_tool>" << XMLEscape(value.C_Str()) << "</authoring_tool>" << endstr;
@@ -288,7 +257,7 @@ void ColladaExporter::WriteHeader() {
         if (meta->Get("Comments", value)) {
             mOutput << startstr << "<comments>" << XMLEscape(value.C_Str()) << "</comments>" << endstr;
         }
-        if (meta->Get(AI_METADATA_SOURCE_COPYRIGHT, value)) {
+        if (meta->Get("Copyright", value)) {
             mOutput << startstr << "<copyright>" << XMLEscape(value.C_Str()) << "</copyright>" << endstr;
         }
         if (meta->Get("SourceData", value)) {
@@ -387,10 +356,9 @@ void ColladaExporter::WriteCamerasLibrary() {
 void ColladaExporter::WriteCamera(size_t pIndex){
 
     const aiCamera *cam = mScene->mCameras[pIndex];
-    const std::string cameraName = XMLEscape(cam->mName.C_Str());
-    const std::string cameraId = XMLIDEncode(cam->mName.C_Str());
+    const std::string idstrEscaped = XMLEscape(cam->mName.C_Str());
 
-    mOutput << startstr << "<camera id=\"" << cameraId << "-camera\" name=\"" << cameraName << "\" >" << endstr;
+    mOutput << startstr << "<camera id=\"" << idstrEscaped << "-camera\" name=\"" << idstrEscaped << "_name\" >" << endstr;
     PushTag();
     mOutput << startstr << "<optics>" << endstr;
     PushTag();
@@ -444,11 +412,10 @@ void ColladaExporter::WriteLightsLibrary() {
 void ColladaExporter::WriteLight(size_t pIndex){
 
     const aiLight *light = mScene->mLights[pIndex];
-    const std::string lightName = XMLEscape(light->mName.C_Str());
-    const std::string lightId = XMLIDEncode(light->mName.C_Str());
+    const std::string idstrEscaped = XMLEscape(light->mName.C_Str());
 
-    mOutput << startstr << "<light id=\"" << lightId << "-light\" name=\""
-            << lightName << "\" >" << endstr;
+    mOutput << startstr << "<light id=\"" << idstrEscaped << "-light\" name=\""
+            << idstrEscaped << "_name\" >" << endstr;
     PushTag();
     mOutput << startstr << "<technique_common>" << endstr;
     PushTag();
@@ -619,7 +586,7 @@ static bool isalnum_C(char c) {
 void ColladaExporter::WriteImageEntry( const Surface& pSurface, const std::string& pNameAdd) {
   if( !pSurface.texture.empty() )
   {
-    mOutput << startstr << "<image id=\"" << XMLIDEncode(pNameAdd) << "\">" << endstr;
+    mOutput << startstr << "<image id=\"" << XMLEscape(pNameAdd) << "\">" << endstr;
     PushTag();
     mOutput << startstr << "<init_from>";
 
@@ -652,7 +619,7 @@ void ColladaExporter::WriteTextureColorEntry( const Surface& pSurface, const std
     }
     else
     {
-      mOutput << startstr << "<texture texture=\"" << XMLIDEncode(pImageName) << "\" texcoord=\"CHANNEL" << pSurface.channel << "\" />" << endstr;
+      mOutput << startstr << "<texture texture=\"" << XMLEscape(pImageName) << "\" texcoord=\"CHANNEL" << pSurface.channel << "\" />" << endstr;
     }
     PopTag();
     mOutput << startstr << "</" << pTypeName << ">" << endstr;
@@ -666,21 +633,21 @@ void ColladaExporter::WriteTextureParamEntry( const Surface& pSurface, const std
   // if surface is a texture, write out the sampler and the surface parameters necessary to reference the texture
   if( !pSurface.texture.empty() )
   {
-    mOutput << startstr << "<newparam sid=\"" << XMLIDEncode(pMatName) << "-" << pTypeName << "-surface\">" << endstr;
+    mOutput << startstr << "<newparam sid=\"" << XMLEscape(pMatName) << "-" << pTypeName << "-surface\">" << endstr;
     PushTag();
     mOutput << startstr << "<surface type=\"2D\">" << endstr;
     PushTag();
-    mOutput << startstr << "<init_from>" << XMLIDEncode(pMatName) << "-" << pTypeName << "-image</init_from>" << endstr;
+    mOutput << startstr << "<init_from>" << XMLEscape(pMatName) << "-" << pTypeName << "-image</init_from>" << endstr;
     PopTag();
     mOutput << startstr << "</surface>" << endstr;
     PopTag();
     mOutput << startstr << "</newparam>" << endstr;
 
-    mOutput << startstr << "<newparam sid=\"" << XMLIDEncode(pMatName) << "-" << pTypeName << "-sampler\">" << endstr;
+    mOutput << startstr << "<newparam sid=\"" << XMLEscape(pMatName) << "-" << pTypeName << "-sampler\">" << endstr;
     PushTag();
     mOutput << startstr << "<sampler2D>" << endstr;
     PushTag();
-    mOutput << startstr << "<source>" << XMLIDEncode(pMatName) << "-" << pTypeName << "-surface</source>" << endstr;
+    mOutput << startstr << "<source>" << XMLEscape(pMatName) << "-" << pTypeName << "-surface</source>" << endstr;
     PopTag();
     mOutput << startstr << "</sampler2D>" << endstr;
     PopTag();
@@ -732,6 +699,11 @@ void ColladaExporter::WriteMaterials()
         materials[a].name = std::string(name.C_Str()) + to_string(materialCountWithThisName);
       }
     }
+    for( std::string::iterator it = materials[a].name.begin(); it != materials[a].name.end(); ++it ) {
+      if( !isalnum_C( *it ) ) {
+        *it = '_';
+      }
+    }
 
     aiShadingMode shading = aiShadingMode_Flat;
     materials[a].shading_model = "phong";
@@ -796,7 +768,7 @@ void ColladaExporter::WriteMaterials()
     {
       const Material& mat = *it;
       // this is so ridiculous it must be right
-      mOutput << startstr << "<effect id=\"" << XMLIDEncode(mat.name) << "-fx\" name=\"" << XMLEscape(mat.name) << "\">" << endstr;
+      mOutput << startstr << "<effect id=\"" << XMLEscape(mat.name) << "-fx\" name=\"" << XMLEscape(mat.name) << "\">" << endstr;
       PushTag();
       mOutput << startstr << "<profile_COMMON>" << endstr;
       PushTag();
@@ -847,9 +819,9 @@ void ColladaExporter::WriteMaterials()
     for( std::vector<Material>::const_iterator it = materials.begin(); it != materials.end(); ++it )
     {
       const Material& mat = *it;
-      mOutput << startstr << "<material id=\"" << XMLIDEncode(mat.name) << "\" name=\"" << XMLEscape(mat.name) << "\">" << endstr;
+      mOutput << startstr << "<material id=\"" << XMLEscape(mat.name) << "\" name=\"" << mat.name << "\">" << endstr;
       PushTag();
-      mOutput << startstr << "<instance_effect url=\"#" << XMLIDEncode(mat.name) << "-fx\"/>" << endstr;
+      mOutput << startstr << "<instance_effect url=\"#" << XMLEscape(mat.name) << "-fx\"/>" << endstr;
       PopTag();
       mOutput << startstr << "</material>" << endstr;
     }
@@ -878,8 +850,8 @@ void ColladaExporter::WriteControllerLibrary()
 void ColladaExporter::WriteController( size_t pIndex)
 {
     const aiMesh* mesh = mScene->mMeshes[pIndex];
-    const std::string idstr = mesh->mName.length == 0 ? GetMeshId(pIndex) : mesh->mName.C_Str();
-    const std::string idstrEscaped = XMLIDEncode(idstr);
+    const std::string idstr = GetMeshId( pIndex);
+    const std::string idstrEscaped = XMLEscape(idstr);
 
     if ( mesh->mNumFaces == 0 || mesh->mNumVertices == 0 )
         return;
@@ -914,7 +886,7 @@ void ColladaExporter::WriteController( size_t pIndex)
     mOutput << startstr << "<Name_array id=\"" << idstrEscaped << "-skin-joints-array\" count=\"" << mesh->mNumBones << "\">";
 
     for( size_t i = 0; i < mesh->mNumBones; ++i )
-        mOutput << XMLIDEncode(mesh->mBones[i]->mName.C_Str()) << " ";
+        mOutput << XMLEscape(mesh->mBones[i]->mName.C_Str()) << " ";
 
     mOutput << "</Name_array>" << endstr;
 
@@ -1049,15 +1021,14 @@ void ColladaExporter::WriteGeometryLibrary()
 void ColladaExporter::WriteGeometry( size_t pIndex)
 {
     const aiMesh* mesh = mScene->mMeshes[pIndex];
-    const std::string idstr = mesh->mName.length == 0 ? GetMeshId(pIndex) : mesh->mName.C_Str();
-    const std::string geometryName = XMLEscape(idstr);
-    const std::string geometryId = XMLIDEncode(idstr);
+    const std::string idstr = GetMeshId( pIndex);
+    const std::string idstrEscaped = XMLEscape(idstr);
 
     if ( mesh->mNumFaces == 0 || mesh->mNumVertices == 0 )
         return;
 
     // opening tag
-    mOutput << startstr << "<geometry id=\"" << geometryId << "\" name=\"" << geometryName << "\" >" << endstr;
+    mOutput << startstr << "<geometry id=\"" << idstrEscaped << "\" name=\"" << idstrEscaped << "_name\" >" << endstr;
     PushTag();
 
     mOutput << startstr << "<mesh>" << endstr;
@@ -1088,9 +1059,9 @@ void ColladaExporter::WriteGeometry( size_t pIndex)
 
     // assemble vertex structure
     // Only write input for POSITION since we will write other as shared inputs in polygon definition
-    mOutput << startstr << "<vertices id=\"" << geometryId << "-vertices" << "\">" << endstr;
+    mOutput << startstr << "<vertices id=\"" << idstrEscaped << "-vertices" << "\">" << endstr;
     PushTag();
-    mOutput << startstr << "<input semantic=\"POSITION\" source=\"#" << geometryId << "-positions\" />" << endstr;
+    mOutput << startstr << "<input semantic=\"POSITION\" source=\"#" << idstrEscaped << "-positions\" />" << endstr;
     PopTag();
     mOutput << startstr << "</vertices>" << endstr;
 
@@ -1108,18 +1079,18 @@ void ColladaExporter::WriteGeometry( size_t pIndex)
     {
         mOutput << startstr << "<lines count=\"" << countLines << "\" material=\"defaultMaterial\">" << endstr;
         PushTag();
-        mOutput << startstr << "<input offset=\"0\" semantic=\"VERTEX\" source=\"#" << geometryId << "-vertices\" />" << endstr;
+        mOutput << startstr << "<input offset=\"0\" semantic=\"VERTEX\" source=\"#" << idstrEscaped << "-vertices\" />" << endstr;
         if( mesh->HasNormals() )
-            mOutput << startstr << "<input semantic=\"NORMAL\" source=\"#" << geometryId << "-normals\" />" << endstr;
+            mOutput << startstr << "<input semantic=\"NORMAL\" source=\"#" << idstrEscaped << "-normals\" />" << endstr;
         for( size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a )
         {
             if( mesh->HasTextureCoords(static_cast<unsigned int>(a)) )
-                mOutput << startstr << "<input semantic=\"TEXCOORD\" source=\"#" << geometryId << "-tex" << a << "\" " << "set=\"" << a << "\""  << " />" << endstr;
+                mOutput << startstr << "<input semantic=\"TEXCOORD\" source=\"#" << idstrEscaped << "-tex" << a << "\" " << "set=\"" << a << "\""  << " />" << endstr;
         }
         for( size_t a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a )
         {
             if( mesh->HasVertexColors(static_cast<unsigned int>(a) ) )
-                mOutput << startstr << "<input semantic=\"COLOR\" source=\"#" << geometryId << "-color" << a << "\" " << "set=\"" << a << "\""  << " />" << endstr;
+                mOutput << startstr << "<input semantic=\"COLOR\" source=\"#" << idstrEscaped << "-color" << a << "\" " << "set=\"" << a << "\""  << " />" << endstr;
         }
 
         mOutput << startstr << "<p>";
@@ -1142,18 +1113,18 @@ void ColladaExporter::WriteGeometry( size_t pIndex)
     {
         mOutput << startstr << "<polylist count=\"" << countPoly << "\" material=\"defaultMaterial\">" << endstr;
         PushTag();
-        mOutput << startstr << "<input offset=\"0\" semantic=\"VERTEX\" source=\"#" << geometryId << "-vertices\" />" << endstr;
+        mOutput << startstr << "<input offset=\"0\" semantic=\"VERTEX\" source=\"#" << idstrEscaped << "-vertices\" />" << endstr;
         if( mesh->HasNormals() )
-            mOutput << startstr << "<input offset=\"0\" semantic=\"NORMAL\" source=\"#" << geometryId << "-normals\" />" << endstr;
+            mOutput << startstr << "<input offset=\"0\" semantic=\"NORMAL\" source=\"#" << idstrEscaped << "-normals\" />" << endstr;
         for( size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a )
         {
             if( mesh->HasTextureCoords(static_cast<unsigned int>(a)) )
-                mOutput << startstr << "<input offset=\"0\" semantic=\"TEXCOORD\" source=\"#" << geometryId << "-tex" << a << "\" " << "set=\"" << a << "\""  << " />" << endstr;
+                mOutput << startstr << "<input offset=\"0\" semantic=\"TEXCOORD\" source=\"#" << idstrEscaped << "-tex" << a << "\" " << "set=\"" << a << "\""  << " />" << endstr;
         }
         for( size_t a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a )
         {
             if( mesh->HasVertexColors(static_cast<unsigned int>(a) ) )
-                mOutput << startstr << "<input offset=\"0\" semantic=\"COLOR\" source=\"#" << geometryId << "-color" << a << "\" " << "set=\"" << a << "\""  << " />" << endstr;
+                mOutput << startstr << "<input offset=\"0\" semantic=\"COLOR\" source=\"#" << idstrEscaped << "-color" << a << "\" " << "set=\"" << a << "\""  << " />" << endstr;
         }
 
         mOutput << startstr << "<vcount>";
@@ -1202,13 +1173,13 @@ void ColladaExporter::WriteFloatArray( const std::string& pIdString, FloatDataTy
             return;
     }
 
-    std::string arrayId = XMLIDEncode(pIdString) + "-array";
+    std::string arrayId = pIdString + "-array";
 
-    mOutput << startstr << "<source id=\"" << XMLIDEncode(pIdString) << "\" name=\"" << XMLEscape(pIdString) << "\">" << endstr;
+    mOutput << startstr << "<source id=\"" << XMLEscape(pIdString) << "\" name=\"" << XMLEscape(pIdString) << "\">" << endstr;
     PushTag();
 
     // source array
-    mOutput << startstr << "<float_array id=\"" << arrayId << "\" count=\"" << pElementCount * floatsPerElement << "\"> ";
+    mOutput << startstr << "<float_array id=\"" << XMLEscape(arrayId) << "\" count=\"" << pElementCount * floatsPerElement << "\"> ";
     PushTag();
 
     if( pType == FloatType_TexCoord2 )
@@ -1294,12 +1265,11 @@ void ColladaExporter::WriteFloatArray( const std::string& pIdString, FloatDataTy
 // Writes the scene library
 void ColladaExporter::WriteSceneLibrary()
 {
-    const std::string sceneName = XMLEscape(mScene->mRootNode->mName.C_Str());
-    const std::string sceneId = XMLIDEncode(mScene->mRootNode->mName.C_Str());
+    const std::string scene_name_escaped = XMLEscape(mScene->mRootNode->mName.C_Str());
 
     mOutput << startstr << "<library_visual_scenes>" << endstr;
     PushTag();
-    mOutput << startstr << "<visual_scene id=\"" + sceneId + "\" name=\"" + sceneName + "\">" << endstr;
+    mOutput << startstr << "<visual_scene id=\"" + scene_name_escaped + "\" name=\"" + scene_name_escaped + "\">" << endstr;
     PushTag();
 
     // start recursive write at the root node
@@ -1330,7 +1300,7 @@ void ColladaExporter::WriteAnimationLibrary(size_t pIndex)
 		idstr = idstr + ending;
 	}
 
-	const std::string idstrEscaped = XMLIDEncode(idstr);
+	const std::string idstrEscaped = XMLEscape(idstr);
 	
 	mOutput << startstr << "<animation id=\"" + idstrEscaped + "\" name=\"" + animation_name_escaped + "\">" << endstr;
 	PushTag();
@@ -1402,13 +1372,13 @@ void ColladaExporter::WriteAnimationLibrary(size_t pIndex)
 			}
 			
 			const std::string node_idstr = nodeAnim->mNodeName.data + std::string("_matrix-interpolation");
-            std::string arrayId = XMLIDEncode(node_idstr) + "-array";
+			std::string arrayId = node_idstr + "-array";
 			
-			mOutput << startstr << "<source id=\"" << XMLIDEncode(node_idstr) << "\">" << endstr;
+			mOutput << startstr << "<source id=\"" << XMLEscape(node_idstr) << "\">" << endstr;
 			PushTag();
 			
 			// source array
-			mOutput << startstr << "<Name_array id=\"" << arrayId << "\" count=\"" << names.size() << "\"> ";
+			mOutput << startstr << "<Name_array id=\"" << XMLEscape(arrayId) << "\" count=\"" << names.size() << "\"> ";
 			for( size_t a = 0; a < names.size(); ++a ) {
 				mOutput << names[a] << " ";
             }
@@ -1417,7 +1387,7 @@ void ColladaExporter::WriteAnimationLibrary(size_t pIndex)
 			mOutput << startstr << "<technique_common>" << endstr;
 			PushTag();
 
-			mOutput << startstr << "<accessor source=\"#" << arrayId << "\" count=\"" << names.size() << "\" stride=\"" << 1 << "\">" << endstr;
+			mOutput << startstr << "<accessor source=\"#" << XMLEscape(arrayId) << "\" count=\"" << names.size() << "\" stride=\"" << 1 << "\">" << endstr;
 			PushTag();
 			
 			mOutput << startstr << "<param name=\"INTERPOLATION\" type=\"name\"></param>" << endstr;
@@ -1439,12 +1409,12 @@ void ColladaExporter::WriteAnimationLibrary(size_t pIndex)
 		{
 		// samplers
 			const std::string node_idstr = nodeAnim->mNodeName.data + std::string("_matrix-sampler");
-			mOutput << startstr << "<sampler id=\"" << XMLIDEncode(node_idstr) << "\">" << endstr;
+			mOutput << startstr << "<sampler id=\"" << XMLEscape(node_idstr) << "\">" << endstr;
 			PushTag();
 			
-			mOutput << startstr << "<input semantic=\"INPUT\" source=\"#" << XMLIDEncode( nodeAnim->mNodeName.data + std::string("_matrix-input") ) << "\"/>" << endstr;
-			mOutput << startstr << "<input semantic=\"OUTPUT\" source=\"#" << XMLIDEncode( nodeAnim->mNodeName.data + std::string("_matrix-output") ) << "\"/>" << endstr;
-			mOutput << startstr << "<input semantic=\"INTERPOLATION\" source=\"#" << XMLIDEncode( nodeAnim->mNodeName.data + std::string("_matrix-interpolation") ) << "\"/>" << endstr;
+			mOutput << startstr << "<input semantic=\"INPUT\" source=\"#" << XMLEscape( nodeAnim->mNodeName.data + std::string("_matrix-input") ) << "\"/>" << endstr;
+			mOutput << startstr << "<input semantic=\"OUTPUT\" source=\"#" << XMLEscape( nodeAnim->mNodeName.data + std::string("_matrix-output") ) << "\"/>" << endstr;
+			mOutput << startstr << "<input semantic=\"INTERPOLATION\" source=\"#" << XMLEscape( nodeAnim->mNodeName.data + std::string("_matrix-interpolation") ) << "\"/>" << endstr;
 			
 			PopTag();
 			mOutput << startstr << "</sampler>" << endstr;
@@ -1456,7 +1426,7 @@ void ColladaExporter::WriteAnimationLibrary(size_t pIndex)
 		
 		{
 		// channels
-			mOutput << startstr << "<channel source=\"#" << XMLIDEncode( nodeAnim->mNodeName.data + std::string("_matrix-sampler") ) << "\" target=\"" << XMLIDEncode(nodeAnim->mNodeName.data) << "/matrix\"/>" << endstr;
+			mOutput << startstr << "<channel source=\"#" << XMLEscape( nodeAnim->mNodeName.data + std::string("_matrix-sampler") ) << "\" target=\"" << XMLEscape(nodeAnim->mNodeName.data) << "/matrix\"/>" << endstr;
 		}
 	}
 	
@@ -1467,6 +1437,8 @@ void ColladaExporter::WriteAnimationLibrary(size_t pIndex)
 // ------------------------------------------------------------------------------------------------
 void ColladaExporter::WriteAnimationsLibrary()
 {
+	const std::string scene_name_escaped = XMLEscape(mScene->mRootNode->mName.C_Str());
+	
 	if ( mScene->mNumAnimations > 0 ) {
 		mOutput << startstr << "<library_animations>" << endstr;
 		PushTag();
@@ -1574,17 +1546,16 @@ void ColladaExporter::WriteNode( const aiScene* pScene, aiNode* pNode)
         }
     }
 
-    const std::string node_id = XMLIDEncode(pNode->mName.data);
-    const std::string node_name = XMLEscape(pNode->mName.data);
+    const std::string node_name_escaped = XMLEscape(pNode->mName.data);
 	mOutput << startstr << "<node ";
 	if(is_skeleton_root) {
-		mOutput << "id=\"" << node_id << "\" " << (is_joint ? "sid=\"" + node_id +"\"" : "") ; // For now, only support one skeleton in a scene.
-		mFoundSkeletonRootNodeID = node_id;
+		mOutput << "id=\"" << node_name_escaped << "\" " << (is_joint ? "sid=\"" + node_name_escaped +"\"" : "") ; // For now, only support one skeleton in a scene.
+		mFoundSkeletonRootNodeID = node_name_escaped;
 	} else {
-		mOutput << "id=\"" << node_id << "\" " << (is_joint ? "sid=\"" + node_id +"\"": "") ;
+		mOutput << "id=\"" << node_name_escaped << "\" " << (is_joint ? "sid=\"" + node_name_escaped +"\"": "") ;
 	}
 	
-    mOutput << " name=\"" << node_name
+    mOutput << " name=\"" << node_name_escaped
             << "\" type=\"" << node_type
             << "\">" << endstr;
     PushTag();
@@ -1623,14 +1594,14 @@ void ColladaExporter::WriteNode( const aiScene* pScene, aiNode* pNode)
         //check if it is a camera node
         for(size_t i=0; i<mScene->mNumCameras; i++){
             if(mScene->mCameras[i]->mName == pNode->mName){
-                mOutput << startstr <<"<instance_camera url=\"#" << node_id << "-camera\"/>" << endstr;
+                mOutput << startstr <<"<instance_camera url=\"#" << node_name_escaped << "-camera\"/>" << endstr;
                 break;
             }
         }
         //check if it is a light node
         for(size_t i=0; i<mScene->mNumLights; i++){
             if(mScene->mLights[i]->mName == pNode->mName){
-                mOutput << startstr <<"<instance_light url=\"#" << node_id << "-light\"/>" << endstr;
+                mOutput << startstr <<"<instance_light url=\"#" << node_name_escaped << "-light\"/>" << endstr;
                 break;
             }
         }
@@ -1644,17 +1615,15 @@ void ColladaExporter::WriteNode( const aiScene* pScene, aiNode* pNode)
         if( mesh->mNumFaces == 0 || mesh->mNumVertices == 0 )
             continue;
 
-        const std::string meshName = mesh->mName.length == 0 ? GetMeshId(pNode->mMeshes[a]) : mesh->mName.C_Str();
-
         if( mesh->mNumBones == 0 )
         {
-            mOutput << startstr << "<instance_geometry url=\"#" << XMLIDEncode(meshName) << "\">" << endstr;
+            mOutput << startstr << "<instance_geometry url=\"#" << XMLEscape(GetMeshId( pNode->mMeshes[a])) << "\">" << endstr;
             PushTag();
         }
         else
         {
             mOutput << startstr
-                    << "<instance_controller url=\"#" << XMLIDEncode(meshName) << "-skin\">"
+                    << "<instance_controller url=\"#" << XMLEscape(GetMeshId( pNode->mMeshes[a])) << "-skin\">"
                     << endstr;
             PushTag();
 
@@ -1662,7 +1631,7 @@ void ColladaExporter::WriteNode( const aiScene* pScene, aiNode* pNode)
 			// use the first bone to find skeleton root
 			const aiNode * skeletonRootBoneNode = findSkeletonRootNode( pScene, mesh );
 			if ( skeletonRootBoneNode ) {
-				mFoundSkeletonRootNodeID = XMLIDEncode( skeletonRootBoneNode->mName.C_Str() );
+				mFoundSkeletonRootNodeID = XMLEscape( skeletonRootBoneNode->mName.C_Str() );
 			}
             mOutput << startstr << "<skeleton>#" << mFoundSkeletonRootNodeID << "</skeleton>" << endstr;
         }
@@ -1670,7 +1639,7 @@ void ColladaExporter::WriteNode( const aiScene* pScene, aiNode* pNode)
         PushTag();
         mOutput << startstr << "<technique_common>" << endstr;
         PushTag();
-        mOutput << startstr << "<instance_material symbol=\"defaultMaterial\" target=\"#" << XMLIDEncode(materials[mesh->mMaterialIndex].name) << "\">" << endstr;
+        mOutput << startstr << "<instance_material symbol=\"defaultMaterial\" target=\"#" << XMLEscape(materials[mesh->mMaterialIndex].name) << "\">" << endstr;
         PushTag();
         for( size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a )
         {
diff --git a/Engine/lib/assimp/code/Collada/ColladaExporter.h b/Engine/lib/assimp/code/Collada/ColladaExporter.h
index f6c66e279..0b4fa59a3 100644
--- a/Engine/lib/assimp/code/Collada/ColladaExporter.h
+++ b/Engine/lib/assimp/code/Collada/ColladaExporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Collada/ColladaHelper.cpp b/Engine/lib/assimp/code/Collada/ColladaHelper.cpp
deleted file mode 100644
index 6f1fed366..000000000
--- a/Engine/lib/assimp/code/Collada/ColladaHelper.cpp
+++ /dev/null
@@ -1,107 +0,0 @@
-/** Helper structures for the Collada loader */
-
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-#include "ColladaHelper.h"
-
-#include <assimp/commonMetaData.h>
-#include <assimp/ParsingUtils.h>
-
-namespace Assimp {
-namespace Collada {
-
-const MetaKeyPairVector MakeColladaAssimpMetaKeys() {
-    MetaKeyPairVector result;
-    result.emplace_back("authoring_tool", AI_METADATA_SOURCE_GENERATOR);
-    result.emplace_back("copyright", AI_METADATA_SOURCE_COPYRIGHT);
-    return result;
-};
-
-const MetaKeyPairVector &GetColladaAssimpMetaKeys() {
-    static const MetaKeyPairVector result = MakeColladaAssimpMetaKeys();
-    return result;
-}
-
-const MetaKeyPairVector MakeColladaAssimpMetaKeysCamelCase() {
-    MetaKeyPairVector result = MakeColladaAssimpMetaKeys();
-    for (auto &val : result)
-    {
-        ToCamelCase(val.first);
-    }
-    return result;
-};
-
-const MetaKeyPairVector &GetColladaAssimpMetaKeysCamelCase()
-{
-    static const MetaKeyPairVector result = MakeColladaAssimpMetaKeysCamelCase();
-    return result;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Convert underscore_separated to CamelCase: "authoring_tool" becomes "AuthoringTool"
-void ToCamelCase(std::string &text)
-{
-    if (text.empty())
-        return;
-    // Capitalise first character
-    auto it = text.begin();
-    (*it) = ToUpper(*it);
-    ++it;
-    for (/*started above*/ ; it != text.end(); /*iterated below*/)
-    {
-        if ((*it) == '_')
-        {
-            it = text.erase(it);
-            if (it != text.end())
-                (*it) = ToUpper(*it);
-        }
-        else
-        {
-            // Make lower case
-            (*it) = ToLower(*it);
-            ++it;               
-        }
-    }
-}
-
-} // namespace Collada
-} // namespace Assimp
diff --git a/Engine/lib/assimp/code/Collada/ColladaHelper.h b/Engine/lib/assimp/code/Collada/ColladaHelper.h
index c6e2e7ddd..66cff2d20 100644
--- a/Engine/lib/assimp/code/Collada/ColladaHelper.h
+++ b/Engine/lib/assimp/code/Collada/ColladaHelper.h
@@ -4,7 +4,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -47,7 +47,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <map>
 #include <vector>
-#include <set>
 #include <stdint.h>
 #include <assimp/light.h>
 #include <assimp/mesh.h>
@@ -105,17 +104,6 @@ enum MorphMethod
     Relative
 };
 
-/** Common metadata keys as <Collada, Assimp> */
-typedef std::pair<std::string, std::string> MetaKeyPair;
-typedef std::vector<MetaKeyPair> MetaKeyPairVector;
-
-// Collada as lower_case (native)
-const MetaKeyPairVector &GetColladaAssimpMetaKeys();
-// Collada as CamelCase (used by Assimp for consistency)
-const MetaKeyPairVector &GetColladaAssimpMetaKeysCamelCase();
-
-/** Convert underscore_separated to CamelCase "authoring_tool" becomes "AuthoringTool" */
-void ToCamelCase(std::string &text);
 
 /** Contains all data for one of the different transformation types */
 struct Transform
@@ -595,7 +583,7 @@ struct Image
     /** Embedded image data */
     std::vector<uint8_t> mImageData;
 
-    /** File format hint of embedded image data */
+    /** File format hint ofembedded image data */
     std::string mEmbeddedFormat;
 };
 
@@ -659,37 +647,23 @@ struct Animation
 
 	void CombineSingleChannelAnimationsRecursively(Animation *pParent)
 	{
-		std::set<std::string> childrenTargets;
-		bool childrenAnimationsHaveDifferentChannels = true;
-
 		for (std::vector<Animation*>::iterator it = pParent->mSubAnims.begin(); it != pParent->mSubAnims.end();)
 		{
 			Animation *anim = *it;
+
 			CombineSingleChannelAnimationsRecursively(anim);
 
-			if (childrenAnimationsHaveDifferentChannels && anim->mChannels.size() == 1 &&
-				childrenTargets.find(anim->mChannels[0].mTarget) == childrenTargets.end()) {
-				childrenTargets.insert(anim->mChannels[0].mTarget);
-			} else {
-				childrenAnimationsHaveDifferentChannels = false;
-			}
-
-			++it;
-		}
-
-		// We only want to combine animations if they have different channels
-		if (childrenAnimationsHaveDifferentChannels)
-		{
-			for (std::vector<Animation*>::iterator it = pParent->mSubAnims.begin(); it != pParent->mSubAnims.end();)
+			if (anim->mChannels.size() == 1)
 			{
-				Animation *anim = *it;
-
 				pParent->mChannels.push_back(anim->mChannels[0]);
 
 				it = pParent->mSubAnims.erase(it);
 
 				delete anim;
-				continue;
+			}
+			else
+			{
+				++it;
 			}
 		}
 	}
diff --git a/Engine/lib/assimp/code/Collada/ColladaLoader.cpp b/Engine/lib/assimp/code/Collada/ColladaLoader.cpp
index b78fc0e3b..0fbc7d599 100644
--- a/Engine/lib/assimp/code/Collada/ColladaLoader.cpp
+++ b/Engine/lib/assimp/code/Collada/ColladaLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
@@ -963,38 +963,18 @@ void ColladaLoader::StoreAnimations( aiScene* pScene, const ColladaParser& pPars
 
     // catch special case: many animations with the same length, each affecting only a single node.
     // we need to unite all those single-node-anims to a proper combined animation
-    for(size_t a = 0; a < mAnims.size(); ++a) {
+    for( size_t a = 0; a < mAnims.size(); ++a) {
         aiAnimation* templateAnim = mAnims[a];
-
-        if (templateAnim->mNumChannels == 1) {
+        if( templateAnim->mNumChannels == 1) {
             // search for other single-channel-anims with the same duration
             std::vector<size_t> collectedAnimIndices;
             for( size_t b = a+1; b < mAnims.size(); ++b) {
                 aiAnimation* other = mAnims[b];
                 if (other->mNumChannels == 1 && other->mDuration == templateAnim->mDuration &&
                     other->mTicksPerSecond == templateAnim->mTicksPerSecond)
-						collectedAnimIndices.push_back(b);
+                    collectedAnimIndices.push_back(b);
             }
 
-			// We only want to combine the animations if they have different channels
-			std::set<std::string> animTargets;
-			animTargets.insert(templateAnim->mChannels[0]->mNodeName.C_Str());
-			bool collectedAnimationsHaveDifferentChannels = true;
-			for (size_t b = 0; b < collectedAnimIndices.size(); ++b)
-			{
-				aiAnimation* srcAnimation = mAnims[collectedAnimIndices[b]];
-				std::string channelName = std::string(srcAnimation->mChannels[0]->mNodeName.C_Str());
-				if (animTargets.find(channelName) == animTargets.end()) {
-					animTargets.insert(channelName);
-				} else {
-					collectedAnimationsHaveDifferentChannels = false;
-					break;
-				}
-			}
-
-			if (!collectedAnimationsHaveDifferentChannels)
-				continue;
-
             // if there are other animations which fit the template anim, combine all channels into a single anim
             if (!collectedAnimIndices.empty())
             {
@@ -1755,7 +1735,6 @@ void ColladaLoader::BuildMaterials(ColladaParser& pParser, aiScene* /*pScene*/)
 
 // ------------------------------------------------------------------------------------------------
 // Resolves the texture name for the given effect texture entry
-// and loads the texture data 
 aiString ColladaLoader::FindFilenameForEffectTexture(const ColladaParser& pParser,
     const Collada::Effect& pEffect, const std::string& pName)
 {
@@ -1783,7 +1762,7 @@ aiString ColladaLoader::FindFilenameForEffectTexture(const ColladaParser& pParse
 
         //set default texture file name
         result.Set(name + ".jpg");
-        ColladaParser::UriDecodePath(result);
+        ConvertPath(result);
         return result;
     }
 
@@ -1802,7 +1781,7 @@ aiString ColladaLoader::FindFilenameForEffectTexture(const ColladaParser& pParse
 
 
         // setup format hint
-        if (imIt->second.mEmbeddedFormat.length() >= HINTMAXTEXTURELEN) {
+        if (imIt->second.mEmbeddedFormat.length() > 3) {
             ASSIMP_LOG_WARN("Collada: texture format hint is too long, truncating to 3 characters");
         }
         strncpy(tex->achFormatHint, imIt->second.mEmbeddedFormat.c_str(), 3);
@@ -1823,10 +1802,61 @@ aiString ColladaLoader::FindFilenameForEffectTexture(const ColladaParser& pParse
         }
 
         result.Set(imIt->second.mFileName);
+        ConvertPath(result);
     }
     return result;
 }
 
+// ------------------------------------------------------------------------------------------------
+// Convert a path read from a collada file to the usual representation
+void ColladaLoader::ConvertPath(aiString& ss)
+{
+    // TODO: collada spec, p 22. Handle URI correctly.
+    // For the moment we're just stripping the file:// away to make it work.
+    // Windows doesn't seem to be able to find stuff like
+    // 'file://..\LWO\LWO2\MappingModes\earthSpherical.jpg'
+    if (0 == strncmp(ss.data, "file://", 7))
+    {
+        ss.length -= 7;
+        memmove(ss.data, ss.data + 7, ss.length);
+        ss.data[ss.length] = '\0';
+    }
+
+    // Maxon Cinema Collada Export writes "file:///C:\andsoon" with three slashes...
+    // I need to filter it without destroying linux paths starting with "/somewhere"
+#if defined( _MSC_VER )
+    if (ss.data[0] == '/' && isalpha((unsigned char)ss.data[1]) && ss.data[2] == ':') {
+#else
+    if (ss.data[0] == '/' && isalpha(ss.data[1]) && ss.data[2] == ':') {
+#endif
+        --ss.length;
+        ::memmove(ss.data, ss.data + 1, ss.length);
+        ss.data[ss.length] = 0;
+    }
+
+    // find and convert all %xy special chars
+    char* out = ss.data;
+    for (const char* it = ss.data; it != ss.data + ss.length; /**/)
+    {
+        if (*it == '%' && (it + 3) < ss.data + ss.length)
+        {
+            // separate the number to avoid dragging in chars from behind into the parsing
+            char mychar[3] = { it[1], it[2], 0 };
+            size_t nbr = strtoul16(mychar);
+            it += 3;
+            *out++ = (char)(nbr & 0xFF);
+        }
+        else
+        {
+            *out++ = *it++;
+        }
+    }
+
+    // adjust length and terminator of the shortened string
+    *out = 0;
+    ss.length = (ptrdiff_t)(out - ss.data);
+}
+
 // ------------------------------------------------------------------------------------------------
 // Reads a float value from an accessor and its data array.
 ai_real ColladaLoader::ReadFloat(const Collada::Accessor& pAccessor, const Collada::Data& pData, size_t pIndex, size_t pOffset) const
diff --git a/Engine/lib/assimp/code/Collada/ColladaLoader.h b/Engine/lib/assimp/code/Collada/ColladaLoader.h
index 198b7a215..dce46e06f 100644
--- a/Engine/lib/assimp/code/Collada/ColladaLoader.h
+++ b/Engine/lib/assimp/code/Collada/ColladaLoader.h
@@ -4,7 +4,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -94,7 +94,7 @@ public:
 public:
     /** Returns whether the class can handle the format of the given file.
      * See BaseImporter::CanRead() for details. */
-    bool CanRead(const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const override;
+    bool CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const override;
 
 protected:
     /** Return importer meta information.
@@ -184,6 +184,9 @@ protected:
     aiString FindFilenameForEffectTexture( const ColladaParser& pParser,
         const Collada::Effect& pEffect, const std::string& pName);
 
+    /** Converts a path read from a collada file to the usual representation */
+    void ConvertPath( aiString& ss);
+
     /** Reads a float value from an accessor and its data array.
      * @param pAccessor The accessor to use for reading
      * @param pData The data array to read from
diff --git a/Engine/lib/assimp/code/Collada/ColladaParser.cpp b/Engine/lib/assimp/code/Collada/ColladaParser.cpp
index d0f71d95a..646ec473d 100644
--- a/Engine/lib/assimp/code/Collada/ColladaParser.cpp
+++ b/Engine/lib/assimp/code/Collada/ColladaParser.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -50,7 +50,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <sstream>
 #include <stdarg.h>
 #include "ColladaParser.h"
-#include <assimp/commonMetaData.h>
 #include <assimp/fast_atof.h>
 #include <assimp/ParsingUtils.h>
 #include <assimp/StringUtils.h>
@@ -184,75 +183,18 @@ std::string ColladaParser::ReadZaeManifest(ZipArchiveIOSystem &zip_archive) {
                 if (filepath == nullptr)
                     return std::string();
 
-                aiString ai_str(filepath);
-                UriDecodePath(ai_str);
-
-                return std::string(ai_str.C_Str());
+                return std::string(filepath);
             }
         }
     }
     return std::string();
 }
 
-// ------------------------------------------------------------------------------------------------
-// Convert a path read from a collada file to the usual representation
-void ColladaParser::UriDecodePath(aiString& ss)
-{
-    // TODO: collada spec, p 22. Handle URI correctly.
-    // For the moment we're just stripping the file:// away to make it work.
-    // Windows doesn't seem to be able to find stuff like
-    // 'file://..\LWO\LWO2\MappingModes\earthSpherical.jpg'
-    if (0 == strncmp(ss.data, "file://", 7))
-    {
-        ss.length -= 7;
-        memmove(ss.data, ss.data + 7, ss.length);
-        ss.data[ss.length] = '\0';
-    }
-
-    // Maxon Cinema Collada Export writes "file:///C:\andsoon" with three slashes...
-    // I need to filter it without destroying linux paths starting with "/somewhere"
-#if defined( _MSC_VER )
-    if (ss.data[0] == '/' && isalpha((unsigned char)ss.data[1]) && ss.data[2] == ':') {
-#else
-    if (ss.data[0] == '/' && isalpha(ss.data[1]) && ss.data[2] == ':') {
-#endif
-        --ss.length;
-        ::memmove(ss.data, ss.data + 1, ss.length);
-        ss.data[ss.length] = 0;
-    }
-
-    // find and convert all %xy special chars
-    char* out = ss.data;
-    for (const char* it = ss.data; it != ss.data + ss.length; /**/)
-    {
-        if (*it == '%' && (it + 3) < ss.data + ss.length)
-        {
-            // separate the number to avoid dragging in chars from behind into the parsing
-            char mychar[3] = { it[1], it[2], 0 };
-            size_t nbr = strtoul16(mychar);
-            it += 3;
-            *out++ = (char)(nbr & 0xFF);
-        }
-        else
-        {
-            *out++ = *it++;
-        }
-    }
-
-    // adjust length and terminator of the shortened string
-    *out = 0;
-    ai_assert(out > ss.data);
-    ss.length = static_cast<ai_uint32>(out - ss.data);
-}
-
 // ------------------------------------------------------------------------------------------------
 // Read bool from text contents of current element
 bool ColladaParser::ReadBoolFromTextContent()
 {
     const char* cur = GetTextContent();
-    if ( nullptr == cur) {
-        return false;
-    }
     return (!ASSIMP_strincmp(cur, "true", 4) || '0' != *cur);
 }
 
@@ -261,9 +203,6 @@ bool ColladaParser::ReadBoolFromTextContent()
 ai_real ColladaParser::ReadFloatFromTextContent()
 {
     const char* cur = GetTextContent();
-    if ( nullptr == cur ) {
-        return 0.0;
-    }
     return fast_atof(cur);
 }
 
@@ -283,11 +222,6 @@ void ColladaParser::ReadContents()
                 if (attrib != -1) {
                     const char* version = mReader->getAttributeValue(attrib);
 
-                    // Store declared format version string
-                    aiString v;
-                    v.Set(version);
-                    mAssetMetaData.emplace(AI_METADATA_SOURCE_FORMAT_VERSION, v );
-
                     if (!::strncmp(version, "1.5", 3)) {
                         mFormat = FV_1_5_n;
                         ASSIMP_LOG_DEBUG("Collada schema version is 1.5.n");
@@ -446,39 +380,23 @@ void ColladaParser::ReadContributorInfo()
     }
 }
 
-static bool FindCommonKey(const std::string &collada_key, const MetaKeyPairVector &key_renaming, size_t &found_index) {
-    for (size_t i = 0; i < key_renaming.size(); ++i) {
-		if (key_renaming[i].first == collada_key) {
-            found_index = i;
-            return true;
-		}
-	}
-    found_index = std::numeric_limits<size_t>::max();
-    return false;
-}
-
 // ------------------------------------------------------------------------------------------------
 // Reads a single string metadata item
-void ColladaParser::ReadMetaDataItem(StringMetaData &metadata) {
-    const Collada::MetaKeyPairVector &key_renaming = GetColladaAssimpMetaKeysCamelCase();
-	// Metadata such as created, keywords, subject etc
-	const char *key_char = mReader->getNodeName();
-	if (key_char != nullptr) {
+void ColladaParser::ReadMetaDataItem(StringMetaData &metadata)
+{
+    // Metadata such as created, keywords, subject etc
+    const char* key_char = mReader->getNodeName();
+    if (key_char != nullptr)
+    {
         const std::string key_str(key_char);
-		const char *value_char = TestTextContent();
-		if (value_char != nullptr) {
+        const char* value_char = TestTextContent();
+        if (value_char != nullptr)
+        {
+            std::string camel_key_str = key_str;
+            ToCamelCase(camel_key_str);
             aiString aistr;
-			aistr.Set(value_char);
-
-            std::string camel_key_str(key_str);
-			ToCamelCase(camel_key_str);
-
-			size_t found_index;
-			if (FindCommonKey(camel_key_str, key_renaming, found_index)) {
-                metadata.emplace(key_renaming[found_index].second, aistr);
-            } else {
-				metadata.emplace(camel_key_str, aistr);
-			}
+            aistr.Set(value_char);
+            metadata.emplace(camel_key_str, aistr);
         }
         TestClosing(key_str.c_str());
     }
@@ -486,6 +404,27 @@ void ColladaParser::ReadMetaDataItem(StringMetaData &metadata) {
         SkipElement();
 }
 
+// ------------------------------------------------------------------------------------------------
+// Convert underscore_seperated to CamelCase: "authoring_tool" becomes "AuthoringTool"
+void ColladaParser::ToCamelCase(std::string &text)
+{
+    if (text.empty())
+        return;
+    // Capitalise first character
+    text[0] = ToUpper(text[0]);
+    for (auto it = text.begin(); it != text.end(); /*iterated below*/)
+    {
+        if ((*it) == '_')
+        {
+            it = text.erase(it);
+            if (it != text.end())
+                (*it) = ToUpper(*it);
+        }
+        else
+            ++it;
+    }
+}
+
 // ------------------------------------------------------------------------------------------------
 // Reads the animation clips
 void ColladaParser::ReadAnimationClipLibrary()
@@ -1181,12 +1120,7 @@ void ColladaParser::ReadImage(Collada::Image& pImage)
                     if (!mReader->isEmptyElement()) {
                         // element content is filename - hopefully
                         const char* sz = TestTextContent();
-                        if (sz)
-                        {
-                            aiString filepath(sz);
-                            UriDecodePath(filepath);
-                            pImage.mFileName = filepath.C_Str();
-                        }
+                        if (sz)pImage.mFileName = sz;
                         TestClosing("init_from");
                     }
                     if (!pImage.mFileName.length()) {
@@ -1219,12 +1153,7 @@ void ColladaParser::ReadImage(Collada::Image& pImage)
                 {
                     // element content is filename - hopefully
                     const char* sz = TestTextContent();
-                    if (sz)
-                    {
-                        aiString filepath(sz);
-                        UriDecodePath(filepath);
-                        pImage.mFileName = filepath.C_Str();
-                    }
+                    if (sz)pImage.mFileName = sz;
                     TestClosing("ref");
                 }
                 else if (IsElement("hex") && !pImage.mFileName.length())
@@ -3127,7 +3056,7 @@ void ColladaParser::ReadMaterialVertexInputBinding(Collada::SemanticMappingTable
     }
 }
 
-void ColladaParser::ReadEmbeddedTextures(ZipArchiveIOSystem& zip_archive)
+void Assimp::ColladaParser::ReadEmbeddedTextures(ZipArchiveIOSystem& zip_archive)
 {
     // Attempt to load any undefined Collada::Image in ImageLibrary
     for (ImageLibrary::iterator it = mImageLibrary.begin(); it != mImageLibrary.end(); ++it) {
@@ -3241,12 +3170,13 @@ void ColladaParser::ReadScene()
 
 // ------------------------------------------------------------------------------------------------
 // Aborts the file reading with an exception
-AI_WONT_RETURN void ColladaParser::ThrowException(const std::string& pError) const {
+AI_WONT_RETURN void ColladaParser::ThrowException(const std::string& pError) const
+{
     throw DeadlyImportError(format() << "Collada: " << mFileName << " - " << pError);
 }
-
-void ColladaParser::ReportWarning(const char* msg, ...) {
-    ai_assert(nullptr != msg);
+void ColladaParser::ReportWarning(const char* msg, ...)
+{
+    ai_assert(NULL != msg);
 
     va_list args;
     va_start(args, msg);
@@ -3261,11 +3191,11 @@ void ColladaParser::ReportWarning(const char* msg, ...) {
 
 // ------------------------------------------------------------------------------------------------
 // Skips all data until the end node of the current element
-void ColladaParser::SkipElement() {
+void ColladaParser::SkipElement()
+{
     // nothing to skip if it's an <element />
-    if (mReader->isEmptyElement()) {
+    if (mReader->isEmptyElement())
         return;
-    }
 
     // reroute
     SkipElement(mReader->getNodeName());
@@ -3273,75 +3203,63 @@ void ColladaParser::SkipElement() {
 
 // ------------------------------------------------------------------------------------------------
 // Skips all data until the end node of the given element
-void ColladaParser::SkipElement(const char* pElement) {
+void ColladaParser::SkipElement(const char* pElement)
+{
     // copy the current node's name because it'a pointer to the reader's internal buffer,
     // which is going to change with the upcoming parsing
     std::string element = pElement;
-    while (mReader->read()) {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
-            if (mReader->getNodeName() == element) {
+    while (mReader->read())
+    {
+        if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+            if (mReader->getNodeName() == element)
                 break;
-            }
-        }
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Tests for an opening element of the given name, throws an exception if not found
-void ColladaParser::TestOpening(const char* pName) {
+void ColladaParser::TestOpening(const char* pName)
+{
     // read element start
-    if (!mReader->read()) {
+    if (!mReader->read())
         ThrowException(format() << "Unexpected end of file while beginning of <" << pName << "> element.");
-    }
     // whitespace in front is ok, just read again if found
-    if (mReader->getNodeType() == irr::io::EXN_TEXT) {
-        if (!mReader->read()) {
+    if (mReader->getNodeType() == irr::io::EXN_TEXT)
+        if (!mReader->read())
             ThrowException(format() << "Unexpected end of file while reading beginning of <" << pName << "> element.");
-        }
-    }
 
-    if (mReader->getNodeType() != irr::io::EXN_ELEMENT || strcmp(mReader->getNodeName(), pName) != 0) {
+    if (mReader->getNodeType() != irr::io::EXN_ELEMENT || strcmp(mReader->getNodeName(), pName) != 0)
         ThrowException(format() << "Expected start of <" << pName << "> element.");
-    }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Tests for the closing tag of the given element, throws an exception if not found
-void ColladaParser::TestClosing(const char* pName) {
-    // check if we have an empty (self-closing) element
-    if (mReader->isEmptyElement()) {
-        return;
-    }
-
+void ColladaParser::TestClosing(const char* pName)
+{
     // check if we're already on the closing tag and return right away
-    if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END && strcmp(mReader->getNodeName(), pName) == 0) {
+    if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END && strcmp(mReader->getNodeName(), pName) == 0)
         return;
-    }
 
     // if not, read some more
-    if (!mReader->read()) {
+    if (!mReader->read())
         ThrowException(format() << "Unexpected end of file while reading end of <" << pName << "> element.");
-    }
     // whitespace in front is ok, just read again if found
-    if (mReader->getNodeType() == irr::io::EXN_TEXT) {
-        if (!mReader->read()) {
+    if (mReader->getNodeType() == irr::io::EXN_TEXT)
+        if (!mReader->read())
             ThrowException(format() << "Unexpected end of file while reading end of <" << pName << "> element.");
-        }
-    }
 
     // but this has the be the closing tag, or we're lost
-    if (mReader->getNodeType() != irr::io::EXN_ELEMENT_END || strcmp(mReader->getNodeName(), pName) != 0) {
+    if (mReader->getNodeType() != irr::io::EXN_ELEMENT_END || strcmp(mReader->getNodeName(), pName) != 0)
         ThrowException(format() << "Expected end of <" << pName << "> element.");
-    }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Returns the index of the named attribute or -1 if not found. Does not throw, therefore useful for optional attributes
-int ColladaParser::GetAttribute(const char* pAttr) const {
+int ColladaParser::GetAttribute(const char* pAttr) const
+{
     int index = TestAttribute(pAttr);
-    if (index != -1) {
+    if (index != -1)
         return index;
-    }
 
     // attribute not found -> throw an exception
     ThrowException(format() << "Expected attribute \"" << pAttr << "\" for element <" << mReader->getNodeName() << ">.");
diff --git a/Engine/lib/assimp/code/Collada/ColladaParser.h b/Engine/lib/assimp/code/Collada/ColladaParser.h
index d1e812bd2..a2c9a4ff2 100644
--- a/Engine/lib/assimp/code/Collada/ColladaParser.h
+++ b/Engine/lib/assimp/code/Collada/ColladaParser.h
@@ -2,7 +2,7 @@
  Open Asset Import Library (assimp)
  ----------------------------------------------------------------------
 
- Copyright (c) 2006-2020, assimp team
+ Copyright (c) 2006-2019, assimp team
 
 
  All rights reserved.
@@ -66,15 +66,12 @@ namespace Assimp
     {
         friend class ColladaLoader;
 
-        /** Converts a path read from a collada file to the usual representation */
-        static void UriDecodePath(aiString& ss);
-
     protected:
         /** Map for generic metadata as aiString */
         typedef std::map<std::string, aiString> StringMetaData;
 
         /** Constructor from XML file */
-        ColladaParser(IOSystem* pIOHandler, const std::string& pFile);
+        ColladaParser( IOSystem* pIOHandler, const std::string& pFile);
 
         /** Destructor */
         ~ColladaParser();
@@ -94,9 +91,12 @@ namespace Assimp
         /** Reads contributor information such as author and legal blah */
         void ReadContributorInfo();
 
-        /** Reads generic metadata into provided map and renames keys for Assimp */
+        /** Reads generic metadata into provided map */
         void ReadMetaDataItem(StringMetaData &metadata);
 
+        /** Convert underscore_seperated to CamelCase "authoring_tool" becomes "AuthoringTool" */
+        static void ToCamelCase(std::string &text);
+
         /** Reads the animation library */
         void ReadAnimationLibrary();
 
diff --git a/Engine/lib/assimp/code/Common/Assimp.cpp b/Engine/lib/assimp/code/Common/Assimp.cpp
index 66588f0bc..178b2c01d 100644
--- a/Engine/lib/assimp/code/Common/Assimp.cpp
+++ b/Engine/lib/assimp/code/Common/Assimp.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/Common/BaseImporter.cpp b/Engine/lib/assimp/code/Common/BaseImporter.cpp
index 8d7b029ba..b77bbfe23 100644
--- a/Engine/lib/assimp/code/Common/BaseImporter.cpp
+++ b/Engine/lib/assimp/code/Common/BaseImporter.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -67,20 +67,7 @@ using namespace Assimp;
 // Constructor to be privately used by Importer
 BaseImporter::BaseImporter() AI_NO_EXCEPT
 : m_progress() {
-    /**
-    * Assimp Importer
-    * unit conversions available
-    * if you need another measurment unit add it below.
-    * it's currently defined in assimp that we prefer meters.
-    *
-    * NOTE: Initialised here rather than in the header file
-    * to workaround a VS2013 bug with brace initialisers
-    * */
-    importerUnits[ImporterUnits::M] = 1.0;
-    importerUnits[ImporterUnits::CM] = 0.01;
-    importerUnits[ImporterUnits::MM] = 0.001;
-    importerUnits[ImporterUnits::INCHES] = 0.0254;
-    importerUnits[ImporterUnits::FEET] = 0.3048;
+    // nothing to do here
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -191,7 +178,7 @@ void BaseImporter::GetExtensionList(std::set<std::string>& extensions) {
     }
 
     std::unique_ptr<IOStream> pStream (pIOHandler->Open(pFile));
-    if (pStream) {
+    if (pStream.get() ) {
         // read 200 characters from the file
         std::unique_ptr<char[]> _buffer (new char[searchBytes+1 /* for the '\0' */]);
         char *buffer( _buffer.get() );
@@ -283,6 +270,7 @@ std::string BaseImporter::GetExtension( const std::string& file ) {
         return "";
     }
 
+
     // thanks to Andy Maloney for the hint
     std::string ret = file.substr( pos + 1 );
     std::transform( ret.begin(), ret.end(), ret.begin(), ToLower<char>);
@@ -308,7 +296,7 @@ std::string BaseImporter::GetExtension( const std::string& file ) {
     };
     magic = reinterpret_cast<const char*>(_magic);
     std::unique_ptr<IOStream> pStream (pIOHandler->Open(pFile));
-    if (pStream) {
+    if (pStream.get() ) {
 
         // skip to offset
         pStream->Seek(offset,aiOrigin_SET);
@@ -602,7 +590,7 @@ unsigned int BatchLoader::AddLoadRequest(const std::string& file,
     }
 
     // no, we don't have it. So add it to the queue ...
-    m_data->requests.emplace_back(file, steps, map, m_data->next_id);
+    m_data->requests.push_back(LoadRequest(file,steps,map, m_data->next_id));
     return m_data->next_id++;
 }
 
diff --git a/Engine/lib/assimp/code/Common/BaseProcess.cpp b/Engine/lib/assimp/code/Common/BaseProcess.cpp
index d02653cf2..e247be418 100644
--- a/Engine/lib/assimp/code/Common/BaseProcess.cpp
+++ b/Engine/lib/assimp/code/Common/BaseProcess.cpp
@@ -3,7 +3,9 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
+
+
 
 All rights reserved.
 
@@ -41,43 +43,45 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** @file Implementation of BaseProcess */
 
-#include "BaseProcess.h"
-#include "Importer.h"
 #include <assimp/BaseImporter.h>
-#include <assimp/scene.h>
+#include "BaseProcess.h"
 #include <assimp/DefaultLogger.hpp>
+#include <assimp/scene.h>
+#include "Importer.h"
 
 using namespace Assimp;
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 BaseProcess::BaseProcess() AI_NO_EXCEPT
-        : shared(),
-          progress() {
-    // empty
+: shared()
+, progress()
+{
 }
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-BaseProcess::~BaseProcess() {
+BaseProcess::~BaseProcess()
+{
     // nothing to do here
 }
 
 // ------------------------------------------------------------------------------------------------
-void BaseProcess::ExecuteOnScene(Importer *pImp) {
-    ai_assert( nullptr != pImp );
-    ai_assert( nullptr != pImp->Pimpl()->mScene);
+void BaseProcess::ExecuteOnScene( Importer* pImp)
+{
+    ai_assert(NULL != pImp && NULL != pImp->Pimpl()->mScene);
 
     progress = pImp->GetProgressHandler();
-    ai_assert(nullptr != progress);
+    ai_assert(progress);
 
-    SetupProperties(pImp);
+    SetupProperties( pImp );
 
     // catch exceptions thrown inside the PostProcess-Step
-    try {
+    try
+    {
         Execute(pImp->Pimpl()->mScene);
 
-    } catch (const std::exception &err) {
+    } catch( const std::exception& err )    {
 
         // extract error description
         pImp->Pimpl()->mErrorString = err.what();
@@ -90,11 +94,14 @@ void BaseProcess::ExecuteOnScene(Importer *pImp) {
 }
 
 // ------------------------------------------------------------------------------------------------
-void BaseProcess::SetupProperties(const Importer * /*pImp*/) {
+void BaseProcess::SetupProperties(const Importer* /*pImp*/)
+{
     // the default implementation does nothing
 }
 
 // ------------------------------------------------------------------------------------------------
-bool BaseProcess::RequireVerboseFormat() const {
+bool BaseProcess::RequireVerboseFormat() const
+{
     return true;
 }
+
diff --git a/Engine/lib/assimp/code/Common/BaseProcess.h b/Engine/lib/assimp/code/Common/BaseProcess.h
index bf1f2586f..4d5c7a76b 100644
--- a/Engine/lib/assimp/code/Common/BaseProcess.h
+++ b/Engine/lib/assimp/code/Common/BaseProcess.h
@@ -2,7 +2,8 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
+
 
 All rights reserved.
 
@@ -43,13 +44,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef INCLUDED_AI_BASEPROCESS_H
 #define INCLUDED_AI_BASEPROCESS_H
 
-#include <assimp/GenericProperty.h>
-
 #include <map>
+#include <assimp/GenericProperty.h>
 
 struct aiScene;
 
-namespace Assimp {
+namespace Assimp    {
 
 class Importer;
 
@@ -60,50 +60,64 @@ class Importer;
  *  to provide additional information to other steps. This is primarily
  *  intended for cross-step optimizations.
  */
-class SharedPostProcessInfo {
+class SharedPostProcessInfo
+{
 public:
-    struct Base {
-        virtual ~Base() {}
+
+    struct Base
+    {
+        virtual ~Base()
+        {}
     };
 
     //! Represents data that is allocated on the heap, thus needs to be deleted
     template <typename T>
-    struct THeapData : public Base {
-        explicit THeapData(T *in) :
-                data(in) {}
+    struct THeapData : public Base
+    {
+        explicit THeapData(T* in)
+            : data (in)
+        {}
 
-        ~THeapData() {
+        ~THeapData()
+        {
             delete data;
         }
-        T *data;
+        T* data;
     };
 
     //! Represents static, by-value data not allocated on the heap
     template <typename T>
-    struct TStaticData : public Base {
-        explicit TStaticData(T in) :
-                data(in) {}
+    struct TStaticData : public Base
+    {
+        explicit TStaticData(T in)
+            : data (in)
+        {}
 
-        ~TStaticData() {}
+        ~TStaticData()
+        {}
 
         T data;
     };
 
     // some typedefs for cleaner code
     typedef unsigned int KeyType;
-    typedef std::map<KeyType, Base *> PropertyMap;
+    typedef std::map<KeyType, Base*>  PropertyMap;
 
 public:
+
     //! Destructor
-    ~SharedPostProcessInfo() {
+    ~SharedPostProcessInfo()
+    {
         Clean();
     }
 
     //! Remove all stored properties from the table
-    void Clean() {
+    void Clean()
+    {
         // invoke the virtual destructor for all stored properties
         for (PropertyMap::iterator it = pmap.begin(), end = pmap.end();
-                it != end; ++it) {
+             it != end; ++it)
+        {
             delete (*it).second;
         }
         pmap.clear();
@@ -111,21 +125,24 @@ public:
 
     //! Add a heap property to the list
     template <typename T>
-    void AddProperty(const char *name, T *in) {
-        AddProperty(name, (Base *)new THeapData<T>(in));
+    void AddProperty( const char* name, T* in ){
+        AddProperty(name,(Base*)new THeapData<T>(in));
     }
 
     //! Add a static by-value property to the list
     template <typename T>
-    void AddProperty(const char *name, T in) {
-        AddProperty(name, (Base *)new TStaticData<T>(in));
+    void AddProperty( const char* name, T in ){
+        AddProperty(name,(Base*)new TStaticData<T>(in));
     }
 
+
     //! Get a heap property
     template <typename T>
-    bool GetProperty(const char *name, T *&out) const {
-        THeapData<T> *t = (THeapData<T> *)GetPropertyInternal(name);
-        if (!t) {
+    bool GetProperty( const char* name, T*& out ) const
+    {
+        THeapData<T>* t = (THeapData<T>*)GetPropertyInternal(name);
+        if(!t)
+        {
             out = NULL;
             return false;
         }
@@ -135,34 +152,53 @@ public:
 
     //! Get a static, by-value property
     template <typename T>
-    bool GetProperty(const char *name, T &out) const {
-        TStaticData<T> *t = (TStaticData<T> *)GetPropertyInternal(name);
-        if ( nullptr == t) {
-            return false;
-        }
+    bool GetProperty( const char* name, T& out ) const
+    {
+        TStaticData<T>* t = (TStaticData<T>*)GetPropertyInternal(name);
+        if(!t)return false;
         out = t->data;
         return true;
     }
 
     //! Remove a property of a specific type
-    void RemoveProperty(const char *name) {
-        SetGenericPropertyPtr<Base>(pmap, name, nullptr );
+    void RemoveProperty( const char* name)  {
+        SetGenericPropertyPtr<Base>(pmap,name,NULL);
     }
 
 private:
-    void AddProperty(const char *name, Base *data) {
-        SetGenericPropertyPtr<Base>(pmap, name, data);
+
+    void AddProperty( const char* name, Base* data) {
+        SetGenericPropertyPtr<Base>(pmap,name,data);
     }
 
-    Base *GetPropertyInternal(const char *name) const {
-        return GetGenericProperty<Base *>(pmap, name, nullptr );
+    Base* GetPropertyInternal( const char* name) const  {
+        return GetGenericProperty<Base*>(pmap,name,NULL);
     }
 
 private:
+
     //! Map of all stored properties
     PropertyMap pmap;
 };
 
+#if 0
+
+// ---------------------------------------------------------------------------
+/** @brief Represents a dependency table for a postprocessing steps.
+ *
+ *  For future use.
+ */
+ struct PPDependencyTable
+ {
+     unsigned int execute_me_before_these;
+     unsigned int execute_me_after_these;
+     unsigned int only_if_these_are_not_specified;
+     unsigned int mutually_exclusive_with;
+ };
+
+#endif
+
+
 #define AI_SPP_SPATIAL_SORT "$Spat"
 
 // ---------------------------------------------------------------------------
@@ -192,7 +228,7 @@ public:
      * @return true if the process is present in this flag fields,
      *   false if not.
     */
-    virtual bool IsActive(unsigned int pFlags) const = 0;
+    virtual bool IsActive( unsigned int pFlags) const = 0;
 
     // -------------------------------------------------------------------
     /** Check whether this step expects its input vertex data to be
@@ -205,14 +241,14 @@ public:
     * the object pointer will be set to NULL).
     * @param pImp Importer instance (pImp->mScene must be valid)
     */
-    void ExecuteOnScene(Importer *pImp);
+    void ExecuteOnScene( Importer* pImp);
 
     // -------------------------------------------------------------------
     /** Called prior to ExecuteOnScene().
     * The function is a request to the process to update its configuration
     * basing on the Importer's configuration property list.
     */
-    virtual void SetupProperties(const Importer *pImp);
+    virtual void SetupProperties(const Importer* pImp);
 
     // -------------------------------------------------------------------
     /** Executes the post processing step on the given imported data.
@@ -220,32 +256,35 @@ public:
     * This method must be implemented by deriving classes.
     * @param pScene The imported data to work at.
     */
-    virtual void Execute(aiScene *pScene) = 0;
+    virtual void Execute( aiScene* pScene) = 0;
+
 
     // -------------------------------------------------------------------
     /** Assign a new SharedPostProcessInfo to the step. This object
      *  allows multiple postprocess steps to share data.
      * @param sh May be NULL
     */
-    inline void SetSharedData(SharedPostProcessInfo *sh) {
+    inline void SetSharedData(SharedPostProcessInfo* sh)    {
         shared = sh;
     }
 
     // -------------------------------------------------------------------
     /** Get the shared data that is assigned to the step.
     */
-    inline SharedPostProcessInfo *GetSharedData() {
+    inline SharedPostProcessInfo* GetSharedData()   {
         return shared;
     }
 
 protected:
+
     /** See the doc of #SharedPostProcessInfo for more details */
-    SharedPostProcessInfo *shared;
+    SharedPostProcessInfo* shared;
 
     /** Currently active progress handler */
-    ProgressHandler *progress;
+    ProgressHandler* progress;
 };
 
+
 } // end of namespace Assimp
 
 #endif // AI_BASEPROCESS_H_INC
diff --git a/Engine/lib/assimp/code/Common/Bitmap.cpp b/Engine/lib/assimp/code/Common/Bitmap.cpp
index 7d8225704..b22b71ea9 100644
--- a/Engine/lib/assimp/code/Common/Bitmap.cpp
+++ b/Engine/lib/assimp/code/Common/Bitmap.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/Common/CreateAnimMesh.cpp b/Engine/lib/assimp/code/Common/CreateAnimMesh.cpp
index 7317dc45b..98b60e531 100644
--- a/Engine/lib/assimp/code/Common/CreateAnimMesh.cpp
+++ b/Engine/lib/assimp/code/Common/CreateAnimMesh.cpp
@@ -4,7 +4,7 @@ Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
 Copyright (C) 2016 The Qt Company Ltd.
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2012, assimp team
 
 All rights reserved.
 
diff --git a/Engine/lib/assimp/code/Common/DefaultIOStream.cpp b/Engine/lib/assimp/code/Common/DefaultIOStream.cpp
index 205f19e37..1c100b618 100644
--- a/Engine/lib/assimp/code/Common/DefaultIOStream.cpp
+++ b/Engine/lib/assimp/code/Common/DefaultIOStream.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -52,35 +52,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 using namespace Assimp;
 
-namespace
-{
-    template<size_t sizeOfPointer>
-    size_t select_ftell(FILE* file)
-    {
-        return ::ftell(file);
-    }
-
-    template<size_t sizeOfPointer>
-    int select_fseek(FILE* file, int64_t offset, int origin)
-    {
-        return ::fseek(file, static_cast<long>(offset), origin);
-    }
-
-#if defined _WIN32 && (!defined __GNUC__ || __MSVCRT_VERSION__ >= 0x0601)
-    template<>
-    size_t select_ftell<8>(FILE* file)
-    {
-        return ::_ftelli64(file);
-    }
-
-    template<>
-    int select_fseek<8>(FILE* file, int64_t offset, int origin)
-    {
-        return ::_fseeki64(file, offset, origin);
-    }
-#endif
-}
-
 // ----------------------------------------------------------------------------------
 DefaultIOStream::~DefaultIOStream()
 {
@@ -122,7 +93,7 @@ aiReturn DefaultIOStream::Seek(size_t pOffset,
         aiOrigin_END == SEEK_END && aiOrigin_SET == SEEK_SET");
 
     // do the seek
-    return (0 == select_fseek<sizeof(void*)>(mFile, (int64_t)pOffset,(int)pOrigin) ? AI_SUCCESS : AI_FAILURE);
+    return (0 == ::fseek(mFile, (long)pOffset,(int)pOrigin) ? AI_SUCCESS : AI_FAILURE);
 }
 
 // ----------------------------------------------------------------------------------
@@ -131,7 +102,7 @@ size_t DefaultIOStream::Tell() const
     if (!mFile) {
         return 0;
     }
-    return select_ftell<sizeof(void*)>(mFile);
+    return ::ftell(mFile);
 }
 
 // ----------------------------------------------------------------------------------
diff --git a/Engine/lib/assimp/code/Common/DefaultIOSystem.cpp b/Engine/lib/assimp/code/Common/DefaultIOSystem.cpp
index 0343cb289..6fdc24dd8 100644
--- a/Engine/lib/assimp/code/Common/DefaultIOSystem.cpp
+++ b/Engine/lib/assimp/code/Common/DefaultIOSystem.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/Common/DefaultLogger.cpp b/Engine/lib/assimp/code/Common/DefaultLogger.cpp
index adb9ba160..de3528d2b 100644
--- a/Engine/lib/assimp/code/Common/DefaultLogger.cpp
+++ b/Engine/lib/assimp/code/Common/DefaultLogger.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -107,7 +107,7 @@ LogStream* LogStream::createDefaultStream(aiDefaultLogStream    streams,
         return nullptr;
 #endif
 
-    // Platform-independent default streams
+        // Platform-independent default streams
     case aiDefaultLogStream_STDERR:
         return new StdOStreamLogStream(std::cerr);
     case aiDefaultLogStream_STDOUT:
@@ -121,7 +121,7 @@ LogStream* LogStream::createDefaultStream(aiDefaultLogStream    streams,
     };
 
     // For compilers without dead code path detection
-    return nullptr;
+    return NULL;
 }
 
 // ----------------------------------------------------------------------------------
diff --git a/Engine/lib/assimp/code/Common/DefaultProgressHandler.h b/Engine/lib/assimp/code/Common/DefaultProgressHandler.h
index ebf7f118c..bd2cce00b 100644
--- a/Engine/lib/assimp/code/Common/DefaultProgressHandler.h
+++ b/Engine/lib/assimp/code/Common/DefaultProgressHandler.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Common/Exporter.cpp b/Engine/lib/assimp/code/Common/Exporter.cpp
index 9f9a33b58..34d49c472 100644
--- a/Engine/lib/assimp/code/Common/Exporter.cpp
+++ b/Engine/lib/assimp/code/Common/Exporter.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -102,92 +102,94 @@ void ExportSceneX3D(const char*, IOSystem*, const aiScene*, const ExportProperti
 void ExportSceneFBX(const char*, IOSystem*, const aiScene*, const ExportProperties*);
 void ExportSceneFBXA(const char*, IOSystem*, const aiScene*, const ExportProperties*);
 void ExportScene3MF( const char*, IOSystem*, const aiScene*, const ExportProperties* );
-void ExportSceneM3D(const char*, IOSystem*, const aiScene*, const ExportProperties*);
-void ExportSceneM3DA(const char*, IOSystem*, const aiScene*, const ExportProperties*);
 void ExportAssimp2Json(const char* , IOSystem*, const aiScene* , const Assimp::ExportProperties*);
 
-
-static void setupExporterArray(std::vector<Exporter::ExportFormatEntry> &exporters) {
+// ------------------------------------------------------------------------------------------------
+// global array of all export formats which Assimp supports in its current build
+Exporter::ExportFormatEntry gExporters[] =
+{
 #ifndef ASSIMP_BUILD_NO_COLLADA_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("collada", "COLLADA - Digital Asset Exchange Schema", "dae", &ExportSceneCollada));
+    Exporter::ExportFormatEntry( "collada", "COLLADA - Digital Asset Exchange Schema", "dae", &ExportSceneCollada ),
 #endif
 
 #ifndef ASSIMP_BUILD_NO_X_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("x", "X Files", "x", &ExportSceneXFile,
-			aiProcess_MakeLeftHanded | aiProcess_FlipWindingOrder | aiProcess_FlipUVs));
+    Exporter::ExportFormatEntry( "x", "X Files", "x", &ExportSceneXFile,
+        aiProcess_MakeLeftHanded | aiProcess_FlipWindingOrder | aiProcess_FlipUVs ),
 #endif
 
 #ifndef ASSIMP_BUILD_NO_STEP_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("stp", "Step Files", "stp", &ExportSceneStep, 0));
+    Exporter::ExportFormatEntry( "stp", "Step Files", "stp", &ExportSceneStep, 0 ),
 #endif
 
 #ifndef ASSIMP_BUILD_NO_OBJ_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("obj", "Wavefront OBJ format", "obj", &ExportSceneObj,
-			aiProcess_GenSmoothNormals /*| aiProcess_PreTransformVertices */));
-	exporters.push_back(Exporter::ExportFormatEntry("objnomtl", "Wavefront OBJ format without material file", "obj", &ExportSceneObjNoMtl,
-			aiProcess_GenSmoothNormals /*| aiProcess_PreTransformVertices */));
+    Exporter::ExportFormatEntry( "obj", "Wavefront OBJ format", "obj", &ExportSceneObj,
+        aiProcess_GenSmoothNormals /*| aiProcess_PreTransformVertices */ ),
+    Exporter::ExportFormatEntry( "objnomtl", "Wavefront OBJ format without material file", "obj", &ExportSceneObjNoMtl,
+        aiProcess_GenSmoothNormals /*| aiProcess_PreTransformVertices */ ),
 #endif
 
 #ifndef ASSIMP_BUILD_NO_STL_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("stl", "Stereolithography", "stl", &ExportSceneSTL,
-			aiProcess_Triangulate | aiProcess_GenNormals | aiProcess_PreTransformVertices));
-	exporters.push_back(Exporter::ExportFormatEntry("stlb", "Stereolithography (binary)", "stl", &ExportSceneSTLBinary,
-			aiProcess_Triangulate | aiProcess_GenNormals | aiProcess_PreTransformVertices));
+    Exporter::ExportFormatEntry( "stl", "Stereolithography", "stl" , &ExportSceneSTL,
+        aiProcess_Triangulate | aiProcess_GenNormals | aiProcess_PreTransformVertices
+    ),
+    Exporter::ExportFormatEntry( "stlb", "Stereolithography (binary)", "stl" , &ExportSceneSTLBinary,
+        aiProcess_Triangulate | aiProcess_GenNormals | aiProcess_PreTransformVertices
+    ),
 #endif
 
 #ifndef ASSIMP_BUILD_NO_PLY_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("ply", "Stanford Polygon Library", "ply", &ExportScenePly,
-			aiProcess_PreTransformVertices));
-	exporters.push_back(Exporter::ExportFormatEntry("plyb", "Stanford Polygon Library (binary)", "ply", &ExportScenePlyBinary,
-			aiProcess_PreTransformVertices));
+    Exporter::ExportFormatEntry( "ply", "Stanford Polygon Library", "ply" , &ExportScenePly,
+        aiProcess_PreTransformVertices
+    ),
+    Exporter::ExportFormatEntry( "plyb", "Stanford Polygon Library (binary)", "ply", &ExportScenePlyBinary,
+        aiProcess_PreTransformVertices
+    ),
 #endif
 
 #ifndef ASSIMP_BUILD_NO_3DS_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("3ds", "Autodesk 3DS (legacy)", "3ds", &ExportScene3DS,
-			aiProcess_Triangulate | aiProcess_SortByPType | aiProcess_JoinIdenticalVertices));
+    Exporter::ExportFormatEntry( "3ds", "Autodesk 3DS (legacy)", "3ds" , &ExportScene3DS,
+        aiProcess_Triangulate | aiProcess_SortByPType | aiProcess_JoinIdenticalVertices ),
 #endif
 
 #ifndef ASSIMP_BUILD_NO_GLTF_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("gltf2", "GL Transmission Format v. 2", "gltf", &ExportSceneGLTF2,
-			aiProcess_JoinIdenticalVertices | aiProcess_Triangulate | aiProcess_SortByPType));
-	exporters.push_back(Exporter::ExportFormatEntry("glb2", "GL Transmission Format v. 2 (binary)", "glb", &ExportSceneGLB2,
-			aiProcess_JoinIdenticalVertices | aiProcess_Triangulate | aiProcess_SortByPType));
-	exporters.push_back(Exporter::ExportFormatEntry("gltf", "GL Transmission Format", "gltf", &ExportSceneGLTF,
-			aiProcess_JoinIdenticalVertices | aiProcess_Triangulate | aiProcess_SortByPType));
-	exporters.push_back(Exporter::ExportFormatEntry("glb", "GL Transmission Format (binary)", "glb", &ExportSceneGLB,
-			aiProcess_JoinIdenticalVertices | aiProcess_Triangulate | aiProcess_SortByPType));
+    Exporter::ExportFormatEntry( "gltf2", "GL Transmission Format v. 2", "gltf", &ExportSceneGLTF2,
+        aiProcess_JoinIdenticalVertices | aiProcess_Triangulate | aiProcess_SortByPType ),
+    Exporter::ExportFormatEntry( "glb2", "GL Transmission Format v. 2 (binary)", "glb", &ExportSceneGLB2,
+        aiProcess_JoinIdenticalVertices | aiProcess_Triangulate | aiProcess_SortByPType ),
+    Exporter::ExportFormatEntry( "gltf", "GL Transmission Format", "gltf", &ExportSceneGLTF,
+        aiProcess_JoinIdenticalVertices | aiProcess_Triangulate | aiProcess_SortByPType ),
+    Exporter::ExportFormatEntry( "glb", "GL Transmission Format (binary)", "glb", &ExportSceneGLB,
+        aiProcess_JoinIdenticalVertices | aiProcess_Triangulate | aiProcess_SortByPType ),
 #endif
 
 #ifndef ASSIMP_BUILD_NO_ASSBIN_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("assbin", "Assimp Binary File", "assbin", &ExportSceneAssbin, 0));
+    Exporter::ExportFormatEntry( "assbin", "Assimp Binary File", "assbin" , &ExportSceneAssbin, 0 ),
 #endif
 
 #ifndef ASSIMP_BUILD_NO_ASSXML_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("assxml", "Assimp XML Document", "assxml", &ExportSceneAssxml, 0));
+    Exporter::ExportFormatEntry( "assxml", "Assimp XML Document", "assxml" , &ExportSceneAssxml, 0 ),
 #endif
 
 #ifndef ASSIMP_BUILD_NO_X3D_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("x3d", "Extensible 3D", "x3d", &ExportSceneX3D, 0));
+    Exporter::ExportFormatEntry( "x3d", "Extensible 3D", "x3d" , &ExportSceneX3D, 0 ),
 #endif
 
 #ifndef ASSIMP_BUILD_NO_FBX_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("fbx", "Autodesk FBX (binary)", "fbx", &ExportSceneFBX, 0));
-	exporters.push_back(Exporter::ExportFormatEntry("fbxa", "Autodesk FBX (ascii)", "fbx", &ExportSceneFBXA, 0));
-#endif
-
-#ifndef ASSIMP_BUILD_NO_M3D_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("m3d", "Model 3D (binary)", "m3d", &ExportSceneM3D, 0));
-	exporters.push_back(Exporter::ExportFormatEntry("m3da", "Model 3D (ascii)", "a3d", &ExportSceneM3DA, 0));
+    Exporter::ExportFormatEntry( "fbx", "Autodesk FBX (binary)", "fbx", &ExportSceneFBX, 0 ),
+    Exporter::ExportFormatEntry( "fbxa", "Autodesk FBX (ascii)", "fbx", &ExportSceneFBXA, 0 ),
 #endif
 
 #ifndef ASSIMP_BUILD_NO_3MF_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("3mf", "The 3MF-File-Format", "3mf", &ExportScene3MF, 0));
+    Exporter::ExportFormatEntry( "3mf", "The 3MF-File-Format", "3mf", &ExportScene3MF, 0 ),
 #endif
 
 #ifndef ASSIMP_BUILD_NO_ASSJSON_EXPORTER
-	exporters.push_back(Exporter::ExportFormatEntry("assjson", "Assimp JSON Document", "json", &ExportAssimp2Json, 0));
+    Exporter::ExportFormatEntry( "assjson", "Assimp JSON Document", "json", &ExportAssimp2Json, 0)
 #endif
-}
+};
+
+#define ASSIMP_NUM_EXPORTERS (sizeof(gExporters)/sizeof(gExporters[0]))
+
 
 class ExporterPimpl {
 public:
@@ -203,7 +205,10 @@ public:
         GetPostProcessingStepInstanceList(mPostProcessingSteps);
 
         // grab all built-in exporters
-		setupExporterArray(mExporters);
+        if ( 0 != ( ASSIMP_NUM_EXPORTERS ) ) {
+            mExporters.resize( ASSIMP_NUM_EXPORTERS );
+            std::copy( gExporters, gExporters + ASSIMP_NUM_EXPORTERS, mExporters.begin() );
+        }
     }
 
     ~ExporterPimpl() {
@@ -247,28 +252,24 @@ Exporter :: Exporter()
 
 // ------------------------------------------------------------------------------------------------
 Exporter::~Exporter() {
-	ai_assert(nullptr != pimpl);
-	FreeBlob();
+    FreeBlob();
     delete pimpl;
 }
 
 // ------------------------------------------------------------------------------------------------
 void Exporter::SetIOHandler( IOSystem* pIOHandler) {
-	ai_assert(nullptr != pimpl);
-	pimpl->mIsDefaultIOHandler = !pIOHandler;
+    pimpl->mIsDefaultIOHandler = !pIOHandler;
     pimpl->mIOSystem.reset(pIOHandler);
 }
 
 // ------------------------------------------------------------------------------------------------
 IOSystem* Exporter::GetIOHandler() const {
-	ai_assert(nullptr != pimpl);
-	return pimpl->mIOSystem.get();
+    return pimpl->mIOSystem.get();
 }
 
 // ------------------------------------------------------------------------------------------------
 bool Exporter::IsDefaultIOHandler() const {
-	ai_assert(nullptr != pimpl);
-	return pimpl->mIsDefaultIOHandler;
+    return pimpl->mIsDefaultIOHandler;
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -294,7 +295,6 @@ void Exporter::SetProgressHandler(ProgressHandler* pHandler) {
 // ------------------------------------------------------------------------------------------------
 const aiExportDataBlob* Exporter::ExportToBlob( const aiScene* pScene, const char* pFormatId,
                                                 unsigned int pPreprocessing, const ExportProperties* pProperties) {
-	ai_assert(nullptr != pimpl);
     if (pimpl->blob) {
         delete pimpl->blob;
         pimpl->blob = nullptr;
@@ -319,7 +319,7 @@ const aiExportDataBlob* Exporter::ExportToBlob( const aiScene* pScene, const cha
 aiReturn Exporter::Export( const aiScene* pScene, const char* pFormatId, const char* pPath,
         unsigned int pPreprocessing, const ExportProperties* pProperties) {
     ASSIMP_BEGIN_EXCEPTION_REGION();
-	ai_assert(nullptr != pimpl);
+
     // when they create scenes from scratch, users will likely create them not in verbose
     // format. They will likely not be aware that there is a flag in the scene to indicate
     // this, however. To avoid surprises and bug reports, we check for duplicates in
@@ -445,7 +445,8 @@ aiReturn Exporter::Export( const aiScene* pScene, const char* pFormatId, const c
 
                 ExportProperties emptyProperties;  // Never pass NULL ExportProperties so Exporters don't have to worry.
                 ExportProperties* pProp = pProperties ? (ExportProperties*)pProperties : &emptyProperties;
-        		pProp->SetPropertyBool("bJoinIdenticalVertices", pp & aiProcess_JoinIdenticalVertices);
+                                pProp->SetPropertyBool("bJoinIdenticalVertices", must_join_again);
+                                exp.mExportFunction(pPath,pimpl->mIOSystem.get(),scenecopy.get(), pProp);
                 exp.mExportFunction(pPath,pimpl->mIOSystem.get(),scenecopy.get(), pProp);
 
                 pimpl->mProgressHandler->UpdateFileWrite(4, 4);
@@ -465,13 +466,11 @@ aiReturn Exporter::Export( const aiScene* pScene, const char* pFormatId, const c
 
 // ------------------------------------------------------------------------------------------------
 const char* Exporter::GetErrorString() const {
-	ai_assert(nullptr != pimpl);
     return pimpl->mError.c_str();
 }
 
 // ------------------------------------------------------------------------------------------------
 void Exporter::FreeBlob() {
-	ai_assert(nullptr != pimpl);
     delete pimpl->blob;
     pimpl->blob = nullptr;
 
@@ -480,34 +479,30 @@ void Exporter::FreeBlob() {
 
 // ------------------------------------------------------------------------------------------------
 const aiExportDataBlob* Exporter::GetBlob() const {
-	ai_assert(nullptr != pimpl);
-	return pimpl->blob;
+    return pimpl->blob;
 }
 
 // ------------------------------------------------------------------------------------------------
 const aiExportDataBlob* Exporter::GetOrphanedBlob() const {
-	ai_assert(nullptr != pimpl);
-	const aiExportDataBlob *tmp = pimpl->blob;
+    const aiExportDataBlob* tmp = pimpl->blob;
     pimpl->blob = nullptr;
     return tmp;
 }
 
 // ------------------------------------------------------------------------------------------------
 size_t Exporter::GetExportFormatCount() const {
-	ai_assert(nullptr != pimpl);
     return pimpl->mExporters.size();
 }
 
 // ------------------------------------------------------------------------------------------------
 const aiExportFormatDesc* Exporter::GetExportFormatDescription( size_t index ) const {
-	ai_assert(nullptr != pimpl);
-	if (index >= GetExportFormatCount()) {
+    if (index >= GetExportFormatCount()) {
         return nullptr;
     }
 
     // Return from static storage if the requested index is built-in.
-	if (index < pimpl->mExporters.size()) {
-		return &pimpl->mExporters[index].mDescription;
+    if (index < sizeof(gExporters) / sizeof(gExporters[0])) {
+        return &gExporters[index].mDescription;
     }
 
     return &pimpl->mExporters[index].mDescription;
@@ -515,8 +510,7 @@ const aiExportFormatDesc* Exporter::GetExportFormatDescription( size_t index ) c
 
 // ------------------------------------------------------------------------------------------------
 aiReturn Exporter::RegisterExporter(const ExportFormatEntry& desc) {
-	ai_assert(nullptr != pimpl);
-	for (const ExportFormatEntry &e : pimpl->mExporters) {
+    for(const ExportFormatEntry& e : pimpl->mExporters) {
         if (!strcmp(e.mDescription.id,desc.mDescription.id)) {
             return aiReturn_FAILURE;
         }
@@ -528,8 +522,7 @@ aiReturn Exporter::RegisterExporter(const ExportFormatEntry& desc) {
 
 // ------------------------------------------------------------------------------------------------
 void Exporter::UnregisterExporter(const char* id) {
-	ai_assert(nullptr != pimpl);
-	for (std::vector<ExportFormatEntry>::iterator it = pimpl->mExporters.begin();
+    for(std::vector<ExportFormatEntry>::iterator it = pimpl->mExporters.begin();
             it != pimpl->mExporters.end(); ++it) {
         if (!strcmp((*it).mDescription.id,id)) {
             pimpl->mExporters.erase(it);
diff --git a/Engine/lib/assimp/code/Common/FileLogStream.h b/Engine/lib/assimp/code/Common/FileLogStream.h
index ecff03a7e..740c50319 100644
--- a/Engine/lib/assimp/code/Common/FileLogStream.h
+++ b/Engine/lib/assimp/code/Common/FileLogStream.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
diff --git a/Engine/lib/assimp/code/Common/FileSystemFilter.h b/Engine/lib/assimp/code/Common/FileSystemFilter.h
index 1440cf97d..9923cdbdd 100644
--- a/Engine/lib/assimp/code/Common/FileSystemFilter.h
+++ b/Engine/lib/assimp/code/Common/FileSystemFilter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2008, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
diff --git a/Engine/lib/assimp/code/Common/Importer.cpp b/Engine/lib/assimp/code/Common/Importer.cpp
index a59ec9812..91b50859a 100644
--- a/Engine/lib/assimp/code/Common/Importer.cpp
+++ b/Engine/lib/assimp/code/Common/Importer.cpp
@@ -3,7 +3,9 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
+
+
 
 All rights reserved.
 
@@ -76,8 +78,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/TinyFormatter.h>
 #include <assimp/Exceptional.h>
 #include <assimp/Profiler.h>
-#include <assimp/commonMetaData.h>
-
 #include <set>
 #include <memory>
 #include <cctype>
@@ -119,7 +119,7 @@ void* AllocateFromAssimpHeap::operator new ( size_t num_bytes, const std::nothro
         return AllocateFromAssimpHeap::operator new( num_bytes );
     }
     catch( ... )    {
-        return nullptr;
+        return NULL;
     }
 }
 
@@ -134,8 +134,9 @@ void* AllocateFromAssimpHeap::operator new[] ( size_t num_bytes)    {
 void* AllocateFromAssimpHeap::operator new[] ( size_t num_bytes, const std::nothrow_t& ) throw() {
     try {
         return AllocateFromAssimpHeap::operator new[]( num_bytes );
-    } catch( ... )    {
-        return nullptr;
+    }
+    catch( ... )    {
+        return NULL;
     }
 }
 
@@ -147,7 +148,7 @@ void AllocateFromAssimpHeap::operator delete[] ( void* data)    {
 // Importer constructor.
 Importer::Importer()
  : pimpl( new ImporterPimpl ) {
-    pimpl->mScene = nullptr;
+    pimpl->mScene = NULL;
     pimpl->mErrorString = "";
 
     // Allocate a default IO handler
@@ -173,14 +174,14 @@ Importer::Importer()
 
 // ------------------------------------------------------------------------------------------------
 // Destructor of Importer
-Importer::~Importer() {
+Importer::~Importer()
+{
     // Delete all import plugins
 	DeleteImporterInstanceList(pimpl->mImporter);
 
     // Delete all post-processing plug-ins
-    for( unsigned int a = 0; a < pimpl->mPostProcessingSteps.size(); ++a ) {
+    for( unsigned int a = 0; a < pimpl->mPostProcessingSteps.size(); a++)
         delete pimpl->mPostProcessingSteps[a];
-    }
 
     // Delete the assigned IO and progress handler
     delete pimpl->mIOHandler;
@@ -198,9 +199,9 @@ Importer::~Importer() {
 
 // ------------------------------------------------------------------------------------------------
 // Register a custom post-processing step
-aiReturn Importer::RegisterPPStep(BaseProcess* pImp) {
-    ai_assert( nullptr != pImp );
-    
+aiReturn Importer::RegisterPPStep(BaseProcess* pImp)
+{
+    ai_assert(NULL != pImp);
     ASSIMP_BEGIN_EXCEPTION_REGION();
 
         pimpl->mPostProcessingSteps.push_back(pImp);
@@ -212,9 +213,9 @@ aiReturn Importer::RegisterPPStep(BaseProcess* pImp) {
 
 // ------------------------------------------------------------------------------------------------
 // Register a custom loader plugin
-aiReturn Importer::RegisterLoader(BaseImporter* pImp) {
-    ai_assert(nullptr != pImp);
-    
+aiReturn Importer::RegisterLoader(BaseImporter* pImp)
+{
+    ai_assert(NULL != pImp);
     ASSIMP_BEGIN_EXCEPTION_REGION();
 
     // --------------------------------------------------------------------
@@ -241,13 +242,13 @@ aiReturn Importer::RegisterLoader(BaseImporter* pImp) {
     pimpl->mImporter.push_back(pImp);
     ASSIMP_LOG_INFO_F("Registering custom importer for these file extensions: ", baked);
     ASSIMP_END_EXCEPTION_REGION(aiReturn);
-    
     return AI_SUCCESS;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Unregister a custom loader plugin
-aiReturn Importer::UnregisterLoader(BaseImporter* pImp) {
+aiReturn Importer::UnregisterLoader(BaseImporter* pImp)
+{
     if(!pImp) {
         // unregistering a NULL importer is no problem for us ... really!
         return AI_SUCCESS;
@@ -264,13 +265,13 @@ aiReturn Importer::UnregisterLoader(BaseImporter* pImp) {
     }
     ASSIMP_LOG_WARN("Unable to remove custom importer: I can't find you ...");
     ASSIMP_END_EXCEPTION_REGION(aiReturn);
-
     return AI_FAILURE;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Unregister a custom loader plugin
-aiReturn Importer::UnregisterPPStep(BaseProcess* pImp) {
+aiReturn Importer::UnregisterPPStep(BaseProcess* pImp)
+{
     if(!pImp) {
         // unregistering a NULL ppstep is no problem for us ... really!
         return AI_SUCCESS;
@@ -287,22 +288,24 @@ aiReturn Importer::UnregisterPPStep(BaseProcess* pImp) {
     }
     ASSIMP_LOG_WARN("Unable to remove custom post-processing step: I can't find you ..");
     ASSIMP_END_EXCEPTION_REGION(aiReturn);
-
     return AI_FAILURE;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Supplies a custom IO handler to the importer to open and access files.
-void Importer::SetIOHandler( IOSystem* pIOHandler) {
-    ai_assert(nullptr != pimpl);
-    
+void Importer::SetIOHandler( IOSystem* pIOHandler)
+{
     ASSIMP_BEGIN_EXCEPTION_REGION();
     // If the new handler is zero, allocate a default IO implementation.
-    if (!pIOHandler) {
+    if (!pIOHandler)
+    {
         // Release pointer in the possession of the caller
         pimpl->mIOHandler = new DefaultIOSystem();
         pimpl->mIsDefaultHandler = true;
-    } else if (pimpl->mIOHandler != pIOHandler) { // Otherwise register the custom handler
+    }
+    // Otherwise register the custom handler
+    else if (pimpl->mIOHandler != pIOHandler)
+    {
         delete pimpl->mIOHandler;
         pimpl->mIOHandler = pIOHandler;
         pimpl->mIsDefaultHandler = false;
@@ -313,32 +316,29 @@ void Importer::SetIOHandler( IOSystem* pIOHandler) {
 // ------------------------------------------------------------------------------------------------
 // Get the currently set IO handler
 IOSystem* Importer::GetIOHandler() const {
-    ai_assert(nullptr != pimpl);
-    
     return pimpl->mIOHandler;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Check whether a custom IO handler is currently set
 bool Importer::IsDefaultIOHandler() const {
-    ai_assert(nullptr != pimpl);
-    
     return pimpl->mIsDefaultHandler;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Supplies a custom progress handler to get regular callbacks during importing
 void Importer::SetProgressHandler ( ProgressHandler* pHandler ) {
-    ai_assert(nullptr != pimpl);
-    
     ASSIMP_BEGIN_EXCEPTION_REGION();
-    
     // If the new handler is zero, allocate a default implementation.
-    if (!pHandler) {
+    if (!pHandler)
+    {
         // Release pointer in the possession of the caller
         pimpl->mProgressHandler = new DefaultProgressHandler();
         pimpl->mIsDefaultProgressHandler = true;
-    } else if (pimpl->mProgressHandler != pHandler) { // Otherwise register the custom handler
+    }
+    // Otherwise register the custom handler
+    else if (pimpl->mProgressHandler != pHandler)
+    {
         delete pimpl->mProgressHandler;
         pimpl->mProgressHandler = pHandler;
         pimpl->mIsDefaultProgressHandler = false;
@@ -349,22 +349,19 @@ void Importer::SetProgressHandler ( ProgressHandler* pHandler ) {
 // ------------------------------------------------------------------------------------------------
 // Get the currently set progress handler
 ProgressHandler* Importer::GetProgressHandler() const {
-    ai_assert(nullptr != pimpl);
-    
     return pimpl->mProgressHandler;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Check whether a custom progress handler is currently set
 bool Importer::IsDefaultProgressHandler() const {
-    ai_assert(nullptr != pimpl);
-    
     return pimpl->mIsDefaultProgressHandler;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Validate post process step flags
-bool _ValidateFlags(unsigned int pFlags) {
+bool _ValidateFlags(unsigned int pFlags)
+{
     if (pFlags & aiProcess_GenSmoothNormals && pFlags & aiProcess_GenNormals)   {
         ASSIMP_LOG_ERROR("#aiProcess_GenSmoothNormals and #aiProcess_GenNormals are incompatible");
         return false;
@@ -378,13 +375,12 @@ bool _ValidateFlags(unsigned int pFlags) {
 
 // ------------------------------------------------------------------------------------------------
 // Free the current scene
-void Importer::FreeScene( ) {
-    ai_assert(nullptr != pimpl);
-    
+void Importer::FreeScene( )
+{
     ASSIMP_BEGIN_EXCEPTION_REGION();
 
     delete pimpl->mScene;
-    pimpl->mScene = nullptr;
+    pimpl->mScene = NULL;
 
     pimpl->mErrorString = "";
     ASSIMP_END_EXCEPTION_REGION(void);
@@ -392,48 +388,44 @@ void Importer::FreeScene( ) {
 
 // ------------------------------------------------------------------------------------------------
 // Get the current error string, if any
-const char* Importer::GetErrorString() const {
-    ai_assert(nullptr != pimpl);
-    
-    // Must remain valid as long as ReadFile() or FreeFile() are not called
+const char* Importer::GetErrorString() const
+{
+     /* Must remain valid as long as ReadFile() or FreeFile() are not called */
     return pimpl->mErrorString.c_str();
 }
 
 // ------------------------------------------------------------------------------------------------
 // Enable extra-verbose mode
-void Importer::SetExtraVerbose(bool bDo) {
-    ai_assert(nullptr != pimpl);
-    
+void Importer::SetExtraVerbose(bool bDo)
+{
     pimpl->bExtraVerbose = bDo;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get the current scene
-const aiScene* Importer::GetScene() const {
-    ai_assert(nullptr != pimpl);
-    
+const aiScene* Importer::GetScene() const
+{
     return pimpl->mScene;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Orphan the current scene and return it.
-aiScene* Importer::GetOrphanedScene() {
-    ai_assert(nullptr != pimpl);
-    
+aiScene* Importer::GetOrphanedScene()
+{
     aiScene* s = pimpl->mScene;
 
     ASSIMP_BEGIN_EXCEPTION_REGION();
-    pimpl->mScene = nullptr;
+    pimpl->mScene = NULL;
 
-    pimpl->mErrorString = ""; // reset error string
+    pimpl->mErrorString = ""; /* reset error string */
     ASSIMP_END_EXCEPTION_REGION(aiScene*);
-    
     return s;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Validate post-processing flags
-bool Importer::ValidateFlags(unsigned int pFlags) const {
+bool Importer::ValidateFlags(unsigned int pFlags) const
+{
     ASSIMP_BEGIN_EXCEPTION_REGION();
     // run basic checks for mutually exclusive flags
     if(!_ValidateFlags(pFlags)) {
@@ -475,9 +467,8 @@ bool Importer::ValidateFlags(unsigned int pFlags) const {
 const aiScene* Importer::ReadFileFromMemory( const void* pBuffer,
     size_t pLength,
     unsigned int pFlags,
-    const char* pHint /*= ""*/) {
-    ai_assert(nullptr != pimpl);
-    
+    const char* pHint /*= ""*/)
+{
     ASSIMP_BEGIN_EXCEPTION_REGION();
     if (!pHint) {
         pHint = "";
@@ -485,12 +476,12 @@ const aiScene* Importer::ReadFileFromMemory( const void* pBuffer,
 
     if (!pBuffer || !pLength || strlen(pHint) > MaxLenHint ) {
         pimpl->mErrorString = "Invalid parameters passed to ReadFileFromMemory()";
-        return nullptr;
+        return NULL;
     }
 
     // prevent deletion of the previous IOHandler
     IOSystem* io = pimpl->mIOHandler;
-    pimpl->mIOHandler = nullptr;
+    pimpl->mIOHandler = NULL;
 
     SetIOHandler(new MemoryIOSystem((const uint8_t*)pBuffer,pLength,io));
 
@@ -502,13 +493,13 @@ const aiScene* Importer::ReadFileFromMemory( const void* pBuffer,
     ReadFile(fbuff,pFlags);
     SetIOHandler(io);
 
-    ASSIMP_END_EXCEPTION_REGION_WITH_ERROR_STRING(const aiScene*, pimpl->mErrorString);
+    ASSIMP_END_EXCEPTION_REGION(const aiScene*);
     return pimpl->mScene;
 }
 
 // ------------------------------------------------------------------------------------------------
-void WriteLogOpening(const std::string& file) {
-    
+void WriteLogOpening(const std::string& file)
+{
     ASSIMP_LOG_INFO_F("Load ", file);
 
     // print a full version dump. This is nice because we don't
@@ -559,9 +550,8 @@ void WriteLogOpening(const std::string& file) {
 
 // ------------------------------------------------------------------------------------------------
 // Reads the given file and returns its contents if successful.
-const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags) {
-    ai_assert(nullptr != pimpl);
-    
+const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags)
+{
     ASSIMP_BEGIN_EXCEPTION_REGION();
     const std::string pFile(_pFile);
 
@@ -590,7 +580,7 @@ const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags) {
 
             pimpl->mErrorString = "Unable to open file \"" + pFile + "\".";
             ASSIMP_LOG_ERROR(pimpl->mErrorString);
-            return nullptr;
+            return NULL;
         }
 
         std::unique_ptr<Profiler> profiler(GetPropertyInteger(AI_CONFIG_GLOB_MEASURE_TIME,0)?new Profiler():NULL);
@@ -599,7 +589,7 @@ const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags) {
         }
 
         // Find an worker class which can handle the file
-        BaseImporter* imp = nullptr;
+        BaseImporter* imp = NULL;
         SetPropertyInteger("importerIndex", -1);
         for( unsigned int a = 0; a < pimpl->mImporter.size(); a++)  {
 
@@ -627,7 +617,7 @@ const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags) {
             if( !imp)   {
                 pimpl->mErrorString = "No suitable reader found for the file format of file \"" + pFile + "\".";
                 ASSIMP_LOG_ERROR(pimpl->mErrorString);
-                return nullptr;
+                return NULL;
             }
         }
 
@@ -643,7 +633,7 @@ const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags) {
         // Dispatch the reading to the worker class for this format
         const aiImporterDesc *desc( imp->GetInfo() );
         std::string ext( "unknown" );
-        if ( nullptr != desc ) {
+        if ( NULL != desc ) {
             ext = desc->mName;
         }
         ASSIMP_LOG_INFO("Found a matching importer for this file format: " + ext + "." );
@@ -664,20 +654,15 @@ const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags) {
 
         // If successful, apply all active post processing steps to the imported data
         if( pimpl->mScene)  {
-            if (!pimpl->mScene->mMetaData || !pimpl->mScene->mMetaData->HasKey(AI_METADATA_SOURCE_FORMAT)) {
-                if (!pimpl->mScene->mMetaData) {
-                    pimpl->mScene->mMetaData = new aiMetadata;
-                }
-                pimpl->mScene->mMetaData->Add(AI_METADATA_SOURCE_FORMAT, aiString(ext));
-            }
 
 #ifndef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
             // The ValidateDS process is an exception. It is executed first, even before ScenePreprocessor is called.
-            if (pFlags & aiProcess_ValidateDataStructure) {
+            if (pFlags & aiProcess_ValidateDataStructure)
+            {
                 ValidateDSProcess ds;
                 ds.ExecuteOnScene (this);
                 if (!pimpl->mScene) {
-                    return nullptr;
+                    return NULL;
                 }
             }
 #endif // no validation
@@ -710,7 +695,8 @@ const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags) {
         }
     }
 #ifdef ASSIMP_CATCH_GLOBAL_EXCEPTIONS
-    catch (std::exception &e) {
+    catch (std::exception &e)
+    {
 #if (defined _MSC_VER) &&   (defined _CPPRTTI)
         // if we have RTTI get the full name of the exception that occurred
         pimpl->mErrorString = std::string(typeid( e ).name()) + ": " + e.what();
@@ -719,26 +705,24 @@ const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags) {
 #endif
 
         ASSIMP_LOG_ERROR(pimpl->mErrorString);
-        delete pimpl->mScene; pimpl->mScene = nullptr;
+        delete pimpl->mScene; pimpl->mScene = NULL;
     }
 #endif // ! ASSIMP_CATCH_GLOBAL_EXCEPTIONS
 
     // either successful or failure - the pointer expresses it anyways
-    ASSIMP_END_EXCEPTION_REGION_WITH_ERROR_STRING(const aiScene*, pimpl->mErrorString);
-    
+    ASSIMP_END_EXCEPTION_REGION(const aiScene*);
     return pimpl->mScene;
 }
 
 
 // ------------------------------------------------------------------------------------------------
 // Apply post-processing to the currently bound scene
-const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags) {
-    ai_assert(nullptr != pimpl);
-    
+const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags)
+{
     ASSIMP_BEGIN_EXCEPTION_REGION();
     // Return immediately if no scene is active
     if (!pimpl->mScene) {
-        return nullptr;
+        return NULL;
     }
 
     // If no flags are given, return the current scene with no further action
@@ -753,11 +737,12 @@ const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags) {
 #ifndef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
     // The ValidateDS process plays an exceptional role. It isn't contained in the global
     // list of post-processing steps, so we need to call it manually.
-    if (pFlags & aiProcess_ValidateDataStructure) {
+    if (pFlags & aiProcess_ValidateDataStructure)
+    {
         ValidateDSProcess ds;
         ds.ExecuteOnScene (this);
         if (!pimpl->mScene) {
-            return nullptr;
+            return NULL;
         }
     }
 #endif // no validation
@@ -777,9 +762,11 @@ const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags) {
 
     std::unique_ptr<Profiler> profiler(GetPropertyInteger(AI_CONFIG_GLOB_MEASURE_TIME,0)?new Profiler():NULL);
     for( unsigned int a = 0; a < pimpl->mPostProcessingSteps.size(); a++)   {
+
         BaseProcess* process = pimpl->mPostProcessingSteps[a];
         pimpl->mProgressHandler->UpdatePostProcess(static_cast<int>(a), static_cast<int>(pimpl->mPostProcessingSteps.size()) );
         if( process->IsActive( pFlags)) {
+
             if (profiler) {
                 profiler->BeginRegion("postprocess");
             }
@@ -816,28 +803,24 @@ const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags) {
         static_cast<int>(pimpl->mPostProcessingSteps.size()) );
 
     // update private scene flags
-    if( pimpl->mScene ) {
+    if( pimpl->mScene )
       ScenePriv(pimpl->mScene)->mPPStepsApplied |= pFlags;
-    }
 
     // clear any data allocated by post-process steps
     pimpl->mPPShared->Clean();
     ASSIMP_LOG_INFO("Leaving post processing pipeline");
 
     ASSIMP_END_EXCEPTION_REGION(const aiScene*);
-    
     return pimpl->mScene;
 }
 
 // ------------------------------------------------------------------------------------------------
 const aiScene* Importer::ApplyCustomizedPostProcessing( BaseProcess *rootProcess, bool requestValidation ) {
-    ai_assert(nullptr != pimpl);
-    
     ASSIMP_BEGIN_EXCEPTION_REGION();
 
     // Return immediately if no scene is active
-    if ( nullptr == pimpl->mScene ) {
-        return nullptr;
+    if ( NULL == pimpl->mScene ) {
+        return NULL;
     }
 
     // If no flags are given, return the current scene with no further action
@@ -856,7 +839,7 @@ const aiScene* Importer::ApplyCustomizedPostProcessing( BaseProcess *rootProcess
         ValidateDSProcess ds;
         ds.ExecuteOnScene( this );
         if ( !pimpl->mScene ) {
-            return nullptr;
+            return NULL;
         }
     }
 #endif // no validation
@@ -907,50 +890,46 @@ const aiScene* Importer::ApplyCustomizedPostProcessing( BaseProcess *rootProcess
 
 // ------------------------------------------------------------------------------------------------
 // Helper function to check whether an extension is supported by ASSIMP
-bool Importer::IsExtensionSupported(const char* szExtension) const {
+bool Importer::IsExtensionSupported(const char* szExtension) const
+{
     return nullptr != GetImporter(szExtension);
 }
 
 // ------------------------------------------------------------------------------------------------
-size_t Importer::GetImporterCount() const {
-    ai_assert(nullptr != pimpl);
-    
+size_t Importer::GetImporterCount() const
+{
     return pimpl->mImporter.size();
 }
 
 // ------------------------------------------------------------------------------------------------
-const aiImporterDesc* Importer::GetImporterInfo(size_t index) const {
-    ai_assert(nullptr != pimpl);
-    
+const aiImporterDesc* Importer::GetImporterInfo(size_t index) const
+{
     if (index >= pimpl->mImporter.size()) {
-        return nullptr;
+        return NULL;
     }
     return pimpl->mImporter[index]->GetInfo();
 }
 
 
 // ------------------------------------------------------------------------------------------------
-BaseImporter* Importer::GetImporter (size_t index) const {
-    ai_assert(nullptr != pimpl);
-    
+BaseImporter* Importer::GetImporter (size_t index) const
+{
     if (index >= pimpl->mImporter.size()) {
-        return nullptr;
+        return NULL;
     }
     return pimpl->mImporter[index];
 }
 
 // ------------------------------------------------------------------------------------------------
 // Find a loader plugin for a given file extension
-BaseImporter* Importer::GetImporter (const char* szExtension) const {
-    ai_assert(nullptr != pimpl);
-    
+BaseImporter* Importer::GetImporter (const char* szExtension) const
+{
     return GetImporter(GetImporterIndex(szExtension));
 }
 
 // ------------------------------------------------------------------------------------------------
 // Find a loader plugin for a given file extension
 size_t Importer::GetImporterIndex (const char* szExtension) const {
-    ai_assert(nullptr != pimpl);
     ai_assert(nullptr != szExtension);
 
     ASSIMP_BEGIN_EXCEPTION_REGION();
@@ -981,9 +960,8 @@ size_t Importer::GetImporterIndex (const char* szExtension) const {
 
 // ------------------------------------------------------------------------------------------------
 // Helper function to build a list of all file extensions supported by ASSIMP
-void Importer::GetExtensionList(aiString& szOut) const {
-    ai_assert(nullptr != pimpl);
-    
+void Importer::GetExtensionList(aiString& szOut) const
+{
     ASSIMP_BEGIN_EXCEPTION_REGION();
     std::set<std::string> str;
     for (std::vector<BaseImporter*>::const_iterator i =  pimpl->mImporter.begin();i != pimpl->mImporter.end();++i)  {
@@ -1007,9 +985,8 @@ void Importer::GetExtensionList(aiString& szOut) const {
 
 // ------------------------------------------------------------------------------------------------
 // Set a configuration property
-bool Importer::SetPropertyInteger(const char* szName, int iValue) {
-    ai_assert(nullptr != pimpl);
-    
+bool Importer::SetPropertyInteger(const char* szName, int iValue)
+{
     bool existing;
     ASSIMP_BEGIN_EXCEPTION_REGION();
         existing = SetGenericProperty<int>(pimpl->mIntProperties, szName,iValue);
@@ -1019,9 +996,8 @@ bool Importer::SetPropertyInteger(const char* szName, int iValue) {
 
 // ------------------------------------------------------------------------------------------------
 // Set a configuration property
-bool Importer::SetPropertyFloat(const char* szName, ai_real iValue) {
-    ai_assert(nullptr != pimpl);
-    
+bool Importer::SetPropertyFloat(const char* szName, ai_real iValue)
+{
     bool existing;
     ASSIMP_BEGIN_EXCEPTION_REGION();
         existing = SetGenericProperty<ai_real>(pimpl->mFloatProperties, szName,iValue);
@@ -1031,9 +1007,8 @@ bool Importer::SetPropertyFloat(const char* szName, ai_real iValue) {
 
 // ------------------------------------------------------------------------------------------------
 // Set a configuration property
-bool Importer::SetPropertyString(const char* szName, const std::string& value) {
-    ai_assert(nullptr != pimpl);
-    
+bool Importer::SetPropertyString(const char* szName, const std::string& value)
+{
     bool existing;
     ASSIMP_BEGIN_EXCEPTION_REGION();
         existing = SetGenericProperty<std::string>(pimpl->mStringProperties, szName,value);
@@ -1043,9 +1018,8 @@ bool Importer::SetPropertyString(const char* szName, const std::string& value) {
 
 // ------------------------------------------------------------------------------------------------
 // Set a configuration property
-bool Importer::SetPropertyMatrix(const char* szName, const aiMatrix4x4& value) {
-    ai_assert(nullptr != pimpl);
-    
+bool Importer::SetPropertyMatrix(const char* szName, const aiMatrix4x4& value)
+{
     bool existing;
     ASSIMP_BEGIN_EXCEPTION_REGION();
         existing = SetGenericProperty<aiMatrix4x4>(pimpl->mMatrixProperties, szName,value);
@@ -1055,43 +1029,40 @@ bool Importer::SetPropertyMatrix(const char* szName, const aiMatrix4x4& value) {
 
 // ------------------------------------------------------------------------------------------------
 // Get a configuration property
-int Importer::GetPropertyInteger(const char* szName, int iErrorReturn /*= 0xffffffff*/) const {
-    ai_assert(nullptr != pimpl);
-    
+int Importer::GetPropertyInteger(const char* szName,
+    int iErrorReturn /*= 0xffffffff*/) const
+{
     return GetGenericProperty<int>(pimpl->mIntProperties,szName,iErrorReturn);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get a configuration property
-ai_real Importer::GetPropertyFloat(const char* szName, ai_real iErrorReturn /*= 10e10*/) const {
-    ai_assert(nullptr != pimpl);
-    
+ai_real Importer::GetPropertyFloat(const char* szName,
+    ai_real iErrorReturn /*= 10e10*/) const
+{
     return GetGenericProperty<ai_real>(pimpl->mFloatProperties,szName,iErrorReturn);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get a configuration property
-std::string Importer::GetPropertyString(const char* szName, const std::string& iErrorReturn /*= ""*/) const {
-    ai_assert(nullptr != pimpl);
-    
+const std::string Importer::GetPropertyString(const char* szName,
+    const std::string& iErrorReturn /*= ""*/) const
+{
     return GetGenericProperty<std::string>(pimpl->mStringProperties,szName,iErrorReturn);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get a configuration property
-aiMatrix4x4 Importer::GetPropertyMatrix(const char* szName, const aiMatrix4x4& iErrorReturn /*= aiMatrix4x4()*/) const {
-    ai_assert(nullptr != pimpl);
-    
+const aiMatrix4x4 Importer::GetPropertyMatrix(const char* szName,
+    const aiMatrix4x4& iErrorReturn /*= aiMatrix4x4()*/) const
+{
     return GetGenericProperty<aiMatrix4x4>(pimpl->mMatrixProperties,szName,iErrorReturn);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get the memory requirements of a single node
-inline 
-void AddNodeWeight(unsigned int& iScene,const aiNode* pcNode) {
-    if ( nullptr == pcNode ) {
-        return;
-    }
+inline void AddNodeWeight(unsigned int& iScene,const aiNode* pcNode)
+{
     iScene += sizeof(aiNode);
     iScene += sizeof(unsigned int) * pcNode->mNumMeshes;
     iScene += sizeof(void*) * pcNode->mNumChildren;
@@ -1103,20 +1074,21 @@ void AddNodeWeight(unsigned int& iScene,const aiNode* pcNode) {
 
 // ------------------------------------------------------------------------------------------------
 // Get the memory requirements of the scene
-void Importer::GetMemoryRequirements(aiMemoryInfo& in) const {
-    ai_assert(nullptr != pimpl);
-    
+void Importer::GetMemoryRequirements(aiMemoryInfo& in) const
+{
     in = aiMemoryInfo();
     aiScene* mScene = pimpl->mScene;
 
     // return if we have no scene loaded
-    if (!mScene)
+    if (!pimpl->mScene)
         return;
 
+
     in.total = sizeof(aiScene);
 
     // add all meshes
-    for (unsigned int i = 0; i < mScene->mNumMeshes;++i) {
+    for (unsigned int i = 0; i < mScene->mNumMeshes;++i)
+    {
         in.meshes += sizeof(aiMesh);
         if (mScene->mMeshes[i]->HasPositions()) {
             in.meshes += sizeof(aiVector3D) * mScene->mMeshes[i]->mNumVertices;
@@ -1133,16 +1105,14 @@ void Importer::GetMemoryRequirements(aiMemoryInfo& in) const {
         for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS;++a) {
             if (mScene->mMeshes[i]->HasVertexColors(a)) {
                 in.meshes += sizeof(aiColor4D) * mScene->mMeshes[i]->mNumVertices;
-            } else {
-                break;
             }
+            else break;
         }
         for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS;++a) {
             if (mScene->mMeshes[i]->HasTextureCoords(a)) {
                 in.meshes += sizeof(aiVector3D) * mScene->mMeshes[i]->mNumVertices;
-            } else {
-                break;
             }
+            else break;
         }
         if (mScene->mMeshes[i]->HasBones()) {
             in.meshes += sizeof(void*) * mScene->mMeshes[i]->mNumBones;
@@ -1161,9 +1131,8 @@ void Importer::GetMemoryRequirements(aiMemoryInfo& in) const {
         in.textures += sizeof(aiTexture);
         if (pc->mHeight) {
             in.textures += 4 * pc->mHeight * pc->mWidth;
-        } else {
-            in.textures += pc->mWidth;
         }
+        else in.textures += pc->mWidth;
     }
     in.total += in.textures;
 
@@ -1201,6 +1170,5 @@ void Importer::GetMemoryRequirements(aiMemoryInfo& in) const {
             in.materials += pc->mProperties[a]->mDataLength;
         }
     }
-
     in.total += in.materials;
 }
diff --git a/Engine/lib/assimp/code/Common/Importer.h b/Engine/lib/assimp/code/Common/Importer.h
index c31f67caa..a439d99c2 100644
--- a/Engine/lib/assimp/code/Common/Importer.h
+++ b/Engine/lib/assimp/code/Common/Importer.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Common/ImporterRegistry.cpp b/Engine/lib/assimp/code/Common/ImporterRegistry.cpp
index 41aa21979..32ac3b416 100644
--- a/Engine/lib/assimp/code/Common/ImporterRegistry.cpp
+++ b/Engine/lib/assimp/code/Common/ImporterRegistry.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -197,9 +197,6 @@ corresponding preprocessor flag to selectively disable formats.
 #ifndef ASSIMP_BUILD_NO_MMD_IMPORTER
 #   include "MMD/MMDImporter.h"
 #endif
-#ifndef ASSIMP_BUILD_NO_M3D_IMPORTER
-#   include "M3D/M3DImporter.h"
-#endif
 #ifndef ASSIMP_BUILD_NO_STEP_IMPORTER
 #   include "Importer/StepFile/StepFileImporter.h"
 #endif
@@ -226,9 +223,6 @@ void GetImporterInstanceList(std::vector< BaseImporter* >& out)
 #if (!defined ASSIMP_BUILD_NO_3DS_IMPORTER)
     out.push_back( new Discreet3DSImporter());
 #endif
-#if (!defined ASSIMP_BUILD_NO_M3D_IMPORTER)
-    out.push_back( new M3DImporter());
-#endif
 #if (!defined ASSIMP_BUILD_NO_MD3_IMPORTER)
     out.push_back( new MD3Importer());
 #endif
diff --git a/Engine/lib/assimp/code/Common/PolyTools.h b/Engine/lib/assimp/code/Common/PolyTools.h
index 1b8972877..fbbda0e7d 100644
--- a/Engine/lib/assimp/code/Common/PolyTools.h
+++ b/Engine/lib/assimp/code/Common/PolyTools.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Common/PostStepRegistry.cpp b/Engine/lib/assimp/code/Common/PostStepRegistry.cpp
index 19382165f..ef58f8ddf 100644
--- a/Engine/lib/assimp/code/Common/PostStepRegistry.cpp
+++ b/Engine/lib/assimp/code/Common/PostStepRegistry.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -123,7 +123,7 @@ corresponding preprocessor flag to selectively disable steps.
 #   include "PostProcessing/OptimizeGraph.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_SPLITBYBONECOUNT_PROCESS
-#   include "PostProcessing/SplitByBoneCountProcess.h"
+#   include "Common/SplitByBoneCountProcess.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_DEBONE_PROCESS
 #   include "PostProcessing/DeboneProcess.h"
@@ -131,15 +131,11 @@ corresponding preprocessor flag to selectively disable steps.
 #if (!defined ASSIMP_BUILD_NO_GLOBALSCALE_PROCESS)
 #   include "PostProcessing/ScaleProcess.h"
 #endif
-#if (!defined ASSIMP_BUILD_NO_ARMATUREPOPULATE_PROCESS)
-#   include "PostProcessing/ArmaturePopulate.h"
-#endif
 #if (!defined ASSIMP_BUILD_NO_GENBOUNDINGBOXES_PROCESS)
 #   include "PostProcessing/GenBoundingBoxesProcess.h"
 #endif
 
 
-
 namespace Assimp {
 
 // ------------------------------------------------------------------------------------------------
@@ -184,9 +180,6 @@ void GetPostProcessingStepInstanceList(std::vector< BaseProcess* >& out)
 #if (!defined ASSIMP_BUILD_NO_GLOBALSCALE_PROCESS)
     out.push_back( new ScaleProcess());
 #endif
-#if (!defined ASSIMP_BUILD_NO_ARMATUREPOPULATE_PROCESS)
-    out.push_back( new ArmaturePopulate());
-#endif
 #if (!defined ASSIMP_BUILD_NO_PRETRANSFORMVERTICES_PROCESS)
     out.push_back( new PretransformVertices());
 #endif
diff --git a/Engine/lib/assimp/code/Common/RemoveComments.cpp b/Engine/lib/assimp/code/Common/RemoveComments.cpp
index f7e735c16..91700a769 100644
--- a/Engine/lib/assimp/code/Common/RemoveComments.cpp
+++ b/Engine/lib/assimp/code/Common/RemoveComments.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Common/SGSpatialSort.cpp b/Engine/lib/assimp/code/Common/SGSpatialSort.cpp
index 35ffaae58..120070b0a 100644
--- a/Engine/lib/assimp/code/Common/SGSpatialSort.cpp
+++ b/Engine/lib/assimp/code/Common/SGSpatialSort.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/Common/SceneCombiner.cpp b/Engine/lib/assimp/code/Common/SceneCombiner.cpp
index 29b6082a8..4e6bc5b47 100644
--- a/Engine/lib/assimp/code/Common/SceneCombiner.cpp
+++ b/Engine/lib/assimp/code/Common/SceneCombiner.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -1196,7 +1196,6 @@ void SceneCombiner::Copy( aiAnimation** _dest, const aiAnimation* src ) {
 
     // and reallocate all arrays
     CopyPtrArray( dest->mChannels, src->mChannels, dest->mNumChannels );
-    CopyPtrArray( dest->mMorphMeshChannels, src->mMorphMeshChannels, dest->mNumMorphMeshChannels );
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -1216,26 +1215,6 @@ void SceneCombiner::Copy(aiNodeAnim** _dest, const aiNodeAnim* src) {
     GetArrayCopy( dest->mRotationKeys, dest->mNumRotationKeys );
 }
 
-void SceneCombiner::Copy(aiMeshMorphAnim** _dest, const aiMeshMorphAnim* src) {
-    if ( nullptr == _dest || nullptr == src ) {
-        return;
-    }
-
-    aiMeshMorphAnim* dest = *_dest = new aiMeshMorphAnim();
-
-    // get a flat copy
-    ::memcpy(dest,src,sizeof(aiMeshMorphAnim));
-
-    // and reallocate all arrays
-    GetArrayCopy( dest->mKeys, dest->mNumKeys );
-    for (ai_uint i = 0; i < dest->mNumKeys;++i) {
-        dest->mKeys[i].mValues = new unsigned int[dest->mKeys[i].mNumValuesAndWeights];
-        dest->mKeys[i].mWeights = new double[dest->mKeys[i].mNumValuesAndWeights];
-        ::memcpy(dest->mKeys[i].mValues, src->mKeys[i].mValues, dest->mKeys[i].mNumValuesAndWeights * sizeof(unsigned int));
-        ::memcpy(dest->mKeys[i].mWeights, src->mKeys[i].mWeights, dest->mKeys[i].mNumValuesAndWeights * sizeof(double));
-    }
-}
-
 // ------------------------------------------------------------------------------------------------
 void SceneCombiner::Copy( aiCamera** _dest,const  aiCamera* src) {
     if ( nullptr == _dest || nullptr == src ) {
@@ -1312,6 +1291,7 @@ void SceneCombiner::Copy(aiMetadata** _dest, const aiMetadata* src) {
     aiMetadata* dest = *_dest = aiMetadata::Alloc( src->mNumProperties );
     std::copy(src->mKeys, src->mKeys + src->mNumProperties, dest->mKeys);
 
+    dest->mValues = new aiMetadataEntry[src->mNumProperties];
     for (unsigned int i = 0; i < src->mNumProperties; ++i) {
         aiMetadataEntry& in = src->mValues[i];
         aiMetadataEntry& out = dest->mValues[i];
diff --git a/Engine/lib/assimp/code/Common/ScenePreprocessor.cpp b/Engine/lib/assimp/code/Common/ScenePreprocessor.cpp
index 606590519..432a3d766 100644
--- a/Engine/lib/assimp/code/Common/ScenePreprocessor.cpp
+++ b/Engine/lib/assimp/code/Common/ScenePreprocessor.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -217,7 +217,6 @@ void ScenePreprocessor::ProcessAnimation (aiAnimation* anim)
 
                 // No rotation keys? Generate a dummy track
                 if (!channel->mNumRotationKeys) {
-                    ai_assert(!channel->mRotationKeys);
                     channel->mNumRotationKeys = 1;
                     channel->mRotationKeys = new aiQuatKey[1];
                     aiQuatKey& q = channel->mRotationKeys[0];
@@ -226,13 +225,10 @@ void ScenePreprocessor::ProcessAnimation (aiAnimation* anim)
                     q.mValue = rotation;
 
                     ASSIMP_LOG_DEBUG("ScenePreprocessor: Dummy rotation track has been generated");
-                } else {
-                    ai_assert(channel->mRotationKeys);
                 }
 
                 // No scaling keys? Generate a dummy track
                 if (!channel->mNumScalingKeys)  {
-                    ai_assert(!channel->mScalingKeys);
                     channel->mNumScalingKeys = 1;
                     channel->mScalingKeys = new aiVectorKey[1];
                     aiVectorKey& q = channel->mScalingKeys[0];
@@ -241,13 +237,10 @@ void ScenePreprocessor::ProcessAnimation (aiAnimation* anim)
                     q.mValue = scaling;
 
                     ASSIMP_LOG_DEBUG("ScenePreprocessor: Dummy scaling track has been generated");
-                } else {
-                    ai_assert(channel->mScalingKeys);
                 }
 
                 // No position keys? Generate a dummy track
                 if (!channel->mNumPositionKeys) {
-                    ai_assert(!channel->mPositionKeys);
                     channel->mNumPositionKeys = 1;
                     channel->mPositionKeys = new aiVectorKey[1];
                     aiVectorKey& q = channel->mPositionKeys[0];
@@ -256,8 +249,6 @@ void ScenePreprocessor::ProcessAnimation (aiAnimation* anim)
                     q.mValue = position;
 
                     ASSIMP_LOG_DEBUG("ScenePreprocessor: Dummy position track has been generated");
-                } else {
-                    ai_assert(channel->mPositionKeys);
                 }
             }
         }
diff --git a/Engine/lib/assimp/code/Common/ScenePreprocessor.h b/Engine/lib/assimp/code/Common/ScenePreprocessor.h
index e059d1c95..3f4c8d7c3 100644
--- a/Engine/lib/assimp/code/Common/ScenePreprocessor.h
+++ b/Engine/lib/assimp/code/Common/ScenePreprocessor.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Common/ScenePrivate.h b/Engine/lib/assimp/code/Common/ScenePrivate.h
index f66f48856..f336aafc9 100644
--- a/Engine/lib/assimp/code/Common/ScenePrivate.h
+++ b/Engine/lib/assimp/code/Common/ScenePrivate.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Common/SkeletonMeshBuilder.cpp b/Engine/lib/assimp/code/Common/SkeletonMeshBuilder.cpp
index 724359f99..06cfe034e 100644
--- a/Engine/lib/assimp/code/Common/SkeletonMeshBuilder.cpp
+++ b/Engine/lib/assimp/code/Common/SkeletonMeshBuilder.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Common/SpatialSort.cpp b/Engine/lib/assimp/code/Common/SpatialSort.cpp
index 604b086b7..a4f3a4e4b 100644
--- a/Engine/lib/assimp/code/Common/SpatialSort.cpp
+++ b/Engine/lib/assimp/code/Common/SpatialSort.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/Common/StandardShapes.cpp b/Engine/lib/assimp/code/Common/StandardShapes.cpp
index d474c6129..2e5100130 100644
--- a/Engine/lib/assimp/code/Common/StandardShapes.cpp
+++ b/Engine/lib/assimp/code/Common/StandardShapes.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Common/StdOStreamLogStream.h b/Engine/lib/assimp/code/Common/StdOStreamLogStream.h
index 4f5999775..893e261a2 100644
--- a/Engine/lib/assimp/code/Common/StdOStreamLogStream.h
+++ b/Engine/lib/assimp/code/Common/StdOStreamLogStream.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/Common/Subdivision.cpp b/Engine/lib/assimp/code/Common/Subdivision.cpp
index 08408f867..60c54939f 100644
--- a/Engine/lib/assimp/code/Common/Subdivision.cpp
+++ b/Engine/lib/assimp/code/Common/Subdivision.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Common/TargetAnimation.cpp b/Engine/lib/assimp/code/Common/TargetAnimation.cpp
index 3c61d2176..b8062499f 100644
--- a/Engine/lib/assimp/code/Common/TargetAnimation.cpp
+++ b/Engine/lib/assimp/code/Common/TargetAnimation.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Common/TargetAnimation.h b/Engine/lib/assimp/code/Common/TargetAnimation.h
index 5b9c1881d..91634ab5a 100644
--- a/Engine/lib/assimp/code/Common/TargetAnimation.h
+++ b/Engine/lib/assimp/code/Common/TargetAnimation.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Common/Version.cpp b/Engine/lib/assimp/code/Common/Version.cpp
index f04d12233..5f72fd319 100644
--- a/Engine/lib/assimp/code/Common/Version.cpp
+++ b/Engine/lib/assimp/code/Common/Version.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -46,7 +46,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/scene.h>
 #include "ScenePrivate.h"
 
-#include "revision.h"
+static const unsigned int MajorVersion = 5;
+static const unsigned int MinorVersion = 0;
 
 // --------------------------------------------------------------------------------
 // Legal information string - don't remove this.
@@ -55,9 +56,9 @@ static const char* LEGAL_INFORMATION =
 "Open Asset Import Library (Assimp).\n"
 "A free C/C++ library to import various 3D file formats into applications\n\n"
 
-"(c) 2006-2020, assimp team\n"
+"(c) 2008-2020, assimp team\n"
 "License under the terms and conditions of the 3-clause BSD license\n"
-"http://assimp.org\n"
+"https://github.com/assimp/assimp\n"
 ;
 
 // ------------------------------------------------------------------------------------------------
@@ -66,22 +67,16 @@ ASSIMP_API const char*  aiGetLegalString  ()    {
     return LEGAL_INFORMATION;
 }
 
-// ------------------------------------------------------------------------------------------------
-// Get Assimp patch version
-ASSIMP_API unsigned int aiGetVersionPatch() {
-	return VER_PATCH;
-}
-
 // ------------------------------------------------------------------------------------------------
 // Get Assimp minor version
 ASSIMP_API unsigned int aiGetVersionMinor ()    {
-    return VER_MINOR;
+    return MinorVersion;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get Assimp major version
 ASSIMP_API unsigned int aiGetVersionMajor ()    {
-    return VER_MAJOR;
+    return MajorVersion;
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -109,6 +104,9 @@ ASSIMP_API unsigned int aiGetCompileFlags ()    {
     return flags;
 }
 
+// include current build revision, which is even updated from time to time -- :-)
+#include "revision.h"
+
 // ------------------------------------------------------------------------------------------------
 ASSIMP_API unsigned int aiGetVersionRevision() {
     return GitVersion;
diff --git a/Engine/lib/assimp/code/Common/VertexTriangleAdjacency.cpp b/Engine/lib/assimp/code/Common/VertexTriangleAdjacency.cpp
index e588dc2a4..7cfd1a350 100644
--- a/Engine/lib/assimp/code/Common/VertexTriangleAdjacency.cpp
+++ b/Engine/lib/assimp/code/Common/VertexTriangleAdjacency.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -58,7 +58,7 @@ VertexTriangleAdjacency::VertexTriangleAdjacency(aiFace *pcFaces,
 {
     // compute the number of referenced vertices if it wasn't specified by the caller
     const aiFace* const pcFaceEnd = pcFaces + iNumFaces;
-    if (0 == iNumVertices)  {
+    if (!iNumVertices)  {
         for (aiFace* pcFace = pcFaces; pcFace != pcFaceEnd; ++pcFace)   {
             ai_assert( nullptr != pcFace );
             ai_assert(3 == pcFace->mNumIndices);
@@ -68,7 +68,7 @@ VertexTriangleAdjacency::VertexTriangleAdjacency(aiFace *pcFaces,
         }
     }
 
-    mNumVertices = iNumVertices + 1;
+    mNumVertices = iNumVertices;
 
     unsigned int* pi;
 
diff --git a/Engine/lib/assimp/code/Common/VertexTriangleAdjacency.h b/Engine/lib/assimp/code/Common/VertexTriangleAdjacency.h
index 2226fc1c4..f3be47612 100644
--- a/Engine/lib/assimp/code/Common/VertexTriangleAdjacency.h
+++ b/Engine/lib/assimp/code/Common/VertexTriangleAdjacency.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Common/Win32DebugLogStream.h b/Engine/lib/assimp/code/Common/Win32DebugLogStream.h
index 3a9d89c73..a6063a261 100644
--- a/Engine/lib/assimp/code/Common/Win32DebugLogStream.h
+++ b/Engine/lib/assimp/code/Common/Win32DebugLogStream.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/Common/ZipArchiveIOSystem.cpp b/Engine/lib/assimp/code/Common/ZipArchiveIOSystem.cpp
index 8d00da912..7c37a05f9 100644
--- a/Engine/lib/assimp/code/Common/ZipArchiveIOSystem.cpp
+++ b/Engine/lib/assimp/code/Common/ZipArchiveIOSystem.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -343,6 +343,8 @@ namespace Assimp {
     }
 
     ZipArchiveIOSystem::Implement::~Implement() {
+        m_ArchiveMap.clear();
+
         if (m_ZipFileHandle != nullptr) {
             unzClose(m_ZipFileHandle);
             m_ZipFileHandle = nullptr;
diff --git a/Engine/lib/assimp/code/Common/assbin_chunks.h b/Engine/lib/assimp/code/Common/assbin_chunks.h
index 822df5198..15e4af5e7 100644
--- a/Engine/lib/assimp/code/Common/assbin_chunks.h
+++ b/Engine/lib/assimp/code/Common/assbin_chunks.h
@@ -37,7 +37,7 @@ The ASSBIN file format is composed of chunks to represent the hierarchical aiSce
 This makes the format extensible and allows backward-compatibility with future data structure
 versions. The <tt>&lt;root&gt;/code/assbin_chunks.h</tt> header contains some magic constants
 for use by stand-alone ASSBIN loaders. Also, Assimp's own file writer can be found
-in <tt>&lt;root&gt;/tools/assimp_cmd/WriteDump.cpp</tt> (yes, the 'b' is no typo ...).
+in <tt>&lt;root&gt;/tools/assimp_cmd/WriteDumb.cpp</tt> (yes, the 'b' is no typo ...).
 
 @verbatim
 
diff --git a/Engine/lib/assimp/code/Common/material.cpp b/Engine/lib/assimp/code/Common/material.cpp
deleted file mode 100644
index f4a29dacf..000000000
--- a/Engine/lib/assimp/code/Common/material.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/// @file material.cpp
-/** Implement common material related functions. */
-
-#include <assimp/ai_assert.h>
-#include <assimp/material.h>
-
-// -------------------------------------------------------------------------------
-const char* TextureTypeToString(aiTextureType in)
-{
-    switch (in)
-    {
-    case aiTextureType_NONE:
-        return "n/a";
-    case aiTextureType_DIFFUSE:
-        return "Diffuse";
-    case aiTextureType_SPECULAR:
-        return "Specular";
-    case aiTextureType_AMBIENT:
-        return "Ambient";
-    case aiTextureType_EMISSIVE:
-        return "Emissive";
-    case aiTextureType_OPACITY:
-        return "Opacity";
-    case aiTextureType_NORMALS:
-        return "Normals";
-    case aiTextureType_HEIGHT:
-        return "Height";
-    case aiTextureType_SHININESS:
-        return "Shininess";
-    case aiTextureType_DISPLACEMENT:
-        return "Displacement";
-    case aiTextureType_LIGHTMAP:
-        return "Lightmap";
-    case aiTextureType_REFLECTION:
-        return "Reflection";
-    case aiTextureType_BASE_COLOR:
-        return "BaseColor";
-    case aiTextureType_NORMAL_CAMERA:
-        return "NormalCamera";
-    case aiTextureType_EMISSION_COLOR:
-        return "EmissionColor";
-    case aiTextureType_METALNESS:
-        return "Metalness";
-    case aiTextureType_DIFFUSE_ROUGHNESS:
-        return "DiffuseRoughness";
-    case aiTextureType_AMBIENT_OCCLUSION:
-        return "AmbientOcclusion";
-    case aiTextureType_UNKNOWN:
-        return "Unknown";
-    default:
-        break;
-    }
-    ai_assert(false);
-    return "BUG";
-}
diff --git a/Engine/lib/assimp/code/Common/scene.cpp b/Engine/lib/assimp/code/Common/scene.cpp
index f56562b1c..2acb348d8 100644
--- a/Engine/lib/assimp/code/Common/scene.cpp
+++ b/Engine/lib/assimp/code/Common/scene.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -44,23 +44,23 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 aiNode::aiNode()
 : mName("")
-, mParent(nullptr)
+, mParent(NULL)
 , mNumChildren(0)
-, mChildren(nullptr)
+, mChildren(NULL)
 , mNumMeshes(0)
-, mMeshes(nullptr)
-, mMetaData(nullptr) {
+, mMeshes(NULL)
+, mMetaData(NULL) {
     // empty
 }
 
 aiNode::aiNode(const std::string& name)
 : mName(name)
-, mParent(nullptr)
+, mParent(NULL)
 , mNumChildren(0)
-, mChildren(nullptr)
+, mChildren(NULL)
 , mNumMeshes(0)
-, mMeshes(nullptr)
-, mMetaData(nullptr) {
+, mMeshes(NULL)
+, mMetaData(NULL) {
     // empty
 }
 
@@ -68,7 +68,7 @@ aiNode::aiNode(const std::string& name)
 aiNode::~aiNode() {
     // delete all children recursively
     // to make sure we won't crash if the data is invalid ...
-    if (mNumChildren && mChildren)
+    if (mChildren && mNumChildren)
     {
         for (unsigned int a = 0; a < mNumChildren; a++)
             delete mChildren[a];
diff --git a/Engine/lib/assimp/code/Common/simd.cpp b/Engine/lib/assimp/code/Common/simd.cpp
index 305445970..04615f408 100644
--- a/Engine/lib/assimp/code/Common/simd.cpp
+++ b/Engine/lib/assimp/code/Common/simd.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/Common/simd.h b/Engine/lib/assimp/code/Common/simd.h
index 17856fe72..3eecdd458 100644
--- a/Engine/lib/assimp/code/Common/simd.h
+++ b/Engine/lib/assimp/code/Common/simd.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/DXF/DXFHelper.h b/Engine/lib/assimp/code/DXF/DXFHelper.h
index 8140d00c6..0ec8e130b 100644
--- a/Engine/lib/assimp/code/DXF/DXFHelper.h
+++ b/Engine/lib/assimp/code/DXF/DXFHelper.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/DXF/DXFLoader.cpp b/Engine/lib/assimp/code/DXF/DXFLoader.cpp
index ea877a484..baf315485 100644
--- a/Engine/lib/assimp/code/DXF/DXFLoader.cpp
+++ b/Engine/lib/assimp/code/DXF/DXFLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/DXF/DXFLoader.h b/Engine/lib/assimp/code/DXF/DXFLoader.h
index 5c4f1787e..044cf6bcb 100644
--- a/Engine/lib/assimp/code/DXF/DXFLoader.h
+++ b/Engine/lib/assimp/code/DXF/DXFLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/FBX/FBXAnimation.cpp b/Engine/lib/assimp/code/FBX/FBXAnimation.cpp
index 9a54f61a0..874914431 100644
--- a/Engine/lib/assimp/code/FBX/FBXAnimation.cpp
+++ b/Engine/lib/assimp/code/FBX/FBXAnimation.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/FBX/FBXBinaryTokenizer.cpp b/Engine/lib/assimp/code/FBX/FBXBinaryTokenizer.cpp
index 7faa0518b..a4a2bc8e7 100644
--- a/Engine/lib/assimp/code/FBX/FBXBinaryTokenizer.cpp
+++ b/Engine/lib/assimp/code/FBX/FBXBinaryTokenizer.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/FBX/FBXCommon.h b/Engine/lib/assimp/code/FBX/FBXCommon.h
index 7f70eb784..e51644913 100644
--- a/Engine/lib/assimp/code/FBX/FBXCommon.h
+++ b/Engine/lib/assimp/code/FBX/FBXCommon.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
@@ -50,10 +50,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 namespace Assimp {
 namespace FBX
 {
-    const std::string NULL_RECORD = { // 25 null bytes in 64-bit and 13 null bytes in 32-bit
-        '\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0',
-        '\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0'
-    }; // who knows why, it looks like two integers 32/64 bit (compressed and uncompressed sizes?) + 1 byte (might be compression type?)
+    const std::string NULL_RECORD = { // 13 null bytes
+        '\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0'
+    }; // who knows why
     const std::string SEPARATOR = {'\x00', '\x01'}; // for use inside strings
     const std::string MAGIC_NODE_TAG = "_$AssimpFbx$"; // from import
     const int64_t SECOND = 46186158000; // FBX's kTime unit
diff --git a/Engine/lib/assimp/code/FBX/FBXCompileConfig.h b/Engine/lib/assimp/code/FBX/FBXCompileConfig.h
index 5cdaa6960..3a3841fa5 100644
--- a/Engine/lib/assimp/code/FBX/FBXCompileConfig.h
+++ b/Engine/lib/assimp/code/FBX/FBXCompileConfig.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -47,7 +47,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define INCLUDED_AI_FBX_COMPILECONFIG_H
 
 #include <map>
-#include <set>
 
 //
 #if _MSC_VER > 1500 || (defined __GNUC___)
@@ -55,23 +54,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #   else
 #   define fbx_unordered_map map
 #   define fbx_unordered_multimap multimap
-#   define fbx_unordered_set set
-#   define fbx_unordered_multiset multiset
 #endif
 
 #ifdef ASSIMP_FBX_USE_UNORDERED_MULTIMAP
 #   include <unordered_map>
-#   include <unordered_set>
 #   if _MSC_VER > 1600
 #       define fbx_unordered_map unordered_map
 #       define fbx_unordered_multimap unordered_multimap
-#       define fbx_unordered_set unordered_set
-#       define fbx_unordered_multiset unordered_multiset
 #   else
 #       define fbx_unordered_map tr1::unordered_map
 #       define fbx_unordered_multimap tr1::unordered_multimap
-#       define fbx_unordered_set tr1::unordered_set
-#       define fbx_unordered_multiset tr1::unordered_multiset
 #   endif
 #endif
 
diff --git a/Engine/lib/assimp/code/FBX/FBXConverter.cpp b/Engine/lib/assimp/code/FBX/FBXConverter.cpp
index 22616a480..152be3277 100644
--- a/Engine/lib/assimp/code/FBX/FBXConverter.cpp
+++ b/Engine/lib/assimp/code/FBX/FBXConverter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -60,8 +60,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/scene.h>
 
 #include <assimp/CreateAnimMesh.h>
-#include <assimp/commonMetaData.h>
-#include <assimp/StringUtils.h>
 
 #include <tuple>
 #include <memory>
@@ -70,8 +68,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <sstream>
 #include <iomanip>
 #include <cstdint>
-#include <iostream>
-#include <stdlib.h>
+
 
 namespace Assimp {
     namespace FBX {
@@ -80,7 +77,7 @@ namespace Assimp {
 
 #define MAGIC_NODE_TAG "_$AssimpFbx$"
 
-#define CONVERT_FBX_TIME(time) static_cast<double>(time) / 46186158000LL
+#define CONVERT_FBX_TIME(time) static_cast<double>(time) / 46186158000L
 
         FBXConverter::FBXConverter(aiScene* out, const Document& doc, bool removeEmptyBones )
         : defaultMaterialIndex()
@@ -99,14 +96,6 @@ namespace Assimp {
             // populate the node_anim_chain_bits map, which is needed
             // to determine which nodes need to be generated.
             ConvertAnimations();
-            // Embedded textures in FBX could be connected to nothing but to itself,
-            // for instance Texture -> Video connection only but not to the main graph,
-            // The idea here is to traverse all objects to find these Textures and convert them,
-            // so later during material conversion it will find converted texture in the textures_converted array.
-            if (doc.Settings().readTextures)
-            {
-                ConvertOrphantEmbeddedTextures();
-            }
             ConvertRootNode();
 
             if (doc.Settings().readAllMaterials) {
@@ -156,7 +145,7 @@ namespace Assimp {
             out->mRootNode->mName.Set(unique_name);
 
             // root has ID 0
-            ConvertNodes(0L, out->mRootNode, out->mRootNode);
+            ConvertNodes(0L, *out->mRootNode);
         }
 
         static std::string getAncestorBaseName(const aiNode* node)
@@ -190,11 +179,8 @@ namespace Assimp {
             GetUniqueName(original_name, unique_name);
             return unique_name;
         }
-        /// todo: pre-build node hierarchy
-        /// todo: get bone from stack
-        /// todo: make map of aiBone* to aiNode*
-        /// then update convert clusters to the new format
-        void FBXConverter::ConvertNodes(uint64_t id, aiNode *parent, aiNode *root_node) {
+
+        void FBXConverter::ConvertNodes(uint64_t id, aiNode& parent, const aiMatrix4x4& parent_transform) {
             const std::vector<const Connection*>& conns = doc.GetConnectionsByDestinationSequenced(id, "Model");
 
             std::vector<aiNode*> nodes;
@@ -205,69 +191,62 @@ namespace Assimp {
 
             try {
                 for (const Connection* con : conns) {
+
                     // ignore object-property links
                     if (con->PropertyName().length()) {
-                        // really important we document why this is ignored.
-                        FBXImporter::LogInfo("ignoring property link - no docs on why this is ignored");
-                        continue; //?
-                    }
-
-                    // convert connection source object into Object base class
-                    const Object* const object = con->SourceObject();
-                    if (nullptr == object) {
-                        FBXImporter::LogError("failed to convert source object for Model link");
                         continue;
                     }
 
-                    // FBX Model::Cube, Model::Bone001, etc elements
-                    // This detects if we can cast the object into this model structure.
+                    const Object* const object = con->SourceObject();
+                    if (nullptr == object) {
+                        FBXImporter::LogWarn("failed to convert source object for Model link");
+                        continue;
+                    }
+
                     const Model* const model = dynamic_cast<const Model*>(object);
 
                     if (nullptr != model) {
                         nodes_chain.clear();
                         post_nodes_chain.clear();
 
-                        aiMatrix4x4 new_abs_transform = parent->mTransformation;
-                        std::string node_name = FixNodeName(model->Name());
+                        aiMatrix4x4 new_abs_transform = parent_transform;
+
+                        std::string unique_name = MakeUniqueNodeName(model, parent);
+
                         // even though there is only a single input node, the design of
                         // assimp (or rather: the complicated transformation chain that
                         // is employed by fbx) means that we may need multiple aiNode's
                         // to represent a fbx node's transformation.
+                        const bool need_additional_node = GenerateTransformationNodeChain(*model, unique_name, nodes_chain, post_nodes_chain);
 
-
-                        // generate node transforms - this includes pivot data
-                        // if need_additional_node is true then you t
-                        const bool need_additional_node = GenerateTransformationNodeChain(*model, node_name, nodes_chain, post_nodes_chain);
-
-                        // assert that for the current node we must have at least a single transform
                         ai_assert(nodes_chain.size());
 
                         if (need_additional_node) {
-                            nodes_chain.push_back(new aiNode(node_name));
+                            nodes_chain.push_back(new aiNode(unique_name));
                         }
 
                         //setup metadata on newest node
                         SetupNodeMetadata(*model, *nodes_chain.back());
 
                         // link all nodes in a row
-                        aiNode* last_parent = parent;
-                        for (aiNode* child : nodes_chain) {
-                            ai_assert(child);
+                        aiNode* last_parent = &parent;
+                        for (aiNode* prenode : nodes_chain) {
+                            ai_assert(prenode);
 
-                            if (last_parent != parent) {
+                            if (last_parent != &parent) {
                                 last_parent->mNumChildren = 1;
                                 last_parent->mChildren = new aiNode*[1];
-                                last_parent->mChildren[0] = child;
+                                last_parent->mChildren[0] = prenode;
                             }
 
-                            child->mParent = last_parent;
-                            last_parent = child;
+                            prenode->mParent = last_parent;
+                            last_parent = prenode;
 
-                            new_abs_transform *= child->mTransformation;
+                            new_abs_transform *= prenode->mTransformation;
                         }
 
                         // attach geometry
-                        ConvertModel(*model, nodes_chain.back(), root_node, new_abs_transform);
+                        ConvertModel(*model, *nodes_chain.back(), new_abs_transform);
 
                         // check if there will be any child nodes
                         const std::vector<const Connection*>& child_conns
@@ -279,7 +258,7 @@ namespace Assimp {
                             for (aiNode* postnode : post_nodes_chain) {
                                 ai_assert(postnode);
 
-                                if (last_parent != parent) {
+                                if (last_parent != &parent) {
                                     last_parent->mNumChildren = 1;
                                     last_parent->mChildren = new aiNode*[1];
                                     last_parent->mChildren[0] = postnode;
@@ -301,15 +280,15 @@ namespace Assimp {
                             );
                         }
 
-                        // recursion call - child nodes
-                        ConvertNodes(model->ID(), last_parent, root_node);
+                        // attach sub-nodes (if any)
+                        ConvertNodes(model->ID(), *last_parent, new_abs_transform);
 
                         if (doc.Settings().readLights) {
-                            ConvertLights(*model, node_name);
+                            ConvertLights(*model, unique_name);
                         }
 
                         if (doc.Settings().readCameras) {
-                            ConvertCameras(*model, node_name);
+                            ConvertCameras(*model, unique_name);
                         }
 
                         nodes.push_back(nodes_chain.front());
@@ -318,17 +297,11 @@ namespace Assimp {
                 }
 
                 if (nodes.size()) {
-                    parent->mChildren = new aiNode*[nodes.size()]();
-                    parent->mNumChildren = static_cast<unsigned int>(nodes.size());
+                    parent.mChildren = new aiNode*[nodes.size()]();
+                    parent.mNumChildren = static_cast<unsigned int>(nodes.size());
 
-                    std::swap_ranges(nodes.begin(), nodes.end(), parent->mChildren);
+                    std::swap_ranges(nodes.begin(), nodes.end(), parent.mChildren);
                 }
-                else
-                {
-                    parent->mNumChildren = 0;
-                    parent->mChildren = nullptr;
-                }
-                
             }
             catch (std::exception&) {
                 Util::delete_fun<aiNode> deleter;
@@ -830,7 +803,7 @@ namespace Assimp {
             // is_complex needs to be consistent with NeedsComplexTransformationChain()
             // or the interplay between this code and the animation converter would
             // not be guaranteed.
-            //ai_assert(NeedsComplexTransformationChain(model) == ((chainBits & chainMaskComplex) != 0));
+            ai_assert(NeedsComplexTransformationChain(model) == ((chainBits & chainMaskComplex) != 0));
 
             // now, if we have more than just Translation, Scaling and Rotation,
             // we need to generate a full node chain to accommodate for assimp's
@@ -932,8 +905,7 @@ namespace Assimp {
             }
         }
 
-        void FBXConverter::ConvertModel(const Model &model, aiNode *parent, aiNode *root_node,
-                                        const aiMatrix4x4 &absolute_transform)
+        void FBXConverter::ConvertModel(const Model& model, aiNode& nd, const aiMatrix4x4& node_global_transform)
         {
             const std::vector<const Geometry*>& geos = model.GetGeometry();
 
@@ -945,12 +917,11 @@ namespace Assimp {
                 const MeshGeometry* const mesh = dynamic_cast<const MeshGeometry*>(geo);
                 const LineGeometry* const line = dynamic_cast<const LineGeometry*>(geo);
                 if (mesh) {
-                    const std::vector<unsigned int>& indices = ConvertMesh(*mesh, model, parent, root_node,
-                                                                           absolute_transform);
+                    const std::vector<unsigned int>& indices = ConvertMesh(*mesh, model, node_global_transform, nd);
                     std::copy(indices.begin(), indices.end(), std::back_inserter(meshes));
                 }
                 else if (line) {
-                    const std::vector<unsigned int>& indices = ConvertLine(*line, model, parent, root_node);
+                    const std::vector<unsigned int>& indices = ConvertLine(*line, model, node_global_transform, nd);
                     std::copy(indices.begin(), indices.end(), std::back_inserter(meshes));
                 }
                 else {
@@ -959,16 +930,15 @@ namespace Assimp {
             }
 
             if (meshes.size()) {
-                parent->mMeshes = new unsigned int[meshes.size()]();
-                parent->mNumMeshes = static_cast<unsigned int>(meshes.size());
+                nd.mMeshes = new unsigned int[meshes.size()]();
+                nd.mNumMeshes = static_cast<unsigned int>(meshes.size());
 
-                std::swap_ranges(meshes.begin(), meshes.end(), parent->mMeshes);
+                std::swap_ranges(meshes.begin(), meshes.end(), nd.mMeshes);
             }
         }
 
-        std::vector<unsigned int>
-        FBXConverter::ConvertMesh(const MeshGeometry &mesh, const Model &model, aiNode *parent, aiNode *root_node,
-                                  const aiMatrix4x4 &absolute_transform)
+        std::vector<unsigned int> FBXConverter::ConvertMesh(const MeshGeometry& mesh, const Model& model,
+            const aiMatrix4x4& node_global_transform, aiNode& nd)
         {
             std::vector<unsigned int> temp;
 
@@ -992,18 +962,18 @@ namespace Assimp {
                 const MatIndexArray::value_type base = mindices[0];
                 for (MatIndexArray::value_type index : mindices) {
                     if (index != base) {
-                        return ConvertMeshMultiMaterial(mesh, model, parent, root_node, absolute_transform);
+                        return ConvertMeshMultiMaterial(mesh, model, node_global_transform, nd);
                     }
                 }
             }
 
             // faster code-path, just copy the data
-            temp.push_back(ConvertMeshSingleMaterial(mesh, model, absolute_transform, parent, root_node));
+            temp.push_back(ConvertMeshSingleMaterial(mesh, model, node_global_transform, nd));
             return temp;
         }
 
         std::vector<unsigned int> FBXConverter::ConvertLine(const LineGeometry& line, const Model& model,
-                                                            aiNode *parent, aiNode *root_node)
+            const aiMatrix4x4& node_global_transform, aiNode& nd)
         {
             std::vector<unsigned int> temp;
 
@@ -1014,7 +984,7 @@ namespace Assimp {
                 return temp;
             }
 
-            aiMesh* const out_mesh = SetupEmptyMesh(line, root_node);
+            aiMesh* const out_mesh = SetupEmptyMesh(line, nd);
             out_mesh->mPrimitiveTypes |= aiPrimitiveType_LINE;
 
             // copy vertices
@@ -1049,7 +1019,7 @@ namespace Assimp {
             return temp;
         }
 
-        aiMesh* FBXConverter::SetupEmptyMesh(const Geometry& mesh, aiNode *parent)
+        aiMesh* FBXConverter::SetupEmptyMesh(const Geometry& mesh, aiNode& nd)
         {
             aiMesh* const out_mesh = new aiMesh();
             meshes.push_back(out_mesh);
@@ -1066,18 +1036,17 @@ namespace Assimp {
             }
             else
             {
-                out_mesh->mName = parent->mName;
+                out_mesh->mName = nd.mName;
             }
 
             return out_mesh;
         }
 
-        unsigned int FBXConverter::ConvertMeshSingleMaterial(const MeshGeometry &mesh, const Model &model,
-                                                             const aiMatrix4x4 &absolute_transform, aiNode *parent,
-                                                             aiNode *root_node)
+        unsigned int FBXConverter::ConvertMeshSingleMaterial(const MeshGeometry& mesh, const Model& model,
+            const aiMatrix4x4& node_global_transform, aiNode& nd)
         {
             const MatIndexArray& mindices = mesh.GetMaterialIndices();
-            aiMesh* const out_mesh = SetupEmptyMesh(mesh, parent);
+            aiMesh* const out_mesh = SetupEmptyMesh(mesh, nd);
 
             const std::vector<aiVector3D>& vertices = mesh.GetVertices();
             const std::vector<unsigned int>& faces = mesh.GetFaceIndexCounts();
@@ -1144,7 +1113,7 @@ namespace Assimp {
                         binormals = &tempBinormals;
                     }
                     else {
-                        binormals = nullptr;
+                        binormals = NULL;
                     }
                 }
 
@@ -1194,9 +1163,8 @@ namespace Assimp {
                 ConvertMaterialForMesh(out_mesh, model, mesh, mindices[0]);
             }
 
-            if (doc.Settings().readWeights && mesh.DeformerSkin() != nullptr) {
-                ConvertWeights(out_mesh, model, mesh, absolute_transform, parent, root_node, NO_MATERIAL_SEPARATION,
-                               nullptr);
+            if (doc.Settings().readWeights && mesh.DeformerSkin() != NULL) {
+                ConvertWeights(out_mesh, model, mesh, node_global_transform, NO_MATERIAL_SEPARATION);
             }
 
             std::vector<aiAnimMesh*> animMeshes;
@@ -1241,10 +1209,8 @@ namespace Assimp {
             return static_cast<unsigned int>(meshes.size() - 1);
         }
 
-        std::vector<unsigned int>
-        FBXConverter::ConvertMeshMultiMaterial(const MeshGeometry &mesh, const Model &model, aiNode *parent,
-                                               aiNode *root_node,
-                                               const aiMatrix4x4 &absolute_transform)
+        std::vector<unsigned int> FBXConverter::ConvertMeshMultiMaterial(const MeshGeometry& mesh, const Model& model,
+            const aiMatrix4x4& node_global_transform, aiNode& nd)
         {
             const MatIndexArray& mindices = mesh.GetMaterialIndices();
             ai_assert(mindices.size());
@@ -1255,7 +1221,7 @@ namespace Assimp {
             for (MatIndexArray::value_type index : mindices) {
                 if (had.find(index) == had.end()) {
 
-                    indices.push_back(ConvertMeshMultiMaterial(mesh, model, index, parent, root_node, absolute_transform));
+                    indices.push_back(ConvertMeshMultiMaterial(mesh, model, index, node_global_transform, nd));
                     had.insert(index);
                 }
             }
@@ -1263,18 +1229,18 @@ namespace Assimp {
             return indices;
         }
 
-        unsigned int FBXConverter::ConvertMeshMultiMaterial(const MeshGeometry &mesh, const Model &model,
-                                                            MatIndexArray::value_type index,
-                                                            aiNode *parent, aiNode *root_node,
-                                                            const aiMatrix4x4 &absolute_transform)
+        unsigned int FBXConverter::ConvertMeshMultiMaterial(const MeshGeometry& mesh, const Model& model,
+            MatIndexArray::value_type index,
+            const aiMatrix4x4& node_global_transform,
+            aiNode& nd)
         {
-            aiMesh* const out_mesh = SetupEmptyMesh(mesh, parent);
+            aiMesh* const out_mesh = SetupEmptyMesh(mesh, nd);
 
             const MatIndexArray& mindices = mesh.GetMaterialIndices();
             const std::vector<aiVector3D>& vertices = mesh.GetVertices();
             const std::vector<unsigned int>& faces = mesh.GetFaceIndexCounts();
 
-            const bool process_weights = doc.Settings().readWeights && mesh.DeformerSkin() != nullptr;
+            const bool process_weights = doc.Settings().readWeights && mesh.DeformerSkin() != NULL;
 
             unsigned int count_faces = 0;
             unsigned int count_vertices = 0;
@@ -1334,7 +1300,7 @@ namespace Assimp {
                         binormals = &tempBinormals;
                     }
                     else {
-                        binormals = nullptr;
+                        binormals = NULL;
                     }
                 }
 
@@ -1433,7 +1399,7 @@ namespace Assimp {
             ConvertMaterialForMesh(out_mesh, model, mesh, index);
 
             if (process_weights) {
-                ConvertWeights(out_mesh, model, mesh, absolute_transform, parent, root_node, index, &reverseMapping);
+                ConvertWeights(out_mesh, model, mesh, node_global_transform, index, &reverseMapping);
             }
 
             std::vector<aiAnimMesh*> animMeshes;
@@ -1483,10 +1449,10 @@ namespace Assimp {
             return static_cast<unsigned int>(meshes.size() - 1);
         }
 
-        void FBXConverter::ConvertWeights(aiMesh *out, const Model &model, const MeshGeometry &geo,
-                                          const aiMatrix4x4 &absolute_transform,
-                                          aiNode *parent, aiNode *root_node, unsigned int materialIndex,
-                                          std::vector<unsigned int> *outputVertStartIndices)
+        void FBXConverter::ConvertWeights(aiMesh* out, const Model& model, const MeshGeometry& geo,
+            const aiMatrix4x4& node_global_transform,
+            unsigned int materialIndex,
+            std::vector<unsigned int>* outputVertStartIndices)
         {
             ai_assert(geo.DeformerSkin());
 
@@ -1497,12 +1463,13 @@ namespace Assimp {
             const Skin& sk = *geo.DeformerSkin();
 
             std::vector<aiBone*> bones;
+            bones.reserve(sk.Clusters().size());
 
             const bool no_mat_check = materialIndex == NO_MATERIAL_SEPARATION;
             ai_assert(no_mat_check || outputVertStartIndices);
 
             try {
-                // iterate over the sub deformers
+
                 for (const Cluster* cluster : sk.Clusters()) {
                     ai_assert(cluster);
 
@@ -1516,16 +1483,15 @@ namespace Assimp {
                     index_out_indices.clear();
                     out_indices.clear();
 
-
                     // now check if *any* of these weights is contained in the output mesh,
                     // taking notes so we don't need to do it twice.
                     for (WeightIndexArray::value_type index : indices) {
 
                         unsigned int count = 0;
                         const unsigned int* const out_idx = geo.ToOutputVertexIndex(index, count);
-                        // ToOutputVertexIndex only returns nullptr if index is out of bounds
+                        // ToOutputVertexIndex only returns NULL if index is out of bounds
                         // which should never happen
-                        ai_assert(out_idx != nullptr);
+                        ai_assert(out_idx != NULL);
 
                         index_out_indices.push_back(no_index_sentinel);
                         count_out_indices.push_back(0);
@@ -1554,15 +1520,13 @@ namespace Assimp {
                             }
                         }
                     }
-
+                    
                     // if we found at least one, generate the output bones
                     // XXX this could be heavily simplified by collecting the bone
                     // data in a single step.
-                    ConvertCluster(bones, cluster, out_indices, index_out_indices,
-                                   count_out_indices, absolute_transform, parent, root_node);
+                    ConvertCluster(bones, model, *cluster, out_indices, index_out_indices,
+                            count_out_indices, node_global_transform);
                 }
-
-                bone_map.clear();
             }
             catch (std::exception&) {
                 std::for_each(bones.begin(), bones.end(), Util::delete_fun<aiBone>());
@@ -1570,90 +1534,54 @@ namespace Assimp {
             }
 
             if (bones.empty()) {
-                out->mBones = nullptr;
-                out->mNumBones = 0;
                 return;
-            } else {
-                out->mBones = new aiBone *[bones.size()]();
-                out->mNumBones = static_cast<unsigned int>(bones.size());
-
-                std::swap_ranges(bones.begin(), bones.end(), out->mBones);
             }
+
+            out->mBones = new aiBone*[bones.size()]();
+            out->mNumBones = static_cast<unsigned int>(bones.size());
+
+            std::swap_ranges(bones.begin(), bones.end(), out->mBones);
         }
 
-        const aiNode* FBXConverter::GetNodeByName( const aiString& name, aiNode *current_node )
+        void FBXConverter::ConvertCluster(std::vector<aiBone*>& bones, const Model& /*model*/, const Cluster& cl,
+            std::vector<size_t>& out_indices,
+            std::vector<size_t>& index_out_indices,
+            std::vector<size_t>& count_out_indices,
+            const aiMatrix4x4& node_global_transform)
         {
-            aiNode * iter = current_node;
-            //printf("Child count: %d", iter->mNumChildren);
-            return iter;
-        }
 
-        void FBXConverter::ConvertCluster(std::vector<aiBone *> &local_mesh_bones, const Cluster *cl,
-                                          std::vector<size_t> &out_indices, std::vector<size_t> &index_out_indices,
-                                          std::vector<size_t> &count_out_indices, const aiMatrix4x4 &absolute_transform,
-                                          aiNode *parent, aiNode *root_node) {
-            ai_assert(cl); // make sure cluster valid
-            std::string deformer_name = cl->TargetNode()->Name();
-            aiString bone_name = aiString(FixNodeName(deformer_name));
+            aiBone* const bone = new aiBone();
+            bones.push_back(bone);
 
-            aiBone *bone = nullptr;
+            bone->mName = FixNodeName(cl.TargetNode()->Name());
 
-            if (bone_map.count(deformer_name)) {
-				ASSIMP_LOG_DEBUG_F("retrieved bone from lookup ", bone_name.C_Str(), ". Deformer:", deformer_name);
-				bone = bone_map[deformer_name];
-			} else {
-				ASSIMP_LOG_DEBUG_F("created new bone ", bone_name.C_Str(), ". Deformer: ", deformer_name);
-				bone = new aiBone();
-                bone->mName = bone_name;
+            bone->mOffsetMatrix = cl.TransformLink();
+            bone->mOffsetMatrix.Inverse();
 
-                // store local transform link for post processing
-                bone->mOffsetMatrix = cl->TransformLink();
-                bone->mOffsetMatrix.Inverse();
+            bone->mOffsetMatrix = bone->mOffsetMatrix * node_global_transform;
 
-                aiMatrix4x4 matrix = (aiMatrix4x4)absolute_transform;
+            bone->mNumWeights = static_cast<unsigned int>(out_indices.size());
+            aiVertexWeight* cursor = bone->mWeights = new aiVertexWeight[out_indices.size()];
 
-                bone->mOffsetMatrix = bone->mOffsetMatrix * matrix; // * mesh_offset
+            const size_t no_index_sentinel = std::numeric_limits<size_t>::max();
+            const WeightArray& weights = cl.GetWeights();
 
+            const size_t c = index_out_indices.size();
+            for (size_t i = 0; i < c; ++i) {
+                const size_t index_index = index_out_indices[i];
 
-                //
-                // Now calculate the aiVertexWeights
-                //
-
-                aiVertexWeight *cursor = nullptr;
-
-                bone->mNumWeights = static_cast<unsigned int>(out_indices.size());
-                cursor = bone->mWeights = new aiVertexWeight[out_indices.size()];
-
-                const size_t no_index_sentinel = std::numeric_limits<size_t>::max();
-                const WeightArray& weights = cl->GetWeights();
-
-                const size_t c = index_out_indices.size();
-                for (size_t i = 0; i < c; ++i) {
-                    const size_t index_index = index_out_indices[i];
-
-                    if (index_index == no_index_sentinel) {
-                        continue;
-                    }
-
-                    const size_t cc = count_out_indices[i];
-                    for (size_t j = 0; j < cc; ++j) {
-                        // cursor runs from first element relative to the start
-                        // or relative to the start of the next indexes.
-                        aiVertexWeight& out_weight = *cursor++;
-
-                        out_weight.mVertexId = static_cast<unsigned int>(out_indices[index_index + j]);
-                        out_weight.mWeight = weights[i];
-                    }
+                if (index_index == no_index_sentinel) {
+                    continue;
                 }
 
-                bone_map.insert(std::pair<const std::string, aiBone *>(deformer_name, bone));
+                const size_t cc = count_out_indices[i];
+                for (size_t j = 0; j < cc; ++j) {
+                    aiVertexWeight& out_weight = *cursor++;
+
+                    out_weight.mVertexId = static_cast<unsigned int>(out_indices[index_index + j]);
+                    out_weight.mWeight = weights[i];
+                }
             }
-
-            ASSIMP_LOG_DEBUG_F("bone research: Indicies size: ", out_indices.size());
-
-            // lookup must be populated in case something goes wrong
-            // this also allocates bones to mesh instance outside
-            local_mesh_bones.push_back(bone);
         }
 
         void FBXConverter::ConvertMaterialForMesh(aiMesh* out, const Model& model, const MeshGeometry& geo,
@@ -1783,7 +1711,7 @@ namespace Assimp {
                 bool textureReady = false; //tells if our texture is ready (if it was loaded or if it was found)
                 unsigned int index;
 
-                VideoMap::const_iterator it = textures_converted.find(*media);
+                VideoMap::const_iterator it = textures_converted.find(media);
                 if (it != textures_converted.end()) {
                     index = (*it).second;
                     textureReady = true;
@@ -1791,7 +1719,7 @@ namespace Assimp {
                 else {
                     if (media->ContentLength() > 0) {
                         index = ConvertVideo(*media);
-                        textures_converted[*media] = index;
+                        textures_converted[media] = index;
                         textureReady = true;
                     }
                 }
@@ -2088,14 +2016,7 @@ namespace Assimp {
             TrySetTextureProperties(out_mat, textures, "Maya|TEX_emissive_map|file", aiTextureType_EMISSION_COLOR, mesh);
             TrySetTextureProperties(out_mat, textures, "Maya|TEX_metallic_map|file", aiTextureType_METALNESS, mesh);
             TrySetTextureProperties(out_mat, textures, "Maya|TEX_roughness_map|file", aiTextureType_DIFFUSE_ROUGHNESS, mesh);
-            TrySetTextureProperties(out_mat, textures, "Maya|TEX_ao_map|file", aiTextureType_AMBIENT_OCCLUSION, mesh);
-
-            // 3DSMax PBR
-            TrySetTextureProperties(out_mat, textures, "3dsMax|Parameters|base_color_map", aiTextureType_BASE_COLOR, mesh);
-            TrySetTextureProperties(out_mat, textures, "3dsMax|Parameters|bump_map", aiTextureType_NORMAL_CAMERA, mesh);
-            TrySetTextureProperties(out_mat, textures, "3dsMax|Parameters|emission_map", aiTextureType_EMISSION_COLOR, mesh);
-            TrySetTextureProperties(out_mat, textures, "3dsMax|Parameters|metalness_map", aiTextureType_METALNESS, mesh);
-            TrySetTextureProperties(out_mat, textures, "3dsMax|Parameters|roughness_map", aiTextureType_DIFFUSE_ROUGHNESS, mesh);
+            TrySetTextureProperties(out_mat, textures, "Maya|TEX_ao_map|file", aiTextureType_AMBIENT_OCCLUSION, mesh);            
         }
 
         void FBXConverter::SetTextureProperties(aiMaterial* out_mat, const LayeredTextureMap& layeredTextures, const MeshGeometry* const mesh)
@@ -2322,13 +2243,13 @@ void FBXConverter::SetShadingPropertiesRaw(aiMaterial* out_mat, const PropertyTa
             if (media != nullptr && media->ContentLength() > 0) {
                 unsigned int index;
 
-                VideoMap::const_iterator it = textures_converted.find(*media);
+                VideoMap::const_iterator it = textures_converted.find(media);
                 if (it != textures_converted.end()) {
                     index = (*it).second;
                 }
                 else {
                     index = ConvertVideo(*media);
-                    textures_converted[*media] = index;
+                    textures_converted[media] = index;
                 }
 
                 // setup texture reference string (copied from ColladaLoader::FindFilenameForEffectTexture)
@@ -2756,7 +2677,7 @@ void FBXConverter::SetShadingPropertiesRaw(aiMaterial* out_mat, const PropertyTa
         // sanity check whether the input is ok
         static void validateAnimCurveNodes(const std::vector<const AnimationCurveNode*>& curves,
             bool strictMode) {
-            const Object* target(nullptr);
+            const Object* target(NULL);
             for (const AnimationCurveNode* node : curves) {
                 if (!target) {
                     target = node->Target();
@@ -2787,7 +2708,7 @@ void FBXConverter::SetShadingPropertiesRaw(aiMaterial* out_mat, const PropertyTa
 #ifdef ASSIMP_BUILD_DEBUG
             validateAnimCurveNodes(curves, doc.Settings().strictMode);
 #endif
-            const AnimationCurveNode* curve_node = nullptr;
+            const AnimationCurveNode* curve_node = NULL;
             for (const AnimationCurveNode* node : curves) {
                 ai_assert(node);
 
@@ -3612,9 +3533,7 @@ void FBXConverter::SetShadingPropertiesRaw(aiMaterial* out_mat, const PropertyTa
                 return;
             }
 
-            const bool hasGenerator = !doc.Creator().empty();
-
-            out->mMetaData = aiMetadata::Alloc(16 + (hasGenerator ? 1 : 0));
+            out->mMetaData = aiMetadata::Alloc(15);
             out->mMetaData->Set(0, "UpAxis", doc.GlobalSettings().UpAxis());
             out->mMetaData->Set(1, "UpAxisSign", doc.GlobalSettings().UpAxisSign());
             out->mMetaData->Set(2, "FrontAxis", doc.GlobalSettings().FrontAxis());
@@ -3630,11 +3549,6 @@ void FBXConverter::SetShadingPropertiesRaw(aiMaterial* out_mat, const PropertyTa
             out->mMetaData->Set(12, "TimeSpanStart", doc.GlobalSettings().TimeSpanStart());
             out->mMetaData->Set(13, "TimeSpanStop", doc.GlobalSettings().TimeSpanStop());
             out->mMetaData->Set(14, "CustomFrameRate", doc.GlobalSettings().CustomFrameRate());
-            out->mMetaData->Set(15, AI_METADATA_SOURCE_FORMAT_VERSION, aiString(to_string(doc.FBXVersion())));
-            if (hasGenerator)
-            {
-                out->mMetaData->Set(16, AI_METADATA_SOURCE_GENERATOR, aiString(doc.Creator()));
-            }
         }
 
         void FBXConverter::TransferDataToScene()
@@ -3642,7 +3556,7 @@ void FBXConverter::SetShadingPropertiesRaw(aiMaterial* out_mat, const PropertyTa
             ai_assert(!out->mMeshes);
             ai_assert(!out->mNumMeshes);
 
-            // note: the trailing () ensures initialization with nullptr - not
+            // note: the trailing () ensures initialization with NULL - not
             // many C++ users seem to know this, so pointing it out to avoid
             // confusion why this code works.
 
@@ -3689,47 +3603,6 @@ void FBXConverter::SetShadingPropertiesRaw(aiMaterial* out_mat, const PropertyTa
             }
         }
 
-        void FBXConverter::ConvertOrphantEmbeddedTextures()
-        {
-            // in C++14 it could be:
-            // for (auto&& [id, object] : objects)
-            for (auto&& id_and_object : doc.Objects())
-            {
-                auto&& id = std::get<0>(id_and_object);
-                auto&& object = std::get<1>(id_and_object);
-                // If an object doesn't have parent
-                if (doc.ConnectionsBySource().count(id) == 0)
-                {
-                    const Texture* realTexture = nullptr;
-                    try
-                    {
-                        const auto& element = object->GetElement();
-                        const Token& key = element.KeyToken();
-                        const char* obtype = key.begin();
-                        const size_t length = static_cast<size_t>(key.end() - key.begin());
-                        if (strncmp(obtype, "Texture", length) == 0)
-                        {
-                            const Texture* texture = static_cast<const Texture*>(object->Get());
-                            if (texture->Media() && texture->Media()->ContentLength() > 0)
-                            {
-                                realTexture = texture;
-                            }
-                        }
-                    }
-                    catch (...)
-                    {
-                        // do nothing
-                    }
-                    if (realTexture)
-                    {
-                        const Video* media = realTexture->Media();
-                        unsigned int index = ConvertVideo(*media);
-                        textures_converted[*media] = index;
-                    }
-                }
-            }
-        }
-
         // ------------------------------------------------------------------------------------------------
         void ConvertToAssimpScene(aiScene* out, const Document& doc, bool removeEmptyBones)
         {
diff --git a/Engine/lib/assimp/code/FBX/FBXConverter.h b/Engine/lib/assimp/code/FBX/FBXConverter.h
index c5ad47059..77ced1950 100644
--- a/Engine/lib/assimp/code/FBX/FBXConverter.h
+++ b/Engine/lib/assimp/code/FBX/FBXConverter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -123,7 +123,7 @@ private:
 
     // ------------------------------------------------------------------------------------------------
     // collect and assign child nodes
-    void ConvertNodes(uint64_t id, aiNode *parent, aiNode *root_node);
+    void ConvertNodes(uint64_t id, aiNode& parent, const aiMatrix4x4& parent_transform = aiMatrix4x4());
 
     // ------------------------------------------------------------------------------------------------
     void ConvertLights(const Model& model, const std::string &orig_name );
@@ -179,35 +179,32 @@ private:
     void SetupNodeMetadata(const Model& model, aiNode& nd);
 
     // ------------------------------------------------------------------------------------------------
-    void ConvertModel(const Model &model, aiNode *parent, aiNode *root_node,
-                      const aiMatrix4x4 &absolute_transform);
+    void ConvertModel(const Model& model, aiNode& nd, const aiMatrix4x4& node_global_transform);
     
     // ------------------------------------------------------------------------------------------------
     // MeshGeometry -> aiMesh, return mesh index + 1 or 0 if the conversion failed
-    std::vector<unsigned int>
-    ConvertMesh(const MeshGeometry &mesh, const Model &model, aiNode *parent, aiNode *root_node,
-                const aiMatrix4x4 &absolute_transform);
+    std::vector<unsigned int> ConvertMesh(const MeshGeometry& mesh, const Model& model,
+        const aiMatrix4x4& node_global_transform, aiNode& nd);
 
     // ------------------------------------------------------------------------------------------------
     std::vector<unsigned int> ConvertLine(const LineGeometry& line, const Model& model,
-                                          aiNode *parent, aiNode *root_node);
+        const aiMatrix4x4& node_global_transform, aiNode& nd);
 
     // ------------------------------------------------------------------------------------------------
-    aiMesh* SetupEmptyMesh(const Geometry& mesh, aiNode *parent);
+    aiMesh* SetupEmptyMesh(const Geometry& mesh, aiNode& nd);
 
     // ------------------------------------------------------------------------------------------------
-    unsigned int ConvertMeshSingleMaterial(const MeshGeometry &mesh, const Model &model,
-                                           const aiMatrix4x4 &absolute_transform, aiNode *parent,
-                                           aiNode *root_node);
+    unsigned int ConvertMeshSingleMaterial(const MeshGeometry& mesh, const Model& model,
+        const aiMatrix4x4& node_global_transform, aiNode& nd);
 
     // ------------------------------------------------------------------------------------------------
-    std::vector<unsigned int>
-    ConvertMeshMultiMaterial(const MeshGeometry &mesh, const Model &model, aiNode *parent, aiNode *root_node,
-                             const aiMatrix4x4 &absolute_transform);
+    std::vector<unsigned int> ConvertMeshMultiMaterial(const MeshGeometry& mesh, const Model& model,
+        const aiMatrix4x4& node_global_transform, aiNode& nd);
 
     // ------------------------------------------------------------------------------------------------
-    unsigned int ConvertMeshMultiMaterial(const MeshGeometry &mesh, const Model &model, MatIndexArray::value_type index,
-                                          aiNode *parent, aiNode *root_node, const aiMatrix4x4 &absolute_transform);
+    unsigned int ConvertMeshMultiMaterial(const MeshGeometry& mesh, const Model& model,
+        MatIndexArray::value_type index,
+        const aiMatrix4x4& node_global_transform, aiNode& nd);
 
     // ------------------------------------------------------------------------------------------------
     static const unsigned int NO_MATERIAL_SEPARATION = /* std::numeric_limits<unsigned int>::max() */
@@ -220,17 +217,17 @@ private:
     *  - outputVertStartIndices is only used when a material index is specified, it gives for
     *    each output vertex the DOM index it maps to.
     */
-    void ConvertWeights(aiMesh *out, const Model &model, const MeshGeometry &geo, const aiMatrix4x4 &absolute_transform,
-                        aiNode *parent = NULL, aiNode *root_node = NULL,
-                        unsigned int materialIndex = NO_MATERIAL_SEPARATION,
-                        std::vector<unsigned int> *outputVertStartIndices = NULL);
-    // lookup
-    static const aiNode* GetNodeByName( const aiString& name, aiNode *current_node );
+    void ConvertWeights(aiMesh* out, const Model& model, const MeshGeometry& geo,
+        const aiMatrix4x4& node_global_transform = aiMatrix4x4(),
+        unsigned int materialIndex = NO_MATERIAL_SEPARATION,
+        std::vector<unsigned int>* outputVertStartIndices = NULL);
+
     // ------------------------------------------------------------------------------------------------
-    void ConvertCluster(std::vector<aiBone *> &local_mesh_bones, const Cluster *cl,
-                        std::vector<size_t> &out_indices, std::vector<size_t> &index_out_indices,
-                        std::vector<size_t> &count_out_indices, const aiMatrix4x4 &absolute_transform,
-                        aiNode *parent, aiNode *root_node);
+    void ConvertCluster(std::vector<aiBone*>& bones, const Model& /*model*/, const Cluster& cl,
+        std::vector<size_t>& out_indices,
+        std::vector<size_t>& index_out_indices,
+        std::vector<size_t>& count_out_indices,
+        const aiMatrix4x4& node_global_transform);
 
     // ------------------------------------------------------------------------------------------------
     void ConvertMaterialForMesh(aiMesh* out, const Model& model, const MeshGeometry& geo,
@@ -421,18 +418,12 @@ private:
         double& minTime,
         Model::RotOrder order);
 
-    // ------------------------------------------------------------------------------------------------
-    // Copy global geometric data and some information about the source asset into scene metadata.
     void ConvertGlobalSettings();
 
     // ------------------------------------------------------------------------------------------------
     // copy generated meshes, animations, lights, cameras and textures to the output scene
     void TransferDataToScene();
 
-    // ------------------------------------------------------------------------------------------------
-    // FBX file could have embedded textures not connected to anything
-    void ConvertOrphantEmbeddedTextures();
-
 private:
     // 0: not assigned yet, others: index is value - 1
     unsigned int defaultMaterialIndex;
@@ -444,47 +435,27 @@ private:
     std::vector<aiCamera*> cameras;
     std::vector<aiTexture*> textures;
 
-    using MaterialMap = std::fbx_unordered_map<const Material*, unsigned int>;
+    using MaterialMap = std::map<const Material*, unsigned int>;
     MaterialMap materials_converted;
 
-    using VideoMap = std::fbx_unordered_map<const Video, unsigned int>;
+    using VideoMap = std::map<const Video*, unsigned int>;
     VideoMap textures_converted;
 
-    using MeshMap = std::fbx_unordered_map<const Geometry*, std::vector<unsigned int> >;
+    using MeshMap = std::map<const Geometry*, std::vector<unsigned int> >;
     MeshMap meshes_converted;
 
     // fixed node name -> which trafo chain components have animations?
-    using NodeAnimBitMap = std::fbx_unordered_map<std::string, unsigned int> ;
+    using NodeAnimBitMap = std::map<std::string, unsigned int> ;
     NodeAnimBitMap node_anim_chain_bits;
 
     // number of nodes with the same name
-    using NodeNameCache = std::fbx_unordered_map<std::string, unsigned int>;
+    using NodeNameCache = std::unordered_map<std::string, unsigned int>;
     NodeNameCache mNodeNames;
 
-    // Deformer name is not the same as a bone name - it does contain the bone name though :)
-    // Deformer names in FBX are always unique in an FBX file.
-    std::map<const std::string, aiBone *> bone_map;
-
     double anim_fps;
 
     aiScene* const out;
     const FBX::Document& doc;
-
-    static void BuildBoneList(aiNode *current_node, const aiNode *root_node, const aiScene *scene,
-                             std::vector<aiBone*>& bones);
-
-    void BuildBoneStack(aiNode *current_node, const aiNode *root_node, const aiScene *scene,
-                   const std::vector<aiBone *> &bones,
-                   std::map<aiBone *, aiNode *> &bone_stack,
-                   std::vector<aiNode*> &node_stack );
-
-    static void BuildNodeList(aiNode *current_node, std::vector<aiNode *> &nodes);
-
-    static aiNode *GetNodeFromStack(const aiString &node_name, std::vector<aiNode *> &nodes);
-
-    static aiNode *GetArmatureRoot(aiNode *bone_node, std::vector<aiBone*> &bone_list);
-
-    static bool IsBoneNode(const aiString &bone_name, std::vector<aiBone *> &bones);
 };
 
 }
diff --git a/Engine/lib/assimp/code/FBX/FBXDeformer.cpp b/Engine/lib/assimp/code/FBX/FBXDeformer.cpp
index 4b76cd0fa..692755345 100644
--- a/Engine/lib/assimp/code/FBX/FBXDeformer.cpp
+++ b/Engine/lib/assimp/code/FBX/FBXDeformer.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/FBX/FBXDocument.cpp b/Engine/lib/assimp/code/FBX/FBXDocument.cpp
index ddb971b3f..506fd978d 100644
--- a/Engine/lib/assimp/code/FBX/FBXDocument.cpp
+++ b/Engine/lib/assimp/code/FBX/FBXDocument.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/FBX/FBXDocument.h b/Engine/lib/assimp/code/FBX/FBXDocument.h
index 8984b3df7..18e5c38f1 100644
--- a/Engine/lib/assimp/code/FBX/FBXDocument.h
+++ b/Engine/lib/assimp/code/FBX/FBXDocument.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -637,20 +637,6 @@ public:
         return ptr;
     }
 
-    bool operator==(const Video& other) const
-    {
-        return (
-               type == other.type
-            && relativeFileName == other.relativeFileName
-            && fileName == other.fileName
-        );
-    }
-
-    bool operator<(const Video& other) const
-    {
-        return std::tie(type, relativeFileName, fileName) < std::tie(other.type, other.relativeFileName, other.fileName);
-    }
-
 private:
     std::string type;
     std::string relativeFileName;
@@ -1019,10 +1005,10 @@ public:
 // during their entire lifetime (Document). FBX files have
 // up to many thousands of objects (most of which we never use),
 // so the memory overhead for them should be kept at a minimum.
-typedef std::fbx_unordered_map<uint64_t, LazyObject*> ObjectMap;
+typedef std::map<uint64_t, LazyObject*> ObjectMap;
 typedef std::fbx_unordered_map<std::string, std::shared_ptr<const PropertyTable> > PropertyTemplateMap;
 
-typedef std::fbx_unordered_multimap<uint64_t, const Connection*> ConnectionMap;
+typedef std::multimap<uint64_t, const Connection*> ConnectionMap;
 
 /** DOM class for global document settings, a single instance per document can
  *  be accessed via Document.Globals(). */
@@ -1191,25 +1177,4 @@ private:
 } // Namespace FBX
 } // Namespace Assimp
 
-namespace std
-{
-    template <>
-    struct hash<const Assimp::FBX::Video>
-    {
-        std::size_t operator()(const Assimp::FBX::Video& video) const
-        {
-            using std::size_t;
-            using std::hash;
-            using std::string;
-
-            size_t res = 17;
-            res = res * 31 + hash<string>()(video.Name());
-            res = res * 31 + hash<string>()(video.RelativeFilename());
-            res = res * 31 + hash<string>()(video.Type());
-
-            return res;
-        }
-    };
-}
-
 #endif // INCLUDED_AI_FBX_DOCUMENT_H
diff --git a/Engine/lib/assimp/code/FBX/FBXDocumentUtil.cpp b/Engine/lib/assimp/code/FBX/FBXDocumentUtil.cpp
index 7178e9f26..f84691479 100644
--- a/Engine/lib/assimp/code/FBX/FBXDocumentUtil.cpp
+++ b/Engine/lib/assimp/code/FBX/FBXDocumentUtil.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/FBX/FBXDocumentUtil.h b/Engine/lib/assimp/code/FBX/FBXDocumentUtil.h
index 2d76ee031..2450109e5 100644
--- a/Engine/lib/assimp/code/FBX/FBXDocumentUtil.h
+++ b/Engine/lib/assimp/code/FBX/FBXDocumentUtil.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2012, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
diff --git a/Engine/lib/assimp/code/FBX/FBXExportNode.cpp b/Engine/lib/assimp/code/FBX/FBXExportNode.cpp
index 53aa719f4..06c89cee4 100644
--- a/Engine/lib/assimp/code/FBX/FBXExportNode.cpp
+++ b/Engine/lib/assimp/code/FBX/FBXExportNode.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
@@ -325,9 +325,9 @@ void FBX::Node::BeginBinary(Assimp::StreamWriterLE &s)
     this->start_pos = s.Tell();
 
     // placeholders for end pos and property section info
-    s.PutU8(0); // end pos
-    s.PutU8(0); // number of properties
-    s.PutU8(0); // total property section length
+    s.PutU4(0); // end pos
+    s.PutU4(0); // number of properties
+    s.PutU4(0); // total property section length
 
     // node name
     s.PutU1(uint8_t(name.size())); // length of node name
@@ -352,9 +352,9 @@ void FBX::Node::EndPropertiesBinary(
     size_t pos = s.Tell();
     ai_assert(pos > property_start);
     size_t property_section_size = pos - property_start;
-    s.Seek(start_pos + 8); // 8 bytes of uint64_t of end_pos
-    s.PutU8(num_properties);
-    s.PutU8(property_section_size);
+    s.Seek(start_pos + 4);
+    s.PutU4(uint32_t(num_properties));
+    s.PutU4(uint32_t(property_section_size));
     s.Seek(pos);
 }
 
@@ -375,7 +375,7 @@ void FBX::Node::EndBinary(
     // now go back and write initial pos
     this->end_pos = s.Tell();
     s.Seek(start_pos);
-    s.PutU8(end_pos);
+    s.PutU4(uint32_t(end_pos));
     s.Seek(end_pos);
 }
 
diff --git a/Engine/lib/assimp/code/FBX/FBXExportNode.h b/Engine/lib/assimp/code/FBX/FBXExportNode.h
index 2e8f491a1..ef3bc781a 100644
--- a/Engine/lib/assimp/code/FBX/FBXExportNode.h
+++ b/Engine/lib/assimp/code/FBX/FBXExportNode.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
diff --git a/Engine/lib/assimp/code/FBX/FBXExportProperty.cpp b/Engine/lib/assimp/code/FBX/FBXExportProperty.cpp
index 11ee35003..f2a63b72b 100644
--- a/Engine/lib/assimp/code/FBX/FBXExportProperty.cpp
+++ b/Engine/lib/assimp/code/FBX/FBXExportProperty.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
diff --git a/Engine/lib/assimp/code/FBX/FBXExportProperty.h b/Engine/lib/assimp/code/FBX/FBXExportProperty.h
index 6baae8b69..d692fe6ee 100644
--- a/Engine/lib/assimp/code/FBX/FBXExportProperty.h
+++ b/Engine/lib/assimp/code/FBX/FBXExportProperty.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
diff --git a/Engine/lib/assimp/code/FBX/FBXExporter.cpp b/Engine/lib/assimp/code/FBX/FBXExporter.cpp
index 594951e78..25d057df1 100644
--- a/Engine/lib/assimp/code/FBX/FBXExporter.cpp
+++ b/Engine/lib/assimp/code/FBX/FBXExporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
@@ -81,8 +81,8 @@ using namespace Assimp::FBX;
 // some constants that we'll use for writing metadata
 namespace Assimp {
 namespace FBX {
-    const std::string EXPORT_VERSION_STR = "7.5.0";
-    const uint32_t EXPORT_VERSION_INT = 7500; // 7.5 == 2016+
+    const std::string EXPORT_VERSION_STR = "7.4.0";
+    const uint32_t EXPORT_VERSION_INT = 7400; // 7.4 == 2014/2015
     // FBX files have some hashed values that depend on the creation time field,
     // but for now we don't actually know how to generate these.
     // what we can do is set them to a known-working version.
@@ -1289,7 +1289,7 @@ void FBXExporter::WriteObjects ()
 
         for(unsigned int lr = 1; lr < m->GetNumUVChannels(); ++ lr)
         {
-            FBX::Node layerExtra("Layer", int32_t(lr));
+            FBX::Node layerExtra("Layer", int32_t(1));
             layerExtra.AddChild("Version", int32_t(100));
             FBX::Node leExtra("LayerElement");
             leExtra.AddChild("Type", "LayerElementUV");
@@ -1860,7 +1860,6 @@ void FBXExporter::WriteObjects ()
             sdnode.AddChild("Version", int32_t(100));
             sdnode.AddChild("UserData", "", "");
 
-            std::set<int32_t> setWeightedVertex;
             // add indices and weights, if any
             if (b) {
                 std::vector<int32_t> subdef_indices;
@@ -1868,8 +1867,7 @@ void FBXExporter::WriteObjects ()
                 int32_t last_index = -1;
                 for (size_t wi = 0; wi < b->mNumWeights; ++wi) {
                     int32_t vi = vertex_indices[b->mWeights[wi].mVertexId];
-                    bool bIsWeightedAlready = (setWeightedVertex.find(vi) != setWeightedVertex.end());
-                    if (vi == last_index || bIsWeightedAlready) {
+                    if (vi == last_index) {
                         // only for vertices we exported to fbx
                         // TODO, FIXME: this assumes identically-located vertices
                         // will always deform in the same way.
@@ -1879,7 +1877,6 @@ void FBXExporter::WriteObjects ()
                         // identical vertex.
                         continue;
                     }
-                    setWeightedVertex.insert(vi);
                     subdef_indices.push_back(vi);
                     subdef_weights.push_back(b->mWeights[wi].mWeight);
                     last_index = vi;
diff --git a/Engine/lib/assimp/code/FBX/FBXExporter.h b/Engine/lib/assimp/code/FBX/FBXExporter.h
index eb8bfaf3b..1ae727eda 100644
--- a/Engine/lib/assimp/code/FBX/FBXExporter.h
+++ b/Engine/lib/assimp/code/FBX/FBXExporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
diff --git a/Engine/lib/assimp/code/FBX/FBXImportSettings.h b/Engine/lib/assimp/code/FBX/FBXImportSettings.h
index 974931b4c..1a4c80f8b 100644
--- a/Engine/lib/assimp/code/FBX/FBXImportSettings.h
+++ b/Engine/lib/assimp/code/FBX/FBXImportSettings.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/FBX/FBXImporter.cpp b/Engine/lib/assimp/code/FBX/FBXImporter.cpp
index 571f60883..c8c1a6853 100644
--- a/Engine/lib/assimp/code/FBX/FBXImporter.cpp
+++ b/Engine/lib/assimp/code/FBX/FBXImporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -48,26 +48,26 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "FBXImporter.h"
 
-#include "FBXConverter.h"
-#include "FBXDocument.h"
-#include "FBXParser.h"
 #include "FBXTokenizer.h"
+#include "FBXParser.h"
 #include "FBXUtil.h"
+#include "FBXDocument.h"
+#include "FBXConverter.h"
 
-#include <assimp/MemoryIOWrapper.h>
 #include <assimp/StreamReader.h>
-#include <assimp/importerdesc.h>
+#include <assimp/MemoryIOWrapper.h>
 #include <assimp/Importer.hpp>
+#include <assimp/importerdesc.h>
 
 namespace Assimp {
 
-template <>
-const char *LogFunctions<FBXImporter>::Prefix() {
-	static auto prefix = "FBX: ";
-	return prefix;
+template<>
+const char* LogFunctions<FBXImporter>::Prefix() {
+    static auto prefix = "FBX: ";
+    return prefix;
 }
 
-} // namespace Assimp
+}
 
 using namespace Assimp;
 using namespace Assimp::Formatter;
@@ -76,123 +76,131 @@ using namespace Assimp::FBX;
 namespace {
 
 static const aiImporterDesc desc = {
-	"Autodesk FBX Importer",
-	"",
-	"",
-	"",
-	aiImporterFlags_SupportTextFlavour,
-	0,
-	0,
-	0,
-	0,
-	"fbx"
+    "Autodesk FBX Importer",
+    "",
+    "",
+    "",
+    aiImporterFlags_SupportTextFlavour,
+    0,
+    0,
+    0,
+    0,
+    "fbx"
 };
 }
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by #Importer
-FBXImporter::FBXImporter() {
+FBXImporter::FBXImporter()
+{
 }
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-FBXImporter::~FBXImporter() {
+FBXImporter::~FBXImporter()
+{
 }
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool FBXImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const {
-	const std::string &extension = GetExtension(pFile);
-	if (extension == std::string(desc.mFileExtensions)) {
-		return true;
-	}
+bool FBXImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
+{
+    const std::string& extension = GetExtension(pFile);
+    if (extension == std::string( desc.mFileExtensions ) ) {
+        return true;
+    }
 
-	else if ((!extension.length() || checkSig) && pIOHandler) {
-		// at least ASCII-FBX files usually have a 'FBX' somewhere in their head
-		const char *tokens[] = { "fbx" };
-		return SearchFileHeaderForToken(pIOHandler, pFile, tokens, 1);
-	}
-	return false;
+    else if ((!extension.length() || checkSig) && pIOHandler)   {
+        // at least ASCII-FBX files usually have a 'FBX' somewhere in their head
+        const char* tokens[] = {"fbx"};
+        return SearchFileHeaderForToken(pIOHandler,pFile,tokens,1);
+    }
+    return false;
 }
 
 // ------------------------------------------------------------------------------------------------
 // List all extensions handled by this loader
-const aiImporterDesc *FBXImporter::GetInfo() const {
-	return &desc;
+const aiImporterDesc* FBXImporter::GetInfo () const
+{
+    return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup configuration properties for the loader
-void FBXImporter::SetupProperties(const Importer *pImp) {
-	settings.readAllLayers = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_ALL_GEOMETRY_LAYERS, true);
-	settings.readAllMaterials = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_ALL_MATERIALS, false);
-	settings.readMaterials = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_MATERIALS, true);
-	settings.readTextures = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_TEXTURES, true);
-	settings.readCameras = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_CAMERAS, true);
-	settings.readLights = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_LIGHTS, true);
-	settings.readAnimations = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_ANIMATIONS, true);
-	settings.strictMode = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_STRICT_MODE, false);
-	settings.preservePivots = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_PRESERVE_PIVOTS, true);
-	settings.optimizeEmptyAnimationCurves = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_OPTIMIZE_EMPTY_ANIMATION_CURVES, true);
-	settings.useLegacyEmbeddedTextureNaming = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_EMBEDDED_TEXTURES_LEGACY_NAMING, false);
-	settings.removeEmptyBones = pImp->GetPropertyBool(AI_CONFIG_IMPORT_REMOVE_EMPTY_BONES, true);
-	settings.convertToMeters = pImp->GetPropertyBool(AI_CONFIG_FBX_CONVERT_TO_M, false);
+void FBXImporter::SetupProperties(const Importer* pImp)
+{
+    settings.readAllLayers = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_ALL_GEOMETRY_LAYERS, true);
+    settings.readAllMaterials = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_ALL_MATERIALS, false);
+    settings.readMaterials = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_MATERIALS, true);
+    settings.readTextures = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_TEXTURES, true);
+    settings.readCameras = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_CAMERAS, true);
+    settings.readLights = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_LIGHTS, true);
+    settings.readAnimations = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_ANIMATIONS, true);
+    settings.strictMode = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_STRICT_MODE, false);
+    settings.preservePivots = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_PRESERVE_PIVOTS, true);
+    settings.optimizeEmptyAnimationCurves = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_OPTIMIZE_EMPTY_ANIMATION_CURVES, true);
+    settings.useLegacyEmbeddedTextureNaming = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_EMBEDDED_TEXTURES_LEGACY_NAMING, false);
+    settings.removeEmptyBones = pImp->GetPropertyBool(AI_CONFIG_IMPORT_REMOVE_EMPTY_BONES, true);
+    settings.convertToMeters = pImp->GetPropertyBool(AI_CONFIG_FBX_CONVERT_TO_M, false);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void FBXImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
-	std::unique_ptr<IOStream> stream(pIOHandler->Open(pFile, "rb"));
-	if (!stream) {
-		ThrowException("Could not open file for reading");
-	}
+void FBXImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler)
+{
+    std::unique_ptr<IOStream> stream(pIOHandler->Open(pFile,"rb"));
+    if (!stream) {
+        ThrowException("Could not open file for reading");
+    }
 
-	// read entire file into memory - no streaming for this, fbx
-	// files can grow large, but the assimp output data structure
-	// then becomes very large, too. Assimp doesn't support
-	// streaming for its output data structures so the net win with
-	// streaming input data would be very low.
-	std::vector<char> contents;
-	contents.resize(stream->FileSize() + 1);
-	stream->Read(&*contents.begin(), 1, contents.size() - 1);
-	contents[contents.size() - 1] = 0;
-	const char *const begin = &*contents.begin();
+    // read entire file into memory - no streaming for this, fbx
+    // files can grow large, but the assimp output data structure
+    // then becomes very large, too. Assimp doesn't support
+    // streaming for its output data structures so the net win with
+    // streaming input data would be very low.
+    std::vector<char> contents;
+    contents.resize(stream->FileSize()+1);
+    stream->Read( &*contents.begin(), 1, contents.size()-1 );
+    contents[ contents.size() - 1 ] = 0;
+    const char* const begin = &*contents.begin();
 
-	// broadphase tokenizing pass in which we identify the core
-	// syntax elements of FBX (brackets, commas, key:value mappings)
-	TokenList tokens;
-	try {
+    // broadphase tokenizing pass in which we identify the core
+    // syntax elements of FBX (brackets, commas, key:value mappings)
+    TokenList tokens;
+    try {
 
-		bool is_binary = false;
-		if (!strncmp(begin, "Kaydara FBX Binary", 18)) {
-			is_binary = true;
-			TokenizeBinary(tokens, begin, contents.size());
-		} else {
-			Tokenize(tokens, begin);
-		}
+        bool is_binary = false;
+        if (!strncmp(begin,"Kaydara FBX Binary",18)) {
+            is_binary = true;
+            TokenizeBinary(tokens,begin,contents.size());
+        }
+        else {
+            Tokenize(tokens,begin);
+        }
 
-		// use this information to construct a very rudimentary
-		// parse-tree representing the FBX scope structure
-		Parser parser(tokens, is_binary);
+        // use this information to construct a very rudimentary
+        // parse-tree representing the FBX scope structure
+        Parser parser(tokens, is_binary);
 
-		// take the raw parse-tree and convert it to a FBX DOM
-		Document doc(parser, settings);
+        // take the raw parse-tree and convert it to a FBX DOM
+        Document doc(parser,settings);
 
-		// convert the FBX DOM to aiScene
-		ConvertToAssimpScene(pScene, doc, settings.removeEmptyBones);
+        // convert the FBX DOM to aiScene
+        ConvertToAssimpScene(pScene, doc, settings.removeEmptyBones);
 
-		// size relative to cm
-		float size_relative_to_cm = doc.GlobalSettings().UnitScaleFactor();
+        // size relative to cm
+        float size_relative_to_cm = doc.GlobalSettings().UnitScaleFactor();
 
-		// Set FBX file scale is relative to CM must be converted to M for
-		// assimp universal format (M)
-		SetFileScale(size_relative_to_cm * 0.01f);
+        // Set FBX file scale is relative to CM must be converted to M for
+        // assimp universal format (M)
+        SetFileScale( size_relative_to_cm * 0.01f);
 
-		std::for_each(tokens.begin(), tokens.end(), Util::delete_fun<Token>());
-	} catch (std::exception &) {
-		std::for_each(tokens.begin(), tokens.end(), Util::delete_fun<Token>());
-		throw;
-	}
+        std::for_each(tokens.begin(),tokens.end(),Util::delete_fun<Token>());
+    }
+    catch(std::exception&) {
+        std::for_each(tokens.begin(),tokens.end(),Util::delete_fun<Token>());
+        throw;
+    }
 }
 
 #endif // !ASSIMP_BUILD_NO_FBX_IMPORTER
diff --git a/Engine/lib/assimp/code/FBX/FBXImporter.h b/Engine/lib/assimp/code/FBX/FBXImporter.h
index 63375e40d..c365b2cdd 100644
--- a/Engine/lib/assimp/code/FBX/FBXImporter.h
+++ b/Engine/lib/assimp/code/FBX/FBXImporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/FBX/FBXMaterial.cpp b/Engine/lib/assimp/code/FBX/FBXMaterial.cpp
index 88ac9db16..f43a8b84b 100644
--- a/Engine/lib/assimp/code/FBX/FBXMaterial.cpp
+++ b/Engine/lib/assimp/code/FBX/FBXMaterial.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/FBX/FBXMeshGeometry.cpp b/Engine/lib/assimp/code/FBX/FBXMeshGeometry.cpp
index 4a3de9f99..1386e2383 100644
--- a/Engine/lib/assimp/code/FBX/FBXMeshGeometry.cpp
+++ b/Engine/lib/assimp/code/FBX/FBXMeshGeometry.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -446,19 +446,14 @@ void ResolveVertexDataArray(std::vector<T>& data_out, const Scope& source,
             return;
         }
         std::vector<T> tempData;
-        ParseVectorDataArray(tempData, GetRequiredElement(source, dataElementName));
-
-        if (tempData.size() != mapping_offsets.size()) {
-            FBXImporter::LogError(Formatter::format("length of input data unexpected for ByVertice mapping: ")
-                                  << tempData.size() << ", expected " << mapping_offsets.size());
-            return;
-        }
+		ParseVectorDataArray(tempData, GetRequiredElement(source, dataElementName));
 
         data_out.resize(vertex_count);
-        for (size_t i = 0, e = tempData.size(); i < e; ++i) {
+		for (size_t i = 0, e = tempData.size(); i < e; ++i) {
+
             const unsigned int istart = mapping_offsets[i], iend = istart + mapping_counts[i];
             for (unsigned int j = istart; j < iend; ++j) {
-                data_out[mappings[j]] = tempData[i];
+				data_out[mappings[j]] = tempData[i];
             }
         }
     }
@@ -466,17 +461,10 @@ void ResolveVertexDataArray(std::vector<T>& data_out, const Scope& source,
 		std::vector<T> tempData;
 		ParseVectorDataArray(tempData, GetRequiredElement(source, dataElementName));
 
-        std::vector<int> uvIndices;
-        ParseVectorDataArray(uvIndices,GetRequiredElement(source,indexDataElementName));
-
-        if (uvIndices.size() != vertex_count) {
-            FBXImporter::LogError(Formatter::format("length of input data unexpected for ByVertice mapping: ")
-                                  << uvIndices.size() << ", expected " << vertex_count);
-            return;
-        }
-
         data_out.resize(vertex_count);
 
+        std::vector<int> uvIndices;
+        ParseVectorDataArray(uvIndices,GetRequiredElement(source,indexDataElementName));
         for (size_t i = 0, e = uvIndices.size(); i < e; ++i) {
 
             const unsigned int istart = mapping_offsets[i], iend = istart + mapping_counts[i];
@@ -505,17 +493,16 @@ void ResolveVertexDataArray(std::vector<T>& data_out, const Scope& source,
 		std::vector<T> tempData;
 		ParseVectorDataArray(tempData, GetRequiredElement(source, dataElementName));
 
+        data_out.resize(vertex_count);
+
         std::vector<int> uvIndices;
         ParseVectorDataArray(uvIndices,GetRequiredElement(source,indexDataElementName));
 
         if (uvIndices.size() != vertex_count) {
-            FBXImporter::LogError(Formatter::format("length of input data unexpected for ByPolygonVertex mapping: ")
-                                  << uvIndices.size() << ", expected " << vertex_count);
+            FBXImporter::LogError("length of input data unexpected for ByPolygonVertex mapping");
             return;
         }
 
-        data_out.resize(vertex_count);
-
         const T empty;
         unsigned int next = 0;
         for(int i : uvIndices) {
diff --git a/Engine/lib/assimp/code/FBX/FBXMeshGeometry.h b/Engine/lib/assimp/code/FBX/FBXMeshGeometry.h
index 97265e4b2..d6d451217 100644
--- a/Engine/lib/assimp/code/FBX/FBXMeshGeometry.h
+++ b/Engine/lib/assimp/code/FBX/FBXMeshGeometry.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/FBX/FBXModel.cpp b/Engine/lib/assimp/code/FBX/FBXModel.cpp
index e34f3a610..589af36ac 100644
--- a/Engine/lib/assimp/code/FBX/FBXModel.cpp
+++ b/Engine/lib/assimp/code/FBX/FBXModel.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/FBX/FBXNodeAttribute.cpp b/Engine/lib/assimp/code/FBX/FBXNodeAttribute.cpp
index 2ebf917e3..b72e5637e 100644
--- a/Engine/lib/assimp/code/FBX/FBXNodeAttribute.cpp
+++ b/Engine/lib/assimp/code/FBX/FBXNodeAttribute.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/FBX/FBXParser.cpp b/Engine/lib/assimp/code/FBX/FBXParser.cpp
index aef59d60c..4a9346040 100644
--- a/Engine/lib/assimp/code/FBX/FBXParser.cpp
+++ b/Engine/lib/assimp/code/FBX/FBXParser.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -367,13 +367,9 @@ float ParseTokenAsFloat(const Token& t, const char*& err_out)
     // first - next in the fbx token stream comes ',',
     // which fast_atof could interpret as decimal point.
 #define MAX_FLOAT_LENGTH 31
-    const size_t length = static_cast<size_t>(t.end()-t.begin());
-    if (length > MAX_FLOAT_LENGTH) {
-        return 0.f;
-    }
-
     char temp[MAX_FLOAT_LENGTH + 1];
-    std::copy(t.begin(), t.end(), temp);
+    const size_t length = static_cast<size_t>(t.end()-t.begin());
+    std::copy(t.begin(),t.end(),temp);
     temp[std::min(static_cast<size_t>(MAX_FLOAT_LENGTH),length)] = '\0';
 
     return fast_atof(temp);
diff --git a/Engine/lib/assimp/code/FBX/FBXParser.h b/Engine/lib/assimp/code/FBX/FBXParser.h
index 5d8d00307..7b0cf7203 100644
--- a/Engine/lib/assimp/code/FBX/FBXParser.h
+++ b/Engine/lib/assimp/code/FBX/FBXParser.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/FBX/FBXProperties.cpp b/Engine/lib/assimp/code/FBX/FBXProperties.cpp
index f6b804894..8d7036b6a 100644
--- a/Engine/lib/assimp/code/FBX/FBXProperties.cpp
+++ b/Engine/lib/assimp/code/FBX/FBXProperties.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/FBX/FBXProperties.h b/Engine/lib/assimp/code/FBX/FBXProperties.h
index 209d5e940..58755542f 100644
--- a/Engine/lib/assimp/code/FBX/FBXProperties.h
+++ b/Engine/lib/assimp/code/FBX/FBXProperties.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/FBX/FBXTokenizer.cpp b/Engine/lib/assimp/code/FBX/FBXTokenizer.cpp
index 831c40061..252cce355 100644
--- a/Engine/lib/assimp/code/FBX/FBXTokenizer.cpp
+++ b/Engine/lib/assimp/code/FBX/FBXTokenizer.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/FBX/FBXTokenizer.h b/Engine/lib/assimp/code/FBX/FBXTokenizer.h
index cadc82770..afa588a47 100644
--- a/Engine/lib/assimp/code/FBX/FBXTokenizer.h
+++ b/Engine/lib/assimp/code/FBX/FBXTokenizer.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/FBX/FBXUtil.cpp b/Engine/lib/assimp/code/FBX/FBXUtil.cpp
index 50dd78a4c..c10e057c8 100644
--- a/Engine/lib/assimp/code/FBX/FBXUtil.cpp
+++ b/Engine/lib/assimp/code/FBX/FBXUtil.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/FBX/FBXUtil.h b/Engine/lib/assimp/code/FBX/FBXUtil.h
index 77bb0ad30..b63441885 100644
--- a/Engine/lib/assimp/code/FBX/FBXUtil.h
+++ b/Engine/lib/assimp/code/FBX/FBXUtil.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/HMP/HMPFileData.h b/Engine/lib/assimp/code/HMP/HMPFileData.h
index bad8dde5c..ab4100174 100644
--- a/Engine/lib/assimp/code/HMP/HMPFileData.h
+++ b/Engine/lib/assimp/code/HMP/HMPFileData.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/HMP/HMPLoader.cpp b/Engine/lib/assimp/code/HMP/HMPLoader.cpp
index 0d1334fdd..d5469181e 100644
--- a/Engine/lib/assimp/code/HMP/HMPLoader.cpp
+++ b/Engine/lib/assimp/code/HMP/HMPLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/HMP/HMPLoader.h b/Engine/lib/assimp/code/HMP/HMPLoader.h
index 0371a608b..421826c91 100644
--- a/Engine/lib/assimp/code/HMP/HMPLoader.h
+++ b/Engine/lib/assimp/code/HMP/HMPLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/HMP/HalfLifeFileData.h b/Engine/lib/assimp/code/HMP/HalfLifeFileData.h
index d7db1476c..ef328edf8 100644
--- a/Engine/lib/assimp/code/HMP/HalfLifeFileData.h
+++ b/Engine/lib/assimp/code/HMP/HalfLifeFileData.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCBoolean.cpp b/Engine/lib/assimp/code/Importer/IFC/IFCBoolean.cpp
index 01fd43cd2..10e7bf3af 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCBoolean.cpp
+++ b/Engine/lib/assimp/code/Importer/IFC/IFCBoolean.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2010, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCCurve.cpp b/Engine/lib/assimp/code/Importer/IFC/IFCCurve.cpp
index b16df9c5c..a817b4f9f 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCCurve.cpp
+++ b/Engine/lib/assimp/code/Importer/IFC/IFCCurve.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -323,7 +323,7 @@ public:
         // oh well.
         bool have_param = false, have_point = false;
         IfcVector3 point;
-        for(const Entry& sel :entity.Trim1) {
+        for(const Entry sel :entity.Trim1) {
             if (const ::Assimp::STEP::EXPRESS::REAL* const r = sel->ToPtr<::Assimp::STEP::EXPRESS::REAL>()) {
                 range.first = *r;
                 have_param = true;
@@ -340,7 +340,7 @@ public:
             }
         }
         have_param = false, have_point = false;
-        for(const Entry& sel :entity.Trim2) {
+        for(const Entry sel :entity.Trim2) {
             if (const ::Assimp::STEP::EXPRESS::REAL* const r = sel->ToPtr<::Assimp::STEP::EXPRESS::REAL>()) {
                 range.second = *r;
                 have_param = true;
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCGeometry.cpp b/Engine/lib/assimp/code/Importer/IFC/IFCGeometry.cpp
index bb4d74758..d1c7aee19 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCGeometry.cpp
+++ b/Engine/lib/assimp/code/Importer/IFC/IFCGeometry.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2010, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -138,9 +138,8 @@ void ProcessPolygonBoundaries(TempMesh& result, const TempMesh& inmesh, size_t m
             }
         }
     }
-	if (outer_polygon_it == end) {
-		return;
-	}
+
+    ai_assert(outer_polygon_it != end);
 
     const size_t outer_polygon_size = *outer_polygon_it;
     const IfcVector3& master_normal = normals[std::distance(begin, outer_polygon_it)];
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCLoader.cpp b/Engine/lib/assimp/code/Importer/IFC/IFCLoader.cpp
index 5dd19f320..5c705c256 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCLoader.cpp
+++ b/Engine/lib/assimp/code/Importer/IFC/IFCLoader.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCLoader.h b/Engine/lib/assimp/code/Importer/IFC/IFCLoader.h
index 4abfe00f1..678c60343 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCLoader.h
+++ b/Engine/lib/assimp/code/Importer/IFC/IFCLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCMaterial.cpp b/Engine/lib/assimp/code/Importer/IFC/IFCMaterial.cpp
index 832712cd4..5fda0a1de 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCMaterial.cpp
+++ b/Engine/lib/assimp/code/Importer/IFC/IFCMaterial.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCOpenings.cpp b/Engine/lib/assimp/code/Importer/IFC/IFCOpenings.cpp
index 2c6754287..d6c40b383 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCOpenings.cpp
+++ b/Engine/lib/assimp/code/Importer/IFC/IFCOpenings.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2010, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCProfile.cpp b/Engine/lib/assimp/code/Importer/IFC/IFCProfile.cpp
index a1a1b3967..daafc9afe 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCProfile.cpp
+++ b/Engine/lib/assimp/code/Importer/IFC/IFCProfile.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen1_2x3.cpp b/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen1_2x3.cpp
index 58ff47113..f4dbed1d1 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen1_2x3.cpp
+++ b/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen1_2x3.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (ASSIMP)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, ASSIMP Development Team
+Copyright (c) 2006-2010, ASSIMP Development Team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms, 
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen2_2x3.cpp b/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen2_2x3.cpp
index e6687014d..7dabe278e 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen2_2x3.cpp
+++ b/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen2_2x3.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (ASSIMP)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, ASSIMP Development Team
+Copyright (c) 2006-2010, ASSIMP Development Team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms, 
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen_2x3.h b/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen_2x3.h
index 4605b94cf..8b39ccdc2 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen_2x3.h
+++ b/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen_2x3.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (ASSIMP)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, ASSIMP Development Team
+Copyright (c) 2006-2010, ASSIMP Development Team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen_4.cpp b/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen_4.cpp
index 9eb3e2446..fdefedb18 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen_4.cpp
+++ b/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen_4.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (ASSIMP)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, ASSIMP Development Team
+Copyright (c) 2006-2010, ASSIMP Development Team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms, 
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen_4.h b/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen_4.h
index 0f184cd02..ccfcb6ea0 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen_4.h
+++ b/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen_4.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (ASSIMP)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, ASSIMP Development Team
+Copyright (c) 2006-2010, ASSIMP Development Team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms, 
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCUtil.cpp b/Engine/lib/assimp/code/Importer/IFC/IFCUtil.cpp
index 3557b4baa..f6bca91f5 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCUtil.cpp
+++ b/Engine/lib/assimp/code/Importer/IFC/IFCUtil.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCUtil.h b/Engine/lib/assimp/code/Importer/IFC/IFCUtil.h
index cf8c94293..32ae1e07f 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCUtil.h
+++ b/Engine/lib/assimp/code/Importer/IFC/IFCUtil.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Importer/STEPParser/STEPFileEncoding.cpp b/Engine/lib/assimp/code/Importer/STEPParser/STEPFileEncoding.cpp
index d917c28f3..101dcdfd7 100644
--- a/Engine/lib/assimp/code/Importer/STEPParser/STEPFileEncoding.cpp
+++ b/Engine/lib/assimp/code/Importer/STEPParser/STEPFileEncoding.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Importer/STEPParser/STEPFileEncoding.h b/Engine/lib/assimp/code/Importer/STEPParser/STEPFileEncoding.h
index a076d1ce9..09f16ba33 100644
--- a/Engine/lib/assimp/code/Importer/STEPParser/STEPFileEncoding.h
+++ b/Engine/lib/assimp/code/Importer/STEPParser/STEPFileEncoding.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Importer/STEPParser/STEPFileReader.cpp b/Engine/lib/assimp/code/Importer/STEPParser/STEPFileReader.cpp
index 72f882d6e..f099d2be7 100644
--- a/Engine/lib/assimp/code/Importer/STEPParser/STEPFileReader.cpp
+++ b/Engine/lib/assimp/code/Importer/STEPParser/STEPFileReader.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Importer/STEPParser/STEPFileReader.h b/Engine/lib/assimp/code/Importer/STEPParser/STEPFileReader.h
index 62292792a..9c4b77241 100644
--- a/Engine/lib/assimp/code/Importer/STEPParser/STEPFileReader.h
+++ b/Engine/lib/assimp/code/Importer/STEPParser/STEPFileReader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Importer/StepFile/StepFileGen1.cpp b/Engine/lib/assimp/code/Importer/StepFile/StepFileGen1.cpp
index 234300700..50c54818e 100644
--- a/Engine/lib/assimp/code/Importer/StepFile/StepFileGen1.cpp
+++ b/Engine/lib/assimp/code/Importer/StepFile/StepFileGen1.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (ASSIMP)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, ASSIMP Development Team
+Copyright (c) 2006-2018, ASSIMP Development Team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms, 
diff --git a/Engine/lib/assimp/code/Importer/StepFile/StepFileGen2.cpp b/Engine/lib/assimp/code/Importer/StepFile/StepFileGen2.cpp
index a80bb69ef..eca09e4e1 100644
--- a/Engine/lib/assimp/code/Importer/StepFile/StepFileGen2.cpp
+++ b/Engine/lib/assimp/code/Importer/StepFile/StepFileGen2.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (ASSIMP)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, ASSIMP Development Team
+Copyright (c) 2006-2010, ASSIMP Development Team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
diff --git a/Engine/lib/assimp/code/Importer/StepFile/StepFileGen3.cpp b/Engine/lib/assimp/code/Importer/StepFile/StepFileGen3.cpp
index 2f25683a8..d8d81141f 100644
--- a/Engine/lib/assimp/code/Importer/StepFile/StepFileGen3.cpp
+++ b/Engine/lib/assimp/code/Importer/StepFile/StepFileGen3.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (ASSIMP)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, ASSIMP Development Team
+Copyright (c) 2006-2010, ASSIMP Development Team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
diff --git a/Engine/lib/assimp/code/Importer/StepFile/StepFileImporter.cpp b/Engine/lib/assimp/code/Importer/StepFile/StepFileImporter.cpp
index 28744c785..26c456ac9 100644
--- a/Engine/lib/assimp/code/Importer/StepFile/StepFileImporter.cpp
+++ b/Engine/lib/assimp/code/Importer/StepFile/StepFileImporter.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/Importer/StepFile/StepFileImporter.h b/Engine/lib/assimp/code/Importer/StepFile/StepFileImporter.h
index c6ac08bb6..70f65fdcf 100644
--- a/Engine/lib/assimp/code/Importer/StepFile/StepFileImporter.h
+++ b/Engine/lib/assimp/code/Importer/StepFile/StepFileImporter.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/Importer/StepFile/StepReaderGen.h b/Engine/lib/assimp/code/Importer/StepFile/StepReaderGen.h
index cb1034e2b..9eb86c332 100644
--- a/Engine/lib/assimp/code/Importer/StepFile/StepReaderGen.h
+++ b/Engine/lib/assimp/code/Importer/StepFile/StepReaderGen.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (ASSIMP)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, ASSIMP Development Team
+Copyright (c) 2006-2018, ASSIMP Development Team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms, 
diff --git a/Engine/lib/assimp/code/Irr/IRRLoader.cpp b/Engine/lib/assimp/code/Irr/IRRLoader.cpp
index 4361d578a..e94fd85a4 100644
--- a/Engine/lib/assimp/code/Irr/IRRLoader.cpp
+++ b/Engine/lib/assimp/code/Irr/IRRLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/Irr/IRRLoader.h b/Engine/lib/assimp/code/Irr/IRRLoader.h
index fc6f77031..b3ad81a7d 100644
--- a/Engine/lib/assimp/code/Irr/IRRLoader.h
+++ b/Engine/lib/assimp/code/Irr/IRRLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Irr/IRRMeshLoader.cpp b/Engine/lib/assimp/code/Irr/IRRMeshLoader.cpp
index 13db70e91..f3aed5943 100644
--- a/Engine/lib/assimp/code/Irr/IRRMeshLoader.cpp
+++ b/Engine/lib/assimp/code/Irr/IRRMeshLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -57,6 +57,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/material.h>
 #include <assimp/scene.h>
 #include <assimp/importerdesc.h>
+#include <assimp/Macros.h>
 
 using namespace Assimp;
 using namespace irr;
diff --git a/Engine/lib/assimp/code/Irr/IRRMeshLoader.h b/Engine/lib/assimp/code/Irr/IRRMeshLoader.h
index f0d249f71..d8b42d78d 100644
--- a/Engine/lib/assimp/code/Irr/IRRMeshLoader.h
+++ b/Engine/lib/assimp/code/Irr/IRRMeshLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Irr/IRRShared.cpp b/Engine/lib/assimp/code/Irr/IRRShared.cpp
index 5dacc2ae1..ecac031ab 100644
--- a/Engine/lib/assimp/code/Irr/IRRShared.cpp
+++ b/Engine/lib/assimp/code/Irr/IRRShared.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/LWO/LWOAnimation.cpp b/Engine/lib/assimp/code/LWO/LWOAnimation.cpp
index ae9c4c13b..3a0d2c392 100644
--- a/Engine/lib/assimp/code/LWO/LWOAnimation.cpp
+++ b/Engine/lib/assimp/code/LWO/LWOAnimation.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/LWO/LWOAnimation.h b/Engine/lib/assimp/code/LWO/LWOAnimation.h
index a46787965..dd29695cc 100644
--- a/Engine/lib/assimp/code/LWO/LWOAnimation.h
+++ b/Engine/lib/assimp/code/LWO/LWOAnimation.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/LWO/LWOBLoader.cpp b/Engine/lib/assimp/code/LWO/LWOBLoader.cpp
index fe542df1b..b24957072 100644
--- a/Engine/lib/assimp/code/LWO/LWOBLoader.cpp
+++ b/Engine/lib/assimp/code/LWO/LWOBLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/LWO/LWOFileData.h b/Engine/lib/assimp/code/LWO/LWOFileData.h
index 33fac8c39..7d1f6b1df 100644
--- a/Engine/lib/assimp/code/LWO/LWOFileData.h
+++ b/Engine/lib/assimp/code/LWO/LWOFileData.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/LWO/LWOLoader.cpp b/Engine/lib/assimp/code/LWO/LWOLoader.cpp
index cb581f7f5..1e5b92c32 100644
--- a/Engine/lib/assimp/code/LWO/LWOLoader.cpp
+++ b/Engine/lib/assimp/code/LWO/LWOLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -586,6 +586,7 @@ void LWOImporter::GenerateNodeGraph(std::map<uint16_t,aiNode*>& apcNodes)
     root->mName.Set("<LWORoot>");
 
     //Set parent of all children, inserting pivots
+    //std::cout << "Set parent of all children" << std::endl;
     std::map<uint16_t, aiNode*> mapPivot;
     for (auto itapcNodes = apcNodes.begin(); itapcNodes != apcNodes.end(); ++itapcNodes) {
 
@@ -617,6 +618,7 @@ void LWOImporter::GenerateNodeGraph(std::map<uint16_t,aiNode*>& apcNodes)
     }
 
     //Merge pivot map into node map
+    //std::cout << "Merge pivot map into node map" << std::endl;
     for (auto itMapPivot = mapPivot.begin(); itMapPivot != mapPivot.end(); ++itMapPivot) {
         apcNodes[itMapPivot->first] = itMapPivot->second;
     }
diff --git a/Engine/lib/assimp/code/LWO/LWOLoader.h b/Engine/lib/assimp/code/LWO/LWOLoader.h
index 680f82923..05b958fd2 100644
--- a/Engine/lib/assimp/code/LWO/LWOLoader.h
+++ b/Engine/lib/assimp/code/LWO/LWOLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/LWO/LWOMaterial.cpp b/Engine/lib/assimp/code/LWO/LWOMaterial.cpp
index b2304a6be..b54c21c26 100644
--- a/Engine/lib/assimp/code/LWO/LWOMaterial.cpp
+++ b/Engine/lib/assimp/code/LWO/LWOMaterial.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/LWS/LWSLoader.cpp b/Engine/lib/assimp/code/LWS/LWSLoader.cpp
index 4a9cec4ec..b52cafa6d 100644
--- a/Engine/lib/assimp/code/LWS/LWSLoader.cpp
+++ b/Engine/lib/assimp/code/LWS/LWSLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/LWS/LWSLoader.h b/Engine/lib/assimp/code/LWS/LWSLoader.h
index c1321af37..eed0491f3 100644
--- a/Engine/lib/assimp/code/LWS/LWSLoader.h
+++ b/Engine/lib/assimp/code/LWS/LWSLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/M3D/M3DExporter.cpp b/Engine/lib/assimp/code/M3D/M3DExporter.cpp
deleted file mode 100644
index 08a0e4ad8..000000000
--- a/Engine/lib/assimp/code/M3D/M3DExporter.cpp
+++ /dev/null
@@ -1,437 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-Copyright (c) 2019 bzt
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-#ifndef ASSIMP_BUILD_NO_EXPORT
-#ifndef ASSIMP_BUILD_NO_M3D_EXPORTER
-
-#define M3D_IMPLEMENTATION
-#define M3D_NOIMPORTER
-#define M3D_EXPORTER
-#ifndef ASSIMP_BUILD_NO_M3D_IMPORTER
-#define M3D_NODUP
-#endif
-
-// Header files, standard library.
-#include <memory> // shared_ptr
-#include <string>
-#include <vector>
-
-#include <assimp/Exceptional.h> // DeadlyExportError
-#include <assimp/StreamWriter.h> // StreamWriterLE
-#include <assimp/material.h> // aiTextureType
-#include <assimp/mesh.h>
-#include <assimp/scene.h>
-#include <assimp/version.h> // aiGetVersion
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/Exporter.hpp>
-#include <assimp/IOSystem.hpp>
-
-#include "M3DWrapper.h"
-#include "M3DExporter.h"
-#include "M3DMaterials.h"
-
-// RESOURCES:
-// https://gitlab.com/bztsrc/model3d/blob/master/docs/m3d_format.md
-// https://gitlab.com/bztsrc/model3d/blob/master/docs/a3d_format.md
-
-/*
- * Currently supports static meshes, vertex colors, materials, textures
- *
- * For animation, it would require the following conversions:
- *  - aiNode (bones) -> m3d_t.bone (with parent id, position vector and oriantation quaternion)
- *  - aiMesh.aiBone -> m3d_t.skin (per vertex, with bone id, weight pairs)
- *  - aiAnimation -> m3d_action (frame with timestamp and list of bone id, position, orientation
- *      triplets, instead of per bone timestamp + lists)
- */
-
-// ------------------------------------------------------------------------------------------------
-// Conversion functions
-// ------------------------------------------------------------------------------------------------
-// helper to add a vertex (private to NodeWalk)
-m3dv_t *AddVrtx(m3dv_t *vrtx, uint32_t *numvrtx, m3dv_t *v, uint32_t *idx) {
-	if (v->x == (M3D_FLOAT)-0.0) v->x = (M3D_FLOAT)0.0;
-	if (v->y == (M3D_FLOAT)-0.0) v->y = (M3D_FLOAT)0.0;
-	if (v->z == (M3D_FLOAT)-0.0) v->z = (M3D_FLOAT)0.0;
-	if (v->w == (M3D_FLOAT)-0.0) v->w = (M3D_FLOAT)0.0;
-	vrtx = (m3dv_t *)M3D_REALLOC(vrtx, ((*numvrtx) + 1) * sizeof(m3dv_t));
-	memcpy(&vrtx[*numvrtx], v, sizeof(m3dv_t));
-	*idx = *numvrtx;
-	(*numvrtx)++;
-	return vrtx;
-}
-
-// ------------------------------------------------------------------------------------------------
-// helper to add a tmap (private to NodeWalk)
-m3dti_t *AddTmap(m3dti_t *tmap, uint32_t *numtmap, m3dti_t *ti, uint32_t *idx) {
-	tmap = (m3dti_t *)M3D_REALLOC(tmap, ((*numtmap) + 1) * sizeof(m3dti_t));
-	memcpy(&tmap[*numtmap], ti, sizeof(m3dti_t));
-	*idx = *numtmap;
-	(*numtmap)++;
-	return tmap;
-}
-
-// ------------------------------------------------------------------------------------------------
-// convert aiColor4D into uint32_t
-uint32_t mkColor(aiColor4D *c) {
-	return ((uint8_t)(c->a * 255) << 24L) |
-		   ((uint8_t)(c->b * 255) << 16L) |
-		   ((uint8_t)(c->g * 255) << 8L) |
-		   ((uint8_t)(c->r * 255) << 0L);
-}
-
-// ------------------------------------------------------------------------------------------------
-// add a material property to the output
-void addProp(m3dm_t *m, uint8_t type, uint32_t value) {
-	unsigned int i;
-	i = m->numprop++;
-	m->prop = (m3dp_t *)M3D_REALLOC(m->prop, m->numprop * sizeof(m3dp_t));
-	if (!m->prop) {
-		throw DeadlyExportError("memory allocation error");
-	}
-	m->prop[i].type = type;
-	m->prop[i].value.num = value;
-}
-
-// ------------------------------------------------------------------------------------------------
-// convert aiString to identifier safe C string. This is a duplication of _m3d_safestr
-char *SafeStr(aiString str, bool isStrict)
-{
-	char *s = (char *)&str.data;
-	char *d, *ret;
-	int i, len;
-
-	for(len = str.length + 1; *s && (*s == ' ' || *s == '\t'); s++, len--);
-	if(len > 255) len = 255;
-	ret = (char *)M3D_MALLOC(len + 1);
-	if (!ret) {
-		throw DeadlyExportError("memory allocation error");
-	}
-	for(i = 0, d = ret; i < len && *s && *s != '\r' && *s != '\n'; s++, d++, i++) {
-		*d = isStrict && (*s == ' ' || *s == '\t' || *s == '/' || *s == '\\') ? '_' : (*s == '\t' ? ' ' : *s);
-	}
-	for(; d > ret && (*(d-1) == ' ' || *(d-1) == '\t'); d--);
-	*d = 0;
-	return ret;
-}
-
-// ------------------------------------------------------------------------------------------------
-// add a material to the output
-M3D_INDEX addMaterial(const Assimp::M3DWrapper &m3d, const aiMaterial *mat) {
-	unsigned int mi = M3D_NOTDEFINED;
-	aiColor4D c;
-	aiString name;
-	ai_real f;
-	char *fn;
-
-	if (mat && mat->Get(AI_MATKEY_NAME, name) == AI_SUCCESS && name.length &&
-			strcmp((char *)&name.data, AI_DEFAULT_MATERIAL_NAME)) {
-		// check if we have saved a material by this name. This has to be done
-		// because only the referenced materials should be added to the output
-		for (unsigned int i = 0; i < m3d->nummaterial; i++)
-			if (!strcmp((char *)&name.data, m3d->material[i].name)) {
-				mi = i;
-				break;
-			}
-		// if not found, add the material to the output
-		if (mi == M3D_NOTDEFINED) {
-			unsigned int k;
-			mi = m3d->nummaterial++;
-			m3d->material = (m3dm_t *)M3D_REALLOC(m3d->material, m3d->nummaterial * sizeof(m3dm_t));
-			if (!m3d->material) {
-				throw DeadlyExportError("memory allocation error");
-			}
-			m3d->material[mi].name = SafeStr(name, true);
-			m3d->material[mi].numprop = 0;
-			m3d->material[mi].prop = NULL;
-			// iterate through the material property table and see what we got
-			for (k = 0; k < 15; k++) {
-				unsigned int j;
-				if (m3d_propertytypes[k].format == m3dpf_map)
-					continue;
-				if (aiProps[k].pKey) {
-					switch (m3d_propertytypes[k].format) {
-						case m3dpf_color:
-							if (mat->Get(aiProps[k].pKey, aiProps[k].type,
-										aiProps[k].index, c) == AI_SUCCESS)
-								addProp(&m3d->material[mi],
-										m3d_propertytypes[k].id, mkColor(&c));
-							break;
-						case m3dpf_float:
-							if (mat->Get(aiProps[k].pKey, aiProps[k].type,
-										aiProps[k].index, f) == AI_SUCCESS)
-								addProp(&m3d->material[mi],
-										m3d_propertytypes[k].id,
-										/* not (uint32_t)f, because we don't want to convert
-                                         * it, we want to see it as 32 bits of memory */
-										*((uint32_t *)&f));
-							break;
-						case m3dpf_uint8:
-							if (mat->Get(aiProps[k].pKey, aiProps[k].type,
-										aiProps[k].index, j) == AI_SUCCESS) {
-								// special conversion for illumination model property
-								if (m3d_propertytypes[k].id == m3dp_il) {
-									switch (j) {
-										case aiShadingMode_NoShading: j = 0; break;
-										case aiShadingMode_Phong: j = 2; break;
-										default: j = 1; break;
-									}
-								}
-								addProp(&m3d->material[mi],
-										m3d_propertytypes[k].id, j);
-							}
-							break;
-						default:
-							if (mat->Get(aiProps[k].pKey, aiProps[k].type,
-										aiProps[k].index, j) == AI_SUCCESS)
-								addProp(&m3d->material[mi],
-										m3d_propertytypes[k].id, j);
-							break;
-					}
-				}
-				if (aiTxProps[k].pKey &&
-						mat->GetTexture((aiTextureType)aiTxProps[k].type,
-								aiTxProps[k].index, &name, NULL, NULL, NULL,
-								NULL, NULL) == AI_SUCCESS) {
-					unsigned int i;
-					for (j = name.length - 1; j > 0 && name.data[j] != '.'; j++)
-						;
-					if (j && name.data[j] == '.' &&
-							(name.data[j + 1] == 'p' || name.data[j + 1] == 'P') &&
-							(name.data[j + 1] == 'n' || name.data[j + 1] == 'N') &&
-							(name.data[j + 1] == 'g' || name.data[j + 1] == 'G'))
-						name.data[j] = 0;
-					// do we have this texture saved already?
-					fn = SafeStr(name, true);
-					for (j = 0, i = M3D_NOTDEFINED; j < m3d->numtexture; j++)
-						if (!strcmp(fn, m3d->texture[j].name)) {
-							i = j;
-							free(fn);
-							break;
-						}
-					if (i == M3D_NOTDEFINED) {
-						i = m3d->numtexture++;
-						m3d->texture = (m3dtx_t *)M3D_REALLOC(
-								m3d->texture,
-								m3d->numtexture * sizeof(m3dtx_t));
-						if (!m3d->texture) {
-							throw DeadlyExportError("memory allocation error");
-						}
-						// we don't need the texture itself, only its name
-						m3d->texture[i].name = fn;
-						m3d->texture[i].w = 0;
-						m3d->texture[i].h = 0;
-						m3d->texture[i].d = NULL;
-					}
-					addProp(&m3d->material[mi],
-							m3d_propertytypes[k].id + 128, i);
-				}
-			}
-		}
-	}
-	return mi;
-}
-
-namespace Assimp {
-
-// ---------------------------------------------------------------------
-// Worker function for exporting a scene to binary M3D.
-// Prototyped and registered in Exporter.cpp
-void ExportSceneM3D(
-		const char *pFile,
-		IOSystem *pIOSystem,
-		const aiScene *pScene,
-		const ExportProperties *pProperties) {
-	// initialize the exporter
-	M3DExporter exporter(pScene, pProperties);
-
-	// perform binary export
-	exporter.doExport(pFile, pIOSystem, false);
-}
-
-// ---------------------------------------------------------------------
-// Worker function for exporting a scene to ASCII A3D.
-// Prototyped and registered in Exporter.cpp
-void ExportSceneM3DA(
-		const char *pFile,
-		IOSystem *pIOSystem,
-		const aiScene *pScene,
-		const ExportProperties *pProperties
-
-) {
-#ifdef M3D_ASCII
-	// initialize the exporter
-	M3DExporter exporter(pScene, pProperties);
-
-	// perform ascii export
-	exporter.doExport(pFile, pIOSystem, true);
-#else
-	throw DeadlyExportError("Assimp configured without M3D_ASCII support");
-#endif
-}
-
-// ------------------------------------------------------------------------------------------------
-M3DExporter::M3DExporter(const aiScene *pScene, const ExportProperties *pProperties) :
-		mScene(pScene),
-		mProperties(pProperties),
-		outfile() {}
-
-// ------------------------------------------------------------------------------------------------
-void M3DExporter::doExport(
-		const char *pFile,
-		IOSystem *pIOSystem,
-		bool toAscii) {
-	// TODO: convert mProperties into M3D_EXP_* flags
-	(void)mProperties;
-
-	// open the indicated file for writing (in binary / ASCII mode)
-	outfile.reset(pIOSystem->Open(pFile, toAscii ? "wt" : "wb"));
-	if (!outfile) {
-		throw DeadlyExportError("could not open output .m3d file: " + std::string(pFile));
-	}
-
-	M3DWrapper m3d;
-	if (!m3d) {
-		throw DeadlyExportError("memory allocation error");
-	}
-	m3d->name = SafeStr(mScene->mRootNode->mName, false);
-
-	// Create a model from assimp structures
-	aiMatrix4x4 m;
-	NodeWalk(m3d, mScene->mRootNode, m);
-
-	// serialize the structures
-	unsigned int size;
-	unsigned char *output = m3d.Save(M3D_EXP_FLOAT, M3D_EXP_EXTRA | (toAscii ? M3D_EXP_ASCII : 0), size);
-
-	if (!output || size < 8) {
-		throw DeadlyExportError("unable to serialize into Model 3D");
-	}
-
-	// Write out serialized model
-	outfile->Write(output, size, 1);
-
-	// explicitly release file pointer,
-	// so we don't have to rely on class destruction.
-	outfile.reset();
-}
-
-// ------------------------------------------------------------------------------------------------
-// recursive node walker
-void M3DExporter::NodeWalk(const M3DWrapper &m3d, const aiNode *pNode, aiMatrix4x4 m) {
-	aiMatrix4x4 nm = m * pNode->mTransformation;
-
-	for (unsigned int i = 0; i < pNode->mNumMeshes; i++) {
-		const aiMesh *mesh = mScene->mMeshes[pNode->mMeshes[i]];
-		unsigned int mi = M3D_NOTDEFINED;
-		if (mScene->mMaterials) {
-			// get the material for this mesh
-			mi = addMaterial(m3d, mScene->mMaterials[mesh->mMaterialIndex]);
-		}
-		// iterate through the mesh faces
-		for (unsigned int j = 0; j < mesh->mNumFaces; j++) {
-			unsigned int n;
-			const aiFace *face = &(mesh->mFaces[j]);
-			// only triangle meshes supported for now
-			if (face->mNumIndices != 3) {
-				throw DeadlyExportError("use aiProcess_Triangulate before export");
-			}
-			// add triangle to the output
-			n = m3d->numface++;
-			m3d->face = (m3df_t *)M3D_REALLOC(m3d->face,
-					m3d->numface * sizeof(m3df_t));
-			if (!m3d->face) {
-				throw DeadlyExportError("memory allocation error");
-			}
-			/* set all index to -1 by default */
-			m3d->face[n].vertex[0] = m3d->face[n].vertex[1] = m3d->face[n].vertex[2] =
-					m3d->face[n].normal[0] = m3d->face[n].normal[1] = m3d->face[n].normal[2] =
-							m3d->face[n].texcoord[0] = m3d->face[n].texcoord[1] = m3d->face[n].texcoord[2] = M3D_UNDEF;
-			m3d->face[n].materialid = mi;
-			for (unsigned int k = 0; k < face->mNumIndices; k++) {
-				// get the vertex's index
-				unsigned int l = face->mIndices[k];
-				unsigned int idx;
-				m3dv_t vertex;
-				m3dti_t ti;
-				// multiply the position vector by the transformation matrix
-				aiVector3D v = mesh->mVertices[l];
-				v *= nm;
-				vertex.x = v.x;
-				vertex.y = v.y;
-				vertex.z = v.z;
-				vertex.w = 1.0;
-				vertex.color = 0;
-				vertex.skinid = M3D_UNDEF;
-				// add color if defined
-				if (mesh->HasVertexColors(0))
-					vertex.color = mkColor(&mesh->mColors[0][l]);
-				// save the vertex to the output
-				m3d->vertex = AddVrtx(m3d->vertex, &m3d->numvertex,
-						&vertex, &idx);
-				m3d->face[n].vertex[k] = (M3D_INDEX)idx;
-				// do we have texture coordinates?
-				if (mesh->HasTextureCoords(0)) {
-					ti.u = mesh->mTextureCoords[0][l].x;
-					ti.v = mesh->mTextureCoords[0][l].y;
-					m3d->tmap = AddTmap(m3d->tmap, &m3d->numtmap, &ti, &idx);
-					m3d->face[n].texcoord[k] = (M3D_INDEX)idx;
-				}
-				// do we have normal vectors?
-				if (mesh->HasNormals()) {
-					vertex.x = mesh->mNormals[l].x;
-					vertex.y = mesh->mNormals[l].y;
-					vertex.z = mesh->mNormals[l].z;
-					vertex.color = 0;
-					m3d->vertex = AddVrtx(m3d->vertex, &m3d->numvertex, &vertex, &idx);
-					m3d->face[n].normal[k] = (M3D_INDEX)idx;
-				}
-			}
-		}
-	}
-	// repeat for the children nodes
-	for (unsigned int i = 0; i < pNode->mNumChildren; i++) {
-		NodeWalk(m3d, pNode->mChildren[i], nm);
-	}
-}
-} // namespace Assimp
-
-#endif // ASSIMP_BUILD_NO_M3D_EXPORTER
-#endif // ASSIMP_BUILD_NO_EXPORT
diff --git a/Engine/lib/assimp/code/M3D/M3DExporter.h b/Engine/lib/assimp/code/M3D/M3DExporter.h
deleted file mode 100644
index 40fce44d0..000000000
--- a/Engine/lib/assimp/code/M3D/M3DExporter.h
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-Copyright (c) 2019 bzt
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file M3DExporter.h
-*   @brief Declares the exporter class to write a scene to a Model 3D file
-*/
-#ifndef AI_M3DEXPORTER_H_INC
-#define AI_M3DEXPORTER_H_INC
-
-#ifndef ASSIMP_BUILD_NO_M3D_EXPORTER
-
-#include <assimp/types.h>
-//#include <assimp/material.h>
-#include <assimp/StreamWriter.h> // StreamWriterLE
-#include <assimp/Exceptional.h> // DeadlyExportError
-
-#include <memory> // shared_ptr
-
-struct aiScene;
-struct aiNode;
-struct aiMaterial;
-struct aiFace;
-
-namespace Assimp
-{
-    class IOSystem;
-    class IOStream;
-    class ExportProperties;
-
-    class M3DWrapper;
-
-    // ---------------------------------------------------------------------
-    /** Helper class to export a given scene to an M3D file. */
-    // ---------------------------------------------------------------------
-    class M3DExporter
-    {
-    public:
-        /// Constructor for a specific scene to export
-        M3DExporter(const aiScene* pScene, const ExportProperties* pProperties);
-        // call this to do the actual export
-        void doExport(const char* pFile, IOSystem* pIOSystem, bool toAscii);
-
-    private:
-        const aiScene* mScene; // the scene to export
-        const ExportProperties* mProperties; // currently unused
-        std::shared_ptr<IOStream> outfile; // file to write to
-
-        // helper to do the recursive walking
-        void NodeWalk(const M3DWrapper &m3d, const aiNode* pNode, aiMatrix4x4 m);
-    };
-}
-
-#endif // ASSIMP_BUILD_NO_M3D_EXPORTER
-
-#endif // AI_M3DEXPORTER_H_INC
diff --git a/Engine/lib/assimp/code/M3D/M3DImporter.cpp b/Engine/lib/assimp/code/M3D/M3DImporter.cpp
deleted file mode 100644
index 9aee14f75..000000000
--- a/Engine/lib/assimp/code/M3D/M3DImporter.cpp
+++ /dev/null
@@ -1,806 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-Copyright (c) 2019 bzt
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-#ifndef ASSIMP_BUILD_NO_M3D_IMPORTER
-
-#define M3D_IMPLEMENTATION
-#define M3D_NONORMALS /* leave the post-processing to Assimp */
-#define M3D_NOWEIGHTS
-#define M3D_NOANIMATION
-
-#include <assimp/DefaultIOSystem.h>
-#include <assimp/IOStreamBuffer.h>
-#include <assimp/ai_assert.h>
-#include <assimp/importerdesc.h>
-#include <assimp/scene.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/Importer.hpp>
-#include <memory>
-
-#include "M3DWrapper.h"
-#include "M3DImporter.h"
-#include "M3DMaterials.h"
-
-// RESOURCES:
-// https://gitlab.com/bztsrc/model3d/blob/master/docs/m3d_format.md
-// https://gitlab.com/bztsrc/model3d/blob/master/docs/a3d_format.md
-
-/*
- Unfortunately aiNode has bone structures and meshes too, yet we can't assign
- the mesh to a bone aiNode as a skin may refer to several aiNodes. Therefore
- I've decided to import into this structure:
-
-   aiScene->mRootNode
-    |        |->mMeshes (all the meshes)
-    |        \->children (empty if there's no skeleton imported, no meshes)
-    |             \->skeleton root aiNode*
-    |                   |->bone aiNode
-    |                   |   \->subbone aiNode
-    |                   |->bone aiNode
-    |                   |   ...
-    |                   \->bone aiNode
-    \->mMeshes[]
-        \->aiBone, referencing mesh-less aiNodes from above
-
-  * - normally one, but if a model has several skeleton roots, then all of them
-      are listed in aiScene->mRootNode->children, but all without meshes
-*/
-
-static const aiImporterDesc desc = {
-	"Model 3D Importer",
-	"",
-	"",
-	"",
-	aiImporterFlags_SupportTextFlavour | aiImporterFlags_SupportBinaryFlavour,
-	0,
-	0,
-	0,
-	0,
-#ifdef M3D_ASCII
-	"m3d a3d"
-#else
-	"m3d"
-#endif
-};
-
-namespace Assimp {
-
-using namespace std;
-
-// ------------------------------------------------------------------------------------------------
-//  Default constructor
-M3DImporter::M3DImporter() :
-		mScene(nullptr) {
-			// empty
-		}
-
-// ------------------------------------------------------------------------------------------------
-//  Returns true, if file is a binary or ASCII Model 3D file.
-bool M3DImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const {
-	const std::string extension = GetExtension(pFile);
-
-	if (extension == "m3d"
-#ifdef M3D_ASCII
-		|| extension == "a3d"
-#endif
-		)
-		return true;
-	else if (!extension.length() || checkSig) {
-		if (!pIOHandler) {
-			return true;
-		}
-		/*
-         * don't use CheckMagicToken because that checks with swapped bytes too, leading to false
-         * positives. This magic is not uint32_t, but char[4], so memcmp is the best way
-
-        const char* tokens[] = {"3DMO", "3dmo"};
-        return CheckMagicToken(pIOHandler,pFile,tokens,2,0,4);
-        */
-		std::unique_ptr<IOStream> pStream(pIOHandler->Open(pFile, "rb"));
-		unsigned char data[4];
-		if (4 != pStream->Read(data, 1, 4)) {
-			return false;
-		}
-		return !memcmp(data, "3DMO", 4) /* bin */
-#ifdef M3D_ASCII
-			|| !memcmp(data, "3dmo", 4) /* ASCII */
-#endif
-		;
-	}
-	return false;
-}
-
-// ------------------------------------------------------------------------------------------------
-const aiImporterDesc *M3DImporter::GetInfo() const {
-	return &desc;
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Model 3D import implementation
-void M3DImporter::InternReadFile(const std::string &file, aiScene *pScene, IOSystem *pIOHandler) {
-	// Read file into memory
-	std::unique_ptr<IOStream> pStream(pIOHandler->Open(file, "rb"));
-	if (!pStream.get()) {
-		throw DeadlyImportError("Failed to open file " + file + ".");
-	}
-
-	// Get the file-size and validate it, throwing an exception when fails
-	size_t fileSize = pStream->FileSize();
-	if (fileSize < 8) {
-		throw DeadlyImportError("M3D-file " + file + " is too small.");
-	}
-	std::vector<unsigned char> buffer(fileSize);
-	if (fileSize != pStream->Read(buffer.data(), 1, fileSize)) {
-		throw DeadlyImportError("Failed to read the file " + file + ".");
-	}
-	// extra check for binary format's first 8 bytes. Not done for the ASCII variant
-	if(!memcmp(buffer.data(), "3DMO", 4) && memcmp(buffer.data() + 4, &fileSize, 4)) {
-		throw DeadlyImportError("Bad binary header in file " + file + ".");
-	}
-#ifdef M3D_ASCII
-	// make sure there's a terminator zero character, as input must be ASCIIZ
-	if(!memcmp(buffer.data(), "3dmo", 4)) {
-		buffer.push_back(0);
-	}
-#endif
-
-	// Get the path for external assets
-	std::string folderName("./");
-	std::string::size_type pos = file.find_last_of("\\/");
-	if (pos != std::string::npos) {
-		folderName = file.substr(0, pos);
-		if (!folderName.empty()) {
-			pIOHandler->PushDirectory(folderName);
-		}
-	}
-
-    //DefaultLogger::create("/dev/stderr", Logger::VERBOSE);
-	ASSIMP_LOG_DEBUG_F("M3D: loading ", file);
-
-	// let the C SDK do the hard work for us
-	M3DWrapper m3d(pIOHandler, buffer);
-
-	if (!m3d) {
-		throw DeadlyImportError("Unable to parse " + file + " as M3D.");
-	}
-
-	// create the root node
-	pScene->mRootNode = new aiNode;
-	pScene->mRootNode->mName = aiString(m3d.Name());
-	pScene->mRootNode->mTransformation = aiMatrix4x4();
-	pScene->mRootNode->mNumChildren = 0;
-	mScene = pScene;
-
-	ASSIMP_LOG_DEBUG("M3D: root node " + m3d.Name());
-
-	// now we just have to fill up the Assimp structures in pScene
-	importMaterials(m3d);
-    importTextures(m3d);
-	importBones(m3d, M3D_NOTDEFINED, pScene->mRootNode);
-	importMeshes(m3d);
-	importAnimations(m3d);
-
-	// Pop directory stack
-	if (pIOHandler->StackSize() > 0) {
-		pIOHandler->PopDirectory();
-	}
-}
-
-// ------------------------------------------------------------------------------------------------
-// convert materials. properties are converted using a static table in M3DMaterials.h
-void M3DImporter::importMaterials(const M3DWrapper &m3d) {
-	unsigned int i, j, k, l, n;
-	m3dm_t *m;
-	aiString name = aiString(AI_DEFAULT_MATERIAL_NAME);
-	aiColor4D c;
-	ai_real f;
-
-	ai_assert(mScene != nullptr);
-	ai_assert(m3d);
-
-	mScene->mNumMaterials = m3d->nummaterial + 1;
-	mScene->mMaterials = new aiMaterial *[mScene->mNumMaterials];
-
-	ASSIMP_LOG_DEBUG_F("M3D: importMaterials ", mScene->mNumMaterials);
-
-	// add a default material as first
-	aiMaterial *mat = new aiMaterial;
-	mat->AddProperty(&name, AI_MATKEY_NAME);
-	c.a = 1.0f;
-	c.b = c.g = c.r = 0.6f;
-	mat->AddProperty(&c, 1, AI_MATKEY_COLOR_DIFFUSE);
-	mScene->mMaterials[0] = mat;
-
-	if (!m3d->nummaterial || !m3d->material) {
-		return;
-	}
-
-	for (i = 0; i < m3d->nummaterial; i++) {
-		m = &m3d->material[i];
-		aiMaterial *mat = new aiMaterial;
-		name.Set(std::string(m->name));
-		mat->AddProperty(&name, AI_MATKEY_NAME);
-		for (j = 0; j < m->numprop; j++) {
-			// look up property type
-			// 0 - 127 scalar values,
-			// 128 - 255 the same properties but for texture maps
-			k = 256;
-			for (l = 0; l < sizeof(m3d_propertytypes) / sizeof(m3d_propertytypes[0]); l++)
-				if (m->prop[j].type == m3d_propertytypes[l].id ||
-						m->prop[j].type == m3d_propertytypes[l].id + 128) {
-					k = l;
-					break;
-				}
-			// should never happen, but be safe than sorry
-			if (k == 256) continue;
-
-			// scalar properties
-			if (m->prop[j].type < 128 && aiProps[k].pKey) {
-				switch (m3d_propertytypes[k].format) {
-					case m3dpf_color:
-						c = mkColor(m->prop[j].value.color);
-						mat->AddProperty(&c, 1, aiProps[k].pKey, aiProps[k].type, aiProps[k].index);
-						break;
-					case m3dpf_float:
-						f = m->prop[j].value.fnum;
-						mat->AddProperty(&f, 1, aiProps[k].pKey, aiProps[k].type, aiProps[k].index);
-						break;
-					default:
-						n = m->prop[j].value.num;
-						if (m->prop[j].type == m3dp_il) {
-							switch (n) {
-								case 0: n = aiShadingMode_NoShading; break;
-								case 2: n = aiShadingMode_Phong; break;
-								default: n = aiShadingMode_Gouraud; break;
-							}
-						}
-						mat->AddProperty(&n, 1, aiProps[k].pKey, aiProps[k].type, aiProps[k].index);
-						break;
-				}
-			}
-			// texture map properties
-			if (m->prop[j].type >= 128 && aiTxProps[k].pKey &&
-					// extra check, should never happen, do we have the refered texture?
-					m->prop[j].value.textureid < m3d->numtexture &&
-					m3d->texture[m->prop[j].value.textureid].name) {
-				name.Set(std::string(std::string(m3d->texture[m->prop[j].value.textureid].name) + ".png"));
-				mat->AddProperty(&name, aiTxProps[k].pKey, aiTxProps[k].type, aiTxProps[k].index);
-				n = 0;
-				mat->AddProperty(&n, 1, _AI_MATKEY_UVWSRC_BASE, aiProps[k].type, aiProps[k].index);
-			}
-		}
-		mScene->mMaterials[i + 1] = mat;
-	}
-}
-
-// ------------------------------------------------------------------------------------------------
-// import textures, this is the simplest of all
-void M3DImporter::importTextures(const M3DWrapper &m3d) {
-	unsigned int i;
-	const char *formatHint[] = {
-		"rgba0800",
-		"rgba0808",
-		"rgba8880",
-		"rgba8888"
-	};
-	m3dtx_t *t;
-
-	ai_assert(mScene != nullptr);
-	ai_assert(m3d);
-
-	mScene->mNumTextures = m3d->numtexture;
-	ASSIMP_LOG_DEBUG_F("M3D: importTextures ", mScene->mNumTextures);
-
-	if (!m3d->numtexture || !m3d->texture) {
-		return;
-	}
-
-	mScene->mTextures = new aiTexture *[m3d->numtexture];
-	for (i = 0; i < m3d->numtexture; i++) {
-		unsigned int j, k;
-		t = &m3d->texture[i];
-		aiTexture *tx = new aiTexture;
-		tx->mFilename = aiString(std::string(t->name) + ".png");
-		if (!t->w || !t->h || !t->f || !t->d) {
-			/* without ASSIMP_USE_M3D_READFILECB, we only have the filename, but no texture data ever */
-			tx->mWidth = 0;
-			tx->mHeight = 0;
-			memcpy(tx->achFormatHint, "png\000", 4);
-			tx->pcData = nullptr;
-		} else {
-			/* if we have the texture loaded, set format hint and pcData too */
-			tx->mWidth = t->w;
-			tx->mHeight = t->h;
-			strcpy(tx->achFormatHint, formatHint[t->f - 1]);
-			tx->pcData = new aiTexel[tx->mWidth * tx->mHeight];
-			for (j = k = 0; j < tx->mWidth * tx->mHeight; j++) {
-				switch (t->f) {
-					case 1: tx->pcData[j].g = t->d[k++]; break;
-					case 2:
-						tx->pcData[j].g = t->d[k++];
-						tx->pcData[j].a = t->d[k++];
-						break;
-					case 3:
-						tx->pcData[j].r = t->d[k++];
-						tx->pcData[j].g = t->d[k++];
-						tx->pcData[j].b = t->d[k++];
-						tx->pcData[j].a = 255;
-						break;
-					case 4:
-						tx->pcData[j].r = t->d[k++];
-						tx->pcData[j].g = t->d[k++];
-						tx->pcData[j].b = t->d[k++];
-						tx->pcData[j].a = t->d[k++];
-						break;
-				}
-			}
-		}
-		mScene->mTextures[i] = tx;
-	}
-}
-
-// ------------------------------------------------------------------------------------------------
-// this is tricky. M3D has a global vertex and UV list, and faces are indexing them
-// individually. In assimp there're per mesh vertex and UV lists, and they must be
-// indexed simultaneously.
-void M3DImporter::importMeshes(const M3DWrapper &m3d) {
-	ASSIMP_LOG_DEBUG_F("M3D: importMeshes ", m3d->numface);
-
-	if (!m3d->numface || !m3d->face || !m3d->numvertex || !m3d->vertex) {
-		return;
-	}
-
-    unsigned int i, j, k, l, numpoly = 3, lastMat = M3D_INDEXMAX;
-	std::vector<aiMesh *> *meshes = new std::vector<aiMesh *>();
-	std::vector<aiFace> *faces = nullptr;
-	std::vector<aiVector3D> *vertices = nullptr;
-	std::vector<aiVector3D> *normals = nullptr;
-	std::vector<aiVector3D> *texcoords = nullptr;
-	std::vector<aiColor4D> *colors = nullptr;
-	std::vector<unsigned int> *vertexids = nullptr;
-	aiMesh *pMesh = nullptr;
-
-	ai_assert(mScene != nullptr);
-	ai_assert(m3d);
-	ai_assert(mScene->mRootNode != nullptr);
-
-
-	for (i = 0; i < m3d->numface; i++) {
-		// we must switch mesh if material changes
-		if (lastMat != m3d->face[i].materialid) {
-			lastMat = m3d->face[i].materialid;
-			if (pMesh && vertices && vertices->size() && faces && faces->size()) {
-				populateMesh(m3d, pMesh, faces, vertices, normals, texcoords, colors, vertexids);
-				meshes->push_back(pMesh);
-				delete faces;
-				delete vertices;
-				delete normals;
-				delete texcoords;
-				delete colors;
-				delete vertexids; // this is not stored in pMesh, just to collect bone vertices
-			}
-			pMesh = new aiMesh;
-			pMesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
-			pMesh->mMaterialIndex = lastMat + 1;
-			faces = new std::vector<aiFace>();
-			vertices = new std::vector<aiVector3D>();
-			normals = new std::vector<aiVector3D>();
-			texcoords = new std::vector<aiVector3D>();
-			colors = new std::vector<aiColor4D>();
-			vertexids = new std::vector<unsigned int>();
-		}
-		// add a face to temporary vector
-		aiFace *pFace = new aiFace;
-		pFace->mNumIndices = numpoly;
-		pFace->mIndices = new unsigned int[numpoly];
-		for (j = 0; j < numpoly; j++) {
-			aiVector3D pos, uv, norm;
-			k = static_cast<unsigned int>(vertices->size());
-			pFace->mIndices[j] = k;
-			l = m3d->face[i].vertex[j];
-			if(l >= m3d->numvertex) continue;
-			pos.x = m3d->vertex[l].x;
-			pos.y = m3d->vertex[l].y;
-			pos.z = m3d->vertex[l].z;
-			vertices->push_back(pos);
-			colors->push_back(mkColor(m3d->vertex[l].color));
-			// add a bone to temporary vector
-			if (m3d->vertex[l].skinid != M3D_UNDEF && m3d->vertex[l].skinid != M3D_INDEXMAX && m3d->skin && m3d->bone) {
-				// this is complicated, because M3D stores a list of bone id / weight pairs per
-				// vertex but assimp uses lists of local vertex id/weight pairs per local bone list
-				vertexids->push_back(l);
-			}
-			l = m3d->face[i].texcoord[j];
-			if (l != M3D_UNDEF && l < m3d->numtmap) {
-				uv.x = m3d->tmap[l].u;
-				uv.y = m3d->tmap[l].v;
-				uv.z = 0.0;
-				texcoords->push_back(uv);
-			}
-			l = m3d->face[i].normal[j];
-			if (l != M3D_UNDEF && l < m3d->numvertex) {
-				norm.x = m3d->vertex[l].x;
-				norm.y = m3d->vertex[l].y;
-				norm.z = m3d->vertex[l].z;
-				normals->push_back(norm);
-			}
-		}
-		faces->push_back(*pFace);
-		delete pFace;
-	}
-	// if there's data left in the temporary vectors, flush them
-	if (pMesh && vertices->size() && faces->size()) {
-		populateMesh(m3d, pMesh, faces, vertices, normals, texcoords, colors, vertexids);
-		meshes->push_back(pMesh);
-	}
-
-	// create global mesh list in scene
-	mScene->mNumMeshes = static_cast<unsigned int>(meshes->size());
-	mScene->mMeshes = new aiMesh *[mScene->mNumMeshes];
-	std::copy(meshes->begin(), meshes->end(), mScene->mMeshes);
-
-	// create mesh indeces in root node
-	mScene->mRootNode->mNumMeshes = static_cast<unsigned int>(meshes->size());
-	mScene->mRootNode->mMeshes = new unsigned int[meshes->size()];
-	for (i = 0; i < meshes->size(); i++) {
-		mScene->mRootNode->mMeshes[i] = i;
-	}
-
-	delete meshes;
-	if (faces) delete faces;
-	if (vertices) delete vertices;
-	if (normals) delete normals;
-	if (texcoords) delete texcoords;
-	if (colors) delete colors;
-	if (vertexids) delete vertexids;
-}
-
-// ------------------------------------------------------------------------------------------------
-// a reentrant node parser. Otherwise this is simple
-void M3DImporter::importBones(const M3DWrapper &m3d, unsigned int parentid, aiNode *pParent) {
-	unsigned int i, n;
-
-	ai_assert(pParent != nullptr);
-	ai_assert(mScene != nullptr);
-	ai_assert(m3d);
-
-	ASSIMP_LOG_DEBUG_F("M3D: importBones ", m3d->numbone, " parentid ", (int)parentid);
-
-	if (!m3d->numbone || !m3d->bone) {
-		return;
-	}
-
-	for (n = 0, i = parentid + 1; i < m3d->numbone; i++) {
-		if (m3d->bone[i].parent == parentid) {
-			n++;
-		}
-	}
-	pParent->mChildren = new aiNode *[n];
-
-	for (i = parentid + 1; i < m3d->numbone; i++) {
-		if (m3d->bone[i].parent == parentid) {
-			aiNode *pChild = new aiNode;
-			pChild->mParent = pParent;
-			pChild->mName = aiString(std::string(m3d->bone[i].name));
-			convertPose(m3d, &pChild->mTransformation, m3d->bone[i].pos, m3d->bone[i].ori);
-			pChild->mNumChildren = 0;
-			pParent->mChildren[pParent->mNumChildren] = pChild;
-			pParent->mNumChildren++;
-			importBones(m3d, i, pChild);
-		}
-	}
-}
-
-// ------------------------------------------------------------------------------------------------
-// this is another headache. M3D stores list of changed bone id/position/orientation triplets and
-// a timestamp per frame, but assimp needs timestamp and lists of position, orientation lists per
-// bone, so we have to convert between the two conceptually different representation forms
-void M3DImporter::importAnimations(const M3DWrapper &m3d) {
-	unsigned int i, j, k, l, pos, ori;
-	double t;
-	m3da_t *a;
-
-	ai_assert(mScene != nullptr);
-	ai_assert(m3d);
-
-	mScene->mNumAnimations = m3d->numaction;
-
-	ASSIMP_LOG_DEBUG_F("M3D: importAnimations ", mScene->mNumAnimations);
-
-	if (!m3d->numaction || !m3d->action || !m3d->numbone || !m3d->bone || !m3d->vertex) {
-		return;
-	}
-
-	mScene->mAnimations = new aiAnimation *[m3d->numaction];
-	for (i = 0; i < m3d->numaction; i++) {
-		a = &m3d->action[i];
-		aiAnimation *pAnim = new aiAnimation;
-		pAnim->mName = aiString(std::string(a->name));
-		pAnim->mDuration = ((double)a->durationmsec) / 10;
-		pAnim->mTicksPerSecond = 100;
-		// now we know how many bones are referenced in this animation
-		pAnim->mNumChannels = m3d->numbone;
-		pAnim->mChannels = new aiNodeAnim *[pAnim->mNumChannels];
-		for (l = 0; l < m3d->numbone; l++) {
-			unsigned int n;
-			pAnim->mChannels[l] = new aiNodeAnim;
-			pAnim->mChannels[l]->mNodeName = aiString(std::string(m3d->bone[l].name));
-			// now n is the size of positions / orientations arrays
-			pAnim->mChannels[l]->mNumPositionKeys = pAnim->mChannels[l]->mNumRotationKeys = a->numframe;
-			pAnim->mChannels[l]->mPositionKeys = new aiVectorKey[a->numframe];
-			pAnim->mChannels[l]->mRotationKeys = new aiQuatKey[a->numframe];
-			pos = m3d->bone[l].pos;
-			ori = m3d->bone[l].ori;
-			for (j = n = 0; j < a->numframe; j++) {
-				t = ((double)a->frame[j].msec) / 10;
-				for (k = 0; k < a->frame[j].numtransform; k++) {
-					if (a->frame[j].transform[k].boneid == l) {
-						pos = a->frame[j].transform[k].pos;
-						ori = a->frame[j].transform[k].ori;
-					}
-				}
-				if(pos >= m3d->numvertex || ori >= m3d->numvertex) continue;
-				m3dv_t *v = &m3d->vertex[pos];
-				m3dv_t *q = &m3d->vertex[ori];
-				pAnim->mChannels[l]->mPositionKeys[j].mTime = t;
-				pAnim->mChannels[l]->mPositionKeys[j].mValue.x = v->x;
-				pAnim->mChannels[l]->mPositionKeys[j].mValue.y = v->y;
-				pAnim->mChannels[l]->mPositionKeys[j].mValue.z = v->z;
-				pAnim->mChannels[l]->mRotationKeys[j].mTime = t;
-				pAnim->mChannels[l]->mRotationKeys[j].mValue.w = q->w;
-				pAnim->mChannels[l]->mRotationKeys[j].mValue.x = q->x;
-				pAnim->mChannels[l]->mRotationKeys[j].mValue.y = q->y;
-				pAnim->mChannels[l]->mRotationKeys[j].mValue.z = q->z;
-			} // foreach frame
-		} // foreach bones
-		mScene->mAnimations[i] = pAnim;
-	}
-}
-
-// ------------------------------------------------------------------------------------------------
-// convert uint32_t into aiColor4D
-aiColor4D M3DImporter::mkColor(uint32_t c) {
-	aiColor4D color;
-	color.a = ((float)((c >> 24) & 0xff)) / 255;
-	color.b = ((float)((c >> 16) & 0xff)) / 255;
-	color.g = ((float)((c >> 8) & 0xff)) / 255;
-	color.r = ((float)((c >> 0) & 0xff)) / 255;
-	return color;
-}
-
-// ------------------------------------------------------------------------------------------------
-// convert a position id and orientation id into a 4 x 4 transformation matrix
-void M3DImporter::convertPose(const M3DWrapper &m3d, aiMatrix4x4 *m, unsigned int posid, unsigned int orientid) {
-	ai_assert(m != nullptr);
-	ai_assert(m3d);
-	ai_assert(posid != M3D_UNDEF && posid < m3d->numvertex);
-	ai_assert(orientid != M3D_UNDEF && orientid < m3d->numvertex);
-	if (!m3d->numvertex || !m3d->vertex)
-		return;
-	m3dv_t *p = &m3d->vertex[posid];
-	m3dv_t *q = &m3d->vertex[orientid];
-
-	/* quaternion to matrix. Do NOT use aiQuaternion to aiMatrix3x3, gives bad results */
-	if (q->x == 0.0 && q->y == 0.0 && q->z >= 0.7071065 && q->z <= 0.7071075 && q->w == 0.0) {
-		m->a2 = m->a3 = m->b1 = m->b3 = m->c1 = m->c2 = 0.0;
-		m->a1 = m->b2 = m->c3 = -1.0;
-	} else {
-		m->a1 = 1 - 2 * (q->y * q->y + q->z * q->z);
-		if (m->a1 > -M3D_EPSILON && m->a1 < M3D_EPSILON) m->a1 = 0.0;
-		m->a2 = 2 * (q->x * q->y - q->z * q->w);
-		if (m->a2 > -M3D_EPSILON && m->a2 < M3D_EPSILON) m->a2 = 0.0;
-		m->a3 = 2 * (q->x * q->z + q->y * q->w);
-		if (m->a3 > -M3D_EPSILON && m->a3 < M3D_EPSILON) m->a3 = 0.0;
-		m->b1 = 2 * (q->x * q->y + q->z * q->w);
-		if (m->b1 > -M3D_EPSILON && m->b1 < M3D_EPSILON) m->b1 = 0.0;
-		m->b2 = 1 - 2 * (q->x * q->x + q->z * q->z);
-		if (m->b2 > -M3D_EPSILON && m->b2 < M3D_EPSILON) m->b2 = 0.0;
-		m->b3 = 2 * (q->y * q->z - q->x * q->w);
-		if (m->b3 > -M3D_EPSILON && m->b3 < M3D_EPSILON) m->b3 = 0.0;
-		m->c1 = 2 * (q->x * q->z - q->y * q->w);
-		if (m->c1 > -M3D_EPSILON && m->c1 < M3D_EPSILON) m->c1 = 0.0;
-		m->c2 = 2 * (q->y * q->z + q->x * q->w);
-		if (m->c2 > -M3D_EPSILON && m->c2 < M3D_EPSILON) m->c2 = 0.0;
-		m->c3 = 1 - 2 * (q->x * q->x + q->y * q->y);
-		if (m->c3 > -M3D_EPSILON && m->c3 < M3D_EPSILON) m->c3 = 0.0;
-	}
-
-	/* set translation */
-	m->a4 = p->x;
-	m->b4 = p->y;
-	m->c4 = p->z;
-
-	m->d1 = 0;
-	m->d2 = 0;
-	m->d3 = 0;
-	m->d4 = 1;
-}
-
-// ------------------------------------------------------------------------------------------------
-// find a node by name
-aiNode *M3DImporter::findNode(aiNode *pNode, aiString name) {
-	ai_assert(pNode != nullptr);
-	ai_assert(mScene != nullptr);
-
-	if (pNode->mName == name) {
-		return pNode;
-	}
-
-	for (unsigned int i = 0; i < pNode->mNumChildren; i++) {
-		aiNode *pChild = findNode(pNode->mChildren[i], name);
-		if (pChild) {
-			return pChild;
-		}
-	}
-	return nullptr;
-}
-
-// ------------------------------------------------------------------------------------------------
-// fills up offsetmatrix in mBones
-void M3DImporter::calculateOffsetMatrix(aiNode *pNode, aiMatrix4x4 *m) {
-	ai_assert(pNode != nullptr);
-	ai_assert(mScene != nullptr);
-
-	if (pNode->mParent) {
-		calculateOffsetMatrix(pNode->mParent, m);
-		*m *= pNode->mTransformation;
-	} else {
-		*m = pNode->mTransformation;
-	}
-}
-
-// ------------------------------------------------------------------------------------------------
-// because M3D has a global mesh, global vertex ids and stores materialid on the face, we need
-// temporary lists to collect data for an aiMesh, which requires local arrays and local indeces
-// this function fills up an aiMesh with those temporary lists
-void M3DImporter::populateMesh(const M3DWrapper &m3d, aiMesh *pMesh, std::vector<aiFace> *faces, std::vector<aiVector3D> *vertices,
-		std::vector<aiVector3D> *normals, std::vector<aiVector3D> *texcoords, std::vector<aiColor4D> *colors,
-		std::vector<unsigned int> *vertexids) {
-
-	ai_assert(pMesh != nullptr);
-	ai_assert(faces != nullptr);
-	ai_assert(vertices != nullptr);
-	ai_assert(normals != nullptr);
-	ai_assert(texcoords != nullptr);
-	ai_assert(colors != nullptr);
-	ai_assert(vertexids != nullptr);
-	ai_assert(m3d);
-
-	ASSIMP_LOG_DEBUG_F("M3D: populateMesh numvertices ", vertices->size(), " numfaces ", faces->size(),
-			" numnormals ", normals->size(), " numtexcoord ", texcoords->size(), " numbones ", m3d->numbone);
-
-	if (vertices->size() && faces->size()) {
-		pMesh->mNumFaces = static_cast<unsigned int>(faces->size());
-		pMesh->mFaces = new aiFace[pMesh->mNumFaces];
-		std::copy(faces->begin(), faces->end(), pMesh->mFaces);
-		pMesh->mNumVertices = static_cast<unsigned int>(vertices->size());
-		pMesh->mVertices = new aiVector3D[pMesh->mNumVertices];
-		std::copy(vertices->begin(), vertices->end(), pMesh->mVertices);
-		if (normals->size() == vertices->size()) {
-			pMesh->mNormals = new aiVector3D[pMesh->mNumVertices];
-			std::copy(normals->begin(), normals->end(), pMesh->mNormals);
-		}
-		if (texcoords->size() == vertices->size()) {
-			pMesh->mTextureCoords[0] = new aiVector3D[pMesh->mNumVertices];
-			std::copy(texcoords->begin(), texcoords->end(), pMesh->mTextureCoords[0]);
-			pMesh->mNumUVComponents[0] = 2;
-		}
-		if (colors->size() == vertices->size()) {
-			pMesh->mColors[0] = new aiColor4D[pMesh->mNumVertices];
-			std::copy(colors->begin(), colors->end(), pMesh->mColors[0]);
-		}
-		// this is complicated, because M3D stores a list of bone id / weight pairs per
-		// vertex but assimp uses lists of local vertex id/weight pairs per local bone list
-		pMesh->mNumBones = m3d->numbone;
-		// we need aiBone with mOffsetMatrix for bones without weights as well
-		if (pMesh->mNumBones && m3d->numbone && m3d->bone) {
-			pMesh->mBones = new aiBone *[pMesh->mNumBones];
-			for (unsigned int i = 0; i < m3d->numbone; i++) {
-				aiNode *pNode;
-				pMesh->mBones[i] = new aiBone;
-				pMesh->mBones[i]->mName = aiString(std::string(m3d->bone[i].name));
-				pMesh->mBones[i]->mNumWeights = 0;
-				pNode = findNode(mScene->mRootNode, pMesh->mBones[i]->mName);
-				if (pNode) {
-					calculateOffsetMatrix(pNode, &pMesh->mBones[i]->mOffsetMatrix);
-					pMesh->mBones[i]->mOffsetMatrix.Inverse();
-				} else
-					pMesh->mBones[i]->mOffsetMatrix = aiMatrix4x4();
-			}
-			if (vertexids->size() && m3d->numvertex && m3d->vertex && m3d->numskin && m3d->skin) {
-				unsigned int i, j;
-				// first count how many vertices we have per bone
-				for (i = 0; i < vertexids->size(); i++) {
-					if(vertexids->at(i) >= m3d->numvertex) {
-						continue;
-					}
-					unsigned int s = m3d->vertex[vertexids->at(i)].skinid;
-					if (s != M3D_UNDEF && s != M3D_INDEXMAX) {
-						for (unsigned int k = 0; k < M3D_NUMBONE && m3d->skin[s].weight[k] > 0.0; k++) {
-							aiString name = aiString(std::string(m3d->bone[m3d->skin[s].boneid[k]].name));
-							for (j = 0; j < pMesh->mNumBones; j++) {
-								if (pMesh->mBones[j]->mName == name) {
-									pMesh->mBones[j]->mNumWeights++;
-									break;
-								}
-							}
-						}
-					}
-				}
-				// allocate mWeights
-				for (j = 0; j < pMesh->mNumBones; j++) {
-					aiBone *pBone = pMesh->mBones[j];
-					if (pBone->mNumWeights) {
-						pBone->mWeights = new aiVertexWeight[pBone->mNumWeights];
-						pBone->mNumWeights = 0;
-					}
-				}
-				// fill up with data
-				for (i = 0; i < vertexids->size(); i++) {
-					if(vertexids->at(i) >= m3d->numvertex) continue;
-					unsigned int s = m3d->vertex[vertexids->at(i)].skinid;
-					if (s != M3D_UNDEF && s != M3D_INDEXMAX && s < m3d->numskin) {
-						for (unsigned int k = 0; k < M3D_NUMBONE && m3d->skin[s].weight[k] > 0.0; k++) {
-							if(m3d->skin[s].boneid[k] >= m3d->numbone) continue;
-							aiString name = aiString(std::string(m3d->bone[m3d->skin[s].boneid[k]].name));
-							for (j = 0; j < pMesh->mNumBones; j++) {
-								if (pMesh->mBones[j]->mName == name) {
-									aiBone *pBone = pMesh->mBones[j];
-									pBone->mWeights[pBone->mNumWeights].mVertexId = i;
-									pBone->mWeights[pBone->mNumWeights].mWeight = m3d->skin[s].weight[k];
-									pBone->mNumWeights++;
-									break;
-								}
-							}
-						} // foreach skin
-					}
-				} // foreach vertexids
-			}
-		}
-	}
-}
-
-// ------------------------------------------------------------------------------------------------
-
-} // Namespace Assimp
-
-#endif // !! ASSIMP_BUILD_NO_M3D_IMPORTER
diff --git a/Engine/lib/assimp/code/M3D/M3DImporter.h b/Engine/lib/assimp/code/M3D/M3DImporter.h
deleted file mode 100644
index 5c9d4fad8..000000000
--- a/Engine/lib/assimp/code/M3D/M3DImporter.h
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-Copyright (c) 2019 bzt
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file M3DImporter.h
-*   @brief Declares the importer class to read a scene from a Model 3D file
-*/
-#ifndef AI_M3DIMPORTER_H_INC
-#define AI_M3DIMPORTER_H_INC
-
-#ifndef ASSIMP_BUILD_NO_M3D_IMPORTER
-
-#include <assimp/BaseImporter.h>
-#include <assimp/material.h>
-#include <vector>
-
-struct aiMesh;
-struct aiNode;
-struct aiMaterial;
-struct aiFace;
-
-namespace Assimp {
-
-class M3DWrapper;
-
-class M3DImporter : public BaseImporter {
-public:
-	/// \brief  Default constructor
-	M3DImporter();
-
-public:
-	/// \brief  Returns whether the class can handle the format of the given file.
-	/// \remark See BaseImporter::CanRead() for details.
-	bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const;
-
-private:
-	aiScene *mScene = nullptr; // the scene to import to
-
-	//! \brief  Appends the supported extension.
-	const aiImporterDesc *GetInfo() const;
-
-	//! \brief  File import implementation.
-	void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler);
-
-	void importMaterials(const M3DWrapper &m3d);
-	void importTextures(const M3DWrapper &m3d);
-	void importMeshes(const M3DWrapper &m3d);
-	void importBones(const M3DWrapper &m3d, unsigned int parentid, aiNode *pParent);
-	void importAnimations(const M3DWrapper &m3d);
-
-	// helper functions
-	aiColor4D mkColor(uint32_t c);
-	void convertPose(const M3DWrapper &m3d, aiMatrix4x4 *m, unsigned int posid, unsigned int orientid);
-	aiNode *findNode(aiNode *pNode, aiString name);
-	void calculateOffsetMatrix(aiNode *pNode, aiMatrix4x4 *m);
-	void populateMesh(const M3DWrapper &m3d, aiMesh *pMesh, std::vector<aiFace> *faces, std::vector<aiVector3D> *verteces,
-			std::vector<aiVector3D> *normals, std::vector<aiVector3D> *texcoords, std::vector<aiColor4D> *colors,
-			std::vector<unsigned int> *vertexids);
-};
-
-} // Namespace Assimp
-
-#endif // ASSIMP_BUILD_NO_M3D_IMPORTER
-
-#endif // AI_M3DIMPORTER_H_INC
diff --git a/Engine/lib/assimp/code/M3D/M3DMaterials.h b/Engine/lib/assimp/code/M3D/M3DMaterials.h
deleted file mode 100644
index 469ddf52b..000000000
--- a/Engine/lib/assimp/code/M3D/M3DMaterials.h
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-Copyright (c) 2019 bzt
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file M3DMaterials.h
-*   @brief Declares the Assimp and Model 3D file material type relations
-*/
-#ifndef AI_M3DMATERIALS_H_INC
-#define AI_M3DMATERIALS_H_INC
-
-/*
- * In the m3d.h header, there's a static array which defines the material
- * properties, called m3d_propertytypes. These must have the same size, and
- * list the matching Assimp materials for those properties. Used by both the
- * M3DImporter and the M3DExporter, so you have to define these relations
- * only once. D.R.Y. and K.I.S.S.
- */
-typedef struct {
-    const char *pKey;
-    unsigned int type;
-    unsigned int index;
-} aiMatProp;
-
-/* --- Scalar Properties ---        !!!!! must match m3d_propertytypes !!!!! */
-static const aiMatProp aiProps[] = {
-    { AI_MATKEY_COLOR_DIFFUSE },                                /* m3dp_Kd */
-    { AI_MATKEY_COLOR_AMBIENT },                                /* m3dp_Ka */
-    { AI_MATKEY_COLOR_SPECULAR },                               /* m3dp_Ks */
-    { AI_MATKEY_SHININESS },                                    /* m3dp_Ns */
-    { AI_MATKEY_COLOR_EMISSIVE },                               /* m3dp_Ke */
-    { AI_MATKEY_COLOR_REFLECTIVE },                             /* m3dp_Tf */
-    { AI_MATKEY_BUMPSCALING },                                  /* m3dp_Km */
-    { AI_MATKEY_OPACITY },                                      /* m3dp_d */
-    { AI_MATKEY_SHADING_MODEL },                                /* m3dp_il */
-
-    { NULL, 0, 0 },                                             /* m3dp_Pr */
-    { AI_MATKEY_REFLECTIVITY },                                 /* m3dp_Pm */
-    { NULL, 0, 0 },                                             /* m3dp_Ps */
-    { AI_MATKEY_REFRACTI },                                     /* m3dp_Ni */
-    { NULL, 0, 0 },                                             /* m3dp_Nt */
-    { NULL, 0, 0 },
-    { NULL, 0, 0 },
-    { NULL, 0, 0 }
-};
-
-/* --- Texture Map Properties ---   !!!!! must match m3d_propertytypes !!!!! */
-static const aiMatProp aiTxProps[] = {
-    { AI_MATKEY_TEXTURE_DIFFUSE(0) },                        /* m3dp_map_Kd */
-    { AI_MATKEY_TEXTURE(aiTextureType_AMBIENT_OCCLUSION,0) },/* m3dp_map_Ka */
-    { AI_MATKEY_TEXTURE_SPECULAR(0) },                       /* m3dp_map_Ks */
-    { AI_MATKEY_TEXTURE_SHININESS(0) },                      /* m3dp_map_Ns */
-    { AI_MATKEY_TEXTURE_EMISSIVE(0) },                       /* m3dp_map_Ke */
-    { NULL, 0, 0 },                                          /* m3dp_map_Tf */
-    { AI_MATKEY_TEXTURE_HEIGHT(0) },                         /* m3dp_bump */
-    { AI_MATKEY_TEXTURE_OPACITY(0) },                        /* m3dp_map_d */
-    { AI_MATKEY_TEXTURE_NORMALS(0) },                        /* m3dp_map_N */
-
-    { AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE_ROUGHNESS,0) },/* m3dp_map_Pr */
-    { AI_MATKEY_TEXTURE(aiTextureType_METALNESS,0) },        /* m3dp_map_Pm */
-    { NULL, 0, 0 },                                          /* m3dp_map_Ps */
-    { AI_MATKEY_TEXTURE(aiTextureType_REFLECTION,0) },       /* m3dp_map_Ni */
-    { NULL, 0, 0 },                                          /* m3dp_map_Nt */
-    { NULL, 0, 0 },
-    { NULL, 0, 0 },
-    { NULL, 0, 0 }
-};
-
-#endif // AI_M3DMATERIALS_H_INC
diff --git a/Engine/lib/assimp/code/M3D/M3DWrapper.cpp b/Engine/lib/assimp/code/M3D/M3DWrapper.cpp
deleted file mode 100644
index 6ab59b2f0..000000000
--- a/Engine/lib/assimp/code/M3D/M3DWrapper.cpp
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-Copyright (c) 2019 bzt
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-#if !(ASSIMP_BUILD_NO_EXPORT || ASSIMP_BUILD_NO_M3D_EXPORTER) || !ASSIMP_BUILD_NO_M3D_IMPORTER
-
-#include "M3DWrapper.h"
-
-#include <assimp/DefaultIOSystem.h>
-#include <assimp/IOStreamBuffer.h>
-#include <assimp/ai_assert.h>
-
-#ifdef ASSIMP_USE_M3D_READFILECB
-
-# if (__cplusplus >= 201103L) || !defined(_MSC_VER) || (_MSC_VER >= 1900) // C++11 and MSVC 2015 onwards
-#  define threadlocal thread_local
-# else
-#  if defined(_MSC_VER) && (_MSC_VER >= 1800) // there's an alternative for MSVC 2013
-#   define threadlocal __declspec(thread)
-#  else
-#   define threadlocal
-#  endif
-# endif
-
-extern "C" {
-
-// workaround: the M3D SDK expects a C callback, but we want to use Assimp::IOSystem to implement that
-threadlocal void *m3dimporter_pIOHandler;
-
-unsigned char *m3dimporter_readfile(char *fn, unsigned int *size) {
-	ai_assert(nullptr != fn);
-	ai_assert(nullptr != size);
-	std::string file(fn);
-	std::unique_ptr<Assimp::IOStream> pStream(
-			(reinterpret_cast<Assimp::IOSystem *>(m3dimporter_pIOHandler))->Open(file, "rb"));
-	size_t fileSize = 0;
-	unsigned char *data = NULL;
-	// sometimes pStream is nullptr in a single-threaded scenario too for some reason
-	// (should be an empty object returning nothing I guess)
-	if (pStream) {
-		fileSize = pStream->FileSize();
-		// should be allocated with malloc(), because the library will call free() to deallocate
-		data = (unsigned char *)malloc(fileSize);
-		if (!data || !pStream.get() || !fileSize || fileSize != pStream->Read(data, 1, fileSize)) {
-			pStream.reset();
-			*size = 0;
-			// don't throw a deadly exception, it's not fatal if we can't read an external asset
-			return nullptr;
-		}
-		pStream.reset();
-	}
-	*size = (int)fileSize;
-	return data;
-}
-}
-#endif
-
-namespace Assimp {
-M3DWrapper::M3DWrapper() {
-	// use malloc() here because m3d_free() will call free()
-	m3d_ = (m3d_t *)calloc(1, sizeof(m3d_t));
-}
-
-M3DWrapper::M3DWrapper(IOSystem *pIOHandler, const std::vector<unsigned char> &buffer) {
-#ifdef ASSIMP_USE_M3D_READFILECB
-	// pass this IOHandler to the C callback in a thread-local pointer
-	m3dimporter_pIOHandler = pIOHandler;
-	m3d_ = m3d_load(const_cast<unsigned char *>(buffer.data()), m3dimporter_readfile, free, nullptr);
-	// Clear the C callback
-	m3dimporter_pIOHandler = nullptr;
-#else
-	m3d_ = m3d_load(const_cast<unsigned char *>(buffer.data()), nullptr, nullptr, nullptr);
-#endif
-}
-
-M3DWrapper::~M3DWrapper() {
-	reset();
-}
-
-void M3DWrapper::reset() {
-	ClearSave();
-	if (m3d_)
-		m3d_free(m3d_);
-	m3d_ = nullptr;
-}
-
-unsigned char *M3DWrapper::Save(int quality, int flags, unsigned int &size) {
-#if (!(ASSIMP_BUILD_NO_EXPORT || ASSIMP_BUILD_NO_M3D_EXPORTER))
-	ClearSave();
-	saved_output_ = m3d_save(m3d_, quality, flags, &size);
-	return saved_output_;
-#else
-	return nullptr;
-#endif
-}
-
-void M3DWrapper::ClearSave() {
-	if (saved_output_)
-		M3D_FREE(saved_output_);
-	saved_output_ = nullptr;
-}
-} // namespace Assimp
-
-#endif
diff --git a/Engine/lib/assimp/code/M3D/M3DWrapper.h b/Engine/lib/assimp/code/M3D/M3DWrapper.h
deleted file mode 100644
index bf3ab7bc9..000000000
--- a/Engine/lib/assimp/code/M3D/M3DWrapper.h
+++ /dev/null
@@ -1,101 +0,0 @@
-#pragma once
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-Copyright (c) 2019 bzt
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file M3DWrapper.h
-*   @brief Declares a class to wrap the C m3d SDK
-*/
-#ifndef AI_M3DWRAPPER_H_INC
-#define AI_M3DWRAPPER_H_INC
-#if !(ASSIMP_BUILD_NO_EXPORT || ASSIMP_BUILD_NO_M3D_EXPORTER) || !ASSIMP_BUILD_NO_M3D_IMPORTER
-
-#include <memory>
-#include <vector>
-#include <string>
-
-// Assimp specific M3D configuration. Comment out these defines to remove functionality
-//#define ASSIMP_USE_M3D_READFILECB
-//#define M3D_ASCII
-
-#include "m3d.h"
-
-namespace Assimp {
-class IOSystem;
-
-class M3DWrapper {
-	m3d_t *m3d_ = nullptr;
-	unsigned char *saved_output_ = nullptr;
-
-public:
-	// Construct an empty M3D model
-	explicit M3DWrapper();
-
-	// Construct an M3D model from provided buffer
-	// NOTE: The m3d.h SDK function does not mark the data as const. Have assumed it does not write.
-	// BUG: SECURITY: The m3d.h SDK cannot be informed of the buffer size. BUFFER OVERFLOW IS CERTAIN
-	explicit M3DWrapper(IOSystem *pIOHandler, const std::vector<unsigned char> &buffer);
-
-	~M3DWrapper();
-
-	void reset();
-
-	// Name
-	inline std::string Name() const {
-		if (m3d_) return std::string(m3d_->name);
-		return std::string();
-	}
-
-	// Execute a save
-	unsigned char *Save(int quality, int flags, unsigned int &size);
-	void ClearSave();
-
-	inline explicit operator bool() const { return m3d_ != nullptr; }
-
-	// Allow direct access to M3D API
-	inline m3d_t *operator->() const { return m3d_; }
-	inline m3d_t *M3D() const { return m3d_; }
-};
-} // namespace Assimp
-
-#endif
-
-#endif // AI_M3DWRAPPER_H_INC
diff --git a/Engine/lib/assimp/code/M3D/m3d.h b/Engine/lib/assimp/code/M3D/m3d.h
deleted file mode 100644
index d09348497..000000000
--- a/Engine/lib/assimp/code/M3D/m3d.h
+++ /dev/null
@@ -1,5612 +0,0 @@
-/*
- * m3d.h
- *
- * Copyright (C) 2019 bzt (bztsrc@gitlab)
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
- * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- *
- * @brief ANSI C89 / C++11 single header importer / exporter SDK for the Model 3D (.M3D) format
- * https://gitlab.com/bztsrc/model3d
- *
- * PNG decompressor included from (with minor modifications to make it C89 valid):
- *  stb_image - v2.13 - public domain image loader - http://nothings.org/stb_image.h
- *
- * @version: 1.0.0
- */
-
-#ifndef _M3D_H_
-#define _M3D_H_
-
-#ifdef  __cplusplus
-extern "C" {
-#endif
-
-#include <stdint.h>
-
-/*** configuration ***/
-#ifndef M3D_MALLOC
-# define M3D_MALLOC(sz)     malloc(sz)
-#endif
-#ifndef M3D_REALLOC
-# define M3D_REALLOC(p,nsz) realloc(p,nsz)
-#endif
-#ifndef M3D_FREE
-# define M3D_FREE(p)        free(p)
-#endif
-#ifndef M3D_LOG
-# define M3D_LOG(x)
-#endif
-#ifndef M3D_APIVERSION
-#define M3D_APIVERSION      0x0100
-#ifndef M3D_DOUBLE
-typedef float M3D_FLOAT;
-#ifndef M3D_EPSILON
-/* carefully choosen for IEEE 754 don't change */
-#define M3D_EPSILON ((M3D_FLOAT)1e-7)
-#endif
-#else
-typedef double M3D_FLOAT;
-#ifndef M3D_EPSILON
-#define M3D_EPSILON ((M3D_FLOAT)1e-14)
-#endif
-#endif
-#if !defined(M3D_SMALLINDEX)
-typedef uint32_t M3D_INDEX;
-#define M3D_UNDEF 0xffffffff
-#define M3D_INDEXMAX 0xfffffffe
-#else
-typedef uint16_t M3D_INDEX;
-#define M3D_UNDEF 0xffff
-#define M3D_INDEXMAX 0xfffe
-#endif
-#define M3D_NOTDEFINED 0xffffffff
-#ifndef M3D_NUMBONE
-#define M3D_NUMBONE 4
-#endif
-#ifndef M3D_BONEMAXLEVEL
-#define M3D_BONEMAXLEVEL 8
-#endif
-#ifndef _MSC_VER
-#define _inline __inline__
-#define _pack __attribute__((packed))
-#define _unused __attribute__((unused))
-#else
-#define _inline
-#define _pack
-#define _unused __pragma(warning(suppress:4100))
-#endif
-#ifndef  __cplusplus
-#define _register register
-#else
-#define _register
-#endif
-
-/*** File format structures ***/
-
-/**
- * M3D file format structure
- *  3DMO m3dchunk_t file header chunk, may followed by compressed data
- *  HEAD m3dhdr_t model header chunk
- *  n x m3dchunk_t more chunks follow
- *      PRVW preview chunk (optional)
- *      CMAP color map chunk (optional)
- *      TMAP texture map chunk (optional)
- *      VRTS vertex data chunk (optional if it's a material library)
- *      BONE bind-pose skeleton, bone hierarchy chunk (optional)
- *          n x m3db_t contains propably more, but at least one bone
- *          n x m3ds_t skin group records
- *      MTRL* material chunk(s), can be more (optional)
- *          n x m3dp_t each material contains propapbly more, but at least one property
- *                     the properties are configurable with a static array, see m3d_propertytypes
- *      n x m3dchunk_t at least one, but maybe more face chunks
- *          PROC* procedural face, or
- *          MESH* triangle mesh (vertex index list) or
- *          SHPE* mathematical shapes like parameterized surfaces
- *      LBLS* annotation label chunks, can be more (optional)
- *      ACTN* action chunk(s), animation-pose skeletons, can be more (optional)
- *          n x m3dfr_t each action contains probably more, but at least one frame
- *              n x m3dtr_t each frame contains probably more, but at least one transformation
- *      ASET* inlined asset chunk(s), can be more (optional)
- *  OMD3 end chunk
- *
- * Typical chunks for a game engine: 3DMO, HEAD, CMAP, TMAP, VRTS, BONE, MTRL, MESH, ACTN, OMD3
- * Typical chunks for CAD software:  3DMO, HEAD, PRVW, CMAP, TMAP, VRTS, MTRL, SHPE, LBLS, OMD3
- */
-#ifdef _MSC_VER
-#pragma pack(push)
-#pragma pack(1)
-#endif
-
-typedef struct {
-    char magic[4];
-    uint32_t length;
-    float scale; /* deliberately not M3D_FLOAT */
-    uint32_t types;
-} _pack m3dhdr_t;
-
-typedef struct {
-    char magic[4];
-    uint32_t length;
-} _pack m3dchunk_t;
-
-#ifdef _MSC_VER
-#pragma pack(pop)
-#endif
-
-/*** in-memory model structure ***/
-
-/* textmap entry */
-typedef struct {
-    M3D_FLOAT u;
-    M3D_FLOAT v;
-} m3dti_t;
-#define m3d_textureindex_t m3dti_t
-
-/* texture */
-typedef struct {
-    char *name;                 /* texture name */
-    uint8_t *d;                 /* pixels data */
-    uint16_t w;                 /* width */
-    uint16_t h;                 /* height */
-    uint8_t f;                  /* format, 1 = grayscale, 2 = grayscale+alpha, 3 = rgb, 4 = rgba */
-} m3dtx_t;
-#define m3d_texturedata_t m3dtx_t
-
-typedef struct {
-    M3D_INDEX vertexid;
-    M3D_FLOAT weight;
-} m3dw_t;
-#define m3d_weight_t m3dw_t
-
-/* bone entry */
-typedef struct {
-    M3D_INDEX parent;           /* parent bone index */
-    char *name;                 /* name for this bone */
-    M3D_INDEX pos;              /* vertex index position */
-    M3D_INDEX ori;              /* vertex index orientation (quaternion) */
-    M3D_INDEX numweight;        /* number of controlled vertices */
-    m3dw_t *weight;             /* weights for those vertices */
-    M3D_FLOAT mat4[16];         /* transformation matrix */
-} m3db_t;
-#define m3d_bone_t m3db_t
-
-/* skin: bone per vertex entry */
-typedef struct {
-    M3D_INDEX boneid[M3D_NUMBONE];
-    M3D_FLOAT weight[M3D_NUMBONE];
-} m3ds_t;
-#define m3d_skin_t m3ds_t
-
-/* vertex entry */
-typedef struct {
-    M3D_FLOAT x;                /* 3D coordinates and weight */
-    M3D_FLOAT y;
-    M3D_FLOAT z;
-    M3D_FLOAT w;
-    uint32_t color;             /* default vertex color */
-    M3D_INDEX skinid;           /* skin index */
-#ifdef M3D_VERTEXTYPE
-    uint8_t type;
-#endif
-} m3dv_t;
-#define m3d_vertex_t m3dv_t
-
-/* material property formats */
-enum {
-    m3dpf_color,
-    m3dpf_uint8,
-    m3dpf_uint16,
-    m3dpf_uint32,
-    m3dpf_float,
-    m3dpf_map
-};
-typedef struct {
-    uint8_t format;
-    uint8_t id;
-#ifdef M3D_ASCII
-#define M3D_PROPERTYDEF(f,i,n) { (f), (i), (char*)(n) }
-    char *key;
-#else
-#define M3D_PROPERTYDEF(f,i,n) { (f), (i) }
-#endif
-} m3dpd_t;
-
-/* material property types */
-/* You shouldn't change the first 8 display and first 4 physical property. Assign the rest as you like. */
-enum {
-    m3dp_Kd = 0,                /* scalar display properties */
-    m3dp_Ka,
-    m3dp_Ks,
-    m3dp_Ns,
-    m3dp_Ke,
-    m3dp_Tf,
-    m3dp_Km,
-    m3dp_d,
-    m3dp_il,
-
-    m3dp_Pr = 64,               /* scalar physical properties */
-    m3dp_Pm,
-    m3dp_Ps,
-    m3dp_Ni,
-    m3dp_Nt,
-
-    m3dp_map_Kd = 128,          /* textured display map properties */
-    m3dp_map_Ka,
-    m3dp_map_Ks,
-    m3dp_map_Ns,
-    m3dp_map_Ke,
-    m3dp_map_Tf,
-    m3dp_map_Km, /* bump map */
-    m3dp_map_D,
-    m3dp_map_N,  /* normal map */
-
-    m3dp_map_Pr = 192,          /* textured physical map properties */
-    m3dp_map_Pm,
-    m3dp_map_Ps,
-    m3dp_map_Ni,
-    m3dp_map_Nt
-};
-enum {                          /* aliases */
-    m3dp_bump = m3dp_map_Km,
-    m3dp_map_il = m3dp_map_N,
-    m3dp_refl = m3dp_map_Pm
-};
-
-/* material property */
-typedef struct {
-    uint8_t type;               /* property type, see "m3dp_*" enumeration */
-    union {
-        uint32_t color;         /* if value is a color, m3dpf_color */
-        uint32_t num;           /* if value is a number, m3dpf_uint8, m3pf_uint16, m3dpf_uint32 */
-        float    fnum;          /* if value is a floating point number, m3dpf_float */
-        M3D_INDEX textureid;    /* if value is a texture, m3dpf_map */
-    } value;
-} m3dp_t;
-#define m3d_property_t m3dp_t
-
-/* material entry */
-typedef struct {
-    char *name;                 /* name of the material */
-    uint8_t numprop;            /* number of properties */
-    m3dp_t *prop;               /* properties array */
-} m3dm_t;
-#define m3d_material_t m3dm_t
-
-/* face entry */
-typedef struct {
-    M3D_INDEX materialid;       /* material index */
-    M3D_INDEX vertex[3];        /* 3D points of the triangle in CCW order */
-    M3D_INDEX normal[3];        /* normal vectors */
-    M3D_INDEX texcoord[3];      /* UV coordinates */
-} m3df_t;
-#define m3d_face_t m3df_t
-
-/* shape command types. must match the row in m3d_commandtypes */
-enum {
-    /* special commands */
-    m3dc_use = 0,               /* use material */
-    m3dc_inc,                   /* include another shape */
-    m3dc_mesh,                  /* include part of polygon mesh */
-    /* approximations */
-    m3dc_div,                   /* subdivision by constant resolution for both u, v */
-    m3dc_sub,                   /* subdivision by constant, different for u and v */
-    m3dc_len,                   /* spacial subdivision by maxlength */
-    m3dc_dist,                  /* subdivision by maxdistance and maxangle */
-    /* modifiers */
-    m3dc_degu,                  /* degree for both u, v */
-    m3dc_deg,                   /* separate degree for u and v */
-    m3dc_rangeu,                /* range for u */
-    m3dc_range,                 /* range for u and v */
-    m3dc_paru,                  /* u parameters (knots) */
-    m3dc_parv,                  /* v parameters */
-    m3dc_trim,                  /* outer trimming curve */
-    m3dc_hole,                  /* inner trimming curve */
-    m3dc_scrv,                  /* spacial curve */
-    m3dc_sp,                    /* special points */
-    /* helper curves */
-    m3dc_bez1,                  /* Bezier 1D */
-    m3dc_bsp1,                  /* B-spline 1D */
-    m3dc_bez2,                  /* bezier 2D */
-    m3dc_bsp2,                  /* B-spline 2D */
-    /* surfaces */
-    m3dc_bezun,                 /* Bezier 3D with control, UV, normal */
-    m3dc_bezu,                  /* with control and UV */
-    m3dc_bezn,                  /* with control and normal */
-    m3dc_bez,                   /* control points only */
-    m3dc_nurbsun,               /* B-spline 3D */
-    m3dc_nurbsu,
-    m3dc_nurbsn,
-    m3dc_nurbs,
-    m3dc_conn,                 /* connect surfaces */
-    /* geometrical */
-    m3dc_line,
-    m3dc_polygon,
-    m3dc_circle,
-    m3dc_cylinder,
-    m3dc_shpere,
-    m3dc_torus,
-    m3dc_cone,
-    m3dc_cube
-};
-
-/* shape command argument types */
-enum {
-    m3dcp_mi_t = 1,             /* material index */
-    m3dcp_hi_t,                 /* shape index */
-    m3dcp_fi_t,                 /* face index */
-    m3dcp_ti_t,                 /* texture map index */
-    m3dcp_vi_t,                 /* vertex index */
-    m3dcp_qi_t,                 /* vertex index for quaternions */
-    m3dcp_vc_t,                 /* coordinate or radius, float scalar */
-    m3dcp_i1_t,                 /* int8 scalar */
-    m3dcp_i2_t,                 /* int16 scalar */
-    m3dcp_i4_t,                 /* int32 scalar */
-    m3dcp_va_t                  /* variadic arguments */
-};
-
-#define M3D_CMDMAXARG 8         /* if you increase this, add more arguments to the macro below */
-typedef struct {
-#ifdef M3D_ASCII
-#define M3D_CMDDEF(t,n,p,a,b,c,d,e,f,g,h) { (char*)(n), (p), { (a), (b), (c), (d), (e), (f), (g), (h) } }
-    char *key;
-#else
-#define M3D_CMDDEF(t,n,p,a,b,c,d,e,f,g,h) { (p), { (a), (b), (c), (d), (e), (f), (g), (h) } }
-#endif
-    uint8_t p;
-    uint8_t a[M3D_CMDMAXARG];
-} m3dcd_t;
-
-/* shape command */
-typedef struct {
-    uint16_t type;              /* shape type */
-    uint32_t *arg;              /* arguments array */
-} m3dc_t;
-#define m3d_shapecommand_t m3dc_t
-
-/* shape entry */
-typedef struct {
-    char *name;                 /* name of the mathematical shape */
-    M3D_INDEX group;            /* group this shape belongs to or -1 */
-    uint32_t numcmd;            /* number of commands */
-    m3dc_t *cmd;                /* commands array */
-} m3dh_t;
-#define m3d_shape_t m3dh_t
-
-/* label entry */
-typedef struct {
-    char *name;                 /* name of the annotation layer or NULL */
-    char *lang;                 /* language code or NULL */
-    char *text;                 /* the label text */
-    uint32_t color;             /* color */
-    M3D_INDEX vertexid;         /* the vertex the label refers to */
-} m3dl_t;
-#define m3d_label_t m3dl_t
-
-/* frame transformations / working copy skeleton entry */
-typedef struct {
-    M3D_INDEX boneid;           /* selects a node in bone hierarchy */
-    M3D_INDEX pos;              /* vertex index new position */
-    M3D_INDEX ori;              /* vertex index new orientation (quaternion) */
-} m3dtr_t;
-#define m3d_transform_t m3dtr_t
-
-/* animation frame entry */
-typedef struct {
-    uint32_t msec;              /* frame's position on the timeline, timestamp */
-    M3D_INDEX numtransform;     /* number of transformations in this frame */
-    m3dtr_t *transform;         /* transformations */
-} m3dfr_t;
-#define m3d_frame_t m3dfr_t
-
-/* model action entry */
-typedef struct {
-    char *name;                 /* name of the action */
-    uint32_t durationmsec;      /* duration in millisec (1/1000 sec) */
-    M3D_INDEX numframe;         /* number of frames in this animation */
-    m3dfr_t *frame;             /* frames array */
-} m3da_t;
-#define m3d_action_t m3da_t
-
-/* inlined asset */
-typedef struct {
-    char *name;                 /* asset name (same pointer as in texture[].name) */
-    uint8_t *data;              /* compressed asset data */
-    uint32_t length;            /* compressed data length */
-} m3di_t;
-#define m3d_inlinedasset_t m3di_t
-
-/*** in-memory model structure ***/
-#define M3D_FLG_FREERAW     (1<<0)
-#define M3D_FLG_FREESTR     (1<<1)
-#define M3D_FLG_MTLLIB      (1<<2)
-#define M3D_FLG_GENNORM     (1<<3)
-
-typedef struct {
-    m3dhdr_t *raw;              /* pointer to raw data */
-    char flags;                 /* internal flags */
-    signed char errcode;        /* returned error code */
-    char vc_s, vi_s, si_s, ci_s, ti_s, bi_s, nb_s, sk_s, fc_s, hi_s,fi_s;  /* decoded sizes for types */
-    char *name;                 /* name of the model, like "Utah teapot" */
-    char *license;              /* usage condition or license, like "MIT", "LGPL" or "BSD-3clause" */
-    char *author;               /* nickname, email, homepage or github URL etc. */
-    char *desc;                 /* comments, descriptions. May contain '\n' newline character */
-    M3D_FLOAT scale;            /* the model's bounding cube's size in SI meters */
-    M3D_INDEX numcmap;
-    uint32_t *cmap;             /* color map */
-    M3D_INDEX numtmap;
-    m3dti_t *tmap;              /* texture map indices */
-    M3D_INDEX numtexture;
-    m3dtx_t *texture;           /* uncompressed textures */
-    M3D_INDEX numbone;
-    m3db_t *bone;               /* bone hierarchy */
-    M3D_INDEX numvertex;
-    m3dv_t *vertex;             /* vertex data */
-    M3D_INDEX numskin;
-    m3ds_t *skin;               /* skin data */
-    M3D_INDEX nummaterial;
-    m3dm_t *material;           /* material list */
-    M3D_INDEX numface;
-    m3df_t *face;               /* model face, polygon (triangle) mesh */
-    M3D_INDEX numshape;
-    m3dh_t *shape;              /* model face, shape commands */
-    M3D_INDEX numlabel;
-    m3dl_t *label;              /* annotation labels */
-    M3D_INDEX numaction;
-    m3da_t *action;             /* action animations */
-    M3D_INDEX numinlined;
-    m3di_t *inlined;            /* inlined assets */
-    M3D_INDEX numextra;
-    m3dchunk_t **extra;         /* unknown chunks, application / engine specific data probably */
-    m3di_t preview;             /* preview chunk */
-} m3d_t;
-
-/*** export parameters ***/
-#define M3D_EXP_INT8        0
-#define M3D_EXP_INT16       1
-#define M3D_EXP_FLOAT       2
-#define M3D_EXP_DOUBLE      3
-
-#define M3D_EXP_NOCMAP      (1<<0)
-#define M3D_EXP_NOMATERIAL  (1<<1)
-#define M3D_EXP_NOFACE      (1<<2)
-#define M3D_EXP_NONORMAL    (1<<3)
-#define M3D_EXP_NOTXTCRD    (1<<4)
-#define M3D_EXP_FLIPTXTCRD  (1<<5)
-#define M3D_EXP_NORECALC    (1<<6)
-#define M3D_EXP_IDOSUCK     (1<<7)
-#define M3D_EXP_NOBONE      (1<<8)
-#define M3D_EXP_NOACTION    (1<<9)
-#define M3D_EXP_INLINE      (1<<10)
-#define M3D_EXP_EXTRA       (1<<11)
-#define M3D_EXP_NOZLIB      (1<<14)
-#define M3D_EXP_ASCII       (1<<15)
-
-/*** error codes ***/
-#define M3D_SUCCESS         0
-#define M3D_ERR_ALLOC       -1
-#define M3D_ERR_BADFILE     -2
-#define M3D_ERR_UNIMPL      -65
-#define M3D_ERR_UNKPROP     -66
-#define M3D_ERR_UNKMESH     -67
-#define M3D_ERR_UNKIMG      -68
-#define M3D_ERR_UNKFRAME    -69
-#define M3D_ERR_UNKCMD      -70
-#define M3D_ERR_TRUNC       -71
-#define M3D_ERR_CMAP        -72
-#define M3D_ERR_TMAP        -73
-#define M3D_ERR_VRTS        -74
-#define M3D_ERR_BONE        -75
-#define M3D_ERR_MTRL        -76
-#define M3D_ERR_SHPE        -77
-
-#define M3D_ERR_ISFATAL(x)  ((x) < 0 && (x) > -65)
-
-/* callbacks */
-typedef unsigned char *(*m3dread_t)(char *filename, unsigned int *size);                        /* read file contents into buffer */
-typedef void (*m3dfree_t)(void *buffer);                                                        /* free file contents buffer */
-typedef int (*m3dtxsc_t)(const char *name, const void *script, uint32_t len, m3dtx_t *output);  /* interpret texture script */
-typedef int (*m3dprsc_t)(const char *name, const void *script, uint32_t len, m3d_t *model);     /* interpret surface script */
-#endif /* ifndef M3D_APIVERSION */
-
-/*** C prototypes ***/
-/* import / export */
-m3d_t *m3d_load(unsigned char *data, m3dread_t readfilecb, m3dfree_t freecb, m3d_t *mtllib);
-unsigned char *m3d_save(m3d_t *model, int quality, int flags, unsigned int *size);
-void m3d_free(m3d_t *model);
-/* generate animation pose skeleton */
-m3dtr_t *m3d_frame(m3d_t *model, M3D_INDEX actionid, M3D_INDEX frameid, m3dtr_t *skeleton);
-m3db_t *m3d_pose(m3d_t *model, M3D_INDEX actionid, uint32_t msec);
-
-/* private prototypes used by both importer and exporter */
-char *_m3d_safestr(char *in, int morelines);
-
-/*** C implementation ***/
-#ifdef M3D_IMPLEMENTATION
-#if !defined(M3D_NOIMPORTER) || defined(M3D_EXPORTER)
-/* material property definitions */
-static m3dpd_t m3d_propertytypes[] = {
-    M3D_PROPERTYDEF(m3dpf_color, m3dp_Kd, "Kd"),    /* diffuse color */
-    M3D_PROPERTYDEF(m3dpf_color, m3dp_Ka, "Ka"),    /* ambient color */
-    M3D_PROPERTYDEF(m3dpf_color, m3dp_Ks, "Ks"),    /* specular color */
-    M3D_PROPERTYDEF(m3dpf_float, m3dp_Ns, "Ns"),    /* specular exponent */
-    M3D_PROPERTYDEF(m3dpf_color, m3dp_Ke, "Ke"),    /* emissive (emitting light of this color) */
-    M3D_PROPERTYDEF(m3dpf_color, m3dp_Tf, "Tf"),    /* transmission color */
-    M3D_PROPERTYDEF(m3dpf_float, m3dp_Km, "Km"),    /* bump strength */
-    M3D_PROPERTYDEF(m3dpf_float, m3dp_d,  "d"),     /* dissolve (transparency) */
-    M3D_PROPERTYDEF(m3dpf_uint8, m3dp_il, "il"),    /* illumination model (informational, ignored by PBR-shaders) */
-
-    M3D_PROPERTYDEF(m3dpf_float, m3dp_Pr, "Pr"),    /* roughness */
-    M3D_PROPERTYDEF(m3dpf_float, m3dp_Pm, "Pm"),    /* metallic, also reflection */
-    M3D_PROPERTYDEF(m3dpf_float, m3dp_Ps, "Ps"),    /* sheen */
-    M3D_PROPERTYDEF(m3dpf_float, m3dp_Ni, "Ni"),    /* index of refraction (optical density) */
-    M3D_PROPERTYDEF(m3dpf_float, m3dp_Nt, "Nt"),    /* thickness of face in millimeter, for printing */
-
-    /* aliases, note that "map_*" aliases are handled automatically */
-    M3D_PROPERTYDEF(m3dpf_map, m3dp_map_Km, "bump"),
-    M3D_PROPERTYDEF(m3dpf_map, m3dp_map_N, "map_N"),/* as normal map has no scalar version, it's counterpart is 'il' */
-    M3D_PROPERTYDEF(m3dpf_map, m3dp_map_Pm, "refl")
-};
-/* shape command definitions. if more commands start with the same string, the longer must come first */
-static m3dcd_t m3d_commandtypes[] = {
-    /* technical */
-    M3D_CMDDEF(m3dc_use,     "use",     1, m3dcp_mi_t, 0, 0, 0, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_inc,     "inc",     3, m3dcp_hi_t, m3dcp_vi_t, m3dcp_qi_t, m3dcp_vi_t, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_mesh,    "mesh",    1, m3dcp_fi_t, m3dcp_fi_t, m3dcp_vi_t, m3dcp_qi_t, m3dcp_vi_t, 0, 0, 0),
-    /* approximations */
-    M3D_CMDDEF(m3dc_div,     "div",     1, m3dcp_vc_t, 0, 0, 0, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_sub,     "sub",     2, m3dcp_vc_t, m3dcp_vc_t, 0, 0, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_len,     "len",     1, m3dcp_vc_t, 0, 0, 0, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_dist,    "dist",    2, m3dcp_vc_t, m3dcp_vc_t, 0, 0, 0, 0, 0, 0),
-    /* modifiers */
-    M3D_CMDDEF(m3dc_degu,    "degu",    1, m3dcp_i1_t, 0, 0, 0, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_deg,     "deg",     2, m3dcp_i1_t, m3dcp_i1_t, 0, 0, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_rangeu,  "rangeu",  1, m3dcp_ti_t, 0, 0, 0, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_range,   "range",   2, m3dcp_ti_t, m3dcp_ti_t, 0, 0, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_paru,    "paru",    2, m3dcp_va_t, m3dcp_vc_t, 0, 0, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_parv,    "parv",    2, m3dcp_va_t, m3dcp_vc_t, 0, 0, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_trim,    "trim",    3, m3dcp_va_t, m3dcp_ti_t, m3dcp_i2_t, 0, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_hole,    "hole",    3, m3dcp_va_t, m3dcp_ti_t, m3dcp_i2_t, 0, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_scrv,    "scrv",    3, m3dcp_va_t, m3dcp_ti_t, m3dcp_i2_t, 0, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_sp,      "sp",      2, m3dcp_va_t, m3dcp_vi_t, 0, 0, 0, 0, 0, 0),
-    /* helper curves */
-    M3D_CMDDEF(m3dc_bez1,    "bez1",    2, m3dcp_va_t, m3dcp_vi_t, 0, 0, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_bsp1,    "bsp1",    2, m3dcp_va_t, m3dcp_vi_t, 0, 0, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_bez2,    "bez2",    2, m3dcp_va_t, m3dcp_vi_t, 0, 0, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_bsp2,    "bsp2",    2, m3dcp_va_t, m3dcp_vi_t, 0, 0, 0, 0, 0, 0),
-    /* surfaces */
-    M3D_CMDDEF(m3dc_bezun,   "bezun",   4, m3dcp_va_t, m3dcp_vi_t, m3dcp_ti_t, m3dcp_vi_t, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_bezu,    "bezu",    3, m3dcp_va_t, m3dcp_vi_t, m3dcp_ti_t, 0, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_bezn,    "bezn",    3, m3dcp_va_t, m3dcp_vi_t, m3dcp_vi_t, 0, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_bez,     "bez",     2, m3dcp_va_t, m3dcp_vi_t, 0, 0, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_nurbsun, "nurbsun", 4, m3dcp_va_t, m3dcp_vi_t, m3dcp_ti_t, m3dcp_vi_t, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_nurbsu,  "nurbsu",  3, m3dcp_va_t, m3dcp_vi_t, m3dcp_ti_t, 0, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_nurbsn,  "nurbsn",  3, m3dcp_va_t, m3dcp_vi_t, m3dcp_vi_t, 0, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_nurbs,   "nurbs",   2, m3dcp_va_t, m3dcp_vi_t, 0, 0, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_conn,    "conn",    6, m3dcp_i2_t, m3dcp_ti_t, m3dcp_i2_t, m3dcp_i2_t, m3dcp_ti_t, m3dcp_i2_t, 0, 0),
-    /* geometrical */
-    M3D_CMDDEF(m3dc_line,    "line",    2, m3dcp_va_t, m3dcp_vi_t, 0, 0, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_polygon, "polygon", 2, m3dcp_va_t, m3dcp_vi_t, 0, 0, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_circle,  "circle",  3, m3dcp_vi_t, m3dcp_qi_t, m3dcp_vc_t, 0, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_cylinder,"cylinder",6, m3dcp_vi_t, m3dcp_qi_t, m3dcp_vc_t, m3dcp_vi_t, m3dcp_qi_t, m3dcp_vc_t, 0, 0),
-    M3D_CMDDEF(m3dc_shpere,  "shpere",  2, m3dcp_vi_t, m3dcp_vc_t, 0, 0, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_torus,   "torus",   4, m3dcp_vi_t, m3dcp_qi_t, m3dcp_vc_t, m3dcp_vc_t, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_cone,    "cone",    3, m3dcp_vi_t, m3dcp_vi_t, m3dcp_vi_t, 0, 0, 0, 0, 0),
-    M3D_CMDDEF(m3dc_cube,    "cube",    3, m3dcp_vi_t, m3dcp_vi_t, m3dcp_vi_t, 0, 0, 0, 0, 0)
-};
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-
-#if !defined(M3D_NOIMPORTER) && !defined(STBI_INCLUDE_STB_IMAGE_H)
-/* PNG decompressor from
-
-   stb_image - v2.23 - public domain image loader - http://nothings.org/stb_image.h
-*/
-static const char *_m3dstbi__g_failure_reason;
-
-enum
-{
-   STBI_default = 0,
-
-   STBI_grey       = 1,
-   STBI_grey_alpha = 2,
-   STBI_rgb        = 3,
-   STBI_rgb_alpha  = 4
-};
-
-enum
-{
-   STBI__SCAN_load=0,
-   STBI__SCAN_type,
-   STBI__SCAN_header
-};
-
-typedef unsigned short _m3dstbi_us;
-
-typedef uint16_t _m3dstbi__uint16;
-typedef int16_t  _m3dstbi__int16;
-typedef uint32_t _m3dstbi__uint32;
-typedef int32_t  _m3dstbi__int32;
-
-typedef struct
-{
-   _m3dstbi__uint32 img_x, img_y;
-   int img_n, img_out_n;
-
-   void *io_user_data;
-
-   int read_from_callbacks;
-   int buflen;
-   unsigned char buffer_start[128];
-
-   unsigned char *img_buffer, *img_buffer_end;
-   unsigned char *img_buffer_original, *img_buffer_original_end;
-} _m3dstbi__context;
-
-typedef struct
-{
-   int bits_per_channel;
-   int num_channels;
-   int channel_order;
-} _m3dstbi__result_info;
-
-#define STBI_ASSERT(v)
-#define STBI_NOTUSED(v)  (void)sizeof(v)
-#define STBI__BYTECAST(x)  ((unsigned char) ((x) & 255))
-#define STBI_MALLOC(sz)           M3D_MALLOC(sz)
-#define STBI_REALLOC(p,newsz)     M3D_REALLOC(p,newsz)
-#define STBI_FREE(p)              M3D_FREE(p)
-#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz)
-
-_inline static unsigned char _m3dstbi__get8(_m3dstbi__context *s)
-{
-   if (s->img_buffer < s->img_buffer_end)
-      return *s->img_buffer++;
-   return 0;
-}
-
-_inline static int _m3dstbi__at_eof(_m3dstbi__context *s)
-{
-   return s->img_buffer >= s->img_buffer_end;
-}
-
-static void _m3dstbi__skip(_m3dstbi__context *s, int n)
-{
-   if (n < 0) {
-      s->img_buffer = s->img_buffer_end;
-      return;
-   }
-   s->img_buffer += n;
-}
-
-static int _m3dstbi__getn(_m3dstbi__context *s, unsigned char *buffer, int n)
-{
-   if (s->img_buffer+n <= s->img_buffer_end) {
-      memcpy(buffer, s->img_buffer, n);
-      s->img_buffer += n;
-      return 1;
-   } else
-      return 0;
-}
-
-static int _m3dstbi__get16be(_m3dstbi__context *s)
-{
-   int z = _m3dstbi__get8(s);
-   return (z << 8) + _m3dstbi__get8(s);
-}
-
-static _m3dstbi__uint32 _m3dstbi__get32be(_m3dstbi__context *s)
-{
-   _m3dstbi__uint32 z = _m3dstbi__get16be(s);
-   return (z << 16) + _m3dstbi__get16be(s);
-}
-
-#define _m3dstbi__err(x,y)  _m3dstbi__errstr(y)
-static int _m3dstbi__errstr(const char *str)
-{
-   _m3dstbi__g_failure_reason = str;
-   return 0;
-}
-
-_inline static void *_m3dstbi__malloc(size_t size)
-{
-    return STBI_MALLOC(size);
-}
-
-static int _m3dstbi__addsizes_valid(int a, int b)
-{
-   if (b < 0) return 0;
-   return a <= 2147483647 - b;
-}
-
-static int _m3dstbi__mul2sizes_valid(int a, int b)
-{
-   if (a < 0 || b < 0) return 0;
-   if (b == 0) return 1;
-   return a <= 2147483647/b;
-}
-
-static int _m3dstbi__mad2sizes_valid(int a, int b, int add)
-{
-   return _m3dstbi__mul2sizes_valid(a, b) && _m3dstbi__addsizes_valid(a*b, add);
-}
-
-static int _m3dstbi__mad3sizes_valid(int a, int b, int c, int add)
-{
-   return _m3dstbi__mul2sizes_valid(a, b) && _m3dstbi__mul2sizes_valid(a*b, c) &&
-      _m3dstbi__addsizes_valid(a*b*c, add);
-}
-
-static void *_m3dstbi__malloc_mad2(int a, int b, int add)
-{
-   if (!_m3dstbi__mad2sizes_valid(a, b, add)) return NULL;
-   return _m3dstbi__malloc(a*b + add);
-}
-
-static void *_m3dstbi__malloc_mad3(int a, int b, int c, int add)
-{
-   if (!_m3dstbi__mad3sizes_valid(a, b, c, add)) return NULL;
-   return _m3dstbi__malloc(a*b*c + add);
-}
-
-static unsigned char _m3dstbi__compute_y(int r, int g, int b)
-{
-   return (unsigned char) (((r*77) + (g*150) +  (29*b)) >> 8);
-}
-
-static unsigned char *_m3dstbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y)
-{
-   int i,j;
-   unsigned char *good;
-
-   if (req_comp == img_n) return data;
-   STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
-
-   good = (unsigned char *) _m3dstbi__malloc_mad3(req_comp, x, y, 0);
-   if (good == NULL) {
-      STBI_FREE(data);
-      _m3dstbi__err("outofmem", "Out of memory");
-      return NULL;
-   }
-
-   for (j=0; j < (int) y; ++j) {
-      unsigned char *src  = data + j * x * img_n   ;
-      unsigned char *dest = good + j * x * req_comp;
-
-      #define STBI__COMBO(a,b)  ((a)*8+(b))
-      #define STBI__CASE(a,b)   case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
-      switch (STBI__COMBO(img_n, req_comp)) {
-         STBI__CASE(1,2) { dest[0]=src[0], dest[1]=255;                                     } break;
-         STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0];                                  } break;
-         STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=255;                     } break;
-         STBI__CASE(2,1) { dest[0]=src[0];                                                  } break;
-         STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0];                                  } break;
-         STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1];                  } break;
-         STBI__CASE(3,4) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=255;        } break;
-         STBI__CASE(3,1) { dest[0]=_m3dstbi__compute_y(src[0],src[1],src[2]);                   } break;
-         STBI__CASE(3,2) { dest[0]=_m3dstbi__compute_y(src[0],src[1],src[2]), dest[1] = 255;    } break;
-         STBI__CASE(4,1) { dest[0]=_m3dstbi__compute_y(src[0],src[1],src[2]);                   } break;
-         STBI__CASE(4,2) { dest[0]=_m3dstbi__compute_y(src[0],src[1],src[2]), dest[1] = src[3]; } break;
-         STBI__CASE(4,3) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2];                    } break;
-         default: STBI_ASSERT(0);
-      }
-      #undef STBI__CASE
-   }
-
-   STBI_FREE(data);
-   return good;
-}
-
-static _m3dstbi__uint16 _m3dstbi__compute_y_16(int r, int g, int b)
-{
-   return (_m3dstbi__uint16) (((r*77) + (g*150) +  (29*b)) >> 8);
-}
-
-static _m3dstbi__uint16 *_m3dstbi__convert_format16(_m3dstbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y)
-{
-   int i,j;
-   _m3dstbi__uint16 *good;
-
-   if (req_comp == img_n) return data;
-   STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
-
-   good = (_m3dstbi__uint16 *) _m3dstbi__malloc(req_comp * x * y * 2);
-   if (good == NULL) {
-      STBI_FREE(data);
-      _m3dstbi__err("outofmem", "Out of memory");
-      return NULL;
-   }
-
-   for (j=0; j < (int) y; ++j) {
-      _m3dstbi__uint16 *src  = data + j * x * img_n   ;
-      _m3dstbi__uint16 *dest = good + j * x * req_comp;
-
-      #define STBI__COMBO(a,b)  ((a)*8+(b))
-      #define STBI__CASE(a,b)   case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
-      switch (STBI__COMBO(img_n, req_comp)) {
-         STBI__CASE(1,2) { dest[0]=src[0], dest[1]=0xffff;                                     } break;
-         STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0];                                     } break;
-         STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=0xffff;                     } break;
-         STBI__CASE(2,1) { dest[0]=src[0];                                                     } break;
-         STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0];                                     } break;
-         STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1];                     } break;
-         STBI__CASE(3,4) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=0xffff;        } break;
-         STBI__CASE(3,1) { dest[0]=_m3dstbi__compute_y_16(src[0],src[1],src[2]);                   } break;
-         STBI__CASE(3,2) { dest[0]=_m3dstbi__compute_y_16(src[0],src[1],src[2]), dest[1] = 0xffff; } break;
-         STBI__CASE(4,1) { dest[0]=_m3dstbi__compute_y_16(src[0],src[1],src[2]);                   } break;
-         STBI__CASE(4,2) { dest[0]=_m3dstbi__compute_y_16(src[0],src[1],src[2]), dest[1] = src[3]; } break;
-         STBI__CASE(4,3) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2];                       } break;
-         default: STBI_ASSERT(0);
-      }
-      #undef STBI__CASE
-   }
-
-   STBI_FREE(data);
-   return good;
-}
-
-#define STBI__ZFAST_BITS  9
-#define STBI__ZFAST_MASK  ((1 << STBI__ZFAST_BITS) - 1)
-
-typedef struct
-{
-   _m3dstbi__uint16 fast[1 << STBI__ZFAST_BITS];
-   _m3dstbi__uint16 firstcode[16];
-   int maxcode[17];
-   _m3dstbi__uint16 firstsymbol[16];
-   unsigned char  size[288];
-   _m3dstbi__uint16 value[288];
-} _m3dstbi__zhuffman;
-
-_inline static int _m3dstbi__bitreverse16(int n)
-{
-  n = ((n & 0xAAAA) >>  1) | ((n & 0x5555) << 1);
-  n = ((n & 0xCCCC) >>  2) | ((n & 0x3333) << 2);
-  n = ((n & 0xF0F0) >>  4) | ((n & 0x0F0F) << 4);
-  n = ((n & 0xFF00) >>  8) | ((n & 0x00FF) << 8);
-  return n;
-}
-
-_inline static int _m3dstbi__bit_reverse(int v, int bits)
-{
-   STBI_ASSERT(bits <= 16);
-   return _m3dstbi__bitreverse16(v) >> (16-bits);
-}
-
-static int _m3dstbi__zbuild_huffman(_m3dstbi__zhuffman *z, unsigned char *sizelist, int num)
-{
-   int i,k=0;
-   int code, next_code[16], sizes[17];
-
-   memset(sizes, 0, sizeof(sizes));
-   memset(z->fast, 0, sizeof(z->fast));
-   for (i=0; i < num; ++i)
-      ++sizes[sizelist[i]];
-   sizes[0] = 0;
-   for (i=1; i < 16; ++i)
-      if (sizes[i] > (1 << i))
-         return _m3dstbi__err("bad sizes", "Corrupt PNG");
-   code = 0;
-   for (i=1; i < 16; ++i) {
-      next_code[i] = code;
-      z->firstcode[i] = (_m3dstbi__uint16) code;
-      z->firstsymbol[i] = (_m3dstbi__uint16) k;
-      code = (code + sizes[i]);
-      if (sizes[i])
-         if (code-1 >= (1 << i)) return _m3dstbi__err("bad codelengths","Corrupt PNG");
-      z->maxcode[i] = code << (16-i);
-      code <<= 1;
-      k += sizes[i];
-   }
-   z->maxcode[16] = 0x10000;
-   for (i=0; i < num; ++i) {
-      int s = sizelist[i];
-      if (s) {
-         int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s];
-         _m3dstbi__uint16 fastv = (_m3dstbi__uint16) ((s << 9) | i);
-         z->size [c] = (unsigned char     ) s;
-         z->value[c] = (_m3dstbi__uint16) i;
-         if (s <= STBI__ZFAST_BITS) {
-            int j = _m3dstbi__bit_reverse(next_code[s],s);
-            while (j < (1 << STBI__ZFAST_BITS)) {
-               z->fast[j] = fastv;
-               j += (1 << s);
-            }
-         }
-         ++next_code[s];
-      }
-   }
-   return 1;
-}
-
-typedef struct
-{
-   unsigned char *zbuffer, *zbuffer_end;
-   int num_bits;
-   _m3dstbi__uint32 code_buffer;
-
-   char *zout;
-   char *zout_start;
-   char *zout_end;
-   int   z_expandable;
-
-   _m3dstbi__zhuffman z_length, z_distance;
-} _m3dstbi__zbuf;
-
-_inline static unsigned char _m3dstbi__zget8(_m3dstbi__zbuf *z)
-{
-   if (z->zbuffer >= z->zbuffer_end) return 0;
-   return *z->zbuffer++;
-}
-
-static void _m3dstbi__fill_bits(_m3dstbi__zbuf *z)
-{
-   do {
-      STBI_ASSERT(z->code_buffer < (1U << z->num_bits));
-      z->code_buffer |= (unsigned int) _m3dstbi__zget8(z) << z->num_bits;
-      z->num_bits += 8;
-   } while (z->num_bits <= 24);
-}
-
-_inline static unsigned int _m3dstbi__zreceive(_m3dstbi__zbuf *z, int n)
-{
-   unsigned int k;
-   if (z->num_bits < n) _m3dstbi__fill_bits(z);
-   k = z->code_buffer & ((1 << n) - 1);
-   z->code_buffer >>= n;
-   z->num_bits -= n;
-   return k;
-}
-
-static int _m3dstbi__zhuffman_decode_slowpath(_m3dstbi__zbuf *a, _m3dstbi__zhuffman *z)
-{
-   int b,s,k;
-   k = _m3dstbi__bit_reverse(a->code_buffer, 16);
-   for (s=STBI__ZFAST_BITS+1; ; ++s)
-      if (k < z->maxcode[s])
-         break;
-   if (s == 16) return -1;
-   b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s];
-   STBI_ASSERT(z->size[b] == s);
-   a->code_buffer >>= s;
-   a->num_bits -= s;
-   return z->value[b];
-}
-
-_inline static int _m3dstbi__zhuffman_decode(_m3dstbi__zbuf *a, _m3dstbi__zhuffman *z)
-{
-   int b,s;
-   if (a->num_bits < 16) _m3dstbi__fill_bits(a);
-   b = z->fast[a->code_buffer & STBI__ZFAST_MASK];
-   if (b) {
-      s = b >> 9;
-      a->code_buffer >>= s;
-      a->num_bits -= s;
-      return b & 511;
-   }
-   return _m3dstbi__zhuffman_decode_slowpath(a, z);
-}
-
-static int _m3dstbi__zexpand(_m3dstbi__zbuf *z, char *zout, int n)
-{
-   char *q;
-   int cur, limit, old_limit;
-   z->zout = zout;
-   if (!z->z_expandable) return _m3dstbi__err("output buffer limit","Corrupt PNG");
-   cur   = (int) (z->zout     - z->zout_start);
-   limit = old_limit = (int) (z->zout_end - z->zout_start);
-   while (cur + n > limit)
-      limit *= 2;
-   q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit);
-   STBI_NOTUSED(old_limit);
-   if (q == NULL) return _m3dstbi__err("outofmem", "Out of memory");
-   z->zout_start = q;
-   z->zout       = q + cur;
-   z->zout_end   = q + limit;
-   return 1;
-}
-
-static int _m3dstbi__zlength_base[31] = {
-   3,4,5,6,7,8,9,10,11,13,
-   15,17,19,23,27,31,35,43,51,59,
-   67,83,99,115,131,163,195,227,258,0,0 };
-
-static int _m3dstbi__zlength_extra[31]=
-{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 };
-
-static int _m3dstbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,
-257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0};
-
-static int _m3dstbi__zdist_extra[32] =
-{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
-
-static int _m3dstbi__parse_huffman_block(_m3dstbi__zbuf *a)
-{
-   char *zout = a->zout;
-   for(;;) {
-      int z = _m3dstbi__zhuffman_decode(a, &a->z_length);
-      if (z < 256) {
-         if (z < 0) return _m3dstbi__err("bad huffman code","Corrupt PNG");
-         if (zout >= a->zout_end) {
-            if (!_m3dstbi__zexpand(a, zout, 1)) return 0;
-            zout = a->zout;
-         }
-         *zout++ = (char) z;
-      } else {
-         unsigned char *p;
-         int len,dist;
-         if (z == 256) {
-            a->zout = zout;
-            return 1;
-         }
-         z -= 257;
-         len = _m3dstbi__zlength_base[z];
-         if (_m3dstbi__zlength_extra[z]) len += _m3dstbi__zreceive(a, _m3dstbi__zlength_extra[z]);
-         z = _m3dstbi__zhuffman_decode(a, &a->z_distance);
-         if (z < 0) return _m3dstbi__err("bad huffman code","Corrupt PNG");
-         dist = _m3dstbi__zdist_base[z];
-         if (_m3dstbi__zdist_extra[z]) dist += _m3dstbi__zreceive(a, _m3dstbi__zdist_extra[z]);
-         if (zout - a->zout_start < dist) return _m3dstbi__err("bad dist","Corrupt PNG");
-         if (zout + len > a->zout_end) {
-            if (!_m3dstbi__zexpand(a, zout, len)) return 0;
-            zout = a->zout;
-         }
-         p = (unsigned char *) (zout - dist);
-         if (dist == 1) {
-            unsigned char v = *p;
-            if (len) { do *zout++ = v; while (--len); }
-         } else {
-            if (len) { do *zout++ = *p++; while (--len); }
-         }
-      }
-   }
-}
-
-static int _m3dstbi__compute_huffman_codes(_m3dstbi__zbuf *a)
-{
-   static unsigned char length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };
-   _m3dstbi__zhuffman z_codelength;
-   unsigned char lencodes[286+32+137];
-   unsigned char codelength_sizes[19];
-   int i,n;
-
-   int hlit  = _m3dstbi__zreceive(a,5) + 257;
-   int hdist = _m3dstbi__zreceive(a,5) + 1;
-   int hclen = _m3dstbi__zreceive(a,4) + 4;
-   int ntot  = hlit + hdist;
-
-   memset(codelength_sizes, 0, sizeof(codelength_sizes));
-   for (i=0; i < hclen; ++i) {
-      int s = _m3dstbi__zreceive(a,3);
-      codelength_sizes[length_dezigzag[i]] = (unsigned char) s;
-   }
-   if (!_m3dstbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0;
-
-   n = 0;
-   while (n < ntot) {
-      int c = _m3dstbi__zhuffman_decode(a, &z_codelength);
-      if (c < 0 || c >= 19) return _m3dstbi__err("bad codelengths", "Corrupt PNG");
-      if (c < 16)
-         lencodes[n++] = (unsigned char) c;
-      else {
-         unsigned char fill = 0;
-         if (c == 16) {
-            c = _m3dstbi__zreceive(a,2)+3;
-            if (n == 0) return _m3dstbi__err("bad codelengths", "Corrupt PNG");
-            fill = lencodes[n-1];
-         } else if (c == 17)
-            c = _m3dstbi__zreceive(a,3)+3;
-         else {
-            STBI_ASSERT(c == 18);
-            c = _m3dstbi__zreceive(a,7)+11;
-         }
-         if (ntot - n < c) return _m3dstbi__err("bad codelengths", "Corrupt PNG");
-         memset(lencodes+n, fill, c);
-         n += c;
-      }
-   }
-   if (n != ntot) return _m3dstbi__err("bad codelengths","Corrupt PNG");
-   if (!_m3dstbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0;
-   if (!_m3dstbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0;
-   return 1;
-}
-
-_inline static int _m3dstbi__parse_uncompressed_block(_m3dstbi__zbuf *a)
-{
-   unsigned char header[4];
-   int len,nlen,k;
-   if (a->num_bits & 7)
-      _m3dstbi__zreceive(a, a->num_bits & 7);
-   k = 0;
-   while (a->num_bits > 0) {
-      header[k++] = (unsigned char) (a->code_buffer & 255);
-      a->code_buffer >>= 8;
-      a->num_bits -= 8;
-   }
-   STBI_ASSERT(a->num_bits == 0);
-   while (k < 4)
-      header[k++] = _m3dstbi__zget8(a);
-   len  = header[1] * 256 + header[0];
-   nlen = header[3] * 256 + header[2];
-   if (nlen != (len ^ 0xffff)) return _m3dstbi__err("zlib corrupt","Corrupt PNG");
-   if (a->zbuffer + len > a->zbuffer_end) return _m3dstbi__err("read past buffer","Corrupt PNG");
-   if (a->zout + len > a->zout_end)
-      if (!_m3dstbi__zexpand(a, a->zout, len)) return 0;
-   memcpy(a->zout, a->zbuffer, len);
-   a->zbuffer += len;
-   a->zout += len;
-   return 1;
-}
-
-static int _m3dstbi__parse_zlib_header(_m3dstbi__zbuf *a)
-{
-   int cmf   = _m3dstbi__zget8(a);
-   int cm    = cmf & 15;
-   /* int cinfo = cmf >> 4; */
-   int flg   = _m3dstbi__zget8(a);
-   if ((cmf*256+flg) % 31 != 0) return _m3dstbi__err("bad zlib header","Corrupt PNG");
-   if (flg & 32) return _m3dstbi__err("no preset dict","Corrupt PNG");
-   if (cm != 8) return _m3dstbi__err("bad compression","Corrupt PNG");
-   return 1;
-}
-
-static unsigned char _m3dstbi__zdefault_length[288], _m3dstbi__zdefault_distance[32];
-static void _m3dstbi__init_zdefaults(void)
-{
-   int i;
-   for (i=0; i <= 143; ++i)     _m3dstbi__zdefault_length[i]   = 8;
-   for (   ; i <= 255; ++i)     _m3dstbi__zdefault_length[i]   = 9;
-   for (   ; i <= 279; ++i)     _m3dstbi__zdefault_length[i]   = 7;
-   for (   ; i <= 287; ++i)     _m3dstbi__zdefault_length[i]   = 8;
-
-   for (i=0; i <=  31; ++i)     _m3dstbi__zdefault_distance[i] = 5;
-}
-
-static int _m3dstbi__parse_zlib(_m3dstbi__zbuf *a, int parse_header)
-{
-   int final, type;
-   if (parse_header)
-      if (!_m3dstbi__parse_zlib_header(a)) return 0;
-   a->num_bits = 0;
-   a->code_buffer = 0;
-   do {
-      final = _m3dstbi__zreceive(a,1);
-      type = _m3dstbi__zreceive(a,2);
-      if (type == 0) {
-         if (!_m3dstbi__parse_uncompressed_block(a)) return 0;
-      } else if (type == 3) {
-         return 0;
-      } else {
-         if (type == 1) {
-            if (!_m3dstbi__zbuild_huffman(&a->z_length  , _m3dstbi__zdefault_length  , 288)) return 0;
-            if (!_m3dstbi__zbuild_huffman(&a->z_distance, _m3dstbi__zdefault_distance,  32)) return 0;
-         } else {
-            if (!_m3dstbi__compute_huffman_codes(a)) return 0;
-         }
-         if (!_m3dstbi__parse_huffman_block(a)) return 0;
-      }
-   } while (!final);
-   return 1;
-}
-
-static int _m3dstbi__do_zlib(_m3dstbi__zbuf *a, char *obuf, int olen, int exp, int parse_header)
-{
-   a->zout_start = obuf;
-   a->zout       = obuf;
-   a->zout_end   = obuf + olen;
-   a->z_expandable = exp;
-   _m3dstbi__init_zdefaults();
-   return _m3dstbi__parse_zlib(a, parse_header);
-}
-
-char *_m3dstbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)
-{
-   _m3dstbi__zbuf a;
-   char *p = (char *) _m3dstbi__malloc(initial_size);
-   if (p == NULL) return NULL;
-   a.zbuffer = (unsigned char *) buffer;
-   a.zbuffer_end = (unsigned char *) buffer + len;
-   if (_m3dstbi__do_zlib(&a, p, initial_size, 1, parse_header)) {
-      if (outlen) *outlen = (int) (a.zout - a.zout_start);
-      return a.zout_start;
-   } else {
-      STBI_FREE(a.zout_start);
-      return NULL;
-   }
-}
-
-typedef struct
-{
-   _m3dstbi__uint32 length;
-   _m3dstbi__uint32 type;
-} _m3dstbi__pngchunk;
-
-static _m3dstbi__pngchunk _m3dstbi__get_chunk_header(_m3dstbi__context *s)
-{
-   _m3dstbi__pngchunk c;
-   c.length = _m3dstbi__get32be(s);
-   c.type   = _m3dstbi__get32be(s);
-   return c;
-}
-
-_inline static int _m3dstbi__check_png_header(_m3dstbi__context *s)
-{
-   static unsigned char png_sig[8] = { 137,80,78,71,13,10,26,10 };
-   int i;
-   for (i=0; i < 8; ++i)
-      if (_m3dstbi__get8(s) != png_sig[i]) return _m3dstbi__err("bad png sig","Not a PNG");
-   return 1;
-}
-
-typedef struct
-{
-   _m3dstbi__context *s;
-   unsigned char *idata, *expanded, *out;
-   int depth;
-} _m3dstbi__png;
-
-
-enum {
-   STBI__F_none=0,
-   STBI__F_sub=1,
-   STBI__F_up=2,
-   STBI__F_avg=3,
-   STBI__F_paeth=4,
-   STBI__F_avg_first,
-   STBI__F_paeth_first
-};
-
-static unsigned char first_row_filter[5] =
-{
-   STBI__F_none,
-   STBI__F_sub,
-   STBI__F_none,
-   STBI__F_avg_first,
-   STBI__F_paeth_first
-};
-
-static int _m3dstbi__paeth(int a, int b, int c)
-{
-   int p = a + b - c;
-   int pa = abs(p-a);
-   int pb = abs(p-b);
-   int pc = abs(p-c);
-   if (pa <= pb && pa <= pc) return a;
-   if (pb <= pc) return b;
-   return c;
-}
-
-static unsigned char _m3dstbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 };
-
-static int _m3dstbi__create_png_image_raw(_m3dstbi__png *a, unsigned char *raw, _m3dstbi__uint32 raw_len, int out_n, _m3dstbi__uint32 x, _m3dstbi__uint32 y, int depth, int color)
-{
-   int bytes = (depth == 16? 2 : 1);
-   _m3dstbi__context *s = a->s;
-   _m3dstbi__uint32 i,j,stride = x*out_n*bytes;
-   _m3dstbi__uint32 img_len, img_width_bytes;
-   int k;
-   int img_n = s->img_n;
-
-   int output_bytes = out_n*bytes;
-   int filter_bytes = img_n*bytes;
-   int width = x;
-
-   STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1);
-   a->out = (unsigned char *) _m3dstbi__malloc_mad3(x, y, output_bytes, 0);
-   if (!a->out) return _m3dstbi__err("outofmem", "Out of memory");
-
-   if (!_m3dstbi__mad3sizes_valid(img_n, x, depth, 7)) return _m3dstbi__err("too large", "Corrupt PNG");
-   img_width_bytes = (((img_n * x * depth) + 7) >> 3);
-   img_len = (img_width_bytes + 1) * y;
-   if (s->img_x == x && s->img_y == y) {
-      if (raw_len != img_len) return _m3dstbi__err("not enough pixels","Corrupt PNG");
-   } else {
-      if (raw_len < img_len) return _m3dstbi__err("not enough pixels","Corrupt PNG");
-   }
-
-   for (j=0; j < y; ++j) {
-      unsigned char *cur = a->out + stride*j;
-      unsigned char *prior = cur - stride;
-      int filter = *raw++;
-
-      if (filter > 4)
-         return _m3dstbi__err("invalid filter","Corrupt PNG");
-
-      if (depth < 8) {
-         STBI_ASSERT(img_width_bytes <= x);
-         cur += x*out_n - img_width_bytes;
-         filter_bytes = 1;
-         width = img_width_bytes;
-      }
-      prior = cur - stride;
-
-      if (j == 0) filter = first_row_filter[filter];
-
-      for (k=0; k < filter_bytes; ++k) {
-         switch (filter) {
-            case STBI__F_none       : cur[k] = raw[k]; break;
-            case STBI__F_sub        : cur[k] = raw[k]; break;
-            case STBI__F_up         : cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break;
-            case STBI__F_avg        : cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); break;
-            case STBI__F_paeth      : cur[k] = STBI__BYTECAST(raw[k] + _m3dstbi__paeth(0,prior[k],0)); break;
-            case STBI__F_avg_first  : cur[k] = raw[k]; break;
-            case STBI__F_paeth_first: cur[k] = raw[k]; break;
-         }
-      }
-
-      if (depth == 8) {
-         if (img_n != out_n)
-            cur[img_n] = 255;
-         raw += img_n;
-         cur += out_n;
-         prior += out_n;
-      } else if (depth == 16) {
-         if (img_n != out_n) {
-            cur[filter_bytes]   = 255;
-            cur[filter_bytes+1] = 255;
-         }
-         raw += filter_bytes;
-         cur += output_bytes;
-         prior += output_bytes;
-      } else {
-         raw += 1;
-         cur += 1;
-         prior += 1;
-      }
-
-      if (depth < 8 || img_n == out_n) {
-         int nk = (width - 1)*filter_bytes;
-         #define STBI__CASE(f) \
-             case f:     \
-                for (k=0; k < nk; ++k)
-         switch (filter) {
-            case STBI__F_none:         memcpy(cur, raw, nk); break;
-            STBI__CASE(STBI__F_sub)          { cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); } break;
-            STBI__CASE(STBI__F_up)           { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break;
-            STBI__CASE(STBI__F_avg)          { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); } break;
-            STBI__CASE(STBI__F_paeth)        { cur[k] = STBI__BYTECAST(raw[k] + _m3dstbi__paeth(cur[k-filter_bytes],prior[k],prior[k-filter_bytes])); } break;
-            STBI__CASE(STBI__F_avg_first)    { cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); } break;
-            STBI__CASE(STBI__F_paeth_first)  { cur[k] = STBI__BYTECAST(raw[k] + _m3dstbi__paeth(cur[k-filter_bytes],0,0)); } break;
-         }
-         #undef STBI__CASE
-         raw += nk;
-      } else {
-         STBI_ASSERT(img_n+1 == out_n);
-         #define STBI__CASE(f) \
-             case f:     \
-                for (i=x-1; i >= 1; --i, cur[filter_bytes]=255,raw+=filter_bytes,cur+=output_bytes,prior+=output_bytes) \
-                   for (k=0; k < filter_bytes; ++k)
-         switch (filter) {
-            STBI__CASE(STBI__F_none)         { cur[k] = raw[k]; } break;
-            STBI__CASE(STBI__F_sub)          { cur[k] = STBI__BYTECAST(raw[k] + cur[k- output_bytes]); } break;
-            STBI__CASE(STBI__F_up)           { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break;
-            STBI__CASE(STBI__F_avg)          { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k- output_bytes])>>1)); } break;
-            STBI__CASE(STBI__F_paeth)        { cur[k] = STBI__BYTECAST(raw[k] + _m3dstbi__paeth(cur[k- output_bytes],prior[k],prior[k- output_bytes])); } break;
-            STBI__CASE(STBI__F_avg_first)    { cur[k] = STBI__BYTECAST(raw[k] + (cur[k- output_bytes] >> 1)); } break;
-            STBI__CASE(STBI__F_paeth_first)  { cur[k] = STBI__BYTECAST(raw[k] + _m3dstbi__paeth(cur[k- output_bytes],0,0)); } break;
-         }
-         #undef STBI__CASE
-
-         if (depth == 16) {
-            cur = a->out + stride*j;
-            for (i=0; i < x; ++i,cur+=output_bytes) {
-               cur[filter_bytes+1] = 255;
-            }
-         }
-      }
-   }
-
-   if (depth < 8) {
-      for (j=0; j < y; ++j) {
-         unsigned char *cur = a->out + stride*j;
-         unsigned char *in  = a->out + stride*j + x*out_n - img_width_bytes;
-         unsigned char scale = (color == 0) ? _m3dstbi__depth_scale_table[depth] : 1;
-
-         if (depth == 4) {
-            for (k=x*img_n; k >= 2; k-=2, ++in) {
-               *cur++ = scale * ((*in >> 4)       );
-               *cur++ = scale * ((*in     ) & 0x0f);
-            }
-            if (k > 0) *cur++ = scale * ((*in >> 4)       );
-         } else if (depth == 2) {
-            for (k=x*img_n; k >= 4; k-=4, ++in) {
-               *cur++ = scale * ((*in >> 6)       );
-               *cur++ = scale * ((*in >> 4) & 0x03);
-               *cur++ = scale * ((*in >> 2) & 0x03);
-               *cur++ = scale * ((*in     ) & 0x03);
-            }
-            if (k > 0) *cur++ = scale * ((*in >> 6)       );
-            if (k > 1) *cur++ = scale * ((*in >> 4) & 0x03);
-            if (k > 2) *cur++ = scale * ((*in >> 2) & 0x03);
-         } else if (depth == 1) {
-            for (k=x*img_n; k >= 8; k-=8, ++in) {
-               *cur++ = scale * ((*in >> 7)       );
-               *cur++ = scale * ((*in >> 6) & 0x01);
-               *cur++ = scale * ((*in >> 5) & 0x01);
-               *cur++ = scale * ((*in >> 4) & 0x01);
-               *cur++ = scale * ((*in >> 3) & 0x01);
-               *cur++ = scale * ((*in >> 2) & 0x01);
-               *cur++ = scale * ((*in >> 1) & 0x01);
-               *cur++ = scale * ((*in     ) & 0x01);
-            }
-            if (k > 0) *cur++ = scale * ((*in >> 7)       );
-            if (k > 1) *cur++ = scale * ((*in >> 6) & 0x01);
-            if (k > 2) *cur++ = scale * ((*in >> 5) & 0x01);
-            if (k > 3) *cur++ = scale * ((*in >> 4) & 0x01);
-            if (k > 4) *cur++ = scale * ((*in >> 3) & 0x01);
-            if (k > 5) *cur++ = scale * ((*in >> 2) & 0x01);
-            if (k > 6) *cur++ = scale * ((*in >> 1) & 0x01);
-         }
-         if (img_n != out_n) {
-            int q;
-            cur = a->out + stride*j;
-            if (img_n == 1) {
-               for (q=x-1; q >= 0; --q) {
-                  cur[q*2+1] = 255;
-                  cur[q*2+0] = cur[q];
-               }
-            } else {
-               STBI_ASSERT(img_n == 3);
-               for (q=x-1; q >= 0; --q) {
-                  cur[q*4+3] = 255;
-                  cur[q*4+2] = cur[q*3+2];
-                  cur[q*4+1] = cur[q*3+1];
-                  cur[q*4+0] = cur[q*3+0];
-               }
-            }
-         }
-      }
-   } else if (depth == 16) {
-      unsigned char *cur = a->out;
-      _m3dstbi__uint16 *cur16 = (_m3dstbi__uint16*)cur;
-
-      for(i=0; i < x*y*out_n; ++i,cur16++,cur+=2) {
-         *cur16 = (cur[0] << 8) | cur[1];
-      }
-   }
-
-   return 1;
-}
-
-static int _m3dstbi__create_png_image(_m3dstbi__png *a, unsigned char *image_data, _m3dstbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced)
-{
-   int bytes = (depth == 16 ? 2 : 1);
-   int out_bytes = out_n * bytes;
-   unsigned char *final;
-   int p;
-   if (!interlaced)
-      return _m3dstbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color);
-
-   final = (unsigned char *) _m3dstbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0);
-   for (p=0; p < 7; ++p) {
-      int xorig[] = { 0,4,0,2,0,1,0 };
-      int yorig[] = { 0,0,4,0,2,0,1 };
-      int xspc[]  = { 8,8,4,4,2,2,1 };
-      int yspc[]  = { 8,8,8,4,4,2,2 };
-      int i,j,x,y;
-      x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p];
-      y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p];
-      if (x && y) {
-         _m3dstbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y;
-         if (!_m3dstbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) {
-            STBI_FREE(final);
-            return 0;
-         }
-         for (j=0; j < y; ++j) {
-            for (i=0; i < x; ++i) {
-               int out_y = j*yspc[p]+yorig[p];
-               int out_x = i*xspc[p]+xorig[p];
-               memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes,
-                      a->out + (j*x+i)*out_bytes, out_bytes);
-            }
-         }
-         STBI_FREE(a->out);
-         image_data += img_len;
-         image_data_len -= img_len;
-      }
-   }
-   a->out = final;
-
-   return 1;
-}
-
-static int _m3dstbi__compute_transparency(_m3dstbi__png *z, unsigned char tc[3], int out_n)
-{
-   _m3dstbi__context *s = z->s;
-   _m3dstbi__uint32 i, pixel_count = s->img_x * s->img_y;
-   unsigned char *p = z->out;
-
-   STBI_ASSERT(out_n == 2 || out_n == 4);
-
-   if (out_n == 2) {
-      for (i=0; i < pixel_count; ++i) {
-         p[1] = (p[0] == tc[0] ? 0 : 255);
-         p += 2;
-      }
-   } else {
-      for (i=0; i < pixel_count; ++i) {
-         if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
-            p[3] = 0;
-         p += 4;
-      }
-   }
-   return 1;
-}
-
-static int _m3dstbi__compute_transparency16(_m3dstbi__png *z, _m3dstbi__uint16 tc[3], int out_n)
-{
-   _m3dstbi__context *s = z->s;
-   _m3dstbi__uint32 i, pixel_count = s->img_x * s->img_y;
-   _m3dstbi__uint16 *p = (_m3dstbi__uint16*) z->out;
-
-   STBI_ASSERT(out_n == 2 || out_n == 4);
-
-   if (out_n == 2) {
-      for (i = 0; i < pixel_count; ++i) {
-         p[1] = (p[0] == tc[0] ? 0 : 65535);
-         p += 2;
-      }
-   } else {
-      for (i = 0; i < pixel_count; ++i) {
-         if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
-            p[3] = 0;
-         p += 4;
-      }
-   }
-   return 1;
-}
-
-static int _m3dstbi__expand_png_palette(_m3dstbi__png *a, unsigned char *palette, int len, int pal_img_n)
-{
-   _m3dstbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y;
-   unsigned char *p, *temp_out, *orig = a->out;
-
-   p = (unsigned char *) _m3dstbi__malloc_mad2(pixel_count, pal_img_n, 0);
-   if (p == NULL) return _m3dstbi__err("outofmem", "Out of memory");
-
-   temp_out = p;
-
-   if (pal_img_n == 3) {
-      for (i=0; i < pixel_count; ++i) {
-         int n = orig[i]*4;
-         p[0] = palette[n  ];
-         p[1] = palette[n+1];
-         p[2] = palette[n+2];
-         p += 3;
-      }
-   } else {
-      for (i=0; i < pixel_count; ++i) {
-         int n = orig[i]*4;
-         p[0] = palette[n  ];
-         p[1] = palette[n+1];
-         p[2] = palette[n+2];
-         p[3] = palette[n+3];
-         p += 4;
-      }
-   }
-   STBI_FREE(a->out);
-   a->out = temp_out;
-
-   STBI_NOTUSED(len);
-
-   return 1;
-}
-
-#define STBI__PNG_TYPE(a,b,c,d)  (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d))
-
-static int _m3dstbi__parse_png_file(_m3dstbi__png *z, int scan, int req_comp)
-{
-   unsigned char palette[1024], pal_img_n=0;
-   unsigned char has_trans=0, tc[3];
-   _m3dstbi__uint16 tc16[3];
-   _m3dstbi__uint32 ioff=0, idata_limit=0, i, pal_len=0;
-   int first=1,k,interlace=0, color=0;
-   _m3dstbi__context *s = z->s;
-
-   z->expanded = NULL;
-   z->idata = NULL;
-   z->out = NULL;
-
-   if (!_m3dstbi__check_png_header(s)) return 0;
-
-   if (scan == STBI__SCAN_type) return 1;
-
-   for (;;) {
-      _m3dstbi__pngchunk c = _m3dstbi__get_chunk_header(s);
-      switch (c.type) {
-         case STBI__PNG_TYPE('C','g','B','I'):
-            _m3dstbi__skip(s, c.length);
-            break;
-         case STBI__PNG_TYPE('I','H','D','R'): {
-            int comp,filter;
-            if (!first) return _m3dstbi__err("multiple IHDR","Corrupt PNG");
-            first = 0;
-            if (c.length != 13) return _m3dstbi__err("bad IHDR len","Corrupt PNG");
-            s->img_x = _m3dstbi__get32be(s); if (s->img_x > (1 << 24)) return _m3dstbi__err("too large","Very large image (corrupt?)");
-            s->img_y = _m3dstbi__get32be(s); if (s->img_y > (1 << 24)) return _m3dstbi__err("too large","Very large image (corrupt?)");
-            z->depth = _m3dstbi__get8(s);  if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16)  return _m3dstbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only");
-            color = _m3dstbi__get8(s);  if (color > 6)         return _m3dstbi__err("bad ctype","Corrupt PNG");
-            if (color == 3 && z->depth == 16)                  return _m3dstbi__err("bad ctype","Corrupt PNG");
-            if (color == 3) pal_img_n = 3; else if (color & 1) return _m3dstbi__err("bad ctype","Corrupt PNG");
-            comp  = _m3dstbi__get8(s);  if (comp) return _m3dstbi__err("bad comp method","Corrupt PNG");
-            filter= _m3dstbi__get8(s);  if (filter) return _m3dstbi__err("bad filter method","Corrupt PNG");
-            interlace = _m3dstbi__get8(s); if (interlace>1) return _m3dstbi__err("bad interlace method","Corrupt PNG");
-            if (!s->img_x || !s->img_y) return _m3dstbi__err("0-pixel image","Corrupt PNG");
-            if (!pal_img_n) {
-               s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0);
-               if ((1 << 30) / s->img_x / s->img_n < s->img_y) return _m3dstbi__err("too large", "Image too large to decode");
-               if (scan == STBI__SCAN_header) return 1;
-            } else {
-               s->img_n = 1;
-               if ((1 << 30) / s->img_x / 4 < s->img_y) return _m3dstbi__err("too large","Corrupt PNG");
-            }
-            break;
-         }
-
-         case STBI__PNG_TYPE('P','L','T','E'):  {
-            if (first) return _m3dstbi__err("first not IHDR", "Corrupt PNG");
-            if (c.length > 256*3) return _m3dstbi__err("invalid PLTE","Corrupt PNG");
-            pal_len = c.length / 3;
-            if (pal_len * 3 != c.length) return _m3dstbi__err("invalid PLTE","Corrupt PNG");
-            for (i=0; i < pal_len; ++i) {
-               palette[i*4+0] = _m3dstbi__get8(s);
-               palette[i*4+1] = _m3dstbi__get8(s);
-               palette[i*4+2] = _m3dstbi__get8(s);
-               palette[i*4+3] = 255;
-            }
-            break;
-         }
-
-         case STBI__PNG_TYPE('t','R','N','S'): {
-            if (first) return _m3dstbi__err("first not IHDR", "Corrupt PNG");
-            if (z->idata) return _m3dstbi__err("tRNS after IDAT","Corrupt PNG");
-            if (pal_img_n) {
-               if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; }
-               if (pal_len == 0) return _m3dstbi__err("tRNS before PLTE","Corrupt PNG");
-               if (c.length > pal_len) return _m3dstbi__err("bad tRNS len","Corrupt PNG");
-               pal_img_n = 4;
-               for (i=0; i < c.length; ++i)
-                  palette[i*4+3] = _m3dstbi__get8(s);
-            } else {
-               if (!(s->img_n & 1)) return _m3dstbi__err("tRNS with alpha","Corrupt PNG");
-               if (c.length != (_m3dstbi__uint32) s->img_n*2) return _m3dstbi__err("bad tRNS len","Corrupt PNG");
-               has_trans = 1;
-               if (z->depth == 16) {
-                  for (k = 0; k < s->img_n; ++k) tc16[k] = (_m3dstbi__uint16)_m3dstbi__get16be(s);
-               } else {
-                  for (k = 0; k < s->img_n; ++k) tc[k] = (unsigned char)(_m3dstbi__get16be(s) & 255) * _m3dstbi__depth_scale_table[z->depth];
-               }
-            }
-            break;
-         }
-
-         case STBI__PNG_TYPE('I','D','A','T'): {
-            if (first) return _m3dstbi__err("first not IHDR", "Corrupt PNG");
-            if (pal_img_n && !pal_len) return _m3dstbi__err("no PLTE","Corrupt PNG");
-            if (scan == STBI__SCAN_header) { s->img_n = pal_img_n; return 1; }
-            if ((int)(ioff + c.length) < (int)ioff) return 0;
-            if (ioff + c.length > idata_limit) {
-               _m3dstbi__uint32 idata_limit_old = idata_limit;
-               unsigned char *p;
-               if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096;
-               while (ioff + c.length > idata_limit)
-                  idata_limit *= 2;
-               STBI_NOTUSED(idata_limit_old);
-               p = (unsigned char *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return _m3dstbi__err("outofmem", "Out of memory");
-               z->idata = p;
-            }
-            if (!_m3dstbi__getn(s, z->idata+ioff,c.length)) return _m3dstbi__err("outofdata","Corrupt PNG");
-            ioff += c.length;
-            break;
-         }
-
-         case STBI__PNG_TYPE('I','E','N','D'): {
-            _m3dstbi__uint32 raw_len, bpl;
-            if (first) return _m3dstbi__err("first not IHDR", "Corrupt PNG");
-            if (scan != STBI__SCAN_load) return 1;
-            if (z->idata == NULL) return _m3dstbi__err("no IDAT","Corrupt PNG");
-            bpl = (s->img_x * z->depth + 7) / 8;
-            raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */;
-            z->expanded = (unsigned char *) _m3dstbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, 1);
-            if (z->expanded == NULL) return 0;
-            STBI_FREE(z->idata); z->idata = NULL;
-            if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans)
-               s->img_out_n = s->img_n+1;
-            else
-               s->img_out_n = s->img_n;
-            if (!_m3dstbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0;
-            if (has_trans) {
-               if (z->depth == 16) {
-                  if (!_m3dstbi__compute_transparency16(z, tc16, s->img_out_n)) return 0;
-               } else {
-                  if (!_m3dstbi__compute_transparency(z, tc, s->img_out_n)) return 0;
-               }
-            }
-            if (pal_img_n) {
-               s->img_n = pal_img_n;
-               s->img_out_n = pal_img_n;
-               if (req_comp >= 3) s->img_out_n = req_comp;
-               if (!_m3dstbi__expand_png_palette(z, palette, pal_len, s->img_out_n))
-                  return 0;
-            } else if (has_trans) {
-               ++s->img_n;
-            }
-            STBI_FREE(z->expanded); z->expanded = NULL;
-            return 1;
-         }
-
-         default:
-            if (first) return _m3dstbi__err("first not IHDR", "Corrupt PNG");
-            if ((c.type & (1 << 29)) == 0) {
-               return _m3dstbi__err("invalid_chunk", "PNG not supported: unknown PNG chunk type");
-            }
-            _m3dstbi__skip(s, c.length);
-            break;
-      }
-      _m3dstbi__get32be(s);
-   }
-}
-
-static void *_m3dstbi__do_png(_m3dstbi__png *p, int *x, int *y, int *n, int req_comp, _m3dstbi__result_info *ri)
-{
-   void *result=NULL;
-   if (req_comp < 0 || req_comp > 4) { _m3dstbi__err("bad req_comp", "Internal error"); return NULL; }
-   if (_m3dstbi__parse_png_file(p, STBI__SCAN_load, req_comp)) {
-      if (p->depth < 8)
-         ri->bits_per_channel = 8;
-      else
-         ri->bits_per_channel = p->depth;
-      result = p->out;
-      p->out = NULL;
-      if (req_comp && req_comp != p->s->img_out_n) {
-         if (ri->bits_per_channel == 8)
-            result = _m3dstbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
-         else
-            result = _m3dstbi__convert_format16((_m3dstbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
-         p->s->img_out_n = req_comp;
-         if (result == NULL) return result;
-      }
-      *x = p->s->img_x;
-      *y = p->s->img_y;
-      if (n) *n = p->s->img_n;
-   }
-   STBI_FREE(p->out);      p->out      = NULL;
-   STBI_FREE(p->expanded); p->expanded = NULL;
-   STBI_FREE(p->idata);    p->idata    = NULL;
-
-   return result;
-}
-
-static void *_m3dstbi__png_load(_m3dstbi__context *s, int *x, int *y, int *comp, int req_comp, _m3dstbi__result_info *ri)
-{
-   _m3dstbi__png p;
-   p.s = s;
-   return _m3dstbi__do_png(&p, x,y,comp,req_comp, ri);
-}
-#define stbi__context _m3dstbi__context
-#define stbi__result_info _m3dstbi__result_info
-#define stbi__png_load _m3dstbi__png_load
-#define stbi_zlib_decode_malloc_guesssize_headerflag _m3dstbi_zlib_decode_malloc_guesssize_headerflag
-#endif
-
-#if defined(M3D_EXPORTER) && !defined(INCLUDE_STB_IMAGE_WRITE_H)
-/* zlib_compressor from
-
-   stb_image_write - v1.13 - public domain - http://nothings.org/stb/stb_image_write.h
-*/
-typedef unsigned char _m3dstbiw__uc;
-typedef unsigned short _m3dstbiw__us;
-
-typedef uint16_t _m3dstbiw__uint16;
-typedef int16_t  _m3dstbiw__int16;
-typedef uint32_t _m3dstbiw__uint32;
-typedef int32_t  _m3dstbiw__int32;
-
-#define STBIW_MALLOC(s)     M3D_MALLOC(s)
-#define STBIW_REALLOC(p,ns) M3D_REALLOC(p,ns)
-#define STBIW_REALLOC_SIZED(p,oldsz,newsz) STBIW_REALLOC(p,newsz)
-#define STBIW_FREE          M3D_FREE
-#define STBIW_MEMMOVE       memmove
-#define STBIW_UCHAR         (uint8_t)
-#define STBIW_ASSERT(x)
-#define _m3dstbiw___sbraw(a)     ((int *) (a) - 2)
-#define _m3dstbiw___sbm(a)       _m3dstbiw___sbraw(a)[0]
-#define _m3dstbiw___sbn(a)       _m3dstbiw___sbraw(a)[1]
-
-#define _m3dstbiw___sbneedgrow(a,n)  ((a)==0 || _m3dstbiw___sbn(a)+n >= _m3dstbiw___sbm(a))
-#define _m3dstbiw___sbmaybegrow(a,n) (_m3dstbiw___sbneedgrow(a,(n)) ? _m3dstbiw___sbgrow(a,n) : 0)
-#define _m3dstbiw___sbgrow(a,n)  _m3dstbiw___sbgrowf((void **) &(a), (n), sizeof(*(a)))
-
-#define _m3dstbiw___sbpush(a, v)      (_m3dstbiw___sbmaybegrow(a,1), (a)[_m3dstbiw___sbn(a)++] = (v))
-#define _m3dstbiw___sbcount(a)        ((a) ? _m3dstbiw___sbn(a) : 0)
-#define _m3dstbiw___sbfree(a)         ((a) ? STBIW_FREE(_m3dstbiw___sbraw(a)),0 : 0)
-
-static void *_m3dstbiw___sbgrowf(void **arr, int increment, int itemsize)
-{
-   int m = *arr ? 2*_m3dstbiw___sbm(*arr)+increment : increment+1;
-   void *p = STBIW_REALLOC_SIZED(*arr ? _m3dstbiw___sbraw(*arr) : 0, *arr ? (_m3dstbiw___sbm(*arr)*itemsize + sizeof(int)*2) : 0, itemsize * m + sizeof(int)*2);
-   STBIW_ASSERT(p);
-   if (p) {
-      if (!*arr) ((int *) p)[1] = 0;
-      *arr = (void *) ((int *) p + 2);
-      _m3dstbiw___sbm(*arr) = m;
-   }
-   return *arr;
-}
-
-static unsigned char *_m3dstbiw___zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount)
-{
-   while (*bitcount >= 8) {
-      _m3dstbiw___sbpush(data, STBIW_UCHAR(*bitbuffer));
-      *bitbuffer >>= 8;
-      *bitcount -= 8;
-   }
-   return data;
-}
-
-static int _m3dstbiw___zlib_bitrev(int code, int codebits)
-{
-   int res=0;
-   while (codebits--) {
-      res = (res << 1) | (code & 1);
-      code >>= 1;
-   }
-   return res;
-}
-
-static unsigned int _m3dstbiw___zlib_countm(unsigned char *a, unsigned char *b, int limit)
-{
-   int i;
-   for (i=0; i < limit && i < 258; ++i)
-      if (a[i] != b[i]) break;
-   return i;
-}
-
-static unsigned int _m3dstbiw___zhash(unsigned char *data)
-{
-   _m3dstbiw__uint32 hash = data[0] + (data[1] << 8) + (data[2] << 16);
-   hash ^= hash << 3;
-   hash += hash >> 5;
-   hash ^= hash << 4;
-   hash += hash >> 17;
-   hash ^= hash << 25;
-   hash += hash >> 6;
-   return hash;
-}
-
-#define _m3dstbiw___zlib_flush() (out = _m3dstbiw___zlib_flushf(out, &bitbuf, &bitcount))
-#define _m3dstbiw___zlib_add(code,codebits) \
-      (bitbuf |= (code) << bitcount, bitcount += (codebits), _m3dstbiw___zlib_flush())
-#define _m3dstbiw___zlib_huffa(b,c)  _m3dstbiw___zlib_add(_m3dstbiw___zlib_bitrev(b,c),c)
-#define _m3dstbiw___zlib_huff1(n)  _m3dstbiw___zlib_huffa(0x30 + (n), 8)
-#define _m3dstbiw___zlib_huff2(n)  _m3dstbiw___zlib_huffa(0x190 + (n)-144, 9)
-#define _m3dstbiw___zlib_huff3(n)  _m3dstbiw___zlib_huffa(0 + (n)-256,7)
-#define _m3dstbiw___zlib_huff4(n)  _m3dstbiw___zlib_huffa(0xc0 + (n)-280,8)
-#define _m3dstbiw___zlib_huff(n)  ((n) <= 143 ? _m3dstbiw___zlib_huff1(n) : (n) <= 255 ? _m3dstbiw___zlib_huff2(n) : (n) <= 279 ? _m3dstbiw___zlib_huff3(n) : _m3dstbiw___zlib_huff4(n))
-#define _m3dstbiw___zlib_huffb(n) ((n) <= 143 ? _m3dstbiw___zlib_huff1(n) : _m3dstbiw___zlib_huff2(n))
-
-#define _m3dstbiw___ZHASH   16384
-
-unsigned char * _m3dstbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality)
-{
-   static unsigned short lengthc[] = { 3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258, 259 };
-   static unsigned char  lengtheb[]= { 0,0,0,0,0,0,0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4,  4,  5,  5,  5,  5,  0 };
-   static unsigned short distc[]   = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577, 32768 };
-   static unsigned char  disteb[]  = { 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13 };
-   unsigned int bitbuf=0;
-   int i,j, bitcount=0;
-   unsigned char *out = NULL;
-   unsigned char ***hash_table = (unsigned char***) STBIW_MALLOC(_m3dstbiw___ZHASH * sizeof(char**));
-   if (hash_table == NULL)
-      return NULL;
-   if (quality < 5) quality = 5;
-
-   _m3dstbiw___sbpush(out, 0x78);
-   _m3dstbiw___sbpush(out, 0x5e);
-   _m3dstbiw___zlib_add(1,1);
-   _m3dstbiw___zlib_add(1,2);
-
-   for (i=0; i < _m3dstbiw___ZHASH; ++i)
-      hash_table[i] = NULL;
-
-   i=0;
-   while (i < data_len-3) {
-      int h = _m3dstbiw___zhash(data+i)&(_m3dstbiw___ZHASH-1), best=3;
-      unsigned char *bestloc = 0;
-      unsigned char **hlist = hash_table[h];
-      int n = _m3dstbiw___sbcount(hlist);
-      for (j=0; j < n; ++j) {
-         if (hlist[j]-data > i-32768) {
-            int d = _m3dstbiw___zlib_countm(hlist[j], data+i, data_len-i);
-            if (d >= best) best=d,bestloc=hlist[j];
-         }
-      }
-      if (hash_table[h] && _m3dstbiw___sbn(hash_table[h]) == 2*quality) {
-         STBIW_MEMMOVE(hash_table[h], hash_table[h]+quality, sizeof(hash_table[h][0])*quality);
-         _m3dstbiw___sbn(hash_table[h]) = quality;
-      }
-      _m3dstbiw___sbpush(hash_table[h],data+i);
-
-      if (bestloc) {
-         h = _m3dstbiw___zhash(data+i+1)&(_m3dstbiw___ZHASH-1);
-         hlist = hash_table[h];
-         n = _m3dstbiw___sbcount(hlist);
-         for (j=0; j < n; ++j) {
-            if (hlist[j]-data > i-32767) {
-               int e = _m3dstbiw___zlib_countm(hlist[j], data+i+1, data_len-i-1);
-               if (e > best) {
-                  bestloc = NULL;
-                  break;
-               }
-            }
-         }
-      }
-
-      if (bestloc) {
-         int d = (int) (data+i - bestloc);
-         STBIW_ASSERT(d <= 32767 && best <= 258);
-         for (j=0; best > lengthc[j+1]-1; ++j);
-         _m3dstbiw___zlib_huff(j+257);
-         if (lengtheb[j]) _m3dstbiw___zlib_add(best - lengthc[j], lengtheb[j]);
-         for (j=0; d > distc[j+1]-1; ++j);
-         _m3dstbiw___zlib_add(_m3dstbiw___zlib_bitrev(j,5),5);
-         if (disteb[j]) _m3dstbiw___zlib_add(d - distc[j], disteb[j]);
-         i += best;
-      } else {
-         _m3dstbiw___zlib_huffb(data[i]);
-         ++i;
-      }
-   }
-   for (;i < data_len; ++i)
-      _m3dstbiw___zlib_huffb(data[i]);
-   _m3dstbiw___zlib_huff(256);
-   while (bitcount)
-      _m3dstbiw___zlib_add(0,1);
-
-   for (i=0; i < _m3dstbiw___ZHASH; ++i)
-      (void) _m3dstbiw___sbfree(hash_table[i]);
-   STBIW_FREE(hash_table);
-
-   {
-      unsigned int s1=1, s2=0;
-      int blocklen = (int) (data_len % 5552);
-      j=0;
-      while (j < data_len) {
-         for (i=0; i < blocklen; ++i) s1 += data[j+i], s2 += s1;
-         s1 %= 65521, s2 %= 65521;
-         j += blocklen;
-         blocklen = 5552;
-      }
-      _m3dstbiw___sbpush(out, STBIW_UCHAR(s2 >> 8));
-      _m3dstbiw___sbpush(out, STBIW_UCHAR(s2));
-      _m3dstbiw___sbpush(out, STBIW_UCHAR(s1 >> 8));
-      _m3dstbiw___sbpush(out, STBIW_UCHAR(s1));
-   }
-   *out_len = _m3dstbiw___sbn(out);
-   STBIW_MEMMOVE(_m3dstbiw___sbraw(out), out, *out_len);
-   return (unsigned char *) _m3dstbiw___sbraw(out);
-}
-#define stbi_zlib_compress _m3dstbi_zlib_compress
-#else
-unsigned char * _m3dstbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality);
-#endif
-
-#define M3D_CHUNKMAGIC(m, a,b,c,d) ((m)[0]==(a) && (m)[1]==(b) && (m)[2]==(c) && (m)[3]==(d))
-
-#ifdef M3D_ASCII
-#include <stdio.h>          /* get sprintf */
-#include <locale.h>         /* sprintf and strtod cares about number locale */
-#endif
-#ifdef M3D_PROFILING
-#include <sys/time.h>
-#endif
-
-#if !defined(M3D_NOIMPORTER) && defined(M3D_ASCII)
-/* helper functions for the ASCII parser */
-static char *_m3d_findarg(char *s) {
-    while(s && *s && *s != ' ' && *s != '\t' && *s != '\r' && *s != '\n') s++;
-    while(s && *s && (*s == ' ' || *s == '\t')) s++;
-    return s;
-}
-static char *_m3d_findnl(char *s) {
-    while(s && *s && *s != '\r' && *s != '\n') s++;
-    if(*s == '\r') s++;
-    if(*s == '\n') s++;
-    return s;
-}
-static char *_m3d_gethex(char *s, uint32_t *ret)
-{
-    if(*s == '#') s++;
-    *ret = 0;
-    for(; *s; s++) {
-        if(*s >= '0' && *s <= '9') {      *ret <<= 4; *ret += (uint32_t)(*s-'0'); }
-        else if(*s >= 'a' && *s <= 'f') { *ret <<= 4; *ret += (uint32_t)(*s-'a'+10); }
-        else if(*s >= 'A' && *s <= 'F') { *ret <<= 4; *ret += (uint32_t)(*s-'A'+10); }
-        else break;
-    }
-    return _m3d_findarg(s);
-}
-static char *_m3d_getint(char *s, uint32_t *ret)
-{
-    char *e = s;
-    if(!s || !*s || *s == '\r' || *s == '\n') return s;
-    for(; *e >= '0' && *e <= '9'; e++);
-    *ret = atoi(s);
-    return e;
-}
-static char *_m3d_getfloat(char *s, M3D_FLOAT *ret)
-{
-    char *e = s;
-    if(!s || !*s || *s == '\r' || *s == '\n') return s;
-    for(; *e == '-' || *e == '+' || *e == '.' || (*e >= '0' && *e <= '9') || *e == 'e' || *e == 'E'; e++);
-    *ret = (M3D_FLOAT)strtod(s, NULL);
-    return _m3d_findarg(e);
-}
-#endif
-#if !defined(M3D_NODUP) && (!defined(M3D_NOIMPORTER) || defined(M3D_ASCII) || defined(M3D_EXPORTER))
-/* helper function to create safe strings */
-char *_m3d_safestr(char *in, int morelines)
-{
-    char *out, *o, *i = in;
-    int l;
-    if(!in || !*in) {
-        out = (char*)M3D_MALLOC(1);
-        if(!out) return NULL;
-        out[0] =0;
-    } else {
-        for(o = in, l = 0; *o && ((morelines & 1) || (*o != '\r' && *o != '\n')) && l < 256; o++, l++);
-        out = o = (char*)M3D_MALLOC(l+1);
-        if(!out) return NULL;
-        while(*i == ' ' || *i == '\t' || *i == '\r' || (morelines && *i == '\n')) i++;
-        for(; *i && (morelines || (*i != '\r' && *i != '\n')); i++) {
-            if(*i == '\r') continue;
-            if(*i == '\n') {
-                if(morelines >= 3 && o > out && *(o-1) == '\n') break;
-                if(i > in && *(i-1) == '\n') continue;
-                if(morelines & 1) {
-                    if(morelines == 1) *o++ = '\r';
-                    *o++ = '\n';
-                } else
-                    break;
-            } else
-            if(*i == ' ' || *i == '\t') {
-                *o++ = morelines? ' ' : '_';
-            } else
-                *o++ = !morelines && (*i == '/' || *i == '\\') ? '_' : *i;
-        }
-        for(; o > out && (*(o-1) == ' ' || *(o-1) == '\t' || *(o-1) == '\r' || *(o-1) == '\n'); o--);
-        *o = 0;
-        out = (char*)M3D_REALLOC(out, (uintptr_t)o - (uintptr_t)out + 1);
-    }
-    return out;
-}
-#endif
-#ifndef M3D_NOIMPORTER
-/* helper function to load and decode/generate a texture */
-M3D_INDEX _m3d_gettx(m3d_t *model, m3dread_t readfilecb, m3dfree_t freecb, char *fn)
-{
-    unsigned int i, len = 0;
-    unsigned char *buff = NULL;
-    char *fn2;
-#ifdef STBI__PNG_TYPE
-    unsigned int w, h;
-    stbi__context s;
-    stbi__result_info ri;
-#endif
-
-    /* do we have loaded this texture already? */
-    for(i = 0; i < model->numtexture; i++)
-        if(!strcmp(fn, model->texture[i].name)) return i;
-    /* see if it's inlined in the model */
-    if(model->inlined) {
-        for(i = 0; i < model->numinlined; i++)
-            if(!strcmp(fn, model->inlined[i].name)) {
-                buff = model->inlined[i].data;
-                len = model->inlined[i].length;
-                freecb = NULL;
-                break;
-            }
-    }
-    /* try to load from external source */
-    if(!buff && readfilecb) {
-        i = (unsigned int)strlen(fn);
-        if(i < 5 || fn[i - 4] != '.') {
-            fn2 = (char*)M3D_MALLOC(i + 5);
-            if(!fn2) { model->errcode = M3D_ERR_ALLOC; return M3D_UNDEF; }
-            memcpy(fn2, fn, i);
-            memcpy(fn2+i, ".png", 5);
-            buff = (*readfilecb)(fn2, &len);
-            M3D_FREE(fn2);
-        }
-        if(!buff) {
-            buff = (*readfilecb)(fn, &len);
-            if(!buff) return M3D_UNDEF;
-        }
-    }
-    /* add to textures array */
-    i = model->numtexture++;
-    model->texture = (m3dtx_t*)M3D_REALLOC(model->texture, model->numtexture * sizeof(m3dtx_t));
-    if(!model->texture) {
-        if(buff && freecb) (*freecb)(buff);
-        model->errcode = M3D_ERR_ALLOC;
-        return M3D_UNDEF;
-    }
-    model->texture[i].name = fn;
-    model->texture[i].w = model->texture[i].h = 0; model->texture[i].d = NULL;
-    if(buff) {
-        if(buff[0] == 0x89 && buff[1] == 'P' && buff[2] == 'N' && buff[3] == 'G') {
-#ifdef STBI__PNG_TYPE
-            s.read_from_callbacks = 0;
-            s.img_buffer = s.img_buffer_original = (unsigned char *) buff;
-            s.img_buffer_end = s.img_buffer_original_end = (unsigned char *) buff+len;
-            /* don't use model->texture[i].w directly, it's a uint16_t */
-            w = h = len = 0;
-            ri.bits_per_channel = 8;
-            model->texture[i].d = (uint8_t*)stbi__png_load(&s, (int*)&w, (int*)&h, (int*)&len, 0, &ri);
-            model->texture[i].w = w;
-            model->texture[i].h = h;
-            model->texture[i].f = (uint8_t)len;
-#endif
-        } else {
-#ifdef M3D_TX_INTERP
-            if((model->errcode = M3D_TX_INTERP(fn, buff, len, &model->texture[i])) != M3D_SUCCESS) {
-                M3D_LOG("Unable to generate texture");
-                M3D_LOG(fn);
-            }
-#else
-            M3D_LOG("Unimplemented interpreter");
-            M3D_LOG(fn);
-#endif
-        }
-        if(freecb) (*freecb)(buff);
-    }
-    if(!model->texture[i].d)
-        model->errcode = M3D_ERR_UNKIMG;
-    return i;
-}
-
-/* helper function to load and generate a procedural surface */
-void _m3d_getpr(m3d_t *model, _unused m3dread_t readfilecb, _unused  m3dfree_t freecb, _unused char *fn)
-{
-#ifdef M3D_PR_INTERP
-    unsigned int i, len = 0;
-    unsigned char *buff = readfilecb ? (*readfilecb)(fn, &len) : NULL;
-
-    if(!buff && model->inlined) {
-        for(i = 0; i < model->numinlined; i++)
-            if(!strcmp(fn, model->inlined[i].name)) {
-                buff = model->inlined[i].data;
-                len = model->inlined[i].length;
-                freecb = NULL;
-                break;
-            }
-    }
-    if(!buff || !len || (model->errcode = M3D_PR_INTERP(fn, buff, len, model)) != M3D_SUCCESS) {
-        M3D_LOG("Unable to generate procedural surface");
-        M3D_LOG(fn);
-        model->errcode = M3D_ERR_UNKIMG;
-    }
-    if(freecb && buff) (*freecb)(buff);
-#else
-    (void)readfilecb;
-    (void)freecb;
-    (void)fn;
-    M3D_LOG("Unimplemented interpreter");
-    M3D_LOG(fn);
-    model->errcode = M3D_ERR_UNIMPL;
-#endif
-}
-/* helpers to read indices from data stream */
-#define M3D_GETSTR(x) do{offs=0;data=_m3d_getidx(data,model->si_s,&offs);x=offs?((char*)model->raw+16+offs):NULL;}while(0)
-_inline static unsigned char *_m3d_getidx(unsigned char *data, char type, M3D_INDEX *idx)
-{
-    switch(type) {
-        case 1: *idx = data[0] > 253 ? (int8_t)data[0] : data[0]; data++; break;
-        case 2: *idx = *((uint16_t*)data) > 65533 ? *((int16_t*)data) : *((uint16_t*)data); data += 2; break;
-        case 4: *idx = *((int32_t*)data); data += 4; break;
-    }
-    return data;
-}
-
-#ifndef M3D_NOANIMATION
-/* multiply 4 x 4 matrices. Do not use float *r[16] as argument, because some compilers misinterpret that as
- * 16 pointers each pointing to a float, but we need a single pointer to 16 floats. */
-void _m3d_mul(M3D_FLOAT *r, M3D_FLOAT *a, M3D_FLOAT *b)
-{
-    r[ 0] = b[ 0] * a[ 0] + b[ 4] * a[ 1] + b[ 8] * a[ 2] + b[12] * a[ 3];
-    r[ 1] = b[ 1] * a[ 0] + b[ 5] * a[ 1] + b[ 9] * a[ 2] + b[13] * a[ 3];
-    r[ 2] = b[ 2] * a[ 0] + b[ 6] * a[ 1] + b[10] * a[ 2] + b[14] * a[ 3];
-    r[ 3] = b[ 3] * a[ 0] + b[ 7] * a[ 1] + b[11] * a[ 2] + b[15] * a[ 3];
-    r[ 4] = b[ 0] * a[ 4] + b[ 4] * a[ 5] + b[ 8] * a[ 6] + b[12] * a[ 7];
-    r[ 5] = b[ 1] * a[ 4] + b[ 5] * a[ 5] + b[ 9] * a[ 6] + b[13] * a[ 7];
-    r[ 6] = b[ 2] * a[ 4] + b[ 6] * a[ 5] + b[10] * a[ 6] + b[14] * a[ 7];
-    r[ 7] = b[ 3] * a[ 4] + b[ 7] * a[ 5] + b[11] * a[ 6] + b[15] * a[ 7];
-    r[ 8] = b[ 0] * a[ 8] + b[ 4] * a[ 9] + b[ 8] * a[10] + b[12] * a[11];
-    r[ 9] = b[ 1] * a[ 8] + b[ 5] * a[ 9] + b[ 9] * a[10] + b[13] * a[11];
-    r[10] = b[ 2] * a[ 8] + b[ 6] * a[ 9] + b[10] * a[10] + b[14] * a[11];
-    r[11] = b[ 3] * a[ 8] + b[ 7] * a[ 9] + b[11] * a[10] + b[15] * a[11];
-    r[12] = b[ 0] * a[12] + b[ 4] * a[13] + b[ 8] * a[14] + b[12] * a[15];
-    r[13] = b[ 1] * a[12] + b[ 5] * a[13] + b[ 9] * a[14] + b[13] * a[15];
-    r[14] = b[ 2] * a[12] + b[ 6] * a[13] + b[10] * a[14] + b[14] * a[15];
-    r[15] = b[ 3] * a[12] + b[ 7] * a[13] + b[11] * a[14] + b[15] * a[15];
-}
-/* calculate 4 x 4 matrix inverse */
-void _m3d_inv(M3D_FLOAT *m)
-{
-    M3D_FLOAT r[16];
-    M3D_FLOAT det =
-          m[ 0]*m[ 5]*m[10]*m[15] - m[ 0]*m[ 5]*m[11]*m[14] + m[ 0]*m[ 6]*m[11]*m[13] - m[ 0]*m[ 6]*m[ 9]*m[15]
-        + m[ 0]*m[ 7]*m[ 9]*m[14] - m[ 0]*m[ 7]*m[10]*m[13] - m[ 1]*m[ 6]*m[11]*m[12] + m[ 1]*m[ 6]*m[ 8]*m[15]
-        - m[ 1]*m[ 7]*m[ 8]*m[14] + m[ 1]*m[ 7]*m[10]*m[12] - m[ 1]*m[ 4]*m[10]*m[15] + m[ 1]*m[ 4]*m[11]*m[14]
-        + m[ 2]*m[ 7]*m[ 8]*m[13] - m[ 2]*m[ 7]*m[ 9]*m[12] + m[ 2]*m[ 4]*m[ 9]*m[15] - m[ 2]*m[ 4]*m[11]*m[13]
-        + m[ 2]*m[ 5]*m[11]*m[12] - m[ 2]*m[ 5]*m[ 8]*m[15] - m[ 3]*m[ 4]*m[ 9]*m[14] + m[ 3]*m[ 4]*m[10]*m[13]
-        - m[ 3]*m[ 5]*m[10]*m[12] + m[ 3]*m[ 5]*m[ 8]*m[14] - m[ 3]*m[ 6]*m[ 8]*m[13] + m[ 3]*m[ 6]*m[ 9]*m[12];
-    if(det == (M3D_FLOAT)0.0 || det == (M3D_FLOAT)-0.0) det = (M3D_FLOAT)1.0; else det = (M3D_FLOAT)1.0 / det;
-    r[ 0] = det *(m[ 5]*(m[10]*m[15] - m[11]*m[14]) + m[ 6]*(m[11]*m[13] - m[ 9]*m[15]) + m[ 7]*(m[ 9]*m[14] - m[10]*m[13]));
-    r[ 1] = -det*(m[ 1]*(m[10]*m[15] - m[11]*m[14]) + m[ 2]*(m[11]*m[13] - m[ 9]*m[15]) + m[ 3]*(m[ 9]*m[14] - m[10]*m[13]));
-    r[ 2] = det *(m[ 1]*(m[ 6]*m[15] - m[ 7]*m[14]) + m[ 2]*(m[ 7]*m[13] - m[ 5]*m[15]) + m[ 3]*(m[ 5]*m[14] - m[ 6]*m[13]));
-    r[ 3] = -det*(m[ 1]*(m[ 6]*m[11] - m[ 7]*m[10]) + m[ 2]*(m[ 7]*m[ 9] - m[ 5]*m[11]) + m[ 3]*(m[ 5]*m[10] - m[ 6]*m[ 9]));
-    r[ 4] = -det*(m[ 4]*(m[10]*m[15] - m[11]*m[14]) + m[ 6]*(m[11]*m[12] - m[ 8]*m[15]) + m[ 7]*(m[ 8]*m[14] - m[10]*m[12]));
-    r[ 5] = det *(m[ 0]*(m[10]*m[15] - m[11]*m[14]) + m[ 2]*(m[11]*m[12] - m[ 8]*m[15]) + m[ 3]*(m[ 8]*m[14] - m[10]*m[12]));
-    r[ 6] = -det*(m[ 0]*(m[ 6]*m[15] - m[ 7]*m[14]) + m[ 2]*(m[ 7]*m[12] - m[ 4]*m[15]) + m[ 3]*(m[ 4]*m[14] - m[ 6]*m[12]));
-    r[ 7] = det *(m[ 0]*(m[ 6]*m[11] - m[ 7]*m[10]) + m[ 2]*(m[ 7]*m[ 8] - m[ 4]*m[11]) + m[ 3]*(m[ 4]*m[10] - m[ 6]*m[ 8]));
-    r[ 8] = det *(m[ 4]*(m[ 9]*m[15] - m[11]*m[13]) + m[ 5]*(m[11]*m[12] - m[ 8]*m[15]) + m[ 7]*(m[ 8]*m[13] - m[ 9]*m[12]));
-    r[ 9] = -det*(m[ 0]*(m[ 9]*m[15] - m[11]*m[13]) + m[ 1]*(m[11]*m[12] - m[ 8]*m[15]) + m[ 3]*(m[ 8]*m[13] - m[ 9]*m[12]));
-    r[10] = det *(m[ 0]*(m[ 5]*m[15] - m[ 7]*m[13]) + m[ 1]*(m[ 7]*m[12] - m[ 4]*m[15]) + m[ 3]*(m[ 4]*m[13] - m[ 5]*m[12]));
-    r[11] = -det*(m[ 0]*(m[ 5]*m[11] - m[ 7]*m[ 9]) + m[ 1]*(m[ 7]*m[ 8] - m[ 4]*m[11]) + m[ 3]*(m[ 4]*m[ 9] - m[ 5]*m[ 8]));
-    r[12] = -det*(m[ 4]*(m[ 9]*m[14] - m[10]*m[13]) + m[ 5]*(m[10]*m[12] - m[ 8]*m[14]) + m[ 6]*(m[ 8]*m[13] - m[ 9]*m[12]));
-    r[13] = det *(m[ 0]*(m[ 9]*m[14] - m[10]*m[13]) + m[ 1]*(m[10]*m[12] - m[ 8]*m[14]) + m[ 2]*(m[ 8]*m[13] - m[ 9]*m[12]));
-    r[14] = -det*(m[ 0]*(m[ 5]*m[14] - m[ 6]*m[13]) + m[ 1]*(m[ 6]*m[12] - m[ 4]*m[14]) + m[ 2]*(m[ 4]*m[13] - m[ 5]*m[12]));
-    r[15] = det *(m[ 0]*(m[ 5]*m[10] - m[ 6]*m[ 9]) + m[ 1]*(m[ 6]*m[ 8] - m[ 4]*m[10]) + m[ 2]*(m[ 4]*m[ 9] - m[ 5]*m[ 8]));
-    memcpy(m, &r, sizeof(r));
-}
-/* compose a coloumn major 4 x 4 matrix from vec3 position and vec4 orientation/rotation quaternion */
-void _m3d_mat(M3D_FLOAT *r, m3dv_t *p, m3dv_t *q)
-{
-    if(q->x == (M3D_FLOAT)0.0 && q->y == (M3D_FLOAT)0.0 && q->z >=(M3D_FLOAT) 0.7071065 && q->z <= (M3D_FLOAT)0.7071075 &&
-        q->w == (M3D_FLOAT)0.0) {
-        r[ 1] = r[ 2] = r[ 4] = r[ 6] = r[ 8] = r[ 9] = (M3D_FLOAT)0.0;
-        r[ 0] = r[ 5] = r[10] = (M3D_FLOAT)-1.0;
-    } else {
-        r[ 0] = 1 - 2 * (q->y * q->y + q->z * q->z); if(r[ 0]>-M3D_EPSILON && r[ 0]<M3D_EPSILON) r[ 0]=(M3D_FLOAT)0.0;
-        r[ 1] = 2 * (q->x * q->y - q->z * q->w);     if(r[ 1]>-M3D_EPSILON && r[ 1]<M3D_EPSILON) r[ 1]=(M3D_FLOAT)0.0;
-        r[ 2] = 2 * (q->x * q->z + q->y * q->w);     if(r[ 2]>-M3D_EPSILON && r[ 2]<M3D_EPSILON) r[ 2]=(M3D_FLOAT)0.0;
-        r[ 4] = 2 * (q->x * q->y + q->z * q->w);     if(r[ 4]>-M3D_EPSILON && r[ 4]<M3D_EPSILON) r[ 4]=(M3D_FLOAT)0.0;
-        r[ 5] = 1 - 2 * (q->x * q->x + q->z * q->z); if(r[ 5]>-M3D_EPSILON && r[ 5]<M3D_EPSILON) r[ 5]=(M3D_FLOAT)0.0;
-        r[ 6] = 2 * (q->y * q->z - q->x * q->w);     if(r[ 6]>-M3D_EPSILON && r[ 6]<M3D_EPSILON) r[ 6]=(M3D_FLOAT)0.0;
-        r[ 8] = 2 * (q->x * q->z - q->y * q->w);     if(r[ 8]>-M3D_EPSILON && r[ 8]<M3D_EPSILON) r[ 8]=(M3D_FLOAT)0.0;
-        r[ 9] = 2 * (q->y * q->z + q->x * q->w);     if(r[ 9]>-M3D_EPSILON && r[ 9]<M3D_EPSILON) r[ 9]=(M3D_FLOAT)0.0;
-        r[10] = 1 - 2 * (q->x * q->x + q->y * q->y); if(r[10]>-M3D_EPSILON && r[10]<M3D_EPSILON) r[10]=(M3D_FLOAT)0.0;
-    }
-    r[ 3] = p->x; r[ 7] = p->y; r[11] = p->z;
-    r[12] = 0; r[13] = 0; r[14] = 0; r[15] = 1;
-}
-#endif
-#if !defined(M3D_NOANIMATION) || !defined(M3D_NONORMALS)
-/* portable fast inverse square root calculation. returns 1/sqrt(x) */
-static M3D_FLOAT _m3d_rsq(M3D_FLOAT x)
-{
-#ifdef M3D_DOUBLE
-    return ((M3D_FLOAT)15.0/(M3D_FLOAT)8.0) + ((M3D_FLOAT)-5.0/(M3D_FLOAT)4.0)*x + ((M3D_FLOAT)3.0/(M3D_FLOAT)8.0)*x*x;
-#else
-    /* John Carmack's */
-    float x2 = x * 0.5f;
-    *((uint32_t*)&x) = (0x5f3759df - (*((uint32_t*)&x) >> 1));
-    return x * (1.5f - (x2 * x * x));
-#endif
-}
-#endif
-
-/**
- * Function to decode a Model 3D into in-memory format
- */
-m3d_t *m3d_load(unsigned char *data, m3dread_t readfilecb, m3dfree_t freecb, m3d_t *mtllib)
-{
-    unsigned char *end, *chunk, *buff, weights[8];
-    unsigned int i, j, k, l, n, am, len = 0, reclen, offs;
-    char *name, *lang;
-    float f;
-    m3d_t *model;
-    M3D_INDEX mi;
-    M3D_FLOAT w;
-    m3dcd_t *cd;
-    m3dtx_t *tx;
-    m3dh_t *h;
-    m3dm_t *m;
-    m3da_t *a;
-    m3di_t *t;
-#ifndef M3D_NONORMALS
-    char neednorm = 0;
-    m3dv_t *norm = NULL, *v0, *v1, *v2, va, vb;
-#endif
-#ifndef M3D_NOANIMATION
-    M3D_FLOAT r[16];
-#endif
-#if !defined(M3D_NOWEIGHTS) || !defined(M3D_NOANIMATION)
-    m3db_t *b;
-#endif
-#ifndef M3D_NOWEIGHTS
-    m3ds_t *sk;
-#endif
-#ifdef M3D_ASCII
-    m3ds_t s;
-    M3D_INDEX bi[M3D_BONEMAXLEVEL+1], level;
-    const char *ol;
-    char *ptr, *pe, *fn;
-#endif
-#ifdef M3D_PROFILING
-    struct timeval tv0, tv1, tvd;
-    gettimeofday(&tv0, NULL);
-#endif
-
-    if(!data || (!M3D_CHUNKMAGIC(data, '3','D','M','O')
-#ifdef M3D_ASCII
-        && !M3D_CHUNKMAGIC(data, '3','d','m','o')
-#endif
-        )) return NULL;
-    model = (m3d_t*)M3D_MALLOC(sizeof(m3d_t));
-    if(!model) {
-        M3D_LOG("Out of memory");
-        return NULL;
-    }
-    memset(model, 0, sizeof(m3d_t));
-
-    if(mtllib) {
-        model->nummaterial = mtllib->nummaterial;
-        model->material = mtllib->material;
-        model->numtexture = mtllib->numtexture;
-        model->texture = mtllib->texture;
-        model->flags |= M3D_FLG_MTLLIB;
-    }
-#ifdef M3D_ASCII
-    /* ASCII variant? */
-    if(M3D_CHUNKMAGIC(data, '3','d','m','o')) {
-        model->errcode = M3D_ERR_BADFILE;
-        model->flags |= M3D_FLG_FREESTR;
-        model->raw = (m3dhdr_t*)data;
-        ptr = (char*)data;
-        ol = setlocale(LC_NUMERIC, NULL);
-        setlocale(LC_NUMERIC, "C");
-        /* parse header. Don't use sscanf, that's incredibly slow */
-        ptr = _m3d_findarg(ptr);
-        if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
-        pe = _m3d_findnl(ptr);
-        model->scale = (float)strtod(ptr, NULL); ptr = pe;
-        if(model->scale <= (M3D_FLOAT)0.0) model->scale = (M3D_FLOAT)1.0;
-        model->name = _m3d_safestr(ptr, 2); ptr = _m3d_findnl(ptr);
-        if(!*ptr) goto asciiend;
-        model->license = _m3d_safestr(ptr, 2); ptr = _m3d_findnl(ptr);
-        if(!*ptr) goto asciiend;
-        model->author = _m3d_safestr(ptr, 2); ptr = _m3d_findnl(ptr);
-        if(!*ptr) goto asciiend;
-        if(*ptr != '\r' && *ptr != '\n')
-            model->desc = _m3d_safestr(ptr, 3);
-        while(*ptr) {
-            while(*ptr && *ptr!='\n') ptr++;
-            ptr++; if(*ptr=='\r') ptr++;
-            if(*ptr == '\n') break;
-        }
-
-        /* the main chunk reader loop */
-        while(*ptr) {
-            while(*ptr && (*ptr == '\r' || *ptr == '\n')) ptr++;
-            if(!*ptr || (ptr[0]=='E' && ptr[1]=='n' && ptr[2]=='d')) break;
-            /* make sure there's at least one data row */
-            pe = ptr; ptr = _m3d_findnl(ptr);
-            if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
-            /* Preview chunk */
-            if(!memcmp(pe, "Preview", 7)) {
-                if(readfilecb) {
-                    pe = _m3d_safestr(ptr, 0);
-                    if(!pe || !*pe) goto asciiend;
-                    model->preview.data = (*readfilecb)(pe, &model->preview.length);
-                    M3D_FREE(pe);
-                }
-                while(*ptr && *ptr != '\r' && *ptr != '\n')
-                    ptr = _m3d_findnl(ptr);
-            } else
-            /* texture map chunk */
-            if(!memcmp(pe, "Textmap", 7)) {
-                if(model->tmap) { M3D_LOG("More texture map chunks, should be unique"); goto asciiend; }
-                while(*ptr && *ptr != '\r' && *ptr != '\n') {
-                    i = model->numtmap++;
-                    model->tmap = (m3dti_t*)M3D_REALLOC(model->tmap, model->numtmap * sizeof(m3dti_t));
-                    if(!model->tmap) goto memerr;
-                    ptr = _m3d_getfloat(ptr, &model->tmap[i].u);
-                    if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
-                    _m3d_getfloat(ptr, &model->tmap[i].v);
-                    ptr = _m3d_findnl(ptr);
-                }
-            } else
-            /* vertex chunk */
-            if(!memcmp(pe, "Vertex", 6)) {
-                if(model->vertex) { M3D_LOG("More vertex chunks, should be unique"); goto asciiend; }
-                while(*ptr && *ptr != '\r' && *ptr != '\n') {
-                    i = model->numvertex++;
-                    model->vertex = (m3dv_t*)M3D_REALLOC(model->vertex, model->numvertex * sizeof(m3dv_t));
-                    if(!model->vertex) goto memerr;
-                    memset(&model->vertex[i], 0, sizeof(m3dv_t));
-                    model->vertex[i].skinid = M3D_UNDEF;
-                    model->vertex[i].color = 0;
-                    model->vertex[i].w = (M3D_FLOAT)1.0;
-                    ptr = _m3d_getfloat(ptr, &model->vertex[i].x);
-                    if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
-                    ptr = _m3d_getfloat(ptr, &model->vertex[i].y);
-                    if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
-                    ptr = _m3d_getfloat(ptr, &model->vertex[i].z);
-                    if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
-                    ptr = _m3d_getfloat(ptr, &model->vertex[i].w);
-                    if(!*ptr) goto asciiend;
-                    if(*ptr == '#') {
-                        ptr = _m3d_gethex(ptr, &model->vertex[i].color);
-                        if(!*ptr) goto asciiend;
-                    }
-                    /* parse skin */
-                    memset(&s, 0, sizeof(m3ds_t));
-                    for(j = 0, w = (M3D_FLOAT)0.0; j < M3D_NUMBONE && *ptr && *ptr != '\r' && *ptr != '\n'; j++) {
-                        ptr = _m3d_findarg(ptr);
-                        if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
-                        ptr = _m3d_getint(ptr, &k);
-                        s.boneid[j] = (M3D_INDEX)k;
-                        if(*ptr == ':') {
-                            ptr++;
-                            ptr = _m3d_getfloat(ptr, &s.weight[j]);
-                            w += s.weight[j];
-                        } else if(!j)
-                            s.weight[j] = (M3D_FLOAT)1.0;
-                        if(!*ptr) goto asciiend;
-                    }
-                    if(s.boneid[0] != M3D_UNDEF && s.weight[0] > (M3D_FLOAT)0.0) {
-                        if(w != (M3D_FLOAT)1.0 && w != (M3D_FLOAT)0.0)
-                            for(j = 0; j < M3D_NUMBONE && s.weight[j] > (M3D_FLOAT)0.0; j++)
-                                s.weight[j] /= w;
-                        k = M3D_NOTDEFINED;
-                        if(model->skin) {
-                            for(j = 0; j < model->numskin; j++)
-                                if(!memcmp(&model->skin[j], &s, sizeof(m3ds_t))) { k = j; break; }
-                        }
-                        if(k == M3D_NOTDEFINED) {
-                            k = model->numskin++;
-                            model->skin = (m3ds_t*)M3D_REALLOC(model->skin, model->numskin * sizeof(m3ds_t));
-                            memcpy(&model->skin[k], &s, sizeof(m3ds_t));
-                        }
-                        model->vertex[i].skinid = (M3D_INDEX)k;
-                    }
-                    ptr = _m3d_findnl(ptr);
-                }
-            } else
-            /* Skeleton, bone hierarchy */
-            if(!memcmp(pe, "Bones", 5)) {
-                if(model->bone) { M3D_LOG("More bones chunks, should be unique"); goto asciiend; }
-                bi[0] = M3D_UNDEF;
-                while(*ptr && *ptr != '\r' && *ptr != '\n') {
-                    i = model->numbone++;
-                    model->bone = (m3db_t*)M3D_REALLOC(model->bone, model->numbone * sizeof(m3db_t));
-                    if(!model->bone) goto memerr;
-                    for(level = 0; *ptr == '/'; ptr++, level++);
-                    if(level > M3D_BONEMAXLEVEL || !*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
-                    bi[level+1] = i;
-                    model->bone[i].numweight = 0;
-                    model->bone[i].weight = NULL;
-                    model->bone[i].parent = bi[level];
-                    ptr = _m3d_getint(ptr, &k);
-                    ptr = _m3d_findarg(ptr);
-                    if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
-                    model->bone[i].pos = (M3D_INDEX)k;
-                    ptr = _m3d_getint(ptr, &k);
-                    ptr = _m3d_findarg(ptr);
-                    if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
-                    model->bone[i].ori = (M3D_INDEX)k;
-                    model->vertex[k].skinid = M3D_INDEXMAX;
-                    pe = _m3d_safestr(ptr, 0);
-                    if(!pe || !*pe) goto asciiend;
-                    model->bone[i].name = pe;
-                    ptr = _m3d_findnl(ptr);
-                }
-            } else
-            /* material chunk */
-            if(!memcmp(pe, "Material", 8)) {
-                pe = _m3d_findarg(pe);
-                if(!*pe || *pe == '\r' || *pe == '\n') goto asciiend;
-                pe = _m3d_safestr(pe, 0);
-                if(!pe || !*pe) goto asciiend;
-                for(i = 0; i < model->nummaterial; i++)
-                    if(!strcmp(pe, model->material[i].name)) {
-                        M3D_LOG("Multiple definitions for material");
-                        M3D_LOG(pe);
-                        M3D_FREE(pe);
-                        pe = NULL;
-                        while(*ptr && *ptr != '\r' && *ptr != '\n') ptr = _m3d_findnl(ptr);
-                        break;
-                    }
-                if(!pe) continue;
-                i = model->nummaterial++;
-                if(model->flags & M3D_FLG_MTLLIB) {
-                    m = model->material;
-                    model->material = (m3dm_t*)M3D_MALLOC(model->nummaterial * sizeof(m3dm_t));
-                    if(!model->material) goto memerr;
-                    memcpy(model->material, m, (model->nummaterial - 1) * sizeof(m3dm_t));
-                    if(model->texture) {
-                        tx = model->texture;
-                        model->texture = (m3dtx_t*)M3D_MALLOC(model->numtexture * sizeof(m3dtx_t));
-                        if(!model->texture) goto memerr;
-                        memcpy(model->texture, tx, model->numtexture * sizeof(m3dm_t));
-                    }
-                    model->flags &= ~M3D_FLG_MTLLIB;
-                } else {
-                    model->material = (m3dm_t*)M3D_REALLOC(model->material, model->nummaterial * sizeof(m3dm_t));
-                    if(!model->material) goto memerr;
-                }
-                m = &model->material[i];
-                m->name = pe;
-                m->numprop = 0;
-                m->prop = NULL;
-                while(*ptr && *ptr != '\r' && *ptr != '\n') {
-                    k = n = 256;
-                    if(*ptr == 'm' && *(ptr+1) == 'a' && *(ptr+2) == 'p' && *(ptr+3) == '_') {
-                        k = m3dpf_map;
-                        ptr += 4;
-                    }
-                    for(j = 0; j < sizeof(m3d_propertytypes)/sizeof(m3d_propertytypes[0]); j++)
-                        if(!memcmp(ptr, m3d_propertytypes[j].key, strlen(m3d_propertytypes[j].key))) {
-                            n = m3d_propertytypes[j].id;
-                            if(k != m3dpf_map) k = m3d_propertytypes[j].format;
-                            break;
-                        }
-                    if(n != 256 && k != 256) {
-                        ptr = _m3d_findarg(ptr);
-                        if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
-                        j = m->numprop++;
-                        m->prop = (m3dp_t*)M3D_REALLOC(m->prop, m->numprop * sizeof(m3dp_t));
-                        if(!m->prop) goto memerr;
-                        m->prop[j].type = n + (k == m3dpf_map && n < 128 ? 128 : 0);
-                        switch(k) {
-                            case m3dpf_color: ptr = _m3d_gethex(ptr, &m->prop[j].value.color); break;
-                            case m3dpf_uint8:
-                            case m3dpf_uint16:
-                            case m3dpf_uint32: ptr = _m3d_getint(ptr, &m->prop[j].value.num); break;
-                            case m3dpf_float:  ptr = _m3d_getfloat(ptr, &m->prop[j].value.fnum); break;
-                            case m3dpf_map:
-                                pe = _m3d_safestr(ptr, 0);
-                                if(!pe || !*pe) goto asciiend;
-                                m->prop[j].value.textureid = _m3d_gettx(model, readfilecb, freecb, pe);
-                                if(model->errcode == M3D_ERR_ALLOC) { M3D_FREE(pe); goto memerr; }
-                                /* this error code only returned if readfilecb was specified */
-                                if(m->prop[j].value.textureid == M3D_UNDEF) {
-                                    M3D_LOG("Texture not found");
-                                    M3D_LOG(pe);
-                                    m->numprop--;
-                                }
-                                M3D_FREE(pe);
-                            break;
-                        }
-                    } else {
-                        M3D_LOG("Unknown material property in");
-                        M3D_LOG(m->name);
-                        model->errcode = M3D_ERR_UNKPROP;
-                    }
-                    ptr = _m3d_findnl(ptr);
-                }
-                if(!m->numprop) model->nummaterial--;
-            } else
-            /* procedural */
-            if(!memcmp(pe, "Procedural", 10)) {
-                pe = _m3d_safestr(ptr, 0);
-                _m3d_getpr(model, readfilecb, freecb, pe);
-                M3D_FREE(pe);
-                while(*ptr && *ptr != '\r' && *ptr != '\n') ptr = _m3d_findnl(ptr);
-            } else
-            /* mesh */
-            if(!memcmp(pe, "Mesh", 4)) {
-                mi = M3D_UNDEF;
-                while(*ptr && *ptr != '\r' && *ptr != '\n') {
-                    if(*ptr == 'u') {
-                        ptr = _m3d_findarg(ptr);
-                        if(!*ptr) goto asciiend;
-                        mi = M3D_UNDEF;
-                        if(*ptr != '\r' && *ptr != '\n') {
-                            pe = _m3d_safestr(ptr, 0);
-                            if(!pe || !*pe) goto asciiend;
-                            for(j = 0; j < model->nummaterial; j++)
-                                if(!strcmp(pe, model->material[j].name)) { mi = (M3D_INDEX)j; break; }
-                            if(mi == M3D_UNDEF && !(model->flags & M3D_FLG_MTLLIB)) {
-                                mi = model->nummaterial++;
-                                model->material = (m3dm_t*)M3D_REALLOC(model->material, model->nummaterial * sizeof(m3dm_t));
-                                if(!model->material) goto memerr;
-                                model->material[mi].name = pe;
-                                model->material[mi].numprop = 1;
-                                model->material[mi].prop = NULL;
-                            } else
-                                M3D_FREE(pe);
-                        }
-                    } else {
-                        i = model->numface++;
-                        model->face = (m3df_t*)M3D_REALLOC(model->face, model->numface * sizeof(m3df_t));
-                        if(!model->face) goto memerr;
-                        memset(&model->face[i], 255, sizeof(m3df_t)); /* set all index to -1 by default */
-                        model->face[i].materialid = mi;
-                        /* hardcoded triangles. */
-                        for(j = 0; j < 3; j++) {
-                            /* vertex */
-                            ptr = _m3d_getint(ptr, &k);
-                            model->face[i].vertex[j] = (M3D_INDEX)k;
-                            if(!*ptr) goto asciiend;
-                            if(*ptr == '/') {
-                                ptr++;
-                                if(*ptr != '/') {
-                                    /* texcoord */
-                                    ptr = _m3d_getint(ptr, &k);
-                                    model->face[i].texcoord[j] = (M3D_INDEX)k;
-                                    if(!*ptr) goto asciiend;
-                                }
-                                if(*ptr == '/') {
-                                    ptr++;
-                                    /* normal */
-                                    ptr = _m3d_getint(ptr, &k);
-                                    model->face[i].normal[j] = (M3D_INDEX)k;
-                                    if(!*ptr) goto asciiend;
-                                }
-                            }
-#ifndef M3D_NONORMALS
-                            if(model->face[i].normal[j] == M3D_UNDEF) neednorm = 1;
-#endif
-                            ptr = _m3d_findarg(ptr);
-                        }
-                    }
-                    ptr = _m3d_findnl(ptr);
-                }
-            } else
-            /* mathematical shape */
-            if(!memcmp(pe, "Shape", 5)) {
-                pe = _m3d_findarg(pe);
-                if(!*pe || *pe == '\r' || *pe == '\n') goto asciiend;
-                pe = _m3d_safestr(pe, 0);
-                if(!pe || !*pe) goto asciiend;
-                i = model->numshape++;
-                model->shape = (m3dh_t*)M3D_REALLOC(model->shape, model->numshape * sizeof(m3ds_t));
-                if(!model->shape) goto memerr;
-                h = &model->shape[i];
-                h->name = pe;
-                h->group = M3D_UNDEF;
-                h->numcmd = 0;
-                h->cmd = NULL;
-                while(*ptr && *ptr != '\r' && *ptr != '\n') {
-                    if(!memcmp(ptr, "group", 5)) {
-                        ptr = _m3d_findarg(ptr);
-                        ptr = _m3d_getint(ptr, &h->group);
-                        ptr = _m3d_findnl(ptr);
-                        if(h->group != M3D_UNDEF && h->group >= model->numbone) {
-                            M3D_LOG("Unknown bone id as shape group in shape");
-                            M3D_LOG(pe);
-                            h->group = M3D_UNDEF;
-                            model->errcode = M3D_ERR_SHPE;
-                        }
-                        continue;
-                    }
-                    for(cd = NULL, k = 0; k < (unsigned int)(sizeof(m3d_commandtypes)/sizeof(m3d_commandtypes[0])); k++) {
-                        j = (unsigned int)strlen(m3d_commandtypes[k].key);
-                        if(!memcmp(ptr, m3d_commandtypes[k].key, j) && (ptr[j] == ' ' || ptr[j] == '\r' || ptr[j] == '\n'))
-                            { cd = &m3d_commandtypes[k]; break; }
-                    }
-                    if(cd) {
-                        j = h->numcmd++;
-                        h->cmd = (m3dc_t*)M3D_REALLOC(h->cmd, h->numcmd * sizeof(m3dc_t));
-                        if(!h->cmd) goto memerr;
-                        h->cmd[j].type = k;
-                        h->cmd[j].arg = (uint32_t*)M3D_MALLOC(cd->p * sizeof(uint32_t));
-                        if(!h->cmd[j].arg) goto memerr;
-                        memset(h->cmd[j].arg, 0, cd->p * sizeof(uint32_t));
-                        for(k = n = 0, l = cd->p; k < l; k++) {
-                            ptr = _m3d_findarg(ptr);
-                            if(!*ptr) goto asciiend;
-                            if(*ptr == '[') {
-                                ptr = _m3d_findarg(ptr + 1);
-                                if(!*ptr) goto asciiend;
-                            }
-                            if(*ptr == ']' || *ptr == '\r' || *ptr == '\n') break;
-                            switch(cd->a[((k - n) % (cd->p - n)) + n]) {
-                                case m3dcp_mi_t:
-                                    mi = M3D_UNDEF;
-                                    if(*ptr != '\r' && *ptr != '\n') {
-                                        pe = _m3d_safestr(ptr, 0);
-                                        if(!pe || !*pe) goto asciiend;
-                                        for(n = 0; n < model->nummaterial; n++)
-                                            if(!strcmp(pe, model->material[n].name)) { mi = (M3D_INDEX)n; break; }
-                                        if(mi == M3D_UNDEF && !(model->flags & M3D_FLG_MTLLIB)) {
-                                            mi = model->nummaterial++;
-                                            model->material = (m3dm_t*)M3D_REALLOC(model->material,
-                                                model->nummaterial * sizeof(m3dm_t));
-                                            if(!model->material) goto memerr;
-                                            model->material[mi].name = pe;
-                                            model->material[mi].numprop = 1;
-                                            model->material[mi].prop = NULL;
-                                        } else
-                                            M3D_FREE(pe);
-                                    }
-                                    h->cmd[j].arg[k] = mi;
-                                break;
-                                case m3dcp_vc_t:
-                                    _m3d_getfloat(ptr, &w);
-                                    h->cmd[j].arg[k] = *((uint32_t*)&w);
-                                break;
-                                case m3dcp_va_t:
-                                    ptr = _m3d_getint(ptr, &h->cmd[j].arg[k]);
-                                    n = k + 1; l += (h->cmd[j].arg[k] - 1) * (cd->p - k - 1);
-                                    h->cmd[j].arg = (uint32_t*)M3D_REALLOC(h->cmd[j].arg, l * sizeof(uint32_t));
-                                    if(!h->cmd[j].arg) goto memerr;
-                                    memset(&h->cmd[j].arg[k + 1], 0, (l - k - 1) * sizeof(uint32_t));
-                                break;
-                                case m3dcp_qi_t:
-                                    ptr = _m3d_getint(ptr, &h->cmd[j].arg[k]);
-                                    model->vertex[h->cmd[i].arg[k]].skinid = M3D_INDEXMAX;
-                                break;
-                                default:
-                                    ptr = _m3d_getint(ptr, &h->cmd[j].arg[k]);
-                                break;
-                            }
-                        }
-                    } else {
-                        M3D_LOG("Unknown shape command in");
-                        M3D_LOG(h->name);
-                        model->errcode = M3D_ERR_UNKCMD;
-                    }
-                    ptr = _m3d_findnl(ptr);
-                }
-                if(!h->numcmd) model->numshape--;
-            } else
-            /* annotation labels */
-            if(!memcmp(pe, "Labels", 6)) {
-                pe = _m3d_findarg(pe);
-                if(!*pe) goto asciiend;
-                if(*pe == '\r' || *pe == '\n') pe = NULL;
-                else pe = _m3d_safestr(pe, 0);
-                k = 0; fn = NULL;
-                while(*ptr && *ptr != '\r' && *ptr != '\n') {
-                    if(*ptr == 'c') {
-                        ptr = _m3d_findarg(ptr);
-                        if(!*pe || *pe == '\r' || *pe == '\n') goto asciiend;
-                        ptr = _m3d_gethex(ptr, &k);
-                    } else
-                    if(*ptr == 'l') {
-                        ptr = _m3d_findarg(ptr);
-                        if(!*pe || *pe == '\r' || *pe == '\n') goto asciiend;
-                        fn = _m3d_safestr(ptr, 2);
-                    } else {
-                        i = model->numlabel++;
-                        model->label = (m3dl_t*)M3D_REALLOC(model->label, model->numlabel * sizeof(m3dl_t));
-                        if(!model->label) goto memerr;
-                        model->label[i].name = pe;
-                        model->label[i].lang = fn;
-                        model->label[i].color = k;
-                        ptr = _m3d_getint(ptr, &j);
-                        model->label[i].vertexid = (M3D_INDEX)j;
-                        ptr = _m3d_findarg(ptr);
-                        if(!*pe || *pe == '\r' || *pe == '\n') goto asciiend;
-                        model->label[i].text = _m3d_safestr(ptr, 2);
-                    }
-                    ptr = _m3d_findnl(ptr);
-                }
-            } else
-            /* action */
-            if(!memcmp(pe, "Action", 6)) {
-                pe = _m3d_findarg(pe);
-                if(!*pe || *pe == '\r' || *pe == '\n') goto asciiend;
-                pe = _m3d_getint(pe, &k);
-                pe = _m3d_findarg(pe);
-                if(!*pe || *pe == '\r' || *pe == '\n') goto asciiend;
-                pe = _m3d_safestr(pe, 0);
-                if(!pe || !*pe) goto asciiend;
-                i = model->numaction++;
-                model->action = (m3da_t*)M3D_REALLOC(model->action, model->numaction * sizeof(m3da_t));
-                if(!model->action) goto memerr;
-                a = &model->action[i];
-                a->name = pe;
-                a->durationmsec = k;
-                /* skip the first frame marker as there's always at least one frame */
-                a->numframe = 1;
-                a->frame = (m3dfr_t*)M3D_MALLOC(sizeof(m3dfr_t));
-                if(!a->frame) goto memerr;
-                a->frame[0].msec = 0;
-                a->frame[0].numtransform = 0;
-                a->frame[0].transform = NULL;
-                i = 0;
-                if(*ptr == 'f')
-                    ptr = _m3d_findnl(ptr);
-                while(*ptr && *ptr != '\r' && *ptr != '\n') {
-                    if(*ptr == 'f') {
-                        i = a->numframe++;
-                        a->frame = (m3dfr_t*)M3D_REALLOC(a->frame, a->numframe * sizeof(m3dfr_t));
-                        if(!a->frame) goto memerr;
-                        ptr = _m3d_findarg(ptr);
-                        ptr = _m3d_getint(ptr, &a->frame[i].msec);
-                        a->frame[i].numtransform = 0;
-                        a->frame[i].transform = NULL;
-                    } else {
-                        j = a->frame[i].numtransform++;
-                        a->frame[i].transform = (m3dtr_t*)M3D_REALLOC(a->frame[i].transform,
-                            a->frame[i].numtransform * sizeof(m3dtr_t));
-                        if(!a->frame[i].transform) goto memerr;
-                        ptr = _m3d_getint(ptr, &k);
-                        ptr = _m3d_findarg(ptr);
-                        if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
-                        a->frame[i].transform[j].boneid = (M3D_INDEX)k;
-                        ptr = _m3d_getint(ptr, &k);
-                        ptr = _m3d_findarg(ptr);
-                        if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
-                        a->frame[i].transform[j].pos = (M3D_INDEX)k;
-                        ptr = _m3d_getint(ptr, &k);
-                        if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
-                        a->frame[i].transform[j].ori = (M3D_INDEX)k;
-                        model->vertex[k].skinid = M3D_INDEXMAX;
-                    }
-                    ptr = _m3d_findnl(ptr);
-                }
-            } else
-            /* inlined assets chunk */
-            if(!memcmp(pe, "Assets", 6)) {
-                while(*ptr && *ptr != '\r' && *ptr != '\n') {
-                    if(readfilecb) {
-                        pe = _m3d_safestr(ptr, 2);
-                        if(!pe || !*pe) goto asciiend;
-                        i = model->numinlined++;
-                        model->inlined = (m3di_t*)M3D_REALLOC(model->inlined, model->numinlined * sizeof(m3di_t));
-                        if(!model->inlined) goto memerr;
-                        t = &model->inlined[i];
-                        model->inlined[i].data = (*readfilecb)(pe, &model->inlined[i].length);
-                        if(model->inlined[i].data) {
-                            fn = strrchr(pe, '.');
-                            if(fn && (fn[1] == 'p' || fn[1] == 'P') && (fn[2] == 'n' || fn[2] == 'N') &&
-                                (fn[3] == 'g' || fn[3] == 'G')) *fn = 0;
-                            fn = strrchr(pe, '/');
-                            if(!fn) fn = strrchr(pe, '\\');
-                            if(!fn) fn = pe; else fn++;
-                            model->inlined[i].name = _m3d_safestr(fn, 0);
-                        } else
-                            model->numinlined--;
-                        M3D_FREE(pe);
-                    }
-                    ptr = _m3d_findnl(ptr);
-                }
-            } else
-            /* extra chunks */
-            if(!memcmp(pe, "Extra", 5)) {
-                pe = _m3d_findarg(pe);
-                if(!*pe || *pe == '\r' || *pe == '\n') goto asciiend;
-                buff = (unsigned char*)_m3d_findnl(ptr);
-                k = ((uint32_t)((uintptr_t)buff - (uintptr_t)ptr) / 3) + 1;
-                i = model->numextra++;
-                model->extra = (m3dchunk_t**)M3D_REALLOC(model->extra, model->numextra * sizeof(m3dchunk_t*));
-                if(!model->extra) goto memerr;
-                model->extra[i] = (m3dchunk_t*)M3D_MALLOC(k + sizeof(m3dchunk_t));
-                if(!model->extra[i]) goto memerr;
-                memcpy(&model->extra[i]->magic, pe, 4);
-                model->extra[i]->length = sizeof(m3dchunk_t);
-                pe = (char*)model->extra[i] + sizeof(m3dchunk_t);
-                while(*ptr && *ptr != '\r' && *ptr != '\n') {
-                    ptr = _m3d_gethex(ptr, &k);
-                    *pe++ = (uint8_t)k;
-                    model->extra[i]->length++;
-                }
-            } else
-                goto asciiend;
-        }
-        model->errcode = M3D_SUCCESS;
-asciiend:
-        setlocale(LC_NUMERIC, ol);
-        goto postprocess;
-    }
-#endif
-    /* Binary variant */
-    if(!M3D_CHUNKMAGIC(data + 8, 'H','E','A','D')) {
-        buff = (unsigned char *)stbi_zlib_decode_malloc_guesssize_headerflag((const char*)data+8, ((m3dchunk_t*)data)->length-8,
-            4096, (int*)&len, 1);
-        if(!buff || !len || !M3D_CHUNKMAGIC(buff, 'H','E','A','D')) {
-            if(buff) M3D_FREE(buff);
-            M3D_FREE(model);
-            return NULL;
-        }
-        buff = (unsigned char*)M3D_REALLOC(buff, len);
-        model->flags |= M3D_FLG_FREERAW; /* mark that we have to free the raw buffer */
-        data = buff;
-#ifdef M3D_PROFILING
-        gettimeofday(&tv1, NULL);
-        tvd.tv_sec = tv1.tv_sec - tv0.tv_sec;
-        tvd.tv_usec = tv1.tv_usec - tv0.tv_usec;
-        if(tvd.tv_usec < 0) { tvd.tv_sec--; tvd.tv_usec += 1000000L; }
-        printf("  Deflate model   %ld.%06ld sec\n", tvd.tv_sec, tvd.tv_usec);
-        memcpy(&tv0, &tv1, sizeof(struct timeval));
-#endif
-    } else {
-        len = ((m3dhdr_t*)data)->length;
-        data += 8;
-    }
-    model->raw = (m3dhdr_t*)data;
-    end = data + len;
-
-    /* parse header */
-    data += sizeof(m3dhdr_t);
-    M3D_LOG(data);
-    model->name = (char*)data;
-    for(; data < end && *data; data++) {}; data++;
-    model->license = (char*)data;
-    for(; data < end && *data; data++) {}; data++;
-    model->author = (char*)data;
-    for(; data < end && *data; data++) {}; data++;
-    model->desc = (char*)data;
-    chunk = (unsigned char*)model->raw + model->raw->length;
-    model->scale = (M3D_FLOAT)model->raw->scale;
-    if(model->scale <= (M3D_FLOAT)0.0) model->scale = (M3D_FLOAT)1.0;
-    model->vc_s = 1 << ((model->raw->types >> 0) & 3);  /* vertex coordinate size */
-    model->vi_s = 1 << ((model->raw->types >> 2) & 3);  /* vertex index size */
-    model->si_s = 1 << ((model->raw->types >> 4) & 3);  /* string offset size */
-    model->ci_s = 1 << ((model->raw->types >> 6) & 3);  /* color index size */
-    model->ti_s = 1 << ((model->raw->types >> 8) & 3);  /* tmap index size */
-    model->bi_s = 1 << ((model->raw->types >>10) & 3);  /* bone index size */
-    model->nb_s = 1 << ((model->raw->types >>12) & 3);  /* number of bones per vertex */
-    model->sk_s = 1 << ((model->raw->types >>14) & 3);  /* skin index size */
-    model->fc_s = 1 << ((model->raw->types >>16) & 3);  /* frame counter size */
-    model->hi_s = 1 << ((model->raw->types >>18) & 3);  /* shape index size */
-    model->fi_s = 1 << ((model->raw->types >>20) & 3);  /* face index size */
-    if(model->ci_s == 8) model->ci_s = 0;               /* optional indices */
-    if(model->ti_s == 8) model->ti_s = 0;
-    if(model->bi_s == 8) model->bi_s = 0;
-    if(model->sk_s == 8) model->sk_s = 0;
-    if(model->fc_s == 8) model->fc_s = 0;
-    if(model->hi_s == 8) model->hi_s = 0;
-    if(model->fi_s == 8) model->fi_s = 0;
-
-    /* variable limit checks */
-    if(sizeof(M3D_FLOAT) == 4 && model->vc_s > 4) {
-        M3D_LOG("Double precision coordinates not supported, truncating to float...");
-        model->errcode = M3D_ERR_TRUNC;
-    }
-    if(sizeof(M3D_INDEX) == 2 && (model->vi_s > 2 || model->si_s > 2 || model->ci_s > 2 || model->ti_s > 2 ||
-        model->bi_s > 2 || model->sk_s > 2 || model->fc_s > 2 || model->hi_s > 2 || model->fi_s > 2)) {
-        M3D_LOG("32 bit indices not supported, unable to load model");
-        M3D_FREE(model);
-        return NULL;
-    }
-    if(model->vi_s > 4 || model->si_s > 4) {
-        M3D_LOG("Invalid index size, unable to load model");
-        M3D_FREE(model);
-        return NULL;
-    }
-    if(model->nb_s > M3D_NUMBONE) {
-        M3D_LOG("Model has more bones per vertex than what importer was configured to support");
-        model->errcode = M3D_ERR_TRUNC;
-    }
-
-    /* look for inlined assets in advance, material and procedural chunks may need them */
-    buff = chunk;
-    while(buff < end && !M3D_CHUNKMAGIC(buff, 'O','M','D','3')) {
-        data = buff;
-        len = ((m3dchunk_t*)data)->length;
-        buff += len;
-        if(len < sizeof(m3dchunk_t) || buff >= end) {
-            M3D_LOG("Invalid chunk size");
-            break;
-        }
-        len -= sizeof(m3dchunk_t) + model->si_s;
-
-        /* inlined assets */
-        if(M3D_CHUNKMAGIC(data, 'A','S','E','T') && len > 0) {
-            M3D_LOG("Inlined asset");
-            i = model->numinlined++;
-            model->inlined = (m3di_t*)M3D_REALLOC(model->inlined, model->numinlined * sizeof(m3di_t));
-            if(!model->inlined) {
-memerr:         M3D_LOG("Out of memory");
-                model->errcode = M3D_ERR_ALLOC;
-                return model;
-            }
-            data += sizeof(m3dchunk_t);
-            t = &model->inlined[i];
-            M3D_GETSTR(t->name);
-            M3D_LOG(t->name);
-            t->data = (uint8_t*)data;
-            t->length = len;
-        }
-    }
-
-    /* parse chunks */
-    while(chunk < end && !M3D_CHUNKMAGIC(chunk, 'O','M','D','3')) {
-        data = chunk;
-        len = ((m3dchunk_t*)chunk)->length;
-        chunk += len;
-        if(len < sizeof(m3dchunk_t) || chunk >= end) {
-            M3D_LOG("Invalid chunk size");
-            break;
-        }
-        len -= sizeof(m3dchunk_t);
-
-        /* preview chunk */
-        if(M3D_CHUNKMAGIC(data, 'P','R','V','W') && len > 0) {
-            model->preview.length = len;
-            model->preview.data = data + sizeof(m3dchunk_t);
-        } else
-        /* color map */
-        if(M3D_CHUNKMAGIC(data, 'C','M','A','P')) {
-            M3D_LOG("Color map");
-            if(model->cmap) { M3D_LOG("More color map chunks, should be unique"); model->errcode = M3D_ERR_CMAP; continue; }
-            if(!model->ci_s) { M3D_LOG("Color map chunk, shouldn't be any"); model->errcode = M3D_ERR_CMAP; continue; }
-            model->numcmap = len / sizeof(uint32_t);
-            model->cmap = (uint32_t*)(data + sizeof(m3dchunk_t));
-        } else
-        /* texture map */
-        if(M3D_CHUNKMAGIC(data, 'T','M','A','P')) {
-            M3D_LOG("Texture map");
-            if(model->tmap) { M3D_LOG("More texture map chunks, should be unique"); model->errcode = M3D_ERR_TMAP; continue; }
-            if(!model->ti_s) { M3D_LOG("Texture map chunk, shouldn't be any"); model->errcode = M3D_ERR_TMAP; continue; }
-            reclen = model->vc_s + model->vc_s;
-            model->numtmap = len / reclen;
-            model->tmap = (m3dti_t*)M3D_MALLOC(model->numtmap * sizeof(m3dti_t));
-            if(!model->tmap) goto memerr;
-            for(i = 0, data += sizeof(m3dchunk_t); data < chunk; i++) {
-                switch(model->vc_s) {
-                    case 1:
-                        model->tmap[i].u = (M3D_FLOAT)(data[0]) / (M3D_FLOAT)255.0;
-                        model->tmap[i].v = (M3D_FLOAT)(data[1]) / (M3D_FLOAT)255.0;
-                    break;
-                    case 2:
-                        model->tmap[i].u = (M3D_FLOAT)(*((int16_t*)(data+0))) / (M3D_FLOAT)65535.0;
-                        model->tmap[i].v = (M3D_FLOAT)(*((int16_t*)(data+2))) / (M3D_FLOAT)65535.0;
-                    break;
-                    case 4:
-                        model->tmap[i].u = (M3D_FLOAT)(*((float*)(data+0)));
-                        model->tmap[i].v = (M3D_FLOAT)(*((float*)(data+4)));
-                    break;
-                    case 8:
-                        model->tmap[i].u = (M3D_FLOAT)(*((double*)(data+0)));
-                        model->tmap[i].v = (M3D_FLOAT)(*((double*)(data+8)));
-                    break;
-                }
-                data += reclen;
-            }
-        } else
-        /* vertex list */
-        if(M3D_CHUNKMAGIC(data, 'V','R','T','S')) {
-            M3D_LOG("Vertex list");
-            if(model->vertex) { M3D_LOG("More vertex chunks, should be unique"); model->errcode = M3D_ERR_VRTS; continue; }
-            if(model->ci_s && model->ci_s < 4 && !model->cmap) model->errcode = M3D_ERR_CMAP;
-            reclen = model->ci_s + model->sk_s + 4 * model->vc_s;
-            model->numvertex = len / reclen;
-            model->vertex = (m3dv_t*)M3D_MALLOC(model->numvertex * sizeof(m3dv_t));
-            if(!model->vertex) goto memerr;
-            memset(model->vertex, 0, model->numvertex * sizeof(m3dv_t));
-            for(i = 0, data += sizeof(m3dchunk_t); data < chunk && i < model->numvertex; i++) {
-                switch(model->vc_s) {
-                    case 1:
-                        model->vertex[i].x = (M3D_FLOAT)((int8_t)data[0]) / (M3D_FLOAT)127.0;
-                        model->vertex[i].y = (M3D_FLOAT)((int8_t)data[1]) / (M3D_FLOAT)127.0;
-                        model->vertex[i].z = (M3D_FLOAT)((int8_t)data[2]) / (M3D_FLOAT)127.0;
-                        model->vertex[i].w = (M3D_FLOAT)((int8_t)data[3]) / (M3D_FLOAT)127.0;
-                        data += 4;
-                    break;
-                    case 2:
-                        model->vertex[i].x = (M3D_FLOAT)(*((int16_t*)(data+0))) / (M3D_FLOAT)32767.0;
-                        model->vertex[i].y = (M3D_FLOAT)(*((int16_t*)(data+2))) / (M3D_FLOAT)32767.0;
-                        model->vertex[i].z = (M3D_FLOAT)(*((int16_t*)(data+4))) / (M3D_FLOAT)32767.0;
-                        model->vertex[i].w = (M3D_FLOAT)(*((int16_t*)(data+6))) / (M3D_FLOAT)32767.0;
-                        data += 8;
-                    break;
-                    case 4:
-                        model->vertex[i].x = (M3D_FLOAT)(*((float*)(data+0)));
-                        model->vertex[i].y = (M3D_FLOAT)(*((float*)(data+4)));
-                        model->vertex[i].z = (M3D_FLOAT)(*((float*)(data+8)));
-                        model->vertex[i].w = (M3D_FLOAT)(*((float*)(data+12)));
-                        data += 16;
-                    break;
-                    case 8:
-                        model->vertex[i].x = (M3D_FLOAT)(*((double*)(data+0)));
-                        model->vertex[i].y = (M3D_FLOAT)(*((double*)(data+8)));
-                        model->vertex[i].z = (M3D_FLOAT)(*((double*)(data+16)));
-                        model->vertex[i].w = (M3D_FLOAT)(*((double*)(data+24)));
-                        data += 32;
-                    break;
-                }
-                switch(model->ci_s) {
-                    case 1: model->vertex[i].color = model->cmap ? model->cmap[data[0]] : 0; data++; break;
-                    case 2: model->vertex[i].color = model->cmap ? model->cmap[*((uint16_t*)data)] : 0; data += 2; break;
-                    case 4: model->vertex[i].color = *((uint32_t*)data); data += 4; break;
-                    /* case 8: break; */
-                }
-                model->vertex[i].skinid = M3D_UNDEF;
-                data = _m3d_getidx(data, model->sk_s, &model->vertex[i].skinid);
-            }
-        } else
-        /* skeleton: bone hierarchy and skin */
-        if(M3D_CHUNKMAGIC(data, 'B','O','N','E')) {
-            M3D_LOG("Skeleton");
-            if(model->bone) { M3D_LOG("More bone chunks, should be unique"); model->errcode = M3D_ERR_BONE; continue; }
-            if(!model->bi_s) { M3D_LOG("Bone chunk, shouldn't be any"); model->errcode=M3D_ERR_BONE; continue; }
-            if(!model->vertex) { M3D_LOG("No vertex chunk before bones"); model->errcode = M3D_ERR_VRTS; break; }
-            data += sizeof(m3dchunk_t);
-            model->numbone = 0;
-            data = _m3d_getidx(data, model->bi_s, &model->numbone);
-            if(model->numbone) {
-                model->bone = (m3db_t*)M3D_MALLOC(model->numbone * sizeof(m3db_t));
-                if(!model->bone) goto memerr;
-            }
-            model->numskin = 0;
-            data = _m3d_getidx(data, model->sk_s, &model->numskin);
-            /* read bone hierarchy */
-            for(i = 0; i < model->numbone; i++) {
-                data = _m3d_getidx(data, model->bi_s, &model->bone[i].parent);
-                M3D_GETSTR(model->bone[i].name);
-                data = _m3d_getidx(data, model->vi_s, &model->bone[i].pos);
-                data = _m3d_getidx(data, model->vi_s, &model->bone[i].ori);
-                model->bone[i].numweight = 0;
-                model->bone[i].weight = NULL;
-            }
-            /* read skin definitions */
-            if(model->numskin) {
-                model->skin = (m3ds_t*)M3D_MALLOC(model->numskin * sizeof(m3ds_t));
-                if(!model->skin) goto memerr;
-                for(i = 0; data < chunk && i < model->numskin; i++) {
-                    for(j = 0; j < M3D_NUMBONE; j++) {
-                        model->skin[i].boneid[j] = M3D_UNDEF;
-                        model->skin[i].weight[j] = (M3D_FLOAT)0.0;
-                    }
-                    memset(&weights, 0, sizeof(weights));
-                    if(model->nb_s == 1) weights[0] = 255;
-                    else {
-                        memcpy(&weights, data, model->nb_s);
-                        data += model->nb_s;
-                    }
-                    for(j = 0, w = (M3D_FLOAT)0.0; j < (unsigned int)model->nb_s; j++) {
-                        if(weights[j]) {
-                            if(j >= M3D_NUMBONE)
-                                data += model->bi_s;
-                            else {
-                                model->skin[i].weight[j] = (M3D_FLOAT)(weights[j]) / (M3D_FLOAT)255.0;
-                                w += model->skin[i].weight[j];
-                                data = _m3d_getidx(data, model->bi_s, &model->skin[i].boneid[j]);
-                            }
-                        }
-                    }
-                    /* this can occur if model has more bones than what the importer is configured to handle */
-                    if(w != (M3D_FLOAT)1.0 && w != (M3D_FLOAT)0.0) {
-                        for(j = 0; j < M3D_NUMBONE; j++)
-                            model->skin[i].weight[j] /= w;
-                    }
-                }
-            }
-        } else
-        /* material */
-        if(M3D_CHUNKMAGIC(data, 'M','T','R','L')) {
-            data += sizeof(m3dchunk_t);
-            M3D_GETSTR(name);
-            M3D_LOG("Material");
-            M3D_LOG(name);
-            if(model->ci_s < 4 && !model->numcmap) model->errcode = M3D_ERR_CMAP;
-            for(i = 0; i < model->nummaterial; i++)
-                if(!strcmp(name, model->material[i].name)) {
-                    model->errcode = M3D_ERR_MTRL;
-                    M3D_LOG("Multiple definitions for material");
-                    M3D_LOG(name);
-                    name = NULL;
-                    break;
-                }
-            if(name) {
-                i = model->nummaterial++;
-                if(model->flags & M3D_FLG_MTLLIB) {
-                    m = model->material;
-                    model->material = (m3dm_t*)M3D_MALLOC(model->nummaterial * sizeof(m3dm_t));
-                    if(!model->material) goto memerr;
-                    memcpy(model->material, m, (model->nummaterial - 1) * sizeof(m3dm_t));
-                    if(model->texture) {
-                        tx = model->texture;
-                        model->texture = (m3dtx_t*)M3D_MALLOC(model->numtexture * sizeof(m3dtx_t));
-                        if(!model->texture) goto memerr;
-                        memcpy(model->texture, tx, model->numtexture * sizeof(m3dm_t));
-                    }
-                    model->flags &= ~M3D_FLG_MTLLIB;
-                } else {
-                    model->material = (m3dm_t*)M3D_REALLOC(model->material, model->nummaterial * sizeof(m3dm_t));
-                    if(!model->material) goto memerr;
-                }
-                m = &model->material[i];
-                m->numprop = 0;
-                m->name = name;
-                m->prop = (m3dp_t*)M3D_MALLOC((len / 2) * sizeof(m3dp_t));
-                if(!m->prop) goto memerr;
-                while(data < chunk) {
-                    i = m->numprop++;
-                    m->prop[i].type = *data++;
-                    m->prop[i].value.num = 0;
-                    if(m->prop[i].type >= 128)
-                        k = m3dpf_map;
-                    else {
-                        for(k = 256, j = 0; j < sizeof(m3d_propertytypes)/sizeof(m3d_propertytypes[0]); j++)
-                            if(m->prop[i].type == m3d_propertytypes[j].id) { k = m3d_propertytypes[j].format; break; }
-                    }
-                    switch(k) {
-                        case m3dpf_color:
-                            switch(model->ci_s) {
-                                case 1: m->prop[i].value.color = model->cmap ? model->cmap[data[0]] : 0; data++; break;
-                                case 2: m->prop[i].value.color = model->cmap ? model->cmap[*((uint16_t*)data)] : 0; data += 2; break;
-                                case 4: m->prop[i].value.color = *((uint32_t*)data); data += 4; break;
-                            }
-                        break;
-
-                        case m3dpf_uint8: m->prop[i].value.num = *data++; break;
-                        case m3dpf_uint16:m->prop[i].value.num = *((uint16_t*)data); data += 2; break;
-                        case m3dpf_uint32:m->prop[i].value.num = *((uint32_t*)data); data += 4; break;
-                        case m3dpf_float: m->prop[i].value.fnum = *((float*)data); data += 4; break;
-
-                        case m3dpf_map:
-                            M3D_GETSTR(name);
-                            m->prop[i].value.textureid = _m3d_gettx(model, readfilecb, freecb, name);
-                            if(model->errcode == M3D_ERR_ALLOC) goto memerr;
-                            /* this error code only returned if readfilecb was specified */
-                            if(m->prop[i].value.textureid == M3D_UNDEF) {
-                                M3D_LOG("Texture not found");
-                                M3D_LOG(m->name);
-                                m->numprop--;
-                            }
-                        break;
-
-                        default:
-                            M3D_LOG("Unknown material property in");
-                            M3D_LOG(m->name);
-                            model->errcode = M3D_ERR_UNKPROP;
-                            data = chunk;
-                        break;
-                    }
-                }
-                m->prop = (m3dp_t*)M3D_REALLOC(m->prop, m->numprop * sizeof(m3dp_t));
-                if(!m->prop) goto memerr;
-            }
-        } else
-        /* face */
-        if(M3D_CHUNKMAGIC(data, 'P','R','O','C')) {
-            /* procedural surface */
-            M3D_GETSTR(name);
-            M3D_LOG("Procedural surface");
-            M3D_LOG(name);
-            _m3d_getpr(model, readfilecb, freecb, name);
-        } else
-        if(M3D_CHUNKMAGIC(data, 'M','E','S','H')) {
-            M3D_LOG("Mesh data");
-            /* mesh */
-            data += sizeof(m3dchunk_t);
-            mi = M3D_UNDEF;
-            am = model->numface;
-            while(data < chunk) {
-                k = *data++;
-                n = k >> 4;
-                k &= 15;
-                if(!n) {
-                    /* use material */
-                    mi = M3D_UNDEF;
-                    M3D_GETSTR(name);
-                    if(name) {
-                        for(j = 0; j < model->nummaterial; j++)
-                            if(!strcmp(name, model->material[j].name)) {
-                                mi = (M3D_INDEX)j;
-                                break;
-                            }
-                        if(mi == M3D_UNDEF) model->errcode = M3D_ERR_MTRL;
-                    }
-                    continue;
-                }
-                if(n != 3) { M3D_LOG("Only triangle mesh supported for now"); model->errcode = M3D_ERR_UNKMESH; return model; }
-                i = model->numface++;
-                if(model->numface > am) {
-                    am = model->numface + 4095;
-                    model->face = (m3df_t*)M3D_REALLOC(model->face, am * sizeof(m3df_t));
-                    if(!model->face) goto memerr;
-                }
-                memset(&model->face[i], 255, sizeof(m3df_t)); /* set all index to -1 by default */
-                model->face[i].materialid = mi;
-                for(j = 0; j < n; j++) {
-                    /* vertex */
-                    data = _m3d_getidx(data, model->vi_s, &model->face[i].vertex[j]);
-                    /* texcoord */
-                    if(k & 1)
-                        data = _m3d_getidx(data, model->ti_s, &model->face[i].texcoord[j]);
-                    /* normal */
-                    if(k & 2)
-                        data = _m3d_getidx(data, model->vi_s, &model->face[i].normal[j]);
-#ifndef M3D_NONORMALS
-                    if(model->face[i].normal[j] == M3D_UNDEF) neednorm = 1;
-#endif
-                }
-            }
-            model->face = (m3df_t*)M3D_REALLOC(model->face, model->numface * sizeof(m3df_t));
-        } else
-        if(M3D_CHUNKMAGIC(data, 'S','H','P','E')) {
-            /* mathematical shape */
-            data += sizeof(m3dchunk_t);
-            M3D_GETSTR(name);
-            M3D_LOG("Mathematical Shape");
-            M3D_LOG(name);
-            i = model->numshape++;
-            model->shape = (m3dh_t*)M3D_REALLOC(model->shape, model->numshape * sizeof(m3dh_t));
-            if(!model->shape) goto memerr;
-            h = &model->shape[i];
-            h->numcmd = 0;
-            h->cmd = NULL;
-            h->name = name;
-            h->group = M3D_UNDEF;
-            data = _m3d_getidx(data, model->bi_s, &h->group);
-            if(h->group != M3D_UNDEF && h->group >= model->numbone) {
-                M3D_LOG("Unknown bone id as shape group in shape");
-                M3D_LOG(name);
-                h->group = M3D_UNDEF;
-                model->errcode = M3D_ERR_SHPE;
-            }
-            while(data < chunk) {
-                i = h->numcmd++;
-                h->cmd = (m3dc_t*)M3D_REALLOC(h->cmd, h->numcmd * sizeof(m3dc_t));
-                if(!h->cmd) goto memerr;
-                h->cmd[i].type = *data++;
-                if(h->cmd[i].type & 0x80) {
-                    h->cmd[i].type &= 0x7F;
-                    h->cmd[i].type |= (*data++ << 7);
-                }
-                if(h->cmd[i].type >= (unsigned int)(sizeof(m3d_commandtypes)/sizeof(m3d_commandtypes[0]))) {
-                    M3D_LOG("Unknown shape command in");
-                    M3D_LOG(h->name);
-                    model->errcode = M3D_ERR_UNKCMD;
-                    break;
-                }
-                cd = &m3d_commandtypes[h->cmd[i].type];
-                h->cmd[i].arg = (uint32_t*)M3D_MALLOC(cd->p * sizeof(uint32_t));
-                if(!h->cmd[i].arg) goto memerr;
-                memset(h->cmd[i].arg, 0, cd->p * sizeof(uint32_t));
-                for(k = n = 0, l = cd->p; k < l; k++)
-                    switch(cd->a[((k - n) % (cd->p - n)) + n]) {
-                        case m3dcp_mi_t:
-                            h->cmd[i].arg[k] = M3D_NOTDEFINED;
-                            M3D_GETSTR(name);
-                            if(name) {
-                                for(n = 0; n < model->nummaterial; n++)
-                                    if(!strcmp(name, model->material[n].name)) {
-                                        h->cmd[i].arg[k] = n;
-                                        break;
-                                    }
-                                if(h->cmd[i].arg[k] == M3D_NOTDEFINED) model->errcode = M3D_ERR_MTRL;
-                            }
-                        break;
-                        case m3dcp_vc_t:
-                            f = 0.0f;
-                            switch(model->vc_s) {
-                                case 1: f = (float)((int8_t)data[0]) / 127; break;
-                                case 2: f = (float)(*((int16_t*)(data+0))) / 32767; break;
-                                case 4: f = (float)(*((float*)(data+0))); break;
-                                case 8: f = (float)(*((double*)(data+0))); break;
-                            }
-                            h->cmd[i].arg[k] = *((uint32_t*)&f);
-                            data += model->vc_s;
-                        break;
-                        case m3dcp_hi_t: data = _m3d_getidx(data, model->hi_s, &h->cmd[i].arg[k]); break;
-                        case m3dcp_fi_t: data = _m3d_getidx(data, model->fi_s, &h->cmd[i].arg[k]); break;
-                        case m3dcp_ti_t: data = _m3d_getidx(data, model->ti_s, &h->cmd[i].arg[k]); break;
-                        case m3dcp_qi_t:
-                        case m3dcp_vi_t: data = _m3d_getidx(data, model->vi_s, &h->cmd[i].arg[k]); break;
-                        case m3dcp_i1_t: data = _m3d_getidx(data, 1, &h->cmd[i].arg[k]); break;
-                        case m3dcp_i2_t: data = _m3d_getidx(data, 2, &h->cmd[i].arg[k]); break;
-                        case m3dcp_i4_t: data = _m3d_getidx(data, 4, &h->cmd[i].arg[k]); break;
-                        case m3dcp_va_t: data = _m3d_getidx(data, 4, &h->cmd[i].arg[k]);
-                            n = k + 1; l += (h->cmd[i].arg[k] - 1) * (cd->p - k - 1);
-                            h->cmd[i].arg = (uint32_t*)M3D_REALLOC(h->cmd[i].arg, l * sizeof(uint32_t));
-                            if(!h->cmd[i].arg) goto memerr;
-                            memset(&h->cmd[i].arg[k + 1], 0, (l - k - 1) * sizeof(uint32_t));
-                        break;
-                    }
-            }
-        } else
-        /* annotation label list */
-        if(M3D_CHUNKMAGIC(data, 'L','B','L','S')) {
-            data += sizeof(m3dchunk_t);
-            M3D_GETSTR(name);
-            M3D_GETSTR(lang);
-            M3D_LOG("Label list");
-            if(name) { M3D_LOG(name); }
-            if(lang) { M3D_LOG(lang); }
-            if(model->ci_s && model->ci_s < 4 && !model->cmap) model->errcode = M3D_ERR_CMAP;
-            k = 0;
-            switch(model->ci_s) {
-                case 1: k = model->cmap ? model->cmap[data[0]] : 0; data++; break;
-                case 2: k = model->cmap ? model->cmap[*((uint16_t*)data)] : 0; data += 2; break;
-                case 4: k = *((uint32_t*)data); data += 4; break;
-                /* case 8: break; */
-            }
-            reclen = model->vi_s + model->si_s;
-            i = model->numlabel; model->numlabel += len / reclen;
-            model->label = (m3dl_t*)M3D_REALLOC(model->label, model->numlabel * sizeof(m3dl_t));
-            if(!model->label) goto memerr;
-            memset(&model->label[i], 0, (model->numlabel - i) * sizeof(m3dl_t));
-            for(; data < chunk && i < model->numlabel; i++) {
-                model->label[i].name = name;
-                model->label[i].lang = lang;
-                model->label[i].color = k;
-                data = _m3d_getidx(data, model->vi_s, &model->label[i].vertexid);
-                M3D_GETSTR(model->label[i].text);
-            }
-        } else
-        /* action */
-        if(M3D_CHUNKMAGIC(data, 'A','C','T','N')) {
-            M3D_LOG("Action");
-            i = model->numaction++;
-            model->action = (m3da_t*)M3D_REALLOC(model->action, model->numaction * sizeof(m3da_t));
-            if(!model->action) goto memerr;
-            a = &model->action[i];
-            data += sizeof(m3dchunk_t);
-            M3D_GETSTR(a->name);
-            M3D_LOG(a->name);
-            a->numframe = *((uint16_t*)data); data += 2;
-            if(a->numframe < 1) {
-                model->numaction--;
-            } else {
-                a->durationmsec = *((uint32_t*)data); data += 4;
-                a->frame = (m3dfr_t*)M3D_MALLOC(a->numframe * sizeof(m3dfr_t));
-                if(!a->frame) goto memerr;
-                for(i = 0; data < chunk && i < a->numframe; i++) {
-                    a->frame[i].msec = *((uint32_t*)data); data += 4;
-                    a->frame[i].numtransform = 0; a->frame[i].transform = NULL;
-                    data = _m3d_getidx(data, model->fc_s, &a->frame[i].numtransform);
-                    if(a->frame[i].numtransform > 0) {
-                        a->frame[i].transform = (m3dtr_t*)M3D_MALLOC(a->frame[i].numtransform * sizeof(m3dtr_t));
-                        for(j = 0; j < a->frame[i].numtransform; j++) {
-                            data = _m3d_getidx(data, model->bi_s, &a->frame[i].transform[j].boneid);
-                            data = _m3d_getidx(data, model->vi_s, &a->frame[i].transform[j].pos);
-                            data = _m3d_getidx(data, model->vi_s, &a->frame[i].transform[j].ori);
-                        }
-                    }
-                }
-            }
-        } else {
-            i = model->numextra++;
-            model->extra = (m3dchunk_t**)M3D_REALLOC(model->extra, model->numextra * sizeof(m3dchunk_t*));
-            if(!model->extra) goto memerr;
-            model->extra[i] = (m3dchunk_t*)data;
-        }
-    }
-    /* calculate normals, normalize skin weights, create bone/vertex cross-references and calculate transform matrices */
-#ifdef M3D_ASCII
-postprocess:
-#endif
-    if(model) {
-        M3D_LOG("Post-process");
-#ifdef M3D_PROFILING
-        gettimeofday(&tv1, NULL);
-        tvd.tv_sec = tv1.tv_sec - tv0.tv_sec;
-        tvd.tv_usec = tv1.tv_usec - tv0.tv_usec;
-        if(tvd.tv_usec < 0) { tvd.tv_sec--; tvd.tv_usec += 1000000L; }
-        printf("  Parsing chunks  %ld.%06ld sec\n", tvd.tv_sec, tvd.tv_usec);
-#endif
-#ifndef M3D_NONORMALS
-        if(model->numface && model->face && neednorm) {
-            /* if they are missing, calculate triangle normals into a temporary buffer */
-            norm = (m3dv_t*)M3D_MALLOC(model->numface * sizeof(m3dv_t));
-            if(!norm) goto memerr;
-            for(i = 0, n = model->numvertex; i < model->numface; i++)
-                if(model->face[i].normal[0] == M3D_UNDEF) {
-                    v0 = &model->vertex[model->face[i].vertex[0]];
-                    v1 = &model->vertex[model->face[i].vertex[1]];
-                    v2 = &model->vertex[model->face[i].vertex[2]];
-                    va.x = v1->x - v0->x; va.y = v1->y - v0->y; va.z = v1->z - v0->z;
-                    vb.x = v2->x - v0->x; vb.y = v2->y - v0->y; vb.z = v2->z - v0->z;
-                    v0 = &norm[i];
-                    v0->x = (va.y * vb.z) - (va.z * vb.y);
-                    v0->y = (va.z * vb.x) - (va.x * vb.z);
-                    v0->z = (va.x * vb.y) - (va.y * vb.x);
-                    w = _m3d_rsq((v0->x * v0->x) + (v0->y * v0->y) + (v0->z * v0->z));
-                    v0->x *= w; v0->y *= w; v0->z *= w;
-                    model->face[i].normal[0] = model->face[i].vertex[0] + n;
-                    model->face[i].normal[1] = model->face[i].vertex[1] + n;
-                    model->face[i].normal[2] = model->face[i].vertex[2] + n;
-                }
-            /* this is the fast way, we don't care if a normal is repeated in model->vertex */
-            M3D_LOG("Generating normals");
-            model->flags |= M3D_FLG_GENNORM;
-            model->numvertex <<= 1;
-            model->vertex = (m3dv_t*)M3D_REALLOC(model->vertex, model->numvertex * sizeof(m3dv_t));
-            if(!model->vertex) goto memerr;
-            memset(&model->vertex[n], 0, n * sizeof(m3dv_t));
-            for(i = 0; i < model->numface; i++)
-                for(j = 0; j < 3; j++) {
-                    v0 = &model->vertex[model->face[i].vertex[j] + n];
-                    v0->x += norm[i].x;
-                    v0->y += norm[i].y;
-                    v0->z += norm[i].z;
-                }
-            /* for each vertex, take the average of the temporary normals and use that */
-            for(i = 0, v0 = &model->vertex[n]; i < n; i++, v0++) {
-                w = _m3d_rsq((v0->x * v0->x) + (v0->y * v0->y) + (v0->z * v0->z));
-                v0->x *= w; v0->y *= w; v0->z *= w;
-                v0->skinid = M3D_UNDEF;
-            }
-            M3D_FREE(norm);
-        }
-#endif
-        if(model->numbone && model->bone && model->numskin && model->skin && model->numvertex && model->vertex) {
-#ifndef M3D_NOWEIGHTS
-            M3D_LOG("Generating weight cross-reference");
-            for(i = 0; i < model->numvertex; i++) {
-                if(model->vertex[i].skinid < model->numskin) {
-                    sk = &model->skin[model->vertex[i].skinid];
-                    w = (M3D_FLOAT)0.0;
-                    for(j = 0; j < M3D_NUMBONE && sk->boneid[j] != M3D_UNDEF && sk->weight[j] > (M3D_FLOAT)0.0; j++)
-                        w += sk->weight[j];
-                    for(j = 0; j < M3D_NUMBONE && sk->boneid[j] != M3D_UNDEF && sk->weight[j] > (M3D_FLOAT)0.0; j++) {
-                        sk->weight[j] /= w;
-                        b = &model->bone[sk->boneid[j]];
-                        k = b->numweight++;
-                        b->weight = (m3dw_t*)M3D_REALLOC(b->weight, b->numweight * sizeof(m3da_t));
-                        if(!b->weight) goto memerr;
-                        b->weight[k].vertexid = i;
-                        b->weight[k].weight = sk->weight[j];
-                    }
-                }
-            }
-#endif
-#ifndef M3D_NOANIMATION
-            M3D_LOG("Calculating bone transformation matrices");
-            for(i = 0; i < model->numbone; i++) {
-                b = &model->bone[i];
-                if(model->bone[i].parent == M3D_UNDEF) {
-                    _m3d_mat((M3D_FLOAT*)&b->mat4, &model->vertex[b->pos], &model->vertex[b->ori]);
-                } else {
-                    _m3d_mat((M3D_FLOAT*)&r, &model->vertex[b->pos], &model->vertex[b->ori]);
-                    _m3d_mul((M3D_FLOAT*)&b->mat4, (M3D_FLOAT*)&model->bone[b->parent].mat4, (M3D_FLOAT*)&r);
-                }
-            }
-            for(i = 0; i < model->numbone; i++)
-                _m3d_inv((M3D_FLOAT*)&model->bone[i].mat4);
-#endif
-        }
-#ifdef M3D_PROFILING
-        gettimeofday(&tv0, NULL);
-        tvd.tv_sec = tv0.tv_sec - tv1.tv_sec;
-        tvd.tv_usec = tv0.tv_usec - tv1.tv_usec;
-        if(tvd.tv_usec < 0) { tvd.tv_sec--; tvd.tv_usec += 1000000L; }
-        printf("  Post-process    %ld.%06ld sec\n", tvd.tv_sec, tvd.tv_usec);
-#endif
-    }
-    return model;
-}
-
-/**
- * Calculates skeletons for animation frames, returns a working copy (should be freed after use)
- */
-m3dtr_t *m3d_frame(m3d_t *model, M3D_INDEX actionid, M3D_INDEX frameid, m3dtr_t *skeleton)
-{
-    unsigned int i;
-    M3D_INDEX s = frameid;
-    m3dfr_t *fr;
-
-    if(!model || !model->numbone || !model->bone || (actionid != M3D_UNDEF && (!model->action ||
-        actionid >= model->numaction || frameid >= model->action[actionid].numframe))) {
-            model->errcode = M3D_ERR_UNKFRAME;
-            return skeleton;
-    }
-    model->errcode = M3D_SUCCESS;
-    if(!skeleton) {
-        skeleton = (m3dtr_t*)M3D_MALLOC(model->numbone * sizeof(m3dtr_t));
-        if(!skeleton) {
-            model->errcode = M3D_ERR_ALLOC;
-            return NULL;
-        }
-        goto gen;
-    }
-    if(actionid == M3D_UNDEF || !frameid) {
-gen:    s = 0;
-        for(i = 0; i < model->numbone; i++) {
-            skeleton[i].boneid = i;
-            skeleton[i].pos = model->bone[i].pos;
-            skeleton[i].ori = model->bone[i].ori;
-        }
-    }
-    if(actionid < model->numaction && (frameid || !model->action[actionid].frame[0].msec)) {
-        for(; s <= frameid; s++) {
-            fr = &model->action[actionid].frame[s];
-            for(i = 0; i < fr->numtransform; i++) {
-                skeleton[fr->transform[i].boneid].pos = fr->transform[i].pos;
-                skeleton[fr->transform[i].boneid].ori = fr->transform[i].ori;
-            }
-        }
-    }
-    return skeleton;
-}
-
-#ifndef M3D_NOANIMATION
-/**
- * Returns interpolated animation-pose, a working copy (should be freed after use)
- */
-m3db_t *m3d_pose(m3d_t *model, M3D_INDEX actionid, uint32_t msec)
-{
-    unsigned int i, j, l;
-    M3D_FLOAT r[16], t, c, d, s;
-    m3db_t *ret;
-    m3dv_t *v, *p, *f;
-    m3dtr_t *tmp;
-    m3dfr_t *fr;
-
-    if(!model || !model->numbone || !model->bone) {
-        model->errcode = M3D_ERR_UNKFRAME;
-        return NULL;
-    }
-    ret = (m3db_t*)M3D_MALLOC(model->numbone * sizeof(m3db_t));
-    if(!ret) {
-        model->errcode = M3D_ERR_ALLOC;
-        return NULL;
-    }
-    memcpy(ret, model->bone, model->numbone * sizeof(m3db_t));
-    for(i = 0; i < model->numbone; i++)
-        _m3d_inv((M3D_FLOAT*)&ret[i].mat4);
-    if(!model->action || actionid >= model->numaction) {
-        model->errcode = M3D_ERR_UNKFRAME;
-        return ret;
-    }
-    msec %= model->action[actionid].durationmsec;
-    model->errcode = M3D_SUCCESS;
-    fr = &model->action[actionid].frame[0];
-    for(j = l = 0; j < model->action[actionid].numframe && model->action[actionid].frame[j].msec <= msec; j++) {
-        fr = &model->action[actionid].frame[j];
-        l = fr->msec;
-        for(i = 0; i < fr->numtransform; i++) {
-            ret[fr->transform[i].boneid].pos = fr->transform[i].pos;
-            ret[fr->transform[i].boneid].ori = fr->transform[i].ori;
-        }
-    }
-    if(l != msec) {
-        model->vertex = (m3dv_t*)M3D_REALLOC(model->vertex, (model->numvertex + 2 * model->numbone) * sizeof(m3dv_t));
-        if(!model->vertex) {
-            free(ret);
-            model->errcode = M3D_ERR_ALLOC;
-            return NULL;
-        }
-        tmp = (m3dtr_t*)M3D_MALLOC(model->numbone * sizeof(m3dtr_t));
-        if(tmp) {
-            for(i = 0; i < model->numbone; i++) {
-                tmp[i].pos = ret[i].pos;
-                tmp[i].ori = ret[i].ori;
-            }
-            fr = &model->action[actionid].frame[j % model->action[actionid].numframe];
-            t = l >= fr->msec ? (M3D_FLOAT)1.0 : (M3D_FLOAT)(msec - l) / (M3D_FLOAT)(fr->msec - l);
-            for(i = 0; i < fr->numtransform; i++) {
-                tmp[fr->transform[i].boneid].pos = fr->transform[i].pos;
-                tmp[fr->transform[i].boneid].ori = fr->transform[i].ori;
-            }
-            for(i = 0, j = model->numvertex; i < model->numbone; i++) {
-                /* interpolation of position */
-                if(ret[i].pos != tmp[i].pos) {
-                    p = &model->vertex[ret[i].pos];
-                    f = &model->vertex[tmp[i].pos];
-                    v = &model->vertex[j];
-                    v->x = p->x + t * (f->x - p->x);
-                    v->y = p->y + t * (f->y - p->y);
-                    v->z = p->z + t * (f->z - p->z);
-                    ret[i].pos = j++;
-                }
-                /* interpolation of orientation */
-                if(ret[i].ori != tmp[i].ori) {
-                    p = &model->vertex[ret[i].ori];
-                    f = &model->vertex[tmp[i].ori];
-                    v = &model->vertex[j];
-                    d = p->w * f->w + p->x * f->x + p->y * f->y + p->z * f->z;
-                    if(d < 0) { d = -d; s = (M3D_FLOAT)-1.0; } else s = (M3D_FLOAT)1.0;
-#if 0
-                    /* don't use SLERP, requires two more variables, libm linkage and it is slow (but nice) */
-                    a = (M3D_FLOAT)1.0 - t; b = t;
-                    if(d < (M3D_FLOAT)0.999999) { c = acosf(d); b = 1 / sinf(c); a = sinf(a * c) * b; b *= sinf(t * c) * s; }
-                    v->x = p->x * a + f->x * b;
-                    v->y = p->y * a + f->y * b;
-                    v->z = p->z * a + f->z * b;
-                    v->w = p->w * a + f->w * b;
-#else
-                    /* approximated NLERP, original approximation by Arseny Kapoulkine, heavily optimized by me */
-                    c = t - (M3D_FLOAT)0.5; t += t * c * (t - (M3D_FLOAT)1.0) * (((M3D_FLOAT)1.0904 + d * ((M3D_FLOAT)-3.2452 +
-                        d * ((M3D_FLOAT)3.55645 - d * (M3D_FLOAT)1.43519))) * c * c + ((M3D_FLOAT)0.848013 + d *
-                        ((M3D_FLOAT)-1.06021 + d * (M3D_FLOAT)0.215638)));
-                    v->x = p->x + t * (s * f->x - p->x);
-                    v->y = p->y + t * (s * f->y - p->y);
-                    v->z = p->z + t * (s * f->z - p->z);
-                    v->w = p->w + t * (s * f->w - p->w);
-                    d = _m3d_rsq(v->w * v->w + v->x * v->x + v->y * v->y + v->z * v->z);
-                    v->x *= d; v->y *= d; v->z *= d; v->w *= d;
-#endif
-                    ret[i].ori = j++;
-                }
-            }
-            M3D_FREE(tmp);
-        }
-    }
-    for(i = 0; i < model->numbone; i++) {
-        if(ret[i].parent == M3D_UNDEF) {
-            _m3d_mat((M3D_FLOAT*)&ret[i].mat4, &model->vertex[ret[i].pos], &model->vertex[ret[i].ori]);
-        } else {
-            _m3d_mat((M3D_FLOAT*)&r, &model->vertex[ret[i].pos], &model->vertex[ret[i].ori]);
-            _m3d_mul((M3D_FLOAT*)&ret[i].mat4, (M3D_FLOAT*)&ret[ret[i].parent].mat4, (M3D_FLOAT*)&r);
-        }
-    }
-    return ret;
-}
-
-#endif /* M3D_NOANIMATION */
-
-#endif /* M3D_IMPLEMENTATION */
-
-#if !defined(M3D_NODUP) && (!defined(M3D_NOIMPORTER) || defined(M3D_EXPORTER))
-/**
- * Free the in-memory model
- */
-void m3d_free(m3d_t *model)
-{
-    unsigned int i, j;
-
-    if(!model) return;
-#ifdef M3D_ASCII
-    /* if model imported from ASCII, we have to free all strings as well */
-    if(model->flags & M3D_FLG_FREESTR) {
-        if(model->name) M3D_FREE(model->name);
-        if(model->license) M3D_FREE(model->license);
-        if(model->author) M3D_FREE(model->author);
-        if(model->desc) M3D_FREE(model->desc);
-        if(model->bone)
-            for(i = 0; i < model->numbone; i++)
-                if(model->bone[i].name)
-                    M3D_FREE(model->bone[i].name);
-        if(model->shape)
-            for(i = 0; i < model->numshape; i++)
-                if(model->shape[i].name)
-                    M3D_FREE(model->shape[i].name);
-        if(model->material)
-            for(i = 0; i < model->nummaterial; i++)
-                if(model->material[i].name)
-                    M3D_FREE(model->material[i].name);
-        if(model->action)
-            for(i = 0; i < model->numaction; i++)
-                if(model->action[i].name)
-                    M3D_FREE(model->action[i].name);
-        if(model->texture)
-            for(i = 0; i < model->numtexture; i++)
-                if(model->texture[i].name)
-                    M3D_FREE(model->texture[i].name);
-        if(model->inlined)
-            for(i = 0; i < model->numinlined; i++) {
-                if(model->inlined[i].name)
-                    M3D_FREE(model->inlined[i].name);
-                if(model->inlined[i].data)
-                    M3D_FREE(model->inlined[i].data);
-            }
-        if(model->extra)
-            for(i = 0; i < model->numextra; i++)
-                if(model->extra[i])
-                    M3D_FREE(model->extra[i]);
-        if(model->label)
-            for(i = 0; i < model->numlabel; i++) {
-                if(model->label[i].name) {
-                    for(j = i + 1; j < model->numlabel; j++)
-                        if(model->label[j].name == model->label[i].name)
-                            model->label[j].name = NULL;
-                    M3D_FREE(model->label[i].name);
-                }
-                if(model->label[i].lang) {
-                    for(j = i + 1; j < model->numlabel; j++)
-                        if(model->label[j].lang == model->label[i].lang)
-                            model->label[j].lang = NULL;
-                    M3D_FREE(model->label[i].lang);
-                }
-                if(model->label[i].text)
-                    M3D_FREE(model->label[i].text);
-            }
-        if(model->preview.data)
-            M3D_FREE(model->preview.data);
-    }
-#endif
-    if(model->flags & M3D_FLG_FREERAW) M3D_FREE(model->raw);
-
-    if(model->tmap) M3D_FREE(model->tmap);
-    if(model->bone) {
-        for(i = 0; i < model->numbone; i++)
-            if(model->bone[i].weight)
-                M3D_FREE(model->bone[i].weight);
-        M3D_FREE(model->bone);
-    }
-    if(model->skin) M3D_FREE(model->skin);
-    if(model->vertex) M3D_FREE(model->vertex);
-    if(model->face) M3D_FREE(model->face);
-    if(model->shape) {
-        for(i = 0; i < model->numshape; i++) {
-            if(model->shape[i].cmd) {
-                for(j = 0; j < model->shape[i].numcmd; j++)
-                    if(model->shape[i].cmd[j].arg) M3D_FREE(model->shape[i].cmd[j].arg);
-                M3D_FREE(model->shape[i].cmd);
-            }
-        }
-        M3D_FREE(model->shape);
-    }
-    if(model->material && !(model->flags & M3D_FLG_MTLLIB)) {
-        for(i = 0; i < model->nummaterial; i++)
-            if(model->material[i].prop) M3D_FREE(model->material[i].prop);
-        M3D_FREE(model->material);
-    }
-    if(model->texture) {
-        for(i = 0; i < model->numtexture; i++)
-            if(model->texture[i].d) M3D_FREE(model->texture[i].d);
-        M3D_FREE(model->texture);
-    }
-    if(model->action) {
-        for(i = 0; i < model->numaction; i++) {
-            if(model->action[i].frame) {
-                for(j = 0; j < model->action[i].numframe; j++)
-                    if(model->action[i].frame[j].transform) M3D_FREE(model->action[i].frame[j].transform);
-                M3D_FREE(model->action[i].frame);
-            }
-        }
-        M3D_FREE(model->action);
-    }
-    if(model->label) M3D_FREE(model->label);
-    if(model->inlined) M3D_FREE(model->inlined);
-    if(model->extra) M3D_FREE(model->extra);
-    free(model);
-}
-#endif
-
-#ifdef M3D_EXPORTER
-typedef struct {
-    char *str;
-    uint32_t offs;
-} m3dstr_t;
-
-typedef struct {
-    m3dti_t data;
-    M3D_INDEX oldidx;
-    M3D_INDEX newidx;
-} m3dtisave_t;
-
-typedef struct {
-    m3dv_t data;
-    M3D_INDEX oldidx;
-    M3D_INDEX newidx;
-    unsigned char norm;
-} m3dvsave_t;
-
-typedef struct {
-    m3ds_t data;
-    M3D_INDEX oldidx;
-    M3D_INDEX newidx;
-} m3dssave_t;
-
-typedef struct {
-    m3df_t data;
-    int group;
-    uint8_t opacity;
-} m3dfsave_t;
-
-/* create unique list of strings */
-static m3dstr_t *_m3d_addstr(m3dstr_t *str, uint32_t *numstr, char *s)
-{
-    uint32_t i;
-    if(!s || !*s) return str;
-    if(str) {
-        for(i = 0; i < *numstr; i++)
-            if(str[i].str == s || !strcmp(str[i].str, s)) return str;
-    }
-    str = (m3dstr_t*)M3D_REALLOC(str, ((*numstr) + 1) * sizeof(m3dstr_t));
-    str[*numstr].str = s;
-    str[*numstr].offs = 0;
-    (*numstr)++;
-    return str;
-}
-
-/* add strings to header */
-m3dhdr_t *_m3d_addhdr(m3dhdr_t *h, m3dstr_t *s)
-{
-    int i;
-    char *safe = _m3d_safestr(s->str, 0);
-    i = (int)strlen(safe);
-    h = (m3dhdr_t*)M3D_REALLOC(h, h->length + i+1);
-    if(!h) { M3D_FREE(safe); return NULL; }
-    memcpy((uint8_t*)h + h->length, safe, i+1);
-    s->offs = h->length - 16;
-    h->length += i+1;
-    M3D_FREE(safe);
-    return h;
-}
-
-/* return offset of string */
-static uint32_t _m3d_stridx(m3dstr_t *str, uint32_t numstr, char *s)
-{
-    uint32_t i;
-    char *safe;
-    if(!s || !*s) return 0;
-    if(str) {
-        safe = _m3d_safestr(s, 0);
-        if(!safe) return 0;
-        if(!*safe) {
-            free(safe);
-            return 0;
-        }
-        for(i = 0; i < numstr; i++)
-            if(!strcmp(str[i].str, s)) {
-                free(safe);
-                return str[i].offs;
-            }
-        free(safe);
-    }
-    return 0;
-}
-
-/* compare to faces by their material */
-static int _m3d_facecmp(const void *a, const void *b) {
-    const m3dfsave_t *A = (const m3dfsave_t*)a, *B = (const m3dfsave_t*)b;
-    return A->group != B->group ? A->group - B->group : (A->opacity != B->opacity ? (int)B->opacity - (int)A->opacity :
-        (int)A->data.materialid - (int)B->data.materialid);
-}
-/* compare face groups */
-static int _m3d_grpcmp(const void *a, const void *b) { return *((uint32_t*)a) - *((uint32_t*)b); }
-/* compare UVs */
-static int _m3d_ticmp(const void *a, const void *b) { return memcmp(a, b, sizeof(m3dti_t)); }
-/* compare skin groups */
-static int _m3d_skincmp(const void *a, const void *b) { return memcmp(a, b, sizeof(m3ds_t)); }
-/* compare vertices */
-static int _m3d_vrtxcmp(const void *a, const void *b) {
-    int c = memcmp(a, b, 3 * sizeof(M3D_FLOAT));
-    if(c) return c;
-    c = ((m3dvsave_t*)a)->norm - ((m3dvsave_t*)b)->norm;
-    if(c) return c;
-    return memcmp(a, b, sizeof(m3dv_t));
-}
-/* compare labels */
-static _inline int _m3d_strcmp(char *a, char *b)
-{
-    if(a == NULL && b != NULL) return -1;
-    if(a != NULL && b == NULL) return 1;
-    if(a == NULL && b == NULL) return 0;
-    return strcmp(a, b);
-}
-static int _m3d_lblcmp(const void *a, const void *b) {
-    const m3dl_t *A = (const m3dl_t*)a, *B = (const m3dl_t*)b;
-    int c = _m3d_strcmp(A->lang, B->lang);
-    if(!c) c = _m3d_strcmp(A->name, B->name);
-    if(!c) c = _m3d_strcmp(A->text, B->text);
-    return c;
-}
-/* compare two colors by HSV value */
-_inline static int _m3d_cmapcmp(const void *a, const void *b)
-{
-    uint8_t *A = (uint8_t*)a,  *B = (uint8_t*)b;
-    _register int m, vA, vB;
-    /* get HSV value for A */
-    m = A[2] < A[1]? A[2] : A[1]; if(A[0] < m) m = A[0];
-    vA = A[2] > A[1]? A[2] : A[1]; if(A[0] > vA) vA = A[0];
-    /* get HSV value for B */
-    m = B[2] < B[1]? B[2] : B[1]; if(B[0] < m) m = B[0];
-    vB = B[2] > B[1]? B[2] : B[1]; if(B[0] > vB) vB = B[0];
-    return vA - vB;
-}
-
-/* create sorted list of colors */
-static uint32_t *_m3d_addcmap(uint32_t *cmap, uint32_t *numcmap, uint32_t color)
-{
-    uint32_t i;
-    if(cmap) {
-        for(i = 0; i < *numcmap; i++)
-            if(cmap[i] == color) return cmap;
-    }
-    cmap = (uint32_t*)M3D_REALLOC(cmap, ((*numcmap) + 1) * sizeof(uint32_t));
-    for(i = 0; i < *numcmap && _m3d_cmapcmp(&color, &cmap[i]) > 0; i++);
-    if(i < *numcmap) memmove(&cmap[i+1], &cmap[i], ((*numcmap) - i)*sizeof(uint32_t));
-    cmap[i] = color;
-    (*numcmap)++;
-    return cmap;
-}
-
-/* look up a color and return its index */
-static uint32_t _m3d_cmapidx(uint32_t *cmap, uint32_t numcmap, uint32_t color)
-{
-    uint32_t i;
-    if(numcmap >= 65536)
-        return color;
-    for(i = 0; i < numcmap; i++)
-        if(cmap[i] == color) return i;
-    return 0;
-}
-
-/* add index to output */
-static unsigned char *_m3d_addidx(unsigned char *out, char type, uint32_t idx) {
-    switch(type) {
-        case 1: *out++ = (uint8_t)(idx); break;
-        case 2: *((uint16_t*)out) = (uint16_t)(idx); out += 2; break;
-        case 4: *((uint32_t*)out) = (uint32_t)(idx); out += 4; break;
-        /* case 0: case 8: break; */
-    }
-    return out;
-}
-
-/* round a vertex position */
-static void _m3d_round(int quality, m3dv_t *src, m3dv_t *dst)
-{
-    _register int t;
-    /* copy additional attributes */
-    if(src != dst) memcpy(dst, src, sizeof(m3dv_t));
-    /* round according to quality */
-    switch(quality) {
-        case M3D_EXP_INT8:
-            t = (int)(src->x * 127 + (src->x >= 0 ? (M3D_FLOAT)0.5 : (M3D_FLOAT)-0.5)); dst->x = (M3D_FLOAT)t / (M3D_FLOAT)127.0;
-            t = (int)(src->y * 127 + (src->y >= 0 ? (M3D_FLOAT)0.5 : (M3D_FLOAT)-0.5)); dst->y = (M3D_FLOAT)t / (M3D_FLOAT)127.0;
-            t = (int)(src->z * 127 + (src->z >= 0 ? (M3D_FLOAT)0.5 : (M3D_FLOAT)-0.5)); dst->z = (M3D_FLOAT)t / (M3D_FLOAT)127.0;
-            t = (int)(src->w * 127 + (src->w >= 0 ? (M3D_FLOAT)0.5 : (M3D_FLOAT)-0.5)); dst->w = (M3D_FLOAT)t / (M3D_FLOAT)127.0;
-        break;
-        case M3D_EXP_INT16:
-            t = (int)(src->x * 32767 + (src->x >= 0 ? (M3D_FLOAT)0.5 : (M3D_FLOAT)-0.5)); dst->x = (M3D_FLOAT)t / (M3D_FLOAT)32767.0;
-            t = (int)(src->y * 32767 + (src->y >= 0 ? (M3D_FLOAT)0.5 : (M3D_FLOAT)-0.5)); dst->y = (M3D_FLOAT)t / (M3D_FLOAT)32767.0;
-            t = (int)(src->z * 32767 + (src->z >= 0 ? (M3D_FLOAT)0.5 : (M3D_FLOAT)-0.5)); dst->z = (M3D_FLOAT)t / (M3D_FLOAT)32767.0;
-            t = (int)(src->w * 32767 + (src->w >= 0 ? (M3D_FLOAT)0.5 : (M3D_FLOAT)-0.5)); dst->w = (M3D_FLOAT)t / (M3D_FLOAT)32767.0;
-        break;
-    }
-    if(dst->x == (M3D_FLOAT)-0.0) dst->x = (M3D_FLOAT)0.0;
-    if(dst->y == (M3D_FLOAT)-0.0) dst->y = (M3D_FLOAT)0.0;
-    if(dst->z == (M3D_FLOAT)-0.0) dst->z = (M3D_FLOAT)0.0;
-    if(dst->w == (M3D_FLOAT)-0.0) dst->w = (M3D_FLOAT)0.0;
-}
-
-#ifdef M3D_ASCII
-/* add a bone to ascii output */
-static char *_m3d_prtbone(char *ptr, m3db_t *bone, M3D_INDEX numbone, M3D_INDEX parent, uint32_t level, M3D_INDEX *vrtxidx)
-{
-    uint32_t i, j;
-    char *sn;
-
-    if(level > M3D_BONEMAXLEVEL || !bone) return ptr;
-    for(i = 0; i < numbone; i++) {
-        if(bone[i].parent == parent) {
-            for(j = 0; j < level; j++) *ptr++ = '/';
-            sn = _m3d_safestr(bone[i].name, 0);
-            ptr += sprintf(ptr, "%d %d %s\r\n", vrtxidx[bone[i].pos], vrtxidx[bone[i].ori], sn);
-            M3D_FREE(sn);
-            ptr = _m3d_prtbone(ptr, bone, numbone, i, level + 1, vrtxidx);
-        }
-    }
-    return ptr;
-}
-#endif
-
-/**
- * Function to encode an in-memory model into on storage Model 3D format
- */
-unsigned char *m3d_save(m3d_t *model, int quality, int flags, unsigned int *size)
-{
-#ifdef M3D_ASCII
-    const char *ol;
-    char *ptr;
-#endif
-    char vc_s, vi_s, si_s, ci_s, ti_s, bi_s, nb_s, sk_s, fc_s, hi_s, fi_s;
-    char *sn = NULL, *sl = NULL, *sa = NULL, *sd = NULL;
-    unsigned char *out = NULL, *z = NULL, weights[M3D_NUMBONE], *norm = NULL;
-    unsigned int i, j, k, l, n, len, chunklen, *length;
-    M3D_FLOAT scale = (M3D_FLOAT)0.0, min_x, max_x, min_y, max_y, min_z, max_z;
-    M3D_INDEX last, *vrtxidx = NULL, *mtrlidx = NULL, *tmapidx = NULL, *skinidx = NULL;
-    uint32_t idx, numcmap = 0, *cmap = NULL, numvrtx = 0, maxvrtx = 0, numtmap = 0, maxtmap = 0, numproc = 0;
-    uint32_t numskin = 0, maxskin = 0, numstr = 0, maxt = 0, maxbone = 0, numgrp = 0, maxgrp = 0, *grpidx = NULL;
-    uint8_t *opa;
-    m3dcd_t *cd;
-    m3dc_t *cmd;
-    m3dstr_t *str = NULL;
-    m3dvsave_t *vrtx = NULL, vertex;
-    m3dtisave_t *tmap = NULL, tcoord;
-    m3dssave_t *skin = NULL, sk;
-    m3dfsave_t *face = NULL;
-    m3dhdr_t *h = NULL;
-    m3dm_t *m;
-    m3da_t *a;
-
-    if(!model) {
-        if(size) *size = 0;
-        return NULL;
-    }
-    model->errcode = M3D_SUCCESS;
-#ifdef M3D_ASCII
-    if(flags & M3D_EXP_ASCII) quality = M3D_EXP_DOUBLE;
-#endif
-    vrtxidx = (M3D_INDEX*)M3D_MALLOC(model->numvertex * sizeof(M3D_INDEX));
-    if(!vrtxidx) goto memerr;
-    memset(vrtxidx, 255, model->numvertex * sizeof(M3D_INDEX));
-    if(model->numvertex && !(flags & M3D_EXP_NONORMAL)){
-        norm = (unsigned char*)M3D_MALLOC(model->numvertex * sizeof(unsigned char));
-        if(!norm) goto memerr;
-        memset(norm, 0, model->numvertex * sizeof(unsigned char));
-    }
-    if(model->nummaterial && !(flags & M3D_EXP_NOMATERIAL)) {
-        mtrlidx = (M3D_INDEX*)M3D_MALLOC(model->nummaterial * sizeof(M3D_INDEX));
-        if(!mtrlidx) goto memerr;
-        memset(mtrlidx, 255, model->nummaterial * sizeof(M3D_INDEX));
-        opa = (uint8_t*)M3D_MALLOC(model->nummaterial * 2 * sizeof(M3D_INDEX));
-        if(!opa) goto memerr;
-        memset(opa, 255, model->nummaterial * 2 * sizeof(M3D_INDEX));
-    }
-    if(model->numtmap && !(flags & M3D_EXP_NOTXTCRD)) {
-        tmapidx = (M3D_INDEX*)M3D_MALLOC(model->numtmap * sizeof(M3D_INDEX));
-        if(!tmapidx) goto memerr;
-        memset(tmapidx, 255, model->numtmap * sizeof(M3D_INDEX));
-    }
-    /** collect array elements that are actually referenced **/
-    if(!(flags & M3D_EXP_NOFACE)) {
-        /* face */
-        if(model->numface && model->face) {
-            M3D_LOG("Processing mesh face");
-            face = (m3dfsave_t*)M3D_MALLOC(model->numface * sizeof(m3dfsave_t));
-            if(!face) goto memerr;
-            for(i = 0; i < model->numface; i++) {
-                memcpy(&face[i].data, &model->face[i], sizeof(m3df_t));
-                face[i].group = 0;
-                face[i].opacity = 255;
-                if(!(flags & M3D_EXP_NOMATERIAL) && model->face[i].materialid < model->nummaterial) {
-                    if(model->material[model->face[i].materialid].numprop) {
-                        mtrlidx[model->face[i].materialid] = 0;
-                        if(opa[model->face[i].materialid * 2]) {
-                            m = &model->material[model->face[i].materialid];
-                            for(j = 0; j < m->numprop; j++)
-                                if(m->prop[j].type == m3dp_Kd) {
-                                    opa[model->face[i].materialid * 2 + 1] = ((uint8_t*)&m->prop[j].value.color)[3];
-                                    break;
-                                }
-                            for(j = 0; j < m->numprop; j++)
-                                if(m->prop[j].type == m3dp_d) {
-                                    opa[model->face[i].materialid * 2 + 1] = (uint8_t)(m->prop[j].value.fnum * 255);
-                                    break;
-                                }
-                            opa[model->face[i].materialid * 2] = 0;
-                        }
-                        face[i].opacity = opa[model->face[i].materialid * 2 + 1];
-                    } else
-                        face[i].data.materialid = M3D_UNDEF;
-                }
-                for(j = 0; j < 3; j++) {
-                    k = model->face[i].vertex[j];
-                    if(k < model->numvertex)
-                        vrtxidx[k] = 0;
-                    if(!(flags & M3D_EXP_NOCMAP)) {
-                        cmap = _m3d_addcmap(cmap, &numcmap, model->vertex[k].color);
-                        if(!cmap) goto memerr;
-                    }
-                    k = model->face[i].normal[j];
-                    if(k < model->numvertex && !(flags & M3D_EXP_NONORMAL)) {
-                        vrtxidx[k] = 0;
-                        norm[k] = 1;
-                    }
-                    k = model->face[i].texcoord[j];
-                    if(k < model->numtmap && !(flags & M3D_EXP_NOTXTCRD))
-                        tmapidx[k] = 0;
-                }
-                /* convert from CW to CCW */
-                if(flags & M3D_EXP_IDOSUCK) {
-                    j = face[i].data.vertex[1];
-                    face[i].data.vertex[1] = face[i].data.vertex[2];
-                    face[i].data.vertex[2] = face[i].data.vertex[1];
-                    j = face[i].data.normal[1];
-                    face[i].data.normal[1] = face[i].data.normal[2];
-                    face[i].data.normal[2] = face[i].data.normal[1];
-                    j = face[i].data.texcoord[1];
-                    face[i].data.texcoord[1] = face[i].data.texcoord[2];
-                    face[i].data.texcoord[2] = face[i].data.texcoord[1];
-                }
-            }
-        }
-        if(model->numshape && model->shape) {
-            M3D_LOG("Processing shape face");
-            for(i = 0; i < model->numshape; i++) {
-                if(!model->shape[i].numcmd) continue;
-                str = _m3d_addstr(str, &numstr, model->shape[i].name);
-                if(!str) goto memerr;
-                for(j = 0; j < model->shape[i].numcmd; j++) {
-                    cmd = &model->shape[i].cmd[j];
-                    if(cmd->type >= (unsigned int)(sizeof(m3d_commandtypes)/sizeof(m3d_commandtypes[0])) || !cmd->arg)
-                        continue;
-                    if(cmd->type == m3dc_mesh) {
-                        if(numgrp + 2 < maxgrp) {
-                            maxgrp += 1024;
-                            grpidx = (uint32_t*)realloc(grpidx, maxgrp * sizeof(uint32_t));
-                            if(!grpidx) goto memerr;
-                            if(!numgrp) {
-                                grpidx[0] = 0;
-                                grpidx[1] = model->numface;
-                                numgrp += 2;
-                            }
-                        }
-                        grpidx[numgrp + 0] = cmd->arg[0];
-                        grpidx[numgrp + 1] = cmd->arg[0] + cmd->arg[1];
-                        numgrp += 2;
-                    }
-                    cd = &m3d_commandtypes[cmd->type];
-                    for(k = n = 0, l = cd->p; k < l; k++)
-                        switch(cd->a[((k - n) % (cd->p - n)) + n]) {
-                            case m3dcp_mi_t:
-                                if(!(flags & M3D_EXP_NOMATERIAL) && cmd->arg[k] < model->nummaterial)
-                                    mtrlidx[cmd->arg[k]] = 0;
-                            break;
-                            case m3dcp_ti_t:
-                                if(!(flags & M3D_EXP_NOTXTCRD) && cmd->arg[k] < model->numtmap)
-                                    tmapidx[cmd->arg[k]] = 0;
-                            break;
-                            case m3dcp_qi_t:
-                            case m3dcp_vi_t:
-                                if(cmd->arg[k] < model->numvertex)
-                                    vrtxidx[cmd->arg[k]] = 0;
-                            break;
-                            case m3dcp_va_t:
-                                n = k + 1; l += (cmd->arg[k] - 1) * (cd->p - k - 1);
-                            break;
-                        }
-                }
-            }
-        }
-        if(model->numface && face) {
-            if(numgrp && grpidx) {
-                qsort(grpidx, numgrp, sizeof(uint32_t), _m3d_grpcmp);
-                for(i = j = 0; i < model->numface && j < numgrp; i++) {
-                    while(j < numgrp && grpidx[j] < i) j++;
-                    face[i].group = j;
-                }
-            }
-            qsort(face, model->numface, sizeof(m3dfsave_t), _m3d_facecmp);
-        }
-        if(grpidx) { M3D_FREE(grpidx); grpidx = NULL; }
-        if(model->numlabel && model->label) {
-            M3D_LOG("Processing annotation labels");
-            for(i = 0; i < model->numlabel; i++) {
-                str = _m3d_addstr(str, &numstr, model->label[i].name);
-                str = _m3d_addstr(str, &numstr, model->label[i].lang);
-                str = _m3d_addstr(str, &numstr, model->label[i].text);
-                if(!(flags & M3D_EXP_NOCMAP)) {
-                    cmap = _m3d_addcmap(cmap, &numcmap, model->label[i].color);
-                    if(!cmap) goto memerr;
-                }
-                if(model->label[i].vertexid < model->numvertex)
-                    vrtxidx[model->label[i].vertexid] = 0;
-            }
-            qsort(model->label, model->numlabel, sizeof(m3dl_t), _m3d_lblcmp);
-        }
-    } else if(!(flags & M3D_EXP_NOMATERIAL)) {
-        /* without a face, simply add all materials, because it can be an mtllib */
-        for(i = 0; i < model->nummaterial; i++)
-            mtrlidx[i] = i;
-    }
-    /* bind-pose skeleton */
-    if(model->numbone && model->bone && !(flags & M3D_EXP_NOBONE)) {
-        M3D_LOG("Processing bones");
-        for(i = 0; i < model->numbone; i++) {
-            str = _m3d_addstr(str, &numstr, model->bone[i].name);
-            if(!str) goto memerr;
-            k = model->bone[i].pos;
-            if(k < model->numvertex)
-                vrtxidx[k] = 0;
-            k = model->bone[i].ori;
-            if(k < model->numvertex)
-                vrtxidx[k] = 0;
-        }
-    }
-    /* actions, animated skeleton poses */
-    if(model->numaction && model->action && !(flags & M3D_EXP_NOACTION)) {
-        M3D_LOG("Processing action list");
-        for(j = 0; j < model->numaction; j++) {
-            a = &model->action[j];
-            str = _m3d_addstr(str, &numstr, a->name);
-            if(!str) goto memerr;
-            if(a->numframe > 65535) a->numframe = 65535;
-            for(i = 0; i < a->numframe; i++) {
-                for(l = 0; l < a->frame[i].numtransform; l++) {
-                    k = a->frame[i].transform[l].pos;
-                    if(k < model->numvertex)
-                        vrtxidx[k] = 0;
-                    k = a->frame[i].transform[l].ori;
-                    if(k < model->numvertex)
-                        vrtxidx[k] = 0;
-                }
-                if(l > maxt) maxt = l;
-            }
-        }
-    }
-    /* add colors to color map and texture names to string table */
-    if(!(flags & M3D_EXP_NOMATERIAL)) {
-        M3D_LOG("Processing materials");
-        for(i = k = 0; i < model->nummaterial; i++) {
-            if(mtrlidx[i] == M3D_UNDEF || !model->material[i].numprop) continue;
-            mtrlidx[i] = k++;
-            m = &model->material[i];
-            str = _m3d_addstr(str, &numstr, m->name);
-            if(!str) goto memerr;
-            if(m->prop)
-                for(j = 0; j < m->numprop; j++) {
-                    if(!(flags & M3D_EXP_NOCMAP) && m->prop[j].type < 128) {
-                        for(l = 0; l < sizeof(m3d_propertytypes)/sizeof(m3d_propertytypes[0]); l++) {
-                            if(m->prop[j].type == m3d_propertytypes[l].id && m3d_propertytypes[l].format == m3dpf_color) {
-                                ((uint8_t*)&m->prop[j].value.color)[3] = opa[i * 2 + 1];
-                                cmap = _m3d_addcmap(cmap, &numcmap, m->prop[j].value.color);
-                                if(!cmap) goto memerr;
-                                break;
-                            }
-                        }
-                    }
-                    if(m->prop[j].type >= 128 && m->prop[j].value.textureid < model->numtexture &&
-                        model->texture[m->prop[j].value.textureid].name) {
-                        str = _m3d_addstr(str, &numstr, model->texture[m->prop[j].value.textureid].name);
-                        if(!str) goto memerr;
-                    }
-                }
-        }
-    }
-    /* if there's only one black color, don't store it */
-    if(numcmap == 1 && cmap && !cmap[0]) numcmap = 0;
-
-    /** compress lists **/
-    if(model->numtmap && !(flags & M3D_EXP_NOTXTCRD)) {
-        M3D_LOG("Compressing tmap");
-        tmap = (m3dtisave_t*)M3D_MALLOC(model->numtmap * sizeof(m3dtisave_t));
-        if(!tmap) goto memerr;
-        for(i = 0; i < model->numtmap; i++) {
-            if(tmapidx[i] == M3D_UNDEF) continue;
-            switch(quality) {
-                case M3D_EXP_INT8:
-                    l = (unsigned int)(model->tmap[i].u * 255); tcoord.data.u = (M3D_FLOAT)l / (M3D_FLOAT)255.0;
-                    l = (unsigned int)(model->tmap[i].v * 255); tcoord.data.v = (M3D_FLOAT)l / (M3D_FLOAT)255.0;
-                break;
-                case M3D_EXP_INT16:
-                    l = (unsigned int)(model->tmap[i].u * 65535); tcoord.data.u = (M3D_FLOAT)l / (M3D_FLOAT)65535.0;
-                    l = (unsigned int)(model->tmap[i].v * 65535); tcoord.data.v = (M3D_FLOAT)l / (M3D_FLOAT)65535.0;
-                break;
-                default:
-                    tcoord.data.u = model->tmap[i].u;
-                    tcoord.data.v = model->tmap[i].v;
-                break;
-            }
-            if(flags & M3D_EXP_FLIPTXTCRD)
-                tcoord.data.v = (M3D_FLOAT)1.0 - tcoord.data.v;
-            tcoord.oldidx = i;
-            memcpy(&tmap[numtmap++], &tcoord, sizeof(m3dtisave_t));
-        }
-        if(numtmap) {
-            qsort(tmap, numtmap, sizeof(m3dtisave_t), _m3d_ticmp);
-            memcpy(&tcoord.data, &tmap[0], sizeof(m3dti_t));
-            for(i = 0; i < numtmap; i++) {
-                if(memcmp(&tcoord.data, &tmap[i].data, sizeof(m3dti_t))) {
-                    memcpy(&tcoord.data, &tmap[i].data, sizeof(m3dti_t));
-                    maxtmap++;
-                }
-                tmap[i].newidx = maxtmap;
-                tmapidx[tmap[i].oldidx] = maxtmap;
-            }
-            maxtmap++;
-        }
-    }
-    if(model->numskin && model->skin && !(flags & M3D_EXP_NOBONE)) {
-        M3D_LOG("Compressing skin");
-        skinidx = (M3D_INDEX*)M3D_MALLOC(model->numskin * sizeof(M3D_INDEX));
-        if(!skinidx) goto memerr;
-        skin = (m3dssave_t*)M3D_MALLOC(model->numskin * sizeof(m3dssave_t));
-        if(!skin) goto memerr;
-        memset(skinidx, 255, model->numskin * sizeof(M3D_INDEX));
-        for(i = 0; i < model->numvertex; i++) {
-            if(vrtxidx[i] != M3D_UNDEF && model->vertex[i].skinid < model->numskin)
-                skinidx[model->vertex[i].skinid] = 0;
-        }
-        for(i = 0; i < model->numskin; i++) {
-            if(skinidx[i] == M3D_UNDEF) continue;
-            memset(&sk, 0, sizeof(m3dssave_t));
-            for(j = 0, min_x = (M3D_FLOAT)0.0; j < M3D_NUMBONE && model->skin[i].boneid[j] != M3D_UNDEF &&
-                model->skin[i].weight[j] > (M3D_FLOAT)0.0; j++) {
-                    sk.data.boneid[j] = model->skin[i].boneid[j];
-                    sk.data.weight[j] = model->skin[i].weight[j];
-                    min_x += sk.data.weight[j];
-            }
-            if(j > maxbone) maxbone = j;
-            if(min_x != (M3D_FLOAT)1.0 && min_x != (M3D_FLOAT)0.0)
-                for(j = 0; j < M3D_NUMBONE && sk.data.weight[j] > (M3D_FLOAT)0.0; j++)
-                    sk.data.weight[j] /= min_x;
-            sk.oldidx = i;
-            memcpy(&skin[numskin++], &sk, sizeof(m3dssave_t));
-        }
-        if(numskin) {
-            qsort(skin, numskin, sizeof(m3dssave_t), _m3d_skincmp);
-            memcpy(&sk.data, &skin[0].data, sizeof(m3ds_t));
-            for(i = 0; i < numskin; i++) {
-                if(memcmp(&sk.data, &skin[i].data, sizeof(m3ds_t))) {
-                    memcpy(&sk.data, &skin[i].data, sizeof(m3ds_t));
-                    maxskin++;
-                }
-                skin[i].newidx = maxskin;
-                skinidx[skin[i].oldidx] = maxskin;
-            }
-            maxskin++;
-        }
-    }
-
-    M3D_LOG("Compressing vertex list");
-    min_x = min_y = min_z = (M3D_FLOAT)1e10;
-    max_x = max_y = max_z = (M3D_FLOAT)-1e10;
-    if(vrtxidx) {
-        vrtx = (m3dvsave_t*)M3D_MALLOC(model->numvertex * sizeof(m3dvsave_t));
-        if(!vrtx) goto memerr;
-        for(i = numvrtx = 0; i < model->numvertex; i++) {
-            if(vrtxidx[i] == M3D_UNDEF) continue;
-            _m3d_round(quality, &model->vertex[i], &vertex.data);
-            vertex.norm = norm ? norm[i] : 0;
-            if(vertex.data.skinid != M3D_INDEXMAX && !vertex.norm) {
-                vertex.data.skinid = vertex.data.skinid != M3D_UNDEF && skinidx ? skinidx[vertex.data.skinid] : M3D_UNDEF;
-                if(vertex.data.x > max_x) max_x = vertex.data.x;
-                if(vertex.data.x < min_x) min_x = vertex.data.x;
-                if(vertex.data.y > max_y) max_y = vertex.data.y;
-                if(vertex.data.y < min_y) min_y = vertex.data.y;
-                if(vertex.data.z > max_z) max_z = vertex.data.z;
-                if(vertex.data.z < min_z) min_z = vertex.data.z;
-            }
-#ifdef M3D_VERTEXTYPE
-            vertex.data.type = 0;
-#endif
-            vertex.oldidx = i;
-            memcpy(&vrtx[numvrtx++], &vertex, sizeof(m3dvsave_t));
-        }
-        if(numvrtx) {
-            qsort(vrtx, numvrtx, sizeof(m3dvsave_t), _m3d_vrtxcmp);
-            memcpy(&vertex.data, &vrtx[0].data, sizeof(m3dv_t));
-            for(i = 0; i < numvrtx; i++) {
-                if(memcmp(&vertex.data, &vrtx[i].data, vrtx[i].norm ? 3 * sizeof(M3D_FLOAT) : sizeof(m3dv_t))) {
-                    memcpy(&vertex.data, &vrtx[i].data, sizeof(m3dv_t));
-                    maxvrtx++;
-                }
-                vrtx[i].newidx = maxvrtx;
-                vrtxidx[vrtx[i].oldidx] = maxvrtx;
-            }
-            maxvrtx++;
-        }
-    }
-    if(skinidx) { M3D_FREE(skinidx); skinidx = NULL; }
-    if(norm) { M3D_FREE(norm); norm = NULL; }
-
-    /* normalize to bounding cube */
-    if(numvrtx && !(flags & M3D_EXP_NORECALC)) {
-        M3D_LOG("Normalizing coordinates");
-        if(min_x < (M3D_FLOAT)0.0) min_x = -min_x;
-        if(max_x < (M3D_FLOAT)0.0) max_x = -max_x;
-        if(min_y < (M3D_FLOAT)0.0) min_y = -min_y;
-        if(max_y < (M3D_FLOAT)0.0) max_y = -max_y;
-        if(min_z < (M3D_FLOAT)0.0) min_z = -min_z;
-        if(max_z < (M3D_FLOAT)0.0) max_z = -max_z;
-        scale = min_x;
-        if(max_x > scale) scale = max_x;
-        if(min_y > scale) scale = min_y;
-        if(max_y > scale) scale = max_y;
-        if(min_z > scale) scale = min_z;
-        if(max_z > scale) scale = max_z;
-        if(scale == (M3D_FLOAT)0.0) scale = (M3D_FLOAT)1.0;
-        if(scale != (M3D_FLOAT)1.0) {
-            for(i = 0; i < numvrtx; i++) {
-                if(vrtx[i].data.skinid == M3D_INDEXMAX) continue;
-                vrtx[i].data.x /= scale;
-                vrtx[i].data.y /= scale;
-                vrtx[i].data.z /= scale;
-            }
-        }
-    }
-    if(model->scale > (M3D_FLOAT)0.0) scale = model->scale;
-    if(scale <= (M3D_FLOAT)0.0) scale = (M3D_FLOAT)1.0;
-
-    /* meta info */
-    sn = _m3d_safestr(model->name && *model->name ? model->name : (char*)"(noname)", 2);
-    sl = _m3d_safestr(model->license ? model->license : (char*)"MIT", 2);
-    sa = _m3d_safestr(model->author ? model->author : getenv("LOGNAME"), 2);
-    if(!sn || !sl || !sa) {
-memerr: if(vrtxidx) M3D_FREE(vrtxidx);
-        if(mtrlidx) M3D_FREE(mtrlidx);
-        if(tmapidx) M3D_FREE(tmapidx);
-        if(skinidx) M3D_FREE(skinidx);
-        if(grpidx) M3D_FREE(grpidx);
-        if(norm) M3D_FREE(norm);
-        if(face) M3D_FREE(face);
-        if(cmap) M3D_FREE(cmap);
-        if(tmap) M3D_FREE(tmap);
-        if(skin) M3D_FREE(skin);
-        if(str) M3D_FREE(str);
-        if(vrtx) M3D_FREE(vrtx);
-        if(sn) M3D_FREE(sn);
-        if(sl) M3D_FREE(sl);
-        if(sa) M3D_FREE(sa);
-        if(sd) M3D_FREE(sd);
-        if(out) M3D_FREE(out);
-        if(h) M3D_FREE(h);
-        M3D_LOG("Out of memory");
-        model->errcode = M3D_ERR_ALLOC;
-        return NULL;
-    }
-
-    M3D_LOG("Serializing model");
-#ifdef M3D_ASCII
-    if(flags & M3D_EXP_ASCII) {
-        /* use CRLF to make model creators on Win happy... */
-        sd = _m3d_safestr(model->desc, 1);
-        if(!sd) goto memerr;
-        ol = setlocale(LC_NUMERIC, NULL);
-        setlocale(LC_NUMERIC, "C");
-        /* header */
-        len = 64 + (unsigned int)(strlen(sn) + strlen(sl) + strlen(sa) + strlen(sd));
-        out = (unsigned char*)M3D_MALLOC(len);
-        if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
-        ptr = (char*)out;
-        ptr += sprintf(ptr, "3dmodel %g\r\n%s\r\n%s\r\n%s\r\n%s\r\n\r\n", scale,
-            sn, sl, sa, sd);
-        M3D_FREE(sl); M3D_FREE(sa); M3D_FREE(sd);
-        sl = sa = sd = NULL;
-        /* preview chunk */
-        if(model->preview.data && model->preview.length) {
-            sl = _m3d_safestr(sn, 0);
-            if(sl) {
-                ptr -= (uintptr_t)out; len = (unsigned int)((uintptr_t)ptr + (uintptr_t)20);
-                out = (unsigned char*)M3D_REALLOC(out, len); ptr += (uintptr_t)out;
-                if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
-                ptr += sprintf(ptr, "Preview\r\n%s.png\r\n\r\n", sl);
-                M3D_FREE(sl); sl = NULL;
-            }
-        }
-        M3D_FREE(sn);  sn = NULL;
-        /* texture map */
-        if(numtmap && tmap && !(flags & M3D_EXP_NOTXTCRD) && !(flags & M3D_EXP_NOFACE)) {
-            ptr -= (uintptr_t)out; len = (unsigned int)((uintptr_t)ptr + (uintptr_t)(maxtmap * 32) + (uintptr_t)12);
-            out = (unsigned char*)M3D_REALLOC(out, len); ptr += (uintptr_t)out;
-            if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
-            ptr += sprintf(ptr, "Textmap\r\n");
-            last = M3D_UNDEF;
-            for(i = 0; i < numtmap; i++) {
-                if(tmap[i].newidx == last) continue;
-                last = tmap[i].newidx;
-                ptr += sprintf(ptr, "%g %g\r\n", tmap[i].data.u, tmap[i].data.v);
-            }
-            ptr += sprintf(ptr, "\r\n");
-        }
-        /* vertex chunk */
-        if(numvrtx && vrtx && !(flags & M3D_EXP_NOFACE)) {
-            ptr -= (uintptr_t)out; len = (unsigned int)((uintptr_t)ptr + (uintptr_t)(maxvrtx * 128) + (uintptr_t)10);
-            out = (unsigned char*)M3D_REALLOC(out, len); ptr += (uintptr_t)out;
-            if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
-            ptr += sprintf(ptr, "Vertex\r\n");
-            last = M3D_UNDEF;
-            for(i = 0; i < numvrtx; i++) {
-                if(vrtx[i].newidx == last) continue;
-                last = vrtx[i].newidx;
-                ptr += sprintf(ptr, "%g %g %g %g", vrtx[i].data.x, vrtx[i].data.y, vrtx[i].data.z, vrtx[i].data.w);
-                if(!(flags & M3D_EXP_NOCMAP) && vrtx[i].data.color)
-                    ptr += sprintf(ptr, " #%08x", vrtx[i].data.color);
-                if(!(flags & M3D_EXP_NOBONE) && model->numbone && maxskin && vrtx[i].data.skinid < M3D_INDEXMAX) {
-                    if(skin[vrtx[i].data.skinid].data.weight[0] == (M3D_FLOAT)1.0)
-                        ptr += sprintf(ptr, " %d", skin[vrtx[i].data.skinid].data.boneid[0]);
-                    else
-                        for(j = 0; j < M3D_NUMBONE && skin[vrtx[i].data.skinid].data.boneid[j] != M3D_UNDEF &&
-                            skin[vrtx[i].data.skinid].data.weight[j] > (M3D_FLOAT)0.0; j++)
-                            ptr += sprintf(ptr, " %d:%g", skin[vrtx[i].data.skinid].data.boneid[j],
-                                skin[vrtx[i].data.skinid].data.weight[j]);
-                }
-                ptr += sprintf(ptr, "\r\n");
-            }
-            ptr += sprintf(ptr, "\r\n");
-        }
-        /* bones chunk */
-        if(model->numbone && model->bone && !(flags & M3D_EXP_NOBONE)) {
-            ptr -= (uintptr_t)out; len = (unsigned int)((uintptr_t)ptr + (uintptr_t)9);
-            for(i = 0; i < model->numbone; i++) {
-                len += (unsigned int)strlen(model->bone[i].name) + 128;
-            }
-            out = (unsigned char*)M3D_REALLOC(out, len); ptr += (uintptr_t)out;
-            if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
-            ptr += sprintf(ptr, "Bones\r\n");
-            ptr = _m3d_prtbone(ptr, model->bone, model->numbone, M3D_UNDEF, 0, vrtxidx);
-            ptr += sprintf(ptr, "\r\n");
-        }
-        /* materials */
-        if(model->nummaterial && !(flags & M3D_EXP_NOMATERIAL)) {
-            for(j = 0; j < model->nummaterial; j++) {
-                if(mtrlidx[j] == M3D_UNDEF || !model->material[j].numprop || !model->material[j].prop) continue;
-                m = &model->material[j];
-                sn = _m3d_safestr(m->name, 0);
-                if(!sn) { setlocale(LC_NUMERIC, ol); goto memerr; }
-                ptr -= (uintptr_t)out; len = (unsigned int)((uintptr_t)ptr + (uintptr_t)strlen(sn) + (uintptr_t)12);
-                for(i = 0; i < m->numprop; i++) {
-                    if(m->prop[i].type < 128)
-                        len += 32;
-                    else if(m->prop[i].value.textureid < model->numtexture && model->texture[m->prop[i].value.textureid].name)
-                        len += (unsigned int)strlen(model->texture[m->prop[i].value.textureid].name) + 16;
-                }
-                out = (unsigned char*)M3D_REALLOC(out, len); ptr += (uintptr_t)out;
-                if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
-                ptr += sprintf(ptr, "Material %s\r\n", sn);
-                M3D_FREE(sn); sn = NULL;
-                for(i = 0; i < m->numprop; i++) {
-                    k = 256;
-                    if(m->prop[i].type >= 128) {
-                        for(l = 0; l < sizeof(m3d_propertytypes)/sizeof(m3d_propertytypes[0]); l++)
-                            if(m->prop[i].type == m3d_propertytypes[l].id) {
-                                sn = m3d_propertytypes[l].key;
-                                break;
-                            }
-                        if(!sn)
-                            for(l = 0; l < sizeof(m3d_propertytypes)/sizeof(m3d_propertytypes[0]); l++)
-                                if(m->prop[i].type - 128 == m3d_propertytypes[l].id) {
-                                    sn = m3d_propertytypes[l].key;
-                                    break;
-                                }
-                        k = sn ? m3dpf_map : 256;
-                    } else {
-                        for(l = 0; l < sizeof(m3d_propertytypes)/sizeof(m3d_propertytypes[0]); l++)
-                            if(m->prop[i].type == m3d_propertytypes[l].id) {
-                                sn = m3d_propertytypes[l].key;
-                                k = m3d_propertytypes[l].format;
-                                break;
-                            }
-                    }
-                    switch(k) {
-                        case m3dpf_color: ptr += sprintf(ptr, "%s #%08x\r\n", sn, m->prop[i].value.color); break;
-                        case m3dpf_uint8:
-                        case m3dpf_uint16:
-                        case m3dpf_uint32: ptr += sprintf(ptr, "%s %d\r\n", sn, m->prop[i].value.num); break;
-                        case m3dpf_float:  ptr += sprintf(ptr, "%s %g\r\n", sn, m->prop[i].value.fnum); break;
-                        case m3dpf_map:
-                            if(m->prop[i].value.textureid < model->numtexture &&
-                                model->texture[m->prop[i].value.textureid].name) {
-                                sl = _m3d_safestr(model->texture[m->prop[i].value.textureid].name, 0);
-                                if(!sl) { setlocale(LC_NUMERIC, ol); goto memerr; }
-                                if(*sl)
-                                    ptr += sprintf(ptr, "map_%s %s\r\n", sn, sl);
-                                M3D_FREE(sn); M3D_FREE(sl); sl = NULL;
-                            }
-                        break;
-                    }
-                    sn = NULL;
-                }
-                ptr += sprintf(ptr, "\r\n");
-            }
-        }
-        /* procedural face */
-        if(model->numinlined && model->inlined && !(flags & M3D_EXP_NOFACE)) {
-            /* all inlined assets which are not textures should be procedural surfaces */
-            for(j = 0; j < model->numinlined; j++) {
-                if(!model->inlined[j].name || !*model->inlined[j].name || !model->inlined[j].length || !model->inlined[j].data ||
-                 (model->inlined[j].data[1] == 'P' && model->inlined[j].data[2] == 'N' && model->inlined[j].data[3] == 'G'))
-                    continue;
-                for(i = k = 0; i < model->numtexture; i++) {
-                    if(!strcmp(model->inlined[j].name, model->texture[i].name)) { k = 1; break; }
-                }
-                if(k) continue;
-                sn = _m3d_safestr(model->inlined[j].name, 0);
-                if(!sn) { setlocale(LC_NUMERIC, ol); goto memerr; }
-                ptr -= (uintptr_t)out; len = (unsigned int)((uintptr_t)ptr + (uintptr_t)strlen(sn) + (uintptr_t)18);
-                out = (unsigned char*)M3D_REALLOC(out, len); ptr += (uintptr_t)out;
-                if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
-                ptr += sprintf(ptr, "Procedural\r\n%s\r\n\r\n", sn);
-                M3D_FREE(sn); sn = NULL;
-            }
-        }
-        /* mesh face */
-        if(model->numface && face && !(flags & M3D_EXP_NOFACE)) {
-            ptr -= (uintptr_t)out; len = (unsigned int)((uintptr_t)ptr + (uintptr_t)(model->numface * 128) + (uintptr_t)6);
-            last = M3D_UNDEF;
-            if(!(flags & M3D_EXP_NOMATERIAL))
-                for(i = 0; i < model->numface; i++) {
-                    j = face[i].data.materialid < model->nummaterial ? face[i].data.materialid : M3D_UNDEF;
-                    if(j != last) {
-                        last = j;
-                        if(last < model->nummaterial)
-                            len += (unsigned int)strlen(model->material[last].name);
-                        len += 6;
-                    }
-                }
-            out = (unsigned char*)M3D_REALLOC(out, len); ptr += (uintptr_t)out;
-            if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
-            ptr += sprintf(ptr, "Mesh\r\n");
-            last = M3D_UNDEF;
-            for(i = 0; i < model->numface; i++) {
-                j = face[i].data.materialid < model->nummaterial ? face[i].data.materialid : M3D_UNDEF;
-                if(!(flags & M3D_EXP_NOMATERIAL) && j != last) {
-                    last = j;
-                    if(last < model->nummaterial) {
-                        sn = _m3d_safestr(model->material[last].name, 0);
-                        if(!sn) { setlocale(LC_NUMERIC, ol); goto memerr; }
-                        ptr += sprintf(ptr, "use %s\r\n", sn);
-                        M3D_FREE(sn); sn = NULL;
-                    } else
-                        ptr += sprintf(ptr, "use\r\n");
-                }
-                /* hardcoded triangles. Should be repeated as many times as the number of edges in polygon */
-                for(j = 0; j < 3; j++) {
-                    ptr += sprintf(ptr, "%s%d", j?" ":"", vrtxidx[face[i].data.vertex[j]]);
-                    k = M3D_NOTDEFINED;
-                    if(!(flags & M3D_EXP_NOTXTCRD) && (face[i].data.texcoord[j] != M3D_UNDEF) &&
-                        (tmapidx[face[i].data.texcoord[j]] != M3D_UNDEF)) {
-                            k = tmapidx[face[i].data.texcoord[j]];
-                            ptr += sprintf(ptr, "/%d", k);
-                    }
-                    if(!(flags & M3D_EXP_NONORMAL) && (face[i].data.normal[j] != M3D_UNDEF))
-                        ptr += sprintf(ptr, "%s/%d", k == M3D_NOTDEFINED? "/" : "", vrtxidx[face[i].data.normal[j]]);
-                }
-                ptr += sprintf(ptr, "\r\n");
-            }
-            ptr += sprintf(ptr, "\r\n");
-        }
-        /* mathematical shapes face */
-        if(model->numshape && model->numshape && !(flags & M3D_EXP_NOFACE)) {
-            for(j = 0; j < model->numshape; j++) {
-                sn = _m3d_safestr(model->shape[j].name, 0);
-                if(!sn) { setlocale(LC_NUMERIC, ol); goto memerr; }
-                ptr -= (uintptr_t)out; len = (unsigned int)((uintptr_t)ptr + (uintptr_t)strlen(sn) + (uintptr_t)33);
-                out = (unsigned char*)M3D_REALLOC(out, len); ptr += (uintptr_t)out;
-                if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
-                ptr += sprintf(ptr, "Shape %s\r\n", sn);
-                M3D_FREE(sn); sn = NULL;
-                if(model->shape[j].group != M3D_UNDEF && !(flags & M3D_EXP_NOBONE))
-                    ptr += sprintf(ptr, "group %d\r\n", model->shape[j].group);
-                for(i = 0; i < model->shape[j].numcmd; i++) {
-                    cmd = &model->shape[j].cmd[i];
-                    if(cmd->type >= (unsigned int)(sizeof(m3d_commandtypes)/sizeof(m3d_commandtypes[0])) || !cmd->arg)
-                        continue;
-                    cd = &m3d_commandtypes[cmd->type];
-                    ptr -= (uintptr_t)out; len = (unsigned int)((uintptr_t)ptr + (uintptr_t)strlen(cd->key) + (uintptr_t)3);
-                    for(k = 0; k < cd->p; k++)
-                        switch(cd->a[k]) {
-                            case m3dcp_mi_t: if(cmd->arg[k] != M3D_NOTDEFINED) { len += (unsigned int)strlen(model->material[cmd->arg[k]].name) + 1; } break;
-                            case m3dcp_va_t: len += cmd->arg[k] * (cd->p - k - 1) * 16; k = cd->p; break;
-                            default: len += 16; break;
-                        }
-                    out = (unsigned char*)M3D_REALLOC(out, len); ptr += (uintptr_t)out;
-                    if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
-                    ptr += sprintf(ptr, "%s", cd->key);
-                    for(k = n = 0, l = cd->p; k < l; k++) {
-                        switch(cd->a[((k - n) % (cd->p - n)) + n]) {
-                            case m3dcp_mi_t:
-                                if(cmd->arg[k] != M3D_NOTDEFINED) {
-                                    sn = _m3d_safestr(model->material[cmd->arg[k]].name, 0);
-                                    if(!sn) { setlocale(LC_NUMERIC, ol); goto memerr; }
-                                    ptr += sprintf(ptr, " %s", sn);
-                                    M3D_FREE(sn); sn = NULL;
-                                }
-                            break;
-                            case m3dcp_vc_t: ptr += sprintf(ptr, " %g", *((float*)&cmd->arg[k])); break;
-                            case m3dcp_va_t: ptr += sprintf(ptr, " %d[", cmd->arg[k]);
-                                n = k + 1; l += (cmd->arg[k] - 1) * (cd->p - k - 1);
-                            break;
-                            default: ptr += sprintf(ptr, " %d", cmd->arg[k]); break;
-                        }
-                    }
-                    ptr += sprintf(ptr, "%s\r\n", l > cd->p ? " ]" : "");
-                }
-                ptr += sprintf(ptr, "\r\n");
-            }
-        }
-        /* annotation labels */
-        if(model->numlabel && model->label && !(flags & M3D_EXP_NOFACE)) {
-            for(i = 0, j = 3, length = NULL; i < model->numlabel; i++) {
-                if(model->label[i].name) j += (unsigned int)strlen(model->label[i].name);
-                if(model->label[i].lang) j += (unsigned int)strlen(model->label[i].lang);
-                if(model->label[i].text) j += (unsigned int)strlen(model->label[i].text);
-                j += 40;
-            }
-            ptr -= (uintptr_t)out; len = (unsigned int)((uintptr_t)ptr + (uintptr_t)j);
-            out = (unsigned char*)M3D_REALLOC(out, len); ptr += (uintptr_t)out;
-            if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
-            for(i = 0; i < model->numlabel; i++) {
-                if(!i || _m3d_strcmp(sl, model->label[i].lang) || _m3d_strcmp(sn, model->label[i].name)) {
-                    sl = model->label[i].lang;
-                    sn = model->label[i].name;
-                    sd = _m3d_safestr(sn, 0);
-                    if(!sd) { setlocale(LC_NUMERIC, ol); sn = sl = NULL; goto memerr; }
-                    if(i) ptr += sprintf(ptr, "\r\n");
-                    ptr += sprintf(ptr, "Labels %s\r\n", sd);
-                    M3D_FREE(sd); sd = NULL;
-                    if(model->label[i].color)
-                        ptr += sprintf(ptr, "color #0x%08x\r\n", model->label[i].color);
-                    if(sl && *sl) {
-                        sd = _m3d_safestr(sl, 0);
-                        if(!sd) { setlocale(LC_NUMERIC, ol); sn = sl = NULL; goto memerr; }
-                        ptr += sprintf(ptr, "lang %s\r\n", sd);
-                        M3D_FREE(sd); sd = NULL;
-                    }
-                }
-                sd = _m3d_safestr(model->label[i].text, 2);
-                if(!sd) { setlocale(LC_NUMERIC, ol); sn = sl = NULL; goto memerr; }
-                ptr += sprintf(ptr, "%d %s\r\n", model->label[i].vertexid, sd);
-                M3D_FREE(sd); sd = NULL;
-            }
-            ptr += sprintf(ptr, "\r\n");
-            sn = sl = NULL;
-        }
-        /* actions */
-        if(model->numaction && model->action && !(flags & M3D_EXP_NOACTION)) {
-            for(j = 0; j < model->numaction; j++) {
-                a = &model->action[j];
-                sn = _m3d_safestr(a->name, 0);
-                if(!sn) { setlocale(LC_NUMERIC, ol); goto memerr; }
-                ptr -= (uintptr_t)out; len = (unsigned int)((uintptr_t)ptr + (uintptr_t)strlen(sn) + (uintptr_t)48);
-                for(i = 0; i < a->numframe; i++)
-                    len += a->frame[i].numtransform * 128 + 8;
-                out = (unsigned char*)M3D_REALLOC(out, len); ptr += (uintptr_t)out;
-                if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
-                ptr += sprintf(ptr, "Action %d %s\r\n", a->durationmsec, sn);
-                M3D_FREE(sn); sn = NULL;
-                for(i = 0; i < a->numframe; i++) {
-                    ptr += sprintf(ptr, "frame %d\r\n", a->frame[i].msec);
-                    for(k = 0; k < a->frame[i].numtransform; k++) {
-                        ptr += sprintf(ptr, "%d %d %d\r\n", a->frame[i].transform[k].boneid,
-                            vrtxidx[a->frame[i].transform[k].pos], vrtxidx[a->frame[i].transform[k].ori]);
-                    }
-                }
-                ptr += sprintf(ptr, "\r\n");
-            }
-        }
-        /* inlined assets */
-        if(model->numinlined && model->inlined) {
-            for(i = j = 0; i < model->numinlined; i++)
-                if(model->inlined[i].name)
-                    j += (unsigned int)strlen(model->inlined[i].name) + 6;
-            if(j > 0) {
-                ptr -= (uintptr_t)out; len = (unsigned int)((uintptr_t)ptr + (uintptr_t)j + (uintptr_t)16);
-                out = (unsigned char*)M3D_REALLOC(out, len); ptr += (uintptr_t)out;
-                if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
-                ptr += sprintf(ptr, "Assets\r\n");
-                for(i = 0; i < model->numinlined; i++)
-                    if(model->inlined[i].name)
-                        ptr += sprintf(ptr, "%s%s\r\n", model->inlined[i].name, strrchr(model->inlined[i].name, '.') ? "" : ".png");
-                ptr += sprintf(ptr, "\r\n");
-            }
-        }
-        /* extra info */
-        if(model->numextra && (flags & M3D_EXP_EXTRA)) {
-            for(i = 0; i < model->numextra; i++) {
-                if(model->extra[i]->length < 9) continue;
-                ptr -= (uintptr_t)out; len = (unsigned int)((uintptr_t)ptr + (uintptr_t)17 + (uintptr_t)(model->extra[i]->length * 3));
-                out = (unsigned char*)M3D_REALLOC(out, len); ptr += (uintptr_t)out;
-                if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
-                ptr += sprintf(ptr, "Extra %c%c%c%c\r\n",
-                    model->extra[i]->magic[0] > ' ' ? model->extra[i]->magic[0] : '_',
-                    model->extra[i]->magic[1] > ' ' ? model->extra[i]->magic[1] : '_',
-                    model->extra[i]->magic[2] > ' ' ? model->extra[i]->magic[2] : '_',
-                    model->extra[i]->magic[3] > ' ' ? model->extra[i]->magic[3] : '_');
-                for(j = 0; j < model->extra[i]->length; j++)
-                    ptr += sprintf(ptr, "%02x ", *((unsigned char *)model->extra + sizeof(m3dchunk_t) + j));
-                ptr--;
-                ptr += sprintf(ptr, "\r\n\r\n");
-            }
-        }
-        setlocale(LC_NUMERIC, ol);
-        len = (unsigned int)((uintptr_t)ptr - (uintptr_t)out);
-        out = (unsigned char*)M3D_REALLOC(out, len + 1);
-        if(!out) goto memerr;
-        out[len] = 0;
-    } else
-#endif
-    {
-        /* stricly only use LF (newline) in binary */
-        sd = _m3d_safestr(model->desc, 3);
-        if(!sd) goto memerr;
-        /* header */
-        h = (m3dhdr_t*)M3D_MALLOC(sizeof(m3dhdr_t) + strlen(sn) + strlen(sl) + strlen(sa) + strlen(sd) + 4);
-        if(!h) goto memerr;
-        memcpy((uint8_t*)h, "HEAD", 4);
-        h->length = sizeof(m3dhdr_t);
-        h->scale = scale;
-        i = (unsigned int)strlen(sn); memcpy((uint8_t*)h + h->length, sn, i+1); h->length += i+1; M3D_FREE(sn);
-        i = (unsigned int)strlen(sl); memcpy((uint8_t*)h + h->length, sl, i+1); h->length += i+1; M3D_FREE(sl);
-        i = (unsigned int)strlen(sa); memcpy((uint8_t*)h + h->length, sa, i+1); h->length += i+1; M3D_FREE(sa);
-        i = (unsigned int)strlen(sd); memcpy((uint8_t*)h + h->length, sd, i+1); h->length += i+1; M3D_FREE(sd);
-        sn = sl = sa = sd = NULL;
-        if(model->inlined)
-            for(i = 0; i < model->numinlined; i++) {
-                if(model->inlined[i].name && *model->inlined[i].name && model->inlined[i].length > 0) {
-                    str = _m3d_addstr(str, &numstr, model->inlined[i].name);
-                    if(!str) goto memerr;
-                }
-            }
-        if(str)
-            for(i = 0; i < numstr; i++) {
-                h = _m3d_addhdr(h, &str[i]);
-                if(!h) goto memerr;
-            }
-        vc_s = quality == M3D_EXP_INT8? 1 : (quality == M3D_EXP_INT16? 2 : (quality == M3D_EXP_DOUBLE? 8 : 4));
-        vi_s = maxvrtx < 254 ? 1 : (maxvrtx < 65534 ? 2 : 4);
-        si_s = h->length - 16 < 254 ? 1 : (h->length - 16 < 65534 ? 2 : 4);
-        ci_s = !numcmap || !cmap ? 0 : (numcmap < 254 ? 1 : (numcmap < 65534 ? 2 : 4));
-        ti_s = !maxtmap || !tmap ? 0 : (maxtmap < 254 ? 1 : (maxtmap < 65534 ? 2 : 4));
-        bi_s = !model->numbone || !model->bone || (flags & M3D_EXP_NOBONE)? 0 : (model->numbone < 254 ? 1 :
-            (model->numbone < 65534 ? 2 : 4));
-        nb_s = maxbone < 2 ? 1 : (maxbone == 2 ? 2 : (maxbone <= 4 ? 4 : 8));
-        sk_s = !bi_s || !maxskin || !skin ? 0 : (maxskin < 254 ? 1 : (maxskin < 65534 ? 2 : 4));
-        fc_s = maxt < 254 ? 1 : (maxt < 65534 ? 2 : 4);
-        hi_s = !model->numshape || !model->shape || (flags & M3D_EXP_NOFACE)? 0 : (model->numshape < 254 ? 1 :
-            (model->numshape < 65534 ? 2 : 4));
-        fi_s = !model->numface || !model->face || (flags & M3D_EXP_NOFACE)? 0 : (model->numface < 254 ? 1 :
-            (model->numface < 65534 ? 2 : 4));
-        h->types =  (vc_s == 8 ? (3<<0) : (vc_s == 2 ? (1<<0) : (vc_s == 1 ? (0<<0) : (2<<0)))) |
-                    (vi_s == 2 ? (1<<2) : (vi_s == 1 ? (0<<2) : (2<<2))) |
-                    (si_s == 2 ? (1<<4) : (si_s == 1 ? (0<<4) : (2<<4))) |
-                    (ci_s == 2 ? (1<<6) : (ci_s == 1 ? (0<<6) : (ci_s == 4 ? (2<<6) : (3<<6)))) |
-                    (ti_s == 2 ? (1<<8) : (ti_s == 1 ? (0<<8) : (ti_s == 4 ? (2<<8) : (3<<8)))) |
-                    (bi_s == 2 ? (1<<10): (bi_s == 1 ? (0<<10): (bi_s == 4 ? (2<<10) : (3<<10)))) |
-                    (nb_s == 2 ? (1<<12): (nb_s == 1 ? (0<<12): (2<<12))) |
-                    (sk_s == 2 ? (1<<14): (sk_s == 1 ? (0<<14): (sk_s == 4 ? (2<<14) : (3<<14)))) |
-                    (fc_s == 2 ? (1<<16): (fc_s == 1 ? (0<<16): (2<<16))) |
-                    (hi_s == 2 ? (1<<18): (hi_s == 1 ? (0<<18): (hi_s == 4 ? (2<<18) : (3<<18)))) |
-                    (fi_s == 2 ? (1<<20): (fi_s == 1 ? (0<<20): (fi_s == 4 ? (2<<20) : (3<<20))));
-        len = h->length;
-        /* preview image chunk, must be the first if exists */
-        if(model->preview.data && model->preview.length) {
-            chunklen = 8 + model->preview.length;
-            h = (m3dhdr_t*)M3D_REALLOC(h, len + chunklen);
-            if(!h) goto memerr;
-            memcpy((uint8_t*)h + len, "PRVW", 4);
-            *((uint32_t*)((uint8_t*)h + len + 4)) = chunklen;
-            memcpy((uint8_t*)h + len + 8, model->preview.data, model->preview.length);
-            len += chunklen;
-        }
-        /* color map */
-        if(numcmap && cmap && ci_s < 4 && !(flags & M3D_EXP_NOCMAP)) {
-            chunklen = 8 + numcmap * sizeof(uint32_t);
-            h = (m3dhdr_t*)M3D_REALLOC(h, len + chunklen);
-            if(!h) goto memerr;
-            memcpy((uint8_t*)h + len, "CMAP", 4);
-            *((uint32_t*)((uint8_t*)h + len + 4)) = chunklen;
-            memcpy((uint8_t*)h + len + 8, cmap, chunklen - 8);
-            len += chunklen;
-        } else numcmap = 0;
-        /* texture map */
-        if(numtmap && tmap && !(flags & M3D_EXP_NOTXTCRD) && !(flags & M3D_EXP_NOFACE)) {
-            chunklen = 8 + maxtmap * vc_s * 2;
-            h = (m3dhdr_t*)M3D_REALLOC(h, len + chunklen);
-            if(!h) goto memerr;
-            memcpy((uint8_t*)h + len, "TMAP", 4);
-            length = (uint32_t*)((uint8_t*)h + len + 4);
-            out = (uint8_t*)h + len + 8;
-            last = M3D_UNDEF;
-            for(i = 0; i < numtmap; i++) {
-                if(tmap[i].newidx == last) continue;
-                last = tmap[i].newidx;
-                switch(vc_s) {
-                    case 1: *out++ = (uint8_t)(tmap[i].data.u * 255); *out++ = (uint8_t)(tmap[i].data.v * 255); break;
-                    case 2:
-                        *((uint16_t*)out) = (uint16_t)(tmap[i].data.u * 65535); out += 2;
-                        *((uint16_t*)out) = (uint16_t)(tmap[i].data.v * 65535); out += 2;
-                    break;
-                    case 4:  *((float*)out) = tmap[i].data.u; out += 4;  *((float*)out) = tmap[i].data.v; out += 4; break;
-                    case 8: *((double*)out) = tmap[i].data.u; out += 8; *((double*)out) = tmap[i].data.v; out += 8; break;
-                }
-            }
-            *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t*)h + len));
-            out = NULL;
-            len += *length;
-        }
-        /* vertex */
-        if(numvrtx && vrtx) {
-            chunklen = 8 + maxvrtx * (ci_s + sk_s + 4 * vc_s);
-            h = (m3dhdr_t*)M3D_REALLOC(h, len + chunklen);
-            if(!h) goto memerr;
-            memcpy((uint8_t*)h + len, "VRTS", 4);
-            length = (uint32_t*)((uint8_t*)h + len + 4);
-            out = (uint8_t*)h + len + 8;
-            last = M3D_UNDEF;
-            for(i = 0; i < numvrtx; i++) {
-                if(vrtx[i].newidx == last) continue;
-                last = vrtx[i].newidx;
-                switch(vc_s) {
-                    case 1:
-                        *out++ = (int8_t)(vrtx[i].data.x * 127);
-                        *out++ = (int8_t)(vrtx[i].data.y * 127);
-                        *out++ = (int8_t)(vrtx[i].data.z * 127);
-                        *out++ = (int8_t)(vrtx[i].data.w * 127);
-                    break;
-                    case 2:
-                        *((int16_t*)out) = (int16_t)(vrtx[i].data.x * 32767); out += 2;
-                        *((int16_t*)out) = (int16_t)(vrtx[i].data.y * 32767); out += 2;
-                        *((int16_t*)out) = (int16_t)(vrtx[i].data.z * 32767); out += 2;
-                        *((int16_t*)out) = (int16_t)(vrtx[i].data.w * 32767); out += 2;
-                    break;
-                    case 4:
-                        *((float*)out) = vrtx[i].data.x; out += 4;
-                        *((float*)out) = vrtx[i].data.y; out += 4;
-                        *((float*)out) = vrtx[i].data.z; out += 4;
-                        *((float*)out) = vrtx[i].data.w; out += 4;
-                    break;
-                    case 8:
-                        *((double*)out) = vrtx[i].data.x; out += 8;
-                        *((double*)out) = vrtx[i].data.y; out += 8;
-                        *((double*)out) = vrtx[i].data.z; out += 8;
-                        *((double*)out) = vrtx[i].data.w; out += 8;
-                    break;
-                }
-                idx = _m3d_cmapidx(cmap, numcmap, vrtx[i].data.color);
-                switch(ci_s) {
-                    case 1: *out++ = (uint8_t)(idx); break;
-                    case 2: *((uint16_t*)out) = (uint16_t)(idx); out += 2; break;
-                    case 4: *((uint32_t*)out) = vrtx[i].data.color; out += 4; break;
-                }
-                out = _m3d_addidx(out, sk_s, vrtx[i].data.skinid);
-            }
-            *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t*)h + len));
-            out = NULL;
-            len += *length;
-        }
-        /* bones chunk */
-        if(model->numbone && model->bone && !(flags & M3D_EXP_NOBONE)) {
-            i = 8 + bi_s + sk_s + model->numbone * (bi_s + si_s + 2*vi_s);
-            chunklen = i + numskin * nb_s * (bi_s + 1);
-            h = (m3dhdr_t*)M3D_REALLOC(h, len + chunklen);
-            if(!h) goto memerr;
-            memcpy((uint8_t*)h + len, "BONE", 4);
-            length = (uint32_t*)((uint8_t*)h + len + 4);
-            out = (uint8_t*)h + len + 8;
-            out = _m3d_addidx(out, bi_s, model->numbone);
-            out = _m3d_addidx(out, sk_s, maxskin);
-            for(i = 0; i < model->numbone; i++) {
-                out = _m3d_addidx(out, bi_s, model->bone[i].parent);
-                out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, model->bone[i].name));
-                out = _m3d_addidx(out, vi_s, vrtxidx[model->bone[i].pos]);
-                out = _m3d_addidx(out, vi_s, vrtxidx[model->bone[i].ori]);
-            }
-            if(numskin && skin && sk_s) {
-                last = M3D_UNDEF;
-                for(i = 0; i < numskin; i++) {
-                    if(skin[i].newidx == last) continue;
-                    last = skin[i].newidx;
-                    memset(&weights, 0, nb_s);
-                    for(j = 0; j < (uint32_t)nb_s && skin[i].data.boneid[j] != M3D_UNDEF &&
-                        skin[i].data.weight[j] > (M3D_FLOAT)0.0; j++)
-                            weights[j] = (uint8_t)(skin[i].data.weight[j] * 255);
-                    switch(nb_s) {
-                        case 1: weights[0] = 255; break;
-                        case 2: *((uint16_t*)out) = *((uint16_t*)&weights[0]); out += 2; break;
-                        case 4: *((uint32_t*)out) = *((uint32_t*)&weights[0]); out += 4; break;
-                        case 8: *((uint64_t*)out) = *((uint64_t*)&weights[0]); out += 8; break;
-                    }
-                    for(j = 0; j < (uint32_t)nb_s && skin[i].data.boneid[j] != M3D_UNDEF && weights[j]; j++) {
-                        out = _m3d_addidx(out, bi_s, skin[i].data.boneid[j]);
-                        *length += bi_s;
-                    }
-                }
-            }
-            *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t*)h + len));
-            out = NULL;
-            len += *length;
-        }
-        /* materials */
-        if(model->nummaterial && !(flags & M3D_EXP_NOMATERIAL)) {
-            for(j = 0; j < model->nummaterial; j++) {
-                if(mtrlidx[j] == M3D_UNDEF || !model->material[j].numprop || !model->material[j].prop) continue;
-                m = &model->material[j];
-                chunklen = 12 + si_s + m->numprop * 5;
-                h = (m3dhdr_t*)M3D_REALLOC(h, len + chunklen);
-                if(!h) goto memerr;
-                memcpy((uint8_t*)h + len, "MTRL", 4);
-                length = (uint32_t*)((uint8_t*)h + len + 4);
-                out = (uint8_t*)h + len + 8;
-                out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, m->name));
-                for(i = 0; i < m->numprop; i++) {
-                    if(m->prop[i].type >= 128) {
-                        if(m->prop[i].value.textureid >= model->numtexture ||
-                            !model->texture[m->prop[i].value.textureid].name) continue;
-                        k = m3dpf_map;
-                    } else {
-                        for(k = 256, l = 0; l < sizeof(m3d_propertytypes)/sizeof(m3d_propertytypes[0]); l++)
-                            if(m->prop[i].type == m3d_propertytypes[l].id) { k = m3d_propertytypes[l].format; break; }
-                    }
-                    if(k == 256) continue;
-                    *out++ = m->prop[i].type;
-                    switch(k) {
-                        case m3dpf_color:
-                            if(!(flags & M3D_EXP_NOCMAP)) {
-                                idx = _m3d_cmapidx(cmap, numcmap, m->prop[i].value.color);
-                                switch(ci_s) {
-                                    case 1: *out++ = (uint8_t)(idx); break;
-                                    case 2: *((uint16_t*)out) = (uint16_t)(idx); out += 2; break;
-                                    case 4: *((uint32_t*)out) = (uint32_t)(m->prop[i].value.color); out += 4; break;
-                                }
-                            } else out--;
-                        break;
-                        case m3dpf_uint8:  *out++ = m->prop[i].value.num; break;
-                        case m3dpf_uint16: *((uint16_t*)out) = m->prop[i].value.num; out += 2; break;
-                        case m3dpf_uint32: *((uint32_t*)out) = m->prop[i].value.num; out += 4; break;
-                        case m3dpf_float:  *((float*)out) = m->prop[i].value.fnum; out += 4; break;
-
-                        case m3dpf_map:
-                            idx = _m3d_stridx(str, numstr, model->texture[m->prop[i].value.textureid].name);
-                            out = _m3d_addidx(out, si_s, idx);
-                        break;
-                    }
-                }
-                *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t*)h + len));
-                len += *length;
-                out = NULL;
-            }
-        }
-        /* procedural face */
-        if(model->numinlined && model->inlined && !(flags & M3D_EXP_NOFACE)) {
-            /* all inlined assets which are not textures should be procedural surfaces */
-            for(j = 0; j < model->numinlined; j++) {
-                if(!model->inlined[j].name || !model->inlined[j].name[0] || model->inlined[j].length < 4 ||
-                    !model->inlined[j].data || (model->inlined[j].data[1] == 'P' && model->inlined[j].data[2] == 'N' &&
-                    model->inlined[j].data[3] == 'G'))
-                    continue;
-                for(i = k = 0; i < model->numtexture; i++) {
-                    if(!strcmp(model->inlined[j].name, model->texture[i].name)) { k = 1; break; }
-                }
-                if(k) continue;
-                numproc++;
-                chunklen = 8 + si_s;
-                h = (m3dhdr_t*)M3D_REALLOC(h, len + chunklen);
-                if(!h) goto memerr;
-                memcpy((uint8_t*)h + len, "PROC", 4);
-                *((uint32_t*)((uint8_t*)h + len + 4)) = chunklen;
-                out = (uint8_t*)h + len + 8;
-                out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, model->inlined[j].name));
-                out = NULL;
-                len += chunklen;
-            }
-        }
-        /* mesh face */
-        if(model->numface && face && !(flags & M3D_EXP_NOFACE)) {
-            chunklen = 8 + si_s + model->numface * (6 * vi_s + 3 * ti_s + si_s + 1);
-            h = (m3dhdr_t*)M3D_REALLOC(h, len + chunklen);
-            if(!h) goto memerr;
-            memcpy((uint8_t*)h + len, "MESH", 4);
-            length = (uint32_t*)((uint8_t*)h + len + 4);
-            out = (uint8_t*)h + len + 8;
-            last = M3D_UNDEF;
-            for(i = 0; i < model->numface; i++) {
-                if(!(flags & M3D_EXP_NOMATERIAL) && face[i].data.materialid != last) {
-                    last = face[i].data.materialid;
-                    idx = last < model->nummaterial ? _m3d_stridx(str, numstr, model->material[last].name) : 0;
-                    *out++ = 0;
-                    out = _m3d_addidx(out, si_s, idx);
-                }
-                /* hardcoded triangles. */
-                k = (3 << 4) |
-                    (((flags & M3D_EXP_NOTXTCRD) || !ti_s || face[i].data.texcoord[0] == M3D_UNDEF ||
-                    face[i].data.texcoord[1] == M3D_UNDEF || face[i].data.texcoord[2] == M3D_UNDEF) ? 0 : 1) |
-                    (((flags & M3D_EXP_NONORMAL) || face[i].data.normal[0] == M3D_UNDEF ||
-                    face[i].data.normal[1] == M3D_UNDEF || face[i].data.normal[2] == M3D_UNDEF) ? 0 : 2);
-                *out++ = k;
-                for(j = 0; j < 3; j++) {
-                    out = _m3d_addidx(out, vi_s, vrtxidx[face[i].data.vertex[j]]);
-                    if(k & 1)
-                        out = _m3d_addidx(out, ti_s, tmapidx[face[i].data.texcoord[j]]);
-                    if(k & 2)
-                        out = _m3d_addidx(out, vi_s, vrtxidx[face[i].data.normal[j]]);
-                }
-            }
-            *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t*)h + len));
-            len += *length;
-            out = NULL;
-        }
-        /* mathematical shapes face */
-        if(model->numshape && model->shape && !(flags & M3D_EXP_NOFACE)) {
-            for(j = 0; j < model->numshape; j++) {
-                chunklen = 12 + si_s + model->shape[j].numcmd * (M3D_CMDMAXARG + 1) * 4;
-                h = (m3dhdr_t*)M3D_REALLOC(h, len + chunklen);
-                if(!h) goto memerr;
-                memcpy((uint8_t*)h + len, "SHPE", 4);
-                length = (uint32_t*)((uint8_t*)h + len + 4);
-                out = (uint8_t*)h + len + 8;
-                out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, model->shape[j].name));
-                out = _m3d_addidx(out, bi_s, model->shape[j].group);
-                for(i = 0; i < model->shape[j].numcmd; i++) {
-                    cmd = &model->shape[j].cmd[i];
-                    if(cmd->type >= (unsigned int)(sizeof(m3d_commandtypes)/sizeof(m3d_commandtypes[0])) || !cmd->arg)
-                        continue;
-                    cd = &m3d_commandtypes[cmd->type];
-                    *out++ = (cmd->type & 0x7F) | (cmd->type > 127 ? 0x80 : 0);
-                    if(cmd->type > 127) *out++ = (cmd->type >> 7) & 0xff;
-                    for(k = n = 0, l = cd->p; k < l; k++) {
-                        switch(cd->a[((k - n) % (cd->p - n)) + n]) {
-                            case m3dcp_mi_t:
-                                out = _m3d_addidx(out, si_s, cmd->arg[k] < model->nummaterial ?
-                                    _m3d_stridx(str, numstr, model->material[cmd->arg[k]].name) : 0);
-                            break;
-                            case m3dcp_vc_t:
-                                min_x = *((float*)&cmd->arg[k]);
-                                switch(vc_s) {
-                                    case 1: *out++ = (int8_t)(min_x * 127); break;
-                                    case 2: *((int16_t*)out) = (int16_t)(min_x * 32767); out += 2; break;
-                                    case 4: *((float*)out) = min_x; out += 4; break;
-                                    case 8: *((double*)out) = min_x; out += 8; break;
-                                }
-                            break;
-                            case m3dcp_hi_t: out = _m3d_addidx(out, hi_s, cmd->arg[k]); break;
-                            case m3dcp_fi_t: out = _m3d_addidx(out, fi_s, cmd->arg[k]); break;
-                            case m3dcp_ti_t: out = _m3d_addidx(out, ti_s, cmd->arg[k]); break;
-                            case m3dcp_qi_t:
-                            case m3dcp_vi_t: out = _m3d_addidx(out, vi_s, cmd->arg[k]); break;
-                            case m3dcp_i1_t: out = _m3d_addidx(out, 1, cmd->arg[k]); break;
-                            case m3dcp_i2_t: out = _m3d_addidx(out, 2, cmd->arg[k]); break;
-                            case m3dcp_i4_t: out = _m3d_addidx(out, 4, cmd->arg[k]); break;
-                            case m3dcp_va_t: out = _m3d_addidx(out, 4, cmd->arg[k]);
-                                n = k + 1; l += (cmd->arg[k] - 1) * (cd->p - k - 1);
-                            break;
-                        }
-                    }
-                }
-                *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t*)h + len));
-                len += *length;
-                out = NULL;
-            }
-        }
-        /* annotation labels */
-        if(model->numlabel && model->label) {
-            for(i = 0, length = NULL; i < model->numlabel; i++) {
-                if(!i || _m3d_strcmp(sl, model->label[i].lang) || _m3d_strcmp(sn, model->label[i].name)) {
-                    sl = model->label[i].lang;
-                    sn = model->label[i].name;
-                    if(length) {
-                        *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t*)h + len));
-                        len += *length;
-                    }
-                    chunklen = 8 + 2 * si_s + ci_s + model->numlabel * (vi_s + si_s);
-                    h = (m3dhdr_t*)M3D_REALLOC(h, len + chunklen);
-                    if(!h) { sn = NULL; sl = NULL; goto memerr; }
-                    memcpy((uint8_t*)h + len, "LBLS", 4);
-                    length = (uint32_t*)((uint8_t*)h + len + 4);
-                    out = (uint8_t*)h + len + 8;
-                    out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, model->label[l].name));
-                    out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, model->label[l].lang));
-                    idx = _m3d_cmapidx(cmap, numcmap, model->label[i].color);
-                    switch(ci_s) {
-                        case 1: *out++ = (uint8_t)(idx); break;
-                        case 2: *((uint16_t*)out) = (uint16_t)(idx); out += 2; break;
-                        case 4: *((uint32_t*)out) = model->label[i].color; out += 4; break;
-                    }
-                }
-                out = _m3d_addidx(out, vi_s, vrtxidx[model->label[i].vertexid]);
-                out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, model->label[l].text));
-            }
-            if(length) {
-                *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t*)h + len));
-                len += *length;
-            }
-            out = NULL;
-            sn = sl = NULL;
-        }
-        /* actions */
-        if(model->numaction && model->action && model->numbone && model->bone && !(flags & M3D_EXP_NOACTION)) {
-            for(j = 0; j < model->numaction; j++) {
-                a = &model->action[j];
-                chunklen = 14 + si_s + a->numframe * (4 + fc_s + maxt * (bi_s + 2 * vi_s));
-                h = (m3dhdr_t*)M3D_REALLOC(h, len + chunklen);
-                if(!h) goto memerr;
-                memcpy((uint8_t*)h + len, "ACTN", 4);
-                length = (uint32_t*)((uint8_t*)h + len + 4);
-                out = (uint8_t*)h + len + 8;
-                out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, a->name));
-                *((uint16_t*)out) = (uint16_t)(a->numframe); out += 2;
-                *((uint32_t*)out) = (uint32_t)(a->durationmsec); out += 4;
-                for(i = 0; i < a->numframe; i++) {
-                    *((uint32_t*)out) = (uint32_t)(a->frame[i].msec); out += 4;
-                    out = _m3d_addidx(out, fc_s, a->frame[i].numtransform);
-                    for(k = 0; k < a->frame[i].numtransform; k++) {
-                        out = _m3d_addidx(out, bi_s, a->frame[i].transform[k].boneid);
-                        out = _m3d_addidx(out, vi_s, vrtxidx[a->frame[i].transform[k].pos]);
-                        out = _m3d_addidx(out, vi_s, vrtxidx[a->frame[i].transform[k].ori]);
-                    }
-                }
-                *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t*)h + len));
-                len += *length;
-                out = NULL;
-            }
-        }
-        /* inlined assets */
-        if(model->numinlined && model->inlined && (numproc || (flags & M3D_EXP_INLINE))) {
-            for(j = 0; j < model->numinlined; j++) {
-                if(!model->inlined[j].name || !model->inlined[j].name[0] || model->inlined[j].length<4 || !model->inlined[j].data)
-                    continue;
-                if(!(flags & M3D_EXP_INLINE)) {
-                    if(model->inlined[j].data[1] == 'P' && model->inlined[j].data[2] == 'N' && model->inlined[j].data[3] == 'G')
-                        continue;
-                    for(i = k = 0; i < model->numtexture; i++) {
-                        if(!strcmp(model->inlined[j].name, model->texture[i].name)) { k = 1; break; }
-                    }
-                    if(k) continue;
-                }
-                chunklen = 8 + si_s + model->inlined[j].length;
-                h = (m3dhdr_t*)M3D_REALLOC(h, len + chunklen);
-                if(!h) goto memerr;
-                memcpy((uint8_t*)h + len, "ASET", 4);
-                *((uint32_t*)((uint8_t*)h + len + 4)) = chunklen;
-                out = (uint8_t*)h + len + 8;
-                out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, model->inlined[j].name));
-                memcpy(out, model->inlined[j].data, model->inlined[j].length);
-                out = NULL;
-                len += chunklen;
-            }
-        }
-        /* extra chunks */
-        if(model->numextra && model->extra && (flags & M3D_EXP_EXTRA)) {
-            for(j = 0; j < model->numextra; j++) {
-                if(!model->extra[j] || model->extra[j]->length < 8)
-                    continue;
-                chunklen = model->extra[j]->length;
-                h = (m3dhdr_t*)M3D_REALLOC(h, len + chunklen);
-                if(!h) goto memerr;
-                memcpy((uint8_t*)h + len, model->extra[j], chunklen);
-                len += chunklen;
-            }
-        }
-        /* add end chunk */
-        h = (m3dhdr_t*)M3D_REALLOC(h, len + 4);
-        if(!h) goto memerr;
-        memcpy((uint8_t*)h + len, "OMD3", 4);
-        len += 4;
-        /* zlib compress */
-        if(!(flags & M3D_EXP_NOZLIB)) {
-            M3D_LOG("Deflating chunks");
-            z = stbi_zlib_compress((unsigned char *)h, len, (int*)&l, 9);
-            if(z && l > 0 && l < len) { len = l; M3D_FREE(h); h = (m3dhdr_t*)z; }
-        }
-        /* add file header at the begining */
-        len += 8;
-        out = (unsigned char*)M3D_MALLOC(len);
-        if(!out) goto memerr;
-        memcpy(out, "3DMO", 4);
-        *((uint32_t*)(out + 4)) = len;
-        memcpy(out + 8, h, len - 8);
-    }
-    if(size) *size = out ? len : 0;
-    if(vrtxidx) M3D_FREE(vrtxidx);
-    if(mtrlidx) M3D_FREE(mtrlidx);
-    if(tmapidx) M3D_FREE(tmapidx);
-    if(skinidx) M3D_FREE(skinidx);
-    if(norm) M3D_FREE(norm);
-    if(face) M3D_FREE(face);
-    if(cmap) M3D_FREE(cmap);
-    if(tmap) M3D_FREE(tmap);
-    if(skin) M3D_FREE(skin);
-    if(str) M3D_FREE(str);
-    if(vrtx) M3D_FREE(vrtx);
-    if(h) M3D_FREE(h);
-    return out;
-}
-#endif
-
-#endif
-
-#ifdef  __cplusplus
-}
-#ifdef M3D_CPPWRAPPER
-#include <vector>
-#include <string>
-#include <memory>
-
-/*** C++ wrapper class ***/
-namespace M3D {
-#ifdef M3D_IMPLEMENTATION
-
-    class Model {
-        public:
-            m3d_t *model;
-
-        public:
-            Model() {
-                this->model = (m3d_t*)malloc(sizeof(m3d_t)); memset(this->model, 0, sizeof(m3d_t));
-            }
-            Model(_unused const std::string &data, _unused m3dread_t ReadFileCB,
-                _unused m3dfree_t FreeCB, _unused M3D::Model mtllib) {
-#ifndef M3D_NOIMPORTER
-                this->model = m3d_load((unsigned char *)data.data(), ReadFileCB, FreeCB, mtllib.model);
-#else
-                Model();
-#endif
-            }
-            Model(_unused const std::vector<unsigned char> data, _unused m3dread_t ReadFileCB,
-                _unused m3dfree_t FreeCB, _unused M3D::Model mtllib) {
-#ifndef M3D_NOIMPORTER
-                this->model = m3d_load((unsigned char *)&data[0], ReadFileCB, FreeCB, mtllib.model);
-#else
-                Model();
-#endif
-            }
-            Model(_unused const unsigned char *data, _unused m3dread_t ReadFileCB,
-                _unused m3dfree_t FreeCB, _unused M3D::Model mtllib) {
-#ifndef M3D_NOIMPORTER
-                this->model = m3d_load((unsigned char*)data, ReadFileCB, FreeCB, mtllib.model);
-#else
-                Model();
-#endif
-            }
-            ~Model() { m3d_free(this->model); }
-
-        public:
-            m3d_t *getCStruct() { return this->model; }
-            std::string getName() { return std::string(this->model->name); }
-            void setName(std::string name) { this->model->name = (char*)name.c_str(); }
-            std::string getLicense() { return std::string(this->model->license); }
-            void setLicense(std::string license) { this->model->license = (char*)license.c_str(); }
-            std::string getAuthor() { return std::string(this->model->author); }
-            void setAuthor(std::string author) { this->model->author = (char*)author.c_str(); }
-            std::string getDescription() { return std::string(this->model->desc); }
-            void setDescription(std::string desc) { this->model->desc = (char*)desc.c_str(); }
-            float getScale() { return this->model->scale; }
-            void setScale(float scale) { this->model->scale = scale; }
-            std::vector<unsigned char> getPreview() { return this->model->preview.data ?
-                std::vector<unsigned char>(this->model->preview.data, this->model->preview.data + this->model->preview.length) :
-                std::vector<unsigned char>(); }
-            std::vector<uint32_t> getColorMap() { return this->model->cmap ? std::vector<uint32_t>(this->model->cmap,
-                this->model->cmap + this->model->numcmap) : std::vector<uint32_t>(); }
-            std::vector<m3dti_t> getTextureMap() { return this->model->tmap ? std::vector<m3dti_t>(this->model->tmap,
-                this->model->tmap + this->model->numtmap) : std::vector<m3dti_t>(); }
-            std::vector<m3dtx_t> getTextures() { return this->model->texture ? std::vector<m3dtx_t>(this->model->texture,
-                this->model->texture + this->model->numtexture) : std::vector<m3dtx_t>(); }
-            std::string getTextureName(int idx) { return idx >= 0 && (unsigned int)idx < this->model->numtexture ?
-                std::string(this->model->texture[idx].name) : nullptr; }
-            std::vector<m3db_t> getBones() { return this->model->bone ? std::vector<m3db_t>(this->model->bone, this->model->bone +
-                this->model->numbone) : std::vector<m3db_t>(); }
-            std::string getBoneName(int idx) { return idx >= 0 && (unsigned int)idx < this->model->numbone ?
-                std::string(this->model->bone[idx].name) : nullptr; }
-            std::vector<m3dm_t> getMaterials() { return this->model->material ? std::vector<m3dm_t>(this->model->material,
-                this->model->material + this->model->nummaterial) : std::vector<m3dm_t>(); }
-            std::string getMaterialName(int idx) { return idx >= 0 && (unsigned int)idx < this->model->nummaterial ?
-                std::string(this->model->material[idx].name) : nullptr; }
-            int getMaterialPropertyInt(int idx, int type) {
-                    if (idx < 0 || (unsigned int)idx >= this->model->nummaterial || type < 0 || type >= 127 ||
-                        !this->model->material[idx].prop) return -1;
-                    for (int i = 0; i < this->model->material[idx].numprop; i++) {
-                        if (this->model->material[idx].prop[i].type == type)
-                            return this->model->material[idx].prop[i].value.num;
-                    }
-                    return -1;
-                }
-            uint32_t getMaterialPropertyColor(int idx, int type) { return this->getMaterialPropertyInt(idx, type); }
-            float getMaterialPropertyFloat(int idx, int type) {
-                    if (idx < 0 || (unsigned int)idx >= this->model->nummaterial || type < 0 || type >= 127 ||
-                        !this->model->material[idx].prop) return -1.0f;
-                    for (int i = 0; i < this->model->material[idx].numprop; i++) {
-                        if (this->model->material[idx].prop[i].type == type)
-                            return this->model->material[idx].prop[i].value.fnum;
-                    }
-                    return -1.0f;
-                }
-            m3dtx_t* getMaterialPropertyMap(int idx, int type) {
-                    if (idx < 0 || (unsigned int)idx >= this->model->nummaterial || type < 128 || type > 255 ||
-                        !this->model->material[idx].prop) return nullptr;
-                    for (int i = 0; i < this->model->material[idx].numprop; i++) {
-                        if (this->model->material[idx].prop[i].type == type)
-                            return this->model->material[idx].prop[i].value.textureid < this->model->numtexture ?
-                                &this->model->texture[this->model->material[idx].prop[i].value.textureid] : nullptr;
-                    }
-                    return nullptr;
-                }
-            std::vector<m3dv_t> getVertices() { return this->model->vertex ? std::vector<m3dv_t>(this->model->vertex,
-                this->model->vertex + this->model->numvertex) : std::vector<m3dv_t>(); }
-            std::vector<m3df_t> getFace() { return this->model->face ? std::vector<m3df_t>(this->model->face, this->model->face +
-                this->model->numface) : std::vector<m3df_t>(); }
-            std::vector<m3dh_t> getShape() { return this->model->shape ? std::vector<m3dh_t>(this->model->shape,
-                this->model->shape + this->model->numshape) : std::vector<m3dh_t>(); }
-            std::string getShapeName(int idx) { return idx >= 0 && (unsigned int)idx < this->model->numshape &&
-                this->model->shape[idx].name && this->model->shape[idx].name[0] ?
-                std::string(this->model->shape[idx].name) : nullptr; }
-            unsigned int getShapeGroup(int idx) { return idx >= 0 && (unsigned int)idx < this->model->numshape ?
-                this->model->shape[idx].group : 0xFFFFFFFF; }
-            std::vector<m3dc_t> getShapeCommands(int idx) { return idx >= 0 && (unsigned int)idx < this->model->numshape &&
-                this->model->shape[idx].cmd ? std::vector<m3dc_t>(this->model->shape[idx].cmd, this->model->shape[idx].cmd +
-                this->model->shape[idx].numcmd) : std::vector<m3dc_t>(); }
-            std::vector<m3dl_t> getAnnotationLabels() { return this->model->label ? std::vector<m3dl_t>(this->model->label,
-                this->model->label + this->model->numlabel) : std::vector<m3dl_t>(); }
-            std::vector<m3ds_t> getSkin() { return this->model->skin ? std::vector<m3ds_t>(this->model->skin, this->model->skin +
-                this->model->numskin) : std::vector<m3ds_t>(); }
-            std::vector<m3da_t> getActions() { return this->model->action ? std::vector<m3da_t>(this->model->action,
-                this->model->action + this->model->numaction) : std::vector<m3da_t>(); }
-            std::string getActionName(int aidx) { return aidx >= 0 && (unsigned int)aidx < this->model->numaction ?
-                std::string(this->model->action[aidx].name) : nullptr; }
-            unsigned int getActionDuration(int aidx) { return aidx >= 0 && (unsigned int)aidx < this->model->numaction ?
-                this->model->action[aidx].durationmsec : 0; }
-            std::vector<m3dfr_t> getActionFrames(int aidx) { return aidx >= 0 && (unsigned int)aidx < this->model->numaction ?
-                std::vector<m3dfr_t>(this->model->action[aidx].frame, this->model->action[aidx].frame +
-                this->model->action[aidx].numframe) : std::vector<m3dfr_t>(); }
-            unsigned int getActionFrameTimestamp(int aidx, int fidx) { return aidx >= 0 && (unsigned int)aidx < this->model->numaction?
-                    (fidx >= 0 && (unsigned int)fidx < this->model->action[aidx].numframe ?
-                    this->model->action[aidx].frame[fidx].msec : 0) : 0; }
-            std::vector<m3dtr_t> getActionFrameTransforms(int aidx, int fidx) {
-                return aidx >= 0 && (unsigned int)aidx < this->model->numaction ? (
-                    fidx >= 0 && (unsigned int)fidx < this->model->action[aidx].numframe ?
-                    std::vector<m3dtr_t>(this->model->action[aidx].frame[fidx].transform,
-                    this->model->action[aidx].frame[fidx].transform + this->model->action[aidx].frame[fidx].numtransform) :
-                    std::vector<m3dtr_t>()) : std::vector<m3dtr_t>(); }
-            std::vector<m3dtr_t> getActionFrame(int aidx, int fidx, std::vector<m3dtr_t> skeleton) {
-                m3dtr_t *pose = m3d_frame(this->model, (unsigned int)aidx, (unsigned int)fidx,
-                    skeleton.size() ? &skeleton[0] : nullptr);
-                return std::vector<m3dtr_t>(pose, pose + this->model->numbone); }
-            std::vector<m3db_t> getActionPose(int aidx, unsigned int msec) {
-                m3db_t *pose = m3d_pose(this->model, (unsigned int)aidx, (unsigned int)msec);
-                return std::vector<m3db_t>(pose, pose + this->model->numbone); }
-            std::vector<m3di_t> getInlinedAssets() { return this->model->inlined ? std::vector<m3di_t>(this->model->inlined,
-                this->model->inlined + this->model->numinlined) : std::vector<m3di_t>(); }
-            std::vector<std::unique_ptr<m3dchunk_t>> getExtras() { return this->model->extra ?
-                std::vector<std::unique_ptr<m3dchunk_t>>(this->model->extra,
-                this->model->extra + this->model->numextra) : std::vector<std::unique_ptr<m3dchunk_t>>(); }
-            std::vector<unsigned char> Save(_unused int quality, _unused int flags) {
-#ifdef M3D_EXPORTER
-                unsigned int size;
-                unsigned char *ptr = m3d_save(this->model, quality, flags, &size);
-                return ptr && size ? std::vector<unsigned char>(ptr, ptr + size) : std::vector<unsigned char>();
-#else
-                return std::vector<unsigned char>();
-#endif
-            }
-    };
-
-#else
-    class Model {
-        public:
-            m3d_t *model;
-
-        public:
-            Model(const std::string &data, m3dread_t ReadFileCB, m3dfree_t FreeCB);
-            Model(const std::vector<unsigned char> data, m3dread_t ReadFileCB, m3dfree_t FreeCB);
-            Model(const unsigned char *data, m3dread_t ReadFileCB, m3dfree_t FreeCB);
-            Model();
-            ~Model();
-
-        public:
-            m3d_t *getCStruct();
-            std::string getName();
-            void setName(std::string name);
-            std::string getLicense();
-            void setLicense(std::string license);
-            std::string getAuthor();
-            void setAuthor(std::string author);
-            std::string getDescription();
-            void setDescription(std::string desc);
-            float getScale();
-            void setScale(float scale);
-            std::vector<unsigned char> getPreview();
-            std::vector<uint32_t> getColorMap();
-            std::vector<m3dti_t> getTextureMap();
-            std::vector<m3dtx_t> getTextures();
-            std::string getTextureName(int idx);
-            std::vector<m3db_t> getBones();
-            std::string getBoneName(int idx);
-            std::vector<m3dm_t> getMaterials();
-            std::string getMaterialName(int idx);
-            int getMaterialPropertyInt(int idx, int type);
-            uint32_t getMaterialPropertyColor(int idx, int type);
-            float getMaterialPropertyFloat(int idx, int type);
-            m3dtx_t* getMaterialPropertyMap(int idx, int type);
-            std::vector<m3dv_t> getVertices();
-            std::vector<m3df_t> getFace();
-            std::vector<m3dh_t> getShape();
-            std::string getShapeName(int idx);
-            unsigned int getShapeGroup(int idx);
-            std::vector<m3dc_t> getShapeCommands(int idx);
-            std::vector<m3dl_t> getAnnotationLabels();
-            std::vector<m3ds_t> getSkin();
-            std::vector<m3da_t> getActions();
-            std::string getActionName(int aidx);
-            unsigned int getActionDuration(int aidx);
-            std::vector<m3dfr_t> getActionFrames(int aidx);
-            unsigned int getActionFrameTimestamp(int aidx, int fidx);
-            std::vector<m3dtr_t> getActionFrameTransforms(int aidx, int fidx);
-            std::vector<m3dtr_t> getActionFrame(int aidx, int fidx, std::vector<m3dtr_t> skeleton);
-            std::vector<m3db_t> getActionPose(int aidx, unsigned int msec);
-            std::vector<m3di_t> getInlinedAssets();
-            std::vector<std::unique_ptr<m3dchunk_t>> getExtras();
-            std::vector<unsigned char> Save(int quality, int flags);
-    };
-
-#endif /* impl */
-}
-#endif
-
-#endif /* __cplusplus */
-
-#endif
diff --git a/Engine/lib/assimp/code/MD2/MD2FileData.h b/Engine/lib/assimp/code/MD2/MD2FileData.h
index 911cd4b98..9fcb8b0e2 100644
--- a/Engine/lib/assimp/code/MD2/MD2FileData.h
+++ b/Engine/lib/assimp/code/MD2/MD2FileData.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/MD2/MD2Loader.cpp b/Engine/lib/assimp/code/MD2/MD2Loader.cpp
index 473ab99bc..7023c0fa3 100644
--- a/Engine/lib/assimp/code/MD2/MD2Loader.cpp
+++ b/Engine/lib/assimp/code/MD2/MD2Loader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/MD2/MD2Loader.h b/Engine/lib/assimp/code/MD2/MD2Loader.h
index cbebc90a4..a3863f366 100644
--- a/Engine/lib/assimp/code/MD2/MD2Loader.h
+++ b/Engine/lib/assimp/code/MD2/MD2Loader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/MD2/MD2NormalTable.h b/Engine/lib/assimp/code/MD2/MD2NormalTable.h
index c5c790872..f82b57683 100644
--- a/Engine/lib/assimp/code/MD2/MD2NormalTable.h
+++ b/Engine/lib/assimp/code/MD2/MD2NormalTable.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/MD3/MD3FileData.h b/Engine/lib/assimp/code/MD3/MD3FileData.h
index a98af199c..2acd6631f 100644
--- a/Engine/lib/assimp/code/MD3/MD3FileData.h
+++ b/Engine/lib/assimp/code/MD3/MD3FileData.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/MD3/MD3Loader.cpp b/Engine/lib/assimp/code/MD3/MD3Loader.cpp
index 2051ecdda..1e78b6e05 100644
--- a/Engine/lib/assimp/code/MD3/MD3Loader.cpp
+++ b/Engine/lib/assimp/code/MD3/MD3Loader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -973,7 +973,7 @@ void MD3Importer::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
             AI_SWAP2( pcVertices[i].Z );
 
             AI_SWAP4( pcUVs[i].U );
-            AI_SWAP4( pcUVs[i].V );
+            AI_SWAP4( pcUVs[i].U );
         }
         for (uint32_t i = 0; i < pcSurfaces->NUM_TRIANGLES;++i) {
             AI_SWAP4(pcTriangles[i].INDEXES[0]);
diff --git a/Engine/lib/assimp/code/MD3/MD3Loader.h b/Engine/lib/assimp/code/MD3/MD3Loader.h
index 8d8304345..01b840228 100644
--- a/Engine/lib/assimp/code/MD3/MD3Loader.h
+++ b/Engine/lib/assimp/code/MD3/MD3Loader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/MD4/MD4FileData.h b/Engine/lib/assimp/code/MD4/MD4FileData.h
index 880df3230..ed3dc65e7 100644
--- a/Engine/lib/assimp/code/MD4/MD4FileData.h
+++ b/Engine/lib/assimp/code/MD4/MD4FileData.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (ASSIMP)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, ASSIMP Development Team
+Copyright (c) 2006-2010, ASSIMP Development Team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
diff --git a/Engine/lib/assimp/code/MD5/MD5Loader.cpp b/Engine/lib/assimp/code/MD5/MD5Loader.cpp
index 8c41794e7..a4aed8d70 100644
--- a/Engine/lib/assimp/code/MD5/MD5Loader.cpp
+++ b/Engine/lib/assimp/code/MD5/MD5Loader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/MD5/MD5Loader.h b/Engine/lib/assimp/code/MD5/MD5Loader.h
index 196ffb69a..e15cc3fb9 100644
--- a/Engine/lib/assimp/code/MD5/MD5Loader.h
+++ b/Engine/lib/assimp/code/MD5/MD5Loader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/MD5/MD5Parser.cpp b/Engine/lib/assimp/code/MD5/MD5Parser.cpp
index 0d3b9c74a..37490212f 100644
--- a/Engine/lib/assimp/code/MD5/MD5Parser.cpp
+++ b/Engine/lib/assimp/code/MD5/MD5Parser.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/MD5/MD5Parser.h b/Engine/lib/assimp/code/MD5/MD5Parser.h
index 692cb72ba..f7ff5303f 100644
--- a/Engine/lib/assimp/code/MD5/MD5Parser.h
+++ b/Engine/lib/assimp/code/MD5/MD5Parser.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/MDC/MDCFileData.h b/Engine/lib/assimp/code/MDC/MDCFileData.h
index 9ec73c170..052473158 100644
--- a/Engine/lib/assimp/code/MDC/MDCFileData.h
+++ b/Engine/lib/assimp/code/MDC/MDCFileData.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/MDC/MDCLoader.cpp b/Engine/lib/assimp/code/MDC/MDCLoader.cpp
index db4cdef54..084ec6024 100644
--- a/Engine/lib/assimp/code/MDC/MDCLoader.cpp
+++ b/Engine/lib/assimp/code/MDC/MDCLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -355,7 +355,7 @@ void MDCImporter::InternReadFile(
         // swap all texture coordinates
         for (unsigned int i = 0; i < pcSurface->ulNumVertices;++i)
         {
-            AI_SWAP4( pcUVs->u );
+            AI_SWAP4( pcUVs->v );
             AI_SWAP4( pcUVs->v );
         }
 
diff --git a/Engine/lib/assimp/code/MDC/MDCLoader.h b/Engine/lib/assimp/code/MDC/MDCLoader.h
index abd23bb19..a21b8a55a 100644
--- a/Engine/lib/assimp/code/MDC/MDCLoader.h
+++ b/Engine/lib/assimp/code/MDC/MDCLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/MDL/HalfLife/HL1FileData.h b/Engine/lib/assimp/code/MDL/HalfLife/HL1FileData.h
deleted file mode 100644
index a3cbb3439..000000000
--- a/Engine/lib/assimp/code/MDL/HalfLife/HL1FileData.h
+++ /dev/null
@@ -1,600 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-/** @file  HL1FileData.h
- *  @brief Definition of in-memory structures for the
- *         Half-Life 1 MDL file format.
- */
-
-#ifndef AI_HL1FILEDATA_INCLUDED
-#define AI_HL1FILEDATA_INCLUDED
-
-#include "HalfLifeMDLBaseHeader.h"
-
-#include <assimp/Compiler/pushpack1.h>
-#include <assimp/types.h>
-
-namespace Assimp {
-namespace MDL {
-namespace HalfLife {
-
-using vec3_t = float[3];
-
-/** \struct Header_HL1
- *  \brief Data structure for the HL1 MDL file header.
- */
-struct Header_HL1 : HalfLifeMDLBaseHeader {
-    //! The model name.
-    char name[64];
-
-    //! The total file size in bytes.
-    int32_t length;
-
-    //! Ideal eye position.
-    vec3_t eyeposition;
-
-    //! Ideal movement hull size.
-    vec3_t min;
-    vec3_t max;
-
-    //! Clipping bounding box.
-    vec3_t bbmin;
-    vec3_t bbmax;
-
-    //! Was "flags".
-    int32_t unused;
-
-    //! The number of bones.
-    int32_t numbones;
-
-    //! Offset to the first bone chunk.
-    int32_t boneindex;
-
-    //! The number of bone controllers.
-    int32_t numbonecontrollers;
-
-    //! Offset to the first bone controller chunk.
-    int32_t bonecontrollerindex;
-
-    //! The number of hitboxes.
-    int32_t numhitboxes;
-
-    //! Offset to the first hitbox chunk.
-    int32_t hitboxindex;
-
-    //! The number of sequences.
-    int32_t numseq;
-
-    //! Offset to the first sequence description chunk.
-    int32_t seqindex;
-
-    //! The number of sequence groups.
-    int32_t numseqgroups;
-
-    //! Offset to the first sequence group chunk.
-    int32_t seqgroupindex;
-
-    //! The number of textures.
-    int32_t numtextures;
-
-    //! Offset to the first texture chunk.
-    int32_t textureindex;
-
-    //! Offset to the first texture's image data.
-    int32_t texturedataindex;
-
-    //! The number of replaceable textures.
-    int32_t numskinref;
-
-    //! The number of skin families.
-    int32_t numskinfamilies;
-
-    //! Offset to the first replaceable texture.
-    int32_t skinindex;
-
-    //! The number of bodyparts.
-    int32_t numbodyparts;
-
-    //! Offset the the first bodypart.
-    int32_t bodypartindex;
-
-    //! The number of attachments.
-    int32_t numattachments;
-
-    //! Offset the the first attachment chunk.
-    int32_t attachmentindex;
-
-    //! Was "soundtable".
-    int32_t unused2;
-
-    //! Was "soundindex".
-    int32_t unused3;
-
-    //! Was "soundgroups".
-    int32_t unused4;
-
-    //! Was "soundgroupindex".
-    int32_t unused5;
-
-    //! The number of nodes in the sequence transition graph.
-    int32_t numtransitions;
-
-    //! Offset the the first sequence transition.
-    int32_t transitionindex;
-} PACK_STRUCT;
-
-/** \struct SequenceHeader_HL1
- *  \brief Data structure for the file header of a demand loaded
- *         HL1 MDL sequence group file.
- */
-struct SequenceHeader_HL1 : HalfLifeMDLBaseHeader {
-    //! The sequence group file name.
-    char name[64];
-
-    //! The total file size in bytes.
-    int32_t length;
-} PACK_STRUCT;
-
-/** \struct Bone_HL1
- *  \brief Data structure for a bone in HL1 MDL files.
- */
-struct Bone_HL1 {
-    //! The bone name.
-    char name[32];
-
-    //! The parent bone index. (-1) If it has no parent.
-    int32_t parent;
-
-    //! Was "flags".
-    int32_t unused;
-
-    //! Available bone controller per motion type.
-    //! (-1) if no controller is available.
-    int32_t bonecontroller[6];
-
-    /*! Default position and rotation values where
-     * scale[0] = position.X
-     * scale[1] = position.Y
-     * scale[2] = position.Z
-     * scale[3] = rotation.X
-     * scale[4] = rotation.Y
-     * scale[5] = rotation.Z
-     */
-    float value[6];
-
-    /*! Compressed scale values where
-     * scale[0] = position.X scale
-     * scale[1] = position.Y scale
-     * scale[2] = position.Z scale
-     * scale[3] = rotation.X scale
-     * scale[4] = rotation.Y scale
-     * scale[5] = rotation.Z scale
-     */
-    float scale[6];
-} PACK_STRUCT;
-
-/** \struct BoneController_HL1
- *  \brief Data structure for a bone controller in HL1 MDL files.
- */
-struct BoneController_HL1 {
-    //! Bone affected by this controller.
-    int32_t bone;
-
-    //! The motion type.
-    int32_t type;
-
-    //! The minimum and maximum values.
-    float start;
-    float end;
-
-    // Was "rest".
-    int32_t unused;
-
-    // The bone controller channel.
-    int32_t index;
-} PACK_STRUCT;
-
-/** \struct Hitbox_HL1
- *  \brief Data structure for a hitbox in HL1 MDL files.
- */
-struct Hitbox_HL1 {
-    //! The bone this hitbox follows.
-    int32_t bone;
-
-    //! The hit group.
-    int32_t group;
-
-    //! The hitbox minimum and maximum extents.
-    vec3_t bbmin;
-    vec3_t bbmax;
-} PACK_STRUCT;
-
-/** \struct SequenceGroup_HL1
- *  \brief Data structure for a sequence group in HL1 MDL files.
- */
-struct SequenceGroup_HL1 {
-    //! A textual name for this sequence group.
-    char label[32];
-
-    //! The file name.
-    char name[64];
-
-    //! Was "cache".
-    int32_t unused;
-
-    //! Was "data".
-    int32_t unused2;
-} PACK_STRUCT;
-
-//! The type of blending for a sequence.
-enum SequenceBlendMode_HL1 {
-    NoBlend = 1,
-    TwoWayBlending = 2,
-    FourWayBlending = 4,
-};
-
-/** \struct SequenceDesc_HL1
- *  \brief Data structure for a sequence description in HL1 MDL files.
- */
-struct SequenceDesc_HL1 {
-    //! The sequence name.
-    char label[32];
-
-    //! Frames per second.
-    float fps;
-
-    //! looping/non-looping flags.
-    int32_t flags;
-
-    //! The sequence activity.
-    int32_t activity;
-
-    //! The sequence activity weight.
-    int32_t actweight;
-
-    //! The number of animation events.
-    int32_t numevents;
-
-    //! Offset the the first animation event chunk.
-    int32_t eventindex;
-
-    //! The number of frames in the sequence.
-    int32_t numframes;
-
-    //! Was "numpivots".
-    int32_t unused;
-
-    //! Was "pivotindex".
-    int32_t unused2;
-
-    //! Linear motion type.
-    int32_t motiontype;
-
-    //! Linear motion bone.
-    int32_t motionbone;
-
-    //! Linear motion.
-    vec3_t linearmovement;
-
-    //! Was "automoveposindex".
-    int32_t unused3;
-
-    //! Was "automoveangleindex".
-    int32_t unused4;
-
-    //! The sequence minimum and maximum extents.
-    vec3_t bbmin;
-    vec3_t bbmax;
-
-    //! The number of blend animations.
-    int32_t numblends;
-
-    //! Offset to first the AnimValueOffset_HL1 chunk.
-    //! This offset is relative to the SequenceHeader_HL1 of the file
-    //! that contains the animation data.
-    int32_t animindex;
-
-    //! The motion type of each blend controller.
-    int32_t blendtype[2];
-
-    //! The starting value of each blend controller.
-    float blendstart[2];
-
-    //! The ending value of each blend controller.
-    float blendend[2];
-
-    //! Was "blendparent".
-    int32_t unused5;
-
-    //! The sequence group.
-    int32_t seqgroup;
-
-    //! The node at entry in the sequence transition graph.
-    int32_t entrynode;
-
-    //! The node at exit in the sequence transition graph.
-    int32_t exitnode;
-
-    //! Transition rules.
-    int32_t nodeflags;
-
-    //! Was "nextseq"
-    int32_t unused6;
-} PACK_STRUCT;
-
-/** \struct AnimEvent_HL1
- *  \brief Data structure for an animation event in HL1 MDL files.
- */
-struct AnimEvent_HL1 {
-    //! The frame at which this animation event occurs.
-    int32_t frame;
-
-    //! The script event type.
-    int32_t event;
-
-    //! was "type"
-    int32_t unused;
-
-    //! Options. Could be path to sound WAVE files.
-    char options[64];
-} PACK_STRUCT;
-
-/** \struct Attachment_HL1
- *  \brief Data structure for an attachment in HL1 MDL files.
- */
-struct Attachment_HL1 {
-    //! Was "name".
-    char unused[32];
-
-    //! Was "type".
-    int32_t unused2;
-
-    //! The bone this attachment follows.
-    int32_t bone;
-
-    //! The attachment origin.
-    vec3_t org;
-
-    //! Was "vectors"
-    vec3_t unused3[3];
-} PACK_STRUCT;
-
-/** \struct AnimValueOffset_HL1
- *  \brief Data structure to hold offsets (one per motion type)
- *         to the first animation frame value for a single bone
- *         in HL1 MDL files.
- */
-struct AnimValueOffset_HL1 {
-    unsigned short offset[6];
-} PACK_STRUCT;
-
-/** \struct AnimValue_HL1
- *  \brief Data structure for an animation frame in HL1 MDL files.
- */
-union AnimValue_HL1 {
-    struct {
-        uint8_t valid;
-        uint8_t total;
-    } num;
-    short value;
-} PACK_STRUCT;
-
-/** \struct Bodypart_HL1
- *  \brief Data structure for a bodypart in HL1 MDL files.
- */
-struct Bodypart_HL1 {
-    //! The bodypart name.
-    char name[64];
-
-    //! The number of available models for this bodypart.
-    int32_t nummodels;
-
-    //! Used to convert from a global model index
-    //! to a local bodypart model index.
-    int32_t base;
-
-    //! The offset to the first model chunk.
-    int32_t modelindex;
-} PACK_STRUCT;
-
-/** \struct Texture_HL1
- *  \brief Data structure for a texture in HL1 MDL files.
- */
-struct Texture_HL1 {
-    //! Texture file name.
-    char name[64];
-
-    //! Texture flags.
-    int32_t flags;
-
-    //! Texture width in pixels.
-    int32_t width;
-
-    //! Texture height in pixels.
-    int32_t height;
-
-    //! Offset to the image data.
-    //! This offset is relative to the texture file header.
-    int32_t index;
-} PACK_STRUCT;
-
-/** \struct Model_HL1
- *  \brief Data structure for a model in HL1 MDL files.
- */
-struct Model_HL1 {
-    //! Model name.
-    char name[64];
-
-    //! Was "type".
-    int32_t unused;
-
-    //! Was "boundingradius".
-    float unused2;
-
-    //! The number of meshes in the model.
-    int32_t nummesh;
-
-    //! Offset to the first mesh chunk.
-    int32_t meshindex;
-
-    //! The number of unique vertices.
-    int32_t numverts;
-
-    //! Offset to the vertex bone array.
-    int32_t vertinfoindex;
-
-    //! Offset to the vertex array.
-    int32_t vertindex;
-
-    //! The number of unique normals.
-    int32_t numnorms;
-
-    //! Offset to the normal bone array.
-    int32_t norminfoindex;
-
-    //! Offset to the normal array.
-    int32_t normindex;
-
-    //! Was "numgroups".
-    int32_t unused3;
-
-    //! Was "groupindex".
-    int32_t unused4;
-} PACK_STRUCT;
-
-/** \struct Mesh_HL1
- *  \brief Data structure for a mesh in HL1 MDL files.
- */
-struct Mesh_HL1 {
-    //! Can be interpreted as the number of triangles in the mesh.
-    int32_t numtris;
-
-    //! Offset to the start of the tris sequence.
-    int32_t triindex;
-
-    //! The skin index.
-    int32_t skinref;
-
-    //! The number of normals in the mesh.
-    int32_t numnorms;
-
-    //! Was "normindex".
-    int32_t unused;
-} PACK_STRUCT;
-
-/** \struct Trivert
- *  \brief Data structure for a trivert in HL1 MDL files.
- */
-struct Trivert {
-    //! Index into Model_HL1 vertex array.
-    short vertindex;
-
-    //! Index into Model_HL1 normal array.
-    short normindex;
-
-    //! Texture coordinates in absolute space (unnormalized).
-    short s, t;
-} PACK_STRUCT;
-
-#include <assimp/Compiler/poppack1.h>
-
-#if (!defined AI_MDL_HL1_VERSION)
-#define AI_MDL_HL1_VERSION 10
-#endif
-#if (!defined AI_MDL_HL1_MAX_TRIANGLES)
-#define AI_MDL_HL1_MAX_TRIANGLES 20000
-#endif
-#if (!defined AI_MDL_HL1_MAX_VERTICES)
-#define AI_MDL_HL1_MAX_VERTICES 2048
-#endif
-#if (!defined AI_MDL_HL1_MAX_SEQUENCES)
-#define AI_MDL_HL1_MAX_SEQUENCES 2048
-#endif
-#if (!defined AI_MDL_HL1_MAX_SEQUENCE_GROUPS)
-#define AI_MDL_HL1_MAX_SEQUENCE_GROUPS 32
-#endif
-#if (!defined AI_MDL_HL1_MAX_TEXTURES)
-#define AI_MDL_HL1_MAX_TEXTURES 100
-#endif
-#if (!defined AI_MDL_HL1_MAX_SKIN_FAMILIES)
-#define AI_MDL_HL1_MAX_SKIN_FAMILIES 100
-#endif
-#if (!defined AI_MDL_HL1_MAX_BONES)
-#define AI_MDL_HL1_MAX_BONES 128
-#endif
-#if (!defined AI_MDL_HL1_MAX_BODYPARTS)
-#define AI_MDL_HL1_MAX_BODYPARTS 32
-#endif
-#if (!defined AI_MDL_HL1_MAX_MODELS)
-#define AI_MDL_HL1_MAX_MODELS 32
-#endif
-#if (!defined AI_MDL_HL1_MAX_MESHES)
-#define AI_MDL_HL1_MAX_MESHES 256
-#endif
-#if (!defined AI_MDL_HL1_MAX_EVENTS)
-#define AI_MDL_HL1_MAX_EVENTS 1024
-#endif
-#if (!defined AI_MDL_HL1_MAX_BONE_CONTROLLERS)
-#define AI_MDL_HL1_MAX_BONE_CONTROLLERS 8
-#endif
-#if (!defined AI_MDL_HL1_MAX_ATTACHMENTS)
-#define AI_MDL_HL1_MAX_ATTACHMENTS 512
-#endif
-
-// lighting options
-#if (!defined AI_MDL_HL1_STUDIO_NF_FLATSHADE)
-#define AI_MDL_HL1_STUDIO_NF_FLATSHADE 0x0001
-#endif
-#if (!defined AI_MDL_HL1_STUDIO_NF_CHROME)
-#define AI_MDL_HL1_STUDIO_NF_CHROME 0x0002
-#endif
-#if (!defined AI_MDL_HL1_STUDIO_NF_ADDITIVE)
-#define AI_MDL_HL1_STUDIO_NF_ADDITIVE 0x0020
-#endif
-#if (!defined AI_MDL_HL1_STUDIO_NF_MASKED)
-#define AI_MDL_HL1_STUDIO_NF_MASKED 0x0040
-#endif
-
-} // namespace HalfLife
-} // namespace MDL
-} // namespace Assimp
-
-#endif // AI_HL1FILEDATA_INCLUDED
diff --git a/Engine/lib/assimp/code/MDL/HalfLife/HL1ImportDefinitions.h b/Engine/lib/assimp/code/MDL/HalfLife/HL1ImportDefinitions.h
deleted file mode 100644
index 29b1cdceb..000000000
--- a/Engine/lib/assimp/code/MDL/HalfLife/HL1ImportDefinitions.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-/** @file HL1ImportDefinitions.h
- *  @brief HL1 MDL loader specific definitions.
- */
-
-#ifndef AI_MDL_HL1_IMPORT_DEFINITIONS_INCLUDED
-#define AI_MDL_HL1_IMPORT_DEFINITIONS_INCLUDED
-
-#define AI_MDL_HL1_NODE_ROOT "<MDL_root>"
-#define AI_MDL_HL1_NODE_BODYPARTS "<MDL_bodyparts>"
-#define AI_MDL_HL1_NODE_BONES "<MDL_bones>"
-#define AI_MDL_HL1_NODE_BONE_CONTROLLERS "<MDL_bone_controllers>"
-#define AI_MDL_HL1_NODE_SEQUENCE_INFOS "<MDL_sequence_infos>"
-#define AI_MDL_HL1_NODE_SEQUENCE_GROUPS "<MDL_sequence_groups>"
-#define AI_MDL_HL1_NODE_SEQUENCE_TRANSITION_GRAPH "<MDL_sequence_transition_graph>"
-#define AI_MDL_HL1_NODE_ATTACHMENTS "<MDL_attachments>"
-#define AI_MDL_HL1_NODE_HITBOXES "<MDL_hitboxes>"
-#define AI_MDL_HL1_NODE_GLOBAL_INFO "<MDL_global_info>"
-#define AI_MDL_HL1_NODE_ANIMATION_EVENTS "AnimationEvents"
-#define AI_MDL_HL1_NODE_BLEND_CONTROLLERS "BlendControllers"
-
-#define AI_MDL_HL1_MATKEY_CHROME(type, N) "$mat.HL1.chrome", type, N
-
-#endif // AI_MDL_HL1_IMPORT_DEFINITIONS_INCLUDED
diff --git a/Engine/lib/assimp/code/MDL/HalfLife/HL1ImportSettings.h b/Engine/lib/assimp/code/MDL/HalfLife/HL1ImportSettings.h
deleted file mode 100644
index 50be1f366..000000000
--- a/Engine/lib/assimp/code/MDL/HalfLife/HL1ImportSettings.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-/** @file HL1ImportSettings.h
- *  @brief Half-Life 1 MDL loader configuration settings.
- */
-
-#ifndef AI_HL1IMPORTSETTINGS_INCLUDED
-#define AI_HL1IMPORTSETTINGS_INCLUDED
-
-#include <string>
-
-namespace Assimp {
-namespace MDL {
-namespace HalfLife {
-
-struct HL1ImportSettings {
-    HL1ImportSettings() :
-        read_animations(false),
-        read_animation_events(false),
-        read_blend_controllers(false),
-        read_sequence_groups_info(false),
-        read_sequence_transitions(false),
-        read_attachments(false),
-        read_bone_controllers(false),
-        read_hitboxes(false),
-        read_textures(false),
-        read_misc_global_info(false) {
-    }
-
-    bool read_animations;
-    bool read_animation_events;
-    bool read_blend_controllers;
-    bool read_sequence_groups_info;
-    bool read_sequence_transitions;
-    bool read_attachments;
-    bool read_bone_controllers;
-    bool read_hitboxes;
-    bool read_textures;
-    bool read_misc_global_info;
-};
-
-} // namespace HalfLife
-} // namespace MDL
-} // namespace Assimp
-
-#endif // AI_HL1IMPORTSETTINGS_INCLUDED
diff --git a/Engine/lib/assimp/code/MDL/HalfLife/HL1MDLLoader.cpp b/Engine/lib/assimp/code/MDL/HalfLife/HL1MDLLoader.cpp
deleted file mode 100644
index c18528e59..000000000
--- a/Engine/lib/assimp/code/MDL/HalfLife/HL1MDLLoader.cpp
+++ /dev/null
@@ -1,1348 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-/** @file HL1MDLLoader.cpp
- *  @brief Implementation for the Half-Life 1 MDL loader.
- */
-
-#include "HL1MDLLoader.h"
-#include "HL1ImportDefinitions.h"
-#include "HL1MeshTrivert.h"
-#include "UniqueNameGenerator.h"
-
-#include <assimp/BaseImporter.h>
-#include <assimp/StringUtils.h>
-#include <assimp/ai_assert.h>
-#include <assimp/qnan.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/Importer.hpp>
-
-#include <iomanip>
-#include <sstream>
-
-#ifdef MDL_HALFLIFE_LOG_WARN_HEADER
-#undef MDL_HALFLIFE_LOG_WARN_HEADER
-#endif
-#define MDL_HALFLIFE_LOG_HEADER "[Half-Life 1 MDL] "
-#include "LogFunctions.h"
-
-namespace Assimp {
-namespace MDL {
-namespace HalfLife {
-
-// ------------------------------------------------------------------------------------------------
-HL1MDLLoader::HL1MDLLoader(
-    aiScene *scene,
-    IOSystem *io,
-    const unsigned char *buffer,
-    const std::string &file_path,
-    const HL1ImportSettings &import_settings) :
-    scene_(scene),
-    io_(io),
-    buffer_(buffer),
-    file_path_(file_path),
-    import_settings_(import_settings),
-    header_(nullptr),
-    texture_header_(nullptr),
-    anim_headers_(nullptr),
-    texture_buffer_(nullptr),
-    anim_buffers_(nullptr),
-    num_sequence_groups_(0),
-    rootnode_children_(),
-    unique_name_generator_(),
-    unique_sequence_names_(),
-    unique_sequence_groups_names_(),
-    temp_bones_(),
-    num_blend_controllers_(0),
-    total_models_(0) {
-    load_file();
-}
-
-// ------------------------------------------------------------------------------------------------
-HL1MDLLoader::~HL1MDLLoader() {
-    release_resources();
-}
-
-// ------------------------------------------------------------------------------------------------
-void HL1MDLLoader::release_resources() {
-    if (buffer_ != texture_buffer_) {
-        delete[] texture_buffer_;
-        texture_buffer_ = nullptr;
-    }
-
-    if (num_sequence_groups_ && anim_buffers_) {
-        for (int i = 1; i < num_sequence_groups_; ++i) {
-            if (anim_buffers_[i]) {
-                delete[] anim_buffers_[i];
-                anim_buffers_[i] = nullptr;
-            }
-        }
-
-        delete[] anim_buffers_;
-        anim_buffers_ = nullptr;
-    }
-
-    if (anim_headers_) {
-        delete[] anim_headers_;
-        anim_headers_ = nullptr;
-    }
-
-    // Root has some children nodes. so let's proceed them
-    if (!rootnode_children_.empty()) {
-        // Here, it means that the nodes were not added to the
-        // scene root node. We still have to delete them.
-        for (auto it = rootnode_children_.begin(); it != rootnode_children_.end(); ++it) {
-            if (*it) {
-                delete *it;
-            }
-        }
-        // Ensure this happens only once.
-        rootnode_children_.clear();
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void HL1MDLLoader::load_file() {
-    try {
-        header_ = (const Header_HL1 *)buffer_;
-        validate_header(header_, false);
-
-        // Create the root scene node.
-        scene_->mRootNode = new aiNode(AI_MDL_HL1_NODE_ROOT);
-
-        load_texture_file();
-
-        if (import_settings_.read_animations) {
-            load_sequence_groups_files();
-        }
-
-        read_textures();
-        read_skins();
-
-        read_bones();
-        read_meshes();
-
-        if (import_settings_.read_animations) {
-            read_sequence_groups_info();
-            read_animations();
-            read_sequence_infos();
-            if (import_settings_.read_sequence_transitions)
-                read_sequence_transitions();
-        }
-
-        if (import_settings_.read_attachments) {
-            read_attachments();
-        }
-
-        if (import_settings_.read_hitboxes) {
-            read_hitboxes();
-        }
-
-        if (import_settings_.read_bone_controllers) {
-            read_bone_controllers();
-        }
-
-        read_global_info();
-
-        if (!header_->numbodyparts) {
-            // This could be an MDL external texture file. In this case,
-            // add this flag to allow the scene to be loaded even if it
-            // has no meshes.
-            scene_->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
-        }
-
-        // Append children to root node.
-        if (rootnode_children_.size()) {
-            scene_->mRootNode->addChildren(
-                    static_cast<unsigned int>(rootnode_children_.size()),
-                    rootnode_children_.data());
-
-            // Clear the list of nodes so they will not be destroyed
-            // when resources are released.
-            rootnode_children_.clear();
-        }
-
-        release_resources();
-
-    } catch (...) {
-        release_resources();
-        throw;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void HL1MDLLoader::validate_header(const Header_HL1 *header, bool is_texture_header) {
-    if (is_texture_header) {
-        // Every single Half-Life model is assumed to have at least one texture.
-        if (!header->numtextures) {
-            throw DeadlyImportError(MDL_HALFLIFE_LOG_HEADER "There are no textures in the file");
-        }
-
-        if (header->numtextures > AI_MDL_HL1_MAX_TEXTURES) {
-            log_warning_limit_exceeded<AI_MDL_HL1_MAX_TEXTURES>(header->numtextures, "textures");
-        }
-
-        if (header->numskinfamilies > AI_MDL_HL1_MAX_SKIN_FAMILIES) {
-            log_warning_limit_exceeded<AI_MDL_HL1_MAX_SKIN_FAMILIES>(header->numskinfamilies, "skin families");
-        }
-
-    } else {
-
-        if (header->numbodyparts > AI_MDL_HL1_MAX_BODYPARTS) {
-            log_warning_limit_exceeded<AI_MDL_HL1_MAX_BODYPARTS>(header->numbodyparts, "bodyparts");
-        }
-
-        if (header->numbones > AI_MDL_HL1_MAX_BONES) {
-            log_warning_limit_exceeded<AI_MDL_HL1_MAX_BONES>(header->numbones, "bones");
-        }
-
-        if (header->numbonecontrollers > AI_MDL_HL1_MAX_BONE_CONTROLLERS) {
-            log_warning_limit_exceeded<AI_MDL_HL1_MAX_BONE_CONTROLLERS>(header->numbonecontrollers, "bone controllers");
-        }
-
-        if (header->numseq > AI_MDL_HL1_MAX_SEQUENCES) {
-            log_warning_limit_exceeded<AI_MDL_HL1_MAX_SEQUENCES>(header->numseq, "sequences");
-        }
-
-        if (header->numseqgroups > AI_MDL_HL1_MAX_SEQUENCE_GROUPS) {
-            log_warning_limit_exceeded<AI_MDL_HL1_MAX_SEQUENCE_GROUPS>(header->numseqgroups, "sequence groups");
-        }
-
-        if (header->numattachments > AI_MDL_HL1_MAX_ATTACHMENTS) {
-            log_warning_limit_exceeded<AI_MDL_HL1_MAX_ATTACHMENTS>(header->numattachments, "attachments");
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-/*
-    Load textures.
-
-    There are two ways for textures to be stored in a Half-Life model:
-
-    1. Directly in the MDL file (filePath) or
-    2. In an external MDL file.
-
-    Due to the way StudioMDL works (tool used to compile SMDs into MDLs),
-    it is assumed that an external texture file follows the naming
-    convention: <YourModelName>T.mdl. Note the extra (T) at the end of the
-    model name.
-
-    .e.g For a given model named MyModel.mdl
-
-    The external texture file name would be MyModelT.mdl
-*/
-void HL1MDLLoader::load_texture_file() {
-    if (header_->numtextures == 0) {
-        // Load an external MDL texture file.
-        std::string texture_file_path =
-                DefaultIOSystem::absolutePath(file_path_) + io_->getOsSeparator() +
-                DefaultIOSystem::completeBaseName(file_path_) + "T." +
-                BaseImporter::GetExtension(file_path_);
-
-        load_file_into_buffer<Header_HL1>(texture_file_path, texture_buffer_);
-    } else {
-        // Model has no external texture file. This means the texture is stored inside the main MDL file.
-        texture_buffer_ = const_cast<unsigned char *>(buffer_);
-    }
-
-    texture_header_ = (const Header_HL1 *)texture_buffer_;
-
-    // Validate texture header.
-    validate_header(texture_header_, true);
-}
-
-// ------------------------------------------------------------------------------------------------
-/*
-    Load sequence group files if any.
-
-    Due to the way StudioMDL works (tool used to compile SMDs into MDLs),
-    it is assumed that a sequence group file follows the naming
-    convention: <YourModelName>0X.mdl. Note the extra (0X) at the end of
-    the model name, where (X) is the sequence group.
-
-    .e.g For a given model named MyModel.mdl
-
-    Sequence group 1 => MyModel01.mdl
-    Sequence group 2 => MyModel02.mdl
-    Sequence group X => MyModel0X.mdl
-
-*/
-void HL1MDLLoader::load_sequence_groups_files() {
-    if (header_->numseqgroups <= 1) {
-        return;
-    }
-
-    num_sequence_groups_ = header_->numseqgroups;
-
-    anim_buffers_ = new unsigned char *[num_sequence_groups_];
-    anim_headers_ = new SequenceHeader_HL1 *[num_sequence_groups_];
-    for (int i = 0; i < num_sequence_groups_; ++i) {
-        anim_buffers_[i] = nullptr;
-        anim_headers_[i] = nullptr;
-    }
-
-    std::string file_path_without_extension =
-            DefaultIOSystem::absolutePath(file_path_) +
-            io_->getOsSeparator() +
-            DefaultIOSystem::completeBaseName(file_path_);
-
-    for (int i = 1; i < num_sequence_groups_; ++i) {
-        std::stringstream ss;
-        ss << file_path_without_extension;
-        ss << std::setw(2) << std::setfill('0') << i;
-        ss << '.' << BaseImporter::GetExtension(file_path_);
-
-        std::string sequence_file_path = ss.str();
-
-        load_file_into_buffer<SequenceHeader_HL1>(sequence_file_path, anim_buffers_[i]);
-
-        anim_headers_[i] = (SequenceHeader_HL1 *)anim_buffers_[i];
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Read an MDL texture.
-void HL1MDLLoader::read_texture(const Texture_HL1 *ptexture,
-        uint8_t *data, uint8_t *pal, aiTexture *pResult,
-        aiColor3D &last_palette_color) {
-    pResult->mFilename = ptexture->name;
-    pResult->mWidth = static_cast<unsigned int>(ptexture->width);
-    pResult->mHeight = static_cast<unsigned int>(ptexture->height);
-    pResult->achFormatHint[0] = 'r';
-    pResult->achFormatHint[1] = 'g';
-    pResult->achFormatHint[2] = 'b';
-    pResult->achFormatHint[3] = 'a';
-    pResult->achFormatHint[4] = '8';
-    pResult->achFormatHint[5] = '8';
-    pResult->achFormatHint[6] = '8';
-    pResult->achFormatHint[7] = '8';
-    pResult->achFormatHint[8] = '\0';
-
-    const size_t num_pixels = pResult->mWidth * pResult->mHeight;
-    aiTexel *out = pResult->pcData = new aiTexel[num_pixels];
-
-    // Convert indexed 8 bit to 32 bit RGBA.
-    for (size_t i = 0; i < num_pixels; ++i, ++out) {
-        out->r = pal[data[i] * 3];
-        out->g = pal[data[i] * 3 + 1];
-        out->b = pal[data[i] * 3 + 2];
-        out->a = 255;
-    }
-
-    // Get the last palette color.
-    last_palette_color.r = pal[255 * 3];
-    last_palette_color.g = pal[255 * 3 + 1];
-    last_palette_color.b = pal[255 * 3 + 2];
-}
-
-// ------------------------------------------------------------------------------------------------
-void HL1MDLLoader::read_textures() {
-    const Texture_HL1 *ptexture = (const Texture_HL1 *)((uint8_t *)texture_header_ + texture_header_->textureindex);
-    unsigned char *pin = texture_buffer_;
-
-    scene_->mNumTextures = scene_->mNumMaterials = texture_header_->numtextures;
-    scene_->mTextures = new aiTexture *[scene_->mNumTextures];
-    scene_->mMaterials = new aiMaterial *[scene_->mNumMaterials];
-
-    for (int i = 0; i < texture_header_->numtextures; ++i) {
-        scene_->mTextures[i] = new aiTexture();
-
-        aiColor3D last_palette_color;
-        read_texture(&ptexture[i],
-                pin + ptexture[i].index,
-                pin + ptexture[i].width * ptexture[i].height + ptexture[i].index,
-                scene_->mTextures[i],
-                last_palette_color);
-
-        aiMaterial *scene_material = scene_->mMaterials[i] = new aiMaterial();
-
-        const aiTextureType texture_type = aiTextureType_DIFFUSE;
-        aiString texture_name(ptexture[i].name);
-        scene_material->AddProperty(&texture_name, AI_MATKEY_TEXTURE(texture_type, 0));
-
-        // Is this a chrome texture?
-        int chrome = ptexture[i].flags & AI_MDL_HL1_STUDIO_NF_CHROME ? 1 : 0;
-        scene_material->AddProperty(&chrome, 1, AI_MDL_HL1_MATKEY_CHROME(texture_type, 0));
-
-        if (ptexture[i].flags & AI_MDL_HL1_STUDIO_NF_FLATSHADE) {
-            // Flat shading.
-            const aiShadingMode shading_mode = aiShadingMode_Flat;
-            scene_material->AddProperty(&shading_mode, 1, AI_MATKEY_SHADING_MODEL);
-        }
-
-        if (ptexture[i].flags & AI_MDL_HL1_STUDIO_NF_ADDITIVE) {
-            // Additive texture.
-            const aiBlendMode blend_mode = aiBlendMode_Additive;
-            scene_material->AddProperty(&blend_mode, 1, AI_MATKEY_BLEND_FUNC);
-        } else if (ptexture[i].flags & AI_MDL_HL1_STUDIO_NF_MASKED) {
-            // Texture with 1 bit alpha test.
-            const aiTextureFlags use_alpha = aiTextureFlags_UseAlpha;
-            scene_material->AddProperty(&use_alpha, 1, AI_MATKEY_TEXFLAGS(texture_type, 0));
-            scene_material->AddProperty(&last_palette_color, 1, AI_MATKEY_COLOR_TRANSPARENT);
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void HL1MDLLoader::read_skins() {
-    // Read skins, if any.
-    if (texture_header_->numskinfamilies <= 1) {
-        return;
-    }
-
-    // Pointer to base texture index.
-    short *default_skin_ptr = (short *)((uint8_t *)texture_header_ + texture_header_->skinindex);
-
-    // Start at first replacement skin.
-    short *replacement_skin_ptr = default_skin_ptr + texture_header_->numskinref;
-
-    for (int i = 1; i < texture_header_->numskinfamilies; ++i, replacement_skin_ptr += texture_header_->numskinref) {
-        for (int j = 0; j < texture_header_->numskinref; ++j) {
-            if (default_skin_ptr[j] != replacement_skin_ptr[j]) {
-                // Save replacement textures.
-                aiString skinMaterialId(scene_->mTextures[replacement_skin_ptr[j]]->mFilename);
-                scene_->mMaterials[default_skin_ptr[j]]->AddProperty(&skinMaterialId, AI_MATKEY_TEXTURE_DIFFUSE(i));
-            }
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void HL1MDLLoader::read_bones() {
-    if (!header_->numbones) {
-        return;
-    }
-
-    const Bone_HL1 *pbone = (const Bone_HL1 *)((uint8_t *)header_ + header_->boneindex);
-
-    std::vector<std::string> unique_bones_names(header_->numbones);
-    for (int i = 0; i < header_->numbones; ++i) {
-        unique_bones_names[i] = pbone[i].name;
-    }
-
-    // Ensure bones have unique names.
-    unique_name_generator_.set_template_name("Bone");
-    unique_name_generator_.make_unique(unique_bones_names);
-
-    temp_bones_.resize(header_->numbones);
-
-    aiNode *bones_node = new aiNode(AI_MDL_HL1_NODE_BONES);
-    rootnode_children_.push_back(bones_node);
-    bones_node->mNumChildren = static_cast<unsigned int>(header_->numbones);
-    bones_node->mChildren = new aiNode *[bones_node->mNumChildren];
-
-    // Create bone matrices in local space.
-    for (int i = 0; i < header_->numbones; ++i) {
-        aiNode *bone_node = temp_bones_[i].node = bones_node->mChildren[i] = new aiNode(unique_bones_names[i]);
-
-        aiVector3D angles(pbone[i].value[3], pbone[i].value[4], pbone[i].value[5]);
-        temp_bones_[i].absolute_transform = bone_node->mTransformation =
-                aiMatrix4x4(aiVector3D(1), aiQuaternion(angles.y, angles.z, angles.x),
-                        aiVector3D(pbone[i].value[0], pbone[i].value[1], pbone[i].value[2]));
-
-        if (pbone[i].parent == -1) {
-            bone_node->mParent = scene_->mRootNode;
-        } else {
-            bone_node->mParent = bones_node->mChildren[pbone[i].parent];
-
-            temp_bones_[i].absolute_transform =
-                    temp_bones_[pbone[i].parent].absolute_transform * bone_node->mTransformation;
-        }
-
-        temp_bones_[i].offset_matrix = temp_bones_[i].absolute_transform;
-        temp_bones_[i].offset_matrix.Inverse();
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-/*
-    Read meshes.
-
-    Half-Life MDLs are structured such that each MDL
-    contains one or more 'bodypart(s)', which contain one
-    or more 'model(s)', which contains one or more mesh(es).
-
-    * Bodyparts are used to group models that may be replaced
-    in the game .e.g a character could have a 'heads' group,
-    'torso' group, 'shoes' group, with each group containing
-    different 'model(s)'.
-
-    * Models, also called 'sub models', contain vertices as
-    well as a reference to each mesh used by the sub model.
-
-    * Meshes contain a list of tris, also known as 'triverts'.
-    Each tris contains the following information:
-
-        1. The index of the position to use for the vertex.
-        2. The index of the normal to use for the vertex.
-        3. The S coordinate to use for the vertex UV.
-        4. The T coordinate ^
-
-    These tris represent the way to represent the triangles
-    for each mesh. Depending on how the tool compiled the MDL,
-    those triangles were saved as strips and or fans.
-
-    NOTE: Each tris is NOT unique. This means that you
-    might encounter the same vertex index but with a different
-    normal index, S coordinate, T coordinate.
-
-    In addition, each mesh contains the texture's index.
-
-    ------------------------------------------------------
-    With the details above, there are several things to
-    take into consideration.
-
-    * The Half-Life models store the vertices by sub model
-    rather than by mesh. Due to Assimp's structure, it
-    is necessary to remap each model vertex to be used
-    per mesh. Unfortunately, this has the consequence
-    to duplicate vertices.
-
-    * Because the mesh triangles are comprised of strips and
-    fans, it is necessary to convert each primitive to
-    triangles, respectively (3 indices per face).
-*/
-void HL1MDLLoader::read_meshes() {
-    if (!header_->numbodyparts) {
-        return;
-    }
-
-    int total_verts = 0;
-    int total_triangles = 0;
-    total_models_ = 0;
-
-    const Bodypart_HL1 *pbodypart = (const Bodypart_HL1 *)((uint8_t *)header_ + header_->bodypartindex);
-    const Model_HL1 *pmodel = nullptr;
-    const Mesh_HL1 *pmesh = nullptr;
-
-    const Texture_HL1 *ptexture = (const Texture_HL1 *)((uint8_t *)texture_header_ + texture_header_->textureindex);
-    short *pskinref = (short *)((uint8_t *)texture_header_ + texture_header_->skinindex);
-
-    scene_->mNumMeshes = 0;
-
-    std::vector<std::string> unique_bodyparts_names;
-    unique_bodyparts_names.resize(header_->numbodyparts);
-
-    // Count the number of meshes.
-
-    for (int i = 0; i < header_->numbodyparts; ++i, ++pbodypart) {
-        unique_bodyparts_names[i] = pbodypart->name;
-
-        pmodel = (Model_HL1 *)((uint8_t *)header_ + pbodypart->modelindex);
-        for (int j = 0; j < pbodypart->nummodels; ++j, ++pmodel) {
-            scene_->mNumMeshes += pmodel->nummesh;
-            total_verts += pmodel->numverts;
-        }
-
-        total_models_ += pbodypart->nummodels;
-    }
-
-    // Display limit infos.
-    if (total_verts > AI_MDL_HL1_MAX_VERTICES) {
-        log_warning_limit_exceeded<AI_MDL_HL1_MAX_VERTICES>(total_verts, "vertices");
-    }
-
-    if (scene_->mNumMeshes > AI_MDL_HL1_MAX_MESHES) {
-        log_warning_limit_exceeded<AI_MDL_HL1_MAX_MESHES>(scene_->mNumMeshes, "meshes");
-    }
-
-    if (total_models_ > AI_MDL_HL1_MAX_MODELS) {
-        log_warning_limit_exceeded<AI_MDL_HL1_MAX_MODELS>(total_models_, "models");
-    }
-
-    // Ensure bodyparts have unique names.
-    unique_name_generator_.set_template_name("Bodypart");
-    unique_name_generator_.make_unique(unique_bodyparts_names);
-
-    // Now do the same for each model.
-    pbodypart = (const Bodypart_HL1 *)((uint8_t *)header_ + header_->bodypartindex);
-
-    // Prepare template name for bodypart models.
-    std::vector<std::string> unique_models_names;
-    unique_models_names.resize(total_models_);
-
-    unsigned int model_index = 0;
-
-    for (int i = 0; i < header_->numbodyparts; ++i, ++pbodypart) {
-        pmodel = (Model_HL1 *)((uint8_t *)header_ + pbodypart->modelindex);
-        for (int j = 0; j < pbodypart->nummodels; ++j, ++pmodel, ++model_index)
-            unique_models_names[model_index] = pmodel->name;
-    }
-
-    unique_name_generator_.set_template_name("Model");
-    unique_name_generator_.make_unique(unique_models_names);
-
-    unsigned int mesh_index = 0;
-
-    scene_->mMeshes = new aiMesh *[scene_->mNumMeshes];
-
-    pbodypart = (const Bodypart_HL1 *)((uint8_t *)header_ + header_->bodypartindex);
-
-    /* Create a node that will represent the mesh hierarchy.
-
-        <MDL_bodyparts>
-            |
-            +-- bodypart --+-- model -- [mesh index, mesh index, ...]
-            |              |
-            |              +-- model -- [mesh index, mesh index, ...]
-            |              |           
-            |              ...
-            |
-            |-- bodypart -- ...
-            |
-            ...
-     */
-    aiNode *bodyparts_node = new aiNode(AI_MDL_HL1_NODE_BODYPARTS);
-    rootnode_children_.push_back(bodyparts_node);
-    bodyparts_node->mNumChildren = static_cast<unsigned int>(header_->numbodyparts);
-    bodyparts_node->mChildren = new aiNode *[bodyparts_node->mNumChildren];
-    aiNode **bodyparts_node_ptr = bodyparts_node->mChildren;
-
-    // The following variables are defined here so they don't have
-    // to be recreated every iteration.
-
-    // Model_HL1 vertices, in bind pose space.
-    std::vector<aiVector3D> bind_pose_vertices;
-
-    // Model_HL1 normals, in bind pose space.
-    std::vector<aiVector3D> bind_pose_normals;
-
-    // Used to contain temporary information for building a mesh.
-    std::vector<HL1MeshTrivert> triverts;
-
-    std::vector<short> tricmds;
-
-    // Which triverts to use for the mesh.
-    std::vector<short> mesh_triverts_indices;
-
-    std::vector<HL1MeshFace> mesh_faces;
-
-    /* triverts that have the same vertindex, but have different normindex,s,t values.
-       Similar triverts are mapped from vertindex to a list of similar triverts. */
-    std::map<short, std::set<short>> triverts_similars;
-
-    // triverts per bone.
-    std::map<int, std::set<short>> bone_triverts;
-
-    /** This function adds a trivert index to the list of triverts per bone.
-     * \param[in] bone The bone that affects the trivert at index \p trivert_index.
-     * \param[in] trivert_index The trivert index.
-     */
-    auto AddTrivertToBone = [&](int bone, short trivert_index) {
-        if (bone_triverts.count(bone) == 0)
-            bone_triverts.insert({ bone, std::set<short>{ trivert_index }});
-        else
-            bone_triverts[bone].insert(trivert_index);
-    };
-
-    /** This function creates and appends a new trivert to the list of triverts.
-     * \param[in] trivert The trivert to use as a prototype.
-     * \param[in] bone The bone that affects \p trivert.
-     */
-    auto AddSimilarTrivert = [&](const Trivert &trivert, const int bone) {
-        HL1MeshTrivert new_trivert(trivert);
-        new_trivert.localindex = static_cast<short>(mesh_triverts_indices.size());
-
-        short new_trivert_index = static_cast<short>(triverts.size());
-
-        if (triverts_similars.count(trivert.vertindex) == 0)
-            triverts_similars.insert({ trivert.vertindex, std::set<short>{ new_trivert_index }});
-        else
-            triverts_similars[trivert.vertindex].insert(new_trivert_index);
-
-        triverts.push_back(new_trivert);
-
-        mesh_triverts_indices.push_back(new_trivert_index);
-        tricmds.push_back(new_trivert.localindex);
-        AddTrivertToBone(bone, new_trivert.localindex);
-    };
-
-    model_index = 0;
-
-    for (int i = 0; i < header_->numbodyparts; ++i, ++pbodypart, ++bodyparts_node_ptr) {
-        pmodel = (const Model_HL1 *)((uint8_t *)header_ + pbodypart->modelindex);
-
-        // Create bodypart node for the mesh tree hierarchy.
-        aiNode *bodypart_node = (*bodyparts_node_ptr) = new aiNode(unique_bodyparts_names[i]);
-        bodypart_node->mParent = bodyparts_node;
-        bodypart_node->mMetaData = aiMetadata::Alloc(1);
-        bodypart_node->mMetaData->Set(0, "Base", pbodypart->base);
-
-        bodypart_node->mNumChildren = static_cast<unsigned int>(pbodypart->nummodels);
-        bodypart_node->mChildren = new aiNode *[bodypart_node->mNumChildren];
-        aiNode **bodypart_models_ptr = bodypart_node->mChildren;
-
-        for (int j = 0; j < pbodypart->nummodels;
-                ++j, ++pmodel, ++bodypart_models_ptr, ++model_index) {
-
-            pmesh = (const Mesh_HL1 *)((uint8_t *)header_ + pmodel->meshindex);
-
-            uint8_t *pvertbone = ((uint8_t *)header_ + pmodel->vertinfoindex);
-            uint8_t *pnormbone = ((uint8_t *)header_ + pmodel->norminfoindex);
-            vec3_t *pstudioverts = (vec3_t *)((uint8_t *)header_ + pmodel->vertindex);
-            vec3_t *pstudionorms = (vec3_t *)((uint8_t *)header_ + pmodel->normindex);
-
-            // Each vertex and normal is in local space, so transform
-            // each of them to bring them in bind pose.
-            bind_pose_vertices.resize(pmodel->numverts);
-            bind_pose_normals.resize(pmodel->numnorms);
-            for (size_t k = 0; k < bind_pose_vertices.size(); ++k) {
-                const vec3_t &vert = pstudioverts[k];
-                bind_pose_vertices[k] = temp_bones_[pvertbone[k]].absolute_transform * aiVector3D(vert[0], vert[1], vert[2]);
-            }
-            for (size_t k = 0; k < bind_pose_normals.size(); ++k) {
-                const vec3_t &norm = pstudionorms[k];
-                // Compute the normal matrix to transform the normal into bind pose,
-                // without affecting its length.
-                const aiMatrix4x4 normal_matrix = aiMatrix4x4(temp_bones_[pnormbone[k]].absolute_transform).Inverse().Transpose();
-                bind_pose_normals[k] = normal_matrix * aiVector3D(norm[0], norm[1], norm[2]);
-            }
-
-            // Create model node for the mesh tree hierarchy.
-            aiNode *model_node = (*bodypart_models_ptr) = new aiNode(unique_models_names[model_index]);
-            model_node->mParent = bodypart_node;
-            model_node->mNumMeshes = static_cast<unsigned int>(pmodel->nummesh);
-            model_node->mMeshes = new unsigned int[model_node->mNumMeshes];
-            unsigned int *model_meshes_ptr = model_node->mMeshes;
-
-            for (int k = 0; k < pmodel->nummesh; ++k, ++pmesh, ++mesh_index, ++model_meshes_ptr) {
-                *model_meshes_ptr = mesh_index;
-
-                // Read triverts.
-                short *ptricmds = (short *)((uint8_t *)header_ + pmesh->triindex);
-                float texcoords_s_scale = 1.0f / (float)ptexture[pskinref[pmesh->skinref]].width;
-                float texcoords_t_scale = 1.0f / (float)ptexture[pskinref[pmesh->skinref]].height;
-
-                // Reset the data for the upcoming mesh.
-                triverts.clear();
-                triverts.resize(pmodel->numverts);
-                mesh_triverts_indices.clear();
-                mesh_faces.clear();
-                triverts_similars.clear();
-                bone_triverts.clear();
-
-                int l;
-                while ((l = *(ptricmds++))) {
-                    bool is_triangle_fan = false;
-
-                    if (l < 0) {
-                        l = -l;
-                        is_triangle_fan = true;
-                    }
-
-                    // Clear the list of tris for the upcoming tris.
-                    tricmds.clear();
-
-                    for (; l > 0; l--, ptricmds += 4) {
-                        const Trivert *input_trivert = reinterpret_cast<const Trivert *>(ptricmds);
-                        const int bone = pvertbone[input_trivert->vertindex];
-
-                        HL1MeshTrivert *private_trivert = &triverts[input_trivert->vertindex];
-                        if (private_trivert->localindex == -1) {
-                            // First time referenced.
-                            *private_trivert = *input_trivert;
-                            private_trivert->localindex = static_cast<short>(mesh_triverts_indices.size());
-                            mesh_triverts_indices.push_back(input_trivert->vertindex);
-                            tricmds.push_back(private_trivert->localindex);
-                            AddTrivertToBone(bone, private_trivert->localindex);
-                        } else if (*private_trivert == *input_trivert) {
-                            // Exists and is the same.
-                            tricmds.push_back(private_trivert->localindex);
-                        } else {
-                            // No similar trivert associated to the trivert currently processed.
-                            if (triverts_similars.count(input_trivert->vertindex) == 0)
-                                AddSimilarTrivert(*input_trivert, bone);
-                            else {
-                                // Search in the list of similar triverts to see if the
-                                // trivert in process is already registered.
-                                short similar_index = -1;
-                                for (auto it = triverts_similars[input_trivert->vertindex].cbegin();
-                                        similar_index == -1 && it != triverts_similars[input_trivert->vertindex].cend();
-                                        ++it) {
-                                    if (triverts[*it] == *input_trivert)
-                                        similar_index = *it;
-                                }
-
-                                // If a similar trivert has been found, reuse it.
-                                // Otherwise, add it.
-                                if (similar_index == -1)
-                                    AddSimilarTrivert(*input_trivert, bone);
-                                else
-                                    tricmds.push_back(triverts[similar_index].localindex);
-                            }
-                        }
-                    }
-
-                    // Build mesh faces.
-                    const int num_faces = static_cast<int>(tricmds.size() - 2);
-                    mesh_faces.reserve(num_faces);
-
-                    if (is_triangle_fan) {
-                        for (int i = 0; i < num_faces; ++i) {
-                            mesh_faces.push_back(HL1MeshFace{
-                                    tricmds[0],
-                                    tricmds[i + 1],
-                                    tricmds[i + 2] });
-                        }
-                    } else {
-                        for (int i = 0; i < num_faces; ++i) {
-                            if (i & 1) {
-                                // Preserve winding order.
-                                mesh_faces.push_back(HL1MeshFace{
-                                        tricmds[i + 1],
-                                        tricmds[i],
-                                        tricmds[i + 2] });
-                            } else {
-                                mesh_faces.push_back(HL1MeshFace{
-                                        tricmds[i],
-                                        tricmds[i + 1],
-                                        tricmds[i + 2] });
-                            }
-                        }
-                    }
-
-                    total_triangles += num_faces;
-                }
-
-                // Create the scene mesh.
-                aiMesh *scene_mesh = scene_->mMeshes[mesh_index] = new aiMesh();
-                scene_mesh->mPrimitiveTypes = aiPrimitiveType::aiPrimitiveType_TRIANGLE;
-                scene_mesh->mMaterialIndex = pskinref[pmesh->skinref];
-
-                scene_mesh->mNumVertices = static_cast<unsigned int>(mesh_triverts_indices.size());
-
-                if (scene_mesh->mNumVertices) {
-                    scene_mesh->mVertices = new aiVector3D[scene_mesh->mNumVertices];
-                    scene_mesh->mNormals = new aiVector3D[scene_mesh->mNumVertices];
-
-                    scene_mesh->mNumUVComponents[0] = 2;
-                    scene_mesh->mTextureCoords[0] = new aiVector3D[scene_mesh->mNumVertices];
-
-                    // Add vertices.
-                    for (unsigned int v = 0; v < scene_mesh->mNumVertices; ++v) {
-                        const HL1MeshTrivert *pTrivert = &triverts[mesh_triverts_indices[v]];
-                        scene_mesh->mVertices[v] = bind_pose_vertices[pTrivert->vertindex];
-                        scene_mesh->mNormals[v] = bind_pose_normals[pTrivert->normindex];
-                        scene_mesh->mTextureCoords[0][v] = aiVector3D(
-                                pTrivert->s * texcoords_s_scale,
-                                pTrivert->t * texcoords_t_scale, 0);
-                    }
-
-                    // Add face and indices.
-                    scene_mesh->mNumFaces = static_cast<unsigned int>(mesh_faces.size());
-                    scene_mesh->mFaces = new aiFace[scene_mesh->mNumFaces];
-
-                    for (unsigned int f = 0; f < scene_mesh->mNumFaces; ++f) {
-                        aiFace *face = &scene_mesh->mFaces[f];
-                        face->mNumIndices = 3;
-                        face->mIndices = new unsigned int[3];
-                        face->mIndices[0] = mesh_faces[f].v0;
-                        face->mIndices[1] = mesh_faces[f].v1;
-                        face->mIndices[2] = mesh_faces[f].v2;
-                    }
-
-                    // Add mesh bones.
-                    scene_mesh->mNumBones = static_cast<unsigned int>(bone_triverts.size());
-                    scene_mesh->mBones = new aiBone *[scene_mesh->mNumBones];
-
-                    aiBone **scene_bone_ptr = scene_mesh->mBones;
-
-                    for (auto bone_it = bone_triverts.cbegin();
-                            bone_it != bone_triverts.cend();
-                            ++bone_it, ++scene_bone_ptr) {
-                        const int bone_index = bone_it->first;
-
-                        aiBone *scene_bone = (*scene_bone_ptr) = new aiBone();
-                        scene_bone->mName = temp_bones_[bone_index].node->mName;
-
-                        scene_bone->mOffsetMatrix = temp_bones_[bone_index].offset_matrix;
-
-                        auto vertex_ids = bone_triverts.at(bone_index);
-
-                        // Add vertex weight per bone.
-                        scene_bone->mNumWeights = static_cast<unsigned int>(vertex_ids.size());
-                        aiVertexWeight *vertex_weight_ptr = scene_bone->mWeights = new aiVertexWeight[scene_bone->mNumWeights];
-
-                        for (auto vertex_it = vertex_ids.begin();
-                                vertex_it != vertex_ids.end();
-                                ++vertex_it, ++vertex_weight_ptr) {
-                            vertex_weight_ptr->mVertexId = *vertex_it;
-                            vertex_weight_ptr->mWeight = 1.0f;
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    if (total_triangles > AI_MDL_HL1_MAX_TRIANGLES) {
-        log_warning_limit_exceeded<AI_MDL_HL1_MAX_TRIANGLES>(total_triangles, "triangles");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void HL1MDLLoader::read_animations() {
-    if (!header_->numseq) {
-        return;
-    }
-
-    const SequenceDesc_HL1 *pseqdesc = (const SequenceDesc_HL1 *)((uint8_t *)header_ + header_->seqindex);
-    const SequenceGroup_HL1 *pseqgroup = nullptr;
-    const AnimValueOffset_HL1 *panim = nullptr;
-    const AnimValue_HL1 *panimvalue = nullptr;
-
-    unique_sequence_names_.resize(header_->numseq);
-    for (int i = 0; i < header_->numseq; ++i)
-        unique_sequence_names_[i] = pseqdesc[i].label;
-
-    // Ensure sequences have unique names.
-    unique_name_generator_.set_template_name("Sequence");
-    unique_name_generator_.make_unique(unique_sequence_names_);
-
-    scene_->mNumAnimations = 0;
-
-    int highest_num_blend_animations = SequenceBlendMode_HL1::NoBlend;
-
-    // Count the total number of animations.
-    for (int i = 0; i < header_->numseq; ++i, ++pseqdesc) {
-        scene_->mNumAnimations += pseqdesc->numblends;
-        highest_num_blend_animations = std::max(pseqdesc->numblends, highest_num_blend_animations);
-    }
-
-    // Get the number of available blend controllers for global info.
-    get_num_blend_controllers(highest_num_blend_animations, num_blend_controllers_);
-
-    pseqdesc = (const SequenceDesc_HL1 *)((uint8_t *)header_ + header_->seqindex);
-
-    aiAnimation **scene_animations_ptr = scene_->mAnimations = new aiAnimation *[scene_->mNumAnimations];
-
-    for (int sequence = 0; sequence < header_->numseq; ++sequence, ++pseqdesc) {
-        pseqgroup = (const SequenceGroup_HL1 *)((uint8_t *)header_ + header_->seqgroupindex) + pseqdesc->seqgroup;
-
-        if (pseqdesc->seqgroup == 0) {
-            panim = (const AnimValueOffset_HL1 *)((uint8_t *)header_ + pseqgroup->unused2 + pseqdesc->animindex);
-        } else {
-            panim = (const AnimValueOffset_HL1 *)((uint8_t *)anim_headers_[pseqdesc->seqgroup] + pseqdesc->animindex);
-        }
-
-        for (int blend = 0; blend < pseqdesc->numblends; ++blend, ++scene_animations_ptr) {
-
-            const Bone_HL1 *pbone = (const Bone_HL1 *)((uint8_t *)header_ + header_->boneindex);
-
-            aiAnimation *scene_animation = (*scene_animations_ptr) = new aiAnimation();
-
-            scene_animation->mName = unique_sequence_names_[sequence];
-            scene_animation->mTicksPerSecond = pseqdesc->fps;
-            scene_animation->mDuration = static_cast<double>(pseqdesc->fps) * pseqdesc->numframes;
-            scene_animation->mNumChannels = static_cast<unsigned int>(header_->numbones);
-            scene_animation->mChannels = new aiNodeAnim *[scene_animation->mNumChannels];
-
-            for (int bone = 0; bone < header_->numbones; bone++, ++pbone, ++panim) {
-                aiNodeAnim *node_anim = scene_animation->mChannels[bone] = new aiNodeAnim();
-                node_anim->mNodeName = temp_bones_[bone].node->mName;
-
-                node_anim->mNumPositionKeys = pseqdesc->numframes;
-                node_anim->mNumRotationKeys = node_anim->mNumPositionKeys;
-                node_anim->mNumScalingKeys = 0;
-
-                node_anim->mPositionKeys = new aiVectorKey[node_anim->mNumPositionKeys];
-                node_anim->mRotationKeys = new aiQuatKey[node_anim->mNumRotationKeys];
-
-                for (int frame = 0; frame < pseqdesc->numframes; ++frame) {
-                    aiVectorKey *position_key = &node_anim->mPositionKeys[frame];
-                    aiQuatKey *rotation_key = &node_anim->mRotationKeys[frame];
-
-                    aiVector3D angle1;
-                    for (int j = 0; j < 3; ++j) {
-                        if (panim->offset[j + 3] != 0) {
-                            // Read compressed rotation delta.
-                            panimvalue = (const AnimValue_HL1 *)((uint8_t *)panim + panim->offset[j + 3]);
-                            extract_anim_value(panimvalue, frame, pbone->scale[j + 3], angle1[j]);
-                        }
-
-                        // Add the default rotation value.
-                        angle1[j] += pbone->value[j + 3];
-
-                        if (panim->offset[j] != 0) {
-                            // Read compressed position delta.
-                            panimvalue = (const AnimValue_HL1 *)((uint8_t *)panim + panim->offset[j]);
-                            extract_anim_value(panimvalue, frame, pbone->scale[j], position_key->mValue[j]);
-                        }
-
-                        // Add the default position value.
-                        position_key->mValue[j] += pbone->value[j];
-                    }
-
-                    position_key->mTime = rotation_key->mTime = static_cast<double>(frame);
-                    /* The Half-Life engine uses X as forward, Y as left, Z as up. Therefore,
-                       pitch,yaw,roll is represented as (YZX). */
-                    rotation_key->mValue = aiQuaternion(angle1.y, angle1.z, angle1.x);
-                    rotation_key->mValue.Normalize();
-                }
-            }
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void HL1MDLLoader::read_sequence_groups_info() {
-    if (!header_->numseqgroups) {
-        return;
-    }
-
-    aiNode *sequence_groups_node = new aiNode(AI_MDL_HL1_NODE_SEQUENCE_GROUPS);
-    rootnode_children_.push_back(sequence_groups_node);
-
-    sequence_groups_node->mNumChildren = static_cast<unsigned int>(header_->numseqgroups);
-    sequence_groups_node->mChildren = new aiNode *[sequence_groups_node->mNumChildren];
-
-    const SequenceGroup_HL1 *pseqgroup = (const SequenceGroup_HL1 *)((uint8_t *)header_ + header_->seqgroupindex);
-
-    unique_sequence_groups_names_.resize(header_->numseqgroups);
-    for (int i = 0; i < header_->numseqgroups; ++i) {
-        unique_sequence_groups_names_[i] = pseqgroup[i].label;
-    }
-
-    // Ensure sequence groups have unique names.
-    unique_name_generator_.set_template_name("SequenceGroup");
-    unique_name_generator_.make_unique(unique_sequence_groups_names_);
-
-    for (int i = 0; i < header_->numseqgroups; ++i, ++pseqgroup) {
-        aiNode *sequence_group_node = sequence_groups_node->mChildren[i] = new aiNode(unique_sequence_groups_names_[i]);
-        sequence_group_node->mParent = sequence_groups_node;
-
-        aiMetadata *md = sequence_group_node->mMetaData = aiMetadata::Alloc(1);
-        if (i == 0) {
-            /* StudioMDL does not write the file name for the default sequence group,
-               so we will write it. */
-            md->Set(0, "File", aiString(file_path_));
-        } else {
-            md->Set(0, "File", aiString(pseqgroup->name));
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void HL1MDLLoader::read_sequence_infos() {
-    if (!header_->numseq) {
-        return;
-    }
-
-    const SequenceDesc_HL1 *pseqdesc = (const SequenceDesc_HL1 *)((uint8_t *)header_ + header_->seqindex);
-
-    aiNode *sequence_infos_node = new aiNode(AI_MDL_HL1_NODE_SEQUENCE_INFOS);
-    rootnode_children_.push_back(sequence_infos_node);
-
-    sequence_infos_node->mNumChildren = static_cast<unsigned int>(header_->numseq);
-    sequence_infos_node->mChildren = new aiNode *[sequence_infos_node->mNumChildren];
-
-    std::vector<aiNode *> sequence_info_node_children;
-
-    int animation_index = 0;
-    for (int i = 0; i < header_->numseq; ++i, ++pseqdesc) {
-        // Clear the list of children for the upcoming sequence info node.
-        sequence_info_node_children.clear();
-
-        aiNode *sequence_info_node = sequence_infos_node->mChildren[i] = new aiNode(unique_sequence_names_[i]);
-        sequence_info_node->mParent = sequence_infos_node;
-
-        // Setup sequence info node Metadata.
-        aiMetadata *md = sequence_info_node->mMetaData = aiMetadata::Alloc(16);
-        md->Set(0, "AnimationIndex", animation_index);
-        animation_index += pseqdesc->numblends;
-
-        // Reference the sequence group by name. This allows us to search a particular
-        // sequence group by name using aiNode(s).
-        md->Set(1, "SequenceGroup", aiString(unique_sequence_groups_names_[pseqdesc->seqgroup]));
-        md->Set(2, "FramesPerSecond", pseqdesc->fps);
-        md->Set(3, "NumFrames", pseqdesc->numframes);
-        md->Set(4, "NumBlends", pseqdesc->numblends);
-        md->Set(5, "Activity", pseqdesc->activity);
-        md->Set(6, "ActivityWeight", pseqdesc->actweight);
-        md->Set(7, "MotionFlags", pseqdesc->motiontype);
-        md->Set(8, "MotionBone", temp_bones_[pseqdesc->motionbone].node->mName);
-        md->Set(9, "LinearMovement", aiVector3D(pseqdesc->linearmovement[0], pseqdesc->linearmovement[1], pseqdesc->linearmovement[2]));
-        md->Set(10, "BBMin", aiVector3D(pseqdesc->bbmin[0], pseqdesc->bbmin[1], pseqdesc->bbmin[2]));
-        md->Set(11, "BBMax", aiVector3D(pseqdesc->bbmax[0], pseqdesc->bbmax[1], pseqdesc->bbmax[2]));
-        md->Set(12, "EntryNode", pseqdesc->entrynode);
-        md->Set(13, "ExitNode", pseqdesc->exitnode);
-        md->Set(14, "NodeFlags", pseqdesc->nodeflags);
-        md->Set(15, "Flags", pseqdesc->flags);
-
-        if (import_settings_.read_blend_controllers) {
-            int num_blend_controllers;
-            if (get_num_blend_controllers(pseqdesc->numblends, num_blend_controllers) && num_blend_controllers) {
-                // Read blend controllers info.
-                aiNode *blend_controllers_node = new aiNode(AI_MDL_HL1_NODE_BLEND_CONTROLLERS);
-                sequence_info_node_children.push_back(blend_controllers_node);
-                blend_controllers_node->mParent = sequence_info_node;
-                blend_controllers_node->mNumChildren = static_cast<unsigned int>(num_blend_controllers);
-                blend_controllers_node->mChildren = new aiNode *[blend_controllers_node->mNumChildren];
-
-                for (unsigned int j = 0; j < blend_controllers_node->mNumChildren; ++j) {
-                    aiNode *blend_controller_node = blend_controllers_node->mChildren[j] = new aiNode();
-                    blend_controller_node->mParent = blend_controllers_node;
-
-                    aiMetadata *md = blend_controller_node->mMetaData = aiMetadata::Alloc(3);
-                    md->Set(0, "Start", pseqdesc->blendstart[j]);
-                    md->Set(1, "End", pseqdesc->blendend[j]);
-                    md->Set(2, "MotionFlags", pseqdesc->blendtype[j]);
-                }
-            }
-        }
-
-        if (import_settings_.read_animation_events && pseqdesc->numevents) {
-            // Read animation events.
-
-            if (pseqdesc->numevents > AI_MDL_HL1_MAX_EVENTS) {
-                log_warning_limit_exceeded<AI_MDL_HL1_MAX_EVENTS>(
-                        "Sequence " + std::string(pseqdesc->label),
-                        pseqdesc->numevents, "animation events");
-            }
-
-            const AnimEvent_HL1 *pevent = (const AnimEvent_HL1 *)((uint8_t *)header_ + pseqdesc->eventindex);
-
-            aiNode *pEventsNode = new aiNode(AI_MDL_HL1_NODE_ANIMATION_EVENTS);
-            sequence_info_node_children.push_back(pEventsNode);
-            pEventsNode->mParent = sequence_info_node;
-            pEventsNode->mNumChildren = static_cast<unsigned int>(pseqdesc->numevents);
-            pEventsNode->mChildren = new aiNode *[pEventsNode->mNumChildren];
-
-            for (unsigned int j = 0; j < pEventsNode->mNumChildren; ++j, ++pevent) {
-                aiNode *pEvent = pEventsNode->mChildren[j] = new aiNode();
-                pEvent->mParent = pEventsNode;
-
-                aiMetadata *md = pEvent->mMetaData = aiMetadata::Alloc(3);
-                md->Set(0, "Frame", pevent->frame);
-                md->Set(1, "ScriptEvent", pevent->event);
-                md->Set(2, "Options", aiString(pevent->options));
-            }
-        }
-
-        if (sequence_info_node_children.size()) {
-            sequence_info_node->addChildren(
-                    static_cast<unsigned int>(sequence_info_node_children.size()),
-                    sequence_info_node_children.data());
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void HL1MDLLoader::read_sequence_transitions() {
-    if (!header_->numtransitions) {
-        return;
-    }
-
-    // Read sequence transition graph.
-    aiNode *transition_graph_node = new aiNode(AI_MDL_HL1_NODE_SEQUENCE_TRANSITION_GRAPH);
-    rootnode_children_.push_back(transition_graph_node);
-
-    uint8_t *ptransitions = ((uint8_t *)header_ + header_->transitionindex);
-    aiMetadata *md = transition_graph_node->mMetaData = aiMetadata::Alloc(header_->numtransitions * header_->numtransitions);
-    for (unsigned int i = 0; i < md->mNumProperties; ++i)
-        md->Set(i, std::to_string(i), static_cast<int>(ptransitions[i]));
-}
-
-void HL1MDLLoader::read_attachments() {
-    if (!header_->numattachments) {
-        return;
-    }
-
-    const Attachment_HL1 *pattach = (const Attachment_HL1 *)((uint8_t *)header_ + header_->attachmentindex);
-
-    aiNode *attachments_node = new aiNode(AI_MDL_HL1_NODE_ATTACHMENTS);
-    rootnode_children_.push_back(attachments_node);
-    attachments_node->mNumChildren = static_cast<unsigned int>(header_->numattachments);
-    attachments_node->mChildren = new aiNode *[attachments_node->mNumChildren];
-
-    for (int i = 0; i < header_->numattachments; ++i, ++pattach) {
-        aiNode *attachment_node = attachments_node->mChildren[i] = new aiNode();
-        attachment_node->mParent = attachments_node;
-        attachment_node->mMetaData = aiMetadata::Alloc(2);
-        attachment_node->mMetaData->Set(0, "Position", aiVector3D(pattach->org[0], pattach->org[1], pattach->org[2]));
-        // Reference the bone by name. This allows us to search a particular
-        // bone by name using aiNode(s).
-        attachment_node->mMetaData->Set(1, "Bone", temp_bones_[pattach->bone].node->mName);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void HL1MDLLoader::read_hitboxes() {
-    if (!header_->numhitboxes) {
-        return;
-    }
-
-    const Hitbox_HL1 *phitbox = (const Hitbox_HL1 *)((uint8_t *)header_ + header_->hitboxindex);
-
-    aiNode *hitboxes_node = new aiNode(AI_MDL_HL1_NODE_HITBOXES);
-    rootnode_children_.push_back(hitboxes_node);
-    hitboxes_node->mNumChildren = static_cast<unsigned int>(header_->numhitboxes);
-    hitboxes_node->mChildren = new aiNode *[hitboxes_node->mNumChildren];
-
-    for (int i = 0; i < header_->numhitboxes; ++i, ++phitbox) {
-        aiNode *hitbox_node = hitboxes_node->mChildren[i] = new aiNode();
-        hitbox_node->mParent = hitboxes_node;
-
-        aiMetadata *md = hitbox_node->mMetaData = aiMetadata::Alloc(4);
-        // Reference the bone by name. This allows us to search a particular
-        // bone by name using aiNode(s).
-        md->Set(0, "Bone", temp_bones_[phitbox->bone].node->mName);
-        md->Set(1, "HitGroup", phitbox->group);
-        md->Set(2, "BBMin", aiVector3D(phitbox->bbmin[0], phitbox->bbmin[1], phitbox->bbmin[2]));
-        md->Set(3, "BBMax", aiVector3D(phitbox->bbmax[0], phitbox->bbmax[1], phitbox->bbmax[2]));
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void HL1MDLLoader::read_bone_controllers() {
-    if (!header_->numbonecontrollers) {
-        return;
-    }
-
-    const BoneController_HL1 *pbonecontroller = (const BoneController_HL1 *)((uint8_t *)header_ + header_->bonecontrollerindex);
-
-    aiNode *bones_controller_node = new aiNode(AI_MDL_HL1_NODE_BONE_CONTROLLERS);
-    rootnode_children_.push_back(bones_controller_node);
-    bones_controller_node->mNumChildren = static_cast<unsigned int>(header_->numbonecontrollers);
-    bones_controller_node->mChildren = new aiNode *[bones_controller_node->mNumChildren];
-
-    for (int i = 0; i < header_->numbonecontrollers; ++i, ++pbonecontroller) {
-        aiNode *bone_controller_node = bones_controller_node->mChildren[i] = new aiNode();
-        bone_controller_node->mParent = bones_controller_node;
-
-        aiMetadata *md = bone_controller_node->mMetaData = aiMetadata::Alloc(5);
-        // Reference the bone by name. This allows us to search a particular
-        // bone by name using aiNode(s).
-        md->Set(0, "Bone", temp_bones_[pbonecontroller->bone].node->mName);
-        md->Set(1, "MotionFlags", pbonecontroller->type);
-        md->Set(2, "Start", pbonecontroller->start);
-        md->Set(3, "End", pbonecontroller->end);
-        md->Set(4, "Channel", pbonecontroller->index);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void HL1MDLLoader::read_global_info() {
-    aiNode *global_info_node = new aiNode(AI_MDL_HL1_NODE_GLOBAL_INFO);
-    rootnode_children_.push_back(global_info_node);
-
-    aiMetadata *md = global_info_node->mMetaData = aiMetadata::Alloc(import_settings_.read_misc_global_info ? 16 : 11);
-    md->Set(0, "Version", AI_MDL_HL1_VERSION);
-    md->Set(1, "NumBodyparts", header_->numbodyparts);
-    md->Set(2, "NumModels", total_models_);
-    md->Set(3, "NumBones", header_->numbones);
-    md->Set(4, "NumAttachments", import_settings_.read_attachments ? header_->numattachments : 0);
-    md->Set(5, "NumSkinFamilies", texture_header_->numskinfamilies);
-    md->Set(6, "NumHitboxes", import_settings_.read_hitboxes ? header_->numhitboxes : 0);
-    md->Set(7, "NumBoneControllers", import_settings_.read_bone_controllers ? header_->numbonecontrollers : 0);
-    md->Set(8, "NumSequences", import_settings_.read_animations ? header_->numseq : 0);
-    md->Set(9, "NumBlendControllers", import_settings_.read_blend_controllers ? num_blend_controllers_ : 0);
-    md->Set(10, "NumTransitionNodes", import_settings_.read_sequence_transitions ? header_->numtransitions : 0);
-
-    if (import_settings_.read_misc_global_info) {
-        md->Set(11, "EyePosition", aiVector3D(header_->eyeposition[0], header_->eyeposition[1], header_->eyeposition[2]));
-        md->Set(12, "HullMin", aiVector3D(header_->min[0], header_->min[1], header_->min[2]));
-        md->Set(13, "HullMax", aiVector3D(header_->max[0], header_->max[1], header_->max[2]));
-        md->Set(14, "CollisionMin", aiVector3D(header_->bbmin[0], header_->bbmin[1], header_->bbmin[2]));
-        md->Set(15, "CollisionMax", aiVector3D(header_->bbmax[0], header_->bbmax[1], header_->bbmax[2]));
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-/** @brief This method reads a compressed anim value.
-*
-*   @note The structure of this method is taken from HL2 source code.
-*   Although this is from HL2, it's implementation is almost identical
-*   to code found in HL1 SDK. See HL1 and HL2 SDKs for more info.
-*   
-*   source:
-*       HL1 source code.
-*           file: studio_render.cpp
-*           function(s): CalcBoneQuaternion and CalcBonePosition
-*
-*       HL2 source code.
-*           file: bone_setup.cpp
-*           function(s): ExtractAnimValue
-*/
-void HL1MDLLoader::extract_anim_value(
-        const AnimValue_HL1 *panimvalue,
-        int frame, float bone_scale, float &value) {
-    int k = frame;
-
-    // find span of values that includes the frame we want
-    while (panimvalue->num.total <= k) {
-        k -= panimvalue->num.total;
-        panimvalue += panimvalue->num.valid + 1;
-    }
-
-    // Bah, missing blend!
-    if (panimvalue->num.valid > k) {
-        value = panimvalue[k + 1].value * bone_scale;
-    } else {
-        value = panimvalue[panimvalue->num.valid].value * bone_scale;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Get the number of blend controllers.
-bool HL1MDLLoader::get_num_blend_controllers(const int num_blend_animations, int &num_blend_controllers) {
-
-    switch (num_blend_animations) {
-        case SequenceBlendMode_HL1::NoBlend:
-            num_blend_controllers = 0;
-            return true;
-        case SequenceBlendMode_HL1::TwoWayBlending:
-            num_blend_controllers = 1;
-            return true;
-        case SequenceBlendMode_HL1::FourWayBlending:
-            num_blend_controllers = 2;
-            return true;
-        default:
-            num_blend_controllers = 0;
-            ASSIMP_LOG_WARN(MDL_HALFLIFE_LOG_HEADER "Unsupported number of blend animations (" + std::to_string(num_blend_animations) + ")");
-            return false;
-    }
-}
-
-} // namespace HalfLife
-} // namespace MDL
-} // namespace Assimp
diff --git a/Engine/lib/assimp/code/MDL/HalfLife/HL1MDLLoader.h b/Engine/lib/assimp/code/MDL/HalfLife/HL1MDLLoader.h
deleted file mode 100644
index c4293259c..000000000
--- a/Engine/lib/assimp/code/MDL/HalfLife/HL1MDLLoader.h
+++ /dev/null
@@ -1,241 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-/** @file HL1MDLLoader.h
- *  @brief Declaration of the Half-Life 1 MDL loader.
- */
-
-#ifndef AI_HL1MDLLOADER_INCLUDED
-#define AI_HL1MDLLOADER_INCLUDED
-
-#include "HL1FileData.h"
-#include "HL1ImportSettings.h"
-#include "UniqueNameGenerator.h"
-
-#include <memory>
-#include <string>
-
-#include <assimp/types.h>
-#include <assimp/scene.h>
-#include <assimp/texture.h>
-#include <assimp/IOSystem.hpp>
-#include <assimp/DefaultIOSystem.h>
-#include <assimp/Exceptional.h>
-
-namespace Assimp {
-namespace MDL {
-namespace HalfLife {
-
-class HL1MDLLoader {
-public:
-    HL1MDLLoader() = delete;
-    HL1MDLLoader(const HL1MDLLoader &) = delete;
-
-    /** See variables descriptions at the end for more details. */
-    HL1MDLLoader(
-        aiScene *scene,
-        IOSystem *io,
-        const unsigned char *buffer,
-        const std::string &file_path,
-        const HL1ImportSettings &import_settings);
-
-    ~HL1MDLLoader();
-
-    void load_file();
-
-protected:
-    /** \brief Validate the header data structure of a Half-Life 1 MDL file.
-     * \param[in] header Input header to be validated.
-     * \param[in] is_texture_header Whether or not we are reading an MDL
-     *   texture file.
-     */
-    void validate_header(const Header_HL1 *header, bool is_texture_header);
-
-    void load_texture_file();
-    void load_sequence_groups_files();
-    void read_textures();
-    void read_skins();
-    void read_bones();
-    void read_meshes();
-    void read_animations();
-    void read_sequence_groups_info();
-    void read_sequence_infos();
-    void read_sequence_transitions();
-    void read_attachments();
-    void read_hitboxes();
-    void read_bone_controllers();
-    void read_global_info();
-
-private:
-    void release_resources();
-
-    /** \brief Load a file and copy it's content to a buffer.
-     * \param file_path The path to the file to be loaded.
-     * \param buffer A pointer to a buffer to receive the data.
-     */
-    template <typename MDLFileHeader>
-    void load_file_into_buffer(const std::string &file_path, unsigned char *&buffer);
-
-    /** \brief Read an MDL texture.
-     * \param[in] ptexture A pointer to an MDL texture.
-     * \param[in] data A pointer to the data from \p ptexture.
-     * \param[in] pal A pointer to the texture palette from \p ptexture.
-     * \param[in,out] pResult A pointer to the output resulting Assimp texture.
-     * \param[in,out] last_palette_color The last color from the image palette.
-     */
-    void read_texture(const Texture_HL1 *ptexture,
-            uint8_t *data, uint8_t *pal, aiTexture *pResult,
-            aiColor3D &last_palette_color);
-
-    /** \brief This method reads a compressed anim value.
-    * \param[in] panimvalue A pointer to the animation data.
-    * \param[in] frame The frame to look for.
-    * \param[in] bone_scale The current bone scale to apply to the compressed value.
-    * \param[in,out] value The decompressed anim value at \p frame.
-    */
-    void extract_anim_value(const AnimValue_HL1 *panimvalue,
-            int frame, float bone_scale, float &value);
-
-    /**
-     *  \brief Given the number of blend animations, determine the number of blend controllers.
-     *
-     * \param[in] num_blend_animations The number of blend animations.
-     * \param[out] num_blend_controllers The number of blend controllers.
-     * \return True if the number of blend controllers was determined. False otherwise.
-     */
-    static bool get_num_blend_controllers(const int num_blend_animations, int &num_blend_controllers);
-
-    /** Output scene to be filled */
-    aiScene *scene_;
-
-    /** Output I/O handler. Required for additional IO operations. */
-    IOSystem *io_;
-
-    /** Buffer from MDLLoader class. */
-    const unsigned char *buffer_;
-
-    /** The full file path to the MDL file we are trying to load.
-     * Used to locate other MDL files since MDL may store resources
-     * in external MDL files. */
-    const std::string &file_path_;
-
-    /** Configuration for HL1 MDL */
-    const HL1ImportSettings &import_settings_;
-
-    /** Main MDL header. */
-    const Header_HL1 *header_;
-
-    /** External MDL texture header. */
-    const Header_HL1 *texture_header_;
-
-    /** External MDL animation headers.
-     * One for each loaded animation file. */
-    SequenceHeader_HL1 **anim_headers_;
-
-    /** Texture file data. */
-    unsigned char *texture_buffer_;
-
-    /** Animation files data. */
-    unsigned char **anim_buffers_;
-
-    /** The number of sequence groups. */
-    int num_sequence_groups_;
-
-    /** The list of children to be appended to the scene's root node. */
-    std::vector<aiNode *> rootnode_children_;
-
-    /** A unique name generator. Used to generate names for MDL values
-     * that may have empty/duplicate names. */
-    UniqueNameGenerator unique_name_generator_;
-
-    /** The list of unique sequence names. */
-    std::vector<std::string> unique_sequence_names_;
-
-    /** The list of unique sequence groups names. */
-    std::vector<std::string> unique_sequence_groups_names_;
-
-    /** Structure to store temporary bone information. */
-    struct TempBone {
-
-        TempBone() :
-            node(nullptr),
-            absolute_transform(),
-            offset_matrix() {}
-
-        aiNode *node;
-        aiMatrix4x4 absolute_transform;
-        aiMatrix4x4 offset_matrix;
-    };
-
-    std::vector<TempBone> temp_bones_;
-
-    /** The number of available bone controllers in the model. */
-    int num_blend_controllers_;
-
-    /** Self explanatory. */
-    int total_models_;
-};
-
-// ------------------------------------------------------------------------------------------------
-template <typename MDLFileHeader>
-void HL1MDLLoader::load_file_into_buffer(const std::string &file_path, unsigned char *&buffer) {
-    if (!io_->Exists(file_path))
-        throw DeadlyImportError("Missing file " + DefaultIOSystem::fileName(file_path) + ".");
-
-    std::unique_ptr<IOStream> file(io_->Open(file_path));
-
-    if (file.get() == NULL)
-        throw DeadlyImportError("Failed to open MDL file " + DefaultIOSystem::fileName(file_path) + ".");
-
-    const size_t file_size = file->FileSize();
-    if (file_size < sizeof(MDLFileHeader))
-        throw DeadlyImportError("MDL file is too small.");
-
-    buffer = new unsigned char[1 + file_size];
-    file->Read((void *)buffer, 1, file_size);
-    buffer[file_size] = '\0';
-}
-
-} // namespace HalfLife
-} // namespace MDL
-} // namespace Assimp
-
-#endif // AI_HL1MDLLOADER_INCLUDED
diff --git a/Engine/lib/assimp/code/MDL/HalfLife/HL1MeshTrivert.h b/Engine/lib/assimp/code/MDL/HalfLife/HL1MeshTrivert.h
deleted file mode 100644
index b61765663..000000000
--- a/Engine/lib/assimp/code/MDL/HalfLife/HL1MeshTrivert.h
+++ /dev/null
@@ -1,127 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-/** @file HL1MeshTrivert.h
- *  @brief This file contains the class declaration for the
- *         HL1 mesh trivert class.
- */
-
-#ifndef AI_HL1MESHTRIVERT_INCLUDED
-#define AI_HL1MESHTRIVERT_INCLUDED
-
-#include "HL1FileData.h"
-
-namespace Assimp {
-namespace MDL {
-namespace HalfLife {
-
-/* A class to help map model triverts to mesh triverts. */
-struct HL1MeshTrivert {
-    HL1MeshTrivert() :
-        vertindex(-1),
-        normindex(-1),
-        s(0),
-        t(0),
-        localindex(-1) {
-    }
-
-    HL1MeshTrivert(short vertindex, short normindex, short s, short t, short localindex) :
-        vertindex(vertindex),
-        normindex(normindex),
-        s(s),
-        t(t),
-        localindex() {
-    }
-
-    HL1MeshTrivert(const Trivert &a) :
-        vertindex(a.vertindex),
-        normindex(a.normindex),
-        s(a.s),
-        t(a.t),
-        localindex(-1) {
-    }
-
-    inline bool operator==(const Trivert &a) const {
-        return vertindex == a.vertindex &&
-               normindex == a.normindex &&
-               s == a.s &&
-               t == a.t;
-    }
-
-    inline bool operator!=(const Trivert &a) const {
-        return !(*this == a);
-    }
-
-    inline bool operator==(const HL1MeshTrivert &a) const {
-        return localindex == a.localindex &&
-               vertindex == a.vertindex &&
-               normindex == a.normindex &&
-               s == a.s &&
-               t == a.t;
-    }
-
-    inline bool operator!=(const HL1MeshTrivert &a) const {
-        return !(*this == a);
-    }
-
-    inline HL1MeshTrivert &operator=(const Trivert &other) {
-        vertindex = other.vertindex;
-        normindex = other.normindex;
-        s = other.s;
-        t = other.t;
-        return *this;
-    }
-
-    short vertindex;
-    short normindex;
-    short s, t;
-    short localindex;
-};
-
-struct HL1MeshFace {
-    short v0, v1, v2;
-};
-
-} // namespace HalfLife
-} // namespace MDL
-} // namespace Assimp
-
-#endif // AI_HL1MESHTRIVERT_INCLUDED
diff --git a/Engine/lib/assimp/code/MDL/HalfLife/LogFunctions.h b/Engine/lib/assimp/code/MDL/HalfLife/LogFunctions.h
deleted file mode 100644
index 5e18a8df7..000000000
--- a/Engine/lib/assimp/code/MDL/HalfLife/LogFunctions.h
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-/** @file LogFunctions.h */
-
-#ifndef AI_MDL_HALFLIFE_LOGFUNCTIONS_INCLUDED
-#define AI_MDL_HALFLIFE_LOGFUNCTIONS_INCLUDED
-
-#include <assimp/Logger.hpp>
-#include <string>
-
-namespace Assimp {
-namespace MDL {
-namespace HalfLife {
-
-/**
- * \brief A function to log precise messages regarding limits exceeded.
- *
- * \param[in] subject Subject.
- * \param[in] current_amount Current amount.
- * \param[in] direct_object Direct object.
- *            LIMIT Limit constant.
- *
- * Example: Model has 100 textures, which exceeds the limit (50)
- *
- *          where \p subject is 'Model'
- *                \p current_amount is '100'
- *                \p direct_object is 'textures'
- *                LIMIT is '50'
- */
-template <int LIMIT>
-static inline void log_warning_limit_exceeded(
-    const std::string &subject, int current_amount,
-    const std::string &direct_object) {
-
-    ASSIMP_LOG_WARN(MDL_HALFLIFE_LOG_HEADER
-        + subject
-        + " has "
-        + std::to_string(current_amount) + " "
-        + direct_object
-        + ", which exceeds the limit ("
-        + std::to_string(LIMIT)
-        + ")");
-}
-
-/** \brief Same as above, but uses 'Model' as the subject. */
-template <int LIMIT>
-static inline void log_warning_limit_exceeded(int current_amount,
-    const std::string &direct_object) {
-    log_warning_limit_exceeded<LIMIT>("Model", current_amount, direct_object);
-}
-
-} // namespace HalfLife
-} // namespace MDL
-} // namespace Assimp
-
-#endif // AI_MDL_HALFLIFE_LOGFUNCTIONS_INCLUDED
diff --git a/Engine/lib/assimp/code/MDL/HalfLife/UniqueNameGenerator.cpp b/Engine/lib/assimp/code/MDL/HalfLife/UniqueNameGenerator.cpp
deleted file mode 100644
index 417a6baef..000000000
--- a/Engine/lib/assimp/code/MDL/HalfLife/UniqueNameGenerator.cpp
+++ /dev/null
@@ -1,180 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-/** @file UniqueNameGenerator.cpp
- *  @brief Implementation for the unique name generator.
- */
-
-#include "UniqueNameGenerator.h"
-#include <algorithm>
-#include <list>
-#include <map>
-#include <numeric>
-
-namespace Assimp {
-namespace MDL {
-namespace HalfLife {
-
-UniqueNameGenerator::UniqueNameGenerator() :
-    template_name_("unnamed"),
-    separator_("_") {
-}
-
-UniqueNameGenerator::UniqueNameGenerator(const char *template_name) :
-    template_name_(template_name),
-    separator_("_") {
-}
-
-UniqueNameGenerator::UniqueNameGenerator(const char *template_name, const char *separator) :
-    template_name_(template_name),
-    separator_(separator) {
-}
-
-UniqueNameGenerator::~UniqueNameGenerator() {
-}
-
-void UniqueNameGenerator::make_unique(std::vector<std::string> &names) {
-    struct DuplicateInfo {
-        DuplicateInfo() :
-            indices(),
-            next_id(0) {
-        }
-
-        std::list<size_t> indices;
-        size_t next_id;
-    };
-
-    std::vector<size_t> empty_names_indices;
-    std::vector<size_t> template_name_duplicates;
-    std::map<std::string, DuplicateInfo> names_to_duplicates;
-
-    const std::string template_name_with_separator(template_name_ + separator_);
-
-    auto format_name = [&](const std::string &base_name, size_t id) -> std::string {
-        return base_name + separator_ + std::to_string(id);
-    };
-
-    auto generate_unique_name = [&](const std::string &base_name) -> std::string {
-        auto *duplicate_info = &names_to_duplicates[base_name];
-
-        std::string new_name = "";
-
-        bool found_identical_name;
-        bool tried_with_base_name_only = false;
-        do {
-            // Assume that no identical name exists.
-            found_identical_name = false;
-
-            if (!tried_with_base_name_only) {
-                // First try with only the base name.
-                new_name = base_name;
-            } else {
-                // Create the name expected to be unique.
-                new_name = format_name(base_name, duplicate_info->next_id);
-            }
-
-            // Check in the list of duplicates for an identical name.
-            for (size_t i = 0;
-                    i < names.size() &&
-                    !found_identical_name;
-                    ++i) {
-                if (new_name == names[i])
-                    found_identical_name = true;
-            }
-
-            if (tried_with_base_name_only)
-                ++duplicate_info->next_id;
-
-            tried_with_base_name_only = true;
-
-        } while (found_identical_name);
-
-        return new_name;
-    };
-
-    for (size_t i = 0; i < names.size(); ++i) {
-        // Check for empty names.
-        if (names[i].find_first_not_of(' ') == std::string::npos) {
-            empty_names_indices.push_back(i);
-            continue;
-        }
-
-        /* Check for potential duplicate.
-        a) Either if this name is the same as the template name or
-        b) <template name><separator> is found at the beginning. */
-        if (names[i] == template_name_ ||
-                names[i].substr(0, template_name_with_separator.length()) == template_name_with_separator)
-            template_name_duplicates.push_back(i);
-
-        // Map each unique name to it's duplicate.
-        if (names_to_duplicates.count(names[i]) == 0)
-            names_to_duplicates.insert({ names[i], DuplicateInfo()});
-        else
-            names_to_duplicates[names[i]].indices.push_back(i);
-    }
-
-    // Make every non-empty name unique.
-    for (auto it = names_to_duplicates.begin();
-            it != names_to_duplicates.end(); ++it) {
-        for (auto it2 = it->second.indices.begin();
-                it2 != it->second.indices.end();
-                ++it2)
-            names[*it2] = generate_unique_name(it->first);
-    }
-
-    // Generate a unique name for every empty string.
-    if (template_name_duplicates.size()) {
-        // At least one string ressembles to <template name>.
-        for (auto it = empty_names_indices.begin();
-                it != empty_names_indices.end(); ++it)
-            names[*it] = generate_unique_name(template_name_);
-    } else {
-        // No string alike <template name> exists.
-        size_t i = 0;
-        for (auto it = empty_names_indices.begin();
-                it != empty_names_indices.end(); ++it, ++i)
-            names[*it] = format_name(template_name_, i);
-    }
-}
-
-} // namespace HalfLife
-} // namespace MDL
-} // namespace Assimp
diff --git a/Engine/lib/assimp/code/MDL/HalfLife/UniqueNameGenerator.h b/Engine/lib/assimp/code/MDL/HalfLife/UniqueNameGenerator.h
deleted file mode 100644
index 131a46dc4..000000000
--- a/Engine/lib/assimp/code/MDL/HalfLife/UniqueNameGenerator.h
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-/** @file UniqueNameGenerator.h
- *  @brief Declaration of the unique name generator.
- */
-
-#ifndef AI_UNIQUENAMEGENERATOR_INCLUDED
-#define AI_UNIQUENAMEGENERATOR_INCLUDED
-
-#include <string>
-#include <vector>
-
-namespace Assimp {
-namespace MDL {
-namespace HalfLife {
-
-class UniqueNameGenerator {
-public:
-    UniqueNameGenerator();
-    UniqueNameGenerator(const char *template_name);
-    UniqueNameGenerator(const char *template_name, const char *separator);
-    ~UniqueNameGenerator();
-
-    inline void set_template_name(const char *template_name) {
-        template_name_ = template_name;
-    }
-    inline void set_separator(const char *separator) {
-        separator_ = separator;
-    }
-
-    void make_unique(std::vector<std::string> &names);
-
-private:
-    std::string template_name_;
-    std::string separator_;
-};
-
-} // namespace HalfLife
-} // namespace MDL
-} // namespace Assimp
-
-#endif // AI_UNIQUENAMEGENERATOR_INCLUDED
diff --git a/Engine/lib/assimp/code/MDL/MDLDefaultColorMap.h b/Engine/lib/assimp/code/MDL/MDLDefaultColorMap.h
index 8c60d1b58..58f642884 100644
--- a/Engine/lib/assimp/code/MDL/MDLDefaultColorMap.h
+++ b/Engine/lib/assimp/code/MDL/MDLDefaultColorMap.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/MDL/MDLFileData.h b/Engine/lib/assimp/code/MDL/MDLFileData.h
index 8ccaf90a2..f33a57731 100644
--- a/Engine/lib/assimp/code/MDL/MDLFileData.h
+++ b/Engine/lib/assimp/code/MDL/MDLFileData.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/MDL/MDLLoader.cpp b/Engine/lib/assimp/code/MDL/MDLLoader.cpp
index 11c6e3ecb..9c9ce2330 100644
--- a/Engine/lib/assimp/code/MDL/MDLLoader.cpp
+++ b/Engine/lib/assimp/code/MDL/MDLLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
@@ -51,8 +51,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "MDL/MDLLoader.h"
 #include "MDL/MDLDefaultColorMap.h"
 #include "MD2/MD2FileData.h"
-#include "MDL/HalfLife/HL1MDLLoader.h"
 
+#include <assimp/Macros.h>
 #include <assimp/qnan.h>
 #include <assimp/StringUtils.h>
 #include <assimp/Importer.hpp>
@@ -143,18 +143,6 @@ void MDLImporter::SetupProperties(const Importer* pImp)
 
     // AI_CONFIG_IMPORT_MDL_COLORMAP - palette file
     configPalette =  pImp->GetPropertyString(AI_CONFIG_IMPORT_MDL_COLORMAP,"colormap.lmp");
-
-    // Read configuration specific to MDL (Half-Life 1).
-    mHL1ImportSettings.read_animations = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_ANIMATIONS, true);
-    if (mHL1ImportSettings.read_animations) {
-        mHL1ImportSettings.read_animation_events = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_ANIMATION_EVENTS, true);
-        mHL1ImportSettings.read_blend_controllers = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_BLEND_CONTROLLERS, true);
-        mHL1ImportSettings.read_sequence_transitions = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_SEQUENCE_TRANSITIONS, true);
-    }
-    mHL1ImportSettings.read_attachments = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_ATTACHMENTS, true);
-    mHL1ImportSettings.read_bone_controllers = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_BONE_CONTROLLERS, true);
-    mHL1ImportSettings.read_hitboxes = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_HITBOXES, true);
-    mHL1ImportSettings.read_misc_global_info = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_MISC_GLOBAL_INFO, true);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -179,104 +167,83 @@ void MDLImporter::InternReadFile( const std::string& pFile,
     }
 
     // This should work for all other types of MDL files, too ...
-    // the HL1 sequence group header is one of the smallest, afaik
+    // the quake header is one of the smallest, afaik
     iFileSize = (unsigned int)file->FileSize();
-    if( iFileSize < sizeof(MDL::HalfLife::SequenceHeader_HL1)) {
+    if( iFileSize < sizeof(MDL::Header)) {
         throw DeadlyImportError( "MDL File is too small.");
     }
-    
-    // delete the file buffer and cleanup.
-    auto DeleteBufferAndCleanup = [&]() {
-        if (mBuffer) {
-            delete [] mBuffer;
-            mBuffer = nullptr;
-        }
-        AI_DEBUG_INVALIDATE_PTR(pIOHandler);
-        AI_DEBUG_INVALIDATE_PTR(pScene);
-    };
-    
-    try {
-        // Allocate storage and copy the contents of the file to a memory buffer
-        mBuffer = new unsigned char[iFileSize+1];
-        file->Read( (void*)mBuffer, 1, iFileSize);
 
-        // Append a binary zero to the end of the buffer.
-        // this is just for safety that string parsing routines
-        // find the end of the buffer ...
-        mBuffer[iFileSize] = '\0';
-        const uint32_t iMagicWord = *((uint32_t*)mBuffer);
+    // Allocate storage and copy the contents of the file to a memory buffer
+    mBuffer =new unsigned char[iFileSize+1];
+    file->Read( (void*)mBuffer, 1, iFileSize);
 
-        // Determine the file subtype and call the appropriate member function
+    // Append a binary zero to the end of the buffer.
+    // this is just for safety that string parsing routines
+    // find the end of the buffer ...
+    mBuffer[iFileSize] = '\0';
+    const uint32_t iMagicWord = *((uint32_t*)mBuffer);
 
-        // Original Quake1 format
-        if (AI_MDL_MAGIC_NUMBER_BE == iMagicWord || AI_MDL_MAGIC_NUMBER_LE == iMagicWord)   {
-            ASSIMP_LOG_DEBUG("MDL subtype: Quake 1, magic word is IDPO");
-            iGSFileVersion = 0;
-            InternReadFile_Quake1();
-        }
-        // GameStudio A<old> MDL2 format - used by some test models that come with 3DGS
-        else if (AI_MDL_MAGIC_NUMBER_BE_GS3 == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS3 == iMagicWord)  {
-            ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A2, magic word is MDL2");
-            iGSFileVersion = 2;
-            InternReadFile_Quake1();
-        }
-        // GameStudio A4 MDL3 format
-        else if (AI_MDL_MAGIC_NUMBER_BE_GS4 == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS4 == iMagicWord)  {
-            ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A4, magic word is MDL3");
-            iGSFileVersion = 3;
-            InternReadFile_3DGS_MDL345();
-        }
-        // GameStudio A5+ MDL4 format
-        else if (AI_MDL_MAGIC_NUMBER_BE_GS5a == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS5a == iMagicWord)    {
-            ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A4, magic word is MDL4");
-            iGSFileVersion = 4;
-            InternReadFile_3DGS_MDL345();
-        }
-        // GameStudio A5+ MDL5 format
-        else if (AI_MDL_MAGIC_NUMBER_BE_GS5b == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS5b == iMagicWord)    {
-            ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A5, magic word is MDL5");
-            iGSFileVersion = 5;
-            InternReadFile_3DGS_MDL345();
-        }
-        // GameStudio A7 MDL7 format
-        else if (AI_MDL_MAGIC_NUMBER_BE_GS7 == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS7 == iMagicWord)  {
-            ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A7, magic word is MDL7");
-            iGSFileVersion = 7;
-            InternReadFile_3DGS_MDL7();
-        }
-        // IDST/IDSQ Format (CS:S/HL^2, etc ...)
-        else if (AI_MDL_MAGIC_NUMBER_BE_HL2a == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_HL2a == iMagicWord ||
-            AI_MDL_MAGIC_NUMBER_BE_HL2b == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_HL2b == iMagicWord)
-        {
-            iGSFileVersion = 0;
+    // Determine the file subtype and call the appropriate member function
 
-            HalfLife::HalfLifeMDLBaseHeader *pHeader = (HalfLife::HalfLifeMDLBaseHeader *)mBuffer;
-            if (pHeader->version == AI_MDL_HL1_VERSION)
-            {
-                ASSIMP_LOG_DEBUG("MDL subtype: Half-Life 1/Goldsrc Engine, magic word is IDST/IDSQ");
-                InternReadFile_HL1(pFile, iMagicWord);
-            }
-            else
-            {
-                ASSIMP_LOG_DEBUG("MDL subtype: Source(tm) Engine, magic word is IDST/IDSQ");
-                InternReadFile_HL2();
-            }
-        }
-        else {
-            // print the magic word to the log file
-            throw DeadlyImportError( "Unknown MDL subformat " + pFile +
-                ". Magic word (" + std::string((char*)&iMagicWord,4) + ") is not known");
-        }
-
-        // Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system
-        pScene->mRootNode->mTransformation = aiMatrix4x4(1.f,0.f,0.f,0.f,
-            0.f,0.f,1.f,0.f,0.f,-1.f,0.f,0.f,0.f,0.f,0.f,1.f);
-
-        DeleteBufferAndCleanup();
-    } catch(...) {
-        DeleteBufferAndCleanup();
-        throw;
+    // Original Quake1 format
+    if (AI_MDL_MAGIC_NUMBER_BE == iMagicWord || AI_MDL_MAGIC_NUMBER_LE == iMagicWord)   {
+        ASSIMP_LOG_DEBUG("MDL subtype: Quake 1, magic word is IDPO");
+        iGSFileVersion = 0;
+        InternReadFile_Quake1();
     }
+    // GameStudio A<old> MDL2 format - used by some test models that come with 3DGS
+    else if (AI_MDL_MAGIC_NUMBER_BE_GS3 == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS3 == iMagicWord)  {
+        ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A2, magic word is MDL2");
+        iGSFileVersion = 2;
+        InternReadFile_Quake1();
+    }
+    // GameStudio A4 MDL3 format
+    else if (AI_MDL_MAGIC_NUMBER_BE_GS4 == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS4 == iMagicWord)  {
+        ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A4, magic word is MDL3");
+        iGSFileVersion = 3;
+        InternReadFile_3DGS_MDL345();
+    }
+    // GameStudio A5+ MDL4 format
+    else if (AI_MDL_MAGIC_NUMBER_BE_GS5a == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS5a == iMagicWord)    {
+        ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A4, magic word is MDL4");
+        iGSFileVersion = 4;
+        InternReadFile_3DGS_MDL345();
+    }
+    // GameStudio A5+ MDL5 format
+    else if (AI_MDL_MAGIC_NUMBER_BE_GS5b == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS5b == iMagicWord)    {
+        ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A5, magic word is MDL5");
+        iGSFileVersion = 5;
+        InternReadFile_3DGS_MDL345();
+    }
+    // GameStudio A7 MDL7 format
+    else if (AI_MDL_MAGIC_NUMBER_BE_GS7 == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS7 == iMagicWord)  {
+        ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A7, magic word is MDL7");
+        iGSFileVersion = 7;
+        InternReadFile_3DGS_MDL7();
+    }
+    // IDST/IDSQ Format (CS:S/HL^2, etc ...)
+    else if (AI_MDL_MAGIC_NUMBER_BE_HL2a == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_HL2a == iMagicWord ||
+        AI_MDL_MAGIC_NUMBER_BE_HL2b == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_HL2b == iMagicWord)
+    {
+        ASSIMP_LOG_DEBUG("MDL subtype: Source(tm) Engine, magic word is IDST/IDSQ");
+        iGSFileVersion = 0;
+        InternReadFile_HL2();
+    }
+    else    {
+        // print the magic word to the log file
+        throw DeadlyImportError( "Unknown MDL subformat " + pFile +
+            ". Magic word (" + std::string((char*)&iMagicWord,4) + ") is not known");
+    }
+
+    // Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system
+    pScene->mRootNode->mTransformation = aiMatrix4x4(1.f,0.f,0.f,0.f,
+        0.f,0.f,1.f,0.f,0.f,-1.f,0.f,0.f,0.f,0.f,0.f,1.f);
+
+    // delete the file buffer and cleanup
+    delete [] mBuffer;
+    mBuffer= nullptr;
+    AI_DEBUG_INVALIDATE_PTR(pIOHandler);
+    AI_DEBUG_INVALIDATE_PTR(pScene);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -1421,11 +1388,11 @@ void MDLImporter::InternReadFile_3DGS_MDL7( )
         avOutList[i].reserve(3);
 
     // buffer to held the names of all groups in the file
-    const size_t buffersize(AI_MDL7_MAX_GROUPNAMESIZE*pcHeader->groups_num);
-    char* aszGroupNameBuffer = new char[ buffersize ];
+	const size_t buffersize( AI_MDL7_MAX_GROUPNAMESIZE*pcHeader->groups_num );
+	char* aszGroupNameBuffer = new char[ buffersize ];
 
     // read all groups
-    for (unsigned int iGroup = 0; iGroup < (unsigned int)pcHeader->groups_num; ++iGroup) {
+    for (unsigned int iGroup = 0; iGroup < (unsigned int)pcHeader->groups_num;++iGroup) {
         MDL::IntGroupInfo_MDL7 groupInfo((BE_NCONST MDL::Group_MDL7*)szCurrent,iGroup);
         szCurrent = (const unsigned char*)(groupInfo.pcGroup+1);
 
@@ -1586,7 +1553,7 @@ void MDLImporter::InternReadFile_3DGS_MDL7( )
 				const size_t maxSize(buffersize - (i*AI_MDL7_MAX_GROUPNAMESIZE));
 				pcNode->mName.length = ai_snprintf(szBuffer, maxSize, "Group_%u", p);
 			} else {
-				pcNode->mName.length = (ai_uint32)::strlen(szBuffer);
+				pcNode->mName.length = ::strlen(szBuffer);
 			}
             ::strncpy(pcNode->mName.data,szBuffer,MAXLEN-1);
             ++p;
@@ -1989,23 +1956,6 @@ void MDLImporter::JoinSkins_3DGS_MDL7(
     }
 }
 
-// ------------------------------------------------------------------------------------------------
-// Read a Half-life 1 MDL
-void MDLImporter::InternReadFile_HL1(const std::string& pFile, const uint32_t iMagicWord)
-{
-    // We can't correctly load an MDL from a MDL "sequence" file.
-    if (iMagicWord == AI_MDL_MAGIC_NUMBER_BE_HL2b || iMagicWord == AI_MDL_MAGIC_NUMBER_LE_HL2b)
-        throw DeadlyImportError("Impossible to properly load a model from an MDL sequence file.");
-
-    // Read the MDL file.
-    HalfLife::HL1MDLLoader loader(
-        pScene,
-        pIOHandler,
-        mBuffer,
-        pFile,
-        mHL1ImportSettings);
-}
-
 // ------------------------------------------------------------------------------------------------
 // Read a half-life 2 MDL
 void MDLImporter::InternReadFile_HL2( )
diff --git a/Engine/lib/assimp/code/MDL/MDLLoader.h b/Engine/lib/assimp/code/MDL/MDLLoader.h
index 0bb78a2b1..c5ebac024 100644
--- a/Engine/lib/assimp/code/MDL/MDLLoader.h
+++ b/Engine/lib/assimp/code/MDL/MDLLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -51,7 +51,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/BaseImporter.h>
 #include "MDLFileData.h"
 #include "HMP/HalfLifeFileData.h"
-#include "HalfLife/HL1ImportSettings.h"
 
 struct aiNode;
 struct aiTexture;
@@ -78,7 +77,6 @@ using namespace MDL;
  *      <li>3D Game Studio MDL3, MDL4</li>
  *      <li>3D Game Studio MDL5</li>
  *      <li>3D Game Studio MDL7</li>
- *      <li>Halflife 1</li>
  *      <li>Halflife 2</li>
  *   </ul>
  *  These formats are partially identical and it would be possible to load
@@ -133,11 +131,6 @@ protected:
     */
     void InternReadFile_3DGS_MDL7( );
 
-    // -------------------------------------------------------------------
-    /** Import a Half-Life 1 MDL file
-    */
-    void InternReadFile_HL1(const std::string& pFile, const uint32_t iMagicWord);
-
     // -------------------------------------------------------------------
     /** Import a CS:S/HL2 MDL file (not fully implemented)
     */
@@ -443,9 +436,6 @@ protected:
 
     /** Size of the input file in bytes */
     unsigned int iFileSize;
-
-    /* Configuration for HL1 MDL */
-    HalfLife::HL1ImportSettings mHL1ImportSettings;
 };
 
 } // end of namespace Assimp
diff --git a/Engine/lib/assimp/code/MDL/MDLMaterialLoader.cpp b/Engine/lib/assimp/code/MDL/MDLMaterialLoader.cpp
index 38ff5bbb1..0a196761f 100644
--- a/Engine/lib/assimp/code/MDL/MDLMaterialLoader.cpp
+++ b/Engine/lib/assimp/code/MDL/MDLMaterialLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -541,7 +541,7 @@ void MDLImporter::ParseSkinLump_3DGS_MDL7(
         size_t iLen2 = iLen+1;
         iLen2 = iLen2 > MAXLEN ? MAXLEN : iLen2;
         memcpy(szFile.data,(const char*)szCurrent,iLen2);
-        szFile.length = (ai_uint32)iLen;
+        szFile.length = iLen;
 
         szCurrent += iLen2;
 
@@ -710,7 +710,7 @@ void MDLImporter::ParseSkinLump_3DGS_MDL7(
         aiString szFile;
         const size_t iLen = strlen((const char*)szCurrent);
         ::memcpy(szFile.data,(const char*)szCurrent,iLen+1);
-        szFile.length = (ai_uint32)iLen;
+        szFile.length = iLen;
 
         pcMatOut->AddProperty(&szFile,AI_MATKEY_TEXTURE_DIFFUSE(0));
 
@@ -831,7 +831,7 @@ void MDLImporter::ParseSkinLump_3DGS_MDL7(
         aiString szFile;
         ::memcpy(szFile.data,pcSkin->texture_name,sizeof(pcSkin->texture_name));
         szFile.data[sizeof(pcSkin->texture_name)] = '\0';
-        szFile.length = (ai_uint32)::strlen(szFile.data);
+        szFile.length = ::strlen(szFile.data);
 
         pcMatOut->AddProperty(&szFile,AI_MATKEY_NAME);
     }
diff --git a/Engine/lib/assimp/code/MMD/MMDCpp14.h b/Engine/lib/assimp/code/MMD/MMDCpp14.h
index 779b6c288..638b0bfd2 100644
--- a/Engine/lib/assimp/code/MMD/MMDCpp14.h
+++ b/Engine/lib/assimp/code/MMD/MMDCpp14.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/MMD/MMDImporter.cpp b/Engine/lib/assimp/code/MMD/MMDImporter.cpp
index 3cc618633..e7744e4cd 100644
--- a/Engine/lib/assimp/code/MMD/MMDImporter.cpp
+++ b/Engine/lib/assimp/code/MMD/MMDImporter.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2016, assimp team
 
 All rights reserved.
 
diff --git a/Engine/lib/assimp/code/MMD/MMDImporter.h b/Engine/lib/assimp/code/MMD/MMDImporter.h
index 1cc91c782..4ee94eeb0 100644
--- a/Engine/lib/assimp/code/MMD/MMDImporter.h
+++ b/Engine/lib/assimp/code/MMD/MMDImporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2016, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
diff --git a/Engine/lib/assimp/code/MMD/MMDPmdParser.h b/Engine/lib/assimp/code/MMD/MMDPmdParser.h
index dad9ed4bc..d2f2224aa 100644
--- a/Engine/lib/assimp/code/MMD/MMDPmdParser.h
+++ b/Engine/lib/assimp/code/MMD/MMDPmdParser.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/MMD/MMDPmxParser.cpp b/Engine/lib/assimp/code/MMD/MMDPmxParser.cpp
index 6421f38cb..80f0986dd 100644
--- a/Engine/lib/assimp/code/MMD/MMDPmxParser.cpp
+++ b/Engine/lib/assimp/code/MMD/MMDPmxParser.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/MMD/MMDPmxParser.h b/Engine/lib/assimp/code/MMD/MMDPmxParser.h
index 9c9fb3ad7..cf523a129 100644
--- a/Engine/lib/assimp/code/MMD/MMDPmxParser.h
+++ b/Engine/lib/assimp/code/MMD/MMDPmxParser.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/MMD/MMDVmdParser.h b/Engine/lib/assimp/code/MMD/MMDVmdParser.h
index 7d15e32d4..947c3a242 100644
--- a/Engine/lib/assimp/code/MMD/MMDVmdParser.h
+++ b/Engine/lib/assimp/code/MMD/MMDVmdParser.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/MS3D/MS3DLoader.cpp b/Engine/lib/assimp/code/MS3D/MS3DLoader.cpp
index 5a29df2ee..c0d0eddbe 100644
--- a/Engine/lib/assimp/code/MS3D/MS3DLoader.cpp
+++ b/Engine/lib/assimp/code/MS3D/MS3DLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/MS3D/MS3DLoader.h b/Engine/lib/assimp/code/MS3D/MS3DLoader.h
index 522664b9a..3e39dc79f 100644
--- a/Engine/lib/assimp/code/MS3D/MS3DLoader.h
+++ b/Engine/lib/assimp/code/MS3D/MS3DLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Material/MaterialSystem.cpp b/Engine/lib/assimp/code/Material/MaterialSystem.cpp
index 1c034e55f..ecdf9942c 100644
--- a/Engine/lib/assimp/code/Material/MaterialSystem.cpp
+++ b/Engine/lib/assimp/code/Material/MaterialSystem.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -51,6 +51,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/types.h>
 #include <assimp/material.h>
 #include <assimp/DefaultLogger.hpp>
+#include <assimp/Macros.h>
 
 using namespace Assimp;
 
@@ -273,14 +274,14 @@ aiReturn aiGetMaterialColor(const aiMaterial* pMat,
 }
 
 // ------------------------------------------------------------------------------------------------
-// Get a aiUVTransform (5 floats) from the material
+// Get a aiUVTransform (4 floats) from the material
 aiReturn aiGetMaterialUVTransform(const aiMaterial* pMat,
     const char* pKey,
     unsigned int type,
     unsigned int index,
     aiUVTransform* pOut)
 {
-    unsigned int iMax = 5;
+    unsigned int iMax = 4;
     return aiGetMaterialFloatArray(pMat,pKey,type,index,(ai_real*)pOut,&iMax);
 }
 
@@ -471,12 +472,12 @@ aiReturn aiMaterial::AddBinaryProperty (const void* pInput,
     aiPropertyTypeInfo pType
     )
 {
-    ai_assert( pInput != nullptr );
-	ai_assert(pKey != nullptr );
+    ai_assert( pInput != NULL );
+    ai_assert( pKey != NULL );
     ai_assert( 0 != pSizeInBytes );
 
     if ( 0 == pSizeInBytes ) {
-		return AI_FAILURE;
+
     }
 
     // first search the list whether there is already an entry with this key
@@ -504,7 +505,7 @@ aiReturn aiMaterial::AddBinaryProperty (const void* pInput,
     pcNew->mData = new char[pSizeInBytes];
     memcpy (pcNew->mData,pInput,pSizeInBytes);
 
-    pcNew->mKey.length = (ai_uint32)::strlen(pKey);
+    pcNew->mKey.length = ::strlen(pKey);
     ai_assert ( MAXLEN > pcNew->mKey.length);
     strcpy( pcNew->mKey.data, pKey );
 
diff --git a/Engine/lib/assimp/code/Material/MaterialSystem.h b/Engine/lib/assimp/code/Material/MaterialSystem.h
index 6df9818a3..67d53578c 100644
--- a/Engine/lib/assimp/code/Material/MaterialSystem.h
+++ b/Engine/lib/assimp/code/Material/MaterialSystem.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/NDO/NDOLoader.cpp b/Engine/lib/assimp/code/NDO/NDOLoader.cpp
index efb942b9c..d33f40c75 100644
--- a/Engine/lib/assimp/code/NDO/NDOLoader.cpp
+++ b/Engine/lib/assimp/code/NDO/NDOLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/NDO/NDOLoader.h b/Engine/lib/assimp/code/NDO/NDOLoader.h
index 4d3f47b25..f2212edab 100644
--- a/Engine/lib/assimp/code/NDO/NDOLoader.h
+++ b/Engine/lib/assimp/code/NDO/NDOLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2008, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
diff --git a/Engine/lib/assimp/code/NFF/NFFLoader.cpp b/Engine/lib/assimp/code/NFF/NFFLoader.cpp
index ca10f7a03..10a7d1aff 100644
--- a/Engine/lib/assimp/code/NFF/NFFLoader.cpp
+++ b/Engine/lib/assimp/code/NFF/NFFLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/NFF/NFFLoader.h b/Engine/lib/assimp/code/NFF/NFFLoader.h
index 02f0f82d5..bc4840e14 100644
--- a/Engine/lib/assimp/code/NFF/NFFLoader.h
+++ b/Engine/lib/assimp/code/NFF/NFFLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/OFF/OFFLoader.cpp b/Engine/lib/assimp/code/OFF/OFFLoader.cpp
index 79f006fca..afd44a539 100644
--- a/Engine/lib/assimp/code/OFF/OFFLoader.cpp
+++ b/Engine/lib/assimp/code/OFF/OFFLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/OFF/OFFLoader.h b/Engine/lib/assimp/code/OFF/OFFLoader.h
index f0f40d9d5..3fca77e1b 100644
--- a/Engine/lib/assimp/code/OFF/OFFLoader.h
+++ b/Engine/lib/assimp/code/OFF/OFFLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Obj/ObjExporter.cpp b/Engine/lib/assimp/code/Obj/ObjExporter.cpp
index 56eb4d9b8..0a0dbd62c 100644
--- a/Engine/lib/assimp/code/Obj/ObjExporter.cpp
+++ b/Engine/lib/assimp/code/Obj/ObjExporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Obj/ObjExporter.h b/Engine/lib/assimp/code/Obj/ObjExporter.h
index 3a46da780..0d2b48d6b 100644
--- a/Engine/lib/assimp/code/Obj/ObjExporter.h
+++ b/Engine/lib/assimp/code/Obj/ObjExporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Obj/ObjFileData.h b/Engine/lib/assimp/code/Obj/ObjFileData.h
index 298d1e1b7..a2d9f2cc7 100644
--- a/Engine/lib/assimp/code/Obj/ObjFileData.h
+++ b/Engine/lib/assimp/code/Obj/ObjFileData.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -110,7 +110,10 @@ struct Object {
     std::vector<unsigned int> m_Meshes;
 
     //! \brief  Default constructor
-    Object() = default;
+    Object() 
+    : m_strObjName("") {
+        // empty
+    }
 
     //! \brief  Destructor
     ~Object() {
@@ -188,12 +191,16 @@ struct Material {
     ,   illumination_model (1)
     ,   ior     ( ai_real( 1.0 ) )
     ,   transparent( ai_real( 1.0), ai_real (1.0), ai_real(1.0)) {
-
-	    std::fill_n(clamp, static_cast<unsigned int>(TextureTypeCount), false);
+        // empty
+        for (size_t i = 0; i < TextureTypeCount; ++i) {
+            clamp[ i ] = false;
+        }
     }
 
     // Destructor
-    ~Material() = default;
+    ~Material() {
+        // empty
+    }
 };
 
 // ------------------------------------------------------------------------------------------------
diff --git a/Engine/lib/assimp/code/Obj/ObjFileImporter.cpp b/Engine/lib/assimp/code/Obj/ObjFileImporter.cpp
index d73cc5b32..26cc6d1f9 100644
--- a/Engine/lib/assimp/code/Obj/ObjFileImporter.cpp
+++ b/Engine/lib/assimp/code/Obj/ObjFileImporter.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -175,15 +175,15 @@ void ObjFileImporter::CreateDataFromImport(const ObjFile::Model* pModel, aiScene
         ai_assert(false);
     }
 
-    if (!pModel->m_Objects.empty()) {
+    if (pModel->m_Objects.size() > 0) {
 
         unsigned int meshCount = 0;
         unsigned int childCount = 0;
 
-        for (auto object : pModel->m_Objects) {
-            if(object) {
+        for(size_t index = 0; index < pModel->m_Objects.size(); ++index) {
+            if(pModel->m_Objects[index]) {
                 ++childCount;
-                meshCount += (unsigned int)object->m_Meshes.size();
+                meshCount += (unsigned int)pModel->m_Objects[index]->m_Meshes.size();
             }
         }
 
@@ -365,8 +365,8 @@ aiMesh *ObjFileImporter::createTopology( const ObjFile::Model* pModel, const Obj
         unsigned int outIndex( 0 );
 
         // Copy all data from all stored meshes
-        for (auto& face : pObjMesh->m_Faces) {
-            ObjFile::Face* const inp = face;
+        for (size_t index = 0; index < pObjMesh->m_Faces.size(); index++) {
+            ObjFile::Face* const inp = pObjMesh->m_Faces[ index ];
             if (inp->m_PrimitiveType == aiPrimitiveType_LINE) {
                 for(size_t i = 0; i < inp->m_vertices.size() - 1; ++i) {
                     aiFace& f = pMesh->mFaces[ outIndex++ ];
@@ -385,7 +385,7 @@ aiMesh *ObjFileImporter::createTopology( const ObjFile::Model* pModel, const Obj
             }
 
             aiFace *pFace = &pMesh->mFaces[ outIndex++ ];
-            const unsigned int uiNumIndices = (unsigned int) face->m_vertices.size();
+            const unsigned int uiNumIndices = (unsigned int) pObjMesh->m_Faces[ index ]->m_vertices.size();
             uiIdxCount += pFace->mNumIndices = (unsigned int) uiNumIndices;
             if (pFace->mNumIndices > 0) {
                 pFace->mIndices = new unsigned int[ uiNumIndices ];
@@ -446,10 +446,13 @@ void ObjFileImporter::createVertexArray(const ObjFile::Model* pModel,
     // Copy vertices, normals and textures into aiMesh instance
     bool normalsok = true, uvok = true;
     unsigned int newIndex = 0, outIndex = 0;
-    for (auto sourceFace : pObjMesh->m_Faces) {
+    for ( size_t index=0; index < pObjMesh->m_Faces.size(); index++ ) {
+        // Get source face
+        ObjFile::Face *pSourceFace = pObjMesh->m_Faces[ index ];
+
         // Copy all index arrays
-        for (size_t vertexIndex = 0, outVertexIndex = 0; vertexIndex < sourceFace->m_vertices.size(); vertexIndex++ ) {
-            const unsigned int vertex = sourceFace->m_vertices.at(vertexIndex );
+        for ( size_t vertexIndex = 0, outVertexIndex = 0; vertexIndex < pSourceFace->m_vertices.size(); vertexIndex++ ) {
+            const unsigned int vertex = pSourceFace->m_vertices.at( vertexIndex );
             if ( vertex >= pModel->m_Vertices.size() ) {
                 throw DeadlyImportError( "OBJ: vertex index out of range" );
             }
@@ -461,8 +464,8 @@ void ObjFileImporter::createVertexArray(const ObjFile::Model* pModel,
             pMesh->mVertices[ newIndex ] = pModel->m_Vertices[ vertex ];
 
             // Copy all normals
-            if ( normalsok && !pModel->m_Normals.empty() && vertexIndex < sourceFace->m_normals.size()) {
-                const unsigned int normal = sourceFace->m_normals.at(vertexIndex );
+            if ( normalsok && !pModel->m_Normals.empty() && vertexIndex < pSourceFace->m_normals.size()) {
+                const unsigned int normal = pSourceFace->m_normals.at( vertexIndex );
                 if ( normal >= pModel->m_Normals.size() )
                 {
                     normalsok = false;
@@ -481,9 +484,9 @@ void ObjFileImporter::createVertexArray(const ObjFile::Model* pModel,
             }
 
             // Copy all texture coordinates
-            if ( uvok && !pModel->m_TextureCoord.empty() && vertexIndex < sourceFace->m_texturCoords.size())
+            if ( uvok && !pModel->m_TextureCoord.empty() && vertexIndex < pSourceFace->m_texturCoords.size())
             {
-                const unsigned int tex = sourceFace->m_texturCoords.at(vertexIndex );
+                const unsigned int tex = pSourceFace->m_texturCoords.at( vertexIndex );
 
                 if ( tex >= pModel->m_TextureCoord.size() )
                 {
@@ -499,16 +502,16 @@ void ObjFileImporter::createVertexArray(const ObjFile::Model* pModel,
             // Get destination face
             aiFace *pDestFace = &pMesh->mFaces[ outIndex ];
 
-            const bool last = (vertexIndex == sourceFace->m_vertices.size() - 1 );
-            if (sourceFace->m_PrimitiveType != aiPrimitiveType_LINE || !last) {
+            const bool last = ( vertexIndex == pSourceFace->m_vertices.size() - 1 );
+            if (pSourceFace->m_PrimitiveType != aiPrimitiveType_LINE || !last) {
                 pDestFace->mIndices[ outVertexIndex ] = newIndex;
                 outVertexIndex++;
             }
 
-            if (sourceFace->m_PrimitiveType == aiPrimitiveType_POINT) {
+            if (pSourceFace->m_PrimitiveType == aiPrimitiveType_POINT) {
                 outIndex++;
                 outVertexIndex = 0;
-            } else if (sourceFace->m_PrimitiveType == aiPrimitiveType_LINE) {
+            } else if (pSourceFace->m_PrimitiveType == aiPrimitiveType_LINE) {
                 outVertexIndex = 0;
 
                 if(!last)
@@ -517,7 +520,7 @@ void ObjFileImporter::createVertexArray(const ObjFile::Model* pModel,
                 if (vertexIndex) {
                     if(!last) {
                         pMesh->mVertices[ newIndex+1 ] = pMesh->mVertices[ newIndex ];
-                        if (!sourceFace->m_normals.empty() && !pModel->m_Normals.empty()) {
+                        if ( !pSourceFace->m_normals.empty() && !pModel->m_Normals.empty()) {
                             pMesh->mNormals[ newIndex+1 ] = pMesh->mNormals[newIndex ];
                         }
                         if ( !pModel->m_TextureCoord.empty() ) {
@@ -560,11 +563,13 @@ void ObjFileImporter::countObjects(const std::vector<ObjFile::Object*> &rObjects
         return;
 
     iNumMeshes += static_cast<unsigned int>( rObjects.size() );
-    for (auto object: rObjects)
+    for (std::vector<ObjFile::Object*>::const_iterator it = rObjects.begin();
+        it != rObjects.end();
+        ++it)
     {
-        if (!object->m_SubObjects.empty())
+        if (!(*it)->m_SubObjects.empty())
         {
-            countObjects(object->m_SubObjects, iNumMeshes);
+            countObjects((*it)->m_SubObjects, iNumMeshes);
         }
     }
 }
diff --git a/Engine/lib/assimp/code/Obj/ObjFileImporter.h b/Engine/lib/assimp/code/Obj/ObjFileImporter.h
index 87b724837..0df2ef731 100644
--- a/Engine/lib/assimp/code/Obj/ObjFileImporter.h
+++ b/Engine/lib/assimp/code/Obj/ObjFileImporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Obj/ObjFileMtlImporter.cpp b/Engine/lib/assimp/code/Obj/ObjFileMtlImporter.cpp
index 90c70cda3..dd9cc3ce2 100644
--- a/Engine/lib/assimp/code/Obj/ObjFileMtlImporter.cpp
+++ b/Engine/lib/assimp/code/Obj/ObjFileMtlImporter.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -274,7 +274,7 @@ void ObjFileMtlImporter::getFloatValue( ai_real &value )
 //  Creates a material from loaded data.
 void ObjFileMtlImporter::createMaterial()
 {
-    std::string line;
+    std::string line( "" );
     while( !IsLineEnd( *m_DataIt ) ) {
         line += *m_DataIt;
         ++m_DataIt;
@@ -282,7 +282,7 @@ void ObjFileMtlImporter::createMaterial()
 
     std::vector<std::string> token;
     const unsigned int numToken = tokenize<std::string>( line, token, " \t" );
-    std::string name;
+    std::string name( "" );
     if ( numToken == 1 ) {
         name = AI_DEFAULT_MATERIAL_NAME;
     } else {
diff --git a/Engine/lib/assimp/code/Obj/ObjFileMtlImporter.h b/Engine/lib/assimp/code/Obj/ObjFileMtlImporter.h
index 2a7fcba7b..731952359 100644
--- a/Engine/lib/assimp/code/Obj/ObjFileMtlImporter.h
+++ b/Engine/lib/assimp/code/Obj/ObjFileMtlImporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Obj/ObjFileParser.cpp b/Engine/lib/assimp/code/Obj/ObjFileParser.cpp
index 7ba2216ae..699aafe6a 100644
--- a/Engine/lib/assimp/code/Obj/ObjFileParser.cpp
+++ b/Engine/lib/assimp/code/Obj/ObjFileParser.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -53,8 +53,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/material.h>
 #include <assimp/Importer.hpp>
 #include <cstdlib>
-#include <memory>
-#include <utility>
 
 namespace Assimp {
 
@@ -73,16 +71,16 @@ ObjFileParser::ObjFileParser()
 
 ObjFileParser::ObjFileParser( IOStreamBuffer<char> &streamBuffer, const std::string &modelName,
                               IOSystem *io, ProgressHandler* progress,
-                              std::string originalObjFileName) :
+                              const std::string &originalObjFileName) :
     m_DataIt(),
     m_DataItEnd(),
     m_pModel(nullptr),
     m_uiLine(0),
-    m_pIO(io),
+    m_pIO( io ),
     m_progress(progress),
-    m_originalObjFileName(std::move(originalObjFileName))
+    m_originalObjFileName(originalObjFileName)
 {
-    std::fill_n(m_buffer, Buffersize,0);
+    std::fill_n(m_buffer,Buffersize,0);
 
     // Create the model instance to store all the data
     m_pModel.reset(new ObjFile::Model());
@@ -98,8 +96,7 @@ ObjFileParser::ObjFileParser( IOStreamBuffer<char> &streamBuffer, const std::str
     parseFile( streamBuffer );
 }
 
-ObjFileParser::~ObjFileParser()
-{
+ObjFileParser::~ObjFileParser() {
 }
 
 void ObjFileParser::setBuffer( std::vector<char> &buffer ) {
@@ -131,7 +128,7 @@ void ObjFileParser::parseFile( IOStreamBuffer<char> &streamBuffer ) {
             processed = static_cast<unsigned int>(filePos);
             lastFilePos = filePos;
             progressCounter++;
-            m_progress->UpdateFileRead(processed, progressTotal);
+            m_progress->UpdateFileRead( processed, progressTotal );
         }
 
         // parse line
@@ -185,7 +182,7 @@ void ObjFileParser::parseFile( IOStreamBuffer<char> &streamBuffer ) {
 
                 getNameNoSpace(m_DataIt, m_DataItEnd, name);
 
-                size_t nextSpace = name.find(' ');
+                size_t nextSpace = name.find(" ");
                 if (nextSpace != std::string::npos)
                     name = name.substr(0, nextSpace);
 
@@ -202,7 +199,7 @@ void ObjFileParser::parseFile( IOStreamBuffer<char> &streamBuffer ) {
 
                 getNameNoSpace(m_DataIt, m_DataItEnd, name);
 
-                size_t nextSpace = name.find(' ');
+                size_t nextSpace = name.find(" ");
                 if (nextSpace != std::string::npos)
                     name = name.substr(0, nextSpace);
 
@@ -277,8 +274,13 @@ static bool isDataDefinitionEnd( const char *tmp ) {
 
 static bool isNanOrInf(const char * in) {
     // Look for "nan" or "inf", case insensitive
-	return ((in[0] == 'N' || in[0] == 'n') && ASSIMP_strincmp(in, "nan", 3) == 0) ||
-	       ((in[0] == 'I' || in[0] == 'i') && ASSIMP_strincmp(in, "inf", 3) == 0);
+    if ((in[0] == 'N' || in[0] == 'n') && ASSIMP_strincmp(in, "nan", 3) == 0) {
+        return true;
+    }
+    else if ((in[0] == 'I' || in[0] == 'i') && ASSIMP_strincmp(in, "inf", 3) == 0) {
+        return true;
+    }
+    return false;
 }
 
 size_t ObjFileParser::getNumComponentsInDataDefinition() {
@@ -339,7 +341,7 @@ size_t ObjFileParser::getTexCoordVector( std::vector<aiVector3D> &point3d_array
     if (!std::isfinite(z))
         z = 0;
 
-    point3d_array.emplace_back( x, y, z );
+    point3d_array.push_back( aiVector3D( x, y, z ) );
     m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
     return numComponents;
 }
@@ -355,7 +357,7 @@ void ObjFileParser::getVector3( std::vector<aiVector3D> &point3d_array ) {
     copyNextWord( m_buffer, Buffersize );
     z = ( ai_real ) fast_atof( m_buffer );
 
-    point3d_array.emplace_back( x, y, z );
+    point3d_array.push_back( aiVector3D( x, y, z ) );
     m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
 }
 
@@ -376,7 +378,7 @@ void ObjFileParser::getHomogeneousVector3( std::vector<aiVector3D> &point3d_arra
     if (w == 0)
       throw DeadlyImportError("OBJ: Invalid component in homogeneous vector (Division by zero)");
 
-    point3d_array.emplace_back( x/w, y/w, z/w );
+    point3d_array.push_back( aiVector3D( x/w, y/w, z/w ) );
     m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
 }
 
@@ -391,7 +393,7 @@ void ObjFileParser::getTwoVectors3( std::vector<aiVector3D> &point3d_array_a, st
     copyNextWord( m_buffer, Buffersize );
     z = ( ai_real ) fast_atof( m_buffer );
 
-    point3d_array_a.emplace_back( x, y, z );
+    point3d_array_a.push_back( aiVector3D( x, y, z ) );
 
     copyNextWord(m_buffer, Buffersize);
     x = (ai_real) fast_atof(m_buffer);
@@ -402,7 +404,7 @@ void ObjFileParser::getTwoVectors3( std::vector<aiVector3D> &point3d_array_a, st
     copyNextWord( m_buffer, Buffersize );
     z = ( ai_real ) fast_atof( m_buffer );
 
-    point3d_array_b.emplace_back( x, y, z );
+    point3d_array_b.push_back( aiVector3D( x, y, z ) );
 
     m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
 }
@@ -415,7 +417,7 @@ void ObjFileParser::getVector2( std::vector<aiVector2D> &point2d_array ) {
     copyNextWord(m_buffer, Buffersize);
     y = (ai_real) fast_atof(m_buffer);
 
-    point2d_array.emplace_back(x, y);
+    point2d_array.push_back(aiVector2D(x, y));
 
     m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
 }
@@ -437,9 +439,9 @@ void ObjFileParser::getFace( aiPrimitiveType type ) {
 
     const bool vt = (!m_pModel->m_TextureCoord.empty());
     const bool vn = (!m_pModel->m_Normals.empty());
-    int iPos = 0;
+    int iStep = 0, iPos = 0;
     while ( m_DataIt != m_DataItEnd ) {
-        int iStep = 1;
+        iStep = 1;
 
         if ( IsLineEnd( *m_DataIt ) ) {
             break;
@@ -843,7 +845,7 @@ void ObjFileParser::createMesh( const std::string &meshName )
 bool ObjFileParser::needsNewMesh( const std::string &materialName )
 {
     // If no mesh data yet
-    if (m_pModel->m_pCurrentMesh == nullptr)
+    if(m_pModel->m_pCurrentMesh == 0)
     {
         return true;
     }
@@ -854,7 +856,7 @@ bool ObjFileParser::needsNewMesh( const std::string &materialName )
         && curMatIdx != matIdx
         // no need create a new mesh if no faces in current
         // lets say 'usemtl' goes straight after 'g'
-        && !m_pModel->m_pCurrentMesh->m_Faces.empty() )
+        && m_pModel->m_pCurrentMesh->m_Faces.size() > 0 )
     {
         // New material -> only one material per mesh, so we need to create a new
         // material
diff --git a/Engine/lib/assimp/code/Obj/ObjFileParser.h b/Engine/lib/assimp/code/Obj/ObjFileParser.h
index f0f5a2dc1..7d1b806ce 100644
--- a/Engine/lib/assimp/code/Obj/ObjFileParser.h
+++ b/Engine/lib/assimp/code/Obj/ObjFileParser.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -78,7 +78,7 @@ public:
     /// @brief  The default constructor.
     ObjFileParser();
     /// @brief  Constructor with data array.
-    ObjFileParser(IOStreamBuffer<char> &streamBuffer, const std::string &modelName, IOSystem* io, ProgressHandler* progress, std::string originalObjFileName);
+    ObjFileParser( IOStreamBuffer<char> &streamBuffer, const std::string &modelName, IOSystem* io, ProgressHandler* progress, const std::string &originalObjFileName);
     /// @brief  Destructor
     ~ObjFileParser();
     /// @brief  If you want to load in-core data.
diff --git a/Engine/lib/assimp/code/Obj/ObjTools.h b/Engine/lib/assimp/code/Obj/ObjTools.h
index 331277333..3f4c41033 100644
--- a/Engine/lib/assimp/code/Obj/ObjTools.h
+++ b/Engine/lib/assimp/code/Obj/ObjTools.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Ogre/OgreBinarySerializer.cpp b/Engine/lib/assimp/code/Ogre/OgreBinarySerializer.cpp
index c7b7e0b5e..589e69c7e 100644
--- a/Engine/lib/assimp/code/Ogre/OgreBinarySerializer.cpp
+++ b/Engine/lib/assimp/code/Ogre/OgreBinarySerializer.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Ogre/OgreBinarySerializer.h b/Engine/lib/assimp/code/Ogre/OgreBinarySerializer.h
index 0b88641aa..8bab00ce9 100644
--- a/Engine/lib/assimp/code/Ogre/OgreBinarySerializer.h
+++ b/Engine/lib/assimp/code/Ogre/OgreBinarySerializer.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Ogre/OgreImporter.cpp b/Engine/lib/assimp/code/Ogre/OgreImporter.cpp
index 6ef9aa462..c2c328a47 100644
--- a/Engine/lib/assimp/code/Ogre/OgreImporter.cpp
+++ b/Engine/lib/assimp/code/Ogre/OgreImporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Ogre/OgreImporter.h b/Engine/lib/assimp/code/Ogre/OgreImporter.h
index ad614b4f4..321d58763 100644
--- a/Engine/lib/assimp/code/Ogre/OgreImporter.h
+++ b/Engine/lib/assimp/code/Ogre/OgreImporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Ogre/OgreMaterial.cpp b/Engine/lib/assimp/code/Ogre/OgreMaterial.cpp
index 6f2e62958..47cb17eb0 100644
--- a/Engine/lib/assimp/code/Ogre/OgreMaterial.cpp
+++ b/Engine/lib/assimp/code/Ogre/OgreMaterial.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Ogre/OgreParsingUtils.h b/Engine/lib/assimp/code/Ogre/OgreParsingUtils.h
index 3fbfd5c31..8786521e4 100644
--- a/Engine/lib/assimp/code/Ogre/OgreParsingUtils.h
+++ b/Engine/lib/assimp/code/Ogre/OgreParsingUtils.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Ogre/OgreStructs.cpp b/Engine/lib/assimp/code/Ogre/OgreStructs.cpp
index 69cfae1cd..7962202c1 100644
--- a/Engine/lib/assimp/code/Ogre/OgreStructs.cpp
+++ b/Engine/lib/assimp/code/Ogre/OgreStructs.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Ogre/OgreStructs.h b/Engine/lib/assimp/code/Ogre/OgreStructs.h
index 2a1121dab..6ea211e10 100644
--- a/Engine/lib/assimp/code/Ogre/OgreStructs.h
+++ b/Engine/lib/assimp/code/Ogre/OgreStructs.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Ogre/OgreXmlSerializer.cpp b/Engine/lib/assimp/code/Ogre/OgreXmlSerializer.cpp
index a93f1b207..19fd3ad61 100644
--- a/Engine/lib/assimp/code/Ogre/OgreXmlSerializer.cpp
+++ b/Engine/lib/assimp/code/Ogre/OgreXmlSerializer.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Ogre/OgreXmlSerializer.h b/Engine/lib/assimp/code/Ogre/OgreXmlSerializer.h
index e81599f9c..7e5e83fec 100644
--- a/Engine/lib/assimp/code/Ogre/OgreXmlSerializer.h
+++ b/Engine/lib/assimp/code/Ogre/OgreXmlSerializer.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/OpenGEX/OpenGEXExporter.cpp b/Engine/lib/assimp/code/OpenGEX/OpenGEXExporter.cpp
index 164a191a2..635174185 100644
--- a/Engine/lib/assimp/code/OpenGEX/OpenGEXExporter.cpp
+++ b/Engine/lib/assimp/code/OpenGEX/OpenGEXExporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/OpenGEX/OpenGEXExporter.h b/Engine/lib/assimp/code/OpenGEX/OpenGEXExporter.h
index 4e4798f2c..b9b54c208 100644
--- a/Engine/lib/assimp/code/OpenGEX/OpenGEXExporter.h
+++ b/Engine/lib/assimp/code/OpenGEX/OpenGEXExporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/OpenGEX/OpenGEXImporter.cpp b/Engine/lib/assimp/code/OpenGEX/OpenGEXImporter.cpp
index 4ee746716..07d3efd5e 100644
--- a/Engine/lib/assimp/code/OpenGEX/OpenGEXImporter.cpp
+++ b/Engine/lib/assimp/code/OpenGEX/OpenGEXImporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/OpenGEX/OpenGEXImporter.h b/Engine/lib/assimp/code/OpenGEX/OpenGEXImporter.h
index 98f7a3e89..22b5cabef 100644
--- a/Engine/lib/assimp/code/OpenGEX/OpenGEXImporter.h
+++ b/Engine/lib/assimp/code/OpenGEX/OpenGEXImporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/OpenGEX/OpenGEXStructs.h b/Engine/lib/assimp/code/OpenGEX/OpenGEXStructs.h
index 7b0b65c1d..2c83e8660 100644
--- a/Engine/lib/assimp/code/OpenGEX/OpenGEXStructs.h
+++ b/Engine/lib/assimp/code/OpenGEX/OpenGEXStructs.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Ply/PlyExporter.cpp b/Engine/lib/assimp/code/Ply/PlyExporter.cpp
index 28ff0c602..5e21a88ac 100644
--- a/Engine/lib/assimp/code/Ply/PlyExporter.cpp
+++ b/Engine/lib/assimp/code/Ply/PlyExporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -373,11 +373,10 @@ void PlyExporter::WriteMeshIndices(const aiMesh* m, unsigned int offset)
 {
     for (unsigned int i = 0; i < m->mNumFaces; ++i) {
         const aiFace& f = m->mFaces[i];
-        mOutput << f.mNumIndices;
+        mOutput << f.mNumIndices << " ";
         for(unsigned int c = 0; c < f.mNumIndices; ++c) {
-            mOutput << " " << (f.mIndices[c] + offset);
+            mOutput << (f.mIndices[c] + offset) << (c == f.mNumIndices-1 ? endl : " ");
         }
-        mOutput << endl;
     }
 }
 
diff --git a/Engine/lib/assimp/code/Ply/PlyExporter.h b/Engine/lib/assimp/code/Ply/PlyExporter.h
index dc53497f6..b82498cbd 100644
--- a/Engine/lib/assimp/code/Ply/PlyExporter.h
+++ b/Engine/lib/assimp/code/Ply/PlyExporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Ply/PlyLoader.cpp b/Engine/lib/assimp/code/Ply/PlyLoader.cpp
index cd52b74f2..3924305cb 100644
--- a/Engine/lib/assimp/code/Ply/PlyLoader.cpp
+++ b/Engine/lib/assimp/code/Ply/PlyLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -49,6 +49,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // internal headers
 #include "PlyLoader.h"
 #include <assimp/IOStreamBuffer.h>
+#include <assimp/Macros.h>
 #include <memory>
 #include <assimp/IOSystem.hpp>
 #include <assimp/scene.h>
diff --git a/Engine/lib/assimp/code/Ply/PlyLoader.h b/Engine/lib/assimp/code/Ply/PlyLoader.h
index 41620e6b0..201c463b2 100644
--- a/Engine/lib/assimp/code/Ply/PlyLoader.h
+++ b/Engine/lib/assimp/code/Ply/PlyLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Ply/PlyParser.cpp b/Engine/lib/assimp/code/Ply/PlyParser.cpp
index d47ca5b6f..2a6f00ad6 100644
--- a/Engine/lib/assimp/code/Ply/PlyParser.cpp
+++ b/Engine/lib/assimp/code/Ply/PlyParser.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Ply/PlyParser.h b/Engine/lib/assimp/code/Ply/PlyParser.h
index e05490649..a11b411d1 100644
--- a/Engine/lib/assimp/code/Ply/PlyParser.h
+++ b/Engine/lib/assimp/code/Ply/PlyParser.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
diff --git a/Engine/lib/assimp/code/PostProcessing/ArmaturePopulate.cpp b/Engine/lib/assimp/code/PostProcessing/ArmaturePopulate.cpp
deleted file mode 100644
index 31c99ae94..000000000
--- a/Engine/lib/assimp/code/PostProcessing/ArmaturePopulate.cpp
+++ /dev/null
@@ -1,262 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------
-*/
-#include "ArmaturePopulate.h"
-
-#include <assimp/BaseImporter.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/postprocess.h>
-#include <assimp/scene.h>
-#include <iostream>
-
-namespace Assimp {
-
-/// The default class constructor.
-ArmaturePopulate::ArmaturePopulate() :
-        BaseProcess() {
-    // do nothing
-}
-
-/// The class destructor.
-ArmaturePopulate::~ArmaturePopulate() {
-    // do nothing
-}
-
-bool ArmaturePopulate::IsActive(unsigned int pFlags) const {
-    return (pFlags & aiProcess_PopulateArmatureData) != 0;
-}
-
-void ArmaturePopulate::SetupProperties(const Importer *pImp) {
-    // do nothing
-}
-
-void ArmaturePopulate::Execute(aiScene *out) {
-
-    // Now convert all bone positions to the correct mOffsetMatrix
-    std::vector<aiBone *> bones;
-    std::vector<aiNode *> nodes;
-    std::map<aiBone *, aiNode *> bone_stack;
-    BuildBoneList(out->mRootNode, out->mRootNode, out, bones);
-    BuildNodeList(out->mRootNode, nodes);
-
-    BuildBoneStack(out->mRootNode, out->mRootNode, out, bones, bone_stack, nodes);
-
-    ASSIMP_LOG_DEBUG_F("Bone stack size: ", bone_stack.size());
-
-    for (std::pair<aiBone *, aiNode *> kvp : bone_stack) {
-        aiBone *bone = kvp.first;
-        aiNode *bone_node = kvp.second;
-        ASSIMP_LOG_DEBUG_F("active node lookup: ", bone->mName.C_Str());
-        // lcl transform grab - done in generate_nodes :)
-
-        // bone->mOffsetMatrix = bone_node->mTransformation;
-        aiNode *armature = GetArmatureRoot(bone_node, bones);
-
-        ai_assert(armature);
-
-        // set up bone armature id
-        bone->mArmature = armature;
-
-        // set this bone node to be referenced properly
-        ai_assert(bone_node);
-        bone->mNode = bone_node;
-    }
-}
-
-
-// Reprocess all nodes to calculate bone transforms properly based on the REAL
-// mOffsetMatrix not the local.
-// Before this would use mesh transforms which is wrong for bone transforms
-// Before this would work for simple character skeletons but not complex meshes
-// with multiple origins
-// Source: sketch fab log cutter fbx
-void ArmaturePopulate::BuildBoneList(aiNode *current_node,
-                                     const aiNode *root_node,
-                                     const aiScene *scene,
-                                     std::vector<aiBone *> &bones) {
-    ai_assert(scene);
-    for (unsigned int nodeId = 0; nodeId < current_node->mNumChildren; ++nodeId) {
-        aiNode *child = current_node->mChildren[nodeId];
-        ai_assert(child);
-
-        // check for bones
-        for (unsigned int meshId = 0; meshId < child->mNumMeshes; ++meshId) {
-            ai_assert(child->mMeshes);
-            unsigned int mesh_index = child->mMeshes[meshId];
-            aiMesh *mesh = scene->mMeshes[mesh_index];
-            ai_assert(mesh);
-
-            for (unsigned int boneId = 0; boneId < mesh->mNumBones; ++boneId) {
-                aiBone *bone = mesh->mBones[boneId];
-                ai_assert(bone);
-
-                // duplicate mehes exist with the same bones sometimes :)
-                // so this must be detected
-                if (std::find(bones.begin(), bones.end(), bone) == bones.end()) {
-                    // add the element once
-                    bones.push_back(bone);
-                }
-            }
-
-            // find mesh and get bones
-            // then do recursive lookup for bones in root node hierarchy
-        }
-
-        BuildBoneList(child, root_node, scene, bones);
-    }
-}
-
-// Prepare flat node list which can be used for non recursive lookups later
-void ArmaturePopulate::BuildNodeList(const aiNode *current_node,
-                                     std::vector<aiNode *> &nodes) {
-    ai_assert(current_node);
-
-    for (unsigned int nodeId = 0; nodeId < current_node->mNumChildren; ++nodeId) {
-        aiNode *child = current_node->mChildren[nodeId];
-        ai_assert(child);
-
-        if (child->mNumMeshes == 0) {
-            nodes.push_back(child);
-        }
-
-        BuildNodeList(child, nodes);
-  }
-}
-
-// A bone stack allows us to have multiple armatures, with the same bone names
-// A bone stack allows us also to retrieve bones true transform even with
-// duplicate names :)
-void ArmaturePopulate::BuildBoneStack(aiNode *current_node,
-                                      const aiNode *root_node,
-                                      const aiScene *scene,
-                                      const std::vector<aiBone *> &bones,
-                                      std::map<aiBone *, aiNode *> &bone_stack,
-                                  std::vector<aiNode *> &node_stack) {
-    ai_assert(scene);
-    ai_assert(root_node);
-    ai_assert(!node_stack.empty());
-
-    for (aiBone *bone : bones) {
-        ai_assert(bone);
-        aiNode *node = GetNodeFromStack(bone->mName, node_stack);
-        if (node == nullptr) {
-            node_stack.clear();
-            BuildNodeList(root_node, node_stack);
-            ASSIMP_LOG_DEBUG_F("Resetting bone stack: nullptr element ", bone->mName.C_Str());
-
-            node = GetNodeFromStack(bone->mName, node_stack);
-
-            if (!node) {
-                ASSIMP_LOG_ERROR("serious import issue node for bone was not detected");
-                continue;
-            }
-        }
-
-        ASSIMP_LOG_DEBUG_F("Successfully added bone[", bone->mName.C_Str(), "] to stack and bone node is: ", node->mName.C_Str());
-
-        bone_stack.insert(std::pair<aiBone *, aiNode *>(bone, node));
-    }
-}
-
-// Returns the armature root node
-// This is required to be detected for a bone initially, it will recurse up
-// until it cannot find another bone and return the node No known failure
-// points. (yet)
-aiNode *ArmaturePopulate::GetArmatureRoot(aiNode *bone_node,
-                                          std::vector<aiBone *> &bone_list) {
-    while (bone_node) {
-        if (!IsBoneNode(bone_node->mName, bone_list)) {
-            ASSIMP_LOG_DEBUG_F("GetArmatureRoot() Found valid armature: ", bone_node->mName.C_Str());
-            return bone_node;
-        }
-
-        bone_node = bone_node->mParent;
-    }
-
-    ASSIMP_LOG_ERROR("GetArmatureRoot() can't find armature!");
-
-    return nullptr;
-}
-
-// Simple IsBoneNode check if this could be a bone
-bool ArmaturePopulate::IsBoneNode(const aiString &bone_name,
-                                  std::vector<aiBone *> &bones) {
-    for (aiBone *bone : bones) {
-        if (bone->mName == bone_name) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-// Pop this node by name from the stack if found
-// Used in multiple armature situations with duplicate node / bone names
-// Known flaw: cannot have nodes with bone names, will be fixed in later release
-// (serious to be fixed) Known flaw: nodes which have more than one bone could
-// be prematurely dropped from stack
-aiNode *ArmaturePopulate::GetNodeFromStack(const aiString &node_name,
-                                           std::vector<aiNode *> &nodes) {
-    std::vector<aiNode *>::iterator iter;
-    aiNode *found = nullptr;
-    for (iter = nodes.begin(); iter < nodes.end(); ++iter) {
-        aiNode *element = *iter;
-        ai_assert(element);
-        // node valid and node name matches
-        if (element->mName == node_name) {
-            found = element;
-            break;
-        }
-    }
-
-    if (found != nullptr) {
-        ASSIMP_LOG_INFO_F("Removed node from stack: ", found->mName.C_Str());
-        // now pop the element from the node list
-        nodes.erase(iter);
-
-        return found;
-    }
-
-    // unique names can cause this problem
-    ASSIMP_LOG_ERROR("[Serious] GetNodeFromStack() can't find node from stack!");
-
-    return nullptr;
-}
-
-} // Namespace Assimp
diff --git a/Engine/lib/assimp/code/PostProcessing/ArmaturePopulate.h b/Engine/lib/assimp/code/PostProcessing/ArmaturePopulate.h
deleted file mode 100644
index 8985e1d1d..000000000
--- a/Engine/lib/assimp/code/PostProcessing/ArmaturePopulate.h
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-#ifndef ARMATURE_POPULATE_H_
-#define ARMATURE_POPULATE_H_
-
-#include "Common/BaseProcess.h"
-#include <assimp/BaseImporter.h>
-#include <vector>
-#include <map>
-
-
-struct aiNode;
-struct aiBone;
-
-namespace Assimp {
-
-// ---------------------------------------------------------------------------
-/** Armature Populate: This is a post process designed
- * To save you time when importing models into your game engines
- * This was originally designed only for fbx but will work with other formats
- * it is intended to auto populate aiBone data with armature and the aiNode
- * This is very useful when dealing with skinned meshes
- * or when dealing with many different skeletons
- * It's off by default but recommend that you try it and use it
- * It should reduce down any glue code you have in your
- * importers
- * You can contact RevoluPowered <gordon@gordonite.tech>
- * For more info about this
-*/
-class ASSIMP_API ArmaturePopulate : public BaseProcess {
-public:
-    /// The default class constructor.
-    ArmaturePopulate();
-
-    /// The class destructor.
-    virtual ~ArmaturePopulate();
-
-    /// Overwritten, @see BaseProcess
-    virtual bool IsActive( unsigned int pFlags ) const;
-
-    /// Overwritten, @see BaseProcess
-    virtual void SetupProperties( const Importer* pImp );
-
-    /// Overwritten, @see BaseProcess
-    virtual void Execute( aiScene* pScene );
-
-    static aiNode *GetArmatureRoot(aiNode *bone_node,
-                                      std::vector<aiBone *> &bone_list);
-
-    static bool IsBoneNode(const aiString &bone_name,
-                              std::vector<aiBone *> &bones);
-
-    static aiNode *GetNodeFromStack(const aiString &node_name,
-                                       std::vector<aiNode *> &nodes);
-
-    static void BuildNodeList(const aiNode *current_node,
-                                 std::vector<aiNode *> &nodes);
-
-    static void BuildBoneList(aiNode *current_node, const aiNode *root_node,
-                                 const aiScene *scene,
-                                 std::vector<aiBone *> &bones);                        
-
-    static void BuildBoneStack(aiNode *current_node, const aiNode *root_node,
-                                  const aiScene *scene,
-                                  const std::vector<aiBone *> &bones,
-                                  std::map<aiBone *, aiNode *> &bone_stack,
-                                  std::vector<aiNode *> &node_stack);
-};
-
-} // Namespace Assimp
-
-
-#endif // SCALE_PROCESS_H_
\ No newline at end of file
diff --git a/Engine/lib/assimp/code/PostProcessing/CalcTangentsProcess.cpp b/Engine/lib/assimp/code/PostProcessing/CalcTangentsProcess.cpp
index 4af335d2f..a3f7dd255 100644
--- a/Engine/lib/assimp/code/PostProcessing/CalcTangentsProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/CalcTangentsProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/PostProcessing/CalcTangentsProcess.h b/Engine/lib/assimp/code/PostProcessing/CalcTangentsProcess.h
index bdd5ca7fa..3568a624f 100644
--- a/Engine/lib/assimp/code/PostProcessing/CalcTangentsProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/CalcTangentsProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/ComputeUVMappingProcess.cpp b/Engine/lib/assimp/code/PostProcessing/ComputeUVMappingProcess.cpp
index 1ebf798bd..df4d44337 100644
--- a/Engine/lib/assimp/code/PostProcessing/ComputeUVMappingProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/ComputeUVMappingProcess.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/ComputeUVMappingProcess.h b/Engine/lib/assimp/code/PostProcessing/ComputeUVMappingProcess.h
index b4ad0f501..a6d36e06e 100644
--- a/Engine/lib/assimp/code/PostProcessing/ComputeUVMappingProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/ComputeUVMappingProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/ConvertToLHProcess.cpp b/Engine/lib/assimp/code/PostProcessing/ConvertToLHProcess.cpp
index 6ca73f10e..b7cd4f0bc 100644
--- a/Engine/lib/assimp/code/PostProcessing/ConvertToLHProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/ConvertToLHProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/PostProcessing/ConvertToLHProcess.h b/Engine/lib/assimp/code/PostProcessing/ConvertToLHProcess.h
index de984a105..f32b91fc3 100644
--- a/Engine/lib/assimp/code/PostProcessing/ConvertToLHProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/ConvertToLHProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -137,9 +137,8 @@ public:
     // -------------------------------------------------------------------
     void Execute( aiScene* pScene);
 
-public:
-    /** Some other types of post-processing require winding order flips */
-    static void ProcessMesh( aiMesh* pMesh);
+protected:
+    void ProcessMesh( aiMesh* pMesh);
 };
 
 // ---------------------------------------------------------------------------
diff --git a/Engine/lib/assimp/code/PostProcessing/DeboneProcess.cpp b/Engine/lib/assimp/code/PostProcessing/DeboneProcess.cpp
index 9d6313f71..83b8336bc 100644
--- a/Engine/lib/assimp/code/PostProcessing/DeboneProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/DeboneProcess.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/DeboneProcess.h b/Engine/lib/assimp/code/PostProcessing/DeboneProcess.h
index 31955f2bd..8b64c2acc 100644
--- a/Engine/lib/assimp/code/PostProcessing/DeboneProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/DeboneProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/DropFaceNormalsProcess.cpp b/Engine/lib/assimp/code/PostProcessing/DropFaceNormalsProcess.cpp
index 1d7cf33b0..b11615bb8 100644
--- a/Engine/lib/assimp/code/PostProcessing/DropFaceNormalsProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/DropFaceNormalsProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/PostProcessing/DropFaceNormalsProcess.h b/Engine/lib/assimp/code/PostProcessing/DropFaceNormalsProcess.h
index b9e942d55..c710c5a5e 100644
--- a/Engine/lib/assimp/code/PostProcessing/DropFaceNormalsProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/DropFaceNormalsProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/EmbedTexturesProcess.cpp b/Engine/lib/assimp/code/PostProcessing/EmbedTexturesProcess.cpp
index b187acf53..739382a05 100644
--- a/Engine/lib/assimp/code/PostProcessing/EmbedTexturesProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/EmbedTexturesProcess.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -128,8 +128,7 @@ bool EmbedTexturesProcess::addTexture(aiScene* pScene, std::string path) const {
     auto oldTextures = pScene->mTextures;
     pScene->mTextures = new aiTexture*[pScene->mNumTextures];
     ::memmove(pScene->mTextures, oldTextures, sizeof(aiTexture*) * (pScene->mNumTextures - 1u));
-    delete [] oldTextures;
-    
+
     // Add the new texture
     auto pTexture = new aiTexture;
     pTexture->mHeight = 0; // Means that this is still compressed
diff --git a/Engine/lib/assimp/code/PostProcessing/EmbedTexturesProcess.h b/Engine/lib/assimp/code/PostProcessing/EmbedTexturesProcess.h
index bbe2656f5..3c4b2eab4 100644
--- a/Engine/lib/assimp/code/PostProcessing/EmbedTexturesProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/EmbedTexturesProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/FindDegenerates.cpp b/Engine/lib/assimp/code/PostProcessing/FindDegenerates.cpp
index dfdfec6cc..50fac46db 100644
--- a/Engine/lib/assimp/code/PostProcessing/FindDegenerates.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/FindDegenerates.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/PostProcessing/FindDegenerates.h b/Engine/lib/assimp/code/PostProcessing/FindDegenerates.h
index 1edaab657..7a15e77cf 100644
--- a/Engine/lib/assimp/code/PostProcessing/FindDegenerates.h
+++ b/Engine/lib/assimp/code/PostProcessing/FindDegenerates.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/FindInstancesProcess.cpp b/Engine/lib/assimp/code/PostProcessing/FindInstancesProcess.cpp
index 9a4c6f53b..64907458a 100644
--- a/Engine/lib/assimp/code/PostProcessing/FindInstancesProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/FindInstancesProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/PostProcessing/FindInstancesProcess.h b/Engine/lib/assimp/code/PostProcessing/FindInstancesProcess.h
index dcac4bf83..64b838d7c 100644
--- a/Engine/lib/assimp/code/PostProcessing/FindInstancesProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/FindInstancesProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/FindInvalidDataProcess.cpp b/Engine/lib/assimp/code/PostProcessing/FindInvalidDataProcess.cpp
index c557d7f70..433f04244 100644
--- a/Engine/lib/assimp/code/PostProcessing/FindInvalidDataProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/FindInvalidDataProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -52,6 +52,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "FindInvalidDataProcess.h"
 #include "ProcessHelper.h"
 
+#include <assimp/Macros.h>
 #include <assimp/Exceptional.h>
 #include <assimp/qnan.h>
 
diff --git a/Engine/lib/assimp/code/PostProcessing/FindInvalidDataProcess.h b/Engine/lib/assimp/code/PostProcessing/FindInvalidDataProcess.h
index 50a2fe04c..ce7375f34 100644
--- a/Engine/lib/assimp/code/PostProcessing/FindInvalidDataProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/FindInvalidDataProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/FixNormalsStep.cpp b/Engine/lib/assimp/code/PostProcessing/FixNormalsStep.cpp
index bb2aa06cc..bbbe6899b 100644
--- a/Engine/lib/assimp/code/PostProcessing/FixNormalsStep.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/FixNormalsStep.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/PostProcessing/FixNormalsStep.h b/Engine/lib/assimp/code/PostProcessing/FixNormalsStep.h
index c022d0364..f60ce596a 100644
--- a/Engine/lib/assimp/code/PostProcessing/FixNormalsStep.h
+++ b/Engine/lib/assimp/code/PostProcessing/FixNormalsStep.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/GenBoundingBoxesProcess.cpp b/Engine/lib/assimp/code/PostProcessing/GenBoundingBoxesProcess.cpp
index bfe016cf2..c013454fc 100644
--- a/Engine/lib/assimp/code/PostProcessing/GenBoundingBoxesProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/GenBoundingBoxesProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
diff --git a/Engine/lib/assimp/code/PostProcessing/GenBoundingBoxesProcess.h b/Engine/lib/assimp/code/PostProcessing/GenBoundingBoxesProcess.h
index d93489a5b..4b43c82a4 100644
--- a/Engine/lib/assimp/code/PostProcessing/GenBoundingBoxesProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/GenBoundingBoxesProcess.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
diff --git a/Engine/lib/assimp/code/PostProcessing/GenFaceNormalsProcess.cpp b/Engine/lib/assimp/code/PostProcessing/GenFaceNormalsProcess.cpp
index 08a1d9aae..028334dec 100644
--- a/Engine/lib/assimp/code/PostProcessing/GenFaceNormalsProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/GenFaceNormalsProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/PostProcessing/GenFaceNormalsProcess.h b/Engine/lib/assimp/code/PostProcessing/GenFaceNormalsProcess.h
index 6e872af3a..c641fd635 100644
--- a/Engine/lib/assimp/code/PostProcessing/GenFaceNormalsProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/GenFaceNormalsProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/GenVertexNormalsProcess.cpp b/Engine/lib/assimp/code/PostProcessing/GenVertexNormalsProcess.cpp
index 1df333410..3f6c2f86b 100644
--- a/Engine/lib/assimp/code/PostProcessing/GenVertexNormalsProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/GenVertexNormalsProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/PostProcessing/GenVertexNormalsProcess.h b/Engine/lib/assimp/code/PostProcessing/GenVertexNormalsProcess.h
index 38104b3bf..2ceee17e8 100644
--- a/Engine/lib/assimp/code/PostProcessing/GenVertexNormalsProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/GenVertexNormalsProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/ImproveCacheLocality.cpp b/Engine/lib/assimp/code/PostProcessing/ImproveCacheLocality.cpp
index d72d15d3a..d0a016fa4 100644
--- a/Engine/lib/assimp/code/PostProcessing/ImproveCacheLocality.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/ImproveCacheLocality.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/PostProcessing/ImproveCacheLocality.h b/Engine/lib/assimp/code/PostProcessing/ImproveCacheLocality.h
index 73e11f57b..de25ecd9f 100644
--- a/Engine/lib/assimp/code/PostProcessing/ImproveCacheLocality.h
+++ b/Engine/lib/assimp/code/PostProcessing/ImproveCacheLocality.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/JoinVerticesProcess.cpp b/Engine/lib/assimp/code/PostProcessing/JoinVerticesProcess.cpp
index 070c9636f..f121fc60d 100644
--- a/Engine/lib/assimp/code/PostProcessing/JoinVerticesProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/JoinVerticesProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/PostProcessing/JoinVerticesProcess.h b/Engine/lib/assimp/code/PostProcessing/JoinVerticesProcess.h
index 76e7cf061..e017ae62d 100644
--- a/Engine/lib/assimp/code/PostProcessing/JoinVerticesProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/JoinVerticesProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/LimitBoneWeightsProcess.cpp b/Engine/lib/assimp/code/PostProcessing/LimitBoneWeightsProcess.cpp
index 1f1abfabb..d560f1928 100644
--- a/Engine/lib/assimp/code/PostProcessing/LimitBoneWeightsProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/LimitBoneWeightsProcess.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/LimitBoneWeightsProcess.h b/Engine/lib/assimp/code/PostProcessing/LimitBoneWeightsProcess.h
index 8bc321a3c..73c2a68d5 100644
--- a/Engine/lib/assimp/code/PostProcessing/LimitBoneWeightsProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/LimitBoneWeightsProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/MakeVerboseFormat.cpp b/Engine/lib/assimp/code/PostProcessing/MakeVerboseFormat.cpp
index 88bdb3124..41f50a5ba 100644
--- a/Engine/lib/assimp/code/PostProcessing/MakeVerboseFormat.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/MakeVerboseFormat.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/PostProcessing/MakeVerboseFormat.h b/Engine/lib/assimp/code/PostProcessing/MakeVerboseFormat.h
index 699cce30b..8565d5933 100644
--- a/Engine/lib/assimp/code/PostProcessing/MakeVerboseFormat.h
+++ b/Engine/lib/assimp/code/PostProcessing/MakeVerboseFormat.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/OptimizeGraph.cpp b/Engine/lib/assimp/code/PostProcessing/OptimizeGraph.cpp
index f3996c275..5db51f58b 100644
--- a/Engine/lib/assimp/code/PostProcessing/OptimizeGraph.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/OptimizeGraph.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
@@ -43,13 +43,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Implementation of the aiProcess_OptimizGraph step
  */
 
+
 #ifndef ASSIMP_BUILD_NO_OPTIMIZEGRAPH_PROCESS
 
 #include "OptimizeGraph.h"
 #include "ProcessHelper.h"
-#include "ConvertToLHProcess.h"
-#include <assimp/Exceptional.h>
 #include <assimp/SceneCombiner.h>
+#include <assimp/Exceptional.h>
 #include <stdio.h>
 
 using namespace Assimp;
@@ -60,299 +60,292 @@ using namespace Assimp;
  * The unhashed variant should be faster, except for *very* large data sets
  */
 #ifdef AI_OG_USE_HASHING
-// Use our standard hashing function to compute the hash
-#define AI_OG_GETKEY(str) SuperFastHash(str.data, str.length)
+    // Use our standard hashing function to compute the hash
+#   define AI_OG_GETKEY(str) SuperFastHash(str.data,str.length)
 #else
-// Otherwise hope that std::string will utilize a static buffer
-// for shorter node names. This would avoid endless heap copying.
-#define AI_OG_GETKEY(str) std::string(str.data)
+    // Otherwise hope that std::string will utilize a static buffer
+    // for shorter node names. This would avoid endless heap copying.
+#   define AI_OG_GETKEY(str) std::string(str.data)
 #endif
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-OptimizeGraphProcess::OptimizeGraphProcess() :
-		mScene(),
-		nodes_in(),
-		nodes_out(),
-		count_merged() {
-	// empty
+OptimizeGraphProcess::OptimizeGraphProcess()
+: mScene()
+, nodes_in()
+, nodes_out()
+, count_merged() {
+    // empty
 }
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
 OptimizeGraphProcess::~OptimizeGraphProcess() {
-	// empty
+    // empty
 }
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the processing step is present in the given flag field.
-bool OptimizeGraphProcess::IsActive(unsigned int pFlags) const {
-	return (0 != (pFlags & aiProcess_OptimizeGraph));
+bool OptimizeGraphProcess::IsActive( unsigned int pFlags) const {
+    return (0 != (pFlags & aiProcess_OptimizeGraph));
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup properties for the post-processing step
-void OptimizeGraphProcess::SetupProperties(const Importer *pImp) {
-	// Get value of AI_CONFIG_PP_OG_EXCLUDE_LIST
-	std::string tmp = pImp->GetPropertyString(AI_CONFIG_PP_OG_EXCLUDE_LIST, "");
-	AddLockedNodeList(tmp);
+void OptimizeGraphProcess::SetupProperties(const Importer* pImp) {
+    // Get value of AI_CONFIG_PP_OG_EXCLUDE_LIST
+    std::string tmp = pImp->GetPropertyString(AI_CONFIG_PP_OG_EXCLUDE_LIST,"");
+    AddLockedNodeList(tmp);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Collect new children
-void OptimizeGraphProcess::CollectNewChildren(aiNode *nd, std::list<aiNode *> &nodes) {
-	nodes_in += nd->mNumChildren;
+void OptimizeGraphProcess::CollectNewChildren(aiNode* nd, std::list<aiNode*>& nodes) {
+    nodes_in += nd->mNumChildren;
 
-	// Process children
-	std::list<aiNode *> child_nodes;
-	for (unsigned int i = 0; i < nd->mNumChildren; ++i) {
-		CollectNewChildren(nd->mChildren[i], child_nodes);
-		nd->mChildren[i] = nullptr;
-	}
+    // Process children
+    std::list<aiNode*> child_nodes;
+    for (unsigned int i = 0; i < nd->mNumChildren; ++i) {
+        CollectNewChildren(nd->mChildren[i],child_nodes);
+        nd->mChildren[i] = nullptr;
+    }
 
-	// Check whether we need this node; if not we can replace it by our own children (warn, danger of incest).
-	if (locked.find(AI_OG_GETKEY(nd->mName)) == locked.end()) {
-		for (std::list<aiNode *>::iterator it = child_nodes.begin(); it != child_nodes.end();) {
+    // Check whether we need this node; if not we can replace it by our own children (warn, danger of incest).
+    if (locked.find(AI_OG_GETKEY(nd->mName)) == locked.end() ) {
+        for (std::list<aiNode*>::iterator it = child_nodes.begin(); it != child_nodes.end();) {
 
-			if (locked.find(AI_OG_GETKEY((*it)->mName)) == locked.end()) {
-				(*it)->mTransformation = nd->mTransformation * (*it)->mTransformation;
-				nodes.push_back(*it);
+            if (locked.find(AI_OG_GETKEY((*it)->mName)) == locked.end()) {
+                (*it)->mTransformation = nd->mTransformation * (*it)->mTransformation;
+                nodes.push_back(*it);
 
-				it = child_nodes.erase(it);
-				continue;
-			}
-			++it;
-		}
+                it = child_nodes.erase(it);
+                continue;
+            }
+            ++it;
+        }
 
-		if (nd->mNumMeshes || !child_nodes.empty()) {
-			nodes.push_back(nd);
-		} else {
-			delete nd; /* bye, node */
-			return;
-		}
-	} else {
+        if (nd->mNumMeshes || !child_nodes.empty()) {
+            nodes.push_back(nd);
+        } else {
+            delete nd; /* bye, node */
+            return;
+        }
+    } else {
 
-		// Retain our current position in the hierarchy
-		nodes.push_back(nd);
+        // Retain our current position in the hierarchy
+        nodes.push_back(nd);
 
-		// Now check for possible optimizations in our list of child nodes. join as many as possible
-		aiNode *join_master = nullptr;
-		aiMatrix4x4 inv;
+        // Now check for possible optimizations in our list of child nodes. join as many as possible
+        aiNode* join_master = NULL;
+        aiMatrix4x4 inv;
 
-		const LockedSetType::const_iterator end = locked.end();
+        const LockedSetType::const_iterator end = locked.end();
 
-		std::list<aiNode *> join;
-		for (std::list<aiNode *>::iterator it = child_nodes.begin(); it != child_nodes.end();) {
-			aiNode *child = *it;
-			if (child->mNumChildren == 0 && locked.find(AI_OG_GETKEY(child->mName)) == end) {
+        std::list<aiNode*> join;
+        for (std::list<aiNode*>::iterator it = child_nodes.begin(); it != child_nodes.end();)   {
+            aiNode* child = *it;
+            if (child->mNumChildren == 0 && locked.find(AI_OG_GETKEY(child->mName)) == end) {
 
-				// There may be no instanced meshes
-				unsigned int n = 0;
-				for (; n < child->mNumMeshes; ++n) {
-					if (meshes[child->mMeshes[n]] > 1) {
-						break;
-					}
-				}
-				if (n == child->mNumMeshes) {
-					if (!join_master) {
-						join_master = child;
-						inv = join_master->mTransformation;
-						inv.Inverse();
-					} else {
-						child->mTransformation = inv * child->mTransformation;
+                // There may be no instanced meshes
+                unsigned int n = 0;
+                for (; n < child->mNumMeshes;++n) {
+                    if (meshes[child->mMeshes[n]] > 1) {
+                        break;
+                    }
+                }
+                if (n == child->mNumMeshes) {
+                    if (!join_master) {
+                        join_master = child;
+                        inv = join_master->mTransformation;
+                        inv.Inverse();
+                    } else {
+                        child->mTransformation = inv * child->mTransformation ;
 
-						join.push_back(child);
-						it = child_nodes.erase(it);
-						continue;
-					}
-				}
-			}
-			++it;
-		}
-		if (join_master && !join.empty()) {
-			join_master->mName.length = ::ai_snprintf(join_master->mName.data, MAXLEN, "$MergedNode_%i", count_merged++);
+                        join.push_back(child);
+                        it = child_nodes.erase(it);
+                        continue;
+                    }
+                }
+            }
+            ++it;
+        }
+        if (join_master && !join.empty()) {
+            join_master->mName.length = ::ai_snprintf(join_master->mName.data, MAXLEN, "$MergedNode_%i",count_merged++);
 
-			unsigned int out_meshes = 0;
-			for (std::list<aiNode *>::const_iterator it = join.cbegin(); it != join.cend(); ++it) {
-				out_meshes += (*it)->mNumMeshes;
-			}
+            unsigned int out_meshes = 0;
+            for (std::list<aiNode*>::iterator it = join.begin(); it != join.end(); ++it) {
+                out_meshes += (*it)->mNumMeshes;
+            }
 
-			// copy all mesh references in one array
-			if (out_meshes) {
-				unsigned int *meshes = new unsigned int[out_meshes + join_master->mNumMeshes], *tmp = meshes;
-				for (unsigned int n = 0; n < join_master->mNumMeshes; ++n) {
-					*tmp++ = join_master->mMeshes[n];
-				}
+            // copy all mesh references in one array
+            if (out_meshes) {
+                unsigned int* meshes = new unsigned int[out_meshes+join_master->mNumMeshes], *tmp = meshes;
+                for (unsigned int n = 0; n < join_master->mNumMeshes;++n) {
+                    *tmp++ = join_master->mMeshes[n];
+                }
 
-				for (const aiNode *join_node : join) {
-					for (unsigned int n = 0; n < join_node->mNumMeshes; ++n) {
+                for (std::list<aiNode*>::iterator it = join.begin(); it != join.end(); ++it) {
+                    for (unsigned int n = 0; n < (*it)->mNumMeshes; ++n) {
 
-						*tmp = join_node->mMeshes[n];
-						aiMesh *mesh = mScene->mMeshes[*tmp++];
+                        *tmp = (*it)->mMeshes[n];
+                        aiMesh* mesh = mScene->mMeshes[*tmp++];
 
-						// Assume the transformation is affine
-						// manually move the mesh into the right coordinate system
+                        // manually move the mesh into the right coordinate system
+                        const aiMatrix3x3 IT = aiMatrix3x3( (*it)->mTransformation ).Inverse().Transpose();
+                        for (unsigned int a = 0; a < mesh->mNumVertices; ++a) {
 
-						// Check for odd negative scale (mirror)
-						if (join_node->mTransformation.Determinant() < 0) {
-							// Reverse the mesh face winding order
-                            FlipWindingOrderProcess::ProcessMesh(mesh);
-						}
+                            mesh->mVertices[a] *= (*it)->mTransformation;
 
-                        // Update positions, normals and tangents
-						const aiMatrix3x3 IT = aiMatrix3x3(join_node->mTransformation).Inverse().Transpose();
-						for (unsigned int a = 0; a < mesh->mNumVertices; ++a) {
+                            if (mesh->HasNormals())
+                                mesh->mNormals[a] *= IT;
 
-							mesh->mVertices[a] *= join_node->mTransformation;
+                            if (mesh->HasTangentsAndBitangents()) {
+                                mesh->mTangents[a] *= IT;
+                                mesh->mBitangents[a] *= IT;
+                            }
+                        }
+                    }
+                    delete *it; // bye, node
+                }
+                delete[] join_master->mMeshes;
+                join_master->mMeshes = meshes;
+                join_master->mNumMeshes += out_meshes;
+            }
+        }
+    }
+    // reassign children if something changed
+    if (child_nodes.empty() || child_nodes.size() > nd->mNumChildren) {
 
-							if (mesh->HasNormals())
-								mesh->mNormals[a] *= IT;
+        delete[] nd->mChildren;
 
-							if (mesh->HasTangentsAndBitangents()) {
-								mesh->mTangents[a] *= IT;
-								mesh->mBitangents[a] *= IT;
-							}
-						}
-					}
-					delete join_node; // bye, node
-				}
-				delete[] join_master->mMeshes;
-				join_master->mMeshes = meshes;
-				join_master->mNumMeshes += out_meshes;
-			}
-		}
-	}
-	// reassign children if something changed
-	if (child_nodes.empty() || child_nodes.size() > nd->mNumChildren) {
+        if (!child_nodes.empty()) {
+            nd->mChildren = new aiNode*[child_nodes.size()];
+        }
+        else nd->mChildren = nullptr;
+    }
 
-		delete[] nd->mChildren;
+    nd->mNumChildren = static_cast<unsigned int>(child_nodes.size());
 
-		if (!child_nodes.empty()) {
-			nd->mChildren = new aiNode *[child_nodes.size()];
-		} else
-			nd->mChildren = nullptr;
-	}
+    if (nd->mChildren) {
+        aiNode** tmp = nd->mChildren;
+        for (std::list<aiNode*>::iterator it = child_nodes.begin(); it != child_nodes.end(); ++it) {
+            aiNode* node = *tmp++ = *it;
+            node->mParent = nd;
+        }
+    }
 
-	nd->mNumChildren = static_cast<unsigned int>(child_nodes.size());
-
-	if (nd->mChildren) {
-		aiNode **tmp = nd->mChildren;
-		for (std::list<aiNode *>::iterator it = child_nodes.begin(); it != child_nodes.end(); ++it) {
-			aiNode *node = *tmp++ = *it;
-			node->mParent = nd;
-		}
-	}
-
-	nodes_out += static_cast<unsigned int>(child_nodes.size());
+    nodes_out += static_cast<unsigned int>(child_nodes.size());
 }
 
 // ------------------------------------------------------------------------------------------------
 // Execute the post-processing step on the given scene
-void OptimizeGraphProcess::Execute(aiScene *pScene) {
-	ASSIMP_LOG_DEBUG("OptimizeGraphProcess begin");
-	nodes_in = nodes_out = count_merged = 0;
-	mScene = pScene;
+void OptimizeGraphProcess::Execute( aiScene* pScene) {
+    ASSIMP_LOG_DEBUG("OptimizeGraphProcess begin");
+    nodes_in = nodes_out = count_merged = 0;
+    mScene = pScene;
 
-	meshes.resize(pScene->mNumMeshes, 0);
-	FindInstancedMeshes(pScene->mRootNode);
+    meshes.resize(pScene->mNumMeshes,0);
+    FindInstancedMeshes(pScene->mRootNode);
 
-	// build a blacklist of identifiers. If the name of a node matches one of these, we won't touch it
-	locked.clear();
-	for (std::list<std::string>::const_iterator it = locked_nodes.begin(); it != locked_nodes.end(); ++it) {
+    // build a blacklist of identifiers. If the name of a node matches one of these, we won't touch it
+    locked.clear();
+    for (std::list<std::string>::const_iterator it = locked_nodes.begin(); it != locked_nodes.end(); ++it) {
 #ifdef AI_OG_USE_HASHING
-		locked.insert(SuperFastHash((*it).c_str()));
+        locked.insert(SuperFastHash((*it).c_str()));
 #else
-		locked.insert(*it);
+        locked.insert(*it);
 #endif
-	}
+    }
 
-	for (unsigned int i = 0; i < pScene->mNumAnimations; ++i) {
-		for (unsigned int a = 0; a < pScene->mAnimations[i]->mNumChannels; ++a) {
-			aiNodeAnim *anim = pScene->mAnimations[i]->mChannels[a];
-			locked.insert(AI_OG_GETKEY(anim->mNodeName));
-		}
-	}
+    for (unsigned int i = 0; i < pScene->mNumAnimations; ++i) {
+        for (unsigned int a = 0; a < pScene->mAnimations[i]->mNumChannels; ++a) {
+            aiNodeAnim* anim = pScene->mAnimations[i]->mChannels[a];
+            locked.insert(AI_OG_GETKEY(anim->mNodeName));
+        }
+    }
 
-	for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
-		for (unsigned int a = 0; a < pScene->mMeshes[i]->mNumBones; ++a) {
+    for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
+        for (unsigned int a = 0; a < pScene->mMeshes[i]->mNumBones; ++a) {
 
-			aiBone *bone = pScene->mMeshes[i]->mBones[a];
-			locked.insert(AI_OG_GETKEY(bone->mName));
+            aiBone* bone = pScene->mMeshes[i]->mBones[a];
+            locked.insert(AI_OG_GETKEY(bone->mName));
 
-			// HACK: Meshes referencing bones may not be transformed; we need to look them.
-			// The easiest way to do this is to increase their reference counters ...
-			meshes[i] += 2;
-		}
-	}
+            // HACK: Meshes referencing bones may not be transformed; we need to look them.
+            // The easiest way to do this is to increase their reference counters ...
+            meshes[i] += 2;
+        }
+    }
 
-	for (unsigned int i = 0; i < pScene->mNumCameras; ++i) {
-		aiCamera *cam = pScene->mCameras[i];
-		locked.insert(AI_OG_GETKEY(cam->mName));
-	}
+    for (unsigned int i = 0; i < pScene->mNumCameras; ++i) {
+        aiCamera* cam = pScene->mCameras[i];
+        locked.insert(AI_OG_GETKEY(cam->mName));
+    }
 
-	for (unsigned int i = 0; i < pScene->mNumLights; ++i) {
-		aiLight *lgh = pScene->mLights[i];
-		locked.insert(AI_OG_GETKEY(lgh->mName));
-	}
+    for (unsigned int i = 0; i < pScene->mNumLights; ++i) {
+        aiLight* lgh = pScene->mLights[i];
+        locked.insert(AI_OG_GETKEY(lgh->mName));
+    }
 
-	// Insert a dummy master node and make it read-only
-	aiNode *dummy_root = new aiNode(AI_RESERVED_NODE_NAME);
-	locked.insert(AI_OG_GETKEY(dummy_root->mName));
+    // Insert a dummy master node and make it read-only
+    aiNode* dummy_root = new aiNode(AI_RESERVED_NODE_NAME);
+    locked.insert(AI_OG_GETKEY(dummy_root->mName));
 
-	const aiString prev = pScene->mRootNode->mName;
-	pScene->mRootNode->mParent = dummy_root;
+    const aiString prev = pScene->mRootNode->mName;
+    pScene->mRootNode->mParent = dummy_root;
 
-	dummy_root->mChildren = new aiNode *[dummy_root->mNumChildren = 1];
-	dummy_root->mChildren[0] = pScene->mRootNode;
+    dummy_root->mChildren = new aiNode*[dummy_root->mNumChildren = 1];
+    dummy_root->mChildren[0] = pScene->mRootNode;
 
-	// Do our recursive processing of scenegraph nodes. For each node collect
-	// a fully new list of children and allow their children to place themselves
-	// on the same hierarchy layer as their parents.
-	std::list<aiNode *> nodes;
-	CollectNewChildren(dummy_root, nodes);
+    // Do our recursive processing of scenegraph nodes. For each node collect
+    // a fully new list of children and allow their children to place themselves
+    // on the same hierarchy layer as their parents.
+    std::list<aiNode*> nodes;
+    CollectNewChildren (dummy_root,nodes);
 
-	ai_assert(nodes.size() == 1);
+    ai_assert(nodes.size() == 1);
 
-	if (dummy_root->mNumChildren == 0) {
-		pScene->mRootNode = nullptr;
-		throw DeadlyImportError("After optimizing the scene graph, no data remains");
-	}
+    if (dummy_root->mNumChildren == 0) {
+        pScene->mRootNode = NULL;
+        throw DeadlyImportError("After optimizing the scene graph, no data remains");
+    }
 
-	if (dummy_root->mNumChildren > 1) {
-		pScene->mRootNode = dummy_root;
+    if (dummy_root->mNumChildren > 1) {
+        pScene->mRootNode = dummy_root;
 
-		// Keep the dummy node but assign the name of the old root node to it
-		pScene->mRootNode->mName = prev;
-	} else {
+        // Keep the dummy node but assign the name of the old root node to it
+        pScene->mRootNode->mName = prev;
+    }
+    else {
 
-		// Remove the dummy root node again.
-		pScene->mRootNode = dummy_root->mChildren[0];
+        // Remove the dummy root node again.
+        pScene->mRootNode = dummy_root->mChildren[0];
 
-		dummy_root->mChildren[0] = nullptr;
-		delete dummy_root;
-	}
+        dummy_root->mChildren[0] = NULL;
+        delete dummy_root;
+    }
 
-	pScene->mRootNode->mParent = nullptr;
-	if (!DefaultLogger::isNullLogger()) {
-		if (nodes_in != nodes_out) {
-			ASSIMP_LOG_INFO_F("OptimizeGraphProcess finished; Input nodes: ", nodes_in, ", Output nodes: ", nodes_out);
-		} else {
-			ASSIMP_LOG_DEBUG("OptimizeGraphProcess finished");
-		}
-	}
-	meshes.clear();
-	locked.clear();
+    pScene->mRootNode->mParent = NULL;
+    if (!DefaultLogger::isNullLogger()) {
+        if ( nodes_in != nodes_out) {
+            ASSIMP_LOG_INFO_F("OptimizeGraphProcess finished; Input nodes: ", nodes_in, ", Output nodes: ", nodes_out);
+        } else {
+            ASSIMP_LOG_DEBUG("OptimizeGraphProcess finished");
+        }
+    }
+    meshes.clear();
+    locked.clear();
 }
 
 // ------------------------------------------------------------------------------------------------
 // Build a LUT of all instanced meshes
-void OptimizeGraphProcess::FindInstancedMeshes(aiNode *pNode) {
-	for (unsigned int i = 0; i < pNode->mNumMeshes; ++i) {
-		++meshes[pNode->mMeshes[i]];
-	}
+void OptimizeGraphProcess::FindInstancedMeshes (aiNode* pNode)
+{
+    for (unsigned int i = 0; i < pNode->mNumMeshes;++i) {
+        ++meshes[pNode->mMeshes[i]];
+    }
 
-	for (unsigned int i = 0; i < pNode->mNumChildren; ++i)
-		FindInstancedMeshes(pNode->mChildren[i]);
+    for (unsigned int i = 0; i < pNode->mNumChildren; ++i)
+        FindInstancedMeshes(pNode->mChildren[i]);
 }
 
 #endif // !! ASSIMP_BUILD_NO_OPTIMIZEGRAPH_PROCESS
diff --git a/Engine/lib/assimp/code/PostProcessing/OptimizeGraph.h b/Engine/lib/assimp/code/PostProcessing/OptimizeGraph.h
index 34f70854f..82cc5db3f 100644
--- a/Engine/lib/assimp/code/PostProcessing/OptimizeGraph.h
+++ b/Engine/lib/assimp/code/PostProcessing/OptimizeGraph.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -75,13 +75,13 @@ public:
     ~OptimizeGraphProcess();
 
     // -------------------------------------------------------------------
-    bool IsActive( unsigned int pFlags) const override;
+    bool IsActive( unsigned int pFlags) const;
 
     // -------------------------------------------------------------------
-    void Execute( aiScene* pScene) override;
+    void Execute( aiScene* pScene);
 
     // -------------------------------------------------------------------
-    void SetupProperties(const Importer* pImp) override;
+    void SetupProperties(const Importer* pImp);
 
     // -------------------------------------------------------------------
     /** @brief Add a list of node names to be locked and not modified.
diff --git a/Engine/lib/assimp/code/PostProcessing/OptimizeMeshes.cpp b/Engine/lib/assimp/code/PostProcessing/OptimizeMeshes.cpp
index 983d8001f..3f6765f6c 100644
--- a/Engine/lib/assimp/code/PostProcessing/OptimizeMeshes.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/OptimizeMeshes.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/PostProcessing/OptimizeMeshes.h b/Engine/lib/assimp/code/PostProcessing/OptimizeMeshes.h
index 50dfe2957..dec4ab52d 100644
--- a/Engine/lib/assimp/code/PostProcessing/OptimizeMeshes.h
+++ b/Engine/lib/assimp/code/PostProcessing/OptimizeMeshes.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/PretransformVertices.cpp b/Engine/lib/assimp/code/PostProcessing/PretransformVertices.cpp
index 293a5c0ea..52001a057 100644
--- a/Engine/lib/assimp/code/PostProcessing/PretransformVertices.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/PretransformVertices.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -45,11 +45,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Implementation of the "PretransformVertices" post processing step
 */
 
+
 #include "PretransformVertices.h"
-#include "ConvertToLHProcess.h"
 #include "ProcessHelper.h"
-#include <assimp/Exceptional.h>
 #include <assimp/SceneCombiner.h>
+#include <assimp/Exceptional.h>
 
 using namespace Assimp;
 
@@ -59,630 +59,670 @@ using namespace Assimp;
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-PretransformVertices::PretransformVertices() :
-		configKeepHierarchy(false),
-		configNormalize(false),
-		configTransform(false),
-		configTransformation(),
-		mConfigPointCloud(false) {
-	// empty
+PretransformVertices::PretransformVertices()
+: configKeepHierarchy (false)
+, configNormalize(false)
+, configTransform(false)
+, configTransformation()
+, mConfigPointCloud( false ) {
+    // empty
 }
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
 PretransformVertices::~PretransformVertices() {
-	// nothing to do here
+    // nothing to do here
 }
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the processing step is present in the given flag field.
-bool PretransformVertices::IsActive(unsigned int pFlags) const {
-	return (pFlags & aiProcess_PreTransformVertices) != 0;
+bool PretransformVertices::IsActive( unsigned int pFlags) const
+{
+    return  (pFlags & aiProcess_PreTransformVertices) != 0;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup import configuration
-void PretransformVertices::SetupProperties(const Importer *pImp) {
-	// Get the current value of AI_CONFIG_PP_PTV_KEEP_HIERARCHY, AI_CONFIG_PP_PTV_NORMALIZE,
-	// AI_CONFIG_PP_PTV_ADD_ROOT_TRANSFORMATION and AI_CONFIG_PP_PTV_ROOT_TRANSFORMATION
-	configKeepHierarchy = (0 != pImp->GetPropertyInteger(AI_CONFIG_PP_PTV_KEEP_HIERARCHY, 0));
-	configNormalize = (0 != pImp->GetPropertyInteger(AI_CONFIG_PP_PTV_NORMALIZE, 0));
-	configTransform = (0 != pImp->GetPropertyInteger(AI_CONFIG_PP_PTV_ADD_ROOT_TRANSFORMATION, 0));
+void PretransformVertices::SetupProperties(const Importer* pImp)
+{
+    // Get the current value of AI_CONFIG_PP_PTV_KEEP_HIERARCHY, AI_CONFIG_PP_PTV_NORMALIZE,
+    // AI_CONFIG_PP_PTV_ADD_ROOT_TRANSFORMATION and AI_CONFIG_PP_PTV_ROOT_TRANSFORMATION
+    configKeepHierarchy = (0 != pImp->GetPropertyInteger(AI_CONFIG_PP_PTV_KEEP_HIERARCHY,0));
+    configNormalize = (0 != pImp->GetPropertyInteger(AI_CONFIG_PP_PTV_NORMALIZE,0));
+    configTransform = (0 != pImp->GetPropertyInteger(AI_CONFIG_PP_PTV_ADD_ROOT_TRANSFORMATION,0));
 
-	configTransformation = pImp->GetPropertyMatrix(AI_CONFIG_PP_PTV_ROOT_TRANSFORMATION, aiMatrix4x4());
+    configTransformation = pImp->GetPropertyMatrix(AI_CONFIG_PP_PTV_ROOT_TRANSFORMATION, aiMatrix4x4());
 
-	mConfigPointCloud = pImp->GetPropertyBool(AI_CONFIG_EXPORT_POINT_CLOUDS);
+    mConfigPointCloud = pImp->GetPropertyBool(AI_CONFIG_EXPORT_POINT_CLOUDS);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Count the number of nodes
-unsigned int PretransformVertices::CountNodes(const aiNode *pcNode) const {
-	unsigned int iRet = 1;
-	for (unsigned int i = 0; i < pcNode->mNumChildren; ++i) {
-		iRet += CountNodes(pcNode->mChildren[i]);
-	}
-	return iRet;
+unsigned int PretransformVertices::CountNodes( aiNode* pcNode )
+{
+    unsigned int iRet = 1;
+    for (unsigned int i = 0;i < pcNode->mNumChildren;++i)
+    {
+        iRet += CountNodes(pcNode->mChildren[i]);
+    }
+    return iRet;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get a bitwise combination identifying the vertex format of a mesh
-unsigned int PretransformVertices::GetMeshVFormat(aiMesh *pcMesh) const {
-	// the vertex format is stored in aiMesh::mBones for later retrieval.
-	// there isn't a good reason to compute it a few hundred times
-	// from scratch. The pointer is unused as animations are lost
-	// during PretransformVertices.
-	if (pcMesh->mBones)
-		return (unsigned int)(uint64_t)pcMesh->mBones;
+unsigned int PretransformVertices::GetMeshVFormat( aiMesh* pcMesh )
+{
+    // the vertex format is stored in aiMesh::mBones for later retrieval.
+    // there isn't a good reason to compute it a few hundred times
+    // from scratch. The pointer is unused as animations are lost
+    // during PretransformVertices.
+    if (pcMesh->mBones)
+        return (unsigned int)(uint64_t)pcMesh->mBones;
 
-	const unsigned int iRet = GetMeshVFormatUnique(pcMesh);
 
-	// store the value for later use
-	pcMesh->mBones = (aiBone **)(uint64_t)iRet;
-	return iRet;
+    const unsigned int iRet = GetMeshVFormatUnique(pcMesh);
+
+    // store the value for later use
+    pcMesh->mBones = (aiBone**)(uint64_t)iRet;
+    return iRet;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Count the number of vertices in the whole scene and a given
 // material index
-void PretransformVertices::CountVerticesAndFaces(const aiScene *pcScene, const aiNode *pcNode, unsigned int iMat,
-		unsigned int iVFormat, unsigned int *piFaces, unsigned int *piVertices) const {
-	for (unsigned int i = 0; i < pcNode->mNumMeshes; ++i) {
-		aiMesh *pcMesh = pcScene->mMeshes[pcNode->mMeshes[i]];
-		if (iMat == pcMesh->mMaterialIndex && iVFormat == GetMeshVFormat(pcMesh)) {
-			*piVertices += pcMesh->mNumVertices;
-			*piFaces += pcMesh->mNumFaces;
-		}
-	}
-	for (unsigned int i = 0; i < pcNode->mNumChildren; ++i) {
-		CountVerticesAndFaces(pcScene, pcNode->mChildren[i], iMat,
-				iVFormat, piFaces, piVertices);
-	}
+void PretransformVertices::CountVerticesAndFaces( aiScene* pcScene, aiNode* pcNode, unsigned int iMat,
+    unsigned int iVFormat, unsigned int* piFaces, unsigned int* piVertices)
+{
+    for (unsigned int i = 0; i < pcNode->mNumMeshes;++i)
+    {
+        aiMesh* pcMesh = pcScene->mMeshes[ pcNode->mMeshes[i] ];
+        if (iMat == pcMesh->mMaterialIndex && iVFormat == GetMeshVFormat(pcMesh))
+        {
+            *piVertices += pcMesh->mNumVertices;
+            *piFaces += pcMesh->mNumFaces;
+        }
+    }
+    for (unsigned int i = 0;i < pcNode->mNumChildren;++i)
+    {
+        CountVerticesAndFaces(pcScene,pcNode->mChildren[i],iMat,
+            iVFormat,piFaces,piVertices);
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Collect vertex/face data
-void PretransformVertices::CollectData(const aiScene *pcScene, const aiNode *pcNode, unsigned int iMat,
-		unsigned int iVFormat, aiMesh *pcMeshOut,
-		unsigned int aiCurrent[2], unsigned int *num_refs) const {
-	// No need to multiply if there's no transformation
-	const bool identity = pcNode->mTransformation.IsIdentity();
-	for (unsigned int i = 0; i < pcNode->mNumMeshes; ++i) {
-		aiMesh *pcMesh = pcScene->mMeshes[pcNode->mMeshes[i]];
-		if (iMat == pcMesh->mMaterialIndex && iVFormat == GetMeshVFormat(pcMesh)) {
-			// Decrement mesh reference counter
-			unsigned int &num_ref = num_refs[pcNode->mMeshes[i]];
-			ai_assert(0 != num_ref);
-			--num_ref;
-			// Save the name of the last mesh
-			if (num_ref == 0) {
-				pcMeshOut->mName = pcMesh->mName;
-			}
+void PretransformVertices::CollectData( aiScene* pcScene, aiNode* pcNode, unsigned int iMat,
+    unsigned int iVFormat, aiMesh* pcMeshOut,
+    unsigned int aiCurrent[2], unsigned int* num_refs)
+{
+    // No need to multiply if there's no transformation
+    const bool identity = pcNode->mTransformation.IsIdentity();
+    for (unsigned int i = 0; i < pcNode->mNumMeshes;++i)
+    {
+        aiMesh* pcMesh = pcScene->mMeshes[ pcNode->mMeshes[i] ];
+        if (iMat == pcMesh->mMaterialIndex && iVFormat == GetMeshVFormat(pcMesh))
+        {
+            // Decrement mesh reference counter
+            unsigned int& num_ref = num_refs[pcNode->mMeshes[i]];
+            ai_assert(0 != num_ref);
+            --num_ref;
+            // Save the name of the last mesh
+            if (num_ref==0)
+            {
+                pcMeshOut->mName = pcMesh->mName;
+            }
 
-			if (identity) {
-				// copy positions without modifying them
-				::memcpy(pcMeshOut->mVertices + aiCurrent[AI_PTVS_VERTEX],
-						pcMesh->mVertices,
-						pcMesh->mNumVertices * sizeof(aiVector3D));
+            if (identity)   {
+                // copy positions without modifying them
+                ::memcpy(pcMeshOut->mVertices + aiCurrent[AI_PTVS_VERTEX],
+                    pcMesh->mVertices,
+                    pcMesh->mNumVertices * sizeof(aiVector3D));
 
-				if (iVFormat & 0x2) {
-					// copy normals without modifying them
-					::memcpy(pcMeshOut->mNormals + aiCurrent[AI_PTVS_VERTEX],
-							pcMesh->mNormals,
-							pcMesh->mNumVertices * sizeof(aiVector3D));
-				}
-				if (iVFormat & 0x4) {
-					// copy tangents without modifying them
-					::memcpy(pcMeshOut->mTangents + aiCurrent[AI_PTVS_VERTEX],
-							pcMesh->mTangents,
-							pcMesh->mNumVertices * sizeof(aiVector3D));
-					// copy bitangents without modifying them
-					::memcpy(pcMeshOut->mBitangents + aiCurrent[AI_PTVS_VERTEX],
-							pcMesh->mBitangents,
-							pcMesh->mNumVertices * sizeof(aiVector3D));
-				}
-			} else {
-				// copy positions, transform them to worldspace
-				for (unsigned int n = 0; n < pcMesh->mNumVertices; ++n) {
-					pcMeshOut->mVertices[aiCurrent[AI_PTVS_VERTEX] + n] = pcNode->mTransformation * pcMesh->mVertices[n];
-				}
-				aiMatrix4x4 mWorldIT = pcNode->mTransformation;
-				mWorldIT.Inverse().Transpose();
+                if (iVFormat & 0x2) {
+                    // copy normals without modifying them
+                    ::memcpy(pcMeshOut->mNormals + aiCurrent[AI_PTVS_VERTEX],
+                        pcMesh->mNormals,
+                        pcMesh->mNumVertices * sizeof(aiVector3D));
+                }
+                if (iVFormat & 0x4)
+                {
+                    // copy tangents without modifying them
+                    ::memcpy(pcMeshOut->mTangents + aiCurrent[AI_PTVS_VERTEX],
+                        pcMesh->mTangents,
+                        pcMesh->mNumVertices * sizeof(aiVector3D));
+                    // copy bitangents without modifying them
+                    ::memcpy(pcMeshOut->mBitangents + aiCurrent[AI_PTVS_VERTEX],
+                        pcMesh->mBitangents,
+                        pcMesh->mNumVertices * sizeof(aiVector3D));
+                }
+            }
+            else
+            {
+                // copy positions, transform them to worldspace
+                for (unsigned int n = 0; n < pcMesh->mNumVertices;++n)  {
+                    pcMeshOut->mVertices[aiCurrent[AI_PTVS_VERTEX]+n] = pcNode->mTransformation * pcMesh->mVertices[n];
+                }
+                aiMatrix4x4 mWorldIT = pcNode->mTransformation;
+                mWorldIT.Inverse().Transpose();
 
-				// TODO: implement Inverse() for aiMatrix3x3
-				aiMatrix3x3 m = aiMatrix3x3(mWorldIT);
+                // TODO: implement Inverse() for aiMatrix3x3
+                aiMatrix3x3 m = aiMatrix3x3(mWorldIT);
 
-				if (iVFormat & 0x2) {
-					// copy normals, transform them to worldspace
-					for (unsigned int n = 0; n < pcMesh->mNumVertices; ++n) {
-						pcMeshOut->mNormals[aiCurrent[AI_PTVS_VERTEX] + n] =
-								(m * pcMesh->mNormals[n]).Normalize();
-					}
-				}
-				if (iVFormat & 0x4) {
-					// copy tangents and bitangents, transform them to worldspace
-					for (unsigned int n = 0; n < pcMesh->mNumVertices; ++n) {
-						pcMeshOut->mTangents[aiCurrent[AI_PTVS_VERTEX] + n] = (m * pcMesh->mTangents[n]).Normalize();
-						pcMeshOut->mBitangents[aiCurrent[AI_PTVS_VERTEX] + n] = (m * pcMesh->mBitangents[n]).Normalize();
-					}
-				}
-			}
-			unsigned int p = 0;
-			while (iVFormat & (0x100 << p)) {
-				// copy texture coordinates
-				memcpy(pcMeshOut->mTextureCoords[p] + aiCurrent[AI_PTVS_VERTEX],
-						pcMesh->mTextureCoords[p],
-						pcMesh->mNumVertices * sizeof(aiVector3D));
-				++p;
-			}
-			p = 0;
-			while (iVFormat & (0x1000000 << p)) {
-				// copy vertex colors
-				memcpy(pcMeshOut->mColors[p] + aiCurrent[AI_PTVS_VERTEX],
-						pcMesh->mColors[p],
-						pcMesh->mNumVertices * sizeof(aiColor4D));
-				++p;
-			}
-			// now we need to copy all faces. since we will delete the source mesh afterwards,
-			// we don't need to reallocate the array of indices except if this mesh is
-			// referenced multiple times.
-			for (unsigned int planck = 0; planck < pcMesh->mNumFaces; ++planck) {
-				aiFace &f_src = pcMesh->mFaces[planck];
-				aiFace &f_dst = pcMeshOut->mFaces[aiCurrent[AI_PTVS_FACE] + planck];
+                if (iVFormat & 0x2)
+                {
+                    // copy normals, transform them to worldspace
+                    for (unsigned int n = 0; n < pcMesh->mNumVertices;++n)  {
+                        pcMeshOut->mNormals[aiCurrent[AI_PTVS_VERTEX]+n] =
+                            (m * pcMesh->mNormals[n]).Normalize();
+                    }
+                }
+                if (iVFormat & 0x4)
+                {
+                    // copy tangents and bitangents, transform them to worldspace
+                    for (unsigned int n = 0; n < pcMesh->mNumVertices;++n)  {
+                        pcMeshOut->mTangents  [aiCurrent[AI_PTVS_VERTEX]+n] = (m * pcMesh->mTangents[n]).Normalize();
+                        pcMeshOut->mBitangents[aiCurrent[AI_PTVS_VERTEX]+n] = (m * pcMesh->mBitangents[n]).Normalize();
+                    }
+                }
+            }
+            unsigned int p = 0;
+            while (iVFormat & (0x100 << p))
+            {
+                // copy texture coordinates
+                memcpy(pcMeshOut->mTextureCoords[p] + aiCurrent[AI_PTVS_VERTEX],
+                    pcMesh->mTextureCoords[p],
+                    pcMesh->mNumVertices * sizeof(aiVector3D));
+                ++p;
+            }
+            p = 0;
+            while (iVFormat & (0x1000000 << p))
+            {
+                // copy vertex colors
+                memcpy(pcMeshOut->mColors[p] + aiCurrent[AI_PTVS_VERTEX],
+                    pcMesh->mColors[p],
+                    pcMesh->mNumVertices * sizeof(aiColor4D));
+                ++p;
+            }
+            // now we need to copy all faces. since we will delete the source mesh afterwards,
+            // we don't need to reallocate the array of indices except if this mesh is
+            // referenced multiple times.
+            for (unsigned int planck = 0;planck < pcMesh->mNumFaces;++planck)
+            {
+                aiFace& f_src = pcMesh->mFaces[planck];
+                aiFace& f_dst = pcMeshOut->mFaces[aiCurrent[AI_PTVS_FACE]+planck];
 
-				const unsigned int num_idx = f_src.mNumIndices;
+                const unsigned int num_idx = f_src.mNumIndices;
 
-				f_dst.mNumIndices = num_idx;
+                f_dst.mNumIndices = num_idx;
 
-				unsigned int *pi;
-				if (!num_ref) { /* if last time the mesh is referenced -> no reallocation */
-					pi = f_dst.mIndices = f_src.mIndices;
+                unsigned int* pi;
+                if (!num_ref) { /* if last time the mesh is referenced -> no reallocation */
+                    pi = f_dst.mIndices = f_src.mIndices;
 
-					// offset all vertex indices
-					for (unsigned int hahn = 0; hahn < num_idx; ++hahn) {
-						pi[hahn] += aiCurrent[AI_PTVS_VERTEX];
-					}
-				} else {
-					pi = f_dst.mIndices = new unsigned int[num_idx];
+                    // offset all vertex indices
+                    for (unsigned int hahn = 0; hahn < num_idx;++hahn){
+                        pi[hahn] += aiCurrent[AI_PTVS_VERTEX];
+                    }
+                }
+                else {
+                    pi = f_dst.mIndices = new unsigned int[num_idx];
 
-					// copy and offset all vertex indices
-					for (unsigned int hahn = 0; hahn < num_idx; ++hahn) {
-						pi[hahn] = f_src.mIndices[hahn] + aiCurrent[AI_PTVS_VERTEX];
-					}
-				}
+                    // copy and offset all vertex indices
+                    for (unsigned int hahn = 0; hahn < num_idx;++hahn){
+                        pi[hahn] = f_src.mIndices[hahn] + aiCurrent[AI_PTVS_VERTEX];
+                    }
+                }
 
-				// Update the mPrimitiveTypes member of the mesh
-				switch (pcMesh->mFaces[planck].mNumIndices) {
-					case 0x1:
-						pcMeshOut->mPrimitiveTypes |= aiPrimitiveType_POINT;
-						break;
-					case 0x2:
-						pcMeshOut->mPrimitiveTypes |= aiPrimitiveType_LINE;
-						break;
-					case 0x3:
-						pcMeshOut->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
-						break;
-					default:
-						pcMeshOut->mPrimitiveTypes |= aiPrimitiveType_POLYGON;
-						break;
-				};
-			}
-			aiCurrent[AI_PTVS_VERTEX] += pcMesh->mNumVertices;
-			aiCurrent[AI_PTVS_FACE] += pcMesh->mNumFaces;
-		}
-	}
+                // Update the mPrimitiveTypes member of the mesh
+                switch (pcMesh->mFaces[planck].mNumIndices)
+                {
+                case 0x1:
+                    pcMeshOut->mPrimitiveTypes |= aiPrimitiveType_POINT;
+                    break;
+                case 0x2:
+                    pcMeshOut->mPrimitiveTypes |= aiPrimitiveType_LINE;
+                    break;
+                case 0x3:
+                    pcMeshOut->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
+                    break;
+                default:
+                    pcMeshOut->mPrimitiveTypes |= aiPrimitiveType_POLYGON;
+                    break;
+                };
+            }
+            aiCurrent[AI_PTVS_VERTEX] += pcMesh->mNumVertices;
+            aiCurrent[AI_PTVS_FACE]   += pcMesh->mNumFaces;
+        }
+    }
 
-	// append all children of us
-	for (unsigned int i = 0; i < pcNode->mNumChildren; ++i) {
-		CollectData(pcScene, pcNode->mChildren[i], iMat,
-				iVFormat, pcMeshOut, aiCurrent, num_refs);
-	}
+    // append all children of us
+    for (unsigned int i = 0;i < pcNode->mNumChildren;++i) {
+        CollectData(pcScene,pcNode->mChildren[i],iMat,
+            iVFormat,pcMeshOut,aiCurrent,num_refs);
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get a list of all vertex formats that occur for a given material index
 // The output list contains duplicate elements
-void PretransformVertices::GetVFormatList(const aiScene *pcScene, unsigned int iMat,
-		std::list<unsigned int> &aiOut) const {
-	for (unsigned int i = 0; i < pcScene->mNumMeshes; ++i) {
-		aiMesh *pcMesh = pcScene->mMeshes[i];
-		if (iMat == pcMesh->mMaterialIndex) {
-			aiOut.push_back(GetMeshVFormat(pcMesh));
-		}
-	}
+void PretransformVertices::GetVFormatList( aiScene* pcScene, unsigned int iMat,
+    std::list<unsigned int>& aiOut)
+{
+    for (unsigned int i = 0; i < pcScene->mNumMeshes;++i)
+    {
+        aiMesh* pcMesh = pcScene->mMeshes[ i ];
+        if (iMat == pcMesh->mMaterialIndex) {
+            aiOut.push_back(GetMeshVFormat(pcMesh));
+        }
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Compute the absolute transformation matrices of each node
-void PretransformVertices::ComputeAbsoluteTransform(aiNode *pcNode) {
-	if (pcNode->mParent) {
-		pcNode->mTransformation = pcNode->mParent->mTransformation * pcNode->mTransformation;
-	}
+void PretransformVertices::ComputeAbsoluteTransform( aiNode* pcNode )
+{
+    if (pcNode->mParent)    {
+        pcNode->mTransformation = pcNode->mParent->mTransformation*pcNode->mTransformation;
+    }
 
-	for (unsigned int i = 0; i < pcNode->mNumChildren; ++i) {
-		ComputeAbsoluteTransform(pcNode->mChildren[i]);
-	}
+    for (unsigned int i = 0;i < pcNode->mNumChildren;++i)   {
+        ComputeAbsoluteTransform(pcNode->mChildren[i]);
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Apply the node transformation to a mesh
-void PretransformVertices::ApplyTransform(aiMesh *mesh, const aiMatrix4x4 &mat) const {
-	// Check whether we need to transform the coordinates at all
-	if (!mat.IsIdentity()) {
+void PretransformVertices::ApplyTransform(aiMesh* mesh, const aiMatrix4x4& mat)
+{
+    // Check whether we need to transform the coordinates at all
+    if (!mat.IsIdentity()) {
 
-		// Check for odd negative scale (mirror)
-		if (mesh->HasFaces() && mat.Determinant() < 0) {
-			// Reverse the mesh face winding order
-			FlipWindingOrderProcess::ProcessMesh(mesh);
-		}
+        if (mesh->HasPositions()) {
+            for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
+                mesh->mVertices[i] = mat * mesh->mVertices[i];
+            }
+        }
+        if (mesh->HasNormals() || mesh->HasTangentsAndBitangents()) {
+            aiMatrix4x4 mWorldIT = mat;
+            mWorldIT.Inverse().Transpose();
 
-		// Update positions
-		if (mesh->HasPositions()) {
-			for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
-				mesh->mVertices[i] = mat * mesh->mVertices[i];
-			}
-		}
+            // TODO: implement Inverse() for aiMatrix3x3
+            aiMatrix3x3 m = aiMatrix3x3(mWorldIT);
 
-		// Update normals and tangents
-		if (mesh->HasNormals() || mesh->HasTangentsAndBitangents()) {
-			const aiMatrix3x3 m = aiMatrix3x3(mat).Inverse().Transpose();
-
-			if (mesh->HasNormals()) {
-				for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
-					mesh->mNormals[i] = (m * mesh->mNormals[i]).Normalize();
-				}
-			}
-			if (mesh->HasTangentsAndBitangents()) {
-				for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
-					mesh->mTangents[i] = (m * mesh->mTangents[i]).Normalize();
-					mesh->mBitangents[i] = (m * mesh->mBitangents[i]).Normalize();
-				}
-			}
-		}
-	}
+            if (mesh->HasNormals()) {
+                for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
+                    mesh->mNormals[i] = (m * mesh->mNormals[i]).Normalize();
+                }
+            }
+            if (mesh->HasTangentsAndBitangents()) {
+                for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
+                    mesh->mTangents[i]   = (m * mesh->mTangents[i]).Normalize();
+                    mesh->mBitangents[i] = (m * mesh->mBitangents[i]).Normalize();
+                }
+            }
+        }
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Simple routine to build meshes in worldspace, no further optimization
-void PretransformVertices::BuildWCSMeshes(std::vector<aiMesh *> &out, aiMesh **in,
-		unsigned int numIn, aiNode *node) const {
-	// NOTE:
-	//  aiMesh::mNumBones store original source mesh, or UINT_MAX if not a copy
-	//  aiMesh::mBones store reference to abs. transform we multiplied with
+void PretransformVertices::BuildWCSMeshes(std::vector<aiMesh*>& out, aiMesh** in,
+    unsigned int numIn, aiNode* node)
+{
+    // NOTE:
+    //  aiMesh::mNumBones store original source mesh, or UINT_MAX if not a copy
+    //  aiMesh::mBones store reference to abs. transform we multiplied with
 
-	// process meshes
-	for (unsigned int i = 0; i < node->mNumMeshes; ++i) {
-		aiMesh *mesh = in[node->mMeshes[i]];
+    // process meshes
+    for (unsigned int i = 0; i < node->mNumMeshes;++i) {
+        aiMesh* mesh = in[node->mMeshes[i]];
 
-		// check whether we can operate on this mesh
-		if (!mesh->mBones || *reinterpret_cast<aiMatrix4x4 *>(mesh->mBones) == node->mTransformation) {
-			// yes, we can.
-			mesh->mBones = reinterpret_cast<aiBone **>(&node->mTransformation);
-			mesh->mNumBones = UINT_MAX;
-		} else {
+        // check whether we can operate on this mesh
+        if (!mesh->mBones || *reinterpret_cast<aiMatrix4x4*>(mesh->mBones) == node->mTransformation) {
+            // yes, we can.
+            mesh->mBones = reinterpret_cast<aiBone**> (&node->mTransformation);
+            mesh->mNumBones = UINT_MAX;
+        }
+        else {
 
-			// try to find us in the list of newly created meshes
-			for (unsigned int n = 0; n < out.size(); ++n) {
-				aiMesh *ctz = out[n];
-				if (ctz->mNumBones == node->mMeshes[i] && *reinterpret_cast<aiMatrix4x4 *>(ctz->mBones) == node->mTransformation) {
+            // try to find us in the list of newly created meshes
+            for (unsigned int n = 0; n < out.size(); ++n) {
+                aiMesh* ctz = out[n];
+                if (ctz->mNumBones == node->mMeshes[i] && *reinterpret_cast<aiMatrix4x4*>(ctz->mBones) ==  node->mTransformation) {
 
-					// ok, use this one. Update node mesh index
-					node->mMeshes[i] = numIn + n;
-				}
-			}
-			if (node->mMeshes[i] < numIn) {
-				// Worst case. Need to operate on a full copy of the mesh
-				ASSIMP_LOG_INFO("PretransformVertices: Copying mesh due to mismatching transforms");
-				aiMesh *ntz;
+                    // ok, use this one. Update node mesh index
+                    node->mMeshes[i] = numIn + n;
+                }
+            }
+            if (node->mMeshes[i] < numIn) {
+                // Worst case. Need to operate on a full copy of the mesh
+                ASSIMP_LOG_INFO("PretransformVertices: Copying mesh due to mismatching transforms");
+                aiMesh* ntz;
 
-				const unsigned int tmp = mesh->mNumBones; //
-				mesh->mNumBones = 0;
-				SceneCombiner::Copy(&ntz, mesh);
-				mesh->mNumBones = tmp;
+                const unsigned int tmp = mesh->mNumBones; //
+                mesh->mNumBones = 0;
+                SceneCombiner::Copy(&ntz,mesh);
+                mesh->mNumBones = tmp;
 
-				ntz->mNumBones = node->mMeshes[i];
-				ntz->mBones = reinterpret_cast<aiBone **>(&node->mTransformation);
+                ntz->mNumBones = node->mMeshes[i];
+                ntz->mBones = reinterpret_cast<aiBone**> (&node->mTransformation);
 
-				out.push_back(ntz);
+                out.push_back(ntz);
 
-				node->mMeshes[i] = static_cast<unsigned int>(numIn + out.size() - 1);
-			}
-		}
-	}
+                node->mMeshes[i] = static_cast<unsigned int>(numIn + out.size() - 1);
+            }
+        }
+    }
 
-	// call children
-	for (unsigned int i = 0; i < node->mNumChildren; ++i)
-		BuildWCSMeshes(out, in, numIn, node->mChildren[i]);
+    // call children
+    for (unsigned int i = 0; i < node->mNumChildren;++i)
+        BuildWCSMeshes(out,in,numIn,node->mChildren[i]);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Reset transformation matrices to identity
-void PretransformVertices::MakeIdentityTransform(aiNode *nd) const {
-	nd->mTransformation = aiMatrix4x4();
+void PretransformVertices::MakeIdentityTransform(aiNode* nd)
+{
+    nd->mTransformation = aiMatrix4x4();
 
-	// call children
-	for (unsigned int i = 0; i < nd->mNumChildren; ++i)
-		MakeIdentityTransform(nd->mChildren[i]);
+    // call children
+    for (unsigned int i = 0; i < nd->mNumChildren;++i)
+        MakeIdentityTransform(nd->mChildren[i]);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Build reference counters for all meshes
-void PretransformVertices::BuildMeshRefCountArray(const aiNode *nd, unsigned int *refs) const {
-	for (unsigned int i = 0; i < nd->mNumMeshes; ++i)
-		refs[nd->mMeshes[i]]++;
+void PretransformVertices::BuildMeshRefCountArray(aiNode* nd, unsigned int * refs)
+{
+    for (unsigned int i = 0; i< nd->mNumMeshes;++i)
+        refs[nd->mMeshes[i]]++;
 
-	// call children
-	for (unsigned int i = 0; i < nd->mNumChildren; ++i)
-		BuildMeshRefCountArray(nd->mChildren[i], refs);
+    // call children
+    for (unsigned int i = 0; i < nd->mNumChildren;++i)
+        BuildMeshRefCountArray(nd->mChildren[i],refs);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Executes the post processing step on the given imported data.
-void PretransformVertices::Execute(aiScene *pScene) {
-	ASSIMP_LOG_DEBUG("PretransformVerticesProcess begin");
+void PretransformVertices::Execute( aiScene* pScene)
+{
+    ASSIMP_LOG_DEBUG("PretransformVerticesProcess begin");
 
-	// Return immediately if we have no meshes
-	if (!pScene->mNumMeshes)
-		return;
+    // Return immediately if we have no meshes
+    if (!pScene->mNumMeshes)
+        return;
 
-	const unsigned int iOldMeshes = pScene->mNumMeshes;
-	const unsigned int iOldAnimationChannels = pScene->mNumAnimations;
-	const unsigned int iOldNodes = CountNodes(pScene->mRootNode);
+    const unsigned int iOldMeshes = pScene->mNumMeshes;
+    const unsigned int iOldAnimationChannels = pScene->mNumAnimations;
+    const unsigned int iOldNodes = CountNodes(pScene->mRootNode);
 
-	if (configTransform) {
-		pScene->mRootNode->mTransformation = configTransformation;
-	}
+    if(configTransform) {
+        pScene->mRootNode->mTransformation = configTransformation;
+    }
 
-	// first compute absolute transformation matrices for all nodes
-	ComputeAbsoluteTransform(pScene->mRootNode);
+    // first compute absolute transformation matrices for all nodes
+    ComputeAbsoluteTransform(pScene->mRootNode);
 
-	// Delete aiMesh::mBones for all meshes. The bones are
-	// removed during this step and we need the pointer as
-	// temporary storage
-	for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
-		aiMesh *mesh = pScene->mMeshes[i];
+    // Delete aiMesh::mBones for all meshes. The bones are
+    // removed during this step and we need the pointer as
+    // temporary storage
+    for (unsigned int i = 0; i < pScene->mNumMeshes;++i)    {
+        aiMesh* mesh = pScene->mMeshes[i];
 
-		for (unsigned int a = 0; a < mesh->mNumBones; ++a)
-			delete mesh->mBones[a];
+        for (unsigned int a = 0; a < mesh->mNumBones;++a)
+            delete mesh->mBones[a];
 
-		delete[] mesh->mBones;
-		mesh->mBones = NULL;
-	}
+        delete[] mesh->mBones;
+        mesh->mBones = NULL;
+    }
 
-	// now build a list of output meshes
-	std::vector<aiMesh *> apcOutMeshes;
+    // now build a list of output meshes
+    std::vector<aiMesh*> apcOutMeshes;
 
-	// Keep scene hierarchy? It's an easy job in this case ...
-	// we go on and transform all meshes, if one is referenced by nodes
-	// with different absolute transformations a depth copy of the mesh
-	// is required.
-	if (configKeepHierarchy) {
+    // Keep scene hierarchy? It's an easy job in this case ...
+    // we go on and transform all meshes, if one is referenced by nodes
+    // with different absolute transformations a depth copy of the mesh
+    // is required.
+    if( configKeepHierarchy ) {
 
-		// Hack: store the matrix we're transforming a mesh with in aiMesh::mBones
-		BuildWCSMeshes(apcOutMeshes, pScene->mMeshes, pScene->mNumMeshes, pScene->mRootNode);
+        // Hack: store the matrix we're transforming a mesh with in aiMesh::mBones
+        BuildWCSMeshes(apcOutMeshes,pScene->mMeshes,pScene->mNumMeshes, pScene->mRootNode);
 
-		// ... if new meshes have been generated, append them to the end of the scene
-		if (apcOutMeshes.size() > 0) {
-			aiMesh **npp = new aiMesh *[pScene->mNumMeshes + apcOutMeshes.size()];
+        // ... if new meshes have been generated, append them to the end of the scene
+        if (apcOutMeshes.size() > 0) {
+            aiMesh** npp = new aiMesh*[pScene->mNumMeshes + apcOutMeshes.size()];
 
-			memcpy(npp, pScene->mMeshes, sizeof(aiMesh *) * pScene->mNumMeshes);
-			memcpy(npp + pScene->mNumMeshes, &apcOutMeshes[0], sizeof(aiMesh *) * apcOutMeshes.size());
+            memcpy(npp,pScene->mMeshes,sizeof(aiMesh*)*pScene->mNumMeshes);
+            memcpy(npp+pScene->mNumMeshes,&apcOutMeshes[0],sizeof(aiMesh*)*apcOutMeshes.size());
 
-			pScene->mNumMeshes += static_cast<unsigned int>(apcOutMeshes.size());
-			delete[] pScene->mMeshes;
-			pScene->mMeshes = npp;
-		}
+            pScene->mNumMeshes  += static_cast<unsigned int>(apcOutMeshes.size());
+            delete[] pScene->mMeshes; pScene->mMeshes = npp;
+        }
 
-		// now iterate through all meshes and transform them to worldspace
-		for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
-			ApplyTransform(pScene->mMeshes[i], *reinterpret_cast<aiMatrix4x4 *>(pScene->mMeshes[i]->mBones));
+        // now iterate through all meshes and transform them to worldspace
+        for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
+            ApplyTransform(pScene->mMeshes[i],*reinterpret_cast<aiMatrix4x4*>( pScene->mMeshes[i]->mBones ));
 
-			// prevent improper destruction
-			pScene->mMeshes[i]->mBones = NULL;
-			pScene->mMeshes[i]->mNumBones = 0;
-		}
-	} else {
-		apcOutMeshes.reserve(pScene->mNumMaterials << 1u);
-		std::list<unsigned int> aiVFormats;
+            // prevent improper destruction
+            pScene->mMeshes[i]->mBones    = NULL;
+            pScene->mMeshes[i]->mNumBones = 0;
+        }
+    } else {
+        apcOutMeshes.reserve(pScene->mNumMaterials<<1u);
+        std::list<unsigned int> aiVFormats;
 
-		std::vector<unsigned int> s(pScene->mNumMeshes, 0);
-		BuildMeshRefCountArray(pScene->mRootNode, &s[0]);
+        std::vector<unsigned int> s(pScene->mNumMeshes,0);
+        BuildMeshRefCountArray(pScene->mRootNode,&s[0]);
 
-		for (unsigned int i = 0; i < pScene->mNumMaterials; ++i) {
-			// get the list of all vertex formats for this material
-			aiVFormats.clear();
-			GetVFormatList(pScene, i, aiVFormats);
-			aiVFormats.sort();
-			aiVFormats.unique();
-			for (std::list<unsigned int>::const_iterator j = aiVFormats.begin(); j != aiVFormats.end(); ++j) {
-				unsigned int iVertices = 0;
-				unsigned int iFaces = 0;
-				CountVerticesAndFaces(pScene, pScene->mRootNode, i, *j, &iFaces, &iVertices);
-				if (0 != iFaces && 0 != iVertices) {
-					apcOutMeshes.push_back(new aiMesh());
-					aiMesh *pcMesh = apcOutMeshes.back();
-					pcMesh->mNumFaces = iFaces;
-					pcMesh->mNumVertices = iVertices;
-					pcMesh->mFaces = new aiFace[iFaces];
-					pcMesh->mVertices = new aiVector3D[iVertices];
-					pcMesh->mMaterialIndex = i;
-					if ((*j) & 0x2) pcMesh->mNormals = new aiVector3D[iVertices];
-					if ((*j) & 0x4) {
-						pcMesh->mTangents = new aiVector3D[iVertices];
-						pcMesh->mBitangents = new aiVector3D[iVertices];
-					}
-					iFaces = 0;
-					while ((*j) & (0x100 << iFaces)) {
-						pcMesh->mTextureCoords[iFaces] = new aiVector3D[iVertices];
-						if ((*j) & (0x10000 << iFaces))
-							pcMesh->mNumUVComponents[iFaces] = 3;
-						else
-							pcMesh->mNumUVComponents[iFaces] = 2;
-						iFaces++;
-					}
-					iFaces = 0;
-					while ((*j) & (0x1000000 << iFaces))
-						pcMesh->mColors[iFaces++] = new aiColor4D[iVertices];
+        for (unsigned int i = 0; i < pScene->mNumMaterials;++i)     {
+            // get the list of all vertex formats for this material
+            aiVFormats.clear();
+            GetVFormatList(pScene,i,aiVFormats);
+            aiVFormats.sort();
+            aiVFormats.unique();
+            for (std::list<unsigned int>::const_iterator j =  aiVFormats.begin();j != aiVFormats.end();++j) {
+                unsigned int iVertices = 0;
+                unsigned int iFaces = 0;
+                CountVerticesAndFaces(pScene,pScene->mRootNode,i,*j,&iFaces,&iVertices);
+                if (0 != iFaces && 0 != iVertices)
+                {
+                    apcOutMeshes.push_back(new aiMesh());
+                    aiMesh* pcMesh = apcOutMeshes.back();
+                    pcMesh->mNumFaces = iFaces;
+                    pcMesh->mNumVertices = iVertices;
+                    pcMesh->mFaces = new aiFace[iFaces];
+                    pcMesh->mVertices = new aiVector3D[iVertices];
+                    pcMesh->mMaterialIndex = i;
+                    if ((*j) & 0x2)pcMesh->mNormals = new aiVector3D[iVertices];
+                    if ((*j) & 0x4)
+                    {
+                        pcMesh->mTangents    = new aiVector3D[iVertices];
+                        pcMesh->mBitangents  = new aiVector3D[iVertices];
+                    }
+                    iFaces = 0;
+                    while ((*j) & (0x100 << iFaces))
+                    {
+                        pcMesh->mTextureCoords[iFaces] = new aiVector3D[iVertices];
+                        if ((*j) & (0x10000 << iFaces))pcMesh->mNumUVComponents[iFaces] = 3;
+                        else pcMesh->mNumUVComponents[iFaces] = 2;
+                        iFaces++;
+                    }
+                    iFaces = 0;
+                    while ((*j) & (0x1000000 << iFaces))
+                        pcMesh->mColors[iFaces++] = new aiColor4D[iVertices];
 
-					// fill the mesh ...
-					unsigned int aiTemp[2] = { 0, 0 };
-					CollectData(pScene, pScene->mRootNode, i, *j, pcMesh, aiTemp, &s[0]);
-				}
-			}
-		}
+                    // fill the mesh ...
+                    unsigned int aiTemp[2] = {0,0};
+                    CollectData(pScene,pScene->mRootNode,i,*j,pcMesh,aiTemp,&s[0]);
+                }
+            }
+        }
 
-		// If no meshes are referenced in the node graph it is possible that we get no output meshes.
-		if (apcOutMeshes.empty()) {
+        // If no meshes are referenced in the node graph it is possible that we get no output meshes.
+        if (apcOutMeshes.empty()) {
+            
+            throw DeadlyImportError("No output meshes: all meshes are orphaned and are not referenced by any nodes");
+        }
+        else
+        {
+            // now delete all meshes in the scene and build a new mesh list
+            for (unsigned int i = 0; i < pScene->mNumMeshes;++i)
+            {
+                aiMesh* mesh = pScene->mMeshes[i];
+                mesh->mNumBones = 0;
+                mesh->mBones    = NULL;
 
-			throw DeadlyImportError("No output meshes: all meshes are orphaned and are not referenced by any nodes");
-		} else {
-			// now delete all meshes in the scene and build a new mesh list
-			for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
-				aiMesh *mesh = pScene->mMeshes[i];
-				mesh->mNumBones = 0;
-				mesh->mBones = NULL;
+                // we're reusing the face index arrays. avoid destruction
+                for (unsigned int a = 0; a < mesh->mNumFaces; ++a) {
+                    mesh->mFaces[a].mNumIndices = 0;
+                    mesh->mFaces[a].mIndices = NULL;
+                }
 
-				// we're reusing the face index arrays. avoid destruction
-				for (unsigned int a = 0; a < mesh->mNumFaces; ++a) {
-					mesh->mFaces[a].mNumIndices = 0;
-					mesh->mFaces[a].mIndices = NULL;
-				}
+                delete mesh;
 
-				delete mesh;
+                // Invalidate the contents of the old mesh array. We will most
+                // likely have less output meshes now, so the last entries of
+                // the mesh array are not overridden. We set them to NULL to
+                // make sure the developer gets notified when his application
+                // attempts to access these fields ...
+                mesh = NULL;
+            }
 
-				// Invalidate the contents of the old mesh array. We will most
-				// likely have less output meshes now, so the last entries of
-				// the mesh array are not overridden. We set them to NULL to
-				// make sure the developer gets notified when his application
-				// attempts to access these fields ...
-				mesh = NULL;
-			}
+            // It is impossible that we have more output meshes than
+            // input meshes, so we can easily reuse the old mesh array
+            pScene->mNumMeshes = (unsigned int)apcOutMeshes.size();
+            for (unsigned int i = 0; i < pScene->mNumMeshes;++i) {
+                pScene->mMeshes[i] = apcOutMeshes[i];
+            }
+        }
+    }
 
-			// It is impossible that we have more output meshes than
-			// input meshes, so we can easily reuse the old mesh array
-			pScene->mNumMeshes = (unsigned int)apcOutMeshes.size();
-			for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
-				pScene->mMeshes[i] = apcOutMeshes[i];
-			}
-		}
-	}
+    // remove all animations from the scene
+    for (unsigned int i = 0; i < pScene->mNumAnimations;++i)
+        delete pScene->mAnimations[i];
+    delete[] pScene->mAnimations;
 
-	// remove all animations from the scene
-	for (unsigned int i = 0; i < pScene->mNumAnimations; ++i)
-		delete pScene->mAnimations[i];
-	delete[] pScene->mAnimations;
+    pScene->mAnimations    = NULL;
+    pScene->mNumAnimations = 0;
 
-	pScene->mAnimations = NULL;
-	pScene->mNumAnimations = 0;
+    // --- we need to keep all cameras and lights
+    for (unsigned int i = 0; i < pScene->mNumCameras;++i)
+    {
+        aiCamera* cam = pScene->mCameras[i];
+        const aiNode* nd = pScene->mRootNode->FindNode(cam->mName);
+        ai_assert(NULL != nd);
 
-	// --- we need to keep all cameras and lights
-	for (unsigned int i = 0; i < pScene->mNumCameras; ++i) {
-		aiCamera *cam = pScene->mCameras[i];
-		const aiNode *nd = pScene->mRootNode->FindNode(cam->mName);
-		ai_assert(NULL != nd);
+        // multiply all properties of the camera with the absolute
+        // transformation of the corresponding node
+        cam->mPosition = nd->mTransformation * cam->mPosition;
+        cam->mLookAt   = aiMatrix3x3( nd->mTransformation ) * cam->mLookAt;
+        cam->mUp       = aiMatrix3x3( nd->mTransformation ) * cam->mUp;
+    }
 
-		// multiply all properties of the camera with the absolute
-		// transformation of the corresponding node
-		cam->mPosition = nd->mTransformation * cam->mPosition;
-		cam->mLookAt = aiMatrix3x3(nd->mTransformation) * cam->mLookAt;
-		cam->mUp = aiMatrix3x3(nd->mTransformation) * cam->mUp;
-	}
+    for (unsigned int i = 0; i < pScene->mNumLights;++i)
+    {
+        aiLight* l = pScene->mLights[i];
+        const aiNode* nd = pScene->mRootNode->FindNode(l->mName);
+        ai_assert(NULL != nd);
 
-	for (unsigned int i = 0; i < pScene->mNumLights; ++i) {
-		aiLight *l = pScene->mLights[i];
-		const aiNode *nd = pScene->mRootNode->FindNode(l->mName);
-		ai_assert(NULL != nd);
+        // multiply all properties of the camera with the absolute
+        // transformation of the corresponding node
+        l->mPosition   = nd->mTransformation * l->mPosition;
+        l->mDirection  = aiMatrix3x3( nd->mTransformation ) * l->mDirection;
+        l->mUp         = aiMatrix3x3( nd->mTransformation ) * l->mUp;
+    }
 
-		// multiply all properties of the camera with the absolute
-		// transformation of the corresponding node
-		l->mPosition = nd->mTransformation * l->mPosition;
-		l->mDirection = aiMatrix3x3(nd->mTransformation) * l->mDirection;
-		l->mUp = aiMatrix3x3(nd->mTransformation) * l->mUp;
-	}
+    if( !configKeepHierarchy ) {
 
-	if (!configKeepHierarchy) {
+        // now delete all nodes in the scene and build a new
+        // flat node graph with a root node and some level 1 children
+        aiNode* newRoot = new aiNode();
+        newRoot->mName = pScene->mRootNode->mName;
+        delete pScene->mRootNode;
+        pScene->mRootNode = newRoot;
 
-		// now delete all nodes in the scene and build a new
-		// flat node graph with a root node and some level 1 children
-		aiNode *newRoot = new aiNode();
-		newRoot->mName = pScene->mRootNode->mName;
-		delete pScene->mRootNode;
-		pScene->mRootNode = newRoot;
+        if (1 == pScene->mNumMeshes && !pScene->mNumLights && !pScene->mNumCameras)
+        {
+            pScene->mRootNode->mNumMeshes = 1;
+            pScene->mRootNode->mMeshes = new unsigned int[1];
+            pScene->mRootNode->mMeshes[0] = 0;
+        }
+        else
+        {
+            pScene->mRootNode->mNumChildren = pScene->mNumMeshes+pScene->mNumLights+pScene->mNumCameras;
+            aiNode** nodes = pScene->mRootNode->mChildren = new aiNode*[pScene->mRootNode->mNumChildren];
 
-		if (1 == pScene->mNumMeshes && !pScene->mNumLights && !pScene->mNumCameras) {
-			pScene->mRootNode->mNumMeshes = 1;
-			pScene->mRootNode->mMeshes = new unsigned int[1];
-			pScene->mRootNode->mMeshes[0] = 0;
-		} else {
-			pScene->mRootNode->mNumChildren = pScene->mNumMeshes + pScene->mNumLights + pScene->mNumCameras;
-			aiNode **nodes = pScene->mRootNode->mChildren = new aiNode *[pScene->mRootNode->mNumChildren];
+            // generate mesh nodes
+            for (unsigned int i = 0; i < pScene->mNumMeshes;++i,++nodes)
+            {
+                aiNode* pcNode = new aiNode();
+                *nodes = pcNode;
+                pcNode->mParent = pScene->mRootNode;
+                pcNode->mName = pScene->mMeshes[i]->mName;
 
-			// generate mesh nodes
-			for (unsigned int i = 0; i < pScene->mNumMeshes; ++i, ++nodes) {
-				aiNode *pcNode = new aiNode();
-				*nodes = pcNode;
-				pcNode->mParent = pScene->mRootNode;
-				pcNode->mName = pScene->mMeshes[i]->mName;
+                // setup mesh indices
+                pcNode->mNumMeshes = 1;
+                pcNode->mMeshes = new unsigned int[1];
+                pcNode->mMeshes[0] = i;
+            }
+            // generate light nodes
+            for (unsigned int i = 0; i < pScene->mNumLights;++i,++nodes)
+            {
+                aiNode* pcNode = new aiNode();
+                *nodes = pcNode;
+                pcNode->mParent = pScene->mRootNode;
+                pcNode->mName.length = ai_snprintf(pcNode->mName.data, MAXLEN, "light_%u",i);
+                pScene->mLights[i]->mName = pcNode->mName;
+            }
+            // generate camera nodes
+            for (unsigned int i = 0; i < pScene->mNumCameras;++i,++nodes)
+            {
+                aiNode* pcNode = new aiNode();
+                *nodes = pcNode;
+                pcNode->mParent = pScene->mRootNode;
+                pcNode->mName.length = ::ai_snprintf(pcNode->mName.data,MAXLEN,"cam_%u",i);
+                pScene->mCameras[i]->mName = pcNode->mName;
+            }
+        }
+    }
+    else {
+        // ... and finally set the transformation matrix of all nodes to identity
+        MakeIdentityTransform(pScene->mRootNode);
+    }
 
-				// setup mesh indices
-				pcNode->mNumMeshes = 1;
-				pcNode->mMeshes = new unsigned int[1];
-				pcNode->mMeshes[0] = i;
-			}
-			// generate light nodes
-			for (unsigned int i = 0; i < pScene->mNumLights; ++i, ++nodes) {
-				aiNode *pcNode = new aiNode();
-				*nodes = pcNode;
-				pcNode->mParent = pScene->mRootNode;
-				pcNode->mName.length = ai_snprintf(pcNode->mName.data, MAXLEN, "light_%u", i);
-				pScene->mLights[i]->mName = pcNode->mName;
-			}
-			// generate camera nodes
-			for (unsigned int i = 0; i < pScene->mNumCameras; ++i, ++nodes) {
-				aiNode *pcNode = new aiNode();
-				*nodes = pcNode;
-				pcNode->mParent = pScene->mRootNode;
-				pcNode->mName.length = ::ai_snprintf(pcNode->mName.data, MAXLEN, "cam_%u", i);
-				pScene->mCameras[i]->mName = pcNode->mName;
-			}
-		}
-	} else {
-		// ... and finally set the transformation matrix of all nodes to identity
-		MakeIdentityTransform(pScene->mRootNode);
-	}
+    if (configNormalize) {
+        // compute the boundary of all meshes
+        aiVector3D min,max;
+        MinMaxChooser<aiVector3D> ()(min,max);
 
-	if (configNormalize) {
-		// compute the boundary of all meshes
-		aiVector3D min, max;
-		MinMaxChooser<aiVector3D>()(min, max);
+        for (unsigned int a = 0; a <  pScene->mNumMeshes; ++a) {
+            aiMesh* m = pScene->mMeshes[a];
+            for (unsigned int i = 0; i < m->mNumVertices;++i) {
+                min = std::min(m->mVertices[i],min);
+                max = std::max(m->mVertices[i],max);
+            }
+        }
 
-		for (unsigned int a = 0; a < pScene->mNumMeshes; ++a) {
-			aiMesh *m = pScene->mMeshes[a];
-			for (unsigned int i = 0; i < m->mNumVertices; ++i) {
-				min = std::min(m->mVertices[i], min);
-				max = std::max(m->mVertices[i], max);
-			}
-		}
+        // find the dominant axis
+        aiVector3D d = max-min;
+        const ai_real div = std::max(d.x,std::max(d.y,d.z))*ai_real( 0.5);
 
-		// find the dominant axis
-		aiVector3D d = max - min;
-		const ai_real div = std::max(d.x, std::max(d.y, d.z)) * ai_real(0.5);
+        d = min + d * (ai_real)0.5;
+        for (unsigned int a = 0; a <  pScene->mNumMeshes; ++a) {
+            aiMesh* m = pScene->mMeshes[a];
+            for (unsigned int i = 0; i < m->mNumVertices;++i) {
+                m->mVertices[i] = (m->mVertices[i]-d)/div;
+            }
+        }
+    }
 
-		d = min + d * (ai_real)0.5;
-		for (unsigned int a = 0; a < pScene->mNumMeshes; ++a) {
-			aiMesh *m = pScene->mMeshes[a];
-			for (unsigned int i = 0; i < m->mNumVertices; ++i) {
-				m->mVertices[i] = (m->mVertices[i] - d) / div;
-			}
-		}
-	}
+    // print statistics
+    if (!DefaultLogger::isNullLogger()) {
+        ASSIMP_LOG_DEBUG("PretransformVerticesProcess finished");
 
-	// print statistics
-	if (!DefaultLogger::isNullLogger()) {
-		ASSIMP_LOG_DEBUG("PretransformVerticesProcess finished");
-
-		ASSIMP_LOG_INFO_F("Removed ", iOldNodes, " nodes and ", iOldAnimationChannels, " animation channels (",
-				CountNodes(pScene->mRootNode), " output nodes)");
-		ASSIMP_LOG_INFO_F("Kept ", pScene->mNumLights, " lights and ", pScene->mNumCameras, " cameras.");
-		ASSIMP_LOG_INFO_F("Moved ", iOldMeshes, " meshes to WCS (number of output meshes: ", pScene->mNumMeshes, ")");
-	}
+        ASSIMP_LOG_INFO_F("Removed ", iOldNodes, " nodes and ", iOldAnimationChannels, " animation channels (", 
+            CountNodes(pScene->mRootNode) ," output nodes)" );
+        ASSIMP_LOG_INFO_F("Kept ", pScene->mNumLights, " lights and ", pScene->mNumCameras, " cameras." );
+        ASSIMP_LOG_INFO_F("Moved ", iOldMeshes, " meshes to WCS (number of output meshes: ", pScene->mNumMeshes, ")");
+    }
 }
diff --git a/Engine/lib/assimp/code/PostProcessing/PretransformVertices.h b/Engine/lib/assimp/code/PostProcessing/PretransformVertices.h
index 4a958def4..b2982951e 100644
--- a/Engine/lib/assimp/code/PostProcessing/PretransformVertices.h
+++ b/Engine/lib/assimp/code/PostProcessing/PretransformVertices.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -59,7 +59,7 @@ struct aiNode;
 
 class PretransformVerticesTest;
 
-namespace Assimp {
+namespace Assimp    {
 
 // ---------------------------------------------------------------------------
 /** The PretransformVertices pre-transforms all vertices in the node tree
@@ -68,97 +68,97 @@ namespace Assimp {
 */
 class ASSIMP_API PretransformVertices : public BaseProcess {
 public:
-	PretransformVertices();
-	~PretransformVertices();
+    PretransformVertices ();
+    ~PretransformVertices ();
 
-	// -------------------------------------------------------------------
-	// Check whether step is active
-	bool IsActive(unsigned int pFlags) const override;
+    // -------------------------------------------------------------------
+    // Check whether step is active
+    bool IsActive( unsigned int pFlags) const;
 
-	// -------------------------------------------------------------------
-	// Execute step on a given scene
-	void Execute(aiScene *pScene) override;
+    // -------------------------------------------------------------------
+    // Execute step on a given scene
+    void Execute( aiScene* pScene);
 
-	// -------------------------------------------------------------------
-	// Setup import settings
-	void SetupProperties(const Importer *pImp) override;
+    // -------------------------------------------------------------------
+    // Setup import settings
+    void SetupProperties(const Importer* pImp);
 
-	// -------------------------------------------------------------------
-	/** @brief Toggle the 'keep hierarchy' option
+    // -------------------------------------------------------------------
+    /** @brief Toggle the 'keep hierarchy' option
      *  @param keep    true for keep configuration.
      */
-	void KeepHierarchy(bool keep) {
-		configKeepHierarchy = keep;
-	}
+    void KeepHierarchy(bool keep) {
+        configKeepHierarchy = keep;
+    }
 
-	// -------------------------------------------------------------------
-	/** @brief Check whether 'keep hierarchy' is currently enabled.
+    // -------------------------------------------------------------------
+    /** @brief Check whether 'keep hierarchy' is currently enabled.
      *  @return ...
      */
-	bool IsHierarchyKept() const {
-		return configKeepHierarchy;
-	}
+    bool IsHierarchyKept() const {
+        return configKeepHierarchy;
+    }
 
 private:
-	// -------------------------------------------------------------------
-	// Count the number of nodes
-	unsigned int CountNodes(const aiNode *pcNode) const;
+    // -------------------------------------------------------------------
+    // Count the number of nodes
+    unsigned int CountNodes( aiNode* pcNode );
 
-	// -------------------------------------------------------------------
-	// Get a bitwise combination identifying the vertex format of a mesh
-	unsigned int GetMeshVFormat(aiMesh *pcMesh) const;
+    // -------------------------------------------------------------------
+    // Get a bitwise combination identifying the vertex format of a mesh
+    unsigned int GetMeshVFormat(aiMesh* pcMesh);
 
-	// -------------------------------------------------------------------
-	// Count the number of vertices in the whole scene and a given
-	// material index
-	void CountVerticesAndFaces(const aiScene *pcScene, const aiNode *pcNode,
-			unsigned int iMat,
-			unsigned int iVFormat,
-			unsigned int *piFaces,
-			unsigned int *piVertices) const;
+    // -------------------------------------------------------------------
+    // Count the number of vertices in the whole scene and a given
+    // material index
+    void CountVerticesAndFaces( aiScene* pcScene, aiNode* pcNode,
+        unsigned int iMat,
+        unsigned int iVFormat,
+        unsigned int* piFaces,
+        unsigned int* piVertices);
 
-	// -------------------------------------------------------------------
-	// Collect vertex/face data
-	void CollectData(const aiScene *pcScene, const aiNode *pcNode,
-			unsigned int iMat,
-			unsigned int iVFormat,
-			aiMesh *pcMeshOut,
-			unsigned int aiCurrent[2],
-			unsigned int *num_refs) const;
+    // -------------------------------------------------------------------
+    // Collect vertex/face data
+    void CollectData( aiScene* pcScene, aiNode* pcNode,
+        unsigned int iMat,
+        unsigned int iVFormat,
+        aiMesh* pcMeshOut,
+        unsigned int aiCurrent[2],
+        unsigned int* num_refs);
 
-	// -------------------------------------------------------------------
-	// Get a list of all vertex formats that occur for a given material
-	// The output list contains duplicate elements
-	void GetVFormatList(const aiScene *pcScene, unsigned int iMat,
-			std::list<unsigned int> &aiOut) const;
+    // -------------------------------------------------------------------
+    // Get a list of all vertex formats that occur for a given material
+    // The output list contains duplicate elements
+    void GetVFormatList( aiScene* pcScene, unsigned int iMat,
+        std::list<unsigned int>& aiOut);
 
-	// -------------------------------------------------------------------
-	// Compute the absolute transformation matrices of each node
-	void ComputeAbsoluteTransform(aiNode *pcNode);
+    // -------------------------------------------------------------------
+    // Compute the absolute transformation matrices of each node
+    void ComputeAbsoluteTransform( aiNode* pcNode );
 
-	// -------------------------------------------------------------------
-	// Simple routine to build meshes in worldspace, no further optimization
-	void BuildWCSMeshes(std::vector<aiMesh *> &out, aiMesh **in,
-			unsigned int numIn, aiNode *node) const;
+    // -------------------------------------------------------------------
+    // Simple routine to build meshes in worldspace, no further optimization
+    void BuildWCSMeshes(std::vector<aiMesh*>& out, aiMesh** in,
+        unsigned int numIn, aiNode* node);
 
-	// -------------------------------------------------------------------
-	// Apply the node transformation to a mesh
-	void ApplyTransform(aiMesh *mesh, const aiMatrix4x4 &mat) const;
+    // -------------------------------------------------------------------
+    // Apply the node transformation to a mesh
+    void ApplyTransform(aiMesh* mesh, const aiMatrix4x4& mat);
 
-	// -------------------------------------------------------------------
-	// Reset transformation matrices to identity
-	void MakeIdentityTransform(aiNode *nd) const;
+    // -------------------------------------------------------------------
+    // Reset transformation matrices to identity
+    void MakeIdentityTransform(aiNode* nd);
 
-	// -------------------------------------------------------------------
-	// Build reference counters for all meshes
-	void BuildMeshRefCountArray(const aiNode *nd, unsigned int *refs) const;
+    // -------------------------------------------------------------------
+    // Build reference counters for all meshes
+    void BuildMeshRefCountArray(aiNode* nd, unsigned int * refs);
 
-	//! Configuration option: keep scene hierarchy as long as possible
-	bool configKeepHierarchy;
-	bool configNormalize;
-	bool configTransform;
-	aiMatrix4x4 configTransformation;
-	bool mConfigPointCloud;
+    //! Configuration option: keep scene hierarchy as long as possible
+    bool configKeepHierarchy;
+    bool configNormalize;
+    bool configTransform;
+    aiMatrix4x4 configTransformation;
+    bool mConfigPointCloud;
 };
 
 } // end of namespace Assimp
diff --git a/Engine/lib/assimp/code/PostProcessing/ProcessHelper.cpp b/Engine/lib/assimp/code/PostProcessing/ProcessHelper.cpp
index 123986438..59869fdff 100644
--- a/Engine/lib/assimp/code/PostProcessing/ProcessHelper.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/ProcessHelper.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -230,6 +230,46 @@ VertexWeightTable* ComputeVertexBoneWeightTable(const aiMesh* pMesh)
     return avPerVertexWeights;
 }
 
+
+// -------------------------------------------------------------------------------
+const char* TextureTypeToString(aiTextureType in)
+{
+    switch (in)
+    {
+    case aiTextureType_NONE:
+        return "n/a";
+    case aiTextureType_DIFFUSE:
+        return "Diffuse";
+    case aiTextureType_SPECULAR:
+        return "Specular";
+    case aiTextureType_AMBIENT:
+        return "Ambient";
+    case aiTextureType_EMISSIVE:
+        return "Emissive";
+    case aiTextureType_OPACITY:
+        return "Opacity";
+    case aiTextureType_NORMALS:
+        return "Normals";
+    case aiTextureType_HEIGHT:
+        return "Height";
+    case aiTextureType_SHININESS:
+        return "Shininess";
+    case aiTextureType_DISPLACEMENT:
+        return "Displacement";
+    case aiTextureType_LIGHTMAP:
+        return "Lightmap";
+    case aiTextureType_REFLECTION:
+        return "Reflection";
+    case aiTextureType_UNKNOWN:
+        return "Unknown";
+    default:
+        break;
+    }
+
+    ai_assert(false);
+    return  "BUG";
+}
+
 // -------------------------------------------------------------------------------
 const char* MappingTypeToString(aiTextureMapping in)
 {
diff --git a/Engine/lib/assimp/code/PostProcessing/ProcessHelper.h b/Engine/lib/assimp/code/PostProcessing/ProcessHelper.h
index 5762fbb35..0afcc4142 100644
--- a/Engine/lib/assimp/code/PostProcessing/ProcessHelper.h
+++ b/Engine/lib/assimp/code/PostProcessing/ProcessHelper.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -316,6 +316,12 @@ typedef std::vector <PerVertexWeight> VertexWeightTable;
 // Compute a per-vertex bone weight table
 VertexWeightTable* ComputeVertexBoneWeightTable(const aiMesh* pMesh);
 
+
+// -------------------------------------------------------------------------------
+// Get a string for a given aiTextureType
+const char* TextureTypeToString(aiTextureType in);
+
+
 // -------------------------------------------------------------------------------
 // Get a string for a given aiTextureMapping
 const char* MappingTypeToString(aiTextureMapping in);
diff --git a/Engine/lib/assimp/code/PostProcessing/RemoveRedundantMaterials.cpp b/Engine/lib/assimp/code/PostProcessing/RemoveRedundantMaterials.cpp
index 0c4280410..49ec8f5c4 100644
--- a/Engine/lib/assimp/code/PostProcessing/RemoveRedundantMaterials.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/RemoveRedundantMaterials.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/PostProcessing/RemoveRedundantMaterials.h b/Engine/lib/assimp/code/PostProcessing/RemoveRedundantMaterials.h
index 4b4f346c8..1f32a0abf 100644
--- a/Engine/lib/assimp/code/PostProcessing/RemoveRedundantMaterials.h
+++ b/Engine/lib/assimp/code/PostProcessing/RemoveRedundantMaterials.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/RemoveVCProcess.cpp b/Engine/lib/assimp/code/PostProcessing/RemoveVCProcess.cpp
index 5ff5b55fa..99fd47a3a 100644
--- a/Engine/lib/assimp/code/PostProcessing/RemoveVCProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/RemoveVCProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/PostProcessing/RemoveVCProcess.h b/Engine/lib/assimp/code/PostProcessing/RemoveVCProcess.h
index 458b37ee0..7bb21a833 100644
--- a/Engine/lib/assimp/code/PostProcessing/RemoveVCProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/RemoveVCProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/ScaleProcess.cpp b/Engine/lib/assimp/code/PostProcessing/ScaleProcess.cpp
index 66714928b..ac770c41f 100644
--- a/Engine/lib/assimp/code/PostProcessing/ScaleProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/ScaleProcess.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/ScaleProcess.h b/Engine/lib/assimp/code/PostProcessing/ScaleProcess.h
index 9cc664c6a..468a21673 100644
--- a/Engine/lib/assimp/code/PostProcessing/ScaleProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/ScaleProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/SortByPTypeProcess.cpp b/Engine/lib/assimp/code/PostProcessing/SortByPTypeProcess.cpp
index c1b08c5a7..be8405a17 100644
--- a/Engine/lib/assimp/code/PostProcessing/SortByPTypeProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/SortByPTypeProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/PostProcessing/SortByPTypeProcess.h b/Engine/lib/assimp/code/PostProcessing/SortByPTypeProcess.h
index 5135139ed..1d7ccfc15 100644
--- a/Engine/lib/assimp/code/PostProcessing/SortByPTypeProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/SortByPTypeProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/SplitByBoneCountProcess.cpp b/Engine/lib/assimp/code/PostProcessing/SplitByBoneCountProcess.cpp
deleted file mode 100644
index ab7a1fe00..000000000
--- a/Engine/lib/assimp/code/PostProcessing/SplitByBoneCountProcess.cpp
+++ /dev/null
@@ -1,447 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-
-/// @file SplitByBoneCountProcess.cpp
-/// Implementation of the SplitByBoneCount postprocessing step
-
-// internal headers of the post-processing framework
-#include "SplitByBoneCountProcess.h"
-#include <assimp/postprocess.h>
-#include <assimp/DefaultLogger.hpp>
-
-#include <limits>
-#include <assimp/TinyFormatter.h>
-#include <assimp/Exceptional.h>
-
-using namespace Assimp;
-using namespace Assimp::Formatter;
-
-// ------------------------------------------------------------------------------------------------
-// Constructor
-SplitByBoneCountProcess::SplitByBoneCountProcess()
-{
-    // set default, might be overridden by importer config
-    mMaxBoneCount = AI_SBBC_DEFAULT_MAX_BONES;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor
-SplitByBoneCountProcess::~SplitByBoneCountProcess()
-{
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the processing step is present in the given flag.
-bool SplitByBoneCountProcess::IsActive( unsigned int pFlags) const
-{
-    return !!(pFlags & aiProcess_SplitByBoneCount);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Updates internal properties
-void SplitByBoneCountProcess::SetupProperties(const Importer* pImp)
-{
-    mMaxBoneCount = pImp->GetPropertyInteger(AI_CONFIG_PP_SBBC_MAX_BONES,AI_SBBC_DEFAULT_MAX_BONES);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void SplitByBoneCountProcess::Execute( aiScene* pScene)
-{
-    ASSIMP_LOG_DEBUG("SplitByBoneCountProcess begin");
-
-    // early out
-    bool isNecessary = false;
-    for( unsigned int a = 0; a < pScene->mNumMeshes; ++a)
-        if( pScene->mMeshes[a]->mNumBones > mMaxBoneCount )
-        {
-            isNecessary = true;
-            break;
-        }
-
-    if( !isNecessary )
-    {
-        ASSIMP_LOG_DEBUG( format() << "SplitByBoneCountProcess early-out: no meshes with more than " << mMaxBoneCount << " bones." );
-        return;
-    }
-
-    // we need to do something. Let's go.
-    mSubMeshIndices.clear();
-    mSubMeshIndices.resize( pScene->mNumMeshes);
-
-    // build a new array of meshes for the scene
-    std::vector<aiMesh*> meshes;
-
-    for( unsigned int a = 0; a < pScene->mNumMeshes; ++a)
-    {
-        aiMesh* srcMesh = pScene->mMeshes[a];
-
-        std::vector<aiMesh*> newMeshes;
-        SplitMesh( pScene->mMeshes[a], newMeshes);
-
-        // mesh was split
-        if( !newMeshes.empty() )
-        {
-            // store new meshes and indices of the new meshes
-            for( unsigned int b = 0; b < newMeshes.size(); ++b)
-            {
-                mSubMeshIndices[a].push_back( static_cast<unsigned int>(meshes.size()));
-                meshes.push_back( newMeshes[b]);
-            }
-
-            // and destroy the source mesh. It should be completely contained inside the new submeshes
-            delete srcMesh;
-        }
-        else
-        {
-            // Mesh is kept unchanged - store it's new place in the mesh array
-            mSubMeshIndices[a].push_back( static_cast<unsigned int>(meshes.size()));
-            meshes.push_back( srcMesh);
-        }
-    }
-
-    // rebuild the scene's mesh array
-    pScene->mNumMeshes = static_cast<unsigned int>(meshes.size());
-    delete [] pScene->mMeshes;
-    pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];
-    std::copy( meshes.begin(), meshes.end(), pScene->mMeshes);
-
-    // recurse through all nodes and translate the node's mesh indices to fit the new mesh array
-    UpdateNode( pScene->mRootNode);
-
-    ASSIMP_LOG_DEBUG( format() << "SplitByBoneCountProcess end: split " << mSubMeshIndices.size() << " meshes into " << meshes.size() << " submeshes." );
-}
-
-// ------------------------------------------------------------------------------------------------
-// Splits the given mesh by bone count.
-void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh*>& poNewMeshes) const
-{
-    // skip if not necessary
-    if( pMesh->mNumBones <= mMaxBoneCount )
-    {
-        return;
-    }
-
-    // necessary optimisation: build a list of all affecting bones for each vertex
-    // TODO: (thom) maybe add a custom allocator here to avoid allocating tens of thousands of small arrays
-    typedef std::pair<unsigned int, float> BoneWeight;
-    std::vector< std::vector<BoneWeight> > vertexBones( pMesh->mNumVertices);
-    for( unsigned int a = 0; a < pMesh->mNumBones; ++a)
-    {
-        const aiBone* bone = pMesh->mBones[a];
-        for( unsigned int b = 0; b < bone->mNumWeights; ++b)
-        {
-            vertexBones[ bone->mWeights[b].mVertexId ].push_back( BoneWeight( a, bone->mWeights[b].mWeight));
-        }
-    }
-
-    unsigned int numFacesHandled = 0;
-    std::vector<bool> isFaceHandled( pMesh->mNumFaces, false);
-    while( numFacesHandled < pMesh->mNumFaces )
-    {
-        // which bones are used in the current submesh
-        unsigned int numBones = 0;
-        std::vector<bool> isBoneUsed( pMesh->mNumBones, false);
-        // indices of the faces which are going to go into this submesh
-        std::vector<unsigned int> subMeshFaces;
-        subMeshFaces.reserve( pMesh->mNumFaces);
-        // accumulated vertex count of all the faces in this submesh
-        unsigned int numSubMeshVertices = 0;
-        // a small local array of new bones for the current face. State of all used bones for that face
-        // can only be updated AFTER the face is completely analysed. Thanks to imre for the fix.
-        std::vector<unsigned int> newBonesAtCurrentFace;
-
-        // add faces to the new submesh as long as all bones affecting the faces' vertices fit in the limit
-        for( unsigned int a = 0; a < pMesh->mNumFaces; ++a)
-        {
-            // skip if the face is already stored in a submesh
-            if( isFaceHandled[a] )
-            {
-                continue;
-            }
-
-            const aiFace& face = pMesh->mFaces[a];
-            // check every vertex if its bones would still fit into the current submesh
-            for( unsigned int b = 0; b < face.mNumIndices; ++b )
-            {
-                const std::vector<BoneWeight>& vb = vertexBones[face.mIndices[b]];
-                for( unsigned int c = 0; c < vb.size(); ++c)
-                {
-                    unsigned int boneIndex = vb[c].first;
-                    // if the bone is already used in this submesh, it's ok
-                    if( isBoneUsed[boneIndex] )
-                    {
-                        continue;
-                    }
-
-                    // if it's not used, yet, we would need to add it. Store its bone index
-                    if( std::find( newBonesAtCurrentFace.begin(), newBonesAtCurrentFace.end(), boneIndex) == newBonesAtCurrentFace.end() )
-                    {
-                        newBonesAtCurrentFace.push_back( boneIndex);
-                    }
-                }
-            }
-
-            if (newBonesAtCurrentFace.size() > mMaxBoneCount)
-            {
-                throw DeadlyImportError("SplitByBoneCountProcess: Single face requires more bones than specified max bone count!");
-            }
-            // leave out the face if the new bones required for this face don't fit the bone count limit anymore
-            if( numBones + newBonesAtCurrentFace.size() > mMaxBoneCount )
-            {
-                continue;
-            }
-
-            // mark all new bones as necessary
-            while( !newBonesAtCurrentFace.empty() )
-            {
-                unsigned int newIndex = newBonesAtCurrentFace.back();
-                newBonesAtCurrentFace.pop_back(); // this also avoids the deallocation which comes with a clear()
-                if( isBoneUsed[newIndex] )
-                {
-                    continue;
-                }
-
-                isBoneUsed[newIndex] = true;
-                numBones++;
-            }
-
-            // store the face index and the vertex count
-            subMeshFaces.push_back( a);
-            numSubMeshVertices += face.mNumIndices;
-
-            // remember that this face is handled
-            isFaceHandled[a] = true;
-            numFacesHandled++;
-        }
-
-        // create a new mesh to hold this subset of the source mesh
-        aiMesh* newMesh = new aiMesh;
-        if( pMesh->mName.length > 0 )
-        {
-            newMesh->mName.Set( format() << pMesh->mName.data << "_sub" << poNewMeshes.size());
-        }
-        newMesh->mMaterialIndex = pMesh->mMaterialIndex;
-        newMesh->mPrimitiveTypes = pMesh->mPrimitiveTypes;
-        poNewMeshes.push_back( newMesh);
-
-        // create all the arrays for this mesh if the old mesh contained them
-        newMesh->mNumVertices = numSubMeshVertices;
-        newMesh->mNumFaces = static_cast<unsigned int>(subMeshFaces.size());
-        newMesh->mVertices = new aiVector3D[newMesh->mNumVertices];
-        if( pMesh->HasNormals() )
-        {
-            newMesh->mNormals = new aiVector3D[newMesh->mNumVertices];
-        }
-        if( pMesh->HasTangentsAndBitangents() )
-        {
-            newMesh->mTangents = new aiVector3D[newMesh->mNumVertices];
-            newMesh->mBitangents = new aiVector3D[newMesh->mNumVertices];
-        }
-        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a )
-        {
-            if( pMesh->HasTextureCoords( a) )
-            {
-                newMesh->mTextureCoords[a] = new aiVector3D[newMesh->mNumVertices];
-            }
-            newMesh->mNumUVComponents[a] = pMesh->mNumUVComponents[a];
-        }
-        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a )
-        {
-            if( pMesh->HasVertexColors( a) )
-            {
-                newMesh->mColors[a] = new aiColor4D[newMesh->mNumVertices];
-            }
-        }
-
-        // and copy over the data, generating faces with linear indices along the way
-        newMesh->mFaces = new aiFace[subMeshFaces.size()];
-        unsigned int nvi = 0; // next vertex index
-        std::vector<unsigned int> previousVertexIndices( numSubMeshVertices, std::numeric_limits<unsigned int>::max()); // per new vertex: its index in the source mesh
-        for( unsigned int a = 0; a < subMeshFaces.size(); ++a )
-        {
-            const aiFace& srcFace = pMesh->mFaces[subMeshFaces[a]];
-            aiFace& dstFace = newMesh->mFaces[a];
-            dstFace.mNumIndices = srcFace.mNumIndices;
-            dstFace.mIndices = new unsigned int[dstFace.mNumIndices];
-
-            // accumulate linearly all the vertices of the source face
-            for( unsigned int b = 0; b < dstFace.mNumIndices; ++b )
-            {
-                unsigned int srcIndex = srcFace.mIndices[b];
-                dstFace.mIndices[b] = nvi;
-                previousVertexIndices[nvi] = srcIndex;
-
-                newMesh->mVertices[nvi] = pMesh->mVertices[srcIndex];
-                if( pMesh->HasNormals() )
-                {
-                    newMesh->mNormals[nvi] = pMesh->mNormals[srcIndex];
-                }
-                if( pMesh->HasTangentsAndBitangents() )
-                {
-                    newMesh->mTangents[nvi] = pMesh->mTangents[srcIndex];
-                    newMesh->mBitangents[nvi] = pMesh->mBitangents[srcIndex];
-                }
-                for( unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++c )
-                {
-                    if( pMesh->HasTextureCoords( c) )
-                    {
-                        newMesh->mTextureCoords[c][nvi] = pMesh->mTextureCoords[c][srcIndex];
-                    }
-                }
-                for( unsigned int c = 0; c < AI_MAX_NUMBER_OF_COLOR_SETS; ++c )
-                {
-                    if( pMesh->HasVertexColors( c) )
-                    {
-                        newMesh->mColors[c][nvi] = pMesh->mColors[c][srcIndex];
-                    }
-                }
-
-                nvi++;
-            }
-        }
-
-        ai_assert( nvi == numSubMeshVertices );
-
-        // Create the bones for the new submesh: first create the bone array
-        newMesh->mNumBones = 0;
-        newMesh->mBones = new aiBone*[numBones];
-
-        std::vector<unsigned int> mappedBoneIndex( pMesh->mNumBones, std::numeric_limits<unsigned int>::max());
-        for( unsigned int a = 0; a < pMesh->mNumBones; ++a )
-        {
-            if( !isBoneUsed[a] )
-            {
-                continue;
-            }
-
-            // create the new bone
-            const aiBone* srcBone = pMesh->mBones[a];
-            aiBone* dstBone = new aiBone;
-            mappedBoneIndex[a] = newMesh->mNumBones;
-            newMesh->mBones[newMesh->mNumBones++] = dstBone;
-            dstBone->mName = srcBone->mName;
-            dstBone->mOffsetMatrix = srcBone->mOffsetMatrix;
-            dstBone->mNumWeights = 0;
-        }
-
-        ai_assert( newMesh->mNumBones == numBones );
-
-        // iterate over all new vertices and count which bones affected its old vertex in the source mesh
-        for( unsigned int a = 0; a < numSubMeshVertices; ++a )
-        {
-            unsigned int oldIndex = previousVertexIndices[a];
-            const std::vector<BoneWeight>& bonesOnThisVertex = vertexBones[oldIndex];
-
-            for( unsigned int b = 0; b < bonesOnThisVertex.size(); ++b )
-            {
-                unsigned int newBoneIndex = mappedBoneIndex[ bonesOnThisVertex[b].first ];
-                if( newBoneIndex != std::numeric_limits<unsigned int>::max() )
-                {
-                    newMesh->mBones[newBoneIndex]->mNumWeights++;
-                }
-            }
-        }
-
-        // allocate all bone weight arrays accordingly
-        for( unsigned int a = 0; a < newMesh->mNumBones; ++a )
-        {
-            aiBone* bone = newMesh->mBones[a];
-            ai_assert( bone->mNumWeights > 0 );
-            bone->mWeights = new aiVertexWeight[bone->mNumWeights];
-            bone->mNumWeights = 0; // for counting up in the next step
-        }
-
-        // now copy all the bone vertex weights for all the vertices which made it into the new submesh
-        for( unsigned int a = 0; a < numSubMeshVertices; ++a)
-        {
-            // find the source vertex for it in the source mesh
-            unsigned int previousIndex = previousVertexIndices[a];
-            // these bones were affecting it
-            const std::vector<BoneWeight>& bonesOnThisVertex = vertexBones[previousIndex];
-            // all of the bones affecting it should be present in the new submesh, or else
-            // the face it comprises shouldn't be present
-            for( unsigned int b = 0; b < bonesOnThisVertex.size(); ++b)
-            {
-                unsigned int newBoneIndex = mappedBoneIndex[ bonesOnThisVertex[b].first ];
-                ai_assert( newBoneIndex != std::numeric_limits<unsigned int>::max() );
-                aiVertexWeight* dstWeight = newMesh->mBones[newBoneIndex]->mWeights + newMesh->mBones[newBoneIndex]->mNumWeights;
-                newMesh->mBones[newBoneIndex]->mNumWeights++;
-
-                dstWeight->mVertexId = a;
-                dstWeight->mWeight = bonesOnThisVertex[b].second;
-            }
-        }
-
-        // I have the strange feeling that this will break apart at some point in time...
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Recursively updates the node's mesh list to account for the changed mesh list
-void SplitByBoneCountProcess::UpdateNode( aiNode* pNode) const
-{
-    // rebuild the node's mesh index list
-    if( pNode->mNumMeshes > 0 )
-    {
-        std::vector<unsigned int> newMeshList;
-        for( unsigned int a = 0; a < pNode->mNumMeshes; ++a)
-        {
-            unsigned int srcIndex = pNode->mMeshes[a];
-            const std::vector<unsigned int>& replaceMeshes = mSubMeshIndices[srcIndex];
-            newMeshList.insert( newMeshList.end(), replaceMeshes.begin(), replaceMeshes.end());
-        }
-
-        delete [] pNode->mMeshes;
-        pNode->mNumMeshes = static_cast<unsigned int>(newMeshList.size());
-        pNode->mMeshes = new unsigned int[pNode->mNumMeshes];
-        std::copy( newMeshList.begin(), newMeshList.end(), pNode->mMeshes);
-    }
-
-    // do that also recursively for all children
-    for( unsigned int a = 0; a < pNode->mNumChildren; ++a )
-    {
-        UpdateNode( pNode->mChildren[a]);
-    }
-}
diff --git a/Engine/lib/assimp/code/PostProcessing/SplitByBoneCountProcess.h b/Engine/lib/assimp/code/PostProcessing/SplitByBoneCountProcess.h
deleted file mode 100644
index b99830fde..000000000
--- a/Engine/lib/assimp/code/PostProcessing/SplitByBoneCountProcess.h
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/// @file SplitByBoneCountProcess.h
-/// Defines a post processing step to split meshes with many bones into submeshes
-#ifndef AI_SPLITBYBONECOUNTPROCESS_H_INC
-#define AI_SPLITBYBONECOUNTPROCESS_H_INC
-
-#include <vector>
-#include "Common/BaseProcess.h"
-
-#include <assimp/mesh.h>
-#include <assimp/scene.h>
-
-namespace Assimp
-{
-
-
-/** Postprocessing filter to split meshes with many bones into submeshes
- * so that each submesh has a certain max bone count.
- *
- * Applied BEFORE the JoinVertices-Step occurs.
- * Returns NON-UNIQUE vertices, splits by bone count.
-*/
-class SplitByBoneCountProcess : public BaseProcess
-{
-public:
-
-    SplitByBoneCountProcess();
-    ~SplitByBoneCountProcess();
-
-public:
-    /** Returns whether the processing step is present in the given flag.
-    * @param pFlags The processing flags the importer was called with. A
-    *   bitwise combination of #aiPostProcessSteps.
-    * @return true if the process is present in this flag fields,
-    *   false if not.
-    */
-    bool IsActive( unsigned int pFlags) const;
-
-    /** Called prior to ExecuteOnScene().
-    * The function is a request to the process to update its configuration
-    * basing on the Importer's configuration property list.
-    */
-    virtual void SetupProperties(const Importer* pImp);
-
-protected:
-    /** Executes the post processing step on the given imported data.
-    * At the moment a process is not supposed to fail.
-    * @param pScene The imported data to work at.
-    */
-    void Execute( aiScene* pScene);
-
-    /// Splits the given mesh by bone count.
-    /// @param pMesh the Mesh to split. Is not changed at all, but might be superfluous in case it was split.
-    /// @param poNewMeshes Array of submeshes created in the process. Empty if splitting was not necessary.
-    void SplitMesh( const aiMesh* pMesh, std::vector<aiMesh*>& poNewMeshes) const;
-
-    /// Recursively updates the node's mesh list to account for the changed mesh list
-    void UpdateNode( aiNode* pNode) const;
-
-public:
-    /// Max bone count. Splitting occurs if a mesh has more than that number of bones.
-    size_t mMaxBoneCount;
-
-    /// Per mesh index: Array of indices of the new submeshes.
-    std::vector< std::vector<unsigned int> > mSubMeshIndices;
-};
-
-} // end of namespace Assimp
-
-#endif // !!AI_SPLITBYBONECOUNTPROCESS_H_INC
diff --git a/Engine/lib/assimp/code/PostProcessing/SplitLargeMeshes.cpp b/Engine/lib/assimp/code/PostProcessing/SplitLargeMeshes.cpp
index 70960f4a8..1797b28d5 100644
--- a/Engine/lib/assimp/code/PostProcessing/SplitLargeMeshes.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/SplitLargeMeshes.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/SplitLargeMeshes.h b/Engine/lib/assimp/code/PostProcessing/SplitLargeMeshes.h
index fa6f77b2d..3f90576ea 100644
--- a/Engine/lib/assimp/code/PostProcessing/SplitLargeMeshes.h
+++ b/Engine/lib/assimp/code/PostProcessing/SplitLargeMeshes.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
diff --git a/Engine/lib/assimp/code/PostProcessing/TextureTransform.cpp b/Engine/lib/assimp/code/PostProcessing/TextureTransform.cpp
index bf60e2970..8ae2ba721 100644
--- a/Engine/lib/assimp/code/PostProcessing/TextureTransform.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/TextureTransform.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -92,8 +92,9 @@ void TextureTransformStep::PreProcessUVTransform(STransformVecInfo& info)
      *  are applied is - as always - scaling, rotation, translation.
      */
 
-	int rounded;
-	char szTemp[512];
+    char szTemp[512];
+    int rounded = 0;
+
 
     /* Optimize the rotation angle. That's slightly difficult as
      * we have an inprecise floating-point number (when comparing
@@ -184,6 +185,7 @@ void TextureTransformStep::PreProcessUVTransform(STransformVecInfo& info)
             info.mTranslation.y = out;
         }
     }
+    return;
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -426,7 +428,7 @@ void TextureTransformStep::Execute( aiScene* pScene)
         // at the end of the list
         bool ref[AI_MAX_NUMBER_OF_TEXTURECOORDS];
         for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n)
-            ref[n] = !mesh->mTextureCoords[n];
+            ref[n] = (!mesh->mTextureCoords[n] ? true : false);
 
         for (it = trafo.begin();it != trafo.end(); ++it)
             ref[(*it).uvIndex] = true;
diff --git a/Engine/lib/assimp/code/PostProcessing/TextureTransform.h b/Engine/lib/assimp/code/PostProcessing/TextureTransform.h
index 2f6fc3edc..2a5d623d7 100644
--- a/Engine/lib/assimp/code/PostProcessing/TextureTransform.h
+++ b/Engine/lib/assimp/code/PostProcessing/TextureTransform.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/TriangulateProcess.cpp b/Engine/lib/assimp/code/PostProcessing/TriangulateProcess.cpp
index 64cc63bbd..1040836bb 100644
--- a/Engine/lib/assimp/code/PostProcessing/TriangulateProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/TriangulateProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
diff --git a/Engine/lib/assimp/code/PostProcessing/TriangulateProcess.h b/Engine/lib/assimp/code/PostProcessing/TriangulateProcess.h
index 388952eb5..916b5103d 100644
--- a/Engine/lib/assimp/code/PostProcessing/TriangulateProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/TriangulateProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/ValidateDataStructure.cpp b/Engine/lib/assimp/code/PostProcessing/ValidateDataStructure.cpp
index 6212bfb69..501f7a9b2 100644
--- a/Engine/lib/assimp/code/PostProcessing/ValidateDataStructure.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/ValidateDataStructure.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -538,17 +538,13 @@ void ValidateDSProcess::Validate( const aiAnimation* pAnimation)
 {
     Validate(&pAnimation->mName);
 
-    // validate all animations
-    if (pAnimation->mNumChannels || pAnimation->mNumMorphMeshChannels)
+    // validate all materials
+    if (pAnimation->mNumChannels)
     {
-        if (!pAnimation->mChannels && pAnimation->mNumChannels) {
+        if (!pAnimation->mChannels) {
             ReportError("aiAnimation::mChannels is NULL (aiAnimation::mNumChannels is %i)",
                 pAnimation->mNumChannels);
         }
-        if (!pAnimation->mMorphMeshChannels && pAnimation->mNumMorphMeshChannels) {
-            ReportError("aiAnimation::mMorphMeshChannels is NULL (aiAnimation::mNumMorphMeshChannels is %i)",
-                pAnimation->mNumMorphMeshChannels);
-        }
         for (unsigned int i = 0; i < pAnimation->mNumChannels;++i)
         {
             if (!pAnimation->mChannels[i])
@@ -558,15 +554,6 @@ void ValidateDSProcess::Validate( const aiAnimation* pAnimation)
             }
             Validate(pAnimation, pAnimation->mChannels[i]);
         }
-        for (unsigned int i = 0; i < pAnimation->mNumMorphMeshChannels;++i)
-        {
-            if (!pAnimation->mMorphMeshChannels[i])
-            {
-                ReportError("aiAnimation::mMorphMeshChannels[%i] is NULL (aiAnimation::mNumMorphMeshChannels is %i)",
-                    i, pAnimation->mNumMorphMeshChannels);
-            }
-            Validate(pAnimation, pAnimation->mMorphMeshChannels[i]);
-        }
     }
     else {
     	ReportError("aiAnimation::mNumChannels is 0. At least one node animation channel must be there.");
@@ -603,18 +590,15 @@ void ValidateDSProcess::SearchForInvalidTextures(const aiMaterial* pMaterial,
         ReportError("%s #%i is set, but there are only %i %s textures",
             szType,iIndex,iNumIndices,szType);
     }
-	if (!iNumIndices) {
-		return;
-	}
+    if (!iNumIndices)return;
     std::vector<aiTextureMapping> mappings(iNumIndices);
 
     // Now check whether all UV indices are valid ...
     bool bNoSpecified = true;
-    for (unsigned int i = 0; i < pMaterial->mNumProperties;++i) {
+    for (unsigned int i = 0; i < pMaterial->mNumProperties;++i)
+    {
         aiMaterialProperty* prop = pMaterial->mProperties[i];
-		if (prop->mSemantic != type) {
-			continue;
-		}
+        if (prop->mSemantic != type)continue;
 
         if ((int)prop->mIndex >= iNumIndices)
         {
@@ -637,7 +621,7 @@ void ValidateDSProcess::SearchForInvalidTextures(const aiMaterial* pMaterial,
                 ReportError("Material property %s%i is expected to be 5 floats large (size is %i)",
                     prop->mKey.data,prop->mIndex, prop->mDataLength);
             }
-			//mappings[prop->mIndex] = ((aiUVTransform*)prop->mData);
+            mappings[prop->mIndex] = *((aiTextureMapping*)prop->mData);
         }
         else if (!::strcmp(prop->mKey.data,"$tex.uvwsrc")) {
             if (aiPTI_Integer != prop->mType || sizeof(int) > prop->mDataLength)
@@ -777,12 +761,6 @@ void ValidateDSProcess::Validate( const aiMaterial* pMaterial)
     SearchForInvalidTextures(pMaterial,aiTextureType_DISPLACEMENT);
     SearchForInvalidTextures(pMaterial,aiTextureType_LIGHTMAP);
     SearchForInvalidTextures(pMaterial,aiTextureType_REFLECTION);
-    SearchForInvalidTextures(pMaterial,aiTextureType_BASE_COLOR);
-    SearchForInvalidTextures(pMaterial,aiTextureType_NORMAL_CAMERA);
-    SearchForInvalidTextures(pMaterial,aiTextureType_EMISSION_COLOR);
-    SearchForInvalidTextures(pMaterial,aiTextureType_METALNESS);
-    SearchForInvalidTextures(pMaterial,aiTextureType_DIFFUSE_ROUGHNESS);
-    SearchForInvalidTextures(pMaterial,aiTextureType_AMBIENT_OCCLUSION);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -804,7 +782,7 @@ void ValidateDSProcess::Validate( const aiTexture* pTexture)
         if (!pTexture->mWidth) {
             ReportError("aiTexture::mWidth is zero (compressed texture)");
         }
-        if ('\0' != pTexture->achFormatHint[HINTMAXTEXTURELEN - 1]) {
+        if ('\0' != pTexture->achFormatHint[3]) {
             ReportWarning("aiTexture::achFormatHint must be zero-terminated");
         }
         else if ('.'  == pTexture->achFormatHint[0])    {
@@ -925,48 +903,6 @@ void ValidateDSProcess::Validate( const aiAnimation* pAnimation,
     }
 }
 
-void ValidateDSProcess::Validate( const aiAnimation* pAnimation,
-     const aiMeshMorphAnim* pMeshMorphAnim)
-{
-    Validate(&pMeshMorphAnim->mName);
-
-    if (!pMeshMorphAnim->mNumKeys) {
-        ReportError("Empty mesh morph animation channel");
-    }
-
-    // otherwise check whether one of the keys exceeds the total duration of the animation
-    if (pMeshMorphAnim->mNumKeys)
-    {
-        if (!pMeshMorphAnim->mKeys)
-        {
-            ReportError("aiMeshMorphAnim::mKeys is NULL (aiMeshMorphAnim::mNumKeys is %i)",
-                pMeshMorphAnim->mNumKeys);
-        }
-        double dLast = -10e10;
-        for (unsigned int i = 0; i < pMeshMorphAnim->mNumKeys;++i)
-        {
-            // ScenePreprocessor will compute the duration if still the default value
-            // (Aramis) Add small epsilon, comparison tended to fail if max_time == duration,
-            //  seems to be due the compilers register usage/width.
-            if (pAnimation->mDuration > 0. && pMeshMorphAnim->mKeys[i].mTime > pAnimation->mDuration+0.001)
-            {
-                ReportError("aiMeshMorphAnim::mKeys[%i].mTime (%.5f) is larger "
-                    "than aiAnimation::mDuration (which is %.5f)",i,
-                    (float)pMeshMorphAnim->mKeys[i].mTime,
-                    (float)pAnimation->mDuration);
-            }
-            if (i && pMeshMorphAnim->mKeys[i].mTime <= dLast)
-            {
-                ReportWarning("aiMeshMorphAnim::mKeys[%i].mTime (%.5f) is smaller "
-                    "than aiMeshMorphAnim::mKeys[%i] (which is %.5f)",i,
-                    (float)pMeshMorphAnim->mKeys[i].mTime,
-                    i-1, (float)dLast);
-            }
-            dLast = pMeshMorphAnim->mKeys[i].mTime;
-        }
-    }
-}
-
 // ------------------------------------------------------------------------------------------------
 void ValidateDSProcess::Validate( const aiNode* pNode)
 {
diff --git a/Engine/lib/assimp/code/PostProcessing/ValidateDataStructure.h b/Engine/lib/assimp/code/PostProcessing/ValidateDataStructure.h
index 4b5503ae0..0b891ef41 100644
--- a/Engine/lib/assimp/code/PostProcessing/ValidateDataStructure.h
+++ b/Engine/lib/assimp/code/PostProcessing/ValidateDataStructure.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -55,7 +55,6 @@ struct aiBone;
 struct aiMesh;
 struct aiAnimation;
 struct aiNodeAnim;
-struct aiMeshMorphAnim;
 struct aiTexture;
 struct aiMaterial;
 struct aiNode;
@@ -151,13 +150,6 @@ protected:
     void Validate( const aiAnimation* pAnimation,
         const aiNodeAnim* pBoneAnim);
 
-    /** Validates a mesh morph animation channel.
-     * @param pAnimation Input animation.
-     * @param pMeshMorphAnim Mesh morph animation channel.
-     * */
-    void Validate( const aiAnimation* pAnimation,
-        const aiMeshMorphAnim* pMeshMorphAnim);
-
     // -------------------------------------------------------------------
     /** Validates a node and all of its subnodes
      * @param Node Input node*/
diff --git a/Engine/lib/assimp/code/Q3BSP/Q3BSPFileData.h b/Engine/lib/assimp/code/Q3BSP/Q3BSPFileData.h
index 099253392..4e05bebf1 100644
--- a/Engine/lib/assimp/code/Q3BSP/Q3BSPFileData.h
+++ b/Engine/lib/assimp/code/Q3BSP/Q3BSPFileData.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Q3BSP/Q3BSPFileImporter.cpp b/Engine/lib/assimp/code/Q3BSP/Q3BSPFileImporter.cpp
index 15f574214..4add00a07 100644
--- a/Engine/lib/assimp/code/Q3BSP/Q3BSPFileImporter.cpp
+++ b/Engine/lib/assimp/code/Q3BSP/Q3BSPFileImporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -616,7 +616,7 @@ bool Q3BSPFileImporter::importTextureFromArchive( const Q3BSP::Q3BSPModel *model
             // We'll leave it up to the user to figure out which extension the file has.
             aiString name;
             strncpy( name.data, pTexture->strName, sizeof name.data );
-            name.length = (ai_uint32)strlen( name.data );
+            name.length = strlen( name.data );
             pMatHelper->AddProperty( &name, AI_MATKEY_TEXTURE_DIFFUSE( 0 ) );
         }
     }
diff --git a/Engine/lib/assimp/code/Q3BSP/Q3BSPFileImporter.h b/Engine/lib/assimp/code/Q3BSP/Q3BSPFileImporter.h
index 619f30863..ee21fa48e 100644
--- a/Engine/lib/assimp/code/Q3BSP/Q3BSPFileImporter.h
+++ b/Engine/lib/assimp/code/Q3BSP/Q3BSPFileImporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Q3BSP/Q3BSPFileParser.cpp b/Engine/lib/assimp/code/Q3BSP/Q3BSPFileParser.cpp
index 73f5ec7b8..bed2efe53 100644
--- a/Engine/lib/assimp/code/Q3BSP/Q3BSPFileParser.cpp
+++ b/Engine/lib/assimp/code/Q3BSP/Q3BSPFileParser.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Q3BSP/Q3BSPFileParser.h b/Engine/lib/assimp/code/Q3BSP/Q3BSPFileParser.h
index eab87c76c..fd73f5e10 100644
--- a/Engine/lib/assimp/code/Q3BSP/Q3BSPFileParser.h
+++ b/Engine/lib/assimp/code/Q3BSP/Q3BSPFileParser.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Q3D/Q3DLoader.cpp b/Engine/lib/assimp/code/Q3D/Q3DLoader.cpp
index f68d2ac32..b8c8de716 100644
--- a/Engine/lib/assimp/code/Q3D/Q3DLoader.cpp
+++ b/Engine/lib/assimp/code/Q3D/Q3DLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/Q3D/Q3DLoader.h b/Engine/lib/assimp/code/Q3D/Q3DLoader.h
index f1118eec7..954d3105c 100644
--- a/Engine/lib/assimp/code/Q3D/Q3DLoader.h
+++ b/Engine/lib/assimp/code/Q3D/Q3DLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Raw/RawLoader.cpp b/Engine/lib/assimp/code/Raw/RawLoader.cpp
index 092323cc0..d0da247e4 100644
--- a/Engine/lib/assimp/code/Raw/RawLoader.cpp
+++ b/Engine/lib/assimp/code/Raw/RawLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/Raw/RawLoader.h b/Engine/lib/assimp/code/Raw/RawLoader.h
index 7f5926bd3..8bfe8ef98 100644
--- a/Engine/lib/assimp/code/Raw/RawLoader.h
+++ b/Engine/lib/assimp/code/Raw/RawLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/SIB/SIBImporter.cpp b/Engine/lib/assimp/code/SIB/SIBImporter.cpp
index ac5646412..20cdc8009 100644
--- a/Engine/lib/assimp/code/SIB/SIBImporter.cpp
+++ b/Engine/lib/assimp/code/SIB/SIBImporter.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/SIB/SIBImporter.h b/Engine/lib/assimp/code/SIB/SIBImporter.h
index 2918a1197..bb88c2255 100644
--- a/Engine/lib/assimp/code/SIB/SIBImporter.h
+++ b/Engine/lib/assimp/code/SIB/SIBImporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/SMD/SMDLoader.cpp b/Engine/lib/assimp/code/SMD/SMDLoader.cpp
index b7c98d68f..4288bf9c3 100644
--- a/Engine/lib/assimp/code/SMD/SMDLoader.cpp
+++ b/Engine/lib/assimp/code/SMD/SMDLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
@@ -60,7 +60,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // internal headers
 #include "SMDLoader.h"
 
-#ifndef _MSC_VER
+#ifndef _WIN32
 #define strtok_s strtok_r
 #endif
 
@@ -616,7 +616,7 @@ void SMDImporter::CreateOutputMaterials() {
         if (aszTextures[iMat].length())
         {
             ::strncpy(szName.data, aszTextures[iMat].c_str(),MAXLEN-1);
-            szName.length = (ai_uint32)aszTextures[iMat].length();
+            szName.length = aszTextures[iMat].length();
             pcMat->AddProperty(&szName,AI_MATKEY_TEXTURE_DIFFUSE(0));
         }
     }
diff --git a/Engine/lib/assimp/code/SMD/SMDLoader.h b/Engine/lib/assimp/code/SMD/SMDLoader.h
index 85dafdebc..85dac97d1 100644
--- a/Engine/lib/assimp/code/SMD/SMDLoader.h
+++ b/Engine/lib/assimp/code/SMD/SMDLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/STL/STLExporter.cpp b/Engine/lib/assimp/code/STL/STLExporter.cpp
index 06723cdba..43bc752ae 100644
--- a/Engine/lib/assimp/code/STL/STLExporter.cpp
+++ b/Engine/lib/assimp/code/STL/STLExporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/STL/STLExporter.h b/Engine/lib/assimp/code/STL/STLExporter.h
index 92fd8a8ab..cb5238e60 100644
--- a/Engine/lib/assimp/code/STL/STLExporter.h
+++ b/Engine/lib/assimp/code/STL/STLExporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/STL/STLLoader.cpp b/Engine/lib/assimp/code/STL/STLLoader.cpp
index 8155d5def..199a84a44 100644
--- a/Engine/lib/assimp/code/STL/STLLoader.cpp
+++ b/Engine/lib/assimp/code/STL/STLLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/STL/STLLoader.h b/Engine/lib/assimp/code/STL/STLLoader.h
index d2f4d6e9c..ca1011cb8 100644
--- a/Engine/lib/assimp/code/STL/STLLoader.h
+++ b/Engine/lib/assimp/code/STL/STLLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Step/STEPFile.h b/Engine/lib/assimp/code/Step/STEPFile.h
index 040a4fa21..d99b34b3c 100644
--- a/Engine/lib/assimp/code/Step/STEPFile.h
+++ b/Engine/lib/assimp/code/Step/STEPFile.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Step/StepExporter.cpp b/Engine/lib/assimp/code/Step/StepExporter.cpp
index 56aedb96c..70035d9ea 100644
--- a/Engine/lib/assimp/code/Step/StepExporter.cpp
+++ b/Engine/lib/assimp/code/Step/StepExporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Step/StepExporter.h b/Engine/lib/assimp/code/Step/StepExporter.h
index 683533854..f96a0d2b5 100644
--- a/Engine/lib/assimp/code/Step/StepExporter.h
+++ b/Engine/lib/assimp/code/Step/StepExporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Terragen/TerragenLoader.cpp b/Engine/lib/assimp/code/Terragen/TerragenLoader.cpp
index d4a268a29..9b0873c68 100644
--- a/Engine/lib/assimp/code/Terragen/TerragenLoader.cpp
+++ b/Engine/lib/assimp/code/Terragen/TerragenLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/Terragen/TerragenLoader.h b/Engine/lib/assimp/code/Terragen/TerragenLoader.h
index 81823fc74..a478c0dcd 100644
--- a/Engine/lib/assimp/code/Terragen/TerragenLoader.h
+++ b/Engine/lib/assimp/code/Terragen/TerragenLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Unreal/UnrealLoader.cpp b/Engine/lib/assimp/code/Unreal/UnrealLoader.cpp
index d165d7d24..0bd4650d0 100644
--- a/Engine/lib/assimp/code/Unreal/UnrealLoader.cpp
+++ b/Engine/lib/assimp/code/Unreal/UnrealLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -403,7 +403,7 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
 
         // set color and name
         mat->AddProperty(&color,1,AI_MATKEY_COLOR_DIFFUSE);
-        s.length = (ai_uint32)::strlen(s.data);
+        s.length = ::strlen(s.data);
         mat->AddProperty(&s,AI_MATKEY_NAME);
 
         // set texture, if any
diff --git a/Engine/lib/assimp/code/Unreal/UnrealLoader.h b/Engine/lib/assimp/code/Unreal/UnrealLoader.h
index c00dfd34e..678aaa76b 100644
--- a/Engine/lib/assimp/code/Unreal/UnrealLoader.h
+++ b/Engine/lib/assimp/code/Unreal/UnrealLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/X/XFileExporter.cpp b/Engine/lib/assimp/code/X/XFileExporter.cpp
index 5b1c49eab..ae9fd58fc 100644
--- a/Engine/lib/assimp/code/X/XFileExporter.cpp
+++ b/Engine/lib/assimp/code/X/XFileExporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/X/XFileExporter.h b/Engine/lib/assimp/code/X/XFileExporter.h
index 42cadc407..322440af8 100644
--- a/Engine/lib/assimp/code/X/XFileExporter.h
+++ b/Engine/lib/assimp/code/X/XFileExporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/X/XFileHelper.h b/Engine/lib/assimp/code/X/XFileHelper.h
index 461331921..0365280f0 100644
--- a/Engine/lib/assimp/code/X/XFileHelper.h
+++ b/Engine/lib/assimp/code/X/XFileHelper.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/X/XFileImporter.cpp b/Engine/lib/assimp/code/X/XFileImporter.cpp
index 9b90c9da3..be7256d5c 100644
--- a/Engine/lib/assimp/code/X/XFileImporter.cpp
+++ b/Engine/lib/assimp/code/X/XFileImporter.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
@@ -211,7 +211,7 @@ aiNode* XFileImporter::CreateNodes( aiScene* pScene, aiNode* pParent, const XFil
 
     // create node
     aiNode* node = new aiNode;
-    node->mName.length = (ai_uint32)pNode->mName.length();
+    node->mName.length = pNode->mName.length();
     node->mParent = pParent;
     memcpy( node->mName.data, pNode->mName.c_str(), pNode->mName.length());
     node->mName.data[node->mName.length] = 0;
@@ -513,36 +513,30 @@ void XFileImporter::CreateAnimations( aiScene* pScene, const XFile::Scene* pData
             } else {
                 // separate key sequences for position, rotation, scaling
                 nbone->mNumPositionKeys = (unsigned int)bone->mPosKeys.size();
-                if (nbone->mNumPositionKeys != 0) {
-                    nbone->mPositionKeys = new aiVectorKey[nbone->mNumPositionKeys];
-                    for( unsigned int c = 0; c < nbone->mNumPositionKeys; ++c ) {
-                        aiVector3D pos = bone->mPosKeys[c].mValue;
+                nbone->mPositionKeys = new aiVectorKey[nbone->mNumPositionKeys];
+                for( unsigned int c = 0; c < nbone->mNumPositionKeys; ++c ) {
+                    aiVector3D pos = bone->mPosKeys[c].mValue;
 
-                        nbone->mPositionKeys[c].mTime = bone->mPosKeys[c].mTime;
-                        nbone->mPositionKeys[c].mValue = pos;
-                    }
+                    nbone->mPositionKeys[c].mTime = bone->mPosKeys[c].mTime;
+                    nbone->mPositionKeys[c].mValue = pos;
                 }
 
                 // rotation
                 nbone->mNumRotationKeys = (unsigned int)bone->mRotKeys.size();
-                if (nbone->mNumRotationKeys != 0) {
-                    nbone->mRotationKeys = new aiQuatKey[nbone->mNumRotationKeys];
-                    for( unsigned int c = 0; c < nbone->mNumRotationKeys; ++c ) {
-                        aiMatrix3x3 rotmat = bone->mRotKeys[c].mValue.GetMatrix();
+                nbone->mRotationKeys = new aiQuatKey[nbone->mNumRotationKeys];
+                for( unsigned int c = 0; c < nbone->mNumRotationKeys; ++c ) {
+                    aiMatrix3x3 rotmat = bone->mRotKeys[c].mValue.GetMatrix();
 
-                        nbone->mRotationKeys[c].mTime = bone->mRotKeys[c].mTime;
-                        nbone->mRotationKeys[c].mValue = aiQuaternion( rotmat);
-                        nbone->mRotationKeys[c].mValue.w *= -1.0f; // needs quat inversion
-                    }
+                    nbone->mRotationKeys[c].mTime = bone->mRotKeys[c].mTime;
+                    nbone->mRotationKeys[c].mValue = aiQuaternion( rotmat);
+                    nbone->mRotationKeys[c].mValue.w *= -1.0f; // needs quat inversion
                 }
 
                 // scaling
                 nbone->mNumScalingKeys = (unsigned int)bone->mScaleKeys.size();
-                if (nbone->mNumScalingKeys != 0) {
-                    nbone->mScalingKeys = new aiVectorKey[nbone->mNumScalingKeys];
-                    for( unsigned int c = 0; c < nbone->mNumScalingKeys; c++)
-                        nbone->mScalingKeys[c] = bone->mScaleKeys[c];
-                }
+                nbone->mScalingKeys = new aiVectorKey[nbone->mNumScalingKeys];
+                for( unsigned int c = 0; c < nbone->mNumScalingKeys; c++)
+                    nbone->mScalingKeys[c] = bone->mScaleKeys[c];
 
                 // longest lasting key sequence determines duration
                 if( bone->mPosKeys.size() > 0)
diff --git a/Engine/lib/assimp/code/X/XFileImporter.h b/Engine/lib/assimp/code/X/XFileImporter.h
index 31abb6c0f..7d12b6fdf 100644
--- a/Engine/lib/assimp/code/X/XFileImporter.h
+++ b/Engine/lib/assimp/code/X/XFileImporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/X/XFileParser.cpp b/Engine/lib/assimp/code/X/XFileParser.cpp
index 8847119c4..8fcf87cf6 100644
--- a/Engine/lib/assimp/code/X/XFileParser.cpp
+++ b/Engine/lib/assimp/code/X/XFileParser.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/X/XFileParser.h b/Engine/lib/assimp/code/X/XFileParser.h
index ea7aca266..993bae6a1 100644
--- a/Engine/lib/assimp/code/X/XFileParser.h
+++ b/Engine/lib/assimp/code/X/XFileParser.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/X3D/FIReader.cpp b/Engine/lib/assimp/code/X3D/FIReader.cpp
index 359643440..9bb2c69f6 100644
--- a/Engine/lib/assimp/code/X3D/FIReader.cpp
+++ b/Engine/lib/assimp/code/X3D/FIReader.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/X3D/FIReader.hpp b/Engine/lib/assimp/code/X3D/FIReader.hpp
index e8b6c2f3a..2c92239ac 100644
--- a/Engine/lib/assimp/code/X3D/FIReader.hpp
+++ b/Engine/lib/assimp/code/X3D/FIReader.hpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/X3D/X3DImporter.cpp b/Engine/lib/assimp/code/X3D/X3DImporter.cpp
index c9f9a6b6d..367d84fcf 100644
--- a/Engine/lib/assimp/code/X3D/X3DImporter.cpp
+++ b/Engine/lib/assimp/code/X3D/X3DImporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/X3D/X3DImporter.hpp b/Engine/lib/assimp/code/X3D/X3DImporter.hpp
index 737a7f160..a4afc1463 100644
--- a/Engine/lib/assimp/code/X3D/X3DImporter.hpp
+++ b/Engine/lib/assimp/code/X3D/X3DImporter.hpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/X3D/X3DImporter_Geometry2D.cpp b/Engine/lib/assimp/code/X3D/X3DImporter_Geometry2D.cpp
index 5879c3d50..350fd6c40 100644
--- a/Engine/lib/assimp/code/X3D/X3DImporter_Geometry2D.cpp
+++ b/Engine/lib/assimp/code/X3D/X3DImporter_Geometry2D.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/X3D/X3DImporter_Geometry3D.cpp b/Engine/lib/assimp/code/X3D/X3DImporter_Geometry3D.cpp
index a6bad981a..e12cbd3ab 100644
--- a/Engine/lib/assimp/code/X3D/X3DImporter_Geometry3D.cpp
+++ b/Engine/lib/assimp/code/X3D/X3DImporter_Geometry3D.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/X3D/X3DImporter_Group.cpp b/Engine/lib/assimp/code/X3D/X3DImporter_Group.cpp
index d78778928..de3610caf 100644
--- a/Engine/lib/assimp/code/X3D/X3DImporter_Group.cpp
+++ b/Engine/lib/assimp/code/X3D/X3DImporter_Group.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/X3D/X3DImporter_Light.cpp b/Engine/lib/assimp/code/X3D/X3DImporter_Light.cpp
index 5a482adcd..842fffc04 100644
--- a/Engine/lib/assimp/code/X3D/X3DImporter_Light.cpp
+++ b/Engine/lib/assimp/code/X3D/X3DImporter_Light.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/X3D/X3DImporter_Macro.hpp b/Engine/lib/assimp/code/X3D/X3DImporter_Macro.hpp
index 2463c7762..a6aca33fb 100644
--- a/Engine/lib/assimp/code/X3D/X3DImporter_Macro.hpp
+++ b/Engine/lib/assimp/code/X3D/X3DImporter_Macro.hpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/X3D/X3DImporter_Metadata.cpp b/Engine/lib/assimp/code/X3D/X3DImporter_Metadata.cpp
index 126eddb4c..f888ac2b9 100644
--- a/Engine/lib/assimp/code/X3D/X3DImporter_Metadata.cpp
+++ b/Engine/lib/assimp/code/X3D/X3DImporter_Metadata.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/X3D/X3DImporter_Networking.cpp b/Engine/lib/assimp/code/X3D/X3DImporter_Networking.cpp
index 688362ab9..a7a200675 100644
--- a/Engine/lib/assimp/code/X3D/X3DImporter_Networking.cpp
+++ b/Engine/lib/assimp/code/X3D/X3DImporter_Networking.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/X3D/X3DImporter_Node.hpp b/Engine/lib/assimp/code/X3D/X3DImporter_Node.hpp
index ebc5200c3..85208223d 100644
--- a/Engine/lib/assimp/code/X3D/X3DImporter_Node.hpp
+++ b/Engine/lib/assimp/code/X3D/X3DImporter_Node.hpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/X3D/X3DImporter_Postprocess.cpp b/Engine/lib/assimp/code/X3D/X3DImporter_Postprocess.cpp
index a8bc1a00c..539563fcf 100644
--- a/Engine/lib/assimp/code/X3D/X3DImporter_Postprocess.cpp
+++ b/Engine/lib/assimp/code/X3D/X3DImporter_Postprocess.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/X3D/X3DImporter_Rendering.cpp b/Engine/lib/assimp/code/X3D/X3DImporter_Rendering.cpp
index a574d5549..6e95c9441 100644
--- a/Engine/lib/assimp/code/X3D/X3DImporter_Rendering.cpp
+++ b/Engine/lib/assimp/code/X3D/X3DImporter_Rendering.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/X3D/X3DImporter_Shape.cpp b/Engine/lib/assimp/code/X3D/X3DImporter_Shape.cpp
index 189ed145d..126d5905a 100644
--- a/Engine/lib/assimp/code/X3D/X3DImporter_Shape.cpp
+++ b/Engine/lib/assimp/code/X3D/X3DImporter_Shape.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/X3D/X3DImporter_Texturing.cpp b/Engine/lib/assimp/code/X3D/X3DImporter_Texturing.cpp
index 0f8c75c41..2eaf3e6bc 100644
--- a/Engine/lib/assimp/code/X3D/X3DImporter_Texturing.cpp
+++ b/Engine/lib/assimp/code/X3D/X3DImporter_Texturing.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/X3D/X3DVocabulary.cpp b/Engine/lib/assimp/code/X3D/X3DVocabulary.cpp
index b985a0d14..c6ee113b3 100644
--- a/Engine/lib/assimp/code/X3D/X3DVocabulary.cpp
+++ b/Engine/lib/assimp/code/X3D/X3DVocabulary.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/XGL/XGLLoader.cpp b/Engine/lib/assimp/code/XGL/XGLLoader.cpp
index 403205e03..32cfd72ca 100644
--- a/Engine/lib/assimp/code/XGL/XGLLoader.cpp
+++ b/Engine/lib/assimp/code/XGL/XGLLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -685,7 +685,7 @@ bool XGLImporter::ReadMesh(TempScope& scope)
     }
 
     // finally extract output meshes and add them to the scope
-    typedef std::pair<const unsigned int, TempMaterialMesh> pairt;
+    typedef std::pair<unsigned int, TempMaterialMesh> pairt;
     for(const pairt& p : bymat) {
         aiMesh* const m  = ToOutputMesh(p.second);
         scope.meshes_linear.push_back(m);
diff --git a/Engine/lib/assimp/code/XGL/XGLLoader.h b/Engine/lib/assimp/code/XGL/XGLLoader.h
index f227c5f0f..bba2a643c 100644
--- a/Engine/lib/assimp/code/XGL/XGLLoader.h
+++ b/Engine/lib/assimp/code/XGL/XGLLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/glTF/glTFAsset.h b/Engine/lib/assimp/code/glTF/glTFAsset.h
index b918d456b..ddc7f086e 100644
--- a/Engine/lib/assimp/code/glTF/glTFAsset.h
+++ b/Engine/lib/assimp/code/glTF/glTFAsset.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -191,7 +191,6 @@ namespace glTF
     //! Values for the BufferView::target field
     enum BufferViewTarget
     {
-        BufferViewTarget_NONE = 0,
         BufferViewTarget_ARRAY_BUFFER = 34962,
         BufferViewTarget_ELEMENT_ARRAY_BUFFER = 34963
     };
@@ -363,8 +362,8 @@ namespace glTF
         ComponentType componentType; //!< The datatype of components in the attribute. (required)
         unsigned int count;          //!< The number of attributes referenced by this accessor. (required)
         AttribType::Value type;      //!< Specifies if the attribute is a scalar, vector, or matrix. (required)
-        std::vector<double> max;     //!< Maximum value of each component in this attribute.
-        std::vector<double> min;     //!< Minimum value of each component in this attribute.
+        std::vector<float> max;      //!< Maximum value of each component in this attribute.
+        std::vector<float> min;      //!< Minimum value of each component in this attribute.
 
         unsigned int GetNumComponents();
         unsigned int GetBytesPerComponent();
@@ -750,7 +749,7 @@ namespace glTF
 		/// \fn void Read(Value& pJSON_Object, Asset& pAsset_Root)
 		/// Get mesh data from JSON-object and place them to root asset.
 		/// \param [in] pJSON_Object - reference to pJSON-object from which data are read.
-		/// \param [out] pAsset_Root - reference to root asset where data will be stored.
+		/// \param [out] pAsset_Root - reference to root assed where data will be stored.
 		void Read(Value& pJSON_Object, Asset& pAsset_Root);
 
 		#ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC
diff --git a/Engine/lib/assimp/code/glTF/glTFAsset.inl b/Engine/lib/assimp/code/glTF/glTFAsset.inl
index 00456edbf..f31781a3f 100644
--- a/Engine/lib/assimp/code/glTF/glTFAsset.inl
+++ b/Engine/lib/assimp/code/glTF/glTFAsset.inl
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
@@ -325,7 +325,7 @@ inline void Buffer::Read(Value& obj, Asset& r)
     }
     else { // Local file
         if (byteLength > 0) {
-            std::string dir = !r.mCurrentAssetDir.empty() ? (r.mCurrentAssetDir) : "";
+            std::string dir = !r.mCurrentAssetDir.empty() ? (r.mCurrentAssetDir + "/") : "";
 
             IOStream* file = r.OpenFile(dir + uri, "rb");
             if (file) {
@@ -688,9 +688,7 @@ inline void Image::SetData(uint8_t* data, size_t length, Asset& r)
         bufferView->byteOffset = b->AppendData(data, length);
     }
     else { // text file: will be stored as a data uri
-        uint8_t *temp = new uint8_t[length];
-        memcpy(temp, data, length);
-        this->mData.reset(temp);
+        this->mData.reset(data);
         this->mDataLength = length;
     }
 }
@@ -1429,6 +1427,9 @@ inline void Asset::ReadExtensionsUsed(Document& doc)
         }
     }
 
+    #define CHECK_EXT(EXT) \
+        if (exts.find(#EXT) != exts.end()) extensionsUsed.EXT = true;
+
     CHECK_EXT(KHR_binary_glTF);
     CHECK_EXT(KHR_materials_common);
 
diff --git a/Engine/lib/assimp/code/glTF/glTFAssetWriter.h b/Engine/lib/assimp/code/glTF/glTFAssetWriter.h
index f166ee532..03aee7d4c 100644
--- a/Engine/lib/assimp/code/glTF/glTFAssetWriter.h
+++ b/Engine/lib/assimp/code/glTF/glTFAssetWriter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/glTF/glTFAssetWriter.inl b/Engine/lib/assimp/code/glTF/glTFAssetWriter.inl
index 6abe7e078..1bbb8fd8c 100644
--- a/Engine/lib/assimp/code/glTF/glTFAssetWriter.inl
+++ b/Engine/lib/assimp/code/glTF/glTFAssetWriter.inl
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -54,9 +54,9 @@ namespace glTF {
 
     namespace {
 
-        template<typename T, size_t N>
+        template<size_t N>
         inline 
-        Value& MakeValue(Value& val, T(&r)[N], MemoryPoolAllocator<>& al) {
+        Value& MakeValue(Value& val, float(&r)[N], MemoryPoolAllocator<>& al) {
             val.SetArray();
             val.Reserve(N, al);
             for (decltype(N) i = 0; i < N; ++i) {
@@ -65,9 +65,8 @@ namespace glTF {
             return val;
         }
 
-        template<typename T>
         inline 
-        Value& MakeValue(Value& val, const std::vector<T> & r, MemoryPoolAllocator<>& al) {
+        Value& MakeValue(Value& val, const std::vector<float> & r, MemoryPoolAllocator<>& al) {
             val.SetArray();
             val.Reserve(static_cast<rapidjson::SizeType>(r.size()), al);
             for (unsigned int i = 0; i < r.size(); ++i) {
@@ -76,16 +75,6 @@ namespace glTF {
             return val;
         }
 
-        template<typename C, typename T>
-        inline Value& MakeValueCast(Value& val, const std::vector<T> & r, MemoryPoolAllocator<>& al) {
-            val.SetArray();
-            val.Reserve(static_cast<rapidjson::SizeType>(r.size()), al);
-            for (unsigned int i = 0; i < r.size(); ++i) {
-                val.PushBack(static_cast<C>(r[i]), al);
-            }
-            return val;
-        }
-
         template<class T>
         inline void AddRefsVector(Value& obj, const char* fieldId, std::vector< Ref<T> >& v, MemoryPoolAllocator<>& al) {
             if (v.empty()) return;
@@ -111,13 +100,8 @@ namespace glTF {
         obj.AddMember("type", StringRef(AttribType::ToString(a.type)), w.mAl);
 
         Value vTmpMax, vTmpMin;
-		if (a.componentType == ComponentType_FLOAT) {
-			obj.AddMember("max", MakeValue(vTmpMax, a.max, w.mAl), w.mAl);
-			obj.AddMember("min", MakeValue(vTmpMin, a.min, w.mAl), w.mAl);
-		} else {
-			obj.AddMember("max", MakeValueCast<int64_t>(vTmpMax, a.max, w.mAl), w.mAl);
-			obj.AddMember("min", MakeValueCast<int64_t>(vTmpMin, a.min, w.mAl), w.mAl);
-		}
+        obj.AddMember("max", MakeValue(vTmpMax, a.max, w.mAl), w.mAl);
+        obj.AddMember("min", MakeValue(vTmpMin, a.min, w.mAl), w.mAl);
     }
 
     inline void Write(Value& obj, Animation& a, AssetWriter& w)
@@ -203,9 +187,7 @@ namespace glTF {
         obj.AddMember("buffer", Value(bv.buffer->id, w.mAl).Move(), w.mAl);
         obj.AddMember("byteOffset", static_cast<uint64_t>(bv.byteOffset), w.mAl);
         obj.AddMember("byteLength", static_cast<uint64_t>(bv.byteLength), w.mAl);
-        if (bv.target != BufferViewTarget_NONE) {
-            obj.AddMember("target", int(bv.target), w.mAl);
-        }
+        obj.AddMember("target", int(bv.target), w.mAl);
     }
 
     inline void Write(Value& /*obj*/, Camera& /*c*/, AssetWriter& /*w*/)
@@ -629,9 +611,6 @@ namespace glTF {
         asset.SetObject();
         asset.AddMember("version", Value(mAsset.asset.version, mAl).Move(), mAl);
         asset.AddMember("generator", Value(mAsset.asset.generator, mAl).Move(), mAl);
-        if (!mAsset.asset.copyright.empty())
-            asset.AddMember("copyright", Value(mAsset.asset.copyright, mAl).Move(), mAl);
-
         mDoc.AddMember("asset", asset, mAl);
     }
 
diff --git a/Engine/lib/assimp/code/glTF/glTFCommon.cpp b/Engine/lib/assimp/code/glTF/glTFCommon.cpp
index 9fac8de2d..cd03224e4 100644
--- a/Engine/lib/assimp/code/glTF/glTFCommon.cpp
+++ b/Engine/lib/assimp/code/glTF/glTFCommon.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
diff --git a/Engine/lib/assimp/code/glTF/glTFCommon.h b/Engine/lib/assimp/code/glTF/glTFCommon.h
index d942b4ba8..d9edee75e 100644
--- a/Engine/lib/assimp/code/glTF/glTFCommon.h
+++ b/Engine/lib/assimp/code/glTF/glTFCommon.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
@@ -188,7 +188,7 @@ namespace glTFCommon {
         size_t DecodeBase64(const char* in, size_t inLength, uint8_t*& out);
 
         inline
-        size_t DecodeBase64(const char* in, uint8_t*& out) {
+            size_t DecodeBase64(const char* in, uint8_t*& out) {
             return DecodeBase64(in, strlen(in), out);
         }
 
@@ -221,22 +221,25 @@ namespace glTFCommon {
         };
 
         inline
-        char EncodeCharBase64(uint8_t b) {
+            char EncodeCharBase64(uint8_t b) {
             return "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="[size_t(b)];
         }
 
         inline
-        uint8_t DecodeCharBase64(char c) {
+            uint8_t DecodeCharBase64(char c) {
             return DATA<true>::tableDecodeBase64[size_t(c)]; // TODO faster with lookup table or ifs?
+            /*if (c >= 'A' && c <= 'Z') return c - 'A';
+            if (c >= 'a' && c <= 'z') return c - 'a' + 26;
+            if (c >= '0' && c <= '9') return c - '0' + 52;
+            if (c == '+') return 62;
+            if (c == '/') return 63;
+            return 64; // '-' */
         }
 
         size_t DecodeBase64(const char* in, size_t inLength, uint8_t*& out);
 
         void EncodeBase64(const uint8_t* in, size_t inLength, std::string& out);
-    } // namespace Util
-
-#define CHECK_EXT(EXT) \
-	if (exts.find(#EXT) != exts.end()) extensionsUsed.EXT = true;
+    }
 
 }
 
diff --git a/Engine/lib/assimp/code/glTF/glTFExporter.cpp b/Engine/lib/assimp/code/glTF/glTFExporter.cpp
index 7c21b738b..034f91f3b 100644
--- a/Engine/lib/assimp/code/glTF/glTFExporter.cpp
+++ b/Engine/lib/assimp/code/glTF/glTFExporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -46,7 +46,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "glTF/glTFAssetWriter.h"
 #include "PostProcessing/SplitLargeMeshes.h"
 
-#include <assimp/commonMetaData.h>
 #include <assimp/Exceptional.h>
 #include <assimp/StringComparison.h>
 #include <assimp/ByteSwapper.h>
@@ -59,7 +58,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // Header files, standard library.
 #include <memory>
-#include <limits>
 #include <inttypes.h>
 
 #ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC
@@ -100,16 +98,17 @@ glTFExporter::glTFExporter(const char* filename, IOSystem* pIOSystem, const aiSc
 {
     aiScene* sceneCopy_tmp;
     SceneCombiner::CopyScene(&sceneCopy_tmp, pScene);
+    aiScene *sceneCopy(sceneCopy_tmp);
 
     SplitLargeMeshesProcess_Triangle tri_splitter;
     tri_splitter.SetLimit(0xffff);
-    tri_splitter.Execute(sceneCopy_tmp);
+    tri_splitter.Execute(sceneCopy);
 
     SplitLargeMeshesProcess_Vertex vert_splitter;
     vert_splitter.SetLimit(0xffff);
-    vert_splitter.Execute(sceneCopy_tmp);
+    vert_splitter.Execute(sceneCopy);
 
-    mScene.reset(sceneCopy_tmp);
+    mScene = sceneCopy;
 
     mAsset.reset( new glTF::Asset( pIOSystem ) );
 
@@ -160,7 +159,10 @@ static void CopyValue(const aiMatrix4x4& v, glTF::mat4& o)
 
 static void CopyValue(const aiMatrix4x4& v, aiMatrix4x4& o)
 {
-    memcpy(&o, &v, sizeof(aiMatrix4x4));
+    o.a1 = v.a1; o.a2 = v.a2; o.a3 = v.a3; o.a4 = v.a4;
+    o.b1 = v.b1; o.b2 = v.b2; o.b3 = v.b3; o.b4 = v.b4;
+    o.c1 = v.c1; o.c2 = v.c2; o.c3 = v.c3; o.c4 = v.c4;
+    o.d1 = v.d1; o.d2 = v.d2; o.d3 = v.d3; o.d4 = v.d4;
 }
 
 static void IdentityMatrix4(glTF::mat4& o)
@@ -171,64 +173,9 @@ static void IdentityMatrix4(glTF::mat4& o)
     o[12] = 0; o[13] = 0; o[14] = 0; o[15] = 1;
 }
 
-template<typename T>
-void SetAccessorRange(Ref<Accessor> acc, void* data, unsigned int count,
-	unsigned int numCompsIn, unsigned int numCompsOut)
+inline Ref<Accessor> ExportData(Asset& a, std::string& meshName, Ref<Buffer>& buffer,
+    unsigned int count, void* data, AttribType::Value typeIn, AttribType::Value typeOut, ComponentType compType, bool isIndices = false)
 {
-	ai_assert(numCompsOut <= numCompsIn);
-
-	// Allocate and initialize with large values.
-	for (unsigned int i = 0 ; i < numCompsOut ; i++) {
-		acc->min.push_back( std::numeric_limits<double>::max());
-		acc->max.push_back(-std::numeric_limits<double>::max());
-	}
-
-	size_t totalComps = count * numCompsIn;
-	T* buffer_ptr = static_cast<T*>(data);
-	T* buffer_end = buffer_ptr + totalComps;
-
-	// Search and set extreme values.
-	for (; buffer_ptr < buffer_end ; buffer_ptr += numCompsIn) {
-		for (unsigned int j = 0 ; j < numCompsOut ; j++) {
-			double valueTmp = buffer_ptr[j];
-
-			if (valueTmp < acc->min[j]) {
-				acc->min[j] = valueTmp;
-			}
-			if (valueTmp > acc->max[j]) {
-				acc->max[j] = valueTmp;
-			}
-		}
-	}
-}
-
-inline void SetAccessorRange(ComponentType compType, Ref<Accessor> acc, void* data,
-		unsigned int count, unsigned int numCompsIn, unsigned int numCompsOut)
-{
-	switch (compType) {
-		case ComponentType_SHORT:
-			SetAccessorRange<short>(acc, data, count, numCompsIn, numCompsOut);
-			return;
-		case ComponentType_UNSIGNED_SHORT:
-			SetAccessorRange<unsigned short>(acc, data, count, numCompsIn, numCompsOut);
-			return;
-		case ComponentType_UNSIGNED_INT:
-			SetAccessorRange<unsigned int>(acc, data, count, numCompsIn, numCompsOut);
-			return;
-		case ComponentType_FLOAT:
-			SetAccessorRange<float>(acc, data, count, numCompsIn, numCompsOut);
-			return;
-		case ComponentType_BYTE:
-			SetAccessorRange<int8_t>(acc, data, count, numCompsIn, numCompsOut);
-			return;
-		case ComponentType_UNSIGNED_BYTE:
-			SetAccessorRange<uint8_t>(acc, data, count, numCompsIn, numCompsOut);
-			return;
-	}
-}
-
-inline Ref<Accessor> ExportData(Asset &a, std::string &meshName, Ref<Buffer> &buffer,
-        unsigned int count, void *data, AttribType::Value typeIn, AttribType::Value typeOut, ComponentType compType, BufferViewTarget target = BufferViewTarget_NONE) {
     if (!count || !data) return Ref<Accessor>();
 
     unsigned int numCompsIn = AttribType::GetNumComponents(typeIn);
@@ -247,7 +194,7 @@ inline Ref<Accessor> ExportData(Asset &a, std::string &meshName, Ref<Buffer> &bu
     bv->buffer = buffer;
     bv->byteOffset = unsigned(offset);
     bv->byteLength = length; //! The target that the WebGL buffer should be bound to.
-    bv->target = target;
+    bv->target = isIndices ? BufferViewTarget_ELEMENT_ARRAY_BUFFER : BufferViewTarget_ARRAY_BUFFER;
 
     // accessor
     Ref<Accessor> acc = a.accessors.Create(a.FindUniqueID(meshName, "accessor"));
@@ -259,7 +206,33 @@ inline Ref<Accessor> ExportData(Asset &a, std::string &meshName, Ref<Buffer> &bu
     acc->type = typeOut;
 
     // calculate min and max values
-	SetAccessorRange(compType, acc, data, count, numCompsIn, numCompsOut);
+    {
+        // Allocate and initialize with large values.
+        float float_MAX = 10000000000000.0f;
+        for (unsigned int i = 0 ; i < numCompsOut ; i++) {
+            acc->min.push_back( float_MAX);
+            acc->max.push_back(-float_MAX);
+        }
+
+        // Search and set extreme values.
+        float valueTmp;
+        for (unsigned int i = 0 ; i < count       ; i++) {
+            for (unsigned int j = 0 ; j < numCompsOut ; j++) {
+                if (numCompsOut == 1) {
+                  valueTmp = static_cast<unsigned short*>(data)[i];
+                } else {
+                  valueTmp = static_cast<aiVector3D*>(data)[i][j];
+                }
+
+                if (valueTmp < acc->min[j]) {
+                    acc->min[j] = valueTmp;
+                }
+                if (valueTmp > acc->max[j]) {
+                    acc->max[j] = valueTmp;
+                }
+            }
+        }
+    }
 
     // copy the data
     acc->WriteData(count, data, numCompsIn*bytesPerComp);
@@ -348,8 +321,6 @@ void glTFExporter::GetMatColorOrTex(const aiMaterial* mat, glTF::TexProperty& pr
 
                     if (path[0] == '*') { // embedded
                         aiTexture* tex = mScene->mTextures[atoi(&path[1])];
-						
-                        prop.texture->source->name = tex->mFilename.C_Str();
 
                         uint8_t* data = reinterpret_cast<uint8_t*>(tex->pcData);
                         prop.texture->source->SetData(data, tex->mWidth, *mAsset);
@@ -612,13 +583,13 @@ void glTFExporter::ExportMeshes()
 		// If compression is used then you need parameters of uncompressed region: begin and size. At this step "begin" is stored.
 		if(comp_allow) idx_srcdata_begin = b->byteLength;
 
-        Ref<Accessor> v = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mVertices, AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT, BufferViewTarget_ARRAY_BUFFER);
+        Ref<Accessor> v = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mVertices, AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT);
 		if (v) p.attributes.position.push_back(v);
 
 		/******************** Normals ********************/
 		if(comp_allow && (aim->mNormals != 0)) idx_srcdata_normal = b->byteLength;// Store index of normals array.
 
-		Ref<Accessor> n = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mNormals, AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT, BufferViewTarget_ARRAY_BUFFER);
+		Ref<Accessor> n = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mNormals, AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT);
 		if (n) p.attributes.normal.push_back(n);
 
 		/************** Texture coordinates **************/
@@ -635,7 +606,7 @@ void glTFExporter::ExportMeshes()
 
 				if(comp_allow) idx_srcdata_tc.push_back(b->byteLength);// Store index of texture coordinates array.
 
-				Ref<Accessor> tc = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mTextureCoords[i], AttribType::VEC3, type, ComponentType_FLOAT, BufferViewTarget_ARRAY_BUFFER);
+				Ref<Accessor> tc = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mTextureCoords[i], AttribType::VEC3, type, ComponentType_FLOAT, false);
 				if (tc) p.attributes.texcoord.push_back(tc);
 			}
 		}
@@ -653,7 +624,7 @@ void glTFExporter::ExportMeshes()
                 }
             }
 
-			p.indices = ExportData(*mAsset, meshId, b, unsigned(indices.size()), &indices[0], AttribType::SCALAR, AttribType::SCALAR, ComponentType_UNSIGNED_SHORT, BufferViewTarget_ELEMENT_ARRAY_BUFFER);
+			p.indices = ExportData(*mAsset, meshId, b, unsigned(indices.size()), &indices[0], AttribType::SCALAR, AttribType::SCALAR, ComponentType_UNSIGNED_SHORT, true);
 		}
 
         switch (aim->mPrimitiveTypes) {
@@ -867,16 +838,10 @@ void glTFExporter::ExportMetadata()
     asset.version = "1.0";
 
     char buffer[256];
-    ai_snprintf(buffer, 256, "Open Asset Import Library (assimp v%d.%d.%x)",
+    ai_snprintf(buffer, 256, "Open Asset Import Library (assimp v%d.%d.%d)",
         aiGetVersionMajor(), aiGetVersionMinor(), aiGetVersionRevision());
 
     asset.generator = buffer;
-
-	// Copyright
-	aiString copyright_str;
-	if (mScene->mMetaData != nullptr && mScene->mMetaData->Get(AI_METADATA_SOURCE_COPYRIGHT, copyright_str)) {
-		asset.copyright = copyright_str.C_Str();
-	}
 }
 
 inline void ExtractAnimationData(Asset& mAsset, std::string& animId, Ref<Animation>& animRef, Ref<Buffer>& buffer, const aiNodeAnim* nodeChannel, float ticksPerSecond)
diff --git a/Engine/lib/assimp/code/glTF/glTFExporter.h b/Engine/lib/assimp/code/glTF/glTFExporter.h
index 415992314..d6c2e7f04 100644
--- a/Engine/lib/assimp/code/glTF/glTFExporter.h
+++ b/Engine/lib/assimp/code/glTF/glTFExporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -90,7 +90,7 @@ namespace Assimp
 
         const char* mFilename;
         IOSystem* mIOSystem;
-        std::shared_ptr<const aiScene> mScene;
+        const aiScene* mScene;
         const ExportProperties* mProperties;
 
         std::map<std::string, unsigned int> mTexturesByPath;
diff --git a/Engine/lib/assimp/code/glTF/glTFImporter.cpp b/Engine/lib/assimp/code/glTF/glTFImporter.cpp
index b410e1002..9ecd742f6 100644
--- a/Engine/lib/assimp/code/glTF/glTFImporter.cpp
+++ b/Engine/lib/assimp/code/glTF/glTFImporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -54,7 +54,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/ai_assert.h>
 #include <assimp/DefaultLogger.hpp>
 #include <assimp/importerdesc.h>
-#include <assimp/commonMetaData.h>
 
 #include <memory>
 
@@ -171,8 +170,6 @@ void glTFImporter::ImportMaterials(glTF::Asset& r) {
 
     if (mScene->mNumMaterials == 0) {
         mScene->mNumMaterials = 1;
-        // Delete the array of length zero created above.
-        delete[] mScene->mMaterials;
         mScene->mMaterials = new aiMaterial*[1];
         mScene->mMaterials[0] = new aiMaterial();
     }
@@ -222,7 +219,6 @@ void glTFImporter::ImportMeshes(glTF::Asset& r)
     std::vector<aiMesh*> meshes;
 
     unsigned int k = 0;
-    meshOffsets.clear();
 
     for (unsigned int m = 0; m < r.meshes.Size(); ++m) {
         Mesh& mesh = r.meshes[m];
@@ -334,10 +330,6 @@ void glTFImporter::ImportMeshes(glTF::Asset& r)
 
                     case PrimitiveMode_LINES: {
                         nFaces = count / 2;
-                        if (nFaces * 2 != count) {
-                            ASSIMP_LOG_WARN("The number of vertices was not compatible with the LINES mode. Some vertices were dropped.");
-                            count = nFaces * 2;
-                        }
                         faces = new aiFace[nFaces];
                         for (unsigned int i = 0; i < count; i += 2) {
                             SetFace(faces[i / 2], data.GetUInt(i), data.GetUInt(i + 1));
@@ -361,10 +353,6 @@ void glTFImporter::ImportMeshes(glTF::Asset& r)
 
                     case PrimitiveMode_TRIANGLES: {
                         nFaces = count / 3;
-                        if (nFaces * 3 != count) {
-                            ASSIMP_LOG_WARN("The number of vertices was not compatible with the TRIANGLES mode. Some vertices were dropped.");
-                            count = nFaces * 3;
-                        }
                         faces = new aiFace[nFaces];
                         for (unsigned int i = 0; i < count; i += 3) {
                             SetFace(faces[i / 3], data.GetUInt(i), data.GetUInt(i + 1), data.GetUInt(i + 2));
@@ -407,10 +395,6 @@ void glTFImporter::ImportMeshes(glTF::Asset& r)
 
                 case PrimitiveMode_LINES: {
                     nFaces = count / 2;
-                    if (nFaces * 2 != count) {
-                        ASSIMP_LOG_WARN("The number of vertices was not compatible with the LINES mode. Some vertices were dropped.");
-                        count = nFaces * 2;
-                    }
                     faces = new aiFace[nFaces];
                     for (unsigned int i = 0; i < count; i += 2) {
                         SetFace(faces[i / 2], i, i + 1);
@@ -434,10 +418,6 @@ void glTFImporter::ImportMeshes(glTF::Asset& r)
 
                 case PrimitiveMode_TRIANGLES: {
                     nFaces = count / 3;
-                    if (nFaces * 3 != count) {
-                        ASSIMP_LOG_WARN("The number of vertices was not compatible with the TRIANGLES mode. Some vertices were dropped.");
-                        count = nFaces * 3;
-                    }
                     faces = new aiFace[nFaces];
                     for (unsigned int i = 0; i < count; i += 3) {
                         SetFace(faces[i / 3], i, i + 1, i + 2);
@@ -681,7 +661,6 @@ void glTFImporter::ImportEmbeddedTextures(glTF::Asset& r)
         size_t length = img.GetDataLength();
         void* data = img.StealData();
 
-        tex->mFilename = img.name;
         tex->mWidth = static_cast<unsigned int>(length);
         tex->mHeight = 0;
         tex->pcData = reinterpret_cast<aiTexel*>(data);
@@ -700,30 +679,6 @@ void glTFImporter::ImportEmbeddedTextures(glTF::Asset& r)
     }
 }
 
-void glTFImporter::ImportCommonMetadata(glTF::Asset& a)
-{
-    ai_assert(mScene->mMetaData == nullptr);
-    const bool hasVersion = !a.asset.version.empty();
-    const bool hasGenerator = !a.asset.generator.empty();
-    const bool hasCopyright = !a.asset.copyright.empty();
-    if (hasVersion || hasGenerator || hasCopyright)
-    {
-        mScene->mMetaData = new aiMetadata;
-        if (hasVersion)
-        {
-            mScene->mMetaData->Add(AI_METADATA_SOURCE_FORMAT_VERSION, aiString(a.asset.version));
-        }
-        if (hasGenerator)
-        {
-            mScene->mMetaData->Add(AI_METADATA_SOURCE_GENERATOR, aiString(a.asset.generator));
-        }
-        if (hasCopyright)
-        {
-            mScene->mMetaData->Add(AI_METADATA_SOURCE_COPYRIGHT, aiString(a.asset.copyright));
-        }
-    }
-}
-
 void glTFImporter::InternReadFile(const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler)
 {
     // clean all member arrays
@@ -750,7 +705,7 @@ void glTFImporter::InternReadFile(const std::string& pFile, aiScene* pScene, IOS
     ImportLights(asset);
 
     ImportNodes(asset);
-    ImportCommonMetadata(asset);
+
 
     if (pScene->mNumMeshes == 0) {
         pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
diff --git a/Engine/lib/assimp/code/glTF/glTFImporter.h b/Engine/lib/assimp/code/glTF/glTFImporter.h
index a1e746808..ce8a000dc 100644
--- a/Engine/lib/assimp/code/glTF/glTFImporter.h
+++ b/Engine/lib/assimp/code/glTF/glTFImporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -83,7 +83,7 @@ private:
     void ImportCameras(glTF::Asset& a);
     void ImportLights(glTF::Asset& a);
     void ImportNodes(glTF::Asset& a);
-    void ImportCommonMetadata(glTF::Asset& a);
+
 };
 
 } // Namespace assimp
diff --git a/Engine/lib/assimp/code/glTF2/glTF2Asset.h b/Engine/lib/assimp/code/glTF2/glTF2Asset.h
index d3c1654d0..15c4c44fa 100644
--- a/Engine/lib/assimp/code/glTF2/glTF2Asset.h
+++ b/Engine/lib/assimp/code/glTF2/glTF2Asset.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -198,7 +198,6 @@ namespace glTF2
     //! Values for the BufferView::target field
     enum BufferViewTarget
     {
-        BufferViewTarget_NONE = 0,
         BufferViewTarget_ARRAY_BUFFER = 34962,
         BufferViewTarget_ELEMENT_ARRAY_BUFFER = 34963
     };
@@ -388,8 +387,8 @@ namespace glTF2
         ComponentType componentType; //!< The datatype of components in the attribute. (required)
         size_t count;                //!< The number of attributes referenced by this accessor. (required)
         AttribType::Value type;      //!< Specifies if the attribute is a scalar, vector, or matrix. (required)
-        std::vector<double> max;     //!< Maximum value of each component in this attribute.
-        std::vector<double> min;     //!< Minimum value of each component in this attribute.
+        std::vector<float> max;      //!< Maximum value of each component in this attribute.
+        std::vector<float> min;      //!< Minimum value of each component in this attribute.
 
         unsigned int GetNumComponents();
         unsigned int GetBytesPerComponent();
@@ -686,13 +685,6 @@ namespace glTF2
         Ref<Texture> texture;
         unsigned int index;
         unsigned int texCoord = 0;
-
-        bool textureTransformSupported = false;
-        struct TextureTransformExt {
-			float offset[2];
-			float rotation;
-			float scale[2];
-		} TextureTransformExt_t;
     };
 
     struct NormalTextureInfo : TextureInfo
@@ -784,7 +776,7 @@ namespace glTF2
 		/// \fn void Read(Value& pJSON_Object, Asset& pAsset_Root)
 		/// Get mesh data from JSON-object and place them to root asset.
 		/// \param [in] pJSON_Object - reference to pJSON-object from which data are read.
-		/// \param [out] pAsset_Root - reference to root asset where data will be stored.
+		/// \param [out] pAsset_Root - reference to root assed where data will be stored.
 		void Read(Value& pJSON_Object, Asset& pAsset_Root);
     };
 
@@ -1032,14 +1024,8 @@ namespace glTF2
             bool KHR_materials_pbrSpecularGlossiness;
             bool KHR_materials_unlit;
             bool KHR_lights_punctual;
-			bool KHR_texture_transform;
-        } extensionsUsed;
 
-        //! Keeps info about the required extensions
-        struct RequiredExtensions
-        {
-            bool KHR_draco_mesh_compression;
-        } extensionsRequired;
+        } extensionsUsed;
 
         AssetMetadata asset;
 
@@ -1083,7 +1069,6 @@ namespace glTF2
             , textures      (*this, "textures")
         {
             memset(&extensionsUsed, 0, sizeof(extensionsUsed));
-            memset(&extensionsRequired, 0, sizeof(extensionsRequired));
         }
 
         //! Main function
@@ -1102,7 +1087,6 @@ namespace glTF2
         void ReadBinaryHeader(IOStream& stream, std::vector<char>& sceneData);
 
         void ReadExtensionsUsed(Document& doc);
-        void ReadExtensionsRequired(Document& doc);
 
         IOStream* OpenFile(std::string path, const char* mode, bool absolute = false);
     };
diff --git a/Engine/lib/assimp/code/glTF2/glTF2Asset.inl b/Engine/lib/assimp/code/glTF2/glTF2Asset.inl
index 35ecfa62d..6b47b1607 100644
--- a/Engine/lib/assimp/code/glTF2/glTF2Asset.inl
+++ b/Engine/lib/assimp/code/glTF2/glTF2Asset.inl
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -270,14 +270,13 @@ Ref<T> LazyDict<T>::Retrieve(unsigned int i)
         throw DeadlyImportError("GLTF: Object at index \"" + to_string(i) + "\" is not a JSON object");
     }
 
-    // Unique ptr prevents memory leak in case of Read throws an exception
-    auto inst = std::unique_ptr<T>(new T());
+    T* inst = new T();
     inst->id = std::string(mDictId) + "_" + to_string(i);
     inst->oIndex = i;
     ReadMember(obj, "name", inst->name);
     inst->Read(obj, mAsset);
 
-    return Add(inst.release());
+    return Add(inst);
 }
 
 template<class T>
@@ -384,7 +383,7 @@ inline void Buffer::Read(Value& obj, Asset& r)
     }
     else { // Local file
         if (byteLength > 0) {
-            std::string dir = !r.mCurrentAssetDir.empty() ? (r.mCurrentAssetDir) : "";
+            std::string dir = !r.mCurrentAssetDir.empty() ? (r.mCurrentAssetDir + "/") : "";
 
             IOStream* file = r.OpenFile(dir + uri, "rb");
             if (file) {
@@ -752,7 +751,6 @@ inline uint8_t* Image::StealData()
 	return mData.release();
 }
 
-// Never take over the ownership of data whenever binary or not
 inline void Image::SetData(uint8_t* data, size_t length, Asset& r)
 {
     Ref<Buffer> b = r.GetBodyBuffer();
@@ -765,10 +763,8 @@ inline void Image::SetData(uint8_t* data, size_t length, Asset& r)
         bufferView->byteOffset = b->AppendData(data, length);
     }
     else { // text file: will be stored as a data uri
-        uint8_t *temp = new uint8_t[length];
-        memcpy(temp, data, length);
-        this->mData.reset(temp);
-        this->mDataLength = length;
+		this->mData.reset(data);
+		this->mDataLength = length;
     }
 }
 
@@ -804,34 +800,8 @@ inline void Texture::Read(Value& obj, Asset& r)
 }
 
 namespace {
-    inline void SetTextureProperties(Asset& r, Value* prop, TextureInfo& out) {
-	    if (r.extensionsUsed.KHR_texture_transform) {
-            if (Value *extensions = FindObject(*prop, "extensions")) {
-				out.textureTransformSupported = true;
-                if (Value *pKHR_texture_transform = FindObject(*extensions, "KHR_texture_transform")) {
-					if (Value *array = FindArray(*pKHR_texture_transform, "offset")) {
-						out.TextureTransformExt_t.offset[0] = (*array)[0].GetFloat();
-						out.TextureTransformExt_t.offset[1] = (*array)[1].GetFloat();
-					} else {
-						out.TextureTransformExt_t.offset[0] = 0;
-						out.TextureTransformExt_t.offset[1] = 0;
-					}      
-					
-                    if (!ReadMember(*pKHR_texture_transform, "rotation", out.TextureTransformExt_t.rotation)) {
-						out.TextureTransformExt_t.rotation = 0;					
-                    }
-					
-                    if (Value *array = FindArray(*pKHR_texture_transform, "scale")) {
-						out.TextureTransformExt_t.scale[0] = (*array)[0].GetFloat();
-						out.TextureTransformExt_t.scale[1] = (*array)[1].GetFloat();
-					} else {
-						out.TextureTransformExt_t.scale[0] = 1;
-						out.TextureTransformExt_t.scale[1] = 1;
-                    }
-				}
-			}
-        }
-
+    inline void SetTextureProperties(Asset& r, Value* prop, TextureInfo& out)
+    {
         if (Value* index = FindUInt(*prop, "index")) {
             out.texture = r.textures.Retrieve(index->GetUint());
         }
@@ -907,9 +877,6 @@ inline void Material::Read(Value& material, Asset& r)
             }
         }
 
-        if (r.extensionsUsed.KHR_texture_transform) {
-		}
-
         unlit = nullptr != FindObject(*extensions, "KHR_materials_unlit");
     }
 }
@@ -1436,12 +1403,6 @@ inline void Asset::Load(const std::string& pFile, bool isBinary)
     // Load the metadata
     asset.Read(doc);
     ReadExtensionsUsed(doc);
-    ReadExtensionsRequired(doc);
-
-    // Currently Draco is not supported
-    if (extensionsRequired.KHR_draco_mesh_compression) {
-        throw DeadlyImportError("GLTF: Draco mesh compression not currently supported.");
-    }
 
     // Prepare the dictionaries
     for (size_t i = 0; i < mDicts.size(); ++i) {
@@ -1488,29 +1449,6 @@ inline void Asset::SetAsBinary()
     }
 }
 
-// As required extensions are only a concept in glTF 2.0, this is here
-// instead of glTFCommon.h
-#define CHECK_REQUIRED_EXT(EXT) \
-	if (exts.find(#EXT) != exts.end()) extensionsRequired.EXT = true;
-
-inline void Asset::ReadExtensionsRequired(Document& doc)
-{
-    Value* extsRequired = FindArray(doc, "extensionsRequired");
-    if (nullptr == extsRequired) {
-	return;
-    }
-
-    std::gltf_unordered_map<std::string, bool> exts;
-    for (unsigned int i = 0; i < extsRequired->Size(); ++i) {
-        if ((*extsRequired)[i].IsString()) {
-            exts[(*extsRequired)[i].GetString()] = true;
-        }
-    }
-
-    CHECK_REQUIRED_EXT(KHR_draco_mesh_compression);
-
-    #undef CHECK_REQUIRED_EXT
-}
 
 inline void Asset::ReadExtensionsUsed(Document& doc)
 {
@@ -1525,10 +1463,12 @@ inline void Asset::ReadExtensionsUsed(Document& doc)
         }
     }
 
+    #define CHECK_EXT(EXT) \
+        if (exts.find(#EXT) != exts.end()) extensionsUsed.EXT = true;
+
     CHECK_EXT(KHR_materials_pbrSpecularGlossiness);
     CHECK_EXT(KHR_materials_unlit);
     CHECK_EXT(KHR_lights_punctual);
-	CHECK_EXT(KHR_texture_transform);
 
     #undef CHECK_EXT
 }
diff --git a/Engine/lib/assimp/code/glTF2/glTF2AssetWriter.h b/Engine/lib/assimp/code/glTF2/glTF2AssetWriter.h
index 784ab2ea5..928b6e71b 100644
--- a/Engine/lib/assimp/code/glTF2/glTF2AssetWriter.h
+++ b/Engine/lib/assimp/code/glTF2/glTF2AssetWriter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/glTF2/glTF2AssetWriter.inl b/Engine/lib/assimp/code/glTF2/glTF2AssetWriter.inl
index 8f99ed008..5d1b22064 100644
--- a/Engine/lib/assimp/code/glTF2/glTF2AssetWriter.inl
+++ b/Engine/lib/assimp/code/glTF2/glTF2AssetWriter.inl
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -54,8 +54,8 @@ namespace glTF2 {
 
     namespace {
 
-        template<typename T, size_t N>
-        inline Value& MakeValue(Value& val, T(&r)[N], MemoryPoolAllocator<>& al) {
+        template<size_t N>
+        inline Value& MakeValue(Value& val, float(&r)[N], MemoryPoolAllocator<>& al) {
             val.SetArray();
             val.Reserve(N, al);
             for (decltype(N) i = 0; i < N; ++i) {
@@ -64,8 +64,7 @@ namespace glTF2 {
             return val;
         }
 
-        template<typename T>
-        inline Value& MakeValue(Value& val, const std::vector<T> & r, MemoryPoolAllocator<>& al) {
+        inline Value& MakeValue(Value& val, const std::vector<float> & r, MemoryPoolAllocator<>& al) {
             val.SetArray();
             val.Reserve(static_cast<rapidjson::SizeType>(r.size()), al);
             for (unsigned int i = 0; i < r.size(); ++i) {
@@ -74,19 +73,8 @@ namespace glTF2 {
             return val;
         }
 
-        template<typename C, typename T>
-        inline Value& MakeValueCast(Value& val, const std::vector<T> & r, MemoryPoolAllocator<>& al) {
-            val.SetArray();
-            val.Reserve(static_cast<rapidjson::SizeType>(r.size()), al);
-            for (unsigned int i = 0; i < r.size(); ++i) {
-                val.PushBack(static_cast<C>(r[i]), al);
-            }
-            return val;
-        }
-
-        template<typename T>
-        inline Value& MakeValue(Value& val, T r, MemoryPoolAllocator<>& /*al*/) {
-            val.Set(r);
+        inline Value& MakeValue(Value& val, float r, MemoryPoolAllocator<>& /*al*/) {
+            val.SetDouble(r);
 
             return val;
         }
@@ -116,13 +104,8 @@ namespace glTF2 {
         obj.AddMember("type", StringRef(AttribType::ToString(a.type)), w.mAl);
 
         Value vTmpMax, vTmpMin;
-		if (a.componentType == ComponentType_FLOAT) {
-			obj.AddMember("max", MakeValue(vTmpMax, a.max, w.mAl), w.mAl);
-			obj.AddMember("min", MakeValue(vTmpMin, a.min, w.mAl), w.mAl);
-		} else {
-			obj.AddMember("max", MakeValueCast<int64_t>(vTmpMax, a.max, w.mAl), w.mAl);
-			obj.AddMember("min", MakeValueCast<int64_t>(vTmpMin, a.min, w.mAl), w.mAl);
-		}
+        obj.AddMember("max", MakeValue(vTmpMax, a.max, w.mAl), w.mAl);
+        obj.AddMember("min", MakeValue(vTmpMin, a.min, w.mAl), w.mAl);
     }
 
     inline void Write(Value& obj, Animation& a, AssetWriter& w)
@@ -176,13 +159,13 @@ namespace glTF2 {
                 valSampler.AddMember("input", s.input->index, w.mAl);
                 switch (s.interpolation) {
                     case Interpolation_LINEAR:
-                        valSampler.AddMember("interpolation", "LINEAR", w.mAl);
+                        valSampler.AddMember("path", "LINEAR", w.mAl);
                         break;
                     case Interpolation_STEP:
-                        valSampler.AddMember("interpolation", "STEP", w.mAl);
+                        valSampler.AddMember("path", "STEP", w.mAl);
                         break;
                     case Interpolation_CUBICSPLINE:
-                        valSampler.AddMember("interpolation", "CUBICSPLINE", w.mAl);
+                        valSampler.AddMember("path", "CUBICSPLINE", w.mAl);
                         break;
                 }
                 valSampler.AddMember("output", s.output->index, w.mAl);
@@ -209,7 +192,7 @@ namespace glTF2 {
         if (bv.byteStride != 0) {
             obj.AddMember("byteStride", bv.byteStride, w.mAl);
         }
-        if (bv.target != BufferViewTarget_NONE) {
+        if (bv.target != 0) {
             obj.AddMember("target", int(bv.target), w.mAl);
         }
     }
@@ -375,7 +358,7 @@ namespace glTF2 {
             WriteVec(pbrSpecularGlossiness, pbrSG.specularFactor, "specularFactor", defaultSpecularFactor, w.mAl);
 
             if (pbrSG.glossinessFactor != 1) {
-                WriteFloat(pbrSpecularGlossiness, pbrSG.glossinessFactor, "glossinessFactor", w.mAl);
+                WriteFloat(obj, pbrSG.glossinessFactor, "glossinessFactor", w.mAl);
             }
 
             WriteTex(pbrSpecularGlossiness, pbrSG.diffuseTexture, "diffuseTexture", w.mAl);
@@ -446,24 +429,6 @@ namespace glTF2 {
                     WriteAttrs(w, attrs, p.attributes.weight, "WEIGHTS", true);
                 }
                 prim.AddMember("attributes", attrs, w.mAl);
-
-                // targets for blendshapes
-                if (p.targets.size() > 0) {
-                    Value tjs;
-                    tjs.SetArray();
-                    tjs.Reserve(unsigned(p.targets.size()), w.mAl);
-                    for (unsigned int t = 0; t < p.targets.size(); ++t) {
-                        Value tj;
-                        tj.SetObject();
-                        {
-                            WriteAttrs(w, tj, p.targets[t].position, "POSITION");
-                            WriteAttrs(w, tj, p.targets[t].normal, "NORMAL");
-                            WriteAttrs(w, tj, p.targets[t].tangent, "TANGENT");
-                        }
-                        tjs.PushBack(tj, w.mAl);
-                    }
-                    prim.AddMember("targets", tjs, w.mAl);
-                }
             }
             primitives.PushBack(prim, w.mAl);
         }
@@ -738,8 +703,6 @@ namespace glTF2 {
         asset.SetObject();
         asset.AddMember("version", Value(mAsset.asset.version, mAl).Move(), mAl);
         asset.AddMember("generator", Value(mAsset.asset.generator, mAl).Move(), mAl);
-        if (!mAsset.asset.copyright.empty())
-            asset.AddMember("copyright", Value(mAsset.asset.copyright, mAl).Move(), mAl);
         mDoc.AddMember("asset", asset, mAl);
     }
 
diff --git a/Engine/lib/assimp/code/glTF2/glTF2Exporter.cpp b/Engine/lib/assimp/code/glTF2/glTF2Exporter.cpp
index 7894f8adb..4724c2ef4 100644
--- a/Engine/lib/assimp/code/glTF2/glTF2Exporter.cpp
+++ b/Engine/lib/assimp/code/glTF2/glTF2Exporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -46,7 +46,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "glTF2/glTF2AssetWriter.h"
 #include "PostProcessing/SplitLargeMeshes.h"
 
-#include <assimp/commonMetaData.h>
 #include <assimp/Exceptional.h>
 #include <assimp/StringComparison.h>
 #include <assimp/ByteSwapper.h>
@@ -59,7 +58,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // Header files, standard library.
 #include <memory>
-#include <limits>
 #include <inttypes.h>
 
 using namespace rapidjson;
@@ -141,7 +139,10 @@ static void CopyValue(const aiMatrix4x4& v, mat4& o) {
 }
 
 static void CopyValue(const aiMatrix4x4& v, aiMatrix4x4& o) {
-    memcpy(&o, &v, sizeof(aiMatrix4x4));
+    o.a1 = v.a1; o.a2 = v.a2; o.a3 = v.a3; o.a4 = v.a4;
+    o.b1 = v.b1; o.b2 = v.b2; o.b3 = v.b3; o.b4 = v.b4;
+    o.c1 = v.c1; o.c2 = v.c2; o.c3 = v.c3; o.c4 = v.c4;
+    o.d1 = v.d1; o.d2 = v.d2; o.d3 = v.d3; o.d4 = v.d4;
 }
 
 static void IdentityMatrix4(mat4& o) {
@@ -151,64 +152,8 @@ static void IdentityMatrix4(mat4& o) {
     o[12] = 0; o[13] = 0; o[14] = 0; o[15] = 1;
 }
 
-template<typename T>
-void SetAccessorRange(Ref<Accessor> acc, void* data, size_t count,
-	unsigned int numCompsIn, unsigned int numCompsOut)
-{
-	ai_assert(numCompsOut <= numCompsIn);
-
-	// Allocate and initialize with large values.
-	for (unsigned int i = 0 ; i < numCompsOut ; i++) {
-		acc->min.push_back( std::numeric_limits<double>::max());
-		acc->max.push_back(-std::numeric_limits<double>::max());
-	}
-
-	size_t totalComps = count * numCompsIn;
-	T* buffer_ptr = static_cast<T*>(data);
-	T* buffer_end = buffer_ptr + totalComps;
-
-	// Search and set extreme values.
-	for (; buffer_ptr < buffer_end ; buffer_ptr += numCompsIn) {
-		for (unsigned int j = 0 ; j < numCompsOut ; j++) {
-			double valueTmp = buffer_ptr[j];
-
-			if (valueTmp < acc->min[j]) {
-				acc->min[j] = valueTmp;
-			}
-			if (valueTmp > acc->max[j]) {
-				acc->max[j] = valueTmp;
-			}
-		}
-	}
-}
-
-inline void SetAccessorRange(ComponentType compType, Ref<Accessor> acc, void* data,
-		size_t count, unsigned int numCompsIn, unsigned int numCompsOut)
-{
-	switch (compType) {
-		case ComponentType_SHORT:
-			SetAccessorRange<short>(acc, data, count, numCompsIn, numCompsOut);
-			return;
-		case ComponentType_UNSIGNED_SHORT:
-			SetAccessorRange<unsigned short>(acc, data, count, numCompsIn, numCompsOut);
-			return;
-		case ComponentType_UNSIGNED_INT:
-			SetAccessorRange<unsigned int>(acc, data, count, numCompsIn, numCompsOut);
-			return;
-		case ComponentType_FLOAT:
-			SetAccessorRange<float>(acc, data, count, numCompsIn, numCompsOut);
-			return;
-		case ComponentType_BYTE:
-			SetAccessorRange<int8_t>(acc, data, count, numCompsIn, numCompsOut);
-			return;
-		case ComponentType_UNSIGNED_BYTE:
-			SetAccessorRange<uint8_t>(acc, data, count, numCompsIn, numCompsOut);
-			return;
-	}
-}
-
 inline Ref<Accessor> ExportData(Asset& a, std::string& meshName, Ref<Buffer>& buffer,
-    size_t count, void* data, AttribType::Value typeIn, AttribType::Value typeOut, ComponentType compType, BufferViewTarget target = BufferViewTarget_NONE)
+    size_t count, void* data, AttribType::Value typeIn, AttribType::Value typeOut, ComponentType compType, bool isIndices = false)
 {
     if (!count || !data) {
         return Ref<Accessor>();
@@ -231,7 +176,7 @@ inline Ref<Accessor> ExportData(Asset& a, std::string& meshName, Ref<Buffer>& bu
     bv->byteOffset = offset;
     bv->byteLength = length; //! The target that the WebGL buffer should be bound to.
     bv->byteStride = 0;
-    bv->target = target;
+    bv->target = isIndices ? BufferViewTarget_ELEMENT_ARRAY_BUFFER : BufferViewTarget_ARRAY_BUFFER;
 
     // accessor
     Ref<Accessor> acc = a.accessors.Create(a.FindUniqueID(meshName, "accessor"));
@@ -242,7 +187,33 @@ inline Ref<Accessor> ExportData(Asset& a, std::string& meshName, Ref<Buffer>& bu
     acc->type = typeOut;
 
     // calculate min and max values
-	SetAccessorRange(compType, acc, data, count, numCompsIn, numCompsOut);
+    {
+        // Allocate and initialize with large values.
+        float float_MAX = 10000000000000.0f;
+        for (unsigned int i = 0 ; i < numCompsOut ; i++) {
+            acc->min.push_back( float_MAX);
+            acc->max.push_back(-float_MAX);
+        }
+
+        // Search and set extreme values.
+        float valueTmp;
+        for (unsigned int i = 0 ; i < count       ; i++) {
+            for (unsigned int j = 0 ; j < numCompsOut ; j++) {
+                if (numCompsOut == 1) {
+                  valueTmp = static_cast<unsigned short*>(data)[i];
+                } else {
+                  valueTmp = static_cast<aiVector3D*>(data)[i][j];
+                }
+
+                if (valueTmp < acc->min[j]) {
+                    acc->min[j] = valueTmp;
+                }
+                if (valueTmp > acc->max[j]) {
+                    acc->max[j] = valueTmp;
+                }
+            }
+        }
+    }
 
     // copy the data
     acc->WriteData(count, data, numCompsIn*bytesPerComp);
@@ -348,11 +319,9 @@ void glTF2Exporter::GetMatTex(const aiMaterial* mat, Ref<Texture>& texture, aiTe
 
                     if (path[0] == '*') { // embedded
                         aiTexture* tex = mScene->mTextures[atoi(&path[1])];
-						
-                        texture->source->name = tex->mFilename.C_Str();
 
-                        // The asset has its own buffer, see Image::SetData
-                        texture->source->SetData(reinterpret_cast<uint8_t*> (tex->pcData), tex->mWidth, *mAsset);
+                        uint8_t* data = reinterpret_cast<uint8_t*>(tex->pcData);
+                        texture->source->SetData(data, tex->mWidth, *mAsset);
 
                         if (tex->achFormatHint[0]) {
                             std::string mimeType = "image/";
@@ -744,7 +713,7 @@ void glTF2Exporter::ExportMeshes()
         p.material = mAsset->materials.Get(aim->mMaterialIndex);
 
 		/******************* Vertices ********************/
-		Ref<Accessor> v = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mVertices, AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT, BufferViewTarget_ARRAY_BUFFER);
+        Ref<Accessor> v = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mVertices, AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT);
 		if (v) p.attributes.position.push_back(v);
 
 		/******************** Normals ********************/
@@ -755,7 +724,7 @@ void glTF2Exporter::ExportMeshes()
             }
         }
 
-		Ref<Accessor> n = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mNormals, AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT, BufferViewTarget_ARRAY_BUFFER);
+		Ref<Accessor> n = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mNormals, AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT);
         if (n) p.attributes.normal.push_back(n);
 
 		/************** Texture coordinates **************/
@@ -773,14 +742,14 @@ void glTF2Exporter::ExportMeshes()
             if (aim->mNumUVComponents[i] > 0) {
                 AttribType::Value type = (aim->mNumUVComponents[i] == 2) ? AttribType::VEC2 : AttribType::VEC3;
 
-				Ref<Accessor> tc = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mTextureCoords[i], AttribType::VEC3, type, ComponentType_FLOAT, BufferViewTarget_ARRAY_BUFFER);
+				Ref<Accessor> tc = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mTextureCoords[i], AttribType::VEC3, type, ComponentType_FLOAT, false);
 				if (tc) p.attributes.texcoord.push_back(tc);
 			}
 		}
 
 		/*************** Vertex colors ****************/
 		for (unsigned int indexColorChannel = 0; indexColorChannel < aim->GetNumColorChannels(); ++indexColorChannel) {
-			Ref<Accessor> c = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mColors[indexColorChannel], AttribType::VEC4, AttribType::VEC4, ComponentType_FLOAT, BufferViewTarget_ARRAY_BUFFER);
+			Ref<Accessor> c = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mColors[indexColorChannel], AttribType::VEC4, AttribType::VEC4, ComponentType_FLOAT, false);
 			if (c)
 				p.attributes.color.push_back(c);
 		}
@@ -796,7 +765,7 @@ void glTF2Exporter::ExportMeshes()
                 }
             }
 
-			p.indices = ExportData(*mAsset, meshId, b, indices.size(), &indices[0], AttribType::SCALAR, AttribType::SCALAR, ComponentType_UNSIGNED_INT, BufferViewTarget_ELEMENT_ARRAY_BUFFER);
+			p.indices = ExportData(*mAsset, meshId, b, indices.size(), &indices[0], AttribType::SCALAR, AttribType::SCALAR, ComponentType_UNSIGNED_INT, true);
 		}
 
         switch (aim->mPrimitiveTypes) {
@@ -814,47 +783,6 @@ void glTF2Exporter::ExportMeshes()
         if(aim->HasBones()) {
             ExportSkin(*mAsset, aim, m, b, skinRef, inverseBindMatricesData);
         }
-
-        /*************** Targets for blendshapes ****************/
-        if (aim->mNumAnimMeshes > 0) {
-            p.targets.resize(aim->mNumAnimMeshes);
-            for (unsigned int am = 0; am < aim->mNumAnimMeshes; ++am) {
-                aiAnimMesh *pAnimMesh = aim->mAnimMeshes[am];
-
-                // position
-                if (pAnimMesh->HasPositions()) {
-                    // NOTE: in gltf it is the diff stored
-                    aiVector3D *pPositionDiff = new aiVector3D[pAnimMesh->mNumVertices];
-                    for (unsigned int vt = 0; vt < pAnimMesh->mNumVertices; ++vt) {
-                        pPositionDiff[vt] = pAnimMesh->mVertices[vt] - aim->mVertices[vt];
-                    }
-                    Ref<Accessor> v = ExportData(*mAsset, meshId, b,
-                            pAnimMesh->mNumVertices, pPositionDiff,
-                            AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT);
-                    if (v) {
-                        p.targets[am].position.push_back(v);
-                    }
-                    delete[] pPositionDiff;
-                }
-
-                // normal
-                if (pAnimMesh->HasNormals()) {
-                    aiVector3D *pNormalDiff = new aiVector3D[pAnimMesh->mNumVertices];
-                    for (unsigned int vt = 0; vt < pAnimMesh->mNumVertices; ++vt) {
-                        pNormalDiff[vt] = pAnimMesh->mNormals[vt] - aim->mNormals[vt];
-                    }
-                    Ref<Accessor> v = ExportData(*mAsset, meshId, b,
-                            pAnimMesh->mNumVertices, pNormalDiff,
-                            AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT);
-                    if (v) {
-                        p.targets[am].normal.push_back(v);
-                    }
-                    delete[] pNormalDiff;
-                }
-
-                // tangent?
-            }
-        }
     }
 
     //----------------------------------------
@@ -994,27 +922,8 @@ unsigned int glTF2Exporter::ExportNode(const aiNode* n, Ref<Node>& parent)
     node->name = name;
 
     if (!n->mTransformation.IsIdentity()) {
-		if (mScene->mNumAnimations > 0) {
-			aiQuaternion quaternion;
-			n->mTransformation.Decompose(*reinterpret_cast<aiVector3D *>(&node->scale.value), quaternion, *reinterpret_cast<aiVector3D *>(&node->translation.value));
-
-			aiVector3D vector(static_cast<ai_real>(1.0f), static_cast<ai_real>(1.0f), static_cast<ai_real>(1.0f));
-			if (!reinterpret_cast<aiVector3D *>(&node->scale.value)->Equal(vector)) {
-				node->scale.isPresent = true;
-			}
-			if (!reinterpret_cast<aiVector3D *>(&node->translation.value)->Equal(vector)) {
-				node->translation.isPresent = true;
-			}
-			node->rotation.isPresent = true;
-			node->rotation.value[0] = quaternion.x;
-			node->rotation.value[1] = quaternion.y;
-			node->rotation.value[2] = quaternion.z;
-			node->rotation.value[3] = quaternion.w;
-			node->matrix.isPresent = false;
-		} else {
-			node->matrix.isPresent = true;
-			CopyValue(n->mTransformation, node->matrix.value);
-		}
+        node->matrix.isPresent = true;
+        CopyValue(n->mTransformation, node->matrix.value);
     }
 
     for (unsigned int i = 0; i < n->mNumMeshes; ++i) {
@@ -1050,16 +959,10 @@ void glTF2Exporter::ExportMetadata()
     asset.version = "2.0";
 
     char buffer[256];
-    ai_snprintf(buffer, 256, "Open Asset Import Library (assimp v%d.%d.%x)",
+    ai_snprintf(buffer, 256, "Open Asset Import Library (assimp v%d.%d.%d)",
         aiGetVersionMajor(), aiGetVersionMinor(), aiGetVersionRevision());
 
     asset.generator = buffer;
-
-    // Copyright
-	aiString copyright_str;
-	if (mScene->mMetaData != nullptr && mScene->mMetaData->Get(AI_METADATA_SOURCE_COPYRIGHT, copyright_str)) {
-        asset.copyright = copyright_str.C_Str();
-	}
 }
 
 inline Ref<Accessor> GetSamplerInputRef(Asset& asset, std::string& animId, Ref<Buffer>& buffer, std::vector<float>& times)
diff --git a/Engine/lib/assimp/code/glTF2/glTF2Exporter.h b/Engine/lib/assimp/code/glTF2/glTF2Exporter.h
index 421a4806e..2dc083709 100644
--- a/Engine/lib/assimp/code/glTF2/glTF2Exporter.h
+++ b/Engine/lib/assimp/code/glTF2/glTF2Exporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -74,7 +74,6 @@ namespace glTF2
     struct Texture;
 
     // Vec/matrix types, as raw float arrays
-	typedef float (vec2)[2];
     typedef float (vec3)[3];
     typedef float (vec4)[4];
 }
diff --git a/Engine/lib/assimp/code/glTF2/glTF2Importer.cpp b/Engine/lib/assimp/code/glTF2/glTF2Importer.cpp
index 8c33674e1..82c6cbfa8 100644
--- a/Engine/lib/assimp/code/glTF2/glTF2Importer.cpp
+++ b/Engine/lib/assimp/code/glTF2/glTF2Importer.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -43,19 +43,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_GLTF_IMPORTER
 
 #include "glTF2/glTF2Importer.h"
-#include "PostProcessing/MakeVerboseFormat.h"
 #include "glTF2/glTF2Asset.h"
 #include "glTF2/glTF2AssetWriter.h"
+#include "PostProcessing/MakeVerboseFormat.h"
 
-#include <assimp/CreateAnimMesh.h>
 #include <assimp/StringComparison.h>
 #include <assimp/StringUtils.h>
-#include <assimp/ai_assert.h>
-#include <assimp/importerdesc.h>
-#include <assimp/scene.h>
-#include <assimp/DefaultLogger.hpp>
 #include <assimp/Importer.hpp>
-#include <assimp/commonMetaData.h>
+#include <assimp/scene.h>
+#include <assimp/ai_assert.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/importerdesc.h>
+#include <assimp/CreateAnimMesh.h>
 
 #include <memory>
 #include <unordered_map>
@@ -68,11 +67,11 @@ using namespace glTF2;
 using namespace glTFCommon;
 
 namespace {
-// generate bi-tangents from normals and tangents according to spec
-struct Tangent {
-	aiVector3D xyz;
-	ai_real w;
-};
+    // generate bi-tangents from normals and tangents according to spec
+    struct Tangent {
+        aiVector3D xyz;
+        ai_real w;
+    };
 } // namespace
 
 //
@@ -80,1259 +79,1187 @@ struct Tangent {
 //
 
 static const aiImporterDesc desc = {
-	"glTF2 Importer",
-	"",
-	"",
-	"",
-	aiImporterFlags_SupportTextFlavour | aiImporterFlags_SupportBinaryFlavour | aiImporterFlags_LimitedSupport | aiImporterFlags_Experimental,
-	0,
-	0,
-	0,
-	0,
-	"gltf glb"
+    "glTF2 Importer",
+    "",
+    "",
+    "",
+    aiImporterFlags_SupportTextFlavour | aiImporterFlags_SupportBinaryFlavour | aiImporterFlags_LimitedSupport | aiImporterFlags_Experimental,
+    0,
+    0,
+    0,
+    0,
+    "gltf glb"
 };
 
-glTF2Importer::glTF2Importer() :
-		BaseImporter(),
-		meshOffsets(),
-		embeddedTexIdxs(),
-		mScene(NULL) {
-	// empty
+glTF2Importer::glTF2Importer()
+: BaseImporter()
+, meshOffsets()
+, embeddedTexIdxs()
+, mScene( NULL ) {
+    // empty
 }
 
 glTF2Importer::~glTF2Importer() {
-	// empty
+    // empty
 }
 
-const aiImporterDesc *glTF2Importer::GetInfo() const {
-	return &desc;
+const aiImporterDesc* glTF2Importer::GetInfo() const
+{
+    return &desc;
 }
 
-bool glTF2Importer::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /* checkSig */) const {
-	const std::string &extension = GetExtension(pFile);
+bool glTF2Importer::CanRead(const std::string& pFile, IOSystem* pIOHandler, bool /* checkSig */) const
+{
+    const std::string &extension = GetExtension(pFile);
 
-	if (extension != "gltf" && extension != "glb") {
-		return false;
-	}
+    if (extension != "gltf" && extension != "glb")
+        return false;
 
-	if (pIOHandler) {
-		glTF2::Asset asset(pIOHandler);
-		asset.Load(pFile, extension == "glb");
-		std::string version = asset.asset.version;
-		return !version.empty() && version[0] == '2';
-	}
+    if (pIOHandler) {
+        glTF2::Asset asset(pIOHandler);
+        asset.Load(pFile, extension == "glb");
+        std::string version = asset.asset.version;
+        return !version.empty() && version[0] == '2';
+    }
 
-	return false;
+    return false;
 }
 
-static aiTextureMapMode ConvertWrappingMode(SamplerWrap gltfWrapMode) {
-	switch (gltfWrapMode) {
-		case SamplerWrap::Mirrored_Repeat:
-			return aiTextureMapMode_Mirror;
+static aiTextureMapMode ConvertWrappingMode(SamplerWrap gltfWrapMode)
+{
+    switch (gltfWrapMode) {
+        case SamplerWrap::Mirrored_Repeat:
+            return aiTextureMapMode_Mirror;
 
-		case SamplerWrap::Clamp_To_Edge:
-			return aiTextureMapMode_Clamp;
+        case SamplerWrap::Clamp_To_Edge:
+            return aiTextureMapMode_Clamp;
 
-		case SamplerWrap::UNSET:
-		case SamplerWrap::Repeat:
-		default:
-			return aiTextureMapMode_Wrap;
-	}
+        case SamplerWrap::UNSET:
+        case SamplerWrap::Repeat:
+        default:
+            return aiTextureMapMode_Wrap;
+    }
 }
 
-inline void SetMaterialColorProperty(Asset & /*r*/, vec4 &prop, aiMaterial *mat, const char *pKey, unsigned int type, unsigned int idx) {
-	aiColor4D col;
-	CopyValue(prop, col);
-	mat->AddProperty(&col, 1, pKey, type, idx);
+/*static void CopyValue(const glTF2::vec3& v, aiColor3D& out)
+{
+    out.r = v[0]; out.g = v[1]; out.b = v[2];
 }
 
-inline void SetMaterialColorProperty(Asset & /*r*/, vec3 &prop, aiMaterial *mat, const char *pKey, unsigned int type, unsigned int idx) {
-	aiColor4D col;
-	glTFCommon::CopyValue(prop, col);
-	mat->AddProperty(&col, 1, pKey, type, idx);
+
+static void CopyValue(const glTF2::vec4& v, aiColor4D& out)
+{
+    out.r = v[0]; out.g = v[1]; out.b = v[2]; out.a = v[3];
+}*/
+
+/*static void CopyValue(const glTF2::vec4& v, aiColor3D& out)
+{
+    out.r = v[0]; out.g = v[1]; out.b = v[2];
+}*/
+
+/*static void CopyValue(const glTF2::vec3& v, aiColor4D& out)
+{
+    out.r = v[0]; out.g = v[1]; out.b = v[2]; out.a = 1.0;
 }
 
-inline void SetMaterialTextureProperty(std::vector<int> &embeddedTexIdxs, Asset & /*r*/, glTF2::TextureInfo prop, aiMaterial *mat, aiTextureType texType, unsigned int texSlot = 0) {
-	if (prop.texture && prop.texture->source) {
-		aiString uri(prop.texture->source->uri);
+static void CopyValue(const glTF2::vec3& v, aiVector3D& out)
+{
+    out.x = v[0]; out.y = v[1]; out.z = v[2];
+}
 
-		int texIdx = embeddedTexIdxs[prop.texture->source.GetIndex()];
-		if (texIdx != -1) { // embedded
-			// setup texture reference string (copied from ColladaLoader::FindFilenameForEffectTexture)
-			uri.data[0] = '*';
-			uri.length = 1 + ASSIMP_itoa10(uri.data + 1, MAXLEN - 1, texIdx);
-		}
+static void CopyValue(const glTF2::vec4& v, aiQuaternion& out)
+{
+    out.x = v[0]; out.y = v[1]; out.z = v[2]; out.w = v[3];
+}*/
+
+/*static void CopyValue(const glTF2::mat4& v, aiMatrix4x4& o)
+{
+    o.a1 = v[ 0]; o.b1 = v[ 1]; o.c1 = v[ 2]; o.d1 = v[ 3];
+    o.a2 = v[ 4]; o.b2 = v[ 5]; o.c2 = v[ 6]; o.d2 = v[ 7];
+    o.a3 = v[ 8]; o.b3 = v[ 9]; o.c3 = v[10]; o.d3 = v[11];
+    o.a4 = v[12]; o.b4 = v[13]; o.c4 = v[14]; o.d4 = v[15];
+}*/
+
+inline void SetMaterialColorProperty(Asset& /*r*/, vec4& prop, aiMaterial* mat, const char* pKey, unsigned int type, unsigned int idx)
+{
+    aiColor4D col;
+    CopyValue(prop, col);
+    mat->AddProperty(&col, 1, pKey, type, idx);
+}
+
+inline void SetMaterialColorProperty(Asset& /*r*/, vec3& prop, aiMaterial* mat, const char* pKey, unsigned int type, unsigned int idx)
+{
+    aiColor4D col;
+    glTFCommon::CopyValue(prop, col);
+    mat->AddProperty(&col, 1, pKey, type, idx);
+}
+
+inline void SetMaterialTextureProperty(std::vector<int>& embeddedTexIdxs, Asset& /*r*/, glTF2::TextureInfo prop, aiMaterial* mat, aiTextureType texType, unsigned int texSlot = 0)
+{
+    if (prop.texture && prop.texture->source) {
+        aiString uri(prop.texture->source->uri);
+
+        int texIdx = embeddedTexIdxs[prop.texture->source.GetIndex()];
+        if (texIdx != -1) { // embedded
+            // setup texture reference string (copied from ColladaLoader::FindFilenameForEffectTexture)
+            uri.data[0] = '*';
+            uri.length = 1 + ASSIMP_itoa10(uri.data + 1, MAXLEN - 1, texIdx);
+        }
 
         mat->AddProperty(&uri, AI_MATKEY_TEXTURE(texType, texSlot));
-        mat->AddProperty(&prop.texCoord, 1, AI_MATKEY_GLTF_TEXTURE_TEXCOORD(texType, texSlot));
+        mat->AddProperty(&prop.texCoord, 1, _AI_MATKEY_GLTF_TEXTURE_TEXCOORD_BASE, texType, texSlot);
 
-		if (prop.textureTransformSupported) {
-			aiUVTransform transform;
-			transform.mScaling.x = prop.TextureTransformExt_t.scale[0];
-			transform.mScaling.y = prop.TextureTransformExt_t.scale[1];
-			transform.mRotation = -prop.TextureTransformExt_t.rotation; // must be negated
+        if (prop.texture->sampler) {
+            Ref<Sampler> sampler = prop.texture->sampler;
 
-			// A change of coordinates is required to map glTF UV transformations into the space used by
-			// Assimp. In glTF all UV origins are at 0,1 (top left of texture) in Assimp space. In Assimp
-			// rotation occurs around the image center (0.5,0.5) where as in glTF rotation is around the
-			// texture origin. All three can be corrected for solely by a change of the translation since
-			// the transformations available are shape preserving. Note the importer already flips the V
-			// coordinate of the actual meshes during import.
-			const ai_real rcos(cos(-transform.mRotation));
-			const ai_real rsin(sin(-transform.mRotation));
-			transform.mTranslation.x = (static_cast<ai_real>( 0.5 ) * transform.mScaling.x) * (-rcos + rsin + 1) + prop.TextureTransformExt_t.offset[0];
-			transform.mTranslation.y = ((static_cast<ai_real>( 0.5 ) * transform.mScaling.y) * (rsin + rcos - 1)) + 1 - transform.mScaling.y - prop.TextureTransformExt_t.offset[1];;
+            aiString name(sampler->name);
+            aiString id(sampler->id);
 
-			mat->AddProperty(&transform, 1, _AI_MATKEY_UVTRANSFORM_BASE, texType, texSlot);
-		}
+            mat->AddProperty(&name, AI_MATKEY_GLTF_MAPPINGNAME(texType, texSlot));
+            mat->AddProperty(&id, AI_MATKEY_GLTF_MAPPINGID(texType, texSlot));
 
-		if (prop.texture->sampler) {
-			Ref<Sampler> sampler = prop.texture->sampler;
+            aiTextureMapMode wrapS = ConvertWrappingMode(sampler->wrapS);
+            aiTextureMapMode wrapT = ConvertWrappingMode(sampler->wrapT);
+            mat->AddProperty(&wrapS, 1, AI_MATKEY_MAPPINGMODE_U(texType, texSlot));
+            mat->AddProperty(&wrapT, 1, AI_MATKEY_MAPPINGMODE_V(texType, texSlot));
 
-			aiString name(sampler->name);
-			aiString id(sampler->id);
+            if (sampler->magFilter != SamplerMagFilter::UNSET) {
+                mat->AddProperty(&sampler->magFilter, 1, AI_MATKEY_GLTF_MAPPINGFILTER_MAG(texType, texSlot));
+            }
 
-			mat->AddProperty(&name, AI_MATKEY_GLTF_MAPPINGNAME(texType, texSlot));
-			mat->AddProperty(&id, AI_MATKEY_GLTF_MAPPINGID(texType, texSlot));
-
-			aiTextureMapMode wrapS = ConvertWrappingMode(sampler->wrapS);
-			aiTextureMapMode wrapT = ConvertWrappingMode(sampler->wrapT);
-			mat->AddProperty(&wrapS, 1, AI_MATKEY_MAPPINGMODE_U(texType, texSlot));
-			mat->AddProperty(&wrapT, 1, AI_MATKEY_MAPPINGMODE_V(texType, texSlot));
-
-			if (sampler->magFilter != SamplerMagFilter::UNSET) {
-				mat->AddProperty(&sampler->magFilter, 1, AI_MATKEY_GLTF_MAPPINGFILTER_MAG(texType, texSlot));
-			}
-
-			if (sampler->minFilter != SamplerMinFilter::UNSET) {
-				mat->AddProperty(&sampler->minFilter, 1, AI_MATKEY_GLTF_MAPPINGFILTER_MIN(texType, texSlot));
-			}
-		}
-	}
+            if (sampler->minFilter != SamplerMinFilter::UNSET) {
+                mat->AddProperty(&sampler->minFilter, 1, AI_MATKEY_GLTF_MAPPINGFILTER_MIN(texType, texSlot));
+            }
+        }
+    }
 }
 
-inline void SetMaterialTextureProperty(std::vector<int> &embeddedTexIdxs, Asset &r, glTF2::NormalTextureInfo &prop, aiMaterial *mat, aiTextureType texType, unsigned int texSlot = 0) {
-	SetMaterialTextureProperty(embeddedTexIdxs, r, (glTF2::TextureInfo)prop, mat, texType, texSlot);
+inline void SetMaterialTextureProperty(std::vector<int>& embeddedTexIdxs, Asset& r, glTF2::NormalTextureInfo& prop, aiMaterial* mat, aiTextureType texType, unsigned int texSlot = 0)
+{
+    SetMaterialTextureProperty( embeddedTexIdxs, r, (glTF2::TextureInfo) prop, mat, texType, texSlot );
 
-	if (prop.texture && prop.texture->source) {
-		mat->AddProperty(&prop.scale, 1, AI_MATKEY_GLTF_TEXTURE_SCALE(texType, texSlot));
-	}
+    if (prop.texture && prop.texture->source) {
+         mat->AddProperty(&prop.scale, 1, AI_MATKEY_GLTF_TEXTURE_SCALE(texType, texSlot));
+    }
 }
 
-inline void SetMaterialTextureProperty(std::vector<int> &embeddedTexIdxs, Asset &r, glTF2::OcclusionTextureInfo &prop, aiMaterial *mat, aiTextureType texType, unsigned int texSlot = 0) {
-	SetMaterialTextureProperty(embeddedTexIdxs, r, (glTF2::TextureInfo)prop, mat, texType, texSlot);
+inline void SetMaterialTextureProperty(std::vector<int>& embeddedTexIdxs, Asset& r, glTF2::OcclusionTextureInfo& prop, aiMaterial* mat, aiTextureType texType, unsigned int texSlot = 0)
+{
+    SetMaterialTextureProperty( embeddedTexIdxs, r, (glTF2::TextureInfo) prop, mat, texType, texSlot );
 
-	if (prop.texture && prop.texture->source) {
-		mat->AddProperty(&prop.strength, 1, AI_MATKEY_GLTF_TEXTURE_STRENGTH(texType, texSlot));
-	}
+    if (prop.texture && prop.texture->source) {
+        mat->AddProperty(&prop.strength, 1, AI_MATKEY_GLTF_TEXTURE_STRENGTH(texType, texSlot));
+    }
 }
 
-static aiMaterial *ImportMaterial(std::vector<int> &embeddedTexIdxs, Asset &r, Material &mat) {
-	aiMaterial *aimat = new aiMaterial();
+static aiMaterial* ImportMaterial(std::vector<int>& embeddedTexIdxs, Asset& r, Material& mat)
+{
+    aiMaterial* aimat = new aiMaterial();
 
-	if (!mat.name.empty()) {
-		aiString str(mat.name);
+   if (!mat.name.empty()) {
+        aiString str(mat.name);
 
-		aimat->AddProperty(&str, AI_MATKEY_NAME);
-	}
+        aimat->AddProperty(&str, AI_MATKEY_NAME);
+    }
 
-	SetMaterialColorProperty(r, mat.pbrMetallicRoughness.baseColorFactor, aimat, AI_MATKEY_COLOR_DIFFUSE);
-	SetMaterialColorProperty(r, mat.pbrMetallicRoughness.baseColorFactor, aimat, AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_BASE_COLOR_FACTOR);
+    SetMaterialColorProperty(r, mat.pbrMetallicRoughness.baseColorFactor, aimat, AI_MATKEY_COLOR_DIFFUSE);
+    SetMaterialColorProperty(r, mat.pbrMetallicRoughness.baseColorFactor, aimat, AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_BASE_COLOR_FACTOR);
 
-	SetMaterialTextureProperty(embeddedTexIdxs, r, mat.pbrMetallicRoughness.baseColorTexture, aimat, aiTextureType_DIFFUSE);
-	SetMaterialTextureProperty(embeddedTexIdxs, r, mat.pbrMetallicRoughness.baseColorTexture, aimat, AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_BASE_COLOR_TEXTURE);
+    SetMaterialTextureProperty(embeddedTexIdxs, r, mat.pbrMetallicRoughness.baseColorTexture, aimat, aiTextureType_DIFFUSE);
+    SetMaterialTextureProperty(embeddedTexIdxs, r, mat.pbrMetallicRoughness.baseColorTexture, aimat, AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_BASE_COLOR_TEXTURE);
 
-	SetMaterialTextureProperty(embeddedTexIdxs, r, mat.pbrMetallicRoughness.metallicRoughnessTexture, aimat, AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_METALLICROUGHNESS_TEXTURE);
+    SetMaterialTextureProperty(embeddedTexIdxs, r, mat.pbrMetallicRoughness.metallicRoughnessTexture, aimat, AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_METALLICROUGHNESS_TEXTURE);
 
-	aimat->AddProperty(&mat.pbrMetallicRoughness.metallicFactor, 1, AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_METALLIC_FACTOR);
-	aimat->AddProperty(&mat.pbrMetallicRoughness.roughnessFactor, 1, AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_ROUGHNESS_FACTOR);
+    aimat->AddProperty(&mat.pbrMetallicRoughness.metallicFactor, 1, AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_METALLIC_FACTOR);
+    aimat->AddProperty(&mat.pbrMetallicRoughness.roughnessFactor, 1, AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_ROUGHNESS_FACTOR);
 
-	float roughnessAsShininess = 1 - mat.pbrMetallicRoughness.roughnessFactor;
-	roughnessAsShininess *= roughnessAsShininess * 1000;
-	aimat->AddProperty(&roughnessAsShininess, 1, AI_MATKEY_SHININESS);
+    float roughnessAsShininess = 1 - mat.pbrMetallicRoughness.roughnessFactor;
+    roughnessAsShininess *= roughnessAsShininess * 1000;
+    aimat->AddProperty(&roughnessAsShininess, 1, AI_MATKEY_SHININESS);
 
-	SetMaterialTextureProperty(embeddedTexIdxs, r, mat.normalTexture, aimat, aiTextureType_NORMALS);
-	SetMaterialTextureProperty(embeddedTexIdxs, r, mat.occlusionTexture, aimat, aiTextureType_LIGHTMAP);
-	SetMaterialTextureProperty(embeddedTexIdxs, r, mat.emissiveTexture, aimat, aiTextureType_EMISSIVE);
-	SetMaterialColorProperty(r, mat.emissiveFactor, aimat, AI_MATKEY_COLOR_EMISSIVE);
+    SetMaterialTextureProperty(embeddedTexIdxs, r, mat.normalTexture, aimat, aiTextureType_NORMALS);
+    SetMaterialTextureProperty(embeddedTexIdxs, r, mat.occlusionTexture, aimat, aiTextureType_LIGHTMAP);
+    SetMaterialTextureProperty(embeddedTexIdxs, r, mat.emissiveTexture, aimat, aiTextureType_EMISSIVE);
+    SetMaterialColorProperty(r, mat.emissiveFactor, aimat, AI_MATKEY_COLOR_EMISSIVE);
 
-	aimat->AddProperty(&mat.doubleSided, 1, AI_MATKEY_TWOSIDED);
+    aimat->AddProperty(&mat.doubleSided, 1, AI_MATKEY_TWOSIDED);
 
-	aiString alphaMode(mat.alphaMode);
-	aimat->AddProperty(&alphaMode, AI_MATKEY_GLTF_ALPHAMODE);
-	aimat->AddProperty(&mat.alphaCutoff, 1, AI_MATKEY_GLTF_ALPHACUTOFF);
+    aiString alphaMode(mat.alphaMode);
+    aimat->AddProperty(&alphaMode, AI_MATKEY_GLTF_ALPHAMODE);
+    aimat->AddProperty(&mat.alphaCutoff, 1, AI_MATKEY_GLTF_ALPHACUTOFF);
 
-	//pbrSpecularGlossiness
-	if (mat.pbrSpecularGlossiness.isPresent) {
-		PbrSpecularGlossiness &pbrSG = mat.pbrSpecularGlossiness.value;
+    //pbrSpecularGlossiness
+    if (mat.pbrSpecularGlossiness.isPresent) {
+        PbrSpecularGlossiness &pbrSG = mat.pbrSpecularGlossiness.value;
 
-		aimat->AddProperty(&mat.pbrSpecularGlossiness.isPresent, 1, AI_MATKEY_GLTF_PBRSPECULARGLOSSINESS);
-		SetMaterialColorProperty(r, pbrSG.diffuseFactor, aimat, AI_MATKEY_COLOR_DIFFUSE);
-		SetMaterialColorProperty(r, pbrSG.specularFactor, aimat, AI_MATKEY_COLOR_SPECULAR);
+        aimat->AddProperty(&mat.pbrSpecularGlossiness.isPresent, 1, AI_MATKEY_GLTF_PBRSPECULARGLOSSINESS);
+        SetMaterialColorProperty(r, pbrSG.diffuseFactor, aimat, AI_MATKEY_COLOR_DIFFUSE);
+        SetMaterialColorProperty(r, pbrSG.specularFactor, aimat, AI_MATKEY_COLOR_SPECULAR);
 
-		float glossinessAsShininess = pbrSG.glossinessFactor * 1000.0f;
-		aimat->AddProperty(&glossinessAsShininess, 1, AI_MATKEY_SHININESS);
-		aimat->AddProperty(&pbrSG.glossinessFactor, 1, AI_MATKEY_GLTF_PBRSPECULARGLOSSINESS_GLOSSINESS_FACTOR);
+        float glossinessAsShininess = pbrSG.glossinessFactor * 1000.0f;
+        aimat->AddProperty(&glossinessAsShininess, 1, AI_MATKEY_SHININESS);
+        aimat->AddProperty(&pbrSG.glossinessFactor, 1, AI_MATKEY_GLTF_PBRSPECULARGLOSSINESS_GLOSSINESS_FACTOR);
 
-		SetMaterialTextureProperty(embeddedTexIdxs, r, pbrSG.diffuseTexture, aimat, aiTextureType_DIFFUSE);
+        SetMaterialTextureProperty(embeddedTexIdxs, r, pbrSG.diffuseTexture, aimat, aiTextureType_DIFFUSE);
 
-		SetMaterialTextureProperty(embeddedTexIdxs, r, pbrSG.specularGlossinessTexture, aimat, aiTextureType_SPECULAR);
-	}
-	if (mat.unlit) {
-		aimat->AddProperty(&mat.unlit, 1, AI_MATKEY_GLTF_UNLIT);
-	}
+        SetMaterialTextureProperty(embeddedTexIdxs, r, pbrSG.specularGlossinessTexture, aimat, aiTextureType_SPECULAR);
+    }
+    if (mat.unlit) {
+        aimat->AddProperty(&mat.unlit, 1, AI_MATKEY_GLTF_UNLIT);
+    }
 
-	return aimat;
+    return aimat;
 }
 
-void glTF2Importer::ImportMaterials(glTF2::Asset &r) {
-	const unsigned int numImportedMaterials = unsigned(r.materials.Size());
-	Material defaultMaterial;
+void glTF2Importer::ImportMaterials(glTF2::Asset& r)
+{
+    const unsigned int numImportedMaterials = unsigned(r.materials.Size());
+    Material defaultMaterial;
 
-	mScene->mNumMaterials = numImportedMaterials + 1;
-	mScene->mMaterials = new aiMaterial *[mScene->mNumMaterials];
-	mScene->mMaterials[numImportedMaterials] = ImportMaterial(embeddedTexIdxs, r, defaultMaterial);
+    mScene->mNumMaterials = numImportedMaterials + 1;
+    mScene->mMaterials = new aiMaterial*[mScene->mNumMaterials];
+    mScene->mMaterials[numImportedMaterials] = ImportMaterial(embeddedTexIdxs, r, defaultMaterial);
 
-	for (unsigned int i = 0; i < numImportedMaterials; ++i) {
-		mScene->mMaterials[i] = ImportMaterial(embeddedTexIdxs, r, r.materials[i]);
-	}
+    for (unsigned int i = 0; i < numImportedMaterials; ++i) {
+       mScene->mMaterials[i] = ImportMaterial(embeddedTexIdxs, r, r.materials[i]);
+    }
 }
 
-static inline void SetFace(aiFace &face, int a) {
-	face.mNumIndices = 1;
-	face.mIndices = new unsigned int[1];
-	face.mIndices[0] = a;
+
+static inline void SetFace(aiFace& face, int a)
+{
+    face.mNumIndices = 1;
+    face.mIndices = new unsigned int[1];
+    face.mIndices[0] = a;
 }
 
-static inline void SetFace(aiFace &face, int a, int b) {
-	face.mNumIndices = 2;
-	face.mIndices = new unsigned int[2];
-	face.mIndices[0] = a;
-	face.mIndices[1] = b;
+static inline void SetFace(aiFace& face, int a, int b)
+{
+    face.mNumIndices = 2;
+    face.mIndices = new unsigned int[2];
+    face.mIndices[0] = a;
+    face.mIndices[1] = b;
 }
 
-static inline void SetFace(aiFace &face, int a, int b, int c) {
-	face.mNumIndices = 3;
-	face.mIndices = new unsigned int[3];
-	face.mIndices[0] = a;
-	face.mIndices[1] = b;
-	face.mIndices[2] = c;
+static inline void SetFace(aiFace& face, int a, int b, int c)
+{
+    face.mNumIndices = 3;
+    face.mIndices = new unsigned int[3];
+    face.mIndices[0] = a;
+    face.mIndices[1] = b;
+    face.mIndices[2] = c;
 }
 
 #ifdef ASSIMP_BUILD_DEBUG
-static inline bool CheckValidFacesIndices(aiFace *faces, unsigned nFaces, unsigned nVerts) {
-	for (unsigned i = 0; i < nFaces; ++i) {
-		for (unsigned j = 0; j < faces[i].mNumIndices; ++j) {
-			unsigned idx = faces[i].mIndices[j];
-			if (idx >= nVerts) {
-				return false;
-			}
-		}
-	}
-	return true;
+static inline bool CheckValidFacesIndices(aiFace* faces, unsigned nFaces, unsigned nVerts)
+{
+    for (unsigned i = 0; i < nFaces; ++i) {
+        for (unsigned j = 0; j < faces[i].mNumIndices; ++j) {
+            unsigned idx = faces[i].mIndices[j];
+            if (idx >= nVerts)
+                return false;
+        }
+    }
+    return true;
 }
 #endif // ASSIMP_BUILD_DEBUG
 
-void glTF2Importer::ImportMeshes(glTF2::Asset &r) {
-	std::vector<aiMesh *> meshes;
+void glTF2Importer::ImportMeshes(glTF2::Asset& r)
+{
+    std::vector<aiMesh*> meshes;
 
-	unsigned int k = 0;
-    meshOffsets.clear();
+    unsigned int k = 0;
 
-	for (unsigned int m = 0; m < r.meshes.Size(); ++m) {
-		Mesh &mesh = r.meshes[m];
+    for (unsigned int m = 0; m < r.meshes.Size(); ++m) {
+        Mesh& mesh = r.meshes[m];
 
-		meshOffsets.push_back(k);
-		k += unsigned(mesh.primitives.size());
+        meshOffsets.push_back(k);
+        k += unsigned(mesh.primitives.size());
 
-		for (unsigned int p = 0; p < mesh.primitives.size(); ++p) {
-			Mesh::Primitive &prim = mesh.primitives[p];
+        for (unsigned int p = 0; p < mesh.primitives.size(); ++p) {
+            Mesh::Primitive& prim = mesh.primitives[p];
 
-			aiMesh *aim = new aiMesh();
-			meshes.push_back(aim);
+            aiMesh* aim = new aiMesh();
+            meshes.push_back(aim);
 
-			aim->mName = mesh.name.empty() ? mesh.id : mesh.name;
+            aim->mName = mesh.name.empty() ? mesh.id : mesh.name;
 
-			if (mesh.primitives.size() > 1) {
-				ai_uint32 &len = aim->mName.length;
-				aim->mName.data[len] = '-';
-				len += 1 + ASSIMP_itoa10(aim->mName.data + len + 1, unsigned(MAXLEN - len - 1), p);
-			}
+            if (mesh.primitives.size() > 1) {
+                ai_uint32& len = aim->mName.length;
+                aim->mName.data[len] = '-';
+                len += 1 + ASSIMP_itoa10(aim->mName.data + len + 1, unsigned(MAXLEN - len - 1), p);
+            }
 
-			switch (prim.mode) {
-				case PrimitiveMode_POINTS:
-					aim->mPrimitiveTypes |= aiPrimitiveType_POINT;
-					break;
+            switch (prim.mode) {
+                case PrimitiveMode_POINTS:
+                    aim->mPrimitiveTypes |= aiPrimitiveType_POINT;
+                    break;
 
-				case PrimitiveMode_LINES:
-				case PrimitiveMode_LINE_LOOP:
-				case PrimitiveMode_LINE_STRIP:
-					aim->mPrimitiveTypes |= aiPrimitiveType_LINE;
-					break;
+                case PrimitiveMode_LINES:
+                case PrimitiveMode_LINE_LOOP:
+                case PrimitiveMode_LINE_STRIP:
+                    aim->mPrimitiveTypes |= aiPrimitiveType_LINE;
+                    break;
 
-				case PrimitiveMode_TRIANGLES:
-				case PrimitiveMode_TRIANGLE_STRIP:
-				case PrimitiveMode_TRIANGLE_FAN:
-					aim->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
-					break;
-			}
+                case PrimitiveMode_TRIANGLES:
+                case PrimitiveMode_TRIANGLE_STRIP:
+                case PrimitiveMode_TRIANGLE_FAN:
+                    aim->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
+                    break;
 
-			Mesh::Primitive::Attributes &attr = prim.attributes;
+            }
 
-			if (attr.position.size() > 0 && attr.position[0]) {
-				aim->mNumVertices = static_cast<unsigned int>(attr.position[0]->count);
-				attr.position[0]->ExtractData(aim->mVertices);
-			}
+            Mesh::Primitive::Attributes& attr = prim.attributes;
 
-			if (attr.normal.size() > 0 && attr.normal[0]) {
-				attr.normal[0]->ExtractData(aim->mNormals);
+            if (attr.position.size() > 0 && attr.position[0]) {
+                aim->mNumVertices = static_cast<unsigned int>(attr.position[0]->count);
+                attr.position[0]->ExtractData(aim->mVertices);
+            }
 
-				// only extract tangents if normals are present
-				if (attr.tangent.size() > 0 && attr.tangent[0]) {
-					// generate bitangents from normals and tangents according to spec
-					Tangent *tangents = nullptr;
+            if (attr.normal.size() > 0 && attr.normal[0]) {
+                attr.normal[0]->ExtractData(aim->mNormals);
 
-					attr.tangent[0]->ExtractData(tangents);
+                // only extract tangents if normals are present
+                if (attr.tangent.size() > 0 && attr.tangent[0]) {
+                    // generate bitangents from normals and tangents according to spec
+                    Tangent *tangents = nullptr;
 
-					aim->mTangents = new aiVector3D[aim->mNumVertices];
-					aim->mBitangents = new aiVector3D[aim->mNumVertices];
+                    attr.tangent[0]->ExtractData(tangents);
 
-					for (unsigned int i = 0; i < aim->mNumVertices; ++i) {
-						aim->mTangents[i] = tangents[i].xyz;
-						aim->mBitangents[i] = (aim->mNormals[i] ^ tangents[i].xyz) * tangents[i].w;
-					}
+                    aim->mTangents = new aiVector3D[aim->mNumVertices];
+                    aim->mBitangents = new aiVector3D[aim->mNumVertices];
 
-					delete[] tangents;
-				}
-			}
+                    for (unsigned int i = 0; i < aim->mNumVertices; ++i) {
+                        aim->mTangents[i] = tangents[i].xyz;
+                        aim->mBitangents[i] = (aim->mNormals[i] ^ tangents[i].xyz) * tangents[i].w;
+                    }
 
-			for (size_t c = 0; c < attr.color.size() && c < AI_MAX_NUMBER_OF_COLOR_SETS; ++c) {
-				if (attr.color[c]->count != aim->mNumVertices) {
-					DefaultLogger::get()->warn("Color stream size in mesh \"" + mesh.name +
-											   "\" does not match the vertex count");
-					continue;
-				}
-				attr.color[c]->ExtractData(aim->mColors[c]);
-			}
-			for (size_t tc = 0; tc < attr.texcoord.size() && tc < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++tc) {
-				if (attr.texcoord[tc]->count != aim->mNumVertices) {
-					DefaultLogger::get()->warn("Texcoord stream size in mesh \"" + mesh.name +
-											   "\" does not match the vertex count");
-					continue;
-				}
+                    delete [] tangents;
+                }
+            }
 
-				attr.texcoord[tc]->ExtractData(aim->mTextureCoords[tc]);
-				aim->mNumUVComponents[tc] = attr.texcoord[tc]->GetNumComponents();
+            for (size_t c = 0; c < attr.color.size() && c < AI_MAX_NUMBER_OF_COLOR_SETS; ++c) {
+                if (attr.color[c]->count != aim->mNumVertices) {
+                    DefaultLogger::get()->warn("Color stream size in mesh \"" + mesh.name +
+                        "\" does not match the vertex count");
+                    continue;
+                }
+                attr.color[c]->ExtractData(aim->mColors[c]);
+            }
+            for (size_t tc = 0; tc < attr.texcoord.size() && tc < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++tc) {
+                if (attr.texcoord[tc]->count != aim->mNumVertices) {
+                    DefaultLogger::get()->warn("Texcoord stream size in mesh \"" + mesh.name +
+                                               "\" does not match the vertex count");
+                    continue;
+                }
 
-				aiVector3D *values = aim->mTextureCoords[tc];
-				for (unsigned int i = 0; i < aim->mNumVertices; ++i) {
-					values[i].y = 1 - values[i].y; // Flip Y coords
-				}
-			}
+                attr.texcoord[tc]->ExtractData(aim->mTextureCoords[tc]);
+                aim->mNumUVComponents[tc] = attr.texcoord[tc]->GetNumComponents();
 
-			std::vector<Mesh::Primitive::Target> &targets = prim.targets;
-			if (targets.size() > 0) {
-				aim->mNumAnimMeshes = (unsigned int)targets.size();
-				aim->mAnimMeshes = new aiAnimMesh *[aim->mNumAnimMeshes];
-				for (size_t i = 0; i < targets.size(); i++) {
-					aim->mAnimMeshes[i] = aiCreateAnimMesh(aim);
-					aiAnimMesh &aiAnimMesh = *(aim->mAnimMeshes[i]);
-					Mesh::Primitive::Target &target = targets[i];
+                aiVector3D* values = aim->mTextureCoords[tc];
+                for (unsigned int i = 0; i < aim->mNumVertices; ++i) {
+                    values[i].y = 1 - values[i].y; // Flip Y coords
+                }
+            }
 
-					if (target.position.size() > 0) {
-						aiVector3D *positionDiff = nullptr;
-						target.position[0]->ExtractData(positionDiff);
-						for (unsigned int vertexId = 0; vertexId < aim->mNumVertices; vertexId++) {
-							aiAnimMesh.mVertices[vertexId] += positionDiff[vertexId];
-						}
-						delete[] positionDiff;
-					}
-					if (target.normal.size() > 0) {
-						aiVector3D *normalDiff = nullptr;
-						target.normal[0]->ExtractData(normalDiff);
-						for (unsigned int vertexId = 0; vertexId < aim->mNumVertices; vertexId++) {
-							aiAnimMesh.mNormals[vertexId] += normalDiff[vertexId];
-						}
-						delete[] normalDiff;
-					}
-					if (target.tangent.size() > 0) {
-						Tangent *tangent = nullptr;
-						attr.tangent[0]->ExtractData(tangent);
+            std::vector<Mesh::Primitive::Target>& targets = prim.targets;
+            if (targets.size() > 0) {
+                aim->mNumAnimMeshes = (unsigned int)targets.size();
+                aim->mAnimMeshes = new aiAnimMesh*[aim->mNumAnimMeshes];
+                for (size_t i = 0; i < targets.size(); i++) {
+                    aim->mAnimMeshes[i] = aiCreateAnimMesh(aim);
+                    aiAnimMesh& aiAnimMesh = *(aim->mAnimMeshes[i]);
+                    Mesh::Primitive::Target& target = targets[i];
 
-						aiVector3D *tangentDiff = nullptr;
-						target.tangent[0]->ExtractData(tangentDiff);
+                    if (target.position.size() > 0) {
+                        aiVector3D *positionDiff = nullptr;
+                        target.position[0]->ExtractData(positionDiff);
+                        for(unsigned int vertexId = 0; vertexId < aim->mNumVertices; vertexId++) {
+                            aiAnimMesh.mVertices[vertexId] += positionDiff[vertexId];
+                        }
+                        delete [] positionDiff;
+                    }
+                    if (target.normal.size() > 0) {
+                        aiVector3D *normalDiff = nullptr;
+                        target.normal[0]->ExtractData(normalDiff);
+                        for(unsigned int vertexId = 0; vertexId < aim->mNumVertices; vertexId++) {
+                            aiAnimMesh.mNormals[vertexId] += normalDiff[vertexId];
+                        }
+                        delete [] normalDiff;
+                    }
+                    if (target.tangent.size() > 0) {
+                        Tangent *tangent = nullptr;
+                        attr.tangent[0]->ExtractData(tangent);
 
-						for (unsigned int vertexId = 0; vertexId < aim->mNumVertices; ++vertexId) {
-							tangent[vertexId].xyz += tangentDiff[vertexId];
-							aiAnimMesh.mTangents[vertexId] = tangent[vertexId].xyz;
-							aiAnimMesh.mBitangents[vertexId] = (aiAnimMesh.mNormals[vertexId] ^ tangent[vertexId].xyz) * tangent[vertexId].w;
-						}
-						delete[] tangent;
-						delete[] tangentDiff;
-					}
-					if (mesh.weights.size() > i) {
-						aiAnimMesh.mWeight = mesh.weights[i];
-					}
-				}
-			}
+                        aiVector3D *tangentDiff = nullptr;
+                        target.tangent[0]->ExtractData(tangentDiff);
 
-			aiFace *faces = nullptr;
-			size_t nFaces = 0;
+                        for (unsigned int vertexId = 0; vertexId < aim->mNumVertices; ++vertexId) {
+                            tangent[vertexId].xyz += tangentDiff[vertexId];
+                            aiAnimMesh.mTangents[vertexId] = tangent[vertexId].xyz;
+                            aiAnimMesh.mBitangents[vertexId] = (aiAnimMesh.mNormals[vertexId] ^ tangent[vertexId].xyz) * tangent[vertexId].w;
+                        }
+                        delete [] tangent;
+                        delete [] tangentDiff;
+                    }
+                    if (mesh.weights.size() > i) {
+                        aiAnimMesh.mWeight = mesh.weights[i];
+                    }
+                }
+            }
 
-			if (prim.indices) {
-				size_t count = prim.indices->count;
 
-				Accessor::Indexer data = prim.indices->GetIndexer();
-				ai_assert(data.IsValid());
+            aiFace* faces = 0;
+            size_t nFaces = 0;
 
-				switch (prim.mode) {
-					case PrimitiveMode_POINTS: {
-						nFaces = count;
-						faces = new aiFace[nFaces];
-						for (unsigned int i = 0; i < count; ++i) {
-							SetFace(faces[i], data.GetUInt(i));
-						}
-						break;
-					}
+            if (prim.indices) {
+                size_t count = prim.indices->count;
 
-					case PrimitiveMode_LINES: {
-						nFaces = count / 2;
-						if (nFaces * 2 != count) {
-							ASSIMP_LOG_WARN("The number of vertices was not compatible with the LINES mode. Some vertices were dropped.");
-							count = nFaces * 2;
-						}
-						faces = new aiFace[nFaces];
-						for (unsigned int i = 0; i < count; i += 2) {
-							SetFace(faces[i / 2], data.GetUInt(i), data.GetUInt(i + 1));
-						}
-						break;
-					}
+                Accessor::Indexer data = prim.indices->GetIndexer();
+                ai_assert(data.IsValid());
 
-					case PrimitiveMode_LINE_LOOP:
-					case PrimitiveMode_LINE_STRIP: {
-						nFaces = count - ((prim.mode == PrimitiveMode_LINE_STRIP) ? 1 : 0);
-						faces = new aiFace[nFaces];
-						SetFace(faces[0], data.GetUInt(0), data.GetUInt(1));
-						for (unsigned int i = 2; i < count; ++i) {
-							SetFace(faces[i - 1], faces[i - 2].mIndices[1], data.GetUInt(i));
-						}
-						if (prim.mode == PrimitiveMode_LINE_LOOP) { // close the loop
-							SetFace(faces[count - 1], faces[count - 2].mIndices[1], faces[0].mIndices[0]);
-						}
-						break;
-					}
+                switch (prim.mode) {
+                    case PrimitiveMode_POINTS: {
+                        nFaces = count;
+                        faces = new aiFace[nFaces];
+                        for (unsigned int i = 0; i < count; ++i) {
+                            SetFace(faces[i], data.GetUInt(i));
+                        }
+                        break;
+                    }
 
-					case PrimitiveMode_TRIANGLES: {
-						nFaces = count / 3;
-						if (nFaces * 3 != count) {
-							ASSIMP_LOG_WARN("The number of vertices was not compatible with the TRIANGLES mode. Some vertices were dropped.");
-							count = nFaces * 3;
-						}
-						faces = new aiFace[nFaces];
-						for (unsigned int i = 0; i < count; i += 3) {
-							SetFace(faces[i / 3], data.GetUInt(i), data.GetUInt(i + 1), data.GetUInt(i + 2));
-						}
-						break;
-					}
-					case PrimitiveMode_TRIANGLE_STRIP: {
-						nFaces = count - 2;
-						faces = new aiFace[nFaces];
-						for (unsigned int i = 0; i < nFaces; ++i) {
-							//The ordering is to ensure that the triangles are all drawn with the same orientation
-							if ((i + 1) % 2 == 0) {
-								//For even n, vertices n + 1, n, and n + 2 define triangle n
-								SetFace(faces[i], data.GetUInt(i + 1), data.GetUInt(i), data.GetUInt(i + 2));
-							} else {
-								//For odd n, vertices n, n+1, and n+2 define triangle n
-								SetFace(faces[i], data.GetUInt(i), data.GetUInt(i + 1), data.GetUInt(i + 2));
-							}
-						}
-						break;
-					}
-					case PrimitiveMode_TRIANGLE_FAN:
-						nFaces = count - 2;
-						faces = new aiFace[nFaces];
-						SetFace(faces[0], data.GetUInt(0), data.GetUInt(1), data.GetUInt(2));
-						for (unsigned int i = 1; i < nFaces; ++i) {
-							SetFace(faces[i], faces[0].mIndices[0], faces[i - 1].mIndices[2], data.GetUInt(i + 2));
-						}
-						break;
-				}
-			} else { // no indices provided so directly generate from counts
+                    case PrimitiveMode_LINES: {
+                        nFaces = count / 2;
+                        faces = new aiFace[nFaces];
+                        for (unsigned int i = 0; i < count; i += 2) {
+                            SetFace(faces[i / 2], data.GetUInt(i), data.GetUInt(i + 1));
+                        }
+                        break;
+                    }
 
-				// use the already determined count as it includes checks
-				unsigned int count = aim->mNumVertices;
+                    case PrimitiveMode_LINE_LOOP:
+                    case PrimitiveMode_LINE_STRIP: {
+                        nFaces = count - ((prim.mode == PrimitiveMode_LINE_STRIP) ? 1 : 0);
+                        faces = new aiFace[nFaces];
+                        SetFace(faces[0], data.GetUInt(0), data.GetUInt(1));
+                        for (unsigned int i = 2; i < count; ++i) {
+                            SetFace(faces[i - 1], faces[i - 2].mIndices[1], data.GetUInt(i));
+                        }
+                        if (prim.mode == PrimitiveMode_LINE_LOOP) { // close the loop
+                            SetFace(faces[count - 1], faces[count - 2].mIndices[1], faces[0].mIndices[0]);
+                        }
+                        break;
+                    }
 
-				switch (prim.mode) {
-					case PrimitiveMode_POINTS: {
-						nFaces = count;
-						faces = new aiFace[nFaces];
-						for (unsigned int i = 0; i < count; ++i) {
-							SetFace(faces[i], i);
-						}
-						break;
-					}
+                    case PrimitiveMode_TRIANGLES: {
+                        nFaces = count / 3;
+                        faces = new aiFace[nFaces];
+                        for (unsigned int i = 0; i < count; i += 3) {
+                            SetFace(faces[i / 3], data.GetUInt(i), data.GetUInt(i + 1), data.GetUInt(i + 2));
+                        }
+                        break;
+                    }
+                    case PrimitiveMode_TRIANGLE_STRIP: {
+                        nFaces = count - 2;
+                        faces = new aiFace[nFaces];
+                        for (unsigned int i = 0; i < nFaces; ++i) {
+                            //The ordering is to ensure that the triangles are all drawn with the same orientation
+                            if ((i + 1) % 2 == 0)
+                            {
+                                //For even n, vertices n + 1, n, and n + 2 define triangle n
+                                SetFace(faces[i], data.GetUInt(i + 1), data.GetUInt(i), data.GetUInt(i + 2));
+                            }
+                            else
+                            {
+                                //For odd n, vertices n, n+1, and n+2 define triangle n
+                                SetFace(faces[i], data.GetUInt(i), data.GetUInt(i + 1), data.GetUInt(i + 2));
+                            }
+                        }
+                        break;
+                    }
+                    case PrimitiveMode_TRIANGLE_FAN:
+                        nFaces = count - 2;
+                        faces = new aiFace[nFaces];
+                        SetFace(faces[0], data.GetUInt(0), data.GetUInt(1), data.GetUInt(2));
+                        for (unsigned int i = 1; i < nFaces; ++i) {
+                            SetFace(faces[i], faces[0].mIndices[0], faces[i - 1].mIndices[2], data.GetUInt(i + 2));
+                        }
+                        break;
+                }
+            }
+            else { // no indices provided so directly generate from counts
 
-					case PrimitiveMode_LINES: {
-						nFaces = count / 2;
-						if (nFaces * 2 != count) {
-							ASSIMP_LOG_WARN("The number of vertices was not compatible with the LINES mode. Some vertices were dropped.");
-							count = (unsigned int)nFaces * 2;
-						}
-						faces = new aiFace[nFaces];
-						for (unsigned int i = 0; i < count; i += 2) {
-							SetFace(faces[i / 2], i, i + 1);
-						}
-						break;
-					}
+                // use the already determined count as it includes checks
+                unsigned int count = aim->mNumVertices;
 
-					case PrimitiveMode_LINE_LOOP:
-					case PrimitiveMode_LINE_STRIP: {
-						nFaces = count - ((prim.mode == PrimitiveMode_LINE_STRIP) ? 1 : 0);
-						faces = new aiFace[nFaces];
-						SetFace(faces[0], 0, 1);
-						for (unsigned int i = 2; i < count; ++i) {
-							SetFace(faces[i - 1], faces[i - 2].mIndices[1], i);
-						}
-						if (prim.mode == PrimitiveMode_LINE_LOOP) { // close the loop
-							SetFace(faces[count - 1], faces[count - 2].mIndices[1], faces[0].mIndices[0]);
-						}
-						break;
-					}
+                switch (prim.mode) {
+                case PrimitiveMode_POINTS: {
+                    nFaces = count;
+                    faces = new aiFace[nFaces];
+                    for (unsigned int i = 0; i < count; ++i) {
+                        SetFace(faces[i], i);
+                    }
+                    break;
+                }
 
-					case PrimitiveMode_TRIANGLES: {
-						nFaces = count / 3;
-						if (nFaces * 3 != count) {
-							ASSIMP_LOG_WARN("The number of vertices was not compatible with the TRIANGLES mode. Some vertices were dropped.");
-							count = (unsigned int)nFaces * 3;
-						}
-						faces = new aiFace[nFaces];
-						for (unsigned int i = 0; i < count; i += 3) {
-							SetFace(faces[i / 3], i, i + 1, i + 2);
-						}
-						break;
-					}
-					case PrimitiveMode_TRIANGLE_STRIP: {
-						nFaces = count - 2;
-						faces = new aiFace[nFaces];
-						for (unsigned int i = 0; i < nFaces; ++i) {
-							//The ordering is to ensure that the triangles are all drawn with the same orientation
-							if ((i + 1) % 2 == 0) {
-								//For even n, vertices n + 1, n, and n + 2 define triangle n
-								SetFace(faces[i], i + 1, i, i + 2);
-							} else {
-								//For odd n, vertices n, n+1, and n+2 define triangle n
-								SetFace(faces[i], i, i + 1, i + 2);
-							}
-						}
-						break;
-					}
-					case PrimitiveMode_TRIANGLE_FAN:
-						nFaces = count - 2;
-						faces = new aiFace[nFaces];
-						SetFace(faces[0], 0, 1, 2);
-						for (unsigned int i = 1; i < nFaces; ++i) {
-							SetFace(faces[i], faces[0].mIndices[0], faces[i - 1].mIndices[2], i + 2);
-						}
-						break;
-				}
-			}
+                case PrimitiveMode_LINES: {
+                    nFaces = count / 2;
+                    faces = new aiFace[nFaces];
+                    for (unsigned int i = 0; i < count; i += 2) {
+                        SetFace(faces[i / 2], i, i + 1);
+                    }
+                    break;
+                }
 
-			if (nullptr != faces) {
-				aim->mFaces = faces;
-				aim->mNumFaces = static_cast<unsigned int>(nFaces);
-				ai_assert(CheckValidFacesIndices(faces, static_cast<unsigned>(nFaces), aim->mNumVertices));
-			}
+                case PrimitiveMode_LINE_LOOP:
+                case PrimitiveMode_LINE_STRIP: {
+                    nFaces = count - ((prim.mode == PrimitiveMode_LINE_STRIP) ? 1 : 0);
+                    faces = new aiFace[nFaces];
+                    SetFace(faces[0], 0, 1);
+                    for (unsigned int i = 2; i < count; ++i) {
+                        SetFace(faces[i - 1], faces[i - 2].mIndices[1], i);
+                    }
+                    if (prim.mode == PrimitiveMode_LINE_LOOP) { // close the loop
+                        SetFace(faces[count - 1], faces[count - 2].mIndices[1], faces[0].mIndices[0]);
+                    }
+                    break;
+                }
 
-			if (prim.material) {
-				aim->mMaterialIndex = prim.material.GetIndex();
-			} else {
-				aim->mMaterialIndex = mScene->mNumMaterials - 1;
-			}
-		}
-	}
+                case PrimitiveMode_TRIANGLES: {
+                    nFaces = count / 3;
+                    faces = new aiFace[nFaces];
+                    for (unsigned int i = 0; i < count; i += 3) {
+                        SetFace(faces[i / 3], i, i + 1, i + 2);
+                    }
+                    break;
+                }
+                case PrimitiveMode_TRIANGLE_STRIP: {
+                    nFaces = count - 2;
+                    faces = new aiFace[nFaces];
+                    for (unsigned int i = 0; i < nFaces; ++i) {
+                        //The ordering is to ensure that the triangles are all drawn with the same orientation
+                        if ((i+1) % 2 == 0)
+                        {
+                            //For even n, vertices n + 1, n, and n + 2 define triangle n
+                            SetFace(faces[i], i+1, i, i+2);
+                        }
+                        else
+                        {
+                            //For odd n, vertices n, n+1, and n+2 define triangle n
+                            SetFace(faces[i], i, i+1, i+2);
+                        }
+                    }
+                    break;
+                }
+                case PrimitiveMode_TRIANGLE_FAN:
+                    nFaces = count - 2;
+                    faces = new aiFace[nFaces];
+                    SetFace(faces[0], 0, 1, 2);
+                    for (unsigned int i = 1; i < nFaces; ++i) {
+                        SetFace(faces[i], faces[0].mIndices[0], faces[i - 1].mIndices[2], i + 2);
+                    }
+                    break;
+                }
+            }
 
-	meshOffsets.push_back(k);
+            if (faces) {
+                aim->mFaces = faces;
+                aim->mNumFaces = static_cast<unsigned int>(nFaces);
+                ai_assert(CheckValidFacesIndices(faces, static_cast<unsigned>(nFaces), aim->mNumVertices));
+            }
 
-	CopyVector(meshes, mScene->mMeshes, mScene->mNumMeshes);
+            if (prim.material) {
+                aim->mMaterialIndex = prim.material.GetIndex();
+            }
+            else {
+                aim->mMaterialIndex = mScene->mNumMaterials - 1;
+            }
+
+        }
+    }
+
+    meshOffsets.push_back(k);
+
+    CopyVector(meshes, mScene->mMeshes, mScene->mNumMeshes);
 }
 
-void glTF2Importer::ImportCameras(glTF2::Asset &r) {
-	if (!r.cameras.Size()) return;
+void glTF2Importer::ImportCameras(glTF2::Asset& r)
+{
+    if (!r.cameras.Size()) return;
 
-	mScene->mNumCameras = r.cameras.Size();
-	mScene->mCameras = new aiCamera *[r.cameras.Size()];
+    mScene->mNumCameras = r.cameras.Size();
+    mScene->mCameras = new aiCamera*[r.cameras.Size()];
 
-	for (size_t i = 0; i < r.cameras.Size(); ++i) {
-		Camera &cam = r.cameras[i];
+    for (size_t i = 0; i < r.cameras.Size(); ++i) {
+        Camera& cam = r.cameras[i];
 
-		aiCamera *aicam = mScene->mCameras[i] = new aiCamera();
+        aiCamera* aicam = mScene->mCameras[i] = new aiCamera();
 
-		// cameras point in -Z by default, rest is specified in node transform
-		aicam->mLookAt = aiVector3D(0.f, 0.f, -1.f);
+        // cameras point in -Z by default, rest is specified in node transform
+        aicam->mLookAt = aiVector3D(0.f,0.f,-1.f);
 
-		if (cam.type == Camera::Perspective) {
+        if (cam.type == Camera::Perspective) {
 
-			aicam->mAspect = cam.cameraProperties.perspective.aspectRatio;
-			aicam->mHorizontalFOV = cam.cameraProperties.perspective.yfov * ((aicam->mAspect == 0.f) ? 1.f : aicam->mAspect);
-			aicam->mClipPlaneFar = cam.cameraProperties.perspective.zfar;
-			aicam->mClipPlaneNear = cam.cameraProperties.perspective.znear;
-		} else {
-			aicam->mClipPlaneFar = cam.cameraProperties.ortographic.zfar;
-			aicam->mClipPlaneNear = cam.cameraProperties.ortographic.znear;
-			aicam->mHorizontalFOV = 0.0;
-			aicam->mAspect = 1.0f;
-			if (0.f != cam.cameraProperties.ortographic.ymag) {
-				aicam->mAspect = cam.cameraProperties.ortographic.xmag / cam.cameraProperties.ortographic.ymag;
-			}
-		}
-	}
+            aicam->mAspect        = cam.cameraProperties.perspective.aspectRatio;
+            aicam->mHorizontalFOV = cam.cameraProperties.perspective.yfov * ((aicam->mAspect == 0.f) ? 1.f : aicam->mAspect);
+            aicam->mClipPlaneFar  = cam.cameraProperties.perspective.zfar;
+            aicam->mClipPlaneNear = cam.cameraProperties.perspective.znear;
+        } else {
+            aicam->mClipPlaneFar = cam.cameraProperties.ortographic.zfar;
+            aicam->mClipPlaneNear = cam.cameraProperties.ortographic.znear;
+            aicam->mHorizontalFOV = 0.0;
+            aicam->mAspect = 1.0f;
+            if (0.f != cam.cameraProperties.ortographic.ymag ) {
+                aicam->mAspect = cam.cameraProperties.ortographic.xmag / cam.cameraProperties.ortographic.ymag;
+            }
+        }
+    }
 }
 
-void glTF2Importer::ImportLights(glTF2::Asset &r) {
-	if (!r.lights.Size())
-		return;
+void glTF2Importer::ImportLights(glTF2::Asset& r)
+{
+    if (!r.lights.Size())
+        return;
 
-	mScene->mNumLights = r.lights.Size();
-	mScene->mLights = new aiLight *[r.lights.Size()];
+    mScene->mNumLights = r.lights.Size();
+    mScene->mLights = new aiLight*[r.lights.Size()];
 
-	for (size_t i = 0; i < r.lights.Size(); ++i) {
-		Light &light = r.lights[i];
+    for (size_t i = 0; i < r.lights.Size(); ++i) {
+        Light& light = r.lights[i];
 
-		aiLight *ail = mScene->mLights[i] = new aiLight();
+        aiLight* ail = mScene->mLights[i] = new aiLight();
 
-		switch (light.type) {
-			case Light::Directional:
-				ail->mType = aiLightSource_DIRECTIONAL;
-				break;
-			case Light::Point:
-				ail->mType = aiLightSource_POINT;
-				break;
-			case Light::Spot:
-				ail->mType = aiLightSource_SPOT;
-				break;
-		}
+        switch (light.type)
+        {
+        case Light::Directional:
+            ail->mType = aiLightSource_DIRECTIONAL; break;
+        case Light::Point:
+            ail->mType = aiLightSource_POINT; break;
+        case Light::Spot:
+            ail->mType = aiLightSource_SPOT; break;
+        }
 
-		if (ail->mType != aiLightSource_POINT) {
-			ail->mDirection = aiVector3D(0.0f, 0.0f, -1.0f);
-			ail->mUp = aiVector3D(0.0f, 1.0f, 0.0f);
-		}
+        if (ail->mType != aiLightSource_POINT)
+        {
+            ail->mDirection = aiVector3D(0.0f, 0.0f, -1.0f);
+            ail->mUp = aiVector3D(0.0f, 1.0f, 0.0f);
+        }
 
-		vec3 colorWithIntensity = { light.color[0] * light.intensity, light.color[1] * light.intensity, light.color[2] * light.intensity };
-		CopyValue(colorWithIntensity, ail->mColorAmbient);
-		CopyValue(colorWithIntensity, ail->mColorDiffuse);
-		CopyValue(colorWithIntensity, ail->mColorSpecular);
+        vec3 colorWithIntensity = { light.color[0] * light.intensity, light.color[1] * light.intensity, light.color[2] * light.intensity };
+        CopyValue(colorWithIntensity, ail->mColorAmbient);
+        CopyValue(colorWithIntensity, ail->mColorDiffuse);
+        CopyValue(colorWithIntensity, ail->mColorSpecular);
 
-		if (ail->mType == aiLightSource_DIRECTIONAL) {
-			ail->mAttenuationConstant = 1.0;
-			ail->mAttenuationLinear = 0.0;
-			ail->mAttenuationQuadratic = 0.0;
-		} else {
-			//in PBR attenuation is calculated using inverse square law which can be expressed
-			//using assimps equation: 1/(att0 + att1 * d + att2 * d*d) with the following parameters
-			//this is correct equation for the case when range (see
-			//https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_lights_punctual)
-			//is not present. When range is not present it is assumed that it is infinite and so numerator is 1.
-			//When range is present then numerator might be any value in range [0,1] and then assimps equation
-			//will not suffice. In this case range is added into metadata in ImportNode function
-			//and its up to implementation to read it when it wants to
-			ail->mAttenuationConstant = 0.0;
-			ail->mAttenuationLinear = 0.0;
-			ail->mAttenuationQuadratic = 1.0;
-		}
+        if (ail->mType == aiLightSource_DIRECTIONAL)
+        {
+            ail->mAttenuationConstant = 1.0;
+            ail->mAttenuationLinear = 0.0;
+            ail->mAttenuationQuadratic = 0.0;
+        }
+        else
+        {
+            //in PBR attenuation is calculated using inverse square law which can be expressed
+            //using assimps equation: 1/(att0 + att1 * d + att2 * d*d) with the following parameters
+            //this is correct equation for the case when range (see
+            //https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_lights_punctual)
+            //is not present. When range is not present it is assumed that it is infinite and so numerator is 1.
+            //When range is present then numerator might be any value in range [0,1] and then assimps equation
+            //will not suffice. In this case range is added into metadata in ImportNode function
+            //and its up to implementation to read it when it wants to
+            ail->mAttenuationConstant = 0.0;
+            ail->mAttenuationLinear = 0.0;
+            ail->mAttenuationQuadratic = 1.0;
+        }
 
-		if (ail->mType == aiLightSource_SPOT) {
-			ail->mAngleInnerCone = light.innerConeAngle;
-			ail->mAngleOuterCone = light.outerConeAngle;
-		}
-	}
+        if (ail->mType == aiLightSource_SPOT)
+        {
+            ail->mAngleInnerCone = light.innerConeAngle;
+            ail->mAngleOuterCone = light.outerConeAngle;
+        }
+    }
 }
 
-static void GetNodeTransform(aiMatrix4x4 &matrix, const glTF2::Node &node) {
-	if (node.matrix.isPresent) {
-		CopyValue(node.matrix.value, matrix);
-	} else {
-		if (node.translation.isPresent) {
-			aiVector3D trans;
-			CopyValue(node.translation.value, trans);
-			aiMatrix4x4 t;
-			aiMatrix4x4::Translation(trans, t);
-			matrix = matrix * t;
-		}
+static void GetNodeTransform(aiMatrix4x4& matrix, const glTF2::Node& node) {
+    if (node.matrix.isPresent) {
+        CopyValue(node.matrix.value, matrix);
+    }
+    else {
+        if (node.translation.isPresent) {
+            aiVector3D trans;
+            CopyValue(node.translation.value, trans);
+            aiMatrix4x4 t;
+            aiMatrix4x4::Translation(trans, t);
+            matrix = matrix * t;
+        }
 
-		if (node.rotation.isPresent) {
-			aiQuaternion rot;
-			CopyValue(node.rotation.value, rot);
-			matrix = matrix * aiMatrix4x4(rot.GetMatrix());
-		}
+        if (node.rotation.isPresent) {
+            aiQuaternion rot;
+            CopyValue(node.rotation.value, rot);
+            matrix = matrix * aiMatrix4x4(rot.GetMatrix());
+        }
 
-		if (node.scale.isPresent) {
-			aiVector3D scal(1.f);
-			CopyValue(node.scale.value, scal);
-			aiMatrix4x4 s;
-			aiMatrix4x4::Scaling(scal, s);
-			matrix = matrix * s;
-		}
-	}
+        if (node.scale.isPresent) {
+            aiVector3D scal(1.f);
+            CopyValue(node.scale.value, scal);
+            aiMatrix4x4 s;
+            aiMatrix4x4::Scaling(scal, s);
+            matrix = matrix * s;
+        }
+    }
 }
 
-static void BuildVertexWeightMapping(Mesh::Primitive &primitive, std::vector<std::vector<aiVertexWeight>> &map) {
-	Mesh::Primitive::Attributes &attr = primitive.attributes;
-	if (attr.weight.empty() || attr.joint.empty()) {
-		return;
-	}
-	if (attr.weight[0]->count != attr.joint[0]->count) {
-		return;
-	}
-
-	size_t num_vertices = attr.weight[0]->count;
-
-	struct Weights {
-		float values[4];
-	};
-	Weights *weights = nullptr;
-	attr.weight[0]->ExtractData(weights);
-
-	struct Indices8 {
-		uint8_t values[4];
-	};
-	struct Indices16 {
-		uint16_t values[4];
-	};
-	Indices8 *indices8 = nullptr;
-	Indices16 *indices16 = nullptr;
-	if (attr.joint[0]->GetElementSize() == 4) {
-		attr.joint[0]->ExtractData(indices8);
-	} else {
-		attr.joint[0]->ExtractData(indices16);
-	}
-	//
-	if (nullptr == indices8 && nullptr == indices16) {
-		// Something went completely wrong!
-		ai_assert(false);
-		return;
-	}
-
-	for (size_t i = 0; i < num_vertices; ++i) {
-		for (int j = 0; j < 4; ++j) {
-			const unsigned int bone = (indices8 != nullptr) ? indices8[i].values[j] : indices16[i].values[j];
-			const float weight = weights[i].values[j];
-			if (weight > 0 && bone < map.size()) {
-				map[bone].reserve(8);
-				map[bone].emplace_back(static_cast<unsigned int>(i), weight);
-			}
-		}
-	}
-
-	delete[] weights;
-	delete[] indices8;
-	delete[] indices16;
-}
-
-static std::string GetNodeName(const Node &node) {
-	return node.name.empty() ? node.id : node.name;
-}
-
-aiNode *ImportNode(aiScene *pScene, glTF2::Asset &r, std::vector<unsigned int> &meshOffsets, glTF2::Ref<glTF2::Node> &ptr) {
-	Node &node = *ptr;
-
-	aiNode *ainode = new aiNode(GetNodeName(node));
-
-	if (!node.children.empty()) {
-		ainode->mNumChildren = unsigned(node.children.size());
-		ainode->mChildren = new aiNode *[ainode->mNumChildren];
-
-		for (unsigned int i = 0; i < ainode->mNumChildren; ++i) {
-			aiNode *child = ImportNode(pScene, r, meshOffsets, node.children[i]);
-			child->mParent = ainode;
-			ainode->mChildren[i] = child;
-		}
-	}
-
-	GetNodeTransform(ainode->mTransformation, node);
-
-	if (!node.meshes.empty()) {
-		// GLTF files contain at most 1 mesh per node.
-		assert(node.meshes.size() == 1);
-		int mesh_idx = node.meshes[0].GetIndex();
-		int count = meshOffsets[mesh_idx + 1] - meshOffsets[mesh_idx];
-
-		ainode->mNumMeshes = count;
-		ainode->mMeshes = new unsigned int[count];
-
-		if (node.skin) {
-			for (int primitiveNo = 0; primitiveNo < count; ++primitiveNo) {
-				aiMesh *mesh = pScene->mMeshes[meshOffsets[mesh_idx] + primitiveNo];
-				unsigned int numBones =static_cast<unsigned int>(node.skin->jointNames.size());
-
-				std::vector<std::vector<aiVertexWeight>> weighting(numBones);
-				BuildVertexWeightMapping(node.meshes[0]->primitives[primitiveNo], weighting);
-
-				unsigned int realNumBones = 0;
-				for (uint32_t i = 0; i < numBones; ++i) {
-					if (weighting[i].size() > 0) {
-						realNumBones++;
-					}
-				}
-
-				mesh->mNumBones = static_cast<unsigned int>(realNumBones);
-				mesh->mBones = new aiBone *[mesh->mNumBones];
-
-				// GLTF and Assimp choose to store bone weights differently.
-				// GLTF has each vertex specify which bones influence the vertex.
-				// Assimp has each bone specify which vertices it has influence over.
-				// To convert this data, we first read over the vertex data and pull
-				// out the bone-to-vertex mapping.  Then, when creating the aiBones,
-				// we copy the bone-to-vertex mapping into the bone.  This is unfortunate
-				// both because it's somewhat slow and because, for many applications,
-				// we then need to reconvert the data back into the vertex-to-bone
-				// mapping which makes things doubly-slow.
-
-				mat4 *pbindMatrices = nullptr;
-				node.skin->inverseBindMatrices->ExtractData(pbindMatrices);
-
-				int cb = 0;
-				for (uint32_t i = 0; i < numBones; ++i) {
-					const std::vector<aiVertexWeight> &weights = weighting[i];
-					if (weights.size() > 0) {
-						aiBone *bone = new aiBone();
-
-						Ref<Node> joint = node.skin->jointNames[i];
-						if (!joint->name.empty()) {
-							bone->mName = joint->name;
-						} else {
-							// Assimp expects each bone to have a unique name.
-							static const std::string kDefaultName = "bone_";
-							char postfix[10] = { 0 };
-							ASSIMP_itoa10(postfix, i);
-							bone->mName = (kDefaultName + postfix);
-						}
-						GetNodeTransform(bone->mOffsetMatrix, *joint);
-						CopyValue(pbindMatrices[i], bone->mOffsetMatrix);
-						bone->mNumWeights = static_cast<uint32_t>(weights.size());
-						bone->mWeights = new aiVertexWeight[bone->mNumWeights];
-						memcpy(bone->mWeights, weights.data(), bone->mNumWeights * sizeof(aiVertexWeight));
-						mesh->mBones[cb++] = bone;
-					}
-				}
-
-				if (pbindMatrices) {
-					delete[] pbindMatrices;
-				}
-			}
-		}
-
-		int k = 0;
-		for (unsigned int j = meshOffsets[mesh_idx]; j < meshOffsets[mesh_idx + 1]; ++j, ++k) {
-			ainode->mMeshes[k] = j;
-		}
-	}
-
-	if (node.camera) {
-		pScene->mCameras[node.camera.GetIndex()]->mName = ainode->mName;
-		if (node.translation.isPresent) {
-			aiVector3D trans;
-			CopyValue(node.translation.value, trans);
-			pScene->mCameras[node.camera.GetIndex()]->mPosition = trans;
-		}
-	}
-
-	if (node.light) {
-		pScene->mLights[node.light.GetIndex()]->mName = ainode->mName;
-
-		//range is optional - see https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_lights_punctual
-		//it is added to meta data of parent node, because there is no other place to put it
-		if (node.light->range.isPresent) {
-			ainode->mMetaData = aiMetadata::Alloc(1);
-			ainode->mMetaData->Set(0, "PBR_LightRange", node.light->range.value);
-		}
-	}
-
-	return ainode;
-}
-
-void glTF2Importer::ImportNodes(glTF2::Asset &r) {
-	if (!r.scene) {
+static void BuildVertexWeightMapping(Mesh::Primitive& primitive, std::vector<std::vector<aiVertexWeight>>& map)
+{
+    Mesh::Primitive::Attributes& attr = primitive.attributes;
+    if (attr.weight.empty() || attr.joint.empty()) {
+        return;
+    }
+    if (attr.weight[0]->count != attr.joint[0]->count) {
         return;
     }
 
-	std::vector<Ref<Node>> rootNodes = r.scene->nodes;
+    size_t num_vertices = attr.weight[0]->count;
 
-	// The root nodes
-	unsigned int numRootNodes = unsigned(rootNodes.size());
-	if (numRootNodes == 1) { // a single root node: use it
-		mScene->mRootNode = ImportNode(mScene, r, meshOffsets, rootNodes[0]);
-	} else if (numRootNodes > 1) { // more than one root node: create a fake root
-		aiNode *root = new aiNode("ROOT");
-		root->mChildren = new aiNode *[numRootNodes];
-		for (unsigned int i = 0; i < numRootNodes; ++i) {
-			aiNode *node = ImportNode(mScene, r, meshOffsets, rootNodes[i]);
-			node->mParent = root;
-			root->mChildren[root->mNumChildren++] = node;
-		}
-		mScene->mRootNode = root;
-	}
+    struct Weights { float values[4]; };
+    Weights* weights = nullptr;
+    attr.weight[0]->ExtractData(weights);
+
+    struct Indices8 { uint8_t values[4]; };
+    struct Indices16 { uint16_t values[4]; };
+    Indices8* indices8 = nullptr;
+    Indices16* indices16 = nullptr;
+    if (attr.joint[0]->GetElementSize() == 4) {
+        attr.joint[0]->ExtractData(indices8);
+    }else {
+        attr.joint[0]->ExtractData(indices16);
+    }
+    // 
+    if (nullptr == indices8 && nullptr == indices16) {
+        // Something went completely wrong!
+        ai_assert(false);
+        return;
+    }
+
+    for (size_t i = 0; i < num_vertices; ++i) {
+        for (int j = 0; j < 4; ++j) {
+            const unsigned int bone = (indices8!=nullptr) ? indices8[i].values[j] : indices16[i].values[j];
+            const float weight = weights[i].values[j];
+            if (weight > 0 && bone < map.size()) {
+                map[bone].reserve(8);
+                map[bone].emplace_back(static_cast<unsigned int>(i), weight);
+            }
+        }
+    }
+
+    delete[] weights;
+    delete[] indices8;
+    delete[] indices16;
+}
+
+static std::string GetNodeName(const Node& node)
+{
+    return node.name.empty() ? node.id : node.name;
+}
+
+aiNode* ImportNode(aiScene* pScene, glTF2::Asset& r, std::vector<unsigned int>& meshOffsets, glTF2::Ref<glTF2::Node>& ptr)
+{
+    Node& node = *ptr;
+
+    aiNode* ainode = new aiNode(GetNodeName(node));
+
+    if (!node.children.empty()) {
+        ainode->mNumChildren = unsigned(node.children.size());
+        ainode->mChildren = new aiNode*[ainode->mNumChildren];
+
+        for (unsigned int i = 0; i < ainode->mNumChildren; ++i) {
+            aiNode* child = ImportNode(pScene, r, meshOffsets, node.children[i]);
+            child->mParent = ainode;
+            ainode->mChildren[i] = child;
+        }
+    }
+
+    GetNodeTransform(ainode->mTransformation, node);
+
+    if (!node.meshes.empty()) {
+        // GLTF files contain at most 1 mesh per node.
+        assert(node.meshes.size() == 1);
+        int mesh_idx = node.meshes[0].GetIndex();
+        int count = meshOffsets[mesh_idx + 1] - meshOffsets[mesh_idx];
+
+        ainode->mNumMeshes = count;
+        ainode->mMeshes = new unsigned int[count];
+
+        if (node.skin) {
+            for (int primitiveNo = 0; primitiveNo < count; ++primitiveNo) {
+                aiMesh* mesh = pScene->mMeshes[meshOffsets[mesh_idx]+primitiveNo];
+                mesh->mNumBones = static_cast<unsigned int>(node.skin->jointNames.size());
+                mesh->mBones = new aiBone*[mesh->mNumBones];
+
+                // GLTF and Assimp choose to store bone weights differently.
+                // GLTF has each vertex specify which bones influence the vertex.
+                // Assimp has each bone specify which vertices it has influence over.
+                // To convert this data, we first read over the vertex data and pull
+                // out the bone-to-vertex mapping.  Then, when creating the aiBones,
+                // we copy the bone-to-vertex mapping into the bone.  This is unfortunate
+                // both because it's somewhat slow and because, for many applications,
+                // we then need to reconvert the data back into the vertex-to-bone
+                // mapping which makes things doubly-slow.
+                std::vector<std::vector<aiVertexWeight>> weighting(mesh->mNumBones);
+                BuildVertexWeightMapping(node.meshes[0]->primitives[primitiveNo], weighting);
+
+                mat4* pbindMatrices = nullptr;
+                node.skin->inverseBindMatrices->ExtractData(pbindMatrices);
+
+                for (uint32_t i = 0; i < mesh->mNumBones; ++i) {
+                    aiBone* bone = new aiBone();
+
+                    Ref<Node> joint = node.skin->jointNames[i];
+                    if (!joint->name.empty()) {
+                      bone->mName = joint->name;
+                    } else {
+                      // Assimp expects each bone to have a unique name.
+                      static const std::string kDefaultName = "bone_";
+                      char postfix[10] = {0};
+                      ASSIMP_itoa10(postfix, i);
+                      bone->mName = (kDefaultName + postfix);
+                    }
+                    GetNodeTransform(bone->mOffsetMatrix, *joint);
+
+                    CopyValue(pbindMatrices[i], bone->mOffsetMatrix);
+
+                    std::vector<aiVertexWeight>& weights = weighting[i];
+
+                    bone->mNumWeights = static_cast<uint32_t>(weights.size());
+                    if (bone->mNumWeights > 0) {
+                      bone->mWeights = new aiVertexWeight[bone->mNumWeights];
+                      memcpy(bone->mWeights, weights.data(), bone->mNumWeights * sizeof(aiVertexWeight));
+                    } else {
+                      // Assimp expects all bones to have at least 1 weight.
+                      bone->mWeights = new aiVertexWeight[1];
+                      bone->mNumWeights = 1;
+                      bone->mWeights->mVertexId = 0;
+                      bone->mWeights->mWeight = 0.f;
+                    }
+                    mesh->mBones[i] = bone;
+                }
+
+                if (pbindMatrices) {
+                    delete[] pbindMatrices;
+                }
+            }
+        }
+
+        int k = 0;
+        for (unsigned int j = meshOffsets[mesh_idx]; j < meshOffsets[mesh_idx + 1]; ++j, ++k) {
+            ainode->mMeshes[k] = j;
+        }
+    }
+
+    if (node.camera) {
+        pScene->mCameras[node.camera.GetIndex()]->mName = ainode->mName;
+    }
+
+    if (node.light) {
+        pScene->mLights[node.light.GetIndex()]->mName = ainode->mName;
+
+        //range is optional - see https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_lights_punctual
+        //it is added to meta data of parent node, because there is no other place to put it
+        if (node.light->range.isPresent)
+        {
+            ainode->mMetaData = aiMetadata::Alloc(1);
+            ainode->mMetaData->Set(0, "PBR_LightRange", node.light->range.value);
+        }
+    }
+
+    return ainode;
+}
+
+void glTF2Importer::ImportNodes(glTF2::Asset& r)
+{
+    if (!r.scene) return;
+
+    std::vector< Ref<Node> > rootNodes = r.scene->nodes;
+
+    // The root nodes
+    unsigned int numRootNodes = unsigned(rootNodes.size());
+    if (numRootNodes == 1) { // a single root node: use it
+        mScene->mRootNode = ImportNode(mScene, r, meshOffsets, rootNodes[0]);
+    }
+    else if (numRootNodes > 1) { // more than one root node: create a fake root
+        aiNode* root = new aiNode("ROOT");
+        root->mChildren = new aiNode*[numRootNodes];
+        for (unsigned int i = 0; i < numRootNodes; ++i) {
+            aiNode* node = ImportNode(mScene, r, meshOffsets, rootNodes[i]);
+            node->mParent = root;
+            root->mChildren[root->mNumChildren++] = node;
+        }
+        mScene->mRootNode = root;
+    }
+
+    //if (!mScene->mRootNode) {
+    //  mScene->mRootNode = new aiNode("EMPTY");
+    //}
 }
 
 struct AnimationSamplers {
-	AnimationSamplers() :
-			translation(nullptr),
-			rotation(nullptr),
-			scale(nullptr),
-			weight(nullptr) {
-		// empty
-	}
+    AnimationSamplers()
+    : translation(nullptr)
+    , rotation(nullptr)
+    , scale(nullptr) {
+        // empty
+    }
 
-	Animation::Sampler *translation;
-	Animation::Sampler *rotation;
-	Animation::Sampler *scale;
-	Animation::Sampler *weight;
+    Animation::Sampler* translation;
+    Animation::Sampler* rotation;
+    Animation::Sampler* scale;
 };
 
-aiNodeAnim *CreateNodeAnim(glTF2::Asset &r, Node &node, AnimationSamplers &samplers) {
-	aiNodeAnim *anim = new aiNodeAnim();
-	anim->mNodeName = GetNodeName(node);
+aiNodeAnim* CreateNodeAnim(glTF2::Asset& r, Node& node, AnimationSamplers& samplers)
+{
+    aiNodeAnim* anim = new aiNodeAnim();
+    anim->mNodeName = GetNodeName(node);
 
-	static const float kMillisecondsFromSeconds = 1000.f;
+    static const float kMillisecondsFromSeconds = 1000.f;
 
-	if (samplers.translation) {
-		float *times = nullptr;
-		samplers.translation->input->ExtractData(times);
-		aiVector3D *values = nullptr;
-		samplers.translation->output->ExtractData(values);
-		anim->mNumPositionKeys = static_cast<uint32_t>(samplers.translation->input->count);
-		anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys];
-		for (unsigned int i = 0; i < anim->mNumPositionKeys; ++i) {
-			anim->mPositionKeys[i].mTime = times[i] * kMillisecondsFromSeconds;
-			anim->mPositionKeys[i].mValue = values[i];
-		}
-		delete[] times;
-		delete[] values;
-	} else if (node.translation.isPresent) {
-		anim->mNumPositionKeys = 1;
-		anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys];
-		anim->mPositionKeys->mTime = 0.f;
-		anim->mPositionKeys->mValue.x = node.translation.value[0];
-		anim->mPositionKeys->mValue.y = node.translation.value[1];
-		anim->mPositionKeys->mValue.z = node.translation.value[2];
-	}
+    if (samplers.translation) {
+        float* times = nullptr;
+        samplers.translation->input->ExtractData(times);
+        aiVector3D* values = nullptr;
+        samplers.translation->output->ExtractData(values);
+        anim->mNumPositionKeys = static_cast<uint32_t>(samplers.translation->input->count);
+        anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys];
+        for (unsigned int i = 0; i < anim->mNumPositionKeys; ++i) {
+            anim->mPositionKeys[i].mTime = times[i] * kMillisecondsFromSeconds;
+            anim->mPositionKeys[i].mValue = values[i];
+        }
+        delete[] times;
+        delete[] values;
+    } else if (node.translation.isPresent) {
+        anim->mNumPositionKeys = 1;
+        anim->mPositionKeys = new aiVectorKey();
+        anim->mPositionKeys->mTime = 0.f;
+        anim->mPositionKeys->mValue.x = node.translation.value[0];
+        anim->mPositionKeys->mValue.y = node.translation.value[1];
+        anim->mPositionKeys->mValue.z = node.translation.value[2];
+    }
 
-	if (samplers.rotation) {
-		float *times = nullptr;
-		samplers.rotation->input->ExtractData(times);
-		aiQuaternion *values = nullptr;
-		samplers.rotation->output->ExtractData(values);
-		anim->mNumRotationKeys = static_cast<uint32_t>(samplers.rotation->input->count);
-		anim->mRotationKeys = new aiQuatKey[anim->mNumRotationKeys];
-		for (unsigned int i = 0; i < anim->mNumRotationKeys; ++i) {
-			anim->mRotationKeys[i].mTime = times[i] * kMillisecondsFromSeconds;
-			anim->mRotationKeys[i].mValue.x = values[i].w;
-			anim->mRotationKeys[i].mValue.y = values[i].x;
-			anim->mRotationKeys[i].mValue.z = values[i].y;
-			anim->mRotationKeys[i].mValue.w = values[i].z;
-		}
-		delete[] times;
-		delete[] values;
-	} else if (node.rotation.isPresent) {
-		anim->mNumRotationKeys = 1;
-		anim->mRotationKeys = new aiQuatKey[anim->mNumRotationKeys];
-		anim->mRotationKeys->mTime = 0.f;
-		anim->mRotationKeys->mValue.x = node.rotation.value[0];
-		anim->mRotationKeys->mValue.y = node.rotation.value[1];
-		anim->mRotationKeys->mValue.z = node.rotation.value[2];
-		anim->mRotationKeys->mValue.w = node.rotation.value[3];
-	}
+    if (samplers.rotation) {
+        float* times = nullptr;
+        samplers.rotation->input->ExtractData(times);
+        aiQuaternion* values = nullptr;
+        samplers.rotation->output->ExtractData(values);
+        anim->mNumRotationKeys = static_cast<uint32_t>(samplers.rotation->input->count);
+        anim->mRotationKeys = new aiQuatKey[anim->mNumRotationKeys];
+        for (unsigned int i = 0; i < anim->mNumRotationKeys; ++i) {
+            anim->mRotationKeys[i].mTime = times[i] * kMillisecondsFromSeconds;
+            anim->mRotationKeys[i].mValue.x = values[i].w;
+            anim->mRotationKeys[i].mValue.y = values[i].x;
+            anim->mRotationKeys[i].mValue.z = values[i].y;
+            anim->mRotationKeys[i].mValue.w = values[i].z;
+        }
+        delete[] times;
+        delete[] values;
+    } else if (node.rotation.isPresent) {
+        anim->mNumRotationKeys = 1;
+        anim->mRotationKeys = new aiQuatKey[anim->mNumRotationKeys];
+        anim->mRotationKeys->mTime = 0.f;
+        anim->mRotationKeys->mValue.x = node.rotation.value[0];
+        anim->mRotationKeys->mValue.y = node.rotation.value[1];
+        anim->mRotationKeys->mValue.z = node.rotation.value[2];
+        anim->mRotationKeys->mValue.w = node.rotation.value[3];
+    }
 
-	if (samplers.scale) {
-		float *times = nullptr;
-		samplers.scale->input->ExtractData(times);
-		aiVector3D *values = nullptr;
-		samplers.scale->output->ExtractData(values);
-		anim->mNumScalingKeys = static_cast<uint32_t>(samplers.scale->input->count);
-		anim->mScalingKeys = new aiVectorKey[anim->mNumScalingKeys];
-		for (unsigned int i = 0; i < anim->mNumScalingKeys; ++i) {
-			anim->mScalingKeys[i].mTime = times[i] * kMillisecondsFromSeconds;
-			anim->mScalingKeys[i].mValue = values[i];
-		}
-		delete[] times;
-		delete[] values;
-	} else if (node.scale.isPresent) {
-		anim->mNumScalingKeys = 1;
-		anim->mScalingKeys = new aiVectorKey[anim->mNumScalingKeys];
-		anim->mScalingKeys->mTime = 0.f;
-		anim->mScalingKeys->mValue.x = node.scale.value[0];
-		anim->mScalingKeys->mValue.y = node.scale.value[1];
-		anim->mScalingKeys->mValue.z = node.scale.value[2];
-	}
+    if (samplers.scale) {
+        float* times = nullptr;
+        samplers.scale->input->ExtractData(times);
+        aiVector3D* values = nullptr;
+        samplers.scale->output->ExtractData(values);
+        anim->mNumScalingKeys = static_cast<uint32_t>(samplers.scale->input->count);
+        anim->mScalingKeys = new aiVectorKey[anim->mNumScalingKeys];
+        for (unsigned int i = 0; i < anim->mNumScalingKeys; ++i) {
+            anim->mScalingKeys[i].mTime = times[i] * kMillisecondsFromSeconds;
+            anim->mScalingKeys[i].mValue = values[i];
+        }
+        delete[] times;
+        delete[] values;
+    } else if (node.scale.isPresent) {
+        anim->mNumScalingKeys = 1;
+        anim->mScalingKeys = new aiVectorKey[anim->mNumScalingKeys];
+        anim->mScalingKeys->mTime = 0.f;
+        anim->mScalingKeys->mValue.x = node.scale.value[0];
+        anim->mScalingKeys->mValue.y = node.scale.value[1];
+        anim->mScalingKeys->mValue.z = node.scale.value[2];
+    }
 
-	return anim;
+    return anim;
 }
 
-aiMeshMorphAnim *CreateMeshMorphAnim(glTF2::Asset &r, Node &node, AnimationSamplers &samplers) {
-	aiMeshMorphAnim *anim = new aiMeshMorphAnim();
-	anim->mName = GetNodeName(node);
+std::unordered_map<unsigned int, AnimationSamplers> GatherSamplers(Animation& anim)
+{
+    std::unordered_map<unsigned int, AnimationSamplers> samplers;
+    for (unsigned int c = 0; c < anim.channels.size(); ++c) {
+        Animation::Channel& channel = anim.channels[c];
+        if (channel.sampler >= static_cast<int>(anim.samplers.size())) {
+            continue;
+        }
 
-	static const float kMillisecondsFromSeconds = 1000.f;
+        const unsigned int node_index = channel.target.node.GetIndex();
 
-	if (nullptr != samplers.weight) {
-		float *times = nullptr;
-		samplers.weight->input->ExtractData(times);
-		float *values = nullptr;
-		samplers.weight->output->ExtractData(values);
-		anim->mNumKeys = static_cast<uint32_t>(samplers.weight->input->count);
+        AnimationSamplers& sampler = samplers[node_index];
+        if (channel.target.path == AnimationPath_TRANSLATION) {
+            sampler.translation = &anim.samplers[channel.sampler];
+        } else if (channel.target.path == AnimationPath_ROTATION) {
+            sampler.rotation = &anim.samplers[channel.sampler];
+        } else if (channel.target.path == AnimationPath_SCALE) {
+            sampler.scale = &anim.samplers[channel.sampler];
+        }
+    }
 
-		const unsigned int numMorphs = (unsigned int)samplers.weight->output->count / anim->mNumKeys;
-
-		anim->mKeys = new aiMeshMorphKey[anim->mNumKeys];
-		unsigned int k = 0u;
-		for (unsigned int i = 0u; i < anim->mNumKeys; ++i) {
-			anim->mKeys[i].mTime = times[i] * kMillisecondsFromSeconds;
-			anim->mKeys[i].mNumValuesAndWeights = numMorphs;
-			anim->mKeys[i].mValues = new unsigned int[numMorphs];
-			anim->mKeys[i].mWeights = new double[numMorphs];
-
-			for (unsigned int j = 0u; j < numMorphs; ++j, ++k) {
-				anim->mKeys[i].mValues[j] = j;
-				anim->mKeys[i].mWeights[j] = (0.f > values[k]) ? 0.f : values[k];
-			}
-		}
-
-		delete[] times;
-		delete[] values;
-	}
-
-	return anim;
+    return samplers;
 }
 
-std::unordered_map<unsigned int, AnimationSamplers> GatherSamplers(Animation &anim) {
-	std::unordered_map<unsigned int, AnimationSamplers> samplers;
-	for (unsigned int c = 0; c < anim.channels.size(); ++c) {
-		Animation::Channel &channel = anim.channels[c];
-		if (channel.sampler >= static_cast<int>(anim.samplers.size())) {
-			continue;
-		}
+void glTF2Importer::ImportAnimations(glTF2::Asset& r)
+{
+    if (!r.scene) return;
 
-		const unsigned int node_index = channel.target.node.GetIndex();
+    mScene->mNumAnimations = r.animations.Size();
+    if (mScene->mNumAnimations == 0) {
+        return;
+    }
 
-		AnimationSamplers &sampler = samplers[node_index];
-		if (channel.target.path == AnimationPath_TRANSLATION) {
-			sampler.translation = &anim.samplers[channel.sampler];
-		} else if (channel.target.path == AnimationPath_ROTATION) {
-			sampler.rotation = &anim.samplers[channel.sampler];
-		} else if (channel.target.path == AnimationPath_SCALE) {
-			sampler.scale = &anim.samplers[channel.sampler];
-		} else if (channel.target.path == AnimationPath_WEIGHTS) {
-			sampler.weight = &anim.samplers[channel.sampler];
-		}
-	}
+    mScene->mAnimations = new aiAnimation*[mScene->mNumAnimations];
+    for (unsigned int i = 0; i < r.animations.Size(); ++i) {
+        Animation& anim = r.animations[i];
 
-	return samplers;
-}
+        aiAnimation* ai_anim = new aiAnimation();
+        ai_anim->mName = anim.name;
+        ai_anim->mDuration = 0;
+        ai_anim->mTicksPerSecond = 0;
 
-void glTF2Importer::ImportAnimations(glTF2::Asset &r) {
-	if (!r.scene) return;
+        std::unordered_map<unsigned int, AnimationSamplers> samplers = GatherSamplers(anim);
 
-	mScene->mNumAnimations = r.animations.Size();
-	if (mScene->mNumAnimations == 0) {
-		return;
-	}
+        ai_anim->mNumChannels = static_cast<uint32_t>(samplers.size());
+        if (ai_anim->mNumChannels > 0) {
+            ai_anim->mChannels = new aiNodeAnim*[ai_anim->mNumChannels];
+            int j = 0;
+            for (auto& iter : samplers) {
+                ai_anim->mChannels[j] = CreateNodeAnim(r, r.nodes[iter.first], iter.second);
+                ++j;
+            }
+        }
 
-	mScene->mAnimations = new aiAnimation *[mScene->mNumAnimations];
-	for (unsigned int i = 0; i < r.animations.Size(); ++i) {
-		Animation &anim = r.animations[i];
-
-		aiAnimation *ai_anim = new aiAnimation();
-		ai_anim->mName = anim.name;
-		ai_anim->mDuration = 0;
-		ai_anim->mTicksPerSecond = 0;
-
-		std::unordered_map<unsigned int, AnimationSamplers> samplers = GatherSamplers(anim);
-
-		uint32_t numChannels = 0u;
-		uint32_t numMorphMeshChannels = 0u;
-
-		for (auto &iter : samplers) {
-			if ((nullptr != iter.second.rotation) || (nullptr != iter.second.scale) || (nullptr != iter.second.translation)) {
-				++numChannels;
-			}
-			if (nullptr != iter.second.weight) {
-				++numMorphMeshChannels;
-			}
-		}
-
-		ai_anim->mNumChannels = numChannels;
-		if (ai_anim->mNumChannels > 0) {
-			ai_anim->mChannels = new aiNodeAnim *[ai_anim->mNumChannels];
-			int j = 0;
-			for (auto &iter : samplers) {
-				if ((nullptr != iter.second.rotation) || (nullptr != iter.second.scale) || (nullptr != iter.second.translation)) {
-					ai_anim->mChannels[j] = CreateNodeAnim(r, r.nodes[iter.first], iter.second);
-					++j;
-				}
-			}
-		}
-
-		ai_anim->mNumMorphMeshChannels = numMorphMeshChannels;
-		if (ai_anim->mNumMorphMeshChannels > 0) {
-			ai_anim->mMorphMeshChannels = new aiMeshMorphAnim *[ai_anim->mNumMorphMeshChannels];
-			int j = 0;
-			for (auto &iter : samplers) {
-				if (nullptr != iter.second.weight) {
-					ai_anim->mMorphMeshChannels[j] = CreateMeshMorphAnim(r, r.nodes[iter.first], iter.second);
-					++j;
-				}
-			}
-		}
-
-		// Use the latest keyframe for the duration of the animation
-		double maxDuration = 0;
-		unsigned int maxNumberOfKeys = 0;
-		for (unsigned int j = 0; j < ai_anim->mNumChannels; ++j) {
-			auto chan = ai_anim->mChannels[j];
-			if (chan->mNumPositionKeys) {
-				auto lastPosKey = chan->mPositionKeys[chan->mNumPositionKeys - 1];
-				if (lastPosKey.mTime > maxDuration) {
-					maxDuration = lastPosKey.mTime;
-				}
-				maxNumberOfKeys = std::max(maxNumberOfKeys, chan->mNumPositionKeys);
-			}
-			if (chan->mNumRotationKeys) {
-				auto lastRotKey = chan->mRotationKeys[chan->mNumRotationKeys - 1];
-				if (lastRotKey.mTime > maxDuration) {
-					maxDuration = lastRotKey.mTime;
-				}
-				maxNumberOfKeys = std::max(maxNumberOfKeys, chan->mNumRotationKeys);
-			}
-			if (chan->mNumScalingKeys) {
-				auto lastScaleKey = chan->mScalingKeys[chan->mNumScalingKeys - 1];
-				if (lastScaleKey.mTime > maxDuration) {
-					maxDuration = lastScaleKey.mTime;
-				}
-				maxNumberOfKeys = std::max(maxNumberOfKeys, chan->mNumScalingKeys);
-			}
-		}
-
-		for (unsigned int j = 0; j < ai_anim->mNumMorphMeshChannels; ++j) {
-			const auto *const chan = ai_anim->mMorphMeshChannels[j];
-
-			if (0u != chan->mNumKeys) {
-				const auto &lastKey = chan->mKeys[chan->mNumKeys - 1u];
-				if (lastKey.mTime > maxDuration) {
-					maxDuration = lastKey.mTime;
-				}
-				maxNumberOfKeys = std::max(maxNumberOfKeys, chan->mNumKeys);
-			}
-		}
-
-		ai_anim->mDuration = maxDuration;
-		ai_anim->mTicksPerSecond = 1000.0;
-
-		mScene->mAnimations[i] = ai_anim;
-	}
-}
-
-void glTF2Importer::ImportEmbeddedTextures(glTF2::Asset &r) {
-	embeddedTexIdxs.resize(r.images.Size(), -1);
-
-	int numEmbeddedTexs = 0;
-	for (size_t i = 0; i < r.images.Size(); ++i) {
-		if (r.images[i].HasData()) {
-			numEmbeddedTexs += 1;
-		}
-	}
-
-	if (numEmbeddedTexs == 0)
-		return;
-
-	mScene->mTextures = new aiTexture *[numEmbeddedTexs];
-
-	// Add the embedded textures
-	for (size_t i = 0; i < r.images.Size(); ++i) {
-		Image &img = r.images[i];
-		if (!img.HasData()) {
-			continue;
-		}
-
-		int idx = mScene->mNumTextures++;
-		embeddedTexIdxs[i] = idx;
-
-		aiTexture *tex = mScene->mTextures[idx] = new aiTexture();
-
-		size_t length = img.GetDataLength();
-		void *data = img.StealData();
-
-		tex->mFilename = img.name;
-		tex->mWidth = static_cast<unsigned int>(length);
-		tex->mHeight = 0;
-		tex->pcData = reinterpret_cast<aiTexel *>(data);
-
-		if (!img.mimeType.empty()) {
-			const char *ext = strchr(img.mimeType.c_str(), '/') + 1;
-			if (ext) {
-				if (strcmp(ext, "jpeg") == 0) {
-                    ext = "jpg";
+        // Use the latest keyframe for the duration of the animation
+        double maxDuration = 0;
+        unsigned int maxNumberOfKeys = 0;
+        for (unsigned int j = 0; j < ai_anim->mNumChannels; ++j) {
+            auto chan = ai_anim->mChannels[j];
+            if (chan->mNumPositionKeys) {
+                auto lastPosKey = chan->mPositionKeys[chan->mNumPositionKeys - 1];
+                if (lastPosKey.mTime > maxDuration) {
+                    maxDuration = lastPosKey.mTime;
                 }
+                maxNumberOfKeys = std::max(maxNumberOfKeys, chan->mNumPositionKeys);
+            }
+            if (chan->mNumRotationKeys) {
+                auto lastRotKey = chan->mRotationKeys[chan->mNumRotationKeys - 1];
+                if (lastRotKey.mTime > maxDuration) {
+                    maxDuration = lastRotKey.mTime;
+                }
+                maxNumberOfKeys = std::max(maxNumberOfKeys, chan->mNumRotationKeys);
+            }
+            if (chan->mNumScalingKeys) {
+                auto lastScaleKey = chan->mScalingKeys[chan->mNumScalingKeys - 1];
+                if (lastScaleKey.mTime > maxDuration) {
+                    maxDuration = lastScaleKey.mTime;
+                }
+                maxNumberOfKeys = std::max(maxNumberOfKeys, chan->mNumScalingKeys);
+            }
+        }
+        ai_anim->mDuration = maxDuration;
+        ai_anim->mTicksPerSecond = (maxNumberOfKeys > 0 && maxDuration > 0) ? (maxNumberOfKeys / (maxDuration/1000)) : 30;
 
-				size_t len = strlen(ext);
-				if (len <= 3) {
-					strcpy(tex->achFormatHint, ext);
-				}
-			}
-		}
-	}
+        mScene->mAnimations[i] = ai_anim;
+    }
 }
 
-void glTF2Importer::ImportCommonMetadata(glTF2::Asset& a) {
-    ai_assert(mScene->mMetaData == nullptr);
-    const bool hasVersion = !a.asset.version.empty();
-    const bool hasGenerator = !a.asset.generator.empty();
-    const bool hasCopyright = !a.asset.copyright.empty();
-    if (hasVersion || hasGenerator || hasCopyright) {
-        mScene->mMetaData = new aiMetadata;
-        if (hasVersion) {
-            mScene->mMetaData->Add(AI_METADATA_SOURCE_FORMAT_VERSION, aiString(a.asset.version));
-        }
-        if (hasGenerator) {
-            mScene->mMetaData->Add(AI_METADATA_SOURCE_GENERATOR, aiString(a.asset.generator));
-        }
-        if (hasCopyright) {
-            mScene->mMetaData->Add(AI_METADATA_SOURCE_COPYRIGHT, aiString(a.asset.copyright));
+void glTF2Importer::ImportEmbeddedTextures(glTF2::Asset& r)
+{
+    embeddedTexIdxs.resize(r.images.Size(), -1);
+
+    int numEmbeddedTexs = 0;
+    for (size_t i = 0; i < r.images.Size(); ++i) {
+        if (r.images[i].HasData())
+            numEmbeddedTexs += 1;
+    }
+
+    if (numEmbeddedTexs == 0)
+        return;
+
+    mScene->mTextures = new aiTexture*[numEmbeddedTexs];
+
+    // Add the embedded textures
+    for (size_t i = 0; i < r.images.Size(); ++i) {
+        Image &img = r.images[i];
+        if (!img.HasData()) continue;
+
+        int idx = mScene->mNumTextures++;
+        embeddedTexIdxs[i] = idx;
+
+        aiTexture* tex = mScene->mTextures[idx] = new aiTexture();
+
+        size_t length = img.GetDataLength();
+        void* data = img.StealData();
+
+        tex->mWidth = static_cast<unsigned int>(length);
+        tex->mHeight = 0;
+        tex->pcData = reinterpret_cast<aiTexel*>(data);
+
+        if (!img.mimeType.empty()) {
+            const char* ext = strchr(img.mimeType.c_str(), '/') + 1;
+            if (ext) {
+                if (strcmp(ext, "jpeg") == 0) ext = "jpg";
+
+                size_t len = strlen(ext);
+                if (len <= 3) {
+                    strcpy(tex->achFormatHint, ext);
+                }
+            }
         }
     }
 }
 
-void glTF2Importer::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
-	// clean all member arrays
-	meshOffsets.clear();
-	embeddedTexIdxs.clear();
+void glTF2Importer::InternReadFile(const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler)
+{
+    // clean all member arrays
+    meshOffsets.clear();
+    embeddedTexIdxs.clear();
 
-	this->mScene = pScene;
+    this->mScene = pScene;
 
-	// read the asset file
-	glTF2::Asset asset(pIOHandler);
-	asset.Load(pFile, GetExtension(pFile) == "glb");
+    // read the asset file
+    glTF2::Asset asset(pIOHandler);
+    asset.Load(pFile, GetExtension(pFile) == "glb");
 
-	//
-	// Copy the data out
-	//
+    //
+    // Copy the data out
+    //
 
-	ImportEmbeddedTextures(asset);
-	ImportMaterials(asset);
+    ImportEmbeddedTextures(asset);
+    ImportMaterials(asset);
 
-	ImportMeshes(asset);
+    ImportMeshes(asset);
 
-	ImportCameras(asset);
-	ImportLights(asset);
+    ImportCameras(asset);
+    ImportLights(asset);
 
-	ImportNodes(asset);
+    ImportNodes(asset);
 
-	ImportAnimations(asset);
+    ImportAnimations(asset);
 
-    ImportCommonMetadata(asset);
-
-	if (pScene->mNumMeshes == 0) {
-		pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
-	}
+    if (pScene->mNumMeshes == 0) {
+        pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
+    }
 }
 
 #endif // ASSIMP_BUILD_NO_GLTF_IMPORTER
+
diff --git a/Engine/lib/assimp/code/glTF2/glTF2Importer.h b/Engine/lib/assimp/code/glTF2/glTF2Importer.h
index 5a093a662..091b61ee6 100644
--- a/Engine/lib/assimp/code/glTF2/glTF2Importer.h
+++ b/Engine/lib/assimp/code/glTF2/glTF2Importer.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -84,7 +84,6 @@ private:
     void ImportLights(glTF2::Asset& a);
     void ImportNodes(glTF2::Asset& a);
     void ImportAnimations(glTF2::Asset& a);
-    void ImportCommonMetadata(glTF2::Asset& a);
 };
 
 } // Namespace assimp
diff --git a/Engine/lib/assimp/code/res/assimp.rc b/Engine/lib/assimp/code/res/assimp.rc
index 9ae821b4b..daecf9cf5 100644
--- a/Engine/lib/assimp/code/res/assimp.rc
+++ b/Engine/lib/assimp/code/res/assimp.rc
@@ -52,7 +52,7 @@ BEGIN
             VALUE "FileDescription", "Open Asset Import Library"
             VALUE "FileVersion", VER_FILEVERSION
             VALUE "InternalName", "assimp "
-            VALUE "LegalCopyright", "Copyright (C) 2006-2020"
+            VALUE "LegalCopyright", "Copyright (C) 2006-2019"
             VALUE "OriginalFilename", VER_ORIGINAL_FILENAME_STR
             VALUE "ProductName", "Open Asset Import Library"
             VALUE "ProductVersion", VER_FILEVERSION_STR
diff --git a/Engine/lib/assimp/contrib/CMakeLists.txt b/Engine/lib/assimp/contrib/CMakeLists.txt
index 8394ad703..362f1653d 100644
--- a/Engine/lib/assimp/contrib/CMakeLists.txt
+++ b/Engine/lib/assimp/contrib/CMakeLists.txt
@@ -1,4 +1,4 @@
 # Compile internal irrXML only if system is not requested
 if( NOT SYSTEM_IRRXML )
     add_subdirectory(irrXML)
-endif()
+endif( NOT SYSTEM_IRRXML )
diff --git a/Engine/lib/assimp/contrib/gtest/.gitignore b/Engine/lib/assimp/contrib/gtest/.gitignore
deleted file mode 100644
index 4b7be4b91..000000000
--- a/Engine/lib/assimp/contrib/gtest/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-# python
-*.pyc
diff --git a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/CMakeDirectoryInformation.cmake b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/CMakeDirectoryInformation.cmake
new file mode 100644
index 000000000..0deaa3cb5
--- /dev/null
+++ b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/CMakeDirectoryInformation.cmake
@@ -0,0 +1,16 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.21
+
+# Relative path conversion top directories.
+set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/home/ragora/Downloads/assimp-5.0.1")
+set(CMAKE_RELATIVE_PATH_TOP_BINARY "/home/ragora/Downloads/assimp-5.0.1")
+
+# Force unix paths in dependencies.
+set(CMAKE_FORCE_UNIX_PATHS 1)
+
+
+# The C and CXX include file regular expressions for this directory.
+set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$")
+set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$")
+set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})
+set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN})
diff --git a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/DependInfo.cmake b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/DependInfo.cmake
new file mode 100644
index 000000000..7960f10e0
--- /dev/null
+++ b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/DependInfo.cmake
@@ -0,0 +1,19 @@
+
+# Consider dependencies only in project.
+set(CMAKE_DEPENDS_IN_PROJECT_ONLY OFF)
+
+# The set of languages for which implicit dependencies are needed:
+set(CMAKE_DEPENDS_LANGUAGES
+  )
+
+# The set of dependency files which are needed:
+set(CMAKE_DEPENDS_DEPENDENCY_FILES
+  "/home/ragora/Downloads/assimp-5.0.1/contrib/irrXML/irrXML.cpp" "contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o" "gcc" "contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o.d"
+  )
+
+# Targets to which this target links.
+set(CMAKE_TARGET_LINKED_INFO_FILES
+  )
+
+# Fortran module output directory.
+set(CMAKE_Fortran_TARGET_MODULE_DIR "")
diff --git a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/build.make b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/build.make
new file mode 100644
index 000000000..767bf6bb8
--- /dev/null
+++ b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/build.make
@@ -0,0 +1,111 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.21
+
+# Delete rule output on recipe failure.
+.DELETE_ON_ERROR:
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /usr/bin/cmake
+
+# The command to remove a file.
+RM = /usr/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /home/ragora/Downloads/assimp-5.0.1
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /home/ragora/Downloads/assimp-5.0.1
+
+# Include any dependencies generated for this target.
+include contrib/irrXML/CMakeFiles/IrrXML.dir/depend.make
+# Include any dependencies generated by the compiler for this target.
+include contrib/irrXML/CMakeFiles/IrrXML.dir/compiler_depend.make
+
+# Include the progress variables for this target.
+include contrib/irrXML/CMakeFiles/IrrXML.dir/progress.make
+
+# Include the compile flags for this target's objects.
+include contrib/irrXML/CMakeFiles/IrrXML.dir/flags.make
+
+contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o: contrib/irrXML/CMakeFiles/IrrXML.dir/flags.make
+contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o: contrib/irrXML/irrXML.cpp
+contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o: contrib/irrXML/CMakeFiles/IrrXML.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/ragora/Downloads/assimp-5.0.1/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o"
+	cd /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o -MF CMakeFiles/IrrXML.dir/irrXML.cpp.o.d -o CMakeFiles/IrrXML.dir/irrXML.cpp.o -c /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML/irrXML.cpp
+
+contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/IrrXML.dir/irrXML.cpp.i"
+	cd /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML/irrXML.cpp > CMakeFiles/IrrXML.dir/irrXML.cpp.i
+
+contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/IrrXML.dir/irrXML.cpp.s"
+	cd /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML/irrXML.cpp -o CMakeFiles/IrrXML.dir/irrXML.cpp.s
+
+# Object files for target IrrXML
+IrrXML_OBJECTS = \
+"CMakeFiles/IrrXML.dir/irrXML.cpp.o"
+
+# External object files for target IrrXML
+IrrXML_EXTERNAL_OBJECTS =
+
+lib/libIrrXML.a: contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o
+lib/libIrrXML.a: contrib/irrXML/CMakeFiles/IrrXML.dir/build.make
+lib/libIrrXML.a: contrib/irrXML/CMakeFiles/IrrXML.dir/link.txt
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/ragora/Downloads/assimp-5.0.1/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Linking CXX static library ../../lib/libIrrXML.a"
+	cd /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML && $(CMAKE_COMMAND) -P CMakeFiles/IrrXML.dir/cmake_clean_target.cmake
+	cd /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML && $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/IrrXML.dir/link.txt --verbose=$(VERBOSE)
+
+# Rule to build all files generated by this target.
+contrib/irrXML/CMakeFiles/IrrXML.dir/build: lib/libIrrXML.a
+.PHONY : contrib/irrXML/CMakeFiles/IrrXML.dir/build
+
+contrib/irrXML/CMakeFiles/IrrXML.dir/clean:
+	cd /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML && $(CMAKE_COMMAND) -P CMakeFiles/IrrXML.dir/cmake_clean.cmake
+.PHONY : contrib/irrXML/CMakeFiles/IrrXML.dir/clean
+
+contrib/irrXML/CMakeFiles/IrrXML.dir/depend:
+	cd /home/ragora/Downloads/assimp-5.0.1 && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/ragora/Downloads/assimp-5.0.1 /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML /home/ragora/Downloads/assimp-5.0.1 /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML/CMakeFiles/IrrXML.dir/DependInfo.cmake --color=$(COLOR)
+.PHONY : contrib/irrXML/CMakeFiles/IrrXML.dir/depend
+
diff --git a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/cmake_clean.cmake b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/cmake_clean.cmake
new file mode 100644
index 000000000..488785da7
--- /dev/null
+++ b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/cmake_clean.cmake
@@ -0,0 +1,11 @@
+file(REMOVE_RECURSE
+  "../../lib/libIrrXML.a"
+  "../../lib/libIrrXML.pdb"
+  "CMakeFiles/IrrXML.dir/irrXML.cpp.o"
+  "CMakeFiles/IrrXML.dir/irrXML.cpp.o.d"
+)
+
+# Per-language clean rules from dependency scanning.
+foreach(lang CXX)
+  include(CMakeFiles/IrrXML.dir/cmake_clean_${lang}.cmake OPTIONAL)
+endforeach()
diff --git a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/cmake_clean_target.cmake b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/cmake_clean_target.cmake
new file mode 100644
index 000000000..e6a95a903
--- /dev/null
+++ b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/cmake_clean_target.cmake
@@ -0,0 +1,3 @@
+file(REMOVE_RECURSE
+  "../../lib/libIrrXML.a"
+)
diff --git a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/compiler_depend.make b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/compiler_depend.make
new file mode 100644
index 000000000..490d7fce8
--- /dev/null
+++ b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/compiler_depend.make
@@ -0,0 +1,2 @@
+# Empty compiler generated dependencies file for IrrXML.
+# This may be replaced when dependencies are built.
diff --git a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/compiler_depend.ts b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/compiler_depend.ts
new file mode 100644
index 000000000..b57672af1
--- /dev/null
+++ b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/compiler_depend.ts
@@ -0,0 +1,2 @@
+# CMAKE generated file: DO NOT EDIT!
+# Timestamp file for compiler generated dependencies management for IrrXML.
diff --git a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/depend.make b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/depend.make
new file mode 100644
index 000000000..f8c27ad70
--- /dev/null
+++ b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/depend.make
@@ -0,0 +1,2 @@
+# Empty dependencies file for IrrXML.
+# This may be replaced when dependencies are built.
diff --git a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/flags.make b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/flags.make
new file mode 100644
index 000000000..f012a643f
--- /dev/null
+++ b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/flags.make
@@ -0,0 +1,10 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.21
+
+# compile CXX with /usr/bin/c++
+CXX_DEFINES = -DASSIMP_BUILD_NO_C4D_IMPORTER -DASSIMP_BUILD_NO_OWN_ZLIB
+
+CXX_INCLUDES = -I/home/ragora/Downloads/assimp-5.0.1/include -I/home/ragora/Downloads/assimp-5.0.1 -I/home/ragora/Downloads/assimp-5.0.1/code -I/home/ragora/Downloads/assimp-5.0.1/.
+
+CXX_FLAGS = -g -fvisibility=hidden -fno-strict-aliasing -Wall -fPIC -std=c++0x 
+
diff --git a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..c4404fedd594a6c91567dad31e47c4cbabb7e972
GIT binary patch
literal 295872
zcmeEv2VBkF|M<PtZD~?OLzA)^(oj-zbEA||LLn(aOG8map(_npkr9RL5R%o>4WSY$
zp_G(DWQ6GdKA+FIqv08z=lOo0@Bhck?fw3ob3SLh&pGdP#%DF%#)^+hrLg}|DP|Pz
z6FZbbF=z2}9?S{MobrzEEgwoN0e>XnCj~!g_`!clZ}`&(<FWwz!ml5GmIK%yegp8c
zJU|8bDZ)<)egokL|0&AwM+M`m7^(qO$M_(CgE6iNPz&Qj01n0YFo44`J_4XN#&rPd
zVq6d4Ncic)ZxjwQ0BDGDBY?&jAB~|2KvRs5!O#rgSd5zkw7~c{3@rhU$2c9J6~-q3
zWWdiFeiL!nB!D&;w*@#E<8~O@1Dt~KsTfWJI342-039(t14Ac(Gci63;B1UL19XAk
z9Qe(}Ve<gGVthV8H;ga9&>f%$#us9^2%sm%7Xw^^@ue7g0rbYW4?tgx`vF{raesgT
z7!SlS2;g#z2LlYj_zHk4F&+vq4CAW+uEuycz%>|O3oruXkpS0Wd_BMo7>@$T#P~*l
z(HP$ZFb3nX7{*~3kKty32^il3a4W{Q0o;!99T+BJxD&%&0FyAj8{i&{?*+II<H;EA
z$M67#DF9P3eh}axj2{M=hVdg99>wq&hQ~2Hf#FFEPXSEF_-TM=Fn$(b2FA|;Jdg1U
z05dUu5nvX^F9E!a@hbqYV*DDwY>ek%m<uou<M|j~2Uvh{7KViYZ(#f;hPMC~Vf;3R
zcL3hScrk`00824`55qEm_c8te!-oLN;a35_N*wkGU=_w6WB3H%Q;b&wtikv*fVCK}
z1Na={^#EUByaB^T3||6l!gw>lR~UZ{@D0XW0KUceI}BSfe2?J=fFI%a34U!j>@&bG
z82^f4JHT%k{|>MN;}kyNzvu@%m=7R7#svV<FfNFp5Qf44MKCT3uouR~0E%N=0-z+u
zr7)Dnus4Q%0Ls8m7JhwkSU-Sr81Ika0D$rsR{*GpaV3BQF|G_y1>>p!)iAD(p$3M7
z01n2uCO|EW4*@t7<HG<B$M^^gwK3GeP#2&c#z$hPkKrhQ1{gO4XoPWNfTJ;P0?-uW
zV=y$sa4bM`j9UO4hjB}Q<1tRh&<eu|02vs!1~?JplK|Ra+!n*h0PQet4{!>`rvjXY
z@#z2^FzyI&2F9HL&cygE3}*v$#<&Z>IT)V{a3028F`N(34dV*{x?|h};6jWq0_chH
z#Q>LJd?`RLjC*6~1JD=aegKzY+#g^7#se`70=OLG!2m-rz5?J%jE4dY!}ux;S7R6s
za1F-S0*t_TB*1kTUk`8t#-ji-F}@LCG{!e!7y~dC<8c7vF}@jK0>-xh+=}sS0Jmd&
z2f##(@5FEyz$A?C2Dk^~djamlcrw8K7(W0o1>>n09>nkvhKDgs!|({eqZmI1@Hoa#
z06dBDQy8WLJdN=)7@oy21H*F|p2zS4z)Xx^1ek^KO8_rp{0fFw0bav+HikJE=3<zK
zVLpb}0Ty7K1+Wm~Hvrzm_$>^J0N%#<9e{T+UJS4V<D~%aVZ03BeT+W<_z>ge04p$F
z3Gfldt1xT;*a$xd2J^Ya^l6NUW+?_Utl^p*@Z<*gQ5Z}XBbwg8U=~1lH4$_ziW`}S
z1TcjW9azm^KE*GTHw|Yn^BB=MIfGdanGkW-%zSn-8z#I#hB6}ZrDj_=yX5^VE5X}X
zM2RetDnJfyd;9(`Htb)~#lNWgPfnn}i@GrN+ZfR_V&uozOTjc~V=$%SUGfONftd!R
zK*4xU^WZm#iT&d|P`1nFQwF(u`I=Bnmj;+n%of5QRlh(V0E1n9ef&*O8uTy7$8&+Q
z=dxv^M|=8=9&PDlYcti|b%FabYcJoWrf!Q|m(2|b@pT`j>>udszRYc@tG~b5=+SOI
z-a+om0;anM2aI<OaMko*<~Em;cE~Vggah#O4$xAbz1%Zkk#eUL%43w5`gku?4)pf-
zT<Gl%<$DL15HAshK{U$1gr`gh;?&U^>Nw8T-`$0%zxE;@FL&)_t_yvZxoVI1S?;~m
z$8~|fHq_J8%Xj#w5jrDuwV}EJ%RJ|6Ll*F^cIQTpSVZv-^qRKF(<4CHRM|kE$o0QQ
z7ym^*%L4um!u&h?wWsEBN7j#f`M=g5<Ur(%ZK&Z-HsQb2A3fEUw>3S?!~e1V_^B2k
z#R%zUa!5C0FhSWOR5CWJ<z>tejrel|gJmv^cmu*&=2C35z+8q3LDh^HSt5w}fXlHR
z;N5Y;#LLm<!i;s<0h+`EX6a1>2(1q3g1BI=Vi(Vdc4@nj*U>>0ojVA8T)U}Ir=O{H
zv;(Mx_CzH**P3Vu<LB!oJfG%CS%quGl~}x_Loy8-+$MS6TqZI*KoQ~W5=ohdif1>T
zN5I7sE&nsJFrrzRkcZ5`7N$cpPeFk~nW$fy29jY6;b?j@!>t&eT98YN!Y-ayrqbJ@
z&82#h#ZX;j!%(iGEZJ{z3d0Ry=AsZLmg?vgl)BR^Wcy@ffLMcRb`)KJbeadnRUUjf
z9n>F%i=p&GX`?7s0DmLhf9m~y(NtOsA9z1$U<5s<YJ-`%j-RaB&qW!Hg15)hzzp*S
zB#hR~M>&kf{dp>FJwK%yp>L?PWPZv{K0wp>Xj%M}7kpj>G5%ZcN|-}crrCoF?>SYA
zsL3A*k+gxgmeQ*ED0NiiIfdT*V?lir5fx5RY2Y&`0J89b(GCIdzSIL0^NLCX>;ED<
ztN<a8`4G+4@sA?Ym7sJDR2p~@GH^O#WU14JQcz<cFXLE2K+Xx$){9aK1!?z0C?5zs
zPKfqFgmOrTRwqI!BJfQjknoTQEm@S3Bs!3Ix$jO?KsuEME)5oy1`d=H?CO-G80bP6
zDVNw`*AY_1N886wiDXx?7^QnbrGc~K?2oFr16A<?QLURq6+aSqJW;K~L=|uUu!`GJ
z0Vk+5@WSL%Y2foY%C62m6!Vfw1Ha07cGv}k+~K2b=BIq*!&JP1(!r2~eqi@NH!5yG
zRZJD6HHx5$o)@816ZjWFTDb^ivk;91;X(+1BMb?dBD4rm%6AcxiX*4>1!p-Q?K=$-
z=N65!o8J=fSNyap8f6^~g(uQzuV|DD1il3o1wGe&@DUjm^3ghI;H#h&(I|WPEdhVc
zPkT(Gtf!&yoiy5O8YPp!xBhlU&|B>^N;x0x292_d-xBa9ep)4s5<x@Z+iA2W8s!{;
zZ~kFM5@Vog^FzRE-hqhN^Vla71%Uhg%kL#x1it>)KS)H%5M*s(`AkR|j-`ck08O?I
zz$}iUR{`(l%45zu5QGF)CnW$B0*)2{II{k+a-hsb)w!r97ahh%84=k!JaVJ~p3S>F
zJ9T;X<vd4(RZ}D*uR&g&DvcyQ(Fl$v5*}7X36O)pYNUfmGNPpz5xJle^oFcDN;|&{
zZH%@@X`#vXQcdn`6(u5@TQG`@$nIJ(PQ{z}xi4{A#|>o5`)<n4ufBq={MA>#<`sK}
zkn`-Ho>yGm{WrZ$q$8X3NwE<BLR_Z}j3UxsjZiU!q6K2Mr<>4(u@S(CrWC-k2-dTC
zbBm^6wuGz$j#|x5NqEX2rc;^R;>Fl#fw>ei#M%nXrK#XZ>uf6lCBX=h0wctcU~OcP
z6G@!p><|>u08Ej>$f*`!#3=Bw6B_3QNH8Lrq}cxHrh0Y^N{{<0p0w9csia@-=W5)k
zFCwy`OtwkN?HeFW7fbL@wvN_A>y-a&>saQ)P)En}_$=+A<(Xhir!Qbc3uqv5$6(Ui
zbhCk6>4>fo*&tUCvC|2;!=&d&(DMbN>G_OAPCJ?Oa&B@dn`jC|$Jn<sqHW1=<{e0C
z(NVlETXJhQVN*tgl~V%5;H7eQCWOJ)I1vmrGVd7s4kDUb3<HoI^u2q~x9&kuFyu?T
zNMKA5p+rga1`ihf!<$P5^iS7V^uq5Q6bg%8)bSmGVhZJZ2a8^Yo+85X`BzPVcR;LC
z7-LXOpb<P~vdlFFfI>v`_@On7+?+N(W)6`u#uvt+18OjklN<nzK|t*;nW6kSnSmnp
z$1~F+Go!AugfglnFHk%p+P()G;Cdko7wW~#&3QSHT3pgb)CwFNzAz=a)T$biLalf*
z8q>ke2<<%kgBk50GvZt21C=P3JWr9lS}b{<{z3A5wsCIYEEEXihsufgNJd!T2tH24
zCo)14w*`$+B2A1hf3$6W*9J7H;&hOV!if*;M0&J42J&!dTfi79Lk#NxS_4YYGY^em
z=oj)1`vzjz7cyd;oES0mVz&0l;~hewXbliAdJ&JD$^QTSi@-1G4M0$mPe?{?0(v&C
zMTCZhPF`AYwZ#8a4AHkFJO3Sxv=g`Pfm8P&>pDp>JUBU$6HPp_bY>UH>4Dy3OT=HY
z6G{1Q(!Nt~{M%(GVvWCK=P%j$OLjK@lAV82Klmj(d$2l%e<(Y#<@if_n*Wxq{68f<
zp|2^}#)o?UvO9m-ogTmJPQu;t%kBi$KpK!e+SdO=vJ<UMF_2#YTx!`2rb8yvHUq5Y
z!f5+p2yk5qXlpPEMm`UoV52<AZOBE|2YeUE2M76ZR)nJI8N5z6WNkt;Y!hM8tC1vS
zz}nK-AWcRLaw~yNo|A?4mUA8pI2gxcQB7>S1Xt0$XAEXBxKgR${A*y*t560_#?i2{
zmdJ>axlZI4P0t3W8hFGAJGX&ZqJkV>g|PA@OeUljGjB#oMbN9L@N7cQ2))LR$2FCU
zb|8qsv{#0@W|AI2j<*bY8SS27`+$*#Sq@YLhl@iY6M2E?<s=o$xg;T|2*HSoJi)wF
zgc>6+BM%ijxh@eEA)26K1EylbpQB<!Cn^FFJ(%=oEP5S5#8J`oI)aGEqg4z91jijS
zSMmb=873gOtq=iGA~pf*fPi%-^!!jXMu>P^NgyCW2a<q=BmrRzkR6H%$n}4~z8WB2
z1Jkw+-fx2u1&_osA;KF_qoW;&D9Dd1nWcd6Z9w=I;-yZ$4?GT#?}J1kM`CT3LtS1!
zw-I|DEZ}i1V_p|+E*4`?g_jFquZ?l8<oa;Pu#*o7jeo+Y#L1gXEk@18Z*uz-#W13E
zaDo^HWDH|wq8KxqTo;fL<ZzdVq^|~EfHj9sB{n(yfo#wuKn}pp*^ryUe&7M)^_gKO
zWap92VAJUz;TKu$9mKz}4CCVEgBet)Kc4@@Jmzo^v@A|?5bY+?Rm$NPf0dDp`4J;2
z0E#ydo@!n;g4m489p*a^CNDF&MD`A`D-Koq4>1$Ynu{jTxB&)rHPE=6X<LR0Cb>xi
zcNh`e1cDJa;R)vDCe<j4hno<O<aRwdj1$}>+JPtnO)OroWJI%0mx@Hw%V6gJPA5T$
z1cPeBozylq=qEa<tt+33qPMc>@6k+d8W~N0Pwud*Mm*{~MU~!)7d8m?^d7M%=$Kp&
z$*VaYOuh*Edtg%UP3UEz*U5Gh9fK+g9m8%rjHj;aJY6liUwo!VcJ)v28O<(35B1xB
zehwfF2}uT+CjXFZ&mtLKha}>7njisSYYQ*SBPJ*)O%3KG%L8%$6SL_zrM_VgQr|-j
zWIj@v2#HQ6Ky{;nHju+WQ;H+^IjM-$#FYA@a{q@M=68s~VKJB}e?N=S{{t+Bqz40d
z3_%bMk3p?(K#CFpfAN^&9+VJX?diXw%fO^=V+OvD2zyTn=na3V0b=l%KR^)v(qKzB
zS~+W?5exn7ecD*lY(f$jR7u#zfp%vgot%8C7G{W$Pq39Qg5HAqpNLtP9aw~xVmNy@
zK#nvGL9u9I9C9Hufd|P8**Vq1BE@6?=oBa)K6XmT=O!l~a_*3fDI%<x5@-#{V78*I
zE`dY3?va6XQYfD5*94T<O@rTpjSC2CyouNh&d8Wv94JDBW<V(LAoz<Sp+o5{O(GF=
zFu|aHpuj>)&Ql_@1JS;Cq7JYv1115f`<659iQN;?BtY5$qynWH#5A)DuajcYn^7rE
zgE+hBVQE_okpS|QLV+OLb0yDHqksoBgII4cp*M$>g79u5EsQo!p7081eN>qvPSD&m
zp;r?PYiLX*Thu_(4eeYc_ffFxg?2PzoNP=3*%**Ts7>&M8q?52V}M5?igR8^J5|^U
zj0#x{G>1@C(4c`M3>4I)_lTrzh@>b}WBU8hdkDun0W4-%I9fQ6r+$%y%wz^4BQ+CM
zpGhx_cFAC5V%{mlFwR>pj!yET-9{1F!c9U9RyK-cHwaF^S~C^YZDW?I3o~LYJFJ-n
zw#+w8QZ~#EqNlARSW?yzuc@}{K87?|$4rM*#C{RftW2<u$+l+_)yxP&0|ntt{9yXS
z&Knjzo9IZeDYK!^P$h^_T?pMrR#})ELoMV{QzPiv(68BSn=+H+q(nKn{t`qn1l2Q9
zS44yr!WPvHWH%P_Zm`0op?y{+E`?ooSfPPRrpCS7G{Kt5vR(HoK+A^t4pB{ubTL4^
ztz(>N6dU8FE?K;?VScq?z91(BcN0N8oQ>9mv(XkV7IQ4-^6-xTzqrjLARw39blF$%
zyWED@ZGduUMC4;<#pO4p5c-esn@+ZiQa1w=Rh-R%^oXA2VMEB&AXpcd5p^;$INa#g
z&vGNqPHTdT|3z-psi`BnHTAdn(-3k{1K%N<%CV=QquP+jB26m9s1RdjGpf4?Cpqpf
zKJ|-F{X4WGTQ+kcv?5{PE9BTFq{Hv>Dej)&^2V1va;ma_j8pO2Km&U;3^}Z7<nObp
zF2)LnSKa(sUX??V12_a{b2Wiuc?x9bs6M~1Id!svwYxX=x0uz??#v1|mhdBkV#HCa
z5cg(tt2@8A6;R-RUaNvOw1L(M3mH8271{ATy4T;43dZ}df4?a3ivqtW@V8K4@<_NX
zM$gknSHJUhG1gv_r|HZ!VqZc-r_+C~I8Oc}t*wb`Y1r59{5{!IIQe(2f56{U04M)0
z_5Yi)|8f1@{@MEfZ1x;_7+P9+E_Fw}Y3aIj={Q%nB|VN1ZhGq;(i6T&_C9~kDP(Y-
zA@5Eb16`W|CwaLKT(zzZoJqcH9}<zc^GRJ4Z{8&y780?e4`q(=uB&T2QAD;l8OMhw
zg?zTSc2cNzNVkUo_B|L3IkYcCtB{e?#?K^tYSHG(pcokE`m1qXBehl7vBIqfudf&T
z+1MpTo2#?62sW+Ii#!DATs!RJ36>@D=ShYfd7Yffux$q48={1~fN=N+PE7mqtk!dh
zMDCHm<^N0xsy&y$bAo}r69SgIl)0YLZpXZl50kJL*ms^t<90&Vkp0W;(?6C^Z^)q2
zne?Wfvg||w&TbFrN;LAKL96H8+R;(cDmg5>TfY!BC0>~auS7cl&EXCev|oe$0=pD@
zpaA$I1G9Ozf)J++yX|rUf|LV6$|-@pJS5-TXqA+<z1(C6IYTJV*-99VF~}U^?hYXy
z*}iWQLI$PpBxe;vCJvX$^khV<q!j%!sx9X<6X$psp2aZT!U~yz`Q0jvcA6k6=@3mu
z3sZ%-$vxCOyU83VS^g)hiZ;GL)3{a5?zyUL>T+i>&&>p#dkbYiR2t`sWAW^VW4894
zb^T~_P4+CsX`;=Cu|wGN_J5Se*$~9&&g0<F<PTUJa?k;D{0$bzS%(5T|Kf1Ke|RS5
zFAj$mMmiDX7l-@B;W{&9f+u0-%$4|D&W@vall8#i;R-aQ#W8y3a9!A&Dw)b$idbm=
z#ob`lj7P)xrN4o~$JQ`@>2H5V)%^GCZ_0#4g6ssuF+e~!$pAATpJK@U7Yy<;L^2F%
zyltk0?aB#&)t_6OmmmS$hY@)m{3@KVp}^tRWv@bpBD{o5N?T-Wf^LBB10j|eBC{pe
zt>b;?hlP&~P=+duU2YA3RRUDuuXf-VGB+}-rtzJg(7hN?5*ZiKLIvXx@jFfsZZJ;J
zBoyBy5Z^>)b6$?lE5_D&Aq4D1$N`!_Y%<BIrom2G?wvIZAZaF;IGrw1LA%`}!qO>$
zqL+}zsWF~tt3x^{_{BUL0o+1@qMNLv=|x~KWOlV%k*x#iIs49`F#~>(G_Of5f?k9+
zyFe~nr-CuPNOCtEED790RD{frBo5k{5$%BPb?9_a26vA-Sg<fg{`#4KzcHWR9>08K
zM-xsAVz?sxz0>$56?*RYC7&fD&k_BDhAT{qKRA9PdEbe#@2POug9c+aKoS0|o`A-$
z%0D)INsj$%`~n+dpC<Z`jXPqC886=i#mdx_z2^k$S%JhVDH>pe+V!`Lxt<D^y!va*
z{r7k#+U33om}VMCgk(5#lE~{vBF{i20)t5gIVQClU1<i1=$YirMj&7y0N&*Iwg~wZ
zC=I)VGKC4wZbDBCECX@Hc@QGlded?UAoIlzTiaw{_1QcUm*D&{$m?bcC2#~WQDBU{
zP8UJbNlrkWSmx^J5)|~EF$$S6DMPx75WS|MU2gs%uaYF{!WBDM`r_RN?D@(*Lz&r~
zW|>d{v@s5~yTII@fV^Ukpa<gJq#gnCm=FS)Sj{OUq(1r7Qwl=OF$;XuDH#ZSbfp(h
zM&y-qxbmO|m2!$53Wh$L@^Bp#656~Z&V+jX4vD)}4)rnj(xm{E-#Tl?L&#2Y0H`Ji
zR3n-N&Ee3e4L6GnW49g(?3M_&S`#^<zHvh1x_jTG5gEg-Si(QrHakF+ywhzu3>L@|
zjU5_Pf<?a!e<@9JD2%5rFdFUQyw_#K%gAs-r$oEQFAJ?gB<2YX6eU&|8rvWzP7LhU
zg;O2bMDBArp}19}IRW^>z=$@NKn<Qim~%+UbqORVA0kpj1L!?4d)P&jLx!j*CycD5
z5NLVXlz@#Su!7iZnBBiQ7SeuaEI>b_a*;<D`&qgCfPK3ekJ9$1#>MZ<Fm%Tq6rRb`
zJDn#0P?|+Y9}T25nR60iLJLNC<x`u`Y7O~55o{VL0M`bRS}Aw<5t+hGbd<m>PVyN0
z1_I}uZ<vx14SdX8h=hs7fEoT5CKnoeMBzU<xsbOP(NGR%0;+BU+t46z9w)+YeJz0J
zT;Mdun&vb_bmkQ&*rV2MZmmP1Fn<WP8%;cs+>byzGe9y35t+Hp7hXf-h#N)>Ve*ln
zFgJ$mzJL+DsgWSUi95?8SZE`9pFGV0W<?S^AzAPuD7bMnhzj1|o^k_A1}^#M)}nL$
z8b6@}>^#v#CAB3Z(Fe+S!<p-X|4dVV*erS8Oo_tA{7zHp;k>VOuKu4Qy=uT<-kgZS
z2P3B(mpBjx(&kvVAj!zLUFZQRne-^$gq>@~8^ff>|A~qk)1!K-6dd*MQcuZ9af0!4
zgPEY3@TBTeBVN@Y8mKyy=u);cjY0j(h@q$R3e*_FkOu9BGdRf<SivAwp?G!{w($^~
z-06MDF2*655gmi(SN9mO-E(0Yam?<{xswfxvG;{wr~_{*C<WJnr&UeE;~OV-AxRe+
zkko;xO-167OF3dNm`ScX31_(>9L+9<2{F5a(4ZlnIbuyakUeNnMvRCPC|a1EY$)*>
zn<g=cLokR+^5`k-mg$f&ye)%<vZ>3hUguUcEh1Gv=qfU4lSbD7;;wO`GjIwVz|Ea|
z_=9}6r<g9x8y{LH%s#f?5_<1n<hQ^_&{_0$LPs$rqy_ROwG*d#;3#M@gV6n}(b_UM
zv=FH##<}d>4Ym>VcGBYO`Yy3;7<d@09`_U#7>i0Ik6BftGe)^^A1_|_{fExJm5{1L
zIne^n**9dY{O~La3{}n<zb3$mcfmyoRsRcz--eOr+_;ySpu0FoYC{3S_!L|ry1#_8
zk-G@gxt@=}adcrA>wm<?6IhKFoq;WYji(M+CODiVFF^V9G%oYvvGR};DHG1rB?gxE
zVC4ltENSJDOV<BuMjnTH44~d$v+_tn@hXd;n|3nax}_kUfnBXUbhUJ6B^T69qL;EU
z8w1gcj^kt!S}{^dG4cPJoyVzO7jE{a^m&5Ifz{TNorel&L$(zGK|SNNpB(^(2q)2>
zu=5agz^lr!^QIB9?KkZ_R7@JG3$LArvVk?rE_NOn%C_@9k!&Q5pnZ>a9=lb%b{?)_
zXFE@TOxfAagM*Zv>^x3Ii3($)K_xred31;+?Ytikh5wS7$F@*@V}^CH@=%jIPk^4R
zJT{rTSb1b{cPo#RX*VnHOSj_4DaC8#!HxcZ!N?P2m+)6+*8hT)*OTc3geUd0&Q>1o
zz5pF|G&!^hQADKgB8|EkKRbC|#0F-gac4UZ%IGP-?v@^J9UI?wwqVGLf~AK(Pu;0Z
zdU#iBg*P9bq(7(!xfaN4=#gc0H}pEUwW~SBTk0RL5ircoh8|gXXG0H#buskFAj!zr
zoymcMnd`if63=5U5d6HS?guW{&DP^>2Tvv_XJaDgPUar28tk3qsQ>J$(Yn|+-ORmC
zCGi+WFi)evTNch1sNsyCv-2<${uh{e)?G-^V~2Dz^AI5;+Q7^^MVfhpZDvB4!GxJd
zJd;`pr0Ztpp=d;6A{n-xNs_RQXE37vl9k8XfxoOg7`C8Saa<3a{X$)=Jfx5`aLh4u
zhZbA`h?Fs|k%s~ci3!KC@g{Y%@$j33t^_VU9utozCNKe&_8+zIZue;6UHB~v55^IB
zPYW=)zt6(cWLtP3FF<Wzllh0%9b887H(7Ul-K;y}Qz%f4o~=955B?+T&L7?*tUG2d
zEYkg-UB4rV^jnr)w-ji(-7N5NC-V;kV;8j+j;}yMSRVg@T}P1puNifmn*F5e$-A4p
zCz}rC-`S=kTTTQc4?O88A(H$Fiw@Dnlw;3L_<eg0)uX#ThpsKc=G;9Z0a7xFyNvLv
z-K!s2b2E98Lr<bTT%^fI_L-?mAlgjE4np4#f*{08IYC|QI8FuGX^48T&A83va@{zH
zB+R%U_5A;g4aXUG&?3@L!DGWAcOwyq$YvHuT5#Yh<_31R-#8f(_S;o<Vi;fOyIY;j
zMX=v^jW<5f;)**d9FYDGFMsp1v;PY-=zrCA1ETk&yc6Bl*>b~T<_}qJT~_Fjme{D#
z#d7O8zwVYBZw(vad&s;N8mcDPZN$~nTq6PIWjDKxHy3u3Nmc>h5yJso{fe~P`gcxf
z+TCjF+|I668*iCitv24cF2$$@fY+95@jw#?2f#Ty-Vj&>P45~a8Tq&yaiZ4wbTij}
zP;yV^+7FTf)s2XZd#Dyn+s+l0jD#=W@%9-Ml*p5a6d&X}NC5X>s}Zd7Ck-{?-G70V
zHm;kM)&p?~E3GdNafoRsx$b&*8x3}okj595Ry|s1s0bbl4bkH7GS7Hx|8FqQuolw*
zTi~kMYhELPuk%<#aQzn&-_@M;F0g}OBy-Fl%kE|nyn^%#=n`HNhzt$fkFxJ({*bGI
z?3KWXuomS2SrGj#BIx?Luoh85A7~NpdPOBsf1dkPnGRJ%?KxMXH^9}8Fp*#;!KL~5
zN_6u3&L<!gF1`MfxAgRIB@qx0t|TJY3k`|wUF5nTcO9!5-{r`qD*LJ)xXd4}>1l_H
z|JqIHRiVUX+k_#CZuKV;730g8h>h=@RheK|PDq4Ki-&!SQQh{U(4(#nLTzS}OSepL
z_|uOgDnx{(bp*=6R`MvI2fWX*j2kZ@Cdk7?8c)N_W6{%r55gxm(M6b)#*Od?-iu=A
z3pX1gwJs4hw@}%Yh1E0k4TNY1xDYVciD$(f*9DgGdyKyd#c?W(R_f6f`)GPRvw~e3
z3@BmZj>YsQ)d+e9%p^LLk?q8eH>PJ0+vg<-rU*OwJ0v5~UVf<JQ2KGW)faS~XousB
z=s<1*VjPOeMso;(Qn7Q4hP?;f8gdn~<W>}xf(fE=-tX}pc7{}XTGLpvKIlg2KV6{+
zdK!$BG$#Fcv;(Nq-Mbm}Zva|c<}?x1J!5)WSeLy(lIv8yBYz}sI;t`KI6=SwOWuf|
zq#bP9$cAiq#~2bP;NHU932eJ=KE*o_IMfFdvGXS@e`|Xx6veXvlfBIVNle}yt8y@F
zU=AYgMl8es@H@qS{!6|@uDo0ae|-UQ9S#E`KB3IBr>yg?ciz+d1RH@oTR_eu?%M_<
zU5aPEq9F2YA!napPv=@d|A##UB#Q%#_bU#Zo`4~q-enL&?&v-CR~$0Ad;-OgUvVHZ
zCcfg3$^ME1P>uMC17ywJj{+~?uQ+f@ByK+by=>4#>YfeggT$cV<b_Vg;2{Nd>tPJA
z`yXhn1Kkg);YxGj=HS2Yj=VRBCE#5U+}k`WAoQQvLDA{nxE>@DG?H^k9$O-z8-%$M
zskqzi!kr}&XMaTj(CRn#SD;mGW(#~w<-G^oAPq7b0g%}UfXqhV@08i--r_$dvw6R$
z(fz_xUXjhd@Dy$EiIGA5*j-#B_bprj4_}SpmDc!Z9c&Il(wcDb5;weZ&Zwce8T@xk
z>dRdv^_lLHnn?~wjuhx5sfmh$Iq}~Y)H6Z3AO&>-(Xs!Wpa#!9TJQt`#N}oGE23KY
z|B|TYXt;8}WHslDOI&I9e^pjbVvAQ;jv8_eIN+bU&z5`db|c9c%RBFNya%B_l+=G|
zC9KnJ)ZOI}ub^hjAyQByIn-T9calRK8U5pnw>efdvn7iDJ{(Et-tbo>Kn(th1_;96
zZsM7I=jUwdH3S>~12#2VWn+SG1s%=c7|`$mgm#8oanDki{Q(4yy^M|=filmQz{T)6
zhkw{kzSvdzp6V`r*OP<n2htY|oPUAnb^gzZUeaUzKPh_E{x6AM_I|`)l9&6f!~b)V
zx695Lbo!EHu)OCV;G_e5N`?lkx=EJp{RMx4F}*$XZYJ^=^4!P)8MHwhHw3sn=M#Ty
zx2Z*Uk14V99|wzF2aZZw*zm~|@}LDixw;J^umiP|fm=-+9U#0snq4z5=f;Ua9DE>8
za??tvHHilpbxqIBD^RU#95=7du4!1(XYUZ`dMAkh6#t`Gw$qn;XNeQ&!I{Xn!*n>#
zv`y>c>jj4&Wi@j6!Md$1K_sqy(|83Dt&=}94Y`6Kgqw(ctqF4agSS&E+O{Z~ejKRG
zt_kdK0k>%p!>yE&^9+u^+(h(8W^fU>B8yDuY3SpE4#nV><i0}s!N4KH1j`utSW*4B
zWybSXitW(>u}FFbf7hdfJWxDd9c98$Kw}DqDvY!kd*s+`AU{}C&CZnxY6Xh7M?Fq_
ziU-nyKP*&{C%Bls7{GDovgqjeGNs7~-Bb#m0d6Cp(J(PY5r|$U2GP`a-D%WDI`-Sb
zvU@7UUW|R0O_$qS$kh>;HmHJf@G6=?WZlTSJK63*-f-f}Oi)QFoE~=vIv`E7w*`6)
zMfH$E7)=PW)7Uk_d;r!{z`Fs&g9BoJg%kXVFQf4De8GtZZqJ|kf|K&!_ys5055M39
zw+j{WjO)MU3r?KUc)#ETWBe)6=S|Jf4S(<pPP9&6aN=h1C%@p-K=}9S*sK~Ijp9lK
z!k0vBi=@}}ED(yZKwxu2Gz5QF9>8a<dEIfuK0zELMu8lF>#{dvVmW{;4_-NdQX#&L
z>IR2GlzB5mJR64#Lpb_CY8(jzba>No-wzzf8_s?IZ{qm`6}#Nt@RK|r-RHo|UV$(F
zkmu_Hjk@rB(l^Lu`P5S2_=r}WI6jNZ@rf4*`}&_|_iVcq1~UFkFyiO`5WhG4qx`-T
zfjI0w2Pn&yH5{QruzPkZq@Wepa}H_S{w|IW-4W3M3I;f<!6n}V!zU8(!2}@sjECDZ
zTbK^j;K;8-QV#h2Uzz8>xV;2)D*Fq5zxBPoe<Qb#qH~zNG8)H7D<s%4a820w@gqiG
z_EVa_Hp&|Ndr<yFQEs5*lRTbxqlq7zzw;zV+e{QVSrCkw*m@!iVTiBqCt-jlCk?^W
ziJh+UoG{LNe-}T;`aN3z`3w3x+OqLSdHE2aSXW+N%%i&l7bm~8$x++kjx)B}PDPHh
z|F8J>$Un@#*>vIXZZK#581Dv;DkS~eSU2p{Kz#c={e4t-Jsq~I0ndhB>dLWUvSNn)
z({uF~xBegH*4%Gn5aST6MfluCAKq^~kTwIlGL@}&5ZV(nunrA!!jgvpOs@l5vD2P{
z5kLGET|=}(9rx?M#`L;XQcaxgHb@;qAHuDJ{QxX_3$QOrlOEc{!n^gLt<z>W6xVs{
zK?~T-Ehf+sVly26o;YM|oEwJv3DhcK1W2jcb!!4oOGyojybl&x(tm|Eyt@g8|LB{d
zf0{JI*`%SM{_92-q*`+}9dM{ZY&!T?P=({KVXxs3z0-AgpbsSXG%jGFr-c;!J+z#?
z(8FmpvC#7qtwuwz^FQ|Yfw*6qBI98hhxj)U?F)r}?C0R!_g$8U%3lBYbasMsW>QsT
zWc=F5z7rdy5-9tZj}sYVp{`7g*s3hGQCT@kpRT$#z#=Q^K+D#{<x?y|4%pF~8>ZDX
z_F0*;_L~2py%m>oK0egmXZQMb(I=CIl{@`Cf)*}csgQnL_*S3vY9Gz-sZO%(8r61n
zL+_udj#rAxjlX^8TXU$B@}5bjTXjlriR8KGroBIUQ0@(L`k4bS9d1o~@nM?d=>^gQ
zyzN~MdnZz!XRQCKHpphDYlYDCP^<a<0-qRtmUYxuJz%|f`{=vJ^&IzHh~0PO&e>=E
zj<hyMo_lFJc-5uRK3iJs0-qRspBeaMM9rqrZycV>20lruyJR+#<-@q%TC5PaSVaDA
zua;(;WP0|;nU3OO0<-9@8g%7jrDF4F!OBUr`60?1XbHi|;=Ri1)|?+!94=IO+T35M
z(0z@9(xSV3dxDeu^m_kn&7EQKcllkMlEa0vG!9uBPiQrdixd;y+G4Kl`0|KpaT3j=
z#e82iLrNz}=!-+nUYA1tZ<c9t(ZTb~llwDf7xD93DypP!5)w_BWS+fPDf7%MAM*#T
z*@bmEQso8wGfqEie!gbPwiS6b%91h;cf#|emE>;U{HQMJtf(2T&k7#suyNuXzW%a$
zsZ(rLnyz2Wr<B_;sNBWr=%Ml)sht8ZcHgtz^Wl@oe5QKA?EUMcBwRZVrRW&tf2qj1
zD@h&8RM2s))L*hBni}l5*vn)_zc19<DG!%l7QZ2Xrl{i7hHon>PQ`uuQsEOh`5j|z
zN1TT1wapKNt=@&oE{Yg@EA(87!C{N>#b-v(%a@3E+<EX@*_JQjTWurFYWJ7NZf`RY
zUg5%5*Vyu=LY(?0sO<gZ-q%E)&0rM09G3EC>l7sefnk@l#xIyJJ;3^At&~5XXNA3^
z&kO0}SDn^>nPYmnSMdu`Gl{UqJ)34`xbHrBJaYy`iOQU>CJ^_+F=ooUalzU8Pn@*%
zlBmbdEf6ggKBQf)_{3>o!g`9UK*EYerHOK;$%}lB5483VPtUd(Vtw6GWQ)w2)D!0A
zgRSRGP4|rK&n&9VUU5IhI8G-e{`08xRSq@+0{&XAg7GsIhfVv&=vTjs;j(jLVKY^l
z|8b(c$XPwT!{hR+7(14EFP!YAa%)VKjZM}q+xoCbPqkLL^vM@*gl;X<9I&%r_y@1l
ziUzwrQ^gXV<+y81*qPdAy!1H6P3kxyp+*^#X7_~on*(H}3Pv+d^_i-W(3k4EQ}vu%
z>hibC`;7OFOUQDJrf%M=IWvAjbu&$5Wy!F!1Diyxj>jB+urhpg>UiJO{+6pE%O^>w
z$Ei3Zhiu^+bY_D}jLLcU>|w=IT#`-01xHtFn=bV=rM8@-Y@==ZUblOalEFjsq|>4;
z;!`6pq?`NA3UM%y<ooUvF0nW#<c7SO@nLF*x!=c^m+vgPV;4SQdctnwti~q`&#U!M
z&X^cm*)X+^Qf7D1qcU$*;zvK@YkJ0R;Q=uTdBYbt%+>d=b9p!1^j+a%Q$6N}gisaz
zicuk&*B7RQ9l2$B<f@e85vruai~R+r)AM$$6|dO6p)@$HkL3M#bk~yBkhIuSHO4KG
zG}EoGCy5wD)ZB>vt~_+b3ilCdqXmnnwcgx2)ZU@)@~UkY<qB?1z5Hz4_1SlV-Lq$^
zgp^lH+&>t@n$}GHIOS9C>G98O=gsxi?q$7yV)o?X;j@YoG$&k;4Y#X}Ou3}NP;fcx
z*w-&Wt~B-}wN6i}P_5?aH2$+T1qKc3Z*NGAb(vpTGJNZl(h`S=D4Stxmj$d;uD3{a
zD5z97Qhe-B+2fdgDJ5E<ov(fF*2|)bih5g?CI(clZLDvIFH;hB*}T<xO^RjdeREB}
z_{@}*eiZ)z#w^juM;cmHC4L_2dIKpBrWn?n=588S|0w&*cwK271;vGe@%^R6ugJa1
z)mKnN<M)L8J>P)BVFHeR8Iz2~Cu}IXo;~aNAQWawIj-idH&A2LMyq=H>=lNUOWz+B
z(Gs-2Mxnk^(dZv5VSO&#{;7qYf?~o7%KlRk3yemq+Y00cZXB=h*jDPIs@2O`i7Ah$
z#VR7Lr|oQ{mIvJB|E{gEc664c^2go$HL<T3ZW7-qyga}`#bDHezEMV5HsO_{=hZZv
zacvM6Tr|C~!7i_4|LsIto2pjs*Q3W$9tpI)mQpN(7e%t?+AA!d@M&PSwx-0aDS0I!
zZaICfk6xTIX-co;VIpTMTlVQpcqqj9JTZ1zK)FLhLra>1qTu(dDS7M5VkInPjk9L>
zr=@&Vd05jhKf81=Yl>mY^xM7xGqW2NChVEyK4XHRsL{RJw3K7*Cb8b5(wAS{k-S#M
zj{mFpr!&wmzPEe>jQVa%G1(%}v|hcY;pS1P2|Fq)R3Ycel2>b;EBP*(w68R9-QFZN
z!BFhkgo!pLSt5E9N008Ms&`uWX32^5iMEWdgC~XwZkaY=`B-y1&GN@3VQYr-@0Qd!
zHEzNN8@tQy^y|G2C8bzS9iyyoReEjI4c`F9P5xYSA*M;zfpO6N`m)0Q>~1#XTe3sm
zU&+-<1#to`kIi?&5F-hpI`w;;xIV?wqqn}r9)W&`Y8v7zXindHJKyv)8ogjL--BU>
zJ0ZG$^gOTSTRv+ZnWC?^PvC*Sh)2p;TZS&<i=6O2V+JIc`uu2eje~6hyk90Jd_qw@
zuSCUDSjtMXw_m^(m1Qd&jx2GFecd<QU{Ye-g88#DQ%r>0EGG&C256f%-;#(l$%<3{
zI87*5@v%nKhrzpOs<E#{!(SRfM@v}Rj4&V5C+0g0#mY@3;dWb9FNf^1gwYfJbUQ;R
zFf-**uQrwIe#-*}Q&(I1m9H~?*<i-sFm$0;fYuO8!$S^RjzpK)C8jK)r5YrpDJllZ
zjvj3~WWt6u*WNUwtDH;8v!}<tW-67Hd^;SMSMrT={o|l1hIvEe>l;eLw`?B2=hj%o
z%ECSNcGa6~4#d9Rce5k&(h1}2InU>;6`k5F^l{5;cfZkD!-(F#G+$~=(a?D^db)Ei
z?%Jnfpx3|dO2h%PoGh*51M=sp=nn0da&^O5@7@!buPAR+jH_7cwRX04$IG-@bPE-P
z-uBt1Z*{cx$VQ<WxA+XcXEW5a=0~cJdat9V5h|AOdPCdl#MDDdj_wfqen9>;ZR<HM
z>5f}LMof~LtEI7fr{&J2vBeap6EbHR_fyo|1>=o{on~CrxpeR5^l|m3^M(hy)=%+p
zU+`M+0sn~S3JuJ>2q-qRzmw0ULWRjY4fIy?IgVePS+qIBs-*CEuj8Ahr<AblK|-wH
zcMZ25a%iK}xKbJAA|2~KW2}Rv%ml5Mgs11I+oq%%sVh=*Yd6*%`c^pq-sSKYC))05
zZkc1>rYkEhp1ROKtx+xQ-C*<3jrkex&Khrj@l9FDevV1<`*?jl*1J%fth>=ge%V8&
z?X0;X_vFb8y)Pm3Puce7S6>8eyX5XBAb&mBqVA6V3(Zxc^X*ixNCdg{Nl|?>u6?z7
zz23$t2VRI?{-|ao8#_NpSI}v=`aLfhHLZcddGTdu)=t@!s;68u%6h&`^dwbArEsK6
zf{fY5>l)Gvl=vTL_4AN$KQn1ozwp2*x)r5cW9R!>3+xOYdU|q<?;+!jo6!_-POR6o
zs#l+P`>6Ds$^J5G{)*}6FBR%f(A9hU;BoW_y$PiQ=x1+*WPdrczNEoT6L_9V@u{Pp
zf;SYdGj0luo4sX0?0j`uzWs&jJ5%JWTi5t*QN1|)LHzZMfp1oxIPt3N`(WjdG@1Cg
z`vYAUbv%;lSd;IZF;L^XV8^y4qLbHE#ucs4UOZ^0cV%4acXPS5sRu+e23p@+qr*}c
zdDU<E)%Xl0VH0&N=daiIXfH4mKfd~+j=$!X#~0fNrmwQM2@+bn_*!P`x}x!kiVu#;
z-qAldaOa-zZ7*^W@{sS?amQd|+gB6n6|=K$(GMN@Rv4<_G}w7TY${^oA@f|)-1Wc6
zP26ZPRli|Is8_^-#bXm@@u{%XcS3Dy%rkEiNQk*pD#QC>-RA3|P6-zl%LWM8JzOIl
zKDhFGMEDlXRJo*i8?*FY+q#}*ouz~wn)hJ4!sLZ5J`{(OYBe{6M;gBH${kc9PdzE_
z+s9hP`%aSe2ukqgihfRN+jL&l8(kT*|7*Nizcj;%qvsA<ajEu=qSVDH)TKUaFZfV;
zu`a9%{z^X}clATwqkY4vy@$!WpD)n7t6-<MOIj)MjrGl`YXbL*?e14SMr_Hb*@f<}
z&mK?9TK4#Q_;b;;nKRCd^7qwBwsoo4<@|bxo#3n?1-ouJ#ZitGZZ)x_p0&NWMb`dx
z{K~V3sV^yRF$>j>-W#+1L%P-l2333LMYWlaWHcjtojaL3@S5Ur(LvYx?`3_NW>zFM
zy2j3JwDdlS0lhl*n$f1tZWr%gDlp$){h8u{n!aMMdlmcA&YpbHGEUG=V9}w-i>eN;
zEoT;)RzJSuK=IKTS-sWGK&fTU6Mo9Tz?923-VLBhpQ5&#O)XHR9UG!K@aXl|l9ZKA
z)}l+~Cx0F{Wh!Oz44H(IyBkZDs^<(k*gIu>;}T&v%D%b+=5zUd>A{mIbG3~5CVxz4
z4(jVQ*!+`bVujl3;X&V?`9+O!v<s4*FiWRSEdT0ZsS#(6jkqsK32C~t_2{+wRK6!^
zW?r684(~Ra+UFA0GfMU4qwLG3eP)JCr0hFs)a*TS!@`llTILtzLqvi#B9`;NkDn>?
z;Kc5;Tjq99+XJt=>S#CeXYJRfteWDGv~8{b-qPJe#Ix&1#VcINtsfsZL;4X_>l9Vi
z%3s`bzHa<P`OLamkB^nD=wIC=UtD@`fPp)I!<_7a-qoe+Psp{anje<W%y5;67)xuo
zBv{Z;=PM*QW3h0`RTbIE{tY)+W2;XL*!9vNVXp9+atm?snsdQ#R#r?NAu~$4Wv949
z-q9r^zW2Au7Y%=4p#LTAvvP-?kHDky9Lrl*Hb>Ed7ttgus_w{)wD4IIZ&!0|alcj8
zR!cN=X-V5|9}%e6R*5L7_#kJsx+JDT)Jf53<RsmS-bo9`M!U}y-ZXzk$kuZdxuMSP
z#{Q3mj_36sabLG?4`0FTlgE!*I&E@K*`=GbPiC`Jg^hX~WB!eld1lg&g<THoy_6o+
ze`>G!@{{tDPQH}RaTzx_{GH5Yr^EH5X9^Ub>-}-j4yls8Gvhu}hA;197N0YlQh99N
zD<9QCdTpBKcQ56%_HQ>Z-`8K~w(F?ccERBBZfBp&?w=rbT3qAVt6D~wc5Q~x<sHv#
z9;klLsoqR+xmSKL$WAYKgt?)i!LHa3Vfl^16`y8PpDdhMz4dI7@w`2I`P$T{Za3C^
zA^Th{eC#%vHLH%iYcW_;Qa0XzI$`yEO~<T3${%EI7CA=7T^giNph$iBWc<eZ^xIxq
zecffuuS*zB$up#6lv59TUOUr2`I2l=k?nYXkEVfZ%Tr>fo+}yD9vFVdKvyQhe}(5A
zdbZoH0hRktj96&*p!rMo(j(>TW<4{#eS<$V@kWjNoSd7X!_D1oW3JY<2nuQoEsCJ_
z5t2F`?I%H5m3m~qPm!3FLd*D%CHudcPHDV3-m2=ZrGcd4djTDnVUlCAE&b-Hl?yt`
zFCT9$zq#aQhI9;N5w&CQqdf)(O!Dg|saILa@J~NleS5O}X}M&F-Vzt2m-7c?+ZtVv
zwxb42&4F~!hMDiXm{VodE@+=-ye`jcykfSzfnn2aukkCRULBtLCg_|rOs!NSSA+Q~
z=0lS%mBl`ax<tu3e6b{;%&Pj%v%}QyJG9nR3Ln46qO4|aU7cAeoGLIY+jo(Q=K7dy
z)0foJ%ymoo7OSO~KBhFL*ymYQ7qCuKZ0!%^EzMUA-)=l_zS?>I3>LMI{9ASNyIP5r
zQ5Tdy9#5H`Z{;jd__Wl1la9O}t$Milo##u(E9q>|`e-pjeu`+@hd~=EqZ}w+i#*?J
zoRb!!tSAc4^U5C@e(hdqv7x(KP=~F2$yS%G*<lIGUbRh)y%?lGF>uptUm2@K@3({{
zB4uK!`ecWG(ZkqVlvyd&>E~*d!j-oAwpB_SN?oC}G<gUHyo!3{X11YY;A73uSHXfq
z_lWcw*!Jo2F^~Os&bbW@H_;T`srB+)txh;gQ}hPol;R6Y=oV{{*(To9&{Ogojw|lt
zYY(}h`!Loi1GxWzd09d2BJ<x4;eRtEE666iTxMP53B}pevi;{K9Vx8zGpc@=acH<p
zPNknpyyMUVPiE2|#+p#C&GlQqB=MBuK5B!8nzq}kHWl-^NpvW~Dp$dD#H3|a4`cg>
zU$~QSU+Lr$%LlRFr~?lgy->J6XbEek`K-mlFo80~8DAeSlU*`ldXroDHIJ=k&=jQ>
zpEJ&t@n5UcmKGN;-C<C-gtdZluF$}0u!~8M(4s{Kz+kF@MBzI;l3o@(jEz<a+NM?I
zWO5*FO!(Nu;Yl^CHP@b0+{fRrZD~qJS>@Z^dMjj)D>km}C2lQRp7CDcO8B&0o+S<*
zgXh&<IvxBmz{@~-(MT8C=(BTr9rrR`A<Ig1U2<i@nzy@$_FAgHBv}6bxI491?~Hok
z_td;Jy5-I1iFQ_PrX#Y%)fcJ7w}d#mg`bgaKRfw$pr&N9Yj25tESFyPJCl6P;$}+}
zD~dk&Zc$YGkuRW7yuLN_1$9MUc-{-Yebny`@@JofD)lSryX)i$o3NtIyYAKw;M;q|
z$h9?d4n^F%X{w1?+$F(ePp_CmDXm7$Uu7w$Mrjm>C_HGSWKW1+8~1$O-P-tfdfA6H
zt|ziwmHJUWJJ!1v)uxvQnM5raJjG3EL*7Yg^Wl}&C6J>T<+;f`y|^Tb{Sp2_t(oqW
z6H|5eupWz_Ua5FcwKelFWpu?I`%UQ~Rjlxi1->H;<DxgbovJqD%-p~|EO-7V*XxQy
zs&v8&>IQ^azwmRX4A-r038@myUS2=o%b|Kd*7thT*fDvowTI?;s`WNWGB_}6rA~Uw
zn<K|Z_=w1t@Xhzv=<Ticj+!+!M`ZM<3(^NEF4{G|@~1_U#l3Sc#u!nGrD=ng)KppR
z7HAMROnek|m-3|oCd>FV{`WpYXP;DA=|`3u^nUw5GvKWBH;T6XZXJ1Dk>r_*&Wl-I
z`4ht*1nTUHtrQN;tTzkq@SK=zz}NI%H2aP6LFTa-^P3ka9qL+Wq8|+qh-uJF3I|RQ
z;BS6LW^uW2)z`6<<o${V8z4hka({`$@~GL=S+(KJn9P33Lb5hq`TkNXOQ#H(uVyCL
za4UBG{K$%^iF=aQ?h$*HxhbYl(4*gV?_`bM@_riCwYC!Hq#yEUq;4tMQD(K2vS=T5
z!=oq`W$cq1Xu6lHIj#oIGSX>#Oq^)pxhHC4iq6e3N$<a>=INGW+H3sPbYu*#PRxH~
znHPG(kUyCwDlxn11a;A|$h?OuGB<ow3E!tTGI`0EDwQvT+E>?E)hxLZ8r4RtP8(s~
zf5=Lcr6+a>`mR3^-_*L|#6w#3s*U6HN|#*mqu7nof}#98{Ao>r%91Pm;R6#C{7-D4
zn}`%&leKxcVxM_)M^@p<1CXzCp9%+6NUI;NmzA}3<M9t!d}f(Ly&6Rytk@E+Zzuhs
zety=2+2U=3uHPutncMVOvRKV(PQk1<8sSeyM)yAd;Ol^vxw5RV6FbVqA1FUwaPDk?
zSK+Kv!>hw&z~Ae2=7D^#)W-GcklO`H<Kzp@*JnxI|Ds%N7nE{Pa&FTV!M3lDi5c%h
z$tt^jQ2g_(Qxli_etR5KV*PN%aLUW7J)(z=Th2YP&py@ceN=vK)3$NV9}fAto!D^T
z0p;qsOH0>_z?A=>B+zjBwN=NFb8}AXtyn$p#D?|iy_e2%mJE}h?0M+)gC$~{oDCh@
zX89NupA3?1DEeYG?{TT+sb_K{m!7yFBqy15Cfn-l`U_Kr*O|V)VpebZI*jo}w|(Uy
zqZfYtR?b^4q8_TWL%?2<b~orw?HTGz)f$)tFe@@eUbJTFh4&re^i@bV?h=3UrK)*m
zaV7%ABLx-A;#TsvEMK|n15Ex?I_G!T>}eVucT6<c_PR(C%bl<6^o~id+DyH5%u`nM
zx1I39ul&<U>eZ61<}du54vSOXjK3*<vehV6f!5|}ty}Mx$eJC#ds~QHtI_fIapBHW
z({$tVTxXmx6w7)tHK5#dM6YCLA)9(XOKMgrbxTN<Sop~qFwIY_EjL+_gyuOvMX}LK
z)2iI`wQTlSU85aItZ#xvH^bCT?glE&5NbIzXv3Y_EK1p_xRM<KN``{TO=3o&N*4rL
z?uUtmO>51px@H{b7N=X;=DaCG`U&+=Ov`hNgEddjmU*h33@;b#EpkEnBIUz$-;4LG
zoJER*MPU3lQD;3HwEIz%IOWy!meGe}jQEO2dh1+}_MrrTAKEMbZq%nyNRm55+3tv1
zzU5fVBK}~*>mp~RX_S~(zyrP2Jg6CIrwB>jdQhJF#GRbpa@nlS%i_@Vo*6!NvrL}V
zJf$6!x1YAyntKU2W{p-pCkwMXwEcvl`JS)90S)F0n5QV}oR;>d%&Laj?Ic<3NSh}A
zRykkEZ|lbLs2P+MhxhH5b2WHol0Ed3VMeW<!2t=Kq#++i%#bhX(_(={`CE$1!>0|C
z7OQQiWIRB1H_Mj%Wcc2;BFc94J*)J+7v6drpKmH#on*MvOGwV>io>L1uBs9)^1bxa
z#c~_(x9FN3TN(bUT+zV1xmdj3alYkcR)*h}6Caza?mkuT+bp%_RLe`HTOZ$QJBVam
zzkHx~z`_^Q&B+t;?+>#WE2cO_<O{3T*iI*WkI<%vRkT*M2j&YFZQYc<<^84C%?rM*
zGBKfFyLV@@`<v5!eBQZzkThsn*ZZA?y<WRm?k@c`eNKHjJ#Ki-^64e-`(JkqI50Rk
zK*~nlt*^l8;i_(Z1$UgOy{)<`q{TMqvPRo*lP3d?o65x<TRW=a?fH3qO|}cM(rXoS
z<jehBS|oz1q)ZEA<s$}H_)Tl+ZQ?C*NIa+Z{JaT4RniLiv6t4;n=?&}wkduRm~poD
zNwq~#Rlm@kil2n;p02%;)386dUGJ@k<LfuQ52v?$Vh$~T%gTS;9IX4cUr@W&TTPSi
zyW1p8z9%?&$rT9~IFETO>iWs)*u0=wMpBicb^_trMhoOW9ac%V=O43kvU#uu-=tB+
zb3T5XEa1fQR~Dj{ZD&c%8?x2G)b)^TYxwk27c{a<3d=omcAQ>(`gX*dbhqg0kf5dg
z+qWx@jEECsxiwY$Hz&%r8=80sJ#}Ll<VZJ{8yM|Xd_+5Z+RfY7%p^$o{IF~{);v*@
zAPJB3wh=kQf|>_3=f*x>`>o>igqCSR&HdZ=Dz2nm8Rqh4o|s8JZAN<A)ttcQa_wM4
zlaG>5Sh1gTBsLl9I7z-TA9E-p;!1N^{3(gtUZoNClkR4}Y0woL)}mJ%8|fpv-z=hF
zUHbhggFk1jWo_4S9i@1>Pi;E=?DS!Gjqmk~NcuJ<?1S>#XR`%A+sVZ4Ja#&6t!1dL
z(M0>aikETP)QgEtS9CM)wn}Vx?|M}#Xov(~=@ErT4Q|&>wYH?U3!J~zFSqzbRG4?~
zadRaL3?=k#xxzp?y>3#T>vJ1jxz(fFd{f^F$t#?bza_ABMT(!;yNR-A(-w}g88oTm
zve1Oo9Xsuw>~%l>YKFw-keZ#cxsKIs77v~XiSM5DqOC^8neS@z+SUQr-woI!Ki{Cy
z?1?^A?pkQXNRwJy|0$zbL3=az&v%_PvsNnF`?bijCSTLS69xUHzuU#nj*eSfH8E77
z&heRZ{Oq_^i;TXt72#of#w3I{R<zYeI4>~Eoxx9)u`-|2bR<wW{M`|6CA<9c<?9{G
z96KiF8Craws$ym+c)R!Z*!Q#z^@EeOmUxca?DxUTqo#Jib)8-VAL_54`7G1XpjE(c
zC;Brp=<u3$C(YP<`F;nDUN2xRO$v$1R6u_W3|gi9yu9jFo-On8*jdw7ZoX=PlG@3L
z+oo2|gOfrwWu7!>mGgVNv|jgF)}tb~{0|vBSy4^yBkiOgvOM;xj<^edPM*4LN_QTc
z6tXe%yFsgr-)HoP-|M|h(Go}NQlHop3CExIovlH?rgDDb(N#m2hNh&(m4(#S%`FSr
zQYR2+>a(lLY0m}5_o;rf4hc*TJ+^h%OVg1W6ZTxN9p=zp75w2)Mcc=^%lyV~cBVeL
zC~x;<s{GRpyI*W>tx<m^+<WZF#fA>+-!eb@D&-#867xv+UdxSL`eKJ_&Lv3+dR2`|
zdR^nwf8LvM*N5*g@NTflv#n5RKkb*dMEKLpip=Pt;>+hBs%f&a%;djS;N|QY+;?1d
z!5$x#_0Ph_$oohfs=0a`<+Umt^18f1K6l=L$?@ZYzuqlKiuTO3P>vjH@FY~cX4Go=
zH=3z6E;;(4UuO%y5iAd$q#}NIoN#$?zd`x-&Tf^N_O^K|1w7?!@&<{z78f*$6z$od
zGa_bB&5E*u``!cQoEEK#i<!Yc&Pe2(-^Qf%x61TG)$D{1A2zt-cdunwWO&T2wNjRE
zhYJ~8?X4pIw6;&~hT5f}216n(<mcYbQ5tjM?PGq=w!Q)eDS3k}PMsb%HgA9Am9Xa{
z)m4k0d~vV66<OLM9t_QX>)_a2F++afs>yk*bjxO;r@I!`4*gi_>nf8wP=0Ppp^|LI
z+nFW$p^Hc5uWAt)B|mWSq`Vhxr7dgTizFJJzjZD+p?K66@6WrHIxH4i9CyCof2m5?
zf=JgFeFnbMo8UKbOg<}RVD+@M+V1+F_EpwvT)op$IP~^{p;wB==wH>Vs<3s`ux>XK
z<R5b?_4>K?ws2PPM`x3cl~xL4lJ>1}@@NsN7Jv1QFG!_qY+h2~_Bqcj%iAA~y(fPo
z)HXy!^6m#Kzsp8bHWu||Wr}QHz4u{#%cAOMeZ~z;xI8=U^6HVTBWgn4ywC4dv3;On
zzx#4W?tPzdaF5B<)G=>Oo}10^{k&{>T3S`6iI>`q**m_vj`Z2FtajbId+M)NJ5)N(
zU}o&;r9Ia>sOg#B^VhScTzotER`Ri`n=Xs%UrqI{YPqs8HLP6i-gmo0SNgnc9{Ti>
zvIxKQt3G}jO+%kvOdiy0`GQL`!=6v*n;(}nbtyf-?fJ)T1Lq`*KCx7&9qc6i*h^xd
z^Sqh5ZNW2qx85<elMOA`+#DkErn%DXt>a{cl?q2gg-@+#CFLL6d}`TEb=$fvw)!HO
zZBEYpZ!~&ryZ0)kYWlJRgSWq+*+$0Q8e?8+cCd8LfaeBVJyw>MyNNyj?6;-BcFomy
zQ73n&-qhL`7MHZ(v(NjeW!ueXg_^$FsJdsy?w7G4bam~ypU=}w&%S&j^CUURVf^Sg
zr)$b5%icYFXO&Xhx_$Z7ofp(%rav6|rB?H!klEdf%(^))_utp3ri`7KIHK*T%?Yjd
znt}t9jcpSi*jr!QZvA3Qs`TMwhi;{|1wG0v8QrKhq_MC>)$_IR<EvM-FOS-}f9TyE
zHA|IVJIFth&)rjzaOkppS@EZBh8s5w0#Za4IVVipebaMiQKRD=Mxu=6sW&QBPd0w7
zY4Cj<nmvu)aA<M;gVddpAyFgFgc-VJEErR_u|W97{@h!V7YD3c9ava%vi!4pYpBDC
zK6<T^F)FN}&2u~opT{pAU@5V@&%VLNCmfCG&aXUdT?^k{o>y2iqBd(rQ^wt+84q`Q
zeu!V$xO}~{_RPsI;`3at9J8J?BkgtD+WHTN*DKs<Ylv?eH{gcCvP^L^kK=d7*xuK7
zJ6<xd#!}*w?#DsaAL8W)Z&@`rCqD1f(kJ5+t{zI*n_z7jtMcg?#lP@v%Nq&fs<hxW
zb*USw?&=+m8mC+5`(pXT)Ab)`RPDcBlO<v~88yrxb!Uvqh6`goq;9Mz{5E^y)#uCC
zR~@=$TIcJZJ43yddUV#s+VS;jqK)xxhOP8zO)3u`p4(LrpJ%H$Ble#0<CDvF4fod@
z#HUjiJSS!NSnrRSTT;U&AN*Emb8Lgcr6bFCstmUED38y(EqnFt=u?$PO-?G=z56oF
zQlg(pK%rJYd4oD%!_pY_PrHsDnq46OP1>xkCFtFhgz1tON9r}cANNURgHQX{HR|7{
zYP?z&!}t=s-?(n0=xr5N-ZhiDmQ`;Pmjp~+QE0o_czA-Pgkg2n#LRCppV~%oT6dmk
zU7YA%wFLPzv&kd;_Bct{RE#JZ_T*i->=jvE)!s86hRS_V*fiHfvxLuGXr;lYEqtH+
z{U1h;QCUARCQfFus^^0=eg8!&$t$)Gye5*q*LP%C!lOXGo$K3f_FJa-{#*T#IfWD3
zYuhuA9K1Jt--hLULo|}|zh2gxe>N)W-5I-tc`;5JAxkq1vppYWj51DpbiZG1Onuwr
z8100%>9_hd+2)H#8E9A?G@~xLR%2iPxlh?D*`Tvh3u9wgv#v9|!==AJThN?de`WCL
zq=oasE={hU|7miu`2HQS{W7vC9+X#o<!;A*Uei0M`O!i_1-qQpbNX*gG>Q;T=v8pl
zy-(!!{A!l;fm8RlIu1D{_;7&#wcf>JpZ533+O@4itn|y4t>3n;dUe%t%rgrQ(JL>*
z`F#3%AD?D=cBW9|jUiF{7Jq(o*4Q9x(2`vno{vsgqL!GRGVYS=wim41C3h35&INTS
z-}1UsBX~%?-+E8OIeF5RdwLya_Bm&M;&IF%(KUf>$*-<|%s&uRJLsjEdd!2@HL!M(
z7*rdby|B0U`O??3wnVWEGrry*d+M>#+t2)!VGM<#rLQ%5zo`87jB?;{8^eByW^1AK
z(WHnoNmDLuc3u<Y=J57Sy>*s~*_4=%seR?L#q2Mc*gUIz?AH6?YYSgfN=Hb<l>B&$
zarRGhwxn9s&MtmB_?`dO_I-;im&7=3dE);#r=RTutqnu=>>4xEYk^v<(<1#(qOS+s
z);(DAOf=${Rc+sR6YJNrQtWJk_Na>6%<OlvB-qt{QNZZkdk6EKv+5W^^X@a?%H+lR
z-m*u`=!Z)NJoXjU61cZ0wAM#E_x98Q-(u>_<}?&HT+SVPqQvM_8~=bXCuq~6kQ|Fe
z0aH{;7FD&$IV_%OJITRN$lWl-O6?+F%y%n&bBiP1QQFf}9-pKM>hPB}lutcbVtvp#
zr772s+Wz8TN|Z|Ay5y^k2dAdI4P;45eV#e-`;Dn?^{S(0-O+MuxjlK`=B>9JZmyVi
zdzAh@&#);ooQ<a39`sGu=IFP%v=7aEWBZqd9o@dWkBY`>Ee-#LVY}a0z7v0^?mIAK
z&Ul%^sI#rs4`V+~uRT3iv~qm^w<%GHjn?^(Xjk8TqUS5zaMIjbZ`J>_&G@Q1=9bn(
zBl}D4dk2K}P9KnUjkao2(efwLZul#{{}OoMg`cY1!BDLs<?lzkObKHS`#L)G;LE`I
z`qdA&t(Ts2a==x?xeN6R=S)enk-T&(deQ);&CjK8t`1)FoOO5TE7fO8Q=ggXUca&5
z-{#QO8RIY4ZCyRlDm*YMN79OJbMM`UU1>M<@4cD5s$F<`uiRJrZzhbreQxom8z;x`
zjmpuUu`Qv@%i-m;dkUj!JXA}!<left!othB$zr^l(&<fsa}P|oU9)x9N7)GqkIxUz
zZ#2sK*2b6mhVk+C^pETA-S)g0e$B{MdPifP;|2--fe~>x@9sT0>CBu_pZ7OzKb^Hb
z;;ja2-fj(zqzGNvx%w^Yg+^ocWX|_aA8;srFm;*)bCY%g-}~vbG}Hgb*f)SzwrpF+
zcE`4D+qTh3I!?#7-5tAQyJOq7*|BZ@$vJ&4-v7>hx4y6T+PlVBW7eFrYE`m!tpr#Z
zgM^<4h%Dd!C^}5;W)2|t0Y*)XFPx__)z9q0x(9}B@RQ>bz)%;=;ds;<So@t|46KT1
zu46I-8KG!^oJa`bFGN|QF2m6GV^7EisFB`-`%;Jv7y}`<A37q34zg&#cx@75Cp=FU
z;sM~!7~Q9nfGZIy&=NoI>0t+vTEt|vpo|gfPog00+SQ@wO_WBSla>eu!ec1Pro!jb
zEE!0){c#PVOt7|zOoaK*N{m3?AiN?9#-(YzGmGbJC^Ik+Jzx)|yGE6aG`Ob!2(Ji{
zpB^Zuv|_zl(I;aL^Xv!+I<oif2x1^|sFV+c{GgH-1<?zib4nO%iy!hjqP90SMUUoV
zU~<5WzTMnsCcKB4Gt4DURf&Bg#}d@0ixL&qCRU8ulN^L2@{{{1G7=QK_~n-98^p3f
z`en{QL${?40M86Kza;?426|*NO#}olEh8$BQMJyVYV`sU0R?bCPqQ`&-i#Trp$J&4
zFqqf#OfN-@G*<M{9{RMrf$;tDSt%<a_hv+Q$oaz6QpkA-T`gj#)s(8y_b&)UT|^;>
z(M%5d!uQt+7>LgyaG25Y@~5@-!dzbsPyAIn+llNy!srTR0Gt%|PM{pn=sL=eW4U$9
z5ePw~pe>yU*)S1E(W&U=Dd~}6>D3tvNxGC9gn0KeD|R`=<Et>M(!)r|M!ys;$;w(W
zwRNM~3GZU<d+@`l&?L-xM5ulo6^1erw*2S`K}N$A6)u;ZIX@)&-W7se;uwU-7s}yY
zKK9C^GP(EV*0l>LjOu$jHt)BkI()0Jou`Cx_k9-C#*to;@jDOyw1&Pgx~|8hFZpzF
zZo8o)xLJ3kWBJ9<dG}$(DOV1Po)1-_L`6IOXYscr+MZ|m!gjr7-6^G#XZ;XDCV89C
z#Cw2dv)uMh3>`^2aS*@6#7URve@vJGlS9LH$GCRUZzL{`#eQjOt+qliD*0t;eQK-h
z&Sg!cva)th|2ToQvh>86tT8NjciY$BqZXUn)LPFTqv`c*xu(!nmbdg2u^lvWi;6Z`
zs_YSa(a-<*05&x-)mE(roc{wc#$v?T;@B7giyv}f2+a!N7H9o@5hW_?O6G~SIePid
zSa1_aZLs9enesS>wi>dI)09Cxy?TG-p|HaSg|n)zZ0eA6H7DG=8Zw@&thX`ujRRWP
z_)cx&+dasDO^mX$VdaPKk%Ba&+MaJa<)EmwuEkj4JFvjd5$9Xwi!BX4>WF>4XGq?M
zLoWmo;dq>~+J%iO$n|4_;Pa7svZsO#P4Qp>wioUrO4^O~-3|Bgd*1?@^=$RDOw|X7
zpbw?V(_wdcbRH?zWWhi6hz8tOCY;%5BexrwKU@e+uOoEAQ+CQ&IY1b{94@cLXs!7R
zo_{ZvLniNZulf8u=eUkl`?>Y1U|Y1>sigzU;-Xo&Hvx~Yur-c&R9V8AJ?4_I%xvfg
zObDob>4jN>Q=Q~xMS6(Lw=GYn#|u_Bc_*83V)H)F#yvV=MoMBxcbn8q7hGt{g9fr)
zmN!Bivw&DeYkLl9TC*^rqaq_QHrG&j3b<TCDy1a%-ti`uxM;4N4UK~Zn{WP==-1&S
zLghkH=sn_nQ#eb#u&tJOc?)+;7+%5|KqW95^mH(UH#>~Cq9z0fQ%H-O<QgmjR>wBE
zlx;m?`5I+yq@Ce8S4lsl-29%SMjvL?>HV)cYn{gQ)F0Z<-!(^5nboxXNM+0M_-K|B
zZ5*G_f^0ARYpZn{rMepKF;>z7N@zOW<J>u<@NdP~sR6x0@6-s@wfv4r;5w&}TG%^k
zKo$e75&-zXxGh6bOKCc5NQ_Uq-g&kSKZs`&HhhSRYCtxj;@+1K%nV|QT9W%t>0)Z%
z1<@|5YHj6w5VYjaZ`N}$H6;5U)v39zI4}}dwZzXJSEhs#T7Ir<&9xwvAos5OGQ>r7
zAn?tkB=45^JX45gmu@mr(=flUSKrdkYV%+UN~NWQ=nYy)HpC*=r)>{eU>Du*oaiFB
z?<nd62<DTRl5LNWUDlAOLsbGwk5T(>uL(6QAz^2)pg$w*wCfyQwNY<j*}eMc)wOI7
z!P45>T_`1E41a{il59S5eGOZ*q3NanJv8Cz;o6P$fwmW1S$Bx#bs&2bcXkPxg%hJl
z8wHX%2^O78NDjKE2-GwJ3Rz~5aLt-P&zgs(9}#mM9$gC50D2}qB8^ej@(ae1$Ri<-
zaXvk7t|*XD{0hlU6_GoH6tYUw!Z<8qWP=J8V_rV-9+(09c;*U!0<*S+fc5&;1o5ea
zja?Kg8iDs1^EsnQ6w`Dnl}m(@bevtKlStG$dA4;G{kreebI;p7oQ!IjdLK6!zp%T~
zN*h*5)N~8Qd*wdC`z_c~1p@L1sQaA?jxiF-Y5CcOz<#zfh9thD|79+9j=s~kAr-x5
zTQ=@(gdsN2v?Y}QRBvkKx2f9NJJ^eMWW2UXT3@~GMb37*8SW<5Jd}pr*BjZovPtRe
zznvgX>&3krQnF%_rp?zDvqRK1`vlv(Vt(LhkhpA}^rUu&^>~q{V`w#-e1rq1^<_8h
zfMv-DwueQtg;ATf941@_=+i{TP%tPpUz@@n1|g^3ER|#Y5+-t+h_BqzDxGk+3TVmg
zPCa=~iwf-AV~NA*5@Up>NSmg~N_4t!M$A_aSxboU&d9MfY2j;m!a6BLjZ?y~z`XEI
zIuJeyVbiC_TS~E^i~EBOnA<#t8kl><xeRg1G8EAI(75%tv1-)**TZU5FAs~m(q)HT
zydnd<nB)v{`WnHN*DcLX6RlHC-?JId*pSnb!&!scB9uPWQobyd#Kka_E0t0sl=8Vo
zi?XE3r6Lr&y>CKPG5Rakq=Yr9+%4}d`4D+1%|aV*ArNIKdSy<z4yK@92_$tZGF16-
z;c-{qVpNaMMr9pmKC6<9d|6>HO(PyYMJPgrs^?Zy_1~%-c!PpA(44$T7n$cGxmT>r
z2YlKK3C6J0?JBaAw9W&urL5;kCYS8)PGr9hI?kg$1KmOk2h1fzT05Idl{eRMqxuL|
zOcK`A<(ApL+lFo%EdiD&syB-tikm*DVKBgNcFlL9zxb-T8J265x0yPQDl}AUG18iS
z`HJqILZ7F+eGf9Ip~vT`Q2?7s-QwjojLE>zGw%E*9<x~7fpv<Hr<IF_^WZqMv*y;K
zbY;XI8|*%4Lstoya&yBQr8-Dvui$oG%YOO9;Oy>yd@*<#(@;rov34M%IUxL9<@t0o
zWZu~M!c$v1u#9w|M>@q|kJo%r-Gk4|;rSY;$w{qfX;kCrG)DR0$Tsls%M9GpXdy0~
zp=$e%h0f7ktNRPomlx5>jm-1@&!#Uy1CRQorCwyzSX3MRa=Cmps`GMZ8^x7lt9plP
zRJ6}Rt^IXB*g(xj7q4*DU$M!#<8aQbSjUq;huRGZ5+<TtHW(RFJm0fk2^={P+$5>D
zjGdRbNw+8?u#)zSqN0Dg-@W4^*lBazO^U*jyH8T5w)2SJF759T<NOL>^ebthPBtQR
z?4JB8jZ?!&Wdqomvp?Vhdn^O{Q{?JFG1KLwKOZOQKn^mkArO=Ps_jfw<^Ah{e6yUy
zNzE9H=Gkc!G`8Vp<iW`7k&Xk{&8mn=)G*Y8-$$34Go$JUY2?q@R2>C&!PpYzz>Rra
z?-m#w?l^-_$A;ln^;Vh*^qhp;QK{uU9@yh1VH?bPA~US8S_ITY;eAqB(Ul;00D=PG
z0c@SozyQ2<t$1=<O#F|4K@0#^i0wSSZI^;~^#9=nz(SkAeLIj%)+ClAW2;1yWsW@n
zgxEehKn@P2;)Z-QfwV}1rGo<E3^*E!0IgE=6E&99FFn9Ok0|7-YV+Bw)Rh7#@7X#v
zdf9cPem?W%9bw{;x~E7%6|05ZlI(i<xwT_fqX(`fU0))v^;Sj{^X8=ig!~h0fP(53
zmw*@*BQQ(S@(}B$B#3Q_0FOzkL6&;-FB)m8Yn=VPCtA8QbGo%yfnqfmsz}D6!S1g9
z<j{v*-L0*i4yd#nzh2kOziPN(!^5A8;?+@C;gRTxVxu4eyMmBMEie*yua-_+Id<T;
zg7L|m&nl27QIySBF>P>@!p;rk)a^eG-CkR!iysY_BmLqcG7&l+qA~DTH_#<XA>UpR
z+a6WE#0^^Lu+&v3=@qYZ-DekWX$`c*CA`E%wWCFJ{TA0!ScZRgkE&2dm-+SyKfg~^
zk(CNq;(p$>1U0%u_*wulDJ-;OeitsdqgJuUp_<(@AVMpYTBp^K+~QtUw{-?h-}1z#
z1CVlfNS!RE?O5{%n?etq2DZoaBN;+NL%ejQgzXwKWAS>PkrBDZ0Rq;&@K7;)m8PKd
zsg7_$d<<<2Dk7qPTnG}fZ&6Z++hBqUn6Hsy54f?dWI)7=a6+4~3%XG}qy|RJ6WA|O
zs#A@j8$F-EOY49FG3#sA;P%?*aGw>IRMMl#r*w%|Z$>x6Dg&A$HN`CR;&@7HHo8yh
zMfVTi%@I;7b=Jlh+#!@U^x97})92RpKYsGCbdg2F3aIc6IjWC^?Gj$2CoqAIE(qSU
zigO-yQeef4J3#=!%`vKGbPCTk35DRneGMmslR&%&%{e2GKd>SI+S|`%e?wu!Tt885
zoqKmqSDEg{Gl}29H>piIA%0Smn1+PV!PYnjLb^B1AFovl$oIxMc9EB2%#vVBflvy5
z+>qQNG;S8|ODm9XeGxU)PLjA=XvoBwUdR$4p>8zcE4VBNpuyo80wHG7-DT7_Z%-#v
z4L27!QH`V@uyTWG5)E!Hw3*u8!X(2>k}hs8Yt7vZ0zaRzfD&#9366fbcFX!dzZtpQ
z`Y&0p6;b5|@9}C9%n99-%m(A%_Q*~$IHy2W%MCo>MHk%MaeXYTtlVlL!9Ik}0^`So
z@PLS}>yR9c%{AOS+|5Fk0I}6oD*jclejNikxt6M;&e0Blh*|yJjK~b)VI7eY6@eYP
z6b5Y?Ka2$X!i5vc*DS~_PG}jp+kJg60YP|ks!Ai~g{P8Mt$K^VDt+O<*aj77sp^Cb
zuF1?1=CaQQL?8+$;HDcYppu$YdHDy9DMM(>8EH@$icHZ62Y7+@S|Ky2gxxd49^-+e
z#}WpmblcZQUFdy8u|i>vfPhNKuH<x5n}^%tm|$f_hJMr>gyH2j3d`LREw93Bb?dPO
z#ht-c5|+S@5>cmI^x6*j+thhuhqTiOyu(sA*%A$57EHQ%dWUGpLSwKrQfb7F;L24w
zi5Et%)e4d1Gk&f+8c@3g;{G}%?ZvR*my=d25-adZUuTg}K17mN&4l|ej=Gy|9hh~A
z3o=wWX$Wk=A+sd90R{{xR2Puw5%mHafE0vxRV2E^!fm^no8t=CU)^0p=g)RX)*98~
z?gN>1H>C!a#FPhz?zKZKYR1cYk`aa#^+Sd5I_xrc0y$IIg%QJj2j-sFW^p2~pdD0)
z3!74!gcYonW_D;6wGN{+r{f<(vT27X5NG7EGV6{7?wgP^C||X8!U)wSRnDSkFq)97
zb&ArE9jj<XI1&s>EGY6RU+?FNk>Q)e)^ZC)V3jF!o$`1K3PELzD4y8_O*}jz^COk7
zE6xzVfAL#^V@7JQePU5t4=Ar(@4R6Hv~us7t*4X3*4E7(`EtA2aXCqtG&Vm;R5mk&
zUj#Eny-YV_<!9C@DNOq$VfE#;9dGaY$+Zai4z>#?zrlop?WTGu;f5pOMmL5IOJVIA
z`Bt+#u3AvK)xEX>MN*r!2aI=pTx{m<ILSIM9i(y<00WVhHIKAiH=d?vmA~gy#Xv1f
zJ<iAAX?3_)_A*PtmFkri<}5b*tv6zWl3<q@(K!(5jx)?~a6u8d#{<ImtPo;qp#mC1
z0(=D%i)|l-7rBa5%8IOO_JK0}#+w9aT=dV!Aph|kBm?-L4gY*D@~g6z)-*o?&oVRf
zPv#n7Nvh8ppgmet=<xtR?_YDRU3j6L4ZxpYt$JtD@je`RT=211r+#JYtpDP4H<HX`
zB6`0sYzs{O{$0?+x!`x?L;gyVxtx<i${;C=8*5mBJuj(J))pHD+CkydpespgwmKr-
z1L)7$j*k?*6N%5lPJ}^F9wP^lue3hn0BHlh=;T}#sKod*Sf6b~uc)3lHYRrNRqU}b
z{geUM%h?B&DTL}JVSv$0*|ju+)Z=s$ZZF#~k5$H)rt<Ay3ne<GeI~h=f{;>gAkk`0
zxzJ&j#MjC7YZsqPy`@G(n)T}_3`PAVR5sc#>QG^m22`vW;NsGHsO_r_KvN^^e<-)<
zpl)YoOrJ$%Oq)uEl_`97gHkLPrvow8rVld6>@HViWj`{x=3$g--|D$Gt@D^ZGX&FT
zi@^G>*w2EeLJY$)f=?E(zaN`GNL342rh}kMo;Q{w>EWOV_4)e_GjVhFnElA?bKF<e
zPNxO>$bLu<0pBEm0*mijzD$qb5G7n&*-W-(cDdY+QEQgtOfpE|WH_><)JK-WJz{JJ
zW9*Neyc$bCA@b0m*wAKoFn*ht?BSRpE>Q7q5x%*4Q7NI0t;V<DY5cnH!3v^HUO-Za
z=NU?AKLll?fR+v9)bOYwuKc;UafYewQRLT~vI7TFu20pF?S9zcuX`6AwsI{2C-L%2
zKSNh8TXUEjv{1}1ffW)}D0)q}(<wl#n+{rEZ#jWiCb~P%+s!f^EUZYorgso%1_A2B
zlsCgDB~*@u4}6{GPEy7=Kht=c5Ib(^Xtm%@SK0RPkoHVhtDsEl6SwZF+gsF7QX)6W
z9eoS)jC$X%&K-g6e|{y_dIQ2uo9PV2y;%MJtue!t!>QS8(&|OT5RCizxCubZM4pAU
z{qYV&ukOhzs>f~9k-N$1dV_O&cu=TSeUuJj$1<~P%6=M?u#VqZk=lJnSJLd=WQWZj
zGxPaiSxM?C(~%|Xtt{t_qFk%&4N3b~@<G1$of~?8&4VcT|2Z#q=DDP_6_9%`j!gOe
z@FhdgJxBt@ks$QJaD<^1B4P@242p9h2%-eF`1~@}lNQwP0YSK+LAfpfZ;NW>K}vFE
z$S6S0Dw0NR`UwXQUQ1i&b?kT3`*prb$7o-g%#b<v$2K98o|s8D#a=$5wg9!mKlg2r
z-UF{dd6zWmt+vFT+q(eh!d#;XctSsOCGK89T_tX`)4aiWtUus&E4(VWK+ta9ft_Z(
zGPOv*2we}1zeeuEqCB>W;sxrg(;e`MtPk(MeSaOMd`jGJhkC}#YHl~0P5eAREI6?a
z=<V0uG1gD5?US~S<H9vS#Mb?qF1csIyZ^Snw`Vc&Rxv(aopRaqYVz}`;JIe#^#tPu
zY#%SUpomWt&v#vs?+$--^4YS>^%>k#H|h?;vth`UZA0z;4*V{V;?a5X#d}1HxMI(f
z?pdjob@XVT=;xhp<3`(->tf=C>nEG^N1=wO8`u5v3ca64WzbIE90G4}PhKwT=TAKz
ze4nozyH3ga_bq;|qwQkBU!H(JEFJg10jyq)-XN`lSG>ndB=hNY^*a{Hy&}v1xW2_e
z|Ia+m#tVqY>ZA9!Td!Z8>VOImgvl=z38iI2zzg_w(}>z*I$UlN>}Sq@*T(@O%EbsN
zCEceGPqtzZIl;H`r_K`M>b<6?;y$SDW)5_FrQ7<oT#us8^|H3-`Fi&DpqqZTxKA;x
zsM^8#NO3eDSsGkpiFV>fM7HmsHv4Ei%c)*_$~<o$Hbt33p4D#QhU|h(&t`&>H>2Oz
zKx<LF@A=iLO*u|EHjMJsQD*tEq`V3;^~g0?(t)3)o#goTt64Csnfk0V0Yz||yolXg
zJ5eaWmTP{v;BoEfJ+h11L_qQw{S8wsV{aNCR2Th_L+An6G%$ga#==+q$1L>vl{CZt
z-IY7FAE_4XXdV$I9dP*wOTf!U8zGa-yw35_nu6CFu(K%nR#|VxQTMq0bnLi0cm(TK
z{I8Ig*4Zr*F66p~ayEo12IAtDhM1q5$duiK4^qxO%@$fK1FHp00x`|wc<#LuJl`_t
z+?V#=x6h5iK{C(!a2{w>8??xLrc=T_BMyFnP`b#qxTx5O^L@rS_y3aOf1nAR|A}5k
zpbdn1*9=~1E}9lJKb)Q=XxlMg2c+7o4=n^NIbu*FZnu%6pariMuqEutf4}T5#|rwS
znvBO6S}_(aiUX`i2CJHl65TT)VkvKJjOdDko)lvhDI$S5$6nfYOAjr%4<<}p6djMN
z4uM*#lV$l4@*Fij_20)wkm|pGcKLCltz(Hj@3@xCwSK(nZRadOD{&!KMO=a?B54QI
zGoc7{`B|$u<|!suN<&VdxyCo2-=8FJw@4$!_7ONKCMH`%Gbq%z?TbXCgkDST3iCcN
zRi+5uVJ#4{8K6Q$G&pcxz-=eZlKp9##%ZbXgW;=qomnSSv;7&5{VB(~^Vo}4LOUh|
zK0YuXEC^7Lz6WyT#ps6hVJAQN&%ifn!wzW&P=^v&T2eg_z0yY!luX^vS0n>y8gIy@
ziP;B!;`m>hG(+?-!N7*usljCghWK<{8q9BP1d1y+(1H|Lx%MlKx-6;p^T8NF2aI}3
z_KWcuU@4#>+TavK4PbV&A0p(MbHKiHoGg{>7u~Z!u(6^u7J>-4CY98JN)HbZ^wl$V
z&Fp6-n@;ZQ%;HdnvL$evM5PpHsD6PtkVv}poW3qfWI^!4*$vP_x1@d!29VGY6kPMs
zZWds)B2QIh$*El8DNb<r;Wo1vqST>DZAz<#9vCKs;ke~#IR~I~3)josL|fgohi{lj
zumDA8<!iVGNNl~KQ+OG+dP&6H$gaO9p={enjXW)4XX-hR{)T$bG)*p57jd4w(coKs
z36-@WLtHYTY}*pHM~QI7uH3l@)jY3j_{##}5vN3aU36Oq!WA{zR-Hqoz=!t<7~~AV
zC`svO&-^H1qi!yk%oBg|x44Umx2Jqx-n{SQ_Bg22!zCu|fEI`sP$eiD{H7QNK$A!#
z3NnHDhi_uaAv6MU%+An~uKvYx2Z!gXXN*1+VofZOfQQ{jZ7AcI5Nk%P{Z~IFh4o2R
zHnn6tnbc<36hvD3SjdM!>Td*n<qdoFAal&&j`K;ou(V#m!Is{V;^{?PCT2U8cE}Pc
zgM3w>zOYT$W1N6G#F&kalj!Rxj?obq&=FpvB7xSZAz*%eAh7d-(y_+B^$!h&3^`)&
zISDsaTT2!-Pv1^IT$tLLzut<a!Mi)`?|)!Dirb{tA`Mn(o3-(?CP8r!hSS^Cf<?Pm
z6?`&En4x|9Zms`-nVdl!u}IZs{7e#Ibp58O(8C?Cd?(VDGG5TaMiR`MJ4x3@F?<>H
zDyHy~kFls!9DyTmw5N<1T}3!t4X*rvtYoz5L)pw9@1*$omk*iT53<picA+(ip(Ex?
zs;SaLLSeww#0j#c9eOMlQPH#@mK}CNi&QejfdOIzrQ=J(m1IQh9W8+ywE+R2vuY?J
zkPLMpeN_xe7>kV`Ko&Bw#dT&qW`wMP>Zo%pdph~8+ZN%GWf#KG-z=UoZM22OTNenC
z!dLo`lVhyaALyW{=7dg#>3+HSuCQ(fK}L>vL!vV_4qZ?r@8ExVLkvwI691$ip^>s1
zBpC%#&C+vFnfX8rI~{zl@H3!}rRV<OPU6+sk$EK{S|wP`VY}J_+2DY;OsE?f38sT@
zcD<ai*{CD#<+#FC>{#KJuRh!-ba<TYAxCAIcT$3;e*GwX=13Z~a&q@On&Y~$V>@*7
z<e409LY>tc&8Ce}IQt4Q407s9wB2UycQCGiEV{V5%=`WT#hlX&WpdYqzSmGom;J8}
zZ>)@4lnkj`l2_TMg=Tt_;l?ugZ&>EWp~$exvN;7o4xo(C2ncOJS0?$j8sSE{i3IjC
zG}KjgTN5#TDVvCbvB%j9D8dQRN&GIjb3g_p!eW#5;W9`#V&|mU%)D7XE}ZZeC=1@<
zzM$90lL~@i5lp@VFoGz;WQ_uv&0Kk_U(LXS9fO6I#vx(HlG-5Cil>&w4LE=DhA>_&
z@yax{XE{c`0#v3(!kd8?*yM&epoSvd<(BK75og0UHs!HgAI=nxq+&WSiJON;s~x5=
z1Cm>GB*dC(@w1l<cFOAJLu;s9j+Pgq71ffONhO#j9w1Q*EnP45a$LvLXSz@HmznIN
z%;1NUuZzY@5|>F?tQO7IIzT`i@QT0C7l-CNo~Ntw25&HPg;I)KMi?^`U6&4^_+>nc
z1@!h%&)1J;5%c_Nv99xM%H*!&A?FgH-QJdAEoM0I3m3}Z$Q5`E1K+Op!lyIW=HTV1
zugAAmY*C{szxLjre9N7?FUA86)0}PR%<L!#1^UF5*)cRmF7IZ5tp1RMOpYU;DGLbg
zWGJ`JJZr2cc%sWrdsV9b(s-~4>rpit=v;EO$4tq5hJTCugP<UsWbKZ@yV?la*)-9V
zx=Bi;lZ(1YO$u`&=JEQ(9<X+dv8P_&Lx4!Uld&XG%g)@WmwL;!%_y35ik8qLZN3R-
zXFC04hhJ%)JL`b2u*N;~&LwS1cRU3no>bK~Y+ZR~>xO0L#19MwtCJKRiFGQLU9xi*
zJ$d_QMd{m0La8C~kxOlSX{7kvIS~ZM_W_W|ak#SD;>WK!x;GObk8>05OIpjoajD8r
zi(=?8!;V9&v-i;Dm0__}Q}W%_C+sHZ7U;T;wHA6E)w|KiqsOL?&T5qfl+~vrgVT0v
z^r|*NTD&$|Q_P+1Sp~5wij>n+;oj@ohn-thSr-gD2~I2tuho+QxN-;WtckoDOC#75
zyFRSoHH)-g!<Mr~^MIG$8z{2AnNYu2D`V>UH2}MVsABwbMxePO=gVP8p9_JP@$VZW
z4Bwy$*cXBeRr@@sv9WyEld>rp`AlFPlP`D0A~KIsv-e;R&xhEnzahmuX-=kuV-J3d
z+x`;j%)RI!d%oUCWPN4BEE_R23!W#V{V0#l2w7Py&lXIcQA9<+;iv0YLIOS+FIGRJ
zp6@za?bcD=cVYqY7D9g5U@LzX^3}1dx@ZkjMds`$tLn1S)A}RKvbR>y=q#-JD9iD+
z$>>iRuvAvqm`@M<IBuRObI6=x02)D#3gi3GKNCOW{JQb|b+lg=1LjJiP>h11F%$mj
z7Kdk0Pu_jB%atO#?mi!z)Y)jnkk|UnLZ6zbHf)<)QK^Gyj<6M?a@!WKEqnrkt8@?N
zIw6|k*TXWq7|U>O#BGs;+qqS6V<D`<oYvYl&*HjW>QnG`#>^2yeXDhIuVzws+r8$O
zK%o+dM8t6hAHps1Q397#_@IS=@Jm8MIzm;|7qZO7_9J{6#-Mv_Gcg}7SYDzy6)>j0
z8&Nrp9i7V`ns6M!=Ox+{(L%e}OS)S+819+}<mJ&SIu~82lSpmMzTYVgzJ$T`BUidZ
z45x0pJ9r4MzNK5=p-F%B7$Kq^Claq|tSiUvLv(X|srC$A$3>bi@d-g@pcJ#sibzCh
zOvh4fQ#W%8yaZISv=h8ih&8%uiF9*@OzwulKD)9Fso@q{yu;WjhU&UQEITiWJn|WQ
z(iIh%)=EIew>LlU5=!**)L=Pj={oX5U8G0?7Y}LaP>d3p*ZR4G7|0k#e>bTkz-N0H
z;uK2Mq6d2ucf8qT=@9LJiLww6|Km3F$>aD7dALB?GU95BS|qaEkpgNY;V4x0G=$n`
z69xz9G?W2}7=PNBx<iQYRk3V8LyhMkR3~ZZlKP{jJiYI?D%W%b_Ieo-WIIe@>D}fC
zRBI|r;m#AZbQZT`?8hexIGV&`>-_Q_LSr4sV&DY5XDI5H;E)+)Gp)=c`AD13Rd5Uz
z><0&`hb+7b4*Dt2%;Kfg9P&w%^6FEirKZB%{GuLTlavQ1w5G+w<6L7z*EWX_cZmGk
z#44Rqd}-*Kc(;{49~Pp1+u9`Qf!a^*{R{~Vs$Siamc{%U<lfV+1b@fnAbt#27)W+o
z+N`9l=!Do5fo4`=mzhn!S-;y9>)DxM?Wi}Q(MarFvlg)IB4%UJXi%q8UdWBpxQRxo
z76)e+m`X({N3Ir^-lfe@Em2PXxEnT`ugq`-qS(9AS7cy3t$blfrn2p!)Ejw6q(aPB
zRAkU6gTkaGiNb`H8<t!^rZSVRoKMadDs9^;l0R@Fk>5~PCLO(wuM~&LB(lb*w5|0e
zObRx6v&uW4oaIZ{Ww}Y1hfw}N{Rnbn0fExC(+`TZ1=W00gjS9Gfd`{7Z5}0Ud#2u+
zA!IhTG2|V$e4AxQ8F!}Mde#x-^(EK*!kPi(#8qj9<uc()voCZ_(XAn-URML<_H_df
zBDaKHbZnxx`Jk_N`Wrnln#BxK=CQtn+~JiNAOengvi5gfw@Ink+!)8aCY*CRJM>Vo
zVpeD8QK7MrbFA!NVmyzdLODA$_}w8B8pdwnV4HYO&6MxFK@AJv)F6;Ndx_yg+|7oh
zd^L0($2QU%{Gw4DXt%nEb#sTl8gUDGY|B|}FA5OTb>gZ?rfk9oF-#$>&+XqtW5(EH
zMpVP8Msj}U&S^WUWvGncbwww-W>M}-E)hp{%<-Eh-)0VLiNM9I3$KuP->!yTe(PKO
z7@yJ@2)2t`)%%O_v81I~4C3AZ_e6!JX*&c?>2T{l9$BvfQF~b=sZSvPn7)1A{%}Xe
z&-B>ps_{q4qj9;ZoHAkw1p?g|5i8#~7MQ?WQiHMA+8$1`7r!&wxXc5L{w?TKo8gcC
z19xk_gXTcP7|^?UwX#Twx_s;C1Fa?4N7Xz3wjA(lPs;t~$-(u}{bseOHA2rb^G8$`
zPZr^s2%f@nuKY7v+y!Te6r&haC&{T;Ds+lWCg+Z6Ic7PY<!{!|zzS!k32IgSH~6<D
zr`8@T{&i|c{few>b(Sgoo)E9$EGBV9q6jqj-R@DKwI~O)fzNrb2NtrCscH7i%3k8Y
zt!nGYB>NPJnxGEP(lTVyo@;&7?9*ccFh_?4*C!3rVNwe6{Wh6LOWpT^SzaC>%u=TE
zPpzoUWeN35JUV4%J?)q$rlqJi0m6r}(QHP|eS=i?A+%G<^DhdsA?YOX*AKrm7|S1b
zf1rQghnOhBBjx@z%pn?KCTs_R#vai_F=af?6g7(GVNCxf)3yov9jR#-L3v{cS-E8}
zCsh;8bS-Z8Y*mw~l_+XvXy4`tEVIhE)SmXqS=*><+Op<5P)32?+hVg=s9tIx5wX;m
z1*B`ty2Kk(x{1pgCFvYr1@uMcDLjqf8KwOqUMr7gnibx)muO@tRonX2rKd68y{?i&
z#n+MB6ud<X$8zuf$RifM;`!UagT+-tx5>zZ-q9poVGqlUWZh?V=|nNs>_<!BSre?+
z?2#?yJ*QsO0iKN}y7@D=M%_{-o5%)TVPjMs5tQH~DgAHSbmqgO=H+|L^EU@92L79F
z<;h1Pqc<9(H$QfpUSlz4L~VKMowdmv&M+sdy@bczLc9)bvrQ23R!y?GhMwnGL(|tn
z_LUjiUR_@*N_k|j#dOozvTuF%MxDH+3Ud~u`FW$*L9Q^+%F^B72di!=Glaf3c(Zlr
zz$<-9f|QxyXw}&mDe>0xb`RuRmVG-h26kZEXzd+J?gl-ZaTnq`KVwDn^sU>1o4?KM
z9<_i?_8Hgg=5<O+L^M5I6K$oUxCjITv0lhReZRQ)j4O7da$UbEs00bW|H}W@eZTa`
z|M~lWtB!^Jazjk7+=W;AXdKCK6&Xu%v2eb#$_05_^xoL<YExh~`H*o}u%KX_J>Pac
z9Y7mDz_;L@W<6shu>}6iNzcdY1Ju|4LqdvS4du9t7DA&KKHBQf4A8vZ+Hwq%#e5k^
zNELVb$VAVPER7Isvvp6Oo-p2C%oL@K!`r>upRj|M8?=p|9FoiC_U_#zyzdE0H}R9k
zav0$jQ+pMV^1};$!Vn=PI!lQ7nIJ#cc6I8UyZ?0S=sW}?;b`p3eF13e82(A!eI|9=
z_M&-!rKil$+06L;Vp!?N)>rAb%6nXEf0_EJxb`=^lE@M{?{fM0XR7?O7em|BTn4R6
zLg{IE{p(uymy-K0Xv0PtxA15Z@J>uQ!v%D2`%Rx>9}K0}K0Sh@0*9*Uqk@Ny%dSZu
zfU6Qyr`7F+c`fJ++@S*(v_|-Cylw%DE=L8#aukONNx*v~ZZ9wAmO^k*Rpg|fc2|X=
znJG+0X7a&Jv4`8cLazE%p2{4s%7HgKwVmElLl~<lRNZaiU7O+U`NK2f277qLLat`1
zRF=tgnS>_WhQ@|74{rVJL3xq8M)uGhx2^x#i6MM#TPPuzv6?}~Q}DS{md~Z3*PDAq
zSNb9tKt$vfJ8_%9i-heOz`HDcf9(g(C8g`g)(J+dM7voeufds$o`Y>Wu|3)4FInNE
z7xyIGO~;1tBEU(kSw6n5VLA5fW=x(>lTPIcmw8$v$M9n?u6D97VkxMIj)a|P%6zXn
zpBbfh3JbEupa~Nrcb;VUEE!GQJu{m_ov%4ZO=kSbxh~q8WWu9(>38X*4Id>JzuheJ
z!Qai;)sJF;I3&B=9FW>n`dRE=!J#<X=>@SmF6Eh*M&at9@b)Ls$}X%Oh@5naTy0=|
zTB+VK`_4+QE4*0M6n=m1Nv92#sFyYw_%*man}xY)`qS|qPI;WrX)B9^U_kOw0M2Av
zrV~P9=gT9I_eB`eInS_%blZ2?`(#VS7BUi22kY8h@gDxnNaV6s<3dUz?8(B3)-?C?
zW>mbRZs${nMW#tP0+FU!_W|k#<4IEy9qlNRQ46IP3yJs5O+<=Lk({F&72qCE2Ullj
zc+$AzmO$Z~nZk^nIZp0L=N8wBiq`&Y*Pil@3;jlMK`J{tRRLI(Zjy;woxWYHu6@Ap
z9%X9=SD;S1hk3}M3##1fd>c=N992S|#!KQowBJnKQ~aa9hBh0+YcnnkQ^17ek6hGS
z*w$NOh)u}fpag<=a}iIfVYiclFrE%NKA#}uqvRu|z5;(=z=9*HuF*?G%=b3#m%4i}
z2wVEO9g<A9730~1Rzg++eD*5OqY$7Y-(67B)L|v?%W(TsN(hGZ=+Z=cuS}e|Qz{0g
zqm4qe0(FS<!^A=ba)ccG>uZY6=rRc~{MW)Qwd(<QjPk|0k)KlPKf5ko(!gRh)R?4-
z@t0%Ic&1JPAp#}bKw?1EjI?`qn4ry4K!%7Q%`0M$%u=(iY+`@B)OY}z1xVWA1s`}7
z_9y)Wf!Jlir&m8LZ4;Wz%H2)Ft-_vk{ygT`l9r!!39Y!|<*%2_WQHSUAv_kGrJ0*3
zaHKD|y>l9D$_FguWdBQ0@mRauCe_`ISO(0r1WX6F?!Z8?hwn}8v8&#C(QU1*Ozpx#
zb33vd<m{MD`AsW8+*Ylnhvbn#9myOGcwvmbb)sRJwGPc0lE4gmdzpBIh3ePwPzIzc
zCERxVQRJ;8P>s`8!>GsJeN4>CxF+4f!wM5^RtwD#^%uM+p;lB2*@&46et;tok>iqG
z?ZV0jjY=?pM|-T+RRJvne<n3EO`*ZW5ah)^5{Wc2j@1b;CJ$d$($_w^+j9w*&tqMe
z7TV?&G{dS%3RBo$7@ZqyXf`p%)8G$6Dnn=<)wf!c`B;i%92a=_jTT}7ryzqY>UuK{
zBug_jSmoJ=zt!ON5e)P0ymDVP{Q@{B_TO3|WC8)uG7K70kP5<l2I2-<t&pzPBg3o5
zvgGtL1#khtW%Whg4B5c~m>N9e5qELW9r)pA=JhM_@TbOAI|!tyMB|UX#?PQ>d2{JA
zn9WR{$G1=&rvdYbF4Nkj82wE1122-^HpC6Z@SN78^>T6S1@2!=Pp1M|R_%UH2|8E#
zN=C~oaXf?;#OBY)_aWz~Tx4#`9~Yg(W<Nus7+s2^`8ORW(rg+)9Zzp_L$~+c^PjmL
zggU+aY**AzGIzNl@k|X;l&WJ`yDWV}cghzKJSl%(dO5&Zs$>toc-h<d^~?MG1h1sG
z`*Ip8G7%`H)SF|0G3*VTEvj#g+v`_w!Hp=61wbCmaiK;6zA7oHJ&e5K44y8`kT>Ag
zd7oY1D(DHtHf`X>UAFsuI}Q|-(7lR&vuYoTZ0wMvt?jE0MZ3-fd~U@ZAqcW$>~);+
zoiNJwE9gi@mQEZhN>3~N#FuPeTyg_EJaP16WWyF;ba}#`m6*6`zQ8=J+2z~8Fk6+{
z;8(`>K@`;rkN`~rZr2W;^ZZB_<Vl<^To#J?4TLgPMSS2W>dly^EL0&3D^>-!C^kzj
zF=KS*cfnWVg`JyK`8icU@#0c}hpzNikjKGC0?{jMg7a0OUU^%2mJ=djO&}w6D2a%z
zghsIwKz$wa6_Tpzs$&e&sBKGw-r0LsTzczh4JdQyE^L)ZWs%FYSoDnx#IEXIXXVs-
zsGm-#d0)na1qyFEw)i3QRRJ!gAaPTq?ij7J8mZn~`*Lg*TRfL(kLxd>h?rn|>KVAe
zUZTI)Gd%{EDuDd7L$%6-rE#D~MHv-N)HE(DtPjQOiqUZ%WN6ZM(#v2|4D`$D`(c$W
z6;Rx0oI*08hZhyfyT7FQ9Skvg_d5yE?im!(?kEdu<!hBOCI*Z!FtXb4+G%+4H*Q`q
z)-=;@J}z{y1CKSy0yYKh>Ud8jRCa$55t+ko-uNQ+V@IN_u7eGa8%30F_AS1{9-oty
zB-k84&k3GaqtWG|zWB<35G<?iji2!uA4$Q;vk3PbKB^$8&^lM$%?aUWFz$2=<l@g(
z$|0=@`}Y7zlYbJ?7>E@|3*R*A%`Lv|Lct-JVM!TZlFzbRQ<mRY;IV6+LgkrN!1>ui
zi$3QFnG+$_`y3>U1o9RQ@Y=X%*og^gie5?b4RwZeZv_6QPS6AUpgoKZuXprt`CAv_
zeo)}HsJx#(=2#4QU7I?Pfus>qm;M}co@0crRly`b)zr4HOJdVrXEg_HldHdGG}J0k
zIpSUlRSn0n({<ZGVTD5Nnm}^qK8HYk(YY`&Mh|yt$^u%Z7)?AMt`#6LN5KlQ0AVH-
z=v^^ZB6o5#`FYx*fjWq3a-=#}1wRxsVKvWzRV907^+>(-6Wb$fRg!EI>!zO!Az+@T
zAKG_~HrRz$#l^`4ZY^^8W2YGlHxkaPCZ0|Cgc$<*1+GnF@={!YiJ7IAvG9>ED!UL2
zqH3&c(2(x*QaUovP#AM`X=G5(ocu5isXIS;5LLJEq7}ppnhvYZRvy(2u0~h}c?;p`
zvD5@-FXP}W)N<-@o$X#&WWw+=p3(J`b|ynlD#=_pn<XUd6TuH`fh8<i1U|9u2_*3<
z{diijW`ej?K7|9ok$<qA6$=dr#DF>I@!1Ro`H_(v=JyOhvCwa_Y(2)qLI15xzz=*%
z3WNs$zkQ#9>foDNrR|qk9v0!b{UzmTXR~{C8J%NUjeY(nLSvQ~ag37U9im#PvZs3m
z?<yjWySxI87SLZZ(}vM3^zE=%Z%=YF0A{&8te<0V&6a&ihC`{x`9HxJJ06`ju5RIL
zyPR>iC(>OTIqZPC(l^l_%I^{lC@IeB<b<c*!JoZ9npo<>Ad+TkT$4I20T;MtOxHHG
z!cZ1$S!~{YvlZY#w<)Y4TrbRR7jHT!y&+F~ZaQ?4^oShBM>=gm-&*6`*HBAZbP=95
zbT|z)l-bM`67E2i>G9^&C(6IPwKmB(Pk`^g6b|``xmb}kLsEM)uv>c*Sv~5UK#is-
zNEO0l<7gbV-n>JuUeVMX<BVfxHW$Pvik}Sj7rHC891$Z(N3~390{$8>CoX#uSUL$@
z(wVKK0BReJce+F@CBT#^3%jK6(N=#_vFKyd8v-BcLpBQRH+!-sy9*|kfQ(=qLPMU2
z&3N`Iv}ML0I)xEM8$JUPlXpkGb_W7D%T-`#UoC}{(`V#q>m=O*QOhCiM<LzBAMwsa
zhb8zgpfMa6zh7#kxG?mGMq8^s`--N7<;)|*7F4-pi8l9o__9ap(dW<)d|E;cmN7rI
zb3P!$q}q4ZB)|)2h~eY)8X*Nlmki&Hf^cVl>`H4nfjZN%<|&zn?X6m|2Fh6O*osqg
z%Q9U@dE_4A`92fN#xi-x)fMs5x#tP9h&``zaV<8TdaAk#)a??aIWp{yt`w&X3%nCA
z16=mV-%qR#Le{kb(bZcT#*4Q}&rj${J<hV!9FEkY!{gnzYG>gUY>|`f%favWi`VfR
z{3^-z!`Np#n28`dkyau<YendYqfH)r*cAp#xMo04`^SsUK-)~J;z5Y05fjaD&%_^$
zU(mdwnj?0z;tdGNk!EMj0O+hJ=PkCU)?CxSAz9bK5L!1AswTd97@8cYXxi)<__!0s
z2k1b>?|FfI*FXjN!DI<9_Kmx`kz=*e1&}>Q)Jm=QLamUJBo4f2z4OV&eNi$LH;l!M
zQ>gEt=ZCgDyZjACn%>v0N<RJ{%1j2q=|zbn#tIslx?*f;tc3{-;IH;7_rRf_TIQJi
zIkEi49n?sa;F>5f>YA1mLRS!J6$($8DD~IQRU9F~&EV0$ro7?Rz!UM<k<rY|ihtFp
zCks}3>WnyzQ3Cl&0r!{#`819^Xb&NVz<@rD%??@-9plBBujl7l^D8Ms`ZR4;kL&vY
z#)fceHbCD`qwMZc1a5f51sbJ_?eo@ig0~bjI*vZm+5K}sByDlWG)ltJhO`Y{Brw2E
z&3I^(=_L~Ab7mRvI8r;na=BSR`tQD&G`}2Wra0traLw|^v-532ty{)y0+THRT;6m6
z;)o0J<(N}9KLK2P2H7wb5fzto>7gB*4KRG7#0+FAj@RnGHQxB{Hqtp88oh*K(H!lD
zvKaJ9xHRy2sU#t@bKXrpA1lXoQ$ERL?oFq_uZVGK5>XcejIkM#+F{3I7hg+O1Pzqa
zF}}+jFx1!L<|lN48`3y^u5c8Ld9Vxn*C1pc!!-R2Q4BLh2<O+u87rUEMXT2D&$Ixj
zw9!DHMI1qP7bGhY6tek|h%X6g>oei^0+MC);yG0vc8M+QC6Ylv-ME}9)NC{JVJ7Q!
z7+L%rNAl>8UE=tO@{m`rZOLdQc(ruA*2d-hMEPip`*WKU9#zP!EkxhW0G5@=W+>@w
zGPRo$h!W8_uWxbV(e}x5Nc<)=nC9SZ&RSFO;Aivv1rFY7AGa(orsZM>7r$IyZSP%G
zvte*-Uo`i#M-CHbdmGsttRCGwk9s)W?p_?rh}4}CzG7KBjZ4H^#xN7Cuk(;BfBi9?
zvD1rH7ZlP0IZgaU|J&=iS0g~SFZ*&+8gUiJv3wmtuN1N4FZNp-CY>my{!f*;Odd7C
znzfwYeC&)iT}m?K?m`~?N!We?(@AgTh#BtQ?=U&nv$N<^l+lV+*1(NoM$h>!eNsT{
z%*A9aPl3V+vEtzTw9Q;<s5MtRN0hfR3-hQ^u@dN09Zs~G85A4z<01}gdL<$S|3+Iv
zGZ+M_Zb#xOY6(}+k}(XU#`_!6k3igB>tLWCOlt=KwZK}~2WFK%OfeNxo(fQ>8*nB2
z3e()jsoA*B<0Gy@<-F(S0yWpHh0eKi_$z#5K{C~ngrLdNRLnG3mDOs-CWEb>6UQxc
z3u`^dAtb~Uc5@c17eCIeQl-wYClQHd2W;$On`YS?C0BpCoe3aYofoy;aOzisyKgF(
zXTt9rE?Uj}*pbOqK!aNB%)*lqXCE`na@WT17Ru!g=7*PK8QxNY>9ebvaz5SXqZQ(U
z%CQH7TTDU{m<!d-4wI2BpJ+p5P6?1a8Im(I#iWypDIjYOWdq-uZ%uOcIuw$JOSq|m
zm5I{9cS&<*d5rp{hPBvPBv*V!2aJ+`&#q^+^%K3q&WG-bmP*xad1B`V2M_|Y$wV(u
zkB+bqAG>U{1LCQJFpm=-0E+(H0XK2)M57|2QrCmDr|xxqELg)v;q<5^kVp4Wa`=*3
zJn@KZ(COh*t`*|rOru)CtW*R|mko{por<GH)z2b|T&iL?V(0b<yQ%aW39i^=M(|K`
zK@wk4KwPHkoc6D~U)H`2+m7w3aKv!A4FfSeu;!k6=1E%VGT0SpZ$o`Mcz?L>F|~7(
zIUjWaE@nphraH|l5o&7Bl(?r3e`Qc4HGu*;&c6pRU!nr&)1ZJE8^9Az*En&mO{czT
z@S_o<B30PET9U&tCvl~ha6!;m=Iac22HiGl>6Wd(9+{6()#Akzo2MlkM!Y`tDuYLW
z=FZ_zfUbBi#3Z`AWtze1%=dg2GQDV&(bVSreTKlZV#Q*`Hi_-rksblS9Q~iiQS)Zg
z05L%KDOl@Pg+%ZF{et4muK!MPT<vb_wnJLa#@Nkz{s=c9YD9M$Hf#R6Kb_;j{b6`P
z)@+cV$&9{0!p5z$q&1-Y3pBT<ATyqh200^&7+iTNy`UrWkWem7n&h#dZyQdX*>d!+
z1z6W-LZ5@1t&;19{-62!JXv*zDPJj7u}V3xX`LM0lMFLCGe<74D7?EoaKZQJC{W#=
zc1F+l&o<eq;)#_>_}~9TV3C74h`YStry|JFLE3o<tg}9=BT<_xiK$-GECmc;V&#)S
zjIbubXoX<sxFiXsO~gLKh=-B>$f-cBWFv;f4KC9@NJ5<N2i0i0&)7Ayvk|sl19NhN
zV|3mOB!|4rQGrel!BtIE6N!yH{Lp;$vdus>bw}-QNfraRP`7<s9FYD~LZJMGqbr_;
zs`c3GwV)$QeEn_SmK|O>fI<3tIMR34>_uI9@xwF1)ZZ7_t4h~n4i7=HrqO8?5~gai
z&O&RoRNvCb$d*&{sU3d^D{mpl>i+Qiwkpm7EE1hnSFGJEDNi8S6Cu2>$Z3R4ve$G_
zu(@C4ab4wjMf5;iQ70S9P`CKCDc8wk8eRpdz-H;hp{meGs#U!IEm0M5qnY^x({)Q*
z0=!yD@qD^GL$kit`?cXRT~=SJyLuj-fk{TmvqIdmg=3-yPm5a_yiLkWBr?6z)!eSD
zVnfu(EyIc%(gyNtHptXC1X(W5Q?5s7oU|c_ej#clr4GSyy?5t51K-B}O+3ZE-@F>$
zyv2j+MyyoAxf*Q^wobDPp0N(@J@~fjP|q{9z)Mli>tW^_FeyVe)}Oa&|8d{859t59
zZ>unD-c64%@&;mIXev~Z2M>{(SQoq&(V~d$OC1_79NT`zsfgEkl7;L>&&9-5JvH?6
zE(a{epA548bykB;1q34pL&%;&H5>GrHu|6wp_SXx0uj9n$Sdu&Li{^O!h;V)aEW7m
zn<)_MT!V)xSYp;!5h~Ts*h{4j7ivJQ61L_1oM4{i8L2jn9(Yfyp;tv2zIfpA6B(}x
zfls|?CqbP#36j&sFm>1I>}NrK6`|YF`qGjIIR4Y8WWJ2~r(V^qhN{ru>3ol2daVFk
zirpE8eOMQu&c>LLy-XaOi~YqvZBfTqbjX3%)Tcpgn&eJg%B|HNE|`8t=J!ENNQe`k
zTufGl0-u3_mVuW3&vuaa1O9sjeXs8z01yCR$4A>=_rU>we};T-`zXkN9smH{6afHT
z5CE}Yz#*dE$=L7hAN8Z)e7p$2Ap`*l!Gfv36W%|5VB8<=?}hZ^<u6?SpSbo%`+NDj
z^FJ^^H+ktlEQ9~CVGrvs`^4|qNBt;;@Abonf7lT52L?+2)6NG+`U86}Vej?-<N5r_
z!+*yd-s?yC*b4Y>JRpTXNFP2S{0`LL`9%L47yl6Y%V!{=f1EG>8%O+CT>8&GeCXT!
z#{Y=TKh9VCgYe-C`foh&{r$i7Q7i)39|XwtgZRPY|1Wu_zj@04yPo)8dQtzSUc-OM
z+xRc-Lj0cJ|Chh?|0PfTH}60B`;mwH-#m=>_y5SF@}GJ7h;Qa^Jo?>_f6K%B*aHp*
z{Db(R!w>u+008iJI{W{nPRReEL;oB9zxp%rA9OzYd;S~$yYY?ihqC|xvL8<UV|+^d
z!(aN}IOV_MMt{cbLtp+k&i${r^Pf2Wdz;N~-05HOkNIr*PmQ?$pz&d&<~L6DuNubx
zv@!Ev*tq}ALHkz?#eenz{o?}qULHR3_g5T%uYo=o#P3ZVzt3O)-^R!6KgY-C-#Y)>
z`1tU}=QsX$`N;f@%fEB~(GMW0KRWtxe#dY8@A9$n8~?j}0Dyf60|5M|d=UTU{BIf`
zeGvYQ|6M-5{1-MteslgVABDg1zsraGZ~Xtt$N6vG-{k}0_j6OEA3^ym@Bgx<(f`I3
z{}l(4`A0tFf8&3b51Zfk{}xO9cg?8Z_<zbr&41AN$j8iY{O|H{{a@HX|5)VT3+l(q
zUvc<znfznzXa9}=T|PE`+xSoUz<-za`K=@Rv0nUT=i?g7{pTF|;N<@12>eeD+dt>o
zz;6!wJO3X#_WzvE`@eCqf5m|W{~&zK=l{psdB8_id~bhAXadp{MMVrz6zRPPN+_XA
zZz`CC5FnTULa5S3MT(+W5D~FqR}{OVsQ9xhDvA|R><z@;-#ats+<o@hon#}v|NVR*
z<U7wjbLPy<nYnXs!YV0mkZ3;Fjr!7DHcq+h%V|-~P|;k7b(tKuAnMO7(Nsb^spYH@
z(}!!M+~;qGl$Yf1ZqZ%n@g*(bWh<G&NMtnnV)|f6G`<Z)Qw24t6+(Y|Nx9G8eM$Ih
z+PzBbv@j0oc!0HGla%+s@{}&&{M#<&y<*Cv`?Gyg-Z-WmCxq>&UfEn2i9B!q()v@j
zS^JFx^pITtU~s)%0#tMA#i<vSU0H5L`E!FG{fNdbTkQGTvrx)??b#sZzV>XD@_sSx
z=^3_Xx0HVp)1D8*_AHh1WZTociZK+4_}Vj2%6;vbBIUmJtderOkJi|x_6^&!Ny<Mn
zPH1_`M`3$LN_n#Fi5zSU$$gO88(_`ZJeMZrzWsbg3D;+raQ(s(uHR6?^;@O<eA5W^
zKV^|^fSFIbrTlm-&xy7#Qq>ehB8BF!@cIei^=VS>ZNHS)#p_Rt+Rv8q94t>67201Y
z<#{pX*<twxDff++tx`TD=KB8O^}D6KHI`3~`WKO(2lb8TG%3FquTQx%w4Wj6x5t!k
z49l~n+!vpPC6sTF@|tMhZ8z-r+$!b1{@GnZd8E2A9EteGPnwkb#!rTn7Z@Yq_!%E<
zzm)s@TPWqe_-v4J-}u=o<-YN=TgrXoCt@9oM112XP0D@aCqv3xVEbXc%9e89_*p3B
zzVWj`%6;+KT0;45Dff+^h%JajtW5h4&MVSND9?~`-}uRva^Lt_DCH9{ekr-(_}NfG
z{adBn7oXiy?i)XmLrleyh;RI)Nx5(QWJtMh{A5eHZ~QEj@)pJkjX#W^4N`tDmP7v8
zD&@ZMvs=o2@zDc7UwPW0rs7D%hEe^4{F5Q&zVVY?Lis`|PmkHZ938Ir8%nr-tCT15
zKP~Wkx0LTPjZpv1UVMigVm61Ctz`;>^HTGdYUJL)tf9x1P~Kh2>&3L8PS}RAQtpe<
z5-In!;YKMht_{zL#@B`~r2Oa@A8Us`R<t*I{yfk?%6&fel5(Gq<{s-u@u5@TL(JaU
z+-tP7uGq7cI%2DLB3);vGyU?I=mrJ<j`o{NUZ%dWQvOULJC8=|TOqpciF7ALb@z#`
zZ(y7Kms=3)|NEjF7M#7r=z0b1>{TwzZFB8mhkx9yE1~=`DPI@U{wqWK?@M{Bpj}~n
zQk&WanfNS`@{<#_yH&K^cZjZUB3&1!GyT!8ws9m9@%6`#VrN?-JC8)`t0Q*0CDL_>
z>bi@rr2Z%nT}k~>#U2Xz`=fCQ<^805jR``SM^=aZQ6S~bf_8=FsSRy|On)3I<tHU-
zck^hwJBiMmnZ%4QGmqrl#PrAeq8kwWJFG9IkM+m)zmz|a$j%+n`tA^2N%MAx=t}C3
zKSkF*(fnu>ogeFtG>%6iF=rPkOTu_QCgp97NaKCBEw*|6eJS6I<tbl9+ppILXX0^j
zY@BL!X~DI}$wSH2XveG}7e?#qC7SN2k@FrC>wQvJapyIr&sK?@VKHN5pzRD(zDdg4
zV?A)rwOz_T!*aPlHh#>K@^*>Z+$7rO+NQGLQ(T)niN@FFPo%Dr+Pp;UoEp>SUSXSW
zl=4=_A?@c$(b#X3@~5#p<?*ne3#7btqBb{-wz-OZP+5GNn~TQR=C`G;lG;2=?3^0o
zvwa+A$L<;__w5-TlJb2q*MDu>Y+QI-$`h^Eru<haPs8iaa4|LGWP_BOeOX!5m>lD_
z4c5;LTR|l9Kh&f=8Tyee<(I~kuMEo<N_nCj)i}7Ofs`kEp0i!_{bTBjKEK*0<-WL9
zKgL`boS~b)bgZSk8v5H@%B>kKhx3ksQf|L!`RUQP{wnpGeOO#v4{<ry^v@cx^Gu8%
zTSGq{lJZqC<;%nJx21ewOu2h*Wa7F|%9D+2gEV6(66tOJ(sreE59{ldW(xfK#|de+
zIP!@35?+6Qc>Pi-_r>)VDYw&0uXm5l?Vf9(l-EcUS9eTp$Ll`PJsAl;YA5Bf(2wf%
zOo9JAq`8!vH7<I64|~0d>)UCjAQDM7t_#Ip3v-eBgZF<@{w0>Dd=mP*wS?<;OZlFd
z>vx6MN779};`7|JfTu}$qTFh(^L@$$1!W`O|C6XZHDaH7#1*ARs+!B<KB?hb8L>sF
zk(wU;p&nk#!w>gxeH(-8J<_8;%ERqlSFDlXyVOWsk3P-A?Ok#LJI8wT^*#J}4>zk;
z{3kWi(8KLhl(-90BTYT}<{sYC!&`fJTMuvV;buo2|4EH>^l)=W6#q$$oZ{j7Hcsp{
zsgbT8y}7fA|D;ATJ-nxfn>*zAPin;6sl|U%BX)-sSCASR;L+QsFbVX7J^CRYZg;Z@
z?2Pc}M|$|_9zM#$&-CzY4<F;<V?8|2!^eC01P`C+;RPOE=;4z+{A>@O=Hb&le1?b5
z^6)txKG(zNd-y^RU+m#aJp6nQU+Uq@JbZ<RU*zEzd$_)J7dtglBbRvet3CX355LmG
z*Le6<9=_JY*LnDQ58vS7*LnE$9)5#|-{j#pd-$y$ew&Bi?%{WM_?;epmxu54@OM1?
zJrDoD!*_Z3ZV&(1!$0xx&piAK5C77`zw+>JJp4Nk-{;}`J^Tj`|Ix#L^6+0g{5KE(
z!^8jd@V`Agc-=d}CpD7d;blF%yoXotaD9t6w(?+~@6lKB@TwkO-NS2mcufyK#KUWO
z_~9OYgohvL;dMN`u7{_2c)Eul=i&7|{CE#<;NcBDys?Kj_3&mMu5Wkq_-WzMxAO4T
z9^S^o+j)2g5AW#VCwurQ9^To*yLfmv56|@Q9v<G)!+U#pUk^Xk!~1*qKo1}6;X^%q
zxQFXo|2%$9_vp{?@X;Qg<>5IVKE}hxdiXdGpWxvWJ-oofCwcf}4?o+(r+N5v51--T
zvpjr`htKu!`5wN&!xwt^Vh>;9;pcn!QV(C|;VV3RrH5ba;g@*$Y7f8M!>{!4t2}(I
zhp+SS^&Y;#!>{-78$J9c58vqFH+%Rk9)7Eb-|pdedidQQzRAPy_3+IeexHZm@8J)4
z_=6t)u!leD;afcXaSz|>;ZJ(_Qy%`bhi~)nXFU8_4}adnU-a;oJp2_8-|peBd-x6y
zf6K$)_V5op{6i1_*uy{Z@XtK_^Eh6`F6r^NJ54Q*lSl0HuHa;yKSdVUCvGuC*V^xb
z7ZK?5r2YONqQP@~OXP<DptOT^u`&?%Pj}+yT7iZ4SiQWQ4F&E_TwYoRexhxvyvz&S
z?R=^OasPBHwSCGNQ+AQHBQHfliOT@;vLNtXRxdBn0dHhOEH88cA8)z500sO$%jG2q
z;Cn2W7X^U-ZMl8g2Q>IOOWTF=a2iUwSS}A&f#+K;4?BTBV0ju4_s{*7*Nfww?GULS
z$0u2C-)@a5yU_9zVwm~nM#~$-@s}(=F^>OedBZr~rMy9n;`ltv&6CL3&kL5@Hz;BX
zzP8-HO%lVaR50J39K*~vO)Q@r$46VfFpjUZ{E|4n#qy1De3#`n$ML@`zax&<t!U5#
zar|`4AByAWSpIMvUu(IW^;r0p<xeBB|Nh1DZE^fCn=)RC<AW{V9><F;-x<fRuzXh>
ze<<MT@SId<!n*;F&jLZd3V6N97MpF1vF2j2Mv%f1*=c2Y^-zDj=!XS7k^NCtAAJt1
z{>=CA4VKpm?cXByw*|aj$`@fmx8V)Sb{igfG}NpAWr9?j$e#)UPme^OhmI2atv&h|
z1N({WbhCEi{Ty$3?a-fPV&D9KRO#VQ@4MecV2ZX_epIL*F8U7xo~Yi>Jo<{k5|R$j
zi?v@GTAmi#?<MvJ1w4`c5muib>UD)!;L)Gw;mZSF6Q1LrC-vUt(cc&F^ppl+z50aX
zFR`Q7>(>*4rP0{0Bv%X-``N<J6t4QE0Z&h99B2PE(eELBBv@jNeZ9k0`=<zhOh%&G
z9~bcSl;&~v?-qR*yIw^is^2C2f5O#%onQ%1Pl-N%mscSpeFI)E<>Ao&25IkXkNy_R
z<Ky|gwew({owQ&uq^CrmoA(#{9W9SOAMYeQ*YfCdaOImU?;6^dS9&AgTONI`{hP!u
zBN$-mDbeTJ=I4RUXPM<0p`95HM|N7?F^>OZdHawz6#bFGRwg|q`u>2%v$y39L%s4@
z0k4;Gf5<n8osAy-o0i9qtGdBfsb0$FI6J2XJUu1){C%L<pI~|PIlIPlmF3ar>B>K_
zd_-tp<6Jk`ilwKF47tX+(DLZ>agFnXmJbW{8t1aX)-63{U>t93dGtL2jdM@SqwgVT
zJZD%Qecwa*O#!c$;&!<v1REp{Z+P@6hZ%q3=U3l=*GsuO^i%E3vHI+g4;K5ETONI0
zukqYsdGxuw@=8Hq(^CpUJAur8`dS`+&aQD@YkBlJyT<tw%O{3*W{8~@wT=DgdjiT&
zvwTdb*Eknh9(|ud<9UPS@#Fk;%cJkf=(<oQxG>RtuM_ZKs>XfNtv-H!o$S$fxBB?J
zVcv01Pl=zumsuX4Pd>8zlrRpB#IvJ=TZQzLcz&AY@p)sT<!6U>ddR=Nvpo8qLl@y~
zgIkXDl<A?qz0^BD;ECdMvDHW4f9NTC^FDTZ%B;|iW@Pj3b9zerd^x0!;nDYYw7<Gq
z9-lWxTOL0jXIUPfPc~Q{Kd+y&JU-9V3N~!%DMLd4HU5J<e5K{_`Q%;8=Y)20<zMN+
zEm?X>^nH&DC2kWfpC9UVoxj)eg(25CzhU{}kZYVP1h;nSDe?2At>wB)kl#@i)SYK}
zeBLnc!=|Ui&&R7RkIyGhTOL2JzqUL+&$Lf7_9uk?Yn+Qbe3Rwz`Q$Ilqwlw9JTvPV
z`_cDXMoUdAEngbeTSfl$rsc~*u5td^@)aT1I5$i;_M`8&w1~LR9Lp~b^*w|?6Yxay
z=nbo173y`rTK8CEKYo67wp@3Mkw{~?a;)X6Lp#q)z2{nfdB}Aqbid_ShFtwGcbutr
zO~}>%fdNnC|Jhc5Rj610AG17u+<svB+ECw5{*_YS)VnU^pNRkUEMFgT^?!)v8$z!B
z-(Y$4{TcQDJIk*R_3CGbAmOB^#P|E@mfsNSHG?d$Jo;YEXX592%Wn?#>gRULqwm!O
z+YkHMYx!-VzJ~B>Cm4UC@71WjspWUX>HAwAeXmCKg_cL(t5N$a170uXiO^24T-wiL
zR=+dk=L`SF@^?ZWxNSdm8W=y{3wfdN0hWIda;<l{<-0;2q%Zq<+49{X&k<hrL}UNs
zkmm^>X!$20?<M>)%cJkx3=#gm<zIyQ*23!t8;tan==(N0ehMuAD%9UA`UfrlCgisZ
zH%CtCDbe?Bv|XJn-xunY&$4`f$b;>){XA&-4<XmM{bG6aeH-QN8k>H6D%5K~<^?=W
zY~q($R{u<#{^o$Er~DLh?f0FQ{}OWT_X<sn{<n}9NF^s({zu5w&l#5g8FG!oLze#?
z@*J`Ao8^%d^<DeDV^dRaO31a}7g%04<l67gT3$Zn+V9ny89Nn1uKhm3@`@qXe!t%G
z=zBZ2i(_9~UM19PyH03s>{pHBxt3QCx%T_@mPg;)(YSqVdCgF-JUwu@UdnS}+_c{Z
zTK-}jUl8#0ltV&0+P`;OUMu9<zaLs2ea~ltw6|tUW9NuaUqg6*%cJl4XdG5q9(~V8
z`}Z}=>xOo;e-CM8?5BlX`*(!p=^@wtz1H&MLazP$h2_!re1hiKPqRP}oHK;_dxg)j
zyg|sdf1kEI`ks%r>mSP-hkE55+Zg*zLtazuTONJSN8|R0<;_FA^4|kqFXffEer(V-
z;E~tjcyG&hguJ@cJ2Bw;Z$b9UYNJniGSmm@#eSZ$d|Sx%{%fD*?}mP=%?j;|oo7S6
z+G%U~3n5oKV=aF<<f>n7`Sy^j{z=0lZ-hM9PTSAN0aqUc*)J7?8<u*Jx8n3C20T3_
zeqB4w^62|i>2l>&mbVJqtNrqo<<a-4wBOrzF!tMo`d#AGJj<i+Q}q<SKH!P`zrpI`
z^Y9y%N8humCw?AslBqZPo|XDJ*78$Af7H)=EswrurGEZmd6!VHe%9`2?8oPgUY1AS
zzdBm{S!#Lo{VVn79m{)!_SK&gIvM*tL$3Z5SRQ@<s*~8?XnFMgE4^d<#`5U<SA!(Z
zjZZfA`-k>*<r`=Dz>s$r``23@eb37LY`pn=VfpY-ukktP6l4GNkgs#{$cdK6_j@19
zqwiU@l6ogw-XXN3_Am1AJ1vjCm!&5NpIaV%FH7&7n{+mQ=7jb&K82Q#3AxVvn=Kz3
zay`M^W4WFVM<N=Z6Elqc==)dde;>;yg?83Rd?s2RKi-yG9)16+nZ#$4<<a-A^n~Rr
z%iUAmNbu3~jpkj9Khwi{2bjX(GsW^5A%8&Z-)4FA{VN@BpIIJ#&&vF4zWFrnYV6Ms
z?Of<^q@U%{_pE}nX+KLXUl{853ct<r#UXE->I%wrGxnE+e6{F@2Ru>UIMeC}hx)#v
zU+dv-S-v#X>-}uA?xx=OaX!%UWuabAI;LChp0=ARwcjuE@XeM--|q_2sr~G=Jo<ju
zXTob_8h@hicbT8hH=hE_qwjZVe70CVF7#95@SBIX>0#_&9_lp?7g-)Zp6|B&%22N-
zP&+Iy2)V}L2M@0q2+~uo3iZKu#eVu*9({l8Y2i~WkG?<FTH^4c<?BN`8izW;#wk5z
zPRKP5BR%{w%dZdh8i#K!j~}<ydK>#UhWb;*&sLV-9P+xt&#?TKkf#ZsY5B&G?-Rb+
z^5}bOx{iEkdGviVU9VI77=NPgoBdDhoM3tMeX~o2_q06vzM1BSvn)S9^d}gW_H(=C
zn?kPl^(jGM(^KNd?Qxdh8|wABQZLKz54px?iskNY6I0<auG+{7%cJkD?GXN)<(or0
z8lN96e=y{_F4yj7{Cqg%&xoB)mPg-DTP1vy<<a-k1`1zj`RdS)#%HVLkB402b9gW?
z(o^Eca|g?}hWeme?Ps**(f89dKId7!E!5W${dJZ<74k=fe_;8OA=mgE6m&#-O7wlU
z8j}B;SpICNe^TrWvOM}e+xf!JwmkYiTM%~px!m#%p&gCSo0h*6a*a>pVBn>vyb|&j
zV&_!Lw}<>o;ZrStJ>;riZF%%Pw>_eN$nv-1^zT?6ea}tv%-;d8m-2q7KSb<A@~2K6
zd1}9=xl^V@vQF>cD)_c#{^S<zdiTgL$QzuOGqzh!K|$A?+_Sp3$(&KVq8lr^v5i16
zuy1aRm4ur1S-l5j_2}I%vv?`H)T(!H+Zf|^-qhZ?{f9KqYTr9(UDupxd6}8)U+Zo`
zk!TC26eQ9QG$s-RBXbOTM)ekzvfc#xe^qZ`DeFz3|5x>LoUvP4=T4rQ*LGUb)ci@~
zd*{Y<0Tsnv)h1`^)STJ9O{1a)Vtdh=@aX*ZvdjQa(D^NKu(W7Cq)SoY_L%8K|6=Ii
z)&Hp@Xv{RDgrSG>n0OcYyP_yF?y3YKF3L=<D~!%>FJV^%^Wgxxf@jkKbVc!wV5<^z
z1<x*&$8<%Zzbguh30-tn6eigfMi=Kr*tH3}B51?`bOndt0J@@hN8(x)O&HzU1ZgK&
zb%thX#*PWTnFqxROz*HDQU2hzqDzVNJWNZ{mnzBj4!YXgWSfNt_YFEWVMI)E?_k#A
z^@$q54aUyJl{O~aHk!pbXD369bBXHa;3ZYJ?P_XRjB_?8mRL7;L{fEQyYmx<9lcAe
zupJ{~IaHYFB-pF9G<&t4{RVXH(l2X3j~+uZhh`1!(zRcv>GGk&i`nJH?zrMNfh|hf
z1a@z36=Mqqmb6>6J{Gs*?8cSF?-g6x{bctMO{eCKYnqice%7q4DS1<;O`eofkY6-A
zYesWwZ=8k9$hgT<@+N7Q*l@;)TC^CSS7i3GL-Ob3ndS|fG&6tF*sQ^M)20{Z6@P8e
zh?2LwK{Jxv@)~nVO1ql?kIOBXJgo#5yO$Ve>D1`Bi3?HdsllE*bKs2p$T;(_;$zY-
z2&aT{+_b#Bvm)b)@(K#@n)bPYm7+Y{&Py04%`8M=f^A&vo<E3JQhWG>H71O7LZz<`
z@U>;D_(lyI+M`8V9w6K%&UR)D`0B&^l42@M)UaaYzS>G|T`M<3;m(p<$Lq)ew$4;o
ziq;u<60PHXHZKC*Trz{yN*i;&ASTb2pba7tlS?^*Y&&qq+a@zUz{`?Mg>J?yl)*{_
zF4>}R8yVe}21`{jx`f-!pe4m^H=)u*y8@0wi+0nBg1gV5Ia5vgo;<ZMr>Jy+Y;RJT
z$@~6z!VE}sOBs`kTDElwV91ob-29w^ZWD5*=HwRTP3@OI4IGON=f4OOrt?^1v3(P#
zi*A~+$V9q?0cuwonBpXl%U>l;7QP@Hg$aCNEso4YgCtJ>?<WhJ3f+vEEWySO#;vbI
z?CrEymv9sW)gQoQVdqOdS=hh<P8K%zpG}tH!-ONfxW0+g>0}8`OQ7457@#Fgmbm4x
zq{+e;grhKlFRaCpnP{@a>Hqy?VN;=-F_R^@Pl9OrI>a1g_;m><OHlm*Ocr*&)RTn`
z9N=VObN|_7DLza%(u?bxIGs+G;5-YuH;DmS!erqUzXa=Xa(Az4Z);+PVX(n*({55u
zc(*|U@oa2P^gh=Y61x#{_M%mJHcZ&ySbGVFbqO0Ls5H^^=6K*y20BveYoU`5xDlmx
zq)qPRNi*`M77fjtRn$GFD90Rz%@{Z|YhZ57sYyv&-xhIpf;IX-u@j7k&`#F0qTtzD
zR_=tevc~1)hxfoV*t)ggBgojW#%}C7Oqo7yLe`kTZf0<r)hayZOEBMf)h%HH#mRjW
zDA@GC*o$dRuwZggg1KP#LrLoV_7cvS;x`27ccO96At=q9DfZgZ&6(mGfe}fn5piQZ
zxj7Tppg23p&6$$z;GA)1hBT;>pCV>xm12tUT3f;tiIe-LNU+u6@eRu)7bTb?b{CYS
z4hKYR>PR?6ir)sH--$*ShoCf5q}XdqH${qX1V$vOM#K&6<fcemgW~KYH$_UeQ^FK6
zTkB+35i_)kn<6Eyovrhy^~*0RD#**6G&VnHQl>p(YneGTbL7yh9s>rS+GS|C|4$Tr
z-k7v(p=<hNG^;CnBr7Xt+O%NFk6A+x#IW><p6<lt8nZb}7)YJIxtTdbj9_qZ%YjeP
z$V$!-vpmyNxCHY&u$0-Nd2kd}P%t?+I26yEsBR@{VO%Obz^-6>C3i*ctemW(2~#J}
z47MO+v+PS8S(EZ+W)<X38ecS_G`{=lDz10T&ZF4gDN3eyj3~L@F{?@Py%RT!53qOG
zo-bmOtBMPLvZjg)zFE_X4Sr!V!8fAhf^YIveDM34m)K~swVo!A?oRKYsJKmTuo0i?
zPKV>mi!zJ7yePBy%L|LYybv!R+B<y6#z~etsMrk3V&1isWSpP)m85si|LkK58^1)U
ziG8w<Rr^mKn>Td!6#H0J`X;Gs%`?RC1+8wAr%#e2^yF)Aix&Fl6y{~x`@`f7#JDg#
zr(pVjVPRljd*YC^7cI@R=`ax1iy=AVf+rTGwbL@rPM2xDgQ)&zhDsORmaP-`)1zQ=
z@C>Ka9{Ej`&Zls|+R^ea2fI0vfJBqjU=LP_%)%)}voj0w3iC=o(%S@~95Q+O)Z9FL
z3YPQ`YhkV*m@_rlVZrr~spxqR&+{NrWtmOEl<8CRvS#E@Et;NV4m!X9XBXad6r1W;
zTvDow)59HFqTXPAGO3QQ2}e#6sV?r?m^_nAs*AHw+Ef>3AjXAcQe83@2KFs78xrq0
zWE=ieS4unnRQDelDn6~mwacHMN*yA<snYor4%j489k(aEHi=XhcWvoXUEJlROmzvb
zFGZ^3>rJ96Ca>{*ZLxWc#U<snIDH9ujrGaoHNGb7>Ll`7+_f=DC7HYyXQ8xtEzUrU
z3(4fQWGu-0e%`#sHvD<b{-{jycKmtmKQdH&4vA}*KN*!eM1E7H^C=v#N#r$dPk3z-
zc`feR(&e?d%S)Np5?)`5yvEm4UTYWk{wE9K-W;}q;r&}QH+#WZIb-r?v}hUpds=>0
zZb5K(msJ$p17_t<8aLSrhm`6rcxY5!@>Ue`bM$A!OxlhbNoG3=a;h`on&3B{Fw{{w
z881QY>6qBKw`dpiL9s!Pf1}*=O45B&>a+E>Q_S5(x9L--26s2+L;!A(4)}3J!n2$3
zob_Kk|Hz-^j$plsnQwqvw8wkduCs0Kk-OLgXH~&DeQ>a4PmXhnCXXvF@;uf`iahIE
z9AM-Fd&Rs~^DiP_yulJ9AJ@Lbk+<9Y#E}n<H}T9q(G4Nb!IFZ``U4GmVDG;TdhrHJ
z40>Gq5(hoz=YBcG@|0;eEziEdkvXt%Nb8t47)rXbWlNV#3MNkre&#gz3E!AQ6aD$-
zlB~37n?HV1@bYl?ym9%H@{95(Pb&V^VfMd8bLU0(E<?MN@=Ec4a$)qSCt0th?E`|J
zXz{c?=2+Z564X?qcjBbTJ3GNqeDq0IaNZ9F5=^P!QCJ`-;Za!dL^=LZ7*x_Cwm8wG
z<e48GKt&}CAinb74Is8s+5r@IebNIc?#faOAilPg1IWDFj6W-ASHzeBRFqlr0HTx|
zbG?0*8VGm*B^m;phoVCuw}c_USN^*pz*b5-1mdnwdI-c_S&AXR*A_nn;(ItZu7?x#
zO<aC#nLlmBg#4nsAyaa4^D+~^Wr_L8-sUBp2ZOVWDFuOH{!xo*nS=We$%+|aL3Yv|
zmgNVsGi;Mvke6c~Bj!(=X4<8OlZpuZ!hr*M!{$GIF*^1okhbAMOc5+$6|hfzOIiiY
zv*Xw_&z1a(RiH)eFiX7e!z@<pFpJBUr5I*G4%5+)#4rnLDrSop4zptJ$=FwX39F>x
zRqVB;dkL%fh9ot->>C}$tr7N(js$B&%=j@@iWy#J48#^EnzNiMX?TS@+?blpPs`~`
z5ycKKw%)Q7!z*}6s1(C1sObQQ7yDY8;Z^Llr5j$wHzcXyW#3tmJ#6$WF{TF#Gdl!#
z0l`lKP7QugFLtR4SBvN?*nzFgn0qF&6_gb_40x$*mv?sXz;xOq^W1w#n=JCt;{e=x
z$8E}k=1iMDW{CZrJem2SFXU$1oGHO=#MszL;n752Ss+1s6Sw}si};y^VLgc^7PlFP
zlY1E`dJ|}?2%G&c&Tr!17>WxK<{S#R-j)>Mpom>qLg%7`B1lig42mLCR&0PcCBvX7
zN@`FT2Z|dML32tR6h)aO4~nQJ`YbhOP!wfG2Srh-+I)b6qWGmKi9vxcetHH)E)I&=
z<siYJFmHDHGevHRgMt$&42s;O28D5;xIqy#r^G>#o5Y}qYN8LKVg^Mn42n|zm=0{4
z|3#)KegR2hP!wjio0=EA88bs({)$T_g|Tlah9f?v{Y52NDN4plZb?>h<E=!WW5Cmp
z;CBPolHU(lHuyR`_+5&B{^LFkfScdZth^;~)Ca#N)qaef5uhIdyfg4Iz|H?Ar1lGe
zqka}})UO4O{@e-N{0?Qc{~&PGzX%-te;+vd^Eq(zXFqV%{{<ZN#{|Ba568bPaP&ui
zKeExI{Xw8d`_q79d-Z?RF?O(j^?$Hoe{KXjX9WM&c-{{j{n-i}{n7u~fc<~VqyH5+
z`d?Xo!=<r<{aXt->fQe{?Bb06p9FgJUw;F-v5)@iZyaa;^*4gEejeCIe=Y-#{^)Py
zW&8S@ZrT28U<d7g0v!AIJK(5Kk>5vb>}Lfr*Zw^OIL4<gaE#B1z)`Qi@0k4`4tn$_
zA2{~!G~lSe066-;1~~e2190^JF5swt7&z+R1CIXe2af)vm;eMH^9Ai63>@uOw(3Zv
zVer-bPIK*-Lxr2m%<qm@o(3H4`|KP6`ium2OugoJ>#O}?qBp~+eDFtkws7N5Cg>Ld
zH@Qpo`g@#>-uy0j<=227<4{^ZbHNVQTLc{IT>u>GttOn~&<*tFcZjS1!LQ%7A8r@+
zSAWo_fgby-D{zzB)qXngA;5869tvFh%lLzO9S^1-&HrgvMeOSDYc~2ZV5h#68~r%Y
zuMlqZ<3X?gj{@^MKtBQWj{(mI{s!=gz&`_i7Vzr9zs<+gTL8Qb@Iv5bteTI}PXeyL
zAK!5EzhY|qjSuF-{2bs@K#%Jzjw_7+)Igso{%3<7jQ@1dWBg};9^;Q3<3AJh7=QD>
zK5Bb0{<DE&{O172_?wuh9gP26;28gTz%l;wfn)rUWBeC@KAHG03iOHMzYy$T{Fi_p
z<9{CLG5*Lg{>C?r561rj;28g<z%l+80>}6-1CH@u4jkjZ0yxHhC2)*Ca*Y2)pid_L
zn13)&n*V)K<CA7*UHrP)3izd<KNk39z=s3Jd3_de)Yk@%`r|wt?VJBiQT_MX?*Vqu
z|K-5ZpRB;9`I!83HQ3kxQIPphpkD`i{hx)59=ZMx28Le)`gcv@4?fI)0KOjdjhsAU
zipvLo<hJr3{r^;qoohj#DSE><03QS#<3Coo+Ak;HPX;~OpAQ`EF9VMDbswVkD~awF
z(4&34uSEM#gC6a_C0y<6KI0?Mqka8<H8?(hf*$Qx3u0(KYX30zZRAMd9RCx6qyLyU
z(Ee!9BR6Zh`561S-kG(=d<;kZV&JI11UTx=ST!HEe>-s0KL8x<KLZ@~+kvD0P2f1r
zD?4{=oN*n;Ja%1ht>%F=(Hs9e13!>FhU=g&&tM)y{c+$Aa?E45f}cM72a?B3-)Vd>
zk0HlAW;CkDJcb<e*qxxqJcj&0^4MKqAM@DVz%h?uoX1N1b)F{5V`v}q7~01?hW3-m
zV`v}q7~01?hW3-mV`v}q7~01?hW4ukF*F~IPog}A_A!s4eavHMAM+UUWbzp5lgVSK
zPbQC{KAAj*`UA;hxF5zmwh6{_n(Y;rhySZQhWklhp20kZddy?UF^@e2{`>47NFI9x
z>|-87j(O}+&|@A$j(O}c&|@A$ejs^l3)sgz_Be3NV;JXT@)+93Jcjl$kD>i!@)+93
zJcjl$kD>i!@)+93Jcjl$kD>i!@)+93Jcjl$kD>k1K_8h<+29ZIWbzp5lgVSKPbQC{
zKAAj*`qJjH6Kxb+9G-x2o8jT3fNuqTK5)D*)A6b6k>;JNM6di4`Thpt4WyrL2m4P#
zy&a|8^dsK)9Z0*L0{h9ftCRTgU$v{Pr(GEkhi%|z7vST84+U=a@VXD21pI%%uLX|!
z&A=yv{xjgH{|7kgD+Sk@kLfSGU#JUwJ=n*7d=_|yF%o=?9ppGZp9B3lR_*jSKGy+%
z9`rm8{|w5^=U(?E++XRqeT=w{+ik*)pEzzuiao=9;}+YM0d|mMdtU(m@q8QGI|S@t
zdrudx^HKljJ{|wcwY}3wukFP+V|!CQ?acsxUIPES0G|OI$Meg;aXh~Q9LF>2aXill
zJ&tG8<9J5>fsE%@p<avwa_nD|+jaipyg+?2c3uNJb0N++PIUiZ#wU)G8%3|<VMVF~
z8c*dqPPUL<$H_CojeQ&^g9G2p$8ek%tt^e7zc?Py&oe}?{){pPgU>|wC2sx}5m!Gk
zKImsTkDnQ0$5i(Q#JLOb^MIrOJAmVOeiJy3XVh!_O})4u!10WF9M7mfknxP;=M`u#
z^7NoB=EMCP{CDj3!yNA~-hw#bxh2{^5A5s&eemC-hW1g9@6U_}{imSEb*&fpkL%j$
zz;WD~X9wnE+J*Wxz)^n#@SefH6U}$@|6^-CeqQ_z9Op$>u#fd76aTltpG9CF{kanO
zJD|T6IQo-JzhM5ye!={V{et;9nSMe2f7LJOC&uS5PaJw2K)<{Tab67evEDVn-vj+^
zz)RaNn8&cam}jtGFwZ2@FQ_kVzf_cVnXtYuu{EeV@DG6NIf+5LfTw}}L*V+ppFz8U
zHwXPkz}o}=7<dNoJ-~Yb{{;9z;GY5?3H&qQ*}y*sJ^}a_z^4HJ68J3OUjbhT{A=J#
zfqw&h74UC?uL1rY@QT3q0#5_J4|oF)$9_RQ_6zb1kDXo~j{SmmuwRg8d+bc`aO@Yf
zgZ+Yhp~ucr566B%JJ>JCD}tTxA^z2Y?+0ER_z%F-fd2@*0dPG7G^jc7pF!Uq_%FaS
zfd2}-7x3SJ4+Q=@@R7j(0G<t8?-31}0Q@h|PXYcn@L9nB0lpBp-L%U0OM#a$n_T&<
zlCQ=@3h*_+Q-N0mUKV&7aP0R69*+Hjdh8eE86G>mJRJK4?O?wk&-U1v;NjRWXb1ZR
z`9hDKr5=v`f_AW9kXHmd<)B}x11}G}Ht-6-(|}h5-T?SPz?%cF1iU?PeV5pv4B%Bj
z-wXJ`zy|`a3VbB+YQVFBR|h@;cn#oFfY$^*3-}?x7Xm*N_)_5dj<i9mfFB0>HNX!C
zUJ-b0;Az0I-y3*1_6zE<Uyx^b?DX<*>=(3y{enE(V`qYgW51vs>=)z<J$9CQIQ9$L
z!G1wr5$qfR{Zbuxf5^kNfe!$l27Dm!2EYdc$9j*1deIL0iFS~S`G_%nRA5K_M*DTZ
zzLpz3?xT{ibF{}!UEs;sIR^CT53W1O*h%x)DXl;CJa%xNCgV@K$4+VeIo4wb#|ip#
zT%gxDV!zi1JNllKLHHgfo~PkCKsTwtoL88$3q5}r0(=GVT;O=WHqFBq0KW+A917gr
zmubCe!11}cp6?kyPY4>PdYz|+HvnD_>>wWu-2BXo+R^iHV+Ze-OKay$u#a|*0p1Ym
z?E*X*J)Ya3zMscVQ{Y%Ho<pLYaiDJmeoh6B=WKI;HwOJ`;CK#(@As~Ue$N6u){E~U
zV7)lruwH!M80)<W>|?z+elQL`j`M4J;C~gd+Y0Ra=GR<k?-0<>1CH}+K5%R=a-3fa
zK#%jw+?VM%PlI}Ke&P6U3jK(2Xa>9<*g=l-t2yY=KAsbn)(*}uw1e}j1=QOG{7goV
z^9%JjzmVhn!g_Ijp&sW~OYrmma(-dG|CjR%<ACD|InJ+f!MH8W{3;CeI?i!^O#+Vd
z3-bfcFXTACrhpxsU*^6{>-Ehqe9x*i=rIm$fY*a@iyY@yThQbD!aP}8J2=144$iN3
zP;VFTGZ{V3FVy4wLXPtb>&5wndYoU^LVx{V&M&O@|8jm|9B^DAUk?4%9{N$=?=t(J
z4!}PF{Yk+01MdjDTo7~fF?KouKLq&6z%z_E_!zx;$4}=Gjziq1O|fdH?+p42fusI<
z;J6Re=hUWN+{f+!J?;}SfOmm<k>hhijB|I;zX^8C&roZ7_W<t!{CnU%ftQ7N_5xlL
zcyHk7XCL4gXI!r_&V50TaYp_1;3w_}FwVGdNhZ#xLcJG&{r<pT13m!whrkB{{}%Wl
z;P%EkC^O?>Fz~7n&mq7wzz)uLj3?%2jOS3WgYiWD^<W?KKgJW+DPKJMgPmbeufDft
z+B+QhCeV)n{w#2O-uDJ@oJV^-yavP*_4u9u@+P3i=i@Db<2>yM^^OGp?*e`r@SVUh
z4&MRC_WlkW{cHyQAU_E>`fv8$=40ZI{u_<?aKD@h9Q~OH9P2$tc+gb)^JTTmS+kMz
zL67gNn4cvvA5$;dc>p;2|0r<u|8;96-v2LwqyIkv$9fxredPFlFZzRVMt^F7eSCgh
z-^1Gi$9lT}$9nq!$MJRtaGZBIevqFF?L}TK)fqDVVt$8)t`}{A<GAe&9OFC;IJRpB
zaI~`uIOc(yfusG+z|sE8z(;}q?*K>rr@$WyVxsL`X#x;@cwXELJjNg3Xn&W7@AdGA
z%o|gTc4`1eKkER;ancAl+Gz_M^?iZkc+N0E2tLN2Ga;TC1_mF)F%BnM>iDG)&sRPC
zL>Pycfqo$9bD-X}z{dc;2Y4><=YYQq_Hq514}2f!k>frG`LW<X@}|Hs&aHs2hk9`x
z84LbnyKo(O2mHi1p#Rw3KS7Uvwg7*ScLI+7cL9$6<NHPE&uGx2Kl#A1-Z{d95X7t_
zCYPFz8E^O=?`^=*&i%mA|3`qM|G2M1|G%)cx_Z(7AAw`NIG&NWhI-MT4#3eLTu1Qz
zwE9pla$HBS-Y%fWdT|}W@rL^roOgeN9pt#aBd-m4bsUW6_P{aDeSu?~M*zom%><5i
zE&+~t;1=L$|32Vo{}tfl!T)!Gqy97Cw+4NhXdOX6aUDT_Hk$z+e9RZLkLw6>Tt|@O
zI)WV65%e>ebp-7k$U2e_@ysxd4L+v57>ClXBlTe(`PPvFs2ATOEd-9^e-iL#te4JD
zyzj=mf%ivv--o;!_=!Bt!y5s|`P&@$`rzL>-f$h64F2B@{^L4=>mbJAYtUnRe*upE
zHwJ%@w*!v;<NAXBw+B7?GXOaHa|Up%w?KFhf|zw=Cg}0!o7MqGJ2wMI|L*{f{=We6
zLH|Djj{f_`3ErQgKTV)s^v8F9itEVu;94CgxQ-ylbp-3}0{&yYxQ^g>!}}4OceoEh
zz8Kntydvb)vtc~f2aa*Z^#$YH9rW0)9N=i@9N?G-E(MPE*8@lU4*{PF{%-@0`t884
zg8rHU>jL_@3^@981#q<gq=&!m;d?y%N8sq^KfrOERE7Hs^ydiRsBa1!=hqw<hj@Q+
zDe&hZZY_WpLHvgT&jy|c{5-IO=Vtia_I}V$2RnFf_Ac0Y)1&_w_zbXv`F1Ao!vmY<
zW5PWPcpu=if#W`W4)A=?uLM8m1IKomcQ(w&)Qf&z1N<DYe=l&fgZprdkBP1M82jk|
zcfisA-+`n5wF4i_$Jm(*{xkuO^_nvf^D%nlX6~C0^YekDpH~4#KW_q#em(>o$Kf-;
zQU8{Qf9~PGdiX(*XVCtkz;Qk{0FLt!^FN+TWVx`}xZ!>bpX==i`cBuQlR%HW3vfJ-
z!ue}{r>okT1p4{FuLX|!&A`$B&w!);AK<931mh6nRu?$N&9}eBdNIG@{TJr9zF;5Y
zJRAH(JC^`QJD4XILfkOUX934NiT9zHC-FJ^eNgWru=5!3w}ZB5KkfjI`j3Dw20K3k
zKNt965T7N$djmfY_$c6Jj;lWtfScT?+`LO;J|;h)pUZ%wpJoi0kI`QM_BR7ZJ9zGm
z@p&Kg=>J~e=>H$U(f=a?AI!)2vlRSk3LNV-XSU{J^vKQL&wQAhHY!Iy*8)dBHv&gL
z9|n%&@PEKjzth9N@bKR}yb|O+v|kH2&UgHM%j<)f>o~zYc`NW_^5n~)$2^I=iwm=j
z|G1znS})Gu3xQ*vTm~HTB<e9wqW_q$P>*>M_5W3#+ym{!{PqX%=OJ$0f`6Nj8K0OZ
z$6M+++QEFd0^)=5>;@e3;drPQ^C7+$aSznH66`z-{4KEa8gSI_0)7$L`2qOF!129^
zRlxE5_7dQyLEJ6{o(CNF^K*cspBDf}Kd%P98tiWZj&>dbj`1;Tjro}VMgPA6j{g4&
z9Q{8m@WFiSI01jmJEF?5Uh|AT5jXd+iMUyVl%t<l0!Ke@0FHh>0365R)4)-`!^1!I
z@Si=r0^~ikUlTay!{dSb@*&<oCX)~GJ{R*L@-8mSwjc4_0O#-JK^rwsVm`bAIOapt
zV?IRxF(0BH^C9X>n-5z_yG-|#5B}(L_EVs}TY|Bz?HT|a?`Ly?o3W>Qd_Mv2M?L{P
z-Y@**;rM<Fj)y~G-r;z_{V?8tWrO`S;3u8~%m9w(SEx_s_W<Di#ivj&?*H-U%}p-S
zxSbB|!u193mr=jQqrU+-#x0qCzYF}qexCsx``z5Ds{i;N1@5mtggD^-2cI({$MqNe
zuLkY%_50i4C-%G9E2^K^@3^mS4}PLPnSRIp681apXRzOKKa)(qqyGO#zvKI0*ze;Z
zp4jhKLp=Wnal>`w4d9sPF%KZ$3wrGL)Fk>H*VAmUvkv^ke#iYoJC8n@e#dnI`yKN(
z_B-b7WcnTTrS10y&@RklnBQ=}IvVu2@BJ7!<|VX`^Q8^w(f%mlX#aiSKKs~@$ATX1
z<2eA@5xHGXjtj;^bpaLSs~KL`1YAGLD+NH;TvK+i2n<gNE}AgLfttW|tQvF}aa~`J
z1a6#KD&zZj;AMmv)Cjn#SI;Rr5MLn)ER%SS4CMaAFRbgp>BOg;=fGIvKgj@@N_^T;
z4$LH8TLOJ9@wF2ixP<ulA_uM@-bw;<J@LnvI`9bbHr*W1yrliL;~d9#kbZ}BpuP{I
z`Z|&rbY3gZNpl9iCp#m{Iq(<pzA{b@l0H>C`;T_QTEtgN!0Hjd_#~%qLj27cj&~q_
zVN=I5i9aPjxG;!#zI33T^Q)itXE{6hr0-GS_*~+b$OP5*I@He3GEP>Le(w-xX9Mxu
zWkYu-@eAiW{UgL{c69t%;-e38d<XFic|lu$2afvra4)CV=LO1Nm$>OUnDYIy@vkU3
zM0puW7`2GsDC0k!_+jN;z0HWXY2tV%;vZCXyf^WciyR+Lys?a*T;j)dcKRvAZ>;9H
z*}IyLwrih^H*@BL{61-y-iNAwRAr~Tk@Q_<LwXPK&*TQ{apLV{Uc5;BHpyde6aR6H
zt5@$&)t}!6I=-Luw@JPK5KlST=?_kIU)4^YB+es<H;{Z)kNDa{-SwHo&oBoC!Dj&R
zO?4cfPJG*N$LA7XAPda7#9#00^vj6X@9DU{@1*UjJks%7N&js{#~&pAVt2>45Kj?1
zPZNKjnbSW{{BK!bUL~&2zuzQ2UF^J1e1+uUuZaIC@!3awob>O{#FsfYBYzS<v&a?b
z|NEwKyY@K8D@uPV|E0I%Rf&Hk_G=OUx`r#LOZ=I^jyEH|`eMi16W=c5qzCan3!Q!_
z@v^cWjU--8@>mgZt#=mjnUZgp6CWVoUrhY^0nVShh%cA<axd}cM>zcp#8v+q@wX>C
z{ddF%r8)i+@dqn7uJ5^NKfWyaU(ZXFA1v#XzR#xorFqWI$ub_5-*<@PXAm!t4e}V`
z{l))<#J_Fk>|8*+pXC4Bh`%TE_a5Ru%eu3Jxa!{{-ZRtH`#14p(;P1+_O!jj4s*N#
z@d3v<-i&x=SH}kvSN&<kKbCcWF7eLd-?_x!ZSCxDB(C~9iI0)~-A;VoVrOS3ab1Ug
zBK}wvr~i}q%3+QlDdSG#Hc{4>dc@bseC$ko_6g2T58{tW-WyB&bGflNi+JOn&d!Cz
zH%xc@V&Z*d9lxIVrfN=q8}T0`FTF^-;zdsXI`PR99siVgN7=7_Lp)8!!#~8Ily$wl
z%ma<{?bDq7BZ$wCen}%fe1X%qBK}J!$2$^#U-W~CPhRNsrxP!f`=%MhGt!-YKJk%f
zIlh+o%6!MKCtf6eK2H3^^PT>G#5>7-<;TR2aq`Gl#J5R4EidbU#(7hBcfrBLr^@=9
zMtr>VV*}zJiM~JaOc_7Ji02&d>YYIRcF8~Uh!2$en&rg1Nq)YHc)M}V{>{XjNuIx-
zcvm?fd7AjJKF-c-#NU!Qd`Nt`tk>TX|8=~x^9S*hrNa&~9TI%BU-qThZzI)-A1V3g
zXyWaqzgrM*B=^zni9glA+0P`dc1|OHOk=0dCY~<e7ZO)H%ZWcD`?gDo-#OaZzm~Y#
z*+Tqg84uftZ@<9Vd5yT**-LzZ+^76Xyg>S?LS<*q6q|FNZuQ;wwTbJ#s~&OP?=>T?
z`@NHi>wd2b@lUF{dPfu2dUJ^Pk^EUiT=#pkh%ayC>|e=T_Ip<oKXiuEZzit$y+?>o
zUE%aQiR*rE7x6|JPX9Y`-S3sD;>xvOu95Zo7~;C$JDzxs=(`iw{a#<<H=OV4%O|e;
zy(z>8EOGkP#C89+miXsKIQ<sls^3QZCCP7}6F)Z1+4+w6Fxj8ikbR2AP4{oLiQgxA
zxFd1ZcO{-*$JLuhT=#DU#JBWx`iqIH{tDtPXFL7F#C5;7m3Z^cPQQz|?)N?=zFhXt
zsWQ(rKDytlM0}j&)ds|Mzt@cT(kafLQ;F+-Zz%C4(%z}Wb-y=@_##=qmJ`?g-fH4c
zo$36!kGSsl9wq)!zSF-#T=#o#5-*Z{#TUeNzqgn8Xt|G0k^QO0U-x?l5r6Cq=T9Bt
zy5BpF_@(olz9aF;3mxx9{4|+gS;Td}H=g*n;{UnCb-%Zq_+9l}y*Crr{odWg56N=+
z7m4eB?+xNDCOQ3H;=14anfTxRo&F%%=W6_QzgL5J{rOJcj=1jkP9fe(_P2wG>wa$>
zaoz6~5!e0RV&b~rTSZ*=d+Ukoe(w(Ay5D<*xbF9!Bd+_sw}|V0?-Sy>-`h`I_j|t)
zze46+c{zX5e$oBRk;HYsSC9A&ZC!sgC9Zb564(7+Z{okoIyjuT+9@Kg`@M6B|0Mga
zrNq_FM&i2PyOa1~a_;vCakcX{aoz8IL|pfK`-s2P)Wxlg<a>?3?z<`x*Zp2?;(Zo6
zJI52({a!=jhaBbfJ&0?)eTdJJ`<l_jb-$NGJVo;7LgKoATSENpzRsU@#8rO-@fYVf
z{Z`_G(j0%5c=Ha9?;)=Hy|0KrH^u2IO1rgRbiY@P_~WuaX+m80d##CoQp?#NOkDSS
zrxEWR+#8tBT;jTaJD2!|lbn7dan;{Ry#8{h-%ecjdpn6wmUEWhiR=EYjO^<*ZdLj?
z`^OPieIw$B%X5VO#C88RjQGT*&i*Xos$W3-wF{m8dg8j@yOnsF+$TIsT=#pg5U(ot
zo8J)E{oW76=T3G0)R1wZant=?ZQ|<|IDK2<y5BpQcyHMcoIzaodpX1(=<4hj5!e0R
zT;dO%?ey0W*Ztm&#1B2k=^rGn`@P4B|0DN<uMyY%-rK~RHFNgACa(Lv{lxV>-ExPy
z>ooql-#eK2hq8Y@j=1jk8WZm!=O?|0>wa$_@x!J&KMIKJey@o5^~XE?D&o4|TSNSB
z*}vUKT=#pA5x-aV4Q~_I{oaSfGn_k-{ls;@_dD^28oCS84tHNQ{<_~gfq06X%bi4A
z_j?0~>wa%Eaoz8oMO^oLvx)0|?*ihw-@BZ+?)PpWuKT@vi0gju3F5lndzrZI_ueDE
zFU`gAW8(MBb$l;z-Or@fj*Y+W_bL&u+uP|5C$4rH5!d}*OX4|Wot@6a)y`<*y5Ad1
z{FEln&e_D(&c(!azjp=kC(d<tZXm99o+PgOy%&h<e(xRPi#0D1ui4MlyO(&S3657d
z!hO|wq58_iKa;##m-uhp-1R3Ae_!^ajflU{(&>8=*Zop|;urLC`U2v*Uz$dIR0F5K
zgt+dP))3E^@%8|5-7jq+{(_vN?k2ALpU;V3Tj>0$bfkO@zL@h^)z={YN_(ekO<ea&
z9f`jq^X*LHy8p=|K3ML9mJ(O}#l-KC_}oie_dgF4KSlOG?-N)39^w}abnPuK_YFD@
zb-#2l@qMx{Y(!l5OD&0iI?>r5NL=?zBZ&X6htp3duKT6A#Peo3{aWI>U%HO?#6eE~
z1aY13&k>(=n$zzjUS8JCFFgDk;`+R~tlUp%oYhW6;^WJ@dXFN$Z>8hM5wD~DLj1Nq
zPT!MwINyo)lKtuo;`_wTJmSyEdCs-OE9Sa-?;)=F?SA6D<s9i{;;Mg*_>r>j{e-yY
z!*7XeKK!0|=X~eq!Seh~`$gk(DDmIUa{89UH6L~$ezN4@5yUkgo=N<|6P*3I#5EtD
zOFUol-A3Y?-|i&7NY<n6#8tnOcv(5${++ny!!mLnqjA&srH&)6`K=N0;muup`x96F
zFyfmf{<DZ{e$#oZ{yaC+*}vYSzm@o^$xi<gam|Ns5Kq6@>Axqg`S4fb!-hEhVX`4t
zKQ$j7O}vqe*N((BA9f}Fj_fP4iEBO_PyA=OA3Tq^#_=NJnh&obevRCB+)Z5P?`Gm(
zE_ZQwk+|w#C7v((kBRGi|C+eY_r1iAl=GI#X|8^azs~oX#Md@;y5_`nzPBSjMZO<K
zT<7~J;=fmn*v}l|I^P!&e?soBZX~Yr_jclA+D7c>72>LYllb>bo&HziI^X{xUT~4q
zr%OK8c<TH;k$6Pbmwv=mKZN*Zu|I>j&i8r5pKRm&*+5+NHxsY0#OYrkuJiph;@4Mo
z`n|+;zW+>oV~*1wn(n@8e007aMZB5pD>@L@`L5>*YUi(Z&hD9{*ZH1D{DYcKe=c#I
z?<<Jwe7~CbJ;ypb_jvgI#J6NQ{maDF&JN-Wt2zBQ#8v+T@rO=y`pV*07$1itHHl}4
zzA16d18s=cmVLr#;<_&yOZ>+?SMg%v_sjk4QsPUcJy#PyUgrBP#D~cK@_yp|<o@D0
z;#=ih@=fCZh@Fp#_Z;W^-%Gqhn&Uqae?Zz>@i<qm@mGCS;%Cb_SUuvZKY@6Y5zg*O
z#3y%jyeILa<-Y7x;>VVE`fTE=A4hyqYp0)0T=ffxx0m-PE+zg;BWFk7E7$m}k@e{&
z(tml7(?3L9^^X&O>2#-mjkxOHCVtBCPX7h*eX?Kqk$4-)tC9NdI`#kbQ{DF!h&P_-
z_>sg_Uyt~An)isSK7;t<vd<Yw{Ns~cy;;Qj$atMeT%V)OCw^=zXJ;+(Ph`GaN4#8T
zr{6++l#I`9#5>Enyqow7OPrn0i5JTJO_hGr_^ZAW@uBB9JI53MUG|erh@U#e>3b93
zo9Xx<;?K%>E+oF?OsAht{OnZ6R}eo*^4?{{udnR%w-a9~`|W#)&yoA$XNa$rb>}7G
zkDcu7e@Oh(^Bw=3_z$%mPnG*KjlZ6IS0=u3oYOZZuKL!*r^|iHFyhr^y%<IOSQ#Hh
z#8rO|@d@ReKdXtWel785Mmhb1#3OPZ@;LGA7Eb>baa|8~5r1=_)BjHV=oH6O8n~|-
z=Tyl{#}YsHJf~|!{2p0f`Vqf>snZW7K0Vv<Da0Ghc6=7``f}fW74c7JIQ<6VdvhIs
zh`8#XAii1dw|5d({Vw8V8$0_y6Msa$|BLu-(qBi)K1k#Iq>Q(E#3Q|({no^n%yYaW
z@%7CeA3}Ub4ad(QK2*-HW)d%uygHwF%`VQ)6~qU~{o0MhE6aSpmw2b)&dyfiy52oY
zyyHPm|26SClE?NFZ+@85*J|j#YMiT%ao^V={{1w^I}`6E?d?JQAlaYf5kE)9VFB@8
zl4q6^uP^KSrNp0F==`~#xW?x(;%`X1z99a(jOQPTYk&Pg{8?Fds>(W3DR9G_+pE47
z@y#8apG}CXzBTba!<@b!@gd6`A42?L$unmW*YP=(_|Y;Bmk~d)le2#b@inr4yOnso
ziB7+X_}#*vBYvyorB{h}l>Ngu#DA0LK|c`Bll@Y8$txQFoI>Z%!Nm8-xNk_jlg#TD
z#AnI8>rK4=0%w09@hfEgnm}ClZ<C3iH`m#@fVl3*E+XDWzQ2vQ>hB@GNb={)#7D|~
z#}4ABNq+d6xa#*4?|*^w{~*c78vpx6r|Y)zGR>U+1k$&c{Y*3BomV=258}Fi>rZ^s
zP^Zr$e)Xx27ZU$b^86Cw*)mU85T7J=ZXo{G2xtE`;=|8&d<*fa?HqrGxZc-&L|pY>
z65l85PBodw8s{5i9X*_Q&r@8zt%(0T#PN>AFPHp0g1D}yXA-X``|}yZRX>mT3dvV`
zeyRSilKYG6NWUb{`S~#M=_?(7mbk8`ZxYw_bPw^$Rh^yhiI45$coiAH>gN%XmueH&
ze0~h^tTUXQmc&)xfq0)<PCtma>PHf<v%=}85ZCo$Ch;r9{>8*~y|{vSIT=@X5!dzN
ze&RD_e7;Ov*NYv*EB12!e?wf?iyw$r8te4cWgn;gqU*)s#0z>leM929UbG;dDfd(T
ziR*eXjCd6p&xOQwy(l6+SMuiy;<{d}Cf-!;FK#EU`Tt(xx1H+R`wDT@ze)U7iRbsk
zHUIxg{5)Als>wQ|@mKv}#J9-xO^EAy(VF<#Mb7`e#C5$GLcH1_r=Lh%*NdsdpON+Y
zLgKn!TtfV%S<e0~#C5&cM7;J=r+=2Xt{1NmH^1A<d_E!`=6~Xs$o*P5$wL}{)gMf}
zNX}bY5!dyiBk_|bIDbYE*YzTc_~#3q{v6_({}&Tqv)t*|5?B3o#IKY2_&9N0FP<UZ
zRnB=nAg=4h*Ti+b(EOqC)b*l5E9b9rT`y`8*Y%<~alJq4L|o4gyAi)h_QS)8t9~@`
z8nSPhPF(eKiC2|<*JZ@@eDZ4I^X0r{GjYvVj}ZUuA{Vc>i0k>}2gE1kJN<9OHD5(q
z$HxDOithV5#Pz)KSmJNWe!eqt)%PI2UDmHL#PxhKpZIreoj>Oh*YnAh#M6g5{jJ0`
zU)@7|w%mU`M_kV*w-X;N<NI^sdOrCb@%Lo?EhG2YI?nZcvLf;Fb)5f45!ds{V~H=5
z{by(5dfwQR_^u<J{RzZXKZW>JGT$#DuJ<8ph@aTs+22H5^$!xymH50$T=j1euX(Ps
z{{wM7pZuM8)_A9{DdR}vuji9T5`RGYuPt#spFD+lBUyj5i0k>}c;YYhasDhNuIH1h
zi1(c6^mh=~^U3>&e<k_kP2zff_&)K%DbD_n#8v+X@t!@L{t&s}(s-)=Na9NhoxUY;
zJ)i7A{1v(H7*1TzCr1<4=O0su>v}hnc$(P1n7E!#UP)Zftu_<a{rn@uryb+k`#N#G
zzt~M&*T?UO>-zX7aXoKLZSU&Q_+MDheSbW0T_2ke&l~9UgNUnsB=J{dUe6@1=ZEu&
zpWnpUzmB+`AKpUzmkLh5gZKzJ&)H2}<M}!9rVE^%--)ZfjI8Gxx19M-e*|&WrxCwO
z=2v^-dOz5i_yEaABZ%wxIg|J=r#gRT5ZC*`dBiKr{JfmF-Vd%L{<@s+-A7#S2OlNA
zQ}zvS6W9IRhs3WL;r!oET<-^eBi>&6{V;ictNo()gGUqZDf{y_#Pxo#6Y;d;oIgW}
z>;CEt;sa(l{WRjbUz$Vwg-K3-1##71Lwwf&r+=8Z-rsE{-ln0`?<B7JUBm|*?DRho
z*ZaXgiSL*5jYH&lwZ>oX2ah7&U!ME4B(D3blZfw=`89~R-VdHeyt3>!rV!Wr!CAyV
zlJkL!iR=B~6~t@SaPhg7xZdC0L;Q>kr+=Ba>fa>(!U<0Q2XVb0Ozq^#HO>#!b>AOD
zT<-@@Aij8^(|04T>s=q>`tyxrh^s!I_(wU;{`ti9esCr6ZrM(M6LGyC+)P~8yC;e3
zdiN@Ey&wF5xZV%`N_<<9^QWvl_tQ9QKG*t{U%1%m>w5I{iC@0R=}#uE_PY~*B-`mn
z5!dx1m-slzkLM8A^<pt`{khY%#C5&6j`+<Zoj(r~*Y#p6@gwFq{oBNKz4(y$sv%DQ
zCvjabQcrQ^8vi+B|1jdZUK~wae^19r#C5&sLi~iIU45q!*YzTs`24<3Ka04o7yA2I
z)&G@8I{lTT*ZjYp_+L|<{t@D;f0Fo1r#bxx#5MnaLcE<k&-;V8>Qm(YTm651nX`Wc
zaa}Lch}WFu^zDf2deNEq;L%P$oVczRXA+-X-|43l*Y#o^@$4#2e;IR`N9%~sm3{1H
z;<{cuLOf5NyS+?2%>TsGWc++jT=l;ZA1C)y$7Hy6Xus%saRTu)$yeQo>w3|b_=2OH
z-SNaV|4$;myU^*+C$9RH#3#!A$!)}Sy|{<?hy5b<^E`1~FLn~weElhLT`zthuIoja
zE)o0Dc<Oplhq%5k(SW#~?=>TSO+#n5D{<BLChpXcNDgt;Par;0`fDL^JwLpFc%5;s
zhHHsyzS>CquX;}Z6mdO2e4h9s*~ffJT=Ug8#B=5Qid|hj8h<?xtVaBw!<?=Wan-jZ
z{`PpM?@wIM4~G%&H_GYHCa&j)vx)aU!s#z3uKDU3;$;>){e8ss{O~d2jm9|r8^rbe
z@Ll5PPjmWjiR<~{kHk-3=JXZ1xvv_3JwL2Qd`e}fYeZbn16vXQOYf(Mt9}&m3UWR+
zkGP)iEg@c8&Y#y2SN#pd+sgg&qr_GJ6!Em$uDu@;*Ym^Ah<_#bQ-2fJ^TYDpW8>Uo
zxcfexxSk(2BtH6Lr|(N#&ku(XUoG*`-<PKStLKMvN#EvhXMYWGJwMz){2w{rev-JJ
z?>$GngRB?3iL3r|;`1b){}5Mw`OMgOzEI%4uS;Cd59<@ZM)FBl;(C7AoA}{Poc&S6
zb-l|a{_!HGKZm%UAD&CR*D+3iEpgq?ZzMjoq0>K3T<<SlBChM>yTo;U{DQc?f2jFS
z$4|D5lbW(0QLgLb5yaPIJ3mh*uKMo8Yt41~T;h6uIFa}$Ij2}jT+a_LBd-6?$5!Ik
z%KiRJ#5JC85Wh>-yU&QL{#)W-iJ#?qy7p<@R9}VosV6wyam4k0uo3arV!s=49Y1}D
zUs%@JA46R42lI&!YwGlii0l2}QsOC9oPGmwy&t@p_!aY=ej9PUAAFJc5f?fAF5-GW
z_$l#4XFGk0JV(;_>;2$C#IJMmNIl|uKiGiywJY5P8N_ve)suLd>~FJ(>wak*@edn2
z`-_RI{zBq|a-9Aq;(C8~2l3o2r+=Eb>R%wfwT#n$L|pF&zaW0tLZ|<SxZV#|=<Uk2
zUrrqFzSrM3qg?k_$CG}JwD)A<dOw&+e3R_oMiJNZ!?DDh4|e{XLtO6%7ZdL#=eL&=
z*ZaF`h#$Gk*?*Y0>YpV3l$;NIPF(K?_YzM#%h|8o$9>g!>iys$#BWb?x@N?6y=zPS
z%_UCXpSbFW5r0$mlT(T7{orikkIDVxCB*f9@LJ-!-rY%D*SklF>;2&K#Pxpg6XL&&
zb?w!k@2nJji|?QRLi%~KU#isCUB~(w#9wORbSDzm^`bfP_v9R-7ja!L1`vOHp0hum
zxULtIh&Pny-RBe6^<pLQgJs`#6LDQH?jXK*sPktVaa}K7B)&)T)fdEdz1T~<>$%Q;
zisW65zpfVt5zml){PDzfy=X%GL^<EfB(Cd4KjNPjIDf_x*Y)Bo;?ECr`g4hE{$ECX
zK^LdrNL=-I5`U<g(?3sK^Z$0@{i{0t=fqY29r5pvclvUty0034T`#H-Unu$iSmL@~
zG$Q_oyr0mOxULs{h~FaptN&l3`lIVbKIt#ZaDFc&uIt58;(y9M_FCe)UTh>@UFQ44
z#KZhgyn;NJ|A4saKP6uAH0OV1IoH(o>Uwbq@k3Lcz8P^{FWM1*agfswA+GuVbmFy6
zcKWHrRX>~f9P$4O;<{d3L;QbDoc;TW>w57taa}K7Bd+Vkhs1Tg_?Eb?7Zqjw*Eqja
z!}-&i_>~PDKbiO&GX6&p-*b@D=Mn#0o~KMAu6C9ZzyAzp=L+Kb`&h3fu67<JK2Gxd
zR^sg>|GY+gt*bWj0r4s`T)~&b*N=1jC*of&bv#w(fyVjIGaau;{JAQQ_mpv}`nC>7
zvWZug{p4)ojYWSc@#<w<!R^F%i+&sNy3)T}WM8TN^pZHdOMFaaXXs-O|B3j)HJrY(
zj0?42xWe&z#Mg?x9q}r%F3%^PEBmp_i9da;vwsiqZIc{-nRuNAj{ih_*Ex>=L%d9`
z<7wiTw(D1!hZ)4n^l|zj#2X#vcsB8(IgX!AeE->wUqbxRsgB=6d{;BaUnBmg#QzK8
zg@sOERn~cJSL;I^Z%DlM#g5M)KH?(BmlN;4(D9pzpDFR#Lj1vsPX7V%iN>+u^B3{o
zBtEr=yK?n^x!7qmB9>n&`?q$)?-1UN_}cT`^#h1^l{lV3{6X<!Jn^v&ot<gK7s>g_
z0^%FwoM$=liDLgs;@`D%_HQ8m-ocLFO}y+;jz3ELd71Ce67MDR;SJ*H)t#LWiJvjX
z@vn(bmT~(F@k1q^sq*|^`?2P6&Q3MrEy_856!E<>A5S3uovaJ3h*yyHx-)V8JvCE^
zcaix2CHn&P^YaSMAAMh2dD)(hFFxIURbE~4@D0RAOQL_6_>~Ra_1lTRD(lVn#0!pb
z`U<k%YP~&VJU1aeRPw+;;bvL+%bBo$k0<?pd9P&}@jK-EbBUiU`Exb#+vL392H{$-
zggNpO@IS$yJ!D7y*-N}iKX*~ZQSPg;{|DGPM!3dD?KC2;?dnKe+tru2w(AVxTJL13
zdkOI0!Jn(ij{0*mac$RDu=5+(*-3h}vxm60>j&c6uGG=asK!Uzb%=1&E>rImsk;;K
zUxk@3L&%Q$lSN$HH4E(g0(LGYz1mqvT-$XA@pEQ7V=s~YyQL2O|L0A+eujFh$o@{_
zp!FV4{2tj?w-v5-Buz%Lfd2&cXOJDWznJ)fW$vP@!Oo9h=U&pQoyUn!ko>ia?8xy_
zq=Kx6#{VC{eqG@lhepJImVDHS_)YTt8S+)_OFE342Yf%&yN>K=yKW)AskOUkE7<uS
z?Cd1H+R<|zZI{~l1MKVrJ2kW2H>y`Vb&0<(>snLd9|_MBZsM>v_@ke>+3sI#{}SOw
z|DBWAzi$!F`lp1eUbX{~uYrGSEx5l@a@<$8Q;oRJuVaYo{OT;cOkmE~*ZDO8_&2U9
z`}YE}qw&0oxX!Oz$xaQi^*Zpc!Ty(INA3SaT<4cQhb$A=_zLXQmwgS#rv-7HUxS3J
z9i3lufPV@0FCjbX=X&BgzwRck^XnC|uk-6y;9o$!)nt9<b{$1r=S3^wrd^+doj#;j
z|A!M-JCnf9XJF?%(yJZ)`B(K*=ht<l*ZK7}*#8vl>+d~MJ8HkIbdYJ+C!jw{IP2Sx
zzN%bvCh$FAXS&DEV&Xc#E+ww>>t3?2^Xom}A49$S$&R+SN}dyGyL5il5pLpO>{Jt5
znZQ31X1<IfJ8FLdah+d_z|L;4vxf9)=SJc>zqXMbX=dbG;2(nhvg6!0+FrF^gSgJG
zbmBU{x(GM%G4^$SodtXs)VrAMXuTH^*Lk78r_I>^0PJibz1n%6xZ3$hxUus-*!h+8
zYNxC;MB}6L>rmo4zxoO{_TK~hV@R*|XM+A+&|l=y-$ME-a?NYN-vK*cc<lT{ypQbv
z%1v+=oAyS6M$9k`2|nq<&9`q`;{NIYdh^^(+cg~YJ3(LQ(Ju!5TcE$nqu)sUyQADi
z&k;Yp&~g2J+uDzJ9PRj5pf~N!mG<rhZrb&Ix;T~Zz8abFbGqO(;){fj6t4AZeDaB(
z(bipXF7YjL|GOOQzbUrOmmS2_pI?CQ0DaYo?i==}g>ciZH$XqYqhCV2a~F5fYTzcG
zLyW=TqrV5seEYg3?yvuW9>>oc#C3e`0dDMf5&My|oIUgHYheFy;gtf0_FIE~JLvm*
z^x2?)74$Pb`X$75d~PJJ<MTn{IzFERZra;a+WRta9G|;{8=3J_$HU*m7fBo17Px<K
ze0mbs@tH%sOq#nsU%09F6^HEK_k!N|U)KnN&-0*v*&+M)ZqQ?YrOG@um%jx1dcxWN
z;ly=(<^ebUR26>~f&CZ3{u<DuKQ|HA@p(URWB*UF^*Y#p0qlPXdbD4Dk`o#Co(KKW
z!nwUILH``+dwcZ5iR<{BMO??{g~WAyt_5z|`=!)<EpQy4n}nNo89#M=ZYRD->{OiW
z{=w}%g1C;)R>W@|<gV{1+|>K5*fw95fZq78Yv<LV{~ze@1wHoHo1lLN^xt^&zY^E|
zTLn2dGJYC6Rm4^^;M>4{58)i2A;fQQ;w~CXeAzt5rvo=}cueY;1KhOthI3uPa^m`4
z#X90w)^++ji9g%R@yCg;m38@5;_DkYeahMHE4Q~g@kxE0uC{O!&!-)-e`f%H3it@J
zqwDop;xlC4PA9JCbr*yEC&B(k(yRT=#MRC=;^)i#+ndC1KgLzESGZ~KR;ahUJZIpz
z9VOi8p8$PJkG?Z;eeeG?u=6<BnL>JP?>yp<7zcvSU1X=F!;!avZxLp`{7iP#exqql
zr0v!Gf0A%how4(QlSRe=*RgMkW|JMYe;#q2zn766oxe|#UhTX<T<yF^ymlk!=pL~D
zsQ7Na98=`J(e|qSHpFY?INiy@O&lI^$o^df{9)kB$&T7zLtOLBt;99YJObS0nQNtv
zCxBy~*-l*Z%typE&+I3zc_vjB8jX+UnL~+dp6N+k+dGW-3GG}1MhiFbd<f!p9`FZ&
zuOmBZ|5oCfXC5K0`C$jxe*o-%O?tKeD{-}R&<uC6#z*tak;FC6v=(mKdq33Mm-Je1
zHt6pI{Y;O3331Ic>%q=uuya4@wce+QYo7Um>}Z}jdZsgK+I273?<id3qxPo|*F3X;
z>}a038TdV5|8cUT_Fo{b`QaV1qj{$MEN7JctVUezq!Ayu&|Tj^xQW9ihwR^DNw0p+
zA^wkXAowf>J9j%||9%+wUBI`K9ku@fam_Q|5!XEP4{(!b7E2vvXS;uBd~`oki@4^Q
z<B4mYX-8c1OfTY^XHFxod1eK1ZSPv*PfI+n7jF9HPKetJ!0!P55!q4u-x1e5^AB;&
z5BhrrOue^*{pNGrHyTg1e=>2k)1SEJnJnU(XJ!jG_1*^ct|GnGdlTqy1^r_l{qw{%
z&+Gv^w}74BNw4)*ILC=J4w`4$3pf57JDO+40KXaR&n7!+|9s*TC%TJnB0Js1)~mob
zf_?q}Y1L1)zn|>ud1<A&?qcKrO<<><aJJJH^f!Y3RFD2N;u^Pk#MRH$#HSetg3r~$
zjh{DI;{JLa`1QcQBs*&VXW|;?TJzk+#=fzmaqbNKI<P-nILBuUagFmFu(JW|Tta&F
zb0g?=4`nXf;?X}(T;u#1akamfxULtG`OZ0Q*O#g8`-;L%eAYW;|L#tDwSPMC<4<uH
zjS+6_TmyEl0=^FTCbFaUw-DEUe4p%SKbBwMjGB6{2Kz?~*Y>LY6Nzg-b^$wU!Olq1
ztDQp7Uj_Ol9{nof+K;z@oi$+R3DRr5J3xOW=)d;pBMY6##ODgoA1<8Z(^$CCUk>_i
z9{otrUk3Wg9{m!~uLk|q9{oeaXSQ({eIVTUd8tG8?;nM8yUHwbBIP=+Y7p1;y{&L#
z{}Okp{rgnXYrmWg`c<G`>d{|DT>ZHN>|6|Xo+iE4`zmp@vx~U4>u0ck5!gRiHd-1V
zwSNS0wcmia+RqSPCa}E{?2jP5+CK;MD?op#NB;ommxKOgkN#uOF9ZE=9(~nwoyhoq
zA?WK1=lFE?@Lt4Qi?QLvpOQwODcsb%6zW|}`a(HxT?YCKKz}dr^MOB4b~OIGKz|<S
zfAZ)nEpZ~_r~K1`dh!j&r!DBkq}8A5(T@SWbdlB1_UJDH{UWP$f8FHKKSf;g$>(5a
zA=vqw^cuIy5-e@6&Wodnhx0<XiJPQqTgwR2tNn98FH4`*U+U4XC$9cH0Cr?+VC}q2
zdad^z;%es$;@Yl=3^LO$*@9X7hYQ#EsQqJ!tNoV5)qWqaFI!z}KZo>c|2)vkmfz~v
zdGuRBFSk%uztf}t2J~{PYW1ly3Aw$sg`4=ut-sYb^XPkf_+a9iPqK-xZ*R><CI~n6
z%8`jJSV8*D2RZ#^pqHa2TksfgIij=t4YH&0{{r-K<Z1Q)c=U%#vNL{8wMzF_BjFs+
z4A9GwxxHY7M_&MXc{E}5=X&&OKrfGatp09~{w3m?PxSwJHtmv>ZS7Q)b%5Jdi@45<
z`ozO|A>7!PM;g|C4(YXD&I5gcRl2{{dGxmsSAVvGowLBsPSR_=dx)!@{lv9hm6kc9
zrd<=kem&tFw<g5ZekbB;f2eR{KOgL$MSAuBV$e?j{YH=e1<;QN{YM`C&!8U%`h#V2
zQz>BhyfR(5@jnmr9X$FW9zKe==97uU=L~g~OcieG9SikdLHcDz5Pa5yKGz}p_y2&8
z0saBm(fIENeGcdkl6@1$r>=10MmFf%c=UZhp9T6HkA4Q|&jkHSkN$elj|Tn29{nqz
z9|ihPJ$n7U!WsvC-!eru-^%rU%XHx;KE}SD?e+zJ2Gl!->}bDCBCh8Q%Yd8nTg~Yk
z!T#xBe;ep=oc~5#&*v-3O^a!lv9Dw3IN_#Ur-A*Bpf~p0S9FEliEF#YgPoCJXFloG
z&IQEP&TU|41lW1fqyGf-!$JRtM_*BH4z+)^-}UDjm21DZ7rlv(v9JA}1AG|NJB#dV
zyOt2we%}Dx^vhte^%&TfRANis1wHnAHMx0K|Fz%i0yp-%iv5#>n|2KmX1)vpJ@)(Q
z#I;@Xz>fNE>|92A?e}YltDUW2XOJ-<pPe54@1P&3;^1oyIdsrCsQtRcwcnc(*M9FW
z+{DM&zgy~<34DMs^W`G4qxG&OuKoT1*^y}**#*2m*#DF4sQng~I+3<l`#nRr@!!~a
zUu;bPeyT9@WdYgI{#r_0>%AT9^aDFjkzVb*NL=lF2X^{`opN%>rR`FE1L3A!eL&yY
zqwhyt-&-36+{}ySVrvO-oL_5+pCZZrdf~>O-r&zWz<UATM|LzmzY*8=mXpIljl*Fn
z&R8wtkwK2vCqA^M<86o^a<t=}g&Y6N2Y<55I^GMo@&9m#Bd3v_2jp;K7U}hj^+Di0
z#fJIv3fa*(>?E#n*h5_7@B?v;Ls>b5)wpRKY7y5s93x!guqxF#+W@%nKilC*2ePAa
z7)kn%M1Ljl9>UC*yU32l;X&dWho^~a9Nr+Vao9s#<M0D<jl*BWwOyU$5ZuHk6Z{_{
zT;r^MW)s(WHwCzvcXh?q8sIqZ?jru&Qg^`v!i_)O!Jlt|cLQEl2Bi9_aXy&1`hNs*
zjq{1bHO?J~Yn*!%*EkOmZu~d%ZoACuQNWG=hf5m@$&U8R3erpSBQFBiHQ$)}nCxgA
zz9z15_=UK}p@KYg(RgYc4kxa0IDxpvp#^bm*A(F<K3yaR=F0`7SN~TLSO2deuKwRe
zT>XE7xca}HxcdLDaP7y4^y41j#{X>NeDL{^>}Y!rk%wX0-jAF-ax(A?Vdl$F;TnH!
zZw_&tcV`1P^R9~6x(YbXySs_&bM6O)8$UaX4fEwY;HLmDCl3YHPwlU&#MS>JiEDo~
zB(D8+67m06+xfs(Ilh1VNRfo0s1%cAl&o5{sI1zuluQjFwY64_t!AyPgdquG2uWoK
zA<X{}h7kJp9YX$3-w>i9^!4xiyRYZI?w!x>bKO1XUj3feYv(!7`&^&<bKQTQ`+3fD
zo}FX*>tu_Y{>rwvY5$v<Q@#2_{tsI5CjTcaZt{Q0;wJxpTioPdYjKnRPZl@%|H+*4
zq<JHao~WfMe~4@H&k1NG(wezxe^cKSEB+0R9}B!6Gg?iz$}#P5iN#GjTx)UD4vQ^r
z+Tme~n|657;-($eFgNXx#JRo$obu0MzR@bjw8L(TbpVw^@oPA~3-A+|(P|KL)1Icj
zqapryh@a|+pKWpTJ0jOv+<cGRQj7m}wl;ah;`{OZ^P<IH*;~i2v-tOkntyKbq-L6L
zwfH~BX>M*-Fzs-Bj^+tV^xE*}&G{sAYUjQ>BzPQW#hdn=>EM@J++2UFu=q7SwaG%}
z<eLh<Z(8xj_g#yd@@p;rR7YLdW+=Z8l;3)(-Z1T8%0I&5+Xw2nF3c&<-cZhHE8dio
zYjKn3REuvvSr>L8l-~==UuMOd@*lT&gvY~kP)-Vz^Nkg6%Bi!s$@3qJw>w4`w#S`%
zP3^#47=WJ4?e-jK@h*j0KNQO8p;7QS!-_X~UTSfZ=XDmJ#&7y>f%3aU`OjMMcg)c*
zz6|l^y(Yc#EpW4I1&YexF=E&EAm-FQ-E>Iscr0@}{&<U<d1jc!%{(*4;%1&Hw78jP
zW?S6MGxII}ePSe77F*oRGY?zb%rh@q{P>(mu&lGVnP<LXPVIAS5UC&jVQ#lio4fSu
zHb30rW;`5c@h1<{`aaBeQ=45i3LYn0@n*bTU~yCar569-a$VR}%y(0pU7-9Yt$0)Z
zD;EEQ-?Y62<s1X${BFgYa)O)xRGeualjpv7Yq8<W%JlX@%y(0pM{5*34z}V=`KMX@
z`axQB7L;R-?exlAE8diIgT+mrODult5xV?)q5PvX3Lf9J;!XLr7Vn*_MVq0V&QMP4
zd-R5BA5+eu7B_izwfL+3v_6G7wdavg{%9-yUcSzg1M!_8eje~6fZu7AWAc0o;yXh8
zT1Wgx7B}<EcNRDE%%2uF^UU7Mw3%r)GtV4iaWl_!vH16iT7QDY%{(*Q;%1&X*WzZL
zDYCekXXY}eemPuQ29Hauc+;NGIC!<i&3IU6@w553_5pM9O$6UP@6{Wo-HdO7#ZCE#
zT0Apf>pL^2@_A|tUKnM?oAPrl{x=Vn0x0KDU3Bnxs}*m`xzpk%&xbAk{&Zc~Q&4^f
zD1W0BZ_2N;xVgT!9m;7B<s5mR-mu%Vo5f9@{VcwErq-u3r}jJq%D=#hH+f!a@mKkz
z;3_Dm9hCE=6>rLU!Qv**w=MpDx-RTJD8DU~|GO1GEL*?$KZtJw@m=rN8+N<(vbdQa
z23q`Y?%$CXpLew`_iX0Wo(F^P9ag+)hX*XafD%*7V^GdP8U>G^Tk)oxZ!B)||Ha}a
z|E9}zp{5<KzD94iWKQ|F)+l&9#fmq+=UDvq3$-W@%4r4VR9Nw*oZBsK^1s*OCjX}`
zK6bP=d67Bge<1k&&x$v``#hk7OgkL5uikFWoXX)tSMb6B;7t^HeRmyyx>b(Jzrczg
z$noV?{JuO%EU@BNk%?L!vf|T^(tNcQKbhk{vEofWTdny2PzBYp$Afxp+QH=0jyZ)<
z(PKHjyA^NpIoXPD!ST6Pyvb*}6@R5pBQoELH~Car@f;p`#)>!j{2SsEOt4yiZN;1M
z@F&FY2k{3yq&Hfq6<&utiaAx2hfWYUz!874#lPnH^DK++#tkvU;wH~aEpFz|>nvWE
z7Nirog*oN9k4C}cvsV1tf%?UlA%1U&|Ivy!`TTBi(_hV3Xt8Ox4_fN&1m={_UQm99
z6>rKPVR6&H<1Bvea9!9W=2ZTkP=2KqZ_0nf;_c4RqNkypW>C(5taww-7K@vH`NQJ(
zjMRlSd04M0&!$j*XXd8e%J$bUc7u4HN`e>mU@gV}!_R4D#ypkJQ$z4-V(=K;Y7@b7
z%zJ-3pEQWacE|#b?VJM~`?nZ4j;nIuI6f<Y<Nj3%9QV^I;0gSkR@MBR>V@-p4RAbO
z)B?xjR~>LXKGJ6vw9pEV*XH~0iR1Y|BE;kQNiuLe&q)K0=T}+4@%$|ZIG#5a1IP2y
za^QGATmc-<w=01ss=Aq_3i#m$s&zH+j=*bx9|61;cqia>z>frO1~<Lj8F&H@dg6S@
z3|>tHo&@p9z>fx=2K*S{S-`sh&jH>Qcrox}ftLgC2D}0|A1Z=ZD}g6Nd=+rK?pF=G
z2gKI^$LpE3!0|e29q?XIj+sQLo$>l`0#7c)@%nQj@Kh)#8F*jdX~6OGi!9(LKzt5x
zzElysS`55D#Fqmf0K5YDiNGs?rva}5J`i{{@Ik<9fDZ;<3!L8q1+Uft&wzMy@St`c
z0z82aD#T9$o(Mb>crx&zz|(-A3_J_?FyJ}BhXXGLehTn%;3I%n06!IYCGafZRlxa{
zqu|wQ;C$!}cn$DTP);pyeoGm=S_k}eh&P`<P&@OfL-1+>A1sNV3Gs=*`K?RvYBKP%
zAU+K^f3z07ng#qEh|d8&26!>>bAguw9}Bz!_&DH|z;l3C0nY_q4SYQC8sK@rYk^My
zUI#oMc<^Df+NO4%2s~jAy+M2u@I>H~fhPkm0G<Z?Jm6Wt&j+3ZybyRX@FL*lz^4GO
z06rCXCGcY4RlqL*UJbkicn$Drz-xh*0<Qx;9k@BkrgokIJb_ONiSwm_;MGLnWe}eX
zd?xTT;In{d0lx@%4)EE)i-BJZyd3x?z$<`X3cM0{Iq)jrmjSN^emU?O;8y^z1wIFO
z9q=oGN1E#mYUjDY6M$a@JQ4Uj;K{(R2A&4|8sJ&LuLYh1d_M4E;MV~!2Yx;93g9;Y
zuLNEJybAb@z^j4Z1iS|L&A@AcF92Q#{1)KmO)Rzlt-urZ(i_BY1D*(cA@F42w*yZD
zz6f|0@H>F#0ACEe82A$4<-nH$uK<20@Jis7z^j1Y1-u&g-N0*r-vhiB_%h&i!0!bf
zd;qAnsh#fwp3p*X5WgRIBJkzFlYu_~JPr7Rz_Wlq1Uv`$3gE@S9|m3y{1M<4z#j!(
z3A_q;74XM^R|9_>cn$C;fY$<l5_lc(r+`QH)*IB$PXkW?{tWO$;46VA1Ai8H8t~_U
zX90g6cn<JYz>9&u0K6Rdi@+;@zXZGzcs1}U;4cHO2L1~08sM)2uLZsucpdQ9fSVg8
zsr_FEp3qWn5Pt)BBJef9lYzepJPr6;z_WnA4Lk?<THwXN{{_4p_&VSf!2b=r5_k>p
zD&X$`uLk}u@EYLn0j~wV9(Wz__ko*>s?^RO08iLQZxH_wcp~r(z>|T01UwD+$H23I
ze*!!Q_@}^&fqw?P9QfzJD}a9iyb^dV@G9V60<Q+X5qJ&o{{XKAz6p38@UMWIi|^FV
zUjt9rS8ovi26!Uy&A^j^e+xVf_;<jwfPW7>2ly7?#lU|6UJm?6;1$5P0<Q#K2fPaS
zPr$2z{|vka_%Fa~fo}s|2mDvy<_9>aoqq$Ku%F%_{yXqQ;M;*G1OG4ZG~j;#&jS7@
z@EqWO0WSvrH*g+S!TCd);(htG!+1^kX8`XG{AA#RfoH4drf)_8KV3aH=TdpV&sNV(
zA4~&&j(T3n+gAX8L_P0IiK(SBc+}@VblmLE+#KU*la3=M-pnDy>9{aY{n28^HgP&G
zOd+Ti(^kZ3o;U5Y9|5({YOVS+W92a5>lD9A{n2t9@PDgqQ~n^}G(Vg2vw^>-xEa$E
zfYW?y%DE8uM^Mhyz?&#;mIc6fH&CsY0&fa@Iq+t{9|yiC@E3sdscZ1+8sL0L5BR&l
z&6uPYJ_WvS5UC%&2F^n}cmc1ICqVok5Ptyhrrap>@`1q3{Y}JM0dEWOt$}v}eh~0(
zzz+uA7kC@sgMqgNehTn*z|RDJ2=H9s?SY>UyaVv*zz+p}DR46<(92f?PlWiJfgcWh
z3Gj}<mjgcn_!Gc80e=Dbk-*;o-Wm8iz>fm{3GgJ~UjaWF_*US@0RJ!WF2Hx^or=a!
zSK#{qKNk4Gz`FtO2>dwU#{y3V-UqmutLbHP{{`jK1LB84d{5w~15W`y4tOu%1;Bd)
zp9Z`S@QZ<`0>28lnG5OV8-X7W@r!|<0Q`R7{eV9Xyg%?4fDZuv2JjPszXLoC_@}@J
z0{;g1AmBd(9}N6&;OW5k<Vl(OF$4Gkz=r_u0Q@B2Nx(CK_XIu^cz@t@+&4=m@L>k3
z^+@2ufsX-x3h;@*M*zP7_^H5W1J43}74Xx5-w1pp@H>Ey0)8)WI-fBMe$GPYGiEXO
zpHjb^VW3*S4&|H)96x^<4g6z>KMVLK;B>xZmaV|)e90_-03TzZS~uf^H|2RQ@cn>~
z1>P3;IN(PB&jEfc@Lb@1fR6`05O^N&;lL*VKLdC^@EqV1fu9F_67W*slYw6Xya4z-
z;O7Cq3HbTI7XvQ@ejo56;Q0BGIj5tSpNIIV5dS*xV&M3>(gnajhWHZTn}AOP{v+^G
z;M;*u2fq6rdV|K*4B-0!zYzGrz{`Li4tyr?F2H92?*;rK;3oo~4SXo@i-C^<ehKh%
zfnN%I67X{1CBQEOelhUNfnNpu3g9;ap9B03;8y~_7x-M@j{?66_;bML0bdRLYT)aD
zUjuvt@N0o@1U?`57U0(b{|)%{z$1I=4H{QB0B-@j0(dLnHv&Ht_)Wl%27WW}6yOVh
z4*-4(@J!&h0v`$dHsE7`F9bdj`0c<i0KN$LMZoU>ekJh5!0~gvCBPR!{8He{fZqxH
zQQ(!pp9Ovw@K=G~4SXH&dw_2Mz6|((fZq%J2jKSs{~h@Kz?(GJ8#Jz#1K$Vu1Hjt=
ze-L;_;12;m7WfL_=Kr(F_hI0JApQ~HrvQHx_?f_~fad~#40s{%$AMo6{0ZQf1Ah|u
zb-<qjejD(of!_`M8Q>2CUkUsf;Lieo1^9Eo*8+bY_y@pO0sj*C3&6Jke-Zfaz+VF1
zWG}rz{a6jWCGeMl9}N5z;2nX#3cM@u)xi4ze+~E`;I9K84*U(^X98aXd_3?sffoUP
z3;2b=-v)j;@U_6N1O6}Iw*g-V{BGd?2L3Sc8sIB|zXSXg;O_$e7x4FhZveg?_(tIG
z1OEZ|2f()j{}A}@E%XMBpAEqG0say2Ho!jy-VyjGz`Fwf6nG!tp8+2T{Bz*LfPVq}
z4B)lEbAf*eyb$<C;4^^#2l!>cHvzvE_*cMh0sb{`{Ji)Z;15FlX5dc({}%X5z`q0j
z7Vz(ZzYly1@GpS>0Q@`PKLXzdd@JyOfY$-vYj3?l<LW2i2Lk^Ycn9FW08awG4R}xB
zzXBfs{5Rm4z<&om3ix*5=K}vP@X5gc0A2$8Pv92={|oq4!2br`k)Knu?yef|0^aUy
zadR$mjK$5q-Ob{AQb(wzhh9ZY`E8l^ws?2u$6I^=^8ps0%6yQ;uVOyj;>(zyX7P>8
z&#?IS%+Im-Z_INnzGo8+@-2QK^YbizDD$ZnKZ<#&#gAh?)8hS^Ut;le=H|VXY5!B1
z&$Hr3GdJ%|O#DRVH(Bu|%x|;!Eav9i+mthh`CV50eCGFA{1)a9S$r9DbM9x#f0(&B
zH#7Wc=H}eV@E4hza}4U%-Pwy)U-EO}P5C*k%sxoG8Sn!MsD)O1>K$wk1I~xUfX@cb
zyJo;21HMl{^uyc0_XYk7@cn=%aQ*1z1mJyu^V8tfzFc{VKLFxS1AZWI^M8;O-wOEW
z5Z@a3C~icGKM45wzz+tF_hYvKz8&J*0zZ&DgUW9Qd=T(MfL{Q-J@7@qI{@DZ{7~R~
z@1Zxy_b}j{fF}Yk1b#U18-RBN{sa#uD*p)Jd&Bv8C*Vf_KN9!=;GKaN0Y3`(V&F-@
zUju$L@O|KX?-<~{fp-CZD)6qr@qGAL;Lkz4Io8n2pVJPl7HXg4f@k`nHyrPhfsX**
z9e4q7bIhWb7Xt4I@oxZ60gm@;^#Y#SQg2Y6=GaFh7kD2X5<JcVo(lXG;C+E_1a6L@
z^zt4&S&;7u5T66QAMgWs5~2A1z+VM!j>YuyR^TT>{J}iwP&sM9F9bdi_~8BZ2E`8o
zekt(5z)#>wisI9O=K;?E{wnYx!2bvQB;arHWJl#^0-wv19r2;S9|3+c@O^m_r1)XL
zGk^~Vej)HvfIk3y1n_*GOsV`+fo}z#1^gqPWGUX93(?C7JjoItNr0C@z(*OV)}_F+
zfuGEiGL>^W@SlO70sK>*tSSCX;0N+#O?)))4B%%0zYzG@z)#`Hoys`}_^-gn0RMs~
zeTqL9xcOpO;$wjy$_E4D<A9$CJO}u>z;l6L0(?C1#lZ7`uLC{-__x6GfuF?(C(3go
z@C$)Y0)7kd$-ut^UI6^qM7=@fp9g$2@biJs1zrezIq)LjZvmeIyy@Y3gM6m~?+?5f
z_&LBY06r6V3Gmy1PXqoG@KWIK0iO=M86VVlQ)~wCMBo<!uK->K{1M<Yfv*KV3wRqo
zX&~Q=fKLEE8~6>tF9!Ys@JoPy0sK<nyYWd0`IZAe0r+LWOMzbw{3hU60Ivc*2lzVR
zR|4Mxd@k@7e3C?YUIn}#@Oi+`1b#K}H-KLQ{43zs0^gla!pL_%@Kb?b2mB7;*8_hY
z_zl3f0j~gl&{2AWd~XDv3j8MECBSb6{t)m5z~2OZ3-E7%-wM20lHQ<vZUcS<@P)t!
z0>2&jI^c_dZvlP>@B@$58|1qfcnR<&z!w2u3jAf@cLE=AjNYK~D}fgRzYF-y!0!hB
zGw^$Wx9g%esQhKX?+1P_@YjIf2Yd_g`+*PZsyC?o<-p$r{s8ck_+*{p9|S%N_(Q;l
zbkiFYzXJGL;12`;3iu<yw<YThD(6w)?Yl>L74X5p9|Qg}@W+8)*dtob6Tp83{v_~e
zJ)`kY0lyFU)4)qoqVdlF-wu2w@cny5<DUh7Sf40=4){sHp9ek#_$uIAfWH9zu2j82
z?ffF}!}><~OTd=^uLfQN{AJ*akJlSi{wu&co)G1)0zU!xYT%juqw%i+e;xSi!1o#u
zjei69O5kgNe}7^${!QS$)1v$>;HLtA8~CHZ*8;zCpx&T%_!sasz}Er4a8NY<-@qRn
z9OX5@e+B*y@O{&x@$Ukk0{lJT=^4@Z^}w$J{yy;bL!$8?03Uf$lz#|(3GfZTp9cOB
z@Pjg=<$Mf$Ebvc&&j$V}@Sa1X<$MPGY~Y^*zYO>nz+0RgEvFXv4Zyzyz8?5S;O&R$
z4H^&s0lvrZDBlEp1n{qb7Xtqpc!yJ><$MD?9r$M8=L7#1_%`6*0iQWSZ&3c<1Ahtl
z7U0cKjmG}~{Ab`l0zW=08ow3zXyA3g_c|>a{}b?J;6DS;2L221&wy_OK7OR$p!)s_
zd^zynfY$;49r(wi^aho)9e9)MDE}|;w}Jlw{1@PV0$+7{w4A?yZvy@|aPyS%$)pEf
z5_#Q3t#{|=v`XXW#GCSSTIKL_;?4Lut*+(g#0Nw9mB9Dp=d^kNcyr)ufbRwT9pEj1
zo3TN@djmIZOS~oUR-7C0eSoI`-xqi`@cn?70#5+G062M=WeM>84OHt@z$yMpe(g2j
z6yJvVCg2orzOU~G;1r+C@hv$CTG5~RKET$%DLzg8(UJn3o|^9)G@nxuqxjM4kCri3
zy!k%EeBcyc97L<%ss>I^&G#i<2b|)|IerCjdTRb3;3?n~zmVhC1E;6vbB@n|Q+yT2
z{{{R2X0&S0I|IFZAn+rBQ#sZAS~~Dn5I+HUYv4t|sT^}`n-BaTh+hHxVBk*yr*h2P
zv>vz_J0#l%ye*W|ig$9VZ#&>Azz+eQ4ZJ<@Qs5ncF9d!l@Rh(11HJ)xBJjU}9}c`d
zPezn~N8tT{9|1fAIJMjUy#Gu9-U;I806!A=GT@zouLgb;@J+yzfH&PkZ&3b615W~e
z4Dd|gU4Typ-WB+K;Ku@A0lXXVwZM-9{yuPOw^O*?wgESD56R4ZtyHh>1b8v`sS@vD
zpjv11L4tTs;HAJ*fG+^v3;0Uly@8wiGpT%js}#Jt9pY0VzC9nDD84W7e!%&yPw?s(
z;3q(QK5%L`^Z$)=fcJy=<-qx^Pw=X_Z;<lgw>SYe_W=^;w>SYe_w^A^3y6Mb%?DTF
zl#e;yqyQfX@uPtc0zMn~VBm{^rvqOFJOlV^z$u>(d0cG*J_O>M^GN{Ze-dzW{}}O1
z;KLz)C~$Ls7sa0pd^*HaKHqXa=KG#0ei+1?`>%-ese170dMJlau>)@IkD_=!l@53-
zK8YdDr_2FQ0iG2Q{m>sc<@qP)IRW@-5I+YvpSlLGE(6Y|t^r>SoKHmqz6m&=at6F9
zpKMY7X9Pq)>;s(g+?N8>k^=lpje^H);O1O|UMK~A7Q`<Aem3wYfu93>J@7HWKLbvA
z9?p3-<&#C)JQw0S0UrxI9r!rl6M*Lcp94G>_%h(*fv*Oh2YeIo3Ba53NiF4{54;ob
ziNMo=PXayx_+;R7fENH?2K+qWtAU>nd=v0O;7$4DoANIL-U;{=;OW4p0-pffoRiYa
zbAVp}@ymdh0ACG!8t_fPOMy2{&>NKhbl{zU&j6kd{6gRpfR_QE1AHd%Wx!_vUk&^s
z;G2NY2Huo*2DMQB7YEPuLnq*u08a;gDewuv%Yn}Uei`s(z%K{B8u%5!HvyjmyeXgD
zQ~p;1?*x1<@O0o;0iOVT9`HH9uLiyh_%*;+1HTsdCgAgdH{~}Wl>c?WI|08QcslSK
zfKLEk0elYd8-XtaeiQK3z;6b=3HSowO<U;=%KsMNoq*p8JRSILz$XA-2z(Ck+kr0w
zz6khg;CBGu1bi{@=B@Px<-Y`Y67Z$KGlAa;d@}G#;PZgr1$;U1yMeC-eh=_1z?T7U
zd63?q{O<+c75II?hXcPKcrozhz-I!dUC>-dSP1+9h`$Rs#gCxG)KU%nL5+gPTHp@>
z{}wovGoH(7ey|Rr%@q*8KX8hl!STt!ABOn8z$yM3jvo#D5s1$PPVtL4z8v_Y5MK$r
z3V1c}$AH%Ye;l~EKty&=0N<;P-XKo-e8~AE0e=$Wy91~ApEy1X_)`#H4E$-}Gl5e%
z&34x>E(HDz#NP#+;@fh3HSm=X|0ZyXH{UC<8Thjh{}XVE@6Y8YwADdW&F3IK8Tj+S
zvw*JxUJU#N;1$4M1b#bk%4Zhmvl94A5dSi8ieJF-wZN+(-dx0?dc6#MuXcKaIF+-U
z%Si(M3dDB@PVuWaJ`4D(5PueMiZ|bvT?TwL#9s!S;?4JHR|0<x;;Vtb4!jol8^Fzv
zBvF0W0N?8ny<ytHeBVS8@HZiTIPkZC7Xp79_;lb@FLS+Y0r0gD|0M8#0bdV%9q?_y
z{|)?a;N)w*pQ3$x9Ypo5f%r7w?*PvM{x0wW;8gySruxNsz~6)T<-peiUjzJo;G2Pe
z0Q@K5<ohW5CUnq2RId*qJ_Yy&;Mu@G0)8%VD*tOPe>U)sA$~FNPk^ri{weTJfqw@4
zFW{d8Z-1!Xpn81){7B%Gr@5a#9e6FoPXPWU@HxOY0$&FFKfoUbPQERg=@-`n-vsg7
zfPV$N)nR&r>h(476yV<g&j!93cq#C2fnN-q^6bEQE(ZP`#IFMWJ@8L~Zvp-n@E?FT
zOVk@wFY-N(eY*nxQHKPN!+~!FUI@Gn_<Z0$0bc?9XW(mr{{sAd;FPEN|B7wEw?TZX
z!}SK$>sR0@z<&dt4g7cD=K?3+Y;K=9z_&yEGT{FOz8d%+z&8Q^6L`~(dV})+3wS5s
ze*=$nn>MqkG<UpOmzL=DWb>>fzc9C3X?|I0q}znt(%eY5@zbV7y4BNe<IWz@v!JA;
zN5RzYeTEJxD9j(3pF3f2Zeih|+`RMCdt}UrKRDSVc(5*cs?JGHXRw`)5@ij`i*%cm
zmp3lIEHA&fbeyVfVSa;3I8`1dspE#8I&R3&;Tetb0&$#{x|#iIwWF?yX@c|}bWKcf
zN{Jc)8Cf$5BEh)XapU%xlwUfkU{=1n>to9A-d$;^YmLsXxMRfi96Ge5Wb`S+X@KUJ
z49y!cDtTP$Pz46%PRq~8;1OkpJEom7I4UbDE|jEMRGP2{WT>4=>_sb^(#B^aNOv}y
zqQ++<NOv|HyQg+Abgfp6QOe^uC2wj;es4A76-=2lG|x2>tSFrY&5UNK1OdHrOG<KQ
z4y6W+mgpQ^JCcMMjH5YM7@9qBRCiAvHLz4wZ2a`nog3p=kfQ?{R;Cf@#n#wS#RfZW
z_de4~RsUt@me9N~wWKJw)H$07&DEf+RGPbJZpm;CTF3qzR&tNtd8+Kv{87dEc?G$J
zgD2;f<mQ#;mkckM=1$id&i0<}=m%=FFl8J&LTOw(LTN^9uQeP9(H)^Q!+S>{Ntl5+
z(o|dRnjOJz^j)(f>^QyH8cRDuOlCW=BiLo_x*fqTc~|TR_CY589U(>;$Bs}G*N#vW
zI!>cILXrQDK$6&D(Qr=_cLY`AU9%(DO}A@ygdL|BTVrWQh{<dxb_BbuUAH6HB{ynE
z2s_Ml@0B-o%8dMy(rk5NlCIvc4OIhYMppK?tUPr-E}n_{7pW%Y`XccJNa`E=6f8Eu
zJSZ(D!C-(#PoxI-Q0HgrO<eXkp)w73hUng=6d8Ssr%#(aZoGO=nlW<NsGgEs%HE#5
zVzc*d-tZ!^d1D%+aaqRS#&pzgL>tp_x{+;c?-#qEjl+xdZsYJG<8Na+pfsY5=@1ax
z#@;(%O2M?@1*N5h`599t6y#3H2;RB&$jHtZojq>IsUuGrn5`~b_?FtEyP0>UV&P`?
z*>weS$GLX@=v0wAikf(&I{58qy1;mv8G1-F!;U7F?#b%3zOZm=o;tVBI4``OF}wdR
z=?=Tpo$ii!3yiZnN;CYrgW|orgXSRL?ugl~cS(2HrS5ch#9LsT-BIM(9Te}~9W-6J
zx?>n!Gq#THDbx5mpqYE5pk8_7)O8wqfA5Ye&4{C@(u{bDDvGD5A}A_2UeiTsI@jt}
zGPN7c429|nQT7@2*U9Y@F1vHp^cz!5g95BK_wnfCNW<Rcebb0XA4eMY38QZs-ugZ<
zSC~UBV?XI|NQQcKdhlrmjg?VeGP-1qLrxVC^^Ie!2)1#kcIavkacOJ_w(-bz=xgO2
zr)?an9lF|SOG7Y@+Dft=`dWEQdcigh)ec?d{Y5a619x0@%twf{V@YL;fmF6RE|^ax
z?ar}h%N<-h3YE$ikEFL~wyXY-%s!08qYOU&8ZmW3e)i1b*pJPEV`f~%&?j&89}Nti
zI(<s)W$5?|>y3qt$Sumxu&*}6Usi*}&d4pCzKaXX8dhYzdx$%?9`w;;eWL}rjmn*<
zJ}jUj&A^Mlv>q{~4V*Sq^}{YMuF+l5BSlDXNa0lV0n5%bqPx^aXIj5g1Y^&>=OFGL
zsV|1EoW-1E#<g3i_YWCG#icVd3iFHd^*-f2FuM0r?LKPi^pd>%=;v9DD<vzpWLkbn
zw3J3&Px6=|?IZ3E?i{dZS6dqY6lp8#yU}loj47tUOyoI5#uT;_Q)En84HEO5BI7A6
zYnZy-r@>Hh?m~8P?kQ3g89IhzN^?(<yR^8tC!UxD-ILkQG@`rIMrT^TQ}|7hc7^MU
ziF=BSDWNe_WK1EAnj*zg8Z|}Q=h_}qWQ;Wavq)PS{}gE}>$}l!ii|0y!A#^iMaC4i
z6H{bNSq&2NoFd~XEVz*{zA4f!&OJq{dlN&a$e7aHQ{*l!F7AmZCPDXPwlj_BF168_
z*6$R4Q>0zt`eNdqB4bKu%oG_@NTa4mv6Mzlk@j2O?!AlYWOVTKk`i@dOz&W0&afMP
z(9($88Fp~txBkYwMig66Mj!3Ox3|YsI~CtV4VoE@t=P9u!Ub{lA)&g49^a=|>h4w7
zr&rS3mY4(KF6kRp>JDx-X>{N0xLBXQiK({SH}=V|+&Aj87DwMmEgrL9?UEK(rT%}k
z_>PP9Y4Mn9%Pp>sR1Nm7crV`dnU){i>5`FEG%7{<=vL|qdk^i=Lr+YFQ>UpLfYq(u
z!h8346YAc(VA2$IH)?wR#DXaWr3F)`#C<QSomTf`omTq5?17ChgzGl7$XtzRR6FCn
zULH5f+g0M0KD9W1N=!?~<kjHg!QhsOIA_D)em$NI8=OvACFWn?oHH9l=Fz96%6kX*
z5=g_$o@}CHwKV>*Y8SFIW7RHeC&p?_QH>d^F@-d4ti}`rx4e6dRlAtRkJaE7D)-T$
z!Pp9JvJM@qr5RphRe5`kRePF_j@7*Q$Esb(&Wu&NteqIEF-0|Iti}}5xUm{jOykC?
zUCfTgs(S{^gHdIo;y%vxD42HU<O2GChTOdT4Eqz6m@_7vzwP&D@p|@9mph6Jm7V=R
z6w@+Bju<tr!G5KtYvGh42-%r80=@DI^K*mSPht*N(jmY;{^4O%-%%r;wCr@64et`{
zEu9!ytz{qK!p4I=TXt_a9zxHcagL04JlLK-<3UY{jT;ZjbO&eHp5wu;!LAz*J5JMg
zJOsDvH8_fdjR$*1vc`jSe&1jO(tq8VTVmrK54NYzcu=>7Hf}s9(_J?n>>BL4@v!4G
zW5<K(-{5ne20c@h(O12dQU4TIqW)3M{+PSrOclN5UQNHTch1E-&-cl{V0v!hv?=r<
z^Qd0q)NnA_)gM;s=kSJ>`kkqXmg=G+q~T@Pc-r*wqk?}2%_xW?ymxM~dPg%MzIPKv
z875q8OmjnWQAR2?`v~=K92rH<9O~Pl5f`=Mzc;fKhk*ULn`;QD=_CFjU{8!N1WMx{
z0%RFB1WGBw*`B8LRgHayKxuuSx-P;s7+}$Gu`#1bM2A4BGvyr*fgK+g;vWKeI0Wp^
z6<k9=O|tP10edclA&?jU5FpF2A&?i>5KuMt83K8JLm(P1Hl`T@c`yrz|G?F->BU)K
z$A<!Y2*jM%HW;}@8GTCf)eR*xV(-bSpPNnYMGf!%b`D?@U+PhIsb|@F9%bjrWxMXM
zjedoMI-!WYQ?bFz!M%_9<EKv=S1@JbRP~K2!Smel<4f|*Jxh#Aa;HqnH(#`(S;>@1
zh3cQh8^XeZDfy-xbz{7FN|<hx=X0F;-1Ys}>1V2|trNSA8#k$}Y+P}E$+W3catjMe
zXO5eZ9O;&)FBL|*O_^Gn-|eIkryo15RQ=l=Z%>*sy<2g~R3$2%$%W@n9yhT>-SVft
z>!f7r^kV#8nMOW8X^8$lAzPltpcSvTsxP={x?A+OI{53WA})P4>so@onTI}ybqS!~
z!$WV{2KDrt^CoYzcI98rzWlX*5vqT45B);cWBs!{^vhV^oY&+((nG&O@E_u#Un%JK
z^3bmq^z>UIrrpij)&4btes2%G`EE39|CSzl^Ic%5-^W95zT*n@`+DeuAFNhwfcxKm
z9{N@)mKO9+@X#j;dio6u({E<&>c6h6$MJiBhdxE{KhQ&;CiqjEn7qx}mB0B7BW%Cc
z9{OzdNBuz_`W)6{`<>^ZpDg&F@1ZXh^o1V!a@OPcJ=jCPK=5zlp|2G5Z9ViWSdZ=B
z&O`sC;D3mRzFP2a@1b8K_;>KouNU-(dgyCekL@?pL%&(@pXH(7Cg?Bn&<9^cujWr2
zzlV9~TdCtUEx7+Ddgv1c{ox+^uB^xQ@93d7->;4NAK{@-6Z|`Q=re`-AL*gb7WADx
z^f^NQ^E~wCcgnE+=r?)HamTD($DdLm|7$$-<%0eW5B+>Wzt}^+P-s8;jXG0rvv$?L
zQt&^@LvMc94cniN3C7o~UH&Tt|A##Es|7tBQ;e@!yZmbe{lgymPX&FFhkmo5f7C<2
zP0&B*p*KGkiT(GyhrT6$k2vb-w-8Oco3*R`+X(ujJ@lOf{fi#@WY**S{gQ`1RnXHp
zg{ik$yXv1N=wI>BXA1RS?V-;W^sjm7a|HeC9{NI|{%?5bO9efhlbLomYghZv7W8j<
z=;sLaU+bZ-5cL1@&@UGB>pb-4cLQ+z|Jy@fCA43Shkm7?f5$^#E!6)#5B*v}Pv_)j
z+?cg%{A>{P?|bMs3HATLL%&7P({JvXyv^E`zxf?e?EeiO`o9GKk395EIYIRQ*hAk^
z(0}5gZ^e2%e$DaFCkpz@JoH@!{d5m~s-Q3N(5DOfi5~haL7(TLA0z0~J@k_WeLoMq
z`JG$r|4%*i<?N5+x4k+iV_d&>?SJ!x{I`1eFA)4Yc=#_C{D1QBUoQ9`=HXu@_&4>?
zuM+$dJ@l&u|7ITg8o{4_Ym#yO+SUK&_mOe@weiqz68t-Q=(h;<Z|k8qzgvRi{|FDg
z`SE$Ie>)F-OaA={^gq%=--`8k{plEw@t?$c%>N4yeTtAjUDJzq{FvXxM*lB8^qE5b
z8$I;q_dn2|errD7{Bs2VO&<C}LI0J9zD#KUuRZkTg8my1{X8Lmx+WWM`z;Xk^c%<V
z>MI5PcOLo`g8q9C{Yuv3{=3CPUoGf=@X)Uj^gnv&Ygmu-M;8yh`5k%Of9RTey!}@v
z<o~OOemm>Y|2Gf4`MrD8|L&nr*dzA({dNz1dqMwS4}FrL|HDI{!g?IPe|qTq3HrZ0
z^yxzWe|zY&1pPlA`Z0q3e;)eDf<EGL{4QlZw*PJ(`q_fMiHClUpx@m?KcDqDe{}U|
zze?8Q{@2{Ye}$0$ULN`<1^*Tv`f5SHw}*bMpl|7+-yrDs@z8G)^!s|~>sXKDcRvsP
zc0r%up^xktJOA$Qp>HYZ5Ae{p5%dRo=sOAeRv!9f)?@p(_Ryya`hz_5X@dS>4}GRk
z|D!zg*@AzPhklHpKiWe-LCF6Y4}GzqKh|UZoGs|PdFba!dXM}UupY<XaUS}`f<D<p
zzf8!#yNA9?&>!c~eyaq1iiiIiq5i!*^fiLMw}*a%kbfT!{U$-5>Y=X_^nE?_e+l(J
z-b3G%2QHp}oZz8P5cK^#^z8+Gvd8#K67>B&{8I#dcMtzGLEpneKb-Zv3htji(IfwC
z!GEBKK1a}}d*}-VeTIj=jP<+<>OaIoUoQBc<e{H0=rcX^3k7{okN#gK=!bgvR|)zQ
z5C2tyzL$r74eNOo^xrU#{A&dNQ#|ya3i=Tq`pts=R1f_&*7GW;f0l>-FTwvb4}J5!
zV$c6adgxmT`raP>pD5@@dH8o_J+@!AhdxEnpYEaWC*<G9qyCwK{!9=5Y(YQTL!Tq)
zFZR$E3i>e~`Z7U3)<Zvs_1OQp9{Tx$f2v3SEfn;59{$S&{R9tvm7u@cL%&MUPx8>O
z5%dKf`t_{G{wws*e=7L*_2|FNf_{pJ|29EC)k7a?5j+3h;-POT=u15GZCH=(U+SSx
z6!c{t`XoVrp@%+M&`<Z!rwaNR9{M!a<NKeP9{S;eewK%Rw4lGpLq9>N|7;I^q2Pas
zhrUekr+ez-{rsz3(9iME&lB`lc<3tx{be5dg@XQa4}B%;ar|BBp<f~B=X&T@3i_)&
z^s9yX&-2i)75uO9&~Fg@>3=ff9e=fgzQRMlS<v6$p|2D4*Lmo-3;OFl^pU+|k6$->
z=vxZ<n>_Sw1pUn(`cACJ<KF@geOJN%Ru6rupuf#SpDySZdg!wR{p}w5F@k=Phkml4
zzr#acD(Dw`=*tEDp&t7AtjF=Q#6!P8@E<Ikzb2~POyLNB+^2Us^;pUJc4orjS11;j
zL(~R^q#;z#C)3T=YBBc#ZB@CqP{`EBd@n<16+@AHyEjRK<+=ULvxaNizpHwg%51E@
zx6)FXd#L<yG5#G8s^?Z%q`P84{jC?8)6I5jG4-VS)AtA1_0Ll=lK%#-KeZ1omQ7@=
zdQtLEWdCFqlRtfbfbCzQUYGp;VgIoDU+eJC66#OiA7J~__f(L-U9Uv`;*Sn|ACU?P
z7Na-Yuc;?e{sUU;h~*}b*S1f!;!^uf=KPJG+OM^c|5l|B^0x~9n*H}>U$dfET<D%q
zV)ppk#`<e8SUtCFBIbW;)2tT~=w?l|lm(BG;QAl^|GjBHGcM0zf4VmXmrD-PTju=F
zyrxSvTagI;Pbe`v|7%!(Ml>{dX4ym*DzVi5^Em%Z)>Hc*qGIj*>3_<|-_F05{i$qR
zC>9sGCyAJy|0dRl?SJN;FuVP0IDg##=>PBS{JW@nN&YPk)>)eRo1E?T>#Ts(ei6Fa
zRxPHVsr?cKf4Zh8`Hy7({f#lNZU1W>`U$Kb6QZB1^iuw9IDb=r%Afv!-EO}Z*<Y<1
zEY<8k$(lcOt3*TJXT9D3Nj&kjjfMu#Y@Zqhr2KP)_NV_}xAWgm9k`_SAH@DQS_#|!
zEtFpJFJu47tf%&){~xyf^Bn%`57iY9tN&Pse=Xgttri@AG}qbwOC0_`vVU0p7drg6
zvp?3K?tioWe{%SjCkE+9!s<`|CnvRk4&5xS7OX$r|6%)gQDTa;$KRqvQb!_T_3y0o
zl7AWdWBuv#Yuo=)hkw_O+CQxRvmE}lbhEo!u>SP<v+e(^!+!|-ht0oFI{de@KhD4O
z`J?Usi^IQ={YU6#sDD(uQG?}2hkp{?tgjZVKYe~>`?po|6Ghtn{~Y@t6O<Btu>I-(
zOjHUH`}mV4_|xYPw*T=C|4r=QFKQh;v;B)4`otr&a7KuJvLpY|oIm#82}1sNIQ(yA
z|FHajap>P=eV35@e{|$OPso3OkpJ;}$o>CMobA_3>81W(Dfp)e{?|GDOFQX`^I^2U
z73}{1$f2Ll`u|!2YcsOmk^g4Se*-(y@r&NS+T*vUy3a`AnEhw&QCdj<Glh%o-%aVI
z_N(5kg_~JG{uzQl-KQt{Pdr+?hRvT>IQ*B>Kf9;}=Z}*F|5qIT<?P>Cr&0fC*Z&2F
ze>MB#{x?+cr~AC5`rpU?S@q8PiS7Tp!@o|b|1iP7qZ$yB|8MLcHh*?dda3`L(?1KT
z1>64=!GEyBKaq{Y=ARi3{TSAV&7T)I@=xUavH!A!{OLX)sr}xKGk>~IMAGle6KB}`
z`MV?kEFu3<LjHsIlKqco<FNJ{p!8Dzmka)<3;wq{{HxeMZ2sKn(63>A*!=mKBmXMS
zALq}}LjL_)$nEz^H@&}x&7XagUTVL2^v`l?!TIxS!T&~w|J^)r!{*QV4*%jh?T`EK
z7{UK-hyN<}51T(<clgg^f877Z3jWRZmfL?L3rFg1sDHHQPx_ohYX6l&{c{BWE)M?`
zy0EF1WAv*2(f04`@UId4#|!?$9sXn4KWzTI)S+L*`mp_fmLvboLjUCp`9JLNPw1hW
zEG++K>H?c8Hs<_gIP1IAx4eF0w?BPBq169vexgz%5gdQ?UQkW9!D9A{;ST>Y_77{n
zlN|n;g8zAf|D6v1AKCvP&eyE$`hV}xH|?nvVe{wLj{M6wf1E#yg#0u1k^AqTUfMrw
z{!CMPssFNm*8PX`=TyOek;DJ<KH7hXF2*!p#BRS^9R8{F&%SEG`d=XU|KRZN)K^;$
z4DsLW@K2zB7PkDS3H~Rj3+xnWzki;1d?1gc>Q()tUH|JH`lYNtsa~m{*!ruLUh2Qi
zoWI%6=>5YCA^+zb{$I0yl5U3jENuU$9R3mdXKA%y|CI^;|8@B9%M({#i2pW+{|5H2
z<IJi4vjqR)>T@Qtu=}s1zZPE2db6_Yf0EKm?Z0NbPCS!^<Ud>RztiFW7yHv^mblpd
ziyZz5^ud5yma~}rFA@BIcKGjcq85gYzaJd_E7>2%U%B9aXoB4SBiKJ|{Iykjsr_r%
zAIIP2g8#V={~2kz{$c$;+Tp*P{@GqF*#GqXTlVp<%HbawsQu5?#pn(7X!rj^4*xp#
zuVW?k|6IX;cl7}aS=i%$>>w>{8RGws!@rikEI=(d{^kk(XE^-N8?61q#@}g5FZKUC
z`mzDF;P|^n@W0&Q|2X@HjlYW>{*~;H<8Qv;zslkNak{R5cfG2AwEO>n1LXc|nV}^^
z>XrJ5t<Q7lN3!0GUsH^&f7YR2#QLtf8;m?={64AlQva3Fmp!P(_|y2kQE0z!9saL#
z#ow%V)=%vGH#z*P**}N%<bSi^f8c>~`&aP5eI}&-`zpOu|HOZ^up0bt5&VZa{4<AY
zVc7V&%b}me`mpiyvqN9adeeVgjhOz=R9_H5HMQrT<|k{#@R0T!tn^a*)pGmgurc-D
zBBA}t9RAtEv~Uya&B`7>(;WV3^kpGxDPtk|FBbgocKD|b*TS&zv&7-QlKrc}f2rXA
zvBSUa6fF!JKgsGo5vr-(e;r3?ec1T9%%Pvm`mpiyp+jHA`YhcI+zPSB&v%tx8b4(`
zQgc{I{dbShetW7nh*JF{Sz7pYy|aE|kDn$=FZpj^e;hye3jW<4{$I0y*!bz{@Xw+z
zn^8-3@Tl+KxnJ-vaQH7BsfB8IHCXKWU+>UA&U$rtY_Qn+Cms6Lar%Gc&~J#-|9=ks
zcX9f6QWt2Y@$*ld{-?5@zMBV^gi(5{5}|tD+}b`_>80_Pz&A9lq2$y;<Nr~i|8I5p
zSH<anqr-m#S7;&lKPLEp;PB7N)_GUzRsEw~|92ez#m#hsV*Q^G{5z-<OiIyi|GGH+
z+bF%%{;7Lvf2{vgg8#V=|BBOfl`HFOuAkWTAMNn3X&zgDnoEpc$%18>!$0{9{d%Qd
z)jt}&0e3q57t)t4sRir*tl+=N;a|i4$;OD+w*MCn|77~ICAE~Xj>iA<g8#wl0|JF(
z`ag1}7KZsBp!8DzFK7Qu@P9$@KiT1*%>Jr+4Hmop84mwC!T%+}e=hsm_dn*azkU5U
zu|YPG$SaQgE8@)m1xNm=`{@3|_IpLh|8GbB)$DJ7{$S^y+D`8Ox;XRisq|9+mkas7
zCgfkr{&xE(j@Atw*8WwF{IggeHhvy*<iAG9pXO3C{!F>wJMu4Q|FHJ&to{K&6&thv
zRmGYA;Yu&He*%5knOboCye;HEp8f6iuVw$R_FwAAKjEyvzW(}!-io%L*}mP8|7aoq
zbwd6hIr2|q|FHIN)n0D@;yCl)PwA!huN3lsN63E=``hhb!Tx+3t7)!CLj5!Sq}Y*v
z73=MIGk#4m=R5M>%=w%7pN=2&`wK>I#{W`B{?&2jzn1m(`>)SgKi4G6Ydxx?@C`@)
zZT8cV%Q=+t|4_((Pu0K*$GrcWaJCk9j#>rJZ2u-oFZF*l`(yikB>2;P%98&z>|Ye(
z-{0Y1$Nr|DsQ#Y_{uep?x3hoP`<GW7`WENt#Q8Sl`dZlS_ktt;<_S6y^Z#7Pe?Mg)
zwO<nZ=hi#xC$@hJrI-3Ik^OQ0tQGvvarj@u{`n#PXE^*P3;r7g|K$$<I`%jDn>6hD
z-{bJFVt*XJ^!?xV{{OqfKXr_D<hN1AKIZz_&kp}uq5gDBvhAO7nB4#K**~S;SwFGs
zzrdldW_{T8qpuzMpIQHSi2s*LFO9z>`m#^8EN4CKzuyV<@0Tdof7!WO_z>&O%C3JO
zrI-9`*uRX0<iADmuTXl0W9HASv0A9Qx4~ljUz;fVXVRCIss;D|9|ivpm0t3n5~u&W
zN-xzvNARaxTI})H_HfyMKKma)m4L;r|5%59DeJ@L-(?PcRh;^*4*e^v4?F&Tr}R?$
zm2vyw_@!GS?DjjRquhR(<8-5i9e<BhddWYLzN}U)IDh>v_~$$Pr?7vaPNV)&ms-CW
z$#M8+u|JMq`bgKV|5Atl$Lt^0|6e)uTUdW+G}Yjloqw$(|H(rB^pT*Qe-Cw^y}~j3
ze~TP#oU2#$kGB7@N-y<aIs0d_lI9=!NW}KP#Nl6<qlIC|-<b~oHG)4Kylnrs9scjK
zzsaAg5p(=|-Ql0mO1Bh_UwV&V`?u>Pw|_fs_^{(|Yo(XkKaKrO{?z_W1^>wo|0(Pr
zcKm(Dp}(8;-A%*sTDM9R?scSG|Mjd7JN`CRda3^Nxc<x8it1076z%pO=kT99UJJvH
zzh^uAlUwVW;_;U*Dcb%|IQ)C$Y5%bO{}G4(a`wmhi!Q0z{(m_9v*Pss)!|<)_|scb
z+rOVWK<uWfYQKM+!v0~$-^(2Oa@L2<zi&A7H^r$x;3zr&Wvrje<Ik-0s4!cR$UaIh
zjo%I2e#<$O#xG52cKe;;@IPjP7OLtsSZx1HhkrSJ*}7VA{-Ts@|9KAoEcTz=z&-Z!
z&nq1MRqT)B_h7;QWrzPt_7Cg-=1Fq@y~X;l{cm@rZ>s8;W;N^@A%FV)ExY|rcld8+
zf1U>GThX$KWI6n6**}w&G=AC({&zY2PtMmuUOD|2JN%QVv($qA^!+c*xg^uCKRW!Y
z*x2Y<7IXalR_UeoFJ^xnzlnl>|D)yp-_HJF$KO<?m;5V*`gaukuXXqjpQvjbcKrR=
zp)Y5B*zvcky1**UzmKy%?D%_>(o6N<%=KT+9Y^D@vrzxb9sUz0X<^v$_hN^CMH^+N
z7CinY3H~2A{1YZ?|FHf49fyDOw%Xr}bE-f6{z7wIZ2kM<4(bBE)c)P#^lzi|Qu`+g
z{#^zCaSs3C>>qagUFOh_WqsKE`<+8y9H+ilSGoNzXMIO%Tv&9kL_xCBOYN7+?N`B}
z)PLQD_Pfa8zpOwD!|MO8L;p1E!^U5iW99m<XZ`2Vss_*O`gc}(ss3xY{>!2My`=g(
z{2xD03r`C1pW*N?rh}zgaR2Ee_}}mF|07QSyB+@X1pmH*|2q!<LFem=A09IP);jzv
z*&oLr{r*F9U2J{39NbOr{|SXUFl_uyap-5TK5YEG;m|K&ec1S;|Fe|FU-BWk|8e}$
z?=QsE|2Vn+B}KaaVdL)rrI-9Sus@E!fr9^FhyQcz-yx*`2RQue*dP0Uu;72S!+*n+
z`1-%rq5qEcVg27%onT4FujW&=e^~#gD81DF<#e*D7VQ6%r20Gjzh?h_A?-iM;h#i5
z_N<n=;8EXyM!)}HkH2*e|Be@EA$?~6F1pkxdDG$FhEA5%QXM>MfBO9f+rM3Rx%~@E
zwD2_6o0aXK@6f-<db;NW7h9jB^iuzA5b_@(<o}?<e@>}(rQa;a#rD6~;lGf6EL$xV
zET-dkmf-)B!+*_mEgZ&rv$FlSIQ*07&4yZXf=AtdBL)A|9&-P+nxTcKH{$|$W&8J3
zda3>Av41fOsQ%f4|J4rv^DfecVe{u4hyQkZv!fQAKhF^SpK|y=9;bhm!$0AOSbzGi
zH+%p2*x~;N`!CkbQ2(e)t>26^>nZo&t+RDZ&yevOQF^KWk~sfNwxa$!N65dI!~d;|
zwXlDPf3m~BnEi47J6G_Z<?wHQsrIMuEWyQYzv&MDoK8Bjn#ENAaf1Kr4*%?OEj*3&
zW@Y>Duiju&iuU!#`^vRqbx8g#m0s$<#3Qv+wJs*Oe|fx+{}~Sd^Dfsy`pzF*bg5Bt
zn!~@A{c--AAowqF_&;)m_6VE*7CQWk>CL`ca)L)a|4kJ9H#z+OVE?fB?+b^24g2H#
zH(BuS)l2UGtgCh6Ve?<I(o6lHcC@ZP&VT0#{<#kSg>m|iarloG{0jyDxeotY_Fu^T
zXI8paW-AhT%%Ly4M#s=^7UE*-S2*%7=KOK~n=0i0rNe*uwc7Rg5dTjd{wvuZ=f4XC
z|IWST@w0Kh_7D61fy0$v8b8bFVv$;^gGaspOcVS|9R5kyYvHM^H!EGL*@{G7aOlfe
z|8z+Et#sr+nZDRnE!DxJ&VPoGf0I6P`*q`qEA0IJZ-;*pUF=c|&VOZs|4@hjc{l3B
z!{)zqrI-3|CHv>-VuJa9mf&CE@PC^9Q$x=Gu66jgIab#n=fBy4|ECWBA8*x(^EAM<
zi2eMgNvhm`Ww&XG>YfIR&MJzAI`ogQerq%|cxLO<m0oK9dB^F<WY*L9L%I61&;MpP
z{Fg4&!rr?#Ou+WPz~R4={c~7P{+A2>pE~^4-=TePZfGB|{Xca0x9O=PvHo)e|J1&6
z|4rr--}Dgwo=PvZf2QC+SMa~W;lG0Y!~XyM5{G{o`)}a<sr}~({@*zK*Duk+(?jOJ
zjSl~;6lJECoZwN<f7b~92OKZA|1o!Jq3YfSi!L>a&T{C-v;OO7Xz<L|XDhwbe^s16
zj-Ts<{O3CSGb^=mpOF3MGKYVyX+PM1ZV>#pIQ+}+(f(ok&o>VLv{c<vSpORZ|I8EQ
z{%f^N`-km6gOy%t|6;-aX2JhvhyQ5y58HpPclcMbKkh%b2>!o2{LAmv^{4NQ#6`Di
zl>F@QFQbd?YRL&6_5O34;NP*I-2UtC(?a$3u)$*c7dZ4y?$@$c8>nNCe-o5m>c0(~
ze;d}*{If{N|5k_p>+GMx<KLuV=YONazs|HD>&bty;QyDy|BnZ?W7z)lyTd=Lzs?l*
zpQVET=>Bs5UH_2w58Ho6DZSMG<$`~u;D3+9|6TSE+kcii{Hxd>_n*53|0V<E`v0*)
z*Z&mL@x0cp8iidQ`pk!Q%>L2P;F+x->(HOg`nnK(r9*%6BU*T9h<=?zKbiH3A^Kk(
z`gyDm`~0^~>80^AZ-8zo?7s(u{_Aw2+<y-~suO=bB>%&dUh>bO54+TY?|&Z>{6{(b
zi>tKpO?p-Ts7tNijL`R7N&d^(ALp-!1^<~2|0a)VkFfWj%N_cWtf&9^#>LM69!LJw
zoPRZoY5uDc@^6+V_g{-Av~UFL&C2#a&Y>U8`mp^k*P%a;_3Mo>uWkQ(9QpxIYC+ik
z_l`q9hV_TBuUXmt+a3DZtPlJA^B1L;#$S1wcEbJd8HMckZ$}N3`)|=xI^)+&;=H!=
z@2K>W|7iNKS1q{zJuCR1;qcFSS{qjARsEywf11O;lKpZ2dtUIL?eMQ-|Ezjv{lxZv
z$e~YrM#qQkfA=}^U&;Abvp?;BFADiLA0+qR_LW*Vl=Wt1=ikGjAM~tNgzbM59Qth5
zKWB`2ZTsKn(C^E_u>EhnL*JG4?L++kbm%i#zyEFx3$XM5P3fiaUp7cb;{NxVLiYZ5
z%wW0y&VF9|zTD70=K95vN-z0m(ajEO!Ts+I!T&6WfBRM1c&=X6Kk8EJHzU~&|Ap+2
z``?>_|D_K9yV*bN`r#uE{g12<+y5SL<X^@4S94Wq|642MpO7y1-+eD?VfScL1<&mE
z+gs_S{wq$`k=TCg1pj^x{|)T_ZHRv#hyOhG$MI7m_!m0-UwJ9M`cHEB*9i50SMXox
z@ZZM%{|Tx8%?|&~LjBhZ{%aim8>-{0|EmuF<P2q|7VQ5I1pjRg{}w!PysFcvf7GSc
zZ$`E{{4?1<nL}y(ZxH-DW$5w0yH#)v`zJ)Lf@fy_Gx#v2Z>l!<bj9FEnc)Ai;GfC<
zO)URf_CK(`ME%6hr;zpa6EnweXZ`-_`XnxP{*z4p7^I#r=lrYQ(=Sl_eJ12z=I~GW
zQ|sF7-mqZX|5}GW=^w3odAA+w=Q{Eq-Buf?9jx_~f31-JoeuxH|7jh63|F6ooj-lg
zXwd)l5&Fr(WbNO)t==a8je`G^4*$d^y5fKD*RWvQ|51m3<xuUP)Gq43N${^`|75G+
zMEbE(wLI2Z>&>GHGu`sGL%-oD9dV!u<N|DcE$i+5uZ}Ogn0VXYY=2_vuj+=&8v0>B
zwcz}-S*U-@A$tEe^Mom5JNw)FpQ(;nw`RT3nf2aBn+QYn+NMV;{hsP2EB#0U>+QVk
z_UO<4wmyyZX&oE-+xk?cm&R``w_idBt*7z(gZeXi)2>t>+nW^SeB)2e0Ijc6LG)R?
pt=~(%tb0nwna3>pvShWi&N4)=?e?Sddr4ncuIUI>KU{46{{d-py;A@H

literal 0
HcmV?d00001

diff --git a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o.d b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o.d
new file mode 100644
index 000000000..2d4217a77
--- /dev/null
+++ b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o.d
@@ -0,0 +1,50 @@
+contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o: \
+ /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML/irrXML.cpp \
+ /usr/include/stdc-predef.h \
+ /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML/irrXML.h \
+ /usr/include/stdio.h /usr/include/bits/libc-header-start.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/wordsize.h /usr/include/bits/long-double.h \
+ /usr/include/gnu/stubs.h /usr/include/gnu/stubs-64.h \
+ /usr/lib/gcc/x86_64-pc-linux-gnu/11.1.0/include/stddef.h \
+ /usr/lib/gcc/x86_64-pc-linux-gnu/11.1.0/include/stdarg.h \
+ /usr/include/bits/types.h /usr/include/bits/timesize.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/time64.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__mbstate_t.h \
+ /usr/include/bits/types/__fpos64_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML/irrString.h \
+ /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML/irrTypes.h \
+ /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML/irrArray.h \
+ /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML/heapsort.h \
+ /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML/CXMLReaderImpl.h \
+ /usr/include/c++/11.1.0/cassert \
+ /usr/include/c++/11.1.0/x86_64-pc-linux-gnu/bits/c++config.h \
+ /usr/include/c++/11.1.0/x86_64-pc-linux-gnu/bits/os_defines.h \
+ /usr/include/c++/11.1.0/x86_64-pc-linux-gnu/bits/cpu_defines.h \
+ /usr/include/assert.h /usr/include/c++/11.1.0/stdlib.h \
+ /usr/include/c++/11.1.0/cstdlib /usr/include/stdlib.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/endianness.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h /usr/include/sys/select.h \
+ /usr/include/bits/select.h /usr/include/bits/types/sigset_t.h \
+ /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/struct_mutex.h \
+ /usr/include/bits/struct_rwlock.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/11.1.0/bits/std_abs.h \
+ /usr/include/c++/11.1.0/cctype /usr/include/ctype.h \
+ /usr/include/c++/11.1.0/cstdint \
+ /usr/lib/gcc/x86_64-pc-linux-gnu/11.1.0/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/wchar.h \
+ /usr/include/bits/stdint-uintn.h
diff --git a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/link.txt b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/link.txt
new file mode 100644
index 000000000..349d378be
--- /dev/null
+++ b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/link.txt
@@ -0,0 +1,2 @@
+/usr/bin/ar qc ../../lib/libIrrXML.a CMakeFiles/IrrXML.dir/irrXML.cpp.o
+/usr/bin/ranlib ../../lib/libIrrXML.a
diff --git a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/progress.make b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/progress.make
new file mode 100644
index 000000000..6c287f17b
--- /dev/null
+++ b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/progress.make
@@ -0,0 +1,3 @@
+CMAKE_PROGRESS_1 = 
+CMAKE_PROGRESS_2 = 
+
diff --git a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/progress.marks b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/progress.marks
new file mode 100644
index 000000000..573541ac9
--- /dev/null
+++ b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/progress.marks
@@ -0,0 +1 @@
+0
diff --git a/Engine/lib/assimp/contrib/irrXML/CXMLReaderImpl.h b/Engine/lib/assimp/contrib/irrXML/CXMLReaderImpl.h
index a125312a1..6f3bec5fa 100644
--- a/Engine/lib/assimp/contrib/irrXML/CXMLReaderImpl.h
+++ b/Engine/lib/assimp/contrib/irrXML/CXMLReaderImpl.h
@@ -15,9 +15,6 @@
 #include <cstdint>
 //using namespace Assimp;
 
-// For locale independent number conversion
-#include <sstream>
-#include <locale>
 
 #ifdef _DEBUG
 #define IRR_DEBUGPRINT(x) printf((x));
@@ -181,11 +178,8 @@ public:
 			return 0;
 
 		core::stringc c = attrvalue;
-		std::istringstream sstr(c.c_str());
-		sstr.imbue(std::locale("C")); // Locale free number convert
-		float fNum;
-		sstr >> fNum;
-		return fNum;
+        return static_cast<float>(atof(c.c_str()));
+		//return fast_atof(c.c_str());
 	}
 
 
diff --git a/Engine/lib/assimp/contrib/irrXML/Makefile b/Engine/lib/assimp/contrib/irrXML/Makefile
new file mode 100644
index 000000000..d428de0c4
--- /dev/null
+++ b/Engine/lib/assimp/contrib/irrXML/Makefile
@@ -0,0 +1,231 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.21
+
+# Default target executed when no arguments are given to make.
+default_target: all
+.PHONY : default_target
+
+# Allow only one "make -f Makefile2" at a time, but pass parallelism.
+.NOTPARALLEL:
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /usr/bin/cmake
+
+# The command to remove a file.
+RM = /usr/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /home/ragora/Downloads/assimp-5.0.1
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /home/ragora/Downloads/assimp-5.0.1
+
+#=============================================================================
+# Targets provided globally by CMake.
+
+# Special rule for the target install/local
+install/local: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Installing only the local directory..."
+	/usr/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
+.PHONY : install/local
+
+# Special rule for the target install/local
+install/local/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Installing only the local directory..."
+	/usr/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
+.PHONY : install/local/fast
+
+# Special rule for the target install
+install: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Install the project..."
+	/usr/bin/cmake -P cmake_install.cmake
+.PHONY : install
+
+# Special rule for the target install
+install/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Install the project..."
+	/usr/bin/cmake -P cmake_install.cmake
+.PHONY : install/fast
+
+# Special rule for the target list_install_components
+list_install_components:
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Available install components are: \"Unspecified\" \"assimp-bin\" \"assimp-dev\" \"libassimp5.0.0-dev\""
+.PHONY : list_install_components
+
+# Special rule for the target list_install_components
+list_install_components/fast: list_install_components
+.PHONY : list_install_components/fast
+
+# Special rule for the target rebuild_cache
+rebuild_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running CMake to regenerate build system..."
+	/usr/bin/cmake --regenerate-during-build -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
+.PHONY : rebuild_cache
+
+# Special rule for the target rebuild_cache
+rebuild_cache/fast: rebuild_cache
+.PHONY : rebuild_cache/fast
+
+# Special rule for the target edit_cache
+edit_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running CMake cache editor..."
+	/usr/bin/ccmake -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
+.PHONY : edit_cache
+
+# Special rule for the target edit_cache
+edit_cache/fast: edit_cache
+.PHONY : edit_cache/fast
+
+# Special rule for the target install/strip
+install/strip: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Installing the project stripped..."
+	/usr/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
+.PHONY : install/strip
+
+# Special rule for the target install/strip
+install/strip/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Installing the project stripped..."
+	/usr/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
+.PHONY : install/strip/fast
+
+# The main all target
+all: cmake_check_build_system
+	cd /home/ragora/Downloads/assimp-5.0.1 && $(CMAKE_COMMAND) -E cmake_progress_start /home/ragora/Downloads/assimp-5.0.1/CMakeFiles /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML//CMakeFiles/progress.marks
+	cd /home/ragora/Downloads/assimp-5.0.1 && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 contrib/irrXML/all
+	$(CMAKE_COMMAND) -E cmake_progress_start /home/ragora/Downloads/assimp-5.0.1/CMakeFiles 0
+.PHONY : all
+
+# The main clean target
+clean:
+	cd /home/ragora/Downloads/assimp-5.0.1 && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 contrib/irrXML/clean
+.PHONY : clean
+
+# The main clean target
+clean/fast: clean
+.PHONY : clean/fast
+
+# Prepare targets for installation.
+preinstall: all
+	cd /home/ragora/Downloads/assimp-5.0.1 && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 contrib/irrXML/preinstall
+.PHONY : preinstall
+
+# Prepare targets for installation.
+preinstall/fast:
+	cd /home/ragora/Downloads/assimp-5.0.1 && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 contrib/irrXML/preinstall
+.PHONY : preinstall/fast
+
+# clear depends
+depend:
+	cd /home/ragora/Downloads/assimp-5.0.1 && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1
+.PHONY : depend
+
+# Convenience name for target.
+contrib/irrXML/CMakeFiles/IrrXML.dir/rule:
+	cd /home/ragora/Downloads/assimp-5.0.1 && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 contrib/irrXML/CMakeFiles/IrrXML.dir/rule
+.PHONY : contrib/irrXML/CMakeFiles/IrrXML.dir/rule
+
+# Convenience name for target.
+IrrXML: contrib/irrXML/CMakeFiles/IrrXML.dir/rule
+.PHONY : IrrXML
+
+# fast build rule for target.
+IrrXML/fast:
+	cd /home/ragora/Downloads/assimp-5.0.1 && $(MAKE) $(MAKESILENT) -f contrib/irrXML/CMakeFiles/IrrXML.dir/build.make contrib/irrXML/CMakeFiles/IrrXML.dir/build
+.PHONY : IrrXML/fast
+
+irrXML.o: irrXML.cpp.o
+.PHONY : irrXML.o
+
+# target to build an object file
+irrXML.cpp.o:
+	cd /home/ragora/Downloads/assimp-5.0.1 && $(MAKE) $(MAKESILENT) -f contrib/irrXML/CMakeFiles/IrrXML.dir/build.make contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o
+.PHONY : irrXML.cpp.o
+
+irrXML.i: irrXML.cpp.i
+.PHONY : irrXML.i
+
+# target to preprocess a source file
+irrXML.cpp.i:
+	cd /home/ragora/Downloads/assimp-5.0.1 && $(MAKE) $(MAKESILENT) -f contrib/irrXML/CMakeFiles/IrrXML.dir/build.make contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.i
+.PHONY : irrXML.cpp.i
+
+irrXML.s: irrXML.cpp.s
+.PHONY : irrXML.s
+
+# target to generate assembly for a file
+irrXML.cpp.s:
+	cd /home/ragora/Downloads/assimp-5.0.1 && $(MAKE) $(MAKESILENT) -f contrib/irrXML/CMakeFiles/IrrXML.dir/build.make contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.s
+.PHONY : irrXML.cpp.s
+
+# Help Target
+help:
+	@echo "The following are some of the valid targets for this Makefile:"
+	@echo "... all (the default if no target is provided)"
+	@echo "... clean"
+	@echo "... depend"
+	@echo "... edit_cache"
+	@echo "... install"
+	@echo "... install/local"
+	@echo "... install/strip"
+	@echo "... list_install_components"
+	@echo "... rebuild_cache"
+	@echo "... IrrXML"
+	@echo "... irrXML.o"
+	@echo "... irrXML.i"
+	@echo "... irrXML.s"
+.PHONY : help
+
+
+
+#=============================================================================
+# Special targets to cleanup operation of make.
+
+# Special rule to run CMake to check the build system integrity.
+# No rule that depends on this can have commands that come from listfiles
+# because they might be regenerated.
+cmake_check_build_system:
+	cd /home/ragora/Downloads/assimp-5.0.1 && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
+.PHONY : cmake_check_build_system
+
diff --git a/Engine/lib/assimp/contrib/irrXML/cmake_install.cmake b/Engine/lib/assimp/contrib/irrXML/cmake_install.cmake
new file mode 100644
index 000000000..bb0122a18
--- /dev/null
+++ b/Engine/lib/assimp/contrib/irrXML/cmake_install.cmake
@@ -0,0 +1,48 @@
+# Install script for directory: /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML
+
+# Set the install prefix
+if(NOT DEFINED CMAKE_INSTALL_PREFIX)
+  set(CMAKE_INSTALL_PREFIX "/usr/local")
+endif()
+string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+
+# Set the install configuration name.
+if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
+  if(BUILD_TYPE)
+    string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
+           CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
+  else()
+    set(CMAKE_INSTALL_CONFIG_NAME "")
+  endif()
+  message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
+endif()
+
+# Set the component getting installed.
+if(NOT CMAKE_INSTALL_COMPONENT)
+  if(COMPONENT)
+    message(STATUS "Install component: \"${COMPONENT}\"")
+    set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
+  else()
+    set(CMAKE_INSTALL_COMPONENT)
+  endif()
+endif()
+
+# Install shared libraries without execute permission?
+if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE)
+  set(CMAKE_INSTALL_SO_NO_EXE "0")
+endif()
+
+# Is this installation the result of a crosscompile?
+if(NOT DEFINED CMAKE_CROSSCOMPILING)
+  set(CMAKE_CROSSCOMPILING "FALSE")
+endif()
+
+# Set default install directory permissions.
+if(NOT DEFINED CMAKE_OBJDUMP)
+  set(CMAKE_OBJDUMP "/usr/bin/objdump")
+endif()
+
+if("x${CMAKE_INSTALL_COMPONENT}x" STREQUAL "xUnspecifiedx" OR NOT CMAKE_INSTALL_COMPONENT)
+  file(INSTALL DESTINATION "${CMAKE_INSTALL_PREFIX}/lib" TYPE STATIC_LIBRARY FILES "/home/ragora/Downloads/assimp-5.0.1/lib/libIrrXML.a")
+endif()
+
diff --git a/Engine/lib/assimp/contrib/zip/.gitignore b/Engine/lib/assimp/contrib/zip/.gitignore
deleted file mode 100644
index a7904a1ef..000000000
--- a/Engine/lib/assimp/contrib/zip/.gitignore
+++ /dev/null
@@ -1,56 +0,0 @@
-/build/
-/test/build/
-/xcodeproj/
-
-# Object files
-*.o
-*.ko
-*.obj
-*.elf
-
-# Precompiled Headers
-*.gch
-*.pch
-
-# Libraries
-*.lib
-*.a
-*.la
-*.lo
-
-# Shared objects (inc. Windows DLLs)
-*.dll
-*.so
-*.so.*
-*.dylib
-*.suo
-
-# Executables
-*.exe
-*.out
-*.app
-*.i*86
-*.x86_64
-*.hex
-
-# Temporary
-*.swp
-.DS_Store
-
-# CMake
-CMakeScripts
-*.cmake
-
-# Xcode
-*.build
-*.xcodeproj
-zip.sln
-zip.vcxproj.filters
-zip.vcxproj
-ALL_BUILD.vcxproj.filters
-ALL_BUILD.vcxproj
-CMakeFiles/
-zip.dir/
-test/test.exe.vcxproj.filters
-test/test.exe.vcxproj
-test/test.exe.dir/
diff --git a/Engine/lib/assimp/contrib/zip/.travis.sh b/Engine/lib/assimp/contrib/zip/.travis.sh
old mode 100644
new mode 100755
diff --git a/Engine/lib/assimp/contrib/zip/CMakeLists.txt b/Engine/lib/assimp/contrib/zip/CMakeLists.txt
index f194649ed..b46dbb1db 100644
--- a/Engine/lib/assimp/contrib/zip/CMakeLists.txt
+++ b/Engine/lib/assimp/contrib/zip/CMakeLists.txt
@@ -1,14 +1,10 @@
-cmake_minimum_required(VERSION 3.0)
-
-project(zip
-  LANGUAGES C
-  VERSION "0.1.18")
+cmake_minimum_required(VERSION 2.8)
+project(zip)
+enable_language(C)
 set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
 
-option(CMAKE_DISABLE_TESTING "Disable test creation" OFF)
-
 if (MSVC)
-  # Use secure functions by default and suppress warnings about "deprecated" functions
+  # Use secure functions by defaualt and suppress warnings about "deprecated" functions
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /D _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES=1")
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /D _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT=1")
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /D _CRT_NONSTDC_NO_WARNINGS=1 /D _CRT_SECURE_NO_WARNINGS=1")
@@ -21,71 +17,23 @@ endif (MSVC)
 # zip
 set(SRC src/miniz.h src/zip.h src/zip.c)
 add_library(${PROJECT_NAME} ${SRC})
-target_include_directories(${PROJECT_NAME} PUBLIC
-  $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
-  $<INSTALL_INTERFACE:include>
-)
+target_include_directories(${PROJECT_NAME} INTERFACE src)
 
 # test
 if (NOT CMAKE_DISABLE_TESTING)
   enable_testing()
   add_subdirectory(test)
   find_package(Sanitizers)
-  add_sanitizers(${PROJECT_NAME} ${test_out})
+  add_sanitizers(${PROJECT_NAME} test.exe)
+  add_sanitizers(${PROJECT_NAME} test_miniz.exe)
 endif()
 
-####
-# Installation (https://github.com/forexample/package-example) {
-
-set(CONFIG_INSTALL_DIR "lib/cmake/${PROJECT_NAME}")
-set(INCLUDE_INSTALL_DIR "include")
-
-set(GENERATED_DIR "${CMAKE_CURRENT_BINARY_DIR}/generated")
-
-# Configuration
-set(VERSION_CONFIG "${GENERATED_DIR}/${PROJECT_NAME}ConfigVersion.cmake")
-set(PROJECT_CONFIG "${GENERATED_DIR}/${PROJECT_NAME}Config.cmake")
-set(TARGETS_EXPORT_NAME "${PROJECT_NAME}Targets")
-set(NAMESPACE "${PROJECT_NAME}::")
-
-# Include module with fuction 'write_basic_package_version_file'
-include(CMakePackageConfigHelpers)
-
-# Note: PROJECT_VERSION is used as a VERSION
-write_basic_package_version_file(
-    "${VERSION_CONFIG}" COMPATIBILITY SameMajorVersion
-)
-
-# Use variables:
-#   * TARGETS_EXPORT_NAME
-#   * PROJECT_NAME
-configure_package_config_file(
-    "cmake/Config.cmake.in"
-    "${PROJECT_CONFIG}"
-    INSTALL_DESTINATION "${CONFIG_INSTALL_DIR}"
-)
-
-install(
-    FILES "${PROJECT_CONFIG}" "${VERSION_CONFIG}"
-    DESTINATION "${CONFIG_INSTALL_DIR}"
-)
-
-install(
-    EXPORT "${TARGETS_EXPORT_NAME}"
-    NAMESPACE "${NAMESPACE}"
-    DESTINATION "${CONFIG_INSTALL_DIR}"
-)
-
-# }
-
 install(TARGETS ${PROJECT_NAME}
-        EXPORT ${TARGETS_EXPORT_NAME}
         RUNTIME DESTINATION bin
         ARCHIVE DESTINATION lib
         LIBRARY DESTINATION lib
-        INCLUDES DESTINATION ${INCLUDE_INSTALL_DIR}
-)
-install(FILES ${PROJECT_SOURCE_DIR}/src/zip.h DESTINATION ${INCLUDE_INSTALL_DIR}/zip)
+        COMPONENT library)
+install(FILES ${PROJECT_SOURCE_DIR}/src/zip.h DESTINATION include)
 
 # uninstall target (https://gitlab.kitware.com/cmake/community/wikis/FAQ#can-i-do-make-uninstall-with-cmake)
 if(NOT TARGET uninstall)
@@ -97,12 +45,3 @@ if(NOT TARGET uninstall)
     add_custom_target(uninstall
         COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake/cmake_uninstall.cmake)
 endif()
-
-find_package(Doxygen)
-if(DOXYGEN_FOUND)
-    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile @ONLY)
-    add_custom_target(doc
-        ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
-        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-        COMMENT "Generating API documentation with Doxygen" VERBATIM)
-endif()
diff --git a/Engine/lib/assimp/contrib/zip/README.md b/Engine/lib/assimp/contrib/zip/README.md
index bdd0822b6..d5fb8cd20 100644
--- a/Engine/lib/assimp/contrib/zip/README.md
+++ b/Engine/lib/assimp/contrib/zip/README.md
@@ -1,8 +1,10 @@
 ### A portable (OSX/Linux/Windows), simple zip library written in C
 This is done by hacking awesome [miniz](https://code.google.com/p/miniz) library and layering functions on top of the miniz v1.15 API.
 
-[![Build](https://github.com/kuba--/zip/workflows/build/badge.svg)](https://github.com/kuba--/zip/actions?query=workflow%3Abuild)
+[![Windows](https://ci.appveyor.com/api/projects/status/bph8dr3jacgmjv32/branch/master?svg=true&label=windows)](https://ci.appveyor.com/project/kuba--/zip)
+[![Linux](https://travis-ci.org/kuba--/zip.svg?branch=master&label=linux%2fosx)](https://travis-ci.org/kuba--/zip)
 [![Version](https://badge.fury.io/gh/kuba--%2Fzip.svg)](https://github.com/kuba--/zip/releases)
+[![Codecov](https://codecov.io/gh/kuba--/zip/branch/master/graph/badge.svg)](https://codecov.io/gh/kuba--/zip)
 
 
 # The Idea
@@ -69,7 +71,7 @@ int arg = 2;
 zip_extract("foo.zip", "/tmp", on_extract_entry, &arg);
 ```
 
-* Extract a zip entry into memory.
+*   Extract a zip entry into memory.
 ```c
 void *buf = NULL;
 size_t bufsize;
@@ -87,7 +89,7 @@ zip_close(zip);
 free(buf);
 ```
 
-* Extract a zip entry into memory (no internal allocation).
+*   Extract a zip entry into memory (no internal allocation).
 ```c
 unsigned char *buf;
 size_t bufsize;
@@ -108,7 +110,7 @@ zip_close(zip);
 free(buf);
 ```
 
-* Extract a zip entry into memory using callback.
+*   Extract a zip entry into memory using callback.
 ```c
 struct buffer_t {
     char *data;
@@ -142,7 +144,7 @@ free(buf.data);
 ```
 
 
-* Extract a zip entry into a file.
+*   Extract a zip entry into a file.
 ```c
 struct zip_t *zip = zip_open("foo.zip", 0, 'r');
 {
@@ -155,7 +157,7 @@ struct zip_t *zip = zip_open("foo.zip", 0, 'r');
 zip_close(zip);
 ```
 
-* List of all zip entries
+*   List of all zip entries
 ```c
 struct zip_t *zip = zip_open("foo.zip", 0, 'r');
 int i, n = zip_total_entries(zip);
@@ -172,7 +174,7 @@ for (i = 0; i < n; ++i) {
 zip_close(zip);
 ```
 
-# Bindings
+## Bindings
 Compile zip library as a dynamic library.
 ```shell
 $ mkdir build
@@ -211,53 +213,6 @@ func main() {
 }
 ```
 
-### Rust (ffi)
-```rust
-extern crate libc;
-use std::ffi::CString;
-
-#[repr(C)]
-pub struct Zip {
-    _private: [u8; 0],
-}
-
-#[link(name = "zip")]
-extern "C" {
-    fn zip_open(path: *const libc::c_char, level: libc::c_int, mode: libc::c_char) -> *mut Zip;
-    fn zip_close(zip: *mut Zip) -> libc::c_void;
-
-    fn zip_entry_open(zip: *mut Zip, entryname: *const libc::c_char) -> libc::c_int;
-    fn zip_entry_close(zip: *mut Zip) -> libc::c_int;
-    fn zip_entry_write(
-        zip: *mut Zip,
-        buf: *const libc::c_void,
-        bufsize: libc::size_t,
-    ) -> libc::c_int;
-}
-
-fn main() {
-    let path = CString::new("/tmp/test.zip").unwrap();
-    let mode: libc::c_char = 'w' as libc::c_char;
-
-    let entryname = CString::new("test.txt").unwrap();
-    let content = "test content\0";
-
-    unsafe {
-        let zip: *mut Zip = zip_open(path.as_ptr(), 5, mode);
-        {
-            zip_entry_open(zip, entryname.as_ptr());
-            {
-                let buf = content.as_ptr() as *const libc::c_void;
-                let bufsize = content.len() as libc::size_t;
-                zip_entry_write(zip, buf, bufsize);
-            }
-            zip_entry_close(zip);
-        }
-        zip_close(zip);
-    }
-}
-```
-
 ### Ruby (ffi)
 Install _ffi_ gem.
 ```shell
diff --git a/Engine/lib/assimp/contrib/zip/appveyor.yml b/Engine/lib/assimp/contrib/zip/appveyor.yml
deleted file mode 100644
index 0be6373ca..000000000
--- a/Engine/lib/assimp/contrib/zip/appveyor.yml
+++ /dev/null
@@ -1,14 +0,0 @@
-version: zip-0.1.9.{build}
-build_script:
-- cmd: >-
-    cd c:\projects\zip
-
-    mkdir build
-
-    cd build
-
-    cmake -G"Visual Studio 14" -DCMAKE_BUILD_TYPE=Debug ..
-
-    cmake --build . --config %CMAKE_BUILD_TYPE%
-
-    ctest --verbose -C "Debug"
diff --git a/Engine/lib/assimp/contrib/zip/cmake/asan-wrapper b/Engine/lib/assimp/contrib/zip/cmake/asan-wrapper
old mode 100644
new mode 100755
diff --git a/Engine/lib/assimp/contrib/zip/src/miniz.h b/Engine/lib/assimp/contrib/zip/src/miniz.h
index c4fcfb83e..2c27a94d8 100644
--- a/Engine/lib/assimp/contrib/zip/src/miniz.h
+++ b/Engine/lib/assimp/contrib/zip/src/miniz.h
@@ -221,7 +221,6 @@
 #ifndef MINIZ_HEADER_INCLUDED
 #define MINIZ_HEADER_INCLUDED
 
-#include <stdint.h>
 #include <stdlib.h>
 
 // Defines to completely disable specific portions of miniz.c:
@@ -285,8 +284,7 @@
 /* Set MINIZ_USE_UNALIGNED_LOADS_AND_STORES only if not set */
 #if !defined(MINIZ_USE_UNALIGNED_LOADS_AND_STORES)
 #if MINIZ_X86_OR_X64_CPU
-/* Set MINIZ_USE_UNALIGNED_LOADS_AND_STORES to 1 on CPU's that permit efficient
- * integer loads and stores from unaligned addresses. */
+/* Set MINIZ_USE_UNALIGNED_LOADS_AND_STORES to 1 on CPU's that permit efficient integer loads and stores from unaligned addresses. */
 #define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 1
 #define MINIZ_UNALIGNED_USE_MEMCPY
 #else
@@ -356,44 +354,6 @@ enum {
   MZ_FIXED = 4
 };
 
-/* miniz error codes. Be sure to update mz_zip_get_error_string() if you add or
- * modify this enum. */
-typedef enum {
-  MZ_ZIP_NO_ERROR = 0,
-  MZ_ZIP_UNDEFINED_ERROR,
-  MZ_ZIP_TOO_MANY_FILES,
-  MZ_ZIP_FILE_TOO_LARGE,
-  MZ_ZIP_UNSUPPORTED_METHOD,
-  MZ_ZIP_UNSUPPORTED_ENCRYPTION,
-  MZ_ZIP_UNSUPPORTED_FEATURE,
-  MZ_ZIP_FAILED_FINDING_CENTRAL_DIR,
-  MZ_ZIP_NOT_AN_ARCHIVE,
-  MZ_ZIP_INVALID_HEADER_OR_CORRUPTED,
-  MZ_ZIP_UNSUPPORTED_MULTIDISK,
-  MZ_ZIP_DECOMPRESSION_FAILED,
-  MZ_ZIP_COMPRESSION_FAILED,
-  MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE,
-  MZ_ZIP_CRC_CHECK_FAILED,
-  MZ_ZIP_UNSUPPORTED_CDIR_SIZE,
-  MZ_ZIP_ALLOC_FAILED,
-  MZ_ZIP_FILE_OPEN_FAILED,
-  MZ_ZIP_FILE_CREATE_FAILED,
-  MZ_ZIP_FILE_WRITE_FAILED,
-  MZ_ZIP_FILE_READ_FAILED,
-  MZ_ZIP_FILE_CLOSE_FAILED,
-  MZ_ZIP_FILE_SEEK_FAILED,
-  MZ_ZIP_FILE_STAT_FAILED,
-  MZ_ZIP_INVALID_PARAMETER,
-  MZ_ZIP_INVALID_FILENAME,
-  MZ_ZIP_BUF_TOO_SMALL,
-  MZ_ZIP_INTERNAL_ERROR,
-  MZ_ZIP_FILE_NOT_FOUND,
-  MZ_ZIP_ARCHIVE_TOO_LARGE,
-  MZ_ZIP_VALIDATION_FAILED,
-  MZ_ZIP_WRITE_CALLBACK_FAILED,
-  MZ_ZIP_TOTAL_ERRORS
-} mz_zip_error;
-
 // Method
 #define MZ_DEFLATED 8
 
@@ -736,7 +696,6 @@ typedef size_t (*mz_file_read_func)(void *pOpaque, mz_uint64 file_ofs,
                                     void *pBuf, size_t n);
 typedef size_t (*mz_file_write_func)(void *pOpaque, mz_uint64 file_ofs,
                                      const void *pBuf, size_t n);
-typedef mz_bool (*mz_file_needs_keepalive)(void *pOpaque);
 
 struct mz_zip_internal_state_tag;
 typedef struct mz_zip_internal_state_tag mz_zip_internal_state;
@@ -748,27 +707,13 @@ typedef enum {
   MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED = 3
 } mz_zip_mode;
 
-typedef enum {
-  MZ_ZIP_TYPE_INVALID = 0,
-  MZ_ZIP_TYPE_USER,
-  MZ_ZIP_TYPE_MEMORY,
-  MZ_ZIP_TYPE_HEAP,
-  MZ_ZIP_TYPE_FILE,
-  MZ_ZIP_TYPE_CFILE,
-  MZ_ZIP_TOTAL_TYPES
-} mz_zip_type;
-
-typedef struct {
+typedef struct mz_zip_archive_tag {
   mz_uint64 m_archive_size;
   mz_uint64 m_central_directory_file_ofs;
-
-  /* We only support up to UINT32_MAX files in zip64 mode. */
-  mz_uint32 m_total_files;
+  mz_uint m_total_files;
   mz_zip_mode m_zip_mode;
-  mz_zip_type m_zip_type;
-  mz_zip_error m_last_error;
 
-  mz_uint64 m_file_offset_alignment;
+  mz_uint m_file_offset_alignment;
 
   mz_alloc_func m_pAlloc;
   mz_free_func m_pFree;
@@ -777,7 +722,6 @@ typedef struct {
 
   mz_file_read_func m_pRead;
   mz_file_write_func m_pWrite;
-  mz_file_needs_keepalive m_pNeeds_keepalive;
   void *m_pIO_opaque;
 
   mz_zip_internal_state *m_pState;
@@ -1319,9 +1263,6 @@ mz_uint tdefl_create_comp_flags_from_zip_params(int level, int window_bits,
                                                 int strategy);
 #endif // #ifndef MINIZ_NO_ZLIB_APIS
 
-#define MZ_UINT16_MAX (0xFFFFU)
-#define MZ_UINT32_MAX (0xFFFFFFFFU)
-
 #ifdef __cplusplus
 }
 #endif
@@ -1370,11 +1311,6 @@ typedef unsigned char mz_validate_uint64[sizeof(mz_uint64) == 8 ? 1 : -1];
    ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
 #endif
 
-#define MZ_READ_LE64(p)                                                        \
-  (((mz_uint64)MZ_READ_LE32(p)) |                                              \
-   (((mz_uint64)MZ_READ_LE32((const mz_uint8 *)(p) + sizeof(mz_uint32)))       \
-    << 32U))
-
 #ifdef _MSC_VER
 #define MZ_FORCEINLINE __forceinline
 #elif defined(__GNUC__)
@@ -4224,17 +4160,6 @@ enum {
   MZ_ZIP_LOCAL_DIR_HEADER_SIZE = 30,
   MZ_ZIP_CENTRAL_DIR_HEADER_SIZE = 46,
   MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE = 22,
-
-  /* ZIP64 archive identifier and record sizes */
-  MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG = 0x06064b50,
-  MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG = 0x07064b50,
-  MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE = 56,
-  MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE = 20,
-  MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID = 0x0001,
-  MZ_ZIP_DATA_DESCRIPTOR_ID = 0x08074b50,
-  MZ_ZIP_DATA_DESCRIPTER_SIZE64 = 24,
-  MZ_ZIP_DATA_DESCRIPTER_SIZE32 = 16,
-
   // Central directory header record offsets
   MZ_ZIP_CDH_SIG_OFS = 0,
   MZ_ZIP_CDH_VERSION_MADE_BY_OFS = 4,
@@ -4274,31 +4199,6 @@ enum {
   MZ_ZIP_ECDH_CDIR_SIZE_OFS = 12,
   MZ_ZIP_ECDH_CDIR_OFS_OFS = 16,
   MZ_ZIP_ECDH_COMMENT_SIZE_OFS = 20,
-
-  /* ZIP64 End of central directory locator offsets */
-  MZ_ZIP64_ECDL_SIG_OFS = 0,                    /* 4 bytes */
-  MZ_ZIP64_ECDL_NUM_DISK_CDIR_OFS = 4,          /* 4 bytes */
-  MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS = 8,  /* 8 bytes */
-  MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS = 16, /* 4 bytes */
-
-  /* ZIP64 End of central directory header offsets */
-  MZ_ZIP64_ECDH_SIG_OFS = 0,                       /* 4 bytes */
-  MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS = 4,            /* 8 bytes */
-  MZ_ZIP64_ECDH_VERSION_MADE_BY_OFS = 12,          /* 2 bytes */
-  MZ_ZIP64_ECDH_VERSION_NEEDED_OFS = 14,           /* 2 bytes */
-  MZ_ZIP64_ECDH_NUM_THIS_DISK_OFS = 16,            /* 4 bytes */
-  MZ_ZIP64_ECDH_NUM_DISK_CDIR_OFS = 20,            /* 4 bytes */
-  MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS = 24, /* 8 bytes */
-  MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS = 32,       /* 8 bytes */
-  MZ_ZIP64_ECDH_CDIR_SIZE_OFS = 40,                /* 8 bytes */
-  MZ_ZIP64_ECDH_CDIR_OFS_OFS = 48,                 /* 8 bytes */
-  MZ_ZIP_VERSION_MADE_BY_DOS_FILESYSTEM_ID = 0,
-  MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG = 0x10,
-  MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED = 1,
-  MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG = 32,
-  MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION = 64,
-  MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_LOCAL_DIR_IS_MASKED = 8192,
-  MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8 = 1 << 11
 };
 
 typedef struct {
@@ -4311,24 +4211,7 @@ struct mz_zip_internal_state_tag {
   mz_zip_array m_central_dir;
   mz_zip_array m_central_dir_offsets;
   mz_zip_array m_sorted_central_dir_offsets;
-
-  /* The flags passed in when the archive is initially opened. */
-  uint32_t m_init_flags;
-
-  /* MZ_TRUE if the archive has a zip64 end of central directory headers, etc.
-   */
-  mz_bool m_zip64;
-
-  /* MZ_TRUE if we found zip64 extended info in the central directory (m_zip64
-   * will also be slammed to true too, even if we didn't find a zip64 end of
-   * central dir header, etc.) */
-  mz_bool m_zip64_has_extended_info_fields;
-
-  /* These fields are used by the file, FILE, memory, and memory/heap read/write
-   * helpers. */
   MZ_FILE *m_pFile;
-  mz_uint64 m_file_archive_start_ofs;
-
   void *m_pMem;
   size_t m_mem_size;
   size_t m_mem_capacity;
@@ -4480,13 +4363,6 @@ static mz_bool mz_zip_set_file_times(const char *pFilename, time_t access_time,
 #endif /* #ifndef MINIZ_NO_STDIO */
 #endif /* #ifndef MINIZ_NO_TIME */
 
-static MZ_FORCEINLINE mz_bool mz_zip_set_error(mz_zip_archive *pZip,
-                                               mz_zip_error err_num) {
-  if (pZip)
-    pZip->m_last_error = err_num;
-  return MZ_FALSE;
-}
-
 static mz_bool mz_zip_reader_init_internal(mz_zip_archive *pZip,
                                            mz_uint32 flags) {
   (void)flags;
@@ -4604,346 +4480,127 @@ mz_zip_reader_sort_central_dir_offsets_by_filename(mz_zip_archive *pZip) {
   }
 }
 
-static mz_bool mz_zip_reader_locate_header_sig(mz_zip_archive *pZip,
-                                               mz_uint32 record_sig,
-                                               mz_uint32 record_size,
-                                               mz_int64 *pOfs) {
+static mz_bool mz_zip_reader_read_central_dir(mz_zip_archive *pZip,
+                                              mz_uint32 flags) {
+  mz_uint cdir_size, num_this_disk, cdir_disk_index;
+  mz_uint64 cdir_ofs;
   mz_int64 cur_file_ofs;
+  const mz_uint8 *p;
   mz_uint32 buf_u32[4096 / sizeof(mz_uint32)];
   mz_uint8 *pBuf = (mz_uint8 *)buf_u32;
-
-  /* Basic sanity checks - reject files which are too small */
-  if (pZip->m_archive_size < record_size)
+  mz_bool sort_central_dir =
+      ((flags & MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY) == 0);
+  // Basic sanity checks - reject files which are too small, and check the first
+  // 4 bytes of the file to make sure a local header is there.
+  if (pZip->m_archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
     return MZ_FALSE;
-
-  /* Find the record by scanning the file from the end towards the beginning. */
+  // Find the end of central directory record by scanning the file from the end
+  // towards the beginning.
   cur_file_ofs =
       MZ_MAX((mz_int64)pZip->m_archive_size - (mz_int64)sizeof(buf_u32), 0);
   for (;;) {
     int i,
         n = (int)MZ_MIN(sizeof(buf_u32), pZip->m_archive_size - cur_file_ofs);
-
     if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, n) != (mz_uint)n)
       return MZ_FALSE;
-
-    for (i = n - 4; i >= 0; --i) {
-      mz_uint s = MZ_READ_LE32(pBuf + i);
-      if (s == record_sig) {
-        if ((pZip->m_archive_size - (cur_file_ofs + i)) >= record_size)
-          break;
-      }
-    }
-
+    for (i = n - 4; i >= 0; --i)
+      if (MZ_READ_LE32(pBuf + i) == MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG)
+        break;
     if (i >= 0) {
       cur_file_ofs += i;
       break;
     }
-
-    /* Give up if we've searched the entire file, or we've gone back "too far"
-     * (~64kb) */
     if ((!cur_file_ofs) || ((pZip->m_archive_size - cur_file_ofs) >=
-                            (MZ_UINT16_MAX + record_size)))
+                            (0xFFFF + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)))
       return MZ_FALSE;
-
     cur_file_ofs = MZ_MAX(cur_file_ofs - (sizeof(buf_u32) - 3), 0);
   }
-
-  *pOfs = cur_file_ofs;
-  return MZ_TRUE;
-}
-
-static mz_bool mz_zip_reader_read_central_dir(mz_zip_archive *pZip,
-                                              mz_uint flags) {
-  mz_uint cdir_size = 0, cdir_entries_on_this_disk = 0, num_this_disk = 0,
-          cdir_disk_index = 0;
-  mz_uint64 cdir_ofs = 0;
-  mz_int64 cur_file_ofs = 0;
-  const mz_uint8 *p;
-
-  mz_uint32 buf_u32[4096 / sizeof(mz_uint32)];
-  mz_uint8 *pBuf = (mz_uint8 *)buf_u32;
-  mz_bool sort_central_dir =
-      ((flags & MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY) == 0);
-  mz_uint32 zip64_end_of_central_dir_locator_u32
-      [(MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE + sizeof(mz_uint32) - 1) /
-       sizeof(mz_uint32)];
-  mz_uint8 *pZip64_locator = (mz_uint8 *)zip64_end_of_central_dir_locator_u32;
-
-  mz_uint32 zip64_end_of_central_dir_header_u32
-      [(MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) /
-       sizeof(mz_uint32)];
-  mz_uint8 *pZip64_end_of_central_dir =
-      (mz_uint8 *)zip64_end_of_central_dir_header_u32;
-
-  mz_uint64 zip64_end_of_central_dir_ofs = 0;
-
-  /* Basic sanity checks - reject files which are too small, and check the first
-   * 4 bytes of the file to make sure a local header is there. */
-  if (pZip->m_archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
-    return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
-
-  if (!mz_zip_reader_locate_header_sig(
-          pZip, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG,
-          MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE, &cur_file_ofs))
-    return mz_zip_set_error(pZip, MZ_ZIP_FAILED_FINDING_CENTRAL_DIR);
-
-  /* Read and verify the end of central directory record. */
+  // Read and verify the end of central directory record.
   if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf,
                     MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) !=
       MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
-    return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
+    return MZ_FALSE;
+  if ((MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_SIG_OFS) !=
+       MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG) ||
+      ((pZip->m_total_files =
+            MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS)) !=
+       MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS)))
+    return MZ_FALSE;
 
-  if (MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_SIG_OFS) !=
-      MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG)
-    return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
-
-  if (cur_file_ofs >= (MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE +
-                       MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE)) {
-    if (pZip->m_pRead(pZip->m_pIO_opaque,
-                      cur_file_ofs - MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE,
-                      pZip64_locator,
-                      MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) ==
-        MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) {
-      if (MZ_READ_LE32(pZip64_locator + MZ_ZIP64_ECDL_SIG_OFS) ==
-          MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG) {
-        zip64_end_of_central_dir_ofs = MZ_READ_LE64(
-            pZip64_locator + MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS);
-        if (zip64_end_of_central_dir_ofs >
-            (pZip->m_archive_size - MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE))
-          return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
-
-        if (pZip->m_pRead(pZip->m_pIO_opaque, zip64_end_of_central_dir_ofs,
-                          pZip64_end_of_central_dir,
-                          MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) ==
-            MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) {
-          if (MZ_READ_LE32(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_SIG_OFS) ==
-              MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG) {
-            pZip->m_pState->m_zip64 = MZ_TRUE;
-          }
-        }
-      }
-    }
-  }
-
-  pZip->m_total_files = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS);
-  cdir_entries_on_this_disk =
-      MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS);
   num_this_disk = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_NUM_THIS_DISK_OFS);
   cdir_disk_index = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_NUM_DISK_CDIR_OFS);
-  cdir_size = MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_SIZE_OFS);
-  cdir_ofs = MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_OFS_OFS);
-
-  if (pZip->m_pState->m_zip64) {
-    mz_uint32 zip64_total_num_of_disks =
-        MZ_READ_LE32(pZip64_locator + MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS);
-    mz_uint64 zip64_cdir_total_entries = MZ_READ_LE64(
-        pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS);
-    mz_uint64 zip64_cdir_total_entries_on_this_disk = MZ_READ_LE64(
-        pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS);
-    mz_uint64 zip64_size_of_end_of_central_dir_record = MZ_READ_LE64(
-        pZip64_end_of_central_dir + MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS);
-    mz_uint64 zip64_size_of_central_directory =
-        MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_SIZE_OFS);
-
-    if (zip64_size_of_end_of_central_dir_record <
-        (MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE - 12))
-      return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
-    if (zip64_total_num_of_disks != 1U)
-      return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK);
-
-    /* Check for miniz's practical limits */
-    if (zip64_cdir_total_entries > MZ_UINT32_MAX)
-      return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
-
-    pZip->m_total_files = (mz_uint32)zip64_cdir_total_entries;
-
-    if (zip64_cdir_total_entries_on_this_disk > MZ_UINT32_MAX)
-      return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
-
-    cdir_entries_on_this_disk =
-        (mz_uint32)zip64_cdir_total_entries_on_this_disk;
-
-    /* Check for miniz's current practical limits (sorry, this should be enough
-     * for millions of files) */
-    if (zip64_size_of_central_directory > MZ_UINT32_MAX)
-      return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE);
-
-    cdir_size = (mz_uint32)zip64_size_of_central_directory;
-
-    num_this_disk = MZ_READ_LE32(pZip64_end_of_central_dir +
-                                 MZ_ZIP64_ECDH_NUM_THIS_DISK_OFS);
-
-    cdir_disk_index = MZ_READ_LE32(pZip64_end_of_central_dir +
-                                   MZ_ZIP64_ECDH_NUM_DISK_CDIR_OFS);
-
-    cdir_ofs =
-        MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_OFS_OFS);
-  }
-
-  if (pZip->m_total_files != cdir_entries_on_this_disk)
-    return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK);
-
   if (((num_this_disk | cdir_disk_index) != 0) &&
       ((num_this_disk != 1) || (cdir_disk_index != 1)))
-    return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK);
+    return MZ_FALSE;
 
-  if (cdir_size < pZip->m_total_files * MZ_ZIP_CENTRAL_DIR_HEADER_SIZE)
-    return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
+  if ((cdir_size = MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_SIZE_OFS)) <
+      pZip->m_total_files * MZ_ZIP_CENTRAL_DIR_HEADER_SIZE)
+    return MZ_FALSE;
 
+  cdir_ofs = MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_OFS_OFS);
   if ((cdir_ofs + (mz_uint64)cdir_size) > pZip->m_archive_size)
-    return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
+    return MZ_FALSE;
 
   pZip->m_central_directory_file_ofs = cdir_ofs;
 
   if (pZip->m_total_files) {
     mz_uint i, n;
-    /* Read the entire central directory into a heap block, and allocate another
-     * heap block to hold the unsorted central dir file record offsets, and
-     * possibly another to hold the sorted indices. */
+
+    // Read the entire central directory into a heap block, and allocate another
+    // heap block to hold the unsorted central dir file record offsets, and
+    // another to hold the sorted indices.
     if ((!mz_zip_array_resize(pZip, &pZip->m_pState->m_central_dir, cdir_size,
                               MZ_FALSE)) ||
         (!mz_zip_array_resize(pZip, &pZip->m_pState->m_central_dir_offsets,
                               pZip->m_total_files, MZ_FALSE)))
-      return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
+      return MZ_FALSE;
 
     if (sort_central_dir) {
       if (!mz_zip_array_resize(pZip,
                                &pZip->m_pState->m_sorted_central_dir_offsets,
                                pZip->m_total_files, MZ_FALSE))
-        return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
+        return MZ_FALSE;
     }
 
     if (pZip->m_pRead(pZip->m_pIO_opaque, cdir_ofs,
                       pZip->m_pState->m_central_dir.m_p,
                       cdir_size) != cdir_size)
-      return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
+      return MZ_FALSE;
 
-    /* Now create an index into the central directory file records, do some
-     * basic sanity checking on each record */
+    // Now create an index into the central directory file records, do some
+    // basic sanity checking on each record, and check for zip64 entries (which
+    // are not yet supported).
     p = (const mz_uint8 *)pZip->m_pState->m_central_dir.m_p;
     for (n = cdir_size, i = 0; i < pZip->m_total_files; ++i) {
-      mz_uint total_header_size, disk_index, bit_flags, filename_size,
-          ext_data_size;
-      mz_uint64 comp_size, decomp_size, local_header_ofs;
-
+      mz_uint total_header_size, comp_size, decomp_size, disk_index;
       if ((n < MZ_ZIP_CENTRAL_DIR_HEADER_SIZE) ||
           (MZ_READ_LE32(p) != MZ_ZIP_CENTRAL_DIR_HEADER_SIG))
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
+        return MZ_FALSE;
       MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32,
                            i) =
           (mz_uint32)(p - (const mz_uint8 *)pZip->m_pState->m_central_dir.m_p);
-
       if (sort_central_dir)
         MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_sorted_central_dir_offsets,
                              mz_uint32, i) = i;
-
       comp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS);
       decomp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS);
-      local_header_ofs = MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS);
-      filename_size = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);
-      ext_data_size = MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS);
-
-      if ((!pZip->m_pState->m_zip64_has_extended_info_fields) &&
-          (ext_data_size) &&
-          (MZ_MAX(MZ_MAX(comp_size, decomp_size), local_header_ofs) ==
-           MZ_UINT32_MAX)) {
-        /* Attempt to find zip64 extended information field in the entry's extra
-         * data */
-        mz_uint32 extra_size_remaining = ext_data_size;
-
-        if (extra_size_remaining) {
-          const mz_uint8 *pExtra_data;
-          void *buf = NULL;
-
-          if (MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size + ext_data_size >
-              n) {
-            buf = MZ_MALLOC(ext_data_size);
-            if (buf == NULL)
-              return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-
-            if (pZip->m_pRead(pZip->m_pIO_opaque,
-                              cdir_ofs + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE +
-                                  filename_size,
-                              buf, ext_data_size) != ext_data_size) {
-              MZ_FREE(buf);
-              return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-            }
-
-            pExtra_data = (mz_uint8 *)buf;
-          } else {
-            pExtra_data = p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size;
-          }
-
-          do {
-            mz_uint32 field_id;
-            mz_uint32 field_data_size;
-
-            if (extra_size_remaining < (sizeof(mz_uint16) * 2)) {
-              MZ_FREE(buf);
-              return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-            }
-
-            field_id = MZ_READ_LE16(pExtra_data);
-            field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16));
-
-            if ((field_data_size + sizeof(mz_uint16) * 2) >
-                extra_size_remaining) {
-              MZ_FREE(buf);
-              return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-            }
-
-            if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID) {
-              /* Ok, the archive didn't have any zip64 headers but it uses a
-               * zip64 extended information field so mark it as zip64 anyway
-               * (this can occur with infozip's zip util when it reads
-               * compresses files from stdin). */
-              pZip->m_pState->m_zip64 = MZ_TRUE;
-              pZip->m_pState->m_zip64_has_extended_info_fields = MZ_TRUE;
-              break;
-            }
-
-            pExtra_data += sizeof(mz_uint16) * 2 + field_data_size;
-            extra_size_remaining =
-                extra_size_remaining - sizeof(mz_uint16) * 2 - field_data_size;
-          } while (extra_size_remaining);
-
-          MZ_FREE(buf);
-        }
-      }
-
-      /* I've seen archives that aren't marked as zip64 that uses zip64 ext
-       * data, argh */
-      if ((comp_size != MZ_UINT32_MAX) && (decomp_size != MZ_UINT32_MAX)) {
-        if (((!MZ_READ_LE32(p + MZ_ZIP_CDH_METHOD_OFS)) &&
-             (decomp_size != comp_size)) ||
-            (decomp_size && !comp_size))
-          return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-      }
-
+      if (((!MZ_READ_LE32(p + MZ_ZIP_CDH_METHOD_OFS)) &&
+           (decomp_size != comp_size)) ||
+          (decomp_size && !comp_size) || (decomp_size == 0xFFFFFFFF) ||
+          (comp_size == 0xFFFFFFFF))
+        return MZ_FALSE;
       disk_index = MZ_READ_LE16(p + MZ_ZIP_CDH_DISK_START_OFS);
-      if ((disk_index == MZ_UINT16_MAX) ||
-          ((disk_index != num_this_disk) && (disk_index != 1)))
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK);
-
-      if (comp_size != MZ_UINT32_MAX) {
-        if (((mz_uint64)MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS) +
-             MZ_ZIP_LOCAL_DIR_HEADER_SIZE + comp_size) > pZip->m_archive_size)
-          return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-      }
-
-      bit_flags = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS);
-      if (bit_flags & MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_LOCAL_DIR_IS_MASKED)
-        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);
-
+      if ((disk_index != num_this_disk) && (disk_index != 1))
+        return MZ_FALSE;
+      if (((mz_uint64)MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS) +
+           MZ_ZIP_LOCAL_DIR_HEADER_SIZE + comp_size) > pZip->m_archive_size)
+        return MZ_FALSE;
       if ((total_header_size = MZ_ZIP_CENTRAL_DIR_HEADER_SIZE +
                                MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS) +
                                MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS) +
                                MZ_READ_LE16(p + MZ_ZIP_CDH_COMMENT_LEN_OFS)) >
           n)
-        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-
+        return MZ_FALSE;
       n -= total_header_size;
       p += total_header_size;
     }
diff --git a/Engine/lib/assimp/contrib/zip/src/zip.c b/Engine/lib/assimp/contrib/zip/src/zip.c
index 3b2821e6a..ff3a8fe1e 100644
--- a/Engine/lib/assimp/contrib/zip/src/zip.c
+++ b/Engine/lib/assimp/contrib/zip/src/zip.c
@@ -24,6 +24,7 @@
   ((((P)[0] >= 'A' && (P)[0] <= 'Z') || ((P)[0] >= 'a' && (P)[0] <= 'z')) &&   \
    (P)[1] == ':')
 #define FILESYSTEM_PREFIX_LEN(P) (HAS_DEVICE(P) ? 2 : 0)
+#define ISSLASH(C) ((C) == '/' || (C) == '\\')
 
 #else
 
@@ -47,7 +48,7 @@ int symlink(const char *target, const char *linkpath); // needed on Linux
 #endif
 
 #ifndef ISSLASH
-#define ISSLASH(C) ((C) == '/' || (C) == '\\')
+#define ISSLASH(C) ((C) == '/')
 #endif
 
 #define CLEANUP(ptr)                                                           \
@@ -77,34 +78,26 @@ static const char *base_name(const char *name) {
   return base;
 }
 
-static int mkpath(char *path) {
-  char *p;
+static int mkpath(const char *path) {
+  char const *p;
   char npath[MAX_PATH + 1];
   int len = 0;
   int has_device = HAS_DEVICE(path);
 
   memset(npath, 0, MAX_PATH + 1);
-  if (has_device) {
-    // only on windows
-    npath[0] = path[0];
-    npath[1] = path[1];
-    len = 2;
-  }
+
+#ifdef _WIN32
+  // only on windows fix the path
+  npath[0] = path[0];
+  npath[1] = path[1];
+  len = 2;
+#endif // _WIN32
+    
   for (p = path + len; *p && len < MAX_PATH; p++) {
     if (ISSLASH(*p) && ((!has_device && len > 0) || (has_device && len > 2))) {
-#if defined(_WIN32) || defined(__WIN32__) || defined(_MSC_VER) ||              \
-    defined(__MINGW32__)
-#else
-      if ('\\' == *p) {
-        *p = '/';
-      }
-#endif
-
-      if (MKDIR(npath) == -1) {
-        if (errno != EEXIST) {
+      if (MKDIR(npath) == -1)
+        if (errno != EEXIST)
           return -1;
-        }
-      }
     }
     npath[len++] = *p;
   }
@@ -222,20 +215,6 @@ void zip_close(struct zip_t *zip) {
   }
 }
 
-int zip_is64(struct zip_t *zip) {
-  if (!zip) {
-    // zip_t handler is not initialized
-    return -1;
-  }
-
-  if (!zip->archive.m_pState) {
-    // zip state is not initialized
-    return -1;
-  }
-
-  return (int)zip->archive.m_pState->m_zip64;
-}
-
 int zip_entry_open(struct zip_t *zip, const char *entryname) {
   size_t entrylen = 0;
   mz_zip_archive *pzip = NULL;
@@ -300,14 +279,7 @@ int zip_entry_open(struct zip_t *zip, const char *entryname) {
   zip->entry.header_offset = zip->archive.m_archive_size;
   memset(zip->entry.header, 0, MZ_ZIP_LOCAL_DIR_HEADER_SIZE * sizeof(mz_uint8));
   zip->entry.method = 0;
-
-  // UNIX or APPLE
-#if MZ_PLATFORM == 3 || MZ_PLATFORM == 19
-  // regular file with rw-r--r-- persmissions
-  zip->entry.external_attr = (mz_uint32)(0100644) << 16;
-#else
   zip->entry.external_attr = 0;
-#endif
 
   num_alignment_padding_bytes =
       mz_zip_writer_compute_padding_needed_for_file_alignment(pzip);
@@ -688,7 +660,7 @@ ssize_t zip_entry_noallocread(struct zip_t *zip, void *buf, size_t bufsize) {
   }
 
   if (!mz_zip_reader_extract_to_mem_no_alloc(pzip, (mz_uint)zip->entry.index,
-                                             buf, bufsize, 0, NULL, 0)) {
+  buf, bufsize, 0, NULL,  0)) {
     return -1;
   }
 
@@ -698,7 +670,10 @@ ssize_t zip_entry_noallocread(struct zip_t *zip, void *buf, size_t bufsize) {
 int zip_entry_fread(struct zip_t *zip, const char *filename) {
   mz_zip_archive *pzip = NULL;
   mz_uint idx;
+#if defined(_MSC_VER)
+#else
   mz_uint32 xattr = 0;
+#endif
   mz_zip_archive_file_stat info;
 
   if (!zip) {
@@ -808,8 +783,7 @@ int zip_create(const char *zipname, const char *filenames[], size_t len) {
 
     if (MZ_FILE_STAT(name, &file_stat) != 0) {
       // problem getting information - check errno
-      status = -1;
-      break;
+      return -1;
     }
 
     if ((file_stat.st_mode & 0200) == 0) {
@@ -901,19 +875,12 @@ int zip_extract(const char *zipname, const char *dir,
       goto out;
     }
 
-    if ((((info.m_version_made_by >> 8) == 3) ||
-         ((info.m_version_made_by >> 8) ==
-          19)) // if zip is produced on Unix or macOS (3 and 19 from
-               // section 4.4.2.2 of zip standard)
-        && info.m_external_attr &
-               (0x20 << 24)) { // and has sym link attribute (0x80 is file, 0x40
-                               // is directory)
+    if ((((info.m_version_made_by >> 8) == 3) || ((info.m_version_made_by >> 8) == 19)) // if zip is produced on Unix or macOS (3 and 19 from section 4.4.2.2 of zip standard)
+        && info.m_external_attr & (0x20 << 24)) { // and has sym link attribute (0x80 is file, 0x40 is directory)
 #if defined(_WIN32) || defined(__WIN32__) || defined(_MSC_VER) ||              \
     defined(__MINGW32__)
-#else
-      if (info.m_uncomp_size > MAX_PATH ||
-          !mz_zip_reader_extract_to_mem_no_alloc(&zip_archive, i, symlink_to,
-                                                 MAX_PATH, 0, NULL, 0)) {
+#else      
+      if (info.m_uncomp_size > MAX_PATH || !mz_zip_reader_extract_to_mem_no_alloc(&zip_archive, i, symlink_to, MAX_PATH, 0, NULL, 0)) {
         goto out;
       }
       symlink_to[info.m_uncomp_size] = '\0';
diff --git a/Engine/lib/assimp/contrib/zip/src/zip.h b/Engine/lib/assimp/contrib/zip/src/zip.h
index cd3ab5cd0..5f39df50a 100644
--- a/Engine/lib/assimp/contrib/zip/src/zip.h
+++ b/Engine/lib/assimp/contrib/zip/src/zip.h
@@ -20,251 +20,241 @@ extern "C" {
 #endif
 
 #if !defined(_SSIZE_T_DEFINED) && !defined(_SSIZE_T_DEFINED_) &&               \
-    !defined(__DEFINED_ssize_t) && !defined(__ssize_t_defined) &&              \
-    !defined(_SSIZE_T) && !defined(_SSIZE_T_) && !defined(_SSIZE_T_DECLARED)
-
+    !defined(_SSIZE_T) && !defined(_SSIZE_T_) && !defined(__ssize_t_defined)
+#define _SSIZE_T
 // 64-bit Windows is the only mainstream platform
 // where sizeof(long) != sizeof(void*)
 #ifdef _WIN64
-typedef long long ssize_t; /* byte count or error */
+typedef long long  ssize_t;  /* byte count or error */
 #else
-typedef long ssize_t; /* byte count or error */
+typedef long  ssize_t;  /* byte count or error */
 #endif
-
-#define _SSIZE_T_DEFINED
-#define _SSIZE_T_DEFINED_
-#define __DEFINED_ssize_t
-#define __ssize_t_defined
-#define _SSIZE_T
-#define _SSIZE_T_
-#define _SSIZE_T_DECLARED
-
 #endif
 
 #ifndef MAX_PATH
 #define MAX_PATH 32767 /* # chars in a path name including NULL */
 #endif
 
-/**
- * @mainpage
- *
- * Documenation for @ref zip.
- */
-
-/**
- * @addtogroup zip
- * @{
- */
-
-/**
- * Default zip compression level.
- */
-
 #define ZIP_DEFAULT_COMPRESSION_LEVEL 6
 
-/**
- * @struct zip_t
- *
- * This data structure is used throughout the library to represent zip archive -
- * forward declaration.
- */
+/*
+  This data structure is used throughout the library to represent zip archive
+  - forward declaration.
+*/
 struct zip_t;
 
-/**
- * Opens zip archive with compression level using the given mode.
- *
- * @param zipname zip archive file name.
- * @param level compression level (0-9 are the standard zlib-style levels).
- * @param mode file access mode.
- *        - 'r': opens a file for reading/extracting (the file must exists).
- *        - 'w': creates an empty file for writing.
- *        - 'a': appends to an existing archive.
- *
- * @return the zip archive handler or NULL on error
- */
+/*
+  Opens zip archive with compression level using the given mode.
+
+  Args:
+    zipname: zip archive file name.
+    level: compression level (0-9 are the standard zlib-style levels).
+    mode: file access mode.
+        'r': opens a file for reading/extracting (the file must exists).
+        'w': creates an empty file for writing.
+        'a': appends to an existing archive.
+
+  Returns:
+    The zip archive handler or NULL on error
+*/
 extern struct zip_t *zip_open(const char *zipname, int level, char mode);
 
-/**
- * Closes the zip archive, releases resources - always finalize.
- *
- * @param zip zip archive handler.
- */
+/*
+  Closes the zip archive, releases resources - always finalize.
+
+  Args:
+    zip: zip archive handler.
+*/
 extern void zip_close(struct zip_t *zip);
 
-/**
- * Determines if the archive has a zip64 end of central directory headers.
- *
- * @param zip zip archive handler.
- *
- * @return the return code - 1 (true), 0 (false), negative number (< 0) on
- *         error.
- */
-extern int zip_is64(struct zip_t *zip);
+/*
+  Opens an entry by name in the zip archive.
+  For zip archive opened in 'w' or 'a' mode the function will append
+  a new entry. In readonly mode the function tries to locate the entry
+  in global dictionary.
 
-/**
- * Opens an entry by name in the zip archive.
- *
- * For zip archive opened in 'w' or 'a' mode the function will append
- * a new entry. In readonly mode the function tries to locate the entry
- * in global dictionary.
- *
- * @param zip zip archive handler.
- * @param entryname an entry name in local dictionary.
- *
- * @return the return code - 0 on success, negative number (< 0) on error.
- */
+  Args:
+    zip: zip archive handler.
+    entryname: an entry name in local dictionary.
+
+  Returns:
+    The return code - 0 on success, negative number (< 0) on error.
+*/
 extern int zip_entry_open(struct zip_t *zip, const char *entryname);
 
-/**
- * Opens a new entry by index in the zip archive.
- *
- * This function is only valid if zip archive was opened in 'r' (readonly) mode.
- *
- * @param zip zip archive handler.
- * @param index index in local dictionary.
- *
- * @return the return code - 0 on success, negative number (< 0) on error.
- */
+/*
+  Opens a new entry by index in the zip archive.
+  This function is only valid if zip archive was opened in 'r' (readonly) mode.
+
+  Args:
+    zip: zip archive handler.
+    index: index in local dictionary.
+
+  Returns:
+    The return code - 0 on success, negative number (< 0) on error.
+*/
 extern int zip_entry_openbyindex(struct zip_t *zip, int index);
 
-/**
- * Closes a zip entry, flushes buffer and releases resources.
- *
- * @param zip zip archive handler.
- *
- * @return the return code - 0 on success, negative number (< 0) on error.
- */
+/*
+  Closes a zip entry, flushes buffer and releases resources.
+
+  Args:
+    zip: zip archive handler.
+
+  Returns:
+    The return code - 0 on success, negative number (< 0) on error.
+*/
 extern int zip_entry_close(struct zip_t *zip);
 
-/**
- * Returns a local name of the current zip entry.
- *
- * The main difference between user's entry name and local entry name
- * is optional relative path.
- * Following .ZIP File Format Specification - the path stored MUST not contain
- * a drive or device letter, or a leading slash.
- * All slashes MUST be forward slashes '/' as opposed to backwards slashes '\'
- * for compatibility with Amiga and UNIX file systems etc.
- *
- * @param zip: zip archive handler.
- *
- * @return the pointer to the current zip entry name, or NULL on error.
- */
+/*
+  Returns a local name of the current zip entry.
+  The main difference between user's entry name and local entry name
+  is optional relative path.
+  Following .ZIP File Format Specification - the path stored MUST not contain
+  a drive or device letter, or a leading slash.
+  All slashes MUST be forward slashes '/' as opposed to backwards slashes '\'
+  for compatibility with Amiga and UNIX file systems etc.
+
+  Args:
+    zip: zip archive handler.
+
+  Returns:
+    The pointer to the current zip entry name, or NULL on error.
+*/
 extern const char *zip_entry_name(struct zip_t *zip);
 
-/**
- * Returns an index of the current zip entry.
- *
- * @param zip zip archive handler.
- *
- * @return the index on success, negative number (< 0) on error.
- */
+/*
+  Returns an index of the current zip entry.
+
+  Args:
+    zip: zip archive handler.
+
+  Returns:
+    The index on success, negative number (< 0) on error.
+*/
 extern int zip_entry_index(struct zip_t *zip);
 
-/**
- * Determines if the current zip entry is a directory entry.
- *
- * @param zip zip archive handler.
- *
- * @return the return code - 1 (true), 0 (false), negative number (< 0) on
- *         error.
- */
+/*
+  Determines if the current zip entry is a directory entry.
+
+  Args:
+    zip: zip archive handler.
+
+  Returns:
+    The return code - 1 (true), 0 (false), negative number (< 0) on error.
+*/
 extern int zip_entry_isdir(struct zip_t *zip);
 
-/**
- * Returns an uncompressed size of the current zip entry.
- *
- * @param zip zip archive handler.
- *
- * @return the uncompressed size in bytes.
- */
+/*
+  Returns an uncompressed size of the current zip entry.
+
+  Args:
+    zip: zip archive handler.
+
+  Returns:
+    The uncompressed size in bytes.
+*/
 extern unsigned long long zip_entry_size(struct zip_t *zip);
 
-/**
- * Returns CRC-32 checksum of the current zip entry.
- *
- * @param zip zip archive handler.
- *
- * @return the CRC-32 checksum.
- */
+/*
+  Returns CRC-32 checksum of the current zip entry.
+
+  Args:
+    zip: zip archive handler.
+
+  Returns:
+    The CRC-32 checksum.
+*/
 extern unsigned int zip_entry_crc32(struct zip_t *zip);
 
-/**
- * Compresses an input buffer for the current zip entry.
- *
- * @param zip zip archive handler.
- * @param buf input buffer.
- * @param bufsize input buffer size (in bytes).
- *
- * @return the return code - 0 on success, negative number (< 0) on error.
- */
+/*
+  Compresses an input buffer for the current zip entry.
+
+  Args:
+    zip: zip archive handler.
+    buf: input buffer.
+    bufsize: input buffer size (in bytes).
+
+  Returns:
+    The return code - 0 on success, negative number (< 0) on error.
+*/
 extern int zip_entry_write(struct zip_t *zip, const void *buf, size_t bufsize);
 
-/**
- * Compresses a file for the current zip entry.
- *
- * @param zip zip archive handler.
- * @param filename input file.
- *
- * @return the return code - 0 on success, negative number (< 0) on error.
- */
+/*
+  Compresses a file for the current zip entry.
+
+  Args:
+    zip: zip archive handler.
+    filename: input file.
+
+  Returns:
+    The return code - 0 on success, negative number (< 0) on error.
+*/
 extern int zip_entry_fwrite(struct zip_t *zip, const char *filename);
 
-/**
- * Extracts the current zip entry into output buffer.
- *
- * The function allocates sufficient memory for a output buffer.
- *
- * @param zip zip archive handler.
- * @param buf output buffer.
- * @param bufsize output buffer size (in bytes).
- *
- * @note remember to release memory allocated for a output buffer.
- *       for large entries, please take a look at zip_entry_extract function.
- *
- * @return the return code - the number of bytes actually read on success.
- *         Otherwise a -1 on error.
- */
+/*
+  Extracts the current zip entry into output buffer.
+  The function allocates sufficient memory for a output buffer.
+
+  Args:
+    zip: zip archive handler.
+    buf: output buffer.
+    bufsize: output buffer size (in bytes).
+
+  Note:
+    - remember to release memory allocated for a output buffer.
+    - for large entries, please take a look at zip_entry_extract function.
+
+  Returns:
+    The return code - the number of bytes actually read on success.
+    Otherwise a -1 on error.
+*/
 extern ssize_t zip_entry_read(struct zip_t *zip, void **buf, size_t *bufsize);
 
-/**
- * Extracts the current zip entry into a memory buffer using no memory
- * allocation.
- *
- * @param zip zip archive handler.
- * @param buf preallocated output buffer.
- * @param bufsize output buffer size (in bytes).
- *
- * @note ensure supplied output buffer is large enough.
- *       zip_entry_size function (returns uncompressed size for the current
- *       entry) can be handy to estimate how big buffer is needed. for large
- * entries, please take a look at zip_entry_extract function.
- *
- * @return the return code - the number of bytes actually read on success.
- *         Otherwise a -1 on error (e.g. bufsize is not large enough).
- */
-extern ssize_t zip_entry_noallocread(struct zip_t *zip, void *buf,
-                                     size_t bufsize);
+/*
+  Extracts the current zip entry into a memory buffer using no memory
+  allocation.
 
-/**
- * Extracts the current zip entry into output file.
- *
- * @param zip zip archive handler.
- * @param filename output file.
- *
- * @return the return code - 0 on success, negative number (< 0) on error.
- */
+  Args:
+    zip: zip archive handler.
+    buf: preallocated output buffer.
+    bufsize: output buffer size (in bytes).
+
+  Note:
+    - ensure supplied output buffer is large enough.
+    - zip_entry_size function (returns uncompressed size for the current entry)
+      can be handy to estimate how big buffer is needed.
+    - for large entries, please take a look at zip_entry_extract function.
+
+  Returns:
+    The return code - the number of bytes actually read on success.
+    Otherwise a -1 on error (e.g. bufsize is not large enough).
+*/
+extern ssize_t zip_entry_noallocread(struct zip_t *zip, void *buf, size_t bufsize);
+
+/*
+  Extracts the current zip entry into output file.
+
+  Args:
+    zip: zip archive handler.
+    filename: output file.
+
+  Returns:
+    The return code - 0 on success, negative number (< 0) on error.
+*/
 extern int zip_entry_fread(struct zip_t *zip, const char *filename);
 
-/**
- * Extracts the current zip entry using a callback function (on_extract).
- *
- * @param zip zip archive handler.
- * @param on_extract callback function.
- * @param arg opaque pointer (optional argument, which you can pass to the
- *        on_extract callback)
- *
- * @return the return code - 0 on success, negative number (< 0) on error.
+/*
+  Extracts the current zip entry using a callback function (on_extract).
+
+  Args:
+    zip: zip archive handler.
+    on_extract: callback function.
+    arg: opaque pointer (optional argument,
+                         which you can pass to the on_extract callback)
+
+   Returns:
+    The return code - 0 on success, negative number (< 0) on error.
  */
 extern int
 zip_entry_extract(struct zip_t *zip,
@@ -272,49 +262,53 @@ zip_entry_extract(struct zip_t *zip,
                                        const void *data, size_t size),
                   void *arg);
 
-/**
- * Returns the number of all entries (files and directories) in the zip archive.
- *
- * @param zip zip archive handler.
- *
- * @return the return code - the number of entries on success, negative number
- *         (< 0) on error.
- */
+/*
+  Returns the number of all entries (files and directories) in the zip archive.
+
+  Args:
+    zip: zip archive handler.
+
+  Returns:
+    The return code - the number of entries on success,
+    negative number (< 0) on error.
+*/
 extern int zip_total_entries(struct zip_t *zip);
 
-/**
- * Creates a new archive and puts files into a single zip archive.
- *
- * @param zipname zip archive file.
- * @param filenames input files.
- * @param len: number of input files.
- *
- * @return the return code - 0 on success, negative number (< 0) on error.
- */
+/*
+  Creates a new archive and puts files into a single zip archive.
+
+  Args:
+    zipname: zip archive file.
+    filenames: input files.
+    len: number of input files.
+
+  Returns:
+    The return code - 0 on success, negative number (< 0) on error.
+*/
 extern int zip_create(const char *zipname, const char *filenames[], size_t len);
 
-/**
- * Extracts a zip archive file into directory.
- *
- * If on_extract_entry is not NULL, the callback will be called after
- * successfully extracted each zip entry.
- * Returning a negative value from the callback will cause abort and return an
- * error. The last argument (void *arg) is optional, which you can use to pass
- * data to the on_extract_entry callback.
- *
- * @param zipname zip archive file.
- * @param dir output directory.
- * @param on_extract_entry on extract callback.
- * @param arg opaque pointer.
- *
- * @return the return code - 0 on success, negative number (< 0) on error.
- */
+/*
+  Extracts a zip archive file into directory.
+
+  If on_extract_entry is not NULL, the callback will be called after
+  successfully extracted each zip entry.
+  Returning a negative value from the callback will cause abort and return an
+  error. The last argument (void *arg) is optional, which you can use to pass
+  data to the on_extract_entry callback.
+
+  Args:
+    zipname: zip archive file.
+    dir: output directory.
+    on_extract_entry: on extract callback.
+    arg: opaque pointer.
+
+  Returns:
+    The return code - 0 on success, negative number (< 0) on error.
+*/
 extern int zip_extract(const char *zipname, const char *dir,
                        int (*on_extract_entry)(const char *filename, void *arg),
                        void *arg);
 
-/** @} */
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/Engine/lib/assimp/contrib/zip/test/CMakeLists.txt b/Engine/lib/assimp/contrib/zip/test/CMakeLists.txt
index 122411585..9b2a8db10 100644
--- a/Engine/lib/assimp/contrib/zip/test/CMakeLists.txt
+++ b/Engine/lib/assimp/contrib/zip/test/CMakeLists.txt
@@ -1,11 +1,19 @@
 cmake_minimum_required(VERSION 2.8)
 
+if ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU" OR "${CMAKE_C_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_C_COMPILER_ID}" STREQUAL "AppleClang")
+  if(ENABLE_COVERAGE)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g ")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O0")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fprofile-arcs")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ftest-coverage")
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage")
+  endif()
+endif ()
+
 # test
-set(test_out test.out)
+include_directories(../src)
+add_executable(test.exe test.c ../src/zip.c)
+add_executable(test_miniz.exe test_miniz.c)
 
-add_executable(${test_out} test.c)
-target_link_libraries(${test_out} zip)
-
-add_test(NAME ${test_out} COMMAND ${test_out})
-
-set(test_out ${test_out} PARENT_SCOPE)
+add_test(NAME test COMMAND test.exe)
+add_test(NAME test_miniz COMMAND test_miniz.exe)
diff --git a/Engine/lib/assimp/contrib/zip/test/test.c b/Engine/lib/assimp/contrib/zip/test/test.c
index 9cc2248ac..454430533 100644
--- a/Engine/lib/assimp/contrib/zip/test/test.c
+++ b/Engine/lib/assimp/contrib/zip/test/test.c
@@ -29,8 +29,6 @@
 #define XFILE "7.txt\0"
 #define XMODE 0100777
 
-#define UNIXMODE 0100644
-
 #define UNUSED(x) (void)x
 
 static int total_entries = 0;
@@ -47,7 +45,7 @@ static void test_write(void) {
   assert(CRC32DATA1 == zip_entry_crc32(zip));
   ++total_entries;
   assert(0 == zip_entry_close(zip));
-  assert(0 == zip_is64(zip));
+
   zip_close(zip);
 }
 
@@ -92,7 +90,6 @@ static void test_read(void) {
   size_t buftmp;
   struct zip_t *zip = zip_open(ZIPNAME, 0, 'r');
   assert(zip != NULL);
-  assert(0 == zip_is64(zip));
 
   assert(0 == zip_entry_open(zip, "test\\test-1.txt"));
   assert(strlen(TESTDATA1) == zip_entry_size(zip));
@@ -105,8 +102,7 @@ static void test_read(void) {
   assert(0 == zip_entry_close(zip));
   free(buf);
   buf = NULL;
-  bufsize = 0;
-
+  
   assert(0 == zip_entry_open(zip, "test/test-2.txt"));
   assert(strlen(TESTDATA2) == zip_entry_size(zip));
   assert(CRC32DATA2 == zip_entry_crc32(zip));
@@ -135,8 +131,7 @@ static void test_read(void) {
   assert(0 == zip_entry_close(zip));
   free(buf);
   buf = NULL;
-  bufsize = 0;
-
+  
   buftmp = strlen(TESTDATA1);
   buf = calloc(buftmp, sizeof(char));
   assert(0 == zip_entry_open(zip, "test/test-1.txt"));
@@ -311,7 +306,6 @@ static void test_fwrite(void) {
   assert(0 == zip_entry_open(zip, WFILE));
   assert(0 == zip_entry_fwrite(zip, WFILE));
   assert(0 == zip_entry_close(zip));
-  assert(0 == zip_is64(zip));
 
   zip_close(zip);
   remove(WFILE);
@@ -439,35 +433,6 @@ static void test_mtime(void) {
   remove(ZIPNAME);
 }
 
-static void test_unix_permissions(void) {
-#if defined(_WIN64) || defined(_WIN32) || defined(__WIN32__)
-#else
-  // UNIX or APPLE
-  struct MZ_FILE_STAT_STRUCT file_stats;
-
-  remove(ZIPNAME);
-
-  struct zip_t *zip = zip_open(ZIPNAME, ZIP_DEFAULT_COMPRESSION_LEVEL, 'w');
-  assert(zip != NULL);
-
-  assert(0 == zip_entry_open(zip, RFILE));
-  assert(0 == zip_entry_write(zip, TESTDATA1, strlen(TESTDATA1)));
-  assert(0 == zip_entry_close(zip));
-
-  zip_close(zip);
-
-  remove(RFILE);
-
-  assert(0 == zip_extract(ZIPNAME, ".", NULL, NULL));
-
-  assert(0 == MZ_FILE_STAT(RFILE, &file_stats));
-  assert(UNIXMODE == file_stats.st_mode);
-
-  remove(RFILE);
-  remove(ZIPNAME);
-#endif
-}
-
 int main(int argc, char *argv[]) {
   UNUSED(argc);
   UNUSED(argv);
@@ -488,7 +453,6 @@ int main(int argc, char *argv[]) {
   test_write_permissions();
   test_exe_permissions();
   test_mtime();
-  test_unix_permissions();
 
   remove(ZIPNAME);
   return 0;
diff --git a/Engine/lib/assimp/contrib/zip/test/test_miniz.c b/Engine/lib/assimp/contrib/zip/test/test_miniz.c
index babcaecdb..ebc0564dc 100644
--- a/Engine/lib/assimp/contrib/zip/test/test_miniz.c
+++ b/Engine/lib/assimp/contrib/zip/test/test_miniz.c
@@ -23,39 +23,16 @@ int main(int argc, char *argv[]) {
   uint step = 0;
   int cmp_status;
   uLong src_len = (uLong)strlen(s_pStr);
+  uLong cmp_len = compressBound(src_len);
   uLong uncomp_len = src_len;
-  uLong cmp_len;
   uint8 *pCmp, *pUncomp;
-  size_t sz;
   uint total_succeeded = 0;
   (void)argc, (void)argv;
 
   printf("miniz.c version: %s\n", MZ_VERSION);
 
   do {
-    pCmp = (uint8 *)tdefl_compress_mem_to_heap(s_pStr, src_len, &cmp_len, 0);
-    if (!pCmp) {
-      printf("tdefl_compress_mem_to_heap failed\n");
-      return EXIT_FAILURE;
-    }
-    if (src_len <= cmp_len) {
-      printf("tdefl_compress_mem_to_heap failed: from %u to %u bytes\n",
-             (mz_uint32)uncomp_len, (mz_uint32)cmp_len);
-      free(pCmp);
-      return EXIT_FAILURE;
-    }
-
-    sz = tdefl_compress_mem_to_mem(pCmp, cmp_len, s_pStr, src_len, 0);
-    if (sz != cmp_len) {
-      printf("tdefl_compress_mem_to_mem failed: expected %u, got %u\n",
-             (mz_uint32)cmp_len, (mz_uint32)sz);
-      free(pCmp);
-      return EXIT_FAILURE;
-    }
-
     // Allocate buffers to hold compressed and uncompressed data.
-    free(pCmp);
-    cmp_len = compressBound(src_len);
     pCmp = (mz_uint8 *)malloc((size_t)cmp_len);
     pUncomp = (mz_uint8 *)malloc((size_t)src_len);
     if ((!pCmp) || (!pUncomp)) {
diff --git a/Engine/lib/assimp/contrib/zlib/CMakeLists.txt b/Engine/lib/assimp/contrib/zlib/CMakeLists.txt
new file mode 100644
index 000000000..9d1fcc943
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/CMakeLists.txt
@@ -0,0 +1,207 @@
+cmake_minimum_required(VERSION 2.4.4)
+set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS ON)
+
+# CMake 3.0 changed the project command, setting policy CMP0048 reverts to the old behaviour.
+# See http://www.cmake.org/cmake/help/v3.0/policy/CMP0048.html
+cmake_policy(PUSH)
+if(CMAKE_MAJOR_VERSION GREATER 2)
+	cmake_policy(SET CMP0048 NEW)
+endif()
+project(zlib C)
+SET (ZLIB_VERSION_MAJOR 1)
+SET (ZLIB_VERSION_MINOR 2)
+SET (ZLIB_VERSION_PATCH 11)
+SET (ZLIB_VERSION ${ZLIB_VERSION_MAJOR}.${ZLIB_VERSION_MINOR}.${ZLIB_VERSION_PATCH})
+SET (ZLIB_SOVERSION 1)
+SET (PROJECT_VERSION "${ZLIB_VERSION}")
+cmake_policy(POP)
+
+
+option(ASM686 "Enable building i686 assembly implementation")
+option(AMD64 "Enable building amd64 assembly implementation")
+
+#set(INSTALL_BIN_DIR "${CMAKE_INSTALL_PREFIX}/bin" CACHE PATH "Installation directory for executables")
+#set(INSTALL_LIB_DIR "${CMAKE_INSTALL_PREFIX}/lib" CACHE PATH "Installation directory for libraries")
+#set(INSTALL_INC_DIR "${CMAKE_INSTALL_PREFIX}/include" CACHE PATH "Installation directory for headers")
+#set(INSTALL_MAN_DIR "${CMAKE_INSTALL_PREFIX}/share/man" CACHE PATH "Installation directory for manual pages")
+#set(INSTALL_PKGCONFIG_DIR "${CMAKE_INSTALL_PREFIX}/share/pkgconfig" CACHE PATH "Installation directory for pkgconfig (.pc) files")
+
+include(CheckTypeSize)
+include(CheckFunctionExists)
+include(CheckIncludeFile)
+include(CheckCSourceCompiles)
+enable_testing()
+
+check_include_file(sys/types.h HAVE_SYS_TYPES_H)
+check_include_file(stdint.h    HAVE_STDINT_H)
+check_include_file(stddef.h    HAVE_STDDEF_H)
+
+#
+# Check to see if we have large file support
+#
+set(CMAKE_REQUIRED_DEFINITIONS -D_LARGEFILE64_SOURCE=1)
+# We add these other definitions here because CheckTypeSize.cmake
+# in CMake 2.4.x does not automatically do so and we want
+# compatibility with CMake 2.4.x.
+if(HAVE_SYS_TYPES_H)
+    list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_SYS_TYPES_H)
+endif()
+if(HAVE_STDINT_H)
+    list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_STDINT_H)
+endif()
+if(HAVE_STDDEF_H)
+    list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_STDDEF_H)
+endif()
+check_type_size(off64_t OFF64_T)
+if(HAVE_OFF64_T)
+   add_definitions(-D_LARGEFILE64_SOURCE=1)
+endif()
+set(CMAKE_REQUIRED_DEFINITIONS) # clear variable
+
+#
+# Check for fseeko
+#
+check_function_exists(fseeko HAVE_FSEEKO)
+if(NOT HAVE_FSEEKO)
+    add_definitions(-DNO_FSEEKO)
+endif()
+
+#
+# Check for unistd.h
+#
+check_include_file(unistd.h Z_HAVE_UNISTD_H)
+
+if(MSVC)
+    set(CMAKE_DEBUG_POSTFIX "d")
+    add_definitions(-D_CRT_SECURE_NO_DEPRECATE)
+    add_definitions(-D_CRT_NONSTDC_NO_DEPRECATE)
+    include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+endif()
+
+if(NOT CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR)
+    # If we're doing an out of source build and the user has a zconf.h
+    # in their source tree...
+    if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/zconf.h)
+        message(STATUS "Renaming")
+        message(STATUS "    ${CMAKE_CURRENT_SOURCE_DIR}/zconf.h")
+        message(STATUS "to 'zconf.h.included' because this file is included with zlib")
+        message(STATUS "but CMake generates it automatically in the build directory.")
+        file(RENAME ${CMAKE_CURRENT_SOURCE_DIR}/zconf.h ${CMAKE_CURRENT_SOURCE_DIR}/zconf.h.included)
+  endif()
+endif()
+
+set(ZLIB_PC ${CMAKE_CURRENT_BINARY_DIR}/zlib.pc)
+configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/zlib.pc.cmakein
+		${ZLIB_PC} @ONLY)
+configure_file(	${CMAKE_CURRENT_SOURCE_DIR}/zconf.h.cmakein
+		${CMAKE_CURRENT_BINARY_DIR}/zconf.h @ONLY)
+include_directories(${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_SOURCE_DIR})
+
+
+#============================================================================
+# zlib
+#============================================================================
+
+set(ZLIB_PUBLIC_HDRS
+    ${CMAKE_CURRENT_BINARY_DIR}/zconf.h
+    zlib.h
+)
+set(ZLIB_PRIVATE_HDRS
+    crc32.h
+    deflate.h
+    gzguts.h
+    inffast.h
+    inffixed.h
+    inflate.h
+    inftrees.h
+    trees.h
+    zutil.h
+)
+set(ZLIB_SRCS
+    adler32.c
+    compress.c
+    crc32.c
+    deflate.c
+    gzclose.c
+    gzlib.c
+    gzread.c
+    gzwrite.c
+    inflate.c
+    infback.c
+    inftrees.c
+    inffast.c
+    trees.c
+    uncompr.c
+    zutil.c
+)
+
+if(NOT MINGW)
+    set(ZLIB_DLL_SRCS
+        win32/zlib1.rc # If present will override custom build rule below.
+    )
+endif()
+
+if(CMAKE_COMPILER_IS_GNUCC)
+    if(ASM686)
+        set(ZLIB_ASMS contrib/asm686/match.S)
+    elseif (AMD64)
+        set(ZLIB_ASMS contrib/amd64/amd64-match.S)
+    endif ()
+
+	if(ZLIB_ASMS)
+		add_definitions(-DASMV)
+		set_source_files_properties(${ZLIB_ASMS} PROPERTIES LANGUAGE C COMPILE_FLAGS -DNO_UNDERLINE)
+	endif()
+endif()
+
+if(MSVC)
+    if(ASM686)
+		ENABLE_LANGUAGE(ASM_MASM)
+        set(ZLIB_ASMS
+			contrib/masmx86/inffas32.asm
+			contrib/masmx86/match686.asm
+		)
+    elseif (AMD64)
+		ENABLE_LANGUAGE(ASM_MASM)
+        set(ZLIB_ASMS
+			contrib/masmx64/gvmat64.asm
+			contrib/masmx64/inffasx64.asm
+		)
+    endif()
+
+	if(ZLIB_ASMS)
+		add_definitions(-DASMV -DASMINF)
+	endif()
+endif()
+
+# parse the full version number from zlib.h and include in ZLIB_FULL_VERSION
+file(READ ${CMAKE_CURRENT_SOURCE_DIR}/zlib.h _zlib_h_contents)
+string(REGEX REPLACE ".*#define[ \t]+ZLIB_VERSION[ \t]+\"([-0-9A-Za-z.]+)\".*"
+    "\\1" ZLIB_FULL_VERSION ${_zlib_h_contents})
+
+if(MINGW)
+    # This gets us DLL resource information when compiling on MinGW.
+    if(NOT CMAKE_RC_COMPILER)
+        set(CMAKE_RC_COMPILER windres.exe)
+    endif()
+
+    add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/zlib1rc.obj
+                       COMMAND ${CMAKE_RC_COMPILER}
+                            -D GCC_WINDRES
+                            -I ${CMAKE_CURRENT_SOURCE_DIR}
+                            -I ${CMAKE_CURRENT_BINARY_DIR}
+                            -o ${CMAKE_CURRENT_BINARY_DIR}/zlib1rc.obj
+                            -i ${CMAKE_CURRENT_SOURCE_DIR}/win32/zlib1.rc)
+    set(ZLIB_DLL_SRCS ${CMAKE_CURRENT_BINARY_DIR}/zlib1rc.obj)
+endif(MINGW)
+
+add_library(zlib SHARED ${ZLIB_SRCS} ${ZLIB_ASMS} ${ZLIB_DLL_SRCS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS})
+add_library(zlibstatic STATIC ${ZLIB_SRCS} ${ZLIB_ASMS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS})
+set_target_properties(zlib PROPERTIES DEFINE_SYMBOL ZLIB_DLL)
+set_target_properties(zlib PROPERTIES SOVERSION 1)
+
+INSTALL( TARGETS zlibstatic
+         LIBRARY DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
+         ARCHIVE DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
+         RUNTIME DESTINATION ${ASSIMP_BIN_INSTALL_DIR}
+         COMPONENT ${LIBASSIMP_COMPONENT})
diff --git a/Engine/lib/assimp/contrib/zlib/README b/Engine/lib/assimp/contrib/zlib/README
new file mode 100644
index 000000000..41777d06d
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/README
@@ -0,0 +1,115 @@
+ZLIB DATA COMPRESSION LIBRARY
+
+zlib 1.2.11.1 is a general purpose data compression library.  All the code is
+thread safe.  The data format used by the zlib library is described by RFCs
+(Request for Comments) 1950 to 1952 in the files
+http://tools.ietf.org/html/rfc1950 (zlib format), rfc1951 (deflate format) and
+rfc1952 (gzip format).
+
+All functions of the compression library are documented in the file zlib.h
+(volunteer to write man pages welcome, contact zlib@gzip.org).  A usage example
+of the library is given in the file test/example.c which also tests that
+the library is working correctly.  Another example is given in the file
+test/minigzip.c.  The compression library itself is composed of all source
+files in the root directory.
+
+To compile all files and run the test program, follow the instructions given at
+the top of Makefile.in.  In short "./configure; make test", and if that goes
+well, "make install" should work for most flavors of Unix.  For Windows, use
+one of the special makefiles in win32/ or contrib/vstudio/ .  For VMS, use
+make_vms.com.
+
+Questions about zlib should be sent to <zlib@gzip.org>, or to Gilles Vollant
+<info@winimage.com> for the Windows DLL version.  The zlib home page is
+http://zlib.net/ .  Before reporting a problem, please check this site to
+verify that you have the latest version of zlib; otherwise get the latest
+version and check whether the problem still exists or not.
+
+PLEASE read the zlib FAQ http://zlib.net/zlib_faq.html before asking for help.
+
+Mark Nelson <markn@ieee.org> wrote an article about zlib for the Jan.  1997
+issue of Dr.  Dobb's Journal; a copy of the article is available at
+http://marknelson.us/1997/01/01/zlib-engine/ .
+
+The changes made in version 1.2.11.1 are documented in the file ChangeLog.
+
+Unsupported third party contributions are provided in directory contrib/ .
+
+zlib is available in Java using the java.util.zip package, documented at
+http://java.sun.com/developer/technicalArticles/Programming/compression/ .
+
+A Perl interface to zlib written by Paul Marquess <pmqs@cpan.org> is available
+at CPAN (Comprehensive Perl Archive Network) sites, including
+http://search.cpan.org/~pmqs/IO-Compress-Zlib/ .
+
+A Python interface to zlib written by A.M. Kuchling <amk@amk.ca> is
+available in Python 1.5 and later versions, see
+http://docs.python.org/library/zlib.html .
+
+zlib is built into tcl: http://wiki.tcl.tk/4610 .
+
+An experimental package to read and write files in .zip format, written on top
+of zlib by Gilles Vollant <info@winimage.com>, is available in the
+contrib/minizip directory of zlib.
+
+
+Notes for some targets:
+
+- For Windows DLL versions, please see win32/DLL_FAQ.txt
+
+- For 64-bit Irix, deflate.c must be compiled without any optimization. With
+  -O, one libpng test fails. The test works in 32 bit mode (with the -n32
+  compiler flag). The compiler bug has been reported to SGI.
+
+- zlib doesn't work with gcc 2.6.3 on a DEC 3000/300LX under OSF/1 2.1 it works
+  when compiled with cc.
+
+- On Digital Unix 4.0D (formely OSF/1) on AlphaServer, the cc option -std1 is
+  necessary to get gzprintf working correctly. This is done by configure.
+
+- zlib doesn't work on HP-UX 9.05 with some versions of /bin/cc. It works with
+  other compilers. Use "make test" to check your compiler.
+
+- gzdopen is not supported on RISCOS or BEOS.
+
+- For PalmOs, see http://palmzlib.sourceforge.net/
+
+
+Acknowledgments:
+
+  The deflate format used by zlib was defined by Phil Katz.  The deflate and
+  zlib specifications were written by L.  Peter Deutsch.  Thanks to all the
+  people who reported problems and suggested various improvements in zlib; they
+  are too numerous to cite here.
+
+Copyright notice:
+
+ (C) 1995-2017 Jean-loup Gailly and Mark Adler
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Jean-loup Gailly        Mark Adler
+  jloup@gzip.org          madler@alumni.caltech.edu
+
+If you use the zlib library in a product, we would appreciate *not* receiving
+lengthy legal documents to sign.  The sources are provided for free but without
+warranty of any kind.  The library has been entirely written by Jean-loup
+Gailly and Mark Adler; it does not include third-party code.
+
+If you redistribute modified sources, we would appreciate that you include in
+the file ChangeLog history information documenting your changes.  Please read
+the FAQ for more information on the distribution of modified source versions.
diff --git a/Engine/lib/assimp/contrib/zlib/adler32.c b/Engine/lib/assimp/contrib/zlib/adler32.c
new file mode 100644
index 000000000..d0be4380a
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/adler32.c
@@ -0,0 +1,186 @@
+/* adler32.c -- compute the Adler-32 checksum of a data stream
+ * Copyright (C) 1995-2011, 2016 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#include "zutil.h"
+
+local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2));
+
+#define BASE 65521U     /* largest prime smaller than 65536 */
+#define NMAX 5552
+/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
+
+#define DO1(buf,i)  {adler += (buf)[i]; sum2 += adler;}
+#define DO2(buf,i)  DO1(buf,i); DO1(buf,i+1);
+#define DO4(buf,i)  DO2(buf,i); DO2(buf,i+2);
+#define DO8(buf,i)  DO4(buf,i); DO4(buf,i+4);
+#define DO16(buf)   DO8(buf,0); DO8(buf,8);
+
+/* use NO_DIVIDE if your processor does not do division in hardware --
+   try it both ways to see which is faster */
+#ifdef NO_DIVIDE
+/* note that this assumes BASE is 65521, where 65536 % 65521 == 15
+   (thank you to John Reiser for pointing this out) */
+#  define CHOP(a) \
+    do { \
+        unsigned long tmp = a >> 16; \
+        a &= 0xffffUL; \
+        a += (tmp << 4) - tmp; \
+    } while (0)
+#  define MOD28(a) \
+    do { \
+        CHOP(a); \
+        if (a >= BASE) a -= BASE; \
+    } while (0)
+#  define MOD(a) \
+    do { \
+        CHOP(a); \
+        MOD28(a); \
+    } while (0)
+#  define MOD63(a) \
+    do { /* this assumes a is not negative */ \
+        z_off64_t tmp = a >> 32; \
+        a &= 0xffffffffL; \
+        a += (tmp << 8) - (tmp << 5) + tmp; \
+        tmp = a >> 16; \
+        a &= 0xffffL; \
+        a += (tmp << 4) - tmp; \
+        tmp = a >> 16; \
+        a &= 0xffffL; \
+        a += (tmp << 4) - tmp; \
+        if (a >= BASE) a -= BASE; \
+    } while (0)
+#else
+#  define MOD(a) a %= BASE
+#  define MOD28(a) a %= BASE
+#  define MOD63(a) a %= BASE
+#endif
+
+/* ========================================================================= */
+uLong ZEXPORT adler32_z(adler, buf, len)
+    uLong adler;
+    const Bytef *buf;
+    z_size_t len;
+{
+    unsigned long sum2;
+    unsigned n;
+
+    /* split Adler-32 into component sums */
+    sum2 = (adler >> 16) & 0xffff;
+    adler &= 0xffff;
+
+    /* in case user likes doing a byte at a time, keep it fast */
+    if (len == 1) {
+        adler += buf[0];
+        if (adler >= BASE)
+            adler -= BASE;
+        sum2 += adler;
+        if (sum2 >= BASE)
+            sum2 -= BASE;
+        return adler | (sum2 << 16);
+    }
+
+    /* initial Adler-32 value (deferred check for len == 1 speed) */
+    if (buf == Z_NULL)
+        return 1L;
+
+    /* in case short lengths are provided, keep it somewhat fast */
+    if (len < 16) {
+        while (len--) {
+            adler += *buf++;
+            sum2 += adler;
+        }
+        if (adler >= BASE)
+            adler -= BASE;
+        MOD28(sum2);            /* only added so many BASE's */
+        return adler | (sum2 << 16);
+    }
+
+    /* do length NMAX blocks -- requires just one modulo operation */
+    while (len >= NMAX) {
+        len -= NMAX;
+        n = NMAX / 16;          /* NMAX is divisible by 16 */
+        do {
+            DO16(buf);          /* 16 sums unrolled */
+            buf += 16;
+        } while (--n);
+        MOD(adler);
+        MOD(sum2);
+    }
+
+    /* do remaining bytes (less than NMAX, still just one modulo) */
+    if (len) {                  /* avoid modulos if none remaining */
+        while (len >= 16) {
+            len -= 16;
+            DO16(buf);
+            buf += 16;
+        }
+        while (len--) {
+            adler += *buf++;
+            sum2 += adler;
+        }
+        MOD(adler);
+        MOD(sum2);
+    }
+
+    /* return recombined sums */
+    return adler | (sum2 << 16);
+}
+
+/* ========================================================================= */
+uLong ZEXPORT adler32(adler, buf, len)
+    uLong adler;
+    const Bytef *buf;
+    uInt len;
+{
+    return adler32_z(adler, buf, len);
+}
+
+/* ========================================================================= */
+local uLong adler32_combine_(adler1, adler2, len2)
+    uLong adler1;
+    uLong adler2;
+    z_off64_t len2;
+{
+    unsigned long sum1;
+    unsigned long sum2;
+    unsigned rem;
+
+    /* for negative len, return invalid adler32 as a clue for debugging */
+    if (len2 < 0)
+        return 0xffffffffUL;
+
+    /* the derivation of this formula is left as an exercise for the reader */
+    MOD63(len2);                /* assumes len2 >= 0 */
+    rem = (unsigned)len2;
+    sum1 = adler1 & 0xffff;
+    sum2 = rem * sum1;
+    MOD(sum2);
+    sum1 += (adler2 & 0xffff) + BASE - 1;
+    sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
+    if (sum1 >= BASE) sum1 -= BASE;
+    if (sum1 >= BASE) sum1 -= BASE;
+    if (sum2 >= ((unsigned long)BASE << 1)) sum2 -= ((unsigned long)BASE << 1);
+    if (sum2 >= BASE) sum2 -= BASE;
+    return sum1 | (sum2 << 16);
+}
+
+/* ========================================================================= */
+uLong ZEXPORT adler32_combine(adler1, adler2, len2)
+    uLong adler1;
+    uLong adler2;
+    z_off_t len2;
+{
+    return adler32_combine_(adler1, adler2, len2);
+}
+
+uLong ZEXPORT adler32_combine64(adler1, adler2, len2)
+    uLong adler1;
+    uLong adler2;
+    z_off64_t len2;
+{
+    return adler32_combine_(adler1, adler2, len2);
+}
diff --git a/Engine/lib/assimp/contrib/zlib/compress.c b/Engine/lib/assimp/contrib/zlib/compress.c
new file mode 100644
index 000000000..e2db404ab
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/compress.c
@@ -0,0 +1,86 @@
+/* compress.c -- compress a memory buffer
+ * Copyright (C) 1995-2005, 2014, 2016 Jean-loup Gailly, Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#define ZLIB_INTERNAL
+#include "zlib.h"
+
+/* ===========================================================================
+     Compresses the source buffer into the destination buffer. The level
+   parameter has the same meaning as in deflateInit.  sourceLen is the byte
+   length of the source buffer. Upon entry, destLen is the total size of the
+   destination buffer, which must be at least 0.1% larger than sourceLen plus
+   12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
+
+     compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_BUF_ERROR if there was not enough room in the output buffer,
+   Z_STREAM_ERROR if the level parameter is invalid.
+*/
+int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
+    Bytef *dest;
+    uLongf *destLen;
+    const Bytef *source;
+    uLong sourceLen;
+    int level;
+{
+    z_stream stream;
+    int err;
+    const uInt max = (uInt)-1;
+    uLong left;
+
+    left = *destLen;
+    *destLen = 0;
+
+    stream.zalloc = (alloc_func)0;
+    stream.zfree = (free_func)0;
+    stream.opaque = (voidpf)0;
+
+    err = deflateInit(&stream, level);
+    if (err != Z_OK) return err;
+
+    stream.next_out = dest;
+    stream.avail_out = 0;
+    stream.next_in = (z_const Bytef *)source;
+    stream.avail_in = 0;
+
+    do {
+        if (stream.avail_out == 0) {
+            stream.avail_out = left > (uLong)max ? max : (uInt)left;
+            left -= stream.avail_out;
+        }
+        if (stream.avail_in == 0) {
+            stream.avail_in = sourceLen > (uLong)max ? max : (uInt)sourceLen;
+            sourceLen -= stream.avail_in;
+        }
+        err = deflate(&stream, sourceLen ? Z_NO_FLUSH : Z_FINISH);
+    } while (err == Z_OK);
+
+    *destLen = stream.total_out;
+    deflateEnd(&stream);
+    return err == Z_STREAM_END ? Z_OK : err;
+}
+
+/* ===========================================================================
+ */
+int ZEXPORT compress (dest, destLen, source, sourceLen)
+    Bytef *dest;
+    uLongf *destLen;
+    const Bytef *source;
+    uLong sourceLen;
+{
+    return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION);
+}
+
+/* ===========================================================================
+     If the default memLevel or windowBits for deflateInit() is changed, then
+   this function needs to be updated.
+ */
+uLong ZEXPORT compressBound (sourceLen)
+    uLong sourceLen;
+{
+    return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
+           (sourceLen >> 25) + 13;
+}
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/README.contrib b/Engine/lib/assimp/contrib/zlib/contrib/README.contrib
new file mode 100644
index 000000000..a411d5c39
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/README.contrib
@@ -0,0 +1,78 @@
+All files under this contrib directory are UNSUPPORTED. There were
+provided by users of zlib and were not tested by the authors of zlib.
+Use at your own risk. Please contact the authors of the contributions
+for help about these, not the zlib authors. Thanks.
+
+
+ada/        by Dmitriy Anisimkov <anisimkov@yahoo.com>
+        Support for Ada
+        See http://zlib-ada.sourceforge.net/
+
+amd64/      by Mikhail Teterin <mi@ALDAN.algebra.com>
+        asm code for AMD64
+        See patch at http://www.freebsd.org/cgi/query-pr.cgi?pr=bin/96393
+
+asm686/     by Brian Raiter <breadbox@muppetlabs.com>
+        asm code for Pentium and PPro/PII, using the AT&T (GNU as) syntax
+        See http://www.muppetlabs.com/~breadbox/software/assembly.html
+
+blast/      by Mark Adler <madler@alumni.caltech.edu>
+        Decompressor for output of PKWare Data Compression Library (DCL)
+
+delphi/     by Cosmin Truta <cosmint@cs.ubbcluj.ro>
+        Support for Delphi and C++ Builder
+
+dotzlib/    by Henrik Ravn <henrik@ravn.com>
+        Support for Microsoft .Net and Visual C++ .Net
+
+gcc_gvmat64/by Gilles Vollant <info@winimage.com>
+        GCC Version of x86 64-bit (AMD64 and Intel EM64t) code for x64
+        assembler to replace longest_match() and inflate_fast()
+
+infback9/   by Mark Adler <madler@alumni.caltech.edu>
+        Unsupported diffs to infback to decode the deflate64 format
+
+inflate86/  by Chris Anderson <christop@charm.net>
+        Tuned x86 gcc asm code to replace inflate_fast()
+
+iostream/   by Kevin Ruland <kevin@rodin.wustl.edu>
+        A C++ I/O streams interface to the zlib gz* functions
+
+iostream2/  by Tyge Løvset <Tyge.Lovset@cmr.no>
+        Another C++ I/O streams interface
+
+iostream3/  by Ludwig Schwardt <schwardt@sun.ac.za>
+            and Kevin Ruland <kevin@rodin.wustl.edu>
+        Yet another C++ I/O streams interface
+
+masmx64/    by Gilles Vollant <info@winimage.com>
+        x86 64-bit (AMD64 and Intel EM64t) code for x64 assembler to
+        replace longest_match() and inflate_fast(),  also masm x86
+        64-bits translation of Chris Anderson inflate_fast()
+
+masmx86/    by Gilles Vollant <info@winimage.com>
+        x86 asm code to replace longest_match() and inflate_fast(),
+        for Visual C++ and MASM (32 bits).
+        Based on Brian Raiter (asm686) and Chris Anderson (inflate86)
+
+minizip/    by Gilles Vollant <info@winimage.com>
+        Mini zip and unzip based on zlib
+        Includes Zip64 support by Mathias Svensson <mathias@result42.com>
+        See http://www.winimage.com/zLibDll/minizip.html
+
+pascal/     by Bob Dellaca <bobdl@xtra.co.nz> et al.
+        Support for Pascal
+
+puff/       by Mark Adler <madler@alumni.caltech.edu>
+        Small, low memory usage inflate.  Also serves to provide an
+        unambiguous description of the deflate format.
+
+testzlib/   by Gilles Vollant <info@winimage.com>
+        Example of the use of zlib
+
+untgz/      by Pedro A. Aranda Gutierrez <paag@tid.es>
+        A very simple tar.gz file extractor using zlib
+
+vstudio/    by Gilles Vollant <info@winimage.com>
+        Building a minizip-enhanced zlib with Microsoft Visual Studio
+        Includes vc11 from kreuzerkrieg and vc12 from davispuh
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/ada/buffer_demo.adb b/Engine/lib/assimp/contrib/zlib/contrib/ada/buffer_demo.adb
new file mode 100644
index 000000000..46b863810
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/ada/buffer_demo.adb
@@ -0,0 +1,106 @@
+----------------------------------------------------------------
+--  ZLib for Ada thick binding.                               --
+--                                                            --
+--  Copyright (C) 2002-2004 Dmitriy Anisimkov                 --
+--                                                            --
+--  Open source license information is in the zlib.ads file.  --
+----------------------------------------------------------------
+--
+--  $Id: buffer_demo.adb,v 1.3 2004/09/06 06:55:35 vagul Exp $
+
+--  This demo program provided by Dr Steve Sangwine <sjs@essex.ac.uk>
+--
+--  Demonstration of a problem with Zlib-Ada (already fixed) when a buffer
+--  of exactly the correct size is used for decompressed data, and the last
+--  few bytes passed in to Zlib are checksum bytes.
+
+--  This program compresses a string of text, and then decompresses the
+--  compressed text into a buffer of the same size as the original text.
+
+with Ada.Streams; use Ada.Streams;
+with Ada.Text_IO;
+
+with ZLib; use ZLib;
+
+procedure Buffer_Demo is
+   EOL  : Character renames ASCII.LF;
+   Text : constant String
+     := "Four score and seven years ago our fathers brought forth," & EOL &
+        "upon this continent, a new nation, conceived in liberty," & EOL &
+        "and dedicated to the proposition that `all men are created equal'.";
+
+   Source : Stream_Element_Array (1 .. Text'Length);
+   for Source'Address use Text'Address;
+
+begin
+   Ada.Text_IO.Put (Text);
+   Ada.Text_IO.New_Line;
+   Ada.Text_IO.Put_Line
+     ("Uncompressed size : " & Positive'Image (Text'Length) & " bytes");
+
+   declare
+      Compressed_Data : Stream_Element_Array (1 .. Text'Length);
+      L               : Stream_Element_Offset;
+   begin
+      Compress : declare
+         Compressor : Filter_Type;
+         I : Stream_Element_Offset;
+      begin
+         Deflate_Init (Compressor);
+
+         --  Compress the whole of T at once.
+
+         Translate (Compressor, Source, I, Compressed_Data, L, Finish);
+         pragma Assert (I = Source'Last);
+
+         Close (Compressor);
+
+         Ada.Text_IO.Put_Line
+           ("Compressed size :   "
+            & Stream_Element_Offset'Image (L) & " bytes");
+      end Compress;
+
+      --  Now we decompress the data, passing short blocks of data to Zlib
+      --  (because this demonstrates the problem - the last block passed will
+      --  contain checksum information and there will be no output, only a
+      --  check inside Zlib that the checksum is correct).
+
+      Decompress : declare
+         Decompressor : Filter_Type;
+
+         Uncompressed_Data : Stream_Element_Array (1 .. Text'Length);
+
+         Block_Size : constant := 4;
+         --  This makes sure that the last block contains
+         --  only Adler checksum data.
+
+         P : Stream_Element_Offset := Compressed_Data'First - 1;
+         O : Stream_Element_Offset;
+      begin
+         Inflate_Init (Decompressor);
+
+         loop
+            Translate
+              (Decompressor,
+               Compressed_Data
+                 (P + 1 .. Stream_Element_Offset'Min (P + Block_Size, L)),
+               P,
+               Uncompressed_Data
+                 (Total_Out (Decompressor) + 1 .. Uncompressed_Data'Last),
+               O,
+               No_Flush);
+
+               Ada.Text_IO.Put_Line
+                 ("Total in : " & Count'Image (Total_In (Decompressor)) &
+                  ", out : " & Count'Image (Total_Out (Decompressor)));
+
+               exit when P = L;
+         end loop;
+
+         Ada.Text_IO.New_Line;
+         Ada.Text_IO.Put_Line
+           ("Decompressed text matches original text : "
+             & Boolean'Image (Uncompressed_Data = Source));
+      end Decompress;
+   end;
+end Buffer_Demo;
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/ada/mtest.adb b/Engine/lib/assimp/contrib/zlib/contrib/ada/mtest.adb
new file mode 100644
index 000000000..c4dfd080f
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/ada/mtest.adb
@@ -0,0 +1,156 @@
+----------------------------------------------------------------
+--  ZLib for Ada thick binding.                               --
+--                                                            --
+--  Copyright (C) 2002-2003 Dmitriy Anisimkov                 --
+--                                                            --
+--  Open source license information is in the zlib.ads file.  --
+----------------------------------------------------------------
+--  Continuous test for ZLib multithreading. If the test would fail
+--  we should provide thread safe allocation routines for the Z_Stream.
+--
+--  $Id: mtest.adb,v 1.4 2004/07/23 07:49:54 vagul Exp $
+
+with ZLib;
+with Ada.Streams;
+with Ada.Numerics.Discrete_Random;
+with Ada.Text_IO;
+with Ada.Exceptions;
+with Ada.Task_Identification;
+
+procedure MTest is
+   use Ada.Streams;
+   use ZLib;
+
+   Stop : Boolean := False;
+
+   pragma Atomic (Stop);
+
+   subtype Visible_Symbols is Stream_Element range 16#20# .. 16#7E#;
+
+   package Random_Elements is
+      new Ada.Numerics.Discrete_Random (Visible_Symbols);
+
+   task type Test_Task;
+
+   task body Test_Task is
+      Buffer : Stream_Element_Array (1 .. 100_000);
+      Gen : Random_Elements.Generator;
+
+      Buffer_First  : Stream_Element_Offset;
+      Compare_First : Stream_Element_Offset;
+
+      Deflate : Filter_Type;
+      Inflate : Filter_Type;
+
+      procedure Further (Item : in Stream_Element_Array);
+
+      procedure Read_Buffer
+        (Item : out Ada.Streams.Stream_Element_Array;
+         Last : out Ada.Streams.Stream_Element_Offset);
+
+      -------------
+      -- Further --
+      -------------
+
+      procedure Further (Item : in Stream_Element_Array) is
+
+         procedure Compare (Item : in Stream_Element_Array);
+
+         -------------
+         -- Compare --
+         -------------
+
+         procedure Compare (Item : in Stream_Element_Array) is
+            Next_First : Stream_Element_Offset := Compare_First + Item'Length;
+         begin
+            if Buffer (Compare_First .. Next_First - 1) /= Item then
+               raise Program_Error;
+            end if;
+
+            Compare_First := Next_First;
+         end Compare;
+
+         procedure Compare_Write is new ZLib.Write (Write => Compare);
+      begin
+         Compare_Write (Inflate, Item, No_Flush);
+      end Further;
+
+      -----------------
+      -- Read_Buffer --
+      -----------------
+
+      procedure Read_Buffer
+        (Item : out Ada.Streams.Stream_Element_Array;
+         Last : out Ada.Streams.Stream_Element_Offset)
+      is
+         Buff_Diff   : Stream_Element_Offset := Buffer'Last - Buffer_First;
+         Next_First : Stream_Element_Offset;
+      begin
+         if Item'Length <= Buff_Diff then
+            Last := Item'Last;
+
+            Next_First := Buffer_First + Item'Length;
+
+            Item := Buffer (Buffer_First .. Next_First - 1);
+
+            Buffer_First := Next_First;
+         else
+            Last := Item'First + Buff_Diff;
+            Item (Item'First .. Last) := Buffer (Buffer_First .. Buffer'Last);
+            Buffer_First := Buffer'Last + 1;
+         end if;
+      end Read_Buffer;
+
+      procedure Translate is new Generic_Translate
+                                   (Data_In  => Read_Buffer,
+                                    Data_Out => Further);
+
+   begin
+      Random_Elements.Reset (Gen);
+
+      Buffer := (others => 20);
+
+      Main : loop
+         for J in Buffer'Range loop
+            Buffer (J) := Random_Elements.Random (Gen);
+
+            Deflate_Init (Deflate);
+            Inflate_Init (Inflate);
+
+            Buffer_First  := Buffer'First;
+            Compare_First := Buffer'First;
+
+            Translate (Deflate);
+
+            if Compare_First /= Buffer'Last + 1 then
+               raise Program_Error;
+            end if;
+
+            Ada.Text_IO.Put_Line
+              (Ada.Task_Identification.Image
+                 (Ada.Task_Identification.Current_Task)
+               & Stream_Element_Offset'Image (J)
+               & ZLib.Count'Image (Total_Out (Deflate)));
+
+            Close (Deflate);
+            Close (Inflate);
+
+            exit Main when Stop;
+         end loop;
+      end loop Main;
+   exception
+      when E : others =>
+         Ada.Text_IO.Put_Line (Ada.Exceptions.Exception_Information (E));
+         Stop := True;
+   end Test_Task;
+
+   Test : array (1 .. 4) of Test_Task;
+
+   pragma Unreferenced (Test);
+
+   Dummy : Character;
+
+begin
+   Ada.Text_IO.Get_Immediate (Dummy);
+   Stop := True;
+end MTest;
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/ada/read.adb b/Engine/lib/assimp/contrib/zlib/contrib/ada/read.adb
new file mode 100644
index 000000000..1f2efbfeb
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/ada/read.adb
@@ -0,0 +1,156 @@
+----------------------------------------------------------------
+--  ZLib for Ada thick binding.                               --
+--                                                            --
+--  Copyright (C) 2002-2003 Dmitriy Anisimkov                 --
+--                                                            --
+--  Open source license information is in the zlib.ads file.  --
+----------------------------------------------------------------
+
+--  $Id: read.adb,v 1.8 2004/05/31 10:53:40 vagul Exp $
+
+--  Test/demo program for the generic read interface.
+
+with Ada.Numerics.Discrete_Random;
+with Ada.Streams;
+with Ada.Text_IO;
+
+with ZLib;
+
+procedure Read is
+
+   use Ada.Streams;
+
+   ------------------------------------
+   --  Test configuration parameters --
+   ------------------------------------
+
+   File_Size   : Stream_Element_Offset := 100_000;
+
+   Continuous  : constant Boolean          := False;
+   --  If this constant is True, the test would be repeated again and again,
+   --  with increment File_Size for every iteration.
+
+   Header      : constant ZLib.Header_Type := ZLib.Default;
+   --  Do not use Header other than Default in ZLib versions 1.1.4 and older.
+
+   Init_Random : constant := 8;
+   --  We are using the same random sequence, in case of we catch bug,
+   --  so we would be able to reproduce it.
+
+   -- End --
+
+   Pack_Size : Stream_Element_Offset;
+   Offset    : Stream_Element_Offset;
+
+   Filter     : ZLib.Filter_Type;
+
+   subtype Visible_Symbols
+      is Stream_Element range 16#20# .. 16#7E#;
+
+   package Random_Elements is new
+      Ada.Numerics.Discrete_Random (Visible_Symbols);
+
+   Gen : Random_Elements.Generator;
+   Period  : constant Stream_Element_Offset := 200;
+   --  Period constant variable for random generator not to be very random.
+   --  Bigger period, harder random.
+
+   Read_Buffer : Stream_Element_Array (1 .. 2048);
+   Read_First  : Stream_Element_Offset;
+   Read_Last   : Stream_Element_Offset;
+
+   procedure Reset;
+
+   procedure Read
+     (Item : out Stream_Element_Array;
+      Last : out Stream_Element_Offset);
+   --  this procedure is for generic instantiation of
+   --  ZLib.Read
+   --  reading data from the File_In.
+
+   procedure Read is new ZLib.Read
+                           (Read,
+                            Read_Buffer,
+                            Rest_First => Read_First,
+                            Rest_Last  => Read_Last);
+
+   ----------
+   -- Read --
+   ----------
+
+   procedure Read
+     (Item : out Stream_Element_Array;
+      Last : out Stream_Element_Offset) is
+   begin
+      Last := Stream_Element_Offset'Min
+               (Item'Last,
+                Item'First + File_Size - Offset);
+
+      for J in Item'First .. Last loop
+         if J < Item'First + Period then
+            Item (J) := Random_Elements.Random (Gen);
+         else
+            Item (J) := Item (J - Period);
+         end if;
+
+         Offset   := Offset + 1;
+      end loop;
+   end Read;
+
+   -----------
+   -- Reset --
+   -----------
+
+   procedure Reset is
+   begin
+      Random_Elements.Reset (Gen, Init_Random);
+      Pack_Size := 0;
+      Offset := 1;
+      Read_First := Read_Buffer'Last + 1;
+      Read_Last  := Read_Buffer'Last;
+   end Reset;
+
+begin
+   Ada.Text_IO.Put_Line ("ZLib " & ZLib.Version);
+
+   loop
+      for Level in ZLib.Compression_Level'Range loop
+
+         Ada.Text_IO.Put ("Level ="
+            & ZLib.Compression_Level'Image (Level));
+
+         --  Deflate using generic instantiation.
+
+         ZLib.Deflate_Init
+               (Filter,
+                Level,
+                Header => Header);
+
+         Reset;
+
+         Ada.Text_IO.Put
+           (Stream_Element_Offset'Image (File_Size) & " ->");
+
+         loop
+            declare
+               Buffer : Stream_Element_Array (1 .. 1024);
+               Last   : Stream_Element_Offset;
+            begin
+               Read (Filter, Buffer, Last);
+
+               Pack_Size := Pack_Size + Last - Buffer'First + 1;
+
+               exit when Last < Buffer'Last;
+            end;
+         end loop;
+
+         Ada.Text_IO.Put_Line (Stream_Element_Offset'Image (Pack_Size));
+
+         ZLib.Close (Filter);
+      end loop;
+
+      exit when not Continuous;
+
+      File_Size := File_Size + 1;
+   end loop;
+end Read;
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/ada/readme.txt b/Engine/lib/assimp/contrib/zlib/contrib/ada/readme.txt
new file mode 100644
index 000000000..ce4d2cadf
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/ada/readme.txt
@@ -0,0 +1,65 @@
+                        ZLib for Ada thick binding (ZLib.Ada)
+                        Release 1.3
+
+ZLib.Ada is a thick binding interface to the popular ZLib data
+compression library, available at http://www.gzip.org/zlib/.
+It provides Ada-style access to the ZLib C library.
+
+
+        Here are the main changes since ZLib.Ada 1.2:
+
+- Attension: ZLib.Read generic routine have a initialization requirement
+  for Read_Last parameter now. It is a bit incompartible with previous version,
+  but extends functionality, we could use new parameters Allow_Read_Some and
+  Flush now.
+
+- Added Is_Open routines to ZLib and ZLib.Streams packages.
+
+- Add pragma Assert to check Stream_Element is 8 bit.
+
+- Fix extraction to buffer with exact known decompressed size. Error reported by
+  Steve Sangwine.
+
+- Fix definition of ULong (changed to unsigned_long), fix regression on 64 bits
+  computers. Patch provided by Pascal Obry.
+
+- Add Status_Error exception definition.
+
+- Add pragma Assertion that Ada.Streams.Stream_Element size is 8 bit.
+
+
+        How to build ZLib.Ada under GNAT
+
+You should have the ZLib library already build on your computer, before
+building ZLib.Ada. Make the directory of ZLib.Ada sources current and
+issue the command:
+
+  gnatmake test -largs -L<directory where libz.a is> -lz
+
+Or use the GNAT project file build for GNAT 3.15 or later:
+
+  gnatmake -Pzlib.gpr -L<directory where libz.a is>
+
+
+        How to build ZLib.Ada under Aonix ObjectAda for Win32 7.2.2
+
+1. Make a project with all *.ads and *.adb files from the distribution.
+2. Build the libz.a library from the ZLib C sources.
+3. Rename libz.a to z.lib.
+4. Add the library z.lib to the project.
+5. Add the libc.lib library from the ObjectAda distribution to the project.
+6. Build the executable using test.adb as a main procedure.
+
+
+        How to use ZLib.Ada
+
+The source files test.adb and read.adb are small demo programs that show
+the main functionality of ZLib.Ada.
+
+The routines from the package specifications are commented.
+
+
+Homepage: http://zlib-ada.sourceforge.net/
+Author: Dmitriy Anisimkov <anisimkov@yahoo.com>
+
+Contributors: Pascal Obry <pascal@obry.org>, Steve Sangwine <sjs@essex.ac.uk>
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/ada/test.adb b/Engine/lib/assimp/contrib/zlib/contrib/ada/test.adb
new file mode 100644
index 000000000..90773acfa
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/ada/test.adb
@@ -0,0 +1,463 @@
+----------------------------------------------------------------
+--  ZLib for Ada thick binding.                               --
+--                                                            --
+--  Copyright (C) 2002-2003 Dmitriy Anisimkov                 --
+--                                                            --
+--  Open source license information is in the zlib.ads file.  --
+----------------------------------------------------------------
+
+--  $Id: test.adb,v 1.17 2003/08/12 12:13:30 vagul Exp $
+
+--  The program has a few aims.
+--  1. Test ZLib.Ada95 thick binding functionality.
+--  2. Show the example of use main functionality of the ZLib.Ada95 binding.
+--  3. Build this program automatically compile all ZLib.Ada95 packages under
+--     GNAT Ada95 compiler.
+
+with ZLib.Streams;
+with Ada.Streams.Stream_IO;
+with Ada.Numerics.Discrete_Random;
+
+with Ada.Text_IO;
+
+with Ada.Calendar;
+
+procedure Test is
+
+   use Ada.Streams;
+   use Stream_IO;
+
+   ------------------------------------
+   --  Test configuration parameters --
+   ------------------------------------
+
+   File_Size   : Count   := 100_000;
+   Continuous  : constant Boolean := False;
+
+   Header      : constant ZLib.Header_Type := ZLib.Default;
+                                              --  ZLib.None;
+                                              --  ZLib.Auto;
+                                              --  ZLib.GZip;
+   --  Do not use Header other then Default in ZLib versions 1.1.4
+   --  and older.
+
+   Strategy    : constant ZLib.Strategy_Type := ZLib.Default_Strategy;
+   Init_Random : constant := 10;
+
+   -- End --
+
+   In_File_Name  : constant String := "testzlib.in";
+   --  Name of the input file
+
+   Z_File_Name   : constant String := "testzlib.zlb";
+   --  Name of the compressed file.
+
+   Out_File_Name : constant String := "testzlib.out";
+   --  Name of the decompressed file.
+
+   File_In   : File_Type;
+   File_Out  : File_Type;
+   File_Back : File_Type;
+   File_Z    : ZLib.Streams.Stream_Type;
+
+   Filter : ZLib.Filter_Type;
+
+   Time_Stamp : Ada.Calendar.Time;
+
+   procedure Generate_File;
+   --  Generate file of spetsified size with some random data.
+   --  The random data is repeatable, for the good compression.
+
+   procedure Compare_Streams
+     (Left, Right : in out Root_Stream_Type'Class);
+   --  The procedure compearing data in 2 streams.
+   --  It is for compare data before and after compression/decompression.
+
+   procedure Compare_Files (Left, Right : String);
+   --  Compare files. Based on the Compare_Streams.
+
+   procedure Copy_Streams
+     (Source, Target : in out Root_Stream_Type'Class;
+      Buffer_Size    : in     Stream_Element_Offset := 1024);
+   --  Copying data from one stream to another. It is for test stream
+   --  interface of the library.
+
+   procedure Data_In
+     (Item : out Stream_Element_Array;
+      Last : out Stream_Element_Offset);
+   --  this procedure is for generic instantiation of
+   --  ZLib.Generic_Translate.
+   --  reading data from the File_In.
+
+   procedure Data_Out (Item : in Stream_Element_Array);
+   --  this procedure is for generic instantiation of
+   --  ZLib.Generic_Translate.
+   --  writing data to the File_Out.
+
+   procedure Stamp;
+   --  Store the timestamp to the local variable.
+
+   procedure Print_Statistic (Msg : String; Data_Size : ZLib.Count);
+   --  Print the time statistic with the message.
+
+   procedure Translate is new ZLib.Generic_Translate
+                                (Data_In  => Data_In,
+                                 Data_Out => Data_Out);
+   --  This procedure is moving data from File_In to File_Out
+   --  with compression or decompression, depend on initialization of
+   --  Filter parameter.
+
+   -------------------
+   -- Compare_Files --
+   -------------------
+
+   procedure Compare_Files (Left, Right : String) is
+      Left_File, Right_File : File_Type;
+   begin
+      Open (Left_File, In_File, Left);
+      Open (Right_File, In_File, Right);
+      Compare_Streams (Stream (Left_File).all, Stream (Right_File).all);
+      Close (Left_File);
+      Close (Right_File);
+   end Compare_Files;
+
+   ---------------------
+   -- Compare_Streams --
+   ---------------------
+
+   procedure Compare_Streams
+     (Left, Right : in out Ada.Streams.Root_Stream_Type'Class)
+   is
+      Left_Buffer, Right_Buffer : Stream_Element_Array (0 .. 16#FFF#);
+      Left_Last, Right_Last : Stream_Element_Offset;
+   begin
+      loop
+         Read (Left, Left_Buffer, Left_Last);
+         Read (Right, Right_Buffer, Right_Last);
+
+         if Left_Last /= Right_Last then
+            Ada.Text_IO.Put_Line ("Compare error :"
+              & Stream_Element_Offset'Image (Left_Last)
+              & " /= "
+              & Stream_Element_Offset'Image (Right_Last));
+
+            raise Constraint_Error;
+
+         elsif Left_Buffer (0 .. Left_Last)
+               /= Right_Buffer (0 .. Right_Last)
+         then
+            Ada.Text_IO.Put_Line ("ERROR: IN and OUT files is not equal.");
+            raise Constraint_Error;
+
+         end if;
+
+         exit when Left_Last < Left_Buffer'Last;
+      end loop;
+   end Compare_Streams;
+
+   ------------------
+   -- Copy_Streams --
+   ------------------
+
+   procedure Copy_Streams
+     (Source, Target : in out Ada.Streams.Root_Stream_Type'Class;
+      Buffer_Size    : in     Stream_Element_Offset := 1024)
+   is
+      Buffer : Stream_Element_Array (1 .. Buffer_Size);
+      Last   : Stream_Element_Offset;
+   begin
+      loop
+         Read  (Source, Buffer, Last);
+         Write (Target, Buffer (1 .. Last));
+
+         exit when Last < Buffer'Last;
+      end loop;
+   end Copy_Streams;
+
+   -------------
+   -- Data_In --
+   -------------
+
+   procedure Data_In
+     (Item : out Stream_Element_Array;
+      Last : out Stream_Element_Offset) is
+   begin
+      Read (File_In, Item, Last);
+   end Data_In;
+
+   --------------
+   -- Data_Out --
+   --------------
+
+   procedure Data_Out (Item : in Stream_Element_Array) is
+   begin
+      Write (File_Out, Item);
+   end Data_Out;
+
+   -------------------
+   -- Generate_File --
+   -------------------
+
+   procedure Generate_File is
+      subtype Visible_Symbols is Stream_Element range 16#20# .. 16#7E#;
+
+      package Random_Elements is
+         new Ada.Numerics.Discrete_Random (Visible_Symbols);
+
+      Gen    : Random_Elements.Generator;
+      Buffer : Stream_Element_Array := (1 .. 77 => 16#20#) & 10;
+
+      Buffer_Count : constant Count := File_Size / Buffer'Length;
+      --  Number of same buffers in the packet.
+
+      Density : constant Count := 30; --  from 0 to Buffer'Length - 2;
+
+      procedure Fill_Buffer (J, D : in Count);
+      --  Change the part of the buffer.
+
+      -----------------
+      -- Fill_Buffer --
+      -----------------
+
+      procedure Fill_Buffer (J, D : in Count) is
+      begin
+         for K in 0 .. D loop
+            Buffer
+              (Stream_Element_Offset ((J + K) mod (Buffer'Length - 1) + 1))
+             := Random_Elements.Random (Gen);
+
+         end loop;
+      end Fill_Buffer;
+
+   begin
+      Random_Elements.Reset (Gen, Init_Random);
+
+      Create (File_In, Out_File, In_File_Name);
+
+      Fill_Buffer (1, Buffer'Length - 2);
+
+      for J in 1 .. Buffer_Count loop
+         Write (File_In, Buffer);
+
+         Fill_Buffer (J, Density);
+      end loop;
+
+      --  fill remain size.
+
+      Write
+        (File_In,
+         Buffer
+           (1 .. Stream_Element_Offset
+                   (File_Size - Buffer'Length * Buffer_Count)));
+
+      Flush (File_In);
+      Close (File_In);
+   end Generate_File;
+
+   ---------------------
+   -- Print_Statistic --
+   ---------------------
+
+   procedure Print_Statistic (Msg : String; Data_Size : ZLib.Count) is
+      use Ada.Calendar;
+      use Ada.Text_IO;
+
+      package Count_IO is new Integer_IO (ZLib.Count);
+
+      Curr_Dur : Duration := Clock - Time_Stamp;
+   begin
+      Put (Msg);
+
+      Set_Col (20);
+      Ada.Text_IO.Put ("size =");
+
+      Count_IO.Put
+        (Data_Size,
+         Width => Stream_IO.Count'Image (File_Size)'Length);
+
+      Put_Line (" duration =" & Duration'Image (Curr_Dur));
+   end Print_Statistic;
+
+   -----------
+   -- Stamp --
+   -----------
+
+   procedure Stamp is
+   begin
+      Time_Stamp := Ada.Calendar.Clock;
+   end Stamp;
+
+begin
+   Ada.Text_IO.Put_Line ("ZLib " & ZLib.Version);
+
+   loop
+      Generate_File;
+
+      for Level in ZLib.Compression_Level'Range loop
+
+         Ada.Text_IO.Put_Line ("Level ="
+            & ZLib.Compression_Level'Image (Level));
+
+         --  Test generic interface.
+         Open   (File_In, In_File, In_File_Name);
+         Create (File_Out, Out_File, Z_File_Name);
+
+         Stamp;
+
+         --  Deflate using generic instantiation.
+
+         ZLib.Deflate_Init
+               (Filter   => Filter,
+                Level    => Level,
+                Strategy => Strategy,
+                Header   => Header);
+
+         Translate (Filter);
+         Print_Statistic ("Generic compress", ZLib.Total_Out (Filter));
+         ZLib.Close (Filter);
+
+         Close (File_In);
+         Close (File_Out);
+
+         Open   (File_In, In_File, Z_File_Name);
+         Create (File_Out, Out_File, Out_File_Name);
+
+         Stamp;
+
+         --  Inflate using generic instantiation.
+
+         ZLib.Inflate_Init (Filter, Header => Header);
+
+         Translate (Filter);
+         Print_Statistic ("Generic decompress", ZLib.Total_Out (Filter));
+
+         ZLib.Close (Filter);
+
+         Close (File_In);
+         Close (File_Out);
+
+         Compare_Files (In_File_Name, Out_File_Name);
+
+         --  Test stream interface.
+
+         --  Compress to the back stream.
+
+         Open   (File_In, In_File, In_File_Name);
+         Create (File_Back, Out_File, Z_File_Name);
+
+         Stamp;
+
+         ZLib.Streams.Create
+           (Stream          => File_Z,
+            Mode            => ZLib.Streams.Out_Stream,
+            Back            => ZLib.Streams.Stream_Access
+                                 (Stream (File_Back)),
+            Back_Compressed => True,
+            Level           => Level,
+            Strategy        => Strategy,
+            Header          => Header);
+
+         Copy_Streams
+           (Source => Stream (File_In).all,
+            Target => File_Z);
+
+         --  Flushing internal buffers to the back stream.
+
+         ZLib.Streams.Flush (File_Z, ZLib.Finish);
+
+         Print_Statistic ("Write compress",
+                          ZLib.Streams.Write_Total_Out (File_Z));
+
+         ZLib.Streams.Close (File_Z);
+
+         Close (File_In);
+         Close (File_Back);
+
+         --  Compare reading from original file and from
+         --  decompression stream.
+
+         Open (File_In,   In_File, In_File_Name);
+         Open (File_Back, In_File, Z_File_Name);
+
+         ZLib.Streams.Create
+           (Stream          => File_Z,
+            Mode            => ZLib.Streams.In_Stream,
+            Back            => ZLib.Streams.Stream_Access
+                                 (Stream (File_Back)),
+            Back_Compressed => True,
+            Header          => Header);
+
+         Stamp;
+         Compare_Streams (Stream (File_In).all, File_Z);
+
+         Print_Statistic ("Read decompress",
+                          ZLib.Streams.Read_Total_Out (File_Z));
+
+         ZLib.Streams.Close (File_Z);
+         Close (File_In);
+         Close (File_Back);
+
+         --  Compress by reading from compression stream.
+
+         Open (File_Back, In_File, In_File_Name);
+         Create (File_Out, Out_File, Z_File_Name);
+
+         ZLib.Streams.Create
+           (Stream          => File_Z,
+            Mode            => ZLib.Streams.In_Stream,
+            Back            => ZLib.Streams.Stream_Access
+                                 (Stream (File_Back)),
+            Back_Compressed => False,
+            Level           => Level,
+            Strategy        => Strategy,
+            Header          => Header);
+
+         Stamp;
+         Copy_Streams
+           (Source => File_Z,
+            Target => Stream (File_Out).all);
+
+         Print_Statistic ("Read compress",
+                          ZLib.Streams.Read_Total_Out (File_Z));
+
+         ZLib.Streams.Close (File_Z);
+
+         Close (File_Out);
+         Close (File_Back);
+
+         --  Decompress to decompression stream.
+
+         Open   (File_In,   In_File, Z_File_Name);
+         Create (File_Back, Out_File, Out_File_Name);
+
+         ZLib.Streams.Create
+           (Stream          => File_Z,
+            Mode            => ZLib.Streams.Out_Stream,
+            Back            => ZLib.Streams.Stream_Access
+                                 (Stream (File_Back)),
+            Back_Compressed => False,
+            Header          => Header);
+
+         Stamp;
+
+         Copy_Streams
+           (Source => Stream (File_In).all,
+            Target => File_Z);
+
+         Print_Statistic ("Write decompress",
+                          ZLib.Streams.Write_Total_Out (File_Z));
+
+         ZLib.Streams.Close (File_Z);
+         Close (File_In);
+         Close (File_Back);
+
+         Compare_Files (In_File_Name, Out_File_Name);
+      end loop;
+
+      Ada.Text_IO.Put_Line (Count'Image (File_Size) & " Ok.");
+
+      exit when not Continuous;
+
+      File_Size := File_Size + 1;
+   end loop;
+end Test;
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/ada/zlib-streams.adb b/Engine/lib/assimp/contrib/zlib/contrib/ada/zlib-streams.adb
new file mode 100644
index 000000000..b6497bae2
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/ada/zlib-streams.adb
@@ -0,0 +1,225 @@
+----------------------------------------------------------------
+--  ZLib for Ada thick binding.                               --
+--                                                            --
+--  Copyright (C) 2002-2003 Dmitriy Anisimkov                 --
+--                                                            --
+--  Open source license information is in the zlib.ads file.  --
+----------------------------------------------------------------
+
+--  $Id: zlib-streams.adb,v 1.10 2004/05/31 10:53:40 vagul Exp $
+
+with Ada.Unchecked_Deallocation;
+
+package body ZLib.Streams is
+
+   -----------
+   -- Close --
+   -----------
+
+   procedure Close (Stream : in out Stream_Type) is
+      procedure Free is new Ada.Unchecked_Deallocation
+         (Stream_Element_Array, Buffer_Access);
+   begin
+      if Stream.Mode = Out_Stream or Stream.Mode = Duplex then
+         --  We should flush the data written by the writer.
+
+         Flush (Stream, Finish);
+
+         Close (Stream.Writer);
+      end if;
+
+      if Stream.Mode = In_Stream or Stream.Mode = Duplex then
+         Close (Stream.Reader);
+         Free (Stream.Buffer);
+      end if;
+   end Close;
+
+   ------------
+   -- Create --
+   ------------
+
+   procedure Create
+     (Stream            :    out Stream_Type;
+      Mode              : in     Stream_Mode;
+      Back              : in     Stream_Access;
+      Back_Compressed   : in     Boolean;
+      Level             : in     Compression_Level := Default_Compression;
+      Strategy          : in     Strategy_Type     := Default_Strategy;
+      Header            : in     Header_Type       := Default;
+      Read_Buffer_Size  : in     Ada.Streams.Stream_Element_Offset
+                                    := Default_Buffer_Size;
+      Write_Buffer_Size : in     Ada.Streams.Stream_Element_Offset
+                                    := Default_Buffer_Size)
+   is
+
+      subtype Buffer_Subtype is Stream_Element_Array (1 .. Read_Buffer_Size);
+
+      procedure Init_Filter
+         (Filter   : in out Filter_Type;
+          Compress : in     Boolean);
+
+      -----------------
+      -- Init_Filter --
+      -----------------
+
+      procedure Init_Filter
+         (Filter   : in out Filter_Type;
+          Compress : in     Boolean) is
+      begin
+         if Compress then
+            Deflate_Init
+              (Filter, Level, Strategy, Header => Header);
+         else
+            Inflate_Init (Filter, Header => Header);
+         end if;
+      end Init_Filter;
+
+   begin
+      Stream.Back := Back;
+      Stream.Mode := Mode;
+
+      if Mode = Out_Stream or Mode = Duplex then
+         Init_Filter (Stream.Writer, Back_Compressed);
+         Stream.Buffer_Size := Write_Buffer_Size;
+      else
+         Stream.Buffer_Size := 0;
+      end if;
+
+      if Mode = In_Stream or Mode = Duplex then
+         Init_Filter (Stream.Reader, not Back_Compressed);
+
+         Stream.Buffer     := new Buffer_Subtype;
+         Stream.Rest_First := Stream.Buffer'Last + 1;
+         Stream.Rest_Last  := Stream.Buffer'Last;
+      end if;
+   end Create;
+
+   -----------
+   -- Flush --
+   -----------
+
+   procedure Flush
+     (Stream : in out Stream_Type;
+      Mode   : in     Flush_Mode := Sync_Flush)
+   is
+      Buffer : Stream_Element_Array (1 .. Stream.Buffer_Size);
+      Last   : Stream_Element_Offset;
+   begin
+      loop
+         Flush (Stream.Writer, Buffer, Last, Mode);
+
+         Ada.Streams.Write (Stream.Back.all, Buffer (1 .. Last));
+
+         exit when Last < Buffer'Last;
+      end loop;
+   end Flush;
+
+   -------------
+   -- Is_Open --
+   -------------
+
+   function Is_Open (Stream : Stream_Type) return Boolean is
+   begin
+      return Is_Open (Stream.Reader) or else Is_Open (Stream.Writer);
+   end Is_Open;
+
+   ----------
+   -- Read --
+   ----------
+
+   procedure Read
+     (Stream : in out Stream_Type;
+      Item   :    out Stream_Element_Array;
+      Last   :    out Stream_Element_Offset)
+   is
+
+      procedure Read
+        (Item : out Stream_Element_Array;
+         Last : out Stream_Element_Offset);
+
+      ----------
+      -- Read --
+      ----------
+
+      procedure Read
+        (Item : out Stream_Element_Array;
+         Last : out Stream_Element_Offset) is
+      begin
+         Ada.Streams.Read (Stream.Back.all, Item, Last);
+      end Read;
+
+      procedure Read is new ZLib.Read
+         (Read       => Read,
+          Buffer     => Stream.Buffer.all,
+          Rest_First => Stream.Rest_First,
+          Rest_Last  => Stream.Rest_Last);
+
+   begin
+      Read (Stream.Reader, Item, Last);
+   end Read;
+
+   -------------------
+   -- Read_Total_In --
+   -------------------
+
+   function Read_Total_In (Stream : in Stream_Type) return Count is
+   begin
+      return Total_In (Stream.Reader);
+   end Read_Total_In;
+
+   --------------------
+   -- Read_Total_Out --
+   --------------------
+
+   function Read_Total_Out (Stream : in Stream_Type) return Count is
+   begin
+      return Total_Out (Stream.Reader);
+   end Read_Total_Out;
+
+   -----------
+   -- Write --
+   -----------
+
+   procedure Write
+     (Stream : in out Stream_Type;
+      Item   : in     Stream_Element_Array)
+   is
+
+      procedure Write (Item : in Stream_Element_Array);
+
+      -----------
+      -- Write --
+      -----------
+
+      procedure Write (Item : in Stream_Element_Array) is
+      begin
+         Ada.Streams.Write (Stream.Back.all, Item);
+      end Write;
+
+      procedure Write is new ZLib.Write
+         (Write       => Write,
+          Buffer_Size => Stream.Buffer_Size);
+
+   begin
+      Write (Stream.Writer, Item, No_Flush);
+   end Write;
+
+   --------------------
+   -- Write_Total_In --
+   --------------------
+
+   function Write_Total_In (Stream : in Stream_Type) return Count is
+   begin
+      return Total_In (Stream.Writer);
+   end Write_Total_In;
+
+   ---------------------
+   -- Write_Total_Out --
+   ---------------------
+
+   function Write_Total_Out (Stream : in Stream_Type) return Count is
+   begin
+      return Total_Out (Stream.Writer);
+   end Write_Total_Out;
+
+end ZLib.Streams;
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/ada/zlib-streams.ads b/Engine/lib/assimp/contrib/zlib/contrib/ada/zlib-streams.ads
new file mode 100644
index 000000000..8e26cd450
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/ada/zlib-streams.ads
@@ -0,0 +1,114 @@
+----------------------------------------------------------------
+--  ZLib for Ada thick binding.                               --
+--                                                            --
+--  Copyright (C) 2002-2003 Dmitriy Anisimkov                 --
+--                                                            --
+--  Open source license information is in the zlib.ads file.  --
+----------------------------------------------------------------
+
+--  $Id: zlib-streams.ads,v 1.12 2004/05/31 10:53:40 vagul Exp $
+
+package ZLib.Streams is
+
+   type Stream_Mode is (In_Stream, Out_Stream, Duplex);
+
+   type Stream_Access is access all Ada.Streams.Root_Stream_Type'Class;
+
+   type Stream_Type is
+      new Ada.Streams.Root_Stream_Type with private;
+
+   procedure Read
+     (Stream : in out Stream_Type;
+      Item   :    out Ada.Streams.Stream_Element_Array;
+      Last   :    out Ada.Streams.Stream_Element_Offset);
+
+   procedure Write
+     (Stream : in out Stream_Type;
+      Item   : in     Ada.Streams.Stream_Element_Array);
+
+   procedure Flush
+     (Stream : in out Stream_Type;
+      Mode   : in     Flush_Mode := Sync_Flush);
+   --  Flush the written data to the back stream,
+   --  all data placed to the compressor is flushing to the Back stream.
+   --  Should not be used until necessary, because it is decreasing
+   --  compression.
+
+   function Read_Total_In (Stream : in Stream_Type) return Count;
+   pragma Inline (Read_Total_In);
+   --  Return total number of bytes read from back stream so far.
+
+   function Read_Total_Out (Stream : in Stream_Type) return Count;
+   pragma Inline (Read_Total_Out);
+   --  Return total number of bytes read so far.
+
+   function Write_Total_In (Stream : in Stream_Type) return Count;
+   pragma Inline (Write_Total_In);
+   --  Return total number of bytes written so far.
+
+   function Write_Total_Out (Stream : in Stream_Type) return Count;
+   pragma Inline (Write_Total_Out);
+   --  Return total number of bytes written to the back stream.
+
+   procedure Create
+     (Stream            :    out Stream_Type;
+      Mode              : in     Stream_Mode;
+      Back              : in     Stream_Access;
+      Back_Compressed   : in     Boolean;
+      Level             : in     Compression_Level := Default_Compression;
+      Strategy          : in     Strategy_Type     := Default_Strategy;
+      Header            : in     Header_Type       := Default;
+      Read_Buffer_Size  : in     Ada.Streams.Stream_Element_Offset
+                                    := Default_Buffer_Size;
+      Write_Buffer_Size : in     Ada.Streams.Stream_Element_Offset
+                                    := Default_Buffer_Size);
+   --  Create the Comression/Decompression stream.
+   --  If mode is In_Stream then Write operation is disabled.
+   --  If mode is Out_Stream then Read operation is disabled.
+
+   --  If Back_Compressed is true then
+   --  Data written to the Stream is compressing to the Back stream
+   --  and data read from the Stream is decompressed data from the Back stream.
+
+   --  If Back_Compressed is false then
+   --  Data written to the Stream is decompressing to the Back stream
+   --  and data read from the Stream is compressed data from the Back stream.
+
+   --  !!! When the Need_Header is False ZLib-Ada is using undocumented
+   --  ZLib 1.1.4 functionality to do not create/wait for ZLib headers.
+
+   function Is_Open (Stream : Stream_Type) return Boolean;
+
+   procedure Close (Stream : in out Stream_Type);
+
+private
+
+   use Ada.Streams;
+
+   type Buffer_Access is access all Stream_Element_Array;
+
+   type Stream_Type
+     is new Root_Stream_Type with
+   record
+      Mode       : Stream_Mode;
+
+      Buffer     : Buffer_Access;
+      Rest_First : Stream_Element_Offset;
+      Rest_Last  : Stream_Element_Offset;
+      --  Buffer for Read operation.
+      --  We need to have this buffer in the record
+      --  because not all read data from back stream
+      --  could be processed during the read operation.
+
+      Buffer_Size : Stream_Element_Offset;
+      --  Buffer size for write operation.
+      --  We do not need to have this buffer
+      --  in the record because all data could be
+      --  processed in the write operation.
+
+      Back       : Stream_Access;
+      Reader     : Filter_Type;
+      Writer     : Filter_Type;
+   end record;
+
+end ZLib.Streams;
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/ada/zlib-thin.adb b/Engine/lib/assimp/contrib/zlib/contrib/ada/zlib-thin.adb
new file mode 100644
index 000000000..0ca4a7120
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/ada/zlib-thin.adb
@@ -0,0 +1,141 @@
+----------------------------------------------------------------
+--  ZLib for Ada thick binding.                               --
+--                                                            --
+--  Copyright (C) 2002-2003 Dmitriy Anisimkov                 --
+--                                                            --
+--  Open source license information is in the zlib.ads file.  --
+----------------------------------------------------------------
+
+--  $Id: zlib-thin.adb,v 1.8 2003/12/14 18:27:31 vagul Exp $
+
+package body ZLib.Thin is
+
+   ZLIB_VERSION  : constant Chars_Ptr := zlibVersion;
+
+   Z_Stream_Size : constant Int := Z_Stream'Size / System.Storage_Unit;
+
+   --------------
+   -- Avail_In --
+   --------------
+
+   function Avail_In (Strm : in Z_Stream) return UInt is
+   begin
+      return Strm.Avail_In;
+   end Avail_In;
+
+   ---------------
+   -- Avail_Out --
+   ---------------
+
+   function Avail_Out (Strm : in Z_Stream) return UInt is
+   begin
+      return Strm.Avail_Out;
+   end Avail_Out;
+
+   ------------------
+   -- Deflate_Init --
+   ------------------
+
+   function Deflate_Init
+     (strm       : Z_Streamp;
+      level      : Int;
+      method     : Int;
+      windowBits : Int;
+      memLevel   : Int;
+      strategy   : Int)
+      return       Int is
+   begin
+      return deflateInit2
+               (strm,
+                level,
+                method,
+                windowBits,
+                memLevel,
+                strategy,
+                ZLIB_VERSION,
+                Z_Stream_Size);
+   end Deflate_Init;
+
+   ------------------
+   -- Inflate_Init --
+   ------------------
+
+   function Inflate_Init (strm : Z_Streamp; windowBits : Int) return Int is
+   begin
+      return inflateInit2 (strm, windowBits, ZLIB_VERSION, Z_Stream_Size);
+   end Inflate_Init;
+
+   ------------------------
+   -- Last_Error_Message --
+   ------------------------
+
+   function Last_Error_Message (Strm : in Z_Stream) return String is
+      use Interfaces.C.Strings;
+   begin
+      if Strm.msg = Null_Ptr then
+         return "";
+      else
+         return Value (Strm.msg);
+      end if;
+   end Last_Error_Message;
+
+   ------------
+   -- Set_In --
+   ------------
+
+   procedure Set_In
+     (Strm   : in out Z_Stream;
+      Buffer : in     Voidp;
+      Size   : in     UInt) is
+   begin
+      Strm.Next_In  := Buffer;
+      Strm.Avail_In := Size;
+   end Set_In;
+
+   ------------------
+   -- Set_Mem_Func --
+   ------------------
+
+   procedure Set_Mem_Func
+     (Strm   : in out Z_Stream;
+      Opaque : in     Voidp;
+      Alloc  : in     alloc_func;
+      Free   : in     free_func) is
+   begin
+      Strm.opaque := Opaque;
+      Strm.zalloc := Alloc;
+      Strm.zfree  := Free;
+   end Set_Mem_Func;
+
+   -------------
+   -- Set_Out --
+   -------------
+
+   procedure Set_Out
+     (Strm   : in out Z_Stream;
+      Buffer : in     Voidp;
+      Size   : in     UInt) is
+   begin
+      Strm.Next_Out  := Buffer;
+      Strm.Avail_Out := Size;
+   end Set_Out;
+
+   --------------
+   -- Total_In --
+   --------------
+
+   function Total_In (Strm : in Z_Stream) return ULong is
+   begin
+      return Strm.Total_In;
+   end Total_In;
+
+   ---------------
+   -- Total_Out --
+   ---------------
+
+   function Total_Out (Strm : in Z_Stream) return ULong is
+   begin
+      return Strm.Total_Out;
+   end Total_Out;
+
+end ZLib.Thin;
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/ada/zlib-thin.ads b/Engine/lib/assimp/contrib/zlib/contrib/ada/zlib-thin.ads
new file mode 100644
index 000000000..810173cff
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/ada/zlib-thin.ads
@@ -0,0 +1,450 @@
+----------------------------------------------------------------
+--  ZLib for Ada thick binding.                               --
+--                                                            --
+--  Copyright (C) 2002-2003 Dmitriy Anisimkov                 --
+--                                                            --
+--  Open source license information is in the zlib.ads file.  --
+----------------------------------------------------------------
+
+--  $Id: zlib-thin.ads,v 1.11 2004/07/23 06:33:11 vagul Exp $
+
+with Interfaces.C.Strings;
+
+with System;
+
+private package ZLib.Thin is
+
+   --  From zconf.h
+
+   MAX_MEM_LEVEL : constant := 9;         --  zconf.h:105
+                                          --  zconf.h:105
+   MAX_WBITS : constant := 15;      --  zconf.h:115
+                                    --  32K LZ77 window
+                                    --  zconf.h:115
+   SEEK_SET : constant := 8#0000#;  --  zconf.h:244
+                                    --  Seek from beginning of file.
+                                    --  zconf.h:244
+   SEEK_CUR : constant := 1;        --  zconf.h:245
+                                    --  Seek from current position.
+                                    --  zconf.h:245
+   SEEK_END : constant := 2;        --  zconf.h:246
+                                    --  Set file pointer to EOF plus "offset"
+                                    --  zconf.h:246
+
+   type Byte is new Interfaces.C.unsigned_char; --  8 bits
+                                                --  zconf.h:214
+   type UInt is new Interfaces.C.unsigned;      --  16 bits or more
+                                                --  zconf.h:216
+   type Int is new Interfaces.C.int;
+
+   type ULong is new Interfaces.C.unsigned_long;     --  32 bits or more
+                                                     --  zconf.h:217
+   subtype Chars_Ptr is Interfaces.C.Strings.chars_ptr;
+
+   type ULong_Access is access ULong;
+   type Int_Access is access Int;
+
+   subtype Voidp is System.Address;            --  zconf.h:232
+
+   subtype Byte_Access is Voidp;
+
+   Nul : constant Voidp := System.Null_Address;
+   --  end from zconf
+
+   Z_NO_FLUSH : constant := 8#0000#;   --  zlib.h:125
+                                       --  zlib.h:125
+   Z_PARTIAL_FLUSH : constant := 1;       --  zlib.h:126
+                                          --  will be removed, use
+                                          --  Z_SYNC_FLUSH instead
+                                          --  zlib.h:126
+   Z_SYNC_FLUSH : constant := 2;       --  zlib.h:127
+                                       --  zlib.h:127
+   Z_FULL_FLUSH : constant := 3;       --  zlib.h:128
+                                       --  zlib.h:128
+   Z_FINISH : constant := 4;        --  zlib.h:129
+                                    --  zlib.h:129
+   Z_OK : constant := 8#0000#;   --  zlib.h:132
+                                 --  zlib.h:132
+   Z_STREAM_END : constant := 1;       --  zlib.h:133
+                                       --  zlib.h:133
+   Z_NEED_DICT : constant := 2;        --  zlib.h:134
+                                       --  zlib.h:134
+   Z_ERRNO : constant := -1;        --  zlib.h:135
+                                    --  zlib.h:135
+   Z_STREAM_ERROR : constant := -2;       --  zlib.h:136
+                                          --  zlib.h:136
+   Z_DATA_ERROR : constant := -3;      --  zlib.h:137
+                                       --  zlib.h:137
+   Z_MEM_ERROR : constant := -4;       --  zlib.h:138
+                                       --  zlib.h:138
+   Z_BUF_ERROR : constant := -5;       --  zlib.h:139
+                                       --  zlib.h:139
+   Z_VERSION_ERROR : constant := -6;      --  zlib.h:140
+                                          --  zlib.h:140
+   Z_NO_COMPRESSION : constant := 8#0000#;   --  zlib.h:145
+                                             --  zlib.h:145
+   Z_BEST_SPEED : constant := 1;       --  zlib.h:146
+                                       --  zlib.h:146
+   Z_BEST_COMPRESSION : constant := 9;       --  zlib.h:147
+                                             --  zlib.h:147
+   Z_DEFAULT_COMPRESSION : constant := -1;      --  zlib.h:148
+                                                --  zlib.h:148
+   Z_FILTERED : constant := 1;      --  zlib.h:151
+                                    --  zlib.h:151
+   Z_HUFFMAN_ONLY : constant := 2;        --  zlib.h:152
+                                          --  zlib.h:152
+   Z_DEFAULT_STRATEGY : constant := 8#0000#; --  zlib.h:153
+                                             --  zlib.h:153
+   Z_BINARY : constant := 8#0000#;  --  zlib.h:156
+                                    --  zlib.h:156
+   Z_ASCII : constant := 1;      --  zlib.h:157
+                                 --  zlib.h:157
+   Z_UNKNOWN : constant := 2;       --  zlib.h:158
+                                    --  zlib.h:158
+   Z_DEFLATED : constant := 8;      --  zlib.h:161
+                                    --  zlib.h:161
+   Z_NULL : constant := 8#0000#; --  zlib.h:164
+                                 --  for initializing zalloc, zfree, opaque
+                                 --  zlib.h:164
+   type gzFile is new Voidp;                  --  zlib.h:646
+
+   type Z_Stream is private;
+
+   type Z_Streamp is access all Z_Stream;     --  zlib.h:89
+
+   type alloc_func is access function
+     (Opaque : Voidp;
+      Items  : UInt;
+      Size   : UInt)
+      return Voidp; --  zlib.h:63
+
+   type free_func is access procedure (opaque : Voidp; address : Voidp);
+
+   function zlibVersion return Chars_Ptr;
+
+   function Deflate (strm : Z_Streamp; flush : Int) return Int;
+
+   function DeflateEnd (strm : Z_Streamp) return Int;
+
+   function Inflate (strm : Z_Streamp; flush : Int) return Int;
+
+   function InflateEnd (strm : Z_Streamp) return Int;
+
+   function deflateSetDictionary
+     (strm       : Z_Streamp;
+      dictionary : Byte_Access;
+      dictLength : UInt)
+      return       Int;
+
+   function deflateCopy (dest : Z_Streamp; source : Z_Streamp) return Int;
+   --  zlib.h:478
+
+   function deflateReset (strm : Z_Streamp) return Int; -- zlib.h:495
+
+   function deflateParams
+     (strm     : Z_Streamp;
+      level    : Int;
+      strategy : Int)
+      return     Int;       -- zlib.h:506
+
+   function inflateSetDictionary
+     (strm       : Z_Streamp;
+      dictionary : Byte_Access;
+      dictLength : UInt)
+      return       Int; --  zlib.h:548
+
+   function inflateSync (strm : Z_Streamp) return Int;  --  zlib.h:565
+
+   function inflateReset (strm : Z_Streamp) return Int; --  zlib.h:580
+
+   function compress
+     (dest      : Byte_Access;
+      destLen   : ULong_Access;
+      source    : Byte_Access;
+      sourceLen : ULong)
+      return      Int;           -- zlib.h:601
+
+   function compress2
+     (dest      : Byte_Access;
+      destLen   : ULong_Access;
+      source    : Byte_Access;
+      sourceLen : ULong;
+      level     : Int)
+      return      Int;          -- zlib.h:615
+
+   function uncompress
+     (dest      : Byte_Access;
+      destLen   : ULong_Access;
+      source    : Byte_Access;
+      sourceLen : ULong)
+      return      Int;
+
+   function gzopen (path : Chars_Ptr; mode : Chars_Ptr) return gzFile;
+
+   function gzdopen (fd : Int; mode : Chars_Ptr) return gzFile;
+
+   function gzsetparams
+     (file     : gzFile;
+      level    : Int;
+      strategy : Int)
+      return     Int;
+
+   function gzread
+     (file : gzFile;
+      buf  : Voidp;
+      len  : UInt)
+      return Int;
+
+   function gzwrite
+     (file : in gzFile;
+      buf  : in Voidp;
+      len  : in UInt)
+      return Int;
+
+   function gzprintf (file : in gzFile; format : in Chars_Ptr) return Int;
+
+   function gzputs (file : in gzFile; s : in Chars_Ptr) return Int;
+
+   function gzgets
+     (file : gzFile;
+      buf  : Chars_Ptr;
+      len  : Int)
+      return Chars_Ptr;
+
+   function gzputc (file : gzFile; char : Int) return Int;
+
+   function gzgetc (file : gzFile) return Int;
+
+   function gzflush (file : gzFile; flush : Int) return Int;
+
+   function gzseek
+     (file   : gzFile;
+      offset : Int;
+      whence : Int)
+      return   Int;
+
+   function gzrewind (file : gzFile) return Int;
+
+   function gztell (file : gzFile) return Int;
+
+   function gzeof (file : gzFile) return Int;
+
+   function gzclose (file : gzFile) return Int;
+
+   function gzerror (file : gzFile; errnum : Int_Access) return Chars_Ptr;
+
+   function adler32
+     (adler : ULong;
+      buf   : Byte_Access;
+      len   : UInt)
+      return  ULong;
+
+   function crc32
+     (crc  : ULong;
+      buf  : Byte_Access;
+      len  : UInt)
+      return ULong;
+
+   function deflateInit
+     (strm        : Z_Streamp;
+      level       : Int;
+      version     : Chars_Ptr;
+      stream_size : Int)
+      return        Int;
+
+   function deflateInit2
+     (strm        : Z_Streamp;
+      level       : Int;
+      method      : Int;
+      windowBits  : Int;
+      memLevel    : Int;
+      strategy    : Int;
+      version     : Chars_Ptr;
+      stream_size : Int)
+      return        Int;
+
+   function Deflate_Init
+     (strm       : Z_Streamp;
+      level      : Int;
+      method     : Int;
+      windowBits : Int;
+      memLevel   : Int;
+      strategy   : Int)
+      return       Int;
+   pragma Inline (Deflate_Init);
+
+   function inflateInit
+     (strm        : Z_Streamp;
+      version     : Chars_Ptr;
+      stream_size : Int)
+      return        Int;
+
+   function inflateInit2
+     (strm        : in Z_Streamp;
+      windowBits  : in Int;
+      version     : in Chars_Ptr;
+      stream_size : in Int)
+      return      Int;
+
+   function inflateBackInit
+     (strm        : in Z_Streamp;
+      windowBits  : in Int;
+      window      : in Byte_Access;
+      version     : in Chars_Ptr;
+      stream_size : in Int)
+      return      Int;
+   --  Size of window have to be 2**windowBits.
+
+   function Inflate_Init (strm : Z_Streamp; windowBits : Int) return Int;
+   pragma Inline (Inflate_Init);
+
+   function zError (err : Int) return Chars_Ptr;
+
+   function inflateSyncPoint (z : Z_Streamp) return Int;
+
+   function get_crc_table return ULong_Access;
+
+   --  Interface to the available fields of the z_stream structure.
+   --  The application must update next_in and avail_in when avail_in has
+   --  dropped to zero. It must update next_out and avail_out when avail_out
+   --  has dropped to zero. The application must initialize zalloc, zfree and
+   --  opaque before calling the init function.
+
+   procedure Set_In
+     (Strm   : in out Z_Stream;
+      Buffer : in Voidp;
+      Size   : in UInt);
+   pragma Inline (Set_In);
+
+   procedure Set_Out
+     (Strm   : in out Z_Stream;
+      Buffer : in Voidp;
+      Size   : in UInt);
+   pragma Inline (Set_Out);
+
+   procedure Set_Mem_Func
+     (Strm   : in out Z_Stream;
+      Opaque : in Voidp;
+      Alloc  : in alloc_func;
+      Free   : in free_func);
+   pragma Inline (Set_Mem_Func);
+
+   function Last_Error_Message (Strm : in Z_Stream) return String;
+   pragma Inline (Last_Error_Message);
+
+   function Avail_Out (Strm : in Z_Stream) return UInt;
+   pragma Inline (Avail_Out);
+
+   function Avail_In (Strm : in Z_Stream) return UInt;
+   pragma Inline (Avail_In);
+
+   function Total_In (Strm : in Z_Stream) return ULong;
+   pragma Inline (Total_In);
+
+   function Total_Out (Strm : in Z_Stream) return ULong;
+   pragma Inline (Total_Out);
+
+   function inflateCopy
+     (dest   : in Z_Streamp;
+      Source : in Z_Streamp)
+      return Int;
+
+   function compressBound (Source_Len : in ULong) return ULong;
+
+   function deflateBound
+     (Strm       : in Z_Streamp;
+      Source_Len : in ULong)
+      return     ULong;
+
+   function gzungetc (C : in Int; File : in  gzFile) return Int;
+
+   function zlibCompileFlags return ULong;
+
+private
+
+   type Z_Stream is record            -- zlib.h:68
+      Next_In   : Voidp      := Nul;  -- next input byte
+      Avail_In  : UInt       := 0;    -- number of bytes available at next_in
+      Total_In  : ULong      := 0;    -- total nb of input bytes read so far
+      Next_Out  : Voidp      := Nul;  -- next output byte should be put there
+      Avail_Out : UInt       := 0;    -- remaining free space at next_out
+      Total_Out : ULong      := 0;    -- total nb of bytes output so far
+      msg       : Chars_Ptr;          -- last error message, NULL if no error
+      state     : Voidp;              -- not visible by applications
+      zalloc    : alloc_func := null; -- used to allocate the internal state
+      zfree     : free_func  := null; -- used to free the internal state
+      opaque    : Voidp;              -- private data object passed to
+                                      --  zalloc and zfree
+      data_type : Int;                -- best guess about the data type:
+                                      --  ascii or binary
+      adler     : ULong;              -- adler32 value of the uncompressed
+                                      --  data
+      reserved  : ULong;              -- reserved for future use
+   end record;
+
+   pragma Convention (C, Z_Stream);
+
+   pragma Import (C, zlibVersion, "zlibVersion");
+   pragma Import (C, Deflate, "deflate");
+   pragma Import (C, DeflateEnd, "deflateEnd");
+   pragma Import (C, Inflate, "inflate");
+   pragma Import (C, InflateEnd, "inflateEnd");
+   pragma Import (C, deflateSetDictionary, "deflateSetDictionary");
+   pragma Import (C, deflateCopy, "deflateCopy");
+   pragma Import (C, deflateReset, "deflateReset");
+   pragma Import (C, deflateParams, "deflateParams");
+   pragma Import (C, inflateSetDictionary, "inflateSetDictionary");
+   pragma Import (C, inflateSync, "inflateSync");
+   pragma Import (C, inflateReset, "inflateReset");
+   pragma Import (C, compress, "compress");
+   pragma Import (C, compress2, "compress2");
+   pragma Import (C, uncompress, "uncompress");
+   pragma Import (C, gzopen, "gzopen");
+   pragma Import (C, gzdopen, "gzdopen");
+   pragma Import (C, gzsetparams, "gzsetparams");
+   pragma Import (C, gzread, "gzread");
+   pragma Import (C, gzwrite, "gzwrite");
+   pragma Import (C, gzprintf, "gzprintf");
+   pragma Import (C, gzputs, "gzputs");
+   pragma Import (C, gzgets, "gzgets");
+   pragma Import (C, gzputc, "gzputc");
+   pragma Import (C, gzgetc, "gzgetc");
+   pragma Import (C, gzflush, "gzflush");
+   pragma Import (C, gzseek, "gzseek");
+   pragma Import (C, gzrewind, "gzrewind");
+   pragma Import (C, gztell, "gztell");
+   pragma Import (C, gzeof, "gzeof");
+   pragma Import (C, gzclose, "gzclose");
+   pragma Import (C, gzerror, "gzerror");
+   pragma Import (C, adler32, "adler32");
+   pragma Import (C, crc32, "crc32");
+   pragma Import (C, deflateInit, "deflateInit_");
+   pragma Import (C, inflateInit, "inflateInit_");
+   pragma Import (C, deflateInit2, "deflateInit2_");
+   pragma Import (C, inflateInit2, "inflateInit2_");
+   pragma Import (C, zError, "zError");
+   pragma Import (C, inflateSyncPoint, "inflateSyncPoint");
+   pragma Import (C, get_crc_table, "get_crc_table");
+
+   --  since zlib 1.2.0:
+
+   pragma Import (C, inflateCopy, "inflateCopy");
+   pragma Import (C, compressBound, "compressBound");
+   pragma Import (C, deflateBound, "deflateBound");
+   pragma Import (C, gzungetc, "gzungetc");
+   pragma Import (C, zlibCompileFlags, "zlibCompileFlags");
+
+   pragma Import (C, inflateBackInit, "inflateBackInit_");
+
+   --  I stopped binding the inflateBack routines, because realize that
+   --  it does not support zlib and gzip headers for now, and have no
+   --  symmetric deflateBack routines.
+   --  ZLib-Ada is symmetric regarding deflate/inflate data transformation
+   --  and has a similar generic callback interface for the
+   --  deflate/inflate transformation based on the regular Deflate/Inflate
+   --  routines.
+
+   --  pragma Import (C, inflateBack, "inflateBack");
+   --  pragma Import (C, inflateBackEnd, "inflateBackEnd");
+
+end ZLib.Thin;
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/ada/zlib.adb b/Engine/lib/assimp/contrib/zlib/contrib/ada/zlib.adb
new file mode 100644
index 000000000..8b6fd686a
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/ada/zlib.adb
@@ -0,0 +1,701 @@
+----------------------------------------------------------------
+--  ZLib for Ada thick binding.                               --
+--                                                            --
+--  Copyright (C) 2002-2004 Dmitriy Anisimkov                 --
+--                                                            --
+--  Open source license information is in the zlib.ads file.  --
+----------------------------------------------------------------
+
+--  $Id: zlib.adb,v 1.31 2004/09/06 06:53:19 vagul Exp $
+
+with Ada.Exceptions;
+with Ada.Unchecked_Conversion;
+with Ada.Unchecked_Deallocation;
+
+with Interfaces.C.Strings;
+
+with ZLib.Thin;
+
+package body ZLib is
+
+   use type Thin.Int;
+
+   type Z_Stream is new Thin.Z_Stream;
+
+   type Return_Code_Enum is
+      (OK,
+       STREAM_END,
+       NEED_DICT,
+       ERRNO,
+       STREAM_ERROR,
+       DATA_ERROR,
+       MEM_ERROR,
+       BUF_ERROR,
+       VERSION_ERROR);
+
+   type Flate_Step_Function is access
+     function (Strm : in Thin.Z_Streamp; Flush : in Thin.Int) return Thin.Int;
+   pragma Convention (C, Flate_Step_Function);
+
+   type Flate_End_Function is access
+      function (Ctrm : in Thin.Z_Streamp) return Thin.Int;
+   pragma Convention (C, Flate_End_Function);
+
+   type Flate_Type is record
+      Step : Flate_Step_Function;
+      Done : Flate_End_Function;
+   end record;
+
+   subtype Footer_Array is Stream_Element_Array (1 .. 8);
+
+   Simple_GZip_Header : constant Stream_Element_Array (1 .. 10)
+     := (16#1f#, 16#8b#,                 --  Magic header
+         16#08#,                         --  Z_DEFLATED
+         16#00#,                         --  Flags
+         16#00#, 16#00#, 16#00#, 16#00#, --  Time
+         16#00#,                         --  XFlags
+         16#03#                          --  OS code
+        );
+   --  The simplest gzip header is not for informational, but just for
+   --  gzip format compatibility.
+   --  Note that some code below is using assumption
+   --  Simple_GZip_Header'Last > Footer_Array'Last, so do not make
+   --  Simple_GZip_Header'Last <= Footer_Array'Last.
+
+   Return_Code : constant array (Thin.Int range <>) of Return_Code_Enum
+     := (0 => OK,
+         1 => STREAM_END,
+         2 => NEED_DICT,
+        -1 => ERRNO,
+        -2 => STREAM_ERROR,
+        -3 => DATA_ERROR,
+        -4 => MEM_ERROR,
+        -5 => BUF_ERROR,
+        -6 => VERSION_ERROR);
+
+   Flate : constant array (Boolean) of Flate_Type
+     := (True  => (Step => Thin.Deflate'Access,
+                   Done => Thin.DeflateEnd'Access),
+         False => (Step => Thin.Inflate'Access,
+                   Done => Thin.InflateEnd'Access));
+
+   Flush_Finish : constant array (Boolean) of Flush_Mode
+     := (True => Finish, False => No_Flush);
+
+   procedure Raise_Error (Stream : in Z_Stream);
+   pragma Inline (Raise_Error);
+
+   procedure Raise_Error (Message : in String);
+   pragma Inline (Raise_Error);
+
+   procedure Check_Error (Stream : in Z_Stream; Code : in Thin.Int);
+
+   procedure Free is new Ada.Unchecked_Deallocation
+      (Z_Stream, Z_Stream_Access);
+
+   function To_Thin_Access is new Ada.Unchecked_Conversion
+     (Z_Stream_Access, Thin.Z_Streamp);
+
+   procedure Translate_GZip
+     (Filter    : in out Filter_Type;
+      In_Data   : in     Ada.Streams.Stream_Element_Array;
+      In_Last   :    out Ada.Streams.Stream_Element_Offset;
+      Out_Data  :    out Ada.Streams.Stream_Element_Array;
+      Out_Last  :    out Ada.Streams.Stream_Element_Offset;
+      Flush     : in     Flush_Mode);
+   --  Separate translate routine for make gzip header.
+
+   procedure Translate_Auto
+     (Filter    : in out Filter_Type;
+      In_Data   : in     Ada.Streams.Stream_Element_Array;
+      In_Last   :    out Ada.Streams.Stream_Element_Offset;
+      Out_Data  :    out Ada.Streams.Stream_Element_Array;
+      Out_Last  :    out Ada.Streams.Stream_Element_Offset;
+      Flush     : in     Flush_Mode);
+   --  translate routine without additional headers.
+
+   -----------------
+   -- Check_Error --
+   -----------------
+
+   procedure Check_Error (Stream : in Z_Stream; Code : in Thin.Int) is
+      use type Thin.Int;
+   begin
+      if Code /= Thin.Z_OK then
+         Raise_Error
+            (Return_Code_Enum'Image (Return_Code (Code))
+              & ": " & Last_Error_Message (Stream));
+      end if;
+   end Check_Error;
+
+   -----------
+   -- Close --
+   -----------
+
+   procedure Close
+     (Filter       : in out Filter_Type;
+      Ignore_Error : in     Boolean := False)
+   is
+      Code : Thin.Int;
+   begin
+      if not Ignore_Error and then not Is_Open (Filter) then
+         raise Status_Error;
+      end if;
+
+      Code := Flate (Filter.Compression).Done (To_Thin_Access (Filter.Strm));
+
+      if Ignore_Error or else Code = Thin.Z_OK then
+         Free (Filter.Strm);
+      else
+         declare
+            Error_Message : constant String
+              := Last_Error_Message (Filter.Strm.all);
+         begin
+            Free (Filter.Strm);
+            Ada.Exceptions.Raise_Exception
+               (ZLib_Error'Identity,
+                Return_Code_Enum'Image (Return_Code (Code))
+                  & ": " & Error_Message);
+         end;
+      end if;
+   end Close;
+
+   -----------
+   -- CRC32 --
+   -----------
+
+   function CRC32
+     (CRC  : in Unsigned_32;
+      Data : in Ada.Streams.Stream_Element_Array)
+      return Unsigned_32
+   is
+      use Thin;
+   begin
+      return Unsigned_32 (crc32 (ULong (CRC),
+                                 Data'Address,
+                                 Data'Length));
+   end CRC32;
+
+   procedure CRC32
+     (CRC  : in out Unsigned_32;
+      Data : in     Ada.Streams.Stream_Element_Array) is
+   begin
+      CRC := CRC32 (CRC, Data);
+   end CRC32;
+
+   ------------------
+   -- Deflate_Init --
+   ------------------
+
+   procedure Deflate_Init
+     (Filter       : in out Filter_Type;
+      Level        : in     Compression_Level  := Default_Compression;
+      Strategy     : in     Strategy_Type      := Default_Strategy;
+      Method       : in     Compression_Method := Deflated;
+      Window_Bits  : in     Window_Bits_Type   := Default_Window_Bits;
+      Memory_Level : in     Memory_Level_Type  := Default_Memory_Level;
+      Header       : in     Header_Type        := Default)
+   is
+      use type Thin.Int;
+      Win_Bits : Thin.Int := Thin.Int (Window_Bits);
+   begin
+      if Is_Open (Filter) then
+         raise Status_Error;
+      end if;
+
+      --  We allow ZLib to make header only in case of default header type.
+      --  Otherwise we would either do header by ourselfs, or do not do
+      --  header at all.
+
+      if Header = None or else Header = GZip then
+         Win_Bits := -Win_Bits;
+      end if;
+
+      --  For the GZip CRC calculation and make headers.
+
+      if Header = GZip then
+         Filter.CRC    := 0;
+         Filter.Offset := Simple_GZip_Header'First;
+      else
+         Filter.Offset := Simple_GZip_Header'Last + 1;
+      end if;
+
+      Filter.Strm        := new Z_Stream;
+      Filter.Compression := True;
+      Filter.Stream_End  := False;
+      Filter.Header      := Header;
+
+      if Thin.Deflate_Init
+           (To_Thin_Access (Filter.Strm),
+            Level      => Thin.Int (Level),
+            method     => Thin.Int (Method),
+            windowBits => Win_Bits,
+            memLevel   => Thin.Int (Memory_Level),
+            strategy   => Thin.Int (Strategy)) /= Thin.Z_OK
+      then
+         Raise_Error (Filter.Strm.all);
+      end if;
+   end Deflate_Init;
+
+   -----------
+   -- Flush --
+   -----------
+
+   procedure Flush
+     (Filter    : in out Filter_Type;
+      Out_Data  :    out Ada.Streams.Stream_Element_Array;
+      Out_Last  :    out Ada.Streams.Stream_Element_Offset;
+      Flush     : in     Flush_Mode)
+   is
+      No_Data : Stream_Element_Array := (1 .. 0 => 0);
+      Last    : Stream_Element_Offset;
+   begin
+      Translate (Filter, No_Data, Last, Out_Data, Out_Last, Flush);
+   end Flush;
+
+   -----------------------
+   -- Generic_Translate --
+   -----------------------
+
+   procedure Generic_Translate
+     (Filter          : in out ZLib.Filter_Type;
+      In_Buffer_Size  : in     Integer := Default_Buffer_Size;
+      Out_Buffer_Size : in     Integer := Default_Buffer_Size)
+   is
+      In_Buffer  : Stream_Element_Array
+                     (1 .. Stream_Element_Offset (In_Buffer_Size));
+      Out_Buffer : Stream_Element_Array
+                     (1 .. Stream_Element_Offset (Out_Buffer_Size));
+      Last       : Stream_Element_Offset;
+      In_Last    : Stream_Element_Offset;
+      In_First   : Stream_Element_Offset;
+      Out_Last   : Stream_Element_Offset;
+   begin
+      Main : loop
+         Data_In (In_Buffer, Last);
+
+         In_First := In_Buffer'First;
+
+         loop
+            Translate
+              (Filter   => Filter,
+               In_Data  => In_Buffer (In_First .. Last),
+               In_Last  => In_Last,
+               Out_Data => Out_Buffer,
+               Out_Last => Out_Last,
+               Flush    => Flush_Finish (Last < In_Buffer'First));
+
+            if Out_Buffer'First <= Out_Last then
+               Data_Out (Out_Buffer (Out_Buffer'First .. Out_Last));
+            end if;
+
+            exit Main when Stream_End (Filter);
+
+            --  The end of in buffer.
+
+            exit when In_Last = Last;
+
+            In_First := In_Last + 1;
+         end loop;
+      end loop Main;
+
+   end Generic_Translate;
+
+   ------------------
+   -- Inflate_Init --
+   ------------------
+
+   procedure Inflate_Init
+     (Filter      : in out Filter_Type;
+      Window_Bits : in     Window_Bits_Type := Default_Window_Bits;
+      Header      : in     Header_Type      := Default)
+   is
+      use type Thin.Int;
+      Win_Bits : Thin.Int := Thin.Int (Window_Bits);
+
+      procedure Check_Version;
+      --  Check the latest header types compatibility.
+
+      procedure Check_Version is
+      begin
+         if Version <= "1.1.4" then
+            Raise_Error
+              ("Inflate header type " & Header_Type'Image (Header)
+               & " incompatible with ZLib version " & Version);
+         end if;
+      end Check_Version;
+
+   begin
+      if Is_Open (Filter) then
+         raise Status_Error;
+      end if;
+
+      case Header is
+         when None =>
+            Check_Version;
+
+            --  Inflate data without headers determined
+            --  by negative Win_Bits.
+
+            Win_Bits := -Win_Bits;
+         when GZip =>
+            Check_Version;
+
+            --  Inflate gzip data defined by flag 16.
+
+            Win_Bits := Win_Bits + 16;
+         when Auto =>
+            Check_Version;
+
+            --  Inflate with automatic detection
+            --  of gzip or native header defined by flag 32.
+
+            Win_Bits := Win_Bits + 32;
+         when Default => null;
+      end case;
+
+      Filter.Strm        := new Z_Stream;
+      Filter.Compression := False;
+      Filter.Stream_End  := False;
+      Filter.Header      := Header;
+
+      if Thin.Inflate_Init
+         (To_Thin_Access (Filter.Strm), Win_Bits) /= Thin.Z_OK
+      then
+         Raise_Error (Filter.Strm.all);
+      end if;
+   end Inflate_Init;
+
+   -------------
+   -- Is_Open --
+   -------------
+
+   function Is_Open (Filter : in Filter_Type) return Boolean is
+   begin
+      return Filter.Strm /= null;
+   end Is_Open;
+
+   -----------------
+   -- Raise_Error --
+   -----------------
+
+   procedure Raise_Error (Message : in String) is
+   begin
+      Ada.Exceptions.Raise_Exception (ZLib_Error'Identity, Message);
+   end Raise_Error;
+
+   procedure Raise_Error (Stream : in Z_Stream) is
+   begin
+      Raise_Error (Last_Error_Message (Stream));
+   end Raise_Error;
+
+   ----------
+   -- Read --
+   ----------
+
+   procedure Read
+     (Filter : in out Filter_Type;
+      Item   :    out Ada.Streams.Stream_Element_Array;
+      Last   :    out Ada.Streams.Stream_Element_Offset;
+      Flush  : in     Flush_Mode := No_Flush)
+   is
+      In_Last    : Stream_Element_Offset;
+      Item_First : Ada.Streams.Stream_Element_Offset := Item'First;
+      V_Flush    : Flush_Mode := Flush;
+
+   begin
+      pragma Assert (Rest_First in Buffer'First .. Buffer'Last + 1);
+      pragma Assert (Rest_Last in Buffer'First - 1 .. Buffer'Last);
+
+      loop
+         if Rest_Last = Buffer'First - 1 then
+            V_Flush := Finish;
+
+         elsif Rest_First > Rest_Last then
+            Read (Buffer, Rest_Last);
+            Rest_First := Buffer'First;
+
+            if Rest_Last < Buffer'First then
+               V_Flush := Finish;
+            end if;
+         end if;
+
+         Translate
+           (Filter   => Filter,
+            In_Data  => Buffer (Rest_First .. Rest_Last),
+            In_Last  => In_Last,
+            Out_Data => Item (Item_First .. Item'Last),
+            Out_Last => Last,
+            Flush    => V_Flush);
+
+         Rest_First := In_Last + 1;
+
+         exit when Stream_End (Filter)
+           or else Last = Item'Last
+           or else (Last >= Item'First and then Allow_Read_Some);
+
+         Item_First := Last + 1;
+      end loop;
+   end Read;
+
+   ----------------
+   -- Stream_End --
+   ----------------
+
+   function Stream_End (Filter : in Filter_Type) return Boolean is
+   begin
+      if Filter.Header = GZip and Filter.Compression then
+         return Filter.Stream_End
+            and then Filter.Offset = Footer_Array'Last + 1;
+      else
+         return Filter.Stream_End;
+      end if;
+   end Stream_End;
+
+   --------------
+   -- Total_In --
+   --------------
+
+   function Total_In (Filter : in Filter_Type) return Count is
+   begin
+      return Count (Thin.Total_In (To_Thin_Access (Filter.Strm).all));
+   end Total_In;
+
+   ---------------
+   -- Total_Out --
+   ---------------
+
+   function Total_Out (Filter : in Filter_Type) return Count is
+   begin
+      return Count (Thin.Total_Out (To_Thin_Access (Filter.Strm).all));
+   end Total_Out;
+
+   ---------------
+   -- Translate --
+   ---------------
+
+   procedure Translate
+     (Filter    : in out Filter_Type;
+      In_Data   : in     Ada.Streams.Stream_Element_Array;
+      In_Last   :    out Ada.Streams.Stream_Element_Offset;
+      Out_Data  :    out Ada.Streams.Stream_Element_Array;
+      Out_Last  :    out Ada.Streams.Stream_Element_Offset;
+      Flush     : in     Flush_Mode) is
+   begin
+      if Filter.Header = GZip and then Filter.Compression then
+         Translate_GZip
+           (Filter   => Filter,
+            In_Data  => In_Data,
+            In_Last  => In_Last,
+            Out_Data => Out_Data,
+            Out_Last => Out_Last,
+            Flush    => Flush);
+      else
+         Translate_Auto
+           (Filter   => Filter,
+            In_Data  => In_Data,
+            In_Last  => In_Last,
+            Out_Data => Out_Data,
+            Out_Last => Out_Last,
+            Flush    => Flush);
+      end if;
+   end Translate;
+
+   --------------------
+   -- Translate_Auto --
+   --------------------
+
+   procedure Translate_Auto
+     (Filter    : in out Filter_Type;
+      In_Data   : in     Ada.Streams.Stream_Element_Array;
+      In_Last   :    out Ada.Streams.Stream_Element_Offset;
+      Out_Data  :    out Ada.Streams.Stream_Element_Array;
+      Out_Last  :    out Ada.Streams.Stream_Element_Offset;
+      Flush     : in     Flush_Mode)
+   is
+      use type Thin.Int;
+      Code : Thin.Int;
+
+   begin
+      if not Is_Open (Filter) then
+         raise Status_Error;
+      end if;
+
+      if Out_Data'Length = 0 and then In_Data'Length = 0 then
+         raise Constraint_Error;
+      end if;
+
+      Set_Out (Filter.Strm.all, Out_Data'Address, Out_Data'Length);
+      Set_In  (Filter.Strm.all, In_Data'Address, In_Data'Length);
+
+      Code := Flate (Filter.Compression).Step
+        (To_Thin_Access (Filter.Strm),
+         Thin.Int (Flush));
+
+      if Code = Thin.Z_STREAM_END then
+         Filter.Stream_End := True;
+      else
+         Check_Error (Filter.Strm.all, Code);
+      end if;
+
+      In_Last  := In_Data'Last
+         - Stream_Element_Offset (Avail_In (Filter.Strm.all));
+      Out_Last := Out_Data'Last
+         - Stream_Element_Offset (Avail_Out (Filter.Strm.all));
+   end Translate_Auto;
+
+   --------------------
+   -- Translate_GZip --
+   --------------------
+
+   procedure Translate_GZip
+     (Filter    : in out Filter_Type;
+      In_Data   : in     Ada.Streams.Stream_Element_Array;
+      In_Last   :    out Ada.Streams.Stream_Element_Offset;
+      Out_Data  :    out Ada.Streams.Stream_Element_Array;
+      Out_Last  :    out Ada.Streams.Stream_Element_Offset;
+      Flush     : in     Flush_Mode)
+   is
+      Out_First : Stream_Element_Offset;
+
+      procedure Add_Data (Data : in Stream_Element_Array);
+      --  Add data to stream from the Filter.Offset till necessary,
+      --  used for add gzip headr/footer.
+
+      procedure Put_32
+        (Item : in out Stream_Element_Array;
+         Data : in     Unsigned_32);
+      pragma Inline (Put_32);
+
+      --------------
+      -- Add_Data --
+      --------------
+
+      procedure Add_Data (Data : in Stream_Element_Array) is
+         Data_First : Stream_Element_Offset renames Filter.Offset;
+         Data_Last  : Stream_Element_Offset;
+         Data_Len   : Stream_Element_Offset; --  -1
+         Out_Len    : Stream_Element_Offset; --  -1
+      begin
+         Out_First := Out_Last + 1;
+
+         if Data_First > Data'Last then
+            return;
+         end if;
+
+         Data_Len  := Data'Last     - Data_First;
+         Out_Len   := Out_Data'Last - Out_First;
+
+         if Data_Len <= Out_Len then
+            Out_Last  := Out_First  + Data_Len;
+            Data_Last := Data'Last;
+         else
+            Out_Last  := Out_Data'Last;
+            Data_Last := Data_First + Out_Len;
+         end if;
+
+         Out_Data (Out_First .. Out_Last) := Data (Data_First .. Data_Last);
+
+         Data_First := Data_Last + 1;
+         Out_First  := Out_Last + 1;
+      end Add_Data;
+
+      ------------
+      -- Put_32 --
+      ------------
+
+      procedure Put_32
+        (Item : in out Stream_Element_Array;
+         Data : in     Unsigned_32)
+      is
+         D : Unsigned_32 := Data;
+      begin
+         for J in Item'First .. Item'First + 3 loop
+            Item (J) := Stream_Element (D and 16#FF#);
+            D := Shift_Right (D, 8);
+         end loop;
+      end Put_32;
+
+   begin
+      Out_Last := Out_Data'First - 1;
+
+      if not Filter.Stream_End then
+         Add_Data (Simple_GZip_Header);
+
+         Translate_Auto
+           (Filter   => Filter,
+            In_Data  => In_Data,
+            In_Last  => In_Last,
+            Out_Data => Out_Data (Out_First .. Out_Data'Last),
+            Out_Last => Out_Last,
+            Flush    => Flush);
+
+         CRC32 (Filter.CRC, In_Data (In_Data'First .. In_Last));
+      end if;
+
+      if Filter.Stream_End and then Out_Last <= Out_Data'Last then
+         --  This detection method would work only when
+         --  Simple_GZip_Header'Last > Footer_Array'Last
+
+         if Filter.Offset = Simple_GZip_Header'Last + 1 then
+            Filter.Offset := Footer_Array'First;
+         end if;
+
+         declare
+            Footer : Footer_Array;
+         begin
+            Put_32 (Footer, Filter.CRC);
+            Put_32 (Footer (Footer'First + 4 .. Footer'Last),
+                    Unsigned_32 (Total_In (Filter)));
+            Add_Data (Footer);
+         end;
+      end if;
+   end Translate_GZip;
+
+   -------------
+   -- Version --
+   -------------
+
+   function Version return String is
+   begin
+      return Interfaces.C.Strings.Value (Thin.zlibVersion);
+   end Version;
+
+   -----------
+   -- Write --
+   -----------
+
+   procedure Write
+     (Filter : in out Filter_Type;
+      Item   : in     Ada.Streams.Stream_Element_Array;
+      Flush  : in     Flush_Mode := No_Flush)
+   is
+      Buffer   : Stream_Element_Array (1 .. Buffer_Size);
+      In_Last  : Stream_Element_Offset;
+      Out_Last : Stream_Element_Offset;
+      In_First : Stream_Element_Offset := Item'First;
+   begin
+      if Item'Length = 0 and Flush = No_Flush then
+         return;
+      end if;
+
+      loop
+         Translate
+           (Filter   => Filter,
+            In_Data  => Item (In_First .. Item'Last),
+            In_Last  => In_Last,
+            Out_Data => Buffer,
+            Out_Last => Out_Last,
+            Flush    => Flush);
+
+         if Out_Last >= Buffer'First then
+            Write (Buffer (1 .. Out_Last));
+         end if;
+
+         exit when In_Last = Item'Last or Stream_End (Filter);
+
+         In_First := In_Last + 1;
+      end loop;
+   end Write;
+
+end ZLib;
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/ada/zlib.ads b/Engine/lib/assimp/contrib/zlib/contrib/ada/zlib.ads
new file mode 100644
index 000000000..79ffc4095
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/ada/zlib.ads
@@ -0,0 +1,328 @@
+------------------------------------------------------------------------------
+--                      ZLib for Ada thick binding.                         --
+--                                                                          --
+--              Copyright (C) 2002-2004 Dmitriy Anisimkov                   --
+--                                                                          --
+--  This library is free software; you can redistribute it and/or modify    --
+--  it under the terms of the GNU General Public License as published by    --
+--  the Free Software Foundation; either version 2 of the License, or (at   --
+--  your option) any later version.                                         --
+--                                                                          --
+--  This library is distributed in the hope that it will be useful, but     --
+--  WITHOUT ANY WARRANTY; without even the implied warranty of              --
+--  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU       --
+--  General Public License for more details.                                --
+--                                                                          --
+--  You should have received a copy of the GNU General Public License       --
+--  along with this library; if not, write to the Free Software Foundation, --
+--  Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.          --
+--                                                                          --
+--  As a special exception, if other files instantiate generics from this   --
+--  unit, or you link this unit with other files to produce an executable,  --
+--  this  unit  does not  by itself cause  the resulting executable to be   --
+--  covered by the GNU General Public License. This exception does not      --
+--  however invalidate any other reasons why the executable file  might be  --
+--  covered by the  GNU Public License.                                     --
+------------------------------------------------------------------------------
+
+--  $Id: zlib.ads,v 1.26 2004/09/06 06:53:19 vagul Exp $
+
+with Ada.Streams;
+
+with Interfaces;
+
+package ZLib is
+
+   ZLib_Error   : exception;
+   Status_Error : exception;
+
+   type Compression_Level is new Integer range -1 .. 9;
+
+   type Flush_Mode is private;
+
+   type Compression_Method is private;
+
+   type Window_Bits_Type is new Integer range 8 .. 15;
+
+   type Memory_Level_Type is new Integer range 1 .. 9;
+
+   type Unsigned_32 is new Interfaces.Unsigned_32;
+
+   type Strategy_Type is private;
+
+   type Header_Type is (None, Auto, Default, GZip);
+   --  Header type usage have a some limitation for inflate.
+   --  See comment for Inflate_Init.
+
+   subtype Count is Ada.Streams.Stream_Element_Count;
+
+   Default_Memory_Level : constant Memory_Level_Type := 8;
+   Default_Window_Bits  : constant Window_Bits_Type  := 15;
+
+   ----------------------------------
+   -- Compression method constants --
+   ----------------------------------
+
+   Deflated : constant Compression_Method;
+   --  Only one method allowed in this ZLib version
+
+   ---------------------------------
+   -- Compression level constants --
+   ---------------------------------
+
+   No_Compression      : constant Compression_Level := 0;
+   Best_Speed          : constant Compression_Level := 1;
+   Best_Compression    : constant Compression_Level := 9;
+   Default_Compression : constant Compression_Level := -1;
+
+   --------------------------
+   -- Flush mode constants --
+   --------------------------
+
+   No_Flush      : constant Flush_Mode;
+   --  Regular way for compression, no flush
+
+   Partial_Flush : constant Flush_Mode;
+   --  Will be removed, use Z_SYNC_FLUSH instead
+
+   Sync_Flush    : constant Flush_Mode;
+   --  All pending output is flushed to the output buffer and the output
+   --  is aligned on a byte boundary, so that the decompressor can get all
+   --  input data available so far. (In particular avail_in is zero after the
+   --  call if enough output space has been provided  before the call.)
+   --  Flushing may degrade compression for some compression algorithms and so
+   --  it should be used only when necessary.
+
+   Block_Flush   : constant Flush_Mode;
+   --  Z_BLOCK requests that inflate() stop
+   --  if and when it get to the next deflate block boundary. When decoding the
+   --  zlib or gzip format, this will cause inflate() to return immediately
+   --  after the header and before the first block. When doing a raw inflate,
+   --  inflate() will go ahead and process the first block, and will return
+   --  when it gets to the end of that block, or when it runs out of data.
+
+   Full_Flush    : constant Flush_Mode;
+   --  All output is flushed as with SYNC_FLUSH, and the compression state
+   --  is reset so that decompression can restart from this point if previous
+   --  compressed data has been damaged or if random access is desired. Using
+   --  Full_Flush too often can seriously degrade the compression.
+
+   Finish        : constant Flush_Mode;
+   --  Just for tell the compressor that input data is complete.
+
+   ------------------------------------
+   -- Compression strategy constants --
+   ------------------------------------
+
+   --  RLE stategy could be used only in version 1.2.0 and later.
+
+   Filtered         : constant Strategy_Type;
+   Huffman_Only     : constant Strategy_Type;
+   RLE              : constant Strategy_Type;
+   Default_Strategy : constant Strategy_Type;
+
+   Default_Buffer_Size : constant := 4096;
+
+   type Filter_Type is tagged limited private;
+   --  The filter is for compression and for decompression.
+   --  The usage of the type is depend of its initialization.
+
+   function Version return String;
+   pragma Inline (Version);
+   --  Return string representation of the ZLib version.
+
+   procedure Deflate_Init
+     (Filter       : in out Filter_Type;
+      Level        : in     Compression_Level  := Default_Compression;
+      Strategy     : in     Strategy_Type      := Default_Strategy;
+      Method       : in     Compression_Method := Deflated;
+      Window_Bits  : in     Window_Bits_Type   := Default_Window_Bits;
+      Memory_Level : in     Memory_Level_Type  := Default_Memory_Level;
+      Header       : in     Header_Type        := Default);
+   --  Compressor initialization.
+   --  When Header parameter is Auto or Default, then default zlib header
+   --  would be provided for compressed data.
+   --  When Header is GZip, then gzip header would be set instead of
+   --  default header.
+   --  When Header is None, no header would be set for compressed data.
+
+   procedure Inflate_Init
+     (Filter      : in out Filter_Type;
+      Window_Bits : in     Window_Bits_Type := Default_Window_Bits;
+      Header      : in     Header_Type      := Default);
+   --  Decompressor initialization.
+   --  Default header type mean that ZLib default header is expecting in the
+   --  input compressed stream.
+   --  Header type None mean that no header is expecting in the input stream.
+   --  GZip header type mean that GZip header is expecting in the
+   --  input compressed stream.
+   --  Auto header type mean that header type (GZip or Native) would be
+   --  detected automatically in the input stream.
+   --  Note that header types parameter values None, GZip and Auto are
+   --  supported for inflate routine only in ZLib versions 1.2.0.2 and later.
+   --  Deflate_Init is supporting all header types.
+
+   function Is_Open (Filter : in Filter_Type) return Boolean;
+   pragma Inline (Is_Open);
+   --  Is the filter opened for compression or decompression.
+
+   procedure Close
+     (Filter       : in out Filter_Type;
+      Ignore_Error : in     Boolean := False);
+   --  Closing the compression or decompressor.
+   --  If stream is closing before the complete and Ignore_Error is False,
+   --  The exception would be raised.
+
+   generic
+      with procedure Data_In
+        (Item : out Ada.Streams.Stream_Element_Array;
+         Last : out Ada.Streams.Stream_Element_Offset);
+      with procedure Data_Out
+        (Item : in Ada.Streams.Stream_Element_Array);
+   procedure Generic_Translate
+     (Filter          : in out Filter_Type;
+      In_Buffer_Size  : in     Integer := Default_Buffer_Size;
+      Out_Buffer_Size : in     Integer := Default_Buffer_Size);
+   --  Compress/decompress data fetch from Data_In routine and pass the result
+   --  to the Data_Out routine. User should provide Data_In and Data_Out
+   --  for compression/decompression data flow.
+   --  Compression or decompression depend on Filter initialization.
+
+   function Total_In (Filter : in Filter_Type) return Count;
+   pragma Inline (Total_In);
+   --  Returns total number of input bytes read so far
+
+   function Total_Out (Filter : in Filter_Type) return Count;
+   pragma Inline (Total_Out);
+   --  Returns total number of bytes output so far
+
+   function CRC32
+     (CRC    : in Unsigned_32;
+      Data   : in Ada.Streams.Stream_Element_Array)
+      return Unsigned_32;
+   pragma Inline (CRC32);
+   --  Compute CRC32, it could be necessary for make gzip format
+
+   procedure CRC32
+     (CRC  : in out Unsigned_32;
+      Data : in     Ada.Streams.Stream_Element_Array);
+   pragma Inline (CRC32);
+   --  Compute CRC32, it could be necessary for make gzip format
+
+   -------------------------------------------------
+   --  Below is more complex low level routines.  --
+   -------------------------------------------------
+
+   procedure Translate
+     (Filter    : in out Filter_Type;
+      In_Data   : in     Ada.Streams.Stream_Element_Array;
+      In_Last   :    out Ada.Streams.Stream_Element_Offset;
+      Out_Data  :    out Ada.Streams.Stream_Element_Array;
+      Out_Last  :    out Ada.Streams.Stream_Element_Offset;
+      Flush     : in     Flush_Mode);
+   --  Compress/decompress the In_Data buffer and place the result into
+   --  Out_Data. In_Last is the index of last element from In_Data accepted by
+   --  the Filter. Out_Last is the last element of the received data from
+   --  Filter. To tell the filter that incoming data are complete put the
+   --  Flush parameter to Finish.
+
+   function Stream_End (Filter : in Filter_Type) return Boolean;
+   pragma Inline (Stream_End);
+   --  Return the true when the stream is complete.
+
+   procedure Flush
+     (Filter    : in out Filter_Type;
+      Out_Data  :    out Ada.Streams.Stream_Element_Array;
+      Out_Last  :    out Ada.Streams.Stream_Element_Offset;
+      Flush     : in     Flush_Mode);
+   pragma Inline (Flush);
+   --  Flushing the data from the compressor.
+
+   generic
+      with procedure Write
+        (Item : in Ada.Streams.Stream_Element_Array);
+      --  User should provide this routine for accept
+      --  compressed/decompressed data.
+
+      Buffer_Size : in Ada.Streams.Stream_Element_Offset
+         := Default_Buffer_Size;
+      --  Buffer size for Write user routine.
+
+   procedure Write
+     (Filter  : in out Filter_Type;
+      Item    : in     Ada.Streams.Stream_Element_Array;
+      Flush   : in     Flush_Mode := No_Flush);
+   --  Compress/Decompress data from Item to the generic parameter procedure
+   --  Write. Output buffer size could be set in Buffer_Size generic parameter.
+
+   generic
+      with procedure Read
+        (Item : out Ada.Streams.Stream_Element_Array;
+         Last : out Ada.Streams.Stream_Element_Offset);
+      --  User should provide data for compression/decompression
+      --  thru this routine.
+
+      Buffer : in out Ada.Streams.Stream_Element_Array;
+      --  Buffer for keep remaining data from the previous
+      --  back read.
+
+      Rest_First, Rest_Last : in out Ada.Streams.Stream_Element_Offset;
+      --  Rest_First have to be initialized to Buffer'Last + 1
+      --  Rest_Last have to be initialized to Buffer'Last
+      --  before usage.
+
+      Allow_Read_Some : in Boolean := False;
+      --  Is it allowed to return Last < Item'Last before end of data.
+
+   procedure Read
+     (Filter : in out Filter_Type;
+      Item   :    out Ada.Streams.Stream_Element_Array;
+      Last   :    out Ada.Streams.Stream_Element_Offset;
+      Flush  : in     Flush_Mode := No_Flush);
+   --  Compress/Decompress data from generic parameter procedure Read to the
+   --  Item. User should provide Buffer and initialized Rest_First, Rest_Last
+   --  indicators. If Allow_Read_Some is True, Read routines could return
+   --  Last < Item'Last only at end of stream.
+
+private
+
+   use Ada.Streams;
+
+   pragma Assert (Ada.Streams.Stream_Element'Size    =    8);
+   pragma Assert (Ada.Streams.Stream_Element'Modulus = 2**8);
+
+   type Flush_Mode is new Integer range 0 .. 5;
+
+   type Compression_Method is new Integer range 8 .. 8;
+
+   type Strategy_Type is new Integer range 0 .. 3;
+
+   No_Flush      : constant Flush_Mode := 0;
+   Partial_Flush : constant Flush_Mode := 1;
+   Sync_Flush    : constant Flush_Mode := 2;
+   Full_Flush    : constant Flush_Mode := 3;
+   Finish        : constant Flush_Mode := 4;
+   Block_Flush   : constant Flush_Mode := 5;
+
+   Filtered         : constant Strategy_Type := 1;
+   Huffman_Only     : constant Strategy_Type := 2;
+   RLE              : constant Strategy_Type := 3;
+   Default_Strategy : constant Strategy_Type := 0;
+
+   Deflated : constant Compression_Method := 8;
+
+   type Z_Stream;
+
+   type Z_Stream_Access is access all Z_Stream;
+
+   type Filter_Type is tagged limited record
+      Strm        : Z_Stream_Access;
+      Compression : Boolean;
+      Stream_End  : Boolean;
+      Header      : Header_Type;
+      CRC         : Unsigned_32;
+      Offset      : Stream_Element_Offset;
+      --  Offset for gzip header/footer output.
+   end record;
+
+end ZLib;
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/ada/zlib.gpr b/Engine/lib/assimp/contrib/zlib/contrib/ada/zlib.gpr
new file mode 100644
index 000000000..296b22aa9
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/ada/zlib.gpr
@@ -0,0 +1,20 @@
+project Zlib is
+
+   for Languages use ("Ada");
+   for Source_Dirs use (".");
+   for Object_Dir use ".";
+   for Main use ("test.adb", "mtest.adb", "read.adb", "buffer_demo");
+
+   package Compiler is
+      for Default_Switches ("ada") use ("-gnatwcfilopru", "-gnatVcdfimorst", "-gnatyabcefhiklmnoprst");
+   end Compiler;
+
+   package Linker is
+      for Default_Switches ("ada") use ("-lz");
+   end Linker;
+
+   package Builder is
+      for Default_Switches ("ada") use ("-s", "-gnatQ");
+   end Builder;
+
+end Zlib;
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/amd64/amd64-match.S b/Engine/lib/assimp/contrib/zlib/contrib/amd64/amd64-match.S
new file mode 100644
index 000000000..81d4a1c94
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/amd64/amd64-match.S
@@ -0,0 +1,452 @@
+/*
+ * match.S -- optimized version of longest_match()
+ * based on the similar work by Gilles Vollant, and Brian Raiter, written 1998
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the BSD License. Use by owners of Che Guevarra
+ * parafernalia is prohibited, where possible, and highly discouraged
+ * elsewhere.
+ */
+
+#ifndef NO_UNDERLINE
+#	define	match_init	_match_init
+#	define	longest_match	_longest_match
+#endif
+
+#define	scanend		ebx
+#define	scanendw	bx
+#define	chainlenwmask	edx /* high word: current chain len low word: s->wmask */
+#define	curmatch	rsi
+#define	curmatchd	esi
+#define	windowbestlen	r8
+#define	scanalign	r9
+#define	scanalignd	r9d
+#define	window		r10
+#define	bestlen		r11
+#define	bestlend	r11d
+#define	scanstart	r12d
+#define	scanstartw	r12w
+#define scan		r13
+#define nicematch	r14d
+#define	limit		r15
+#define	limitd		r15d
+#define prev		rcx
+
+/*
+ * The 258 is a "magic number, not a parameter -- changing it
+ * breaks the hell loose
+ */
+#define	MAX_MATCH	(258)
+#define	MIN_MATCH	(3)
+#define	MIN_LOOKAHEAD	(MAX_MATCH + MIN_MATCH + 1)
+#define	MAX_MATCH_8	((MAX_MATCH + 7) & ~7)
+
+/* stack frame offsets */
+#define	LocalVarsSize	(112)
+#define _chainlenwmask	( 8-LocalVarsSize)(%rsp)
+#define _windowbestlen	(16-LocalVarsSize)(%rsp)
+#define save_r14        (24-LocalVarsSize)(%rsp)
+#define save_rsi        (32-LocalVarsSize)(%rsp)
+#define save_rbx        (40-LocalVarsSize)(%rsp)
+#define save_r12        (56-LocalVarsSize)(%rsp)
+#define save_r13        (64-LocalVarsSize)(%rsp)
+#define save_r15        (80-LocalVarsSize)(%rsp)
+
+
+.globl	match_init, longest_match
+
+/*
+ * On AMD64 the first argument of a function (in our case -- the pointer to
+ * deflate_state structure) is passed in %rdi, hence our offsets below are
+ * all off of that.
+ */
+
+/* you can check the structure offset by running
+
+#include <stdlib.h>
+#include <stdio.h>
+#include "deflate.h"
+
+void print_depl()
+{
+deflate_state ds;
+deflate_state *s=&ds;
+printf("size pointer=%u\n",(int)sizeof(void*));
+
+printf("#define dsWSize         (%3u)(%%rdi)\n",(int)(((char*)&(s->w_size))-((char*)s)));
+printf("#define dsWMask         (%3u)(%%rdi)\n",(int)(((char*)&(s->w_mask))-((char*)s)));
+printf("#define dsWindow        (%3u)(%%rdi)\n",(int)(((char*)&(s->window))-((char*)s)));
+printf("#define dsPrev          (%3u)(%%rdi)\n",(int)(((char*)&(s->prev))-((char*)s)));
+printf("#define dsMatchLen      (%3u)(%%rdi)\n",(int)(((char*)&(s->match_length))-((char*)s)));
+printf("#define dsPrevMatch     (%3u)(%%rdi)\n",(int)(((char*)&(s->prev_match))-((char*)s)));
+printf("#define dsStrStart      (%3u)(%%rdi)\n",(int)(((char*)&(s->strstart))-((char*)s)));
+printf("#define dsMatchStart    (%3u)(%%rdi)\n",(int)(((char*)&(s->match_start))-((char*)s)));
+printf("#define dsLookahead     (%3u)(%%rdi)\n",(int)(((char*)&(s->lookahead))-((char*)s)));
+printf("#define dsPrevLen       (%3u)(%%rdi)\n",(int)(((char*)&(s->prev_length))-((char*)s)));
+printf("#define dsMaxChainLen   (%3u)(%%rdi)\n",(int)(((char*)&(s->max_chain_length))-((char*)s)));
+printf("#define dsGoodMatch     (%3u)(%%rdi)\n",(int)(((char*)&(s->good_match))-((char*)s)));
+printf("#define dsNiceMatch     (%3u)(%%rdi)\n",(int)(((char*)&(s->nice_match))-((char*)s)));
+}
+
+*/
+
+
+/*
+  to compile for XCode 3.2 on MacOSX x86_64
+  - run "gcc -g -c -DXCODE_MAC_X64_STRUCTURE amd64-match.S"
+ */
+
+
+#ifndef CURRENT_LINX_XCODE_MAC_X64_STRUCTURE
+#define dsWSize		( 68)(%rdi)
+#define dsWMask		( 76)(%rdi)
+#define dsWindow	( 80)(%rdi)
+#define dsPrev		( 96)(%rdi)
+#define dsMatchLen	(144)(%rdi)
+#define dsPrevMatch	(148)(%rdi)
+#define dsStrStart	(156)(%rdi)
+#define dsMatchStart	(160)(%rdi)
+#define dsLookahead	(164)(%rdi)
+#define dsPrevLen	(168)(%rdi)
+#define dsMaxChainLen	(172)(%rdi)
+#define dsGoodMatch	(188)(%rdi)
+#define dsNiceMatch	(192)(%rdi)
+
+#else 
+
+#ifndef STRUCT_OFFSET
+#	define STRUCT_OFFSET	(0)
+#endif
+
+
+#define dsWSize		( 56 + STRUCT_OFFSET)(%rdi)
+#define dsWMask		( 64 + STRUCT_OFFSET)(%rdi)
+#define dsWindow	( 72 + STRUCT_OFFSET)(%rdi)
+#define dsPrev		( 88 + STRUCT_OFFSET)(%rdi)
+#define dsMatchLen	(136 + STRUCT_OFFSET)(%rdi)
+#define dsPrevMatch	(140 + STRUCT_OFFSET)(%rdi)
+#define dsStrStart	(148 + STRUCT_OFFSET)(%rdi)
+#define dsMatchStart	(152 + STRUCT_OFFSET)(%rdi)
+#define dsLookahead	(156 + STRUCT_OFFSET)(%rdi)
+#define dsPrevLen	(160 + STRUCT_OFFSET)(%rdi)
+#define dsMaxChainLen	(164 + STRUCT_OFFSET)(%rdi)
+#define dsGoodMatch	(180 + STRUCT_OFFSET)(%rdi)
+#define dsNiceMatch	(184 + STRUCT_OFFSET)(%rdi)
+
+#endif
+
+
+
+
+.text
+
+/* uInt longest_match(deflate_state *deflatestate, IPos curmatch) */
+
+longest_match:
+/*
+ * Retrieve the function arguments. %curmatch will hold cur_match
+ * throughout the entire function (passed via rsi on amd64).
+ * rdi will hold the pointer to the deflate_state (first arg on amd64)
+ */
+		mov     %rsi, save_rsi
+		mov     %rbx, save_rbx
+		mov	%r12, save_r12
+		mov     %r13, save_r13
+		mov     %r14, save_r14
+		mov     %r15, save_r15
+
+/* uInt wmask = s->w_mask;						*/
+/* unsigned chain_length = s->max_chain_length;				*/
+/* if (s->prev_length >= s->good_match) {				*/
+/*     chain_length >>= 2;						*/
+/* }									*/
+
+		movl	dsPrevLen, %eax
+		movl	dsGoodMatch, %ebx
+		cmpl	%ebx, %eax
+		movl	dsWMask, %eax
+		movl	dsMaxChainLen, %chainlenwmask
+		jl	LastMatchGood
+		shrl	$2, %chainlenwmask
+LastMatchGood:
+
+/* chainlen is decremented once beforehand so that the function can	*/
+/* use the sign flag instead of the zero flag for the exit test.	*/
+/* It is then shifted into the high word, to make room for the wmask	*/
+/* value, which it will always accompany.				*/
+
+		decl	%chainlenwmask
+		shll	$16, %chainlenwmask
+		orl	%eax, %chainlenwmask
+
+/* if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;	*/
+
+		movl	dsNiceMatch, %eax
+		movl	dsLookahead, %ebx
+		cmpl	%eax, %ebx
+		jl	LookaheadLess
+		movl	%eax, %ebx
+LookaheadLess:	movl	%ebx, %nicematch
+
+/* register Bytef *scan = s->window + s->strstart;			*/
+
+		mov	dsWindow, %window
+		movl	dsStrStart, %limitd
+		lea	(%limit, %window), %scan
+
+/* Determine how many bytes the scan ptr is off from being		*/
+/* dword-aligned.							*/
+
+		mov	%scan, %scanalign
+		negl	%scanalignd
+		andl	$3, %scanalignd
+
+/* IPos limit = s->strstart > (IPos)MAX_DIST(s) ?			*/
+/*     s->strstart - (IPos)MAX_DIST(s) : NIL;				*/
+
+		movl	dsWSize, %eax
+		subl	$MIN_LOOKAHEAD, %eax
+		xorl	%ecx, %ecx
+		subl	%eax, %limitd
+		cmovng	%ecx, %limitd
+
+/* int best_len = s->prev_length;					*/
+
+		movl	dsPrevLen, %bestlend
+
+/* Store the sum of s->window + best_len in %windowbestlen locally, and in memory.	*/
+
+		lea	(%window, %bestlen), %windowbestlen
+		mov	%windowbestlen, _windowbestlen
+
+/* register ush scan_start = *(ushf*)scan;				*/
+/* register ush scan_end   = *(ushf*)(scan+best_len-1);			*/
+/* Posf *prev = s->prev;						*/
+
+		movzwl	(%scan), %scanstart
+		movzwl	-1(%scan, %bestlen), %scanend
+		mov	dsPrev, %prev
+
+/* Jump into the main loop.						*/
+
+		movl	%chainlenwmask, _chainlenwmask
+		jmp	LoopEntry
+
+.balign 16
+
+/* do {
+ *     match = s->window + cur_match;
+ *     if (*(ushf*)(match+best_len-1) != scan_end ||
+ *         *(ushf*)match != scan_start) continue;
+ *     [...]
+ * } while ((cur_match = prev[cur_match & wmask]) > limit
+ *          && --chain_length != 0);
+ *
+ * Here is the inner loop of the function. The function will spend the
+ * majority of its time in this loop, and majority of that time will
+ * be spent in the first ten instructions.
+ */
+LookupLoop:
+		andl	%chainlenwmask, %curmatchd
+		movzwl	(%prev, %curmatch, 2), %curmatchd
+		cmpl	%limitd, %curmatchd
+		jbe	LeaveNow
+		subl	$0x00010000, %chainlenwmask
+		js	LeaveNow
+LoopEntry:	cmpw	-1(%windowbestlen, %curmatch), %scanendw
+		jne	LookupLoop
+		cmpw	%scanstartw, (%window, %curmatch)
+		jne	LookupLoop
+
+/* Store the current value of chainlen.					*/
+		movl	%chainlenwmask, _chainlenwmask
+
+/* %scan is the string under scrutiny, and %prev to the string we	*/
+/* are hoping to match it up with. In actuality, %esi and %edi are	*/
+/* both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and %edx is	*/
+/* initialized to -(MAX_MATCH_8 - scanalign).				*/
+
+		mov	$(-MAX_MATCH_8), %rdx
+		lea	(%curmatch, %window), %windowbestlen
+		lea	MAX_MATCH_8(%windowbestlen, %scanalign), %windowbestlen
+		lea	MAX_MATCH_8(%scan, %scanalign), %prev
+
+/* the prefetching below makes very little difference... */
+		prefetcht1	(%windowbestlen, %rdx)
+		prefetcht1	(%prev, %rdx)
+
+/*
+ * Test the strings for equality, 8 bytes at a time. At the end,
+ * adjust %rdx so that it is offset to the exact byte that mismatched.
+ *
+ * It should be confessed that this loop usually does not represent
+ * much of the total running time. Replacing it with a more
+ * straightforward "rep cmpsb" would not drastically degrade
+ * performance -- unrolling it, for example, makes no difference.
+ */
+
+#undef USE_SSE	/* works, but is 6-7% slower, than non-SSE... */
+
+LoopCmps:
+#ifdef USE_SSE
+		/* Preload the SSE registers */
+		movdqu	  (%windowbestlen, %rdx), %xmm1
+		movdqu	  (%prev, %rdx), %xmm2
+		pcmpeqb	%xmm2, %xmm1
+		movdqu	16(%windowbestlen, %rdx), %xmm3
+		movdqu	16(%prev, %rdx), %xmm4
+		pcmpeqb	%xmm4, %xmm3
+		movdqu	32(%windowbestlen, %rdx), %xmm5
+		movdqu	32(%prev, %rdx), %xmm6
+		pcmpeqb	%xmm6, %xmm5
+		movdqu	48(%windowbestlen, %rdx), %xmm7
+		movdqu	48(%prev, %rdx), %xmm8
+		pcmpeqb	%xmm8, %xmm7
+
+		/* Check the comparisions' results */
+		pmovmskb %xmm1, %rax
+		notw	%ax
+		bsfw	%ax, %ax
+		jnz	LeaveLoopCmps
+		
+		/* this is the only iteration of the loop with a possibility of having
+		   incremented rdx by 0x108 (each loop iteration add 16*4 = 0x40 
+		   and (0x40*4)+8=0x108 */
+		add	$8, %rdx
+		jz LenMaximum
+		add	$8, %rdx
+
+		
+		pmovmskb %xmm3, %rax
+		notw	%ax
+		bsfw	%ax, %ax
+		jnz	LeaveLoopCmps
+		
+		
+		add	$16, %rdx
+
+
+		pmovmskb %xmm5, %rax
+		notw	%ax
+		bsfw	%ax, %ax
+		jnz	LeaveLoopCmps
+		
+		add	$16, %rdx
+
+
+		pmovmskb %xmm7, %rax
+		notw	%ax
+		bsfw	%ax, %ax
+		jnz	LeaveLoopCmps
+		
+		add	$16, %rdx
+		
+		jmp	LoopCmps
+LeaveLoopCmps:	add	%rax, %rdx
+#else
+		mov	(%windowbestlen, %rdx), %rax
+		xor	(%prev, %rdx), %rax
+		jnz	LeaveLoopCmps
+		
+		mov	8(%windowbestlen, %rdx), %rax
+		xor	8(%prev, %rdx), %rax
+		jnz	LeaveLoopCmps8
+
+		mov	16(%windowbestlen, %rdx), %rax
+		xor	16(%prev, %rdx), %rax
+		jnz	LeaveLoopCmps16
+				
+		add	$24, %rdx
+		jnz	LoopCmps
+		jmp	LenMaximum
+#	if 0
+/*
+ * This three-liner is tantalizingly simple, but bsf is a slow instruction,
+ * and the complicated alternative down below is quite a bit faster. Sad...
+ */
+
+LeaveLoopCmps:	bsf	%rax, %rax /* find the first non-zero bit */
+		shrl	$3, %eax /* divide by 8 to get the byte */
+		add	%rax, %rdx
+#	else
+LeaveLoopCmps16:
+		add	$8, %rdx
+LeaveLoopCmps8:
+		add	$8, %rdx
+LeaveLoopCmps:	testl   $0xFFFFFFFF, %eax /* Check the first 4 bytes */
+		jnz     Check16
+		add     $4, %rdx
+		shr     $32, %rax
+Check16:        testw   $0xFFFF, %ax
+		jnz     LenLower
+		add	$2, %rdx
+		shrl	$16, %eax
+LenLower:	subb	$1, %al
+		adc	$0, %rdx
+#	endif
+#endif
+
+/* Calculate the length of the match. If it is longer than MAX_MATCH,	*/
+/* then automatically accept it as the best possible match and leave.	*/
+
+		lea	(%prev, %rdx), %rax
+		sub	%scan, %rax
+		cmpl	$MAX_MATCH, %eax
+		jge	LenMaximum
+
+/* If the length of the match is not longer than the best match we	*/
+/* have so far, then forget it and return to the lookup loop.		*/
+
+		cmpl	%bestlend, %eax
+		jg	LongerMatch
+		mov	_windowbestlen, %windowbestlen
+		mov	dsPrev, %prev
+		movl	_chainlenwmask, %edx
+		jmp	LookupLoop
+
+/*         s->match_start = cur_match;					*/
+/*         best_len = len;						*/
+/*         if (len >= nice_match) break;				*/
+/*         scan_end = *(ushf*)(scan+best_len-1);			*/
+
+LongerMatch:
+		movl	%eax, %bestlend
+		movl	%curmatchd, dsMatchStart
+		cmpl	%nicematch, %eax
+		jge	LeaveNow
+
+		lea	(%window, %bestlen), %windowbestlen
+		mov	%windowbestlen, _windowbestlen
+
+		movzwl	-1(%scan, %rax), %scanend
+		mov	dsPrev, %prev
+		movl	_chainlenwmask, %chainlenwmask
+		jmp	LookupLoop
+
+/* Accept the current string, with the maximum possible length.		*/
+
+LenMaximum:
+		movl	$MAX_MATCH, %bestlend
+		movl	%curmatchd, dsMatchStart
+
+/* if ((uInt)best_len <= s->lookahead) return (uInt)best_len;		*/
+/* return s->lookahead;							*/
+
+LeaveNow:
+		movl	dsLookahead, %eax
+		cmpl	%eax, %bestlend
+		cmovngl	%bestlend, %eax
+LookaheadRet:
+
+/* Restore the registers and return from whence we came.			*/
+
+	mov	save_rsi, %rsi
+	mov	save_rbx, %rbx
+	mov	save_r12, %r12
+	mov	save_r13, %r13
+	mov	save_r14, %r14
+	mov	save_r15, %r15
+
+	ret
+
+match_init:	ret
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/asm686/README.686 b/Engine/lib/assimp/contrib/zlib/contrib/asm686/README.686
new file mode 100644
index 000000000..a0bf3bea4
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/asm686/README.686
@@ -0,0 +1,51 @@
+This is a patched version of zlib, modified to use
+Pentium-Pro-optimized assembly code in the deflation algorithm. The
+files changed/added by this patch are:
+
+README.686
+match.S
+
+The speedup that this patch provides varies, depending on whether the
+compiler used to build the original version of zlib falls afoul of the
+PPro's speed traps. My own tests show a speedup of around 10-20% at
+the default compression level, and 20-30% using -9, against a version
+compiled using gcc 2.7.2.3. Your mileage may vary.
+
+Note that this code has been tailored for the PPro/PII in particular,
+and will not perform particuarly well on a Pentium.
+
+If you are using an assembler other than GNU as, you will have to
+translate match.S to use your assembler's syntax. (Have fun.)
+
+Brian Raiter
+breadbox@muppetlabs.com
+April, 1998
+
+
+Added for zlib 1.1.3:
+
+The patches come from
+http://www.muppetlabs.com/~breadbox/software/assembly.html
+
+To compile zlib with this asm file, copy match.S to the zlib directory
+then do:
+
+CFLAGS="-O3 -DASMV" ./configure
+make OBJA=match.o
+
+
+Update:
+
+I've been ignoring these assembly routines for years, believing that
+gcc's generated code had caught up with it sometime around gcc 2.95
+and the major rearchitecting of the Pentium 4. However, I recently
+learned that, despite what I believed, this code still has some life
+in it. On the Pentium 4 and AMD64 chips, it continues to run about 8%
+faster than the code produced by gcc 4.1.
+
+In acknowledgement of its continuing usefulness, I've altered the
+license to match that of the rest of zlib. Share and Enjoy!
+
+Brian Raiter
+breadbox@muppetlabs.com
+April, 2007
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/asm686/match.S b/Engine/lib/assimp/contrib/zlib/contrib/asm686/match.S
new file mode 100644
index 000000000..fa4210927
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/asm686/match.S
@@ -0,0 +1,357 @@
+/* match.S -- x86 assembly version of the zlib longest_match() function.
+ * Optimized for the Intel 686 chips (PPro and later).
+ *
+ * Copyright (C) 1998, 2007 Brian Raiter <breadbox@muppetlabs.com>
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the author be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef NO_UNDERLINE
+#define	match_init	_match_init
+#define	longest_match	_longest_match
+#endif
+
+#define	MAX_MATCH	(258)
+#define	MIN_MATCH	(3)
+#define	MIN_LOOKAHEAD	(MAX_MATCH + MIN_MATCH + 1)
+#define	MAX_MATCH_8	((MAX_MATCH + 7) & ~7)
+
+/* stack frame offsets */
+
+#define	chainlenwmask		0	/* high word: current chain len	*/
+					/* low word: s->wmask		*/
+#define	window			4	/* local copy of s->window	*/
+#define	windowbestlen		8	/* s->window + bestlen		*/
+#define	scanstart		16	/* first two bytes of string	*/
+#define	scanend			12	/* last two bytes of string	*/
+#define	scanalign		20	/* dword-misalignment of string	*/
+#define	nicematch		24	/* a good enough match size	*/
+#define	bestlen			28	/* size of best match so far	*/
+#define	scan			32	/* ptr to string wanting match	*/
+
+#define	LocalVarsSize		(36)
+/*	saved ebx		36 */
+/*	saved edi		40 */
+/*	saved esi		44 */
+/*	saved ebp		48 */
+/*	return address		52 */
+#define	deflatestate		56	/* the function arguments	*/
+#define	curmatch		60
+
+/* All the +zlib1222add offsets are due to the addition of fields
+ *  in zlib in the deflate_state structure since the asm code was first written
+ * (if you compile with zlib 1.0.4 or older, use "zlib1222add equ (-4)").
+ * (if you compile with zlib between 1.0.5 and 1.2.2.1, use "zlib1222add equ 0").
+ * if you compile with zlib 1.2.2.2 or later , use "zlib1222add equ 8").
+ */
+
+#define zlib1222add		(8)
+
+#define	dsWSize			(36+zlib1222add)
+#define	dsWMask			(44+zlib1222add)
+#define	dsWindow		(48+zlib1222add)
+#define	dsPrev			(56+zlib1222add)
+#define	dsMatchLen		(88+zlib1222add)
+#define	dsPrevMatch		(92+zlib1222add)
+#define	dsStrStart		(100+zlib1222add)
+#define	dsMatchStart		(104+zlib1222add)
+#define	dsLookahead		(108+zlib1222add)
+#define	dsPrevLen		(112+zlib1222add)
+#define	dsMaxChainLen		(116+zlib1222add)
+#define	dsGoodMatch		(132+zlib1222add)
+#define	dsNiceMatch		(136+zlib1222add)
+
+
+.file "match.S"
+
+.globl	match_init, longest_match
+
+.text
+
+/* uInt longest_match(deflate_state *deflatestate, IPos curmatch) */
+.cfi_sections	.debug_frame
+
+longest_match:
+
+.cfi_startproc
+/* Save registers that the compiler may be using, and adjust %esp to	*/
+/* make room for our stack frame.					*/
+
+		pushl	%ebp
+		.cfi_def_cfa_offset 8
+		.cfi_offset ebp, -8
+		pushl	%edi
+		.cfi_def_cfa_offset 12
+		pushl	%esi
+		.cfi_def_cfa_offset 16
+		pushl	%ebx
+		.cfi_def_cfa_offset 20
+		subl	$LocalVarsSize, %esp
+		.cfi_def_cfa_offset LocalVarsSize+20
+
+/* Retrieve the function arguments. %ecx will hold cur_match		*/
+/* throughout the entire function. %edx will hold the pointer to the	*/
+/* deflate_state structure during the function's setup (before		*/
+/* entering the main loop).						*/
+
+		movl	deflatestate(%esp), %edx
+		movl	curmatch(%esp), %ecx
+
+/* uInt wmask = s->w_mask;						*/
+/* unsigned chain_length = s->max_chain_length;				*/
+/* if (s->prev_length >= s->good_match) {				*/
+/*     chain_length >>= 2;						*/
+/* }									*/
+ 
+		movl	dsPrevLen(%edx), %eax
+		movl	dsGoodMatch(%edx), %ebx
+		cmpl	%ebx, %eax
+		movl	dsWMask(%edx), %eax
+		movl	dsMaxChainLen(%edx), %ebx
+		jl	LastMatchGood
+		shrl	$2, %ebx
+LastMatchGood:
+
+/* chainlen is decremented once beforehand so that the function can	*/
+/* use the sign flag instead of the zero flag for the exit test.	*/
+/* It is then shifted into the high word, to make room for the wmask	*/
+/* value, which it will always accompany.				*/
+
+		decl	%ebx
+		shll	$16, %ebx
+		orl	%eax, %ebx
+		movl	%ebx, chainlenwmask(%esp)
+
+/* if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;	*/
+
+		movl	dsNiceMatch(%edx), %eax
+		movl	dsLookahead(%edx), %ebx
+		cmpl	%eax, %ebx
+		jl	LookaheadLess
+		movl	%eax, %ebx
+LookaheadLess:	movl	%ebx, nicematch(%esp)
+
+/* register Bytef *scan = s->window + s->strstart;			*/
+
+		movl	dsWindow(%edx), %esi
+		movl	%esi, window(%esp)
+		movl	dsStrStart(%edx), %ebp
+		lea	(%esi,%ebp), %edi
+		movl	%edi, scan(%esp)
+
+/* Determine how many bytes the scan ptr is off from being		*/
+/* dword-aligned.							*/
+
+		movl	%edi, %eax
+		negl	%eax
+		andl	$3, %eax
+		movl	%eax, scanalign(%esp)
+
+/* IPos limit = s->strstart > (IPos)MAX_DIST(s) ?			*/
+/*     s->strstart - (IPos)MAX_DIST(s) : NIL;				*/
+
+		movl	dsWSize(%edx), %eax
+		subl	$MIN_LOOKAHEAD, %eax
+		subl	%eax, %ebp
+		jg	LimitPositive
+		xorl	%ebp, %ebp
+LimitPositive:
+
+/* int best_len = s->prev_length;					*/
+
+		movl	dsPrevLen(%edx), %eax
+		movl	%eax, bestlen(%esp)
+
+/* Store the sum of s->window + best_len in %esi locally, and in %esi.	*/
+
+		addl	%eax, %esi
+		movl	%esi, windowbestlen(%esp)
+
+/* register ush scan_start = *(ushf*)scan;				*/
+/* register ush scan_end   = *(ushf*)(scan+best_len-1);			*/
+/* Posf *prev = s->prev;						*/
+
+		movzwl	(%edi), %ebx
+		movl	%ebx, scanstart(%esp)
+		movzwl	-1(%edi,%eax), %ebx
+		movl	%ebx, scanend(%esp)
+		movl	dsPrev(%edx), %edi
+
+/* Jump into the main loop.						*/
+
+		movl	chainlenwmask(%esp), %edx
+		jmp	LoopEntry
+
+.balign 16
+
+/* do {
+ *     match = s->window + cur_match;
+ *     if (*(ushf*)(match+best_len-1) != scan_end ||
+ *         *(ushf*)match != scan_start) continue;
+ *     [...]
+ * } while ((cur_match = prev[cur_match & wmask]) > limit
+ *          && --chain_length != 0);
+ *
+ * Here is the inner loop of the function. The function will spend the
+ * majority of its time in this loop, and majority of that time will
+ * be spent in the first ten instructions.
+ *
+ * Within this loop:
+ * %ebx = scanend
+ * %ecx = curmatch
+ * %edx = chainlenwmask - i.e., ((chainlen << 16) | wmask)
+ * %esi = windowbestlen - i.e., (window + bestlen)
+ * %edi = prev
+ * %ebp = limit
+ */
+LookupLoop:
+		andl	%edx, %ecx
+		movzwl	(%edi,%ecx,2), %ecx
+		cmpl	%ebp, %ecx
+		jbe	LeaveNow
+		subl	$0x00010000, %edx
+		js	LeaveNow
+LoopEntry:	movzwl	-1(%esi,%ecx), %eax
+		cmpl	%ebx, %eax
+		jnz	LookupLoop
+		movl	window(%esp), %eax
+		movzwl	(%eax,%ecx), %eax
+		cmpl	scanstart(%esp), %eax
+		jnz	LookupLoop
+
+/* Store the current value of chainlen.					*/
+
+		movl	%edx, chainlenwmask(%esp)
+
+/* Point %edi to the string under scrutiny, and %esi to the string we	*/
+/* are hoping to match it up with. In actuality, %esi and %edi are	*/
+/* both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and %edx is	*/
+/* initialized to -(MAX_MATCH_8 - scanalign).				*/
+
+		movl	window(%esp), %esi
+		movl	scan(%esp), %edi
+		addl	%ecx, %esi
+		movl	scanalign(%esp), %eax
+		movl	$(-MAX_MATCH_8), %edx
+		lea	MAX_MATCH_8(%edi,%eax), %edi
+		lea	MAX_MATCH_8(%esi,%eax), %esi
+
+/* Test the strings for equality, 8 bytes at a time. At the end,
+ * adjust %edx so that it is offset to the exact byte that mismatched.
+ *
+ * We already know at this point that the first three bytes of the
+ * strings match each other, and they can be safely passed over before
+ * starting the compare loop. So what this code does is skip over 0-3
+ * bytes, as much as necessary in order to dword-align the %edi
+ * pointer. (%esi will still be misaligned three times out of four.)
+ *
+ * It should be confessed that this loop usually does not represent
+ * much of the total running time. Replacing it with a more
+ * straightforward "rep cmpsb" would not drastically degrade
+ * performance.
+ */
+LoopCmps:
+		movl	(%esi,%edx), %eax
+		xorl	(%edi,%edx), %eax
+		jnz	LeaveLoopCmps
+		movl	4(%esi,%edx), %eax
+		xorl	4(%edi,%edx), %eax
+		jnz	LeaveLoopCmps4
+		addl	$8, %edx
+		jnz	LoopCmps
+		jmp	LenMaximum
+LeaveLoopCmps4:	addl	$4, %edx
+LeaveLoopCmps:	testl	$0x0000FFFF, %eax
+		jnz	LenLower
+		addl	$2, %edx
+		shrl	$16, %eax
+LenLower:	subb	$1, %al
+		adcl	$0, %edx
+
+/* Calculate the length of the match. If it is longer than MAX_MATCH,	*/
+/* then automatically accept it as the best possible match and leave.	*/
+
+		lea	(%edi,%edx), %eax
+		movl	scan(%esp), %edi
+		subl	%edi, %eax
+		cmpl	$MAX_MATCH, %eax
+		jge	LenMaximum
+
+/* If the length of the match is not longer than the best match we	*/
+/* have so far, then forget it and return to the lookup loop.		*/
+
+		movl	deflatestate(%esp), %edx
+		movl	bestlen(%esp), %ebx
+		cmpl	%ebx, %eax
+		jg	LongerMatch
+		movl	windowbestlen(%esp), %esi
+		movl	dsPrev(%edx), %edi
+		movl	scanend(%esp), %ebx
+		movl	chainlenwmask(%esp), %edx
+		jmp	LookupLoop
+
+/*         s->match_start = cur_match;					*/
+/*         best_len = len;						*/
+/*         if (len >= nice_match) break;				*/
+/*         scan_end = *(ushf*)(scan+best_len-1);			*/
+
+LongerMatch:	movl	nicematch(%esp), %ebx
+		movl	%eax, bestlen(%esp)
+		movl	%ecx, dsMatchStart(%edx)
+		cmpl	%ebx, %eax
+		jge	LeaveNow
+		movl	window(%esp), %esi
+		addl	%eax, %esi
+		movl	%esi, windowbestlen(%esp)
+		movzwl	-1(%edi,%eax), %ebx
+		movl	dsPrev(%edx), %edi
+		movl	%ebx, scanend(%esp)
+		movl	chainlenwmask(%esp), %edx
+		jmp	LookupLoop
+
+/* Accept the current string, with the maximum possible length.		*/
+
+LenMaximum:	movl	deflatestate(%esp), %edx
+		movl	$MAX_MATCH, bestlen(%esp)
+		movl	%ecx, dsMatchStart(%edx)
+
+/* if ((uInt)best_len <= s->lookahead) return (uInt)best_len;		*/
+/* return s->lookahead;							*/
+
+LeaveNow:
+		movl	deflatestate(%esp), %edx
+		movl	bestlen(%esp), %ebx
+		movl	dsLookahead(%edx), %eax
+		cmpl	%eax, %ebx
+		jg	LookaheadRet
+		movl	%ebx, %eax
+LookaheadRet:
+
+/* Restore the stack and return from whence we came.			*/
+
+		addl	$LocalVarsSize, %esp
+		.cfi_def_cfa_offset 20
+		popl	%ebx
+		.cfi_def_cfa_offset 16
+		popl	%esi
+		.cfi_def_cfa_offset 12
+		popl	%edi
+		.cfi_def_cfa_offset 8
+		popl	%ebp
+		.cfi_def_cfa_offset 4
+.cfi_endproc
+match_init:	ret
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/blast/README b/Engine/lib/assimp/contrib/zlib/contrib/blast/README
new file mode 100644
index 000000000..e3a60b3f5
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/blast/README
@@ -0,0 +1,4 @@
+Read blast.h for purpose and usage.
+
+Mark Adler
+madler@alumni.caltech.edu
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/blast/blast.c b/Engine/lib/assimp/contrib/zlib/contrib/blast/blast.c
new file mode 100644
index 000000000..e6e659073
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/blast/blast.c
@@ -0,0 +1,466 @@
+/* blast.c
+ * Copyright (C) 2003, 2012, 2013 Mark Adler
+ * For conditions of distribution and use, see copyright notice in blast.h
+ * version 1.3, 24 Aug 2013
+ *
+ * blast.c decompresses data compressed by the PKWare Compression Library.
+ * This function provides functionality similar to the explode() function of
+ * the PKWare library, hence the name "blast".
+ *
+ * This decompressor is based on the excellent format description provided by
+ * Ben Rudiak-Gould in comp.compression on August 13, 2001.  Interestingly, the
+ * example Ben provided in the post is incorrect.  The distance 110001 should
+ * instead be 111000.  When corrected, the example byte stream becomes:
+ *
+ *    00 04 82 24 25 8f 80 7f
+ *
+ * which decompresses to "AIAIAIAIAIAIA" (without the quotes).
+ */
+
+/*
+ * Change history:
+ *
+ * 1.0  12 Feb 2003     - First version
+ * 1.1  16 Feb 2003     - Fixed distance check for > 4 GB uncompressed data
+ * 1.2  24 Oct 2012     - Add note about using binary mode in stdio
+ *                      - Fix comparisons of differently signed integers
+ * 1.3  24 Aug 2013     - Return unused input from blast()
+ *                      - Fix test code to correctly report unused input
+ *                      - Enable the provision of initial input to blast()
+ */
+
+#include <stddef.h>             /* for NULL */
+#include <setjmp.h>             /* for setjmp(), longjmp(), and jmp_buf */
+#include "blast.h"              /* prototype for blast() */
+
+#define local static            /* for local function definitions */
+#define MAXBITS 13              /* maximum code length */
+#define MAXWIN 4096             /* maximum window size */
+
+/* input and output state */
+struct state {
+    /* input state */
+    blast_in infun;             /* input function provided by user */
+    void *inhow;                /* opaque information passed to infun() */
+    unsigned char *in;          /* next input location */
+    unsigned left;              /* available input at in */
+    int bitbuf;                 /* bit buffer */
+    int bitcnt;                 /* number of bits in bit buffer */
+
+    /* input limit error return state for bits() and decode() */
+    jmp_buf env;
+
+    /* output state */
+    blast_out outfun;           /* output function provided by user */
+    void *outhow;               /* opaque information passed to outfun() */
+    unsigned next;              /* index of next write location in out[] */
+    int first;                  /* true to check distances (for first 4K) */
+    unsigned char out[MAXWIN];  /* output buffer and sliding window */
+};
+
+/*
+ * Return need bits from the input stream.  This always leaves less than
+ * eight bits in the buffer.  bits() works properly for need == 0.
+ *
+ * Format notes:
+ *
+ * - Bits are stored in bytes from the least significant bit to the most
+ *   significant bit.  Therefore bits are dropped from the bottom of the bit
+ *   buffer, using shift right, and new bytes are appended to the top of the
+ *   bit buffer, using shift left.
+ */
+local int bits(struct state *s, int need)
+{
+    int val;            /* bit accumulator */
+
+    /* load at least need bits into val */
+    val = s->bitbuf;
+    while (s->bitcnt < need) {
+        if (s->left == 0) {
+            s->left = s->infun(s->inhow, &(s->in));
+            if (s->left == 0) longjmp(s->env, 1);       /* out of input */
+        }
+        val |= (int)(*(s->in)++) << s->bitcnt;          /* load eight bits */
+        s->left--;
+        s->bitcnt += 8;
+    }
+
+    /* drop need bits and update buffer, always zero to seven bits left */
+    s->bitbuf = val >> need;
+    s->bitcnt -= need;
+
+    /* return need bits, zeroing the bits above that */
+    return val & ((1 << need) - 1);
+}
+
+/*
+ * Huffman code decoding tables.  count[1..MAXBITS] is the number of symbols of
+ * each length, which for a canonical code are stepped through in order.
+ * symbol[] are the symbol values in canonical order, where the number of
+ * entries is the sum of the counts in count[].  The decoding process can be
+ * seen in the function decode() below.
+ */
+struct huffman {
+    short *count;       /* number of symbols of each length */
+    short *symbol;      /* canonically ordered symbols */
+};
+
+/*
+ * Decode a code from the stream s using huffman table h.  Return the symbol or
+ * a negative value if there is an error.  If all of the lengths are zero, i.e.
+ * an empty code, or if the code is incomplete and an invalid code is received,
+ * then -9 is returned after reading MAXBITS bits.
+ *
+ * Format notes:
+ *
+ * - The codes as stored in the compressed data are bit-reversed relative to
+ *   a simple integer ordering of codes of the same lengths.  Hence below the
+ *   bits are pulled from the compressed data one at a time and used to
+ *   build the code value reversed from what is in the stream in order to
+ *   permit simple integer comparisons for decoding.
+ *
+ * - The first code for the shortest length is all ones.  Subsequent codes of
+ *   the same length are simply integer decrements of the previous code.  When
+ *   moving up a length, a one bit is appended to the code.  For a complete
+ *   code, the last code of the longest length will be all zeros.  To support
+ *   this ordering, the bits pulled during decoding are inverted to apply the
+ *   more "natural" ordering starting with all zeros and incrementing.
+ */
+local int decode(struct state *s, struct huffman *h)
+{
+    int len;            /* current number of bits in code */
+    int code;           /* len bits being decoded */
+    int first;          /* first code of length len */
+    int count;          /* number of codes of length len */
+    int index;          /* index of first code of length len in symbol table */
+    int bitbuf;         /* bits from stream */
+    int left;           /* bits left in next or left to process */
+    short *next;        /* next number of codes */
+
+    bitbuf = s->bitbuf;
+    left = s->bitcnt;
+    code = first = index = 0;
+    len = 1;
+    next = h->count + 1;
+    while (1) {
+        while (left--) {
+            code |= (bitbuf & 1) ^ 1;   /* invert code */
+            bitbuf >>= 1;
+            count = *next++;
+            if (code < first + count) { /* if length len, return symbol */
+                s->bitbuf = bitbuf;
+                s->bitcnt = (s->bitcnt - len) & 7;
+                return h->symbol[index + (code - first)];
+            }
+            index += count;             /* else update for next length */
+            first += count;
+            first <<= 1;
+            code <<= 1;
+            len++;
+        }
+        left = (MAXBITS+1) - len;
+        if (left == 0) break;
+        if (s->left == 0) {
+            s->left = s->infun(s->inhow, &(s->in));
+            if (s->left == 0) longjmp(s->env, 1);       /* out of input */
+        }
+        bitbuf = *(s->in)++;
+        s->left--;
+        if (left > 8) left = 8;
+    }
+    return -9;                          /* ran out of codes */
+}
+
+/*
+ * Given a list of repeated code lengths rep[0..n-1], where each byte is a
+ * count (high four bits + 1) and a code length (low four bits), generate the
+ * list of code lengths.  This compaction reduces the size of the object code.
+ * Then given the list of code lengths length[0..n-1] representing a canonical
+ * Huffman code for n symbols, construct the tables required to decode those
+ * codes.  Those tables are the number of codes of each length, and the symbols
+ * sorted by length, retaining their original order within each length.  The
+ * return value is zero for a complete code set, negative for an over-
+ * subscribed code set, and positive for an incomplete code set.  The tables
+ * can be used if the return value is zero or positive, but they cannot be used
+ * if the return value is negative.  If the return value is zero, it is not
+ * possible for decode() using that table to return an error--any stream of
+ * enough bits will resolve to a symbol.  If the return value is positive, then
+ * it is possible for decode() using that table to return an error for received
+ * codes past the end of the incomplete lengths.
+ */
+local int construct(struct huffman *h, const unsigned char *rep, int n)
+{
+    int symbol;         /* current symbol when stepping through length[] */
+    int len;            /* current length when stepping through h->count[] */
+    int left;           /* number of possible codes left of current length */
+    short offs[MAXBITS+1];      /* offsets in symbol table for each length */
+    short length[256];  /* code lengths */
+
+    /* convert compact repeat counts into symbol bit length list */
+    symbol = 0;
+    do {
+        len = *rep++;
+        left = (len >> 4) + 1;
+        len &= 15;
+        do {
+            length[symbol++] = len;
+        } while (--left);
+    } while (--n);
+    n = symbol;
+
+    /* count number of codes of each length */
+    for (len = 0; len <= MAXBITS; len++)
+        h->count[len] = 0;
+    for (symbol = 0; symbol < n; symbol++)
+        (h->count[length[symbol]])++;   /* assumes lengths are within bounds */
+    if (h->count[0] == n)               /* no codes! */
+        return 0;                       /* complete, but decode() will fail */
+
+    /* check for an over-subscribed or incomplete set of lengths */
+    left = 1;                           /* one possible code of zero length */
+    for (len = 1; len <= MAXBITS; len++) {
+        left <<= 1;                     /* one more bit, double codes left */
+        left -= h->count[len];          /* deduct count from possible codes */
+        if (left < 0) return left;      /* over-subscribed--return negative */
+    }                                   /* left > 0 means incomplete */
+
+    /* generate offsets into symbol table for each length for sorting */
+    offs[1] = 0;
+    for (len = 1; len < MAXBITS; len++)
+        offs[len + 1] = offs[len] + h->count[len];
+
+    /*
+     * put symbols in table sorted by length, by symbol order within each
+     * length
+     */
+    for (symbol = 0; symbol < n; symbol++)
+        if (length[symbol] != 0)
+            h->symbol[offs[length[symbol]]++] = symbol;
+
+    /* return zero for complete set, positive for incomplete set */
+    return left;
+}
+
+/*
+ * Decode PKWare Compression Library stream.
+ *
+ * Format notes:
+ *
+ * - First byte is 0 if literals are uncoded or 1 if they are coded.  Second
+ *   byte is 4, 5, or 6 for the number of extra bits in the distance code.
+ *   This is the base-2 logarithm of the dictionary size minus six.
+ *
+ * - Compressed data is a combination of literals and length/distance pairs
+ *   terminated by an end code.  Literals are either Huffman coded or
+ *   uncoded bytes.  A length/distance pair is a coded length followed by a
+ *   coded distance to represent a string that occurs earlier in the
+ *   uncompressed data that occurs again at the current location.
+ *
+ * - A bit preceding a literal or length/distance pair indicates which comes
+ *   next, 0 for literals, 1 for length/distance.
+ *
+ * - If literals are uncoded, then the next eight bits are the literal, in the
+ *   normal bit order in the stream, i.e. no bit-reversal is needed. Similarly,
+ *   no bit reversal is needed for either the length extra bits or the distance
+ *   extra bits.
+ *
+ * - Literal bytes are simply written to the output.  A length/distance pair is
+ *   an instruction to copy previously uncompressed bytes to the output.  The
+ *   copy is from distance bytes back in the output stream, copying for length
+ *   bytes.
+ *
+ * - Distances pointing before the beginning of the output data are not
+ *   permitted.
+ *
+ * - Overlapped copies, where the length is greater than the distance, are
+ *   allowed and common.  For example, a distance of one and a length of 518
+ *   simply copies the last byte 518 times.  A distance of four and a length of
+ *   twelve copies the last four bytes three times.  A simple forward copy
+ *   ignoring whether the length is greater than the distance or not implements
+ *   this correctly.
+ */
+local int decomp(struct state *s)
+{
+    int lit;            /* true if literals are coded */
+    int dict;           /* log2(dictionary size) - 6 */
+    int symbol;         /* decoded symbol, extra bits for distance */
+    int len;            /* length for copy */
+    unsigned dist;      /* distance for copy */
+    int copy;           /* copy counter */
+    unsigned char *from, *to;   /* copy pointers */
+    static int virgin = 1;                              /* build tables once */
+    static short litcnt[MAXBITS+1], litsym[256];        /* litcode memory */
+    static short lencnt[MAXBITS+1], lensym[16];         /* lencode memory */
+    static short distcnt[MAXBITS+1], distsym[64];       /* distcode memory */
+    static struct huffman litcode = {litcnt, litsym};   /* length code */
+    static struct huffman lencode = {lencnt, lensym};   /* length code */
+    static struct huffman distcode = {distcnt, distsym};/* distance code */
+        /* bit lengths of literal codes */
+    static const unsigned char litlen[] = {
+        11, 124, 8, 7, 28, 7, 188, 13, 76, 4, 10, 8, 12, 10, 12, 10, 8, 23, 8,
+        9, 7, 6, 7, 8, 7, 6, 55, 8, 23, 24, 12, 11, 7, 9, 11, 12, 6, 7, 22, 5,
+        7, 24, 6, 11, 9, 6, 7, 22, 7, 11, 38, 7, 9, 8, 25, 11, 8, 11, 9, 12,
+        8, 12, 5, 38, 5, 38, 5, 11, 7, 5, 6, 21, 6, 10, 53, 8, 7, 24, 10, 27,
+        44, 253, 253, 253, 252, 252, 252, 13, 12, 45, 12, 45, 12, 61, 12, 45,
+        44, 173};
+        /* bit lengths of length codes 0..15 */
+    static const unsigned char lenlen[] = {2, 35, 36, 53, 38, 23};
+        /* bit lengths of distance codes 0..63 */
+    static const unsigned char distlen[] = {2, 20, 53, 230, 247, 151, 248};
+    static const short base[16] = {     /* base for length codes */
+        3, 2, 4, 5, 6, 7, 8, 9, 10, 12, 16, 24, 40, 72, 136, 264};
+    static const char extra[16] = {     /* extra bits for length codes */
+        0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8};
+
+    /* set up decoding tables (once--might not be thread-safe) */
+    if (virgin) {
+        construct(&litcode, litlen, sizeof(litlen));
+        construct(&lencode, lenlen, sizeof(lenlen));
+        construct(&distcode, distlen, sizeof(distlen));
+        virgin = 0;
+    }
+
+    /* read header */
+    lit = bits(s, 8);
+    if (lit > 1) return -1;
+    dict = bits(s, 8);
+    if (dict < 4 || dict > 6) return -2;
+
+    /* decode literals and length/distance pairs */
+    do {
+        if (bits(s, 1)) {
+            /* get length */
+            symbol = decode(s, &lencode);
+            len = base[symbol] + bits(s, extra[symbol]);
+            if (len == 519) break;              /* end code */
+
+            /* get distance */
+            symbol = len == 2 ? 2 : dict;
+            dist = decode(s, &distcode) << symbol;
+            dist += bits(s, symbol);
+            dist++;
+            if (s->first && dist > s->next)
+                return -3;              /* distance too far back */
+
+            /* copy length bytes from distance bytes back */
+            do {
+                to = s->out + s->next;
+                from = to - dist;
+                copy = MAXWIN;
+                if (s->next < dist) {
+                    from += copy;
+                    copy = dist;
+                }
+                copy -= s->next;
+                if (copy > len) copy = len;
+                len -= copy;
+                s->next += copy;
+                do {
+                    *to++ = *from++;
+                } while (--copy);
+                if (s->next == MAXWIN) {
+                    if (s->outfun(s->outhow, s->out, s->next)) return 1;
+                    s->next = 0;
+                    s->first = 0;
+                }
+            } while (len != 0);
+        }
+        else {
+            /* get literal and write it */
+            symbol = lit ? decode(s, &litcode) : bits(s, 8);
+            s->out[s->next++] = symbol;
+            if (s->next == MAXWIN) {
+                if (s->outfun(s->outhow, s->out, s->next)) return 1;
+                s->next = 0;
+                s->first = 0;
+            }
+        }
+    } while (1);
+    return 0;
+}
+
+/* See comments in blast.h */
+int blast(blast_in infun, void *inhow, blast_out outfun, void *outhow,
+          unsigned *left, unsigned char **in)
+{
+    struct state s;             /* input/output state */
+    int err;                    /* return value */
+
+    /* initialize input state */
+    s.infun = infun;
+    s.inhow = inhow;
+    if (left != NULL && *left) {
+        s.left = *left;
+        s.in = *in;
+    }
+    else
+        s.left = 0;
+    s.bitbuf = 0;
+    s.bitcnt = 0;
+
+    /* initialize output state */
+    s.outfun = outfun;
+    s.outhow = outhow;
+    s.next = 0;
+    s.first = 1;
+
+    /* return if bits() or decode() tries to read past available input */
+    if (setjmp(s.env) != 0)             /* if came back here via longjmp(), */
+        err = 2;                        /*  then skip decomp(), return error */
+    else
+        err = decomp(&s);               /* decompress */
+
+    /* return unused input */
+    if (left != NULL)
+        *left = s.left;
+    if (in != NULL)
+        *in = s.left ? s.in : NULL;
+
+    /* write any leftover output and update the error code if needed */
+    if (err != 1 && s.next && s.outfun(s.outhow, s.out, s.next) && err == 0)
+        err = 1;
+    return err;
+}
+
+#ifdef TEST
+/* Example of how to use blast() */
+#include <stdio.h>
+#include <stdlib.h>
+
+#define CHUNK 16384
+
+local unsigned inf(void *how, unsigned char **buf)
+{
+    static unsigned char hold[CHUNK];
+
+    *buf = hold;
+    return fread(hold, 1, CHUNK, (FILE *)how);
+}
+
+local int outf(void *how, unsigned char *buf, unsigned len)
+{
+    return fwrite(buf, 1, len, (FILE *)how) != len;
+}
+
+/* Decompress a PKWare Compression Library stream from stdin to stdout */
+int main(void)
+{
+    int ret;
+    unsigned left;
+
+    /* decompress to stdout */
+    left = 0;
+    ret = blast(inf, stdin, outf, stdout, &left, NULL);
+    if (ret != 0)
+        fprintf(stderr, "blast error: %d\n", ret);
+
+    /* count any leftover bytes */
+    while (getchar() != EOF)
+        left++;
+    if (left)
+        fprintf(stderr, "blast warning: %u unused bytes of input\n", left);
+
+    /* return blast() error code */
+    return ret;
+}
+#endif
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/blast/blast.h b/Engine/lib/assimp/contrib/zlib/contrib/blast/blast.h
new file mode 100644
index 000000000..6cf65eda1
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/blast/blast.h
@@ -0,0 +1,83 @@
+/* blast.h -- interface for blast.c
+  Copyright (C) 2003, 2012, 2013 Mark Adler
+  version 1.3, 24 Aug 2013
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the author be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Mark Adler    madler@alumni.caltech.edu
+ */
+
+
+/*
+ * blast() decompresses the PKWare Data Compression Library (DCL) compressed
+ * format.  It provides the same functionality as the explode() function in
+ * that library.  (Note: PKWare overused the "implode" verb, and the format
+ * used by their library implode() function is completely different and
+ * incompatible with the implode compression method supported by PKZIP.)
+ *
+ * The binary mode for stdio functions should be used to assure that the
+ * compressed data is not corrupted when read or written.  For example:
+ * fopen(..., "rb") and fopen(..., "wb").
+ */
+
+
+typedef unsigned (*blast_in)(void *how, unsigned char **buf);
+typedef int (*blast_out)(void *how, unsigned char *buf, unsigned len);
+/* Definitions for input/output functions passed to blast().  See below for
+ * what the provided functions need to do.
+ */
+
+
+int blast(blast_in infun, void *inhow, blast_out outfun, void *outhow,
+          unsigned *left, unsigned char **in);
+/* Decompress input to output using the provided infun() and outfun() calls.
+ * On success, the return value of blast() is zero.  If there is an error in
+ * the source data, i.e. it is not in the proper format, then a negative value
+ * is returned.  If there is not enough input available or there is not enough
+ * output space, then a positive error is returned.
+ *
+ * The input function is invoked: len = infun(how, &buf), where buf is set by
+ * infun() to point to the input buffer, and infun() returns the number of
+ * available bytes there.  If infun() returns zero, then blast() returns with
+ * an input error.  (blast() only asks for input if it needs it.)  inhow is for
+ * use by the application to pass an input descriptor to infun(), if desired.
+ *
+ * If left and in are not NULL and *left is not zero when blast() is called,
+ * then the *left bytes are *in are consumed for input before infun() is used.
+ *
+ * The output function is invoked: err = outfun(how, buf, len), where the bytes
+ * to be written are buf[0..len-1].  If err is not zero, then blast() returns
+ * with an output error.  outfun() is always called with len <= 4096.  outhow
+ * is for use by the application to pass an output descriptor to outfun(), if
+ * desired.
+ *
+ * If there is any unused input, *left is set to the number of bytes that were
+ * read and *in points to them.  Otherwise *left is set to zero and *in is set
+ * to NULL.  If left or in are NULL, then they are not set.
+ *
+ * The return codes are:
+ *
+ *   2:  ran out of input before completing decompression
+ *   1:  output error before completing decompression
+ *   0:  successful decompression
+ *  -1:  literal flag not zero or one
+ *  -2:  dictionary size not in 4..6
+ *  -3:  distance is too far back
+ *
+ * At the bottom of blast.c is an example program that uses blast() that can be
+ * compiled to produce a command-line decompression filter by defining TEST.
+ */
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/blast/test.pk b/Engine/lib/assimp/contrib/zlib/contrib/blast/test.pk
new file mode 100644
index 0000000000000000000000000000000000000000..be10b2bbb251759ffdf6da49fadd1a3f137a54c1
GIT binary patch
literal 8
PcmZQzX;M+`Z>R?V2c!aC

literal 0
HcmV?d00001

diff --git a/Engine/lib/assimp/contrib/zlib/contrib/blast/test.txt b/Engine/lib/assimp/contrib/zlib/contrib/blast/test.txt
new file mode 100644
index 000000000..bfdf1c5dc
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/blast/test.txt
@@ -0,0 +1 @@
+AIAIAIAIAIAIA
\ No newline at end of file
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/delphi/ZLib.pas b/Engine/lib/assimp/contrib/zlib/contrib/delphi/ZLib.pas
new file mode 100644
index 000000000..060e19911
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/delphi/ZLib.pas
@@ -0,0 +1,557 @@
+{*******************************************************}
+{                                                       }
+{       Borland Delphi Supplemental Components          }
+{       ZLIB Data Compression Interface Unit            }
+{                                                       }
+{       Copyright (c) 1997,99 Borland Corporation       }
+{                                                       }
+{*******************************************************}
+
+{ Updated for zlib 1.2.x by Cosmin Truta <cosmint@cs.ubbcluj.ro> }
+
+unit ZLib;
+
+interface
+
+uses SysUtils, Classes;
+
+type
+  TAlloc = function (AppData: Pointer; Items, Size: Integer): Pointer; cdecl;
+  TFree = procedure (AppData, Block: Pointer); cdecl;
+
+  // Internal structure.  Ignore.
+  TZStreamRec = packed record
+    next_in: PChar;       // next input byte
+    avail_in: Integer;    // number of bytes available at next_in
+    total_in: Longint;    // total nb of input bytes read so far
+
+    next_out: PChar;      // next output byte should be put here
+    avail_out: Integer;   // remaining free space at next_out
+    total_out: Longint;   // total nb of bytes output so far
+
+    msg: PChar;           // last error message, NULL if no error
+    internal: Pointer;    // not visible by applications
+
+    zalloc: TAlloc;       // used to allocate the internal state
+    zfree: TFree;         // used to free the internal state
+    AppData: Pointer;     // private data object passed to zalloc and zfree
+
+    data_type: Integer;   // best guess about the data type: ascii or binary
+    adler: Longint;       // adler32 value of the uncompressed data
+    reserved: Longint;    // reserved for future use
+  end;
+
+  // Abstract ancestor class
+  TCustomZlibStream = class(TStream)
+  private
+    FStrm: TStream;
+    FStrmPos: Integer;
+    FOnProgress: TNotifyEvent;
+    FZRec: TZStreamRec;
+    FBuffer: array [Word] of Char;
+  protected
+    procedure Progress(Sender: TObject); dynamic;
+    property OnProgress: TNotifyEvent read FOnProgress write FOnProgress;
+    constructor Create(Strm: TStream);
+  end;
+
+{ TCompressionStream compresses data on the fly as data is written to it, and
+  stores the compressed data to another stream.
+
+  TCompressionStream is write-only and strictly sequential. Reading from the
+  stream will raise an exception. Using Seek to move the stream pointer
+  will raise an exception.
+
+  Output data is cached internally, written to the output stream only when
+  the internal output buffer is full.  All pending output data is flushed
+  when the stream is destroyed.
+
+  The Position property returns the number of uncompressed bytes of
+  data that have been written to the stream so far.
+
+  CompressionRate returns the on-the-fly percentage by which the original
+  data has been compressed:  (1 - (CompressedBytes / UncompressedBytes)) * 100
+  If raw data size = 100 and compressed data size = 25, the CompressionRate
+  is 75%
+
+  The OnProgress event is called each time the output buffer is filled and
+  written to the output stream.  This is useful for updating a progress
+  indicator when you are writing a large chunk of data to the compression
+  stream in a single call.}
+
+
+  TCompressionLevel = (clNone, clFastest, clDefault, clMax);
+
+  TCompressionStream = class(TCustomZlibStream)
+  private
+    function GetCompressionRate: Single;
+  public
+    constructor Create(CompressionLevel: TCompressionLevel; Dest: TStream);
+    destructor Destroy; override;
+    function Read(var Buffer; Count: Longint): Longint; override;
+    function Write(const Buffer; Count: Longint): Longint; override;
+    function Seek(Offset: Longint; Origin: Word): Longint; override;
+    property CompressionRate: Single read GetCompressionRate;
+    property OnProgress;
+  end;
+
+{ TDecompressionStream decompresses data on the fly as data is read from it.
+
+  Compressed data comes from a separate source stream.  TDecompressionStream
+  is read-only and unidirectional; you can seek forward in the stream, but not
+  backwards.  The special case of setting the stream position to zero is
+  allowed.  Seeking forward decompresses data until the requested position in
+  the uncompressed data has been reached.  Seeking backwards, seeking relative
+  to the end of the stream, requesting the size of the stream, and writing to
+  the stream will raise an exception.
+
+  The Position property returns the number of bytes of uncompressed data that
+  have been read from the stream so far.
+
+  The OnProgress event is called each time the internal input buffer of
+  compressed data is exhausted and the next block is read from the input stream.
+  This is useful for updating a progress indicator when you are reading a
+  large chunk of data from the decompression stream in a single call.}
+
+  TDecompressionStream = class(TCustomZlibStream)
+  public
+    constructor Create(Source: TStream);
+    destructor Destroy; override;
+    function Read(var Buffer; Count: Longint): Longint; override;
+    function Write(const Buffer; Count: Longint): Longint; override;
+    function Seek(Offset: Longint; Origin: Word): Longint; override;
+    property OnProgress;
+  end;
+
+
+
+{ CompressBuf compresses data, buffer to buffer, in one call.
+   In: InBuf = ptr to compressed data
+       InBytes = number of bytes in InBuf
+  Out: OutBuf = ptr to newly allocated buffer containing decompressed data
+       OutBytes = number of bytes in OutBuf   }
+procedure CompressBuf(const InBuf: Pointer; InBytes: Integer;
+                      out OutBuf: Pointer; out OutBytes: Integer);
+
+
+{ DecompressBuf decompresses data, buffer to buffer, in one call.
+   In: InBuf = ptr to compressed data
+       InBytes = number of bytes in InBuf
+       OutEstimate = zero, or est. size of the decompressed data
+  Out: OutBuf = ptr to newly allocated buffer containing decompressed data
+       OutBytes = number of bytes in OutBuf   }
+procedure DecompressBuf(const InBuf: Pointer; InBytes: Integer;
+ OutEstimate: Integer; out OutBuf: Pointer; out OutBytes: Integer);
+
+{ DecompressToUserBuf decompresses data, buffer to buffer, in one call.
+   In: InBuf = ptr to compressed data
+       InBytes = number of bytes in InBuf
+  Out: OutBuf = ptr to user-allocated buffer to contain decompressed data
+       BufSize = number of bytes in OutBuf   }
+procedure DecompressToUserBuf(const InBuf: Pointer; InBytes: Integer;
+  const OutBuf: Pointer; BufSize: Integer);
+
+const
+  zlib_version = '1.2.11';
+
+type
+  EZlibError = class(Exception);
+  ECompressionError = class(EZlibError);
+  EDecompressionError = class(EZlibError);
+
+implementation
+
+uses ZLibConst;
+
+const
+  Z_NO_FLUSH      = 0;
+  Z_PARTIAL_FLUSH = 1;
+  Z_SYNC_FLUSH    = 2;
+  Z_FULL_FLUSH    = 3;
+  Z_FINISH        = 4;
+
+  Z_OK            = 0;
+  Z_STREAM_END    = 1;
+  Z_NEED_DICT     = 2;
+  Z_ERRNO         = (-1);
+  Z_STREAM_ERROR  = (-2);
+  Z_DATA_ERROR    = (-3);
+  Z_MEM_ERROR     = (-4);
+  Z_BUF_ERROR     = (-5);
+  Z_VERSION_ERROR = (-6);
+
+  Z_NO_COMPRESSION       =   0;
+  Z_BEST_SPEED           =   1;
+  Z_BEST_COMPRESSION     =   9;
+  Z_DEFAULT_COMPRESSION  = (-1);
+
+  Z_FILTERED            = 1;
+  Z_HUFFMAN_ONLY        = 2;
+  Z_RLE                 = 3;
+  Z_DEFAULT_STRATEGY    = 0;
+
+  Z_BINARY   = 0;
+  Z_ASCII    = 1;
+  Z_UNKNOWN  = 2;
+
+  Z_DEFLATED = 8;
+
+
+{$L adler32.obj}
+{$L compress.obj}
+{$L crc32.obj}
+{$L deflate.obj}
+{$L infback.obj}
+{$L inffast.obj}
+{$L inflate.obj}
+{$L inftrees.obj}
+{$L trees.obj}
+{$L uncompr.obj}
+{$L zutil.obj}
+
+procedure adler32; external;
+procedure compressBound; external;
+procedure crc32; external;
+procedure deflateInit2_; external;
+procedure deflateParams; external;
+
+function _malloc(Size: Integer): Pointer; cdecl;
+begin
+  Result := AllocMem(Size);
+end;
+
+procedure _free(Block: Pointer); cdecl;
+begin
+  FreeMem(Block);
+end;
+
+procedure _memset(P: Pointer; B: Byte; count: Integer); cdecl;
+begin
+  FillChar(P^, count, B);
+end;
+
+procedure _memcpy(dest, source: Pointer; count: Integer); cdecl;
+begin
+  Move(source^, dest^, count);
+end;
+
+
+
+// deflate compresses data
+function deflateInit_(var strm: TZStreamRec; level: Integer; version: PChar;
+  recsize: Integer): Integer; external;
+function deflate(var strm: TZStreamRec; flush: Integer): Integer; external;
+function deflateEnd(var strm: TZStreamRec): Integer; external;
+
+// inflate decompresses data
+function inflateInit_(var strm: TZStreamRec; version: PChar;
+  recsize: Integer): Integer; external;
+function inflate(var strm: TZStreamRec; flush: Integer): Integer; external;
+function inflateEnd(var strm: TZStreamRec): Integer; external;
+function inflateReset(var strm: TZStreamRec): Integer; external;
+
+
+function zlibAllocMem(AppData: Pointer; Items, Size: Integer): Pointer; cdecl;
+begin
+//  GetMem(Result, Items*Size);
+  Result := AllocMem(Items * Size);
+end;
+
+procedure zlibFreeMem(AppData, Block: Pointer); cdecl;
+begin
+  FreeMem(Block);
+end;
+
+{function zlibCheck(code: Integer): Integer;
+begin
+  Result := code;
+  if code < 0 then
+    raise EZlibError.Create('error');    //!!
+end;}
+
+function CCheck(code: Integer): Integer;
+begin
+  Result := code;
+  if code < 0 then
+    raise ECompressionError.Create('error'); //!!
+end;
+
+function DCheck(code: Integer): Integer;
+begin
+  Result := code;
+  if code < 0 then
+    raise EDecompressionError.Create('error');  //!!
+end;
+
+procedure CompressBuf(const InBuf: Pointer; InBytes: Integer;
+                      out OutBuf: Pointer; out OutBytes: Integer);
+var
+  strm: TZStreamRec;
+  P: Pointer;
+begin
+  FillChar(strm, sizeof(strm), 0);
+  strm.zalloc := zlibAllocMem;
+  strm.zfree := zlibFreeMem;
+  OutBytes := ((InBytes + (InBytes div 10) + 12) + 255) and not 255;
+  GetMem(OutBuf, OutBytes);
+  try
+    strm.next_in := InBuf;
+    strm.avail_in := InBytes;
+    strm.next_out := OutBuf;
+    strm.avail_out := OutBytes;
+    CCheck(deflateInit_(strm, Z_BEST_COMPRESSION, zlib_version, sizeof(strm)));
+    try
+      while CCheck(deflate(strm, Z_FINISH)) <> Z_STREAM_END do
+      begin
+        P := OutBuf;
+        Inc(OutBytes, 256);
+        ReallocMem(OutBuf, OutBytes);
+        strm.next_out := PChar(Integer(OutBuf) + (Integer(strm.next_out) - Integer(P)));
+        strm.avail_out := 256;
+      end;
+    finally
+      CCheck(deflateEnd(strm));
+    end;
+    ReallocMem(OutBuf, strm.total_out);
+    OutBytes := strm.total_out;
+  except
+    FreeMem(OutBuf);
+    raise
+  end;
+end;
+
+
+procedure DecompressBuf(const InBuf: Pointer; InBytes: Integer;
+  OutEstimate: Integer; out OutBuf: Pointer; out OutBytes: Integer);
+var
+  strm: TZStreamRec;
+  P: Pointer;
+  BufInc: Integer;
+begin
+  FillChar(strm, sizeof(strm), 0);
+  strm.zalloc := zlibAllocMem;
+  strm.zfree := zlibFreeMem;
+  BufInc := (InBytes + 255) and not 255;
+  if OutEstimate = 0 then
+    OutBytes := BufInc
+  else
+    OutBytes := OutEstimate;
+  GetMem(OutBuf, OutBytes);
+  try
+    strm.next_in := InBuf;
+    strm.avail_in := InBytes;
+    strm.next_out := OutBuf;
+    strm.avail_out := OutBytes;
+    DCheck(inflateInit_(strm, zlib_version, sizeof(strm)));
+    try
+      while DCheck(inflate(strm, Z_NO_FLUSH)) <> Z_STREAM_END do
+      begin
+        P := OutBuf;
+        Inc(OutBytes, BufInc);
+        ReallocMem(OutBuf, OutBytes);
+        strm.next_out := PChar(Integer(OutBuf) + (Integer(strm.next_out) - Integer(P)));
+        strm.avail_out := BufInc;
+      end;
+    finally
+      DCheck(inflateEnd(strm));
+    end;
+    ReallocMem(OutBuf, strm.total_out);
+    OutBytes := strm.total_out;
+  except
+    FreeMem(OutBuf);
+    raise
+  end;
+end;
+
+procedure DecompressToUserBuf(const InBuf: Pointer; InBytes: Integer;
+  const OutBuf: Pointer; BufSize: Integer);
+var
+  strm: TZStreamRec;
+begin
+  FillChar(strm, sizeof(strm), 0);
+  strm.zalloc := zlibAllocMem;
+  strm.zfree := zlibFreeMem;
+  strm.next_in := InBuf;
+  strm.avail_in := InBytes;
+  strm.next_out := OutBuf;
+  strm.avail_out := BufSize;
+  DCheck(inflateInit_(strm, zlib_version, sizeof(strm)));
+  try
+    if DCheck(inflate(strm, Z_FINISH)) <> Z_STREAM_END then
+      raise EZlibError.CreateRes(@sTargetBufferTooSmall);
+  finally
+    DCheck(inflateEnd(strm));
+  end;
+end;
+
+// TCustomZlibStream
+
+constructor TCustomZLibStream.Create(Strm: TStream);
+begin
+  inherited Create;
+  FStrm := Strm;
+  FStrmPos := Strm.Position;
+  FZRec.zalloc := zlibAllocMem;
+  FZRec.zfree := zlibFreeMem;
+end;
+
+procedure TCustomZLibStream.Progress(Sender: TObject);
+begin
+  if Assigned(FOnProgress) then FOnProgress(Sender);
+end;
+
+
+// TCompressionStream
+
+constructor TCompressionStream.Create(CompressionLevel: TCompressionLevel;
+  Dest: TStream);
+const
+  Levels: array [TCompressionLevel] of ShortInt =
+    (Z_NO_COMPRESSION, Z_BEST_SPEED, Z_DEFAULT_COMPRESSION, Z_BEST_COMPRESSION);
+begin
+  inherited Create(Dest);
+  FZRec.next_out := FBuffer;
+  FZRec.avail_out := sizeof(FBuffer);
+  CCheck(deflateInit_(FZRec, Levels[CompressionLevel], zlib_version, sizeof(FZRec)));
+end;
+
+destructor TCompressionStream.Destroy;
+begin
+  FZRec.next_in := nil;
+  FZRec.avail_in := 0;
+  try
+    if FStrm.Position <> FStrmPos then FStrm.Position := FStrmPos;
+    while (CCheck(deflate(FZRec, Z_FINISH)) <> Z_STREAM_END)
+      and (FZRec.avail_out = 0) do
+    begin
+      FStrm.WriteBuffer(FBuffer, sizeof(FBuffer));
+      FZRec.next_out := FBuffer;
+      FZRec.avail_out := sizeof(FBuffer);
+    end;
+    if FZRec.avail_out < sizeof(FBuffer) then
+      FStrm.WriteBuffer(FBuffer, sizeof(FBuffer) - FZRec.avail_out);
+  finally
+    deflateEnd(FZRec);
+  end;
+  inherited Destroy;
+end;
+
+function TCompressionStream.Read(var Buffer; Count: Longint): Longint;
+begin
+  raise ECompressionError.CreateRes(@sInvalidStreamOp);
+end;
+
+function TCompressionStream.Write(const Buffer; Count: Longint): Longint;
+begin
+  FZRec.next_in := @Buffer;
+  FZRec.avail_in := Count;
+  if FStrm.Position <> FStrmPos then FStrm.Position := FStrmPos;
+  while (FZRec.avail_in > 0) do
+  begin
+    CCheck(deflate(FZRec, 0));
+    if FZRec.avail_out = 0 then
+    begin
+      FStrm.WriteBuffer(FBuffer, sizeof(FBuffer));
+      FZRec.next_out := FBuffer;
+      FZRec.avail_out := sizeof(FBuffer);
+      FStrmPos := FStrm.Position;
+      Progress(Self);
+    end;
+  end;
+  Result := Count;
+end;
+
+function TCompressionStream.Seek(Offset: Longint; Origin: Word): Longint;
+begin
+  if (Offset = 0) and (Origin = soFromCurrent) then
+    Result := FZRec.total_in
+  else
+    raise ECompressionError.CreateRes(@sInvalidStreamOp);
+end;
+
+function TCompressionStream.GetCompressionRate: Single;
+begin
+  if FZRec.total_in = 0 then
+    Result := 0
+  else
+    Result := (1.0 - (FZRec.total_out / FZRec.total_in)) * 100.0;
+end;
+
+
+// TDecompressionStream
+
+constructor TDecompressionStream.Create(Source: TStream);
+begin
+  inherited Create(Source);
+  FZRec.next_in := FBuffer;
+  FZRec.avail_in := 0;
+  DCheck(inflateInit_(FZRec, zlib_version, sizeof(FZRec)));
+end;
+
+destructor TDecompressionStream.Destroy;
+begin
+  FStrm.Seek(-FZRec.avail_in, 1);
+  inflateEnd(FZRec);
+  inherited Destroy;
+end;
+
+function TDecompressionStream.Read(var Buffer; Count: Longint): Longint;
+begin
+  FZRec.next_out := @Buffer;
+  FZRec.avail_out := Count;
+  if FStrm.Position <> FStrmPos then FStrm.Position := FStrmPos;
+  while (FZRec.avail_out > 0) do
+  begin
+    if FZRec.avail_in = 0 then
+    begin
+      FZRec.avail_in := FStrm.Read(FBuffer, sizeof(FBuffer));
+      if FZRec.avail_in = 0 then
+      begin
+        Result := Count - FZRec.avail_out;
+        Exit;
+      end;
+      FZRec.next_in := FBuffer;
+      FStrmPos := FStrm.Position;
+      Progress(Self);
+    end;
+    CCheck(inflate(FZRec, 0));
+  end;
+  Result := Count;
+end;
+
+function TDecompressionStream.Write(const Buffer; Count: Longint): Longint;
+begin
+  raise EDecompressionError.CreateRes(@sInvalidStreamOp);
+end;
+
+function TDecompressionStream.Seek(Offset: Longint; Origin: Word): Longint;
+var
+  I: Integer;
+  Buf: array [0..4095] of Char;
+begin
+  if (Offset = 0) and (Origin = soFromBeginning) then
+  begin
+    DCheck(inflateReset(FZRec));
+    FZRec.next_in := FBuffer;
+    FZRec.avail_in := 0;
+    FStrm.Position := 0;
+    FStrmPos := 0;
+  end
+  else if ( (Offset >= 0) and (Origin = soFromCurrent)) or
+          ( ((Offset - FZRec.total_out) > 0) and (Origin = soFromBeginning)) then
+  begin
+    if Origin = soFromBeginning then Dec(Offset, FZRec.total_out);
+    if Offset > 0 then
+    begin
+      for I := 1 to Offset div sizeof(Buf) do
+        ReadBuffer(Buf, sizeof(Buf));
+      ReadBuffer(Buf, Offset mod sizeof(Buf));
+    end;
+  end
+  else
+    raise EDecompressionError.CreateRes(@sInvalidStreamOp);
+  Result := FZRec.total_out;
+end;
+
+
+end.
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/delphi/ZLibConst.pas b/Engine/lib/assimp/contrib/zlib/contrib/delphi/ZLibConst.pas
new file mode 100644
index 000000000..cdfe13671
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/delphi/ZLibConst.pas
@@ -0,0 +1,11 @@
+unit ZLibConst;
+
+interface
+
+resourcestring
+  sTargetBufferTooSmall = 'ZLib error: target buffer may be too small';
+  sInvalidStreamOp = 'Invalid stream operation';
+
+implementation
+
+end.
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/delphi/readme.txt b/Engine/lib/assimp/contrib/zlib/contrib/delphi/readme.txt
new file mode 100644
index 000000000..2dc9a8bba
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/delphi/readme.txt
@@ -0,0 +1,76 @@
+
+Overview
+========
+
+This directory contains an update to the ZLib interface unit,
+distributed by Borland as a Delphi supplemental component.
+
+The original ZLib unit is Copyright (c) 1997,99 Borland Corp.,
+and is based on zlib version 1.0.4.  There are a series of bugs
+and security problems associated with that old zlib version, and
+we recommend the users to update their ZLib unit.
+
+
+Summary of modifications
+========================
+
+- Improved makefile, adapted to zlib version 1.2.1.
+
+- Some field types from TZStreamRec are changed from Integer to
+  Longint, for consistency with the zlib.h header, and for 64-bit
+  readiness.
+
+- The zlib_version constant is updated.
+
+- The new Z_RLE strategy has its corresponding symbolic constant.
+
+- The allocation and deallocation functions and function types
+  (TAlloc, TFree, zlibAllocMem and zlibFreeMem) are now cdecl,
+  and _malloc and _free are added as C RTL stubs.  As a result,
+  the original C sources of zlib can be compiled out of the box,
+  and linked to the ZLib unit.
+
+
+Suggestions for improvements
+============================
+
+Currently, the ZLib unit provides only a limited wrapper around
+the zlib library, and much of the original zlib functionality is
+missing.  Handling compressed file formats like ZIP/GZIP or PNG
+cannot be implemented without having this functionality.
+Applications that handle these formats are either using their own,
+duplicated code, or not using the ZLib unit at all.
+
+Here are a few suggestions:
+
+- Checksum class wrappers around adler32() and crc32(), similar
+  to the Java classes that implement the java.util.zip.Checksum
+  interface.
+
+- The ability to read and write raw deflate streams, without the
+  zlib stream header and trailer.  Raw deflate streams are used
+  in the ZIP file format.
+
+- The ability to read and write gzip streams, used in the GZIP
+  file format, and normally produced by the gzip program.
+
+- The ability to select a different compression strategy, useful
+  to PNG and MNG image compression, and to multimedia compression
+  in general.  Besides the compression level
+
+    TCompressionLevel = (clNone, clFastest, clDefault, clMax);
+
+  which, in fact, could have used the 'z' prefix and avoided
+  TColor-like symbols
+
+    TCompressionLevel = (zcNone, zcFastest, zcDefault, zcMax);
+
+  there could be a compression strategy
+
+    TCompressionStrategy = (zsDefault, zsFiltered, zsHuffmanOnly, zsRle);
+
+- ZIP and GZIP stream handling via TStreams.
+
+
+--
+Cosmin Truta <cosmint@cs.ubbcluj.ro>
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/delphi/zlibd32.mak b/Engine/lib/assimp/contrib/zlib/contrib/delphi/zlibd32.mak
new file mode 100644
index 000000000..9bb00b7cc
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/delphi/zlibd32.mak
@@ -0,0 +1,99 @@
+# Makefile for zlib
+# For use with Delphi and C++ Builder under Win32
+# Updated for zlib 1.2.x by Cosmin Truta
+
+# ------------ Borland C++ ------------
+
+# This project uses the Delphi (fastcall/register) calling convention:
+LOC = -DZEXPORT=__fastcall -DZEXPORTVA=__cdecl
+
+CC = bcc32
+LD = bcc32
+AR = tlib
+# do not use "-pr" in CFLAGS
+CFLAGS = -a -d -k- -O2 $(LOC)
+LDFLAGS =
+
+
+# variables
+ZLIB_LIB = zlib.lib
+
+OBJ1 = adler32.obj compress.obj crc32.obj deflate.obj gzclose.obj gzlib.obj gzread.obj
+OBJ2 = gzwrite.obj infback.obj inffast.obj inflate.obj inftrees.obj trees.obj uncompr.obj zutil.obj
+OBJP1 = +adler32.obj+compress.obj+crc32.obj+deflate.obj+gzclose.obj+gzlib.obj+gzread.obj
+OBJP2 = +gzwrite.obj+infback.obj+inffast.obj+inflate.obj+inftrees.obj+trees.obj+uncompr.obj+zutil.obj
+
+
+# targets
+all: $(ZLIB_LIB) example.exe minigzip.exe
+
+.c.obj:
+	$(CC) -c $(CFLAGS) $*.c
+
+adler32.obj: adler32.c zlib.h zconf.h
+
+compress.obj: compress.c zlib.h zconf.h
+
+crc32.obj: crc32.c zlib.h zconf.h crc32.h
+
+deflate.obj: deflate.c deflate.h zutil.h zlib.h zconf.h
+
+gzclose.obj: gzclose.c zlib.h zconf.h gzguts.h
+
+gzlib.obj: gzlib.c zlib.h zconf.h gzguts.h
+
+gzread.obj: gzread.c zlib.h zconf.h gzguts.h
+
+gzwrite.obj: gzwrite.c zlib.h zconf.h gzguts.h
+
+infback.obj: infback.c zutil.h zlib.h zconf.h inftrees.h inflate.h \
+ inffast.h inffixed.h
+
+inffast.obj: inffast.c zutil.h zlib.h zconf.h inftrees.h inflate.h \
+ inffast.h
+
+inflate.obj: inflate.c zutil.h zlib.h zconf.h inftrees.h inflate.h \
+ inffast.h inffixed.h
+
+inftrees.obj: inftrees.c zutil.h zlib.h zconf.h inftrees.h
+
+trees.obj: trees.c zutil.h zlib.h zconf.h deflate.h trees.h
+
+uncompr.obj: uncompr.c zlib.h zconf.h
+
+zutil.obj: zutil.c zutil.h zlib.h zconf.h
+
+example.obj: test/example.c zlib.h zconf.h
+
+minigzip.obj: test/minigzip.c zlib.h zconf.h
+
+
+# For the sake of the old Borland make,
+# the command line is cut to fit in the MS-DOS 128 byte limit:
+$(ZLIB_LIB): $(OBJ1) $(OBJ2)
+	-del $(ZLIB_LIB)
+	$(AR) $(ZLIB_LIB) $(OBJP1)
+	$(AR) $(ZLIB_LIB) $(OBJP2)
+
+
+# testing
+test: example.exe minigzip.exe
+	example
+	echo hello world | minigzip | minigzip -d
+
+example.exe: example.obj $(ZLIB_LIB)
+	$(LD) $(LDFLAGS) example.obj $(ZLIB_LIB)
+
+minigzip.exe: minigzip.obj $(ZLIB_LIB)
+	$(LD) $(LDFLAGS) minigzip.obj $(ZLIB_LIB)
+
+
+# cleanup
+clean:
+	-del *.obj
+	-del *.exe
+	-del *.lib
+	-del *.tds
+	-del zlib.bak
+	-del foo.gz
+
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib.build b/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib.build
new file mode 100644
index 000000000..e69630cec
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib.build
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<project name="DotZLib" default="build" basedir="./DotZLib">
+	<description>A .Net wrapper library around ZLib1.dll</description>
+
+	<property name="nunit.location" value="c:/program files/NUnit V2.1/bin" />
+	<property name="build.root" value="bin" />
+
+	<property name="debug" value="true" />
+	<property name="nunit" value="true" />
+
+	<property name="build.folder" value="${build.root}/debug/" if="${debug}" />
+	<property name="build.folder" value="${build.root}/release/" unless="${debug}" />
+
+	<target name="clean" description="Remove all generated files">
+		<delete dir="${build.root}" failonerror="false" />
+	</target>
+
+	<target name="build" description="compiles the source code">
+
+		<mkdir dir="${build.folder}" />
+		<csc target="library" output="${build.folder}DotZLib.dll" debug="${debug}">
+			<references basedir="${nunit.location}">
+				<includes if="${nunit}" name="nunit.framework.dll" />
+			</references>
+			<sources>
+				<includes name="*.cs" />
+				<excludes name="UnitTests.cs" unless="${nunit}" />
+			</sources>
+			<arg value="/d:nunit" if="${nunit}" />
+		</csc>
+	</target>
+
+</project>
\ No newline at end of file
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib.chm b/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib.chm
new file mode 100644
index 0000000000000000000000000000000000000000..f214a444aebb20950fb3e8499b36731e1f12be95
GIT binary patch
literal 72726
zcmeGEby!tR_Xmt0Lb^-3ySqWUyF;2oNq0+kgMffYgLESxDJ4jYNJ^JTHv%sx-r#-v
zJooqc<9Geu_qyC%`^?@mpEY~UXU(jcS?6pdRg}fR004mg^$Bu)%1mlyL4X4QNEaZU
zg&sr5>2QFIcf>23$bY-P!QUL1KN5iJZK}ff<Kq2odU;dn^?`|dd-3BIAgQ9PaFe5Q
zeZt)2AproO*U8WGChMmB>iW3R5Bgdsi#SjndZHoZ7pFgTx{<vp|9L3LipvOI=iMAP
zc{lPP4A&n}3?z~w8WJK(Aj$J?8Q*VJgswHXE`nwtQC3lsloMA5dEV!c26YWp)>Kvz
zl?C`=WYS*WsmLox3SSrcy2a>U->NFfT;oBWza%PF`f;lwBm?q1PBTK{x+--^IT3kv
zWsrnPVqY0p22wFe6GwAd19NMT#CmhT0wib#Qh6aMNjYT|ki;D7XOGYsNY&K^9UN?o
z%ncmPoq;mu)=wO6G{*aFfr7n_EzsW4?OK=|9Qg(!4Rmv{u{Zup4&xu0LMrw^AV|WL
zwQsr1_s9JrB4XfZ0FoHNo#>AC4@p@ATad(TRwb-|l-$z;f)Is4#Ky?U3TW+k-2@wJ
zdNVU4khpqL-+b49mOKH8pXU?Axt4I$k})@=7c{m6+6$Wjjh;9-S<#z0T3Lel_6kK{
z(ESI5s;#ksBT&!A8E9{5V_>Yu@<YaN%q>xs_Wvg1a4XW~9`%&`_aeeJ)((#LPDYM4
z_P1bvf^b5Le+4t$qN5&#DE~W}`4*jo5@tpG`?_U;R)#?PTaA4`Y7~qAN1&sbjq%T>
zWj@XEAo#1spY)0Yt%3FicWv5~3zH%HFDNCT1JLn@j{f;lA>2&=1^aiq+%n<6i4ckN
zzsTKk;{Vw>0`q^7yX^=5y$_%1{V#H?x9w}T45wlIzqjv}X#aBXD6{`Yp_+lE6Y%yC
zvAiK_cU|-!MiDY_0MhFjIoaD^52PO=0n>~j#w7n)tM4M;$Bh3eRfG)Hzaa0~Gw=m`
zs1Vz~;Qxb71J`(?*#1}9Te}8M!9+6uud=tc4Qv-omi%93Z|xgc;}Ido`oFdJ*2aN(
z^3k;aM(sU22kdBss?h)UNBzUU1eD1|h%o%0g>FYzz#EiM{{OqwtqlS?6~amWr9oom
zK+B)rBw)xPoR9jy>-LME3J7$1rTMP{_xx4B8EuxqoyY&}(72s(%z?LN30Ou87rAra
z|B(4bBfn$pD4YKZzNd|U3Q8pBf8povn)nAnhqK(dWnmj*pwacbW_&kE-I^<?8$HVK
zzXES96x1jcE=_dD_&;jA<shhnD2xjCZ@8aK{BR*bX%r!Xf3NCh&KGnxFt;=?w7m6B
zL2Hg7<k)|!O3d8a+`;U&qA`~cCe*(HzWbiQBfC(mdtT~B+aJ!%+(E?L!PdqBX#As&
z;CGTC+V{-x7xH&(g_OI;p#CfPma&i=mI(2Cj`+7V-?A3+Tt7^i@Yj}n*Y{WEf|nnM
zvfi6S|Ef~h5@=wpYWt%}A#L!XV1MKHdu2v8wr-NvwobRMJfs&XQtEdK{>B!eDF&e=
zzkBj6o3~FM*9s%~T{Et&W?*UVerwo}d9M&^{NJ?pzHvh~C_>#H{s#2jz(Kp%;Y`0X
z@Dm{?6BD4l@?Q@N9w7}8yj%Eu9}3^ukhlI#J3|f#Lu`Imul>!!L*B{pj=c-S5S`y4
zuW`RxEi}+F4Eb+k>_&rsc--J>v|t0ge>Pdv`Fi@j?J1$rUSY<+!QA(b!HrIlD!<|P
z7ylFVO}b9<x1f7|CwLpFP~kUS>F@p~coG=qg7vHB_q7h1r3{n#+fe>h8z0>mi+=#_
zX%duU7QywmcK=<Apje48y}Nb1u#J`Nwb>kGfX+b6A00F_2Rs_*9zsc&h52vBsv-z?
zxaaqOLHvF7!SbWlux6I~D}CYrCUa}Xurk*BEB#+Y{?RW&zi8fH>HjD2txFF*a=X9M
z|4-;!FBN(vbAP4(3;Gueg|?vFU+Mo1c+XN{VO%*LcisJ$K_+2feY3f`rELr<lK0O4
zhyYD2ulG^*zn!PT*O8(PN&o6#zs25C8$K%&CUV!Y|APMFBg0SZLs;*+(_f(b9w@?>
zJe2%;+xxr25HSWJ1O5n30L~7!4rT+I2HFJ51=0yZ?STQf6qqY$0th@v6o4OK0=U`#
z(?Z<UaT5c;_-8}Dd$q6yk^7VEPp$sZA;R;~L$Uv<{V(<k+d`~|_#Nh+slv+{O7ZUe
zwYZkKt+Jy%(7=jb*uYu|XmC46My9ibnEWT0G7$LWhdm?nu|hcRoW-xTsoR@7-n#$D
zGKCP}Z>#%dGKq@!3>E)vb-&IgQ7?o;=<n=(@3CT*PCu6lQMq=ZMwoxmeh>7W_=qr>
zNUgi+?Ow4A(Aw1TcD)h#nk|C;w;CzfIGF#4Gu%WAB0HW$-1E`*YP;h!s!S#M_hj8*
zgxr3T71aY9N_}U>dv)CrA2rMt#dbI1e!)22Z$Q*%iwK9`QgzQfQJXr6F2AkqJLpce
zXn&Px?7JE8?y>*quMx{0VfuHY_qWJf?-jA59i{Lu&|B9PaYYk}@H?aZG7ch=$@^7*
zkGeM!B8TPM>3-Mfzt1s|5nQqE@PBor@4d&jfGZ37&XGx4{})FVlcay&k^L5X>&Rjv
zaql~_zo5T3vY33K`;P1{(0xZ1Q|25>e&=)k!hBagI?g&=^sZC?Ec}NJqsO^|#qK)d
zPuwqDN2jyg_c?c%drU{qJ}t$&v&S{YhF-$JK?G>%WcvN)yH>F=tRbQ|p}HR-xx0dx
zdfYJazlq;0_T)|EO-%lZ4aFwAg(%#)nD630PzpBY);E*PkEdixhA8~fCL8)6FjdK)
z0gu>1tPrWYF>|jfRT&#=)7y$FjY8z^hQfD{ssqsBI*NK7EwgmHS#{nb8<|3M?iM=V
zk!siBwC_R68|M+*fe<3}t4{y0Ma&+4@T0rs)=ee9*dgYvQ7O;eChVsC@BKLDR3}mW
zZY6XR_!M<D0@~hrvDo(tk(_s%onH|D&?qheJn~*J@;`xZ2YFm3X(Z^~n*2YZZ^wCD
zDS0@--PrsE{Y$fBC!y*+p&4YAMdav>92`IrQfOLS5E*Rk&7G})H(ik4)Z7FlAp$%Y
z4&gf2#?j;^r0_j6e%mn^<pyfwcn=zX3=s^6{5|)&<a?C+M-}l%!8q^?woZoEOUvty
za#L;mB}x$Rx>_g0`xVT42e~2LWd0%_zvdF;1<T-Y6Pz~sQDcBhFgzMJ_swca+19`a
z$RKB6bsc$ka0CE&DevbiUk6JKOo7*}{JFjb8Z%tm!|_@XK(>&76%6hF32tv=dGj!U
z1uoUU;;%KbzUf2&LnwxS1*_N_SUZ^5*jq7tSD%+$?|%^S;1CmL=Hy~!q~j7{VWMMV
z61lz-V&<S@WE5l+=3)}%66O&0VvxL!g&SBK0dHDx^UZ|$|BoN>Jxr-`6Pf_{Lii%x
zdZoL)<S)U3+iv@3|9{8NuPe4c`~UC3sDC)oKl}fm^ZoapBm3QF-!6v!?En8-4E?h8
zzSoKV?Ek+n>i++*|5t=&fa-*N3>gCP@d3pHNAOm#Lr_Lg7m#Xz(9Ql|at87Hcm8)v
z@Si*TA8W$9;J}}&KMed~;12_T82H1$9|ry~@P~mv4E$l>4+DP~_`|>-2L3<D04M<e
z`t1QYfGWTmU<9xMSOIJS_5dKj;rb5<FuraP96%PJ3=sZpnFoLaAa-5G4B!NC0ayWy
z0J`f`1i%7dy1rt%{u8;*J9qf;^MadC87&RrpKmMNq&IIH+#EO8@Yg5Q^+|bs{*(!u
zxW2hLe7=AF^+Aa6<I*1WM~X!7BXuYJkq$8ZNPF0Sq^!a}(jAE(X_(rNG(_)5n&A8+
zRcZN=-n=~l0{{oq0%ZiD0T=)Y2|>c!ufYge={Z>GIXM`auggilzhiMD^ZmVvAHsn0
zKJ~2h7aczvcilR8z|YX(O$-PC20*yZxc3480OC5w_?Mgq0BC@$gR!*)(9#wFdHt+1
zD5GMy>-6Th<_bxLL|OI~aW%-zV}ict{&<7q_VSmvJZ^r~@%Q5f_m_%4h5n>}82H1$
z9|ry~@P~mv4E$l>4+DP~_`|>-2L3Schk-u~{J)9;#M@W^64Fidgau511pq))O(ryd
z1lkJ<4U}b!vlFh=$D7i8MMuk2Nz7V{XY;j|=6tiZHcmtQJY)|M{NXWUF#tfqtS<@y
zkOZWYRRSyJ)PzW-rIW-?Bok@f2oou!{V6E}wf86Bn|cRo9k!a1=<6%bC$jZADJ=&a
z7pWfWw>tNp1R$Ovql(VwWf2_s5U3IgsvhL#TSH^So#=o{Uuy<nV*%*f2uyicO&--u
zrjQoLRZcZ<Rn|Fcdo)<$YHGwqkFuLvUue}<Y^Jc5qRz1{bV(3<S{eyKn1M(VG5LfG
z2#^aPl0FUqkTeK1h;($G6COVNWc$usX2A|iOPZ)cF#cI$)N=}HTa*YVOsK`&BT2Z+
zk-p^z9T)-5Mz8f<DEbr9#Hz?>^+Qqys*;DvUL}rA?=4`lbR=jsW0?YvR*h$HnNhp=
zC!izu;7A+DiZ@kulAlK{n{*^;+WBXnvVm^`j<GX6d1U>#IMvXU-V}_qao1<69ICjx
z#>je?dOT5Wl|%`3vbEPHG~%aFZzYFws0JrvGib&2P+KG9gm@|Na;`dR;@hXdF0GoZ
zA-H|QH*e*41=$Iq5bI%HN<7~G#@%@RB7i{JIIaZ}<lf*1qNv@R80mBigO}%z`iZw}
zEgt(Wj3vdZs**>5Wwy4o<;eoy+hDvrhjIDL?wm@1uB1Q#CKL+EnX#od_o5Ll)IMaO
z7NBj&@^Kd;)<%OES%^J;dru5(Byz|)wNe231+*1B;m&Izkxf{~q>@M^K5oRE!sTob
zc|{J<Kr^;A9X$?SfkG+&D6=xYDjU!xlKG4Z5cyg!w4N`X>+dp9AWy9VYkT9+9Xs~h
za7ux3s^H@U1XPuqE^Qhl@AX5bvU0-YlbYY7u#DLoD@_$+y~Nzr<y6Fa!4S!i;QA2J
zGALhqv5!pY0c-wzE$U(bk))YVbmXfQHDWHZ5;l5iP-^CqLs<x$NH%Ex5|Bq8{Aue`
z1{W<W?JrFTF2VQp2j>tM0>7+1`o^!%<4#Gz6nx%!45)1j#*6H%w}%<A9__5zMR+_D
z*d}LF#Z7imTn9c|aAt6zN%c~HY#)U{KB3?pb03*%U4OT%tPRy6o`kXVDl+tFAWTuG
z7S&vsCm)jJqNMRq{O9Mbc^v|fCCC(oVBC>lL>bkPU;E?AJ8F+BF#1h*)IhVyMi_Ov
zsP^M0U`mpo15%jKwLnIhv>I@EEM%1`z#gA-uZa|{w;0Fa<;p*AlslXpj&U`@7sC2t
z^zDl(eNUPt;1!(3LTitPAQ;BOW~318lc{z8PH}Qizn}}TOCKI8urso=eH&5)*=8``
zp2~o#l&9$#hnp<9m0A6^0!0mYp=~A0p6kv&f``RmG&`p&3S1xA1q#Z&mWDQ+e8$QU
zdYCmRYx5Uo_^3Kpt2*gWb+llW=!(}qid*e*;K%r3yXT@z9M~6J6s4W)yAYFWe5HLK
zLzt|wA*)yYu{qhsS{D>18jm#IH$G*d<0Wc!%;ZV=R!Zbb{^7V)aDh~#Y<J2?Elr`8
zC3{!ln2mOm?(ES(%ghu=MPywPaq#kcAk#2ZuAKF=aSaIcvUEmqsU}+Y!0g;}4##{|
zeJ?dcy!7-M<;e`<`TXuIMfji<x3z9L2HGu=aE)LFdU$AGvA0?Fim5>lpjpjKM9N=;
z>p{p}tsH%-GWJ_W?06|`VM8Q3<;UnLcV=dbQ(dHnG(Sljt7Yptr<tH7(FGGbpE^p&
z0N$#7(#wDz4$o+)@m7!3GZI1By!YV-l2}7-=L-oniowX<7}*n%G**&VvsO(#{<xEp
zp>cYv!i*oOTH}{<Iuy1J(0Ue@^;7MY>dKWA=+9*g{ZYWJuh2k-7#a>5t$bF)tT%YE
zXknN}yshg~aR3ihYrf2JAi1;`U>8O3G~wXHJT%z47}=uULl5)|GbC{@3l!y+B2*~f
z5DjcU3lNj0L9LvJs2$yYo&PnlA$`0mw8lE44re*ay-w$)@TQd*clNAR(%5uPdB1zi
z$VV@;e2am|gwU=bi3Ahc2-#RQ@Nj4ZR|M%yV{F)u1EjT!9~IyGxH=6o=bI!9tM4V9
zbj_g>xz2R!1`{swDfWX?J_xn2!x`6(1sn7`%cIC}oA8KLKFZ6G`1-{Mb%Gh{twcVN
zq6VA;DyiF|ZA@EJ=2F1GleU)erF@D~9hw9hVXb^lDkhymJIUFHVbQAc(AH!-KEV8w
zAjx)Vwy>U^Iw=20(<2uf(23nLxb!{&gdH4nxP_*xYF?fdBUT{!B>#)%AdnKLLoAd%
zF)T0&Lw=ZSZHt59{(K>Bkvty(DpM`l82!)rC-3lEYU$}o8c0{qipkSGIh)_p6+1p#
zvQ=^Jkc`a9Sh>;&={E<<*3Q65XH(xKGsk_s8o{X6xD&4X*)r4CLE#*tde3<2Ftz&J
z-bRK2D)TE^O0lz+q_}32BSXH1giVjkV-(CZqm^v#z3`3d>Q)Jlz#WZ2C|%q+1=V7(
zOL<5p{(S34Nr@ks)(@gEk0mIzP1K$3)Az#HKgrY=yXS2rUBJ+Y=+H1-R5Fa~QBCT!
z;f*{V=ue75&_o`g?M=eV>fF=Ze+=&v4p)Cx6@aLwjlc>kTCyq1q@mr`ZM7q*a8^Ly
z7rz}o$wn8ZUHU<+Y8&|JQlkt+Luh{UZ0GGW=pkwJ@fV_I9S-k7!Cuo$&2Vpl9RZKd
zRQCZ-s|f59qfG4gNx(e7C8Y721+6zf4~s=w7U|a_o6;>swO!S`4CNDZwO@EKZpwjQ
z@Pb_6ThX|78n<ajY~qq3^S(+wGr8h3rvwh}!Q$1lFguzr?N{aXS~V$=-u5VS3W<qn
z@)z6PuzQS2q>r(WG{ROYB;F7^oFX=zE~dK9y4#dXex!BgnaRaZU$J?%%%?&@hbFD_
z%Ej3Yq2$%}j60QKxp?1@dHrs(8ZPvf(sVTU+E_+p@nQTY&2sr@D<nEi$h}_mkP%l?
zC!){TZ*>^;-;ho|sPO(8yoxcfqEqX?w-F68l>x{*l95$+F#fzj1+VJ-K+ktL;m{t$
zn*%I&+651%T{a&pFy@uVK)CaMp}j?{^FkcEfLYv<4xTgo(Wqm$#Om052eiCYmD5DZ
z&ijs8rrC14S&PxVisY*Kk%D6meU3**RHOwGs&qZsrpG0M*RMk9!HROcM%3-<G~FZT
zYS{xUSpnppf|<Zx0`-OE#%!0J{6D&$6?CkcM$f4gwU4xuec-6~Of`H{1z8}{#npGf
z6M@Z=)-uxnpl=5DW7`-SWCmPO?>mu)-(XZb)E($w()#z-L!EMb*e%#1Z&iG(gpF+|
zPXJUKk3eY3l_H->hMO+$C1jVgFKG1?m&zkX*b&7{SCJIYlb(0r<YTvd*xgS2Im;P#
z28L;imgiwg%`<5e29eTZZ>-{B6Oe<c#D)(vOF1pvX>9N(5)5M=Uak}sB*b)ZU~ghv
z(IG(iUu5B<3fH9T^vKy~ats%hi{$1Kr^pY|L96c7P4Ov5#}w|2zlD{iskUo=IVpM&
z5&@Ix^_sV=wO8TrX-WhxY#pk%*a8z;q0z?Y<$dMxBn;<P;Jl(Gf1Kdg^g$1Kf*Jw)
zSB&qE`y@mLV(FJ2uN-A|<59m>Zozj{YZV2o7z&>-DtLB`*fMufc%<m8@V}*^GcDxY
zrGNU#oWUN}PNk(ijUE)$dT&gGio)dT-RYF8k)Hh-$gxKYGj-@<#T(Otd15D!x`=jg
z1AULn<>%(P`up2-<26ztjiYl_%skr?=WwAIm-DJTPl3SZ?3yXxi-;#GI?^qq0Vz>4
z17s=BFD^xg<MtBJzfn%MYT#|Y)^?A!LBcY3Z)l+P*&WjVKt*-L0b04BK3Zwo`<3pv
z2=kB^YDZS?<&66qUZF<I_1y!Z-tz{T8B6`_rTJ$qF7{sn2HnqI<-DSU5oPzNh5?f-
zZ$S7=Xy!vm-Xn$e)Q8lPvG#?Jhz;vF!ul)~6_Zd3(@GZ|4JpW$0==_N<eQjC*-eH%
z78;c@JwX`Lk{n~QJlu12SLk$Zqd+Fxl6MCDoUh{4M;O9=ieM59ZBCw#Y7XY$;ShSS
zU^wl?e?<zZiQhn+5`-;#W);&5_D+_+qq^H#a|7{9&EQIBbU`Ow8n=4V$Jt}2qzq5N
zi>9QS3XB!9=mS(}0@iPiJn9F_P{+q@xoiB?Pdx_epH5dJ=0UgN)10zR@>e3E?b9{{
zu=7O-DJXpk$DfkL>3b_qCwq<n-WNj3kgP@HI?rx^^98*;_7o!n&cg?16Tg8WppOsB
zchf}m0MtIqG=Ol_GsC4W6<_tN*&{goo%|(Nc1@k3(86oI6QxB_Yg-q|6l04k9U2uT
zUth!skI1^F{<pX#8op#pESXP6RW2_fa1Rtr*}rDat|75Dj&gfHhUWNGuwl$`cz)5w
zQ4G3YwiMSS=-Hu&oD{B;W6#frnp^n@6=PU_k?L7mXiO^wUO`XF+Zq~JmEZ|hrEiqk
zo12S->JZ(UJ*8MzM^gggLS^N`54;Yct-#~H$Opm6;`8YGxoQ}nH}tDm6C{>AWzyOt
zc*q%{(5GjR-L*c-SM-qC8rWtpJ}eyPLfs2(;<xC#Jw^QH@it|6(Q!uMqWa$9hFCJ+
zRT%T$IaY*d`rLD#gBZE62wU_81Db8AUisGK>`=O)&pfpP?+S}`2*d-mA)Gz(@Ft?R
zt2G~<dD2&rIbnX=M)Ij=8WMbLL!>BJg^gwVe2)myY~)kl+h<baQdzJMXO?ub9NSJ9
zvq#GlXWbm6gqDn6N`O_b#M8yt!7n%M%h`g5I>L5HM6v*|CE5I0N*l$uUwYfeSNjeS
z`)!3Mh4u&uQ#rhcI;Damwu(b;3wdYGeE#~QH2~Q}43<5R`+2?}n;|>zyo?cv{eTw-
zriS0vVZYvMCV^{zOFyle9<$auzW9~f7(b#M^>`otrAN#T%&-+lM;i#CcGV|Kq`IIT
zf;N?5q-`97b)<>Z5tBoK^NWxKcbHM5957zsdeFKAo1-weVs;pe$jiL8B7qK@+Se1&
zXa+-)2$2@;Eb2y4lmv>Y)31$JA!c467rmo)o3P%2aapVL?BrhZdYJdl$<vBX^4%Ns
z=OLi*<~l+JOeRf|mYrQdre~sC!!vbA5Gh-^IYSn0JBqa$$So?*HtXZo_8`)%X{C}%
z2?XluF<_D97Chn6>-%C~;;j&o&8+sIuC5Hud||g|)0M~D+^e+JPOja>HqYSdkF2!=
zgGe!}hQQ_+Gkdd(J=c=$`tfz|1&_XOo>|5>oW#%Vf*atEtQXbgyN&#ESLSPS<m0%r
z)}o8cN~&N4u>$QOmq8~BiXU;z6*+xu=JQSQ+JU~{t_=sVL>ii(V-}H6M-2+xf>cp>
zIMCfb4tePxIM{PVzTgVEX~XBfSH@ArgQ?rgVuj+KEw;e1sYH^vCBEZf@jht=o(vh0
zn~>wHx`X_i$*#mR0uKVRmx_9rR7y)Dk54veWKQB*0V(P+L<65F)^;aRpkKp|uzBQ#
zo}#0DW&>}U>Y9$o;AA+UuF9WZo{;{aJKq%kvUXhy@=*89D=Ub?a*T7eU=t2h+ju^F
zT_5)2dY8%7pe$0{d=*6%?4Gze7XqdRlwH+q2?g_SN?906dm++;hlki%IqQRNO@&Q%
z!SKZIOzqvXZ3rpRV5U&ucY9@~&?Y0Necd9wZF3id>w>~;lKJf8M9mK061%TP^D8Kb
zef?xC;PJJB%t}etmuBPK6ZAmAKR04Yp&^}d-hxC0@DY`!5%Sq1AU0k}@zaS<{_efl
zXBtzKcG?TAhz9f?RcZV09+=C0U0L^`zEC%$(&r{GWIUWFL1Kp=f_aO?8DHW53I-`u
z4V*tDLS-;4uBl^929^3*t!}ClMZqHi{2n<)AM5OlG$KK6{1ii(a#N**5Ev=Xup_*I
zEX8BvB%cD69?VhC-nAo5&*$&7D^H~kO6|04QqmFHP9^o}rY89F+v6*7?T|%yH4v}_
zE7|Rc_i_q_AM$%n)CxcyESmRZrjxoq=Pt^|TMQqH9t&kO(dBN?7O_M<t^EK6Ll}xP
zi8Pc7QWSv)uh{aAR%Y6#M}<<R5T_l-Aw)Y+yndiBitcm2Rm-O)Ja3PPKybZM(BU_2
zZ(|i9C>O`NhuVg&e2`KMd?Bt{8q+~=86vNUk!`z}G?0+n9sB%)<v|IkS&t;CdXjg1
zBxYmhE<#>sDV^{OiS*9!yH7{@mmZ){U%dVb_5R?MpzGt|H7&>z1wlHDwoin!&tU!a
z1pS$dTb84Jqm{4~VT0ck=J#;p?w26bGjL)w$3pSqz17UwhJQp&f<52e$)-SwkIoJw
zl3+6_my0ke)>r#ck&~DB_0+Q~Vzkg@UHqpJX6b<>II!X;$<T<b^q5TngajcR?Yogc
zs0H%JBf;qYum+!H=J@q}L@H2fju9yh;A%CU*TPEUQz)xYyhO;6*tZj^bkE08uI4(&
zIu6NKJ^^u^Qy31O<7rjKu89VqWzq4z%#qFpdGz$?QUIHSbZJ;Rh5k)rgakh^G|E(B
zm2;`j33dTE+8!vGpUFbvSa558sP|ieH8&&y;hBk9E>L}{tsz%|S$N!8RZ3f;J|*8y
zv-j+r-|k1;Y=AN`lLUfxzTlPCpSoT%X|6@lc?;IY1ayVOOgT^2PUUS?)o#U^i0_9i
zTu0o-kv;+dSXi&KzyNDt1QPnyF)2_WG$5e-t!3@@=)yKWI$x^$+nv9bmT8PRmo~bD
zTUb3gZZ0YLI@35=QnR}on^ZU%wOiL+*w_`uz&o<4W#t;GZfYG72->_;5iCFmzHkm8
z0sxSiz_J;Anjg)cZyn8SUCk)h%|rk-s~&!~t{r>w^`p5;&Wi+D79=|DR7aDT0%}$$
znXClJbk}rfKOa!P9H=m6P(q(aKK_8{y+`dCnBfFzgt<L0;VZF1cO9svgc8~MQ?XbR
zf^f2poC`Qk7AQ6*qGChGO{^{U$(Qi36<JVv=_@o5m5Z?2qfAW%9tk!I^SPx4(Ya-7
zxqpThEooo{T7>yO?}e)*?u*m%?G=5O*z`2edwRd!QC4AjE(XI{AQK2_nUv53>yY}6
zXY1or!u*R;p2vY6(a9ttr!Wah^~>vqHMv#|;cYFG!>CPR>D$x7>7(4Vy0WcXIZ`{L
zMdOi2Gu)UBX-RrtJW^m~;VGc4ww$%#wNmA?CnLF%QyG~(_IfAiAJDb83#6H<)E#XQ
zuNPlD*h$;|@<pnx^9n}$RGLfE`DGC=1!^D<C9j=fOX*mVdh^D5ex)DShX$cncJ3mA
z&|nHEvBO?3eS}^0HA93)Fr`H~-58u>vFy<+50j@lULpkJNe-tbg#!CXGM}dThN0wY
zd0vvwsyF$cYcB;lFx7re)zbU6<IlSy4wvLOI6tUx(A-IsZ!|bKps)qCkmzR=+Who$
z1k?n*!h75LYSu}P%{kVFPn{J!{RQL?R4_2|jCwuGKGf12Oif8ssENqMb4v>b@2G|M
z7#N0IF?1Tz^kwo`N`MlDJc%7H?5U1E970xI&R&U>=N~t!|BzT><m#L}s68q#*>?G{
zi2LohH00cJBGqih8UXLB-)vMXOm3E3*_x>%MGb6Y*y6F)mhTS!iL>*b#!5PiqhZVI
z$~m()Do1J`!oH-CrLC+9)HTDH#iJkwaW<Oqlh!m5Ow$c*o767L>SOy-Fjc6o?NP<!
z(5#w#P4IIzM0u;YfE$exOO%K$+xkrpdD_tEu@4j~ro%o4qH}!n@yQu{vq*I`Gsm2%
zw;LNn7p6Fi^CU@EkMj6r;}eeDTt2bvNQ($~>aY;+0=vs?I+Cm=_x2Z|CR1tz2#D<G
zXFR5u?Qg*aFZTL(=Cvxy&1hIm*SU(;zP@6in4J(DT+(^NDW=`dBW(^GFKtFBNuEFn
z%xG`vhSd+Lc7UE>!j>Ky_mvG8YTe#^)P^=aWI<Fc@KnqvoVtQG>Vm1W+!q?2PpDdy
z!?>rD<dfrZ6Eon`A~y>k1u3$O-du}p_t;`9-r~}ifx7sI7ctJyM|jq=E%Y+ZHXdcB
zD^_NV)L~*WNzzaAmMIcvsT0)5a$murA&+jb$#ZTbm|7gO7-y_K@f>_1uX}=w2i-cq
z3Pgw{kejSq7cPDurWz?n7QAO!Up7fOsNC)kOZ6%f0n7IE+-wRwcoT0G;tFO)<jMy>
z-D^=T48wu}uwoZAI&#b^nC--lEY|;+K+tdXLkEM^s;5z6fD1eq!>Mln*iy&K(k|_n
z41HBF3y`~EyqV0J<~){HJ`eWDtFVWNBZG8ao-{tJXhE7?6wKn9IxDDEEZ><jXX0JN
znurN59hNlfVJ7&nHR5nkf2my>{D>*8Jd%etAphHkuB|@oH-*n(2lBVC9(vdED#>(+
zPWLRJ5*Ngw5`y@2p;3Pe_UJ>x(r>Nf7auUlUg8-s^P41)A=Q=dZCpA!A6hLDt+LA|
z#*1MGMjyYYqYw){pTOjse_3HF?t+M)T&}IaG?+S%vc0mabYi&Onw27s-2Ub)D4cg!
zv2j0;48?)7!zjwIEmYd9mTo6&9S)IGqO9jjw-v)dq*XUur=Nj_*7SNoq8MageL`!0
zvh=ahxC!Zp)kZZU0?{*yOkC1cD$Ycwrn!BkS6oW_jJcl4!AzQ4A*QX05lbN2!U4Fd
z=-qF@_K4l1bn6V*o*T-okqm#pP<I=C`<OvjMQka~Q0+~Z3mfUB&k;58!$k_C_>B+?
z{(?uujG%lulY0g%vS13?ZExpbCw;v|ZPVT!z-7_e`l*Z%Q}ihmEkjcw)QY*k5@?3z
zgSF{yM+-+$;8+kBO9(v^)9~_Wh64SDZUE=kgiD%|+x$8vZb$D!$mAfnCLfV2pPBka
zXsh$GcwRb!mARyeN5ckNa}F3e?TU=1Q5kc0lBQyCI8#`ON-V31H9%9|#x_cZEj~tG
zAH2g0*bA=kBxYBc2!ebgIWLGFNJd8Rn9iJ;lFOm{NFZp346wiUsI0G;DPY={^i4cI
zI@8<-nmOwDp32#z_uHhSC;IU_M3&tvexDsqgxF3h`}BkkEGDu!mx;D(`bC>Q4ahLH
z&4+doE0`V5H80hmcXz>?vI+q*w&HWnTiQ#4-y~r|M7$m)BxS&Go6kv90$D00N-P3<
zz4?s;&W$~kK64y%dKg*grOr|DLA{}Ltu%&o_i1DoDsfWT4zh+23WO)N;n2cKWIDmi
zUbup8<m3kr%A7sJ6Q|u*t>~!V0J%e5xsHP@-#daiW)*n9C+tON1&Rc~%Smt}T>mS-
z?vjE;;;Zfhe{&Kz#E3o9Md^CLGSqueKlR4g?6Ad0d{W}dC@;3A&ex~wqAx^0=O+j8
zoSH?vieTcMugR+RL8b$fjsF5|><V3iFh^!2@<NG?`dm7Jff5N8;0QnmfCvBxu>nv%
zxEn^)8#(2^009s{*V&13z&H9<Ie)PoYe7;chS^3@dM_4hsIM`;3`!P?{72JFqee@R
z3;D3xsxA+TAsKO6pkV#gca(_aG4w~qu!*N^=`CIl73Q-Y*QepgRB?8`R3H!FwaU_>
z=*@0}=T0=^)#^QZHrcEYR>9P=P#Zqx%0ZpZzE}04u)l#zd(QQw8PWQoedN2vehh{S
zbg_5OM_Va2DOu)11^5`q*9J1I%fVlMa)DlWpWt-{B_+(zU#IJ&lz_?0pGne~AOl^;
zDN_$LN%cyYbPfu@dz@t77=x}Gh-#|y`G`(<ZX_)BSqKa?1v5z5j+ar%9;)bzOxrET
zi=Of^!6qnd6r&C@w)I?+AwgHOVVF<}K1mXa&q&Zh(`88HaE=kd3|~4;pR_M1xQ7TD
zXTudo%x^&Wf~yp>vf%8`+8erGxC=cKT}~!RUv|^lX+J+VF^7FRJIUc*hvsNK$Y+Yr
z=`FWwRA)%e9qe-$9`q;_)uzR3ww`gPN>&PI!A9s(sb}Xso%|H9RZ!zfm+0VSyccH+
z!K)XJRQMZjR<Fi+GFN#mIQmx^28}2ix2a+JWzq2J#rQ&uMzGanJWN|pamn>yZO+;}
z6#GxzQqxEQ{VY#pc%R3A9DSYV;(2jMiErqwYZ<ak1}{D-%}LMFrpQG4GESz%b99>M
zTvm6f1&%<mER(Sb*8BAlgFlQ^)C>lib=g>dzUEcF&^HkmAB?!3nf&FV%`$Nk#7C}L
zgxtM7h-S1Omi*<Q$j9W@BHyxP0u^cb#U53*BGdx%x7!3bsmSYG(y%ZYl~7n+d;<K*
z;s*D|+yNf&aqWIgNeAo8Xx>i>+54-v(JIqg>Qs8ss2T9EUAi#=E!HnONh1p%KTxh!
z_o^5o|N2P;7Y{YgQ{>@=pD>_0YAqLy^#qgyCnmqA;4CiV%p5n_9-a<=x&XtMTA>0~
zfhmX`Hq#5mOPMxA{%T|-)*AEyAjfSv=}R4)-(V>*;d=l+7kj~rRf*Fj*fi?8@aC<8
zUFq_9HFaZ`*{g>PxSg7!JS{SkGcbNNwW$PWae<yNd-67WAskFE<P;%jb?xe0MYJ7g
zfaWVRYWNd;>-szqRcd*L+Xe$g#Wj~c{cr$J$g#||a$w_zoQDn}38gsA#hiNTz=exy
zcJRYD#5Uxrr&WOn$J(nI+2boL5fAJx4Ij&cDxxvtKC3Bddzv=&DpI2-jkw64qgORN
zc$m=nL3+khHT^M(vnTp7!3L%JRAUn-odw!^%RaNL=Nyy!yX+9nm_kU44x%7X=c$S&
zY%7e`HA56^;uSA2O1_HM2n{Z$Lt+Yk?86qO;A!Kw4Y8k8^q(AT^;FV!psmj0DiAl(
z7Wo#b>?Qu9`+@MMN!nFQk}1xx7$rwbLOe)A#V5ua@a4mvHR0|tG(<wrv_CbG6>2Mm
zdQ!tsw~%b}t<$!DA`IpY>xEnx663d%D%!2xEpv}kPOx>VQ57w18LH3fvxvEZ6NJG|
z3M+unT*e<;5YKrZ0!<7G>3LqNpoyl6K&`|$8+L+Lz+oL|6-I439VQiuy$)BndftMp
z8m#Ee2SvW!;v+kt@%*FSGpJ1eWHiuc2+ixo^V&hGh6*I&vdI+B-&Henmq^IiscUY2
z!$?vj{IJb5QjZb!HA~n%P54RpWYMrRTCGl~H<Vo~g>`_VAj7WulF;G)6Ed=rdCG~z
zxs?L3y*5#mq+|(wzm<OQLi`}BZ4q^3eU)`as5MMBJ#X|&B2vdf_t6F+V_|Zb_ze1&
zF3sfSQlj{Vu9LJNq5xyw2OX|5F-3%XEypEssPjv-9WJVLKvQ>fLQn#I2y)XUS-;RT
zxKe2?d;DaKx=Hywz1Q>vfB~a#UP7n(G+YA*+Y?)Ca-f%GG~%2P>nF2>aI@Ly4y5nX
zsinVFN8qb6(g_#}_@c3TP&_0ywbf0t%zTBtEJU{5Z(<XYM2W6&RkXsD!qN~(|ESBg
zJ7n@HL;kTmv4%!bcdfHi$*X!AiGBS#e+nmuwGPhZB0|x<bAI%}qVSIhNni?9$u?G&
z?JDk{#ZLNV>O_?;J&pr1jF_~`6*aT4>zFNJ%Y8>&WmbBO%?!Un`jw`rG}8sB%ohe6
zbBev?3Gr@gmI&03t)mlNf*Ok<|8Nj#;T2^KY=TApTsc$5@sZ*4i-7Q_+>Zk1#+_#}
z^HERFrc#S8-!*t!&f1uP#RiT8N-f?lvJ9cGFk5n<uM?*6E|Yw=2ATTkxe!ci(`T2B
zyoOhn+T&IEjA}>z)u?FE@Ml(i%1=EYb01v`KS;q&H)QEwZ|;4l-{Y0H_h7?d#(eWX
zjsKRi<`y2Dlg#PQy7^3|_o1t7p*E?=Cc*RWK4hlY4mcQQCONBp5_(bE%lJBSB{|lC
zx=o==x?WSWRJJS8py0i(0Joe<@fqF`m;6thPkWMwFNh3mJ3J%`%_Bd^usic|O36xC
zWUmCdlyVuO`0&xIiQ3T*K;Tc2S@<7#w8ZbfA#b0qf!}1*j}r!M?jqr!RUzcYJEsFD
znO#>H6gr2T;V6MJc>HzgQ`r^KVIX}?+>*GU@PMMc()cCHr@~kaX>6+)LQ#_opFBk!
z`CMpGYdf3?F8yh-JT3Pli<~sLJ>oBn>WcOgZ=-h%C#9B1!E-b=Uc8nJL-qVDp``D2
zWg6{sNa{X2-Oc|jmZI|=4Y{?}6P%Hel5@@ogSH}rCmnq_V=_&Zx<!(0WcqEHX^c#{
z=O>I_`VVr}Un9k^=)>b%#rc`Pr6D!se2|f9-X&6=t5!Sl0V+;$Re8Au!aFETzne2n
z1q6BMfq<&}ER4R)ZVCjQ;XDJuYnIQ|XiLM!s=<NSXjI8aaSwzABn=V}Hw?+r<Lbm^
zyhBWcm<buKXKLs!d^J#p35DhAJ)z=Wqh#%@J@@>}oK;m&>Q)TOve#(n?B#LBVFS_f
zq})=lXaLeyI0b+YnDZGx;5H0m^!<lNz|)~Ce@eM>!jH6565`;nIu&G8J%MDbwE?WP
z!nHFz%Y)7hjmZ=9Z?aCnKspZtE&u@Il~OYRU~`TD6x2KbTL>D`7is52yBL9$RG?P1
zuhZSR?v&1yWA@B?AZ4a;%7$*-eu~eFzPECEcejKhu@W!ubDh;dS9jf;izoCY3qfUr
zwI|?#@o%(g2>^&Z(zv?-0dRns$y^2^oX7UprlYNyt*V))9(mfa{dljo+^4>b*OXX|
z^-~H@cIZe6LVduVdQ)8@Ed~uO2`vPLiE@xn8Um#uO6CpXV+TU(4FDzDrvVM|0i<|W
zF}-qIJPpO<QNTu3b`H|{%7bLC`BgK7TE?NTMtuaU(~`--bwbe+4V#|j)%r(QB!806
zJUqF{&vo*$(0UtaEDM~~f)kau#urzOI5bAT!Ig+u5PzWxp?UV+uLSD~o28u@493_?
zb2|0$GINQ$4GUZFZiD{Ix^e{fc1=g}U9#@5y%oI37VQlbHcz+Lm+b>x1vX|r=Lan?
zWrk@FJ8A{nnrR1hN4_FCgod}IN~(tGYwSL$D&)Ym$2NgSYVIj2!2$o`xy@=GP%-7j
zh5SYn%dfUJn+R6>EKZcx#<iW)BT_2cu6h;hK+KS6YK)a4U+LZ1$!6{gJ%|Z9kCg@z
zs>ib#Q}#owtZNV&s)&e&)QlB_KmssY0AFq7Dlh;GkuRPVhCz^b)q3{DRlE8|=TZPo
zjln9~$nKn}%npe<b2XWJ8ZP|M7cd0a_xpQgtXuXNRx^(r^J=+s&nhs8!>#$-SGGq<
zu<N&-K6Y<OGraxsjC~fz0>A1#U)^I;K$nc~9=wgq=WVCWvmDju>KJc|-e=?i-{q}+
zD1<_NO-EnM4Z4oGmrXaq7nYJB{SdgV+kM*b*87Z9)u;in_|j{tqqK=<k`sA1E&ZWL
z|E3C@PC)<Zx3@Jlm&iCN2pa~g1|{E0a65$DD~I%Bq7E;J%&pfGB`oAKDU_kmCe1Ev
znk{hQ4)Nf&#7DOGtY3_EqX03e7*68ZK2djep{Iq1cYfQf;l=FcsYUAbvP8TX`uN)7
zk_v9<!Y9&_-fxk=_Dk?QQ@BM9zJAc8)r5-}eT6T8BxFn=<eiAttS5^$siQ<CzC?yy
zFPNBL^C0(!DlsnvStBSp!6iy@i30bKnjy$unG*!rZ^h`7?{F$+RX-479*@cU1aaoG
zboEn`F<Ow=6QYH7q)^h<Vi8oBqbYf_dnY=Ak5$iU?$-OQV>w&Yf31F3RhW|d`J?28
zOzzY-EKi?fMX2~3`M`a~8tFH7<c#~A1xQEkiqw<oem)*k5a@Y3UvX+!<)9EyjZX1*
zKfk%WgidREzWAC`FA?80v<n~M40{{rYwr`?D)ta-|IE3jiRYNkaF<+)SVf`3SP!Tu
z^3QsQCpT(Ao*sF)q_u2aDeoppUgCc(B$-oQUnYM=QNn}vzEN2bN+Edz`?DoS?~~6?
z)I$DI?U6e#WrZ9WpFgHu{G?+!U4%B%l^5H^+;}njpw;86sSD~d8ujY)tcJ06ZBaVL
zD%g@bPZfs8;m#i{9<Cag7>hpGEEckig`$ut6x{4$CjmxTEYLz!c|rS`yQlM!OkS!6
z&%Jn77(OTL^6+ElHr=L9^SGs%!Je4&hbPIXnYpF!3rD7|?A`3b#orbzN1Mn|MoHBK
zmy|%Rmwkyt3vhW@Gbf`MDjIzZ!x#Q^IY75krD!(x6H2z!YaMT9+bAa~H<O2X`hsM2
zLiypZ+x;)=@h8I%w*4*r+qaAuDvnv3xXl@iOCOCe?(vd)@56m<<i$@)Z**Fm{)#=3
z`c6H2kxN`fI2Kgjq67Krq-iR?oSmRw7p#~A%V#d^4VjeFs3PF4f$)s}G34Bb5ATDf
z$8(PcX1mfGz4Q_2nMqDZrn;&)5S|kdlr`|g*g#FK+acCq?3i4=IB9vobR1n%W<b;9
z;@4dypuMA^2#qBtIi=g<VkT8cOp4enI_6HktG#D?CJ;W&F*G%qNm_5F@24HDi^7}Z
zgFhze5ekM!6}pX)Mik{Hq~|u&@q})LTM9kQHQ;M7Mg2=v;hOrcV=8A2_VLb!zC@ZH
z6}aK5mn<484X0OL7p@}E3^3h_`V5PYwnVo}%3LTuASMZ;mYd_%^z5l?_k+hu&BFTb
zR8IHSorKz%L&SY3e=xBO{j}C_cyzRl(~ggn6I)NHko&zKqF;5Zn`J_r^c8yZFwB=s
znoH=;_N{k^A#fCaNH{UzT!QgEPI-tE8MAXR9UH8IK|J<)LO}R(a=5-zUL8W4{K;yL
zoLZBr9GMcpTca+BfUzf>qgp}MFEu}*)km1lIMv5^2`;0Ce`;wbZ+u*0)9?M@DS6da
ziCz^2)#-|G#o@8N@|2gg^0fAptaG?I32}D?yUmhaw^b(y@lyqsD~aVHo(BEUZ^i=G
z-$0`d=?p#@8+fu-dM4{jdA^t-EY5a<<Y$+`&qb60hX94l1W+M{UNzD8FIMnEwmW<`
zfI>g3?d=X5U1J@mfoh>gdfGr?3Wv7)4k*m^w$YcgyNw*4$~V*)k)dyrF@Af1FvkaL
zXdj}n>MO(=qk^{%xe%e~v%yV$em;1(tjBFtFwY{3s3KnlfmoHTB5mh|<r*JAALGQJ
z(S)5l4wy!74A#exsfc+F)lLt$v-?`g`gA@qOO4Q;MaFd{_{^V`N7_E!df5<%P3E+x
z-^?5LIc&ee)63r`X}?C0i3l2Fk(>wA*Cxa3u@IbH<d&FCq)K-fp|O-64k6f-EE&f0
zylyIN%^b5%3U*530rtHF)aor!yJy^pWkfH0MWn831W>Z9TLnZcjP1#j%N|pQpwTVS
ziJS|JT;-W#!qsuaXBZUf0%J@tcbEtK7&%X{mp9-T1sFw=srhn=xbWsUgr?rr*G*J+
zJ+ICq8#Le0)HC6H9aLuSiDbt->LD0Lo=r*A!P%Y#yXy~S<iAzV#}W5-{uG`KacP9B
z@vWLk$3ZzCulNg$e(k{5)*b#a&`BE!P2|@8;gaes@SC4Z4pV3!%suvrG8s92OAuXV
zw4nNmo}u&IusgGcLv+Lt8q~CrDh+GhE;ojAhI+g@3?iYWiZC}_T=j&vS8&MUo+`tX
z0dY_4q>ogvVAYW$KBTp12+n&<<d2Xq4`)xsvZKA2lm$7?YWg%8@nUS%@kvwWrPSWr
zGWC9b|MoM-To7RzZCa5C8afIn4`QmWbV+C5Q}>4#;QY@G@*kGtLj_WBe`8Z(W&F@~
z{zWu2Ys?PTq5VKFC?c$8dU-#66kE~rTzA2m0!xI;e_r;PzLk1hcqj7X3FC0wl}PS%
zm;62UruR`239S1~AbJoCzO1m1OPA_f4W}}{Olw?J74}y?k>3517c&|gXUV|zFumJZ
z_}$U7lIDlcdE<*<VTOf*3z~M?3L@~a8Rbd#FYD-Km#`63m)f6)bFHJbzt{oaGy!+^
zcV>DyF>3zA*>jv@|3dW(e2D&wCs2;>@-q30r$ze_20wn_%TV0-wxZ~pfqPPKfwjl{
zNa?KjDx3l@1`|?gd+eMRS3Wf)2K$k7?Pdw@n~bp#+(Rrk^$V!{N4s7xx<Ji6u>3@t
z93hkt&y0gNG3f_)eLq0vFN+AdiAHUp@S?DNtd>Z9)s-!H2+b79fdpwkWz|1=$g+s7
z=Lm4FU|y3|0>h2FOz+Y{;n?LJ+khC+03K#5B&lCoP&I#+wAH5M<Ky8P0U^iw^5o-@
z^oQ$h&A6wX*iqgwBVa#*L3yArhLqSJg0P(1Yk!m!Ss-YTcePZU5NBFfJ!51sBzF-g
zzKV#w+GQ76kWj9;RfiF9QT<LTwO;Dzsy_gJh+IUHOK*TV%xlZ4x{>XX);nR!@=v^%
zgL;ny(*`YTtm=CGcfM9MuNXY$bUxZRQf3fQ<+0x4Cz_<9aTwD9y&6!RAjGdk%U>e3
z!7|1p1AE9NTMA2Z>X2crMo8O0@BZo2uqmh}+vv6)B6>H=Qq3E@d6`G98%U808<MMI
zj>lLsRy{2R!zBIcX3N$|2((bsfL1;gNMBtc`9~`L7~ceO(JSh9u<AbUf>drT(pD}Y
z4d5R;@;j~vJF8mMu!rSDzf?0+8N?cWcG8=j{HamY-8I`jMPAIY1-+<DFNZ^w6|Mw-
zm|We^o_jTE(J2D+tu<_$(gsBk1tyjEuqJ1N6hbc))9|;7u@YKuR(joa`*Aj|7c7W-
zEO1ak{5gw?VxuBa5U$%xHCN-$OVXj;C&3~hoAR!p)e!^f9<^Tq6YH#6S@d;j-Ubk!
zeSKb5hfMmW*|3=Yl;c$u>C+NtUi!$=!UPGqz1PuMvpU0TOsKk2{4{h%=R}_0AmL5>
z$!9OLQ*@D15|?0T@D<b>r1tE^=Dc{Nrc;rRLEw6L6XRg%dSq+gh=+OT)B0j9EGelj
z2gNN~OnwmRrAzP@t%)y{fCme-oY;YgDIzlWfD!;3CarFr6x3Z`ueYeG>3Xn$`@Hgz
z=LI0YH#YiwD{NfI?h7Ujl-E%*L;_-J5uOGg?W~`fRRF>wE*(rJhHKv5v!P|1^F}U}
zbYHFp6C7Y26BpSmY0Xg=dqIMJ)hzKUqR=zg1Uw~-#--Jg;$;ap!4G1rsmgMxXAUL~
zQYtEqBcjmH#>%e$RRsS|25bZX4FK>-2Z@3A09?+^#EwR7HG!!B8UTP%M5J+^!bAwC
zGw-8$W?vd_SW5If1WFAlwejJZz=Flhu?%2K`7)ly>v21(gEhbh;yOXYz>&;D6vsZ-
z%G7jkOolgZdknpW0eA|J<~Aw&Yz@E`iKIu_Yw@KF)_FK4Q^L2%r&?ar7Lec_^wq&v
z$jDUhTAOVSkJ7_Vn7I(B^P4gj7k}A0v?*Jk(ovmpuh)EpQ&O>MPP^zvXilA0M054&
z@gU8|IC@PLuoXh5XZTA_pNh5Q7oM}~KYNA?lL}e5As@n41U*Ki_CSS$1;LpJgom%s
zNiOA+Eb#5(stw%k96dVXX;55i$bOH}ljcmK)`_o0^@omM@LbwqJFJ)srzOPk%$dyQ
za2MS_wUI0`7WjE<%nK357caqjyo|tpFhlt4qC82+5h&IFQFr<h9j6fq>z!X3r<L2g
zhWOs(@QmE22o9<lK%@ccfO412=wXpA0W*;`hz{Jy*ivOy^{vyYev3VUF9f(-D=<wb
zPh-pH<eD5``O!Q%b2mArMpr%NnfkPwso*e{tVY1_kh-BhpsF)Y@iEcWXU1lk4WEZx
zML}3dnh_~pRRu2`C`n1}b)cp)--oEH^F}9Wc~s2nR>-~^XB(^0jw|9}G}I;-J!=Vj
zJqEkBF|Y1JFznYMh`O^J@_r5@%R=Iy=t;v?HqDgV<?bpy`c&Kj(s6lBpcc_nS-b<~
z$&)f6&!$E^lHNC9r3zCxJ;msoZb=OnEil<`!XXsIV`<?}(>n~;wzJ0O3s(;4oAGMh
zztEo;!|q*-ja#eL8G$qf1Rbtb7MbNQR|`s#Aq1r<*FhtD!>G}mHO_<k<(PCQQ0E(R
z^-Z#?&wk;s0cuMmz+QN)hGycQGnDl3Cn&jjy8<m^wht2ex(;8(e-Ilb+YQYUw+TOC
ziYZP@(>(bmcOjA*465Tl3ZL1<01_5IS)wR)nuQ<$%i^iDATzYrJ>9OyUM8TW(UB-u
z?5`l!>H>h{Sj{LW+zD+N<8KCLYtgdhnF0-2;F?92XbG?8ULNwR!Dkpsp0OHteloGm
z=6%2-I%!6oDVZ3g@6As@p+q@@yM=D(;qy_cBB@#QM20e`#}yXwVMgv?!ROMJ$6bR>
z9V+oJELlepgL?U!H!~cctUf0&qFhHJZ%P0;Z0qskCvxmtZ^Wx_F0L>Zeo<QBmIMYC
zQ)B%8`XB9=+Gs9ey~>q!ZOB5&NuCD8s&p+ouk*dav|C-G8zq0`>m>E<L28A*l5{sS
zCnv5XUBDi(TNW#sis2(kDlQ@c`?a;BXpF5fY<%dlz8*tcAt@ZUP|#p4gRK$!%G_$>
zQ6PG3U#f(jtoA^pB)|^_P)rC5@D#ZIGO87TnZZ>Ka7hLbUOR@Po44E!K#*m~IJ)Y+
zOxP923V}=oJa4H#NL4?7ADDG6X_!)~UiADCYKbTm0p<pN>*njZV%Mo&*TP<hLu%hb
zPDWVT*R61X57cLrl^6>(gwcvY!9*O4{sWSi&A$A`5#I29xqJQ6^D-#(tZRa=p+!n!
z{)#4nF|z)AjSV^k2BlILn{5e+R-wDLm=YuL(?{eK4|tb44&b2GN9&PZGd;yiU%<j;
zz~OZ?3F0Q2bk-Ui1O4?qt&uMXR6ECKv5!9Ft>soUJpEO=nmJ=7)0-tTH6;_3ja!or
z{S#Y9&V8SayCcf%Dx3#^-*!u^s-EpeCT%CGJ*45^HSB}XYy+{e1&s$M^a0pi|EPwl
zqmUKQB))yx>{5H&G=(=-Sn}K%kIY5A#%fB3M>W}0Q)LW0Q$&{ZN;^;vg-Fp?(OcyI
z0ark%zZSj%6cTVa@Hq|~zySdcoWqCt7@rLPBmI*V8Il5N7_ua>lW55di$@ca3GNh<
z<wbwA6<1Rv<}P_uOQkT`>Zc}9R$v$dRm5szKF2&`C)f|xAT}H8(lV)vDVEZkqoz|L
z(ivRGV%%7EcI-?*#IPB&C9#{u%_mL$_(zdS^ZrE>oh;q(vW|m)eeak2h>4ccGUPI|
zs`!k#$tt}3%$%8kOxA{DjqXitm^<eZIMkWxBi4jsqgM?LoDr{OMRs1EW+^-kC2QZY
zrBWztcjsP{{G6HD>8zP+hPgAYTmiNa?Iq(Q)65kk9WZ5CQW#3sqnhyu-025`t}*CP
zyYZVk9kK(FYaX(yRjse6E)$F2vfY2}GAznjX!qRz)DRZlx-GCAQ^qr`8D6@sl?DEI
z%BN24x8ice67z*w6<YnOi_qI8o}VcvTP5z+GHaHxT2kvv*3;ws=BOlv;hk&hZlj#g
z?8g@Qduj*I7?UQvV#}L~&)4p|)#^UYRy*qjy~uuHvo1wjJ)7E2K(~tK4zm)|v2d|i
z*nF(C$ouse8%xC2$BGLG-4be!O}5Cl6n^`@-)MUT>}!<GcbQvWV~9S^XW1TRov(TC
z`?^>~$F(Ze7OJd=@U=TGz#iC7d0tCxYX}|@c@;XZ%1VUzD_FMUqWC5Rg4HL(5{lz#
z@cOk?8RN&lFP~)a%273(-baQWyS6$Rc1s-RiS_8NTOG=&wwviFt6}1CFvU4Cq|n1#
z=4DPEnUj{v()#3a+^m<xo7TsktH)1c4qWwEkfqsL+KHI-<#tauY7eGl`7Ox8iE>T4
zeZmcLn7d}Yz(<f@q&z2N7^NXGuDRa;T81NQSb;=pRHw76cG1!&@giI~vokycAX|k&
zkvROlbxjq*vjF$nu_I)dQ}XVAgs*`pda4GyW@_`~3gQ*`FPM3bNDflg(_1QR=^O~h
z8bh+_+e9V^QZ4W9WEp_PgRIRJ%0tz(zOZ?DrGR6!BFb_wr&)}do6v1n0T;a;cpb|%
zPc)1=n7=;!(=+%3o4vg%pBfI5Yg!HMh-(4$<<oy!7IZC|7X2E8d|Jo7_iA#7vXedS
ze`F!lqAOjAQ<l%$m7Z!p292limhu;2S{#Wi`kX{<DZQZGMU|=Y5*Pf^DQdQ8bC{b@
z+}ttycoBCw^VLCi-@lO~<~!hJ7Ehb|T=+&{u`@pG>vt7LhMrmmxFHS?3hTTfn++U4
z<U_e+F6db9e{ao|^x8_C(?q(Ni8od$l{dT<BEx`IzAl1Sh%QP2)u)lJ$8S5hWM+~w
zZ?cGE<n3i8Tsy1AW6Bx5J2+or*+0JHB7K4#4B=ZX{W8PwLYiEv+&b4$S5&7IJugnZ
zSWnBfi&(25_+D)T_I-z^-xb(B;MXtVJP>Bf*9TF%4=%hto~p#TRQV;d`IO9EK1L3m
z{J<<KU3Na5HBBy3m#q`Hp|cN4YIdznbq%GFz`J5g{*!9in`P|gKIRFU7P&#XHii|5
zl-gtSwwR;!Z4$H;b<QuF*-`$!P?T+9RmQtraPRC`^@gTCa4(P4nfUk_1a!IP@V0&L
zWl1GQFLNz(^YP84&)UNoGQoG_nv0)jGl5wS8b|fVTND<%wLLNik5L8B-xCwlU9dBc
z5^-6(-lYWouw(W+nHH5~h2W;Zq9I*p82;TGY6MLiNVEb~ITQLMLAlzS{ONm<E!q-!
zy}zT}U4&`JeTgKHV}JG-y(I5|WKHkTmA>0+B}r!*FCKnw051q(4<R4XWppGxxhV+t
zAl>=T&yq084fLbX5#al*=aj15sPO*1M%|Xvor8?;swt$avlw^{#mX1Yq6M2*6@Dt#
z=h51|W}clgxU?92u_KeiMArOK;F#?>waDM<9;u#`C|!FH+`f-84_z)*aRi-O>gQ_y
zFRYjXEP`*I%?QtmdfKpQpN^{n&N~*|ZDGUp5@0m7cx|6sYB|&N?=*%1X<*4N?b0FX
zRCNNw^oI6y^uQouha~he?O)V~8KLB7y9$N?A$JWgP9SC}XoOi;O}U%Y!l_o@29i&Q
z6}XwOip+{^hxAu?-`~P}&5-u~GsX<_U4=^eJsOePqX!bUNjFCKUf+;s8;#ICyunE;
za9e{d8fwPBf8G0|Lp0D9vFoSP6QDqkJd?ln2J{Ns2>SgfYF6!Sfs4n8kjjQ?-e?&#
zJ#1P}N|Pn)nt>q+Pn`gOsO9*T?2!HPAgJqvj2S}|g2?Mosc&m@l{A)o-`Y)lHeoS0
ziZrArO(K^cS?lt$kf*)rYm0ToAq+or=z7axIwvDIY@ja9#I2hT(i^#k<)NgH?!e^J
zkgMb8HMi%Io`W8souPy(2hQ7Co5r|FkA!YT+5aUmvzBY*eiK@A5qJYeJ8@acW{&R~
zmp|>%!EOiR9-|?S1_u)uFASLNQ{ig!y5IL2&+1|L%|XwUP(k3hJE-0v5$F4<I$IkT
zaD}XPA+e;lM2uw`(@CVk43dSdw=pY>4VP!(aAVEC<hkzD2?2<?E17Hr4y3GcX{8T#
z6H}tG^fEvctKM<vnY<KVZ}53?#?Y&~B)dY>l4(O-aMO1M@Q<0kGD&`YjPFN+YRcak
zJ*+6+{b6PL&nUI!*Mqjena*M_G<VIvMA0<|!8%jJ1;)OPEpZKaLPO_h2~TM{-BH4I
zfYX!acTO)_1_gbqpT=DuDy_ff7(PsLww^u_bIZ!nsReGR0H=_G>32<74x5IN3YdLm
za9tIT;Bi#BbCqFTN4=p!Vn<}y3=Gs^?H30>lwvcXNM6@xJEbJKsj0o?EMx>I9ilif
z%IFykN<2*nHPk>L+Z}Prmpl22a$=17I%AUkA0BQHlE}t+*f+VekYDNBe#rU+d4lHv
zkhhcV?i;v*DHGVxJv(vy0R#)`@v0|PXPN-6MS~!?tgMaT1+gTUu!U_yV}tL#FArw0
z_3aPVw5s|(=x}aIRjC$rD3!#E%^20u0bqV5Y7Nxl&H1xby~HvdI_a@?SebKtifvcP
zerl5SjqZrJgFreo#tiJxp153Hr~~3V=FFImkIcXGJFM;xIy~_ayx_>jKJ`~Na|Uw|
z2o(dd6ZSC|!oAib1hIi$k8a_5+F-)TcUUk66^=AgIZkQ1H9rSg?aASYGkbP)vNo?L
z2L=75+t{2))Zj)Vy(l4cgGk7XVY`#x1^jq~StjN>pVZ~hGK(*B@Bu&b1EC2CtDAo=
z-YV4~%_25?IHq-4h`aUpswqeOiG#hXbniaaxjDDjk-;betlThW1v3(E-n?Q3n79=N
zfL95tbmERnp?3Rf&CN%D9F#{iauErzym}VC&agD_(1~g!i!#G+F@6PGt8~NWI;$m<
zz2PxK$nF<@Rp}hq*1}+@@4uwTk|0D^NJY^TFci^xn!}_(qbZy9priKar5njuBt!rJ
zy8+Dz2z|m(NITDC8}Z%a`P7_`yk$b7JYS@2tRP(1PY#pAdqa7{pHL9wT;2Jv9)Z!}
z!2Ii@T7r<R1mSbjPI3wtgirvfU;_XEgdUZ*fkX@V&fBmbop2yX*g&v)C_iAx;Z5z)
zA=EnSC|h4qfZl+KF0M*z+<BT!FDl&aWB~1c_L$!=SaP62R~(J$1pwH+3K~S$ekf*n
zNQT4a06OOnR+<h3Z-EGShczK^1ClfDPi`56{J{ZqL0BA=&>N-!PGiM^u@2x{Z|jh!
ziV9DJ{H~$9>cOQHc;AURg_rym0sjTF9UibtXVcUgButGt)K267*GoRtm@!YZm9>Kv
z5GqRQGL}vR)(h(=<&2U(5HSTf9ri?sfeydHjs)>w7e7ZNy_CynV3bUv8AJep%>gw2
z2zF2@zj+AS^`J{ipyEFmkAlC25cNU-L&gIa000mN007`S000000002Wm<BWe0YCr%
zI{^EjfMkRR8~^~|pa2X20AK(B006;5iUeB;x`Wmx;-4kaOL_g&V+KL3>ZD!~z9bmK
zgt%9jm_FZ0XteP+xEQ*`GK9lHI_(U>Z=ith9S4+_sBIWC<X#3v4!-7vhJ9w-K!OkV
zVBE1mNkZYlkQQ8Qla!m(p{oLGUV!ZyygWh~4t%<?&ObztP*`By#5)ShnS>42Xbxg!
zWw|8$sIBFgZlSb}dV?i8XUvdW#buw1Xzr~F8ll>5HuMy<GhbBeM3B?LsfZi`-hlYB
zE*dE{0MR__TCmc8g6x~89_q?FWXRY$#DH}Xb&4O6_OY8`(+{miF<O6p*4WWiPtSr^
z-kgu)v^}G&h*|P;X3rYB%Cc{;QInJ0_IJNYqAm{*GHjRgp^ay^pCJV_Q@6i_wsyIl
zYFl`$gWJLW3YW_D{(x5;<NSv#KO-rfC(J2scMYSI<8Xw9$Q>jSTnqSZnE!$_Bq%Xd
zz2Q`-gCeAL-V}sBm+g(Et)Uc`!<F<L3YDeP>($t5=~6h2B;q7_-%^ZCR=CYq`-x70
z*^}|ojXCs*U{B_ap#PS+>_+mxM2mjyccCV!8d85?-to<+wft*G(Z5|}o(ar#2sNgY
zyvAT&HQ1x*MPLL<10xRlmT$$Rfl57W0k+4Uk%RdSW$(<8U^2&)!h(f=r=9i%>|G*n
z9qqr5m7l${b9AKJ<QFm-M^-IM%8o#efyoZWou1HEZvcE*qoAM<+rN`)FsvkNJwcTq
zwk=sI%=njdY62?{Hjbx=EIh!b0Y45uRmcntFAM+{VC$M|!O&61X8#cXD3tmqGd$?c
zF%=)^K(CHRqkgp0SmVWx{SDZJAe685DH23a!TjrOQRPqvJpdx{VX}iL$AWq4IteQl
zBUFXReA;A<g9?K{M^Q4f#f*&zlVVz5<$?eJ69c-g1$6++r%O<I#9TYQkm}gnkbP&V
zue~Jz;N;I!^FPlkQ9q+u_}U?<qB(#w005N0|0n;72pA7Ur!Cn?5Mn-juo#VRT}F+8
z-Vk3#4*s%rGi+whX_Bj-eAT;g?V%uU(1`pj8<8H~WVF|j7L>Lbq|J>oI2fbJgp9y$
zM`A~qC1{Ib{u@mUfd>F1!^4kf1{fV0OwNI7)rI9g__EmF`(SH@Gm3tdte}8N*5S#g
z7^{QP=Mlic&z53D@xforIEkI8B8!W@n9UDsO4GVw#IzSl<45%(U5Bt&p5?^Yw}}wA
zDRZ{!Q<w^vIb37W@`>F=@X8%zn&<v2X`la^DbILP;@6(<P0|=t0wc7GR<^$DjO~(U
zhmm5X7=&}kp|g}d)c;6Kn#FiNif9z;LPDfbqOe>=QQis(-Hb@<+E;hnZcueXCo5yN
zRq8)V-X@c~R$(^lDmQ*k)P#Mh08zpI44TO6W|Tjc@bL}1s*T~i?bS$oK%BEdxb^}>
zKcfsk;4xIduS>~>*3Ff~FszPklu|#CND_)o6*>E&Hfb4=sVcH$WxJicKH*o)1MJoA
z(jt9PMJ$(`Hk_(=Nc9jg$Trft>{j-4EJ)_ik97D3kOnI8VI4y4ikSdn7$Ud7Rf>ri
ztfJR|N44KTD~3u+3H{zlCKhoNsbZe+--p|Yo(weMFeRP*cUBV%SXrbkLo&Lw*w_V+
z<jW&H(D_k!gnH|a-)ckp&?WdO+AjO);V1sbYRDnI{g0f3ulzA+Sb}1dn%8^;3>M|6
zpxuWN%iqurQM1Qf-7lR^1gpyG8ffY2b$#A~ub8($t7*WcW}+&|mvA@xLDjKZXt^sl
zO?hR!6G>z4*<SOF>lc3{dQ<Y59tKI<J@CmyFBR;{Ghv!~B9h`LP5Bx5HWk4Eox~uO
zP->oDXbqpkOUaOtQ47{UI~S3-4QW(eujpBg7*qqdK~=t@fAOht7nA_B697m-833H1
z3IG6L0NQv4DgYNK04UZp000mW0ssI2G$UX&004b(yW91;rQ>zH7N^zHVfxsKy_<Er
z9O~EJ`yXs~cDrrot-9A#-rH~cZ+h>0eZ9T+YPU47EM+j3*hUeEW{QO|0|Wt~K@eJc
z<*_y(Bmlr4YE=-3AQpcNm;eC)8JV!60{~F~rzVZE*(Jp!5=GBQSn){`H0s3KPZL{8
z0e9UTqmWI#_d;%M+wN{w2Hb4-J6$%m)V?_!Ms00+a!T9UDSmli*A}gOe6%XAR=!Tb
z9YsMoGP%P6D3D0p9I|PWKsW#ZW(3S=3;^d1`JQg?+wNVvnJu=q5M8&L?q0jw?RVF%
zEn5`Ux9<ISy0-q@q>@S(Q8JK#Ig&^SVkt2)QGf^t5{*I;0VId{5#a~;AL2of=?8#4
zeSelr1Oq$&B?}V;j}danNe@Vc0rk&7EQR`n6l9JI`ox8fISPg_dP<~#DoSBwVyQWw
zh9;{^LWh(<DLGZBk}E@raw2RJ&@)D7<_riqQHSLrv}e%@tP+*ZJM|U-e;yh@DO6sA
zC8<V~{1XR^bYnkf*1dc-35D47x*&x>WDNSsU|bTF+8NNvq5}^elRTwTX`PMHVTdHk
zdz|d+X;g&Fb~GtDRn;miNLgRlmAE*5`urz(`$C&vChH}UjgkvtktxW<ruwE%M1=9l
zsG^Gm*DjUi1T+ItV2%@7NY<X$D2ZiECpyd%2u(A<$*LovjjYo^#*zd}d3nO6N)|}P
z@^h+mM2IuNqpTM&hT|MQYbQ$CMX(BqqsmgSP^TWS7e&u_kVIiC9J_&qb|VP!RLO~m
zs*uVd!RdOHg`lilRsE;Ml1$ojLbaU`@pQJ7P_qfL_p(7AR12g~$x}^9cy(!8LAjO%
zD-aZmugVn=k+pUC757z_p2<;I^p!uE8WLg7PY{FBM<-CxQG_0^{g9S+l4ua8>PkI=
zXa4!G@gkR|7iXK!iEfXXm7x%x)nd!-_4<UbEj}ZASwkdf3PV(=K*gGo#J3~~w5+V<
z&LXvty*R(LQh>jkvnMQo(1m1hPlqyURcBTQbrXb$Rm*E_RSbHve$x8Hc1dK64AxdG
z5+~@w#BdUzMuC+buoF7^+v&dqk+@oEGGFS{_ya?KpY(kCH6`#W$HYBGPE@+sDsDO&
zB?vM#Kun^1bak(%vxVo39TCzl(=&NPq_7#!)HKG<>e!b$TTf1qOPY)kyIQtkiC3Il
zsMHhES@H)uryGnO;OapY<8F0hW2n%GwVu;Xk}Qg28<D^5BqCc^Cjs~~b$n{P+7ys<
z&qo!7dZ=DxKW^*fpOLWtu0$=RQM~{!yVl{<b(XJIYO4Frk6e*j`FdhvVWS6fOEdaE
zEMIn!I{YGj=oN#b#lii;9o<BCFBo(pJ3(2Jo7;qJewN?(pHK&)iO2^UQcbsoZ?4z4
zMs4D!@On&32Sn=9`&|DTeq74EK{<oW!X!$TC3TLrW2X<S567>ppLZQj8BOQ(E0d$r
zR&*WvCS`{);FiUY-3NtnY8%hTGdc98DXLD(F}*CC^wy#6El<G!VIx9=6xVLYKb2uN
z%X4}0^$_sMoX<2Jm5qy$V3i@FvQC$^>B~#s07RuolH^bICR7SrQk_<$^js*X;hw0m
z&3toUHC)Kg+6y+Q>5r@v6LK2Oib}<X8r9@s)@AQw`92%((cYcayo8^<en1QB8ZrAp
z3o&i1FfN(}zNl1O#`LmkqXOs;9%|Heu<(EIQ0YA-8#n%n?A2xkw;we<kX$!Af$HK`
zxHJcg1e4Q1M|w(@wCFS4?80;1tQkK!rN{~DUBy{9P+GB`q@ntQ3m9`H^!!)(j<F5q
zd0L~mHLH?^x{_4@c>F3nDsfY<yl0VV9B|r++n9|~->gNSlhP7ECJRclRMnORl>oAe
z)tAnxxuMiycRCV~WHiI7P(Cfj{SmYk7sDeC=eDY{|H;?Bg(N5|?t<+cW6u}<mENlT
zO8wfnxv;r%JrNq<s#^_cjiYoWM6^Dt8X-+YT`oFch9n0?UW@Xrqb|jC_>Hd1t!00z
zZ|oQ=aF)3g#&;za=IJjT{B%vzg4dqN#+TyhtvO=i4VAwy&y}2s8{(yCk`}?ROMW0P
z@cH?ZBhfd~)Fc~zrBAA#8(Yl%wXSTq?IWVfU9OQ1ZUHoHGSY73+>#y;pPYj)XnPJD
zjrWQ)Kj5|zCh!!hAprcSe>OY;qG`}AI@y{)X%&#I7=jIPCuW3zV6|g>{}cLXgLI;$
z_HR0YHCNNbW*tlPiPll*RBAM41gsyZTPPqq;3P}^08SfWAq*Afoea(wGBem=@P`S^
z&brVMB2*KI_X7)yZ)DH*ogzdk;Ie>*<D9LlMmyb$Yqlv?(PHcTHl`HfyHf9*4S`s3
zCEBq70b0A%HQ2tK0xl)e&c*<ZzA-pH_u#k*l6;vx)!PWpuC@TH{?<>o209q)!y+!@
zl5Z%1LycpA9zRVL9YL)tb|(ZI_Op>J(o6Yg^)3b8_5C}%tKAR&0pdf-VqO)XcO>oX
zsetukIqivRnSoJMvKjUV1T3wsW62jI9og_$-zWqeF0;l*YT;JT02sTRer3}#TzSWI
zK|#aBrxH3RVgQf8;h(^_L}fRM=VlpN$HihLUf-}XIOp>#?sLw7$v<fm1YHC8KrJU5
zJEsP12f2g531FVUj-QTVu39j2tqDXm)Nd=S8jo9miXEDiiJRNd1OHAoQcdy!pO6GZ
z{G1ayjinp`ikTTU+<owveO#qW;i%a<@Jf{D%(ePDheDnruuafflcFReOmmYP+yC0q
zfh1>m*Nq~9O&0id1g4gLCHu{J-cz4vZxjxXaxs2Uu`j6TTT#(ypN;VDmG7RAq~vT9
zdk*4?>sakGUR}Y~tmHFDhQ(h*s{$L}j?g=2nk0=PbYUC#1wZlee-q3qYwOBBC~=qs
zRhk~N_&7w7u#<$gIwK;twpvAh`|+Qg^0Wu9hTTb&Y>*D8^yml^FcYH1yDc&Jz<Sd?
zFDd}CV{;)eM7dGtL^qpvTW;ve?OjH-wyp%c39@MUx_gRrhv8Oe&Mj2-h}&KV<}Nun
z>GWF@E?1g_>i?As1M(v}E{BwK)NZu^v&GP}axG4~>mgZ|#qXOY!DLf>o}y%TI*mvj
zs;;gR<CIfxFby%Ut8F?daSzLU%$vF~o5!6u`#w=>lp(SYGllv|ZTNC_vr!2*Msvoy
zomLUsPRh0B*t?HF)3oEs!@}L@a=Hf0($2?Qml?oi&X(y!?c^m2#5@lkjGLKP8vl>+
ziGyA=vs>Ed`{MhqXWR5$(2`k@t(>Zy@`6&1aP4~6kY`DS?Wk`etBTCco!%!+(@L_2
z;dA$~u$y)vvlrgmycfH2n-+p*9Pb$o@oK6-FI^rxt*)(ySZ|Tk3YY3k6Ipw*tzicf
z1NJsxDr_~`{_j`13boWQCqf|wum>_|OT&+#=haCj?hX-Jb>n+w;+RSyG$+LqV6lXc
zW77o3+rMCNeiFIOvDcK>LTB$~+^I4L8`9>-{O}rpn%L{%XZZ30y8uze6D)jEH;}8)
zNWS?ZaR3KU0WG@Xbl4NzAAL{6V~0b6kV84-Lk^hl$Xd(z=N5>CFqc8Lt@;61X20zA
z24)yh<=Z!9z_bjuZ&9Txm+IA*`kw*=K2UvtxBWL>*wvAE-^>B$#}Q(}<sv==s3xKS
zouMEv$``S>y!;xJ6an>zjQ9w6Kc?kx1%acIvUYc%Hi`g-Aw_Zh@$*oG#Si#nM9Z!5
z)u`(o1`{|D)DL-?02R?htoVb!op^hB`9bWH0F48Rn)0xp6#>LYFx9AlaayNX`2yTr
zCd+3^MZo#-<97o14=dA(D%e~TInzfFZz4RAgc{Y$6UU3RO;{|nA_DjiE?LQjP_)34
zI!)gs*N=Q8ak?8his_vWgBuMUD%pU=Rh~^PoSi?}?(%z%3Fw`gNZ0p&sw$o5ojzhF
zl-q`;YlvyAtK>hUfs`wXMzm>luSyVC5=nJkQuYy9&w~*IJIz<lRAai2SJ70fajp^J
z2N23%O2xEiU9tlYS)zP_$4iS^Tsdtt4H0Y7bxTj}F&ltrnxVOz{K`Au{;h;vwQH+F
z=D+slV8IiOs9wvb--b>_|D1v!%3NtVAy1Ol=q6ZJGg0@pup$^2y>3pxN!&%<gL`QA
zIL{1j^L1ImqGAECT2D>HM!S@Av^%pyuXkW)HvvT4vRzFm2T4iPT{07haIG2e)}F`r
z^!q&hKXsUw)GLc)LS8|!zRn$o2(yv1n65m3v|O~zemXsWBR3N~Ao=r+3;+*GO!a4)
z-n-mx$Zpl~Yhj15K1@d=RlRN(6i5^exSxq@zVdWTr1ZRUVI+BHBQ@7<qe}{qpUs*6
zj$zHs9${14R0Ada)ltt)w_nqoDSb^@;o~v!ywdTrJlmv&Q38aHMcpMkG8<5PX7j>3
zwl*MNp~<dOMA2H^%Q|49{Q%|>vX3X(g1bTw=0!3@#{X2A<jov!{+CP!Q2#}&+S8hQ
zzMx4XsOQb!aZ7`pb<;l%lBM_p8!61YW#08mL>;I#tueri0V3m?=$@LJVLykmZ?*<~
z5^!i8Hig}EakkB{3E6;B93F9EA~v5!-*(wkKM+3PLiJ6yJU`c=YvF9;{pP||W~5A}
zX4j&d@O;YmJ2&5^UP5(omeC<t1pi@*E%gv;y2zu=l7BSjdHxX3zBlWMG7U-Z7!S!9
zCea4WHFEQHka0$qHX0^A^EoNa^(hgnH9Fe00iMoE_>%%fw#_y=G5*K=ZF&<Vb<G*1
z@!DHmlXZro<ggDp<F?;0Be@^8q63SE<&Ja$`Y^$AxZ!xsr48yidq8(h2>B&w1ftdr
z-Eg1%j{uvT`4M5;v-XPP2fagdagJ`0PB91Jo*}~;SiAB!#C`z9J24;b%ZJ>2ju(mQ
zS$Kyi1@Zcan&B^QWLGIBGJk){k!oxgh>2AWmHR*=P!a3Ss0lFdjy^ljI?ZVB7e>E1
zQCXh#c9V?g2V~H$-W?eKfLbcocnWQL(2g}A^l5_YkaFQUZP4j#=p;*#xxF7qi}Yc3
z3kHet;<J0^fdcmv8)S7cg^=)(Wqc0%`-MOZ`tDl5_7VM`BR*;od?m$ZojlYX(#viy
zM}k*eMe4aVoS~2m4(b%;)H<tg>94zG7Aj^<;v-RK88Ntcw?Bl20*-?qwjnxpypnTU
zZw<-<*Rv^%GzkQ%p8MiSN?7x#9mD?7U%QWV>&!*?AQ9J(=@*SLkKG{=2n`tF-ClBK
zgBsGXoELbF4$8wUfGgo7SfF0|qsZ}-7d&4Ws~?f%Tub>-qz})}K;x#O(o<S%zW<7|
zX~9DZoG%m6JJOG6mx3#5)|jSmfoaAel$Fx~q)OQpA9E1E*}}Za@(Eu{XHGRB5XnLo
zYV}<sA!z}++GfJ!LsBk|3NibFnI#-uWTiPbWXiyUA)Y};MRkb4RaZmw9C10OJx`f|
z3h53!1?7(H(vGqi-fs^DJd=3P@X?}f8$se3>W6whaU~K^UOE@Q#fs;?xy=WHR2*%j
zW?p8kN*7Ai>|(0hd)5wi%N4#UrUPrOmbb2Wtyv%MYc;%41?1CmzHj4%hLFjKW231V
zT}Vucl82SYEhetcW319nkYGDyjM;kTrf-=wU-x0mlQUxio-rAWMvRz#9#j2{>hMhQ
zV)b`S+cQ^-XM!~jwCHRQ-J}gk#;b7Ce$S-tEMvvnRq3FZ?OwbaFF%t)I^6-MJb#Mu
z-Gw`reLcy9pH26Y^-e7WrL%x+>ADH1rFwAZ73c>ltiNmacUCay7>M+ShiD{ikwSqA
z*x6FjQWX;O2v=T+_Cf{|8tH~lvu#o_Sp%Ih8-2idj8x0kW2X?>9@1}*lbnks9()m+
zXQ2ft8sAb~luEe9O9*Am_#kT?0{SA63uH!)GWI0{=AsMXPv+Q0XT&}l0B&TOjkE@f
z>3teI<qX(LXXY<W_WCtZ=5Hj7KfSxkjwUA(Lrl|c*NnE-<hN}@!syIHAN?U{w8kQ0
zX1nA|S!)7XUmhgvQ64ugl3aaB|M!rF(Ajdj+_w7-761)Fw8Gz|H@05Vw3yD{F~7fo
z!NN%+hHOYQDQvk#shj=LbulB6!bP4Ugn@*N>+f1FTF6mMsCp)fa#9tHP)9KBb(Ef}
zg`!k3>U5)+nNmDzo83I>(BJl>fbH^8C6<2pq6R{V4uz9=DXf8<LszdcCZ#(I84c&k
zcHIaLR22sQ&WC5Uv^KIE7!daKZ8|jACkfTM-W-#~5M|Zs`ORnunk98B&NpisHe_hf
z&2B+D(3h8a{5K?jB!vTS0Pb-~P3S=;)onVQIoFyJ)iPGA7-FT(H=(_mkY_HvNKVC#
zdp9^|9}|eT@sIBl#WLWqtl>|Iz_^Yn7>NhH9Ne~2#g!wX(}&&ShDM<r926p@&W$Za
zksR7Vno_U(42d*J2*}EHnqltzipcM&u?@KnR!&mTv;SL|qXfV$wT1}#raM3VgQRV?
z)z1t(iGZoB?Pi<)0l6v;^$J_sefU|!w6F$42HRxsj6=TyWxZ<CrQ%pkKw7I<$m?CL
zT#h;j6>NSzj+})qfoNb2E8G`#eHKbXMdjl4;!sh&F!e`Kf{{Jyy-FiT6bTr4qb^Xb
zLBZXksuZ;D2D?;~Tu_Q=YzaZpl68=5T1C5=aiGuI6=hM-fn4*FXh$q)poU>w?%u0I
zS+R#`reTdEZneqmlUDLMlhEg7?*J#FN;@7R+IgR4)DWR-#~eTSc|=%~ZY@X9cS(*D
zj+HrpUGLxsy(_Ffc~8_3*#%W#%ZZX<M7RLsb!2$&igdU?F?^R16yb5SGaOw1JS<jp
z^JKR$(B>}~lBb`HJ^yn;DC$XOq-8k6Y#<4sXHr1xv=5J)$A~^-?%3iH{Ba+T`4bts
z!`#NiYg#h#x$m-Ytoeta{~=G$xBTSm<<#Nxi`?KqPjcKB7Y~#VftkN~FyR!~oSc`!
z@WNhP87EWxuHT;FulUV*A@luX|7FV!`S6c732SfcH@x>RWVw8k7{~Q{r~PE>xN>3t
zi-xcLgMReh?;QQ(8J9fzCtv#mv;Oh&%YI<hFYwkF-q5b*GF}|LUB(VUCtce5-y85H
zy|3b2GcZ^gTRy@8i16kiuU^NOo|oSvy=Cslzx#e)Fyvkt?r%PM*>{|94;}*({DpI_
z!InWtqTkOwinlQ4kKB9bWBlg#r+#qbW_*wXFy`N!dAgzCXFp5Yl>4VY*)aci-0IIf
zN*#U|3;jCw_C8-nxC(!i+vvCyKjhl<_!|qqzJmO44@Au8-)lS=STJV1_ES>T6Pf3O
za^~;27huAv*8LR|d6jX%XCHxz4E_zQ|MJ4$U$F3t0DgmC{p{aE?=|xfK2Y-S|2XYe
z+3$f*>oL4<{%w|L^TVJgFy2mF;}uPw`_G=&0}eX(UJvu1)_wi~^ZF=pMP}I)A6e+h
zCGG?>bUE9fa%g{uFPvkT!h9&<CqE_gdwCP?!HUrH5Hq`;!V7ZY&)9l!@EdRV^HTVf
zlQ^~B{pR7reW1wnYk64cE8g+g*F1jO{;h`j{pT~b{rJbLBY!X9cib^O^Ucq^il$rp
z&h+<FJ*NM)u<$dmzBoIA;Mtrw54MB}{x3X`000RPc6$H-BQjt#003VAZtv^bZLQkY
z)z&|?TWXza`MS@wi<Y)`KI+?AR&@`E?rwA2ZhO1ey0u%aQLRK+SCItZB}t5cgpELj
z7lZ-n2T`8D`i0;_h-5-f4@n@95-31Q1^{Mez={k2?g4y~?!9XBd-vToK)R=sYU0J9
zh^w_^dxQd2TWf1>Zlt4ab#F=5x%PcW+1hI_d#l#A+S%ml*2Rn4Q*C66i<@s`M-~w;
zUeb;g6Fztn4`7A>4DbdNK!AQB0HFW?AreHID*)>~d;Ryi>-~P#EZfVLle^YtyRlbF
zH?o^G6Ag0>5D~;P_#l2n{4n*=0*D9ukL2N$a0edlqkS3QL#1ts&G??TnpxuPH8dX9
zcrZ8~drDem0s?3sY-qcy7bNzI^bQ=c&hECn%?|NOT6L<4w{>vL-S%hmUAElq1-Fds
z6>vryb=&yjX+QYrt7?HkmMm?{!>%`CJ|k9DcAPJ<k}t$Z)HdJ*!MDIYA=o3W&U;Tx
z$63FLagB(!;Of{TnBJsnrfT8B@l-o3aEIpqo}D?Q!fyFi)qSDewW8o&!YmzN?e8Ib
z#;V)uX$MB}*-S5aQAJt6+S;~EVpxYE`-_WVn@tA;J>`!tSv6I&MVn0H>@|D4Uv#JY
z8*`8KF>z)G&fphm_nKT+2@kkR(=|dX?lqu%M22s$(9Vs1RmhL$pyu@XKp*_Ujicm+
z-nh~uopLuZ@(g~b1RE1J8ybk48hJMSYzRLlx4iNY_%#r0NZ7y55H~gQZ1~s^{YW>#
z@(}nn5Nu4?2#XnRYvkDQupv8=>ydWMH)Nz8&DBXnDJLVSoF`Cd5vLFojG(`NAt*sj
zixP6iIEA2y1cf0e3PDi_z>_SJ@5-4QaaKv#$Q>f~`A32gG)KroPSS{$XpBxFC?dp`
ze~eBcQ5^v?qeR0|QGObNnjPJIvmataG3&IP(v6fXE8jy#mPAbw5|PA3fk!J5QJU!_
zWU2FH3XS3vf+7$Ug`h(OO%x&krZeHSye2+Pk9nfm5-~Dcl_e`98M#PS*^@mIKO&6C
zITA3U)|oT&60`Z_@e%<VCJdH)=ReJ&&uNSp*6gpjry2XvBbpyLBr`IL&fCitBNdmt
zop9k#12U}9I7PT>!PN$xhT9FdjJY!QrXlcAa0Gdyyiwl3Z+JIM8?BAmhVJ~rQx1Ux
z;NjKAwUDl4rQkWwJgpRdKXPdhxrsG9uJvM=>b;v#Hj9&{+aBPNi+1)+-!7tTc{xTt
zQ~z(W>r@qQL9{ir9^LVbfIEf0#-Y8%E_s3%IpPiug|%)s7xJ%{zCricCl7hZ8O%Sw
zJHIiT@yR}T(<dz8j#v6K9r@eCFWWD>wVCSHtIdw#9qxD#yqa)v54<k|#Hb;9lC*(&
zsw^4>(1qQ>|IS6s1p(K~8n_-*PWRR@+S<G+Dh0HceVB207B|O~+8qbo#|QXvh6a`T
z+hWqeaE!|obDi>*ryOP{mGNy#tyW;l-o$J8stskU@W4Nu->B|dqqi@-JG=2~UAxU+
zX!>(6gI*iog6U=pJGs~Kd-|T0#Icv~{rj^jyMFZ<@BWzDn&O%}>Dk)}wcz3QuWr$&
z@{5MF1>br^0`nSvhm6A0qrf4CQ+xS;`45K39+7%7|2EMP4hydxhoK%)NP^QTq4%9n
z28;gc*~H#VCoyQ_51-h-am9jwtQ_l@Yyi>eI-liLIbD2shD2xt+OhdwAiLza3UMY0
z*Tilf9y7Mp!I9hS^zq0ScBP3{jnRs?i0-uc>k#C@r5B%f6FHC(!Htn$?@2`JKR}+l
zZH>mUjkmRz%6t&LoE$THSupAi-Y=o#8hf}^kqM#k)f(&ST<koZUH`1wnVFF{8nY;E
zBF@rQqOfY(x@+eMdYJ--SW91^#hVn8MUbyJO!Y81Hm4b3ZJ{v}#89j!lh!-Efuhrh
zg(lgUk1(4#NI6+p+cN&*k2OEPq(&31WF9QGGO8ALIm>Mm95ssznhPseCI<fJ%LI&7
zYPsvxCS^i<6}vEh!mXcIF05}=F`)8Qhh)TFkegSdOyuLS1EL9i_Auy1JrA*@+s+KZ
zmD_MwQin23lztsw$q`&ldXrqN*x!~XcGd?1oKSv&AsKF|9F0tkxLriX8R8Q7G#qj#
zI5X{WZ0+b8<u1|lt$Up|8!%bN=$t^8I6v$oTx`){Y9-IN%mLWxpN5#73fxztsCHY#
zUdNTBefah9g(UH2NYetYT=pT2ESUF<Q_k=3>~sma(`Ob_4qeJD8F<cvFB-sJj^2Fr
z6Qr!x7c}k9TR{^7jH9#Zq^-MkSVf$gV5chR6T_*SHybIpz!~>Lc%?Th)~&F63%Zyr
z(j-DI8|8jn>XkkXBUBUcI&O>k(lJOM^njOkUje_+JFPUGerC!JwXF}8O|ISQ#B&mz
z$GQyLI`p{^s@HWI{XDNGw4ScaJ5f6*i{3Qq9nf&kp~@1M+k>tghk8(e6qh2bD&~L|
z^qsHVqzNxhsV`^*sK{CYQZnqsWdn24IvfUdK^LIHd8c&LgRp3PN9yQ|kPq{@oG#PP
zeVJT4gQJI)>N*vC+vb2yV@_Ij8xo6pTJty@xd=T;Bp;OSN`_A}hwVh7q25q$9LQwU
zW?G*6C5tcNw9-6ulZj|N7I#P(p-=)`a)RaN(xED#A!&`(jsSOOFht^fC5;5}?Npsj
z=PU23F8YLqvml<VWVkBLxH?^`F^9^-N8AvpDr8@PXRN@}#m94z_Z??msZ`X`aG;n|
zky-W&2(dC(@YS@sjEkEumtrEpKrJydsm{4l-Q*8rl%(Pae)!cN`bDlO0j5N)>=4Zf
z^H2T`oNY6Tm{QLs`9WjnK>MlQ^@hxtlB;*3=LDswuPR_-u_By}*PS~9I|wfaSN?6+
zEPVH~X$$A^1O6#JL}zpOBklhTOX4s?I}_^NF$eqebdu40QJV~$@WG3=<kTbzQF%bM
zvOZ91kPFqw^MI`O@`<#6&`sU|P+;oKVbu8SLe6q44(OqY6@lKUF!$H>RX&U#evmsm
zeo#NOF00dESloaf4MjppeWFl{nSt_C;wiJ8>lA}vrcq~h-f9{m;_Y{nq>V>`n67y{
z(;Zf$Cv<7hbtm&3VbjE6-)ZrcIUX!ubb2Hk8ozh28f4S}y;;m2#pstnc2IiK>KscM
zrKJ9vOlykS(C6beOPq~shok+G;-zP+X36W;-QA8p<Gq;sX!p-%oY*ANEoOvRH5~Sa
zrC$nafv^^DqzC#-@d$1OD^%CTavstTmP2`~b>N?#$ad|ytE-;9YTc?`%4KOPUD;yn
z-GN{R>!JabKV{P2(4(fqgO@W)u&KD_=tGwE@dLN-n-JVb)c_<#l0s~j=pyRg6Er$-
zLqxf~Ysq8><APea_w-+$1DWO~U=)X(q4E-VmFgnf6lyy%l9sl}={c2|q?w%S@aCiN
zl6~%38Sbgo5aqAc40D4}gqFB;ck*VKn#4L4v3tOSeS724K~OB+jCYuopFHT!i+UC4
zOn1_rKa85k+B0XQYe(;oLQ!1%UE1*+yzd_2!O!R@+uu^R&qPF_1jH2ybd!rnb2SC8
zd3=ohfX!bWmg#80)O*LQW#uNA_>wX<|Hxsl@`o*aNcnH?Ha$xdjvoH_?sGS^?aq%B
z`W_@$oyav-T|rs`QQ`Jsv(-wNWQ9Sc_J^37oi%?NC?-f0&nrl<ZzlETl+Cp{v}BU*
zoFUVFeNmhr8Ht{Py^CRjYDQIdqaCHM>;Q1?e^^DbNXOp0hdEs9?45`8l-X0%C{5Zs
zR~R<Nn|p|z$xmj2_P2?P)lCG^EWoeV=lent<@v=ERv8V0);~{&EjXdS>QI?kv<clS
z`4Ly2*8`TnWcPTYDZv}Z;1Y_ME~mv5uxzWC&Fans{QPa#lr_uAy|%2%QG2{qZAJ8R
z?W{|3<~Ww=zsksHO`>Prxjs@${Im;g>7is{19b*U8^YlN=8Gr_B9GSe$}ePshf`!b
zzR2vGtM;~KG2vm4I{<`*pqKD-;oaU}*L;ep1$*~PwhK^E+BvMV*d@-v?pRZVGDu`)
zA)W`DVj%Ggh3?!>Wz8r+wYevrY86_zZ&%Y-?`$=2M}}g(%qRBI?ryAZu^+1IUM=S{
z<c(7#(nc0*^FE;VtsohhSnorycb&Nix@>TW-&gdb3o7V+<hJ&)-=dyak23hR`|f;r
zDM?$#BnEXlG1dwY^bphm;;fFo1TyX&9zzt}WW!%4AdDkpI=P>7-dgj}L~?j~9tF#B
zoQ7XW5ceX-kdFPEYK&7UK{ZO<<X{cj;X{M%mB?FDKNqxC0Y+|kJ=gX0*&-GX16@9L
zyyOaI{MWd_?!*OfdIw#KVE4LdD}<w?va_RHzmNE76DZEJ=Wpk-hG_^crhBvBG&|2L
z!QWS}r^rHSyK<^9bhTBI-tH=XtW1bC5v`>G?pQ<D-%l(yH#tN#J7=XGhzU95!uO}f
zkv6S`2(_2kb`8-f>np}U35=tM>5{AlucddT?fAp$^GACf)h0#wuT6DwPjxU2%4}E|
zYFbcfiv46?9cTRvt8L%)&WXfRI@zU=vSrUZ5d}l|B*F-o7$TgIN$rwbY3)gDX>6%(
zId6i>hy{snj8+q2VvgeD#XrbodxYE&JxrF^b*C|ASCp++dx-gLBNr}8K`tZAr^DAT
z?Dx&1iD`0A>naSa>X>!ewfN@I%C;Wx>@+$n2Z7d7Qia{jDtJf+L4nM<fH99dmE9Jr
zD?J_C4HCj3E<TjU_~*F3y(g9e=56&P#U2u@c<uRN%pCtP#n8wi%n^iC3APWQ`=d{%
zE67m8M<Cartl<S{5*qu3FeG5jCBVhAX6A7L{8OZhlEwK^7jMuWtwa4lwiMckOO8XH
z=nbGVLkdR@M&`g*cz}6u_aT^O1Y4`SCu%2MMhW_4s?~x;KXD!1xyRw<v1NdGuz3lj
za{cp!z2nEY`C&`RlP!b9h16I=s@a2O5P#{@!+c}bakh0k{$}i9yJ4{WT~R6rGGBmD
zaY8XJP@1;tP-*A1sNG|k_&6Eg6|m<J2xbSsbtG2FK2|X0IvaCdd0P8a%NzSWmoQm%
z5?o_#gSA5Ojn)>3+Yxp?@PljdG<BgCHSI;(%aOta<-Qj@*)Sf;gCkohs%KOa)RF_}
z+=aHQgnJ7M)S4jRz%FGkIrrFxe8F}O^<M<FI3WY7S$)OP6#M}@AY5YYf)Og&FsQX7
zOz(l5FMHsslKp1dL>rKmg>ebBZ208B<V#xPVXcGAQX(n%6BppcWm^yi27i(qI9q`|
z1b%v9RA@rG(pscl;2sIT!7x}wzy}cKN_YM<WmjC3me7^RD&=o2U>GAPsx02-;$J)2
z#Xe(R0Qyl?{VM3`0JX<5SQI>8w1OtNW0?ew*txHC{qjbIG&iu-WLfn##0hT9s<FQ#
z!Qd=y$Cwfow4!ze%pQ7CNbOqz0Gxerr_&W|yutwpkI8^FY9%+|;E~QWSapfb#S`R&
z?q!)jV*-W8v<@!l%8hz42gMikQ;(D05Tr&T!-0#A!Cxpp>*MnZ;0=P}V@8y658@#^
zm$y2kkU}d?^x%`DP#lUX7tkE7_?SVRau~A*Y9H+VfR>?qj>&N3b1N{I?W1j9*oJco
z??C3UCw2fU;VQLFrlwkh(9;nR^JUfn8#RDV2CgtG4B*%MtlMIs3}cRhv%otBurZ-j
z3m;i{nFB9mxtdUccP!SnT~HX>0m$`TA%N+QEP#et>x~~s#uoW>7Q$E70)+8IO;95>
zRjh}*wtQdEiO2YbxJ{rRIu?uZbD+=s1bU~dBwb(qpbm%O#bpy*oU&e7V3xRkMeGHy
zm88);b3eFqY(L{MqN=p?>tTbl=8uA7t^=!xigp7LH#s?@H@6L_G!oa(a;MTo@2)pi
zB9r_A?cu7&@YgNU_v{|MhN}lk)r$sAVMO_(F|?Ke^-Qox$SU2@#B&6lqI1!`09z8=
ze=-9JdqQCC3)?3ym-W(WCpjMcxB)^Iu1^o%5)gjE@Rk)`o>@{yHwyh2D*&62yC!M=
zWf3<q>9ZS3hgMKLam<Vusdu#Y;AY&z=cQljAyIyyd7(H1x;QS8mN$nU>W=(I&=@jV
zseC>1tQlN&#R1i-u@BIjqpFZPIcK?s)&na@N*HI}a)N`nEt6qLl*zE#{duV)28Tre
z0Jrgbul52z#l;14q%B!^k5YnBs=P)8fo1ZDpbc{>^&7W~5NC|3g}4C5UULPip&<0j
z$lA{lrvXybB6<eu$6sNdZ460d$ZqPHWnict^blGVDvL!${w`iZq9%Xw)K_Qf3ZCHn
z%&BSfIbNAMOMEGBCL|y~)Csmq{<{%sKV;T1!Prr*A1ckw#rssLDLEiL#Z>Y8*s#cL
z!XKwPEFaV2J@9sr2r(pTJqY8-Euuj}ifJ?;!En&3{$QEWN_*Cn8KF7y0LH6#SQW5z
z>Ca|Sg%PxDhJj+AQph>rLyaci-!tw1?7NZ6<^2;NkD7`rQK-oP32wXiNh@y4<_73F
zkFf@oJ|GEuMfG}&NKQ=t-%rfUGi`Pc5@!<yo%zC3<2hjlqoRh$F)*B$#-q1Keh_i7
zkHL~Iw4~+{jfb6$SwPIqa2!tdke(-3dZ6QR+@gYAZoKt?G2;TnMBD4D>c5LvU?U#Y
z8JL>w%Yx}q9(X+QZInZ|uoM)p3Rr-n2B=Xv6>~v{3|L{58O;Z^tz*C4@(IgCg{^_Q
zeb_9Q!_(0EHZa)W11+P;Tab@lxnQ;i)mhG%q}QYQ4Cc|42JAkzc7uc-q?0vR_}F7F
zr^#C)n{79+?!fMH7x-|1UP&%B-|qFe!k^ZBQ`(aD13|;|t>9rz&WPJEU?H$y95YY5
z^f{lg-35Y2AcCL=QS0l6^Oy70`YD6II{7E75Nbz%<W%1H??I!wY9}=y{53v2!H85-
zSH=RnqsD+9vJ?GSugK{s_5Eo`Ybt=`T5u<2P5G8ntcx>Y_@^gHpce;Q8#AC6UWRqS
z^Bp=&jkOAfAbz+q&yD|{rQ_NLJ70u2YVr*91C84T;BE)r^Vmy|lP(5$8UAjeUe67D
zzOu%H1CJTW4(XZmPP7#WUke6VZ{G4C!DG;NG2CzBKyT{uMwJrP(ETddR7@yyMo$|x
z`$_}&mLMi;pHMT(>l{)}{Xo}9sA2_{gZ=tZ6NoTnK1%7w2C_4jn9Yk-@D4I#0B9BD
zbqXq~gJq*_z%tuT4CM378#zW0A-86k9!TbnKt8Pz^=1D{B%pv;_8Hlm5qU`sH*x$J
z{cQ>P{mM2W(l?THeQI|g04`*`6}%EBaPd*2cl01mB`Q-JsG>Jm8JQNA8|P*q&7WdB
z*9eX8(nmcMWN_~ynKpYvnNi|tP=5wgV|tN_lwiT8^%yCbmEoIAWy7-t#|&+?3|?96
z)rG-g11#4uvkoJM=PqMA^$2Ffdp_s}5E%)xrK%r*j~dy%5*yOBG$#b9TP5)IXb^w%
zd4Z}t03KExS@uK83W;ZmNj2kEEpUE}3!u{8IjXR4tFZ1qrl=HuPnGF6+%ECsbOh$@
zFS{X_e3`Fc4%}ZdhDcb<AXg_f)Ef9P)BRTRs>dJ=)}OXXe~|HK)|Y(LIu@^98Rwjq
zEO&ww2X`QqG>k;k&u3J)q`q%4PYLG;8G@dkywL_Egjyn%EWuGjQtGglX3ouX38{u+
z<*FC>=RzLkm44PPJnHo6fxk%lTucuE`TsOyZ^-+B`=9y1pn)gF7v&Vqz@Hh3`=bbE
z06<M0el(=RMb$*|wp2ua*69BtLxd|Im_j-y+~J2i|8T6<2VLFr;f_1paEBf4xWf*2
z+~Mp$&dg-Dv;Q*$XL;3qxdq|(1Dek1-~X?e@6`v&-x<%2%~b0_8SrKZMjg#$?^bu^
z3=OjU@~pZ3*Xnx0Q_u2IVK>`2n~(ndGFHE-`TDsJm&c%*4wdHl%Cv_~m$IrCAxhA)
zVkxpADbeLZP?0v9q;+hF3bnaVC?FdmVl5(;EgO__ZZ2XoX<`$qd}f<aY#0+tQ$nZ6
zD%I44D+tE_O^i_qg;J@6Q4lpXLj>b{8_7$bHMUqNsY+)BDW8TYRLzA_6~+m5HlYeq
zW+$3Zuo6T;RMrg<S=cD0Pgp?&Ze1dU-y5wZsG#slqLmz>gd!s>+?-J;D?h9Ch-qKg
z;i^(o#GR(D>&Bp3R4B?nt!}BPSE>FlGd5^Fu1#<j+=cW;p3q4qvk;Dk09rt$ziEg!
zHWDA2z7}$2>NdsQFu9B+CYK?^G)C_eUB44`nNLh+2AIGkpV?(RF`Yp%u`@UnHu1!N
zhLkekBqjbAjw2Yz5}24+DI*Hf?+9-nQDB&98_H6`Z^>=oiL(TrCiHeq=8?OH|1uC~
z^%x`5do3pt1k%{jb~`~yJ5lSo1iiG#+SVrd(jaWRo9jyi!L+}&pH7gc0q}Mcq?+R!
zZv=Uo;9F29h_udIzbDAF)!e@)2sGNbp-+%$zqx=-5UM@6^Gy(`Y0MQ}f{~gC-NGj%
zwUD}qPl0M6c}<k7R|K)G@4Z)o#EX0uR6*plKYZ25+>a;SYUJ(^O@!dd@I0ZLa73X$
zY4C(&<q8ZHuNbLWc?G|M6Udu4R>DjcD?&|@C=`=KNtl#MqNF4e#U)WFCW(?UDU?J>
zNhFF&qESo|C1O%2iIb8^6qH1wm?TQYq)`$kC6XvSp_{lw!J+x7FXD;b#1m6Q=ab&&
z6TgHfCK8Pg4uww%$G?9s{3|~Lru*1^5}OeB-Vn%y1~QUxH2`-9002|tSVLnP5+DWx
zP4+|@8uV`1J&>N8e`9wxu-MRy?(!CJ--aDz$GF=~0`8AU+E*(XpV1#mY*w+*Nb$B-
zkv=R+@moB3EG%pKY1gmTlFr+2TfdE#uUDh#l`12%swy)XA~?9Bqm`yHsJK>KhN`ND
zFs$<%<9-|n2{=X=bZhg?ki!}U1V6YTtQMyU(WDeL6g5&^X=%Z7uBRPPRo`86-%047
zDUycoRo_7DliD=kuBv0G?_OH+&ik93l~WlA&wKCL#c}8J-Fm~!c?tZ)=-HUSpIK*(
z009&g0RR9I4Mzb%lw*j(!QL3DjQOf6tGr38*%$8b-$C+G*9DU1&ind7r#V1tuIsFN
zBkl7EUH%d?)qHbu*@yc7zed%``ERx7;KMmS21SX(*O1|^U98zy(#r?cNXe5S{srFe
z-UILhvR+$=yb=MVJsU_O8?@8BfInXNxYzjwuk+^1mhf)EX<M6_azss4?DXpO^!mHS
zPrP$Q?{3jM`K$2l-RI?^Q28qBeDAuTDY+@fyGjjx72&?0FcrPD`wFVL=icm6Z`R+w
z^~h2`SNqRF1qWTHK^OYB-t4fZJftu@A;WNVMGrlOR{THF0{wq+JqpHlz`W6{fCLV0
zv4}<ZQD`ywkil~-ScezF!9Kd-jD>4h(HlI5gNUI?S8@8Gw(3WE>eiT8VJ=)DL$|0o
zijEGvk*u&AHUf9%j5r0JxNQVh&<`IG5ksd_$dQw~_Q95qSdG&~=W${iKjBxbSg=>3
z^{kKGdj!r)S8@6vy_>E-rfVdwh^L=>dt%gMg^@8@QDBU2tiU&@?on4c)atnf9jPDO
z-Ps?b<ls}l1FNprs&Jilth76d%ii^wxU4@W_^wo|tAK#I)IUE;YCJq$Y7aw?Q&~q%
zxx3ucAWG{9vcBzsv^(GSonl=NJY;U)UnTWmV6=YYfuTcW)!DO7?LSY{pStx24ZYTc
zJhB&(>uLj#vVL&t$qNdVQ)tmSwU%sCOGuaUT`Y31E6?lpBVl&$5h|@A?7g9xxrBt4
z)P;rS)G(4Pdx75s*5>TFbMjC-EoKzwpIsoQBObRz(w}NS5}#^1QjBVDU6;D1=JT(A
z!c#;5RU?uDRr`^hRV7K!s)!_K)ivV;TH22atu09sRE<cAR@gJlTC(=lgDCsWNGep#
zNitL|Njg-GNRC#1{V>$B1G4OW`9e(XGfGs=Ns(5+y`@u4Ns6kz^;5U)rYS6+-SuaM
zCG+cn8I~R2*S+IAi&Z;)txUXF9v+c7$1pYatyiEoYql>|=<*A~Xa6sAoly3lTi=>)
z`vvXf?Xl0MiS`P%kNIl<J1W?9_vbl=_K`OKQ0s3pb9U3*Id07RX{Kufc&#md-T8jT
zon5=Sc7E+Hn2H;?vTAzM<%LaaS1f2qsSc)EP!{A^L$VlZK{&k7Au1~^%PNavc7<bx
z*<OwZG)`seAjvYSCF;n)5+iFu)=0As1J#l|KA<@*=f`h#0A@u}MnIIE(+(h;krb9A
z{3C6%mSKJ@KO+UeY@;=D-kI89-Q|EnV;xTMh*;Lh+79WDIx{|UFy^^kEvyMGIqfoV
ziAb}%hgwXYzRqD*;*LzP9w@D_1N9MzmXMuuYc*fxCrBQsbhgu-?J4`zKIv>=dmn}F
zKyhu39+F5=d8lb2|G{nZA?k9r4$VwyaI_mRhbWl2(utSM!=bNQ>Gw?yor0`$=8i}9
zWNDCt80oCCTG_9Ld(<L{FLN2Rq<3*BzFn|nkoYmVU|UdL3?r#H8lBdLh0hxtxt}&J
zP%`FW?ciPq*s_z34dXFv6J&tJEvhp#^IQO}kFaw@9?E`d3#p^H&MIZkqGShY*#UO8
zhsD{2Wr)Im@2DFIq5Z2oP{~m+*vv?`kab20Zy1yQt^&_@iESSztwwxg?9gE)Y7Avx
z<|l9t%$egH|C+{&vf>ZTs=SdOVyKFz@=P{1Y$vchDg%9w5s#?gzK`|_<F5zqV5e0S
zNkrOQIsKYE+QhsU&ZCM=x~mnIgXSAC_;zvqa!};E(A&jl^Uu!8b)l>RSXnw7De5KX
zLSyX|Eb5eeRPQ6(N@|uY;sg{=>hZq|b{Cg(*cZz&e<74q(X)psI=C3H4gFj*_72cK
zIB7|c0){I8`f?Fn;~#i-g||)1ao&*igeU%|7Y=PHzkf!_mUaY54LANg5w>Yf-*<mM
z%-i2)JTJS30=G?IhqB_A4MvkPRztZxf{`4a5Uu62n6Sqh9{UVexP%<}`pKVI@x@H0
z;p^B7!pT9OJIcr$oRq5vMDBGzj(<%9FAk(o5&WAj2=wKk4}g4$kgOoyq^5^ms2pPA
zKm-#A^-<&9mR(@tDy3O|gVYYi&+{{v4XliYEjAng+V=H`y@hs2#^Lqg{@pJnW^YIc
zB6{ZD=iLyR2uwO;d*NxxqKsqf!ORGZC45S4dc#P8BxEm*N+enSR=-s%T9d4;g;N9#
z8Sah!{q6BN2^sX|(9pow^`|FS2p~6{ABtn9olb}u#tQmN;z%_*ud{P+$8F#V;L@%k
zqg}GTtV;Te8tx_Fh9Ivrn%O|PuPCn93>}Jj9W{}U-4y_psf4ipJ{s(}<xM-m#+UsM
z&V$;}NCshp*a79I9uqvdiqQ-J;)F)fQ6o6ZB_)~F2Q3*4mUYcxTbc@5WV0U3rKv>3
zziTSQS0Xy#eoounOqV9W%T!X(^IU`L3lk(oB>O{OE;=T}C^I1&68^(yV?}WSAr&zq
zSsB{GM^R7<1PsLFiMb@82mAx$R7+L$A0bPUZZ2eS7{aki8F}iBvgkq`)|X*RlTx`}
z?nYKAt;fs3Y#gj+DKJUnm5)r8C0d!Boyh?@+q)Ua;b+NZDPa~6zhcLT+@vwTjs#m0
zuo>3}GB_?@lA#(Wp~MbSdRg0rOwmpn50wn50$R?J=9bhct#@$6GpRbQZ=BK`nbqo)
zM4<t>FVh03T$ICLi&^LGKb{B6i}R8CPTy5Fa5{7+$p>^h(72LEkHj^WuCcCI`R#yA
zed&d7lLRN|wN(G6cA3&s*C04EFKcb)n=F~cn%Sc^bWzkfin!~phnx8RfEiTP%DOPx
z{s#oOt}5rByn8WrfAckvPEu~;1J|PXGoU3g_$}{jw;ky5UI?W5)mT&sVZJ&SDpY$I
zWUx~T4-keI_llDDm@l)u*-xqaJJc5GUBRo<1sb-_*F0)3aUY$;4_m+W$bi5oxQ14f
z{yuJO6fFnfpBL3e)Z3txy5YAL2SdlNCx23#8@lV=klhQrgCtCK^6iq&yiGFX5gCk?
zJi$U8oA&ueV5a4Hibx?Jp{Wc)@y<wCTM9=(6}Ad79i$-fifnX1NX(5R63K>X=My*(
zL7_7NhVB~}!;y46N@yX6=YrUu?q0n2-ayE&8Ho^2BXfon%n2sU9aqf$oy;6~8J}>H
zA=e6|(<JvIA(NPC%pL;QqbaZ1UU9y6lhAY`uHKi2QyUq9wrBFzC?QFIunP)kID+~W
ze{gLaCA6TjG6B$IBW_7mw!#&eM%i5X>V|~0e$zg3m8eUa8xk-7JsYyzuqpOft-`Rs
zH^+xTx^N`$Z(RqLP=&Cgt{C(VUdUC!mI((V)P4m!0wiLB9-Shs<G|8^qz24lV%cdF
zA~BMypD7Nt+A~-4Pu!?}452F0d->WtBKhe;Uo=S~*pirGTs<vy7wdY!5q=L_uewL_
zJcFUSgJR(6Fs0I(N@v~U!N^CLR#!!$%;6e=`2ia~(2j&_l`mU*G1=g<Q0T}f?24fe
zth8eXp$6Auzp<H@I)kc`H8ppa7=W@XwM?pAjM8}_`eFUz3t->*K95*3FV&@Z1ZZvE
zs5;LRT(8aVhx$<tk~FB=OGrX`BDJsRdc3yH8DeXpktFO0cu-Vzih`T8O<}k1zm3Hb
z`2&+dP!X6(pffHQ0v(lY+6mds$L72zIj!o@1OqDJ4=BA+l^<&D0*)SQK0^bMR$~*p
z3sDyAFtc#d+K5wNV6CG|IwDZvc=M{*Hc)I;WuyU5-?Mxo>2Rw2m9u0ed~~K_>+K?D
zQ->Y$as3~}ncAQf`Px+BhWYurUqwNYCk}Ae9}f!cSZ}aN419)jz}OD?14EuQj7E8X
z%#CFCGLl{2Ke<O)Gtc`R@9hP3`$2?~bOiMk8tXC+y*<IVsYzNgDJ!REI`h<?R$7Nz
zBqzRT@OaDn(w8ti9i((M_G=Y@GCG~EgPJ&p^+^mtjowdxFk29FWCW6S7t?$+=y>qR
z93I_m2RRq+EpkhL`5qeZZZFA@Dd>i!S9QL#ocuX<;Di515AeJnM5)m&{DwdT6}UGZ
z?Uh#$Y6g>e%;_3}a`FG<A05r-5Y3K~42kqp^t3pJGQt)NJ#&L1X%C^Y?c~=Y(L#Il
ziaV3b$iUnvV#?DM2MV4(D@Q(*ymcjJm`1{=LfnW2Qxk+HNL!U$O`f_=yff$;J{d{+
zeELxuLnG0!HG--~x@)o)ws3wRpBtPSAA7FNE485Y@Gj6^m`%(qB_nV*R*X>(76i>`
zmP&lVdBNoMCUt}+xUcScH_sZfJF@aMJ)L>t4NOU#VH&1h(E9s5WOKHKC=ly-4$9jM
zEE55DTxES{$aq3gb#=7Xg1ESn06x3_JrvU+xr;S91oUY&5OtS?NMJf*nj<u`;O!Je
z^(6vd$hn0*TI5YVgbNV0gq4By#)HPnP^PU2;Y16)E3T%t)4NFA&0`H$$0k-XB)-X)
zKcCA$+v~@f(*qkDbs9xn!7l?(FuIQYI*-@3YUejj@73%yf2w3Nvf8v@y^frQo^xH+
zpdJXuzx{8qUbtM!N>>gnH;|xK!p;vm&%_V^CrBt#gE)ST&-YNyWb6|sl#a@W0#~i;
z>m$o(W>{vB=VoSS*c^DP8JSff`(OOoRt{y=K8i6ijAu^8kQOiFVY9A6YRG}3WZtmf
zkfh?J<7%3aopW%u8OKyPCuxSr0oa(YMje=_9za>@!5@Kol$Wr2q)=Bq{%R!EunQm%
ztoS>ixZ&obHjK|T+tb7Le3)`4dNMDRk&f~7`9jv>k+LQ<4;-g(@S%OL4_-Ptc@aJr
zk`wpgV9(o5$pjM9{~2-P@y*dEad{cg54z|u<VxsQ!vnj{i#efV-AR#uO}~fV!W!SS
zOJBmz<1_6PbTS@wVTB#b#^$o6H1qQyBFu|lCcogY43A0<OS}Z!Z74?NJPt#frQhqW
zt}?elO^KM<Y=cJ+30j+jUoUXS4IT2lF5tt?628>5EJ3W&!*{eT{hXjfJ%vY@F;a0u
z<@HFN*82RvNu61V2%s4i!^wbFKSOa-c}QPvs-(<q)36-$^?IQ+knxk_idJe$Izya>
zb*|>|LLp>$ExD{S(NZG@#Cpwc;n>Whycyunvc`pAE{1-#>?b?RWqK22XyaN<5izLq
zG3}x#N<8`Ivbh*zRrd}i%cXMRd}MQ~*Y|+#F6@H~+cQQ)+==?<C;z!0qMKupBX^dz
z$bwOciSw|rblj)<;Xw3eeMi{LmGJ>`zmk5$Th*v>#)!6daf6%pp=)r>m|T!9zXv%$
zALcUT6Mtq3n2oAw!Kk14-vkwTET!yNzq8HH5YQa<e#WCjE%w0ivM-`%YZUVH>2_Xi
z6ArY?2h91VXJre5ABlpB7?R_uPC+ir!7GnbV#s+GP7EJgiPPA@5S(diaorAAD8cTF
zo(+{hTmwJS?xrM^9vJ3Cjb7l<BhANXVBBi#33p-2f<|vq0L)LiCiWb8z{Fdw=;xt2
z&euO;r$nl9nFA%vfk3`2qnv$Qs>KA2tJXefPF*(qK0H+>WP%5ZR?E0W`87l_1-d}X
zD5lzwmnGk^*g}kFDKoSYTC`RLhX8ULYgRbqRFhv&BaU?N1mOv`CREcA&Ol-s3LLOM
zHC|%Ag~wplRiIqM)G*!|=tLR$*5C{C!vov@H`};}Zp%9qGHhg$A0$Z<eoKH3l%EbB
z$`X!P8%bt4J{D}g5C;x#Sz!)5I6gc$EIVA8<2ZLYOw)Xv`yjVF$*QA10-0M)k1Dz<
zOLNo8%JnY(vd&|Dd|NAymS?;{&LN4S*N-L#|L7p{5aO8D!OX^q9yiPY2}rVwoF&Wz
zfAmHpk*poRJVNjOBf{l|u<3qsiiIpors^}li4^HTc7?8c6(ag~-x%Pris?UVNdBys
z=JOd3%+^aFhOF{*LT?0qI^FQJQKg58m?_eQV{xt9=LA?H;?Az)EGP?yTBPTb;}xg#
z@N+=K$<{)4aR*kOOHD|lqZK#9(zq7zNMY+*&YYmc39ExjrcNP1GG?4{o)->ngj}Sk
zteKOn-C%ZcLK1SB+AGz<!bxbc!<!!VRywkcQ=cHrjA9+j`xhNcGB!lu#1zlX>Q|wl
z(}r`j%?N8sv?Bl?>1bK7jJJ04HGUE{IkB<^j<elmzqJoK8`xdlEp7x6*W~CYiR-FB
zO^%fj+{ga|n%&)kRr}^rce!0%nW*Fg(W+l2{I7~O($&|#j9l_V2f;7p$}ljsYbcs(
z$GfXDs6SE~;_=c~Rp_5J;a+YvW6#M+T2KEeJQ>m!^`)U~VD9>-i1enVWHf=1p#&r(
zmW0s>DifF>2x~^{;aMSkj}M&%D=XDMuESWZdpS~JRQpQx2qm6g0dBkhc+@^B0pv|_
zA4B|gY7X?aDh2$T*C?k~Ad>?3ZX{SCg<#yJtuvTSKL;8$`A7cht-N$XeNOMa8Ucv0
zrh&TsHQV*=PJxg2RW#lIXFh{(*HiUu9H!!&8X3A$mS}|ga|I3Kdt<e@GwQpW4dI`y
zuYCP||HYl^QBVDV0C+rt3XI?P>?+z(%LX`jzS!~lz3XM#v-%kdpx-a|XEtI#<J9|8
z)wa}yvcni)!0CJ#l6gLb+@$Agb#Yd0ZX{m|$i1EJsmYsT3m9-@#@;63aZ>F%U`ccf
zvTc)Df*4cU@J({p*ZhEm)`)|q1x@yPo?`3uKr};Qua`i!$&&kVx5UlOip)w^oEaQ>
z!%%0aOxpsfQFv71R;G*s9C<0(+17TatOJbmV@@&gRIsiV48}%#=lF8BYli<pO~Db@
zhH)_(i33x4l)LXz6L?F<oT>TqKl$J@j~wsTyyg<MVNl(l1vAe%FeszMWkxGcWnDYl
z==2DYVZ*Mxb$}rsNh!z<ca;`TNO*}0B?DIc_9765ncaPY_jWsQKx2OR%n#wCg>=-C
z%jEV3!BoWtTqx4?vMyIR2#~9;wT(D5-~$gCg3A?r^3X?$xE5tbNzGbB=&dmhH)cvO
z<MPuk7C$2)nJZ1TteU=iUrtDgmFOr;QUCJTq@Rif8B7LEx8sLJ64Koa@A<j<$3Kjj
zws-5N{G#0X%z@ZEbuyn$-11+ht@W$2%AV^5jRq!O=Idbd?nDdqtp-ts-D$owLi{|4
znPj8z69k4NbDCHhH)Pavz=I}Z+CkD015XO1@UFFBY7o)Y7pH^h7PvC!v2Q%EolIr^
z`uaI*x0mA+u+evxqKF(q-1-$ET#h+h>h%rh4Jjn*eCN_$3n^#<k+07B@ISR@S1!TH
zRe{)``osG|m8cs3H|+zVoEfV^9IKN3t$pcD^}$cE70donxcbhx2M1qh_*m_YZ<RE(
z15I$VU-G}orQgV(i2Z)?!F?-Tr&)VH)joaI`Jf}Z{U86Ad2sZ6(>0^0dYCLV{dzC~
zLJRO<b&3xU%~eE5Z<<ZWySd37F&c%Wwz5Cn0(>}{N-*0x*=|8i+NN*e3?lRr9eQ#E
zJ5{&Y+2F>)$J$A*c^}yUI<u`6iCaPmx9QUY=-?iz-T0QPQ&QgPY~JkgqbW&{4`5dK
zdl~&ut=HOUW*USXlEFEGw<A{>O;G_z<ZQ}Ato-hbEPo#q^}Peyi>{M3|F6t>&WmF<
z>e*q@&`PqvSrhE(m8s@FO5RNiH4=Um+Uu4-0N2@VsZl|!+dFxvD#Ew4c>R?IaO#)j
z)M(w-=J7+y-}_yi#H*_ye~s4Cl5M%E&#i4osmC?6bB9`X$Q<7LqlT_72UQ%bNJ?4o
zj!yVuk6+V>+#&NXlvuni4lgdZEu3(caof~1^%hy^f;Mjy-qNLuCXsjsANoH%MVb+s
zZh5(!ie|UNAxx0j2?A<x5~+tbQgitz2~_AKio9ID^&<&*$<+<X^MYc>R%M##dN;-J
zr&q-Om)4Juy{qW<eX1g+QS=GTM~0xNTi8jY5#m*hGSMK21+^CT%+%i-3MMA$7z}sl
z3)OJ#Lo=`TsU{$-%86lre)9fRI~W^G5#x!D$--ibfasBuKRlOKObOlTz-3+r^nRrs
z8~P2E*C#<s3zdm2R60~dJlaJPbJ#sXxN>;GA*batgd@?!W!q}OH?yUAY5WRkB^_<p
z39msKlQLgdteFzfo<IoJt*~m0cA8U0O|VE+oR*iLZt(=r#4J_gJmzf&1DB%xH4BSH
z?~dSN=m{$jN&^eD%3I9iifhB(QlLVxNb8u=4?|R{NZ6&%oR~1Tg9aNFh&hb4byWJx
z_}M0-TPxdUyC*-IO6=;zd!WZC(h&ZC<hkk2w~u+0Ob>%dT8#&n9#M4$?9@Y?VN*Gm
zQh*Im<hs#spoprg$8dBHxm_@jZlzUEYl(b4axhk8P0umHy6`i!V4U8$moGpAP(95j
z;>iczOIq+ZN{uW30x~l`HRP05Dv~bD&u=G@#VmT^5$vc`F_8(9=LYd#i41CDLuvw^
zqdb4_T43cmGV6G|ib0EcMXb0NvV2d#EUJe_8tb-4i~s%eeKd`(pRsGD^PA|Ztgx_O
zxL`WtIz!xfbn++z0gErnIuNr)GxZnW-4FXSGj>GRO^D#8;6AXF@U2z-KSpCtVETcS
z>Tn(TCutUdBN_?AoFMHyb?Yd=mNCoWG@(Y!^K8|ntt)e^WH$YiN3;h)26}}dg&HBy
zw{i0G<~B-qGu;)e%cb|3GwnPGJ~Vux?<22kf8Tp|B+M*sj$>`#JuCeSV?QqGFiPM3
zUiZqsSj70Z*717psJ18be7Q>%=kV5sr~S?=nn&)N!?N{4*Wq};ZK?2+;THUt<K~S?
zoPNk>*SPKX>TVOcvx(9DehL2kE5VxhlK#W<KOOZeMj5I0I3MTcgdSfIjd+pEi6sv`
z$gvC_RV;3|pO@&?bL>``B_UT~M)b-{wNe&h)f{iuq{xhIlN6nwkuZkN^RNEmkpb(u
zJ>{@Ws1|r>+cYwAFPTe|FI2eeDb7IjTOu8dN(4O;jVA-Iqh0jZCB>rRhZjV`mEh;E
zv4=gJB~s6nYjXf~_4k=lJL6(T-DcS=&fA5ift~P<23wu1zlUdpCj3&*k>;%r_@Hp)
zO8feale4nvVut#oos9V1F27CFD<I{OGglT1cn*}B68%s&e-g1NAVJdxK|^1Xx>+Q6
z=eF9e3<`1Q1r(@H6;u{J%m0QF*%#OfxuYdoze#UW32}$wmo+OakTj>1kOY266f(48
zFmXv3oho8S371zT?iV0pBsvrfXG@f<dmlIf*>gtr7r&Y1j3<>c`w&wzIb=2SKUols
zm@5hUC+#f|m?*u&EEr^P^wrUZ{UP$Kp-h<;6#jVKx$-yy&j44XY1J~4*vfPjwf!e8
z8DDCOZS$vjk>u?lGBkJFg3EVA5yhXZ1#&CCp|aFh&jeW#chFs`*}~SbE2CK+Hd_e~
zXY>TA2*KRzmWSnYUB8MtgmJA3FvWF;J@m`_I08=>P=DOuM0Uj{8^Zsakk-^R?OVUj
zFsAu3{p)i<K`)m|225RBpxm%*U_#hsuNmfgfP~OUV?={%3E8K4z4yCkFj2-x=mqJ<
z(ZNR-!N-bpa?#Z5_7BC=fZJhhLENAe?^PyPJW#fUoI|tY?=DHFU>*-~1)a#9qu64W
zK6(&B=UQsYE}iRZK!BKse_Vw;#$v9B|0`yisQu7SuQ`U!7VcB|Lcm7&2*4bA4A{7h
ziN*||P?^%vU;zM`cOrOP9;1={tL10R^TGgjK%bRp2&Pv|0iX%jPUL%3jjaGs^Ui8i
zg|(`rDm;aD_X>2Hs$884=^LOLUCv=URG!MSn7~fEv}SGf`~oXqb$2&H(F(<+<H?k(
z=sG)e^sR+`o#A*Ia_E_agIMv4dAVT4Ewl4nsameK?KHudehb!TOf$BwEf(8e<lM|p
zqAmqlvF+EL-*fU%_r-;ZrafN!&60lt><NvM<=;sY)6`Ce@HoC;`}`-D+)hffO)#=w
zpxC6ggIRJx!HaVzsvagW(=__RChmkPb@la2+qOLk)Jfb-yFL|@LY;!4{3ny4(x^^C
z$ztc&m~3r())8Y(%<QYvX`M{Sp7hEZjU<>LWALA{DXneuceudigxm0wH1e&!I4**O
zj6I7UtXHsXP)T&8lX}a*-6!BPb`H;(!d(){Ky6m=T0ANDM9)yTtBXpFrgD{p8!-s>
z*|Vk2+NgMa19>`MJzZ!aU+ms!|5}BoCZdT}i<lVw!*|-kclc8eb%vNNe%g}9#zODp
zP3NM2XjbmnTE7{XI|)8Civ?Y|41G2oYS^eBuAb?^M%Tr(k*~9n+S@_=X7Fw3sW6Cc
zvI<bopmD!@p>~7-bRz5$ZF(-<e#f(u3QyWzP`b!Uk>^$1!lp+B{3Vq}vWrtsPqs`D
zMujwD*2(DRn<wHWCDBhtD`$Q3V@?qBu=`iaXtuZ_&M;@AY(#}~N6{#Dy0?dTC$ua0
zST@9`ZE-g?675+FF;76GpmDlj%<i>|DNms-{>H^;BbGF_*U!wG{_6~nZLbaIllfK+
zW9zNz{d$($weHX+^$EugEChgLTivu4y8ZQqs`oNDsjgMV)_a1mVLUOlRf2)mT61@)
zHi=2{><BiMPpi=Qfju3Pir{Xkv67w&$7MWS1zh)2(U}uM&?UK}EY%FIvEQOU^Li$H
z<7xY^vQrdFU)=kIyz5-ezvA(NE(wm{kR)dVrHGK+-uDc%fZwDUm<TqF(Hs>I6`v%0
zPdQr}5i$A%otU;S%@b;N26duH`uxi2cFm&QD4*H*eJ?UWPbBS}e}|S3?ED4PEQw8Z
z9yYcmjrj{j#644<+F}abTacRE%TlG2H!{)Z|AzM)sYrdStuvEzu|lmDWS+kN3wMkI
z$&uN@^TV4^MNb9PDk%?{XxTuj?|7gn<UJpNw~gbIm7wzp3(_PgQz2)pJo;QIbVH1>
z<vZpId?qRGoYO1wWSslnnZNr{ed%m&e?lciOaA0(3y3NkBAdcKTq@#nC;3jH+^@xw
zkR(BIk2Mk-36WnJ^#7p@#hdT@@XRc@y@1sxHU+7fK8_py#Bz!$=&4xME1m5rp1jZ`
zt8Z%h7g#=Z#?tV|kvE$F6tSR5-pi>L#uLwyvJaGaE$9cvp-ZPyx0jise7z{$@JgfA
zuH9;>oXTdjcx&tJCbqMLFa4o(G#1jXb9B7o)D!p`^)VZ9p>?r}B%lAioF>`e;cyZZ
zzo0Yd;-)7pbnMHOW-jKJewesPN+3sbFEcgQqLb-i$tG+`zH4(?wT1jWEa(p(UCLWx
z=74``aaRKWtZ67s_e&QZNHLQ$Zt$=<1(H3q+1Cv8h8ZfWtwFy0zHRoi@Od$Xdp8o8
zghrhBPbz69j^E@ODc^yvEN7oP_Pp%(sO)UUkx>&aqPu~nb&~V#R0uhu1k02Y&4cK5
zZP$Il$a2v1%}Kdv8%!4|Lv??GpMEsvym{bMy;_w`Mj|RE2-=g=J~4Bx3g!RY9~p{{
zulG+8RS`5|Oon~x=@DqHQ0l1YDjCXZmsHiV8Z#T_@2ge2k&R6xCGCu)+?Jzfk96ma
z6;n2KQLeQST3}e~KaZL;@Fkw41YMP<o=eQ{k^~YluM^AvdU}Agzf?~6(@YO%yIw%t
zTj7?5@^#h{9^7(Qz(G@J>bbv=m!chGk<UdsydN_dT2S0V75){n>LtzV3)Yqs5g1MA
z)1I!gRMNcObK<!(Y8@g!v!#&OK-FkH4O<hYMlCQ{+k)*paMlkYnB3z&(wYFgJB4)i
zOyo1tQL6gtnu=&A79=V1jLVU?{}wj1WwDommSaAnIfqFb>AqU-0nFy-+HF;d{YIQV
zfi<c76tQ%L3fjcYr0X!ErpV`>Yfp=R_TFF6nN;im(rB7}vd^Laq>?E&(8&lI=8!Ih
zlX@-k)fk@_@kCSXbLYZK8%GzlO5jZ2C~*`+sKx%|y7s0i>X@SC*z1|b#xN$XRdG@a
z{xbcGyZRYqwr$Lb^pvu4L#UCgnzWKCxY0*s7Vz9D`6*LqA6--+Tl~+yk4o9&kwndV
z`CrMx8C9DsU$p=i;J%t&ij$I+e~QM3U#aPFKVQ40e|=>2u7z$}t+$Q>FQ>(gOnJP&
zJg3Hso6q|EcVVATSN7d9O;+2a=94C-W^QS8BUSQrONX?uO!d3!BNEMSElKx+g0lD)
zI3w?V^4Tm#rw$+_rMJ%HdbG-)lt|%gU81*7io7^!pVI8vCd2lHs}l4y#o8@-h`qbL
zo5pC=KhXLcN9~n*+RuMye1uEc*^%Xk&KFjS(d#_oX03+f*V6=Q^C)zEHJ@N#!X(Js
zWSZ1%^3%@1z<Fpr1W|x{Xdkn(tD=kDALyJwN2-$alLZ{tS<=|(`pO30e%-`c|LOk)
z2T>(!qXAy-rlf{=)viyKI;zz%F~DEuQzsg@-tDh8+h6PDJKgi7@6X-i>p;g6vy4Kq
z2g;>6eJ<LOb}JFB56IUK=5f>!vx#(HtZH|u?9e~$N>9YnpA@wi5vT1Kp(_>7;VW#{
zgr_E4&Z8>4udKgQfeiSMgG`sFQlh+tk$%e!*V2slVYbnL$~6C>zbTw=o8~5YgX5)N
zfs)hcl3Kz*?K!CD#rL*ZTYnd|_NIa=YUs)QHf;Ep%BHa4c$I+I>1gXq(aUUXi;pri
ze`Dk0KUQYa>Ghk*=}7+hCdMNQqfXmDq3MzkCu96_Dmqo0eun1Ke{M=mQlUo0gkr1v
z`78tNhGI<gX%`qq&MDp7RilwWZQ9dQPef)y6O}&{;=@OiCrc-iZ6AmMJtZWY82L`8
zO$=@vF3q~fJ1W$9;;EJ8D6u0oA#2Z<^p!}tZb+?o-fx2ylNCI@L%!2|oM`gL(b34@
zyOckh{8QJ6zFJadKBP*N2op6M89n(Ic0c_pB6)nPLF@#5fJLio3s2s$W{~k8_VmzM
zBtVFeETnDeMYpiFwovXfJzAiOV!W-#xXoNe&r-wdUJN}?9y2BbH8V*>$Jh;xXC)O8
zx5{%W!+wpju7C_XuGoz@ld!?w6=$Fq^^FOjON<~clW}Ii4a=5R1F)-0g(H)CZj;Uu
zG5@5e5MQl736sQi{9`0$yA)~Z-EV(0PWX9R1CFl_rf<;jP05mg|3Wz!%p>M@K;mFH
z4qgt!hODR`Hq!GiH@C$I_3rTJSWqnnj@9(lqeK}TD*)-Jaj@RPH_|p;J#U!9pn9s{
z*ey0Ia`q&6raf2@%O|144(oV$EIG1u75<ViGr@8#=3sLrLz`(!Y{Zg#h)b&DS2@h1
z%EXVbyih)k2jVM43!`@_^IQ|py0?qgA;Q6%&-=7HFtbtprA&e#+gCp55xC}E9co%u
z4sbgMe*+axvxm^k+1y5<%dOya?RV6PSyqB)(ET9_cZeD5r9B}P;D)^&)_ITGdB6*h
zNRKEZA}58ooHr&rz<67B#tZf`IRHKC9`V+;tzkRJ$@-T(XqlFRG)cg>5ebGx<S)&{
zAxYV~lqAwn<1Z`P^q_S^YT0r?02jEm$!ixJSLmtBf1t^OSVD{JF*`9bxwoo&Qjar8
zm1yAj9ETSP$M`3dsF>>9yHX(X)#|4r!|Vgmm(NEuG^uV!5tq6a;cG&FQ~-e`<Ds%?
z=tNl`ZRG~MTD5@Dsbd>1#|#_n^-%<wr~*iOP#*V8wLWk(Id5`Q1o3@t6*x%9V7qqM
ztD4{1PgM8L`wcZ2U0%KU*Ax^@b?-8O|05B!(Gko}myXf-l>j#~eQM{-^m^L1It82X
z$<7YTR;|L|zQ(Sinh(u_M4<)A4@=5-(dK9~0{g$G{(HEICy?+tv4*S^hzlR20|RJ|
zdj#-qUy+#wxfly+m1X;`s-fSvaH!>QoNiA%77n#I7z;Qj#xtV(IW(ME=A^MpdIv*i
z14!^L<eyCXfD2xXQmtd_<<(!u^CmF;gwWW&^#i6`I60pzJpUEMeg_Pfg48Gdu&w{v
z0|4bg5Ym{nE3^&VWl6a(&8TK8gihmzxPq*OL47pP<HR}*sG*be*l_>qxDe44cqa{<
zCM-1oTJs#nD`rXP=`$3MmEU+MStO2G-CL2Y3EyKzPcrNE*iCDv{k`12jBHOQbeXmN
z&{lNk=B<N&5@O8;x*W^E(p*ifY3SUW|IAgBnc1#-rj50iY;B0})@*b;L@`^<5MDMf
zYX@AvU$fDAG&0_P-E%2RKeU~OhIX&}CS=w=Ds`;@zaL!k1#0*+rXvmMA7f-!@2rq=
zEIJ%Bafav|ua^4Fjf*@;KCXFNxRGiNJuzWSwMLpor-{&HzH(h0n?~C(Cjes_XIeYq
z4d>t?^4Y=1RYBQMij^lyHbZ1vBaOR_vSD8AvZ>JpAD@^2`APTt7BU@RtB`(CG;WX#
z_RQ5BEu3L1H-hhec<DF=oBGYsKtV=ax=QnOLxypbcWMrBalw50tj9Ot=&Vy_s4qgX
zBhz~_rwC_9Il<9K(ChJpF*L{1O4Q#VPa{-c5s!^n5x<8%z8?a47(I9qC97&{jA~UB
z3k2;ladalHUWkQ!FIsoPYyPD7>R<}E)?MDcQ_fw*nLbfTu<^MrM^PIfd)8=&;~S0}
zZ;jQ-bu}b6zJT$#eF<CjI`X;DYm;DH*>sk*YbI(O@+cIFMGFC(8sY07RwIeZQViuO
zjBtrt^jU>@YI`ozwOJDSV>$bfHQ5nfhQqJEE%KhR?O_;qQQ2VXUiz&6Fl^BJnIerE
zfV{%#F?SkonE|B&XdPyv;0Tn0xQ1R0n(Sl3%Y2fRg?ZH_%DE629uETC5wAh;`RWuL
z9iE;jL*!GKw7e8n)uSpij<cOcjLURWL?8vKD7t_iI{=$!iUKdR+JJo8724g<yrT3*
z{8zCfb|^-?>w`21#NtGL-GQ9jsUi=V80O(sB3FdFkyvTKM3DXS;re)q8URhms>n}^
zgM6Y-hI+JKRypuqI%I)&8)6Q#uC%&{_tk<-0$5CDwabSy=WLpU)(e~s#}TF9#Aq^j
zV%LhCaLhfpz?l+P&iiFya!~10#&Gr#a;$u&sb7g`=A?&1kbV-nz@x{SkI=xL)yB?s
z7ceZT!_UG`Yq!dW>PPpvTQBz-iNr=lRc;BUrOwuw^SFNQPcn}~JrfD>$yg)7X*DER
z;=)u&gq813e_NWhvtX_q0=5whrYL7q2lVAD#S*gh`V!~a45%#K4Qy<_^}O-78d$%|
zt$u9XC+%D$KrtM=;Nvm6+<Wknt(YZlE@NfPujpvrdz9bx54*QzRZdW}=;(*B*;JbH
zdo)L80#TN1_(~LbiDHbGD#r2|3AC>vYyn+5dDI)OCW<T4e`~7ntnp9YRaM;KWgvR}
zYVW_C1d_`JBLr%xc(wpCJY~sL#hjoRFWb{2QjtOH;Eo<^5^#jhn6v*RA<EA3DUcw<
zKWcxA{kCK_TBHSQPli$Wo_Qv<t0UVW?@&LUyPZ&O*kkVlW0(6G?46ekWH0tTyg#eU
zxpmzvd++6$c63iuzZ`?x^6E>d9VT4okqZiaD1j~Ry>Y4c8c)r3IfWu>K$WAcjf**K
z&al;n&39w@?<eEg1`X&E)GsFIwd05Sq3{f6749`?_7qhs;J%)#b)eJ=p`4EivWgP8
zRy5Bef<G0Pa#}=Ec_e9o>{M$DK&Ndiq-oabJRcu4L$>pO&XcbZ9Mv_*$lq*j2kkFc
z<oiODRITdLL<#ambBHe0<Pl+5B#b>AJs=bh*tPB~$MlcPFV$jnbMm}g!5o`;Bp|N1
z28rdpqSDVcn$rbWm7yHBH6NVX%PojfS`Lr+nx|Gy-p5oMELo=1mLQK9dc6&Q5FH6z
z{j5;sG$Uuk?4f^ciLIL{XZ5epRELw@nOK6<+OX-9fXfA%#xzV@BPA4U&>`4LYrQu~
z9$?vOEJj~noJKsZ9H+4HWi??f^_3BNK>plWc_}|UPcxHc@@=~D{dfo$fk-At@tW5H
z^+%7vHBj(&Ewv}pzTH7haUtt)DtP!7hZo0+A|54MfDEj$yQ!Xvprfh!3$*MxEXX&K
za8D^n;zO*wImeWM0wf>%4@FYkiyk3k{2c3?@81WFTzkX3^Z^yj_p3d<dtBq^&Y1QY
z9>+Doh+5(ep1!l<S$sL$+)$*0TCztPl2BVz&6O6N#tm@-!<}iv=@%-cyv`JaL?u}D
z)v$4$c!QVR_m3R>8LF~?6MfW}7i8-mPZ>$(56DC~=I(miVX=mn=U!co=yJEt>##vo
z<2@144><`uy4GVqNF&GPLk<1}i}lKDz?)TQwJg#Y&E&h(Fu+nCCvhV!M<0aM4T%@|
zN+&atOoW&iDjtIbR%dB=!Yz79;~XY1)j;_3$l9^2D?>%+de}VJoQ96*fBy%@vyJZJ
z+Css?b*)(L6K;^gLfy>q&P<Iey}pze0P7W*)DNbJyY=?LMtM_K8V#NoP-O<a`h{aY
zplcFIY>@qhNxFhpbYS>qK}~#7(BP)c&jM}!gnbi(!lHiK-hh`oRKArv@THS%ioaci
zx>@||wtWduQJnP>6$6rh4{Y!kO?(@v>atJk&lWwy%uBfOj*IpC?X-wZe=VI`HHa!e
z<{1g1cL8=H8i}5y&3jZr(&&=zQxRE2Y#6ITN{NBdVyxqJu;W1K7v6S!8&<+143~ki
za$)W=TUO92f}<?d9@SYwVP91&;%$R5HfeH|ce`#>+JS6{$@5DkW;SdXUOZQ6*=c;)
z@39yMnRaH$j>u6l<n8Htr+t@a3qv;Z+Szl8KNaQ}@5x(lr)=P`etw>G!j879lX=~u
zS}<Y7(#3k(dw_xV&d^p8PtSdp8$B<=30td_F~)R1$#W+aq~R)_w$={%HWIGU7Rv@5
z<ROg5mN*gsE?U2_B5TfF16Zj<{so%`P>G*%aI_($dNS-q>uIR%^={dXuX$HKYU=+b
zq}%mpeP%1v(ulJ@G&q5Gz|UV$Z3{K)o4Ql<ma9bNb1G3CxLOqknOplko}T6)8+g}e
zEO|8ny&t>e#s_vfzf)utLROLfo1&7u9B+bgfwK%x_~?$`{NTt3eb$t;9bi(|QHm&T
zok}ZgV8nwK#l^aNOdyhDMY-R2Jj`$O`+I+-i3JQ01zz%mAR$l4B@j5pKmJp>@*K=(
zCL*Qd@F&s`6ZKvPwrDHyGwAiHKC@hKz}$5OV>AG|WklCe-$KBeQF?w7w>;)?i$3N(
zmtvCi57sxWBab!#bEl{12@p$UZ9LIwjH-Kaq*&{urdpyP4dz~^VllD_rksewMJP@U
zM}Rxhdz$pemy2djDTgS;c{4aT4Uu?k-t`clp<sEkAF5@Z)y>FmQ3rb3e~>LzByvQ_
zqD(k)NSY~r#3zmQKYRDzqw9brpkpx}aY^^ml|u_%E{FoqH3|VL;}-XGFCN}DNXgI(
zy~%`tZ)VnmT-gV!RhqnJsWIy#JzBu<2Tw?gQ~J9ez*bqyXM(qX%C~@5xxB4!fqY5)
z3h)GW#diVsCp9DV7=tU6;|Pth;dow)XLBpTaf<EoStZ@`%HAciz%s2e@R?f~S=OL!
z>b+sv50C?TQ|~iVSKip`^rl=1)`{&I!IH**I}yR68)qMSDJQEYkayXD264bd^nDG#
zPx4f7jzLC8I9L%D#!kv*MNAWUsc1Dtdc?>>L`M93x&JQM60r}Gju4khG@#&h3N6Sx
zcjiRsC|J1?4QDMzL;XEX4B>aUX}buOB8(9bFN?01<li7h!%PQr)Y9iBd-CX+jpfvr
zgzNaTqxt~|yF*S?>|UL(?nxH!!3#V+O*vN~xBv{ftiL8Bj+TDb-n1Q0M_R&FG3=pX
zcVhD$f|vg<1jC$cxlPvA+|*)I71$_tCVcPFU&=}M)^D{n0EybZ!uGEs7vO#!zu8`#
zUJ*zhrlw$o5v5!wpE*M4X$SN3z|tk!eWf`WL$ZuUx6ffdTqT3SB7fF!tc)3~eoD{X
z8(twEYJF(KsQ>uSe!Y8`!}}A#U;G2#I;1p&vX$1|UkNk_0?^|7joKA4?Mijp1dDvR
z|6Ko33tO60`%x1U<W~O+b^CxwYn$zJU8pG0lQLIw$R+b(Gv&bx;@buqI_y=RX?{c5
zVu)8!RZyh$5CR7&VggE(yRI4c-<PQ$iGmiO`q*%)q{E`2ECIDEsMRRRa|gsv1nodL
z8B2^$h)A6(<69TyL~Dij7RqHGo~$#|toxyk6d9Mf&q7<UD<!bU!&Ta5&WcWg?#%e6
zwYJ&kU|m2pF%$SNN6|%%vhhCKcXBRYRU`Ji*+KRr`PdEejP<8&kn#OB0L+c6Ib-Pd
zP~uQ57i_*bN8=?do1<!N4oeh)VH<{(cUHK|N#gNlLBy+#1K_+kg9(RyWG&}__stoP
z1((xvQvY$I(xWu6of13)3tx80Ye!I?qcTpD%RX&~bGM$Q;Nt~j@I02J!o)Ez1aqUh
zFL4}H)9D)N6cls>=YS;Zt#H_-;|9>VW-Z4O)-+Z6)@a71OZ>cgw+i${lO<{XkVgNs
znyMBKBIgWHEd<Ug=ai8U<>x#TNCa1{h#TP?Y3IBaw5@(?Y+4eQ<aS<prt?@rb#PKg
z>^G;2r(`8#uQNVyFwFDjTI<f!%Gf?!oYLUhJ=Kb8_|D0turZ$yEDb!3s@5P7oBr3%
z#bfWq58>P#r1zm(y#pZ;d^-EsVBI7HvbZ)JAp_S$jdn5Gu^r?h*0G)P45s8s`{YKl
zK-z2{<EwIA6PbKfA&x>txmOiRYL-tjfQ=cUDs5G4HCru{mdbtyIfI%a&}#DNsn)BD
z`owEEA+>(5WNvx)(=9S6;3;7s=HW)TBo@rBo^v6X(hp`b5sD=1wmi*AvX~c@Ib(uU
z)-(nhM>!1V7lipBAk5`Z5F>#vpacMD3STB9w#a5+^FW}H^#=}SFOrc$Tn7>_evD*q
zL)`(8Zb+X9-zbhMk{k-EDGv@+9hNL!LD*;^OgAzSfNr~np+cbkA!a0hy6g+xuzOgK
zT6h!EH31Iz{VFqcgDr%*aC5<&$fY14^y-9@1LVg(Ke_HGTY>O*rI8Sp-vG(`xr$fR
zL_7BA*`5*;Gy;F|2P^<i{%KvM1rf}p!DyU@_37GC;3U^Py7`$$p}?KEru(YPvBycA
zi@Qu$AY4Qfjy-6wo>}ord=0t$42l?4sFtZc!O#P}#w&$FkXy7^)-uo+67>ZLtU2`l
z0!6DHpPO-+A~5jK)hfL_kyd_jZH9t1B_YC3D`*h=id6^+^>A*zJbp+uo5znQkMZ~q
zn;_L7n#s;TJ(m(NR)O8O_Ed!VXvbHLSTz=yF8rH@$CN4*M_?TFuwsno&gtC*^8Gby
z7^q67?F2&l*Srd&wgQ`LXfGj5wimmJ?*l+(l`y@hdxTSS+G}d&CAa1BB||o?MHwfb
z)#k_Y^Fr$o&KltTsP7k?A@)U4=@tIR<_BhH#I}DV+r62Uh7C-lnmY|$w!_i!&H;+y
zB`2d(<&++a_psBYle2zo<L=mkC6jcT149B#GfnJ=?<kq%mMxqV(xBZYv)gYOt?EOO
z+%Ln~`dIR&9K=tjh9$Jv6>X9ro^*O$h-Sjl0>aLjH}yVkn|AkH4^J@G)S<5Z%}xe8
z_&lyBml~0jUe<J@09vjgZqSRC<+3Im<+Naz0q@VyBeG?OeuhbvX-3T=EEM)4VvwEH
zS{m$lwOF?-eM8SoGFhvQoNO!o&>klXssGcQC1vn(i=ik8(P_Ct=Q~KCLmh?Mas>KC
zLgR#t0utD$a^7|RBKOIteX?WTAj!e`M?k_}ss$oj8fS^t?aXD>)Jf>sN%qAj*drv3
z6c^i95lr{7h+_WYzY3Iei+nNx6>6;>X&U0s-3D|cl-uePgL-kWD`Iz8emOeJ{)AtF
zYm>TU(<($qKIQ5{a~i@y8I>N$#8C-CbTeOD7_w#mN3!C#Iv>HrM^a5u22G`<WC?m2
z20gf2t&K<W8)fO<!!#nyF+TcJC_u3%p>h``D$@@yZf>}T6p5ZJfg$+@0xclvnEx<E
z?y<DrZTfTk37IvT%Jx<Vl35t?&|oWQ_sOei^GNA`h<}aOhR8XE$UH`tNAS41$!iwO
zl_NN#(2IBQ!BfcOP83OL@M&8?!FkwD;P7Zk#F6`-j2?(RoVjB?Ppl19WV{pzeO36#
zQ_;Wv#WG>9q=CF|z?VB*#`&ICO2sAOy}Ym$qc?c7UakgAHth3Dxew3hKDg{rU&o-t
z^AT0_)pFcy=w`G+l^8u8KI(qBjmKv7T!S$ttHk2u;+oyHqFLkDnjyo654R1uqt?AK
z&#}8UrOg^3j1Uug9tI)9g~v0)^ap%kD6aEpscVY$`ODE_v@P1`=FHdwu1y|(tgvZm
zn-nAhj@az_Wpt4C&ug9LNinF@89J@9EEJ>?8gg(Pds~>AuNb@%wk~PQBRHdB8u}Uv
z8P(b&^e^5|^(wKWNVH`V=PY>yadBsBK6fnjEK;XJ*yN=n<9F7=X&J;{tztWyUYA3J
zd>|TBVwJptxMA;p@7>-mnPX^+^CDdj81Ztf(5->xGer$Wgmk*2LA|gaFi8&Nd@v?_
zdHd7v=1LFkDA=}vm^_KtE!t^LO%d5*UbkERd4yQ5AyA*vlxcm8o{A`3ohiJ?H>Xfh
zF6;2Bp!{zI4}vttj>;5;hXW@#4+%x^y+3$6>&mi0vHX}`pN;fJqNZVr;1S`RGn-+=
zI>jV#zTh(4_R#~r!&!Af)z|Mm4(PU{RqQNR`R*t8g}XN1W)t+j+P3gWO+c0~M{T1W
zuAXAFBDQ5+!tG<`q^q`eY-v?$=IRNy$g*5FeJwnhiQiS?i^o7$J&#u-@>MQf8_J!{
z=^E3>v9F_PTL#>i{`xk}(}4P7Gpai4VzNzAK+g*?+mtETzzygQheUTJKTy1rRA<st
zpfl;MS&z#ey8F6ME9mApGdHRQ7Utw;H9*O(CPeYt1jT*D!;K{YIU&a0`9?eUnqH)o
zba{;tsvhd;TzaXRQsypcdfJzOOS;mgYbi~)BRLQ7m`AO^uWzV7m%LZ!E?VWlU5Iq>
zjcSf7E9k2}=7|HU1ZUKqsH)0tz@u7@z<XWhohj;rHS-J$40v5atr+?B(%oRMHNRfM
z7nrb@pP_UCp_R?ppY^Sw&j(q+>$qN>Otqz6{@>_t+Qn$7<q`0iF=RcaDOMxfiGFE$
z@&YY~%Ekh=PVso_h7kbO86To@bH`7Hv7mILEa@97gY(BF<e}}U4%z<#eQItYOvD&Y
zbwW)b-*qdN!N8VWSnQN4FYi~wx|JA8%?{|{-WGoq$$)dO1CIIFF9k}EgCE7XpV-SR
zUd8;bu0pU@j!lV^LX2)thD}9xUb=QL8JV96B=MR<mAQQNH<?FFz!54@zO!v5!oJ@4
zlgZWG%Nk%!gc^tfuRHuGZsw!A%x`|(Y_5<Uxt7KPlm~|zMT*Me^Mzv5(mIO#T(yfT
zGe`LAS8VDw(eBOn{dHJ?zjkC>9VqzNf$yp?b&%tH8QAwpN8${htEzMU&Fi)P17o>I
zlj%!u%LUI~7Ctzp>7KH~EeU<FG#{1Sp6i_WiBexCfLjW3zxbO^Kqsr>#Jo(ZMV)hs
z-eTQAWY>f8>K9{^2Mad{Rwu-TY^P1Z6PK&b5Ujso`2w^;^z=>346>e;Uva3uRNGYa
z$y>YQ`*iK%Kx>?*@x-cYACs8fG+H#~v*=P_T|X|kzzv}`dbwT2k)y{4b3Z4nGvYj%
z*#yvjcfIOe_?zVMt|kHhgWBb9Vut6q5nfxMOlpC}jlGW@4!!J!c4>7iZ9)0}zJbN7
zE^AK>UBM@OI>REsd~FcL82nGeT}ajj5(tmrAIHQy)zW~tFWxL2f*CjaNze6v;}Lbr
zQPV|0OW{h1*eykXQ$rfIn@9IcjR7$(A^u(G1wZI6r!z_P^x!#~<515nHg#8riDqzU
z5%h;Sx4Jb9lebB>i@ey+FEt$HCY<)n*crV}VT*MdEt#A!#l|#+z9+;OgvKipUH+7X
z)+~B;=Lt38yWDOFz3pK$c2x@;sq9wX{tvL!g-LX=_Yw`nO)7z-CmQgVSzQB?2!ytX
z@1dtsoxbQEhB#$;F@hikLX&Lb%F<;)a$rP{eT_t38=RAdkd5F}8t_s@4QTC`a^O&g
zAm%<r+aIPuesH#;v9}l$8Lu-DX)<s`&!b|Z@g;hOVx{vn7e<-&j7E62=B}IoK@Y+D
z2S2e5Q!3TONAK)bjO?%$sV3VSrQkvVa;j=df?@^OeN~#gc*KtNy560fuK1VD)!2m-
zu`fB0@mC%{|4Hk}N5kL+=}eI^&zf@?(iL4BWExfMf~@@ipr#zSm1l-ewX!Dk@y8Br
z+f=|h?X$2G?~>O0^xJ3K#L-^uwU(F`fGG(SZ{=29Ru4neYyQUa=5T82?R?X3dsMXn
zCcfEEr1!5sXOobAD_3zzzmsZ`jAfnJHhRFjNvud*>9j9OHrptChnGozDuxL-+A0{G
z(7yEq=NcTQjLDB5DUr_gaMV@OHZEMtMeQ=84K+O^EmTr+^_Hg!$+v(f*^HN~d}wP%
z%2!1uP3iQ_V_NzWKN@NwuM@<vQ3^Cn|E$uACBMcdUEB1FZ-wQ4s-%9Z{rPtDIUw4^
zKTsiK{LqAkih5b>-qwqXp(L29x9DDRBaJT7?Um#}-PAMa3{P}PNPiQj@+%ukoQJl+
z0wOj7arm=SwX~-sxglw{N_P2A1$z5g7<9ePjvU&bicQO(pDvPqUZ`i2+){gcn|QRF
z9^OMOg?K8zGspJrxRwan?%Cj<^cgML_I6f7Y^v|5-hgv~qz_yRw_#5{z7(yCiLpBp
zwHb=Q#WZ*`=o_HoZmU1O^sXeXj~4#{D=Sj->Qwes#&y<XAGqqajBUq4_{T4CbJ5Gw
z$h11+x+tEomPof_{7&nvbLzcaSMXlt`MqwOgrhz5(xV2GV)MU)7XcFFA+fnWL%bi%
z+>S2y|3;|*5{=%mz>cJ@)!Jh3UT8`>ZKJi}Z7vn@_nADIl>guS%x|wCtZ=AzhWUx7
z^!6u<$F6-VwzYcWd#>qBSQ-|0hA{QiLLF8WX1SF9s@WE9zbQ7!)p$ZKsKN19qe#io
zyGzbdoaduP+kStfZ@>}!#Id3#fuck4wB$SKXKkR{8NJu(;=iQfN$a4pou2IdrAAu<
zzRfe4s%~BtzD<c62>K9b;^eBNA3{IOOy8I^8_F4U&1#sY?~*3s_gi=c-l%#n|Ae<K
zY#hQO8Gex)O^c=65?`;yA^fq7O39>iFV?@s-~79~q4W?4&Oj6D1M2d9?&|@)=>i8^
z=gA0-Ak;2*OLv0I!*>Tz&f7re2p|UlaT5TrbO1FW0B`^R|8MVoW_#w@Z}`xoQsc4>
zLA%3#CVXH_EyKONo4wo9^WNLr)iI}c<tLN-$_G1l(XG1F(Mj)CtkSu%w+homjiV(Y
zAxm3X07EkXG$R0JPyqc6Pup6rZfnp@Hcd3pfP_SG;i<k>wxH5F3F~z)w+h#`X^j~n
zvC<CP6eSR(?%F2Gj)AteYGhJ{5KdGPK?SEWMx&<qN{LjH_<=`)P^L-tn*bvK05k>$
zB18b!Qx(N9z!XL2#@NTpXq##G5|ZS!-Wj}ddCTuVrOp;u#!}!q-Vm7NC}sxb@)$~1
z2n#hp8cZX(d#7TWLN9f}7h_5b*&DRbG>}<Yv&K@F&SW&4AvdMu>f+&)&Sfqkpu~3q
zA&Metm2o)VA2w%<@FU0kB*X()*ifces~7bCIAsgIh3O^fR>@C4D_z+54kZX7C53Eo
zAylL0FEI)&nDz_Z`w^3|Qky~}P|5`)%5UG{?cQjHFClo$n_pNI-!$^FQD4T=Rl@`6
zV#;+#juZ|B{BDcoLeoO=p9dGJiMN1f|6(sq?+pDs!buUt8FY?XIZq1LOT$ZHa(TK(
zO*#si%yg;`%?D1f4viO+f1cc9CN#x2ozmF6I#h&}N*}2-7$;M&J&Pd-<7TGdrlNxz
zkWC<yk#p}ttPICkAS$F(hSEDV9J#0hYi>*rb)x|qY&t?EcSBc71~!5<QgYU`&qCw%
zLpzifbRaPc<qCQdb>s!i6Hp^^i4WE0BpZo5xqyEHGGw6|$#(VUHZDXVd2t@mlyt@>
zp`Pn-QVFtAi%Afs(MOuL|H}9nQWi!cM#4hMme_|7GB3WG=1^5oxg)JG#ec3ckufs!
zSbDNXT$PH^EN<ZlH^gkxczxfV$%OEYsoo(lm*lw^e<yB#A@D}HrK)_W$PZIgn<{@v
zA~0+|p)5gA#Z-~(3{ir&Bz^kI-_nIYWDk<%P*c!@Vd5Hy`H(?uksQZvTq<3%5_&9L
zJ8q^Xxs~Xb1fwSYAPccZmJ6AjT&1pWtL0{#H`U(d8&r@Az2D(m;vf0wL%+*ll-{Ro
zkOsSksdHA*uzu2v@xKeWiXCg~gfjQ#F7R~onOKg3-xL;Tf6mI75|_~PyM-VAS`ooi
z7EHp&Gb4T>z*m!0c4V)LH&LT4zeeFrL6jj)XgfJVl2YbnO)exOC0(5sc~H)I<)s@p
zcu|E7qrOFIO5Uf4l5n#^w@8cXHI%}>dz2k1mZ+dNaoX3vQS?tTRj;QSI`m)n3ZF_L
z+;|4$VVd-wgcps8=<Uf=Xi(5X;h*gbW>Xy8NOl%DAfDIpy?$z+kasF7<1%k?pwqvi
z=$n+gvH@{Lnj1MS{uTaV;pyDv!k?PCpi_OD?-Cm`G$|5Otq#(6k589WPzIT!riFXG
z_{CEx9Lc0PndW4tdbZ+C5*UhTjZLKL`$rg0(II@KR)ZVLxcu|4zms{uWE_2#<IZwE
z(Q`C0(iwC}=IL8s3y{(>{(qW>n5lt%FNy7tVhE~k-HF`FeD<pn#Y_6<!y+idNwW$o
z76~DqrTR4=y3<s;sT^lVwIw@~I@Rb|$6~X9@2>DF!~wH_6WhTe!)tKd4^R@x%orzN
zHHOW)kntFcNlDDxE{f1XT4u2i_3@TYJDiQ!%SXR6{zIIg@DiaDT!7M#Fh?Zxo7syB
zw-JV-6!DHqPw5~>UTF`^(dX1j0q*WekLuuv-jyWmBUs0$^F9U{th*CKdff;=lu)6x
zcv7vBUY#1A)e8qWlk<;(=XRtbCfTI{eJU{-3QIpF9b}?|zzn4)8N%BictmU=h5KAD
z-1ynY@f1$q@1Ei5QMtqAqf}+|Ut4N^8}29IJ^qWf*5nXX{76Pe=Ixx$TZ@|t??CdP
zU#^u&v*Aw8^TifOiY#&E#P4ZNs<ypVD^>E}_z(q9;m9(YlbuRrjZ2yss-LVs=n3-M
z+At%-&iqx<ShJ5$B!dzXA#?elze~pZrYtBrTa!0_tcU<Ni~Jy6b9B%Q{UB04H_^uw
zUVY;9VR`|lM_yE8CWpehx>$sbPF+9YO-6t5tsg7Ms^eIpKk-=}>#{@rP7iJOk@YW1
z95lC#6}eV^#lM6e{%#Q7$FVKLUS%WnYs=)S!fSVxLAKa5&2Oc@*uFks8?l8<2QR5;
zM2#q3Z&A>AcBo>MXFr)FbF+fXi;){GC$O4Ac`x=0DSdjXWLhYb#xxG7yI`I=|E6G?
zgTsPkI0PYKW$!j|w+&B%Bf0zu<#Ww6C6Y+G!lOJM*I6W6jH%9y!p5^w{F=H7nQ?{G
z<5#o4OtmqE$CCv1&FGTADTiIM)o1JUy!v+3`I_bU{(!f%Z@CiiuZDMhj&YsHe4*)c
zHl__1RFFc;LB$^O!7`SsC$;s>1MdjumF25dRETuqrV#1=k=zw3@zbA7c9TsqxT^|2
zRn75^wO7?N3+iOC=N>o6;Kyytq{jBw<B^`M$bIc(B5dx~)}TLXF?+D~H>Rc8&8;D`
zuPp=gJzcTvStJf3_I>S>#cqS}F4^QB#`4DxWX^Usl`|(-*rzoyI)gkIVbs(woTeRx
zXEDYwTD%Yb<Z?Kz$5;-ft^<n+f7Tnld)UR0!rlMZu!-(A{$#l^6@(5B+pu3)tc8rg
z)2o|4hZ`2;8pQ3<-xu?AH^p{#6Y1#7(|fb_W`+~<47!Ef<}TS^a4XVKm+6peuKIK+
z$JFO=ag1FyqS3kVN%lAPrW*$WU-T8`@vvPxCP3do&#qe9HnHqtJUmJk`**kL_L0mu
z=C#?q(^2<TM!&7m`ps!4uAlzLlB9Uq#OIuwIGXF{xshut<|bhkEcRt|yAJ8G#yL5D
z1>aPyf~}rbE%Do}7o7MjYF$zn*qYV4lHcae%D-VRvHG6WWDc?TPi5WrX<V`Evrg=5
z1obV~ljiPAeseJH{m*;I*<^0YoFk9JIhD|AItLTSPE&xtH@+TC@kRXw?;GXl>1S9b
zTIgxv352@nhq|W+Tg?zz!ApLhZIJtLtxxC2Me@X5snSk8XZ)p0cO{;n%LkHLHky)e
zZdlFRYXxU<+ObEIoH7O#gnf6s=v~OZGx99?R(1hEhX$=J+`M?_IWjD}HE`UCH=71~
zlfLUvbDpHIU%Bsv(#DAAx1t||6t8-%nD3&MIGsA1-j}VQbPtlQZwZ=Dk-D+kH?9_I
zcJ^+2V`Oc9XxZa1qaodvnVCWKH@?sJx27XHXkix9X$o~hA!z7wyB*fzXJajiIgR_g
zvMhDtE7qlYgE4PfU+GLxYUG<#ec3&b7hM(01t02CX0!s2K<OF1o``mc?(7oL%*I&P
znXEzY03lNB0)*5Eeu!*#M7kKg@?Q%#CejYtv$<TIu!O1|`_<8g!&hXMJVQ&#jS-7&
zj1#V3k}hNFE?1ap7d+83!n(Yqar^Mvn3Z#`+W&dN9d;6U;=$&1_Qj?L$Ji5aysAZB
za_(0pXxZ}*3jA{~S?@!N`D^p6vs3wd4P0Syk_vLl`3nV~`+FGHKbmj_C~junHoRSH
ztqOihLMha=?_{0K^{w}R`m|irC?$IVRnS(xT=t<LWkf6S2$`PO>yBuF=*%t^&1sBu
zoxmFP4iF;EE=Nd);DpFwN8F69+qwC*f!ordQJ$!3InI~D6HsYVr*&_+{hiL4Uy05;
zzC?9Tmq2#Gx(at<vammi(tHGvZLFtEFU%|@`HlTac>~G)IHHP2mYTSm0?bX9<c@|r
z^=m^?=)s65TT}T#dW)^H8F?`;LqiG*8mnwOdy5%U37bs)CilzAX3T@*d?YV_fy2)C
zMV0!m^R5b6=UHKRkvtxvCOwA#U>q?eYxYYU5OJn%%OR)*#J6nr-^<ya#yd#H?ns`e
z0FCr@*<KRN_fm+k_meyHxb74cRH1;rbFQ*6WDl|^un%!d++O$=-b3zqq79h3imW-O
ziCK><ik9wvgW*6Qnn4?=K^cyS`zoOxGRL6oS1VHV#y+PJqh}yLDxYN}GwN`v4I?xS
zg@T(P%Tlbu8G?&r-%taRIZRTiAkLX^wAm(T*xdgUij+bQ$8+{~W%k}$jBze*%Lsm?
zA0K!M4QayurJhug2E+=o!&oV%PD8$U2*&-N>_S?urVHlCv9%v*Wh5z!R@~g>ac(?}
z(2uCmJe`t@Y@LHDkU<&8iN=4w-ZRSsE`R}Gz!)$F3;_ecfV_XK)Lw|u%_*Qz?)+!F
z0CP1fDa8tPvUfIRHysJE3xEM&z!)$F3;_ecfG}VT82JaCRa7sDc-YOOP*?VethW3w
zM^mP`Nf>Yj3;_ecfG}VT7y|}?9S00c_PQs0`;#XL9`UOMS7SI_%iXa<gN;dS>p0*v
z3|j!Zmyhsahke2B@`DS-)z0$B3zO$D8Uut+Smq{OacGrzNQ+tS2L26R4De58py14R
z0mTK(?xla>8?9G9#{hkq1!%XB!W`|^7a!gDiS!$?pu7Sj3kKi(4d)b)tAH<hPzG-p
zI4td?D&)UhoWSs#k~O~9@jEjmej1tvzp*c(VAFzwr5KQQfs4;UPy}G(p?@5J;W%tQ
zFo7=YLBfnzIiSl+-7y*kUmWJACcya_Z-nwd2ccm9;)xuD>OfXY3{~-`1H+g0sb0W|
zo)b+zZRmL^**g?gX*V7?^$Z~o-T_wl_{6}jy*o^{YhLbN9Ab0|=8`uchR;p>m_=|j
zMw}M1_!R{l9o~C}AOhMLUPC$DMJyDh&5rWu24?}si|rXtjSnWcoPQM(Bz)KM37%q%
z-!@<|_=a%6ie?XhTL#c@*Z^ANxHMJ1ps<1O77Qja8U-;{lm7q<5@qfia5sRq_u(fC
zcuwy_umz58{1cac7xHO4YWXtnijoJD1qkD^J3xNT4~?Jc;Two2fZk(*P6@7tcVHGD
zG<$81Yug6G<68`Af&O<-t*{9I<@M-(cR(=JaeR<NqTT|7tn1=K@fUz-NQ1en9sD3Z
zUk3ESJ=_f_7=QsR2G<v<qxhI_Aomyt7C}9IkMJWZq`4{}mjxcv>wF*rwdCWBpx?O|
zhWGf2j!=hQRluwP<9dLpBp2?&&!n#6hYE1G7?yZ}NYxea0Vo3SIC^j_P#3>Buqb`p
zVB$cy^ssz06;n0%{JjnzF#+FtMh`j$kQ*<Y4;F~UU>vv&@N)X`2eaS<z(H|>)TM>w
z#hUtzbetLe0XV&{_yaH0^!ekaknB#{DF70mOQ43HOF@;&YKlQFFtZ?7YCl~8d8QX&
zK)`@I^+in<00DSDXEdH={`|D~(LK6>T?Rt!B^s^(9hu!oxAf7uK(VU>qvI2+sr=vp
zO?z;QS{wyf72*Jpes&APe02la1<>gr4EGuWcYnIos0W9l;*blo=fLb5W`6bq$N_L>
zLh<i4fr5veZzy<{+Gi+u{$3~qnkimnz!HOd>7%(l;lHZj8{Qhw>C(Xr1Je`2<Reu}
z*WQm@34q`My;n!_t1#8KC49{D63yKHV{7gJ(qgLy*8py&vcLN0d{stG0ZdZGVuYj>
z{4zo+LlT$FHMiw$YYup3sw|x<K2r<vn&*jiLDtsqsA_xrj07duDWVG7mQD2zZG93X
zd`?2H9iHvwV1a}edal|eU2eZv&JHbe!0HMojfnYRWbVI8b0(N#@g3o_W}tTTV)Q2G
zYLz(Cg1iOC@6Mb+Ru}D6uV2qcr_2C<eaNe<&u?J%Ov1HQ{IP0Q{yrHc9$kIl_g<t9
zx0;LHS3toIOg-@|pHElO@u<m*a|)~Z$Kd#9OBAkzKbj7$3G=v*dn@lpwnILqa!vTw
zP~ZHw-H<9WFtk*!xuU<xGsD`MR^gGU=;GjxAXoUJiYw|}?RKkKwex7&u6^bzNTTgv
zkklJ<5E-!dTb{s?5ZDTAZH{+z4M_zsmHWw!#yf5DwAPq^4^1v3C#Fw(PQ&_BAu6~W
zWi>AwXZ~<|YAGPdAQew6D&oB>=OzB7LISq=s`R=GO9Qsp@~31~%%+#(K;xpdv8xXU
zZ@u|131XtuDsmu%3E23GMO?ia9j$2RlEE5GFq2`*`7gVH%T02hLZ}3YQuqaDu|r=e
zh(Yj7OCILHX=0VW1)N8t{<6r=&8Yma=h$sk=H(;EMauC@U{dZNYxcHH>FC|9VAaU-
znlk@Ay*dN6V(rzz<Vvu?<a}z0sT#18;pTBwYS8*}EY?EG3fifegov!2)!y>ZbU-oK
zq)y!Q(@6BWu}d?Qnz%t^MJ>dx-R)_A%#0@~$g9}7U?am7x87_`caTS+LQ}x4_Y>&j
zs0Vs`E>(Kb(}or^T8@=AOxj^=zNyQvu^2v1j&|y1d9~dm#!s-te~8(mg0-W&7W)RD
zy~DK|AyR$s)8gbxM}oszups71{womfBLuuRo1qu}8fy)efs1#u1vD~>Uk0fCqg6L>
z%Mg_jZ&}0c%c~9PhsoKGj@-+jD&pY8#oH}$czc?wy&{L@R?}pdm1aZVa<Tx53lq(t
ziq^@Fky#e;yn~b|_R6VO{>D{53nQqbp)OPBs!`?JXvFBuF5*2h$McO>EdOpfvz#Rz
z(~c_&EOPedb=)v|eU(irPAwgUoc@Ro_*fYx$Ns_X<{Q(zJRdAWp{!SMy@D6LfY#|N
z{DO1U|3D;d-X6K2S&0_C9VcJCX+cc|O?}F}dV46hsLN#6F?G3Q(24<3!F2CgP~%fN
zv0t?yYeTHkB*33p--Lm7i#KIozhG&@ocj)Z$r<PTnQ9tw6_5Md&Mf>TOwF|C7q!u_
z!7Ry7>L*}7emk<0Z$|r_0(+>d1=6h^{156Cm!6cXj<17@f=(C36$xJ&CO4c*Lin-F
zP00>~@4WB8|LX5bm>-YAb0GinJvwcC0~EFfxLT&M;Ni%Dlcy%6Q?Oc-^e6x7(GA>|
z^llJZ&`h`KY5*vUXt|(wZ6BpWCp%mX%%*djYu#cd<UE()WDyuO(n)@zt|oaLJH-iq
zzh&z7y^@T?xplaJM<vZ{6aMB^Z`4>yAB6prlqjt+4rN*7EVS%~3YKz&^u~H)Fj8c7
zxn6d8vs3+&RBHdD*`>AY!UlA#V*=(Y&_7bL>!lpYdkNpvM|(^7k0sEQGR|n()Kps<
z4GB3b!Ei!&<+{zxI*@75I^HVl-<mKl{)Apu^@tU>M-<w|(%DhJNL%7x-b+~N5?;f#
z^F1T03V{2GC;V<AQ~x_iRFGEt`maY5{xII*(6u@FfDcz-l}YWr+D%yJ|3Vs)Zc~N!
zglMI2Plqcoy<@qW4Ek>d)OH_6iNa2@ZV{eo-{`eX_+HQPo*z8Z`G5INN!?Y-_E&k`
z_vI;+ee#sbzjsO{XNCVP63@R0M{AN*B1!j6<8|Uzf0q|x!(?qL{96fb{H6)nM=&*#
zxeV=O!nTxat;`55-*4?m4MO^IWdt#`lbc#q*aMrHo-$IfN(iOzxBg<kB&1%lv}*0V
zD#c!rreysf(OGY;RHcRue2r=+{=ysyua)4_w6%R<v9X#Zv8m#$SMxMlJLS%)<r7ay
zPn7AZF+0`!&Q%gKQt_;F#NyGT)YDCNQT2}ZR)nvVh;2rHM(}bM8n!kt#vdf5R4XjZ
z_|wa?&zTZiC{Acv35OGhD?LvoKGieQN!1freQHS3knNqJ;~~MBg(FNP;gMQJqEoej
z9xcC-D1~iMPOv+U*zbXaOll-NQ*COwXydizzQj`Ukcr(#FZ`AMO((2%`@MJ3hEo|K
z)gS+qGr6Rhs*tJ0O2y*AtFYE;bFtWKC+?mJkS;&|ni)Qvs;+)7%hn$fM)gyKl9;8|
zX%AAAPnu0(lcSG7-M-FahnMYU%xWjbj68L|&Lm#XOA>4;Es!>;Hz(}aMo(4Tf$+YT
zJvtK!%Nm1>MUszE<5u-yYde@0#!;MXp&PSyO(`-z(EepIslC+C-k*ejmu8Qggj1^m
z^UG>pn+eNRmGHl`5_*sNY6MXA%hhxkc0UzMzeo2@z|_wYrK*|eDhW;#S}TX5hAgfA
z|3?>Q|BEVK38;56w5J&`77}efDdOk27!QVhXxtfXVN(z3<Tgh9v}Oy4zdoI{Ox%}t
z_utJN<V*h{+&ni?2%hUF<TFbT7cTy;ACh*x4A^^XGP7lOMX%iU`_PQA9X}+0pOc?X
zK-)E=y62yIta(M`r&>zNqM1ZH>DnVZ<X;gkB}Dt+-965s`y}iz3WV2tg84i26AWfO
zfx0W&opVzV>Ytq_VwAnCzxp5oAuQ7pEwu3w(2MwDT<#o)r(!+47=1gcbr-*x*6MX3
z-Jr*WBlkWJTEp5wPJrGB-=c46F9eHTM*0odz4v)BE_a44TLrIvgM@dDQ-pX#$)J~s
z{8K7=5ke!oYA$NjyQMLW<jeldKKzACAT-_(c7(rl2ShlQbuzCqF;<DK@kiRcdvM!r
zk7qX8vZro{_V}AGf=AXnMAZN8+|jN#kRs1$3)kk4<T=_Ru8dXNiKj&qO*Pu0GU;cD
zP}*-10ckSLlL)2+wvP5%M6@jta$J}9eUaW$7ViSGt;hSGnq18#D(Dfg2e(<G?*8|m
zlasek_1l#+VKH)Lv#LF<Cn=jwG}XR|4BETVp8Y$ysrwb8Sew1wV(b?Y)oCKW<95-o
z%_bs`|BH5awn)8vo2Z}>x@s@>on)SMHGAD_wxbXK$XK(AX7>MNg0fC%b^Vw*pe7N(
z&4?K7cai<QTuoeR;+VhQhR#nClj?c<q?AC!I;U$}*Fvrj-G{9RPxwdQM(~M59)De(
ze90`{S02t2tZljjfp6M-ap~_QwrLM<sAliR=%RO$k<+V0(@;GTC4M%porJTe_xP6<
YloM(DzZd`p3;_ecfG}VT82kqS5Dd#@CIA2c

literal 0
HcmV?d00001

diff --git a/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/AssemblyInfo.cs b/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/AssemblyInfo.cs
new file mode 100644
index 000000000..724c5347f
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/AssemblyInfo.cs
@@ -0,0 +1,58 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+//
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+//
+[assembly: AssemblyTitle("DotZLib")]
+[assembly: AssemblyDescription(".Net bindings for ZLib compression dll 1.2.x")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("Henrik Ravn")]
+[assembly: AssemblyProduct("")]
+[assembly: AssemblyCopyright("(c) 2004 by Henrik Ravn")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+//
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers
+// by using the '*' as shown below:
+
+[assembly: AssemblyVersion("1.0.*")]
+
+//
+// In order to sign your assembly you must specify a key to use. Refer to the
+// Microsoft .NET Framework documentation for more information on assembly signing.
+//
+// Use the attributes below to control which key is used for signing.
+//
+// Notes:
+//   (*) If no key is specified, the assembly is not signed.
+//   (*) KeyName refers to a key that has been installed in the Crypto Service
+//       Provider (CSP) on your machine. KeyFile refers to a file which contains
+//       a key.
+//   (*) If the KeyFile and the KeyName values are both specified, the
+//       following processing occurs:
+//       (1) If the KeyName can be found in the CSP, that key is used.
+//       (2) If the KeyName does not exist and the KeyFile does exist, the key
+//           in the KeyFile is installed into the CSP and used.
+//   (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility.
+//       When specifying the KeyFile, the location of the KeyFile should be
+//       relative to the project output directory which is
+//       %Project Directory%\obj\<configuration>. For example, if your KeyFile is
+//       located in the project directory, you would specify the AssemblyKeyFile
+//       attribute as [assembly: AssemblyKeyFile("..\\..\\mykey.snk")]
+//   (*) Delay Signing is an advanced option - see the Microsoft .NET Framework
+//       documentation for more information on this.
+//
+[assembly: AssemblyDelaySign(false)]
+[assembly: AssemblyKeyFile("")]
+[assembly: AssemblyKeyName("")]
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/ChecksumImpl.cs b/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/ChecksumImpl.cs
new file mode 100644
index 000000000..cd1ef44eb
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/ChecksumImpl.cs
@@ -0,0 +1,202 @@
+//
+// © Copyright Henrik Ravn 2004
+//
+// Use, modification and distribution are subject to the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+
+
+namespace DotZLib
+{
+    #region ChecksumGeneratorBase
+    /// <summary>
+    /// Implements the common functionality needed for all <see cref="ChecksumGenerator"/>s
+    /// </summary>
+    /// <example></example>
+    public abstract class ChecksumGeneratorBase : ChecksumGenerator
+    {
+        /// <summary>
+        /// The value of the current checksum
+        /// </summary>
+        protected uint _current;
+
+        /// <summary>
+        /// Initializes a new instance of the checksum generator base - the current checksum is
+        /// set to zero
+        /// </summary>
+        public ChecksumGeneratorBase()
+        {
+            _current = 0;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the checksum generator basewith a specified value
+        /// </summary>
+        /// <param name="initialValue">The value to set the current checksum to</param>
+        public ChecksumGeneratorBase(uint initialValue)
+        {
+            _current = initialValue;
+        }
+
+        /// <summary>
+        /// Resets the current checksum to zero
+        /// </summary>
+        public void Reset() { _current = 0; }
+
+        /// <summary>
+        /// Gets the current checksum value
+        /// </summary>
+        public uint Value { get { return _current; } }
+
+        /// <summary>
+        /// Updates the current checksum with part of an array of bytes
+        /// </summary>
+        /// <param name="data">The data to update the checksum with</param>
+        /// <param name="offset">Where in <c>data</c> to start updating</param>
+        /// <param name="count">The number of bytes from <c>data</c> to use</param>
+        /// <exception cref="ArgumentException">The sum of offset and count is larger than the length of <c>data</c></exception>
+        /// <exception cref="NullReferenceException"><c>data</c> is a null reference</exception>
+        /// <exception cref="ArgumentOutOfRangeException">Offset or count is negative.</exception>
+        /// <remarks>All the other <c>Update</c> methods are implmeneted in terms of this one.
+        /// This is therefore the only method a derived class has to implement</remarks>
+        public abstract void Update(byte[] data, int offset, int count);
+
+        /// <summary>
+        /// Updates the current checksum with an array of bytes.
+        /// </summary>
+        /// <param name="data">The data to update the checksum with</param>
+        public void Update(byte[] data)
+        {
+            Update(data, 0, data.Length);
+        }
+
+        /// <summary>
+        /// Updates the current checksum with the data from a string
+        /// </summary>
+        /// <param name="data">The string to update the checksum with</param>
+        /// <remarks>The characters in the string are converted by the UTF-8 encoding</remarks>
+        public void Update(string data)
+        {
+			Update(Encoding.UTF8.GetBytes(data));
+        }
+
+        /// <summary>
+        /// Updates the current checksum with the data from a string, using a specific encoding
+        /// </summary>
+        /// <param name="data">The string to update the checksum with</param>
+        /// <param name="encoding">The encoding to use</param>
+        public void Update(string data, Encoding encoding)
+        {
+            Update(encoding.GetBytes(data));
+        }
+
+    }
+    #endregion
+
+    #region CRC32
+    /// <summary>
+    /// Implements a CRC32 checksum generator
+    /// </summary>
+    public sealed class CRC32Checksum : ChecksumGeneratorBase
+    {
+        #region DLL imports
+
+        [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
+        private static extern uint crc32(uint crc, int data, uint length);
+
+        #endregion
+
+        /// <summary>
+        /// Initializes a new instance of the CRC32 checksum generator
+        /// </summary>
+        public CRC32Checksum() : base() {}
+
+        /// <summary>
+        /// Initializes a new instance of the CRC32 checksum generator with a specified value
+        /// </summary>
+        /// <param name="initialValue">The value to set the current checksum to</param>
+        public CRC32Checksum(uint initialValue) : base(initialValue) {}
+
+        /// <summary>
+        /// Updates the current checksum with part of an array of bytes
+        /// </summary>
+        /// <param name="data">The data to update the checksum with</param>
+        /// <param name="offset">Where in <c>data</c> to start updating</param>
+        /// <param name="count">The number of bytes from <c>data</c> to use</param>
+        /// <exception cref="ArgumentException">The sum of offset and count is larger than the length of <c>data</c></exception>
+        /// <exception cref="NullReferenceException"><c>data</c> is a null reference</exception>
+        /// <exception cref="ArgumentOutOfRangeException">Offset or count is negative.</exception>
+        public override void Update(byte[] data, int offset, int count)
+        {
+            if (offset < 0 || count < 0) throw new ArgumentOutOfRangeException();
+            if ((offset+count) > data.Length) throw new ArgumentException();
+            GCHandle hData = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                _current = crc32(_current, hData.AddrOfPinnedObject().ToInt32()+offset, (uint)count);
+            }
+            finally
+            {
+                hData.Free();
+            }
+        }
+
+    }
+    #endregion
+
+    #region Adler
+    /// <summary>
+    /// Implements a checksum generator that computes the Adler checksum on data
+    /// </summary>
+    public sealed class AdlerChecksum : ChecksumGeneratorBase
+    {
+        #region DLL imports
+
+        [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
+        private static extern uint adler32(uint adler, int data, uint length);
+
+        #endregion
+
+        /// <summary>
+        /// Initializes a new instance of the Adler checksum generator
+        /// </summary>
+        public AdlerChecksum() : base() {}
+
+        /// <summary>
+        /// Initializes a new instance of the Adler checksum generator with a specified value
+        /// </summary>
+        /// <param name="initialValue">The value to set the current checksum to</param>
+        public AdlerChecksum(uint initialValue) : base(initialValue) {}
+
+        /// <summary>
+        /// Updates the current checksum with part of an array of bytes
+        /// </summary>
+        /// <param name="data">The data to update the checksum with</param>
+        /// <param name="offset">Where in <c>data</c> to start updating</param>
+        /// <param name="count">The number of bytes from <c>data</c> to use</param>
+        /// <exception cref="ArgumentException">The sum of offset and count is larger than the length of <c>data</c></exception>
+        /// <exception cref="NullReferenceException"><c>data</c> is a null reference</exception>
+        /// <exception cref="ArgumentOutOfRangeException">Offset or count is negative.</exception>
+        public override void Update(byte[] data, int offset, int count)
+        {
+            if (offset < 0 || count < 0) throw new ArgumentOutOfRangeException();
+            if ((offset+count) > data.Length) throw new ArgumentException();
+            GCHandle hData = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                _current = adler32(_current, hData.AddrOfPinnedObject().ToInt32()+offset, (uint)count);
+            }
+            finally
+            {
+                hData.Free();
+            }
+        }
+
+    }
+    #endregion
+
+}
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/CircularBuffer.cs b/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/CircularBuffer.cs
new file mode 100644
index 000000000..e7a88b9f4
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/CircularBuffer.cs
@@ -0,0 +1,83 @@
+//
+// © Copyright Henrik Ravn 2004
+//
+// Use, modification and distribution are subject to the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+using System;
+using System.Diagnostics;
+
+namespace DotZLib
+{
+
+	/// <summary>
+	/// This class implements a circular buffer
+	/// </summary>
+	internal class CircularBuffer
+	{
+        #region Private data
+        private int _capacity;
+        private int _head;
+        private int _tail;
+        private int _size;
+        private byte[] _buffer;
+        #endregion
+
+        public CircularBuffer(int capacity)
+        {
+            Debug.Assert( capacity > 0 );
+            _buffer = new byte[capacity];
+            _capacity = capacity;
+            _head = 0;
+            _tail = 0;
+            _size = 0;
+        }
+
+        public int Size { get { return _size; } }
+
+        public int Put(byte[] source, int offset, int count)
+        {
+            Debug.Assert( count > 0 );
+            int trueCount = Math.Min(count, _capacity - Size);
+            for (int i = 0; i < trueCount; ++i)
+                _buffer[(_tail+i) % _capacity] = source[offset+i];
+            _tail += trueCount;
+            _tail %= _capacity;
+            _size += trueCount;
+            return trueCount;
+        }
+
+        public bool Put(byte b)
+        {
+            if (Size == _capacity) // no room
+                return false;
+            _buffer[_tail++] = b;
+            _tail %= _capacity;
+            ++_size;
+            return true;
+        }
+
+        public int Get(byte[] destination, int offset, int count)
+        {
+            int trueCount = Math.Min(count,Size);
+            for (int i = 0; i < trueCount; ++i)
+                destination[offset + i] = _buffer[(_head+i) % _capacity];
+            _head += trueCount;
+            _head %= _capacity;
+            _size -= trueCount;
+            return trueCount;
+        }
+
+        public int Get()
+        {
+            if (Size == 0)
+                return -1;
+
+            int result = (int)_buffer[_head++ % _capacity];
+            --_size;
+            return result;
+        }
+
+    }
+}
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/CodecBase.cs b/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/CodecBase.cs
new file mode 100644
index 000000000..6ef6d8fab
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/CodecBase.cs
@@ -0,0 +1,198 @@
+//
+// © Copyright Henrik Ravn 2004
+//
+// Use, modification and distribution are subject to the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace DotZLib
+{
+	/// <summary>
+	/// Implements the common functionality needed for all <see cref="Codec"/>s
+	/// </summary>
+	public abstract class CodecBase : Codec, IDisposable
+	{
+
+        #region Data members
+
+        /// <summary>
+        /// Instance of the internal zlib buffer structure that is
+        /// passed to all functions in the zlib dll
+        /// </summary>
+        internal ZStream _ztream = new ZStream();
+
+        /// <summary>
+        /// True if the object instance has been disposed, false otherwise
+        /// </summary>
+        protected bool _isDisposed = false;
+
+        /// <summary>
+        /// The size of the internal buffers
+        /// </summary>
+        protected const int kBufferSize = 16384;
+
+        private byte[] _outBuffer = new byte[kBufferSize];
+        private byte[] _inBuffer = new byte[kBufferSize];
+
+        private GCHandle _hInput;
+        private GCHandle _hOutput;
+
+        private uint _checksum = 0;
+
+        #endregion
+
+        /// <summary>
+        /// Initializes a new instance of the <c>CodeBase</c> class.
+        /// </summary>
+		public CodecBase()
+		{
+            try
+            {
+                _hInput = GCHandle.Alloc(_inBuffer, GCHandleType.Pinned);
+                _hOutput = GCHandle.Alloc(_outBuffer, GCHandleType.Pinned);
+            }
+            catch (Exception)
+            {
+                CleanUp(false);
+                throw;
+            }
+        }
+
+
+        #region Codec Members
+
+        /// <summary>
+        /// Occurs when more processed data are available.
+        /// </summary>
+        public event DataAvailableHandler DataAvailable;
+
+        /// <summary>
+        /// Fires the <see cref="DataAvailable"/> event
+        /// </summary>
+        protected void OnDataAvailable()
+        {
+            if (_ztream.total_out > 0)
+            {
+                if (DataAvailable != null)
+                    DataAvailable( _outBuffer, 0, (int)_ztream.total_out);
+                resetOutput();
+            }
+        }
+
+        /// <summary>
+        /// Adds more data to the codec to be processed.
+        /// </summary>
+        /// <param name="data">Byte array containing the data to be added to the codec</param>
+        /// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks>
+        public void Add(byte[] data)
+        {
+            Add(data,0,data.Length);
+        }
+
+        /// <summary>
+        /// Adds more data to the codec to be processed.
+        /// </summary>
+        /// <param name="data">Byte array containing the data to be added to the codec</param>
+        /// <param name="offset">The index of the first byte to add from <c>data</c></param>
+        /// <param name="count">The number of bytes to add</param>
+        /// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks>
+        /// <remarks>This must be implemented by a derived class</remarks>
+        public abstract void Add(byte[] data, int offset, int count);
+
+        /// <summary>
+        /// Finishes up any pending data that needs to be processed and handled.
+        /// </summary>
+        /// <remarks>This must be implemented by a derived class</remarks>
+        public abstract void Finish();
+
+        /// <summary>
+        /// Gets the checksum of the data that has been added so far
+        /// </summary>
+        public uint Checksum { get { return _checksum; } }
+
+        #endregion
+
+        #region Destructor & IDisposable stuff
+
+        /// <summary>
+        /// Destroys this instance
+        /// </summary>
+        ~CodecBase()
+        {
+            CleanUp(false);
+        }
+
+        /// <summary>
+        /// Releases any unmanaged resources and calls the <see cref="CleanUp()"/> method of the derived class
+        /// </summary>
+        public void Dispose()
+        {
+            CleanUp(true);
+        }
+
+        /// <summary>
+        /// Performs any codec specific cleanup
+        /// </summary>
+        /// <remarks>This must be implemented by a derived class</remarks>
+        protected abstract void CleanUp();
+
+        // performs the release of the handles and calls the dereived CleanUp()
+        private void CleanUp(bool isDisposing)
+        {
+            if (!_isDisposed)
+            {
+                CleanUp();
+                if (_hInput.IsAllocated)
+                    _hInput.Free();
+                if (_hOutput.IsAllocated)
+                    _hOutput.Free();
+
+                _isDisposed = true;
+            }
+        }
+
+
+        #endregion
+
+        #region Helper methods
+
+        /// <summary>
+        /// Copies a number of bytes to the internal codec buffer - ready for proccesing
+        /// </summary>
+        /// <param name="data">The byte array that contains the data to copy</param>
+        /// <param name="startIndex">The index of the first byte to copy</param>
+        /// <param name="count">The number of bytes to copy from <c>data</c></param>
+        protected void copyInput(byte[] data, int startIndex, int count)
+        {
+            Array.Copy(data, startIndex, _inBuffer,0, count);
+            _ztream.next_in = _hInput.AddrOfPinnedObject();
+            _ztream.total_in = 0;
+            _ztream.avail_in = (uint)count;
+
+        }
+
+        /// <summary>
+        /// Resets the internal output buffers to a known state - ready for processing
+        /// </summary>
+        protected void resetOutput()
+        {
+            _ztream.total_out = 0;
+            _ztream.avail_out = kBufferSize;
+            _ztream.next_out = _hOutput.AddrOfPinnedObject();
+        }
+
+        /// <summary>
+        /// Updates the running checksum property
+        /// </summary>
+        /// <param name="newSum">The new checksum value</param>
+        protected void setChecksum(uint newSum)
+        {
+            _checksum = newSum;
+        }
+        #endregion
+
+    }
+}
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/Deflater.cs b/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/Deflater.cs
new file mode 100644
index 000000000..778a6794d
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/Deflater.cs
@@ -0,0 +1,106 @@
+//
+// © Copyright Henrik Ravn 2004
+//
+// Use, modification and distribution are subject to the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+using System;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace DotZLib
+{
+
+    /// <summary>
+    /// Implements a data compressor, using the deflate algorithm in the ZLib dll
+    /// </summary>
+	public sealed class Deflater : CodecBase
+	{
+        #region Dll imports
+        [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl, CharSet=CharSet.Ansi)]
+        private static extern int deflateInit_(ref ZStream sz, int level, string vs, int size);
+
+        [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
+        private static extern int deflate(ref ZStream sz, int flush);
+
+        [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
+        private static extern int deflateReset(ref ZStream sz);
+
+        [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
+        private static extern int deflateEnd(ref ZStream sz);
+        #endregion
+
+        /// <summary>
+        /// Constructs an new instance of the <c>Deflater</c>
+        /// </summary>
+        /// <param name="level">The compression level to use for this <c>Deflater</c></param>
+		public Deflater(CompressLevel level) : base()
+		{
+            int retval = deflateInit_(ref _ztream, (int)level, Info.Version, Marshal.SizeOf(_ztream));
+            if (retval != 0)
+                throw new ZLibException(retval, "Could not initialize deflater");
+
+            resetOutput();
+		}
+
+        /// <summary>
+        /// Adds more data to the codec to be processed.
+        /// </summary>
+        /// <param name="data">Byte array containing the data to be added to the codec</param>
+        /// <param name="offset">The index of the first byte to add from <c>data</c></param>
+        /// <param name="count">The number of bytes to add</param>
+        /// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks>
+        public override void Add(byte[] data, int offset, int count)
+        {
+            if (data == null) throw new ArgumentNullException();
+            if (offset < 0 || count < 0) throw new ArgumentOutOfRangeException();
+            if ((offset+count) > data.Length) throw new ArgumentException();
+
+            int total = count;
+            int inputIndex = offset;
+            int err = 0;
+
+            while (err >= 0 && inputIndex < total)
+            {
+                copyInput(data, inputIndex, Math.Min(total - inputIndex, kBufferSize));
+                while (err >= 0 && _ztream.avail_in > 0)
+                {
+                    err = deflate(ref _ztream, (int)FlushTypes.None);
+                    if (err == 0)
+                        while (_ztream.avail_out == 0)
+                        {
+                            OnDataAvailable();
+                            err = deflate(ref _ztream, (int)FlushTypes.None);
+                        }
+                    inputIndex += (int)_ztream.total_in;
+                }
+            }
+            setChecksum( _ztream.adler );
+        }
+
+
+        /// <summary>
+        /// Finishes up any pending data that needs to be processed and handled.
+        /// </summary>
+        public override void Finish()
+        {
+            int err;
+            do
+            {
+                err = deflate(ref _ztream, (int)FlushTypes.Finish);
+                OnDataAvailable();
+            }
+            while (err == 0);
+            setChecksum( _ztream.adler );
+            deflateReset(ref _ztream);
+            resetOutput();
+        }
+
+        /// <summary>
+        /// Closes the internal zlib deflate stream
+        /// </summary>
+        protected override void CleanUp() { deflateEnd(ref _ztream); }
+
+    }
+}
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/DotZLib.cs b/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/DotZLib.cs
new file mode 100644
index 000000000..a48ed4974
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/DotZLib.cs
@@ -0,0 +1,288 @@
+//
+// © Copyright Henrik Ravn 2004
+//
+// Use, modification and distribution are subject to the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text;
+
+
+namespace DotZLib
+{
+
+    #region Internal types
+
+    /// <summary>
+    /// Defines constants for the various flush types used with zlib
+    /// </summary>
+    internal enum FlushTypes
+    {
+        None,  Partial,  Sync,  Full,  Finish,  Block
+    }
+
+    #region ZStream structure
+    // internal mapping of the zlib zstream structure for marshalling
+    [StructLayoutAttribute(LayoutKind.Sequential, Pack=4, Size=0, CharSet=CharSet.Ansi)]
+    internal struct ZStream
+    {
+        public IntPtr next_in;
+        public uint avail_in;
+        public uint total_in;
+
+        public IntPtr next_out;
+        public uint avail_out;
+        public uint total_out;
+
+        [MarshalAs(UnmanagedType.LPStr)]
+        string msg;
+        uint state;
+
+        uint zalloc;
+        uint zfree;
+        uint opaque;
+
+        int data_type;
+        public uint adler;
+        uint reserved;
+    }
+
+    #endregion
+
+    #endregion
+
+    #region Public enums
+    /// <summary>
+    /// Defines constants for the available compression levels in zlib
+    /// </summary>
+    public enum CompressLevel : int
+    {
+        /// <summary>
+        /// The default compression level with a reasonable compromise between compression and speed
+        /// </summary>
+        Default = -1,
+        /// <summary>
+        /// No compression at all. The data are passed straight through.
+        /// </summary>
+        None = 0,
+        /// <summary>
+        /// The maximum compression rate available.
+        /// </summary>
+        Best = 9,
+        /// <summary>
+        /// The fastest available compression level.
+        /// </summary>
+        Fastest = 1
+    }
+    #endregion
+
+    #region Exception classes
+    /// <summary>
+    /// The exception that is thrown when an error occurs on the zlib dll
+    /// </summary>
+    public class ZLibException : ApplicationException
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ZLibException"/> class with a specified
+        /// error message and error code
+        /// </summary>
+        /// <param name="errorCode">The zlib error code that caused the exception</param>
+        /// <param name="msg">A message that (hopefully) describes the error</param>
+        public ZLibException(int errorCode, string msg) : base(String.Format("ZLib error {0} {1}", errorCode, msg))
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ZLibException"/> class with a specified
+        /// error code
+        /// </summary>
+        /// <param name="errorCode">The zlib error code that caused the exception</param>
+        public ZLibException(int errorCode) : base(String.Format("ZLib error {0}", errorCode))
+        {
+        }
+    }
+    #endregion
+
+    #region Interfaces
+
+    /// <summary>
+    /// Declares methods and properties that enables a running checksum to be calculated
+    /// </summary>
+    public interface ChecksumGenerator
+    {
+        /// <summary>
+        /// Gets the current value of the checksum
+        /// </summary>
+        uint Value { get; }
+
+        /// <summary>
+        /// Clears the current checksum to 0
+        /// </summary>
+        void Reset();
+
+        /// <summary>
+        /// Updates the current checksum with an array of bytes
+        /// </summary>
+        /// <param name="data">The data to update the checksum with</param>
+        void Update(byte[] data);
+
+        /// <summary>
+        /// Updates the current checksum with part of an array of bytes
+        /// </summary>
+        /// <param name="data">The data to update the checksum with</param>
+        /// <param name="offset">Where in <c>data</c> to start updating</param>
+        /// <param name="count">The number of bytes from <c>data</c> to use</param>
+        /// <exception cref="ArgumentException">The sum of offset and count is larger than the length of <c>data</c></exception>
+        /// <exception cref="ArgumentNullException"><c>data</c> is a null reference</exception>
+        /// <exception cref="ArgumentOutOfRangeException">Offset or count is negative.</exception>
+        void Update(byte[] data, int offset, int count);
+
+        /// <summary>
+        /// Updates the current checksum with the data from a string
+        /// </summary>
+        /// <param name="data">The string to update the checksum with</param>
+        /// <remarks>The characters in the string are converted by the UTF-8 encoding</remarks>
+        void Update(string data);
+
+        /// <summary>
+        /// Updates the current checksum with the data from a string, using a specific encoding
+        /// </summary>
+        /// <param name="data">The string to update the checksum with</param>
+        /// <param name="encoding">The encoding to use</param>
+        void Update(string data, Encoding encoding);
+    }
+
+
+    /// <summary>
+    /// Represents the method that will be called from a codec when new data
+    /// are available.
+    /// </summary>
+    /// <paramref name="data">The byte array containing the processed data</paramref>
+    /// <paramref name="startIndex">The index of the first processed byte in <c>data</c></paramref>
+    /// <paramref name="count">The number of processed bytes available</paramref>
+    /// <remarks>On return from this method, the data may be overwritten, so grab it while you can.
+    /// You cannot assume that startIndex will be zero.
+    /// </remarks>
+    public delegate void DataAvailableHandler(byte[] data, int startIndex, int count);
+
+    /// <summary>
+    /// Declares methods and events for implementing compressors/decompressors
+    /// </summary>
+    public interface Codec
+    {
+        /// <summary>
+        /// Occurs when more processed data are available.
+        /// </summary>
+        event DataAvailableHandler DataAvailable;
+
+        /// <summary>
+        /// Adds more data to the codec to be processed.
+        /// </summary>
+        /// <param name="data">Byte array containing the data to be added to the codec</param>
+        /// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks>
+        void Add(byte[] data);
+
+        /// <summary>
+        /// Adds more data to the codec to be processed.
+        /// </summary>
+        /// <param name="data">Byte array containing the data to be added to the codec</param>
+        /// <param name="offset">The index of the first byte to add from <c>data</c></param>
+        /// <param name="count">The number of bytes to add</param>
+        /// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks>
+        void Add(byte[] data, int offset, int count);
+
+        /// <summary>
+        /// Finishes up any pending data that needs to be processed and handled.
+        /// </summary>
+        void Finish();
+
+        /// <summary>
+        /// Gets the checksum of the data that has been added so far
+        /// </summary>
+        uint Checksum { get; }
+
+
+    }
+
+    #endregion
+
+    #region Classes
+    /// <summary>
+    /// Encapsulates general information about the ZLib library
+    /// </summary>
+    public class Info
+    {
+        #region DLL imports
+        [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
+        private static extern uint zlibCompileFlags();
+
+        [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
+        private static extern string zlibVersion();
+        #endregion
+
+        #region Private stuff
+        private uint _flags;
+
+        // helper function that unpacks a bitsize mask
+        private static int bitSize(uint bits)
+        {
+            switch (bits)
+            {
+                case 0: return 16;
+                case 1: return 32;
+                case 2: return 64;
+            }
+            return -1;
+        }
+        #endregion
+
+        /// <summary>
+        /// Constructs an instance of the <c>Info</c> class.
+        /// </summary>
+        public Info()
+        {
+            _flags = zlibCompileFlags();
+        }
+
+        /// <summary>
+        /// True if the library is compiled with debug info
+        /// </summary>
+        public bool HasDebugInfo { get { return 0 != (_flags & 0x100); } }
+
+        /// <summary>
+        /// True if the library is compiled with assembly optimizations
+        /// </summary>
+        public bool UsesAssemblyCode { get { return 0 != (_flags & 0x200); } }
+
+        /// <summary>
+        /// Gets the size of the unsigned int that was compiled into Zlib
+        /// </summary>
+        public int SizeOfUInt { get { return bitSize(_flags & 3); } }
+
+        /// <summary>
+        /// Gets the size of the unsigned long that was compiled into Zlib
+        /// </summary>
+        public int SizeOfULong { get { return bitSize((_flags >> 2) & 3); } }
+
+        /// <summary>
+        /// Gets the size of the pointers that were compiled into Zlib
+        /// </summary>
+        public int SizeOfPointer { get { return bitSize((_flags >> 4) & 3); } }
+
+        /// <summary>
+        /// Gets the size of the z_off_t type that was compiled into Zlib
+        /// </summary>
+        public int SizeOfOffset { get { return bitSize((_flags >> 6) & 3); } }
+
+        /// <summary>
+        /// Gets the version of ZLib as a string, e.g. "1.2.1"
+        /// </summary>
+        public static string Version { get { return zlibVersion(); } }
+    }
+
+    #endregion
+
+}
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/DotZLib.csproj b/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/DotZLib.csproj
new file mode 100644
index 000000000..dea7fb16a
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/DotZLib.csproj
@@ -0,0 +1,141 @@
+<VisualStudioProject>
+    <CSHARP
+        ProjectType = "Local"
+        ProductVersion = "7.10.3077"
+        SchemaVersion = "2.0"
+        ProjectGuid = "{BB1EE0B1-1808-46CB-B786-949D91117FC5}"
+    >
+        <Build>
+            <Settings
+                ApplicationIcon = ""
+                AssemblyKeyContainerName = ""
+                AssemblyName = "DotZLib"
+                AssemblyOriginatorKeyFile = ""
+                DefaultClientScript = "JScript"
+                DefaultHTMLPageLayout = "Grid"
+                DefaultTargetSchema = "IE50"
+                DelaySign = "false"
+                OutputType = "Library"
+                PreBuildEvent = ""
+                PostBuildEvent = ""
+                RootNamespace = "DotZLib"
+                RunPostBuildEvent = "OnBuildSuccess"
+                StartupObject = ""
+            >
+                <Config
+                    Name = "Debug"
+                    AllowUnsafeBlocks = "false"
+                    BaseAddress = "285212672"
+                    CheckForOverflowUnderflow = "false"
+                    ConfigurationOverrideFile = ""
+                    DefineConstants = "DEBUG;TRACE"
+                    DocumentationFile = "docs\DotZLib.xml"
+                    DebugSymbols = "true"
+                    FileAlignment = "4096"
+                    IncrementalBuild = "false"
+                    NoStdLib = "false"
+                    NoWarn = "1591"
+                    Optimize = "false"
+                    OutputPath = "bin\Debug\"
+                    RegisterForComInterop = "false"
+                    RemoveIntegerChecks = "false"
+                    TreatWarningsAsErrors = "false"
+                    WarningLevel = "4"
+                />
+                <Config
+                    Name = "Release"
+                    AllowUnsafeBlocks = "false"
+                    BaseAddress = "285212672"
+                    CheckForOverflowUnderflow = "false"
+                    ConfigurationOverrideFile = ""
+                    DefineConstants = "TRACE"
+                    DocumentationFile = "docs\DotZLib.xml"
+                    DebugSymbols = "false"
+                    FileAlignment = "4096"
+                    IncrementalBuild = "false"
+                    NoStdLib = "false"
+                    NoWarn = ""
+                    Optimize = "true"
+                    OutputPath = "bin\Release\"
+                    RegisterForComInterop = "false"
+                    RemoveIntegerChecks = "false"
+                    TreatWarningsAsErrors = "false"
+                    WarningLevel = "4"
+                />
+            </Settings>
+            <References>
+                <Reference
+                    Name = "System"
+                    AssemblyName = "System"
+                    HintPath = "C:\WINNT\Microsoft.NET\Framework\v1.1.4322\System.dll"
+                />
+                <Reference
+                    Name = "System.Data"
+                    AssemblyName = "System.Data"
+                    HintPath = "C:\WINNT\Microsoft.NET\Framework\v1.1.4322\System.Data.dll"
+                />
+                <Reference
+                    Name = "System.XML"
+                    AssemblyName = "System.Xml"
+                    HintPath = "C:\WINNT\Microsoft.NET\Framework\v1.1.4322\System.XML.dll"
+                />
+                <Reference
+                    Name = "nunit.framework"
+                    AssemblyName = "nunit.framework"
+                    HintPath = "E:\apps\NUnit V2.1\\bin\nunit.framework.dll"
+                    AssemblyFolderKey = "hklm\dn\nunit.framework"
+                />
+            </References>
+        </Build>
+        <Files>
+            <Include>
+                <File
+                    RelPath = "AssemblyInfo.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "ChecksumImpl.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "CircularBuffer.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "CodecBase.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "Deflater.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "DotZLib.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "GZipStream.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "Inflater.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "UnitTests.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+            </Include>
+        </Files>
+    </CSHARP>
+</VisualStudioProject>
+
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/GZipStream.cs b/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/GZipStream.cs
new file mode 100644
index 000000000..07b2f7a9b
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/GZipStream.cs
@@ -0,0 +1,301 @@
+//
+// © Copyright Henrik Ravn 2004
+//
+// Use, modification and distribution are subject to the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+
+namespace DotZLib
+{
+	/// <summary>
+	/// Implements a compressed <see cref="Stream"/>, in GZip (.gz) format.
+	/// </summary>
+	public class GZipStream : Stream, IDisposable
+	{
+        #region Dll Imports
+        [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl, CharSet=CharSet.Ansi)]
+        private static extern IntPtr gzopen(string name, string mode);
+
+        [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
+        private static extern int gzclose(IntPtr gzFile);
+
+        [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
+        private static extern int gzwrite(IntPtr gzFile, int data, int length);
+
+        [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
+        private static extern int gzread(IntPtr gzFile, int data, int length);
+
+        [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
+        private static extern int gzgetc(IntPtr gzFile);
+
+        [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
+        private static extern int gzputc(IntPtr gzFile, int c);
+
+        #endregion
+
+        #region Private data
+        private IntPtr _gzFile;
+        private bool _isDisposed = false;
+        private bool _isWriting;
+        #endregion
+
+        #region Constructors
+        /// <summary>
+        /// Creates a new file as a writeable GZipStream
+        /// </summary>
+        /// <param name="fileName">The name of the compressed file to create</param>
+        /// <param name="level">The compression level to use when adding data</param>
+        /// <exception cref="ZLibException">If an error occurred in the internal zlib function</exception>
+		public GZipStream(string fileName, CompressLevel level)
+		{
+            _isWriting = true;
+            _gzFile = gzopen(fileName, String.Format("wb{0}", (int)level));
+            if (_gzFile == IntPtr.Zero)
+                throw new ZLibException(-1, "Could not open " + fileName);
+		}
+
+        /// <summary>
+        /// Opens an existing file as a readable GZipStream
+        /// </summary>
+        /// <param name="fileName">The name of the file to open</param>
+        /// <exception cref="ZLibException">If an error occurred in the internal zlib function</exception>
+        public GZipStream(string fileName)
+        {
+            _isWriting = false;
+            _gzFile = gzopen(fileName, "rb");
+            if (_gzFile == IntPtr.Zero)
+                throw new ZLibException(-1, "Could not open " + fileName);
+
+        }
+        #endregion
+
+        #region Access properties
+        /// <summary>
+        /// Returns true of this stream can be read from, false otherwise
+        /// </summary>
+        public override bool CanRead
+        {
+            get
+            {
+                return !_isWriting;
+            }
+        }
+
+
+        /// <summary>
+        /// Returns false.
+        /// </summary>
+        public override bool CanSeek
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Returns true if this tsream is writeable, false otherwise
+        /// </summary>
+        public override bool CanWrite
+        {
+            get
+            {
+                return _isWriting;
+            }
+        }
+        #endregion
+
+        #region Destructor & IDispose stuff
+
+        /// <summary>
+        /// Destroys this instance
+        /// </summary>
+        ~GZipStream()
+        {
+            cleanUp(false);
+        }
+
+        /// <summary>
+        /// Closes the external file handle
+        /// </summary>
+        public void Dispose()
+        {
+            cleanUp(true);
+        }
+
+        // Does the actual closing of the file handle.
+        private void cleanUp(bool isDisposing)
+        {
+            if (!_isDisposed)
+            {
+                gzclose(_gzFile);
+                _isDisposed = true;
+            }
+        }
+        #endregion
+
+        #region Basic reading and writing
+        /// <summary>
+        /// Attempts to read a number of bytes from the stream.
+        /// </summary>
+        /// <param name="buffer">The destination data buffer</param>
+        /// <param name="offset">The index of the first destination byte in <c>buffer</c></param>
+        /// <param name="count">The number of bytes requested</param>
+        /// <returns>The number of bytes read</returns>
+        /// <exception cref="ArgumentNullException">If <c>buffer</c> is null</exception>
+        /// <exception cref="ArgumentOutOfRangeException">If <c>count</c> or <c>offset</c> are negative</exception>
+        /// <exception cref="ArgumentException">If <c>offset</c>  + <c>count</c> is &gt; buffer.Length</exception>
+        /// <exception cref="NotSupportedException">If this stream is not readable.</exception>
+        /// <exception cref="ObjectDisposedException">If this stream has been disposed.</exception>
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            if (!CanRead) throw new NotSupportedException();
+            if (buffer == null) throw new ArgumentNullException();
+            if (offset < 0 || count < 0) throw new ArgumentOutOfRangeException();
+            if ((offset+count) > buffer.Length) throw new ArgumentException();
+            if (_isDisposed) throw new ObjectDisposedException("GZipStream");
+
+            GCHandle h = GCHandle.Alloc(buffer, GCHandleType.Pinned);
+            int result;
+            try
+            {
+                result = gzread(_gzFile, h.AddrOfPinnedObject().ToInt32() + offset, count);
+                if (result < 0)
+                    throw new IOException();
+            }
+            finally
+            {
+                h.Free();
+            }
+            return result;
+        }
+
+        /// <summary>
+        /// Attempts to read a single byte from the stream.
+        /// </summary>
+        /// <returns>The byte that was read, or -1 in case of error or End-Of-File</returns>
+        public override int ReadByte()
+        {
+            if (!CanRead) throw new NotSupportedException();
+            if (_isDisposed) throw new ObjectDisposedException("GZipStream");
+            return gzgetc(_gzFile);
+        }
+
+        /// <summary>
+        /// Writes a number of bytes to the stream
+        /// </summary>
+        /// <param name="buffer"></param>
+        /// <param name="offset"></param>
+        /// <param name="count"></param>
+        /// <exception cref="ArgumentNullException">If <c>buffer</c> is null</exception>
+        /// <exception cref="ArgumentOutOfRangeException">If <c>count</c> or <c>offset</c> are negative</exception>
+        /// <exception cref="ArgumentException">If <c>offset</c>  + <c>count</c> is &gt; buffer.Length</exception>
+        /// <exception cref="NotSupportedException">If this stream is not writeable.</exception>
+        /// <exception cref="ObjectDisposedException">If this stream has been disposed.</exception>
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            if (!CanWrite) throw new NotSupportedException();
+            if (buffer == null) throw new ArgumentNullException();
+            if (offset < 0 || count < 0) throw new ArgumentOutOfRangeException();
+            if ((offset+count) > buffer.Length) throw new ArgumentException();
+            if (_isDisposed) throw new ObjectDisposedException("GZipStream");
+
+            GCHandle h = GCHandle.Alloc(buffer, GCHandleType.Pinned);
+            try
+            {
+                int result = gzwrite(_gzFile, h.AddrOfPinnedObject().ToInt32() + offset, count);
+                if (result < 0)
+                    throw new IOException();
+            }
+            finally
+            {
+                h.Free();
+            }
+        }
+
+        /// <summary>
+        /// Writes a single byte to the stream
+        /// </summary>
+        /// <param name="value">The byte to add to the stream.</param>
+        /// <exception cref="NotSupportedException">If this stream is not writeable.</exception>
+        /// <exception cref="ObjectDisposedException">If this stream has been disposed.</exception>
+        public override void WriteByte(byte value)
+        {
+            if (!CanWrite) throw new NotSupportedException();
+            if (_isDisposed) throw new ObjectDisposedException("GZipStream");
+
+            int result = gzputc(_gzFile, (int)value);
+            if (result < 0)
+                throw new IOException();
+        }
+        #endregion
+
+        #region Position & length stuff
+        /// <summary>
+        /// Not supported.
+        /// </summary>
+        /// <param name="value"></param>
+        /// <exception cref="NotSupportedException">Always thrown</exception>
+        public override void SetLength(long value)
+        {
+            throw new NotSupportedException();
+        }
+
+        /// <summary>
+        ///  Not suppported.
+        /// </summary>
+        /// <param name="offset"></param>
+        /// <param name="origin"></param>
+        /// <returns></returns>
+        /// <exception cref="NotSupportedException">Always thrown</exception>
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotSupportedException();
+        }
+
+        /// <summary>
+        /// Flushes the <c>GZipStream</c>.
+        /// </summary>
+        /// <remarks>In this implementation, this method does nothing. This is because excessive
+        /// flushing may degrade the achievable compression rates.</remarks>
+        public override void Flush()
+        {
+            // left empty on purpose
+        }
+
+        /// <summary>
+        /// Gets/sets the current position in the <c>GZipStream</c>. Not suppported.
+        /// </summary>
+        /// <remarks>In this implementation this property is not supported</remarks>
+        /// <exception cref="NotSupportedException">Always thrown</exception>
+        public override long Position
+        {
+            get
+            {
+                throw new NotSupportedException();
+            }
+            set
+            {
+                throw new NotSupportedException();
+            }
+        }
+
+        /// <summary>
+        /// Gets the size of the stream. Not suppported.
+        /// </summary>
+        /// <remarks>In this implementation this property is not supported</remarks>
+        /// <exception cref="NotSupportedException">Always thrown</exception>
+        public override long Length
+        {
+            get
+            {
+                throw new NotSupportedException();
+            }
+        }
+        #endregion
+    }
+}
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/Inflater.cs b/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/Inflater.cs
new file mode 100644
index 000000000..8e900ae20
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/Inflater.cs
@@ -0,0 +1,105 @@
+//
+// © Copyright Henrik Ravn 2004
+//
+// Use, modification and distribution are subject to the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+using System;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace DotZLib
+{
+
+    /// <summary>
+    /// Implements a data decompressor, using the inflate algorithm in the ZLib dll
+    /// </summary>
+    public class Inflater : CodecBase
+	{
+        #region Dll imports
+        [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl, CharSet=CharSet.Ansi)]
+        private static extern int inflateInit_(ref ZStream sz, string vs, int size);
+
+        [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
+        private static extern int inflate(ref ZStream sz, int flush);
+
+        [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
+        private static extern int inflateReset(ref ZStream sz);
+
+        [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
+        private static extern int inflateEnd(ref ZStream sz);
+        #endregion
+
+        /// <summary>
+        /// Constructs an new instance of the <c>Inflater</c>
+        /// </summary>
+        public Inflater() : base()
+		{
+            int retval = inflateInit_(ref _ztream, Info.Version, Marshal.SizeOf(_ztream));
+            if (retval != 0)
+                throw new ZLibException(retval, "Could not initialize inflater");
+
+            resetOutput();
+        }
+
+
+        /// <summary>
+        /// Adds more data to the codec to be processed.
+        /// </summary>
+        /// <param name="data">Byte array containing the data to be added to the codec</param>
+        /// <param name="offset">The index of the first byte to add from <c>data</c></param>
+        /// <param name="count">The number of bytes to add</param>
+        /// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks>
+        public override void Add(byte[] data, int offset, int count)
+        {
+            if (data == null) throw new ArgumentNullException();
+            if (offset < 0 || count < 0) throw new ArgumentOutOfRangeException();
+            if ((offset+count) > data.Length) throw new ArgumentException();
+
+            int total = count;
+            int inputIndex = offset;
+            int err = 0;
+
+            while (err >= 0 && inputIndex < total)
+            {
+                copyInput(data, inputIndex, Math.Min(total - inputIndex, kBufferSize));
+                err = inflate(ref _ztream, (int)FlushTypes.None);
+                if (err == 0)
+                    while (_ztream.avail_out == 0)
+                    {
+                        OnDataAvailable();
+                        err = inflate(ref _ztream, (int)FlushTypes.None);
+                    }
+
+                inputIndex += (int)_ztream.total_in;
+            }
+            setChecksum( _ztream.adler );
+        }
+
+
+        /// <summary>
+        /// Finishes up any pending data that needs to be processed and handled.
+        /// </summary>
+        public override void Finish()
+        {
+            int err;
+            do
+            {
+                err = inflate(ref _ztream, (int)FlushTypes.Finish);
+                OnDataAvailable();
+            }
+            while (err == 0);
+            setChecksum( _ztream.adler );
+            inflateReset(ref _ztream);
+            resetOutput();
+        }
+
+        /// <summary>
+        /// Closes the internal zlib inflate stream
+        /// </summary>
+        protected override void CleanUp() { inflateEnd(ref _ztream); }
+
+
+	}
+}
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/UnitTests.cs b/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/UnitTests.cs
new file mode 100644
index 000000000..6d8aebb79
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/DotZLib/UnitTests.cs
@@ -0,0 +1,274 @@
+//
+// © Copyright Henrik Ravn 2004
+//
+// Use, modification and distribution are subject to the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+using System;
+using System.Collections;
+using System.IO;
+
+// uncomment the define below to include unit tests
+//#define nunit
+#if nunit
+using NUnit.Framework;
+
+// Unit tests for the DotZLib class library
+// ----------------------------------------
+//
+// Use this with NUnit 2 from http://www.nunit.org
+//
+
+namespace DotZLibTests
+{
+    using DotZLib;
+
+    // helper methods
+    internal class Utils
+    {
+        public static bool byteArrEqual( byte[] lhs, byte[] rhs )
+        {
+            if (lhs.Length != rhs.Length)
+                return false;
+            for (int i = lhs.Length-1; i >= 0; --i)
+                if (lhs[i] != rhs[i])
+                    return false;
+            return true;
+        }
+
+    }
+
+
+    [TestFixture]
+    public class CircBufferTests
+    {
+        #region Circular buffer tests
+        [Test]
+        public void SinglePutGet()
+        {
+            CircularBuffer buf = new CircularBuffer(10);
+            Assert.AreEqual( 0, buf.Size );
+            Assert.AreEqual( -1, buf.Get() );
+
+            Assert.IsTrue(buf.Put( 1 ));
+            Assert.AreEqual( 1, buf.Size );
+            Assert.AreEqual( 1, buf.Get() );
+            Assert.AreEqual( 0, buf.Size );
+            Assert.AreEqual( -1, buf.Get() );
+        }
+
+        [Test]
+        public void BlockPutGet()
+        {
+            CircularBuffer buf = new CircularBuffer(10);
+            byte[] arr = {1,2,3,4,5,6,7,8,9,10};
+            Assert.AreEqual( 10, buf.Put(arr,0,10) );
+            Assert.AreEqual( 10, buf.Size );
+            Assert.IsFalse( buf.Put(11) );
+            Assert.AreEqual( 1, buf.Get() );
+            Assert.IsTrue( buf.Put(11) );
+
+            byte[] arr2 = (byte[])arr.Clone();
+            Assert.AreEqual( 9, buf.Get(arr2,1,9) );
+            Assert.IsTrue( Utils.byteArrEqual(arr,arr2) );
+        }
+
+        #endregion
+    }
+
+    [TestFixture]
+    public class ChecksumTests
+    {
+        #region CRC32 Tests
+        [Test]
+        public void CRC32_Null()
+        {
+            CRC32Checksum crc32 = new CRC32Checksum();
+            Assert.AreEqual( 0, crc32.Value );
+
+            crc32 = new CRC32Checksum(1);
+            Assert.AreEqual( 1, crc32.Value );
+
+            crc32 = new CRC32Checksum(556);
+            Assert.AreEqual( 556, crc32.Value );
+        }
+
+        [Test]
+        public void CRC32_Data()
+        {
+            CRC32Checksum crc32 = new CRC32Checksum();
+            byte[] data = { 1,2,3,4,5,6,7 };
+            crc32.Update(data);
+            Assert.AreEqual( 0x70e46888, crc32.Value  );
+
+            crc32 = new CRC32Checksum();
+            crc32.Update("penguin");
+            Assert.AreEqual( 0x0e5c1a120, crc32.Value );
+
+            crc32 = new CRC32Checksum(1);
+            crc32.Update("penguin");
+            Assert.AreEqual(0x43b6aa94, crc32.Value);
+
+        }
+        #endregion
+
+        #region Adler tests
+
+        [Test]
+        public void Adler_Null()
+        {
+            AdlerChecksum adler = new AdlerChecksum();
+            Assert.AreEqual(0, adler.Value);
+
+            adler = new AdlerChecksum(1);
+            Assert.AreEqual( 1, adler.Value );
+
+            adler = new AdlerChecksum(556);
+            Assert.AreEqual( 556, adler.Value );
+        }
+
+        [Test]
+        public void Adler_Data()
+        {
+            AdlerChecksum adler = new AdlerChecksum(1);
+            byte[] data = { 1,2,3,4,5,6,7 };
+            adler.Update(data);
+            Assert.AreEqual( 0x5b001d, adler.Value  );
+
+            adler = new AdlerChecksum();
+            adler.Update("penguin");
+            Assert.AreEqual(0x0bcf02f6, adler.Value );
+
+            adler = new AdlerChecksum(1);
+            adler.Update("penguin");
+            Assert.AreEqual(0x0bd602f7, adler.Value);
+
+        }
+        #endregion
+    }
+
+    [TestFixture]
+    public class InfoTests
+    {
+        #region Info tests
+        [Test]
+        public void Info_Version()
+        {
+            Info info = new Info();
+            Assert.AreEqual("1.2.11", Info.Version);
+            Assert.AreEqual(32, info.SizeOfUInt);
+            Assert.AreEqual(32, info.SizeOfULong);
+            Assert.AreEqual(32, info.SizeOfPointer);
+            Assert.AreEqual(32, info.SizeOfOffset);
+        }
+        #endregion
+    }
+
+    [TestFixture]
+    public class DeflateInflateTests
+    {
+        #region Deflate tests
+        [Test]
+        public void Deflate_Init()
+        {
+            using (Deflater def = new Deflater(CompressLevel.Default))
+            {
+            }
+        }
+
+        private ArrayList compressedData = new ArrayList();
+        private uint adler1;
+
+        private ArrayList uncompressedData = new ArrayList();
+        private uint adler2;
+
+        public void CDataAvail(byte[] data, int startIndex, int count)
+        {
+            for (int i = 0; i < count; ++i)
+                compressedData.Add(data[i+startIndex]);
+        }
+
+        [Test]
+        public void Deflate_Compress()
+        {
+            compressedData.Clear();
+
+            byte[] testData = new byte[35000];
+            for (int i = 0; i < testData.Length; ++i)
+                testData[i] = 5;
+
+            using (Deflater def = new Deflater((CompressLevel)5))
+            {
+                def.DataAvailable += new DataAvailableHandler(CDataAvail);
+                def.Add(testData);
+                def.Finish();
+                adler1 = def.Checksum;
+            }
+        }
+        #endregion
+
+        #region Inflate tests
+        [Test]
+        public void Inflate_Init()
+        {
+            using (Inflater inf = new Inflater())
+            {
+            }
+        }
+
+        private void DDataAvail(byte[] data, int startIndex, int count)
+        {
+            for (int i = 0; i < count; ++i)
+                uncompressedData.Add(data[i+startIndex]);
+        }
+
+        [Test]
+        public void Inflate_Expand()
+        {
+            uncompressedData.Clear();
+
+            using (Inflater inf = new Inflater())
+            {
+                inf.DataAvailable += new DataAvailableHandler(DDataAvail);
+                inf.Add((byte[])compressedData.ToArray(typeof(byte)));
+                inf.Finish();
+                adler2 = inf.Checksum;
+            }
+            Assert.AreEqual( adler1, adler2 );
+        }
+        #endregion
+    }
+
+    [TestFixture]
+    public class GZipStreamTests
+    {
+        #region GZipStream test
+        [Test]
+        public void GZipStream_WriteRead()
+        {
+            using (GZipStream gzOut = new GZipStream("gzstream.gz", CompressLevel.Best))
+            {
+                BinaryWriter writer = new BinaryWriter(gzOut);
+                writer.Write("hi there");
+                writer.Write(Math.PI);
+                writer.Write(42);
+            }
+
+            using (GZipStream gzIn = new GZipStream("gzstream.gz"))
+            {
+                BinaryReader reader = new BinaryReader(gzIn);
+                string s = reader.ReadString();
+                Assert.AreEqual("hi there",s);
+                double d = reader.ReadDouble();
+                Assert.AreEqual(Math.PI, d);
+                int i = reader.ReadInt32();
+                Assert.AreEqual(42,i);
+            }
+
+        }
+        #endregion
+	}
+}
+
+#endif
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/LICENSE_1_0.txt b/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/LICENSE_1_0.txt
new file mode 100644
index 000000000..127a5bc39
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/LICENSE_1_0.txt
@@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
\ No newline at end of file
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/readme.txt b/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/readme.txt
new file mode 100644
index 000000000..4d8c2dd93
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/readme.txt
@@ -0,0 +1,58 @@
+This directory contains a .Net wrapper class library for the ZLib1.dll
+
+The wrapper includes support for inflating/deflating memory buffers,
+.Net streaming wrappers for the gz streams part of zlib, and wrappers
+for the checksum parts of zlib. See DotZLib/UnitTests.cs for examples.
+
+Directory structure:
+--------------------
+
+LICENSE_1_0.txt       - License file.
+readme.txt            - This file.
+DotZLib.chm           - Class library documentation
+DotZLib.build         - NAnt build file
+DotZLib.sln           - Microsoft Visual Studio 2003 solution file
+
+DotZLib\*.cs          - Source files for the class library
+
+Unit tests:
+-----------
+The file DotZLib/UnitTests.cs contains unit tests for use with NUnit 2.1 or higher.
+To include unit tests in the build, define nunit before building.
+
+
+Build instructions:
+-------------------
+
+1. Using Visual Studio.Net 2003:
+   Open DotZLib.sln in VS.Net and build from there. Output file (DotZLib.dll)
+   will be found ./DotZLib/bin/release or ./DotZLib/bin/debug, depending on
+   you are building the release or debug version of the library. Check
+   DotZLib/UnitTests.cs for instructions on how to include unit tests in the
+   build.
+
+2. Using NAnt:
+   Open a command prompt with access to the build environment and run nant
+   in the same directory as the DotZLib.build file.
+   You can define 2 properties on the nant command-line to control the build:
+   debug={true|false} to toggle between release/debug builds (default=true).
+   nunit={true|false} to include or esclude unit tests (default=true).
+   Also the target clean will remove binaries.
+   Output file (DotZLib.dll) will be found in either ./DotZLib/bin/release
+   or ./DotZLib/bin/debug, depending on whether you are building the release
+   or debug version of the library.
+
+   Examples:
+     nant -D:debug=false -D:nunit=false
+       will build a release mode version of the library without unit tests.
+     nant
+       will build a debug version of the library with unit tests
+     nant clean
+       will remove all previously built files.
+
+
+---------------------------------
+Copyright (c) Henrik Ravn 2004
+
+Use, modification and distribution are subject to the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/gcc_gvmat64/gvmat64.S b/Engine/lib/assimp/contrib/zlib/contrib/gcc_gvmat64/gvmat64.S
new file mode 100644
index 000000000..23309fa28
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/gcc_gvmat64/gvmat64.S
@@ -0,0 +1,574 @@
+/*
+;uInt longest_match_x64(
+;    deflate_state *s,
+;    IPos cur_match);                             // current match 
+
+; gvmat64.S -- Asm portion of the optimized longest_match for 32 bits x86_64
+;  (AMD64 on Athlon 64, Opteron, Phenom
+;     and Intel EM64T on Pentium 4 with EM64T, Pentium D, Core 2 Duo, Core I5/I7)
+; this file is translation from gvmat64.asm to GCC 4.x (for Linux, Mac XCode)
+; Copyright (C) 1995-2010 Jean-loup Gailly, Brian Raiter and Gilles Vollant.
+;
+; File written by Gilles Vollant, by converting to assembly the longest_match
+;  from Jean-loup Gailly in deflate.c of zLib and infoZip zip.
+;  and by taking inspiration on asm686 with masm, optimised assembly code
+;        from Brian Raiter, written 1998
+;
+;  This software is provided 'as-is', without any express or implied
+;  warranty.  In no event will the authors be held liable for any damages
+;  arising from the use of this software.
+;
+;  Permission is granted to anyone to use this software for any purpose,
+;  including commercial applications, and to alter it and redistribute it
+;  freely, subject to the following restrictions:
+;
+;  1. The origin of this software must not be misrepresented; you must not
+;     claim that you wrote the original software. If you use this software
+;     in a product, an acknowledgment in the product documentation would be
+;     appreciated but is not required.
+;  2. Altered source versions must be plainly marked as such, and must not be
+;     misrepresented as being the original software
+;  3. This notice may not be removed or altered from any source distribution.
+;
+;         http://www.zlib.net
+;         http://www.winimage.com/zLibDll
+;         http://www.muppetlabs.com/~breadbox/software/assembly.html
+;
+; to compile this file for zLib, I use option:
+;   gcc -c -arch x86_64 gvmat64.S
+
+
+;uInt longest_match(s, cur_match)
+;    deflate_state *s;
+;    IPos cur_match;                             // current match /
+;
+; with XCode for Mac, I had strange error with some jump on intel syntax
+; this is why BEFORE_JMP and AFTER_JMP are used
+ */
+
+
+#define BEFORE_JMP .att_syntax
+#define AFTER_JMP .intel_syntax noprefix
+
+#ifndef NO_UNDERLINE
+#	define	match_init	_match_init
+#	define	longest_match	_longest_match
+#endif
+
+.intel_syntax noprefix
+
+.globl	match_init, longest_match
+.text
+longest_match:
+
+
+
+#define LocalVarsSize 96
+/*
+; register used : rax,rbx,rcx,rdx,rsi,rdi,r8,r9,r10,r11,r12
+; free register :  r14,r15
+; register can be saved : rsp
+*/
+
+#define chainlenwmask     (rsp + 8 - LocalVarsSize)
+#define nicematch         (rsp + 16 - LocalVarsSize)
+
+#define save_rdi        (rsp + 24 - LocalVarsSize)
+#define save_rsi        (rsp + 32 - LocalVarsSize)
+#define save_rbx        (rsp + 40 - LocalVarsSize)
+#define save_rbp        (rsp + 48 - LocalVarsSize)
+#define save_r12        (rsp + 56 - LocalVarsSize)
+#define save_r13        (rsp + 64 - LocalVarsSize)
+#define save_r14        (rsp + 72 - LocalVarsSize)
+#define save_r15        (rsp + 80 - LocalVarsSize)
+
+
+/*
+;  all the +4 offsets are due to the addition of pending_buf_size (in zlib
+;  in the deflate_state structure since the asm code was first written
+;  (if you compile with zlib 1.0.4 or older, remove the +4).
+;  Note : these value are good with a 8 bytes boundary pack structure
+*/
+
+#define    MAX_MATCH              258
+#define    MIN_MATCH              3
+#define    MIN_LOOKAHEAD          (MAX_MATCH+MIN_MATCH+1)
+
+/*
+;;; Offsets for fields in the deflate_state structure. These numbers
+;;; are calculated from the definition of deflate_state, with the
+;;; assumption that the compiler will dword-align the fields. (Thus,
+;;; changing the definition of deflate_state could easily cause this
+;;; program to crash horribly, without so much as a warning at
+;;; compile time. Sigh.)
+
+;  all the +zlib1222add offsets are due to the addition of fields
+;  in zlib in the deflate_state structure since the asm code was first written
+;  (if you compile with zlib 1.0.4 or older, use "zlib1222add equ (-4)").
+;  (if you compile with zlib between 1.0.5 and 1.2.2.1, use "zlib1222add equ 0").
+;  if you compile with zlib 1.2.2.2 or later , use "zlib1222add equ 8").
+*/
+
+
+
+/* you can check the structure offset by running
+
+#include <stdlib.h>
+#include <stdio.h>
+#include "deflate.h"
+
+void print_depl()
+{
+deflate_state ds;
+deflate_state *s=&ds;
+printf("size pointer=%u\n",(int)sizeof(void*));
+
+printf("#define dsWSize         %u\n",(int)(((char*)&(s->w_size))-((char*)s)));
+printf("#define dsWMask         %u\n",(int)(((char*)&(s->w_mask))-((char*)s)));
+printf("#define dsWindow        %u\n",(int)(((char*)&(s->window))-((char*)s)));
+printf("#define dsPrev          %u\n",(int)(((char*)&(s->prev))-((char*)s)));
+printf("#define dsMatchLen      %u\n",(int)(((char*)&(s->match_length))-((char*)s)));
+printf("#define dsPrevMatch     %u\n",(int)(((char*)&(s->prev_match))-((char*)s)));
+printf("#define dsStrStart      %u\n",(int)(((char*)&(s->strstart))-((char*)s)));
+printf("#define dsMatchStart    %u\n",(int)(((char*)&(s->match_start))-((char*)s)));
+printf("#define dsLookahead     %u\n",(int)(((char*)&(s->lookahead))-((char*)s)));
+printf("#define dsPrevLen       %u\n",(int)(((char*)&(s->prev_length))-((char*)s)));
+printf("#define dsMaxChainLen   %u\n",(int)(((char*)&(s->max_chain_length))-((char*)s)));
+printf("#define dsGoodMatch     %u\n",(int)(((char*)&(s->good_match))-((char*)s)));
+printf("#define dsNiceMatch     %u\n",(int)(((char*)&(s->nice_match))-((char*)s)));
+}
+*/
+
+#define dsWSize          68
+#define dsWMask          76
+#define dsWindow         80
+#define dsPrev           96
+#define dsMatchLen       144
+#define dsPrevMatch      148
+#define dsStrStart       156
+#define dsMatchStart     160
+#define dsLookahead      164
+#define dsPrevLen        168
+#define dsMaxChainLen    172
+#define dsGoodMatch      188
+#define dsNiceMatch      192
+
+#define window_size      [ rcx + dsWSize]
+#define WMask            [ rcx + dsWMask]
+#define window_ad        [ rcx + dsWindow]
+#define prev_ad          [ rcx + dsPrev]
+#define strstart         [ rcx + dsStrStart]
+#define match_start      [ rcx + dsMatchStart]
+#define Lookahead        [ rcx + dsLookahead] //; 0ffffffffh on infozip
+#define prev_length      [ rcx + dsPrevLen]
+#define max_chain_length [ rcx + dsMaxChainLen]
+#define good_match       [ rcx + dsGoodMatch]
+#define nice_match       [ rcx + dsNiceMatch]
+
+/*
+; windows:
+; parameter 1 in rcx(deflate state s), param 2 in rdx (cur match)
+
+; see http://weblogs.asp.net/oldnewthing/archive/2004/01/14/58579.aspx and
+; http://msdn.microsoft.com/library/en-us/kmarch/hh/kmarch/64bitAMD_8e951dd2-ee77-4728-8702-55ce4b5dd24a.xml.asp
+;
+; All registers must be preserved across the call, except for
+;   rax, rcx, rdx, r8, r9, r10, and r11, which are scratch.
+
+;
+; gcc on macosx-linux:
+; see http://www.x86-64.org/documentation/abi-0.99.pdf
+; param 1 in rdi, param 2 in rsi
+; rbx, rsp, rbp, r12 to r15 must be preserved
+
+;;; Save registers that the compiler may be using, and adjust esp to
+;;; make room for our stack frame.
+
+
+;;; Retrieve the function arguments. r8d will hold cur_match
+;;; throughout the entire function. edx will hold the pointer to the
+;;; deflate_state structure during the function's setup (before
+;;; entering the main loop.
+
+; ms: parameter 1 in rcx (deflate_state* s), param 2 in edx -> r8 (cur match)
+; mac: param 1 in rdi, param 2 rsi
+; this clear high 32 bits of r8, which can be garbage in both r8 and rdx
+*/
+        mov [save_rbx],rbx
+        mov [save_rbp],rbp
+
+
+        mov rcx,rdi
+
+        mov r8d,esi
+
+
+        mov [save_r12],r12
+        mov [save_r13],r13
+        mov [save_r14],r14
+        mov [save_r15],r15
+
+
+//;;; uInt wmask = s->w_mask;
+//;;; unsigned chain_length = s->max_chain_length;
+//;;; if (s->prev_length >= s->good_match) {
+//;;;     chain_length >>= 2;
+//;;; }
+
+
+        mov edi, prev_length
+        mov esi, good_match
+        mov eax, WMask
+        mov ebx, max_chain_length
+        cmp edi, esi
+        jl  LastMatchGood
+        shr ebx, 2
+LastMatchGood:
+
+//;;; chainlen is decremented once beforehand so that the function can
+//;;; use the sign flag instead of the zero flag for the exit test.
+//;;; It is then shifted into the high word, to make room for the wmask
+//;;; value, which it will always accompany.
+
+        dec ebx
+        shl ebx, 16
+        or  ebx, eax
+
+//;;; on zlib only
+//;;; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
+
+
+
+        mov eax, nice_match
+        mov [chainlenwmask], ebx
+        mov r10d, Lookahead
+        cmp r10d, eax
+        cmovnl r10d, eax
+        mov [nicematch],r10d
+
+
+
+//;;; register Bytef *scan = s->window + s->strstart;
+        mov r10, window_ad
+        mov ebp, strstart
+        lea r13, [r10 + rbp]
+
+//;;; Determine how many bytes the scan ptr is off from being
+//;;; dword-aligned.
+
+         mov r9,r13
+         neg r13
+         and r13,3
+
+//;;; IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
+//;;;     s->strstart - (IPos)MAX_DIST(s) : NIL;
+
+
+        mov eax, window_size
+        sub eax, MIN_LOOKAHEAD
+
+
+        xor edi,edi
+        sub ebp, eax
+
+        mov r11d, prev_length
+
+        cmovng ebp,edi
+
+//;;; int best_len = s->prev_length;
+
+
+//;;; Store the sum of s->window + best_len in esi locally, and in esi.
+
+       lea  rsi,[r10+r11]
+
+//;;; register ush scan_start = *(ushf*)scan;
+//;;; register ush scan_end   = *(ushf*)(scan+best_len-1);
+//;;; Posf *prev = s->prev;
+
+        movzx r12d,word ptr [r9]
+        movzx ebx, word ptr [r9 + r11 - 1]
+
+        mov rdi, prev_ad
+
+//;;; Jump into the main loop.
+
+        mov edx, [chainlenwmask]
+
+        cmp bx,word ptr [rsi + r8 - 1]
+        jz  LookupLoopIsZero
+				
+						
+						
+LookupLoop1:
+        and r8d, edx
+
+        movzx   r8d, word ptr [rdi + r8*2]
+        cmp r8d, ebp
+        jbe LeaveNow
+		
+		
+		
+        sub edx, 0x00010000
+		BEFORE_JMP
+        js  LeaveNow
+		AFTER_JMP
+
+LoopEntry1:
+        cmp bx,word ptr [rsi + r8 - 1]
+		BEFORE_JMP
+        jz  LookupLoopIsZero
+		AFTER_JMP
+
+LookupLoop2:
+        and r8d, edx
+
+        movzx   r8d, word ptr [rdi + r8*2]
+        cmp r8d, ebp
+		BEFORE_JMP
+        jbe LeaveNow
+		AFTER_JMP
+        sub edx, 0x00010000
+		BEFORE_JMP
+        js  LeaveNow
+		AFTER_JMP
+
+LoopEntry2:
+        cmp bx,word ptr [rsi + r8 - 1]
+		BEFORE_JMP
+        jz  LookupLoopIsZero
+		AFTER_JMP
+
+LookupLoop4:
+        and r8d, edx
+
+        movzx   r8d, word ptr [rdi + r8*2]
+        cmp r8d, ebp
+		BEFORE_JMP
+        jbe LeaveNow
+		AFTER_JMP
+        sub edx, 0x00010000
+		BEFORE_JMP
+        js  LeaveNow
+		AFTER_JMP
+
+LoopEntry4:
+
+        cmp bx,word ptr [rsi + r8 - 1]
+		BEFORE_JMP
+        jnz LookupLoop1
+        jmp LookupLoopIsZero
+		AFTER_JMP
+/*
+;;; do {
+;;;     match = s->window + cur_match;
+;;;     if (*(ushf*)(match+best_len-1) != scan_end ||
+;;;         *(ushf*)match != scan_start) continue;
+;;;     [...]
+;;; } while ((cur_match = prev[cur_match & wmask]) > limit
+;;;          && --chain_length != 0);
+;;;
+;;; Here is the inner loop of the function. The function will spend the
+;;; majority of its time in this loop, and majority of that time will
+;;; be spent in the first ten instructions.
+;;;
+;;; Within this loop:
+;;; ebx = scanend
+;;; r8d = curmatch
+;;; edx = chainlenwmask - i.e., ((chainlen << 16) | wmask)
+;;; esi = windowbestlen - i.e., (window + bestlen)
+;;; edi = prev
+;;; ebp = limit
+*/
+.balign 16
+LookupLoop:
+        and r8d, edx
+
+        movzx   r8d, word ptr [rdi + r8*2]
+        cmp r8d, ebp
+		BEFORE_JMP
+        jbe LeaveNow
+		AFTER_JMP
+        sub edx, 0x00010000
+		BEFORE_JMP
+        js  LeaveNow
+		AFTER_JMP
+
+LoopEntry:
+
+        cmp bx,word ptr [rsi + r8 - 1]
+		BEFORE_JMP
+        jnz LookupLoop1
+		AFTER_JMP
+LookupLoopIsZero:
+        cmp     r12w, word ptr [r10 + r8]
+		BEFORE_JMP
+        jnz LookupLoop1
+		AFTER_JMP
+
+
+//;;; Store the current value of chainlen.
+        mov [chainlenwmask], edx
+/*
+;;; Point edi to the string under scrutiny, and esi to the string we
+;;; are hoping to match it up with. In actuality, esi and edi are
+;;; both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and edx is
+;;; initialized to -(MAX_MATCH_8 - scanalign).
+*/
+        lea rsi,[r8+r10]
+        mov rdx, 0xfffffffffffffef8 //; -(MAX_MATCH_8)
+        lea rsi, [rsi + r13 + 0x0108] //;MAX_MATCH_8]
+        lea rdi, [r9 + r13 + 0x0108] //;MAX_MATCH_8]
+
+        prefetcht1 [rsi+rdx]
+        prefetcht1 [rdi+rdx]
+
+/*
+;;; Test the strings for equality, 8 bytes at a time. At the end,
+;;; adjust rdx so that it is offset to the exact byte that mismatched.
+;;;
+;;; We already know at this point that the first three bytes of the
+;;; strings match each other, and they can be safely passed over before
+;;; starting the compare loop. So what this code does is skip over 0-3
+;;; bytes, as much as necessary in order to dword-align the edi
+;;; pointer. (rsi will still be misaligned three times out of four.)
+;;;
+;;; It should be confessed that this loop usually does not represent
+;;; much of the total running time. Replacing it with a more
+;;; straightforward "rep cmpsb" would not drastically degrade
+;;; performance.
+*/
+
+LoopCmps:
+        mov rax, [rsi + rdx]
+        xor rax, [rdi + rdx]
+        jnz LeaveLoopCmps
+
+        mov rax, [rsi + rdx + 8]
+        xor rax, [rdi + rdx + 8]
+        jnz LeaveLoopCmps8
+
+
+        mov rax, [rsi + rdx + 8+8]
+        xor rax, [rdi + rdx + 8+8]
+        jnz LeaveLoopCmps16
+
+        add rdx,8+8+8
+
+		BEFORE_JMP
+        jnz  LoopCmps
+        jmp  LenMaximum
+		AFTER_JMP
+		
+LeaveLoopCmps16: add rdx,8
+LeaveLoopCmps8: add rdx,8
+LeaveLoopCmps:
+
+        test    eax, 0x0000FFFF
+        jnz LenLower
+
+        test eax,0xffffffff
+
+        jnz LenLower32
+
+        add rdx,4
+        shr rax,32
+        or ax,ax
+		BEFORE_JMP
+        jnz LenLower
+		AFTER_JMP
+
+LenLower32:
+        shr eax,16
+        add rdx,2
+		
+LenLower:		
+        sub al, 1
+        adc rdx, 0
+//;;; Calculate the length of the match. If it is longer than MAX_MATCH,
+//;;; then automatically accept it as the best possible match and leave.
+
+        lea rax, [rdi + rdx]
+        sub rax, r9
+        cmp eax, MAX_MATCH
+		BEFORE_JMP
+        jge LenMaximum
+		AFTER_JMP
+/*
+;;; If the length of the match is not longer than the best match we
+;;; have so far, then forget it and return to the lookup loop.
+;///////////////////////////////////
+*/
+        cmp eax, r11d
+        jg  LongerMatch
+
+        lea rsi,[r10+r11]
+
+        mov rdi, prev_ad
+        mov edx, [chainlenwmask]
+		BEFORE_JMP
+        jmp LookupLoop
+		AFTER_JMP
+/*
+;;;         s->match_start = cur_match;
+;;;         best_len = len;
+;;;         if (len >= nice_match) break;
+;;;         scan_end = *(ushf*)(scan+best_len-1);
+*/
+LongerMatch:
+        mov r11d, eax
+        mov match_start, r8d
+        cmp eax, [nicematch]
+		BEFORE_JMP
+        jge LeaveNow
+		AFTER_JMP
+
+        lea rsi,[r10+rax]
+
+        movzx   ebx, word ptr [r9 + rax - 1]
+        mov rdi, prev_ad
+        mov edx, [chainlenwmask]
+		BEFORE_JMP
+        jmp LookupLoop
+		AFTER_JMP
+
+//;;; Accept the current string, with the maximum possible length.
+
+LenMaximum:
+        mov r11d,MAX_MATCH
+        mov match_start, r8d
+
+//;;; if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
+//;;; return s->lookahead;
+
+LeaveNow:
+        mov eax, Lookahead
+        cmp r11d, eax
+        cmovng eax, r11d
+
+
+
+//;;; Restore the stack and return from whence we came.
+
+
+//        mov rsi,[save_rsi]
+//        mov rdi,[save_rdi]
+        mov rbx,[save_rbx]
+        mov rbp,[save_rbp]
+        mov r12,[save_r12]
+        mov r13,[save_r13]
+        mov r14,[save_r14]
+        mov r15,[save_r15]
+
+
+        ret 0
+//; please don't remove this string !
+//; Your can freely use gvmat64 in any free or commercial app
+//; but it is far better don't remove the string in the binary!
+ //   db     0dh,0ah,"asm686 with masm, optimised assembly code from Brian Raiter, written 1998, converted to amd 64 by Gilles Vollant 2005",0dh,0ah,0
+
+
+match_init:
+  ret 0
+
+
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/infback9/README b/Engine/lib/assimp/contrib/zlib/contrib/infback9/README
new file mode 100644
index 000000000..e75ed1329
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/infback9/README
@@ -0,0 +1 @@
+See infback9.h for what this is and how to use it.
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/infback9/infback9.c b/Engine/lib/assimp/contrib/zlib/contrib/infback9/infback9.c
new file mode 100644
index 000000000..05fb3e338
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/infback9/infback9.c
@@ -0,0 +1,615 @@
+/* infback9.c -- inflate deflate64 data using a call-back interface
+ * Copyright (C) 1995-2008 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "zutil.h"
+#include "infback9.h"
+#include "inftree9.h"
+#include "inflate9.h"
+
+#define WSIZE 65536UL
+
+/*
+   strm provides memory allocation functions in zalloc and zfree, or
+   Z_NULL to use the library memory allocation functions.
+
+   window is a user-supplied window and output buffer that is 64K bytes.
+ */
+int ZEXPORT inflateBack9Init_(strm, window, version, stream_size)
+z_stream FAR *strm;
+unsigned char FAR *window;
+const char *version;
+int stream_size;
+{
+    struct inflate_state FAR *state;
+
+    if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
+        stream_size != (int)(sizeof(z_stream)))
+        return Z_VERSION_ERROR;
+    if (strm == Z_NULL || window == Z_NULL)
+        return Z_STREAM_ERROR;
+    strm->msg = Z_NULL;                 /* in case we return an error */
+    if (strm->zalloc == (alloc_func)0) {
+        strm->zalloc = zcalloc;
+        strm->opaque = (voidpf)0;
+    }
+    if (strm->zfree == (free_func)0) strm->zfree = zcfree;
+    state = (struct inflate_state FAR *)ZALLOC(strm, 1,
+                                               sizeof(struct inflate_state));
+    if (state == Z_NULL) return Z_MEM_ERROR;
+    Tracev((stderr, "inflate: allocated\n"));
+    strm->state = (voidpf)state;
+    state->window = window;
+    return Z_OK;
+}
+
+/*
+   Build and output length and distance decoding tables for fixed code
+   decoding.
+ */
+#ifdef MAKEFIXED
+#include <stdio.h>
+
+void makefixed9(void)
+{
+    unsigned sym, bits, low, size;
+    code *next, *lenfix, *distfix;
+    struct inflate_state state;
+    code fixed[544];
+
+    /* literal/length table */
+    sym = 0;
+    while (sym < 144) state.lens[sym++] = 8;
+    while (sym < 256) state.lens[sym++] = 9;
+    while (sym < 280) state.lens[sym++] = 7;
+    while (sym < 288) state.lens[sym++] = 8;
+    next = fixed;
+    lenfix = next;
+    bits = 9;
+    inflate_table9(LENS, state.lens, 288, &(next), &(bits), state.work);
+
+    /* distance table */
+    sym = 0;
+    while (sym < 32) state.lens[sym++] = 5;
+    distfix = next;
+    bits = 5;
+    inflate_table9(DISTS, state.lens, 32, &(next), &(bits), state.work);
+
+    /* write tables */
+    puts("    /* inffix9.h -- table for decoding deflate64 fixed codes");
+    puts("     * Generated automatically by makefixed9().");
+    puts("     */");
+    puts("");
+    puts("    /* WARNING: this file should *not* be used by applications.");
+    puts("       It is part of the implementation of this library and is");
+    puts("       subject to change. Applications should only use zlib.h.");
+    puts("     */");
+    puts("");
+    size = 1U << 9;
+    printf("    static const code lenfix[%u] = {", size);
+    low = 0;
+    for (;;) {
+        if ((low % 6) == 0) printf("\n        ");
+        printf("{%u,%u,%d}", lenfix[low].op, lenfix[low].bits,
+               lenfix[low].val);
+        if (++low == size) break;
+        putchar(',');
+    }
+    puts("\n    };");
+    size = 1U << 5;
+    printf("\n    static const code distfix[%u] = {", size);
+    low = 0;
+    for (;;) {
+        if ((low % 5) == 0) printf("\n        ");
+        printf("{%u,%u,%d}", distfix[low].op, distfix[low].bits,
+               distfix[low].val);
+        if (++low == size) break;
+        putchar(',');
+    }
+    puts("\n    };");
+}
+#endif /* MAKEFIXED */
+
+/* Macros for inflateBack(): */
+
+/* Clear the input bit accumulator */
+#define INITBITS() \
+    do { \
+        hold = 0; \
+        bits = 0; \
+    } while (0)
+
+/* Assure that some input is available.  If input is requested, but denied,
+   then return a Z_BUF_ERROR from inflateBack(). */
+#define PULL() \
+    do { \
+        if (have == 0) { \
+            have = in(in_desc, &next); \
+            if (have == 0) { \
+                next = Z_NULL; \
+                ret = Z_BUF_ERROR; \
+                goto inf_leave; \
+            } \
+        } \
+    } while (0)
+
+/* Get a byte of input into the bit accumulator, or return from inflateBack()
+   with an error if there is no input available. */
+#define PULLBYTE() \
+    do { \
+        PULL(); \
+        have--; \
+        hold += (unsigned long)(*next++) << bits; \
+        bits += 8; \
+    } while (0)
+
+/* Assure that there are at least n bits in the bit accumulator.  If there is
+   not enough available input to do that, then return from inflateBack() with
+   an error. */
+#define NEEDBITS(n) \
+    do { \
+        while (bits < (unsigned)(n)) \
+            PULLBYTE(); \
+    } while (0)
+
+/* Return the low n bits of the bit accumulator (n <= 16) */
+#define BITS(n) \
+    ((unsigned)hold & ((1U << (n)) - 1))
+
+/* Remove n bits from the bit accumulator */
+#define DROPBITS(n) \
+    do { \
+        hold >>= (n); \
+        bits -= (unsigned)(n); \
+    } while (0)
+
+/* Remove zero to seven bits as needed to go to a byte boundary */
+#define BYTEBITS() \
+    do { \
+        hold >>= bits & 7; \
+        bits -= bits & 7; \
+    } while (0)
+
+/* Assure that some output space is available, by writing out the window
+   if it's full.  If the write fails, return from inflateBack() with a
+   Z_BUF_ERROR. */
+#define ROOM() \
+    do { \
+        if (left == 0) { \
+            put = window; \
+            left = WSIZE; \
+            wrap = 1; \
+            if (out(out_desc, put, (unsigned)left)) { \
+                ret = Z_BUF_ERROR; \
+                goto inf_leave; \
+            } \
+        } \
+    } while (0)
+
+/*
+   strm provides the memory allocation functions and window buffer on input,
+   and provides information on the unused input on return.  For Z_DATA_ERROR
+   returns, strm will also provide an error message.
+
+   in() and out() are the call-back input and output functions.  When
+   inflateBack() needs more input, it calls in().  When inflateBack() has
+   filled the window with output, or when it completes with data in the
+   window, it calls out() to write out the data.  The application must not
+   change the provided input until in() is called again or inflateBack()
+   returns.  The application must not change the window/output buffer until
+   inflateBack() returns.
+
+   in() and out() are called with a descriptor parameter provided in the
+   inflateBack() call.  This parameter can be a structure that provides the
+   information required to do the read or write, as well as accumulated
+   information on the input and output such as totals and check values.
+
+   in() should return zero on failure.  out() should return non-zero on
+   failure.  If either in() or out() fails, than inflateBack() returns a
+   Z_BUF_ERROR.  strm->next_in can be checked for Z_NULL to see whether it
+   was in() or out() that caused in the error.  Otherwise,  inflateBack()
+   returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format
+   error, or Z_MEM_ERROR if it could not allocate memory for the state.
+   inflateBack() can also return Z_STREAM_ERROR if the input parameters
+   are not correct, i.e. strm is Z_NULL or the state was not initialized.
+ */
+int ZEXPORT inflateBack9(strm, in, in_desc, out, out_desc)
+z_stream FAR *strm;
+in_func in;
+void FAR *in_desc;
+out_func out;
+void FAR *out_desc;
+{
+    struct inflate_state FAR *state;
+    z_const unsigned char FAR *next;    /* next input */
+    unsigned char FAR *put;     /* next output */
+    unsigned have;              /* available input */
+    unsigned long left;         /* available output */
+    inflate_mode mode;          /* current inflate mode */
+    int lastblock;              /* true if processing last block */
+    int wrap;                   /* true if the window has wrapped */
+    unsigned char FAR *window;  /* allocated sliding window, if needed */
+    unsigned long hold;         /* bit buffer */
+    unsigned bits;              /* bits in bit buffer */
+    unsigned extra;             /* extra bits needed */
+    unsigned long length;       /* literal or length of data to copy */
+    unsigned long offset;       /* distance back to copy string from */
+    unsigned long copy;         /* number of stored or match bytes to copy */
+    unsigned char FAR *from;    /* where to copy match bytes from */
+    code const FAR *lencode;    /* starting table for length/literal codes */
+    code const FAR *distcode;   /* starting table for distance codes */
+    unsigned lenbits;           /* index bits for lencode */
+    unsigned distbits;          /* index bits for distcode */
+    code here;                  /* current decoding table entry */
+    code last;                  /* parent table entry */
+    unsigned len;               /* length to copy for repeats, bits to drop */
+    int ret;                    /* return code */
+    static const unsigned short order[19] = /* permutation of code lengths */
+        {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
+#include "inffix9.h"
+
+    /* Check that the strm exists and that the state was initialized */
+    if (strm == Z_NULL || strm->state == Z_NULL)
+        return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+
+    /* Reset the state */
+    strm->msg = Z_NULL;
+    mode = TYPE;
+    lastblock = 0;
+    wrap = 0;
+    window = state->window;
+    next = strm->next_in;
+    have = next != Z_NULL ? strm->avail_in : 0;
+    hold = 0;
+    bits = 0;
+    put = window;
+    left = WSIZE;
+    lencode = Z_NULL;
+    distcode = Z_NULL;
+
+    /* Inflate until end of block marked as last */
+    for (;;)
+        switch (mode) {
+        case TYPE:
+            /* determine and dispatch block type */
+            if (lastblock) {
+                BYTEBITS();
+                mode = DONE;
+                break;
+            }
+            NEEDBITS(3);
+            lastblock = BITS(1);
+            DROPBITS(1);
+            switch (BITS(2)) {
+            case 0:                             /* stored block */
+                Tracev((stderr, "inflate:     stored block%s\n",
+                        lastblock ? " (last)" : ""));
+                mode = STORED;
+                break;
+            case 1:                             /* fixed block */
+                lencode = lenfix;
+                lenbits = 9;
+                distcode = distfix;
+                distbits = 5;
+                Tracev((stderr, "inflate:     fixed codes block%s\n",
+                        lastblock ? " (last)" : ""));
+                mode = LEN;                     /* decode codes */
+                break;
+            case 2:                             /* dynamic block */
+                Tracev((stderr, "inflate:     dynamic codes block%s\n",
+                        lastblock ? " (last)" : ""));
+                mode = TABLE;
+                break;
+            case 3:
+                strm->msg = (char *)"invalid block type";
+                mode = BAD;
+            }
+            DROPBITS(2);
+            break;
+
+        case STORED:
+            /* get and verify stored block length */
+            BYTEBITS();                         /* go to byte boundary */
+            NEEDBITS(32);
+            if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
+                strm->msg = (char *)"invalid stored block lengths";
+                mode = BAD;
+                break;
+            }
+            length = (unsigned)hold & 0xffff;
+            Tracev((stderr, "inflate:       stored length %lu\n",
+                    length));
+            INITBITS();
+
+            /* copy stored block from input to output */
+            while (length != 0) {
+                copy = length;
+                PULL();
+                ROOM();
+                if (copy > have) copy = have;
+                if (copy > left) copy = left;
+                zmemcpy(put, next, copy);
+                have -= copy;
+                next += copy;
+                left -= copy;
+                put += copy;
+                length -= copy;
+            }
+            Tracev((stderr, "inflate:       stored end\n"));
+            mode = TYPE;
+            break;
+
+        case TABLE:
+            /* get dynamic table entries descriptor */
+            NEEDBITS(14);
+            state->nlen = BITS(5) + 257;
+            DROPBITS(5);
+            state->ndist = BITS(5) + 1;
+            DROPBITS(5);
+            state->ncode = BITS(4) + 4;
+            DROPBITS(4);
+            if (state->nlen > 286) {
+                strm->msg = (char *)"too many length symbols";
+                mode = BAD;
+                break;
+            }
+            Tracev((stderr, "inflate:       table sizes ok\n"));
+
+            /* get code length code lengths (not a typo) */
+            state->have = 0;
+            while (state->have < state->ncode) {
+                NEEDBITS(3);
+                state->lens[order[state->have++]] = (unsigned short)BITS(3);
+                DROPBITS(3);
+            }
+            while (state->have < 19)
+                state->lens[order[state->have++]] = 0;
+            state->next = state->codes;
+            lencode = (code const FAR *)(state->next);
+            lenbits = 7;
+            ret = inflate_table9(CODES, state->lens, 19, &(state->next),
+                                &(lenbits), state->work);
+            if (ret) {
+                strm->msg = (char *)"invalid code lengths set";
+                mode = BAD;
+                break;
+            }
+            Tracev((stderr, "inflate:       code lengths ok\n"));
+
+            /* get length and distance code code lengths */
+            state->have = 0;
+            while (state->have < state->nlen + state->ndist) {
+                for (;;) {
+                    here = lencode[BITS(lenbits)];
+                    if ((unsigned)(here.bits) <= bits) break;
+                    PULLBYTE();
+                }
+                if (here.val < 16) {
+                    NEEDBITS(here.bits);
+                    DROPBITS(here.bits);
+                    state->lens[state->have++] = here.val;
+                }
+                else {
+                    if (here.val == 16) {
+                        NEEDBITS(here.bits + 2);
+                        DROPBITS(here.bits);
+                        if (state->have == 0) {
+                            strm->msg = (char *)"invalid bit length repeat";
+                            mode = BAD;
+                            break;
+                        }
+                        len = (unsigned)(state->lens[state->have - 1]);
+                        copy = 3 + BITS(2);
+                        DROPBITS(2);
+                    }
+                    else if (here.val == 17) {
+                        NEEDBITS(here.bits + 3);
+                        DROPBITS(here.bits);
+                        len = 0;
+                        copy = 3 + BITS(3);
+                        DROPBITS(3);
+                    }
+                    else {
+                        NEEDBITS(here.bits + 7);
+                        DROPBITS(here.bits);
+                        len = 0;
+                        copy = 11 + BITS(7);
+                        DROPBITS(7);
+                    }
+                    if (state->have + copy > state->nlen + state->ndist) {
+                        strm->msg = (char *)"invalid bit length repeat";
+                        mode = BAD;
+                        break;
+                    }
+                    while (copy--)
+                        state->lens[state->have++] = (unsigned short)len;
+                }
+            }
+
+            /* handle error breaks in while */
+            if (mode == BAD) break;
+
+            /* check for end-of-block code (better have one) */
+            if (state->lens[256] == 0) {
+                strm->msg = (char *)"invalid code -- missing end-of-block";
+                mode = BAD;
+                break;
+            }
+
+            /* build code tables -- note: do not change the lenbits or distbits
+               values here (9 and 6) without reading the comments in inftree9.h
+               concerning the ENOUGH constants, which depend on those values */
+            state->next = state->codes;
+            lencode = (code const FAR *)(state->next);
+            lenbits = 9;
+            ret = inflate_table9(LENS, state->lens, state->nlen,
+                            &(state->next), &(lenbits), state->work);
+            if (ret) {
+                strm->msg = (char *)"invalid literal/lengths set";
+                mode = BAD;
+                break;
+            }
+            distcode = (code const FAR *)(state->next);
+            distbits = 6;
+            ret = inflate_table9(DISTS, state->lens + state->nlen,
+                            state->ndist, &(state->next), &(distbits),
+                            state->work);
+            if (ret) {
+                strm->msg = (char *)"invalid distances set";
+                mode = BAD;
+                break;
+            }
+            Tracev((stderr, "inflate:       codes ok\n"));
+            mode = LEN;
+
+        case LEN:
+            /* get a literal, length, or end-of-block code */
+            for (;;) {
+                here = lencode[BITS(lenbits)];
+                if ((unsigned)(here.bits) <= bits) break;
+                PULLBYTE();
+            }
+            if (here.op && (here.op & 0xf0) == 0) {
+                last = here;
+                for (;;) {
+                    here = lencode[last.val +
+                            (BITS(last.bits + last.op) >> last.bits)];
+                    if ((unsigned)(last.bits + here.bits) <= bits) break;
+                    PULLBYTE();
+                }
+                DROPBITS(last.bits);
+            }
+            DROPBITS(here.bits);
+            length = (unsigned)here.val;
+
+            /* process literal */
+            if (here.op == 0) {
+                Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
+                        "inflate:         literal '%c'\n" :
+                        "inflate:         literal 0x%02x\n", here.val));
+                ROOM();
+                *put++ = (unsigned char)(length);
+                left--;
+                mode = LEN;
+                break;
+            }
+
+            /* process end of block */
+            if (here.op & 32) {
+                Tracevv((stderr, "inflate:         end of block\n"));
+                mode = TYPE;
+                break;
+            }
+
+            /* invalid code */
+            if (here.op & 64) {
+                strm->msg = (char *)"invalid literal/length code";
+                mode = BAD;
+                break;
+            }
+
+            /* length code -- get extra bits, if any */
+            extra = (unsigned)(here.op) & 31;
+            if (extra != 0) {
+                NEEDBITS(extra);
+                length += BITS(extra);
+                DROPBITS(extra);
+            }
+            Tracevv((stderr, "inflate:         length %lu\n", length));
+
+            /* get distance code */
+            for (;;) {
+                here = distcode[BITS(distbits)];
+                if ((unsigned)(here.bits) <= bits) break;
+                PULLBYTE();
+            }
+            if ((here.op & 0xf0) == 0) {
+                last = here;
+                for (;;) {
+                    here = distcode[last.val +
+                            (BITS(last.bits + last.op) >> last.bits)];
+                    if ((unsigned)(last.bits + here.bits) <= bits) break;
+                    PULLBYTE();
+                }
+                DROPBITS(last.bits);
+            }
+            DROPBITS(here.bits);
+            if (here.op & 64) {
+                strm->msg = (char *)"invalid distance code";
+                mode = BAD;
+                break;
+            }
+            offset = (unsigned)here.val;
+
+            /* get distance extra bits, if any */
+            extra = (unsigned)(here.op) & 15;
+            if (extra != 0) {
+                NEEDBITS(extra);
+                offset += BITS(extra);
+                DROPBITS(extra);
+            }
+            if (offset > WSIZE - (wrap ? 0: left)) {
+                strm->msg = (char *)"invalid distance too far back";
+                mode = BAD;
+                break;
+            }
+            Tracevv((stderr, "inflate:         distance %lu\n", offset));
+
+            /* copy match from window to output */
+            do {
+                ROOM();
+                copy = WSIZE - offset;
+                if (copy < left) {
+                    from = put + copy;
+                    copy = left - copy;
+                }
+                else {
+                    from = put - offset;
+                    copy = left;
+                }
+                if (copy > length) copy = length;
+                length -= copy;
+                left -= copy;
+                do {
+                    *put++ = *from++;
+                } while (--copy);
+            } while (length != 0);
+            break;
+
+        case DONE:
+            /* inflate stream terminated properly -- write leftover output */
+            ret = Z_STREAM_END;
+            if (left < WSIZE) {
+                if (out(out_desc, window, (unsigned)(WSIZE - left)))
+                    ret = Z_BUF_ERROR;
+            }
+            goto inf_leave;
+
+        case BAD:
+            ret = Z_DATA_ERROR;
+            goto inf_leave;
+
+        default:                /* can't happen, but makes compilers happy */
+            ret = Z_STREAM_ERROR;
+            goto inf_leave;
+        }
+
+    /* Return unused input */
+  inf_leave:
+    strm->next_in = next;
+    strm->avail_in = have;
+    return ret;
+}
+
+int ZEXPORT inflateBack9End(strm)
+z_stream FAR *strm;
+{
+    if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
+        return Z_STREAM_ERROR;
+    ZFREE(strm, strm->state);
+    strm->state = Z_NULL;
+    Tracev((stderr, "inflate: end\n"));
+    return Z_OK;
+}
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/infback9/infback9.h b/Engine/lib/assimp/contrib/zlib/contrib/infback9/infback9.h
new file mode 100644
index 000000000..1073c0a38
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/infback9/infback9.h
@@ -0,0 +1,37 @@
+/* infback9.h -- header for using inflateBack9 functions
+ * Copyright (C) 2003 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/*
+ * This header file and associated patches provide a decoder for PKWare's
+ * undocumented deflate64 compression method (method 9).  Use with infback9.c,
+ * inftree9.h, inftree9.c, and inffix9.h.  These patches are not supported.
+ * This should be compiled with zlib, since it uses zutil.h and zutil.o.
+ * This code has not yet been tested on 16-bit architectures.  See the
+ * comments in zlib.h for inflateBack() usage.  These functions are used
+ * identically, except that there is no windowBits parameter, and a 64K
+ * window must be provided.  Also if int's are 16 bits, then a zero for
+ * the third parameter of the "out" function actually means 65536UL.
+ * zlib.h must be included before this header file.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ZEXTERN int ZEXPORT inflateBack9 OF((z_stream FAR *strm,
+                                    in_func in, void FAR *in_desc,
+                                    out_func out, void FAR *out_desc));
+ZEXTERN int ZEXPORT inflateBack9End OF((z_stream FAR *strm));
+ZEXTERN int ZEXPORT inflateBack9Init_ OF((z_stream FAR *strm,
+                                         unsigned char FAR *window,
+                                         const char *version,
+                                         int stream_size));
+#define inflateBack9Init(strm, window) \
+        inflateBack9Init_((strm), (window), \
+        ZLIB_VERSION, sizeof(z_stream))
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/infback9/inffix9.h b/Engine/lib/assimp/contrib/zlib/contrib/infback9/inffix9.h
new file mode 100644
index 000000000..ee5671d2d
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/infback9/inffix9.h
@@ -0,0 +1,107 @@
+    /* inffix9.h -- table for decoding deflate64 fixed codes
+     * Generated automatically by makefixed9().
+     */
+
+    /* WARNING: this file should *not* be used by applications.
+       It is part of the implementation of this library and is
+       subject to change. Applications should only use zlib.h.
+     */
+
+    static const code lenfix[512] = {
+        {96,7,0},{0,8,80},{0,8,16},{132,8,115},{130,7,31},{0,8,112},
+        {0,8,48},{0,9,192},{128,7,10},{0,8,96},{0,8,32},{0,9,160},
+        {0,8,0},{0,8,128},{0,8,64},{0,9,224},{128,7,6},{0,8,88},
+        {0,8,24},{0,9,144},{131,7,59},{0,8,120},{0,8,56},{0,9,208},
+        {129,7,17},{0,8,104},{0,8,40},{0,9,176},{0,8,8},{0,8,136},
+        {0,8,72},{0,9,240},{128,7,4},{0,8,84},{0,8,20},{133,8,227},
+        {131,7,43},{0,8,116},{0,8,52},{0,9,200},{129,7,13},{0,8,100},
+        {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},
+        {128,7,8},{0,8,92},{0,8,28},{0,9,152},{132,7,83},{0,8,124},
+        {0,8,60},{0,9,216},{130,7,23},{0,8,108},{0,8,44},{0,9,184},
+        {0,8,12},{0,8,140},{0,8,76},{0,9,248},{128,7,3},{0,8,82},
+        {0,8,18},{133,8,163},{131,7,35},{0,8,114},{0,8,50},{0,9,196},
+        {129,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2},{0,8,130},
+        {0,8,66},{0,9,228},{128,7,7},{0,8,90},{0,8,26},{0,9,148},
+        {132,7,67},{0,8,122},{0,8,58},{0,9,212},{130,7,19},{0,8,106},
+        {0,8,42},{0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},
+        {128,7,5},{0,8,86},{0,8,22},{65,8,0},{131,7,51},{0,8,118},
+        {0,8,54},{0,9,204},{129,7,15},{0,8,102},{0,8,38},{0,9,172},
+        {0,8,6},{0,8,134},{0,8,70},{0,9,236},{128,7,9},{0,8,94},
+        {0,8,30},{0,9,156},{132,7,99},{0,8,126},{0,8,62},{0,9,220},
+        {130,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142},
+        {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{133,8,131},
+        {130,7,31},{0,8,113},{0,8,49},{0,9,194},{128,7,10},{0,8,97},
+        {0,8,33},{0,9,162},{0,8,1},{0,8,129},{0,8,65},{0,9,226},
+        {128,7,6},{0,8,89},{0,8,25},{0,9,146},{131,7,59},{0,8,121},
+        {0,8,57},{0,9,210},{129,7,17},{0,8,105},{0,8,41},{0,9,178},
+        {0,8,9},{0,8,137},{0,8,73},{0,9,242},{128,7,4},{0,8,85},
+        {0,8,21},{144,8,3},{131,7,43},{0,8,117},{0,8,53},{0,9,202},
+        {129,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},
+        {0,8,69},{0,9,234},{128,7,8},{0,8,93},{0,8,29},{0,9,154},
+        {132,7,83},{0,8,125},{0,8,61},{0,9,218},{130,7,23},{0,8,109},
+        {0,8,45},{0,9,186},{0,8,13},{0,8,141},{0,8,77},{0,9,250},
+        {128,7,3},{0,8,83},{0,8,19},{133,8,195},{131,7,35},{0,8,115},
+        {0,8,51},{0,9,198},{129,7,11},{0,8,99},{0,8,35},{0,9,166},
+        {0,8,3},{0,8,131},{0,8,67},{0,9,230},{128,7,7},{0,8,91},
+        {0,8,27},{0,9,150},{132,7,67},{0,8,123},{0,8,59},{0,9,214},
+        {130,7,19},{0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},
+        {0,8,75},{0,9,246},{128,7,5},{0,8,87},{0,8,23},{77,8,0},
+        {131,7,51},{0,8,119},{0,8,55},{0,9,206},{129,7,15},{0,8,103},
+        {0,8,39},{0,9,174},{0,8,7},{0,8,135},{0,8,71},{0,9,238},
+        {128,7,9},{0,8,95},{0,8,31},{0,9,158},{132,7,99},{0,8,127},
+        {0,8,63},{0,9,222},{130,7,27},{0,8,111},{0,8,47},{0,9,190},
+        {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},
+        {0,8,16},{132,8,115},{130,7,31},{0,8,112},{0,8,48},{0,9,193},
+        {128,7,10},{0,8,96},{0,8,32},{0,9,161},{0,8,0},{0,8,128},
+        {0,8,64},{0,9,225},{128,7,6},{0,8,88},{0,8,24},{0,9,145},
+        {131,7,59},{0,8,120},{0,8,56},{0,9,209},{129,7,17},{0,8,104},
+        {0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72},{0,9,241},
+        {128,7,4},{0,8,84},{0,8,20},{133,8,227},{131,7,43},{0,8,116},
+        {0,8,52},{0,9,201},{129,7,13},{0,8,100},{0,8,36},{0,9,169},
+        {0,8,4},{0,8,132},{0,8,68},{0,9,233},{128,7,8},{0,8,92},
+        {0,8,28},{0,9,153},{132,7,83},{0,8,124},{0,8,60},{0,9,217},
+        {130,7,23},{0,8,108},{0,8,44},{0,9,185},{0,8,12},{0,8,140},
+        {0,8,76},{0,9,249},{128,7,3},{0,8,82},{0,8,18},{133,8,163},
+        {131,7,35},{0,8,114},{0,8,50},{0,9,197},{129,7,11},{0,8,98},
+        {0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229},
+        {128,7,7},{0,8,90},{0,8,26},{0,9,149},{132,7,67},{0,8,122},
+        {0,8,58},{0,9,213},{130,7,19},{0,8,106},{0,8,42},{0,9,181},
+        {0,8,10},{0,8,138},{0,8,74},{0,9,245},{128,7,5},{0,8,86},
+        {0,8,22},{65,8,0},{131,7,51},{0,8,118},{0,8,54},{0,9,205},
+        {129,7,15},{0,8,102},{0,8,38},{0,9,173},{0,8,6},{0,8,134},
+        {0,8,70},{0,9,237},{128,7,9},{0,8,94},{0,8,30},{0,9,157},
+        {132,7,99},{0,8,126},{0,8,62},{0,9,221},{130,7,27},{0,8,110},
+        {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},
+        {96,7,0},{0,8,81},{0,8,17},{133,8,131},{130,7,31},{0,8,113},
+        {0,8,49},{0,9,195},{128,7,10},{0,8,97},{0,8,33},{0,9,163},
+        {0,8,1},{0,8,129},{0,8,65},{0,9,227},{128,7,6},{0,8,89},
+        {0,8,25},{0,9,147},{131,7,59},{0,8,121},{0,8,57},{0,9,211},
+        {129,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9},{0,8,137},
+        {0,8,73},{0,9,243},{128,7,4},{0,8,85},{0,8,21},{144,8,3},
+        {131,7,43},{0,8,117},{0,8,53},{0,9,203},{129,7,13},{0,8,101},
+        {0,8,37},{0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},
+        {128,7,8},{0,8,93},{0,8,29},{0,9,155},{132,7,83},{0,8,125},
+        {0,8,61},{0,9,219},{130,7,23},{0,8,109},{0,8,45},{0,9,187},
+        {0,8,13},{0,8,141},{0,8,77},{0,9,251},{128,7,3},{0,8,83},
+        {0,8,19},{133,8,195},{131,7,35},{0,8,115},{0,8,51},{0,9,199},
+        {129,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131},
+        {0,8,67},{0,9,231},{128,7,7},{0,8,91},{0,8,27},{0,9,151},
+        {132,7,67},{0,8,123},{0,8,59},{0,9,215},{130,7,19},{0,8,107},
+        {0,8,43},{0,9,183},{0,8,11},{0,8,139},{0,8,75},{0,9,247},
+        {128,7,5},{0,8,87},{0,8,23},{77,8,0},{131,7,51},{0,8,119},
+        {0,8,55},{0,9,207},{129,7,15},{0,8,103},{0,8,39},{0,9,175},
+        {0,8,7},{0,8,135},{0,8,71},{0,9,239},{128,7,9},{0,8,95},
+        {0,8,31},{0,9,159},{132,7,99},{0,8,127},{0,8,63},{0,9,223},
+        {130,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},
+        {0,8,79},{0,9,255}
+    };
+
+    static const code distfix[32] = {
+        {128,5,1},{135,5,257},{131,5,17},{139,5,4097},{129,5,5},
+        {137,5,1025},{133,5,65},{141,5,16385},{128,5,3},{136,5,513},
+        {132,5,33},{140,5,8193},{130,5,9},{138,5,2049},{134,5,129},
+        {142,5,32769},{128,5,2},{135,5,385},{131,5,25},{139,5,6145},
+        {129,5,7},{137,5,1537},{133,5,97},{141,5,24577},{128,5,4},
+        {136,5,769},{132,5,49},{140,5,12289},{130,5,13},{138,5,3073},
+        {134,5,193},{142,5,49153}
+    };
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/infback9/inflate9.h b/Engine/lib/assimp/contrib/zlib/contrib/infback9/inflate9.h
new file mode 100644
index 000000000..ee9a79394
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/infback9/inflate9.h
@@ -0,0 +1,47 @@
+/* inflate9.h -- internal inflate state definition
+ * Copyright (C) 1995-2003 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* Possible inflate modes between inflate() calls */
+typedef enum {
+        TYPE,       /* i: waiting for type bits, including last-flag bit */
+        STORED,     /* i: waiting for stored size (length and complement) */
+        TABLE,      /* i: waiting for dynamic block table lengths */
+            LEN,        /* i: waiting for length/lit code */
+    DONE,       /* finished check, done -- remain here until reset */
+    BAD         /* got a data error -- remain here until reset */
+} inflate_mode;
+
+/*
+    State transitions between above modes -
+
+    (most modes can go to the BAD mode -- not shown for clarity)
+
+    Read deflate blocks:
+            TYPE -> STORED or TABLE or LEN or DONE
+            STORED -> TYPE
+            TABLE -> LENLENS -> CODELENS -> LEN
+    Read deflate codes:
+                LEN -> LEN or TYPE
+ */
+
+/* state maintained between inflate() calls.  Approximately 7K bytes. */
+struct inflate_state {
+        /* sliding window */
+    unsigned char FAR *window;  /* allocated sliding window, if needed */
+        /* dynamic table building */
+    unsigned ncode;             /* number of code length code lengths */
+    unsigned nlen;              /* number of length code lengths */
+    unsigned ndist;             /* number of distance code lengths */
+    unsigned have;              /* number of code lengths in lens[] */
+    code FAR *next;             /* next available space in codes[] */
+    unsigned short lens[320];   /* temporary storage for code lengths */
+    unsigned short work[288];   /* work area for code table building */
+    code codes[ENOUGH];         /* space for code tables */
+};
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/infback9/inftree9.c b/Engine/lib/assimp/contrib/zlib/contrib/infback9/inftree9.c
new file mode 100644
index 000000000..5f4a76798
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/infback9/inftree9.c
@@ -0,0 +1,324 @@
+/* inftree9.c -- generate Huffman trees for efficient decoding
+ * Copyright (C) 1995-2017 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "zutil.h"
+#include "inftree9.h"
+
+#define MAXBITS 15
+
+const char inflate9_copyright[] =
+   " inflate9 1.2.11 Copyright 1995-2017 Mark Adler ";
+/*
+  If you use the zlib library in a product, an acknowledgment is welcome
+  in the documentation of your product. If for some reason you cannot
+  include such an acknowledgment, I would appreciate that you keep this
+  copyright string in the executable of your product.
+ */
+
+/*
+   Build a set of tables to decode the provided canonical Huffman code.
+   The code lengths are lens[0..codes-1].  The result starts at *table,
+   whose indices are 0..2^bits-1.  work is a writable array of at least
+   lens shorts, which is used as a work area.  type is the type of code
+   to be generated, CODES, LENS, or DISTS.  On return, zero is success,
+   -1 is an invalid code, and +1 means that ENOUGH isn't enough.  table
+   on return points to the next available entry's address.  bits is the
+   requested root table index bits, and on return it is the actual root
+   table index bits.  It will differ if the request is greater than the
+   longest code or if it is less than the shortest code.
+ */
+int inflate_table9(type, lens, codes, table, bits, work)
+codetype type;
+unsigned short FAR *lens;
+unsigned codes;
+code FAR * FAR *table;
+unsigned FAR *bits;
+unsigned short FAR *work;
+{
+    unsigned len;               /* a code's length in bits */
+    unsigned sym;               /* index of code symbols */
+    unsigned min, max;          /* minimum and maximum code lengths */
+    unsigned root;              /* number of index bits for root table */
+    unsigned curr;              /* number of index bits for current table */
+    unsigned drop;              /* code bits to drop for sub-table */
+    int left;                   /* number of prefix codes available */
+    unsigned used;              /* code entries in table used */
+    unsigned huff;              /* Huffman code */
+    unsigned incr;              /* for incrementing code, index */
+    unsigned fill;              /* index for replicating entries */
+    unsigned low;               /* low bits for current root entry */
+    unsigned mask;              /* mask for low root bits */
+    code this;                  /* table entry for duplication */
+    code FAR *next;             /* next available space in table */
+    const unsigned short FAR *base;     /* base value table to use */
+    const unsigned short FAR *extra;    /* extra bits table to use */
+    int end;                    /* use base and extra for symbol > end */
+    unsigned short count[MAXBITS+1];    /* number of codes of each length */
+    unsigned short offs[MAXBITS+1];     /* offsets in table for each length */
+    static const unsigned short lbase[31] = { /* Length codes 257..285 base */
+        3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17,
+        19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115,
+        131, 163, 195, 227, 3, 0, 0};
+    static const unsigned short lext[31] = { /* Length codes 257..285 extra */
+        128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129,
+        130, 130, 130, 130, 131, 131, 131, 131, 132, 132, 132, 132,
+        133, 133, 133, 133, 144, 77, 202};
+    static const unsigned short dbase[32] = { /* Distance codes 0..31 base */
+        1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49,
+        65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073,
+        4097, 6145, 8193, 12289, 16385, 24577, 32769, 49153};
+    static const unsigned short dext[32] = { /* Distance codes 0..31 extra */
+        128, 128, 128, 128, 129, 129, 130, 130, 131, 131, 132, 132,
+        133, 133, 134, 134, 135, 135, 136, 136, 137, 137, 138, 138,
+        139, 139, 140, 140, 141, 141, 142, 142};
+
+    /*
+       Process a set of code lengths to create a canonical Huffman code.  The
+       code lengths are lens[0..codes-1].  Each length corresponds to the
+       symbols 0..codes-1.  The Huffman code is generated by first sorting the
+       symbols by length from short to long, and retaining the symbol order
+       for codes with equal lengths.  Then the code starts with all zero bits
+       for the first code of the shortest length, and the codes are integer
+       increments for the same length, and zeros are appended as the length
+       increases.  For the deflate format, these bits are stored backwards
+       from their more natural integer increment ordering, and so when the
+       decoding tables are built in the large loop below, the integer codes
+       are incremented backwards.
+
+       This routine assumes, but does not check, that all of the entries in
+       lens[] are in the range 0..MAXBITS.  The caller must assure this.
+       1..MAXBITS is interpreted as that code length.  zero means that that
+       symbol does not occur in this code.
+
+       The codes are sorted by computing a count of codes for each length,
+       creating from that a table of starting indices for each length in the
+       sorted table, and then entering the symbols in order in the sorted
+       table.  The sorted table is work[], with that space being provided by
+       the caller.
+
+       The length counts are used for other purposes as well, i.e. finding
+       the minimum and maximum length codes, determining if there are any
+       codes at all, checking for a valid set of lengths, and looking ahead
+       at length counts to determine sub-table sizes when building the
+       decoding tables.
+     */
+
+    /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
+    for (len = 0; len <= MAXBITS; len++)
+        count[len] = 0;
+    for (sym = 0; sym < codes; sym++)
+        count[lens[sym]]++;
+
+    /* bound code lengths, force root to be within code lengths */
+    root = *bits;
+    for (max = MAXBITS; max >= 1; max--)
+        if (count[max] != 0) break;
+    if (root > max) root = max;
+    if (max == 0) return -1;            /* no codes! */
+    for (min = 1; min <= MAXBITS; min++)
+        if (count[min] != 0) break;
+    if (root < min) root = min;
+
+    /* check for an over-subscribed or incomplete set of lengths */
+    left = 1;
+    for (len = 1; len <= MAXBITS; len++) {
+        left <<= 1;
+        left -= count[len];
+        if (left < 0) return -1;        /* over-subscribed */
+    }
+    if (left > 0 && (type == CODES || max != 1))
+        return -1;                      /* incomplete set */
+
+    /* generate offsets into symbol table for each length for sorting */
+    offs[1] = 0;
+    for (len = 1; len < MAXBITS; len++)
+        offs[len + 1] = offs[len] + count[len];
+
+    /* sort symbols by length, by symbol order within each length */
+    for (sym = 0; sym < codes; sym++)
+        if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym;
+
+    /*
+       Create and fill in decoding tables.  In this loop, the table being
+       filled is at next and has curr index bits.  The code being used is huff
+       with length len.  That code is converted to an index by dropping drop
+       bits off of the bottom.  For codes where len is less than drop + curr,
+       those top drop + curr - len bits are incremented through all values to
+       fill the table with replicated entries.
+
+       root is the number of index bits for the root table.  When len exceeds
+       root, sub-tables are created pointed to by the root entry with an index
+       of the low root bits of huff.  This is saved in low to check for when a
+       new sub-table should be started.  drop is zero when the root table is
+       being filled, and drop is root when sub-tables are being filled.
+
+       When a new sub-table is needed, it is necessary to look ahead in the
+       code lengths to determine what size sub-table is needed.  The length
+       counts are used for this, and so count[] is decremented as codes are
+       entered in the tables.
+
+       used keeps track of how many table entries have been allocated from the
+       provided *table space.  It is checked for LENS and DIST tables against
+       the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in
+       the initial root table size constants.  See the comments in inftree9.h
+       for more information.
+
+       sym increments through all symbols, and the loop terminates when
+       all codes of length max, i.e. all codes, have been processed.  This
+       routine permits incomplete codes, so another loop after this one fills
+       in the rest of the decoding tables with invalid code markers.
+     */
+
+    /* set up for code type */
+    switch (type) {
+    case CODES:
+        base = extra = work;    /* dummy value--not used */
+        end = 19;
+        break;
+    case LENS:
+        base = lbase;
+        base -= 257;
+        extra = lext;
+        extra -= 257;
+        end = 256;
+        break;
+    default:            /* DISTS */
+        base = dbase;
+        extra = dext;
+        end = -1;
+    }
+
+    /* initialize state for loop */
+    huff = 0;                   /* starting code */
+    sym = 0;                    /* starting code symbol */
+    len = min;                  /* starting code length */
+    next = *table;              /* current table to fill in */
+    curr = root;                /* current table index bits */
+    drop = 0;                   /* current bits to drop from code for index */
+    low = (unsigned)(-1);       /* trigger new sub-table when len > root */
+    used = 1U << root;          /* use root table entries */
+    mask = used - 1;            /* mask for comparing low */
+
+    /* check available table space */
+    if ((type == LENS && used >= ENOUGH_LENS) ||
+        (type == DISTS && used >= ENOUGH_DISTS))
+        return 1;
+
+    /* process all codes and make table entries */
+    for (;;) {
+        /* create table entry */
+        this.bits = (unsigned char)(len - drop);
+        if ((int)(work[sym]) < end) {
+            this.op = (unsigned char)0;
+            this.val = work[sym];
+        }
+        else if ((int)(work[sym]) > end) {
+            this.op = (unsigned char)(extra[work[sym]]);
+            this.val = base[work[sym]];
+        }
+        else {
+            this.op = (unsigned char)(32 + 64);         /* end of block */
+            this.val = 0;
+        }
+
+        /* replicate for those indices with low len bits equal to huff */
+        incr = 1U << (len - drop);
+        fill = 1U << curr;
+        do {
+            fill -= incr;
+            next[(huff >> drop) + fill] = this;
+        } while (fill != 0);
+
+        /* backwards increment the len-bit code huff */
+        incr = 1U << (len - 1);
+        while (huff & incr)
+            incr >>= 1;
+        if (incr != 0) {
+            huff &= incr - 1;
+            huff += incr;
+        }
+        else
+            huff = 0;
+
+        /* go to next symbol, update count, len */
+        sym++;
+        if (--(count[len]) == 0) {
+            if (len == max) break;
+            len = lens[work[sym]];
+        }
+
+        /* create new sub-table if needed */
+        if (len > root && (huff & mask) != low) {
+            /* if first time, transition to sub-tables */
+            if (drop == 0)
+                drop = root;
+
+            /* increment past last table */
+            next += 1U << curr;
+
+            /* determine length of next table */
+            curr = len - drop;
+            left = (int)(1 << curr);
+            while (curr + drop < max) {
+                left -= count[curr + drop];
+                if (left <= 0) break;
+                curr++;
+                left <<= 1;
+            }
+
+            /* check for enough space */
+            used += 1U << curr;
+            if ((type == LENS && used >= ENOUGH_LENS) ||
+                (type == DISTS && used >= ENOUGH_DISTS))
+                return 1;
+
+            /* point entry in root table to sub-table */
+            low = huff & mask;
+            (*table)[low].op = (unsigned char)curr;
+            (*table)[low].bits = (unsigned char)root;
+            (*table)[low].val = (unsigned short)(next - *table);
+        }
+    }
+
+    /*
+       Fill in rest of table for incomplete codes.  This loop is similar to the
+       loop above in incrementing huff for table indices.  It is assumed that
+       len is equal to curr + drop, so there is no loop needed to increment
+       through high index bits.  When the current sub-table is filled, the loop
+       drops back to the root table to fill in any remaining entries there.
+     */
+    this.op = (unsigned char)64;                /* invalid code marker */
+    this.bits = (unsigned char)(len - drop);
+    this.val = (unsigned short)0;
+    while (huff != 0) {
+        /* when done with sub-table, drop back to root table */
+        if (drop != 0 && (huff & mask) != low) {
+            drop = 0;
+            len = root;
+            next = *table;
+            curr = root;
+            this.bits = (unsigned char)len;
+        }
+
+        /* put invalid code marker in table */
+        next[huff >> drop] = this;
+
+        /* backwards increment the len-bit code huff */
+        incr = 1U << (len - 1);
+        while (huff & incr)
+            incr >>= 1;
+        if (incr != 0) {
+            huff &= incr - 1;
+            huff += incr;
+        }
+        else
+            huff = 0;
+    }
+
+    /* set return parameters */
+    *table += used;
+    *bits = root;
+    return 0;
+}
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/infback9/inftree9.h b/Engine/lib/assimp/contrib/zlib/contrib/infback9/inftree9.h
new file mode 100644
index 000000000..5ab21f0c6
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/infback9/inftree9.h
@@ -0,0 +1,61 @@
+/* inftree9.h -- header to use inftree9.c
+ * Copyright (C) 1995-2008 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* Structure for decoding tables.  Each entry provides either the
+   information needed to do the operation requested by the code that
+   indexed that table entry, or it provides a pointer to another
+   table that indexes more bits of the code.  op indicates whether
+   the entry is a pointer to another table, a literal, a length or
+   distance, an end-of-block, or an invalid code.  For a table
+   pointer, the low four bits of op is the number of index bits of
+   that table.  For a length or distance, the low four bits of op
+   is the number of extra bits to get after the code.  bits is
+   the number of bits in this code or part of the code to drop off
+   of the bit buffer.  val is the actual byte to output in the case
+   of a literal, the base length or distance, or the offset from
+   the current table to the next table.  Each entry is four bytes. */
+typedef struct {
+    unsigned char op;           /* operation, extra bits, table bits */
+    unsigned char bits;         /* bits in this part of the code */
+    unsigned short val;         /* offset in table or code value */
+} code;
+
+/* op values as set by inflate_table():
+    00000000 - literal
+    0000tttt - table link, tttt != 0 is the number of table index bits
+    100eeeee - length or distance, eeee is the number of extra bits
+    01100000 - end of block
+    01000000 - invalid code
+ */
+
+/* Maximum size of the dynamic table.  The maximum number of code structures is
+   1446, which is the sum of 852 for literal/length codes and 594 for distance
+   codes.  These values were found by exhaustive searches using the program
+   examples/enough.c found in the zlib distribtution.  The arguments to that
+   program are the number of symbols, the initial root table size, and the
+   maximum bit length of a code.  "enough 286 9 15" for literal/length codes
+   returns returns 852, and "enough 32 6 15" for distance codes returns 594.
+   The initial root table size (9 or 6) is found in the fifth argument of the
+   inflate_table() calls in infback9.c.  If the root table size is changed,
+   then these maximum sizes would be need to be recalculated and updated. */
+#define ENOUGH_LENS 852
+#define ENOUGH_DISTS 594
+#define ENOUGH (ENOUGH_LENS+ENOUGH_DISTS)
+
+/* Type of code to build for inflate_table9() */
+typedef enum {
+    CODES,
+    LENS,
+    DISTS
+} codetype;
+
+extern int inflate_table9 OF((codetype type, unsigned short FAR *lens,
+                             unsigned codes, code FAR * FAR *table,
+                             unsigned FAR *bits, unsigned short FAR *work));
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/inflate86/inffas86.c b/Engine/lib/assimp/contrib/zlib/contrib/inflate86/inffas86.c
new file mode 100644
index 000000000..7292f67b7
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/inflate86/inffas86.c
@@ -0,0 +1,1157 @@
+/* inffas86.c is a hand tuned assembler version of
+ *
+ * inffast.c -- fast decoding
+ * Copyright (C) 1995-2003 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ *
+ * Copyright (C) 2003 Chris Anderson <christop@charm.net>
+ * Please use the copyright conditions above.
+ *
+ * Dec-29-2003 -- I added AMD64 inflate asm support.  This version is also
+ * slightly quicker on x86 systems because, instead of using rep movsb to copy
+ * data, it uses rep movsw, which moves data in 2-byte chunks instead of single
+ * bytes.  I've tested the AMD64 code on a Fedora Core 1 + the x86_64 updates
+ * from http://fedora.linux.duke.edu/fc1_x86_64
+ * which is running on an Athlon 64 3000+ / Gigabyte GA-K8VT800M system with
+ * 1GB ram.  The 64-bit version is about 4% faster than the 32-bit version,
+ * when decompressing mozilla-source-1.3.tar.gz.
+ *
+ * Mar-13-2003 -- Most of this is derived from inffast.S which is derived from
+ * the gcc -S output of zlib-1.2.0/inffast.c.  Zlib-1.2.0 is in beta release at
+ * the moment.  I have successfully compiled and tested this code with gcc2.96,
+ * gcc3.2, icc5.0, msvc6.0.  It is very close to the speed of inffast.S
+ * compiled with gcc -DNO_MMX, but inffast.S is still faster on the P3 with MMX
+ * enabled.  I will attempt to merge the MMX code into this version.  Newer
+ * versions of this and inffast.S can be found at
+ * http://www.eetbeetee.com/zlib/ and http://www.charm.net/~christop/zlib/
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+#include "inflate.h"
+#include "inffast.h"
+
+/* Mark Adler's comments from inffast.c: */
+
+/*
+   Decode literal, length, and distance codes and write out the resulting
+   literal and match bytes until either not enough input or output is
+   available, an end-of-block is encountered, or a data error is encountered.
+   When large enough input and output buffers are supplied to inflate(), for
+   example, a 16K input buffer and a 64K output buffer, more than 95% of the
+   inflate execution time is spent in this routine.
+
+   Entry assumptions:
+
+        state->mode == LEN
+        strm->avail_in >= 6
+        strm->avail_out >= 258
+        start >= strm->avail_out
+        state->bits < 8
+
+   On return, state->mode is one of:
+
+        LEN -- ran out of enough output space or enough available input
+        TYPE -- reached end of block code, inflate() to interpret next block
+        BAD -- error in block data
+
+   Notes:
+
+    - The maximum input bits used by a length/distance pair is 15 bits for the
+      length code, 5 bits for the length extra, 15 bits for the distance code,
+      and 13 bits for the distance extra.  This totals 48 bits, or six bytes.
+      Therefore if strm->avail_in >= 6, then there is enough input to avoid
+      checking for available input while decoding.
+
+    - The maximum bytes that a single length/distance pair can output is 258
+      bytes, which is the maximum length that can be coded.  inflate_fast()
+      requires strm->avail_out >= 258 for each loop to avoid checking for
+      output space.
+ */
+void inflate_fast(strm, start)
+z_streamp strm;
+unsigned start;         /* inflate()'s starting value for strm->avail_out */
+{
+    struct inflate_state FAR *state;
+    struct inffast_ar {
+/* 64   32                               x86  x86_64 */
+/* ar offset                              register */
+/*  0    0 */ void *esp;                /* esp save */
+/*  8    4 */ void *ebp;                /* ebp save */
+/* 16    8 */ unsigned char FAR *in;    /* esi rsi  local strm->next_in */
+/* 24   12 */ unsigned char FAR *last;  /*     r9   while in < last */
+/* 32   16 */ unsigned char FAR *out;   /* edi rdi  local strm->next_out */
+/* 40   20 */ unsigned char FAR *beg;   /*          inflate()'s init next_out */
+/* 48   24 */ unsigned char FAR *end;   /*     r10  while out < end */
+/* 56   28 */ unsigned char FAR *window;/*          size of window, wsize!=0 */
+/* 64   32 */ code const FAR *lcode;    /* ebp rbp  local strm->lencode */
+/* 72   36 */ code const FAR *dcode;    /*     r11  local strm->distcode */
+/* 80   40 */ unsigned long hold;       /* edx rdx  local strm->hold */
+/* 88   44 */ unsigned bits;            /* ebx rbx  local strm->bits */
+/* 92   48 */ unsigned wsize;           /*          window size */
+/* 96   52 */ unsigned write;           /*          window write index */
+/*100   56 */ unsigned lmask;           /*     r12  mask for lcode */
+/*104   60 */ unsigned dmask;           /*     r13  mask for dcode */
+/*108   64 */ unsigned len;             /*     r14  match length */
+/*112   68 */ unsigned dist;            /*     r15  match distance */
+/*116   72 */ unsigned status;          /*          set when state chng*/
+    } ar;
+
+#if defined( __GNUC__ ) && defined( __amd64__ ) && ! defined( __i386 )
+#define PAD_AVAIL_IN 6
+#define PAD_AVAIL_OUT 258
+#else
+#define PAD_AVAIL_IN 5
+#define PAD_AVAIL_OUT 257
+#endif
+
+    /* copy state to local variables */
+    state = (struct inflate_state FAR *)strm->state;
+    ar.in = strm->next_in;
+    ar.last = ar.in + (strm->avail_in - PAD_AVAIL_IN);
+    ar.out = strm->next_out;
+    ar.beg = ar.out - (start - strm->avail_out);
+    ar.end = ar.out + (strm->avail_out - PAD_AVAIL_OUT);
+    ar.wsize = state->wsize;
+    ar.write = state->wnext;
+    ar.window = state->window;
+    ar.hold = state->hold;
+    ar.bits = state->bits;
+    ar.lcode = state->lencode;
+    ar.dcode = state->distcode;
+    ar.lmask = (1U << state->lenbits) - 1;
+    ar.dmask = (1U << state->distbits) - 1;
+
+    /* decode literals and length/distances until end-of-block or not enough
+       input data or output space */
+
+    /* align in on 1/2 hold size boundary */
+    while (((unsigned long)(void *)ar.in & (sizeof(ar.hold) / 2 - 1)) != 0) {
+        ar.hold += (unsigned long)*ar.in++ << ar.bits;
+        ar.bits += 8;
+    }
+
+#if defined( __GNUC__ ) && defined( __amd64__ ) && ! defined( __i386 )
+    __asm__ __volatile__ (
+"        leaq    %0, %%rax\n"
+"        movq    %%rbp, 8(%%rax)\n"       /* save regs rbp and rsp */
+"        movq    %%rsp, (%%rax)\n"
+"        movq    %%rax, %%rsp\n"          /* make rsp point to &ar */
+"        movq    16(%%rsp), %%rsi\n"      /* rsi  = in */
+"        movq    32(%%rsp), %%rdi\n"      /* rdi  = out */
+"        movq    24(%%rsp), %%r9\n"       /* r9   = last */
+"        movq    48(%%rsp), %%r10\n"      /* r10  = end */
+"        movq    64(%%rsp), %%rbp\n"      /* rbp  = lcode */
+"        movq    72(%%rsp), %%r11\n"      /* r11  = dcode */
+"        movq    80(%%rsp), %%rdx\n"      /* rdx  = hold */
+"        movl    88(%%rsp), %%ebx\n"      /* ebx  = bits */
+"        movl    100(%%rsp), %%r12d\n"    /* r12d = lmask */
+"        movl    104(%%rsp), %%r13d\n"    /* r13d = dmask */
+                                          /* r14d = len */
+                                          /* r15d = dist */
+"        cld\n"
+"        cmpq    %%rdi, %%r10\n"
+"        je      .L_one_time\n"           /* if only one decode left */
+"        cmpq    %%rsi, %%r9\n"
+"        je      .L_one_time\n"
+"        jmp     .L_do_loop\n"
+
+".L_one_time:\n"
+"        movq    %%r12, %%r8\n"           /* r8 = lmask */
+"        cmpb    $32, %%bl\n"
+"        ja      .L_get_length_code_one_time\n"
+
+"        lodsl\n"                         /* eax = *(uint *)in++ */
+"        movb    %%bl, %%cl\n"            /* cl = bits, needs it for shifting */
+"        addb    $32, %%bl\n"             /* bits += 32 */
+"        shlq    %%cl, %%rax\n"
+"        orq     %%rax, %%rdx\n"          /* hold |= *((uint *)in)++ << bits */
+"        jmp     .L_get_length_code_one_time\n"
+
+".align 32,0x90\n"
+".L_while_test:\n"
+"        cmpq    %%rdi, %%r10\n"
+"        jbe     .L_break_loop\n"
+"        cmpq    %%rsi, %%r9\n"
+"        jbe     .L_break_loop\n"
+
+".L_do_loop:\n"
+"        movq    %%r12, %%r8\n"           /* r8 = lmask */
+"        cmpb    $32, %%bl\n"
+"        ja      .L_get_length_code\n"    /* if (32 < bits) */
+
+"        lodsl\n"                         /* eax = *(uint *)in++ */
+"        movb    %%bl, %%cl\n"            /* cl = bits, needs it for shifting */
+"        addb    $32, %%bl\n"             /* bits += 32 */
+"        shlq    %%cl, %%rax\n"
+"        orq     %%rax, %%rdx\n"          /* hold |= *((uint *)in)++ << bits */
+
+".L_get_length_code:\n"
+"        andq    %%rdx, %%r8\n"            /* r8 &= hold */
+"        movl    (%%rbp,%%r8,4), %%eax\n"  /* eax = lcode[hold & lmask] */
+
+"        movb    %%ah, %%cl\n"            /* cl = this.bits */
+"        subb    %%ah, %%bl\n"            /* bits -= this.bits */
+"        shrq    %%cl, %%rdx\n"           /* hold >>= this.bits */
+
+"        testb   %%al, %%al\n"
+"        jnz     .L_test_for_length_base\n" /* if (op != 0) 45.7% */
+
+"        movq    %%r12, %%r8\n"            /* r8 = lmask */
+"        shrl    $16, %%eax\n"            /* output this.val char */
+"        stosb\n"
+
+".L_get_length_code_one_time:\n"
+"        andq    %%rdx, %%r8\n"            /* r8 &= hold */
+"        movl    (%%rbp,%%r8,4), %%eax\n" /* eax = lcode[hold & lmask] */
+
+".L_dolen:\n"
+"        movb    %%ah, %%cl\n"            /* cl = this.bits */
+"        subb    %%ah, %%bl\n"            /* bits -= this.bits */
+"        shrq    %%cl, %%rdx\n"           /* hold >>= this.bits */
+
+"        testb   %%al, %%al\n"
+"        jnz     .L_test_for_length_base\n" /* if (op != 0) 45.7% */
+
+"        shrl    $16, %%eax\n"            /* output this.val char */
+"        stosb\n"
+"        jmp     .L_while_test\n"
+
+".align 32,0x90\n"
+".L_test_for_length_base:\n"
+"        movl    %%eax, %%r14d\n"         /* len = this */
+"        shrl    $16, %%r14d\n"           /* len = this.val */
+"        movb    %%al, %%cl\n"
+
+"        testb   $16, %%al\n"
+"        jz      .L_test_for_second_level_length\n" /* if ((op & 16) == 0) 8% */
+"        andb    $15, %%cl\n"             /* op &= 15 */
+"        jz      .L_decode_distance\n"    /* if (!op) */
+
+".L_add_bits_to_len:\n"
+"        subb    %%cl, %%bl\n"
+"        xorl    %%eax, %%eax\n"
+"        incl    %%eax\n"
+"        shll    %%cl, %%eax\n"
+"        decl    %%eax\n"
+"        andl    %%edx, %%eax\n"          /* eax &= hold */
+"        shrq    %%cl, %%rdx\n"
+"        addl    %%eax, %%r14d\n"         /* len += hold & mask[op] */
+
+".L_decode_distance:\n"
+"        movq    %%r13, %%r8\n"           /* r8 = dmask */
+"        cmpb    $32, %%bl\n"
+"        ja      .L_get_distance_code\n"  /* if (32 < bits) */
+
+"        lodsl\n"                         /* eax = *(uint *)in++ */
+"        movb    %%bl, %%cl\n"            /* cl = bits, needs it for shifting */
+"        addb    $32, %%bl\n"             /* bits += 32 */
+"        shlq    %%cl, %%rax\n"
+"        orq     %%rax, %%rdx\n"          /* hold |= *((uint *)in)++ << bits */
+
+".L_get_distance_code:\n"
+"        andq    %%rdx, %%r8\n"           /* r8 &= hold */
+"        movl    (%%r11,%%r8,4), %%eax\n" /* eax = dcode[hold & dmask] */
+
+".L_dodist:\n"
+"        movl    %%eax, %%r15d\n"         /* dist = this */
+"        shrl    $16, %%r15d\n"           /* dist = this.val */
+"        movb    %%ah, %%cl\n"
+"        subb    %%ah, %%bl\n"            /* bits -= this.bits */
+"        shrq    %%cl, %%rdx\n"           /* hold >>= this.bits */
+"        movb    %%al, %%cl\n"            /* cl = this.op */
+
+"        testb   $16, %%al\n"             /* if ((op & 16) == 0) */
+"        jz      .L_test_for_second_level_dist\n"
+"        andb    $15, %%cl\n"             /* op &= 15 */
+"        jz      .L_check_dist_one\n"
+
+".L_add_bits_to_dist:\n"
+"        subb    %%cl, %%bl\n"
+"        xorl    %%eax, %%eax\n"
+"        incl    %%eax\n"
+"        shll    %%cl, %%eax\n"
+"        decl    %%eax\n"                 /* (1 << op) - 1 */
+"        andl    %%edx, %%eax\n"          /* eax &= hold */
+"        shrq    %%cl, %%rdx\n"
+"        addl    %%eax, %%r15d\n"         /* dist += hold & ((1 << op) - 1) */
+
+".L_check_window:\n"
+"        movq    %%rsi, %%r8\n"           /* save in so from can use it's reg */
+"        movq    %%rdi, %%rax\n"
+"        subq    40(%%rsp), %%rax\n"      /* nbytes = out - beg */
+
+"        cmpl    %%r15d, %%eax\n"
+"        jb      .L_clip_window\n"        /* if (dist > nbytes) 4.2% */
+
+"        movl    %%r14d, %%ecx\n"         /* ecx = len */
+"        movq    %%rdi, %%rsi\n"
+"        subq    %%r15, %%rsi\n"          /* from = out - dist */
+
+"        sarl    %%ecx\n"
+"        jnc     .L_copy_two\n"           /* if len % 2 == 0 */
+
+"        rep     movsw\n"
+"        movb    (%%rsi), %%al\n"
+"        movb    %%al, (%%rdi)\n"
+"        incq    %%rdi\n"
+
+"        movq    %%r8, %%rsi\n"           /* move in back to %rsi, toss from */
+"        jmp     .L_while_test\n"
+
+".L_copy_two:\n"
+"        rep     movsw\n"
+"        movq    %%r8, %%rsi\n"           /* move in back to %rsi, toss from */
+"        jmp     .L_while_test\n"
+
+".align 32,0x90\n"
+".L_check_dist_one:\n"
+"        cmpl    $1, %%r15d\n"            /* if dist 1, is a memset */
+"        jne     .L_check_window\n"
+"        cmpq    %%rdi, 40(%%rsp)\n"      /* if out == beg, outside window */
+"        je      .L_check_window\n"
+
+"        movl    %%r14d, %%ecx\n"         /* ecx = len */
+"        movb    -1(%%rdi), %%al\n"
+"        movb    %%al, %%ah\n"
+
+"        sarl    %%ecx\n"
+"        jnc     .L_set_two\n"
+"        movb    %%al, (%%rdi)\n"
+"        incq    %%rdi\n"
+
+".L_set_two:\n"
+"        rep     stosw\n"
+"        jmp     .L_while_test\n"
+
+".align 32,0x90\n"
+".L_test_for_second_level_length:\n"
+"        testb   $64, %%al\n"
+"        jnz     .L_test_for_end_of_block\n" /* if ((op & 64) != 0) */
+
+"        xorl    %%eax, %%eax\n"
+"        incl    %%eax\n"
+"        shll    %%cl, %%eax\n"
+"        decl    %%eax\n"
+"        andl    %%edx, %%eax\n"         /* eax &= hold */
+"        addl    %%r14d, %%eax\n"        /* eax += len */
+"        movl    (%%rbp,%%rax,4), %%eax\n" /* eax = lcode[val+(hold&mask[op])]*/
+"        jmp     .L_dolen\n"
+
+".align 32,0x90\n"
+".L_test_for_second_level_dist:\n"
+"        testb   $64, %%al\n"
+"        jnz     .L_invalid_distance_code\n" /* if ((op & 64) != 0) */
+
+"        xorl    %%eax, %%eax\n"
+"        incl    %%eax\n"
+"        shll    %%cl, %%eax\n"
+"        decl    %%eax\n"
+"        andl    %%edx, %%eax\n"         /* eax &= hold */
+"        addl    %%r15d, %%eax\n"        /* eax += dist */
+"        movl    (%%r11,%%rax,4), %%eax\n" /* eax = dcode[val+(hold&mask[op])]*/
+"        jmp     .L_dodist\n"
+
+".align 32,0x90\n"
+".L_clip_window:\n"
+"        movl    %%eax, %%ecx\n"         /* ecx = nbytes */
+"        movl    92(%%rsp), %%eax\n"     /* eax = wsize, prepare for dist cmp */
+"        negl    %%ecx\n"                /* nbytes = -nbytes */
+
+"        cmpl    %%r15d, %%eax\n"
+"        jb      .L_invalid_distance_too_far\n" /* if (dist > wsize) */
+
+"        addl    %%r15d, %%ecx\n"         /* nbytes = dist - nbytes */
+"        cmpl    $0, 96(%%rsp)\n"
+"        jne     .L_wrap_around_window\n" /* if (write != 0) */
+
+"        movq    56(%%rsp), %%rsi\n"     /* from  = window */
+"        subl    %%ecx, %%eax\n"         /* eax  -= nbytes */
+"        addq    %%rax, %%rsi\n"         /* from += wsize - nbytes */
+
+"        movl    %%r14d, %%eax\n"        /* eax = len */
+"        cmpl    %%ecx, %%r14d\n"
+"        jbe     .L_do_copy\n"           /* if (nbytes >= len) */
+
+"        subl    %%ecx, %%eax\n"         /* eax -= nbytes */
+"        rep     movsb\n"
+"        movq    %%rdi, %%rsi\n"
+"        subq    %%r15, %%rsi\n"         /* from = &out[ -dist ] */
+"        jmp     .L_do_copy\n"
+
+".align 32,0x90\n"
+".L_wrap_around_window:\n"
+"        movl    96(%%rsp), %%eax\n"     /* eax = write */
+"        cmpl    %%eax, %%ecx\n"
+"        jbe     .L_contiguous_in_window\n" /* if (write >= nbytes) */
+
+"        movl    92(%%rsp), %%esi\n"     /* from  = wsize */
+"        addq    56(%%rsp), %%rsi\n"     /* from += window */
+"        addq    %%rax, %%rsi\n"         /* from += write */
+"        subq    %%rcx, %%rsi\n"         /* from -= nbytes */
+"        subl    %%eax, %%ecx\n"         /* nbytes -= write */
+
+"        movl    %%r14d, %%eax\n"        /* eax = len */
+"        cmpl    %%ecx, %%eax\n"
+"        jbe     .L_do_copy\n"           /* if (nbytes >= len) */
+
+"        subl    %%ecx, %%eax\n"         /* len -= nbytes */
+"        rep     movsb\n"
+"        movq    56(%%rsp), %%rsi\n"     /* from = window */
+"        movl    96(%%rsp), %%ecx\n"     /* nbytes = write */
+"        cmpl    %%ecx, %%eax\n"
+"        jbe     .L_do_copy\n"           /* if (nbytes >= len) */
+
+"        subl    %%ecx, %%eax\n"         /* len -= nbytes */
+"        rep     movsb\n"
+"        movq    %%rdi, %%rsi\n"
+"        subq    %%r15, %%rsi\n"         /* from = out - dist */
+"        jmp     .L_do_copy\n"
+
+".align 32,0x90\n"
+".L_contiguous_in_window:\n"
+"        movq    56(%%rsp), %%rsi\n"     /* rsi = window */
+"        addq    %%rax, %%rsi\n"
+"        subq    %%rcx, %%rsi\n"         /* from += write - nbytes */
+
+"        movl    %%r14d, %%eax\n"        /* eax = len */
+"        cmpl    %%ecx, %%eax\n"
+"        jbe     .L_do_copy\n"           /* if (nbytes >= len) */
+
+"        subl    %%ecx, %%eax\n"         /* len -= nbytes */
+"        rep     movsb\n"
+"        movq    %%rdi, %%rsi\n"
+"        subq    %%r15, %%rsi\n"         /* from = out - dist */
+"        jmp     .L_do_copy\n"           /* if (nbytes >= len) */
+
+".align 32,0x90\n"
+".L_do_copy:\n"
+"        movl    %%eax, %%ecx\n"         /* ecx = len */
+"        rep     movsb\n"
+
+"        movq    %%r8, %%rsi\n"          /* move in back to %esi, toss from */
+"        jmp     .L_while_test\n"
+
+".L_test_for_end_of_block:\n"
+"        testb   $32, %%al\n"
+"        jz      .L_invalid_literal_length_code\n"
+"        movl    $1, 116(%%rsp)\n"
+"        jmp     .L_break_loop_with_status\n"
+
+".L_invalid_literal_length_code:\n"
+"        movl    $2, 116(%%rsp)\n"
+"        jmp     .L_break_loop_with_status\n"
+
+".L_invalid_distance_code:\n"
+"        movl    $3, 116(%%rsp)\n"
+"        jmp     .L_break_loop_with_status\n"
+
+".L_invalid_distance_too_far:\n"
+"        movl    $4, 116(%%rsp)\n"
+"        jmp     .L_break_loop_with_status\n"
+
+".L_break_loop:\n"
+"        movl    $0, 116(%%rsp)\n"
+
+".L_break_loop_with_status:\n"
+/* put in, out, bits, and hold back into ar and pop esp */
+"        movq    %%rsi, 16(%%rsp)\n"     /* in */
+"        movq    %%rdi, 32(%%rsp)\n"     /* out */
+"        movl    %%ebx, 88(%%rsp)\n"     /* bits */
+"        movq    %%rdx, 80(%%rsp)\n"     /* hold */
+"        movq    (%%rsp), %%rax\n"       /* restore rbp and rsp */
+"        movq    8(%%rsp), %%rbp\n"
+"        movq    %%rax, %%rsp\n"
+          :
+          : "m" (ar)
+          : "memory", "%rax", "%rbx", "%rcx", "%rdx", "%rsi", "%rdi",
+            "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
+    );
+#elif ( defined( __GNUC__ ) || defined( __ICC ) ) && defined( __i386 )
+    __asm__ __volatile__ (
+"        leal    %0, %%eax\n"
+"        movl    %%esp, (%%eax)\n"        /* save esp, ebp */
+"        movl    %%ebp, 4(%%eax)\n"
+"        movl    %%eax, %%esp\n"
+"        movl    8(%%esp), %%esi\n"       /* esi = in */
+"        movl    16(%%esp), %%edi\n"      /* edi = out */
+"        movl    40(%%esp), %%edx\n"      /* edx = hold */
+"        movl    44(%%esp), %%ebx\n"      /* ebx = bits */
+"        movl    32(%%esp), %%ebp\n"      /* ebp = lcode */
+
+"        cld\n"
+"        jmp     .L_do_loop\n"
+
+".align 32,0x90\n"
+".L_while_test:\n"
+"        cmpl    %%edi, 24(%%esp)\n"      /* out < end */
+"        jbe     .L_break_loop\n"
+"        cmpl    %%esi, 12(%%esp)\n"      /* in < last */
+"        jbe     .L_break_loop\n"
+
+".L_do_loop:\n"
+"        cmpb    $15, %%bl\n"
+"        ja      .L_get_length_code\n"    /* if (15 < bits) */
+
+"        xorl    %%eax, %%eax\n"
+"        lodsw\n"                         /* al = *(ushort *)in++ */
+"        movb    %%bl, %%cl\n"            /* cl = bits, needs it for shifting */
+"        addb    $16, %%bl\n"             /* bits += 16 */
+"        shll    %%cl, %%eax\n"
+"        orl     %%eax, %%edx\n"        /* hold |= *((ushort *)in)++ << bits */
+
+".L_get_length_code:\n"
+"        movl    56(%%esp), %%eax\n"      /* eax = lmask */
+"        andl    %%edx, %%eax\n"          /* eax &= hold */
+"        movl    (%%ebp,%%eax,4), %%eax\n" /* eax = lcode[hold & lmask] */
+
+".L_dolen:\n"
+"        movb    %%ah, %%cl\n"            /* cl = this.bits */
+"        subb    %%ah, %%bl\n"            /* bits -= this.bits */
+"        shrl    %%cl, %%edx\n"           /* hold >>= this.bits */
+
+"        testb   %%al, %%al\n"
+"        jnz     .L_test_for_length_base\n" /* if (op != 0) 45.7% */
+
+"        shrl    $16, %%eax\n"            /* output this.val char */
+"        stosb\n"
+"        jmp     .L_while_test\n"
+
+".align 32,0x90\n"
+".L_test_for_length_base:\n"
+"        movl    %%eax, %%ecx\n"          /* len = this */
+"        shrl    $16, %%ecx\n"            /* len = this.val */
+"        movl    %%ecx, 64(%%esp)\n"      /* save len */
+"        movb    %%al, %%cl\n"
+
+"        testb   $16, %%al\n"
+"        jz      .L_test_for_second_level_length\n" /* if ((op & 16) == 0) 8% */
+"        andb    $15, %%cl\n"             /* op &= 15 */
+"        jz      .L_decode_distance\n"    /* if (!op) */
+"        cmpb    %%cl, %%bl\n"
+"        jae     .L_add_bits_to_len\n"    /* if (op <= bits) */
+
+"        movb    %%cl, %%ch\n"            /* stash op in ch, freeing cl */
+"        xorl    %%eax, %%eax\n"
+"        lodsw\n"                         /* al = *(ushort *)in++ */
+"        movb    %%bl, %%cl\n"            /* cl = bits, needs it for shifting */
+"        addb    $16, %%bl\n"             /* bits += 16 */
+"        shll    %%cl, %%eax\n"
+"        orl     %%eax, %%edx\n"         /* hold |= *((ushort *)in)++ << bits */
+"        movb    %%ch, %%cl\n"            /* move op back to ecx */
+
+".L_add_bits_to_len:\n"
+"        subb    %%cl, %%bl\n"
+"        xorl    %%eax, %%eax\n"
+"        incl    %%eax\n"
+"        shll    %%cl, %%eax\n"
+"        decl    %%eax\n"
+"        andl    %%edx, %%eax\n"          /* eax &= hold */
+"        shrl    %%cl, %%edx\n"
+"        addl    %%eax, 64(%%esp)\n"      /* len += hold & mask[op] */
+
+".L_decode_distance:\n"
+"        cmpb    $15, %%bl\n"
+"        ja      .L_get_distance_code\n"  /* if (15 < bits) */
+
+"        xorl    %%eax, %%eax\n"
+"        lodsw\n"                         /* al = *(ushort *)in++ */
+"        movb    %%bl, %%cl\n"            /* cl = bits, needs it for shifting */
+"        addb    $16, %%bl\n"             /* bits += 16 */
+"        shll    %%cl, %%eax\n"
+"        orl     %%eax, %%edx\n"         /* hold |= *((ushort *)in)++ << bits */
+
+".L_get_distance_code:\n"
+"        movl    60(%%esp), %%eax\n"      /* eax = dmask */
+"        movl    36(%%esp), %%ecx\n"      /* ecx = dcode */
+"        andl    %%edx, %%eax\n"          /* eax &= hold */
+"        movl    (%%ecx,%%eax,4), %%eax\n"/* eax = dcode[hold & dmask] */
+
+".L_dodist:\n"
+"        movl    %%eax, %%ebp\n"          /* dist = this */
+"        shrl    $16, %%ebp\n"            /* dist = this.val */
+"        movb    %%ah, %%cl\n"
+"        subb    %%ah, %%bl\n"            /* bits -= this.bits */
+"        shrl    %%cl, %%edx\n"           /* hold >>= this.bits */
+"        movb    %%al, %%cl\n"            /* cl = this.op */
+
+"        testb   $16, %%al\n"             /* if ((op & 16) == 0) */
+"        jz      .L_test_for_second_level_dist\n"
+"        andb    $15, %%cl\n"             /* op &= 15 */
+"        jz      .L_check_dist_one\n"
+"        cmpb    %%cl, %%bl\n"
+"        jae     .L_add_bits_to_dist\n"   /* if (op <= bits) 97.6% */
+
+"        movb    %%cl, %%ch\n"            /* stash op in ch, freeing cl */
+"        xorl    %%eax, %%eax\n"
+"        lodsw\n"                         /* al = *(ushort *)in++ */
+"        movb    %%bl, %%cl\n"            /* cl = bits, needs it for shifting */
+"        addb    $16, %%bl\n"             /* bits += 16 */
+"        shll    %%cl, %%eax\n"
+"        orl     %%eax, %%edx\n"        /* hold |= *((ushort *)in)++ << bits */
+"        movb    %%ch, %%cl\n"            /* move op back to ecx */
+
+".L_add_bits_to_dist:\n"
+"        subb    %%cl, %%bl\n"
+"        xorl    %%eax, %%eax\n"
+"        incl    %%eax\n"
+"        shll    %%cl, %%eax\n"
+"        decl    %%eax\n"                 /* (1 << op) - 1 */
+"        andl    %%edx, %%eax\n"          /* eax &= hold */
+"        shrl    %%cl, %%edx\n"
+"        addl    %%eax, %%ebp\n"          /* dist += hold & ((1 << op) - 1) */
+
+".L_check_window:\n"
+"        movl    %%esi, 8(%%esp)\n"       /* save in so from can use it's reg */
+"        movl    %%edi, %%eax\n"
+"        subl    20(%%esp), %%eax\n"      /* nbytes = out - beg */
+
+"        cmpl    %%ebp, %%eax\n"
+"        jb      .L_clip_window\n"        /* if (dist > nbytes) 4.2% */
+
+"        movl    64(%%esp), %%ecx\n"      /* ecx = len */
+"        movl    %%edi, %%esi\n"
+"        subl    %%ebp, %%esi\n"          /* from = out - dist */
+
+"        sarl    %%ecx\n"
+"        jnc     .L_copy_two\n"           /* if len % 2 == 0 */
+
+"        rep     movsw\n"
+"        movb    (%%esi), %%al\n"
+"        movb    %%al, (%%edi)\n"
+"        incl    %%edi\n"
+
+"        movl    8(%%esp), %%esi\n"       /* move in back to %esi, toss from */
+"        movl    32(%%esp), %%ebp\n"      /* ebp = lcode */
+"        jmp     .L_while_test\n"
+
+".L_copy_two:\n"
+"        rep     movsw\n"
+"        movl    8(%%esp), %%esi\n"       /* move in back to %esi, toss from */
+"        movl    32(%%esp), %%ebp\n"      /* ebp = lcode */
+"        jmp     .L_while_test\n"
+
+".align 32,0x90\n"
+".L_check_dist_one:\n"
+"        cmpl    $1, %%ebp\n"            /* if dist 1, is a memset */
+"        jne     .L_check_window\n"
+"        cmpl    %%edi, 20(%%esp)\n"
+"        je      .L_check_window\n"      /* out == beg, if outside window */
+
+"        movl    64(%%esp), %%ecx\n"      /* ecx = len */
+"        movb    -1(%%edi), %%al\n"
+"        movb    %%al, %%ah\n"
+
+"        sarl    %%ecx\n"
+"        jnc     .L_set_two\n"
+"        movb    %%al, (%%edi)\n"
+"        incl    %%edi\n"
+
+".L_set_two:\n"
+"        rep     stosw\n"
+"        movl    32(%%esp), %%ebp\n"      /* ebp = lcode */
+"        jmp     .L_while_test\n"
+
+".align 32,0x90\n"
+".L_test_for_second_level_length:\n"
+"        testb   $64, %%al\n"
+"        jnz     .L_test_for_end_of_block\n" /* if ((op & 64) != 0) */
+
+"        xorl    %%eax, %%eax\n"
+"        incl    %%eax\n"
+"        shll    %%cl, %%eax\n"
+"        decl    %%eax\n"
+"        andl    %%edx, %%eax\n"         /* eax &= hold */
+"        addl    64(%%esp), %%eax\n"     /* eax += len */
+"        movl    (%%ebp,%%eax,4), %%eax\n" /* eax = lcode[val+(hold&mask[op])]*/
+"        jmp     .L_dolen\n"
+
+".align 32,0x90\n"
+".L_test_for_second_level_dist:\n"
+"        testb   $64, %%al\n"
+"        jnz     .L_invalid_distance_code\n" /* if ((op & 64) != 0) */
+
+"        xorl    %%eax, %%eax\n"
+"        incl    %%eax\n"
+"        shll    %%cl, %%eax\n"
+"        decl    %%eax\n"
+"        andl    %%edx, %%eax\n"         /* eax &= hold */
+"        addl    %%ebp, %%eax\n"         /* eax += dist */
+"        movl    36(%%esp), %%ecx\n"     /* ecx = dcode */
+"        movl    (%%ecx,%%eax,4), %%eax\n" /* eax = dcode[val+(hold&mask[op])]*/
+"        jmp     .L_dodist\n"
+
+".align 32,0x90\n"
+".L_clip_window:\n"
+"        movl    %%eax, %%ecx\n"
+"        movl    48(%%esp), %%eax\n"     /* eax = wsize */
+"        negl    %%ecx\n"                /* nbytes = -nbytes */
+"        movl    28(%%esp), %%esi\n"     /* from = window */
+
+"        cmpl    %%ebp, %%eax\n"
+"        jb      .L_invalid_distance_too_far\n" /* if (dist > wsize) */
+
+"        addl    %%ebp, %%ecx\n"         /* nbytes = dist - nbytes */
+"        cmpl    $0, 52(%%esp)\n"
+"        jne     .L_wrap_around_window\n" /* if (write != 0) */
+
+"        subl    %%ecx, %%eax\n"
+"        addl    %%eax, %%esi\n"         /* from += wsize - nbytes */
+
+"        movl    64(%%esp), %%eax\n"     /* eax = len */
+"        cmpl    %%ecx, %%eax\n"
+"        jbe     .L_do_copy\n"           /* if (nbytes >= len) */
+
+"        subl    %%ecx, %%eax\n"         /* len -= nbytes */
+"        rep     movsb\n"
+"        movl    %%edi, %%esi\n"
+"        subl    %%ebp, %%esi\n"         /* from = out - dist */
+"        jmp     .L_do_copy\n"
+
+".align 32,0x90\n"
+".L_wrap_around_window:\n"
+"        movl    52(%%esp), %%eax\n"     /* eax = write */
+"        cmpl    %%eax, %%ecx\n"
+"        jbe     .L_contiguous_in_window\n" /* if (write >= nbytes) */
+
+"        addl    48(%%esp), %%esi\n"     /* from += wsize */
+"        addl    %%eax, %%esi\n"         /* from += write */
+"        subl    %%ecx, %%esi\n"         /* from -= nbytes */
+"        subl    %%eax, %%ecx\n"         /* nbytes -= write */
+
+"        movl    64(%%esp), %%eax\n"     /* eax = len */
+"        cmpl    %%ecx, %%eax\n"
+"        jbe     .L_do_copy\n"           /* if (nbytes >= len) */
+
+"        subl    %%ecx, %%eax\n"         /* len -= nbytes */
+"        rep     movsb\n"
+"        movl    28(%%esp), %%esi\n"     /* from = window */
+"        movl    52(%%esp), %%ecx\n"     /* nbytes = write */
+"        cmpl    %%ecx, %%eax\n"
+"        jbe     .L_do_copy\n"           /* if (nbytes >= len) */
+
+"        subl    %%ecx, %%eax\n"         /* len -= nbytes */
+"        rep     movsb\n"
+"        movl    %%edi, %%esi\n"
+"        subl    %%ebp, %%esi\n"         /* from = out - dist */
+"        jmp     .L_do_copy\n"
+
+".align 32,0x90\n"
+".L_contiguous_in_window:\n"
+"        addl    %%eax, %%esi\n"
+"        subl    %%ecx, %%esi\n"         /* from += write - nbytes */
+
+"        movl    64(%%esp), %%eax\n"     /* eax = len */
+"        cmpl    %%ecx, %%eax\n"
+"        jbe     .L_do_copy\n"           /* if (nbytes >= len) */
+
+"        subl    %%ecx, %%eax\n"         /* len -= nbytes */
+"        rep     movsb\n"
+"        movl    %%edi, %%esi\n"
+"        subl    %%ebp, %%esi\n"         /* from = out - dist */
+"        jmp     .L_do_copy\n"           /* if (nbytes >= len) */
+
+".align 32,0x90\n"
+".L_do_copy:\n"
+"        movl    %%eax, %%ecx\n"
+"        rep     movsb\n"
+
+"        movl    8(%%esp), %%esi\n"      /* move in back to %esi, toss from */
+"        movl    32(%%esp), %%ebp\n"     /* ebp = lcode */
+"        jmp     .L_while_test\n"
+
+".L_test_for_end_of_block:\n"
+"        testb   $32, %%al\n"
+"        jz      .L_invalid_literal_length_code\n"
+"        movl    $1, 72(%%esp)\n"
+"        jmp     .L_break_loop_with_status\n"
+
+".L_invalid_literal_length_code:\n"
+"        movl    $2, 72(%%esp)\n"
+"        jmp     .L_break_loop_with_status\n"
+
+".L_invalid_distance_code:\n"
+"        movl    $3, 72(%%esp)\n"
+"        jmp     .L_break_loop_with_status\n"
+
+".L_invalid_distance_too_far:\n"
+"        movl    8(%%esp), %%esi\n"
+"        movl    $4, 72(%%esp)\n"
+"        jmp     .L_break_loop_with_status\n"
+
+".L_break_loop:\n"
+"        movl    $0, 72(%%esp)\n"
+
+".L_break_loop_with_status:\n"
+/* put in, out, bits, and hold back into ar and pop esp */
+"        movl    %%esi, 8(%%esp)\n"      /* save in */
+"        movl    %%edi, 16(%%esp)\n"     /* save out */
+"        movl    %%ebx, 44(%%esp)\n"     /* save bits */
+"        movl    %%edx, 40(%%esp)\n"     /* save hold */
+"        movl    4(%%esp), %%ebp\n"      /* restore esp, ebp */
+"        movl    (%%esp), %%esp\n"
+          :
+          : "m" (ar)
+          : "memory", "%eax", "%ebx", "%ecx", "%edx", "%esi", "%edi"
+    );
+#elif defined( _MSC_VER ) && ! defined( _M_AMD64 )
+    __asm {
+	lea	eax, ar
+	mov	[eax], esp         /* save esp, ebp */
+	mov	[eax+4], ebp
+	mov	esp, eax
+	mov	esi, [esp+8]       /* esi = in */
+	mov	edi, [esp+16]      /* edi = out */
+	mov	edx, [esp+40]      /* edx = hold */
+	mov	ebx, [esp+44]      /* ebx = bits */
+	mov	ebp, [esp+32]      /* ebp = lcode */
+
+	cld
+	jmp	L_do_loop
+
+ALIGN 4
+L_while_test:
+	cmp	[esp+24], edi
+	jbe	L_break_loop
+	cmp	[esp+12], esi
+	jbe	L_break_loop
+
+L_do_loop:
+	cmp	bl, 15
+	ja	L_get_length_code    /* if (15 < bits) */
+
+	xor	eax, eax
+	lodsw                         /* al = *(ushort *)in++ */
+	mov	cl, bl            /* cl = bits, needs it for shifting */
+	add	bl, 16             /* bits += 16 */
+	shl	eax, cl
+	or	edx, eax        /* hold |= *((ushort *)in)++ << bits */
+
+L_get_length_code:
+	mov	eax, [esp+56]      /* eax = lmask */
+	and	eax, edx          /* eax &= hold */
+	mov	eax, [ebp+eax*4] /* eax = lcode[hold & lmask] */
+
+L_dolen:
+	mov	cl, ah            /* cl = this.bits */
+	sub	bl, ah            /* bits -= this.bits */
+	shr	edx, cl           /* hold >>= this.bits */
+
+	test	al, al
+	jnz	L_test_for_length_base /* if (op != 0) 45.7% */
+
+	shr	eax, 16            /* output this.val char */
+	stosb
+	jmp	L_while_test
+
+ALIGN 4
+L_test_for_length_base:
+	mov	ecx, eax          /* len = this */
+	shr	ecx, 16            /* len = this.val */
+	mov	[esp+64], ecx      /* save len */
+	mov	cl, al
+
+	test	al, 16
+	jz	L_test_for_second_level_length /* if ((op & 16) == 0) 8% */
+	and	cl, 15             /* op &= 15 */
+	jz	L_decode_distance    /* if (!op) */
+	cmp	bl, cl
+	jae	L_add_bits_to_len    /* if (op <= bits) */
+
+	mov	ch, cl            /* stash op in ch, freeing cl */
+	xor	eax, eax
+	lodsw                         /* al = *(ushort *)in++ */
+	mov	cl, bl            /* cl = bits, needs it for shifting */
+	add	bl, 16             /* bits += 16 */
+	shl	eax, cl
+	or	edx, eax         /* hold |= *((ushort *)in)++ << bits */
+	mov	cl, ch            /* move op back to ecx */
+
+L_add_bits_to_len:
+	sub	bl, cl
+	xor	eax, eax
+	inc	eax
+	shl	eax, cl
+	dec	eax
+	and	eax, edx          /* eax &= hold */
+	shr	edx, cl
+	add	[esp+64], eax      /* len += hold & mask[op] */
+
+L_decode_distance:
+	cmp	bl, 15
+	ja	L_get_distance_code  /* if (15 < bits) */
+
+	xor	eax, eax
+	lodsw                         /* al = *(ushort *)in++ */
+	mov	cl, bl            /* cl = bits, needs it for shifting */
+	add	bl, 16             /* bits += 16 */
+	shl	eax, cl
+	or	edx, eax         /* hold |= *((ushort *)in)++ << bits */
+
+L_get_distance_code:
+	mov	eax, [esp+60]      /* eax = dmask */
+	mov	ecx, [esp+36]      /* ecx = dcode */
+	and	eax, edx          /* eax &= hold */
+	mov	eax, [ecx+eax*4]/* eax = dcode[hold & dmask] */
+
+L_dodist:
+	mov	ebp, eax          /* dist = this */
+	shr	ebp, 16            /* dist = this.val */
+	mov	cl, ah
+	sub	bl, ah            /* bits -= this.bits */
+	shr	edx, cl           /* hold >>= this.bits */
+	mov	cl, al            /* cl = this.op */
+
+	test	al, 16             /* if ((op & 16) == 0) */
+	jz	L_test_for_second_level_dist
+	and	cl, 15             /* op &= 15 */
+	jz	L_check_dist_one
+	cmp	bl, cl
+	jae	L_add_bits_to_dist   /* if (op <= bits) 97.6% */
+
+	mov	ch, cl            /* stash op in ch, freeing cl */
+	xor	eax, eax
+	lodsw                         /* al = *(ushort *)in++ */
+	mov	cl, bl            /* cl = bits, needs it for shifting */
+	add	bl, 16             /* bits += 16 */
+	shl	eax, cl
+	or	edx, eax        /* hold |= *((ushort *)in)++ << bits */
+	mov	cl, ch            /* move op back to ecx */
+
+L_add_bits_to_dist:
+	sub	bl, cl
+	xor	eax, eax
+	inc	eax
+	shl	eax, cl
+	dec	eax                 /* (1 << op) - 1 */
+	and	eax, edx          /* eax &= hold */
+	shr	edx, cl
+	add	ebp, eax          /* dist += hold & ((1 << op) - 1) */
+
+L_check_window:
+	mov	[esp+8], esi       /* save in so from can use it's reg */
+	mov	eax, edi
+	sub	eax, [esp+20]      /* nbytes = out - beg */
+
+	cmp	eax, ebp
+	jb	L_clip_window        /* if (dist > nbytes) 4.2% */
+
+	mov	ecx, [esp+64]      /* ecx = len */
+	mov	esi, edi
+	sub	esi, ebp          /* from = out - dist */
+
+	sar	ecx, 1
+	jnc	L_copy_two
+
+	rep     movsw
+	mov	al, [esi]
+	mov	[edi], al
+	inc	edi
+
+	mov	esi, [esp+8]      /* move in back to %esi, toss from */
+	mov	ebp, [esp+32]     /* ebp = lcode */
+	jmp	L_while_test
+
+L_copy_two:
+	rep     movsw
+	mov	esi, [esp+8]      /* move in back to %esi, toss from */
+	mov	ebp, [esp+32]     /* ebp = lcode */
+	jmp	L_while_test
+
+ALIGN 4
+L_check_dist_one:
+	cmp	ebp, 1            /* if dist 1, is a memset */
+	jne	L_check_window
+	cmp	[esp+20], edi
+	je	L_check_window    /* out == beg, if outside window */
+
+	mov	ecx, [esp+64]     /* ecx = len */
+	mov	al, [edi-1]
+	mov	ah, al
+
+	sar	ecx, 1
+	jnc	L_set_two
+	mov	[edi], al         /* memset out with from[-1] */
+	inc	edi
+
+L_set_two:
+	rep     stosw
+	mov	ebp, [esp+32]     /* ebp = lcode */
+	jmp	L_while_test
+
+ALIGN 4
+L_test_for_second_level_length:
+	test	al, 64
+	jnz	L_test_for_end_of_block /* if ((op & 64) != 0) */
+
+	xor	eax, eax
+	inc	eax
+	shl	eax, cl
+	dec	eax
+	and	eax, edx         /* eax &= hold */
+	add	eax, [esp+64]     /* eax += len */
+	mov	eax, [ebp+eax*4] /* eax = lcode[val+(hold&mask[op])]*/
+	jmp	L_dolen
+
+ALIGN 4
+L_test_for_second_level_dist:
+	test	al, 64
+	jnz	L_invalid_distance_code /* if ((op & 64) != 0) */
+
+	xor	eax, eax
+	inc	eax
+	shl	eax, cl
+	dec	eax
+	and	eax, edx         /* eax &= hold */
+	add	eax, ebp         /* eax += dist */
+	mov	ecx, [esp+36]     /* ecx = dcode */
+	mov	eax, [ecx+eax*4] /* eax = dcode[val+(hold&mask[op])]*/
+	jmp	L_dodist
+
+ALIGN 4
+L_clip_window:
+	mov	ecx, eax
+	mov	eax, [esp+48]     /* eax = wsize */
+	neg	ecx                /* nbytes = -nbytes */
+	mov	esi, [esp+28]     /* from = window */
+
+	cmp	eax, ebp
+	jb	L_invalid_distance_too_far /* if (dist > wsize) */
+
+	add	ecx, ebp         /* nbytes = dist - nbytes */
+	cmp	dword ptr [esp+52], 0
+	jne	L_wrap_around_window /* if (write != 0) */
+
+	sub	eax, ecx
+	add	esi, eax         /* from += wsize - nbytes */
+
+	mov	eax, [esp+64]    /* eax = len */
+	cmp	eax, ecx
+	jbe	L_do_copy          /* if (nbytes >= len) */
+
+	sub	eax, ecx         /* len -= nbytes */
+	rep     movsb
+	mov	esi, edi
+	sub	esi, ebp         /* from = out - dist */
+	jmp	L_do_copy
+
+ALIGN 4
+L_wrap_around_window:
+	mov	eax, [esp+52]    /* eax = write */
+	cmp	ecx, eax
+	jbe	L_contiguous_in_window /* if (write >= nbytes) */
+
+	add	esi, [esp+48]    /* from += wsize */
+	add	esi, eax         /* from += write */
+	sub	esi, ecx         /* from -= nbytes */
+	sub	ecx, eax         /* nbytes -= write */
+
+	mov	eax, [esp+64]    /* eax = len */
+	cmp	eax, ecx
+	jbe	L_do_copy          /* if (nbytes >= len) */
+
+	sub	eax, ecx         /* len -= nbytes */
+	rep     movsb
+	mov	esi, [esp+28]     /* from = window */
+	mov	ecx, [esp+52]     /* nbytes = write */
+	cmp	eax, ecx
+	jbe	L_do_copy          /* if (nbytes >= len) */
+
+	sub	eax, ecx         /* len -= nbytes */
+	rep     movsb
+	mov	esi, edi
+	sub	esi, ebp         /* from = out - dist */
+	jmp	L_do_copy
+
+ALIGN 4
+L_contiguous_in_window:
+	add	esi, eax
+	sub	esi, ecx         /* from += write - nbytes */
+
+	mov	eax, [esp+64]    /* eax = len */
+	cmp	eax, ecx
+	jbe	L_do_copy          /* if (nbytes >= len) */
+
+	sub	eax, ecx         /* len -= nbytes */
+	rep     movsb
+	mov	esi, edi
+	sub	esi, ebp         /* from = out - dist */
+	jmp	L_do_copy
+
+ALIGN 4
+L_do_copy:
+	mov	ecx, eax
+	rep     movsb
+
+	mov	esi, [esp+8]      /* move in back to %esi, toss from */
+	mov	ebp, [esp+32]     /* ebp = lcode */
+	jmp	L_while_test
+
+L_test_for_end_of_block:
+	test	al, 32
+	jz	L_invalid_literal_length_code
+	mov	dword ptr [esp+72], 1
+	jmp	L_break_loop_with_status
+
+L_invalid_literal_length_code:
+	mov	dword ptr [esp+72], 2
+	jmp	L_break_loop_with_status
+
+L_invalid_distance_code:
+	mov	dword ptr [esp+72], 3
+	jmp	L_break_loop_with_status
+
+L_invalid_distance_too_far:
+	mov	esi, [esp+4]
+	mov	dword ptr [esp+72], 4
+	jmp	L_break_loop_with_status
+
+L_break_loop:
+	mov	dword ptr [esp+72], 0
+
+L_break_loop_with_status:
+/* put in, out, bits, and hold back into ar and pop esp */
+	mov	[esp+8], esi     /* save in */
+	mov	[esp+16], edi    /* save out */
+	mov	[esp+44], ebx    /* save bits */
+	mov	[esp+40], edx    /* save hold */
+	mov	ebp, [esp+4]     /* restore esp, ebp */
+	mov	esp, [esp]
+    }
+#else
+#error "x86 architecture not defined"
+#endif
+
+    if (ar.status > 1) {
+        if (ar.status == 2)
+            strm->msg = "invalid literal/length code";
+        else if (ar.status == 3)
+            strm->msg = "invalid distance code";
+        else
+            strm->msg = "invalid distance too far back";
+        state->mode = BAD;
+    }
+    else if ( ar.status == 1 ) {
+        state->mode = TYPE;
+    }
+
+    /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
+    ar.len = ar.bits >> 3;
+    ar.in -= ar.len;
+    ar.bits -= ar.len << 3;
+    ar.hold &= (1U << ar.bits) - 1;
+
+    /* update state and return */
+    strm->next_in = ar.in;
+    strm->next_out = ar.out;
+    strm->avail_in = (unsigned)(ar.in < ar.last ?
+                                PAD_AVAIL_IN + (ar.last - ar.in) :
+                                PAD_AVAIL_IN - (ar.in - ar.last));
+    strm->avail_out = (unsigned)(ar.out < ar.end ?
+                                 PAD_AVAIL_OUT + (ar.end - ar.out) :
+                                 PAD_AVAIL_OUT - (ar.out - ar.end));
+    state->hold = ar.hold;
+    state->bits = ar.bits;
+    return;
+}
+
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/inflate86/inffast.S b/Engine/lib/assimp/contrib/zlib/contrib/inflate86/inffast.S
new file mode 100644
index 000000000..2245a2905
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/inflate86/inffast.S
@@ -0,0 +1,1368 @@
+/*
+ * inffast.S is a hand tuned assembler version of:
+ *
+ * inffast.c -- fast decoding
+ * Copyright (C) 1995-2003 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ *
+ * Copyright (C) 2003 Chris Anderson <christop@charm.net>
+ * Please use the copyright conditions above.
+ *
+ * This version (Jan-23-2003) of inflate_fast was coded and tested under
+ * GNU/Linux on a pentium 3, using the gcc-3.2 compiler distribution.  On that
+ * machine, I found that gzip style archives decompressed about 20% faster than
+ * the gcc-3.2 -O3 -fomit-frame-pointer compiled version.  Your results will
+ * depend on how large of a buffer is used for z_stream.next_in & next_out
+ * (8K-32K worked best for my 256K cpu cache) and how much overhead there is in
+ * stream processing I/O and crc32/addler32.  In my case, this routine used
+ * 70% of the cpu time and crc32 used 20%.
+ *
+ * I am confident that this version will work in the general case, but I have
+ * not tested a wide variety of datasets or a wide variety of platforms.
+ *
+ * Jan-24-2003 -- Added -DUSE_MMX define for slightly faster inflating.
+ * It should be a runtime flag instead of compile time flag...
+ *
+ * Jan-26-2003 -- Added runtime check for MMX support with cpuid instruction.
+ * With -DUSE_MMX, only MMX code is compiled.  With -DNO_MMX, only non-MMX code
+ * is compiled.  Without either option, runtime detection is enabled.  Runtime
+ * detection should work on all modern cpus and the recomended algorithm (flip
+ * ID bit on eflags and then use the cpuid instruction) is used in many
+ * multimedia applications.  Tested under win2k with gcc-2.95 and gas-2.12
+ * distributed with cygwin3.  Compiling with gcc-2.95 -c inffast.S -o
+ * inffast.obj generates a COFF object which can then be linked with MSVC++
+ * compiled code.  Tested under FreeBSD 4.7 with gcc-2.95.
+ *
+ * Jan-28-2003 -- Tested Athlon XP... MMX mode is slower than no MMX (and
+ * slower than compiler generated code).  Adjusted cpuid check to use the MMX
+ * code only for Pentiums < P4 until I have more data on the P4.  Speed
+ * improvment is only about 15% on the Athlon when compared with code generated
+ * with MSVC++.  Not sure yet, but I think the P4 will also be slower using the
+ * MMX mode because many of it's x86 ALU instructions execute in .5 cycles and
+ * have less latency than MMX ops.  Added code to buffer the last 11 bytes of
+ * the input stream since the MMX code grabs bits in chunks of 32, which
+ * differs from the inffast.c algorithm.  I don't think there would have been
+ * read overruns where a page boundary was crossed (a segfault), but there
+ * could have been overruns when next_in ends on unaligned memory (unintialized
+ * memory read).
+ *
+ * Mar-13-2003 -- P4 MMX is slightly slower than P4 NO_MMX.  I created a C
+ * version of the non-MMX code so that it doesn't depend on zstrm and zstate
+ * structure offsets which are hard coded in this file.  This was last tested
+ * with zlib-1.2.0 which is currently in beta testing, newer versions of this
+ * and inffas86.c can be found at http://www.eetbeetee.com/zlib/ and
+ * http://www.charm.net/~christop/zlib/
+ */
+
+
+/*
+ * if you have underscore linking problems (_inflate_fast undefined), try
+ * using -DGAS_COFF
+ */
+#if ! defined( GAS_COFF ) && ! defined( GAS_ELF )
+
+#if defined( WIN32 ) || defined( __CYGWIN__ )
+#define GAS_COFF /* windows object format */
+#else
+#define GAS_ELF
+#endif
+
+#endif /* ! GAS_COFF && ! GAS_ELF */
+
+
+#if defined( GAS_COFF )
+
+/* coff externals have underscores */
+#define inflate_fast _inflate_fast
+#define inflate_fast_use_mmx _inflate_fast_use_mmx
+
+#endif /* GAS_COFF */
+
+
+.file "inffast.S"
+
+.globl inflate_fast
+
+.text
+.align 4,0
+.L_invalid_literal_length_code_msg:
+.string "invalid literal/length code"
+
+.align 4,0
+.L_invalid_distance_code_msg:
+.string "invalid distance code"
+
+.align 4,0
+.L_invalid_distance_too_far_msg:
+.string "invalid distance too far back"
+
+#if ! defined( NO_MMX )
+.align 4,0
+.L_mask: /* mask[N] = ( 1 << N ) - 1 */
+.long 0
+.long 1
+.long 3
+.long 7
+.long 15
+.long 31
+.long 63
+.long 127
+.long 255
+.long 511
+.long 1023
+.long 2047
+.long 4095
+.long 8191
+.long 16383
+.long 32767
+.long 65535
+.long 131071
+.long 262143
+.long 524287
+.long 1048575
+.long 2097151
+.long 4194303
+.long 8388607
+.long 16777215
+.long 33554431
+.long 67108863
+.long 134217727
+.long 268435455
+.long 536870911
+.long 1073741823
+.long 2147483647
+.long 4294967295
+#endif /* NO_MMX */
+
+.text
+
+/*
+ * struct z_stream offsets, in zlib.h
+ */
+#define next_in_strm   0   /* strm->next_in */
+#define avail_in_strm  4   /* strm->avail_in */
+#define next_out_strm  12  /* strm->next_out */
+#define avail_out_strm 16  /* strm->avail_out */
+#define msg_strm       24  /* strm->msg */
+#define state_strm     28  /* strm->state */
+
+/*
+ * struct inflate_state offsets, in inflate.h
+ */
+#define mode_state     0   /* state->mode */
+#define wsize_state    32  /* state->wsize */
+#define write_state    40  /* state->write */
+#define window_state   44  /* state->window */
+#define hold_state     48  /* state->hold */
+#define bits_state     52  /* state->bits */
+#define lencode_state  68  /* state->lencode */
+#define distcode_state 72  /* state->distcode */
+#define lenbits_state  76  /* state->lenbits */
+#define distbits_state 80  /* state->distbits */
+
+/*
+ * inflate_fast's activation record
+ */
+#define local_var_size 64 /* how much local space for vars */
+#define strm_sp        88 /* first arg: z_stream * (local_var_size + 24) */
+#define start_sp       92 /* second arg: unsigned int (local_var_size + 28) */
+
+/*
+ * offsets for local vars on stack
+ */
+#define out            60  /* unsigned char* */
+#define window         56  /* unsigned char* */
+#define wsize          52  /* unsigned int */
+#define write          48  /* unsigned int */
+#define in             44  /* unsigned char* */
+#define beg            40  /* unsigned char* */
+#define buf            28  /* char[ 12 ] */
+#define len            24  /* unsigned int */
+#define last           20  /* unsigned char* */
+#define end            16  /* unsigned char* */
+#define dcode          12  /* code* */
+#define lcode           8  /* code* */
+#define dmask           4  /* unsigned int */
+#define lmask           0  /* unsigned int */
+
+/*
+ * typedef enum inflate_mode consts, in inflate.h
+ */
+#define INFLATE_MODE_TYPE 11  /* state->mode flags enum-ed in inflate.h */
+#define INFLATE_MODE_BAD  26
+
+
+#if ! defined( USE_MMX ) && ! defined( NO_MMX )
+
+#define RUN_TIME_MMX
+
+#define CHECK_MMX    1
+#define DO_USE_MMX   2
+#define DONT_USE_MMX 3
+
+.globl inflate_fast_use_mmx
+
+.data
+
+.align 4,0
+inflate_fast_use_mmx: /* integer flag for run time control 1=check,2=mmx,3=no */
+.long CHECK_MMX
+
+#if defined( GAS_ELF )
+/* elf info */
+.type   inflate_fast_use_mmx,@object
+.size   inflate_fast_use_mmx,4
+#endif
+
+#endif /* RUN_TIME_MMX */
+
+#if defined( GAS_COFF )
+/* coff info: scl 2 = extern, type 32 = function */
+.def inflate_fast; .scl 2; .type 32; .endef
+#endif
+
+.text
+
+.align 32,0x90
+inflate_fast:
+        pushl   %edi
+        pushl   %esi
+        pushl   %ebp
+        pushl   %ebx
+        pushf   /* save eflags (strm_sp, state_sp assumes this is 32 bits) */
+        subl    $local_var_size, %esp
+        cld
+
+#define strm_r  %esi
+#define state_r %edi
+
+        movl    strm_sp(%esp), strm_r
+        movl    state_strm(strm_r), state_r
+
+        /* in = strm->next_in;
+         * out = strm->next_out;
+         * last = in + strm->avail_in - 11;
+         * beg = out - (start - strm->avail_out);
+         * end = out + (strm->avail_out - 257);
+         */
+        movl    avail_in_strm(strm_r), %edx
+        movl    next_in_strm(strm_r), %eax
+
+        addl    %eax, %edx      /* avail_in += next_in */
+        subl    $11, %edx       /* avail_in -= 11 */
+
+        movl    %eax, in(%esp)
+        movl    %edx, last(%esp)
+
+        movl    start_sp(%esp), %ebp
+        movl    avail_out_strm(strm_r), %ecx
+        movl    next_out_strm(strm_r), %ebx
+
+        subl    %ecx, %ebp      /* start -= avail_out */
+        negl    %ebp            /* start = -start */
+        addl    %ebx, %ebp      /* start += next_out */
+
+        subl    $257, %ecx      /* avail_out -= 257 */
+        addl    %ebx, %ecx      /* avail_out += out */
+
+        movl    %ebx, out(%esp)
+        movl    %ebp, beg(%esp)
+        movl    %ecx, end(%esp)
+
+        /* wsize = state->wsize;
+         * write = state->write;
+         * window = state->window;
+         * hold = state->hold;
+         * bits = state->bits;
+         * lcode = state->lencode;
+         * dcode = state->distcode;
+         * lmask = ( 1 << state->lenbits ) - 1;
+         * dmask = ( 1 << state->distbits ) - 1;
+         */
+
+        movl    lencode_state(state_r), %eax
+        movl    distcode_state(state_r), %ecx
+
+        movl    %eax, lcode(%esp)
+        movl    %ecx, dcode(%esp)
+
+        movl    $1, %eax
+        movl    lenbits_state(state_r), %ecx
+        shll    %cl, %eax
+        decl    %eax
+        movl    %eax, lmask(%esp)
+
+        movl    $1, %eax
+        movl    distbits_state(state_r), %ecx
+        shll    %cl, %eax
+        decl    %eax
+        movl    %eax, dmask(%esp)
+
+        movl    wsize_state(state_r), %eax
+        movl    write_state(state_r), %ecx
+        movl    window_state(state_r), %edx
+
+        movl    %eax, wsize(%esp)
+        movl    %ecx, write(%esp)
+        movl    %edx, window(%esp)
+
+        movl    hold_state(state_r), %ebp
+        movl    bits_state(state_r), %ebx
+
+#undef strm_r
+#undef state_r
+
+#define in_r       %esi
+#define from_r     %esi
+#define out_r      %edi
+
+        movl    in(%esp), in_r
+        movl    last(%esp), %ecx
+        cmpl    in_r, %ecx
+        ja      .L_align_long           /* if in < last */
+
+        addl    $11, %ecx               /* ecx = &in[ avail_in ] */
+        subl    in_r, %ecx              /* ecx = avail_in */
+        movl    $12, %eax
+        subl    %ecx, %eax              /* eax = 12 - avail_in */
+        leal    buf(%esp), %edi
+        rep     movsb                   /* memcpy( buf, in, avail_in ) */
+        movl    %eax, %ecx
+        xorl    %eax, %eax
+        rep     stosb         /* memset( &buf[ avail_in ], 0, 12 - avail_in ) */
+        leal    buf(%esp), in_r         /* in = buf */
+        movl    in_r, last(%esp)        /* last = in, do just one iteration */
+        jmp     .L_is_aligned
+
+        /* align in_r on long boundary */
+.L_align_long:
+        testl   $3, in_r
+        jz      .L_is_aligned
+        xorl    %eax, %eax
+        movb    (in_r), %al
+        incl    in_r
+        movl    %ebx, %ecx
+        addl    $8, %ebx
+        shll    %cl, %eax
+        orl     %eax, %ebp
+        jmp     .L_align_long
+
+.L_is_aligned:
+        movl    out(%esp), out_r
+
+#if defined( NO_MMX )
+        jmp     .L_do_loop
+#endif
+
+#if defined( USE_MMX )
+        jmp     .L_init_mmx
+#endif
+
+/*** Runtime MMX check ***/
+
+#if defined( RUN_TIME_MMX )
+.L_check_mmx:
+        cmpl    $DO_USE_MMX, inflate_fast_use_mmx
+        je      .L_init_mmx
+        ja      .L_do_loop /* > 2 */
+
+        pushl   %eax
+        pushl   %ebx
+        pushl   %ecx
+        pushl   %edx
+        pushf
+        movl    (%esp), %eax      /* copy eflags to eax */
+        xorl    $0x200000, (%esp) /* try toggling ID bit of eflags (bit 21)
+                                   * to see if cpu supports cpuid...
+                                   * ID bit method not supported by NexGen but
+                                   * bios may load a cpuid instruction and
+                                   * cpuid may be disabled on Cyrix 5-6x86 */
+        popf
+        pushf
+        popl    %edx              /* copy new eflags to edx */
+        xorl    %eax, %edx        /* test if ID bit is flipped */
+        jz      .L_dont_use_mmx   /* not flipped if zero */
+        xorl    %eax, %eax
+        cpuid
+        cmpl    $0x756e6547, %ebx /* check for GenuineIntel in ebx,ecx,edx */
+        jne     .L_dont_use_mmx
+        cmpl    $0x6c65746e, %ecx
+        jne     .L_dont_use_mmx
+        cmpl    $0x49656e69, %edx
+        jne     .L_dont_use_mmx
+        movl    $1, %eax
+        cpuid                     /* get cpu features */
+        shrl    $8, %eax
+        andl    $15, %eax
+        cmpl    $6, %eax          /* check for Pentium family, is 0xf for P4 */
+        jne     .L_dont_use_mmx
+        testl   $0x800000, %edx   /* test if MMX feature is set (bit 23) */
+        jnz     .L_use_mmx
+        jmp     .L_dont_use_mmx
+.L_use_mmx:
+        movl    $DO_USE_MMX, inflate_fast_use_mmx
+        jmp     .L_check_mmx_pop
+.L_dont_use_mmx:
+        movl    $DONT_USE_MMX, inflate_fast_use_mmx
+.L_check_mmx_pop:
+        popl    %edx
+        popl    %ecx
+        popl    %ebx
+        popl    %eax
+        jmp     .L_check_mmx
+#endif
+
+
+/*** Non-MMX code ***/
+
+#if defined ( NO_MMX ) || defined( RUN_TIME_MMX )
+
+#define hold_r     %ebp
+#define bits_r     %bl
+#define bitslong_r %ebx
+
+.align 32,0x90
+.L_while_test:
+        /* while (in < last && out < end)
+         */
+        cmpl    out_r, end(%esp)
+        jbe     .L_break_loop           /* if (out >= end) */
+
+        cmpl    in_r, last(%esp)
+        jbe     .L_break_loop
+
+.L_do_loop:
+        /* regs: %esi = in, %ebp = hold, %bl = bits, %edi = out
+         *
+         * do {
+         *   if (bits < 15) {
+         *     hold |= *((unsigned short *)in)++ << bits;
+         *     bits += 16
+         *   }
+         *   this = lcode[hold & lmask]
+         */
+        cmpb    $15, bits_r
+        ja      .L_get_length_code      /* if (15 < bits) */
+
+        xorl    %eax, %eax
+        lodsw                           /* al = *(ushort *)in++ */
+        movb    bits_r, %cl             /* cl = bits, needs it for shifting */
+        addb    $16, bits_r             /* bits += 16 */
+        shll    %cl, %eax
+        orl     %eax, hold_r            /* hold |= *((ushort *)in)++ << bits */
+
+.L_get_length_code:
+        movl    lmask(%esp), %edx       /* edx = lmask */
+        movl    lcode(%esp), %ecx       /* ecx = lcode */
+        andl    hold_r, %edx            /* edx &= hold */
+        movl    (%ecx,%edx,4), %eax     /* eax = lcode[hold & lmask] */
+
+.L_dolen:
+        /* regs: %esi = in, %ebp = hold, %bl = bits, %edi = out
+         *
+         * dolen:
+         *    bits -= this.bits;
+         *    hold >>= this.bits
+         */
+        movb    %ah, %cl                /* cl = this.bits */
+        subb    %ah, bits_r             /* bits -= this.bits */
+        shrl    %cl, hold_r             /* hold >>= this.bits */
+
+        /* check if op is a literal
+         * if (op == 0) {
+         *    PUP(out) = this.val;
+         *  }
+         */
+        testb   %al, %al
+        jnz     .L_test_for_length_base /* if (op != 0) 45.7% */
+
+        shrl    $16, %eax               /* output this.val char */
+        stosb
+        jmp     .L_while_test
+
+.L_test_for_length_base:
+        /* regs: %esi = in, %ebp = hold, %bl = bits, %edi = out, %edx = len
+         *
+         * else if (op & 16) {
+         *   len = this.val
+         *   op &= 15
+         *   if (op) {
+         *     if (op > bits) {
+         *       hold |= *((unsigned short *)in)++ << bits;
+         *       bits += 16
+         *     }
+         *     len += hold & mask[op];
+         *     bits -= op;
+         *     hold >>= op;
+         *   }
+         */
+#define len_r %edx
+        movl    %eax, len_r             /* len = this */
+        shrl    $16, len_r              /* len = this.val */
+        movb    %al, %cl
+
+        testb   $16, %al
+        jz      .L_test_for_second_level_length /* if ((op & 16) == 0) 8% */
+        andb    $15, %cl                /* op &= 15 */
+        jz      .L_save_len             /* if (!op) */
+        cmpb    %cl, bits_r
+        jae     .L_add_bits_to_len      /* if (op <= bits) */
+
+        movb    %cl, %ch                /* stash op in ch, freeing cl */
+        xorl    %eax, %eax
+        lodsw                           /* al = *(ushort *)in++ */
+        movb    bits_r, %cl             /* cl = bits, needs it for shifting */
+        addb    $16, bits_r             /* bits += 16 */
+        shll    %cl, %eax
+        orl     %eax, hold_r            /* hold |= *((ushort *)in)++ << bits */
+        movb    %ch, %cl                /* move op back to ecx */
+
+.L_add_bits_to_len:
+        movl    $1, %eax
+        shll    %cl, %eax
+        decl    %eax
+        subb    %cl, bits_r
+        andl    hold_r, %eax            /* eax &= hold */
+        shrl    %cl, hold_r
+        addl    %eax, len_r             /* len += hold & mask[op] */
+
+.L_save_len:
+        movl    len_r, len(%esp)        /* save len */
+#undef  len_r
+
+.L_decode_distance:
+        /* regs: %esi = in, %ebp = hold, %bl = bits, %edi = out, %edx = dist
+         *
+         *   if (bits < 15) {
+         *     hold |= *((unsigned short *)in)++ << bits;
+         *     bits += 16
+         *   }
+         *   this = dcode[hold & dmask];
+         * dodist:
+         *   bits -= this.bits;
+         *   hold >>= this.bits;
+         *   op = this.op;
+         */
+
+        cmpb    $15, bits_r
+        ja      .L_get_distance_code    /* if (15 < bits) */
+
+        xorl    %eax, %eax
+        lodsw                           /* al = *(ushort *)in++ */
+        movb    bits_r, %cl             /* cl = bits, needs it for shifting */
+        addb    $16, bits_r             /* bits += 16 */
+        shll    %cl, %eax
+        orl     %eax, hold_r            /* hold |= *((ushort *)in)++ << bits */
+
+.L_get_distance_code:
+        movl    dmask(%esp), %edx       /* edx = dmask */
+        movl    dcode(%esp), %ecx       /* ecx = dcode */
+        andl    hold_r, %edx            /* edx &= hold */
+        movl    (%ecx,%edx,4), %eax     /* eax = dcode[hold & dmask] */
+
+#define dist_r %edx
+.L_dodist:
+        movl    %eax, dist_r            /* dist = this */
+        shrl    $16, dist_r             /* dist = this.val */
+        movb    %ah, %cl
+        subb    %ah, bits_r             /* bits -= this.bits */
+        shrl    %cl, hold_r             /* hold >>= this.bits */
+
+        /* if (op & 16) {
+         *   dist = this.val
+         *   op &= 15
+         *   if (op > bits) {
+         *     hold |= *((unsigned short *)in)++ << bits;
+         *     bits += 16
+         *   }
+         *   dist += hold & mask[op];
+         *   bits -= op;
+         *   hold >>= op;
+         */
+        movb    %al, %cl                /* cl = this.op */
+
+        testb   $16, %al                /* if ((op & 16) == 0) */
+        jz      .L_test_for_second_level_dist
+        andb    $15, %cl                /* op &= 15 */
+        jz      .L_check_dist_one
+        cmpb    %cl, bits_r
+        jae     .L_add_bits_to_dist     /* if (op <= bits) 97.6% */
+
+        movb    %cl, %ch                /* stash op in ch, freeing cl */
+        xorl    %eax, %eax
+        lodsw                           /* al = *(ushort *)in++ */
+        movb    bits_r, %cl             /* cl = bits, needs it for shifting */
+        addb    $16, bits_r             /* bits += 16 */
+        shll    %cl, %eax
+        orl     %eax, hold_r            /* hold |= *((ushort *)in)++ << bits */
+        movb    %ch, %cl                /* move op back to ecx */
+
+.L_add_bits_to_dist:
+        movl    $1, %eax
+        shll    %cl, %eax
+        decl    %eax                    /* (1 << op) - 1 */
+        subb    %cl, bits_r
+        andl    hold_r, %eax            /* eax &= hold */
+        shrl    %cl, hold_r
+        addl    %eax, dist_r            /* dist += hold & ((1 << op) - 1) */
+        jmp     .L_check_window
+
+.L_check_window:
+        /* regs: %esi = from, %ebp = hold, %bl = bits, %edi = out, %edx = dist
+         *       %ecx = nbytes
+         *
+         * nbytes = out - beg;
+         * if (dist <= nbytes) {
+         *   from = out - dist;
+         *   do {
+         *     PUP(out) = PUP(from);
+         *   } while (--len > 0) {
+         * }
+         */
+
+        movl    in_r, in(%esp)          /* save in so from can use it's reg */
+        movl    out_r, %eax
+        subl    beg(%esp), %eax         /* nbytes = out - beg */
+
+        cmpl    dist_r, %eax
+        jb      .L_clip_window          /* if (dist > nbytes) 4.2% */
+
+        movl    len(%esp), %ecx
+        movl    out_r, from_r
+        subl    dist_r, from_r          /* from = out - dist */
+
+        subl    $3, %ecx
+        movb    (from_r), %al
+        movb    %al, (out_r)
+        movb    1(from_r), %al
+        movb    2(from_r), %dl
+        addl    $3, from_r
+        movb    %al, 1(out_r)
+        movb    %dl, 2(out_r)
+        addl    $3, out_r
+        rep     movsb
+
+        movl    in(%esp), in_r          /* move in back to %esi, toss from */
+        jmp     .L_while_test
+
+.align 16,0x90
+.L_check_dist_one:
+        cmpl    $1, dist_r
+        jne     .L_check_window
+        cmpl    out_r, beg(%esp)
+        je      .L_check_window
+
+        decl    out_r
+        movl    len(%esp), %ecx
+        movb    (out_r), %al
+        subl    $3, %ecx
+
+        movb    %al, 1(out_r)
+        movb    %al, 2(out_r)
+        movb    %al, 3(out_r)
+        addl    $4, out_r
+        rep     stosb
+
+        jmp     .L_while_test
+
+.align 16,0x90
+.L_test_for_second_level_length:
+        /* else if ((op & 64) == 0) {
+         *   this = lcode[this.val + (hold & mask[op])];
+         * }
+         */
+        testb   $64, %al
+        jnz     .L_test_for_end_of_block  /* if ((op & 64) != 0) */
+
+        movl    $1, %eax
+        shll    %cl, %eax
+        decl    %eax
+        andl    hold_r, %eax            /* eax &= hold */
+        addl    %edx, %eax              /* eax += this.val */
+        movl    lcode(%esp), %edx       /* edx = lcode */
+        movl    (%edx,%eax,4), %eax     /* eax = lcode[val + (hold&mask[op])] */
+        jmp     .L_dolen
+
+.align 16,0x90
+.L_test_for_second_level_dist:
+        /* else if ((op & 64) == 0) {
+         *   this = dcode[this.val + (hold & mask[op])];
+         * }
+         */
+        testb   $64, %al
+        jnz     .L_invalid_distance_code  /* if ((op & 64) != 0) */
+
+        movl    $1, %eax
+        shll    %cl, %eax
+        decl    %eax
+        andl    hold_r, %eax            /* eax &= hold */
+        addl    %edx, %eax              /* eax += this.val */
+        movl    dcode(%esp), %edx       /* edx = dcode */
+        movl    (%edx,%eax,4), %eax     /* eax = dcode[val + (hold&mask[op])] */
+        jmp     .L_dodist
+
+.align 16,0x90
+.L_clip_window:
+        /* regs: %esi = from, %ebp = hold, %bl = bits, %edi = out, %edx = dist
+         *       %ecx = nbytes
+         *
+         * else {
+         *   if (dist > wsize) {
+         *     invalid distance
+         *   }
+         *   from = window;
+         *   nbytes = dist - nbytes;
+         *   if (write == 0) {
+         *     from += wsize - nbytes;
+         */
+#define nbytes_r %ecx
+        movl    %eax, nbytes_r
+        movl    wsize(%esp), %eax       /* prepare for dist compare */
+        negl    nbytes_r                /* nbytes = -nbytes */
+        movl    window(%esp), from_r    /* from = window */
+
+        cmpl    dist_r, %eax
+        jb      .L_invalid_distance_too_far /* if (dist > wsize) */
+
+        addl    dist_r, nbytes_r        /* nbytes = dist - nbytes */
+        cmpl    $0, write(%esp)
+        jne     .L_wrap_around_window   /* if (write != 0) */
+
+        subl    nbytes_r, %eax
+        addl    %eax, from_r            /* from += wsize - nbytes */
+
+        /* regs: %esi = from, %ebp = hold, %bl = bits, %edi = out, %edx = dist
+         *       %ecx = nbytes, %eax = len
+         *
+         *     if (nbytes < len) {
+         *       len -= nbytes;
+         *       do {
+         *         PUP(out) = PUP(from);
+         *       } while (--nbytes);
+         *       from = out - dist;
+         *     }
+         *   }
+         */
+#define len_r %eax
+        movl    len(%esp), len_r
+        cmpl    nbytes_r, len_r
+        jbe     .L_do_copy1             /* if (nbytes >= len) */
+
+        subl    nbytes_r, len_r         /* len -= nbytes */
+        rep     movsb
+        movl    out_r, from_r
+        subl    dist_r, from_r          /* from = out - dist */
+        jmp     .L_do_copy1
+
+        cmpl    nbytes_r, len_r
+        jbe     .L_do_copy1             /* if (nbytes >= len) */
+
+        subl    nbytes_r, len_r         /* len -= nbytes */
+        rep     movsb
+        movl    out_r, from_r
+        subl    dist_r, from_r          /* from = out - dist */
+        jmp     .L_do_copy1
+
+.L_wrap_around_window:
+        /* regs: %esi = from, %ebp = hold, %bl = bits, %edi = out, %edx = dist
+         *       %ecx = nbytes, %eax = write, %eax = len
+         *
+         *   else if (write < nbytes) {
+         *     from += wsize + write - nbytes;
+         *     nbytes -= write;
+         *     if (nbytes < len) {
+         *       len -= nbytes;
+         *       do {
+         *         PUP(out) = PUP(from);
+         *       } while (--nbytes);
+         *       from = window;
+         *       nbytes = write;
+         *       if (nbytes < len) {
+         *         len -= nbytes;
+         *         do {
+         *           PUP(out) = PUP(from);
+         *         } while(--nbytes);
+         *         from = out - dist;
+         *       }
+         *     }
+         *   }
+         */
+#define write_r %eax
+        movl    write(%esp), write_r
+        cmpl    write_r, nbytes_r
+        jbe     .L_contiguous_in_window /* if (write >= nbytes) */
+
+        addl    wsize(%esp), from_r
+        addl    write_r, from_r
+        subl    nbytes_r, from_r        /* from += wsize + write - nbytes */
+        subl    write_r, nbytes_r       /* nbytes -= write */
+#undef write_r
+
+        movl    len(%esp), len_r
+        cmpl    nbytes_r, len_r
+        jbe     .L_do_copy1             /* if (nbytes >= len) */
+
+        subl    nbytes_r, len_r         /* len -= nbytes */
+        rep     movsb
+        movl    window(%esp), from_r    /* from = window */
+        movl    write(%esp), nbytes_r   /* nbytes = write */
+        cmpl    nbytes_r, len_r
+        jbe     .L_do_copy1             /* if (nbytes >= len) */
+
+        subl    nbytes_r, len_r         /* len -= nbytes */
+        rep     movsb
+        movl    out_r, from_r
+        subl    dist_r, from_r          /* from = out - dist */
+        jmp     .L_do_copy1
+
+.L_contiguous_in_window:
+        /* regs: %esi = from, %ebp = hold, %bl = bits, %edi = out, %edx = dist
+         *       %ecx = nbytes, %eax = write, %eax = len
+         *
+         *   else {
+         *     from += write - nbytes;
+         *     if (nbytes < len) {
+         *       len -= nbytes;
+         *       do {
+         *         PUP(out) = PUP(from);
+         *       } while (--nbytes);
+         *       from = out - dist;
+         *     }
+         *   }
+         */
+#define write_r %eax
+        addl    write_r, from_r
+        subl    nbytes_r, from_r        /* from += write - nbytes */
+#undef write_r
+
+        movl    len(%esp), len_r
+        cmpl    nbytes_r, len_r
+        jbe     .L_do_copy1             /* if (nbytes >= len) */
+
+        subl    nbytes_r, len_r         /* len -= nbytes */
+        rep     movsb
+        movl    out_r, from_r
+        subl    dist_r, from_r          /* from = out - dist */
+
+.L_do_copy1:
+        /* regs: %esi = from, %esi = in, %ebp = hold, %bl = bits, %edi = out
+         *       %eax = len
+         *
+         *     while (len > 0) {
+         *       PUP(out) = PUP(from);
+         *       len--;
+         *     }
+         *   }
+         * } while (in < last && out < end);
+         */
+#undef nbytes_r
+#define in_r %esi
+        movl    len_r, %ecx
+        rep     movsb
+
+        movl    in(%esp), in_r          /* move in back to %esi, toss from */
+        jmp     .L_while_test
+
+#undef len_r
+#undef dist_r
+
+#endif /* NO_MMX || RUN_TIME_MMX */
+
+
+/*** MMX code ***/
+
+#if defined( USE_MMX ) || defined( RUN_TIME_MMX )
+
+.align 32,0x90
+.L_init_mmx:
+        emms
+
+#undef  bits_r
+#undef  bitslong_r
+#define bitslong_r %ebp
+#define hold_mm    %mm0
+        movd    %ebp, hold_mm
+        movl    %ebx, bitslong_r
+
+#define used_mm   %mm1
+#define dmask2_mm %mm2
+#define lmask2_mm %mm3
+#define lmask_mm  %mm4
+#define dmask_mm  %mm5
+#define tmp_mm    %mm6
+
+        movd    lmask(%esp), lmask_mm
+        movq    lmask_mm, lmask2_mm
+        movd    dmask(%esp), dmask_mm
+        movq    dmask_mm, dmask2_mm
+        pxor    used_mm, used_mm
+        movl    lcode(%esp), %ebx       /* ebx = lcode */
+        jmp     .L_do_loop_mmx
+
+.align 32,0x90
+.L_while_test_mmx:
+        /* while (in < last && out < end)
+         */
+        cmpl    out_r, end(%esp)
+        jbe     .L_break_loop           /* if (out >= end) */
+
+        cmpl    in_r, last(%esp)
+        jbe     .L_break_loop
+
+.L_do_loop_mmx:
+        psrlq   used_mm, hold_mm        /* hold_mm >>= last bit length */
+
+        cmpl    $32, bitslong_r
+        ja      .L_get_length_code_mmx  /* if (32 < bits) */
+
+        movd    bitslong_r, tmp_mm
+        movd    (in_r), %mm7
+        addl    $4, in_r
+        psllq   tmp_mm, %mm7
+        addl    $32, bitslong_r
+        por     %mm7, hold_mm           /* hold_mm |= *((uint *)in)++ << bits */
+
+.L_get_length_code_mmx:
+        pand    hold_mm, lmask_mm
+        movd    lmask_mm, %eax
+        movq    lmask2_mm, lmask_mm
+        movl    (%ebx,%eax,4), %eax     /* eax = lcode[hold & lmask] */
+
+.L_dolen_mmx:
+        movzbl  %ah, %ecx               /* ecx = this.bits */
+        movd    %ecx, used_mm
+        subl    %ecx, bitslong_r        /* bits -= this.bits */
+
+        testb   %al, %al
+        jnz     .L_test_for_length_base_mmx /* if (op != 0) 45.7% */
+
+        shrl    $16, %eax               /* output this.val char */
+        stosb
+        jmp     .L_while_test_mmx
+
+.L_test_for_length_base_mmx:
+#define len_r  %edx
+        movl    %eax, len_r             /* len = this */
+        shrl    $16, len_r              /* len = this.val */
+
+        testb   $16, %al
+        jz      .L_test_for_second_level_length_mmx /* if ((op & 16) == 0) 8% */
+        andl    $15, %eax               /* op &= 15 */
+        jz      .L_decode_distance_mmx  /* if (!op) */
+
+        psrlq   used_mm, hold_mm        /* hold_mm >>= last bit length */
+        movd    %eax, used_mm
+        movd    hold_mm, %ecx
+        subl    %eax, bitslong_r
+        andl    .L_mask(,%eax,4), %ecx
+        addl    %ecx, len_r             /* len += hold & mask[op] */
+
+.L_decode_distance_mmx:
+        psrlq   used_mm, hold_mm        /* hold_mm >>= last bit length */
+
+        cmpl    $32, bitslong_r
+        ja      .L_get_dist_code_mmx    /* if (32 < bits) */
+
+        movd    bitslong_r, tmp_mm
+        movd    (in_r), %mm7
+        addl    $4, in_r
+        psllq   tmp_mm, %mm7
+        addl    $32, bitslong_r
+        por     %mm7, hold_mm           /* hold_mm |= *((uint *)in)++ << bits */
+
+.L_get_dist_code_mmx:
+        movl    dcode(%esp), %ebx       /* ebx = dcode */
+        pand    hold_mm, dmask_mm
+        movd    dmask_mm, %eax
+        movq    dmask2_mm, dmask_mm
+        movl    (%ebx,%eax,4), %eax     /* eax = dcode[hold & lmask] */
+
+.L_dodist_mmx:
+#define dist_r %ebx
+        movzbl  %ah, %ecx               /* ecx = this.bits */
+        movl    %eax, dist_r
+        shrl    $16, dist_r             /* dist  = this.val */
+        subl    %ecx, bitslong_r        /* bits -= this.bits */
+        movd    %ecx, used_mm
+
+        testb   $16, %al                /* if ((op & 16) == 0) */
+        jz      .L_test_for_second_level_dist_mmx
+        andl    $15, %eax               /* op &= 15 */
+        jz      .L_check_dist_one_mmx
+
+.L_add_bits_to_dist_mmx:
+        psrlq   used_mm, hold_mm        /* hold_mm >>= last bit length */
+        movd    %eax, used_mm           /* save bit length of current op */
+        movd    hold_mm, %ecx           /* get the next bits on input stream */
+        subl    %eax, bitslong_r        /* bits -= op bits */
+        andl    .L_mask(,%eax,4), %ecx  /* ecx   = hold & mask[op] */
+        addl    %ecx, dist_r            /* dist += hold & mask[op] */
+
+.L_check_window_mmx:
+        movl    in_r, in(%esp)          /* save in so from can use it's reg */
+        movl    out_r, %eax
+        subl    beg(%esp), %eax         /* nbytes = out - beg */
+
+        cmpl    dist_r, %eax
+        jb      .L_clip_window_mmx      /* if (dist > nbytes) 4.2% */
+
+        movl    len_r, %ecx
+        movl    out_r, from_r
+        subl    dist_r, from_r          /* from = out - dist */
+
+        subl    $3, %ecx
+        movb    (from_r), %al
+        movb    %al, (out_r)
+        movb    1(from_r), %al
+        movb    2(from_r), %dl
+        addl    $3, from_r
+        movb    %al, 1(out_r)
+        movb    %dl, 2(out_r)
+        addl    $3, out_r
+        rep     movsb
+
+        movl    in(%esp), in_r          /* move in back to %esi, toss from */
+        movl    lcode(%esp), %ebx       /* move lcode back to %ebx, toss dist */
+        jmp     .L_while_test_mmx
+
+.align 16,0x90
+.L_check_dist_one_mmx:
+        cmpl    $1, dist_r
+        jne     .L_check_window_mmx
+        cmpl    out_r, beg(%esp)
+        je      .L_check_window_mmx
+
+        decl    out_r
+        movl    len_r, %ecx
+        movb    (out_r), %al
+        subl    $3, %ecx
+
+        movb    %al, 1(out_r)
+        movb    %al, 2(out_r)
+        movb    %al, 3(out_r)
+        addl    $4, out_r
+        rep     stosb
+
+        movl    lcode(%esp), %ebx       /* move lcode back to %ebx, toss dist */
+        jmp     .L_while_test_mmx
+
+.align 16,0x90
+.L_test_for_second_level_length_mmx:
+        testb   $64, %al
+        jnz     .L_test_for_end_of_block  /* if ((op & 64) != 0) */
+
+        andl    $15, %eax
+        psrlq   used_mm, hold_mm        /* hold_mm >>= last bit length */
+        movd    hold_mm, %ecx
+        andl    .L_mask(,%eax,4), %ecx
+        addl    len_r, %ecx
+        movl    (%ebx,%ecx,4), %eax     /* eax = lcode[hold & lmask] */
+        jmp     .L_dolen_mmx
+
+.align 16,0x90
+.L_test_for_second_level_dist_mmx:
+        testb   $64, %al
+        jnz     .L_invalid_distance_code  /* if ((op & 64) != 0) */
+
+        andl    $15, %eax
+        psrlq   used_mm, hold_mm        /* hold_mm >>= last bit length */
+        movd    hold_mm, %ecx
+        andl    .L_mask(,%eax,4), %ecx
+        movl    dcode(%esp), %eax       /* ecx = dcode */
+        addl    dist_r, %ecx
+        movl    (%eax,%ecx,4), %eax     /* eax = lcode[hold & lmask] */
+        jmp     .L_dodist_mmx
+
+.align 16,0x90
+.L_clip_window_mmx:
+#define nbytes_r %ecx
+        movl    %eax, nbytes_r
+        movl    wsize(%esp), %eax       /* prepare for dist compare */
+        negl    nbytes_r                /* nbytes = -nbytes */
+        movl    window(%esp), from_r    /* from = window */
+
+        cmpl    dist_r, %eax
+        jb      .L_invalid_distance_too_far /* if (dist > wsize) */
+
+        addl    dist_r, nbytes_r        /* nbytes = dist - nbytes */
+        cmpl    $0, write(%esp)
+        jne     .L_wrap_around_window_mmx /* if (write != 0) */
+
+        subl    nbytes_r, %eax
+        addl    %eax, from_r            /* from += wsize - nbytes */
+
+        cmpl    nbytes_r, len_r
+        jbe     .L_do_copy1_mmx         /* if (nbytes >= len) */
+
+        subl    nbytes_r, len_r         /* len -= nbytes */
+        rep     movsb
+        movl    out_r, from_r
+        subl    dist_r, from_r          /* from = out - dist */
+        jmp     .L_do_copy1_mmx
+
+        cmpl    nbytes_r, len_r
+        jbe     .L_do_copy1_mmx         /* if (nbytes >= len) */
+
+        subl    nbytes_r, len_r         /* len -= nbytes */
+        rep     movsb
+        movl    out_r, from_r
+        subl    dist_r, from_r          /* from = out - dist */
+        jmp     .L_do_copy1_mmx
+
+.L_wrap_around_window_mmx:
+#define write_r %eax
+        movl    write(%esp), write_r
+        cmpl    write_r, nbytes_r
+        jbe     .L_contiguous_in_window_mmx /* if (write >= nbytes) */
+
+        addl    wsize(%esp), from_r
+        addl    write_r, from_r
+        subl    nbytes_r, from_r        /* from += wsize + write - nbytes */
+        subl    write_r, nbytes_r       /* nbytes -= write */
+#undef write_r
+
+        cmpl    nbytes_r, len_r
+        jbe     .L_do_copy1_mmx         /* if (nbytes >= len) */
+
+        subl    nbytes_r, len_r         /* len -= nbytes */
+        rep     movsb
+        movl    window(%esp), from_r    /* from = window */
+        movl    write(%esp), nbytes_r   /* nbytes = write */
+        cmpl    nbytes_r, len_r
+        jbe     .L_do_copy1_mmx         /* if (nbytes >= len) */
+
+        subl    nbytes_r, len_r         /* len -= nbytes */
+        rep     movsb
+        movl    out_r, from_r
+        subl    dist_r, from_r          /* from = out - dist */
+        jmp     .L_do_copy1_mmx
+
+.L_contiguous_in_window_mmx:
+#define write_r %eax
+        addl    write_r, from_r
+        subl    nbytes_r, from_r        /* from += write - nbytes */
+#undef write_r
+
+        cmpl    nbytes_r, len_r
+        jbe     .L_do_copy1_mmx         /* if (nbytes >= len) */
+
+        subl    nbytes_r, len_r         /* len -= nbytes */
+        rep     movsb
+        movl    out_r, from_r
+        subl    dist_r, from_r          /* from = out - dist */
+
+.L_do_copy1_mmx:
+#undef nbytes_r
+#define in_r %esi
+        movl    len_r, %ecx
+        rep     movsb
+
+        movl    in(%esp), in_r          /* move in back to %esi, toss from */
+        movl    lcode(%esp), %ebx       /* move lcode back to %ebx, toss dist */
+        jmp     .L_while_test_mmx
+
+#undef hold_r
+#undef bitslong_r
+
+#endif /* USE_MMX || RUN_TIME_MMX */
+
+
+/*** USE_MMX, NO_MMX, and RUNTIME_MMX from here on ***/
+
+.L_invalid_distance_code:
+        /* else {
+         *   strm->msg = "invalid distance code";
+         *   state->mode = BAD;
+         * }
+         */
+        movl    $.L_invalid_distance_code_msg, %ecx
+        movl    $INFLATE_MODE_BAD, %edx
+        jmp     .L_update_stream_state
+
+.L_test_for_end_of_block:
+        /* else if (op & 32) {
+         *   state->mode = TYPE;
+         *   break;
+         * }
+         */
+        testb   $32, %al
+        jz      .L_invalid_literal_length_code  /* if ((op & 32) == 0) */
+
+        movl    $0, %ecx
+        movl    $INFLATE_MODE_TYPE, %edx
+        jmp     .L_update_stream_state
+
+.L_invalid_literal_length_code:
+        /* else {
+         *   strm->msg = "invalid literal/length code";
+         *   state->mode = BAD;
+         * }
+         */
+        movl    $.L_invalid_literal_length_code_msg, %ecx
+        movl    $INFLATE_MODE_BAD, %edx
+        jmp     .L_update_stream_state
+
+.L_invalid_distance_too_far:
+        /* strm->msg = "invalid distance too far back";
+         * state->mode = BAD;
+         */
+        movl    in(%esp), in_r          /* from_r has in's reg, put in back */
+        movl    $.L_invalid_distance_too_far_msg, %ecx
+        movl    $INFLATE_MODE_BAD, %edx
+        jmp     .L_update_stream_state
+
+.L_update_stream_state:
+        /* set strm->msg = %ecx, strm->state->mode = %edx */
+        movl    strm_sp(%esp), %eax
+        testl   %ecx, %ecx              /* if (msg != NULL) */
+        jz      .L_skip_msg
+        movl    %ecx, msg_strm(%eax)    /* strm->msg = msg */
+.L_skip_msg:
+        movl    state_strm(%eax), %eax  /* state = strm->state */
+        movl    %edx, mode_state(%eax)  /* state->mode = edx (BAD | TYPE) */
+        jmp     .L_break_loop
+
+.align 32,0x90
+.L_break_loop:
+
+/*
+ * Regs:
+ *
+ * bits = %ebp when mmx, and in %ebx when non-mmx
+ * hold = %hold_mm when mmx, and in %ebp when non-mmx
+ * in   = %esi
+ * out  = %edi
+ */
+
+#if defined( USE_MMX ) || defined( RUN_TIME_MMX )
+
+#if defined( RUN_TIME_MMX )
+
+        cmpl    $DO_USE_MMX, inflate_fast_use_mmx
+        jne     .L_update_next_in
+
+#endif /* RUN_TIME_MMX */
+
+        movl    %ebp, %ebx
+
+.L_update_next_in:
+
+#endif
+
+#define strm_r  %eax
+#define state_r %edx
+
+        /* len = bits >> 3;
+         * in -= len;
+         * bits -= len << 3;
+         * hold &= (1U << bits) - 1;
+         * state->hold = hold;
+         * state->bits = bits;
+         * strm->next_in = in;
+         * strm->next_out = out;
+         */
+        movl    strm_sp(%esp), strm_r
+        movl    %ebx, %ecx
+        movl    state_strm(strm_r), state_r
+        shrl    $3, %ecx
+        subl    %ecx, in_r
+        shll    $3, %ecx
+        subl    %ecx, %ebx
+        movl    out_r, next_out_strm(strm_r)
+        movl    %ebx, bits_state(state_r)
+        movl    %ebx, %ecx
+
+        leal    buf(%esp), %ebx
+        cmpl    %ebx, last(%esp)
+        jne     .L_buf_not_used         /* if buf != last */
+
+        subl    %ebx, in_r              /* in -= buf */
+        movl    next_in_strm(strm_r), %ebx
+        movl    %ebx, last(%esp)        /* last = strm->next_in */
+        addl    %ebx, in_r              /* in += strm->next_in */
+        movl    avail_in_strm(strm_r), %ebx
+        subl    $11, %ebx
+        addl    %ebx, last(%esp)    /* last = &strm->next_in[ avail_in - 11 ] */
+
+.L_buf_not_used:
+        movl    in_r, next_in_strm(strm_r)
+
+        movl    $1, %ebx
+        shll    %cl, %ebx
+        decl    %ebx
+
+#if defined( USE_MMX ) || defined( RUN_TIME_MMX )
+
+#if defined( RUN_TIME_MMX )
+
+        cmpl    $DO_USE_MMX, inflate_fast_use_mmx
+        jne     .L_update_hold
+
+#endif /* RUN_TIME_MMX */
+
+        psrlq   used_mm, hold_mm        /* hold_mm >>= last bit length */
+        movd    hold_mm, %ebp
+
+        emms
+
+.L_update_hold:
+
+#endif /* USE_MMX || RUN_TIME_MMX */
+
+        andl    %ebx, %ebp
+        movl    %ebp, hold_state(state_r)
+
+#define last_r %ebx
+
+        /* strm->avail_in = in < last ? 11 + (last - in) : 11 - (in - last) */
+        movl    last(%esp), last_r
+        cmpl    in_r, last_r
+        jbe     .L_last_is_smaller     /* if (in >= last) */
+
+        subl    in_r, last_r           /* last -= in */
+        addl    $11, last_r            /* last += 11 */
+        movl    last_r, avail_in_strm(strm_r)
+        jmp     .L_fixup_out
+.L_last_is_smaller:
+        subl    last_r, in_r           /* in -= last */
+        negl    in_r                   /* in = -in */
+        addl    $11, in_r              /* in += 11 */
+        movl    in_r, avail_in_strm(strm_r)
+
+#undef last_r
+#define end_r %ebx
+
+.L_fixup_out:
+        /* strm->avail_out = out < end ? 257 + (end - out) : 257 - (out - end)*/
+        movl    end(%esp), end_r
+        cmpl    out_r, end_r
+        jbe     .L_end_is_smaller      /* if (out >= end) */
+
+        subl    out_r, end_r           /* end -= out */
+        addl    $257, end_r            /* end += 257 */
+        movl    end_r, avail_out_strm(strm_r)
+        jmp     .L_done
+.L_end_is_smaller:
+        subl    end_r, out_r           /* out -= end */
+        negl    out_r                  /* out = -out */
+        addl    $257, out_r            /* out += 257 */
+        movl    out_r, avail_out_strm(strm_r)
+
+#undef end_r
+#undef strm_r
+#undef state_r
+
+.L_done:
+        addl    $local_var_size, %esp
+        popf
+        popl    %ebx
+        popl    %ebp
+        popl    %esi
+        popl    %edi
+        ret
+
+#if defined( GAS_ELF )
+/* elf info */
+.type inflate_fast,@function
+.size inflate_fast,.-inflate_fast
+#endif
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/iostream/test.cpp b/Engine/lib/assimp/contrib/zlib/contrib/iostream/test.cpp
new file mode 100644
index 000000000..7d265b3b5
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/iostream/test.cpp
@@ -0,0 +1,24 @@
+
+#include "zfstream.h"
+
+int main() {
+
+  // Construct a stream object with this filebuffer.  Anything sent
+  // to this stream will go to standard out.
+  gzofstream os( 1, ios::out );
+
+  // This text is getting compressed and sent to stdout.
+  // To prove this, run 'test | zcat'.
+  os << "Hello, Mommy" << endl;
+
+  os << setcompressionlevel( Z_NO_COMPRESSION );
+  os << "hello, hello, hi, ho!" << endl;
+
+  setcompressionlevel( os, Z_DEFAULT_COMPRESSION )
+    << "I'm compressing again" << endl;
+
+  os.close();
+
+  return 0;
+
+}
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/iostream/zfstream.cpp b/Engine/lib/assimp/contrib/zlib/contrib/iostream/zfstream.cpp
new file mode 100644
index 000000000..d0cd85faa
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/iostream/zfstream.cpp
@@ -0,0 +1,329 @@
+
+#include "zfstream.h"
+
+gzfilebuf::gzfilebuf() :
+  file(NULL),
+  mode(0),
+  own_file_descriptor(0)
+{ }
+
+gzfilebuf::~gzfilebuf() {
+
+  sync();
+  if ( own_file_descriptor )
+    close();
+
+}
+
+gzfilebuf *gzfilebuf::open( const char *name,
+                            int io_mode ) {
+
+  if ( is_open() )
+    return NULL;
+
+  char char_mode[10];
+  char *p = char_mode;
+
+  if ( io_mode & ios::in ) {
+    mode = ios::in;
+    *p++ = 'r';
+  } else if ( io_mode & ios::app ) {
+    mode = ios::app;
+    *p++ = 'a';
+  } else {
+    mode = ios::out;
+    *p++ = 'w';
+  }
+
+  if ( io_mode & ios::binary ) {
+    mode |= ios::binary;
+    *p++ = 'b';
+  }
+
+  // Hard code the compression level
+  if ( io_mode & (ios::out|ios::app )) {
+    *p++ = '9';
+  }
+
+  // Put the end-of-string indicator
+  *p = '\0';
+
+  if ( (file = gzopen(name, char_mode)) == NULL )
+    return NULL;
+
+  own_file_descriptor = 1;
+
+  return this;
+
+}
+
+gzfilebuf *gzfilebuf::attach( int file_descriptor,
+                              int io_mode ) {
+
+  if ( is_open() )
+    return NULL;
+
+  char char_mode[10];
+  char *p = char_mode;
+
+  if ( io_mode & ios::in ) {
+    mode = ios::in;
+    *p++ = 'r';
+  } else if ( io_mode & ios::app ) {
+    mode = ios::app;
+    *p++ = 'a';
+  } else {
+    mode = ios::out;
+    *p++ = 'w';
+  }
+
+  if ( io_mode & ios::binary ) {
+    mode |= ios::binary;
+    *p++ = 'b';
+  }
+
+  // Hard code the compression level
+  if ( io_mode & (ios::out|ios::app )) {
+    *p++ = '9';
+  }
+
+  // Put the end-of-string indicator
+  *p = '\0';
+
+  if ( (file = gzdopen(file_descriptor, char_mode)) == NULL )
+    return NULL;
+
+  own_file_descriptor = 0;
+
+  return this;
+
+}
+
+gzfilebuf *gzfilebuf::close() {
+
+  if ( is_open() ) {
+
+    sync();
+    gzclose( file );
+    file = NULL;
+
+  }
+
+  return this;
+
+}
+
+int gzfilebuf::setcompressionlevel( int comp_level ) {
+
+  return gzsetparams(file, comp_level, -2);
+
+}
+
+int gzfilebuf::setcompressionstrategy( int comp_strategy ) {
+
+  return gzsetparams(file, -2, comp_strategy);
+
+}
+
+
+streampos gzfilebuf::seekoff( streamoff off, ios::seek_dir dir, int which ) {
+
+  return streampos(EOF);
+
+}
+
+int gzfilebuf::underflow() {
+
+  // If the file hasn't been opened for reading, error.
+  if ( !is_open() || !(mode & ios::in) )
+    return EOF;
+
+  // if a buffer doesn't exists, allocate one.
+  if ( !base() ) {
+
+    if ( (allocate()) == EOF )
+      return EOF;
+    setp(0,0);
+
+  } else {
+
+    if ( in_avail() )
+      return (unsigned char) *gptr();
+
+    if ( out_waiting() ) {
+      if ( flushbuf() == EOF )
+        return EOF;
+    }
+
+  }
+
+  // Attempt to fill the buffer.
+
+  int result = fillbuf();
+  if ( result == EOF ) {
+    // disable get area
+    setg(0,0,0);
+    return EOF;
+  }
+
+  return (unsigned char) *gptr();
+
+}
+
+int gzfilebuf::overflow( int c ) {
+
+  if ( !is_open() || !(mode & ios::out) )
+    return EOF;
+
+  if ( !base() ) {
+    if ( allocate() == EOF )
+      return EOF;
+    setg(0,0,0);
+  } else {
+    if (in_avail()) {
+        return EOF;
+    }
+    if (out_waiting()) {
+      if (flushbuf() == EOF)
+        return EOF;
+    }
+  }
+
+  int bl = blen();
+  setp( base(), base() + bl);
+
+  if ( c != EOF ) {
+
+    *pptr() = c;
+    pbump(1);
+
+  }
+
+  return 0;
+
+}
+
+int gzfilebuf::sync() {
+
+  if ( !is_open() )
+    return EOF;
+
+  if ( out_waiting() )
+    return flushbuf();
+
+  return 0;
+
+}
+
+int gzfilebuf::flushbuf() {
+
+  int n;
+  char *q;
+
+  q = pbase();
+  n = pptr() - q;
+
+  if ( gzwrite( file, q, n) < n )
+    return EOF;
+
+  setp(0,0);
+
+  return 0;
+
+}
+
+int gzfilebuf::fillbuf() {
+
+  int required;
+  char *p;
+
+  p = base();
+
+  required = blen();
+
+  int t = gzread( file, p, required );
+
+  if ( t <= 0) return EOF;
+
+  setg( base(), base(), base()+t);
+
+  return t;
+
+}
+
+gzfilestream_common::gzfilestream_common() :
+  ios( gzfilestream_common::rdbuf() )
+{ }
+
+gzfilestream_common::~gzfilestream_common()
+{ }
+
+void gzfilestream_common::attach( int fd, int io_mode ) {
+
+  if ( !buffer.attach( fd, io_mode) )
+    clear( ios::failbit | ios::badbit );
+  else
+    clear();
+
+}
+
+void gzfilestream_common::open( const char *name, int io_mode ) {
+
+  if ( !buffer.open( name, io_mode ) )
+    clear( ios::failbit | ios::badbit );
+  else
+    clear();
+
+}
+
+void gzfilestream_common::close() {
+
+  if ( !buffer.close() )
+    clear( ios::failbit | ios::badbit );
+
+}
+
+gzfilebuf *gzfilestream_common::rdbuf()
+{
+  return &buffer;
+}
+
+gzifstream::gzifstream() :
+  ios( gzfilestream_common::rdbuf() )
+{
+  clear( ios::badbit );
+}
+
+gzifstream::gzifstream( const char *name, int io_mode ) :
+  ios( gzfilestream_common::rdbuf() )
+{
+  gzfilestream_common::open( name, io_mode );
+}
+
+gzifstream::gzifstream( int fd, int io_mode ) :
+  ios( gzfilestream_common::rdbuf() )
+{
+  gzfilestream_common::attach( fd, io_mode );
+}
+
+gzifstream::~gzifstream() { }
+
+gzofstream::gzofstream() :
+  ios( gzfilestream_common::rdbuf() )
+{
+  clear( ios::badbit );
+}
+
+gzofstream::gzofstream( const char *name, int io_mode ) :
+  ios( gzfilestream_common::rdbuf() )
+{
+  gzfilestream_common::open( name, io_mode );
+}
+
+gzofstream::gzofstream( int fd, int io_mode ) :
+  ios( gzfilestream_common::rdbuf() )
+{
+  gzfilestream_common::attach( fd, io_mode );
+}
+
+gzofstream::~gzofstream() { }
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/iostream/zfstream.h b/Engine/lib/assimp/contrib/zlib/contrib/iostream/zfstream.h
new file mode 100644
index 000000000..ed79098a3
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/iostream/zfstream.h
@@ -0,0 +1,128 @@
+
+#ifndef zfstream_h
+#define zfstream_h
+
+#include <fstream.h>
+#include "zlib.h"
+
+class gzfilebuf : public streambuf {
+
+public:
+
+  gzfilebuf( );
+  virtual ~gzfilebuf();
+
+  gzfilebuf *open( const char *name, int io_mode );
+  gzfilebuf *attach( int file_descriptor, int io_mode );
+  gzfilebuf *close();
+
+  int setcompressionlevel( int comp_level );
+  int setcompressionstrategy( int comp_strategy );
+
+  inline int is_open() const { return (file !=NULL); }
+
+  virtual streampos seekoff( streamoff, ios::seek_dir, int );
+
+  virtual int sync();
+
+protected:
+
+  virtual int underflow();
+  virtual int overflow( int = EOF );
+
+private:
+
+  gzFile file;
+  short mode;
+  short own_file_descriptor;
+
+  int flushbuf();
+  int fillbuf();
+
+};
+
+class gzfilestream_common : virtual public ios {
+
+  friend class gzifstream;
+  friend class gzofstream;
+  friend gzofstream &setcompressionlevel( gzofstream &, int );
+  friend gzofstream &setcompressionstrategy( gzofstream &, int );
+
+public:
+  virtual ~gzfilestream_common();
+
+  void attach( int fd, int io_mode );
+  void open( const char *name, int io_mode );
+  void close();
+
+protected:
+  gzfilestream_common();
+
+private:
+  gzfilebuf *rdbuf();
+
+  gzfilebuf buffer;
+
+};
+
+class gzifstream : public gzfilestream_common, public istream {
+
+public:
+
+  gzifstream();
+  gzifstream( const char *name, int io_mode = ios::in );
+  gzifstream( int fd, int io_mode = ios::in );
+
+  virtual ~gzifstream();
+
+};
+
+class gzofstream : public gzfilestream_common, public ostream {
+
+public:
+
+  gzofstream();
+  gzofstream( const char *name, int io_mode = ios::out );
+  gzofstream( int fd, int io_mode = ios::out );
+
+  virtual ~gzofstream();
+
+};
+
+template<class T> class gzomanip {
+  friend gzofstream &operator<<(gzofstream &, const gzomanip<T> &);
+public:
+  gzomanip(gzofstream &(*f)(gzofstream &, T), T v) : func(f), val(v) { }
+private:
+  gzofstream &(*func)(gzofstream &, T);
+  T val;
+};
+
+template<class T> gzofstream &operator<<(gzofstream &s, const gzomanip<T> &m)
+{
+  return (*m.func)(s, m.val);
+}
+
+inline gzofstream &setcompressionlevel( gzofstream &s, int l )
+{
+  (s.rdbuf())->setcompressionlevel(l);
+  return s;
+}
+
+inline gzofstream &setcompressionstrategy( gzofstream &s, int l )
+{
+  (s.rdbuf())->setcompressionstrategy(l);
+  return s;
+}
+
+inline gzomanip<int> setcompressionlevel(int l)
+{
+  return gzomanip<int>(&setcompressionlevel,l);
+}
+
+inline gzomanip<int> setcompressionstrategy(int l)
+{
+  return gzomanip<int>(&setcompressionstrategy,l);
+}
+
+#endif
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/iostream2/zstream.h b/Engine/lib/assimp/contrib/zlib/contrib/iostream2/zstream.h
new file mode 100644
index 000000000..43d2332b7
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/iostream2/zstream.h
@@ -0,0 +1,307 @@
+/*
+ *
+ * Copyright (c) 1997
+ * Christian Michelsen Research AS
+ * Advanced Computing
+ * Fantoftvegen 38, 5036 BERGEN, Norway
+ * http://www.cmr.no
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Christian Michelsen Research AS makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+#ifndef ZSTREAM__H
+#define ZSTREAM__H
+
+/*
+ * zstream.h - C++ interface to the 'zlib' general purpose compression library
+ * $Id: zstream.h 1.1 1997-06-25 12:00:56+02 tyge Exp tyge $
+ */
+
+#include <strstream.h>
+#include <string.h>
+#include <stdio.h>
+#include "zlib.h"
+
+#if defined(_WIN32)
+#   include <fcntl.h>
+#   include <io.h>
+#   define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
+#else
+#   define SET_BINARY_MODE(file)
+#endif
+
+class zstringlen {
+public:
+    zstringlen(class izstream&);
+    zstringlen(class ozstream&, const char*);
+    size_t value() const { return val.word; }
+private:
+    struct Val { unsigned char byte; size_t word; } val;
+};
+
+//  ----------------------------- izstream -----------------------------
+
+class izstream
+{
+    public:
+        izstream() : m_fp(0) {}
+        izstream(FILE* fp) : m_fp(0) { open(fp); }
+        izstream(const char* name) : m_fp(0) { open(name); }
+        ~izstream() { close(); }
+
+        /* Opens a gzip (.gz) file for reading.
+         * open() can be used to read a file which is not in gzip format;
+         * in this case read() will directly read from the file without
+         * decompression. errno can be checked to distinguish two error
+         * cases (if errno is zero, the zlib error is Z_MEM_ERROR).
+         */
+        void open(const char* name) {
+            if (m_fp) close();
+            m_fp = ::gzopen(name, "rb");
+        }
+
+        void open(FILE* fp) {
+            SET_BINARY_MODE(fp);
+            if (m_fp) close();
+            m_fp = ::gzdopen(fileno(fp), "rb");
+        }
+
+        /* Flushes all pending input if necessary, closes the compressed file
+         * and deallocates all the (de)compression state. The return value is
+         * the zlib error number (see function error() below).
+         */
+        int close() {
+            int r = ::gzclose(m_fp);
+            m_fp = 0; return r;
+        }
+
+        /* Binary read the given number of bytes from the compressed file.
+         */
+        int read(void* buf, size_t len) {
+            return ::gzread(m_fp, buf, len);
+        }
+
+        /* Returns the error message for the last error which occurred on the
+         * given compressed file. errnum is set to zlib error number. If an
+         * error occurred in the file system and not in the compression library,
+         * errnum is set to Z_ERRNO and the application may consult errno
+         * to get the exact error code.
+         */
+        const char* error(int* errnum) {
+            return ::gzerror(m_fp, errnum);
+        }
+
+        gzFile fp() { return m_fp; }
+
+    private:
+        gzFile m_fp;
+};
+
+/*
+ * Binary read the given (array of) object(s) from the compressed file.
+ * If the input file was not in gzip format, read() copies the objects number
+ * of bytes into the buffer.
+ * returns the number of uncompressed bytes actually read
+ * (0 for end of file, -1 for error).
+ */
+template <class T, class Items>
+inline int read(izstream& zs, T* x, Items items) {
+    return ::gzread(zs.fp(), x, items*sizeof(T));
+}
+
+/*
+ * Binary input with the '>' operator.
+ */
+template <class T>
+inline izstream& operator>(izstream& zs, T& x) {
+    ::gzread(zs.fp(), &x, sizeof(T));
+    return zs;
+}
+
+
+inline zstringlen::zstringlen(izstream& zs) {
+    zs > val.byte;
+    if (val.byte == 255) zs > val.word;
+    else val.word = val.byte;
+}
+
+/*
+ * Read length of string + the string with the '>' operator.
+ */
+inline izstream& operator>(izstream& zs, char* x) {
+    zstringlen len(zs);
+    ::gzread(zs.fp(), x, len.value());
+    x[len.value()] = '\0';
+    return zs;
+}
+
+inline char* read_string(izstream& zs) {
+    zstringlen len(zs);
+    char* x = new char[len.value()+1];
+    ::gzread(zs.fp(), x, len.value());
+    x[len.value()] = '\0';
+    return x;
+}
+
+// ----------------------------- ozstream -----------------------------
+
+class ozstream
+{
+    public:
+        ozstream() : m_fp(0), m_os(0) {
+        }
+        ozstream(FILE* fp, int level = Z_DEFAULT_COMPRESSION)
+            : m_fp(0), m_os(0) {
+            open(fp, level);
+        }
+        ozstream(const char* name, int level = Z_DEFAULT_COMPRESSION)
+            : m_fp(0), m_os(0) {
+            open(name, level);
+        }
+        ~ozstream() {
+            close();
+        }
+
+        /* Opens a gzip (.gz) file for writing.
+         * The compression level parameter should be in 0..9
+         * errno can be checked to distinguish two error cases
+         * (if errno is zero, the zlib error is Z_MEM_ERROR).
+         */
+        void open(const char* name, int level = Z_DEFAULT_COMPRESSION) {
+            char mode[4] = "wb\0";
+            if (level != Z_DEFAULT_COMPRESSION) mode[2] = '0'+level;
+            if (m_fp) close();
+            m_fp = ::gzopen(name, mode);
+        }
+
+        /* open from a FILE pointer.
+         */
+        void open(FILE* fp, int level = Z_DEFAULT_COMPRESSION) {
+            SET_BINARY_MODE(fp);
+            char mode[4] = "wb\0";
+            if (level != Z_DEFAULT_COMPRESSION) mode[2] = '0'+level;
+            if (m_fp) close();
+            m_fp = ::gzdopen(fileno(fp), mode);
+        }
+
+        /* Flushes all pending output if necessary, closes the compressed file
+         * and deallocates all the (de)compression state. The return value is
+         * the zlib error number (see function error() below).
+         */
+        int close() {
+            if (m_os) {
+                ::gzwrite(m_fp, m_os->str(), m_os->pcount());
+                delete[] m_os->str(); delete m_os; m_os = 0;
+            }
+            int r = ::gzclose(m_fp); m_fp = 0; return r;
+        }
+
+        /* Binary write the given number of bytes into the compressed file.
+         */
+        int write(const void* buf, size_t len) {
+            return ::gzwrite(m_fp, (voidp) buf, len);
+        }
+
+        /* Flushes all pending output into the compressed file. The parameter
+         * _flush is as in the deflate() function. The return value is the zlib
+         * error number (see function gzerror below). flush() returns Z_OK if
+         * the flush_ parameter is Z_FINISH and all output could be flushed.
+         * flush() should be called only when strictly necessary because it can
+         * degrade compression.
+         */
+        int flush(int _flush) {
+            os_flush();
+            return ::gzflush(m_fp, _flush);
+        }
+
+        /* Returns the error message for the last error which occurred on the
+         * given compressed file. errnum is set to zlib error number. If an
+         * error occurred in the file system and not in the compression library,
+         * errnum is set to Z_ERRNO and the application may consult errno
+         * to get the exact error code.
+         */
+        const char* error(int* errnum) {
+            return ::gzerror(m_fp, errnum);
+        }
+
+        gzFile fp() { return m_fp; }
+
+        ostream& os() {
+            if (m_os == 0) m_os = new ostrstream;
+            return *m_os;
+        }
+
+        void os_flush() {
+            if (m_os && m_os->pcount()>0) {
+                ostrstream* oss = new ostrstream;
+                oss->fill(m_os->fill());
+                oss->flags(m_os->flags());
+                oss->precision(m_os->precision());
+                oss->width(m_os->width());
+                ::gzwrite(m_fp, m_os->str(), m_os->pcount());
+                delete[] m_os->str(); delete m_os; m_os = oss;
+            }
+        }
+
+    private:
+        gzFile m_fp;
+        ostrstream* m_os;
+};
+
+/*
+ * Binary write the given (array of) object(s) into the compressed file.
+ * returns the number of uncompressed bytes actually written
+ * (0 in case of error).
+ */
+template <class T, class Items>
+inline int write(ozstream& zs, const T* x, Items items) {
+    return ::gzwrite(zs.fp(), (voidp) x, items*sizeof(T));
+}
+
+/*
+ * Binary output with the '<' operator.
+ */
+template <class T>
+inline ozstream& operator<(ozstream& zs, const T& x) {
+    ::gzwrite(zs.fp(), (voidp) &x, sizeof(T));
+    return zs;
+}
+
+inline zstringlen::zstringlen(ozstream& zs, const char* x) {
+    val.byte = 255;  val.word = ::strlen(x);
+    if (val.word < 255) zs < (val.byte = val.word);
+    else zs < val;
+}
+
+/*
+ * Write length of string + the string with the '<' operator.
+ */
+inline ozstream& operator<(ozstream& zs, const char* x) {
+    zstringlen len(zs, x);
+    ::gzwrite(zs.fp(), (voidp) x, len.value());
+    return zs;
+}
+
+#ifdef _MSC_VER
+inline ozstream& operator<(ozstream& zs, char* const& x) {
+    return zs < (const char*) x;
+}
+#endif
+
+/*
+ * Ascii write with the << operator;
+ */
+template <class T>
+inline ostream& operator<<(ozstream& zs, const T& x) {
+    zs.os_flush();
+    return zs.os() << x;
+}
+
+#endif
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/iostream2/zstream_test.cpp b/Engine/lib/assimp/contrib/zlib/contrib/iostream2/zstream_test.cpp
new file mode 100644
index 000000000..6273f62d6
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/iostream2/zstream_test.cpp
@@ -0,0 +1,25 @@
+#include "zstream.h"
+#include <math.h>
+#include <stdlib.h>
+#include <iomanip.h>
+
+void main() {
+    char h[256] = "Hello";
+    char* g = "Goodbye";
+    ozstream out("temp.gz");
+    out < "This works well" < h < g;
+    out.close();
+
+    izstream in("temp.gz"); // read it back
+    char *x = read_string(in), *y = new char[256], z[256];
+    in > y > z;
+    in.close();
+    cout << x << endl << y << endl << z << endl;
+
+    out.open("temp.gz"); // try ascii output; zcat temp.gz to see the results
+    out << setw(50) << setfill('#') << setprecision(20) << x << endl << y << endl << z << endl;
+    out << z << endl << y << endl << x << endl;
+    out << 1.1234567890123456789 << endl;
+
+    delete[] x; delete[] y;
+}
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/iostream3/README b/Engine/lib/assimp/contrib/zlib/contrib/iostream3/README
new file mode 100644
index 000000000..f7b319ab9
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/iostream3/README
@@ -0,0 +1,35 @@
+These classes provide a C++ stream interface to the zlib library. It allows you
+to do things like:
+
+  gzofstream outf("blah.gz");
+  outf << "These go into the gzip file " << 123 << endl;
+
+It does this by deriving a specialized stream buffer for gzipped files, which is
+the way Stroustrup would have done it. :->
+
+The gzifstream and gzofstream classes were originally written by Kevin Ruland
+and made available in the zlib contrib/iostream directory. The older version still
+compiles under gcc 2.xx, but not under gcc 3.xx, which sparked the development of
+this version.
+
+The new classes are as standard-compliant as possible, closely following the
+approach of the standard library's fstream classes. It compiles under gcc versions
+3.2 and 3.3, but not under gcc 2.xx. This is mainly due to changes in the standard
+library naming scheme. The new version of gzifstream/gzofstream/gzfilebuf differs
+from the previous one in the following respects:
+- added showmanyc
+- added setbuf, with support for unbuffered output via setbuf(0,0)
+- a few bug fixes of stream behavior
+- gzipped output file opened with default compression level instead of maximum level
+- setcompressionlevel()/strategy() members replaced by single setcompression()
+
+The code is provided "as is", with the permission to use, copy, modify, distribute
+and sell it for any purpose without fee.
+
+Ludwig Schwardt
+<schwardt@sun.ac.za>
+
+DSP Lab
+Electrical & Electronic Engineering Department
+University of Stellenbosch
+South Africa
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/iostream3/TODO b/Engine/lib/assimp/contrib/zlib/contrib/iostream3/TODO
new file mode 100644
index 000000000..7032f97be
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/iostream3/TODO
@@ -0,0 +1,17 @@
+Possible upgrades to gzfilebuf:
+
+- The ability to do putback (e.g. putbackfail)
+
+- The ability to seek (zlib supports this, but could be slow/tricky)
+
+- Simultaneous read/write access (does it make sense?)
+
+- Support for ios_base::ate open mode
+
+- Locale support?
+
+- Check public interface to see which calls give problems
+  (due to dependence on library internals)
+
+- Override operator<<(ostream&, gzfilebuf*) to allow direct copying
+  of stream buffer to stream ( i.e. os << is.rdbuf(); )
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/iostream3/test.cc b/Engine/lib/assimp/contrib/zlib/contrib/iostream3/test.cc
new file mode 100644
index 000000000..94235334f
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/iostream3/test.cc
@@ -0,0 +1,50 @@
+/*
+ * Test program for gzifstream and gzofstream
+ *
+ * by Ludwig Schwardt <schwardt@sun.ac.za>
+ * original version by Kevin Ruland <kevin@rodin.wustl.edu>
+ */
+
+#include "zfstream.h"
+#include <iostream>      // for cout
+
+int main() {
+
+  gzofstream outf;
+  gzifstream inf;
+  char buf[80];
+
+  outf.open("test1.txt.gz");
+  outf << "The quick brown fox sidestepped the lazy canine\n"
+       << 1.3 << "\nPlan " << 9 << std::endl;
+  outf.close();
+  std::cout << "Wrote the following message to 'test1.txt.gz' (check with zcat or zless):\n"
+            << "The quick brown fox sidestepped the lazy canine\n"
+            << 1.3 << "\nPlan " << 9 << std::endl;
+
+  std::cout << "\nReading 'test1.txt.gz' (buffered) produces:\n";
+  inf.open("test1.txt.gz");
+  while (inf.getline(buf,80,'\n')) {
+    std::cout << buf << "\t(" << inf.rdbuf()->in_avail() << " chars left in buffer)\n";
+  }
+  inf.close();
+
+  outf.rdbuf()->pubsetbuf(0,0);
+  outf.open("test2.txt.gz");
+  outf << setcompression(Z_NO_COMPRESSION)
+       << "The quick brown fox sidestepped the lazy canine\n"
+       << 1.3 << "\nPlan " << 9 << std::endl;
+  outf.close();
+  std::cout << "\nWrote the same message to 'test2.txt.gz' in uncompressed form";
+
+  std::cout << "\nReading 'test2.txt.gz' (unbuffered) produces:\n";
+  inf.rdbuf()->pubsetbuf(0,0);
+  inf.open("test2.txt.gz");
+  while (inf.getline(buf,80,'\n')) {
+    std::cout << buf << "\t(" << inf.rdbuf()->in_avail() << " chars left in buffer)\n";
+  }
+  inf.close();
+
+  return 0;
+
+}
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/iostream3/zfstream.cc b/Engine/lib/assimp/contrib/zlib/contrib/iostream3/zfstream.cc
new file mode 100644
index 000000000..94eb93344
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/iostream3/zfstream.cc
@@ -0,0 +1,479 @@
+/*
+ * A C++ I/O streams interface to the zlib gz* functions
+ *
+ * by Ludwig Schwardt <schwardt@sun.ac.za>
+ * original version by Kevin Ruland <kevin@rodin.wustl.edu>
+ *
+ * This version is standard-compliant and compatible with gcc 3.x.
+ */
+
+#include "zfstream.h"
+#include <cstring>          // for strcpy, strcat, strlen (mode strings)
+#include <cstdio>           // for BUFSIZ
+
+// Internal buffer sizes (default and "unbuffered" versions)
+#define BIGBUFSIZE BUFSIZ
+#define SMALLBUFSIZE 1
+
+/*****************************************************************************/
+
+// Default constructor
+gzfilebuf::gzfilebuf()
+: file(NULL), io_mode(std::ios_base::openmode(0)), own_fd(false),
+  buffer(NULL), buffer_size(BIGBUFSIZE), own_buffer(true)
+{
+  // No buffers to start with
+  this->disable_buffer();
+}
+
+// Destructor
+gzfilebuf::~gzfilebuf()
+{
+  // Sync output buffer and close only if responsible for file
+  // (i.e. attached streams should be left open at this stage)
+  this->sync();
+  if (own_fd)
+    this->close();
+  // Make sure internal buffer is deallocated
+  this->disable_buffer();
+}
+
+// Set compression level and strategy
+int
+gzfilebuf::setcompression(int comp_level,
+                          int comp_strategy)
+{
+  return gzsetparams(file, comp_level, comp_strategy);
+}
+
+// Open gzipped file
+gzfilebuf*
+gzfilebuf::open(const char *name,
+                std::ios_base::openmode mode)
+{
+  // Fail if file already open
+  if (this->is_open())
+    return NULL;
+  // Don't support simultaneous read/write access (yet)
+  if ((mode & std::ios_base::in) && (mode & std::ios_base::out))
+    return NULL;
+
+  // Build mode string for gzopen and check it [27.8.1.3.2]
+  char char_mode[6] = "\0\0\0\0\0";
+  if (!this->open_mode(mode, char_mode))
+    return NULL;
+
+  // Attempt to open file
+  if ((file = gzopen(name, char_mode)) == NULL)
+    return NULL;
+
+  // On success, allocate internal buffer and set flags
+  this->enable_buffer();
+  io_mode = mode;
+  own_fd = true;
+  return this;
+}
+
+// Attach to gzipped file
+gzfilebuf*
+gzfilebuf::attach(int fd,
+                  std::ios_base::openmode mode)
+{
+  // Fail if file already open
+  if (this->is_open())
+    return NULL;
+  // Don't support simultaneous read/write access (yet)
+  if ((mode & std::ios_base::in) && (mode & std::ios_base::out))
+    return NULL;
+
+  // Build mode string for gzdopen and check it [27.8.1.3.2]
+  char char_mode[6] = "\0\0\0\0\0";
+  if (!this->open_mode(mode, char_mode))
+    return NULL;
+
+  // Attempt to attach to file
+  if ((file = gzdopen(fd, char_mode)) == NULL)
+    return NULL;
+
+  // On success, allocate internal buffer and set flags
+  this->enable_buffer();
+  io_mode = mode;
+  own_fd = false;
+  return this;
+}
+
+// Close gzipped file
+gzfilebuf*
+gzfilebuf::close()
+{
+  // Fail immediately if no file is open
+  if (!this->is_open())
+    return NULL;
+  // Assume success
+  gzfilebuf* retval = this;
+  // Attempt to sync and close gzipped file
+  if (this->sync() == -1)
+    retval = NULL;
+  if (gzclose(file) < 0)
+    retval = NULL;
+  // File is now gone anyway (postcondition [27.8.1.3.8])
+  file = NULL;
+  own_fd = false;
+  // Destroy internal buffer if it exists
+  this->disable_buffer();
+  return retval;
+}
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+// Convert int open mode to mode string
+bool
+gzfilebuf::open_mode(std::ios_base::openmode mode,
+                     char* c_mode) const
+{
+  bool testb = mode & std::ios_base::binary;
+  bool testi = mode & std::ios_base::in;
+  bool testo = mode & std::ios_base::out;
+  bool testt = mode & std::ios_base::trunc;
+  bool testa = mode & std::ios_base::app;
+
+  // Check for valid flag combinations - see [27.8.1.3.2] (Table 92)
+  // Original zfstream hardcoded the compression level to maximum here...
+  // Double the time for less than 1% size improvement seems
+  // excessive though - keeping it at the default level
+  // To change back, just append "9" to the next three mode strings
+  if (!testi && testo && !testt && !testa)
+    strcpy(c_mode, "w");
+  if (!testi && testo && !testt && testa)
+    strcpy(c_mode, "a");
+  if (!testi && testo && testt && !testa)
+    strcpy(c_mode, "w");
+  if (testi && !testo && !testt && !testa)
+    strcpy(c_mode, "r");
+  // No read/write mode yet
+//  if (testi && testo && !testt && !testa)
+//    strcpy(c_mode, "r+");
+//  if (testi && testo && testt && !testa)
+//    strcpy(c_mode, "w+");
+
+  // Mode string should be empty for invalid combination of flags
+  if (strlen(c_mode) == 0)
+    return false;
+  if (testb)
+    strcat(c_mode, "b");
+  return true;
+}
+
+// Determine number of characters in internal get buffer
+std::streamsize
+gzfilebuf::showmanyc()
+{
+  // Calls to underflow will fail if file not opened for reading
+  if (!this->is_open() || !(io_mode & std::ios_base::in))
+    return -1;
+  // Make sure get area is in use
+  if (this->gptr() && (this->gptr() < this->egptr()))
+    return std::streamsize(this->egptr() - this->gptr());
+  else
+    return 0;
+}
+
+// Fill get area from gzipped file
+gzfilebuf::int_type
+gzfilebuf::underflow()
+{
+  // If something is left in the get area by chance, return it
+  // (this shouldn't normally happen, as underflow is only supposed
+  // to be called when gptr >= egptr, but it serves as error check)
+  if (this->gptr() && (this->gptr() < this->egptr()))
+    return traits_type::to_int_type(*(this->gptr()));
+
+  // If the file hasn't been opened for reading, produce error
+  if (!this->is_open() || !(io_mode & std::ios_base::in))
+    return traits_type::eof();
+
+  // Attempt to fill internal buffer from gzipped file
+  // (buffer must be guaranteed to exist...)
+  int bytes_read = gzread(file, buffer, buffer_size);
+  // Indicates error or EOF
+  if (bytes_read <= 0)
+  {
+    // Reset get area
+    this->setg(buffer, buffer, buffer);
+    return traits_type::eof();
+  }
+  // Make all bytes read from file available as get area
+  this->setg(buffer, buffer, buffer + bytes_read);
+
+  // Return next character in get area
+  return traits_type::to_int_type(*(this->gptr()));
+}
+
+// Write put area to gzipped file
+gzfilebuf::int_type
+gzfilebuf::overflow(int_type c)
+{
+  // Determine whether put area is in use
+  if (this->pbase())
+  {
+    // Double-check pointer range
+    if (this->pptr() > this->epptr() || this->pptr() < this->pbase())
+      return traits_type::eof();
+    // Add extra character to buffer if not EOF
+    if (!traits_type::eq_int_type(c, traits_type::eof()))
+    {
+      *(this->pptr()) = traits_type::to_char_type(c);
+      this->pbump(1);
+    }
+    // Number of characters to write to file
+    int bytes_to_write = this->pptr() - this->pbase();
+    // Overflow doesn't fail if nothing is to be written
+    if (bytes_to_write > 0)
+    {
+      // If the file hasn't been opened for writing, produce error
+      if (!this->is_open() || !(io_mode & std::ios_base::out))
+        return traits_type::eof();
+      // If gzipped file won't accept all bytes written to it, fail
+      if (gzwrite(file, this->pbase(), bytes_to_write) != bytes_to_write)
+        return traits_type::eof();
+      // Reset next pointer to point to pbase on success
+      this->pbump(-bytes_to_write);
+    }
+  }
+  // Write extra character to file if not EOF
+  else if (!traits_type::eq_int_type(c, traits_type::eof()))
+  {
+    // If the file hasn't been opened for writing, produce error
+    if (!this->is_open() || !(io_mode & std::ios_base::out))
+      return traits_type::eof();
+    // Impromptu char buffer (allows "unbuffered" output)
+    char_type last_char = traits_type::to_char_type(c);
+    // If gzipped file won't accept this character, fail
+    if (gzwrite(file, &last_char, 1) != 1)
+      return traits_type::eof();
+  }
+
+  // If you got here, you have succeeded (even if c was EOF)
+  // The return value should therefore be non-EOF
+  if (traits_type::eq_int_type(c, traits_type::eof()))
+    return traits_type::not_eof(c);
+  else
+    return c;
+}
+
+// Assign new buffer
+std::streambuf*
+gzfilebuf::setbuf(char_type* p,
+                  std::streamsize n)
+{
+  // First make sure stuff is sync'ed, for safety
+  if (this->sync() == -1)
+    return NULL;
+  // If buffering is turned off on purpose via setbuf(0,0), still allocate one...
+  // "Unbuffered" only really refers to put [27.8.1.4.10], while get needs at
+  // least a buffer of size 1 (very inefficient though, therefore make it bigger?)
+  // This follows from [27.5.2.4.3]/12 (gptr needs to point at something, it seems)
+  if (!p || !n)
+  {
+    // Replace existing buffer (if any) with small internal buffer
+    this->disable_buffer();
+    buffer = NULL;
+    buffer_size = 0;
+    own_buffer = true;
+    this->enable_buffer();
+  }
+  else
+  {
+    // Replace existing buffer (if any) with external buffer
+    this->disable_buffer();
+    buffer = p;
+    buffer_size = n;
+    own_buffer = false;
+    this->enable_buffer();
+  }
+  return this;
+}
+
+// Write put area to gzipped file (i.e. ensures that put area is empty)
+int
+gzfilebuf::sync()
+{
+  return traits_type::eq_int_type(this->overflow(), traits_type::eof()) ? -1 : 0;
+}
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+// Allocate internal buffer
+void
+gzfilebuf::enable_buffer()
+{
+  // If internal buffer required, allocate one
+  if (own_buffer && !buffer)
+  {
+    // Check for buffered vs. "unbuffered"
+    if (buffer_size > 0)
+    {
+      // Allocate internal buffer
+      buffer = new char_type[buffer_size];
+      // Get area starts empty and will be expanded by underflow as need arises
+      this->setg(buffer, buffer, buffer);
+      // Setup entire internal buffer as put area.
+      // The one-past-end pointer actually points to the last element of the buffer,
+      // so that overflow(c) can safely add the extra character c to the sequence.
+      // These pointers remain in place for the duration of the buffer
+      this->setp(buffer, buffer + buffer_size - 1);
+    }
+    else
+    {
+      // Even in "unbuffered" case, (small?) get buffer is still required
+      buffer_size = SMALLBUFSIZE;
+      buffer = new char_type[buffer_size];
+      this->setg(buffer, buffer, buffer);
+      // "Unbuffered" means no put buffer
+      this->setp(0, 0);
+    }
+  }
+  else
+  {
+    // If buffer already allocated, reset buffer pointers just to make sure no
+    // stale chars are lying around
+    this->setg(buffer, buffer, buffer);
+    this->setp(buffer, buffer + buffer_size - 1);
+  }
+}
+
+// Destroy internal buffer
+void
+gzfilebuf::disable_buffer()
+{
+  // If internal buffer exists, deallocate it
+  if (own_buffer && buffer)
+  {
+    // Preserve unbuffered status by zeroing size
+    if (!this->pbase())
+      buffer_size = 0;
+    delete[] buffer;
+    buffer = NULL;
+    this->setg(0, 0, 0);
+    this->setp(0, 0);
+  }
+  else
+  {
+    // Reset buffer pointers to initial state if external buffer exists
+    this->setg(buffer, buffer, buffer);
+    if (buffer)
+      this->setp(buffer, buffer + buffer_size - 1);
+    else
+      this->setp(0, 0);
+  }
+}
+
+/*****************************************************************************/
+
+// Default constructor initializes stream buffer
+gzifstream::gzifstream()
+: std::istream(NULL), sb()
+{ this->init(&sb); }
+
+// Initialize stream buffer and open file
+gzifstream::gzifstream(const char* name,
+                       std::ios_base::openmode mode)
+: std::istream(NULL), sb()
+{
+  this->init(&sb);
+  this->open(name, mode);
+}
+
+// Initialize stream buffer and attach to file
+gzifstream::gzifstream(int fd,
+                       std::ios_base::openmode mode)
+: std::istream(NULL), sb()
+{
+  this->init(&sb);
+  this->attach(fd, mode);
+}
+
+// Open file and go into fail() state if unsuccessful
+void
+gzifstream::open(const char* name,
+                 std::ios_base::openmode mode)
+{
+  if (!sb.open(name, mode | std::ios_base::in))
+    this->setstate(std::ios_base::failbit);
+  else
+    this->clear();
+}
+
+// Attach to file and go into fail() state if unsuccessful
+void
+gzifstream::attach(int fd,
+                   std::ios_base::openmode mode)
+{
+  if (!sb.attach(fd, mode | std::ios_base::in))
+    this->setstate(std::ios_base::failbit);
+  else
+    this->clear();
+}
+
+// Close file
+void
+gzifstream::close()
+{
+  if (!sb.close())
+    this->setstate(std::ios_base::failbit);
+}
+
+/*****************************************************************************/
+
+// Default constructor initializes stream buffer
+gzofstream::gzofstream()
+: std::ostream(NULL), sb()
+{ this->init(&sb); }
+
+// Initialize stream buffer and open file
+gzofstream::gzofstream(const char* name,
+                       std::ios_base::openmode mode)
+: std::ostream(NULL), sb()
+{
+  this->init(&sb);
+  this->open(name, mode);
+}
+
+// Initialize stream buffer and attach to file
+gzofstream::gzofstream(int fd,
+                       std::ios_base::openmode mode)
+: std::ostream(NULL), sb()
+{
+  this->init(&sb);
+  this->attach(fd, mode);
+}
+
+// Open file and go into fail() state if unsuccessful
+void
+gzofstream::open(const char* name,
+                 std::ios_base::openmode mode)
+{
+  if (!sb.open(name, mode | std::ios_base::out))
+    this->setstate(std::ios_base::failbit);
+  else
+    this->clear();
+}
+
+// Attach to file and go into fail() state if unsuccessful
+void
+gzofstream::attach(int fd,
+                   std::ios_base::openmode mode)
+{
+  if (!sb.attach(fd, mode | std::ios_base::out))
+    this->setstate(std::ios_base::failbit);
+  else
+    this->clear();
+}
+
+// Close file
+void
+gzofstream::close()
+{
+  if (!sb.close())
+    this->setstate(std::ios_base::failbit);
+}
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/iostream3/zfstream.h b/Engine/lib/assimp/contrib/zlib/contrib/iostream3/zfstream.h
new file mode 100644
index 000000000..8574479ae
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/iostream3/zfstream.h
@@ -0,0 +1,466 @@
+/*
+ * A C++ I/O streams interface to the zlib gz* functions
+ *
+ * by Ludwig Schwardt <schwardt@sun.ac.za>
+ * original version by Kevin Ruland <kevin@rodin.wustl.edu>
+ *
+ * This version is standard-compliant and compatible with gcc 3.x.
+ */
+
+#ifndef ZFSTREAM_H
+#define ZFSTREAM_H
+
+#include <istream>  // not iostream, since we don't need cin/cout
+#include <ostream>
+#include "zlib.h"
+
+/*****************************************************************************/
+
+/**
+ *  @brief  Gzipped file stream buffer class.
+ *
+ *  This class implements basic_filebuf for gzipped files. It doesn't yet support
+ *  seeking (allowed by zlib but slow/limited), putback and read/write access
+ *  (tricky). Otherwise, it attempts to be a drop-in replacement for the standard
+ *  file streambuf.
+*/
+class gzfilebuf : public std::streambuf
+{
+public:
+  //  Default constructor.
+  gzfilebuf();
+
+  //  Destructor.
+  virtual
+  ~gzfilebuf();
+
+  /**
+   *  @brief  Set compression level and strategy on the fly.
+   *  @param  comp_level  Compression level (see zlib.h for allowed values)
+   *  @param  comp_strategy  Compression strategy (see zlib.h for allowed values)
+   *  @return  Z_OK on success, Z_STREAM_ERROR otherwise.
+   *
+   *  Unfortunately, these parameters cannot be modified separately, as the
+   *  previous zfstream version assumed. Since the strategy is seldom changed,
+   *  it can default and setcompression(level) then becomes like the old
+   *  setcompressionlevel(level).
+  */
+  int
+  setcompression(int comp_level,
+                 int comp_strategy = Z_DEFAULT_STRATEGY);
+
+  /**
+   *  @brief  Check if file is open.
+   *  @return  True if file is open.
+  */
+  bool
+  is_open() const { return (file != NULL); }
+
+  /**
+   *  @brief  Open gzipped file.
+   *  @param  name  File name.
+   *  @param  mode  Open mode flags.
+   *  @return  @c this on success, NULL on failure.
+  */
+  gzfilebuf*
+  open(const char* name,
+       std::ios_base::openmode mode);
+
+  /**
+   *  @brief  Attach to already open gzipped file.
+   *  @param  fd  File descriptor.
+   *  @param  mode  Open mode flags.
+   *  @return  @c this on success, NULL on failure.
+  */
+  gzfilebuf*
+  attach(int fd,
+         std::ios_base::openmode mode);
+
+  /**
+   *  @brief  Close gzipped file.
+   *  @return  @c this on success, NULL on failure.
+  */
+  gzfilebuf*
+  close();
+
+protected:
+  /**
+   *  @brief  Convert ios open mode int to mode string used by zlib.
+   *  @return  True if valid mode flag combination.
+  */
+  bool
+  open_mode(std::ios_base::openmode mode,
+            char* c_mode) const;
+
+  /**
+   *  @brief  Number of characters available in stream buffer.
+   *  @return  Number of characters.
+   *
+   *  This indicates number of characters in get area of stream buffer.
+   *  These characters can be read without accessing the gzipped file.
+  */
+  virtual std::streamsize
+  showmanyc();
+
+  /**
+   *  @brief  Fill get area from gzipped file.
+   *  @return  First character in get area on success, EOF on error.
+   *
+   *  This actually reads characters from gzipped file to stream
+   *  buffer. Always buffered.
+  */
+  virtual int_type
+  underflow();
+
+  /**
+   *  @brief  Write put area to gzipped file.
+   *  @param  c  Extra character to add to buffer contents.
+   *  @return  Non-EOF on success, EOF on error.
+   *
+   *  This actually writes characters in stream buffer to
+   *  gzipped file. With unbuffered output this is done one
+   *  character at a time.
+  */
+  virtual int_type
+  overflow(int_type c = traits_type::eof());
+
+  /**
+   *  @brief  Installs external stream buffer.
+   *  @param  p  Pointer to char buffer.
+   *  @param  n  Size of external buffer.
+   *  @return  @c this on success, NULL on failure.
+   *
+   *  Call setbuf(0,0) to enable unbuffered output.
+  */
+  virtual std::streambuf*
+  setbuf(char_type* p,
+         std::streamsize n);
+
+  /**
+   *  @brief  Flush stream buffer to file.
+   *  @return  0 on success, -1 on error.
+   *
+   *  This calls underflow(EOF) to do the job.
+  */
+  virtual int
+  sync();
+
+//
+// Some future enhancements
+//
+//  virtual int_type uflow();
+//  virtual int_type pbackfail(int_type c = traits_type::eof());
+//  virtual pos_type
+//  seekoff(off_type off,
+//          std::ios_base::seekdir way,
+//          std::ios_base::openmode mode = std::ios_base::in|std::ios_base::out);
+//  virtual pos_type
+//  seekpos(pos_type sp,
+//          std::ios_base::openmode mode = std::ios_base::in|std::ios_base::out);
+
+private:
+  /**
+   *  @brief  Allocate internal buffer.
+   *
+   *  This function is safe to call multiple times. It will ensure
+   *  that a proper internal buffer exists if it is required. If the
+   *  buffer already exists or is external, the buffer pointers will be
+   *  reset to their original state.
+  */
+  void
+  enable_buffer();
+
+  /**
+   *  @brief  Destroy internal buffer.
+   *
+   *  This function is safe to call multiple times. It will ensure
+   *  that the internal buffer is deallocated if it exists. In any
+   *  case, it will also reset the buffer pointers.
+  */
+  void
+  disable_buffer();
+
+  /**
+   *  Underlying file pointer.
+  */
+  gzFile file;
+
+  /**
+   *  Mode in which file was opened.
+  */
+  std::ios_base::openmode io_mode;
+
+  /**
+   *  @brief  True if this object owns file descriptor.
+   *
+   *  This makes the class responsible for closing the file
+   *  upon destruction.
+  */
+  bool own_fd;
+
+  /**
+   *  @brief  Stream buffer.
+   *
+   *  For simplicity this remains allocated on the free store for the
+   *  entire life span of the gzfilebuf object, unless replaced by setbuf.
+  */
+  char_type* buffer;
+
+  /**
+   *  @brief  Stream buffer size.
+   *
+   *  Defaults to system default buffer size (typically 8192 bytes).
+   *  Modified by setbuf.
+  */
+  std::streamsize buffer_size;
+
+  /**
+   *  @brief  True if this object owns stream buffer.
+   *
+   *  This makes the class responsible for deleting the buffer
+   *  upon destruction.
+  */
+  bool own_buffer;
+};
+
+/*****************************************************************************/
+
+/**
+ *  @brief  Gzipped file input stream class.
+ *
+ *  This class implements ifstream for gzipped files. Seeking and putback
+ *  is not supported yet.
+*/
+class gzifstream : public std::istream
+{
+public:
+  //  Default constructor
+  gzifstream();
+
+  /**
+   *  @brief  Construct stream on gzipped file to be opened.
+   *  @param  name  File name.
+   *  @param  mode  Open mode flags (forced to contain ios::in).
+  */
+  explicit
+  gzifstream(const char* name,
+             std::ios_base::openmode mode = std::ios_base::in);
+
+  /**
+   *  @brief  Construct stream on already open gzipped file.
+   *  @param  fd    File descriptor.
+   *  @param  mode  Open mode flags (forced to contain ios::in).
+  */
+  explicit
+  gzifstream(int fd,
+             std::ios_base::openmode mode = std::ios_base::in);
+
+  /**
+   *  Obtain underlying stream buffer.
+  */
+  gzfilebuf*
+  rdbuf() const
+  { return const_cast<gzfilebuf*>(&sb); }
+
+  /**
+   *  @brief  Check if file is open.
+   *  @return  True if file is open.
+  */
+  bool
+  is_open() { return sb.is_open(); }
+
+  /**
+   *  @brief  Open gzipped file.
+   *  @param  name  File name.
+   *  @param  mode  Open mode flags (forced to contain ios::in).
+   *
+   *  Stream will be in state good() if file opens successfully;
+   *  otherwise in state fail(). This differs from the behavior of
+   *  ifstream, which never sets the state to good() and therefore
+   *  won't allow you to reuse the stream for a second file unless
+   *  you manually clear() the state. The choice is a matter of
+   *  convenience.
+  */
+  void
+  open(const char* name,
+       std::ios_base::openmode mode = std::ios_base::in);
+
+  /**
+   *  @brief  Attach to already open gzipped file.
+   *  @param  fd  File descriptor.
+   *  @param  mode  Open mode flags (forced to contain ios::in).
+   *
+   *  Stream will be in state good() if attach succeeded; otherwise
+   *  in state fail().
+  */
+  void
+  attach(int fd,
+         std::ios_base::openmode mode = std::ios_base::in);
+
+  /**
+   *  @brief  Close gzipped file.
+   *
+   *  Stream will be in state fail() if close failed.
+  */
+  void
+  close();
+
+private:
+  /**
+   *  Underlying stream buffer.
+  */
+  gzfilebuf sb;
+};
+
+/*****************************************************************************/
+
+/**
+ *  @brief  Gzipped file output stream class.
+ *
+ *  This class implements ofstream for gzipped files. Seeking and putback
+ *  is not supported yet.
+*/
+class gzofstream : public std::ostream
+{
+public:
+  //  Default constructor
+  gzofstream();
+
+  /**
+   *  @brief  Construct stream on gzipped file to be opened.
+   *  @param  name  File name.
+   *  @param  mode  Open mode flags (forced to contain ios::out).
+  */
+  explicit
+  gzofstream(const char* name,
+             std::ios_base::openmode mode = std::ios_base::out);
+
+  /**
+   *  @brief  Construct stream on already open gzipped file.
+   *  @param  fd    File descriptor.
+   *  @param  mode  Open mode flags (forced to contain ios::out).
+  */
+  explicit
+  gzofstream(int fd,
+             std::ios_base::openmode mode = std::ios_base::out);
+
+  /**
+   *  Obtain underlying stream buffer.
+  */
+  gzfilebuf*
+  rdbuf() const
+  { return const_cast<gzfilebuf*>(&sb); }
+
+  /**
+   *  @brief  Check if file is open.
+   *  @return  True if file is open.
+  */
+  bool
+  is_open() { return sb.is_open(); }
+
+  /**
+   *  @brief  Open gzipped file.
+   *  @param  name  File name.
+   *  @param  mode  Open mode flags (forced to contain ios::out).
+   *
+   *  Stream will be in state good() if file opens successfully;
+   *  otherwise in state fail(). This differs from the behavior of
+   *  ofstream, which never sets the state to good() and therefore
+   *  won't allow you to reuse the stream for a second file unless
+   *  you manually clear() the state. The choice is a matter of
+   *  convenience.
+  */
+  void
+  open(const char* name,
+       std::ios_base::openmode mode = std::ios_base::out);
+
+  /**
+   *  @brief  Attach to already open gzipped file.
+   *  @param  fd  File descriptor.
+   *  @param  mode  Open mode flags (forced to contain ios::out).
+   *
+   *  Stream will be in state good() if attach succeeded; otherwise
+   *  in state fail().
+  */
+  void
+  attach(int fd,
+         std::ios_base::openmode mode = std::ios_base::out);
+
+  /**
+   *  @brief  Close gzipped file.
+   *
+   *  Stream will be in state fail() if close failed.
+  */
+  void
+  close();
+
+private:
+  /**
+   *  Underlying stream buffer.
+  */
+  gzfilebuf sb;
+};
+
+/*****************************************************************************/
+
+/**
+ *  @brief  Gzipped file output stream manipulator class.
+ *
+ *  This class defines a two-argument manipulator for gzofstream. It is used
+ *  as base for the setcompression(int,int) manipulator.
+*/
+template<typename T1, typename T2>
+  class gzomanip2
+  {
+  public:
+    // Allows insertor to peek at internals
+    template <typename Ta, typename Tb>
+      friend gzofstream&
+      operator<<(gzofstream&,
+                 const gzomanip2<Ta,Tb>&);
+
+    // Constructor
+    gzomanip2(gzofstream& (*f)(gzofstream&, T1, T2),
+              T1 v1,
+              T2 v2);
+  private:
+    // Underlying manipulator function
+    gzofstream&
+    (*func)(gzofstream&, T1, T2);
+
+    // Arguments for manipulator function
+    T1 val1;
+    T2 val2;
+  };
+
+/*****************************************************************************/
+
+// Manipulator function thunks through to stream buffer
+inline gzofstream&
+setcompression(gzofstream &gzs, int l, int s = Z_DEFAULT_STRATEGY)
+{
+  (gzs.rdbuf())->setcompression(l, s);
+  return gzs;
+}
+
+// Manipulator constructor stores arguments
+template<typename T1, typename T2>
+  inline
+  gzomanip2<T1,T2>::gzomanip2(gzofstream &(*f)(gzofstream &, T1, T2),
+                              T1 v1,
+                              T2 v2)
+  : func(f), val1(v1), val2(v2)
+  { }
+
+// Insertor applies underlying manipulator function to stream
+template<typename T1, typename T2>
+  inline gzofstream&
+  operator<<(gzofstream& s, const gzomanip2<T1,T2>& m)
+  { return (*m.func)(s, m.val1, m.val2); }
+
+// Insert this onto stream to simplify setting of compression level
+inline gzomanip2<int,int>
+setcompression(int l, int s = Z_DEFAULT_STRATEGY)
+{ return gzomanip2<int,int>(&setcompression, l, s); }
+
+#endif // ZFSTREAM_H
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/masmx64/bld_ml64.bat b/Engine/lib/assimp/contrib/zlib/contrib/masmx64/bld_ml64.bat
new file mode 100644
index 000000000..f74bcef5b
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/masmx64/bld_ml64.bat
@@ -0,0 +1,2 @@
+ml64.exe /Flinffasx64 /c /Zi inffasx64.asm
+ml64.exe /Flgvmat64   /c /Zi gvmat64.asm
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/masmx64/gvmat64.asm b/Engine/lib/assimp/contrib/zlib/contrib/masmx64/gvmat64.asm
new file mode 100644
index 000000000..c1817f1be
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/masmx64/gvmat64.asm
@@ -0,0 +1,553 @@
+;uInt longest_match_x64(
+;    deflate_state *s,
+;    IPos cur_match);                             /* current match */
+
+; gvmat64.asm -- Asm portion of the optimized longest_match for 32 bits x86_64
+;  (AMD64 on Athlon 64, Opteron, Phenom
+;     and Intel EM64T on Pentium 4 with EM64T, Pentium D, Core 2 Duo, Core I5/I7)
+; Copyright (C) 1995-2010 Jean-loup Gailly, Brian Raiter and Gilles Vollant.
+;
+; File written by Gilles Vollant, by converting to assembly the longest_match
+;  from Jean-loup Gailly in deflate.c of zLib and infoZip zip.
+;
+;  and by taking inspiration on asm686 with masm, optimised assembly code
+;        from Brian Raiter, written 1998
+;
+;  This software is provided 'as-is', without any express or implied
+;  warranty.  In no event will the authors be held liable for any damages
+;  arising from the use of this software.
+;
+;  Permission is granted to anyone to use this software for any purpose,
+;  including commercial applications, and to alter it and redistribute it
+;  freely, subject to the following restrictions:
+;
+;  1. The origin of this software must not be misrepresented; you must not
+;     claim that you wrote the original software. If you use this software
+;     in a product, an acknowledgment in the product documentation would be
+;     appreciated but is not required.
+;  2. Altered source versions must be plainly marked as such, and must not be
+;     misrepresented as being the original software
+;  3. This notice may not be removed or altered from any source distribution.
+;
+;
+;
+;         http://www.zlib.net
+;         http://www.winimage.com/zLibDll
+;         http://www.muppetlabs.com/~breadbox/software/assembly.html
+;
+; to compile this file for infozip Zip, I use option:
+;   ml64.exe /Flgvmat64 /c /Zi /DINFOZIP gvmat64.asm
+;
+; to compile this file for zLib, I use option:
+;   ml64.exe /Flgvmat64 /c /Zi gvmat64.asm
+; Be carrefull to adapt zlib1222add below to your version of zLib
+;   (if you use a version of zLib before 1.0.4 or after 1.2.2.2, change
+;    value of zlib1222add later)
+;
+; This file compile with Microsoft Macro Assembler (x64) for AMD64
+;
+;   ml64.exe is given with Visual Studio 2005/2008/2010 and Windows WDK
+;
+;   (you can get Windows WDK with ml64 for AMD64 from
+;      http://www.microsoft.com/whdc/Devtools/wdk/default.mspx for low price)
+;
+
+
+;uInt longest_match(s, cur_match)
+;    deflate_state *s;
+;    IPos cur_match;                             /* current match */
+.code
+longest_match PROC
+
+
+;LocalVarsSize   equ 88
+ LocalVarsSize   equ 72
+
+; register used : rax,rbx,rcx,rdx,rsi,rdi,r8,r9,r10,r11,r12
+; free register :  r14,r15
+; register can be saved : rsp
+
+ chainlenwmask   equ  rsp + 8 - LocalVarsSize    ; high word: current chain len
+                                                 ; low word: s->wmask
+;window          equ  rsp + xx - LocalVarsSize   ; local copy of s->window ; stored in r10
+;windowbestlen   equ  rsp + xx - LocalVarsSize   ; s->window + bestlen , use r10+r11
+;scanstart       equ  rsp + xx - LocalVarsSize   ; first two bytes of string ; stored in r12w
+;scanend         equ  rsp + xx - LocalVarsSize   ; last two bytes of string use ebx
+;scanalign       equ  rsp + xx - LocalVarsSize   ; dword-misalignment of string r13
+;bestlen         equ  rsp + xx - LocalVarsSize   ; size of best match so far -> r11d
+;scan            equ  rsp + xx - LocalVarsSize   ; ptr to string wanting match -> r9
+IFDEF INFOZIP
+ELSE
+ nicematch       equ  (rsp + 16 - LocalVarsSize) ; a good enough match size
+ENDIF
+
+save_rdi        equ  rsp + 24 - LocalVarsSize
+save_rsi        equ  rsp + 32 - LocalVarsSize
+save_rbx        equ  rsp + 40 - LocalVarsSize
+save_rbp        equ  rsp + 48 - LocalVarsSize
+save_r12        equ  rsp + 56 - LocalVarsSize
+save_r13        equ  rsp + 64 - LocalVarsSize
+;save_r14        equ  rsp + 72 - LocalVarsSize
+;save_r15        equ  rsp + 80 - LocalVarsSize
+
+
+; summary of register usage
+; scanend     ebx
+; scanendw    bx
+; chainlenwmask   edx
+; curmatch    rsi
+; curmatchd   esi
+; windowbestlen   r8
+; scanalign   r9
+; scanalignd  r9d
+; window      r10
+; bestlen     r11
+; bestlend    r11d
+; scanstart   r12d
+; scanstartw  r12w
+; scan        r13
+; nicematch   r14d
+; limit       r15
+; limitd      r15d
+; prev        rcx
+
+;  all the +4 offsets are due to the addition of pending_buf_size (in zlib
+;  in the deflate_state structure since the asm code was first written
+;  (if you compile with zlib 1.0.4 or older, remove the +4).
+;  Note : these value are good with a 8 bytes boundary pack structure
+
+
+    MAX_MATCH           equ     258
+    MIN_MATCH           equ     3
+    MIN_LOOKAHEAD       equ     (MAX_MATCH+MIN_MATCH+1)
+
+
+;;; Offsets for fields in the deflate_state structure. These numbers
+;;; are calculated from the definition of deflate_state, with the
+;;; assumption that the compiler will dword-align the fields. (Thus,
+;;; changing the definition of deflate_state could easily cause this
+;;; program to crash horribly, without so much as a warning at
+;;; compile time. Sigh.)
+
+;  all the +zlib1222add offsets are due to the addition of fields
+;  in zlib in the deflate_state structure since the asm code was first written
+;  (if you compile with zlib 1.0.4 or older, use "zlib1222add equ (-4)").
+;  (if you compile with zlib between 1.0.5 and 1.2.2.1, use "zlib1222add equ 0").
+;  if you compile with zlib 1.2.2.2 or later , use "zlib1222add equ 8").
+
+
+IFDEF INFOZIP
+
+_DATA   SEGMENT
+COMM    window_size:DWORD
+; WMask ; 7fff
+COMM    window:BYTE:010040H
+COMM    prev:WORD:08000H
+; MatchLen : unused
+; PrevMatch : unused
+COMM    strstart:DWORD
+COMM    match_start:DWORD
+; Lookahead : ignore
+COMM    prev_length:DWORD ; PrevLen
+COMM    max_chain_length:DWORD
+COMM    good_match:DWORD
+COMM    nice_match:DWORD
+prev_ad equ OFFSET prev
+window_ad equ OFFSET window
+nicematch equ nice_match
+_DATA ENDS
+WMask equ 07fffh
+
+ELSE
+
+  IFNDEF zlib1222add
+    zlib1222add equ 8
+  ENDIF
+dsWSize         equ 56+zlib1222add+(zlib1222add/2)
+dsWMask         equ 64+zlib1222add+(zlib1222add/2)
+dsWindow        equ 72+zlib1222add
+dsPrev          equ 88+zlib1222add
+dsMatchLen      equ 128+zlib1222add
+dsPrevMatch     equ 132+zlib1222add
+dsStrStart      equ 140+zlib1222add
+dsMatchStart    equ 144+zlib1222add
+dsLookahead     equ 148+zlib1222add
+dsPrevLen       equ 152+zlib1222add
+dsMaxChainLen   equ 156+zlib1222add
+dsGoodMatch     equ 172+zlib1222add
+dsNiceMatch     equ 176+zlib1222add
+
+window_size     equ [ rcx + dsWSize]
+WMask           equ [ rcx + dsWMask]
+window_ad       equ [ rcx + dsWindow]
+prev_ad         equ [ rcx + dsPrev]
+strstart        equ [ rcx + dsStrStart]
+match_start     equ [ rcx + dsMatchStart]
+Lookahead       equ [ rcx + dsLookahead] ; 0ffffffffh on infozip
+prev_length     equ [ rcx + dsPrevLen]
+max_chain_length equ [ rcx + dsMaxChainLen]
+good_match      equ [ rcx + dsGoodMatch]
+nice_match      equ [ rcx + dsNiceMatch]
+ENDIF
+
+; parameter 1 in r8(deflate state s), param 2 in rdx (cur match)
+
+; see http://weblogs.asp.net/oldnewthing/archive/2004/01/14/58579.aspx and
+; http://msdn.microsoft.com/library/en-us/kmarch/hh/kmarch/64bitAMD_8e951dd2-ee77-4728-8702-55ce4b5dd24a.xml.asp
+;
+; All registers must be preserved across the call, except for
+;   rax, rcx, rdx, r8, r9, r10, and r11, which are scratch.
+
+
+
+;;; Save registers that the compiler may be using, and adjust esp to
+;;; make room for our stack frame.
+
+
+;;; Retrieve the function arguments. r8d will hold cur_match
+;;; throughout the entire function. edx will hold the pointer to the
+;;; deflate_state structure during the function's setup (before
+;;; entering the main loop.
+
+; parameter 1 in rcx (deflate_state* s), param 2 in edx -> r8 (cur match)
+
+; this clear high 32 bits of r8, which can be garbage in both r8 and rdx
+
+        mov [save_rdi],rdi
+        mov [save_rsi],rsi
+        mov [save_rbx],rbx
+        mov [save_rbp],rbp
+IFDEF INFOZIP
+        mov r8d,ecx
+ELSE
+        mov r8d,edx
+ENDIF
+        mov [save_r12],r12
+        mov [save_r13],r13
+;        mov [save_r14],r14
+;        mov [save_r15],r15
+
+
+;;; uInt wmask = s->w_mask;
+;;; unsigned chain_length = s->max_chain_length;
+;;; if (s->prev_length >= s->good_match) {
+;;;     chain_length >>= 2;
+;;; }
+
+        mov edi, prev_length
+        mov esi, good_match
+        mov eax, WMask
+        mov ebx, max_chain_length
+        cmp edi, esi
+        jl  LastMatchGood
+        shr ebx, 2
+LastMatchGood:
+
+;;; chainlen is decremented once beforehand so that the function can
+;;; use the sign flag instead of the zero flag for the exit test.
+;;; It is then shifted into the high word, to make room for the wmask
+;;; value, which it will always accompany.
+
+        dec ebx
+        shl ebx, 16
+        or  ebx, eax
+
+;;; on zlib only
+;;; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
+
+IFDEF INFOZIP
+        mov [chainlenwmask], ebx
+; on infozip nice_match = [nice_match]
+ELSE
+        mov eax, nice_match
+        mov [chainlenwmask], ebx
+        mov r10d, Lookahead
+        cmp r10d, eax
+        cmovnl r10d, eax
+        mov [nicematch],r10d
+ENDIF
+
+;;; register Bytef *scan = s->window + s->strstart;
+        mov r10, window_ad
+        mov ebp, strstart
+        lea r13, [r10 + rbp]
+
+;;; Determine how many bytes the scan ptr is off from being
+;;; dword-aligned.
+
+         mov r9,r13
+         neg r13
+         and r13,3
+
+;;; IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
+;;;     s->strstart - (IPos)MAX_DIST(s) : NIL;
+IFDEF INFOZIP
+        mov eax,07efah ; MAX_DIST = (WSIZE-MIN_LOOKAHEAD) (0x8000-(3+8+1))
+ELSE
+        mov eax, window_size
+        sub eax, MIN_LOOKAHEAD
+ENDIF
+        xor edi,edi
+        sub ebp, eax
+
+        mov r11d, prev_length
+
+        cmovng ebp,edi
+
+;;; int best_len = s->prev_length;
+
+
+;;; Store the sum of s->window + best_len in esi locally, and in esi.
+
+       lea  rsi,[r10+r11]
+
+;;; register ush scan_start = *(ushf*)scan;
+;;; register ush scan_end   = *(ushf*)(scan+best_len-1);
+;;; Posf *prev = s->prev;
+
+        movzx r12d,word ptr [r9]
+        movzx ebx, word ptr [r9 + r11 - 1]
+
+        mov rdi, prev_ad
+
+;;; Jump into the main loop.
+
+        mov edx, [chainlenwmask]
+
+        cmp bx,word ptr [rsi + r8 - 1]
+        jz  LookupLoopIsZero
+
+LookupLoop1:
+        and r8d, edx
+
+        movzx   r8d, word ptr [rdi + r8*2]
+        cmp r8d, ebp
+        jbe LeaveNow
+        sub edx, 00010000h
+        js  LeaveNow
+
+LoopEntry1:
+        cmp bx,word ptr [rsi + r8 - 1]
+        jz  LookupLoopIsZero
+
+LookupLoop2:
+        and r8d, edx
+
+        movzx   r8d, word ptr [rdi + r8*2]
+        cmp r8d, ebp
+        jbe LeaveNow
+        sub edx, 00010000h
+        js  LeaveNow
+
+LoopEntry2:
+        cmp bx,word ptr [rsi + r8 - 1]
+        jz  LookupLoopIsZero
+
+LookupLoop4:
+        and r8d, edx
+
+        movzx   r8d, word ptr [rdi + r8*2]
+        cmp r8d, ebp
+        jbe LeaveNow
+        sub edx, 00010000h
+        js  LeaveNow
+
+LoopEntry4:
+
+        cmp bx,word ptr [rsi + r8 - 1]
+        jnz LookupLoop1
+        jmp LookupLoopIsZero
+
+
+;;; do {
+;;;     match = s->window + cur_match;
+;;;     if (*(ushf*)(match+best_len-1) != scan_end ||
+;;;         *(ushf*)match != scan_start) continue;
+;;;     [...]
+;;; } while ((cur_match = prev[cur_match & wmask]) > limit
+;;;          && --chain_length != 0);
+;;;
+;;; Here is the inner loop of the function. The function will spend the
+;;; majority of its time in this loop, and majority of that time will
+;;; be spent in the first ten instructions.
+;;;
+;;; Within this loop:
+;;; ebx = scanend
+;;; r8d = curmatch
+;;; edx = chainlenwmask - i.e., ((chainlen << 16) | wmask)
+;;; esi = windowbestlen - i.e., (window + bestlen)
+;;; edi = prev
+;;; ebp = limit
+
+LookupLoop:
+        and r8d, edx
+
+        movzx   r8d, word ptr [rdi + r8*2]
+        cmp r8d, ebp
+        jbe LeaveNow
+        sub edx, 00010000h
+        js  LeaveNow
+
+LoopEntry:
+
+        cmp bx,word ptr [rsi + r8 - 1]
+        jnz LookupLoop1
+LookupLoopIsZero:
+        cmp     r12w, word ptr [r10 + r8]
+        jnz LookupLoop1
+
+
+;;; Store the current value of chainlen.
+        mov [chainlenwmask], edx
+
+;;; Point edi to the string under scrutiny, and esi to the string we
+;;; are hoping to match it up with. In actuality, esi and edi are
+;;; both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and edx is
+;;; initialized to -(MAX_MATCH_8 - scanalign).
+
+        lea rsi,[r8+r10]
+        mov rdx, 0fffffffffffffef8h; -(MAX_MATCH_8)
+        lea rsi, [rsi + r13 + 0108h] ;MAX_MATCH_8]
+        lea rdi, [r9 + r13 + 0108h] ;MAX_MATCH_8]
+
+        prefetcht1 [rsi+rdx]
+        prefetcht1 [rdi+rdx]
+
+
+;;; Test the strings for equality, 8 bytes at a time. At the end,
+;;; adjust rdx so that it is offset to the exact byte that mismatched.
+;;;
+;;; We already know at this point that the first three bytes of the
+;;; strings match each other, and they can be safely passed over before
+;;; starting the compare loop. So what this code does is skip over 0-3
+;;; bytes, as much as necessary in order to dword-align the edi
+;;; pointer. (rsi will still be misaligned three times out of four.)
+;;;
+;;; It should be confessed that this loop usually does not represent
+;;; much of the total running time. Replacing it with a more
+;;; straightforward "rep cmpsb" would not drastically degrade
+;;; performance.
+
+
+LoopCmps:
+        mov rax, [rsi + rdx]
+        xor rax, [rdi + rdx]
+        jnz LeaveLoopCmps
+
+        mov rax, [rsi + rdx + 8]
+        xor rax, [rdi + rdx + 8]
+        jnz LeaveLoopCmps8
+
+
+        mov rax, [rsi + rdx + 8+8]
+        xor rax, [rdi + rdx + 8+8]
+        jnz LeaveLoopCmps16
+
+        add rdx,8+8+8
+
+        jnz short LoopCmps
+        jmp short LenMaximum
+LeaveLoopCmps16: add rdx,8
+LeaveLoopCmps8: add rdx,8
+LeaveLoopCmps:
+
+        test    eax, 0000FFFFh
+        jnz LenLower
+
+        test eax,0ffffffffh
+
+        jnz LenLower32
+
+        add rdx,4
+        shr rax,32
+        or ax,ax
+        jnz LenLower
+
+LenLower32:
+        shr eax,16
+        add rdx,2
+LenLower:   sub al, 1
+        adc rdx, 0
+;;; Calculate the length of the match. If it is longer than MAX_MATCH,
+;;; then automatically accept it as the best possible match and leave.
+
+        lea rax, [rdi + rdx]
+        sub rax, r9
+        cmp eax, MAX_MATCH
+        jge LenMaximum
+
+;;; If the length of the match is not longer than the best match we
+;;; have so far, then forget it and return to the lookup loop.
+;///////////////////////////////////
+
+        cmp eax, r11d
+        jg  LongerMatch
+
+        lea rsi,[r10+r11]
+
+        mov rdi, prev_ad
+        mov edx, [chainlenwmask]
+        jmp LookupLoop
+
+;;;         s->match_start = cur_match;
+;;;         best_len = len;
+;;;         if (len >= nice_match) break;
+;;;         scan_end = *(ushf*)(scan+best_len-1);
+
+LongerMatch:
+        mov r11d, eax
+        mov match_start, r8d
+        cmp eax, [nicematch]
+        jge LeaveNow
+
+        lea rsi,[r10+rax]
+
+        movzx   ebx, word ptr [r9 + rax - 1]
+        mov rdi, prev_ad
+        mov edx, [chainlenwmask]
+        jmp LookupLoop
+
+;;; Accept the current string, with the maximum possible length.
+
+LenMaximum:
+        mov r11d,MAX_MATCH
+        mov match_start, r8d
+
+;;; if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
+;;; return s->lookahead;
+
+LeaveNow:
+IFDEF INFOZIP
+        mov eax,r11d
+ELSE
+        mov eax, Lookahead
+        cmp r11d, eax
+        cmovng eax, r11d
+ENDIF
+
+;;; Restore the stack and return from whence we came.
+
+
+        mov rsi,[save_rsi]
+        mov rdi,[save_rdi]
+        mov rbx,[save_rbx]
+        mov rbp,[save_rbp]
+        mov r12,[save_r12]
+        mov r13,[save_r13]
+;        mov r14,[save_r14]
+;        mov r15,[save_r15]
+
+
+        ret 0
+; please don't remove this string !
+; Your can freely use gvmat64 in any free or commercial app
+; but it is far better don't remove the string in the binary!
+    db     0dh,0ah,"asm686 with masm, optimised assembly code from Brian Raiter, written 1998, converted to amd 64 by Gilles Vollant 2005",0dh,0ah,0
+longest_match   ENDP
+
+match_init PROC
+  ret 0
+match_init ENDP
+
+
+END
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/masmx64/inffas8664.c b/Engine/lib/assimp/contrib/zlib/contrib/masmx64/inffas8664.c
new file mode 100644
index 000000000..aa861a333
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/masmx64/inffas8664.c
@@ -0,0 +1,186 @@
+/* inffas8664.c is a hand tuned assembler version of inffast.c - fast decoding
+ * version for AMD64 on Windows using Microsoft C compiler
+ *
+ * Copyright (C) 1995-2003 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ *
+ * Copyright (C) 2003 Chris Anderson <christop@charm.net>
+ * Please use the copyright conditions above.
+ *
+ * 2005 - Adaptation to Microsoft C Compiler for AMD64 by Gilles Vollant
+ *
+ * inffas8664.c call function inffas8664fnc in inffasx64.asm
+ *  inffasx64.asm is automatically convert from AMD64 portion of inffas86.c
+ *
+ * Dec-29-2003 -- I added AMD64 inflate asm support.  This version is also
+ * slightly quicker on x86 systems because, instead of using rep movsb to copy
+ * data, it uses rep movsw, which moves data in 2-byte chunks instead of single
+ * bytes.  I've tested the AMD64 code on a Fedora Core 1 + the x86_64 updates
+ * from http://fedora.linux.duke.edu/fc1_x86_64
+ * which is running on an Athlon 64 3000+ / Gigabyte GA-K8VT800M system with
+ * 1GB ram.  The 64-bit version is about 4% faster than the 32-bit version,
+ * when decompressing mozilla-source-1.3.tar.gz.
+ *
+ * Mar-13-2003 -- Most of this is derived from inffast.S which is derived from
+ * the gcc -S output of zlib-1.2.0/inffast.c.  Zlib-1.2.0 is in beta release at
+ * the moment.  I have successfully compiled and tested this code with gcc2.96,
+ * gcc3.2, icc5.0, msvc6.0.  It is very close to the speed of inffast.S
+ * compiled with gcc -DNO_MMX, but inffast.S is still faster on the P3 with MMX
+ * enabled.  I will attempt to merge the MMX code into this version.  Newer
+ * versions of this and inffast.S can be found at
+ * http://www.eetbeetee.com/zlib/ and http://www.charm.net/~christop/zlib/
+ *
+ */
+
+#include <stdio.h>
+#include "zutil.h"
+#include "inftrees.h"
+#include "inflate.h"
+#include "inffast.h"
+
+/* Mark Adler's comments from inffast.c: */
+
+/*
+   Decode literal, length, and distance codes and write out the resulting
+   literal and match bytes until either not enough input or output is
+   available, an end-of-block is encountered, or a data error is encountered.
+   When large enough input and output buffers are supplied to inflate(), for
+   example, a 16K input buffer and a 64K output buffer, more than 95% of the
+   inflate execution time is spent in this routine.
+
+   Entry assumptions:
+
+        state->mode == LEN
+        strm->avail_in >= 6
+        strm->avail_out >= 258
+        start >= strm->avail_out
+        state->bits < 8
+
+   On return, state->mode is one of:
+
+        LEN -- ran out of enough output space or enough available input
+        TYPE -- reached end of block code, inflate() to interpret next block
+        BAD -- error in block data
+
+   Notes:
+
+    - The maximum input bits used by a length/distance pair is 15 bits for the
+      length code, 5 bits for the length extra, 15 bits for the distance code,
+      and 13 bits for the distance extra.  This totals 48 bits, or six bytes.
+      Therefore if strm->avail_in >= 6, then there is enough input to avoid
+      checking for available input while decoding.
+
+    - The maximum bytes that a single length/distance pair can output is 258
+      bytes, which is the maximum length that can be coded.  inflate_fast()
+      requires strm->avail_out >= 258 for each loop to avoid checking for
+      output space.
+ */
+
+
+
+    typedef struct inffast_ar {
+/* 64   32                               x86  x86_64 */
+/* ar offset                              register */
+/*  0    0 */ void *esp;                /* esp save */
+/*  8    4 */ void *ebp;                /* ebp save */
+/* 16    8 */ unsigned char FAR *in;    /* esi rsi  local strm->next_in */
+/* 24   12 */ unsigned char FAR *last;  /*     r9   while in < last */
+/* 32   16 */ unsigned char FAR *out;   /* edi rdi  local strm->next_out */
+/* 40   20 */ unsigned char FAR *beg;   /*          inflate()'s init next_out */
+/* 48   24 */ unsigned char FAR *end;   /*     r10  while out < end */
+/* 56   28 */ unsigned char FAR *window;/*          size of window, wsize!=0 */
+/* 64   32 */ code const FAR *lcode;    /* ebp rbp  local strm->lencode */
+/* 72   36 */ code const FAR *dcode;    /*     r11  local strm->distcode */
+/* 80   40 */ size_t /*unsigned long */hold;       /* edx rdx  local strm->hold */
+/* 88   44 */ unsigned bits;            /* ebx rbx  local strm->bits */
+/* 92   48 */ unsigned wsize;           /*          window size */
+/* 96   52 */ unsigned write;           /*          window write index */
+/*100   56 */ unsigned lmask;           /*     r12  mask for lcode */
+/*104   60 */ unsigned dmask;           /*     r13  mask for dcode */
+/*108   64 */ unsigned len;             /*     r14  match length */
+/*112   68 */ unsigned dist;            /*     r15  match distance */
+/*116   72 */ unsigned status;          /*          set when state chng*/
+    } type_ar;
+#ifdef ASMINF
+
+void inflate_fast(strm, start)
+z_streamp strm;
+unsigned start;         /* inflate()'s starting value for strm->avail_out */
+{
+    struct inflate_state FAR *state;
+    type_ar ar;
+    void inffas8664fnc(struct inffast_ar * par);
+
+
+
+#if (defined( __GNUC__ ) && defined( __amd64__ ) && ! defined( __i386 )) || (defined(_MSC_VER) && defined(_M_AMD64))
+#define PAD_AVAIL_IN 6
+#define PAD_AVAIL_OUT 258
+#else
+#define PAD_AVAIL_IN 5
+#define PAD_AVAIL_OUT 257
+#endif
+
+    /* copy state to local variables */
+    state = (struct inflate_state FAR *)strm->state;
+
+    ar.in = strm->next_in;
+    ar.last = ar.in + (strm->avail_in - PAD_AVAIL_IN);
+    ar.out = strm->next_out;
+    ar.beg = ar.out - (start - strm->avail_out);
+    ar.end = ar.out + (strm->avail_out - PAD_AVAIL_OUT);
+    ar.wsize = state->wsize;
+    ar.write = state->wnext;
+    ar.window = state->window;
+    ar.hold = state->hold;
+    ar.bits = state->bits;
+    ar.lcode = state->lencode;
+    ar.dcode = state->distcode;
+    ar.lmask = (1U << state->lenbits) - 1;
+    ar.dmask = (1U << state->distbits) - 1;
+
+    /* decode literals and length/distances until end-of-block or not enough
+       input data or output space */
+
+    /* align in on 1/2 hold size boundary */
+    while (((size_t)(void *)ar.in & (sizeof(ar.hold) / 2 - 1)) != 0) {
+        ar.hold += (unsigned long)*ar.in++ << ar.bits;
+        ar.bits += 8;
+    }
+
+    inffas8664fnc(&ar);
+
+    if (ar.status > 1) {
+        if (ar.status == 2)
+            strm->msg = "invalid literal/length code";
+        else if (ar.status == 3)
+            strm->msg = "invalid distance code";
+        else
+            strm->msg = "invalid distance too far back";
+        state->mode = BAD;
+    }
+    else if ( ar.status == 1 ) {
+        state->mode = TYPE;
+    }
+
+    /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
+    ar.len = ar.bits >> 3;
+    ar.in -= ar.len;
+    ar.bits -= ar.len << 3;
+    ar.hold &= (1U << ar.bits) - 1;
+
+    /* update state and return */
+    strm->next_in = ar.in;
+    strm->next_out = ar.out;
+    strm->avail_in = (unsigned)(ar.in < ar.last ?
+                                PAD_AVAIL_IN + (ar.last - ar.in) :
+                                PAD_AVAIL_IN - (ar.in - ar.last));
+    strm->avail_out = (unsigned)(ar.out < ar.end ?
+                                 PAD_AVAIL_OUT + (ar.end - ar.out) :
+                                 PAD_AVAIL_OUT - (ar.out - ar.end));
+    state->hold = (unsigned long)ar.hold;
+    state->bits = ar.bits;
+    return;
+}
+
+#endif
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/masmx64/inffasx64.asm b/Engine/lib/assimp/contrib/zlib/contrib/masmx64/inffasx64.asm
new file mode 100644
index 000000000..41ec82392
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/masmx64/inffasx64.asm
@@ -0,0 +1,396 @@
+; inffasx64.asm is a hand tuned assembler version of inffast.c - fast decoding
+; version for AMD64 on Windows using Microsoft C compiler
+;
+; inffasx64.asm is automatically convert from AMD64 portion of inffas86.c
+; inffasx64.asm is called by inffas8664.c, which contain more info.
+
+
+; to compile this file, I use option
+;   ml64.exe /Flinffasx64 /c /Zi inffasx64.asm
+;   with Microsoft Macro Assembler (x64) for AMD64
+;
+
+; This file compile with Microsoft Macro Assembler (x64) for AMD64
+;
+;   ml64.exe is given with Visual Studio 2005/2008/2010 and Windows WDK
+;
+;   (you can get Windows WDK with ml64 for AMD64 from
+;      http://www.microsoft.com/whdc/Devtools/wdk/default.mspx for low price)
+;
+
+
+.code
+inffas8664fnc PROC
+
+; see http://weblogs.asp.net/oldnewthing/archive/2004/01/14/58579.aspx and
+; http://msdn.microsoft.com/library/en-us/kmarch/hh/kmarch/64bitAMD_8e951dd2-ee77-4728-8702-55ce4b5dd24a.xml.asp
+;
+; All registers must be preserved across the call, except for
+;   rax, rcx, rdx, r8, r-9, r10, and r11, which are scratch.
+
+
+	mov [rsp-8],rsi
+	mov [rsp-16],rdi
+	mov [rsp-24],r12
+	mov [rsp-32],r13
+	mov [rsp-40],r14
+	mov [rsp-48],r15
+	mov [rsp-56],rbx
+
+	mov rax,rcx
+
+	mov	[rax+8], rbp       ; /* save regs rbp and rsp */
+	mov	[rax], rsp
+
+	mov	rsp, rax          ; /* make rsp point to &ar */
+
+	mov	rsi, [rsp+16]      ; /* rsi  = in */
+	mov	rdi, [rsp+32]      ; /* rdi  = out */
+	mov	r9, [rsp+24]       ; /* r9   = last */
+	mov	r10, [rsp+48]      ; /* r10  = end */
+	mov	rbp, [rsp+64]      ; /* rbp  = lcode */
+	mov	r11, [rsp+72]      ; /* r11  = dcode */
+	mov	rdx, [rsp+80]      ; /* rdx  = hold */
+	mov	ebx, [rsp+88]      ; /* ebx  = bits */
+	mov	r12d, [rsp+100]    ; /* r12d = lmask */
+	mov	r13d, [rsp+104]    ; /* r13d = dmask */
+                                          ; /* r14d = len */
+                                          ; /* r15d = dist */
+
+
+	cld
+	cmp	r10, rdi
+	je	L_one_time           ; /* if only one decode left */
+	cmp	r9, rsi
+
+    jne L_do_loop
+
+
+L_one_time:
+	mov	r8, r12           ; /* r8 = lmask */
+	cmp	bl, 32
+	ja	L_get_length_code_one_time
+
+	lodsd                         ; /* eax = *(uint *)in++ */
+	mov	cl, bl            ; /* cl = bits, needs it for shifting */
+	add	bl, 32             ; /* bits += 32 */
+	shl	rax, cl
+	or	rdx, rax          ; /* hold |= *((uint *)in)++ << bits */
+	jmp	L_get_length_code_one_time
+
+ALIGN 4
+L_while_test:
+	cmp	r10, rdi
+	jbe	L_break_loop
+	cmp	r9, rsi
+	jbe	L_break_loop
+
+L_do_loop:
+	mov	r8, r12           ; /* r8 = lmask */
+	cmp	bl, 32
+	ja	L_get_length_code    ; /* if (32 < bits) */
+
+	lodsd                         ; /* eax = *(uint *)in++ */
+	mov	cl, bl            ; /* cl = bits, needs it for shifting */
+	add	bl, 32             ; /* bits += 32 */
+	shl	rax, cl
+	or	rdx, rax          ; /* hold |= *((uint *)in)++ << bits */
+
+L_get_length_code:
+	and	r8, rdx            ; /* r8 &= hold */
+	mov	eax, [rbp+r8*4]  ; /* eax = lcode[hold & lmask] */
+
+	mov	cl, ah            ; /* cl = this.bits */
+	sub	bl, ah            ; /* bits -= this.bits */
+	shr	rdx, cl           ; /* hold >>= this.bits */
+
+	test	al, al
+	jnz	L_test_for_length_base ; /* if (op != 0) 45.7% */
+
+	mov	r8, r12            ; /* r8 = lmask */
+	shr	eax, 16            ; /* output this.val char */
+	stosb
+
+L_get_length_code_one_time:
+	and	r8, rdx            ; /* r8 &= hold */
+	mov	eax, [rbp+r8*4] ; /* eax = lcode[hold & lmask] */
+
+L_dolen:
+	mov	cl, ah            ; /* cl = this.bits */
+	sub	bl, ah            ; /* bits -= this.bits */
+	shr	rdx, cl           ; /* hold >>= this.bits */
+
+	test	al, al
+	jnz	L_test_for_length_base ; /* if (op != 0) 45.7% */
+
+	shr	eax, 16            ; /* output this.val char */
+	stosb
+	jmp	L_while_test
+
+ALIGN 4
+L_test_for_length_base:
+	mov	r14d, eax         ; /* len = this */
+	shr	r14d, 16           ; /* len = this.val */
+	mov	cl, al
+
+	test	al, 16
+	jz	L_test_for_second_level_length ; /* if ((op & 16) == 0) 8% */
+	and	cl, 15             ; /* op &= 15 */
+	jz	L_decode_distance    ; /* if (!op) */
+
+L_add_bits_to_len:
+	sub	bl, cl
+	xor	eax, eax
+	inc	eax
+	shl	eax, cl
+	dec	eax
+	and	eax, edx          ; /* eax &= hold */
+	shr	rdx, cl
+	add	r14d, eax         ; /* len += hold & mask[op] */
+
+L_decode_distance:
+	mov	r8, r13           ; /* r8 = dmask */
+	cmp	bl, 32
+	ja	L_get_distance_code  ; /* if (32 < bits) */
+
+	lodsd                         ; /* eax = *(uint *)in++ */
+	mov	cl, bl            ; /* cl = bits, needs it for shifting */
+	add	bl, 32             ; /* bits += 32 */
+	shl	rax, cl
+	or	rdx, rax          ; /* hold |= *((uint *)in)++ << bits */
+
+L_get_distance_code:
+	and	r8, rdx           ; /* r8 &= hold */
+	mov	eax, [r11+r8*4] ; /* eax = dcode[hold & dmask] */
+
+L_dodist:
+	mov	r15d, eax         ; /* dist = this */
+	shr	r15d, 16           ; /* dist = this.val */
+	mov	cl, ah
+	sub	bl, ah            ; /* bits -= this.bits */
+	shr	rdx, cl           ; /* hold >>= this.bits */
+	mov	cl, al            ; /* cl = this.op */
+
+	test	al, 16             ; /* if ((op & 16) == 0) */
+	jz	L_test_for_second_level_dist
+	and	cl, 15             ; /* op &= 15 */
+	jz	L_check_dist_one
+
+L_add_bits_to_dist:
+	sub	bl, cl
+	xor	eax, eax
+	inc	eax
+	shl	eax, cl
+	dec	eax                 ; /* (1 << op) - 1 */
+	and	eax, edx          ; /* eax &= hold */
+	shr	rdx, cl
+	add	r15d, eax         ; /* dist += hold & ((1 << op) - 1) */
+
+L_check_window:
+	mov	r8, rsi           ; /* save in so from can use it's reg */
+	mov	rax, rdi
+	sub	rax, [rsp+40]      ; /* nbytes = out - beg */
+
+	cmp	eax, r15d
+	jb	L_clip_window        ; /* if (dist > nbytes) 4.2% */
+
+	mov	ecx, r14d         ; /* ecx = len */
+	mov	rsi, rdi
+	sub	rsi, r15          ; /* from = out - dist */
+
+	sar	ecx, 1
+	jnc	L_copy_two           ; /* if len % 2 == 0 */
+
+	rep     movsw
+	mov	al, [rsi]
+	mov	[rdi], al
+	inc	rdi
+
+	mov	rsi, r8           ; /* move in back to %rsi, toss from */
+	jmp	L_while_test
+
+L_copy_two:
+	rep     movsw
+	mov	rsi, r8           ; /* move in back to %rsi, toss from */
+	jmp	L_while_test
+
+ALIGN 4
+L_check_dist_one:
+	cmp	r15d, 1            ; /* if dist 1, is a memset */
+	jne	L_check_window
+	cmp	[rsp+40], rdi      ; /* if out == beg, outside window */
+	je	L_check_window
+
+	mov	ecx, r14d         ; /* ecx = len */
+	mov	al, [rdi-1]
+	mov	ah, al
+
+	sar	ecx, 1
+	jnc	L_set_two
+	mov	[rdi], al
+	inc	rdi
+
+L_set_two:
+	rep     stosw
+	jmp	L_while_test
+
+ALIGN 4
+L_test_for_second_level_length:
+	test	al, 64
+	jnz	L_test_for_end_of_block ; /* if ((op & 64) != 0) */
+
+	xor	eax, eax
+	inc	eax
+	shl	eax, cl
+	dec	eax
+	and	eax, edx         ; /* eax &= hold */
+	add	eax, r14d        ; /* eax += len */
+	mov	eax, [rbp+rax*4] ; /* eax = lcode[val+(hold&mask[op])]*/
+	jmp	L_dolen
+
+ALIGN 4
+L_test_for_second_level_dist:
+	test	al, 64
+	jnz	L_invalid_distance_code ; /* if ((op & 64) != 0) */
+
+	xor	eax, eax
+	inc	eax
+	shl	eax, cl
+	dec	eax
+	and	eax, edx         ; /* eax &= hold */
+	add	eax, r15d        ; /* eax += dist */
+	mov	eax, [r11+rax*4] ; /* eax = dcode[val+(hold&mask[op])]*/
+	jmp	L_dodist
+
+ALIGN 4
+L_clip_window:
+	mov	ecx, eax         ; /* ecx = nbytes */
+	mov	eax, [rsp+92]     ; /* eax = wsize, prepare for dist cmp */
+	neg	ecx                ; /* nbytes = -nbytes */
+
+	cmp	eax, r15d
+	jb	L_invalid_distance_too_far ; /* if (dist > wsize) */
+
+	add	ecx, r15d         ; /* nbytes = dist - nbytes */
+	cmp	dword ptr [rsp+96], 0
+	jne	L_wrap_around_window ; /* if (write != 0) */
+
+	mov	rsi, [rsp+56]     ; /* from  = window */
+	sub	eax, ecx         ; /* eax  -= nbytes */
+	add	rsi, rax         ; /* from += wsize - nbytes */
+
+	mov	eax, r14d        ; /* eax = len */
+	cmp	r14d, ecx
+	jbe	L_do_copy           ; /* if (nbytes >= len) */
+
+	sub	eax, ecx         ; /* eax -= nbytes */
+	rep     movsb
+	mov	rsi, rdi
+	sub	rsi, r15         ; /* from = &out[ -dist ] */
+	jmp	L_do_copy
+
+ALIGN 4
+L_wrap_around_window:
+	mov	eax, [rsp+96]     ; /* eax = write */
+	cmp	ecx, eax
+	jbe	L_contiguous_in_window ; /* if (write >= nbytes) */
+
+	mov	esi, [rsp+92]     ; /* from  = wsize */
+	add	rsi, [rsp+56]     ; /* from += window */
+	add	rsi, rax         ; /* from += write */
+	sub	rsi, rcx         ; /* from -= nbytes */
+	sub	ecx, eax         ; /* nbytes -= write */
+
+	mov	eax, r14d        ; /* eax = len */
+	cmp	eax, ecx
+	jbe	L_do_copy           ; /* if (nbytes >= len) */
+
+	sub	eax, ecx         ; /* len -= nbytes */
+	rep     movsb
+	mov	rsi, [rsp+56]     ; /* from = window */
+	mov	ecx, [rsp+96]     ; /* nbytes = write */
+	cmp	eax, ecx
+	jbe	L_do_copy           ; /* if (nbytes >= len) */
+
+	sub	eax, ecx         ; /* len -= nbytes */
+	rep     movsb
+	mov	rsi, rdi
+	sub	rsi, r15         ; /* from = out - dist */
+	jmp	L_do_copy
+
+ALIGN 4
+L_contiguous_in_window:
+	mov	rsi, [rsp+56]     ; /* rsi = window */
+	add	rsi, rax
+	sub	rsi, rcx         ; /* from += write - nbytes */
+
+	mov	eax, r14d        ; /* eax = len */
+	cmp	eax, ecx
+	jbe	L_do_copy           ; /* if (nbytes >= len) */
+
+	sub	eax, ecx         ; /* len -= nbytes */
+	rep     movsb
+	mov	rsi, rdi
+	sub	rsi, r15         ; /* from = out - dist */
+	jmp	L_do_copy           ; /* if (nbytes >= len) */
+
+ALIGN 4
+L_do_copy:
+	mov	ecx, eax         ; /* ecx = len */
+	rep     movsb
+
+	mov	rsi, r8          ; /* move in back to %esi, toss from */
+	jmp	L_while_test
+
+L_test_for_end_of_block:
+	test	al, 32
+	jz	L_invalid_literal_length_code
+	mov	dword ptr [rsp+116], 1
+	jmp	L_break_loop_with_status
+
+L_invalid_literal_length_code:
+	mov	dword ptr [rsp+116], 2
+	jmp	L_break_loop_with_status
+
+L_invalid_distance_code:
+	mov	dword ptr [rsp+116], 3
+	jmp	L_break_loop_with_status
+
+L_invalid_distance_too_far:
+	mov	dword ptr [rsp+116], 4
+	jmp	L_break_loop_with_status
+
+L_break_loop:
+	mov	dword ptr [rsp+116], 0
+
+L_break_loop_with_status:
+; /* put in, out, bits, and hold back into ar and pop esp */
+	mov	[rsp+16], rsi     ; /* in */
+	mov	[rsp+32], rdi     ; /* out */
+	mov	[rsp+88], ebx     ; /* bits */
+	mov	[rsp+80], rdx     ; /* hold */
+
+	mov	rax, [rsp]       ; /* restore rbp and rsp */
+	mov	rbp, [rsp+8]
+	mov	rsp, rax
+
+
+
+	mov rsi,[rsp-8]
+	mov rdi,[rsp-16]
+	mov r12,[rsp-24]
+	mov r13,[rsp-32]
+	mov r14,[rsp-40]
+	mov r15,[rsp-48]
+	mov rbx,[rsp-56]
+
+    ret 0
+;          :
+;          : "m" (ar)
+;          : "memory", "%rax", "%rbx", "%rcx", "%rdx", "%rsi", "%rdi",
+;            "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
+;    );
+
+inffas8664fnc 	ENDP
+;_TEXT	ENDS
+END
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/masmx64/readme.txt b/Engine/lib/assimp/contrib/zlib/contrib/masmx64/readme.txt
new file mode 100644
index 000000000..652571c7a
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/masmx64/readme.txt
@@ -0,0 +1,31 @@
+Summary
+-------
+This directory contains ASM implementations of the functions
+longest_match() and inflate_fast(), for 64 bits x86 (both AMD64 and Intel EM64t),
+for use with Microsoft Macro Assembler (x64) for AMD64 and Microsoft C++ 64 bits.
+
+gvmat64.asm is written by Gilles Vollant (2005), by using Brian Raiter 686/32 bits
+   assembly optimized version from Jean-loup Gailly original longest_match function
+
+inffasx64.asm and inffas8664.c were written by Chris Anderson, by optimizing
+   original function from Mark Adler
+
+Use instructions
+----------------
+Assemble the .asm files using MASM and put the object files into the zlib source
+directory.  You can also get object files here:
+
+     http://www.winimage.com/zLibDll/zlib124_masm_obj.zip
+
+define ASMV and ASMINF in your project. Include inffas8664.c in your source tree,
+and inffasx64.obj and gvmat64.obj as object to link.
+
+
+Build instructions
+------------------
+run bld_64.bat with Microsoft Macro Assembler (x64) for AMD64 (ml64.exe)
+
+ml64.exe is given with Visual Studio 2005, Windows 2003 server DDK
+
+You can get Windows 2003 server DDK with ml64 and cl for AMD64 from
+  http://www.microsoft.com/whdc/devtools/ddk/default.mspx for low price)
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/masmx86/bld_ml32.bat b/Engine/lib/assimp/contrib/zlib/contrib/masmx86/bld_ml32.bat
new file mode 100644
index 000000000..fcf5755e4
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/masmx86/bld_ml32.bat
@@ -0,0 +1,2 @@
+ml /coff /Zi /c /Flmatch686.lst match686.asm
+ml /coff /Zi /c /Flinffas32.lst inffas32.asm
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/masmx86/inffas32.asm b/Engine/lib/assimp/contrib/zlib/contrib/masmx86/inffas32.asm
new file mode 100644
index 000000000..cb37a81e4
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/masmx86/inffas32.asm
@@ -0,0 +1,1080 @@
+;/* inffas32.asm is a hand tuned assembler version of inffast.c -- fast decoding
+; *
+; * inffas32.asm is derivated from inffas86.c, with translation of assembly code
+; *
+; * Copyright (C) 1995-2003 Mark Adler
+; * For conditions of distribution and use, see copyright notice in zlib.h
+; *
+; * Copyright (C) 2003 Chris Anderson <christop@charm.net>
+; * Please use the copyright conditions above.
+; *
+; * Mar-13-2003 -- Most of this is derived from inffast.S which is derived from
+; * the gcc -S output of zlib-1.2.0/inffast.c.  Zlib-1.2.0 is in beta release at
+; * the moment.  I have successfully compiled and tested this code with gcc2.96,
+; * gcc3.2, icc5.0, msvc6.0.  It is very close to the speed of inffast.S
+; * compiled with gcc -DNO_MMX, but inffast.S is still faster on the P3 with MMX
+; * enabled.  I will attempt to merge the MMX code into this version.  Newer
+; * versions of this and inffast.S can be found at
+; * http://www.eetbeetee.com/zlib/ and http://www.charm.net/~christop/zlib/
+; *
+; * 2005 : modification by Gilles Vollant
+; */
+; For Visual C++ 4.x and higher and ML 6.x and higher
+;   ml.exe is in directory \MASM611C of Win95 DDK
+;   ml.exe is also distributed in http://www.masm32.com/masmdl.htm
+;    and in VC++2003 toolkit at http://msdn.microsoft.com/visualc/vctoolkit2003/
+;
+;
+;   compile with command line option
+;   ml  /coff /Zi /c /Flinffas32.lst inffas32.asm
+
+;   if you define NO_GZIP (see inflate.h), compile with
+;   ml  /coff /Zi /c /Flinffas32.lst /DNO_GUNZIP inffas32.asm
+
+
+; zlib122sup is 0 fort zlib 1.2.2.1 and lower
+; zlib122sup is 8 fort zlib 1.2.2.2 and more (with addition of dmax and head
+;        in inflate_state in inflate.h)
+zlib1222sup      equ    8
+
+
+IFDEF GUNZIP
+  INFLATE_MODE_TYPE    equ 11
+  INFLATE_MODE_BAD     equ 26
+ELSE
+  IFNDEF NO_GUNZIP
+    INFLATE_MODE_TYPE    equ 11
+    INFLATE_MODE_BAD     equ 26
+  ELSE
+    INFLATE_MODE_TYPE    equ 3
+    INFLATE_MODE_BAD     equ 17
+  ENDIF
+ENDIF
+
+
+; 75 "inffast.S"
+;FILE "inffast.S"
+
+;;;GLOBAL _inflate_fast
+
+;;;SECTION .text
+
+
+
+	.586p
+	.mmx
+
+	name	inflate_fast_x86
+	.MODEL	FLAT
+
+_DATA			segment
+inflate_fast_use_mmx:
+	dd	1
+
+
+_TEXT			segment
+
+
+
+ALIGN 4
+	db	'Fast decoding Code from Chris Anderson'
+	db	0
+
+ALIGN 4
+invalid_literal_length_code_msg:
+	db	'invalid literal/length code'
+	db	0
+
+ALIGN 4
+invalid_distance_code_msg:
+	db	'invalid distance code'
+	db	0
+
+ALIGN 4
+invalid_distance_too_far_msg:
+	db	'invalid distance too far back'
+	db	0
+
+
+ALIGN 4
+inflate_fast_mask:
+dd	0
+dd	1
+dd	3
+dd	7
+dd	15
+dd	31
+dd	63
+dd	127
+dd	255
+dd	511
+dd	1023
+dd	2047
+dd	4095
+dd	8191
+dd	16383
+dd	32767
+dd	65535
+dd	131071
+dd	262143
+dd	524287
+dd	1048575
+dd	2097151
+dd	4194303
+dd	8388607
+dd	16777215
+dd	33554431
+dd	67108863
+dd	134217727
+dd	268435455
+dd	536870911
+dd	1073741823
+dd	2147483647
+dd	4294967295
+
+
+mode_state	 equ	0	;/* state->mode	*/
+wsize_state	 equ	(32+zlib1222sup)	;/* state->wsize */
+write_state	 equ	(36+4+zlib1222sup)	;/* state->write */
+window_state	 equ	(40+4+zlib1222sup)	;/* state->window */
+hold_state	 equ	(44+4+zlib1222sup)	;/* state->hold	*/
+bits_state	 equ	(48+4+zlib1222sup)	;/* state->bits	*/
+lencode_state	 equ	(64+4+zlib1222sup)	;/* state->lencode */
+distcode_state	 equ	(68+4+zlib1222sup)	;/* state->distcode */
+lenbits_state	 equ	(72+4+zlib1222sup)	;/* state->lenbits */
+distbits_state	 equ	(76+4+zlib1222sup)	;/* state->distbits */
+
+
+;;SECTION .text
+; 205 "inffast.S"
+;GLOBAL	inflate_fast_use_mmx
+
+;SECTION .data
+
+
+; GLOBAL inflate_fast_use_mmx:object
+;.size inflate_fast_use_mmx, 4
+; 226 "inffast.S"
+;SECTION .text
+
+ALIGN 4
+_inflate_fast proc near
+.FPO (16, 4, 0, 0, 1, 0)
+	push  edi
+	push  esi
+	push  ebp
+	push  ebx
+	pushfd
+	sub  esp,64
+	cld
+
+
+
+
+	mov  esi, [esp+88]
+	mov  edi, [esi+28]
+
+
+
+
+
+
+
+	mov  edx, [esi+4]
+	mov  eax, [esi+0]
+
+	add  edx,eax
+	sub  edx,11
+
+	mov  [esp+44],eax
+	mov  [esp+20],edx
+
+	mov  ebp, [esp+92]
+	mov  ecx, [esi+16]
+	mov  ebx, [esi+12]
+
+	sub  ebp,ecx
+	neg  ebp
+	add  ebp,ebx
+
+	sub  ecx,257
+	add  ecx,ebx
+
+	mov  [esp+60],ebx
+	mov  [esp+40],ebp
+	mov  [esp+16],ecx
+; 285 "inffast.S"
+	mov  eax, [edi+lencode_state]
+	mov  ecx, [edi+distcode_state]
+
+	mov  [esp+8],eax
+	mov  [esp+12],ecx
+
+	mov  eax,1
+	mov  ecx, [edi+lenbits_state]
+	shl  eax,cl
+	dec  eax
+	mov  [esp+0],eax
+
+	mov  eax,1
+	mov  ecx, [edi+distbits_state]
+	shl  eax,cl
+	dec  eax
+	mov  [esp+4],eax
+
+	mov  eax, [edi+wsize_state]
+	mov  ecx, [edi+write_state]
+	mov  edx, [edi+window_state]
+
+	mov  [esp+52],eax
+	mov  [esp+48],ecx
+	mov  [esp+56],edx
+
+	mov  ebp, [edi+hold_state]
+	mov  ebx, [edi+bits_state]
+; 321 "inffast.S"
+	mov  esi, [esp+44]
+	mov  ecx, [esp+20]
+	cmp  ecx,esi
+	ja   L_align_long
+
+	add  ecx,11
+	sub  ecx,esi
+	mov  eax,12
+	sub  eax,ecx
+	lea  edi, [esp+28]
+	rep movsb
+	mov  ecx,eax
+	xor  eax,eax
+	rep stosb
+	lea  esi, [esp+28]
+	mov  [esp+20],esi
+	jmp  L_is_aligned
+
+
+L_align_long:
+	test  esi,3
+	jz   L_is_aligned
+	xor  eax,eax
+	mov  al, [esi]
+	inc  esi
+	mov  ecx,ebx
+	add  ebx,8
+	shl  eax,cl
+	or  ebp,eax
+	jmp L_align_long
+
+L_is_aligned:
+	mov  edi, [esp+60]
+; 366 "inffast.S"
+L_check_mmx:
+	cmp  dword ptr [inflate_fast_use_mmx],2
+	je   L_init_mmx
+	ja   L_do_loop
+
+	push  eax
+	push  ebx
+	push  ecx
+	push  edx
+	pushfd
+	mov  eax, [esp]
+	xor  dword ptr [esp],0200000h
+
+
+
+
+	popfd
+	pushfd
+	pop  edx
+	xor  edx,eax
+	jz   L_dont_use_mmx
+	xor  eax,eax
+	cpuid
+	cmp  ebx,0756e6547h
+	jne  L_dont_use_mmx
+	cmp  ecx,06c65746eh
+	jne  L_dont_use_mmx
+	cmp  edx,049656e69h
+	jne  L_dont_use_mmx
+	mov  eax,1
+	cpuid
+	shr  eax,8
+	and  eax,15
+	cmp  eax,6
+	jne  L_dont_use_mmx
+	test  edx,0800000h
+	jnz  L_use_mmx
+	jmp  L_dont_use_mmx
+L_use_mmx:
+	mov  dword ptr [inflate_fast_use_mmx],2
+	jmp  L_check_mmx_pop
+L_dont_use_mmx:
+	mov  dword ptr [inflate_fast_use_mmx],3
+L_check_mmx_pop:
+	pop  edx
+	pop  ecx
+	pop  ebx
+	pop  eax
+	jmp  L_check_mmx
+; 426 "inffast.S"
+ALIGN 4
+L_do_loop:
+; 437 "inffast.S"
+	cmp  bl,15
+	ja   L_get_length_code
+
+	xor  eax,eax
+	lodsw
+	mov  cl,bl
+	add  bl,16
+	shl  eax,cl
+	or  ebp,eax
+
+L_get_length_code:
+	mov  edx, [esp+0]
+	mov  ecx, [esp+8]
+	and  edx,ebp
+	mov  eax, [ecx+edx*4]
+
+L_dolen:
+
+
+
+
+
+
+	mov  cl,ah
+	sub  bl,ah
+	shr  ebp,cl
+
+
+
+
+
+
+	test  al,al
+	jnz   L_test_for_length_base
+
+	shr  eax,16
+	stosb
+
+L_while_test:
+
+
+	cmp  [esp+16],edi
+	jbe  L_break_loop
+
+	cmp  [esp+20],esi
+	ja   L_do_loop
+	jmp  L_break_loop
+
+L_test_for_length_base:
+; 502 "inffast.S"
+	mov  edx,eax
+	shr  edx,16
+	mov  cl,al
+
+	test  al,16
+	jz   L_test_for_second_level_length
+	and  cl,15
+	jz   L_save_len
+	cmp  bl,cl
+	jae  L_add_bits_to_len
+
+	mov  ch,cl
+	xor  eax,eax
+	lodsw
+	mov  cl,bl
+	add  bl,16
+	shl  eax,cl
+	or  ebp,eax
+	mov  cl,ch
+
+L_add_bits_to_len:
+	mov  eax,1
+	shl  eax,cl
+	dec  eax
+	sub  bl,cl
+	and  eax,ebp
+	shr  ebp,cl
+	add  edx,eax
+
+L_save_len:
+	mov  [esp+24],edx
+
+
+L_decode_distance:
+; 549 "inffast.S"
+	cmp  bl,15
+	ja   L_get_distance_code
+
+	xor  eax,eax
+	lodsw
+	mov  cl,bl
+	add  bl,16
+	shl  eax,cl
+	or  ebp,eax
+
+L_get_distance_code:
+	mov  edx, [esp+4]
+	mov  ecx, [esp+12]
+	and  edx,ebp
+	mov  eax, [ecx+edx*4]
+
+
+L_dodist:
+	mov  edx,eax
+	shr  edx,16
+	mov  cl,ah
+	sub  bl,ah
+	shr  ebp,cl
+; 584 "inffast.S"
+	mov  cl,al
+
+	test  al,16
+	jz  L_test_for_second_level_dist
+	and  cl,15
+	jz  L_check_dist_one
+	cmp  bl,cl
+	jae  L_add_bits_to_dist
+
+	mov  ch,cl
+	xor  eax,eax
+	lodsw
+	mov  cl,bl
+	add  bl,16
+	shl  eax,cl
+	or  ebp,eax
+	mov  cl,ch
+
+L_add_bits_to_dist:
+	mov  eax,1
+	shl  eax,cl
+	dec  eax
+	sub  bl,cl
+	and  eax,ebp
+	shr  ebp,cl
+	add  edx,eax
+	jmp  L_check_window
+
+L_check_window:
+; 625 "inffast.S"
+	mov  [esp+44],esi
+	mov  eax,edi
+	sub  eax, [esp+40]
+
+	cmp  eax,edx
+	jb   L_clip_window
+
+	mov  ecx, [esp+24]
+	mov  esi,edi
+	sub  esi,edx
+
+	sub  ecx,3
+	mov  al, [esi]
+	mov  [edi],al
+	mov  al, [esi+1]
+	mov  dl, [esi+2]
+	add  esi,3
+	mov  [edi+1],al
+	mov  [edi+2],dl
+	add  edi,3
+	rep movsb
+
+	mov  esi, [esp+44]
+	jmp  L_while_test
+
+ALIGN 4
+L_check_dist_one:
+	cmp  edx,1
+	jne  L_check_window
+	cmp  [esp+40],edi
+	je  L_check_window
+
+	dec  edi
+	mov  ecx, [esp+24]
+	mov  al, [edi]
+	sub  ecx,3
+
+	mov  [edi+1],al
+	mov  [edi+2],al
+	mov  [edi+3],al
+	add  edi,4
+	rep stosb
+
+	jmp  L_while_test
+
+ALIGN 4
+L_test_for_second_level_length:
+
+
+
+
+	test  al,64
+	jnz   L_test_for_end_of_block
+
+	mov  eax,1
+	shl  eax,cl
+	dec  eax
+	and  eax,ebp
+	add  eax,edx
+	mov  edx, [esp+8]
+	mov  eax, [edx+eax*4]
+	jmp  L_dolen
+
+ALIGN 4
+L_test_for_second_level_dist:
+
+
+
+
+	test  al,64
+	jnz   L_invalid_distance_code
+
+	mov  eax,1
+	shl  eax,cl
+	dec  eax
+	and  eax,ebp
+	add  eax,edx
+	mov  edx, [esp+12]
+	mov  eax, [edx+eax*4]
+	jmp  L_dodist
+
+ALIGN 4
+L_clip_window:
+; 721 "inffast.S"
+	mov  ecx,eax
+	mov  eax, [esp+52]
+	neg  ecx
+	mov  esi, [esp+56]
+
+	cmp  eax,edx
+	jb   L_invalid_distance_too_far
+
+	add  ecx,edx
+	cmp  dword ptr [esp+48],0
+	jne  L_wrap_around_window
+
+	sub  eax,ecx
+	add  esi,eax
+; 749 "inffast.S"
+	mov  eax, [esp+24]
+	cmp  eax,ecx
+	jbe  L_do_copy1
+
+	sub  eax,ecx
+	rep movsb
+	mov  esi,edi
+	sub  esi,edx
+	jmp  L_do_copy1
+
+	cmp  eax,ecx
+	jbe  L_do_copy1
+
+	sub  eax,ecx
+	rep movsb
+	mov  esi,edi
+	sub  esi,edx
+	jmp  L_do_copy1
+
+L_wrap_around_window:
+; 793 "inffast.S"
+	mov  eax, [esp+48]
+	cmp  ecx,eax
+	jbe  L_contiguous_in_window
+
+	add  esi, [esp+52]
+	add  esi,eax
+	sub  esi,ecx
+	sub  ecx,eax
+
+
+	mov  eax, [esp+24]
+	cmp  eax,ecx
+	jbe  L_do_copy1
+
+	sub  eax,ecx
+	rep movsb
+	mov  esi, [esp+56]
+	mov  ecx, [esp+48]
+	cmp  eax,ecx
+	jbe  L_do_copy1
+
+	sub  eax,ecx
+	rep movsb
+	mov  esi,edi
+	sub  esi,edx
+	jmp  L_do_copy1
+
+L_contiguous_in_window:
+; 836 "inffast.S"
+	add  esi,eax
+	sub  esi,ecx
+
+
+	mov  eax, [esp+24]
+	cmp  eax,ecx
+	jbe  L_do_copy1
+
+	sub  eax,ecx
+	rep movsb
+	mov  esi,edi
+	sub  esi,edx
+
+L_do_copy1:
+; 862 "inffast.S"
+	mov  ecx,eax
+	rep movsb
+
+	mov  esi, [esp+44]
+	jmp  L_while_test
+; 878 "inffast.S"
+ALIGN 4
+L_init_mmx:
+	emms
+
+
+
+
+
+	movd mm0,ebp
+	mov  ebp,ebx
+; 896 "inffast.S"
+	movd mm4,dword ptr [esp+0]
+	movq mm3,mm4
+	movd mm5,dword ptr [esp+4]
+	movq mm2,mm5
+	pxor mm1,mm1
+	mov  ebx, [esp+8]
+	jmp  L_do_loop_mmx
+
+ALIGN 4
+L_do_loop_mmx:
+	psrlq mm0,mm1
+
+	cmp  ebp,32
+	ja  L_get_length_code_mmx
+
+	movd mm6,ebp
+	movd mm7,dword ptr [esi]
+	add  esi,4
+	psllq mm7,mm6
+	add  ebp,32
+	por mm0,mm7
+
+L_get_length_code_mmx:
+	pand mm4,mm0
+	movd eax,mm4
+	movq mm4,mm3
+	mov  eax, [ebx+eax*4]
+
+L_dolen_mmx:
+	movzx  ecx,ah
+	movd mm1,ecx
+	sub  ebp,ecx
+
+	test  al,al
+	jnz L_test_for_length_base_mmx
+
+	shr  eax,16
+	stosb
+
+L_while_test_mmx:
+
+
+	cmp  [esp+16],edi
+	jbe L_break_loop
+
+	cmp  [esp+20],esi
+	ja L_do_loop_mmx
+	jmp L_break_loop
+
+L_test_for_length_base_mmx:
+
+	mov  edx,eax
+	shr  edx,16
+
+	test  al,16
+	jz  L_test_for_second_level_length_mmx
+	and  eax,15
+	jz L_decode_distance_mmx
+
+	psrlq mm0,mm1
+	movd mm1,eax
+	movd ecx,mm0
+	sub  ebp,eax
+	and  ecx, [inflate_fast_mask+eax*4]
+	add  edx,ecx
+
+L_decode_distance_mmx:
+	psrlq mm0,mm1
+
+	cmp  ebp,32
+	ja L_get_dist_code_mmx
+
+	movd mm6,ebp
+	movd mm7,dword ptr [esi]
+	add  esi,4
+	psllq mm7,mm6
+	add  ebp,32
+	por mm0,mm7
+
+L_get_dist_code_mmx:
+	mov  ebx, [esp+12]
+	pand mm5,mm0
+	movd eax,mm5
+	movq mm5,mm2
+	mov  eax, [ebx+eax*4]
+
+L_dodist_mmx:
+
+	movzx  ecx,ah
+	mov  ebx,eax
+	shr  ebx,16
+	sub  ebp,ecx
+	movd mm1,ecx
+
+	test  al,16
+	jz L_test_for_second_level_dist_mmx
+	and  eax,15
+	jz L_check_dist_one_mmx
+
+L_add_bits_to_dist_mmx:
+	psrlq mm0,mm1
+	movd mm1,eax
+	movd ecx,mm0
+	sub  ebp,eax
+	and  ecx, [inflate_fast_mask+eax*4]
+	add  ebx,ecx
+
+L_check_window_mmx:
+	mov  [esp+44],esi
+	mov  eax,edi
+	sub  eax, [esp+40]
+
+	cmp  eax,ebx
+	jb L_clip_window_mmx
+
+	mov  ecx,edx
+	mov  esi,edi
+	sub  esi,ebx
+
+	sub  ecx,3
+	mov  al, [esi]
+	mov  [edi],al
+	mov  al, [esi+1]
+	mov  dl, [esi+2]
+	add  esi,3
+	mov  [edi+1],al
+	mov  [edi+2],dl
+	add  edi,3
+	rep movsb
+
+	mov  esi, [esp+44]
+	mov  ebx, [esp+8]
+	jmp  L_while_test_mmx
+
+ALIGN 4
+L_check_dist_one_mmx:
+	cmp  ebx,1
+	jne  L_check_window_mmx
+	cmp  [esp+40],edi
+	je   L_check_window_mmx
+
+	dec  edi
+	mov  ecx,edx
+	mov  al, [edi]
+	sub  ecx,3
+
+	mov  [edi+1],al
+	mov  [edi+2],al
+	mov  [edi+3],al
+	add  edi,4
+	rep stosb
+
+	mov  ebx, [esp+8]
+	jmp  L_while_test_mmx
+
+ALIGN 4
+L_test_for_second_level_length_mmx:
+	test  al,64
+	jnz L_test_for_end_of_block
+
+	and  eax,15
+	psrlq mm0,mm1
+	movd ecx,mm0
+	and  ecx, [inflate_fast_mask+eax*4]
+	add  ecx,edx
+	mov  eax, [ebx+ecx*4]
+	jmp L_dolen_mmx
+
+ALIGN 4
+L_test_for_second_level_dist_mmx:
+	test  al,64
+	jnz L_invalid_distance_code
+
+	and  eax,15
+	psrlq mm0,mm1
+	movd ecx,mm0
+	and  ecx, [inflate_fast_mask+eax*4]
+	mov  eax, [esp+12]
+	add  ecx,ebx
+	mov  eax, [eax+ecx*4]
+	jmp  L_dodist_mmx
+
+ALIGN 4
+L_clip_window_mmx:
+
+	mov  ecx,eax
+	mov  eax, [esp+52]
+	neg  ecx
+	mov  esi, [esp+56]
+
+	cmp  eax,ebx
+	jb  L_invalid_distance_too_far
+
+	add  ecx,ebx
+	cmp  dword ptr [esp+48],0
+	jne  L_wrap_around_window_mmx
+
+	sub  eax,ecx
+	add  esi,eax
+
+	cmp  edx,ecx
+	jbe  L_do_copy1_mmx
+
+	sub  edx,ecx
+	rep movsb
+	mov  esi,edi
+	sub  esi,ebx
+	jmp  L_do_copy1_mmx
+
+	cmp  edx,ecx
+	jbe  L_do_copy1_mmx
+
+	sub  edx,ecx
+	rep movsb
+	mov  esi,edi
+	sub  esi,ebx
+	jmp  L_do_copy1_mmx
+
+L_wrap_around_window_mmx:
+
+	mov  eax, [esp+48]
+	cmp  ecx,eax
+	jbe  L_contiguous_in_window_mmx
+
+	add  esi, [esp+52]
+	add  esi,eax
+	sub  esi,ecx
+	sub  ecx,eax
+
+
+	cmp  edx,ecx
+	jbe  L_do_copy1_mmx
+
+	sub  edx,ecx
+	rep movsb
+	mov  esi, [esp+56]
+	mov  ecx, [esp+48]
+	cmp  edx,ecx
+	jbe  L_do_copy1_mmx
+
+	sub  edx,ecx
+	rep movsb
+	mov  esi,edi
+	sub  esi,ebx
+	jmp  L_do_copy1_mmx
+
+L_contiguous_in_window_mmx:
+
+	add  esi,eax
+	sub  esi,ecx
+
+
+	cmp  edx,ecx
+	jbe  L_do_copy1_mmx
+
+	sub  edx,ecx
+	rep movsb
+	mov  esi,edi
+	sub  esi,ebx
+
+L_do_copy1_mmx:
+
+
+	mov  ecx,edx
+	rep movsb
+
+	mov  esi, [esp+44]
+	mov  ebx, [esp+8]
+	jmp  L_while_test_mmx
+; 1174 "inffast.S"
+L_invalid_distance_code:
+
+
+
+
+
+	mov  ecx, invalid_distance_code_msg
+	mov  edx,INFLATE_MODE_BAD
+	jmp  L_update_stream_state
+
+L_test_for_end_of_block:
+
+
+
+
+
+	test  al,32
+	jz  L_invalid_literal_length_code
+
+	mov  ecx,0
+	mov  edx,INFLATE_MODE_TYPE
+	jmp  L_update_stream_state
+
+L_invalid_literal_length_code:
+
+
+
+
+
+	mov  ecx, invalid_literal_length_code_msg
+	mov  edx,INFLATE_MODE_BAD
+	jmp  L_update_stream_state
+
+L_invalid_distance_too_far:
+
+
+
+	mov  esi, [esp+44]
+	mov  ecx, invalid_distance_too_far_msg
+	mov  edx,INFLATE_MODE_BAD
+	jmp  L_update_stream_state
+
+L_update_stream_state:
+
+	mov  eax, [esp+88]
+	test  ecx,ecx
+	jz  L_skip_msg
+	mov  [eax+24],ecx
+L_skip_msg:
+	mov  eax, [eax+28]
+	mov  [eax+mode_state],edx
+	jmp  L_break_loop
+
+ALIGN 4
+L_break_loop:
+; 1243 "inffast.S"
+	cmp  dword ptr [inflate_fast_use_mmx],2
+	jne  L_update_next_in
+
+
+
+	mov  ebx,ebp
+
+L_update_next_in:
+; 1266 "inffast.S"
+	mov  eax, [esp+88]
+	mov  ecx,ebx
+	mov  edx, [eax+28]
+	shr  ecx,3
+	sub  esi,ecx
+	shl  ecx,3
+	sub  ebx,ecx
+	mov  [eax+12],edi
+	mov  [edx+bits_state],ebx
+	mov  ecx,ebx
+
+	lea  ebx, [esp+28]
+	cmp  [esp+20],ebx
+	jne  L_buf_not_used
+
+	sub  esi,ebx
+	mov  ebx, [eax+0]
+	mov  [esp+20],ebx
+	add  esi,ebx
+	mov  ebx, [eax+4]
+	sub  ebx,11
+	add  [esp+20],ebx
+
+L_buf_not_used:
+	mov  [eax+0],esi
+
+	mov  ebx,1
+	shl  ebx,cl
+	dec  ebx
+
+
+
+
+
+	cmp  dword ptr [inflate_fast_use_mmx],2
+	jne  L_update_hold
+
+
+
+	psrlq mm0,mm1
+	movd ebp,mm0
+
+	emms
+
+L_update_hold:
+
+
+
+	and  ebp,ebx
+	mov  [edx+hold_state],ebp
+
+
+
+
+	mov  ebx, [esp+20]
+	cmp  ebx,esi
+	jbe  L_last_is_smaller
+
+	sub  ebx,esi
+	add  ebx,11
+	mov  [eax+4],ebx
+	jmp  L_fixup_out
+L_last_is_smaller:
+	sub  esi,ebx
+	neg  esi
+	add  esi,11
+	mov  [eax+4],esi
+
+
+
+
+L_fixup_out:
+
+	mov  ebx, [esp+16]
+	cmp  ebx,edi
+	jbe  L_end_is_smaller
+
+	sub  ebx,edi
+	add  ebx,257
+	mov  [eax+16],ebx
+	jmp  L_done
+L_end_is_smaller:
+	sub  edi,ebx
+	neg  edi
+	add  edi,257
+	mov  [eax+16],edi
+
+
+
+
+
+L_done:
+	add  esp,64
+	popfd
+	pop  ebx
+	pop  ebp
+	pop  esi
+	pop  edi
+	ret
+_inflate_fast endp
+
+_TEXT	ends
+end
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/masmx86/match686.asm b/Engine/lib/assimp/contrib/zlib/contrib/masmx86/match686.asm
new file mode 100644
index 000000000..69e0eed01
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/masmx86/match686.asm
@@ -0,0 +1,479 @@
+; match686.asm -- Asm portion of the optimized longest_match for 32 bits x86
+; Copyright (C) 1995-1996 Jean-loup Gailly, Brian Raiter and Gilles Vollant.
+; File written by Gilles Vollant, by converting match686.S from Brian Raiter
+; for MASM. This is as assembly version of longest_match
+;  from Jean-loup Gailly in deflate.c
+;
+;         http://www.zlib.net
+;         http://www.winimage.com/zLibDll
+;         http://www.muppetlabs.com/~breadbox/software/assembly.html
+;
+; For Visual C++ 4.x and higher and ML 6.x and higher
+;   ml.exe is distributed in
+;  http://www.microsoft.com/downloads/details.aspx?FamilyID=7a1c9da0-0510-44a2-b042-7ef370530c64
+;
+; this file contain two implementation of longest_match
+;
+;  this longest_match was written by Brian raiter (1998), optimized for Pentium Pro
+;   (and the faster known version of match_init on modern Core 2 Duo and AMD Phenom)
+;
+;  for using an assembly version of longest_match, you need define ASMV in project
+;
+;    compile the asm file running
+;           ml /coff /Zi /c /Flmatch686.lst match686.asm
+;    and do not include match686.obj in your project
+;
+; note: contrib of zLib 1.2.3 and earlier contained both a deprecated version for
+;  Pentium (prior Pentium Pro) and this version for Pentium Pro and modern processor
+;  with autoselect (with cpu detection code)
+;  if you want support the old pentium optimization, you can still use these version
+;
+; this file is not optimized for old pentium, but it compatible with all x86 32 bits
+; processor (starting 80386)
+;
+;
+; see below : zlib1222add must be adjuster if you use a zlib version < 1.2.2.2
+
+;uInt longest_match(s, cur_match)
+;    deflate_state *s;
+;    IPos cur_match;                             /* current match */
+
+    NbStack         equ     76
+    cur_match       equ     dword ptr[esp+NbStack-0]
+    str_s           equ     dword ptr[esp+NbStack-4]
+; 5 dword on top (ret,ebp,esi,edi,ebx)
+    adrret          equ     dword ptr[esp+NbStack-8]
+    pushebp         equ     dword ptr[esp+NbStack-12]
+    pushedi         equ     dword ptr[esp+NbStack-16]
+    pushesi         equ     dword ptr[esp+NbStack-20]
+    pushebx         equ     dword ptr[esp+NbStack-24]
+
+    chain_length    equ     dword ptr [esp+NbStack-28]
+    limit           equ     dword ptr [esp+NbStack-32]
+    best_len        equ     dword ptr [esp+NbStack-36]
+    window          equ     dword ptr [esp+NbStack-40]
+    prev            equ     dword ptr [esp+NbStack-44]
+    scan_start      equ      word ptr [esp+NbStack-48]
+    wmask           equ     dword ptr [esp+NbStack-52]
+    match_start_ptr equ     dword ptr [esp+NbStack-56]
+    nice_match      equ     dword ptr [esp+NbStack-60]
+    scan            equ     dword ptr [esp+NbStack-64]
+
+    windowlen       equ     dword ptr [esp+NbStack-68]
+    match_start     equ     dword ptr [esp+NbStack-72]
+    strend          equ     dword ptr [esp+NbStack-76]
+    NbStackAdd      equ     (NbStack-24)
+
+    .386p
+
+    name    gvmatch
+    .MODEL  FLAT
+
+
+
+;  all the +zlib1222add offsets are due to the addition of fields
+;  in zlib in the deflate_state structure since the asm code was first written
+;  (if you compile with zlib 1.0.4 or older, use "zlib1222add equ (-4)").
+;  (if you compile with zlib between 1.0.5 and 1.2.2.1, use "zlib1222add equ 0").
+;  if you compile with zlib 1.2.2.2 or later , use "zlib1222add equ 8").
+
+    zlib1222add         equ     8
+
+;  Note : these value are good with a 8 bytes boundary pack structure
+    dep_chain_length    equ     74h+zlib1222add
+    dep_window          equ     30h+zlib1222add
+    dep_strstart        equ     64h+zlib1222add
+    dep_prev_length     equ     70h+zlib1222add
+    dep_nice_match      equ     88h+zlib1222add
+    dep_w_size          equ     24h+zlib1222add
+    dep_prev            equ     38h+zlib1222add
+    dep_w_mask          equ     2ch+zlib1222add
+    dep_good_match      equ     84h+zlib1222add
+    dep_match_start     equ     68h+zlib1222add
+    dep_lookahead       equ     6ch+zlib1222add
+
+
+_TEXT                   segment
+
+IFDEF NOUNDERLINE
+            public  longest_match
+            public  match_init
+ELSE
+            public  _longest_match
+            public  _match_init
+ENDIF
+
+    MAX_MATCH           equ     258
+    MIN_MATCH           equ     3
+    MIN_LOOKAHEAD       equ     (MAX_MATCH+MIN_MATCH+1)
+
+
+
+MAX_MATCH       equ     258
+MIN_MATCH       equ     3
+MIN_LOOKAHEAD   equ     (MAX_MATCH + MIN_MATCH + 1)
+MAX_MATCH_8_     equ     ((MAX_MATCH + 7) AND 0FFF0h)
+
+
+;;; stack frame offsets
+
+chainlenwmask   equ  esp + 0    ; high word: current chain len
+                    ; low word: s->wmask
+window      equ  esp + 4    ; local copy of s->window
+windowbestlen   equ  esp + 8    ; s->window + bestlen
+scanstart   equ  esp + 16   ; first two bytes of string
+scanend     equ  esp + 12   ; last two bytes of string
+scanalign   equ  esp + 20   ; dword-misalignment of string
+nicematch   equ  esp + 24   ; a good enough match size
+bestlen     equ  esp + 28   ; size of best match so far
+scan        equ  esp + 32   ; ptr to string wanting match
+
+LocalVarsSize   equ 36
+;   saved ebx   byte esp + 36
+;   saved edi   byte esp + 40
+;   saved esi   byte esp + 44
+;   saved ebp   byte esp + 48
+;   return address  byte esp + 52
+deflatestate    equ  esp + 56   ; the function arguments
+curmatch    equ  esp + 60
+
+;;; Offsets for fields in the deflate_state structure. These numbers
+;;; are calculated from the definition of deflate_state, with the
+;;; assumption that the compiler will dword-align the fields. (Thus,
+;;; changing the definition of deflate_state could easily cause this
+;;; program to crash horribly, without so much as a warning at
+;;; compile time. Sigh.)
+
+dsWSize     equ 36+zlib1222add
+dsWMask     equ 44+zlib1222add
+dsWindow    equ 48+zlib1222add
+dsPrev      equ 56+zlib1222add
+dsMatchLen  equ 88+zlib1222add
+dsPrevMatch equ 92+zlib1222add
+dsStrStart  equ 100+zlib1222add
+dsMatchStart    equ 104+zlib1222add
+dsLookahead equ 108+zlib1222add
+dsPrevLen   equ 112+zlib1222add
+dsMaxChainLen   equ 116+zlib1222add
+dsGoodMatch equ 132+zlib1222add
+dsNiceMatch equ 136+zlib1222add
+
+
+;;; match686.asm -- Pentium-Pro-optimized version of longest_match()
+;;; Written for zlib 1.1.2
+;;; Copyright (C) 1998 Brian Raiter <breadbox@muppetlabs.com>
+;;; You can look at http://www.muppetlabs.com/~breadbox/software/assembly.html
+;;;
+;;
+;;  This software is provided 'as-is', without any express or implied
+;;  warranty.  In no event will the authors be held liable for any damages
+;;  arising from the use of this software.
+;;
+;;  Permission is granted to anyone to use this software for any purpose,
+;;  including commercial applications, and to alter it and redistribute it
+;;  freely, subject to the following restrictions:
+;;
+;;  1. The origin of this software must not be misrepresented; you must not
+;;     claim that you wrote the original software. If you use this software
+;;     in a product, an acknowledgment in the product documentation would be
+;;     appreciated but is not required.
+;;  2. Altered source versions must be plainly marked as such, and must not be
+;;     misrepresented as being the original software
+;;  3. This notice may not be removed or altered from any source distribution.
+;;
+
+;GLOBAL _longest_match, _match_init
+
+
+;SECTION    .text
+
+;;; uInt longest_match(deflate_state *deflatestate, IPos curmatch)
+
+;_longest_match:
+    IFDEF NOUNDERLINE
+    longest_match       proc near
+    ELSE
+    _longest_match      proc near
+    ENDIF
+.FPO (9, 4, 0, 0, 1, 0)
+
+;;; Save registers that the compiler may be using, and adjust esp to
+;;; make room for our stack frame.
+
+        push    ebp
+        push    edi
+        push    esi
+        push    ebx
+        sub esp, LocalVarsSize
+
+;;; Retrieve the function arguments. ecx will hold cur_match
+;;; throughout the entire function. edx will hold the pointer to the
+;;; deflate_state structure during the function's setup (before
+;;; entering the main loop.
+
+        mov edx, [deflatestate]
+        mov ecx, [curmatch]
+
+;;; uInt wmask = s->w_mask;
+;;; unsigned chain_length = s->max_chain_length;
+;;; if (s->prev_length >= s->good_match) {
+;;;     chain_length >>= 2;
+;;; }
+
+        mov eax, [edx + dsPrevLen]
+        mov ebx, [edx + dsGoodMatch]
+        cmp eax, ebx
+        mov eax, [edx + dsWMask]
+        mov ebx, [edx + dsMaxChainLen]
+        jl  LastMatchGood
+        shr ebx, 2
+LastMatchGood:
+
+;;; chainlen is decremented once beforehand so that the function can
+;;; use the sign flag instead of the zero flag for the exit test.
+;;; It is then shifted into the high word, to make room for the wmask
+;;; value, which it will always accompany.
+
+        dec ebx
+        shl ebx, 16
+        or  ebx, eax
+        mov [chainlenwmask], ebx
+
+;;; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
+
+        mov eax, [edx + dsNiceMatch]
+        mov ebx, [edx + dsLookahead]
+        cmp ebx, eax
+        jl  LookaheadLess
+        mov ebx, eax
+LookaheadLess:  mov [nicematch], ebx
+
+;;; register Bytef *scan = s->window + s->strstart;
+
+        mov esi, [edx + dsWindow]
+        mov [window], esi
+        mov ebp, [edx + dsStrStart]
+        lea edi, [esi + ebp]
+        mov [scan], edi
+
+;;; Determine how many bytes the scan ptr is off from being
+;;; dword-aligned.
+
+        mov eax, edi
+        neg eax
+        and eax, 3
+        mov [scanalign], eax
+
+;;; IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
+;;;     s->strstart - (IPos)MAX_DIST(s) : NIL;
+
+        mov eax, [edx + dsWSize]
+        sub eax, MIN_LOOKAHEAD
+        sub ebp, eax
+        jg  LimitPositive
+        xor ebp, ebp
+LimitPositive:
+
+;;; int best_len = s->prev_length;
+
+        mov eax, [edx + dsPrevLen]
+        mov [bestlen], eax
+
+;;; Store the sum of s->window + best_len in esi locally, and in esi.
+
+        add esi, eax
+        mov [windowbestlen], esi
+
+;;; register ush scan_start = *(ushf*)scan;
+;;; register ush scan_end   = *(ushf*)(scan+best_len-1);
+;;; Posf *prev = s->prev;
+
+        movzx   ebx, word ptr [edi]
+        mov [scanstart], ebx
+        movzx   ebx, word ptr [edi + eax - 1]
+        mov [scanend], ebx
+        mov edi, [edx + dsPrev]
+
+;;; Jump into the main loop.
+
+        mov edx, [chainlenwmask]
+        jmp short LoopEntry
+
+align 4
+
+;;; do {
+;;;     match = s->window + cur_match;
+;;;     if (*(ushf*)(match+best_len-1) != scan_end ||
+;;;         *(ushf*)match != scan_start) continue;
+;;;     [...]
+;;; } while ((cur_match = prev[cur_match & wmask]) > limit
+;;;          && --chain_length != 0);
+;;;
+;;; Here is the inner loop of the function. The function will spend the
+;;; majority of its time in this loop, and majority of that time will
+;;; be spent in the first ten instructions.
+;;;
+;;; Within this loop:
+;;; ebx = scanend
+;;; ecx = curmatch
+;;; edx = chainlenwmask - i.e., ((chainlen << 16) | wmask)
+;;; esi = windowbestlen - i.e., (window + bestlen)
+;;; edi = prev
+;;; ebp = limit
+
+LookupLoop:
+        and ecx, edx
+        movzx   ecx, word ptr [edi + ecx*2]
+        cmp ecx, ebp
+        jbe LeaveNow
+        sub edx, 00010000h
+        js  LeaveNow
+LoopEntry:  movzx   eax, word ptr [esi + ecx - 1]
+        cmp eax, ebx
+        jnz LookupLoop
+        mov eax, [window]
+        movzx   eax, word ptr [eax + ecx]
+        cmp eax, [scanstart]
+        jnz LookupLoop
+
+;;; Store the current value of chainlen.
+
+        mov [chainlenwmask], edx
+
+;;; Point edi to the string under scrutiny, and esi to the string we
+;;; are hoping to match it up with. In actuality, esi and edi are
+;;; both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and edx is
+;;; initialized to -(MAX_MATCH_8 - scanalign).
+
+        mov esi, [window]
+        mov edi, [scan]
+        add esi, ecx
+        mov eax, [scanalign]
+        mov edx, 0fffffef8h; -(MAX_MATCH_8)
+        lea edi, [edi + eax + 0108h] ;MAX_MATCH_8]
+        lea esi, [esi + eax + 0108h] ;MAX_MATCH_8]
+
+;;; Test the strings for equality, 8 bytes at a time. At the end,
+;;; adjust edx so that it is offset to the exact byte that mismatched.
+;;;
+;;; We already know at this point that the first three bytes of the
+;;; strings match each other, and they can be safely passed over before
+;;; starting the compare loop. So what this code does is skip over 0-3
+;;; bytes, as much as necessary in order to dword-align the edi
+;;; pointer. (esi will still be misaligned three times out of four.)
+;;;
+;;; It should be confessed that this loop usually does not represent
+;;; much of the total running time. Replacing it with a more
+;;; straightforward "rep cmpsb" would not drastically degrade
+;;; performance.
+
+LoopCmps:
+        mov eax, [esi + edx]
+        xor eax, [edi + edx]
+        jnz LeaveLoopCmps
+        mov eax, [esi + edx + 4]
+        xor eax, [edi + edx + 4]
+        jnz LeaveLoopCmps4
+        add edx, 8
+        jnz LoopCmps
+        jmp short LenMaximum
+LeaveLoopCmps4: add edx, 4
+LeaveLoopCmps:  test    eax, 0000FFFFh
+        jnz LenLower
+        add edx,  2
+        shr eax, 16
+LenLower:   sub al, 1
+        adc edx, 0
+
+;;; Calculate the length of the match. If it is longer than MAX_MATCH,
+;;; then automatically accept it as the best possible match and leave.
+
+        lea eax, [edi + edx]
+        mov edi, [scan]
+        sub eax, edi
+        cmp eax, MAX_MATCH
+        jge LenMaximum
+
+;;; If the length of the match is not longer than the best match we
+;;; have so far, then forget it and return to the lookup loop.
+
+        mov edx, [deflatestate]
+        mov ebx, [bestlen]
+        cmp eax, ebx
+        jg  LongerMatch
+        mov esi, [windowbestlen]
+        mov edi, [edx + dsPrev]
+        mov ebx, [scanend]
+        mov edx, [chainlenwmask]
+        jmp LookupLoop
+
+;;;         s->match_start = cur_match;
+;;;         best_len = len;
+;;;         if (len >= nice_match) break;
+;;;         scan_end = *(ushf*)(scan+best_len-1);
+
+LongerMatch:    mov ebx, [nicematch]
+        mov [bestlen], eax
+        mov [edx + dsMatchStart], ecx
+        cmp eax, ebx
+        jge LeaveNow
+        mov esi, [window]
+        add esi, eax
+        mov [windowbestlen], esi
+        movzx   ebx, word ptr [edi + eax - 1]
+        mov edi, [edx + dsPrev]
+        mov [scanend], ebx
+        mov edx, [chainlenwmask]
+        jmp LookupLoop
+
+;;; Accept the current string, with the maximum possible length.
+
+LenMaximum: mov edx, [deflatestate]
+        mov dword ptr [bestlen], MAX_MATCH
+        mov [edx + dsMatchStart], ecx
+
+;;; if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
+;;; return s->lookahead;
+
+LeaveNow:
+        mov edx, [deflatestate]
+        mov ebx, [bestlen]
+        mov eax, [edx + dsLookahead]
+        cmp ebx, eax
+        jg  LookaheadRet
+        mov eax, ebx
+LookaheadRet:
+
+;;; Restore the stack and return from whence we came.
+
+        add esp, LocalVarsSize
+        pop ebx
+        pop esi
+        pop edi
+        pop ebp
+
+        ret
+; please don't remove this string !
+; Your can freely use match686 in any free or commercial app if you don't remove the string in the binary!
+    db     0dh,0ah,"asm686 with masm, optimised assembly code from Brian Raiter, written 1998",0dh,0ah
+
+
+    IFDEF NOUNDERLINE
+    longest_match       endp
+    ELSE
+    _longest_match      endp
+    ENDIF
+
+    IFDEF NOUNDERLINE
+    match_init      proc near
+                    ret
+    match_init      endp
+    ELSE
+    _match_init     proc near
+                    ret
+    _match_init     endp
+    ENDIF
+
+
+_TEXT   ends
+end
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/masmx86/readme.txt b/Engine/lib/assimp/contrib/zlib/contrib/masmx86/readme.txt
new file mode 100644
index 000000000..3f8888679
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/masmx86/readme.txt
@@ -0,0 +1,27 @@
+
+Summary
+-------
+This directory contains ASM implementations of the functions
+longest_match() and inflate_fast().
+
+
+Use instructions
+----------------
+Assemble using MASM, and copy the object files into the zlib source
+directory, then run the appropriate makefile, as suggested below.  You can
+donwload MASM from here:
+
+    http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=7a1c9da0-0510-44a2-b042-7ef370530c64
+
+You can also get objects files here:
+
+    http://www.winimage.com/zLibDll/zlib124_masm_obj.zip
+
+Build instructions
+------------------
+* With Microsoft C and MASM:
+nmake -f win32/Makefile.msc LOC="-DASMV -DASMINF" OBJA="match686.obj inffas32.obj"
+
+* With Borland C and TASM:
+make -f win32/Makefile.bor LOCAL_ZLIB="-DASMV -DASMINF" OBJA="match686.obj inffas32.obj" OBJPA="+match686c.obj+match686.obj+inffas32.obj"
+
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/minizip/Makefile.am b/Engine/lib/assimp/contrib/zlib/contrib/minizip/Makefile.am
new file mode 100644
index 000000000..d343011eb
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/minizip/Makefile.am
@@ -0,0 +1,45 @@
+lib_LTLIBRARIES = libminizip.la
+
+if COND_DEMOS
+bin_PROGRAMS = miniunzip minizip
+endif
+
+zlib_top_srcdir = $(top_srcdir)/../..
+zlib_top_builddir = $(top_builddir)/../..
+
+AM_CPPFLAGS = -I$(zlib_top_srcdir)
+AM_LDFLAGS = -L$(zlib_top_builddir)
+
+if WIN32
+iowin32_src = iowin32.c
+iowin32_h = iowin32.h
+endif
+
+libminizip_la_SOURCES = \
+	ioapi.c \
+	mztools.c \
+	unzip.c \
+	zip.c \
+	${iowin32_src}
+
+libminizip_la_LDFLAGS = $(AM_LDFLAGS) -version-info 1:0:0 -lz
+
+minizip_includedir = $(includedir)/minizip
+minizip_include_HEADERS = \
+	crypt.h \
+	ioapi.h \
+	mztools.h \
+	unzip.h \
+	zip.h \
+	${iowin32_h}
+
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = minizip.pc
+
+EXTRA_PROGRAMS = miniunzip minizip
+
+miniunzip_SOURCES = miniunz.c
+miniunzip_LDADD = libminizip.la
+
+minizip_SOURCES = minizip.c
+minizip_LDADD = libminizip.la -lz
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/minizip/MiniZip64_Changes.txt b/Engine/lib/assimp/contrib/zlib/contrib/minizip/MiniZip64_Changes.txt
new file mode 100644
index 000000000..13a1bd91a
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/minizip/MiniZip64_Changes.txt
@@ -0,0 +1,6 @@
+
+MiniZip 1.1 was derrived from MiniZip at version 1.01f
+
+Change in 1.0 (Okt 2009)
+ - **TODO - Add history**
+
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/minizip/MiniZip64_info.txt b/Engine/lib/assimp/contrib/zlib/contrib/minizip/MiniZip64_info.txt
new file mode 100644
index 000000000..57d715242
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/minizip/MiniZip64_info.txt
@@ -0,0 +1,74 @@
+MiniZip - Copyright (c) 1998-2010 - by Gilles Vollant - version 1.1 64 bits from Mathias Svensson
+
+Introduction
+---------------------
+MiniZip 1.1 is built from MiniZip 1.0 by Gilles Vollant ( http://www.winimage.com/zLibDll/minizip.html )
+
+When adding ZIP64 support into minizip it would result into risk of breaking compatibility with minizip 1.0.
+All possible work was done for compatibility.
+
+
+Background
+---------------------
+When adding ZIP64 support Mathias Svensson found that Even Rouault have added ZIP64 
+support for unzip.c into minizip for a open source project called gdal ( http://www.gdal.org/ )
+
+That was used as a starting point. And after that ZIP64 support was added to zip.c
+some refactoring and code cleanup was also done.
+
+
+Changed from MiniZip 1.0 to MiniZip 1.1
+---------------------------------------
+* Added ZIP64 support for unzip ( by Even Rouault )
+* Added ZIP64 support for zip ( by Mathias Svensson )
+* Reverted some changed that Even Rouault did.
+* Bunch of patches received from Gulles Vollant that he received for MiniZip from various users.
+* Added unzip patch for BZIP Compression method (patch create by Daniel Borca)
+* Added BZIP Compress method for zip
+* Did some refactoring and code cleanup
+
+
+Credits
+
+ Gilles Vollant    - Original MiniZip author
+ Even Rouault      - ZIP64 unzip Support
+ Daniel Borca      - BZip Compression method support in unzip
+ Mathias Svensson  - ZIP64 zip support
+ Mathias Svensson  - BZip Compression method support in zip
+
+ Resources
+
+ ZipLayout   http://result42.com/projects/ZipFileLayout
+             Command line tool for Windows that shows the layout and information of the headers in a zip archive.
+             Used when debugging and validating the creation of zip files using MiniZip64
+
+
+ ZIP App Note  http://www.pkware.com/documents/casestudies/APPNOTE.TXT
+               Zip File specification
+
+
+Notes.
+ * To be able to use BZip compression method in zip64.c or unzip64.c the BZIP2 lib is needed and HAVE_BZIP2 need to be defined.
+
+License
+----------------------------------------------------------
+   Condition of use and distribution are the same than zlib :
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+----------------------------------------------------------
+
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/minizip/configure.ac b/Engine/lib/assimp/contrib/zlib/contrib/minizip/configure.ac
new file mode 100644
index 000000000..5b1197097
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/minizip/configure.ac
@@ -0,0 +1,32 @@
+#                                               -*- Autoconf -*-
+# Process this file with autoconf to produce a configure script.
+
+AC_INIT([minizip], [1.2.11], [bugzilla.redhat.com])
+AC_CONFIG_SRCDIR([minizip.c])
+AM_INIT_AUTOMAKE([foreign])
+LT_INIT
+
+AC_MSG_CHECKING([whether to build example programs])
+AC_ARG_ENABLE([demos], AC_HELP_STRING([--enable-demos], [build example programs]))
+AM_CONDITIONAL([COND_DEMOS], [test "$enable_demos" = yes])
+if test "$enable_demos" = yes
+then
+	AC_MSG_RESULT([yes])
+else
+	AC_MSG_RESULT([no])
+fi
+
+case "${host}" in
+	*-mingw* | mingw*)
+		WIN32="yes"
+		;;
+	*)
+		;;
+esac
+AM_CONDITIONAL([WIN32], [test "${WIN32}" = "yes"])
+
+
+AC_SUBST([HAVE_UNISTD_H], [0])
+AC_CHECK_HEADER([unistd.h], [HAVE_UNISTD_H=1], [])
+AC_CONFIG_FILES([Makefile minizip.pc])
+AC_OUTPUT
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/minizip/crypt.h b/Engine/lib/assimp/contrib/zlib/contrib/minizip/crypt.h
new file mode 100644
index 000000000..1e9e8200b
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/minizip/crypt.h
@@ -0,0 +1,131 @@
+/* crypt.h -- base code for crypt/uncrypt ZIPfile
+
+
+   Version 1.01e, February 12th, 2005
+
+   Copyright (C) 1998-2005 Gilles Vollant
+
+   This code is a modified version of crypting code in Infozip distribution
+
+   The encryption/decryption parts of this source code (as opposed to the
+   non-echoing password parts) were originally written in Europe.  The
+   whole source package can be freely distributed, including from the USA.
+   (Prior to January 2000, re-export from the US was a violation of US law.)
+
+   This encryption code is a direct transcription of the algorithm from
+   Roger Schlafly, described by Phil Katz in the file appnote.txt.  This
+   file (appnote.txt) is distributed with the PKZIP program (even in the
+   version without encryption capabilities).
+
+   If you don't need crypting in your application, just define symbols
+   NOCRYPT and NOUNCRYPT.
+
+   This code support the "Traditional PKWARE Encryption".
+
+   The new AES encryption added on Zip format by Winzip (see the page
+   http://www.winzip.com/aes_info.htm ) and PKWare PKZip 5.x Strong
+   Encryption is not supported.
+*/
+
+#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))
+
+/***********************************************************************
+ * Return the next byte in the pseudo-random sequence
+ */
+static int decrypt_byte(unsigned long* pkeys, const z_crc_t* pcrc_32_tab)
+{
+    unsigned temp;  /* POTENTIAL BUG:  temp*(temp^1) may overflow in an
+                     * unpredictable manner on 16-bit systems; not a problem
+                     * with any known compiler so far, though */
+
+    temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2;
+    return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);
+}
+
+/***********************************************************************
+ * Update the encryption keys with the next byte of plain text
+ */
+static int update_keys(unsigned long* pkeys,const z_crc_t* pcrc_32_tab,int c)
+{
+    (*(pkeys+0)) = CRC32((*(pkeys+0)), c);
+    (*(pkeys+1)) += (*(pkeys+0)) & 0xff;
+    (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1;
+    {
+      register int keyshift = (int)((*(pkeys+1)) >> 24);
+      (*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift);
+    }
+    return c;
+}
+
+
+/***********************************************************************
+ * Initialize the encryption keys and the random header according to
+ * the given password.
+ */
+static void init_keys(const char* passwd,unsigned long* pkeys,const z_crc_t* pcrc_32_tab)
+{
+    *(pkeys+0) = 305419896L;
+    *(pkeys+1) = 591751049L;
+    *(pkeys+2) = 878082192L;
+    while (*passwd != '\0') {
+        update_keys(pkeys,pcrc_32_tab,(int)*passwd);
+        passwd++;
+    }
+}
+
+#define zdecode(pkeys,pcrc_32_tab,c) \
+    (update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab)))
+
+#define zencode(pkeys,pcrc_32_tab,c,t) \
+    (t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c))
+
+#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED
+
+#define RAND_HEAD_LEN  12
+   /* "last resort" source for second part of crypt seed pattern */
+#  ifndef ZCR_SEED2
+#    define ZCR_SEED2 3141592654UL     /* use PI as default pattern */
+#  endif
+
+static int crypthead(const char* passwd,      /* password string */
+                     unsigned char* buf,      /* where to write header */
+                     int bufSize,
+                     unsigned long* pkeys,
+                     const z_crc_t* pcrc_32_tab,
+                     unsigned long crcForCrypting)
+{
+    int n;                       /* index in random header */
+    int t;                       /* temporary */
+    int c;                       /* random byte */
+    unsigned char header[RAND_HEAD_LEN-2]; /* random header */
+    static unsigned calls = 0;   /* ensure different random header each time */
+
+    if (bufSize<RAND_HEAD_LEN)
+      return 0;
+
+    /* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the
+     * output of rand() to get less predictability, since rand() is
+     * often poorly implemented.
+     */
+    if (++calls == 1)
+    {
+        srand((unsigned)(time(NULL) ^ ZCR_SEED2));
+    }
+    init_keys(passwd, pkeys, pcrc_32_tab);
+    for (n = 0; n < RAND_HEAD_LEN-2; n++)
+    {
+        c = (rand() >> 7) & 0xff;
+        header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t);
+    }
+    /* Encrypt random header (last two bytes is high word of crc) */
+    init_keys(passwd, pkeys, pcrc_32_tab);
+    for (n = 0; n < RAND_HEAD_LEN-2; n++)
+    {
+        buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t);
+    }
+    buf[n++] = (unsigned char)zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t);
+    buf[n++] = (unsigned char)zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t);
+    return n;
+}
+
+#endif
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/minizip/ioapi.c b/Engine/lib/assimp/contrib/zlib/contrib/minizip/ioapi.c
new file mode 100644
index 000000000..7f5c191b2
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/minizip/ioapi.c
@@ -0,0 +1,247 @@
+/* ioapi.h -- IO base function header for compress/uncompress .zip
+   part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Modifications for Zip64 support
+         Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+
+         For more info read MiniZip_info.txt
+
+*/
+
+#if defined(_WIN32) && (!(defined(_CRT_SECURE_NO_WARNINGS)))
+        #define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#if defined(__APPLE__) || defined(IOAPI_NO_64)
+// In darwin and perhaps other BSD variants off_t is a 64 bit value, hence no need for specific 64 bit functions
+#define FOPEN_FUNC(filename, mode) fopen(filename, mode)
+#define FTELLO_FUNC(stream) ftello(stream)
+#define FSEEKO_FUNC(stream, offset, origin) fseeko(stream, offset, origin)
+#else
+#define FOPEN_FUNC(filename, mode) fopen64(filename, mode)
+#define FTELLO_FUNC(stream) ftello64(stream)
+#define FSEEKO_FUNC(stream, offset, origin) fseeko64(stream, offset, origin)
+#endif
+
+
+#include "ioapi.h"
+
+voidpf call_zopen64 (const zlib_filefunc64_32_def* pfilefunc,const void*filename,int mode)
+{
+    if (pfilefunc->zfile_func64.zopen64_file != NULL)
+        return (*(pfilefunc->zfile_func64.zopen64_file)) (pfilefunc->zfile_func64.opaque,filename,mode);
+    else
+    {
+        return (*(pfilefunc->zopen32_file))(pfilefunc->zfile_func64.opaque,(const char*)filename,mode);
+    }
+}
+
+long call_zseek64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin)
+{
+    if (pfilefunc->zfile_func64.zseek64_file != NULL)
+        return (*(pfilefunc->zfile_func64.zseek64_file)) (pfilefunc->zfile_func64.opaque,filestream,offset,origin);
+    else
+    {
+        uLong offsetTruncated = (uLong)offset;
+        if (offsetTruncated != offset)
+            return -1;
+        else
+            return (*(pfilefunc->zseek32_file))(pfilefunc->zfile_func64.opaque,filestream,offsetTruncated,origin);
+    }
+}
+
+ZPOS64_T call_ztell64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream)
+{
+    if (pfilefunc->zfile_func64.zseek64_file != NULL)
+        return (*(pfilefunc->zfile_func64.ztell64_file)) (pfilefunc->zfile_func64.opaque,filestream);
+    else
+    {
+        uLong tell_uLong = (*(pfilefunc->ztell32_file))(pfilefunc->zfile_func64.opaque,filestream);
+        if ((tell_uLong) == MAXU32)
+            return (ZPOS64_T)-1;
+        else
+            return tell_uLong;
+    }
+}
+
+void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def* p_filefunc64_32,const zlib_filefunc_def* p_filefunc32)
+{
+    p_filefunc64_32->zfile_func64.zopen64_file = NULL;
+    p_filefunc64_32->zopen32_file = p_filefunc32->zopen_file;
+    p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file;
+    p_filefunc64_32->zfile_func64.zread_file = p_filefunc32->zread_file;
+    p_filefunc64_32->zfile_func64.zwrite_file = p_filefunc32->zwrite_file;
+    p_filefunc64_32->zfile_func64.ztell64_file = NULL;
+    p_filefunc64_32->zfile_func64.zseek64_file = NULL;
+    p_filefunc64_32->zfile_func64.zclose_file = p_filefunc32->zclose_file;
+    p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file;
+    p_filefunc64_32->zfile_func64.opaque = p_filefunc32->opaque;
+    p_filefunc64_32->zseek32_file = p_filefunc32->zseek_file;
+    p_filefunc64_32->ztell32_file = p_filefunc32->ztell_file;
+}
+
+
+
+static voidpf  ZCALLBACK fopen_file_func OF((voidpf opaque, const char* filename, int mode));
+static uLong   ZCALLBACK fread_file_func OF((voidpf opaque, voidpf stream, void* buf, uLong size));
+static uLong   ZCALLBACK fwrite_file_func OF((voidpf opaque, voidpf stream, const void* buf,uLong size));
+static ZPOS64_T ZCALLBACK ftell64_file_func OF((voidpf opaque, voidpf stream));
+static long    ZCALLBACK fseek64_file_func OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin));
+static int     ZCALLBACK fclose_file_func OF((voidpf opaque, voidpf stream));
+static int     ZCALLBACK ferror_file_func OF((voidpf opaque, voidpf stream));
+
+static voidpf ZCALLBACK fopen_file_func (voidpf opaque, const char* filename, int mode)
+{
+    FILE* file = NULL;
+    const char* mode_fopen = NULL;
+    if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
+        mode_fopen = "rb";
+    else
+    if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
+        mode_fopen = "r+b";
+    else
+    if (mode & ZLIB_FILEFUNC_MODE_CREATE)
+        mode_fopen = "wb";
+
+    if ((filename!=NULL) && (mode_fopen != NULL))
+        file = fopen(filename, mode_fopen);
+    return file;
+}
+
+static voidpf ZCALLBACK fopen64_file_func (voidpf opaque, const void* filename, int mode)
+{
+    FILE* file = NULL;
+    const char* mode_fopen = NULL;
+    if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
+        mode_fopen = "rb";
+    else
+    if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
+        mode_fopen = "r+b";
+    else
+    if (mode & ZLIB_FILEFUNC_MODE_CREATE)
+        mode_fopen = "wb";
+
+    if ((filename!=NULL) && (mode_fopen != NULL))
+        file = FOPEN_FUNC((const char*)filename, mode_fopen);
+    return file;
+}
+
+
+static uLong ZCALLBACK fread_file_func (voidpf opaque, voidpf stream, void* buf, uLong size)
+{
+    uLong ret;
+    ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream);
+    return ret;
+}
+
+static uLong ZCALLBACK fwrite_file_func (voidpf opaque, voidpf stream, const void* buf, uLong size)
+{
+    uLong ret;
+    ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream);
+    return ret;
+}
+
+static long ZCALLBACK ftell_file_func (voidpf opaque, voidpf stream)
+{
+    long ret;
+    ret = ftell((FILE *)stream);
+    return ret;
+}
+
+
+static ZPOS64_T ZCALLBACK ftell64_file_func (voidpf opaque, voidpf stream)
+{
+    ZPOS64_T ret;
+    ret = FTELLO_FUNC((FILE *)stream);
+    return ret;
+}
+
+static long ZCALLBACK fseek_file_func (voidpf  opaque, voidpf stream, uLong offset, int origin)
+{
+    int fseek_origin=0;
+    long ret;
+    switch (origin)
+    {
+    case ZLIB_FILEFUNC_SEEK_CUR :
+        fseek_origin = SEEK_CUR;
+        break;
+    case ZLIB_FILEFUNC_SEEK_END :
+        fseek_origin = SEEK_END;
+        break;
+    case ZLIB_FILEFUNC_SEEK_SET :
+        fseek_origin = SEEK_SET;
+        break;
+    default: return -1;
+    }
+    ret = 0;
+    if (fseek((FILE *)stream, offset, fseek_origin) != 0)
+        ret = -1;
+    return ret;
+}
+
+static long ZCALLBACK fseek64_file_func (voidpf  opaque, voidpf stream, ZPOS64_T offset, int origin)
+{
+    int fseek_origin=0;
+    long ret;
+    switch (origin)
+    {
+    case ZLIB_FILEFUNC_SEEK_CUR :
+        fseek_origin = SEEK_CUR;
+        break;
+    case ZLIB_FILEFUNC_SEEK_END :
+        fseek_origin = SEEK_END;
+        break;
+    case ZLIB_FILEFUNC_SEEK_SET :
+        fseek_origin = SEEK_SET;
+        break;
+    default: return -1;
+    }
+    ret = 0;
+
+    if(FSEEKO_FUNC((FILE *)stream, offset, fseek_origin) != 0)
+                        ret = -1;
+
+    return ret;
+}
+
+
+static int ZCALLBACK fclose_file_func (voidpf opaque, voidpf stream)
+{
+    int ret;
+    ret = fclose((FILE *)stream);
+    return ret;
+}
+
+static int ZCALLBACK ferror_file_func (voidpf opaque, voidpf stream)
+{
+    int ret;
+    ret = ferror((FILE *)stream);
+    return ret;
+}
+
+void fill_fopen_filefunc (pzlib_filefunc_def)
+  zlib_filefunc_def* pzlib_filefunc_def;
+{
+    pzlib_filefunc_def->zopen_file = fopen_file_func;
+    pzlib_filefunc_def->zread_file = fread_file_func;
+    pzlib_filefunc_def->zwrite_file = fwrite_file_func;
+    pzlib_filefunc_def->ztell_file = ftell_file_func;
+    pzlib_filefunc_def->zseek_file = fseek_file_func;
+    pzlib_filefunc_def->zclose_file = fclose_file_func;
+    pzlib_filefunc_def->zerror_file = ferror_file_func;
+    pzlib_filefunc_def->opaque = NULL;
+}
+
+void fill_fopen64_filefunc (zlib_filefunc64_def*  pzlib_filefunc_def)
+{
+    pzlib_filefunc_def->zopen64_file = fopen64_file_func;
+    pzlib_filefunc_def->zread_file = fread_file_func;
+    pzlib_filefunc_def->zwrite_file = fwrite_file_func;
+    pzlib_filefunc_def->ztell64_file = ftell64_file_func;
+    pzlib_filefunc_def->zseek64_file = fseek64_file_func;
+    pzlib_filefunc_def->zclose_file = fclose_file_func;
+    pzlib_filefunc_def->zerror_file = ferror_file_func;
+    pzlib_filefunc_def->opaque = NULL;
+}
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/minizip/ioapi.h b/Engine/lib/assimp/contrib/zlib/contrib/minizip/ioapi.h
new file mode 100644
index 000000000..8dcbdb06e
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/minizip/ioapi.h
@@ -0,0 +1,208 @@
+/* ioapi.h -- IO base function header for compress/uncompress .zip
+   part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Modifications for Zip64 support
+         Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+
+         For more info read MiniZip_info.txt
+
+         Changes
+
+    Oct-2009 - Defined ZPOS64_T to fpos_t on windows and u_int64_t on linux. (might need to find a better why for this)
+    Oct-2009 - Change to fseeko64, ftello64 and fopen64 so large files would work on linux.
+               More if/def section may be needed to support other platforms
+    Oct-2009 - Defined fxxxx64 calls to normal fopen/ftell/fseek so they would compile on windows.
+                          (but you should use iowin32.c for windows instead)
+
+*/
+
+#ifndef _ZLIBIOAPI64_H
+#define _ZLIBIOAPI64_H
+
+#if (!defined(_WIN32)) && (!defined(WIN32)) && (!defined(__APPLE__))
+
+  // Linux needs this to support file operation on files larger then 4+GB
+  // But might need better if/def to select just the platforms that needs them.
+
+        #ifndef __USE_FILE_OFFSET64
+                #define __USE_FILE_OFFSET64
+        #endif
+        #ifndef __USE_LARGEFILE64
+                #define __USE_LARGEFILE64
+        #endif
+        #ifndef _LARGEFILE64_SOURCE
+                #define _LARGEFILE64_SOURCE
+        #endif
+        #ifndef _FILE_OFFSET_BIT
+                #define _FILE_OFFSET_BIT 64
+        #endif
+
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "zlib.h"
+
+#if defined(USE_FILE32API)
+#define fopen64 fopen
+#define ftello64 ftell
+#define fseeko64 fseek
+#else
+#ifdef __FreeBSD__
+#define fopen64 fopen
+#define ftello64 ftello
+#define fseeko64 fseeko
+#endif
+#ifdef _MSC_VER
+ #define fopen64 fopen
+ #if (_MSC_VER >= 1400) && (!(defined(NO_MSCVER_FILE64_FUNC)))
+  #define ftello64 _ftelli64
+  #define fseeko64 _fseeki64
+ #else // old MSC
+  #define ftello64 ftell
+  #define fseeko64 fseek
+ #endif
+#endif
+#endif
+
+/*
+#ifndef ZPOS64_T
+  #ifdef _WIN32
+                #define ZPOS64_T fpos_t
+  #else
+    #include <stdint.h>
+    #define ZPOS64_T uint64_t
+  #endif
+#endif
+*/
+
+#ifdef HAVE_MINIZIP64_CONF_H
+#include "mz64conf.h"
+#endif
+
+/* a type choosen by DEFINE */
+#ifdef HAVE_64BIT_INT_CUSTOM
+typedef  64BIT_INT_CUSTOM_TYPE ZPOS64_T;
+#else
+#ifdef HAS_STDINT_H
+#include "stdint.h"
+typedef uint64_t ZPOS64_T;
+#else
+
+/* Maximum unsigned 32-bit value used as placeholder for zip64 */
+#define MAXU32 0xffffffff
+
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+typedef unsigned __int64 ZPOS64_T;
+#else
+typedef unsigned long long int ZPOS64_T;
+#endif
+#endif
+#endif
+
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#define ZLIB_FILEFUNC_SEEK_CUR (1)
+#define ZLIB_FILEFUNC_SEEK_END (2)
+#define ZLIB_FILEFUNC_SEEK_SET (0)
+
+#define ZLIB_FILEFUNC_MODE_READ      (1)
+#define ZLIB_FILEFUNC_MODE_WRITE     (2)
+#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3)
+
+#define ZLIB_FILEFUNC_MODE_EXISTING (4)
+#define ZLIB_FILEFUNC_MODE_CREATE   (8)
+
+
+#ifndef ZCALLBACK
+ #if (defined(WIN32) || defined(_WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK)
+   #define ZCALLBACK CALLBACK
+ #else
+   #define ZCALLBACK
+ #endif
+#endif
+
+
+
+
+typedef voidpf   (ZCALLBACK *open_file_func)      OF((voidpf opaque, const char* filename, int mode));
+typedef uLong    (ZCALLBACK *read_file_func)      OF((voidpf opaque, voidpf stream, void* buf, uLong size));
+typedef uLong    (ZCALLBACK *write_file_func)     OF((voidpf opaque, voidpf stream, const void* buf, uLong size));
+typedef int      (ZCALLBACK *close_file_func)     OF((voidpf opaque, voidpf stream));
+typedef int      (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream));
+
+typedef long     (ZCALLBACK *tell_file_func)      OF((voidpf opaque, voidpf stream));
+typedef long     (ZCALLBACK *seek_file_func)      OF((voidpf opaque, voidpf stream, uLong offset, int origin));
+
+
+/* here is the "old" 32 bits structure structure */
+typedef struct zlib_filefunc_def_s
+{
+    open_file_func      zopen_file;
+    read_file_func      zread_file;
+    write_file_func     zwrite_file;
+    tell_file_func      ztell_file;
+    seek_file_func      zseek_file;
+    close_file_func     zclose_file;
+    testerror_file_func zerror_file;
+    voidpf              opaque;
+} zlib_filefunc_def;
+
+typedef ZPOS64_T (ZCALLBACK *tell64_file_func)    OF((voidpf opaque, voidpf stream));
+typedef long     (ZCALLBACK *seek64_file_func)    OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin));
+typedef voidpf   (ZCALLBACK *open64_file_func)    OF((voidpf opaque, const void* filename, int mode));
+
+typedef struct zlib_filefunc64_def_s
+{
+    open64_file_func    zopen64_file;
+    read_file_func      zread_file;
+    write_file_func     zwrite_file;
+    tell64_file_func    ztell64_file;
+    seek64_file_func    zseek64_file;
+    close_file_func     zclose_file;
+    testerror_file_func zerror_file;
+    voidpf              opaque;
+} zlib_filefunc64_def;
+
+void fill_fopen64_filefunc OF((zlib_filefunc64_def* pzlib_filefunc_def));
+void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
+
+/* now internal definition, only for zip.c and unzip.h */
+typedef struct zlib_filefunc64_32_def_s
+{
+    zlib_filefunc64_def zfile_func64;
+    open_file_func      zopen32_file;
+    tell_file_func      ztell32_file;
+    seek_file_func      zseek32_file;
+} zlib_filefunc64_32_def;
+
+
+#define ZREAD64(filefunc,filestream,buf,size)     ((*((filefunc).zfile_func64.zread_file))   ((filefunc).zfile_func64.opaque,filestream,buf,size))
+#define ZWRITE64(filefunc,filestream,buf,size)    ((*((filefunc).zfile_func64.zwrite_file))  ((filefunc).zfile_func64.opaque,filestream,buf,size))
+//#define ZTELL64(filefunc,filestream)            ((*((filefunc).ztell64_file)) ((filefunc).opaque,filestream))
+//#define ZSEEK64(filefunc,filestream,pos,mode)   ((*((filefunc).zseek64_file)) ((filefunc).opaque,filestream,pos,mode))
+#define ZCLOSE64(filefunc,filestream)             ((*((filefunc).zfile_func64.zclose_file))  ((filefunc).zfile_func64.opaque,filestream))
+#define ZERROR64(filefunc,filestream)             ((*((filefunc).zfile_func64.zerror_file))  ((filefunc).zfile_func64.opaque,filestream))
+
+voidpf call_zopen64 OF((const zlib_filefunc64_32_def* pfilefunc,const void*filename,int mode));
+long    call_zseek64 OF((const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin));
+ZPOS64_T call_ztell64 OF((const zlib_filefunc64_32_def* pfilefunc,voidpf filestream));
+
+void    fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def* p_filefunc64_32,const zlib_filefunc_def* p_filefunc32);
+
+#define ZOPEN64(filefunc,filename,mode)         (call_zopen64((&(filefunc)),(filename),(mode)))
+#define ZTELL64(filefunc,filestream)            (call_ztell64((&(filefunc)),(filestream)))
+#define ZSEEK64(filefunc,filestream,pos,mode)   (call_zseek64((&(filefunc)),(filestream),(pos),(mode)))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/minizip/iowin32.c b/Engine/lib/assimp/contrib/zlib/contrib/minizip/iowin32.c
new file mode 100644
index 000000000..274f39eb1
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/minizip/iowin32.c
@@ -0,0 +1,462 @@
+/* iowin32.c -- IO base function header for compress/uncompress .zip
+     Version 1.1, February 14h, 2010
+     part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Modifications for Zip64 support
+         Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+
+     For more info read MiniZip_info.txt
+
+*/
+
+#include <stdlib.h>
+
+#include "zlib.h"
+#include "ioapi.h"
+#include "iowin32.h"
+
+#ifndef INVALID_HANDLE_VALUE
+#define INVALID_HANDLE_VALUE (0xFFFFFFFF)
+#endif
+
+#ifndef INVALID_SET_FILE_POINTER
+#define INVALID_SET_FILE_POINTER ((DWORD)-1)
+#endif
+
+
+// see Include/shared/winapifamily.h in the Windows Kit
+#if defined(WINAPI_FAMILY_PARTITION) && (!(defined(IOWIN32_USING_WINRT_API)))
+#if WINAPI_FAMILY_ONE_PARTITION(WINAPI_FAMILY, WINAPI_PARTITION_APP)
+#define IOWIN32_USING_WINRT_API 1
+#endif
+#endif
+
+voidpf  ZCALLBACK win32_open_file_func  OF((voidpf opaque, const char* filename, int mode));
+uLong   ZCALLBACK win32_read_file_func  OF((voidpf opaque, voidpf stream, void* buf, uLong size));
+uLong   ZCALLBACK win32_write_file_func OF((voidpf opaque, voidpf stream, const void* buf, uLong size));
+ZPOS64_T ZCALLBACK win32_tell64_file_func  OF((voidpf opaque, voidpf stream));
+long    ZCALLBACK win32_seek64_file_func  OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin));
+int     ZCALLBACK win32_close_file_func OF((voidpf opaque, voidpf stream));
+int     ZCALLBACK win32_error_file_func OF((voidpf opaque, voidpf stream));
+
+typedef struct
+{
+    HANDLE hf;
+    int error;
+} WIN32FILE_IOWIN;
+
+
+static void win32_translate_open_mode(int mode,
+                                      DWORD* lpdwDesiredAccess,
+                                      DWORD* lpdwCreationDisposition,
+                                      DWORD* lpdwShareMode,
+                                      DWORD* lpdwFlagsAndAttributes)
+{
+    *lpdwDesiredAccess = *lpdwShareMode = *lpdwFlagsAndAttributes = *lpdwCreationDisposition = 0;
+
+    if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
+    {
+        *lpdwDesiredAccess = GENERIC_READ;
+        *lpdwCreationDisposition = OPEN_EXISTING;
+        *lpdwShareMode = FILE_SHARE_READ;
+    }
+    else if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
+    {
+        *lpdwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
+        *lpdwCreationDisposition = OPEN_EXISTING;
+    }
+    else if (mode & ZLIB_FILEFUNC_MODE_CREATE)
+    {
+        *lpdwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
+        *lpdwCreationDisposition = CREATE_ALWAYS;
+    }
+}
+
+static voidpf win32_build_iowin(HANDLE hFile)
+{
+    voidpf ret=NULL;
+
+    if ((hFile != NULL) && (hFile != INVALID_HANDLE_VALUE))
+    {
+        WIN32FILE_IOWIN w32fiow;
+        w32fiow.hf = hFile;
+        w32fiow.error = 0;
+        ret = malloc(sizeof(WIN32FILE_IOWIN));
+
+        if (ret==NULL)
+            CloseHandle(hFile);
+        else
+            *((WIN32FILE_IOWIN*)ret) = w32fiow;
+    }
+    return ret;
+}
+
+voidpf ZCALLBACK win32_open64_file_func (voidpf opaque,const void* filename,int mode)
+{
+    const char* mode_fopen = NULL;
+    DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
+    HANDLE hFile = NULL;
+
+    win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
+
+#ifdef IOWIN32_USING_WINRT_API
+#ifdef UNICODE
+    if ((filename!=NULL) && (dwDesiredAccess != 0))
+        hFile = CreateFile2((LPCTSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
+#else
+    if ((filename!=NULL) && (dwDesiredAccess != 0))
+    {
+        WCHAR filenameW[FILENAME_MAX + 0x200 + 1];
+        MultiByteToWideChar(CP_ACP,0,(const char*)filename,-1,filenameW,FILENAME_MAX + 0x200);
+        hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
+    }
+#endif
+#else
+    if ((filename!=NULL) && (dwDesiredAccess != 0))
+        hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
+#endif
+
+    return win32_build_iowin(hFile);
+}
+
+
+voidpf ZCALLBACK win32_open64_file_funcA (voidpf opaque,const void* filename,int mode)
+{
+    const char* mode_fopen = NULL;
+    DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
+    HANDLE hFile = NULL;
+
+    win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
+
+#ifdef IOWIN32_USING_WINRT_API
+    if ((filename!=NULL) && (dwDesiredAccess != 0))
+    {
+        WCHAR filenameW[FILENAME_MAX + 0x200 + 1];
+        MultiByteToWideChar(CP_ACP,0,(const char*)filename,-1,filenameW,FILENAME_MAX + 0x200);
+        hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
+    }
+#else
+    if ((filename!=NULL) && (dwDesiredAccess != 0))
+        hFile = CreateFileA((LPCSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
+#endif
+
+    return win32_build_iowin(hFile);
+}
+
+
+voidpf ZCALLBACK win32_open64_file_funcW (voidpf opaque,const void* filename,int mode)
+{
+    const char* mode_fopen = NULL;
+    DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
+    HANDLE hFile = NULL;
+
+    win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
+
+#ifdef IOWIN32_USING_WINRT_API
+    if ((filename!=NULL) && (dwDesiredAccess != 0))
+        hFile = CreateFile2((LPCWSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition,NULL);
+#else
+    if ((filename!=NULL) && (dwDesiredAccess != 0))
+        hFile = CreateFileW((LPCWSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
+#endif
+
+    return win32_build_iowin(hFile);
+}
+
+
+voidpf ZCALLBACK win32_open_file_func (voidpf opaque,const char* filename,int mode)
+{
+    const char* mode_fopen = NULL;
+    DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
+    HANDLE hFile = NULL;
+
+    win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
+
+#ifdef IOWIN32_USING_WINRT_API
+#ifdef UNICODE
+    if ((filename!=NULL) && (dwDesiredAccess != 0))
+        hFile = CreateFile2((LPCTSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
+#else
+    if ((filename!=NULL) && (dwDesiredAccess != 0))
+    {
+        WCHAR filenameW[FILENAME_MAX + 0x200 + 1];
+        MultiByteToWideChar(CP_ACP,0,(const char*)filename,-1,filenameW,FILENAME_MAX + 0x200);
+        hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
+    }
+#endif
+#else
+    if ((filename!=NULL) && (dwDesiredAccess != 0))
+        hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
+#endif
+
+    return win32_build_iowin(hFile);
+}
+
+
+uLong ZCALLBACK win32_read_file_func (voidpf opaque, voidpf stream, void* buf,uLong size)
+{
+    uLong ret=0;
+    HANDLE hFile = NULL;
+    if (stream!=NULL)
+        hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
+
+    if (hFile != NULL)
+    {
+        if (!ReadFile(hFile, buf, size, &ret, NULL))
+        {
+            DWORD dwErr = GetLastError();
+            if (dwErr == ERROR_HANDLE_EOF)
+                dwErr = 0;
+            ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
+        }
+    }
+
+    return ret;
+}
+
+
+uLong ZCALLBACK win32_write_file_func (voidpf opaque,voidpf stream,const void* buf,uLong size)
+{
+    uLong ret=0;
+    HANDLE hFile = NULL;
+    if (stream!=NULL)
+        hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
+
+    if (hFile != NULL)
+    {
+        if (!WriteFile(hFile, buf, size, &ret, NULL))
+        {
+            DWORD dwErr = GetLastError();
+            if (dwErr == ERROR_HANDLE_EOF)
+                dwErr = 0;
+            ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
+        }
+    }
+
+    return ret;
+}
+
+static BOOL MySetFilePointerEx(HANDLE hFile, LARGE_INTEGER pos, LARGE_INTEGER *newPos,  DWORD dwMoveMethod)
+{
+#ifdef IOWIN32_USING_WINRT_API
+    return SetFilePointerEx(hFile, pos, newPos, dwMoveMethod);
+#else
+    LONG lHigh = pos.HighPart;
+    DWORD dwNewPos = SetFilePointer(hFile, pos.LowPart, &lHigh, dwMoveMethod);
+    BOOL fOk = TRUE;
+    if (dwNewPos == 0xFFFFFFFF)
+        if (GetLastError() != NO_ERROR)
+            fOk = FALSE;
+    if ((newPos != NULL) && (fOk))
+    {
+        newPos->LowPart = dwNewPos;
+        newPos->HighPart = lHigh;
+    }
+    return fOk;
+#endif
+}
+
+long ZCALLBACK win32_tell_file_func (voidpf opaque,voidpf stream)
+{
+    long ret=-1;
+    HANDLE hFile = NULL;
+    if (stream!=NULL)
+        hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
+    if (hFile != NULL)
+    {
+        LARGE_INTEGER pos;
+        pos.QuadPart = 0;
+
+        if (!MySetFilePointerEx(hFile, pos, &pos, FILE_CURRENT))
+        {
+            DWORD dwErr = GetLastError();
+            ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
+            ret = -1;
+        }
+        else
+            ret=(long)pos.LowPart;
+    }
+    return ret;
+}
+
+ZPOS64_T ZCALLBACK win32_tell64_file_func (voidpf opaque, voidpf stream)
+{
+    ZPOS64_T ret= (ZPOS64_T)-1;
+    HANDLE hFile = NULL;
+    if (stream!=NULL)
+        hFile = ((WIN32FILE_IOWIN*)stream)->hf;
+
+    if (hFile)
+    {
+        LARGE_INTEGER pos;
+        pos.QuadPart = 0;
+
+        if (!MySetFilePointerEx(hFile, pos, &pos, FILE_CURRENT))
+        {
+            DWORD dwErr = GetLastError();
+            ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
+            ret = (ZPOS64_T)-1;
+        }
+        else
+            ret=pos.QuadPart;
+    }
+    return ret;
+}
+
+
+long ZCALLBACK win32_seek_file_func (voidpf opaque,voidpf stream,uLong offset,int origin)
+{
+    DWORD dwMoveMethod=0xFFFFFFFF;
+    HANDLE hFile = NULL;
+
+    long ret=-1;
+    if (stream!=NULL)
+        hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
+    switch (origin)
+    {
+    case ZLIB_FILEFUNC_SEEK_CUR :
+        dwMoveMethod = FILE_CURRENT;
+        break;
+    case ZLIB_FILEFUNC_SEEK_END :
+        dwMoveMethod = FILE_END;
+        break;
+    case ZLIB_FILEFUNC_SEEK_SET :
+        dwMoveMethod = FILE_BEGIN;
+        break;
+    default: return -1;
+    }
+
+    if (hFile != NULL)
+    {
+        LARGE_INTEGER pos;
+        pos.QuadPart = offset;
+        if (!MySetFilePointerEx(hFile, pos, NULL, dwMoveMethod))
+        {
+            DWORD dwErr = GetLastError();
+            ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
+            ret = -1;
+        }
+        else
+            ret=0;
+    }
+    return ret;
+}
+
+long ZCALLBACK win32_seek64_file_func (voidpf opaque, voidpf stream,ZPOS64_T offset,int origin)
+{
+    DWORD dwMoveMethod=0xFFFFFFFF;
+    HANDLE hFile = NULL;
+    long ret=-1;
+
+    if (stream!=NULL)
+        hFile = ((WIN32FILE_IOWIN*)stream)->hf;
+
+    switch (origin)
+    {
+        case ZLIB_FILEFUNC_SEEK_CUR :
+            dwMoveMethod = FILE_CURRENT;
+            break;
+        case ZLIB_FILEFUNC_SEEK_END :
+            dwMoveMethod = FILE_END;
+            break;
+        case ZLIB_FILEFUNC_SEEK_SET :
+            dwMoveMethod = FILE_BEGIN;
+            break;
+        default: return -1;
+    }
+
+    if (hFile)
+    {
+        LARGE_INTEGER pos;
+        pos.QuadPart = offset;
+        if (!MySetFilePointerEx(hFile, pos, NULL, dwMoveMethod))
+        {
+            DWORD dwErr = GetLastError();
+            ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
+            ret = -1;
+        }
+        else
+            ret=0;
+    }
+    return ret;
+}
+
+int ZCALLBACK win32_close_file_func (voidpf opaque, voidpf stream)
+{
+    int ret=-1;
+
+    if (stream!=NULL)
+    {
+        HANDLE hFile;
+        hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
+        if (hFile != NULL)
+        {
+            CloseHandle(hFile);
+            ret=0;
+        }
+        free(stream);
+    }
+    return ret;
+}
+
+int ZCALLBACK win32_error_file_func (voidpf opaque,voidpf stream)
+{
+    int ret=-1;
+    if (stream!=NULL)
+    {
+        ret = ((WIN32FILE_IOWIN*)stream) -> error;
+    }
+    return ret;
+}
+
+void fill_win32_filefunc (zlib_filefunc_def* pzlib_filefunc_def)
+{
+    pzlib_filefunc_def->zopen_file = win32_open_file_func;
+    pzlib_filefunc_def->zread_file = win32_read_file_func;
+    pzlib_filefunc_def->zwrite_file = win32_write_file_func;
+    pzlib_filefunc_def->ztell_file = win32_tell_file_func;
+    pzlib_filefunc_def->zseek_file = win32_seek_file_func;
+    pzlib_filefunc_def->zclose_file = win32_close_file_func;
+    pzlib_filefunc_def->zerror_file = win32_error_file_func;
+    pzlib_filefunc_def->opaque = NULL;
+}
+
+void fill_win32_filefunc64(zlib_filefunc64_def* pzlib_filefunc_def)
+{
+    pzlib_filefunc_def->zopen64_file = win32_open64_file_func;
+    pzlib_filefunc_def->zread_file = win32_read_file_func;
+    pzlib_filefunc_def->zwrite_file = win32_write_file_func;
+    pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
+    pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
+    pzlib_filefunc_def->zclose_file = win32_close_file_func;
+    pzlib_filefunc_def->zerror_file = win32_error_file_func;
+    pzlib_filefunc_def->opaque = NULL;
+}
+
+
+void fill_win32_filefunc64A(zlib_filefunc64_def* pzlib_filefunc_def)
+{
+    pzlib_filefunc_def->zopen64_file = win32_open64_file_funcA;
+    pzlib_filefunc_def->zread_file = win32_read_file_func;
+    pzlib_filefunc_def->zwrite_file = win32_write_file_func;
+    pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
+    pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
+    pzlib_filefunc_def->zclose_file = win32_close_file_func;
+    pzlib_filefunc_def->zerror_file = win32_error_file_func;
+    pzlib_filefunc_def->opaque = NULL;
+}
+
+
+void fill_win32_filefunc64W(zlib_filefunc64_def* pzlib_filefunc_def)
+{
+    pzlib_filefunc_def->zopen64_file = win32_open64_file_funcW;
+    pzlib_filefunc_def->zread_file = win32_read_file_func;
+    pzlib_filefunc_def->zwrite_file = win32_write_file_func;
+    pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
+    pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
+    pzlib_filefunc_def->zclose_file = win32_close_file_func;
+    pzlib_filefunc_def->zerror_file = win32_error_file_func;
+    pzlib_filefunc_def->opaque = NULL;
+}
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/minizip/iowin32.h b/Engine/lib/assimp/contrib/zlib/contrib/minizip/iowin32.h
new file mode 100644
index 000000000..0ca0969a7
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/minizip/iowin32.h
@@ -0,0 +1,28 @@
+/* iowin32.h -- IO base function header for compress/uncompress .zip
+     Version 1.1, February 14h, 2010
+     part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Modifications for Zip64 support
+         Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+
+         For more info read MiniZip_info.txt
+
+*/
+
+#include <windows.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void fill_win32_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
+void fill_win32_filefunc64 OF((zlib_filefunc64_def* pzlib_filefunc_def));
+void fill_win32_filefunc64A OF((zlib_filefunc64_def* pzlib_filefunc_def));
+void fill_win32_filefunc64W OF((zlib_filefunc64_def* pzlib_filefunc_def));
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/minizip/make_vms.com b/Engine/lib/assimp/contrib/zlib/contrib/minizip/make_vms.com
new file mode 100644
index 000000000..9ac13a98f
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/minizip/make_vms.com
@@ -0,0 +1,25 @@
+$ if f$search("ioapi.h_orig") .eqs. "" then copy ioapi.h ioapi.h_orig
+$ open/write zdef vmsdefs.h
+$ copy sys$input: zdef
+$ deck
+#define unix
+#define fill_zlib_filefunc64_32_def_from_filefunc32 fillzffunc64from
+#define Write_Zip64EndOfCentralDirectoryLocator Write_Zip64EoDLocator
+#define Write_Zip64EndOfCentralDirectoryRecord Write_Zip64EoDRecord
+#define Write_EndOfCentralDirectoryRecord Write_EoDRecord
+$ eod
+$ close zdef
+$ copy vmsdefs.h,ioapi.h_orig ioapi.h
+$ cc/include=[--]/prefix=all ioapi.c
+$ cc/include=[--]/prefix=all miniunz.c
+$ cc/include=[--]/prefix=all unzip.c
+$ cc/include=[--]/prefix=all minizip.c
+$ cc/include=[--]/prefix=all zip.c
+$ link miniunz,unzip,ioapi,[--]libz.olb/lib
+$ link minizip,zip,ioapi,[--]libz.olb/lib
+$ mcr []minizip test minizip_info.txt
+$ mcr []miniunz -l test.zip
+$ rename minizip_info.txt; minizip_info.txt_old
+$ mcr []miniunz test.zip
+$ delete test.zip;*
+$exit
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/minizip/miniunz.c b/Engine/lib/assimp/contrib/zlib/contrib/minizip/miniunz.c
new file mode 100644
index 000000000..3d65401be
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/minizip/miniunz.c
@@ -0,0 +1,660 @@
+/*
+   miniunz.c
+   Version 1.1, February 14h, 2010
+   sample part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Modifications of Unzip for Zip64
+         Copyright (C) 2007-2008 Even Rouault
+
+         Modifications for Zip64 support on both zip and unzip
+         Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+*/
+
+#if (!defined(_WIN32)) && (!defined(WIN32)) && (!defined(__APPLE__))
+        #ifndef __USE_FILE_OFFSET64
+                #define __USE_FILE_OFFSET64
+        #endif
+        #ifndef __USE_LARGEFILE64
+                #define __USE_LARGEFILE64
+        #endif
+        #ifndef _LARGEFILE64_SOURCE
+                #define _LARGEFILE64_SOURCE
+        #endif
+        #ifndef _FILE_OFFSET_BIT
+                #define _FILE_OFFSET_BIT 64
+        #endif
+#endif
+
+#ifdef __APPLE__
+// In darwin and perhaps other BSD variants off_t is a 64 bit value, hence no need for specific 64 bit functions
+#define FOPEN_FUNC(filename, mode) fopen(filename, mode)
+#define FTELLO_FUNC(stream) ftello(stream)
+#define FSEEKO_FUNC(stream, offset, origin) fseeko(stream, offset, origin)
+#else
+#define FOPEN_FUNC(filename, mode) fopen64(filename, mode)
+#define FTELLO_FUNC(stream) ftello64(stream)
+#define FSEEKO_FUNC(stream, offset, origin) fseeko64(stream, offset, origin)
+#endif
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <errno.h>
+#include <fcntl.h>
+
+#ifdef _WIN32
+# include <direct.h>
+# include <io.h>
+#else
+# include <unistd.h>
+# include <utime.h>
+#endif
+
+
+#include "unzip.h"
+
+#define CASESENSITIVITY (0)
+#define WRITEBUFFERSIZE (8192)
+#define MAXFILENAME (256)
+
+#ifdef _WIN32
+#define USEWIN32IOAPI
+#include "iowin32.h"
+#endif
+/*
+  mini unzip, demo of unzip package
+
+  usage :
+  Usage : miniunz [-exvlo] file.zip [file_to_extract] [-d extractdir]
+
+  list the file in the zipfile, and print the content of FILE_ID.ZIP or README.TXT
+    if it exists
+*/
+
+
+/* change_file_date : change the date/time of a file
+    filename : the filename of the file where date/time must be modified
+    dosdate : the new date at the MSDos format (4 bytes)
+    tmu_date : the SAME new date at the tm_unz format */
+void change_file_date(filename,dosdate,tmu_date)
+    const char *filename;
+    uLong dosdate;
+    tm_unz tmu_date;
+{
+#ifdef _WIN32
+  HANDLE hFile;
+  FILETIME ftm,ftLocal,ftCreate,ftLastAcc,ftLastWrite;
+
+  hFile = CreateFileA(filename,GENERIC_READ | GENERIC_WRITE,
+                      0,NULL,OPEN_EXISTING,0,NULL);
+  GetFileTime(hFile,&ftCreate,&ftLastAcc,&ftLastWrite);
+  DosDateTimeToFileTime((WORD)(dosdate>>16),(WORD)dosdate,&ftLocal);
+  LocalFileTimeToFileTime(&ftLocal,&ftm);
+  SetFileTime(hFile,&ftm,&ftLastAcc,&ftm);
+  CloseHandle(hFile);
+#else
+#ifdef unix || __APPLE__
+  struct utimbuf ut;
+  struct tm newdate;
+  newdate.tm_sec = tmu_date.tm_sec;
+  newdate.tm_min=tmu_date.tm_min;
+  newdate.tm_hour=tmu_date.tm_hour;
+  newdate.tm_mday=tmu_date.tm_mday;
+  newdate.tm_mon=tmu_date.tm_mon;
+  if (tmu_date.tm_year > 1900)
+      newdate.tm_year=tmu_date.tm_year - 1900;
+  else
+      newdate.tm_year=tmu_date.tm_year ;
+  newdate.tm_isdst=-1;
+
+  ut.actime=ut.modtime=mktime(&newdate);
+  utime(filename,&ut);
+#endif
+#endif
+}
+
+
+/* mymkdir and change_file_date are not 100 % portable
+   As I don't know well Unix, I wait feedback for the unix portion */
+
+int mymkdir(dirname)
+    const char* dirname;
+{
+    int ret=0;
+#ifdef _WIN32
+    ret = _mkdir(dirname);
+#elif unix
+    ret = mkdir (dirname,0775);
+#elif __APPLE__
+    ret = mkdir (dirname,0775);
+#endif
+    return ret;
+}
+
+int makedir (newdir)
+    char *newdir;
+{
+  char *buffer ;
+  char *p;
+  int  len = (int)strlen(newdir);
+
+  if (len <= 0)
+    return 0;
+
+  buffer = (char*)malloc(len+1);
+        if (buffer==NULL)
+        {
+                printf("Error allocating memory\n");
+                return UNZ_INTERNALERROR;
+        }
+  strcpy(buffer,newdir);
+
+  if (buffer[len-1] == '/') {
+    buffer[len-1] = '\0';
+  }
+  if (mymkdir(buffer) == 0)
+    {
+      free(buffer);
+      return 1;
+    }
+
+  p = buffer+1;
+  while (1)
+    {
+      char hold;
+
+      while(*p && *p != '\\' && *p != '/')
+        p++;
+      hold = *p;
+      *p = 0;
+      if ((mymkdir(buffer) == -1) && (errno == ENOENT))
+        {
+          printf("couldn't create directory %s\n",buffer);
+          free(buffer);
+          return 0;
+        }
+      if (hold == 0)
+        break;
+      *p++ = hold;
+    }
+  free(buffer);
+  return 1;
+}
+
+void do_banner()
+{
+    printf("MiniUnz 1.01b, demo of zLib + Unz package written by Gilles Vollant\n");
+    printf("more info at http://www.winimage.com/zLibDll/unzip.html\n\n");
+}
+
+void do_help()
+{
+    printf("Usage : miniunz [-e] [-x] [-v] [-l] [-o] [-p password] file.zip [file_to_extr.] [-d extractdir]\n\n" \
+           "  -e  Extract without pathname (junk paths)\n" \
+           "  -x  Extract with pathname\n" \
+           "  -v  list files\n" \
+           "  -l  list files\n" \
+           "  -d  directory to extract into\n" \
+           "  -o  overwrite files without prompting\n" \
+           "  -p  extract crypted file using password\n\n");
+}
+
+void Display64BitsSize(ZPOS64_T n, int size_char)
+{
+  /* to avoid compatibility problem , we do here the conversion */
+  char number[21];
+  int offset=19;
+  int pos_string = 19;
+  number[20]=0;
+  for (;;) {
+      number[offset]=(char)((n%10)+'0');
+      if (number[offset] != '0')
+          pos_string=offset;
+      n/=10;
+      if (offset==0)
+          break;
+      offset--;
+  }
+  {
+      int size_display_string = 19-pos_string;
+      while (size_char > size_display_string)
+      {
+          size_char--;
+          printf(" ");
+      }
+  }
+
+  printf("%s",&number[pos_string]);
+}
+
+int do_list(uf)
+    unzFile uf;
+{
+    uLong i;
+    unz_global_info64 gi;
+    int err;
+
+    err = unzGetGlobalInfo64(uf,&gi);
+    if (err!=UNZ_OK)
+        printf("error %d with zipfile in unzGetGlobalInfo \n",err);
+    printf("  Length  Method     Size Ratio   Date    Time   CRC-32     Name\n");
+    printf("  ------  ------     ---- -----   ----    ----   ------     ----\n");
+    for (i=0;i<gi.number_entry;i++)
+    {
+        char filename_inzip[256];
+        unz_file_info64 file_info;
+        uLong ratio=0;
+        const char *string_method;
+        char charCrypt=' ';
+        err = unzGetCurrentFileInfo64(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0);
+        if (err!=UNZ_OK)
+        {
+            printf("error %d with zipfile in unzGetCurrentFileInfo\n",err);
+            break;
+        }
+        if (file_info.uncompressed_size>0)
+            ratio = (uLong)((file_info.compressed_size*100)/file_info.uncompressed_size);
+
+        /* display a '*' if the file is crypted */
+        if ((file_info.flag & 1) != 0)
+            charCrypt='*';
+
+        if (file_info.compression_method==0)
+            string_method="Stored";
+        else
+        if (file_info.compression_method==Z_DEFLATED)
+        {
+            uInt iLevel=(uInt)((file_info.flag & 0x6)/2);
+            if (iLevel==0)
+              string_method="Defl:N";
+            else if (iLevel==1)
+              string_method="Defl:X";
+            else if ((iLevel==2) || (iLevel==3))
+              string_method="Defl:F"; /* 2:fast , 3 : extra fast*/
+        }
+        else
+        if (file_info.compression_method==Z_BZIP2ED)
+        {
+              string_method="BZip2 ";
+        }
+        else
+            string_method="Unkn. ";
+
+        Display64BitsSize(file_info.uncompressed_size,7);
+        printf("  %6s%c",string_method,charCrypt);
+        Display64BitsSize(file_info.compressed_size,7);
+        printf(" %3lu%%  %2.2lu-%2.2lu-%2.2lu  %2.2lu:%2.2lu  %8.8lx   %s\n",
+                ratio,
+                (uLong)file_info.tmu_date.tm_mon + 1,
+                (uLong)file_info.tmu_date.tm_mday,
+                (uLong)file_info.tmu_date.tm_year % 100,
+                (uLong)file_info.tmu_date.tm_hour,(uLong)file_info.tmu_date.tm_min,
+                (uLong)file_info.crc,filename_inzip);
+        if ((i+1)<gi.number_entry)
+        {
+            err = unzGoToNextFile(uf);
+            if (err!=UNZ_OK)
+            {
+                printf("error %d with zipfile in unzGoToNextFile\n",err);
+                break;
+            }
+        }
+    }
+
+    return 0;
+}
+
+
+int do_extract_currentfile(uf,popt_extract_without_path,popt_overwrite,password)
+    unzFile uf;
+    const int* popt_extract_without_path;
+    int* popt_overwrite;
+    const char* password;
+{
+    char filename_inzip[256];
+    char* filename_withoutpath;
+    char* p;
+    int err=UNZ_OK;
+    FILE *fout=NULL;
+    void* buf;
+    uInt size_buf;
+
+    unz_file_info64 file_info;
+    uLong ratio=0;
+    err = unzGetCurrentFileInfo64(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0);
+
+    if (err!=UNZ_OK)
+    {
+        printf("error %d with zipfile in unzGetCurrentFileInfo\n",err);
+        return err;
+    }
+
+    size_buf = WRITEBUFFERSIZE;
+    buf = (void*)malloc(size_buf);
+    if (buf==NULL)
+    {
+        printf("Error allocating memory\n");
+        return UNZ_INTERNALERROR;
+    }
+
+    p = filename_withoutpath = filename_inzip;
+    while ((*p) != '\0')
+    {
+        if (((*p)=='/') || ((*p)=='\\'))
+            filename_withoutpath = p+1;
+        p++;
+    }
+
+    if ((*filename_withoutpath)=='\0')
+    {
+        if ((*popt_extract_without_path)==0)
+        {
+            printf("creating directory: %s\n",filename_inzip);
+            mymkdir(filename_inzip);
+        }
+    }
+    else
+    {
+        const char* write_filename;
+        int skip=0;
+
+        if ((*popt_extract_without_path)==0)
+            write_filename = filename_inzip;
+        else
+            write_filename = filename_withoutpath;
+
+        err = unzOpenCurrentFilePassword(uf,password);
+        if (err!=UNZ_OK)
+        {
+            printf("error %d with zipfile in unzOpenCurrentFilePassword\n",err);
+        }
+
+        if (((*popt_overwrite)==0) && (err==UNZ_OK))
+        {
+            char rep=0;
+            FILE* ftestexist;
+            ftestexist = FOPEN_FUNC(write_filename,"rb");
+            if (ftestexist!=NULL)
+            {
+                fclose(ftestexist);
+                do
+                {
+                    char answer[128];
+                    int ret;
+
+                    printf("The file %s exists. Overwrite ? [y]es, [n]o, [A]ll: ",write_filename);
+                    ret = scanf("%1s",answer);
+                    if (ret != 1)
+                    {
+                       exit(EXIT_FAILURE);
+                    }
+                    rep = answer[0] ;
+                    if ((rep>='a') && (rep<='z'))
+                        rep -= 0x20;
+                }
+                while ((rep!='Y') && (rep!='N') && (rep!='A'));
+            }
+
+            if (rep == 'N')
+                skip = 1;
+
+            if (rep == 'A')
+                *popt_overwrite=1;
+        }
+
+        if ((skip==0) && (err==UNZ_OK))
+        {
+            fout=FOPEN_FUNC(write_filename,"wb");
+            /* some zipfile don't contain directory alone before file */
+            if ((fout==NULL) && ((*popt_extract_without_path)==0) &&
+                                (filename_withoutpath!=(char*)filename_inzip))
+            {
+                char c=*(filename_withoutpath-1);
+                *(filename_withoutpath-1)='\0';
+                makedir(write_filename);
+                *(filename_withoutpath-1)=c;
+                fout=FOPEN_FUNC(write_filename,"wb");
+            }
+
+            if (fout==NULL)
+            {
+                printf("error opening %s\n",write_filename);
+            }
+        }
+
+        if (fout!=NULL)
+        {
+            printf(" extracting: %s\n",write_filename);
+
+            do
+            {
+                err = unzReadCurrentFile(uf,buf,size_buf);
+                if (err<0)
+                {
+                    printf("error %d with zipfile in unzReadCurrentFile\n",err);
+                    break;
+                }
+                if (err>0)
+                    if (fwrite(buf,err,1,fout)!=1)
+                    {
+                        printf("error in writing extracted file\n");
+                        err=UNZ_ERRNO;
+                        break;
+                    }
+            }
+            while (err>0);
+            if (fout)
+                    fclose(fout);
+
+            if (err==0)
+                change_file_date(write_filename,file_info.dosDate,
+                                 file_info.tmu_date);
+        }
+
+        if (err==UNZ_OK)
+        {
+            err = unzCloseCurrentFile (uf);
+            if (err!=UNZ_OK)
+            {
+                printf("error %d with zipfile in unzCloseCurrentFile\n",err);
+            }
+        }
+        else
+            unzCloseCurrentFile(uf); /* don't lose the error */
+    }
+
+    free(buf);
+    return err;
+}
+
+
+int do_extract(uf,opt_extract_without_path,opt_overwrite,password)
+    unzFile uf;
+    int opt_extract_without_path;
+    int opt_overwrite;
+    const char* password;
+{
+    uLong i;
+    unz_global_info64 gi;
+    int err;
+    FILE* fout=NULL;
+
+    err = unzGetGlobalInfo64(uf,&gi);
+    if (err!=UNZ_OK)
+        printf("error %d with zipfile in unzGetGlobalInfo \n",err);
+
+    for (i=0;i<gi.number_entry;i++)
+    {
+        if (do_extract_currentfile(uf,&opt_extract_without_path,
+                                      &opt_overwrite,
+                                      password) != UNZ_OK)
+            break;
+
+        if ((i+1)<gi.number_entry)
+        {
+            err = unzGoToNextFile(uf);
+            if (err!=UNZ_OK)
+            {
+                printf("error %d with zipfile in unzGoToNextFile\n",err);
+                break;
+            }
+        }
+    }
+
+    return 0;
+}
+
+int do_extract_onefile(uf,filename,opt_extract_without_path,opt_overwrite,password)
+    unzFile uf;
+    const char* filename;
+    int opt_extract_without_path;
+    int opt_overwrite;
+    const char* password;
+{
+    int err = UNZ_OK;
+    if (unzLocateFile(uf,filename,CASESENSITIVITY)!=UNZ_OK)
+    {
+        printf("file %s not found in the zipfile\n",filename);
+        return 2;
+    }
+
+    if (do_extract_currentfile(uf,&opt_extract_without_path,
+                                      &opt_overwrite,
+                                      password) == UNZ_OK)
+        return 0;
+    else
+        return 1;
+}
+
+
+int main(argc,argv)
+    int argc;
+    char *argv[];
+{
+    const char *zipfilename=NULL;
+    const char *filename_to_extract=NULL;
+    const char *password=NULL;
+    char filename_try[MAXFILENAME+16] = "";
+    int i;
+    int ret_value=0;
+    int opt_do_list=0;
+    int opt_do_extract=1;
+    int opt_do_extract_withoutpath=0;
+    int opt_overwrite=0;
+    int opt_extractdir=0;
+    const char *dirname=NULL;
+    unzFile uf=NULL;
+
+    do_banner();
+    if (argc==1)
+    {
+        do_help();
+        return 0;
+    }
+    else
+    {
+        for (i=1;i<argc;i++)
+        {
+            if ((*argv[i])=='-')
+            {
+                const char *p=argv[i]+1;
+
+                while ((*p)!='\0')
+                {
+                    char c=*(p++);;
+                    if ((c=='l') || (c=='L'))
+                        opt_do_list = 1;
+                    if ((c=='v') || (c=='V'))
+                        opt_do_list = 1;
+                    if ((c=='x') || (c=='X'))
+                        opt_do_extract = 1;
+                    if ((c=='e') || (c=='E'))
+                        opt_do_extract = opt_do_extract_withoutpath = 1;
+                    if ((c=='o') || (c=='O'))
+                        opt_overwrite=1;
+                    if ((c=='d') || (c=='D'))
+                    {
+                        opt_extractdir=1;
+                        dirname=argv[i+1];
+                    }
+
+                    if (((c=='p') || (c=='P')) && (i+1<argc))
+                    {
+                        password=argv[i+1];
+                        i++;
+                    }
+                }
+            }
+            else
+            {
+                if (zipfilename == NULL)
+                    zipfilename = argv[i];
+                else if ((filename_to_extract==NULL) && (!opt_extractdir))
+                        filename_to_extract = argv[i] ;
+            }
+        }
+    }
+
+    if (zipfilename!=NULL)
+    {
+
+#        ifdef USEWIN32IOAPI
+        zlib_filefunc64_def ffunc;
+#        endif
+
+        strncpy(filename_try, zipfilename,MAXFILENAME-1);
+        /* strncpy doesnt append the trailing NULL, of the string is too long. */
+        filename_try[ MAXFILENAME ] = '\0';
+
+#        ifdef USEWIN32IOAPI
+        fill_win32_filefunc64A(&ffunc);
+        uf = unzOpen2_64(zipfilename,&ffunc);
+#        else
+        uf = unzOpen64(zipfilename);
+#        endif
+        if (uf==NULL)
+        {
+            strcat(filename_try,".zip");
+#            ifdef USEWIN32IOAPI
+            uf = unzOpen2_64(filename_try,&ffunc);
+#            else
+            uf = unzOpen64(filename_try);
+#            endif
+        }
+    }
+
+    if (uf==NULL)
+    {
+        printf("Cannot open %s or %s.zip\n",zipfilename,zipfilename);
+        return 1;
+    }
+    printf("%s opened\n",filename_try);
+
+    if (opt_do_list==1)
+        ret_value = do_list(uf);
+    else if (opt_do_extract==1)
+    {
+#ifdef _WIN32
+        if (opt_extractdir && _chdir(dirname))
+#else
+        if (opt_extractdir && chdir(dirname))
+#endif
+        {
+          printf("Error changing into %s, aborting\n", dirname);
+          exit(-1);
+        }
+
+        if (filename_to_extract == NULL)
+            ret_value = do_extract(uf, opt_do_extract_withoutpath, opt_overwrite, password);
+        else
+            ret_value = do_extract_onefile(uf, filename_to_extract, opt_do_extract_withoutpath, opt_overwrite, password);
+    }
+
+    unzClose(uf);
+
+    return ret_value;
+}
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/minizip/miniunzip.1 b/Engine/lib/assimp/contrib/zlib/contrib/minizip/miniunzip.1
new file mode 100644
index 000000000..111ac6919
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/minizip/miniunzip.1
@@ -0,0 +1,63 @@
+.\"                                      Hey, EMACS: -*- nroff -*-
+.TH miniunzip 1 "Nov 7, 2001"
+.\" Please adjust this date whenever revising the manpage.
+.\"
+.\" Some roff macros, for reference:
+.\" .nh        disable hyphenation
+.\" .hy        enable hyphenation
+.\" .ad l      left justify
+.\" .ad b      justify to both left and right margins
+.\" .nf        disable filling
+.\" .fi        enable filling
+.\" .br        insert line break
+.\" .sp <n>    insert n+1 empty lines
+.\" for manpage-specific macros, see man(7)
+.SH NAME
+miniunzip - uncompress and examine ZIP archives
+.SH SYNOPSIS
+.B miniunzip
+.RI [ -exvlo ]
+zipfile [ files_to_extract ] [-d tempdir]
+.SH DESCRIPTION
+.B minizip
+is a simple tool which allows the extraction of compressed file
+archives in the ZIP format used by the MS-DOS utility PKZIP.  It was
+written as a demonstration of the
+.IR zlib (3)
+library and therefore lack many of the features of the
+.IR unzip (1)
+program.
+.SH OPTIONS
+A number of options are supported.  With the exception of
+.BI \-d\  tempdir
+these must be supplied before any
+other arguments and are:
+.TP
+.BI \-l\ ,\ \-\-v
+List the files in the archive without extracting them.
+.TP
+.B \-o
+Overwrite files without prompting for confirmation.
+.TP
+.B \-x
+Extract files (default).
+.PP
+The
+.I zipfile
+argument is the name of the archive to process. The next argument can be used
+to specify a single file to extract from the archive.
+
+Lastly, the following option can be specified at the end of the command-line:
+.TP
+.BI \-d\  tempdir
+Extract the archive in the directory
+.I tempdir
+rather than the current directory.
+.SH SEE ALSO
+.BR minizip (1),
+.BR zlib (3),
+.BR unzip (1).
+.SH AUTHOR
+This program was written by Gilles Vollant.  This manual page was
+written by Mark Brown <broonie@sirena.org.uk>. The -d tempdir option
+was added by Dirk Eddelbuettel <edd@debian.org>.
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/minizip/minizip.1 b/Engine/lib/assimp/contrib/zlib/contrib/minizip/minizip.1
new file mode 100644
index 000000000..1154484c1
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/minizip/minizip.1
@@ -0,0 +1,46 @@
+.\"                                      Hey, EMACS: -*- nroff -*-
+.TH minizip 1 "May 2, 2001"
+.\" Please adjust this date whenever revising the manpage.
+.\"
+.\" Some roff macros, for reference:
+.\" .nh        disable hyphenation
+.\" .hy        enable hyphenation
+.\" .ad l      left justify
+.\" .ad b      justify to both left and right margins
+.\" .nf        disable filling
+.\" .fi        enable filling
+.\" .br        insert line break
+.\" .sp <n>    insert n+1 empty lines
+.\" for manpage-specific macros, see man(7)
+.SH NAME
+minizip - create ZIP archives
+.SH SYNOPSIS
+.B minizip
+.RI [ -o ]
+zipfile [ " files" ... ]
+.SH DESCRIPTION
+.B minizip
+is a simple tool which allows the creation of compressed file archives
+in the ZIP format used by the MS-DOS utility PKZIP.  It was written as
+a demonstration of the
+.IR zlib (3)
+library and therefore lack many of the features of the
+.IR zip (1)
+program.
+.SH OPTIONS
+The first argument supplied is the name of the ZIP archive to create or
+.RI -o
+in which case it is ignored and the second argument treated as the
+name of the ZIP file.  If the ZIP file already exists it will be
+overwritten.
+.PP
+Subsequent arguments specify a list of files to place in the ZIP
+archive.  If none are specified then an empty archive will be created.
+.SH SEE ALSO
+.BR miniunzip (1),
+.BR zlib (3),
+.BR zip (1).
+.SH AUTHOR
+This program was written by Gilles Vollant.  This manual page was
+written by Mark Brown <broonie@sirena.org.uk>.
+
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/minizip/minizip.c b/Engine/lib/assimp/contrib/zlib/contrib/minizip/minizip.c
new file mode 100644
index 000000000..4288962ec
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/minizip/minizip.c
@@ -0,0 +1,520 @@
+/*
+   minizip.c
+   Version 1.1, February 14h, 2010
+   sample part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Modifications of Unzip for Zip64
+         Copyright (C) 2007-2008 Even Rouault
+
+         Modifications for Zip64 support on both zip and unzip
+         Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+*/
+
+
+#if (!defined(_WIN32)) && (!defined(WIN32)) && (!defined(__APPLE__))
+        #ifndef __USE_FILE_OFFSET64
+                #define __USE_FILE_OFFSET64
+        #endif
+        #ifndef __USE_LARGEFILE64
+                #define __USE_LARGEFILE64
+        #endif
+        #ifndef _LARGEFILE64_SOURCE
+                #define _LARGEFILE64_SOURCE
+        #endif
+        #ifndef _FILE_OFFSET_BIT
+                #define _FILE_OFFSET_BIT 64
+        #endif
+#endif
+
+#ifdef __APPLE__
+// In darwin and perhaps other BSD variants off_t is a 64 bit value, hence no need for specific 64 bit functions
+#define FOPEN_FUNC(filename, mode) fopen(filename, mode)
+#define FTELLO_FUNC(stream) ftello(stream)
+#define FSEEKO_FUNC(stream, offset, origin) fseeko(stream, offset, origin)
+#else
+#define FOPEN_FUNC(filename, mode) fopen64(filename, mode)
+#define FTELLO_FUNC(stream) ftello64(stream)
+#define FSEEKO_FUNC(stream, offset, origin) fseeko64(stream, offset, origin)
+#endif
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <errno.h>
+#include <fcntl.h>
+
+#ifdef _WIN32
+# include <direct.h>
+# include <io.h>
+#else
+# include <unistd.h>
+# include <utime.h>
+# include <sys/types.h>
+# include <sys/stat.h>
+#endif
+
+#include "zip.h"
+
+#ifdef _WIN32
+        #define USEWIN32IOAPI
+        #include "iowin32.h"
+#endif
+
+
+
+#define WRITEBUFFERSIZE (16384)
+#define MAXFILENAME (256)
+
+#ifdef _WIN32
+uLong filetime(f, tmzip, dt)
+    char *f;                /* name of file to get info on */
+    tm_zip *tmzip;             /* return value: access, modific. and creation times */
+    uLong *dt;             /* dostime */
+{
+  int ret = 0;
+  {
+      FILETIME ftLocal;
+      HANDLE hFind;
+      WIN32_FIND_DATAA ff32;
+
+      hFind = FindFirstFileA(f,&ff32);
+      if (hFind != INVALID_HANDLE_VALUE)
+      {
+        FileTimeToLocalFileTime(&(ff32.ftLastWriteTime),&ftLocal);
+        FileTimeToDosDateTime(&ftLocal,((LPWORD)dt)+1,((LPWORD)dt)+0);
+        FindClose(hFind);
+        ret = 1;
+      }
+  }
+  return ret;
+}
+#else
+#ifdef unix || __APPLE__
+uLong filetime(f, tmzip, dt)
+    char *f;               /* name of file to get info on */
+    tm_zip *tmzip;         /* return value: access, modific. and creation times */
+    uLong *dt;             /* dostime */
+{
+  int ret=0;
+  struct stat s;        /* results of stat() */
+  struct tm* filedate;
+  time_t tm_t=0;
+
+  if (strcmp(f,"-")!=0)
+  {
+    char name[MAXFILENAME+1];
+    int len = strlen(f);
+    if (len > MAXFILENAME)
+      len = MAXFILENAME;
+
+    strncpy(name, f,MAXFILENAME-1);
+    /* strncpy doesnt append the trailing NULL, of the string is too long. */
+    name[ MAXFILENAME ] = '\0';
+
+    if (name[len - 1] == '/')
+      name[len - 1] = '\0';
+    /* not all systems allow stat'ing a file with / appended */
+    if (stat(name,&s)==0)
+    {
+      tm_t = s.st_mtime;
+      ret = 1;
+    }
+  }
+  filedate = localtime(&tm_t);
+
+  tmzip->tm_sec  = filedate->tm_sec;
+  tmzip->tm_min  = filedate->tm_min;
+  tmzip->tm_hour = filedate->tm_hour;
+  tmzip->tm_mday = filedate->tm_mday;
+  tmzip->tm_mon  = filedate->tm_mon ;
+  tmzip->tm_year = filedate->tm_year;
+
+  return ret;
+}
+#else
+uLong filetime(f, tmzip, dt)
+    char *f;                /* name of file to get info on */
+    tm_zip *tmzip;             /* return value: access, modific. and creation times */
+    uLong *dt;             /* dostime */
+{
+    return 0;
+}
+#endif
+#endif
+
+
+
+
+int check_exist_file(filename)
+    const char* filename;
+{
+    FILE* ftestexist;
+    int ret = 1;
+    ftestexist = FOPEN_FUNC(filename,"rb");
+    if (ftestexist==NULL)
+        ret = 0;
+    else
+        fclose(ftestexist);
+    return ret;
+}
+
+void do_banner()
+{
+    printf("MiniZip 1.1, demo of zLib + MiniZip64 package, written by Gilles Vollant\n");
+    printf("more info on MiniZip at http://www.winimage.com/zLibDll/minizip.html\n\n");
+}
+
+void do_help()
+{
+    printf("Usage : minizip [-o] [-a] [-0 to -9] [-p password] [-j] file.zip [files_to_add]\n\n" \
+           "  -o  Overwrite existing file.zip\n" \
+           "  -a  Append to existing file.zip\n" \
+           "  -0  Store only\n" \
+           "  -1  Compress faster\n" \
+           "  -9  Compress better\n\n" \
+           "  -j  exclude path. store only the file name.\n\n");
+}
+
+/* calculate the CRC32 of a file,
+   because to encrypt a file, we need known the CRC32 of the file before */
+int getFileCrc(const char* filenameinzip,void*buf,unsigned long size_buf,unsigned long* result_crc)
+{
+   unsigned long calculate_crc=0;
+   int err=ZIP_OK;
+   FILE * fin = FOPEN_FUNC(filenameinzip,"rb");
+
+   unsigned long size_read = 0;
+   unsigned long total_read = 0;
+   if (fin==NULL)
+   {
+       err = ZIP_ERRNO;
+   }
+
+    if (err == ZIP_OK)
+        do
+        {
+            err = ZIP_OK;
+            size_read = (int)fread(buf,1,size_buf,fin);
+            if (size_read < size_buf)
+                if (feof(fin)==0)
+            {
+                printf("error in reading %s\n",filenameinzip);
+                err = ZIP_ERRNO;
+            }
+
+            if (size_read>0)
+                calculate_crc = crc32(calculate_crc,buf,size_read);
+            total_read += size_read;
+
+        } while ((err == ZIP_OK) && (size_read>0));
+
+    if (fin)
+        fclose(fin);
+
+    *result_crc=calculate_crc;
+    printf("file %s crc %lx\n", filenameinzip, calculate_crc);
+    return err;
+}
+
+int isLargeFile(const char* filename)
+{
+  int largeFile = 0;
+  ZPOS64_T pos = 0;
+  FILE* pFile = FOPEN_FUNC(filename, "rb");
+
+  if(pFile != NULL)
+  {
+    int n = FSEEKO_FUNC(pFile, 0, SEEK_END);
+    pos = FTELLO_FUNC(pFile);
+
+                printf("File : %s is %lld bytes\n", filename, pos);
+
+    if(pos >= 0xffffffff)
+     largeFile = 1;
+
+                fclose(pFile);
+  }
+
+ return largeFile;
+}
+
+int main(argc,argv)
+    int argc;
+    char *argv[];
+{
+    int i;
+    int opt_overwrite=0;
+    int opt_compress_level=Z_DEFAULT_COMPRESSION;
+    int opt_exclude_path=0;
+    int zipfilenamearg = 0;
+    char filename_try[MAXFILENAME+16];
+    int zipok;
+    int err=0;
+    int size_buf=0;
+    void* buf=NULL;
+    const char* password=NULL;
+
+
+    do_banner();
+    if (argc==1)
+    {
+        do_help();
+        return 0;
+    }
+    else
+    {
+        for (i=1;i<argc;i++)
+        {
+            if ((*argv[i])=='-')
+            {
+                const char *p=argv[i]+1;
+
+                while ((*p)!='\0')
+                {
+                    char c=*(p++);;
+                    if ((c=='o') || (c=='O'))
+                        opt_overwrite = 1;
+                    if ((c=='a') || (c=='A'))
+                        opt_overwrite = 2;
+                    if ((c>='0') && (c<='9'))
+                        opt_compress_level = c-'0';
+                    if ((c=='j') || (c=='J'))
+                        opt_exclude_path = 1;
+
+                    if (((c=='p') || (c=='P')) && (i+1<argc))
+                    {
+                        password=argv[i+1];
+                        i++;
+                    }
+                }
+            }
+            else
+            {
+                if (zipfilenamearg == 0)
+                {
+                    zipfilenamearg = i ;
+                }
+            }
+        }
+    }
+
+    size_buf = WRITEBUFFERSIZE;
+    buf = (void*)malloc(size_buf);
+    if (buf==NULL)
+    {
+        printf("Error allocating memory\n");
+        return ZIP_INTERNALERROR;
+    }
+
+    if (zipfilenamearg==0)
+    {
+        zipok=0;
+    }
+    else
+    {
+        int i,len;
+        int dot_found=0;
+
+        zipok = 1 ;
+        strncpy(filename_try, argv[zipfilenamearg],MAXFILENAME-1);
+        /* strncpy doesnt append the trailing NULL, of the string is too long. */
+        filename_try[ MAXFILENAME ] = '\0';
+
+        len=(int)strlen(filename_try);
+        for (i=0;i<len;i++)
+            if (filename_try[i]=='.')
+                dot_found=1;
+
+        if (dot_found==0)
+            strcat(filename_try,".zip");
+
+        if (opt_overwrite==2)
+        {
+            /* if the file don't exist, we not append file */
+            if (check_exist_file(filename_try)==0)
+                opt_overwrite=1;
+        }
+        else
+        if (opt_overwrite==0)
+            if (check_exist_file(filename_try)!=0)
+            {
+                char rep=0;
+                do
+                {
+                    char answer[128];
+                    int ret;
+                    printf("The file %s exists. Overwrite ? [y]es, [n]o, [a]ppend : ",filename_try);
+                    ret = scanf("%1s",answer);
+                    if (ret != 1)
+                    {
+                       exit(EXIT_FAILURE);
+                    }
+                    rep = answer[0] ;
+                    if ((rep>='a') && (rep<='z'))
+                        rep -= 0x20;
+                }
+                while ((rep!='Y') && (rep!='N') && (rep!='A'));
+                if (rep=='N')
+                    zipok = 0;
+                if (rep=='A')
+                    opt_overwrite = 2;
+            }
+    }
+
+    if (zipok==1)
+    {
+        zipFile zf;
+        int errclose;
+#        ifdef USEWIN32IOAPI
+        zlib_filefunc64_def ffunc;
+        fill_win32_filefunc64A(&ffunc);
+        zf = zipOpen2_64(filename_try,(opt_overwrite==2) ? 2 : 0,NULL,&ffunc);
+#        else
+        zf = zipOpen64(filename_try,(opt_overwrite==2) ? 2 : 0);
+#        endif
+
+        if (zf == NULL)
+        {
+            printf("error opening %s\n",filename_try);
+            err= ZIP_ERRNO;
+        }
+        else
+            printf("creating %s\n",filename_try);
+
+        for (i=zipfilenamearg+1;(i<argc) && (err==ZIP_OK);i++)
+        {
+            if (!((((*(argv[i]))=='-') || ((*(argv[i]))=='/')) &&
+                  ((argv[i][1]=='o') || (argv[i][1]=='O') ||
+                   (argv[i][1]=='a') || (argv[i][1]=='A') ||
+                   (argv[i][1]=='p') || (argv[i][1]=='P') ||
+                   ((argv[i][1]>='0') || (argv[i][1]<='9'))) &&
+                  (strlen(argv[i]) == 2)))
+            {
+                FILE * fin;
+                int size_read;
+                const char* filenameinzip = argv[i];
+                const char *savefilenameinzip;
+                zip_fileinfo zi;
+                unsigned long crcFile=0;
+                int zip64 = 0;
+
+                zi.tmz_date.tm_sec = zi.tmz_date.tm_min = zi.tmz_date.tm_hour =
+                zi.tmz_date.tm_mday = zi.tmz_date.tm_mon = zi.tmz_date.tm_year = 0;
+                zi.dosDate = 0;
+                zi.internal_fa = 0;
+                zi.external_fa = 0;
+                filetime(filenameinzip,&zi.tmz_date,&zi.dosDate);
+
+/*
+                err = zipOpenNewFileInZip(zf,filenameinzip,&zi,
+                                 NULL,0,NULL,0,NULL / * comment * /,
+                                 (opt_compress_level != 0) ? Z_DEFLATED : 0,
+                                 opt_compress_level);
+*/
+                if ((password != NULL) && (err==ZIP_OK))
+                    err = getFileCrc(filenameinzip,buf,size_buf,&crcFile);
+
+                zip64 = isLargeFile(filenameinzip);
+
+                                                         /* The path name saved, should not include a leading slash. */
+               /*if it did, windows/xp and dynazip couldn't read the zip file. */
+                 savefilenameinzip = filenameinzip;
+                 while( savefilenameinzip[0] == '\\' || savefilenameinzip[0] == '/' )
+                 {
+                     savefilenameinzip++;
+                 }
+
+                 /*should the zip file contain any path at all?*/
+                 if( opt_exclude_path )
+                 {
+                     const char *tmpptr;
+                     const char *lastslash = 0;
+                     for( tmpptr = savefilenameinzip; *tmpptr; tmpptr++)
+                     {
+                         if( *tmpptr == '\\' || *tmpptr == '/')
+                         {
+                             lastslash = tmpptr;
+                         }
+                     }
+                     if( lastslash != NULL )
+                     {
+                         savefilenameinzip = lastslash+1; // base filename follows last slash.
+                     }
+                 }
+
+                 /**/
+                err = zipOpenNewFileInZip3_64(zf,savefilenameinzip,&zi,
+                                 NULL,0,NULL,0,NULL /* comment*/,
+                                 (opt_compress_level != 0) ? Z_DEFLATED : 0,
+                                 opt_compress_level,0,
+                                 /* -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, */
+                                 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
+                                 password,crcFile, zip64);
+
+                if (err != ZIP_OK)
+                    printf("error in opening %s in zipfile\n",filenameinzip);
+                else
+                {
+                    fin = FOPEN_FUNC(filenameinzip,"rb");
+                    if (fin==NULL)
+                    {
+                        err=ZIP_ERRNO;
+                        printf("error in opening %s for reading\n",filenameinzip);
+                    }
+                }
+
+                if (err == ZIP_OK)
+                    do
+                    {
+                        err = ZIP_OK;
+                        size_read = (int)fread(buf,1,size_buf,fin);
+                        if (size_read < size_buf)
+                            if (feof(fin)==0)
+                        {
+                            printf("error in reading %s\n",filenameinzip);
+                            err = ZIP_ERRNO;
+                        }
+
+                        if (size_read>0)
+                        {
+                            err = zipWriteInFileInZip (zf,buf,size_read);
+                            if (err<0)
+                            {
+                                printf("error in writing %s in the zipfile\n",
+                                                 filenameinzip);
+                            }
+
+                        }
+                    } while ((err == ZIP_OK) && (size_read>0));
+
+                if (fin)
+                    fclose(fin);
+
+                if (err<0)
+                    err=ZIP_ERRNO;
+                else
+                {
+                    err = zipCloseFileInZip(zf);
+                    if (err!=ZIP_OK)
+                        printf("error in closing %s in the zipfile\n",
+                                    filenameinzip);
+                }
+            }
+        }
+        errclose = zipClose(zf,NULL);
+        if (errclose != ZIP_OK)
+            printf("error in closing %s\n",filename_try);
+    }
+    else
+    {
+       do_help();
+    }
+
+    free(buf);
+    return 0;
+}
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/minizip/minizip.pc.in b/Engine/lib/assimp/contrib/zlib/contrib/minizip/minizip.pc.in
new file mode 100644
index 000000000..69b5b7fdc
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/minizip/minizip.pc.in
@@ -0,0 +1,12 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@/minizip
+
+Name: minizip
+Description: Minizip zip file manipulation library
+Requires:
+Version: @PACKAGE_VERSION@
+Libs: -L${libdir} -lminizip
+Libs.private: -lz
+Cflags: -I${includedir}
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/minizip/mztools.c b/Engine/lib/assimp/contrib/zlib/contrib/minizip/mztools.c
new file mode 100644
index 000000000..96891c2e0
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/minizip/mztools.c
@@ -0,0 +1,291 @@
+/*
+  Additional tools for Minizip
+  Code: Xavier Roche '2004
+  License: Same as ZLIB (www.gzip.org)
+*/
+
+/* Code */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "zlib.h"
+#include "unzip.h"
+
+#define READ_8(adr)  ((unsigned char)*(adr))
+#define READ_16(adr) ( READ_8(adr) | (READ_8(adr+1) << 8) )
+#define READ_32(adr) ( READ_16(adr) | (READ_16((adr)+2) << 16) )
+
+#define WRITE_8(buff, n) do { \
+  *((unsigned char*)(buff)) = (unsigned char) ((n) & 0xff); \
+} while(0)
+#define WRITE_16(buff, n) do { \
+  WRITE_8((unsigned char*)(buff), n); \
+  WRITE_8(((unsigned char*)(buff)) + 1, (n) >> 8); \
+} while(0)
+#define WRITE_32(buff, n) do { \
+  WRITE_16((unsigned char*)(buff), (n) & 0xffff); \
+  WRITE_16((unsigned char*)(buff) + 2, (n) >> 16); \
+} while(0)
+
+extern int ZEXPORT unzRepair(file, fileOut, fileOutTmp, nRecovered, bytesRecovered)
+const char* file;
+const char* fileOut;
+const char* fileOutTmp;
+uLong* nRecovered;
+uLong* bytesRecovered;
+{
+  int err = Z_OK;
+  FILE* fpZip = fopen(file, "rb");
+  FILE* fpOut = fopen(fileOut, "wb");
+  FILE* fpOutCD = fopen(fileOutTmp, "wb");
+  if (fpZip != NULL &&  fpOut != NULL) {
+    int entries = 0;
+    uLong totalBytes = 0;
+    char header[30];
+    char filename[1024];
+    char extra[1024];
+    int offset = 0;
+    int offsetCD = 0;
+    while ( fread(header, 1, 30, fpZip) == 30 ) {
+      int currentOffset = offset;
+
+      /* File entry */
+      if (READ_32(header) == 0x04034b50) {
+        unsigned int version = READ_16(header + 4);
+        unsigned int gpflag = READ_16(header + 6);
+        unsigned int method = READ_16(header + 8);
+        unsigned int filetime = READ_16(header + 10);
+        unsigned int filedate = READ_16(header + 12);
+        unsigned int crc = READ_32(header + 14); /* crc */
+        unsigned int cpsize = READ_32(header + 18); /* compressed size */
+        unsigned int uncpsize = READ_32(header + 22); /* uncompressed sz */
+        unsigned int fnsize = READ_16(header + 26); /* file name length */
+        unsigned int extsize = READ_16(header + 28); /* extra field length */
+        filename[0] = extra[0] = '\0';
+
+        /* Header */
+        if (fwrite(header, 1, 30, fpOut) == 30) {
+          offset += 30;
+        } else {
+          err = Z_ERRNO;
+          break;
+        }
+
+        /* Filename */
+        if (fnsize > 0) {
+          if (fnsize < sizeof(filename)) {
+            if (fread(filename, 1, fnsize, fpZip) == fnsize) {
+                if (fwrite(filename, 1, fnsize, fpOut) == fnsize) {
+                offset += fnsize;
+              } else {
+                err = Z_ERRNO;
+                break;
+              }
+            } else {
+              err = Z_ERRNO;
+              break;
+            }
+          } else {
+            err = Z_ERRNO;
+            break;
+          }
+        } else {
+          err = Z_STREAM_ERROR;
+          break;
+        }
+
+        /* Extra field */
+        if (extsize > 0) {
+          if (extsize < sizeof(extra)) {
+            if (fread(extra, 1, extsize, fpZip) == extsize) {
+              if (fwrite(extra, 1, extsize, fpOut) == extsize) {
+                offset += extsize;
+                } else {
+                err = Z_ERRNO;
+                break;
+              }
+            } else {
+              err = Z_ERRNO;
+              break;
+            }
+          } else {
+            err = Z_ERRNO;
+            break;
+          }
+        }
+
+        /* Data */
+        {
+          int dataSize = cpsize;
+          if (dataSize == 0) {
+            dataSize = uncpsize;
+          }
+          if (dataSize > 0) {
+            char* data = malloc(dataSize);
+            if (data != NULL) {
+              if ((int)fread(data, 1, dataSize, fpZip) == dataSize) {
+                if ((int)fwrite(data, 1, dataSize, fpOut) == dataSize) {
+                  offset += dataSize;
+                  totalBytes += dataSize;
+                } else {
+                  err = Z_ERRNO;
+                }
+              } else {
+                err = Z_ERRNO;
+              }
+              free(data);
+              if (err != Z_OK) {
+                break;
+              }
+            } else {
+              err = Z_MEM_ERROR;
+              break;
+            }
+          }
+        }
+
+        /* Central directory entry */
+        {
+          char header[46];
+          char* comment = "";
+          int comsize = (int) strlen(comment);
+          WRITE_32(header, 0x02014b50);
+          WRITE_16(header + 4, version);
+          WRITE_16(header + 6, version);
+          WRITE_16(header + 8, gpflag);
+          WRITE_16(header + 10, method);
+          WRITE_16(header + 12, filetime);
+          WRITE_16(header + 14, filedate);
+          WRITE_32(header + 16, crc);
+          WRITE_32(header + 20, cpsize);
+          WRITE_32(header + 24, uncpsize);
+          WRITE_16(header + 28, fnsize);
+          WRITE_16(header + 30, extsize);
+          WRITE_16(header + 32, comsize);
+          WRITE_16(header + 34, 0);     /* disk # */
+          WRITE_16(header + 36, 0);     /* int attrb */
+          WRITE_32(header + 38, 0);     /* ext attrb */
+          WRITE_32(header + 42, currentOffset);
+          /* Header */
+          if (fwrite(header, 1, 46, fpOutCD) == 46) {
+            offsetCD += 46;
+
+            /* Filename */
+            if (fnsize > 0) {
+              if (fwrite(filename, 1, fnsize, fpOutCD) == fnsize) {
+                offsetCD += fnsize;
+              } else {
+                err = Z_ERRNO;
+                break;
+              }
+            } else {
+              err = Z_STREAM_ERROR;
+              break;
+            }
+
+            /* Extra field */
+            if (extsize > 0) {
+              if (fwrite(extra, 1, extsize, fpOutCD) == extsize) {
+                offsetCD += extsize;
+              } else {
+                err = Z_ERRNO;
+                break;
+              }
+            }
+
+            /* Comment field */
+            if (comsize > 0) {
+              if ((int)fwrite(comment, 1, comsize, fpOutCD) == comsize) {
+                offsetCD += comsize;
+              } else {
+                err = Z_ERRNO;
+                break;
+              }
+            }
+
+
+          } else {
+            err = Z_ERRNO;
+            break;
+          }
+        }
+
+        /* Success */
+        entries++;
+
+      } else {
+        break;
+      }
+    }
+
+    /* Final central directory  */
+    {
+      int entriesZip = entries;
+      char header[22];
+      char* comment = ""; // "ZIP File recovered by zlib/minizip/mztools";
+      int comsize = (int) strlen(comment);
+      if (entriesZip > 0xffff) {
+        entriesZip = 0xffff;
+      }
+      WRITE_32(header, 0x06054b50);
+      WRITE_16(header + 4, 0);    /* disk # */
+      WRITE_16(header + 6, 0);    /* disk # */
+      WRITE_16(header + 8, entriesZip);   /* hack */
+      WRITE_16(header + 10, entriesZip);  /* hack */
+      WRITE_32(header + 12, offsetCD);    /* size of CD */
+      WRITE_32(header + 16, offset);      /* offset to CD */
+      WRITE_16(header + 20, comsize);     /* comment */
+
+      /* Header */
+      if (fwrite(header, 1, 22, fpOutCD) == 22) {
+
+        /* Comment field */
+        if (comsize > 0) {
+          if ((int)fwrite(comment, 1, comsize, fpOutCD) != comsize) {
+            err = Z_ERRNO;
+          }
+        }
+
+      } else {
+        err = Z_ERRNO;
+      }
+    }
+
+    /* Final merge (file + central directory) */
+    fclose(fpOutCD);
+    if (err == Z_OK) {
+      fpOutCD = fopen(fileOutTmp, "rb");
+      if (fpOutCD != NULL) {
+        int nRead;
+        char buffer[8192];
+        while ( (nRead = (int)fread(buffer, 1, sizeof(buffer), fpOutCD)) > 0) {
+          if ((int)fwrite(buffer, 1, nRead, fpOut) != nRead) {
+            err = Z_ERRNO;
+            break;
+          }
+        }
+        fclose(fpOutCD);
+      }
+    }
+
+    /* Close */
+    fclose(fpZip);
+    fclose(fpOut);
+
+    /* Wipe temporary file */
+    (void)remove(fileOutTmp);
+
+    /* Number of recovered entries */
+    if (err == Z_OK) {
+      if (nRecovered != NULL) {
+        *nRecovered = entries;
+      }
+      if (bytesRecovered != NULL) {
+        *bytesRecovered = totalBytes;
+      }
+    }
+  } else {
+    err = Z_STREAM_ERROR;
+  }
+  return err;
+}
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/minizip/mztools.h b/Engine/lib/assimp/contrib/zlib/contrib/minizip/mztools.h
new file mode 100644
index 000000000..a49a426ec
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/minizip/mztools.h
@@ -0,0 +1,37 @@
+/*
+  Additional tools for Minizip
+  Code: Xavier Roche '2004
+  License: Same as ZLIB (www.gzip.org)
+*/
+
+#ifndef _zip_tools_H
+#define _zip_tools_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef _ZLIB_H
+#include "zlib.h"
+#endif
+
+#include "unzip.h"
+
+/* Repair a ZIP file (missing central directory)
+   file: file to recover
+   fileOut: output file after recovery
+   fileOutTmp: temporary file name used for recovery
+*/
+extern int ZEXPORT unzRepair(const char* file,
+                             const char* fileOut,
+                             const char* fileOutTmp,
+                             uLong* nRecovered,
+                             uLong* bytesRecovered);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/minizip/unzip.c b/Engine/lib/assimp/contrib/zlib/contrib/minizip/unzip.c
new file mode 100644
index 000000000..bcfb9416e
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/minizip/unzip.c
@@ -0,0 +1,2125 @@
+/* unzip.c -- IO for uncompress .zip files using zlib
+   Version 1.1, February 14h, 2010
+   part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Modifications of Unzip for Zip64
+         Copyright (C) 2007-2008 Even Rouault
+
+         Modifications for Zip64 support on both zip and unzip
+         Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+
+         For more info read MiniZip_info.txt
+
+
+  ------------------------------------------------------------------------------------
+  Decryption code comes from crypt.c by Info-ZIP but has been greatly reduced in terms of
+  compatibility with older software. The following is from the original crypt.c.
+  Code woven in by Terry Thorsen 1/2003.
+
+  Copyright (c) 1990-2000 Info-ZIP.  All rights reserved.
+
+  See the accompanying file LICENSE, version 2000-Apr-09 or later
+  (the contents of which are also included in zip.h) for terms of use.
+  If, for some reason, all these files are missing, the Info-ZIP license
+  also may be found at:  ftp://ftp.info-zip.org/pub/infozip/license.html
+
+        crypt.c (full version) by Info-ZIP.      Last revised:  [see crypt.h]
+
+  The encryption/decryption parts of this source code (as opposed to the
+  non-echoing password parts) were originally written in Europe.  The
+  whole source package can be freely distributed, including from the USA.
+  (Prior to January 2000, re-export from the US was a violation of US law.)
+
+        This encryption code is a direct transcription of the algorithm from
+  Roger Schlafly, described by Phil Katz in the file appnote.txt.  This
+  file (appnote.txt) is distributed with the PKZIP program (even in the
+  version without encryption capabilities).
+
+        ------------------------------------------------------------------------------------
+
+        Changes in unzip.c
+
+        2007-2008 - Even Rouault - Addition of cpl_unzGetCurrentFileZStreamPos
+  2007-2008 - Even Rouault - Decoration of symbol names unz* -> cpl_unz*
+  2007-2008 - Even Rouault - Remove old C style function prototypes
+  2007-2008 - Even Rouault - Add unzip support for ZIP64
+
+        Copyright (C) 2007-2008 Even Rouault
+
+
+        Oct-2009 - Mathias Svensson - Removed cpl_* from symbol names (Even Rouault added them but since this is now moved to a new project (minizip64) I renamed them again).
+  Oct-2009 - Mathias Svensson - Fixed problem if uncompressed size was > 4G and compressed size was <4G
+                                should only read the compressed/uncompressed size from the Zip64 format if
+                                the size from normal header was 0xFFFFFFFF
+  Oct-2009 - Mathias Svensson - Applied some bug fixes from paches recived from Gilles Vollant
+        Oct-2009 - Mathias Svensson - Applied support to unzip files with compression mathod BZIP2 (bzip2 lib is required)
+                                Patch created by Daniel Borca
+
+  Jan-2010 - back to unzip and minizip 1.0 name scheme, with compatibility layer
+
+  Copyright (C) 1998 - 2010 Gilles Vollant, Even Rouault, Mathias Svensson
+
+*/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef NOUNCRYPT
+        #define NOUNCRYPT
+#endif
+
+#include "zlib.h"
+#include "unzip.h"
+
+#ifdef STDC
+#  include <stddef.h>
+#  include <string.h>
+#  include <stdlib.h>
+#endif
+#ifdef NO_ERRNO_H
+    extern int errno;
+#else
+#   include <errno.h>
+#endif
+
+
+#ifndef local
+#  define local static
+#endif
+/* compile with -Dlocal if your debugger can't find static symbols */
+
+
+#ifndef CASESENSITIVITYDEFAULT_NO
+#  if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES)
+#    define CASESENSITIVITYDEFAULT_NO
+#  endif
+#endif
+
+
+#ifndef UNZ_BUFSIZE
+#define UNZ_BUFSIZE (16384)
+#endif
+
+#ifndef UNZ_MAXFILENAMEINZIP
+#define UNZ_MAXFILENAMEINZIP (256)
+#endif
+
+#ifndef ALLOC
+# define ALLOC(size) (malloc(size))
+#endif
+#ifndef TRYFREE
+# define TRYFREE(p) {if (p) free(p);}
+#endif
+
+#define SIZECENTRALDIRITEM (0x2e)
+#define SIZEZIPLOCALHEADER (0x1e)
+
+
+const char unz_copyright[] =
+   " unzip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll";
+
+/* unz_file_info_interntal contain internal info about a file in zipfile*/
+typedef struct unz_file_info64_internal_s
+{
+    ZPOS64_T offset_curfile;/* relative offset of local header 8 bytes */
+} unz_file_info64_internal;
+
+
+/* file_in_zip_read_info_s contain internal information about a file in zipfile,
+    when reading and decompress it */
+typedef struct
+{
+    char  *read_buffer;         /* internal buffer for compressed data */
+    z_stream stream;            /* zLib stream structure for inflate */
+
+#ifdef HAVE_BZIP2
+    bz_stream bstream;          /* bzLib stream structure for bziped */
+#endif
+
+    ZPOS64_T pos_in_zipfile;       /* position in byte on the zipfile, for fseek*/
+    uLong stream_initialised;   /* flag set if stream structure is initialised*/
+
+    ZPOS64_T offset_local_extrafield;/* offset of the local extra field */
+    uInt  size_local_extrafield;/* size of the local extra field */
+    ZPOS64_T pos_local_extrafield;   /* position in the local extra field in read*/
+    ZPOS64_T total_out_64;
+
+    uLong crc32;                /* crc32 of all data uncompressed */
+    uLong crc32_wait;           /* crc32 we must obtain after decompress all */
+    ZPOS64_T rest_read_compressed; /* number of byte to be decompressed */
+    ZPOS64_T rest_read_uncompressed;/*number of byte to be obtained after decomp*/
+    zlib_filefunc64_32_def z_filefunc;
+    voidpf filestream;        /* io structore of the zipfile */
+    uLong compression_method;   /* compression method (0==store) */
+    ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
+    int   raw;
+} file_in_zip64_read_info_s;
+
+
+/* unz64_s contain internal information about the zipfile
+*/
+typedef struct
+{
+    zlib_filefunc64_32_def z_filefunc;
+    int is64bitOpenFunction;
+    voidpf filestream;        /* io structore of the zipfile */
+    unz_global_info64 gi;       /* public global information */
+    ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
+    ZPOS64_T num_file;             /* number of the current file in the zipfile*/
+    ZPOS64_T pos_in_central_dir;   /* pos of the current file in the central dir*/
+    ZPOS64_T current_file_ok;      /* flag about the usability of the current file*/
+    ZPOS64_T central_pos;          /* position of the beginning of the central dir*/
+
+    ZPOS64_T size_central_dir;     /* size of the central directory  */
+    ZPOS64_T offset_central_dir;   /* offset of start of central directory with
+                                   respect to the starting disk number */
+
+    unz_file_info64 cur_file_info; /* public info about the current file in zip*/
+    unz_file_info64_internal cur_file_info_internal; /* private info about it*/
+    file_in_zip64_read_info_s* pfile_in_zip_read; /* structure about the current
+                                        file if we are decompressing it */
+    int encrypted;
+
+    int isZip64;
+
+#    ifndef NOUNCRYPT
+    unsigned long keys[3];     /* keys defining the pseudo-random sequence */
+    const z_crc_t* pcrc_32_tab;
+#    endif
+} unz64_s;
+
+
+#ifndef NOUNCRYPT
+#include "crypt.h"
+#endif
+
+/* ===========================================================================
+     Read a byte from a gz_stream; update next_in and avail_in. Return EOF
+   for end of file.
+   IN assertion: the stream s has been successfully opened for reading.
+*/
+
+
+local int unz64local_getByte OF((
+    const zlib_filefunc64_32_def* pzlib_filefunc_def,
+    voidpf filestream,
+    int *pi));
+
+local int unz64local_getByte(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, int *pi)
+{
+    unsigned char c;
+    int err = (int)ZREAD64(*pzlib_filefunc_def,filestream,&c,1);
+    if (err==1)
+    {
+        *pi = (int)c;
+        return UNZ_OK;
+    }
+    else
+    {
+        if (ZERROR64(*pzlib_filefunc_def,filestream))
+            return UNZ_ERRNO;
+        else
+            return UNZ_EOF;
+    }
+}
+
+
+/* ===========================================================================
+   Reads a long in LSB order from the given gz_stream. Sets
+*/
+local int unz64local_getShort OF((
+    const zlib_filefunc64_32_def* pzlib_filefunc_def,
+    voidpf filestream,
+    uLong *pX));
+
+local int unz64local_getShort (const zlib_filefunc64_32_def* pzlib_filefunc_def,
+                             voidpf filestream,
+                             uLong *pX)
+{
+    uLong x ;
+    int i = 0;
+    int err;
+
+    err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
+    x = (uLong)i;
+
+    if (err==UNZ_OK)
+        err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
+    x |= ((uLong)i)<<8;
+
+    if (err==UNZ_OK)
+        *pX = x;
+    else
+        *pX = 0;
+    return err;
+}
+
+local int unz64local_getLong OF((
+    const zlib_filefunc64_32_def* pzlib_filefunc_def,
+    voidpf filestream,
+    uLong *pX));
+
+local int unz64local_getLong (const zlib_filefunc64_32_def* pzlib_filefunc_def,
+                            voidpf filestream,
+                            uLong *pX)
+{
+    uLong x ;
+    int i = 0;
+    int err;
+
+    err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
+    x = (uLong)i;
+
+    if (err==UNZ_OK)
+        err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
+    x |= ((uLong)i)<<8;
+
+    if (err==UNZ_OK)
+        err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
+    x |= ((uLong)i)<<16;
+
+    if (err==UNZ_OK)
+        err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
+    x += ((uLong)i)<<24;
+
+    if (err==UNZ_OK)
+        *pX = x;
+    else
+        *pX = 0;
+    return err;
+}
+
+local int unz64local_getLong64 OF((
+    const zlib_filefunc64_32_def* pzlib_filefunc_def,
+    voidpf filestream,
+    ZPOS64_T *pX));
+
+
+local int unz64local_getLong64 (const zlib_filefunc64_32_def* pzlib_filefunc_def,
+                            voidpf filestream,
+                            ZPOS64_T *pX)
+{
+    ZPOS64_T x ;
+    int i = 0;
+    int err;
+
+    err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
+    x = (ZPOS64_T)i;
+
+    if (err==UNZ_OK)
+        err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
+    x |= ((ZPOS64_T)i)<<8;
+
+    if (err==UNZ_OK)
+        err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
+    x |= ((ZPOS64_T)i)<<16;
+
+    if (err==UNZ_OK)
+        err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
+    x |= ((ZPOS64_T)i)<<24;
+
+    if (err==UNZ_OK)
+        err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
+    x |= ((ZPOS64_T)i)<<32;
+
+    if (err==UNZ_OK)
+        err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
+    x |= ((ZPOS64_T)i)<<40;
+
+    if (err==UNZ_OK)
+        err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
+    x |= ((ZPOS64_T)i)<<48;
+
+    if (err==UNZ_OK)
+        err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
+    x |= ((ZPOS64_T)i)<<56;
+
+    if (err==UNZ_OK)
+        *pX = x;
+    else
+        *pX = 0;
+    return err;
+}
+
+/* My own strcmpi / strcasecmp */
+local int strcmpcasenosensitive_internal (const char* fileName1, const char* fileName2)
+{
+    for (;;)
+    {
+        char c1=*(fileName1++);
+        char c2=*(fileName2++);
+        if ((c1>='a') && (c1<='z'))
+            c1 -= 0x20;
+        if ((c2>='a') && (c2<='z'))
+            c2 -= 0x20;
+        if (c1=='\0')
+            return ((c2=='\0') ? 0 : -1);
+        if (c2=='\0')
+            return 1;
+        if (c1<c2)
+            return -1;
+        if (c1>c2)
+            return 1;
+    }
+}
+
+
+#ifdef  CASESENSITIVITYDEFAULT_NO
+#define CASESENSITIVITYDEFAULTVALUE 2
+#else
+#define CASESENSITIVITYDEFAULTVALUE 1
+#endif
+
+#ifndef STRCMPCASENOSENTIVEFUNCTION
+#define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal
+#endif
+
+/*
+   Compare two filename (fileName1,fileName2).
+   If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
+   If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
+                                                                or strcasecmp)
+   If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
+        (like 1 on Unix, 2 on Windows)
+
+*/
+extern int ZEXPORT unzStringFileNameCompare (const char*  fileName1,
+                                                 const char*  fileName2,
+                                                 int iCaseSensitivity)
+
+{
+    if (iCaseSensitivity==0)
+        iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;
+
+    if (iCaseSensitivity==1)
+        return strcmp(fileName1,fileName2);
+
+    return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2);
+}
+
+#ifndef BUFREADCOMMENT
+#define BUFREADCOMMENT (0x400)
+#endif
+
+/*
+  Locate the Central directory of a zipfile (at the end, just before
+    the global comment)
+*/
+local ZPOS64_T unz64local_SearchCentralDir OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream));
+local ZPOS64_T unz64local_SearchCentralDir(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)
+{
+    unsigned char* buf;
+    ZPOS64_T uSizeFile;
+    ZPOS64_T uBackRead;
+    ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
+    ZPOS64_T uPosFound=0;
+
+    if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
+        return 0;
+
+
+    uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);
+
+    if (uMaxBack>uSizeFile)
+        uMaxBack = uSizeFile;
+
+    buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
+    if (buf==NULL)
+        return 0;
+
+    uBackRead = 4;
+    while (uBackRead<uMaxBack)
+    {
+        uLong uReadSize;
+        ZPOS64_T uReadPos ;
+        int i;
+        if (uBackRead+BUFREADCOMMENT>uMaxBack)
+            uBackRead = uMaxBack;
+        else
+            uBackRead+=BUFREADCOMMENT;
+        uReadPos = uSizeFile-uBackRead ;
+
+        uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
+                     (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
+        if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
+            break;
+
+        if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
+            break;
+
+        for (i=(int)uReadSize-3; (i--)>0;)
+            if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
+                ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
+            {
+                uPosFound = uReadPos+i;
+                break;
+            }
+
+        if (uPosFound!=0)
+            break;
+    }
+    TRYFREE(buf);
+    return uPosFound;
+}
+
+
+/*
+  Locate the Central directory 64 of a zipfile (at the end, just before
+    the global comment)
+*/
+local ZPOS64_T unz64local_SearchCentralDir64 OF((
+    const zlib_filefunc64_32_def* pzlib_filefunc_def,
+    voidpf filestream));
+
+local ZPOS64_T unz64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib_filefunc_def,
+                                      voidpf filestream)
+{
+    unsigned char* buf;
+    ZPOS64_T uSizeFile;
+    ZPOS64_T uBackRead;
+    ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
+    ZPOS64_T uPosFound=0;
+    uLong uL;
+                ZPOS64_T relativeOffset;
+
+    if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
+        return 0;
+
+
+    uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);
+
+    if (uMaxBack>uSizeFile)
+        uMaxBack = uSizeFile;
+
+    buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
+    if (buf==NULL)
+        return 0;
+
+    uBackRead = 4;
+    while (uBackRead<uMaxBack)
+    {
+        uLong uReadSize;
+        ZPOS64_T uReadPos;
+        int i;
+        if (uBackRead+BUFREADCOMMENT>uMaxBack)
+            uBackRead = uMaxBack;
+        else
+            uBackRead+=BUFREADCOMMENT;
+        uReadPos = uSizeFile-uBackRead ;
+
+        uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
+                     (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
+        if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
+            break;
+
+        if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
+            break;
+
+        for (i=(int)uReadSize-3; (i--)>0;)
+            if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
+                ((*(buf+i+2))==0x06) && ((*(buf+i+3))==0x07))
+            {
+                uPosFound = uReadPos+i;
+                break;
+            }
+
+        if (uPosFound!=0)
+            break;
+    }
+    TRYFREE(buf);
+    if (uPosFound == 0)
+        return 0;
+
+    /* Zip64 end of central directory locator */
+    if (ZSEEK64(*pzlib_filefunc_def,filestream, uPosFound,ZLIB_FILEFUNC_SEEK_SET)!=0)
+        return 0;
+
+    /* the signature, already checked */
+    if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
+        return 0;
+
+    /* number of the disk with the start of the zip64 end of  central directory */
+    if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
+        return 0;
+    if (uL != 0)
+        return 0;
+
+    /* relative offset of the zip64 end of central directory record */
+    if (unz64local_getLong64(pzlib_filefunc_def,filestream,&relativeOffset)!=UNZ_OK)
+        return 0;
+
+    /* total number of disks */
+    if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
+        return 0;
+    if (uL != 1)
+        return 0;
+
+    /* Goto end of central directory record */
+    if (ZSEEK64(*pzlib_filefunc_def,filestream, relativeOffset,ZLIB_FILEFUNC_SEEK_SET)!=0)
+        return 0;
+
+     /* the signature */
+    if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
+        return 0;
+
+    if (uL != 0x06064b50)
+        return 0;
+
+    return relativeOffset;
+}
+
+/*
+  Open a Zip file. path contain the full pathname (by example,
+     on a Windows NT computer "c:\\test\\zlib114.zip" or on an Unix computer
+     "zlib/zlib114.zip".
+     If the zipfile cannot be opened (file doesn't exist or in not valid), the
+       return value is NULL.
+     Else, the return value is a unzFile Handle, usable with other function
+       of this unzip package.
+*/
+local unzFile unzOpenInternal (const void *path,
+                               zlib_filefunc64_32_def* pzlib_filefunc64_32_def,
+                               int is64bitOpenFunction)
+{
+    unz64_s us;
+    unz64_s *s;
+    ZPOS64_T central_pos;
+    uLong   uL;
+
+    uLong number_disk;          /* number of the current dist, used for
+                                   spaning ZIP, unsupported, always 0*/
+    uLong number_disk_with_CD;  /* number the the disk with central dir, used
+                                   for spaning ZIP, unsupported, always 0*/
+    ZPOS64_T number_entry_CD;      /* total number of entries in
+                                   the central dir
+                                   (same than number_entry on nospan) */
+
+    int err=UNZ_OK;
+
+    if (unz_copyright[0]!=' ')
+        return NULL;
+
+    us.z_filefunc.zseek32_file = NULL;
+    us.z_filefunc.ztell32_file = NULL;
+    if (pzlib_filefunc64_32_def==NULL)
+        fill_fopen64_filefunc(&us.z_filefunc.zfile_func64);
+    else
+        us.z_filefunc = *pzlib_filefunc64_32_def;
+    us.is64bitOpenFunction = is64bitOpenFunction;
+
+
+
+    us.filestream = ZOPEN64(us.z_filefunc,
+                                                 path,
+                                                 ZLIB_FILEFUNC_MODE_READ |
+                                                 ZLIB_FILEFUNC_MODE_EXISTING);
+    if (us.filestream==NULL)
+        return NULL;
+
+    central_pos = unz64local_SearchCentralDir64(&us.z_filefunc,us.filestream);
+    if (central_pos)
+    {
+        uLong uS;
+        ZPOS64_T uL64;
+
+        us.isZip64 = 1;
+
+        if (ZSEEK64(us.z_filefunc, us.filestream,
+                                      central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
+        err=UNZ_ERRNO;
+
+        /* the signature, already checked */
+        if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
+            err=UNZ_ERRNO;
+
+        /* size of zip64 end of central directory record */
+        if (unz64local_getLong64(&us.z_filefunc, us.filestream,&uL64)!=UNZ_OK)
+            err=UNZ_ERRNO;
+
+        /* version made by */
+        if (unz64local_getShort(&us.z_filefunc, us.filestream,&uS)!=UNZ_OK)
+            err=UNZ_ERRNO;
+
+        /* version needed to extract */
+        if (unz64local_getShort(&us.z_filefunc, us.filestream,&uS)!=UNZ_OK)
+            err=UNZ_ERRNO;
+
+        /* number of this disk */
+        if (unz64local_getLong(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK)
+            err=UNZ_ERRNO;
+
+        /* number of the disk with the start of the central directory */
+        if (unz64local_getLong(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK)
+            err=UNZ_ERRNO;
+
+        /* total number of entries in the central directory on this disk */
+        if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.gi.number_entry)!=UNZ_OK)
+            err=UNZ_ERRNO;
+
+        /* total number of entries in the central directory */
+        if (unz64local_getLong64(&us.z_filefunc, us.filestream,&number_entry_CD)!=UNZ_OK)
+            err=UNZ_ERRNO;
+
+        if ((number_entry_CD!=us.gi.number_entry) ||
+            (number_disk_with_CD!=0) ||
+            (number_disk!=0))
+            err=UNZ_BADZIPFILE;
+
+        /* size of the central directory */
+        if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.size_central_dir)!=UNZ_OK)
+            err=UNZ_ERRNO;
+
+        /* offset of start of central directory with respect to the
+          starting disk number */
+        if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.offset_central_dir)!=UNZ_OK)
+            err=UNZ_ERRNO;
+
+        us.gi.size_comment = 0;
+    }
+    else
+    {
+        central_pos = unz64local_SearchCentralDir(&us.z_filefunc,us.filestream);
+        if (central_pos==0)
+            err=UNZ_ERRNO;
+
+        us.isZip64 = 0;
+
+        if (ZSEEK64(us.z_filefunc, us.filestream,
+                                        central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
+            err=UNZ_ERRNO;
+
+        /* the signature, already checked */
+        if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
+            err=UNZ_ERRNO;
+
+        /* number of this disk */
+        if (unz64local_getShort(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK)
+            err=UNZ_ERRNO;
+
+        /* number of the disk with the start of the central directory */
+        if (unz64local_getShort(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK)
+            err=UNZ_ERRNO;
+
+        /* total number of entries in the central dir on this disk */
+        if (unz64local_getShort(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
+            err=UNZ_ERRNO;
+        us.gi.number_entry = uL;
+
+        /* total number of entries in the central dir */
+        if (unz64local_getShort(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
+            err=UNZ_ERRNO;
+        number_entry_CD = uL;
+
+        if ((number_entry_CD!=us.gi.number_entry) ||
+            (number_disk_with_CD!=0) ||
+            (number_disk!=0))
+            err=UNZ_BADZIPFILE;
+
+        /* size of the central directory */
+        if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
+            err=UNZ_ERRNO;
+        us.size_central_dir = uL;
+
+        /* offset of start of central directory with respect to the
+            starting disk number */
+        if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
+            err=UNZ_ERRNO;
+        us.offset_central_dir = uL;
+
+        /* zipfile comment length */
+        if (unz64local_getShort(&us.z_filefunc, us.filestream,&us.gi.size_comment)!=UNZ_OK)
+            err=UNZ_ERRNO;
+    }
+
+    if ((central_pos<us.offset_central_dir+us.size_central_dir) &&
+        (err==UNZ_OK))
+        err=UNZ_BADZIPFILE;
+
+    if (err!=UNZ_OK)
+    {
+        ZCLOSE64(us.z_filefunc, us.filestream);
+        return NULL;
+    }
+
+    us.byte_before_the_zipfile = central_pos -
+                            (us.offset_central_dir+us.size_central_dir);
+    us.central_pos = central_pos;
+    us.pfile_in_zip_read = NULL;
+    us.encrypted = 0;
+
+
+    s=(unz64_s*)ALLOC(sizeof(unz64_s));
+    if( s != NULL)
+    {
+        *s=us;
+        unzGoToFirstFile((unzFile)s);
+    }
+    return (unzFile)s;
+}
+
+
+extern unzFile ZEXPORT unzOpen2 (const char *path,
+                                        zlib_filefunc_def* pzlib_filefunc32_def)
+{
+    if (pzlib_filefunc32_def != NULL)
+    {
+        zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
+        fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill,pzlib_filefunc32_def);
+        return unzOpenInternal(path, &zlib_filefunc64_32_def_fill, 0);
+    }
+    else
+        return unzOpenInternal(path, NULL, 0);
+}
+
+extern unzFile ZEXPORT unzOpen2_64 (const void *path,
+                                     zlib_filefunc64_def* pzlib_filefunc_def)
+{
+    if (pzlib_filefunc_def != NULL)
+    {
+        zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
+        zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def;
+        zlib_filefunc64_32_def_fill.ztell32_file = NULL;
+        zlib_filefunc64_32_def_fill.zseek32_file = NULL;
+        return unzOpenInternal(path, &zlib_filefunc64_32_def_fill, 1);
+    }
+    else
+        return unzOpenInternal(path, NULL, 1);
+}
+
+extern unzFile ZEXPORT unzOpen (const char *path)
+{
+    return unzOpenInternal(path, NULL, 0);
+}
+
+extern unzFile ZEXPORT unzOpen64 (const void *path)
+{
+    return unzOpenInternal(path, NULL, 1);
+}
+
+/*
+  Close a ZipFile opened with unzOpen.
+  If there is files inside the .Zip opened with unzOpenCurrentFile (see later),
+    these files MUST be closed with unzCloseCurrentFile before call unzClose.
+  return UNZ_OK if there is no problem. */
+extern int ZEXPORT unzClose (unzFile file)
+{
+    unz64_s* s;
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz64_s*)file;
+
+    if (s->pfile_in_zip_read!=NULL)
+        unzCloseCurrentFile(file);
+
+    ZCLOSE64(s->z_filefunc, s->filestream);
+    TRYFREE(s);
+    return UNZ_OK;
+}
+
+
+/*
+  Write info about the ZipFile in the *pglobal_info structure.
+  No preparation of the structure is needed
+  return UNZ_OK if there is no problem. */
+extern int ZEXPORT unzGetGlobalInfo64 (unzFile file, unz_global_info64* pglobal_info)
+{
+    unz64_s* s;
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz64_s*)file;
+    *pglobal_info=s->gi;
+    return UNZ_OK;
+}
+
+extern int ZEXPORT unzGetGlobalInfo (unzFile file, unz_global_info* pglobal_info32)
+{
+    unz64_s* s;
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz64_s*)file;
+    /* to do : check if number_entry is not truncated */
+    pglobal_info32->number_entry = (uLong)s->gi.number_entry;
+    pglobal_info32->size_comment = s->gi.size_comment;
+    return UNZ_OK;
+}
+/*
+   Translate date/time from Dos format to tm_unz (readable more easilty)
+*/
+local void unz64local_DosDateToTmuDate (ZPOS64_T ulDosDate, tm_unz* ptm)
+{
+    ZPOS64_T uDate;
+    uDate = (ZPOS64_T)(ulDosDate>>16);
+    ptm->tm_mday = (uInt)(uDate&0x1f) ;
+    ptm->tm_mon =  (uInt)((((uDate)&0x1E0)/0x20)-1) ;
+    ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ;
+
+    ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800);
+    ptm->tm_min =  (uInt) ((ulDosDate&0x7E0)/0x20) ;
+    ptm->tm_sec =  (uInt) (2*(ulDosDate&0x1f)) ;
+}
+
+/*
+  Get Info about the current file in the zipfile, with internal only info
+*/
+local int unz64local_GetCurrentFileInfoInternal OF((unzFile file,
+                                                  unz_file_info64 *pfile_info,
+                                                  unz_file_info64_internal
+                                                  *pfile_info_internal,
+                                                  char *szFileName,
+                                                  uLong fileNameBufferSize,
+                                                  void *extraField,
+                                                  uLong extraFieldBufferSize,
+                                                  char *szComment,
+                                                  uLong commentBufferSize));
+
+local int unz64local_GetCurrentFileInfoInternal (unzFile file,
+                                                  unz_file_info64 *pfile_info,
+                                                  unz_file_info64_internal
+                                                  *pfile_info_internal,
+                                                  char *szFileName,
+                                                  uLong fileNameBufferSize,
+                                                  void *extraField,
+                                                  uLong extraFieldBufferSize,
+                                                  char *szComment,
+                                                  uLong commentBufferSize)
+{
+    unz64_s* s;
+    unz_file_info64 file_info;
+    unz_file_info64_internal file_info_internal;
+    int err=UNZ_OK;
+    uLong uMagic;
+    long lSeek=0;
+    uLong uL;
+
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz64_s*)file;
+    if (ZSEEK64(s->z_filefunc, s->filestream,
+              s->pos_in_central_dir+s->byte_before_the_zipfile,
+              ZLIB_FILEFUNC_SEEK_SET)!=0)
+        err=UNZ_ERRNO;
+
+
+    /* we check the magic */
+    if (err==UNZ_OK)
+    {
+        if (unz64local_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
+            err=UNZ_ERRNO;
+        else if (uMagic!=0x02014b50)
+            err=UNZ_BADZIPFILE;
+    }
+
+    if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.version) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.version_needed) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.flag) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.compression_method) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.dosDate) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    unz64local_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date);
+
+    if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.crc) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)
+        err=UNZ_ERRNO;
+    file_info.compressed_size = uL;
+
+    if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)
+        err=UNZ_ERRNO;
+    file_info.uncompressed_size = uL;
+
+    if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_filename) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_extra) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_comment) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.disk_num_start) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.internal_fa) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.external_fa) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+                // relative offset of local header
+    if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)
+        err=UNZ_ERRNO;
+    file_info_internal.offset_curfile = uL;
+
+    lSeek+=file_info.size_filename;
+    if ((err==UNZ_OK) && (szFileName!=NULL))
+    {
+        uLong uSizeRead ;
+        if (file_info.size_filename<fileNameBufferSize)
+        {
+            *(szFileName+file_info.size_filename)='\0';
+            uSizeRead = file_info.size_filename;
+        }
+        else
+            uSizeRead = fileNameBufferSize;
+
+        if ((file_info.size_filename>0) && (fileNameBufferSize>0))
+            if (ZREAD64(s->z_filefunc, s->filestream,szFileName,uSizeRead)!=uSizeRead)
+                err=UNZ_ERRNO;
+        lSeek -= uSizeRead;
+    }
+
+    // Read extrafield
+    if ((err==UNZ_OK) && (extraField!=NULL))
+    {
+        ZPOS64_T uSizeRead ;
+        if (file_info.size_file_extra<extraFieldBufferSize)
+            uSizeRead = file_info.size_file_extra;
+        else
+            uSizeRead = extraFieldBufferSize;
+
+        if (lSeek!=0)
+        {
+            if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
+                lSeek=0;
+            else
+                err=UNZ_ERRNO;
+        }
+
+        if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0))
+            if (ZREAD64(s->z_filefunc, s->filestream,extraField,(uLong)uSizeRead)!=uSizeRead)
+                err=UNZ_ERRNO;
+
+        lSeek += file_info.size_file_extra - (uLong)uSizeRead;
+    }
+    else
+        lSeek += file_info.size_file_extra;
+
+
+    if ((err==UNZ_OK) && (file_info.size_file_extra != 0))
+    {
+                                uLong acc = 0;
+
+        // since lSeek now points to after the extra field we need to move back
+        lSeek -= file_info.size_file_extra;
+
+        if (lSeek!=0)
+        {
+            if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
+                lSeek=0;
+            else
+                err=UNZ_ERRNO;
+        }
+
+        while(acc < file_info.size_file_extra)
+        {
+            uLong headerId;
+                                                uLong dataSize;
+
+            if (unz64local_getShort(&s->z_filefunc, s->filestream,&headerId) != UNZ_OK)
+                err=UNZ_ERRNO;
+
+            if (unz64local_getShort(&s->z_filefunc, s->filestream,&dataSize) != UNZ_OK)
+                err=UNZ_ERRNO;
+
+            /* ZIP64 extra fields */
+            if (headerId == 0x0001)
+            {
+                                                        uLong uL;
+
+                                                                if(file_info.uncompressed_size == MAXU32)
+                                                                {
+                                                                        if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info.uncompressed_size) != UNZ_OK)
+                                                                                        err=UNZ_ERRNO;
+                                                                }
+
+                                                                if(file_info.compressed_size == MAXU32)
+                                                                {
+                                                                        if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info.compressed_size) != UNZ_OK)
+                                                                                  err=UNZ_ERRNO;
+                                                                }
+
+                                                                if(file_info_internal.offset_curfile == MAXU32)
+                                                                {
+                                                                        /* Relative Header offset */
+                                                                        if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info_internal.offset_curfile) != UNZ_OK)
+                                                                                err=UNZ_ERRNO;
+                                                                }
+
+                                                                if(file_info.disk_num_start == MAXU32)
+                                                                {
+                                                                        /* Disk Start Number */
+                                                                        if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)
+                                                                                err=UNZ_ERRNO;
+                                                                }
+
+            }
+            else
+            {
+                if (ZSEEK64(s->z_filefunc, s->filestream,dataSize,ZLIB_FILEFUNC_SEEK_CUR)!=0)
+                    err=UNZ_ERRNO;
+            }
+
+            acc += 2 + 2 + dataSize;
+        }
+    }
+
+    if ((err==UNZ_OK) && (szComment!=NULL))
+    {
+        uLong uSizeRead ;
+        if (file_info.size_file_comment<commentBufferSize)
+        {
+            *(szComment+file_info.size_file_comment)='\0';
+            uSizeRead = file_info.size_file_comment;
+        }
+        else
+            uSizeRead = commentBufferSize;
+
+        if (lSeek!=0)
+        {
+            if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
+                lSeek=0;
+            else
+                err=UNZ_ERRNO;
+        }
+
+        if ((file_info.size_file_comment>0) && (commentBufferSize>0))
+            if (ZREAD64(s->z_filefunc, s->filestream,szComment,uSizeRead)!=uSizeRead)
+                err=UNZ_ERRNO;
+        lSeek+=file_info.size_file_comment - uSizeRead;
+    }
+    else
+        lSeek+=file_info.size_file_comment;
+
+
+    if ((err==UNZ_OK) && (pfile_info!=NULL))
+        *pfile_info=file_info;
+
+    if ((err==UNZ_OK) && (pfile_info_internal!=NULL))
+        *pfile_info_internal=file_info_internal;
+
+    return err;
+}
+
+
+
+/*
+  Write info about the ZipFile in the *pglobal_info structure.
+  No preparation of the structure is needed
+  return UNZ_OK if there is no problem.
+*/
+extern int ZEXPORT unzGetCurrentFileInfo64 (unzFile file,
+                                          unz_file_info64 * pfile_info,
+                                          char * szFileName, uLong fileNameBufferSize,
+                                          void *extraField, uLong extraFieldBufferSize,
+                                          char* szComment,  uLong commentBufferSize)
+{
+    return unz64local_GetCurrentFileInfoInternal(file,pfile_info,NULL,
+                                                szFileName,fileNameBufferSize,
+                                                extraField,extraFieldBufferSize,
+                                                szComment,commentBufferSize);
+}
+
+extern int ZEXPORT unzGetCurrentFileInfo (unzFile file,
+                                          unz_file_info * pfile_info,
+                                          char * szFileName, uLong fileNameBufferSize,
+                                          void *extraField, uLong extraFieldBufferSize,
+                                          char* szComment,  uLong commentBufferSize)
+{
+    int err;
+    unz_file_info64 file_info64;
+    err = unz64local_GetCurrentFileInfoInternal(file,&file_info64,NULL,
+                                                szFileName,fileNameBufferSize,
+                                                extraField,extraFieldBufferSize,
+                                                szComment,commentBufferSize);
+    if ((err==UNZ_OK) && (pfile_info != NULL))
+    {
+        pfile_info->version = file_info64.version;
+        pfile_info->version_needed = file_info64.version_needed;
+        pfile_info->flag = file_info64.flag;
+        pfile_info->compression_method = file_info64.compression_method;
+        pfile_info->dosDate = file_info64.dosDate;
+        pfile_info->crc = file_info64.crc;
+
+        pfile_info->size_filename = file_info64.size_filename;
+        pfile_info->size_file_extra = file_info64.size_file_extra;
+        pfile_info->size_file_comment = file_info64.size_file_comment;
+
+        pfile_info->disk_num_start = file_info64.disk_num_start;
+        pfile_info->internal_fa = file_info64.internal_fa;
+        pfile_info->external_fa = file_info64.external_fa;
+
+        pfile_info->tmu_date = file_info64.tmu_date,
+
+
+        pfile_info->compressed_size = (uLong)file_info64.compressed_size;
+        pfile_info->uncompressed_size = (uLong)file_info64.uncompressed_size;
+
+    }
+    return err;
+}
+/*
+  Set the current file of the zipfile to the first file.
+  return UNZ_OK if there is no problem
+*/
+extern int ZEXPORT unzGoToFirstFile (unzFile file)
+{
+    int err=UNZ_OK;
+    unz64_s* s;
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz64_s*)file;
+    s->pos_in_central_dir=s->offset_central_dir;
+    s->num_file=0;
+    err=unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,
+                                             &s->cur_file_info_internal,
+                                             NULL,0,NULL,0,NULL,0);
+    s->current_file_ok = (err == UNZ_OK);
+    return err;
+}
+
+/*
+  Set the current file of the zipfile to the next file.
+  return UNZ_OK if there is no problem
+  return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
+*/
+extern int ZEXPORT unzGoToNextFile (unzFile  file)
+{
+    unz64_s* s;
+    int err;
+
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz64_s*)file;
+    if (!s->current_file_ok)
+        return UNZ_END_OF_LIST_OF_FILE;
+    if (s->gi.number_entry != 0xffff)    /* 2^16 files overflow hack */
+      if (s->num_file+1==s->gi.number_entry)
+        return UNZ_END_OF_LIST_OF_FILE;
+
+    s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
+            s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;
+    s->num_file++;
+    err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,
+                                               &s->cur_file_info_internal,
+                                               NULL,0,NULL,0,NULL,0);
+    s->current_file_ok = (err == UNZ_OK);
+    return err;
+}
+
+
+/*
+  Try locate the file szFileName in the zipfile.
+  For the iCaseSensitivity signification, see unzStringFileNameCompare
+
+  return value :
+  UNZ_OK if the file is found. It becomes the current file.
+  UNZ_END_OF_LIST_OF_FILE if the file is not found
+*/
+extern int ZEXPORT unzLocateFile (unzFile file, const char *szFileName, int iCaseSensitivity)
+{
+    unz64_s* s;
+    int err;
+
+    /* We remember the 'current' position in the file so that we can jump
+     * back there if we fail.
+     */
+    unz_file_info64 cur_file_infoSaved;
+    unz_file_info64_internal cur_file_info_internalSaved;
+    ZPOS64_T num_fileSaved;
+    ZPOS64_T pos_in_central_dirSaved;
+
+
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+
+    if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP)
+        return UNZ_PARAMERROR;
+
+    s=(unz64_s*)file;
+    if (!s->current_file_ok)
+        return UNZ_END_OF_LIST_OF_FILE;
+
+    /* Save the current state */
+    num_fileSaved = s->num_file;
+    pos_in_central_dirSaved = s->pos_in_central_dir;
+    cur_file_infoSaved = s->cur_file_info;
+    cur_file_info_internalSaved = s->cur_file_info_internal;
+
+    err = unzGoToFirstFile(file);
+
+    while (err == UNZ_OK)
+    {
+        char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];
+        err = unzGetCurrentFileInfo64(file,NULL,
+                                    szCurrentFileName,sizeof(szCurrentFileName)-1,
+                                    NULL,0,NULL,0);
+        if (err == UNZ_OK)
+        {
+            if (unzStringFileNameCompare(szCurrentFileName,
+                                            szFileName,iCaseSensitivity)==0)
+                return UNZ_OK;
+            err = unzGoToNextFile(file);
+        }
+    }
+
+    /* We failed, so restore the state of the 'current file' to where we
+     * were.
+     */
+    s->num_file = num_fileSaved ;
+    s->pos_in_central_dir = pos_in_central_dirSaved ;
+    s->cur_file_info = cur_file_infoSaved;
+    s->cur_file_info_internal = cur_file_info_internalSaved;
+    return err;
+}
+
+
+/*
+///////////////////////////////////////////
+// Contributed by Ryan Haksi (mailto://cryogen@infoserve.net)
+// I need random access
+//
+// Further optimization could be realized by adding an ability
+// to cache the directory in memory. The goal being a single
+// comprehensive file read to put the file I need in a memory.
+*/
+
+/*
+typedef struct unz_file_pos_s
+{
+    ZPOS64_T pos_in_zip_directory;   // offset in file
+    ZPOS64_T num_of_file;            // # of file
+} unz_file_pos;
+*/
+
+extern int ZEXPORT unzGetFilePos64(unzFile file, unz64_file_pos*  file_pos)
+{
+    unz64_s* s;
+
+    if (file==NULL || file_pos==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz64_s*)file;
+    if (!s->current_file_ok)
+        return UNZ_END_OF_LIST_OF_FILE;
+
+    file_pos->pos_in_zip_directory  = s->pos_in_central_dir;
+    file_pos->num_of_file           = s->num_file;
+
+    return UNZ_OK;
+}
+
+extern int ZEXPORT unzGetFilePos(
+    unzFile file,
+    unz_file_pos* file_pos)
+{
+    unz64_file_pos file_pos64;
+    int err = unzGetFilePos64(file,&file_pos64);
+    if (err==UNZ_OK)
+    {
+        file_pos->pos_in_zip_directory = (uLong)file_pos64.pos_in_zip_directory;
+        file_pos->num_of_file = (uLong)file_pos64.num_of_file;
+    }
+    return err;
+}
+
+extern int ZEXPORT unzGoToFilePos64(unzFile file, const unz64_file_pos* file_pos)
+{
+    unz64_s* s;
+    int err;
+
+    if (file==NULL || file_pos==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz64_s*)file;
+
+    /* jump to the right spot */
+    s->pos_in_central_dir = file_pos->pos_in_zip_directory;
+    s->num_file           = file_pos->num_of_file;
+
+    /* set the current file */
+    err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,
+                                               &s->cur_file_info_internal,
+                                               NULL,0,NULL,0,NULL,0);
+    /* return results */
+    s->current_file_ok = (err == UNZ_OK);
+    return err;
+}
+
+extern int ZEXPORT unzGoToFilePos(
+    unzFile file,
+    unz_file_pos* file_pos)
+{
+    unz64_file_pos file_pos64;
+    if (file_pos == NULL)
+        return UNZ_PARAMERROR;
+
+    file_pos64.pos_in_zip_directory = file_pos->pos_in_zip_directory;
+    file_pos64.num_of_file = file_pos->num_of_file;
+    return unzGoToFilePos64(file,&file_pos64);
+}
+
+/*
+// Unzip Helper Functions - should be here?
+///////////////////////////////////////////
+*/
+
+/*
+  Read the local header of the current zipfile
+  Check the coherency of the local header and info in the end of central
+        directory about this file
+  store in *piSizeVar the size of extra info in local header
+        (filename and size of extra field data)
+*/
+local int unz64local_CheckCurrentFileCoherencyHeader (unz64_s* s, uInt* piSizeVar,
+                                                    ZPOS64_T * poffset_local_extrafield,
+                                                    uInt  * psize_local_extrafield)
+{
+    uLong uMagic,uData,uFlags;
+    uLong size_filename;
+    uLong size_extra_field;
+    int err=UNZ_OK;
+
+    *piSizeVar = 0;
+    *poffset_local_extrafield = 0;
+    *psize_local_extrafield = 0;
+
+    if (ZSEEK64(s->z_filefunc, s->filestream,s->cur_file_info_internal.offset_curfile +
+                                s->byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0)
+        return UNZ_ERRNO;
+
+
+    if (err==UNZ_OK)
+    {
+        if (unz64local_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
+            err=UNZ_ERRNO;
+        else if (uMagic!=0x04034b50)
+            err=UNZ_BADZIPFILE;
+    }
+
+    if (unz64local_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
+        err=UNZ_ERRNO;
+/*
+    else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
+        err=UNZ_BADZIPFILE;
+*/
+    if (unz64local_getShort(&s->z_filefunc, s->filestream,&uFlags) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unz64local_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
+        err=UNZ_ERRNO;
+    else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method))
+        err=UNZ_BADZIPFILE;
+
+    if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) &&
+/* #ifdef HAVE_BZIP2 */
+                         (s->cur_file_info.compression_method!=Z_BZIP2ED) &&
+/* #endif */
+                         (s->cur_file_info.compression_method!=Z_DEFLATED))
+        err=UNZ_BADZIPFILE;
+
+    if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* date/time */
+        err=UNZ_ERRNO;
+
+    if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* crc */
+        err=UNZ_ERRNO;
+    else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) && ((uFlags & 8)==0))
+        err=UNZ_BADZIPFILE;
+
+    if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size compr */
+        err=UNZ_ERRNO;
+    else if (uData != 0xFFFFFFFF && (err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) && ((uFlags & 8)==0))
+        err=UNZ_BADZIPFILE;
+
+    if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size uncompr */
+        err=UNZ_ERRNO;
+    else if (uData != 0xFFFFFFFF && (err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) && ((uFlags & 8)==0))
+        err=UNZ_BADZIPFILE;
+
+    if (unz64local_getShort(&s->z_filefunc, s->filestream,&size_filename) != UNZ_OK)
+        err=UNZ_ERRNO;
+    else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename))
+        err=UNZ_BADZIPFILE;
+
+    *piSizeVar += (uInt)size_filename;
+
+    if (unz64local_getShort(&s->z_filefunc, s->filestream,&size_extra_field) != UNZ_OK)
+        err=UNZ_ERRNO;
+    *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile +
+                                    SIZEZIPLOCALHEADER + size_filename;
+    *psize_local_extrafield = (uInt)size_extra_field;
+
+    *piSizeVar += (uInt)size_extra_field;
+
+    return err;
+}
+
+/*
+  Open for reading data the current file in the zipfile.
+  If there is no error and the file is opened, the return value is UNZ_OK.
+*/
+extern int ZEXPORT unzOpenCurrentFile3 (unzFile file, int* method,
+                                            int* level, int raw, const char* password)
+{
+    int err=UNZ_OK;
+    uInt iSizeVar;
+    unz64_s* s;
+    file_in_zip64_read_info_s* pfile_in_zip_read_info;
+    ZPOS64_T offset_local_extrafield;  /* offset of the local extra field */
+    uInt  size_local_extrafield;    /* size of the local extra field */
+#    ifndef NOUNCRYPT
+    char source[12];
+#    else
+    if (password != NULL)
+        return UNZ_PARAMERROR;
+#    endif
+
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz64_s*)file;
+    if (!s->current_file_ok)
+        return UNZ_PARAMERROR;
+
+    if (s->pfile_in_zip_read != NULL)
+        unzCloseCurrentFile(file);
+
+    if (unz64local_CheckCurrentFileCoherencyHeader(s,&iSizeVar, &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK)
+        return UNZ_BADZIPFILE;
+
+    pfile_in_zip_read_info = (file_in_zip64_read_info_s*)ALLOC(sizeof(file_in_zip64_read_info_s));
+    if (pfile_in_zip_read_info==NULL)
+        return UNZ_INTERNALERROR;
+
+    pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE);
+    pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
+    pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
+    pfile_in_zip_read_info->pos_local_extrafield=0;
+    pfile_in_zip_read_info->raw=raw;
+
+    if (pfile_in_zip_read_info->read_buffer==NULL)
+    {
+        TRYFREE(pfile_in_zip_read_info);
+        return UNZ_INTERNALERROR;
+    }
+
+    pfile_in_zip_read_info->stream_initialised=0;
+
+    if (method!=NULL)
+        *method = (int)s->cur_file_info.compression_method;
+
+    if (level!=NULL)
+    {
+        *level = 6;
+        switch (s->cur_file_info.flag & 0x06)
+        {
+          case 6 : *level = 1; break;
+          case 4 : *level = 2; break;
+          case 2 : *level = 9; break;
+        }
+    }
+
+    if ((s->cur_file_info.compression_method!=0) &&
+/* #ifdef HAVE_BZIP2 */
+        (s->cur_file_info.compression_method!=Z_BZIP2ED) &&
+/* #endif */
+        (s->cur_file_info.compression_method!=Z_DEFLATED))
+
+        err=UNZ_BADZIPFILE;
+
+    pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc;
+    pfile_in_zip_read_info->crc32=0;
+    pfile_in_zip_read_info->total_out_64=0;
+    pfile_in_zip_read_info->compression_method = s->cur_file_info.compression_method;
+    pfile_in_zip_read_info->filestream=s->filestream;
+    pfile_in_zip_read_info->z_filefunc=s->z_filefunc;
+    pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile;
+
+    pfile_in_zip_read_info->stream.total_out = 0;
+
+    if ((s->cur_file_info.compression_method==Z_BZIP2ED) && (!raw))
+    {
+#ifdef HAVE_BZIP2
+      pfile_in_zip_read_info->bstream.bzalloc = (void *(*) (void *, int, int))0;
+      pfile_in_zip_read_info->bstream.bzfree = (free_func)0;
+      pfile_in_zip_read_info->bstream.opaque = (voidpf)0;
+      pfile_in_zip_read_info->bstream.state = (voidpf)0;
+
+      pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
+      pfile_in_zip_read_info->stream.zfree = (free_func)0;
+      pfile_in_zip_read_info->stream.opaque = (voidpf)0;
+      pfile_in_zip_read_info->stream.next_in = (voidpf)0;
+      pfile_in_zip_read_info->stream.avail_in = 0;
+
+      err=BZ2_bzDecompressInit(&pfile_in_zip_read_info->bstream, 0, 0);
+      if (err == Z_OK)
+        pfile_in_zip_read_info->stream_initialised=Z_BZIP2ED;
+      else
+      {
+        TRYFREE(pfile_in_zip_read_info);
+        return err;
+      }
+#else
+      pfile_in_zip_read_info->raw=1;
+#endif
+    }
+    else if ((s->cur_file_info.compression_method==Z_DEFLATED) && (!raw))
+    {
+      pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
+      pfile_in_zip_read_info->stream.zfree = (free_func)0;
+      pfile_in_zip_read_info->stream.opaque = (voidpf)0;
+      pfile_in_zip_read_info->stream.next_in = 0;
+      pfile_in_zip_read_info->stream.avail_in = 0;
+
+      err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);
+      if (err == Z_OK)
+        pfile_in_zip_read_info->stream_initialised=Z_DEFLATED;
+      else
+      {
+        TRYFREE(pfile_in_zip_read_info);
+        return err;
+      }
+        /* windowBits is passed < 0 to tell that there is no zlib header.
+         * Note that in this case inflate *requires* an extra "dummy" byte
+         * after the compressed stream in order to complete decompression and
+         * return Z_STREAM_END.
+         * In unzip, i don't wait absolutely Z_STREAM_END because I known the
+         * size of both compressed and uncompressed data
+         */
+    }
+    pfile_in_zip_read_info->rest_read_compressed =
+            s->cur_file_info.compressed_size ;
+    pfile_in_zip_read_info->rest_read_uncompressed =
+            s->cur_file_info.uncompressed_size ;
+
+
+    pfile_in_zip_read_info->pos_in_zipfile =
+            s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER +
+              iSizeVar;
+
+    pfile_in_zip_read_info->stream.avail_in = (uInt)0;
+
+    s->pfile_in_zip_read = pfile_in_zip_read_info;
+                s->encrypted = 0;
+
+#    ifndef NOUNCRYPT
+    if (password != NULL)
+    {
+        int i;
+        s->pcrc_32_tab = get_crc_table();
+        init_keys(password,s->keys,s->pcrc_32_tab);
+        if (ZSEEK64(s->z_filefunc, s->filestream,
+                  s->pfile_in_zip_read->pos_in_zipfile +
+                     s->pfile_in_zip_read->byte_before_the_zipfile,
+                  SEEK_SET)!=0)
+            return UNZ_INTERNALERROR;
+        if(ZREAD64(s->z_filefunc, s->filestream,source, 12)<12)
+            return UNZ_INTERNALERROR;
+
+        for (i = 0; i<12; i++)
+            zdecode(s->keys,s->pcrc_32_tab,source[i]);
+
+        s->pfile_in_zip_read->pos_in_zipfile+=12;
+        s->encrypted=1;
+    }
+#    endif
+
+
+    return UNZ_OK;
+}
+
+extern int ZEXPORT unzOpenCurrentFile (unzFile file)
+{
+    return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL);
+}
+
+extern int ZEXPORT unzOpenCurrentFilePassword (unzFile file, const char*  password)
+{
+    return unzOpenCurrentFile3(file, NULL, NULL, 0, password);
+}
+
+extern int ZEXPORT unzOpenCurrentFile2 (unzFile file, int* method, int* level, int raw)
+{
+    return unzOpenCurrentFile3(file, method, level, raw, NULL);
+}
+
+/** Addition for GDAL : START */
+
+extern ZPOS64_T ZEXPORT unzGetCurrentFileZStreamPos64( unzFile file)
+{
+    unz64_s* s;
+    file_in_zip64_read_info_s* pfile_in_zip_read_info;
+    s=(unz64_s*)file;
+    if (file==NULL)
+        return 0; //UNZ_PARAMERROR;
+    pfile_in_zip_read_info=s->pfile_in_zip_read;
+    if (pfile_in_zip_read_info==NULL)
+        return 0; //UNZ_PARAMERROR;
+    return pfile_in_zip_read_info->pos_in_zipfile +
+                         pfile_in_zip_read_info->byte_before_the_zipfile;
+}
+
+/** Addition for GDAL : END */
+
+/*
+  Read bytes from the current file.
+  buf contain buffer where data must be copied
+  len the size of buf.
+
+  return the number of byte copied if somes bytes are copied
+  return 0 if the end of file was reached
+  return <0 with error code if there is an error
+    (UNZ_ERRNO for IO error, or zLib error for uncompress error)
+*/
+extern int ZEXPORT unzReadCurrentFile  (unzFile file, voidp buf, unsigned len)
+{
+    int err=UNZ_OK;
+    uInt iRead = 0;
+    unz64_s* s;
+    file_in_zip64_read_info_s* pfile_in_zip_read_info;
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz64_s*)file;
+    pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+    if (pfile_in_zip_read_info==NULL)
+        return UNZ_PARAMERROR;
+
+
+    if (pfile_in_zip_read_info->read_buffer == NULL)
+        return UNZ_END_OF_LIST_OF_FILE;
+    if (len==0)
+        return 0;
+
+    pfile_in_zip_read_info->stream.next_out = (Bytef*)buf;
+
+    pfile_in_zip_read_info->stream.avail_out = (uInt)len;
+
+    if ((len>pfile_in_zip_read_info->rest_read_uncompressed) &&
+        (!(pfile_in_zip_read_info->raw)))
+        pfile_in_zip_read_info->stream.avail_out =
+            (uInt)pfile_in_zip_read_info->rest_read_uncompressed;
+
+    if ((len>pfile_in_zip_read_info->rest_read_compressed+
+           pfile_in_zip_read_info->stream.avail_in) &&
+         (pfile_in_zip_read_info->raw))
+        pfile_in_zip_read_info->stream.avail_out =
+            (uInt)pfile_in_zip_read_info->rest_read_compressed+
+            pfile_in_zip_read_info->stream.avail_in;
+
+    while (pfile_in_zip_read_info->stream.avail_out>0)
+    {
+        if ((pfile_in_zip_read_info->stream.avail_in==0) &&
+            (pfile_in_zip_read_info->rest_read_compressed>0))
+        {
+            uInt uReadThis = UNZ_BUFSIZE;
+            if (pfile_in_zip_read_info->rest_read_compressed<uReadThis)
+                uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;
+            if (uReadThis == 0)
+                return UNZ_EOF;
+            if (ZSEEK64(pfile_in_zip_read_info->z_filefunc,
+                      pfile_in_zip_read_info->filestream,
+                      pfile_in_zip_read_info->pos_in_zipfile +
+                         pfile_in_zip_read_info->byte_before_the_zipfile,
+                         ZLIB_FILEFUNC_SEEK_SET)!=0)
+                return UNZ_ERRNO;
+            if (ZREAD64(pfile_in_zip_read_info->z_filefunc,
+                      pfile_in_zip_read_info->filestream,
+                      pfile_in_zip_read_info->read_buffer,
+                      uReadThis)!=uReadThis)
+                return UNZ_ERRNO;
+
+
+#            ifndef NOUNCRYPT
+            if(s->encrypted)
+            {
+                uInt i;
+                for(i=0;i<uReadThis;i++)
+                  pfile_in_zip_read_info->read_buffer[i] =
+                      zdecode(s->keys,s->pcrc_32_tab,
+                              pfile_in_zip_read_info->read_buffer[i]);
+            }
+#            endif
+
+
+            pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
+
+            pfile_in_zip_read_info->rest_read_compressed-=uReadThis;
+
+            pfile_in_zip_read_info->stream.next_in =
+                (Bytef*)pfile_in_zip_read_info->read_buffer;
+            pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;
+        }
+
+        if ((pfile_in_zip_read_info->compression_method==0) || (pfile_in_zip_read_info->raw))
+        {
+            uInt uDoCopy,i ;
+
+            if ((pfile_in_zip_read_info->stream.avail_in == 0) &&
+                (pfile_in_zip_read_info->rest_read_compressed == 0))
+                return (iRead==0) ? UNZ_EOF : iRead;
+
+            if (pfile_in_zip_read_info->stream.avail_out <
+                            pfile_in_zip_read_info->stream.avail_in)
+                uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
+            else
+                uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
+
+            for (i=0;i<uDoCopy;i++)
+                *(pfile_in_zip_read_info->stream.next_out+i) =
+                        *(pfile_in_zip_read_info->stream.next_in+i);
+
+            pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uDoCopy;
+
+            pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,
+                                pfile_in_zip_read_info->stream.next_out,
+                                uDoCopy);
+            pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy;
+            pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
+            pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
+            pfile_in_zip_read_info->stream.next_out += uDoCopy;
+            pfile_in_zip_read_info->stream.next_in += uDoCopy;
+            pfile_in_zip_read_info->stream.total_out += uDoCopy;
+            iRead += uDoCopy;
+        }
+        else if (pfile_in_zip_read_info->compression_method==Z_BZIP2ED)
+        {
+#ifdef HAVE_BZIP2
+            uLong uTotalOutBefore,uTotalOutAfter;
+            const Bytef *bufBefore;
+            uLong uOutThis;
+
+            pfile_in_zip_read_info->bstream.next_in        = (char*)pfile_in_zip_read_info->stream.next_in;
+            pfile_in_zip_read_info->bstream.avail_in       = pfile_in_zip_read_info->stream.avail_in;
+            pfile_in_zip_read_info->bstream.total_in_lo32  = pfile_in_zip_read_info->stream.total_in;
+            pfile_in_zip_read_info->bstream.total_in_hi32  = 0;
+            pfile_in_zip_read_info->bstream.next_out       = (char*)pfile_in_zip_read_info->stream.next_out;
+            pfile_in_zip_read_info->bstream.avail_out      = pfile_in_zip_read_info->stream.avail_out;
+            pfile_in_zip_read_info->bstream.total_out_lo32 = pfile_in_zip_read_info->stream.total_out;
+            pfile_in_zip_read_info->bstream.total_out_hi32 = 0;
+
+            uTotalOutBefore = pfile_in_zip_read_info->bstream.total_out_lo32;
+            bufBefore = (const Bytef *)pfile_in_zip_read_info->bstream.next_out;
+
+            err=BZ2_bzDecompress(&pfile_in_zip_read_info->bstream);
+
+            uTotalOutAfter = pfile_in_zip_read_info->bstream.total_out_lo32;
+            uOutThis = uTotalOutAfter-uTotalOutBefore;
+
+            pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uOutThis;
+
+            pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,bufBefore, (uInt)(uOutThis));
+            pfile_in_zip_read_info->rest_read_uncompressed -= uOutThis;
+            iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
+
+            pfile_in_zip_read_info->stream.next_in   = (Bytef*)pfile_in_zip_read_info->bstream.next_in;
+            pfile_in_zip_read_info->stream.avail_in  = pfile_in_zip_read_info->bstream.avail_in;
+            pfile_in_zip_read_info->stream.total_in  = pfile_in_zip_read_info->bstream.total_in_lo32;
+            pfile_in_zip_read_info->stream.next_out  = (Bytef*)pfile_in_zip_read_info->bstream.next_out;
+            pfile_in_zip_read_info->stream.avail_out = pfile_in_zip_read_info->bstream.avail_out;
+            pfile_in_zip_read_info->stream.total_out = pfile_in_zip_read_info->bstream.total_out_lo32;
+
+            if (err==BZ_STREAM_END)
+              return (iRead==0) ? UNZ_EOF : iRead;
+            if (err!=BZ_OK)
+              break;
+#endif
+        } // end Z_BZIP2ED
+        else
+        {
+            ZPOS64_T uTotalOutBefore,uTotalOutAfter;
+            const Bytef *bufBefore;
+            ZPOS64_T uOutThis;
+            int flush=Z_SYNC_FLUSH;
+
+            uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
+            bufBefore = pfile_in_zip_read_info->stream.next_out;
+
+            /*
+            if ((pfile_in_zip_read_info->rest_read_uncompressed ==
+                     pfile_in_zip_read_info->stream.avail_out) &&
+                (pfile_in_zip_read_info->rest_read_compressed == 0))
+                flush = Z_FINISH;
+            */
+            err=inflate(&pfile_in_zip_read_info->stream,flush);
+
+            if ((err>=0) && (pfile_in_zip_read_info->stream.msg!=NULL))
+              err = Z_DATA_ERROR;
+
+            uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
+            uOutThis = uTotalOutAfter-uTotalOutBefore;
+
+            pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uOutThis;
+
+            pfile_in_zip_read_info->crc32 =
+                crc32(pfile_in_zip_read_info->crc32,bufBefore,
+                        (uInt)(uOutThis));
+
+            pfile_in_zip_read_info->rest_read_uncompressed -=
+                uOutThis;
+
+            iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
+
+            if (err==Z_STREAM_END)
+                return (iRead==0) ? UNZ_EOF : iRead;
+            if (err!=Z_OK)
+                break;
+        }
+    }
+
+    if (err==Z_OK)
+        return iRead;
+    return err;
+}
+
+
+/*
+  Give the current position in uncompressed data
+*/
+extern z_off_t ZEXPORT unztell (unzFile file)
+{
+    unz64_s* s;
+    file_in_zip64_read_info_s* pfile_in_zip_read_info;
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz64_s*)file;
+    pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+    if (pfile_in_zip_read_info==NULL)
+        return UNZ_PARAMERROR;
+
+    return (z_off_t)pfile_in_zip_read_info->stream.total_out;
+}
+
+extern ZPOS64_T ZEXPORT unztell64 (unzFile file)
+{
+
+    unz64_s* s;
+    file_in_zip64_read_info_s* pfile_in_zip_read_info;
+    if (file==NULL)
+        return (ZPOS64_T)-1;
+    s=(unz64_s*)file;
+    pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+    if (pfile_in_zip_read_info==NULL)
+        return (ZPOS64_T)-1;
+
+    return pfile_in_zip_read_info->total_out_64;
+}
+
+
+/*
+  return 1 if the end of file was reached, 0 elsewhere
+*/
+extern int ZEXPORT unzeof (unzFile file)
+{
+    unz64_s* s;
+    file_in_zip64_read_info_s* pfile_in_zip_read_info;
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz64_s*)file;
+    pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+    if (pfile_in_zip_read_info==NULL)
+        return UNZ_PARAMERROR;
+
+    if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
+        return 1;
+    else
+        return 0;
+}
+
+
+
+/*
+Read extra field from the current file (opened by unzOpenCurrentFile)
+This is the local-header version of the extra field (sometimes, there is
+more info in the local-header version than in the central-header)
+
+  if buf==NULL, it return the size of the local extra field that can be read
+
+  if buf!=NULL, len is the size of the buffer, the extra header is copied in
+    buf.
+  the return value is the number of bytes copied in buf, or (if <0)
+    the error code
+*/
+extern int ZEXPORT unzGetLocalExtrafield (unzFile file, voidp buf, unsigned len)
+{
+    unz64_s* s;
+    file_in_zip64_read_info_s* pfile_in_zip_read_info;
+    uInt read_now;
+    ZPOS64_T size_to_read;
+
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz64_s*)file;
+    pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+    if (pfile_in_zip_read_info==NULL)
+        return UNZ_PARAMERROR;
+
+    size_to_read = (pfile_in_zip_read_info->size_local_extrafield -
+                pfile_in_zip_read_info->pos_local_extrafield);
+
+    if (buf==NULL)
+        return (int)size_to_read;
+
+    if (len>size_to_read)
+        read_now = (uInt)size_to_read;
+    else
+        read_now = (uInt)len ;
+
+    if (read_now==0)
+        return 0;
+
+    if (ZSEEK64(pfile_in_zip_read_info->z_filefunc,
+              pfile_in_zip_read_info->filestream,
+              pfile_in_zip_read_info->offset_local_extrafield +
+              pfile_in_zip_read_info->pos_local_extrafield,
+              ZLIB_FILEFUNC_SEEK_SET)!=0)
+        return UNZ_ERRNO;
+
+    if (ZREAD64(pfile_in_zip_read_info->z_filefunc,
+              pfile_in_zip_read_info->filestream,
+              buf,read_now)!=read_now)
+        return UNZ_ERRNO;
+
+    return (int)read_now;
+}
+
+/*
+  Close the file in zip opened with unzOpenCurrentFile
+  Return UNZ_CRCERROR if all the file was read but the CRC is not good
+*/
+extern int ZEXPORT unzCloseCurrentFile (unzFile file)
+{
+    int err=UNZ_OK;
+
+    unz64_s* s;
+    file_in_zip64_read_info_s* pfile_in_zip_read_info;
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz64_s*)file;
+    pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+    if (pfile_in_zip_read_info==NULL)
+        return UNZ_PARAMERROR;
+
+
+    if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) &&
+        (!pfile_in_zip_read_info->raw))
+    {
+        if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)
+            err=UNZ_CRCERROR;
+    }
+
+
+    TRYFREE(pfile_in_zip_read_info->read_buffer);
+    pfile_in_zip_read_info->read_buffer = NULL;
+    if (pfile_in_zip_read_info->stream_initialised == Z_DEFLATED)
+        inflateEnd(&pfile_in_zip_read_info->stream);
+#ifdef HAVE_BZIP2
+    else if (pfile_in_zip_read_info->stream_initialised == Z_BZIP2ED)
+        BZ2_bzDecompressEnd(&pfile_in_zip_read_info->bstream);
+#endif
+
+
+    pfile_in_zip_read_info->stream_initialised = 0;
+    TRYFREE(pfile_in_zip_read_info);
+
+    s->pfile_in_zip_read=NULL;
+
+    return err;
+}
+
+
+/*
+  Get the global comment string of the ZipFile, in the szComment buffer.
+  uSizeBuf is the size of the szComment buffer.
+  return the number of byte copied or an error code <0
+*/
+extern int ZEXPORT unzGetGlobalComment (unzFile file, char * szComment, uLong uSizeBuf)
+{
+    unz64_s* s;
+    uLong uReadThis ;
+    if (file==NULL)
+        return (int)UNZ_PARAMERROR;
+    s=(unz64_s*)file;
+
+    uReadThis = uSizeBuf;
+    if (uReadThis>s->gi.size_comment)
+        uReadThis = s->gi.size_comment;
+
+    if (ZSEEK64(s->z_filefunc,s->filestream,s->central_pos+22,ZLIB_FILEFUNC_SEEK_SET)!=0)
+        return UNZ_ERRNO;
+
+    if (uReadThis>0)
+    {
+      *szComment='\0';
+      if (ZREAD64(s->z_filefunc,s->filestream,szComment,uReadThis)!=uReadThis)
+        return UNZ_ERRNO;
+    }
+
+    if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment))
+        *(szComment+s->gi.size_comment)='\0';
+    return (int)uReadThis;
+}
+
+/* Additions by RX '2004 */
+extern ZPOS64_T ZEXPORT unzGetOffset64(unzFile file)
+{
+    unz64_s* s;
+
+    if (file==NULL)
+          return 0; //UNZ_PARAMERROR;
+    s=(unz64_s*)file;
+    if (!s->current_file_ok)
+      return 0;
+    if (s->gi.number_entry != 0 && s->gi.number_entry != 0xffff)
+      if (s->num_file==s->gi.number_entry)
+         return 0;
+    return s->pos_in_central_dir;
+}
+
+extern uLong ZEXPORT unzGetOffset (unzFile file)
+{
+    ZPOS64_T offset64;
+
+    if (file==NULL)
+          return 0; //UNZ_PARAMERROR;
+    offset64 = unzGetOffset64(file);
+    return (uLong)offset64;
+}
+
+extern int ZEXPORT unzSetOffset64(unzFile file, ZPOS64_T pos)
+{
+    unz64_s* s;
+    int err;
+
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz64_s*)file;
+
+    s->pos_in_central_dir = pos;
+    s->num_file = s->gi.number_entry;      /* hack */
+    err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,
+                                              &s->cur_file_info_internal,
+                                              NULL,0,NULL,0,NULL,0);
+    s->current_file_ok = (err == UNZ_OK);
+    return err;
+}
+
+extern int ZEXPORT unzSetOffset (unzFile file, uLong pos)
+{
+    return unzSetOffset64(file,pos);
+}
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/minizip/unzip.h b/Engine/lib/assimp/contrib/zlib/contrib/minizip/unzip.h
new file mode 100644
index 000000000..2104e3915
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/minizip/unzip.h
@@ -0,0 +1,437 @@
+/* unzip.h -- IO for uncompress .zip files using zlib
+   Version 1.1, February 14h, 2010
+   part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Modifications of Unzip for Zip64
+         Copyright (C) 2007-2008 Even Rouault
+
+         Modifications for Zip64 support on both zip and unzip
+         Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+
+         For more info read MiniZip_info.txt
+
+         ---------------------------------------------------------------------------------
+
+        Condition of use and distribution are the same than zlib :
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  ---------------------------------------------------------------------------------
+
+        Changes
+
+        See header of unzip64.c
+
+*/
+
+#ifndef _unz64_H
+#define _unz64_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef _ZLIB_H
+#include "zlib.h"
+#endif
+
+#ifndef  _ZLIBIOAPI_H
+#include "ioapi.h"
+#endif
+
+#ifdef HAVE_BZIP2
+#include "bzlib.h"
+#endif
+
+#define Z_BZIP2ED 12
+
+#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)
+/* like the STRICT of WIN32, we define a pointer that cannot be converted
+    from (void*) without cast */
+typedef struct TagunzFile__ { int unused; } unzFile__;
+typedef unzFile__ *unzFile;
+#else
+typedef voidp unzFile;
+#endif
+
+
+#define UNZ_OK                          (0)
+#define UNZ_END_OF_LIST_OF_FILE         (-100)
+#define UNZ_ERRNO                       (Z_ERRNO)
+#define UNZ_EOF                         (0)
+#define UNZ_PARAMERROR                  (-102)
+#define UNZ_BADZIPFILE                  (-103)
+#define UNZ_INTERNALERROR               (-104)
+#define UNZ_CRCERROR                    (-105)
+
+/* tm_unz contain date/time info */
+typedef struct tm_unz_s
+{
+    uInt tm_sec;            /* seconds after the minute - [0,59] */
+    uInt tm_min;            /* minutes after the hour - [0,59] */
+    uInt tm_hour;           /* hours since midnight - [0,23] */
+    uInt tm_mday;           /* day of the month - [1,31] */
+    uInt tm_mon;            /* months since January - [0,11] */
+    uInt tm_year;           /* years - [1980..2044] */
+} tm_unz;
+
+/* unz_global_info structure contain global data about the ZIPfile
+   These data comes from the end of central dir */
+typedef struct unz_global_info64_s
+{
+    ZPOS64_T number_entry;         /* total number of entries in
+                                     the central dir on this disk */
+    uLong size_comment;         /* size of the global comment of the zipfile */
+} unz_global_info64;
+
+typedef struct unz_global_info_s
+{
+    uLong number_entry;         /* total number of entries in
+                                     the central dir on this disk */
+    uLong size_comment;         /* size of the global comment of the zipfile */
+} unz_global_info;
+
+/* unz_file_info contain information about a file in the zipfile */
+typedef struct unz_file_info64_s
+{
+    uLong version;              /* version made by                 2 bytes */
+    uLong version_needed;       /* version needed to extract       2 bytes */
+    uLong flag;                 /* general purpose bit flag        2 bytes */
+    uLong compression_method;   /* compression method              2 bytes */
+    uLong dosDate;              /* last mod file date in Dos fmt   4 bytes */
+    uLong crc;                  /* crc-32                          4 bytes */
+    ZPOS64_T compressed_size;   /* compressed size                 8 bytes */
+    ZPOS64_T uncompressed_size; /* uncompressed size               8 bytes */
+    uLong size_filename;        /* filename length                 2 bytes */
+    uLong size_file_extra;      /* extra field length              2 bytes */
+    uLong size_file_comment;    /* file comment length             2 bytes */
+
+    uLong disk_num_start;       /* disk number start               2 bytes */
+    uLong internal_fa;          /* internal file attributes        2 bytes */
+    uLong external_fa;          /* external file attributes        4 bytes */
+
+    tm_unz tmu_date;
+} unz_file_info64;
+
+typedef struct unz_file_info_s
+{
+    uLong version;              /* version made by                 2 bytes */
+    uLong version_needed;       /* version needed to extract       2 bytes */
+    uLong flag;                 /* general purpose bit flag        2 bytes */
+    uLong compression_method;   /* compression method              2 bytes */
+    uLong dosDate;              /* last mod file date in Dos fmt   4 bytes */
+    uLong crc;                  /* crc-32                          4 bytes */
+    uLong compressed_size;      /* compressed size                 4 bytes */
+    uLong uncompressed_size;    /* uncompressed size               4 bytes */
+    uLong size_filename;        /* filename length                 2 bytes */
+    uLong size_file_extra;      /* extra field length              2 bytes */
+    uLong size_file_comment;    /* file comment length             2 bytes */
+
+    uLong disk_num_start;       /* disk number start               2 bytes */
+    uLong internal_fa;          /* internal file attributes        2 bytes */
+    uLong external_fa;          /* external file attributes        4 bytes */
+
+    tm_unz tmu_date;
+} unz_file_info;
+
+extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1,
+                                                 const char* fileName2,
+                                                 int iCaseSensitivity));
+/*
+   Compare two filename (fileName1,fileName2).
+   If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
+   If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
+                                or strcasecmp)
+   If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
+    (like 1 on Unix, 2 on Windows)
+*/
+
+
+extern unzFile ZEXPORT unzOpen OF((const char *path));
+extern unzFile ZEXPORT unzOpen64 OF((const void *path));
+/*
+  Open a Zip file. path contain the full pathname (by example,
+     on a Windows XP computer "c:\\zlib\\zlib113.zip" or on an Unix computer
+     "zlib/zlib113.zip".
+     If the zipfile cannot be opened (file don't exist or in not valid), the
+       return value is NULL.
+     Else, the return value is a unzFile Handle, usable with other function
+       of this unzip package.
+     the "64" function take a const void* pointer, because the path is just the
+       value passed to the open64_file_func callback.
+     Under Windows, if UNICODE is defined, using fill_fopen64_filefunc, the path
+       is a pointer to a wide unicode string (LPCTSTR is LPCWSTR), so const char*
+       does not describe the reality
+*/
+
+
+extern unzFile ZEXPORT unzOpen2 OF((const char *path,
+                                    zlib_filefunc_def* pzlib_filefunc_def));
+/*
+   Open a Zip file, like unzOpen, but provide a set of file low level API
+      for read/write the zip file (see ioapi.h)
+*/
+
+extern unzFile ZEXPORT unzOpen2_64 OF((const void *path,
+                                    zlib_filefunc64_def* pzlib_filefunc_def));
+/*
+   Open a Zip file, like unz64Open, but provide a set of file low level API
+      for read/write the zip file (see ioapi.h)
+*/
+
+extern int ZEXPORT unzClose OF((unzFile file));
+/*
+  Close a ZipFile opened with unzOpen.
+  If there is files inside the .Zip opened with unzOpenCurrentFile (see later),
+    these files MUST be closed with unzCloseCurrentFile before call unzClose.
+  return UNZ_OK if there is no problem. */
+
+extern int ZEXPORT unzGetGlobalInfo OF((unzFile file,
+                                        unz_global_info *pglobal_info));
+
+extern int ZEXPORT unzGetGlobalInfo64 OF((unzFile file,
+                                        unz_global_info64 *pglobal_info));
+/*
+  Write info about the ZipFile in the *pglobal_info structure.
+  No preparation of the structure is needed
+  return UNZ_OK if there is no problem. */
+
+
+extern int ZEXPORT unzGetGlobalComment OF((unzFile file,
+                                           char *szComment,
+                                           uLong uSizeBuf));
+/*
+  Get the global comment string of the ZipFile, in the szComment buffer.
+  uSizeBuf is the size of the szComment buffer.
+  return the number of byte copied or an error code <0
+*/
+
+
+/***************************************************************************/
+/* Unzip package allow you browse the directory of the zipfile */
+
+extern int ZEXPORT unzGoToFirstFile OF((unzFile file));
+/*
+  Set the current file of the zipfile to the first file.
+  return UNZ_OK if there is no problem
+*/
+
+extern int ZEXPORT unzGoToNextFile OF((unzFile file));
+/*
+  Set the current file of the zipfile to the next file.
+  return UNZ_OK if there is no problem
+  return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
+*/
+
+extern int ZEXPORT unzLocateFile OF((unzFile file,
+                     const char *szFileName,
+                     int iCaseSensitivity));
+/*
+  Try locate the file szFileName in the zipfile.
+  For the iCaseSensitivity signification, see unzStringFileNameCompare
+
+  return value :
+  UNZ_OK if the file is found. It becomes the current file.
+  UNZ_END_OF_LIST_OF_FILE if the file is not found
+*/
+
+
+/* ****************************************** */
+/* Ryan supplied functions */
+/* unz_file_info contain information about a file in the zipfile */
+typedef struct unz_file_pos_s
+{
+    uLong pos_in_zip_directory;   /* offset in zip file directory */
+    uLong num_of_file;            /* # of file */
+} unz_file_pos;
+
+extern int ZEXPORT unzGetFilePos(
+    unzFile file,
+    unz_file_pos* file_pos);
+
+extern int ZEXPORT unzGoToFilePos(
+    unzFile file,
+    unz_file_pos* file_pos);
+
+typedef struct unz64_file_pos_s
+{
+    ZPOS64_T pos_in_zip_directory;   /* offset in zip file directory */
+    ZPOS64_T num_of_file;            /* # of file */
+} unz64_file_pos;
+
+extern int ZEXPORT unzGetFilePos64(
+    unzFile file,
+    unz64_file_pos* file_pos);
+
+extern int ZEXPORT unzGoToFilePos64(
+    unzFile file,
+    const unz64_file_pos* file_pos);
+
+/* ****************************************** */
+
+extern int ZEXPORT unzGetCurrentFileInfo64 OF((unzFile file,
+                         unz_file_info64 *pfile_info,
+                         char *szFileName,
+                         uLong fileNameBufferSize,
+                         void *extraField,
+                         uLong extraFieldBufferSize,
+                         char *szComment,
+                         uLong commentBufferSize));
+
+extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file,
+                         unz_file_info *pfile_info,
+                         char *szFileName,
+                         uLong fileNameBufferSize,
+                         void *extraField,
+                         uLong extraFieldBufferSize,
+                         char *szComment,
+                         uLong commentBufferSize));
+/*
+  Get Info about the current file
+  if pfile_info!=NULL, the *pfile_info structure will contain somes info about
+        the current file
+  if szFileName!=NULL, the filemane string will be copied in szFileName
+            (fileNameBufferSize is the size of the buffer)
+  if extraField!=NULL, the extra field information will be copied in extraField
+            (extraFieldBufferSize is the size of the buffer).
+            This is the Central-header version of the extra field
+  if szComment!=NULL, the comment string of the file will be copied in szComment
+            (commentBufferSize is the size of the buffer)
+*/
+
+
+/** Addition for GDAL : START */
+
+extern ZPOS64_T ZEXPORT unzGetCurrentFileZStreamPos64 OF((unzFile file));
+
+/** Addition for GDAL : END */
+
+
+/***************************************************************************/
+/* for reading the content of the current zipfile, you can open it, read data
+   from it, and close it (you can close it before reading all the file)
+   */
+
+extern int ZEXPORT unzOpenCurrentFile OF((unzFile file));
+/*
+  Open for reading data the current file in the zipfile.
+  If there is no error, the return value is UNZ_OK.
+*/
+
+extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file,
+                                                  const char* password));
+/*
+  Open for reading data the current file in the zipfile.
+  password is a crypting password
+  If there is no error, the return value is UNZ_OK.
+*/
+
+extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file,
+                                           int* method,
+                                           int* level,
+                                           int raw));
+/*
+  Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
+    if raw==1
+  *method will receive method of compression, *level will receive level of
+     compression
+  note : you can set level parameter as NULL (if you did not want known level,
+         but you CANNOT set method parameter as NULL
+*/
+
+extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file,
+                                           int* method,
+                                           int* level,
+                                           int raw,
+                                           const char* password));
+/*
+  Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
+    if raw==1
+  *method will receive method of compression, *level will receive level of
+     compression
+  note : you can set level parameter as NULL (if you did not want known level,
+         but you CANNOT set method parameter as NULL
+*/
+
+
+extern int ZEXPORT unzCloseCurrentFile OF((unzFile file));
+/*
+  Close the file in zip opened with unzOpenCurrentFile
+  Return UNZ_CRCERROR if all the file was read but the CRC is not good
+*/
+
+extern int ZEXPORT unzReadCurrentFile OF((unzFile file,
+                      voidp buf,
+                      unsigned len));
+/*
+  Read bytes from the current file (opened by unzOpenCurrentFile)
+  buf contain buffer where data must be copied
+  len the size of buf.
+
+  return the number of byte copied if somes bytes are copied
+  return 0 if the end of file was reached
+  return <0 with error code if there is an error
+    (UNZ_ERRNO for IO error, or zLib error for uncompress error)
+*/
+
+extern z_off_t ZEXPORT unztell OF((unzFile file));
+
+extern ZPOS64_T ZEXPORT unztell64 OF((unzFile file));
+/*
+  Give the current position in uncompressed data
+*/
+
+extern int ZEXPORT unzeof OF((unzFile file));
+/*
+  return 1 if the end of file was reached, 0 elsewhere
+*/
+
+extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file,
+                                             voidp buf,
+                                             unsigned len));
+/*
+  Read extra field from the current file (opened by unzOpenCurrentFile)
+  This is the local-header version of the extra field (sometimes, there is
+    more info in the local-header version than in the central-header)
+
+  if buf==NULL, it return the size of the local extra field
+
+  if buf!=NULL, len is the size of the buffer, the extra header is copied in
+    buf.
+  the return value is the number of bytes copied in buf, or (if <0)
+    the error code
+*/
+
+/***************************************************************************/
+
+/* Get the current file offset */
+extern ZPOS64_T ZEXPORT unzGetOffset64 (unzFile file);
+extern uLong ZEXPORT unzGetOffset (unzFile file);
+
+/* Set the current file offset */
+extern int ZEXPORT unzSetOffset64 (unzFile file, ZPOS64_T pos);
+extern int ZEXPORT unzSetOffset (unzFile file, uLong pos);
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _unz64_H */
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/minizip/zip.c b/Engine/lib/assimp/contrib/zlib/contrib/minizip/zip.c
new file mode 100644
index 000000000..44e88a9cb
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/minizip/zip.c
@@ -0,0 +1,2007 @@
+/* zip.c -- IO on .zip files using zlib
+   Version 1.1, February 14h, 2010
+   part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Modifications for Zip64 support
+         Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+
+         For more info read MiniZip_info.txt
+
+         Changes
+   Oct-2009 - Mathias Svensson - Remove old C style function prototypes
+   Oct-2009 - Mathias Svensson - Added Zip64 Support when creating new file archives
+   Oct-2009 - Mathias Svensson - Did some code cleanup and refactoring to get better overview of some functions.
+   Oct-2009 - Mathias Svensson - Added zipRemoveExtraInfoBlock to strip extra field data from its ZIP64 data
+                                 It is used when recreting zip archive with RAW when deleting items from a zip.
+                                 ZIP64 data is automatically added to items that needs it, and existing ZIP64 data need to be removed.
+   Oct-2009 - Mathias Svensson - Added support for BZIP2 as compression mode (bzip2 lib is required)
+   Jan-2010 - back to unzip and minizip 1.0 name scheme, with compatibility layer
+
+*/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include "zlib.h"
+#include "zip.h"
+
+#ifdef STDC
+#  include <stddef.h>
+#  include <string.h>
+#  include <stdlib.h>
+#endif
+#ifdef NO_ERRNO_H
+    extern int errno;
+#else
+#   include <errno.h>
+#endif
+
+
+#ifndef local
+#  define local static
+#endif
+/* compile with -Dlocal if your debugger can't find static symbols */
+
+#ifndef VERSIONMADEBY
+# define VERSIONMADEBY   (0x0) /* platform depedent */
+#endif
+
+#ifndef Z_BUFSIZE
+#define Z_BUFSIZE (64*1024) //(16384)
+#endif
+
+#ifndef Z_MAXFILENAMEINZIP
+#define Z_MAXFILENAMEINZIP (256)
+#endif
+
+#ifndef ALLOC
+# define ALLOC(size) (malloc(size))
+#endif
+#ifndef TRYFREE
+# define TRYFREE(p) {if (p) free(p);}
+#endif
+
+/*
+#define SIZECENTRALDIRITEM (0x2e)
+#define SIZEZIPLOCALHEADER (0x1e)
+*/
+
+/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
+
+
+// NOT sure that this work on ALL platform
+#define MAKEULONG64(a, b) ((ZPOS64_T)(((unsigned long)(a)) | ((ZPOS64_T)((unsigned long)(b))) << 32))
+
+#ifndef SEEK_CUR
+#define SEEK_CUR    1
+#endif
+
+#ifndef SEEK_END
+#define SEEK_END    2
+#endif
+
+#ifndef SEEK_SET
+#define SEEK_SET    0
+#endif
+
+#ifndef DEF_MEM_LEVEL
+#if MAX_MEM_LEVEL >= 8
+#  define DEF_MEM_LEVEL 8
+#else
+#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
+#endif
+#endif
+const char zip_copyright[] =" zip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll";
+
+
+#define SIZEDATA_INDATABLOCK (4096-(4*4))
+
+#define LOCALHEADERMAGIC    (0x04034b50)
+#define CENTRALHEADERMAGIC  (0x02014b50)
+#define ENDHEADERMAGIC      (0x06054b50)
+#define ZIP64ENDHEADERMAGIC      (0x6064b50)
+#define ZIP64ENDLOCHEADERMAGIC   (0x7064b50)
+
+#define FLAG_LOCALHEADER_OFFSET (0x06)
+#define CRC_LOCALHEADER_OFFSET  (0x0e)
+
+#define SIZECENTRALHEADER (0x2e) /* 46 */
+
+typedef struct linkedlist_datablock_internal_s
+{
+  struct linkedlist_datablock_internal_s* next_datablock;
+  uLong  avail_in_this_block;
+  uLong  filled_in_this_block;
+  uLong  unused; /* for future use and alignment */
+  unsigned char data[SIZEDATA_INDATABLOCK];
+} linkedlist_datablock_internal;
+
+typedef struct linkedlist_data_s
+{
+    linkedlist_datablock_internal* first_block;
+    linkedlist_datablock_internal* last_block;
+} linkedlist_data;
+
+
+typedef struct
+{
+    z_stream stream;            /* zLib stream structure for inflate */
+#ifdef HAVE_BZIP2
+    bz_stream bstream;          /* bzLib stream structure for bziped */
+#endif
+
+    int  stream_initialised;    /* 1 is stream is initialised */
+    uInt pos_in_buffered_data;  /* last written byte in buffered_data */
+
+    ZPOS64_T pos_local_header;     /* offset of the local header of the file
+                                     currenty writing */
+    char* central_header;       /* central header data for the current file */
+    uLong size_centralExtra;
+    uLong size_centralheader;   /* size of the central header for cur file */
+    uLong size_centralExtraFree; /* Extra bytes allocated to the centralheader but that are not used */
+    uLong flag;                 /* flag of the file currently writing */
+
+    int  method;                /* compression method of file currenty wr.*/
+    int  raw;                   /* 1 for directly writing raw data */
+    Byte buffered_data[Z_BUFSIZE];/* buffer contain compressed data to be writ*/
+    uLong dosDate;
+    uLong crc32;
+    int  encrypt;
+    int  zip64;               /* Add ZIP64 extened information in the extra field */
+    ZPOS64_T pos_zip64extrainfo;
+    ZPOS64_T totalCompressedData;
+    ZPOS64_T totalUncompressedData;
+#ifndef NOCRYPT
+    unsigned long keys[3];     /* keys defining the pseudo-random sequence */
+    const z_crc_t* pcrc_32_tab;
+    int crypt_header_size;
+#endif
+} curfile64_info;
+
+typedef struct
+{
+    zlib_filefunc64_32_def z_filefunc;
+    voidpf filestream;        /* io structore of the zipfile */
+    linkedlist_data central_dir;/* datablock with central dir in construction*/
+    int  in_opened_file_inzip;  /* 1 if a file in the zip is currently writ.*/
+    curfile64_info ci;            /* info on the file curretly writing */
+
+    ZPOS64_T begin_pos;            /* position of the beginning of the zipfile */
+    ZPOS64_T add_position_when_writing_offset;
+    ZPOS64_T number_entry;
+
+#ifndef NO_ADDFILEINEXISTINGZIP
+    char *globalcomment;
+#endif
+
+} zip64_internal;
+
+
+#ifndef NOCRYPT
+#define INCLUDECRYPTINGCODE_IFCRYPTALLOWED
+#include "crypt.h"
+#endif
+
+local linkedlist_datablock_internal* allocate_new_datablock()
+{
+    linkedlist_datablock_internal* ldi;
+    ldi = (linkedlist_datablock_internal*)
+                 ALLOC(sizeof(linkedlist_datablock_internal));
+    if (ldi!=NULL)
+    {
+        ldi->next_datablock = NULL ;
+        ldi->filled_in_this_block = 0 ;
+        ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ;
+    }
+    return ldi;
+}
+
+local void free_datablock(linkedlist_datablock_internal* ldi)
+{
+    while (ldi!=NULL)
+    {
+        linkedlist_datablock_internal* ldinext = ldi->next_datablock;
+        TRYFREE(ldi);
+        ldi = ldinext;
+    }
+}
+
+local void init_linkedlist(linkedlist_data* ll)
+{
+    ll->first_block = ll->last_block = NULL;
+}
+
+local void free_linkedlist(linkedlist_data* ll)
+{
+    free_datablock(ll->first_block);
+    ll->first_block = ll->last_block = NULL;
+}
+
+
+local int add_data_in_datablock(linkedlist_data* ll, const void* buf, uLong len)
+{
+    linkedlist_datablock_internal* ldi;
+    const unsigned char* from_copy;
+
+    if (ll==NULL)
+        return ZIP_INTERNALERROR;
+
+    if (ll->last_block == NULL)
+    {
+        ll->first_block = ll->last_block = allocate_new_datablock();
+        if (ll->first_block == NULL)
+            return ZIP_INTERNALERROR;
+    }
+
+    ldi = ll->last_block;
+    from_copy = (unsigned char*)buf;
+
+    while (len>0)
+    {
+        uInt copy_this;
+        uInt i;
+        unsigned char* to_copy;
+
+        if (ldi->avail_in_this_block==0)
+        {
+            ldi->next_datablock = allocate_new_datablock();
+            if (ldi->next_datablock == NULL)
+                return ZIP_INTERNALERROR;
+            ldi = ldi->next_datablock ;
+            ll->last_block = ldi;
+        }
+
+        if (ldi->avail_in_this_block < len)
+            copy_this = (uInt)ldi->avail_in_this_block;
+        else
+            copy_this = (uInt)len;
+
+        to_copy = &(ldi->data[ldi->filled_in_this_block]);
+
+        for (i=0;i<copy_this;i++)
+            *(to_copy+i)=*(from_copy+i);
+
+        ldi->filled_in_this_block += copy_this;
+        ldi->avail_in_this_block -= copy_this;
+        from_copy += copy_this ;
+        len -= copy_this;
+    }
+    return ZIP_OK;
+}
+
+
+
+/****************************************************************************/
+
+#ifndef NO_ADDFILEINEXISTINGZIP
+/* ===========================================================================
+   Inputs a long in LSB order to the given file
+   nbByte == 1, 2 ,4 or 8 (byte, short or long, ZPOS64_T)
+*/
+
+local int zip64local_putValue OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T x, int nbByte));
+local int zip64local_putValue (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T x, int nbByte)
+{
+    unsigned char buf[8];
+    int n;
+    for (n = 0; n < nbByte; n++)
+    {
+        buf[n] = (unsigned char)(x & 0xff);
+        x >>= 8;
+    }
+    if (x != 0)
+      {     /* data overflow - hack for ZIP64 (X Roche) */
+      for (n = 0; n < nbByte; n++)
+        {
+          buf[n] = 0xff;
+        }
+      }
+
+    if (ZWRITE64(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte)
+        return ZIP_ERRNO;
+    else
+        return ZIP_OK;
+}
+
+local void zip64local_putValue_inmemory OF((void* dest, ZPOS64_T x, int nbByte));
+local void zip64local_putValue_inmemory (void* dest, ZPOS64_T x, int nbByte)
+{
+    unsigned char* buf=(unsigned char*)dest;
+    int n;
+    for (n = 0; n < nbByte; n++) {
+        buf[n] = (unsigned char)(x & 0xff);
+        x >>= 8;
+    }
+
+    if (x != 0)
+    {     /* data overflow - hack for ZIP64 */
+       for (n = 0; n < nbByte; n++)
+       {
+          buf[n] = 0xff;
+       }
+    }
+}
+
+/****************************************************************************/
+
+
+local uLong zip64local_TmzDateToDosDate(const tm_zip* ptm)
+{
+    uLong year = (uLong)ptm->tm_year;
+    if (year>=1980)
+        year-=1980;
+    else if (year>=80)
+        year-=80;
+    return
+      (uLong) (((ptm->tm_mday) + (32 * (ptm->tm_mon+1)) + (512 * year)) << 16) |
+        ((ptm->tm_sec/2) + (32* ptm->tm_min) + (2048 * (uLong)ptm->tm_hour));
+}
+
+
+/****************************************************************************/
+
+local int zip64local_getByte OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, int *pi));
+
+local int zip64local_getByte(const zlib_filefunc64_32_def* pzlib_filefunc_def,voidpf filestream,int* pi)
+{
+    unsigned char c;
+    int err = (int)ZREAD64(*pzlib_filefunc_def,filestream,&c,1);
+    if (err==1)
+    {
+        *pi = (int)c;
+        return ZIP_OK;
+    }
+    else
+    {
+        if (ZERROR64(*pzlib_filefunc_def,filestream))
+            return ZIP_ERRNO;
+        else
+            return ZIP_EOF;
+    }
+}
+
+
+/* ===========================================================================
+   Reads a long in LSB order from the given gz_stream. Sets
+*/
+local int zip64local_getShort OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong *pX));
+
+local int zip64local_getShort (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong* pX)
+{
+    uLong x ;
+    int i = 0;
+    int err;
+
+    err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+    x = (uLong)i;
+
+    if (err==ZIP_OK)
+        err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+    x += ((uLong)i)<<8;
+
+    if (err==ZIP_OK)
+        *pX = x;
+    else
+        *pX = 0;
+    return err;
+}
+
+local int zip64local_getLong OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong *pX));
+
+local int zip64local_getLong (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong* pX)
+{
+    uLong x ;
+    int i = 0;
+    int err;
+
+    err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+    x = (uLong)i;
+
+    if (err==ZIP_OK)
+        err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+    x += ((uLong)i)<<8;
+
+    if (err==ZIP_OK)
+        err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+    x += ((uLong)i)<<16;
+
+    if (err==ZIP_OK)
+        err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+    x += ((uLong)i)<<24;
+
+    if (err==ZIP_OK)
+        *pX = x;
+    else
+        *pX = 0;
+    return err;
+}
+
+local int zip64local_getLong64 OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX));
+
+
+local int zip64local_getLong64 (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX)
+{
+  ZPOS64_T x;
+  int i = 0;
+  int err;
+
+  err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+  x = (ZPOS64_T)i;
+
+  if (err==ZIP_OK)
+    err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+  x += ((ZPOS64_T)i)<<8;
+
+  if (err==ZIP_OK)
+    err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+  x += ((ZPOS64_T)i)<<16;
+
+  if (err==ZIP_OK)
+    err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+  x += ((ZPOS64_T)i)<<24;
+
+  if (err==ZIP_OK)
+    err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+  x += ((ZPOS64_T)i)<<32;
+
+  if (err==ZIP_OK)
+    err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+  x += ((ZPOS64_T)i)<<40;
+
+  if (err==ZIP_OK)
+    err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+  x += ((ZPOS64_T)i)<<48;
+
+  if (err==ZIP_OK)
+    err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+  x += ((ZPOS64_T)i)<<56;
+
+  if (err==ZIP_OK)
+    *pX = x;
+  else
+    *pX = 0;
+
+  return err;
+}
+
+#ifndef BUFREADCOMMENT
+#define BUFREADCOMMENT (0x400)
+#endif
+/*
+  Locate the Central directory of a zipfile (at the end, just before
+    the global comment)
+*/
+local ZPOS64_T zip64local_SearchCentralDir OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream));
+
+local ZPOS64_T zip64local_SearchCentralDir(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)
+{
+  unsigned char* buf;
+  ZPOS64_T uSizeFile;
+  ZPOS64_T uBackRead;
+  ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
+  ZPOS64_T uPosFound=0;
+
+  if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
+    return 0;
+
+
+  uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);
+
+  if (uMaxBack>uSizeFile)
+    uMaxBack = uSizeFile;
+
+  buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
+  if (buf==NULL)
+    return 0;
+
+  uBackRead = 4;
+  while (uBackRead<uMaxBack)
+  {
+    uLong uReadSize;
+    ZPOS64_T uReadPos ;
+    int i;
+    if (uBackRead+BUFREADCOMMENT>uMaxBack)
+      uBackRead = uMaxBack;
+    else
+      uBackRead+=BUFREADCOMMENT;
+    uReadPos = uSizeFile-uBackRead ;
+
+    uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
+      (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
+    if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
+      break;
+
+    if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
+      break;
+
+    for (i=(int)uReadSize-3; (i--)>0;)
+      if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
+        ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
+      {
+        uPosFound = uReadPos+i;
+        break;
+      }
+
+      if (uPosFound!=0)
+        break;
+  }
+  TRYFREE(buf);
+  return uPosFound;
+}
+
+/*
+Locate the End of Zip64 Central directory locator and from there find the CD of a zipfile (at the end, just before
+the global comment)
+*/
+local ZPOS64_T zip64local_SearchCentralDir64 OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream));
+
+local ZPOS64_T zip64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)
+{
+  unsigned char* buf;
+  ZPOS64_T uSizeFile;
+  ZPOS64_T uBackRead;
+  ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
+  ZPOS64_T uPosFound=0;
+  uLong uL;
+  ZPOS64_T relativeOffset;
+
+  if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
+    return 0;
+
+  uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);
+
+  if (uMaxBack>uSizeFile)
+    uMaxBack = uSizeFile;
+
+  buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
+  if (buf==NULL)
+    return 0;
+
+  uBackRead = 4;
+  while (uBackRead<uMaxBack)
+  {
+    uLong uReadSize;
+    ZPOS64_T uReadPos;
+    int i;
+    if (uBackRead+BUFREADCOMMENT>uMaxBack)
+      uBackRead = uMaxBack;
+    else
+      uBackRead+=BUFREADCOMMENT;
+    uReadPos = uSizeFile-uBackRead ;
+
+    uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
+      (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
+    if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
+      break;
+
+    if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
+      break;
+
+    for (i=(int)uReadSize-3; (i--)>0;)
+    {
+      // Signature "0x07064b50" Zip64 end of central directory locater
+      if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && ((*(buf+i+2))==0x06) && ((*(buf+i+3))==0x07))
+      {
+        uPosFound = uReadPos+i;
+        break;
+      }
+    }
+
+      if (uPosFound!=0)
+        break;
+  }
+
+  TRYFREE(buf);
+  if (uPosFound == 0)
+    return 0;
+
+  /* Zip64 end of central directory locator */
+  if (ZSEEK64(*pzlib_filefunc_def,filestream, uPosFound,ZLIB_FILEFUNC_SEEK_SET)!=0)
+    return 0;
+
+  /* the signature, already checked */
+  if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK)
+    return 0;
+
+  /* number of the disk with the start of the zip64 end of  central directory */
+  if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK)
+    return 0;
+  if (uL != 0)
+    return 0;
+
+  /* relative offset of the zip64 end of central directory record */
+  if (zip64local_getLong64(pzlib_filefunc_def,filestream,&relativeOffset)!=ZIP_OK)
+    return 0;
+
+  /* total number of disks */
+  if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK)
+    return 0;
+  if (uL != 1)
+    return 0;
+
+  /* Goto Zip64 end of central directory record */
+  if (ZSEEK64(*pzlib_filefunc_def,filestream, relativeOffset,ZLIB_FILEFUNC_SEEK_SET)!=0)
+    return 0;
+
+  /* the signature */
+  if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK)
+    return 0;
+
+  if (uL != 0x06064b50) // signature of 'Zip64 end of central directory'
+    return 0;
+
+  return relativeOffset;
+}
+
+int LoadCentralDirectoryRecord(zip64_internal* pziinit)
+{
+  int err=ZIP_OK;
+  ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
+
+  ZPOS64_T size_central_dir;     /* size of the central directory  */
+  ZPOS64_T offset_central_dir;   /* offset of start of central directory */
+  ZPOS64_T central_pos;
+  uLong uL;
+
+  uLong number_disk;          /* number of the current dist, used for
+                              spaning ZIP, unsupported, always 0*/
+  uLong number_disk_with_CD;  /* number the the disk with central dir, used
+                              for spaning ZIP, unsupported, always 0*/
+  ZPOS64_T number_entry;
+  ZPOS64_T number_entry_CD;      /* total number of entries in
+                                the central dir
+                                (same than number_entry on nospan) */
+  uLong VersionMadeBy;
+  uLong VersionNeeded;
+  uLong size_comment;
+
+  int hasZIP64Record = 0;
+
+  // check first if we find a ZIP64 record
+  central_pos = zip64local_SearchCentralDir64(&pziinit->z_filefunc,pziinit->filestream);
+  if(central_pos > 0)
+  {
+    hasZIP64Record = 1;
+  }
+  else if(central_pos == 0)
+  {
+    central_pos = zip64local_SearchCentralDir(&pziinit->z_filefunc,pziinit->filestream);
+  }
+
+/* disable to allow appending to empty ZIP archive
+        if (central_pos==0)
+            err=ZIP_ERRNO;
+*/
+
+  if(hasZIP64Record)
+  {
+    ZPOS64_T sizeEndOfCentralDirectory;
+    if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, central_pos, ZLIB_FILEFUNC_SEEK_SET) != 0)
+      err=ZIP_ERRNO;
+
+    /* the signature, already checked */
+    if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&uL)!=ZIP_OK)
+      err=ZIP_ERRNO;
+
+    /* size of zip64 end of central directory record */
+    if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream, &sizeEndOfCentralDirectory)!=ZIP_OK)
+      err=ZIP_ERRNO;
+
+    /* version made by */
+    if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &VersionMadeBy)!=ZIP_OK)
+      err=ZIP_ERRNO;
+
+    /* version needed to extract */
+    if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &VersionNeeded)!=ZIP_OK)
+      err=ZIP_ERRNO;
+
+    /* number of this disk */
+    if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&number_disk)!=ZIP_OK)
+      err=ZIP_ERRNO;
+
+    /* number of the disk with the start of the central directory */
+    if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&number_disk_with_CD)!=ZIP_OK)
+      err=ZIP_ERRNO;
+
+    /* total number of entries in the central directory on this disk */
+    if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream, &number_entry)!=ZIP_OK)
+      err=ZIP_ERRNO;
+
+    /* total number of entries in the central directory */
+    if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&number_entry_CD)!=ZIP_OK)
+      err=ZIP_ERRNO;
+
+    if ((number_entry_CD!=number_entry) || (number_disk_with_CD!=0) || (number_disk!=0))
+      err=ZIP_BADZIPFILE;
+
+    /* size of the central directory */
+    if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&size_central_dir)!=ZIP_OK)
+      err=ZIP_ERRNO;
+
+    /* offset of start of central directory with respect to the
+    starting disk number */
+    if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&offset_central_dir)!=ZIP_OK)
+      err=ZIP_ERRNO;
+
+    // TODO..
+    // read the comment from the standard central header.
+    size_comment = 0;
+  }
+  else
+  {
+    // Read End of central Directory info
+    if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
+      err=ZIP_ERRNO;
+
+    /* the signature, already checked */
+    if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&uL)!=ZIP_OK)
+      err=ZIP_ERRNO;
+
+    /* number of this disk */
+    if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,&number_disk)!=ZIP_OK)
+      err=ZIP_ERRNO;
+
+    /* number of the disk with the start of the central directory */
+    if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,&number_disk_with_CD)!=ZIP_OK)
+      err=ZIP_ERRNO;
+
+    /* total number of entries in the central dir on this disk */
+    number_entry = 0;
+    if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK)
+      err=ZIP_ERRNO;
+    else
+      number_entry = uL;
+
+    /* total number of entries in the central dir */
+    number_entry_CD = 0;
+    if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK)
+      err=ZIP_ERRNO;
+    else
+      number_entry_CD = uL;
+
+    if ((number_entry_CD!=number_entry) || (number_disk_with_CD!=0) || (number_disk!=0))
+      err=ZIP_BADZIPFILE;
+
+    /* size of the central directory */
+    size_central_dir = 0;
+    if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK)
+      err=ZIP_ERRNO;
+    else
+      size_central_dir = uL;
+
+    /* offset of start of central directory with respect to the starting disk number */
+    offset_central_dir = 0;
+    if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK)
+      err=ZIP_ERRNO;
+    else
+      offset_central_dir = uL;
+
+
+    /* zipfile global comment length */
+    if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &size_comment)!=ZIP_OK)
+      err=ZIP_ERRNO;
+  }
+
+  if ((central_pos<offset_central_dir+size_central_dir) &&
+    (err==ZIP_OK))
+    err=ZIP_BADZIPFILE;
+
+  if (err!=ZIP_OK)
+  {
+    ZCLOSE64(pziinit->z_filefunc, pziinit->filestream);
+    return ZIP_ERRNO;
+  }
+
+  if (size_comment>0)
+  {
+    pziinit->globalcomment = (char*)ALLOC(size_comment+1);
+    if (pziinit->globalcomment)
+    {
+      size_comment = ZREAD64(pziinit->z_filefunc, pziinit->filestream, pziinit->globalcomment,size_comment);
+      pziinit->globalcomment[size_comment]=0;
+    }
+  }
+
+  byte_before_the_zipfile = central_pos - (offset_central_dir+size_central_dir);
+  pziinit->add_position_when_writing_offset = byte_before_the_zipfile;
+
+  {
+    ZPOS64_T size_central_dir_to_read = size_central_dir;
+    size_t buf_size = SIZEDATA_INDATABLOCK;
+    void* buf_read = (void*)ALLOC(buf_size);
+    if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, offset_central_dir + byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0)
+      err=ZIP_ERRNO;
+
+    while ((size_central_dir_to_read>0) && (err==ZIP_OK))
+    {
+      ZPOS64_T read_this = SIZEDATA_INDATABLOCK;
+      if (read_this > size_central_dir_to_read)
+        read_this = size_central_dir_to_read;
+
+      if (ZREAD64(pziinit->z_filefunc, pziinit->filestream,buf_read,(uLong)read_this) != read_this)
+        err=ZIP_ERRNO;
+
+      if (err==ZIP_OK)
+        err = add_data_in_datablock(&pziinit->central_dir,buf_read, (uLong)read_this);
+
+      size_central_dir_to_read-=read_this;
+    }
+    TRYFREE(buf_read);
+  }
+  pziinit->begin_pos = byte_before_the_zipfile;
+  pziinit->number_entry = number_entry_CD;
+
+  if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, offset_central_dir+byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET) != 0)
+    err=ZIP_ERRNO;
+
+  return err;
+}
+
+
+#endif /* !NO_ADDFILEINEXISTINGZIP*/
+
+
+/************************************************************/
+extern zipFile ZEXPORT zipOpen3 (const void *pathname, int append, zipcharpc* globalcomment, zlib_filefunc64_32_def* pzlib_filefunc64_32_def)
+{
+    zip64_internal ziinit;
+    zip64_internal* zi;
+    int err=ZIP_OK;
+
+    ziinit.z_filefunc.zseek32_file = NULL;
+    ziinit.z_filefunc.ztell32_file = NULL;
+    if (pzlib_filefunc64_32_def==NULL)
+        fill_fopen64_filefunc(&ziinit.z_filefunc.zfile_func64);
+    else
+        ziinit.z_filefunc = *pzlib_filefunc64_32_def;
+
+    ziinit.filestream = ZOPEN64(ziinit.z_filefunc,
+                  pathname,
+                  (append == APPEND_STATUS_CREATE) ?
+                  (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE) :
+                    (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING));
+
+    if (ziinit.filestream == NULL)
+        return NULL;
+
+    if (append == APPEND_STATUS_CREATEAFTER)
+        ZSEEK64(ziinit.z_filefunc,ziinit.filestream,0,SEEK_END);
+
+    ziinit.begin_pos = ZTELL64(ziinit.z_filefunc,ziinit.filestream);
+    ziinit.in_opened_file_inzip = 0;
+    ziinit.ci.stream_initialised = 0;
+    ziinit.number_entry = 0;
+    ziinit.add_position_when_writing_offset = 0;
+    init_linkedlist(&(ziinit.central_dir));
+
+
+
+    zi = (zip64_internal*)ALLOC(sizeof(zip64_internal));
+    if (zi==NULL)
+    {
+        ZCLOSE64(ziinit.z_filefunc,ziinit.filestream);
+        return NULL;
+    }
+
+    /* now we add file in a zipfile */
+#    ifndef NO_ADDFILEINEXISTINGZIP
+    ziinit.globalcomment = NULL;
+    if (append == APPEND_STATUS_ADDINZIP)
+    {
+      // Read and Cache Central Directory Records
+      err = LoadCentralDirectoryRecord(&ziinit);
+    }
+
+    if (globalcomment)
+    {
+      *globalcomment = ziinit.globalcomment;
+    }
+#    endif /* !NO_ADDFILEINEXISTINGZIP*/
+
+    if (err != ZIP_OK)
+    {
+#    ifndef NO_ADDFILEINEXISTINGZIP
+        TRYFREE(ziinit.globalcomment);
+#    endif /* !NO_ADDFILEINEXISTINGZIP*/
+        TRYFREE(zi);
+        return NULL;
+    }
+    else
+    {
+        *zi = ziinit;
+        return (zipFile)zi;
+    }
+}
+
+extern zipFile ZEXPORT zipOpen2 (const char *pathname, int append, zipcharpc* globalcomment, zlib_filefunc_def* pzlib_filefunc32_def)
+{
+    if (pzlib_filefunc32_def != NULL)
+    {
+        zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
+        fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill,pzlib_filefunc32_def);
+        return zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill);
+    }
+    else
+        return zipOpen3(pathname, append, globalcomment, NULL);
+}
+
+extern zipFile ZEXPORT zipOpen2_64 (const void *pathname, int append, zipcharpc* globalcomment, zlib_filefunc64_def* pzlib_filefunc_def)
+{
+    if (pzlib_filefunc_def != NULL)
+    {
+        zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
+        zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def;
+        zlib_filefunc64_32_def_fill.ztell32_file = NULL;
+        zlib_filefunc64_32_def_fill.zseek32_file = NULL;
+        return zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill);
+    }
+    else
+        return zipOpen3(pathname, append, globalcomment, NULL);
+}
+
+
+
+extern zipFile ZEXPORT zipOpen (const char* pathname, int append)
+{
+    return zipOpen3((const void*)pathname,append,NULL,NULL);
+}
+
+extern zipFile ZEXPORT zipOpen64 (const void* pathname, int append)
+{
+    return zipOpen3(pathname,append,NULL,NULL);
+}
+
+int Write_LocalFileHeader(zip64_internal* zi, const char* filename, uInt size_extrafield_local, const void* extrafield_local)
+{
+  /* write the local header */
+  int err;
+  uInt size_filename = (uInt)strlen(filename);
+  uInt size_extrafield = size_extrafield_local;
+
+  err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)LOCALHEADERMAGIC, 4);
+
+  if (err==ZIP_OK)
+  {
+    if(zi->ci.zip64)
+      err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2);/* version needed to extract */
+    else
+      err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)20,2);/* version needed to extract */
+  }
+
+  if (err==ZIP_OK)
+    err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.flag,2);
+
+  if (err==ZIP_OK)
+    err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.method,2);
+
+  if (err==ZIP_OK)
+    err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.dosDate,4);
+
+  // CRC / Compressed size / Uncompressed size will be filled in later and rewritten later
+  if (err==ZIP_OK)
+    err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* crc 32, unknown */
+  if (err==ZIP_OK)
+  {
+    if(zi->ci.zip64)
+      err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xFFFFFFFF,4); /* compressed size, unknown */
+    else
+      err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* compressed size, unknown */
+  }
+  if (err==ZIP_OK)
+  {
+    if(zi->ci.zip64)
+      err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xFFFFFFFF,4); /* uncompressed size, unknown */
+    else
+      err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* uncompressed size, unknown */
+  }
+
+  if (err==ZIP_OK)
+    err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_filename,2);
+
+  if(zi->ci.zip64)
+  {
+    size_extrafield += 20;
+  }
+
+  if (err==ZIP_OK)
+    err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_extrafield,2);
+
+  if ((err==ZIP_OK) && (size_filename > 0))
+  {
+    if (ZWRITE64(zi->z_filefunc,zi->filestream,filename,size_filename)!=size_filename)
+      err = ZIP_ERRNO;
+  }
+
+  if ((err==ZIP_OK) && (size_extrafield_local > 0))
+  {
+    if (ZWRITE64(zi->z_filefunc, zi->filestream, extrafield_local, size_extrafield_local) != size_extrafield_local)
+      err = ZIP_ERRNO;
+  }
+
+
+  if ((err==ZIP_OK) && (zi->ci.zip64))
+  {
+      // write the Zip64 extended info
+      short HeaderID = 1;
+      short DataSize = 16;
+      ZPOS64_T CompressedSize = 0;
+      ZPOS64_T UncompressedSize = 0;
+
+      // Remember position of Zip64 extended info for the local file header. (needed when we update size after done with file)
+      zi->ci.pos_zip64extrainfo = ZTELL64(zi->z_filefunc,zi->filestream);
+
+      err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)HeaderID,2);
+      err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)DataSize,2);
+
+      err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)UncompressedSize,8);
+      err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)CompressedSize,8);
+  }
+
+  return err;
+}
+
+/*
+ NOTE.
+ When writing RAW the ZIP64 extended information in extrafield_local and extrafield_global needs to be stripped
+ before calling this function it can be done with zipRemoveExtraInfoBlock
+
+ It is not done here because then we need to realloc a new buffer since parameters are 'const' and I want to minimize
+ unnecessary allocations.
+ */
+extern int ZEXPORT zipOpenNewFileInZip4_64 (zipFile file, const char* filename, const zip_fileinfo* zipfi,
+                                         const void* extrafield_local, uInt size_extrafield_local,
+                                         const void* extrafield_global, uInt size_extrafield_global,
+                                         const char* comment, int method, int level, int raw,
+                                         int windowBits,int memLevel, int strategy,
+                                         const char* password, uLong crcForCrypting,
+                                         uLong versionMadeBy, uLong flagBase, int zip64)
+{
+    zip64_internal* zi;
+    uInt size_filename;
+    uInt size_comment;
+    uInt i;
+    int err = ZIP_OK;
+
+#    ifdef NOCRYPT
+    (crcForCrypting);
+    if (password != NULL)
+        return ZIP_PARAMERROR;
+#    endif
+
+    if (file == NULL)
+        return ZIP_PARAMERROR;
+
+#ifdef HAVE_BZIP2
+    if ((method!=0) && (method!=Z_DEFLATED) && (method!=Z_BZIP2ED))
+      return ZIP_PARAMERROR;
+#else
+    if ((method!=0) && (method!=Z_DEFLATED))
+      return ZIP_PARAMERROR;
+#endif
+
+    zi = (zip64_internal*)file;
+
+    if (zi->in_opened_file_inzip == 1)
+    {
+        err = zipCloseFileInZip (file);
+        if (err != ZIP_OK)
+            return err;
+    }
+
+    if (filename==NULL)
+        filename="-";
+
+    if (comment==NULL)
+        size_comment = 0;
+    else
+        size_comment = (uInt)strlen(comment);
+
+    size_filename = (uInt)strlen(filename);
+
+    if (zipfi == NULL)
+        zi->ci.dosDate = 0;
+    else
+    {
+        if (zipfi->dosDate != 0)
+            zi->ci.dosDate = zipfi->dosDate;
+        else
+          zi->ci.dosDate = zip64local_TmzDateToDosDate(&zipfi->tmz_date);
+    }
+
+    zi->ci.flag = flagBase;
+    if ((level==8) || (level==9))
+      zi->ci.flag |= 2;
+    if (level==2)
+      zi->ci.flag |= 4;
+    if (level==1)
+      zi->ci.flag |= 6;
+    if (password != NULL)
+      zi->ci.flag |= 1;
+
+    zi->ci.crc32 = 0;
+    zi->ci.method = method;
+    zi->ci.encrypt = 0;
+    zi->ci.stream_initialised = 0;
+    zi->ci.pos_in_buffered_data = 0;
+    zi->ci.raw = raw;
+    zi->ci.pos_local_header = ZTELL64(zi->z_filefunc,zi->filestream);
+
+    zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename + size_extrafield_global + size_comment;
+    zi->ci.size_centralExtraFree = 32; // Extra space we have reserved in case we need to add ZIP64 extra info data
+
+    zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader + zi->ci.size_centralExtraFree);
+
+    zi->ci.size_centralExtra = size_extrafield_global;
+    zip64local_putValue_inmemory(zi->ci.central_header,(uLong)CENTRALHEADERMAGIC,4);
+    /* version info */
+    zip64local_putValue_inmemory(zi->ci.central_header+4,(uLong)versionMadeBy,2);
+    zip64local_putValue_inmemory(zi->ci.central_header+6,(uLong)20,2);
+    zip64local_putValue_inmemory(zi->ci.central_header+8,(uLong)zi->ci.flag,2);
+    zip64local_putValue_inmemory(zi->ci.central_header+10,(uLong)zi->ci.method,2);
+    zip64local_putValue_inmemory(zi->ci.central_header+12,(uLong)zi->ci.dosDate,4);
+    zip64local_putValue_inmemory(zi->ci.central_header+16,(uLong)0,4); /*crc*/
+    zip64local_putValue_inmemory(zi->ci.central_header+20,(uLong)0,4); /*compr size*/
+    zip64local_putValue_inmemory(zi->ci.central_header+24,(uLong)0,4); /*uncompr size*/
+    zip64local_putValue_inmemory(zi->ci.central_header+28,(uLong)size_filename,2);
+    zip64local_putValue_inmemory(zi->ci.central_header+30,(uLong)size_extrafield_global,2);
+    zip64local_putValue_inmemory(zi->ci.central_header+32,(uLong)size_comment,2);
+    zip64local_putValue_inmemory(zi->ci.central_header+34,(uLong)0,2); /*disk nm start*/
+
+    if (zipfi==NULL)
+        zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)0,2);
+    else
+        zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)zipfi->internal_fa,2);
+
+    if (zipfi==NULL)
+        zip64local_putValue_inmemory(zi->ci.central_header+38,(uLong)0,4);
+    else
+        zip64local_putValue_inmemory(zi->ci.central_header+38,(uLong)zipfi->external_fa,4);
+
+    if(zi->ci.pos_local_header >= 0xffffffff)
+      zip64local_putValue_inmemory(zi->ci.central_header+42,(uLong)0xffffffff,4);
+    else
+      zip64local_putValue_inmemory(zi->ci.central_header+42,(uLong)zi->ci.pos_local_header - zi->add_position_when_writing_offset,4);
+
+    for (i=0;i<size_filename;i++)
+        *(zi->ci.central_header+SIZECENTRALHEADER+i) = *(filename+i);
+
+    for (i=0;i<size_extrafield_global;i++)
+        *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+i) =
+              *(((const char*)extrafield_global)+i);
+
+    for (i=0;i<size_comment;i++)
+        *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+
+              size_extrafield_global+i) = *(comment+i);
+    if (zi->ci.central_header == NULL)
+        return ZIP_INTERNALERROR;
+
+    zi->ci.zip64 = zip64;
+    zi->ci.totalCompressedData = 0;
+    zi->ci.totalUncompressedData = 0;
+    zi->ci.pos_zip64extrainfo = 0;
+
+    err = Write_LocalFileHeader(zi, filename, size_extrafield_local, extrafield_local);
+
+#ifdef HAVE_BZIP2
+    zi->ci.bstream.avail_in = (uInt)0;
+    zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE;
+    zi->ci.bstream.next_out = (char*)zi->ci.buffered_data;
+    zi->ci.bstream.total_in_hi32 = 0;
+    zi->ci.bstream.total_in_lo32 = 0;
+    zi->ci.bstream.total_out_hi32 = 0;
+    zi->ci.bstream.total_out_lo32 = 0;
+#endif
+
+    zi->ci.stream.avail_in = (uInt)0;
+    zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
+    zi->ci.stream.next_out = zi->ci.buffered_data;
+    zi->ci.stream.total_in = 0;
+    zi->ci.stream.total_out = 0;
+    zi->ci.stream.data_type = Z_BINARY;
+
+#ifdef HAVE_BZIP2
+    if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED || zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw))
+#else
+    if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
+#endif
+    {
+        if(zi->ci.method == Z_DEFLATED)
+        {
+          zi->ci.stream.zalloc = (alloc_func)0;
+          zi->ci.stream.zfree = (free_func)0;
+          zi->ci.stream.opaque = (voidpf)0;
+
+          if (windowBits>0)
+              windowBits = -windowBits;
+
+          err = deflateInit2(&zi->ci.stream, level, Z_DEFLATED, windowBits, memLevel, strategy);
+
+          if (err==Z_OK)
+              zi->ci.stream_initialised = Z_DEFLATED;
+        }
+        else if(zi->ci.method == Z_BZIP2ED)
+        {
+#ifdef HAVE_BZIP2
+            // Init BZip stuff here
+          zi->ci.bstream.bzalloc = 0;
+          zi->ci.bstream.bzfree = 0;
+          zi->ci.bstream.opaque = (voidpf)0;
+
+          err = BZ2_bzCompressInit(&zi->ci.bstream, level, 0,35);
+          if(err == BZ_OK)
+            zi->ci.stream_initialised = Z_BZIP2ED;
+#endif
+        }
+
+    }
+
+#    ifndef NOCRYPT
+    zi->ci.crypt_header_size = 0;
+    if ((err==Z_OK) && (password != NULL))
+    {
+        unsigned char bufHead[RAND_HEAD_LEN];
+        unsigned int sizeHead;
+        zi->ci.encrypt = 1;
+        zi->ci.pcrc_32_tab = get_crc_table();
+        /*init_keys(password,zi->ci.keys,zi->ci.pcrc_32_tab);*/
+
+        sizeHead=crypthead(password,bufHead,RAND_HEAD_LEN,zi->ci.keys,zi->ci.pcrc_32_tab,crcForCrypting);
+        zi->ci.crypt_header_size = sizeHead;
+
+        if (ZWRITE64(zi->z_filefunc,zi->filestream,bufHead,sizeHead) != sizeHead)
+                err = ZIP_ERRNO;
+    }
+#    endif
+
+    if (err==Z_OK)
+        zi->in_opened_file_inzip = 1;
+    return err;
+}
+
+extern int ZEXPORT zipOpenNewFileInZip4 (zipFile file, const char* filename, const zip_fileinfo* zipfi,
+                                         const void* extrafield_local, uInt size_extrafield_local,
+                                         const void* extrafield_global, uInt size_extrafield_global,
+                                         const char* comment, int method, int level, int raw,
+                                         int windowBits,int memLevel, int strategy,
+                                         const char* password, uLong crcForCrypting,
+                                         uLong versionMadeBy, uLong flagBase)
+{
+    return zipOpenNewFileInZip4_64 (file, filename, zipfi,
+                                 extrafield_local, size_extrafield_local,
+                                 extrafield_global, size_extrafield_global,
+                                 comment, method, level, raw,
+                                 windowBits, memLevel, strategy,
+                                 password, crcForCrypting, versionMadeBy, flagBase, 0);
+}
+
+extern int ZEXPORT zipOpenNewFileInZip3 (zipFile file, const char* filename, const zip_fileinfo* zipfi,
+                                         const void* extrafield_local, uInt size_extrafield_local,
+                                         const void* extrafield_global, uInt size_extrafield_global,
+                                         const char* comment, int method, int level, int raw,
+                                         int windowBits,int memLevel, int strategy,
+                                         const char* password, uLong crcForCrypting)
+{
+    return zipOpenNewFileInZip4_64 (file, filename, zipfi,
+                                 extrafield_local, size_extrafield_local,
+                                 extrafield_global, size_extrafield_global,
+                                 comment, method, level, raw,
+                                 windowBits, memLevel, strategy,
+                                 password, crcForCrypting, VERSIONMADEBY, 0, 0);
+}
+
+extern int ZEXPORT zipOpenNewFileInZip3_64(zipFile file, const char* filename, const zip_fileinfo* zipfi,
+                                         const void* extrafield_local, uInt size_extrafield_local,
+                                         const void* extrafield_global, uInt size_extrafield_global,
+                                         const char* comment, int method, int level, int raw,
+                                         int windowBits,int memLevel, int strategy,
+                                         const char* password, uLong crcForCrypting, int zip64)
+{
+    return zipOpenNewFileInZip4_64 (file, filename, zipfi,
+                                 extrafield_local, size_extrafield_local,
+                                 extrafield_global, size_extrafield_global,
+                                 comment, method, level, raw,
+                                 windowBits, memLevel, strategy,
+                                 password, crcForCrypting, VERSIONMADEBY, 0, zip64);
+}
+
+extern int ZEXPORT zipOpenNewFileInZip2(zipFile file, const char* filename, const zip_fileinfo* zipfi,
+                                        const void* extrafield_local, uInt size_extrafield_local,
+                                        const void* extrafield_global, uInt size_extrafield_global,
+                                        const char* comment, int method, int level, int raw)
+{
+    return zipOpenNewFileInZip4_64 (file, filename, zipfi,
+                                 extrafield_local, size_extrafield_local,
+                                 extrafield_global, size_extrafield_global,
+                                 comment, method, level, raw,
+                                 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
+                                 NULL, 0, VERSIONMADEBY, 0, 0);
+}
+
+extern int ZEXPORT zipOpenNewFileInZip2_64(zipFile file, const char* filename, const zip_fileinfo* zipfi,
+                                        const void* extrafield_local, uInt size_extrafield_local,
+                                        const void* extrafield_global, uInt size_extrafield_global,
+                                        const char* comment, int method, int level, int raw, int zip64)
+{
+    return zipOpenNewFileInZip4_64 (file, filename, zipfi,
+                                 extrafield_local, size_extrafield_local,
+                                 extrafield_global, size_extrafield_global,
+                                 comment, method, level, raw,
+                                 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
+                                 NULL, 0, VERSIONMADEBY, 0, zip64);
+}
+
+extern int ZEXPORT zipOpenNewFileInZip64 (zipFile file, const char* filename, const zip_fileinfo* zipfi,
+                                        const void* extrafield_local, uInt size_extrafield_local,
+                                        const void*extrafield_global, uInt size_extrafield_global,
+                                        const char* comment, int method, int level, int zip64)
+{
+    return zipOpenNewFileInZip4_64 (file, filename, zipfi,
+                                 extrafield_local, size_extrafield_local,
+                                 extrafield_global, size_extrafield_global,
+                                 comment, method, level, 0,
+                                 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
+                                 NULL, 0, VERSIONMADEBY, 0, zip64);
+}
+
+extern int ZEXPORT zipOpenNewFileInZip (zipFile file, const char* filename, const zip_fileinfo* zipfi,
+                                        const void* extrafield_local, uInt size_extrafield_local,
+                                        const void*extrafield_global, uInt size_extrafield_global,
+                                        const char* comment, int method, int level)
+{
+    return zipOpenNewFileInZip4_64 (file, filename, zipfi,
+                                 extrafield_local, size_extrafield_local,
+                                 extrafield_global, size_extrafield_global,
+                                 comment, method, level, 0,
+                                 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
+                                 NULL, 0, VERSIONMADEBY, 0, 0);
+}
+
+local int zip64FlushWriteBuffer(zip64_internal* zi)
+{
+    int err=ZIP_OK;
+
+    if (zi->ci.encrypt != 0)
+    {
+#ifndef NOCRYPT
+        uInt i;
+        int t;
+        for (i=0;i<zi->ci.pos_in_buffered_data;i++)
+            zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab, zi->ci.buffered_data[i],t);
+#endif
+    }
+
+    if (ZWRITE64(zi->z_filefunc,zi->filestream,zi->ci.buffered_data,zi->ci.pos_in_buffered_data) != zi->ci.pos_in_buffered_data)
+      err = ZIP_ERRNO;
+
+    zi->ci.totalCompressedData += zi->ci.pos_in_buffered_data;
+
+#ifdef HAVE_BZIP2
+    if(zi->ci.method == Z_BZIP2ED)
+    {
+      zi->ci.totalUncompressedData += zi->ci.bstream.total_in_lo32;
+      zi->ci.bstream.total_in_lo32 = 0;
+      zi->ci.bstream.total_in_hi32 = 0;
+    }
+    else
+#endif
+    {
+      zi->ci.totalUncompressedData += zi->ci.stream.total_in;
+      zi->ci.stream.total_in = 0;
+    }
+
+
+    zi->ci.pos_in_buffered_data = 0;
+
+    return err;
+}
+
+extern int ZEXPORT zipWriteInFileInZip (zipFile file,const void* buf,unsigned int len)
+{
+    zip64_internal* zi;
+    int err=ZIP_OK;
+
+    if (file == NULL)
+        return ZIP_PARAMERROR;
+    zi = (zip64_internal*)file;
+
+    if (zi->in_opened_file_inzip == 0)
+        return ZIP_PARAMERROR;
+
+    zi->ci.crc32 = crc32(zi->ci.crc32,buf,(uInt)len);
+
+#ifdef HAVE_BZIP2
+    if(zi->ci.method == Z_BZIP2ED && (!zi->ci.raw))
+    {
+      zi->ci.bstream.next_in = (void*)buf;
+      zi->ci.bstream.avail_in = len;
+      err = BZ_RUN_OK;
+
+      while ((err==BZ_RUN_OK) && (zi->ci.bstream.avail_in>0))
+      {
+        if (zi->ci.bstream.avail_out == 0)
+        {
+          if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)
+            err = ZIP_ERRNO;
+          zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE;
+          zi->ci.bstream.next_out = (char*)zi->ci.buffered_data;
+        }
+
+
+        if(err != BZ_RUN_OK)
+          break;
+
+        if ((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw))
+        {
+          uLong uTotalOutBefore_lo = zi->ci.bstream.total_out_lo32;
+//          uLong uTotalOutBefore_hi = zi->ci.bstream.total_out_hi32;
+          err=BZ2_bzCompress(&zi->ci.bstream,  BZ_RUN);
+
+          zi->ci.pos_in_buffered_data += (uInt)(zi->ci.bstream.total_out_lo32 - uTotalOutBefore_lo) ;
+        }
+      }
+
+      if(err == BZ_RUN_OK)
+        err = ZIP_OK;
+    }
+    else
+#endif
+    {
+      zi->ci.stream.next_in = (Bytef*)buf;
+      zi->ci.stream.avail_in = len;
+
+      while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0))
+      {
+          if (zi->ci.stream.avail_out == 0)
+          {
+              if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)
+                  err = ZIP_ERRNO;
+              zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
+              zi->ci.stream.next_out = zi->ci.buffered_data;
+          }
+
+
+          if(err != ZIP_OK)
+              break;
+
+          if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
+          {
+              uLong uTotalOutBefore = zi->ci.stream.total_out;
+              err=deflate(&zi->ci.stream,  Z_NO_FLUSH);
+              if(uTotalOutBefore > zi->ci.stream.total_out)
+              {
+                int bBreak = 0;
+                bBreak++;
+              }
+
+              zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
+          }
+          else
+          {
+              uInt copy_this,i;
+              if (zi->ci.stream.avail_in < zi->ci.stream.avail_out)
+                  copy_this = zi->ci.stream.avail_in;
+              else
+                  copy_this = zi->ci.stream.avail_out;
+
+              for (i = 0; i < copy_this; i++)
+                  *(((char*)zi->ci.stream.next_out)+i) =
+                      *(((const char*)zi->ci.stream.next_in)+i);
+              {
+                  zi->ci.stream.avail_in -= copy_this;
+                  zi->ci.stream.avail_out-= copy_this;
+                  zi->ci.stream.next_in+= copy_this;
+                  zi->ci.stream.next_out+= copy_this;
+                  zi->ci.stream.total_in+= copy_this;
+                  zi->ci.stream.total_out+= copy_this;
+                  zi->ci.pos_in_buffered_data += copy_this;
+              }
+          }
+      }// while(...)
+    }
+
+    return err;
+}
+
+extern int ZEXPORT zipCloseFileInZipRaw (zipFile file, uLong uncompressed_size, uLong crc32)
+{
+    return zipCloseFileInZipRaw64 (file, uncompressed_size, crc32);
+}
+
+extern int ZEXPORT zipCloseFileInZipRaw64 (zipFile file, ZPOS64_T uncompressed_size, uLong crc32)
+{
+    zip64_internal* zi;
+    ZPOS64_T compressed_size;
+    uLong invalidValue = 0xffffffff;
+    short datasize = 0;
+    int err=ZIP_OK;
+
+    if (file == NULL)
+        return ZIP_PARAMERROR;
+    zi = (zip64_internal*)file;
+
+    if (zi->in_opened_file_inzip == 0)
+        return ZIP_PARAMERROR;
+    zi->ci.stream.avail_in = 0;
+
+    if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
+                {
+                        while (err==ZIP_OK)
+                        {
+                                uLong uTotalOutBefore;
+                                if (zi->ci.stream.avail_out == 0)
+                                {
+                                        if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)
+                                                err = ZIP_ERRNO;
+                                        zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
+                                        zi->ci.stream.next_out = zi->ci.buffered_data;
+                                }
+                                uTotalOutBefore = zi->ci.stream.total_out;
+                                err=deflate(&zi->ci.stream,  Z_FINISH);
+                                zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
+                        }
+                }
+    else if ((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw))
+    {
+#ifdef HAVE_BZIP2
+      err = BZ_FINISH_OK;
+      while (err==BZ_FINISH_OK)
+      {
+        uLong uTotalOutBefore;
+        if (zi->ci.bstream.avail_out == 0)
+        {
+          if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)
+            err = ZIP_ERRNO;
+          zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE;
+          zi->ci.bstream.next_out = (char*)zi->ci.buffered_data;
+        }
+        uTotalOutBefore = zi->ci.bstream.total_out_lo32;
+        err=BZ2_bzCompress(&zi->ci.bstream,  BZ_FINISH);
+        if(err == BZ_STREAM_END)
+          err = Z_STREAM_END;
+
+        zi->ci.pos_in_buffered_data += (uInt)(zi->ci.bstream.total_out_lo32 - uTotalOutBefore);
+      }
+
+      if(err == BZ_FINISH_OK)
+        err = ZIP_OK;
+#endif
+    }
+
+    if (err==Z_STREAM_END)
+        err=ZIP_OK; /* this is normal */
+
+    if ((zi->ci.pos_in_buffered_data>0) && (err==ZIP_OK))
+                {
+        if (zip64FlushWriteBuffer(zi)==ZIP_ERRNO)
+            err = ZIP_ERRNO;
+                }
+
+    if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
+    {
+        int tmp_err = deflateEnd(&zi->ci.stream);
+        if (err == ZIP_OK)
+            err = tmp_err;
+        zi->ci.stream_initialised = 0;
+    }
+#ifdef HAVE_BZIP2
+    else if((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw))
+    {
+      int tmperr = BZ2_bzCompressEnd(&zi->ci.bstream);
+                        if (err==ZIP_OK)
+                                err = tmperr;
+                        zi->ci.stream_initialised = 0;
+    }
+#endif
+
+    if (!zi->ci.raw)
+    {
+        crc32 = (uLong)zi->ci.crc32;
+        uncompressed_size = zi->ci.totalUncompressedData;
+    }
+    compressed_size = zi->ci.totalCompressedData;
+
+#    ifndef NOCRYPT
+    compressed_size += zi->ci.crypt_header_size;
+#    endif
+
+    // update Current Item crc and sizes,
+    if(compressed_size >= 0xffffffff || uncompressed_size >= 0xffffffff || zi->ci.pos_local_header >= 0xffffffff)
+    {
+      /*version Made by*/
+      zip64local_putValue_inmemory(zi->ci.central_header+4,(uLong)45,2);
+      /*version needed*/
+      zip64local_putValue_inmemory(zi->ci.central_header+6,(uLong)45,2);
+
+    }
+
+    zip64local_putValue_inmemory(zi->ci.central_header+16,crc32,4); /*crc*/
+
+
+    if(compressed_size >= 0xffffffff)
+      zip64local_putValue_inmemory(zi->ci.central_header+20, invalidValue,4); /*compr size*/
+    else
+      zip64local_putValue_inmemory(zi->ci.central_header+20, compressed_size,4); /*compr size*/
+
+    /// set internal file attributes field
+    if (zi->ci.stream.data_type == Z_ASCII)
+        zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)Z_ASCII,2);
+
+    if(uncompressed_size >= 0xffffffff)
+      zip64local_putValue_inmemory(zi->ci.central_header+24, invalidValue,4); /*uncompr size*/
+    else
+      zip64local_putValue_inmemory(zi->ci.central_header+24, uncompressed_size,4); /*uncompr size*/
+
+    // Add ZIP64 extra info field for uncompressed size
+    if(uncompressed_size >= 0xffffffff)
+      datasize += 8;
+
+    // Add ZIP64 extra info field for compressed size
+    if(compressed_size >= 0xffffffff)
+      datasize += 8;
+
+    // Add ZIP64 extra info field for relative offset to local file header of current file
+    if(zi->ci.pos_local_header >= 0xffffffff)
+      datasize += 8;
+
+    if(datasize > 0)
+    {
+      char* p = NULL;
+
+      if((uLong)(datasize + 4) > zi->ci.size_centralExtraFree)
+      {
+        // we can not write more data to the buffer that we have room for.
+        return ZIP_BADZIPFILE;
+      }
+
+      p = zi->ci.central_header + zi->ci.size_centralheader;
+
+      // Add Extra Information Header for 'ZIP64 information'
+      zip64local_putValue_inmemory(p, 0x0001, 2); // HeaderID
+      p += 2;
+      zip64local_putValue_inmemory(p, datasize, 2); // DataSize
+      p += 2;
+
+      if(uncompressed_size >= 0xffffffff)
+      {
+        zip64local_putValue_inmemory(p, uncompressed_size, 8);
+        p += 8;
+      }
+
+      if(compressed_size >= 0xffffffff)
+      {
+        zip64local_putValue_inmemory(p, compressed_size, 8);
+        p += 8;
+      }
+
+      if(zi->ci.pos_local_header >= 0xffffffff)
+      {
+        zip64local_putValue_inmemory(p, zi->ci.pos_local_header, 8);
+        p += 8;
+      }
+
+      // Update how much extra free space we got in the memory buffer
+      // and increase the centralheader size so the new ZIP64 fields are included
+      // ( 4 below is the size of HeaderID and DataSize field )
+      zi->ci.size_centralExtraFree -= datasize + 4;
+      zi->ci.size_centralheader += datasize + 4;
+
+      // Update the extra info size field
+      zi->ci.size_centralExtra += datasize + 4;
+      zip64local_putValue_inmemory(zi->ci.central_header+30,(uLong)zi->ci.size_centralExtra,2);
+    }
+
+    if (err==ZIP_OK)
+        err = add_data_in_datablock(&zi->central_dir, zi->ci.central_header, (uLong)zi->ci.size_centralheader);
+
+    free(zi->ci.central_header);
+
+    if (err==ZIP_OK)
+    {
+        // Update the LocalFileHeader with the new values.
+
+        ZPOS64_T cur_pos_inzip = ZTELL64(zi->z_filefunc,zi->filestream);
+
+        if (ZSEEK64(zi->z_filefunc,zi->filestream, zi->ci.pos_local_header + 14,ZLIB_FILEFUNC_SEEK_SET)!=0)
+            err = ZIP_ERRNO;
+
+        if (err==ZIP_OK)
+            err = zip64local_putValue(&zi->z_filefunc,zi->filestream,crc32,4); /* crc 32, unknown */
+
+        if(uncompressed_size >= 0xffffffff || compressed_size >= 0xffffffff )
+        {
+          if(zi->ci.pos_zip64extrainfo > 0)
+          {
+            // Update the size in the ZIP64 extended field.
+            if (ZSEEK64(zi->z_filefunc,zi->filestream, zi->ci.pos_zip64extrainfo + 4,ZLIB_FILEFUNC_SEEK_SET)!=0)
+              err = ZIP_ERRNO;
+
+            if (err==ZIP_OK) /* compressed size, unknown */
+              err = zip64local_putValue(&zi->z_filefunc, zi->filestream, uncompressed_size, 8);
+
+            if (err==ZIP_OK) /* uncompressed size, unknown */
+              err = zip64local_putValue(&zi->z_filefunc, zi->filestream, compressed_size, 8);
+          }
+          else
+              err = ZIP_BADZIPFILE; // Caller passed zip64 = 0, so no room for zip64 info -> fatal
+        }
+        else
+        {
+          if (err==ZIP_OK) /* compressed size, unknown */
+              err = zip64local_putValue(&zi->z_filefunc,zi->filestream,compressed_size,4);
+
+          if (err==ZIP_OK) /* uncompressed size, unknown */
+              err = zip64local_putValue(&zi->z_filefunc,zi->filestream,uncompressed_size,4);
+        }
+
+        if (ZSEEK64(zi->z_filefunc,zi->filestream, cur_pos_inzip,ZLIB_FILEFUNC_SEEK_SET)!=0)
+            err = ZIP_ERRNO;
+    }
+
+    zi->number_entry ++;
+    zi->in_opened_file_inzip = 0;
+
+    return err;
+}
+
+extern int ZEXPORT zipCloseFileInZip (zipFile file)
+{
+    return zipCloseFileInZipRaw (file,0,0);
+}
+
+int Write_Zip64EndOfCentralDirectoryLocator(zip64_internal* zi, ZPOS64_T zip64eocd_pos_inzip)
+{
+  int err = ZIP_OK;
+  ZPOS64_T pos = zip64eocd_pos_inzip - zi->add_position_when_writing_offset;
+
+  err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ZIP64ENDLOCHEADERMAGIC,4);
+
+  /*num disks*/
+    if (err==ZIP_OK) /* number of the disk with the start of the central directory */
+      err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4);
+
+  /*relative offset*/
+    if (err==ZIP_OK) /* Relative offset to the Zip64EndOfCentralDirectory */
+      err = zip64local_putValue(&zi->z_filefunc,zi->filestream, pos,8);
+
+  /*total disks*/ /* Do not support spawning of disk so always say 1 here*/
+    if (err==ZIP_OK) /* number of the disk with the start of the central directory */
+      err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)1,4);
+
+    return err;
+}
+
+int Write_Zip64EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centraldir, ZPOS64_T centraldir_pos_inzip)
+{
+  int err = ZIP_OK;
+
+  uLong Zip64DataSize = 44;
+
+  err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ZIP64ENDHEADERMAGIC,4);
+
+  if (err==ZIP_OK) /* size of this 'zip64 end of central directory' */
+    err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(ZPOS64_T)Zip64DataSize,8); // why ZPOS64_T of this ?
+
+  if (err==ZIP_OK) /* version made by */
+    err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2);
+
+  if (err==ZIP_OK) /* version needed */
+    err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2);
+
+  if (err==ZIP_OK) /* number of this disk */
+    err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4);
+
+  if (err==ZIP_OK) /* number of the disk with the start of the central directory */
+    err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4);
+
+  if (err==ZIP_OK) /* total number of entries in the central dir on this disk */
+    err = zip64local_putValue(&zi->z_filefunc, zi->filestream, zi->number_entry, 8);
+
+  if (err==ZIP_OK) /* total number of entries in the central dir */
+    err = zip64local_putValue(&zi->z_filefunc, zi->filestream, zi->number_entry, 8);
+
+  if (err==ZIP_OK) /* size of the central directory */
+    err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(ZPOS64_T)size_centraldir,8);
+
+  if (err==ZIP_OK) /* offset of start of central directory with respect to the starting disk number */
+  {
+    ZPOS64_T pos = centraldir_pos_inzip - zi->add_position_when_writing_offset;
+    err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (ZPOS64_T)pos,8);
+  }
+  return err;
+}
+int Write_EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centraldir, ZPOS64_T centraldir_pos_inzip)
+{
+  int err = ZIP_OK;
+
+  /*signature*/
+  err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ENDHEADERMAGIC,4);
+
+  if (err==ZIP_OK) /* number of this disk */
+    err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
+
+  if (err==ZIP_OK) /* number of the disk with the start of the central directory */
+    err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
+
+  if (err==ZIP_OK) /* total number of entries in the central dir on this disk */
+  {
+    {
+      if(zi->number_entry >= 0xFFFF)
+        err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xffff,2); // use value in ZIP64 record
+      else
+        err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
+    }
+  }
+
+  if (err==ZIP_OK) /* total number of entries in the central dir */
+  {
+    if(zi->number_entry >= 0xFFFF)
+      err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xffff,2); // use value in ZIP64 record
+    else
+      err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
+  }
+
+  if (err==ZIP_OK) /* size of the central directory */
+    err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_centraldir,4);
+
+  if (err==ZIP_OK) /* offset of start of central directory with respect to the starting disk number */
+  {
+    ZPOS64_T pos = centraldir_pos_inzip - zi->add_position_when_writing_offset;
+    if(pos >= 0xffffffff)
+    {
+      err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (uLong)0xffffffff,4);
+    }
+    else
+      err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (uLong)(centraldir_pos_inzip - zi->add_position_when_writing_offset),4);
+  }
+
+   return err;
+}
+
+int Write_GlobalComment(zip64_internal* zi, const char* global_comment)
+{
+  int err = ZIP_OK;
+  uInt size_global_comment = 0;
+
+  if(global_comment != NULL)
+    size_global_comment = (uInt)strlen(global_comment);
+
+  err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_global_comment,2);
+
+  if (err == ZIP_OK && size_global_comment > 0)
+  {
+    if (ZWRITE64(zi->z_filefunc,zi->filestream, global_comment, size_global_comment) != size_global_comment)
+      err = ZIP_ERRNO;
+  }
+  return err;
+}
+
+extern int ZEXPORT zipClose (zipFile file, const char* global_comment)
+{
+    zip64_internal* zi;
+    int err = 0;
+    uLong size_centraldir = 0;
+    ZPOS64_T centraldir_pos_inzip;
+    ZPOS64_T pos;
+
+    if (file == NULL)
+        return ZIP_PARAMERROR;
+
+    zi = (zip64_internal*)file;
+
+    if (zi->in_opened_file_inzip == 1)
+    {
+        err = zipCloseFileInZip (file);
+    }
+
+#ifndef NO_ADDFILEINEXISTINGZIP
+    if (global_comment==NULL)
+        global_comment = zi->globalcomment;
+#endif
+
+    centraldir_pos_inzip = ZTELL64(zi->z_filefunc,zi->filestream);
+
+    if (err==ZIP_OK)
+    {
+        linkedlist_datablock_internal* ldi = zi->central_dir.first_block;
+        while (ldi!=NULL)
+        {
+            if ((err==ZIP_OK) && (ldi->filled_in_this_block>0))
+            {
+                if (ZWRITE64(zi->z_filefunc,zi->filestream, ldi->data, ldi->filled_in_this_block) != ldi->filled_in_this_block)
+                    err = ZIP_ERRNO;
+            }
+
+            size_centraldir += ldi->filled_in_this_block;
+            ldi = ldi->next_datablock;
+        }
+    }
+    free_linkedlist(&(zi->central_dir));
+
+    pos = centraldir_pos_inzip - zi->add_position_when_writing_offset;
+    if(pos >= 0xffffffff || zi->number_entry > 0xFFFF)
+    {
+      ZPOS64_T Zip64EOCDpos = ZTELL64(zi->z_filefunc,zi->filestream);
+      Write_Zip64EndOfCentralDirectoryRecord(zi, size_centraldir, centraldir_pos_inzip);
+
+      Write_Zip64EndOfCentralDirectoryLocator(zi, Zip64EOCDpos);
+    }
+
+    if (err==ZIP_OK)
+      err = Write_EndOfCentralDirectoryRecord(zi, size_centraldir, centraldir_pos_inzip);
+
+    if(err == ZIP_OK)
+      err = Write_GlobalComment(zi, global_comment);
+
+    if (ZCLOSE64(zi->z_filefunc,zi->filestream) != 0)
+        if (err == ZIP_OK)
+            err = ZIP_ERRNO;
+
+#ifndef NO_ADDFILEINEXISTINGZIP
+    TRYFREE(zi->globalcomment);
+#endif
+    TRYFREE(zi);
+
+    return err;
+}
+
+extern int ZEXPORT zipRemoveExtraInfoBlock (char* pData, int* dataLen, short sHeader)
+{
+  char* p = pData;
+  int size = 0;
+  char* pNewHeader;
+  char* pTmp;
+  short header;
+  short dataSize;
+
+  int retVal = ZIP_OK;
+
+  if(pData == NULL || *dataLen < 4)
+    return ZIP_PARAMERROR;
+
+  pNewHeader = (char*)ALLOC(*dataLen);
+  pTmp = pNewHeader;
+
+  while(p < (pData + *dataLen))
+  {
+    header = *(short*)p;
+    dataSize = *(((short*)p)+1);
+
+    if( header == sHeader ) // Header found.
+    {
+      p += dataSize + 4; // skip it. do not copy to temp buffer
+    }
+    else
+    {
+      // Extra Info block should not be removed, So copy it to the temp buffer.
+      memcpy(pTmp, p, dataSize + 4);
+      p += dataSize + 4;
+      size += dataSize + 4;
+    }
+
+  }
+
+  if(size < *dataLen)
+  {
+    // clean old extra info block.
+    memset(pData,0, *dataLen);
+
+    // copy the new extra info block over the old
+    if(size > 0)
+      memcpy(pData, pNewHeader, size);
+
+    // set the new extra info size
+    *dataLen = size;
+
+    retVal = ZIP_OK;
+  }
+  else
+    retVal = ZIP_ERRNO;
+
+  TRYFREE(pNewHeader);
+
+  return retVal;
+}
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/minizip/zip.h b/Engine/lib/assimp/contrib/zlib/contrib/minizip/zip.h
new file mode 100644
index 000000000..8aaebb623
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/minizip/zip.h
@@ -0,0 +1,362 @@
+/* zip.h -- IO on .zip files using zlib
+   Version 1.1, February 14h, 2010
+   part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Modifications for Zip64 support
+         Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+
+         For more info read MiniZip_info.txt
+
+         ---------------------------------------------------------------------------
+
+   Condition of use and distribution are the same than zlib :
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+        ---------------------------------------------------------------------------
+
+        Changes
+
+        See header of zip.h
+
+*/
+
+#ifndef _zip12_H
+#define _zip12_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//#define HAVE_BZIP2
+
+#ifndef _ZLIB_H
+#include "zlib.h"
+#endif
+
+#ifndef _ZLIBIOAPI_H
+#include "ioapi.h"
+#endif
+
+#ifdef HAVE_BZIP2
+#include "bzlib.h"
+#endif
+
+#define Z_BZIP2ED 12
+
+#if defined(STRICTZIP) || defined(STRICTZIPUNZIP)
+/* like the STRICT of WIN32, we define a pointer that cannot be converted
+    from (void*) without cast */
+typedef struct TagzipFile__ { int unused; } zipFile__;
+typedef zipFile__ *zipFile;
+#else
+typedef voidp zipFile;
+#endif
+
+#define ZIP_OK                          (0)
+#define ZIP_EOF                         (0)
+#define ZIP_ERRNO                       (Z_ERRNO)
+#define ZIP_PARAMERROR                  (-102)
+#define ZIP_BADZIPFILE                  (-103)
+#define ZIP_INTERNALERROR               (-104)
+
+#ifndef DEF_MEM_LEVEL
+#  if MAX_MEM_LEVEL >= 8
+#    define DEF_MEM_LEVEL 8
+#  else
+#    define DEF_MEM_LEVEL  MAX_MEM_LEVEL
+#  endif
+#endif
+/* default memLevel */
+
+/* tm_zip contain date/time info */
+typedef struct tm_zip_s
+{
+    uInt tm_sec;            /* seconds after the minute - [0,59] */
+    uInt tm_min;            /* minutes after the hour - [0,59] */
+    uInt tm_hour;           /* hours since midnight - [0,23] */
+    uInt tm_mday;           /* day of the month - [1,31] */
+    uInt tm_mon;            /* months since January - [0,11] */
+    uInt tm_year;           /* years - [1980..2044] */
+} tm_zip;
+
+typedef struct
+{
+    tm_zip      tmz_date;       /* date in understandable format           */
+    uLong       dosDate;       /* if dos_date == 0, tmu_date is used      */
+/*    uLong       flag;        */   /* general purpose bit flag        2 bytes */
+
+    uLong       internal_fa;    /* internal file attributes        2 bytes */
+    uLong       external_fa;    /* external file attributes        4 bytes */
+} zip_fileinfo;
+
+typedef const char* zipcharpc;
+
+
+#define APPEND_STATUS_CREATE        (0)
+#define APPEND_STATUS_CREATEAFTER   (1)
+#define APPEND_STATUS_ADDINZIP      (2)
+
+extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append));
+extern zipFile ZEXPORT zipOpen64 OF((const void *pathname, int append));
+/*
+  Create a zipfile.
+     pathname contain on Windows XP a filename like "c:\\zlib\\zlib113.zip" or on
+       an Unix computer "zlib/zlib113.zip".
+     if the file pathname exist and append==APPEND_STATUS_CREATEAFTER, the zip
+       will be created at the end of the file.
+         (useful if the file contain a self extractor code)
+     if the file pathname exist and append==APPEND_STATUS_ADDINZIP, we will
+       add files in existing zip (be sure you don't add file that doesn't exist)
+     If the zipfile cannot be opened, the return value is NULL.
+     Else, the return value is a zipFile Handle, usable with other function
+       of this zip package.
+*/
+
+/* Note : there is no delete function into a zipfile.
+   If you want delete file into a zipfile, you must open a zipfile, and create another
+   Of couse, you can use RAW reading and writing to copy the file you did not want delte
+*/
+
+extern zipFile ZEXPORT zipOpen2 OF((const char *pathname,
+                                   int append,
+                                   zipcharpc* globalcomment,
+                                   zlib_filefunc_def* pzlib_filefunc_def));
+
+extern zipFile ZEXPORT zipOpen2_64 OF((const void *pathname,
+                                   int append,
+                                   zipcharpc* globalcomment,
+                                   zlib_filefunc64_def* pzlib_filefunc_def));
+
+extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file,
+                       const char* filename,
+                       const zip_fileinfo* zipfi,
+                       const void* extrafield_local,
+                       uInt size_extrafield_local,
+                       const void* extrafield_global,
+                       uInt size_extrafield_global,
+                       const char* comment,
+                       int method,
+                       int level));
+
+extern int ZEXPORT zipOpenNewFileInZip64 OF((zipFile file,
+                       const char* filename,
+                       const zip_fileinfo* zipfi,
+                       const void* extrafield_local,
+                       uInt size_extrafield_local,
+                       const void* extrafield_global,
+                       uInt size_extrafield_global,
+                       const char* comment,
+                       int method,
+                       int level,
+                       int zip64));
+
+/*
+  Open a file in the ZIP for writing.
+  filename : the filename in zip (if NULL, '-' without quote will be used
+  *zipfi contain supplemental information
+  if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local
+    contains the extrafield data the the local header
+  if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global
+    contains the extrafield data the the local header
+  if comment != NULL, comment contain the comment string
+  method contain the compression method (0 for store, Z_DEFLATED for deflate)
+  level contain the level of compression (can be Z_DEFAULT_COMPRESSION)
+  zip64 is set to 1 if a zip64 extended information block should be added to the local file header.
+                    this MUST be '1' if the uncompressed size is >= 0xffffffff.
+
+*/
+
+
+extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file,
+                                            const char* filename,
+                                            const zip_fileinfo* zipfi,
+                                            const void* extrafield_local,
+                                            uInt size_extrafield_local,
+                                            const void* extrafield_global,
+                                            uInt size_extrafield_global,
+                                            const char* comment,
+                                            int method,
+                                            int level,
+                                            int raw));
+
+
+extern int ZEXPORT zipOpenNewFileInZip2_64 OF((zipFile file,
+                                            const char* filename,
+                                            const zip_fileinfo* zipfi,
+                                            const void* extrafield_local,
+                                            uInt size_extrafield_local,
+                                            const void* extrafield_global,
+                                            uInt size_extrafield_global,
+                                            const char* comment,
+                                            int method,
+                                            int level,
+                                            int raw,
+                                            int zip64));
+/*
+  Same than zipOpenNewFileInZip, except if raw=1, we write raw file
+ */
+
+extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file,
+                                            const char* filename,
+                                            const zip_fileinfo* zipfi,
+                                            const void* extrafield_local,
+                                            uInt size_extrafield_local,
+                                            const void* extrafield_global,
+                                            uInt size_extrafield_global,
+                                            const char* comment,
+                                            int method,
+                                            int level,
+                                            int raw,
+                                            int windowBits,
+                                            int memLevel,
+                                            int strategy,
+                                            const char* password,
+                                            uLong crcForCrypting));
+
+extern int ZEXPORT zipOpenNewFileInZip3_64 OF((zipFile file,
+                                            const char* filename,
+                                            const zip_fileinfo* zipfi,
+                                            const void* extrafield_local,
+                                            uInt size_extrafield_local,
+                                            const void* extrafield_global,
+                                            uInt size_extrafield_global,
+                                            const char* comment,
+                                            int method,
+                                            int level,
+                                            int raw,
+                                            int windowBits,
+                                            int memLevel,
+                                            int strategy,
+                                            const char* password,
+                                            uLong crcForCrypting,
+                                            int zip64
+                                            ));
+
+/*
+  Same than zipOpenNewFileInZip2, except
+    windowBits,memLevel,,strategy : see parameter strategy in deflateInit2
+    password : crypting password (NULL for no crypting)
+    crcForCrypting : crc of file to compress (needed for crypting)
+ */
+
+extern int ZEXPORT zipOpenNewFileInZip4 OF((zipFile file,
+                                            const char* filename,
+                                            const zip_fileinfo* zipfi,
+                                            const void* extrafield_local,
+                                            uInt size_extrafield_local,
+                                            const void* extrafield_global,
+                                            uInt size_extrafield_global,
+                                            const char* comment,
+                                            int method,
+                                            int level,
+                                            int raw,
+                                            int windowBits,
+                                            int memLevel,
+                                            int strategy,
+                                            const char* password,
+                                            uLong crcForCrypting,
+                                            uLong versionMadeBy,
+                                            uLong flagBase
+                                            ));
+
+
+extern int ZEXPORT zipOpenNewFileInZip4_64 OF((zipFile file,
+                                            const char* filename,
+                                            const zip_fileinfo* zipfi,
+                                            const void* extrafield_local,
+                                            uInt size_extrafield_local,
+                                            const void* extrafield_global,
+                                            uInt size_extrafield_global,
+                                            const char* comment,
+                                            int method,
+                                            int level,
+                                            int raw,
+                                            int windowBits,
+                                            int memLevel,
+                                            int strategy,
+                                            const char* password,
+                                            uLong crcForCrypting,
+                                            uLong versionMadeBy,
+                                            uLong flagBase,
+                                            int zip64
+                                            ));
+/*
+  Same than zipOpenNewFileInZip4, except
+    versionMadeBy : value for Version made by field
+    flag : value for flag field (compression level info will be added)
+ */
+
+
+extern int ZEXPORT zipWriteInFileInZip OF((zipFile file,
+                       const void* buf,
+                       unsigned len));
+/*
+  Write data in the zipfile
+*/
+
+extern int ZEXPORT zipCloseFileInZip OF((zipFile file));
+/*
+  Close the current file in the zipfile
+*/
+
+extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file,
+                                            uLong uncompressed_size,
+                                            uLong crc32));
+
+extern int ZEXPORT zipCloseFileInZipRaw64 OF((zipFile file,
+                                            ZPOS64_T uncompressed_size,
+                                            uLong crc32));
+
+/*
+  Close the current file in the zipfile, for file opened with
+    parameter raw=1 in zipOpenNewFileInZip2
+  uncompressed_size and crc32 are value for the uncompressed size
+*/
+
+extern int ZEXPORT zipClose OF((zipFile file,
+                const char* global_comment));
+/*
+  Close the zipfile
+*/
+
+
+extern int ZEXPORT zipRemoveExtraInfoBlock OF((char* pData, int* dataLen, short sHeader));
+/*
+  zipRemoveExtraInfoBlock -  Added by Mathias Svensson
+
+  Remove extra information block from a extra information data for the local file header or central directory header
+
+  It is needed to remove ZIP64 extra information blocks when before data is written if using RAW mode.
+
+  0x0001 is the signature header for the ZIP64 extra information blocks
+
+  usage.
+                        Remove ZIP64 Extra information from a central director extra field data
+              zipRemoveExtraInfoBlock(pCenDirExtraFieldData, &nCenDirExtraFieldDataLen, 0x0001);
+
+                        Remove ZIP64 Extra information from a Local File Header extra field data
+        zipRemoveExtraInfoBlock(pLocalHeaderExtraFieldData, &nLocalHeaderExtraFieldDataLen, 0x0001);
+*/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _zip64_H */
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/pascal/example.pas b/Engine/lib/assimp/contrib/zlib/contrib/pascal/example.pas
new file mode 100644
index 000000000..5518b36a7
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/pascal/example.pas
@@ -0,0 +1,599 @@
+(* example.c -- usage example of the zlib compression library
+ * Copyright (C) 1995-2003 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ *
+ * Pascal translation
+ * Copyright (C) 1998 by Jacques Nomssi Nzali.
+ * For conditions of distribution and use, see copyright notice in readme.txt
+ *
+ * Adaptation to the zlibpas interface
+ * Copyright (C) 2003 by Cosmin Truta.
+ * For conditions of distribution and use, see copyright notice in readme.txt
+ *)
+
+program example;
+
+{$DEFINE TEST_COMPRESS}
+{DO NOT $DEFINE TEST_GZIO}
+{$DEFINE TEST_DEFLATE}
+{$DEFINE TEST_INFLATE}
+{$DEFINE TEST_FLUSH}
+{$DEFINE TEST_SYNC}
+{$DEFINE TEST_DICT}
+
+uses SysUtils, zlibpas;
+
+const TESTFILE = 'foo.gz';
+
+(* "hello world" would be more standard, but the repeated "hello"
+ * stresses the compression code better, sorry...
+ *)
+const hello: PChar = 'hello, hello!';
+
+const dictionary: PChar = 'hello';
+
+var dictId: LongInt; (* Adler32 value of the dictionary *)
+
+procedure CHECK_ERR(err: Integer; msg: String);
+begin
+  if err <> Z_OK then
+  begin
+    WriteLn(msg, ' error: ', err);
+    Halt(1);
+  end;
+end;
+
+procedure EXIT_ERR(const msg: String);
+begin
+  WriteLn('Error: ', msg);
+  Halt(1);
+end;
+
+(* ===========================================================================
+ * Test compress and uncompress
+ *)
+{$IFDEF TEST_COMPRESS}
+procedure test_compress(compr: Pointer; comprLen: LongInt;
+                        uncompr: Pointer; uncomprLen: LongInt);
+var err: Integer;
+    len: LongInt;
+begin
+  len := StrLen(hello)+1;
+
+  err := compress(compr, comprLen, hello, len);
+  CHECK_ERR(err, 'compress');
+
+  StrCopy(PChar(uncompr), 'garbage');
+
+  err := uncompress(uncompr, uncomprLen, compr, comprLen);
+  CHECK_ERR(err, 'uncompress');
+
+  if StrComp(PChar(uncompr), hello) <> 0 then
+    EXIT_ERR('bad uncompress')
+  else
+    WriteLn('uncompress(): ', PChar(uncompr));
+end;
+{$ENDIF}
+
+(* ===========================================================================
+ * Test read/write of .gz files
+ *)
+{$IFDEF TEST_GZIO}
+procedure test_gzio(const fname: PChar; (* compressed file name *)
+                    uncompr: Pointer;
+                    uncomprLen: LongInt);
+var err: Integer;
+    len: Integer;
+    zfile: gzFile;
+    pos: LongInt;
+begin
+  len := StrLen(hello)+1;
+
+  zfile := gzopen(fname, 'wb');
+  if zfile = NIL then
+  begin
+    WriteLn('gzopen error');
+    Halt(1);
+  end;
+  gzputc(zfile, 'h');
+  if gzputs(zfile, 'ello') <> 4 then
+  begin
+    WriteLn('gzputs err: ', gzerror(zfile, err));
+    Halt(1);
+  end;
+  {$IFDEF GZ_FORMAT_STRING}
+  if gzprintf(zfile, ', %s!', 'hello') <> 8 then
+  begin
+    WriteLn('gzprintf err: ', gzerror(zfile, err));
+    Halt(1);
+  end;
+  {$ELSE}
+  if gzputs(zfile, ', hello!') <> 8 then
+  begin
+    WriteLn('gzputs err: ', gzerror(zfile, err));
+    Halt(1);
+  end;
+  {$ENDIF}
+  gzseek(zfile, 1, SEEK_CUR); (* add one zero byte *)
+  gzclose(zfile);
+
+  zfile := gzopen(fname, 'rb');
+  if zfile = NIL then
+  begin
+    WriteLn('gzopen error');
+    Halt(1);
+  end;
+
+  StrCopy(PChar(uncompr), 'garbage');
+
+  if gzread(zfile, uncompr, uncomprLen) <> len then
+  begin
+    WriteLn('gzread err: ', gzerror(zfile, err));
+    Halt(1);
+  end;
+  if StrComp(PChar(uncompr), hello) <> 0 then
+  begin
+    WriteLn('bad gzread: ', PChar(uncompr));
+    Halt(1);
+  end
+  else
+    WriteLn('gzread(): ', PChar(uncompr));
+
+  pos := gzseek(zfile, -8, SEEK_CUR);
+  if (pos <> 6) or (gztell(zfile) <> pos) then
+  begin
+    WriteLn('gzseek error, pos=', pos, ', gztell=', gztell(zfile));
+    Halt(1);
+  end;
+
+  if gzgetc(zfile) <> ' ' then
+  begin
+    WriteLn('gzgetc error');
+    Halt(1);
+  end;
+
+  if gzungetc(' ', zfile) <> ' ' then
+  begin
+    WriteLn('gzungetc error');
+    Halt(1);
+  end;
+
+  gzgets(zfile, PChar(uncompr), uncomprLen);
+  uncomprLen := StrLen(PChar(uncompr));
+  if uncomprLen <> 7 then (* " hello!" *)
+  begin
+    WriteLn('gzgets err after gzseek: ', gzerror(zfile, err));
+    Halt(1);
+  end;
+  if StrComp(PChar(uncompr), hello + 6) <> 0 then
+  begin
+    WriteLn('bad gzgets after gzseek');
+    Halt(1);
+  end
+  else
+    WriteLn('gzgets() after gzseek: ', PChar(uncompr));
+
+  gzclose(zfile);
+end;
+{$ENDIF}
+
+(* ===========================================================================
+ * Test deflate with small buffers
+ *)
+{$IFDEF TEST_DEFLATE}
+procedure test_deflate(compr: Pointer; comprLen: LongInt);
+var c_stream: z_stream; (* compression stream *)
+    err: Integer;
+    len: LongInt;
+begin
+  len := StrLen(hello)+1;
+
+  c_stream.zalloc := NIL;
+  c_stream.zfree := NIL;
+  c_stream.opaque := NIL;
+
+  err := deflateInit(c_stream, Z_DEFAULT_COMPRESSION);
+  CHECK_ERR(err, 'deflateInit');
+
+  c_stream.next_in := hello;
+  c_stream.next_out := compr;
+
+  while (c_stream.total_in <> len) and
+        (c_stream.total_out < comprLen) do
+  begin
+    c_stream.avail_out := 1; { force small buffers }
+    c_stream.avail_in := 1;
+    err := deflate(c_stream, Z_NO_FLUSH);
+    CHECK_ERR(err, 'deflate');
+  end;
+
+  (* Finish the stream, still forcing small buffers: *)
+  while TRUE do
+  begin
+    c_stream.avail_out := 1;
+    err := deflate(c_stream, Z_FINISH);
+    if err = Z_STREAM_END then
+      break;
+    CHECK_ERR(err, 'deflate');
+  end;
+
+  err := deflateEnd(c_stream);
+  CHECK_ERR(err, 'deflateEnd');
+end;
+{$ENDIF}
+
+(* ===========================================================================
+ * Test inflate with small buffers
+ *)
+{$IFDEF TEST_INFLATE}
+procedure test_inflate(compr: Pointer; comprLen : LongInt;
+                       uncompr: Pointer; uncomprLen : LongInt);
+var err: Integer;
+    d_stream: z_stream; (* decompression stream *)
+begin
+  StrCopy(PChar(uncompr), 'garbage');
+
+  d_stream.zalloc := NIL;
+  d_stream.zfree := NIL;
+  d_stream.opaque := NIL;
+
+  d_stream.next_in := compr;
+  d_stream.avail_in := 0;
+  d_stream.next_out := uncompr;
+
+  err := inflateInit(d_stream);
+  CHECK_ERR(err, 'inflateInit');
+
+  while (d_stream.total_out < uncomprLen) and
+        (d_stream.total_in < comprLen) do
+  begin
+    d_stream.avail_out := 1; (* force small buffers *)
+    d_stream.avail_in := 1;
+    err := inflate(d_stream, Z_NO_FLUSH);
+    if err = Z_STREAM_END then
+      break;
+    CHECK_ERR(err, 'inflate');
+  end;
+
+  err := inflateEnd(d_stream);
+  CHECK_ERR(err, 'inflateEnd');
+
+  if StrComp(PChar(uncompr), hello) <> 0 then
+    EXIT_ERR('bad inflate')
+  else
+    WriteLn('inflate(): ', PChar(uncompr));
+end;
+{$ENDIF}
+
+(* ===========================================================================
+ * Test deflate with large buffers and dynamic change of compression level
+ *)
+{$IFDEF TEST_DEFLATE}
+procedure test_large_deflate(compr: Pointer; comprLen: LongInt;
+                             uncompr: Pointer; uncomprLen: LongInt);
+var c_stream: z_stream; (* compression stream *)
+    err: Integer;
+begin
+  c_stream.zalloc := NIL;
+  c_stream.zfree := NIL;
+  c_stream.opaque := NIL;
+
+  err := deflateInit(c_stream, Z_BEST_SPEED);
+  CHECK_ERR(err, 'deflateInit');
+
+  c_stream.next_out := compr;
+  c_stream.avail_out := Integer(comprLen);
+
+  (* At this point, uncompr is still mostly zeroes, so it should compress
+   * very well:
+   *)
+  c_stream.next_in := uncompr;
+  c_stream.avail_in := Integer(uncomprLen);
+  err := deflate(c_stream, Z_NO_FLUSH);
+  CHECK_ERR(err, 'deflate');
+  if c_stream.avail_in <> 0 then
+    EXIT_ERR('deflate not greedy');
+
+  (* Feed in already compressed data and switch to no compression: *)
+  deflateParams(c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY);
+  c_stream.next_in := compr;
+  c_stream.avail_in := Integer(comprLen div 2);
+  err := deflate(c_stream, Z_NO_FLUSH);
+  CHECK_ERR(err, 'deflate');
+
+  (* Switch back to compressing mode: *)
+  deflateParams(c_stream, Z_BEST_COMPRESSION, Z_FILTERED);
+  c_stream.next_in := uncompr;
+  c_stream.avail_in := Integer(uncomprLen);
+  err := deflate(c_stream, Z_NO_FLUSH);
+  CHECK_ERR(err, 'deflate');
+
+  err := deflate(c_stream, Z_FINISH);
+  if err <> Z_STREAM_END then
+    EXIT_ERR('deflate should report Z_STREAM_END');
+
+  err := deflateEnd(c_stream);
+  CHECK_ERR(err, 'deflateEnd');
+end;
+{$ENDIF}
+
+(* ===========================================================================
+ * Test inflate with large buffers
+ *)
+{$IFDEF TEST_INFLATE}
+procedure test_large_inflate(compr: Pointer; comprLen: LongInt;
+                             uncompr: Pointer; uncomprLen: LongInt);
+var err: Integer;
+    d_stream: z_stream; (* decompression stream *)
+begin
+  StrCopy(PChar(uncompr), 'garbage');
+
+  d_stream.zalloc := NIL;
+  d_stream.zfree := NIL;
+  d_stream.opaque := NIL;
+
+  d_stream.next_in := compr;
+  d_stream.avail_in := Integer(comprLen);
+
+  err := inflateInit(d_stream);
+  CHECK_ERR(err, 'inflateInit');
+
+  while TRUE do
+  begin
+    d_stream.next_out := uncompr;            (* discard the output *)
+    d_stream.avail_out := Integer(uncomprLen);
+    err := inflate(d_stream, Z_NO_FLUSH);
+    if err = Z_STREAM_END then
+      break;
+    CHECK_ERR(err, 'large inflate');
+  end;
+
+  err := inflateEnd(d_stream);
+  CHECK_ERR(err, 'inflateEnd');
+
+  if d_stream.total_out <> 2 * uncomprLen + comprLen div 2 then
+  begin
+    WriteLn('bad large inflate: ', d_stream.total_out);
+    Halt(1);
+  end
+  else
+    WriteLn('large_inflate(): OK');
+end;
+{$ENDIF}
+
+(* ===========================================================================
+ * Test deflate with full flush
+ *)
+{$IFDEF TEST_FLUSH}
+procedure test_flush(compr: Pointer; var comprLen : LongInt);
+var c_stream: z_stream; (* compression stream *)
+    err: Integer;
+    len: Integer;
+begin
+  len := StrLen(hello)+1;
+
+  c_stream.zalloc := NIL;
+  c_stream.zfree := NIL;
+  c_stream.opaque := NIL;
+
+  err := deflateInit(c_stream, Z_DEFAULT_COMPRESSION);
+  CHECK_ERR(err, 'deflateInit');
+
+  c_stream.next_in := hello;
+  c_stream.next_out := compr;
+  c_stream.avail_in := 3;
+  c_stream.avail_out := Integer(comprLen);
+  err := deflate(c_stream, Z_FULL_FLUSH);
+  CHECK_ERR(err, 'deflate');
+
+  Inc(PByteArray(compr)^[3]); (* force an error in first compressed block *)
+  c_stream.avail_in := len - 3;
+
+  err := deflate(c_stream, Z_FINISH);
+  if err <> Z_STREAM_END then
+    CHECK_ERR(err, 'deflate');
+
+  err := deflateEnd(c_stream);
+  CHECK_ERR(err, 'deflateEnd');
+
+  comprLen := c_stream.total_out;
+end;
+{$ENDIF}
+
+(* ===========================================================================
+ * Test inflateSync()
+ *)
+{$IFDEF TEST_SYNC}
+procedure test_sync(compr: Pointer; comprLen: LongInt;
+                    uncompr: Pointer; uncomprLen : LongInt);
+var err: Integer;
+    d_stream: z_stream; (* decompression stream *)
+begin
+  StrCopy(PChar(uncompr), 'garbage');
+
+  d_stream.zalloc := NIL;
+  d_stream.zfree := NIL;
+  d_stream.opaque := NIL;
+
+  d_stream.next_in := compr;
+  d_stream.avail_in := 2; (* just read the zlib header *)
+
+  err := inflateInit(d_stream);
+  CHECK_ERR(err, 'inflateInit');
+
+  d_stream.next_out := uncompr;
+  d_stream.avail_out := Integer(uncomprLen);
+
+  inflate(d_stream, Z_NO_FLUSH);
+  CHECK_ERR(err, 'inflate');
+
+  d_stream.avail_in := Integer(comprLen-2);   (* read all compressed data *)
+  err := inflateSync(d_stream);               (* but skip the damaged part *)
+  CHECK_ERR(err, 'inflateSync');
+
+  err := inflate(d_stream, Z_FINISH);
+  if err <> Z_DATA_ERROR then
+    EXIT_ERR('inflate should report DATA_ERROR');
+    (* Because of incorrect adler32 *)
+
+  err := inflateEnd(d_stream);
+  CHECK_ERR(err, 'inflateEnd');
+
+  WriteLn('after inflateSync(): hel', PChar(uncompr));
+end;
+{$ENDIF}
+
+(* ===========================================================================
+ * Test deflate with preset dictionary
+ *)
+{$IFDEF TEST_DICT}
+procedure test_dict_deflate(compr: Pointer; comprLen: LongInt);
+var c_stream: z_stream; (* compression stream *)
+    err: Integer;
+begin
+  c_stream.zalloc := NIL;
+  c_stream.zfree := NIL;
+  c_stream.opaque := NIL;
+
+  err := deflateInit(c_stream, Z_BEST_COMPRESSION);
+  CHECK_ERR(err, 'deflateInit');
+
+  err := deflateSetDictionary(c_stream, dictionary, StrLen(dictionary));
+  CHECK_ERR(err, 'deflateSetDictionary');
+
+  dictId := c_stream.adler;
+  c_stream.next_out := compr;
+  c_stream.avail_out := Integer(comprLen);
+
+  c_stream.next_in := hello;
+  c_stream.avail_in := StrLen(hello)+1;
+
+  err := deflate(c_stream, Z_FINISH);
+  if err <> Z_STREAM_END then
+    EXIT_ERR('deflate should report Z_STREAM_END');
+
+  err := deflateEnd(c_stream);
+  CHECK_ERR(err, 'deflateEnd');
+end;
+{$ENDIF}
+
+(* ===========================================================================
+ * Test inflate with a preset dictionary
+ *)
+{$IFDEF TEST_DICT}
+procedure test_dict_inflate(compr: Pointer; comprLen: LongInt;
+                            uncompr: Pointer; uncomprLen: LongInt);
+var err: Integer;
+    d_stream: z_stream; (* decompression stream *)
+begin
+  StrCopy(PChar(uncompr), 'garbage');
+
+  d_stream.zalloc := NIL;
+  d_stream.zfree := NIL;
+  d_stream.opaque := NIL;
+
+  d_stream.next_in := compr;
+  d_stream.avail_in := Integer(comprLen);
+
+  err := inflateInit(d_stream);
+  CHECK_ERR(err, 'inflateInit');
+
+  d_stream.next_out := uncompr;
+  d_stream.avail_out := Integer(uncomprLen);
+
+  while TRUE do
+  begin
+    err := inflate(d_stream, Z_NO_FLUSH);
+    if err = Z_STREAM_END then
+      break;
+    if err = Z_NEED_DICT then
+    begin
+      if d_stream.adler <> dictId then
+        EXIT_ERR('unexpected dictionary');
+      err := inflateSetDictionary(d_stream, dictionary, StrLen(dictionary));
+    end;
+    CHECK_ERR(err, 'inflate with dict');
+  end;
+
+  err := inflateEnd(d_stream);
+  CHECK_ERR(err, 'inflateEnd');
+
+  if StrComp(PChar(uncompr), hello) <> 0 then
+    EXIT_ERR('bad inflate with dict')
+  else
+    WriteLn('inflate with dictionary: ', PChar(uncompr));
+end;
+{$ENDIF}
+
+var compr, uncompr: Pointer;
+    comprLen, uncomprLen: LongInt;
+
+begin
+  if zlibVersion^ <> ZLIB_VERSION[1] then
+    EXIT_ERR('Incompatible zlib version');
+
+  WriteLn('zlib version: ', zlibVersion);
+  WriteLn('zlib compile flags: ', Format('0x%x', [zlibCompileFlags]));
+
+  comprLen := 10000 * SizeOf(Integer); (* don't overflow on MSDOS *)
+  uncomprLen := comprLen;
+  GetMem(compr, comprLen);
+  GetMem(uncompr, uncomprLen);
+  if (compr = NIL) or (uncompr = NIL) then
+    EXIT_ERR('Out of memory');
+  (* compr and uncompr are cleared to avoid reading uninitialized
+   * data and to ensure that uncompr compresses well.
+   *)
+  FillChar(compr^, comprLen, 0);
+  FillChar(uncompr^, uncomprLen, 0);
+
+  {$IFDEF TEST_COMPRESS}
+  WriteLn('** Testing compress');
+  test_compress(compr, comprLen, uncompr, uncomprLen);
+  {$ENDIF}
+
+  {$IFDEF TEST_GZIO}
+  WriteLn('** Testing gzio');
+  if ParamCount >= 1 then
+    test_gzio(ParamStr(1), uncompr, uncomprLen)
+  else
+    test_gzio(TESTFILE, uncompr, uncomprLen);
+  {$ENDIF}
+
+  {$IFDEF TEST_DEFLATE}
+  WriteLn('** Testing deflate with small buffers');
+  test_deflate(compr, comprLen);
+  {$ENDIF}
+  {$IFDEF TEST_INFLATE}
+  WriteLn('** Testing inflate with small buffers');
+  test_inflate(compr, comprLen, uncompr, uncomprLen);
+  {$ENDIF}
+
+  {$IFDEF TEST_DEFLATE}
+  WriteLn('** Testing deflate with large buffers');
+  test_large_deflate(compr, comprLen, uncompr, uncomprLen);
+  {$ENDIF}
+  {$IFDEF TEST_INFLATE}
+  WriteLn('** Testing inflate with large buffers');
+  test_large_inflate(compr, comprLen, uncompr, uncomprLen);
+  {$ENDIF}
+
+  {$IFDEF TEST_FLUSH}
+  WriteLn('** Testing deflate with full flush');
+  test_flush(compr, comprLen);
+  {$ENDIF}
+  {$IFDEF TEST_SYNC}
+  WriteLn('** Testing inflateSync');
+  test_sync(compr, comprLen, uncompr, uncomprLen);
+  {$ENDIF}
+  comprLen := uncomprLen;
+
+  {$IFDEF TEST_DICT}
+  WriteLn('** Testing deflate and inflate with preset dictionary');
+  test_dict_deflate(compr, comprLen);
+  test_dict_inflate(compr, comprLen, uncompr, uncomprLen);
+  {$ENDIF}
+
+  FreeMem(compr, comprLen);
+  FreeMem(uncompr, uncomprLen);
+end.
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/pascal/readme.txt b/Engine/lib/assimp/contrib/zlib/contrib/pascal/readme.txt
new file mode 100644
index 000000000..60e87c8a3
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/pascal/readme.txt
@@ -0,0 +1,76 @@
+
+This directory contains a Pascal (Delphi, Kylix) interface to the
+zlib data compression library.
+
+
+Directory listing
+=================
+
+zlibd32.mak     makefile for Borland C++
+example.pas     usage example of zlib
+zlibpas.pas     the Pascal interface to zlib
+readme.txt      this file
+
+
+Compatibility notes
+===================
+
+- Although the name "zlib" would have been more normal for the
+  zlibpas unit, this name is already taken by Borland's ZLib unit.
+  This is somehow unfortunate, because that unit is not a genuine
+  interface to the full-fledged zlib functionality, but a suite of
+  class wrappers around zlib streams.  Other essential features,
+  such as checksums, are missing.
+  It would have been more appropriate for that unit to have a name
+  like "ZStreams", or something similar.
+
+- The C and zlib-supplied types int, uInt, long, uLong, etc. are
+  translated directly into Pascal types of similar sizes (Integer,
+  LongInt, etc.), to avoid namespace pollution.  In particular,
+  there is no conversion of unsigned int into a Pascal unsigned
+  integer.  The Word type is non-portable and has the same size
+  (16 bits) both in a 16-bit and in a 32-bit environment, unlike
+  Integer.  Even if there is a 32-bit Cardinal type, there is no
+  real need for unsigned int in zlib under a 32-bit environment.
+
+- Except for the callbacks, the zlib function interfaces are
+  assuming the calling convention normally used in Pascal
+  (__pascal for DOS and Windows16, __fastcall for Windows32).
+  Since the cdecl keyword is used, the old Turbo Pascal does
+  not work with this interface.
+
+- The gz* function interfaces are not translated, to avoid
+  interfacing problems with the C runtime library.  Besides,
+    gzprintf(gzFile file, const char *format, ...)
+  cannot be translated into Pascal.
+
+
+Legal issues
+============
+
+The zlibpas interface is:
+  Copyright (C) 1995-2003 Jean-loup Gailly and Mark Adler.
+  Copyright (C) 1998 by Bob Dellaca.
+  Copyright (C) 2003 by Cosmin Truta.
+
+The example program is:
+  Copyright (C) 1995-2003 by Jean-loup Gailly.
+  Copyright (C) 1998,1999,2000 by Jacques Nomssi Nzali.
+  Copyright (C) 2003 by Cosmin Truta.
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the author be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/pascal/zlibd32.mak b/Engine/lib/assimp/contrib/zlib/contrib/pascal/zlibd32.mak
new file mode 100644
index 000000000..9bb00b7cc
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/pascal/zlibd32.mak
@@ -0,0 +1,99 @@
+# Makefile for zlib
+# For use with Delphi and C++ Builder under Win32
+# Updated for zlib 1.2.x by Cosmin Truta
+
+# ------------ Borland C++ ------------
+
+# This project uses the Delphi (fastcall/register) calling convention:
+LOC = -DZEXPORT=__fastcall -DZEXPORTVA=__cdecl
+
+CC = bcc32
+LD = bcc32
+AR = tlib
+# do not use "-pr" in CFLAGS
+CFLAGS = -a -d -k- -O2 $(LOC)
+LDFLAGS =
+
+
+# variables
+ZLIB_LIB = zlib.lib
+
+OBJ1 = adler32.obj compress.obj crc32.obj deflate.obj gzclose.obj gzlib.obj gzread.obj
+OBJ2 = gzwrite.obj infback.obj inffast.obj inflate.obj inftrees.obj trees.obj uncompr.obj zutil.obj
+OBJP1 = +adler32.obj+compress.obj+crc32.obj+deflate.obj+gzclose.obj+gzlib.obj+gzread.obj
+OBJP2 = +gzwrite.obj+infback.obj+inffast.obj+inflate.obj+inftrees.obj+trees.obj+uncompr.obj+zutil.obj
+
+
+# targets
+all: $(ZLIB_LIB) example.exe minigzip.exe
+
+.c.obj:
+	$(CC) -c $(CFLAGS) $*.c
+
+adler32.obj: adler32.c zlib.h zconf.h
+
+compress.obj: compress.c zlib.h zconf.h
+
+crc32.obj: crc32.c zlib.h zconf.h crc32.h
+
+deflate.obj: deflate.c deflate.h zutil.h zlib.h zconf.h
+
+gzclose.obj: gzclose.c zlib.h zconf.h gzguts.h
+
+gzlib.obj: gzlib.c zlib.h zconf.h gzguts.h
+
+gzread.obj: gzread.c zlib.h zconf.h gzguts.h
+
+gzwrite.obj: gzwrite.c zlib.h zconf.h gzguts.h
+
+infback.obj: infback.c zutil.h zlib.h zconf.h inftrees.h inflate.h \
+ inffast.h inffixed.h
+
+inffast.obj: inffast.c zutil.h zlib.h zconf.h inftrees.h inflate.h \
+ inffast.h
+
+inflate.obj: inflate.c zutil.h zlib.h zconf.h inftrees.h inflate.h \
+ inffast.h inffixed.h
+
+inftrees.obj: inftrees.c zutil.h zlib.h zconf.h inftrees.h
+
+trees.obj: trees.c zutil.h zlib.h zconf.h deflate.h trees.h
+
+uncompr.obj: uncompr.c zlib.h zconf.h
+
+zutil.obj: zutil.c zutil.h zlib.h zconf.h
+
+example.obj: test/example.c zlib.h zconf.h
+
+minigzip.obj: test/minigzip.c zlib.h zconf.h
+
+
+# For the sake of the old Borland make,
+# the command line is cut to fit in the MS-DOS 128 byte limit:
+$(ZLIB_LIB): $(OBJ1) $(OBJ2)
+	-del $(ZLIB_LIB)
+	$(AR) $(ZLIB_LIB) $(OBJP1)
+	$(AR) $(ZLIB_LIB) $(OBJP2)
+
+
+# testing
+test: example.exe minigzip.exe
+	example
+	echo hello world | minigzip | minigzip -d
+
+example.exe: example.obj $(ZLIB_LIB)
+	$(LD) $(LDFLAGS) example.obj $(ZLIB_LIB)
+
+minigzip.exe: minigzip.obj $(ZLIB_LIB)
+	$(LD) $(LDFLAGS) minigzip.obj $(ZLIB_LIB)
+
+
+# cleanup
+clean:
+	-del *.obj
+	-del *.exe
+	-del *.lib
+	-del *.tds
+	-del zlib.bak
+	-del foo.gz
+
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/pascal/zlibpas.pas b/Engine/lib/assimp/contrib/zlib/contrib/pascal/zlibpas.pas
new file mode 100644
index 000000000..a0dff11b5
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/pascal/zlibpas.pas
@@ -0,0 +1,276 @@
+(* zlibpas -- Pascal interface to the zlib data compression library
+ *
+ * Copyright (C) 2003 Cosmin Truta.
+ * Derived from original sources by Bob Dellaca.
+ * For conditions of distribution and use, see copyright notice in readme.txt
+ *)
+
+unit zlibpas;
+
+interface
+
+const
+  ZLIB_VERSION = '1.2.11';
+  ZLIB_VERNUM  = $12a0;
+
+type
+  alloc_func = function(opaque: Pointer; items, size: Integer): Pointer;
+                 cdecl;
+  free_func  = procedure(opaque, address: Pointer);
+                 cdecl;
+
+  in_func    = function(opaque: Pointer; var buf: PByte): Integer;
+                 cdecl;
+  out_func   = function(opaque: Pointer; buf: PByte; size: Integer): Integer;
+                 cdecl;
+
+  z_streamp = ^z_stream;
+  z_stream = packed record
+    next_in: PChar;       (* next input byte *)
+    avail_in: Integer;    (* number of bytes available at next_in *)
+    total_in: LongInt;    (* total nb of input bytes read so far *)
+
+    next_out: PChar;      (* next output byte should be put there *)
+    avail_out: Integer;   (* remaining free space at next_out *)
+    total_out: LongInt;   (* total nb of bytes output so far *)
+
+    msg: PChar;           (* last error message, NULL if no error *)
+    state: Pointer;       (* not visible by applications *)
+
+    zalloc: alloc_func;   (* used to allocate the internal state *)
+    zfree: free_func;     (* used to free the internal state *)
+    opaque: Pointer;      (* private data object passed to zalloc and zfree *)
+
+    data_type: Integer;   (* best guess about the data type: ascii or binary *)
+    adler: LongInt;       (* adler32 value of the uncompressed data *)
+    reserved: LongInt;    (* reserved for future use *)
+  end;
+
+  gz_headerp = ^gz_header;
+  gz_header = packed record
+    text: Integer;        (* true if compressed data believed to be text *)
+    time: LongInt;        (* modification time *)
+    xflags: Integer;      (* extra flags (not used when writing a gzip file) *)
+    os: Integer;          (* operating system *)
+    extra: PChar;         (* pointer to extra field or Z_NULL if none *)
+    extra_len: Integer;   (* extra field length (valid if extra != Z_NULL) *)
+    extra_max: Integer;   (* space at extra (only when reading header) *)
+    name: PChar;          (* pointer to zero-terminated file name or Z_NULL *)
+    name_max: Integer;    (* space at name (only when reading header) *)
+    comment: PChar;       (* pointer to zero-terminated comment or Z_NULL *)
+    comm_max: Integer;    (* space at comment (only when reading header) *)
+    hcrc: Integer;        (* true if there was or will be a header crc *)
+    done: Integer;        (* true when done reading gzip header *)
+  end;
+
+(* constants *)
+const
+  Z_NO_FLUSH      = 0;
+  Z_PARTIAL_FLUSH = 1;
+  Z_SYNC_FLUSH    = 2;
+  Z_FULL_FLUSH    = 3;
+  Z_FINISH        = 4;
+  Z_BLOCK         = 5;
+  Z_TREES         = 6;
+
+  Z_OK            =  0;
+  Z_STREAM_END    =  1;
+  Z_NEED_DICT     =  2;
+  Z_ERRNO         = -1;
+  Z_STREAM_ERROR  = -2;
+  Z_DATA_ERROR    = -3;
+  Z_MEM_ERROR     = -4;
+  Z_BUF_ERROR     = -5;
+  Z_VERSION_ERROR = -6;
+
+  Z_NO_COMPRESSION       =  0;
+  Z_BEST_SPEED           =  1;
+  Z_BEST_COMPRESSION     =  9;
+  Z_DEFAULT_COMPRESSION  = -1;
+
+  Z_FILTERED            = 1;
+  Z_HUFFMAN_ONLY        = 2;
+  Z_RLE                 = 3;
+  Z_FIXED               = 4;
+  Z_DEFAULT_STRATEGY    = 0;
+
+  Z_BINARY   = 0;
+  Z_TEXT     = 1;
+  Z_ASCII    = 1;
+  Z_UNKNOWN  = 2;
+
+  Z_DEFLATED = 8;
+
+(* basic functions *)
+function zlibVersion: PChar;
+function deflateInit(var strm: z_stream; level: Integer): Integer;
+function deflate(var strm: z_stream; flush: Integer): Integer;
+function deflateEnd(var strm: z_stream): Integer;
+function inflateInit(var strm: z_stream): Integer;
+function inflate(var strm: z_stream; flush: Integer): Integer;
+function inflateEnd(var strm: z_stream): Integer;
+
+(* advanced functions *)
+function deflateInit2(var strm: z_stream; level, method, windowBits,
+                      memLevel, strategy: Integer): Integer;
+function deflateSetDictionary(var strm: z_stream; const dictionary: PChar;
+                              dictLength: Integer): Integer;
+function deflateCopy(var dest, source: z_stream): Integer;
+function deflateReset(var strm: z_stream): Integer;
+function deflateParams(var strm: z_stream; level, strategy: Integer): Integer;
+function deflateTune(var strm: z_stream; good_length, max_lazy, nice_length, max_chain: Integer): Integer;
+function deflateBound(var strm: z_stream; sourceLen: LongInt): LongInt;
+function deflatePending(var strm: z_stream; var pending: Integer; var bits: Integer): Integer;
+function deflatePrime(var strm: z_stream; bits, value: Integer): Integer;
+function deflateSetHeader(var strm: z_stream; head: gz_header): Integer;
+function inflateInit2(var strm: z_stream; windowBits: Integer): Integer;
+function inflateSetDictionary(var strm: z_stream; const dictionary: PChar;
+                              dictLength: Integer): Integer;
+function inflateSync(var strm: z_stream): Integer;
+function inflateCopy(var dest, source: z_stream): Integer;
+function inflateReset(var strm: z_stream): Integer;
+function inflateReset2(var strm: z_stream; windowBits: Integer): Integer;
+function inflatePrime(var strm: z_stream; bits, value: Integer): Integer;
+function inflateMark(var strm: z_stream): LongInt;
+function inflateGetHeader(var strm: z_stream; var head: gz_header): Integer;
+function inflateBackInit(var strm: z_stream;
+                         windowBits: Integer; window: PChar): Integer;
+function inflateBack(var strm: z_stream; in_fn: in_func; in_desc: Pointer;
+                     out_fn: out_func; out_desc: Pointer): Integer;
+function inflateBackEnd(var strm: z_stream): Integer;
+function zlibCompileFlags: LongInt;
+
+(* utility functions *)
+function compress(dest: PChar; var destLen: LongInt;
+                  const source: PChar; sourceLen: LongInt): Integer;
+function compress2(dest: PChar; var destLen: LongInt;
+                  const source: PChar; sourceLen: LongInt;
+                  level: Integer): Integer;
+function compressBound(sourceLen: LongInt): LongInt;
+function uncompress(dest: PChar; var destLen: LongInt;
+                    const source: PChar; sourceLen: LongInt): Integer;
+
+(* checksum functions *)
+function adler32(adler: LongInt; const buf: PChar; len: Integer): LongInt;
+function adler32_combine(adler1, adler2, len2: LongInt): LongInt;
+function crc32(crc: LongInt; const buf: PChar; len: Integer): LongInt;
+function crc32_combine(crc1, crc2, len2: LongInt): LongInt;
+
+(* various hacks, don't look :) *)
+function deflateInit_(var strm: z_stream; level: Integer;
+                      const version: PChar; stream_size: Integer): Integer;
+function inflateInit_(var strm: z_stream; const version: PChar;
+                      stream_size: Integer): Integer;
+function deflateInit2_(var strm: z_stream;
+                       level, method, windowBits, memLevel, strategy: Integer;
+                       const version: PChar; stream_size: Integer): Integer;
+function inflateInit2_(var strm: z_stream; windowBits: Integer;
+                       const version: PChar; stream_size: Integer): Integer;
+function inflateBackInit_(var strm: z_stream;
+                          windowBits: Integer; window: PChar;
+                          const version: PChar; stream_size: Integer): Integer;
+
+
+implementation
+
+{$L adler32.obj}
+{$L compress.obj}
+{$L crc32.obj}
+{$L deflate.obj}
+{$L infback.obj}
+{$L inffast.obj}
+{$L inflate.obj}
+{$L inftrees.obj}
+{$L trees.obj}
+{$L uncompr.obj}
+{$L zutil.obj}
+
+function adler32; external;
+function adler32_combine; external;
+function compress; external;
+function compress2; external;
+function compressBound; external;
+function crc32; external;
+function crc32_combine; external;
+function deflate; external;
+function deflateBound; external;
+function deflateCopy; external;
+function deflateEnd; external;
+function deflateInit_; external;
+function deflateInit2_; external;
+function deflateParams; external;
+function deflatePending; external;
+function deflatePrime; external;
+function deflateReset; external;
+function deflateSetDictionary; external;
+function deflateSetHeader; external;
+function deflateTune; external;
+function inflate; external;
+function inflateBack; external;
+function inflateBackEnd; external;
+function inflateBackInit_; external;
+function inflateCopy; external;
+function inflateEnd; external;
+function inflateGetHeader; external;
+function inflateInit_; external;
+function inflateInit2_; external;
+function inflateMark; external;
+function inflatePrime; external;
+function inflateReset; external;
+function inflateReset2; external;
+function inflateSetDictionary; external;
+function inflateSync; external;
+function uncompress; external;
+function zlibCompileFlags; external;
+function zlibVersion; external;
+
+function deflateInit(var strm: z_stream; level: Integer): Integer;
+begin
+  Result := deflateInit_(strm, level, ZLIB_VERSION, sizeof(z_stream));
+end;
+
+function deflateInit2(var strm: z_stream; level, method, windowBits, memLevel,
+                      strategy: Integer): Integer;
+begin
+  Result := deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
+                          ZLIB_VERSION, sizeof(z_stream));
+end;
+
+function inflateInit(var strm: z_stream): Integer;
+begin
+  Result := inflateInit_(strm, ZLIB_VERSION, sizeof(z_stream));
+end;
+
+function inflateInit2(var strm: z_stream; windowBits: Integer): Integer;
+begin
+  Result := inflateInit2_(strm, windowBits, ZLIB_VERSION, sizeof(z_stream));
+end;
+
+function inflateBackInit(var strm: z_stream;
+                         windowBits: Integer; window: PChar): Integer;
+begin
+  Result := inflateBackInit_(strm, windowBits, window,
+                             ZLIB_VERSION, sizeof(z_stream));
+end;
+
+function _malloc(Size: Integer): Pointer; cdecl;
+begin
+  GetMem(Result, Size);
+end;
+
+procedure _free(Block: Pointer); cdecl;
+begin
+  FreeMem(Block);
+end;
+
+procedure _memset(P: Pointer; B: Byte; count: Integer); cdecl;
+begin
+  FillChar(P^, count, B);
+end;
+
+procedure _memcpy(dest, source: Pointer; count: Integer); cdecl;
+begin
+  Move(source^, dest^, count);
+end;
+
+end.
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/puff/README b/Engine/lib/assimp/contrib/zlib/contrib/puff/README
new file mode 100644
index 000000000..bbc4cb595
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/puff/README
@@ -0,0 +1,63 @@
+Puff -- A Simple Inflate
+3 Mar 2003
+Mark Adler
+madler@alumni.caltech.edu
+
+What this is --
+
+puff.c provides the routine puff() to decompress the deflate data format.  It
+does so more slowly than zlib, but the code is about one-fifth the size of the
+inflate code in zlib, and written to be very easy to read.
+
+Why I wrote this --
+
+puff.c was written to document the deflate format unambiguously, by virtue of
+being working C code.  It is meant to supplement RFC 1951, which formally
+describes the deflate format.  I have received many questions on details of the
+deflate format, and I hope that reading this code will answer those questions.
+puff.c is heavily commented with details of the deflate format, especially
+those little nooks and cranies of the format that might not be obvious from a
+specification.
+
+puff.c may also be useful in applications where code size or memory usage is a
+very limited resource, and speed is not as important.
+
+How to use it --
+
+Well, most likely you should just be reading puff.c and using zlib for actual
+applications, but if you must ...
+
+Include puff.h in your code, which provides this prototype:
+
+int puff(unsigned char *dest,           /* pointer to destination pointer */
+         unsigned long *destlen,        /* amount of output space */
+         unsigned char *source,         /* pointer to source data pointer */
+         unsigned long *sourcelen);     /* amount of input available */
+
+Then you can call puff() to decompress a deflate stream that is in memory in
+its entirety at source, to a sufficiently sized block of memory for the
+decompressed data at dest.  puff() is the only external symbol in puff.c  The
+only C library functions that puff.c needs are setjmp() and longjmp(), which
+are used to simplify error checking in the code to improve readabilty.  puff.c
+does no memory allocation, and uses less than 2K bytes off of the stack.
+
+If destlen is not enough space for the uncompressed data, then inflate will
+return an error without writing more than destlen bytes.  Note that this means
+that in order to decompress the deflate data successfully, you need to know
+the size of the uncompressed data ahead of time.
+
+If needed, puff() can determine the size of the uncompressed data with no
+output space.  This is done by passing dest equal to (unsigned char *)0.  Then
+the initial value of *destlen is ignored and *destlen is set to the length of
+the uncompressed data.  So if the size of the uncompressed data is not known,
+then two passes of puff() can be used--first to determine the size, and second
+to do the actual inflation after allocating the appropriate memory.  Not
+pretty, but it works.  (This is one of the reasons you should be using zlib.)
+
+The deflate format is self-terminating.  If the deflate stream does not end
+in *sourcelen bytes, puff() will return an error without reading at or past
+endsource.
+
+On return, *sourcelen is updated to the amount of input data consumed, and
+*destlen is updated to the size of the uncompressed data.  See the comments
+in puff.c for the possible return codes for puff().
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/puff/puff.c b/Engine/lib/assimp/contrib/zlib/contrib/puff/puff.c
new file mode 100644
index 000000000..c6c90d714
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/puff/puff.c
@@ -0,0 +1,840 @@
+/*
+ * puff.c
+ * Copyright (C) 2002-2013 Mark Adler
+ * For conditions of distribution and use, see copyright notice in puff.h
+ * version 2.3, 21 Jan 2013
+ *
+ * puff.c is a simple inflate written to be an unambiguous way to specify the
+ * deflate format.  It is not written for speed but rather simplicity.  As a
+ * side benefit, this code might actually be useful when small code is more
+ * important than speed, such as bootstrap applications.  For typical deflate
+ * data, zlib's inflate() is about four times as fast as puff().  zlib's
+ * inflate compiles to around 20K on my machine, whereas puff.c compiles to
+ * around 4K on my machine (a PowerPC using GNU cc).  If the faster decode()
+ * function here is used, then puff() is only twice as slow as zlib's
+ * inflate().
+ *
+ * All dynamically allocated memory comes from the stack.  The stack required
+ * is less than 2K bytes.  This code is compatible with 16-bit int's and
+ * assumes that long's are at least 32 bits.  puff.c uses the short data type,
+ * assumed to be 16 bits, for arrays in order to conserve memory.  The code
+ * works whether integers are stored big endian or little endian.
+ *
+ * In the comments below are "Format notes" that describe the inflate process
+ * and document some of the less obvious aspects of the format.  This source
+ * code is meant to supplement RFC 1951, which formally describes the deflate
+ * format:
+ *
+ *    http://www.zlib.org/rfc-deflate.html
+ */
+
+/*
+ * Change history:
+ *
+ * 1.0  10 Feb 2002     - First version
+ * 1.1  17 Feb 2002     - Clarifications of some comments and notes
+ *                      - Update puff() dest and source pointers on negative
+ *                        errors to facilitate debugging deflators
+ *                      - Remove longest from struct huffman -- not needed
+ *                      - Simplify offs[] index in construct()
+ *                      - Add input size and checking, using longjmp() to
+ *                        maintain easy readability
+ *                      - Use short data type for large arrays
+ *                      - Use pointers instead of long to specify source and
+ *                        destination sizes to avoid arbitrary 4 GB limits
+ * 1.2  17 Mar 2002     - Add faster version of decode(), doubles speed (!),
+ *                        but leave simple version for readabilty
+ *                      - Make sure invalid distances detected if pointers
+ *                        are 16 bits
+ *                      - Fix fixed codes table error
+ *                      - Provide a scanning mode for determining size of
+ *                        uncompressed data
+ * 1.3  20 Mar 2002     - Go back to lengths for puff() parameters [Gailly]
+ *                      - Add a puff.h file for the interface
+ *                      - Add braces in puff() for else do [Gailly]
+ *                      - Use indexes instead of pointers for readability
+ * 1.4  31 Mar 2002     - Simplify construct() code set check
+ *                      - Fix some comments
+ *                      - Add FIXLCODES #define
+ * 1.5   6 Apr 2002     - Minor comment fixes
+ * 1.6   7 Aug 2002     - Minor format changes
+ * 1.7   3 Mar 2003     - Added test code for distribution
+ *                      - Added zlib-like license
+ * 1.8   9 Jan 2004     - Added some comments on no distance codes case
+ * 1.9  21 Feb 2008     - Fix bug on 16-bit integer architectures [Pohland]
+ *                      - Catch missing end-of-block symbol error
+ * 2.0  25 Jul 2008     - Add #define to permit distance too far back
+ *                      - Add option in TEST code for puff to write the data
+ *                      - Add option in TEST code to skip input bytes
+ *                      - Allow TEST code to read from piped stdin
+ * 2.1   4 Apr 2010     - Avoid variable initialization for happier compilers
+ *                      - Avoid unsigned comparisons for even happier compilers
+ * 2.2  25 Apr 2010     - Fix bug in variable initializations [Oberhumer]
+ *                      - Add const where appropriate [Oberhumer]
+ *                      - Split if's and ?'s for coverage testing
+ *                      - Break out test code to separate file
+ *                      - Move NIL to puff.h
+ *                      - Allow incomplete code only if single code length is 1
+ *                      - Add full code coverage test to Makefile
+ * 2.3  21 Jan 2013     - Check for invalid code length codes in dynamic blocks
+ */
+
+#include <setjmp.h>             /* for setjmp(), longjmp(), and jmp_buf */
+#include "puff.h"               /* prototype for puff() */
+
+#define local static            /* for local function definitions */
+
+/*
+ * Maximums for allocations and loops.  It is not useful to change these --
+ * they are fixed by the deflate format.
+ */
+#define MAXBITS 15              /* maximum bits in a code */
+#define MAXLCODES 286           /* maximum number of literal/length codes */
+#define MAXDCODES 30            /* maximum number of distance codes */
+#define MAXCODES (MAXLCODES+MAXDCODES)  /* maximum codes lengths to read */
+#define FIXLCODES 288           /* number of fixed literal/length codes */
+
+/* input and output state */
+struct state {
+    /* output state */
+    unsigned char *out;         /* output buffer */
+    unsigned long outlen;       /* available space at out */
+    unsigned long outcnt;       /* bytes written to out so far */
+
+    /* input state */
+    const unsigned char *in;    /* input buffer */
+    unsigned long inlen;        /* available input at in */
+    unsigned long incnt;        /* bytes read so far */
+    int bitbuf;                 /* bit buffer */
+    int bitcnt;                 /* number of bits in bit buffer */
+
+    /* input limit error return state for bits() and decode() */
+    jmp_buf env;
+};
+
+/*
+ * Return need bits from the input stream.  This always leaves less than
+ * eight bits in the buffer.  bits() works properly for need == 0.
+ *
+ * Format notes:
+ *
+ * - Bits are stored in bytes from the least significant bit to the most
+ *   significant bit.  Therefore bits are dropped from the bottom of the bit
+ *   buffer, using shift right, and new bytes are appended to the top of the
+ *   bit buffer, using shift left.
+ */
+local int bits(struct state *s, int need)
+{
+    long val;           /* bit accumulator (can use up to 20 bits) */
+
+    /* load at least need bits into val */
+    val = s->bitbuf;
+    while (s->bitcnt < need) {
+        if (s->incnt == s->inlen)
+            longjmp(s->env, 1);         /* out of input */
+        val |= (long)(s->in[s->incnt++]) << s->bitcnt;  /* load eight bits */
+        s->bitcnt += 8;
+    }
+
+    /* drop need bits and update buffer, always zero to seven bits left */
+    s->bitbuf = (int)(val >> need);
+    s->bitcnt -= need;
+
+    /* return need bits, zeroing the bits above that */
+    return (int)(val & ((1L << need) - 1));
+}
+
+/*
+ * Process a stored block.
+ *
+ * Format notes:
+ *
+ * - After the two-bit stored block type (00), the stored block length and
+ *   stored bytes are byte-aligned for fast copying.  Therefore any leftover
+ *   bits in the byte that has the last bit of the type, as many as seven, are
+ *   discarded.  The value of the discarded bits are not defined and should not
+ *   be checked against any expectation.
+ *
+ * - The second inverted copy of the stored block length does not have to be
+ *   checked, but it's probably a good idea to do so anyway.
+ *
+ * - A stored block can have zero length.  This is sometimes used to byte-align
+ *   subsets of the compressed data for random access or partial recovery.
+ */
+local int stored(struct state *s)
+{
+    unsigned len;       /* length of stored block */
+
+    /* discard leftover bits from current byte (assumes s->bitcnt < 8) */
+    s->bitbuf = 0;
+    s->bitcnt = 0;
+
+    /* get length and check against its one's complement */
+    if (s->incnt + 4 > s->inlen)
+        return 2;                               /* not enough input */
+    len = s->in[s->incnt++];
+    len |= s->in[s->incnt++] << 8;
+    if (s->in[s->incnt++] != (~len & 0xff) ||
+        s->in[s->incnt++] != ((~len >> 8) & 0xff))
+        return -2;                              /* didn't match complement! */
+
+    /* copy len bytes from in to out */
+    if (s->incnt + len > s->inlen)
+        return 2;                               /* not enough input */
+    if (s->out != NIL) {
+        if (s->outcnt + len > s->outlen)
+            return 1;                           /* not enough output space */
+        while (len--)
+            s->out[s->outcnt++] = s->in[s->incnt++];
+    }
+    else {                                      /* just scanning */
+        s->outcnt += len;
+        s->incnt += len;
+    }
+
+    /* done with a valid stored block */
+    return 0;
+}
+
+/*
+ * Huffman code decoding tables.  count[1..MAXBITS] is the number of symbols of
+ * each length, which for a canonical code are stepped through in order.
+ * symbol[] are the symbol values in canonical order, where the number of
+ * entries is the sum of the counts in count[].  The decoding process can be
+ * seen in the function decode() below.
+ */
+struct huffman {
+    short *count;       /* number of symbols of each length */
+    short *symbol;      /* canonically ordered symbols */
+};
+
+/*
+ * Decode a code from the stream s using huffman table h.  Return the symbol or
+ * a negative value if there is an error.  If all of the lengths are zero, i.e.
+ * an empty code, or if the code is incomplete and an invalid code is received,
+ * then -10 is returned after reading MAXBITS bits.
+ *
+ * Format notes:
+ *
+ * - The codes as stored in the compressed data are bit-reversed relative to
+ *   a simple integer ordering of codes of the same lengths.  Hence below the
+ *   bits are pulled from the compressed data one at a time and used to
+ *   build the code value reversed from what is in the stream in order to
+ *   permit simple integer comparisons for decoding.  A table-based decoding
+ *   scheme (as used in zlib) does not need to do this reversal.
+ *
+ * - The first code for the shortest length is all zeros.  Subsequent codes of
+ *   the same length are simply integer increments of the previous code.  When
+ *   moving up a length, a zero bit is appended to the code.  For a complete
+ *   code, the last code of the longest length will be all ones.
+ *
+ * - Incomplete codes are handled by this decoder, since they are permitted
+ *   in the deflate format.  See the format notes for fixed() and dynamic().
+ */
+#ifdef SLOW
+local int decode(struct state *s, const struct huffman *h)
+{
+    int len;            /* current number of bits in code */
+    int code;           /* len bits being decoded */
+    int first;          /* first code of length len */
+    int count;          /* number of codes of length len */
+    int index;          /* index of first code of length len in symbol table */
+
+    code = first = index = 0;
+    for (len = 1; len <= MAXBITS; len++) {
+        code |= bits(s, 1);             /* get next bit */
+        count = h->count[len];
+        if (code - count < first)       /* if length len, return symbol */
+            return h->symbol[index + (code - first)];
+        index += count;                 /* else update for next length */
+        first += count;
+        first <<= 1;
+        code <<= 1;
+    }
+    return -10;                         /* ran out of codes */
+}
+
+/*
+ * A faster version of decode() for real applications of this code.   It's not
+ * as readable, but it makes puff() twice as fast.  And it only makes the code
+ * a few percent larger.
+ */
+#else /* !SLOW */
+local int decode(struct state *s, const struct huffman *h)
+{
+    int len;            /* current number of bits in code */
+    int code;           /* len bits being decoded */
+    int first;          /* first code of length len */
+    int count;          /* number of codes of length len */
+    int index;          /* index of first code of length len in symbol table */
+    int bitbuf;         /* bits from stream */
+    int left;           /* bits left in next or left to process */
+    short *next;        /* next number of codes */
+
+    bitbuf = s->bitbuf;
+    left = s->bitcnt;
+    code = first = index = 0;
+    len = 1;
+    next = h->count + 1;
+    while (1) {
+        while (left--) {
+            code |= bitbuf & 1;
+            bitbuf >>= 1;
+            count = *next++;
+            if (code - count < first) { /* if length len, return symbol */
+                s->bitbuf = bitbuf;
+                s->bitcnt = (s->bitcnt - len) & 7;
+                return h->symbol[index + (code - first)];
+            }
+            index += count;             /* else update for next length */
+            first += count;
+            first <<= 1;
+            code <<= 1;
+            len++;
+        }
+        left = (MAXBITS+1) - len;
+        if (left == 0)
+            break;
+        if (s->incnt == s->inlen)
+            longjmp(s->env, 1);         /* out of input */
+        bitbuf = s->in[s->incnt++];
+        if (left > 8)
+            left = 8;
+    }
+    return -10;                         /* ran out of codes */
+}
+#endif /* SLOW */
+
+/*
+ * Given the list of code lengths length[0..n-1] representing a canonical
+ * Huffman code for n symbols, construct the tables required to decode those
+ * codes.  Those tables are the number of codes of each length, and the symbols
+ * sorted by length, retaining their original order within each length.  The
+ * return value is zero for a complete code set, negative for an over-
+ * subscribed code set, and positive for an incomplete code set.  The tables
+ * can be used if the return value is zero or positive, but they cannot be used
+ * if the return value is negative.  If the return value is zero, it is not
+ * possible for decode() using that table to return an error--any stream of
+ * enough bits will resolve to a symbol.  If the return value is positive, then
+ * it is possible for decode() using that table to return an error for received
+ * codes past the end of the incomplete lengths.
+ *
+ * Not used by decode(), but used for error checking, h->count[0] is the number
+ * of the n symbols not in the code.  So n - h->count[0] is the number of
+ * codes.  This is useful for checking for incomplete codes that have more than
+ * one symbol, which is an error in a dynamic block.
+ *
+ * Assumption: for all i in 0..n-1, 0 <= length[i] <= MAXBITS
+ * This is assured by the construction of the length arrays in dynamic() and
+ * fixed() and is not verified by construct().
+ *
+ * Format notes:
+ *
+ * - Permitted and expected examples of incomplete codes are one of the fixed
+ *   codes and any code with a single symbol which in deflate is coded as one
+ *   bit instead of zero bits.  See the format notes for fixed() and dynamic().
+ *
+ * - Within a given code length, the symbols are kept in ascending order for
+ *   the code bits definition.
+ */
+local int construct(struct huffman *h, const short *length, int n)
+{
+    int symbol;         /* current symbol when stepping through length[] */
+    int len;            /* current length when stepping through h->count[] */
+    int left;           /* number of possible codes left of current length */
+    short offs[MAXBITS+1];      /* offsets in symbol table for each length */
+
+    /* count number of codes of each length */
+    for (len = 0; len <= MAXBITS; len++)
+        h->count[len] = 0;
+    for (symbol = 0; symbol < n; symbol++)
+        (h->count[length[symbol]])++;   /* assumes lengths are within bounds */
+    if (h->count[0] == n)               /* no codes! */
+        return 0;                       /* complete, but decode() will fail */
+
+    /* check for an over-subscribed or incomplete set of lengths */
+    left = 1;                           /* one possible code of zero length */
+    for (len = 1; len <= MAXBITS; len++) {
+        left <<= 1;                     /* one more bit, double codes left */
+        left -= h->count[len];          /* deduct count from possible codes */
+        if (left < 0)
+            return left;                /* over-subscribed--return negative */
+    }                                   /* left > 0 means incomplete */
+
+    /* generate offsets into symbol table for each length for sorting */
+    offs[1] = 0;
+    for (len = 1; len < MAXBITS; len++)
+        offs[len + 1] = offs[len] + h->count[len];
+
+    /*
+     * put symbols in table sorted by length, by symbol order within each
+     * length
+     */
+    for (symbol = 0; symbol < n; symbol++)
+        if (length[symbol] != 0)
+            h->symbol[offs[length[symbol]]++] = symbol;
+
+    /* return zero for complete set, positive for incomplete set */
+    return left;
+}
+
+/*
+ * Decode literal/length and distance codes until an end-of-block code.
+ *
+ * Format notes:
+ *
+ * - Compressed data that is after the block type if fixed or after the code
+ *   description if dynamic is a combination of literals and length/distance
+ *   pairs terminated by and end-of-block code.  Literals are simply Huffman
+ *   coded bytes.  A length/distance pair is a coded length followed by a
+ *   coded distance to represent a string that occurs earlier in the
+ *   uncompressed data that occurs again at the current location.
+ *
+ * - Literals, lengths, and the end-of-block code are combined into a single
+ *   code of up to 286 symbols.  They are 256 literals (0..255), 29 length
+ *   symbols (257..285), and the end-of-block symbol (256).
+ *
+ * - There are 256 possible lengths (3..258), and so 29 symbols are not enough
+ *   to represent all of those.  Lengths 3..10 and 258 are in fact represented
+ *   by just a length symbol.  Lengths 11..257 are represented as a symbol and
+ *   some number of extra bits that are added as an integer to the base length
+ *   of the length symbol.  The number of extra bits is determined by the base
+ *   length symbol.  These are in the static arrays below, lens[] for the base
+ *   lengths and lext[] for the corresponding number of extra bits.
+ *
+ * - The reason that 258 gets its own symbol is that the longest length is used
+ *   often in highly redundant files.  Note that 258 can also be coded as the
+ *   base value 227 plus the maximum extra value of 31.  While a good deflate
+ *   should never do this, it is not an error, and should be decoded properly.
+ *
+ * - If a length is decoded, including its extra bits if any, then it is
+ *   followed a distance code.  There are up to 30 distance symbols.  Again
+ *   there are many more possible distances (1..32768), so extra bits are added
+ *   to a base value represented by the symbol.  The distances 1..4 get their
+ *   own symbol, but the rest require extra bits.  The base distances and
+ *   corresponding number of extra bits are below in the static arrays dist[]
+ *   and dext[].
+ *
+ * - Literal bytes are simply written to the output.  A length/distance pair is
+ *   an instruction to copy previously uncompressed bytes to the output.  The
+ *   copy is from distance bytes back in the output stream, copying for length
+ *   bytes.
+ *
+ * - Distances pointing before the beginning of the output data are not
+ *   permitted.
+ *
+ * - Overlapped copies, where the length is greater than the distance, are
+ *   allowed and common.  For example, a distance of one and a length of 258
+ *   simply copies the last byte 258 times.  A distance of four and a length of
+ *   twelve copies the last four bytes three times.  A simple forward copy
+ *   ignoring whether the length is greater than the distance or not implements
+ *   this correctly.  You should not use memcpy() since its behavior is not
+ *   defined for overlapped arrays.  You should not use memmove() or bcopy()
+ *   since though their behavior -is- defined for overlapping arrays, it is
+ *   defined to do the wrong thing in this case.
+ */
+local int codes(struct state *s,
+                const struct huffman *lencode,
+                const struct huffman *distcode)
+{
+    int symbol;         /* decoded symbol */
+    int len;            /* length for copy */
+    unsigned dist;      /* distance for copy */
+    static const short lens[29] = { /* Size base for length codes 257..285 */
+        3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
+        35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258};
+    static const short lext[29] = { /* Extra bits for length codes 257..285 */
+        0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
+        3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0};
+    static const short dists[30] = { /* Offset base for distance codes 0..29 */
+        1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
+        257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
+        8193, 12289, 16385, 24577};
+    static const short dext[30] = { /* Extra bits for distance codes 0..29 */
+        0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
+        7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
+        12, 12, 13, 13};
+
+    /* decode literals and length/distance pairs */
+    do {
+        symbol = decode(s, lencode);
+        if (symbol < 0)
+            return symbol;              /* invalid symbol */
+        if (symbol < 256) {             /* literal: symbol is the byte */
+            /* write out the literal */
+            if (s->out != NIL) {
+                if (s->outcnt == s->outlen)
+                    return 1;
+                s->out[s->outcnt] = symbol;
+            }
+            s->outcnt++;
+        }
+        else if (symbol > 256) {        /* length */
+            /* get and compute length */
+            symbol -= 257;
+            if (symbol >= 29)
+                return -10;             /* invalid fixed code */
+            len = lens[symbol] + bits(s, lext[symbol]);
+
+            /* get and check distance */
+            symbol = decode(s, distcode);
+            if (symbol < 0)
+                return symbol;          /* invalid symbol */
+            dist = dists[symbol] + bits(s, dext[symbol]);
+#ifndef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
+            if (dist > s->outcnt)
+                return -11;     /* distance too far back */
+#endif
+
+            /* copy length bytes from distance bytes back */
+            if (s->out != NIL) {
+                if (s->outcnt + len > s->outlen)
+                    return 1;
+                while (len--) {
+                    s->out[s->outcnt] =
+#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
+                        dist > s->outcnt ?
+                            0 :
+#endif
+                            s->out[s->outcnt - dist];
+                    s->outcnt++;
+                }
+            }
+            else
+                s->outcnt += len;
+        }
+    } while (symbol != 256);            /* end of block symbol */
+
+    /* done with a valid fixed or dynamic block */
+    return 0;
+}
+
+/*
+ * Process a fixed codes block.
+ *
+ * Format notes:
+ *
+ * - This block type can be useful for compressing small amounts of data for
+ *   which the size of the code descriptions in a dynamic block exceeds the
+ *   benefit of custom codes for that block.  For fixed codes, no bits are
+ *   spent on code descriptions.  Instead the code lengths for literal/length
+ *   codes and distance codes are fixed.  The specific lengths for each symbol
+ *   can be seen in the "for" loops below.
+ *
+ * - The literal/length code is complete, but has two symbols that are invalid
+ *   and should result in an error if received.  This cannot be implemented
+ *   simply as an incomplete code since those two symbols are in the "middle"
+ *   of the code.  They are eight bits long and the longest literal/length\
+ *   code is nine bits.  Therefore the code must be constructed with those
+ *   symbols, and the invalid symbols must be detected after decoding.
+ *
+ * - The fixed distance codes also have two invalid symbols that should result
+ *   in an error if received.  Since all of the distance codes are the same
+ *   length, this can be implemented as an incomplete code.  Then the invalid
+ *   codes are detected while decoding.
+ */
+local int fixed(struct state *s)
+{
+    static int virgin = 1;
+    static short lencnt[MAXBITS+1], lensym[FIXLCODES];
+    static short distcnt[MAXBITS+1], distsym[MAXDCODES];
+    static struct huffman lencode, distcode;
+
+    /* build fixed huffman tables if first call (may not be thread safe) */
+    if (virgin) {
+        int symbol;
+        short lengths[FIXLCODES];
+
+        /* construct lencode and distcode */
+        lencode.count = lencnt;
+        lencode.symbol = lensym;
+        distcode.count = distcnt;
+        distcode.symbol = distsym;
+
+        /* literal/length table */
+        for (symbol = 0; symbol < 144; symbol++)
+            lengths[symbol] = 8;
+        for (; symbol < 256; symbol++)
+            lengths[symbol] = 9;
+        for (; symbol < 280; symbol++)
+            lengths[symbol] = 7;
+        for (; symbol < FIXLCODES; symbol++)
+            lengths[symbol] = 8;
+        construct(&lencode, lengths, FIXLCODES);
+
+        /* distance table */
+        for (symbol = 0; symbol < MAXDCODES; symbol++)
+            lengths[symbol] = 5;
+        construct(&distcode, lengths, MAXDCODES);
+
+        /* do this just once */
+        virgin = 0;
+    }
+
+    /* decode data until end-of-block code */
+    return codes(s, &lencode, &distcode);
+}
+
+/*
+ * Process a dynamic codes block.
+ *
+ * Format notes:
+ *
+ * - A dynamic block starts with a description of the literal/length and
+ *   distance codes for that block.  New dynamic blocks allow the compressor to
+ *   rapidly adapt to changing data with new codes optimized for that data.
+ *
+ * - The codes used by the deflate format are "canonical", which means that
+ *   the actual bits of the codes are generated in an unambiguous way simply
+ *   from the number of bits in each code.  Therefore the code descriptions
+ *   are simply a list of code lengths for each symbol.
+ *
+ * - The code lengths are stored in order for the symbols, so lengths are
+ *   provided for each of the literal/length symbols, and for each of the
+ *   distance symbols.
+ *
+ * - If a symbol is not used in the block, this is represented by a zero as
+ *   as the code length.  This does not mean a zero-length code, but rather
+ *   that no code should be created for this symbol.  There is no way in the
+ *   deflate format to represent a zero-length code.
+ *
+ * - The maximum number of bits in a code is 15, so the possible lengths for
+ *   any code are 1..15.
+ *
+ * - The fact that a length of zero is not permitted for a code has an
+ *   interesting consequence.  Normally if only one symbol is used for a given
+ *   code, then in fact that code could be represented with zero bits.  However
+ *   in deflate, that code has to be at least one bit.  So for example, if
+ *   only a single distance base symbol appears in a block, then it will be
+ *   represented by a single code of length one, in particular one 0 bit.  This
+ *   is an incomplete code, since if a 1 bit is received, it has no meaning,
+ *   and should result in an error.  So incomplete distance codes of one symbol
+ *   should be permitted, and the receipt of invalid codes should be handled.
+ *
+ * - It is also possible to have a single literal/length code, but that code
+ *   must be the end-of-block code, since every dynamic block has one.  This
+ *   is not the most efficient way to create an empty block (an empty fixed
+ *   block is fewer bits), but it is allowed by the format.  So incomplete
+ *   literal/length codes of one symbol should also be permitted.
+ *
+ * - If there are only literal codes and no lengths, then there are no distance
+ *   codes.  This is represented by one distance code with zero bits.
+ *
+ * - The list of up to 286 length/literal lengths and up to 30 distance lengths
+ *   are themselves compressed using Huffman codes and run-length encoding.  In
+ *   the list of code lengths, a 0 symbol means no code, a 1..15 symbol means
+ *   that length, and the symbols 16, 17, and 18 are run-length instructions.
+ *   Each of 16, 17, and 18 are follwed by extra bits to define the length of
+ *   the run.  16 copies the last length 3 to 6 times.  17 represents 3 to 10
+ *   zero lengths, and 18 represents 11 to 138 zero lengths.  Unused symbols
+ *   are common, hence the special coding for zero lengths.
+ *
+ * - The symbols for 0..18 are Huffman coded, and so that code must be
+ *   described first.  This is simply a sequence of up to 19 three-bit values
+ *   representing no code (0) or the code length for that symbol (1..7).
+ *
+ * - A dynamic block starts with three fixed-size counts from which is computed
+ *   the number of literal/length code lengths, the number of distance code
+ *   lengths, and the number of code length code lengths (ok, you come up with
+ *   a better name!) in the code descriptions.  For the literal/length and
+ *   distance codes, lengths after those provided are considered zero, i.e. no
+ *   code.  The code length code lengths are received in a permuted order (see
+ *   the order[] array below) to make a short code length code length list more
+ *   likely.  As it turns out, very short and very long codes are less likely
+ *   to be seen in a dynamic code description, hence what may appear initially
+ *   to be a peculiar ordering.
+ *
+ * - Given the number of literal/length code lengths (nlen) and distance code
+ *   lengths (ndist), then they are treated as one long list of nlen + ndist
+ *   code lengths.  Therefore run-length coding can and often does cross the
+ *   boundary between the two sets of lengths.
+ *
+ * - So to summarize, the code description at the start of a dynamic block is
+ *   three counts for the number of code lengths for the literal/length codes,
+ *   the distance codes, and the code length codes.  This is followed by the
+ *   code length code lengths, three bits each.  This is used to construct the
+ *   code length code which is used to read the remainder of the lengths.  Then
+ *   the literal/length code lengths and distance lengths are read as a single
+ *   set of lengths using the code length codes.  Codes are constructed from
+ *   the resulting two sets of lengths, and then finally you can start
+ *   decoding actual compressed data in the block.
+ *
+ * - For reference, a "typical" size for the code description in a dynamic
+ *   block is around 80 bytes.
+ */
+local int dynamic(struct state *s)
+{
+    int nlen, ndist, ncode;             /* number of lengths in descriptor */
+    int index;                          /* index of lengths[] */
+    int err;                            /* construct() return value */
+    short lengths[MAXCODES];            /* descriptor code lengths */
+    short lencnt[MAXBITS+1], lensym[MAXLCODES];         /* lencode memory */
+    short distcnt[MAXBITS+1], distsym[MAXDCODES];       /* distcode memory */
+    struct huffman lencode, distcode;   /* length and distance codes */
+    static const short order[19] =      /* permutation of code length codes */
+        {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
+
+    /* construct lencode and distcode */
+    lencode.count = lencnt;
+    lencode.symbol = lensym;
+    distcode.count = distcnt;
+    distcode.symbol = distsym;
+
+    /* get number of lengths in each table, check lengths */
+    nlen = bits(s, 5) + 257;
+    ndist = bits(s, 5) + 1;
+    ncode = bits(s, 4) + 4;
+    if (nlen > MAXLCODES || ndist > MAXDCODES)
+        return -3;                      /* bad counts */
+
+    /* read code length code lengths (really), missing lengths are zero */
+    for (index = 0; index < ncode; index++)
+        lengths[order[index]] = bits(s, 3);
+    for (; index < 19; index++)
+        lengths[order[index]] = 0;
+
+    /* build huffman table for code lengths codes (use lencode temporarily) */
+    err = construct(&lencode, lengths, 19);
+    if (err != 0)               /* require complete code set here */
+        return -4;
+
+    /* read length/literal and distance code length tables */
+    index = 0;
+    while (index < nlen + ndist) {
+        int symbol;             /* decoded value */
+        int len;                /* last length to repeat */
+
+        symbol = decode(s, &lencode);
+        if (symbol < 0)
+            return symbol;          /* invalid symbol */
+        if (symbol < 16)                /* length in 0..15 */
+            lengths[index++] = symbol;
+        else {                          /* repeat instruction */
+            len = 0;                    /* assume repeating zeros */
+            if (symbol == 16) {         /* repeat last length 3..6 times */
+                if (index == 0)
+                    return -5;          /* no last length! */
+                len = lengths[index - 1];       /* last length */
+                symbol = 3 + bits(s, 2);
+            }
+            else if (symbol == 17)      /* repeat zero 3..10 times */
+                symbol = 3 + bits(s, 3);
+            else                        /* == 18, repeat zero 11..138 times */
+                symbol = 11 + bits(s, 7);
+            if (index + symbol > nlen + ndist)
+                return -6;              /* too many lengths! */
+            while (symbol--)            /* repeat last or zero symbol times */
+                lengths[index++] = len;
+        }
+    }
+
+    /* check for end-of-block code -- there better be one! */
+    if (lengths[256] == 0)
+        return -9;
+
+    /* build huffman table for literal/length codes */
+    err = construct(&lencode, lengths, nlen);
+    if (err && (err < 0 || nlen != lencode.count[0] + lencode.count[1]))
+        return -7;      /* incomplete code ok only for single length 1 code */
+
+    /* build huffman table for distance codes */
+    err = construct(&distcode, lengths + nlen, ndist);
+    if (err && (err < 0 || ndist != distcode.count[0] + distcode.count[1]))
+        return -8;      /* incomplete code ok only for single length 1 code */
+
+    /* decode data until end-of-block code */
+    return codes(s, &lencode, &distcode);
+}
+
+/*
+ * Inflate source to dest.  On return, destlen and sourcelen are updated to the
+ * size of the uncompressed data and the size of the deflate data respectively.
+ * On success, the return value of puff() is zero.  If there is an error in the
+ * source data, i.e. it is not in the deflate format, then a negative value is
+ * returned.  If there is not enough input available or there is not enough
+ * output space, then a positive error is returned.  In that case, destlen and
+ * sourcelen are not updated to facilitate retrying from the beginning with the
+ * provision of more input data or more output space.  In the case of invalid
+ * inflate data (a negative error), the dest and source pointers are updated to
+ * facilitate the debugging of deflators.
+ *
+ * puff() also has a mode to determine the size of the uncompressed output with
+ * no output written.  For this dest must be (unsigned char *)0.  In this case,
+ * the input value of *destlen is ignored, and on return *destlen is set to the
+ * size of the uncompressed output.
+ *
+ * The return codes are:
+ *
+ *   2:  available inflate data did not terminate
+ *   1:  output space exhausted before completing inflate
+ *   0:  successful inflate
+ *  -1:  invalid block type (type == 3)
+ *  -2:  stored block length did not match one's complement
+ *  -3:  dynamic block code description: too many length or distance codes
+ *  -4:  dynamic block code description: code lengths codes incomplete
+ *  -5:  dynamic block code description: repeat lengths with no first length
+ *  -6:  dynamic block code description: repeat more than specified lengths
+ *  -7:  dynamic block code description: invalid literal/length code lengths
+ *  -8:  dynamic block code description: invalid distance code lengths
+ *  -9:  dynamic block code description: missing end-of-block code
+ * -10:  invalid literal/length or distance code in fixed or dynamic block
+ * -11:  distance is too far back in fixed or dynamic block
+ *
+ * Format notes:
+ *
+ * - Three bits are read for each block to determine the kind of block and
+ *   whether or not it is the last block.  Then the block is decoded and the
+ *   process repeated if it was not the last block.
+ *
+ * - The leftover bits in the last byte of the deflate data after the last
+ *   block (if it was a fixed or dynamic block) are undefined and have no
+ *   expected values to check.
+ */
+int puff(unsigned char *dest,           /* pointer to destination pointer */
+         unsigned long *destlen,        /* amount of output space */
+         const unsigned char *source,   /* pointer to source data pointer */
+         unsigned long *sourcelen)      /* amount of input available */
+{
+    struct state s;             /* input/output state */
+    int last, type;             /* block information */
+    int err;                    /* return value */
+
+    /* initialize output state */
+    s.out = dest;
+    s.outlen = *destlen;                /* ignored if dest is NIL */
+    s.outcnt = 0;
+
+    /* initialize input state */
+    s.in = source;
+    s.inlen = *sourcelen;
+    s.incnt = 0;
+    s.bitbuf = 0;
+    s.bitcnt = 0;
+
+    /* return if bits() or decode() tries to read past available input */
+    if (setjmp(s.env) != 0)             /* if came back here via longjmp() */
+        err = 2;                        /* then skip do-loop, return error */
+    else {
+        /* process blocks until last block or error */
+        do {
+            last = bits(&s, 1);         /* one if last block */
+            type = bits(&s, 2);         /* block type 0..3 */
+            err = type == 0 ?
+                    stored(&s) :
+                    (type == 1 ?
+                        fixed(&s) :
+                        (type == 2 ?
+                            dynamic(&s) :
+                            -1));       /* type == 3, invalid */
+            if (err != 0)
+                break;                  /* return with error */
+        } while (!last);
+    }
+
+    /* update the lengths and return */
+    if (err <= 0) {
+        *destlen = s.outcnt;
+        *sourcelen = s.incnt;
+    }
+    return err;
+}
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/puff/puff.h b/Engine/lib/assimp/contrib/zlib/contrib/puff/puff.h
new file mode 100644
index 000000000..e23a24543
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/puff/puff.h
@@ -0,0 +1,35 @@
+/* puff.h
+  Copyright (C) 2002-2013 Mark Adler, all rights reserved
+  version 2.3, 21 Jan 2013
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the author be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Mark Adler    madler@alumni.caltech.edu
+ */
+
+
+/*
+ * See puff.c for purpose and usage.
+ */
+#ifndef NIL
+#  define NIL ((unsigned char *)0)      /* for no output option */
+#endif
+
+int puff(unsigned char *dest,           /* pointer to destination pointer */
+         unsigned long *destlen,        /* amount of output space */
+         const unsigned char *source,   /* pointer to source data pointer */
+         unsigned long *sourcelen);     /* amount of input available */
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/puff/pufftest.c b/Engine/lib/assimp/contrib/zlib/contrib/puff/pufftest.c
new file mode 100644
index 000000000..776481488
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/puff/pufftest.c
@@ -0,0 +1,165 @@
+/*
+ * pufftest.c
+ * Copyright (C) 2002-2013 Mark Adler
+ * For conditions of distribution and use, see copyright notice in puff.h
+ * version 2.3, 21 Jan 2013
+ */
+
+/* Example of how to use puff().
+
+   Usage: puff [-w] [-f] [-nnn] file
+          ... | puff [-w] [-f] [-nnn]
+
+   where file is the input file with deflate data, nnn is the number of bytes
+   of input to skip before inflating (e.g. to skip a zlib or gzip header), and
+   -w is used to write the decompressed data to stdout.  -f is for coverage
+   testing, and causes pufftest to fail with not enough output space (-f does
+   a write like -w, so -w is not required). */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "puff.h"
+
+#if defined(MSDOS) || defined(OS2) || defined(WIN32) || defined(__CYGWIN__)
+#  include <fcntl.h>
+#  include <io.h>
+#  define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
+#else
+#  define SET_BINARY_MODE(file)
+#endif
+
+#define local static
+
+/* Return size times approximately the cube root of 2, keeping the result as 1,
+   3, or 5 times a power of 2 -- the result is always > size, until the result
+   is the maximum value of an unsigned long, where it remains.  This is useful
+   to keep reallocations less than ~33% over the actual data. */
+local size_t bythirds(size_t size)
+{
+    int n;
+    size_t m;
+
+    m = size;
+    for (n = 0; m; n++)
+        m >>= 1;
+    if (n < 3)
+        return size + 1;
+    n -= 3;
+    m = size >> n;
+    m += m == 6 ? 2 : 1;
+    m <<= n;
+    return m > size ? m : (size_t)(-1);
+}
+
+/* Read the input file *name, or stdin if name is NULL, into allocated memory.
+   Reallocate to larger buffers until the entire file is read in.  Return a
+   pointer to the allocated data, or NULL if there was a memory allocation
+   failure.  *len is the number of bytes of data read from the input file (even
+   if load() returns NULL).  If the input file was empty or could not be opened
+   or read, *len is zero. */
+local void *load(const char *name, size_t *len)
+{
+    size_t size;
+    void *buf, *swap;
+    FILE *in;
+
+    *len = 0;
+    buf = malloc(size = 4096);
+    if (buf == NULL)
+        return NULL;
+    in = name == NULL ? stdin : fopen(name, "rb");
+    if (in != NULL) {
+        for (;;) {
+            *len += fread((char *)buf + *len, 1, size - *len, in);
+            if (*len < size) break;
+            size = bythirds(size);
+            if (size == *len || (swap = realloc(buf, size)) == NULL) {
+                free(buf);
+                buf = NULL;
+                break;
+            }
+            buf = swap;
+        }
+        fclose(in);
+    }
+    return buf;
+}
+
+int main(int argc, char **argv)
+{
+    int ret, put = 0, fail = 0;
+    unsigned skip = 0;
+    char *arg, *name = NULL;
+    unsigned char *source = NULL, *dest;
+    size_t len = 0;
+    unsigned long sourcelen, destlen;
+
+    /* process arguments */
+    while (arg = *++argv, --argc)
+        if (arg[0] == '-') {
+            if (arg[1] == 'w' && arg[2] == 0)
+                put = 1;
+            else if (arg[1] == 'f' && arg[2] == 0)
+                fail = 1, put = 1;
+            else if (arg[1] >= '0' && arg[1] <= '9')
+                skip = (unsigned)atoi(arg + 1);
+            else {
+                fprintf(stderr, "invalid option %s\n", arg);
+                return 3;
+            }
+        }
+        else if (name != NULL) {
+            fprintf(stderr, "only one file name allowed\n");
+            return 3;
+        }
+        else
+            name = arg;
+    source = load(name, &len);
+    if (source == NULL) {
+        fprintf(stderr, "memory allocation failure\n");
+        return 4;
+    }
+    if (len == 0) {
+        fprintf(stderr, "could not read %s, or it was empty\n",
+                name == NULL ? "<stdin>" : name);
+        free(source);
+        return 3;
+    }
+    if (skip >= len) {
+        fprintf(stderr, "skip request of %d leaves no input\n", skip);
+        free(source);
+        return 3;
+    }
+
+    /* test inflate data with offset skip */
+    len -= skip;
+    sourcelen = (unsigned long)len;
+    ret = puff(NIL, &destlen, source + skip, &sourcelen);
+    if (ret)
+        fprintf(stderr, "puff() failed with return code %d\n", ret);
+    else {
+        fprintf(stderr, "puff() succeeded uncompressing %lu bytes\n", destlen);
+        if (sourcelen < len) fprintf(stderr, "%lu compressed bytes unused\n",
+                                     len - sourcelen);
+    }
+
+    /* if requested, inflate again and write decompressd data to stdout */
+    if (put && ret == 0) {
+        if (fail)
+            destlen >>= 1;
+        dest = malloc(destlen);
+        if (dest == NULL) {
+            fprintf(stderr, "memory allocation failure\n");
+            free(source);
+            return 4;
+        }
+        puff(dest, &destlen, source + skip, &sourcelen);
+        SET_BINARY_MODE(stdout);
+        fwrite(dest, 1, destlen, stdout);
+        free(dest);
+    }
+
+    /* clean up */
+    free(source);
+    return ret;
+}
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/puff/zeros.raw b/Engine/lib/assimp/contrib/zlib/contrib/puff/zeros.raw
new file mode 100644
index 0000000000000000000000000000000000000000..0a90e76b300205a44a0ecbf613e64aaaef2e51e7
GIT binary patch
literal 2517
zcmYdFkYHV$AkxzmXu#!mP=i#?5{3o^3jqcYc(h*%Opg+yAut*OqaiT#LSPd+y9&tF
zP5<`ixi4UXdB8xJfs^6ee;AkH?VUytyFsD;HLIJ(gg5bUnNh}Q2#kinXb22!2pr%5
E0JRq+;s5{u

literal 0
HcmV?d00001

diff --git a/Engine/lib/assimp/contrib/zlib/contrib/testzlib/testzlib.c b/Engine/lib/assimp/contrib/zlib/contrib/testzlib/testzlib.c
new file mode 100644
index 000000000..8626c92ad
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/testzlib/testzlib.c
@@ -0,0 +1,275 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <windows.h>
+
+#include "zlib.h"
+
+
+void MyDoMinus64(LARGE_INTEGER *R,LARGE_INTEGER A,LARGE_INTEGER B)
+{
+    R->HighPart = A.HighPart - B.HighPart;
+    if (A.LowPart >= B.LowPart)
+        R->LowPart = A.LowPart - B.LowPart;
+    else
+    {
+        R->LowPart = A.LowPart - B.LowPart;
+        R->HighPart --;
+    }
+}
+
+#ifdef _M_X64
+// see http://msdn2.microsoft.com/library/twchhe95(en-us,vs.80).aspx for __rdtsc
+unsigned __int64 __rdtsc(void);
+void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
+{
+ //   printf("rdtsc = %I64x\n",__rdtsc());
+   pbeginTime64->QuadPart=__rdtsc();
+}
+
+LARGE_INTEGER GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
+{
+    LARGE_INTEGER LIres;
+    unsigned _int64 res=__rdtsc()-((unsigned _int64)(beginTime64.QuadPart));
+    LIres.QuadPart=res;
+   // printf("rdtsc = %I64x\n",__rdtsc());
+    return LIres;
+}
+#else
+#ifdef _M_IX86
+void myGetRDTSC32(LARGE_INTEGER * pbeginTime64)
+{
+    DWORD dwEdx,dwEax;
+    _asm
+    {
+        rdtsc
+        mov dwEax,eax
+        mov dwEdx,edx
+    }
+    pbeginTime64->LowPart=dwEax;
+    pbeginTime64->HighPart=dwEdx;
+}
+
+void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
+{
+    myGetRDTSC32(pbeginTime64);
+}
+
+LARGE_INTEGER GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
+{
+    LARGE_INTEGER LIres,endTime64;
+    myGetRDTSC32(&endTime64);
+
+    LIres.LowPart=LIres.HighPart=0;
+    MyDoMinus64(&LIres,endTime64,beginTime64);
+    return LIres;
+}
+#else
+void myGetRDTSC32(LARGE_INTEGER * pbeginTime64)
+{
+}
+
+void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
+{
+}
+
+LARGE_INTEGER GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
+{
+    LARGE_INTEGER lr;
+    lr.QuadPart=0;
+    return lr;
+}
+#endif
+#endif
+
+void BeginCountPerfCounter(LARGE_INTEGER * pbeginTime64,BOOL fComputeTimeQueryPerf)
+{
+    if ((!fComputeTimeQueryPerf) || (!QueryPerformanceCounter(pbeginTime64)))
+    {
+        pbeginTime64->LowPart = GetTickCount();
+        pbeginTime64->HighPart = 0;
+    }
+}
+
+DWORD GetMsecSincePerfCounter(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
+{
+    LARGE_INTEGER endTime64,ticksPerSecond,ticks;
+    DWORDLONG ticksShifted,tickSecShifted;
+    DWORD dwLog=16+0;
+    DWORD dwRet;
+    if ((!fComputeTimeQueryPerf) || (!QueryPerformanceCounter(&endTime64)))
+        dwRet = (GetTickCount() - beginTime64.LowPart)*1;
+    else
+    {
+        MyDoMinus64(&ticks,endTime64,beginTime64);
+        QueryPerformanceFrequency(&ticksPerSecond);
+
+
+        {
+            ticksShifted = Int64ShrlMod32(*(DWORDLONG*)&ticks,dwLog);
+            tickSecShifted = Int64ShrlMod32(*(DWORDLONG*)&ticksPerSecond,dwLog);
+
+        }
+
+        dwRet = (DWORD)((((DWORD)ticksShifted)*1000)/(DWORD)(tickSecShifted));
+        dwRet *=1;
+    }
+    return dwRet;
+}
+
+int ReadFileMemory(const char* filename,long* plFileSize,unsigned char** pFilePtr)
+{
+    FILE* stream;
+    unsigned char* ptr;
+    int retVal=1;
+    stream=fopen(filename, "rb");
+    if (stream==NULL)
+        return 0;
+
+    fseek(stream,0,SEEK_END);
+
+    *plFileSize=ftell(stream);
+    fseek(stream,0,SEEK_SET);
+    ptr=malloc((*plFileSize)+1);
+    if (ptr==NULL)
+        retVal=0;
+    else
+    {
+        if (fread(ptr, 1, *plFileSize,stream) != (*plFileSize))
+            retVal=0;
+    }
+    fclose(stream);
+    *pFilePtr=ptr;
+    return retVal;
+}
+
+int main(int argc, char *argv[])
+{
+    int BlockSizeCompress=0x8000;
+    int BlockSizeUncompress=0x8000;
+    int cprLevel=Z_DEFAULT_COMPRESSION ;
+    long lFileSize;
+    unsigned char* FilePtr;
+    long lBufferSizeCpr;
+    long lBufferSizeUncpr;
+    long lCompressedSize=0;
+    unsigned char* CprPtr;
+    unsigned char* UncprPtr;
+    long lSizeCpr,lSizeUncpr;
+    DWORD dwGetTick,dwMsecQP;
+    LARGE_INTEGER li_qp,li_rdtsc,dwResRdtsc;
+
+    if (argc<=1)
+    {
+        printf("run TestZlib <File> [BlockSizeCompress] [BlockSizeUncompress] [compres. level]\n");
+        return 0;
+    }
+
+    if (ReadFileMemory(argv[1],&lFileSize,&FilePtr)==0)
+    {
+        printf("error reading %s\n",argv[1]);
+        return 1;
+    }
+    else printf("file %s read, %u bytes\n",argv[1],lFileSize);
+
+    if (argc>=3)
+        BlockSizeCompress=atol(argv[2]);
+
+    if (argc>=4)
+        BlockSizeUncompress=atol(argv[3]);
+
+    if (argc>=5)
+        cprLevel=(int)atol(argv[4]);
+
+    lBufferSizeCpr = lFileSize + (lFileSize/0x10) + 0x200;
+    lBufferSizeUncpr = lBufferSizeCpr;
+
+    CprPtr=(unsigned char*)malloc(lBufferSizeCpr + BlockSizeCompress);
+
+    BeginCountPerfCounter(&li_qp,TRUE);
+    dwGetTick=GetTickCount();
+    BeginCountRdtsc(&li_rdtsc);
+    {
+        z_stream zcpr;
+        int ret=Z_OK;
+        long lOrigToDo = lFileSize;
+        long lOrigDone = 0;
+        int step=0;
+        memset(&zcpr,0,sizeof(z_stream));
+        deflateInit(&zcpr,cprLevel);
+
+        zcpr.next_in = FilePtr;
+        zcpr.next_out = CprPtr;
+
+
+        do
+        {
+            long all_read_before = zcpr.total_in;
+            zcpr.avail_in = min(lOrigToDo,BlockSizeCompress);
+            zcpr.avail_out = BlockSizeCompress;
+            ret=deflate(&zcpr,(zcpr.avail_in==lOrigToDo) ? Z_FINISH : Z_SYNC_FLUSH);
+            lOrigDone += (zcpr.total_in-all_read_before);
+            lOrigToDo -= (zcpr.total_in-all_read_before);
+            step++;
+        } while (ret==Z_OK);
+
+        lSizeCpr=zcpr.total_out;
+        deflateEnd(&zcpr);
+        dwGetTick=GetTickCount()-dwGetTick;
+        dwMsecQP=GetMsecSincePerfCounter(li_qp,TRUE);
+        dwResRdtsc=GetResRdtsc(li_rdtsc,TRUE);
+        printf("total compress size = %u, in %u step\n",lSizeCpr,step);
+        printf("time = %u msec = %f sec\n",dwGetTick,dwGetTick/(double)1000.);
+        printf("defcpr time QP = %u msec = %f sec\n",dwMsecQP,dwMsecQP/(double)1000.);
+        printf("defcpr result rdtsc = %I64x\n\n",dwResRdtsc.QuadPart);
+    }
+
+    CprPtr=(unsigned char*)realloc(CprPtr,lSizeCpr);
+    UncprPtr=(unsigned char*)malloc(lBufferSizeUncpr + BlockSizeUncompress);
+
+    BeginCountPerfCounter(&li_qp,TRUE);
+    dwGetTick=GetTickCount();
+    BeginCountRdtsc(&li_rdtsc);
+    {
+        z_stream zcpr;
+        int ret=Z_OK;
+        long lOrigToDo = lSizeCpr;
+        long lOrigDone = 0;
+        int step=0;
+        memset(&zcpr,0,sizeof(z_stream));
+        inflateInit(&zcpr);
+
+        zcpr.next_in = CprPtr;
+        zcpr.next_out = UncprPtr;
+
+
+        do
+        {
+            long all_read_before = zcpr.total_in;
+            zcpr.avail_in = min(lOrigToDo,BlockSizeUncompress);
+            zcpr.avail_out = BlockSizeUncompress;
+            ret=inflate(&zcpr,Z_SYNC_FLUSH);
+            lOrigDone += (zcpr.total_in-all_read_before);
+            lOrigToDo -= (zcpr.total_in-all_read_before);
+            step++;
+        } while (ret==Z_OK);
+
+        lSizeUncpr=zcpr.total_out;
+        inflateEnd(&zcpr);
+        dwGetTick=GetTickCount()-dwGetTick;
+        dwMsecQP=GetMsecSincePerfCounter(li_qp,TRUE);
+        dwResRdtsc=GetResRdtsc(li_rdtsc,TRUE);
+        printf("total uncompress size = %u, in %u step\n",lSizeUncpr,step);
+        printf("time = %u msec = %f sec\n",dwGetTick,dwGetTick/(double)1000.);
+        printf("uncpr  time QP = %u msec = %f sec\n",dwMsecQP,dwMsecQP/(double)1000.);
+        printf("uncpr  result rdtsc = %I64x\n\n",dwResRdtsc.QuadPart);
+    }
+
+    if (lSizeUncpr==lFileSize)
+    {
+        if (memcmp(FilePtr,UncprPtr,lFileSize)==0)
+            printf("compare ok\n");
+
+    }
+
+    return 0;
+}
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/testzlib/testzlib.txt b/Engine/lib/assimp/contrib/zlib/contrib/testzlib/testzlib.txt
new file mode 100644
index 000000000..e508bb22f
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/testzlib/testzlib.txt
@@ -0,0 +1,10 @@
+To build testzLib with Visual Studio 2005:
+
+copy to a directory file from :
+- root of zLib tree
+- contrib/testzlib
+- contrib/masmx86
+- contrib/masmx64
+- contrib/vstudio/vc7
+
+and open testzlib8.sln
\ No newline at end of file
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/untgz/Makefile.msc b/Engine/lib/assimp/contrib/zlib/contrib/untgz/Makefile.msc
new file mode 100644
index 000000000..77b860221
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/untgz/Makefile.msc
@@ -0,0 +1,17 @@
+CC=cl
+CFLAGS=-MD
+
+untgz.exe: untgz.obj ..\..\zlib.lib
+	$(CC) $(CFLAGS) untgz.obj ..\..\zlib.lib
+
+untgz.obj: untgz.c ..\..\zlib.h
+	$(CC) $(CFLAGS) -c -I..\.. untgz.c
+
+..\..\zlib.lib:
+	cd ..\..
+	$(MAKE) -f win32\makefile.msc
+	cd contrib\untgz
+
+clean:
+	-del untgz.obj
+	-del untgz.exe
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/untgz/untgz.c b/Engine/lib/assimp/contrib/zlib/contrib/untgz/untgz.c
new file mode 100644
index 000000000..2c391e598
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/untgz/untgz.c
@@ -0,0 +1,674 @@
+/*
+ * untgz.c -- Display contents and extract files from a gzip'd TAR file
+ *
+ * written by Pedro A. Aranda Gutierrez <paag@tid.es>
+ * adaptation to Unix by Jean-loup Gailly <jloup@gzip.org>
+ * various fixes by Cosmin Truta <cosmint@cs.ubbcluj.ro>
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <errno.h>
+
+#include "zlib.h"
+
+#ifdef unix
+#  include <unistd.h>
+#else
+#  include <direct.h>
+#  include <io.h>
+#endif
+
+#ifdef WIN32
+#include <windows.h>
+#  ifndef F_OK
+#    define F_OK  0
+#  endif
+#  define mkdir(dirname,mode)   _mkdir(dirname)
+#  ifdef _MSC_VER
+#    define access(path,mode)   _access(path,mode)
+#    define chmod(path,mode)    _chmod(path,mode)
+#    define strdup(str)         _strdup(str)
+#  endif
+#else
+#  include <utime.h>
+#endif
+
+
+/* values used in typeflag field */
+
+#define REGTYPE  '0'            /* regular file */
+#define AREGTYPE '\0'           /* regular file */
+#define LNKTYPE  '1'            /* link */
+#define SYMTYPE  '2'            /* reserved */
+#define CHRTYPE  '3'            /* character special */
+#define BLKTYPE  '4'            /* block special */
+#define DIRTYPE  '5'            /* directory */
+#define FIFOTYPE '6'            /* FIFO special */
+#define CONTTYPE '7'            /* reserved */
+
+/* GNU tar extensions */
+
+#define GNUTYPE_DUMPDIR  'D'    /* file names from dumped directory */
+#define GNUTYPE_LONGLINK 'K'    /* long link name */
+#define GNUTYPE_LONGNAME 'L'    /* long file name */
+#define GNUTYPE_MULTIVOL 'M'    /* continuation of file from another volume */
+#define GNUTYPE_NAMES    'N'    /* file name that does not fit into main hdr */
+#define GNUTYPE_SPARSE   'S'    /* sparse file */
+#define GNUTYPE_VOLHDR   'V'    /* tape/volume header */
+
+
+/* tar header */
+
+#define BLOCKSIZE     512
+#define SHORTNAMESIZE 100
+
+struct tar_header
+{                               /* byte offset */
+  char name[100];               /*   0 */
+  char mode[8];                 /* 100 */
+  char uid[8];                  /* 108 */
+  char gid[8];                  /* 116 */
+  char size[12];                /* 124 */
+  char mtime[12];               /* 136 */
+  char chksum[8];               /* 148 */
+  char typeflag;                /* 156 */
+  char linkname[100];           /* 157 */
+  char magic[6];                /* 257 */
+  char version[2];              /* 263 */
+  char uname[32];               /* 265 */
+  char gname[32];               /* 297 */
+  char devmajor[8];             /* 329 */
+  char devminor[8];             /* 337 */
+  char prefix[155];             /* 345 */
+                                /* 500 */
+};
+
+union tar_buffer
+{
+  char               buffer[BLOCKSIZE];
+  struct tar_header  header;
+};
+
+struct attr_item
+{
+  struct attr_item  *next;
+  char              *fname;
+  int                mode;
+  time_t             time;
+};
+
+enum { TGZ_EXTRACT, TGZ_LIST, TGZ_INVALID };
+
+char *TGZfname          OF((const char *));
+void TGZnotfound        OF((const char *));
+
+int getoct              OF((char *, int));
+char *strtime           OF((time_t *));
+int setfiletime         OF((char *, time_t));
+void push_attr          OF((struct attr_item **, char *, int, time_t));
+void restore_attr       OF((struct attr_item **));
+
+int ExprMatch           OF((char *, char *));
+
+int makedir             OF((char *));
+int matchname           OF((int, int, char **, char *));
+
+void error              OF((const char *));
+int tar                 OF((gzFile, int, int, int, char **));
+
+void help               OF((int));
+int main                OF((int, char **));
+
+char *prog;
+
+const char *TGZsuffix[] = { "\0", ".tar", ".tar.gz", ".taz", ".tgz", NULL };
+
+/* return the file name of the TGZ archive */
+/* or NULL if it does not exist */
+
+char *TGZfname (const char *arcname)
+{
+  static char buffer[1024];
+  int origlen,i;
+
+  strcpy(buffer,arcname);
+  origlen = strlen(buffer);
+
+  for (i=0; TGZsuffix[i]; i++)
+    {
+       strcpy(buffer+origlen,TGZsuffix[i]);
+       if (access(buffer,F_OK) == 0)
+         return buffer;
+    }
+  return NULL;
+}
+
+
+/* error message for the filename */
+
+void TGZnotfound (const char *arcname)
+{
+  int i;
+
+  fprintf(stderr,"%s: Couldn't find ",prog);
+  for (i=0;TGZsuffix[i];i++)
+    fprintf(stderr,(TGZsuffix[i+1]) ? "%s%s, " : "or %s%s\n",
+            arcname,
+            TGZsuffix[i]);
+  exit(1);
+}
+
+
+/* convert octal digits to int */
+/* on error return -1 */
+
+int getoct (char *p,int width)
+{
+  int result = 0;
+  char c;
+
+  while (width--)
+    {
+      c = *p++;
+      if (c == 0)
+        break;
+      if (c == ' ')
+        continue;
+      if (c < '0' || c > '7')
+        return -1;
+      result = result * 8 + (c - '0');
+    }
+  return result;
+}
+
+
+/* convert time_t to string */
+/* use the "YYYY/MM/DD hh:mm:ss" format */
+
+char *strtime (time_t *t)
+{
+  struct tm   *local;
+  static char result[32];
+
+  local = localtime(t);
+  sprintf(result,"%4d/%02d/%02d %02d:%02d:%02d",
+          local->tm_year+1900, local->tm_mon+1, local->tm_mday,
+          local->tm_hour, local->tm_min, local->tm_sec);
+  return result;
+}
+
+
+/* set file time */
+
+int setfiletime (char *fname,time_t ftime)
+{
+#ifdef WIN32
+  static int isWinNT = -1;
+  SYSTEMTIME st;
+  FILETIME locft, modft;
+  struct tm *loctm;
+  HANDLE hFile;
+  int result;
+
+  loctm = localtime(&ftime);
+  if (loctm == NULL)
+    return -1;
+
+  st.wYear         = (WORD)loctm->tm_year + 1900;
+  st.wMonth        = (WORD)loctm->tm_mon + 1;
+  st.wDayOfWeek    = (WORD)loctm->tm_wday;
+  st.wDay          = (WORD)loctm->tm_mday;
+  st.wHour         = (WORD)loctm->tm_hour;
+  st.wMinute       = (WORD)loctm->tm_min;
+  st.wSecond       = (WORD)loctm->tm_sec;
+  st.wMilliseconds = 0;
+  if (!SystemTimeToFileTime(&st, &locft) ||
+      !LocalFileTimeToFileTime(&locft, &modft))
+    return -1;
+
+  if (isWinNT < 0)
+    isWinNT = (GetVersion() < 0x80000000) ? 1 : 0;
+  hFile = CreateFile(fname, GENERIC_WRITE, 0, NULL, OPEN_EXISTING,
+                     (isWinNT ? FILE_FLAG_BACKUP_SEMANTICS : 0),
+                     NULL);
+  if (hFile == INVALID_HANDLE_VALUE)
+    return -1;
+  result = SetFileTime(hFile, NULL, NULL, &modft) ? 0 : -1;
+  CloseHandle(hFile);
+  return result;
+#else
+  struct utimbuf settime;
+
+  settime.actime = settime.modtime = ftime;
+  return utime(fname,&settime);
+#endif
+}
+
+
+/* push file attributes */
+
+void push_attr(struct attr_item **list,char *fname,int mode,time_t time)
+{
+  struct attr_item *item;
+
+  item = (struct attr_item *)malloc(sizeof(struct attr_item));
+  if (item == NULL)
+    error("Out of memory");
+  item->fname = strdup(fname);
+  item->mode  = mode;
+  item->time  = time;
+  item->next  = *list;
+  *list       = item;
+}
+
+
+/* restore file attributes */
+
+void restore_attr(struct attr_item **list)
+{
+  struct attr_item *item, *prev;
+
+  for (item = *list; item != NULL; )
+    {
+      setfiletime(item->fname,item->time);
+      chmod(item->fname,item->mode);
+      prev = item;
+      item = item->next;
+      free(prev);
+    }
+  *list = NULL;
+}
+
+
+/* match regular expression */
+
+#define ISSPECIAL(c) (((c) == '*') || ((c) == '/'))
+
+int ExprMatch (char *string,char *expr)
+{
+  while (1)
+    {
+      if (ISSPECIAL(*expr))
+        {
+          if (*expr == '/')
+            {
+              if (*string != '\\' && *string != '/')
+                return 0;
+              string ++; expr++;
+            }
+          else if (*expr == '*')
+            {
+              if (*expr ++ == 0)
+                return 1;
+              while (*++string != *expr)
+                if (*string == 0)
+                  return 0;
+            }
+        }
+      else
+        {
+          if (*string != *expr)
+            return 0;
+          if (*expr++ == 0)
+            return 1;
+          string++;
+        }
+    }
+}
+
+
+/* recursive mkdir */
+/* abort on ENOENT; ignore other errors like "directory already exists" */
+/* return 1 if OK */
+/*        0 on error */
+
+int makedir (char *newdir)
+{
+  char *buffer = strdup(newdir);
+  char *p;
+  int  len = strlen(buffer);
+
+  if (len <= 0) {
+    free(buffer);
+    return 0;
+  }
+  if (buffer[len-1] == '/') {
+    buffer[len-1] = '\0';
+  }
+  if (mkdir(buffer, 0755) == 0)
+    {
+      free(buffer);
+      return 1;
+    }
+
+  p = buffer+1;
+  while (1)
+    {
+      char hold;
+
+      while(*p && *p != '\\' && *p != '/')
+        p++;
+      hold = *p;
+      *p = 0;
+      if ((mkdir(buffer, 0755) == -1) && (errno == ENOENT))
+        {
+          fprintf(stderr,"%s: Couldn't create directory %s\n",prog,buffer);
+          free(buffer);
+          return 0;
+        }
+      if (hold == 0)
+        break;
+      *p++ = hold;
+    }
+  free(buffer);
+  return 1;
+}
+
+
+int matchname (int arg,int argc,char **argv,char *fname)
+{
+  if (arg == argc)      /* no arguments given (untgz tgzarchive) */
+    return 1;
+
+  while (arg < argc)
+    if (ExprMatch(fname,argv[arg++]))
+      return 1;
+
+  return 0; /* ignore this for the moment being */
+}
+
+
+/* tar file list or extract */
+
+int tar (gzFile in,int action,int arg,int argc,char **argv)
+{
+  union  tar_buffer buffer;
+  int    len;
+  int    err;
+  int    getheader = 1;
+  int    remaining = 0;
+  FILE   *outfile = NULL;
+  char   fname[BLOCKSIZE];
+  int    tarmode;
+  time_t tartime;
+  struct attr_item *attributes = NULL;
+
+  if (action == TGZ_LIST)
+    printf("    date      time     size                       file\n"
+           " ---------- -------- --------- -------------------------------------\n");
+  while (1)
+    {
+      len = gzread(in, &buffer, BLOCKSIZE);
+      if (len < 0)
+        error(gzerror(in, &err));
+      /*
+       * Always expect complete blocks to process
+       * the tar information.
+       */
+      if (len != BLOCKSIZE)
+        {
+          action = TGZ_INVALID; /* force error exit */
+          remaining = 0;        /* force I/O cleanup */
+        }
+
+      /*
+       * If we have to get a tar header
+       */
+      if (getheader >= 1)
+        {
+          /*
+           * if we met the end of the tar
+           * or the end-of-tar block,
+           * we are done
+           */
+          if (len == 0 || buffer.header.name[0] == 0)
+            break;
+
+          tarmode = getoct(buffer.header.mode,8);
+          tartime = (time_t)getoct(buffer.header.mtime,12);
+          if (tarmode == -1 || tartime == (time_t)-1)
+            {
+              buffer.header.name[0] = 0;
+              action = TGZ_INVALID;
+            }
+
+          if (getheader == 1)
+            {
+              strncpy(fname,buffer.header.name,SHORTNAMESIZE);
+              if (fname[SHORTNAMESIZE-1] != 0)
+                  fname[SHORTNAMESIZE] = 0;
+            }
+          else
+            {
+              /*
+               * The file name is longer than SHORTNAMESIZE
+               */
+              if (strncmp(fname,buffer.header.name,SHORTNAMESIZE-1) != 0)
+                  error("bad long name");
+              getheader = 1;
+            }
+
+          /*
+           * Act according to the type flag
+           */
+          switch (buffer.header.typeflag)
+            {
+            case DIRTYPE:
+              if (action == TGZ_LIST)
+                printf(" %s     <dir> %s\n",strtime(&tartime),fname);
+              if (action == TGZ_EXTRACT)
+                {
+                  makedir(fname);
+                  push_attr(&attributes,fname,tarmode,tartime);
+                }
+              break;
+            case REGTYPE:
+            case AREGTYPE:
+              remaining = getoct(buffer.header.size,12);
+              if (remaining == -1)
+                {
+                  action = TGZ_INVALID;
+                  break;
+                }
+              if (action == TGZ_LIST)
+                printf(" %s %9d %s\n",strtime(&tartime),remaining,fname);
+              else if (action == TGZ_EXTRACT)
+                {
+                  if (matchname(arg,argc,argv,fname))
+                    {
+                      outfile = fopen(fname,"wb");
+                      if (outfile == NULL) {
+                        /* try creating directory */
+                        char *p = strrchr(fname, '/');
+                        if (p != NULL) {
+                          *p = '\0';
+                          makedir(fname);
+                          *p = '/';
+                          outfile = fopen(fname,"wb");
+                        }
+                      }
+                      if (outfile != NULL)
+                        printf("Extracting %s\n",fname);
+                      else
+                        fprintf(stderr, "%s: Couldn't create %s",prog,fname);
+                    }
+                  else
+                    outfile = NULL;
+                }
+              getheader = 0;
+              break;
+            case GNUTYPE_LONGLINK:
+            case GNUTYPE_LONGNAME:
+              remaining = getoct(buffer.header.size,12);
+              if (remaining < 0 || remaining >= BLOCKSIZE)
+                {
+                  action = TGZ_INVALID;
+                  break;
+                }
+              len = gzread(in, fname, BLOCKSIZE);
+              if (len < 0)
+                error(gzerror(in, &err));
+              if (fname[BLOCKSIZE-1] != 0 || (int)strlen(fname) > remaining)
+                {
+                  action = TGZ_INVALID;
+                  break;
+                }
+              getheader = 2;
+              break;
+            default:
+              if (action == TGZ_LIST)
+                printf(" %s     <---> %s\n",strtime(&tartime),fname);
+              break;
+            }
+        }
+      else
+        {
+          unsigned int bytes = (remaining > BLOCKSIZE) ? BLOCKSIZE : remaining;
+
+          if (outfile != NULL)
+            {
+              if (fwrite(&buffer,sizeof(char),bytes,outfile) != bytes)
+                {
+                  fprintf(stderr,
+                    "%s: Error writing %s -- skipping\n",prog,fname);
+                  fclose(outfile);
+                  outfile = NULL;
+                  remove(fname);
+                }
+            }
+          remaining -= bytes;
+        }
+
+      if (remaining == 0)
+        {
+          getheader = 1;
+          if (outfile != NULL)
+            {
+              fclose(outfile);
+              outfile = NULL;
+              if (action != TGZ_INVALID)
+                push_attr(&attributes,fname,tarmode,tartime);
+            }
+        }
+
+      /*
+       * Abandon if errors are found
+       */
+      if (action == TGZ_INVALID)
+        {
+          error("broken archive");
+          break;
+        }
+    }
+
+  /*
+   * Restore file modes and time stamps
+   */
+  restore_attr(&attributes);
+
+  if (gzclose(in) != Z_OK)
+    error("failed gzclose");
+
+  return 0;
+}
+
+
+/* ============================================================ */
+
+void help(int exitval)
+{
+  printf("untgz version 0.2.1\n"
+         "  using zlib version %s\n\n",
+         zlibVersion());
+  printf("Usage: untgz file.tgz            extract all files\n"
+         "       untgz file.tgz fname ...  extract selected files\n"
+         "       untgz -l file.tgz         list archive contents\n"
+         "       untgz -h                  display this help\n");
+  exit(exitval);
+}
+
+void error(const char *msg)
+{
+  fprintf(stderr, "%s: %s\n", prog, msg);
+  exit(1);
+}
+
+
+/* ============================================================ */
+
+#if defined(WIN32) && defined(__GNUC__)
+int _CRT_glob = 0;      /* disable argument globbing in MinGW */
+#endif
+
+int main(int argc,char **argv)
+{
+    int         action = TGZ_EXTRACT;
+    int         arg = 1;
+    char        *TGZfile;
+    gzFile      *f;
+
+    prog = strrchr(argv[0],'\\');
+    if (prog == NULL)
+      {
+        prog = strrchr(argv[0],'/');
+        if (prog == NULL)
+          {
+            prog = strrchr(argv[0],':');
+            if (prog == NULL)
+              prog = argv[0];
+            else
+              prog++;
+          }
+        else
+          prog++;
+      }
+    else
+      prog++;
+
+    if (argc == 1)
+      help(0);
+
+    if (strcmp(argv[arg],"-l") == 0)
+      {
+        action = TGZ_LIST;
+        if (argc == ++arg)
+          help(0);
+      }
+    else if (strcmp(argv[arg],"-h") == 0)
+      {
+        help(0);
+      }
+
+    if ((TGZfile = TGZfname(argv[arg])) == NULL)
+      TGZnotfound(argv[arg]);
+
+    ++arg;
+    if ((action == TGZ_LIST) && (arg != argc))
+      help(1);
+
+/*
+ *  Process the TGZ file
+ */
+    switch(action)
+      {
+      case TGZ_LIST:
+      case TGZ_EXTRACT:
+        f = gzopen(TGZfile,"rb");
+        if (f == NULL)
+          {
+            fprintf(stderr,"%s: Couldn't gzopen %s\n",prog,TGZfile);
+            return 1;
+          }
+        exit(tar(f, action, arg, argc, argv));
+      break;
+
+      default:
+        error("Unknown option");
+        exit(1);
+      }
+
+    return 0;
+}
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/vstudio/readme.txt b/Engine/lib/assimp/contrib/zlib/contrib/vstudio/readme.txt
new file mode 100644
index 000000000..48cccc0d2
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/vstudio/readme.txt
@@ -0,0 +1,78 @@
+Building instructions for the DLL versions of Zlib 1.2.11
+========================================================
+
+This directory contains projects that build zlib and minizip using
+Microsoft Visual C++ 9.0/10.0.
+
+You don't need to build these projects yourself. You can download the
+binaries from:
+  http://www.winimage.com/zLibDll
+
+More information can be found at this site.
+
+
+
+
+
+Build instructions for Visual Studio 2008 (32 bits or 64 bits)
+--------------------------------------------------------------
+- Decompress current zlib, including all contrib/* files
+- Compile assembly code (with Visual Studio Command Prompt) by running:
+   bld_ml64.bat (in contrib\masmx64)
+   bld_ml32.bat (in contrib\masmx86)
+- Open contrib\vstudio\vc9\zlibvc.sln with Microsoft Visual C++ 2008
+- Or run: vcbuild /rebuild contrib\vstudio\vc9\zlibvc.sln "Release|Win32"
+
+Build instructions for Visual Studio 2010 (32 bits or 64 bits)
+--------------------------------------------------------------
+- Decompress current zlib, including all contrib/* files
+- Open contrib\vstudio\vc10\zlibvc.sln with Microsoft Visual C++ 2010
+
+Build instructions for Visual Studio 2012 (32 bits or 64 bits)
+--------------------------------------------------------------
+- Decompress current zlib, including all contrib/* files
+- Open contrib\vstudio\vc11\zlibvc.sln with Microsoft Visual C++ 2012
+
+Build instructions for Visual Studio 2013 (32 bits or 64 bits)
+--------------------------------------------------------------
+- Decompress current zlib, including all contrib/* files
+- Open contrib\vstudio\vc12\zlibvc.sln with Microsoft Visual C++ 2013
+
+Build instructions for Visual Studio 2015 (32 bits or 64 bits)
+--------------------------------------------------------------
+- Decompress current zlib, including all contrib/* files
+- Open contrib\vstudio\vc14\zlibvc.sln with Microsoft Visual C++ 2015
+
+
+Important
+---------
+- To use zlibwapi.dll in your application, you must define the
+  macro ZLIB_WINAPI when compiling your application's source files.
+
+
+Additional notes
+----------------
+- This DLL, named zlibwapi.dll, is compatible to the old zlib.dll built
+  by Gilles Vollant from the zlib 1.1.x sources, and distributed at
+    http://www.winimage.com/zLibDll
+  It uses the WINAPI calling convention for the exported functions, and
+  includes the minizip functionality. If your application needs that
+  particular build of zlib.dll, you can rename zlibwapi.dll to zlib.dll.
+
+- The new DLL was renamed because there exist several incompatible
+  versions of zlib.dll on the Internet.
+
+- There is also an official DLL build of zlib, named zlib1.dll. This one
+  is exporting the functions using the CDECL convention. See the file
+  win32\DLL_FAQ.txt found in this zlib distribution.
+
+- There used to be a ZLIB_DLL macro in zlib 1.1.x, but now this symbol
+  has a slightly different effect. To avoid compatibility problems, do
+  not define it here.
+
+
+Gilles Vollant
+info@winimage.com
+
+Visual Studio 2013 and 2015 Projects from Sean Hunt
+seandhunt_7@yahoo.com
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc10/zlib.rc b/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc10/zlib.rc
new file mode 100644
index 000000000..c4e4b016e
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc10/zlib.rc
@@ -0,0 +1,32 @@
+#include <windows.h>
+
+#define IDR_VERSION1  1
+IDR_VERSION1	VERSIONINFO	MOVEABLE IMPURE LOADONCALL DISCARDABLE
+  FILEVERSION	 1, 2, 11, 0
+  PRODUCTVERSION 1, 2, 11, 0
+  FILEFLAGSMASK	VS_FFI_FILEFLAGSMASK
+  FILEFLAGS	0
+  FILEOS	VOS_DOS_WINDOWS32
+  FILETYPE	VFT_DLL
+  FILESUBTYPE	0	// not used
+BEGIN
+  BLOCK "StringFileInfo"
+  BEGIN
+    BLOCK "040904E4"
+    //language ID = U.S. English, char set = Windows, Multilingual
+
+    BEGIN
+      VALUE "FileDescription", "zlib data compression and ZIP file I/O library\0"
+      VALUE "FileVersion",	"1.2.11\0"
+      VALUE "InternalName",	"zlib\0"
+      VALUE "OriginalFilename",	"zlibwapi.dll\0"
+      VALUE "ProductName",	"ZLib.DLL\0"
+      VALUE "Comments","DLL support by Alessandro Iacopetti & Gilles Vollant\0"
+      VALUE "LegalCopyright", "(C) 1995-2017 Jean-loup Gailly & Mark Adler\0"
+    END
+  END
+  BLOCK "VarFileInfo"
+  BEGIN
+    VALUE "Translation", 0x0409, 1252
+  END
+END
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc10/zlibvc.def b/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc10/zlibvc.def
new file mode 100644
index 000000000..f876c3bca
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc10/zlibvc.def
@@ -0,0 +1,153 @@
+LIBRARY
+; zlib data compression and ZIP file I/O library
+
+VERSION		1.2
+
+EXPORTS
+        adler32                                  @1
+        compress                                 @2
+        crc32                                    @3
+        deflate                                  @4
+        deflateCopy                              @5
+        deflateEnd                               @6
+        deflateInit2_                            @7
+        deflateInit_                             @8
+        deflateParams                            @9
+        deflateReset                             @10
+        deflateSetDictionary                     @11
+        gzclose                                  @12
+        gzdopen                                  @13
+        gzerror                                  @14
+        gzflush                                  @15
+        gzopen                                   @16
+        gzread                                   @17
+        gzwrite                                  @18
+        inflate                                  @19
+        inflateEnd                               @20
+        inflateInit2_                            @21
+        inflateInit_                             @22
+        inflateReset                             @23
+        inflateSetDictionary                     @24
+        inflateSync                              @25
+        uncompress                               @26
+        zlibVersion                              @27
+        gzprintf                                 @28
+        gzputc                                   @29
+        gzgetc                                   @30
+        gzseek                                   @31
+        gzrewind                                 @32
+        gztell                                   @33
+        gzeof                                    @34
+        gzsetparams                              @35
+        zError                                   @36
+        inflateSyncPoint                         @37
+        get_crc_table                            @38
+        compress2                                @39
+        gzputs                                   @40
+        gzgets                                   @41
+        inflateCopy                              @42
+        inflateBackInit_                         @43
+        inflateBack                              @44
+        inflateBackEnd                           @45
+        compressBound                            @46
+        deflateBound                             @47
+        gzclearerr                               @48
+        gzungetc                                 @49
+        zlibCompileFlags                         @50
+        deflatePrime                             @51
+        deflatePending                           @52
+
+        unzOpen                                  @61
+        unzClose                                 @62
+        unzGetGlobalInfo                         @63
+        unzGetCurrentFileInfo                    @64
+        unzGoToFirstFile                         @65
+        unzGoToNextFile                          @66
+        unzOpenCurrentFile                       @67
+        unzReadCurrentFile                       @68
+        unzOpenCurrentFile3                      @69
+        unztell                                  @70
+        unzeof                                   @71
+        unzCloseCurrentFile                      @72
+        unzGetGlobalComment                      @73
+        unzStringFileNameCompare                 @74
+        unzLocateFile                            @75
+        unzGetLocalExtrafield                    @76
+        unzOpen2                                 @77
+        unzOpenCurrentFile2                      @78
+        unzOpenCurrentFilePassword               @79
+
+        zipOpen                                  @80
+        zipOpenNewFileInZip                      @81
+        zipWriteInFileInZip                      @82
+        zipCloseFileInZip                        @83
+        zipClose                                 @84
+        zipOpenNewFileInZip2                     @86
+        zipCloseFileInZipRaw                     @87
+        zipOpen2                                 @88
+        zipOpenNewFileInZip3                     @89
+
+        unzGetFilePos                            @100
+        unzGoToFilePos                           @101
+
+        fill_win32_filefunc                      @110
+
+; zlibwapi v1.2.4 added:
+        fill_win32_filefunc64                   @111
+        fill_win32_filefunc64A                  @112
+        fill_win32_filefunc64W                  @113
+
+        unzOpen64                               @120
+        unzOpen2_64                             @121
+        unzGetGlobalInfo64                      @122
+        unzGetCurrentFileInfo64                 @124
+        unzGetCurrentFileZStreamPos64           @125
+        unztell64                               @126
+        unzGetFilePos64                         @127
+        unzGoToFilePos64                        @128
+
+        zipOpen64                               @130
+        zipOpen2_64                             @131
+        zipOpenNewFileInZip64                   @132
+        zipOpenNewFileInZip2_64                 @133
+        zipOpenNewFileInZip3_64                 @134
+        zipOpenNewFileInZip4_64                 @135
+        zipCloseFileInZipRaw64                  @136
+
+; zlib1 v1.2.4 added:
+        adler32_combine                         @140
+        crc32_combine                           @142
+        deflateSetHeader                        @144
+        deflateTune                             @145
+        gzbuffer                                @146
+        gzclose_r                               @147
+        gzclose_w                               @148
+        gzdirect                                @149
+        gzoffset                                @150
+        inflateGetHeader                        @156
+        inflateMark                             @157
+        inflatePrime                            @158
+        inflateReset2                           @159
+        inflateUndermine                        @160
+
+; zlib1 v1.2.6 added:
+        gzgetc_                                 @161
+        inflateResetKeep                        @163
+        deflateResetKeep                        @164
+
+; zlib1 v1.2.7 added:
+        gzopen_w                                @165
+
+; zlib1 v1.2.8 added:
+        inflateGetDictionary                    @166
+        gzvprintf                               @167
+
+; zlib1 v1.2.9 added:
+        inflateCodesUsed                        @168
+        inflateValidate                         @169
+        uncompress2                             @170
+        gzfread                                 @171
+        gzfwrite                                @172
+        deflateGetDictionary                    @173
+        adler32_z                               @174
+        crc32_z                                 @175
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc11/zlib.rc b/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc11/zlib.rc
new file mode 100644
index 000000000..c4e4b016e
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc11/zlib.rc
@@ -0,0 +1,32 @@
+#include <windows.h>
+
+#define IDR_VERSION1  1
+IDR_VERSION1	VERSIONINFO	MOVEABLE IMPURE LOADONCALL DISCARDABLE
+  FILEVERSION	 1, 2, 11, 0
+  PRODUCTVERSION 1, 2, 11, 0
+  FILEFLAGSMASK	VS_FFI_FILEFLAGSMASK
+  FILEFLAGS	0
+  FILEOS	VOS_DOS_WINDOWS32
+  FILETYPE	VFT_DLL
+  FILESUBTYPE	0	// not used
+BEGIN
+  BLOCK "StringFileInfo"
+  BEGIN
+    BLOCK "040904E4"
+    //language ID = U.S. English, char set = Windows, Multilingual
+
+    BEGIN
+      VALUE "FileDescription", "zlib data compression and ZIP file I/O library\0"
+      VALUE "FileVersion",	"1.2.11\0"
+      VALUE "InternalName",	"zlib\0"
+      VALUE "OriginalFilename",	"zlibwapi.dll\0"
+      VALUE "ProductName",	"ZLib.DLL\0"
+      VALUE "Comments","DLL support by Alessandro Iacopetti & Gilles Vollant\0"
+      VALUE "LegalCopyright", "(C) 1995-2017 Jean-loup Gailly & Mark Adler\0"
+    END
+  END
+  BLOCK "VarFileInfo"
+  BEGIN
+    VALUE "Translation", 0x0409, 1252
+  END
+END
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc11/zlibvc.def b/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc11/zlibvc.def
new file mode 100644
index 000000000..f876c3bca
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc11/zlibvc.def
@@ -0,0 +1,153 @@
+LIBRARY
+; zlib data compression and ZIP file I/O library
+
+VERSION		1.2
+
+EXPORTS
+        adler32                                  @1
+        compress                                 @2
+        crc32                                    @3
+        deflate                                  @4
+        deflateCopy                              @5
+        deflateEnd                               @6
+        deflateInit2_                            @7
+        deflateInit_                             @8
+        deflateParams                            @9
+        deflateReset                             @10
+        deflateSetDictionary                     @11
+        gzclose                                  @12
+        gzdopen                                  @13
+        gzerror                                  @14
+        gzflush                                  @15
+        gzopen                                   @16
+        gzread                                   @17
+        gzwrite                                  @18
+        inflate                                  @19
+        inflateEnd                               @20
+        inflateInit2_                            @21
+        inflateInit_                             @22
+        inflateReset                             @23
+        inflateSetDictionary                     @24
+        inflateSync                              @25
+        uncompress                               @26
+        zlibVersion                              @27
+        gzprintf                                 @28
+        gzputc                                   @29
+        gzgetc                                   @30
+        gzseek                                   @31
+        gzrewind                                 @32
+        gztell                                   @33
+        gzeof                                    @34
+        gzsetparams                              @35
+        zError                                   @36
+        inflateSyncPoint                         @37
+        get_crc_table                            @38
+        compress2                                @39
+        gzputs                                   @40
+        gzgets                                   @41
+        inflateCopy                              @42
+        inflateBackInit_                         @43
+        inflateBack                              @44
+        inflateBackEnd                           @45
+        compressBound                            @46
+        deflateBound                             @47
+        gzclearerr                               @48
+        gzungetc                                 @49
+        zlibCompileFlags                         @50
+        deflatePrime                             @51
+        deflatePending                           @52
+
+        unzOpen                                  @61
+        unzClose                                 @62
+        unzGetGlobalInfo                         @63
+        unzGetCurrentFileInfo                    @64
+        unzGoToFirstFile                         @65
+        unzGoToNextFile                          @66
+        unzOpenCurrentFile                       @67
+        unzReadCurrentFile                       @68
+        unzOpenCurrentFile3                      @69
+        unztell                                  @70
+        unzeof                                   @71
+        unzCloseCurrentFile                      @72
+        unzGetGlobalComment                      @73
+        unzStringFileNameCompare                 @74
+        unzLocateFile                            @75
+        unzGetLocalExtrafield                    @76
+        unzOpen2                                 @77
+        unzOpenCurrentFile2                      @78
+        unzOpenCurrentFilePassword               @79
+
+        zipOpen                                  @80
+        zipOpenNewFileInZip                      @81
+        zipWriteInFileInZip                      @82
+        zipCloseFileInZip                        @83
+        zipClose                                 @84
+        zipOpenNewFileInZip2                     @86
+        zipCloseFileInZipRaw                     @87
+        zipOpen2                                 @88
+        zipOpenNewFileInZip3                     @89
+
+        unzGetFilePos                            @100
+        unzGoToFilePos                           @101
+
+        fill_win32_filefunc                      @110
+
+; zlibwapi v1.2.4 added:
+        fill_win32_filefunc64                   @111
+        fill_win32_filefunc64A                  @112
+        fill_win32_filefunc64W                  @113
+
+        unzOpen64                               @120
+        unzOpen2_64                             @121
+        unzGetGlobalInfo64                      @122
+        unzGetCurrentFileInfo64                 @124
+        unzGetCurrentFileZStreamPos64           @125
+        unztell64                               @126
+        unzGetFilePos64                         @127
+        unzGoToFilePos64                        @128
+
+        zipOpen64                               @130
+        zipOpen2_64                             @131
+        zipOpenNewFileInZip64                   @132
+        zipOpenNewFileInZip2_64                 @133
+        zipOpenNewFileInZip3_64                 @134
+        zipOpenNewFileInZip4_64                 @135
+        zipCloseFileInZipRaw64                  @136
+
+; zlib1 v1.2.4 added:
+        adler32_combine                         @140
+        crc32_combine                           @142
+        deflateSetHeader                        @144
+        deflateTune                             @145
+        gzbuffer                                @146
+        gzclose_r                               @147
+        gzclose_w                               @148
+        gzdirect                                @149
+        gzoffset                                @150
+        inflateGetHeader                        @156
+        inflateMark                             @157
+        inflatePrime                            @158
+        inflateReset2                           @159
+        inflateUndermine                        @160
+
+; zlib1 v1.2.6 added:
+        gzgetc_                                 @161
+        inflateResetKeep                        @163
+        deflateResetKeep                        @164
+
+; zlib1 v1.2.7 added:
+        gzopen_w                                @165
+
+; zlib1 v1.2.8 added:
+        inflateGetDictionary                    @166
+        gzvprintf                               @167
+
+; zlib1 v1.2.9 added:
+        inflateCodesUsed                        @168
+        inflateValidate                         @169
+        uncompress2                             @170
+        gzfread                                 @171
+        gzfwrite                                @172
+        deflateGetDictionary                    @173
+        adler32_z                               @174
+        crc32_z                                 @175
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc12/zlib.rc b/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc12/zlib.rc
new file mode 100644
index 000000000..c4e4b016e
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc12/zlib.rc
@@ -0,0 +1,32 @@
+#include <windows.h>
+
+#define IDR_VERSION1  1
+IDR_VERSION1	VERSIONINFO	MOVEABLE IMPURE LOADONCALL DISCARDABLE
+  FILEVERSION	 1, 2, 11, 0
+  PRODUCTVERSION 1, 2, 11, 0
+  FILEFLAGSMASK	VS_FFI_FILEFLAGSMASK
+  FILEFLAGS	0
+  FILEOS	VOS_DOS_WINDOWS32
+  FILETYPE	VFT_DLL
+  FILESUBTYPE	0	// not used
+BEGIN
+  BLOCK "StringFileInfo"
+  BEGIN
+    BLOCK "040904E4"
+    //language ID = U.S. English, char set = Windows, Multilingual
+
+    BEGIN
+      VALUE "FileDescription", "zlib data compression and ZIP file I/O library\0"
+      VALUE "FileVersion",	"1.2.11\0"
+      VALUE "InternalName",	"zlib\0"
+      VALUE "OriginalFilename",	"zlibwapi.dll\0"
+      VALUE "ProductName",	"ZLib.DLL\0"
+      VALUE "Comments","DLL support by Alessandro Iacopetti & Gilles Vollant\0"
+      VALUE "LegalCopyright", "(C) 1995-2017 Jean-loup Gailly & Mark Adler\0"
+    END
+  END
+  BLOCK "VarFileInfo"
+  BEGIN
+    VALUE "Translation", 0x0409, 1252
+  END
+END
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc12/zlibvc.def b/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc12/zlibvc.def
new file mode 100644
index 000000000..f876c3bca
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc12/zlibvc.def
@@ -0,0 +1,153 @@
+LIBRARY
+; zlib data compression and ZIP file I/O library
+
+VERSION		1.2
+
+EXPORTS
+        adler32                                  @1
+        compress                                 @2
+        crc32                                    @3
+        deflate                                  @4
+        deflateCopy                              @5
+        deflateEnd                               @6
+        deflateInit2_                            @7
+        deflateInit_                             @8
+        deflateParams                            @9
+        deflateReset                             @10
+        deflateSetDictionary                     @11
+        gzclose                                  @12
+        gzdopen                                  @13
+        gzerror                                  @14
+        gzflush                                  @15
+        gzopen                                   @16
+        gzread                                   @17
+        gzwrite                                  @18
+        inflate                                  @19
+        inflateEnd                               @20
+        inflateInit2_                            @21
+        inflateInit_                             @22
+        inflateReset                             @23
+        inflateSetDictionary                     @24
+        inflateSync                              @25
+        uncompress                               @26
+        zlibVersion                              @27
+        gzprintf                                 @28
+        gzputc                                   @29
+        gzgetc                                   @30
+        gzseek                                   @31
+        gzrewind                                 @32
+        gztell                                   @33
+        gzeof                                    @34
+        gzsetparams                              @35
+        zError                                   @36
+        inflateSyncPoint                         @37
+        get_crc_table                            @38
+        compress2                                @39
+        gzputs                                   @40
+        gzgets                                   @41
+        inflateCopy                              @42
+        inflateBackInit_                         @43
+        inflateBack                              @44
+        inflateBackEnd                           @45
+        compressBound                            @46
+        deflateBound                             @47
+        gzclearerr                               @48
+        gzungetc                                 @49
+        zlibCompileFlags                         @50
+        deflatePrime                             @51
+        deflatePending                           @52
+
+        unzOpen                                  @61
+        unzClose                                 @62
+        unzGetGlobalInfo                         @63
+        unzGetCurrentFileInfo                    @64
+        unzGoToFirstFile                         @65
+        unzGoToNextFile                          @66
+        unzOpenCurrentFile                       @67
+        unzReadCurrentFile                       @68
+        unzOpenCurrentFile3                      @69
+        unztell                                  @70
+        unzeof                                   @71
+        unzCloseCurrentFile                      @72
+        unzGetGlobalComment                      @73
+        unzStringFileNameCompare                 @74
+        unzLocateFile                            @75
+        unzGetLocalExtrafield                    @76
+        unzOpen2                                 @77
+        unzOpenCurrentFile2                      @78
+        unzOpenCurrentFilePassword               @79
+
+        zipOpen                                  @80
+        zipOpenNewFileInZip                      @81
+        zipWriteInFileInZip                      @82
+        zipCloseFileInZip                        @83
+        zipClose                                 @84
+        zipOpenNewFileInZip2                     @86
+        zipCloseFileInZipRaw                     @87
+        zipOpen2                                 @88
+        zipOpenNewFileInZip3                     @89
+
+        unzGetFilePos                            @100
+        unzGoToFilePos                           @101
+
+        fill_win32_filefunc                      @110
+
+; zlibwapi v1.2.4 added:
+        fill_win32_filefunc64                   @111
+        fill_win32_filefunc64A                  @112
+        fill_win32_filefunc64W                  @113
+
+        unzOpen64                               @120
+        unzOpen2_64                             @121
+        unzGetGlobalInfo64                      @122
+        unzGetCurrentFileInfo64                 @124
+        unzGetCurrentFileZStreamPos64           @125
+        unztell64                               @126
+        unzGetFilePos64                         @127
+        unzGoToFilePos64                        @128
+
+        zipOpen64                               @130
+        zipOpen2_64                             @131
+        zipOpenNewFileInZip64                   @132
+        zipOpenNewFileInZip2_64                 @133
+        zipOpenNewFileInZip3_64                 @134
+        zipOpenNewFileInZip4_64                 @135
+        zipCloseFileInZipRaw64                  @136
+
+; zlib1 v1.2.4 added:
+        adler32_combine                         @140
+        crc32_combine                           @142
+        deflateSetHeader                        @144
+        deflateTune                             @145
+        gzbuffer                                @146
+        gzclose_r                               @147
+        gzclose_w                               @148
+        gzdirect                                @149
+        gzoffset                                @150
+        inflateGetHeader                        @156
+        inflateMark                             @157
+        inflatePrime                            @158
+        inflateReset2                           @159
+        inflateUndermine                        @160
+
+; zlib1 v1.2.6 added:
+        gzgetc_                                 @161
+        inflateResetKeep                        @163
+        deflateResetKeep                        @164
+
+; zlib1 v1.2.7 added:
+        gzopen_w                                @165
+
+; zlib1 v1.2.8 added:
+        inflateGetDictionary                    @166
+        gzvprintf                               @167
+
+; zlib1 v1.2.9 added:
+        inflateCodesUsed                        @168
+        inflateValidate                         @169
+        uncompress2                             @170
+        gzfread                                 @171
+        gzfwrite                                @172
+        deflateGetDictionary                    @173
+        adler32_z                               @174
+        crc32_z                                 @175
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc14/zlib.rc b/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc14/zlib.rc
new file mode 100644
index 000000000..c4e4b016e
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc14/zlib.rc
@@ -0,0 +1,32 @@
+#include <windows.h>
+
+#define IDR_VERSION1  1
+IDR_VERSION1	VERSIONINFO	MOVEABLE IMPURE LOADONCALL DISCARDABLE
+  FILEVERSION	 1, 2, 11, 0
+  PRODUCTVERSION 1, 2, 11, 0
+  FILEFLAGSMASK	VS_FFI_FILEFLAGSMASK
+  FILEFLAGS	0
+  FILEOS	VOS_DOS_WINDOWS32
+  FILETYPE	VFT_DLL
+  FILESUBTYPE	0	// not used
+BEGIN
+  BLOCK "StringFileInfo"
+  BEGIN
+    BLOCK "040904E4"
+    //language ID = U.S. English, char set = Windows, Multilingual
+
+    BEGIN
+      VALUE "FileDescription", "zlib data compression and ZIP file I/O library\0"
+      VALUE "FileVersion",	"1.2.11\0"
+      VALUE "InternalName",	"zlib\0"
+      VALUE "OriginalFilename",	"zlibwapi.dll\0"
+      VALUE "ProductName",	"ZLib.DLL\0"
+      VALUE "Comments","DLL support by Alessandro Iacopetti & Gilles Vollant\0"
+      VALUE "LegalCopyright", "(C) 1995-2017 Jean-loup Gailly & Mark Adler\0"
+    END
+  END
+  BLOCK "VarFileInfo"
+  BEGIN
+    VALUE "Translation", 0x0409, 1252
+  END
+END
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc14/zlibvc.def b/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc14/zlibvc.def
new file mode 100644
index 000000000..f876c3bca
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc14/zlibvc.def
@@ -0,0 +1,153 @@
+LIBRARY
+; zlib data compression and ZIP file I/O library
+
+VERSION		1.2
+
+EXPORTS
+        adler32                                  @1
+        compress                                 @2
+        crc32                                    @3
+        deflate                                  @4
+        deflateCopy                              @5
+        deflateEnd                               @6
+        deflateInit2_                            @7
+        deflateInit_                             @8
+        deflateParams                            @9
+        deflateReset                             @10
+        deflateSetDictionary                     @11
+        gzclose                                  @12
+        gzdopen                                  @13
+        gzerror                                  @14
+        gzflush                                  @15
+        gzopen                                   @16
+        gzread                                   @17
+        gzwrite                                  @18
+        inflate                                  @19
+        inflateEnd                               @20
+        inflateInit2_                            @21
+        inflateInit_                             @22
+        inflateReset                             @23
+        inflateSetDictionary                     @24
+        inflateSync                              @25
+        uncompress                               @26
+        zlibVersion                              @27
+        gzprintf                                 @28
+        gzputc                                   @29
+        gzgetc                                   @30
+        gzseek                                   @31
+        gzrewind                                 @32
+        gztell                                   @33
+        gzeof                                    @34
+        gzsetparams                              @35
+        zError                                   @36
+        inflateSyncPoint                         @37
+        get_crc_table                            @38
+        compress2                                @39
+        gzputs                                   @40
+        gzgets                                   @41
+        inflateCopy                              @42
+        inflateBackInit_                         @43
+        inflateBack                              @44
+        inflateBackEnd                           @45
+        compressBound                            @46
+        deflateBound                             @47
+        gzclearerr                               @48
+        gzungetc                                 @49
+        zlibCompileFlags                         @50
+        deflatePrime                             @51
+        deflatePending                           @52
+
+        unzOpen                                  @61
+        unzClose                                 @62
+        unzGetGlobalInfo                         @63
+        unzGetCurrentFileInfo                    @64
+        unzGoToFirstFile                         @65
+        unzGoToNextFile                          @66
+        unzOpenCurrentFile                       @67
+        unzReadCurrentFile                       @68
+        unzOpenCurrentFile3                      @69
+        unztell                                  @70
+        unzeof                                   @71
+        unzCloseCurrentFile                      @72
+        unzGetGlobalComment                      @73
+        unzStringFileNameCompare                 @74
+        unzLocateFile                            @75
+        unzGetLocalExtrafield                    @76
+        unzOpen2                                 @77
+        unzOpenCurrentFile2                      @78
+        unzOpenCurrentFilePassword               @79
+
+        zipOpen                                  @80
+        zipOpenNewFileInZip                      @81
+        zipWriteInFileInZip                      @82
+        zipCloseFileInZip                        @83
+        zipClose                                 @84
+        zipOpenNewFileInZip2                     @86
+        zipCloseFileInZipRaw                     @87
+        zipOpen2                                 @88
+        zipOpenNewFileInZip3                     @89
+
+        unzGetFilePos                            @100
+        unzGoToFilePos                           @101
+
+        fill_win32_filefunc                      @110
+
+; zlibwapi v1.2.4 added:
+        fill_win32_filefunc64                   @111
+        fill_win32_filefunc64A                  @112
+        fill_win32_filefunc64W                  @113
+
+        unzOpen64                               @120
+        unzOpen2_64                             @121
+        unzGetGlobalInfo64                      @122
+        unzGetCurrentFileInfo64                 @124
+        unzGetCurrentFileZStreamPos64           @125
+        unztell64                               @126
+        unzGetFilePos64                         @127
+        unzGoToFilePos64                        @128
+
+        zipOpen64                               @130
+        zipOpen2_64                             @131
+        zipOpenNewFileInZip64                   @132
+        zipOpenNewFileInZip2_64                 @133
+        zipOpenNewFileInZip3_64                 @134
+        zipOpenNewFileInZip4_64                 @135
+        zipCloseFileInZipRaw64                  @136
+
+; zlib1 v1.2.4 added:
+        adler32_combine                         @140
+        crc32_combine                           @142
+        deflateSetHeader                        @144
+        deflateTune                             @145
+        gzbuffer                                @146
+        gzclose_r                               @147
+        gzclose_w                               @148
+        gzdirect                                @149
+        gzoffset                                @150
+        inflateGetHeader                        @156
+        inflateMark                             @157
+        inflatePrime                            @158
+        inflateReset2                           @159
+        inflateUndermine                        @160
+
+; zlib1 v1.2.6 added:
+        gzgetc_                                 @161
+        inflateResetKeep                        @163
+        deflateResetKeep                        @164
+
+; zlib1 v1.2.7 added:
+        gzopen_w                                @165
+
+; zlib1 v1.2.8 added:
+        inflateGetDictionary                    @166
+        gzvprintf                               @167
+
+; zlib1 v1.2.9 added:
+        inflateCodesUsed                        @168
+        inflateValidate                         @169
+        uncompress2                             @170
+        gzfread                                 @171
+        gzfwrite                                @172
+        deflateGetDictionary                    @173
+        adler32_z                               @174
+        crc32_z                                 @175
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc9/zlib.rc b/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc9/zlib.rc
new file mode 100644
index 000000000..c4e4b016e
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc9/zlib.rc
@@ -0,0 +1,32 @@
+#include <windows.h>
+
+#define IDR_VERSION1  1
+IDR_VERSION1	VERSIONINFO	MOVEABLE IMPURE LOADONCALL DISCARDABLE
+  FILEVERSION	 1, 2, 11, 0
+  PRODUCTVERSION 1, 2, 11, 0
+  FILEFLAGSMASK	VS_FFI_FILEFLAGSMASK
+  FILEFLAGS	0
+  FILEOS	VOS_DOS_WINDOWS32
+  FILETYPE	VFT_DLL
+  FILESUBTYPE	0	// not used
+BEGIN
+  BLOCK "StringFileInfo"
+  BEGIN
+    BLOCK "040904E4"
+    //language ID = U.S. English, char set = Windows, Multilingual
+
+    BEGIN
+      VALUE "FileDescription", "zlib data compression and ZIP file I/O library\0"
+      VALUE "FileVersion",	"1.2.11\0"
+      VALUE "InternalName",	"zlib\0"
+      VALUE "OriginalFilename",	"zlibwapi.dll\0"
+      VALUE "ProductName",	"ZLib.DLL\0"
+      VALUE "Comments","DLL support by Alessandro Iacopetti & Gilles Vollant\0"
+      VALUE "LegalCopyright", "(C) 1995-2017 Jean-loup Gailly & Mark Adler\0"
+    END
+  END
+  BLOCK "VarFileInfo"
+  BEGIN
+    VALUE "Translation", 0x0409, 1252
+  END
+END
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc9/zlibvc.def b/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc9/zlibvc.def
new file mode 100644
index 000000000..f876c3bca
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/contrib/vstudio/vc9/zlibvc.def
@@ -0,0 +1,153 @@
+LIBRARY
+; zlib data compression and ZIP file I/O library
+
+VERSION		1.2
+
+EXPORTS
+        adler32                                  @1
+        compress                                 @2
+        crc32                                    @3
+        deflate                                  @4
+        deflateCopy                              @5
+        deflateEnd                               @6
+        deflateInit2_                            @7
+        deflateInit_                             @8
+        deflateParams                            @9
+        deflateReset                             @10
+        deflateSetDictionary                     @11
+        gzclose                                  @12
+        gzdopen                                  @13
+        gzerror                                  @14
+        gzflush                                  @15
+        gzopen                                   @16
+        gzread                                   @17
+        gzwrite                                  @18
+        inflate                                  @19
+        inflateEnd                               @20
+        inflateInit2_                            @21
+        inflateInit_                             @22
+        inflateReset                             @23
+        inflateSetDictionary                     @24
+        inflateSync                              @25
+        uncompress                               @26
+        zlibVersion                              @27
+        gzprintf                                 @28
+        gzputc                                   @29
+        gzgetc                                   @30
+        gzseek                                   @31
+        gzrewind                                 @32
+        gztell                                   @33
+        gzeof                                    @34
+        gzsetparams                              @35
+        zError                                   @36
+        inflateSyncPoint                         @37
+        get_crc_table                            @38
+        compress2                                @39
+        gzputs                                   @40
+        gzgets                                   @41
+        inflateCopy                              @42
+        inflateBackInit_                         @43
+        inflateBack                              @44
+        inflateBackEnd                           @45
+        compressBound                            @46
+        deflateBound                             @47
+        gzclearerr                               @48
+        gzungetc                                 @49
+        zlibCompileFlags                         @50
+        deflatePrime                             @51
+        deflatePending                           @52
+
+        unzOpen                                  @61
+        unzClose                                 @62
+        unzGetGlobalInfo                         @63
+        unzGetCurrentFileInfo                    @64
+        unzGoToFirstFile                         @65
+        unzGoToNextFile                          @66
+        unzOpenCurrentFile                       @67
+        unzReadCurrentFile                       @68
+        unzOpenCurrentFile3                      @69
+        unztell                                  @70
+        unzeof                                   @71
+        unzCloseCurrentFile                      @72
+        unzGetGlobalComment                      @73
+        unzStringFileNameCompare                 @74
+        unzLocateFile                            @75
+        unzGetLocalExtrafield                    @76
+        unzOpen2                                 @77
+        unzOpenCurrentFile2                      @78
+        unzOpenCurrentFilePassword               @79
+
+        zipOpen                                  @80
+        zipOpenNewFileInZip                      @81
+        zipWriteInFileInZip                      @82
+        zipCloseFileInZip                        @83
+        zipClose                                 @84
+        zipOpenNewFileInZip2                     @86
+        zipCloseFileInZipRaw                     @87
+        zipOpen2                                 @88
+        zipOpenNewFileInZip3                     @89
+
+        unzGetFilePos                            @100
+        unzGoToFilePos                           @101
+
+        fill_win32_filefunc                      @110
+
+; zlibwapi v1.2.4 added:
+        fill_win32_filefunc64                   @111
+        fill_win32_filefunc64A                  @112
+        fill_win32_filefunc64W                  @113
+
+        unzOpen64                               @120
+        unzOpen2_64                             @121
+        unzGetGlobalInfo64                      @122
+        unzGetCurrentFileInfo64                 @124
+        unzGetCurrentFileZStreamPos64           @125
+        unztell64                               @126
+        unzGetFilePos64                         @127
+        unzGoToFilePos64                        @128
+
+        zipOpen64                               @130
+        zipOpen2_64                             @131
+        zipOpenNewFileInZip64                   @132
+        zipOpenNewFileInZip2_64                 @133
+        zipOpenNewFileInZip3_64                 @134
+        zipOpenNewFileInZip4_64                 @135
+        zipCloseFileInZipRaw64                  @136
+
+; zlib1 v1.2.4 added:
+        adler32_combine                         @140
+        crc32_combine                           @142
+        deflateSetHeader                        @144
+        deflateTune                             @145
+        gzbuffer                                @146
+        gzclose_r                               @147
+        gzclose_w                               @148
+        gzdirect                                @149
+        gzoffset                                @150
+        inflateGetHeader                        @156
+        inflateMark                             @157
+        inflatePrime                            @158
+        inflateReset2                           @159
+        inflateUndermine                        @160
+
+; zlib1 v1.2.6 added:
+        gzgetc_                                 @161
+        inflateResetKeep                        @163
+        deflateResetKeep                        @164
+
+; zlib1 v1.2.7 added:
+        gzopen_w                                @165
+
+; zlib1 v1.2.8 added:
+        inflateGetDictionary                    @166
+        gzvprintf                               @167
+
+; zlib1 v1.2.9 added:
+        inflateCodesUsed                        @168
+        inflateValidate                         @169
+        uncompress2                             @170
+        gzfread                                 @171
+        gzfwrite                                @172
+        deflateGetDictionary                    @173
+        adler32_z                               @174
+        crc32_z                                 @175
diff --git a/Engine/lib/assimp/contrib/zlib/crc32.c b/Engine/lib/assimp/contrib/zlib/crc32.c
new file mode 100644
index 000000000..e72636a50
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/crc32.c
@@ -0,0 +1,442 @@
+/* crc32.c -- compute the CRC-32 of a data stream
+ * Copyright (C) 1995-2006, 2010, 2011, 2012, 2016 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ *
+ * Thanks to Rodney Brown <rbrown64@csc.com.au> for his contribution of faster
+ * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing
+ * tables for updating the shift register in one step with three exclusive-ors
+ * instead of four steps with four exclusive-ors.  This results in about a
+ * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3.
+ */
+
+/* @(#) $Id$ */
+
+/*
+  Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore
+  protection on the static variables used to control the first-use generation
+  of the crc tables.  Therefore, if you #define DYNAMIC_CRC_TABLE, you should
+  first call get_crc_table() to initialize the tables before allowing more than
+  one thread to use crc32().
+
+  DYNAMIC_CRC_TABLE and MAKECRCH can be #defined to write out crc32.h.
+ */
+
+#ifdef MAKECRCH
+#  include <stdio.h>
+#  ifndef DYNAMIC_CRC_TABLE
+#    define DYNAMIC_CRC_TABLE
+#  endif /* !DYNAMIC_CRC_TABLE */
+#endif /* MAKECRCH */
+
+#include "zutil.h"      /* for STDC and FAR definitions */
+
+/* Definitions for doing the crc four data bytes at a time. */
+#if !defined(NOBYFOUR) && defined(Z_U4)
+#  define BYFOUR
+#endif
+#ifdef BYFOUR
+   local unsigned long crc32_little OF((unsigned long,
+                        const unsigned char FAR *, z_size_t));
+   local unsigned long crc32_big OF((unsigned long,
+                        const unsigned char FAR *, z_size_t));
+#  define TBLS 8
+#else
+#  define TBLS 1
+#endif /* BYFOUR */
+
+/* Local functions for crc concatenation */
+local unsigned long gf2_matrix_times OF((unsigned long *mat,
+                                         unsigned long vec));
+local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat));
+local uLong crc32_combine_ OF((uLong crc1, uLong crc2, z_off64_t len2));
+
+
+#ifdef DYNAMIC_CRC_TABLE
+
+local volatile int crc_table_empty = 1;
+local z_crc_t FAR crc_table[TBLS][256];
+local void make_crc_table OF((void));
+#ifdef MAKECRCH
+   local void write_table OF((FILE *, const z_crc_t FAR *));
+#endif /* MAKECRCH */
+/*
+  Generate tables for a byte-wise 32-bit CRC calculation on the polynomial:
+  x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
+
+  Polynomials over GF(2) are represented in binary, one bit per coefficient,
+  with the lowest powers in the most significant bit.  Then adding polynomials
+  is just exclusive-or, and multiplying a polynomial by x is a right shift by
+  one.  If we call the above polynomial p, and represent a byte as the
+  polynomial q, also with the lowest power in the most significant bit (so the
+  byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,
+  where a mod b means the remainder after dividing a by b.
+
+  This calculation is done using the shift-register method of multiplying and
+  taking the remainder.  The register is initialized to zero, and for each
+  incoming bit, x^32 is added mod p to the register if the bit is a one (where
+  x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by
+  x (which is shifting right by one and adding x^32 mod p if the bit shifted
+  out is a one).  We start with the highest power (least significant bit) of
+  q and repeat for all eight bits of q.
+
+  The first table is simply the CRC of all possible eight bit values.  This is
+  all the information needed to generate CRCs on data a byte at a time for all
+  combinations of CRC register values and incoming bytes.  The remaining tables
+  allow for word-at-a-time CRC calculation for both big-endian and little-
+  endian machines, where a word is four bytes.
+*/
+local void make_crc_table()
+{
+    z_crc_t c;
+    int n, k;
+    z_crc_t poly;                       /* polynomial exclusive-or pattern */
+    /* terms of polynomial defining this crc (except x^32): */
+    static volatile int first = 1;      /* flag to limit concurrent making */
+    static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
+
+    /* See if another task is already doing this (not thread-safe, but better
+       than nothing -- significantly reduces duration of vulnerability in
+       case the advice about DYNAMIC_CRC_TABLE is ignored) */
+    if (first) {
+        first = 0;
+
+        /* make exclusive-or pattern from polynomial (0xedb88320UL) */
+        poly = 0;
+        for (n = 0; n < (int)(sizeof(p)/sizeof(unsigned char)); n++)
+            poly |= (z_crc_t)1 << (31 - p[n]);
+
+        /* generate a crc for every 8-bit value */
+        for (n = 0; n < 256; n++) {
+            c = (z_crc_t)n;
+            for (k = 0; k < 8; k++)
+                c = c & 1 ? poly ^ (c >> 1) : c >> 1;
+            crc_table[0][n] = c;
+        }
+
+#ifdef BYFOUR
+        /* generate crc for each value followed by one, two, and three zeros,
+           and then the byte reversal of those as well as the first table */
+        for (n = 0; n < 256; n++) {
+            c = crc_table[0][n];
+            crc_table[4][n] = ZSWAP32(c);
+            for (k = 1; k < 4; k++) {
+                c = crc_table[0][c & 0xff] ^ (c >> 8);
+                crc_table[k][n] = c;
+                crc_table[k + 4][n] = ZSWAP32(c);
+            }
+        }
+#endif /* BYFOUR */
+
+        crc_table_empty = 0;
+    }
+    else {      /* not first */
+        /* wait for the other guy to finish (not efficient, but rare) */
+        while (crc_table_empty)
+            ;
+    }
+
+#ifdef MAKECRCH
+    /* write out CRC tables to crc32.h */
+    {
+        FILE *out;
+
+        out = fopen("crc32.h", "w");
+        if (out == NULL) return;
+        fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n");
+        fprintf(out, " * Generated automatically by crc32.c\n */\n\n");
+        fprintf(out, "local const z_crc_t FAR ");
+        fprintf(out, "crc_table[TBLS][256] =\n{\n  {\n");
+        write_table(out, crc_table[0]);
+#  ifdef BYFOUR
+        fprintf(out, "#ifdef BYFOUR\n");
+        for (k = 1; k < 8; k++) {
+            fprintf(out, "  },\n  {\n");
+            write_table(out, crc_table[k]);
+        }
+        fprintf(out, "#endif\n");
+#  endif /* BYFOUR */
+        fprintf(out, "  }\n};\n");
+        fclose(out);
+    }
+#endif /* MAKECRCH */
+}
+
+#ifdef MAKECRCH
+local void write_table(out, table)
+    FILE *out;
+    const z_crc_t FAR *table;
+{
+    int n;
+
+    for (n = 0; n < 256; n++)
+        fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : "    ",
+                (unsigned long)(table[n]),
+                n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", "));
+}
+#endif /* MAKECRCH */
+
+#else /* !DYNAMIC_CRC_TABLE */
+/* ========================================================================
+ * Tables of CRC-32s of all single-byte values, made by make_crc_table().
+ */
+#include "crc32.h"
+#endif /* DYNAMIC_CRC_TABLE */
+
+/* =========================================================================
+ * This function can be used by asm versions of crc32()
+ */
+const z_crc_t FAR * ZEXPORT get_crc_table()
+{
+#ifdef DYNAMIC_CRC_TABLE
+    if (crc_table_empty)
+        make_crc_table();
+#endif /* DYNAMIC_CRC_TABLE */
+    return (const z_crc_t FAR *)crc_table;
+}
+
+/* ========================================================================= */
+#define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8)
+#define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1
+
+/* ========================================================================= */
+unsigned long ZEXPORT crc32_z(crc, buf, len)
+    unsigned long crc;
+    const unsigned char FAR *buf;
+    z_size_t len;
+{
+    if (buf == Z_NULL) return 0UL;
+
+#ifdef DYNAMIC_CRC_TABLE
+    if (crc_table_empty)
+        make_crc_table();
+#endif /* DYNAMIC_CRC_TABLE */
+
+#ifdef BYFOUR
+    if (sizeof(void *) == sizeof(z_size_t)) {
+        z_crc_t endian;
+
+        endian = 1;
+        if (*((unsigned char *)(&endian)))
+            return crc32_little(crc, buf, len);
+        else
+            return crc32_big(crc, buf, len);
+    }
+#endif /* BYFOUR */
+    crc = crc ^ 0xffffffffUL;
+    while (len >= 8) {
+        DO8;
+        len -= 8;
+    }
+    if (len) do {
+        DO1;
+    } while (--len);
+    return crc ^ 0xffffffffUL;
+}
+
+/* ========================================================================= */
+unsigned long ZEXPORT crc32(crc, buf, len)
+    unsigned long crc;
+    const unsigned char FAR *buf;
+    uInt len;
+{
+    return crc32_z(crc, buf, len);
+}
+
+#ifdef BYFOUR
+
+/*
+   This BYFOUR code accesses the passed unsigned char * buffer with a 32-bit
+   integer pointer type. This violates the strict aliasing rule, where a
+   compiler can assume, for optimization purposes, that two pointers to
+   fundamentally different types won't ever point to the same memory. This can
+   manifest as a problem only if one of the pointers is written to. This code
+   only reads from those pointers. So long as this code remains isolated in
+   this compilation unit, there won't be a problem. For this reason, this code
+   should not be copied and pasted into a compilation unit in which other code
+   writes to the buffer that is passed to these routines.
+ */
+
+/* ========================================================================= */
+#define DOLIT4 c ^= *buf4++; \
+        c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \
+            crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24]
+#define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4
+
+/* ========================================================================= */
+local unsigned long crc32_little(crc, buf, len)
+    unsigned long crc;
+    const unsigned char FAR *buf;
+    z_size_t len;
+{
+    register z_crc_t c;
+    register const z_crc_t FAR *buf4;
+
+    c = (z_crc_t)crc;
+    c = ~c;
+    while (len && ((z_size_t)buf & 3)) {
+        c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
+        len--;
+    }
+
+    buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
+    while (len >= 32) {
+        DOLIT32;
+        len -= 32;
+    }
+    while (len >= 4) {
+        DOLIT4;
+        len -= 4;
+    }
+    buf = (const unsigned char FAR *)buf4;
+
+    if (len) do {
+        c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
+    } while (--len);
+    c = ~c;
+    return (unsigned long)c;
+}
+
+/* ========================================================================= */
+#define DOBIG4 c ^= *buf4++; \
+        c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \
+            crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24]
+#define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4
+
+/* ========================================================================= */
+local unsigned long crc32_big(crc, buf, len)
+    unsigned long crc;
+    const unsigned char FAR *buf;
+    z_size_t len;
+{
+    register z_crc_t c;
+    register const z_crc_t FAR *buf4;
+
+    c = ZSWAP32((z_crc_t)crc);
+    c = ~c;
+    while (len && ((z_size_t)buf & 3)) {
+        c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
+        len--;
+    }
+
+    buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
+    while (len >= 32) {
+        DOBIG32;
+        len -= 32;
+    }
+    while (len >= 4) {
+        DOBIG4;
+        len -= 4;
+    }
+    buf = (const unsigned char FAR *)buf4;
+
+    if (len) do {
+        c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
+    } while (--len);
+    c = ~c;
+    return (unsigned long)(ZSWAP32(c));
+}
+
+#endif /* BYFOUR */
+
+#define GF2_DIM 32      /* dimension of GF(2) vectors (length of CRC) */
+
+/* ========================================================================= */
+local unsigned long gf2_matrix_times(mat, vec)
+    unsigned long *mat;
+    unsigned long vec;
+{
+    unsigned long sum;
+
+    sum = 0;
+    while (vec) {
+        if (vec & 1)
+            sum ^= *mat;
+        vec >>= 1;
+        mat++;
+    }
+    return sum;
+}
+
+/* ========================================================================= */
+local void gf2_matrix_square(square, mat)
+    unsigned long *square;
+    unsigned long *mat;
+{
+    int n;
+
+    for (n = 0; n < GF2_DIM; n++)
+        square[n] = gf2_matrix_times(mat, mat[n]);
+}
+
+/* ========================================================================= */
+local uLong crc32_combine_(crc1, crc2, len2)
+    uLong crc1;
+    uLong crc2;
+    z_off64_t len2;
+{
+    int n;
+    unsigned long row;
+    unsigned long even[GF2_DIM];    /* even-power-of-two zeros operator */
+    unsigned long odd[GF2_DIM];     /* odd-power-of-two zeros operator */
+
+    /* degenerate case (also disallow negative lengths) */
+    if (len2 <= 0)
+        return crc1;
+
+    /* put operator for one zero bit in odd */
+    odd[0] = 0xedb88320UL;          /* CRC-32 polynomial */
+    row = 1;
+    for (n = 1; n < GF2_DIM; n++) {
+        odd[n] = row;
+        row <<= 1;
+    }
+
+    /* put operator for two zero bits in even */
+    gf2_matrix_square(even, odd);
+
+    /* put operator for four zero bits in odd */
+    gf2_matrix_square(odd, even);
+
+    /* apply len2 zeros to crc1 (first square will put the operator for one
+       zero byte, eight zero bits, in even) */
+    do {
+        /* apply zeros operator for this bit of len2 */
+        gf2_matrix_square(even, odd);
+        if (len2 & 1)
+            crc1 = gf2_matrix_times(even, crc1);
+        len2 >>= 1;
+
+        /* if no more bits set, then done */
+        if (len2 == 0)
+            break;
+
+        /* another iteration of the loop with odd and even swapped */
+        gf2_matrix_square(odd, even);
+        if (len2 & 1)
+            crc1 = gf2_matrix_times(odd, crc1);
+        len2 >>= 1;
+
+        /* if no more bits set, then done */
+    } while (len2 != 0);
+
+    /* return combined crc */
+    crc1 ^= crc2;
+    return crc1;
+}
+
+/* ========================================================================= */
+uLong ZEXPORT crc32_combine(crc1, crc2, len2)
+    uLong crc1;
+    uLong crc2;
+    z_off_t len2;
+{
+    return crc32_combine_(crc1, crc2, len2);
+}
+
+uLong ZEXPORT crc32_combine64(crc1, crc2, len2)
+    uLong crc1;
+    uLong crc2;
+    z_off64_t len2;
+{
+    return crc32_combine_(crc1, crc2, len2);
+}
diff --git a/Engine/lib/assimp/contrib/zlib/crc32.h b/Engine/lib/assimp/contrib/zlib/crc32.h
new file mode 100644
index 000000000..9e0c77810
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/crc32.h
@@ -0,0 +1,441 @@
+/* crc32.h -- tables for rapid CRC calculation
+ * Generated automatically by crc32.c
+ */
+
+local const z_crc_t FAR crc_table[TBLS][256] =
+{
+  {
+    0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
+    0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
+    0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
+    0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
+    0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
+    0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
+    0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
+    0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
+    0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
+    0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
+    0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
+    0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
+    0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
+    0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
+    0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
+    0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
+    0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
+    0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
+    0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
+    0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
+    0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
+    0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
+    0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
+    0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
+    0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
+    0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
+    0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
+    0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
+    0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
+    0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
+    0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
+    0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
+    0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
+    0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
+    0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
+    0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
+    0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
+    0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
+    0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
+    0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
+    0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
+    0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
+    0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
+    0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
+    0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
+    0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
+    0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
+    0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
+    0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
+    0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
+    0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
+    0x2d02ef8dUL
+#ifdef BYFOUR
+  },
+  {
+    0x00000000UL, 0x191b3141UL, 0x32366282UL, 0x2b2d53c3UL, 0x646cc504UL,
+    0x7d77f445UL, 0x565aa786UL, 0x4f4196c7UL, 0xc8d98a08UL, 0xd1c2bb49UL,
+    0xfaefe88aUL, 0xe3f4d9cbUL, 0xacb54f0cUL, 0xb5ae7e4dUL, 0x9e832d8eUL,
+    0x87981ccfUL, 0x4ac21251UL, 0x53d92310UL, 0x78f470d3UL, 0x61ef4192UL,
+    0x2eaed755UL, 0x37b5e614UL, 0x1c98b5d7UL, 0x05838496UL, 0x821b9859UL,
+    0x9b00a918UL, 0xb02dfadbUL, 0xa936cb9aUL, 0xe6775d5dUL, 0xff6c6c1cUL,
+    0xd4413fdfUL, 0xcd5a0e9eUL, 0x958424a2UL, 0x8c9f15e3UL, 0xa7b24620UL,
+    0xbea97761UL, 0xf1e8e1a6UL, 0xe8f3d0e7UL, 0xc3de8324UL, 0xdac5b265UL,
+    0x5d5daeaaUL, 0x44469febUL, 0x6f6bcc28UL, 0x7670fd69UL, 0x39316baeUL,
+    0x202a5aefUL, 0x0b07092cUL, 0x121c386dUL, 0xdf4636f3UL, 0xc65d07b2UL,
+    0xed705471UL, 0xf46b6530UL, 0xbb2af3f7UL, 0xa231c2b6UL, 0x891c9175UL,
+    0x9007a034UL, 0x179fbcfbUL, 0x0e848dbaUL, 0x25a9de79UL, 0x3cb2ef38UL,
+    0x73f379ffUL, 0x6ae848beUL, 0x41c51b7dUL, 0x58de2a3cUL, 0xf0794f05UL,
+    0xe9627e44UL, 0xc24f2d87UL, 0xdb541cc6UL, 0x94158a01UL, 0x8d0ebb40UL,
+    0xa623e883UL, 0xbf38d9c2UL, 0x38a0c50dUL, 0x21bbf44cUL, 0x0a96a78fUL,
+    0x138d96ceUL, 0x5ccc0009UL, 0x45d73148UL, 0x6efa628bUL, 0x77e153caUL,
+    0xbabb5d54UL, 0xa3a06c15UL, 0x888d3fd6UL, 0x91960e97UL, 0xded79850UL,
+    0xc7cca911UL, 0xece1fad2UL, 0xf5facb93UL, 0x7262d75cUL, 0x6b79e61dUL,
+    0x4054b5deUL, 0x594f849fUL, 0x160e1258UL, 0x0f152319UL, 0x243870daUL,
+    0x3d23419bUL, 0x65fd6ba7UL, 0x7ce65ae6UL, 0x57cb0925UL, 0x4ed03864UL,
+    0x0191aea3UL, 0x188a9fe2UL, 0x33a7cc21UL, 0x2abcfd60UL, 0xad24e1afUL,
+    0xb43fd0eeUL, 0x9f12832dUL, 0x8609b26cUL, 0xc94824abUL, 0xd05315eaUL,
+    0xfb7e4629UL, 0xe2657768UL, 0x2f3f79f6UL, 0x362448b7UL, 0x1d091b74UL,
+    0x04122a35UL, 0x4b53bcf2UL, 0x52488db3UL, 0x7965de70UL, 0x607eef31UL,
+    0xe7e6f3feUL, 0xfefdc2bfUL, 0xd5d0917cUL, 0xcccba03dUL, 0x838a36faUL,
+    0x9a9107bbUL, 0xb1bc5478UL, 0xa8a76539UL, 0x3b83984bUL, 0x2298a90aUL,
+    0x09b5fac9UL, 0x10aecb88UL, 0x5fef5d4fUL, 0x46f46c0eUL, 0x6dd93fcdUL,
+    0x74c20e8cUL, 0xf35a1243UL, 0xea412302UL, 0xc16c70c1UL, 0xd8774180UL,
+    0x9736d747UL, 0x8e2de606UL, 0xa500b5c5UL, 0xbc1b8484UL, 0x71418a1aUL,
+    0x685abb5bUL, 0x4377e898UL, 0x5a6cd9d9UL, 0x152d4f1eUL, 0x0c367e5fUL,
+    0x271b2d9cUL, 0x3e001cddUL, 0xb9980012UL, 0xa0833153UL, 0x8bae6290UL,
+    0x92b553d1UL, 0xddf4c516UL, 0xc4eff457UL, 0xefc2a794UL, 0xf6d996d5UL,
+    0xae07bce9UL, 0xb71c8da8UL, 0x9c31de6bUL, 0x852aef2aUL, 0xca6b79edUL,
+    0xd37048acUL, 0xf85d1b6fUL, 0xe1462a2eUL, 0x66de36e1UL, 0x7fc507a0UL,
+    0x54e85463UL, 0x4df36522UL, 0x02b2f3e5UL, 0x1ba9c2a4UL, 0x30849167UL,
+    0x299fa026UL, 0xe4c5aeb8UL, 0xfdde9ff9UL, 0xd6f3cc3aUL, 0xcfe8fd7bUL,
+    0x80a96bbcUL, 0x99b25afdUL, 0xb29f093eUL, 0xab84387fUL, 0x2c1c24b0UL,
+    0x350715f1UL, 0x1e2a4632UL, 0x07317773UL, 0x4870e1b4UL, 0x516bd0f5UL,
+    0x7a468336UL, 0x635db277UL, 0xcbfad74eUL, 0xd2e1e60fUL, 0xf9ccb5ccUL,
+    0xe0d7848dUL, 0xaf96124aUL, 0xb68d230bUL, 0x9da070c8UL, 0x84bb4189UL,
+    0x03235d46UL, 0x1a386c07UL, 0x31153fc4UL, 0x280e0e85UL, 0x674f9842UL,
+    0x7e54a903UL, 0x5579fac0UL, 0x4c62cb81UL, 0x8138c51fUL, 0x9823f45eUL,
+    0xb30ea79dUL, 0xaa1596dcUL, 0xe554001bUL, 0xfc4f315aUL, 0xd7626299UL,
+    0xce7953d8UL, 0x49e14f17UL, 0x50fa7e56UL, 0x7bd72d95UL, 0x62cc1cd4UL,
+    0x2d8d8a13UL, 0x3496bb52UL, 0x1fbbe891UL, 0x06a0d9d0UL, 0x5e7ef3ecUL,
+    0x4765c2adUL, 0x6c48916eUL, 0x7553a02fUL, 0x3a1236e8UL, 0x230907a9UL,
+    0x0824546aUL, 0x113f652bUL, 0x96a779e4UL, 0x8fbc48a5UL, 0xa4911b66UL,
+    0xbd8a2a27UL, 0xf2cbbce0UL, 0xebd08da1UL, 0xc0fdde62UL, 0xd9e6ef23UL,
+    0x14bce1bdUL, 0x0da7d0fcUL, 0x268a833fUL, 0x3f91b27eUL, 0x70d024b9UL,
+    0x69cb15f8UL, 0x42e6463bUL, 0x5bfd777aUL, 0xdc656bb5UL, 0xc57e5af4UL,
+    0xee530937UL, 0xf7483876UL, 0xb809aeb1UL, 0xa1129ff0UL, 0x8a3fcc33UL,
+    0x9324fd72UL
+  },
+  {
+    0x00000000UL, 0x01c26a37UL, 0x0384d46eUL, 0x0246be59UL, 0x0709a8dcUL,
+    0x06cbc2ebUL, 0x048d7cb2UL, 0x054f1685UL, 0x0e1351b8UL, 0x0fd13b8fUL,
+    0x0d9785d6UL, 0x0c55efe1UL, 0x091af964UL, 0x08d89353UL, 0x0a9e2d0aUL,
+    0x0b5c473dUL, 0x1c26a370UL, 0x1de4c947UL, 0x1fa2771eUL, 0x1e601d29UL,
+    0x1b2f0bacUL, 0x1aed619bUL, 0x18abdfc2UL, 0x1969b5f5UL, 0x1235f2c8UL,
+    0x13f798ffUL, 0x11b126a6UL, 0x10734c91UL, 0x153c5a14UL, 0x14fe3023UL,
+    0x16b88e7aUL, 0x177ae44dUL, 0x384d46e0UL, 0x398f2cd7UL, 0x3bc9928eUL,
+    0x3a0bf8b9UL, 0x3f44ee3cUL, 0x3e86840bUL, 0x3cc03a52UL, 0x3d025065UL,
+    0x365e1758UL, 0x379c7d6fUL, 0x35dac336UL, 0x3418a901UL, 0x3157bf84UL,
+    0x3095d5b3UL, 0x32d36beaUL, 0x331101ddUL, 0x246be590UL, 0x25a98fa7UL,
+    0x27ef31feUL, 0x262d5bc9UL, 0x23624d4cUL, 0x22a0277bUL, 0x20e69922UL,
+    0x2124f315UL, 0x2a78b428UL, 0x2bbade1fUL, 0x29fc6046UL, 0x283e0a71UL,
+    0x2d711cf4UL, 0x2cb376c3UL, 0x2ef5c89aUL, 0x2f37a2adUL, 0x709a8dc0UL,
+    0x7158e7f7UL, 0x731e59aeUL, 0x72dc3399UL, 0x7793251cUL, 0x76514f2bUL,
+    0x7417f172UL, 0x75d59b45UL, 0x7e89dc78UL, 0x7f4bb64fUL, 0x7d0d0816UL,
+    0x7ccf6221UL, 0x798074a4UL, 0x78421e93UL, 0x7a04a0caUL, 0x7bc6cafdUL,
+    0x6cbc2eb0UL, 0x6d7e4487UL, 0x6f38fadeUL, 0x6efa90e9UL, 0x6bb5866cUL,
+    0x6a77ec5bUL, 0x68315202UL, 0x69f33835UL, 0x62af7f08UL, 0x636d153fUL,
+    0x612bab66UL, 0x60e9c151UL, 0x65a6d7d4UL, 0x6464bde3UL, 0x662203baUL,
+    0x67e0698dUL, 0x48d7cb20UL, 0x4915a117UL, 0x4b531f4eUL, 0x4a917579UL,
+    0x4fde63fcUL, 0x4e1c09cbUL, 0x4c5ab792UL, 0x4d98dda5UL, 0x46c49a98UL,
+    0x4706f0afUL, 0x45404ef6UL, 0x448224c1UL, 0x41cd3244UL, 0x400f5873UL,
+    0x4249e62aUL, 0x438b8c1dUL, 0x54f16850UL, 0x55330267UL, 0x5775bc3eUL,
+    0x56b7d609UL, 0x53f8c08cUL, 0x523aaabbUL, 0x507c14e2UL, 0x51be7ed5UL,
+    0x5ae239e8UL, 0x5b2053dfUL, 0x5966ed86UL, 0x58a487b1UL, 0x5deb9134UL,
+    0x5c29fb03UL, 0x5e6f455aUL, 0x5fad2f6dUL, 0xe1351b80UL, 0xe0f771b7UL,
+    0xe2b1cfeeUL, 0xe373a5d9UL, 0xe63cb35cUL, 0xe7fed96bUL, 0xe5b86732UL,
+    0xe47a0d05UL, 0xef264a38UL, 0xeee4200fUL, 0xeca29e56UL, 0xed60f461UL,
+    0xe82fe2e4UL, 0xe9ed88d3UL, 0xebab368aUL, 0xea695cbdUL, 0xfd13b8f0UL,
+    0xfcd1d2c7UL, 0xfe976c9eUL, 0xff5506a9UL, 0xfa1a102cUL, 0xfbd87a1bUL,
+    0xf99ec442UL, 0xf85cae75UL, 0xf300e948UL, 0xf2c2837fUL, 0xf0843d26UL,
+    0xf1465711UL, 0xf4094194UL, 0xf5cb2ba3UL, 0xf78d95faUL, 0xf64fffcdUL,
+    0xd9785d60UL, 0xd8ba3757UL, 0xdafc890eUL, 0xdb3ee339UL, 0xde71f5bcUL,
+    0xdfb39f8bUL, 0xddf521d2UL, 0xdc374be5UL, 0xd76b0cd8UL, 0xd6a966efUL,
+    0xd4efd8b6UL, 0xd52db281UL, 0xd062a404UL, 0xd1a0ce33UL, 0xd3e6706aUL,
+    0xd2241a5dUL, 0xc55efe10UL, 0xc49c9427UL, 0xc6da2a7eUL, 0xc7184049UL,
+    0xc25756ccUL, 0xc3953cfbUL, 0xc1d382a2UL, 0xc011e895UL, 0xcb4dafa8UL,
+    0xca8fc59fUL, 0xc8c97bc6UL, 0xc90b11f1UL, 0xcc440774UL, 0xcd866d43UL,
+    0xcfc0d31aUL, 0xce02b92dUL, 0x91af9640UL, 0x906dfc77UL, 0x922b422eUL,
+    0x93e92819UL, 0x96a63e9cUL, 0x976454abUL, 0x9522eaf2UL, 0x94e080c5UL,
+    0x9fbcc7f8UL, 0x9e7eadcfUL, 0x9c381396UL, 0x9dfa79a1UL, 0x98b56f24UL,
+    0x99770513UL, 0x9b31bb4aUL, 0x9af3d17dUL, 0x8d893530UL, 0x8c4b5f07UL,
+    0x8e0de15eUL, 0x8fcf8b69UL, 0x8a809decUL, 0x8b42f7dbUL, 0x89044982UL,
+    0x88c623b5UL, 0x839a6488UL, 0x82580ebfUL, 0x801eb0e6UL, 0x81dcdad1UL,
+    0x8493cc54UL, 0x8551a663UL, 0x8717183aUL, 0x86d5720dUL, 0xa9e2d0a0UL,
+    0xa820ba97UL, 0xaa6604ceUL, 0xaba46ef9UL, 0xaeeb787cUL, 0xaf29124bUL,
+    0xad6fac12UL, 0xacadc625UL, 0xa7f18118UL, 0xa633eb2fUL, 0xa4755576UL,
+    0xa5b73f41UL, 0xa0f829c4UL, 0xa13a43f3UL, 0xa37cfdaaUL, 0xa2be979dUL,
+    0xb5c473d0UL, 0xb40619e7UL, 0xb640a7beUL, 0xb782cd89UL, 0xb2cddb0cUL,
+    0xb30fb13bUL, 0xb1490f62UL, 0xb08b6555UL, 0xbbd72268UL, 0xba15485fUL,
+    0xb853f606UL, 0xb9919c31UL, 0xbcde8ab4UL, 0xbd1ce083UL, 0xbf5a5edaUL,
+    0xbe9834edUL
+  },
+  {
+    0x00000000UL, 0xb8bc6765UL, 0xaa09c88bUL, 0x12b5afeeUL, 0x8f629757UL,
+    0x37def032UL, 0x256b5fdcUL, 0x9dd738b9UL, 0xc5b428efUL, 0x7d084f8aUL,
+    0x6fbde064UL, 0xd7018701UL, 0x4ad6bfb8UL, 0xf26ad8ddUL, 0xe0df7733UL,
+    0x58631056UL, 0x5019579fUL, 0xe8a530faUL, 0xfa109f14UL, 0x42acf871UL,
+    0xdf7bc0c8UL, 0x67c7a7adUL, 0x75720843UL, 0xcdce6f26UL, 0x95ad7f70UL,
+    0x2d111815UL, 0x3fa4b7fbUL, 0x8718d09eUL, 0x1acfe827UL, 0xa2738f42UL,
+    0xb0c620acUL, 0x087a47c9UL, 0xa032af3eUL, 0x188ec85bUL, 0x0a3b67b5UL,
+    0xb28700d0UL, 0x2f503869UL, 0x97ec5f0cUL, 0x8559f0e2UL, 0x3de59787UL,
+    0x658687d1UL, 0xdd3ae0b4UL, 0xcf8f4f5aUL, 0x7733283fUL, 0xeae41086UL,
+    0x525877e3UL, 0x40edd80dUL, 0xf851bf68UL, 0xf02bf8a1UL, 0x48979fc4UL,
+    0x5a22302aUL, 0xe29e574fUL, 0x7f496ff6UL, 0xc7f50893UL, 0xd540a77dUL,
+    0x6dfcc018UL, 0x359fd04eUL, 0x8d23b72bUL, 0x9f9618c5UL, 0x272a7fa0UL,
+    0xbafd4719UL, 0x0241207cUL, 0x10f48f92UL, 0xa848e8f7UL, 0x9b14583dUL,
+    0x23a83f58UL, 0x311d90b6UL, 0x89a1f7d3UL, 0x1476cf6aUL, 0xaccaa80fUL,
+    0xbe7f07e1UL, 0x06c36084UL, 0x5ea070d2UL, 0xe61c17b7UL, 0xf4a9b859UL,
+    0x4c15df3cUL, 0xd1c2e785UL, 0x697e80e0UL, 0x7bcb2f0eUL, 0xc377486bUL,
+    0xcb0d0fa2UL, 0x73b168c7UL, 0x6104c729UL, 0xd9b8a04cUL, 0x446f98f5UL,
+    0xfcd3ff90UL, 0xee66507eUL, 0x56da371bUL, 0x0eb9274dUL, 0xb6054028UL,
+    0xa4b0efc6UL, 0x1c0c88a3UL, 0x81dbb01aUL, 0x3967d77fUL, 0x2bd27891UL,
+    0x936e1ff4UL, 0x3b26f703UL, 0x839a9066UL, 0x912f3f88UL, 0x299358edUL,
+    0xb4446054UL, 0x0cf80731UL, 0x1e4da8dfUL, 0xa6f1cfbaUL, 0xfe92dfecUL,
+    0x462eb889UL, 0x549b1767UL, 0xec277002UL, 0x71f048bbUL, 0xc94c2fdeUL,
+    0xdbf98030UL, 0x6345e755UL, 0x6b3fa09cUL, 0xd383c7f9UL, 0xc1366817UL,
+    0x798a0f72UL, 0xe45d37cbUL, 0x5ce150aeUL, 0x4e54ff40UL, 0xf6e89825UL,
+    0xae8b8873UL, 0x1637ef16UL, 0x048240f8UL, 0xbc3e279dUL, 0x21e91f24UL,
+    0x99557841UL, 0x8be0d7afUL, 0x335cb0caUL, 0xed59b63bUL, 0x55e5d15eUL,
+    0x47507eb0UL, 0xffec19d5UL, 0x623b216cUL, 0xda874609UL, 0xc832e9e7UL,
+    0x708e8e82UL, 0x28ed9ed4UL, 0x9051f9b1UL, 0x82e4565fUL, 0x3a58313aUL,
+    0xa78f0983UL, 0x1f336ee6UL, 0x0d86c108UL, 0xb53aa66dUL, 0xbd40e1a4UL,
+    0x05fc86c1UL, 0x1749292fUL, 0xaff54e4aUL, 0x322276f3UL, 0x8a9e1196UL,
+    0x982bbe78UL, 0x2097d91dUL, 0x78f4c94bUL, 0xc048ae2eUL, 0xd2fd01c0UL,
+    0x6a4166a5UL, 0xf7965e1cUL, 0x4f2a3979UL, 0x5d9f9697UL, 0xe523f1f2UL,
+    0x4d6b1905UL, 0xf5d77e60UL, 0xe762d18eUL, 0x5fdeb6ebUL, 0xc2098e52UL,
+    0x7ab5e937UL, 0x680046d9UL, 0xd0bc21bcUL, 0x88df31eaUL, 0x3063568fUL,
+    0x22d6f961UL, 0x9a6a9e04UL, 0x07bda6bdUL, 0xbf01c1d8UL, 0xadb46e36UL,
+    0x15080953UL, 0x1d724e9aUL, 0xa5ce29ffUL, 0xb77b8611UL, 0x0fc7e174UL,
+    0x9210d9cdUL, 0x2aacbea8UL, 0x38191146UL, 0x80a57623UL, 0xd8c66675UL,
+    0x607a0110UL, 0x72cfaefeUL, 0xca73c99bUL, 0x57a4f122UL, 0xef189647UL,
+    0xfdad39a9UL, 0x45115eccUL, 0x764dee06UL, 0xcef18963UL, 0xdc44268dUL,
+    0x64f841e8UL, 0xf92f7951UL, 0x41931e34UL, 0x5326b1daUL, 0xeb9ad6bfUL,
+    0xb3f9c6e9UL, 0x0b45a18cUL, 0x19f00e62UL, 0xa14c6907UL, 0x3c9b51beUL,
+    0x842736dbUL, 0x96929935UL, 0x2e2efe50UL, 0x2654b999UL, 0x9ee8defcUL,
+    0x8c5d7112UL, 0x34e11677UL, 0xa9362eceUL, 0x118a49abUL, 0x033fe645UL,
+    0xbb838120UL, 0xe3e09176UL, 0x5b5cf613UL, 0x49e959fdUL, 0xf1553e98UL,
+    0x6c820621UL, 0xd43e6144UL, 0xc68bceaaUL, 0x7e37a9cfUL, 0xd67f4138UL,
+    0x6ec3265dUL, 0x7c7689b3UL, 0xc4caeed6UL, 0x591dd66fUL, 0xe1a1b10aUL,
+    0xf3141ee4UL, 0x4ba87981UL, 0x13cb69d7UL, 0xab770eb2UL, 0xb9c2a15cUL,
+    0x017ec639UL, 0x9ca9fe80UL, 0x241599e5UL, 0x36a0360bUL, 0x8e1c516eUL,
+    0x866616a7UL, 0x3eda71c2UL, 0x2c6fde2cUL, 0x94d3b949UL, 0x090481f0UL,
+    0xb1b8e695UL, 0xa30d497bUL, 0x1bb12e1eUL, 0x43d23e48UL, 0xfb6e592dUL,
+    0xe9dbf6c3UL, 0x516791a6UL, 0xccb0a91fUL, 0x740cce7aUL, 0x66b96194UL,
+    0xde0506f1UL
+  },
+  {
+    0x00000000UL, 0x96300777UL, 0x2c610eeeUL, 0xba510999UL, 0x19c46d07UL,
+    0x8ff46a70UL, 0x35a563e9UL, 0xa395649eUL, 0x3288db0eUL, 0xa4b8dc79UL,
+    0x1ee9d5e0UL, 0x88d9d297UL, 0x2b4cb609UL, 0xbd7cb17eUL, 0x072db8e7UL,
+    0x911dbf90UL, 0x6410b71dUL, 0xf220b06aUL, 0x4871b9f3UL, 0xde41be84UL,
+    0x7dd4da1aUL, 0xebe4dd6dUL, 0x51b5d4f4UL, 0xc785d383UL, 0x56986c13UL,
+    0xc0a86b64UL, 0x7af962fdUL, 0xecc9658aUL, 0x4f5c0114UL, 0xd96c0663UL,
+    0x633d0ffaUL, 0xf50d088dUL, 0xc8206e3bUL, 0x5e10694cUL, 0xe44160d5UL,
+    0x727167a2UL, 0xd1e4033cUL, 0x47d4044bUL, 0xfd850dd2UL, 0x6bb50aa5UL,
+    0xfaa8b535UL, 0x6c98b242UL, 0xd6c9bbdbUL, 0x40f9bcacUL, 0xe36cd832UL,
+    0x755cdf45UL, 0xcf0dd6dcUL, 0x593dd1abUL, 0xac30d926UL, 0x3a00de51UL,
+    0x8051d7c8UL, 0x1661d0bfUL, 0xb5f4b421UL, 0x23c4b356UL, 0x9995bacfUL,
+    0x0fa5bdb8UL, 0x9eb80228UL, 0x0888055fUL, 0xb2d90cc6UL, 0x24e90bb1UL,
+    0x877c6f2fUL, 0x114c6858UL, 0xab1d61c1UL, 0x3d2d66b6UL, 0x9041dc76UL,
+    0x0671db01UL, 0xbc20d298UL, 0x2a10d5efUL, 0x8985b171UL, 0x1fb5b606UL,
+    0xa5e4bf9fUL, 0x33d4b8e8UL, 0xa2c90778UL, 0x34f9000fUL, 0x8ea80996UL,
+    0x18980ee1UL, 0xbb0d6a7fUL, 0x2d3d6d08UL, 0x976c6491UL, 0x015c63e6UL,
+    0xf4516b6bUL, 0x62616c1cUL, 0xd8306585UL, 0x4e0062f2UL, 0xed95066cUL,
+    0x7ba5011bUL, 0xc1f40882UL, 0x57c40ff5UL, 0xc6d9b065UL, 0x50e9b712UL,
+    0xeab8be8bUL, 0x7c88b9fcUL, 0xdf1ddd62UL, 0x492dda15UL, 0xf37cd38cUL,
+    0x654cd4fbUL, 0x5861b24dUL, 0xce51b53aUL, 0x7400bca3UL, 0xe230bbd4UL,
+    0x41a5df4aUL, 0xd795d83dUL, 0x6dc4d1a4UL, 0xfbf4d6d3UL, 0x6ae96943UL,
+    0xfcd96e34UL, 0x468867adUL, 0xd0b860daUL, 0x732d0444UL, 0xe51d0333UL,
+    0x5f4c0aaaUL, 0xc97c0dddUL, 0x3c710550UL, 0xaa410227UL, 0x10100bbeUL,
+    0x86200cc9UL, 0x25b56857UL, 0xb3856f20UL, 0x09d466b9UL, 0x9fe461ceUL,
+    0x0ef9de5eUL, 0x98c9d929UL, 0x2298d0b0UL, 0xb4a8d7c7UL, 0x173db359UL,
+    0x810db42eUL, 0x3b5cbdb7UL, 0xad6cbac0UL, 0x2083b8edUL, 0xb6b3bf9aUL,
+    0x0ce2b603UL, 0x9ad2b174UL, 0x3947d5eaUL, 0xaf77d29dUL, 0x1526db04UL,
+    0x8316dc73UL, 0x120b63e3UL, 0x843b6494UL, 0x3e6a6d0dUL, 0xa85a6a7aUL,
+    0x0bcf0ee4UL, 0x9dff0993UL, 0x27ae000aUL, 0xb19e077dUL, 0x44930ff0UL,
+    0xd2a30887UL, 0x68f2011eUL, 0xfec20669UL, 0x5d5762f7UL, 0xcb676580UL,
+    0x71366c19UL, 0xe7066b6eUL, 0x761bd4feUL, 0xe02bd389UL, 0x5a7ada10UL,
+    0xcc4add67UL, 0x6fdfb9f9UL, 0xf9efbe8eUL, 0x43beb717UL, 0xd58eb060UL,
+    0xe8a3d6d6UL, 0x7e93d1a1UL, 0xc4c2d838UL, 0x52f2df4fUL, 0xf167bbd1UL,
+    0x6757bca6UL, 0xdd06b53fUL, 0x4b36b248UL, 0xda2b0dd8UL, 0x4c1b0aafUL,
+    0xf64a0336UL, 0x607a0441UL, 0xc3ef60dfUL, 0x55df67a8UL, 0xef8e6e31UL,
+    0x79be6946UL, 0x8cb361cbUL, 0x1a8366bcUL, 0xa0d26f25UL, 0x36e26852UL,
+    0x95770cccUL, 0x03470bbbUL, 0xb9160222UL, 0x2f260555UL, 0xbe3bbac5UL,
+    0x280bbdb2UL, 0x925ab42bUL, 0x046ab35cUL, 0xa7ffd7c2UL, 0x31cfd0b5UL,
+    0x8b9ed92cUL, 0x1daede5bUL, 0xb0c2649bUL, 0x26f263ecUL, 0x9ca36a75UL,
+    0x0a936d02UL, 0xa906099cUL, 0x3f360eebUL, 0x85670772UL, 0x13570005UL,
+    0x824abf95UL, 0x147ab8e2UL, 0xae2bb17bUL, 0x381bb60cUL, 0x9b8ed292UL,
+    0x0dbed5e5UL, 0xb7efdc7cUL, 0x21dfdb0bUL, 0xd4d2d386UL, 0x42e2d4f1UL,
+    0xf8b3dd68UL, 0x6e83da1fUL, 0xcd16be81UL, 0x5b26b9f6UL, 0xe177b06fUL,
+    0x7747b718UL, 0xe65a0888UL, 0x706a0fffUL, 0xca3b0666UL, 0x5c0b0111UL,
+    0xff9e658fUL, 0x69ae62f8UL, 0xd3ff6b61UL, 0x45cf6c16UL, 0x78e20aa0UL,
+    0xeed20dd7UL, 0x5483044eUL, 0xc2b30339UL, 0x612667a7UL, 0xf71660d0UL,
+    0x4d476949UL, 0xdb776e3eUL, 0x4a6ad1aeUL, 0xdc5ad6d9UL, 0x660bdf40UL,
+    0xf03bd837UL, 0x53aebca9UL, 0xc59ebbdeUL, 0x7fcfb247UL, 0xe9ffb530UL,
+    0x1cf2bdbdUL, 0x8ac2bacaUL, 0x3093b353UL, 0xa6a3b424UL, 0x0536d0baUL,
+    0x9306d7cdUL, 0x2957de54UL, 0xbf67d923UL, 0x2e7a66b3UL, 0xb84a61c4UL,
+    0x021b685dUL, 0x942b6f2aUL, 0x37be0bb4UL, 0xa18e0cc3UL, 0x1bdf055aUL,
+    0x8def022dUL
+  },
+  {
+    0x00000000UL, 0x41311b19UL, 0x82623632UL, 0xc3532d2bUL, 0x04c56c64UL,
+    0x45f4777dUL, 0x86a75a56UL, 0xc796414fUL, 0x088ad9c8UL, 0x49bbc2d1UL,
+    0x8ae8effaUL, 0xcbd9f4e3UL, 0x0c4fb5acUL, 0x4d7eaeb5UL, 0x8e2d839eUL,
+    0xcf1c9887UL, 0x5112c24aUL, 0x1023d953UL, 0xd370f478UL, 0x9241ef61UL,
+    0x55d7ae2eUL, 0x14e6b537UL, 0xd7b5981cUL, 0x96848305UL, 0x59981b82UL,
+    0x18a9009bUL, 0xdbfa2db0UL, 0x9acb36a9UL, 0x5d5d77e6UL, 0x1c6c6cffUL,
+    0xdf3f41d4UL, 0x9e0e5acdUL, 0xa2248495UL, 0xe3159f8cUL, 0x2046b2a7UL,
+    0x6177a9beUL, 0xa6e1e8f1UL, 0xe7d0f3e8UL, 0x2483dec3UL, 0x65b2c5daUL,
+    0xaaae5d5dUL, 0xeb9f4644UL, 0x28cc6b6fUL, 0x69fd7076UL, 0xae6b3139UL,
+    0xef5a2a20UL, 0x2c09070bUL, 0x6d381c12UL, 0xf33646dfUL, 0xb2075dc6UL,
+    0x715470edUL, 0x30656bf4UL, 0xf7f32abbUL, 0xb6c231a2UL, 0x75911c89UL,
+    0x34a00790UL, 0xfbbc9f17UL, 0xba8d840eUL, 0x79dea925UL, 0x38efb23cUL,
+    0xff79f373UL, 0xbe48e86aUL, 0x7d1bc541UL, 0x3c2ade58UL, 0x054f79f0UL,
+    0x447e62e9UL, 0x872d4fc2UL, 0xc61c54dbUL, 0x018a1594UL, 0x40bb0e8dUL,
+    0x83e823a6UL, 0xc2d938bfUL, 0x0dc5a038UL, 0x4cf4bb21UL, 0x8fa7960aUL,
+    0xce968d13UL, 0x0900cc5cUL, 0x4831d745UL, 0x8b62fa6eUL, 0xca53e177UL,
+    0x545dbbbaUL, 0x156ca0a3UL, 0xd63f8d88UL, 0x970e9691UL, 0x5098d7deUL,
+    0x11a9ccc7UL, 0xd2fae1ecUL, 0x93cbfaf5UL, 0x5cd76272UL, 0x1de6796bUL,
+    0xdeb55440UL, 0x9f844f59UL, 0x58120e16UL, 0x1923150fUL, 0xda703824UL,
+    0x9b41233dUL, 0xa76bfd65UL, 0xe65ae67cUL, 0x2509cb57UL, 0x6438d04eUL,
+    0xa3ae9101UL, 0xe29f8a18UL, 0x21cca733UL, 0x60fdbc2aUL, 0xafe124adUL,
+    0xeed03fb4UL, 0x2d83129fUL, 0x6cb20986UL, 0xab2448c9UL, 0xea1553d0UL,
+    0x29467efbUL, 0x687765e2UL, 0xf6793f2fUL, 0xb7482436UL, 0x741b091dUL,
+    0x352a1204UL, 0xf2bc534bUL, 0xb38d4852UL, 0x70de6579UL, 0x31ef7e60UL,
+    0xfef3e6e7UL, 0xbfc2fdfeUL, 0x7c91d0d5UL, 0x3da0cbccUL, 0xfa368a83UL,
+    0xbb07919aUL, 0x7854bcb1UL, 0x3965a7a8UL, 0x4b98833bUL, 0x0aa99822UL,
+    0xc9fab509UL, 0x88cbae10UL, 0x4f5def5fUL, 0x0e6cf446UL, 0xcd3fd96dUL,
+    0x8c0ec274UL, 0x43125af3UL, 0x022341eaUL, 0xc1706cc1UL, 0x804177d8UL,
+    0x47d73697UL, 0x06e62d8eUL, 0xc5b500a5UL, 0x84841bbcUL, 0x1a8a4171UL,
+    0x5bbb5a68UL, 0x98e87743UL, 0xd9d96c5aUL, 0x1e4f2d15UL, 0x5f7e360cUL,
+    0x9c2d1b27UL, 0xdd1c003eUL, 0x120098b9UL, 0x533183a0UL, 0x9062ae8bUL,
+    0xd153b592UL, 0x16c5f4ddUL, 0x57f4efc4UL, 0x94a7c2efUL, 0xd596d9f6UL,
+    0xe9bc07aeUL, 0xa88d1cb7UL, 0x6bde319cUL, 0x2aef2a85UL, 0xed796bcaUL,
+    0xac4870d3UL, 0x6f1b5df8UL, 0x2e2a46e1UL, 0xe136de66UL, 0xa007c57fUL,
+    0x6354e854UL, 0x2265f34dUL, 0xe5f3b202UL, 0xa4c2a91bUL, 0x67918430UL,
+    0x26a09f29UL, 0xb8aec5e4UL, 0xf99fdefdUL, 0x3accf3d6UL, 0x7bfde8cfUL,
+    0xbc6ba980UL, 0xfd5ab299UL, 0x3e099fb2UL, 0x7f3884abUL, 0xb0241c2cUL,
+    0xf1150735UL, 0x32462a1eUL, 0x73773107UL, 0xb4e17048UL, 0xf5d06b51UL,
+    0x3683467aUL, 0x77b25d63UL, 0x4ed7facbUL, 0x0fe6e1d2UL, 0xccb5ccf9UL,
+    0x8d84d7e0UL, 0x4a1296afUL, 0x0b238db6UL, 0xc870a09dUL, 0x8941bb84UL,
+    0x465d2303UL, 0x076c381aUL, 0xc43f1531UL, 0x850e0e28UL, 0x42984f67UL,
+    0x03a9547eUL, 0xc0fa7955UL, 0x81cb624cUL, 0x1fc53881UL, 0x5ef42398UL,
+    0x9da70eb3UL, 0xdc9615aaUL, 0x1b0054e5UL, 0x5a314ffcUL, 0x996262d7UL,
+    0xd85379ceUL, 0x174fe149UL, 0x567efa50UL, 0x952dd77bUL, 0xd41ccc62UL,
+    0x138a8d2dUL, 0x52bb9634UL, 0x91e8bb1fUL, 0xd0d9a006UL, 0xecf37e5eUL,
+    0xadc26547UL, 0x6e91486cUL, 0x2fa05375UL, 0xe836123aUL, 0xa9070923UL,
+    0x6a542408UL, 0x2b653f11UL, 0xe479a796UL, 0xa548bc8fUL, 0x661b91a4UL,
+    0x272a8abdUL, 0xe0bccbf2UL, 0xa18dd0ebUL, 0x62defdc0UL, 0x23efe6d9UL,
+    0xbde1bc14UL, 0xfcd0a70dUL, 0x3f838a26UL, 0x7eb2913fUL, 0xb924d070UL,
+    0xf815cb69UL, 0x3b46e642UL, 0x7a77fd5bUL, 0xb56b65dcUL, 0xf45a7ec5UL,
+    0x370953eeUL, 0x763848f7UL, 0xb1ae09b8UL, 0xf09f12a1UL, 0x33cc3f8aUL,
+    0x72fd2493UL
+  },
+  {
+    0x00000000UL, 0x376ac201UL, 0x6ed48403UL, 0x59be4602UL, 0xdca80907UL,
+    0xebc2cb06UL, 0xb27c8d04UL, 0x85164f05UL, 0xb851130eUL, 0x8f3bd10fUL,
+    0xd685970dUL, 0xe1ef550cUL, 0x64f91a09UL, 0x5393d808UL, 0x0a2d9e0aUL,
+    0x3d475c0bUL, 0x70a3261cUL, 0x47c9e41dUL, 0x1e77a21fUL, 0x291d601eUL,
+    0xac0b2f1bUL, 0x9b61ed1aUL, 0xc2dfab18UL, 0xf5b56919UL, 0xc8f23512UL,
+    0xff98f713UL, 0xa626b111UL, 0x914c7310UL, 0x145a3c15UL, 0x2330fe14UL,
+    0x7a8eb816UL, 0x4de47a17UL, 0xe0464d38UL, 0xd72c8f39UL, 0x8e92c93bUL,
+    0xb9f80b3aUL, 0x3cee443fUL, 0x0b84863eUL, 0x523ac03cUL, 0x6550023dUL,
+    0x58175e36UL, 0x6f7d9c37UL, 0x36c3da35UL, 0x01a91834UL, 0x84bf5731UL,
+    0xb3d59530UL, 0xea6bd332UL, 0xdd011133UL, 0x90e56b24UL, 0xa78fa925UL,
+    0xfe31ef27UL, 0xc95b2d26UL, 0x4c4d6223UL, 0x7b27a022UL, 0x2299e620UL,
+    0x15f32421UL, 0x28b4782aUL, 0x1fdeba2bUL, 0x4660fc29UL, 0x710a3e28UL,
+    0xf41c712dUL, 0xc376b32cUL, 0x9ac8f52eUL, 0xada2372fUL, 0xc08d9a70UL,
+    0xf7e75871UL, 0xae591e73UL, 0x9933dc72UL, 0x1c259377UL, 0x2b4f5176UL,
+    0x72f11774UL, 0x459bd575UL, 0x78dc897eUL, 0x4fb64b7fUL, 0x16080d7dUL,
+    0x2162cf7cUL, 0xa4748079UL, 0x931e4278UL, 0xcaa0047aUL, 0xfdcac67bUL,
+    0xb02ebc6cUL, 0x87447e6dUL, 0xdefa386fUL, 0xe990fa6eUL, 0x6c86b56bUL,
+    0x5bec776aUL, 0x02523168UL, 0x3538f369UL, 0x087faf62UL, 0x3f156d63UL,
+    0x66ab2b61UL, 0x51c1e960UL, 0xd4d7a665UL, 0xe3bd6464UL, 0xba032266UL,
+    0x8d69e067UL, 0x20cbd748UL, 0x17a11549UL, 0x4e1f534bUL, 0x7975914aUL,
+    0xfc63de4fUL, 0xcb091c4eUL, 0x92b75a4cUL, 0xa5dd984dUL, 0x989ac446UL,
+    0xaff00647UL, 0xf64e4045UL, 0xc1248244UL, 0x4432cd41UL, 0x73580f40UL,
+    0x2ae64942UL, 0x1d8c8b43UL, 0x5068f154UL, 0x67023355UL, 0x3ebc7557UL,
+    0x09d6b756UL, 0x8cc0f853UL, 0xbbaa3a52UL, 0xe2147c50UL, 0xd57ebe51UL,
+    0xe839e25aUL, 0xdf53205bUL, 0x86ed6659UL, 0xb187a458UL, 0x3491eb5dUL,
+    0x03fb295cUL, 0x5a456f5eUL, 0x6d2fad5fUL, 0x801b35e1UL, 0xb771f7e0UL,
+    0xeecfb1e2UL, 0xd9a573e3UL, 0x5cb33ce6UL, 0x6bd9fee7UL, 0x3267b8e5UL,
+    0x050d7ae4UL, 0x384a26efUL, 0x0f20e4eeUL, 0x569ea2ecUL, 0x61f460edUL,
+    0xe4e22fe8UL, 0xd388ede9UL, 0x8a36abebUL, 0xbd5c69eaUL, 0xf0b813fdUL,
+    0xc7d2d1fcUL, 0x9e6c97feUL, 0xa90655ffUL, 0x2c101afaUL, 0x1b7ad8fbUL,
+    0x42c49ef9UL, 0x75ae5cf8UL, 0x48e900f3UL, 0x7f83c2f2UL, 0x263d84f0UL,
+    0x115746f1UL, 0x944109f4UL, 0xa32bcbf5UL, 0xfa958df7UL, 0xcdff4ff6UL,
+    0x605d78d9UL, 0x5737bad8UL, 0x0e89fcdaUL, 0x39e33edbUL, 0xbcf571deUL,
+    0x8b9fb3dfUL, 0xd221f5ddUL, 0xe54b37dcUL, 0xd80c6bd7UL, 0xef66a9d6UL,
+    0xb6d8efd4UL, 0x81b22dd5UL, 0x04a462d0UL, 0x33cea0d1UL, 0x6a70e6d3UL,
+    0x5d1a24d2UL, 0x10fe5ec5UL, 0x27949cc4UL, 0x7e2adac6UL, 0x494018c7UL,
+    0xcc5657c2UL, 0xfb3c95c3UL, 0xa282d3c1UL, 0x95e811c0UL, 0xa8af4dcbUL,
+    0x9fc58fcaUL, 0xc67bc9c8UL, 0xf1110bc9UL, 0x740744ccUL, 0x436d86cdUL,
+    0x1ad3c0cfUL, 0x2db902ceUL, 0x4096af91UL, 0x77fc6d90UL, 0x2e422b92UL,
+    0x1928e993UL, 0x9c3ea696UL, 0xab546497UL, 0xf2ea2295UL, 0xc580e094UL,
+    0xf8c7bc9fUL, 0xcfad7e9eUL, 0x9613389cUL, 0xa179fa9dUL, 0x246fb598UL,
+    0x13057799UL, 0x4abb319bUL, 0x7dd1f39aUL, 0x3035898dUL, 0x075f4b8cUL,
+    0x5ee10d8eUL, 0x698bcf8fUL, 0xec9d808aUL, 0xdbf7428bUL, 0x82490489UL,
+    0xb523c688UL, 0x88649a83UL, 0xbf0e5882UL, 0xe6b01e80UL, 0xd1dadc81UL,
+    0x54cc9384UL, 0x63a65185UL, 0x3a181787UL, 0x0d72d586UL, 0xa0d0e2a9UL,
+    0x97ba20a8UL, 0xce0466aaUL, 0xf96ea4abUL, 0x7c78ebaeUL, 0x4b1229afUL,
+    0x12ac6fadUL, 0x25c6adacUL, 0x1881f1a7UL, 0x2feb33a6UL, 0x765575a4UL,
+    0x413fb7a5UL, 0xc429f8a0UL, 0xf3433aa1UL, 0xaafd7ca3UL, 0x9d97bea2UL,
+    0xd073c4b5UL, 0xe71906b4UL, 0xbea740b6UL, 0x89cd82b7UL, 0x0cdbcdb2UL,
+    0x3bb10fb3UL, 0x620f49b1UL, 0x55658bb0UL, 0x6822d7bbUL, 0x5f4815baUL,
+    0x06f653b8UL, 0x319c91b9UL, 0xb48adebcUL, 0x83e01cbdUL, 0xda5e5abfUL,
+    0xed3498beUL
+  },
+  {
+    0x00000000UL, 0x6567bcb8UL, 0x8bc809aaUL, 0xeeafb512UL, 0x5797628fUL,
+    0x32f0de37UL, 0xdc5f6b25UL, 0xb938d79dUL, 0xef28b4c5UL, 0x8a4f087dUL,
+    0x64e0bd6fUL, 0x018701d7UL, 0xb8bfd64aUL, 0xddd86af2UL, 0x3377dfe0UL,
+    0x56106358UL, 0x9f571950UL, 0xfa30a5e8UL, 0x149f10faUL, 0x71f8ac42UL,
+    0xc8c07bdfUL, 0xada7c767UL, 0x43087275UL, 0x266fcecdUL, 0x707fad95UL,
+    0x1518112dUL, 0xfbb7a43fUL, 0x9ed01887UL, 0x27e8cf1aUL, 0x428f73a2UL,
+    0xac20c6b0UL, 0xc9477a08UL, 0x3eaf32a0UL, 0x5bc88e18UL, 0xb5673b0aUL,
+    0xd00087b2UL, 0x6938502fUL, 0x0c5fec97UL, 0xe2f05985UL, 0x8797e53dUL,
+    0xd1878665UL, 0xb4e03addUL, 0x5a4f8fcfUL, 0x3f283377UL, 0x8610e4eaUL,
+    0xe3775852UL, 0x0dd8ed40UL, 0x68bf51f8UL, 0xa1f82bf0UL, 0xc49f9748UL,
+    0x2a30225aUL, 0x4f579ee2UL, 0xf66f497fUL, 0x9308f5c7UL, 0x7da740d5UL,
+    0x18c0fc6dUL, 0x4ed09f35UL, 0x2bb7238dUL, 0xc518969fUL, 0xa07f2a27UL,
+    0x1947fdbaUL, 0x7c204102UL, 0x928ff410UL, 0xf7e848a8UL, 0x3d58149bUL,
+    0x583fa823UL, 0xb6901d31UL, 0xd3f7a189UL, 0x6acf7614UL, 0x0fa8caacUL,
+    0xe1077fbeUL, 0x8460c306UL, 0xd270a05eUL, 0xb7171ce6UL, 0x59b8a9f4UL,
+    0x3cdf154cUL, 0x85e7c2d1UL, 0xe0807e69UL, 0x0e2fcb7bUL, 0x6b4877c3UL,
+    0xa20f0dcbUL, 0xc768b173UL, 0x29c70461UL, 0x4ca0b8d9UL, 0xf5986f44UL,
+    0x90ffd3fcUL, 0x7e5066eeUL, 0x1b37da56UL, 0x4d27b90eUL, 0x284005b6UL,
+    0xc6efb0a4UL, 0xa3880c1cUL, 0x1ab0db81UL, 0x7fd76739UL, 0x9178d22bUL,
+    0xf41f6e93UL, 0x03f7263bUL, 0x66909a83UL, 0x883f2f91UL, 0xed589329UL,
+    0x546044b4UL, 0x3107f80cUL, 0xdfa84d1eUL, 0xbacff1a6UL, 0xecdf92feUL,
+    0x89b82e46UL, 0x67179b54UL, 0x027027ecUL, 0xbb48f071UL, 0xde2f4cc9UL,
+    0x3080f9dbUL, 0x55e74563UL, 0x9ca03f6bUL, 0xf9c783d3UL, 0x176836c1UL,
+    0x720f8a79UL, 0xcb375de4UL, 0xae50e15cUL, 0x40ff544eUL, 0x2598e8f6UL,
+    0x73888baeUL, 0x16ef3716UL, 0xf8408204UL, 0x9d273ebcUL, 0x241fe921UL,
+    0x41785599UL, 0xafd7e08bUL, 0xcab05c33UL, 0x3bb659edUL, 0x5ed1e555UL,
+    0xb07e5047UL, 0xd519ecffUL, 0x6c213b62UL, 0x094687daUL, 0xe7e932c8UL,
+    0x828e8e70UL, 0xd49eed28UL, 0xb1f95190UL, 0x5f56e482UL, 0x3a31583aUL,
+    0x83098fa7UL, 0xe66e331fUL, 0x08c1860dUL, 0x6da63ab5UL, 0xa4e140bdUL,
+    0xc186fc05UL, 0x2f294917UL, 0x4a4ef5afUL, 0xf3762232UL, 0x96119e8aUL,
+    0x78be2b98UL, 0x1dd99720UL, 0x4bc9f478UL, 0x2eae48c0UL, 0xc001fdd2UL,
+    0xa566416aUL, 0x1c5e96f7UL, 0x79392a4fUL, 0x97969f5dUL, 0xf2f123e5UL,
+    0x05196b4dUL, 0x607ed7f5UL, 0x8ed162e7UL, 0xebb6de5fUL, 0x528e09c2UL,
+    0x37e9b57aUL, 0xd9460068UL, 0xbc21bcd0UL, 0xea31df88UL, 0x8f566330UL,
+    0x61f9d622UL, 0x049e6a9aUL, 0xbda6bd07UL, 0xd8c101bfUL, 0x366eb4adUL,
+    0x53090815UL, 0x9a4e721dUL, 0xff29cea5UL, 0x11867bb7UL, 0x74e1c70fUL,
+    0xcdd91092UL, 0xa8beac2aUL, 0x46111938UL, 0x2376a580UL, 0x7566c6d8UL,
+    0x10017a60UL, 0xfeaecf72UL, 0x9bc973caUL, 0x22f1a457UL, 0x479618efUL,
+    0xa939adfdUL, 0xcc5e1145UL, 0x06ee4d76UL, 0x6389f1ceUL, 0x8d2644dcUL,
+    0xe841f864UL, 0x51792ff9UL, 0x341e9341UL, 0xdab12653UL, 0xbfd69aebUL,
+    0xe9c6f9b3UL, 0x8ca1450bUL, 0x620ef019UL, 0x07694ca1UL, 0xbe519b3cUL,
+    0xdb362784UL, 0x35999296UL, 0x50fe2e2eUL, 0x99b95426UL, 0xfcdee89eUL,
+    0x12715d8cUL, 0x7716e134UL, 0xce2e36a9UL, 0xab498a11UL, 0x45e63f03UL,
+    0x208183bbUL, 0x7691e0e3UL, 0x13f65c5bUL, 0xfd59e949UL, 0x983e55f1UL,
+    0x2106826cUL, 0x44613ed4UL, 0xaace8bc6UL, 0xcfa9377eUL, 0x38417fd6UL,
+    0x5d26c36eUL, 0xb389767cUL, 0xd6eecac4UL, 0x6fd61d59UL, 0x0ab1a1e1UL,
+    0xe41e14f3UL, 0x8179a84bUL, 0xd769cb13UL, 0xb20e77abUL, 0x5ca1c2b9UL,
+    0x39c67e01UL, 0x80fea99cUL, 0xe5991524UL, 0x0b36a036UL, 0x6e511c8eUL,
+    0xa7166686UL, 0xc271da3eUL, 0x2cde6f2cUL, 0x49b9d394UL, 0xf0810409UL,
+    0x95e6b8b1UL, 0x7b490da3UL, 0x1e2eb11bUL, 0x483ed243UL, 0x2d596efbUL,
+    0xc3f6dbe9UL, 0xa6916751UL, 0x1fa9b0ccUL, 0x7ace0c74UL, 0x9461b966UL,
+    0xf10605deUL
+#endif
+  }
+};
diff --git a/Engine/lib/assimp/contrib/zlib/deflate.c b/Engine/lib/assimp/contrib/zlib/deflate.c
new file mode 100644
index 000000000..568eaddbe
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/deflate.c
@@ -0,0 +1,2174 @@
+/* deflate.c -- compress data using the deflation algorithm
+ * Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/*
+ *  ALGORITHM
+ *
+ *      The "deflation" process depends on being able to identify portions
+ *      of the input text which are identical to earlier input (within a
+ *      sliding window trailing behind the input currently being processed).
+ *
+ *      The most straightforward technique turns out to be the fastest for
+ *      most input files: try all possible matches and select the longest.
+ *      The key feature of this algorithm is that insertions into the string
+ *      dictionary are very simple and thus fast, and deletions are avoided
+ *      completely. Insertions are performed at each input character, whereas
+ *      string matches are performed only when the previous match ends. So it
+ *      is preferable to spend more time in matches to allow very fast string
+ *      insertions and avoid deletions. The matching algorithm for small
+ *      strings is inspired from that of Rabin & Karp. A brute force approach
+ *      is used to find longer strings when a small match has been found.
+ *      A similar algorithm is used in comic (by Jan-Mark Wams) and freeze
+ *      (by Leonid Broukhis).
+ *         A previous version of this file used a more sophisticated algorithm
+ *      (by Fiala and Greene) which is guaranteed to run in linear amortized
+ *      time, but has a larger average cost, uses more memory and is patented.
+ *      However the F&G algorithm may be faster for some highly redundant
+ *      files if the parameter max_chain_length (described below) is too large.
+ *
+ *  ACKNOWLEDGEMENTS
+ *
+ *      The idea of lazy evaluation of matches is due to Jan-Mark Wams, and
+ *      I found it in 'freeze' written by Leonid Broukhis.
+ *      Thanks to many people for bug reports and testing.
+ *
+ *  REFERENCES
+ *
+ *      Deutsch, L.P.,"DEFLATE Compressed Data Format Specification".
+ *      Available in http://tools.ietf.org/html/rfc1951
+ *
+ *      A description of the Rabin and Karp algorithm is given in the book
+ *         "Algorithms" by R. Sedgewick, Addison-Wesley, p252.
+ *
+ *      Fiala,E.R., and Greene,D.H.
+ *         Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595
+ *
+ */
+
+/* @(#) $Id$ */
+
+#include "deflate.h"
+
+const char deflate_copyright[] =
+   " deflate 1.2.11.1 Copyright 1995-2017 Jean-loup Gailly and Mark Adler ";
+/*
+  If you use the zlib library in a product, an acknowledgment is welcome
+  in the documentation of your product. If for some reason you cannot
+  include such an acknowledgment, I would appreciate that you keep this
+  copyright string in the executable of your product.
+ */
+
+/* ===========================================================================
+ *  Function prototypes.
+ */
+typedef enum {
+    need_more,      /* block not completed, need more input or more output */
+    block_done,     /* block flush performed */
+    finish_started, /* finish started, need only more output at next deflate */
+    finish_done     /* finish done, accept no more input or output */
+} block_state;
+
+typedef block_state (*compress_func) OF((deflate_state *s, int flush));
+/* Compression function. Returns the block state after the call. */
+
+local int deflateStateCheck      OF((z_streamp strm));
+local void slide_hash     OF((deflate_state *s));
+local void fill_window    OF((deflate_state *s));
+local block_state deflate_stored OF((deflate_state *s, int flush));
+local block_state deflate_fast   OF((deflate_state *s, int flush));
+#ifndef FASTEST
+local block_state deflate_slow   OF((deflate_state *s, int flush));
+#endif
+local block_state deflate_rle    OF((deflate_state *s, int flush));
+local block_state deflate_huff   OF((deflate_state *s, int flush));
+local void lm_init        OF((deflate_state *s));
+local void putShortMSB    OF((deflate_state *s, uInt b));
+local void flush_pending  OF((z_streamp strm));
+local unsigned read_buf   OF((z_streamp strm, Bytef *buf, unsigned size));
+#ifdef ASMV
+#  pragma message("Assembler code may have bugs -- use at your own risk")
+      void match_init OF((void)); /* asm code initialization */
+      uInt longest_match  OF((deflate_state *s, IPos cur_match));
+#else
+local uInt longest_match  OF((deflate_state *s, IPos cur_match));
+#endif
+
+#ifdef ZLIB_DEBUG
+local  void check_match OF((deflate_state *s, IPos start, IPos match,
+                            int length));
+#endif
+
+/* ===========================================================================
+ * Local data
+ */
+
+#define NIL 0
+/* Tail of hash chains */
+
+#ifndef TOO_FAR
+#  define TOO_FAR 4096
+#endif
+/* Matches of length 3 are discarded if their distance exceeds TOO_FAR */
+
+/* Values for max_lazy_match, good_match and max_chain_length, depending on
+ * the desired pack level (0..9). The values given below have been tuned to
+ * exclude worst case performance for pathological files. Better values may be
+ * found for specific files.
+ */
+typedef struct config_s {
+   ush good_length; /* reduce lazy search above this match length */
+   ush max_lazy;    /* do not perform lazy search above this match length */
+   ush nice_length; /* quit search above this match length */
+   ush max_chain;
+   compress_func func;
+} config;
+
+#ifdef FASTEST
+local const config configuration_table[2] = {
+/*      good lazy nice chain */
+/* 0 */ {0,    0,  0,    0, deflate_stored},  /* store only */
+/* 1 */ {4,    4,  8,    4, deflate_fast}}; /* max speed, no lazy matches */
+#else
+local const config configuration_table[10] = {
+/*      good lazy nice chain */
+/* 0 */ {0,    0,  0,    0, deflate_stored},  /* store only */
+/* 1 */ {4,    4,  8,    4, deflate_fast}, /* max speed, no lazy matches */
+/* 2 */ {4,    5, 16,    8, deflate_fast},
+/* 3 */ {4,    6, 32,   32, deflate_fast},
+
+/* 4 */ {4,    4, 16,   16, deflate_slow},  /* lazy matches */
+/* 5 */ {8,   16, 32,   32, deflate_slow},
+/* 6 */ {8,   16, 128, 128, deflate_slow},
+/* 7 */ {8,   32, 128, 256, deflate_slow},
+/* 8 */ {32, 128, 258, 1024, deflate_slow},
+/* 9 */ {32, 258, 258, 4096, deflate_slow}}; /* max compression */
+#endif
+
+/* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
+ * For deflate_fast() (levels <= 3) good is ignored and lazy has a different
+ * meaning.
+ */
+
+/* rank Z_BLOCK between Z_NO_FLUSH and Z_PARTIAL_FLUSH */
+#define RANK(f) (((f) * 2) - ((f) > 4 ? 9 : 0))
+
+/* ===========================================================================
+ * Update a hash value with the given input byte
+ * IN  assertion: all calls to UPDATE_HASH are made with consecutive input
+ *    characters, so that a running hash key can be computed from the previous
+ *    key instead of complete recalculation each time.
+ */
+#define UPDATE_HASH(s,h,c) (h = (((h)<<s->hash_shift) ^ (c)) & s->hash_mask)
+
+
+/* ===========================================================================
+ * Insert string str in the dictionary and set match_head to the previous head
+ * of the hash chain (the most recent string with same hash key). Return
+ * the previous length of the hash chain.
+ * If this file is compiled with -DFASTEST, the compression level is forced
+ * to 1, and no hash chains are maintained.
+ * IN  assertion: all calls to INSERT_STRING are made with consecutive input
+ *    characters and the first MIN_MATCH bytes of str are valid (except for
+ *    the last MIN_MATCH-1 bytes of the input file).
+ */
+#ifdef FASTEST
+#define INSERT_STRING(s, str, match_head) \
+   (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \
+    match_head = s->head[s->ins_h], \
+    s->head[s->ins_h] = (Pos)(str))
+#else
+#define INSERT_STRING(s, str, match_head) \
+   (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \
+    match_head = s->prev[(str) & s->w_mask] = s->head[s->ins_h], \
+    s->head[s->ins_h] = (Pos)(str))
+#endif
+
+/* ===========================================================================
+ * Initialize the hash table (avoiding 64K overflow for 16 bit systems).
+ * prev[] will be initialized on the fly.
+ */
+#define CLEAR_HASH(s) \
+    do { \
+        s->head[s->hash_size-1] = NIL; \
+        zmemzero((Bytef *)s->head, \
+                 (unsigned)(s->hash_size-1)*sizeof(*s->head)); \
+    } while (0)
+
+/* ===========================================================================
+ * Slide the hash table when sliding the window down (could be avoided with 32
+ * bit values at the expense of memory usage). We slide even when level == 0 to
+ * keep the hash table consistent if we switch back to level > 0 later.
+ */
+local void slide_hash(s)
+    deflate_state *s;
+{
+    unsigned n, m;
+    Posf *p;
+    uInt wsize = s->w_size;
+
+    n = s->hash_size;
+    p = &s->head[n];
+    do {
+        m = *--p;
+        *p = (Pos)(m >= wsize ? m - wsize : NIL);
+    } while (--n);
+    n = wsize;
+#ifndef FASTEST
+    p = &s->prev[n];
+    do {
+        m = *--p;
+        *p = (Pos)(m >= wsize ? m - wsize : NIL);
+        /* If n is not on any hash chain, prev[n] is garbage but
+         * its value will never be used.
+         */
+    } while (--n);
+#endif
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateInit_(strm, level, version, stream_size)
+    z_streamp strm;
+    int level;
+    const char *version;
+    int stream_size;
+{
+    return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL,
+                         Z_DEFAULT_STRATEGY, version, stream_size);
+    /* To do: ignore strm->next_in if we use it as window */
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
+                  version, stream_size)
+    z_streamp strm;
+    int  level;
+    int  method;
+    int  windowBits;
+    int  memLevel;
+    int  strategy;
+    const char *version;
+    int stream_size;
+{
+    deflate_state *s;
+    int wrap = 1;
+    static const char my_version[] = ZLIB_VERSION;
+
+    ushf *overlay;
+    /* We overlay pending_buf and d_buf+l_buf. This works since the average
+     * output size for (length,distance) codes is <= 24 bits.
+     */
+
+    if (version == Z_NULL || version[0] != my_version[0] ||
+        stream_size != sizeof(z_stream)) {
+        return Z_VERSION_ERROR;
+    }
+    if (strm == Z_NULL) return Z_STREAM_ERROR;
+
+    strm->msg = Z_NULL;
+    if (strm->zalloc == (alloc_func)0) {
+#ifdef Z_SOLO
+        return Z_STREAM_ERROR;
+#else
+        strm->zalloc = zcalloc;
+        strm->opaque = (voidpf)0;
+#endif
+    }
+    if (strm->zfree == (free_func)0)
+#ifdef Z_SOLO
+        return Z_STREAM_ERROR;
+#else
+        strm->zfree = zcfree;
+#endif
+
+#ifdef FASTEST
+    if (level != 0) level = 1;
+#else
+    if (level == Z_DEFAULT_COMPRESSION) level = 6;
+#endif
+
+    if (windowBits < 0) { /* suppress zlib wrapper */
+        wrap = 0;
+        windowBits = -windowBits;
+    }
+#ifdef GZIP
+    else if (windowBits > 15) {
+        wrap = 2;       /* write gzip wrapper instead */
+        windowBits -= 16;
+    }
+#endif
+    if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED ||
+        windowBits < 8 || windowBits > 15 || level < 0 || level > 9 ||
+        strategy < 0 || strategy > Z_FIXED || (windowBits == 8 && wrap != 1)) {
+        return Z_STREAM_ERROR;
+    }
+    if (windowBits == 8) windowBits = 9;  /* until 256-byte window bug fixed */
+    s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state));
+    if (s == Z_NULL) return Z_MEM_ERROR;
+    strm->state = (struct internal_state FAR *)s;
+    s->strm = strm;
+    s->status = INIT_STATE;     /* to pass state test in deflateReset() */
+
+    s->wrap = wrap;
+    s->gzhead = Z_NULL;
+    s->w_bits = (uInt)windowBits;
+    s->w_size = 1 << s->w_bits;
+    s->w_mask = s->w_size - 1;
+
+    s->hash_bits = (uInt)memLevel + 7;
+    s->hash_size = 1 << s->hash_bits;
+    s->hash_mask = s->hash_size - 1;
+    s->hash_shift =  ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH);
+
+    s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte));
+    s->prev   = (Posf *)  ZALLOC(strm, s->w_size, sizeof(Pos));
+    s->head   = (Posf *)  ZALLOC(strm, s->hash_size, sizeof(Pos));
+
+    s->high_water = 0;      /* nothing written to s->window yet */
+
+    s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */
+
+    overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);
+    s->pending_buf = (uchf *) overlay;
+    s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L);
+
+    if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL ||
+        s->pending_buf == Z_NULL) {
+        s->status = FINISH_STATE;
+        strm->msg = ERR_MSG(Z_MEM_ERROR);
+        deflateEnd (strm);
+        return Z_MEM_ERROR;
+    }
+    s->d_buf = overlay + s->lit_bufsize/sizeof(ush);
+    s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;
+
+    s->level = level;
+    s->strategy = strategy;
+    s->method = (Byte)method;
+
+    return deflateReset(strm);
+}
+
+/* =========================================================================
+ * Check for a valid deflate stream state. Return 0 if ok, 1 if not.
+ */
+local int deflateStateCheck (strm)
+    z_streamp strm;
+{
+    deflate_state *s;
+    if (strm == Z_NULL ||
+        strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0)
+        return 1;
+    s = strm->state;
+    if (s == Z_NULL || s->strm != strm || (s->status != INIT_STATE &&
+#ifdef GZIP
+                                           s->status != GZIP_STATE &&
+#endif
+                                           s->status != EXTRA_STATE &&
+                                           s->status != NAME_STATE &&
+                                           s->status != COMMENT_STATE &&
+                                           s->status != HCRC_STATE &&
+                                           s->status != BUSY_STATE &&
+                                           s->status != FINISH_STATE))
+        return 1;
+    return 0;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength)
+    z_streamp strm;
+    const Bytef *dictionary;
+    uInt  dictLength;
+{
+    deflate_state *s;
+    uInt str, n;
+    int wrap;
+    unsigned avail;
+    z_const unsigned char *next;
+
+    if (deflateStateCheck(strm) || dictionary == Z_NULL)
+        return Z_STREAM_ERROR;
+    s = strm->state;
+    wrap = s->wrap;
+    if (wrap == 2 || (wrap == 1 && s->status != INIT_STATE) || s->lookahead)
+        return Z_STREAM_ERROR;
+
+    /* when using zlib wrappers, compute Adler-32 for provided dictionary */
+    if (wrap == 1)
+        strm->adler = adler32(strm->adler, dictionary, dictLength);
+    s->wrap = 0;                    /* avoid computing Adler-32 in read_buf */
+
+    /* if dictionary would fill window, just replace the history */
+    if (dictLength >= s->w_size) {
+        if (wrap == 0) {            /* already empty otherwise */
+            CLEAR_HASH(s);
+            s->strstart = 0;
+            s->block_start = 0L;
+            s->insert = 0;
+        }
+        dictionary += dictLength - s->w_size;  /* use the tail */
+        dictLength = s->w_size;
+    }
+
+    /* insert dictionary into window and hash */
+    avail = strm->avail_in;
+    next = strm->next_in;
+    strm->avail_in = dictLength;
+    strm->next_in = (z_const Bytef *)dictionary;
+    fill_window(s);
+    while (s->lookahead >= MIN_MATCH) {
+        str = s->strstart;
+        n = s->lookahead - (MIN_MATCH-1);
+        do {
+            UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]);
+#ifndef FASTEST
+            s->prev[str & s->w_mask] = s->head[s->ins_h];
+#endif
+            s->head[s->ins_h] = (Pos)str;
+            str++;
+        } while (--n);
+        s->strstart = str;
+        s->lookahead = MIN_MATCH-1;
+        fill_window(s);
+    }
+    s->strstart += s->lookahead;
+    s->block_start = (long)s->strstart;
+    s->insert = s->lookahead;
+    s->lookahead = 0;
+    s->match_length = s->prev_length = MIN_MATCH-1;
+    s->match_available = 0;
+    strm->next_in = next;
+    strm->avail_in = avail;
+    s->wrap = wrap;
+    return Z_OK;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateGetDictionary (strm, dictionary, dictLength)
+    z_streamp strm;
+    Bytef *dictionary;
+    uInt  *dictLength;
+{
+    deflate_state *s;
+    uInt len;
+
+    if (deflateStateCheck(strm))
+        return Z_STREAM_ERROR;
+    s = strm->state;
+    len = s->strstart + s->lookahead;
+    if (len > s->w_size)
+        len = s->w_size;
+    if (dictionary != Z_NULL && len)
+        zmemcpy(dictionary, s->window + s->strstart + s->lookahead - len, len);
+    if (dictLength != Z_NULL)
+        *dictLength = len;
+    return Z_OK;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateResetKeep (strm)
+    z_streamp strm;
+{
+    deflate_state *s;
+
+    if (deflateStateCheck(strm)) {
+        return Z_STREAM_ERROR;
+    }
+
+    strm->total_in = strm->total_out = 0;
+    strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */
+    strm->data_type = Z_UNKNOWN;
+
+    s = (deflate_state *)strm->state;
+    s->pending = 0;
+    s->pending_out = s->pending_buf;
+
+    if (s->wrap < 0) {
+        s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */
+    }
+    s->status =
+#ifdef GZIP
+        s->wrap == 2 ? GZIP_STATE :
+#endif
+        s->wrap ? INIT_STATE : BUSY_STATE;
+    strm->adler =
+#ifdef GZIP
+        s->wrap == 2 ? crc32(0L, Z_NULL, 0) :
+#endif
+        adler32(0L, Z_NULL, 0);
+    s->last_flush = -2;
+
+    _tr_init(s);
+
+    return Z_OK;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateReset (strm)
+    z_streamp strm;
+{
+    int ret;
+
+    ret = deflateResetKeep(strm);
+    if (ret == Z_OK)
+        lm_init(strm->state);
+    return ret;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateSetHeader (strm, head)
+    z_streamp strm;
+    gz_headerp head;
+{
+    if (deflateStateCheck(strm) || strm->state->wrap != 2)
+        return Z_STREAM_ERROR;
+    strm->state->gzhead = head;
+    return Z_OK;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflatePending (strm, pending, bits)
+    unsigned *pending;
+    int *bits;
+    z_streamp strm;
+{
+    if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
+    if (pending != Z_NULL)
+        *pending = strm->state->pending;
+    if (bits != Z_NULL)
+        *bits = strm->state->bi_valid;
+    return Z_OK;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflatePrime (strm, bits, value)
+    z_streamp strm;
+    int bits;
+    int value;
+{
+    deflate_state *s;
+    int put;
+
+    if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
+    s = strm->state;
+    if ((Bytef *)(s->d_buf) < s->pending_out + ((Buf_size + 7) >> 3))
+        return Z_BUF_ERROR;
+    do {
+        put = Buf_size - s->bi_valid;
+        if (put > bits)
+            put = bits;
+        s->bi_buf |= (ush)((value & ((1 << put) - 1)) << s->bi_valid);
+        s->bi_valid += put;
+        _tr_flush_bits(s);
+        value >>= put;
+        bits -= put;
+    } while (bits);
+    return Z_OK;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateParams(strm, level, strategy)
+    z_streamp strm;
+    int level;
+    int strategy;
+{
+    deflate_state *s;
+    compress_func func;
+
+    if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
+    s = strm->state;
+
+#ifdef FASTEST
+    if (level != 0) level = 1;
+#else
+    if (level == Z_DEFAULT_COMPRESSION) level = 6;
+#endif
+    if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) {
+        return Z_STREAM_ERROR;
+    }
+    func = configuration_table[s->level].func;
+
+    if ((strategy != s->strategy || func != configuration_table[level].func) &&
+        s->last_flush != -2) {
+        /* Flush the last buffer: */
+        int err = deflate(strm, Z_BLOCK);
+        if (err == Z_STREAM_ERROR)
+            return err;
+        if (strm->avail_in || (s->strstart - s->block_start) + s->lookahead)
+            return Z_BUF_ERROR;
+    }
+    if (s->level != level) {
+        if (s->level == 0 && s->matches != 0) {
+            if (s->matches == 1)
+                slide_hash(s);
+            else
+                CLEAR_HASH(s);
+            s->matches = 0;
+        }
+        s->level = level;
+        s->max_lazy_match   = configuration_table[level].max_lazy;
+        s->good_match       = configuration_table[level].good_length;
+        s->nice_match       = configuration_table[level].nice_length;
+        s->max_chain_length = configuration_table[level].max_chain;
+    }
+    s->strategy = strategy;
+    return Z_OK;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain)
+    z_streamp strm;
+    int good_length;
+    int max_lazy;
+    int nice_length;
+    int max_chain;
+{
+    deflate_state *s;
+
+    if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
+    s = strm->state;
+    s->good_match = (uInt)good_length;
+    s->max_lazy_match = (uInt)max_lazy;
+    s->nice_match = nice_length;
+    s->max_chain_length = (uInt)max_chain;
+    return Z_OK;
+}
+
+/* =========================================================================
+ * For the default windowBits of 15 and memLevel of 8, this function returns
+ * a close to exact, as well as small, upper bound on the compressed size.
+ * They are coded as constants here for a reason--if the #define's are
+ * changed, then this function needs to be changed as well.  The return
+ * value for 15 and 8 only works for those exact settings.
+ *
+ * For any setting other than those defaults for windowBits and memLevel,
+ * the value returned is a conservative worst case for the maximum expansion
+ * resulting from using fixed blocks instead of stored blocks, which deflate
+ * can emit on compressed data for some combinations of the parameters.
+ *
+ * This function could be more sophisticated to provide closer upper bounds for
+ * every combination of windowBits and memLevel.  But even the conservative
+ * upper bound of about 14% expansion does not seem onerous for output buffer
+ * allocation.
+ */
+uLong ZEXPORT deflateBound(strm, sourceLen)
+    z_streamp strm;
+    uLong sourceLen;
+{
+    deflate_state *s;
+    uLong complen, wraplen;
+
+    /* conservative upper bound for compressed data */
+    complen = sourceLen +
+              ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5;
+
+    /* if can't get parameters, return conservative bound plus zlib wrapper */
+    if (deflateStateCheck(strm))
+        return complen + 6;
+
+    /* compute wrapper length */
+    s = strm->state;
+    switch (s->wrap) {
+    case 0:                                 /* raw deflate */
+        wraplen = 0;
+        break;
+    case 1:                                 /* zlib wrapper */
+        wraplen = 6 + (s->strstart ? 4 : 0);
+        break;
+#ifdef GZIP
+    case 2:                                 /* gzip wrapper */
+        wraplen = 18;
+        if (s->gzhead != Z_NULL) {          /* user-supplied gzip header */
+            Bytef *str;
+            if (s->gzhead->extra != Z_NULL)
+                wraplen += 2 + s->gzhead->extra_len;
+            str = s->gzhead->name;
+            if (str != Z_NULL)
+                do {
+                    wraplen++;
+                } while (*str++);
+            str = s->gzhead->comment;
+            if (str != Z_NULL)
+                do {
+                    wraplen++;
+                } while (*str++);
+            if (s->gzhead->hcrc)
+                wraplen += 2;
+        }
+        break;
+#endif
+    default:                                /* for compiler happiness */
+        wraplen = 6;
+    }
+
+    /* if not default parameters, return conservative bound */
+    if (s->w_bits != 15 || s->hash_bits != 8 + 7)
+        return complen + wraplen;
+
+    /* default settings: return tight bound for that case */
+    return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
+           (sourceLen >> 25) + 13 - 6 + wraplen;
+}
+
+/* =========================================================================
+ * Put a short in the pending buffer. The 16-bit value is put in MSB order.
+ * IN assertion: the stream state is correct and there is enough room in
+ * pending_buf.
+ */
+local void putShortMSB (s, b)
+    deflate_state *s;
+    uInt b;
+{
+    put_byte(s, (Byte)(b >> 8));
+    put_byte(s, (Byte)(b & 0xff));
+}
+
+/* =========================================================================
+ * Flush as much pending output as possible. All deflate() output, except for
+ * some deflate_stored() output, goes through this function so some
+ * applications may wish to modify it to avoid allocating a large
+ * strm->next_out buffer and copying into it. (See also read_buf()).
+ */
+local void flush_pending(strm)
+    z_streamp strm;
+{
+    unsigned len;
+    deflate_state *s = strm->state;
+
+    _tr_flush_bits(s);
+    len = s->pending;
+    if (len > strm->avail_out) len = strm->avail_out;
+    if (len == 0) return;
+
+    zmemcpy(strm->next_out, s->pending_out, len);
+    strm->next_out  += len;
+    s->pending_out  += len;
+    strm->total_out += len;
+    strm->avail_out -= len;
+    s->pending      -= len;
+    if (s->pending == 0) {
+        s->pending_out = s->pending_buf;
+    }
+}
+
+/* ===========================================================================
+ * Update the header CRC with the bytes s->pending_buf[beg..s->pending - 1].
+ */
+#define HCRC_UPDATE(beg) \
+    do { \
+        if (s->gzhead->hcrc && s->pending > (beg)) \
+            strm->adler = crc32(strm->adler, s->pending_buf + (beg), \
+                                s->pending - (beg)); \
+    } while (0)
+
+/* ========================================================================= */
+int ZEXPORT deflate (strm, flush)
+    z_streamp strm;
+    int flush;
+{
+    int old_flush; /* value of flush param for previous deflate call */
+    deflate_state *s;
+
+    if (deflateStateCheck(strm) || flush > Z_BLOCK || flush < 0) {
+        return Z_STREAM_ERROR;
+    }
+    s = strm->state;
+
+    if (strm->next_out == Z_NULL ||
+        (strm->avail_in != 0 && strm->next_in == Z_NULL) ||
+        (s->status == FINISH_STATE && flush != Z_FINISH)) {
+        ERR_RETURN(strm, Z_STREAM_ERROR);
+    }
+    if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR);
+
+    old_flush = s->last_flush;
+    s->last_flush = flush;
+
+    /* Flush as much pending output as possible */
+    if (s->pending != 0) {
+        flush_pending(strm);
+        if (strm->avail_out == 0) {
+            /* Since avail_out is 0, deflate will be called again with
+             * more output space, but possibly with both pending and
+             * avail_in equal to zero. There won't be anything to do,
+             * but this is not an error situation so make sure we
+             * return OK instead of BUF_ERROR at next call of deflate:
+             */
+            s->last_flush = -1;
+            return Z_OK;
+        }
+
+    /* Make sure there is something to do and avoid duplicate consecutive
+     * flushes. For repeated and useless calls with Z_FINISH, we keep
+     * returning Z_STREAM_END instead of Z_BUF_ERROR.
+     */
+    } else if (strm->avail_in == 0 && RANK(flush) <= RANK(old_flush) &&
+               flush != Z_FINISH) {
+        ERR_RETURN(strm, Z_BUF_ERROR);
+    }
+
+    /* User must not provide more input after the first FINISH: */
+    if (s->status == FINISH_STATE && strm->avail_in != 0) {
+        ERR_RETURN(strm, Z_BUF_ERROR);
+    }
+
+    /* Write the header */
+    if (s->status == INIT_STATE) {
+        /* zlib header */
+        uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8;
+        uInt level_flags;
+
+        if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2)
+            level_flags = 0;
+        else if (s->level < 6)
+            level_flags = 1;
+        else if (s->level == 6)
+            level_flags = 2;
+        else
+            level_flags = 3;
+        header |= (level_flags << 6);
+        if (s->strstart != 0) header |= PRESET_DICT;
+        header += 31 - (header % 31);
+
+        putShortMSB(s, header);
+
+        /* Save the adler32 of the preset dictionary: */
+        if (s->strstart != 0) {
+            putShortMSB(s, (uInt)(strm->adler >> 16));
+            putShortMSB(s, (uInt)(strm->adler & 0xffff));
+        }
+        strm->adler = adler32(0L, Z_NULL, 0);
+        s->status = BUSY_STATE;
+
+        /* Compression must start with an empty pending buffer */
+        flush_pending(strm);
+        if (s->pending != 0) {
+            s->last_flush = -1;
+            return Z_OK;
+        }
+    }
+#ifdef GZIP
+    if (s->status == GZIP_STATE) {
+        /* gzip header */
+        strm->adler = crc32(0L, Z_NULL, 0);
+        put_byte(s, 31);
+        put_byte(s, 139);
+        put_byte(s, 8);
+        if (s->gzhead == Z_NULL) {
+            put_byte(s, 0);
+            put_byte(s, 0);
+            put_byte(s, 0);
+            put_byte(s, 0);
+            put_byte(s, 0);
+            put_byte(s, s->level == 9 ? 2 :
+                     (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
+                      4 : 0));
+            put_byte(s, OS_CODE);
+            s->status = BUSY_STATE;
+
+            /* Compression must start with an empty pending buffer */
+            flush_pending(strm);
+            if (s->pending != 0) {
+                s->last_flush = -1;
+                return Z_OK;
+            }
+        }
+        else {
+            put_byte(s, (s->gzhead->text ? 1 : 0) +
+                     (s->gzhead->hcrc ? 2 : 0) +
+                     (s->gzhead->extra == Z_NULL ? 0 : 4) +
+                     (s->gzhead->name == Z_NULL ? 0 : 8) +
+                     (s->gzhead->comment == Z_NULL ? 0 : 16)
+                     );
+            put_byte(s, (Byte)(s->gzhead->time & 0xff));
+            put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff));
+            put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff));
+            put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff));
+            put_byte(s, s->level == 9 ? 2 :
+                     (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
+                      4 : 0));
+            put_byte(s, s->gzhead->os & 0xff);
+            if (s->gzhead->extra != Z_NULL) {
+                put_byte(s, s->gzhead->extra_len & 0xff);
+                put_byte(s, (s->gzhead->extra_len >> 8) & 0xff);
+            }
+            if (s->gzhead->hcrc)
+                strm->adler = crc32(strm->adler, s->pending_buf,
+                                    s->pending);
+            s->gzindex = 0;
+            s->status = EXTRA_STATE;
+        }
+    }
+    if (s->status == EXTRA_STATE) {
+        if (s->gzhead->extra != Z_NULL) {
+            ulg beg = s->pending;   /* start of bytes to update crc */
+            uInt left = (s->gzhead->extra_len & 0xffff) - s->gzindex;
+            while (s->pending + left > s->pending_buf_size) {
+                uInt copy = s->pending_buf_size - s->pending;
+                zmemcpy(s->pending_buf + s->pending,
+                        s->gzhead->extra + s->gzindex, copy);
+                s->pending = s->pending_buf_size;
+                HCRC_UPDATE(beg);
+                s->gzindex += copy;
+                flush_pending(strm);
+                if (s->pending != 0) {
+                    s->last_flush = -1;
+                    return Z_OK;
+                }
+                beg = 0;
+                left -= copy;
+            }
+            zmemcpy(s->pending_buf + s->pending,
+                    s->gzhead->extra + s->gzindex, left);
+            s->pending += left;
+            HCRC_UPDATE(beg);
+            s->gzindex = 0;
+        }
+        s->status = NAME_STATE;
+    }
+    if (s->status == NAME_STATE) {
+        if (s->gzhead->name != Z_NULL) {
+            ulg beg = s->pending;   /* start of bytes to update crc */
+            int val;
+            do {
+                if (s->pending == s->pending_buf_size) {
+                    HCRC_UPDATE(beg);
+                    flush_pending(strm);
+                    if (s->pending != 0) {
+                        s->last_flush = -1;
+                        return Z_OK;
+                    }
+                    beg = 0;
+                }
+                val = s->gzhead->name[s->gzindex++];
+                put_byte(s, val);
+            } while (val != 0);
+            HCRC_UPDATE(beg);
+            s->gzindex = 0;
+        }
+        s->status = COMMENT_STATE;
+    }
+    if (s->status == COMMENT_STATE) {
+        if (s->gzhead->comment != Z_NULL) {
+            ulg beg = s->pending;   /* start of bytes to update crc */
+            int val;
+            do {
+                if (s->pending == s->pending_buf_size) {
+                    HCRC_UPDATE(beg);
+                    flush_pending(strm);
+                    if (s->pending != 0) {
+                        s->last_flush = -1;
+                        return Z_OK;
+                    }
+                    beg = 0;
+                }
+                val = s->gzhead->comment[s->gzindex++];
+                put_byte(s, val);
+            } while (val != 0);
+            HCRC_UPDATE(beg);
+        }
+        s->status = HCRC_STATE;
+    }
+    if (s->status == HCRC_STATE) {
+        if (s->gzhead->hcrc) {
+            if (s->pending + 2 > s->pending_buf_size) {
+                flush_pending(strm);
+                if (s->pending != 0) {
+                    s->last_flush = -1;
+                    return Z_OK;
+                }
+            }
+            put_byte(s, (Byte)(strm->adler & 0xff));
+            put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
+            strm->adler = crc32(0L, Z_NULL, 0);
+        }
+        s->status = BUSY_STATE;
+
+        /* Compression must start with an empty pending buffer */
+        flush_pending(strm);
+        if (s->pending != 0) {
+            s->last_flush = -1;
+            return Z_OK;
+        }
+    }
+#endif
+
+    /* Start a new block or continue the current one.
+     */
+    if (strm->avail_in != 0 || s->lookahead != 0 ||
+        (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) {
+        block_state bstate;
+
+        bstate = s->level == 0 ? deflate_stored(s, flush) :
+                 s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) :
+                 s->strategy == Z_RLE ? deflate_rle(s, flush) :
+                 (*(configuration_table[s->level].func))(s, flush);
+
+        if (bstate == finish_started || bstate == finish_done) {
+            s->status = FINISH_STATE;
+        }
+        if (bstate == need_more || bstate == finish_started) {
+            if (strm->avail_out == 0) {
+                s->last_flush = -1; /* avoid BUF_ERROR next call, see above */
+            }
+            return Z_OK;
+            /* If flush != Z_NO_FLUSH && avail_out == 0, the next call
+             * of deflate should use the same flush parameter to make sure
+             * that the flush is complete. So we don't have to output an
+             * empty block here, this will be done at next call. This also
+             * ensures that for a very small output buffer, we emit at most
+             * one empty block.
+             */
+        }
+        if (bstate == block_done) {
+            if (flush == Z_PARTIAL_FLUSH) {
+                _tr_align(s);
+            } else if (flush != Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */
+                _tr_stored_block(s, (char*)0, 0L, 0);
+                /* For a full flush, this empty block will be recognized
+                 * as a special marker by inflate_sync().
+                 */
+                if (flush == Z_FULL_FLUSH) {
+                    CLEAR_HASH(s);             /* forget history */
+                    if (s->lookahead == 0) {
+                        s->strstart = 0;
+                        s->block_start = 0L;
+                        s->insert = 0;
+                    }
+                }
+            }
+            flush_pending(strm);
+            if (strm->avail_out == 0) {
+              s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */
+              return Z_OK;
+            }
+        }
+    }
+
+    if (flush != Z_FINISH) return Z_OK;
+    if (s->wrap <= 0) return Z_STREAM_END;
+
+    /* Write the trailer */
+#ifdef GZIP
+    if (s->wrap == 2) {
+        put_byte(s, (Byte)(strm->adler & 0xff));
+        put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
+        put_byte(s, (Byte)((strm->adler >> 16) & 0xff));
+        put_byte(s, (Byte)((strm->adler >> 24) & 0xff));
+        put_byte(s, (Byte)(strm->total_in & 0xff));
+        put_byte(s, (Byte)((strm->total_in >> 8) & 0xff));
+        put_byte(s, (Byte)((strm->total_in >> 16) & 0xff));
+        put_byte(s, (Byte)((strm->total_in >> 24) & 0xff));
+    }
+    else
+#endif
+    {
+        putShortMSB(s, (uInt)(strm->adler >> 16));
+        putShortMSB(s, (uInt)(strm->adler & 0xffff));
+    }
+    flush_pending(strm);
+    /* If avail_out is zero, the application will call deflate again
+     * to flush the rest.
+     */
+    if (s->wrap > 0) s->wrap = -s->wrap; /* write the trailer only once! */
+    return s->pending != 0 ? Z_OK : Z_STREAM_END;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateEnd (strm)
+    z_streamp strm;
+{
+    int status;
+
+    if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
+
+    status = strm->state->status;
+
+    /* Deallocate in reverse order of allocations: */
+    TRY_FREE(strm, strm->state->pending_buf);
+    TRY_FREE(strm, strm->state->head);
+    TRY_FREE(strm, strm->state->prev);
+    TRY_FREE(strm, strm->state->window);
+
+    ZFREE(strm, strm->state);
+    strm->state = Z_NULL;
+
+    return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK;
+}
+
+/* =========================================================================
+ * Copy the source state to the destination state.
+ * To simplify the source, this is not supported for 16-bit MSDOS (which
+ * doesn't have enough memory anyway to duplicate compression states).
+ */
+int ZEXPORT deflateCopy (dest, source)
+    z_streamp dest;
+    z_streamp source;
+{
+#ifdef MAXSEG_64K
+    return Z_STREAM_ERROR;
+#else
+    deflate_state *ds;
+    deflate_state *ss;
+    ushf *overlay;
+
+
+    if (deflateStateCheck(source) || dest == Z_NULL) {
+        return Z_STREAM_ERROR;
+    }
+
+    ss = source->state;
+
+    zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream));
+
+    ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state));
+    if (ds == Z_NULL) return Z_MEM_ERROR;
+    dest->state = (struct internal_state FAR *) ds;
+    zmemcpy((voidpf)ds, (voidpf)ss, sizeof(deflate_state));
+    ds->strm = dest;
+
+    ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte));
+    ds->prev   = (Posf *)  ZALLOC(dest, ds->w_size, sizeof(Pos));
+    ds->head   = (Posf *)  ZALLOC(dest, ds->hash_size, sizeof(Pos));
+    overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof(ush)+2);
+    ds->pending_buf = (uchf *) overlay;
+
+    if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL ||
+        ds->pending_buf == Z_NULL) {
+        deflateEnd (dest);
+        return Z_MEM_ERROR;
+    }
+    /* following zmemcpy do not work for 16-bit MSDOS */
+    zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte));
+    zmemcpy((voidpf)ds->prev, (voidpf)ss->prev, ds->w_size * sizeof(Pos));
+    zmemcpy((voidpf)ds->head, (voidpf)ss->head, ds->hash_size * sizeof(Pos));
+    zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size);
+
+    ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf);
+    ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush);
+    ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize;
+
+    ds->l_desc.dyn_tree = ds->dyn_ltree;
+    ds->d_desc.dyn_tree = ds->dyn_dtree;
+    ds->bl_desc.dyn_tree = ds->bl_tree;
+
+    return Z_OK;
+#endif /* MAXSEG_64K */
+}
+
+/* ===========================================================================
+ * Read a new buffer from the current input stream, update the adler32
+ * and total number of bytes read.  All deflate() input goes through
+ * this function so some applications may wish to modify it to avoid
+ * allocating a large strm->next_in buffer and copying from it.
+ * (See also flush_pending()).
+ */
+local unsigned read_buf(strm, buf, size)
+    z_streamp strm;
+    Bytef *buf;
+    unsigned size;
+{
+    unsigned len = strm->avail_in;
+
+    if (len > size) len = size;
+    if (len == 0) return 0;
+
+    strm->avail_in  -= len;
+
+    zmemcpy(buf, strm->next_in, len);
+    if (strm->state->wrap == 1) {
+        strm->adler = adler32(strm->adler, buf, len);
+    }
+#ifdef GZIP
+    else if (strm->state->wrap == 2) {
+        strm->adler = crc32(strm->adler, buf, len);
+    }
+#endif
+    strm->next_in  += len;
+    strm->total_in += len;
+
+    return len;
+}
+
+/* ===========================================================================
+ * Initialize the "longest match" routines for a new zlib stream
+ */
+local void lm_init (s)
+    deflate_state *s;
+{
+    s->window_size = (ulg)2L*s->w_size;
+
+    CLEAR_HASH(s);
+
+    /* Set the default configuration parameters:
+     */
+    s->max_lazy_match   = configuration_table[s->level].max_lazy;
+    s->good_match       = configuration_table[s->level].good_length;
+    s->nice_match       = configuration_table[s->level].nice_length;
+    s->max_chain_length = configuration_table[s->level].max_chain;
+
+    s->strstart = 0;
+    s->block_start = 0L;
+    s->lookahead = 0;
+    s->insert = 0;
+    s->match_length = s->prev_length = MIN_MATCH-1;
+    s->match_available = 0;
+    s->ins_h = 0;
+#ifndef FASTEST
+#ifdef ASMV
+    match_init(); /* initialize the asm code */
+#endif
+#endif
+}
+
+#ifndef FASTEST
+/* ===========================================================================
+ * Set match_start to the longest match starting at the given string and
+ * return its length. Matches shorter or equal to prev_length are discarded,
+ * in which case the result is equal to prev_length and match_start is
+ * garbage.
+ * IN assertions: cur_match is the head of the hash chain for the current
+ *   string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
+ * OUT assertion: the match length is not greater than s->lookahead.
+ */
+#ifndef ASMV
+/* For 80x86 and 680x0, an optimized version will be provided in match.asm or
+ * match.S. The code will be functionally equivalent.
+ */
+local uInt longest_match(s, cur_match)
+    deflate_state *s;
+    IPos cur_match;                             /* current match */
+{
+    unsigned chain_length = s->max_chain_length;/* max hash chain length */
+    register Bytef *scan = s->window + s->strstart; /* current string */
+    register Bytef *match;                      /* matched string */
+    register int len;                           /* length of current match */
+    int best_len = (int)s->prev_length;         /* best match length so far */
+    int nice_match = s->nice_match;             /* stop if match long enough */
+    IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
+        s->strstart - (IPos)MAX_DIST(s) : NIL;
+    /* Stop when cur_match becomes <= limit. To simplify the code,
+     * we prevent matches with the string of window index 0.
+     */
+    Posf *prev = s->prev;
+    uInt wmask = s->w_mask;
+
+#ifdef UNALIGNED_OK
+    /* Compare two bytes at a time. Note: this is not always beneficial.
+     * Try with and without -DUNALIGNED_OK to check.
+     */
+    register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
+    register ush scan_start = *(ushf*)scan;
+    register ush scan_end   = *(ushf*)(scan+best_len-1);
+#else
+    register Bytef *strend = s->window + s->strstart + MAX_MATCH;
+    register Byte scan_end1  = scan[best_len-1];
+    register Byte scan_end   = scan[best_len];
+#endif
+
+    /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
+     * It is easy to get rid of this optimization if necessary.
+     */
+    Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
+
+    /* Do not waste too much time if we already have a good match: */
+    if (s->prev_length >= s->good_match) {
+        chain_length >>= 2;
+    }
+    /* Do not look for matches beyond the end of the input. This is necessary
+     * to make deflate deterministic.
+     */
+    if ((uInt)nice_match > s->lookahead) nice_match = (int)s->lookahead;
+
+    Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
+
+    do {
+        Assert(cur_match < s->strstart, "no future");
+        match = s->window + cur_match;
+
+        /* Skip to next match if the match length cannot increase
+         * or if the match length is less than 2.  Note that the checks below
+         * for insufficient lookahead only occur occasionally for performance
+         * reasons.  Therefore uninitialized memory will be accessed, and
+         * conditional jumps will be made that depend on those values.
+         * However the length of the match is limited to the lookahead, so
+         * the output of deflate is not affected by the uninitialized values.
+         */
+#if (defined(UNALIGNED_OK) && MAX_MATCH == 258)
+        /* This code assumes sizeof(unsigned short) == 2. Do not use
+         * UNALIGNED_OK if your compiler uses a different size.
+         */
+        if (*(ushf*)(match+best_len-1) != scan_end ||
+            *(ushf*)match != scan_start) continue;
+
+        /* It is not necessary to compare scan[2] and match[2] since they are
+         * always equal when the other bytes match, given that the hash keys
+         * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at
+         * strstart+3, +5, ... up to strstart+257. We check for insufficient
+         * lookahead only every 4th comparison; the 128th check will be made
+         * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is
+         * necessary to put more guard bytes at the end of the window, or
+         * to check more often for insufficient lookahead.
+         */
+        Assert(scan[2] == match[2], "scan[2]?");
+        scan++, match++;
+        do {
+        } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
+                 *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
+                 *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
+                 *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
+                 scan < strend);
+        /* The funny "do {}" generates better code on most compilers */
+
+        /* Here, scan <= window+strstart+257 */
+        Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
+        if (*scan == *match) scan++;
+
+        len = (MAX_MATCH - 1) - (int)(strend-scan);
+        scan = strend - (MAX_MATCH-1);
+
+#else /* UNALIGNED_OK */
+
+        if (match[best_len]   != scan_end  ||
+            match[best_len-1] != scan_end1 ||
+            *match            != *scan     ||
+            *++match          != scan[1])      continue;
+
+        /* The check at best_len-1 can be removed because it will be made
+         * again later. (This heuristic is not always a win.)
+         * It is not necessary to compare scan[2] and match[2] since they
+         * are always equal when the other bytes match, given that
+         * the hash keys are equal and that HASH_BITS >= 8.
+         */
+        scan += 2, match++;
+        Assert(*scan == *match, "match[2]?");
+
+        /* We check for insufficient lookahead only every 8th comparison;
+         * the 256th check will be made at strstart+258.
+         */
+        do {
+        } while (*++scan == *++match && *++scan == *++match &&
+                 *++scan == *++match && *++scan == *++match &&
+                 *++scan == *++match && *++scan == *++match &&
+                 *++scan == *++match && *++scan == *++match &&
+                 scan < strend);
+
+        Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
+
+        len = MAX_MATCH - (int)(strend - scan);
+        scan = strend - MAX_MATCH;
+
+#endif /* UNALIGNED_OK */
+
+        if (len > best_len) {
+            s->match_start = cur_match;
+            best_len = len;
+            if (len >= nice_match) break;
+#ifdef UNALIGNED_OK
+            scan_end = *(ushf*)(scan+best_len-1);
+#else
+            scan_end1  = scan[best_len-1];
+            scan_end   = scan[best_len];
+#endif
+        }
+    } while ((cur_match = prev[cur_match & wmask]) > limit
+             && --chain_length != 0);
+
+    if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
+    return s->lookahead;
+}
+#endif /* ASMV */
+
+#else /* FASTEST */
+
+/* ---------------------------------------------------------------------------
+ * Optimized version for FASTEST only
+ */
+local uInt longest_match(s, cur_match)
+    deflate_state *s;
+    IPos cur_match;                             /* current match */
+{
+    register Bytef *scan = s->window + s->strstart; /* current string */
+    register Bytef *match;                       /* matched string */
+    register int len;                           /* length of current match */
+    register Bytef *strend = s->window + s->strstart + MAX_MATCH;
+
+    /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
+     * It is easy to get rid of this optimization if necessary.
+     */
+    Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
+
+    Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
+
+    Assert(cur_match < s->strstart, "no future");
+
+    match = s->window + cur_match;
+
+    /* Return failure if the match length is less than 2:
+     */
+    if (match[0] != scan[0] || match[1] != scan[1]) return MIN_MATCH-1;
+
+    /* The check at best_len-1 can be removed because it will be made
+     * again later. (This heuristic is not always a win.)
+     * It is not necessary to compare scan[2] and match[2] since they
+     * are always equal when the other bytes match, given that
+     * the hash keys are equal and that HASH_BITS >= 8.
+     */
+    scan += 2, match += 2;
+    Assert(*scan == *match, "match[2]?");
+
+    /* We check for insufficient lookahead only every 8th comparison;
+     * the 256th check will be made at strstart+258.
+     */
+    do {
+    } while (*++scan == *++match && *++scan == *++match &&
+             *++scan == *++match && *++scan == *++match &&
+             *++scan == *++match && *++scan == *++match &&
+             *++scan == *++match && *++scan == *++match &&
+             scan < strend);
+
+    Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
+
+    len = MAX_MATCH - (int)(strend - scan);
+
+    if (len < MIN_MATCH) return MIN_MATCH - 1;
+
+    s->match_start = cur_match;
+    return (uInt)len <= s->lookahead ? (uInt)len : s->lookahead;
+}
+
+#endif /* FASTEST */
+
+#ifdef ZLIB_DEBUG
+
+#define EQUAL 0
+/* result of memcmp for equal strings */
+
+/* ===========================================================================
+ * Check that the match at match_start is indeed a match.
+ */
+local void check_match(s, start, match, length)
+    deflate_state *s;
+    IPos start, match;
+    int length;
+{
+    /* check that the match is indeed a match */
+    if (zmemcmp(s->window + match,
+                s->window + start, length) != EQUAL) {
+        fprintf(stderr, " start %u, match %u, length %d\n",
+                start, match, length);
+        do {
+            fprintf(stderr, "%c%c", s->window[match++], s->window[start++]);
+        } while (--length != 0);
+        z_error("invalid match");
+    }
+    if (z_verbose > 1) {
+        fprintf(stderr,"\\[%d,%d]", start-match, length);
+        do { putc(s->window[start++], stderr); } while (--length != 0);
+    }
+}
+#else
+#  define check_match(s, start, match, length)
+#endif /* ZLIB_DEBUG */
+
+/* ===========================================================================
+ * Fill the window when the lookahead becomes insufficient.
+ * Updates strstart and lookahead.
+ *
+ * IN assertion: lookahead < MIN_LOOKAHEAD
+ * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
+ *    At least one byte has been read, or avail_in == 0; reads are
+ *    performed for at least two bytes (required for the zip translate_eol
+ *    option -- not supported here).
+ */
+local void fill_window(s)
+    deflate_state *s;
+{
+    unsigned n;
+    unsigned more;    /* Amount of free space at the end of the window. */
+    uInt wsize = s->w_size;
+
+    Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead");
+
+    do {
+        more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart);
+
+        /* Deal with !@#$% 64K limit: */
+        if (sizeof(int) <= 2) {
+            if (more == 0 && s->strstart == 0 && s->lookahead == 0) {
+                more = wsize;
+
+            } else if (more == (unsigned)(-1)) {
+                /* Very unlikely, but possible on 16 bit machine if
+                 * strstart == 0 && lookahead == 1 (input done a byte at time)
+                 */
+                more--;
+            }
+        }
+
+        /* If the window is almost full and there is insufficient lookahead,
+         * move the upper half to the lower one to make room in the upper half.
+         */
+        if (s->strstart >= wsize+MAX_DIST(s)) {
+
+            zmemcpy(s->window, s->window+wsize, (unsigned)wsize - more);
+            s->match_start -= wsize;
+            s->strstart    -= wsize; /* we now have strstart >= MAX_DIST */
+            s->block_start -= (long) wsize;
+            if (s->insert > s->strstart)
+                s->insert = s->strstart;
+            slide_hash(s);
+            more += wsize;
+        }
+        if (s->strm->avail_in == 0) break;
+
+        /* If there was no sliding:
+         *    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
+         *    more == window_size - lookahead - strstart
+         * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
+         * => more >= window_size - 2*WSIZE + 2
+         * In the BIG_MEM or MMAP case (not yet supported),
+         *   window_size == input_size + MIN_LOOKAHEAD  &&
+         *   strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.
+         * Otherwise, window_size == 2*WSIZE so more >= 2.
+         * If there was sliding, more >= WSIZE. So in all cases, more >= 2.
+         */
+        Assert(more >= 2, "more < 2");
+
+        n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more);
+        s->lookahead += n;
+
+        /* Initialize the hash value now that we have some input: */
+        if (s->lookahead + s->insert >= MIN_MATCH) {
+            uInt str = s->strstart - s->insert;
+            s->ins_h = s->window[str];
+            UPDATE_HASH(s, s->ins_h, s->window[str + 1]);
+#if MIN_MATCH != 3
+            Call UPDATE_HASH() MIN_MATCH-3 more times
+#endif
+            while (s->insert) {
+                UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]);
+#ifndef FASTEST
+                s->prev[str & s->w_mask] = s->head[s->ins_h];
+#endif
+                s->head[s->ins_h] = (Pos)str;
+                str++;
+                s->insert--;
+                if (s->lookahead + s->insert < MIN_MATCH)
+                    break;
+            }
+        }
+        /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
+         * but this is not important since only literal bytes will be emitted.
+         */
+
+    } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0);
+
+    /* If the WIN_INIT bytes after the end of the current data have never been
+     * written, then zero those bytes in order to avoid memory check reports of
+     * the use of uninitialized (or uninitialised as Julian writes) bytes by
+     * the longest match routines.  Update the high water mark for the next
+     * time through here.  WIN_INIT is set to MAX_MATCH since the longest match
+     * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead.
+     */
+    if (s->high_water < s->window_size) {
+        ulg curr = s->strstart + (ulg)(s->lookahead);
+        ulg init;
+
+        if (s->high_water < curr) {
+            /* Previous high water mark below current data -- zero WIN_INIT
+             * bytes or up to end of window, whichever is less.
+             */
+            init = s->window_size - curr;
+            if (init > WIN_INIT)
+                init = WIN_INIT;
+            zmemzero(s->window + curr, (unsigned)init);
+            s->high_water = curr + init;
+        }
+        else if (s->high_water < (ulg)curr + WIN_INIT) {
+            /* High water mark at or above current data, but below current data
+             * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up
+             * to end of window, whichever is less.
+             */
+            init = (ulg)curr + WIN_INIT - s->high_water;
+            if (init > s->window_size - s->high_water)
+                init = s->window_size - s->high_water;
+            zmemzero(s->window + s->high_water, (unsigned)init);
+            s->high_water += init;
+        }
+    }
+
+    Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD,
+           "not enough room for search");
+}
+
+/* ===========================================================================
+ * Flush the current block, with given end-of-file flag.
+ * IN assertion: strstart is set to the end of the current match.
+ */
+#define FLUSH_BLOCK_ONLY(s, last) { \
+   _tr_flush_block(s, (s->block_start >= 0L ? \
+                   (charf *)&s->window[(unsigned)s->block_start] : \
+                   (charf *)Z_NULL), \
+                (ulg)((long)s->strstart - s->block_start), \
+                (last)); \
+   s->block_start = s->strstart; \
+   flush_pending(s->strm); \
+   Tracev((stderr,"[FLUSH]")); \
+}
+
+/* Same but force premature exit if necessary. */
+#define FLUSH_BLOCK(s, last) { \
+   FLUSH_BLOCK_ONLY(s, last); \
+   if (s->strm->avail_out == 0) return (last) ? finish_started : need_more; \
+}
+
+/* Maximum stored block length in deflate format (not including header). */
+#define MAX_STORED 65535
+
+/* Minimum of a and b. */
+#define MIN(a, b) ((a) > (b) ? (b) : (a))
+
+/* ===========================================================================
+ * Copy without compression as much as possible from the input stream, return
+ * the current block state.
+ *
+ * In case deflateParams() is used to later switch to a non-zero compression
+ * level, s->matches (otherwise unused when storing) keeps track of the number
+ * of hash table slides to perform. If s->matches is 1, then one hash table
+ * slide will be done when switching. If s->matches is 2, the maximum value
+ * allowed here, then the hash table will be cleared, since two or more slides
+ * is the same as a clear.
+ *
+ * deflate_stored() is written to minimize the number of times an input byte is
+ * copied. It is most efficient with large input and output buffers, which
+ * maximizes the opportunites to have a single copy from next_in to next_out.
+ */
+local block_state deflate_stored(s, flush)
+    deflate_state *s;
+    int flush;
+{
+    /* Smallest worthy block size when not flushing or finishing. By default
+     * this is 32K. This can be as small as 507 bytes for memLevel == 1. For
+     * large input and output buffers, the stored block size will be larger.
+     */
+    unsigned min_block = MIN(s->pending_buf_size - 5, s->w_size);
+
+    /* Copy as many min_block or larger stored blocks directly to next_out as
+     * possible. If flushing, copy the remaining available input to next_out as
+     * stored blocks, if there is enough space.
+     */
+    unsigned len, left, have, last = 0;
+    unsigned used = s->strm->avail_in;
+    do {
+        /* Set len to the maximum size block that we can copy directly with the
+         * available input data and output space. Set left to how much of that
+         * would be copied from what's left in the window.
+         */
+        len = MAX_STORED;       /* maximum deflate stored block length */
+        have = (s->bi_valid + 42) >> 3;         /* number of header bytes */
+        if (s->strm->avail_out < have)          /* need room for header */
+            break;
+            /* maximum stored block length that will fit in avail_out: */
+        have = s->strm->avail_out - have;
+        left = s->strstart - s->block_start;    /* bytes left in window */
+        if (len > (ulg)left + s->strm->avail_in)
+            len = left + s->strm->avail_in;     /* limit len to the input */
+        if (len > have)
+            len = have;                         /* limit len to the output */
+
+        /* If the stored block would be less than min_block in length, or if
+         * unable to copy all of the available input when flushing, then try
+         * copying to the window and the pending buffer instead. Also don't
+         * write an empty block when flushing -- deflate() does that.
+         */
+        if (len < min_block && ((len == 0 && flush != Z_FINISH) ||
+                                flush == Z_NO_FLUSH ||
+                                len != left + s->strm->avail_in))
+            break;
+
+        /* Make a dummy stored block in pending to get the header bytes,
+         * including any pending bits. This also updates the debugging counts.
+         */
+        last = flush == Z_FINISH && len == left + s->strm->avail_in ? 1 : 0;
+        _tr_stored_block(s, (char *)0, 0L, last);
+
+        /* Replace the lengths in the dummy stored block with len. */
+        s->pending_buf[s->pending - 4] = len;
+        s->pending_buf[s->pending - 3] = len >> 8;
+        s->pending_buf[s->pending - 2] = ~len;
+        s->pending_buf[s->pending - 1] = ~len >> 8;
+
+        /* Write the stored block header bytes. */
+        flush_pending(s->strm);
+
+#ifdef ZLIB_DEBUG
+        /* Update debugging counts for the data about to be copied. */
+        s->compressed_len += len << 3;
+        s->bits_sent += len << 3;
+#endif
+
+        /* Copy uncompressed bytes from the window to next_out. */
+        if (left) {
+            if (left > len)
+                left = len;
+            zmemcpy(s->strm->next_out, s->window + s->block_start, left);
+            s->strm->next_out += left;
+            s->strm->avail_out -= left;
+            s->strm->total_out += left;
+            s->block_start += left;
+            len -= left;
+        }
+
+        /* Copy uncompressed bytes directly from next_in to next_out, updating
+         * the check value.
+         */
+        if (len) {
+            read_buf(s->strm, s->strm->next_out, len);
+            s->strm->next_out += len;
+            s->strm->avail_out -= len;
+            s->strm->total_out += len;
+        }
+    } while (last == 0);
+
+    /* Update the sliding window with the last s->w_size bytes of the copied
+     * data, or append all of the copied data to the existing window if less
+     * than s->w_size bytes were copied. Also update the number of bytes to
+     * insert in the hash tables, in the event that deflateParams() switches to
+     * a non-zero compression level.
+     */
+    used -= s->strm->avail_in;      /* number of input bytes directly copied */
+    if (used) {
+        /* If any input was used, then no unused input remains in the window,
+         * therefore s->block_start == s->strstart.
+         */
+        if (used >= s->w_size) {    /* supplant the previous history */
+            s->matches = 2;         /* clear hash */
+            zmemcpy(s->window, s->strm->next_in - s->w_size, s->w_size);
+            s->strstart = s->w_size;
+            s->insert = s->strstart;
+        }
+        else {
+            if (s->window_size - s->strstart <= used) {
+                /* Slide the window down. */
+                s->strstart -= s->w_size;
+                zmemcpy(s->window, s->window + s->w_size, s->strstart);
+                if (s->matches < 2)
+                    s->matches++;   /* add a pending slide_hash() */
+                if (s->insert > s->strstart)
+                    s->insert = s->strstart;
+            }
+            zmemcpy(s->window + s->strstart, s->strm->next_in - used, used);
+            s->strstart += used;
+            s->insert += MIN(used, s->w_size - s->insert);
+        }
+        s->block_start = s->strstart;
+    }
+    if (s->high_water < s->strstart)
+        s->high_water = s->strstart;
+
+    /* If the last block was written to next_out, then done. */
+    if (last)
+        return finish_done;
+
+    /* If flushing and all input has been consumed, then done. */
+    if (flush != Z_NO_FLUSH && flush != Z_FINISH &&
+        s->strm->avail_in == 0 && (long)s->strstart == s->block_start)
+        return block_done;
+
+    /* Fill the window with any remaining input. */
+    have = s->window_size - s->strstart;
+    if (s->strm->avail_in > have && s->block_start >= (long)s->w_size) {
+        /* Slide the window down. */
+        s->block_start -= s->w_size;
+        s->strstart -= s->w_size;
+        zmemcpy(s->window, s->window + s->w_size, s->strstart);
+        if (s->matches < 2)
+            s->matches++;           /* add a pending slide_hash() */
+        have += s->w_size;          /* more space now */
+        if (s->insert > s->strstart)
+            s->insert = s->strstart;
+    }
+    if (have > s->strm->avail_in)
+        have = s->strm->avail_in;
+    if (have) {
+        read_buf(s->strm, s->window + s->strstart, have);
+        s->strstart += have;
+        s->insert += MIN(have, s->w_size - s->insert);
+    }
+    if (s->high_water < s->strstart)
+        s->high_water = s->strstart;
+
+    /* There was not enough avail_out to write a complete worthy or flushed
+     * stored block to next_out. Write a stored block to pending instead, if we
+     * have enough input for a worthy block, or if flushing and there is enough
+     * room for the remaining input as a stored block in the pending buffer.
+     */
+    have = (s->bi_valid + 42) >> 3;         /* number of header bytes */
+        /* maximum stored block length that will fit in pending: */
+    have = MIN(s->pending_buf_size - have, MAX_STORED);
+    min_block = MIN(have, s->w_size);
+    left = s->strstart - s->block_start;
+    if (left >= min_block ||
+        ((left || flush == Z_FINISH) && flush != Z_NO_FLUSH &&
+         s->strm->avail_in == 0 && left <= have)) {
+        len = MIN(left, have);
+        last = flush == Z_FINISH && s->strm->avail_in == 0 &&
+               len == left ? 1 : 0;
+        _tr_stored_block(s, (charf *)s->window + s->block_start, len, last);
+        s->block_start += len;
+        flush_pending(s->strm);
+    }
+
+    /* We've done all we can with the available input and output. */
+    return last ? finish_started : need_more;
+}
+
+/* ===========================================================================
+ * Compress as much as possible from the input stream, return the current
+ * block state.
+ * This function does not perform lazy evaluation of matches and inserts
+ * new strings in the dictionary only for unmatched strings or for short
+ * matches. It is used only for the fast compression options.
+ */
+local block_state deflate_fast(s, flush)
+    deflate_state *s;
+    int flush;
+{
+    IPos hash_head;       /* head of the hash chain */
+    int bflush;           /* set if current block must be flushed */
+
+    for (;;) {
+        /* Make sure that we always have enough lookahead, except
+         * at the end of the input file. We need MAX_MATCH bytes
+         * for the next match, plus MIN_MATCH bytes to insert the
+         * string following the next match.
+         */
+        if (s->lookahead < MIN_LOOKAHEAD) {
+            fill_window(s);
+            if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
+                return need_more;
+            }
+            if (s->lookahead == 0) break; /* flush the current block */
+        }
+
+        /* Insert the string window[strstart .. strstart+2] in the
+         * dictionary, and set hash_head to the head of the hash chain:
+         */
+        hash_head = NIL;
+        if (s->lookahead >= MIN_MATCH) {
+            INSERT_STRING(s, s->strstart, hash_head);
+        }
+
+        /* Find the longest match, discarding those <= prev_length.
+         * At this point we have always match_length < MIN_MATCH
+         */
+        if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) {
+            /* To simplify the code, we prevent matches with the string
+             * of window index 0 (in particular we have to avoid a match
+             * of the string with itself at the start of the input file).
+             */
+            s->match_length = longest_match (s, hash_head);
+            /* longest_match() sets match_start */
+        }
+        if (s->match_length >= MIN_MATCH) {
+            check_match(s, s->strstart, s->match_start, s->match_length);
+
+            _tr_tally_dist(s, s->strstart - s->match_start,
+                           s->match_length - MIN_MATCH, bflush);
+
+            s->lookahead -= s->match_length;
+
+            /* Insert new strings in the hash table only if the match length
+             * is not too large. This saves time but degrades compression.
+             */
+#ifndef FASTEST
+            if (s->match_length <= s->max_insert_length &&
+                s->lookahead >= MIN_MATCH) {
+                s->match_length--; /* string at strstart already in table */
+                do {
+                    s->strstart++;
+                    INSERT_STRING(s, s->strstart, hash_head);
+                    /* strstart never exceeds WSIZE-MAX_MATCH, so there are
+                     * always MIN_MATCH bytes ahead.
+                     */
+                } while (--s->match_length != 0);
+                s->strstart++;
+            } else
+#endif
+            {
+                s->strstart += s->match_length;
+                s->match_length = 0;
+                s->ins_h = s->window[s->strstart];
+                UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
+#if MIN_MATCH != 3
+                Call UPDATE_HASH() MIN_MATCH-3 more times
+#endif
+                /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not
+                 * matter since it will be recomputed at next deflate call.
+                 */
+            }
+        } else {
+            /* No match, output a literal byte */
+            Tracevv((stderr,"%c", s->window[s->strstart]));
+            _tr_tally_lit (s, s->window[s->strstart], bflush);
+            s->lookahead--;
+            s->strstart++;
+        }
+        if (bflush) FLUSH_BLOCK(s, 0);
+    }
+    s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1;
+    if (flush == Z_FINISH) {
+        FLUSH_BLOCK(s, 1);
+        return finish_done;
+    }
+    if (s->last_lit)
+        FLUSH_BLOCK(s, 0);
+    return block_done;
+}
+
+#ifndef FASTEST
+/* ===========================================================================
+ * Same as above, but achieves better compression. We use a lazy
+ * evaluation for matches: a match is finally adopted only if there is
+ * no better match at the next window position.
+ */
+local block_state deflate_slow(s, flush)
+    deflate_state *s;
+    int flush;
+{
+    IPos hash_head;          /* head of hash chain */
+    int bflush;              /* set if current block must be flushed */
+
+    /* Process the input block. */
+    for (;;) {
+        /* Make sure that we always have enough lookahead, except
+         * at the end of the input file. We need MAX_MATCH bytes
+         * for the next match, plus MIN_MATCH bytes to insert the
+         * string following the next match.
+         */
+        if (s->lookahead < MIN_LOOKAHEAD) {
+            fill_window(s);
+            if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
+                return need_more;
+            }
+            if (s->lookahead == 0) break; /* flush the current block */
+        }
+
+        /* Insert the string window[strstart .. strstart+2] in the
+         * dictionary, and set hash_head to the head of the hash chain:
+         */
+        hash_head = NIL;
+        if (s->lookahead >= MIN_MATCH) {
+            INSERT_STRING(s, s->strstart, hash_head);
+        }
+
+        /* Find the longest match, discarding those <= prev_length.
+         */
+        s->prev_length = s->match_length, s->prev_match = s->match_start;
+        s->match_length = MIN_MATCH-1;
+
+        if (hash_head != NIL && s->prev_length < s->max_lazy_match &&
+            s->strstart - hash_head <= MAX_DIST(s)) {
+            /* To simplify the code, we prevent matches with the string
+             * of window index 0 (in particular we have to avoid a match
+             * of the string with itself at the start of the input file).
+             */
+            s->match_length = longest_match (s, hash_head);
+            /* longest_match() sets match_start */
+
+            if (s->match_length <= 5 && (s->strategy == Z_FILTERED
+#if TOO_FAR <= 32767
+                || (s->match_length == MIN_MATCH &&
+                    s->strstart - s->match_start > TOO_FAR)
+#endif
+                )) {
+
+                /* If prev_match is also MIN_MATCH, match_start is garbage
+                 * but we will ignore the current match anyway.
+                 */
+                s->match_length = MIN_MATCH-1;
+            }
+        }
+        /* If there was a match at the previous step and the current
+         * match is not better, output the previous match:
+         */
+        if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) {
+            uInt max_insert = s->strstart + s->lookahead - MIN_MATCH;
+            /* Do not insert strings in hash table beyond this. */
+
+            check_match(s, s->strstart-1, s->prev_match, s->prev_length);
+
+            _tr_tally_dist(s, s->strstart -1 - s->prev_match,
+                           s->prev_length - MIN_MATCH, bflush);
+
+            /* Insert in hash table all strings up to the end of the match.
+             * strstart-1 and strstart are already inserted. If there is not
+             * enough lookahead, the last two strings are not inserted in
+             * the hash table.
+             */
+            s->lookahead -= s->prev_length-1;
+            s->prev_length -= 2;
+            do {
+                if (++s->strstart <= max_insert) {
+                    INSERT_STRING(s, s->strstart, hash_head);
+                }
+            } while (--s->prev_length != 0);
+            s->match_available = 0;
+            s->match_length = MIN_MATCH-1;
+            s->strstart++;
+
+            if (bflush) FLUSH_BLOCK(s, 0);
+
+        } else if (s->match_available) {
+            /* If there was no match at the previous position, output a
+             * single literal. If there was a match but the current match
+             * is longer, truncate the previous match to a single literal.
+             */
+            Tracevv((stderr,"%c", s->window[s->strstart-1]));
+            _tr_tally_lit(s, s->window[s->strstart-1], bflush);
+            if (bflush) {
+                FLUSH_BLOCK_ONLY(s, 0);
+            }
+            s->strstart++;
+            s->lookahead--;
+            if (s->strm->avail_out == 0) return need_more;
+        } else {
+            /* There is no previous match to compare with, wait for
+             * the next step to decide.
+             */
+            s->match_available = 1;
+            s->strstart++;
+            s->lookahead--;
+        }
+    }
+    Assert (flush != Z_NO_FLUSH, "no flush?");
+    if (s->match_available) {
+        Tracevv((stderr,"%c", s->window[s->strstart-1]));
+        _tr_tally_lit(s, s->window[s->strstart-1], bflush);
+        s->match_available = 0;
+    }
+    s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1;
+    if (flush == Z_FINISH) {
+        FLUSH_BLOCK(s, 1);
+        return finish_done;
+    }
+    if (s->last_lit)
+        FLUSH_BLOCK(s, 0);
+    return block_done;
+}
+#endif /* FASTEST */
+
+/* ===========================================================================
+ * For Z_RLE, simply look for runs of bytes, generate matches only of distance
+ * one.  Do not maintain a hash table.  (It will be regenerated if this run of
+ * deflate switches away from Z_RLE.)
+ */
+local block_state deflate_rle(s, flush)
+    deflate_state *s;
+    int flush;
+{
+    int bflush;             /* set if current block must be flushed */
+    uInt prev;              /* byte at distance one to match */
+    Bytef *scan, *strend;   /* scan goes up to strend for length of run */
+
+    for (;;) {
+        /* Make sure that we always have enough lookahead, except
+         * at the end of the input file. We need MAX_MATCH bytes
+         * for the longest run, plus one for the unrolled loop.
+         */
+        if (s->lookahead <= MAX_MATCH) {
+            fill_window(s);
+            if (s->lookahead <= MAX_MATCH && flush == Z_NO_FLUSH) {
+                return need_more;
+            }
+            if (s->lookahead == 0) break; /* flush the current block */
+        }
+
+        /* See how many times the previous byte repeats */
+        s->match_length = 0;
+        if (s->lookahead >= MIN_MATCH && s->strstart > 0) {
+            scan = s->window + s->strstart - 1;
+            prev = *scan;
+            if (prev == *++scan && prev == *++scan && prev == *++scan) {
+                strend = s->window + s->strstart + MAX_MATCH;
+                do {
+                } while (prev == *++scan && prev == *++scan &&
+                         prev == *++scan && prev == *++scan &&
+                         prev == *++scan && prev == *++scan &&
+                         prev == *++scan && prev == *++scan &&
+                         scan < strend);
+                s->match_length = MAX_MATCH - (uInt)(strend - scan);
+                if (s->match_length > s->lookahead)
+                    s->match_length = s->lookahead;
+            }
+            Assert(scan <= s->window+(uInt)(s->window_size-1), "wild scan");
+        }
+
+        /* Emit match if have run of MIN_MATCH or longer, else emit literal */
+        if (s->match_length >= MIN_MATCH) {
+            check_match(s, s->strstart, s->strstart - 1, s->match_length);
+
+            _tr_tally_dist(s, 1, s->match_length - MIN_MATCH, bflush);
+
+            s->lookahead -= s->match_length;
+            s->strstart += s->match_length;
+            s->match_length = 0;
+        } else {
+            /* No match, output a literal byte */
+            Tracevv((stderr,"%c", s->window[s->strstart]));
+            _tr_tally_lit (s, s->window[s->strstart], bflush);
+            s->lookahead--;
+            s->strstart++;
+        }
+        if (bflush) FLUSH_BLOCK(s, 0);
+    }
+    s->insert = 0;
+    if (flush == Z_FINISH) {
+        FLUSH_BLOCK(s, 1);
+        return finish_done;
+    }
+    if (s->last_lit)
+        FLUSH_BLOCK(s, 0);
+    return block_done;
+}
+
+/* ===========================================================================
+ * For Z_HUFFMAN_ONLY, do not look for matches.  Do not maintain a hash table.
+ * (It will be regenerated if this run of deflate switches away from Huffman.)
+ */
+local block_state deflate_huff(s, flush)
+    deflate_state *s;
+    int flush;
+{
+    int bflush;             /* set if current block must be flushed */
+
+    for (;;) {
+        /* Make sure that we have a literal to write. */
+        if (s->lookahead == 0) {
+            fill_window(s);
+            if (s->lookahead == 0) {
+                if (flush == Z_NO_FLUSH)
+                    return need_more;
+                break;      /* flush the current block */
+            }
+        }
+
+        /* Output a literal byte */
+        s->match_length = 0;
+        Tracevv((stderr,"%c", s->window[s->strstart]));
+        _tr_tally_lit (s, s->window[s->strstart], bflush);
+        s->lookahead--;
+        s->strstart++;
+        if (bflush) FLUSH_BLOCK(s, 0);
+    }
+    s->insert = 0;
+    if (flush == Z_FINISH) {
+        FLUSH_BLOCK(s, 1);
+        return finish_done;
+    }
+    if (s->last_lit)
+        FLUSH_BLOCK(s, 0);
+    return block_done;
+}
diff --git a/Engine/lib/assimp/contrib/zlib/deflate.h b/Engine/lib/assimp/contrib/zlib/deflate.h
new file mode 100644
index 000000000..23ecdd312
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/deflate.h
@@ -0,0 +1,349 @@
+/* deflate.h -- internal compression state
+ * Copyright (C) 1995-2016 Jean-loup Gailly
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* @(#) $Id$ */
+
+#ifndef DEFLATE_H
+#define DEFLATE_H
+
+#include "zutil.h"
+
+/* define NO_GZIP when compiling if you want to disable gzip header and
+   trailer creation by deflate().  NO_GZIP would be used to avoid linking in
+   the crc code when it is not needed.  For shared libraries, gzip encoding
+   should be left enabled. */
+#ifndef NO_GZIP
+#  define GZIP
+#endif
+
+/* ===========================================================================
+ * Internal compression state.
+ */
+
+#define LENGTH_CODES 29
+/* number of length codes, not counting the special END_BLOCK code */
+
+#define LITERALS  256
+/* number of literal bytes 0..255 */
+
+#define L_CODES (LITERALS+1+LENGTH_CODES)
+/* number of Literal or Length codes, including the END_BLOCK code */
+
+#define D_CODES   30
+/* number of distance codes */
+
+#define BL_CODES  19
+/* number of codes used to transfer the bit lengths */
+
+#define HEAP_SIZE (2*L_CODES+1)
+/* maximum heap size */
+
+#define MAX_BITS 15
+/* All codes must not exceed MAX_BITS bits */
+
+#define Buf_size 16
+/* size of bit buffer in bi_buf */
+
+#define INIT_STATE    42    /* zlib header -> BUSY_STATE */
+#ifdef GZIP
+#  define GZIP_STATE  57    /* gzip header -> BUSY_STATE | EXTRA_STATE */
+#endif
+#define EXTRA_STATE   69    /* gzip extra block -> NAME_STATE */
+#define NAME_STATE    73    /* gzip file name -> COMMENT_STATE */
+#define COMMENT_STATE 91    /* gzip comment -> HCRC_STATE */
+#define HCRC_STATE   103    /* gzip header CRC -> BUSY_STATE */
+#define BUSY_STATE   113    /* deflate -> FINISH_STATE */
+#define FINISH_STATE 666    /* stream complete */
+/* Stream status */
+
+
+/* Data structure describing a single value and its code string. */
+typedef struct ct_data_s {
+    union {
+        ush  freq;       /* frequency count */
+        ush  code;       /* bit string */
+    } fc;
+    union {
+        ush  dad;        /* father node in Huffman tree */
+        ush  len;        /* length of bit string */
+    } dl;
+} FAR ct_data;
+
+#define Freq fc.freq
+#define Code fc.code
+#define Dad  dl.dad
+#define Len  dl.len
+
+typedef struct static_tree_desc_s  static_tree_desc;
+
+typedef struct tree_desc_s {
+    ct_data *dyn_tree;           /* the dynamic tree */
+    int     max_code;            /* largest code with non zero frequency */
+    const static_tree_desc *stat_desc;  /* the corresponding static tree */
+} FAR tree_desc;
+
+typedef ush Pos;
+typedef Pos FAR Posf;
+typedef unsigned IPos;
+
+/* A Pos is an index in the character window. We use short instead of int to
+ * save space in the various tables. IPos is used only for parameter passing.
+ */
+
+typedef struct internal_state {
+    z_streamp strm;      /* pointer back to this zlib stream */
+    int   status;        /* as the name implies */
+    Bytef *pending_buf;  /* output still pending */
+    ulg   pending_buf_size; /* size of pending_buf */
+    Bytef *pending_out;  /* next pending byte to output to the stream */
+    ulg   pending;       /* nb of bytes in the pending buffer */
+    int   wrap;          /* bit 0 true for zlib, bit 1 true for gzip */
+    gz_headerp  gzhead;  /* gzip header information to write */
+    ulg   gzindex;       /* where in extra, name, or comment */
+    Byte  method;        /* can only be DEFLATED */
+    int   last_flush;    /* value of flush param for previous deflate call */
+
+                /* used by deflate.c: */
+
+    uInt  w_size;        /* LZ77 window size (32K by default) */
+    uInt  w_bits;        /* log2(w_size)  (8..16) */
+    uInt  w_mask;        /* w_size - 1 */
+
+    Bytef *window;
+    /* Sliding window. Input bytes are read into the second half of the window,
+     * and move to the first half later to keep a dictionary of at least wSize
+     * bytes. With this organization, matches are limited to a distance of
+     * wSize-MAX_MATCH bytes, but this ensures that IO is always
+     * performed with a length multiple of the block size. Also, it limits
+     * the window size to 64K, which is quite useful on MSDOS.
+     * To do: use the user input buffer as sliding window.
+     */
+
+    ulg window_size;
+    /* Actual size of window: 2*wSize, except when the user input buffer
+     * is directly used as sliding window.
+     */
+
+    Posf *prev;
+    /* Link to older string with same hash index. To limit the size of this
+     * array to 64K, this link is maintained only for the last 32K strings.
+     * An index in this array is thus a window index modulo 32K.
+     */
+
+    Posf *head; /* Heads of the hash chains or NIL. */
+
+    uInt  ins_h;          /* hash index of string to be inserted */
+    uInt  hash_size;      /* number of elements in hash table */
+    uInt  hash_bits;      /* log2(hash_size) */
+    uInt  hash_mask;      /* hash_size-1 */
+
+    uInt  hash_shift;
+    /* Number of bits by which ins_h must be shifted at each input
+     * step. It must be such that after MIN_MATCH steps, the oldest
+     * byte no longer takes part in the hash key, that is:
+     *   hash_shift * MIN_MATCH >= hash_bits
+     */
+
+    long block_start;
+    /* Window position at the beginning of the current output block. Gets
+     * negative when the window is moved backwards.
+     */
+
+    uInt match_length;           /* length of best match */
+    IPos prev_match;             /* previous match */
+    int match_available;         /* set if previous match exists */
+    uInt strstart;               /* start of string to insert */
+    uInt match_start;            /* start of matching string */
+    uInt lookahead;              /* number of valid bytes ahead in window */
+
+    uInt prev_length;
+    /* Length of the best match at previous step. Matches not greater than this
+     * are discarded. This is used in the lazy match evaluation.
+     */
+
+    uInt max_chain_length;
+    /* To speed up deflation, hash chains are never searched beyond this
+     * length.  A higher limit improves compression ratio but degrades the
+     * speed.
+     */
+
+    uInt max_lazy_match;
+    /* Attempt to find a better match only when the current match is strictly
+     * smaller than this value. This mechanism is used only for compression
+     * levels >= 4.
+     */
+#   define max_insert_length  max_lazy_match
+    /* Insert new strings in the hash table only if the match length is not
+     * greater than this length. This saves time but degrades compression.
+     * max_insert_length is used only for compression levels <= 3.
+     */
+
+    int level;    /* compression level (1..9) */
+    int strategy; /* favor or force Huffman coding*/
+
+    uInt good_match;
+    /* Use a faster search when the previous match is longer than this */
+
+    int nice_match; /* Stop searching when current match exceeds this */
+
+                /* used by trees.c: */
+    /* Didn't use ct_data typedef below to suppress compiler warning */
+    struct ct_data_s dyn_ltree[HEAP_SIZE];   /* literal and length tree */
+    struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */
+    struct ct_data_s bl_tree[2*BL_CODES+1];  /* Huffman tree for bit lengths */
+
+    struct tree_desc_s l_desc;               /* desc. for literal tree */
+    struct tree_desc_s d_desc;               /* desc. for distance tree */
+    struct tree_desc_s bl_desc;              /* desc. for bit length tree */
+
+    ush bl_count[MAX_BITS+1];
+    /* number of codes at each bit length for an optimal tree */
+
+    int heap[2*L_CODES+1];      /* heap used to build the Huffman trees */
+    int heap_len;               /* number of elements in the heap */
+    int heap_max;               /* element of largest frequency */
+    /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
+     * The same heap array is used to build all trees.
+     */
+
+    uch depth[2*L_CODES+1];
+    /* Depth of each subtree used as tie breaker for trees of equal frequency
+     */
+
+    uchf *l_buf;          /* buffer for literals or lengths */
+
+    uInt  lit_bufsize;
+    /* Size of match buffer for literals/lengths.  There are 4 reasons for
+     * limiting lit_bufsize to 64K:
+     *   - frequencies can be kept in 16 bit counters
+     *   - if compression is not successful for the first block, all input
+     *     data is still in the window so we can still emit a stored block even
+     *     when input comes from standard input.  (This can also be done for
+     *     all blocks if lit_bufsize is not greater than 32K.)
+     *   - if compression is not successful for a file smaller than 64K, we can
+     *     even emit a stored file instead of a stored block (saving 5 bytes).
+     *     This is applicable only for zip (not gzip or zlib).
+     *   - creating new Huffman trees less frequently may not provide fast
+     *     adaptation to changes in the input data statistics. (Take for
+     *     example a binary file with poorly compressible code followed by
+     *     a highly compressible string table.) Smaller buffer sizes give
+     *     fast adaptation but have of course the overhead of transmitting
+     *     trees more frequently.
+     *   - I can't count above 4
+     */
+
+    uInt last_lit;      /* running index in l_buf */
+
+    ushf *d_buf;
+    /* Buffer for distances. To simplify the code, d_buf and l_buf have
+     * the same number of elements. To use different lengths, an extra flag
+     * array would be necessary.
+     */
+
+    ulg opt_len;        /* bit length of current block with optimal trees */
+    ulg static_len;     /* bit length of current block with static trees */
+    uInt matches;       /* number of string matches in current block */
+    uInt insert;        /* bytes at end of window left to insert */
+
+#ifdef ZLIB_DEBUG
+    ulg compressed_len; /* total bit length of compressed file mod 2^32 */
+    ulg bits_sent;      /* bit length of compressed data sent mod 2^32 */
+#endif
+
+    ush bi_buf;
+    /* Output buffer. bits are inserted starting at the bottom (least
+     * significant bits).
+     */
+    int bi_valid;
+    /* Number of valid bits in bi_buf.  All bits above the last valid bit
+     * are always zero.
+     */
+
+    ulg high_water;
+    /* High water mark offset in window for initialized bytes -- bytes above
+     * this are set to zero in order to avoid memory check warnings when
+     * longest match routines access bytes past the input.  This is then
+     * updated to the new high water mark.
+     */
+
+} FAR deflate_state;
+
+/* Output a byte on the stream.
+ * IN assertion: there is enough room in pending_buf.
+ */
+#define put_byte(s, c) {s->pending_buf[s->pending++] = (Bytef)(c);}
+
+
+#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
+/* Minimum amount of lookahead, except at the end of the input file.
+ * See deflate.c for comments about the MIN_MATCH+1.
+ */
+
+#define MAX_DIST(s)  ((s)->w_size-MIN_LOOKAHEAD)
+/* In order to simplify the code, particularly on 16 bit machines, match
+ * distances are limited to MAX_DIST instead of WSIZE.
+ */
+
+#define WIN_INIT MAX_MATCH
+/* Number of bytes after end of data in window to initialize in order to avoid
+   memory checker errors from longest match routines */
+
+        /* in trees.c */
+void ZLIB_INTERNAL _tr_init OF((deflate_state *s));
+int ZLIB_INTERNAL _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc));
+void ZLIB_INTERNAL _tr_flush_block OF((deflate_state *s, charf *buf,
+                        ulg stored_len, int last));
+void ZLIB_INTERNAL _tr_flush_bits OF((deflate_state *s));
+void ZLIB_INTERNAL _tr_align OF((deflate_state *s));
+void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf,
+                        ulg stored_len, int last));
+
+#define d_code(dist) \
+   ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)])
+/* Mapping from a distance to a distance code. dist is the distance - 1 and
+ * must not have side effects. _dist_code[256] and _dist_code[257] are never
+ * used.
+ */
+
+#ifndef ZLIB_DEBUG
+/* Inline versions of _tr_tally for speed: */
+
+#if defined(GEN_TREES_H) || !defined(STDC)
+  extern uch ZLIB_INTERNAL _length_code[];
+  extern uch ZLIB_INTERNAL _dist_code[];
+#else
+  extern const uch ZLIB_INTERNAL _length_code[];
+  extern const uch ZLIB_INTERNAL _dist_code[];
+#endif
+
+# define _tr_tally_lit(s, c, flush) \
+  { uch cc = (c); \
+    s->d_buf[s->last_lit] = 0; \
+    s->l_buf[s->last_lit++] = cc; \
+    s->dyn_ltree[cc].Freq++; \
+    flush = (s->last_lit == s->lit_bufsize-1); \
+   }
+# define _tr_tally_dist(s, distance, length, flush) \
+  { uch len = (uch)(length); \
+    ush dist = (ush)(distance); \
+    s->d_buf[s->last_lit] = dist; \
+    s->l_buf[s->last_lit++] = len; \
+    dist--; \
+    s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \
+    s->dyn_dtree[d_code(dist)].Freq++; \
+    flush = (s->last_lit == s->lit_bufsize-1); \
+  }
+#else
+# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c)
+# define _tr_tally_dist(s, distance, length, flush) \
+              flush = _tr_tally(s, distance, length)
+#endif
+
+#endif /* DEFLATE_H */
diff --git a/Engine/lib/assimp/contrib/zlib/gzclose.c b/Engine/lib/assimp/contrib/zlib/gzclose.c
new file mode 100644
index 000000000..caeb99a31
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/gzclose.c
@@ -0,0 +1,25 @@
+/* gzclose.c -- zlib gzclose() function
+ * Copyright (C) 2004, 2010 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "gzguts.h"
+
+/* gzclose() is in a separate file so that it is linked in only if it is used.
+   That way the other gzclose functions can be used instead to avoid linking in
+   unneeded compression or decompression routines. */
+int ZEXPORT gzclose(file)
+    gzFile file;
+{
+#ifndef NO_GZCOMPRESS
+    gz_statep state;
+
+    if (file == NULL)
+        return Z_STREAM_ERROR;
+    state = (gz_statep)file;
+
+    return state->mode == GZ_READ ? gzclose_r(file) : gzclose_w(file);
+#else
+    return gzclose_r(file);
+#endif
+}
diff --git a/Engine/lib/assimp/contrib/zlib/gzguts.h b/Engine/lib/assimp/contrib/zlib/gzguts.h
new file mode 100644
index 000000000..6378d468a
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/gzguts.h
@@ -0,0 +1,218 @@
+/* gzguts.h -- zlib internal header definitions for gz* operations
+ * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013, 2016 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#ifdef _LARGEFILE64_SOURCE
+#  ifndef _LARGEFILE_SOURCE
+#    define _LARGEFILE_SOURCE 1
+#  endif
+#  ifdef _FILE_OFFSET_BITS
+#    undef _FILE_OFFSET_BITS
+#  endif
+#endif
+
+#ifdef HAVE_HIDDEN
+#  define ZLIB_INTERNAL __attribute__((visibility ("hidden")))
+#else
+#  define ZLIB_INTERNAL
+#endif
+
+#include <stdio.h>
+#include "zlib.h"
+#ifdef STDC
+#  include <string.h>
+#  include <stdlib.h>
+#  include <limits.h>
+#endif
+
+#ifndef _POSIX_SOURCE
+#  define _POSIX_SOURCE
+#endif
+#include <fcntl.h>
+
+#ifdef _WIN32
+#  include <stddef.h>
+#endif
+
+#if defined(__TURBOC__) || defined(_MSC_VER) || defined(_WIN32)
+#  include <io.h>
+#endif
+
+#if defined(_WIN32)
+#  define WIDECHAR
+#endif
+
+#ifdef WINAPI_FAMILY
+#  define open _open
+#  define read _read
+#  define write _write
+#  define close _close
+#endif
+
+#ifdef NO_DEFLATE       /* for compatibility with old definition */
+#  define NO_GZCOMPRESS
+#endif
+
+#if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550)
+#  ifndef HAVE_VSNPRINTF
+#    define HAVE_VSNPRINTF
+#  endif
+#endif
+
+#if defined(__CYGWIN__)
+#  ifndef HAVE_VSNPRINTF
+#    define HAVE_VSNPRINTF
+#  endif
+#endif
+
+#if defined(MSDOS) && defined(__BORLANDC__) && (BORLANDC > 0x410)
+#  ifndef HAVE_VSNPRINTF
+#    define HAVE_VSNPRINTF
+#  endif
+#endif
+
+#ifndef HAVE_VSNPRINTF
+#  ifdef MSDOS
+/* vsnprintf may exist on some MS-DOS compilers (DJGPP?),
+   but for now we just assume it doesn't. */
+#    define NO_vsnprintf
+#  endif
+#  ifdef __TURBOC__
+#    define NO_vsnprintf
+#  endif
+#  ifdef WIN32
+/* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */
+#    if !defined(vsnprintf) && !defined(NO_vsnprintf)
+#      if !defined(_MSC_VER) || ( defined(_MSC_VER) && _MSC_VER < 1500 )
+#         define vsnprintf _vsnprintf
+#      endif
+#    endif
+#  endif
+#  ifdef __SASC
+#    define NO_vsnprintf
+#  endif
+#  ifdef VMS
+#    define NO_vsnprintf
+#  endif
+#  ifdef __OS400__
+#    define NO_vsnprintf
+#  endif
+#  ifdef __MVS__
+#    define NO_vsnprintf
+#  endif
+#endif
+
+/* unlike snprintf (which is required in C99), _snprintf does not guarantee
+   null termination of the result -- however this is only used in gzlib.c where
+   the result is assured to fit in the space provided */
+#if defined(_MSC_VER) && _MSC_VER < 1900
+#  define snprintf _snprintf
+#endif
+
+#ifndef local
+#  define local static
+#endif
+/* since "static" is used to mean two completely different things in C, we
+   define "local" for the non-static meaning of "static", for readability
+   (compile with -Dlocal if your debugger can't find static symbols) */
+
+/* gz* functions always use library allocation functions */
+#ifndef STDC
+  extern voidp  malloc OF((uInt size));
+  extern void   free   OF((voidpf ptr));
+#endif
+
+/* get errno and strerror definition */
+#if defined UNDER_CE
+#  include <windows.h>
+#  define zstrerror() gz_strwinerror((DWORD)GetLastError())
+#else
+#  ifndef NO_STRERROR
+#    include <errno.h>
+#    define zstrerror() strerror(errno)
+#  else
+#    define zstrerror() "stdio error (consult errno)"
+#  endif
+#endif
+
+/* provide prototypes for these when building zlib without LFS */
+#if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0
+    ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
+    ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int));
+    ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile));
+    ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile));
+#endif
+
+/* default memLevel */
+#if MAX_MEM_LEVEL >= 8
+#  define DEF_MEM_LEVEL 8
+#else
+#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
+#endif
+
+/* default i/o buffer size -- double this for output when reading (this and
+   twice this must be able to fit in an unsigned type) */
+#define GZBUFSIZE 8192
+
+/* gzip modes, also provide a little integrity check on the passed structure */
+#define GZ_NONE 0
+#define GZ_READ 7247
+#define GZ_WRITE 31153
+#define GZ_APPEND 1     /* mode set to GZ_WRITE after the file is opened */
+
+/* values for gz_state how */
+#define LOOK 0      /* look for a gzip header */
+#define COPY 1      /* copy input directly */
+#define GZIP 2      /* decompress a gzip stream */
+
+/* internal gzip file state data structure */
+typedef struct {
+        /* exposed contents for gzgetc() macro */
+    struct gzFile_s x;      /* "x" for exposed */
+                            /* x.have: number of bytes available at x.next */
+                            /* x.next: next output data to deliver or write */
+                            /* x.pos: current position in uncompressed data */
+        /* used for both reading and writing */
+    int mode;               /* see gzip modes above */
+    int fd;                 /* file descriptor */
+    char *path;             /* path or fd for error messages */
+    unsigned size;          /* buffer size, zero if not allocated yet */
+    unsigned want;          /* requested buffer size, default is GZBUFSIZE */
+    unsigned char *in;      /* input buffer (double-sized when writing) */
+    unsigned char *out;     /* output buffer (double-sized when reading) */
+    int direct;             /* 0 if processing gzip, 1 if transparent */
+        /* just for reading */
+    int how;                /* 0: get header, 1: copy, 2: decompress */
+    z_off64_t start;        /* where the gzip data started, for rewinding */
+    int eof;                /* true if end of input file reached */
+    int past;               /* true if read requested past end */
+        /* just for writing */
+    int level;              /* compression level */
+    int strategy;           /* compression strategy */
+        /* seek request */
+    z_off64_t skip;         /* amount to skip (already rewound if backwards) */
+    int seek;               /* true if seek request pending */
+        /* error information */
+    int err;                /* error code */
+    char *msg;              /* error message */
+        /* zlib inflate or deflate stream */
+    z_stream strm;          /* stream structure in-place (not a pointer) */
+} gz_state;
+typedef gz_state FAR *gz_statep;
+
+/* shared functions */
+void ZLIB_INTERNAL gz_error OF((gz_statep, int, const char *));
+#if defined UNDER_CE
+char ZLIB_INTERNAL *gz_strwinerror OF((DWORD error));
+#endif
+
+/* GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t
+   value -- needed when comparing unsigned to z_off64_t, which is signed
+   (possible z_off64_t types off_t, off64_t, and long are all signed) */
+#ifdef INT_MAX
+#  define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > INT_MAX)
+#else
+unsigned ZLIB_INTERNAL gz_intmax OF((void));
+#  define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > gz_intmax())
+#endif
diff --git a/Engine/lib/assimp/contrib/zlib/gzlib.c b/Engine/lib/assimp/contrib/zlib/gzlib.c
new file mode 100644
index 000000000..4838bf047
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/gzlib.c
@@ -0,0 +1,637 @@
+/* gzlib.c -- zlib functions common to reading and writing gzip files
+ * Copyright (C) 2004-2017 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "gzguts.h"
+
+#if defined(_WIN32) && !defined(__BORLANDC__)
+#  define LSEEK _lseeki64
+#else
+#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0
+#  define LSEEK lseek64
+#else
+#  define LSEEK lseek
+#endif
+#endif
+
+/* Local functions */
+local void gz_reset OF((gz_statep));
+local gzFile gz_open OF((const void *, int, const char *));
+
+#if defined UNDER_CE
+
+/* Map the Windows error number in ERROR to a locale-dependent error message
+   string and return a pointer to it.  Typically, the values for ERROR come
+   from GetLastError.
+
+   The string pointed to shall not be modified by the application, but may be
+   overwritten by a subsequent call to gz_strwinerror
+
+   The gz_strwinerror function does not change the current setting of
+   GetLastError. */
+char ZLIB_INTERNAL *gz_strwinerror (error)
+     DWORD error;
+{
+    static char buf[1024];
+
+    wchar_t *msgbuf;
+    DWORD lasterr = GetLastError();
+    DWORD chars = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM
+        | FORMAT_MESSAGE_ALLOCATE_BUFFER,
+        NULL,
+        error,
+        0, /* Default language */
+        (LPVOID)&msgbuf,
+        0,
+        NULL);
+    if (chars != 0) {
+        /* If there is an \r\n appended, zap it.  */
+        if (chars >= 2
+            && msgbuf[chars - 2] == '\r' && msgbuf[chars - 1] == '\n') {
+            chars -= 2;
+            msgbuf[chars] = 0;
+        }
+
+        if (chars > sizeof (buf) - 1) {
+            chars = sizeof (buf) - 1;
+            msgbuf[chars] = 0;
+        }
+
+        wcstombs(buf, msgbuf, chars + 1);
+        LocalFree(msgbuf);
+    }
+    else {
+        sprintf(buf, "unknown win32 error (%ld)", error);
+    }
+
+    SetLastError(lasterr);
+    return buf;
+}
+
+#endif /* UNDER_CE */
+
+/* Reset gzip file state */
+local void gz_reset(state)
+    gz_statep state;
+{
+    state->x.have = 0;              /* no output data available */
+    if (state->mode == GZ_READ) {   /* for reading ... */
+        state->eof = 0;             /* not at end of file */
+        state->past = 0;            /* have not read past end yet */
+        state->how = LOOK;          /* look for gzip header */
+    }
+    state->seek = 0;                /* no seek request pending */
+    gz_error(state, Z_OK, NULL);    /* clear error */
+    state->x.pos = 0;               /* no uncompressed data yet */
+    state->strm.avail_in = 0;       /* no input data yet */
+}
+
+/* Open a gzip file either by name or file descriptor. */
+local gzFile gz_open(path, fd, mode)
+    const void *path;
+    int fd;
+    const char *mode;
+{
+    gz_statep state;
+    z_size_t len;
+    int oflag;
+#ifdef O_CLOEXEC
+    int cloexec = 0;
+#endif
+#ifdef O_EXCL
+    int exclusive = 0;
+#endif
+
+    /* check input */
+    if (path == NULL)
+        return NULL;
+
+    /* allocate gzFile structure to return */
+    state = (gz_statep)malloc(sizeof(gz_state));
+    if (state == NULL)
+        return NULL;
+    state->size = 0;            /* no buffers allocated yet */
+    state->want = GZBUFSIZE;    /* requested buffer size */
+    state->msg = NULL;          /* no error message yet */
+
+    /* interpret mode */
+    state->mode = GZ_NONE;
+    state->level = Z_DEFAULT_COMPRESSION;
+    state->strategy = Z_DEFAULT_STRATEGY;
+    state->direct = 0;
+    while (*mode) {
+        if (*mode >= '0' && *mode <= '9')
+            state->level = *mode - '0';
+        else
+            switch (*mode) {
+            case 'r':
+                state->mode = GZ_READ;
+                break;
+#ifndef NO_GZCOMPRESS
+            case 'w':
+                state->mode = GZ_WRITE;
+                break;
+            case 'a':
+                state->mode = GZ_APPEND;
+                break;
+#endif
+            case '+':       /* can't read and write at the same time */
+                free(state);
+                return NULL;
+            case 'b':       /* ignore -- will request binary anyway */
+                break;
+#ifdef O_CLOEXEC
+            case 'e':
+                cloexec = 1;
+                break;
+#endif
+#ifdef O_EXCL
+            case 'x':
+                exclusive = 1;
+                break;
+#endif
+            case 'f':
+                state->strategy = Z_FILTERED;
+                break;
+            case 'h':
+                state->strategy = Z_HUFFMAN_ONLY;
+                break;
+            case 'R':
+                state->strategy = Z_RLE;
+                break;
+            case 'F':
+                state->strategy = Z_FIXED;
+                break;
+            case 'T':
+                state->direct = 1;
+                break;
+            default:        /* could consider as an error, but just ignore */
+                ;
+            }
+        mode++;
+    }
+
+    /* must provide an "r", "w", or "a" */
+    if (state->mode == GZ_NONE) {
+        free(state);
+        return NULL;
+    }
+
+    /* can't force transparent read */
+    if (state->mode == GZ_READ) {
+        if (state->direct) {
+            free(state);
+            return NULL;
+        }
+        state->direct = 1;      /* for empty file */
+    }
+
+    /* save the path name for error messages */
+#ifdef WIDECHAR
+    if (fd == -2) {
+        len = wcstombs(NULL, path, 0);
+        if (len == (z_size_t)-1)
+            len = 0;
+    }
+    else
+#endif
+        len = strlen((const char *)path);
+    state->path = (char *)malloc(len + 1);
+    if (state->path == NULL) {
+        free(state);
+        return NULL;
+    }
+#ifdef WIDECHAR
+    if (fd == -2)
+        if (len)
+            wcstombs(state->path, path, len + 1);
+        else
+            *(state->path) = 0;
+    else
+#endif
+#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
+        (void)snprintf(state->path, len + 1, "%s", (const char *)path);
+#else
+        strcpy(state->path, path);
+#endif
+
+    /* compute the flags for open() */
+    oflag =
+#ifdef O_LARGEFILE
+        O_LARGEFILE |
+#endif
+#ifdef O_BINARY
+        O_BINARY |
+#endif
+#ifdef O_CLOEXEC
+        (cloexec ? O_CLOEXEC : 0) |
+#endif
+        (state->mode == GZ_READ ?
+         O_RDONLY :
+         (O_WRONLY | O_CREAT |
+#ifdef O_EXCL
+          (exclusive ? O_EXCL : 0) |
+#endif
+          (state->mode == GZ_WRITE ?
+           O_TRUNC :
+           O_APPEND)));
+
+    /* open the file with the appropriate flags (or just use fd) */
+    state->fd = fd > -1 ? fd : (
+#ifdef WIDECHAR
+        fd == -2 ? _wopen(path, oflag, 0666) :
+#endif
+        open((const char *)path, oflag, 0666));
+    if (state->fd == -1) {
+        free(state->path);
+        free(state);
+        return NULL;
+    }
+    if (state->mode == GZ_APPEND) {
+        LSEEK(state->fd, 0, SEEK_END);  /* so gzoffset() is correct */
+        state->mode = GZ_WRITE;         /* simplify later checks */
+    }
+
+    /* save the current position for rewinding (only if reading) */
+    if (state->mode == GZ_READ) {
+        state->start = LSEEK(state->fd, 0, SEEK_CUR);
+        if (state->start == -1) state->start = 0;
+    }
+
+    /* initialize stream */
+    gz_reset(state);
+
+    /* return stream */
+    return (gzFile)state;
+}
+
+/* -- see zlib.h -- */
+gzFile ZEXPORT gzopen(path, mode)
+    const char *path;
+    const char *mode;
+{
+    return gz_open(path, -1, mode);
+}
+
+/* -- see zlib.h -- */
+gzFile ZEXPORT gzopen64(path, mode)
+    const char *path;
+    const char *mode;
+{
+    return gz_open(path, -1, mode);
+}
+
+/* -- see zlib.h -- */
+gzFile ZEXPORT gzdopen(fd, mode)
+    int fd;
+    const char *mode;
+{
+    char *path;         /* identifier for error messages */
+    gzFile gz;
+
+    if (fd == -1 || (path = (char *)malloc(7 + 3 * sizeof(int))) == NULL)
+        return NULL;
+#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
+    (void)snprintf(path, 7 + 3 * sizeof(int), "<fd:%d>", fd);
+#else
+    sprintf(path, "<fd:%d>", fd);   /* for debugging */
+#endif
+    gz = gz_open(path, fd, mode);
+    free(path);
+    return gz;
+}
+
+/* -- see zlib.h -- */
+#ifdef WIDECHAR
+gzFile ZEXPORT gzopen_w(path, mode)
+    const wchar_t *path;
+    const char *mode;
+{
+    return gz_open(path, -2, mode);
+}
+#endif
+
+/* -- see zlib.h -- */
+int ZEXPORT gzbuffer(file, size)
+    gzFile file;
+    unsigned size;
+{
+    gz_statep state;
+
+    /* get internal structure and check integrity */
+    if (file == NULL)
+        return -1;
+    state = (gz_statep)file;
+    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
+        return -1;
+
+    /* make sure we haven't already allocated memory */
+    if (state->size != 0)
+        return -1;
+
+    /* check and set requested size */
+    if ((size << 1) < size)
+        return -1;              /* need to be able to double it */
+    if (size < 2)
+        size = 2;               /* need two bytes to check magic header */
+    state->want = size;
+    return 0;
+}
+
+/* -- see zlib.h -- */
+int ZEXPORT gzrewind(file)
+    gzFile file;
+{
+    gz_statep state;
+
+    /* get internal structure */
+    if (file == NULL)
+        return -1;
+    state = (gz_statep)file;
+
+    /* check that we're reading and that there's no error */
+    if (state->mode != GZ_READ ||
+            (state->err != Z_OK && state->err != Z_BUF_ERROR))
+        return -1;
+
+    /* back up and start over */
+    if (LSEEK(state->fd, state->start, SEEK_SET) == -1)
+        return -1;
+    gz_reset(state);
+    return 0;
+}
+
+/* -- see zlib.h -- */
+z_off64_t ZEXPORT gzseek64(file, offset, whence)
+    gzFile file;
+    z_off64_t offset;
+    int whence;
+{
+    unsigned n;
+    z_off64_t ret;
+    gz_statep state;
+
+    /* get internal structure and check integrity */
+    if (file == NULL)
+        return -1;
+    state = (gz_statep)file;
+    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
+        return -1;
+
+    /* check that there's no error */
+    if (state->err != Z_OK && state->err != Z_BUF_ERROR)
+        return -1;
+
+    /* can only seek from start or relative to current position */
+    if (whence != SEEK_SET && whence != SEEK_CUR)
+        return -1;
+
+    /* normalize offset to a SEEK_CUR specification */
+    if (whence == SEEK_SET)
+        offset -= state->x.pos;
+    else if (state->seek)
+        offset += state->skip;
+    state->seek = 0;
+
+    /* if within raw area while reading, just go there */
+    if (state->mode == GZ_READ && state->how == COPY &&
+            state->x.pos + offset >= 0) {
+        ret = LSEEK(state->fd, offset - (z_off64_t)state->x.have, SEEK_CUR);
+        if (ret == -1)
+            return -1;
+        state->x.have = 0;
+        state->eof = 0;
+        state->past = 0;
+        state->seek = 0;
+        gz_error(state, Z_OK, NULL);
+        state->strm.avail_in = 0;
+        state->x.pos += offset;
+        return state->x.pos;
+    }
+
+    /* calculate skip amount, rewinding if needed for back seek when reading */
+    if (offset < 0) {
+        if (state->mode != GZ_READ)         /* writing -- can't go backwards */
+            return -1;
+        offset += state->x.pos;
+        if (offset < 0)                     /* before start of file! */
+            return -1;
+        if (gzrewind(file) == -1)           /* rewind, then skip to offset */
+            return -1;
+    }
+
+    /* if reading, skip what's in output buffer (one less gzgetc() check) */
+    if (state->mode == GZ_READ) {
+        n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > offset ?
+            (unsigned)offset : state->x.have;
+        state->x.have -= n;
+        state->x.next += n;
+        state->x.pos += n;
+        offset -= n;
+    }
+
+    /* request skip (if not zero) */
+    if (offset) {
+        state->seek = 1;
+        state->skip = offset;
+    }
+    return state->x.pos + offset;
+}
+
+/* -- see zlib.h -- */
+z_off_t ZEXPORT gzseek(file, offset, whence)
+    gzFile file;
+    z_off_t offset;
+    int whence;
+{
+    z_off64_t ret;
+
+    ret = gzseek64(file, (z_off64_t)offset, whence);
+    return ret == (z_off_t)ret ? (z_off_t)ret : -1;
+}
+
+/* -- see zlib.h -- */
+z_off64_t ZEXPORT gztell64(file)
+    gzFile file;
+{
+    gz_statep state;
+
+    /* get internal structure and check integrity */
+    if (file == NULL)
+        return -1;
+    state = (gz_statep)file;
+    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
+        return -1;
+
+    /* return position */
+    return state->x.pos + (state->seek ? state->skip : 0);
+}
+
+/* -- see zlib.h -- */
+z_off_t ZEXPORT gztell(file)
+    gzFile file;
+{
+    z_off64_t ret;
+
+    ret = gztell64(file);
+    return ret == (z_off_t)ret ? (z_off_t)ret : -1;
+}
+
+/* -- see zlib.h -- */
+z_off64_t ZEXPORT gzoffset64(file)
+    gzFile file;
+{
+    z_off64_t offset;
+    gz_statep state;
+
+    /* get internal structure and check integrity */
+    if (file == NULL)
+        return -1;
+    state = (gz_statep)file;
+    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
+        return -1;
+
+    /* compute and return effective offset in file */
+    offset = LSEEK(state->fd, 0, SEEK_CUR);
+    if (offset == -1)
+        return -1;
+    if (state->mode == GZ_READ)             /* reading */
+        offset -= state->strm.avail_in;     /* don't count buffered input */
+    return offset;
+}
+
+/* -- see zlib.h -- */
+z_off_t ZEXPORT gzoffset(file)
+    gzFile file;
+{
+    z_off64_t ret;
+
+    ret = gzoffset64(file);
+    return ret == (z_off_t)ret ? (z_off_t)ret : -1;
+}
+
+/* -- see zlib.h -- */
+int ZEXPORT gzeof(file)
+    gzFile file;
+{
+    gz_statep state;
+
+    /* get internal structure and check integrity */
+    if (file == NULL)
+        return 0;
+    state = (gz_statep)file;
+    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
+        return 0;
+
+    /* return end-of-file state */
+    return state->mode == GZ_READ ? state->past : 0;
+}
+
+/* -- see zlib.h -- */
+const char * ZEXPORT gzerror(file, errnum)
+    gzFile file;
+    int *errnum;
+{
+    gz_statep state;
+
+    /* get internal structure and check integrity */
+    if (file == NULL)
+        return NULL;
+    state = (gz_statep)file;
+    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
+        return NULL;
+
+    /* return error information */
+    if (errnum != NULL)
+        *errnum = state->err;
+    return state->err == Z_MEM_ERROR ? "out of memory" :
+                                       (state->msg == NULL ? "" : state->msg);
+}
+
+/* -- see zlib.h -- */
+void ZEXPORT gzclearerr(file)
+    gzFile file;
+{
+    gz_statep state;
+
+    /* get internal structure and check integrity */
+    if (file == NULL)
+        return;
+    state = (gz_statep)file;
+    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
+        return;
+
+    /* clear error and end-of-file */
+    if (state->mode == GZ_READ) {
+        state->eof = 0;
+        state->past = 0;
+    }
+    gz_error(state, Z_OK, NULL);
+}
+
+/* Create an error message in allocated memory and set state->err and
+   state->msg accordingly.  Free any previous error message already there.  Do
+   not try to free or allocate space if the error is Z_MEM_ERROR (out of
+   memory).  Simply save the error message as a static string.  If there is an
+   allocation failure constructing the error message, then convert the error to
+   out of memory. */
+void ZLIB_INTERNAL gz_error(state, err, msg)
+    gz_statep state;
+    int err;
+    const char *msg;
+{
+    /* free previously allocated message and clear */
+    if (state->msg != NULL) {
+        if (state->err != Z_MEM_ERROR)
+            free(state->msg);
+        state->msg = NULL;
+    }
+
+    /* if fatal, set state->x.have to 0 so that the gzgetc() macro fails */
+    if (err != Z_OK && err != Z_BUF_ERROR)
+        state->x.have = 0;
+
+    /* set error code, and if no message, then done */
+    state->err = err;
+    if (msg == NULL)
+        return;
+
+    /* for an out of memory error, return literal string when requested */
+    if (err == Z_MEM_ERROR)
+        return;
+
+    /* construct error message with path */
+    if ((state->msg = (char *)malloc(strlen(state->path) + strlen(msg) + 3)) ==
+            NULL) {
+        state->err = Z_MEM_ERROR;
+        return;
+    }
+#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
+    (void)snprintf(state->msg, strlen(state->path) + strlen(msg) + 3,
+                   "%s%s%s", state->path, ": ", msg);
+#else
+    strcpy(state->msg, state->path);
+    strcat(state->msg, ": ");
+    strcat(state->msg, msg);
+#endif
+}
+
+#ifndef INT_MAX
+/* portably return maximum value for an int (when limits.h presumed not
+   available) -- we need to do this to cover cases where 2's complement not
+   used, since C standard permits 1's complement and sign-bit representations,
+   otherwise we could just use ((unsigned)-1) >> 1 */
+unsigned ZLIB_INTERNAL gz_intmax()
+{
+    unsigned p, q;
+
+    p = 1;
+    do {
+        q = p;
+        p <<= 1;
+        p++;
+    } while (p > q);
+    return q >> 1;
+}
+#endif
diff --git a/Engine/lib/assimp/contrib/zlib/gzread.c b/Engine/lib/assimp/contrib/zlib/gzread.c
new file mode 100644
index 000000000..f94abfed3
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/gzread.c
@@ -0,0 +1,652 @@
+/* gzread.c -- zlib functions for reading gzip files
+ * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013, 2016 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "gzguts.h"
+
+/* Local functions */
+local int gz_load OF((gz_statep, unsigned char *, unsigned, unsigned *));
+local int gz_avail OF((gz_statep));
+local int gz_look OF((gz_statep));
+local int gz_decomp OF((gz_statep));
+local int gz_fetch OF((gz_statep));
+local int gz_skip OF((gz_statep, z_off64_t));
+local z_size_t gz_read OF((gz_statep, voidp, z_size_t));
+
+/* Use read() to load a buffer -- return -1 on error, otherwise 0.  Read from
+   state->fd, and update state->eof, state->err, and state->msg as appropriate.
+   This function needs to loop on read(), since read() is not guaranteed to
+   read the number of bytes requested, depending on the type of descriptor. */
+local int gz_load(state, buf, len, have)
+    gz_statep state;
+    unsigned char *buf;
+    unsigned len;
+    unsigned *have;
+{
+    int ret;
+    unsigned get, max = ((unsigned)-1 >> 2) + 1;
+
+    *have = 0;
+    do {
+        get = len - *have;
+        if (get > max)
+            get = max;
+        ret = read(state->fd, buf + *have, get);
+        if (ret <= 0)
+            break;
+        *have += (unsigned)ret;
+    } while (*have < len);
+    if (ret < 0) {
+        gz_error(state, Z_ERRNO, zstrerror());
+        return -1;
+    }
+    if (ret == 0)
+        state->eof = 1;
+    return 0;
+}
+
+/* Load up input buffer and set eof flag if last data loaded -- return -1 on
+   error, 0 otherwise.  Note that the eof flag is set when the end of the input
+   file is reached, even though there may be unused data in the buffer.  Once
+   that data has been used, no more attempts will be made to read the file.
+   If strm->avail_in != 0, then the current data is moved to the beginning of
+   the input buffer, and then the remainder of the buffer is loaded with the
+   available data from the input file. */
+local int gz_avail(state)
+    gz_statep state;
+{
+    unsigned got;
+    z_streamp strm = &(state->strm);
+
+    if (state->err != Z_OK && state->err != Z_BUF_ERROR)
+        return -1;
+    if (state->eof == 0) {
+        if (strm->avail_in) {       /* copy what's there to the start */
+            unsigned char *p = state->in;
+            unsigned const char *q = strm->next_in;
+            unsigned n = strm->avail_in;
+            do {
+                *p++ = *q++;
+            } while (--n);
+        }
+        if (gz_load(state, state->in + strm->avail_in,
+                    state->size - strm->avail_in, &got) == -1)
+            return -1;
+        strm->avail_in += got;
+        strm->next_in = state->in;
+    }
+    return 0;
+}
+
+/* Look for gzip header, set up for inflate or copy.  state->x.have must be 0.
+   If this is the first time in, allocate required memory.  state->how will be
+   left unchanged if there is no more input data available, will be set to COPY
+   if there is no gzip header and direct copying will be performed, or it will
+   be set to GZIP for decompression.  If direct copying, then leftover input
+   data from the input buffer will be copied to the output buffer.  In that
+   case, all further file reads will be directly to either the output buffer or
+   a user buffer.  If decompressing, the inflate state will be initialized.
+   gz_look() will return 0 on success or -1 on failure. */
+local int gz_look(state)
+    gz_statep state;
+{
+    z_streamp strm = &(state->strm);
+
+    /* allocate read buffers and inflate memory */
+    if (state->size == 0) {
+        /* allocate buffers */
+        state->in = (unsigned char *)malloc(state->want);
+        state->out = (unsigned char *)malloc(state->want << 1);
+        if (state->in == NULL || state->out == NULL) {
+            free(state->out);
+            free(state->in);
+            gz_error(state, Z_MEM_ERROR, "out of memory");
+            return -1;
+        }
+        state->size = state->want;
+
+        /* allocate inflate memory */
+        state->strm.zalloc = Z_NULL;
+        state->strm.zfree = Z_NULL;
+        state->strm.opaque = Z_NULL;
+        state->strm.avail_in = 0;
+        state->strm.next_in = Z_NULL;
+        if (inflateInit2(&(state->strm), 15 + 16) != Z_OK) {    /* gunzip */
+            free(state->out);
+            free(state->in);
+            state->size = 0;
+            gz_error(state, Z_MEM_ERROR, "out of memory");
+            return -1;
+        }
+    }
+
+    /* get at least the magic bytes in the input buffer */
+    if (strm->avail_in < 2) {
+        if (gz_avail(state) == -1)
+            return -1;
+        if (strm->avail_in == 0)
+            return 0;
+    }
+
+    /* look for gzip magic bytes -- if there, do gzip decoding (note: there is
+       a logical dilemma here when considering the case of a partially written
+       gzip file, to wit, if a single 31 byte is written, then we cannot tell
+       whether this is a single-byte file, or just a partially written gzip
+       file -- for here we assume that if a gzip file is being written, then
+       the header will be written in a single operation, so that reading a
+       single byte is sufficient indication that it is not a gzip file) */
+    if (strm->avail_in > 1 &&
+            strm->next_in[0] == 31 && strm->next_in[1] == 139) {
+        inflateReset(strm);
+        state->how = GZIP;
+        state->direct = 0;
+        return 0;
+    }
+
+    /* no gzip header -- if we were decoding gzip before, then this is trailing
+       garbage.  Ignore the trailing garbage and finish. */
+    if (state->direct == 0) {
+        strm->avail_in = 0;
+        state->eof = 1;
+        state->x.have = 0;
+        return 0;
+    }
+
+    /* doing raw i/o, copy any leftover input to output -- this assumes that
+       the output buffer is larger than the input buffer, which also assures
+       space for gzungetc() */
+    state->x.next = state->out;
+    if (strm->avail_in) {
+        memcpy(state->x.next, strm->next_in, strm->avail_in);
+        state->x.have = strm->avail_in;
+        strm->avail_in = 0;
+    }
+    state->how = COPY;
+    state->direct = 1;
+    return 0;
+}
+
+/* Decompress from input to the provided next_out and avail_out in the state.
+   On return, state->x.have and state->x.next point to the just decompressed
+   data.  If the gzip stream completes, state->how is reset to LOOK to look for
+   the next gzip stream or raw data, once state->x.have is depleted.  Returns 0
+   on success, -1 on failure. */
+local int gz_decomp(state)
+    gz_statep state;
+{
+    int ret = Z_OK;
+    unsigned had;
+    z_streamp strm = &(state->strm);
+
+    /* fill output buffer up to end of deflate stream */
+    had = strm->avail_out;
+    do {
+        /* get more input for inflate() */
+        if (strm->avail_in == 0 && gz_avail(state) == -1)
+            return -1;
+        if (strm->avail_in == 0) {
+            gz_error(state, Z_BUF_ERROR, "unexpected end of file");
+            break;
+        }
+
+        /* decompress and handle errors */
+        ret = inflate(strm, Z_NO_FLUSH);
+        if (ret == Z_STREAM_ERROR || ret == Z_NEED_DICT) {
+            gz_error(state, Z_STREAM_ERROR,
+                     "internal error: inflate stream corrupt");
+            return -1;
+        }
+        if (ret == Z_MEM_ERROR) {
+            gz_error(state, Z_MEM_ERROR, "out of memory");
+            return -1;
+        }
+        if (ret == Z_DATA_ERROR) {              /* deflate stream invalid */
+            gz_error(state, Z_DATA_ERROR,
+                     strm->msg == NULL ? "compressed data error" : strm->msg);
+            return -1;
+        }
+    } while (strm->avail_out && ret != Z_STREAM_END);
+
+    /* update available output */
+    state->x.have = had - strm->avail_out;
+    state->x.next = strm->next_out - state->x.have;
+
+    /* if the gzip stream completed successfully, look for another */
+    if (ret == Z_STREAM_END)
+        state->how = LOOK;
+
+    /* good decompression */
+    return 0;
+}
+
+/* Fetch data and put it in the output buffer.  Assumes state->x.have is 0.
+   Data is either copied from the input file or decompressed from the input
+   file depending on state->how.  If state->how is LOOK, then a gzip header is
+   looked for to determine whether to copy or decompress.  Returns -1 on error,
+   otherwise 0.  gz_fetch() will leave state->how as COPY or GZIP unless the
+   end of the input file has been reached and all data has been processed.  */
+local int gz_fetch(state)
+    gz_statep state;
+{
+    z_streamp strm = &(state->strm);
+
+    do {
+        switch(state->how) {
+        case LOOK:      /* -> LOOK, COPY (only if never GZIP), or GZIP */
+            if (gz_look(state) == -1)
+                return -1;
+            if (state->how == LOOK)
+                return 0;
+            break;
+        case COPY:      /* -> COPY */
+            if (gz_load(state, state->out, state->size << 1, &(state->x.have))
+                    == -1)
+                return -1;
+            state->x.next = state->out;
+            return 0;
+        case GZIP:      /* -> GZIP or LOOK (if end of gzip stream) */
+            strm->avail_out = state->size << 1;
+            strm->next_out = state->out;
+            if (gz_decomp(state) == -1)
+                return -1;
+        }
+    } while (state->x.have == 0 && (!state->eof || strm->avail_in));
+    return 0;
+}
+
+/* Skip len uncompressed bytes of output.  Return -1 on error, 0 on success. */
+local int gz_skip(state, len)
+    gz_statep state;
+    z_off64_t len;
+{
+    unsigned n;
+
+    /* skip over len bytes or reach end-of-file, whichever comes first */
+    while (len)
+        /* skip over whatever is in output buffer */
+        if (state->x.have) {
+            n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > len ?
+                (unsigned)len : state->x.have;
+            state->x.have -= n;
+            state->x.next += n;
+            state->x.pos += n;
+            len -= n;
+        }
+
+        /* output buffer empty -- return if we're at the end of the input */
+        else if (state->eof && state->strm.avail_in == 0)
+            break;
+
+        /* need more data to skip -- load up output buffer */
+        else {
+            /* get more output, looking for header if required */
+            if (gz_fetch(state) == -1)
+                return -1;
+        }
+    return 0;
+}
+
+/* Read len bytes into buf from file, or less than len up to the end of the
+   input.  Return the number of bytes read.  If zero is returned, either the
+   end of file was reached, or there was an error.  state->err must be
+   consulted in that case to determine which. */
+local z_size_t gz_read(state, buf, len)
+    gz_statep state;
+    voidp buf;
+    z_size_t len;
+{
+    z_size_t got;
+    unsigned n;
+
+    /* if len is zero, avoid unnecessary operations */
+    if (len == 0)
+        return 0;
+
+    /* process a skip request */
+    if (state->seek) {
+        state->seek = 0;
+        if (gz_skip(state, state->skip) == -1)
+            return 0;
+    }
+
+    /* get len bytes to buf, or less than len if at the end */
+    got = 0;
+    do {
+        /* set n to the maximum amount of len that fits in an unsigned int */
+        n = (unsigned)-1;
+        if (n > len)
+            n = (unsigned)len;
+
+        /* first just try copying data from the output buffer */
+        if (state->x.have) {
+            if (state->x.have < n)
+                n = state->x.have;
+            memcpy(buf, state->x.next, n);
+            state->x.next += n;
+            state->x.have -= n;
+        }
+
+        /* output buffer empty -- return if we're at the end of the input */
+        else if (state->eof && state->strm.avail_in == 0) {
+            state->past = 1;        /* tried to read past end */
+            break;
+        }
+
+        /* need output data -- for small len or new stream load up our output
+           buffer */
+        else if (state->how == LOOK || n < (state->size << 1)) {
+            /* get more output, looking for header if required */
+            if (gz_fetch(state) == -1)
+                return 0;
+            continue;       /* no progress yet -- go back to copy above */
+            /* the copy above assures that we will leave with space in the
+               output buffer, allowing at least one gzungetc() to succeed */
+        }
+
+        /* large len -- read directly into user buffer */
+        else if (state->how == COPY) {      /* read directly */
+            if (gz_load(state, (unsigned char *)buf, n, &n) == -1)
+                return 0;
+        }
+
+        /* large len -- decompress directly into user buffer */
+        else {  /* state->how == GZIP */
+            state->strm.avail_out = n;
+            state->strm.next_out = (unsigned char *)buf;
+            if (gz_decomp(state) == -1)
+                return 0;
+            n = state->x.have;
+            state->x.have = 0;
+        }
+
+        /* update progress */
+        len -= n;
+        buf = (char *)buf + n;
+        got += n;
+        state->x.pos += n;
+    } while (len);
+
+    /* return number of bytes read into user buffer */
+    return got;
+}
+
+/* -- see zlib.h -- */
+int ZEXPORT gzread(file, buf, len)
+    gzFile file;
+    voidp buf;
+    unsigned len;
+{
+    gz_statep state;
+
+    /* get internal structure */
+    if (file == NULL)
+        return -1;
+    state = (gz_statep)file;
+
+    /* check that we're reading and that there's no (serious) error */
+    if (state->mode != GZ_READ ||
+            (state->err != Z_OK && state->err != Z_BUF_ERROR))
+        return -1;
+
+    /* since an int is returned, make sure len fits in one, otherwise return
+       with an error (this avoids a flaw in the interface) */
+    if ((int)len < 0) {
+        gz_error(state, Z_STREAM_ERROR, "request does not fit in an int");
+        return -1;
+    }
+
+    /* read len or fewer bytes to buf */
+    len = (unsigned)gz_read(state, buf, len);
+
+    /* check for an error */
+    if (len == 0 && state->err != Z_OK && state->err != Z_BUF_ERROR)
+        return -1;
+
+    /* return the number of bytes read (this is assured to fit in an int) */
+    return (int)len;
+}
+
+/* -- see zlib.h -- */
+z_size_t ZEXPORT gzfread(buf, size, nitems, file)
+    voidp buf;
+    z_size_t size;
+    z_size_t nitems;
+    gzFile file;
+{
+    z_size_t len;
+    gz_statep state;
+
+    /* get internal structure */
+    if (file == NULL)
+        return 0;
+    state = (gz_statep)file;
+
+    /* check that we're reading and that there's no (serious) error */
+    if (state->mode != GZ_READ ||
+            (state->err != Z_OK && state->err != Z_BUF_ERROR))
+        return 0;
+
+    /* compute bytes to read -- error on overflow */
+    len = nitems * size;
+    if (size && len / size != nitems) {
+        gz_error(state, Z_STREAM_ERROR, "request does not fit in a size_t");
+        return 0;
+    }
+
+    /* read len or fewer bytes to buf, return the number of full items read */
+    return len ? gz_read(state, buf, len) / size : 0;
+}
+
+/* -- see zlib.h -- */
+#ifdef Z_PREFIX_SET
+#  undef z_gzgetc
+#else
+#  undef gzgetc
+#endif
+int ZEXPORT gzgetc(file)
+    gzFile file;
+{
+    unsigned char buf[1];
+    gz_statep state;
+
+    /* get internal structure */
+    if (file == NULL)
+        return -1;
+    state = (gz_statep)file;
+
+    /* check that we're reading and that there's no (serious) error */
+    if (state->mode != GZ_READ ||
+        (state->err != Z_OK && state->err != Z_BUF_ERROR))
+        return -1;
+
+    /* try output buffer (no need to check for skip request) */
+    if (state->x.have) {
+        state->x.have--;
+        state->x.pos++;
+        return *(state->x.next)++;
+    }
+
+    /* nothing there -- try gz_read() */
+    return gz_read(state, buf, 1) < 1 ? -1 : buf[0];
+}
+
+int ZEXPORT gzgetc_(file)
+gzFile file;
+{
+    return gzgetc(file);
+}
+
+/* -- see zlib.h -- */
+int ZEXPORT gzungetc(c, file)
+    int c;
+    gzFile file;
+{
+    gz_statep state;
+
+    /* get internal structure */
+    if (file == NULL)
+        return -1;
+    state = (gz_statep)file;
+
+    /* check that we're reading and that there's no (serious) error */
+    if (state->mode != GZ_READ ||
+        (state->err != Z_OK && state->err != Z_BUF_ERROR))
+        return -1;
+
+    /* process a skip request */
+    if (state->seek) {
+        state->seek = 0;
+        if (gz_skip(state, state->skip) == -1)
+            return -1;
+    }
+
+    /* can't push EOF */
+    if (c < 0)
+        return -1;
+
+    /* if output buffer empty, put byte at end (allows more pushing) */
+    if (state->x.have == 0) {
+        state->x.have = 1;
+        state->x.next = state->out + (state->size << 1) - 1;
+        state->x.next[0] = (unsigned char)c;
+        state->x.pos--;
+        state->past = 0;
+        return c;
+    }
+
+    /* if no room, give up (must have already done a gzungetc()) */
+    if (state->x.have == (state->size << 1)) {
+        gz_error(state, Z_DATA_ERROR, "out of room to push characters");
+        return -1;
+    }
+
+    /* slide output data if needed and insert byte before existing data */
+    if (state->x.next == state->out) {
+        unsigned char *src = state->out + state->x.have;
+        unsigned char *dest = state->out + (state->size << 1);
+        while (src > state->out)
+            *--dest = *--src;
+        state->x.next = dest;
+    }
+    state->x.have++;
+    state->x.next--;
+    state->x.next[0] = (unsigned char)c;
+    state->x.pos--;
+    state->past = 0;
+    return c;
+}
+
+/* -- see zlib.h -- */
+char * ZEXPORT gzgets(file, buf, len)
+    gzFile file;
+    char *buf;
+    int len;
+{
+    unsigned left, n;
+    char *str;
+    unsigned char *eol;
+    gz_statep state;
+
+    /* check parameters and get internal structure */
+    if (file == NULL || buf == NULL || len < 1)
+        return NULL;
+    state = (gz_statep)file;
+
+    /* check that we're reading and that there's no (serious) error */
+    if (state->mode != GZ_READ ||
+        (state->err != Z_OK && state->err != Z_BUF_ERROR))
+        return NULL;
+
+    /* process a skip request */
+    if (state->seek) {
+        state->seek = 0;
+        if (gz_skip(state, state->skip) == -1)
+            return NULL;
+    }
+
+    /* copy output bytes up to new line or len - 1, whichever comes first --
+       append a terminating zero to the string (we don't check for a zero in
+       the contents, let the user worry about that) */
+    str = buf;
+    left = (unsigned)len - 1;
+    if (left) do {
+        /* assure that something is in the output buffer */
+        if (state->x.have == 0 && gz_fetch(state) == -1)
+            return NULL;                /* error */
+        if (state->x.have == 0) {       /* end of file */
+            state->past = 1;            /* read past end */
+            break;                      /* return what we have */
+        }
+
+        /* look for end-of-line in current output buffer */
+        n = state->x.have > left ? left : state->x.have;
+        eol = (unsigned char *)memchr(state->x.next, '\n', n);
+        if (eol != NULL)
+            n = (unsigned)(eol - state->x.next) + 1;
+
+        /* copy through end-of-line, or remainder if not found */
+        memcpy(buf, state->x.next, n);
+        state->x.have -= n;
+        state->x.next += n;
+        state->x.pos += n;
+        left -= n;
+        buf += n;
+    } while (left && eol == NULL);
+
+    /* return terminated string, or if nothing, end of file */
+    if (buf == str)
+        return NULL;
+    buf[0] = 0;
+    return str;
+}
+
+/* -- see zlib.h -- */
+int ZEXPORT gzdirect(file)
+    gzFile file;
+{
+    gz_statep state;
+
+    /* get internal structure */
+    if (file == NULL)
+        return 0;
+    state = (gz_statep)file;
+
+    /* if the state is not known, but we can find out, then do so (this is
+       mainly for right after a gzopen() or gzdopen()) */
+    if (state->mode == GZ_READ && state->how == LOOK && state->x.have == 0)
+        (void)gz_look(state);
+
+    /* return 1 if transparent, 0 if processing a gzip stream */
+    return state->direct;
+}
+
+/* -- see zlib.h -- */
+int ZEXPORT gzclose_r(file)
+    gzFile file;
+{
+    int ret, err;
+    gz_statep state;
+
+    /* get internal structure */
+    if (file == NULL)
+        return Z_STREAM_ERROR;
+    state = (gz_statep)file;
+
+    /* check that we're reading */
+    if (state->mode != GZ_READ)
+        return Z_STREAM_ERROR;
+
+    /* free memory and close file */
+    if (state->size) {
+        inflateEnd(&(state->strm));
+        free(state->out);
+        free(state->in);
+    }
+    err = state->err == Z_BUF_ERROR ? Z_BUF_ERROR : Z_OK;
+    gz_error(state, Z_OK, NULL);
+    free(state->path);
+    ret = close(state->fd);
+    free(state);
+    return ret ? Z_ERRNO : err;
+}
diff --git a/Engine/lib/assimp/contrib/zlib/gzwrite.c b/Engine/lib/assimp/contrib/zlib/gzwrite.c
new file mode 100644
index 000000000..3560193b8
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/gzwrite.c
@@ -0,0 +1,668 @@
+/* gzwrite.c -- zlib functions for writing gzip files
+ * Copyright (C) 2004-2017 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "gzguts.h"
+
+/* Local functions */
+local int gz_init OF((gz_statep));
+local int gz_comp OF((gz_statep, int));
+local int gz_zero OF((gz_statep, z_off64_t));
+local z_size_t gz_write OF((gz_statep, voidpc, z_size_t));
+
+/* Initialize state for writing a gzip file.  Mark initialization by setting
+   state->size to non-zero.  Return -1 on a memory allocation failure, or 0 on
+   success. */
+local int gz_init(state)
+    gz_statep state;
+{
+    int ret;
+    z_streamp strm = &(state->strm);
+
+    /* allocate input buffer (double size for gzprintf) */
+    state->in = (unsigned char *)malloc(state->want << 1);
+    if (state->in == NULL) {
+        gz_error(state, Z_MEM_ERROR, "out of memory");
+        return -1;
+    }
+
+    /* only need output buffer and deflate state if compressing */
+    if (!state->direct) {
+        /* allocate output buffer */
+        state->out = (unsigned char *)malloc(state->want);
+        if (state->out == NULL) {
+            free(state->in);
+            gz_error(state, Z_MEM_ERROR, "out of memory");
+            return -1;
+        }
+
+        /* allocate deflate memory, set up for gzip compression */
+        strm->zalloc = Z_NULL;
+        strm->zfree = Z_NULL;
+        strm->opaque = Z_NULL;
+        ret = deflateInit2(strm, state->level, Z_DEFLATED,
+                           MAX_WBITS + 16, DEF_MEM_LEVEL, state->strategy);
+        if (ret != Z_OK) {
+            free(state->out);
+            free(state->in);
+            gz_error(state, Z_MEM_ERROR, "out of memory");
+            return -1;
+        }
+        strm->next_in = NULL;
+    }
+
+    /* mark state as initialized */
+    state->size = state->want;
+
+    /* initialize write buffer if compressing */
+    if (!state->direct) {
+        strm->avail_out = state->size;
+        strm->next_out = state->out;
+        state->x.next = strm->next_out;
+    }
+    return 0;
+}
+
+/* Compress whatever is at avail_in and next_in and write to the output file.
+   Return -1 if there is an error writing to the output file or if gz_init()
+   fails to allocate memory, otherwise 0.  flush is assumed to be a valid
+   deflate() flush value.  If flush is Z_FINISH, then the deflate() state is
+   reset to start a new gzip stream.  If gz->direct is true, then simply write
+   to the output file without compressing, and ignore flush. */
+local int gz_comp(state, flush)
+    gz_statep state;
+    int flush;
+{
+    int ret, writ;
+    unsigned have, put, max = ((unsigned)-1 >> 2) + 1;
+    z_streamp strm = &(state->strm);
+
+    /* allocate memory if this is the first time through */
+    if (state->size == 0 && gz_init(state) == -1)
+        return -1;
+
+    /* write directly if requested */
+    if (state->direct) {
+        while (strm->avail_in) {
+            put = strm->avail_in > max ? max : strm->avail_in;
+            writ = write(state->fd, strm->next_in, put);
+            if (writ < 0) {
+                gz_error(state, Z_ERRNO, zstrerror());
+                return -1;
+            }
+            strm->avail_in -= (unsigned)writ;
+            strm->next_in += writ;
+        }
+        return 0;
+    }
+
+    /* run deflate() on provided input until it produces no more output */
+    ret = Z_OK;
+    do {
+        /* write out current buffer contents if full, or if flushing, but if
+           doing Z_FINISH then don't write until we get to Z_STREAM_END */
+        if (strm->avail_out == 0 || (flush != Z_NO_FLUSH &&
+            (flush != Z_FINISH || ret == Z_STREAM_END))) {
+            while (strm->next_out > state->x.next) {
+                put = strm->next_out - state->x.next > (int)max ? max :
+                      (unsigned)(strm->next_out - state->x.next);
+                writ = write(state->fd, state->x.next, put);
+                if (writ < 0) {
+                    gz_error(state, Z_ERRNO, zstrerror());
+                    return -1;
+                }
+                state->x.next += writ;
+            }
+            if (strm->avail_out == 0) {
+                strm->avail_out = state->size;
+                strm->next_out = state->out;
+                state->x.next = state->out;
+            }
+        }
+
+        /* compress */
+        have = strm->avail_out;
+        ret = deflate(strm, flush);
+        if (ret == Z_STREAM_ERROR) {
+            gz_error(state, Z_STREAM_ERROR,
+                      "internal error: deflate stream corrupt");
+            return -1;
+        }
+        have -= strm->avail_out;
+    } while (have);
+
+    /* if that completed a deflate stream, allow another to start */
+    if (flush == Z_FINISH)
+        deflateReset(strm);
+
+    /* all done, no errors */
+    return 0;
+}
+
+/* Compress len zeros to output.  Return -1 on a write error or memory
+   allocation failure by gz_comp(), or 0 on success. */
+local int gz_zero(state, len)
+    gz_statep state;
+    z_off64_t len;
+{
+    int first;
+    unsigned n;
+    z_streamp strm = &(state->strm);
+
+    /* consume whatever's left in the input buffer */
+    if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
+        return -1;
+
+    /* compress len zeros (len guaranteed > 0) */
+    first = 1;
+    while (len) {
+        n = GT_OFF(state->size) || (z_off64_t)state->size > len ?
+            (unsigned)len : state->size;
+        if (first) {
+            memset(state->in, 0, n);
+            first = 0;
+        }
+        strm->avail_in = n;
+        strm->next_in = state->in;
+        state->x.pos += n;
+        if (gz_comp(state, Z_NO_FLUSH) == -1)
+            return -1;
+        len -= n;
+    }
+    return 0;
+}
+
+/* Write len bytes from buf to file.  Return the number of bytes written.  If
+   the returned value is less than len, then there was an error. */
+local z_size_t gz_write(state, buf, len)
+    gz_statep state;
+    voidpc buf;
+    z_size_t len;
+{
+    z_size_t put = len;
+
+    /* if len is zero, avoid unnecessary operations */
+    if (len == 0)
+        return 0;
+
+    /* allocate memory if this is the first time through */
+    if (state->size == 0 && gz_init(state) == -1)
+        return 0;
+
+    /* check for seek request */
+    if (state->seek) {
+        state->seek = 0;
+        if (gz_zero(state, state->skip) == -1)
+            return 0;
+    }
+
+    /* for small len, copy to input buffer, otherwise compress directly */
+    if (len < state->size) {
+        /* copy to input buffer, compress when full */
+        do {
+            unsigned have, copy;
+
+            if (state->strm.avail_in == 0)
+                state->strm.next_in = state->in;
+            have = (unsigned)((state->strm.next_in + state->strm.avail_in) -
+                              state->in);
+            copy = state->size - have;
+            if (copy > len)
+                copy = (unsigned)len;
+            memcpy(state->in + have, buf, copy);
+            state->strm.avail_in += copy;
+            state->x.pos += copy;
+            buf = (const char *)buf + copy;
+            len -= copy;
+            if (len && gz_comp(state, Z_NO_FLUSH) == -1)
+                return 0;
+        } while (len);
+    }
+    else {
+        /* consume whatever's left in the input buffer */
+        if (state->strm.avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
+            return 0;
+
+        /* directly compress user buffer to file */
+        state->strm.next_in = (z_const Bytef *)buf;
+        do {
+            unsigned n = (unsigned)-1;
+            if (n > len)
+                n = (unsigned)len;
+            state->strm.avail_in = n;
+            state->x.pos += n;
+            if (gz_comp(state, Z_NO_FLUSH) == -1)
+                return 0;
+            len -= n;
+        } while (len);
+    }
+
+    /* input was all buffered or compressed */
+    return put;
+}
+
+/* -- see zlib.h -- */
+int ZEXPORT gzwrite(file, buf, len)
+    gzFile file;
+    voidpc buf;
+    unsigned len;
+{
+    gz_statep state;
+
+    /* get internal structure */
+    if (file == NULL)
+        return 0;
+    state = (gz_statep)file;
+
+    /* check that we're writing and that there's no error */
+    if (state->mode != GZ_WRITE || state->err != Z_OK)
+        return 0;
+
+    /* since an int is returned, make sure len fits in one, otherwise return
+       with an error (this avoids a flaw in the interface) */
+    if ((int)len < 0) {
+        gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");
+        return 0;
+    }
+
+    /* write len bytes from buf (the return value will fit in an int) */
+    return (int)gz_write(state, buf, len);
+}
+
+/* -- see zlib.h -- */
+z_size_t ZEXPORT gzfwrite(buf, size, nitems, file)
+    voidpc buf;
+    z_size_t size;
+    z_size_t nitems;
+    gzFile file;
+{
+    z_size_t len;
+    gz_statep state;
+
+    /* get internal structure */
+    if (file == NULL)
+        return 0;
+    state = (gz_statep)file;
+
+    /* check that we're writing and that there's no error */
+    if (state->mode != GZ_WRITE || state->err != Z_OK)
+        return 0;
+
+    /* compute bytes to read -- error on overflow */
+    len = nitems * size;
+    if (size && len / size != nitems) {
+        gz_error(state, Z_STREAM_ERROR, "request does not fit in a size_t");
+        return 0;
+    }
+
+    /* write len bytes to buf, return the number of full items written */
+    return len ? gz_write(state, buf, len) / size : 0;
+}
+
+/* -- see zlib.h -- */
+int ZEXPORT gzputc(file, c)
+    gzFile file;
+    int c;
+{
+    unsigned have;
+    unsigned char buf[1];
+    gz_statep state;
+    z_streamp strm;
+
+    /* get internal structure */
+    if (file == NULL)
+        return -1;
+    state = (gz_statep)file;
+    strm = &(state->strm);
+
+    /* check that we're writing and that there's no error */
+    if (state->mode != GZ_WRITE || state->err != Z_OK)
+        return -1;
+
+    /* check for seek request */
+    if (state->seek) {
+        state->seek = 0;
+        if (gz_zero(state, state->skip) == -1)
+            return -1;
+    }
+
+    /* try writing to input buffer for speed (state->size == 0 if buffer not
+       initialized) */
+    if (state->size) {
+        if (strm->avail_in == 0)
+            strm->next_in = state->in;
+        have = (unsigned)((strm->next_in + strm->avail_in) - state->in);
+        if (have < state->size) {
+            state->in[have] = (unsigned char)c;
+            strm->avail_in++;
+            state->x.pos++;
+            return c & 0xff;
+        }
+    }
+
+    /* no room in buffer or not initialized, use gz_write() */
+    buf[0] = (unsigned char)c;
+    if (gz_write(state, buf, 1) != 1)
+        return -1;
+    return c & 0xff;
+}
+
+/* -- see zlib.h -- */
+int ZEXPORT gzputs(file, str)
+    gzFile file;
+    const char *str;
+{
+    z_size_t len, put;
+    gz_statep state;
+
+    /* get internal structure */
+    if (file == NULL)
+        return -1;
+    state = (gz_statep)file;
+
+    /* check that we're writing and that there's no error */
+    if (state->mode != GZ_WRITE || state->err != Z_OK)
+        return -1;
+
+    /* write string */
+    len = strlen(str);
+    if ((int)len < 0 || (unsigned)len != len) {
+        gz_error(state, Z_STREAM_ERROR, "string length does not fit in int");
+        return -1;
+    }
+    put = gz_write(state, str, len);
+    return put < len ? -1 : (int)len;
+}
+
+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#include <stdarg.h>
+
+/* -- see zlib.h -- */
+int ZEXPORTVA gzvprintf(gzFile file, const char *format, va_list va)
+{
+    int len;
+    unsigned left;
+    char *next;
+    gz_statep state;
+    z_streamp strm;
+
+    /* get internal structure */
+    if (file == NULL)
+        return Z_STREAM_ERROR;
+    state = (gz_statep)file;
+    strm = &(state->strm);
+
+    /* check that we're writing and that there's no error */
+    if (state->mode != GZ_WRITE || state->err != Z_OK)
+        return Z_STREAM_ERROR;
+
+    /* make sure we have some buffer space */
+    if (state->size == 0 && gz_init(state) == -1)
+        return state->err;
+
+    /* check for seek request */
+    if (state->seek) {
+        state->seek = 0;
+        if (gz_zero(state, state->skip) == -1)
+            return state->err;
+    }
+
+    /* do the printf() into the input buffer, put length in len -- the input
+       buffer is double-sized just for this function, so there is guaranteed to
+       be state->size bytes available after the current contents */
+    if (strm->avail_in == 0)
+        strm->next_in = state->in;
+    next = (char *)(state->in + (strm->next_in - state->in) + strm->avail_in);
+    next[state->size - 1] = 0;
+#ifdef NO_vsnprintf
+#  ifdef HAS_vsprintf_void
+    (void)vsprintf(next, format, va);
+    for (len = 0; len < state->size; len++)
+        if (next[len] == 0) break;
+#  else
+    len = vsprintf(next, format, va);
+#  endif
+#else
+#  ifdef HAS_vsnprintf_void
+    (void)vsnprintf(next, state->size, format, va);
+    len = strlen(next);
+#  else
+    len = vsnprintf(next, state->size, format, va);
+#  endif
+#endif
+
+    /* check that printf() results fit in buffer */
+    if (len == 0 || (unsigned)len >= state->size || next[state->size - 1] != 0)
+        return 0;
+
+    /* update buffer and position, compress first half if past that */
+    strm->avail_in += (unsigned)len;
+    state->x.pos += len;
+    if (strm->avail_in >= state->size) {
+        left = strm->avail_in - state->size;
+        strm->avail_in = state->size;
+        if (gz_comp(state, Z_NO_FLUSH) == -1)
+            return state->err;
+        memcpy(state->in, state->in + state->size, left);
+        strm->next_in = state->in;
+        strm->avail_in = left;
+    }
+    return len;
+}
+
+int ZEXPORTVA gzprintf(gzFile file, const char *format, ...)
+{
+    va_list va;
+    int ret;
+
+    va_start(va, format);
+    ret = gzvprintf(file, format, va);
+    va_end(va);
+    return ret;
+}
+
+#else /* !STDC && !Z_HAVE_STDARG_H */
+
+/* -- see zlib.h -- */
+int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
+                       a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
+    gzFile file;
+    const char *format;
+    int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
+        a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;
+{
+    unsigned len, left;
+    char *next;
+    gz_statep state;
+    z_streamp strm;
+
+    /* get internal structure */
+    if (file == NULL)
+        return Z_STREAM_ERROR;
+    state = (gz_statep)file;
+    strm = &(state->strm);
+
+    /* check that can really pass pointer in ints */
+    if (sizeof(int) != sizeof(void *))
+        return Z_STREAM_ERROR;
+
+    /* check that we're writing and that there's no error */
+    if (state->mode != GZ_WRITE || state->err != Z_OK)
+        return Z_STREAM_ERROR;
+
+    /* make sure we have some buffer space */
+    if (state->size == 0 && gz_init(state) == -1)
+        return state->error;
+
+    /* check for seek request */
+    if (state->seek) {
+        state->seek = 0;
+        if (gz_zero(state, state->skip) == -1)
+            return state->error;
+    }
+
+    /* do the printf() into the input buffer, put length in len -- the input
+       buffer is double-sized just for this function, so there is guaranteed to
+       be state->size bytes available after the current contents */
+    if (strm->avail_in == 0)
+        strm->next_in = state->in;
+    next = (char *)(strm->next_in + strm->avail_in);
+    next[state->size - 1] = 0;
+#ifdef NO_snprintf
+#  ifdef HAS_sprintf_void
+    sprintf(next, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12,
+            a13, a14, a15, a16, a17, a18, a19, a20);
+    for (len = 0; len < size; len++)
+        if (next[len] == 0)
+            break;
+#  else
+    len = sprintf(next, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
+                  a12, a13, a14, a15, a16, a17, a18, a19, a20);
+#  endif
+#else
+#  ifdef HAS_snprintf_void
+    snprintf(next, state->size, format, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+             a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+    len = strlen(next);
+#  else
+    len = snprintf(next, state->size, format, a1, a2, a3, a4, a5, a6, a7, a8,
+                   a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+#  endif
+#endif
+
+    /* check that printf() results fit in buffer */
+    if (len == 0 || len >= state->size || next[state->size - 1] != 0)
+        return 0;
+
+    /* update buffer and position, compress first half if past that */
+    strm->avail_in += len;
+    state->x.pos += len;
+    if (strm->avail_in >= state->size) {
+        left = strm->avail_in - state->size;
+        strm->avail_in = state->size;
+        if (gz_comp(state, Z_NO_FLUSH) == -1)
+            return state->err;
+        memcpy(state->in, state->in + state->size, left);
+        strm->next_in = state->in;
+        strm->avail_in = left;
+    }
+    return (int)len;
+}
+
+#endif
+
+/* -- see zlib.h -- */
+int ZEXPORT gzflush(file, flush)
+    gzFile file;
+    int flush;
+{
+    gz_statep state;
+
+    /* get internal structure */
+    if (file == NULL)
+        return Z_STREAM_ERROR;
+    state = (gz_statep)file;
+
+    /* check that we're writing and that there's no error */
+    if (state->mode != GZ_WRITE || state->err != Z_OK)
+        return Z_STREAM_ERROR;
+
+    /* check flush parameter */
+    if (flush < 0 || flush > Z_FINISH)
+        return Z_STREAM_ERROR;
+
+    /* check for seek request */
+    if (state->seek) {
+        state->seek = 0;
+        if (gz_zero(state, state->skip) == -1)
+            return state->err;
+    }
+
+    /* compress remaining data with requested flush */
+    (void)gz_comp(state, flush);
+    return state->err;
+}
+
+/* -- see zlib.h -- */
+int ZEXPORT gzsetparams(file, level, strategy)
+    gzFile file;
+    int level;
+    int strategy;
+{
+    gz_statep state;
+    z_streamp strm;
+
+    /* get internal structure */
+    if (file == NULL)
+        return Z_STREAM_ERROR;
+    state = (gz_statep)file;
+    strm = &(state->strm);
+
+    /* check that we're writing and that there's no error */
+    if (state->mode != GZ_WRITE || state->err != Z_OK)
+        return Z_STREAM_ERROR;
+
+    /* if no change is requested, then do nothing */
+    if (level == state->level && strategy == state->strategy)
+        return Z_OK;
+
+    /* check for seek request */
+    if (state->seek) {
+        state->seek = 0;
+        if (gz_zero(state, state->skip) == -1)
+            return state->err;
+    }
+
+    /* change compression parameters for subsequent input */
+    if (state->size) {
+        /* flush previous input with previous parameters before changing */
+        if (strm->avail_in && gz_comp(state, Z_BLOCK) == -1)
+            return state->err;
+        deflateParams(strm, level, strategy);
+    }
+    state->level = level;
+    state->strategy = strategy;
+    return Z_OK;
+}
+
+/* -- see zlib.h -- */
+int ZEXPORT gzclose_w(file)
+    gzFile file;
+{
+    int ret = Z_OK;
+    gz_statep state;
+
+    /* get internal structure */
+    if (file == NULL)
+        return Z_STREAM_ERROR;
+    state = (gz_statep)file;
+
+    /* check that we're writing */
+    if (state->mode != GZ_WRITE)
+        return Z_STREAM_ERROR;
+
+    /* check for seek request */
+    if (state->seek) {
+        state->seek = 0;
+        if (gz_zero(state, state->skip) == -1)
+            ret = state->err;
+    }
+
+    /* flush, free memory, and close file */
+    if (gz_comp(state, Z_FINISH) == -1)
+        ret = state->err;
+    if (state->size) {
+        if (!state->direct) {
+            (void)deflateEnd(&(state->strm));
+            free(state->out);
+        }
+        free(state->in);
+    }
+    gz_error(state, Z_OK, NULL);
+    free(state->path);
+    if (close(state->fd) == -1)
+        ret = Z_ERRNO;
+    free(state);
+    return ret;
+}
diff --git a/Engine/lib/assimp/contrib/zlib/infback.c b/Engine/lib/assimp/contrib/zlib/infback.c
new file mode 100644
index 000000000..59679ecbf
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/infback.c
@@ -0,0 +1,640 @@
+/* infback.c -- inflate using a call-back interface
+ * Copyright (C) 1995-2016 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/*
+   This code is largely copied from inflate.c.  Normally either infback.o or
+   inflate.o would be linked into an application--not both.  The interface
+   with inffast.c is retained so that optimized assembler-coded versions of
+   inflate_fast() can be used with either inflate.c or infback.c.
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+#include "inflate.h"
+#include "inffast.h"
+
+/* function prototypes */
+local void fixedtables OF((struct inflate_state FAR *state));
+
+/*
+   strm provides memory allocation functions in zalloc and zfree, or
+   Z_NULL to use the library memory allocation functions.
+
+   windowBits is in the range 8..15, and window is a user-supplied
+   window and output buffer that is 2**windowBits bytes.
+ */
+int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size)
+z_streamp strm;
+int windowBits;
+unsigned char FAR *window;
+const char *version;
+int stream_size;
+{
+    struct inflate_state FAR *state;
+
+    if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
+        stream_size != (int)(sizeof(z_stream)))
+        return Z_VERSION_ERROR;
+    if (strm == Z_NULL || window == Z_NULL ||
+        windowBits < 8 || windowBits > 15)
+        return Z_STREAM_ERROR;
+    strm->msg = Z_NULL;                 /* in case we return an error */
+    if (strm->zalloc == (alloc_func)0) {
+#ifdef Z_SOLO
+        return Z_STREAM_ERROR;
+#else
+        strm->zalloc = zcalloc;
+        strm->opaque = (voidpf)0;
+#endif
+    }
+    if (strm->zfree == (free_func)0)
+#ifdef Z_SOLO
+        return Z_STREAM_ERROR;
+#else
+    strm->zfree = zcfree;
+#endif
+    state = (struct inflate_state FAR *)ZALLOC(strm, 1,
+                                               sizeof(struct inflate_state));
+    if (state == Z_NULL) return Z_MEM_ERROR;
+    Tracev((stderr, "inflate: allocated\n"));
+    strm->state = (struct internal_state FAR *)state;
+    state->dmax = 32768U;
+    state->wbits = (uInt)windowBits;
+    state->wsize = 1U << windowBits;
+    state->window = window;
+    state->wnext = 0;
+    state->whave = 0;
+    return Z_OK;
+}
+
+/*
+   Return state with length and distance decoding tables and index sizes set to
+   fixed code decoding.  Normally this returns fixed tables from inffixed.h.
+   If BUILDFIXED is defined, then instead this routine builds the tables the
+   first time it's called, and returns those tables the first time and
+   thereafter.  This reduces the size of the code by about 2K bytes, in
+   exchange for a little execution time.  However, BUILDFIXED should not be
+   used for threaded applications, since the rewriting of the tables and virgin
+   may not be thread-safe.
+ */
+local void fixedtables(state)
+struct inflate_state FAR *state;
+{
+#ifdef BUILDFIXED
+    static int virgin = 1;
+    static code *lenfix, *distfix;
+    static code fixed[544];
+
+    /* build fixed huffman tables if first call (may not be thread safe) */
+    if (virgin) {
+        unsigned sym, bits;
+        static code *next;
+
+        /* literal/length table */
+        sym = 0;
+        while (sym < 144) state->lens[sym++] = 8;
+        while (sym < 256) state->lens[sym++] = 9;
+        while (sym < 280) state->lens[sym++] = 7;
+        while (sym < 288) state->lens[sym++] = 8;
+        next = fixed;
+        lenfix = next;
+        bits = 9;
+        inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
+
+        /* distance table */
+        sym = 0;
+        while (sym < 32) state->lens[sym++] = 5;
+        distfix = next;
+        bits = 5;
+        inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
+
+        /* do this just once */
+        virgin = 0;
+    }
+#else /* !BUILDFIXED */
+#   include "inffixed.h"
+#endif /* BUILDFIXED */
+    state->lencode = lenfix;
+    state->lenbits = 9;
+    state->distcode = distfix;
+    state->distbits = 5;
+}
+
+/* Macros for inflateBack(): */
+
+/* Load returned state from inflate_fast() */
+#define LOAD() \
+    do { \
+        put = strm->next_out; \
+        left = strm->avail_out; \
+        next = strm->next_in; \
+        have = strm->avail_in; \
+        hold = state->hold; \
+        bits = state->bits; \
+    } while (0)
+
+/* Set state from registers for inflate_fast() */
+#define RESTORE() \
+    do { \
+        strm->next_out = put; \
+        strm->avail_out = left; \
+        strm->next_in = next; \
+        strm->avail_in = have; \
+        state->hold = hold; \
+        state->bits = bits; \
+    } while (0)
+
+/* Clear the input bit accumulator */
+#define INITBITS() \
+    do { \
+        hold = 0; \
+        bits = 0; \
+    } while (0)
+
+/* Assure that some input is available.  If input is requested, but denied,
+   then return a Z_BUF_ERROR from inflateBack(). */
+#define PULL() \
+    do { \
+        if (have == 0) { \
+            have = in(in_desc, &next); \
+            if (have == 0) { \
+                next = Z_NULL; \
+                ret = Z_BUF_ERROR; \
+                goto inf_leave; \
+            } \
+        } \
+    } while (0)
+
+/* Get a byte of input into the bit accumulator, or return from inflateBack()
+   with an error if there is no input available. */
+#define PULLBYTE() \
+    do { \
+        PULL(); \
+        have--; \
+        hold += (unsigned long)(*next++) << bits; \
+        bits += 8; \
+    } while (0)
+
+/* Assure that there are at least n bits in the bit accumulator.  If there is
+   not enough available input to do that, then return from inflateBack() with
+   an error. */
+#define NEEDBITS(n) \
+    do { \
+        while (bits < (unsigned)(n)) \
+            PULLBYTE(); \
+    } while (0)
+
+/* Return the low n bits of the bit accumulator (n < 16) */
+#define BITS(n) \
+    ((unsigned)hold & ((1U << (n)) - 1))
+
+/* Remove n bits from the bit accumulator */
+#define DROPBITS(n) \
+    do { \
+        hold >>= (n); \
+        bits -= (unsigned)(n); \
+    } while (0)
+
+/* Remove zero to seven bits as needed to go to a byte boundary */
+#define BYTEBITS() \
+    do { \
+        hold >>= bits & 7; \
+        bits -= bits & 7; \
+    } while (0)
+
+/* Assure that some output space is available, by writing out the window
+   if it's full.  If the write fails, return from inflateBack() with a
+   Z_BUF_ERROR. */
+#define ROOM() \
+    do { \
+        if (left == 0) { \
+            put = state->window; \
+            left = state->wsize; \
+            state->whave = left; \
+            if (out(out_desc, put, left)) { \
+                ret = Z_BUF_ERROR; \
+                goto inf_leave; \
+            } \
+        } \
+    } while (0)
+
+/*
+   strm provides the memory allocation functions and window buffer on input,
+   and provides information on the unused input on return.  For Z_DATA_ERROR
+   returns, strm will also provide an error message.
+
+   in() and out() are the call-back input and output functions.  When
+   inflateBack() needs more input, it calls in().  When inflateBack() has
+   filled the window with output, or when it completes with data in the
+   window, it calls out() to write out the data.  The application must not
+   change the provided input until in() is called again or inflateBack()
+   returns.  The application must not change the window/output buffer until
+   inflateBack() returns.
+
+   in() and out() are called with a descriptor parameter provided in the
+   inflateBack() call.  This parameter can be a structure that provides the
+   information required to do the read or write, as well as accumulated
+   information on the input and output such as totals and check values.
+
+   in() should return zero on failure.  out() should return non-zero on
+   failure.  If either in() or out() fails, than inflateBack() returns a
+   Z_BUF_ERROR.  strm->next_in can be checked for Z_NULL to see whether it
+   was in() or out() that caused in the error.  Otherwise,  inflateBack()
+   returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format
+   error, or Z_MEM_ERROR if it could not allocate memory for the state.
+   inflateBack() can also return Z_STREAM_ERROR if the input parameters
+   are not correct, i.e. strm is Z_NULL or the state was not initialized.
+ */
+int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc)
+z_streamp strm;
+in_func in;
+void FAR *in_desc;
+out_func out;
+void FAR *out_desc;
+{
+    struct inflate_state FAR *state;
+    z_const unsigned char FAR *next;    /* next input */
+    unsigned char FAR *put;     /* next output */
+    unsigned have, left;        /* available input and output */
+    unsigned long hold;         /* bit buffer */
+    unsigned bits;              /* bits in bit buffer */
+    unsigned copy;              /* number of stored or match bytes to copy */
+    unsigned char FAR *from;    /* where to copy match bytes from */
+    code here;                  /* current decoding table entry */
+    code last;                  /* parent table entry */
+    unsigned len;               /* length to copy for repeats, bits to drop */
+    int ret;                    /* return code */
+    static const unsigned short order[19] = /* permutation of code lengths */
+        {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
+
+    /* Check that the strm exists and that the state was initialized */
+    if (strm == Z_NULL || strm->state == Z_NULL)
+        return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+
+    /* Reset the state */
+    strm->msg = Z_NULL;
+    state->mode = TYPE;
+    state->last = 0;
+    state->whave = 0;
+    next = strm->next_in;
+    have = next != Z_NULL ? strm->avail_in : 0;
+    hold = 0;
+    bits = 0;
+    put = state->window;
+    left = state->wsize;
+
+    /* Inflate until end of block marked as last */
+    for (;;)
+        switch (state->mode) {
+        case TYPE:
+            /* determine and dispatch block type */
+            if (state->last) {
+                BYTEBITS();
+                state->mode = DONE;
+                break;
+            }
+            NEEDBITS(3);
+            state->last = BITS(1);
+            DROPBITS(1);
+            switch (BITS(2)) {
+            case 0:                             /* stored block */
+                Tracev((stderr, "inflate:     stored block%s\n",
+                        state->last ? " (last)" : ""));
+                state->mode = STORED;
+                break;
+            case 1:                             /* fixed block */
+                fixedtables(state);
+                Tracev((stderr, "inflate:     fixed codes block%s\n",
+                        state->last ? " (last)" : ""));
+                state->mode = LEN;              /* decode codes */
+                break;
+            case 2:                             /* dynamic block */
+                Tracev((stderr, "inflate:     dynamic codes block%s\n",
+                        state->last ? " (last)" : ""));
+                state->mode = TABLE;
+                break;
+            case 3:
+                strm->msg = (char *)"invalid block type";
+                state->mode = BAD;
+            }
+            DROPBITS(2);
+            break;
+
+        case STORED:
+            /* get and verify stored block length */
+            BYTEBITS();                         /* go to byte boundary */
+            NEEDBITS(32);
+            if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
+                strm->msg = (char *)"invalid stored block lengths";
+                state->mode = BAD;
+                break;
+            }
+            state->length = (unsigned)hold & 0xffff;
+            Tracev((stderr, "inflate:       stored length %u\n",
+                    state->length));
+            INITBITS();
+
+            /* copy stored block from input to output */
+            while (state->length != 0) {
+                copy = state->length;
+                PULL();
+                ROOM();
+                if (copy > have) copy = have;
+                if (copy > left) copy = left;
+                zmemcpy(put, next, copy);
+                have -= copy;
+                next += copy;
+                left -= copy;
+                put += copy;
+                state->length -= copy;
+            }
+            Tracev((stderr, "inflate:       stored end\n"));
+            state->mode = TYPE;
+            break;
+
+        case TABLE:
+            /* get dynamic table entries descriptor */
+            NEEDBITS(14);
+            state->nlen = BITS(5) + 257;
+            DROPBITS(5);
+            state->ndist = BITS(5) + 1;
+            DROPBITS(5);
+            state->ncode = BITS(4) + 4;
+            DROPBITS(4);
+#ifndef PKZIP_BUG_WORKAROUND
+            if (state->nlen > 286 || state->ndist > 30) {
+                strm->msg = (char *)"too many length or distance symbols";
+                state->mode = BAD;
+                break;
+            }
+#endif
+            Tracev((stderr, "inflate:       table sizes ok\n"));
+
+            /* get code length code lengths (not a typo) */
+            state->have = 0;
+            while (state->have < state->ncode) {
+                NEEDBITS(3);
+                state->lens[order[state->have++]] = (unsigned short)BITS(3);
+                DROPBITS(3);
+            }
+            while (state->have < 19)
+                state->lens[order[state->have++]] = 0;
+            state->next = state->codes;
+            state->lencode = (code const FAR *)(state->next);
+            state->lenbits = 7;
+            ret = inflate_table(CODES, state->lens, 19, &(state->next),
+                                &(state->lenbits), state->work);
+            if (ret) {
+                strm->msg = (char *)"invalid code lengths set";
+                state->mode = BAD;
+                break;
+            }
+            Tracev((stderr, "inflate:       code lengths ok\n"));
+
+            /* get length and distance code code lengths */
+            state->have = 0;
+            while (state->have < state->nlen + state->ndist) {
+                for (;;) {
+                    here = state->lencode[BITS(state->lenbits)];
+                    if ((unsigned)(here.bits) <= bits) break;
+                    PULLBYTE();
+                }
+                if (here.val < 16) {
+                    DROPBITS(here.bits);
+                    state->lens[state->have++] = here.val;
+                }
+                else {
+                    if (here.val == 16) {
+                        NEEDBITS(here.bits + 2);
+                        DROPBITS(here.bits);
+                        if (state->have == 0) {
+                            strm->msg = (char *)"invalid bit length repeat";
+                            state->mode = BAD;
+                            break;
+                        }
+                        len = (unsigned)(state->lens[state->have - 1]);
+                        copy = 3 + BITS(2);
+                        DROPBITS(2);
+                    }
+                    else if (here.val == 17) {
+                        NEEDBITS(here.bits + 3);
+                        DROPBITS(here.bits);
+                        len = 0;
+                        copy = 3 + BITS(3);
+                        DROPBITS(3);
+                    }
+                    else {
+                        NEEDBITS(here.bits + 7);
+                        DROPBITS(here.bits);
+                        len = 0;
+                        copy = 11 + BITS(7);
+                        DROPBITS(7);
+                    }
+                    if (state->have + copy > state->nlen + state->ndist) {
+                        strm->msg = (char *)"invalid bit length repeat";
+                        state->mode = BAD;
+                        break;
+                    }
+                    while (copy--)
+                        state->lens[state->have++] = (unsigned short)len;
+                }
+            }
+
+            /* handle error breaks in while */
+            if (state->mode == BAD) break;
+
+            /* check for end-of-block code (better have one) */
+            if (state->lens[256] == 0) {
+                strm->msg = (char *)"invalid code -- missing end-of-block";
+                state->mode = BAD;
+                break;
+            }
+
+            /* build code tables -- note: do not change the lenbits or distbits
+               values here (9 and 6) without reading the comments in inftrees.h
+               concerning the ENOUGH constants, which depend on those values */
+            state->next = state->codes;
+            state->lencode = (code const FAR *)(state->next);
+            state->lenbits = 9;
+            ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
+                                &(state->lenbits), state->work);
+            if (ret) {
+                strm->msg = (char *)"invalid literal/lengths set";
+                state->mode = BAD;
+                break;
+            }
+            state->distcode = (code const FAR *)(state->next);
+            state->distbits = 6;
+            ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
+                            &(state->next), &(state->distbits), state->work);
+            if (ret) {
+                strm->msg = (char *)"invalid distances set";
+                state->mode = BAD;
+                break;
+            }
+            Tracev((stderr, "inflate:       codes ok\n"));
+            state->mode = LEN;
+
+        case LEN:
+            /* use inflate_fast() if we have enough input and output */
+            if (have >= 6 && left >= 258) {
+                RESTORE();
+                if (state->whave < state->wsize)
+                    state->whave = state->wsize - left;
+                inflate_fast(strm, state->wsize);
+                LOAD();
+                break;
+            }
+
+            /* get a literal, length, or end-of-block code */
+            for (;;) {
+                here = state->lencode[BITS(state->lenbits)];
+                if ((unsigned)(here.bits) <= bits) break;
+                PULLBYTE();
+            }
+            if (here.op && (here.op & 0xf0) == 0) {
+                last = here;
+                for (;;) {
+                    here = state->lencode[last.val +
+                            (BITS(last.bits + last.op) >> last.bits)];
+                    if ((unsigned)(last.bits + here.bits) <= bits) break;
+                    PULLBYTE();
+                }
+                DROPBITS(last.bits);
+            }
+            DROPBITS(here.bits);
+            state->length = (unsigned)here.val;
+
+            /* process literal */
+            if (here.op == 0) {
+                Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
+                        "inflate:         literal '%c'\n" :
+                        "inflate:         literal 0x%02x\n", here.val));
+                ROOM();
+                *put++ = (unsigned char)(state->length);
+                left--;
+                state->mode = LEN;
+                break;
+            }
+
+            /* process end of block */
+            if (here.op & 32) {
+                Tracevv((stderr, "inflate:         end of block\n"));
+                state->mode = TYPE;
+                break;
+            }
+
+            /* invalid code */
+            if (here.op & 64) {
+                strm->msg = (char *)"invalid literal/length code";
+                state->mode = BAD;
+                break;
+            }
+
+            /* length code -- get extra bits, if any */
+            state->extra = (unsigned)(here.op) & 15;
+            if (state->extra != 0) {
+                NEEDBITS(state->extra);
+                state->length += BITS(state->extra);
+                DROPBITS(state->extra);
+            }
+            Tracevv((stderr, "inflate:         length %u\n", state->length));
+
+            /* get distance code */
+            for (;;) {
+                here = state->distcode[BITS(state->distbits)];
+                if ((unsigned)(here.bits) <= bits) break;
+                PULLBYTE();
+            }
+            if ((here.op & 0xf0) == 0) {
+                last = here;
+                for (;;) {
+                    here = state->distcode[last.val +
+                            (BITS(last.bits + last.op) >> last.bits)];
+                    if ((unsigned)(last.bits + here.bits) <= bits) break;
+                    PULLBYTE();
+                }
+                DROPBITS(last.bits);
+            }
+            DROPBITS(here.bits);
+            if (here.op & 64) {
+                strm->msg = (char *)"invalid distance code";
+                state->mode = BAD;
+                break;
+            }
+            state->offset = (unsigned)here.val;
+
+            /* get distance extra bits, if any */
+            state->extra = (unsigned)(here.op) & 15;
+            if (state->extra != 0) {
+                NEEDBITS(state->extra);
+                state->offset += BITS(state->extra);
+                DROPBITS(state->extra);
+            }
+            if (state->offset > state->wsize - (state->whave < state->wsize ?
+                                                left : 0)) {
+                strm->msg = (char *)"invalid distance too far back";
+                state->mode = BAD;
+                break;
+            }
+            Tracevv((stderr, "inflate:         distance %u\n", state->offset));
+
+            /* copy match from window to output */
+            do {
+                ROOM();
+                copy = state->wsize - state->offset;
+                if (copy < left) {
+                    from = put + copy;
+                    copy = left - copy;
+                }
+                else {
+                    from = put - state->offset;
+                    copy = left;
+                }
+                if (copy > state->length) copy = state->length;
+                state->length -= copy;
+                left -= copy;
+                do {
+                    *put++ = *from++;
+                } while (--copy);
+            } while (state->length != 0);
+            break;
+
+        case DONE:
+            /* inflate stream terminated properly -- write leftover output */
+            ret = Z_STREAM_END;
+            if (left < state->wsize) {
+                if (out(out_desc, state->window, state->wsize - left))
+                    ret = Z_BUF_ERROR;
+            }
+            goto inf_leave;
+
+        case BAD:
+            ret = Z_DATA_ERROR;
+            goto inf_leave;
+
+        default:                /* can't happen, but makes compilers happy */
+            ret = Z_STREAM_ERROR;
+            goto inf_leave;
+        }
+
+    /* Return unused input */
+  inf_leave:
+    strm->next_in = next;
+    strm->avail_in = have;
+    return ret;
+}
+
+int ZEXPORT inflateBackEnd(strm)
+z_streamp strm;
+{
+    if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
+        return Z_STREAM_ERROR;
+    ZFREE(strm, strm->state);
+    strm->state = Z_NULL;
+    Tracev((stderr, "inflate: end\n"));
+    return Z_OK;
+}
diff --git a/Engine/lib/assimp/contrib/zlib/inffast.c b/Engine/lib/assimp/contrib/zlib/inffast.c
new file mode 100644
index 000000000..1fec7f363
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/inffast.c
@@ -0,0 +1,323 @@
+/* inffast.c -- fast decoding
+ * Copyright (C) 1995-2017 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+#include "inflate.h"
+#include "inffast.h"
+
+#ifdef ASMINF
+#  pragma message("Assembler code may have bugs -- use at your own risk")
+#else
+
+/*
+   Decode literal, length, and distance codes and write out the resulting
+   literal and match bytes until either not enough input or output is
+   available, an end-of-block is encountered, or a data error is encountered.
+   When large enough input and output buffers are supplied to inflate(), for
+   example, a 16K input buffer and a 64K output buffer, more than 95% of the
+   inflate execution time is spent in this routine.
+
+   Entry assumptions:
+
+        state->mode == LEN
+        strm->avail_in >= 6
+        strm->avail_out >= 258
+        start >= strm->avail_out
+        state->bits < 8
+
+   On return, state->mode is one of:
+
+        LEN -- ran out of enough output space or enough available input
+        TYPE -- reached end of block code, inflate() to interpret next block
+        BAD -- error in block data
+
+   Notes:
+
+    - The maximum input bits used by a length/distance pair is 15 bits for the
+      length code, 5 bits for the length extra, 15 bits for the distance code,
+      and 13 bits for the distance extra.  This totals 48 bits, or six bytes.
+      Therefore if strm->avail_in >= 6, then there is enough input to avoid
+      checking for available input while decoding.
+
+    - The maximum bytes that a single length/distance pair can output is 258
+      bytes, which is the maximum length that can be coded.  inflate_fast()
+      requires strm->avail_out >= 258 for each loop to avoid checking for
+      output space.
+ */
+void ZLIB_INTERNAL inflate_fast(strm, start)
+z_streamp strm;
+unsigned start;         /* inflate()'s starting value for strm->avail_out */
+{
+    struct inflate_state FAR *state;
+    z_const unsigned char FAR *in;      /* local strm->next_in */
+    z_const unsigned char FAR *last;    /* have enough input while in < last */
+    unsigned char FAR *out;     /* local strm->next_out */
+    unsigned char FAR *beg;     /* inflate()'s initial strm->next_out */
+    unsigned char FAR *end;     /* while out < end, enough space available */
+#ifdef INFLATE_STRICT
+    unsigned dmax;              /* maximum distance from zlib header */
+#endif
+    unsigned wsize;             /* window size or zero if not using window */
+    unsigned whave;             /* valid bytes in the window */
+    unsigned wnext;             /* window write index */
+    unsigned char FAR *window;  /* allocated sliding window, if wsize != 0 */
+    unsigned long hold;         /* local strm->hold */
+    unsigned bits;              /* local strm->bits */
+    code const FAR *lcode;      /* local strm->lencode */
+    code const FAR *dcode;      /* local strm->distcode */
+    unsigned lmask;             /* mask for first level of length codes */
+    unsigned dmask;             /* mask for first level of distance codes */
+    code const *here;           /* retrieved table entry */
+    unsigned op;                /* code bits, operation, extra bits, or */
+                                /*  window position, window bytes to copy */
+    unsigned len;               /* match length, unused bytes */
+    unsigned dist;              /* match distance */
+    unsigned char FAR *from;    /* where to copy match from */
+
+    /* copy state to local variables */
+    state = (struct inflate_state FAR *)strm->state;
+    in = strm->next_in;
+    last = in + (strm->avail_in - 5);
+    out = strm->next_out;
+    beg = out - (start - strm->avail_out);
+    end = out + (strm->avail_out - 257);
+#ifdef INFLATE_STRICT
+    dmax = state->dmax;
+#endif
+    wsize = state->wsize;
+    whave = state->whave;
+    wnext = state->wnext;
+    window = state->window;
+    hold = state->hold;
+    bits = state->bits;
+    lcode = state->lencode;
+    dcode = state->distcode;
+    lmask = (1U << state->lenbits) - 1;
+    dmask = (1U << state->distbits) - 1;
+
+    /* decode literals and length/distances until end-of-block or not enough
+       input data or output space */
+    do {
+        if (bits < 15) {
+            hold += (unsigned long)(*in++) << bits;
+            bits += 8;
+            hold += (unsigned long)(*in++) << bits;
+            bits += 8;
+        }
+        here = lcode + (hold & lmask);
+      dolen:
+        op = (unsigned)(here->bits);
+        hold >>= op;
+        bits -= op;
+        op = (unsigned)(here->op);
+        if (op == 0) {                          /* literal */
+            Tracevv((stderr, here->val >= 0x20 && here->val < 0x7f ?
+                    "inflate:         literal '%c'\n" :
+                    "inflate:         literal 0x%02x\n", here->val));
+            *out++ = (unsigned char)(here->val);
+        }
+        else if (op & 16) {                     /* length base */
+            len = (unsigned)(here->val);
+            op &= 15;                           /* number of extra bits */
+            if (op) {
+                if (bits < op) {
+                    hold += (unsigned long)(*in++) << bits;
+                    bits += 8;
+                }
+                len += (unsigned)hold & ((1U << op) - 1);
+                hold >>= op;
+                bits -= op;
+            }
+            Tracevv((stderr, "inflate:         length %u\n", len));
+            if (bits < 15) {
+                hold += (unsigned long)(*in++) << bits;
+                bits += 8;
+                hold += (unsigned long)(*in++) << bits;
+                bits += 8;
+            }
+            here = dcode + (hold & dmask);
+          dodist:
+            op = (unsigned)(here->bits);
+            hold >>= op;
+            bits -= op;
+            op = (unsigned)(here->op);
+            if (op & 16) {                      /* distance base */
+                dist = (unsigned)(here->val);
+                op &= 15;                       /* number of extra bits */
+                if (bits < op) {
+                    hold += (unsigned long)(*in++) << bits;
+                    bits += 8;
+                    if (bits < op) {
+                        hold += (unsigned long)(*in++) << bits;
+                        bits += 8;
+                    }
+                }
+                dist += (unsigned)hold & ((1U << op) - 1);
+#ifdef INFLATE_STRICT
+                if (dist > dmax) {
+                    strm->msg = (char *)"invalid distance too far back";
+                    state->mode = BAD;
+                    break;
+                }
+#endif
+                hold >>= op;
+                bits -= op;
+                Tracevv((stderr, "inflate:         distance %u\n", dist));
+                op = (unsigned)(out - beg);     /* max distance in output */
+                if (dist > op) {                /* see if copy from window */
+                    op = dist - op;             /* distance back in window */
+                    if (op > whave) {
+                        if (state->sane) {
+                            strm->msg =
+                                (char *)"invalid distance too far back";
+                            state->mode = BAD;
+                            break;
+                        }
+#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
+                        if (len <= op - whave) {
+                            do {
+                                *out++ = 0;
+                            } while (--len);
+                            continue;
+                        }
+                        len -= op - whave;
+                        do {
+                            *out++ = 0;
+                        } while (--op > whave);
+                        if (op == 0) {
+                            from = out - dist;
+                            do {
+                                *out++ = *from++;
+                            } while (--len);
+                            continue;
+                        }
+#endif
+                    }
+                    from = window;
+                    if (wnext == 0) {           /* very common case */
+                        from += wsize - op;
+                        if (op < len) {         /* some from window */
+                            len -= op;
+                            do {
+                                *out++ = *from++;
+                            } while (--op);
+                            from = out - dist;  /* rest from output */
+                        }
+                    }
+                    else if (wnext < op) {      /* wrap around window */
+                        from += wsize + wnext - op;
+                        op -= wnext;
+                        if (op < len) {         /* some from end of window */
+                            len -= op;
+                            do {
+                                *out++ = *from++;
+                            } while (--op);
+                            from = window;
+                            if (wnext < len) {  /* some from start of window */
+                                op = wnext;
+                                len -= op;
+                                do {
+                                    *out++ = *from++;
+                                } while (--op);
+                                from = out - dist;      /* rest from output */
+                            }
+                        }
+                    }
+                    else {                      /* contiguous in window */
+                        from += wnext - op;
+                        if (op < len) {         /* some from window */
+                            len -= op;
+                            do {
+                                *out++ = *from++;
+                            } while (--op);
+                            from = out - dist;  /* rest from output */
+                        }
+                    }
+                    while (len > 2) {
+                        *out++ = *from++;
+                        *out++ = *from++;
+                        *out++ = *from++;
+                        len -= 3;
+                    }
+                    if (len) {
+                        *out++ = *from++;
+                        if (len > 1)
+                            *out++ = *from++;
+                    }
+                }
+                else {
+                    from = out - dist;          /* copy direct from output */
+                    do {                        /* minimum length is three */
+                        *out++ = *from++;
+                        *out++ = *from++;
+                        *out++ = *from++;
+                        len -= 3;
+                    } while (len > 2);
+                    if (len) {
+                        *out++ = *from++;
+                        if (len > 1)
+                            *out++ = *from++;
+                    }
+                }
+            }
+            else if ((op & 64) == 0) {          /* 2nd level distance code */
+                here = dcode + here->val + (hold & ((1U << op) - 1));
+                goto dodist;
+            }
+            else {
+                strm->msg = (char *)"invalid distance code";
+                state->mode = BAD;
+                break;
+            }
+        }
+        else if ((op & 64) == 0) {              /* 2nd level length code */
+            here = lcode + here->val + (hold & ((1U << op) - 1));
+            goto dolen;
+        }
+        else if (op & 32) {                     /* end-of-block */
+            Tracevv((stderr, "inflate:         end of block\n"));
+            state->mode = TYPE;
+            break;
+        }
+        else {
+            strm->msg = (char *)"invalid literal/length code";
+            state->mode = BAD;
+            break;
+        }
+    } while (in < last && out < end);
+
+    /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
+    len = bits >> 3;
+    in -= len;
+    bits -= len << 3;
+    hold &= (1U << bits) - 1;
+
+    /* update state and return */
+    strm->next_in = in;
+    strm->next_out = out;
+    strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last));
+    strm->avail_out = (unsigned)(out < end ?
+                                 257 + (end - out) : 257 - (out - end));
+    state->hold = hold;
+    state->bits = bits;
+    return;
+}
+
+/*
+   inflate_fast() speedups that turned out slower (on a PowerPC G3 750CXe):
+   - Using bit fields for code structure
+   - Different op definition to avoid & for extra bits (do & for table bits)
+   - Three separate decoding do-loops for direct, window, and wnext == 0
+   - Special case for distance > 1 copies to do overlapped load and store copy
+   - Explicit branch predictions (based on measured branch probabilities)
+   - Deferring match copy and interspersed it with decoding subsequent codes
+   - Swapping literal/length else
+   - Swapping window/direct else
+   - Larger unrolled copy loops (three is about right)
+   - Moving len -= 3 statement into middle of loop
+ */
+
+#endif /* !ASMINF */
diff --git a/Engine/lib/assimp/contrib/zlib/inffast.h b/Engine/lib/assimp/contrib/zlib/inffast.h
new file mode 100644
index 000000000..e5c1aa4ca
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/inffast.h
@@ -0,0 +1,11 @@
+/* inffast.h -- header to use inffast.c
+ * Copyright (C) 1995-2003, 2010 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+void ZLIB_INTERNAL inflate_fast OF((z_streamp strm, unsigned start));
diff --git a/Engine/lib/assimp/contrib/zlib/inffixed.h b/Engine/lib/assimp/contrib/zlib/inffixed.h
new file mode 100644
index 000000000..d62832776
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/inffixed.h
@@ -0,0 +1,94 @@
+    /* inffixed.h -- table for decoding fixed codes
+     * Generated automatically by makefixed().
+     */
+
+    /* WARNING: this file should *not* be used by applications.
+       It is part of the implementation of this library and is
+       subject to change. Applications should only use zlib.h.
+     */
+
+    static const code lenfix[512] = {
+        {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48},
+        {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128},
+        {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59},
+        {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176},
+        {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20},
+        {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100},
+        {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8},
+        {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216},
+        {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76},
+        {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114},
+        {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2},
+        {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148},
+        {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42},
+        {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86},
+        {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15},
+        {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236},
+        {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62},
+        {0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142},
+        {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31},
+        {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162},
+        {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25},
+        {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105},
+        {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4},
+        {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202},
+        {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69},
+        {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125},
+        {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13},
+        {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195},
+        {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35},
+        {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91},
+        {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19},
+        {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246},
+        {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55},
+        {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135},
+        {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99},
+        {0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190},
+        {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16},
+        {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96},
+        {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6},
+        {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209},
+        {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72},
+        {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116},
+        {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4},
+        {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153},
+        {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44},
+        {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82},
+        {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11},
+        {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229},
+        {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58},
+        {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138},
+        {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51},
+        {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173},
+        {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30},
+        {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110},
+        {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0},
+        {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195},
+        {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65},
+        {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121},
+        {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9},
+        {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258},
+        {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37},
+        {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93},
+        {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23},
+        {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251},
+        {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51},
+        {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131},
+        {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67},
+        {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183},
+        {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23},
+        {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103},
+        {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9},
+        {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223},
+        {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79},
+        {0,9,255}
+    };
+
+    static const code distfix[32] = {
+        {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025},
+        {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193},
+        {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385},
+        {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577},
+        {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073},
+        {22,5,193},{64,5,0}
+    };
diff --git a/Engine/lib/assimp/contrib/zlib/inflate.c b/Engine/lib/assimp/contrib/zlib/inflate.c
new file mode 100644
index 000000000..575fcdf82
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/inflate.c
@@ -0,0 +1,1563 @@
+/* inflate.c -- zlib decompression
+ * Copyright (C) 1995-2016 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/*
+ * Change history:
+ *
+ * 1.2.beta0    24 Nov 2002
+ * - First version -- complete rewrite of inflate to simplify code, avoid
+ *   creation of window when not needed, minimize use of window when it is
+ *   needed, make inffast.c even faster, implement gzip decoding, and to
+ *   improve code readability and style over the previous zlib inflate code
+ *
+ * 1.2.beta1    25 Nov 2002
+ * - Use pointers for available input and output checking in inffast.c
+ * - Remove input and output counters in inffast.c
+ * - Change inffast.c entry and loop from avail_in >= 7 to >= 6
+ * - Remove unnecessary second byte pull from length extra in inffast.c
+ * - Unroll direct copy to three copies per loop in inffast.c
+ *
+ * 1.2.beta2    4 Dec 2002
+ * - Change external routine names to reduce potential conflicts
+ * - Correct filename to inffixed.h for fixed tables in inflate.c
+ * - Make hbuf[] unsigned char to match parameter type in inflate.c
+ * - Change strm->next_out[-state->offset] to *(strm->next_out - state->offset)
+ *   to avoid negation problem on Alphas (64 bit) in inflate.c
+ *
+ * 1.2.beta3    22 Dec 2002
+ * - Add comments on state->bits assertion in inffast.c
+ * - Add comments on op field in inftrees.h
+ * - Fix bug in reuse of allocated window after inflateReset()
+ * - Remove bit fields--back to byte structure for speed
+ * - Remove distance extra == 0 check in inflate_fast()--only helps for lengths
+ * - Change post-increments to pre-increments in inflate_fast(), PPC biased?
+ * - Add compile time option, POSTINC, to use post-increments instead (Intel?)
+ * - Make MATCH copy in inflate() much faster for when inflate_fast() not used
+ * - Use local copies of stream next and avail values, as well as local bit
+ *   buffer and bit count in inflate()--for speed when inflate_fast() not used
+ *
+ * 1.2.beta4    1 Jan 2003
+ * - Split ptr - 257 statements in inflate_table() to avoid compiler warnings
+ * - Move a comment on output buffer sizes from inffast.c to inflate.c
+ * - Add comments in inffast.c to introduce the inflate_fast() routine
+ * - Rearrange window copies in inflate_fast() for speed and simplification
+ * - Unroll last copy for window match in inflate_fast()
+ * - Use local copies of window variables in inflate_fast() for speed
+ * - Pull out common wnext == 0 case for speed in inflate_fast()
+ * - Make op and len in inflate_fast() unsigned for consistency
+ * - Add FAR to lcode and dcode declarations in inflate_fast()
+ * - Simplified bad distance check in inflate_fast()
+ * - Added inflateBackInit(), inflateBack(), and inflateBackEnd() in new
+ *   source file infback.c to provide a call-back interface to inflate for
+ *   programs like gzip and unzip -- uses window as output buffer to avoid
+ *   window copying
+ *
+ * 1.2.beta5    1 Jan 2003
+ * - Improved inflateBack() interface to allow the caller to provide initial
+ *   input in strm.
+ * - Fixed stored blocks bug in inflateBack()
+ *
+ * 1.2.beta6    4 Jan 2003
+ * - Added comments in inffast.c on effectiveness of POSTINC
+ * - Typecasting all around to reduce compiler warnings
+ * - Changed loops from while (1) or do {} while (1) to for (;;), again to
+ *   make compilers happy
+ * - Changed type of window in inflateBackInit() to unsigned char *
+ *
+ * 1.2.beta7    27 Jan 2003
+ * - Changed many types to unsigned or unsigned short to avoid warnings
+ * - Added inflateCopy() function
+ *
+ * 1.2.0        9 Mar 2003
+ * - Changed inflateBack() interface to provide separate opaque descriptors
+ *   for the in() and out() functions
+ * - Changed inflateBack() argument and in_func typedef to swap the length
+ *   and buffer address return values for the input function
+ * - Check next_in and next_out for Z_NULL on entry to inflate()
+ *
+ * The history for versions after 1.2.0 are in ChangeLog in zlib distribution.
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+#include "inflate.h"
+#include "inffast.h"
+
+#ifdef MAKEFIXED
+#  ifndef BUILDFIXED
+#    define BUILDFIXED
+#  endif
+#endif
+
+/* function prototypes */
+local int inflateStateCheck OF((z_streamp strm));
+local void fixedtables OF((struct inflate_state FAR *state));
+local int updatewindow OF((z_streamp strm, const unsigned char FAR *end,
+                           unsigned copy));
+#ifdef BUILDFIXED
+   void makefixed OF((void));
+#endif
+local unsigned syncsearch OF((unsigned FAR *have, const unsigned char FAR *buf,
+                              unsigned len));
+
+local int inflateStateCheck(strm)
+z_streamp strm;
+{
+    struct inflate_state FAR *state;
+    if (strm == Z_NULL ||
+        strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0)
+        return 1;
+    state = (struct inflate_state FAR *)strm->state;
+    if (state == Z_NULL || state->strm != strm ||
+        state->mode < HEAD || state->mode > SYNC)
+        return 1;
+    return 0;
+}
+
+int ZEXPORT inflateResetKeep(strm)
+z_streamp strm;
+{
+    struct inflate_state FAR *state;
+
+    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    strm->total_in = strm->total_out = state->total = 0;
+    strm->msg = Z_NULL;
+    if (state->wrap)        /* to support ill-conceived Java test suite */
+        strm->adler = state->wrap & 1;
+    state->mode = HEAD;
+    state->last = 0;
+    state->havedict = 0;
+    state->dmax = 32768U;
+    state->head = Z_NULL;
+    state->hold = 0;
+    state->bits = 0;
+    state->lencode = state->distcode = state->next = state->codes;
+    state->sane = 1;
+    state->back = -1;
+    Tracev((stderr, "inflate: reset\n"));
+    return Z_OK;
+}
+
+int ZEXPORT inflateReset(strm)
+z_streamp strm;
+{
+    struct inflate_state FAR *state;
+
+    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    state->wsize = 0;
+    state->whave = 0;
+    state->wnext = 0;
+    return inflateResetKeep(strm);
+}
+
+int ZEXPORT inflateReset2(strm, windowBits)
+z_streamp strm;
+int windowBits;
+{
+    int wrap;
+    struct inflate_state FAR *state;
+
+    /* get the state */
+    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+
+    /* extract wrap request from windowBits parameter */
+    if (windowBits < 0) {
+        wrap = 0;
+        windowBits = -windowBits;
+    }
+    else {
+        wrap = (windowBits >> 4) + 5;
+#ifdef GUNZIP
+        if (windowBits < 48)
+            windowBits &= 15;
+#endif
+    }
+
+    /* set number of window bits, free window if different */
+    if (windowBits && (windowBits < 8 || windowBits > 15))
+        return Z_STREAM_ERROR;
+    if (state->window != Z_NULL && state->wbits != (unsigned)windowBits) {
+        ZFREE(strm, state->window);
+        state->window = Z_NULL;
+    }
+
+    /* update state and reset the rest of it */
+    state->wrap = wrap;
+    state->wbits = (unsigned)windowBits;
+    return inflateReset(strm);
+}
+
+int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size)
+z_streamp strm;
+int windowBits;
+const char *version;
+int stream_size;
+{
+    int ret;
+    struct inflate_state FAR *state;
+
+    if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
+        stream_size != (int)(sizeof(z_stream)))
+        return Z_VERSION_ERROR;
+    if (strm == Z_NULL) return Z_STREAM_ERROR;
+    strm->msg = Z_NULL;                 /* in case we return an error */
+    if (strm->zalloc == (alloc_func)0) {
+#ifdef Z_SOLO
+        return Z_STREAM_ERROR;
+#else
+        strm->zalloc = zcalloc;
+        strm->opaque = (voidpf)0;
+#endif
+    }
+    if (strm->zfree == (free_func)0)
+#ifdef Z_SOLO
+        return Z_STREAM_ERROR;
+#else
+        strm->zfree = zcfree;
+#endif
+    state = (struct inflate_state FAR *)
+            ZALLOC(strm, 1, sizeof(struct inflate_state));
+    if (state == Z_NULL) return Z_MEM_ERROR;
+    Tracev((stderr, "inflate: allocated\n"));
+    strm->state = (struct internal_state FAR *)state;
+    state->strm = strm;
+    state->window = Z_NULL;
+    state->mode = HEAD;     /* to pass state test in inflateReset2() */
+    ret = inflateReset2(strm, windowBits);
+    if (ret != Z_OK) {
+        ZFREE(strm, state);
+        strm->state = Z_NULL;
+    }
+    return ret;
+}
+
+int ZEXPORT inflateInit_(strm, version, stream_size)
+z_streamp strm;
+const char *version;
+int stream_size;
+{
+    return inflateInit2_(strm, DEF_WBITS, version, stream_size);
+}
+
+int ZEXPORT inflatePrime(strm, bits, value)
+z_streamp strm;
+int bits;
+int value;
+{
+    struct inflate_state FAR *state;
+
+    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    if (bits < 0) {
+        state->hold = 0;
+        state->bits = 0;
+        return Z_OK;
+    }
+    if (bits > 16 || state->bits + (uInt)bits > 32) return Z_STREAM_ERROR;
+    value &= (1L << bits) - 1;
+    state->hold += (unsigned)value << state->bits;
+    state->bits += (uInt)bits;
+    return Z_OK;
+}
+
+/*
+   Return state with length and distance decoding tables and index sizes set to
+   fixed code decoding.  Normally this returns fixed tables from inffixed.h.
+   If BUILDFIXED is defined, then instead this routine builds the tables the
+   first time it's called, and returns those tables the first time and
+   thereafter.  This reduces the size of the code by about 2K bytes, in
+   exchange for a little execution time.  However, BUILDFIXED should not be
+   used for threaded applications, since the rewriting of the tables and virgin
+   may not be thread-safe.
+ */
+local void fixedtables(state)
+struct inflate_state FAR *state;
+{
+#ifdef BUILDFIXED
+    static int virgin = 1;
+    static code *lenfix, *distfix;
+    static code fixed[544];
+
+    /* build fixed huffman tables if first call (may not be thread safe) */
+    if (virgin) {
+        unsigned sym, bits;
+        static code *next;
+
+        /* literal/length table */
+        sym = 0;
+        while (sym < 144) state->lens[sym++] = 8;
+        while (sym < 256) state->lens[sym++] = 9;
+        while (sym < 280) state->lens[sym++] = 7;
+        while (sym < 288) state->lens[sym++] = 8;
+        next = fixed;
+        lenfix = next;
+        bits = 9;
+        inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
+
+        /* distance table */
+        sym = 0;
+        while (sym < 32) state->lens[sym++] = 5;
+        distfix = next;
+        bits = 5;
+        inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
+
+        /* do this just once */
+        virgin = 0;
+    }
+#else /* !BUILDFIXED */
+#   include "inffixed.h"
+#endif /* BUILDFIXED */
+    state->lencode = lenfix;
+    state->lenbits = 9;
+    state->distcode = distfix;
+    state->distbits = 5;
+}
+
+#ifdef MAKEFIXED
+#include <stdio.h>
+
+/*
+   Write out the inffixed.h that is #include'd above.  Defining MAKEFIXED also
+   defines BUILDFIXED, so the tables are built on the fly.  makefixed() writes
+   those tables to stdout, which would be piped to inffixed.h.  A small program
+   can simply call makefixed to do this:
+
+    void makefixed(void);
+
+    int main(void)
+    {
+        makefixed();
+        return 0;
+    }
+
+   Then that can be linked with zlib built with MAKEFIXED defined and run:
+
+    a.out > inffixed.h
+ */
+void makefixed()
+{
+    unsigned low, size;
+    struct inflate_state state;
+
+    fixedtables(&state);
+    puts("    /* inffixed.h -- table for decoding fixed codes");
+    puts("     * Generated automatically by makefixed().");
+    puts("     */");
+    puts("");
+    puts("    /* WARNING: this file should *not* be used by applications.");
+    puts("       It is part of the implementation of this library and is");
+    puts("       subject to change. Applications should only use zlib.h.");
+    puts("     */");
+    puts("");
+    size = 1U << 9;
+    printf("    static const code lenfix[%u] = {", size);
+    low = 0;
+    for (;;) {
+        if ((low % 7) == 0) printf("\n        ");
+        printf("{%u,%u,%d}", (low & 127) == 99 ? 64 : state.lencode[low].op,
+               state.lencode[low].bits, state.lencode[low].val);
+        if (++low == size) break;
+        putchar(',');
+    }
+    puts("\n    };");
+    size = 1U << 5;
+    printf("\n    static const code distfix[%u] = {", size);
+    low = 0;
+    for (;;) {
+        if ((low % 6) == 0) printf("\n        ");
+        printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits,
+               state.distcode[low].val);
+        if (++low == size) break;
+        putchar(',');
+    }
+    puts("\n    };");
+}
+#endif /* MAKEFIXED */
+
+/*
+   Update the window with the last wsize (normally 32K) bytes written before
+   returning.  If window does not exist yet, create it.  This is only called
+   when a window is already in use, or when output has been written during this
+   inflate call, but the end of the deflate stream has not been reached yet.
+   It is also called to create a window for dictionary data when a dictionary
+   is loaded.
+
+   Providing output buffers larger than 32K to inflate() should provide a speed
+   advantage, since only the last 32K of output is copied to the sliding window
+   upon return from inflate(), and since all distances after the first 32K of
+   output will fall in the output data, making match copies simpler and faster.
+   The advantage may be dependent on the size of the processor's data caches.
+ */
+local int updatewindow(strm, end, copy)
+z_streamp strm;
+const Bytef *end;
+unsigned copy;
+{
+    struct inflate_state FAR *state;
+    unsigned dist;
+
+    state = (struct inflate_state FAR *)strm->state;
+
+    /* if it hasn't been done already, allocate space for the window */
+    if (state->window == Z_NULL) {
+        state->window = (unsigned char FAR *)
+                        ZALLOC(strm, 1U << state->wbits,
+                               sizeof(unsigned char));
+        if (state->window == Z_NULL) return 1;
+    }
+
+    /* if window not in use yet, initialize */
+    if (state->wsize == 0) {
+        state->wsize = 1U << state->wbits;
+        state->wnext = 0;
+        state->whave = 0;
+    }
+
+    /* copy state->wsize or less output bytes into the circular window */
+    if (copy >= state->wsize) {
+        zmemcpy(state->window, end - state->wsize, state->wsize);
+        state->wnext = 0;
+        state->whave = state->wsize;
+    }
+    else {
+        dist = state->wsize - state->wnext;
+        if (dist > copy) dist = copy;
+        zmemcpy(state->window + state->wnext, end - copy, dist);
+        copy -= dist;
+        if (copy) {
+            zmemcpy(state->window, end - copy, copy);
+            state->wnext = copy;
+            state->whave = state->wsize;
+        }
+        else {
+            state->wnext += dist;
+            if (state->wnext == state->wsize) state->wnext = 0;
+            if (state->whave < state->wsize) state->whave += dist;
+        }
+    }
+    return 0;
+}
+
+/* Macros for inflate(): */
+
+/* check function to use adler32() for zlib or crc32() for gzip */
+#ifdef GUNZIP
+#  define UPDATE(check, buf, len) \
+    (state->flags ? crc32(check, buf, len) : adler32(check, buf, len))
+#else
+#  define UPDATE(check, buf, len) adler32(check, buf, len)
+#endif
+
+/* check macros for header crc */
+#ifdef GUNZIP
+#  define CRC2(check, word) \
+    do { \
+        hbuf[0] = (unsigned char)(word); \
+        hbuf[1] = (unsigned char)((word) >> 8); \
+        check = crc32(check, hbuf, 2); \
+    } while (0)
+
+#  define CRC4(check, word) \
+    do { \
+        hbuf[0] = (unsigned char)(word); \
+        hbuf[1] = (unsigned char)((word) >> 8); \
+        hbuf[2] = (unsigned char)((word) >> 16); \
+        hbuf[3] = (unsigned char)((word) >> 24); \
+        check = crc32(check, hbuf, 4); \
+    } while (0)
+#endif
+
+/* Load registers with state in inflate() for speed */
+#define LOAD() \
+    do { \
+        put = strm->next_out; \
+        left = strm->avail_out; \
+        next = strm->next_in; \
+        have = strm->avail_in; \
+        hold = state->hold; \
+        bits = state->bits; \
+    } while (0)
+
+/* Restore state from registers in inflate() */
+#define RESTORE() \
+    do { \
+        strm->next_out = put; \
+        strm->avail_out = left; \
+        strm->next_in = next; \
+        strm->avail_in = have; \
+        state->hold = hold; \
+        state->bits = bits; \
+    } while (0)
+
+/* Clear the input bit accumulator */
+#define INITBITS() \
+    do { \
+        hold = 0; \
+        bits = 0; \
+    } while (0)
+
+/* Get a byte of input into the bit accumulator, or return from inflate()
+   if there is no input available. */
+#define PULLBYTE() \
+    do { \
+        if (have == 0) goto inf_leave; \
+        have--; \
+        hold += (unsigned long)(*next++) << bits; \
+        bits += 8; \
+    } while (0)
+
+/* Assure that there are at least n bits in the bit accumulator.  If there is
+   not enough available input to do that, then return from inflate(). */
+#define NEEDBITS(n) \
+    do { \
+        while (bits < (unsigned)(n)) \
+            PULLBYTE(); \
+    } while (0)
+
+/* Return the low n bits of the bit accumulator (n < 16) */
+#define BITS(n) \
+    ((unsigned)hold & ((1U << (n)) - 1))
+
+/* Remove n bits from the bit accumulator */
+#define DROPBITS(n) \
+    do { \
+        hold >>= (n); \
+        bits -= (unsigned)(n); \
+    } while (0)
+
+/* Remove zero to seven bits as needed to go to a byte boundary */
+#define BYTEBITS() \
+    do { \
+        hold >>= bits & 7; \
+        bits -= bits & 7; \
+    } while (0)
+
+/*
+   inflate() uses a state machine to process as much input data and generate as
+   much output data as possible before returning.  The state machine is
+   structured roughly as follows:
+
+    for (;;) switch (state) {
+    ...
+    case STATEn:
+        if (not enough input data or output space to make progress)
+            return;
+        ... make progress ...
+        state = STATEm;
+        break;
+    ...
+    }
+
+   so when inflate() is called again, the same case is attempted again, and
+   if the appropriate resources are provided, the machine proceeds to the
+   next state.  The NEEDBITS() macro is usually the way the state evaluates
+   whether it can proceed or should return.  NEEDBITS() does the return if
+   the requested bits are not available.  The typical use of the BITS macros
+   is:
+
+        NEEDBITS(n);
+        ... do something with BITS(n) ...
+        DROPBITS(n);
+
+   where NEEDBITS(n) either returns from inflate() if there isn't enough
+   input left to load n bits into the accumulator, or it continues.  BITS(n)
+   gives the low n bits in the accumulator.  When done, DROPBITS(n) drops
+   the low n bits off the accumulator.  INITBITS() clears the accumulator
+   and sets the number of available bits to zero.  BYTEBITS() discards just
+   enough bits to put the accumulator on a byte boundary.  After BYTEBITS()
+   and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.
+
+   NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return
+   if there is no input available.  The decoding of variable length codes uses
+   PULLBYTE() directly in order to pull just enough bytes to decode the next
+   code, and no more.
+
+   Some states loop until they get enough input, making sure that enough
+   state information is maintained to continue the loop where it left off
+   if NEEDBITS() returns in the loop.  For example, want, need, and keep
+   would all have to actually be part of the saved state in case NEEDBITS()
+   returns:
+
+    case STATEw:
+        while (want < need) {
+            NEEDBITS(n);
+            keep[want++] = BITS(n);
+            DROPBITS(n);
+        }
+        state = STATEx;
+    case STATEx:
+
+   As shown above, if the next state is also the next case, then the break
+   is omitted.
+
+   A state may also return if there is not enough output space available to
+   complete that state.  Those states are copying stored data, writing a
+   literal byte, and copying a matching string.
+
+   When returning, a "goto inf_leave" is used to update the total counters,
+   update the check value, and determine whether any progress has been made
+   during that inflate() call in order to return the proper return code.
+   Progress is defined as a change in either strm->avail_in or strm->avail_out.
+   When there is a window, goto inf_leave will update the window with the last
+   output written.  If a goto inf_leave occurs in the middle of decompression
+   and there is no window currently, goto inf_leave will create one and copy
+   output to the window for the next call of inflate().
+
+   In this implementation, the flush parameter of inflate() only affects the
+   return code (per zlib.h).  inflate() always writes as much as possible to
+   strm->next_out, given the space available and the provided input--the effect
+   documented in zlib.h of Z_SYNC_FLUSH.  Furthermore, inflate() always defers
+   the allocation of and copying into a sliding window until necessary, which
+   provides the effect documented in zlib.h for Z_FINISH when the entire input
+   stream available.  So the only thing the flush parameter actually does is:
+   when flush is set to Z_FINISH, inflate() cannot return Z_OK.  Instead it
+   will return Z_BUF_ERROR if it has not reached the end of the stream.
+ */
+
+int ZEXPORT inflate(strm, flush)
+z_streamp strm;
+int flush;
+{
+    struct inflate_state FAR *state;
+    z_const unsigned char FAR *next;    /* next input */
+    unsigned char FAR *put;     /* next output */
+    unsigned have, left;        /* available input and output */
+    unsigned long hold;         /* bit buffer */
+    unsigned bits;              /* bits in bit buffer */
+    unsigned in, out;           /* save starting available input and output */
+    unsigned copy;              /* number of stored or match bytes to copy */
+    unsigned char FAR *from;    /* where to copy match bytes from */
+    code here;                  /* current decoding table entry */
+    code last;                  /* parent table entry */
+    unsigned len;               /* length to copy for repeats, bits to drop */
+    int ret;                    /* return code */
+#ifdef GUNZIP
+    unsigned char hbuf[4];      /* buffer for gzip header crc calculation */
+#endif
+    static const unsigned short order[19] = /* permutation of code lengths */
+        {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
+
+    if (inflateStateCheck(strm) || strm->next_out == Z_NULL ||
+        (strm->next_in == Z_NULL && strm->avail_in != 0))
+        return Z_STREAM_ERROR;
+
+    state = (struct inflate_state FAR *)strm->state;
+    if (state->mode == TYPE) state->mode = TYPEDO;      /* skip check */
+    LOAD();
+    in = have;
+    out = left;
+    ret = Z_OK;
+    for (;;)
+        switch (state->mode) {
+        case HEAD:
+            if (state->wrap == 0) {
+                state->mode = TYPEDO;
+                break;
+            }
+            NEEDBITS(16);
+#ifdef GUNZIP
+            if ((state->wrap & 2) && hold == 0x8b1f) {  /* gzip header */
+                if (state->wbits == 0)
+                    state->wbits = 15;
+                state->check = crc32(0L, Z_NULL, 0);
+                CRC2(state->check, hold);
+                INITBITS();
+                state->mode = FLAGS;
+                break;
+            }
+            state->flags = 0;           /* expect zlib header */
+            if (state->head != Z_NULL)
+                state->head->done = -1;
+            if (!(state->wrap & 1) ||   /* check if zlib header allowed */
+#else
+            if (
+#endif
+                ((BITS(8) << 8) + (hold >> 8)) % 31) {
+                strm->msg = (char *)"incorrect header check";
+                state->mode = BAD;
+                break;
+            }
+            if (BITS(4) != Z_DEFLATED) {
+                strm->msg = (char *)"unknown compression method";
+                state->mode = BAD;
+                break;
+            }
+            DROPBITS(4);
+            len = BITS(4) + 8;
+            if (state->wbits == 0)
+                state->wbits = len;
+            if (len > 15 || len > state->wbits) {
+                strm->msg = (char *)"invalid window size";
+                state->mode = BAD;
+                break;
+            }
+            state->dmax = 1U << len;
+            Tracev((stderr, "inflate:   zlib header ok\n"));
+            strm->adler = state->check = adler32(0L, Z_NULL, 0);
+            state->mode = hold & 0x200 ? DICTID : TYPE;
+            INITBITS();
+            break;
+#ifdef GUNZIP
+        case FLAGS:
+            NEEDBITS(16);
+            state->flags = (int)(hold);
+            if ((state->flags & 0xff) != Z_DEFLATED) {
+                strm->msg = (char *)"unknown compression method";
+                state->mode = BAD;
+                break;
+            }
+            if (state->flags & 0xe000) {
+                strm->msg = (char *)"unknown header flags set";
+                state->mode = BAD;
+                break;
+            }
+            if (state->head != Z_NULL)
+                state->head->text = (int)((hold >> 8) & 1);
+            if ((state->flags & 0x0200) && (state->wrap & 4))
+                CRC2(state->check, hold);
+            INITBITS();
+            state->mode = TIME;
+        case TIME:
+            NEEDBITS(32);
+            if (state->head != Z_NULL)
+                state->head->time = hold;
+            if ((state->flags & 0x0200) && (state->wrap & 4))
+                CRC4(state->check, hold);
+            INITBITS();
+            state->mode = OS;
+        case OS:
+            NEEDBITS(16);
+            if (state->head != Z_NULL) {
+                state->head->xflags = (int)(hold & 0xff);
+                state->head->os = (int)(hold >> 8);
+            }
+            if ((state->flags & 0x0200) && (state->wrap & 4))
+                CRC2(state->check, hold);
+            INITBITS();
+            state->mode = EXLEN;
+        case EXLEN:
+            if (state->flags & 0x0400) {
+                NEEDBITS(16);
+                state->length = (unsigned)(hold);
+                if (state->head != Z_NULL)
+                    state->head->extra_len = (unsigned)hold;
+                if ((state->flags & 0x0200) && (state->wrap & 4))
+                    CRC2(state->check, hold);
+                INITBITS();
+            }
+            else if (state->head != Z_NULL)
+                state->head->extra = Z_NULL;
+            state->mode = EXTRA;
+        case EXTRA:
+            if (state->flags & 0x0400) {
+                copy = state->length;
+                if (copy > have) copy = have;
+                if (copy) {
+                    if (state->head != Z_NULL &&
+                        state->head->extra != Z_NULL) {
+                        len = state->head->extra_len - state->length;
+                        zmemcpy(state->head->extra + len, next,
+                                len + copy > state->head->extra_max ?
+                                state->head->extra_max - len : copy);
+                    }
+                    if ((state->flags & 0x0200) && (state->wrap & 4))
+                        state->check = crc32(state->check, next, copy);
+                    have -= copy;
+                    next += copy;
+                    state->length -= copy;
+                }
+                if (state->length) goto inf_leave;
+            }
+            state->length = 0;
+            state->mode = NAME;
+        case NAME:
+            if (state->flags & 0x0800) {
+                if (have == 0) goto inf_leave;
+                copy = 0;
+                do {
+                    len = (unsigned)(next[copy++]);
+                    if (state->head != Z_NULL &&
+                            state->head->name != Z_NULL &&
+                            state->length < state->head->name_max)
+                        state->head->name[state->length++] = (Bytef)len;
+                } while (len && copy < have);
+                if ((state->flags & 0x0200) && (state->wrap & 4))
+                    state->check = crc32(state->check, next, copy);
+                have -= copy;
+                next += copy;
+                if (len) goto inf_leave;
+            }
+            else if (state->head != Z_NULL)
+                state->head->name = Z_NULL;
+            state->length = 0;
+            state->mode = COMMENT;
+        case COMMENT:
+            if (state->flags & 0x1000) {
+                if (have == 0) goto inf_leave;
+                copy = 0;
+                do {
+                    len = (unsigned)(next[copy++]);
+                    if (state->head != Z_NULL &&
+                            state->head->comment != Z_NULL &&
+                            state->length < state->head->comm_max)
+                        state->head->comment[state->length++] = (Bytef)len;
+                } while (len && copy < have);
+                if ((state->flags & 0x0200) && (state->wrap & 4))
+                    state->check = crc32(state->check, next, copy);
+                have -= copy;
+                next += copy;
+                if (len) goto inf_leave;
+            }
+            else if (state->head != Z_NULL)
+                state->head->comment = Z_NULL;
+            state->mode = HCRC;
+        case HCRC:
+            if (state->flags & 0x0200) {
+                NEEDBITS(16);
+                if ((state->wrap & 4) && hold != (state->check & 0xffff)) {
+                    strm->msg = (char *)"header crc mismatch";
+                    state->mode = BAD;
+                    break;
+                }
+                INITBITS();
+            }
+            if (state->head != Z_NULL) {
+                state->head->hcrc = (int)((state->flags >> 9) & 1);
+                state->head->done = 1;
+            }
+            strm->adler = state->check = crc32(0L, Z_NULL, 0);
+            state->mode = TYPE;
+            break;
+#endif
+        case DICTID:
+            NEEDBITS(32);
+            strm->adler = state->check = ZSWAP32(hold);
+            INITBITS();
+            state->mode = DICT;
+        case DICT:
+            if (state->havedict == 0) {
+                RESTORE();
+                return Z_NEED_DICT;
+            }
+            strm->adler = state->check = adler32(0L, Z_NULL, 0);
+            state->mode = TYPE;
+        case TYPE:
+            if (flush == Z_BLOCK || flush == Z_TREES) goto inf_leave;
+        case TYPEDO:
+            if (state->last) {
+                BYTEBITS();
+                state->mode = CHECK;
+                break;
+            }
+            NEEDBITS(3);
+            state->last = BITS(1);
+            DROPBITS(1);
+            switch (BITS(2)) {
+            case 0:                             /* stored block */
+                Tracev((stderr, "inflate:     stored block%s\n",
+                        state->last ? " (last)" : ""));
+                state->mode = STORED;
+                break;
+            case 1:                             /* fixed block */
+                fixedtables(state);
+                Tracev((stderr, "inflate:     fixed codes block%s\n",
+                        state->last ? " (last)" : ""));
+                state->mode = LEN_;             /* decode codes */
+                if (flush == Z_TREES) {
+                    DROPBITS(2);
+                    goto inf_leave;
+                }
+                break;
+            case 2:                             /* dynamic block */
+                Tracev((stderr, "inflate:     dynamic codes block%s\n",
+                        state->last ? " (last)" : ""));
+                state->mode = TABLE;
+                break;
+            case 3:
+                strm->msg = (char *)"invalid block type";
+                state->mode = BAD;
+            }
+            DROPBITS(2);
+            break;
+        case STORED:
+            BYTEBITS();                         /* go to byte boundary */
+            NEEDBITS(32);
+            if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
+                strm->msg = (char *)"invalid stored block lengths";
+                state->mode = BAD;
+                break;
+            }
+            state->length = (unsigned)hold & 0xffff;
+            Tracev((stderr, "inflate:       stored length %u\n",
+                    state->length));
+            INITBITS();
+            state->mode = COPY_;
+            if (flush == Z_TREES) goto inf_leave;
+        case COPY_:
+            state->mode = COPY;
+        case COPY:
+            copy = state->length;
+            if (copy) {
+                if (copy > have) copy = have;
+                if (copy > left) copy = left;
+                if (copy == 0) goto inf_leave;
+                zmemcpy(put, next, copy);
+                have -= copy;
+                next += copy;
+                left -= copy;
+                put += copy;
+                state->length -= copy;
+                break;
+            }
+            Tracev((stderr, "inflate:       stored end\n"));
+            state->mode = TYPE;
+            break;
+        case TABLE:
+            NEEDBITS(14);
+            state->nlen = BITS(5) + 257;
+            DROPBITS(5);
+            state->ndist = BITS(5) + 1;
+            DROPBITS(5);
+            state->ncode = BITS(4) + 4;
+            DROPBITS(4);
+#ifndef PKZIP_BUG_WORKAROUND
+            if (state->nlen > 286 || state->ndist > 30) {
+                strm->msg = (char *)"too many length or distance symbols";
+                state->mode = BAD;
+                break;
+            }
+#endif
+            Tracev((stderr, "inflate:       table sizes ok\n"));
+            state->have = 0;
+            state->mode = LENLENS;
+        case LENLENS:
+            while (state->have < state->ncode) {
+                NEEDBITS(3);
+                state->lens[order[state->have++]] = (unsigned short)BITS(3);
+                DROPBITS(3);
+            }
+            while (state->have < 19)
+                state->lens[order[state->have++]] = 0;
+            state->next = state->codes;
+            state->lencode = (const code FAR *)(state->next);
+            state->lenbits = 7;
+            ret = inflate_table(CODES, state->lens, 19, &(state->next),
+                                &(state->lenbits), state->work);
+            if (ret) {
+                strm->msg = (char *)"invalid code lengths set";
+                state->mode = BAD;
+                break;
+            }
+            Tracev((stderr, "inflate:       code lengths ok\n"));
+            state->have = 0;
+            state->mode = CODELENS;
+        case CODELENS:
+            while (state->have < state->nlen + state->ndist) {
+                for (;;) {
+                    here = state->lencode[BITS(state->lenbits)];
+                    if ((unsigned)(here.bits) <= bits) break;
+                    PULLBYTE();
+                }
+                if (here.val < 16) {
+                    DROPBITS(here.bits);
+                    state->lens[state->have++] = here.val;
+                }
+                else {
+                    if (here.val == 16) {
+                        NEEDBITS(here.bits + 2);
+                        DROPBITS(here.bits);
+                        if (state->have == 0) {
+                            strm->msg = (char *)"invalid bit length repeat";
+                            state->mode = BAD;
+                            break;
+                        }
+                        len = state->lens[state->have - 1];
+                        copy = 3 + BITS(2);
+                        DROPBITS(2);
+                    }
+                    else if (here.val == 17) {
+                        NEEDBITS(here.bits + 3);
+                        DROPBITS(here.bits);
+                        len = 0;
+                        copy = 3 + BITS(3);
+                        DROPBITS(3);
+                    }
+                    else {
+                        NEEDBITS(here.bits + 7);
+                        DROPBITS(here.bits);
+                        len = 0;
+                        copy = 11 + BITS(7);
+                        DROPBITS(7);
+                    }
+                    if (state->have + copy > state->nlen + state->ndist) {
+                        strm->msg = (char *)"invalid bit length repeat";
+                        state->mode = BAD;
+                        break;
+                    }
+                    while (copy--)
+                        state->lens[state->have++] = (unsigned short)len;
+                }
+            }
+
+            /* handle error breaks in while */
+            if (state->mode == BAD) break;
+
+            /* check for end-of-block code (better have one) */
+            if (state->lens[256] == 0) {
+                strm->msg = (char *)"invalid code -- missing end-of-block";
+                state->mode = BAD;
+                break;
+            }
+
+            /* build code tables -- note: do not change the lenbits or distbits
+               values here (9 and 6) without reading the comments in inftrees.h
+               concerning the ENOUGH constants, which depend on those values */
+            state->next = state->codes;
+            state->lencode = (const code FAR *)(state->next);
+            state->lenbits = 9;
+            ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
+                                &(state->lenbits), state->work);
+            if (ret) {
+                strm->msg = (char *)"invalid literal/lengths set";
+                state->mode = BAD;
+                break;
+            }
+            state->distcode = (const code FAR *)(state->next);
+            state->distbits = 6;
+            ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
+                            &(state->next), &(state->distbits), state->work);
+            if (ret) {
+                strm->msg = (char *)"invalid distances set";
+                state->mode = BAD;
+                break;
+            }
+            Tracev((stderr, "inflate:       codes ok\n"));
+            state->mode = LEN_;
+            if (flush == Z_TREES) goto inf_leave;
+        case LEN_:
+            state->mode = LEN;
+        case LEN:
+            if (have >= 6 && left >= 258) {
+                RESTORE();
+                inflate_fast(strm, out);
+                LOAD();
+                if (state->mode == TYPE)
+                    state->back = -1;
+                break;
+            }
+            state->back = 0;
+            for (;;) {
+                here = state->lencode[BITS(state->lenbits)];
+                if ((unsigned)(here.bits) <= bits) break;
+                PULLBYTE();
+            }
+            if (here.op && (here.op & 0xf0) == 0) {
+                last = here;
+                for (;;) {
+                    here = state->lencode[last.val +
+                            (BITS(last.bits + last.op) >> last.bits)];
+                    if ((unsigned)(last.bits + here.bits) <= bits) break;
+                    PULLBYTE();
+                }
+                DROPBITS(last.bits);
+                state->back += last.bits;
+            }
+            DROPBITS(here.bits);
+            state->back += here.bits;
+            state->length = (unsigned)here.val;
+            if ((int)(here.op) == 0) {
+                Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
+                        "inflate:         literal '%c'\n" :
+                        "inflate:         literal 0x%02x\n", here.val));
+                state->mode = LIT;
+                break;
+            }
+            if (here.op & 32) {
+                Tracevv((stderr, "inflate:         end of block\n"));
+                state->back = -1;
+                state->mode = TYPE;
+                break;
+            }
+            if (here.op & 64) {
+                strm->msg = (char *)"invalid literal/length code";
+                state->mode = BAD;
+                break;
+            }
+            state->extra = (unsigned)(here.op) & 15;
+            state->mode = LENEXT;
+        case LENEXT:
+            if (state->extra) {
+                NEEDBITS(state->extra);
+                state->length += BITS(state->extra);
+                DROPBITS(state->extra);
+                state->back += state->extra;
+            }
+            Tracevv((stderr, "inflate:         length %u\n", state->length));
+            state->was = state->length;
+            state->mode = DIST;
+        case DIST:
+            for (;;) {
+                here = state->distcode[BITS(state->distbits)];
+                if ((unsigned)(here.bits) <= bits) break;
+                PULLBYTE();
+            }
+            if ((here.op & 0xf0) == 0) {
+                last = here;
+                for (;;) {
+                    here = state->distcode[last.val +
+                            (BITS(last.bits + last.op) >> last.bits)];
+                    if ((unsigned)(last.bits + here.bits) <= bits) break;
+                    PULLBYTE();
+                }
+                DROPBITS(last.bits);
+                state->back += last.bits;
+            }
+            DROPBITS(here.bits);
+            state->back += here.bits;
+            if (here.op & 64) {
+                strm->msg = (char *)"invalid distance code";
+                state->mode = BAD;
+                break;
+            }
+            state->offset = (unsigned)here.val;
+            state->extra = (unsigned)(here.op) & 15;
+            state->mode = DISTEXT;
+        case DISTEXT:
+            if (state->extra) {
+                NEEDBITS(state->extra);
+                state->offset += BITS(state->extra);
+                DROPBITS(state->extra);
+                state->back += state->extra;
+            }
+#ifdef INFLATE_STRICT
+            if (state->offset > state->dmax) {
+                strm->msg = (char *)"invalid distance too far back";
+                state->mode = BAD;
+                break;
+            }
+#endif
+            Tracevv((stderr, "inflate:         distance %u\n", state->offset));
+            state->mode = MATCH;
+        case MATCH:
+            if (left == 0) goto inf_leave;
+            copy = out - left;
+            if (state->offset > copy) {         /* copy from window */
+                copy = state->offset - copy;
+                if (copy > state->whave) {
+                    if (state->sane) {
+                        strm->msg = (char *)"invalid distance too far back";
+                        state->mode = BAD;
+                        break;
+                    }
+#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
+                    Trace((stderr, "inflate.c too far\n"));
+                    copy -= state->whave;
+                    if (copy > state->length) copy = state->length;
+                    if (copy > left) copy = left;
+                    left -= copy;
+                    state->length -= copy;
+                    do {
+                        *put++ = 0;
+                    } while (--copy);
+                    if (state->length == 0) state->mode = LEN;
+                    break;
+#endif
+                }
+                if (copy > state->wnext) {
+                    copy -= state->wnext;
+                    from = state->window + (state->wsize - copy);
+                }
+                else
+                    from = state->window + (state->wnext - copy);
+                if (copy > state->length) copy = state->length;
+            }
+            else {                              /* copy from output */
+                from = put - state->offset;
+                copy = state->length;
+            }
+            if (copy > left) copy = left;
+            left -= copy;
+            state->length -= copy;
+            do {
+                *put++ = *from++;
+            } while (--copy);
+            if (state->length == 0) state->mode = LEN;
+            break;
+        case LIT:
+            if (left == 0) goto inf_leave;
+            *put++ = (unsigned char)(state->length);
+            left--;
+            state->mode = LEN;
+            break;
+        case CHECK:
+            if (state->wrap) {
+                NEEDBITS(32);
+                out -= left;
+                strm->total_out += out;
+                state->total += out;
+                if ((state->wrap & 4) && out)
+                    strm->adler = state->check =
+                        UPDATE(state->check, put - out, out);
+                out = left;
+                if ((state->wrap & 4) && (
+#ifdef GUNZIP
+                     state->flags ? hold :
+#endif
+                     ZSWAP32(hold)) != state->check) {
+                    strm->msg = (char *)"incorrect data check";
+                    state->mode = BAD;
+                    break;
+                }
+                INITBITS();
+                Tracev((stderr, "inflate:   check matches trailer\n"));
+            }
+#ifdef GUNZIP
+            state->mode = LENGTH;
+        case LENGTH:
+            if (state->wrap && state->flags) {
+                NEEDBITS(32);
+                if (hold != (state->total & 0xffffffffUL)) {
+                    strm->msg = (char *)"incorrect length check";
+                    state->mode = BAD;
+                    break;
+                }
+                INITBITS();
+                Tracev((stderr, "inflate:   length matches trailer\n"));
+            }
+#endif
+            state->mode = DONE;
+        case DONE:
+            ret = Z_STREAM_END;
+            goto inf_leave;
+        case BAD:
+            ret = Z_DATA_ERROR;
+            goto inf_leave;
+        case MEM:
+            return Z_MEM_ERROR;
+        case SYNC:
+        default:
+            return Z_STREAM_ERROR;
+        }
+
+    /*
+       Return from inflate(), updating the total counts and the check value.
+       If there was no progress during the inflate() call, return a buffer
+       error.  Call updatewindow() to create and/or update the window state.
+       Note: a memory error from inflate() is non-recoverable.
+     */
+  inf_leave:
+    RESTORE();
+    if (state->wsize || (out != strm->avail_out && state->mode < BAD &&
+            (state->mode < CHECK || flush != Z_FINISH)))
+        if (updatewindow(strm, strm->next_out, out - strm->avail_out)) {
+            state->mode = MEM;
+            return Z_MEM_ERROR;
+        }
+    in -= strm->avail_in;
+    out -= strm->avail_out;
+    strm->total_in += in;
+    strm->total_out += out;
+    state->total += out;
+    if ((state->wrap & 4) && out)
+        strm->adler = state->check =
+            UPDATE(state->check, strm->next_out - out, out);
+    strm->data_type = (int)state->bits + (state->last ? 64 : 0) +
+                      (state->mode == TYPE ? 128 : 0) +
+                      (state->mode == LEN_ || state->mode == COPY_ ? 256 : 0);
+    if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
+        ret = Z_BUF_ERROR;
+    return ret;
+}
+
+int ZEXPORT inflateEnd(strm)
+z_streamp strm;
+{
+    struct inflate_state FAR *state;
+    if (inflateStateCheck(strm))
+        return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    if (state->window != Z_NULL) ZFREE(strm, state->window);
+    ZFREE(strm, strm->state);
+    strm->state = Z_NULL;
+    Tracev((stderr, "inflate: end\n"));
+    return Z_OK;
+}
+
+int ZEXPORT inflateGetDictionary(strm, dictionary, dictLength)
+z_streamp strm;
+Bytef *dictionary;
+uInt *dictLength;
+{
+    struct inflate_state FAR *state;
+
+    /* check state */
+    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+
+    /* copy dictionary */
+    if (state->whave && dictionary != Z_NULL) {
+        zmemcpy(dictionary, state->window + state->wnext,
+                state->whave - state->wnext);
+        zmemcpy(dictionary + state->whave - state->wnext,
+                state->window, state->wnext);
+    }
+    if (dictLength != Z_NULL)
+        *dictLength = state->whave;
+    return Z_OK;
+}
+
+int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength)
+z_streamp strm;
+const Bytef *dictionary;
+uInt dictLength;
+{
+    struct inflate_state FAR *state;
+    unsigned long dictid;
+    int ret;
+
+    /* check state */
+    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    if (state->wrap != 0 && state->mode != DICT)
+        return Z_STREAM_ERROR;
+
+    /* check for correct dictionary identifier */
+    if (state->mode == DICT) {
+        dictid = adler32(0L, Z_NULL, 0);
+        dictid = adler32(dictid, dictionary, dictLength);
+        if (dictid != state->check)
+            return Z_DATA_ERROR;
+    }
+
+    /* copy dictionary to window using updatewindow(), which will amend the
+       existing dictionary if appropriate */
+    ret = updatewindow(strm, dictionary + dictLength, dictLength);
+    if (ret) {
+        state->mode = MEM;
+        return Z_MEM_ERROR;
+    }
+    state->havedict = 1;
+    Tracev((stderr, "inflate:   dictionary set\n"));
+    return Z_OK;
+}
+
+int ZEXPORT inflateGetHeader(strm, head)
+z_streamp strm;
+gz_headerp head;
+{
+    struct inflate_state FAR *state;
+
+    /* check state */
+    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;
+
+    /* save header structure */
+    state->head = head;
+    head->done = 0;
+    return Z_OK;
+}
+
+/*
+   Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff.  Return when found
+   or when out of input.  When called, *have is the number of pattern bytes
+   found in order so far, in 0..3.  On return *have is updated to the new
+   state.  If on return *have equals four, then the pattern was found and the
+   return value is how many bytes were read including the last byte of the
+   pattern.  If *have is less than four, then the pattern has not been found
+   yet and the return value is len.  In the latter case, syncsearch() can be
+   called again with more data and the *have state.  *have is initialized to
+   zero for the first call.
+ */
+local unsigned syncsearch(have, buf, len)
+unsigned FAR *have;
+const unsigned char FAR *buf;
+unsigned len;
+{
+    unsigned got;
+    unsigned next;
+
+    got = *have;
+    next = 0;
+    while (next < len && got < 4) {
+        if ((int)(buf[next]) == (got < 2 ? 0 : 0xff))
+            got++;
+        else if (buf[next])
+            got = 0;
+        else
+            got = 4 - got;
+        next++;
+    }
+    *have = got;
+    return next;
+}
+
+int ZEXPORT inflateSync(strm)
+z_streamp strm;
+{
+    unsigned len;               /* number of bytes to look at or looked at */
+    unsigned long in, out;      /* temporary to save total_in and total_out */
+    unsigned char buf[4];       /* to restore bit buffer to byte string */
+    struct inflate_state FAR *state;
+
+    /* check parameters */
+    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;
+
+    /* if first time, start search in bit buffer */
+    if (state->mode != SYNC) {
+        state->mode = SYNC;
+        state->hold <<= state->bits & 7;
+        state->bits -= state->bits & 7;
+        len = 0;
+        while (state->bits >= 8) {
+            buf[len++] = (unsigned char)(state->hold);
+            state->hold >>= 8;
+            state->bits -= 8;
+        }
+        state->have = 0;
+        syncsearch(&(state->have), buf, len);
+    }
+
+    /* search available input */
+    len = syncsearch(&(state->have), strm->next_in, strm->avail_in);
+    strm->avail_in -= len;
+    strm->next_in += len;
+    strm->total_in += len;
+
+    /* return no joy or set up to restart inflate() on a new block */
+    if (state->have != 4) return Z_DATA_ERROR;
+    if (state->mode == HEAD)
+        state->wrap = 0;    /* never processed header, so assume raw */
+    in = strm->total_in;  out = strm->total_out;
+    inflateReset(strm);
+    strm->total_in = in;  strm->total_out = out;
+    state->mode = TYPE;
+    return Z_OK;
+}
+
+/*
+   Returns true if inflate is currently at the end of a block generated by
+   Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
+   implementation to provide an additional safety check. PPP uses
+   Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored
+   block. When decompressing, PPP checks that at the end of input packet,
+   inflate is waiting for these length bytes.
+ */
+int ZEXPORT inflateSyncPoint(strm)
+z_streamp strm;
+{
+    struct inflate_state FAR *state;
+
+    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    return state->mode == STORED && state->bits == 0;
+}
+
+int ZEXPORT inflateCopy(dest, source)
+z_streamp dest;
+z_streamp source;
+{
+    struct inflate_state FAR *state;
+    struct inflate_state FAR *copy;
+    unsigned char FAR *window;
+    unsigned wsize;
+
+    /* check input */
+    if (inflateStateCheck(source) || dest == Z_NULL)
+        return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)source->state;
+
+    /* allocate space */
+    copy = (struct inflate_state FAR *)
+           ZALLOC(source, 1, sizeof(struct inflate_state));
+    if (copy == Z_NULL) return Z_MEM_ERROR;
+    window = Z_NULL;
+    if (state->window != Z_NULL) {
+        window = (unsigned char FAR *)
+                 ZALLOC(source, 1U << state->wbits, sizeof(unsigned char));
+        if (window == Z_NULL) {
+            ZFREE(source, copy);
+            return Z_MEM_ERROR;
+        }
+    }
+
+    /* copy state */
+    zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream));
+    zmemcpy((voidpf)copy, (voidpf)state, sizeof(struct inflate_state));
+    copy->strm = dest;
+    if (state->lencode >= state->codes &&
+        state->lencode <= state->codes + ENOUGH - 1) {
+        copy->lencode = copy->codes + (state->lencode - state->codes);
+        copy->distcode = copy->codes + (state->distcode - state->codes);
+    }
+    copy->next = copy->codes + (state->next - state->codes);
+    if (window != Z_NULL) {
+        wsize = 1U << state->wbits;
+        zmemcpy(window, state->window, wsize);
+    }
+    copy->window = window;
+    dest->state = (struct internal_state FAR *)copy;
+    return Z_OK;
+}
+
+int ZEXPORT inflateUndermine(strm, subvert)
+z_streamp strm;
+int subvert;
+{
+    struct inflate_state FAR *state;
+
+    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
+    state->sane = !subvert;
+    return Z_OK;
+#else
+    (void)subvert;
+    state->sane = 1;
+    return Z_DATA_ERROR;
+#endif
+}
+
+int ZEXPORT inflateValidate(strm, check)
+z_streamp strm;
+int check;
+{
+    struct inflate_state FAR *state;
+
+    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    if (check && state->wrap)
+        state->wrap |= 4;
+    else
+        state->wrap &= ~4;
+    return Z_OK;
+}
+
+long ZEXPORT inflateMark(strm)
+z_streamp strm;
+{
+    struct inflate_state FAR *state;
+
+    if (inflateStateCheck(strm))
+        return -(1L << 16);
+    state = (struct inflate_state FAR *)strm->state;
+    return (long)(((unsigned long)((long)state->back)) << 16) +
+        (state->mode == COPY ? state->length :
+            (state->mode == MATCH ? state->was - state->length : 0));
+}
+
+unsigned long ZEXPORT inflateCodesUsed(strm)
+z_streamp strm;
+{
+    struct inflate_state FAR *state;
+    if (inflateStateCheck(strm)) return (unsigned long)-1;
+    state = (struct inflate_state FAR *)strm->state;
+    return (unsigned long)(state->next - state->codes);
+}
diff --git a/Engine/lib/assimp/contrib/zlib/inflate.h b/Engine/lib/assimp/contrib/zlib/inflate.h
new file mode 100644
index 000000000..a46cce6b6
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/inflate.h
@@ -0,0 +1,125 @@
+/* inflate.h -- internal inflate state definition
+ * Copyright (C) 1995-2016 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* define NO_GZIP when compiling if you want to disable gzip header and
+   trailer decoding by inflate().  NO_GZIP would be used to avoid linking in
+   the crc code when it is not needed.  For shared libraries, gzip decoding
+   should be left enabled. */
+#ifndef NO_GZIP
+#  define GUNZIP
+#endif
+
+/* Possible inflate modes between inflate() calls */
+typedef enum {
+    HEAD = 16180,   /* i: waiting for magic header */
+    FLAGS,      /* i: waiting for method and flags (gzip) */
+    TIME,       /* i: waiting for modification time (gzip) */
+    OS,         /* i: waiting for extra flags and operating system (gzip) */
+    EXLEN,      /* i: waiting for extra length (gzip) */
+    EXTRA,      /* i: waiting for extra bytes (gzip) */
+    NAME,       /* i: waiting for end of file name (gzip) */
+    COMMENT,    /* i: waiting for end of comment (gzip) */
+    HCRC,       /* i: waiting for header crc (gzip) */
+    DICTID,     /* i: waiting for dictionary check value */
+    DICT,       /* waiting for inflateSetDictionary() call */
+        TYPE,       /* i: waiting for type bits, including last-flag bit */
+        TYPEDO,     /* i: same, but skip check to exit inflate on new block */
+        STORED,     /* i: waiting for stored size (length and complement) */
+        COPY_,      /* i/o: same as COPY below, but only first time in */
+        COPY,       /* i/o: waiting for input or output to copy stored block */
+        TABLE,      /* i: waiting for dynamic block table lengths */
+        LENLENS,    /* i: waiting for code length code lengths */
+        CODELENS,   /* i: waiting for length/lit and distance code lengths */
+            LEN_,       /* i: same as LEN below, but only first time in */
+            LEN,        /* i: waiting for length/lit/eob code */
+            LENEXT,     /* i: waiting for length extra bits */
+            DIST,       /* i: waiting for distance code */
+            DISTEXT,    /* i: waiting for distance extra bits */
+            MATCH,      /* o: waiting for output space to copy string */
+            LIT,        /* o: waiting for output space to write literal */
+    CHECK,      /* i: waiting for 32-bit check value */
+    LENGTH,     /* i: waiting for 32-bit length (gzip) */
+    DONE,       /* finished check, done -- remain here until reset */
+    BAD,        /* got a data error -- remain here until reset */
+    MEM,        /* got an inflate() memory error -- remain here until reset */
+    SYNC        /* looking for synchronization bytes to restart inflate() */
+} inflate_mode;
+
+/*
+    State transitions between above modes -
+
+    (most modes can go to BAD or MEM on error -- not shown for clarity)
+
+    Process header:
+        HEAD -> (gzip) or (zlib) or (raw)
+        (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME -> COMMENT ->
+                  HCRC -> TYPE
+        (zlib) -> DICTID or TYPE
+        DICTID -> DICT -> TYPE
+        (raw) -> TYPEDO
+    Read deflate blocks:
+            TYPE -> TYPEDO -> STORED or TABLE or LEN_ or CHECK
+            STORED -> COPY_ -> COPY -> TYPE
+            TABLE -> LENLENS -> CODELENS -> LEN_
+            LEN_ -> LEN
+    Read deflate codes in fixed or dynamic block:
+                LEN -> LENEXT or LIT or TYPE
+                LENEXT -> DIST -> DISTEXT -> MATCH -> LEN
+                LIT -> LEN
+    Process trailer:
+        CHECK -> LENGTH -> DONE
+ */
+
+/* State maintained between inflate() calls -- approximately 7K bytes, not
+   including the allocated sliding window, which is up to 32K bytes. */
+struct inflate_state {
+    z_streamp strm;             /* pointer back to this zlib stream */
+    inflate_mode mode;          /* current inflate mode */
+    int last;                   /* true if processing last block */
+    int wrap;                   /* bit 0 true for zlib, bit 1 true for gzip,
+                                   bit 2 true to validate check value */
+    int havedict;               /* true if dictionary provided */
+    int flags;                  /* gzip header method and flags (0 if zlib) */
+    unsigned dmax;              /* zlib header max distance (INFLATE_STRICT) */
+    unsigned long check;        /* protected copy of check value */
+    unsigned long total;        /* protected copy of output count */
+    gz_headerp head;            /* where to save gzip header information */
+        /* sliding window */
+    unsigned wbits;             /* log base 2 of requested window size */
+    unsigned wsize;             /* window size or zero if not using window */
+    unsigned whave;             /* valid bytes in the window */
+    unsigned wnext;             /* window write index */
+    unsigned char FAR *window;  /* allocated sliding window, if needed */
+        /* bit accumulator */
+    unsigned long hold;         /* input bit accumulator */
+    unsigned bits;              /* number of bits in "in" */
+        /* for string and stored block copying */
+    unsigned length;            /* literal or length of data to copy */
+    unsigned offset;            /* distance back to copy string from */
+        /* for table and code decoding */
+    unsigned extra;             /* extra bits needed */
+        /* fixed and dynamic code tables */
+    code const FAR *lencode;    /* starting table for length/literal codes */
+    code const FAR *distcode;   /* starting table for distance codes */
+    unsigned lenbits;           /* index bits for lencode */
+    unsigned distbits;          /* index bits for distcode */
+        /* dynamic table building */
+    unsigned ncode;             /* number of code length code lengths */
+    unsigned nlen;              /* number of length code lengths */
+    unsigned ndist;             /* number of distance code lengths */
+    unsigned have;              /* number of code lengths in lens[] */
+    code FAR *next;             /* next available space in codes[] */
+    unsigned short lens[320];   /* temporary storage for code lengths */
+    unsigned short work[288];   /* work area for code table building */
+    code codes[ENOUGH];         /* space for code tables */
+    int sane;                   /* if false, allow invalid distance too far */
+    int back;                   /* bits back of last unprocessed length/lit */
+    unsigned was;               /* initial length of match */
+};
diff --git a/Engine/lib/assimp/contrib/zlib/inftrees.c b/Engine/lib/assimp/contrib/zlib/inftrees.c
new file mode 100644
index 000000000..716c98842
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/inftrees.c
@@ -0,0 +1,304 @@
+/* inftrees.c -- generate Huffman trees for efficient decoding
+ * Copyright (C) 1995-2017 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+
+#define MAXBITS 15
+
+const char inflate_copyright[] =
+   " inflate 1.2.11.1 Copyright 1995-2017 Mark Adler ";
+/*
+  If you use the zlib library in a product, an acknowledgment is welcome
+  in the documentation of your product. If for some reason you cannot
+  include such an acknowledgment, I would appreciate that you keep this
+  copyright string in the executable of your product.
+ */
+
+/*
+   Build a set of tables to decode the provided canonical Huffman code.
+   The code lengths are lens[0..codes-1].  The result starts at *table,
+   whose indices are 0..2^bits-1.  work is a writable array of at least
+   lens shorts, which is used as a work area.  type is the type of code
+   to be generated, CODES, LENS, or DISTS.  On return, zero is success,
+   -1 is an invalid code, and +1 means that ENOUGH isn't enough.  table
+   on return points to the next available entry's address.  bits is the
+   requested root table index bits, and on return it is the actual root
+   table index bits.  It will differ if the request is greater than the
+   longest code or if it is less than the shortest code.
+ */
+int ZLIB_INTERNAL inflate_table(type, lens, codes, table, bits, work)
+codetype type;
+unsigned short FAR *lens;
+unsigned codes;
+code FAR * FAR *table;
+unsigned FAR *bits;
+unsigned short FAR *work;
+{
+    unsigned len;               /* a code's length in bits */
+    unsigned sym;               /* index of code symbols */
+    unsigned min, max;          /* minimum and maximum code lengths */
+    unsigned root;              /* number of index bits for root table */
+    unsigned curr;              /* number of index bits for current table */
+    unsigned drop;              /* code bits to drop for sub-table */
+    int left;                   /* number of prefix codes available */
+    unsigned used;              /* code entries in table used */
+    unsigned huff;              /* Huffman code */
+    unsigned incr;              /* for incrementing code, index */
+    unsigned fill;              /* index for replicating entries */
+    unsigned low;               /* low bits for current root entry */
+    unsigned mask;              /* mask for low root bits */
+    code here;                  /* table entry for duplication */
+    code FAR *next;             /* next available space in table */
+    const unsigned short FAR *base;     /* base value table to use */
+    const unsigned short FAR *extra;    /* extra bits table to use */
+    unsigned match;             /* use base and extra for symbol >= match */
+    unsigned short count[MAXBITS+1];    /* number of codes of each length */
+    unsigned short offs[MAXBITS+1];     /* offsets in table for each length */
+    static const unsigned short lbase[31] = { /* Length codes 257..285 base */
+        3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
+        35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
+    static const unsigned short lext[31] = { /* Length codes 257..285 extra */
+        16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
+        19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 198, 196};
+    static const unsigned short dbase[32] = { /* Distance codes 0..29 base */
+        1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
+        257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
+        8193, 12289, 16385, 24577, 0, 0};
+    static const unsigned short dext[32] = { /* Distance codes 0..29 extra */
+        16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
+        23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
+        28, 28, 29, 29, 64, 64};
+
+    /*
+       Process a set of code lengths to create a canonical Huffman code.  The
+       code lengths are lens[0..codes-1].  Each length corresponds to the
+       symbols 0..codes-1.  The Huffman code is generated by first sorting the
+       symbols by length from short to long, and retaining the symbol order
+       for codes with equal lengths.  Then the code starts with all zero bits
+       for the first code of the shortest length, and the codes are integer
+       increments for the same length, and zeros are appended as the length
+       increases.  For the deflate format, these bits are stored backwards
+       from their more natural integer increment ordering, and so when the
+       decoding tables are built in the large loop below, the integer codes
+       are incremented backwards.
+
+       This routine assumes, but does not check, that all of the entries in
+       lens[] are in the range 0..MAXBITS.  The caller must assure this.
+       1..MAXBITS is interpreted as that code length.  zero means that that
+       symbol does not occur in this code.
+
+       The codes are sorted by computing a count of codes for each length,
+       creating from that a table of starting indices for each length in the
+       sorted table, and then entering the symbols in order in the sorted
+       table.  The sorted table is work[], with that space being provided by
+       the caller.
+
+       The length counts are used for other purposes as well, i.e. finding
+       the minimum and maximum length codes, determining if there are any
+       codes at all, checking for a valid set of lengths, and looking ahead
+       at length counts to determine sub-table sizes when building the
+       decoding tables.
+     */
+
+    /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
+    for (len = 0; len <= MAXBITS; len++)
+        count[len] = 0;
+    for (sym = 0; sym < codes; sym++)
+        count[lens[sym]]++;
+
+    /* bound code lengths, force root to be within code lengths */
+    root = *bits;
+    for (max = MAXBITS; max >= 1; max--)
+        if (count[max] != 0) break;
+    if (root > max) root = max;
+    if (max == 0) {                     /* no symbols to code at all */
+        here.op = (unsigned char)64;    /* invalid code marker */
+        here.bits = (unsigned char)1;
+        here.val = (unsigned short)0;
+        *(*table)++ = here;             /* make a table to force an error */
+        *(*table)++ = here;
+        *bits = 1;
+        return 0;     /* no symbols, but wait for decoding to report error */
+    }
+    for (min = 1; min < max; min++)
+        if (count[min] != 0) break;
+    if (root < min) root = min;
+
+    /* check for an over-subscribed or incomplete set of lengths */
+    left = 1;
+    for (len = 1; len <= MAXBITS; len++) {
+        left <<= 1;
+        left -= count[len];
+        if (left < 0) return -1;        /* over-subscribed */
+    }
+    if (left > 0 && (type == CODES || max != 1))
+        return -1;                      /* incomplete set */
+
+    /* generate offsets into symbol table for each length for sorting */
+    offs[1] = 0;
+    for (len = 1; len < MAXBITS; len++)
+        offs[len + 1] = offs[len] + count[len];
+
+    /* sort symbols by length, by symbol order within each length */
+    for (sym = 0; sym < codes; sym++)
+        if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym;
+
+    /*
+       Create and fill in decoding tables.  In this loop, the table being
+       filled is at next and has curr index bits.  The code being used is huff
+       with length len.  That code is converted to an index by dropping drop
+       bits off of the bottom.  For codes where len is less than drop + curr,
+       those top drop + curr - len bits are incremented through all values to
+       fill the table with replicated entries.
+
+       root is the number of index bits for the root table.  When len exceeds
+       root, sub-tables are created pointed to by the root entry with an index
+       of the low root bits of huff.  This is saved in low to check for when a
+       new sub-table should be started.  drop is zero when the root table is
+       being filled, and drop is root when sub-tables are being filled.
+
+       When a new sub-table is needed, it is necessary to look ahead in the
+       code lengths to determine what size sub-table is needed.  The length
+       counts are used for this, and so count[] is decremented as codes are
+       entered in the tables.
+
+       used keeps track of how many table entries have been allocated from the
+       provided *table space.  It is checked for LENS and DIST tables against
+       the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in
+       the initial root table size constants.  See the comments in inftrees.h
+       for more information.
+
+       sym increments through all symbols, and the loop terminates when
+       all codes of length max, i.e. all codes, have been processed.  This
+       routine permits incomplete codes, so another loop after this one fills
+       in the rest of the decoding tables with invalid code markers.
+     */
+
+    /* set up for code type */
+    switch (type) {
+    case CODES:
+        base = extra = work;    /* dummy value--not used */
+        match = 20;
+        break;
+    case LENS:
+        base = lbase;
+        extra = lext;
+        match = 257;
+        break;
+    default:    /* DISTS */
+        base = dbase;
+        extra = dext;
+        match = 0;
+    }
+
+    /* initialize state for loop */
+    huff = 0;                   /* starting code */
+    sym = 0;                    /* starting code symbol */
+    len = min;                  /* starting code length */
+    next = *table;              /* current table to fill in */
+    curr = root;                /* current table index bits */
+    drop = 0;                   /* current bits to drop from code for index */
+    low = (unsigned)(-1);       /* trigger new sub-table when len > root */
+    used = 1U << root;          /* use root table entries */
+    mask = used - 1;            /* mask for comparing low */
+
+    /* check available table space */
+    if ((type == LENS && used > ENOUGH_LENS) ||
+        (type == DISTS && used > ENOUGH_DISTS))
+        return 1;
+
+    /* process all codes and make table entries */
+    for (;;) {
+        /* create table entry */
+        here.bits = (unsigned char)(len - drop);
+        if (work[sym] + 1U < match) {
+            here.op = (unsigned char)0;
+            here.val = work[sym];
+        }
+        else if (work[sym] >= match) {
+            here.op = (unsigned char)(extra[work[sym] - match]);
+            here.val = base[work[sym] - match];
+        }
+        else {
+            here.op = (unsigned char)(32 + 64);         /* end of block */
+            here.val = 0;
+        }
+
+        /* replicate for those indices with low len bits equal to huff */
+        incr = 1U << (len - drop);
+        fill = 1U << curr;
+        min = fill;                 /* save offset to next table */
+        do {
+            fill -= incr;
+            next[(huff >> drop) + fill] = here;
+        } while (fill != 0);
+
+        /* backwards increment the len-bit code huff */
+        incr = 1U << (len - 1);
+        while (huff & incr)
+            incr >>= 1;
+        if (incr != 0) {
+            huff &= incr - 1;
+            huff += incr;
+        }
+        else
+            huff = 0;
+
+        /* go to next symbol, update count, len */
+        sym++;
+        if (--(count[len]) == 0) {
+            if (len == max) break;
+            len = lens[work[sym]];
+        }
+
+        /* create new sub-table if needed */
+        if (len > root && (huff & mask) != low) {
+            /* if first time, transition to sub-tables */
+            if (drop == 0)
+                drop = root;
+
+            /* increment past last table */
+            next += min;            /* here min is 1 << curr */
+
+            /* determine length of next table */
+            curr = len - drop;
+            left = (int)(1 << curr);
+            while (curr + drop < max) {
+                left -= count[curr + drop];
+                if (left <= 0) break;
+                curr++;
+                left <<= 1;
+            }
+
+            /* check for enough space */
+            used += 1U << curr;
+            if ((type == LENS && used > ENOUGH_LENS) ||
+                (type == DISTS && used > ENOUGH_DISTS))
+                return 1;
+
+            /* point entry in root table to sub-table */
+            low = huff & mask;
+            (*table)[low].op = (unsigned char)curr;
+            (*table)[low].bits = (unsigned char)root;
+            (*table)[low].val = (unsigned short)(next - *table);
+        }
+    }
+
+    /* fill in remaining table entry if code is incomplete (guaranteed to have
+       at most one remaining entry, since if the code is incomplete, the
+       maximum code length that was allowed to get this far is one bit) */
+    if (huff != 0) {
+        here.op = (unsigned char)64;            /* invalid code marker */
+        here.bits = (unsigned char)(len - drop);
+        here.val = (unsigned short)0;
+        next[huff] = here;
+    }
+
+    /* set return parameters */
+    *table += used;
+    *bits = root;
+    return 0;
+}
diff --git a/Engine/lib/assimp/contrib/zlib/inftrees.h b/Engine/lib/assimp/contrib/zlib/inftrees.h
new file mode 100644
index 000000000..baa53a0b1
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/inftrees.h
@@ -0,0 +1,62 @@
+/* inftrees.h -- header to use inftrees.c
+ * Copyright (C) 1995-2005, 2010 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* Structure for decoding tables.  Each entry provides either the
+   information needed to do the operation requested by the code that
+   indexed that table entry, or it provides a pointer to another
+   table that indexes more bits of the code.  op indicates whether
+   the entry is a pointer to another table, a literal, a length or
+   distance, an end-of-block, or an invalid code.  For a table
+   pointer, the low four bits of op is the number of index bits of
+   that table.  For a length or distance, the low four bits of op
+   is the number of extra bits to get after the code.  bits is
+   the number of bits in this code or part of the code to drop off
+   of the bit buffer.  val is the actual byte to output in the case
+   of a literal, the base length or distance, or the offset from
+   the current table to the next table.  Each entry is four bytes. */
+typedef struct {
+    unsigned char op;           /* operation, extra bits, table bits */
+    unsigned char bits;         /* bits in this part of the code */
+    unsigned short val;         /* offset in table or code value */
+} code;
+
+/* op values as set by inflate_table():
+    00000000 - literal
+    0000tttt - table link, tttt != 0 is the number of table index bits
+    0001eeee - length or distance, eeee is the number of extra bits
+    01100000 - end of block
+    01000000 - invalid code
+ */
+
+/* Maximum size of the dynamic table.  The maximum number of code structures is
+   1444, which is the sum of 852 for literal/length codes and 592 for distance
+   codes.  These values were found by exhaustive searches using the program
+   examples/enough.c found in the zlib distribtution.  The arguments to that
+   program are the number of symbols, the initial root table size, and the
+   maximum bit length of a code.  "enough 286 9 15" for literal/length codes
+   returns returns 852, and "enough 30 6 15" for distance codes returns 592.
+   The initial root table size (9 or 6) is found in the fifth argument of the
+   inflate_table() calls in inflate.c and infback.c.  If the root table size is
+   changed, then these maximum sizes would be need to be recalculated and
+   updated. */
+#define ENOUGH_LENS 852
+#define ENOUGH_DISTS 592
+#define ENOUGH (ENOUGH_LENS+ENOUGH_DISTS)
+
+/* Type of code to build for inflate_table() */
+typedef enum {
+    CODES,
+    LENS,
+    DISTS
+} codetype;
+
+int ZLIB_INTERNAL inflate_table OF((codetype type, unsigned short FAR *lens,
+                             unsigned codes, code FAR * FAR *table,
+                             unsigned FAR *bits, unsigned short FAR *work));
diff --git a/Engine/lib/assimp/contrib/zlib/trees.c b/Engine/lib/assimp/contrib/zlib/trees.c
new file mode 100644
index 000000000..50cf4b457
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/trees.c
@@ -0,0 +1,1203 @@
+/* trees.c -- output deflated data using Huffman coding
+ * Copyright (C) 1995-2017 Jean-loup Gailly
+ * detect_data_type() function provided freely by Cosmin Truta, 2006
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/*
+ *  ALGORITHM
+ *
+ *      The "deflation" process uses several Huffman trees. The more
+ *      common source values are represented by shorter bit sequences.
+ *
+ *      Each code tree is stored in a compressed form which is itself
+ * a Huffman encoding of the lengths of all the code strings (in
+ * ascending order by source values).  The actual code strings are
+ * reconstructed from the lengths in the inflate process, as described
+ * in the deflate specification.
+ *
+ *  REFERENCES
+ *
+ *      Deutsch, L.P.,"'Deflate' Compressed Data Format Specification".
+ *      Available in ftp.uu.net:/pub/archiving/zip/doc/deflate-1.1.doc
+ *
+ *      Storer, James A.
+ *          Data Compression:  Methods and Theory, pp. 49-50.
+ *          Computer Science Press, 1988.  ISBN 0-7167-8156-5.
+ *
+ *      Sedgewick, R.
+ *          Algorithms, p290.
+ *          Addison-Wesley, 1983. ISBN 0-201-06672-6.
+ */
+
+/* @(#) $Id$ */
+
+/* #define GEN_TREES_H */
+
+#include "deflate.h"
+
+#ifdef ZLIB_DEBUG
+#  include <ctype.h>
+#endif
+
+/* ===========================================================================
+ * Constants
+ */
+
+#define MAX_BL_BITS 7
+/* Bit length codes must not exceed MAX_BL_BITS bits */
+
+#define END_BLOCK 256
+/* end of block literal code */
+
+#define REP_3_6      16
+/* repeat previous bit length 3-6 times (2 bits of repeat count) */
+
+#define REPZ_3_10    17
+/* repeat a zero length 3-10 times  (3 bits of repeat count) */
+
+#define REPZ_11_138  18
+/* repeat a zero length 11-138 times  (7 bits of repeat count) */
+
+local const int extra_lbits[LENGTH_CODES] /* extra bits for each length code */
+   = {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0};
+
+local const int extra_dbits[D_CODES] /* extra bits for each distance code */
+   = {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
+
+local const int extra_blbits[BL_CODES]/* extra bits for each bit length code */
+   = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7};
+
+local const uch bl_order[BL_CODES]
+   = {16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15};
+/* The lengths of the bit length codes are sent in order of decreasing
+ * probability, to avoid transmitting the lengths for unused bit length codes.
+ */
+
+/* ===========================================================================
+ * Local data. These are initialized only once.
+ */
+
+#define DIST_CODE_LEN  512 /* see definition of array dist_code below */
+
+#if defined(GEN_TREES_H) || !defined(STDC)
+/* non ANSI compilers may not accept trees.h */
+
+local ct_data static_ltree[L_CODES+2];
+/* The static literal tree. Since the bit lengths are imposed, there is no
+ * need for the L_CODES extra codes used during heap construction. However
+ * The codes 286 and 287 are needed to build a canonical tree (see _tr_init
+ * below).
+ */
+
+local ct_data static_dtree[D_CODES];
+/* The static distance tree. (Actually a trivial tree since all codes use
+ * 5 bits.)
+ */
+
+uch _dist_code[DIST_CODE_LEN];
+/* Distance codes. The first 256 values correspond to the distances
+ * 3 .. 258, the last 256 values correspond to the top 8 bits of
+ * the 15 bit distances.
+ */
+
+uch _length_code[MAX_MATCH-MIN_MATCH+1];
+/* length code for each normalized match length (0 == MIN_MATCH) */
+
+local int base_length[LENGTH_CODES];
+/* First normalized length for each code (0 = MIN_MATCH) */
+
+local int base_dist[D_CODES];
+/* First normalized distance for each code (0 = distance of 1) */
+
+#else
+#  include "trees.h"
+#endif /* GEN_TREES_H */
+
+struct static_tree_desc_s {
+    const ct_data *static_tree;  /* static tree or NULL */
+    const intf *extra_bits;      /* extra bits for each code or NULL */
+    int     extra_base;          /* base index for extra_bits */
+    int     elems;               /* max number of elements in the tree */
+    int     max_length;          /* max bit length for the codes */
+};
+
+local const static_tree_desc  static_l_desc =
+{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS};
+
+local const static_tree_desc  static_d_desc =
+{static_dtree, extra_dbits, 0,          D_CODES, MAX_BITS};
+
+local const static_tree_desc  static_bl_desc =
+{(const ct_data *)0, extra_blbits, 0,   BL_CODES, MAX_BL_BITS};
+
+/* ===========================================================================
+ * Local (static) routines in this file.
+ */
+
+local void tr_static_init OF((void));
+local void init_block     OF((deflate_state *s));
+local void pqdownheap     OF((deflate_state *s, ct_data *tree, int k));
+local void gen_bitlen     OF((deflate_state *s, tree_desc *desc));
+local void gen_codes      OF((ct_data *tree, int max_code, ushf *bl_count));
+local void build_tree     OF((deflate_state *s, tree_desc *desc));
+local void scan_tree      OF((deflate_state *s, ct_data *tree, int max_code));
+local void send_tree      OF((deflate_state *s, ct_data *tree, int max_code));
+local int  build_bl_tree  OF((deflate_state *s));
+local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes,
+                              int blcodes));
+local void compress_block OF((deflate_state *s, const ct_data *ltree,
+                              const ct_data *dtree));
+local int  detect_data_type OF((deflate_state *s));
+local unsigned bi_reverse OF((unsigned value, int length));
+local void bi_windup      OF((deflate_state *s));
+local void bi_flush       OF((deflate_state *s));
+
+#ifdef GEN_TREES_H
+local void gen_trees_header OF((void));
+#endif
+
+#ifndef ZLIB_DEBUG
+#  define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len)
+   /* Send a code of the given tree. c and tree must not have side effects */
+
+#else /* !ZLIB_DEBUG */
+#  define send_code(s, c, tree) \
+     { if (z_verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \
+       send_bits(s, tree[c].Code, tree[c].Len); }
+#endif
+
+/* ===========================================================================
+ * Output a short LSB first on the stream.
+ * IN assertion: there is enough room in pendingBuf.
+ */
+#define put_short(s, w) { \
+    put_byte(s, (uch)((w) & 0xff)); \
+    put_byte(s, (uch)((ush)(w) >> 8)); \
+}
+
+/* ===========================================================================
+ * Send a value on a given number of bits.
+ * IN assertion: length <= 16 and value fits in length bits.
+ */
+#ifdef ZLIB_DEBUG
+local void send_bits      OF((deflate_state *s, int value, int length));
+
+local void send_bits(s, value, length)
+    deflate_state *s;
+    int value;  /* value to send */
+    int length; /* number of bits */
+{
+    Tracevv((stderr," l %2d v %4x ", length, value));
+    Assert(length > 0 && length <= 15, "invalid length");
+    s->bits_sent += (ulg)length;
+
+    /* If not enough room in bi_buf, use (valid) bits from bi_buf and
+     * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid))
+     * unused bits in value.
+     */
+    if (s->bi_valid > (int)Buf_size - length) {
+        s->bi_buf |= (ush)value << s->bi_valid;
+        put_short(s, s->bi_buf);
+        s->bi_buf = (ush)value >> (Buf_size - s->bi_valid);
+        s->bi_valid += length - Buf_size;
+    } else {
+        s->bi_buf |= (ush)value << s->bi_valid;
+        s->bi_valid += length;
+    }
+}
+#else /* !ZLIB_DEBUG */
+
+#define send_bits(s, value, length) \
+{ int len = length;\
+  if (s->bi_valid > (int)Buf_size - len) {\
+    int val = (int)value;\
+    s->bi_buf |= (ush)val << s->bi_valid;\
+    put_short(s, s->bi_buf);\
+    s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\
+    s->bi_valid += len - Buf_size;\
+  } else {\
+    s->bi_buf |= (ush)(value) << s->bi_valid;\
+    s->bi_valid += len;\
+  }\
+}
+#endif /* ZLIB_DEBUG */
+
+
+/* the arguments must not have side effects */
+
+/* ===========================================================================
+ * Initialize the various 'constant' tables.
+ */
+local void tr_static_init()
+{
+#if defined(GEN_TREES_H) || !defined(STDC)
+    static int static_init_done = 0;
+    int n;        /* iterates over tree elements */
+    int bits;     /* bit counter */
+    int length;   /* length value */
+    int code;     /* code value */
+    int dist;     /* distance index */
+    ush bl_count[MAX_BITS+1];
+    /* number of codes at each bit length for an optimal tree */
+
+    if (static_init_done) return;
+
+    /* For some embedded targets, global variables are not initialized: */
+#ifdef NO_INIT_GLOBAL_POINTERS
+    static_l_desc.static_tree = static_ltree;
+    static_l_desc.extra_bits = extra_lbits;
+    static_d_desc.static_tree = static_dtree;
+    static_d_desc.extra_bits = extra_dbits;
+    static_bl_desc.extra_bits = extra_blbits;
+#endif
+
+    /* Initialize the mapping length (0..255) -> length code (0..28) */
+    length = 0;
+    for (code = 0; code < LENGTH_CODES-1; code++) {
+        base_length[code] = length;
+        for (n = 0; n < (1<<extra_lbits[code]); n++) {
+            _length_code[length++] = (uch)code;
+        }
+    }
+    Assert (length == 256, "tr_static_init: length != 256");
+    /* Note that the length 255 (match length 258) can be represented
+     * in two different ways: code 284 + 5 bits or code 285, so we
+     * overwrite length_code[255] to use the best encoding:
+     */
+    _length_code[length-1] = (uch)code;
+
+    /* Initialize the mapping dist (0..32K) -> dist code (0..29) */
+    dist = 0;
+    for (code = 0 ; code < 16; code++) {
+        base_dist[code] = dist;
+        for (n = 0; n < (1<<extra_dbits[code]); n++) {
+            _dist_code[dist++] = (uch)code;
+        }
+    }
+    Assert (dist == 256, "tr_static_init: dist != 256");
+    dist >>= 7; /* from now on, all distances are divided by 128 */
+    for ( ; code < D_CODES; code++) {
+        base_dist[code] = dist << 7;
+        for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) {
+            _dist_code[256 + dist++] = (uch)code;
+        }
+    }
+    Assert (dist == 256, "tr_static_init: 256+dist != 512");
+
+    /* Construct the codes of the static literal tree */
+    for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0;
+    n = 0;
+    while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++;
+    while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++;
+    while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++;
+    while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++;
+    /* Codes 286 and 287 do not exist, but we must include them in the
+     * tree construction to get a canonical Huffman tree (longest code
+     * all ones)
+     */
+    gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count);
+
+    /* The static distance tree is trivial: */
+    for (n = 0; n < D_CODES; n++) {
+        static_dtree[n].Len = 5;
+        static_dtree[n].Code = bi_reverse((unsigned)n, 5);
+    }
+    static_init_done = 1;
+
+#  ifdef GEN_TREES_H
+    gen_trees_header();
+#  endif
+#endif /* defined(GEN_TREES_H) || !defined(STDC) */
+}
+
+/* ===========================================================================
+ * Genererate the file trees.h describing the static trees.
+ */
+#ifdef GEN_TREES_H
+#  ifndef ZLIB_DEBUG
+#    include <stdio.h>
+#  endif
+
+#  define SEPARATOR(i, last, width) \
+      ((i) == (last)? "\n};\n\n" :    \
+       ((i) % (width) == (width)-1 ? ",\n" : ", "))
+
+void gen_trees_header()
+{
+    FILE *header = fopen("trees.h", "w");
+    int i;
+
+    Assert (header != NULL, "Can't open trees.h");
+    fprintf(header,
+            "/* header created automatically with -DGEN_TREES_H */\n\n");
+
+    fprintf(header, "local const ct_data static_ltree[L_CODES+2] = {\n");
+    for (i = 0; i < L_CODES+2; i++) {
+        fprintf(header, "{{%3u},{%3u}}%s", static_ltree[i].Code,
+                static_ltree[i].Len, SEPARATOR(i, L_CODES+1, 5));
+    }
+
+    fprintf(header, "local const ct_data static_dtree[D_CODES] = {\n");
+    for (i = 0; i < D_CODES; i++) {
+        fprintf(header, "{{%2u},{%2u}}%s", static_dtree[i].Code,
+                static_dtree[i].Len, SEPARATOR(i, D_CODES-1, 5));
+    }
+
+    fprintf(header, "const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = {\n");
+    for (i = 0; i < DIST_CODE_LEN; i++) {
+        fprintf(header, "%2u%s", _dist_code[i],
+                SEPARATOR(i, DIST_CODE_LEN-1, 20));
+    }
+
+    fprintf(header,
+        "const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= {\n");
+    for (i = 0; i < MAX_MATCH-MIN_MATCH+1; i++) {
+        fprintf(header, "%2u%s", _length_code[i],
+                SEPARATOR(i, MAX_MATCH-MIN_MATCH, 20));
+    }
+
+    fprintf(header, "local const int base_length[LENGTH_CODES] = {\n");
+    for (i = 0; i < LENGTH_CODES; i++) {
+        fprintf(header, "%1u%s", base_length[i],
+                SEPARATOR(i, LENGTH_CODES-1, 20));
+    }
+
+    fprintf(header, "local const int base_dist[D_CODES] = {\n");
+    for (i = 0; i < D_CODES; i++) {
+        fprintf(header, "%5u%s", base_dist[i],
+                SEPARATOR(i, D_CODES-1, 10));
+    }
+
+    fclose(header);
+}
+#endif /* GEN_TREES_H */
+
+/* ===========================================================================
+ * Initialize the tree data structures for a new zlib stream.
+ */
+void ZLIB_INTERNAL _tr_init(s)
+    deflate_state *s;
+{
+    tr_static_init();
+
+    s->l_desc.dyn_tree = s->dyn_ltree;
+    s->l_desc.stat_desc = &static_l_desc;
+
+    s->d_desc.dyn_tree = s->dyn_dtree;
+    s->d_desc.stat_desc = &static_d_desc;
+
+    s->bl_desc.dyn_tree = s->bl_tree;
+    s->bl_desc.stat_desc = &static_bl_desc;
+
+    s->bi_buf = 0;
+    s->bi_valid = 0;
+#ifdef ZLIB_DEBUG
+    s->compressed_len = 0L;
+    s->bits_sent = 0L;
+#endif
+
+    /* Initialize the first block of the first file: */
+    init_block(s);
+}
+
+/* ===========================================================================
+ * Initialize a new block.
+ */
+local void init_block(s)
+    deflate_state *s;
+{
+    int n; /* iterates over tree elements */
+
+    /* Initialize the trees. */
+    for (n = 0; n < L_CODES;  n++) s->dyn_ltree[n].Freq = 0;
+    for (n = 0; n < D_CODES;  n++) s->dyn_dtree[n].Freq = 0;
+    for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0;
+
+    s->dyn_ltree[END_BLOCK].Freq = 1;
+    s->opt_len = s->static_len = 0L;
+    s->last_lit = s->matches = 0;
+}
+
+#define SMALLEST 1
+/* Index within the heap array of least frequent node in the Huffman tree */
+
+
+/* ===========================================================================
+ * Remove the smallest element from the heap and recreate the heap with
+ * one less element. Updates heap and heap_len.
+ */
+#define pqremove(s, tree, top) \
+{\
+    top = s->heap[SMALLEST]; \
+    s->heap[SMALLEST] = s->heap[s->heap_len--]; \
+    pqdownheap(s, tree, SMALLEST); \
+}
+
+/* ===========================================================================
+ * Compares to subtrees, using the tree depth as tie breaker when
+ * the subtrees have equal frequency. This minimizes the worst case length.
+ */
+#define smaller(tree, n, m, depth) \
+   (tree[n].Freq < tree[m].Freq || \
+   (tree[n].Freq == tree[m].Freq && depth[n] <= depth[m]))
+
+/* ===========================================================================
+ * Restore the heap property by moving down the tree starting at node k,
+ * exchanging a node with the smallest of its two sons if necessary, stopping
+ * when the heap property is re-established (each father smaller than its
+ * two sons).
+ */
+local void pqdownheap(s, tree, k)
+    deflate_state *s;
+    ct_data *tree;  /* the tree to restore */
+    int k;               /* node to move down */
+{
+    int v = s->heap[k];
+    int j = k << 1;  /* left son of k */
+    while (j <= s->heap_len) {
+        /* Set j to the smallest of the two sons: */
+        if (j < s->heap_len &&
+            smaller(tree, s->heap[j+1], s->heap[j], s->depth)) {
+            j++;
+        }
+        /* Exit if v is smaller than both sons */
+        if (smaller(tree, v, s->heap[j], s->depth)) break;
+
+        /* Exchange v with the smallest son */
+        s->heap[k] = s->heap[j];  k = j;
+
+        /* And continue down the tree, setting j to the left son of k */
+        j <<= 1;
+    }
+    s->heap[k] = v;
+}
+
+/* ===========================================================================
+ * Compute the optimal bit lengths for a tree and update the total bit length
+ * for the current block.
+ * IN assertion: the fields freq and dad are set, heap[heap_max] and
+ *    above are the tree nodes sorted by increasing frequency.
+ * OUT assertions: the field len is set to the optimal bit length, the
+ *     array bl_count contains the frequencies for each bit length.
+ *     The length opt_len is updated; static_len is also updated if stree is
+ *     not null.
+ */
+local void gen_bitlen(s, desc)
+    deflate_state *s;
+    tree_desc *desc;    /* the tree descriptor */
+{
+    ct_data *tree        = desc->dyn_tree;
+    int max_code         = desc->max_code;
+    const ct_data *stree = desc->stat_desc->static_tree;
+    const intf *extra    = desc->stat_desc->extra_bits;
+    int base             = desc->stat_desc->extra_base;
+    int max_length       = desc->stat_desc->max_length;
+    int h;              /* heap index */
+    int n, m;           /* iterate over the tree elements */
+    int bits;           /* bit length */
+    int xbits;          /* extra bits */
+    ush f;              /* frequency */
+    int overflow = 0;   /* number of elements with bit length too large */
+
+    for (bits = 0; bits <= MAX_BITS; bits++) s->bl_count[bits] = 0;
+
+    /* In a first pass, compute the optimal bit lengths (which may
+     * overflow in the case of the bit length tree).
+     */
+    tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */
+
+    for (h = s->heap_max+1; h < HEAP_SIZE; h++) {
+        n = s->heap[h];
+        bits = tree[tree[n].Dad].Len + 1;
+        if (bits > max_length) bits = max_length, overflow++;
+        tree[n].Len = (ush)bits;
+        /* We overwrite tree[n].Dad which is no longer needed */
+
+        if (n > max_code) continue; /* not a leaf node */
+
+        s->bl_count[bits]++;
+        xbits = 0;
+        if (n >= base) xbits = extra[n-base];
+        f = tree[n].Freq;
+        s->opt_len += (ulg)f * (unsigned)(bits + xbits);
+        if (stree) s->static_len += (ulg)f * (unsigned)(stree[n].Len + xbits);
+    }
+    if (overflow == 0) return;
+
+    Tracev((stderr,"\nbit length overflow\n"));
+    /* This happens for example on obj2 and pic of the Calgary corpus */
+
+    /* Find the first bit length which could increase: */
+    do {
+        bits = max_length-1;
+        while (s->bl_count[bits] == 0) bits--;
+        s->bl_count[bits]--;      /* move one leaf down the tree */
+        s->bl_count[bits+1] += 2; /* move one overflow item as its brother */
+        s->bl_count[max_length]--;
+        /* The brother of the overflow item also moves one step up,
+         * but this does not affect bl_count[max_length]
+         */
+        overflow -= 2;
+    } while (overflow > 0);
+
+    /* Now recompute all bit lengths, scanning in increasing frequency.
+     * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
+     * lengths instead of fixing only the wrong ones. This idea is taken
+     * from 'ar' written by Haruhiko Okumura.)
+     */
+    for (bits = max_length; bits != 0; bits--) {
+        n = s->bl_count[bits];
+        while (n != 0) {
+            m = s->heap[--h];
+            if (m > max_code) continue;
+            if ((unsigned) tree[m].Len != (unsigned) bits) {
+                Tracev((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
+                s->opt_len += ((ulg)bits - tree[m].Len) * tree[m].Freq;
+                tree[m].Len = (ush)bits;
+            }
+            n--;
+        }
+    }
+}
+
+/* ===========================================================================
+ * Generate the codes for a given tree and bit counts (which need not be
+ * optimal).
+ * IN assertion: the array bl_count contains the bit length statistics for
+ * the given tree and the field len is set for all tree elements.
+ * OUT assertion: the field code is set for all tree elements of non
+ *     zero code length.
+ */
+local void gen_codes (tree, max_code, bl_count)
+    ct_data *tree;             /* the tree to decorate */
+    int max_code;              /* largest code with non zero frequency */
+    ushf *bl_count;            /* number of codes at each bit length */
+{
+    ush next_code[MAX_BITS+1]; /* next code value for each bit length */
+    unsigned code = 0;         /* running code value */
+    int bits;                  /* bit index */
+    int n;                     /* code index */
+
+    /* The distribution counts are first used to generate the code values
+     * without bit reversal.
+     */
+    for (bits = 1; bits <= MAX_BITS; bits++) {
+        code = (code + bl_count[bits-1]) << 1;
+        next_code[bits] = (ush)code;
+    }
+    /* Check that the bit counts in bl_count are consistent. The last code
+     * must be all ones.
+     */
+    Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
+            "inconsistent bit counts");
+    Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
+
+    for (n = 0;  n <= max_code; n++) {
+        int len = tree[n].Len;
+        if (len == 0) continue;
+        /* Now reverse the bits */
+        tree[n].Code = (ush)bi_reverse(next_code[len]++, len);
+
+        Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",
+             n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));
+    }
+}
+
+/* ===========================================================================
+ * Construct one Huffman tree and assigns the code bit strings and lengths.
+ * Update the total bit length for the current block.
+ * IN assertion: the field freq is set for all tree elements.
+ * OUT assertions: the fields len and code are set to the optimal bit length
+ *     and corresponding code. The length opt_len is updated; static_len is
+ *     also updated if stree is not null. The field max_code is set.
+ */
+local void build_tree(s, desc)
+    deflate_state *s;
+    tree_desc *desc; /* the tree descriptor */
+{
+    ct_data *tree         = desc->dyn_tree;
+    const ct_data *stree  = desc->stat_desc->static_tree;
+    int elems             = desc->stat_desc->elems;
+    int n, m;          /* iterate over heap elements */
+    int max_code = -1; /* largest code with non zero frequency */
+    int node;          /* new node being created */
+
+    /* Construct the initial heap, with least frequent element in
+     * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
+     * heap[0] is not used.
+     */
+    s->heap_len = 0, s->heap_max = HEAP_SIZE;
+
+    for (n = 0; n < elems; n++) {
+        if (tree[n].Freq != 0) {
+            s->heap[++(s->heap_len)] = max_code = n;
+            s->depth[n] = 0;
+        } else {
+            tree[n].Len = 0;
+        }
+    }
+
+    /* The pkzip format requires that at least one distance code exists,
+     * and that at least one bit should be sent even if there is only one
+     * possible code. So to avoid special checks later on we force at least
+     * two codes of non zero frequency.
+     */
+    while (s->heap_len < 2) {
+        node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0);
+        tree[node].Freq = 1;
+        s->depth[node] = 0;
+        s->opt_len--; if (stree) s->static_len -= stree[node].Len;
+        /* node is 0 or 1 so it does not have extra bits */
+    }
+    desc->max_code = max_code;
+
+    /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
+     * establish sub-heaps of increasing lengths:
+     */
+    for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n);
+
+    /* Construct the Huffman tree by repeatedly combining the least two
+     * frequent nodes.
+     */
+    node = elems;              /* next internal node of the tree */
+    do {
+        pqremove(s, tree, n);  /* n = node of least frequency */
+        m = s->heap[SMALLEST]; /* m = node of next least frequency */
+
+        s->heap[--(s->heap_max)] = n; /* keep the nodes sorted by frequency */
+        s->heap[--(s->heap_max)] = m;
+
+        /* Create a new node father of n and m */
+        tree[node].Freq = tree[n].Freq + tree[m].Freq;
+        s->depth[node] = (uch)((s->depth[n] >= s->depth[m] ?
+                                s->depth[n] : s->depth[m]) + 1);
+        tree[n].Dad = tree[m].Dad = (ush)node;
+#ifdef DUMP_BL_TREE
+        if (tree == s->bl_tree) {
+            fprintf(stderr,"\nnode %d(%d), sons %d(%d) %d(%d)",
+                    node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq);
+        }
+#endif
+        /* and insert the new node in the heap */
+        s->heap[SMALLEST] = node++;
+        pqdownheap(s, tree, SMALLEST);
+
+    } while (s->heap_len >= 2);
+
+    s->heap[--(s->heap_max)] = s->heap[SMALLEST];
+
+    /* At this point, the fields freq and dad are set. We can now
+     * generate the bit lengths.
+     */
+    gen_bitlen(s, (tree_desc *)desc);
+
+    /* The field len is now set, we can generate the bit codes */
+    gen_codes ((ct_data *)tree, max_code, s->bl_count);
+}
+
+/* ===========================================================================
+ * Scan a literal or distance tree to determine the frequencies of the codes
+ * in the bit length tree.
+ */
+local void scan_tree (s, tree, max_code)
+    deflate_state *s;
+    ct_data *tree;   /* the tree to be scanned */
+    int max_code;    /* and its largest code of non zero frequency */
+{
+    int n;                     /* iterates over all tree elements */
+    int prevlen = -1;          /* last emitted length */
+    int curlen;                /* length of current code */
+    int nextlen = tree[0].Len; /* length of next code */
+    int count = 0;             /* repeat count of the current code */
+    int max_count = 7;         /* max repeat count */
+    int min_count = 4;         /* min repeat count */
+
+    if (nextlen == 0) max_count = 138, min_count = 3;
+    tree[max_code+1].Len = (ush)0xffff; /* guard */
+
+    for (n = 0; n <= max_code; n++) {
+        curlen = nextlen; nextlen = tree[n+1].Len;
+        if (++count < max_count && curlen == nextlen) {
+            continue;
+        } else if (count < min_count) {
+            s->bl_tree[curlen].Freq += count;
+        } else if (curlen != 0) {
+            if (curlen != prevlen) s->bl_tree[curlen].Freq++;
+            s->bl_tree[REP_3_6].Freq++;
+        } else if (count <= 10) {
+            s->bl_tree[REPZ_3_10].Freq++;
+        } else {
+            s->bl_tree[REPZ_11_138].Freq++;
+        }
+        count = 0; prevlen = curlen;
+        if (nextlen == 0) {
+            max_count = 138, min_count = 3;
+        } else if (curlen == nextlen) {
+            max_count = 6, min_count = 3;
+        } else {
+            max_count = 7, min_count = 4;
+        }
+    }
+}
+
+/* ===========================================================================
+ * Send a literal or distance tree in compressed form, using the codes in
+ * bl_tree.
+ */
+local void send_tree (s, tree, max_code)
+    deflate_state *s;
+    ct_data *tree; /* the tree to be scanned */
+    int max_code;       /* and its largest code of non zero frequency */
+{
+    int n;                     /* iterates over all tree elements */
+    int prevlen = -1;          /* last emitted length */
+    int curlen;                /* length of current code */
+    int nextlen = tree[0].Len; /* length of next code */
+    int count = 0;             /* repeat count of the current code */
+    int max_count = 7;         /* max repeat count */
+    int min_count = 4;         /* min repeat count */
+
+    /* tree[max_code+1].Len = -1; */  /* guard already set */
+    if (nextlen == 0) max_count = 138, min_count = 3;
+
+    for (n = 0; n <= max_code; n++) {
+        curlen = nextlen; nextlen = tree[n+1].Len;
+        if (++count < max_count && curlen == nextlen) {
+            continue;
+        } else if (count < min_count) {
+            do { send_code(s, curlen, s->bl_tree); } while (--count != 0);
+
+        } else if (curlen != 0) {
+            if (curlen != prevlen) {
+                send_code(s, curlen, s->bl_tree); count--;
+            }
+            Assert(count >= 3 && count <= 6, " 3_6?");
+            send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2);
+
+        } else if (count <= 10) {
+            send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3);
+
+        } else {
+            send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count-11, 7);
+        }
+        count = 0; prevlen = curlen;
+        if (nextlen == 0) {
+            max_count = 138, min_count = 3;
+        } else if (curlen == nextlen) {
+            max_count = 6, min_count = 3;
+        } else {
+            max_count = 7, min_count = 4;
+        }
+    }
+}
+
+/* ===========================================================================
+ * Construct the Huffman tree for the bit lengths and return the index in
+ * bl_order of the last bit length code to send.
+ */
+local int build_bl_tree(s)
+    deflate_state *s;
+{
+    int max_blindex;  /* index of last bit length code of non zero freq */
+
+    /* Determine the bit length frequencies for literal and distance trees */
+    scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code);
+    scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code);
+
+    /* Build the bit length tree: */
+    build_tree(s, (tree_desc *)(&(s->bl_desc)));
+    /* opt_len now includes the length of the tree representations, except
+     * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
+     */
+
+    /* Determine the number of bit length codes to send. The pkzip format
+     * requires that at least 4 bit length codes be sent. (appnote.txt says
+     * 3 but the actual value used is 4.)
+     */
+    for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) {
+        if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;
+    }
+    /* Update opt_len to include the bit length tree and counts */
+    s->opt_len += 3*((ulg)max_blindex+1) + 5+5+4;
+    Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
+            s->opt_len, s->static_len));
+
+    return max_blindex;
+}
+
+/* ===========================================================================
+ * Send the header for a block using dynamic Huffman trees: the counts, the
+ * lengths of the bit length codes, the literal tree and the distance tree.
+ * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
+ */
+local void send_all_trees(s, lcodes, dcodes, blcodes)
+    deflate_state *s;
+    int lcodes, dcodes, blcodes; /* number of codes for each tree */
+{
+    int rank;                    /* index in bl_order */
+
+    Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
+    Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,
+            "too many codes");
+    Tracev((stderr, "\nbl counts: "));
+    send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */
+    send_bits(s, dcodes-1,   5);
+    send_bits(s, blcodes-4,  4); /* not -3 as stated in appnote.txt */
+    for (rank = 0; rank < blcodes; rank++) {
+        Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
+        send_bits(s, s->bl_tree[bl_order[rank]].Len, 3);
+    }
+    Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent));
+
+    send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */
+    Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent));
+
+    send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */
+    Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent));
+}
+
+/* ===========================================================================
+ * Send a stored block
+ */
+void ZLIB_INTERNAL _tr_stored_block(s, buf, stored_len, last)
+    deflate_state *s;
+    charf *buf;       /* input block */
+    ulg stored_len;   /* length of input block */
+    int last;         /* one if this is the last block for a file */
+{
+    send_bits(s, (STORED_BLOCK<<1)+last, 3);    /* send block type */
+    bi_windup(s);        /* align on byte boundary */
+    put_short(s, (ush)stored_len);
+    put_short(s, (ush)~stored_len);
+    zmemcpy(s->pending_buf + s->pending, (Bytef *)buf, stored_len);
+    s->pending += stored_len;
+#ifdef ZLIB_DEBUG
+    s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;
+    s->compressed_len += (stored_len + 4) << 3;
+    s->bits_sent += 2*16;
+    s->bits_sent += stored_len<<3;
+#endif
+}
+
+/* ===========================================================================
+ * Flush the bits in the bit buffer to pending output (leaves at most 7 bits)
+ */
+void ZLIB_INTERNAL _tr_flush_bits(s)
+    deflate_state *s;
+{
+    bi_flush(s);
+}
+
+/* ===========================================================================
+ * Send one empty static block to give enough lookahead for inflate.
+ * This takes 10 bits, of which 7 may remain in the bit buffer.
+ */
+void ZLIB_INTERNAL _tr_align(s)
+    deflate_state *s;
+{
+    send_bits(s, STATIC_TREES<<1, 3);
+    send_code(s, END_BLOCK, static_ltree);
+#ifdef ZLIB_DEBUG
+    s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
+#endif
+    bi_flush(s);
+}
+
+/* ===========================================================================
+ * Determine the best encoding for the current block: dynamic trees, static
+ * trees or store, and write out the encoded block.
+ */
+void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last)
+    deflate_state *s;
+    charf *buf;       /* input block, or NULL if too old */
+    ulg stored_len;   /* length of input block */
+    int last;         /* one if this is the last block for a file */
+{
+    ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */
+    int max_blindex = 0;  /* index of last bit length code of non zero freq */
+
+    /* Build the Huffman trees unless a stored block is forced */
+    if (s->level > 0) {
+
+        /* Check if the file is binary or text */
+        if (s->strm->data_type == Z_UNKNOWN)
+            s->strm->data_type = detect_data_type(s);
+
+        /* Construct the literal and distance trees */
+        build_tree(s, (tree_desc *)(&(s->l_desc)));
+        Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,
+                s->static_len));
+
+        build_tree(s, (tree_desc *)(&(s->d_desc)));
+        Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,
+                s->static_len));
+        /* At this point, opt_len and static_len are the total bit lengths of
+         * the compressed block data, excluding the tree representations.
+         */
+
+        /* Build the bit length tree for the above two trees, and get the index
+         * in bl_order of the last bit length code to send.
+         */
+        max_blindex = build_bl_tree(s);
+
+        /* Determine the best encoding. Compute the block lengths in bytes. */
+        opt_lenb = (s->opt_len+3+7)>>3;
+        static_lenb = (s->static_len+3+7)>>3;
+
+        Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",
+                opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,
+                s->last_lit));
+
+        if (static_lenb <= opt_lenb) opt_lenb = static_lenb;
+
+    } else {
+        Assert(buf != (char*)0, "lost buf");
+        opt_lenb = static_lenb = stored_len + 5; /* force a stored block */
+    }
+
+#ifdef FORCE_STORED
+    if (buf != (char*)0) { /* force stored block */
+#else
+    if (stored_len+4 <= opt_lenb && buf != (char*)0) {
+                       /* 4: two words for the lengths */
+#endif
+        /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
+         * Otherwise we can't have processed more than WSIZE input bytes since
+         * the last block flush, because compression would have been
+         * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
+         * transform a block into a stored block.
+         */
+        _tr_stored_block(s, buf, stored_len, last);
+
+#ifdef FORCE_STATIC
+    } else if (static_lenb >= 0) { /* force static trees */
+#else
+    } else if (s->strategy == Z_FIXED || static_lenb == opt_lenb) {
+#endif
+        send_bits(s, (STATIC_TREES<<1)+last, 3);
+        compress_block(s, (const ct_data *)static_ltree,
+                       (const ct_data *)static_dtree);
+#ifdef ZLIB_DEBUG
+        s->compressed_len += 3 + s->static_len;
+#endif
+    } else {
+        send_bits(s, (DYN_TREES<<1)+last, 3);
+        send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1,
+                       max_blindex+1);
+        compress_block(s, (const ct_data *)s->dyn_ltree,
+                       (const ct_data *)s->dyn_dtree);
+#ifdef ZLIB_DEBUG
+        s->compressed_len += 3 + s->opt_len;
+#endif
+    }
+    Assert (s->compressed_len == s->bits_sent, "bad compressed size");
+    /* The above check is made mod 2^32, for files larger than 512 MB
+     * and uLong implemented on 32 bits.
+     */
+    init_block(s);
+
+    if (last) {
+        bi_windup(s);
+#ifdef ZLIB_DEBUG
+        s->compressed_len += 7;  /* align on byte boundary */
+#endif
+    }
+    Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3,
+           s->compressed_len-7*last));
+}
+
+/* ===========================================================================
+ * Save the match info and tally the frequency counts. Return true if
+ * the current block must be flushed.
+ */
+int ZLIB_INTERNAL _tr_tally (s, dist, lc)
+    deflate_state *s;
+    unsigned dist;  /* distance of matched string */
+    unsigned lc;    /* match length-MIN_MATCH or unmatched char (if dist==0) */
+{
+    s->d_buf[s->last_lit] = (ush)dist;
+    s->l_buf[s->last_lit++] = (uch)lc;
+    if (dist == 0) {
+        /* lc is the unmatched char */
+        s->dyn_ltree[lc].Freq++;
+    } else {
+        s->matches++;
+        /* Here, lc is the match length - MIN_MATCH */
+        dist--;             /* dist = match distance - 1 */
+        Assert((ush)dist < (ush)MAX_DIST(s) &&
+               (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
+               (ush)d_code(dist) < (ush)D_CODES,  "_tr_tally: bad match");
+
+        s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++;
+        s->dyn_dtree[d_code(dist)].Freq++;
+    }
+
+#ifdef TRUNCATE_BLOCK
+    /* Try to guess if it is profitable to stop the current block here */
+    if ((s->last_lit & 0x1fff) == 0 && s->level > 2) {
+        /* Compute an upper bound for the compressed length */
+        ulg out_length = (ulg)s->last_lit*8L;
+        ulg in_length = (ulg)((long)s->strstart - s->block_start);
+        int dcode;
+        for (dcode = 0; dcode < D_CODES; dcode++) {
+            out_length += (ulg)s->dyn_dtree[dcode].Freq *
+                (5L+extra_dbits[dcode]);
+        }
+        out_length >>= 3;
+        Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ",
+               s->last_lit, in_length, out_length,
+               100L - out_length*100L/in_length));
+        if (s->matches < s->last_lit/2 && out_length < in_length/2) return 1;
+    }
+#endif
+    return (s->last_lit == s->lit_bufsize-1);
+    /* We avoid equality with lit_bufsize because of wraparound at 64K
+     * on 16 bit machines and because stored blocks are restricted to
+     * 64K-1 bytes.
+     */
+}
+
+/* ===========================================================================
+ * Send the block data compressed using the given Huffman trees
+ */
+local void compress_block(s, ltree, dtree)
+    deflate_state *s;
+    const ct_data *ltree; /* literal tree */
+    const ct_data *dtree; /* distance tree */
+{
+    unsigned dist;      /* distance of matched string */
+    int lc;             /* match length or unmatched char (if dist == 0) */
+    unsigned lx = 0;    /* running index in l_buf */
+    unsigned code;      /* the code to send */
+    int extra;          /* number of extra bits to send */
+
+    if (s->last_lit != 0) do {
+        dist = s->d_buf[lx];
+        lc = s->l_buf[lx++];
+        if (dist == 0) {
+            send_code(s, lc, ltree); /* send a literal byte */
+            Tracecv(isgraph(lc), (stderr," '%c' ", lc));
+        } else {
+            /* Here, lc is the match length - MIN_MATCH */
+            code = _length_code[lc];
+            send_code(s, code+LITERALS+1, ltree); /* send the length code */
+            extra = extra_lbits[code];
+            if (extra != 0) {
+                lc -= base_length[code];
+                send_bits(s, lc, extra);       /* send the extra length bits */
+            }
+            dist--; /* dist is now the match distance - 1 */
+            code = d_code(dist);
+            Assert (code < D_CODES, "bad d_code");
+
+            send_code(s, code, dtree);       /* send the distance code */
+            extra = extra_dbits[code];
+            if (extra != 0) {
+                dist -= (unsigned)base_dist[code];
+                send_bits(s, dist, extra);   /* send the extra distance bits */
+            }
+        } /* literal or match pair ? */
+
+        /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */
+        Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,
+               "pendingBuf overflow");
+
+    } while (lx < s->last_lit);
+
+    send_code(s, END_BLOCK, ltree);
+}
+
+/* ===========================================================================
+ * Check if the data type is TEXT or BINARY, using the following algorithm:
+ * - TEXT if the two conditions below are satisfied:
+ *    a) There are no non-portable control characters belonging to the
+ *       "black list" (0..6, 14..25, 28..31).
+ *    b) There is at least one printable character belonging to the
+ *       "white list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255).
+ * - BINARY otherwise.
+ * - The following partially-portable control characters form a
+ *   "gray list" that is ignored in this detection algorithm:
+ *   (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}).
+ * IN assertion: the fields Freq of dyn_ltree are set.
+ */
+local int detect_data_type(s)
+    deflate_state *s;
+{
+    /* black_mask is the bit mask of black-listed bytes
+     * set bits 0..6, 14..25, and 28..31
+     * 0xf3ffc07f = binary 11110011111111111100000001111111
+     */
+    unsigned long black_mask = 0xf3ffc07fUL;
+    int n;
+
+    /* Check for non-textual ("black-listed") bytes. */
+    for (n = 0; n <= 31; n++, black_mask >>= 1)
+        if ((black_mask & 1) && (s->dyn_ltree[n].Freq != 0))
+            return Z_BINARY;
+
+    /* Check for textual ("white-listed") bytes. */
+    if (s->dyn_ltree[9].Freq != 0 || s->dyn_ltree[10].Freq != 0
+            || s->dyn_ltree[13].Freq != 0)
+        return Z_TEXT;
+    for (n = 32; n < LITERALS; n++)
+        if (s->dyn_ltree[n].Freq != 0)
+            return Z_TEXT;
+
+    /* There are no "black-listed" or "white-listed" bytes:
+     * this stream either is empty or has tolerated ("gray-listed") bytes only.
+     */
+    return Z_BINARY;
+}
+
+/* ===========================================================================
+ * Reverse the first len bits of a code, using straightforward code (a faster
+ * method would use a table)
+ * IN assertion: 1 <= len <= 15
+ */
+local unsigned bi_reverse(code, len)
+    unsigned code; /* the value to invert */
+    int len;       /* its bit length */
+{
+    register unsigned res = 0;
+    do {
+        res |= code & 1;
+        code >>= 1, res <<= 1;
+    } while (--len > 0);
+    return res >> 1;
+}
+
+/* ===========================================================================
+ * Flush the bit buffer, keeping at most 7 bits in it.
+ */
+local void bi_flush(s)
+    deflate_state *s;
+{
+    if (s->bi_valid == 16) {
+        put_short(s, s->bi_buf);
+        s->bi_buf = 0;
+        s->bi_valid = 0;
+    } else if (s->bi_valid >= 8) {
+        put_byte(s, (Byte)s->bi_buf);
+        s->bi_buf >>= 8;
+        s->bi_valid -= 8;
+    }
+}
+
+/* ===========================================================================
+ * Flush the bit buffer and align the output on a byte boundary
+ */
+local void bi_windup(s)
+    deflate_state *s;
+{
+    if (s->bi_valid > 8) {
+        put_short(s, s->bi_buf);
+    } else if (s->bi_valid > 0) {
+        put_byte(s, (Byte)s->bi_buf);
+    }
+    s->bi_buf = 0;
+    s->bi_valid = 0;
+#ifdef ZLIB_DEBUG
+    s->bits_sent = (s->bits_sent+7) & ~7;
+#endif
+}
diff --git a/Engine/lib/assimp/contrib/zlib/trees.h b/Engine/lib/assimp/contrib/zlib/trees.h
new file mode 100644
index 000000000..d35639d82
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/trees.h
@@ -0,0 +1,128 @@
+/* header created automatically with -DGEN_TREES_H */
+
+local const ct_data static_ltree[L_CODES+2] = {
+{{ 12},{  8}}, {{140},{  8}}, {{ 76},{  8}}, {{204},{  8}}, {{ 44},{  8}},
+{{172},{  8}}, {{108},{  8}}, {{236},{  8}}, {{ 28},{  8}}, {{156},{  8}},
+{{ 92},{  8}}, {{220},{  8}}, {{ 60},{  8}}, {{188},{  8}}, {{124},{  8}},
+{{252},{  8}}, {{  2},{  8}}, {{130},{  8}}, {{ 66},{  8}}, {{194},{  8}},
+{{ 34},{  8}}, {{162},{  8}}, {{ 98},{  8}}, {{226},{  8}}, {{ 18},{  8}},
+{{146},{  8}}, {{ 82},{  8}}, {{210},{  8}}, {{ 50},{  8}}, {{178},{  8}},
+{{114},{  8}}, {{242},{  8}}, {{ 10},{  8}}, {{138},{  8}}, {{ 74},{  8}},
+{{202},{  8}}, {{ 42},{  8}}, {{170},{  8}}, {{106},{  8}}, {{234},{  8}},
+{{ 26},{  8}}, {{154},{  8}}, {{ 90},{  8}}, {{218},{  8}}, {{ 58},{  8}},
+{{186},{  8}}, {{122},{  8}}, {{250},{  8}}, {{  6},{  8}}, {{134},{  8}},
+{{ 70},{  8}}, {{198},{  8}}, {{ 38},{  8}}, {{166},{  8}}, {{102},{  8}},
+{{230},{  8}}, {{ 22},{  8}}, {{150},{  8}}, {{ 86},{  8}}, {{214},{  8}},
+{{ 54},{  8}}, {{182},{  8}}, {{118},{  8}}, {{246},{  8}}, {{ 14},{  8}},
+{{142},{  8}}, {{ 78},{  8}}, {{206},{  8}}, {{ 46},{  8}}, {{174},{  8}},
+{{110},{  8}}, {{238},{  8}}, {{ 30},{  8}}, {{158},{  8}}, {{ 94},{  8}},
+{{222},{  8}}, {{ 62},{  8}}, {{190},{  8}}, {{126},{  8}}, {{254},{  8}},
+{{  1},{  8}}, {{129},{  8}}, {{ 65},{  8}}, {{193},{  8}}, {{ 33},{  8}},
+{{161},{  8}}, {{ 97},{  8}}, {{225},{  8}}, {{ 17},{  8}}, {{145},{  8}},
+{{ 81},{  8}}, {{209},{  8}}, {{ 49},{  8}}, {{177},{  8}}, {{113},{  8}},
+{{241},{  8}}, {{  9},{  8}}, {{137},{  8}}, {{ 73},{  8}}, {{201},{  8}},
+{{ 41},{  8}}, {{169},{  8}}, {{105},{  8}}, {{233},{  8}}, {{ 25},{  8}},
+{{153},{  8}}, {{ 89},{  8}}, {{217},{  8}}, {{ 57},{  8}}, {{185},{  8}},
+{{121},{  8}}, {{249},{  8}}, {{  5},{  8}}, {{133},{  8}}, {{ 69},{  8}},
+{{197},{  8}}, {{ 37},{  8}}, {{165},{  8}}, {{101},{  8}}, {{229},{  8}},
+{{ 21},{  8}}, {{149},{  8}}, {{ 85},{  8}}, {{213},{  8}}, {{ 53},{  8}},
+{{181},{  8}}, {{117},{  8}}, {{245},{  8}}, {{ 13},{  8}}, {{141},{  8}},
+{{ 77},{  8}}, {{205},{  8}}, {{ 45},{  8}}, {{173},{  8}}, {{109},{  8}},
+{{237},{  8}}, {{ 29},{  8}}, {{157},{  8}}, {{ 93},{  8}}, {{221},{  8}},
+{{ 61},{  8}}, {{189},{  8}}, {{125},{  8}}, {{253},{  8}}, {{ 19},{  9}},
+{{275},{  9}}, {{147},{  9}}, {{403},{  9}}, {{ 83},{  9}}, {{339},{  9}},
+{{211},{  9}}, {{467},{  9}}, {{ 51},{  9}}, {{307},{  9}}, {{179},{  9}},
+{{435},{  9}}, {{115},{  9}}, {{371},{  9}}, {{243},{  9}}, {{499},{  9}},
+{{ 11},{  9}}, {{267},{  9}}, {{139},{  9}}, {{395},{  9}}, {{ 75},{  9}},
+{{331},{  9}}, {{203},{  9}}, {{459},{  9}}, {{ 43},{  9}}, {{299},{  9}},
+{{171},{  9}}, {{427},{  9}}, {{107},{  9}}, {{363},{  9}}, {{235},{  9}},
+{{491},{  9}}, {{ 27},{  9}}, {{283},{  9}}, {{155},{  9}}, {{411},{  9}},
+{{ 91},{  9}}, {{347},{  9}}, {{219},{  9}}, {{475},{  9}}, {{ 59},{  9}},
+{{315},{  9}}, {{187},{  9}}, {{443},{  9}}, {{123},{  9}}, {{379},{  9}},
+{{251},{  9}}, {{507},{  9}}, {{  7},{  9}}, {{263},{  9}}, {{135},{  9}},
+{{391},{  9}}, {{ 71},{  9}}, {{327},{  9}}, {{199},{  9}}, {{455},{  9}},
+{{ 39},{  9}}, {{295},{  9}}, {{167},{  9}}, {{423},{  9}}, {{103},{  9}},
+{{359},{  9}}, {{231},{  9}}, {{487},{  9}}, {{ 23},{  9}}, {{279},{  9}},
+{{151},{  9}}, {{407},{  9}}, {{ 87},{  9}}, {{343},{  9}}, {{215},{  9}},
+{{471},{  9}}, {{ 55},{  9}}, {{311},{  9}}, {{183},{  9}}, {{439},{  9}},
+{{119},{  9}}, {{375},{  9}}, {{247},{  9}}, {{503},{  9}}, {{ 15},{  9}},
+{{271},{  9}}, {{143},{  9}}, {{399},{  9}}, {{ 79},{  9}}, {{335},{  9}},
+{{207},{  9}}, {{463},{  9}}, {{ 47},{  9}}, {{303},{  9}}, {{175},{  9}},
+{{431},{  9}}, {{111},{  9}}, {{367},{  9}}, {{239},{  9}}, {{495},{  9}},
+{{ 31},{  9}}, {{287},{  9}}, {{159},{  9}}, {{415},{  9}}, {{ 95},{  9}},
+{{351},{  9}}, {{223},{  9}}, {{479},{  9}}, {{ 63},{  9}}, {{319},{  9}},
+{{191},{  9}}, {{447},{  9}}, {{127},{  9}}, {{383},{  9}}, {{255},{  9}},
+{{511},{  9}}, {{  0},{  7}}, {{ 64},{  7}}, {{ 32},{  7}}, {{ 96},{  7}},
+{{ 16},{  7}}, {{ 80},{  7}}, {{ 48},{  7}}, {{112},{  7}}, {{  8},{  7}},
+{{ 72},{  7}}, {{ 40},{  7}}, {{104},{  7}}, {{ 24},{  7}}, {{ 88},{  7}},
+{{ 56},{  7}}, {{120},{  7}}, {{  4},{  7}}, {{ 68},{  7}}, {{ 36},{  7}},
+{{100},{  7}}, {{ 20},{  7}}, {{ 84},{  7}}, {{ 52},{  7}}, {{116},{  7}},
+{{  3},{  8}}, {{131},{  8}}, {{ 67},{  8}}, {{195},{  8}}, {{ 35},{  8}},
+{{163},{  8}}, {{ 99},{  8}}, {{227},{  8}}
+};
+
+local const ct_data static_dtree[D_CODES] = {
+{{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}},
+{{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}},
+{{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}},
+{{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}},
+{{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}},
+{{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}}
+};
+
+const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = {
+ 0,  1,  2,  3,  4,  4,  5,  5,  6,  6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  8,
+ 8,  8,  8,  8,  9,  9,  9,  9,  9,  9,  9,  9, 10, 10, 10, 10, 10, 10, 10, 10,
+10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13,
+13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15,
+15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,  0,  0, 16, 17,
+18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22,
+23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27,
+27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29
+};
+
+const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= {
+ 0,  1,  2,  3,  4,  5,  6,  7,  8,  8,  9,  9, 10, 10, 11, 11, 12, 12, 12, 12,
+13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16,
+17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19,
+19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22,
+22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23,
+23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26,
+26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28
+};
+
+local const int base_length[LENGTH_CODES] = {
+0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56,
+64, 80, 96, 112, 128, 160, 192, 224, 0
+};
+
+local const int base_dist[D_CODES] = {
+    0,     1,     2,     3,     4,     6,     8,    12,    16,    24,
+   32,    48,    64,    96,   128,   192,   256,   384,   512,   768,
+ 1024,  1536,  2048,  3072,  4096,  6144,  8192, 12288, 16384, 24576
+};
+
diff --git a/Engine/lib/assimp/contrib/zlib/uncompr.c b/Engine/lib/assimp/contrib/zlib/uncompr.c
new file mode 100644
index 000000000..f03a1a865
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/uncompr.c
@@ -0,0 +1,93 @@
+/* uncompr.c -- decompress a memory buffer
+ * Copyright (C) 1995-2003, 2010, 2014, 2016 Jean-loup Gailly, Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#define ZLIB_INTERNAL
+#include "zlib.h"
+
+/* ===========================================================================
+     Decompresses the source buffer into the destination buffer.  *sourceLen is
+   the byte length of the source buffer. Upon entry, *destLen is the total size
+   of the destination buffer, which must be large enough to hold the entire
+   uncompressed data. (The size of the uncompressed data must have been saved
+   previously by the compressor and transmitted to the decompressor by some
+   mechanism outside the scope of this compression library.) Upon exit,
+   *destLen is the size of the decompressed data and *sourceLen is the number
+   of source bytes consumed. Upon return, source + *sourceLen points to the
+   first unused input byte.
+
+     uncompress returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_BUF_ERROR if there was not enough room in the output buffer, or
+   Z_DATA_ERROR if the input data was corrupted, including if the input data is
+   an incomplete zlib stream.
+*/
+int ZEXPORT uncompress2 (dest, destLen, source, sourceLen)
+    Bytef *dest;
+    uLongf *destLen;
+    const Bytef *source;
+    uLong *sourceLen;
+{
+    z_stream stream;
+    int err;
+    const uInt max = (uInt)-1;
+    uLong len, left;
+    Byte buf[1];    /* for detection of incomplete stream when *destLen == 0 */
+
+    len = *sourceLen;
+    if (*destLen) {
+        left = *destLen;
+        *destLen = 0;
+    }
+    else {
+        left = 1;
+        dest = buf;
+    }
+
+    stream.next_in = (z_const Bytef *)source;
+    stream.avail_in = 0;
+    stream.zalloc = (alloc_func)0;
+    stream.zfree = (free_func)0;
+    stream.opaque = (voidpf)0;
+
+    err = inflateInit(&stream);
+    if (err != Z_OK) return err;
+
+    stream.next_out = dest;
+    stream.avail_out = 0;
+
+    do {
+        if (stream.avail_out == 0) {
+            stream.avail_out = left > (uLong)max ? max : (uInt)left;
+            left -= stream.avail_out;
+        }
+        if (stream.avail_in == 0) {
+            stream.avail_in = len > (uLong)max ? max : (uInt)len;
+            len -= stream.avail_in;
+        }
+        err = inflate(&stream, Z_NO_FLUSH);
+    } while (err == Z_OK);
+
+    *sourceLen -= len + stream.avail_in;
+    if (dest != buf)
+        *destLen = stream.total_out;
+    else if (stream.total_out && err == Z_BUF_ERROR)
+        left = 1;
+
+    inflateEnd(&stream);
+    return err == Z_STREAM_END ? Z_OK :
+           err == Z_NEED_DICT ? Z_DATA_ERROR  :
+           err == Z_BUF_ERROR && left + stream.avail_out ? Z_DATA_ERROR :
+           err;
+}
+
+int ZEXPORT uncompress (dest, destLen, source, sourceLen)
+    Bytef *dest;
+    uLongf *destLen;
+    const Bytef *source;
+    uLong sourceLen;
+{
+    return uncompress2(dest, destLen, source, &sourceLen);
+}
diff --git a/Engine/lib/assimp/contrib/zlib/win32/DLL_FAQ.txt b/Engine/lib/assimp/contrib/zlib/win32/DLL_FAQ.txt
new file mode 100644
index 000000000..12c009018
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/win32/DLL_FAQ.txt
@@ -0,0 +1,397 @@
+
+            Frequently Asked Questions about ZLIB1.DLL
+
+
+This document describes the design, the rationale, and the usage
+of the official DLL build of zlib, named ZLIB1.DLL.  If you have
+general questions about zlib, you should see the file "FAQ" found
+in the zlib distribution, or at the following location:
+  http://www.gzip.org/zlib/zlib_faq.html
+
+
+ 1. What is ZLIB1.DLL, and how can I get it?
+
+  - ZLIB1.DLL is the official build of zlib as a DLL.
+    (Please remark the character '1' in the name.)
+
+    Pointers to a precompiled ZLIB1.DLL can be found in the zlib
+    web site at:
+      http://www.zlib.net/
+
+    Applications that link to ZLIB1.DLL can rely on the following
+    specification:
+
+    * The exported symbols are exclusively defined in the source
+      files "zlib.h" and "zlib.def", found in an official zlib
+      source distribution.
+    * The symbols are exported by name, not by ordinal.
+    * The exported names are undecorated.
+    * The calling convention of functions is "C" (CDECL).
+    * The ZLIB1.DLL binary is linked to MSVCRT.DLL.
+
+    The archive in which ZLIB1.DLL is bundled contains compiled
+    test programs that must run with a valid build of ZLIB1.DLL.
+    It is recommended to download the prebuilt DLL from the zlib
+    web site, instead of building it yourself, to avoid potential
+    incompatibilities that could be introduced by your compiler
+    and build settings.  If you do build the DLL yourself, please
+    make sure that it complies with all the above requirements,
+    and it runs with the precompiled test programs, bundled with
+    the original ZLIB1.DLL distribution.
+
+    If, for any reason, you need to build an incompatible DLL,
+    please use a different file name.
+
+
+ 2. Why did you change the name of the DLL to ZLIB1.DLL?
+    What happened to the old ZLIB.DLL?
+
+  - The old ZLIB.DLL, built from zlib-1.1.4 or earlier, required
+    compilation settings that were incompatible to those used by
+    a static build.  The DLL settings were supposed to be enabled
+    by defining the macro ZLIB_DLL, before including "zlib.h".
+    Incorrect handling of this macro was silently accepted at
+    build time, resulting in two major problems:
+
+    * ZLIB_DLL was missing from the old makefile.  When building
+      the DLL, not all people added it to the build options.  In
+      consequence, incompatible incarnations of ZLIB.DLL started
+      to circulate around the net.
+
+    * When switching from using the static library to using the
+      DLL, applications had to define the ZLIB_DLL macro and
+      to recompile all the sources that contained calls to zlib
+      functions.  Failure to do so resulted in creating binaries
+      that were unable to run with the official ZLIB.DLL build.
+
+    The only possible solution that we could foresee was to make
+    a binary-incompatible change in the DLL interface, in order to
+    remove the dependency on the ZLIB_DLL macro, and to release
+    the new DLL under a different name.
+
+    We chose the name ZLIB1.DLL, where '1' indicates the major
+    zlib version number.  We hope that we will not have to break
+    the binary compatibility again, at least not as long as the
+    zlib-1.x series will last.
+
+    There is still a ZLIB_DLL macro, that can trigger a more
+    efficient build and use of the DLL, but compatibility no
+    longer dependents on it.
+
+
+ 3. Can I build ZLIB.DLL from the new zlib sources, and replace
+    an old ZLIB.DLL, that was built from zlib-1.1.4 or earlier?
+
+  - In principle, you can do it by assigning calling convention
+    keywords to the macros ZEXPORT and ZEXPORTVA.  In practice,
+    it depends on what you mean by "an old ZLIB.DLL", because the
+    old DLL exists in several mutually-incompatible versions.
+    You have to find out first what kind of calling convention is
+    being used in your particular ZLIB.DLL build, and to use the
+    same one in the new build.  If you don't know what this is all
+    about, you might be better off if you would just leave the old
+    DLL intact.
+
+
+ 4. Can I compile my application using the new zlib interface, and
+    link it to an old ZLIB.DLL, that was built from zlib-1.1.4 or
+    earlier?
+
+  - The official answer is "no"; the real answer depends again on
+    what kind of ZLIB.DLL you have.  Even if you are lucky, this
+    course of action is unreliable.
+
+    If you rebuild your application and you intend to use a newer
+    version of zlib (post- 1.1.4), it is strongly recommended to
+    link it to the new ZLIB1.DLL.
+
+
+ 5. Why are the zlib symbols exported by name, and not by ordinal?
+
+  - Although exporting symbols by ordinal is a little faster, it
+    is risky.  Any single glitch in the maintenance or use of the
+    DEF file that contains the ordinals can result in incompatible
+    builds and frustrating crashes.  Simply put, the benefits of
+    exporting symbols by ordinal do not justify the risks.
+
+    Technically, it should be possible to maintain ordinals in
+    the DEF file, and still export the symbols by name.  Ordinals
+    exist in every DLL, and even if the dynamic linking performed
+    at the DLL startup is searching for names, ordinals serve as
+    hints, for a faster name lookup.  However, if the DEF file
+    contains ordinals, the Microsoft linker automatically builds
+    an implib that will cause the executables linked to it to use
+    those ordinals, and not the names.  It is interesting to
+    notice that the GNU linker for Win32 does not suffer from this
+    problem.
+
+    It is possible to avoid the DEF file if the exported symbols
+    are accompanied by a "__declspec(dllexport)" attribute in the
+    source files.  You can do this in zlib by predefining the
+    ZLIB_DLL macro.
+
+
+ 6. I see that the ZLIB1.DLL functions use the "C" (CDECL) calling
+    convention.  Why not use the STDCALL convention?
+    STDCALL is the standard convention in Win32, and I need it in
+    my Visual Basic project!
+
+    (For readability, we use CDECL to refer to the convention
+     triggered by the "__cdecl" keyword, STDCALL to refer to
+     the convention triggered by "__stdcall", and FASTCALL to
+     refer to the convention triggered by "__fastcall".)
+
+  - Most of the native Windows API functions (without varargs) use
+    indeed the WINAPI convention (which translates to STDCALL in
+    Win32), but the standard C functions use CDECL.  If a user
+    application is intrinsically tied to the Windows API (e.g.
+    it calls native Windows API functions such as CreateFile()),
+    sometimes it makes sense to decorate its own functions with
+    WINAPI.  But if ANSI C or POSIX portability is a goal (e.g.
+    it calls standard C functions such as fopen()), it is not a
+    sound decision to request the inclusion of <windows.h>, or to
+    use non-ANSI constructs, for the sole purpose to make the user
+    functions STDCALL-able.
+
+    The functionality offered by zlib is not in the category of
+    "Windows functionality", but is more like "C functionality".
+
+    Technically, STDCALL is not bad; in fact, it is slightly
+    faster than CDECL, and it works with variable-argument
+    functions, just like CDECL.  It is unfortunate that, in spite
+    of using STDCALL in the Windows API, it is not the default
+    convention used by the C compilers that run under Windows.
+    The roots of the problem reside deep inside the unsafety of
+    the K&R-style function prototypes, where the argument types
+    are not specified; but that is another story for another day.
+
+    The remaining fact is that CDECL is the default convention.
+    Even if an explicit convention is hard-coded into the function
+    prototypes inside C headers, problems may appear.  The
+    necessity to expose the convention in users' callbacks is one
+    of these problems.
+
+    The calling convention issues are also important when using
+    zlib in other programming languages.  Some of them, like Ada
+    (GNAT) and Fortran (GNU G77), have C bindings implemented
+    initially on Unix, and relying on the C calling convention.
+    On the other hand, the pre- .NET versions of Microsoft Visual
+    Basic require STDCALL, while Borland Delphi prefers, although
+    it does not require, FASTCALL.
+
+    In fairness to all possible uses of zlib outside the C
+    programming language, we choose the default "C" convention.
+    Anyone interested in different bindings or conventions is
+    encouraged to maintain specialized projects.  The "contrib/"
+    directory from the zlib distribution already holds a couple
+    of foreign bindings, such as Ada, C++, and Delphi.
+
+
+ 7. I need a DLL for my Visual Basic project.  What can I do?
+
+  - Define the ZLIB_WINAPI macro before including "zlib.h", when
+    building both the DLL and the user application (except that
+    you don't need to define anything when using the DLL in Visual
+    Basic).  The ZLIB_WINAPI macro will switch on the WINAPI
+    (STDCALL) convention.  The name of this DLL must be different
+    than the official ZLIB1.DLL.
+
+    Gilles Vollant has contributed a build named ZLIBWAPI.DLL,
+    with the ZLIB_WINAPI macro turned on, and with the minizip
+    functionality built in.  For more information, please read
+    the notes inside "contrib/vstudio/readme.txt", found in the
+    zlib distribution.
+
+
+ 8. I need to use zlib in my Microsoft .NET project.  What can I
+    do?
+
+  - Henrik Ravn has contributed a .NET wrapper around zlib.  Look
+    into contrib/dotzlib/, inside the zlib distribution.
+
+
+ 9. If my application uses ZLIB1.DLL, should I link it to
+    MSVCRT.DLL?  Why?
+
+  - It is not required, but it is recommended to link your
+    application to MSVCRT.DLL, if it uses ZLIB1.DLL.
+
+    The executables (.EXE, .DLL, etc.) that are involved in the
+    same process and are using the C run-time library (i.e. they
+    are calling standard C functions), must link to the same
+    library.  There are several libraries in the Win32 system:
+    CRTDLL.DLL, MSVCRT.DLL, the static C libraries, etc.
+    Since ZLIB1.DLL is linked to MSVCRT.DLL, the executables that
+    depend on it should also be linked to MSVCRT.DLL.
+
+
+10. Why are you saying that ZLIB1.DLL and my application should
+    be linked to the same C run-time (CRT) library?  I linked my
+    application and my DLLs to different C libraries (e.g. my
+    application to a static library, and my DLLs to MSVCRT.DLL),
+    and everything works fine.
+
+  - If a user library invokes only pure Win32 API (accessible via
+    <windows.h> and the related headers), its DLL build will work
+    in any context.  But if this library invokes standard C API,
+    things get more complicated.
+
+    There is a single Win32 library in a Win32 system.  Every
+    function in this library resides in a single DLL module, that
+    is safe to call from anywhere.  On the other hand, there are
+    multiple versions of the C library, and each of them has its
+    own separate internal state.  Standalone executables and user
+    DLLs that call standard C functions must link to a C run-time
+    (CRT) library, be it static or shared (DLL).  Intermixing
+    occurs when an executable (not necessarily standalone) and a
+    DLL are linked to different CRTs, and both are running in the
+    same process.
+
+    Intermixing multiple CRTs is possible, as long as their
+    internal states are kept intact.  The Microsoft Knowledge Base
+    articles KB94248 "HOWTO: Use the C Run-Time" and KB140584
+    "HOWTO: Link with the Correct C Run-Time (CRT) Library"
+    mention the potential problems raised by intermixing.
+
+    If intermixing works for you, it's because your application
+    and DLLs are avoiding the corruption of each of the CRTs'
+    internal states, maybe by careful design, or maybe by fortune.
+
+    Also note that linking ZLIB1.DLL to non-Microsoft CRTs, such
+    as those provided by Borland, raises similar problems.
+
+
+11. Why are you linking ZLIB1.DLL to MSVCRT.DLL?
+
+  - MSVCRT.DLL exists on every Windows 95 with a new service pack
+    installed, or with Microsoft Internet Explorer 4 or later, and
+    on all other Windows 4.x or later (Windows 98, Windows NT 4,
+    or later).  It is freely distributable; if not present in the
+    system, it can be downloaded from Microsoft or from other
+    software provider for free.
+
+    The fact that MSVCRT.DLL does not exist on a virgin Windows 95
+    is not so problematic.  Windows 95 is scarcely found nowadays,
+    Microsoft ended its support a long time ago, and many recent
+    applications from various vendors, including Microsoft, do not
+    even run on it.  Furthermore, no serious user should run
+    Windows 95 without a proper update installed.
+
+
+12. Why are you not linking ZLIB1.DLL to
+    <<my favorite C run-time library>> ?
+
+  - We considered and abandoned the following alternatives:
+
+    * Linking ZLIB1.DLL to a static C library (LIBC.LIB, or
+      LIBCMT.LIB) is not a good option.  People are using the DLL
+      mainly to save disk space.  If you are linking your program
+      to a static C library, you may as well consider linking zlib
+      in statically, too.
+
+    * Linking ZLIB1.DLL to CRTDLL.DLL looks appealing, because
+      CRTDLL.DLL is present on every Win32 installation.
+      Unfortunately, it has a series of problems: it does not
+      work properly with Microsoft's C++ libraries, it does not
+      provide support for 64-bit file offsets, (and so on...),
+      and Microsoft discontinued its support a long time ago.
+
+    * Linking ZLIB1.DLL to MSVCR70.DLL or MSVCR71.DLL, supplied
+      with the Microsoft .NET platform, and Visual C++ 7.0/7.1,
+      raises problems related to the status of ZLIB1.DLL as a
+      system component.  According to the Microsoft Knowledge Base
+      article KB326922 "INFO: Redistribution of the Shared C
+      Runtime Component in Visual C++ .NET", MSVCR70.DLL and
+      MSVCR71.DLL are not supposed to function as system DLLs,
+      because they may clash with MSVCRT.DLL.  Instead, the
+      application's installer is supposed to put these DLLs
+      (if needed) in the application's private directory.
+      If ZLIB1.DLL depends on a non-system runtime, it cannot
+      function as a redistributable system component.
+
+    * Linking ZLIB1.DLL to non-Microsoft runtimes, such as
+      Borland's, or Cygwin's, raises problems related to the
+      reliable presence of these runtimes on Win32 systems.
+      It's easier to let the DLL build of zlib up to the people
+      who distribute these runtimes, and who may proceed as
+      explained in the answer to Question 14.
+
+
+13. If ZLIB1.DLL cannot be linked to MSVCR70.DLL or MSVCR71.DLL,
+    how can I build/use ZLIB1.DLL in Microsoft Visual C++ 7.0
+    (Visual Studio .NET) or newer?
+
+  - Due to the problems explained in the Microsoft Knowledge Base
+    article KB326922 (see the previous answer), the C runtime that
+    comes with the VC7 environment is no longer considered a
+    system component.  That is, it should not be assumed that this
+    runtime exists, or may be installed in a system directory.
+    Since ZLIB1.DLL is supposed to be a system component, it may
+    not depend on a non-system component.
+
+    In order to link ZLIB1.DLL and your application to MSVCRT.DLL
+    in VC7, you need the library of Visual C++ 6.0 or older.  If
+    you don't have this library at hand, it's probably best not to
+    use ZLIB1.DLL.
+
+    We are hoping that, in the future, Microsoft will provide a
+    way to build applications linked to a proper system runtime,
+    from the Visual C++ environment.  Until then, you have a
+    couple of alternatives, such as linking zlib in statically.
+    If your application requires dynamic linking, you may proceed
+    as explained in the answer to Question 14.
+
+
+14. I need to link my own DLL build to a CRT different than
+    MSVCRT.DLL.  What can I do?
+
+  - Feel free to rebuild the DLL from the zlib sources, and link
+    it the way you want.  You should, however, clearly state that
+    your build is unofficial.  You should give it a different file
+    name, and/or install it in a private directory that can be
+    accessed by your application only, and is not visible to the
+    others (i.e. it's neither in the PATH, nor in the SYSTEM or
+    SYSTEM32 directories).  Otherwise, your build may clash with
+    applications that link to the official build.
+
+    For example, in Cygwin, zlib is linked to the Cygwin runtime
+    CYGWIN1.DLL, and it is distributed under the name CYGZ.DLL.
+
+
+15. May I include additional pieces of code that I find useful,
+    link them in ZLIB1.DLL, and export them?
+
+  - No.  A legitimate build of ZLIB1.DLL must not include code
+    that does not originate from the official zlib source code.
+    But you can make your own private DLL build, under a different
+    file name, as suggested in the previous answer.
+
+    For example, zlib is a part of the VCL library, distributed
+    with Borland Delphi and C++ Builder.  The DLL build of VCL
+    is a redistributable file, named VCLxx.DLL.
+
+
+16. May I remove some functionality out of ZLIB1.DLL, by enabling
+    macros like NO_GZCOMPRESS or NO_GZIP at compile time?
+
+  - No.  A legitimate build of ZLIB1.DLL must provide the complete
+    zlib functionality, as implemented in the official zlib source
+    code.  But you can make your own private DLL build, under a
+    different file name, as suggested in the previous answer.
+
+
+17. I made my own ZLIB1.DLL build.  Can I test it for compliance?
+
+  - We prefer that you download the official DLL from the zlib
+    web site.  If you need something peculiar from this DLL, you
+    can send your suggestion to the zlib mailing list.
+
+    However, in case you do rebuild the DLL yourself, you can run
+    it with the test programs found in the DLL distribution.
+    Running these test programs is not a guarantee of compliance,
+    but a failure can imply a detected problem.
+
+**
+
+This document is written and maintained by
+Cosmin Truta <cosmint@cs.ubbcluj.ro>
diff --git a/Engine/lib/assimp/contrib/zlib/win32/Makefile.bor b/Engine/lib/assimp/contrib/zlib/win32/Makefile.bor
new file mode 100644
index 000000000..d152bbb7f
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/win32/Makefile.bor
@@ -0,0 +1,110 @@
+# Makefile for zlib
+# Borland C++ for Win32
+#
+# Usage:
+#  make -f win32/Makefile.bor
+#  make -f win32/Makefile.bor LOCAL_ZLIB=-DASMV OBJA=match.obj OBJPA=+match.obj
+
+# ------------ Borland C++ ------------
+
+# Optional nonstandard preprocessor flags (e.g. -DMAX_MEM_LEVEL=7)
+# should be added to the environment via "set LOCAL_ZLIB=-DFOO" or
+# added to the declaration of LOC here:
+LOC = $(LOCAL_ZLIB)
+
+CC = bcc32
+AS = bcc32
+LD = bcc32
+AR = tlib
+CFLAGS  = -a -d -k- -O2 $(LOC)
+ASFLAGS = $(LOC)
+LDFLAGS = $(LOC)
+
+
+# variables
+ZLIB_LIB = zlib.lib
+
+OBJ1 = adler32.obj compress.obj crc32.obj deflate.obj gzclose.obj gzlib.obj gzread.obj
+OBJ2 = gzwrite.obj infback.obj inffast.obj inflate.obj inftrees.obj trees.obj uncompr.obj zutil.obj
+#OBJA =
+OBJP1 = +adler32.obj+compress.obj+crc32.obj+deflate.obj+gzclose.obj+gzlib.obj+gzread.obj
+OBJP2 = +gzwrite.obj+infback.obj+inffast.obj+inflate.obj+inftrees.obj+trees.obj+uncompr.obj+zutil.obj
+#OBJPA=
+
+
+# targets
+all: $(ZLIB_LIB) example.exe minigzip.exe
+
+.c.obj:
+	$(CC) -c $(CFLAGS) $<
+
+.asm.obj:
+	$(AS) -c $(ASFLAGS) $<
+
+adler32.obj: adler32.c zlib.h zconf.h
+
+compress.obj: compress.c zlib.h zconf.h
+
+crc32.obj: crc32.c zlib.h zconf.h crc32.h
+
+deflate.obj: deflate.c deflate.h zutil.h zlib.h zconf.h
+
+gzclose.obj: gzclose.c zlib.h zconf.h gzguts.h
+
+gzlib.obj: gzlib.c zlib.h zconf.h gzguts.h
+
+gzread.obj: gzread.c zlib.h zconf.h gzguts.h
+
+gzwrite.obj: gzwrite.c zlib.h zconf.h gzguts.h
+
+infback.obj: infback.c zutil.h zlib.h zconf.h inftrees.h inflate.h \
+ inffast.h inffixed.h
+
+inffast.obj: inffast.c zutil.h zlib.h zconf.h inftrees.h inflate.h \
+ inffast.h
+
+inflate.obj: inflate.c zutil.h zlib.h zconf.h inftrees.h inflate.h \
+ inffast.h inffixed.h
+
+inftrees.obj: inftrees.c zutil.h zlib.h zconf.h inftrees.h
+
+trees.obj: trees.c zutil.h zlib.h zconf.h deflate.h trees.h
+
+uncompr.obj: uncompr.c zlib.h zconf.h
+
+zutil.obj: zutil.c zutil.h zlib.h zconf.h
+
+example.obj: test/example.c zlib.h zconf.h
+
+minigzip.obj: test/minigzip.c zlib.h zconf.h
+
+
+# For the sake of the old Borland make,
+# the command line is cut to fit in the MS-DOS 128 byte limit:
+$(ZLIB_LIB): $(OBJ1) $(OBJ2) $(OBJA)
+	-del $(ZLIB_LIB)
+	$(AR) $(ZLIB_LIB) $(OBJP1)
+	$(AR) $(ZLIB_LIB) $(OBJP2)
+	$(AR) $(ZLIB_LIB) $(OBJPA)
+
+
+# testing
+test: example.exe minigzip.exe
+	example
+	echo hello world | minigzip | minigzip -d
+
+example.exe: example.obj $(ZLIB_LIB)
+	$(LD) $(LDFLAGS) example.obj $(ZLIB_LIB)
+
+minigzip.exe: minigzip.obj $(ZLIB_LIB)
+	$(LD) $(LDFLAGS) minigzip.obj $(ZLIB_LIB)
+
+
+# cleanup
+clean:
+	-del $(ZLIB_LIB)
+	-del *.obj
+	-del *.exe
+	-del *.tds
+	-del zlib.bak
+	-del foo.gz
diff --git a/Engine/lib/assimp/contrib/zlib/win32/Makefile.gcc b/Engine/lib/assimp/contrib/zlib/win32/Makefile.gcc
new file mode 100644
index 000000000..305be50af
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/win32/Makefile.gcc
@@ -0,0 +1,182 @@
+# Makefile for zlib, derived from Makefile.dj2.
+# Modified for mingw32 by C. Spieler, 6/16/98.
+# Updated for zlib 1.2.x by Christian Spieler and Cosmin Truta, Mar-2003.
+# Last updated: Mar 2012.
+# Tested under Cygwin and MinGW.
+
+# Copyright (C) 1995-2003 Jean-loup Gailly.
+# For conditions of distribution and use, see copyright notice in zlib.h
+
+# To compile, or to compile and test, type from the top level zlib directory:
+#
+#   make -fwin32/Makefile.gcc;  make test testdll -fwin32/Makefile.gcc
+#
+# To use the asm code, type:
+#   cp contrib/asm?86/match.S ./match.S
+#   make LOC=-DASMV OBJA=match.o -fwin32/Makefile.gcc
+#
+# To install libz.a, zconf.h and zlib.h in the system directories, type:
+#
+#   make install -fwin32/Makefile.gcc
+#
+# BINARY_PATH, INCLUDE_PATH and LIBRARY_PATH must be set.
+#
+# To install the shared lib, append SHARED_MODE=1 to the make command :
+#
+#   make install -fwin32/Makefile.gcc SHARED_MODE=1
+
+# Note:
+# If the platform is *not* MinGW (e.g. it is Cygwin or UWIN),
+# the DLL name should be changed from "zlib1.dll".
+
+STATICLIB = libz.a
+SHAREDLIB = zlib1.dll
+IMPLIB    = libz.dll.a
+
+#
+# Set to 1 if shared object needs to be installed
+#
+SHARED_MODE=0
+
+#LOC = -DASMV
+#LOC = -DZLIB_DEBUG -g
+
+PREFIX =
+CC = $(PREFIX)gcc
+CFLAGS = $(LOC) -O3 -Wall
+
+AS = $(CC)
+ASFLAGS = $(LOC) -Wall
+
+LD = $(CC)
+LDFLAGS = $(LOC)
+
+AR = $(PREFIX)ar
+ARFLAGS = rcs
+
+RC = $(PREFIX)windres
+RCFLAGS = --define GCC_WINDRES
+
+STRIP = $(PREFIX)strip
+
+CP = cp -fp
+# If GNU install is available, replace $(CP) with install.
+INSTALL = $(CP)
+RM = rm -f
+
+prefix ?= /usr/local
+exec_prefix = $(prefix)
+
+OBJS = adler32.o compress.o crc32.o deflate.o gzclose.o gzlib.o gzread.o \
+       gzwrite.o infback.o inffast.o inflate.o inftrees.o trees.o uncompr.o zutil.o
+OBJA =
+
+all: $(STATICLIB) $(SHAREDLIB) $(IMPLIB) example.exe minigzip.exe example_d.exe minigzip_d.exe
+
+test: example.exe minigzip.exe
+	./example
+	echo hello world | ./minigzip | ./minigzip -d
+
+testdll: example_d.exe minigzip_d.exe
+	./example_d
+	echo hello world | ./minigzip_d | ./minigzip_d -d
+
+.c.o:
+	$(CC) $(CFLAGS) -c -o $@ $<
+
+.S.o:
+	$(AS) $(ASFLAGS) -c -o $@ $<
+
+$(STATICLIB): $(OBJS) $(OBJA)
+	$(AR) $(ARFLAGS) $@ $(OBJS) $(OBJA)
+
+$(IMPLIB): $(SHAREDLIB)
+
+$(SHAREDLIB): win32/zlib.def $(OBJS) $(OBJA) zlibrc.o
+	$(CC) -shared -Wl,--out-implib,$(IMPLIB) $(LDFLAGS) \
+	-o $@ win32/zlib.def $(OBJS) $(OBJA) zlibrc.o
+	$(STRIP) $@
+
+example.exe: example.o $(STATICLIB)
+	$(LD) $(LDFLAGS) -o $@ example.o $(STATICLIB)
+	$(STRIP) $@
+
+minigzip.exe: minigzip.o $(STATICLIB)
+	$(LD) $(LDFLAGS) -o $@ minigzip.o $(STATICLIB)
+	$(STRIP) $@
+
+example_d.exe: example.o $(IMPLIB)
+	$(LD) $(LDFLAGS) -o $@ example.o $(IMPLIB)
+	$(STRIP) $@
+
+minigzip_d.exe: minigzip.o $(IMPLIB)
+	$(LD) $(LDFLAGS) -o $@ minigzip.o $(IMPLIB)
+	$(STRIP) $@
+
+example.o: test/example.c zlib.h zconf.h
+	$(CC) $(CFLAGS) -I. -c -o $@ test/example.c
+
+minigzip.o: test/minigzip.c zlib.h zconf.h
+	$(CC) $(CFLAGS) -I. -c -o $@ test/minigzip.c
+
+zlibrc.o: win32/zlib1.rc
+	$(RC) $(RCFLAGS) -o $@ win32/zlib1.rc
+
+.PHONY: install uninstall clean
+
+install: zlib.h zconf.h $(STATICLIB) $(IMPLIB)
+	@if test -z "$(DESTDIR)$(INCLUDE_PATH)" -o -z "$(DESTDIR)$(LIBRARY_PATH)" -o -z "$(DESTDIR)$(BINARY_PATH)"; then \
+		echo INCLUDE_PATH, LIBRARY_PATH, and BINARY_PATH must be specified; \
+		exit 1; \
+	fi
+	-@mkdir -p '$(DESTDIR)$(INCLUDE_PATH)'
+	-@mkdir -p '$(DESTDIR)$(LIBRARY_PATH)' '$(DESTDIR)$(LIBRARY_PATH)'/pkgconfig
+	-if [ "$(SHARED_MODE)" = "1" ]; then \
+		mkdir -p '$(DESTDIR)$(BINARY_PATH)'; \
+		$(INSTALL) $(SHAREDLIB) '$(DESTDIR)$(BINARY_PATH)'; \
+		$(INSTALL) $(IMPLIB) '$(DESTDIR)$(LIBRARY_PATH)'; \
+	fi
+	-$(INSTALL) zlib.h '$(DESTDIR)$(INCLUDE_PATH)'
+	-$(INSTALL) zconf.h '$(DESTDIR)$(INCLUDE_PATH)'
+	-$(INSTALL) $(STATICLIB) '$(DESTDIR)$(LIBRARY_PATH)'
+	sed \
+		-e 's|@prefix@|${prefix}|g' \
+		-e 's|@exec_prefix@|${exec_prefix}|g' \
+		-e 's|@libdir@|$(LIBRARY_PATH)|g' \
+		-e 's|@sharedlibdir@|$(LIBRARY_PATH)|g' \
+		-e 's|@includedir@|$(INCLUDE_PATH)|g' \
+		-e 's|@VERSION@|'`sed -n -e '/VERSION "/s/.*"\(.*\)".*/\1/p' zlib.h`'|g' \
+		zlib.pc.in > '$(DESTDIR)$(LIBRARY_PATH)'/pkgconfig/zlib.pc
+
+uninstall:
+	-if [ "$(SHARED_MODE)" = "1" ]; then \
+		$(RM) '$(DESTDIR)$(BINARY_PATH)'/$(SHAREDLIB); \
+		$(RM) '$(DESTDIR)$(LIBRARY_PATH)'/$(IMPLIB); \
+	fi
+	-$(RM) '$(DESTDIR)$(INCLUDE_PATH)'/zlib.h
+	-$(RM) '$(DESTDIR)$(INCLUDE_PATH)'/zconf.h
+	-$(RM) '$(DESTDIR)$(LIBRARY_PATH)'/$(STATICLIB)
+
+clean:
+	-$(RM) $(STATICLIB)
+	-$(RM) $(SHAREDLIB)
+	-$(RM) $(IMPLIB)
+	-$(RM) *.o
+	-$(RM) *.exe
+	-$(RM) foo.gz
+
+adler32.o: zlib.h zconf.h
+compress.o: zlib.h zconf.h
+crc32.o: crc32.h zlib.h zconf.h
+deflate.o: deflate.h zutil.h zlib.h zconf.h
+gzclose.o: zlib.h zconf.h gzguts.h
+gzlib.o: zlib.h zconf.h gzguts.h
+gzread.o: zlib.h zconf.h gzguts.h
+gzwrite.o: zlib.h zconf.h gzguts.h
+inffast.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h
+inflate.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h
+infback.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h
+inftrees.o: zutil.h zlib.h zconf.h inftrees.h
+trees.o: deflate.h zutil.h zlib.h zconf.h trees.h
+uncompr.o: zlib.h zconf.h
+zutil.o: zutil.h zlib.h zconf.h
diff --git a/Engine/lib/assimp/contrib/zlib/win32/Makefile.msc b/Engine/lib/assimp/contrib/zlib/win32/Makefile.msc
new file mode 100644
index 000000000..6831882de
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/win32/Makefile.msc
@@ -0,0 +1,163 @@
+# Makefile for zlib using Microsoft (Visual) C
+# zlib is copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler
+#
+# Usage:
+#   nmake -f win32/Makefile.msc                          (standard build)
+#   nmake -f win32/Makefile.msc LOC=-DFOO                (nonstandard build)
+#   nmake -f win32/Makefile.msc LOC="-DASMV -DASMINF" \
+#         OBJA="inffas32.obj match686.obj"               (use ASM code, x86)
+#   nmake -f win32/Makefile.msc AS=ml64 LOC="-DASMV -DASMINF -I." \
+#         OBJA="inffasx64.obj gvmat64.obj inffas8664.obj"  (use ASM code, x64)
+
+# The toplevel directory of the source tree.
+#
+TOP = .
+
+# optional build flags
+LOC =
+
+# variables
+STATICLIB = zlib.lib
+SHAREDLIB = zlib1.dll
+IMPLIB    = zdll.lib
+
+CC = cl
+AS = ml
+LD = link
+AR = lib
+RC = rc
+CFLAGS  = -nologo -MD -W3 -O2 -Oy- -Zi -Fd"zlib" $(LOC)
+WFLAGS  = -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE
+ASFLAGS = -coff -Zi $(LOC)
+LDFLAGS = -nologo -debug -incremental:no -opt:ref
+ARFLAGS = -nologo
+RCFLAGS = /dWIN32 /r
+
+OBJS = adler32.obj compress.obj crc32.obj deflate.obj gzclose.obj gzlib.obj gzread.obj \
+       gzwrite.obj infback.obj inflate.obj inftrees.obj inffast.obj trees.obj uncompr.obj zutil.obj
+OBJA =
+
+
+# targets
+all: $(STATICLIB) $(SHAREDLIB) $(IMPLIB) \
+     example.exe minigzip.exe example_d.exe minigzip_d.exe
+
+$(STATICLIB): $(OBJS) $(OBJA)
+	$(AR) $(ARFLAGS) -out:$@ $(OBJS) $(OBJA)
+
+$(IMPLIB): $(SHAREDLIB)
+
+$(SHAREDLIB): $(TOP)/win32/zlib.def $(OBJS) $(OBJA) zlib1.res
+	$(LD) $(LDFLAGS) -def:$(TOP)/win32/zlib.def -dll -implib:$(IMPLIB) \
+	  -out:$@ -base:0x5A4C0000 $(OBJS) $(OBJA) zlib1.res
+	if exist $@.manifest \
+	  mt -nologo -manifest $@.manifest -outputresource:$@;2
+
+example.exe: example.obj $(STATICLIB)
+	$(LD) $(LDFLAGS) example.obj $(STATICLIB)
+	if exist $@.manifest \
+	  mt -nologo -manifest $@.manifest -outputresource:$@;1
+
+minigzip.exe: minigzip.obj $(STATICLIB)
+	$(LD) $(LDFLAGS) minigzip.obj $(STATICLIB)
+	if exist $@.manifest \
+	  mt -nologo -manifest $@.manifest -outputresource:$@;1
+
+example_d.exe: example.obj $(IMPLIB)
+	$(LD) $(LDFLAGS) -out:$@ example.obj $(IMPLIB)
+	if exist $@.manifest \
+	  mt -nologo -manifest $@.manifest -outputresource:$@;1
+
+minigzip_d.exe: minigzip.obj $(IMPLIB)
+	$(LD) $(LDFLAGS) -out:$@ minigzip.obj $(IMPLIB)
+	if exist $@.manifest \
+	  mt -nologo -manifest $@.manifest -outputresource:$@;1
+
+{$(TOP)}.c.obj:
+	$(CC) -c $(WFLAGS) $(CFLAGS) $<
+
+{$(TOP)/test}.c.obj:
+	$(CC) -c -I$(TOP) $(WFLAGS) $(CFLAGS) $<
+
+{$(TOP)/contrib/masmx64}.c.obj:
+	$(CC) -c $(WFLAGS) $(CFLAGS) $<
+
+{$(TOP)/contrib/masmx64}.asm.obj:
+	$(AS) -c $(ASFLAGS) $<
+
+{$(TOP)/contrib/masmx86}.asm.obj:
+	$(AS) -c $(ASFLAGS) $<
+
+adler32.obj: $(TOP)/adler32.c $(TOP)/zlib.h $(TOP)/zconf.h
+
+compress.obj: $(TOP)/compress.c $(TOP)/zlib.h $(TOP)/zconf.h
+
+crc32.obj: $(TOP)/crc32.c $(TOP)/zlib.h $(TOP)/zconf.h $(TOP)/crc32.h
+
+deflate.obj: $(TOP)/deflate.c $(TOP)/deflate.h $(TOP)/zutil.h $(TOP)/zlib.h $(TOP)/zconf.h
+
+gzclose.obj: $(TOP)/gzclose.c $(TOP)/zlib.h $(TOP)/zconf.h $(TOP)/gzguts.h
+
+gzlib.obj: $(TOP)/gzlib.c $(TOP)/zlib.h $(TOP)/zconf.h $(TOP)/gzguts.h
+
+gzread.obj: $(TOP)/gzread.c $(TOP)/zlib.h $(TOP)/zconf.h $(TOP)/gzguts.h
+
+gzwrite.obj: $(TOP)/gzwrite.c $(TOP)/zlib.h $(TOP)/zconf.h $(TOP)/gzguts.h
+
+infback.obj: $(TOP)/infback.c $(TOP)/zutil.h $(TOP)/zlib.h $(TOP)/zconf.h $(TOP)/inftrees.h $(TOP)/inflate.h \
+             $(TOP)/inffast.h $(TOP)/inffixed.h
+
+inffast.obj: $(TOP)/inffast.c $(TOP)/zutil.h $(TOP)/zlib.h $(TOP)/zconf.h $(TOP)/inftrees.h $(TOP)/inflate.h \
+             $(TOP)/inffast.h
+
+inflate.obj: $(TOP)/inflate.c $(TOP)/zutil.h $(TOP)/zlib.h $(TOP)/zconf.h $(TOP)/inftrees.h $(TOP)/inflate.h \
+             $(TOP)/inffast.h $(TOP)/inffixed.h
+
+inftrees.obj: $(TOP)/inftrees.c $(TOP)/zutil.h $(TOP)/zlib.h $(TOP)/zconf.h $(TOP)/inftrees.h
+
+trees.obj: $(TOP)/trees.c $(TOP)/zutil.h $(TOP)/zlib.h $(TOP)/zconf.h $(TOP)/deflate.h $(TOP)/trees.h
+
+uncompr.obj: $(TOP)/uncompr.c $(TOP)/zlib.h $(TOP)/zconf.h
+
+zutil.obj: $(TOP)/zutil.c $(TOP)/zutil.h $(TOP)/zlib.h $(TOP)/zconf.h
+
+gvmat64.obj: $(TOP)/contrib\masmx64\gvmat64.asm
+
+inffasx64.obj: $(TOP)/contrib\masmx64\inffasx64.asm
+
+inffas8664.obj: $(TOP)/contrib\masmx64\inffas8664.c $(TOP)/zutil.h $(TOP)/zlib.h $(TOP)/zconf.h \
+		$(TOP)/inftrees.h $(TOP)/inflate.h $(TOP)/inffast.h
+
+inffas32.obj: $(TOP)/contrib\masmx86\inffas32.asm
+
+match686.obj: $(TOP)/contrib\masmx86\match686.asm
+
+example.obj: $(TOP)/test/example.c $(TOP)/zlib.h $(TOP)/zconf.h
+
+minigzip.obj: $(TOP)/test/minigzip.c $(TOP)/zlib.h $(TOP)/zconf.h
+
+zlib1.res: $(TOP)/win32/zlib1.rc
+	$(RC) $(RCFLAGS) /fo$@ $(TOP)/win32/zlib1.rc
+
+# testing
+test: example.exe minigzip.exe
+	example
+	echo hello world | minigzip | minigzip -d
+
+testdll: example_d.exe minigzip_d.exe
+	example_d
+	echo hello world | minigzip_d | minigzip_d -d
+
+
+# cleanup
+clean:
+	-del $(STATICLIB)
+	-del $(SHAREDLIB)
+	-del $(IMPLIB)
+	-del *.obj
+	-del *.res
+	-del *.exp
+	-del *.exe
+	-del *.pdb
+	-del *.manifest
+	-del foo.gz
diff --git a/Engine/lib/assimp/contrib/zlib/win32/README-WIN32.txt b/Engine/lib/assimp/contrib/zlib/win32/README-WIN32.txt
new file mode 100644
index 000000000..a1de359a3
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/win32/README-WIN32.txt
@@ -0,0 +1,103 @@
+ZLIB DATA COMPRESSION LIBRARY
+
+zlib 1.2.11.1 is a general purpose data compression library.  All the code is
+thread safe.  The data format used by the zlib library is described by RFCs
+(Request for Comments) 1950 to 1952 in the files
+http://www.ietf.org/rfc/rfc1950.txt (zlib format), rfc1951.txt (deflate format)
+and rfc1952.txt (gzip format).
+
+All functions of the compression library are documented in the file zlib.h
+(volunteer to write man pages welcome, contact zlib@gzip.org).  Two compiled
+examples are distributed in this package, example and minigzip.  The example_d
+and minigzip_d flavors validate that the zlib1.dll file is working correctly.
+
+Questions about zlib should be sent to <zlib@gzip.org>.  The zlib home page
+is http://zlib.net/ .  Before reporting a problem, please check this site to
+verify that you have the latest version of zlib; otherwise get the latest
+version and check whether the problem still exists or not.
+
+PLEASE read DLL_FAQ.txt, and the the zlib FAQ http://zlib.net/zlib_faq.html
+before asking for help.
+
+
+Manifest:
+
+The package zlib-1.2.11.1-win32-x86.zip will contain the following files:
+
+  README-WIN32.txt This document
+  ChangeLog        Changes since previous zlib packages
+  DLL_FAQ.txt      Frequently asked questions about zlib1.dll
+  zlib.3.pdf       Documentation of this library in Adobe Acrobat format
+
+  example.exe      A statically-bound example (using zlib.lib, not the dll)
+  example.pdb      Symbolic information for debugging example.exe
+
+  example_d.exe    A zlib1.dll bound example (using zdll.lib)
+  example_d.pdb    Symbolic information for debugging example_d.exe
+
+  minigzip.exe     A statically-bound test program (using zlib.lib, not the dll)
+  minigzip.pdb     Symbolic information for debugging minigzip.exe
+
+  minigzip_d.exe   A zlib1.dll bound test program (using zdll.lib)
+  minigzip_d.pdb   Symbolic information for debugging minigzip_d.exe
+
+  zlib.h           Install these files into the compilers' INCLUDE path to
+  zconf.h          compile programs which use zlib.lib or zdll.lib
+
+  zdll.lib         Install these files into the compilers' LIB path if linking
+  zdll.exp         a compiled program to the zlib1.dll binary
+
+  zlib.lib         Install these files into the compilers' LIB path to link zlib
+  zlib.pdb         into compiled programs, without zlib1.dll runtime dependency
+                   (zlib.pdb provides debugging info to the compile time linker)
+
+  zlib1.dll        Install this binary shared library into the system PATH, or
+                   the program's runtime directory (where the .exe resides)
+  zlib1.pdb        Install in the same directory as zlib1.dll, in order to debug
+                   an application crash using WinDbg or similar tools.
+
+All .pdb files above are entirely optional, but are very useful to a developer
+attempting to diagnose program misbehavior or a crash.  Many additional
+important files for developers can be found in the zlib127.zip source package
+available from http://zlib.net/ - review that package's README file for details.
+
+
+Acknowledgments:
+
+The deflate format used by zlib was defined by Phil Katz.  The deflate and
+zlib specifications were written by L.  Peter Deutsch.  Thanks to all the
+people who reported problems and suggested various improvements in zlib; they
+are too numerous to cite here.
+
+
+Copyright notice:
+
+  (C) 1995-2017 Jean-loup Gailly and Mark Adler
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Jean-loup Gailly        Mark Adler
+  jloup@gzip.org          madler@alumni.caltech.edu
+
+If you use the zlib library in a product, we would appreciate *not* receiving
+lengthy legal documents to sign.  The sources are provided for free but without
+warranty of any kind.  The library has been entirely written by Jean-loup
+Gailly and Mark Adler; it does not include third-party code.
+
+If you redistribute modified sources, we would appreciate that you include in
+the file ChangeLog history information documenting your changes.  Please read
+the FAQ for more information on the distribution of modified source versions.
diff --git a/Engine/lib/assimp/contrib/zlib/win32/VisualC.txt b/Engine/lib/assimp/contrib/zlib/win32/VisualC.txt
new file mode 100644
index 000000000..1005b2194
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/win32/VisualC.txt
@@ -0,0 +1,3 @@
+
+To build zlib using the Microsoft Visual C++ environment,
+use the appropriate project from the contrib/vstudio/ directory.
diff --git a/Engine/lib/assimp/contrib/zlib/win32/zlib.def b/Engine/lib/assimp/contrib/zlib/win32/zlib.def
new file mode 100644
index 000000000..a2188b000
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/win32/zlib.def
@@ -0,0 +1,94 @@
+; zlib data compression library
+EXPORTS
+; basic functions
+    zlibVersion
+    deflate
+    deflateEnd
+    inflate
+    inflateEnd
+; advanced functions
+    deflateSetDictionary
+    deflateGetDictionary
+    deflateCopy
+    deflateReset
+    deflateParams
+    deflateTune
+    deflateBound
+    deflatePending
+    deflatePrime
+    deflateSetHeader
+    inflateSetDictionary
+    inflateGetDictionary
+    inflateSync
+    inflateCopy
+    inflateReset
+    inflateReset2
+    inflatePrime
+    inflateMark
+    inflateGetHeader
+    inflateBack
+    inflateBackEnd
+    zlibCompileFlags
+; utility functions
+    compress
+    compress2
+    compressBound
+    uncompress
+    uncompress2
+    gzopen
+    gzdopen
+    gzbuffer
+    gzsetparams
+    gzread
+    gzfread
+    gzwrite
+    gzfwrite
+    gzprintf
+    gzvprintf
+    gzputs
+    gzgets
+    gzputc
+    gzgetc
+    gzungetc
+    gzflush
+    gzseek
+    gzrewind
+    gztell
+    gzoffset
+    gzeof
+    gzdirect
+    gzclose
+    gzclose_r
+    gzclose_w
+    gzerror
+    gzclearerr
+; large file functions
+    gzopen64
+    gzseek64
+    gztell64
+    gzoffset64
+    adler32_combine64
+    crc32_combine64
+; checksum functions
+    adler32
+    adler32_z
+    crc32
+    crc32_z
+    adler32_combine
+    crc32_combine
+; various hacks, don't look :)
+    deflateInit_
+    deflateInit2_
+    inflateInit_
+    inflateInit2_
+    inflateBackInit_
+    gzgetc_
+    zError
+    inflateSyncPoint
+    get_crc_table
+    inflateUndermine
+    inflateValidate
+    inflateCodesUsed
+    inflateResetKeep
+    deflateResetKeep
+    gzopen_w
diff --git a/Engine/lib/assimp/contrib/zlib/win32/zlib1.rc b/Engine/lib/assimp/contrib/zlib/win32/zlib1.rc
new file mode 100644
index 000000000..234e641c3
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/win32/zlib1.rc
@@ -0,0 +1,40 @@
+#include <winver.h>
+#include "../zlib.h"
+
+#ifdef GCC_WINDRES
+VS_VERSION_INFO		VERSIONINFO
+#else
+VS_VERSION_INFO		VERSIONINFO	MOVEABLE IMPURE LOADONCALL DISCARDABLE
+#endif
+  FILEVERSION		ZLIB_VER_MAJOR,ZLIB_VER_MINOR,ZLIB_VER_REVISION,0
+  PRODUCTVERSION	ZLIB_VER_MAJOR,ZLIB_VER_MINOR,ZLIB_VER_REVISION,0
+  FILEFLAGSMASK		VS_FFI_FILEFLAGSMASK
+#ifdef _DEBUG
+  FILEFLAGS		1
+#else
+  FILEFLAGS		0
+#endif
+  FILEOS		VOS__WINDOWS32
+  FILETYPE		VFT_DLL
+  FILESUBTYPE		0	// not used
+BEGIN
+  BLOCK "StringFileInfo"
+  BEGIN
+    BLOCK "040904E4"
+    //language ID = U.S. English, char set = Windows, Multilingual
+    BEGIN
+      VALUE "FileDescription",	"zlib data compression library\0"
+      VALUE "FileVersion",	ZLIB_VERSION "\0"
+      VALUE "InternalName",	"zlib1.dll\0"
+      VALUE "LegalCopyright",	"(C) 1995-2017 Jean-loup Gailly & Mark Adler\0"
+      VALUE "OriginalFilename",	"zlib1.dll\0"
+      VALUE "ProductName",	"zlib\0"
+      VALUE "ProductVersion",	ZLIB_VERSION "\0"
+      VALUE "Comments",		"For more information visit http://www.zlib.net/\0"
+    END
+  END
+  BLOCK "VarFileInfo"
+  BEGIN
+    VALUE "Translation", 0x0409, 1252
+  END
+END
diff --git a/Engine/lib/assimp/contrib/zlib/zconf.h.cmakein b/Engine/lib/assimp/contrib/zlib/zconf.h.cmakein
new file mode 100644
index 000000000..a7f24cce6
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/zconf.h.cmakein
@@ -0,0 +1,536 @@
+/* zconf.h -- configuration of the zlib compression library
+ * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#ifndef ZCONF_H
+#define ZCONF_H
+#cmakedefine Z_PREFIX
+#cmakedefine Z_HAVE_UNISTD_H
+
+/*
+ * If you *really* need a unique prefix for all types and library functions,
+ * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
+ * Even better than compiling with -DZ_PREFIX would be to use configure to set
+ * this permanently in zconf.h using "./configure --zprefix".
+ */
+#ifdef Z_PREFIX     /* may be set to #if 1 by ./configure */
+#  define Z_PREFIX_SET
+
+/* all linked symbols and init macros */
+#  define _dist_code            z__dist_code
+#  define _length_code          z__length_code
+#  define _tr_align             z__tr_align
+#  define _tr_flush_bits        z__tr_flush_bits
+#  define _tr_flush_block       z__tr_flush_block
+#  define _tr_init              z__tr_init
+#  define _tr_stored_block      z__tr_stored_block
+#  define _tr_tally             z__tr_tally
+#  define adler32               z_adler32
+#  define adler32_combine       z_adler32_combine
+#  define adler32_combine64     z_adler32_combine64
+#  define adler32_z             z_adler32_z
+#  ifndef Z_SOLO
+#    define compress              z_compress
+#    define compress2             z_compress2
+#    define compressBound         z_compressBound
+#  endif
+#  define crc32                 z_crc32
+#  define crc32_combine         z_crc32_combine
+#  define crc32_combine64       z_crc32_combine64
+#  define crc32_z               z_crc32_z
+#  define deflate               z_deflate
+#  define deflateBound          z_deflateBound
+#  define deflateCopy           z_deflateCopy
+#  define deflateEnd            z_deflateEnd
+#  define deflateGetDictionary  z_deflateGetDictionary
+#  define deflateInit           z_deflateInit
+#  define deflateInit2          z_deflateInit2
+#  define deflateInit2_         z_deflateInit2_
+#  define deflateInit_          z_deflateInit_
+#  define deflateParams         z_deflateParams
+#  define deflatePending        z_deflatePending
+#  define deflatePrime          z_deflatePrime
+#  define deflateReset          z_deflateReset
+#  define deflateResetKeep      z_deflateResetKeep
+#  define deflateSetDictionary  z_deflateSetDictionary
+#  define deflateSetHeader      z_deflateSetHeader
+#  define deflateTune           z_deflateTune
+#  define deflate_copyright     z_deflate_copyright
+#  define get_crc_table         z_get_crc_table
+#  ifndef Z_SOLO
+#    define gz_error              z_gz_error
+#    define gz_intmax             z_gz_intmax
+#    define gz_strwinerror        z_gz_strwinerror
+#    define gzbuffer              z_gzbuffer
+#    define gzclearerr            z_gzclearerr
+#    define gzclose               z_gzclose
+#    define gzclose_r             z_gzclose_r
+#    define gzclose_w             z_gzclose_w
+#    define gzdirect              z_gzdirect
+#    define gzdopen               z_gzdopen
+#    define gzeof                 z_gzeof
+#    define gzerror               z_gzerror
+#    define gzflush               z_gzflush
+#    define gzfread               z_gzfread
+#    define gzfwrite              z_gzfwrite
+#    define gzgetc                z_gzgetc
+#    define gzgetc_               z_gzgetc_
+#    define gzgets                z_gzgets
+#    define gzoffset              z_gzoffset
+#    define gzoffset64            z_gzoffset64
+#    define gzopen                z_gzopen
+#    define gzopen64              z_gzopen64
+#    ifdef _WIN32
+#      define gzopen_w              z_gzopen_w
+#    endif
+#    define gzprintf              z_gzprintf
+#    define gzputc                z_gzputc
+#    define gzputs                z_gzputs
+#    define gzread                z_gzread
+#    define gzrewind              z_gzrewind
+#    define gzseek                z_gzseek
+#    define gzseek64              z_gzseek64
+#    define gzsetparams           z_gzsetparams
+#    define gztell                z_gztell
+#    define gztell64              z_gztell64
+#    define gzungetc              z_gzungetc
+#    define gzvprintf             z_gzvprintf
+#    define gzwrite               z_gzwrite
+#  endif
+#  define inflate               z_inflate
+#  define inflateBack           z_inflateBack
+#  define inflateBackEnd        z_inflateBackEnd
+#  define inflateBackInit       z_inflateBackInit
+#  define inflateBackInit_      z_inflateBackInit_
+#  define inflateCodesUsed      z_inflateCodesUsed
+#  define inflateCopy           z_inflateCopy
+#  define inflateEnd            z_inflateEnd
+#  define inflateGetDictionary  z_inflateGetDictionary
+#  define inflateGetHeader      z_inflateGetHeader
+#  define inflateInit           z_inflateInit
+#  define inflateInit2          z_inflateInit2
+#  define inflateInit2_         z_inflateInit2_
+#  define inflateInit_          z_inflateInit_
+#  define inflateMark           z_inflateMark
+#  define inflatePrime          z_inflatePrime
+#  define inflateReset          z_inflateReset
+#  define inflateReset2         z_inflateReset2
+#  define inflateResetKeep      z_inflateResetKeep
+#  define inflateSetDictionary  z_inflateSetDictionary
+#  define inflateSync           z_inflateSync
+#  define inflateSyncPoint      z_inflateSyncPoint
+#  define inflateUndermine      z_inflateUndermine
+#  define inflateValidate       z_inflateValidate
+#  define inflate_copyright     z_inflate_copyright
+#  define inflate_fast          z_inflate_fast
+#  define inflate_table         z_inflate_table
+#  ifndef Z_SOLO
+#    define uncompress            z_uncompress
+#    define uncompress2           z_uncompress2
+#  endif
+#  define zError                z_zError
+#  ifndef Z_SOLO
+#    define zcalloc               z_zcalloc
+#    define zcfree                z_zcfree
+#  endif
+#  define zlibCompileFlags      z_zlibCompileFlags
+#  define zlibVersion           z_zlibVersion
+
+/* all zlib typedefs in zlib.h and zconf.h */
+#  define Byte                  z_Byte
+#  define Bytef                 z_Bytef
+#  define alloc_func            z_alloc_func
+#  define charf                 z_charf
+#  define free_func             z_free_func
+#  ifndef Z_SOLO
+#    define gzFile                z_gzFile
+#  endif
+#  define gz_header             z_gz_header
+#  define gz_headerp            z_gz_headerp
+#  define in_func               z_in_func
+#  define intf                  z_intf
+#  define out_func              z_out_func
+#  define uInt                  z_uInt
+#  define uIntf                 z_uIntf
+#  define uLong                 z_uLong
+#  define uLongf                z_uLongf
+#  define voidp                 z_voidp
+#  define voidpc                z_voidpc
+#  define voidpf                z_voidpf
+
+/* all zlib structs in zlib.h and zconf.h */
+#  define gz_header_s           z_gz_header_s
+#  define internal_state        z_internal_state
+
+#endif
+
+#if defined(__MSDOS__) && !defined(MSDOS)
+#  define MSDOS
+#endif
+#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
+#  define OS2
+#endif
+#if defined(_WINDOWS) && !defined(WINDOWS)
+#  define WINDOWS
+#endif
+#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
+#  ifndef WIN32
+#    define WIN32
+#  endif
+#endif
+#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
+#  if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
+#    ifndef SYS16BIT
+#      define SYS16BIT
+#    endif
+#  endif
+#endif
+
+/*
+ * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
+ * than 64k bytes at a time (needed on systems with 16-bit int).
+ */
+#ifdef SYS16BIT
+#  define MAXSEG_64K
+#endif
+#ifdef MSDOS
+#  define UNALIGNED_OK
+#endif
+
+#ifdef __STDC_VERSION__
+#  ifndef STDC
+#    define STDC
+#  endif
+#  if __STDC_VERSION__ >= 199901L
+#    ifndef STDC99
+#      define STDC99
+#    endif
+#  endif
+#endif
+#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
+#  define STDC
+#endif
+
+#if defined(__OS400__) && !defined(STDC)    /* iSeries (formerly AS/400). */
+#  define STDC
+#endif
+
+#ifndef STDC
+#  ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
+#    define const       /* note: need a more gentle solution here */
+#  endif
+#endif
+
+#if defined(ZLIB_CONST) && !defined(z_const)
+#  define z_const const
+#else
+#  define z_const
+#endif
+
+#ifdef Z_SOLO
+   typedef unsigned long z_size_t;
+#else
+#  define z_longlong long long
+#  if defined(NO_SIZE_T)
+     typedef unsigned NO_SIZE_T z_size_t;
+#  elif defined(STDC)
+#    include <stddef.h>
+     typedef size_t z_size_t;
+#  else
+     typedef unsigned long z_size_t;
+#  endif
+#  undef z_longlong
+#endif
+
+/* Maximum value for memLevel in deflateInit2 */
+#ifndef MAX_MEM_LEVEL
+#  ifdef MAXSEG_64K
+#    define MAX_MEM_LEVEL 8
+#  else
+#    define MAX_MEM_LEVEL 9
+#  endif
+#endif
+
+/* Maximum value for windowBits in deflateInit2 and inflateInit2.
+ * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
+ * created by gzip. (Files created by minigzip can still be extracted by
+ * gzip.)
+ */
+#ifndef MAX_WBITS
+#  define MAX_WBITS   15 /* 32K LZ77 window */
+#endif
+
+/* The memory requirements for deflate are (in bytes):
+            (1 << (windowBits+2)) +  (1 << (memLevel+9))
+ that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
+ plus a few kilobytes for small objects. For example, if you want to reduce
+ the default memory requirements from 256K to 128K, compile with
+     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
+ Of course this will generally degrade compression (there's no free lunch).
+
+   The memory requirements for inflate are (in bytes) 1 << windowBits
+ that is, 32K for windowBits=15 (default value) plus about 7 kilobytes
+ for small objects.
+*/
+
+                        /* Type declarations */
+
+#ifndef OF /* function prototypes */
+#  ifdef STDC
+#    define OF(args)  args
+#  else
+#    define OF(args)  ()
+#  endif
+#endif
+
+#ifndef Z_ARG /* function prototypes for stdarg */
+#  if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#    define Z_ARG(args)  args
+#  else
+#    define Z_ARG(args)  ()
+#  endif
+#endif
+
+/* The following definitions for FAR are needed only for MSDOS mixed
+ * model programming (small or medium model with some far allocations).
+ * This was tested only with MSC; for other MSDOS compilers you may have
+ * to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
+ * just define FAR to be empty.
+ */
+#ifdef SYS16BIT
+#  if defined(M_I86SM) || defined(M_I86MM)
+     /* MSC small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef _MSC_VER
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#  if (defined(__SMALL__) || defined(__MEDIUM__))
+     /* Turbo C small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef __BORLANDC__
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#endif
+
+#if defined(WINDOWS) || defined(WIN32)
+   /* If building or using zlib as a DLL, define ZLIB_DLL.
+    * This is not mandatory, but it offers a little performance increase.
+    */
+#  ifdef ZLIB_DLL
+#    if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
+#      ifdef ZLIB_INTERNAL
+#        define ZEXTERN extern __declspec(dllexport)
+#      else
+#        define ZEXTERN extern __declspec(dllimport)
+#      endif
+#    endif
+#  endif  /* ZLIB_DLL */
+   /* If building or using zlib with the WINAPI/WINAPIV calling convention,
+    * define ZLIB_WINAPI.
+    * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
+    */
+#  ifdef ZLIB_WINAPI
+#    ifdef FAR
+#      undef FAR
+#    endif
+#    include <windows.h>
+     /* No need for _export, use ZLIB.DEF instead. */
+     /* For complete Windows compatibility, use WINAPI, not __stdcall. */
+#    define ZEXPORT WINAPI
+#    ifdef WIN32
+#      define ZEXPORTVA WINAPIV
+#    else
+#      define ZEXPORTVA FAR CDECL
+#    endif
+#  endif
+#endif
+
+#if defined (__BEOS__)
+#  ifdef ZLIB_DLL
+#    ifdef ZLIB_INTERNAL
+#      define ZEXPORT   __declspec(dllexport)
+#      define ZEXPORTVA __declspec(dllexport)
+#    else
+#      define ZEXPORT   __declspec(dllimport)
+#      define ZEXPORTVA __declspec(dllimport)
+#    endif
+#  endif
+#endif
+
+#ifndef ZEXTERN
+#  define ZEXTERN extern
+#endif
+#ifndef ZEXPORT
+#  define ZEXPORT
+#endif
+#ifndef ZEXPORTVA
+#  define ZEXPORTVA
+#endif
+
+#ifndef FAR
+#  define FAR
+#endif
+
+#if !defined(__MACTYPES__)
+typedef unsigned char  Byte;  /* 8 bits */
+#endif
+typedef unsigned int   uInt;  /* 16 bits or more */
+typedef unsigned long  uLong; /* 32 bits or more */
+
+#ifdef SMALL_MEDIUM
+   /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
+#  define Bytef Byte FAR
+#else
+   typedef Byte  FAR Bytef;
+#endif
+typedef char  FAR charf;
+typedef int   FAR intf;
+typedef uInt  FAR uIntf;
+typedef uLong FAR uLongf;
+
+#ifdef STDC
+   typedef void const *voidpc;
+   typedef void FAR   *voidpf;
+   typedef void       *voidp;
+#else
+   typedef Byte const *voidpc;
+   typedef Byte FAR   *voidpf;
+   typedef Byte       *voidp;
+#endif
+
+#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC)
+#  include <limits.h>
+#  if (UINT_MAX == 0xffffffffUL)
+#    define Z_U4 unsigned
+#  elif (ULONG_MAX == 0xffffffffUL)
+#    define Z_U4 unsigned long
+#  elif (USHRT_MAX == 0xffffffffUL)
+#    define Z_U4 unsigned short
+#  endif
+#endif
+
+#ifdef Z_U4
+   typedef Z_U4 z_crc_t;
+#else
+   typedef unsigned long z_crc_t;
+#endif
+
+#ifdef HAVE_UNISTD_H    /* may be set to #if 1 by ./configure */
+#  define Z_HAVE_UNISTD_H
+#endif
+
+#ifdef HAVE_STDARG_H    /* may be set to #if 1 by ./configure */
+#  define Z_HAVE_STDARG_H
+#endif
+
+#ifdef STDC
+#  ifndef Z_SOLO
+#    include <sys/types.h>      /* for off_t */
+#  endif
+#endif
+
+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#  ifndef Z_SOLO
+#    include <stdarg.h>         /* for va_list */
+#  endif
+#endif
+
+#ifdef _WIN32
+#  ifndef Z_SOLO
+#    include <stddef.h>         /* for wchar_t */
+#  endif
+#endif
+
+/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and
+ * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even
+ * though the former does not conform to the LFS document), but considering
+ * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as
+ * equivalently requesting no 64-bit operations
+ */
+#if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1
+#  undef _LARGEFILE64_SOURCE
+#endif
+
+#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H)
+#  define Z_HAVE_UNISTD_H
+#endif
+#ifndef Z_SOLO
+#  if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE)
+#    include <unistd.h>         /* for SEEK_*, off_t, and _LFS64_LARGEFILE */
+#    ifdef VMS
+#      include <unixio.h>       /* for off_t */
+#    endif
+#    ifndef z_off_t
+#      define z_off_t off_t
+#    endif
+#  endif
+#endif
+
+#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0
+#  define Z_LFS64
+#endif
+
+#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64)
+#  define Z_LARGE64
+#endif
+
+#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64)
+#  define Z_WANT64
+#endif
+
+#if !defined(SEEK_SET) && !defined(Z_SOLO)
+#  define SEEK_SET        0       /* Seek from beginning of file.  */
+#  define SEEK_CUR        1       /* Seek from current position.  */
+#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
+#endif
+
+#ifndef z_off_t
+#  define z_off_t long
+#endif
+
+#if !defined(_WIN32) && defined(Z_LARGE64)
+#  define z_off64_t off64_t
+#else
+#  if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO)
+#    define z_off64_t __int64
+#  else
+#    define z_off64_t z_off_t
+#  endif
+#endif
+
+/* MVS linker does not support external names larger than 8 bytes */
+#if defined(__MVS__)
+  #pragma map(deflateInit_,"DEIN")
+  #pragma map(deflateInit2_,"DEIN2")
+  #pragma map(deflateEnd,"DEEND")
+  #pragma map(deflateBound,"DEBND")
+  #pragma map(inflateInit_,"ININ")
+  #pragma map(inflateInit2_,"ININ2")
+  #pragma map(inflateEnd,"INEND")
+  #pragma map(inflateSync,"INSY")
+  #pragma map(inflateSetDictionary,"INSEDI")
+  #pragma map(compressBound,"CMBND")
+  #pragma map(inflate_table,"INTABL")
+  #pragma map(inflate_fast,"INFA")
+  #pragma map(inflate_copyright,"INCOPY")
+#endif
+
+#endif /* ZCONF_H */
diff --git a/Engine/lib/assimp/contrib/zlib/zconf.h.in b/Engine/lib/assimp/contrib/zlib/zconf.h.in
new file mode 100644
index 000000000..5e1d68a00
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/zconf.h.in
@@ -0,0 +1,534 @@
+/* zconf.h -- configuration of the zlib compression library
+ * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#ifndef ZCONF_H
+#define ZCONF_H
+
+/*
+ * If you *really* need a unique prefix for all types and library functions,
+ * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
+ * Even better than compiling with -DZ_PREFIX would be to use configure to set
+ * this permanently in zconf.h using "./configure --zprefix".
+ */
+#ifdef Z_PREFIX     /* may be set to #if 1 by ./configure */
+#  define Z_PREFIX_SET
+
+/* all linked symbols and init macros */
+#  define _dist_code            z__dist_code
+#  define _length_code          z__length_code
+#  define _tr_align             z__tr_align
+#  define _tr_flush_bits        z__tr_flush_bits
+#  define _tr_flush_block       z__tr_flush_block
+#  define _tr_init              z__tr_init
+#  define _tr_stored_block      z__tr_stored_block
+#  define _tr_tally             z__tr_tally
+#  define adler32               z_adler32
+#  define adler32_combine       z_adler32_combine
+#  define adler32_combine64     z_adler32_combine64
+#  define adler32_z             z_adler32_z
+#  ifndef Z_SOLO
+#    define compress              z_compress
+#    define compress2             z_compress2
+#    define compressBound         z_compressBound
+#  endif
+#  define crc32                 z_crc32
+#  define crc32_combine         z_crc32_combine
+#  define crc32_combine64       z_crc32_combine64
+#  define crc32_z               z_crc32_z
+#  define deflate               z_deflate
+#  define deflateBound          z_deflateBound
+#  define deflateCopy           z_deflateCopy
+#  define deflateEnd            z_deflateEnd
+#  define deflateGetDictionary  z_deflateGetDictionary
+#  define deflateInit           z_deflateInit
+#  define deflateInit2          z_deflateInit2
+#  define deflateInit2_         z_deflateInit2_
+#  define deflateInit_          z_deflateInit_
+#  define deflateParams         z_deflateParams
+#  define deflatePending        z_deflatePending
+#  define deflatePrime          z_deflatePrime
+#  define deflateReset          z_deflateReset
+#  define deflateResetKeep      z_deflateResetKeep
+#  define deflateSetDictionary  z_deflateSetDictionary
+#  define deflateSetHeader      z_deflateSetHeader
+#  define deflateTune           z_deflateTune
+#  define deflate_copyright     z_deflate_copyright
+#  define get_crc_table         z_get_crc_table
+#  ifndef Z_SOLO
+#    define gz_error              z_gz_error
+#    define gz_intmax             z_gz_intmax
+#    define gz_strwinerror        z_gz_strwinerror
+#    define gzbuffer              z_gzbuffer
+#    define gzclearerr            z_gzclearerr
+#    define gzclose               z_gzclose
+#    define gzclose_r             z_gzclose_r
+#    define gzclose_w             z_gzclose_w
+#    define gzdirect              z_gzdirect
+#    define gzdopen               z_gzdopen
+#    define gzeof                 z_gzeof
+#    define gzerror               z_gzerror
+#    define gzflush               z_gzflush
+#    define gzfread               z_gzfread
+#    define gzfwrite              z_gzfwrite
+#    define gzgetc                z_gzgetc
+#    define gzgetc_               z_gzgetc_
+#    define gzgets                z_gzgets
+#    define gzoffset              z_gzoffset
+#    define gzoffset64            z_gzoffset64
+#    define gzopen                z_gzopen
+#    define gzopen64              z_gzopen64
+#    ifdef _WIN32
+#      define gzopen_w              z_gzopen_w
+#    endif
+#    define gzprintf              z_gzprintf
+#    define gzputc                z_gzputc
+#    define gzputs                z_gzputs
+#    define gzread                z_gzread
+#    define gzrewind              z_gzrewind
+#    define gzseek                z_gzseek
+#    define gzseek64              z_gzseek64
+#    define gzsetparams           z_gzsetparams
+#    define gztell                z_gztell
+#    define gztell64              z_gztell64
+#    define gzungetc              z_gzungetc
+#    define gzvprintf             z_gzvprintf
+#    define gzwrite               z_gzwrite
+#  endif
+#  define inflate               z_inflate
+#  define inflateBack           z_inflateBack
+#  define inflateBackEnd        z_inflateBackEnd
+#  define inflateBackInit       z_inflateBackInit
+#  define inflateBackInit_      z_inflateBackInit_
+#  define inflateCodesUsed      z_inflateCodesUsed
+#  define inflateCopy           z_inflateCopy
+#  define inflateEnd            z_inflateEnd
+#  define inflateGetDictionary  z_inflateGetDictionary
+#  define inflateGetHeader      z_inflateGetHeader
+#  define inflateInit           z_inflateInit
+#  define inflateInit2          z_inflateInit2
+#  define inflateInit2_         z_inflateInit2_
+#  define inflateInit_          z_inflateInit_
+#  define inflateMark           z_inflateMark
+#  define inflatePrime          z_inflatePrime
+#  define inflateReset          z_inflateReset
+#  define inflateReset2         z_inflateReset2
+#  define inflateResetKeep      z_inflateResetKeep
+#  define inflateSetDictionary  z_inflateSetDictionary
+#  define inflateSync           z_inflateSync
+#  define inflateSyncPoint      z_inflateSyncPoint
+#  define inflateUndermine      z_inflateUndermine
+#  define inflateValidate       z_inflateValidate
+#  define inflate_copyright     z_inflate_copyright
+#  define inflate_fast          z_inflate_fast
+#  define inflate_table         z_inflate_table
+#  ifndef Z_SOLO
+#    define uncompress            z_uncompress
+#    define uncompress2           z_uncompress2
+#  endif
+#  define zError                z_zError
+#  ifndef Z_SOLO
+#    define zcalloc               z_zcalloc
+#    define zcfree                z_zcfree
+#  endif
+#  define zlibCompileFlags      z_zlibCompileFlags
+#  define zlibVersion           z_zlibVersion
+
+/* all zlib typedefs in zlib.h and zconf.h */
+#  define Byte                  z_Byte
+#  define Bytef                 z_Bytef
+#  define alloc_func            z_alloc_func
+#  define charf                 z_charf
+#  define free_func             z_free_func
+#  ifndef Z_SOLO
+#    define gzFile                z_gzFile
+#  endif
+#  define gz_header             z_gz_header
+#  define gz_headerp            z_gz_headerp
+#  define in_func               z_in_func
+#  define intf                  z_intf
+#  define out_func              z_out_func
+#  define uInt                  z_uInt
+#  define uIntf                 z_uIntf
+#  define uLong                 z_uLong
+#  define uLongf                z_uLongf
+#  define voidp                 z_voidp
+#  define voidpc                z_voidpc
+#  define voidpf                z_voidpf
+
+/* all zlib structs in zlib.h and zconf.h */
+#  define gz_header_s           z_gz_header_s
+#  define internal_state        z_internal_state
+
+#endif
+
+#if defined(__MSDOS__) && !defined(MSDOS)
+#  define MSDOS
+#endif
+#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
+#  define OS2
+#endif
+#if defined(_WINDOWS) && !defined(WINDOWS)
+#  define WINDOWS
+#endif
+#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
+#  ifndef WIN32
+#    define WIN32
+#  endif
+#endif
+#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
+#  if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
+#    ifndef SYS16BIT
+#      define SYS16BIT
+#    endif
+#  endif
+#endif
+
+/*
+ * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
+ * than 64k bytes at a time (needed on systems with 16-bit int).
+ */
+#ifdef SYS16BIT
+#  define MAXSEG_64K
+#endif
+#ifdef MSDOS
+#  define UNALIGNED_OK
+#endif
+
+#ifdef __STDC_VERSION__
+#  ifndef STDC
+#    define STDC
+#  endif
+#  if __STDC_VERSION__ >= 199901L
+#    ifndef STDC99
+#      define STDC99
+#    endif
+#  endif
+#endif
+#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
+#  define STDC
+#endif
+
+#if defined(__OS400__) && !defined(STDC)    /* iSeries (formerly AS/400). */
+#  define STDC
+#endif
+
+#ifndef STDC
+#  ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
+#    define const       /* note: need a more gentle solution here */
+#  endif
+#endif
+
+#if defined(ZLIB_CONST) && !defined(z_const)
+#  define z_const const
+#else
+#  define z_const
+#endif
+
+#ifdef Z_SOLO
+   typedef unsigned long z_size_t;
+#else
+#  define z_longlong long long
+#  if defined(NO_SIZE_T)
+     typedef unsigned NO_SIZE_T z_size_t;
+#  elif defined(STDC)
+#    include <stddef.h>
+     typedef size_t z_size_t;
+#  else
+     typedef unsigned long z_size_t;
+#  endif
+#  undef z_longlong
+#endif
+
+/* Maximum value for memLevel in deflateInit2 */
+#ifndef MAX_MEM_LEVEL
+#  ifdef MAXSEG_64K
+#    define MAX_MEM_LEVEL 8
+#  else
+#    define MAX_MEM_LEVEL 9
+#  endif
+#endif
+
+/* Maximum value for windowBits in deflateInit2 and inflateInit2.
+ * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
+ * created by gzip. (Files created by minigzip can still be extracted by
+ * gzip.)
+ */
+#ifndef MAX_WBITS
+#  define MAX_WBITS   15 /* 32K LZ77 window */
+#endif
+
+/* The memory requirements for deflate are (in bytes):
+            (1 << (windowBits+2)) +  (1 << (memLevel+9))
+ that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
+ plus a few kilobytes for small objects. For example, if you want to reduce
+ the default memory requirements from 256K to 128K, compile with
+     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
+ Of course this will generally degrade compression (there's no free lunch).
+
+   The memory requirements for inflate are (in bytes) 1 << windowBits
+ that is, 32K for windowBits=15 (default value) plus about 7 kilobytes
+ for small objects.
+*/
+
+                        /* Type declarations */
+
+#ifndef OF /* function prototypes */
+#  ifdef STDC
+#    define OF(args)  args
+#  else
+#    define OF(args)  ()
+#  endif
+#endif
+
+#ifndef Z_ARG /* function prototypes for stdarg */
+#  if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#    define Z_ARG(args)  args
+#  else
+#    define Z_ARG(args)  ()
+#  endif
+#endif
+
+/* The following definitions for FAR are needed only for MSDOS mixed
+ * model programming (small or medium model with some far allocations).
+ * This was tested only with MSC; for other MSDOS compilers you may have
+ * to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
+ * just define FAR to be empty.
+ */
+#ifdef SYS16BIT
+#  if defined(M_I86SM) || defined(M_I86MM)
+     /* MSC small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef _MSC_VER
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#  if (defined(__SMALL__) || defined(__MEDIUM__))
+     /* Turbo C small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef __BORLANDC__
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#endif
+
+#if defined(WINDOWS) || defined(WIN32)
+   /* If building or using zlib as a DLL, define ZLIB_DLL.
+    * This is not mandatory, but it offers a little performance increase.
+    */
+#  ifdef ZLIB_DLL
+#    if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
+#      ifdef ZLIB_INTERNAL
+#        define ZEXTERN extern __declspec(dllexport)
+#      else
+#        define ZEXTERN extern __declspec(dllimport)
+#      endif
+#    endif
+#  endif  /* ZLIB_DLL */
+   /* If building or using zlib with the WINAPI/WINAPIV calling convention,
+    * define ZLIB_WINAPI.
+    * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
+    */
+#  ifdef ZLIB_WINAPI
+#    ifdef FAR
+#      undef FAR
+#    endif
+#    include <windows.h>
+     /* No need for _export, use ZLIB.DEF instead. */
+     /* For complete Windows compatibility, use WINAPI, not __stdcall. */
+#    define ZEXPORT WINAPI
+#    ifdef WIN32
+#      define ZEXPORTVA WINAPIV
+#    else
+#      define ZEXPORTVA FAR CDECL
+#    endif
+#  endif
+#endif
+
+#if defined (__BEOS__)
+#  ifdef ZLIB_DLL
+#    ifdef ZLIB_INTERNAL
+#      define ZEXPORT   __declspec(dllexport)
+#      define ZEXPORTVA __declspec(dllexport)
+#    else
+#      define ZEXPORT   __declspec(dllimport)
+#      define ZEXPORTVA __declspec(dllimport)
+#    endif
+#  endif
+#endif
+
+#ifndef ZEXTERN
+#  define ZEXTERN extern
+#endif
+#ifndef ZEXPORT
+#  define ZEXPORT
+#endif
+#ifndef ZEXPORTVA
+#  define ZEXPORTVA
+#endif
+
+#ifndef FAR
+#  define FAR
+#endif
+
+#if !defined(__MACTYPES__)
+typedef unsigned char  Byte;  /* 8 bits */
+#endif
+typedef unsigned int   uInt;  /* 16 bits or more */
+typedef unsigned long  uLong; /* 32 bits or more */
+
+#ifdef SMALL_MEDIUM
+   /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
+#  define Bytef Byte FAR
+#else
+   typedef Byte  FAR Bytef;
+#endif
+typedef char  FAR charf;
+typedef int   FAR intf;
+typedef uInt  FAR uIntf;
+typedef uLong FAR uLongf;
+
+#ifdef STDC
+   typedef void const *voidpc;
+   typedef void FAR   *voidpf;
+   typedef void       *voidp;
+#else
+   typedef Byte const *voidpc;
+   typedef Byte FAR   *voidpf;
+   typedef Byte       *voidp;
+#endif
+
+#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC)
+#  include <limits.h>
+#  if (UINT_MAX == 0xffffffffUL)
+#    define Z_U4 unsigned
+#  elif (ULONG_MAX == 0xffffffffUL)
+#    define Z_U4 unsigned long
+#  elif (USHRT_MAX == 0xffffffffUL)
+#    define Z_U4 unsigned short
+#  endif
+#endif
+
+#ifdef Z_U4
+   typedef Z_U4 z_crc_t;
+#else
+   typedef unsigned long z_crc_t;
+#endif
+
+#ifdef HAVE_UNISTD_H    /* may be set to #if 1 by ./configure */
+#  define Z_HAVE_UNISTD_H
+#endif
+
+#ifdef HAVE_STDARG_H    /* may be set to #if 1 by ./configure */
+#  define Z_HAVE_STDARG_H
+#endif
+
+#ifdef STDC
+#  ifndef Z_SOLO
+#    include <sys/types.h>      /* for off_t */
+#  endif
+#endif
+
+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#  ifndef Z_SOLO
+#    include <stdarg.h>         /* for va_list */
+#  endif
+#endif
+
+#ifdef _WIN32
+#  ifndef Z_SOLO
+#    include <stddef.h>         /* for wchar_t */
+#  endif
+#endif
+
+/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and
+ * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even
+ * though the former does not conform to the LFS document), but considering
+ * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as
+ * equivalently requesting no 64-bit operations
+ */
+#if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1
+#  undef _LARGEFILE64_SOURCE
+#endif
+
+#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H)
+#  define Z_HAVE_UNISTD_H
+#endif
+#ifndef Z_SOLO
+#  if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE)
+#    include <unistd.h>         /* for SEEK_*, off_t, and _LFS64_LARGEFILE */
+#    ifdef VMS
+#      include <unixio.h>       /* for off_t */
+#    endif
+#    ifndef z_off_t
+#      define z_off_t off_t
+#    endif
+#  endif
+#endif
+
+#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0
+#  define Z_LFS64
+#endif
+
+#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64)
+#  define Z_LARGE64
+#endif
+
+#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64)
+#  define Z_WANT64
+#endif
+
+#if !defined(SEEK_SET) && !defined(Z_SOLO)
+#  define SEEK_SET        0       /* Seek from beginning of file.  */
+#  define SEEK_CUR        1       /* Seek from current position.  */
+#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
+#endif
+
+#ifndef z_off_t
+#  define z_off_t long
+#endif
+
+#if !defined(_WIN32) && defined(Z_LARGE64)
+#  define z_off64_t off64_t
+#else
+#  if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO)
+#    define z_off64_t __int64
+#  else
+#    define z_off64_t z_off_t
+#  endif
+#endif
+
+/* MVS linker does not support external names larger than 8 bytes */
+#if defined(__MVS__)
+  #pragma map(deflateInit_,"DEIN")
+  #pragma map(deflateInit2_,"DEIN2")
+  #pragma map(deflateEnd,"DEEND")
+  #pragma map(deflateBound,"DEBND")
+  #pragma map(inflateInit_,"ININ")
+  #pragma map(inflateInit2_,"ININ2")
+  #pragma map(inflateEnd,"INEND")
+  #pragma map(inflateSync,"INSY")
+  #pragma map(inflateSetDictionary,"INSEDI")
+  #pragma map(compressBound,"CMBND")
+  #pragma map(inflate_table,"INTABL")
+  #pragma map(inflate_fast,"INFA")
+  #pragma map(inflate_copyright,"INCOPY")
+#endif
+
+#endif /* ZCONF_H */
diff --git a/Engine/lib/assimp/contrib/zlib/zconf.h.included b/Engine/lib/assimp/contrib/zlib/zconf.h.included
new file mode 100644
index 000000000..352f552b8
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/zconf.h.included
@@ -0,0 +1,536 @@
+/* zconf.h -- configuration of the zlib compression library
+ * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#ifndef ZCONF_H
+#define ZCONF_H
+/* #undef Z_PREFIX */
+/* #undef Z_HAVE_UNISTD_H */
+
+/*
+ * If you *really* need a unique prefix for all types and library functions,
+ * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
+ * Even better than compiling with -DZ_PREFIX would be to use configure to set
+ * this permanently in zconf.h using "./configure --zprefix".
+ */
+#ifdef Z_PREFIX     /* may be set to #if 1 by ./configure */
+#  define Z_PREFIX_SET
+
+/* all linked symbols and init macros */
+#  define _dist_code            z__dist_code
+#  define _length_code          z__length_code
+#  define _tr_align             z__tr_align
+#  define _tr_flush_bits        z__tr_flush_bits
+#  define _tr_flush_block       z__tr_flush_block
+#  define _tr_init              z__tr_init
+#  define _tr_stored_block      z__tr_stored_block
+#  define _tr_tally             z__tr_tally
+#  define adler32               z_adler32
+#  define adler32_combine       z_adler32_combine
+#  define adler32_combine64     z_adler32_combine64
+#  define adler32_z             z_adler32_z
+#  ifndef Z_SOLO
+#    define compress              z_compress
+#    define compress2             z_compress2
+#    define compressBound         z_compressBound
+#  endif
+#  define crc32                 z_crc32
+#  define crc32_combine         z_crc32_combine
+#  define crc32_combine64       z_crc32_combine64
+#  define crc32_z               z_crc32_z
+#  define deflate               z_deflate
+#  define deflateBound          z_deflateBound
+#  define deflateCopy           z_deflateCopy
+#  define deflateEnd            z_deflateEnd
+#  define deflateGetDictionary  z_deflateGetDictionary
+#  define deflateInit           z_deflateInit
+#  define deflateInit2          z_deflateInit2
+#  define deflateInit2_         z_deflateInit2_
+#  define deflateInit_          z_deflateInit_
+#  define deflateParams         z_deflateParams
+#  define deflatePending        z_deflatePending
+#  define deflatePrime          z_deflatePrime
+#  define deflateReset          z_deflateReset
+#  define deflateResetKeep      z_deflateResetKeep
+#  define deflateSetDictionary  z_deflateSetDictionary
+#  define deflateSetHeader      z_deflateSetHeader
+#  define deflateTune           z_deflateTune
+#  define deflate_copyright     z_deflate_copyright
+#  define get_crc_table         z_get_crc_table
+#  ifndef Z_SOLO
+#    define gz_error              z_gz_error
+#    define gz_intmax             z_gz_intmax
+#    define gz_strwinerror        z_gz_strwinerror
+#    define gzbuffer              z_gzbuffer
+#    define gzclearerr            z_gzclearerr
+#    define gzclose               z_gzclose
+#    define gzclose_r             z_gzclose_r
+#    define gzclose_w             z_gzclose_w
+#    define gzdirect              z_gzdirect
+#    define gzdopen               z_gzdopen
+#    define gzeof                 z_gzeof
+#    define gzerror               z_gzerror
+#    define gzflush               z_gzflush
+#    define gzfread               z_gzfread
+#    define gzfwrite              z_gzfwrite
+#    define gzgetc                z_gzgetc
+#    define gzgetc_               z_gzgetc_
+#    define gzgets                z_gzgets
+#    define gzoffset              z_gzoffset
+#    define gzoffset64            z_gzoffset64
+#    define gzopen                z_gzopen
+#    define gzopen64              z_gzopen64
+#    ifdef _WIN32
+#      define gzopen_w              z_gzopen_w
+#    endif
+#    define gzprintf              z_gzprintf
+#    define gzputc                z_gzputc
+#    define gzputs                z_gzputs
+#    define gzread                z_gzread
+#    define gzrewind              z_gzrewind
+#    define gzseek                z_gzseek
+#    define gzseek64              z_gzseek64
+#    define gzsetparams           z_gzsetparams
+#    define gztell                z_gztell
+#    define gztell64              z_gztell64
+#    define gzungetc              z_gzungetc
+#    define gzvprintf             z_gzvprintf
+#    define gzwrite               z_gzwrite
+#  endif
+#  define inflate               z_inflate
+#  define inflateBack           z_inflateBack
+#  define inflateBackEnd        z_inflateBackEnd
+#  define inflateBackInit       z_inflateBackInit
+#  define inflateBackInit_      z_inflateBackInit_
+#  define inflateCodesUsed      z_inflateCodesUsed
+#  define inflateCopy           z_inflateCopy
+#  define inflateEnd            z_inflateEnd
+#  define inflateGetDictionary  z_inflateGetDictionary
+#  define inflateGetHeader      z_inflateGetHeader
+#  define inflateInit           z_inflateInit
+#  define inflateInit2          z_inflateInit2
+#  define inflateInit2_         z_inflateInit2_
+#  define inflateInit_          z_inflateInit_
+#  define inflateMark           z_inflateMark
+#  define inflatePrime          z_inflatePrime
+#  define inflateReset          z_inflateReset
+#  define inflateReset2         z_inflateReset2
+#  define inflateResetKeep      z_inflateResetKeep
+#  define inflateSetDictionary  z_inflateSetDictionary
+#  define inflateSync           z_inflateSync
+#  define inflateSyncPoint      z_inflateSyncPoint
+#  define inflateUndermine      z_inflateUndermine
+#  define inflateValidate       z_inflateValidate
+#  define inflate_copyright     z_inflate_copyright
+#  define inflate_fast          z_inflate_fast
+#  define inflate_table         z_inflate_table
+#  ifndef Z_SOLO
+#    define uncompress            z_uncompress
+#    define uncompress2           z_uncompress2
+#  endif
+#  define zError                z_zError
+#  ifndef Z_SOLO
+#    define zcalloc               z_zcalloc
+#    define zcfree                z_zcfree
+#  endif
+#  define zlibCompileFlags      z_zlibCompileFlags
+#  define zlibVersion           z_zlibVersion
+
+/* all zlib typedefs in zlib.h and zconf.h */
+#  define Byte                  z_Byte
+#  define Bytef                 z_Bytef
+#  define alloc_func            z_alloc_func
+#  define charf                 z_charf
+#  define free_func             z_free_func
+#  ifndef Z_SOLO
+#    define gzFile                z_gzFile
+#  endif
+#  define gz_header             z_gz_header
+#  define gz_headerp            z_gz_headerp
+#  define in_func               z_in_func
+#  define intf                  z_intf
+#  define out_func              z_out_func
+#  define uInt                  z_uInt
+#  define uIntf                 z_uIntf
+#  define uLong                 z_uLong
+#  define uLongf                z_uLongf
+#  define voidp                 z_voidp
+#  define voidpc                z_voidpc
+#  define voidpf                z_voidpf
+
+/* all zlib structs in zlib.h and zconf.h */
+#  define gz_header_s           z_gz_header_s
+#  define internal_state        z_internal_state
+
+#endif
+
+#if defined(__MSDOS__) && !defined(MSDOS)
+#  define MSDOS
+#endif
+#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
+#  define OS2
+#endif
+#if defined(_WINDOWS) && !defined(WINDOWS)
+#  define WINDOWS
+#endif
+#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
+#  ifndef WIN32
+#    define WIN32
+#  endif
+#endif
+#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
+#  if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
+#    ifndef SYS16BIT
+#      define SYS16BIT
+#    endif
+#  endif
+#endif
+
+/*
+ * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
+ * than 64k bytes at a time (needed on systems with 16-bit int).
+ */
+#ifdef SYS16BIT
+#  define MAXSEG_64K
+#endif
+#ifdef MSDOS
+#  define UNALIGNED_OK
+#endif
+
+#ifdef __STDC_VERSION__
+#  ifndef STDC
+#    define STDC
+#  endif
+#  if __STDC_VERSION__ >= 199901L
+#    ifndef STDC99
+#      define STDC99
+#    endif
+#  endif
+#endif
+#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
+#  define STDC
+#endif
+
+#if defined(__OS400__) && !defined(STDC)    /* iSeries (formerly AS/400). */
+#  define STDC
+#endif
+
+#ifndef STDC
+#  ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
+#    define const       /* note: need a more gentle solution here */
+#  endif
+#endif
+
+#if defined(ZLIB_CONST) && !defined(z_const)
+#  define z_const const
+#else
+#  define z_const
+#endif
+
+#ifdef Z_SOLO
+   typedef unsigned long z_size_t;
+#else
+#  define z_longlong long long
+#  if defined(NO_SIZE_T)
+     typedef unsigned NO_SIZE_T z_size_t;
+#  elif defined(STDC)
+#    include <stddef.h>
+     typedef size_t z_size_t;
+#  else
+     typedef unsigned long z_size_t;
+#  endif
+#  undef z_longlong
+#endif
+
+/* Maximum value for memLevel in deflateInit2 */
+#ifndef MAX_MEM_LEVEL
+#  ifdef MAXSEG_64K
+#    define MAX_MEM_LEVEL 8
+#  else
+#    define MAX_MEM_LEVEL 9
+#  endif
+#endif
+
+/* Maximum value for windowBits in deflateInit2 and inflateInit2.
+ * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
+ * created by gzip. (Files created by minigzip can still be extracted by
+ * gzip.)
+ */
+#ifndef MAX_WBITS
+#  define MAX_WBITS   15 /* 32K LZ77 window */
+#endif
+
+/* The memory requirements for deflate are (in bytes):
+            (1 << (windowBits+2)) +  (1 << (memLevel+9))
+ that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
+ plus a few kilobytes for small objects. For example, if you want to reduce
+ the default memory requirements from 256K to 128K, compile with
+     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
+ Of course this will generally degrade compression (there's no free lunch).
+
+   The memory requirements for inflate are (in bytes) 1 << windowBits
+ that is, 32K for windowBits=15 (default value) plus about 7 kilobytes
+ for small objects.
+*/
+
+                        /* Type declarations */
+
+#ifndef OF /* function prototypes */
+#  ifdef STDC
+#    define OF(args)  args
+#  else
+#    define OF(args)  ()
+#  endif
+#endif
+
+#ifndef Z_ARG /* function prototypes for stdarg */
+#  if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#    define Z_ARG(args)  args
+#  else
+#    define Z_ARG(args)  ()
+#  endif
+#endif
+
+/* The following definitions for FAR are needed only for MSDOS mixed
+ * model programming (small or medium model with some far allocations).
+ * This was tested only with MSC; for other MSDOS compilers you may have
+ * to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
+ * just define FAR to be empty.
+ */
+#ifdef SYS16BIT
+#  if defined(M_I86SM) || defined(M_I86MM)
+     /* MSC small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef _MSC_VER
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#  if (defined(__SMALL__) || defined(__MEDIUM__))
+     /* Turbo C small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef __BORLANDC__
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#endif
+
+#if defined(WINDOWS) || defined(WIN32)
+   /* If building or using zlib as a DLL, define ZLIB_DLL.
+    * This is not mandatory, but it offers a little performance increase.
+    */
+#  ifdef ZLIB_DLL
+#    if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
+#      ifdef ZLIB_INTERNAL
+#        define ZEXTERN extern __declspec(dllexport)
+#      else
+#        define ZEXTERN extern __declspec(dllimport)
+#      endif
+#    endif
+#  endif  /* ZLIB_DLL */
+   /* If building or using zlib with the WINAPI/WINAPIV calling convention,
+    * define ZLIB_WINAPI.
+    * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
+    */
+#  ifdef ZLIB_WINAPI
+#    ifdef FAR
+#      undef FAR
+#    endif
+#    include <windows.h>
+     /* No need for _export, use ZLIB.DEF instead. */
+     /* For complete Windows compatibility, use WINAPI, not __stdcall. */
+#    define ZEXPORT WINAPI
+#    ifdef WIN32
+#      define ZEXPORTVA WINAPIV
+#    else
+#      define ZEXPORTVA FAR CDECL
+#    endif
+#  endif
+#endif
+
+#if defined (__BEOS__)
+#  ifdef ZLIB_DLL
+#    ifdef ZLIB_INTERNAL
+#      define ZEXPORT   __declspec(dllexport)
+#      define ZEXPORTVA __declspec(dllexport)
+#    else
+#      define ZEXPORT   __declspec(dllimport)
+#      define ZEXPORTVA __declspec(dllimport)
+#    endif
+#  endif
+#endif
+
+#ifndef ZEXTERN
+#  define ZEXTERN extern
+#endif
+#ifndef ZEXPORT
+#  define ZEXPORT
+#endif
+#ifndef ZEXPORTVA
+#  define ZEXPORTVA
+#endif
+
+#ifndef FAR
+#  define FAR
+#endif
+
+#if !defined(__MACTYPES__)
+typedef unsigned char  Byte;  /* 8 bits */
+#endif
+typedef unsigned int   uInt;  /* 16 bits or more */
+typedef unsigned long  uLong; /* 32 bits or more */
+
+#ifdef SMALL_MEDIUM
+   /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
+#  define Bytef Byte FAR
+#else
+   typedef Byte  FAR Bytef;
+#endif
+typedef char  FAR charf;
+typedef int   FAR intf;
+typedef uInt  FAR uIntf;
+typedef uLong FAR uLongf;
+
+#ifdef STDC
+   typedef void const *voidpc;
+   typedef void FAR   *voidpf;
+   typedef void       *voidp;
+#else
+   typedef Byte const *voidpc;
+   typedef Byte FAR   *voidpf;
+   typedef Byte       *voidp;
+#endif
+
+#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC)
+#  include <limits.h>
+#  if (UINT_MAX == 0xffffffffUL)
+#    define Z_U4 unsigned
+#  elif (ULONG_MAX == 0xffffffffUL)
+#    define Z_U4 unsigned long
+#  elif (USHRT_MAX == 0xffffffffUL)
+#    define Z_U4 unsigned short
+#  endif
+#endif
+
+#ifdef Z_U4
+   typedef Z_U4 z_crc_t;
+#else
+   typedef unsigned long z_crc_t;
+#endif
+
+#ifdef HAVE_UNISTD_H    /* may be set to #if 1 by ./configure */
+#  define Z_HAVE_UNISTD_H
+#endif
+
+#ifdef HAVE_STDARG_H    /* may be set to #if 1 by ./configure */
+#  define Z_HAVE_STDARG_H
+#endif
+
+#ifdef STDC
+#  ifndef Z_SOLO
+#    include <sys/types.h>      /* for off_t */
+#  endif
+#endif
+
+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#  ifndef Z_SOLO
+#    include <stdarg.h>         /* for va_list */
+#  endif
+#endif
+
+#ifdef _WIN32
+#  ifndef Z_SOLO
+#    include <stddef.h>         /* for wchar_t */
+#  endif
+#endif
+
+/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and
+ * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even
+ * though the former does not conform to the LFS document), but considering
+ * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as
+ * equivalently requesting no 64-bit operations
+ */
+#if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1
+#  undef _LARGEFILE64_SOURCE
+#endif
+
+#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H)
+#  define Z_HAVE_UNISTD_H
+#endif
+#ifndef Z_SOLO
+#  if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE)
+#    include <unistd.h>         /* for SEEK_*, off_t, and _LFS64_LARGEFILE */
+#    ifdef VMS
+#      include <unixio.h>       /* for off_t */
+#    endif
+#    ifndef z_off_t
+#      define z_off_t off_t
+#    endif
+#  endif
+#endif
+
+#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0
+#  define Z_LFS64
+#endif
+
+#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64)
+#  define Z_LARGE64
+#endif
+
+#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64)
+#  define Z_WANT64
+#endif
+
+#if !defined(SEEK_SET) && !defined(Z_SOLO)
+#  define SEEK_SET        0       /* Seek from beginning of file.  */
+#  define SEEK_CUR        1       /* Seek from current position.  */
+#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
+#endif
+
+#ifndef z_off_t
+#  define z_off_t long
+#endif
+
+#if !defined(_WIN32) && defined(Z_LARGE64)
+#  define z_off64_t off64_t
+#else
+#  if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO)
+#    define z_off64_t __int64
+#  else
+#    define z_off64_t z_off_t
+#  endif
+#endif
+
+/* MVS linker does not support external names larger than 8 bytes */
+#if defined(__MVS__)
+  #pragma map(deflateInit_,"DEIN")
+  #pragma map(deflateInit2_,"DEIN2")
+  #pragma map(deflateEnd,"DEEND")
+  #pragma map(deflateBound,"DEBND")
+  #pragma map(inflateInit_,"ININ")
+  #pragma map(inflateInit2_,"ININ2")
+  #pragma map(inflateEnd,"INEND")
+  #pragma map(inflateSync,"INSY")
+  #pragma map(inflateSetDictionary,"INSEDI")
+  #pragma map(compressBound,"CMBND")
+  #pragma map(inflate_table,"INTABL")
+  #pragma map(inflate_fast,"INFA")
+  #pragma map(inflate_copyright,"INCOPY")
+#endif
+
+#endif /* ZCONF_H */
diff --git a/Engine/lib/assimp/contrib/zlib/zlib.h b/Engine/lib/assimp/contrib/zlib/zlib.h
new file mode 100644
index 000000000..dcb7b5063
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/zlib.h
@@ -0,0 +1,1917 @@
+/* zlib.h -- interface of the 'zlib' general purpose compression library
+  version 1.2.11.1, January xxth, 2017
+
+  Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Jean-loup Gailly        Mark Adler
+  jloup@gzip.org          madler@alumni.caltech.edu
+
+
+  The data format used by the zlib library is described by RFCs (Request for
+  Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950
+  (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format).
+*/
+
+#ifndef ZLIB_H
+#define ZLIB_H
+
+#include "zconf.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ZLIB_VERSION "1.2.11.1-motley"
+#define ZLIB_VERNUM 0x12b1
+#define ZLIB_VER_MAJOR 1
+#define ZLIB_VER_MINOR 2
+#define ZLIB_VER_REVISION 11
+#define ZLIB_VER_SUBREVISION 1
+
+/*
+    The 'zlib' compression library provides in-memory compression and
+  decompression functions, including integrity checks of the uncompressed data.
+  This version of the library supports only one compression method (deflation)
+  but other algorithms will be added later and will have the same stream
+  interface.
+
+    Compression can be done in a single step if the buffers are large enough,
+  or can be done by repeated calls of the compression function.  In the latter
+  case, the application must provide more input and/or consume the output
+  (providing more output space) before each call.
+
+    The compressed data format used by default by the in-memory functions is
+  the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped
+  around a deflate stream, which is itself documented in RFC 1951.
+
+    The library also supports reading and writing files in gzip (.gz) format
+  with an interface similar to that of stdio using the functions that start
+  with "gz".  The gzip format is different from the zlib format.  gzip is a
+  gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.
+
+    This library can optionally read and write gzip and raw deflate streams in
+  memory as well.
+
+    The zlib format was designed to be compact and fast for use in memory
+  and on communications channels.  The gzip format was designed for single-
+  file compression on file systems, has a larger header than zlib to maintain
+  directory information, and uses a different, slower check method than zlib.
+
+    The library does not install any signal handler.  The decoder checks
+  the consistency of the compressed data, so the library should never crash
+  even in the case of corrupted input.
+*/
+
+#ifdef __ANDROID__
+typedef unsigned long zcrc_t;
+#endif
+
+typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
+typedef void   (*free_func)  OF((voidpf opaque, voidpf address));
+
+struct internal_state;
+
+typedef struct z_stream_s {
+    z_const Bytef *next_in;     /* next input byte */
+    uInt     avail_in;  /* number of bytes available at next_in */
+    uLong    total_in;  /* total number of input bytes read so far */
+
+    Bytef    *next_out; /* next output byte will go here */
+    uInt     avail_out; /* remaining free space at next_out */
+    uLong    total_out; /* total number of bytes output so far */
+
+    z_const char *msg;  /* last error message, NULL if no error */
+    struct internal_state FAR *state; /* not visible by applications */
+
+    alloc_func zalloc;  /* used to allocate the internal state */
+    free_func  zfree;   /* used to free the internal state */
+    voidpf     opaque;  /* private data object passed to zalloc and zfree */
+
+    int     data_type;  /* best guess about the data type: binary or text
+                           for deflate, or the decoding state for inflate */
+    uLong   adler;      /* Adler-32 or CRC-32 value of the uncompressed data */
+    uLong   reserved;   /* reserved for future use */
+} z_stream;
+
+typedef z_stream FAR *z_streamp;
+
+/*
+     gzip header information passed to and from zlib routines.  See RFC 1952
+  for more details on the meanings of these fields.
+*/
+typedef struct gz_header_s {
+    int     text;       /* true if compressed data believed to be text */
+    uLong   time;       /* modification time */
+    int     xflags;     /* extra flags (not used when writing a gzip file) */
+    int     os;         /* operating system */
+    Bytef   *extra;     /* pointer to extra field or Z_NULL if none */
+    uInt    extra_len;  /* extra field length (valid if extra != Z_NULL) */
+    uInt    extra_max;  /* space at extra (only when reading header) */
+    Bytef   *name;      /* pointer to zero-terminated file name or Z_NULL */
+    uInt    name_max;   /* space at name (only when reading header) */
+    Bytef   *comment;   /* pointer to zero-terminated comment or Z_NULL */
+    uInt    comm_max;   /* space at comment (only when reading header) */
+    int     hcrc;       /* true if there was or will be a header crc */
+    int     done;       /* true when done reading gzip header (not used
+                           when writing a gzip file) */
+} gz_header;
+
+typedef gz_header FAR *gz_headerp;
+
+/*
+     The application must update next_in and avail_in when avail_in has dropped
+   to zero.  It must update next_out and avail_out when avail_out has dropped
+   to zero.  The application must initialize zalloc, zfree and opaque before
+   calling the init function.  All other fields are set by the compression
+   library and must not be updated by the application.
+
+     The opaque value provided by the application will be passed as the first
+   parameter for calls of zalloc and zfree.  This can be useful for custom
+   memory management.  The compression library attaches no meaning to the
+   opaque value.
+
+     zalloc must return Z_NULL if there is not enough memory for the object.
+   If zlib is used in a multi-threaded application, zalloc and zfree must be
+   thread safe.  In that case, zlib is thread-safe.  When zalloc and zfree are
+   Z_NULL on entry to the initialization function, they are set to internal
+   routines that use the standard library functions malloc() and free().
+
+     On 16-bit systems, the functions zalloc and zfree must be able to allocate
+   exactly 65536 bytes, but will not be required to allocate more than this if
+   the symbol MAXSEG_64K is defined (see zconf.h).  WARNING: On MSDOS, pointers
+   returned by zalloc for objects of exactly 65536 bytes *must* have their
+   offset normalized to zero.  The default allocation function provided by this
+   library ensures this (see zutil.c).  To reduce memory requirements and avoid
+   any allocation of 64K objects, at the expense of compression ratio, compile
+   the library with -DMAX_WBITS=14 (see zconf.h).
+
+     The fields total_in and total_out can be used for statistics or progress
+   reports.  After compression, total_in holds the total size of the
+   uncompressed data and may be saved for use by the decompressor (particularly
+   if the decompressor wants to decompress everything in a single step).
+*/
+
+                        /* constants */
+
+#define Z_NO_FLUSH      0
+#define Z_PARTIAL_FLUSH 1
+#define Z_SYNC_FLUSH    2
+#define Z_FULL_FLUSH    3
+#define Z_FINISH        4
+#define Z_BLOCK         5
+#define Z_TREES         6
+/* Allowed flush values; see deflate() and inflate() below for details */
+
+#define Z_OK            0
+#define Z_STREAM_END    1
+#define Z_NEED_DICT     2
+#define Z_ERRNO        (-1)
+#define Z_STREAM_ERROR (-2)
+#define Z_DATA_ERROR   (-3)
+#define Z_MEM_ERROR    (-4)
+#define Z_BUF_ERROR    (-5)
+#define Z_VERSION_ERROR (-6)
+/* Return codes for the compression/decompression functions. Negative values
+ * are errors, positive values are used for special but normal events.
+ */
+
+#define Z_NO_COMPRESSION         0
+#define Z_BEST_SPEED             1
+#define Z_BEST_COMPRESSION       9
+#define Z_DEFAULT_COMPRESSION  (-1)
+/* compression levels */
+
+#define Z_FILTERED            1
+#define Z_HUFFMAN_ONLY        2
+#define Z_RLE                 3
+#define Z_FIXED               4
+#define Z_DEFAULT_STRATEGY    0
+/* compression strategy; see deflateInit2() below for details */
+
+#define Z_BINARY   0
+#define Z_TEXT     1
+#define Z_ASCII    Z_TEXT   /* for compatibility with 1.2.2 and earlier */
+#define Z_UNKNOWN  2
+/* Possible values of the data_type field for deflate() */
+
+#define Z_DEFLATED   8
+/* The deflate compression method (the only one supported in this version) */
+
+#define Z_NULL  0  /* for initializing zalloc, zfree, opaque */
+
+#define zlib_version zlibVersion()
+/* for compatibility with versions < 1.0.2 */
+
+
+                        /* basic functions */
+
+ZEXTERN const char * ZEXPORT zlibVersion OF((void));
+/* The application can compare zlibVersion and ZLIB_VERSION for consistency.
+   If the first character differs, the library code actually used is not
+   compatible with the zlib.h header file used by the application.  This check
+   is automatically made by deflateInit and inflateInit.
+ */
+
+/*
+ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level));
+
+     Initializes the internal stream state for compression.  The fields
+   zalloc, zfree and opaque must be initialized before by the caller.  If
+   zalloc and zfree are set to Z_NULL, deflateInit updates them to use default
+   allocation functions.
+
+     The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
+   1 gives best speed, 9 gives best compression, 0 gives no compression at all
+   (the input data is simply copied a block at a time).  Z_DEFAULT_COMPRESSION
+   requests a default compromise between speed and compression (currently
+   equivalent to level 6).
+
+     deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if level is not a valid compression level, or
+   Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
+   with the version assumed by the caller (ZLIB_VERSION).  msg is set to null
+   if there is no error message.  deflateInit does not perform any compression:
+   this will be done by deflate().
+*/
+
+
+ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
+/*
+    deflate compresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full.  It may introduce
+  some output latency (reading input without producing any output) except when
+  forced to flush.
+
+    The detailed semantics are as follows.  deflate performs one or both of the
+  following actions:
+
+  - Compress more input starting at next_in and update next_in and avail_in
+    accordingly.  If not all input can be processed (because there is not
+    enough room in the output buffer), next_in and avail_in are updated and
+    processing will resume at this point for the next call of deflate().
+
+  - Generate more output starting at next_out and update next_out and avail_out
+    accordingly.  This action is forced if the parameter flush is non zero.
+    Forcing flush frequently degrades the compression ratio, so this parameter
+    should be set only when necessary.  Some output may be provided even if
+    flush is zero.
+
+    Before the call of deflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming more
+  output, and updating avail_in or avail_out accordingly; avail_out should
+  never be zero before the call.  The application can consume the compressed
+  output when it wants, for example when the output buffer is full (avail_out
+  == 0), or after each call of deflate().  If deflate returns Z_OK and with
+  zero avail_out, it must be called again after making room in the output
+  buffer because there might be more output pending. See deflatePending(),
+  which can be used if desired to determine whether or not there is more ouput
+  in that case.
+
+    Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to
+  decide how much data to accumulate before producing output, in order to
+  maximize compression.
+
+    If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
+  flushed to the output buffer and the output is aligned on a byte boundary, so
+  that the decompressor can get all input data available so far.  (In
+  particular avail_in is zero after the call if enough output space has been
+  provided before the call.) Flushing may degrade compression for some
+  compression algorithms and so it should be used only when necessary.  This
+  completes the current deflate block and follows it with an empty stored block
+  that is three bits plus filler bits to the next byte, followed by four bytes
+  (00 00 ff ff).
+
+    If flush is set to Z_PARTIAL_FLUSH, all pending output is flushed to the
+  output buffer, but the output is not aligned to a byte boundary.  All of the
+  input data so far will be available to the decompressor, as for Z_SYNC_FLUSH.
+  This completes the current deflate block and follows it with an empty fixed
+  codes block that is 10 bits long.  This assures that enough bytes are output
+  in order for the decompressor to finish the block before the empty fixed
+  codes block.
+
+    If flush is set to Z_BLOCK, a deflate block is completed and emitted, as
+  for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to
+  seven bits of the current block are held to be written as the next byte after
+  the next deflate block is completed.  In this case, the decompressor may not
+  be provided enough bits at this point in order to complete decompression of
+  the data provided so far to the compressor.  It may need to wait for the next
+  block to be emitted.  This is for advanced applications that need to control
+  the emission of deflate blocks.
+
+    If flush is set to Z_FULL_FLUSH, all output is flushed as with
+  Z_SYNC_FLUSH, and the compression state is reset so that decompression can
+  restart from this point if previous compressed data has been damaged or if
+  random access is desired.  Using Z_FULL_FLUSH too often can seriously degrade
+  compression.
+
+    If deflate returns with avail_out == 0, this function must be called again
+  with the same value of the flush parameter and more output space (updated
+  avail_out), until the flush is complete (deflate returns with non-zero
+  avail_out).  In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that
+  avail_out is greater than six to avoid repeated flush markers due to
+  avail_out == 0 on return.
+
+    If the parameter flush is set to Z_FINISH, pending input is processed,
+  pending output is flushed and deflate returns with Z_STREAM_END if there was
+  enough output space.  If deflate returns with Z_OK or Z_BUF_ERROR, this
+  function must be called again with Z_FINISH and more output space (updated
+  avail_out) but no more input data, until it returns with Z_STREAM_END or an
+  error.  After deflate has returned Z_STREAM_END, the only possible operations
+  on the stream are deflateReset or deflateEnd.
+
+    Z_FINISH can be used in the first deflate call after deflateInit if all the
+  compression is to be done in a single step.  In order to complete in one
+  call, avail_out must be at least the value returned by deflateBound (see
+  below).  Then deflate is guaranteed to return Z_STREAM_END.  If not enough
+  output space is provided, deflate will not return Z_STREAM_END, and it must
+  be called again as described above.
+
+    deflate() sets strm->adler to the Adler-32 checksum of all input read
+  so far (that is, total_in bytes).  If a gzip stream is being generated, then
+  strm->adler will be the CRC-32 checksum of the input read so far.  (See
+  deflateInit2 below.)
+
+    deflate() may update strm->data_type if it can make a good guess about
+  the input data type (Z_BINARY or Z_TEXT).  If in doubt, the data is
+  considered binary.  This field is only for information purposes and does not
+  affect the compression algorithm in any manner.
+
+    deflate() returns Z_OK if some progress has been made (more input
+  processed or more output produced), Z_STREAM_END if all input has been
+  consumed and all output has been produced (only when flush is set to
+  Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
+  if next_in or next_out was Z_NULL or the state was inadvertently written over
+  by the application), or Z_BUF_ERROR if no progress is possible (for example
+  avail_in or avail_out was zero).  Note that Z_BUF_ERROR is not fatal, and
+  deflate() can be called again with more input and more output space to
+  continue compressing.
+*/
+
+
+ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm));
+/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any pending
+   output.
+
+     deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
+   stream state was inconsistent, Z_DATA_ERROR if the stream was freed
+   prematurely (some input or output was discarded).  In the error case, msg
+   may be set but then points to a static string (which must not be
+   deallocated).
+*/
+
+
+/*
+ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
+
+     Initializes the internal stream state for decompression.  The fields
+   next_in, avail_in, zalloc, zfree and opaque must be initialized before by
+   the caller.  In the current version of inflate, the provided input is not
+   read or consumed.  The allocation of a sliding window will be deferred to
+   the first call of inflate (if the decompression does not complete on the
+   first call).  If zalloc and zfree are set to Z_NULL, inflateInit updates
+   them to use default allocation functions.
+
+     inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
+   version assumed by the caller, or Z_STREAM_ERROR if the parameters are
+   invalid, such as a null pointer to the structure.  msg is set to null if
+   there is no error message.  inflateInit does not perform any decompression.
+   Actual decompression will be done by inflate().  So next_in, and avail_in,
+   next_out, and avail_out are unused and unchanged.  The current
+   implementation of inflateInit() does not process any header information --
+   that is deferred until inflate() is called.
+*/
+
+
+ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
+/*
+    inflate decompresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full.  It may introduce
+  some output latency (reading input without producing any output) except when
+  forced to flush.
+
+  The detailed semantics are as follows.  inflate performs one or both of the
+  following actions:
+
+  - Decompress more input starting at next_in and update next_in and avail_in
+    accordingly.  If not all input can be processed (because there is not
+    enough room in the output buffer), then next_in and avail_in are updated
+    accordingly, and processing will resume at this point for the next call of
+    inflate().
+
+  - Generate more output starting at next_out and update next_out and avail_out
+    accordingly.  inflate() provides as much output as possible, until there is
+    no more input data or no more space in the output buffer (see below about
+    the flush parameter).
+
+    Before the call of inflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming more
+  output, and updating the next_* and avail_* values accordingly.  If the
+  caller of inflate() does not provide both available input and available
+  output space, it is possible that there will be no progress made.  The
+  application can consume the uncompressed output when it wants, for example
+  when the output buffer is full (avail_out == 0), or after each call of
+  inflate().  If inflate returns Z_OK and with zero avail_out, it must be
+  called again after making room in the output buffer because there might be
+  more output pending.
+
+    The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FINISH,
+  Z_BLOCK, or Z_TREES.  Z_SYNC_FLUSH requests that inflate() flush as much
+  output as possible to the output buffer.  Z_BLOCK requests that inflate()
+  stop if and when it gets to the next deflate block boundary.  When decoding
+  the zlib or gzip format, this will cause inflate() to return immediately
+  after the header and before the first block.  When doing a raw inflate,
+  inflate() will go ahead and process the first block, and will return when it
+  gets to the end of that block, or when it runs out of data.
+
+    The Z_BLOCK option assists in appending to or combining deflate streams.
+  To assist in this, on return inflate() always sets strm->data_type to the
+  number of unused bits in the last byte taken from strm->next_in, plus 64 if
+  inflate() is currently decoding the last block in the deflate stream, plus
+  128 if inflate() returned immediately after decoding an end-of-block code or
+  decoding the complete header up to just before the first byte of the deflate
+  stream.  The end-of-block will not be indicated until all of the uncompressed
+  data from that block has been written to strm->next_out.  The number of
+  unused bits may in general be greater than seven, except when bit 7 of
+  data_type is set, in which case the number of unused bits will be less than
+  eight.  data_type is set as noted here every time inflate() returns for all
+  flush options, and so can be used to determine the amount of currently
+  consumed input in bits.
+
+    The Z_TREES option behaves as Z_BLOCK does, but it also returns when the
+  end of each deflate block header is reached, before any actual data in that
+  block is decoded.  This allows the caller to determine the length of the
+  deflate block header for later use in random access within a deflate block.
+  256 is added to the value of strm->data_type when inflate() returns
+  immediately after reaching the end of the deflate block header.
+
+    inflate() should normally be called until it returns Z_STREAM_END or an
+  error.  However if all decompression is to be performed in a single step (a
+  single call of inflate), the parameter flush should be set to Z_FINISH.  In
+  this case all pending input is processed and all pending output is flushed;
+  avail_out must be large enough to hold all of the uncompressed data for the
+  operation to complete.  (The size of the uncompressed data may have been
+  saved by the compressor for this purpose.)  The use of Z_FINISH is not
+  required to perform an inflation in one step.  However it may be used to
+  inform inflate that a faster approach can be used for the single inflate()
+  call.  Z_FINISH also informs inflate to not maintain a sliding window if the
+  stream completes, which reduces inflate's memory footprint.  If the stream
+  does not complete, either because not all of the stream is provided or not
+  enough output space is provided, then a sliding window will be allocated and
+  inflate() can be called again to continue the operation as if Z_NO_FLUSH had
+  been used.
+
+     In this implementation, inflate() always flushes as much output as
+  possible to the output buffer, and always uses the faster approach on the
+  first call.  So the effects of the flush parameter in this implementation are
+  on the return value of inflate() as noted below, when inflate() returns early
+  when Z_BLOCK or Z_TREES is used, and when inflate() avoids the allocation of
+  memory for a sliding window when Z_FINISH is used.
+
+     If a preset dictionary is needed after this call (see inflateSetDictionary
+  below), inflate sets strm->adler to the Adler-32 checksum of the dictionary
+  chosen by the compressor and returns Z_NEED_DICT; otherwise it sets
+  strm->adler to the Adler-32 checksum of all output produced so far (that is,
+  total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described
+  below.  At the end of the stream, inflate() checks that its computed Adler-32
+  checksum is equal to that saved by the compressor and returns Z_STREAM_END
+  only if the checksum is correct.
+
+    inflate() can decompress and check either zlib-wrapped or gzip-wrapped
+  deflate data.  The header type is detected automatically, if requested when
+  initializing with inflateInit2().  Any information contained in the gzip
+  header is not retained unless inflateGetHeader() is used.  When processing
+  gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output
+  produced so far.  The CRC-32 is checked against the gzip trailer, as is the
+  uncompressed length, modulo 2^32.
+
+    inflate() returns Z_OK if some progress has been made (more input processed
+  or more output produced), Z_STREAM_END if the end of the compressed data has
+  been reached and all uncompressed output has been produced, Z_NEED_DICT if a
+  preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
+  corrupted (input stream not conforming to the zlib format or incorrect check
+  value, in which case strm->msg points to a string with a more specific
+  error), Z_STREAM_ERROR if the stream structure was inconsistent (for example
+  next_in or next_out was Z_NULL, or the state was inadvertently written over
+  by the application), Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR
+  if no progress was possible or if there was not enough room in the output
+  buffer when Z_FINISH is used.  Note that Z_BUF_ERROR is not fatal, and
+  inflate() can be called again with more input and more output space to
+  continue decompressing.  If Z_DATA_ERROR is returned, the application may
+  then call inflateSync() to look for a good compression block if a partial
+  recovery of the data is to be attempted.
+*/
+
+
+ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
+/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any pending
+   output.
+
+     inflateEnd returns Z_OK if success, or Z_STREAM_ERROR if the stream state
+   was inconsistent.
+*/
+
+
+                        /* Advanced functions */
+
+/*
+    The following functions are needed only in some special applications.
+*/
+
+/*
+ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
+                                     int  level,
+                                     int  method,
+                                     int  windowBits,
+                                     int  memLevel,
+                                     int  strategy));
+
+     This is another version of deflateInit with more compression options.  The
+   fields next_in, zalloc, zfree and opaque must be initialized before by the
+   caller.
+
+     The method parameter is the compression method.  It must be Z_DEFLATED in
+   this version of the library.
+
+     The windowBits parameter is the base two logarithm of the window size
+   (the size of the history buffer).  It should be in the range 8..15 for this
+   version of the library.  Larger values of this parameter result in better
+   compression at the expense of memory usage.  The default value is 15 if
+   deflateInit is used instead.
+
+     For the current implementation of deflate(), a windowBits value of 8 (a
+   window size of 256 bytes) is not supported.  As a result, a request for 8
+   will result in 9 (a 512-byte window).  In that case, providing 8 to
+   inflateInit2() will result in an error when the zlib header with 9 is
+   checked against the initialization of inflate().  The remedy is to not use 8
+   with deflateInit2() with this initialization, or at least in that case use 9
+   with inflateInit2().
+
+     windowBits can also be -8..-15 for raw deflate.  In this case, -windowBits
+   determines the window size.  deflate() will then generate raw deflate data
+   with no zlib header or trailer, and will not compute a check value.
+
+     windowBits can also be greater than 15 for optional gzip encoding.  Add
+   16 to windowBits to write a simple gzip header and trailer around the
+   compressed data instead of a zlib wrapper.  The gzip header will have no
+   file name, no extra data, no comment, no modification time (set to zero), no
+   header crc, and the operating system will be set to the appropriate value,
+   if the operating system was determined at compile time.  If a gzip stream is
+   being written, strm->adler is a CRC-32 instead of an Adler-32.
+
+     For raw deflate or gzip encoding, a request for a 256-byte window is
+   rejected as invalid, since only the zlib header provides a means of
+   transmitting the window size to the decompressor.
+
+     The memLevel parameter specifies how much memory should be allocated
+   for the internal compression state.  memLevel=1 uses minimum memory but is
+   slow and reduces compression ratio; memLevel=9 uses maximum memory for
+   optimal speed.  The default value is 8.  See zconf.h for total memory usage
+   as a function of windowBits and memLevel.
+
+     The strategy parameter is used to tune the compression algorithm.  Use the
+   value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
+   filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no
+   string match), or Z_RLE to limit match distances to one (run-length
+   encoding).  Filtered data consists mostly of small values with a somewhat
+   random distribution.  In this case, the compression algorithm is tuned to
+   compress them better.  The effect of Z_FILTERED is to force more Huffman
+   coding and less string matching; it is somewhat intermediate between
+   Z_DEFAULT_STRATEGY and Z_HUFFMAN_ONLY.  Z_RLE is designed to be almost as
+   fast as Z_HUFFMAN_ONLY, but give better compression for PNG image data.  The
+   strategy parameter only affects the compression ratio but not the
+   correctness of the compressed output even if it is not set appropriately.
+   Z_FIXED prevents the use of dynamic Huffman codes, allowing for a simpler
+   decoder for special applications.
+
+     deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if any parameter is invalid (such as an invalid
+   method), or Z_VERSION_ERROR if the zlib library version (zlib_version) is
+   incompatible with the version assumed by the caller (ZLIB_VERSION).  msg is
+   set to null if there is no error message.  deflateInit2 does not perform any
+   compression: this will be done by deflate().
+*/
+
+ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
+                                             const Bytef *dictionary,
+                                             uInt  dictLength));
+/*
+     Initializes the compression dictionary from the given byte sequence
+   without producing any compressed output.  When using the zlib format, this
+   function must be called immediately after deflateInit, deflateInit2 or
+   deflateReset, and before any call of deflate.  When doing raw deflate, this
+   function must be called either before any call of deflate, or immediately
+   after the completion of a deflate block, i.e. after all input has been
+   consumed and all output has been delivered when using any of the flush
+   options Z_BLOCK, Z_PARTIAL_FLUSH, Z_SYNC_FLUSH, or Z_FULL_FLUSH.  The
+   compressor and decompressor must use exactly the same dictionary (see
+   inflateSetDictionary).
+
+     The dictionary should consist of strings (byte sequences) that are likely
+   to be encountered later in the data to be compressed, with the most commonly
+   used strings preferably put towards the end of the dictionary.  Using a
+   dictionary is most useful when the data to be compressed is short and can be
+   predicted with good accuracy; the data can then be compressed better than
+   with the default empty dictionary.
+
+     Depending on the size of the compression data structures selected by
+   deflateInit or deflateInit2, a part of the dictionary may in effect be
+   discarded, for example if the dictionary is larger than the window size
+   provided in deflateInit or deflateInit2.  Thus the strings most likely to be
+   useful should be put at the end of the dictionary, not at the front.  In
+   addition, the current implementation of deflate will use at most the window
+   size minus 262 bytes of the provided dictionary.
+
+     Upon return of this function, strm->adler is set to the Adler-32 value
+   of the dictionary; the decompressor may later use this value to determine
+   which dictionary has been used by the compressor.  (The Adler-32 value
+   applies to the whole dictionary even if only a subset of the dictionary is
+   actually used by the compressor.) If a raw deflate was requested, then the
+   Adler-32 value is not computed and strm->adler is not set.
+
+     deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
+   parameter is invalid (e.g.  dictionary being Z_NULL) or the stream state is
+   inconsistent (for example if deflate has already been called for this stream
+   or if not at a block boundary for raw deflate).  deflateSetDictionary does
+   not perform any compression: this will be done by deflate().
+*/
+
+ZEXTERN int ZEXPORT deflateGetDictionary OF((z_streamp strm,
+                                             Bytef *dictionary,
+                                             uInt  *dictLength));
+/*
+     Returns the sliding dictionary being maintained by deflate.  dictLength is
+   set to the number of bytes in the dictionary, and that many bytes are copied
+   to dictionary.  dictionary must have enough space, where 32768 bytes is
+   always enough.  If deflateGetDictionary() is called with dictionary equal to
+   Z_NULL, then only the dictionary length is returned, and nothing is copied.
+   Similary, if dictLength is Z_NULL, then it is not set.
+
+     deflateGetDictionary() may return a length less than the window size, even
+   when more than the window size in input has been provided. It may return up
+   to 258 bytes less in that case, due to how zlib's implementation of deflate
+   manages the sliding window and lookahead for matches, where matches can be
+   up to 258 bytes long. If the application needs the last window-size bytes of
+   input, then that would need to be saved by the application outside of zlib.
+
+     deflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the
+   stream state is inconsistent.
+*/
+
+ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
+                                    z_streamp source));
+/*
+     Sets the destination stream as a complete copy of the source stream.
+
+     This function can be useful when several compression strategies will be
+   tried, for example when there are several ways of pre-processing the input
+   data with a filter.  The streams that will be discarded should then be freed
+   by calling deflateEnd.  Note that deflateCopy duplicates the internal
+   compression state which can be quite large, so this strategy is slow and can
+   consume lots of memory.
+
+     deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+   (such as zalloc being Z_NULL).  msg is left unchanged in both source and
+   destination.
+*/
+
+ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
+/*
+     This function is equivalent to deflateEnd followed by deflateInit, but
+   does not free and reallocate the internal compression state.  The stream
+   will leave the compression level and any other attributes that may have been
+   set unchanged.
+
+     deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being Z_NULL).
+*/
+
+ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
+                                      int level,
+                                      int strategy));
+/*
+     Dynamically update the compression level and compression strategy.  The
+   interpretation of level and strategy is as in deflateInit2().  This can be
+   used to switch between compression and straight copy of the input data, or
+   to switch to a different kind of input data requiring a different strategy.
+   If the compression approach (which is a function of the level) or the
+   strategy is changed, and if there have been any deflate() calls since the
+   state was initialized or reset, then the input available so far is
+   compressed with the old level and strategy using deflate(strm, Z_BLOCK).
+   There are three approaches for the compression levels 0, 1..3, and 4..9
+   respectively.  The new level and strategy will take effect at the next call
+   of deflate().
+
+     If a deflate(strm, Z_BLOCK) is performed by deflateParams(), and it does
+   not have enough output space to complete, then the parameter change will not
+   take effect.  In this case, deflateParams() can be called again with the
+   same parameters and more output space to try again.
+
+     In order to assure a change in the parameters on the first try, the
+   deflate stream should be flushed using deflate() with Z_BLOCK or other flush
+   request until strm.avail_out is not zero, before calling deflateParams().
+   Then no more input data should be provided before the deflateParams() call.
+   If this is done, the old level and strategy will be applied to the data
+   compressed before deflateParams(), and the new level and strategy will be
+   applied to the the data compressed after deflateParams().
+
+     deflateParams returns Z_OK on success, Z_STREAM_ERROR if the source stream
+   state was inconsistent or if a parameter was invalid, or Z_BUF_ERROR if
+   there was not enough output space to complete the compression of the
+   available input data before a change in the strategy or approach.  Note that
+   in the case of a Z_BUF_ERROR, the parameters are not changed.  A return
+   value of Z_BUF_ERROR is not fatal, in which case deflateParams() can be
+   retried with more output space.
+*/
+
+ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm,
+                                    int good_length,
+                                    int max_lazy,
+                                    int nice_length,
+                                    int max_chain));
+/*
+     Fine tune deflate's internal compression parameters.  This should only be
+   used by someone who understands the algorithm used by zlib's deflate for
+   searching for the best matching string, and even then only by the most
+   fanatic optimizer trying to squeeze out the last compressed bit for their
+   specific input data.  Read the deflate.c source code for the meaning of the
+   max_lazy, good_length, nice_length, and max_chain parameters.
+
+     deflateTune() can be called after deflateInit() or deflateInit2(), and
+   returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream.
+ */
+
+ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm,
+                                       uLong sourceLen));
+/*
+     deflateBound() returns an upper bound on the compressed size after
+   deflation of sourceLen bytes.  It must be called after deflateInit() or
+   deflateInit2(), and after deflateSetHeader(), if used.  This would be used
+   to allocate an output buffer for deflation in a single pass, and so would be
+   called before deflate().  If that first deflate() call is provided the
+   sourceLen input bytes, an output buffer allocated to the size returned by
+   deflateBound(), and the flush value Z_FINISH, then deflate() is guaranteed
+   to return Z_STREAM_END.  Note that it is possible for the compressed size to
+   be larger than the value returned by deflateBound() if flush options other
+   than Z_FINISH or Z_NO_FLUSH are used.
+*/
+
+ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm,
+                                       unsigned *pending,
+                                       int *bits));
+/*
+     deflatePending() returns the number of bytes and bits of output that have
+   been generated, but not yet provided in the available output.  The bytes not
+   provided would be due to the available output space having being consumed.
+   The number of bits of output not provided are between 0 and 7, where they
+   await more bits to join them in order to fill out a full byte.  If pending
+   or bits are Z_NULL, then those values are not set.
+
+     deflatePending returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+ */
+
+ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm,
+                                     int bits,
+                                     int value));
+/*
+     deflatePrime() inserts bits in the deflate output stream.  The intent
+   is that this function is used to start off the deflate output with the bits
+   leftover from a previous deflate stream when appending to it.  As such, this
+   function can only be used for raw deflate, and must be used before the first
+   deflate() call after a deflateInit2() or deflateReset().  bits must be less
+   than or equal to 16, and that many of the least significant bits of value
+   will be inserted in the output.
+
+     deflatePrime returns Z_OK if success, Z_BUF_ERROR if there was not enough
+   room in the internal buffer to insert the bits, or Z_STREAM_ERROR if the
+   source stream state was inconsistent.
+*/
+
+ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm,
+                                         gz_headerp head));
+/*
+     deflateSetHeader() provides gzip header information for when a gzip
+   stream is requested by deflateInit2().  deflateSetHeader() may be called
+   after deflateInit2() or deflateReset() and before the first call of
+   deflate().  The text, time, os, extra field, name, and comment information
+   in the provided gz_header structure are written to the gzip header (xflag is
+   ignored -- the extra flags are set according to the compression level).  The
+   caller must assure that, if not Z_NULL, name and comment are terminated with
+   a zero byte, and that if extra is not Z_NULL, that extra_len bytes are
+   available there.  If hcrc is true, a gzip header crc is included.  Note that
+   the current versions of the command-line version of gzip (up through version
+   1.3.x) do not support header crc's, and will report that it is a "multi-part
+   gzip file" and give up.
+
+     If deflateSetHeader is not used, the default gzip header has text false,
+   the time set to zero, and os set to 255, with no extra, name, or comment
+   fields.  The gzip header is returned to the default state by deflateReset().
+
+     deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+/*
+ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
+                                     int  windowBits));
+
+     This is another version of inflateInit with an extra parameter.  The
+   fields next_in, avail_in, zalloc, zfree and opaque must be initialized
+   before by the caller.
+
+     The windowBits parameter is the base two logarithm of the maximum window
+   size (the size of the history buffer).  It should be in the range 8..15 for
+   this version of the library.  The default value is 15 if inflateInit is used
+   instead.  windowBits must be greater than or equal to the windowBits value
+   provided to deflateInit2() while compressing, or it must be equal to 15 if
+   deflateInit2() was not used.  If a compressed stream with a larger window
+   size is given as input, inflate() will return with the error code
+   Z_DATA_ERROR instead of trying to allocate a larger window.
+
+     windowBits can also be zero to request that inflate use the window size in
+   the zlib header of the compressed stream.
+
+     windowBits can also be -8..-15 for raw inflate.  In this case, -windowBits
+   determines the window size.  inflate() will then process raw deflate data,
+   not looking for a zlib or gzip header, not generating a check value, and not
+   looking for any check values for comparison at the end of the stream.  This
+   is for use with other formats that use the deflate compressed data format
+   such as zip.  Those formats provide their own check values.  If a custom
+   format is developed using the raw deflate format for compressed data, it is
+   recommended that a check value such as an Adler-32 or a CRC-32 be applied to
+   the uncompressed data as is done in the zlib, gzip, and zip formats.  For
+   most applications, the zlib format should be used as is.  Note that comments
+   above on the use in deflateInit2() applies to the magnitude of windowBits.
+
+     windowBits can also be greater than 15 for optional gzip decoding.  Add
+   32 to windowBits to enable zlib and gzip decoding with automatic header
+   detection, or add 16 to decode only the gzip format (the zlib format will
+   return a Z_DATA_ERROR).  If a gzip stream is being decoded, strm->adler is a
+   CRC-32 instead of an Adler-32.  Unlike the gunzip utility and gzread() (see
+   below), inflate() will not automatically decode concatenated gzip streams.
+   inflate() will return Z_STREAM_END at the end of the gzip stream.  The state
+   would need to be reset to continue decoding a subsequent gzip stream.
+
+     inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
+   version assumed by the caller, or Z_STREAM_ERROR if the parameters are
+   invalid, such as a null pointer to the structure.  msg is set to null if
+   there is no error message.  inflateInit2 does not perform any decompression
+   apart from possibly reading the zlib header if present: actual decompression
+   will be done by inflate().  (So next_in and avail_in may be modified, but
+   next_out and avail_out are unused and unchanged.) The current implementation
+   of inflateInit2() does not process any header information -- that is
+   deferred until inflate() is called.
+*/
+
+ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
+                                             const Bytef *dictionary,
+                                             uInt  dictLength));
+/*
+     Initializes the decompression dictionary from the given uncompressed byte
+   sequence.  This function must be called immediately after a call of inflate,
+   if that call returned Z_NEED_DICT.  The dictionary chosen by the compressor
+   can be determined from the Adler-32 value returned by that call of inflate.
+   The compressor and decompressor must use exactly the same dictionary (see
+   deflateSetDictionary).  For raw inflate, this function can be called at any
+   time to set the dictionary.  If the provided dictionary is smaller than the
+   window and there is already data in the window, then the provided dictionary
+   will amend what's there.  The application must insure that the dictionary
+   that was used for compression is provided.
+
+     inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
+   parameter is invalid (e.g.  dictionary being Z_NULL) or the stream state is
+   inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
+   expected one (incorrect Adler-32 value).  inflateSetDictionary does not
+   perform any decompression: this will be done by subsequent calls of
+   inflate().
+*/
+
+ZEXTERN int ZEXPORT inflateGetDictionary OF((z_streamp strm,
+                                             Bytef *dictionary,
+                                             uInt  *dictLength));
+/*
+     Returns the sliding dictionary being maintained by inflate.  dictLength is
+   set to the number of bytes in the dictionary, and that many bytes are copied
+   to dictionary.  dictionary must have enough space, where 32768 bytes is
+   always enough.  If inflateGetDictionary() is called with dictionary equal to
+   Z_NULL, then only the dictionary length is returned, and nothing is copied.
+   Similary, if dictLength is Z_NULL, then it is not set.
+
+     inflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the
+   stream state is inconsistent.
+*/
+
+ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
+/*
+     Skips invalid compressed data until a possible full flush point (see above
+   for the description of deflate with Z_FULL_FLUSH) can be found, or until all
+   available input is skipped.  No output is provided.
+
+     inflateSync searches for a 00 00 FF FF pattern in the compressed data.
+   All full flush points have this pattern, but not all occurrences of this
+   pattern are full flush points.
+
+     inflateSync returns Z_OK if a possible full flush point has been found,
+   Z_BUF_ERROR if no more input was provided, Z_DATA_ERROR if no flush point
+   has been found, or Z_STREAM_ERROR if the stream structure was inconsistent.
+   In the success case, the application may save the current current value of
+   total_in which indicates where valid compressed data was found.  In the
+   error case, the application may repeatedly call inflateSync, providing more
+   input each time, until success or end of the input data.
+*/
+
+ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest,
+                                    z_streamp source));
+/*
+     Sets the destination stream as a complete copy of the source stream.
+
+     This function can be useful when randomly accessing a large stream.  The
+   first pass through the stream can periodically record the inflate state,
+   allowing restarting inflate at those points when randomly accessing the
+   stream.
+
+     inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+   (such as zalloc being Z_NULL).  msg is left unchanged in both source and
+   destination.
+*/
+
+ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
+/*
+     This function is equivalent to inflateEnd followed by inflateInit,
+   but does not free and reallocate the internal decompression state.  The
+   stream will keep attributes that may have been set by inflateInit2.
+
+     inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being Z_NULL).
+*/
+
+ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm,
+                                      int windowBits));
+/*
+     This function is the same as inflateReset, but it also permits changing
+   the wrap and window size requests.  The windowBits parameter is interpreted
+   the same as it is for inflateInit2.  If the window size is changed, then the
+   memory allocated for the window is freed, and the window will be reallocated
+   by inflate() if needed.
+
+     inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being Z_NULL), or if
+   the windowBits parameter is invalid.
+*/
+
+ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm,
+                                     int bits,
+                                     int value));
+/*
+     This function inserts bits in the inflate input stream.  The intent is
+   that this function is used to start inflating at a bit position in the
+   middle of a byte.  The provided bits will be used before any bytes are used
+   from next_in.  This function should only be used with raw inflate, and
+   should be used before the first inflate() call after inflateInit2() or
+   inflateReset().  bits must be less than or equal to 16, and that many of the
+   least significant bits of value will be inserted in the input.
+
+     If bits is negative, then the input stream bit buffer is emptied.  Then
+   inflatePrime() can be called again to put bits in the buffer.  This is used
+   to clear out bits leftover after feeding inflate a block description prior
+   to feeding inflate codes.
+
+     inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm));
+/*
+     This function returns two values, one in the lower 16 bits of the return
+   value, and the other in the remaining upper bits, obtained by shifting the
+   return value down 16 bits.  If the upper value is -1 and the lower value is
+   zero, then inflate() is currently decoding information outside of a block.
+   If the upper value is -1 and the lower value is non-zero, then inflate is in
+   the middle of a stored block, with the lower value equaling the number of
+   bytes from the input remaining to copy.  If the upper value is not -1, then
+   it is the number of bits back from the current bit position in the input of
+   the code (literal or length/distance pair) currently being processed.  In
+   that case the lower value is the number of bytes already emitted for that
+   code.
+
+     A code is being processed if inflate is waiting for more input to complete
+   decoding of the code, or if it has completed decoding but is waiting for
+   more output space to write the literal or match data.
+
+     inflateMark() is used to mark locations in the input data for random
+   access, which may be at bit positions, and to note those cases where the
+   output of a code may span boundaries of random access blocks.  The current
+   location in the input stream can be determined from avail_in and data_type
+   as noted in the description for the Z_BLOCK flush parameter for inflate.
+
+     inflateMark returns the value noted above, or -65536 if the provided
+   source stream state was inconsistent.
+*/
+
+ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm,
+                                         gz_headerp head));
+/*
+     inflateGetHeader() requests that gzip header information be stored in the
+   provided gz_header structure.  inflateGetHeader() may be called after
+   inflateInit2() or inflateReset(), and before the first call of inflate().
+   As inflate() processes the gzip stream, head->done is zero until the header
+   is completed, at which time head->done is set to one.  If a zlib stream is
+   being decoded, then head->done is set to -1 to indicate that there will be
+   no gzip header information forthcoming.  Note that Z_BLOCK or Z_TREES can be
+   used to force inflate() to return immediately after header processing is
+   complete and before any actual data is decompressed.
+
+     The text, time, xflags, and os fields are filled in with the gzip header
+   contents.  hcrc is set to true if there is a header CRC.  (The header CRC
+   was valid if done is set to one.) If extra is not Z_NULL, then extra_max
+   contains the maximum number of bytes to write to extra.  Once done is true,
+   extra_len contains the actual extra field length, and extra contains the
+   extra field, or that field truncated if extra_max is less than extra_len.
+   If name is not Z_NULL, then up to name_max characters are written there,
+   terminated with a zero unless the length is greater than name_max.  If
+   comment is not Z_NULL, then up to comm_max characters are written there,
+   terminated with a zero unless the length is greater than comm_max.  When any
+   of extra, name, or comment are not Z_NULL and the respective field is not
+   present in the header, then that field is set to Z_NULL to signal its
+   absence.  This allows the use of deflateSetHeader() with the returned
+   structure to duplicate the header.  However if those fields are set to
+   allocated memory, then the application will need to save those pointers
+   elsewhere so that they can be eventually freed.
+
+     If inflateGetHeader is not used, then the header information is simply
+   discarded.  The header is always checked for validity, including the header
+   CRC if present.  inflateReset() will reset the process to discard the header
+   information.  The application would need to call inflateGetHeader() again to
+   retrieve the header from the next gzip stream.
+
+     inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+/*
+ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits,
+                                        unsigned char FAR *window));
+
+     Initialize the internal stream state for decompression using inflateBack()
+   calls.  The fields zalloc, zfree and opaque in strm must be initialized
+   before the call.  If zalloc and zfree are Z_NULL, then the default library-
+   derived memory allocation routines are used.  windowBits is the base two
+   logarithm of the window size, in the range 8..15.  window is a caller
+   supplied buffer of that size.  Except for special applications where it is
+   assured that deflate was used with small window sizes, windowBits must be 15
+   and a 32K byte window must be supplied to be able to decompress general
+   deflate streams.
+
+     See inflateBack() for the usage of these routines.
+
+     inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of
+   the parameters are invalid, Z_MEM_ERROR if the internal state could not be
+   allocated, or Z_VERSION_ERROR if the version of the library does not match
+   the version of the header file.
+*/
+
+typedef unsigned (*in_func) OF((void FAR *,
+                                z_const unsigned char FAR * FAR *));
+typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned));
+
+ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm,
+                                    in_func in, void FAR *in_desc,
+                                    out_func out, void FAR *out_desc));
+/*
+     inflateBack() does a raw inflate with a single call using a call-back
+   interface for input and output.  This is potentially more efficient than
+   inflate() for file i/o applications, in that it avoids copying between the
+   output and the sliding window by simply making the window itself the output
+   buffer.  inflate() can be faster on modern CPUs when used with large
+   buffers.  inflateBack() trusts the application to not change the output
+   buffer passed by the output function, at least until inflateBack() returns.
+
+     inflateBackInit() must be called first to allocate the internal state
+   and to initialize the state with the user-provided window buffer.
+   inflateBack() may then be used multiple times to inflate a complete, raw
+   deflate stream with each call.  inflateBackEnd() is then called to free the
+   allocated state.
+
+     A raw deflate stream is one with no zlib or gzip header or trailer.
+   This routine would normally be used in a utility that reads zip or gzip
+   files and writes out uncompressed files.  The utility would decode the
+   header and process the trailer on its own, hence this routine expects only
+   the raw deflate stream to decompress.  This is different from the default
+   behavior of inflate(), which expects a zlib header and trailer around the
+   deflate stream.
+
+     inflateBack() uses two subroutines supplied by the caller that are then
+   called by inflateBack() for input and output.  inflateBack() calls those
+   routines until it reads a complete deflate stream and writes out all of the
+   uncompressed data, or until it encounters an error.  The function's
+   parameters and return types are defined above in the in_func and out_func
+   typedefs.  inflateBack() will call in(in_desc, &buf) which should return the
+   number of bytes of provided input, and a pointer to that input in buf.  If
+   there is no input available, in() must return zero -- buf is ignored in that
+   case -- and inflateBack() will return a buffer error.  inflateBack() will
+   call out(out_desc, buf, len) to write the uncompressed data buf[0..len-1].
+   out() should return zero on success, or non-zero on failure.  If out()
+   returns non-zero, inflateBack() will return with an error.  Neither in() nor
+   out() are permitted to change the contents of the window provided to
+   inflateBackInit(), which is also the buffer that out() uses to write from.
+   The length written by out() will be at most the window size.  Any non-zero
+   amount of input may be provided by in().
+
+     For convenience, inflateBack() can be provided input on the first call by
+   setting strm->next_in and strm->avail_in.  If that input is exhausted, then
+   in() will be called.  Therefore strm->next_in must be initialized before
+   calling inflateBack().  If strm->next_in is Z_NULL, then in() will be called
+   immediately for input.  If strm->next_in is not Z_NULL, then strm->avail_in
+   must also be initialized, and then if strm->avail_in is not zero, input will
+   initially be taken from strm->next_in[0 ..  strm->avail_in - 1].
+
+     The in_desc and out_desc parameters of inflateBack() is passed as the
+   first parameter of in() and out() respectively when they are called.  These
+   descriptors can be optionally used to pass any information that the caller-
+   supplied in() and out() functions need to do their job.
+
+     On return, inflateBack() will set strm->next_in and strm->avail_in to
+   pass back any unused input that was provided by the last in() call.  The
+   return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR
+   if in() or out() returned an error, Z_DATA_ERROR if there was a format error
+   in the deflate stream (in which case strm->msg is set to indicate the nature
+   of the error), or Z_STREAM_ERROR if the stream was not properly initialized.
+   In the case of Z_BUF_ERROR, an input or output error can be distinguished
+   using strm->next_in which will be Z_NULL only if in() returned an error.  If
+   strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning
+   non-zero.  (in() will always be called before out(), so strm->next_in is
+   assured to be defined if out() returns non-zero.)  Note that inflateBack()
+   cannot return Z_OK.
+*/
+
+ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm));
+/*
+     All memory allocated by inflateBackInit() is freed.
+
+     inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream
+   state was inconsistent.
+*/
+
+ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void));
+/* Return flags indicating compile-time options.
+
+    Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other:
+     1.0: size of uInt
+     3.2: size of uLong
+     5.4: size of voidpf (pointer)
+     7.6: size of z_off_t
+
+    Compiler, assembler, and debug options:
+     8: ZLIB_DEBUG
+     9: ASMV or ASMINF -- use ASM code
+     10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention
+     11: 0 (reserved)
+
+    One-time table building (smaller code, but not thread-safe if true):
+     12: BUILDFIXED -- build static block decoding tables when needed
+     13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed
+     14,15: 0 (reserved)
+
+    Library content (indicates missing functionality):
+     16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking
+                          deflate code when not needed)
+     17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect
+                    and decode gzip streams (to avoid linking crc code)
+     18-19: 0 (reserved)
+
+    Operation variations (changes in library functionality):
+     20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate
+     21: FASTEST -- deflate algorithm with only one, lowest compression level
+     22,23: 0 (reserved)
+
+    The sprintf variant used by gzprintf (zero is best):
+     24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format
+     25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure!
+     26: 0 = returns value, 1 = void -- 1 means inferred string length returned
+
+    Remainder:
+     27-31: 0 (reserved)
+ */
+
+#ifndef Z_SOLO
+
+                        /* utility functions */
+
+/*
+     The following utility functions are implemented on top of the basic
+   stream-oriented functions.  To simplify the interface, some default options
+   are assumed (compression level and memory usage, standard memory allocation
+   functions).  The source code of these utility functions can be modified if
+   you need special options.
+*/
+
+ZEXTERN int ZEXPORT compress OF((Bytef *dest,   uLongf *destLen,
+                                 const Bytef *source, uLong sourceLen));
+/*
+     Compresses the source buffer into the destination buffer.  sourceLen is
+   the byte length of the source buffer.  Upon entry, destLen is the total size
+   of the destination buffer, which must be at least the value returned by
+   compressBound(sourceLen).  Upon exit, destLen is the actual size of the
+   compressed data.  compress() is equivalent to compress2() with a level
+   parameter of Z_DEFAULT_COMPRESSION.
+
+     compress returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_BUF_ERROR if there was not enough room in the output
+   buffer.
+*/
+
+ZEXTERN int ZEXPORT compress2 OF((Bytef *dest,   uLongf *destLen,
+                                  const Bytef *source, uLong sourceLen,
+                                  int level));
+/*
+     Compresses the source buffer into the destination buffer.  The level
+   parameter has the same meaning as in deflateInit.  sourceLen is the byte
+   length of the source buffer.  Upon entry, destLen is the total size of the
+   destination buffer, which must be at least the value returned by
+   compressBound(sourceLen).  Upon exit, destLen is the actual size of the
+   compressed data.
+
+     compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_BUF_ERROR if there was not enough room in the output buffer,
+   Z_STREAM_ERROR if the level parameter is invalid.
+*/
+
+ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen));
+/*
+     compressBound() returns an upper bound on the compressed size after
+   compress() or compress2() on sourceLen bytes.  It would be used before a
+   compress() or compress2() call to allocate the destination buffer.
+*/
+
+ZEXTERN int ZEXPORT uncompress OF((Bytef *dest,   uLongf *destLen,
+                                   const Bytef *source, uLong sourceLen));
+/*
+     Decompresses the source buffer into the destination buffer.  sourceLen is
+   the byte length of the source buffer.  Upon entry, destLen is the total size
+   of the destination buffer, which must be large enough to hold the entire
+   uncompressed data.  (The size of the uncompressed data must have been saved
+   previously by the compressor and transmitted to the decompressor by some
+   mechanism outside the scope of this compression library.) Upon exit, destLen
+   is the actual size of the uncompressed data.
+
+     uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_BUF_ERROR if there was not enough room in the output
+   buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete.  In
+   the case where there is not enough room, uncompress() will fill the output
+   buffer with the uncompressed data up to that point.
+*/
+
+ZEXTERN int ZEXPORT uncompress2 OF((Bytef *dest,   uLongf *destLen,
+                                    const Bytef *source, uLong *sourceLen));
+/*
+     Same as uncompress, except that sourceLen is a pointer, where the
+   length of the source is *sourceLen.  On return, *sourceLen is the number of
+   source bytes consumed.
+*/
+
+                        /* gzip file access functions */
+
+/*
+     This library supports reading and writing files in gzip (.gz) format with
+   an interface similar to that of stdio, using the functions that start with
+   "gz".  The gzip format is different from the zlib format.  gzip is a gzip
+   wrapper, documented in RFC 1952, wrapped around a deflate stream.
+*/
+
+typedef struct gzFile_s *gzFile;    /* semi-opaque gzip file descriptor */
+
+/*
+ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode));
+
+     Opens a gzip (.gz) file for reading or writing.  The mode parameter is as
+   in fopen ("rb" or "wb") but can also include a compression level ("wb9") or
+   a strategy: 'f' for filtered data as in "wb6f", 'h' for Huffman-only
+   compression as in "wb1h", 'R' for run-length encoding as in "wb1R", or 'F'
+   for fixed code compression as in "wb9F".  (See the description of
+   deflateInit2 for more information about the strategy parameter.)  'T' will
+   request transparent writing or appending with no compression and not using
+   the gzip format.
+
+     "a" can be used instead of "w" to request that the gzip stream that will
+   be written be appended to the file.  "+" will result in an error, since
+   reading and writing to the same gzip file is not supported.  The addition of
+   "x" when writing will create the file exclusively, which fails if the file
+   already exists.  On systems that support it, the addition of "e" when
+   reading or writing will set the flag to close the file on an execve() call.
+
+     These functions, as well as gzip, will read and decode a sequence of gzip
+   streams in a file.  The append function of gzopen() can be used to create
+   such a file.  (Also see gzflush() for another way to do this.)  When
+   appending, gzopen does not test whether the file begins with a gzip stream,
+   nor does it look for the end of the gzip streams to begin appending.  gzopen
+   will simply append a gzip stream to the existing file.
+
+     gzopen can be used to read a file which is not in gzip format; in this
+   case gzread will directly read from the file without decompression.  When
+   reading, this will be detected automatically by looking for the magic two-
+   byte gzip header.
+
+     gzopen returns NULL if the file could not be opened, if there was
+   insufficient memory to allocate the gzFile state, or if an invalid mode was
+   specified (an 'r', 'w', or 'a' was not provided, or '+' was provided).
+   errno can be checked to determine if the reason gzopen failed was that the
+   file could not be opened.
+*/
+
+ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode));
+/*
+     gzdopen associates a gzFile with the file descriptor fd.  File descriptors
+   are obtained from calls like open, dup, creat, pipe or fileno (if the file
+   has been previously opened with fopen).  The mode parameter is as in gzopen.
+
+     The next call of gzclose on the returned gzFile will also close the file
+   descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor
+   fd.  If you want to keep fd open, use fd = dup(fd_keep); gz = gzdopen(fd,
+   mode);.  The duplicated descriptor should be saved to avoid a leak, since
+   gzdopen does not close fd if it fails.  If you are using fileno() to get the
+   file descriptor from a FILE *, then you will have to use dup() to avoid
+   double-close()ing the file descriptor.  Both gzclose() and fclose() will
+   close the associated file descriptor, so they need to have different file
+   descriptors.
+
+     gzdopen returns NULL if there was insufficient memory to allocate the
+   gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not
+   provided, or '+' was provided), or if fd is -1.  The file descriptor is not
+   used until the next gz* read, write, seek, or close operation, so gzdopen
+   will not detect if fd is invalid (unless fd is -1).
+*/
+
+ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size));
+/*
+     Set the internal buffer size used by this library's functions.  The
+   default buffer size is 8192 bytes.  This function must be called after
+   gzopen() or gzdopen(), and before any other calls that read or write the
+   file.  The buffer memory allocation is always deferred to the first read or
+   write.  Three times that size in buffer space is allocated.  A larger buffer
+   size of, for example, 64K or 128K bytes will noticeably increase the speed
+   of decompression (reading).
+
+     The new buffer size also affects the maximum length for gzprintf().
+
+     gzbuffer() returns 0 on success, or -1 on failure, such as being called
+   too late.
+*/
+
+ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
+/*
+     Dynamically update the compression level or strategy.  See the description
+   of deflateInit2 for the meaning of these parameters.  Previously provided
+   data is flushed before the parameter change.
+
+     gzsetparams returns Z_OK if success, Z_STREAM_ERROR if the file was not
+   opened for writing, Z_ERRNO if there is an error writing the flushed data,
+   or Z_MEM_ERROR if there is a memory allocation error.
+*/
+
+ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len));
+/*
+     Reads the given number of uncompressed bytes from the compressed file.  If
+   the input file is not in gzip format, gzread copies the given number of
+   bytes into the buffer directly from the file.
+
+     After reaching the end of a gzip stream in the input, gzread will continue
+   to read, looking for another gzip stream.  Any number of gzip streams may be
+   concatenated in the input file, and will all be decompressed by gzread().
+   If something other than a gzip stream is encountered after a gzip stream,
+   that remaining trailing garbage is ignored (and no error is returned).
+
+     gzread can be used to read a gzip file that is being concurrently written.
+   Upon reaching the end of the input, gzread will return with the available
+   data.  If the error code returned by gzerror is Z_OK or Z_BUF_ERROR, then
+   gzclearerr can be used to clear the end of file indicator in order to permit
+   gzread to be tried again.  Z_OK indicates that a gzip stream was completed
+   on the last gzread.  Z_BUF_ERROR indicates that the input file ended in the
+   middle of a gzip stream.  Note that gzread does not return -1 in the event
+   of an incomplete gzip stream.  This error is deferred until gzclose(), which
+   will return Z_BUF_ERROR if the last gzread ended in the middle of a gzip
+   stream.  Alternatively, gzerror can be used before gzclose to detect this
+   case.
+
+     gzread returns the number of uncompressed bytes actually read, less than
+   len for end of file, or -1 for error.  If len is too large to fit in an int,
+   then nothing is read, -1 is returned, and the error state is set to
+   Z_STREAM_ERROR.
+*/
+
+ZEXTERN z_size_t ZEXPORT gzfread OF((voidp buf, z_size_t size, z_size_t nitems,
+                                     gzFile file));
+/*
+     Read up to nitems items of size size from file to buf, otherwise operating
+   as gzread() does.  This duplicates the interface of stdio's fread(), with
+   size_t request and return types.  If the library defines size_t, then
+   z_size_t is identical to size_t.  If not, then z_size_t is an unsigned
+   integer type that can contain a pointer.
+
+     gzfread() returns the number of full items read of size size, or zero if
+   the end of the file was reached and a full item could not be read, or if
+   there was an error.  gzerror() must be consulted if zero is returned in
+   order to determine if there was an error.  If the multiplication of size and
+   nitems overflows, i.e. the product does not fit in a z_size_t, then nothing
+   is read, zero is returned, and the error state is set to Z_STREAM_ERROR.
+
+     In the event that the end of file is reached and only a partial item is
+   available at the end, i.e. the remaining uncompressed data length is not a
+   multiple of size, then the final partial item is nevetheless read into buf
+   and the end-of-file flag is set.  The length of the partial item read is not
+   provided, but could be inferred from the result of gztell().  This behavior
+   is the same as the behavior of fread() implementations in common libraries,
+   but it prevents the direct use of gzfread() to read a concurrently written
+   file, reseting and retrying on end-of-file, when size is not 1.
+*/
+
+ZEXTERN int ZEXPORT gzwrite OF((gzFile file,
+                                voidpc buf, unsigned len));
+/*
+     Writes the given number of uncompressed bytes into the compressed file.
+   gzwrite returns the number of uncompressed bytes written or 0 in case of
+   error.
+*/
+
+ZEXTERN z_size_t ZEXPORT gzfwrite OF((voidpc buf, z_size_t size,
+                                      z_size_t nitems, gzFile file));
+/*
+     gzfwrite() writes nitems items of size size from buf to file, duplicating
+   the interface of stdio's fwrite(), with size_t request and return types.  If
+   the library defines size_t, then z_size_t is identical to size_t.  If not,
+   then z_size_t is an unsigned integer type that can contain a pointer.
+
+     gzfwrite() returns the number of full items written of size size, or zero
+   if there was an error.  If the multiplication of size and nitems overflows,
+   i.e. the product does not fit in a z_size_t, then nothing is written, zero
+   is returned, and the error state is set to Z_STREAM_ERROR.
+*/
+
+ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...));
+/*
+     Converts, formats, and writes the arguments to the compressed file under
+   control of the format string, as in fprintf.  gzprintf returns the number of
+   uncompressed bytes actually written, or a negative zlib error code in case
+   of error.  The number of uncompressed bytes written is limited to 8191, or
+   one less than the buffer size given to gzbuffer().  The caller should assure
+   that this limit is not exceeded.  If it is exceeded, then gzprintf() will
+   return an error (0) with nothing written.  In this case, there may also be a
+   buffer overflow with unpredictable consequences, which is possible only if
+   zlib was compiled with the insecure functions sprintf() or vsprintf()
+   because the secure snprintf() or vsnprintf() functions were not available.
+   This can be determined using zlibCompileFlags().
+*/
+
+ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
+/*
+     Writes the given null-terminated string to the compressed file, excluding
+   the terminating null character.
+
+     gzputs returns the number of characters written, or -1 in case of error.
+*/
+
+ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len));
+/*
+     Reads bytes from the compressed file until len-1 characters are read, or a
+   newline character is read and transferred to buf, or an end-of-file
+   condition is encountered.  If any characters are read or if len == 1, the
+   string is terminated with a null character.  If no characters are read due
+   to an end-of-file or len < 1, then the buffer is left untouched.
+
+     gzgets returns buf which is a null-terminated string, or it returns NULL
+   for end-of-file or in case of error.  If there was an error, the contents at
+   buf are indeterminate.
+*/
+
+ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c));
+/*
+     Writes c, converted to an unsigned char, into the compressed file.  gzputc
+   returns the value that was written, or -1 in case of error.
+*/
+
+ZEXTERN int ZEXPORT gzgetc OF((gzFile file));
+/*
+     Reads one byte from the compressed file.  gzgetc returns this byte or -1
+   in case of end of file or error.  This is implemented as a macro for speed.
+   As such, it does not do all of the checking the other functions do.  I.e.
+   it does not check to see if file is NULL, nor whether the structure file
+   points to has been clobbered or not.
+*/
+
+ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file));
+/*
+     Push one character back onto the stream to be read as the first character
+   on the next read.  At least one character of push-back is allowed.
+   gzungetc() returns the character pushed, or -1 on failure.  gzungetc() will
+   fail if c is -1, and may fail if a character has been pushed but not read
+   yet.  If gzungetc is used immediately after gzopen or gzdopen, at least the
+   output buffer size of pushed characters is allowed.  (See gzbuffer above.)
+   The pushed character will be discarded if the stream is repositioned with
+   gzseek() or gzrewind().
+*/
+
+ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush));
+/*
+     Flushes all pending output into the compressed file.  The parameter flush
+   is as in the deflate() function.  The return value is the zlib error number
+   (see function gzerror below).  gzflush is only permitted when writing.
+
+     If the flush parameter is Z_FINISH, the remaining data is written and the
+   gzip stream is completed in the output.  If gzwrite() is called again, a new
+   gzip stream will be started in the output.  gzread() is able to read such
+   concatenated gzip streams.
+
+     gzflush should be called only when strictly necessary because it will
+   degrade compression if called too often.
+*/
+
+/*
+ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file,
+                                   z_off_t offset, int whence));
+
+     Sets the starting position for the next gzread or gzwrite on the given
+   compressed file.  The offset represents a number of bytes in the
+   uncompressed data stream.  The whence parameter is defined as in lseek(2);
+   the value SEEK_END is not supported.
+
+     If the file is opened for reading, this function is emulated but can be
+   extremely slow.  If the file is opened for writing, only forward seeks are
+   supported; gzseek then compresses a sequence of zeroes up to the new
+   starting position.
+
+     gzseek returns the resulting offset location as measured in bytes from
+   the beginning of the uncompressed stream, or -1 in case of error, in
+   particular if the file is opened for writing and the new starting position
+   would be before the current position.
+*/
+
+ZEXTERN int ZEXPORT    gzrewind OF((gzFile file));
+/*
+     Rewinds the given file. This function is supported only for reading.
+
+     gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
+*/
+
+/*
+ZEXTERN z_off_t ZEXPORT    gztell OF((gzFile file));
+
+     Returns the starting position for the next gzread or gzwrite on the given
+   compressed file.  This position represents a number of bytes in the
+   uncompressed data stream, and is zero when starting, even if appending or
+   reading a gzip stream from the middle of a file using gzdopen().
+
+     gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
+*/
+
+/*
+ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file));
+
+     Returns the current offset in the file being read or written.  This offset
+   includes the count of bytes that precede the gzip stream, for example when
+   appending or when using gzdopen() for reading.  When reading, the offset
+   does not include as yet unused buffered input.  This information can be used
+   for a progress indicator.  On error, gzoffset() returns -1.
+*/
+
+ZEXTERN int ZEXPORT gzeof OF((gzFile file));
+/*
+     Returns true (1) if the end-of-file indicator has been set while reading,
+   false (0) otherwise.  Note that the end-of-file indicator is set only if the
+   read tried to go past the end of the input, but came up short.  Therefore,
+   just like feof(), gzeof() may return false even if there is no more data to
+   read, in the event that the last read request was for the exact number of
+   bytes remaining in the input file.  This will happen if the input file size
+   is an exact multiple of the buffer size.
+
+     If gzeof() returns true, then the read functions will return no more data,
+   unless the end-of-file indicator is reset by gzclearerr() and the input file
+   has grown since the previous end of file was detected.
+*/
+
+ZEXTERN int ZEXPORT gzdirect OF((gzFile file));
+/*
+     Returns true (1) if file is being copied directly while reading, or false
+   (0) if file is a gzip stream being decompressed.
+
+     If the input file is empty, gzdirect() will return true, since the input
+   does not contain a gzip stream.
+
+     If gzdirect() is used immediately after gzopen() or gzdopen() it will
+   cause buffers to be allocated to allow reading the file to determine if it
+   is a gzip file.  Therefore if gzbuffer() is used, it should be called before
+   gzdirect().
+
+     When writing, gzdirect() returns true (1) if transparent writing was
+   requested ("wT" for the gzopen() mode), or false (0) otherwise.  (Note:
+   gzdirect() is not needed when writing.  Transparent writing must be
+   explicitly requested, so the application already knows the answer.  When
+   linking statically, using gzdirect() will include all of the zlib code for
+   gzip file reading and decompression, which may not be desired.)
+*/
+
+ZEXTERN int ZEXPORT    gzclose OF((gzFile file));
+/*
+     Flushes all pending output if necessary, closes the compressed file and
+   deallocates the (de)compression state.  Note that once file is closed, you
+   cannot call gzerror with file, since its structures have been deallocated.
+   gzclose must not be called more than once on the same file, just as free
+   must not be called more than once on the same allocation.
+
+     gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a
+   file operation error, Z_MEM_ERROR if out of memory, Z_BUF_ERROR if the
+   last read ended in the middle of a gzip stream, or Z_OK on success.
+*/
+
+ZEXTERN int ZEXPORT gzclose_r OF((gzFile file));
+ZEXTERN int ZEXPORT gzclose_w OF((gzFile file));
+/*
+     Same as gzclose(), but gzclose_r() is only for use when reading, and
+   gzclose_w() is only for use when writing or appending.  The advantage to
+   using these instead of gzclose() is that they avoid linking in zlib
+   compression or decompression code that is not used when only reading or only
+   writing respectively.  If gzclose() is used, then both compression and
+   decompression code will be included the application when linking to a static
+   zlib library.
+*/
+
+ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum));
+/*
+     Returns the error message for the last error which occurred on the given
+   compressed file.  errnum is set to zlib error number.  If an error occurred
+   in the file system and not in the compression library, errnum is set to
+   Z_ERRNO and the application may consult errno to get the exact error code.
+
+     The application must not modify the returned string.  Future calls to
+   this function may invalidate the previously returned string.  If file is
+   closed, then the string previously returned by gzerror will no longer be
+   available.
+
+     gzerror() should be used to distinguish errors from end-of-file for those
+   functions above that do not distinguish those cases in their return values.
+*/
+
+ZEXTERN void ZEXPORT gzclearerr OF((gzFile file));
+/*
+     Clears the error and end-of-file flags for file.  This is analogous to the
+   clearerr() function in stdio.  This is useful for continuing to read a gzip
+   file that is being written concurrently.
+*/
+
+#endif /* !Z_SOLO */
+
+                        /* checksum functions */
+
+/*
+     These functions are not related to compression but are exported
+   anyway because they might be useful in applications using the compression
+   library.
+*/
+
+ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
+/*
+     Update a running Adler-32 checksum with the bytes buf[0..len-1] and
+   return the updated checksum.  If buf is Z_NULL, this function returns the
+   required initial value for the checksum.
+
+     An Adler-32 checksum is almost as reliable as a CRC-32 but can be computed
+   much faster.
+
+   Usage example:
+
+     uLong adler = adler32(0L, Z_NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       adler = adler32(adler, buffer, length);
+     }
+     if (adler != original_adler) error();
+*/
+
+ZEXTERN uLong ZEXPORT adler32_z OF((uLong adler, const Bytef *buf,
+                                    z_size_t len));
+/*
+     Same as adler32(), but with a size_t length.
+*/
+
+/*
+ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2,
+                                          z_off_t len2));
+
+     Combine two Adler-32 checksums into one.  For two sequences of bytes, seq1
+   and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for
+   each, adler1 and adler2.  adler32_combine() returns the Adler-32 checksum of
+   seq1 and seq2 concatenated, requiring only adler1, adler2, and len2.  Note
+   that the z_off_t type (like off_t) is a signed integer.  If len2 is
+   negative, the result has no meaning or utility.
+*/
+
+ZEXTERN uLong ZEXPORT crc32   OF((uLong crc, const Bytef *buf, uInt len));
+/*
+     Update a running CRC-32 with the bytes buf[0..len-1] and return the
+   updated CRC-32.  If buf is Z_NULL, this function returns the required
+   initial value for the crc.  Pre- and post-conditioning (one's complement) is
+   performed within this function so it shouldn't be done by the application.
+
+   Usage example:
+
+     uLong crc = crc32(0L, Z_NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       crc = crc32(crc, buffer, length);
+     }
+     if (crc != original_crc) error();
+*/
+
+ZEXTERN uLong ZEXPORT crc32_z OF((uLong adler, const Bytef *buf,
+                                  z_size_t len));
+/*
+     Same as crc32(), but with a size_t length.
+*/
+
+/*
+ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2));
+
+     Combine two CRC-32 check values into one.  For two sequences of bytes,
+   seq1 and seq2 with lengths len1 and len2, CRC-32 check values were
+   calculated for each, crc1 and crc2.  crc32_combine() returns the CRC-32
+   check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and
+   len2.
+*/
+
+
+                        /* various hacks, don't look :) */
+
+/* deflateInit and inflateInit are macros to allow checking the zlib version
+ * and the compiler's view of z_stream:
+ */
+ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
+                                     const char *version, int stream_size));
+ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm,
+                                     const char *version, int stream_size));
+ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int  level, int  method,
+                                      int windowBits, int memLevel,
+                                      int strategy, const char *version,
+                                      int stream_size));
+ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int  windowBits,
+                                      const char *version, int stream_size));
+ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits,
+                                         unsigned char FAR *window,
+                                         const char *version,
+                                         int stream_size));
+#ifdef Z_PREFIX_SET
+#  define z_deflateInit(strm, level) \
+          deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
+#  define z_inflateInit(strm) \
+          inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
+#  define z_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+          deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
+                        (strategy), ZLIB_VERSION, (int)sizeof(z_stream))
+#  define z_inflateInit2(strm, windowBits) \
+          inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
+                        (int)sizeof(z_stream))
+#  define z_inflateBackInit(strm, windowBits, window) \
+          inflateBackInit_((strm), (windowBits), (window), \
+                           ZLIB_VERSION, (int)sizeof(z_stream))
+#else
+#  define deflateInit(strm, level) \
+          deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
+#  define inflateInit(strm) \
+          inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
+#  define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+          deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
+                        (strategy), ZLIB_VERSION, (int)sizeof(z_stream))
+#  define inflateInit2(strm, windowBits) \
+          inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
+                        (int)sizeof(z_stream))
+#  define inflateBackInit(strm, windowBits, window) \
+          inflateBackInit_((strm), (windowBits), (window), \
+                           ZLIB_VERSION, (int)sizeof(z_stream))
+#endif
+
+#ifndef Z_SOLO
+
+/* gzgetc() macro and its supporting function and exposed data structure.  Note
+ * that the real internal state is much larger than the exposed structure.
+ * This abbreviated structure exposes just enough for the gzgetc() macro.  The
+ * user should not mess with these exposed elements, since their names or
+ * behavior could change in the future, perhaps even capriciously.  They can
+ * only be used by the gzgetc() macro.  You have been warned.
+ */
+struct gzFile_s {
+    unsigned have;
+    unsigned char *next;
+    z_off64_t pos;
+};
+ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file));  /* backward compatibility */
+#ifdef Z_PREFIX_SET
+#  undef z_gzgetc
+#  define z_gzgetc(g) \
+          ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g))
+#else
+#  define gzgetc(g) \
+          ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g))
+#endif
+
+/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or
+ * change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if
+ * both are true, the application gets the *64 functions, and the regular
+ * functions are changed to 64 bits) -- in case these are set on systems
+ * without large file support, _LFS64_LARGEFILE must also be true
+ */
+#ifdef Z_LARGE64
+   ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
+   ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int));
+   ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile));
+   ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile));
+   ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t));
+   ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t));
+#endif
+
+#if !defined(ZLIB_INTERNAL) && defined(Z_WANT64)
+#  ifdef Z_PREFIX_SET
+#    define z_gzopen z_gzopen64
+#    define z_gzseek z_gzseek64
+#    define z_gztell z_gztell64
+#    define z_gzoffset z_gzoffset64
+#    define z_adler32_combine z_adler32_combine64
+#    define z_crc32_combine z_crc32_combine64
+#  else
+#    define gzopen gzopen64
+#    define gzseek gzseek64
+#    define gztell gztell64
+#    define gzoffset gzoffset64
+#    define adler32_combine adler32_combine64
+#    define crc32_combine crc32_combine64
+#  endif
+#  ifndef Z_LARGE64
+     ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
+     ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int));
+     ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile));
+     ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile));
+     ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t));
+     ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t));
+#  endif
+#else
+   ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *));
+   ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int));
+   ZEXTERN z_off_t ZEXPORT gztell OF((gzFile));
+   ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile));
+   ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
+   ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
+#endif
+
+#else /* Z_SOLO */
+
+   ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
+   ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
+
+#endif /* !Z_SOLO */
+
+/* undocumented functions */
+ZEXTERN const char   * ZEXPORT zError           OF((int));
+ZEXTERN int            ZEXPORT inflateSyncPoint OF((z_streamp));
+ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table    OF((void));
+ZEXTERN int            ZEXPORT inflateUndermine OF((z_streamp, int));
+ZEXTERN int            ZEXPORT inflateValidate OF((z_streamp, int));
+ZEXTERN unsigned long  ZEXPORT inflateCodesUsed OF ((z_streamp));
+ZEXTERN int            ZEXPORT inflateResetKeep OF((z_streamp));
+ZEXTERN int            ZEXPORT deflateResetKeep OF((z_streamp));
+#if defined(_WIN32) && !defined(Z_SOLO)
+ZEXTERN gzFile         ZEXPORT gzopen_w OF((const wchar_t *path,
+                                            const char *mode));
+#endif
+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#  ifndef Z_SOLO
+ZEXTERN int            ZEXPORTVA gzvprintf Z_ARG((gzFile file,
+                                                  const char *format,
+                                                  va_list va));
+#  endif
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZLIB_H */
diff --git a/Engine/lib/assimp/contrib/zlib/zlib.pc.cmakein b/Engine/lib/assimp/contrib/zlib/zlib.pc.cmakein
new file mode 100644
index 000000000..a5e642938
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/zlib.pc.cmakein
@@ -0,0 +1,13 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=@CMAKE_INSTALL_PREFIX@
+libdir=@INSTALL_LIB_DIR@
+sharedlibdir=@INSTALL_LIB_DIR@
+includedir=@INSTALL_INC_DIR@
+
+Name: zlib
+Description: zlib compression library
+Version: @VERSION@
+
+Requires:
+Libs: -L${libdir} -L${sharedlibdir} -lz
+Cflags: -I${includedir}
diff --git a/Engine/lib/assimp/contrib/zlib/zutil.c b/Engine/lib/assimp/contrib/zlib/zutil.c
new file mode 100644
index 000000000..dcab28a0d
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/zutil.c
@@ -0,0 +1,325 @@
+/* zutil.c -- target dependent utility functions for the compression library
+ * Copyright (C) 1995-2017 Jean-loup Gailly
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#include "zutil.h"
+#ifndef Z_SOLO
+#  include "gzguts.h"
+#endif
+
+z_const char * const z_errmsg[10] = {
+    (z_const char *)"need dictionary",     /* Z_NEED_DICT       2  */
+    (z_const char *)"stream end",          /* Z_STREAM_END      1  */
+    (z_const char *)"",                    /* Z_OK              0  */
+    (z_const char *)"file error",          /* Z_ERRNO         (-1) */
+    (z_const char *)"stream error",        /* Z_STREAM_ERROR  (-2) */
+    (z_const char *)"data error",          /* Z_DATA_ERROR    (-3) */
+    (z_const char *)"insufficient memory", /* Z_MEM_ERROR     (-4) */
+    (z_const char *)"buffer error",        /* Z_BUF_ERROR     (-5) */
+    (z_const char *)"incompatible version",/* Z_VERSION_ERROR (-6) */
+    (z_const char *)""
+};
+
+
+const char * ZEXPORT zlibVersion()
+{
+    return ZLIB_VERSION;
+}
+
+uLong ZEXPORT zlibCompileFlags()
+{
+    uLong flags;
+
+    flags = 0;
+    switch ((int)(sizeof(uInt))) {
+    case 2:     break;
+    case 4:     flags += 1;     break;
+    case 8:     flags += 2;     break;
+    default:    flags += 3;
+    }
+    switch ((int)(sizeof(uLong))) {
+    case 2:     break;
+    case 4:     flags += 1 << 2;        break;
+    case 8:     flags += 2 << 2;        break;
+    default:    flags += 3 << 2;
+    }
+    switch ((int)(sizeof(voidpf))) {
+    case 2:     break;
+    case 4:     flags += 1 << 4;        break;
+    case 8:     flags += 2 << 4;        break;
+    default:    flags += 3 << 4;
+    }
+    switch ((int)(sizeof(z_off_t))) {
+    case 2:     break;
+    case 4:     flags += 1 << 6;        break;
+    case 8:     flags += 2 << 6;        break;
+    default:    flags += 3 << 6;
+    }
+#ifdef ZLIB_DEBUG
+    flags += 1 << 8;
+#endif
+#if defined(ASMV) || defined(ASMINF)
+    flags += 1 << 9;
+#endif
+#ifdef ZLIB_WINAPI
+    flags += 1 << 10;
+#endif
+#ifdef BUILDFIXED
+    flags += 1 << 12;
+#endif
+#ifdef DYNAMIC_CRC_TABLE
+    flags += 1 << 13;
+#endif
+#ifdef NO_GZCOMPRESS
+    flags += 1L << 16;
+#endif
+#ifdef NO_GZIP
+    flags += 1L << 17;
+#endif
+#ifdef PKZIP_BUG_WORKAROUND
+    flags += 1L << 20;
+#endif
+#ifdef FASTEST
+    flags += 1L << 21;
+#endif
+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#  ifdef NO_vsnprintf
+    flags += 1L << 25;
+#    ifdef HAS_vsprintf_void
+    flags += 1L << 26;
+#    endif
+#  else
+#    ifdef HAS_vsnprintf_void
+    flags += 1L << 26;
+#    endif
+#  endif
+#else
+    flags += 1L << 24;
+#  ifdef NO_snprintf
+    flags += 1L << 25;
+#    ifdef HAS_sprintf_void
+    flags += 1L << 26;
+#    endif
+#  else
+#    ifdef HAS_snprintf_void
+    flags += 1L << 26;
+#    endif
+#  endif
+#endif
+    return flags;
+}
+
+#ifdef ZLIB_DEBUG
+#include <stdlib.h>
+#  ifndef verbose
+#    define verbose 0
+#  endif
+int ZLIB_INTERNAL z_verbose = verbose;
+
+void ZLIB_INTERNAL z_error (m)
+    char *m;
+{
+    fprintf(stderr, "%s\n", m);
+    exit(1);
+}
+#endif
+
+/* exported to allow conversion of error code to string for compress() and
+ * uncompress()
+ */
+const char * ZEXPORT zError(err)
+    int err;
+{
+    return ERR_MSG(err);
+}
+
+#if defined(_WIN32_WCE) && _WIN32_WCE < 0x800
+    /* The older Microsoft C Run-Time Library for Windows CE doesn't have
+     * errno.  We define it as a global variable to simplify porting.
+     * Its value is always 0 and should not be used.
+     */
+    int errno = 0;
+#endif
+
+#ifndef HAVE_MEMCPY
+
+void ZLIB_INTERNAL zmemcpy(dest, source, len)
+    Bytef* dest;
+    const Bytef* source;
+    uInt  len;
+{
+    if (len == 0) return;
+    do {
+        *dest++ = *source++; /* ??? to be unrolled */
+    } while (--len != 0);
+}
+
+int ZLIB_INTERNAL zmemcmp(s1, s2, len)
+    const Bytef* s1;
+    const Bytef* s2;
+    uInt  len;
+{
+    uInt j;
+
+    for (j = 0; j < len; j++) {
+        if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;
+    }
+    return 0;
+}
+
+void ZLIB_INTERNAL zmemzero(dest, len)
+    Bytef* dest;
+    uInt  len;
+{
+    if (len == 0) return;
+    do {
+        *dest++ = 0;  /* ??? to be unrolled */
+    } while (--len != 0);
+}
+#endif
+
+#ifndef Z_SOLO
+
+#ifdef SYS16BIT
+
+#ifdef __TURBOC__
+/* Turbo C in 16-bit mode */
+
+#  define MY_ZCALLOC
+
+/* Turbo C malloc() does not allow dynamic allocation of 64K bytes
+ * and farmalloc(64K) returns a pointer with an offset of 8, so we
+ * must fix the pointer. Warning: the pointer must be put back to its
+ * original form in order to free it, use zcfree().
+ */
+
+#define MAX_PTR 10
+/* 10*64K = 640K */
+
+local int next_ptr = 0;
+
+typedef struct ptr_table_s {
+    voidpf org_ptr;
+    voidpf new_ptr;
+} ptr_table;
+
+local ptr_table table[MAX_PTR];
+/* This table is used to remember the original form of pointers
+ * to large buffers (64K). Such pointers are normalized with a zero offset.
+ * Since MSDOS is not a preemptive multitasking OS, this table is not
+ * protected from concurrent access. This hack doesn't work anyway on
+ * a protected system like OS/2. Use Microsoft C instead.
+ */
+
+voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size)
+{
+    voidpf buf;
+    ulg bsize = (ulg)items*size;
+
+    (void)opaque;
+
+    /* If we allocate less than 65520 bytes, we assume that farmalloc
+     * will return a usable pointer which doesn't have to be normalized.
+     */
+    if (bsize < 65520L) {
+        buf = farmalloc(bsize);
+        if (*(ush*)&buf != 0) return buf;
+    } else {
+        buf = farmalloc(bsize + 16L);
+    }
+    if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
+    table[next_ptr].org_ptr = buf;
+
+    /* Normalize the pointer to seg:0 */
+    *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
+    *(ush*)&buf = 0;
+    table[next_ptr++].new_ptr = buf;
+    return buf;
+}
+
+void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
+{
+    int n;
+
+    (void)opaque;
+
+    if (*(ush*)&ptr != 0) { /* object < 64K */
+        farfree(ptr);
+        return;
+    }
+    /* Find the original pointer */
+    for (n = 0; n < next_ptr; n++) {
+        if (ptr != table[n].new_ptr) continue;
+
+        farfree(table[n].org_ptr);
+        while (++n < next_ptr) {
+            table[n-1] = table[n];
+        }
+        next_ptr--;
+        return;
+    }
+    Assert(0, "zcfree: ptr not found");
+}
+
+#endif /* __TURBOC__ */
+
+
+#ifdef M_I86
+/* Microsoft C in 16-bit mode */
+
+#  define MY_ZCALLOC
+
+#if (!defined(_MSC_VER) || (_MSC_VER <= 600))
+#  define _halloc  halloc
+#  define _hfree   hfree
+#endif
+
+voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size)
+{
+    (void)opaque;
+    return _halloc((long)items, size);
+}
+
+void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
+{
+    (void)opaque;
+    _hfree(ptr);
+}
+
+#endif /* M_I86 */
+
+#endif /* SYS16BIT */
+
+
+#ifndef MY_ZCALLOC /* Any system without a special alloc function */
+
+#ifndef STDC
+extern voidp  malloc OF((uInt size));
+extern voidp  calloc OF((uInt items, uInt size));
+extern void   free   OF((voidpf ptr));
+#endif
+
+voidpf ZLIB_INTERNAL zcalloc (opaque, items, size)
+    voidpf opaque;
+    unsigned items;
+    unsigned size;
+{
+    (void)opaque;
+    return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
+                              (voidpf)calloc(items, size);
+}
+
+void ZLIB_INTERNAL zcfree (opaque, ptr)
+    voidpf opaque;
+    voidpf ptr;
+{
+    (void)opaque;
+    free(ptr);
+}
+
+#endif /* MY_ZCALLOC */
+
+#endif /* !Z_SOLO */
diff --git a/Engine/lib/assimp/contrib/zlib/zutil.h b/Engine/lib/assimp/contrib/zlib/zutil.h
new file mode 100644
index 000000000..60a0bca79
--- /dev/null
+++ b/Engine/lib/assimp/contrib/zlib/zutil.h
@@ -0,0 +1,263 @@
+/* zutil.h -- internal interface and configuration of the compression library
+ * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* @(#) $Id$ */
+
+#ifndef ZUTIL_H
+#define ZUTIL_H
+
+#ifdef HAVE_HIDDEN
+#  define ZLIB_INTERNAL __attribute__((visibility ("hidden")))
+#else
+#  define ZLIB_INTERNAL
+#endif
+
+#include "zlib.h"
+
+#if defined(STDC) && !defined(Z_SOLO)
+#  if !(defined(_WIN32_WCE) && defined(_MSC_VER))
+#    include <stddef.h>
+#  endif
+#  include <string.h>
+#  include <stdlib.h>
+#endif
+
+#ifndef local
+#  define local static
+#endif
+/* since "static" is used to mean two completely different things in C, we
+   define "local" for the non-static meaning of "static", for readability
+   (compile with -Dlocal if your debugger can't find static symbols) */
+
+typedef unsigned char  uch;
+typedef uch FAR uchf;
+typedef unsigned short ush;
+typedef ush FAR ushf;
+typedef unsigned long  ulg;
+
+extern z_const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
+/* (size given to avoid silly warnings with Visual C++) */
+
+#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)]
+
+#define ERR_RETURN(strm,err) \
+  return (strm->msg = ERR_MSG(err), (err))
+/* To be used only when the state is known to be valid */
+
+        /* common constants */
+
+#ifndef DEF_WBITS
+#  define DEF_WBITS MAX_WBITS
+#endif
+/* default windowBits for decompression. MAX_WBITS is for compression only */
+
+#if MAX_MEM_LEVEL >= 8
+#  define DEF_MEM_LEVEL 8
+#else
+#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
+#endif
+/* default memLevel */
+
+#define STORED_BLOCK 0
+#define STATIC_TREES 1
+#define DYN_TREES    2
+/* The three kinds of block type */
+
+#define MIN_MATCH  3
+#define MAX_MATCH  258
+/* The minimum and maximum match lengths */
+
+#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */
+
+        /* target dependencies */
+
+#if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32))
+#  define OS_CODE  0x00
+#  ifndef Z_SOLO
+#    if defined(__TURBOC__) || defined(__BORLANDC__)
+#      if (__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__))
+         /* Allow compilation with ANSI keywords only enabled */
+         void _Cdecl farfree( void *block );
+         void *_Cdecl farmalloc( unsigned long nbytes );
+#      else
+#        include <alloc.h>
+#      endif
+#    else /* MSC or DJGPP */
+#      include <malloc.h>
+#    endif
+#  endif
+#endif
+
+#ifdef AMIGA
+#  define OS_CODE  1
+#endif
+
+#if defined(VAXC) || defined(VMS)
+#  define OS_CODE  2
+#  define F_OPEN(name, mode) \
+     fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
+#endif
+
+#ifdef __370__
+#  if __TARGET_LIB__ < 0x20000000
+#    define OS_CODE 4
+#  elif __TARGET_LIB__ < 0x40000000
+#    define OS_CODE 11
+#  else
+#    define OS_CODE 8
+#  endif
+#endif
+
+#if defined(ATARI) || defined(atarist)
+#  define OS_CODE  5
+#endif
+
+#ifdef OS2
+#  define OS_CODE  6
+#  if defined(M_I86) && !defined(Z_SOLO)
+#    include <malloc.h>
+#  endif
+#endif
+
+#if defined(MACOS) || defined(TARGET_OS_MAC)
+#  define OS_CODE  7
+#  ifndef Z_SOLO
+#    if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
+#      include <unix.h> /* for fdopen */
+#    else
+#      ifndef fdopen
+#        define fdopen(fd,mode) NULL /* No fdopen() */
+#      endif
+#    endif
+#  endif
+#endif
+
+#ifdef __acorn
+#  define OS_CODE 13
+#endif
+
+#if defined(WIN32) && !defined(__CYGWIN__)
+#  define OS_CODE  10
+#endif
+
+#ifdef _BEOS_
+#  define OS_CODE  16
+#endif
+
+#ifdef __TOS_OS400__
+#  define OS_CODE 18
+#endif
+
+#ifdef __APPLE__
+#  define OS_CODE 19
+#endif
+
+#if defined(_BEOS_) || defined(RISCOS)
+#  define fdopen(fd,mode) NULL /* No fdopen() */
+#endif
+
+#if (defined(_MSC_VER) && (_MSC_VER > 600)) && !defined __INTERIX
+#  if defined(_WIN32_WCE)
+#    define fdopen(fd,mode) NULL /* No fdopen() */
+#  else
+#    define fdopen(fd,type)  _fdopen(fd,type)
+#  endif
+#endif
+
+#if defined(__BORLANDC__) && !defined(MSDOS)
+  #pragma warn -8004
+  #pragma warn -8008
+  #pragma warn -8066
+#endif
+
+/* provide prototypes for these when building zlib without LFS */
+#if !defined(_WIN32) && \
+    (!defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0)
+    ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t));
+    ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t));
+#endif
+
+        /* common defaults */
+
+#ifndef OS_CODE
+#  define OS_CODE  3     /* assume Unix */
+#endif
+
+#ifndef F_OPEN
+#  define F_OPEN(name, mode) fopen((name), (mode))
+#endif
+
+         /* functions */
+
+#if defined(pyr) || defined(Z_SOLO)
+#  define NO_MEMCPY
+#endif
+#if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__)
+ /* Use our own functions for small and medium model with MSC <= 5.0.
+  * You may have to use the same strategy for Borland C (untested).
+  * The __SC__ check is for Symantec.
+  */
+#  define NO_MEMCPY
+#endif
+#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY)
+#  define HAVE_MEMCPY
+#endif
+#ifdef HAVE_MEMCPY
+#  ifdef SMALL_MEDIUM /* MSDOS small or medium model */
+#    define zmemcpy _fmemcpy
+#    define zmemcmp _fmemcmp
+#    define zmemzero(dest, len) _fmemset(dest, 0, len)
+#  else
+#    define zmemcpy memcpy
+#    define zmemcmp memcmp
+#    define zmemzero(dest, len) memset(dest, 0, len)
+#  endif
+#else
+   void ZLIB_INTERNAL zmemcpy OF((Bytef* dest, const Bytef* source, uInt len));
+   int ZLIB_INTERNAL zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len));
+   void ZLIB_INTERNAL zmemzero OF((Bytef* dest, uInt len));
+#endif
+
+/* Diagnostic functions */
+#ifdef ZLIB_DEBUG
+#  include <stdio.h>
+   extern int ZLIB_INTERNAL z_verbose;
+   extern void ZLIB_INTERNAL z_error OF((char *m));
+#  define Assert(cond,msg) {if(!(cond)) z_error(msg);}
+#  define Trace(x) {if (z_verbose>=0) fprintf x ;}
+#  define Tracev(x) {if (z_verbose>0) fprintf x ;}
+#  define Tracevv(x) {if (z_verbose>1) fprintf x ;}
+#  define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;}
+#  define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;}
+#else
+#  define Assert(cond,msg)
+#  define Trace(x)
+#  define Tracev(x)
+#  define Tracevv(x)
+#  define Tracec(c,x)
+#  define Tracecv(c,x)
+#endif
+
+#ifndef Z_SOLO
+   voidpf ZLIB_INTERNAL zcalloc OF((voidpf opaque, unsigned items,
+                                    unsigned size));
+   void ZLIB_INTERNAL zcfree  OF((voidpf opaque, voidpf ptr));
+#endif
+
+#define ZALLOC(strm, items, size) \
+           (*((strm)->zalloc))((strm)->opaque, (items), (size))
+#define ZFREE(strm, addr)  (*((strm)->zfree))((strm)->opaque, (voidpf)(addr))
+#define TRY_FREE(s, p) {if (p) ZFREE(s, p);}
+
+/* Reverse the bytes in a 32-bit value */
+#define ZSWAP32(q) ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
+                    (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
+
+#endif /* ZUTIL_H */
diff --git a/Engine/lib/assimp/include/assimp/BaseImporter.h b/Engine/lib/assimp/include/assimp/BaseImporter.h
index 7cf835174..55f7fe375 100644
--- a/Engine/lib/assimp/include/assimp/BaseImporter.h
+++ b/Engine/lib/assimp/include/assimp/BaseImporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -41,14 +41,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 /** @file Definition of the base class for all importer worker classes. */
-#pragma once
 #ifndef INCLUDED_AI_BASEIMPORTER_H
 #define INCLUDED_AI_BASEIMPORTER_H
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include "Exceptional.h"
 
 #include <vector>
@@ -196,13 +191,16 @@ public:
     /**
      * Assimp Importer
      * unit conversions available 
-     * NOTE: Valid options are initialised in the
-     * constructor in the implementation file to
-     * work around a VS2013 compiler bug if support
-     * for that compiler is dropped in the future
-     * initialisation can be moved back here
+     * if you need another measurment unit add it below.
+     * it's currently defined in assimp that we prefer meters.
      * */
-    std::map<ImporterUnits, double> importerUnits;
+    std::map<ImporterUnits, double> importerUnits = {
+        {ImporterUnits::M, 1},
+        {ImporterUnits::CM, 0.01},
+        {ImporterUnits::MM, 0.001},
+        {ImporterUnits::INCHES, 0.0254},
+        {ImporterUnits::FEET, 0.3048}
+    };
 
     virtual void SetApplicationUnits( const ImporterUnits& unit )
     {
diff --git a/Engine/lib/assimp/include/assimp/Bitmap.h b/Engine/lib/assimp/include/assimp/Bitmap.h
index d0d94a6eb..e6b5fb132 100644
--- a/Engine/lib/assimp/include/assimp/Bitmap.h
+++ b/Engine/lib/assimp/include/assimp/Bitmap.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -46,14 +46,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * Used for file formats which embed their textures into the model file.
  */
-#pragma once
+
 #ifndef AI_BITMAP_H_INC
 #define AI_BITMAP_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include "defs.h"
 #include <stdint.h>
 #include <cstddef>
diff --git a/Engine/lib/assimp/include/assimp/BlobIOSystem.h b/Engine/lib/assimp/include/assimp/BlobIOSystem.h
index 30d9b1ac3..d005e5c11 100644
--- a/Engine/lib/assimp/include/assimp/BlobIOSystem.h
+++ b/Engine/lib/assimp/include/assimp/BlobIOSystem.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/Engine/lib/assimp/include/assimp/ByteSwapper.h b/Engine/lib/assimp/include/assimp/ByteSwapper.h
index 7af78b61c..20a2463fb 100644
--- a/Engine/lib/assimp/include/assimp/ByteSwapper.h
+++ b/Engine/lib/assimp/include/assimp/ByteSwapper.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -42,14 +42,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** @file Helper class tp perform various byte oder swappings
    (e.g. little to big endian) */
-#pragma once
 #ifndef AI_BYTESWAPPER_H_INC
 #define AI_BYTESWAPPER_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <assimp/ai_assert.h>
 #include <assimp/types.h>
 #include <stdint.h>
diff --git a/Engine/lib/assimp/include/assimp/CreateAnimMesh.h b/Engine/lib/assimp/include/assimp/CreateAnimMesh.h
index 01a118ba3..a60173588 100644
--- a/Engine/lib/assimp/include/assimp/CreateAnimMesh.h
+++ b/Engine/lib/assimp/include/assimp/CreateAnimMesh.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -43,26 +43,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file CreateAnimMesh.h
  *  Create AnimMesh from Mesh
  */
-#pragma once
 #ifndef INCLUDED_AI_CREATE_ANIM_MESH_H
 #define INCLUDED_AI_CREATE_ANIM_MESH_H
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <assimp/mesh.h>
 
-namespace Assimp {
+namespace Assimp    {
 
-/**
- *  Create aiAnimMesh from aiMesh.
- *  @param  mesh    The input mesh to create an animated mesh from.
- *  @return The new created animated mesh.
- */
+/** Create aiAnimMesh from aiMesh. */
 ASSIMP_API aiAnimMesh *aiCreateAnimMesh(const aiMesh *mesh);
 
 } // end of namespace Assimp
-
 #endif // INCLUDED_AI_CREATE_ANIM_MESH_H
 
diff --git a/Engine/lib/assimp/include/assimp/DefaultIOStream.h b/Engine/lib/assimp/include/assimp/DefaultIOStream.h
index 05780def7..994d728ff 100644
--- a/Engine/lib/assimp/include/assimp/DefaultIOStream.h
+++ b/Engine/lib/assimp/include/assimp/DefaultIOStream.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -41,20 +41,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 /** @file Default file I/O using fXXX()-family of functions */
-#pragma once
 #ifndef AI_DEFAULTIOSTREAM_H_INC
 #define AI_DEFAULTIOSTREAM_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <stdio.h>
 #include <assimp/IOStream.hpp>
 #include <assimp/importerdesc.h>
 #include <assimp/Defines.h>
 
-namespace Assimp {
+namespace Assimp    {
 
 // ----------------------------------------------------------------------------------
 //! @class  DefaultIOStream
@@ -62,7 +57,8 @@ namespace Assimp {
 //! @note   An instance of this class can exist without a valid file handle
 //!         attached to it. All calls fail, but the instance can nevertheless be
 //!         used with no restrictions.
-class ASSIMP_API DefaultIOStream : public IOStream {
+class ASSIMP_API DefaultIOStream : public IOStream
+{
     friend class DefaultIOSystem;
 #if __ANDROID__
 # if __ANDROID_API__ > 9
@@ -86,6 +82,7 @@ public:
         size_t pSize,
         size_t pCount);
 
+
     // -------------------------------------------------------------------
     /// Write to stream
     size_t Write(const void* pvBuffer,
@@ -110,13 +107,16 @@ public:
     void Flush();
 
 private:
+    //  File data-structure, using clib
     FILE* mFile;
+    //  Filename
     std::string mFilename;
+    // Cached file size
     mutable size_t mCachedSize;
 };
 
 // ----------------------------------------------------------------------------------
-AI_FORCE_INLINE
+inline
 DefaultIOStream::DefaultIOStream() AI_NO_EXCEPT
 : mFile(nullptr)
 , mFilename("")
@@ -125,7 +125,7 @@ DefaultIOStream::DefaultIOStream() AI_NO_EXCEPT
 }
 
 // ----------------------------------------------------------------------------------
-AI_FORCE_INLINE
+inline
 DefaultIOStream::DefaultIOStream (FILE* pFile, const std::string &strFilename)
 : mFile(pFile)
 , mFilename(strFilename)
@@ -137,3 +137,4 @@ DefaultIOStream::DefaultIOStream (FILE* pFile, const std::string &strFilename)
 } // ns assimp
 
 #endif //!!AI_DEFAULTIOSTREAM_H_INC
+
diff --git a/Engine/lib/assimp/include/assimp/DefaultIOSystem.h b/Engine/lib/assimp/include/assimp/DefaultIOSystem.h
index 75dd97e7f..2dd5c801b 100644
--- a/Engine/lib/assimp/include/assimp/DefaultIOSystem.h
+++ b/Engine/lib/assimp/include/assimp/DefaultIOSystem.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -41,14 +41,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 /** @file Default implementation of IOSystem using the standard C file functions */
-#pragma once
 #ifndef AI_DEFAULTIOSYSTEM_H_INC
 #define AI_DEFAULTIOSYSTEM_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <assimp/IOSystem.hpp>
 
 namespace Assimp    {
diff --git a/Engine/lib/assimp/include/assimp/DefaultLogger.hpp b/Engine/lib/assimp/include/assimp/DefaultLogger.hpp
index 789072a7c..1946e250a 100644
--- a/Engine/lib/assimp/include/assimp/DefaultLogger.hpp
+++ b/Engine/lib/assimp/include/assimp/DefaultLogger.hpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/include/assimp/Defines.h b/Engine/lib/assimp/include/assimp/Defines.h
index 959e4b1fb..15e1d83c2 100644
--- a/Engine/lib/assimp/include/assimp/Defines.h
+++ b/Engine/lib/assimp/include/assimp/Defines.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2012, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -38,14 +38,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
-#pragma once
-#ifndef AI_DEFINES_H_INC
-#define AI_DEFINES_H_INC
-
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 // We need those constants, workaround for any platforms where nobody defined them yet
 #if (!defined SIZE_MAX)
 #   define SIZE_MAX (~((size_t)0))
@@ -55,4 +47,3 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #   define UINT_MAX (~((unsigned int)0))
 #endif
 
-#endif // AI_DEINES_H_INC
diff --git a/Engine/lib/assimp/include/assimp/Exceptional.h b/Engine/lib/assimp/include/assimp/Exceptional.h
index dcd5e2b2e..5109b8f07 100644
--- a/Engine/lib/assimp/include/assimp/Exceptional.h
+++ b/Engine/lib/assimp/include/assimp/Exceptional.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2008, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -38,17 +38,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
-#pragma once
-#ifndef AI_INCLUDED_EXCEPTIONAL_H
-#define AI_INCLUDED_EXCEPTIONAL_H
-
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
+#ifndef INCLUDED_EXCEPTIONAL_H
+#define INCLUDED_EXCEPTIONAL_H
 
 #include <stdexcept>
 #include <assimp/DefaultIOStream.h>
-
 using std::runtime_error;
 
 #ifdef _MSC_VER
@@ -59,14 +53,17 @@ using std::runtime_error;
 /** FOR IMPORTER PLUGINS ONLY: Simple exception class to be thrown if an
  *  unrecoverable error occurs while importing. Loading APIs return
  *  NULL instead of a valid aiScene then.  */
-class DeadlyImportError : public runtime_error {
+class DeadlyImportError
+    : public runtime_error
+{
 public:
     /** Constructor with arguments */
     explicit DeadlyImportError( const std::string& errorText)
-    : runtime_error(errorText) {
-        // empty
+        : runtime_error(errorText)
+    {
     }
 
+private:
 };
 
 typedef DeadlyImportError DeadlyExportError;
@@ -87,7 +84,7 @@ struct ExceptionSwallower   {
 template <typename T>
 struct ExceptionSwallower<T*>   {
     T* operator ()() const {
-        return nullptr;
+        return NULL;
     }
 };
 
@@ -119,20 +116,10 @@ struct ExceptionSwallower<void> {
 {\
     try {
 
-#define ASSIMP_END_EXCEPTION_REGION_WITH_ERROR_STRING(type, ASSIMP_END_EXCEPTION_REGION_errorString)\
-    } catch(const DeadlyImportError& e) {\
-        ASSIMP_END_EXCEPTION_REGION_errorString = e.what();\
-        return ExceptionSwallower<type>()();\
-    } catch(...) {\
-        ASSIMP_END_EXCEPTION_REGION_errorString = "Unknown exception";\
-        return ExceptionSwallower<type>()();\
-    }\
-}
-
 #define ASSIMP_END_EXCEPTION_REGION(type)\
     } catch(...) {\
         return ExceptionSwallower<type>()();\
     }\
 }
 
-#endif // AI_INCLUDED_EXCEPTIONAL_H
+#endif // INCLUDED_EXCEPTIONAL_H
diff --git a/Engine/lib/assimp/include/assimp/Exporter.hpp b/Engine/lib/assimp/include/assimp/Exporter.hpp
index dc6661c11..ea0303e80 100644
--- a/Engine/lib/assimp/include/assimp/Exporter.hpp
+++ b/Engine/lib/assimp/include/assimp/Exporter.hpp
@@ -3,7 +3,9 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
+
+
 
 All rights reserved.
 
@@ -46,10 +48,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_EXPORT_HPP_INC
 #define AI_EXPORT_HPP_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #ifndef ASSIMP_BUILD_NO_EXPORT
 
 #include "cexport.h"
diff --git a/Engine/lib/assimp/include/assimp/GenericProperty.h b/Engine/lib/assimp/include/assimp/GenericProperty.h
index c1891c7b6..183ecd519 100644
--- a/Engine/lib/assimp/include/assimp/GenericProperty.h
+++ b/Engine/lib/assimp/include/assimp/GenericProperty.h
@@ -2,7 +2,8 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
+
 
 All rights reserved.
 
@@ -39,30 +40,26 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
-#pragma once
 #ifndef AI_GENERIC_PROPERTY_H_INCLUDED
 #define AI_GENERIC_PROPERTY_H_INCLUDED
 
-#ifdef __GNUC__
-#    pragma GCC system_header
-#endif
-
-#include <assimp/Hash.h>
-#include <assimp/ai_assert.h>
 #include <assimp/Importer.hpp>
+#include <assimp/ai_assert.h>
+#include "Hash.h"
 
 #include <map>
 
 // ------------------------------------------------------------------------------------------------
 template <class T>
-inline bool SetGenericProperty(std::map<unsigned int, T> &list,
-        const char *szName, const T &value) {
+inline
+bool SetGenericProperty(std::map< unsigned int, T >& list,
+        const char* szName, const T& value) {
     ai_assert(nullptr != szName);
     const uint32_t hash = SuperFastHash(szName);
 
     typename std::map<unsigned int, T>::iterator it = list.find(hash);
-    if (it == list.end()) {
-        list.insert(std::pair<unsigned int, T>(hash, value));
+    if (it == list.end())   {
+        list.insert(std::pair<unsigned int, T>( hash, value ));
         return false;
     }
     (*it).second = value;
@@ -72,8 +69,9 @@ inline bool SetGenericProperty(std::map<unsigned int, T> &list,
 
 // ------------------------------------------------------------------------------------------------
 template <class T>
-inline const T &GetGenericProperty(const std::map<unsigned int, T> &list,
-        const char *szName, const T &errorReturn) {
+inline
+const T& GetGenericProperty(const std::map< unsigned int, T >& list,
+        const char* szName, const T& errorReturn) {
     ai_assert(nullptr != szName);
     const uint32_t hash = SuperFastHash(szName);
 
@@ -89,21 +87,22 @@ inline const T &GetGenericProperty(const std::map<unsigned int, T> &list,
 // Special version for pointer types - they will be deleted when replaced with another value
 // passing NULL removes the whole property
 template <class T>
-inline void SetGenericPropertyPtr(std::map<unsigned int, T *> &list,
-        const char *szName, T *value, bool *bWasExisting = nullptr) {
+inline
+void SetGenericPropertyPtr(std::map< unsigned int, T* >& list,
+        const char* szName, T* value, bool* bWasExisting = nullptr ) {
     ai_assert(nullptr != szName);
     const uint32_t hash = SuperFastHash(szName);
 
-    typename std::map<unsigned int, T *>::iterator it = list.find(hash);
-    if (it == list.end()) {
+    typename std::map<unsigned int, T*>::iterator it = list.find(hash);
+    if (it == list.end())   {
         if (bWasExisting) {
             *bWasExisting = false;
         }
 
-        list.insert(std::pair<unsigned int, T *>(hash, value));
+        list.insert(std::pair<unsigned int,T*>( hash, value ));
         return;
     }
-    if ((*it).second != value) {
+    if ((*it).second != value)  {
         delete (*it).second;
         (*it).second = value;
     }
@@ -117,8 +116,9 @@ inline void SetGenericPropertyPtr(std::map<unsigned int, T *> &list,
 
 // ------------------------------------------------------------------------------------------------
 template <class T>
-inline bool HasGenericProperty(const std::map<unsigned int, T> &list,
-        const char *szName) {
+inline
+bool HasGenericProperty(const std::map< unsigned int, T >& list,
+        const char* szName) {
     ai_assert(nullptr != szName);
     const uint32_t hash = SuperFastHash(szName);
 
diff --git a/Engine/lib/assimp/include/assimp/Hash.h b/Engine/lib/assimp/include/assimp/Hash.h
index 7c360b474..30657be19 100644
--- a/Engine/lib/assimp/include/assimp/Hash.h
+++ b/Engine/lib/assimp/include/assimp/Hash.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -39,14 +39,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 ----------------------------------------------------------------------
 */
-#pragma once
+
 #ifndef AI_HASH_H_INCLUDED
 #define AI_HASH_H_INCLUDED
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <stdint.h>
 #include <string.h>
 
diff --git a/Engine/lib/assimp/include/assimp/IOStream.hpp b/Engine/lib/assimp/include/assimp/IOStream.hpp
index c3271d007..0623d0f70 100644
--- a/Engine/lib/assimp/include/assimp/IOStream.hpp
+++ b/Engine/lib/assimp/include/assimp/IOStream.hpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -48,18 +48,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_IOSTREAM_H_INC
 #define AI_IOSTREAM_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
-#include <assimp/types.h>
+#include "types.h"
 
 #ifndef __cplusplus
 #   error This header requires C++ to be used. aiFileIO.h is the \
     corresponding C interface.
 #endif
 
-namespace Assimp {
+namespace Assimp    {
 
 // ----------------------------------------------------------------------------------
 /** @brief CPP-API: Class to handle file I/O for C++
@@ -129,13 +125,13 @@ public:
 }; //! class IOStream
 
 // ----------------------------------------------------------------------------------
-AI_FORCE_INLINE
+inline
 IOStream::IOStream() AI_NO_EXCEPT {
     // empty
 }
 
 // ----------------------------------------------------------------------------------
-AI_FORCE_INLINE
+inline
 IOStream::~IOStream() {
     // empty
 }
diff --git a/Engine/lib/assimp/include/assimp/IOStreamBuffer.h b/Engine/lib/assimp/include/assimp/IOStreamBuffer.h
index 6ca9be84a..58abd97a0 100644
--- a/Engine/lib/assimp/include/assimp/IOStreamBuffer.h
+++ b/Engine/lib/assimp/include/assimp/IOStreamBuffer.h
@@ -1,8 +1,10 @@
+#pragma once
+
 /*
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -40,17 +42,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
-#pragma once
-#ifndef AI_IOSTREAMBUFFER_H_INC
-#define AI_IOSTREAMBUFFER_H_INC
-
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <assimp/types.h>
 #include <assimp/IOStream.hpp>
-#include <assimp/ParsingUtils.h>
+
+#include "ParsingUtils.h"
 
 #include <vector>
 
@@ -129,7 +124,7 @@ private:
 };
 
 template<class T>
-AI_FORCE_INLINE
+inline
 IOStreamBuffer<T>::IOStreamBuffer( size_t cache )
 : m_stream( nullptr )
 , m_filesize( 0 )
@@ -143,13 +138,13 @@ IOStreamBuffer<T>::IOStreamBuffer( size_t cache )
 }
 
 template<class T>
-AI_FORCE_INLINE
+inline
 IOStreamBuffer<T>::~IOStreamBuffer() {
     // empty
 }
 
 template<class T>
-AI_FORCE_INLINE
+inline
 bool IOStreamBuffer<T>::open( IOStream *stream ) {
     //  file still opened!
     if ( nullptr != m_stream ) {
@@ -179,7 +174,7 @@ bool IOStreamBuffer<T>::open( IOStream *stream ) {
 }
 
 template<class T>
-AI_FORCE_INLINE
+inline
 bool IOStreamBuffer<T>::close() {
     if ( nullptr == m_stream ) {
         return false;
@@ -197,19 +192,19 @@ bool IOStreamBuffer<T>::close() {
 }
 
 template<class T>
-AI_FORCE_INLINE
+inline
 size_t IOStreamBuffer<T>::size() const {
     return m_filesize;
 }
 
 template<class T>
-AI_FORCE_INLINE
+inline
 size_t IOStreamBuffer<T>::cacheSize() const {
     return m_cacheSize;
 }
 
 template<class T>
-AI_FORCE_INLINE
+inline
 bool IOStreamBuffer<T>::readNextBlock() {
     m_stream->Seek( m_filePos, aiOrigin_SET );
     size_t readLen = m_stream->Read( &m_cache[ 0 ], sizeof( T ), m_cacheSize );
@@ -227,25 +222,25 @@ bool IOStreamBuffer<T>::readNextBlock() {
 }
 
 template<class T>
-AI_FORCE_INLINE
+inline
 size_t IOStreamBuffer<T>::getNumBlocks() const {
     return m_numBlocks;
 }
 
 template<class T>
-AI_FORCE_INLINE
+inline
 size_t IOStreamBuffer<T>::getCurrentBlockIndex() const {
     return m_blockIdx;
 }
 
 template<class T>
-AI_FORCE_INLINE
+inline
 size_t IOStreamBuffer<T>::getFilePos() const {
     return m_filePos;
 }
 
 template<class T>
-AI_FORCE_INLINE
+inline
 bool IOStreamBuffer<T>::getNextDataLine( std::vector<T> &buffer, T continuationToken ) {
     buffer.resize( m_cacheSize );
     if ( m_cachePos >= m_cacheSize || 0 == m_filePos ) {
@@ -294,13 +289,13 @@ bool IOStreamBuffer<T>::getNextDataLine( std::vector<T> &buffer, T continuationT
     return true;
 }
 
-static AI_FORCE_INLINE
+static inline
 bool isEndOfCache( size_t pos, size_t cacheSize ) {
     return ( pos == cacheSize );
 }
 
 template<class T>
-AI_FORCE_INLINE
+inline
 bool IOStreamBuffer<T>::getNextLine(std::vector<T> &buffer) {
     buffer.resize(m_cacheSize);
     if ( isEndOfCache( m_cachePos, m_cacheSize ) || 0 == m_filePos) {
@@ -340,7 +335,7 @@ bool IOStreamBuffer<T>::getNextLine(std::vector<T> &buffer) {
 }
 
 template<class T>
-AI_FORCE_INLINE
+inline
 bool IOStreamBuffer<T>::getNextBlock( std::vector<T> &buffer) {
     // Return the last block-value if getNextLine was used before
     if ( 0 != m_cachePos ) {      
@@ -358,5 +353,3 @@ bool IOStreamBuffer<T>::getNextBlock( std::vector<T> &buffer) {
 }
 
 } // !ns Assimp
-
-#endif // AI_IOSTREAMBUFFER_H_INC
diff --git a/Engine/lib/assimp/include/assimp/IOSystem.hpp b/Engine/lib/assimp/include/assimp/IOSystem.hpp
index 291cd938f..78139c283 100644
--- a/Engine/lib/assimp/include/assimp/IOSystem.hpp
+++ b/Engine/lib/assimp/include/assimp/IOSystem.hpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -50,10 +50,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_IOSYSTEM_H_INC
 #define AI_IOSYSTEM_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #ifndef __cplusplus
 #   error This header requires C++ to be used. aiFileIO.h is the \
     corresponding C interface.
diff --git a/Engine/lib/assimp/include/assimp/Importer.hpp b/Engine/lib/assimp/include/assimp/Importer.hpp
index df52471a9..4941df412 100644
--- a/Engine/lib/assimp/include/assimp/Importer.hpp
+++ b/Engine/lib/assimp/include/assimp/Importer.hpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -48,10 +48,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_ASSIMP_HPP_INC
 #define AI_ASSIMP_HPP_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #ifndef __cplusplus
 #   error This header requires C++ to be used. Use assimp.h for plain C.
 #endif // __cplusplus
@@ -285,7 +281,7 @@ public:
      *  The return value remains valid until the property is modified.
      * @see GetPropertyInteger()
      */
-    std::string GetPropertyString(const char* szName,
+    const std::string GetPropertyString(const char* szName,
         const std::string& sErrorReturn = "") const;
 
     // -------------------------------------------------------------------
@@ -294,7 +290,7 @@ public:
      *  The return value remains valid until the property is modified.
      * @see GetPropertyInteger()
      */
-    aiMatrix4x4 GetPropertyMatrix(const char* szName,
+    const aiMatrix4x4 GetPropertyMatrix(const char* szName,
         const aiMatrix4x4& sErrorReturn = aiMatrix4x4()) const;
 
     // -------------------------------------------------------------------
diff --git a/Engine/lib/assimp/include/assimp/LineSplitter.h b/Engine/lib/assimp/include/assimp/LineSplitter.h
index 869585d92..4afe45b92 100644
--- a/Engine/lib/assimp/include/assimp/LineSplitter.h
+++ b/Engine/lib/assimp/include/assimp/LineSplitter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -48,13 +48,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef INCLUDED_LINE_SPLITTER_H
 #define INCLUDED_LINE_SPLITTER_H
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <stdexcept>
-#include <assimp/StreamReader.h>
-#include <assimp/ParsingUtils.h>
+#include "StreamReader.h"
+#include "ParsingUtils.h"
 
 namespace Assimp {
 
@@ -72,7 +68,7 @@ for(LineSplitter splitter(stream);splitter;++splitter) {
        if (strtol(splitter[2]) > 5) { .. }
     }
 
-    ASSIMP_LOG_DEBUG_F("Current line is: ", splitter.get_index());
+    std::cout << "Current line is: " << splitter.get_index() << std::endl;
 }
 @endcode
 */
@@ -144,7 +140,7 @@ private:
     bool mSwallow, mSkip_empty_lines, mTrim;
 };
 
-AI_FORCE_INLINE
+inline
 LineSplitter::LineSplitter(StreamReaderLE& stream, bool skip_empty_lines, bool trim )
 : mIdx(0)
 , mCur()
@@ -157,12 +153,12 @@ LineSplitter::LineSplitter(StreamReaderLE& stream, bool skip_empty_lines, bool t
     mIdx = 0;
 }
 
-AI_FORCE_INLINE
+inline
 LineSplitter::~LineSplitter() {
     // empty
 }
 
-AI_FORCE_INLINE
+inline
 LineSplitter& LineSplitter::operator++() {
     if (mSwallow) {
         mSwallow = false;
@@ -203,12 +199,12 @@ LineSplitter& LineSplitter::operator++() {
     return *this;
 }
 
-AI_FORCE_INLINE
+inline
 LineSplitter &LineSplitter::operator++(int) {
     return ++(*this);
 }
 
-AI_FORCE_INLINE
+inline
 const char *LineSplitter::operator[] (size_t idx) const {
     const char* s = operator->()->c_str();
 
@@ -226,7 +222,7 @@ const char *LineSplitter::operator[] (size_t idx) const {
 }
 
 template <size_t N>
-AI_FORCE_INLINE
+inline
 void LineSplitter::get_tokens(const char* (&tokens)[N]) const {
     const char* s = operator->()->c_str();
 
@@ -242,44 +238,44 @@ void LineSplitter::get_tokens(const char* (&tokens)[N]) const {
     }
 }
 
-AI_FORCE_INLINE
+inline
 const std::string* LineSplitter::operator -> () const {
     return &mCur;
 }
 
-AI_FORCE_INLINE
+inline
 std::string LineSplitter::operator* () const {
     return mCur;
 }
 
-AI_FORCE_INLINE
+inline
 LineSplitter::operator bool() const {
     return mStream.GetRemainingSize() > 0;
 }
 
-AI_FORCE_INLINE
+inline
 LineSplitter::operator line_idx() const {
     return mIdx;
 }
 
-AI_FORCE_INLINE
+inline
 LineSplitter::line_idx LineSplitter::get_index() const {
     return mIdx;
 }
 
-AI_FORCE_INLINE
+inline
 StreamReaderLE &LineSplitter::get_stream() {
     return mStream;
 }
 
-AI_FORCE_INLINE
+inline
 bool LineSplitter::match_start(const char* check) {
     const size_t len = ::strlen(check);
 
     return len <= mCur.length() && std::equal(check, check + len, mCur.begin());
 }
 
-AI_FORCE_INLINE
+inline
 void LineSplitter::swallow_next_increment() {
     mSwallow = true;
 }
diff --git a/Engine/lib/assimp/include/assimp/LogAux.h b/Engine/lib/assimp/include/assimp/LogAux.h
index 2265ff19c..558485272 100644
--- a/Engine/lib/assimp/include/assimp/LogAux.h
+++ b/Engine/lib/assimp/include/assimp/LogAux.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -43,14 +43,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file  LogAux.h
  *  @brief Common logging usage patterns for importer implementations
  */
-#pragma once
 #ifndef INCLUDED_AI_LOGAUX_H
 #define INCLUDED_AI_LOGAUX_H
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <assimp/TinyFormatter.h>
 #include <assimp/Exceptional.h>
 #include <assimp/DefaultLogger.hpp>
diff --git a/Engine/lib/assimp/include/assimp/LogStream.hpp b/Engine/lib/assimp/include/assimp/LogStream.hpp
index 243f13ee6..d0281e2d0 100644
--- a/Engine/lib/assimp/include/assimp/LogStream.hpp
+++ b/Engine/lib/assimp/include/assimp/LogStream.hpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/include/assimp/Logger.hpp b/Engine/lib/assimp/include/assimp/Logger.hpp
index a0b798564..89cade6c3 100644
--- a/Engine/lib/assimp/include/assimp/Logger.hpp
+++ b/Engine/lib/assimp/include/assimp/Logger.hpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/MDL/HalfLife/HalfLifeMDLBaseHeader.h b/Engine/lib/assimp/include/assimp/Macros.h
similarity index 78%
rename from Engine/lib/assimp/code/MDL/HalfLife/HalfLifeMDLBaseHeader.h
rename to Engine/lib/assimp/include/assimp/Macros.h
index f26f8735d..651530337 100644
--- a/Engine/lib/assimp/code/MDL/HalfLife/HalfLifeMDLBaseHeader.h
+++ b/Engine/lib/assimp/include/assimp/Macros.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
@@ -39,29 +39,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
 
-/** @file HalfLifeMDLBaseHeader.h */
+/* Helper macro to set a pointer to NULL in debug builds
+ */
+#if (defined ASSIMP_BUILD_DEBUG)
+#   define AI_DEBUG_INVALIDATE_PTR(x) x = NULL;
+#else
+#   define AI_DEBUG_INVALIDATE_PTR(x)
+#endif
 
-#ifndef AI_HALFLIFEMDLBASEHEADER_INCLUDED
-#define AI_HALFLIFEMDLBASEHEADER_INCLUDED
-
-#include <assimp/types.h>
-
-namespace Assimp {
-namespace MDL {
-namespace HalfLife {
-
-/** Used to interface different Valve MDL formats. */
-struct HalfLifeMDLBaseHeader
-{
-    //! Magic number: "IDST"/"IDSQ"
-    char ident[4];
-
-    //! The file format version.
-    int32_t version;
-};
-
-}
-}
-}
-
-#endif // AI_HALFLIFEMDLBASEHEADER_INCLUDED
diff --git a/Engine/lib/assimp/include/assimp/MathFunctions.h b/Engine/lib/assimp/include/assimp/MathFunctions.h
index 1880ce0a9..f49273bb3 100644
--- a/Engine/lib/assimp/include/assimp/MathFunctions.h
+++ b/Engine/lib/assimp/include/assimp/MathFunctions.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2016, assimp team
 
 All rights reserved.
 
@@ -41,10 +41,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #pragma once
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 /** @file  MathFunctions.h
 *  @brief Implementation of math utility functions.
  *
diff --git a/Engine/lib/assimp/include/assimp/MemoryIOWrapper.h b/Engine/lib/assimp/include/assimp/MemoryIOWrapper.h
index 2ad80cc85..c52278718 100644
--- a/Engine/lib/assimp/include/assimp/MemoryIOWrapper.h
+++ b/Engine/lib/assimp/include/assimp/MemoryIOWrapper.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -42,18 +42,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** @file MemoryIOWrapper.h
  *  Handy IOStream/IOSystem implemetation to read directly from a memory buffer */
-#pragma once
 #ifndef AI_MEMORYIOSTREAM_H_INC
 #define AI_MEMORYIOSTREAM_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <assimp/IOStream.hpp>
 #include <assimp/IOSystem.hpp>
 #include <assimp/ai_assert.h>
-
 #include <stdint.h>
 
 namespace Assimp    {
diff --git a/Engine/lib/assimp/include/assimp/NullLogger.hpp b/Engine/lib/assimp/include/assimp/NullLogger.hpp
index 7effca83a..c45d01bd4 100644
--- a/Engine/lib/assimp/include/assimp/NullLogger.hpp
+++ b/Engine/lib/assimp/include/assimp/NullLogger.hpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/include/assimp/ParsingUtils.h b/Engine/lib/assimp/include/assimp/ParsingUtils.h
index 736952e26..6b9574fc6 100644
--- a/Engine/lib/assimp/include/assimp/ParsingUtils.h
+++ b/Engine/lib/assimp/include/assimp/ParsingUtils.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -44,16 +44,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file ParsingUtils.h
  *  @brief Defines helper functions for text parsing
  */
-#pragma once
 #ifndef AI_PARSING_UTILS_H_INC
 #define AI_PARSING_UTILS_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
-#include <assimp/StringComparison.h>
-#include <assimp/StringUtils.h>
+#include "StringComparison.h"
+#include "StringUtils.h"
 #include <assimp/defs.h>
 
 namespace Assimp {
diff --git a/Engine/lib/assimp/include/assimp/Profiler.h b/Engine/lib/assimp/include/assimp/Profiler.h
index ee6c5545f..6ff9d41c0 100644
--- a/Engine/lib/assimp/include/assimp/Profiler.h
+++ b/Engine/lib/assimp/include/assimp/Profiler.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -43,17 +43,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Profiler.h
  *  @brief Utility to measure the respective runtime of each import step
  */
-#pragma once
-#ifndef AI_INCLUDED_PROFILER_H
-#define AI_INCLUDED_PROFILER_H
-
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
+#ifndef INCLUDED_PROFILER_H
+#define INCLUDED_PROFILER_H
 
 #include <chrono>
 #include <assimp/DefaultLogger.hpp>
-#include <assimp/TinyFormatter.h>
+#include "TinyFormatter.h"
 
 #include <map>
 
@@ -72,6 +67,7 @@ public:
         // empty
     }
 
+public:
 
     /** Start a named timer */
     void BeginRegion(const std::string& region) {
@@ -99,5 +95,5 @@ private:
 }
 }
 
-#endif // AI_INCLUDED_PROFILER_H
+#endif
 
diff --git a/Engine/lib/assimp/include/assimp/ProgressHandler.hpp b/Engine/lib/assimp/include/assimp/ProgressHandler.hpp
index 45d3f57cd..4e47f1d0a 100644
--- a/Engine/lib/assimp/include/assimp/ProgressHandler.hpp
+++ b/Engine/lib/assimp/include/assimp/ProgressHandler.hpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -47,13 +47,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_PROGRESSHANDLER_H_INC
 #define AI_PROGRESSHANDLER_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
+#include "types.h"
 
-#include <assimp/types.h>
-
-namespace Assimp {
+namespace Assimp    {
 
 // ------------------------------------------------------------------------------------
 /** @brief CPP-API: Abstract interface for custom progress report receivers.
diff --git a/Engine/lib/assimp/include/assimp/RemoveComments.h b/Engine/lib/assimp/include/assimp/RemoveComments.h
index 5bb958257..404b49671 100644
--- a/Engine/lib/assimp/include/assimp/RemoveComments.h
+++ b/Engine/lib/assimp/include/assimp/RemoveComments.h
@@ -2,7 +2,8 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
+
 
 All rights reserved.
 
@@ -42,13 +43,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Declares a helper class, "CommentRemover", which can be
  *  used to remove comments (single and multi line) from a text file.
  */
-#pragma once
 #ifndef AI_REMOVE_COMMENTS_H_INC
 #define AI_REMOVE_COMMENTS_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
 
 #include <assimp/defs.h>
 
@@ -61,7 +58,8 @@ namespace Assimp    {
  *  to those in C or C++ so this code has been moved to a separate
  *  module.
  */
-class ASSIMP_API CommentRemover {
+class ASSIMP_API CommentRemover
+{
     // class cannot be instanced
     CommentRemover() {}
 
diff --git a/Engine/lib/assimp/include/assimp/SGSpatialSort.h b/Engine/lib/assimp/include/assimp/SGSpatialSort.h
index 9afe38f85..5b4f3f41f 100644
--- a/Engine/lib/assimp/include/assimp/SGSpatialSort.h
+++ b/Engine/lib/assimp/include/assimp/SGSpatialSort.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -42,14 +42,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** Small helper classes to optimize finding vertices close to a given location
  */
-#pragma once
 #ifndef AI_D3DSSPATIALSORT_H_INC
 #define AI_D3DSSPATIALSORT_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <assimp/types.h>
 #include <vector>
 #include <stdint.h>
diff --git a/Engine/lib/assimp/include/assimp/SceneCombiner.h b/Engine/lib/assimp/include/assimp/SceneCombiner.h
index 40aad0890..f69a25f43 100644
--- a/Engine/lib/assimp/include/assimp/SceneCombiner.h
+++ b/Engine/lib/assimp/include/assimp/SceneCombiner.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -43,22 +43,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Declares a helper class, "SceneCombiner" providing various
  *  utilities to merge scenes.
  */
-#pragma once
 #ifndef AI_SCENE_COMBINER_H_INC
 #define AI_SCENE_COMBINER_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <assimp/ai_assert.h>
 #include <assimp/types.h>
 #include <assimp/Defines.h>
-
 #include <stddef.h>
 #include <set>
 #include <list>
 #include <stdint.h>
+
 #include <vector>
 
 struct aiScene;
@@ -73,7 +68,6 @@ struct aiMesh;
 struct aiAnimMesh;
 struct aiAnimation;
 struct aiNodeAnim;
-struct aiMeshMorphAnim;
 
 namespace Assimp    {
 
@@ -378,7 +372,6 @@ public:
     static void Copy  (aiBone** dest, const aiBone* src);
     static void Copy  (aiLight** dest, const aiLight* src);
     static void Copy  (aiNodeAnim** dest, const aiNodeAnim* src);
-    static void Copy  (aiMeshMorphAnim** dest, const aiMeshMorphAnim* src);
     static void Copy  (aiMetadata** dest, const aiMetadata* src);
 
     // recursive, of course
diff --git a/Engine/lib/assimp/include/assimp/SkeletonMeshBuilder.h b/Engine/lib/assimp/include/assimp/SkeletonMeshBuilder.h
index 8e1a9830f..f9b8d9f55 100644
--- a/Engine/lib/assimp/include/assimp/SkeletonMeshBuilder.h
+++ b/Engine/lib/assimp/include/assimp/SkeletonMeshBuilder.h
@@ -4,7 +4,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -47,14 +47,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  for animation skeletons.
  */
 
-#pragma once
 #ifndef AI_SKELETONMESHBUILDER_H_INC
 #define AI_SKELETONMESHBUILDER_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <vector>
 #include <assimp/mesh.h>
 
diff --git a/Engine/lib/assimp/include/assimp/SmoothingGroups.h b/Engine/lib/assimp/include/assimp/SmoothingGroups.h
index 5d37f1bb5..92d65cea0 100644
--- a/Engine/lib/assimp/include/assimp/SmoothingGroups.h
+++ b/Engine/lib/assimp/include/assimp/SmoothingGroups.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -43,16 +43,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Defines the helper data structures for importing 3DS files.
 http://www.jalix.org/ressources/graphics/3DS/_unofficials/3ds-unofficial.txt */
 
-#pragma once
 #ifndef AI_SMOOTHINGGROUPS_H_INC
 #define AI_SMOOTHINGGROUPS_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <assimp/vector3.h>
-
 #include <stdint.h>
 #include <vector>
 
diff --git a/Engine/lib/assimp/include/assimp/SmoothingGroups.inl b/Engine/lib/assimp/include/assimp/SmoothingGroups.inl
index 417ca4312..84ea4a1b0 100644
--- a/Engine/lib/assimp/include/assimp/SmoothingGroups.inl
+++ b/Engine/lib/assimp/include/assimp/SmoothingGroups.inl
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2012, assimp team
 
 All rights reserved.
 
@@ -41,16 +41,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** @file Generation of normal vectors basing on smoothing groups */
 
-#pragma once
 #ifndef AI_SMOOTHINGGROUPS_INL_INCLUDED
 #define AI_SMOOTHINGGROUPS_INL_INCLUDED
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
+// internal headers
 #include <assimp/SGSpatialSort.h>
 
+// CRT header
 #include <algorithm>
 
 using namespace Assimp;
diff --git a/Engine/lib/assimp/include/assimp/SpatialSort.h b/Engine/lib/assimp/include/assimp/SpatialSort.h
index c2d8bbbf8..61b345bcb 100644
--- a/Engine/lib/assimp/include/assimp/SpatialSort.h
+++ b/Engine/lib/assimp/include/assimp/SpatialSort.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -41,14 +41,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 /** Small helper classes to optimise finding vertizes close to a given location */
-#pragma once
 #ifndef AI_SPATIALSORT_H_INC
 #define AI_SPATIALSORT_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <vector>
 #include <assimp/types.h>
 
diff --git a/Engine/lib/assimp/include/assimp/StandardShapes.h b/Engine/lib/assimp/include/assimp/StandardShapes.h
index 79bdae859..3791569b8 100644
--- a/Engine/lib/assimp/include/assimp/StandardShapes.h
+++ b/Engine/lib/assimp/include/assimp/StandardShapes.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -41,16 +41,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 /** @file Declares a helper class, "StandardShapes" which generates
- *  vertices for standard shapes, such as cylinders, cones, spheres ..
+ *  vertices for standard shapes, such as cylnders, cones, spheres ..
  */
-#pragma once
 #ifndef AI_STANDARD_SHAPES_H_INC
 #define AI_STANDARD_SHAPES_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <assimp/vector3.h>
 #include <vector>
 
diff --git a/Engine/lib/assimp/include/assimp/StreamReader.h b/Engine/lib/assimp/include/assimp/StreamReader.h
index 4cad96f6e..9116c1426 100644
--- a/Engine/lib/assimp/include/assimp/StreamReader.h
+++ b/Engine/lib/assimp/include/assimp/StreamReader.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -44,19 +44,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Defines the StreamReader class which reads data from
  *  a binary stream with a well-defined endianness.
  */
-#pragma once
+
 #ifndef AI_STREAMREADER_H_INCLUDED
 #define AI_STREAMREADER_H_INCLUDED
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <assimp/IOStream.hpp>
 #include <assimp/Defines.h>
-#include <assimp/ByteSwapper.h>
-#include <assimp/Exceptional.h>
 
+#include "ByteSwapper.h"
+#include "Exceptional.h"
 #include <memory>
 
 namespace Assimp {
diff --git a/Engine/lib/assimp/include/assimp/StreamWriter.h b/Engine/lib/assimp/include/assimp/StreamWriter.h
index de889b9f0..c7cf6c0d7 100644
--- a/Engine/lib/assimp/include/assimp/StreamWriter.h
+++ b/Engine/lib/assimp/include/assimp/StreamWriter.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -43,15 +43,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** @file Defines the StreamWriter class which writes data to
  *  a binary stream with a well-defined endianness. */
-#pragma once
+
 #ifndef AI_STREAMWRITER_H_INCLUDED
 #define AI_STREAMWRITER_H_INCLUDED
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
-#include <assimp/ByteSwapper.h>
+#include "ByteSwapper.h"
 #include <assimp/IOStream.hpp>
 
 #include <memory>
diff --git a/Engine/lib/assimp/include/assimp/StringComparison.h b/Engine/lib/assimp/include/assimp/StringComparison.h
index d7b8972e3..8acef277b 100644
--- a/Engine/lib/assimp/include/assimp/StringComparison.h
+++ b/Engine/lib/assimp/include/assimp/StringComparison.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -49,17 +49,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    These functions are not consistently available on all platforms,
    or the provided implementations behave too differently.
 */
-#pragma once
 #ifndef INCLUDED_AI_STRING_WORKERS_H
 #define INCLUDED_AI_STRING_WORKERS_H
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <assimp/ai_assert.h>
 #include <assimp/defs.h>
-#include <assimp/StringComparison.h>
+#include "StringComparison.h"
 
 #include <string.h>
 #include <stdint.h>
diff --git a/Engine/lib/assimp/include/assimp/StringUtils.h b/Engine/lib/assimp/include/assimp/StringUtils.h
index 31410a9fb..d68b7fa47 100644
--- a/Engine/lib/assimp/include/assimp/StringUtils.h
+++ b/Engine/lib/assimp/include/assimp/StringUtils.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -39,14 +39,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 ----------------------------------------------------------------------
 */
-#pragma once
 #ifndef INCLUDED_AI_STRINGUTILS_H
 #define INCLUDED_AI_STRINGUTILS_H
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <assimp/defs.h>
 
 #include <sstream>
diff --git a/Engine/lib/assimp/include/assimp/Subdivision.h b/Engine/lib/assimp/include/assimp/Subdivision.h
index 9a8bb9fd3..43feb73b3 100644
--- a/Engine/lib/assimp/include/assimp/Subdivision.h
+++ b/Engine/lib/assimp/include/assimp/Subdivision.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -45,10 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_SUBDISIVION_H_INC
 #define AI_SUBDISIVION_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
+#include <cstddef>
 #include <assimp/types.h>
 
 struct aiMesh;
diff --git a/Engine/lib/assimp/include/assimp/TinyFormatter.h b/Engine/lib/assimp/include/assimp/TinyFormatter.h
index 3c6ca66c6..1226b482e 100644
--- a/Engine/lib/assimp/include/assimp/TinyFormatter.h
+++ b/Engine/lib/assimp/include/assimp/TinyFormatter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -45,14 +45,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *    to get rid of the boost::format dependency. Much slinker,
  *    basically just extends stringstream.
  */
-#pragma once
 #ifndef INCLUDED_TINY_FORMATTER_H
 #define INCLUDED_TINY_FORMATTER_H
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <sstream>
 
 namespace Assimp {
@@ -70,15 +65,24 @@ namespace Formatter {
  *  @endcode */
 template < typename T,
     typename CharTraits = std::char_traits<T>,
-    typename Allocator  = std::allocator<T> >
-class basic_formatter {
-public:
-    typedef class std::basic_string<T,CharTraits,Allocator> string;
-    typedef class std::basic_ostringstream<T,CharTraits,Allocator> stringstream;
+    typename Allocator  = std::allocator<T>
+>
+class basic_formatter
+{
 
-    basic_formatter() {
-        // empty
-    }
+public:
+
+    typedef class std::basic_string<
+        T,CharTraits,Allocator
+    > string;
+
+    typedef class std::basic_ostringstream<
+        T,CharTraits,Allocator
+    > stringstream;
+
+public:
+
+    basic_formatter() {}
 
     /* Allow basic_formatter<T>'s to be used almost interchangeably
      * with std::(w)string or const (w)char* arguments because the
@@ -100,10 +104,14 @@ public:
     }
 #endif
 
+
+public:
+
     operator string () const {
         return underlying.str();
     }
 
+
     /* note - this is declared const because binding temporaries does only
      * work for const references, so many function prototypes will
      * include const basic_formatter<T>& s but might still want to
diff --git a/Engine/lib/assimp/include/assimp/Vertex.h b/Engine/lib/assimp/include/assimp/Vertex.h
index 5d4242cbd..2a7f0256a 100644
--- a/Engine/lib/assimp/include/assimp/Vertex.h
+++ b/Engine/lib/assimp/include/assimp/Vertex.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -47,18 +47,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   that are not currently well-defined (and would cause compile errors
   due to missing operators in the math library), are commented.
   */
-#pragma once
 #ifndef AI_VERTEX_H_INC
 #define AI_VERTEX_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <assimp/vector3.h>
 #include <assimp/mesh.h>
 #include <assimp/ai_assert.h>
-
 #include <functional>
 
 namespace Assimp    {
@@ -97,14 +91,23 @@ namespace Assimp    {
  *  to *all* vertex components equally. This is useful for stuff like interpolation
  *  or subdivision, but won't work if special handling is required for some vertex components. */
 // ------------------------------------------------------------------------------------------------
-class Vertex {
+class Vertex
+{
     friend Vertex operator + (const Vertex&,const Vertex&);
     friend Vertex operator - (const Vertex&,const Vertex&);
+
+//  friend Vertex operator + (const Vertex&,ai_real);
+//  friend Vertex operator - (const Vertex&,ai_real);
     friend Vertex operator * (const Vertex&,ai_real);
     friend Vertex operator / (const Vertex&,ai_real);
+
+//  friend Vertex operator + (ai_real, const Vertex&);
+//  friend Vertex operator - (ai_real, const Vertex&);
     friend Vertex operator * (ai_real, const Vertex&);
+//  friend Vertex operator / (ai_real, const Vertex&);
 
 public:
+
     Vertex() {}
 
     // ----------------------------------------------------------------------------
@@ -155,6 +158,8 @@ public:
         }
     }
 
+public:
+
     Vertex& operator += (const Vertex& v) {
         *this = *this+v;
         return *this;
@@ -165,6 +170,18 @@ public:
         return *this;
     }
 
+
+/*
+    Vertex& operator += (ai_real v) {
+        *this = *this+v;
+        return *this;
+    }
+
+    Vertex& operator -= (ai_real v) {
+        *this = *this-v;
+        return *this;
+    }
+*/
     Vertex& operator *= (ai_real v) {
         *this = *this*v;
         return *this;
@@ -175,9 +192,12 @@ public:
         return *this;
     }
 
+public:
+
     // ----------------------------------------------------------------------------
     /** Convert back to non-interleaved storage */
     void SortBack(aiMesh* out, unsigned int idx) const {
+
         ai_assert(idx<out->mNumVertices);
         out->mVertices[idx] = position;
 
@@ -271,6 +291,8 @@ public:
     aiColor4D colors[AI_MAX_NUMBER_OF_COLOR_SETS];
 };
 
+
+
 // ------------------------------------------------------------------------------------------------
 AI_FORCE_INLINE Vertex operator + (const Vertex& v0,const Vertex& v1) {
     return Vertex::BinaryOp<std::plus>(v0,v1);
@@ -280,6 +302,19 @@ AI_FORCE_INLINE Vertex operator - (const Vertex& v0,const Vertex& v1) {
     return Vertex::BinaryOp<std::minus>(v0,v1);
 }
 
+
+// ------------------------------------------------------------------------------------------------
+/*
+AI_FORCE_INLINE Vertex operator + (const Vertex& v0,ai_real f) {
+    return Vertex::BinaryOp<Intern::plus>(v0,f);
+}
+
+AI_FORCE_INLINE Vertex operator - (const Vertex& v0,ai_real f) {
+    return Vertex::BinaryOp<Intern::minus>(v0,f);
+}
+
+*/
+
 AI_FORCE_INLINE Vertex operator * (const Vertex& v0,ai_real f) {
     return Vertex::BinaryOp<Intern::multiplies>(v0,f);
 }
@@ -288,10 +323,26 @@ AI_FORCE_INLINE Vertex operator / (const Vertex& v0,ai_real f) {
     return Vertex::BinaryOp<Intern::multiplies>(v0,1.f/f);
 }
 
+// ------------------------------------------------------------------------------------------------
+/*
+AI_FORCE_INLINE Vertex operator + (ai_real f,const Vertex& v0) {
+    return Vertex::BinaryOp<Intern::plus>(f,v0);
+}
+
+AI_FORCE_INLINE Vertex operator - (ai_real f,const Vertex& v0) {
+    return Vertex::BinaryOp<Intern::minus>(f,v0);
+}
+*/
+
 AI_FORCE_INLINE Vertex operator * (ai_real f,const Vertex& v0) {
     return Vertex::BinaryOp<Intern::multiplies>(f,v0);
 }
 
+/*
+AI_FORCE_INLINE Vertex operator / (ai_real f,const Vertex& v0) {
+    return Vertex::BinaryOp<Intern::divides>(f,v0);
 }
+*/
 
-#endif // AI_VERTEX_H_INC
+}
+#endif
diff --git a/Engine/lib/assimp/include/assimp/XMLTools.h b/Engine/lib/assimp/include/assimp/XMLTools.h
index 845851308..b0d327687 100644
--- a/Engine/lib/assimp/include/assimp/XMLTools.h
+++ b/Engine/lib/assimp/include/assimp/XMLTools.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -40,14 +40,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
-#pragma once
 #ifndef INCLUDED_ASSIMP_XML_TOOLS_H
 #define INCLUDED_ASSIMP_XML_TOOLS_H
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <string>
 
 namespace Assimp {
diff --git a/Engine/lib/assimp/include/assimp/ZipArchiveIOSystem.h b/Engine/lib/assimp/include/assimp/ZipArchiveIOSystem.h
index b0541fa59..38cbbf2a7 100644
--- a/Engine/lib/assimp/include/assimp/ZipArchiveIOSystem.h
+++ b/Engine/lib/assimp/include/assimp/ZipArchiveIOSystem.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -45,50 +45,43 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Implementation of IOSystem to read a ZIP file from another IOSystem
 */
 
-#pragma once
 #ifndef AI_ZIPARCHIVEIOSYSTEM_H_INC
 #define AI_ZIPARCHIVEIOSYSTEM_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <assimp/IOStream.hpp>
 #include <assimp/IOSystem.hpp>
 
 namespace Assimp {
+    class ZipArchiveIOSystem : public IOSystem {
+    public:
+        //! Open a Zip using the proffered IOSystem
+        ZipArchiveIOSystem(IOSystem* pIOHandler, const char *pFilename, const char* pMode = "r");
+        ZipArchiveIOSystem(IOSystem* pIOHandler, const std::string& rFilename, const char* pMode = "r");
+        virtual ~ZipArchiveIOSystem();
+        bool Exists(const char* pFilename) const override;
+        char getOsSeparator() const override;
+        IOStream* Open(const char* pFilename, const char* pMode = "rb") override;
+        void Close(IOStream* pFile) override;
 
-class ZipArchiveIOSystem : public IOSystem {
-public:
-    //! Open a Zip using the proffered IOSystem
-    ZipArchiveIOSystem(IOSystem* pIOHandler, const char *pFilename, const char* pMode = "r");
-    ZipArchiveIOSystem(IOSystem* pIOHandler, const std::string& rFilename, const char* pMode = "r");
-    virtual ~ZipArchiveIOSystem();
-    bool Exists(const char* pFilename) const override;
-    char getOsSeparator() const override;
-    IOStream* Open(const char* pFilename, const char* pMode = "rb") override;
-    void Close(IOStream* pFile) override;
+        // Specific to ZIP
+        //! The file was opened and is a ZIP
+        bool isOpen() const;
 
-    // Specific to ZIP
-    //! The file was opened and is a ZIP
-    bool isOpen() const;
+        //! Get the list of all files with their simplified paths
+        //! Intended for use within Assimp library boundaries
+        void getFileList(std::vector<std::string>& rFileList) const;
 
-    //! Get the list of all files with their simplified paths
-    //! Intended for use within Assimp library boundaries
-    void getFileList(std::vector<std::string>& rFileList) const;
+        //! Get the list of all files with extension (must be lowercase)
+        //! Intended for use within Assimp library boundaries
+        void getFileListExtension(std::vector<std::string>& rFileList, const std::string& extension) const;
 
-    //! Get the list of all files with extension (must be lowercase)
-    //! Intended for use within Assimp library boundaries
-    void getFileListExtension(std::vector<std::string>& rFileList, const std::string& extension) const;
-
-    static bool isZipArchive(IOSystem* pIOHandler, const char *pFilename);
-    static bool isZipArchive(IOSystem* pIOHandler, const std::string& rFilename);
-
-private:
-    class Implement;
-    Implement *pImpl = nullptr;
-};
+        static bool isZipArchive(IOSystem* pIOHandler, const char *pFilename);
+        static bool isZipArchive(IOSystem* pIOHandler, const std::string& rFilename);
 
+    private:
+        class Implement;
+        Implement *pImpl = nullptr;
+    };
 } // Namespace Assimp
 
 #endif // AI_ZIPARCHIVEIOSYSTEM_H_INC
diff --git a/Engine/lib/assimp/include/assimp/aabb.h b/Engine/lib/assimp/include/assimp/aabb.h
index 27a142c8e..a20f31742 100644
--- a/Engine/lib/assimp/include/assimp/aabb.h
+++ b/Engine/lib/assimp/include/assimp/aabb.h
@@ -3,7 +3,9 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
+
+
 
 All rights reserved.
 
@@ -43,10 +45,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_AABB_H_INC
 #define AI_AABB_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <assimp/vector3.h>
 
 struct aiAABB {
@@ -71,9 +69,8 @@ struct aiAABB {
         // empty
     }
 
-#endif // __cplusplus
-
+#endif 
 };
 
 
-#endif // AI_AABB_H_INC
+#endif
diff --git a/Engine/lib/assimp/include/assimp/ai_assert.h b/Engine/lib/assimp/include/assimp/ai_assert.h
index f430e4ad3..e5de5d3f3 100644
--- a/Engine/lib/assimp/include/assimp/ai_assert.h
+++ b/Engine/lib/assimp/include/assimp/ai_assert.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -44,10 +44,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_ASSERT_H_INC
 #define AI_ASSERT_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #ifdef ASSIMP_BUILD_DEBUG
 #   include <assert.h>
 #   define ai_assert(expression) assert( expression )
diff --git a/Engine/lib/assimp/include/assimp/anim.h b/Engine/lib/assimp/include/assimp/anim.h
index a7af1034f..02e92739e 100644
--- a/Engine/lib/assimp/include/assimp/anim.h
+++ b/Engine/lib/assimp/include/assimp/anim.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -50,10 +50,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_ANIM_H_INC
 #define AI_ANIM_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <assimp/types.h>
 #include <assimp/quaternion.h>
 
diff --git a/Engine/lib/assimp/include/assimp/camera.h b/Engine/lib/assimp/include/assimp/camera.h
index 2001a9354..a9a9f7653 100644
--- a/Engine/lib/assimp/include/assimp/camera.h
+++ b/Engine/lib/assimp/include/assimp/camera.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
@@ -47,10 +47,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_CAMERA_H_INC
 #define AI_CAMERA_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include "types.h"
 
 #ifdef __cplusplus
diff --git a/Engine/lib/assimp/include/assimp/cexport.h b/Engine/lib/assimp/include/assimp/cexport.h
index 959d4377e..1d62dc26b 100644
--- a/Engine/lib/assimp/include/assimp/cexport.h
+++ b/Engine/lib/assimp/include/assimp/cexport.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2011, assimp team
 
 All rights reserved.
 
@@ -46,10 +46,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_EXPORT_H_INC
 #define AI_EXPORT_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #ifndef ASSIMP_BUILD_NO_EXPORT
 
 // Public ASSIMP data structures
diff --git a/Engine/lib/assimp/include/assimp/cfileio.h b/Engine/lib/assimp/include/assimp/cfileio.h
index 627c700ad..8f7ca4546 100644
--- a/Engine/lib/assimp/include/assimp/cfileio.h
+++ b/Engine/lib/assimp/include/assimp/cfileio.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -48,16 +48,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_FILEIO_H_INC
 #define AI_FILEIO_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <assimp/types.h>
-
 #ifdef __cplusplus
 extern "C" {
 #endif
-
 struct aiFileIO;
 struct aiFile;
 
diff --git a/Engine/lib/assimp/include/assimp/cimport.h b/Engine/lib/assimp/include/assimp/cimport.h
index dab60584b..dbd10f137 100644
--- a/Engine/lib/assimp/include/assimp/cimport.h
+++ b/Engine/lib/assimp/include/assimp/cimport.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -48,12 +48,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_ASSIMP_H_INC
 #define AI_ASSIMP_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <assimp/types.h>
-#include <assimp/importerdesc.h>
+#include "importerdesc.h"
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/Engine/lib/assimp/include/assimp/color4.h b/Engine/lib/assimp/include/assimp/color4.h
index 505a3510c..3c97c8eda 100644
--- a/Engine/lib/assimp/include/assimp/color4.h
+++ b/Engine/lib/assimp/include/assimp/color4.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -47,11 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_COLOR4D_H_INC
 #define AI_COLOR4D_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
-#include <assimp/defs.h>
+#include "defs.h"
 
 #ifdef __cplusplus
 
@@ -60,7 +56,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *   alpha component. Color values range from 0 to 1. */
 // ----------------------------------------------------------------------------------
 template <typename TReal>
-class aiColor4t {
+class aiColor4t
+{
 public:
     aiColor4t() AI_NO_EXCEPT : r(), g(), b(), a() {}
     aiColor4t (TReal _r, TReal _g, TReal _b, TReal _a)
@@ -68,12 +65,14 @@ public:
     explicit aiColor4t (TReal _r) : r(_r), g(_r), b(_r), a(_r) {}
     aiColor4t (const aiColor4t& o) = default;
 
+public:
     // combined operators
     const aiColor4t& operator += (const aiColor4t& o);
     const aiColor4t& operator -= (const aiColor4t& o);
     const aiColor4t& operator *= (TReal f);
     const aiColor4t& operator /= (TReal f);
 
+public:
     // comparison
     bool operator == (const aiColor4t& other) const;
     bool operator != (const aiColor4t& other) const;
@@ -86,6 +85,8 @@ public:
     /** check whether a color is (close to) black */
     inline bool IsBlack() const;
 
+public:
+
     // Red, green, blue and alpha color values
     TReal r, g, b, a;
 };  // !struct aiColor4D
diff --git a/Engine/lib/assimp/include/assimp/color4.inl b/Engine/lib/assimp/include/assimp/color4.inl
index 964b8fbf9..afa53dcb5 100644
--- a/Engine/lib/assimp/include/assimp/color4.inl
+++ b/Engine/lib/assimp/include/assimp/color4.inl
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -48,61 +48,36 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_COLOR4D_INL_INC
 #define AI_COLOR4D_INL_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #ifdef __cplusplus
-#include <assimp/color4.h>
+#include "color4.h"
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-const aiColor4t<TReal>& aiColor4t<TReal>::operator += (const aiColor4t<TReal>& o) {
-    r += o.r;
-    g += o.g;
-    b += o.b;
-    a += o.a;
-
+AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator += (const aiColor4t<TReal>& o) {
+    r += o.r; g += o.g; b += o.b; a += o.a;
     return *this;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-const aiColor4t<TReal>& aiColor4t<TReal>::operator -= (const aiColor4t<TReal>& o) {
-    r -= o.r;
-    g -= o.g;
-    b -= o.b;
-    a -= o.a;
-
+AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator -= (const aiColor4t<TReal>& o) {
+    r -= o.r; g -= o.g; b -= o.b; a -= o.a;
     return *this;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-const aiColor4t<TReal>& aiColor4t<TReal>::operator *= (TReal f) {
-    r *= f;
-    g *= f;
-    b *= f;
-    a *= f;
-
+AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator *= (TReal f) {
+    r *= f; g *= f; b *= f; a *= f;
     return *this;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-const aiColor4t<TReal>& aiColor4t<TReal>::operator /= (TReal f) {
-    r /= f;
-    g /= f;
-    b /= f;
-    a /= f;
-
+AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator /= (TReal f) {
+    r /= f; g /= f; b /= f; a /= f;
     return *this;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-TReal aiColor4t<TReal>::operator[](unsigned int i) const {
+AI_FORCE_INLINE TReal aiColor4t<TReal>::operator[](unsigned int i) const {
     switch ( i ) {
         case 0:
             return r;
@@ -119,8 +94,7 @@ TReal aiColor4t<TReal>::operator[](unsigned int i) const {
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-TReal& aiColor4t<TReal>::operator[](unsigned int i) {
+AI_FORCE_INLINE TReal& aiColor4t<TReal>::operator[](unsigned int i) {
     switch ( i ) {
         case 0:
             return r;
@@ -137,20 +111,17 @@ TReal& aiColor4t<TReal>::operator[](unsigned int i) {
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-bool aiColor4t<TReal>::operator== (const aiColor4t<TReal>& other) const {
+AI_FORCE_INLINE bool aiColor4t<TReal>::operator== (const aiColor4t<TReal>& other) const {
     return r == other.r && g == other.g && b == other.b && a == other.a;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-bool aiColor4t<TReal>::operator!= (const aiColor4t<TReal>& other) const {
+AI_FORCE_INLINE bool aiColor4t<TReal>::operator!= (const aiColor4t<TReal>& other) const {
     return r != other.r || g != other.g || b != other.b || a != other.a;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-bool aiColor4t<TReal>::operator< (const aiColor4t<TReal>& other) const {
+AI_FORCE_INLINE bool aiColor4t<TReal>::operator< (const aiColor4t<TReal>& other) const {
     return r < other.r || (
         r == other.r && (
             g < other.g || (
@@ -165,17 +136,14 @@ bool aiColor4t<TReal>::operator< (const aiColor4t<TReal>& other) const {
         )
     );
 }
-
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiColor4t<TReal> operator + (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2)    {
+AI_FORCE_INLINE aiColor4t<TReal> operator + (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2)    {
     return aiColor4t<TReal>( v1.r + v2.r, v1.g + v2.g, v1.b + v2.b, v1.a + v2.a);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiColor4t<TReal> operator - (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2)    {
+AI_FORCE_INLINE aiColor4t<TReal> operator - (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2)    {
     return aiColor4t<TReal>( v1.r - v2.r, v1.g - v2.g, v1.b - v2.b, v1.a - v2.a);
 }
 // ------------------------------------------------------------------------------------------------
@@ -185,63 +153,53 @@ AI_FORCE_INLINE aiColor4t<TReal> operator * (const aiColor4t<TReal>& v1, const a
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiColor4t<TReal> operator / (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2)    {
+AI_FORCE_INLINE aiColor4t<TReal> operator / (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2)    {
     return aiColor4t<TReal>( v1.r / v2.r, v1.g / v2.g, v1.b / v2.b, v1.a / v2.a);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiColor4t<TReal> operator * ( TReal f, const aiColor4t<TReal>& v)   {
+AI_FORCE_INLINE aiColor4t<TReal> operator * ( TReal f, const aiColor4t<TReal>& v)   {
     return aiColor4t<TReal>( f*v.r, f*v.g, f*v.b, f*v.a);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiColor4t<TReal> operator * ( const aiColor4t<TReal>& v, TReal f)  {
+AI_FORCE_INLINE  aiColor4t<TReal> operator * ( const aiColor4t<TReal>& v, TReal f)  {
     return aiColor4t<TReal>( f*v.r, f*v.g, f*v.b, f*v.a);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiColor4t<TReal> operator / ( const aiColor4t<TReal>& v, TReal f)  {
+AI_FORCE_INLINE  aiColor4t<TReal> operator / ( const aiColor4t<TReal>& v, TReal f)  {
     return v * (1/f);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiColor4t<TReal> operator / ( TReal f,const aiColor4t<TReal>& v)   {
+AI_FORCE_INLINE  aiColor4t<TReal> operator / ( TReal f,const aiColor4t<TReal>& v)   {
     return aiColor4t<TReal>(f,f,f,f)/v;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiColor4t<TReal> operator + ( const aiColor4t<TReal>& v, TReal f)  {
+AI_FORCE_INLINE  aiColor4t<TReal> operator + ( const aiColor4t<TReal>& v, TReal f)  {
     return aiColor4t<TReal>( f+v.r, f+v.g, f+v.b, f+v.a);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiColor4t<TReal> operator - ( const aiColor4t<TReal>& v, TReal f)  {
+AI_FORCE_INLINE  aiColor4t<TReal> operator - ( const aiColor4t<TReal>& v, TReal f)  {
     return aiColor4t<TReal>( v.r-f, v.g-f, v.b-f, v.a-f);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiColor4t<TReal> operator + ( TReal f, const aiColor4t<TReal>& v)  {
+AI_FORCE_INLINE  aiColor4t<TReal> operator + ( TReal f, const aiColor4t<TReal>& v)  {
     return aiColor4t<TReal>( f+v.r, f+v.g, f+v.b, f+v.a);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiColor4t<TReal> operator - ( TReal f, const aiColor4t<TReal>& v)  {
+AI_FORCE_INLINE  aiColor4t<TReal> operator - ( TReal f, const aiColor4t<TReal>& v)  {
     return aiColor4t<TReal>( f-v.r, f-v.g, f-v.b, f-v.a);
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-bool aiColor4t<TReal>::IsBlack() const {
+inline bool aiColor4t<TReal> :: IsBlack() const {
     // The alpha component doesn't care here. black is black.
     static const TReal epsilon = 10e-3f;
     return std::fabs( r ) < epsilon && std::fabs( g ) < epsilon && std::fabs( b ) < epsilon;
diff --git a/Engine/lib/assimp/include/assimp/commonMetaData.h b/Engine/lib/assimp/include/assimp/commonMetaData.h
deleted file mode 100644
index f3f7d170a..000000000
--- a/Engine/lib/assimp/include/assimp/commonMetaData.h
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-/** @file commonMetaData.h
- *  @brief Defines a set of common scene metadata keys.
- */
-#pragma once
-#ifndef AI_COMMONMETADATA_H_INC
-#define AI_COMMONMETADATA_H_INC
-
-/// Scene metadata holding the name of the importer which loaded the source asset.
-/// This is always present if the scene was created from an imported asset.
-#define AI_METADATA_SOURCE_FORMAT "SourceAsset_Format"
-
-/// Scene metadata holding the version of the source asset as a string, if available.
-/// Not all formats add this metadata.
-#define AI_METADATA_SOURCE_FORMAT_VERSION "SourceAsset_FormatVersion"
-
-/// Scene metadata holding the name of the software which generated the source asset, if available.
-/// Not all formats add this metadata.
-#define AI_METADATA_SOURCE_GENERATOR "SourceAsset_Generator"
-
-/// Scene metadata holding the source asset copyright statement, if available.
-/// Not all formats add this metadata.
-#define AI_METADATA_SOURCE_COPYRIGHT "SourceAsset_Copyright"
-
-#endif
diff --git a/Engine/lib/assimp/include/assimp/config.h b/Engine/lib/assimp/include/assimp/config.h
index 081f94cb9..48d61941a 100644
--- a/Engine/lib/assimp/include/assimp/config.h
+++ b/Engine/lib/assimp/include/assimp/config.h
@@ -1013,4 +1013,6 @@ enum aiComponent
  * Property type: Bool. Default value: undefined.
  */
 
+/* #undef ASSIMP_DOUBLE_PRECISION */
+
 #endif // !! AI_CONFIG_H_INC
diff --git a/Engine/lib/assimp/include/assimp/config.h.in b/Engine/lib/assimp/include/assimp/config.h.in
index e2f2a3888..3a6379bf4 100644
--- a/Engine/lib/assimp/include/assimp/config.h.in
+++ b/Engine/lib/assimp/include/assimp/config.h.in
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2018, assimp team
 
 
 All rights reserved.
@@ -695,73 +695,6 @@ enum aiComponent
 #define AI_CONFIG_IMPORT_SMD_KEYFRAME       "IMPORT_SMD_KEYFRAME"
 #define AI_CONFIG_IMPORT_UNREAL_KEYFRAME    "IMPORT_UNREAL_KEYFRAME"
 
-// ---------------------------------------------------------------------------
-/** @brief Set whether the MDL (HL1) importer will read animations.
- *
- * The default value is true (1)
- * Property type: bool
- */
-#define AI_CONFIG_IMPORT_MDL_HL1_READ_ANIMATIONS "IMPORT_MDL_HL1_READ_ANIMATIONS"
-
-// ---------------------------------------------------------------------------
-/** @brief Set whether the MDL (HL1) importer will read animation events.
- * \note This property requires AI_CONFIG_IMPORT_MDL_HL1_READ_ANIMATIONS to be set to true.
- *
- * The default value is true (1)
- * Property type: bool
- */
-#define AI_CONFIG_IMPORT_MDL_HL1_READ_ANIMATION_EVENTS "IMPORT_MDL_HL1_READ_ANIMATION_EVENTS"
-
-// ---------------------------------------------------------------------------
-/** @brief Set whether the MDL (HL1) importer will read blend controllers.
- * \note This property requires AI_CONFIG_IMPORT_MDL_HL1_READ_ANIMATIONS to be set to true.
- *
- * The default value is true (1)
- * Property type: bool
- */
-#define AI_CONFIG_IMPORT_MDL_HL1_READ_BLEND_CONTROLLERS "IMPORT_MDL_HL1_READ_BLEND_CONTROLLERS"
-
-// ---------------------------------------------------------------------------
-/** @brief Set whether the MDL (HL1) importer will read sequence transition graph.
- * \note This property requires AI_CONFIG_IMPORT_MDL_HL1_READ_ANIMATIONS to be set to true.
- *
- * The default value is true (1)
- * Property type: bool
- */
-#define AI_CONFIG_IMPORT_MDL_HL1_READ_SEQUENCE_TRANSITIONS "IMPORT_MDL_HL1_READ_SEQUENCE_TRANSITIONS"
-
-// ---------------------------------------------------------------------------
-/** @brief Set whether the MDL (HL1) importer will read attachments info.
- *
- * The default value is true (1)
- * Property type: bool
- */
-#define AI_CONFIG_IMPORT_MDL_HL1_READ_ATTACHMENTS "IMPORT_MDL_HL1_READ_ATTACHMENTS"
-
-// ---------------------------------------------------------------------------
-/** @brief Set whether the MDL (HL1) importer will read bone controllers info.
- *
- * The default value is true (1)
- * Property type: bool
- */
-#define AI_CONFIG_IMPORT_MDL_HL1_READ_BONE_CONTROLLERS "IMPORT_MDL_HL1_READ_BONE_CONTROLLERS"
-
-// ---------------------------------------------------------------------------
-/** @brief Set whether the MDL (HL1) importer will read hitboxes info.
- *
- * The default value is true (1)
- * Property type: bool
- */
-#define AI_CONFIG_IMPORT_MDL_HL1_READ_HITBOXES "IMPORT_MDL_HL1_READ_HITBOXES"
-
-// ---------------------------------------------------------------------------
-/** @brief Set whether the MDL (HL1) importer will read miscellaneous global model info.
- *
- * The default value is true (1)
- * Property type: bool
- */
-#define AI_CONFIG_IMPORT_MDL_HL1_READ_MISC_GLOBAL_INFO "IMPORT_MDL_HL1_READ_MISC_GLOBAL_INFO"
-
 // ---------------------------------------------------------------------------
 /** Smd load multiple animations
  *
diff --git a/Engine/lib/assimp/include/assimp/defs.h b/Engine/lib/assimp/include/assimp/defs.h
index 8e300e968..05a5e3fd4 100644
--- a/Engine/lib/assimp/include/assimp/defs.h
+++ b/Engine/lib/assimp/include/assimp/defs.h
@@ -3,7 +3,9 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
+
+
 
 All rights reserved.
 
@@ -48,10 +50,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_DEFINES_H_INC
 #define AI_DEFINES_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <assimp/config.h>
 
 //////////////////////////////////////////////////////////////////////////
@@ -128,14 +126,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  * GENBOUNDINGBOXES */
 //////////////////////////////////////////////////////////////////////////
 
-#ifdef _WIN32
+#ifdef _MSC_VER
 #   undef ASSIMP_API
+
     //////////////////////////////////////////////////////////////////////////
     /* Define 'ASSIMP_BUILD_DLL_EXPORT' to build a DLL of the library */
     //////////////////////////////////////////////////////////////////////////
 #   ifdef ASSIMP_BUILD_DLL_EXPORT
 #       define ASSIMP_API __declspec(dllexport)
 #       define ASSIMP_API_WINONLY __declspec(dllexport)
+#       pragma warning (disable : 4251)
 
     //////////////////////////////////////////////////////////////////////////
     /* Define 'ASSIMP_DLL' before including Assimp to link to ASSIMP in
@@ -148,19 +148,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #       define ASSIMP_API
 #       define ASSIMP_API_WINONLY
 #   endif
-#elif defined(SWIG)
 
-    /* Do nothing, the relevant defines are all in AssimpSwigPort.i */
-
-#else
-#   define ASSIMP_API __attribute__ ((visibility("default")))
-#   define ASSIMP_API_WINONLY
-#endif
-
-#ifdef _MSC_VER
-#   ifdef ASSIMP_BUILD_DLL_EXPORT
-#       pragma warning (disable : 4251)
-#   endif
     /* Force the compiler to inline a function, if possible
      */
 #   define AI_FORCE_INLINE __forceinline
@@ -168,12 +156,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     /* Tells the compiler that a function never returns. Used in code analysis
      * to skip dead paths (e.g. after an assertion evaluated to false). */
 #   define AI_WONT_RETURN __declspec(noreturn)
+
 #elif defined(SWIG)
 
     /* Do nothing, the relevant defines are all in AssimpSwigPort.i */
 
 #else
+
 #   define AI_WONT_RETURN
+
+#   define ASSIMP_API __attribute__ ((visibility("default")))
+#   define ASSIMP_API_WINONLY
 #   define AI_FORCE_INLINE inline
 #endif // (defined _MSC_VER)
 
@@ -298,19 +291,14 @@ static const ai_real ai_epsilon = (ai_real) 0.00001;
 #endif
 
 
-/**
- *  To avoid running out of memory
- *  This can be adjusted for specific use cases
- *  It's NOT a total limit, just a limit for individual allocations
+/* To avoid running out of memory
+ * This can be adjusted for specific use cases
+ * It's NOT a total limit, just a limit for individual allocations
  */
 #define AI_MAX_ALLOC(type) ((256U * 1024 * 1024) / sizeof(type))
 
 #ifndef _MSC_VER
-#  if __cplusplus >= 201103L // C++11
-#    define AI_NO_EXCEPT noexcept
-#  else
-#    define AI_NO_EXCEPT
-#  endif
+#  define AI_NO_EXCEPT noexcept
 #else
 #  if (_MSC_VER >= 1915 )
 #    define AI_NO_EXCEPT noexcept
@@ -319,13 +307,4 @@ static const ai_real ai_epsilon = (ai_real) 0.00001;
 #  endif
 #endif // _MSC_VER
 
-/**
- *  Helper macro to set a pointer to NULL in debug builds
- */
-#if (defined ASSIMP_BUILD_DEBUG)
-#   define AI_DEBUG_INVALIDATE_PTR(x) x = NULL;
-#else
-#   define AI_DEBUG_INVALIDATE_PTR(x)
-#endif
-
 #endif // !! AI_DEFINES_H_INC
diff --git a/Engine/lib/assimp/include/assimp/fast_atof.h b/Engine/lib/assimp/include/assimp/fast_atof.h
index 6e9a1bba7..62ea969e9 100644
--- a/Engine/lib/assimp/include/assimp/fast_atof.h
+++ b/Engine/lib/assimp/include/assimp/fast_atof.h
@@ -13,14 +13,10 @@
 //     to ensure long numbers are handled correctly
 // ------------------------------------------------------------------------------------
 
-#pragma once
+
 #ifndef FAST_A_TO_F_H_INCLUDED
 #define FAST_A_TO_F_H_INCLUDED
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <cmath>
 #include <limits>
 #include <stdint.h>
diff --git a/Engine/lib/assimp/include/assimp/importerdesc.h b/Engine/lib/assimp/include/assimp/importerdesc.h
index e0f22a9d6..36e387f01 100644
--- a/Engine/lib/assimp/include/assimp/importerdesc.h
+++ b/Engine/lib/assimp/include/assimp/importerdesc.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -48,14 +48,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_IMPORTER_DESC_H_INC
 #define AI_IMPORTER_DESC_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 
 /** Mixed set of flags for #aiImporterDesc, indicating some features
   *  common to many importers*/
-enum aiImporterFlags {
+enum aiImporterFlags
+{
     /** Indicates that there is a textual encoding of the
      *  file format; and that it is supported.*/
     aiImporterFlags_SupportTextFlavour = 0x1,
@@ -90,7 +87,8 @@ enum aiImporterFlags {
  *  as importers/exporters are added to Assimp, so it might be useful
  *  to have a common mechanism to query some rough importer
  *  characteristics. */
-struct aiImporterDesc {
+struct aiImporterDesc
+{
     /** Full name of the importer (i.e. Blender3D importer)*/
     const char* mName;
 
diff --git a/Engine/lib/assimp/include/assimp/irrXMLWrapper.h b/Engine/lib/assimp/include/assimp/irrXMLWrapper.h
index 65a7be298..77cfd5e47 100644
--- a/Engine/lib/assimp/include/assimp/irrXMLWrapper.h
+++ b/Engine/lib/assimp/include/assimp/irrXMLWrapper.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/include/assimp/light.h b/Engine/lib/assimp/include/assimp/light.h
index 84f2f7d0a..1667cfb8c 100644
--- a/Engine/lib/assimp/include/assimp/light.h
+++ b/Engine/lib/assimp/include/assimp/light.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -49,11 +49,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_LIGHT_H_INC
 #define AI_LIGHT_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
-#include <assimp/types.h>
+#include "types.h"
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/Engine/lib/assimp/include/assimp/material.h b/Engine/lib/assimp/include/assimp/material.h
index 75695e50b..206eb2a2b 100644
--- a/Engine/lib/assimp/include/assimp/material.h
+++ b/Engine/lib/assimp/include/assimp/material.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -48,11 +48,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_MATERIAL_H_INC
 #define AI_MATERIAL_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
-#include <assimp/types.h>
+#include "types.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -312,10 +308,6 @@ enum aiTextureType
 
 #define AI_TEXTURE_TYPE_MAX  aiTextureType_UNKNOWN
 
-// -------------------------------------------------------------------------------
-// Get a string for a given aiTextureType
-ASSIMP_API const char* TextureTypeToString(enum aiTextureType in);
-
 // ---------------------------------------------------------------------------
 /** @brief Defines all shading models supported by the library
  *
diff --git a/Engine/lib/assimp/include/assimp/material.inl b/Engine/lib/assimp/include/assimp/material.inl
index 759134441..b05d6af6c 100644
--- a/Engine/lib/assimp/include/assimp/material.inl
+++ b/Engine/lib/assimp/include/assimp/material.inl
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -49,18 +49,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_MATERIAL_INL_INC
 #define AI_MATERIAL_INL_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE
-aiPropertyTypeInfo ai_real_to_property_type_info(float) {
+inline aiPropertyTypeInfo ai_real_to_property_type_info(float)
+{
 	return aiPTI_Float;
 }
 
-AI_FORCE_INLINE
-aiPropertyTypeInfo ai_real_to_property_type_info(double) {
+inline aiPropertyTypeInfo ai_real_to_property_type_info(double)
+{
 	return aiPTI_Double;
 }
 // ---------------------------------------------------------------------------
@@ -68,30 +64,30 @@ aiPropertyTypeInfo ai_real_to_property_type_info(double) {
 //! @cond never
 
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE
-aiReturn aiMaterial::GetTexture( aiTextureType type,
-       unsigned int  index,
-       C_STRUCT aiString* path,
-       aiTextureMapping* mapping    /*= NULL*/,
-       unsigned int* uvindex        /*= NULL*/,
-       ai_real* blend               /*= NULL*/,
-       aiTextureOp* op              /*= NULL*/,
-       aiTextureMapMode* mapmode    /*= NULL*/) const {
+inline aiReturn aiMaterial::GetTexture( aiTextureType type,
+   unsigned int  index,
+   C_STRUCT aiString* path,
+   aiTextureMapping* mapping    /*= NULL*/,
+   unsigned int* uvindex        /*= NULL*/,
+   ai_real* blend               /*= NULL*/,
+   aiTextureOp* op              /*= NULL*/,
+   aiTextureMapMode* mapmode    /*= NULL*/) const
+{
     return ::aiGetMaterialTexture(this,type,index,path,mapping,uvindex,blend,op,mapmode);
 }
 
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE
-unsigned int aiMaterial::GetTextureCount(aiTextureType type) const {
+inline unsigned int aiMaterial::GetTextureCount(aiTextureType type) const
+{
     return ::aiGetMaterialTextureCount(this,type);
 }
 
 // ---------------------------------------------------------------------------
 template <typename Type>
-AI_FORCE_INLINE
-aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-        unsigned int idx, Type* pOut,
-        unsigned int* pMax) const {
+inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+    unsigned int idx, Type* pOut,
+    unsigned int* pMax) const
+{
     unsigned int iNum = pMax ? *pMax : 1;
 
     const aiMaterialProperty* prop;
@@ -118,9 +114,9 @@ aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
 
 // ---------------------------------------------------------------------------
 template <typename Type>
-AI_FORCE_INLINE
-aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-        unsigned int idx,Type& pOut) const {
+inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+    unsigned int idx,Type& pOut) const
+{
     const aiMaterialProperty* prop;
     const aiReturn ret = ::aiGetMaterialProperty(this,pKey,type,idx,
         (const aiMaterialProperty**)&prop);
@@ -140,56 +136,60 @@ aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
 }
 
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE
-aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-        unsigned int idx,ai_real* pOut,
-        unsigned int* pMax) const {
+inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+    unsigned int idx,ai_real* pOut,
+    unsigned int* pMax) const
+{
     return ::aiGetMaterialFloatArray(this,pKey,type,idx,pOut,pMax);
 }
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE
-aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-        unsigned int idx,int* pOut,
-        unsigned int* pMax) const {
+inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+    unsigned int idx,int* pOut,
+    unsigned int* pMax) const
+{
     return ::aiGetMaterialIntegerArray(this,pKey,type,idx,pOut,pMax);
 }
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE
-aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-        unsigned int idx,ai_real& pOut) const {
+inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+    unsigned int idx,ai_real& pOut) const
+{
     return aiGetMaterialFloat(this,pKey,type,idx,&pOut);
 }
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE
-aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-        unsigned int idx,int& pOut) const {
+inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+    unsigned int idx,int& pOut) const
+{
     return aiGetMaterialInteger(this,pKey,type,idx,&pOut);
 }
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE
-aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-        unsigned int idx,aiColor4D& pOut) const {
+inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+    unsigned int idx,aiColor4D& pOut) const
+{
     return aiGetMaterialColor(this,pKey,type,idx,&pOut);
 }
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-        unsigned int idx,aiColor3D& pOut) const {
+inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+    unsigned int idx,aiColor3D& pOut) const
+{
     aiColor4D c;
     const aiReturn ret = aiGetMaterialColor(this,pKey,type,idx,&c);
     pOut = aiColor3D(c.r,c.g,c.b);
     return ret;
 }
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-        unsigned int idx,aiString& pOut) const {
+inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+    unsigned int idx,aiString& pOut) const
+{
     return aiGetMaterialString(this,pKey,type,idx,&pOut);
 }
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-        unsigned int idx,aiUVTransform& pOut) const {
+inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+    unsigned int idx,aiUVTransform& pOut) const
+{
     return aiGetMaterialUVTransform(this,pKey,type,idx,&pOut);
 }
 
+
 // ---------------------------------------------------------------------------
 template<class TYPE>
 aiReturn aiMaterial::AddProperty (const TYPE* pInput,
@@ -204,83 +204,84 @@ aiReturn aiMaterial::AddProperty (const TYPE* pInput,
 }
 
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE aiReturn aiMaterial::AddProperty(const float* pInput,
-        const unsigned int pNumValues,
-        const char* pKey,
-        unsigned int type,
-        unsigned int index) {
+inline aiReturn aiMaterial::AddProperty(const float* pInput,
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
+{
     return AddBinaryProperty((const void*)pInput,
         pNumValues * sizeof(float),
         pKey,type,index,aiPTI_Float);
 }
 
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE
-aiReturn aiMaterial::AddProperty(const double* pInput,
-        const unsigned int pNumValues,
-        const char* pKey,
-        unsigned int type,
-        unsigned int index) {
+inline aiReturn aiMaterial::AddProperty(const double* pInput,
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
+{
     return AddBinaryProperty((const void*)pInput,
         pNumValues * sizeof(double),
         pKey,type,index,aiPTI_Double);
 }
 
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE
-aiReturn aiMaterial::AddProperty(const aiUVTransform* pInput,
-        const unsigned int pNumValues,
-        const char* pKey,
-        unsigned int type,
-        unsigned int index) {
+inline aiReturn aiMaterial::AddProperty(const aiUVTransform* pInput,
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
+{
     return AddBinaryProperty((const void*)pInput,
         pNumValues * sizeof(aiUVTransform),
         pKey,type,index,ai_real_to_property_type_info(pInput->mRotation));
 }
 
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE
-aiReturn aiMaterial::AddProperty(const aiColor4D* pInput,
-        const unsigned int pNumValues,
-        const char* pKey,
-        unsigned int type,
-        unsigned int index) {
+inline aiReturn aiMaterial::AddProperty(const aiColor4D* pInput,
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
+{
     return AddBinaryProperty((const void*)pInput,
         pNumValues * sizeof(aiColor4D),
         pKey,type,index,ai_real_to_property_type_info(pInput->a));
 }
 
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE
-aiReturn aiMaterial::AddProperty(const aiColor3D* pInput,
-        const unsigned int pNumValues,
-        const char* pKey,
-        unsigned int type,
-        unsigned int index) {
+inline aiReturn aiMaterial::AddProperty(const aiColor3D* pInput,
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
+{
     return AddBinaryProperty((const void*)pInput,
         pNumValues * sizeof(aiColor3D),
         pKey,type,index,ai_real_to_property_type_info(pInput->b));
 }
 
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE
-aiReturn aiMaterial::AddProperty(const aiVector3D* pInput,
-        const unsigned int pNumValues,
-        const char* pKey,
-        unsigned int type,
-        unsigned int index) {
+inline aiReturn aiMaterial::AddProperty(const aiVector3D* pInput,
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
+{
     return AddBinaryProperty((const void*)pInput,
         pNumValues * sizeof(aiVector3D),
         pKey,type,index,ai_real_to_property_type_info(pInput->x));
 }
 
 // ---------------------------------------------------------------------------
-AI_FORCE_INLINE
-aiReturn aiMaterial::AddProperty(const int* pInput,
-        const unsigned int pNumValues,
-        const char* pKey,
-        unsigned int type,
-        unsigned int index) {
+inline aiReturn aiMaterial::AddProperty(const int* pInput,
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
+{
     return AddBinaryProperty((const void*)pInput,
         pNumValues * sizeof(int),
         pKey,type,index,aiPTI_Integer);
@@ -295,12 +296,12 @@ aiReturn aiMaterial::AddProperty(const int* pInput,
 
 // ---------------------------------------------------------------------------
 template<>
-AI_FORCE_INLINE
-aiReturn aiMaterial::AddProperty<float>(const float* pInput,
-        const unsigned int pNumValues,
-        const char* pKey,
-        unsigned int type,
-        unsigned int index) {
+inline aiReturn aiMaterial::AddProperty<float>(const float* pInput,
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
+{
     return AddBinaryProperty((const void*)pInput,
         pNumValues * sizeof(float),
         pKey,type,index,aiPTI_Float);
@@ -308,12 +309,12 @@ aiReturn aiMaterial::AddProperty<float>(const float* pInput,
 
 // ---------------------------------------------------------------------------
 template<>
-AI_FORCE_INLINE
-aiReturn aiMaterial::AddProperty<double>(const double* pInput,
-        const unsigned int pNumValues,
-        const char* pKey,
-        unsigned int type,
-        unsigned int index) {
+inline aiReturn aiMaterial::AddProperty<double>(const double* pInput,
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
+{
     return AddBinaryProperty((const void*)pInput,
         pNumValues * sizeof(double),
         pKey,type,index,aiPTI_Double);
@@ -321,12 +322,12 @@ aiReturn aiMaterial::AddProperty<double>(const double* pInput,
 
 // ---------------------------------------------------------------------------
 template<>
-AI_FORCE_INLINE
-aiReturn aiMaterial::AddProperty<aiUVTransform>(const aiUVTransform* pInput,
-        const unsigned int pNumValues,
-        const char* pKey,
-        unsigned int type,
-        unsigned int index) {
+inline aiReturn aiMaterial::AddProperty<aiUVTransform>(const aiUVTransform* pInput,
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
+{
     return AddBinaryProperty((const void*)pInput,
         pNumValues * sizeof(aiUVTransform),
         pKey,type,index,aiPTI_Float);
@@ -334,12 +335,12 @@ aiReturn aiMaterial::AddProperty<aiUVTransform>(const aiUVTransform* pInput,
 
 // ---------------------------------------------------------------------------
 template<>
-AI_FORCE_INLINE
-aiReturn aiMaterial::AddProperty<aiColor4D>(const aiColor4D* pInput,
-        const unsigned int pNumValues,
-        const char* pKey,
-        unsigned int type,
-        unsigned int index) {
+inline aiReturn aiMaterial::AddProperty<aiColor4D>(const aiColor4D* pInput,
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
+{
     return AddBinaryProperty((const void*)pInput,
         pNumValues * sizeof(aiColor4D),
         pKey,type,index,aiPTI_Float);
@@ -347,12 +348,12 @@ aiReturn aiMaterial::AddProperty<aiColor4D>(const aiColor4D* pInput,
 
 // ---------------------------------------------------------------------------
 template<>
-AI_FORCE_INLINE
-aiReturn aiMaterial::AddProperty<aiColor3D>(const aiColor3D* pInput,
-        const unsigned int pNumValues,
-        const char* pKey,
-        unsigned int type,
-        unsigned int index) {
+inline aiReturn aiMaterial::AddProperty<aiColor3D>(const aiColor3D* pInput,
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
+{
     return AddBinaryProperty((const void*)pInput,
         pNumValues * sizeof(aiColor3D),
         pKey,type,index,aiPTI_Float);
@@ -360,12 +361,12 @@ aiReturn aiMaterial::AddProperty<aiColor3D>(const aiColor3D* pInput,
 
 // ---------------------------------------------------------------------------
 template<>
-AI_FORCE_INLINE
-aiReturn aiMaterial::AddProperty<aiVector3D>(const aiVector3D* pInput,
-        const unsigned int pNumValues,
-        const char* pKey,
-        unsigned int type,
-        unsigned int index) {
+inline aiReturn aiMaterial::AddProperty<aiVector3D>(const aiVector3D* pInput,
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
+{
     return AddBinaryProperty((const void*)pInput,
         pNumValues * sizeof(aiVector3D),
         pKey,type,index,aiPTI_Float);
@@ -373,12 +374,12 @@ aiReturn aiMaterial::AddProperty<aiVector3D>(const aiVector3D* pInput,
 
 // ---------------------------------------------------------------------------
 template<>
-AI_FORCE_INLINE
-aiReturn aiMaterial::AddProperty<int>(const int* pInput,
-        const unsigned int pNumValues,
-        const char* pKey,
-        unsigned int type,
-        unsigned int index) {
+inline aiReturn aiMaterial::AddProperty<int>(const int* pInput,
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
+{
     return AddBinaryProperty((const void*)pInput,
         pNumValues * sizeof(int),
         pKey,type,index,aiPTI_Integer);
diff --git a/Engine/lib/assimp/include/assimp/matrix3x3.h b/Engine/lib/assimp/include/assimp/matrix3x3.h
index 9f11b6b83..22b69561f 100644
--- a/Engine/lib/assimp/include/assimp/matrix3x3.h
+++ b/Engine/lib/assimp/include/assimp/matrix3x3.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -48,11 +48,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_MATRIX3X3_H_INC
 #define AI_MATRIX3X3_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
-#include <assimp/defs.h>
+#include "defs.h"
 
 #ifdef __cplusplus
 
@@ -69,8 +65,10 @@ template <typename T> class aiVector2t;
  *  defined thereby.
  */
 template <typename TReal>
-class aiMatrix3x3t {
+class aiMatrix3x3t
+{
 public:
+
     aiMatrix3x3t() AI_NO_EXCEPT :
         a1(static_cast<TReal>(1.0f)), a2(), a3(),
         b1(), b2(static_cast<TReal>(1.0f)), b3(),
@@ -84,6 +82,8 @@ public:
         c1(_c1), c2(_c2), c3(_c3)
     {}
 
+public:
+
     // matrix multiplication.
     aiMatrix3x3t& operator *= (const aiMatrix3x3t& m);
     aiMatrix3x3t  operator  * (const aiMatrix3x3t& m) const;
@@ -93,14 +93,16 @@ public:
     const TReal* operator[] (unsigned int p_iIndex) const;
 
     // comparison operators
-    bool operator== (const aiMatrix3x3t<TReal>& m) const;
-    bool operator!= (const aiMatrix3x3t<TReal>& m) const;
+    bool operator== (const aiMatrix4x4t<TReal>& m) const;
+    bool operator!= (const aiMatrix4x4t<TReal>& m) const;
 
-    bool Equal(const aiMatrix3x3t<TReal>& m, TReal epsilon = 1e-6) const;
+    bool Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon = 1e-6) const;
 
     template <typename TOther>
     operator aiMatrix3x3t<TOther> () const;
 
+public:
+
     // -------------------------------------------------------------------
     /** @brief Construction from a 4x4 matrix. The remaining parts
      *  of the matrix are ignored.
@@ -120,6 +122,7 @@ public:
     aiMatrix3x3t& Inverse();
     TReal Determinant() const;
 
+public:
     // -------------------------------------------------------------------
     /** @brief Returns a rotation matrix for a rotation around z
      *  @param a Rotation angle, in radians
diff --git a/Engine/lib/assimp/include/assimp/matrix3x3.inl b/Engine/lib/assimp/include/assimp/matrix3x3.inl
index 0b9565604..d9d45a3e9 100644
--- a/Engine/lib/assimp/include/assimp/matrix3x3.inl
+++ b/Engine/lib/assimp/include/assimp/matrix3x3.inl
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -48,14 +48,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_MATRIX3X3_INL_INC
 #define AI_MATRIX3X3_INL_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #ifdef __cplusplus
-#include <assimp/matrix3x3.h>
-#include <assimp/matrix4x4.h>
+#include "matrix3x3.h"
 
+#include "matrix4x4.h"
 #include <algorithm>
 #include <cmath>
 #include <limits>
@@ -63,8 +59,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // ------------------------------------------------------------------------------------------------
 // Construction from a 4x4 matrix. The remaining parts of the matrix are ignored.
 template <typename TReal>
-AI_FORCE_INLINE
-aiMatrix3x3t<TReal>::aiMatrix3x3t( const aiMatrix4x4t<TReal>& pMatrix) {
+inline aiMatrix3x3t<TReal>::aiMatrix3x3t( const aiMatrix4x4t<TReal>& pMatrix)
+{
     a1 = pMatrix.a1; a2 = pMatrix.a2; a3 = pMatrix.a3;
     b1 = pMatrix.b1; b2 = pMatrix.b2; b3 = pMatrix.b3;
     c1 = pMatrix.c1; c2 = pMatrix.c2; c3 = pMatrix.c3;
@@ -72,8 +68,8 @@ aiMatrix3x3t<TReal>::aiMatrix3x3t( const aiMatrix4x4t<TReal>& pMatrix) {
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::operator *= (const aiMatrix3x3t<TReal>& m) {
+inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::operator *= (const aiMatrix3x3t<TReal>& m)
+{
     *this = aiMatrix3x3t<TReal>(m.a1 * a1 + m.b1 * a2 + m.c1 * a3,
         m.a2 * a1 + m.b2 * a2 + m.c2 * a3,
         m.a3 * a1 + m.b3 * a2 + m.c3 * a3,
@@ -89,7 +85,8 @@ aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::operator *= (const aiMatrix3x3t<TReal>
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 template <typename TOther>
-aiMatrix3x3t<TReal>::operator aiMatrix3x3t<TOther> () const {
+aiMatrix3x3t<TReal>::operator aiMatrix3x3t<TOther> () const
+{
     return aiMatrix3x3t<TOther>(static_cast<TOther>(a1),static_cast<TOther>(a2),static_cast<TOther>(a3),
         static_cast<TOther>(b1),static_cast<TOther>(b2),static_cast<TOther>(b3),
         static_cast<TOther>(c1),static_cast<TOther>(c2),static_cast<TOther>(c3));
@@ -97,8 +94,8 @@ aiMatrix3x3t<TReal>::operator aiMatrix3x3t<TOther> () const {
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiMatrix3x3t<TReal> aiMatrix3x3t<TReal>::operator* (const aiMatrix3x3t<TReal>& m) const {
+inline aiMatrix3x3t<TReal> aiMatrix3x3t<TReal>::operator* (const aiMatrix3x3t<TReal>& m) const
+{
     aiMatrix3x3t<TReal> temp( *this);
     temp *= m;
     return temp;
@@ -106,8 +103,7 @@ aiMatrix3x3t<TReal> aiMatrix3x3t<TReal>::operator* (const aiMatrix3x3t<TReal>& m
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex) {
+inline TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex) {
     switch ( p_iIndex ) {
         case 0:
             return &a1;
@@ -123,8 +119,7 @@ TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex) {
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-const TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex) const {
+inline const TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex) const {
     switch ( p_iIndex ) {
         case 0:
             return &a1;
@@ -140,8 +135,8 @@ const TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex) const {
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-bool aiMatrix3x3t<TReal>::operator== (const aiMatrix3x3t<TReal>& m) const {
+inline bool aiMatrix3x3t<TReal>::operator== (const aiMatrix4x4t<TReal>& m) const
+{
     return a1 == m.a1 && a2 == m.a2 && a3 == m.a3 &&
            b1 == m.b1 && b2 == m.b2 && b3 == m.b3 &&
            c1 == m.c1 && c2 == m.c2 && c3 == m.c3;
@@ -149,15 +144,14 @@ bool aiMatrix3x3t<TReal>::operator== (const aiMatrix3x3t<TReal>& m) const {
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-bool aiMatrix3x3t<TReal>::operator!= (const aiMatrix3x3t<TReal>& m) const {
+inline bool aiMatrix3x3t<TReal>::operator!= (const aiMatrix4x4t<TReal>& m) const
+{
     return !(*this == m);
 }
 
 // ---------------------------------------------------------------------------
 template<typename TReal>
-AI_FORCE_INLINE
-bool aiMatrix3x3t<TReal>::Equal(const aiMatrix3x3t<TReal>& m, TReal epsilon) const {
+inline bool aiMatrix3x3t<TReal>::Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon) const {
     return
         std::abs(a1 - m.a1) <= epsilon &&
         std::abs(a2 - m.a2) <= epsilon &&
@@ -172,8 +166,8 @@ bool aiMatrix3x3t<TReal>::Equal(const aiMatrix3x3t<TReal>& m, TReal epsilon) con
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Transpose() {
+inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Transpose()
+{
     // (TReal&) don't remove, GCC complains cause of packed fields
     std::swap( (TReal&)a2, (TReal&)b1);
     std::swap( (TReal&)a3, (TReal&)c1);
@@ -183,15 +177,15 @@ aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Transpose() {
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-TReal aiMatrix3x3t<TReal>::Determinant() const {
+inline TReal aiMatrix3x3t<TReal>::Determinant() const
+{
     return a1*b2*c3 - a1*b3*c2 + a2*b3*c1 - a2*b1*c3 + a3*b1*c2 - a3*b2*c1;
 }
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Inverse() {
+inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Inverse()
+{
     // Compute the reciprocal determinant
     TReal det = Determinant();
     if(det == static_cast<TReal>(0.0))
@@ -225,8 +219,8 @@ aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Inverse() {
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::RotationZ(TReal a, aiMatrix3x3t<TReal>& out) {
+inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::RotationZ(TReal a, aiMatrix3x3t<TReal>& out)
+{
     out.a1 = out.b2 = std::cos(a);
     out.b1 = std::sin(a);
     out.a2 = - out.b1;
@@ -240,8 +234,8 @@ aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::RotationZ(TReal a, aiMatrix3x3t<TReal>
 // ------------------------------------------------------------------------------------------------
 // Returns a rotation matrix for a rotation around an arbitrary axis.
 template <typename TReal>
-AI_FORCE_INLINE
-aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Rotation( TReal a, const aiVector3t<TReal>& axis, aiMatrix3x3t<TReal>& out) {
+inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Rotation( TReal a, const aiVector3t<TReal>& axis, aiMatrix3x3t<TReal>& out)
+{
   TReal c = std::cos( a), s = std::sin( a), t = 1 - c;
   TReal x = axis.x, y = axis.y, z = axis.z;
 
@@ -255,8 +249,8 @@ aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Rotation( TReal a, const aiVector3t<TR
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Translation( const aiVector2t<TReal>& v, aiMatrix3x3t<TReal>& out) {
+inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Translation( const aiVector2t<TReal>& v, aiMatrix3x3t<TReal>& out)
+{
     out = aiMatrix3x3t<TReal>();
     out.a3 = v.x;
     out.b3 = v.y;
@@ -274,8 +268,9 @@ aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Translation( const aiVector2t<TReal>&
  */
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::FromToMatrix(const aiVector3t<TReal>& from,
-        const aiVector3t<TReal>& to, aiMatrix3x3t<TReal>& mtx) {
+inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::FromToMatrix(const aiVector3t<TReal>& from,
+    const aiVector3t<TReal>& to, aiMatrix3x3t<TReal>& mtx)
+{
     const TReal e = from * to;
     const TReal f = (e < 0)? -e:e;
 
@@ -357,5 +352,6 @@ AI_FORCE_INLINE aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::FromToMatrix(const aiV
     return mtx;
 }
 
+
 #endif // __cplusplus
 #endif // AI_MATRIX3X3_INL_INC
diff --git a/Engine/lib/assimp/include/assimp/matrix4x4.h b/Engine/lib/assimp/include/assimp/matrix4x4.h
index 456d285e6..046bb535f 100644
--- a/Engine/lib/assimp/include/assimp/matrix4x4.h
+++ b/Engine/lib/assimp/include/assimp/matrix4x4.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -47,12 +47,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_MATRIX4X4_H_INC
 #define AI_MATRIX4X4_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
-#include <assimp/vector3.h>
-#include <assimp/defs.h>
+#include "vector3.h"
+#include "defs.h"
 
 #ifdef __cplusplus
 
@@ -70,7 +66,8 @@ template<typename TReal> class aiQuaterniont;
  *  defined thereby.
  */
 template<typename TReal>
-class aiMatrix4x4t {
+class aiMatrix4x4t
+{
 public:
 
     /** set to identity */
@@ -94,6 +91,8 @@ public:
     aiMatrix4x4t(const aiVector3t<TReal>& scaling, const aiQuaterniont<TReal>& rotation,
         const aiVector3t<TReal>& position);
 
+public:
+
     // array access operators
 	/** @fn TReal* operator[] (unsigned int p_iIndex)
 	 *  @param [in] p_iIndex - index of the row.
@@ -121,6 +120,8 @@ public:
     template <typename TOther>
     operator aiMatrix4x4t<TOther> () const;
 
+public:
+
     // -------------------------------------------------------------------
     /** @brief Transpose the matrix */
     aiMatrix4x4t& Transpose();
@@ -181,6 +182,7 @@ public:
     void DecomposeNoScaling (aiQuaterniont<TReal>& rotation,
         aiVector3t<TReal>& position) const;
 
+
     // -------------------------------------------------------------------
     /** @brief Creates a trafo matrix from a set of euler angles
      *  @param x Rotation angle for the x-axis, in radians
@@ -190,6 +192,7 @@ public:
     aiMatrix4x4t& FromEulerAnglesXYZ(TReal x, TReal y, TReal z);
     aiMatrix4x4t& FromEulerAnglesXYZ(const aiVector3t<TReal>& blubb);
 
+public:
     // -------------------------------------------------------------------
     /** @brief Returns a rotation matrix for a rotation around the x axis
      *  @param a Rotation angle, in radians
@@ -253,6 +256,7 @@ public:
     static aiMatrix4x4t& FromToMatrix(const aiVector3t<TReal>& from,
             const aiVector3t<TReal>& to, aiMatrix4x4t& out);
 
+public:
     TReal a1, a2, a3, a4;
     TReal b1, b2, b3, b4;
     TReal c1, c2, c3, c4;
diff --git a/Engine/lib/assimp/include/assimp/matrix4x4.inl b/Engine/lib/assimp/include/assimp/matrix4x4.inl
index e8a3c5305..19e684917 100644
--- a/Engine/lib/assimp/include/assimp/matrix4x4.inl
+++ b/Engine/lib/assimp/include/assimp/matrix4x4.inl
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
@@ -60,11 +60,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
 aiMatrix4x4t<TReal>::aiMatrix4x4t() AI_NO_EXCEPT :
-        a1(1.0f), a2(), a3(), a4(),
-        b1(), b2(1.0f), b3(), b4(),
-        c1(), c2(), c3(1.0f), c4(),
-        d1(), d2(), d3(), d4(1.0f) {
-    // empty
+    a1(1.0f), a2(), a3(), a4(),
+    b1(), b2(1.0f), b3(), b4(),
+    c1(), c2(), c3(1.0f), c4(),
+    d1(), d2(), d3(), d4(1.0f)
+{
+
 }
 
 // ----------------------------------------------------------------------------------------
@@ -73,17 +74,19 @@ aiMatrix4x4t<TReal>::aiMatrix4x4t (TReal _a1, TReal _a2, TReal _a3, TReal _a4,
               TReal _b1, TReal _b2, TReal _b3, TReal _b4,
               TReal _c1, TReal _c2, TReal _c3, TReal _c4,
               TReal _d1, TReal _d2, TReal _d3, TReal _d4) :
-        a1(_a1), a2(_a2), a3(_a3), a4(_a4),
-        b1(_b1), b2(_b2), b3(_b3), b4(_b4),
-        c1(_c1), c2(_c2), c3(_c3), c4(_c4),
-        d1(_d1), d2(_d2), d3(_d3), d4(_d4) {
-    // empty
+    a1(_a1), a2(_a2), a3(_a3), a4(_a4),
+    b1(_b1), b2(_b2), b3(_b3), b4(_b4),
+    c1(_c1), c2(_c2), c3(_c3), c4(_c4),
+    d1(_d1), d2(_d2), d3(_d3), d4(_d4)
+{
+
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 template <typename TOther>
-aiMatrix4x4t<TReal>::operator aiMatrix4x4t<TOther> () const {
+aiMatrix4x4t<TReal>::operator aiMatrix4x4t<TOther> () const
+{
     return aiMatrix4x4t<TOther>(static_cast<TOther>(a1),static_cast<TOther>(a2),static_cast<TOther>(a3),static_cast<TOther>(a4),
         static_cast<TOther>(b1),static_cast<TOther>(b2),static_cast<TOther>(b3),static_cast<TOther>(b4),
         static_cast<TOther>(c1),static_cast<TOther>(c2),static_cast<TOther>(c3),static_cast<TOther>(c4),
@@ -93,8 +96,8 @@ aiMatrix4x4t<TReal>::operator aiMatrix4x4t<TOther> () const {
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiMatrix4x4t<TReal>::aiMatrix4x4t (const aiMatrix3x3t<TReal>& m) {
+inline aiMatrix4x4t<TReal>::aiMatrix4x4t (const aiMatrix3x3t<TReal>& m)
+{
     a1 = m.a1; a2 = m.a2; a3 = m.a3; a4 = static_cast<TReal>(0.0);
     b1 = m.b1; b2 = m.b2; b3 = m.b3; b4 = static_cast<TReal>(0.0);
     c1 = m.c1; c2 = m.c2; c3 = m.c3; c4 = static_cast<TReal>(0.0);
@@ -103,8 +106,8 @@ aiMatrix4x4t<TReal>::aiMatrix4x4t (const aiMatrix3x3t<TReal>& m) {
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiMatrix4x4t<TReal>::aiMatrix4x4t (const aiVector3t<TReal>& scaling, const aiQuaterniont<TReal>& rotation, const aiVector3t<TReal>& position) {
+inline aiMatrix4x4t<TReal>::aiMatrix4x4t (const aiVector3t<TReal>& scaling, const aiQuaterniont<TReal>& rotation, const aiVector3t<TReal>& position)
+{
     // build a 3x3 rotation matrix
     aiMatrix3x3t<TReal> m = rotation.GetMatrix();
 
@@ -131,8 +134,8 @@ aiMatrix4x4t<TReal>::aiMatrix4x4t (const aiVector3t<TReal>& scaling, const aiQua
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::operator *= (const aiMatrix4x4t<TReal>& m) {
+inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::operator *= (const aiMatrix4x4t<TReal>& m)
+{
     *this = aiMatrix4x4t<TReal>(
         m.a1 * a1 + m.b1 * a2 + m.c1 * a3 + m.d1 * a4,
         m.a2 * a1 + m.b2 * a2 + m.c2 * a3 + m.d2 * a4,
@@ -155,7 +158,8 @@ aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::operator *= (const aiMatrix4x4t<TReal>
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator* (const TReal& aFloat) const {
+inline aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator* (const TReal& aFloat) const
+{
     aiMatrix4x4t<TReal> temp(
         a1 * aFloat,
         a2 * aFloat,
@@ -178,8 +182,8 @@ AI_FORCE_INLINE aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator* (const TReal&
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator+ (const aiMatrix4x4t<TReal>& m) const {
+inline aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator+ (const aiMatrix4x4t<TReal>& m) const
+{
     aiMatrix4x4t<TReal> temp(
         m.a1 + a1,
         m.a2 + a2,
@@ -202,16 +206,18 @@ aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator+ (const aiMatrix4x4t<TReal>& m
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator* (const aiMatrix4x4t<TReal>& m) const {
+inline aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator* (const aiMatrix4x4t<TReal>& m) const
+{
     aiMatrix4x4t<TReal> temp( *this);
     temp *= m;
     return temp;
 }
 
+
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Transpose() {
+inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Transpose()
+{
     // (TReal&) don't remove, GCC complains cause of packed fields
     std::swap( (TReal&)b1, (TReal&)a2);
     std::swap( (TReal&)c1, (TReal&)a3);
@@ -222,10 +228,11 @@ AI_FORCE_INLINE aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Transpose() {
     return *this;
 }
 
+
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-TReal aiMatrix4x4t<TReal>::Determinant() const {
+inline TReal aiMatrix4x4t<TReal>::Determinant() const
+{
     return a1*b2*c3*d4 - a1*b2*c4*d3 + a1*b3*c4*d2 - a1*b3*c2*d4
         + a1*b4*c2*d3 - a1*b4*c3*d2 - a2*b3*c4*d1 + a2*b3*c1*d4
         - a2*b4*c1*d3 + a2*b4*c3*d1 - a2*b1*c3*d4 + a2*b1*c4*d3
@@ -236,8 +243,8 @@ TReal aiMatrix4x4t<TReal>::Determinant() const {
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Inverse() {
+inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Inverse()
+{
     // Compute the reciprocal determinant
     const TReal det = Determinant();
     if(det == static_cast<TReal>(0.0))
@@ -281,10 +288,9 @@ aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Inverse() {
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-TReal* aiMatrix4x4t<TReal>::operator[](unsigned int p_iIndex) {
+inline TReal* aiMatrix4x4t<TReal>::operator[](unsigned int p_iIndex) {
     if (p_iIndex > 3) {
-        return nullptr;
+        return NULL;
     }
     switch ( p_iIndex ) {
         case 0:
@@ -303,10 +309,9 @@ TReal* aiMatrix4x4t<TReal>::operator[](unsigned int p_iIndex) {
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-const TReal* aiMatrix4x4t<TReal>::operator[](unsigned int p_iIndex) const {
+inline const TReal* aiMatrix4x4t<TReal>::operator[](unsigned int p_iIndex) const {
     if (p_iIndex > 3) {
-        return nullptr;
+        return NULL;
     }
 
     switch ( p_iIndex ) {
@@ -326,8 +331,8 @@ const TReal* aiMatrix4x4t<TReal>::operator[](unsigned int p_iIndex) const {
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-bool aiMatrix4x4t<TReal>::operator== (const aiMatrix4x4t<TReal>& m) const {
+inline bool aiMatrix4x4t<TReal>::operator== (const aiMatrix4x4t<TReal>& m) const
+{
     return (a1 == m.a1 && a2 == m.a2 && a3 == m.a3 && a4 == m.a4 &&
             b1 == m.b1 && b2 == m.b2 && b3 == m.b3 && b4 == m.b4 &&
             c1 == m.c1 && c2 == m.c2 && c3 == m.c3 && c4 == m.c4 &&
@@ -336,15 +341,14 @@ bool aiMatrix4x4t<TReal>::operator== (const aiMatrix4x4t<TReal>& m) const {
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-bool aiMatrix4x4t<TReal>::operator!= (const aiMatrix4x4t<TReal>& m) const {
+inline bool aiMatrix4x4t<TReal>::operator!= (const aiMatrix4x4t<TReal>& m) const
+{
     return !(*this == m);
 }
 
 // ---------------------------------------------------------------------------
 template<typename TReal>
-AI_FORCE_INLINE
-bool aiMatrix4x4t<TReal>::Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon) const {
+inline bool aiMatrix4x4t<TReal>::Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon) const {
     return
         std::abs(a1 - m.a1) <= epsilon &&
         std::abs(a2 - m.a2) <= epsilon &&
@@ -396,10 +400,13 @@ bool aiMatrix4x4t<TReal>::Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon) con
 	\
 	do {} while(false)
 
+
+
+
 template <typename TReal>
-AI_FORCE_INLINE
-void aiMatrix4x4t<TReal>::Decompose (aiVector3t<TReal>& pScaling, aiQuaterniont<TReal>& pRotation,
-        aiVector3t<TReal>& pPosition) const {
+inline void aiMatrix4x4t<TReal>::Decompose (aiVector3t<TReal>& pScaling, aiQuaterniont<TReal>& pRotation,
+    aiVector3t<TReal>& pPosition) const
+{
 	ASSIMP_MATRIX4_4_DECOMPOSE_PART;
 
     // build a 3x3 rotation matrix
@@ -412,7 +419,7 @@ void aiMatrix4x4t<TReal>::Decompose (aiVector3t<TReal>& pScaling, aiQuaterniont<
 }
 
 template <typename TReal>
-AI_FORCE_INLINE
+inline
 void aiMatrix4x4t<TReal>::Decompose(aiVector3t<TReal>& pScaling, aiVector3t<TReal>& pRotation, aiVector3t<TReal>& pPosition) const {
 	ASSIMP_MATRIX4_4_DECOMPOSE_PART;
 
@@ -467,10 +474,10 @@ void aiMatrix4x4t<TReal>::Decompose(aiVector3t<TReal>& pScaling, aiVector3t<TRea
 #undef ASSIMP_MATRIX4_4_DECOMPOSE_PART
 
 template <typename TReal>
-AI_FORCE_INLINE
-void aiMatrix4x4t<TReal>::Decompose(aiVector3t<TReal>& pScaling, aiVector3t<TReal>& pRotationAxis, TReal& pRotationAngle,
-											aiVector3t<TReal>& pPosition) const {
-    aiQuaterniont<TReal> pRotation;
+inline void aiMatrix4x4t<TReal>::Decompose(aiVector3t<TReal>& pScaling, aiVector3t<TReal>& pRotationAxis, TReal& pRotationAngle,
+											aiVector3t<TReal>& pPosition) const
+{
+aiQuaterniont<TReal> pRotation;
 
 	Decompose(pScaling, pRotation, pPosition);
 	pRotation.Normalize();
@@ -492,9 +499,9 @@ void aiMatrix4x4t<TReal>::Decompose(aiVector3t<TReal>& pScaling, aiVector3t<TRea
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-void aiMatrix4x4t<TReal>::DecomposeNoScaling (aiQuaterniont<TReal>& rotation,
-        aiVector3t<TReal>& position) const {
+inline void aiMatrix4x4t<TReal>::DecomposeNoScaling (aiQuaterniont<TReal>& rotation,
+    aiVector3t<TReal>& position) const
+{
     const aiMatrix4x4t<TReal>& _this = *this;
 
     // extract translation
@@ -508,15 +515,15 @@ void aiMatrix4x4t<TReal>::DecomposeNoScaling (aiQuaterniont<TReal>& rotation,
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromEulerAnglesXYZ(const aiVector3t<TReal>& blubb) {
+inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromEulerAnglesXYZ(const aiVector3t<TReal>& blubb)
+{
     return FromEulerAnglesXYZ(blubb.x,blubb.y,blubb.z);
 }
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromEulerAnglesXYZ(TReal x, TReal y, TReal z) {
+inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromEulerAnglesXYZ(TReal x, TReal y, TReal z)
+{
     aiMatrix4x4t<TReal>& _this = *this;
 
     TReal cx = std::cos(x);
@@ -544,8 +551,8 @@ aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromEulerAnglesXYZ(TReal x, TReal y, T
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-bool aiMatrix4x4t<TReal>::IsIdentity() const {
+inline bool aiMatrix4x4t<TReal>::IsIdentity() const
+{
     // Use a small epsilon to solve floating-point inaccuracies
     const static TReal epsilon = 10e-3f;
 
@@ -569,8 +576,8 @@ bool aiMatrix4x4t<TReal>::IsIdentity() const {
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationX(TReal a, aiMatrix4x4t<TReal>& out) {
+inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationX(TReal a, aiMatrix4x4t<TReal>& out)
+{
     /*
          |  1  0       0       0 |
      M = |  0  cos(A) -sin(A)  0 |
@@ -584,8 +591,8 @@ aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationX(TReal a, aiMatrix4x4t<TReal>
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationY(TReal a, aiMatrix4x4t<TReal>& out) {
+inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationY(TReal a, aiMatrix4x4t<TReal>& out)
+{
     /*
          |  cos(A)  0   sin(A)  0 |
      M = |  0       1   0       0 |
@@ -600,8 +607,8 @@ aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationY(TReal a, aiMatrix4x4t<TReal>
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationZ(TReal a, aiMatrix4x4t<TReal>& out) {
+inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationZ(TReal a, aiMatrix4x4t<TReal>& out)
+{
     /*
          |  cos(A)  -sin(A)   0   0 |
      M = |  sin(A)   cos(A)   0   0 |
@@ -616,25 +623,26 @@ aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationZ(TReal a, aiMatrix4x4t<TReal>
 // ----------------------------------------------------------------------------------------
 // Returns a rotation matrix for a rotation around an arbitrary axis.
 template <typename TReal>
-AI_FORCE_INLINE
-aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Rotation( TReal a, const aiVector3t<TReal>& axis, aiMatrix4x4t<TReal>& out) {
-    TReal c = std::cos( a), s = std::sin( a), t = 1 - c;
-    TReal x = axis.x, y = axis.y, z = axis.z;
+inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Rotation( TReal a, const aiVector3t<TReal>& axis, aiMatrix4x4t<TReal>& out)
+{
+  TReal c = std::cos( a), s = std::sin( a), t = 1 - c;
+  TReal x = axis.x, y = axis.y, z = axis.z;
 
-    // Many thanks to MathWorld and Wikipedia
-    out.a1 = t*x*x + c;   out.a2 = t*x*y - s*z; out.a3 = t*x*z + s*y;
-    out.b1 = t*x*y + s*z; out.b2 = t*y*y + c;   out.b3 = t*y*z - s*x;
-    out.c1 = t*x*z - s*y; out.c2 = t*y*z + s*x; out.c3 = t*z*z + c;
-    out.a4 = out.b4 = out.c4 = static_cast<TReal>(0.0);
-    out.d1 = out.d2 = out.d3 = static_cast<TReal>(0.0);
-    out.d4 = static_cast<TReal>(1.0);
+  // Many thanks to MathWorld and Wikipedia
+  out.a1 = t*x*x + c;   out.a2 = t*x*y - s*z; out.a3 = t*x*z + s*y;
+  out.b1 = t*x*y + s*z; out.b2 = t*y*y + c;   out.b3 = t*y*z - s*x;
+  out.c1 = t*x*z - s*y; out.c2 = t*y*z + s*x; out.c3 = t*z*z + c;
+  out.a4 = out.b4 = out.c4 = static_cast<TReal>(0.0);
+  out.d1 = out.d2 = out.d3 = static_cast<TReal>(0.0);
+  out.d4 = static_cast<TReal>(1.0);
 
-    return out;
+  return out;
 }
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Translation( const aiVector3t<TReal>& v, aiMatrix4x4t<TReal>& out) {
+inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Translation( const aiVector3t<TReal>& v, aiMatrix4x4t<TReal>& out)
+{
     out = aiMatrix4x4t<TReal>();
     out.a4 = v.x;
     out.b4 = v.y;
@@ -644,8 +652,8 @@ AI_FORCE_INLINE aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Translation( const aiV
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Scaling( const aiVector3t<TReal>& v, aiMatrix4x4t<TReal>& out) {
+inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Scaling( const aiVector3t<TReal>& v, aiMatrix4x4t<TReal>& out)
+{
     out = aiMatrix4x4t<TReal>();
     out.a1 = v.x;
     out.b2 = v.y;
@@ -664,9 +672,9 @@ aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Scaling( const aiVector3t<TReal>& v, a
  */
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromToMatrix(const aiVector3t<TReal>& from,
-        const aiVector3t<TReal>& to, aiMatrix4x4t<TReal>& mtx) {
+inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromToMatrix(const aiVector3t<TReal>& from,
+    const aiVector3t<TReal>& to, aiMatrix4x4t<TReal>& mtx)
+{
     aiMatrix3x3t<TReal> m3;
     aiMatrix3x3t<TReal>::FromToMatrix(from,to,m3);
     mtx = aiMatrix4x4t<TReal>(m3);
diff --git a/Engine/lib/assimp/include/assimp/mesh.h b/Engine/lib/assimp/include/assimp/mesh.h
index 8fd8c7f87..f1628f1f5 100644
--- a/Engine/lib/assimp/include/assimp/mesh.h
+++ b/Engine/lib/assimp/include/assimp/mesh.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -48,10 +48,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_MESH_H_INC
 #define AI_MESH_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <assimp/types.h>
 #include <assimp/aabb.h>
 
@@ -252,9 +248,6 @@ struct aiVertexWeight {
 };
 
 
-// Forward declare aiNode (pointer use only)
-struct aiNode;
-
 // ---------------------------------------------------------------------------
 /** @brief A single bone of a mesh.
  *
@@ -271,16 +264,6 @@ struct aiBone {
     //! The maximum value for this member is #AI_MAX_BONE_WEIGHTS.
     unsigned int mNumWeights;
 
-#ifndef ASSIMP_BUILD_NO_ARMATUREPOPULATE_PROCESS
-    // The bone armature node - used for skeleton conversion
-    // you must enable aiProcess_PopulateArmatureData to populate this
-    C_STRUCT aiNode* mArmature;
-
-    // The bone node in the scene - used for skeleton conversion
-    // you must enable aiProcess_PopulateArmatureData to populate this
-    C_STRUCT aiNode* mNode;
-
-#endif
     //! The influence weights of this bone, by vertex index.
     C_STRUCT aiVertexWeight* mWeights;
 
@@ -435,11 +418,11 @@ struct aiAnimMesh
     /**Anim Mesh name */
     C_STRUCT aiString mName;
 
-    /** Replacement for aiMesh::mVertices. If this array is non-nullptr,
+    /** Replacement for aiMesh::mVertices. If this array is non-NULL,
      *  it *must* contain mNumVertices entries. The corresponding
-     *  array in the host mesh must be non-nullptr as well - animation
+     *  array in the host mesh must be non-NULL as well - animation
      *  meshes may neither add or nor remove vertex components (if
-     *  a replacement array is nullptr and the corresponding source
+     *  a replacement array is NULL and the corresponding source
      *  array is not, the source data is taken instead)*/
     C_STRUCT aiVector3D* mVertices;
 
@@ -613,7 +596,7 @@ struct aiMesh
     C_STRUCT aiVector3D* mVertices;
 
     /** Vertex normals.
-    * The array contains normalized vectors, nullptr if not present.
+    * The array contains normalized vectors, NULL if not present.
     * The array is mNumVertices in size. Normals are undefined for
     * point and line primitives. A mesh consisting of points and
     * lines only may not have normal vectors. Meshes with mixed
@@ -636,7 +619,7 @@ struct aiMesh
 
     /** Vertex tangents.
     * The tangent of a vertex points in the direction of the positive
-    * X texture axis. The array contains normalized vectors, nullptr if
+    * X texture axis. The array contains normalized vectors, NULL if
     * not present. The array is mNumVertices in size. A mesh consisting
     * of points and lines only may not have normal vectors. Meshes with
     * mixed primitive types (i.e. lines and triangles) may have
@@ -650,7 +633,7 @@ struct aiMesh
 
     /** Vertex bitangents.
     * The bitangent of a vertex points in the direction of the positive
-    * Y texture axis. The array contains normalized vectors, nullptr if not
+    * Y texture axis. The array contains normalized vectors, NULL if not
     * present. The array is mNumVertices in size.
     * @note If the mesh contains tangents, it automatically also contains
     * bitangents.
@@ -659,14 +642,14 @@ struct aiMesh
 
     /** Vertex color sets.
     * A mesh may contain 0 to #AI_MAX_NUMBER_OF_COLOR_SETS vertex
-    * colors per vertex. nullptr if not present. Each array is
+    * colors per vertex. NULL if not present. Each array is
     * mNumVertices in size if present.
     */
     C_STRUCT aiColor4D* mColors[AI_MAX_NUMBER_OF_COLOR_SETS];
 
     /** Vertex texture coords, also known as UV channels.
     * A mesh may contain 0 to AI_MAX_NUMBER_OF_TEXTURECOORDS per
-    * vertex. nullptr if not present. The array is mNumVertices in size.
+    * vertex. NULL if not present. The array is mNumVertices in size.
     */
     C_STRUCT aiVector3D* mTextureCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS];
 
@@ -688,7 +671,7 @@ struct aiMesh
     C_STRUCT aiFace* mFaces;
 
     /** The number of bones this mesh contains.
-    * Can be 0, in which case the mBones array is nullptr.
+    * Can be 0, in which case the mBones array is NULL.
     */
     unsigned int mNumBones;
 
@@ -786,10 +769,7 @@ struct aiMesh
         // DO NOT REMOVE THIS ADDITIONAL CHECK
         if (mNumBones && mBones)    {
             for( unsigned int a = 0; a < mNumBones; a++) {
-                if(mBones[a])
-                {
-                    delete mBones[a];
-                }
+                delete mBones[a];
             }
             delete [] mBones;
         }
diff --git a/Engine/lib/assimp/include/assimp/metadata.h b/Engine/lib/assimp/include/assimp/metadata.h
index bddd04b1e..3a1dd1442 100644
--- a/Engine/lib/assimp/include/assimp/metadata.h
+++ b/Engine/lib/assimp/include/assimp/metadata.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -48,10 +48,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_METADATA_H_INC
 #define AI_METADATA_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #if defined(_MSC_VER) && (_MSC_VER <= 1500)
 #  include "Compiler/pstdint.h"
 #else
@@ -286,8 +282,8 @@ struct aiMetadata {
 			new_values[i] = mValues[i];
 		}
 
-		delete[] mKeys;
-		delete[] mValues;
+		delete mKeys;
+		delete mValues;
 
 		mKeys = new_keys;
 		mValues = new_values;
@@ -377,23 +373,6 @@ struct aiMetadata {
 		return true;
 	}
 
-    /// Check whether there is a metadata entry for the given key.
-    /// \param [in] Key - the key value value to check for.
-    inline
-    bool HasKey(const char* key) {
-        if ( nullptr == key ) {
-            return false;
-        }
-        
-        // Search for the given key
-        for (unsigned int i = 0; i < mNumProperties; ++i) {
-            if ( 0 == strncmp(mKeys[i].C_Str(), key, mKeys[i].length ) ) {
-                return true;
-            }
-        }
-        return false;
-    }
-
 #endif // __cplusplus
 
 };
diff --git a/Engine/lib/assimp/include/assimp/pbrmaterial.h b/Engine/lib/assimp/include/assimp/pbrmaterial.h
index cac4ab56b..ce5f82217 100644
--- a/Engine/lib/assimp/include/assimp/pbrmaterial.h
+++ b/Engine/lib/assimp/include/assimp/pbrmaterial.h
@@ -3,7 +3,9 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
+
+
 
 All rights reserved.
 
@@ -42,14 +44,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file pbrmaterial.h
  *  @brief Defines the material system of the library
  */
-#pragma once
 #ifndef AI_PBRMATERIAL_H_INC
 #define AI_PBRMATERIAL_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #define AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_BASE_COLOR_FACTOR "$mat.gltf.pbrMetallicRoughness.baseColorFactor", 0, 0
 #define AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_METALLIC_FACTOR "$mat.gltf.pbrMetallicRoughness.metallicFactor", 0, 0
 #define AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_ROUGHNESS_FACTOR "$mat.gltf.pbrMetallicRoughness.roughnessFactor", 0, 0
diff --git a/Engine/lib/assimp/include/assimp/port/AndroidJNI/AndroidJNIIOSystem.h b/Engine/lib/assimp/include/assimp/port/AndroidJNI/AndroidJNIIOSystem.h
index 01505d571..41d800487 100644
--- a/Engine/lib/assimp/include/assimp/port/AndroidJNI/AndroidJNIIOSystem.h
+++ b/Engine/lib/assimp/include/assimp/port/AndroidJNI/AndroidJNIIOSystem.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2016, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
diff --git a/Engine/lib/assimp/include/assimp/postprocess.h b/Engine/lib/assimp/include/assimp/postprocess.h
index 9997f0d60..2a7441421 100644
--- a/Engine/lib/assimp/include/assimp/postprocess.h
+++ b/Engine/lib/assimp/include/assimp/postprocess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -47,11 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_POSTPROCESS_H_INC
 #define AI_POSTPROCESS_H_INC
 
-#include <assimp/types.h>
-
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
+#include "types.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -320,19 +316,6 @@ enum aiPostProcessSteps
     */
     aiProcess_FixInfacingNormals = 0x2000,
 
-
-
-    // -------------------------------------------------------------------------
-    /** 
-     * This step generically populates aiBone->mArmature and aiBone->mNode generically
-     * The point of these is it saves you later having to calculate these elements
-     * This is useful when handling rest information or skin information
-     * If you have multiple armatures on your models we strongly recommend enabling this 
-     * Instead of writing your own multi-root, multi-armature lookups we have done the 
-     * hard work for you :)
-   */
-    aiProcess_PopulateArmatureData = 0x4000,
-
     // -------------------------------------------------------------------------
     /** <hr>This step splits meshes with more than one primitive type in
      *  homogeneous sub-meshes.
@@ -550,8 +533,6 @@ enum aiPostProcessSteps
     */
     aiProcess_Debone  = 0x4000000,
 
-
-
     // -------------------------------------------------------------------------
     /** <hr>This step will perform a global scale of the model.
     *
diff --git a/Engine/lib/assimp/include/assimp/qnan.h b/Engine/lib/assimp/include/assimp/qnan.h
index 5ca80601d..0918bde5e 100644
--- a/Engine/lib/assimp/include/assimp/qnan.h
+++ b/Engine/lib/assimp/include/assimp/qnan.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -50,23 +50,19 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *     but last time I checked compiler coverage was so bad that I decided
  *     to reinvent the wheel.
  */
-#pragma once
+
 #ifndef AI_QNAN_H_INCLUDED
 #define AI_QNAN_H_INCLUDED
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #include <assimp/defs.h>
-
 #include <limits>
 #include <stdint.h>
 
 // ---------------------------------------------------------------------------
 /** Data structure to represent the bit pattern of a 32 Bit
  *         IEEE 754 floating-point number. */
-union _IEEESingle {
+union _IEEESingle
+{
     float Float;
     struct
     {
@@ -79,7 +75,8 @@ union _IEEESingle {
 // ---------------------------------------------------------------------------
 /** Data structure to represent the bit pattern of a 64 Bit
  *         IEEE 754 floating-point number. */
-union _IEEEDouble {
+union _IEEEDouble
+{
     double Double;
     struct
     {
@@ -92,7 +89,8 @@ union _IEEEDouble {
 // ---------------------------------------------------------------------------
 /** Check whether a given float is qNaN.
  *  @param in Input value */
-AI_FORCE_INLINE bool is_qnan(float in) {
+AI_FORCE_INLINE bool is_qnan(float in)
+{
     // the straightforward solution does not work:
     //   return (in != in);
     // compiler generates code like this
@@ -109,7 +107,8 @@ AI_FORCE_INLINE bool is_qnan(float in) {
 // ---------------------------------------------------------------------------
 /** Check whether a given double is qNaN.
  *  @param in Input value */
-AI_FORCE_INLINE bool is_qnan(double in) {
+AI_FORCE_INLINE bool is_qnan(double in)
+{
     // the straightforward solution does not work:
     //   return (in != in);
     // compiler generates code like this
@@ -128,7 +127,8 @@ AI_FORCE_INLINE bool is_qnan(double in) {
  *
  *  Denorms return false, they're treated like normal values.
  *  @param in Input value */
-AI_FORCE_INLINE bool is_special_float(float in) {
+AI_FORCE_INLINE bool is_special_float(float in)
+{
     _IEEESingle temp;
     memcpy(&temp, &in, sizeof(float));
     return (temp.IEEE.Exp == (1u << 8)-1);
@@ -139,7 +139,8 @@ AI_FORCE_INLINE bool is_special_float(float in) {
  *
  *  Denorms return false, they're treated like normal values.
  *  @param in Input value */
-AI_FORCE_INLINE bool is_special_float(double in) {
+AI_FORCE_INLINE bool is_special_float(double in)
+{
    _IEEESingle temp;
     memcpy(&temp, &in, sizeof(float));
     return (temp.IEEE.Exp == (1u << 11)-1);
@@ -149,13 +150,15 @@ AI_FORCE_INLINE bool is_special_float(double in) {
 /** Check whether a float is NOT qNaN.
  *  @param in Input value */
 template<class TReal>
-AI_FORCE_INLINE bool is_not_qnan(TReal in) {
+AI_FORCE_INLINE bool is_not_qnan(TReal in)
+{
     return !is_qnan(in);
 }
 
 // ---------------------------------------------------------------------------
 /** @brief Get a fresh qnan.  */
-AI_FORCE_INLINE ai_real get_qnan() {
+AI_FORCE_INLINE ai_real get_qnan()
+{
     return std::numeric_limits<ai_real>::quiet_NaN();
 }
 
diff --git a/Engine/lib/assimp/include/assimp/quaternion.h b/Engine/lib/assimp/include/assimp/quaternion.h
index fd9abfd21..96574d24b 100644
--- a/Engine/lib/assimp/include/assimp/quaternion.h
+++ b/Engine/lib/assimp/include/assimp/quaternion.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -49,11 +49,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef __cplusplus
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
-#include <assimp/defs.h>
+#include "defs.h"
 
 template <typename TReal> class aiVector3t;
 template <typename TReal> class aiMatrix3x3t;
diff --git a/Engine/lib/assimp/include/assimp/quaternion.inl b/Engine/lib/assimp/include/assimp/quaternion.inl
index e8bdb9aeb..c26648215 100644
--- a/Engine/lib/assimp/include/assimp/quaternion.inl
+++ b/Engine/lib/assimp/include/assimp/quaternion.inl
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -48,12 +48,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_QUATERNION_INL_INC
 #define AI_QUATERNION_INL_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #ifdef __cplusplus
-#include <assimp/quaternion.h>
+#include "quaternion.h"
 
 #include <cmath>
 
diff --git a/Engine/lib/assimp/include/assimp/revision.h b/Engine/lib/assimp/include/assimp/revision.h
index 346afbbd3..4d27fd8d7 100644
--- a/Engine/lib/assimp/include/assimp/revision.h
+++ b/Engine/lib/assimp/include/assimp/revision.h
@@ -1,8 +1,8 @@
 #ifndef ASSIMP_REVISION_H_INC
 #define ASSIMP_REVISION_H_INC
 
-#define GitVersion 0xd5ac3330
-#define GitBranch "master"
+#define GitVersion 0x0
+#define GitBranch ""
 
 #define VER_MAJOR 5
 #define VER_MINOR 0
@@ -16,13 +16,13 @@
 #if (GitVersion == 0)
 #define VER_FILEVERSION_STR         STR(VER_MAJOR) "." STR(VER_MINOR) "." STR(VER_PATCH) "." STR(VER_BUILD)
 #else
-#define VER_FILEVERSION_STR         STR(VER_MAJOR) "." STR(VER_MINOR) "." STR(VER_PATCH) "." STR(VER_BUILD) " (Commit d5ac3330)"
+#define VER_FILEVERSION_STR         STR(VER_MAJOR) "." STR(VER_MINOR) "." STR(VER_PATCH) "." STR(VER_BUILD) " (Commit 0)"
 #endif
 
 #ifdef  NDEBUG
-#define VER_ORIGINAL_FILENAME_STR   "assimp-vc142-mt.dll"
+#define VER_ORIGINAL_FILENAME_STR   "assimp.dll"
 #else
-#define VER_ORIGINAL_FILENAME_STR   "assimp-vc142-mtd.dll"
+#define VER_ORIGINAL_FILENAME_STR   "assimp.dll"
 #endif //  NDEBUG
 
 #endif // ASSIMP_REVISION_H_INC
diff --git a/Engine/lib/assimp/include/assimp/scene.h b/Engine/lib/assimp/include/assimp/scene.h
index 93d04eee6..2667db85b 100644
--- a/Engine/lib/assimp/include/assimp/scene.h
+++ b/Engine/lib/assimp/include/assimp/scene.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -48,18 +48,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_SCENE_H_INC
 #define AI_SCENE_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
-#include <assimp/types.h>
-#include <assimp/texture.h>
-#include <assimp/mesh.h>
-#include <assimp/light.h>
-#include <assimp/camera.h>
-#include <assimp/material.h>
-#include <assimp/anim.h>
-#include <assimp/metadata.h>
+#include "types.h"
+#include "texture.h"
+#include "mesh.h"
+#include "light.h"
+#include "camera.h"
+#include "material.h"
+#include "anim.h"
+#include "metadata.h"
 
 #ifdef __cplusplus
 #  include <cstdlib>
@@ -110,13 +106,13 @@ struct ASSIMP_API aiNode
     /** The transformation relative to the node's parent. */
     C_STRUCT aiMatrix4x4 mTransformation;
 
-    /** Parent node. nullptr if this node is the root node. */
+    /** Parent node. NULL if this node is the root node. */
     C_STRUCT aiNode* mParent;
 
     /** The number of child nodes of this node. */
     unsigned int mNumChildren;
 
-    /** The child nodes of this node. nullptr if mNumChildren is 0. */
+    /** The child nodes of this node. NULL if mNumChildren is 0. */
     C_STRUCT aiNode** mChildren;
 
     /** The number of meshes of this node. */
@@ -127,7 +123,7 @@ struct ASSIMP_API aiNode
       */
     unsigned int* mMeshes;
 
-    /** Metadata associated with this node or nullptr if there is no metadata.
+    /** Metadata associated with this node or NULL if there is no metadata.
       *  Whether any metadata is generated depends on the source file format. See the
       * @link importer_notes @endlink page for more information on every source file
       * format. Importers that don't document any metadata don't write any.
@@ -149,7 +145,7 @@ struct ASSIMP_API aiNode
      *  of the scene.
      *
      *  @param name Name to search for
-     *  @return nullptr or a valid Node if the search was successful.
+     *  @return NULL or a valid Node if the search was successful.
      */
     inline 
     const aiNode* FindNode(const aiString& name) const {
@@ -344,7 +340,7 @@ struct aiScene
 
 #ifdef __cplusplus
 
-    //! Default constructor - set everything to 0/nullptr
+    //! Default constructor - set everything to 0/NULL
     ASSIMP_API aiScene();
 
     //! Destructor
@@ -353,33 +349,33 @@ struct aiScene
     //! Check whether the scene contains meshes
     //! Unless no special scene flags are set this will always be true.
     inline bool HasMeshes() const { 
-        return mMeshes != nullptr && mNumMeshes > 0; 
+        return mMeshes != NULL && mNumMeshes > 0; 
     }
 
     //! Check whether the scene contains materials
     //! Unless no special scene flags are set this will always be true.
     inline bool HasMaterials() const { 
-        return mMaterials != nullptr && mNumMaterials > 0; 
+        return mMaterials != NULL && mNumMaterials > 0; 
     }
 
     //! Check whether the scene contains lights
     inline bool HasLights() const { 
-        return mLights != nullptr && mNumLights > 0; 
+        return mLights != NULL && mNumLights > 0; 
     }
 
     //! Check whether the scene contains textures
     inline bool HasTextures() const {
-        return mTextures != nullptr && mNumTextures > 0; 
+        return mTextures != NULL && mNumTextures > 0; 
     }
 
     //! Check whether the scene contains cameras
     inline bool HasCameras() const {
-        return mCameras != nullptr && mNumCameras > 0; 
+        return mCameras != NULL && mNumCameras > 0; 
     }
 
     //! Check whether the scene contains animations
     inline bool HasAnimations() const { 
-        return mAnimations != nullptr && mNumAnimations > 0; 
+        return mAnimations != NULL && mNumAnimations > 0; 
     }
 
     //! Returns a short filename from a full path
diff --git a/Engine/lib/assimp/include/assimp/texture.h b/Engine/lib/assimp/include/assimp/texture.h
index 5a4486431..dc6cbef65 100644
--- a/Engine/lib/assimp/include/assimp/texture.h
+++ b/Engine/lib/assimp/include/assimp/texture.h
@@ -3,7 +3,9 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
+
+
 
 All rights reserved.
 
@@ -51,16 +53,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_TEXTURE_H_INC
 #define AI_TEXTURE_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
-#include <assimp/types.h>
+#include "types.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+
 // --------------------------------------------------------------------------------
 
 /** \def AI_EMBEDDED_TEXNAME_PREFIX
@@ -80,6 +79,7 @@ extern "C" {
 #   define AI_MAKE_EMBEDDED_TEXNAME(_n_) AI_EMBEDDED_TEXNAME_PREFIX # _n_
 #endif
 
+
 #include "./Compiler/pushpack1.h"
 
 // --------------------------------------------------------------------------------
@@ -87,7 +87,8 @@ extern "C" {
 *
 *  Used by aiTexture.
 */
-struct aiTexel {
+struct aiTexel
+{
     unsigned char b,g,r,a;
 
 #ifdef __cplusplus
@@ -207,7 +208,8 @@ struct aiTexture {
     , mHeight(0)
     , pcData(nullptr)
     , mFilename() {
-        memset(achFormatHint, 0, sizeof(achFormatHint));
+        achFormatHint[0] = achFormatHint[1] = 0;
+        achFormatHint[2] = achFormatHint[3] = 0;
     }
 
     // Destruction
diff --git a/Engine/lib/assimp/include/assimp/types.h b/Engine/lib/assimp/include/assimp/types.h
index 1f47dad8f..8ad5680f3 100644
--- a/Engine/lib/assimp/include/assimp/types.h
+++ b/Engine/lib/assimp/include/assimp/types.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -48,10 +48,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_TYPES_H_INC
 #define AI_TYPES_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 // Some runtime headers
 #include <sys/types.h>
 #include <stddef.h>
@@ -60,15 +56,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <stdint.h>
 
 // Our compile configuration
-#include <assimp/defs.h>
+#include "defs.h"
 
 // Some types moved to separate header due to size of operators
-#include <assimp/vector3.h>
-#include <assimp/vector2.h>
-#include <assimp/color4.h>
-#include <assimp/matrix3x3.h>
-#include <assimp/matrix4x4.h>
-#include <assimp/quaternion.h>
+#include "vector3.h"
+#include "vector2.h"
+#include "color4.h"
+#include "matrix3x3.h"
+#include "matrix4x4.h"
+#include "quaternion.h"
 
 typedef int32_t ai_int32;
 typedef uint32_t ai_uint32 ;
@@ -78,8 +74,9 @@ typedef uint32_t ai_uint32 ;
 #include <new>      // for std::nothrow_t
 #include <string>   // for aiString::Set(const std::string&)
 
+
 namespace Assimp    {
-//! @cond never
+    //! @cond never
 namespace Intern        {
     // --------------------------------------------------------------------
     /** @brief Internal helper class to utilize our internal new/delete
diff --git a/Engine/lib/assimp/include/assimp/vector2.h b/Engine/lib/assimp/include/assimp/vector2.h
index a23e32e63..d5ef00154 100644
--- a/Engine/lib/assimp/include/assimp/vector2.h
+++ b/Engine/lib/assimp/include/assimp/vector2.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -47,10 +47,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_VECTOR2D_H_INC
 #define AI_VECTOR2D_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #ifdef __cplusplus
 #   include <cmath>
 #else
diff --git a/Engine/lib/assimp/include/assimp/vector2.inl b/Engine/lib/assimp/include/assimp/vector2.inl
index 19dbce291..3b7a7beab 100644
--- a/Engine/lib/assimp/include/assimp/vector2.inl
+++ b/Engine/lib/assimp/include/assimp/vector2.inl
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -48,12 +48,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_VECTOR2D_INL_INC
 #define AI_VECTOR2D_INL_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #ifdef __cplusplus
-#include <assimp/vector2.h>
+#include "vector2.h"
 
 #include <cmath>
 
diff --git a/Engine/lib/assimp/include/assimp/vector3.h b/Engine/lib/assimp/include/assimp/vector3.h
index 8d3c82cf8..7ff25cf0a 100644
--- a/Engine/lib/assimp/include/assimp/vector3.h
+++ b/Engine/lib/assimp/include/assimp/vector3.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -47,17 +47,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_VECTOR3D_H_INC
 #define AI_VECTOR3D_H_INC
 
-#ifdef __GNUC__
-#   pragma GCC system_header
-#endif
-
 #ifdef __cplusplus
 #   include <cmath>
 #else
 #   include <math.h>
 #endif
 
-#include <assimp/defs.h>
+#include "defs.h"
 
 #ifdef __cplusplus
 
@@ -67,13 +63,16 @@ template<typename TReal> class aiMatrix4x4t;
 // ---------------------------------------------------------------------------
 /** Represents a three-dimensional vector. */
 template <typename TReal>
-class aiVector3t {
+class aiVector3t
+{
 public:
     aiVector3t() AI_NO_EXCEPT : x(), y(), z() {}
     aiVector3t(TReal _x, TReal _y, TReal _z) : x(_x), y(_y), z(_z) {}
     explicit aiVector3t (TReal _xyz ) : x(_xyz), y(_xyz), z(_xyz) {}
     aiVector3t( const aiVector3t& o ) = default;
 
+public:
+
     // combined operators
     const aiVector3t& operator += (const aiVector3t& o);
     const aiVector3t& operator -= (const aiVector3t& o);
@@ -98,6 +97,7 @@ public:
     template <typename TOther>
     operator aiVector3t<TOther> () const;
 
+public:
     /** @brief Set the components of a vector
      *  @param pX X component
      *  @param pY Y component
diff --git a/Engine/lib/assimp/include/assimp/vector3.inl b/Engine/lib/assimp/include/assimp/vector3.inl
index 2765115a2..2fce6edde 100644
--- a/Engine/lib/assimp/include/assimp/vector3.inl
+++ b/Engine/lib/assimp/include/assimp/vector3.inl
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -49,7 +49,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define AI_VECTOR3D_INL_INC
 
 #ifdef __cplusplus
-#include <assimp/vector3.h>
+#include "vector3.h"
 
 #include <cmath>
 
diff --git a/Engine/lib/assimp/include/assimp/version.h b/Engine/lib/assimp/include/assimp/version.h
index 6709eaf39..c62a40e11 100644
--- a/Engine/lib/assimp/include/assimp/version.h
+++ b/Engine/lib/assimp/include/assimp/version.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -49,7 +49,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_VERSION_H_INC
 #define AI_VERSION_H_INC
 
-#include <assimp/defs.h>
+#include "defs.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -62,13 +62,6 @@ extern "C" {
  */
 ASSIMP_API const char*  aiGetLegalString  (void);
 
-// ---------------------------------------------------------------------------
-/** @brief Returns the current patch version number of Assimp.
- *  @return Patch version of the Assimp runtime the application was
- *    linked/built against
- */
-ASSIMP_API unsigned int aiGetVersionPatch(void);
-
 // ---------------------------------------------------------------------------
 /** @brief Returns the current minor version number of Assimp.
  *  @return Minor version of the Assimp runtime the application was

From a05c83493e3e69cd68622167ec8ae172c87aee6a Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Thu, 21 Oct 2021 22:08:56 -0500
Subject: [PATCH 205/399] adress gl spotlights disapearing for deferred It was
 mixing vars up between it and forward. resolved by prefixing the forward vars
 with "in" as the rest are, as well as pointing the val at the const String
 ShaderGenVars::lightSpotParams("$inlightSpotParams");

---
 Engine/source/lighting/shadowMap/lightShadowMap.cpp | 2 +-
 Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp  | 2 +-
 Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp  | 2 +-
 Engine/source/shaderGen/shaderGenVars.cpp           | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Engine/source/lighting/shadowMap/lightShadowMap.cpp b/Engine/source/lighting/shadowMap/lightShadowMap.cpp
index 3fde1ccbf..9ecde8c97 100644
--- a/Engine/source/lighting/shadowMap/lightShadowMap.cpp
+++ b/Engine/source/lighting/shadowMap/lightShadowMap.cpp
@@ -470,7 +470,6 @@ void LightingShaderConstants::init(GFXShader* shader)
    }
 
    mLightParamsSC = shader->getShaderConstHandle("$lightParams");
-   mLightSpotParamsSC = shader->getShaderConstHandle("$lightSpotParams");
 
    // NOTE: These are the shader constants used for doing lighting 
    // during the forward pass.  Do not confuse these for the deferred
@@ -480,6 +479,7 @@ void LightingShaderConstants::init(GFXShader* shader)
    mLightAmbientSC = shader->getShaderConstHandle( ShaderGenVars::lightAmbient );
    mLightConfigDataSC = shader->getShaderConstHandle( ShaderGenVars::lightConfigData);
    mLightSpotDirSC = shader->getShaderConstHandle( ShaderGenVars::lightSpotDir );
+   mLightSpotParamsSC = shader->getShaderConstHandle(ShaderGenVars::lightSpotParams);
 
    mHasVectorLightSC = shader->getShaderConstHandle(ShaderGenVars::hasVectorLight);
    mVectorLightDirectionSC = shader->getShaderConstHandle(ShaderGenVars::vectorLightDirection);
diff --git a/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp b/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
index bb09113a4..3c132bf55 100644
--- a/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
+++ b/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
@@ -2189,7 +2189,7 @@ void RTLightingFeatGLSL::processPix(   Vector<ShaderComponent*> &componentList,
    inLightSpotDir->arraySize = 4;
    inLightSpotDir->constSortPos = cspPotentialPrimitive;
 
-   Var * lightSpotParams = new Var( "lightSpotParams", "vec2" );
+   Var * lightSpotParams = new Var( "inlightSpotParams", "vec2" );
    lightSpotParams->uniform = true;
    lightSpotParams->arraySize = 4;
    lightSpotParams->constSortPos = cspPotentialPrimitive;
diff --git a/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp b/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
index 0b5f79e4d..48a20d835 100644
--- a/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
+++ b/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
@@ -2262,7 +2262,7 @@ void RTLightingFeatHLSL::processPix(   Vector<ShaderComponent*> &componentList,
    inLightSpotDir->arraySize = 4;
    inLightSpotDir->constSortPos = cspPotentialPrimitive;
 
-   Var * lightSpotParams = new Var( "lightSpotParams", "float2" );
+   Var * lightSpotParams = new Var( "inlightSpotParams", "float2" );
    lightSpotParams->uniform = true;
    lightSpotParams->arraySize = 4;
    lightSpotParams->constSortPos = cspPotentialPrimitive;
diff --git a/Engine/source/shaderGen/shaderGenVars.cpp b/Engine/source/shaderGen/shaderGenVars.cpp
index 45d1fe7f2..6a933319d 100644
--- a/Engine/source/shaderGen/shaderGenVars.cpp
+++ b/Engine/source/shaderGen/shaderGenVars.cpp
@@ -66,7 +66,7 @@ const String ShaderGenVars::lightDiffuse("$inLightColor");
 const String ShaderGenVars::lightAmbient("$ambient");
 const String ShaderGenVars::lightConfigData("$inLightConfigData");
 const String ShaderGenVars::lightSpotDir("$inLightSpotDir");
-const String ShaderGenVars::lightSpotParams("$lightSpotParams");
+const String ShaderGenVars::lightSpotParams("$inlightSpotParams");
 
 const String ShaderGenVars::hasVectorLight("$hasVectorLight");
 const String ShaderGenVars::vectorLightDirection("$vectorLightDirection");

From edf9afbd9b72b667c5b3a5761cc6ab3c6bc0ff48 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Fri, 22 Oct 2021 11:22:34 -0400
Subject: [PATCH 206/399] * [AssetBrowser] BugFix: Allow the asset browser tree
 view to use a horizontal scroll bar where necessary.

---
 .../BaseGame/game/tools/assetBrowser/guis/assetBrowser.gui    | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Templates/BaseGame/game/tools/assetBrowser/guis/assetBrowser.gui b/Templates/BaseGame/game/tools/assetBrowser/guis/assetBrowser.gui
index 57b021106..59e7beb10 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/guis/assetBrowser.gui
+++ b/Templates/BaseGame/game/tools/assetBrowser/guis/assetBrowser.gui
@@ -518,9 +518,9 @@ $guiContent = new GuiControl(AssetBrowser) {
 
                new GuiScrollCtrl() {
                   willFirstRespond = "1";
-                  hScrollBar = "alwaysOff";
+                  hScrollBar = "dynamic";
                   vScrollBar = "dynamic";
-                  lockHorizScroll = "1";
+                  lockHorizScroll = "0";
                   lockVertScroll = "0";
                   constantThumbHeight = "0";
                   childMargin = "0 0";

From 27d75486e6f4f9cc8bcbbd97d08902d996b8ac9b Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Sun, 24 Oct 2021 19:10:59 -0400
Subject: [PATCH 207/399] * [Editor] BugFix: Correct the inability to use
 function keys F1-F10 when running the editor. These keys were supposed to
 open a series of other editors.

---
 .../game/tools/worldEditor/scripts/EditorGui.ed.tscript      | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
index dca4d1f30..38b5c72d8 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
@@ -359,8 +359,9 @@ function EditorGui::addToEditorsMenu( %this, %displayName, %accel, %newPlugin )
          
    if(!%alreadyExists)
    {
-      EditorsMenuList.add(%displayName TAB %accel TAB %newPlugin);
-      %windowMenu.addItem( %count, %displayName TAB %accel TAB %newPlugin );
+      %pluginCommand = "EditorGui.setEditor(" @ %newPlugin @ ");";
+      EditorsMenuList.add(%displayName TAB %accel TAB %pluginCommand);
+      %windowMenu.addItem( %count, %displayName TAB %accel TAB %pluginCommand);
    }
       
    return %accel;

From 4082fd36e39276fb6fbedf212b974c8272fc69ef Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Mon, 25 Oct 2021 16:14:11 -0400
Subject: [PATCH 208/399] * [AssetBrowser] BugFix: Address an error where
 deleting directories may result in an infinite loop.

---
 .../scripts/directoryHandling.tscript         | 37 ++++++++++++++-----
 1 file changed, 28 insertions(+), 9 deletions(-)

diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/directoryHandling.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/directoryHandling.tscript
index 4f13dfb8b..329e2763f 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/directoryHandling.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/directoryHandling.tscript
@@ -277,27 +277,46 @@ function directoryHandler::deleteFolder(%this, %folderPath)
    %fullPath = makeFullPath(%folderPath);
    
    //First, wipe out any files inside the folder first
-   %file = findFirstFileMultiExpr( %fullPath @ "/*.*", true);
+   %file = findFirstFileMultiExpr( %fullPath @ "/*", true);
 
    while( %file !$= "" )
    {      
-      %success = fileDelete( %file );
-      
-      if(!%success)
+      if (isFile(%file))
       {
-         error("doDeleteFolder - unable to delete file " @ %file);
-         return;         
-      }
+         %success = fileDelete( %file );
       
-      %file = findNextFileMultiExpr( %fullPath @ "/*.*" );
+         if(!%success)
+         {
+            error("doDeleteFolder - unable to delete file " @ %file);
+            return;         
+         }
+      }
+      %file = findNextFileMultiExpr( %fullPath @ "/*" );
    }
    
    //next, walk through and delete any subfolders that may be remaining
+   %finalDeleteAttempt = false;
    while(IsDirectory(%fullPath) && fileDelete(%fullPath) == 0)
    {
       //We couldn't delete the folder, so get a directory list and recurse through it, deleteing them as we go
       %paths = getDirectoryList(%fullPath);
-      for(%i=0; %i < getFieldCount(%paths); %i++)
+
+      // If nothing is in this directory, let the loop run once more and if that fails we're not going
+      // to delete the folder. This prevents an infinite loop if for some reason the directory cannot
+      // be deleted.
+      %pathCount = getFieldCount(%paths);
+      if (%pathCount == 0)
+      {
+         if (%finalDeleteattempt)
+         {
+            error("doDeleteFolder - unable to delete directory " @ %fullPath);
+            return;
+         }
+         %finalDeleteAttempt = true;
+         continue;
+      }
+
+      for(%i=0; %i < %pathCount; %i++)
       {
          %childPath = getField(%paths, %i);
          %this.deleteFolder(%fullPath @ "/" @ %childPath);

From 3fdf49f829911c11082775f72d9e87d3b6ab9a4e Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Mon, 25 Oct 2021 22:54:19 -0500
Subject: [PATCH 209/399] addsa material.setAnimflags(LAYER,TAGS STRING);
 method workaround for mat.animFlags[#]= foo; not taking time of writing seems
 to not work for scroll for some reason. might be a different bug

---
 .../source/materials/materialDefinition.cpp   | 24 +++++++++++++++++++
 .../scripts/materialEditor.ed.tscript         |  4 ++--
 2 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/Engine/source/materials/materialDefinition.cpp b/Engine/source/materials/materialDefinition.cpp
index 1ed904bee..34a26a617 100644
--- a/Engine/source/materials/materialDefinition.cpp
+++ b/Engine/source/materials/materialDefinition.cpp
@@ -755,6 +755,30 @@ DefineEngineMethod(Material, getAnimFlags, const char*, (U32 id), , "")
    return animFlags;
 }
 
+DefineEngineMethod(Material, setAnimFlags, void, (S32 id, const char *flags), (0, ""), "setAnimFlags")
+{
+   object->mAnimFlags[id] = 0;
+
+   if (String(flags).find("$Scroll") != String::NPos)
+      object->mAnimFlags[id] |= Material::Scroll;
+
+   if (String(flags).find("$Rotate") != String::NPos)
+      object->mAnimFlags[id] |= Material::Rotate;
+
+   if (String(flags).find("$Wave") != String::NPos)
+      object->mAnimFlags[id] |= Material::Wave;
+
+   if (String(flags).find("$Scale") != String::NPos)
+      object->mAnimFlags[id] |= Material::Scale;
+
+   if (String(flags).find("$Sequence") != String::NPos)
+      object->mAnimFlags[id] |= Material::Sequence;
+
+   //if we're still unset, see if they tried assigning a number
+   if (object->mAnimFlags[id] == 0)
+      object->mAnimFlags[id] = dAtoi(flags);
+}
+
 DefineEngineMethod(Material, getFilename, const char*, (), , "Get filename of material")
 {
    SimObject* material = static_cast<SimObject*>(object);
diff --git a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
index 5deca8a4c..24b00874a 100644
--- a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
@@ -1432,13 +1432,13 @@ function MaterialEditorGui::updateAnimationFlags(%this)
    %action.oldValue = %oldFlags;
    MaterialEditorGui.submitUndo( %action );
    
-   materialEd_previewMaterial.animFlags[MaterialEditorGui.currentLayer] = %flags;
+   materialEd_previewMaterial.setAnimFlags(MaterialEditorGui.currentLayer, %flags);
    materialEd_previewMaterial.flush();
    materialEd_previewMaterial.reload();
    
    if (MaterialEditorGui.livePreview == true)
    {
-      MaterialEditorGui.currentMaterial.animFlags[MaterialEditorGui.currentLayer] = %flags;
+      MaterialEditorGui.currentMaterial.setAnimFlags(MaterialEditorGui.currentLayer, %flags);
       MaterialEditorGui.currentMaterial.flush();
       MaterialEditorGui.currentMaterial.reload();
    }

From d07d11324633f9f024e35cdfd58eec185040ca8e Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Mon, 25 Oct 2021 23:16:41 -0500
Subject: [PATCH 210/399] blatantly ganked from T2D; adds rotation as an option
 for drawbitmap demonstrates a bit of usage in guibitmapctrl. (do note, gui
 elements may need followup via altering thier clip rect depending on how
 folks want to end up using this)

---
 Engine/source/gfx/gfxDrawUtil.cpp            | 56 ++++++++++++++------
 Engine/source/gfx/gfxDrawUtil.h              | 16 +++---
 Engine/source/gui/controls/guiBitmapCtrl.cpp |  7 ++-
 Engine/source/gui/controls/guiBitmapCtrl.h   |  3 +-
 4 files changed, 55 insertions(+), 27 deletions(-)

diff --git a/Engine/source/gfx/gfxDrawUtil.cpp b/Engine/source/gfx/gfxDrawUtil.cpp
index 357e48a5e..a806bef80 100644
--- a/Engine/source/gfx/gfxDrawUtil.cpp
+++ b/Engine/source/gfx/gfxDrawUtil.cpp
@@ -303,54 +303,54 @@ U32 GFXDrawUtil::drawTextN( GFont *font, const Point2F &ptDraw, const UTF16 *in_
 //-----------------------------------------------------------------------------
 // Draw Bitmaps
 //-----------------------------------------------------------------------------
-void GFXDrawUtil::drawBitmap( GFXTextureObject* texture, const Point2I &in_rAt, const GFXBitmapFlip in_flip, const GFXTextureFilterType filter , bool in_wrap /*= true*/ )
+void GFXDrawUtil::drawBitmap( GFXTextureObject* texture, const Point2I &in_rAt, const GFXBitmapFlip in_flip, const GFXTextureFilterType filter , bool in_wrap /*= true*/, F32 fSpin)
 {
-   drawBitmap(texture,Point2F((F32)in_rAt.x,(F32)in_rAt.y),in_flip,filter,in_wrap);
+   drawBitmap(texture,Point2F((F32)in_rAt.x,(F32)in_rAt.y),in_flip,filter,in_wrap, fSpin);
 }
 
-void GFXDrawUtil::drawBitmapStretch( GFXTextureObject* texture, const RectI &dstRect, const GFXBitmapFlip in_flip, const GFXTextureFilterType filter , bool in_wrap /*= true*/ )
+void GFXDrawUtil::drawBitmapStretch( GFXTextureObject* texture, const RectI &dstRect, const GFXBitmapFlip in_flip, const GFXTextureFilterType filter , bool in_wrap /*= true*/, F32 fSpin)
 {
-   drawBitmapStretch(texture,RectF((F32)dstRect.point.x,(F32)dstRect.point.y,(F32)dstRect.extent.x,(F32)dstRect.extent.y),in_flip,filter,in_wrap);
+   drawBitmapStretch(texture,RectF((F32)dstRect.point.x,(F32)dstRect.point.y,(F32)dstRect.extent.x,(F32)dstRect.extent.y),in_flip,filter,in_wrap, fSpin);
 }
 
-void GFXDrawUtil::drawBitmapSR( GFXTextureObject* texture, const Point2I &in_rAt, const RectI &srcRect, const GFXBitmapFlip in_flip, const GFXTextureFilterType filter , bool in_wrap /*= true*/ )
+void GFXDrawUtil::drawBitmapSR( GFXTextureObject* texture, const Point2I &in_rAt, const RectI &srcRect, const GFXBitmapFlip in_flip, const GFXTextureFilterType filter , bool in_wrap /*= true*/, F32 fSpin)
 {
-   drawBitmapSR(texture,Point2F((F32)in_rAt.x,(F32)in_rAt.y),RectF((F32)srcRect.point.x,(F32)srcRect.point.y,(F32)srcRect.extent.x,(F32)srcRect.extent.y),in_flip,filter,in_wrap);
+   drawBitmapSR(texture,Point2F((F32)in_rAt.x,(F32)in_rAt.y),RectF((F32)srcRect.point.x,(F32)srcRect.point.y,(F32)srcRect.extent.x,(F32)srcRect.extent.y),in_flip,filter,in_wrap, fSpin);
 }
 
-void GFXDrawUtil::drawBitmapStretchSR( GFXTextureObject *texture, const RectI &dstRect, const RectI &srcRect, const GFXBitmapFlip in_flip, const GFXTextureFilterType filter , bool in_wrap /*= true*/ ) 
+void GFXDrawUtil::drawBitmapStretchSR( GFXTextureObject *texture, const RectI &dstRect, const RectI &srcRect, const GFXBitmapFlip in_flip, const GFXTextureFilterType filter , bool in_wrap /*= true*/, F32 fSpin)
 {
    RectF dstRectF = RectF((F32)dstRect.point.x,(F32)dstRect.point.y,(F32)dstRect.extent.x,(F32)dstRect.extent.y);
    RectF srcRectF = RectF((F32)srcRect.point.x,(F32)srcRect.point.y,(F32)srcRect.extent.x,(F32)srcRect.extent.y);
-   drawBitmapStretchSR(texture,dstRectF,srcRectF,in_flip,filter,in_wrap);
+   drawBitmapStretchSR(texture,dstRectF,srcRectF,in_flip,filter,in_wrap, fSpin);
 }
 
-void GFXDrawUtil::drawBitmap( GFXTextureObject*texture, const Point2F &in_rAt, const GFXBitmapFlip in_flip /*= GFXBitmapFlip_None*/, const GFXTextureFilterType filter /*= GFXTextureFilterPoint */ , bool in_wrap /*= true*/ )
+void GFXDrawUtil::drawBitmap( GFXTextureObject*texture, const Point2F &in_rAt, const GFXBitmapFlip in_flip /*= GFXBitmapFlip_None*/, const GFXTextureFilterType filter /*= GFXTextureFilterPoint */ , bool in_wrap /*= true*/, F32 fSpin)
 {
    AssertFatal( texture != 0, "No texture specified for drawBitmap()" );
 
    RectI subRegion( 0, 0, texture->mBitmapSize.x, texture->mBitmapSize.y );
    RectI stretch( in_rAt.x, in_rAt.y, texture->mBitmapSize.x, texture->mBitmapSize.y );
-   drawBitmapStretchSR( texture, stretch, subRegion, in_flip, filter, in_wrap );
+   drawBitmapStretchSR( texture, stretch, subRegion, in_flip, filter, in_wrap, fSpin);
 }
 
-void GFXDrawUtil::drawBitmapStretch( GFXTextureObject*texture, const RectF &dstRect, const GFXBitmapFlip in_flip /*= GFXBitmapFlip_None*/, const GFXTextureFilterType filter /*= GFXTextureFilterPoint */ , bool in_wrap /*= true*/ )
+void GFXDrawUtil::drawBitmapStretch( GFXTextureObject*texture, const RectF &dstRect, const GFXBitmapFlip in_flip /*= GFXBitmapFlip_None*/, const GFXTextureFilterType filter /*= GFXTextureFilterPoint */ , bool in_wrap /*= true*/, F32 fSpin)
 {
    AssertFatal( texture != 0, "No texture specified for drawBitmapStretch()" );
 
    RectF subRegion( 0.f, 0.f, (F32)texture->mBitmapSize.x, (F32)texture->mBitmapSize.y );
-   drawBitmapStretchSR( texture, dstRect, subRegion, in_flip, filter, in_wrap );
+   drawBitmapStretchSR( texture, dstRect, subRegion, in_flip, filter, in_wrap, fSpin);
 }
 
-void GFXDrawUtil::drawBitmapSR( GFXTextureObject*texture, const Point2F &in_rAt, const RectF &srcRect, const GFXBitmapFlip in_flip /*= GFXBitmapFlip_None*/, const GFXTextureFilterType filter /*= GFXTextureFilterPoint */ , bool in_wrap /*= true*/ )
+void GFXDrawUtil::drawBitmapSR( GFXTextureObject*texture, const Point2F &in_rAt, const RectF &srcRect, const GFXBitmapFlip in_flip /*= GFXBitmapFlip_None*/, const GFXTextureFilterType filter /*= GFXTextureFilterPoint */ , bool in_wrap /*= true*/, F32 fSpin)
 {
    AssertFatal( texture != 0, "No texture specified for drawBitmapSR()" );
 
    RectF stretch( in_rAt.x, in_rAt.y, srcRect.len_x(), srcRect.len_y() );
-   drawBitmapStretchSR( texture, stretch, srcRect, in_flip, filter, in_wrap );
+   drawBitmapStretchSR( texture, stretch, srcRect, in_flip, filter, in_wrap, fSpin);
 }
 
-void GFXDrawUtil::drawBitmapStretchSR( GFXTextureObject* texture, const RectF &dstRect, const RectF &srcRect, const GFXBitmapFlip in_flip /*= GFXBitmapFlip_None*/, const GFXTextureFilterType filter /*= GFXTextureFilterPoint */ , bool in_wrap /*= true*/ )
+void GFXDrawUtil::drawBitmapStretchSR( GFXTextureObject* texture, const RectF &dstRect, const RectF &srcRect, const GFXBitmapFlip in_flip /*= GFXBitmapFlip_None*/, const GFXTextureFilterType filter /*= GFXTextureFilterPoint */ , bool in_wrap /*= true*/, F32 fSpin)
 {
    // Sanity if no texture is specified.
    if(!texture)
@@ -395,6 +395,30 @@ void GFXDrawUtil::drawBitmapStretchSR( GFXTextureObject* texture, const RectF &d
    verts[2].texCoord.set( texLeft,  texBottom );
    verts[3].texCoord.set( texRight, texBottom );
 
+   if (fSpin != 0.0f)
+   {
+      U32 i = 0;
+      Point3F points[4];
+
+      points[0] = Point3F(-dstRect.extent.x / 2.0f, -dstRect.extent.y / 2.0f, 0.0);
+      points[1] = Point3F(dstRect.extent.x / 2.0f, -dstRect.extent.y / 2.0f, 0.0);
+      points[2] = Point3F(-dstRect.extent.x / 2.0f, dstRect.extent.y / 2.0f, 0.0);
+      points[3] = Point3F(dstRect.extent.x / 2.0f, dstRect.extent.y / 2.0f, 0.0);
+
+      //calc center by taking position+extent/2
+      Point3F offset(dstRect.point.x + dstRect.extent.x / 2.0f,
+         dstRect.point.y + dstRect.extent.y / 2.0f, 0.0);
+
+      //rotate points by mulitplying by a rotation matrix
+      MatrixF rotMatrix(EulerF(0.0, 0.0, mDegToRad(fSpin)));
+      for (i = 0; i < 4; i++)
+      {
+         rotMatrix.mulP(points[i]);
+         points[i] += offset;
+         verts[i].point = points[i];
+      }
+   }
+
    verts.unlock();
 
    mDevice->setVertexBuffer( verts );
@@ -1641,4 +1665,4 @@ void GFXDrawUtil::drawTransform( const GFXStateBlockDesc &desc, const MatrixF &m
    mDevice->setVertexBuffer( verts );
    mDevice->setupGenericShaders();
    mDevice->drawPrimitive( GFXLineList, 0, 3 );
-}
\ No newline at end of file
+}
diff --git a/Engine/source/gfx/gfxDrawUtil.h b/Engine/source/gfx/gfxDrawUtil.h
index 47f6581cf..a60c81624 100644
--- a/Engine/source/gfx/gfxDrawUtil.h
+++ b/Engine/source/gfx/gfxDrawUtil.h
@@ -93,15 +93,15 @@ public:
    //-----------------------------------------------------------------------------
    // Draw Bitmaps
    //-----------------------------------------------------------------------------  
-   void drawBitmap( GFXTextureObject*texture, const Point2F &in_rAt, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true );
-   void drawBitmapSR( GFXTextureObject*texture, const Point2F &in_rAt, const RectF &srcRect, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true );
-   void drawBitmapStretch( GFXTextureObject*texture, const RectF &dstRect, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true );
-   void drawBitmapStretchSR( GFXTextureObject*texture, const RectF &dstRect, const RectF &srcRect, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true );
+   void drawBitmap( GFXTextureObject*texture, const Point2F &in_rAt, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true, F32 fSpin = 0.0f);
+   void drawBitmapSR( GFXTextureObject*texture, const Point2F &in_rAt, const RectF &srcRect, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true, F32 fSpin = 0.0f);
+   void drawBitmapStretch( GFXTextureObject*texture, const RectF &dstRect, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true, F32 fSpin = 0.0f);
+   void drawBitmapStretchSR( GFXTextureObject*texture, const RectF &dstRect, const RectF &srcRect, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true, F32 fSpin = 0.0f);
 
-   void drawBitmap( GFXTextureObject*texture, const Point2I &in_rAt, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true );
-   void drawBitmapSR( GFXTextureObject*texture, const Point2I &in_rAt, const RectI &srcRect, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true );
-   void drawBitmapStretch( GFXTextureObject*texture, const RectI &dstRect, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true );
-   void drawBitmapStretchSR( GFXTextureObject*texture, const RectI &dstRect, const RectI &srcRect, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true );
+   void drawBitmap( GFXTextureObject*texture, const Point2I &in_rAt, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true, F32 fSpin = 0.0f);
+   void drawBitmapSR( GFXTextureObject*texture, const Point2I &in_rAt, const RectI &srcRect, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true, F32 fSpin = 0.0f);
+   void drawBitmapStretch( GFXTextureObject*texture, const RectI &dstRect, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true, F32 fSpin = 0.0f);
+   void drawBitmapStretchSR( GFXTextureObject*texture, const RectI &dstRect, const RectI &srcRect, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true, F32 fSpin = 0.0f);
 
    //-----------------------------------------------------------------------------
    // Draw 3D Shapes
diff --git a/Engine/source/gui/controls/guiBitmapCtrl.cpp b/Engine/source/gui/controls/guiBitmapCtrl.cpp
index 89e8ecbb3..ecbe288f7 100644
--- a/Engine/source/gui/controls/guiBitmapCtrl.cpp
+++ b/Engine/source/gui/controls/guiBitmapCtrl.cpp
@@ -58,6 +58,7 @@ ConsoleDocClass( GuiBitmapCtrl,
 GuiBitmapCtrl::GuiBitmapCtrl(void)
  : mStartPoint( 0, 0 ),
    mColor(ColorI::WHITE),
+   mRotation(0),
    mWrap( false )
 {
    INIT_ASSET(Bitmap);
@@ -83,6 +84,8 @@ void GuiBitmapCtrl::initPersistFields()
       addField("color", TypeColorI, Offset(mColor, GuiBitmapCtrl),"color mul");
       addField( "wrap",   TypeBool,     Offset( mWrap, GuiBitmapCtrl ),
          "If true, the bitmap is tiled inside the control rather than stretched to fit." );
+
+      addField("rotation", TypeF32, Offset(mRotation, GuiBitmapCtrl), "rotation");
       
    endGroup( "Bitmap" );
 
@@ -187,14 +190,14 @@ void GuiBitmapCtrl::onRender(Point2I offset, const RectI &updateRect)
 								      ((texture->mBitmapSize.y*y)+offset.y)-yshift,
 								      texture->mBitmapSize.x,
 								      texture->mBitmapSize.y);
-               GFX->getDrawUtil()->drawBitmapStretchSR(texture,dstRegion, srcRegion, GFXBitmapFlip_None, GFXTextureFilterLinear);
+               GFX->getDrawUtil()->drawBitmapStretchSR(texture, dstRegion, srcRegion, GFXBitmapFlip_None, GFXTextureFilterLinear, mRotation);
 				}
 
 		}
 		else
       {
          RectI rect(offset, getExtent());
-         GFX->getDrawUtil()->drawBitmapStretch(mBitmap, rect, GFXBitmapFlip_None, GFXTextureFilterLinear, false);
+         GFX->getDrawUtil()->drawBitmapStretch(mBitmap, rect, GFXBitmapFlip_None, GFXTextureFilterLinear, false, mRotation);
       }
    }
 
diff --git a/Engine/source/gui/controls/guiBitmapCtrl.h b/Engine/source/gui/controls/guiBitmapCtrl.h
index c5e2130dd..42e3c8a8f 100644
--- a/Engine/source/gui/controls/guiBitmapCtrl.h
+++ b/Engine/source/gui/controls/guiBitmapCtrl.h
@@ -44,7 +44,8 @@ class GuiBitmapCtrl : public GuiControl
             
       Point2I mStartPoint;
       ColorI   mColor;
-      
+      F32     mRotation;
+
       /// If true, bitmap tiles inside control.  Otherwise stretches.
       bool mWrap;
 

From 0cf8498fcebe1ec4f652df03200532e39cba81d9 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Tue, 26 Oct 2021 08:22:58 -0400
Subject: [PATCH 211/399] * BugFix: Correct usage of mkdir in posixVolume.cpp
 to check for the expected successful return value.

---
 Engine/source/platformPOSIX/posixVolume.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Engine/source/platformPOSIX/posixVolume.cpp b/Engine/source/platformPOSIX/posixVolume.cpp
index 6e691dbbc..d06dccd13 100644
--- a/Engine/source/platformPOSIX/posixVolume.cpp
+++ b/Engine/source/platformPOSIX/posixVolume.cpp
@@ -196,7 +196,7 @@ FileNodeRef PosixFileSystem::create(const Path& path, FileNode::Mode mode)
    {
       String file = buildFileName(_volume,path);
       
-      if (mkdir(file.c_str(),S_IRWXU | S_IRWXG | S_IRWXO))
+      if (mkdir(file.c_str(),S_IRWXU | S_IRWXG | S_IRWXO) == 0)
          return new PosixDirectory(path,file);
    }
    

From 72b31f6f6bf4e7aceb89c324e020269b1420f26a Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Fri, 22 Oct 2021 10:44:54 -0400
Subject: [PATCH 212/399] * BugFix: Correct a crash caused by sfxProfile due to
 returning an address to a temporary value in getSoundFileName.

---
 Engine/source/sfx/sfxProfile.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Engine/source/sfx/sfxProfile.h b/Engine/source/sfx/sfxProfile.h
index 4480e64de..e26079c8e 100644
--- a/Engine/source/sfx/sfxProfile.h
+++ b/Engine/source/sfx/sfxProfile.h
@@ -154,7 +154,7 @@ class SFXProfile : public SFXTrack
       void unpackData( BitStream* stream );
 
       /// Returns the sound filename.
-      const String& getSoundFileName() const { return mFilename; }
+      const String getSoundFileName() const { return mFilename; }
       void setSoundFileName(StringTableEntry filename) { mFilename = filename; }
 
       bool getPreload() const { return mPreload; }

From 42bc6fa3580b5f3dae58bbb4efe88e7093e55e48 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Tue, 26 Oct 2021 12:32:37 -0500
Subject: [PATCH 213/399] differentiate forward lit and deferred ibl vars since
 we're not currently using the same arrays et al for the whole pass, need to
 make sure those don't fight

---
 .../source/renderInstance/renderProbeMgr.cpp  |  4 ++--
 .../shaderGen/GLSL/shaderFeatureGLSL.cpp      | 16 +++++++--------
 .../shaderGen/HLSL/debugVizFeatureHLSL.cpp    | 16 +++++++--------
 .../shaderGen/HLSL/shaderFeatureHLSL.cpp      | 20 +++++++++----------
 Engine/source/shaderGen/shaderGenVars.cpp     | 15 +++++++-------
 .../advanced/gl/reflectionProbeArrayP.glsl    |  8 ++++----
 .../advanced/reflectionProbeArrayP.hlsl       |  8 ++++----
 7 files changed, 44 insertions(+), 43 deletions(-)

diff --git a/Engine/source/renderInstance/renderProbeMgr.cpp b/Engine/source/renderInstance/renderProbeMgr.cpp
index 7b9126302..d39048971 100644
--- a/Engine/source/renderInstance/renderProbeMgr.cpp
+++ b/Engine/source/renderInstance/renderProbeMgr.cpp
@@ -780,8 +780,8 @@ void RenderProbeMgr::render( SceneRenderState *state )
 
    mProbeArrayEffect->setShaderConst("$probeContribColors", contribColors);
 
-   mProbeArrayEffect->setShaderConst("$inProbePosArray", mProbeData.probePositionArray);
-   mProbeArrayEffect->setShaderConst("$inRefPosArray", mProbeData.probeRefPositionArray);
+   mProbeArrayEffect->setShaderConst("$probePosArray", mProbeData.probePositionArray);
+   mProbeArrayEffect->setShaderConst("$refPosArray", mProbeData.probeRefPositionArray);
    mProbeArrayEffect->setShaderConst("$worldToObjArray", mProbeData.probeWorldToObjArray);
    mProbeArrayEffect->setShaderConst("$refScaleArray", mProbeData.refScaleArray);
    mProbeArrayEffect->setShaderConst("$probeConfigData", mProbeData.probeConfigArray);
diff --git a/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp b/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
index 3c132bf55..69af7ef5c 100644
--- a/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
+++ b/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
@@ -2981,7 +2981,7 @@ void ReflectionProbeFeatGLSL::processPix(Vector<ShaderComponent*>& componentList
    //Reflection Probe WIP
    U32 MAX_FORWARD_PROBES = 4;
 
-   Var * numProbes = new Var("numProbes", "int");
+   Var * numProbes = new Var("inNumProbes", "int");
    numProbes->uniform = true;
    numProbes->constSortPos = cspPotentialPrimitive;
 
@@ -2989,7 +2989,7 @@ void ReflectionProbeFeatGLSL::processPix(Vector<ShaderComponent*>& componentList
    cubeMips->uniform = true;
    cubeMips->constSortPos = cspPotentialPrimitive;
 
-   Var * skylightCubemapIdx = new Var("skylightCubemapIdx", "float");
+   Var * skylightCubemapIdx = new Var("inSkylightCubemapIdx", "float");
    skylightCubemapIdx->uniform = true;
    skylightCubemapIdx->constSortPos = cspPotentialPrimitive;
 
@@ -3008,12 +3008,12 @@ void ReflectionProbeFeatGLSL::processPix(Vector<ShaderComponent*>& componentList
    refScaleArray->uniform = true;
    refScaleArray->constSortPos = cspPotentialPrimitive;
 
-   Var * probeConfigData = new Var("probeConfigData", "vec4");
+   Var * probeConfigData = new Var("inProbeConfigData", "vec4");
    probeConfigData->arraySize = MAX_FORWARD_PROBES;
    probeConfigData->uniform = true;
    probeConfigData->constSortPos = cspPotentialPrimitive;
 
-   Var * worldToObjArray = new Var("worldToObjArray", "mat4");
+   Var * worldToObjArray = new Var("inWorldToObjArray", "mat4");
    worldToObjArray->arraySize = MAX_FORWARD_PROBES;
    worldToObjArray->uniform = true;
    worldToObjArray->constSortPos = cspPotentialPrimitive;
@@ -3026,12 +3026,12 @@ void ReflectionProbeFeatGLSL::processPix(Vector<ShaderComponent*>& componentList
    BRDFTexture->sampler = true;
    BRDFTexture->constNum = Var::getTexUnitNum();     // used as texture unit num here
    
-   Var * specularCubemapAR = new Var("specularCubemapAR", "samplerCubeArray");
+   Var * specularCubemapAR = new Var("inSpecularCubemapAR", "samplerCubeArray");
    specularCubemapAR->uniform = true;
    specularCubemapAR->sampler = true;
    specularCubemapAR->constNum = Var::getTexUnitNum();
 
-   Var * irradianceCubemapAR = new Var("irradianceCubemapAR", "samplerCubeArray");
+   Var * irradianceCubemapAR = new Var("inIrradianceCubemapAR", "samplerCubeArray");
    irradianceCubemapAR->uniform = true;
    irradianceCubemapAR->sampler = true;
    irradianceCubemapAR->constNum = Var::getTexUnitNum();
@@ -3078,9 +3078,9 @@ void ReflectionProbeFeatGLSL::setTexData(Material::StageData& stageDat,
       passData.mSamplerNames[texIndex] = "BRDFTexture";
       passData.mTexType[texIndex++] = Material::Standard;
       // assuming here that it is a scenegraph cubemap
-      passData.mSamplerNames[texIndex] = "specularCubemapAR";
+      passData.mSamplerNames[texIndex] = "inSpecularCubemapAR";
       passData.mTexType[texIndex++] = Material::SGCube;
-      passData.mSamplerNames[texIndex] = "irradianceCubemapAR";
+      passData.mSamplerNames[texIndex] = "inIrradianceCubemapAR";
       passData.mTexType[texIndex++] = Material::SGCube;
    }
 }
diff --git a/Engine/source/shaderGen/HLSL/debugVizFeatureHLSL.cpp b/Engine/source/shaderGen/HLSL/debugVizFeatureHLSL.cpp
index fe2fdb3af..ff746c076 100644
--- a/Engine/source/shaderGen/HLSL/debugVizFeatureHLSL.cpp
+++ b/Engine/source/shaderGen/HLSL/debugVizFeatureHLSL.cpp
@@ -135,24 +135,24 @@ void DebugVizHLSL::processPix(Vector<ShaderComponent*>& componentList,
       //Reflection Probe WIP
       U32 MAX_FORWARD_PROBES = 4;
 
-      Var* numProbes = (Var*)LangElement::find("numProbes");
+      Var* numProbes = (Var*)LangElement::find("inNumProbes");
       Var* cubeMips = (Var*)LangElement::find("cubeMips");
-      Var* skylightCubemapIdx = (Var*)LangElement::find("skylightCubemapIdx");
+      Var* skylightCubemapIdx = (Var*)LangElement::find("inSkylightCubemapIdx");
       Var* inProbePosArray = (Var*)LangElement::find("inProbePosArray");
       Var* inRefPosArray = (Var*)LangElement::find("inRefPosArray");
       Var* refScaleArray = (Var*)LangElement::find("inRefScale");
 
-      Var* probeConfigData = (Var*)LangElement::find("probeConfigData");
-      Var* worldToObjArray = (Var*)LangElement::find("worldToObjArray");
+      Var* probeConfigData = (Var*)LangElement::find("inProbeConfigData");
+      Var* worldToObjArray = (Var*)LangElement::find("inWorldToObjArray");
 
       Var* BRDFTexture = (Var*)LangElement::find("BRDFTexture");
       Var* BRDFTextureTex = (Var*)LangElement::find("texture_BRDFTexture");
 
-      Var* specularCubemapAR = (Var*)LangElement::find("specularCubemapAR");
-      Var* specularCubemapARTex = (Var*)LangElement::find("texture_specularCubemapAR");
+      Var* specularCubemapAR = (Var*)LangElement::find("inSpecularCubemapAR");
+      Var* specularCubemapARTex = (Var*)LangElement::find("texture_inSpecularCubemapAR");
 
-      Var* irradianceCubemapAR = (Var*)LangElement::find("irradianceCubemapAR");
-      Var* irradianceCubemapARTex = (Var*)LangElement::find("texture_irradianceCubemapAR");
+      Var* irradianceCubemapAR = (Var*)LangElement::find("inIrradianceCubemapAR");
+      Var* irradianceCubemapARTex = (Var*)LangElement::find("texture_inIrradianceCubemapAR");
 
       Var* matinfo = (Var*)LangElement::find("ORMConfig");
       Var* metalness = (Var*)LangElement::find("metalness");
diff --git a/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp b/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
index 48a20d835..c53e939e0 100644
--- a/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
+++ b/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
@@ -3054,7 +3054,7 @@ void ReflectionProbeFeatHLSL::processPix(Vector<ShaderComponent*> &componentList
    //Reflection Probe WIP
    U32 MAX_FORWARD_PROBES = 4;
 
-   Var *numProbes = new Var("numProbes", "int");
+   Var *numProbes = new Var("inNumProbes", "int");
    numProbes->uniform = true;
    numProbes->constSortPos = cspPotentialPrimitive;
 
@@ -3062,7 +3062,7 @@ void ReflectionProbeFeatHLSL::processPix(Vector<ShaderComponent*> &componentList
    cubeMips->uniform = true;
    cubeMips->constSortPos = cspPotentialPrimitive;
 
-   Var * skylightCubemapIdx = new Var("skylightCubemapIdx", "float");
+   Var * skylightCubemapIdx = new Var("inSkylightCubemapIdx", "float");
    skylightCubemapIdx->uniform = true;
    skylightCubemapIdx->constSortPos = cspPotentialPrimitive;
 
@@ -3081,12 +3081,12 @@ void ReflectionProbeFeatHLSL::processPix(Vector<ShaderComponent*> &componentList
    refScaleArray->uniform = true;
    refScaleArray->constSortPos = cspPotentialPrimitive;
 
-   Var *probeConfigData = new Var("probeConfigData", "float4");
+   Var *probeConfigData = new Var("inProbeConfigData", "float4");
    probeConfigData->arraySize = MAX_FORWARD_PROBES;
    probeConfigData->uniform = true;
    probeConfigData->constSortPos = cspPotentialPrimitive;
 
-   Var *worldToObjArray = new Var("worldToObjArray", "float4x4");
+   Var *worldToObjArray = new Var("inWorldToObjArray", "float4x4");
    worldToObjArray->arraySize = MAX_FORWARD_PROBES;
    worldToObjArray->uniform = true;
    worldToObjArray->constSortPos = cspPotentialPrimitive;
@@ -3101,22 +3101,22 @@ void ReflectionProbeFeatHLSL::processPix(Vector<ShaderComponent*> &componentList
    BRDFTextureTex->texture = true;
    BRDFTextureTex->constNum = BRDFTexture->constNum;
 
-   Var *specularCubemapAR = new Var("specularCubemapAR", "SamplerState");
+   Var *specularCubemapAR = new Var("inSpecularCubemapAR", "SamplerState");
    specularCubemapAR->uniform = true;
    specularCubemapAR->sampler = true;
    specularCubemapAR->constNum = Var::getTexUnitNum();     // used as texture unit num here
 
-   Var *specularCubemapARTex = new Var("texture_specularCubemapAR", "TextureCubeArray");
+   Var *specularCubemapARTex = new Var("texture_inSpecularCubemapAR", "TextureCubeArray");
    specularCubemapARTex->uniform = true;
    specularCubemapARTex->texture = true;
    specularCubemapARTex->constNum = specularCubemapAR->constNum;
 
-   Var *irradianceCubemapAR = new Var("irradianceCubemapAR", "SamplerState");
+   Var *irradianceCubemapAR = new Var("inIrradianceCubemapAR", "SamplerState");
    irradianceCubemapAR->uniform = true;
    irradianceCubemapAR->sampler = true;
    irradianceCubemapAR->constNum = Var::getTexUnitNum();     // used as texture unit num here
 
-   Var *irradianceCubemapARTex = new Var("texture_irradianceCubemapAR", "TextureCubeArray");
+   Var *irradianceCubemapARTex = new Var("texture_inIrradianceCubemapAR", "TextureCubeArray");
    irradianceCubemapARTex->uniform = true;
    irradianceCubemapARTex->texture = true;
    irradianceCubemapARTex->constNum = irradianceCubemapAR->constNum;
@@ -3171,9 +3171,9 @@ void ReflectionProbeFeatHLSL::setTexData(Material::StageData &stageDat,
       passData.mSamplerNames[texIndex] = "BRDFTexture";
       passData.mTexType[texIndex++] = Material::Standard;
       // assuming here that it is a scenegraph cubemap
-      passData.mSamplerNames[texIndex] = "specularCubemapAR";
+      passData.mSamplerNames[texIndex] = "inSpecularCubemapAR";
       passData.mTexType[texIndex++] = Material::SGCube;
-      passData.mSamplerNames[texIndex] = "irradianceCubemapAR";
+      passData.mSamplerNames[texIndex] = "inIrradianceCubemapAR";
       passData.mTexType[texIndex++] = Material::SGCube;
    }
 }
diff --git a/Engine/source/shaderGen/shaderGenVars.cpp b/Engine/source/shaderGen/shaderGenVars.cpp
index 6a933319d..7aec7b82b 100644
--- a/Engine/source/shaderGen/shaderGenVars.cpp
+++ b/Engine/source/shaderGen/shaderGenVars.cpp
@@ -78,20 +78,21 @@ const String ShaderGenVars::roughness("$roughness");
 const String ShaderGenVars::metalness("$metalness");
 const String ShaderGenVars::glowMul("$glowMul");
 
-//Reflection Probes
+//Reflection Probes - Forward lit. not to be confused with the deferred handwritten vars
+//change to parity once we've got the same arrays used for both routes
 const String ShaderGenVars::probePosition("$inProbePosArray");
 const String ShaderGenVars::probeRefPos("$inRefPosArray");
 const String ShaderGenVars::refScale("$inRefScale");
-const String ShaderGenVars::worldToObjArray("$worldToObjArray");
-const String ShaderGenVars::probeConfigData("$probeConfigData");
-const String ShaderGenVars::specularCubemapAR("$specularCubemapAR");
-const String ShaderGenVars::irradianceCubemapAR("$irradianceCubemapAR");
-const String ShaderGenVars::probeCount("$numProbes");
+const String ShaderGenVars::worldToObjArray("inWorldToObjArray");
+const String ShaderGenVars::probeConfigData("$inProbeConfigData");
+const String ShaderGenVars::specularCubemapAR("$inSpecularCubemapAR");
+const String ShaderGenVars::irradianceCubemapAR("$inIrradianceCubemapAR");
+const String ShaderGenVars::probeCount("$inNumProbes");
 
 const String ShaderGenVars::BRDFTextureMap("$BRDFTexture");
 
 //Skylight
-const String ShaderGenVars::skylightCubemapIdx("$skylightCubemapIdx");
+const String ShaderGenVars::skylightCubemapIdx("$inSkylightCubemapIdx");
 
 // These are ignored by the D3D layers.
 const String ShaderGenVars::fogMap("$fogMap");
diff --git a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/reflectionProbeArrayP.glsl b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/reflectionProbeArrayP.glsl
index 9abc5f3d5..c5ffd6f67 100644
--- a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/reflectionProbeArrayP.glsl
+++ b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/reflectionProbeArrayP.glsl
@@ -30,8 +30,8 @@ uniform sampler2D ssaoMask;
 uniform vec4 rtParams6;
 #endif
 
-uniform vec4    inProbePosArray[MAX_PROBES];
-uniform vec4    inRefPosArray[MAX_PROBES];
+uniform vec4    probePosArray[MAX_PROBES];
+uniform vec4    refPosArray[MAX_PROBES];
 uniform mat4    worldToObjArray[MAX_PROBES];
 uniform vec4    refScaleArray[MAX_PROBES];
 uniform vec4    probeConfigData[MAX_PROBES];   //r,g,b/mode,radius,atten
@@ -92,7 +92,7 @@ void main()
          }
          else if (probeConfigData[i].r == 1) //sphere
          {
-            contribution[i] = defineSphereSpaceInfluence(surface.P, inProbePosArray[i].xyz, probeConfigData[i].g);
+            contribution[i] = defineSphereSpaceInfluence(surface.P, probePosArray[i].xyz, probeConfigData[i].g);
             if (contribution[i]>0.0)
                probehits++;
          }
@@ -179,7 +179,7 @@ void main()
       if (contrib > 0.0f)
       {
          float cubemapIdx = probeConfigData[i].a;
-         vec3 dir = boxProject(surface.P, surface.R, worldToObjArray[i], refScaleArray[i].xyz, inRefPosArray[i].xyz);
+         vec3 dir = boxProject(surface.P, surface.R, worldToObjArray[i], refScaleArray[i].xyz, refPosArray[i].xyz);
 
          irradiance += textureLod(irradianceCubemapAR, vec4(dir, cubemapIdx), 0).xyz * contrib;
          specular += textureLod(specularCubemapAR, vec4(dir, cubemapIdx), lod).xyz * contrib;
diff --git a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/reflectionProbeArrayP.hlsl b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/reflectionProbeArrayP.hlsl
index 36ef1a766..aaff0145b 100644
--- a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/reflectionProbeArrayP.hlsl
+++ b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/reflectionProbeArrayP.hlsl
@@ -27,8 +27,8 @@ TORQUE_UNIFORM_SAMPLER2D(ssaoMask, 6);
 uniform float4 rtParams6;
 #endif
 
-uniform float4    inProbePosArray[MAX_PROBES];
-uniform float4    inRefPosArray[MAX_PROBES];
+uniform float4    probePosArray[MAX_PROBES];
+uniform float4    refPosArray[MAX_PROBES];
 uniform float4x4  worldToObjArray[MAX_PROBES];
 uniform float4    refScaleArray[MAX_PROBES];
 uniform float4    probeConfigData[MAX_PROBES];   //r,g,b/mode,radius,atten
@@ -86,7 +86,7 @@ float4 main(PFXVertToPix IN) : SV_TARGET
          }
          else if (probeConfigData[i].r == 1) //sphere
          {
-            contribution[i] = defineSphereSpaceInfluence(surface.P, inProbePosArray[i].xyz, probeConfigData[i].g);
+            contribution[i] = defineSphereSpaceInfluence(surface.P, probePosArray[i].xyz, probeConfigData[i].g);
             if (contribution[i]>0.0)
                probehits++;
          }
@@ -171,7 +171,7 @@ float4 main(PFXVertToPix IN) : SV_TARGET
       if (contrib > 0.0f)
       {
          int cubemapIdx = probeConfigData[i].a;
-         float3 dir = boxProject(surface.P, surface.R, worldToObjArray[i], refScaleArray[i].xyz, inRefPosArray[i].xyz);
+         float3 dir = boxProject(surface.P, surface.R, worldToObjArray[i], refScaleArray[i].xyz, refPosArray[i].xyz);
 
          irradiance += TORQUE_TEXCUBEARRAYLOD(irradianceCubemapAR, dir, cubemapIdx, 0).xyz * contrib;
          specular += TORQUE_TEXCUBEARRAYLOD(specularCubemapAR, dir, cubemapIdx, lod).xyz * contrib;

From bf646b604f5f3296d243ec26f28eb925b35ee273 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Tue, 26 Oct 2021 17:47:19 -0500
Subject: [PATCH 214/399] typofix for impoerter

---
 .../scripts/pre40/T3Dpre4ProjectImporter.tscript                | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
index 78cdfecf8..82d11595e 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
@@ -961,7 +961,7 @@ $MaterialEntriesList = "baseTex diffuseMapAsset diffuseMap diffuseMapAsset";
 $MaterialEntriesList = $MaterialEntriesList SPC "lightMap lightMapAsset toneMap toneMapAsset";
 $MaterialEntriesList = $MaterialEntriesList SPC "detailTex detailMapAsset detailMap detailMapAsset detailNormalMap detailNormalMapAsset";
 $MaterialEntriesList = $MaterialEntriesList SPC "overlayTex overlayMapAsset overlayMap overlayMapAsset";
-$MaterialEntriesList = $MaterialEntriesList SPC "bumpTex normalMapAsset normalMap normalMapAsset
+$MaterialEntriesList = $MaterialEntriesList SPC "bumpTex normalMapAsset normalMap normalMapAsset";
 $MaterialEntriesList = $MaterialEntriesList SPC "ormConfigMap ormConfigMapAsset roughMap roughMapAsset";
 $MaterialEntriesList = $MaterialEntriesList SPC "aoMap aoMapAsset metalMap metalMapAsset";
 $MaterialEntriesList = $MaterialEntriesList SPC "glowMap glowMapAsset";

From 8685173207adb21a2227e71be02145b0ef875011 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Wed, 27 Oct 2021 16:01:37 -0500
Subject: [PATCH 215/399] typofix

---
 Engine/source/shaderGen/shaderGenVars.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Engine/source/shaderGen/shaderGenVars.cpp b/Engine/source/shaderGen/shaderGenVars.cpp
index 7aec7b82b..839a4c36b 100644
--- a/Engine/source/shaderGen/shaderGenVars.cpp
+++ b/Engine/source/shaderGen/shaderGenVars.cpp
@@ -83,7 +83,7 @@ const String ShaderGenVars::glowMul("$glowMul");
 const String ShaderGenVars::probePosition("$inProbePosArray");
 const String ShaderGenVars::probeRefPos("$inRefPosArray");
 const String ShaderGenVars::refScale("$inRefScale");
-const String ShaderGenVars::worldToObjArray("inWorldToObjArray");
+const String ShaderGenVars::worldToObjArray("$inWorldToObjArray");
 const String ShaderGenVars::probeConfigData("$inProbeConfigData");
 const String ShaderGenVars::specularCubemapAR("$inSpecularCubemapAR");
 const String ShaderGenVars::irradianceCubemapAR("$inIrradianceCubemapAR");

From 6b56210a4796b17d0c190570a52e032c6f3729cc Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Wed, 27 Oct 2021 17:30:43 -0400
Subject: [PATCH 216/399] * Feature: Properly detect ARM32/ARM64 in the CMake
 build process and enable ARM NEON when either of these are detected.

---
 Tools/CMake/basics.cmake         | 17 +++++++++++++----
 Tools/CMake/libraries/lpng.cmake | 14 +++++++++-----
 2 files changed, 22 insertions(+), 9 deletions(-)

diff --git a/Tools/CMake/basics.cmake b/Tools/CMake/basics.cmake
index a9004b7ba..9a88a9d82 100644
--- a/Tools/CMake/basics.cmake
+++ b/Tools/CMake/basics.cmake
@@ -22,10 +22,19 @@
 
 project("Torque3DEngine")
 
-if( CMAKE_CXX_SIZEOF_DATA_PTR EQUAL 8 )
-    set( TORQUE_CPU_X64 ON )
-elseif( CMAKE_CXX_SIZEOF_DATA_PTR EQUAL 4 )
-    set( TORQUE_CPU_X32 ON )
+# Detect 32bit and 64bit x86/ARM
+if (CMAKE_SYSTEM_PROCESSOR MATCHES "arm")
+    if( CMAKE_CXX_SIZEOF_DATA_PTR EQUAL 8 )
+        set( TORQUE_CPU_ARM64 ON )
+    elseif( CMAKE_CXX_SIZEOF_DATA_PTR EQUAL 4 )
+        set( TORQUE_CPU_ARM32 ON )
+    endif()
+else()
+    if( CMAKE_CXX_SIZEOF_DATA_PTR EQUAL 8 )
+        set( TORQUE_CPU_X64 ON )
+    elseif( CMAKE_CXX_SIZEOF_DATA_PTR EQUAL 4 )
+        set( TORQUE_CPU_X32 ON )
+    endif()
 endif()
 
 if(NOT TORQUE_TEMPLATE)
diff --git a/Tools/CMake/libraries/lpng.cmake b/Tools/CMake/libraries/lpng.cmake
index 0d4307239..480e6c2b6 100644
--- a/Tools/CMake/libraries/lpng.cmake
+++ b/Tools/CMake/libraries/lpng.cmake
@@ -24,13 +24,17 @@ project(lpng)
 
 # addDef(PNG_NO_ASSEMBLER_CODE)
 
-# Issues with Neon at the moment (Arm support)
-# https://sourceforge.net/p/libpng/bugs/281/
-set(PNG_ARM_NEON off CACHE STRING "")
-add_definitions(-DPNG_ARM_NEON_OPT=0)
+# Enables NEON for libpng
+if ( TORQUE_CPU_ARM32 OR TORQUE_CPU_ARM64 )
+    set(PNG_INTEL_NEON on CACHE STRING "")
+    add_definitions(-DPNG_ARM_NEON_OPT=1)
+    addPath("${libDir}/lpng/arm")
+else()
+    set(PNG_ARM_NEON off CACHE STRING "")
+    add_definitions(-DPNG_ARM_NEON_OPT=0)
+endif()
 
 # Enables SSE for libpng - also takes care of compiler warnings.
-# If we don't want SSE, we should set it to off/0.
 if ( TORQUE_CPU_X32 OR TORQUE_CPU_X64 )
     set(PNG_INTEL_SSE on CACHE STRING "")
     add_definitions(-DPNG_INTEL_SSE_OPT=1)

From 9d2e95a1b19fdbfd48ee1666bf67b1c60bdc29b8 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Thu, 28 Oct 2021 10:30:43 -0400
Subject: [PATCH 217/399] * BugFix: Correct the usage of a local variable in a
 non-function scope in the set object locked dropdown item when right clicking
 in the inspector.

---
 .../game/tools/worldEditor/scripts/EditorGui.ed.tscript         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
index 38b5c72d8..d68fa2258 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
@@ -1678,7 +1678,7 @@ function EditorTree::onRightMouseUp( %this, %itemId, %mouse, %obj )
          %popup.item[ 1 ] = "Delete" TAB "" TAB "EWorldEditor.deleteMissionObject(" @ %popup.object @ ");";
          %popup.item[ 2 ] = "Inspect" TAB "" TAB "inspectObject(" @ %popup.object @ ");";
          %popup.item[ 3 ] = "-";
-         %popup.item[ 4 ] = "Locked" TAB "" TAB "%this.object.setLocked( !" @ %popup.object @ ".locked ); EWorldEditor.syncGui();";
+         %popup.item[ 4 ] = "Locked" TAB "" TAB %popup.object @ ".setLocked( !" @ %popup.object @ ".locked ); EWorldEditor.syncGui();";
          %popup.item[ 5 ] = "Hidden" TAB "" TAB "EWorldEditor.hideObject( " @ %popup.object @ ", !" @ %popup.object @ ".hidden ); EWorldEditor.syncGui();";
          %popup.item[ 6 ] = "-";
          %popup.item[ 7 ] = "Group" TAB "" TAB "EWorldEditor.addSimGroup( true );";

From 5c83b417a5c8299b1679cc7075c2782aba702b11 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Thu, 28 Oct 2021 10:40:13 -0400
Subject: [PATCH 218/399] * [GuiControl] BugFix: Don't assume a tooltip profile
 is going to be set when waking and sleeping.

---
 Engine/source/gui/core/guiControl.cpp | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/Engine/source/gui/core/guiControl.cpp b/Engine/source/gui/core/guiControl.cpp
index d312c7610..5f20c4302 100644
--- a/Engine/source/gui/core/guiControl.cpp
+++ b/Engine/source/gui/core/guiControl.cpp
@@ -843,7 +843,11 @@ bool GuiControl::onWake()
 
    //increment the profile
    mProfile->incLoadCount();
-   mTooltipProfile->incLoadCount();
+
+   if (mTooltipProfile)
+   {
+       mTooltipProfile->incLoadCount();
+   }
 
    // Only invoke script callbacks if we have a namespace in which to do so
    // This will suppress warnings
@@ -869,7 +873,11 @@ void GuiControl::onSleep()
 
    //decrement the profile reference
    mProfile->decLoadCount();
-   mTooltipProfile->decLoadCount();
+
+   if (mTooltipProfile)
+   {
+       mTooltipProfile->decLoadCount();
+   }
 
    // Set Flag
    mAwake = false;

From 0fab2ebf54bc3ae652a2bc657f9d60286f6ac9d1 Mon Sep 17 00:00:00 2001
From: Areloch <Areloch@gmail.com>
Date: Thu, 28 Oct 2021 23:52:58 -0500
Subject: [PATCH 219/399] Added fallback handling to MaterialAssets if the
 asset was found but the matDef was not Added import config handling for
 prepending Directory to asset name Added handling for import config of
 appending a sound suffix Integrated handling of directory prepend and asset
 type suffix to rename issue resolution of asset importing Corrected
 miswording of warn message for duplicate object names Correct GUI issues with
 verve tools Convert verve tools to utilize assets for their GUI elements Fix
 window binding/naming issue depending on window mode for verve Fix popup
 menus formatting for verve WIP fix for material swap in Material editor.
 Corrects crash, but swap action is unreliable depending on object type Fix
 display issue with mission area editor toolbar button image Fix tooltip
 display of SFXEmitters in editor tree to correctly show the bound asset
 Changed network graph accelerator keybind from just N to Ctrl N to avoid
 keybind issues when typing Fixed Create New Emitter button in particle
 emitter that was showing as no texture

---
 Engine/source/T3D/assets/MaterialAsset.cpp    |   6 +
 Engine/source/T3D/assets/assetImporter.cpp    |  87 ++-
 Engine/source/T3D/assets/assetImporter.h      |  32 +
 Engine/source/console/simDictionary.cpp       |   2 +-
 .../tools/VerveEditor/GUI/GuiProfiles.tscript |   2 +-
 .../tools/VerveEditor/GUI/VerveEditor.gui     |  70 +-
 .../GUI/VerveEditorGroupBuilder.gui           |  54 +-
 .../GUI/VerveEditorImportPathNodes.gui        |  24 +-
 .../GUI/VerveEditorPreferences.gui            |  64 +-
 .../Controller/VControllerProperties.tscript  |   8 +-
 .../VerveEditor/Scripts/EditorMenu.tscript    |  42 +-
 .../VerveEditor/Scripts/EditorWindow.tscript  |  32 +-
 .../VerveEditor/Scripts/Groups/VGroup.tscript |  12 +-
 .../Scripts/Inspector/Controls.tscript        |   4 +-
 .../Scripts/Inspector/Fields/TypeData.tscript |   4 +-
 .../Scripts/Inspector/Selection.tscript       |   3 +-
 .../Scripts/Tracks/VMotionTrack.tscript       |  12 +-
 .../VerveEditor/Scripts/Tracks/VTrack.tscript |  10 +-
 .../game/tools/VerveEditor/main.tscript       |   5 +-
 .../tools/assetBrowser/assetImportConfigs.xml | 638 ++++++------------
 .../scripts/assetImportConfig.tscript         |   7 +-
 .../scripts/assetImportConfigEditor.tscript   |   4 +-
 .../tools/gui/images/stencilIcons/larger.png  | Bin 0 -> 15389 bytes
 .../stencilIcons/larger_image.asset.taml      |   8 +
 .../tools/gui/images/stencilIcons/smaller.png | Bin 0 -> 15374 bytes
 .../stencilIcons/smaller_image.asset.taml     |   8 +
 .../game/tools/gui/profiles.ed.tscript        |   3 +-
 .../gui/guiMaterialPropertiesWindow.ed.gui    |   2 +-
 .../scripts/materialEditor.ed.tscript         |  69 +-
 .../images/mission-area_h.png                 | Bin 1218 -> 1254 bytes
 .../images/mission-area_n.png                 | Bin 845 -> 1472 bytes
 .../particleEditor/ParticleEditor.ed.gui      |   2 +-
 .../worldEditor/scripts/EditorGui.ed.tscript  |  10 +-
 .../worldEditor/scripts/menus.ed.tscript      |   2 +-
 34 files changed, 590 insertions(+), 636 deletions(-)
 create mode 100644 Templates/BaseGame/game/tools/gui/images/stencilIcons/larger.png
 create mode 100644 Templates/BaseGame/game/tools/gui/images/stencilIcons/larger_image.asset.taml
 create mode 100644 Templates/BaseGame/game/tools/gui/images/stencilIcons/smaller.png
 create mode 100644 Templates/BaseGame/game/tools/gui/images/stencilIcons/smaller_image.asset.taml

diff --git a/Engine/source/T3D/assets/MaterialAsset.cpp b/Engine/source/T3D/assets/MaterialAsset.cpp
index 50e75ffa3..e51f9a709 100644
--- a/Engine/source/T3D/assets/MaterialAsset.cpp
+++ b/Engine/source/T3D/assets/MaterialAsset.cpp
@@ -319,6 +319,12 @@ U32 MaterialAsset::getAssetByMaterialName(StringTableEntry matName, AssetPtr<Mat
          AssetDatabase.releaseAsset(query.mAssetList[i]); //cleanup if that's not the one we needed
       }
    }
+
+   //Somehow we failed to bind an asset, so just use the fallback and mark the failure
+   matAsset->setAssetId(MaterialAsset::smNoMaterialAssetFallback);
+   (*matAsset)->mLoadedState = AssetErrCode::UsingFallback;
+   return AssetErrCode::UsingFallback;
+
 }
 
 StringTableEntry MaterialAsset::getAssetIdByMaterialName(StringTableEntry matName)
diff --git a/Engine/source/T3D/assets/assetImporter.cpp b/Engine/source/T3D/assets/assetImporter.cpp
index e9afcc479..8dc898dae 100644
--- a/Engine/source/T3D/assets/assetImporter.cpp
+++ b/Engine/source/T3D/assets/assetImporter.cpp
@@ -104,7 +104,9 @@ AssetImportConfig::AssetImportConfig() :
    importSounds(true),
    VolumeAdjust(false),
    PitchAdjust(false),
-   SoundsCompressed(false)
+   SoundsCompressed(false),
+   AlwaysAddSoundSuffix(false),
+   AddedSoundSuffix("_sound")
 {
 }
 
@@ -316,6 +318,8 @@ void AssetImportConfig::loadImportConfig(Settings* configSettings, String config
    VolumeAdjust = dAtof(configSettings->value(String(configName + "/Sounds/VolumeAdjust").c_str()));
    PitchAdjust = dAtof(configSettings->value(String(configName + "/Sounds/PitchAdjust").c_str()));
    SoundsCompressed = dAtob(configSettings->value(String(configName + "/Sounds/Compressed").c_str()));
+   AlwaysAddSoundSuffix = dAtob(configSettings->value(String(configName + "/Sounds/AlwaysAddSoundSuffix").c_str()));
+   AddedSoundSuffix = configSettings->value(String(configName + "/Sounds/AddedSoundSuffix").c_str());
 }
 
 void AssetImportConfig::CopyTo(AssetImportConfig* target) const
@@ -406,6 +410,8 @@ void AssetImportConfig::CopyTo(AssetImportConfig* target) const
    target->VolumeAdjust = VolumeAdjust;
    target->PitchAdjust = PitchAdjust;
    target->SoundsCompressed = SoundsCompressed;
+   target->AlwaysAddSoundSuffix = AlwaysAddSoundSuffix;
+   target->AddedSoundSuffix = AddedSoundSuffix;
 }
 
 ConsoleDocClass(AssetImportObject,
@@ -607,6 +613,7 @@ AssetImportObject* AssetImporter::addImportingAsset(String assetType, Torque::Pa
    assetName.replace('*', '_');
    assetName.replace('-', '_');
    assetName.replace('+', '_');
+   assetName.replace('&', '_');
 
    assetImportObj->assetType = assetType;
    assetImportObj->filePath = filePath;
@@ -622,6 +629,14 @@ AssetImportObject* AssetImporter::addImportingAsset(String assetType, Torque::Pa
    assetImportObj->importStatus = AssetImportObject::NotProcessed;
    assetImportObj->generatedAsset = false;
 
+   //If the config is marked to always set the directory prefix, do that now
+   if (activeImportConfig->AddDirectoryPrefixToAssetName)
+   {
+      assetName = getFolderPrefixedName(assetImportObj);
+      assetImportObj->assetName = assetName;
+      assetImportObj->cleanAssetName = assetName;
+   }
+
    if (parentItem != nullptr)
    {
       dSprintf(importLogBuffer, sizeof(importLogBuffer), "Added Child Importing Asset to %s", parentItem->assetName.c_str());
@@ -1976,6 +1991,12 @@ void AssetImporter::processSoundAsset(AssetImportObject* assetItem)
    dSprintf(importLogBuffer, sizeof(importLogBuffer), "Preparing Sound for Import: %s", assetItem->assetName.c_str());
    activityLog.push_back(importLogBuffer);
 
+   if (activeImportConfig->AlwaysAddSoundSuffix)
+   {
+      assetItem->assetName += activeImportConfig->AddedSoundSuffix;
+      assetItem->cleanAssetName = assetItem->assetName;
+   }
+
    assetItem->importStatus = AssetImportObject::Processed;
 }
 
@@ -2165,7 +2186,49 @@ void AssetImporter::resolveAssetItemIssues(AssetImportObject* assetItem)
       {
          //Set trailing number
          String renamedAssetName = assetItem->assetName;
-         renamedAssetName = Sim::getUniqueName(renamedAssetName.c_str());
+         String renamedAssetId = assetItem->moduleName + ":" + renamedAssetName;
+
+         String addedSuffix;
+
+         if (assetItem->assetType == String("ShapeAsset"))
+            addedSuffix = activeImportConfig->AddedShapeSuffix;
+         else if (assetItem->assetType == String("MaterialAsset"))
+            addedSuffix = activeImportConfig->AddedMaterialSuffix;
+         else if (assetItem->assetType == String("ImageAsset"))
+            addedSuffix = activeImportConfig->AddedImageSuffix;
+         else if (assetItem->assetType == String("SoundAsset"))
+            addedSuffix = activeImportConfig->AddedSoundSuffix;
+
+         //do the suffix if it isn't already on it
+         if (!renamedAssetName.endsWith(addedSuffix.c_str()))
+         {
+            renamedAssetName += addedSuffix;
+            renamedAssetId = assetItem->moduleName + ":" + renamedAssetName;
+            assetItem->assetName = renamedAssetName;
+         }
+
+         //if still conflicted
+         //add the directory prefix
+         if (AssetDatabase.isDeclaredAsset(renamedAssetId.c_str()))
+         {
+            renamedAssetName = getFolderPrefixedName(assetItem);
+            renamedAssetId = assetItem->moduleName + ":" + renamedAssetName;
+            assetItem->assetName = renamedAssetName;
+         }
+
+         bool appendedNumber = false;
+         U32 uniqueNumber = 0;
+         while (AssetDatabase.isDeclaredAsset(renamedAssetId.c_str()))
+         {
+            uniqueNumber++;
+            renamedAssetId = assetItem->moduleName + ":" + renamedAssetName + String::ToString(uniqueNumber);
+            appendedNumber = true;
+         }
+
+         if (appendedNumber)
+         {
+            renamedAssetName += String::ToString(uniqueNumber);
+         }
 
          //Log it's renaming
          dSprintf(importLogBuffer, sizeof(importLogBuffer), "Asset %s was renamed due to %s as part of the Import Configuration", assetItem->assetName.c_str(), humanReadableReason.c_str());
@@ -2186,25 +2249,7 @@ void AssetImporter::resolveAssetItemIssues(AssetImportObject* assetItem)
       }
       else if (activeImportConfig->DuplicateAutoResolution == String("FolderPrefix"))
       {
-         String renamedAssetName = assetItem->assetName;
-
-         //Set trailing number
-         S32 dirIndex = assetItem->filePath.getDirectoryCount() - 1;
-         while (dirIndex > -1)
-         {
-            renamedAssetName = assetItem->assetName;
-            String owningFolder = assetItem->filePath.getDirectory(dirIndex);
-
-            renamedAssetName = owningFolder + "_" + renamedAssetName;
-
-            if (AssetDatabase.isDeclaredAsset(renamedAssetName))
-            {
-               dirIndex--;
-               continue;
-            }
-
-            break;
-         }
+         String renamedAssetName = getFolderPrefixedName(assetItem);
 
          //Log it's renaming
          dSprintf(importLogBuffer, sizeof(importLogBuffer), "Asset %s was renamed due to %s as part of the Import Configuration", assetItem->assetName.c_str(), humanReadableReason.c_str());
diff --git a/Engine/source/T3D/assets/assetImporter.h b/Engine/source/T3D/assets/assetImporter.h
index b03c89c40..9505d00b1 100644
--- a/Engine/source/T3D/assets/assetImporter.h
+++ b/Engine/source/T3D/assets/assetImporter.h
@@ -409,6 +409,15 @@ public:
    /// </summary>
    bool SoundsCompressed;
 
+   /// When importing an image, this indicates if it should automatically add a standard suffix onto the name
+   /// </summary>
+   bool AlwaysAddSoundSuffix;
+
+   /// <summary>
+   /// If AlwaysAddSoundSuffix is on, this is the suffix to be added
+   /// </summary>
+   String AddedSoundSuffix;
+
 public:
    AssetImportConfig();
    virtual ~AssetImportConfig();
@@ -934,4 +943,27 @@ public:
    //
    void setTargetModuleId(const String& moduleId) { targetModuleId = moduleId; }
    const String& getTargetModuleId() { return targetModuleId; }
+
+   String getFolderPrefixedName(AssetImportObject* assetItem)
+   {
+      String renamedAssetName = assetItem->assetName;
+      S32 dirIndex = assetItem->filePath.getDirectoryCount() - 1;
+      while (dirIndex > -1)
+      {
+         renamedAssetName = assetItem->assetName;
+         String owningFolder = assetItem->filePath.getDirectory(dirIndex);
+
+         renamedAssetName = owningFolder + "_" + renamedAssetName;
+
+         if (AssetDatabase.isDeclaredAsset(renamedAssetName))
+         {
+            dirIndex--;
+            continue;
+         }
+
+         break;
+      }
+
+      return renamedAssetName;
+   }
 };
diff --git a/Engine/source/console/simDictionary.cpp b/Engine/source/console/simDictionary.cpp
index 93491fd1c..8730a89dd 100644
--- a/Engine/source/console/simDictionary.cpp
+++ b/Engine/source/console/simDictionary.cpp
@@ -53,7 +53,7 @@ void SimNameDictionary::insert(SimObject* obj)
    SimObject* checkForDup = find(obj->getName());
 
    if (checkForDup)
-      Con::warnf("Warning! You have a duplicate datablock name of %s. This can cause problems. You should rename one of them.", obj->getName());
+      Con::warnf("Warning! You have a duplicate object name of %s. This can cause problems. You should rename one of them.", obj->getName());
 
    Mutex::lockMutex(mutex);
 #ifndef USE_NEW_SIMDICTIONARY
diff --git a/Templates/BaseGame/game/tools/VerveEditor/GUI/GuiProfiles.tscript b/Templates/BaseGame/game/tools/VerveEditor/GUI/GuiProfiles.tscript
index f636bf413..3d7217100 100644
--- a/Templates/BaseGame/game/tools/VerveEditor/GUI/GuiProfiles.tscript
+++ b/Templates/BaseGame/game/tools/VerveEditor/GUI/GuiProfiles.tscript
@@ -92,7 +92,7 @@ singleton GuiControlProfile ( VEditorBitmapButtonProfile : VEditorDefaultProfile
     justify = "center";
     
     hasBitmapArray = true;
-    bitmap         = "./Images/Button";
+    bitmapAsset         = "ToolsModule:button_image";
 };
 
 //-----------------------------------------------------------------------------
diff --git a/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditor.gui b/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditor.gui
index 4c684b6ff..a11011a37 100644
--- a/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditor.gui
+++ b/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditor.gui
@@ -4,15 +4,15 @@ $guiContent = new GuiControl(VerveEditorGui) {
    Enabled = "1";
    isContainer = "1";
    Profile = "VEditorDefaultProfile";
-   HorizSizing = "right";
-   VertSizing = "bottom";
+   HorizSizing = "width";
+   VertSizing = "height";
    Position = "0 0";
    Extent = "1024 768";
    MinExtent = "8 2";
    canSave = "1";
    isDecoy = "0";
    Visible = "1";
-   tooltipprofile = "GuiToolTipProfile";
+   tooltipprofile = "ToolsGuiToolTipProfile";
    hovertime = "1000";
 
    new GuiControl() {
@@ -44,7 +44,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
          canSave = "1";
          isDecoy = "0";
          Visible = "1";
-         tooltipprofile = "GuiToolTipProfile";
+         tooltipprofile = "ToolsGuiToolTipProfile";
          hovertime = "1000";
          Margin = "0 0 0 0";
          Padding = "0 0 0 0";
@@ -80,7 +80,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
             canSave = "1";
             isDecoy = "0";
             Visible = "1";
-            tooltipprofile = "GuiToolTipProfile";
+            tooltipprofile = "ToolsGuiToolTipProfile";
             hovertime = "1000";
             
             new VEditorButton() {
@@ -96,7 +96,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
                  MinExtent = "210 1";
                  canSave = "1";
                  Visible = "1";
-                 tooltipprofile = "GuiToolTipProfile";
+                 tooltipprofile = "ToolsGuiToolTipProfile";
                  hovertime = "1000";
                  text = "";
                  groupNum = "-1";
@@ -122,7 +122,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
                canSave = "1";
                isDecoy = "0";
                Visible = "1";
-               tooltipprofile = "GuiToolTipProfile";
+               tooltipprofile = "ToolsGuiToolTipProfile";
                hovertime = "1000";
             };
          };
@@ -140,7 +140,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
          canSave = "1";
          isDecoy = "0";
          Visible = "1";
-         tooltipprofile = "GuiToolTipProfile";
+         tooltipprofile = "ToolsGuiToolTipProfile";
          hovertime = "1000";
          Margin = "0 0 0 0";
          Padding = "0 0 0 0";
@@ -176,7 +176,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
             canSave = "1";
             isDecoy = "0";
             Visible = "1";
-            tooltipprofile = "GuiToolTipProfile";
+            tooltipprofile = "ToolsGuiToolTipProfile";
             hovertime = "1000";
 
             new VTimeLineControl(VerveEditorTrackTimeLine) {
@@ -192,7 +192,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
                canSave = "1";
                isDecoy = "0";
                Visible = "1";
-               tooltipprofile = "GuiToolTipProfile";
+               tooltipprofile = "ToolsGuiToolTipProfile";
                hovertime = "1000";
                IsController = "0";
                Controller = "VerveEditorController";
@@ -211,7 +211,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
                      MinExtent = "8 8";
                      canSave = "1";
                      Visible = "1";
-                     tooltipprofile = "GuiToolTipProfile";
+                     tooltipprofile = "ToolsGuiToolTipProfile";
                      hovertime = "1000";
                      text = "";
                      groupNum = "-1";
@@ -237,7 +237,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
                     canSave = "1";
                     isDecoy = "0";
                     Visible = "1";
-                    tooltipprofile = "GuiToolTipProfile";
+                    tooltipprofile = "ToolsGuiToolTipProfile";
                     hovertime = "1000";
                 };
             };
@@ -256,7 +256,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
          canSave = "1";
          isDecoy = "0";
          Visible = "1";
-         tooltipprofile = "GuiDefaultProfile";
+         tooltipprofile = "ToolsGuiDefaultProfile";
          hovertime = "1000";
          Margin = "0 0 0 0";
          Padding = "0 0 0 0";
@@ -283,7 +283,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
             canSave = "1";
             isDecoy = "0";
             Visible = "1";
-            tooltipprofile = "GuiToolTipProfile";
+            tooltipprofile = "ToolsGuiToolTipProfile";
             hovertime = "1000";
 
              new GuiBitmapButtonCtrl(VerveEditorAddGroupButton) {
@@ -300,7 +300,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
                 canSave = "1";
                 isDecoy = "0";
                 Visible = "1";
-                tooltipprofile = "GuiToolTipProfile";
+                tooltipprofile = "ToolsGuiToolTipProfile";
                 tooltip = "Add New Group";
                 command = "$ThisControl.DisplayContextMenu();";
                 hovertime = "1000";
@@ -323,7 +323,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
                 canSave = "1";
                 isDecoy = "0";
                 Visible = "1";
-                tooltipprofile = "GuiToolTipProfile";
+                tooltipprofile = "ToolsGuiToolTipProfile";
                 tooltip = "Add New Track";
                 command = "$ThisControl.DisplayContextMenu();";
                 hovertime = "1000";
@@ -345,7 +345,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
                 canSave = "1";
                 isDecoy = "0";
                 Visible = "1";
-                tooltipprofile = "GuiToolTipProfile";
+                tooltipprofile = "ToolsGuiToolTipProfile";
                 tooltip = "Add New Event";
                 command = "VerveEditor::AddEvent();";
                 hovertime = "1000";
@@ -367,7 +367,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
                 canSave = "1";
                 isDecoy = "0";
                 Visible = "1";
-                tooltipprofile = "GuiToolTipProfile";
+                tooltipprofile = "ToolsGuiToolTipProfile";
                 tooltip = "Delete Selected Object(s)";
                 command = "VerveEditor::DeleteSelection();";
                 hovertime = "1000";
@@ -391,7 +391,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
          canSave = "1";
          isDecoy = "0";
          Visible = "1";
-         tooltipprofile = "GuiToolTipProfile";
+         tooltipprofile = "ToolsGuiToolTipProfile";
          hovertime = "1000";
          Margin = "0 0 0 0";
          Padding = "0 0 0 0";
@@ -427,7 +427,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
             canSave = "1";
             isDecoy = "0";
             Visible = "1";
-            tooltipprofile = "GuiToolTipProfile";
+            tooltipprofile = "ToolsGuiToolTipProfile";
             hovertime = "1000";
 
             new VTimeLineControl(VerveEditorTimeLine) {
@@ -443,7 +443,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
                canSave = "1";
                isDecoy = "0";
                Visible = "1";
-               tooltipprofile = "GuiToolTipProfile";
+               tooltipprofile = "ToolsGuiToolTipProfile";
                hovertime = "1000";
                IsController = "1";
                Controller = "VerveEditorController";
@@ -465,7 +465,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
       canSave = "1";
       isDecoy = "0";
       Visible = "1";
-      tooltipprofile = "GuiToolTipProfile";
+      tooltipprofile = "ToolsGuiToolTipProfile";
       hovertime = "1000";
       Margin = "0 0 0 0";
       Padding = "0 0 0 0";
@@ -496,7 +496,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
         canSave = "1";
         isDecoy = "0";
         Visible = "1";
-        tooltipprofile = "GuiToolTipProfile";
+        tooltipprofile = "ToolsGuiToolTipProfile";
         hovertime = "1000";
      };
    };
@@ -513,7 +513,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
       canSave = "1";
       isDecoy = "0";
       Visible = "1";
-      tooltipprofile = "GuiDefaultProfile";
+      tooltipprofile = "ToolsGuiDefaultProfile";
       hovertime = "1000";
       Margin = "0 0 0 0";
       Padding = "0 0 0 0";
@@ -540,7 +540,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
          canSave = "1";
          isDecoy = "0";
          Visible = "1";
-         tooltipprofile = "GuiToolTipProfile";
+         tooltipprofile = "ToolsGuiToolTipProfile";
          hovertime = "1000";
       };
    };
@@ -557,7 +557,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
       canSave = "1";
       isDecoy = "0";
       Visible = "1";
-      tooltipprofile = "GuiDefaultProfile";
+      tooltipprofile = "ToolsGuiDefaultProfile";
       hovertime = "1000";
       Margin = "0 0 0 0";
       Padding = "0 0 0 0";
@@ -584,7 +584,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
          canSave = "1";
          isDecoy = "0";
          Visible = "1";
-         tooltipprofile = "GuiToolTipProfile";
+         tooltipprofile = "ToolsGuiToolTipProfile";
          hovertime = "1000";
 
          new GuiControl() {
@@ -600,7 +600,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
             canSave = "1";
             isDecoy = "0";
             Visible = "1";
-            tooltipprofile = "GuiToolTipProfile";
+            tooltipprofile = "ToolsGuiToolTipProfile";
             hovertime = "1000";
 
             new GuiBitmapButtonCtrl() {
@@ -616,7 +616,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
                canSave = "1";
                isDecoy = "0";
                Visible = "1";
-               tooltipprofile = "GuiToolTipProfile";
+               tooltipprofile = "ToolsGuiToolTipProfile";
                tooltip = "Jump Backwards";
                command = "VerveEditor::Rewind();";
                hovertime = "1000";
@@ -638,7 +638,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
                canSave = "1";
                isDecoy = "0";
                Visible = "1";
-               tooltipprofile = "GuiToolTipProfile";
+               tooltipprofile = "ToolsGuiToolTipProfile";
                tooltip = "Step Backwards 1 Frame";
                command = "VerveEditor::StepB();";
                hovertime = "1000";
@@ -660,7 +660,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
                canSave = "1";
                isDecoy = "0";
                Visible = "1";
-               tooltipprofile = "GuiToolTipProfile";
+               tooltipprofile = "ToolsGuiToolTipProfile";
                tooltip = "Play / Pause";
                command = "VerveEditor::TogglePlay( $ThisControl );";
                hovertime = "1000";
@@ -682,7 +682,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
                canSave = "1";
                isDecoy = "0";
                Visible = "1";
-               tooltipprofile = "GuiToolTipProfile";
+               tooltipprofile = "ToolsGuiToolTipProfile";
                tooltip = "Step Forward 1 Frame";
                command = "VerveEditor::StepF();";
                hovertime = "1000";
@@ -704,7 +704,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
                canSave = "1";
                isDecoy = "0";
                Visible = "1";
-               tooltipprofile = "GuiToolTipProfile";
+               tooltipprofile = "ToolsGuiToolTipProfile";
                tooltip = "Jump Forward";
                command = "VerveEditor::Forward();";
                hovertime = "1000";
@@ -727,7 +727,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
             canSave = "1";
             isDecoy = "0";
             Visible = "1";
-            tooltipprofile = "GuiToolTipProfile";
+            tooltipprofile = "ToolsGuiToolTipProfile";
             tooltip = "Insert Time (Front)";
             command = "VerveEditor::InsertTimeFront();";
             hovertime = "1000";
@@ -749,7 +749,7 @@ $guiContent = new GuiControl(VerveEditorGui) {
             canSave = "1";
             isDecoy = "0";
             Visible = "1";
-            tooltipprofile = "GuiToolTipProfile";
+            tooltipprofile = "ToolsGuiToolTipProfile";
             tooltip = "Insert Time (Back)";
             command = "VerveEditor::InsertTimeBack();";
             hovertime = "1000";
diff --git a/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditorGroupBuilder.gui b/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditorGroupBuilder.gui
index 19076f551..3d85c03b1 100644
--- a/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditorGroupBuilder.gui
+++ b/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditorGroupBuilder.gui
@@ -1,7 +1,7 @@
 //--- OBJECT WRITE BEGIN ---
 $guiContent = new GuiControl(VerveEditorGroupBuilderGUI) {
    isContainer = "1";
-   Profile = "GuiDefaultProfile";
+   Profile = "ToolsGuiDefaultProfile";
    HorizSizing = "right";
    VertSizing = "bottom";
    position = "0 0";
@@ -9,7 +9,7 @@ $guiContent = new GuiControl(VerveEditorGroupBuilderGUI) {
    MinExtent = "8 8";
    canSave = "1";
    Visible = "1";
-   tooltipprofile = "GuiToolTipProfile";
+   tooltipprofile = "ToolsGuiToolTipProfile";
    hovertime = "1000";
    canSaveDynamicFields = "0";
 
@@ -30,7 +30,7 @@ $guiContent = new GuiControl(VerveEditorGroupBuilderGUI) {
       AnchorLeft = "1";
       AnchorRight = "0";
       isContainer = "1";
-      Profile = "GuiWindowProfile";
+      Profile = "ToolsGuiWindowProfile";
       HorizSizing = "center";
       VertSizing = "center";
       position = "268 181";
@@ -38,7 +38,7 @@ $guiContent = new GuiControl(VerveEditorGroupBuilderGUI) {
       MinExtent = "256 8";
       canSave = "1";
       Visible = "1";
-      tooltipprofile = "GuiToolTipProfile";
+      tooltipprofile = "ToolsGuiToolTipProfile";
       hovertime = "1000";
       canSaveDynamicFields = "0";
 
@@ -52,7 +52,7 @@ $guiContent = new GuiControl(VerveEditorGroupBuilderGUI) {
          AnchorLeft = "1";
          AnchorRight = "0";
          isContainer = "0";
-         Profile = "GuiTextProfile";
+         Profile = "ToolsGuiTextProfile";
          HorizSizing = "right";
          VertSizing = "bottom";
          position = "14 30";
@@ -60,7 +60,7 @@ $guiContent = new GuiControl(VerveEditorGroupBuilderGUI) {
          MinExtent = "8 8";
          canSave = "1";
          Visible = "1";
-         tooltipprofile = "GuiToolTipProfile";
+         tooltipprofile = "ToolsGuiToolTipProfile";
          hovertime = "1000";
          canSaveDynamicFields = "0";
       };
@@ -78,7 +78,7 @@ $guiContent = new GuiControl(VerveEditorGroupBuilderGUI) {
          AnchorLeft = "1";
          AnchorRight = "0";
          isContainer = "0";
-         Profile = "GuiTextEditProfile";
+         Profile = "ToolsGuiTextEditProfile";
          HorizSizing = "width";
          VertSizing = "bottom";
          position = "79 29";
@@ -86,13 +86,13 @@ $guiContent = new GuiControl(VerveEditorGroupBuilderGUI) {
          MinExtent = "8 8";
          canSave = "1";
          Visible = "1";
-         tooltipprofile = "GuiToolTipProfile";
+         tooltipprofile = "ToolsGuiToolTipProfile";
          hovertime = "1000";
          canSaveDynamicFields = "0";
       };
       new GuiBitmapBorderCtrl() {
          isContainer = "0";
-         Profile = "GuiGroupBorderProfile";
+         Profile = "ToolsGuiGroupBorderProfile";
          HorizSizing = "width";
          VertSizing = "bottom";
          position = "7 55";
@@ -100,7 +100,7 @@ $guiContent = new GuiControl(VerveEditorGroupBuilderGUI) {
          MinExtent = "1 1";
          canSave = "1";
          Visible = "1";
-         tooltipprofile = "GuiToolTipProfile";
+         tooltipprofile = "ToolsGuiToolTipProfile";
          hovertime = "1000";
          canSaveDynamicFields = "0";
 
@@ -112,7 +112,7 @@ $guiContent = new GuiControl(VerveEditorGroupBuilderGUI) {
             ChangeChildSizeToFit = "1";
             ChangeChildPosition = "1";
             isContainer = "1";
-            Profile = "GuiTransparentProfile";
+            Profile = "ToolsGuiTransparentProfile";
             HorizSizing = "width";
             VertSizing = "height";
             position = "3 3";
@@ -120,13 +120,13 @@ $guiContent = new GuiControl(VerveEditorGroupBuilderGUI) {
             MinExtent = "8 8";
             canSave = "1";
             Visible = "1";
-            tooltipprofile = "GuiToolTipProfile";
+            tooltipprofile = "ToolsGuiToolTipProfile";
             hovertime = "1000";
             canSaveDynamicFields = "0";
 
             new GuiControl() {
                isContainer = "1";
-               Profile = "GuiTransparentProfile";
+               Profile = "ToolsGuiTransparentProfile";
                HorizSizing = "right";
                VertSizing = "bottom";
                position = "0 0";
@@ -134,7 +134,7 @@ $guiContent = new GuiControl(VerveEditorGroupBuilderGUI) {
                MinExtent = "8 2";
                canSave = "1";
                Visible = "1";
-               tooltipprofile = "GuiToolTipProfile";
+               tooltipprofile = "ToolsGuiToolTipProfile";
                hovertime = "1000";
                canSaveDynamicFields = "0";
 
@@ -148,7 +148,7 @@ $guiContent = new GuiControl(VerveEditorGroupBuilderGUI) {
                   AnchorLeft = "1";
                   AnchorRight = "0";
                   isContainer = "0";
-                  Profile = "GuiTextProfile";
+                  Profile = "ToolsGuiTextProfile";
                   HorizSizing = "right";
                   VertSizing = "center";
                   position = "4 1";
@@ -156,7 +156,7 @@ $guiContent = new GuiControl(VerveEditorGroupBuilderGUI) {
                   MinExtent = "8 2";
                   canSave = "1";
                   Visible = "1";
-                  tooltipprofile = "GuiToolTipProfile";
+                  tooltipprofile = "ToolsGuiToolTipProfile";
                   hovertime = "1000";
                   canSaveDynamicFields = "0";
                };
@@ -181,7 +181,7 @@ $guiContent = new GuiControl(VerveEditorGroupBuilderGUI) {
                   MinExtent = "8 2";
                   canSave = "1";
                   Visible = "1";
-                  tooltipprofile = "GuiToolTipProfile";
+                  tooltipprofile = "ToolsGuiToolTipProfile";
                   hovertime = "1000";
                   internalName = "SceneObjectList";
                   canSaveDynamicFields = "0";
@@ -195,7 +195,7 @@ $guiContent = new GuiControl(VerveEditorGroupBuilderGUI) {
          buttonType = "PushButton";
          useMouseEvents = "0";
          isContainer = "0";
-         Profile = "GuiButtonProfile";
+         Profile = "ToolsGuiButtonProfile";
          HorizSizing = "left";
          VertSizing = "top";
          position = "66 139";
@@ -204,7 +204,7 @@ $guiContent = new GuiControl(VerveEditorGroupBuilderGUI) {
          canSave = "1";
          Visible = "1";
          Command = "VerveEditorGroupBuilderGUI._Build( VerveEditorGroupBuilderNameField.getText() );";
-         tooltipprofile = "GuiToolTipProfile";
+         tooltipprofile = "ToolsGuiToolTipProfile";
          hovertime = "1000";
          canSaveDynamicFields = "0";
       };
@@ -214,7 +214,7 @@ $guiContent = new GuiControl(VerveEditorGroupBuilderGUI) {
          buttonType = "PushButton";
          useMouseEvents = "0";
          isContainer = "0";
-         Profile = "GuiButtonProfile";
+         Profile = "ToolsGuiButtonProfile";
          HorizSizing = "left";
          VertSizing = "top";
          position = "174 139";
@@ -223,7 +223,7 @@ $guiContent = new GuiControl(VerveEditorGroupBuilderGUI) {
          canSave = "1";
          Visible = "1";
          Command = "VerveEditorGroupBuilderGUI.Close();";
-         tooltipprofile = "GuiToolTipProfile";
+         tooltipprofile = "ToolsGuiToolTipProfile";
          hovertime = "1000";
          canSaveDynamicFields = "0";
       };
@@ -283,7 +283,7 @@ function VerveEditorGroupBuilderGUI::_Build( %this, %groupLabel )
 {
     if ( %groupLabel $= "" )
     {
-        toolsMessageBox( "Warning", "You must provide a Valid Group Label.", "Ok" );
+        MessageBox( "Warning", "You must provide a Valid Group Label.", "Ok" );
         return;
     }
     
@@ -316,7 +316,7 @@ function VerveEditorGroupBuilderFieldStack::CreateObjectList( %this, %objectType
 {
     %container = new GuiControl()
     {
-        Profile      = "GuiTransparentProfile";
+        Profile      = "ToolsGuiTransparentProfile";
         
         HorizSizing  = "right";
         VertSizing   = "bottom";
@@ -326,7 +326,7 @@ function VerveEditorGroupBuilderFieldStack::CreateObjectList( %this, %objectType
     
     %label = new GuiTextCtrl()
     {
-        Profile      = "GuiTextProfile";
+        Profile      = "ToolsGuiTextProfile";
         
         HorizSizing  = "right";
         VertSizing   = "center";
@@ -392,7 +392,7 @@ function VerveEditorGroupBuilderFieldStack::CreateCheckbox( %this, %internalName
 {
     %container = new GuiControl()
     {
-        Profile      = "GuiTransparentProfile";
+        Profile      = "ToolsGuiTransparentProfile";
         
         HorizSizing  = "right";
         VertSizing   = "bottom";
@@ -402,7 +402,7 @@ function VerveEditorGroupBuilderFieldStack::CreateCheckbox( %this, %internalName
     
     %label = new GuiTextCtrl()
     {
-        Profile      = "GuiTextProfile";
+        Profile      = "ToolsGuiTextProfile";
         
         HorizSizing  = "right";
         VertSizing   = "center";
@@ -415,7 +415,7 @@ function VerveEditorGroupBuilderFieldStack::CreateCheckbox( %this, %internalName
     
     %checkBox = new GuiCheckBoxCtrl()
     {
-        Profile      = "GuiCheckboxProfile";
+        Profile      = "ToolsGuiCheckboxProfile";
         
         HorizSizing  = "left";
         VertSizing   = "center";
diff --git a/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditorImportPathNodes.gui b/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditorImportPathNodes.gui
index 9309ee64f..0d79d862c 100644
--- a/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditorImportPathNodes.gui
+++ b/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditorImportPathNodes.gui
@@ -1,7 +1,7 @@
 //--- OBJECT WRITE BEGIN ---
 $guiContent = new GuiControl(VerveEditorImportPathNodesGUI) {
    isContainer = "1";
-   Profile = "GuiDefaultProfile";
+   Profile = "ToolsGuiDefaultProfile";
    HorizSizing = "right";
    VertSizing = "bottom";
    Position = "0 0";
@@ -9,7 +9,7 @@ $guiContent = new GuiControl(VerveEditorImportPathNodesGUI) {
    MinExtent = "8 8";
    canSave = "1";
    Visible = "1";
-   tooltipprofile = "GuiToolTipProfile";
+   tooltipprofile = "ToolsGuiToolTipProfile";
    hovertime = "1000";
    canSaveDynamicFields = "1";
 
@@ -30,7 +30,7 @@ $guiContent = new GuiControl(VerveEditorImportPathNodesGUI) {
       AnchorLeft = "1";
       AnchorRight = "0";
       isContainer = "1";
-      Profile = "GuiWindowProfile";
+      Profile = "ToolsGuiWindowProfile";
       HorizSizing = "center";
       VertSizing = "center";
       Position = "268 181";
@@ -38,7 +38,7 @@ $guiContent = new GuiControl(VerveEditorImportPathNodesGUI) {
       MinExtent = "256 8";
       canSave = "1";
       Visible = "1";
-      tooltipprofile = "GuiToolTipProfile";
+      tooltipprofile = "ToolsGuiToolTipProfile";
       hovertime = "1000";
       canSaveDynamicFields = "0";
 
@@ -52,7 +52,7 @@ $guiContent = new GuiControl(VerveEditorImportPathNodesGUI) {
          AnchorLeft = "1";
          AnchorRight = "0";
          isContainer = "0";
-         Profile = "GuiTextProfile";
+         Profile = "ToolsGuiTextProfile";
          HorizSizing = "right";
          VertSizing = "bottom";
          Position = "14 30";
@@ -60,7 +60,7 @@ $guiContent = new GuiControl(VerveEditorImportPathNodesGUI) {
          MinExtent = "8 8";
          canSave = "1";
          Visible = "1";
-         tooltipprofile = "GuiToolTipProfile";
+         tooltipprofile = "ToolsGuiToolTipProfile";
          hovertime = "1000";
          canSaveDynamicFields = "0";
       };
@@ -78,7 +78,7 @@ $guiContent = new GuiControl(VerveEditorImportPathNodesGUI) {
          AnchorLeft = "1";
          AnchorRight = "0";
          isContainer = "0";
-         Profile = "GuiTextEditProfile";
+         Profile = "ToolsGuiTextEditProfile";
          HorizSizing = "width";
          VertSizing = "bottom";
          Position = "79 29";
@@ -86,7 +86,7 @@ $guiContent = new GuiControl(VerveEditorImportPathNodesGUI) {
          MinExtent = "8 8";
          canSave = "1";
          Visible = "1";
-         tooltipprofile = "GuiToolTipProfile";
+         tooltipprofile = "ToolsGuiToolTipProfile";
          hovertime = "1000";
          canSaveDynamicFields = "0";
       };
@@ -96,7 +96,7 @@ $guiContent = new GuiControl(VerveEditorImportPathNodesGUI) {
          buttonType = "PushButton";
          useMouseEvents = "0";
          isContainer = "0";
-         Profile = "GuiButtonProfile";
+         Profile = "ToolsGuiButtonProfile";
          HorizSizing = "left";
          VertSizing = "top";
          Position = "66 62";
@@ -105,7 +105,7 @@ $guiContent = new GuiControl(VerveEditorImportPathNodesGUI) {
          canSave = "1";
          Visible = "1";
          Command = "VMotionTrack::_ImportPathNodes( VerveEditorImportPathNodesSpeed.getText() );";
-         tooltipprofile = "GuiToolTipProfile";
+         tooltipprofile = "ToolsGuiToolTipProfile";
          hovertime = "1000";
          canSaveDynamicFields = "0";
       };
@@ -115,7 +115,7 @@ $guiContent = new GuiControl(VerveEditorImportPathNodesGUI) {
          buttonType = "PushButton";
          useMouseEvents = "0";
          isContainer = "0";
-         Profile = "GuiButtonProfile";
+         Profile = "ToolsGuiButtonProfile";
          HorizSizing = "left";
          VertSizing = "top";
          Position = "174 62";
@@ -124,7 +124,7 @@ $guiContent = new GuiControl(VerveEditorImportPathNodesGUI) {
          canSave = "1";
          Visible = "1";
          Command = "VerveEditorWindow.popDialog( VerveEditorImportPathNodesGUI );";
-         tooltipprofile = "GuiToolTipProfile";
+         tooltipprofile = "ToolsGuiToolTipProfile";
          hovertime = "1000";
          canSaveDynamicFields = "0";
       };
diff --git a/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditorPreferences.gui b/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditorPreferences.gui
index 417f15908..36db45114 100644
--- a/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditorPreferences.gui
+++ b/Templates/BaseGame/game/tools/VerveEditor/GUI/VerveEditorPreferences.gui
@@ -2,7 +2,7 @@
 $guiContent = new GuiControl(VerveEditorPreferenceGui) {
    canSaveDynamicFields = "0";
    isContainer = "1";
-   Profile = "GuiDefaultProfile";
+   Profile = "ToolsGuiDefaultProfile";
    HorizSizing = "right";
    VertSizing = "bottom";
    position = "0 0";
@@ -10,13 +10,13 @@ $guiContent = new GuiControl(VerveEditorPreferenceGui) {
    MinExtent = "8 2";
    canSave = "1";
    Visible = "1";
-   tooltipprofile = "GuiToolTipProfile";
+   tooltipprofile = "ToolsGuiToolTipProfile";
    hovertime = "1000";
 
    new GuiWindowCtrl() {
       canSaveDynamicFields = "0";
       isContainer = "1";
-      Profile = "GuiWindowProfile";
+      Profile = "ToolsGuiWindowProfile";
       HorizSizing = "center";
       VertSizing = "center";
       position = "392 253";
@@ -24,7 +24,7 @@ $guiContent = new GuiControl(VerveEditorPreferenceGui) {
       MinExtent = "8 2";
       canSave = "1";
       Visible = "1";
-      tooltipprofile = "GuiToolTipProfile";
+      tooltipprofile = "ToolsGuiToolTipProfile";
       hovertime = "1000";
       Docking = "None";
       Margin = "4 24 4 4";
@@ -50,7 +50,7 @@ $guiContent = new GuiControl(VerveEditorPreferenceGui) {
       new GuiControl() {
          canSaveDynamicFields = "0";
          isContainer = "1";
-         Profile = "GuiDefaultProfile";
+         Profile = "ToolsGuiDefaultProfile";
          HorizSizing = "right";
          VertSizing = "bottom";
          position = "10 93";
@@ -58,13 +58,13 @@ $guiContent = new GuiControl(VerveEditorPreferenceGui) {
          MinExtent = "8 2";
          canSave = "1";
          Visible = "1";
-         tooltipprofile = "GuiToolTipProfile";
+         tooltipprofile = "ToolsGuiToolTipProfile";
          hovertime = "1000";
 
          new GuiBitmapBorderCtrl() {
             canSaveDynamicFields = "0";
             isContainer = "0";
-            Profile = "GuiBitmapBorderProfile";
+            Profile = "ToolsGuiBitmapBorderProfile";
             HorizSizing = "width";
             VertSizing = "height";
             position = "0 10";
@@ -72,7 +72,7 @@ $guiContent = new GuiControl(VerveEditorPreferenceGui) {
             MinExtent = "8 2";
             canSave = "1";
             Visible = "1";
-            tooltipprofile = "GuiToolTipProfile";
+            tooltipprofile = "ToolsGuiToolTipProfile";
             hovertime = "1000";
          };
          new GuiTextEditCtrl() {
@@ -87,7 +87,7 @@ $guiContent = new GuiControl(VerveEditorPreferenceGui) {
             MinExtent = "8 2";
             canSave = "1";
             Visible = "1";
-            tooltipprofile = "GuiToolTipProfile";
+            tooltipprofile = "ToolsGuiToolTipProfile";
             hovertime = "1000";
             Margin = "0 0 0 0";
             Padding = "0 0 0 0";
@@ -101,7 +101,7 @@ $guiContent = new GuiControl(VerveEditorPreferenceGui) {
          new GuiTextCtrl() {
             canSaveDynamicFields = "0";
             isContainer = "0";
-            Profile = "GuiTextProfile";
+            Profile = "ToolsGuiTextProfile";
             HorizSizing = "right";
             VertSizing = "bottom";
             position = "30 50";
@@ -109,7 +109,7 @@ $guiContent = new GuiControl(VerveEditorPreferenceGui) {
             MinExtent = "8 2";
             canSave = "1";
             Visible = "1";
-            tooltipprofile = "GuiToolTipProfile";
+            tooltipprofile = "ToolsGuiToolTipProfile";
             hovertime = "1000";
             Margin = "0 0 0 0";
             Padding = "0 0 0 0";
@@ -123,7 +123,7 @@ $guiContent = new GuiControl(VerveEditorPreferenceGui) {
          new GuiCheckBoxCtrl() {
             canSaveDynamicFields = "0";
             isContainer = "0";
-            Profile = "GuiCheckBoxProfile";
+            Profile = "ToolsGuiCheckBoxProfile";
             HorizSizing = "right";
             VertSizing = "bottom";
             position = "6 30";
@@ -132,7 +132,7 @@ $guiContent = new GuiControl(VerveEditorPreferenceGui) {
             canSave = "1";
             Visible = "1";
             Variable = "$Pref::VerveEditor::Event::SnapToTime";
-            tooltipprofile = "GuiToolTipProfile";
+            tooltipprofile = "ToolsGuiToolTipProfile";
             hovertime = "1000";
             text = "   Snap to Time";
             groupNum = "-1";
@@ -143,7 +143,7 @@ $guiContent = new GuiControl(VerveEditorPreferenceGui) {
          new GuiTextEditCtrl() {
             canSaveDynamicFields = "0";
             isContainer = "0";
-            Profile = "GuiTextEditProfile";
+            Profile = "ToolsGuiTextEditProfile";
             HorizSizing = "right";
             VertSizing = "bottom";
             position = "150 50";
@@ -152,7 +152,7 @@ $guiContent = new GuiControl(VerveEditorPreferenceGui) {
             canSave = "1";
             Visible = "1";
             Variable = "$Pref::VerveEditor::Event::SnapToTimeThreshold";
-            tooltipprofile = "GuiToolTipProfile";
+            tooltipprofile = "ToolsGuiToolTipProfile";
             hovertime = "1000";
             Margin = "0 0 0 0";
             Padding = "0 0 0 0";
@@ -170,7 +170,7 @@ $guiContent = new GuiControl(VerveEditorPreferenceGui) {
          new GuiCheckBoxCtrl() {
             canSaveDynamicFields = "0";
             isContainer = "0";
-            Profile = "GuiCheckBoxProfile";
+            Profile = "ToolsGuiCheckBoxProfile";
             HorizSizing = "right";
             VertSizing = "bottom";
             position = "6 80";
@@ -179,7 +179,7 @@ $guiContent = new GuiControl(VerveEditorPreferenceGui) {
             canSave = "1";
             Visible = "1";
             Variable = "$Pref::VerveEditor::Event::SnapToSiblings";
-            tooltipprofile = "GuiToolTipProfile";
+            tooltipprofile = "ToolsGuiToolTipProfile";
             hovertime = "1000";
             text = "   Snap to Siblings";
             groupNum = "-1";
@@ -190,7 +190,7 @@ $guiContent = new GuiControl(VerveEditorPreferenceGui) {
          new GuiTextCtrl() {
             canSaveDynamicFields = "0";
             isContainer = "0";
-            Profile = "GuiTextProfile";
+            Profile = "ToolsGuiTextProfile";
             HorizSizing = "right";
             VertSizing = "bottom";
             position = "30 100";
@@ -198,7 +198,7 @@ $guiContent = new GuiControl(VerveEditorPreferenceGui) {
             MinExtent = "8 2";
             canSave = "1";
             Visible = "1";
-            tooltipprofile = "GuiToolTipProfile";
+            tooltipprofile = "ToolsGuiToolTipProfile";
             hovertime = "1000";
             Margin = "0 0 0 0";
             Padding = "0 0 0 0";
@@ -212,7 +212,7 @@ $guiContent = new GuiControl(VerveEditorPreferenceGui) {
          new GuiTextEditCtrl() {
             canSaveDynamicFields = "0";
             isContainer = "0";
-            Profile = "GuiTextEditProfile";
+            Profile = "ToolsGuiTextEditProfile";
             HorizSizing = "right";
             VertSizing = "bottom";
             position = "150 100";
@@ -221,7 +221,7 @@ $guiContent = new GuiControl(VerveEditorPreferenceGui) {
             canSave = "1";
             Visible = "1";
             Variable = "$Pref::VerveEditor::Event::SnapToSiblingThreshold";
-            tooltipprofile = "GuiToolTipProfile";
+            tooltipprofile = "ToolsGuiToolTipProfile";
             hovertime = "1000";
             Margin = "0 0 0 0";
             Padding = "0 0 0 0";
@@ -240,7 +240,7 @@ $guiContent = new GuiControl(VerveEditorPreferenceGui) {
       new GuiControl() {
          canSaveDynamicFields = "0";
          isContainer = "1";
-         Profile = "GuiDefaultProfile";
+         Profile = "ToolsGuiDefaultProfile";
          HorizSizing = "right";
          VertSizing = "bottom";
          position = "10 30";
@@ -248,13 +248,13 @@ $guiContent = new GuiControl(VerveEditorPreferenceGui) {
          MinExtent = "8 2";
          canSave = "1";
          Visible = "1";
-         tooltipprofile = "GuiToolTipProfile";
+         tooltipprofile = "ToolsGuiToolTipProfile";
          hovertime = "1000";
 
          new GuiBitmapBorderCtrl() {
             canSaveDynamicFields = "0";
             isContainer = "0";
-            Profile = "GuiBitmapBorderProfile";
+            Profile = "ToolsGuiBitmapBorderProfile";
             HorizSizing = "width";
             VertSizing = "height";
             position = "0 10";
@@ -262,7 +262,7 @@ $guiContent = new GuiControl(VerveEditorPreferenceGui) {
             MinExtent = "8 2";
             canSave = "1";
             Visible = "1";
-            tooltipprofile = "GuiToolTipProfile";
+            tooltipprofile = "ToolsGuiToolTipProfile";
             hovertime = "1000";
          };
          new GuiTextEditCtrl() {
@@ -277,7 +277,7 @@ $guiContent = new GuiControl(VerveEditorPreferenceGui) {
             MinExtent = "8 2";
             canSave = "1";
             Visible = "1";
-            tooltipprofile = "GuiToolTipProfile";
+            tooltipprofile = "ToolsGuiToolTipProfile";
             hovertime = "1000";
             Margin = "0 0 0 0";
             Padding = "0 0 0 0";
@@ -291,7 +291,7 @@ $guiContent = new GuiControl(VerveEditorPreferenceGui) {
          new GuiTextEditCtrl() {
             canSaveDynamicFields = "0";
             isContainer = "0";
-            Profile = "GuiTextEditProfile";
+            Profile = "ToolsGuiTextEditProfile";
             HorizSizing = "right";
             VertSizing = "bottom";
             position = "6 30";
@@ -300,7 +300,7 @@ $guiContent = new GuiControl(VerveEditorPreferenceGui) {
             canSave = "1";
             Visible = "1";
             Variable = "$Pref::VerveEditor::RecentFileSize";
-            tooltipprofile = "GuiToolTipProfile";
+            tooltipprofile = "ToolsGuiToolTipProfile";
             hovertime = "1000";
             Margin = "0 0 0 0";
             Padding = "0 0 0 0";
@@ -318,7 +318,7 @@ $guiContent = new GuiControl(VerveEditorPreferenceGui) {
          new GuiTextCtrl() {
             canSaveDynamicFields = "0";
             isContainer = "0";
-            Profile = "GuiTextProfile";
+            Profile = "ToolsGuiTextProfile";
             HorizSizing = "right";
             VertSizing = "bottom";
             position = "56 30";
@@ -326,7 +326,7 @@ $guiContent = new GuiControl(VerveEditorPreferenceGui) {
             MinExtent = "8 2";
             canSave = "1";
             Visible = "1";
-            tooltipprofile = "GuiToolTipProfile";
+            tooltipprofile = "ToolsGuiToolTipProfile";
             hovertime = "1000";
             Margin = "0 0 0 0";
             Padding = "0 0 0 0";
@@ -341,7 +341,7 @@ $guiContent = new GuiControl(VerveEditorPreferenceGui) {
       new GuiButtonCtrl() {
          canSaveDynamicFields = "0";
          isContainer = "0";
-         Profile = "GuiButtonProfile";
+         Profile = "ToolsGuiButtonProfile";
          HorizSizing = "right";
          VertSizing = "bottom";
          position = "151 228";
@@ -350,7 +350,7 @@ $guiContent = new GuiControl(VerveEditorPreferenceGui) {
          canSave = "1";
          Visible = "1";
          Command = "VerveEditor::CloseEditorPreferences();";
-         tooltipprofile = "GuiToolTipProfile";
+         tooltipprofile = "ToolsGuiToolTipProfile";
          hovertime = "1000";
          text = "OK";
          groupNum = "-1";
diff --git a/Templates/BaseGame/game/tools/VerveEditor/Scripts/Controller/VControllerProperties.tscript b/Templates/BaseGame/game/tools/VerveEditor/Scripts/Controller/VControllerProperties.tscript
index 3fd8b8046..3edb6ca34 100644
--- a/Templates/BaseGame/game/tools/VerveEditor/Scripts/Controller/VControllerProperties.tscript
+++ b/Templates/BaseGame/game/tools/VerveEditor/Scripts/Controller/VControllerProperties.tscript
@@ -103,13 +103,13 @@ function VController::DisplayContextMenu( %this, %x, %y )
             
             Item[1] = "" TAB "";
              
-            Item[2] = "Cu&t"     TAB "" TAB "";
-            Item[3] = "&Copy"    TAB "" TAB "";
-            Item[4] = "&Paste"   TAB "" TAB "VerveEditor::Paste();";
+            Item[2] = "Cut"     TAB "" TAB "";
+            Item[3] = "Copy"    TAB "" TAB "";
+            Item[4] = "Paste"   TAB "" TAB "VerveEditor::Paste();";
             
             Item[5] = "" TAB "";
             
-            Item[6] = "&Delete"  TAB "" TAB "";
+            Item[6] = "Delete"  TAB "" TAB "";
             
             PasteIndex = 4;
         };
diff --git a/Templates/BaseGame/game/tools/VerveEditor/Scripts/EditorMenu.tscript b/Templates/BaseGame/game/tools/VerveEditor/Scripts/EditorMenu.tscript
index 20bcfe3a3..daa08b5d3 100644
--- a/Templates/BaseGame/game/tools/VerveEditor/Scripts/EditorMenu.tscript
+++ b/Templates/BaseGame/game/tools/VerveEditor/Scripts/EditorMenu.tscript
@@ -76,7 +76,7 @@ function VerveEditorWindow::onCreateMenu( %this )
     // Store Menu Bars.
     if ( !isObject( %this.MenuSet ) )
     {
-        %this.MenuSet = new SimSet();
+        %this.MenuSet = new GuiMenuBar();
     }
     
     // CMD Key.
@@ -103,14 +103,14 @@ function VerveEditorWindow::onCreateMenu( %this )
     {
         SuperClass = "VerveWindowMenu";
         
-        Label    = "&File";
+        Label    = "File";
         Position = 0;
         
-        Item[0] = "&New"         TAB %cmdKey @ "+N"       TAB "VerveEditor::NewFile();";
-        Item[1] = "&Open"        TAB %cmdKey @ "+O"       TAB "VerveEditor::LoadFile();";
+        Item[0] = "New"         TAB %cmdKey @ "+N"       TAB "VerveEditor::NewFile();";
+        Item[1] = "Open"        TAB %cmdKey @ "+O"       TAB "VerveEditor::LoadFile();";
         Item[2] = ""             TAB "";
-        Item[3] = "&Save"        TAB %cmdKey @ "+S"       TAB "VerveEditor::SaveFile();";
-        Item[4] = "Save &As"     TAB %cmdKey @ "-Shift+S" TAB "VerveEditor::SaveFile( true );";
+        Item[3] = "Save"        TAB %cmdKey @ "+S"       TAB "VerveEditor::SaveFile();";
+        Item[4] = "Save As"     TAB %cmdKey @ "-Shift+S" TAB "VerveEditor::SaveFile( true );";
         Item[5] = ""             TAB "";
         Item[6] = "Recent Files" TAB %recentSequenceMenu;
     };
@@ -133,34 +133,38 @@ function VerveEditorWindow::onCreateMenu( %this )
         Class      = "VerveWindowEditMenu";
         SuperClass = "VerveWindowMenu";
         
-        Label    = "&Edit";
+        Label    = "Edit";
         Position = 1;
         
-        Item[0]  = "&Undo"            TAB %cmdKey @ "+Z" TAB "VerveEditor::Undo();";
-        Item[1]  = "&Redo"            TAB %cmdKey @ "+Y" TAB "VerveEditor::Redo();";
+        Item[0]  = "Undo"            TAB %cmdKey @ "+Z" TAB "VerveEditor::Undo();";
+        Item[1]  = "Redo"            TAB %cmdKey @ "+Y" TAB "VerveEditor::Redo();";
         Item[2]  = ""                 TAB "";
-        Item[3]  = "Cu&t"             TAB %cmdKey @ "+X" TAB "VerveEditor::CutSelection();"    TAB VerveEditorEditMap;
-        Item[4]  = "&Copy"            TAB %cmdKey @ "+C" TAB "VerveEditor::CopySelection();"   TAB VerveEditorEditMap;
-        Item[5]  = "&Paste"           TAB %cmdKey @ "+V" TAB "VerveEditor::Paste();"           TAB VerveEditorEditMap;
+        Item[3]  = "Cut"             TAB %cmdKey @ "+X" TAB "VerveEditor::CutSelection();"    TAB VerveEditorEditMap;
+        Item[4]  = "Copy"            TAB %cmdKey @ "+C" TAB "VerveEditor::CopySelection();"   TAB VerveEditorEditMap;
+        Item[5]  = "Paste"           TAB %cmdKey @ "+V" TAB "VerveEditor::Paste();"           TAB VerveEditorEditMap;
         
         Item[6]  = ""                 TAB "";
-        Item[7]  = "&Delete"          TAB "Del"          TAB "VerveEditor::DeleteSelection();" TAB VerveEditorEditMap;
+        Item[7]  = "Delete"          TAB "Del"          TAB "VerveEditor::DeleteSelection();" TAB VerveEditorEditMap;
         
         Item[8]  = ""                 TAB "";
-        Item[9]  = "&Clear Selection" TAB "Esc"          TAB "VerveEditor::ClearSelection();";
+        Item[9]  = "Clear Selection" TAB "Esc"          TAB "VerveEditor::ClearSelection();";
         
         Item[10] = ""                 TAB "";
-        Item[11] = "&Preferences"     TAB %cmdKey @ "+P" TAB "VerveEditor::LaunchEditorPreferences();";
+        Item[11] = "Preferences"     TAB %cmdKey @ "+P" TAB "VerveEditor::LaunchEditorPreferences();";
     };
     %this.MenuSet.add( %editMenu );
     
     // Init Popups.
-    %fileMenu.Init();
-    %editMenu.Init();
+    //%fileMenu.Init();
+    //%editMenu.Init();
     
     // Attach.
-    %fileMenu.attachToMenuBar( %this, %fileMenu.Position, %fileMenu.Label );
-    %editMenu.attachToMenuBar( %this, %editMenu.Position, %editMenu.Label );
+    if($Verve::UseSeparateWindow)
+    {
+       %this.setMenuBar(%this.MenuSet);
+       //%fileMenu.attachToMenuBar( %this, %fileMenu.Position, %fileMenu.Label );
+       //%editMenu.attachToMenuBar( %this, %editMenu.Position, %editMenu.Label );
+    }
 }
 
 function VerveEditorWindow::ClearMenu( %this )
diff --git a/Templates/BaseGame/game/tools/VerveEditor/Scripts/EditorWindow.tscript b/Templates/BaseGame/game/tools/VerveEditor/Scripts/EditorWindow.tscript
index 22baa8e95..ad64ab0c2 100644
--- a/Templates/BaseGame/game/tools/VerveEditor/Scripts/EditorWindow.tscript
+++ b/Templates/BaseGame/game/tools/VerveEditor/Scripts/EditorWindow.tscript
@@ -50,8 +50,9 @@ function VerveEditorWindow::Open()
     {
        %editorWindow = new guiWindowCtrl(VerveEditorWindow)
        {
+          Profile = "ToolsGuiWindowProfile";
          position = "0 0";
-         extent = "1024 768";
+         extent = "1024 788";
          minExtent = "8 2";
          horizSizing = "right";
          vertSizing = "bottom";
@@ -62,20 +63,23 @@ function VerveEditorWindow::Open()
 
 function VerveEditorWindow::UpdateWindowTitle( %this )
 {
-    %fileName = fileName( $VerveEditor::Controller.FileName );
-    if ( %fileName $= "" )
-    {
-        %fileName = "Untitled.vsf";
-    }
+   %fileName = fileName( $VerveEditor::Controller.FileName );
+   if ( %fileName $= "" )
+   {
+      %fileName = "Untitled.vsf";
+   }
+
+   if ( VerveEditor::IsDirty() )
+   {
+      // Signify Unsaved Work.
+      %fileName = %fileName @ "*";
+   }
     
-    if ( VerveEditor::IsDirty() )
-    {
-        // Signify Unsaved Work.
-        %fileName = %fileName @ "*";
-    }
-    
-    // Set Title.
-    %this.setWindowTitle( %fileName SPC "- Verve"  );
+   // Set Title.
+   if($Verve::UseSeparateWindow)
+      %this.setWindowTitle( %fileName SPC "- Verve"  );
+   else
+      %this.text = %fileName SPC "- Verve";
 }
 
 function VerveEditorWindow::onGainFocus( %this )
diff --git a/Templates/BaseGame/game/tools/VerveEditor/Scripts/Groups/VGroup.tscript b/Templates/BaseGame/game/tools/VerveEditor/Scripts/Groups/VGroup.tscript
index 4bd4c5fb4..532278610 100644
--- a/Templates/BaseGame/game/tools/VerveEditor/Scripts/Groups/VGroup.tscript
+++ b/Templates/BaseGame/game/tools/VerveEditor/Scripts/Groups/VGroup.tscript
@@ -188,13 +188,13 @@ function VGroup::DisplayContextMenu( %this, %x, %y )
             
             Item[1] = "" TAB "";
              
-            Item[2] = "Cu&t"     TAB "" TAB "VerveEditor::CutSelection();";
-            Item[3] = "&Copy"    TAB "" TAB "VerveEditor::CopySelection();";
-            Item[4] = "&Paste"   TAB "" TAB "VerveEditor::Paste();";
+            Item[2] = "Cut"     TAB "" TAB "VerveEditor::CutSelection();";
+            Item[3] = "Copy"    TAB "" TAB "VerveEditor::CopySelection();";
+            Item[4] = "Paste"   TAB "" TAB "VerveEditor::Paste();";
             
             Item[5] = "" TAB "";
             
-            Item[6] = "&Delete"  TAB "" TAB "VerveEditor::DeleteSelection();";
+            Item[6] = "Delete"  TAB "" TAB "VerveEditor::DeleteSelection();";
             
             AddIndex   = 0;
             PasteIndex = 4;
@@ -283,7 +283,7 @@ function VerveEditor::CreateGroupControl( %object )
         Class       = "VEditorSelectableGroup";
         Profile     = "VEditorGroupHeaderProfile";
         
-        Bitmap      = "~/VerveEditor/GUI/Images/GroupBackground";
+        bitmapAsset      = "ToolsModule:GroupBackground_image";
         
         HorizSizing = "width";
         VertSizing  = "bottom";
@@ -322,7 +322,7 @@ function VerveEditor::CreateGroupControl( %object )
         Class       = "VEditorSelectableGroup";
         Profile     = "VEditorGroupTrackProfile";
         
-        Bitmap      = "~/VerveEditor/GUI/Images/GroupBackground";
+        bitmapAsset      = "ToolsModule:GroupBackground_image";
         
         HorizSizing = "width";
         VertSizing  = "bottom";
diff --git a/Templates/BaseGame/game/tools/VerveEditor/Scripts/Inspector/Controls.tscript b/Templates/BaseGame/game/tools/VerveEditor/Scripts/Inspector/Controls.tscript
index 79beeda86..520ca3cfa 100644
--- a/Templates/BaseGame/game/tools/VerveEditor/Scripts/Inspector/Controls.tscript
+++ b/Templates/BaseGame/game/tools/VerveEditor/Scripts/Inspector/Controls.tscript
@@ -33,7 +33,7 @@ function VerveEditorPropertyStack::CreatePropertyRollout( %this, %groupLabel )
     %propertyStack = new GuiStackControl()
     {
         Class       = "VEditorPropertyStack";
-        Profile     = "GuiTransparentProfile";
+        Profile     = "ToolsGuiTransparentProfile";
         
         HorizSizing = "width";
         VertSizing  = "bottom";
@@ -123,7 +123,7 @@ function VerveEditor::CreateField( %targetStack, %fieldName, %fieldType )
     if ( isMethod( "VerveEditor", "Create" @ %fieldType @ "Field" ) )
     {
         // Create the Input Control.
-        %fieldInput = eval( "return VerveEditor::Create" @ %fieldType @ "Field( %fieldContainer, %fieldName );" );
+        %fieldInput = eval( "return VerveEditor::Create" @ %fieldType @ "Field(" @ %fieldContainer @ "," @ %fieldName @ ");" );
     }
     else
     {
diff --git a/Templates/BaseGame/game/tools/VerveEditor/Scripts/Inspector/Fields/TypeData.tscript b/Templates/BaseGame/game/tools/VerveEditor/Scripts/Inspector/Fields/TypeData.tscript
index 93fe911fc..b1f134e47 100644
--- a/Templates/BaseGame/game/tools/VerveEditor/Scripts/Inspector/Fields/TypeData.tscript
+++ b/Templates/BaseGame/game/tools/VerveEditor/Scripts/Inspector/Fields/TypeData.tscript
@@ -56,7 +56,7 @@ function VerveEditor::CreateDataField( %fieldContainer, %fieldName )
         Position     = %fieldWidth - 24 SPC 0;
         Extent       = "18 18";
         
-        Bitmap       = "tools/VerveEditor/GUI/Images/btn_DeleteSml";
+        bitmapAsset       = "ToolsModule:btn_DeleteSml_image";
         
         Command      = %fieldInput @ ".Remove();";
     };
@@ -274,7 +274,7 @@ function VerveEditor::CreateAddDataField( %targetStack )
         Position     = %fieldWidth - 24 SPC 0;
         Extent       = "18 18";
         
-        Bitmap       = "tools/VerveEditor/GUI/Images/btn_AddSml";
+        bitmapAsset       = "ToolsModule:btn_AddSml_image";
         
         Command      = "VEditorDataPropertyField::Insert(" @ %fieldType @ ".getText(), " @ %fieldName @ ".getText(), " @ %fieldValue @ ".getText() );";
     };
diff --git a/Templates/BaseGame/game/tools/VerveEditor/Scripts/Inspector/Selection.tscript b/Templates/BaseGame/game/tools/VerveEditor/Scripts/Inspector/Selection.tscript
index 1034044a2..43e44b797 100644
--- a/Templates/BaseGame/game/tools/VerveEditor/Scripts/Inspector/Selection.tscript
+++ b/Templates/BaseGame/game/tools/VerveEditor/Scripts/Inspector/Selection.tscript
@@ -114,7 +114,8 @@ function VEditorSelectable::OnRightMouseUp( %this, %position, %modifiers, %click
     VerveEditor::SetSelection( %this );
     
     // Repaint.
-    VerveEditorWindow.Repaint();
+    if($Verve::UseSeparateWindow)
+      VerveEditorWindow.Repaint();
     
     if ( %this.Proxy.isMethod( "DisplayContextMenu" ) )
     {
diff --git a/Templates/BaseGame/game/tools/VerveEditor/Scripts/Tracks/VMotionTrack.tscript b/Templates/BaseGame/game/tools/VerveEditor/Scripts/Tracks/VMotionTrack.tscript
index 2341988e9..b67024340 100644
--- a/Templates/BaseGame/game/tools/VerveEditor/Scripts/Tracks/VMotionTrack.tscript
+++ b/Templates/BaseGame/game/tools/VerveEditor/Scripts/Tracks/VMotionTrack.tscript
@@ -105,21 +105,21 @@ function VMotionTrack::GetContextMenu( %this )
             Label    = "VTrackContextMenu";
             Position = 0;
             
-            Item[0] = "&Add Event" TAB "" TAB "VEditorSelectableTrack::AddEvent();";
+            Item[0] = "Add Event" TAB "" TAB "VEditorSelectableTrack::AddEvent();";
             
             Item[1] = "" TAB "";
             
-            Item[2] = "&Import Path Nodes" TAB "" TAB "VMotionTrack::ImportPathNodes();";
+            Item[2] = "Import Path Nodes" TAB "" TAB "VMotionTrack::ImportPathNodes();";
             
             Item[3] = "" TAB "";
              
-            Item[4] = "Cu&t"    TAB "" TAB "VerveEditor::CutSelection();";
-            Item[5] = "&Copy"   TAB "" TAB "VerveEditor::CopySelection();";
-            Item[6] = "&Paste"  TAB "" TAB "VEditorSelectableTrack::PasteEvent();";
+            Item[4] = "Cut"    TAB "" TAB "VerveEditor::CutSelection();";
+            Item[5] = "Copy"   TAB "" TAB "VerveEditor::CopySelection();";
+            Item[6] = "Paste"  TAB "" TAB "VEditorSelectableTrack::PasteEvent();";
             
             Item[7] = "" TAB "";
             
-            Item[8] = "&Delete" TAB "" TAB "VerveEditor::DeleteSelection();";
+            Item[8] = "Delete" TAB "" TAB "VerveEditor::DeleteSelection();";
             
             AddIndex   = 0;
             PasteIndex = 4;
diff --git a/Templates/BaseGame/game/tools/VerveEditor/Scripts/Tracks/VTrack.tscript b/Templates/BaseGame/game/tools/VerveEditor/Scripts/Tracks/VTrack.tscript
index 5c50497ed..891566662 100644
--- a/Templates/BaseGame/game/tools/VerveEditor/Scripts/Tracks/VTrack.tscript
+++ b/Templates/BaseGame/game/tools/VerveEditor/Scripts/Tracks/VTrack.tscript
@@ -175,17 +175,17 @@ function VTrack::GetContextMenu( %this )
             Label    = "VTrackContextMenu";
             Position = 0;
             
-            Item[0] = "&Add Event" TAB "" TAB "VEditorSelectableTrack::AddEvent();";
+            Item[0] = "Add Event" TAB "" TAB "VEditorSelectableTrack::AddEvent();";
             
             Item[1] = "" TAB "";
              
-            Item[2] = "Cu&t"    TAB "" TAB "VerveEditor::CutSelection();";
-            Item[3] = "&Copy"   TAB "" TAB "VerveEditor::CopySelection();";
-            Item[4] = "&Paste"  TAB "" TAB "VEditorSelectableTrack::PasteEvent();";
+            Item[2] = "Cut"    TAB "" TAB "VerveEditor::CutSelection();";
+            Item[3] = "Copy"   TAB "" TAB "VerveEditor::CopySelection();";
+            Item[4] = "Paste"  TAB "" TAB "VEditorSelectableTrack::PasteEvent();";
             
             Item[5] = "" TAB "";
             
-            Item[6] = "&Delete" TAB "" TAB "VerveEditor::DeleteSelection();";
+            Item[6] = "Delete" TAB "" TAB "VerveEditor::DeleteSelection();";
             
             AddIndex   = 0;
             PasteIndex = 4;
diff --git a/Templates/BaseGame/game/tools/VerveEditor/main.tscript b/Templates/BaseGame/game/tools/VerveEditor/main.tscript
index 45ff8b2d9..d65cd2651 100644
--- a/Templates/BaseGame/game/tools/VerveEditor/main.tscript
+++ b/Templates/BaseGame/game/tools/VerveEditor/main.tscript
@@ -5,7 +5,7 @@
 
 function InitializeVerveEditor()
 {
-   $Verve::UseSeparateWindow = true;
+   $Verve::UseSeparateWindow = ($pref::Video::deviceMode == 0); //can't do separate window atm if you're in fullscreen or borderless full
    
     // Preferences.
     exec( "./DefaultPrefs." @ $TorqueScriptFileExtension );
@@ -59,7 +59,7 @@ function DestroyVerveEditor()
 
 function ToggleVerveEditor( %value )
 {
-    if ( %value && $Verve::UseSeparateWindow )
+    if ( %value)
     {
         if ( !isObject( VerveEditorWindow ) )
         {
@@ -97,7 +97,6 @@ function VerveEditor::LaunchEditor()
     VerveEditor::ClearHistory();
     
     // Update Window Title.
-    if($Verve::UseSeparateWindow)
       VerveEditorWindow.UpdateWindowTitle();
     
     // Update Selection.
diff --git a/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml b/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml
index c2256aeb7..ae2e6b034 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml
+++ b/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml
@@ -1,451 +1,239 @@
-<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
+<?xml version="1.0" encoding="UTF-8" standalone ="yes"?>
 <AssetImportSettings>
-    <Group
-        name="DefaultImportConfig">
-        <Group
-            name="Animations">
-            <Setting
-                name="animFPS">2</Setting>
-            <Setting
-                name="animTiming">Seconds</Setting>
-            <Setting
-                name="ImportAnimations">1</Setting>
-            <Setting
-                name="SeparateAnimations">1</Setting>
+    <Group name="DefaultImportConfig">
+        <Group name="Animations">
+            <Setting name="animFPS">2</Setting>
+            <Setting name="animTiming">Seconds</Setting>
+            <Setting name="ImportAnimations">1</Setting>
+            <Setting name="SeparateAnimations">1</Setting>
         </Group>
-        <Group
-            name="Collision">
-            <Setting
-                name="CollisionMeshPrefix">Col</Setting>
-            <Setting
-                name="GenCollisionType">CollisionMesh</Setting>
-            <Setting
-                name="GenerateCollisions">1</Setting>
-            <Setting
-                name="GenerateLOSCollisions">1</Setting>
-            <Setting
-                name="GenLOSCollisionType">CollisionMesh</Setting>
-            <Setting
-                name="LOSCollisionMeshPrefix">LOS</Setting>
+        <Group name="Collision">
+            <Setting name="CollisionMeshPrefix">Col</Setting>
+            <Setting name="GenCollisionType">CollisionMesh</Setting>
+            <Setting name="GenerateCollisions">1</Setting>
+            <Setting name="GenerateLOSCollisions">1</Setting>
+            <Setting name="GenLOSCollisionType">CollisionMesh</Setting>
+            <Setting name="LOSCollisionMeshPrefix">LOS</Setting>
         </Group>
-        <Group
-            name="General">
-            <Setting
-                name="AutomaticallyPromptMissingFiles">0</Setting>
-            <Setting
-                name="DuplicatAutoResolution">AutoPrune</Setting>
-            <Setting
-                name="PreventImportWithErrors">1</Setting>
-            <Setting
-                name="WarningsAsErrors">0</Setting>
-            <Setting
-                name="AddDirectoryPrefixToAssetName">0</Setting>
+        <Group name="General">
+            <Setting name="AddDirectoryPrefixToAssetName">0</Setting>
+            <Setting name="AutomaticallyPromptMissingFiles">0</Setting>
+            <Setting name="DuplicatAutoResolution">AutoPrune</Setting>
+            <Setting name="PreventImportWithErrors">1</Setting>
+            <Setting name="WarningsAsErrors">0</Setting>
         </Group>
-        <Group
-            name="Images">
-            <Setting
-                name="AddedImageSuffix">_image</Setting>
-            <Setting
-                name="AlwaysAddImageSuffix">1</Setting>
-            <Setting
-                name="AOTypeSuffixes">_AO,_AMBIENT,_AMBIENTOCCLUSION</Setting>
-            <Setting
-                name="CompositeTypeSuffixes">_COMP,_COMPOSITE,_PBR,-COMP,-COMPOSITE,-PBR,_ORM,-ORM</Setting>
-            <Setting
-                name="Compressed">1</Setting>
-            <Setting
-                name="DiffuseTypeSuffixes">_ALBEDO,_DIFFUSE,_ALB,_DIF,_COLOR,_COL</Setting>
-            <Setting
-                name="GenerateMaterialOnImport">0</Setting>
-            <Setting
-                name="ImageType">N/A</Setting>
-            <Setting
-                name="ImportImages">1</Setting>
-            <Setting
-                name="IsHDR">0</Setting>
-            <Setting
-                name="MetalnessTypeSuffixes">_METAL,_MET,_METALNESS,_METALLIC</Setting>
-            <Setting
-                name="NormalTypeSuffixes">_NORMAL,_NORM</Setting>
-            <Setting
-                name="RoughnessTypeSuffixes">_ROUGH,_ROUGHNESS</Setting>
-            <Setting
-                name="Scaling">1.0</Setting>
-            <Setting
-                name="SmoothnessTypeSuffixes">_SMOOTH,_SMOOTHNESS</Setting>
-            <Setting
-                name="TextureFilteringMode">Bilinear</Setting>
-            <Setting
-                name="UseMips">1</Setting>
+        <Group name="Images">
+            <Setting name="AddedImageSuffix">_image</Setting>
+            <Setting name="AlwaysAddImageSuffix">1</Setting>
+            <Setting name="AOTypeSuffixes">_AO,_AMBIENT,_AMBIENTOCCLUSION</Setting>
+            <Setting name="CompositeTypeSuffixes">_COMP,_COMPOSITE,_PBR,-COMP,-COMPOSITE,-PBR,_ORM,-ORM</Setting>
+            <Setting name="Compressed">1</Setting>
+            <Setting name="DiffuseTypeSuffixes">_ALBEDO,_DIFFUSE,_ALB,_DIF,_COLOR,_COL</Setting>
+            <Setting name="GenerateMaterialOnImport">0</Setting>
+            <Setting name="ImageType">N/A</Setting>
+            <Setting name="ImportImages">1</Setting>
+            <Setting name="IsHDR">0</Setting>
+            <Setting name="MetalnessTypeSuffixes">_METAL,_MET,_METALNESS,_METALLIC</Setting>
+            <Setting name="NormalTypeSuffixes">_NORMAL,_NORM</Setting>
+            <Setting name="RoughnessTypeSuffixes">_ROUGH,_ROUGHNESS</Setting>
+            <Setting name="Scaling">1.0</Setting>
+            <Setting name="SmoothnessTypeSuffixes">_SMOOTH,_SMOOTHNESS</Setting>
+            <Setting name="TextureFilteringMode">Bilinear</Setting>
+            <Setting name="UseMips">1</Setting>
         </Group>
-        <Group
-            name="Materials">
-            <Setting
-                name="AddedMaterialSuffix">_mat</Setting>
-            <Setting
-                name="AlwaysAddMaterialSuffix">0</Setting>
-            <Setting
-                name="CreateComposites">1</Setting>
-            <Setting
-                name="ImportMaterials">1</Setting>
-            <Setting
-                name="PopulateMaterialMaps">1</Setting>
-            <Setting
-                name="UseDiffuseSuffixOnOriginImage">1</Setting>
-            <Setting
-                name="UseExistingMaterials">1</Setting>
+        <Group name="Materials">
+            <Setting name="AddedMaterialSuffix">_mat</Setting>
+            <Setting name="AlwaysAddMaterialSuffix">0</Setting>
+            <Setting name="CreateComposites">1</Setting>
+            <Setting name="ImportMaterials">1</Setting>
+            <Setting name="PopulateMaterialMaps">1</Setting>
+            <Setting name="UseDiffuseSuffixOnOriginImage">1</Setting>
+            <Setting name="UseExistingMaterials">1</Setting>
         </Group>
-        <Group
-            name="Meshes">
-            <Setting
-                name="AddedShapeSuffix">_shape</Setting>
-            <Setting
-                name="AdjustCenter">0</Setting>
-            <Setting
-                name="AdjustFloor">0</Setting>
-            <Setting
-                name="AlwaysAddShapeSuffix">0</Setting>
-            <Setting
-                name="calcTangentSpace">0</Setting>
-            <Setting
-                name="CollapseSubmeshes">0</Setting>
-            <Setting
-                name="convertLeftHanded">0</Setting>
-            <Setting
-                name="DoScaleOverride">0</Setting>
-            <Setting
-                name="DoUpAxisOverride">0</Setting>
-            <Setting
-                name="findInstances">0</Setting>
-            <Setting
-                name="flipUVCoords">0</Setting>
-            <Setting
-                name="genUVCoords">0</Setting>
-            <Setting
-                name="IgnoreNodeScale">0</Setting>
-            <Setting
-                name="ImportMesh">1</Setting>
-            <Setting
-                name="invertNormals">0</Setting>
-            <Setting
-                name="JoinIdenticalVerts">0</Setting>
-            <Setting
-                name="limitBoneWeights">0</Setting>
-            <Setting
-                name="LODType">TrailingNumber</Setting>
-            <Setting
-                name="removeRedundantMats">0</Setting>
-            <Setting
-                name="reverseWindingOrder">0</Setting>
-            <Setting
-                name="ScaleOverride">1</Setting>
-            <Setting
-                name="TransformUVs">0</Setting>
-            <Setting
-                name="UpAxisOverride">Z_AXIS</Setting>
+        <Group name="Meshes">
+            <Setting name="AddedShapeSuffix">_shape</Setting>
+            <Setting name="AdjustCenter">0</Setting>
+            <Setting name="AdjustFloor">0</Setting>
+            <Setting name="AlwaysAddShapeSuffix">0</Setting>
+            <Setting name="calcTangentSpace">0</Setting>
+            <Setting name="CollapseSubmeshes">0</Setting>
+            <Setting name="convertLeftHanded">0</Setting>
+            <Setting name="DoScaleOverride">0</Setting>
+            <Setting name="DoUpAxisOverride">0</Setting>
+            <Setting name="findInstances">0</Setting>
+            <Setting name="flipUVCoords">0</Setting>
+            <Setting name="genUVCoords">0</Setting>
+            <Setting name="IgnoreNodeScale">0</Setting>
+            <Setting name="ImportMesh">1</Setting>
+            <Setting name="invertNormals">0</Setting>
+            <Setting name="JoinIdenticalVerts">0</Setting>
+            <Setting name="limitBoneWeights">0</Setting>
+            <Setting name="LODType">TrailingNumber</Setting>
+            <Setting name="removeRedundantMats">0</Setting>
+            <Setting name="reverseWindingOrder">0</Setting>
+            <Setting name="ScaleOverride">1</Setting>
+            <Setting name="TransformUVs">0</Setting>
+            <Setting name="UpAxisOverride">Z_AXIS</Setting>
         </Group>
-        <Group
-            name="Sounds">
-            <Setting
-                name="Compressed">0</Setting>
-            <Setting
-                name="PitchAdjust">1.0</Setting>
-            <Setting
-                name="VolumeAdjust">1.0</Setting>
+        <Group name="Sounds">
+            <Setting name="Compressed">0</Setting>
+            <Setting name="PitchAdjust">1.0</Setting>
+            <Setting name="VolumeAdjust">1.0</Setting>
         </Group>
     </Group>
-    <Group
-        name="LegacyProjectImport">
-        <Group
-            name="Animations">
-            <Setting
-                name="animFPS">2</Setting>
-            <Setting
-                name="animTiming">Seconds</Setting>
-            <Setting
-                name="ImportAnimations">1</Setting>
-            <Setting
-                name="SeparateAnimations">1</Setting>
+    <Group name="LegacyProjectImport">
+        <Group name="Animations">
+            <Setting name="animFPS">2</Setting>
+            <Setting name="animTiming">Seconds</Setting>
+            <Setting name="ImportAnimations">1</Setting>
+            <Setting name="SeparateAnimations">1</Setting>
         </Group>
-        <Group
-            name="Collision">
-            <Setting
-                name="CollisionMeshPrefix">Col</Setting>
-            <Setting
-                name="GenCollisionType">CollisionMesh</Setting>
-            <Setting
-                name="GenerateCollisions">1</Setting>
-            <Setting
-                name="GenerateLOSCollisions">1</Setting>
-            <Setting
-                name="GenLOSCollisionType">CollisionMesh</Setting>
-            <Setting
-                name="LOSCollisionMeshPrefix">LOS</Setting>
+        <Group name="Collision">
+            <Setting name="CollisionMeshPrefix">Col</Setting>
+            <Setting name="GenCollisionType">CollisionMesh</Setting>
+            <Setting name="GenerateCollisions">1</Setting>
+            <Setting name="GenerateLOSCollisions">1</Setting>
+            <Setting name="GenLOSCollisionType">CollisionMesh</Setting>
+            <Setting name="LOSCollisionMeshPrefix">LOS</Setting>
         </Group>
-        <Group
-            name="General">
-            <Setting
-                name="AutomaticallyPromptMissingFiles">0</Setting>
-            <Setting
-                name="DuplicateAutoResolution">FolderPrefix</Setting>
-            <Setting
-                name="PreventImportWithErrors">1</Setting>
-            <Setting
-                name="WarningsAsErrors">0</Setting>
-            <Setting
-                name="AddDirectoryPrefixToAssetName">1</Setting>
+        <Group name="General">
+            <Setting name="AddDirectoryPrefixToAssetName">1</Setting>
+            <Setting name="AutomaticallyPromptMissingFiles">0</Setting>
+            <Setting name="DuplicateAutoResolution">FolderPrefix</Setting>
+            <Setting name="PreventImportWithErrors">1</Setting>
+            <Setting name="WarningsAsErrors">0</Setting>
         </Group>
-        <Group
-            name="Images">
-            <Setting
-                name="AddedImageSuffix">_image</Setting>
-            <Setting
-                name="AlwaysAddImageSuffix">1</Setting>
-            <Setting
-                name="AOTypeSuffixes">_AO,_AMBIENT,_AMBIENTOCCLUSION</Setting>
-            <Setting
-                name="CompositeTypeSuffixes">_COMP,_COMPOSITE</Setting>
-            <Setting
-                name="Compressed">1</Setting>
-            <Setting
-                name="DiffuseTypeSuffixes">_ALBEDO,_DIFFUSE,_ALB,_DIF,_COLOR,_COL</Setting>
-            <Setting
-                name="GenerateMaterialOnImport">0</Setting>
-            <Setting
-                name="ImageType">N/A</Setting>
-            <Setting
-                name="ImportImages">1</Setting>
-            <Setting
-                name="IsHDR">0</Setting>
-            <Setting
-                name="MetalnessTypeSuffixes">_METAL,_MET,_METALNESS,_METALLIC</Setting>
-            <Setting
-                name="NormalTypeSuffixes">_NORMAL,_NORM</Setting>
-            <Setting
-                name="RoughnessTypeSuffixes">_ROUGH,_ROUGHNESS</Setting>
-            <Setting
-                name="Scaling">1.0</Setting>
-            <Setting
-                name="SmoothnessTypeSuffixes">_SMOOTH,_SMOOTHNESS</Setting>
-            <Setting
-                name="TextureFilteringMode">Bilinear</Setting>
-            <Setting
-                name="UseMips">1</Setting>
+        <Group name="Images">
+            <Setting name="AddedImageSuffix">_image</Setting>
+            <Setting name="AlwaysAddImageSuffix">1</Setting>
+            <Setting name="AOTypeSuffixes">_AO,_AMBIENT,_AMBIENTOCCLUSION</Setting>
+            <Setting name="CompositeTypeSuffixes">_COMP,_COMPOSITE</Setting>
+            <Setting name="Compressed">1</Setting>
+            <Setting name="DiffuseTypeSuffixes">_ALBEDO,_DIFFUSE,_ALB,_DIF,_COLOR,_COL</Setting>
+            <Setting name="GenerateMaterialOnImport">0</Setting>
+            <Setting name="ImageType">N/A</Setting>
+            <Setting name="ImportImages">1</Setting>
+            <Setting name="IsHDR">0</Setting>
+            <Setting name="MetalnessTypeSuffixes">_METAL,_MET,_METALNESS,_METALLIC</Setting>
+            <Setting name="NormalTypeSuffixes">_NORMAL,_NORM</Setting>
+            <Setting name="RoughnessTypeSuffixes">_ROUGH,_ROUGHNESS</Setting>
+            <Setting name="Scaling">1.0</Setting>
+            <Setting name="SmoothnessTypeSuffixes">_SMOOTH,_SMOOTHNESS</Setting>
+            <Setting name="TextureFilteringMode">Bilinear</Setting>
+            <Setting name="UseMips">1</Setting>
         </Group>
-        <Group
-            name="Materials">
-            <Setting
-                name="AddedMaterialSuffix">_mat</Setting>
-            <Setting
-                name="AlwaysAddMaterialSuffix">1</Setting>
-            <Setting
-                name="CreateComposites">1</Setting>
-            <Setting
-                name="ImportMaterials">1</Setting>
-            <Setting
-                name="PopulateMaterialMaps">1</Setting>
-            <Setting
-                name="UseDiffuseSuffixOnOriginImage">1</Setting>
-            <Setting
-                name="UseExistingMaterials">1</Setting>
+        <Group name="Materials">
+            <Setting name="AddedMaterialSuffix">_mat</Setting>
+            <Setting name="AlwaysAddMaterialSuffix">1</Setting>
+            <Setting name="CreateComposites">1</Setting>
+            <Setting name="ImportMaterials">1</Setting>
+            <Setting name="PopulateMaterialMaps">1</Setting>
+            <Setting name="UseDiffuseSuffixOnOriginImage">1</Setting>
+            <Setting name="UseExistingMaterials">1</Setting>
         </Group>
-        <Group
-            name="Meshes">
-            <Setting
-                name="AddedShapeSuffix">_shape</Setting>
-            <Setting
-                name="AdjustCenter">0</Setting>
-            <Setting
-                name="AdjustFloor">0</Setting>
-            <Setting
-                name="AlwaysAddShapeSuffix">0</Setting>
-            <Setting
-                name="calcTangentSpace">0</Setting>
-            <Setting
-                name="CollapseSubmeshes">0</Setting>
-            <Setting
-                name="convertLeftHanded">0</Setting>
-            <Setting
-                name="DoScaleOverride">0</Setting>
-            <Setting
-                name="DoUpAxisOverride">0</Setting>
-            <Setting
-                name="findInstances">0</Setting>
-            <Setting
-                name="flipUVCoords">0</Setting>
-            <Setting
-                name="genUVCoords">0</Setting>
-            <Setting
-                name="IgnoreNodeScale">0</Setting>
-            <Setting
-                name="ImportMesh">1</Setting>
-            <Setting
-                name="invertNormals">0</Setting>
-            <Setting
-                name="JoinIdenticalVerts">0</Setting>
-            <Setting
-                name="limitBoneWeights">0</Setting>
-            <Setting
-                name="LODType">TrailingNumber</Setting>
-            <Setting
-                name="removeRedundantMats">0</Setting>
-            <Setting
-                name="reverseWindingOrder">0</Setting>
-            <Setting
-                name="ScaleOverride">1</Setting>
-            <Setting
-                name="TransformUVs">0</Setting>
-            <Setting
-                name="UpAxisOverride">Z_AXIS</Setting>
+        <Group name="Meshes">
+            <Setting name="AddedShapeSuffix">_shape</Setting>
+            <Setting name="AdjustCenter">0</Setting>
+            <Setting name="AdjustFloor">0</Setting>
+            <Setting name="AlwaysAddShapeSuffix">0</Setting>
+            <Setting name="calcTangentSpace">0</Setting>
+            <Setting name="CollapseSubmeshes">0</Setting>
+            <Setting name="convertLeftHanded">0</Setting>
+            <Setting name="DoScaleOverride">0</Setting>
+            <Setting name="DoUpAxisOverride">0</Setting>
+            <Setting name="findInstances">0</Setting>
+            <Setting name="flipUVCoords">0</Setting>
+            <Setting name="genUVCoords">0</Setting>
+            <Setting name="IgnoreNodeScale">0</Setting>
+            <Setting name="ImportMesh">1</Setting>
+            <Setting name="invertNormals">0</Setting>
+            <Setting name="JoinIdenticalVerts">0</Setting>
+            <Setting name="limitBoneWeights">0</Setting>
+            <Setting name="LODType">TrailingNumber</Setting>
+            <Setting name="removeRedundantMats">0</Setting>
+            <Setting name="reverseWindingOrder">0</Setting>
+            <Setting name="ScaleOverride">1</Setting>
+            <Setting name="TransformUVs">0</Setting>
+            <Setting name="UpAxisOverride">Z_AXIS</Setting>
         </Group>
-        <Group
-            name="Sounds">
-            <Setting
-                name="Compressed">0</Setting>
-            <Setting
-                name="PitchAdjust">1.0</Setting>
-            <Setting
-                name="VolumeAdjust">1.0</Setting>
+        <Group name="Sounds">
+            <Setting name="Compressed">0</Setting>
+            <Setting name="PitchAdjust">1.0</Setting>
+            <Setting name="VolumeAdjust">1.0</Setting>
         </Group>
     </Group>
-    <Group
-        name="NewTest">
-        <Group
-            name="Animations">
-            <Setting
-                name="animFPS">2</Setting>
-            <Setting
-                name="animTiming">Seconds</Setting>
-            <Setting
-                name="ImportAnimations">1</Setting>
-            <Setting
-                name="SeparateAnimations">1</Setting>
+    <Group name="NewTest">
+        <Group name="Animations">
+            <Setting name="animFPS">2</Setting>
+            <Setting name="animTiming">Seconds</Setting>
+            <Setting name="ImportAnimations">1</Setting>
+            <Setting name="SeparateAnimations">1</Setting>
         </Group>
-        <Group
-            name="Collision">
-            <Setting
-                name="CollisionMeshPrefix">Col</Setting>
-            <Setting
-                name="GenCollisionType">CollisionMesh</Setting>
-            <Setting
-                name="GenerateCollisions">1</Setting>
-            <Setting
-                name="GenerateLOSCollisions">1</Setting>
-            <Setting
-                name="GenLOSCollisionType">CollisionMesh</Setting>
-            <Setting
-                name="LOSCollisionMeshPrefix">LOS</Setting>
+        <Group name="Collision">
+            <Setting name="CollisionMeshPrefix">Col</Setting>
+            <Setting name="GenCollisionType">CollisionMesh</Setting>
+            <Setting name="GenerateCollisions">1</Setting>
+            <Setting name="GenerateLOSCollisions">1</Setting>
+            <Setting name="GenLOSCollisionType">CollisionMesh</Setting>
+            <Setting name="LOSCollisionMeshPrefix">LOS</Setting>
         </Group>
-        <Group
-            name="General">
-            <Setting
-                name="AutomaticallyPromptMissingFiles">0</Setting>
-            <Setting
-                name="DuplicatAutoResolution">AutoPrune</Setting>
-            <Setting
-                name="PreventImportWithErrors">1</Setting>
-            <Setting
-                name="WarningsAsErrors">0</Setting>
-            <Setting
-                name="AddDirectoryPrefixToAssetName">0</Setting>
+        <Group name="General">
+            <Setting name="AddDirectoryPrefixToAssetName">0</Setting>
+            <Setting name="AutomaticallyPromptMissingFiles">0</Setting>
+            <Setting name="DuplicatAutoResolution">AutoPrune</Setting>
+            <Setting name="PreventImportWithErrors">1</Setting>
+            <Setting name="WarningsAsErrors">0</Setting>
         </Group>
-        <Group
-            name="Images">
-            <Setting
-                name="AOTypeSuffixes">_AO,_AMBIENT,_AMBIENTOCCLUSION</Setting>
-            <Setting
-                name="Compressed">1</Setting>
-            <Setting
-                name="DiffuseTypeSuffixes">_ALBEDO,_DIFFUSE,_ALB,_DIF,_COLOR,_COL</Setting>
-            <Setting
-                name="GenerateMaterialOnImport">1</Setting>
-            <Setting
-                name="ImageType">N/A</Setting>
-            <Setting
-                name="IsHDR">0</Setting>
-            <Setting
-                name="MetalnessTypeSuffixes">_METAL,_MET,_METALNESS,_METALLIC</Setting>
-            <Setting
-                name="NormalTypeSuffixes">_NORMAL,_NORM</Setting>
-            <Setting
-                name="PBRTypeSuffixes">_COMP,_COMPOSITE,_PBR,-COMP,-COMPOSITE,-PBR,_ORM,-ORM</Setting>
-            <Setting
-                name="RoughnessTypeSuffixes">_ROUGH,_ROUGHNESS</Setting>
-            <Setting
-                name="Scaling">1.0</Setting>
-            <Setting
-                name="SmoothnessTypeSuffixes">_SMOOTH,_SMOOTHNESS</Setting>
-            <Setting
-                name="TextureFilteringMode">Bilinear</Setting>
-            <Setting
-                name="UseMips">1</Setting>
+        <Group name="Images">
+            <Setting name="AOTypeSuffixes">_AO,_AMBIENT,_AMBIENTOCCLUSION</Setting>
+            <Setting name="Compressed">1</Setting>
+            <Setting name="DiffuseTypeSuffixes">_ALBEDO,_DIFFUSE,_ALB,_DIF,_COLOR,_COL</Setting>
+            <Setting name="GenerateMaterialOnImport">1</Setting>
+            <Setting name="ImageType">N/A</Setting>
+            <Setting name="IsHDR">0</Setting>
+            <Setting name="MetalnessTypeSuffixes">_METAL,_MET,_METALNESS,_METALLIC</Setting>
+            <Setting name="NormalTypeSuffixes">_NORMAL,_NORM</Setting>
+            <Setting name="PBRTypeSuffixes">_COMP,_COMPOSITE,_PBR,-COMP,-COMPOSITE,-PBR,_ORM,-ORM</Setting>
+            <Setting name="RoughnessTypeSuffixes">_ROUGH,_ROUGHNESS</Setting>
+            <Setting name="Scaling">1.0</Setting>
+            <Setting name="SmoothnessTypeSuffixes">_SMOOTH,_SMOOTHNESS</Setting>
+            <Setting name="TextureFilteringMode">Bilinear</Setting>
+            <Setting name="UseMips">1</Setting>
         </Group>
-        <Group
-            name="Materials">
-            <Setting
-                name="CreateComposites">1</Setting>
-            <Setting
-                name="ImportMaterials">1</Setting>
-            <Setting
-                name="PopulateMaterialMaps">1</Setting>
-            <Setting
-                name="UseDiffuseSuffixOnOriginImage">1</Setting>
-            <Setting
-                name="UseExistingMaterials">1</Setting>
+        <Group name="Materials">
+            <Setting name="CreateComposites">1</Setting>
+            <Setting name="ImportMaterials">1</Setting>
+            <Setting name="PopulateMaterialMaps">1</Setting>
+            <Setting name="UseDiffuseSuffixOnOriginImage">1</Setting>
+            <Setting name="UseExistingMaterials">1</Setting>
         </Group>
-        <Group
-            name="Meshes">
-            <Setting
-                name="AdjustCenter">0</Setting>
-            <Setting
-                name="AdjustFloor">0</Setting>
-            <Setting
-                name="calcTangentSpace">0</Setting>
-            <Setting
-                name="CollapseSubmeshes">0</Setting>
-            <Setting
-                name="convertLeftHanded">0</Setting>
-            <Setting
-                name="DoScaleOverride">0</Setting>
-            <Setting
-                name="DoUpAxisOverride">0</Setting>
-            <Setting
-                name="findInstances">0</Setting>
-            <Setting
-                name="flipUVCoords">0</Setting>
-            <Setting
-                name="genUVCoords">0</Setting>
-            <Setting
-                name="IgnoreNodeScale">0</Setting>
-            <Setting
-                name="ImportMesh">1</Setting>
-            <Setting
-                name="invertNormals">0</Setting>
-            <Setting
-                name="JoinIdenticalVerts">0</Setting>
-            <Setting
-                name="limitBoneWeights">0</Setting>
-            <Setting
-                name="LODType">TrailingNumber</Setting>
-            <Setting
-                name="removeRedundantMats">0</Setting>
-            <Setting
-                name="reverseWindingOrder">0</Setting>
-            <Setting
-                name="ScaleOverride">1</Setting>
-            <Setting
-                name="TransformUVs">0</Setting>
-            <Setting
-                name="UpAxisOverride">Z_AXIS</Setting>
+        <Group name="Meshes">
+            <Setting name="AdjustCenter">0</Setting>
+            <Setting name="AdjustFloor">0</Setting>
+            <Setting name="calcTangentSpace">0</Setting>
+            <Setting name="CollapseSubmeshes">0</Setting>
+            <Setting name="convertLeftHanded">0</Setting>
+            <Setting name="DoScaleOverride">0</Setting>
+            <Setting name="DoUpAxisOverride">0</Setting>
+            <Setting name="findInstances">0</Setting>
+            <Setting name="flipUVCoords">0</Setting>
+            <Setting name="genUVCoords">0</Setting>
+            <Setting name="IgnoreNodeScale">0</Setting>
+            <Setting name="ImportMesh">1</Setting>
+            <Setting name="invertNormals">0</Setting>
+            <Setting name="JoinIdenticalVerts">0</Setting>
+            <Setting name="limitBoneWeights">0</Setting>
+            <Setting name="LODType">TrailingNumber</Setting>
+            <Setting name="removeRedundantMats">0</Setting>
+            <Setting name="reverseWindingOrder">0</Setting>
+            <Setting name="ScaleOverride">1</Setting>
+            <Setting name="TransformUVs">0</Setting>
+            <Setting name="UpAxisOverride">Z_AXIS</Setting>
         </Group>
-        <Group
-            name="Sounds">
-            <Setting
-                name="Compressed">0</Setting>
-            <Setting
-                name="PitchAdjust">1.0</Setting>
-            <Setting
-                name="VolumeAdjust">1.0</Setting>
+        <Group name="Sounds">
+            <Setting name="Compressed">0</Setting>
+            <Setting name="PitchAdjust">1.0</Setting>
+            <Setting name="VolumeAdjust">1.0</Setting>
         </Group>
     </Group>
 </AssetImportSettings>
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfig.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfig.tscript
index 30eac0209..44be3b3ce 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfig.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfig.tscript
@@ -35,6 +35,7 @@ function setupImportConfigSettingsList()
       ImportAssetConfigSettingsList.addNewConfigSetting("General/WarningsAsErrors", "Warnings As Errors", "bool", "", "0", "", "");
       ImportAssetConfigSettingsList.addNewConfigSetting("General/PreventImportWithErrors", "Prevent Import With Errors", "bool", "", "1", "", "");
       ImportAssetConfigSettingsList.addNewConfigSetting("General/AutomaticallyPromptMissingFiles", "Automatically Prompt Missing Files", "bool", "", "0", "", "");
+      ImportAssetConfigSettingsList.addNewConfigSetting("General/AddDirectoryPrefixToAssetName", "Adds the name of the folder to importing asset name", "bool", "", "0", "", "");
    
       ImportAssetConfigSettingsList.addNewConfigSetting("Meshes/ImportMesh", "Import Mesh", "bool", "", "1", "", "ToggleImportMesh");
       ImportAssetConfigSettingsList.addNewConfigSetting("Meshes/AlwaysAddShapeSuffix", "Always Add Shape Suffix", "bool", "", "0", "");
@@ -117,6 +118,8 @@ function setupImportConfigSettingsList()
       ImportAssetConfigSettingsList.addNewConfigSetting("Sounds/VolumeAdjust", "Volume Adjustment", "float", "", "1.0", "");
       ImportAssetConfigSettingsList.addNewConfigSetting("Sounds/PitchAdjust", "Pitch Adjustment", "float", "", "1.0", "");
       ImportAssetConfigSettingsList.addNewConfigSetting("Sounds/Compressed", "Is Compressed", "bool", "", "0", "");
+      ImportAssetConfigSettingsList.addNewConfigSetting("Sounds/AlwaysAddSoundSuffix", "Always Add Sound Suffix", "bool", "", "1", "");
+      ImportAssetConfigSettingsList.addNewConfigSetting("Sounds/AddedSoundSuffix", "Added Sound Suffix", "string", "", "_sound", "");
    }
 }
 
@@ -272,7 +275,7 @@ function ImportAssetConfigEditorWindow::populateConfigList(%this, %configName)
    %this.populateConfigListByGroup("Animations");
    %this.populateConfigListByGroup("Images");
    %this.populateConfigListByGroup("Collision");
-   %this.populateConfigListByGroup("Sound");
+   %this.populateConfigListByGroup("Sounds");
    
    ImportOptionsConfigList.update();
 }
@@ -373,6 +376,8 @@ function ImportAssetConfigEditorWindow::addNewConfig(%this)
    AssetImportSettings.setValue("Sounds/VolumeAdjust", "1.0");
    AssetImportSettings.setValue("Sounds/PitchAdjust", "1.0");
    AssetImportSettings.setValue("Sounds/Compressed", "0");
+   AssetImportSettings.setValue("Sounds/AlwaysAddSoundSuffix", "1");
+   AssetImportSettings.setValue("Sounds/AddedSoundSuffix", "_sound");
    
    AssetImportSettings.endGroup();
    
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfigEditor.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfigEditor.tscript
index 2ad61eee0..effa43f52 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfigEditor.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfigEditor.tscript
@@ -38,10 +38,10 @@ function AssetImportConfigList::onSelect( %this, %id, %text )
    %this.populateConfigListByGroup("General");
    %this.populateConfigListByGroup("Meshes");
    %this.populateConfigListByGroup("Materials");
-   %this.populateConfigListByGroup("Animations");
    %this.populateConfigListByGroup("Images");
+   %this.populateConfigListByGroup("Sounds");
+   %this.populateConfigListByGroup("Animations");
    %this.populateConfigListByGroup("Collision");
-   %this.populateConfigListByGroup("Sound");
    
    ImportOptionsConfigList.update();  
 }
diff --git a/Templates/BaseGame/game/tools/gui/images/stencilIcons/larger.png b/Templates/BaseGame/game/tools/gui/images/stencilIcons/larger.png
new file mode 100644
index 0000000000000000000000000000000000000000..4f5d73310dca5211a7e69b92d834df08fd3ffecb
GIT binary patch
literal 15389
zcmeI3du$X%9LE=eLJKIC@=}AFQ!GU8cK2TGt#^m*T}z7|l(s-oqilDl?b^HB<96G-
ztBUo7;3L+GC@K&i#Gp|k2)+;vT4*Xt#79t!rbvPi2=)&HT71mjb9%jFF!9g1Y<s`X
ze1G5B`OI&o`_HbeT{wSY;gy9HMNO=!_SV5~N&gvlDf}He`b-1-DhO3CS1D@zWc_Cp
z_56#|Dax^4ZfMjReYfzU5-<sp(gaM=KnSWS$~i9@62vy3(M_O54!R6yKK$4~%aY5m
z%;sZ#ArEMkt2@J>zH?!N*x4pJB*Q#+p)<-ug8<M3IvVf?RX*x6#C>@f>&=XTj!U#Q
zm!VuAkZ$zV(jFxYXq(Aq6j?JzmpV+G&FbK|xwM((EDXmoW`~jEcxx%o+3DoR;4Xxb
zGb}apb>6DvaPTjep;gmDJi|mH5mUrsQo=0^=WsX}*36jAMyN2Vv7jbIjY0L=gh|TB
z3sf;IhcsCU(z>tEq_k@;gFzoC{YlO%5K0deRFmu=MJ6hQ7|z5pd6Im-3#SDFIWtwQ
z4rFGQb3nBr76MEiP?h$u2%!AhT(_WVl^t+ONkkW6RM`Q7T23oTO#6h|!~QsENo0T@
z1Yn8^DR4RG5^7a6MQv5`08Dr1#i+^6d06N@dDB2t&XcD1B+}wFl~`&gEM(pj27;!9
z8x+OwPLykH>h5Wehn~Gm4oXTyo#SM()tQ>f7y+-K0XM8^E39TCYi=-eyoKX!wi{TE
zXIaD~q0I8|DU#eA8{uK**)ra0MLiH@wg=pUlAs9}<$`L5`}ll(O;FW@pa^QbZa8<7
zEK9u2!HPne!)!D=ETXZAvjU^TEW$q}3v1y@ORW~MEI!HM=_9PYirB8#P|{k0*4DBr
zuiakhwVORv99L;At0=RSdu&!qg~!f0Z1$8bk~-2Bgyjw(RfUy6e0zt4unP2D<1(bS
zP5L}Y)<AsU@$$&2Chw;_|NV?e&D;+(cP6@}yfdx9IU}hV=QM`QRI^GNqF)r2;fXHz
z5mx#N{uj(SERdUkZg7}tS%q6ChK#SzTR&Ip!OG#SsSdw<kqeVv9(bDZf~cR^ZdHJb
z>ty05T&gW|Q;7_HpoAdDnqFM_j!4fxMx+%4hi&()t(vfktMZ$uO0yOb!l1kb?g-2w
zlrS8gk>6Qt6@o25ax*DtsfO$nC!?>LUmm__iPqt3nX12$YwwgqzF7$e1kEi6gciVr
zf-O!a)0i34nf?#JdlbJChKCt&TbxX;W+Y2L`}NX>l!SOaa871KTeiMY-}wIaxW3fP
z!Vi4ffS+V4+MS)c{KBbdcXnzfb4gIv+~(wHS<Oh6{tqevqaHq#0k_>|v)G(Wc5`+{
ztsDjZMz0LdQdQp}aB9h<?4F#N%kyR;J;}^OF(406@mfi=!pAfCWXPl+4TqOedSm|2
zL1s$-voUH%20>|HV}c8d2o(@qC=F~(aA6Ul0)h*rfsF|+EFx4uaG^A?F~NmJgbD~Q
zlm<2?xUh&&0l|gRz{Ug@77;2SxKJ9{nBc-9LIngDN&_1cTv$Y?fZ#%DU}J&{iwG4E
zTqq4}OmJZlp#p*nrGbqJE-WHcKyaZnura}fMT80nE|dl~Cb+POPyxY((!j<97ZwpJ
zAh=K(*qGqLB0>cO7fJ&g6I@tCsDR)?X<%c53yTO95L_q?Y)o)r5upNt3#EaL2`(%m
zR6uZ{G_dgnaTR7>wgf@=hGhi4O8IiZcTxBnCM{Oi`6#M$7DaVENKt?M1HVsDR69#i
zCs$Au{~Se4Q+n>~t)i&WqiVe64bdM?{rJ^Wd+Fk;fvfh7K2$UJ{?mPRyVjk)>E<;X
zTQB+k+1;ncubgT+->u%UadD4w%ieJdkL;RpqPXmmu1Pd{jTuL$uU8NC4!F*IDgJ$B
z?4GATHH<y8Wb)U2zx>kE>w1V9rC*&J9y!)w+41e*U*gf7Z)~{tU1zj6*4H*qKG=V}
ziQDnWhA$3y{<fbfX+AMYJbZVxuXx6U-(TpQSUl(PnVYsd7awCgW2b(<>8a0tm1ou!
zRZe|nO5gKqdv3dIA8)8W;GHuV7-FifzT()%wM|d#`F7<sL)~Y)H`Tr_yt8NP*{-@N
zo`E?x&)CAR?iaTi7EGS7CAOw$fn|ba^Ut29>-%@^70+JLcVyt4`>vx0Tb|oGImaX$
zKA1Z6P5sb&({B7}^T0=o{%St)=A_8M!JUV%G0$RWcI*!J-@W<I&kqgN+Yb(Iy?y(-
z^^q@^-gn=l#cPh<dZc;ws0qe()at1VD9`v=T`xU+X!LbsMdNROv|ZmHq8-!U{^a=l
zwh!lRc`VlV+VolLBMY{DaCyn6-SZ1dKI^V3DCzC4EGXI6?JX$T-|cyS%_`5TqHSCM
zQIw_Um2HR5ohx{D{~e>pOoG=*Fte!l$>p8*oT@+GQ`tpTWUj=z)ef#2OKo4WdVImS
S!Xo_z-kQpV-nS}NJn%2AIqYZv

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/tools/gui/images/stencilIcons/larger_image.asset.taml b/Templates/BaseGame/game/tools/gui/images/stencilIcons/larger_image.asset.taml
new file mode 100644
index 000000000..6a0f57ae1
--- /dev/null
+++ b/Templates/BaseGame/game/tools/gui/images/stencilIcons/larger_image.asset.taml
@@ -0,0 +1,8 @@
+<ImageAsset
+    canSave="true"
+    canSaveDynamicFields="true"
+    AssetName="larger_image"
+    imageFile="@assetFile=larger.png"
+    UseMips="true"
+    isHDRImage="false"
+    imageType="Albedo" />
diff --git a/Templates/BaseGame/game/tools/gui/images/stencilIcons/smaller.png b/Templates/BaseGame/game/tools/gui/images/stencilIcons/smaller.png
new file mode 100644
index 0000000000000000000000000000000000000000..c1520a5120492f4c22bfbe2172af38a04d1b75b4
GIT binary patch
literal 15374
zcmeI3eQXnD9LH~SDr_+D4FS!(REbPz@2+dR_0n~2?dFCQ#+b4hbi3Z&w#(YPa(AQM
z)JQ~;5tJ7<P%*}d8kB$u8i|;=5HldS;7ewVN;GaUf+ACl4n>2{_4QfT^323PpXRpy
z_B`L;_qpfu{GMm`&-K=?xMz0$!hC`tX4lnv8^E_<{LHup{0@!wH-fL3q1tARAPR0U
zesYKxUYt)5&RtStliuW8&hkpo!U>9Bv_yg-pe6`cMI^-WouW?q#db+9H;unPXd)${
z+_c8-qkSQd*df*SsN(9L6^(pPC+`$Y74CdjgarmcQRm1=Fd%Deq}&wsWkGB-QzkMh
z(L2jcmBxT%ldqoiD5^->Ep{_cTN$#{X<_U(C&Mfytu#|YF*Id$ni+<*m9mV3jDJk-
zd=R-*p^a_u*2IScf0dg$bUnmUR5%>Agi9=n+D<V}r<0<sl+|hm3bWQN>s-VvYq!Tt
z5<Xs0<5el7ONvYyzMNm_(#uUIW1!?GKCfUXIgqTy*#U}FgbPuOg{HD3`FvMS3kEZ0
zYI=j1npwsHwZ`s{NHvI>(xvhukl&u^7BszjJ(yA)(KL*z*Nd{A(MsTxKA|o(5Ctvp
zlo$|$AVmWdn2d7?btt-`btqW?CcCp@)TOp8ER3G4X<|gml4kV8(xNpLTWS|5WY(jK
zoUW*iiV|?g%C$am_oT-|E?y(af)dt>T~xX{RWm6g(aY(g8`QK7RI{13Hd-0BgkkOW
zB{aj*G-MJ}rg``jL2B!s;$da!GS<$(9*{EK1MES8)46H6z}m?^J|9~rYdR<MVx89w
z=5CQBfwgf?r=6kO%>FV)Fw>mPZstlIwAs%)Xq$r<95$;zI?2iDQ>?uT-(}QL+*&ZK
z%WAw1N43*o_0%v-wXLkGtfbOox0O_R9E{WMNZ3NDQ*A|6S}zJUsuGND?+~YIqOohr
zO^I!jJP+bE5Z!mIlwqo|`*CEypDC%S`vK;zShtXMrllxnC^hAr#E_b5T1f-+D^&@c
z=v)9|Wvt+T!JNSYx(VP0hN+b_uywkj@r`*K=jv*4-Q?CpM?jk9!X%dmoMtS?8z;6~
z<G|v&sOSloXiMExEW;QmCdjm=(<<L7>Dk8!cZl+&?Vh$(V^&dBb`wo$)5Dx9R<?s3
zfjER>hLbb0JM$f!+%5`kDgiCgke=eAj8zLrlNT-4I(aP<^*43xT>{UxDQb|@-BOTi
z7paik?xIqSsWDy2{{XB<2`DN!%tUvIi^|jtWf^C`QQCkK7p(`zMNMf-*Ebm(KhPD`
zms)A?0Z$v?6HkS^(^H$ToC<fRr=~LRlO^44jgOYr3}qSrpkgpqgNHKF?XcTR>@F(3
zIX$CZiim+GuLRCg&DbGeYVoA>o{X8zSu>%YcxJ2^pa-aEt;AZv;~97|q>_(@lglW%
zG5_ZvHKqUA7`DTMz%-CC#)U)#3otI21~SIDkceOb#s$+r#uyh85iG#CU>e96<3b{W
z1sE4h0~upnNJOvz<AP}*V~h)l2o_*mFb!mkaUl`G0*ni$fs8ROBqCUValtf@F~)^N
z1Pd@Om<BS&xR8io0mcQ>K*kss5)mxGxL_K{7~?`Bf&~~COamEXTu4N)0ONvbAY+UR
zi3k>8Trdq}jBz0m!2*m6rh$wxE+isYfN{YzkTJ%EL<9>kE|>-~#<-A(U;)Mj(?G@;
z7ZMRHz_?%<$oPu5@>4HciZXb^G7Mg&TrzT@0=$Mv^0f^<g6LU95F0iU#GjYJ_gRAI
zq6y;1R)S!kBZ!-ooh?H(1d(&0&Rf|S`Rd&1qw78-Z>;`w&a=5Ay$|M|Kk?eDefsvk
zmv#SrF9$}=Lhfxv7r!}hY~i_*%7#0xJN29Gv*HUk5LFxCYc9DVd2L^&6khs!X<%^A
zm*Jrwlv86L{e0QqHvZCBLE#){-};O6+kKVAkGjjYQ3CzJaNxIFzujEidFdbj?%uYY
zgZ||Y&w765YquObv+=K4iyvfeJawpV)e(N*i+|kp%B-XHM+#R}E!gzk)rZ!+vi0CK
z{F=PF{>Ax^9k@JHyM?@G(aEjlOyTGJi6sNJ4}Wp*8_Zp{dTUX8^OC)`<7c|Qdf&9A
zpyuPBw)fYcriYK6p3^+AZTQ`@=bsvxcYo1sheJcTd2@|R*x@?p*?BR%tEi>**9EUH
zjW@?SpCEFK>w(fSt@&{O@#9*ve~dplIzLY1?X^$6I{fbb{x9}4jLXkZMZZ5{+5dU|
z%)M`UigvY(cWx=}Jfq(9^w-1d7HprfY2LCtPr;(c2cEqC=qFXZtsMiA4I{1Rax2b1
z)N8u7VdIXxyLZlBJAUu?EqAWm>S<l-*_~sEy!1Quruh#nzHXMe4|ts1JTWqnyJ_ML
z<xTH<J%!Iqj0}y=vygc+;43G0M$VzCimQmt)=dRDg=b~sjorHH72bnYt&jf;6w%xs

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/tools/gui/images/stencilIcons/smaller_image.asset.taml b/Templates/BaseGame/game/tools/gui/images/stencilIcons/smaller_image.asset.taml
new file mode 100644
index 000000000..98bdfaf08
--- /dev/null
+++ b/Templates/BaseGame/game/tools/gui/images/stencilIcons/smaller_image.asset.taml
@@ -0,0 +1,8 @@
+<ImageAsset
+    canSave="true"
+    canSaveDynamicFields="true"
+    AssetName="smaller_image"
+    imageFile="@assetFile=smaller.png"
+    UseMips="true"
+    isHDRImage="false"
+    imageType="Albedo" />
diff --git a/Templates/BaseGame/game/tools/gui/profiles.ed.tscript b/Templates/BaseGame/game/tools/gui/profiles.ed.tscript
index e59be8ddf..492423e3d 100644
--- a/Templates/BaseGame/game/tools/gui/profiles.ed.tscript
+++ b/Templates/BaseGame/game/tools/gui/profiles.ed.tscript
@@ -163,7 +163,8 @@ new GuiControlProfile (ToolsGuiWindowProfile)
    opaque = false;
    border = 1;
    fillColor = EditorSettings.value("Theme/tabsColor");
-   fillColorHL = EditorSettings.value("Theme/tabsColor");
+   fillColorHL = EditorSettings.value("Theme/tabsHLColor");
+   fillColorSEL = EditorSettings.value("Theme/tabsSELColor");
    fillColorNA = EditorSettings.value("Theme/tabsColor");
    fontColor = EditorSettings.value("Theme/headerTextColor");
    fontColorHL = EditorSettings.value("Theme/headerTextColor");
diff --git a/Templates/BaseGame/game/tools/materialEditor/gui/guiMaterialPropertiesWindow.ed.gui b/Templates/BaseGame/game/tools/materialEditor/gui/guiMaterialPropertiesWindow.ed.gui
index 50b5563a8..0f71d8757 100644
--- a/Templates/BaseGame/game/tools/materialEditor/gui/guiMaterialPropertiesWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/materialEditor/gui/guiMaterialPropertiesWindow.ed.gui
@@ -113,7 +113,7 @@ $guiContent = new GuiControl(MaterialEditorGui,EditorGuiGroup) {
                   HorizSizing = "left";
                   tooltip = "Swap material on the object with existing";
                   bitmapAsset = "ToolsModule:change_material_btn_n_image";
-                  command = "materialSelector.showDialog(\"MaterialEditorGui.showMaterialChangeSaveDialog\");"; 
+                  command = "MaterialEditorGui.swapMaterial();"; 
                };
                
                new GuiTextEditCtrl(){ 
diff --git a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
index 24b00874a..072925f14 100644
--- a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
@@ -465,6 +465,9 @@ function MaterialEditorGui::setActiveMaterial( %this, %material )
    MaterialEditorGui.lastMaterial = %material;
    
    // we create or recreate a material to hold in a pristine state
+   if(isObject(notDirtyMaterial))
+      notDirtyMaterial.delete();
+      
    singleton Material(notDirtyMaterial)
    {
       mapTo = "matEd_mappedMat";
@@ -1949,8 +1952,8 @@ function MaterialEditorGui::showMaterialChangeSaveDialog( %this, %toMaterial )
    
    toolsMessageBoxYesNoCancel("Save Material?", 
       "The material " @ %fromMaterial.getName() @ " has unsaved changes. <br>Do you want to save before changing the material?", 
-      "MaterialEditorGui.saveDialogSave(" @ %toMaterial @ "); MaterialEditorGui.changeMaterial(" @ %fromMaterial @ ", " @ %toMaterial @ ");", 
-      "MaterialEditorGui.saveDialogDontSave(" @ %toMaterial @ "); MaterialEditorGui.changeMaterial(" @ %fromMaterial @ ", " @ %toMaterial @ ");", 
+      "MaterialEditorGui.saveDialogSave(\"" @ %toMaterial @ "\"); MaterialEditorGui.changeMaterial(" @ %fromMaterial @ ", \"" @ %toMaterial @ "\");", 
+      "MaterialEditorGui.saveDialogDontSave(\"" @ %toMaterial @ "\"); MaterialEditorGui.changeMaterial(" @ %fromMaterial @ ", \"" @ %toMaterial @ "\");", 
       "MaterialEditorGui.saveDialogCancel();" );
 }
 
@@ -1986,11 +1989,21 @@ function MaterialEditorGui::saveDialogDontSave( %this, %material )
    
    MaterialEditorGui.setMaterialNotDirty();
    
+   if(AssetDatabase.isDeclaredAsset(%material))
+   {
+      %material = AssetDatabase.acquireAsset(%material).materialDefinitionName;
+   }
+   
    MaterialEditorGui.setActiveMaterial( %material );
 }
 
 function MaterialEditorGui::saveDialogSave( %this, %material )
 {
+   if(AssetDatabase.isDeclaredAsset(%material))
+   {
+      %material = AssetDatabase.acquireAsset(%material).materialDefinitionName;
+   }
+      
    MaterialEditorGui.save();
    MaterialEditorGui.setActiveMaterial( %material );
 }
@@ -2277,16 +2290,34 @@ function MaterialEditorGui::changeMaterial(%this, %fromMaterial, %toMaterial)
    %materialTarget = SubMaterialSelector.text;
    %action.materialTarget = %materialTarget;   
    
+   %toMaterialDefinition = %toMaterial;
+   
+   %isMatAsset = false;
+   if(AssetDatabase.isDeclaredAsset(%toMaterial))
+   {
+      %isMatAsset = true;
+      %assetDef = AssetDatabase.acquireAsset(%toMaterial);
+      %toMaterialDefinition = %assetDef.materialDefinitionName;
+      %filename = %assetDef.getScriptPath();
+   }
+   
    %action.fromMaterial = %fromMaterial;    
    %action.toMaterial = %toMaterial;   
-   %action.toMaterialOldFname = %toMaterial.getFilename();
+   %action.toMaterialOldFname = %toMaterialDefinition.getFilename();
    %action.object =  MaterialEditorGui.currentObject;
 
    if( MaterialEditorGui.currentMeshMode $= "Model" ) // Models
    {
       %action.mode = "model";      
       
-      MaterialEditorGui.currentObject.changeMaterial( %materialTarget, %fromMaterial.getName(), %toMaterial.getName() );
+      if(!%isMatAsset)
+      {
+         MaterialEditorGui.currentObject.changeMaterial( %materialTarget, %fromMaterial.getName(), %toMaterialDefinition.getName() );
+      }
+      else
+      {
+         eval("MaterialEditorGui.currentObject." @ %materialTarget @ " = " @ %toMaterial);
+      }
       
       if( MaterialEditorGui.currentObject.shapeName !$= "" ) 
          %sourcePath = MaterialEditorGui.currentObject.shapeName;
@@ -2296,6 +2327,8 @@ function MaterialEditorGui::changeMaterial(%this, %fromMaterial, %toMaterial)
             %sourcePath = MaterialEditorGui.currentObject.getDatablock().shapeFile;
       }
       
+      if(!%isMatAsset)
+      {
       // Creating "to" path
       %k = 0;
       while( strpos( %sourcePath, "/", %k ) != -1 )
@@ -2308,28 +2341,33 @@ function MaterialEditorGui::changeMaterial(%this, %fromMaterial, %toMaterial)
       
       %action.toMaterialNewFname = %fileName;
       
-      MaterialEditorGui.prepareActiveMaterial( %toMaterial, true );
-      if( !MaterialEditorGui.isMatEditorMaterial( %toMaterial ) )
+         MaterialEditorGui.prepareActiveMaterial( %toMaterialDefinition, true );
+         if( !MaterialEditorGui.isMatEditorMaterial( %toMaterialDefinition ) )
       {
-         matEd_PersistMan.removeObjectFromFile(%toMaterial);
+            matEd_PersistMan.removeObjectFromFile(%toMaterialDefinition);
+         }
       }
       
       matEd_PersistMan.setDirty(%fromMaterial);
-      matEd_PersistMan.setDirty(%toMaterial, %fileName);
+      matEd_PersistMan.setDirty(%toMaterialDefinition, %fileName);
       matEd_PersistMan.saveDirty();
       
       matEd_PersistMan.removeDirty(%fromMaterial);
-      matEd_PersistMan.removeDirty(%toMaterial);
+      matEd_PersistMan.removeDirty(%toMaterialDefinition);
    }
    else // EditorShapes
    {
       %action.mode = "editorShapes";
 
-      MaterialEditorGui.currentObject.setFieldValue(SubMaterialSelector.getText(), %toMaterial.getName());
+      if(!%isMatAsset)
+         MaterialEditorGui.currentObject.setFieldValue(SubMaterialSelector.getText(), %toMaterialDefinition.getName());
+      else
+         MaterialEditorGui.currentObject.setFieldValue(SubMaterialSelector.getText(), %toMaterial);
+         
       if( MaterialEditorGui.currentObject.isMethod("postApply") )
          MaterialEditorGui.currentObject.postApply();
       
-      MaterialEditorGui.prepareActiveMaterial( %toMaterial, true );
+      MaterialEditorGui.prepareActiveMaterial( %toMaterialDefinition, true );
    }
    
    MaterialEditorGui.submitUndo( %action );
@@ -2458,3 +2496,12 @@ function MaterialEditorGui::saveCompositeMap(%this)
     saveCompositeTexture(%aoMap,%roughMap,%metalMap,"",%channelKey, %saveAs);
     %dlg.delete();
 }
+
+function MaterialEditorGui::swapMaterial(%this)
+{
+   AssetBrowser.showDialog("MaterialAsset", %this @ ".doSwapMaterial", "", "", "");
+}
+function MaterialEditorGui::doSwapMaterial(%this, %materialAsset)
+{
+   MaterialEditorGui.showMaterialChangeSaveDialog(%materialAsset);
+}
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/missionAreaEditor/images/mission-area_h.png b/Templates/BaseGame/game/tools/missionAreaEditor/images/mission-area_h.png
index b96012a60889e0cae1fe49d9e85aa4f18549fdfe..e4d4e1cc0b2305df4d8a4ec97c10176551ab6e1f 100644
GIT binary patch
literal 1254
zcmV<C1R48@P)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80004nX+uL$Nkc;*
zaB^>EX>4Tx04R}tkv&MmKpe$iQ>9WW3KkS`$WUFhAS$ApRIvyaN?V~-2a`*`ph-)T
z;^HW{799LotU9<j>+0Yt2!bCVZf;JBE>hzEl0u6Z503ls?%w0>9U#<8Of@>j0aY{g
zL^L9%GpnNS6@K)i7o(V!m{Ex(7gKN@U-$6v^)Ae_+|T_vx|OWK0FOvK$11u>yg@v@
zX;wJz69-vAQi#uq$8@?N@gvt|hu=8oZ5DWDP){Z1iG##qzK!KJW(8d(o+1t@sz&)j
z+F^zB7H73oWzBo?7Y4H0N|Ng|hY-aQVu(Y8j4FyK!9<u=jT8e3+K;&S2W@|xTr#<e
zVB}ap87d^(5B>+gyESr?6HZbf0(8Du*2gg5+XWgm%lbaHti}o8eFm<ymcLvFW<E);
zwY1O?(6bF(T(>lN54hX`2A(RCF4>ZorjW}4?`QN)8KCbL@UJ<&HTQA)0Hmm^<s0DO
z5E#i*_PWcvyV`sE_e`_D9{~4q;7>%2nE(I)24YJ`L;(K){{a7>y{D4^000SaNLh0L
z04^f{04^f|c%?sf00007bV*G`2jvPE5Hm2tx1ss~00QDkL_t(o!|j$yZxmM$$A9&f
zc|BRJDBG25mILx9Kmr9NMj{-LSPuCD;TR8!&EjsnTzx~y5s<JHP{<`dB;O!8aN%kx
zQY1tmLc|%SyQeCL8BfMmunjW`mnrF~U%!6KzpCE9{w)vxc<?1J(Ht+?CIBV?!m~ci
zw$85(zppGWo!jrG&$Bk{woy?O0L;zJapUljRRNp`vKNBs>1}IYC;~fe=GJ$3?@1{m
zgn$g8FoP{r0{k-D8a)L&(LZ_e7mY>(47AbMHgD+s|6IG9$!?YK#^EEYN7vTa{CgAc
zJXtfNnKfyo#`cqqf8FnomsQElPe0>}pMN^{!YmNLIY$hUloDCWNGTCRB!<Y-d-vFA
zwfOUgJH!~d|IN4jmKV5Ahtx<ok<n7%L`bQD2!s#@eKQ5%wU0j{zV|*4Zrw&zdAPpL
z+n*nYW`?N}_W@wf2wb|nz~a&}Ax50{AcC3=+Ph~?V`kjHcAa$K0B@Z<N&9J=vZ_YE
zgaDT>U8L-kRAq?(;vC+&?Kg112BY0>_cjgz88rd`s)m}97gs3D3RCNi_1o`PuL3YN
zGefzt!K0gNs2a|>z3at(B4DbR_1qMJx~_4)7llXP-(mCaUEVo$idT<*Lg(>gHrLn5
zKKy`m@Zfk-&^ue0|GLNPs;USUkRVJQJI3pW4xuSgmL+eVJ<A&>P9U!|Da#5q8$AVv
zVx}0%LSFRxLycyJY8NwQd1Zw(HHG(Kz?6|AFr04y=RB%PU3YQLVb&XqQSja)(tDcO
zcrM|vw-@H;FjKB9E|C`ns>(v1lNSZvJ1$<B$4sf~3X%P3{WDAPPD!1e{fZbPbzM`}
z^}yS$g0+=zGh=aa2@%2d={goUE<2q*=ZzR5s!G)_Hr{)>-R^+@&N=ct$2m7XIsWnV
z8Jq}F1TTWYz-tj1P}PYb)6)a*$0o;nsoJpp+B&~F7CD~$6;A+60Q?{J4?=rV@B0CA
QtN;K207*qoM6N<$g7p<aUjP6A

literal 1218
zcmV;z1U>tSP)<h;3K|Lk000e1NJLTq0012T000{Z0ssI252zDG0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU$WJyFpRCwB~Rm*N1MHH>7uI`?m$=DXM
z6SE@O@>oO`t8DNFB5<UTMWj5wfru=yCB}Kp#7Pz)C9EP~g|mnyf(RS@0VqNdEV95X
zZ6Se;AIQ_0NB7KBac)(0yFE_ChU%W0>Z;TC-a7ZxZN9U;6+e&FKrzNN)0}bJvqHlR
z`r^_-q{X0l!mEx{WixJ8t0R?4h5cvK*?_-f)y%hBt+*MB!C+7>m&u(rF0;G%=*D?m
z1=!xr+#o8KVN()JY3pk5ZPOG}2e&yie;{arAr7g?s=I*x=+dPebnounAx}kq(GP)h
z4B55ji{2WI2Krj9_VtMqupv0-FJpXaDhDS?B243g@+lFnR*Jpo-I+(<dY%`CB`IaT
zuCx50`(<`62RC<j{lG`6JVrL9p;z<5cH!I(;`n(G1lWT@Kb-bqaI+a#s)vFg<U$Z#
zzpwl@Ir%DKvp2qZXZqyQQmfs95=#+XK^W|r)CH+&miE$z?|<;_;^IIJAlA{*(ZCPZ
z*Z&gA5J8<LLNFjsh47^xf&yG&h%xT&%F628+&@1&_I-cj%dh^ZH$;+zL5Ku|Vc<(?
zGQqX6MLJW&na&BcI6y$F9RP}jLvOw5ADP^I^qo>_dwF^M!_zD(ArznUQi*Z^(g3y*
z3KypR(I2$Qu3f*eaO*ar6rP8ax+Sd-UpNo=#^QtU*s)j6p6zryX|D&D(li1iE~T7)
zv%KZ0X4kJ>O%qU;;t_f9gcv%?c(c>#Sc}{^)-E<O0-G*grCh-1=|mCFs@}Mnrae1p
z??3O~$LiS3OuD+d^Kc0>Bv^{kpt7Hd*BIs89S*BgyJjEz{XPOl$UEOZZasT8aqe8@
z<a^2PZfkkD^v3Jq@#7|Zmv_@MqhI&T^9?#i7@z-?wAt(Rq?TOru~Vn2)6*&p(=;8u
zcyZ*+8D5UCAwvQyY}e$C^kCz+DzkQ(K{0is-pF!BHw2*60E63i?u27wo+qtTlpc@;
zW;xYa-Jvy}1<D=28P`Y~u>Jl3RAL#AzRz*KkuLNw!HGoX)NkU&zqBq2wMA!q(S2pU
z27aMAOwQM8byH<9dG*SC-!zg}0S}AZ5W$~5{dr=1!sLs}S>xtHe)eZ)Kf%$m@7n;G
zDR0VcO)o6m!lW=NynOj%pBfd&&CN}lH(k)~UY$&n#72)pj6L<t5r6}H4y<xvv0ksE
zH{cXtL0(8(Qadf1;P)5HAJ1PvbU3C6)u`Pn&q<Q1!PJz<j!di7LQ16sHmj2bZS5<4
zZ+~&GL@f#e-{o|_<6l4fJO`&~B7Juns7^k4^3yo@Ei~*mZZ_NPHr%2@mZAu>?f;5p
z9<=WD``u0lD#k>)QmIy}C~RBXTN%H$xMnZ-K@b^cz$WEF$`=^TzWGW8lvR{g<KBJW
z@X%?uqbPDk1-67h(WRni*hG~QoFDvBSo;!=rJo&oeA`5~(}hj`_s06#+8T}~`=1)V
gaz|e~`mX>30G~`$T?ibl^#A|>07*qoM6N<$g7{Kd2><{9

diff --git a/Templates/BaseGame/game/tools/missionAreaEditor/images/mission-area_n.png b/Templates/BaseGame/game/tools/missionAreaEditor/images/mission-area_n.png
index 5612871e727f2d493b9e94529f9f8084e4824b65..5817fb9e775fcff3ec3e22509e1dd1fd70b1336e 100644
GIT binary patch
literal 1472
zcmV;x1wZ<UP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80004nX+uL$Nkc;*
zaB^>EX>4Tx04R}tkv&MmKpe$iQ>9WW3KkS`$WUFhAS$ApRIvyaN?V~-2a`*`ph-)T
z;^HW{799LotU9<j>+0Yt2!bCVZf;JBE>hzEl0u6Z503ls?%w0>9U#<8Of@>j0aY{g
zL^L9%GpnNS6@K)i7o(V!m{Ex(7gKN@U-$6v^)Ae_+|T_vx|OWK0FOvK$11u>yg@v@
zX;wJz69-vAQi#uq$8@?N@gvt|hu=8oZ5DWDP){Z1iG##qzK!KJW(8d(o+1t@sz&)j
z+F^zB7H73oWzBo?7Y4H0N|Ng|hY-aQVu(Y8j4FyK!9<u=jT8e3+K;&S2W@|xTr#<e
zVB}ap87d^(5B>+gyESr?6HZbf0(8Du*2gg5+XWgm%lbaHti}o8eFm<ymcLvFW<E);
zwY1O?(6bF(T(>lN54hX`2A(RCF4>ZorjW}4?`QN)8KCbL@UJ<&HTQA)0Hmm^<s0DO
z5E#i*_PWcvyV`sE_e`_D9{~4q;7>%2nE(I)24YJ`L;(K){{a7>y{D4^000SaNLh0L
z04^f{04^f|c%?sf00007bV*G`2jvPE5HSZyJZ5(Q00X>9L_t(o!|j(bPclsq$A7!G
zdv}0JWo>I=WyHipKNE>yAn~lQpu+EAX=`O-VL~N-0t*uh8&Svu2e(i0W;e&NCw6b~
zzLOA^-I>|Bxtafefd9G(fX~lQgb;4i7=sYPeHX<T^N(>sr_9dk=cQh+1E7kRTF3eC
z;^p}Z^Lszp`St*0QNb5&e$PIkU6(oj&E+nDqEnxPVh}%_mx)hD`O+$c;Qai2MSCz9
zh%%?eOqALB9!?bx^6TsCYXFiYq1kL2d(m&wp0}OP=SV5tXDxtY7JQN<2|*ALMG;D=
z(kd51(Cv0tY`?y~&{|WiR{a5#U7jR~TTdnv!Z6&}89v+Z?{8|g8gU$N#(})EX0vH7
zFE5!)CP*o%R;$EuOcX_HeP8UPG)?JrI&?Z6k!2aRT8(<WP8fy&?Ck8UwqaSDDW!;_
zh-$S;rBb0%sSt)CVHooM{?6^~Ezi%-L{Y@U!vlABcNk-c;}|I=aU7$y_P+nMBJ=@D
z9LESD&{{jER`&Mx7>z~@heM1pj7B3GjRs*Dl4Th|5KygFNz;@lio5~HpL$jZL6Ri&
zdOgB0L@BlA<m~JWfXBy2c6WC<K0fBppFb=X3jnm%&bG7-eQ0Rc{eGX>Y{p`-KuU=a
zf*=UIZEK8SKA&TZL2K;=tY2lIsA!BKNfH)|#oF2Z{XGDOhlhN8eDL)21mJ?q*OU(l
zW%0lmv-aCwDy3w(T(Vp)0T>R4yuQA2baceY$qD=W`@Foo@b>oR1-Ff_z(-0#2&9zs
z`+bBEESF2C(`Ym}I5<El#cVd?^z_sfVVb6E5Aq`!`RKJMola+MFNz|vECb-`>WZD6
z9kkYK87)Iu^;_C>21;R!A<HsXlv-<oARq_=lu`siu+q{S>DY(oJ{b%KE)(r`8)FQu
zR*QDKjZ%u6n;QU@%cTo$6CDeH@p!xjtF2aRMZ4ec6NVv+#lp3u#e}?FmStRAT)5f+
z==FL+YrWE%7K&97g3IW5Hk%=(#2Dj{&Vr4U($#?lt6r~%l+w|$h4o^Fm5&E}ub|uQ
zBBdk<0vAYeIL(h~dBmJfr!H_CL}?qAQEI2t5tT~C%Z8p{P2M(5Q?%A(S+-{5YQQJ+
z`JC~1%w#el%QB)Ua%{M1T29lH>2yk(rU)U}+S+1!d)w8)S`GN-dMTwFLM*%4iD=V6
zVr^`TT1qa(0pI@uJA_#DE0U4#V!LPO2wR-iwy3YlSj`$qDINH18qbS`oX^xIl>J}+
aHTes{y8ys8GxlWw0000<MNUMnLSTaZ8?FHW

literal 845
zcmV-T1G4;yP)<h;3K|Lk000e1NJLTq0012T000{Z0ssI252zDG0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU!?@2^KRCwBamOW2uK@f%o4j&g#Xsl@|
ztPGf#;9mm6N3ID{L188T!_t<Dgu;YM_yraw7Bqel6omVD28VSH+$lD*d)|3>c4l_=
zgr1+DL!r=~FRRrGUB*2}SYdQO1(AYL@f0MMI=ZCFrPHlQcN*5Y*-)qAmnep47wI>z
zYi4jR_15*E=qJyFtXi!q==%CPXy$qy1nVbHHB~yD4&&wJWu;OH{m3o{75w@68U7KQ
zHzS}Ukw`oq_dG9{cUCSgE)@Lw`WlT!lgZ?oH%JPdDDUs@u~=+Zc^L59+gmD?N+c5N
zUA2DIfa5otO-R|9{ej}LTeEHn&FAyKzATqZcr%#{uB_`USWg@rE=d3Q67%Kh>FMU?
z=KlVkPyK%X_VyM$yRtnaLD1lC@@A?X93xOM6KF1%8;wT8;SexNu~=j?+$0BhfaC0^
z;PBQ;B5Lh+8#5eNC~|go#yA)Z4i67cPEKaC*<!I^1rG$gsWZ38G{jd|S05iA*g(n(
z9+_GMNntU<Xl~6Ge_aGNcn!6?*z5HekB^ThlgZuP9lC6(xzQ>NtG4pR6che_`GQVl
zA08eGg~I9SX+EDHkH?RXkLFt0IGFB(4kOV(fmA+`sH3AJf=Gx;rIO^0bh+OA>N}<f
zx{;wU-6<KT08m=3*1^F6!FA8-+Im~N+^-JpecwswB!_TCd|{nY3)J>WbL9=GbSb>9
z*XzJ)wHgYH-ENn4LL{4Q>Dn(ZFYX1!QbEL*2rhilyQD}?&}cLy6HKZ1s4udOXC5xM
z^^qTJ_$2pAt^g|%V!1NVF-o752C(h~ZgVhkpbcU}5QW`+J@r}A+c=$0#e+39ad2za
zeFDzU&uKcQpP7wSFPF=7iEK72q1f=Ma3U7zlbjbu>1VrMXzCYF8CglE)BF4T!s`Y9
z95|Y^bLmy`UhL}Y0+ZsCR%z=&p-W%nnz?<)z+}4o5lN|nf5pK(_`808{)5*;{1adR
Xeyjx=)AJ4p00000NkvXXu0mjf(zl7R

diff --git a/Templates/BaseGame/game/tools/particleEditor/ParticleEditor.ed.gui b/Templates/BaseGame/game/tools/particleEditor/ParticleEditor.ed.gui
index 681e67f7d..594a4dd92 100644
--- a/Templates/BaseGame/game/tools/particleEditor/ParticleEditor.ed.gui
+++ b/Templates/BaseGame/game/tools/particleEditor/ParticleEditor.ed.gui
@@ -214,7 +214,7 @@ $guiContent = new GuiWindowCollapseCtrl(PE_Window) {
                      groupNum = "-1";
                      buttonType = "PushButton";
                      useMouseEvents = "0";
-                     bitmapAsset = "ToolsModule:new_image";
+                     bitmapAsset = "ToolsModule:new_n_image";
                      tooltip = "Create New Emitter";
                   };
                   new GuiBitmapButtonCtrl() {
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
index d68fa2258..3e950231a 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
@@ -1883,10 +1883,16 @@ function EditorTree::GetTooltipGroundCover( %this, %obj )
 // Tooltip for SFXEmitter
 function EditorTree::GetTooltipSFXEmitter( %this, %obj )
 {
+   %soundName = %obj.soundAsset;
+   if(%soundName $= "")
+   {
    if(%obj.fileName $= "")
-      return "Track: " @ %obj.track;
+         %soundName = "Track: " @ %obj.track;
    else
-      return "File: " @ %obj.fileName;
+         %soundName = "File: " @ %obj.fileName;
+   }
+
+   return "Sound: " @ %soundName;
 }
 
 // Tooltip for ParticleEmitterNode
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/menus.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/menus.ed.tscript
index bf69e6bdb..48cb8c5d5 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/menus.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/menus.ed.tscript
@@ -354,7 +354,7 @@ function EditorGui::buildMenus(%this)
 
       barTitle = "Tools";
          
-      item[0] = "Network Graph" TAB "n" TAB "toggleNetGraph();";
+      item[0] = "Network Graph" TAB "ctrl n" TAB "toggleNetGraph();";
       item[1] = "Profiler" TAB "ctrl F2" TAB "showMetrics(true);";
 	  item[2] = "Torque SimView" TAB "" TAB "tree();";
       item[3] = "Make Selected a Mesh" TAB "" TAB "AssetBrowser.setupCreateNewAsset(\"ShapeAsset\", AssetBrowser.selectedModule, \"makeSelectedAMesh\");";

From 7b77877c6336cb5b089db564eb36ec58a69c14ff Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Fri, 29 Oct 2021 16:25:31 -0500
Subject: [PATCH 220/399] fix material scrolling

---
 .../game/tools/materialEditor/scripts/materialEditor.ed.tscript | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
index 24b00874a..5e1ebc782 100644
--- a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
@@ -1313,7 +1313,7 @@ function MaterialEditorGui::updateScrollOffset(%this, %isSlider, %onMouseUp)
 	%Y = MaterialEditorPropertiesWindow-->ScrollTextEditV.getText();
 	MaterialEditorPropertiesWindow-->ScrollCrosshair.setPosition( -(23 * %X)+20, -(23 * %Y)+20);
 	
-	MaterialEditorGui.updateActiveMaterial("scrollDir[" @ %layer @ "]","\"" @ %X SPC %Y @ "\"",%isSlider,%onMouseUp);	
+	MaterialEditorGui.updateActiveMaterial("scrollDir[" @ %layer @ "]",%X SPC %Y,%isSlider,%onMouseUp);	
 }
 
 function MaterialEditorGui::updateScrollSpeed(%this, %isSlider, %onMouseUp)

From 0dcd272b873300c858617bdf7d77cee92232de1a Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Sun, 31 Oct 2021 14:38:02 -0500
Subject: [PATCH 221/399] clean up more texture profile refs to kill spam

---
 Engine/source/gui/buttons/guiIconButtonCtrl.h        | 2 +-
 Engine/source/gui/buttons/guiToolboxButtonCtrl.h     | 6 +++---
 Engine/source/gui/controls/guiTreeViewCtrl.cpp       | 2 +-
 Engine/source/gui/core/guiTypes.cpp                  | 2 +-
 Engine/source/gui/core/guiTypes.h                    | 2 +-
 Engine/source/gui/worldEditor/editorIconRegistry.cpp | 6 +++---
 Engine/source/gui/worldEditor/guiMissionArea.h       | 2 +-
 7 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/Engine/source/gui/buttons/guiIconButtonCtrl.h b/Engine/source/gui/buttons/guiIconButtonCtrl.h
index 8196fef49..081201ad8 100644
--- a/Engine/source/gui/buttons/guiIconButtonCtrl.h
+++ b/Engine/source/gui/buttons/guiIconButtonCtrl.h
@@ -42,7 +42,7 @@ private:
 
 protected:
 
-   DECLARE_IMAGEASSET(GuiIconButtonCtrl, Bitmap, onImageChanged, GFXTexturePersistentSRGBProfile);
+   DECLARE_IMAGEASSET(GuiIconButtonCtrl, Bitmap, onImageChanged, GFXDefaultGUIProfile);
    DECLARE_ASSET_SETGET(GuiIconButtonCtrl, Bitmap);
 
    S32               mIconLocation;
diff --git a/Engine/source/gui/buttons/guiToolboxButtonCtrl.h b/Engine/source/gui/buttons/guiToolboxButtonCtrl.h
index 8741cdee9..fd3e360ad 100644
--- a/Engine/source/gui/buttons/guiToolboxButtonCtrl.h
+++ b/Engine/source/gui/buttons/guiToolboxButtonCtrl.h
@@ -39,11 +39,11 @@ private:
 
 protected:
 
-   DECLARE_IMAGEASSET(GuiToolboxButtonCtrl, NormalBitmap, onNormalImageChanged, GFXTexturePersistentSRGBProfile);
+   DECLARE_IMAGEASSET(GuiToolboxButtonCtrl, NormalBitmap, onNormalImageChanged, GFXDefaultGUIProfile);
    DECLARE_ASSET_SETGET(GuiToolboxButtonCtrl, NormalBitmap);
-   DECLARE_IMAGEASSET(GuiToolboxButtonCtrl, LoweredBitmap, onLoweredImageChanged, GFXTexturePersistentSRGBProfile);
+   DECLARE_IMAGEASSET(GuiToolboxButtonCtrl, LoweredBitmap, onLoweredImageChanged, GFXDefaultGUIProfile);
    DECLARE_ASSET_SETGET(GuiToolboxButtonCtrl, LoweredBitmap);
-   DECLARE_IMAGEASSET(GuiToolboxButtonCtrl, HoverBitmap, onHoverImageChanged, GFXTexturePersistentSRGBProfile);
+   DECLARE_IMAGEASSET(GuiToolboxButtonCtrl, HoverBitmap, onHoverImageChanged, GFXDefaultGUIProfile);
    DECLARE_ASSET_SETGET(GuiToolboxButtonCtrl, HoverBitmap);
 
    void renderButton(GFXTexHandle &texture, Point2I &offset, const RectI& updateRect);
diff --git a/Engine/source/gui/controls/guiTreeViewCtrl.cpp b/Engine/source/gui/controls/guiTreeViewCtrl.cpp
index aaed67a78..ae5517a5e 100644
--- a/Engine/source/gui/controls/guiTreeViewCtrl.cpp
+++ b/Engine/source/gui/controls/guiTreeViewCtrl.cpp
@@ -1880,7 +1880,7 @@ bool GuiTreeViewCtrl::buildIconTable(const char * icons)
          dStrncpy( buf, start, getMin( sizeof( buf ) / sizeof( buf[ 0 ] ) - 1, len ) );
          buf[ len ] = '\0';
                   
-         mIconTable[ numIcons ] = GFXTexHandle( buf, &GFXTexturePersistentProfile, avar( "%s() - mIconTable[%d] (line %d)", __FUNCTION__, numIcons, __LINE__ ) );
+         mIconTable[ numIcons ] = GFXTexHandle( buf, &GFXDefaultGUIProfile, avar( "%s() - mIconTable[%d] (line %d)", __FUNCTION__, numIcons, __LINE__ ) );
       }
       else
          mIconTable[ numIcons ] = GFXTexHandle();
diff --git a/Engine/source/gui/core/guiTypes.cpp b/Engine/source/gui/core/guiTypes.cpp
index d4575d21a..85032a2ed 100644
--- a/Engine/source/gui/core/guiTypes.cpp
+++ b/Engine/source/gui/core/guiTypes.cpp
@@ -68,7 +68,7 @@ GFX_ImplementTextureProfile(GFXGuiCursorProfile,
 GFX_ImplementTextureProfile(GFXDefaultGUIProfile,
                             GFXTextureProfile::DiffuseMap, 
                             GFXTextureProfile::PreserveSize |
-                            GFXTextureProfile::Static | GFXTextureProfile::SRGB |
+                            GFXTextureProfile::Static | GFXTextureProfile::KeepBitmap | GFXTextureProfile::SRGB |
                             GFXTextureProfile::NoPadding, 
                             GFXTextureProfile::NONE);
 
diff --git a/Engine/source/gui/core/guiTypes.h b/Engine/source/gui/core/guiTypes.h
index c82c2fd50..37b77d57d 100644
--- a/Engine/source/gui/core/guiTypes.h
+++ b/Engine/source/gui/core/guiTypes.h
@@ -455,7 +455,7 @@ public:
    StringTableEntry mBitmapName; 
    StringTableEntry mBitmapAssetId; 
    AssetPtr<ImageAsset>  mBitmapAsset; 
-   GFXTextureProfile* mBitmapProfile = &GFXTexturePersistentSRGBProfile; 
+   GFXTextureProfile* mBitmapProfile = &GFXDefaultGUIProfile;
 public: 
    const StringTableEntry getBitmapFile() const { return mBitmapName; }
    void setBitmapFile(const FileName& _in) { mBitmapName = StringTable->insert(_in.c_str()); }
diff --git a/Engine/source/gui/worldEditor/editorIconRegistry.cpp b/Engine/source/gui/worldEditor/editorIconRegistry.cpp
index b75a28335..97a75c6ba 100644
--- a/Engine/source/gui/worldEditor/editorIconRegistry.cpp
+++ b/Engine/source/gui/worldEditor/editorIconRegistry.cpp
@@ -25,7 +25,7 @@
 
 #include "console/engineAPI.h"
 #include "console/simBase.h"
-
+#include "gui/core/guiTypes.h"
 
 EditorIconRegistry gEditorIcons;
 
@@ -60,7 +60,7 @@ void EditorIconRegistry::loadFromPath( const String &path, bool overwrite )
    String defaultIconFile = path + "default";
 
    mDefaultIcon.set( defaultIconFile,
-                     &GFXTexturePersistentSRGBProfile,
+                     &GFXDefaultGUIProfile,
                      avar("%s() - mIcons[] (line %d)", 
                      __FUNCTION__, __LINE__) );
 }
@@ -68,7 +68,7 @@ void EditorIconRegistry::loadFromPath( const String &path, bool overwrite )
 void EditorIconRegistry::add( const String &className, const String &imageFile, bool overwrite )
 {
    // First see if we can load the image.
-   GFXTexHandle icon(   imageFile, &GFXTexturePersistentSRGBProfile,
+   GFXTexHandle icon(   imageFile, &GFXDefaultGUIProfile,
                         avar("%s() - mIcons[] (line %d)", __FUNCTION__, __LINE__) );
    if ( icon.isNull() )
       return;
diff --git a/Engine/source/gui/worldEditor/guiMissionArea.h b/Engine/source/gui/worldEditor/guiMissionArea.h
index 32d68ecc7..947cd5a8c 100644
--- a/Engine/source/gui/worldEditor/guiMissionArea.h
+++ b/Engine/source/gui/worldEditor/guiMissionArea.h
@@ -63,7 +63,7 @@ protected:
    GFXStateBlockRef  mBlendStateBlock;
    GFXStateBlockRef  mSolidStateBlock;
 
-   DECLARE_IMAGEASSET(GuiMissionAreaCtrl, HandleBitmap, onHandleBitmapChanged, GFXTexturePersistentSRGBProfile);
+   DECLARE_IMAGEASSET(GuiMissionAreaCtrl, HandleBitmap, onHandleBitmapChanged, GFXDefaultGUIProfile);
    DECLARE_ASSET_SETGET(GuiMissionAreaCtrl, HandleBitmap);
 
    Point2I           mHandleTextureSize;

From dd03af5041b6e15f6117c8dd5d0565614eafcebd Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragora@Roberts-MacBook-Air.local>
Date: Mon, 1 Nov 2021 08:52:35 -0400
Subject: [PATCH 222/399] * BugFix: Corrections to the Unix file IO to allow
 for compilation on ARM Unix devics.

---
 Engine/source/platformMac/macVolume.mm        |  7 +-
 Engine/source/platformPOSIX/POSIXFileio.cpp   | 90 +++++++++++++++++++
 .../POSIXIO.cpp}                              |  5 +-
 .../source/platformX86UNIX/x86UNIXFileio.cpp  | 76 ----------------
 4 files changed, 94 insertions(+), 84 deletions(-)
 create mode 100644 Engine/source/platformPOSIX/POSIXFileio.cpp
 rename Engine/source/{platformX86UNIX/x86UNIXIO.cpp => platformPOSIX/POSIXIO.cpp} (96%)

diff --git a/Engine/source/platformMac/macVolume.mm b/Engine/source/platformMac/macVolume.mm
index c360be3a1..00152eef8 100644
--- a/Engine/source/platformMac/macVolume.mm
+++ b/Engine/source/platformMac/macVolume.mm
@@ -175,9 +175,4 @@ bool MacFileSystemChangeNotifier::internalRemoveNotification( const Torque::Path
 Torque::FS::FileSystemRef Platform::FS::createNativeFS( const String &volume )
 {
    return new MacFileSystem( volume );
-}
-
-bool Torque::FS::VerifyWriteAccess(const Torque::Path &path)
-{
-   return true;
-}
+}
\ No newline at end of file
diff --git a/Engine/source/platformPOSIX/POSIXFileio.cpp b/Engine/source/platformPOSIX/POSIXFileio.cpp
new file mode 100644
index 000000000..8bdcea7b5
--- /dev/null
+++ b/Engine/source/platformPOSIX/POSIXFileio.cpp
@@ -0,0 +1,90 @@
+#include "core/fileio.h"
+#include "core/util/tVector.h"
+#include "core/stringTable.h"
+#include "console/console.h"
+#include "core/strings/stringFunctions.h"
+#include "util/tempAlloc.h"
+#include "cinterface/c_controlInterface.h"
+#include "core/volume.h"
+
+/* these are for reading directors, getting stats, etc. */
+#include <dirent.h>
+#include <sys/stat.h>
+
+const int MaxPath = PATH_MAX;
+
+//------------------------------------------------------------------------------
+// munge the case of the specified pathName.  This means try to find the actual
+// filename in with case-insensitive matching on the specified pathName, and
+// store the actual found name.
+bool ResolvePathCaseInsensitive(char* pathName, S32 pathNameSize, bool requiredAbsolute)
+{
+    char tempBuf[MaxPath];
+    dStrncpy(tempBuf, pathName, pathNameSize);
+
+    // Check if we're an absolute path
+    if (pathName[0] != '/')
+    {
+        AssertFatal(!requiredAbsolute, "PATH must be absolute");
+        return false;
+    }
+
+    struct stat filestat;
+    const int MaxPathEl = 200;
+    char *currChar = pathName;
+    char testPath[MaxPath];
+    char pathEl[MaxPathEl];
+    bool done = false;
+    bool foundMatch = false;
+
+    dStrncpy(tempBuf, "/", MaxPath);
+    currChar++;
+
+    while (!done)
+    {
+        char* termChar = dStrchr(currChar, '/');
+        if (termChar == NULL)
+            termChar = dStrchr(currChar, '\0');
+        AssertFatal(termChar, "Can't find / or NULL terminator");
+
+        S32 pathElLen = (termChar - currChar);
+        dStrncpy(pathEl, currChar, pathElLen);
+        pathEl[pathElLen] = '\0';
+        dStrncpy(testPath, tempBuf, MaxPath);
+        dStrcat(testPath, pathEl, MaxPath);
+        if (stat(testPath, &filestat) != -1)
+        {
+            dStrncpy(tempBuf, testPath, MaxPath);
+        }
+        else
+        {
+            DIR *dir = opendir(tempBuf);
+            struct dirent* ent;
+            while (dir != NULL && (ent = readdir(dir)) != NULL)
+            {
+                if (dStricmp(pathEl, ent->d_name) == 0)
+                {
+                    foundMatch = true;
+                    dStrcat(tempBuf, ent->d_name, MaxPath);
+                    break;
+                }
+            }
+
+            if (!foundMatch)
+                dStrncpy(tempBuf, testPath, MaxPath);
+            if (dir)
+                closedir(dir);
+        }
+        if (*termChar == '/')
+        {
+            dStrcat(tempBuf, "/", MaxPath);
+            termChar++;
+            currChar = termChar;
+        }
+        else
+            done = true;
+    }
+
+    dStrncpy(pathName, tempBuf, pathNameSize);
+    return foundMatch;
+}
\ No newline at end of file
diff --git a/Engine/source/platformX86UNIX/x86UNIXIO.cpp b/Engine/source/platformPOSIX/POSIXIO.cpp
similarity index 96%
rename from Engine/source/platformX86UNIX/x86UNIXIO.cpp
rename to Engine/source/platformPOSIX/POSIXIO.cpp
index 975b9a9f5..8ac5924f9 100644
--- a/Engine/source/platformX86UNIX/x86UNIXIO.cpp
+++ b/Engine/source/platformPOSIX/POSIXIO.cpp
@@ -20,7 +20,8 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "platformX86UNIX/platformX86UNIX.h"
+#include "platform/types.h"
+#include "platform/platformMemory.h"
 #include "core/volume.h"
 
 #include <sys/types.h>
@@ -54,4 +55,4 @@ ssize_t x86UNIXWrite(int fd, const void *buf, size_t nbytes)
 bool Torque::FS::VerifyWriteAccess(const Torque::Path &path)
 {
    return true;
-}
+}
\ No newline at end of file
diff --git a/Engine/source/platformX86UNIX/x86UNIXFileio.cpp b/Engine/source/platformX86UNIX/x86UNIXFileio.cpp
index a3d6c2d55..591b28f1c 100644
--- a/Engine/source/platformX86UNIX/x86UNIXFileio.cpp
+++ b/Engine/source/platformX86UNIX/x86UNIXFileio.cpp
@@ -179,82 +179,6 @@ bool dPathCopy(const char *fromName, const char *toName, bool nooverwrite)
     return sgPrefDir;
  }
 
- //------------------------------------------------------------------------------
- // munge the case of the specified pathName.  This means try to find the actual
- // filename in with case-insensitive matching on the specified pathName, and
- // store the actual found name.
- bool ResolvePathCaseInsensitive(char* pathName, S32 pathNameSize, bool requiredAbsolute)
- {
-    char tempBuf[MaxPath];
-    dStrncpy(tempBuf, pathName, pathNameSize);
-
-    // Check if we're an absolute path
-    if (pathName[0] != '/')
-    {
-        AssertFatal(!requiredAbsolute, "PATH must be absolute");
-        return false;
-    }
-
-    struct stat filestat;
-    const int MaxPathEl = 200;
-    char *currChar = pathName;
-    char testPath[MaxPath];
-    char pathEl[MaxPathEl];
-    bool done = false;
-    bool foundMatch = false;
-
-    dStrncpy(tempBuf, "/", MaxPath);
-    currChar++;
-
-    while (!done)
-    {
-       char* termChar = dStrchr(currChar, '/');
-       if (termChar == NULL)
-          termChar = dStrchr(currChar, '\0');
-       AssertFatal(termChar, "Can't find / or NULL terminator");
-
-       S32 pathElLen = (termChar - currChar);
-       dStrncpy(pathEl, currChar, pathElLen);
-       pathEl[pathElLen] = '\0';
-       dStrncpy(testPath, tempBuf, MaxPath);
-       dStrcat(testPath, pathEl, MaxPath);
-       if (stat(testPath, &filestat) != -1)
-       {
-          dStrncpy(tempBuf, testPath, MaxPath);
-       }
-       else
-       {
-          DIR *dir = opendir(tempBuf);
-          struct dirent* ent;
-          while (dir != NULL && (ent = readdir(dir)) != NULL)
-          {
-             if (dStricmp(pathEl, ent->d_name) == 0)
-             {
-                foundMatch = true;
-                dStrcat(tempBuf, ent->d_name, MaxPath);
-                break;
-             }
-          }
-
-          if (!foundMatch)
-             dStrncpy(tempBuf, testPath, MaxPath);
-          if (dir)
-             closedir(dir);
-       }
-       if (*termChar == '/')
-       {
-          dStrcat(tempBuf, "/", MaxPath);
-          termChar++;
-          currChar = termChar;
-       }
-       else
-          done = true;
-    }
-
-    dStrncpy(pathName, tempBuf, pathNameSize);
-    return foundMatch;
- }
-
  //-----------------------------------------------------------------------------
  // Returns true if the pathname exists, false otherwise.  If isFile is true,
  // the pathname is assumed to be a file path, and only the directory part

From 6f617cace85f3d5b5ec0df2c618af34acae5efad Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragora@Roberts-MacBook-Air.local>
Date: Mon, 1 Nov 2021 09:01:00 -0400
Subject: [PATCH 223/399] * BugFix: Correct compiler warnings induced by adding
 -msse to the compiler commandline on non-x86 devices.

---
 Tools/CMake/torque3d.cmake | 25 ++++++++++++++++++-------
 1 file changed, 18 insertions(+), 7 deletions(-)

diff --git a/Tools/CMake/torque3d.cmake b/Tools/CMake/torque3d.cmake
index 97b57260e..0629e944a 100644
--- a/Tools/CMake/torque3d.cmake
+++ b/Tools/CMake/torque3d.cmake
@@ -29,14 +29,25 @@ if(UNIX)
     #set(CXX_FLAG32 "-m32") #uncomment for build x32 on OSx64
 
     if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAG32} -Wundef -msse -pipe -Wfatal-errors -Wno-return-type-c-linkage -Wno-unused-local-typedef ${TORQUE_ADDITIONAL_LINKER_FLAGS}")
-	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CXX_FLAG32} -Wundef -msse -pipe -Wfatal-errors -Wno-return-type-c-linkage -Wno-unused-local-typedef ${TORQUE_ADDITIONAL_LINKER_FLAGS}")
-    else()
-    # default compiler flags
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAG32} -Wundef -msse -pipe -Wfatal-errors -no-pie ${TORQUE_ADDITIONAL_LINKER_FLAGS} -Wl,-rpath,'$ORIGIN'")
-	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CXX_FLAG32} -Wundef -msse -pipe -Wfatal-errors ${TORQUE_ADDITIONAL_LINKER_FLAGS} -Wl,-rpath,'$ORIGIN'")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAG32} -Wundef -pipe -Wfatal-errors -Wno-return-type-c-linkage -Wno-unused-local-typedef ${TORQUE_ADDITIONAL_LINKER_FLAGS}")
+        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CXX_FLAG32} -Wundef -pipe -Wfatal-errors -Wno-return-type-c-linkage -Wno-unused-local-typedef ${TORQUE_ADDITIONAL_LINKER_FLAGS}")
 
-   endif()    
+        # Only use SSE on x86 devices
+        if (TORQUE_CPU_X32 OR TORQUE_CPU_X64)
+            set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -msse")
+            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -msse")
+        endif()
+    else()
+        # default compiler flags
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_FLAG32} -Wundef -pipe -Wfatal-errors -no-pie ${TORQUE_ADDITIONAL_LINKER_FLAGS} -Wl,-rpath,'$ORIGIN'")
+        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CXX_FLAG32} -Wundef -pipe -Wfatal-errors ${TORQUE_ADDITIONAL_LINKER_FLAGS} -Wl,-rpath,'$ORIGIN'")
+
+        # Only use SSE on x86 devices
+        if (TORQUE_CPU_X32 OR TORQUE_CPU_X64)
+            set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -msse")
+            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -msse")
+        endif()
+    endif()
 
     set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
 endif()

From 724e4f423c0573c40b27e5949ab36713f7569ddd Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Tue, 2 Nov 2021 08:16:54 -0400
Subject: [PATCH 224/399] * BugFix: Correct an ASAN reported memory access
 error when calling updateHeight on GuiGameListMenuCtrl when an invalid
 profile is initially set.

---
 Engine/source/gui/controls/guiGameListMenuCtrl.cpp | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/Engine/source/gui/controls/guiGameListMenuCtrl.cpp b/Engine/source/gui/controls/guiGameListMenuCtrl.cpp
index 33efb32d8..7a9951087 100644
--- a/Engine/source/gui/controls/guiGameListMenuCtrl.cpp
+++ b/Engine/source/gui/controls/guiGameListMenuCtrl.cpp
@@ -543,7 +543,8 @@ Point2I  GuiGameListMenuCtrl::getMinExtent() const
 {
    Point2I parentMin = Parent::getMinExtent();
 
-   GuiGameListMenuProfile * profile = (GuiGameListMenuProfile *) mProfile;
+   GuiGameListMenuProfile * profile = dynamic_cast<GuiGameListMenuProfile*>(mProfile);
+   AssertFatal(profile, "Invalid profile for GuiGameListMenuCtrl!");
 
    S32 minHeight = 0;
    S32 rowHeight = profile->getRowHeight();
@@ -632,10 +633,13 @@ void GuiGameListMenuCtrl::enforceConstraints()
 
 void GuiGameListMenuCtrl::updateHeight()
 {
-   S32 minHeight = getMinExtent().y;
-   if (getHeight() < minHeight)
+   if (hasValidProfile())
    {
-      setHeight(minHeight);
+       S32 minHeight = getMinExtent().y;
+       if (getHeight() < minHeight)
+       {
+           setHeight(minHeight);
+       }
    }
 }
 

From 2eefb4972fc74a1bd2992292cec71d4b06852297 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Tue, 2 Nov 2021 09:11:25 -0400
Subject: [PATCH 225/399] * BugFix: Correct an ASAN memory access error in
 TSShapeEdit caused by reading a reference from the same vector we are pushing
 to at the same time.

---
 Engine/source/ts/tsShapeEdit.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/Engine/source/ts/tsShapeEdit.cpp b/Engine/source/ts/tsShapeEdit.cpp
index 6c5db7814..601b4ad87 100644
--- a/Engine/source/ts/tsShapeEdit.cpp
+++ b/Engine/source/ts/tsShapeEdit.cpp
@@ -1584,7 +1584,8 @@ bool TSShape::addSequence(const Torque::Path& path, const String& fromSeq,
          offset = srcShape->groundTranslations.size() - 1;
       }
 
-      groundTranslations.push_back(srcShape->groundTranslations[offset]);
+      const Point3F pointValueToCopy = srcShape->groundTranslations[offset];
+      groundTranslations.push_back(pointValueToCopy);
 
       S32 offset2 = groundBase + i;
       if (offset2 >= srcShape->groundRotations.size())
@@ -1593,7 +1594,8 @@ bool TSShape::addSequence(const Torque::Path& path, const String& fromSeq,
          offset2 = srcShape->groundRotations.size() - 1;
       }
 
-      groundRotations.push_back(srcShape->groundRotations[offset2]);
+      const Quat16 quatValueToCopy = srcShape->groundRotations[offset2];
+      groundRotations.push_back(quatValueToCopy);
    }
 
    // Add triggers

From 2b53c065ce99d03c9efbaa46cf32a61a9865edca Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Tue, 2 Nov 2021 13:55:57 -0400
Subject: [PATCH 226/399] * BugFix: Correct an invalid memory access error
 caused by the tab autocomplete in the console when attempting to tab complete
 at the start of the input while there is text to the right.

---
 Engine/source/console/console.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/Engine/source/console/console.cpp b/Engine/source/console/console.cpp
index 750db2a17..14e75f0f8 100644
--- a/Engine/source/console/console.cpp
+++ b/Engine/source/console/console.cpp
@@ -485,6 +485,13 @@ U32 tabComplete(char* inputBuffer, U32 cursorPos, U32 maxResultLength, bool forw
       }
       completionBaseStart = p;
       completionBaseLen = cursorPos - p;
+
+      // Bail if we end up at start of string
+      if (p == 0)
+      {
+          return cursorPos;
+      }
+
       // Is this function being invoked on an object?
       if (inputBuffer[p - 1] == '.') 
       {

From b33e1b400b03b3ecc92eb10212d9dfa2eb30fc05 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Tue, 2 Nov 2021 10:18:57 -0400
Subject: [PATCH 227/399] * BugFix: Correct a crash in the variable inspector
 caused by keeping pointers into tVector managed memory.

---
 .../editor/inspector/variableInspector.cpp    | 80 ++++++++++---------
 .../gui/editor/inspector/variableInspector.h  |  2 +-
 Engine/source/ts/tsShapeEdit.cpp              |  2 -
 3 files changed, 45 insertions(+), 39 deletions(-)

diff --git a/Engine/source/gui/editor/inspector/variableInspector.cpp b/Engine/source/gui/editor/inspector/variableInspector.cpp
index e280cbfb7..6afcb46e5 100644
--- a/Engine/source/gui/editor/inspector/variableInspector.cpp
+++ b/Engine/source/gui/editor/inspector/variableInspector.cpp
@@ -32,6 +32,7 @@ GuiVariableInspector::GuiVariableInspector() : mAutoUpdate(true)
 
 GuiVariableInspector::~GuiVariableInspector()
 {
+
 }
 
 IMPLEMENT_CONOBJECT(GuiVariableInspector);
@@ -75,7 +76,7 @@ void GuiVariableInspector::update()
 
       for (U32 g = 0; g < mGroups.size(); g++)
       {
-         if (mGroups[g]->getCaption().equal(mFields[i].mGroup))
+         if (mGroups[g]->getCaption().equal(mFields[i]->mGroup))
          {
             group = static_cast<GuiInspectorVariableGroup*>(mGroups[g]);
             break;
@@ -89,14 +90,14 @@ void GuiVariableInspector::update()
          group->setHeaderHidden(false);
          group->setCanCollapse(true);
          group->mParent = this;
-         group->setCaption(mFields[i].mGroup);
+         group->setCaption(mFields[i]->mGroup);
 
          group->registerObject();
          mGroups.push_back(group);
          addObject(group);
       }
-      
-      group->addField(&mFields[i]);
+
+      group->addField(mFields[i]);
    }
 
    //And now, cue our update for the groups themselves
@@ -148,26 +149,26 @@ void GuiVariableInspector::setGroupsExpanded(bool isExpanded)
 void GuiVariableInspector::addField(const char* name, const char* label, const char* typeName, const char* description, 
    const char* defaultValue, const char* dataValues, const char* callbackName, SimObject* ownerObj)
 {
-   VariableField newField;
-   newField.mFieldName = StringTable->insert(name);
-   newField.mFieldLabel = StringTable->insert(label, true);
-   newField.mFieldTypeName = StringTable->insert(typeName);
-   newField.mFieldDescription = StringTable->insert(description);
-   newField.mDefaultValue = StringTable->insert(defaultValue);
-   newField.mDataValues = String(dataValues);
-   newField.mGroup = mCurrentGroup;
-   newField.mSetCallbackName = StringTable->insert(callbackName);
-   newField.mEnabled = true;
+   VariableField* newField = new VariableField;
+   newField->mFieldName = StringTable->insert(name);
+   newField->mFieldLabel = StringTable->insert(label, true);
+   newField->mFieldTypeName = StringTable->insert(typeName);
+   newField->mFieldDescription = StringTable->insert(description);
+   newField->mDefaultValue = StringTable->insert(defaultValue);
+   newField->mDataValues = String(dataValues);
+   newField->mGroup = mCurrentGroup;
+   newField->mSetCallbackName = StringTable->insert(callbackName);
+   newField->mEnabled = true;
 
-   newField.mOwnerObject = ownerObj;
+   newField->mOwnerObject = ownerObj;
 
    //establish the field on the ownerObject(if we have one)
    //This way, we can let the field hook into the object's field and modify it when changed
-   if (newField.mOwnerObject != nullptr)
+   if (newField->mOwnerObject != nullptr)
    {
-      if (!newField.mOwnerObject->isField(newField.mFieldName))
+      if (!newField->mOwnerObject->isField(newField->mFieldName))
       {
-         newField.mOwnerObject->setDataField(newField.mFieldName, NULL, newField.mDefaultValue);
+         newField->mOwnerObject->setDataField(newField->mFieldName, NULL, newField->mDefaultValue);
       }
    }
 
@@ -175,40 +176,40 @@ void GuiVariableInspector::addField(const char* name, const char* label, const c
    //find the field type
    S32 fieldTypeMask = -1;
 
-   if (newField.mFieldTypeName == StringTable->insert("int"))
+   if (newField->mFieldTypeName == StringTable->insert("int"))
       fieldTypeMask = TypeS32;
-   else if (newField.mFieldTypeName == StringTable->insert("float"))
+   else if (newField->mFieldTypeName == StringTable->insert("float"))
       fieldTypeMask = TypeF32;
-   else if (newField.mFieldTypeName == StringTable->insert("vector"))
+   else if (newField->mFieldTypeName == StringTable->insert("vector"))
       fieldTypeMask = TypePoint3F;
-   else if (newField.mFieldTypeName == StringTable->insert("vector2"))
+   else if (newField->mFieldTypeName == StringTable->insert("vector2"))
       fieldTypeMask = TypePoint2F;
-   else if (newField.mFieldTypeName == StringTable->insert("material"))
+   else if (newField->mFieldTypeName == StringTable->insert("material"))
       fieldTypeMask = TypeMaterialAssetId;
-   else if (newField.mFieldTypeName == StringTable->insert("image"))
+   else if (newField->mFieldTypeName == StringTable->insert("image"))
       fieldTypeMask = TypeImageAssetId;
-   else if (newField.mFieldTypeName == StringTable->insert("shape"))
+   else if (newField->mFieldTypeName == StringTable->insert("shape"))
       fieldTypeMask = TypeShapeAssetId;
-   else if (newField.mFieldTypeName == StringTable->insert("bool"))
+   else if (newField->mFieldTypeName == StringTable->insert("bool"))
       fieldTypeMask = TypeBool;
-   else if (newField.mFieldTypeName == StringTable->insert("object"))
+   else if (newField->mFieldTypeName == StringTable->insert("object"))
       fieldTypeMask = TypeSimObjectPtr;
-   else if (newField.mFieldTypeName == StringTable->insert("string"))
+   else if (newField->mFieldTypeName == StringTable->insert("string"))
       fieldTypeMask = TypeString;
-   else if (newField.mFieldTypeName == StringTable->insert("colorI"))
+   else if (newField->mFieldTypeName == StringTable->insert("colorI"))
       fieldTypeMask = TypeColorI;
-   else if (newField.mFieldTypeName == StringTable->insert("colorF"))
+   else if (newField->mFieldTypeName == StringTable->insert("colorF"))
       fieldTypeMask = TypeColorF;
-   else if (newField.mFieldTypeName == StringTable->insert("ease"))
+   else if (newField->mFieldTypeName == StringTable->insert("ease"))
       fieldTypeMask = TypeEaseF;
-   else if (newField.mFieldTypeName == StringTable->insert("command"))
+   else if (newField->mFieldTypeName == StringTable->insert("command"))
       fieldTypeMask = TypeCommand;
-   else if (newField.mFieldTypeName == StringTable->insert("filename"))
+   else if (newField->mFieldTypeName == StringTable->insert("filename"))
       fieldTypeMask = TypeStringFilename;
    else
       fieldTypeMask = -1;
 
-   newField.mFieldType = fieldTypeMask;
+   newField->mFieldType = fieldTypeMask;
    //
 
    mFields.push_back(newField);
@@ -226,6 +227,13 @@ void GuiVariableInspector::addCallbackField(const char* name, const char* label,
 void GuiVariableInspector::clearFields()
 {
    mGroups.clear();
+
+   // Before clearing the fields, dealloc the memory first
+   for (U32 iteration = 0; iteration < mFields.size(); ++iteration)
+   {
+       delete mFields[iteration];
+   }
+
    mFields.clear();
    clear();
    
@@ -237,9 +245,9 @@ void GuiVariableInspector::setFieldEnabled(const char* name, bool enabled)
    String fieldName = name;
    for (U32 i = 0; i < mFields.size(); i++)
    {
-      if (fieldName.equal(mFields[i].mFieldName, String::NoCase))
+      if (fieldName.equal(mFields[i]->mFieldName, String::NoCase))
       {
-         mFields[i].mEnabled = enabled;
+         mFields[i]->mEnabled = enabled;
          update();
          return;
       }
diff --git a/Engine/source/gui/editor/inspector/variableInspector.h b/Engine/source/gui/editor/inspector/variableInspector.h
index 2648567c6..2488e8206 100644
--- a/Engine/source/gui/editor/inspector/variableInspector.h
+++ b/Engine/source/gui/editor/inspector/variableInspector.h
@@ -65,7 +65,7 @@ public:
 
 protected:
    
-   Vector<VariableField> mFields;
+   Vector<VariableField*> mFields;
 
    String mCurrentGroup;
 
diff --git a/Engine/source/ts/tsShapeEdit.cpp b/Engine/source/ts/tsShapeEdit.cpp
index 6c5db7814..86583fef4 100644
--- a/Engine/source/ts/tsShapeEdit.cpp
+++ b/Engine/source/ts/tsShapeEdit.cpp
@@ -1583,7 +1583,6 @@ bool TSShape::addSequence(const Torque::Path& path, const String& fromSeq,
          Con::errorf("%s  groundTranslations out of bounds! [%i/%i] ", path.getFullPath().c_str(), groundBase + i, srcShape->groundTranslations.size());
          offset = srcShape->groundTranslations.size() - 1;
       }
-
       groundTranslations.push_back(srcShape->groundTranslations[offset]);
 
       S32 offset2 = groundBase + i;
@@ -1592,7 +1591,6 @@ bool TSShape::addSequence(const Torque::Path& path, const String& fromSeq,
          Con::errorf("%s  groundRotations out of bounds! [%i/%i] ", path.getFullPath().c_str(), groundBase + i, srcShape->groundRotations.size());
          offset2 = srcShape->groundRotations.size() - 1;
       }
-
       groundRotations.push_back(srcShape->groundRotations[offset2]);
    }
 

From 215a93e9af9ce0c3b100bca0561e7f9e78507578 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Tue, 2 Nov 2021 17:36:22 -0400
Subject: [PATCH 228/399] * BugFix: Correction for compiling on x86 Unix
 devices.

---
 Engine/source/platformX86UNIX/x86UNIXFileio.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Engine/source/platformX86UNIX/x86UNIXFileio.cpp b/Engine/source/platformX86UNIX/x86UNIXFileio.cpp
index 591b28f1c..d702d6417 100644
--- a/Engine/source/platformX86UNIX/x86UNIXFileio.cpp
+++ b/Engine/source/platformX86UNIX/x86UNIXFileio.cpp
@@ -76,6 +76,7 @@
  extern int x86UNIXClose(int fd);
  extern ssize_t x86UNIXRead(int fd, void *buf, size_t nbytes);
  extern ssize_t x86UNIXWrite(int fd, const void *buf, size_t nbytes);
+ extern bool ResolvePathCaseInsensitive(char* pathName, S32 pathNameSize, bool requiredAbsolute);
 
  const int MaxPath = PATH_MAX;
 

From 2311d7d683219de14dcd5d8f7d0c29714758be79 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Tue, 2 Nov 2021 18:11:42 -0400
Subject: [PATCH 229/399] * BugFix: Correct an ASAN reported memory error
 caused by incorrect usage of __sync_fetch_and_add.

---
 Engine/source/platform/platformIntrinsics.gcc.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Engine/source/platform/platformIntrinsics.gcc.h b/Engine/source/platform/platformIntrinsics.gcc.h
index 5d5c39794..1acc8245e 100644
--- a/Engine/source/platform/platformIntrinsics.gcc.h
+++ b/Engine/source/platform/platformIntrinsics.gcc.h
@@ -79,7 +79,7 @@ inline bool dCompareAndSwap( volatile U64& ref, U64 oldVal, U64 newVal )
 inline U32 dAtomicRead( volatile U32 &ref )
 {
    #if !defined(TORQUE_OS_MAC)
-      return __sync_fetch_and_add( ( volatile long* ) &ref, 0 );
+      return __sync_fetch_and_add( &ref, 0 );
    #else
       return OSAtomicAdd32( 0, (int32_t* ) &ref);
    #endif

From 38e7bb9232bd8eb112f6a68266fc7f271186ffe4 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Tue, 2 Nov 2021 18:52:54 -0400
Subject: [PATCH 230/399] * BugFix: Correct the possibility of the Sim module
 being deinitialized after the Scene module despite the Sim module being
 dependentant on the Scene module.

---
 Engine/source/T3D/gameFunctions.cpp  | 2 +-
 Engine/source/scene/sceneManager.cpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Engine/source/T3D/gameFunctions.cpp b/Engine/source/T3D/gameFunctions.cpp
index c546bf83b..aa6ea80e3 100644
--- a/Engine/source/T3D/gameFunctions.cpp
+++ b/Engine/source/T3D/gameFunctions.cpp
@@ -46,7 +46,7 @@ MODULE_BEGIN( 3D )
    
    MODULE_SHUTDOWN_BEFORE( Process )
    MODULE_SHUTDOWN_BEFORE( Sim )
-   MODULE_SHUTDOWN_AFTER( Scene )
+   MODULE_SHUTDOWN_BEFORE( Scene )
    
    MODULE_INIT
    {
diff --git a/Engine/source/scene/sceneManager.cpp b/Engine/source/scene/sceneManager.cpp
index 5e1d97cb0..83ab66f2e 100644
--- a/Engine/source/scene/sceneManager.cpp
+++ b/Engine/source/scene/sceneManager.cpp
@@ -49,7 +49,7 @@ extern bool gEditingMission;
 MODULE_BEGIN( Scene )
 
    MODULE_INIT_AFTER( Sim )   
-   MODULE_SHUTDOWN_BEFORE( Sim )
+   MODULE_SHUTDOWN_AFTER( Sim )
    
    MODULE_INIT
    {

From fda722e355f59d0f24de72a96462dd78eaf819c0 Mon Sep 17 00:00:00 2001
From: JeffR <Areloch@gmail.com>
Date: Wed, 3 Nov 2021 00:13:00 -0500
Subject: [PATCH 231/399] Updates asset importer and project importer to output
 to separate log files into tools/logs Add utility console function for
 getting current datetime

---
 Engine/source/T3D/assets/assetImporter.cpp    |  44 ++++-
 Engine/source/T3D/assets/assetImporter.h      |   2 +
 .../T3D/assets/assetImporter_ScriptBinding.h  |   2 +-
 Engine/source/console/consoleFunctions.cpp    |  18 ++
 .../game/tools/projectImporter/main.tscript   |   1 +
 .../pre40/T3Dpre4ProjectImporter.tscript      |  48 ++---
 .../scripts/projectImporter.tscript           | 180 +++++++++++-------
 7 files changed, 195 insertions(+), 100 deletions(-)

diff --git a/Engine/source/T3D/assets/assetImporter.cpp b/Engine/source/T3D/assets/assetImporter.cpp
index 8dc898dae..65c18d664 100644
--- a/Engine/source/T3D/assets/assetImporter.cpp
+++ b/Engine/source/T3D/assets/assetImporter.cpp
@@ -18,6 +18,7 @@
 #include "materials/materialManager.h"
 
 #include "console/persistenceManager.h"
+#include "core/util/timeClass.h"
 
 ConsoleDocClass(AssetImportConfig,
    "@brief Defines properties for an AssetImprotConfig object.\n"
@@ -506,7 +507,8 @@ AssetImporter::AssetImporter() :
    isReimport(false),
    assetHeirarchyChanged(false),
    importLogBuffer(""),
-   activeImportConfig(nullptr)
+   activeImportConfig(nullptr),
+   mDumpLogs(true)
 {
 }
 
@@ -534,6 +536,7 @@ void AssetImporter::initPersistFields()
    addField("targetModuleId", TypeRealString, Offset(targetModuleId, AssetImporter), "The Id of the module the assets are to be imported into");
    addField("finalImportedAssetPath", TypeRealString, Offset(finalImportedAssetPath, AssetImporter), "The Id of the module the assets are to be imported into");
    addField("targetPath", TypeRealString, Offset(targetPath, AssetImporter), "The path any imported assets are placed in as their destination");
+   addField("dumpLogs", TypeBool, Offset(mDumpLogs, AssetImporter), "Indicates if the importer always dumps its logs or not");
 }
 
 //
@@ -924,9 +927,41 @@ String AssetImporter::getActivityLogLine(U32 line)
 
 void AssetImporter::dumpActivityLog()
 {
-   for (U32 i = 0; i < activityLog.size(); i++)
+   if (!mDumpLogs)
+      return;
+
+   FileObject logFile;
+
+   //If there's nothing logged, don't bother
+   if (activityLog.size() == 0)
+      return;
+
+   Torque::Time::DateTime curTime;
+   Torque::Time::getCurrentDateTime(curTime);
+
+   String logName = String("tools/logs/AssetImportLog_") + String::ToString(curTime.year + 1900) + "-" +
+      String::ToString(curTime.month + 1) + "-" + String::ToString(curTime.day) + "_" +
+      String::ToString(curTime.hour) + "-" + String::ToString(curTime.minute) + "-" + String::ToString(curTime.second)
+      + "-" + String::ToString(curTime.microsecond) + ".log";
+
+   if (logFile.openForWrite(logName.c_str()))
    {
-      Con::printf(activityLog[i].c_str());
+      for (U32 i = 0; i < activityLog.size(); i++)
+      {
+         logFile.writeLine((const U8*)activityLog[i].c_str());
+      }
+
+      logFile.close();
+
+      Con::warnf("Asset Import log file dumped to: %s", logName.c_str());
+   }
+   else
+   {
+      Con::errorf("Error: Failed to open log file for writing! Dumping log results to console!");
+      for (U32 i = 0; i < activityLog.size(); i++)
+      {
+         Con::printf(activityLog[i].c_str());
+      }
    }
 }
 
@@ -2383,6 +2418,7 @@ void AssetImporter::importAssets(AssetImportObject* assetItem)
    {
       dSprintf(importLogBuffer, sizeof(importLogBuffer), "AssetImporter::importAssets - Unable to find moduleId %s", targetModuleId.c_str());
       activityLog.push_back(importLogBuffer);
+      dumpActivityLog();
       return;
    }
 
@@ -2483,6 +2519,8 @@ void AssetImporter::importAssets(AssetImportObject* assetItem)
       //recurse if needed
       importAssets(item);
    }
+
+   dumpActivityLog();
 }
 
 //
diff --git a/Engine/source/T3D/assets/assetImporter.h b/Engine/source/T3D/assets/assetImporter.h
index 9505d00b1..327b38dca 100644
--- a/Engine/source/T3D/assets/assetImporter.h
+++ b/Engine/source/T3D/assets/assetImporter.h
@@ -647,6 +647,8 @@ class AssetImporter : public SimObject
    /// </summary>
    String finalImportedAssetPath;
 
+   bool mDumpLogs;
+
 public:
    AssetImporter();
    virtual ~AssetImporter();
diff --git a/Engine/source/T3D/assets/assetImporter_ScriptBinding.h b/Engine/source/T3D/assets/assetImporter_ScriptBinding.h
index 88125760a..e52da2c52 100644
--- a/Engine/source/T3D/assets/assetImporter_ScriptBinding.h
+++ b/Engine/source/T3D/assets/assetImporter_ScriptBinding.h
@@ -44,7 +44,7 @@ DefineEngineMethod(AssetImporter, getActivityLogLine, String, (S32 i), (0),
    "Creates a new script asset using the targetFilePath.\n"
    "@return The bool result of calling exec")
 {
-   return object->getActivityLogLine(0);
+   return object->getActivityLogLine(i);
 }
 
 DefineEngineMethod(AssetImporter, autoImportFile, String, (String path, String typeHint), ("", ""),
diff --git a/Engine/source/console/consoleFunctions.cpp b/Engine/source/console/consoleFunctions.cpp
index ceac8de6d..a4b50cfcc 100644
--- a/Engine/source/console/consoleFunctions.cpp
+++ b/Engine/source/console/consoleFunctions.cpp
@@ -2841,3 +2841,21 @@ DefineEngineFunction( getStringHash, S32, (const char* _inString, bool _sensitiv
    else
       return S32(String(_inString).getHashCaseInsensitive());
 }
+
+//-----------------------------------------------------------------------------
+
+DefineEngineFunction(getTimestamp, const char*, (), ,
+   "Gets datetime string.\n\n"
+   "@return YYYY-mm-DD_hh-MM-ss formatted date time string.")
+{
+   Torque::Time::DateTime curTime;
+   Torque::Time::getCurrentDateTime(curTime);
+
+   String timestampStr = String::ToString(curTime.year + 1900) + "-" +
+      String::ToString(curTime.month + 1) + "-" + String::ToString(curTime.day) + "_" +
+      String::ToString(curTime.hour) + "-" + String::ToString(curTime.minute) + "-" + String::ToString(curTime.second);
+
+   const char* returnBuffer = Con::getReturnBuffer(timestampStr);
+
+   return returnBuffer;
+}
diff --git a/Templates/BaseGame/game/tools/projectImporter/main.tscript b/Templates/BaseGame/game/tools/projectImporter/main.tscript
index 2766b4bad..da7fd3a3b 100644
--- a/Templates/BaseGame/game/tools/projectImporter/main.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/main.tscript
@@ -41,6 +41,7 @@ function initializeProjectImporter()
    //Input::GetEventManager().subscribe( ProjectImportCtrl, "EndDropFiles" );
    
    $ProjectImporter::importer = new AssetImporter();
+   $ProjectImporter::importer.dumpLogs = false; //we'll handle the log files ourselves
    
    %importConfig = new AssetImportConfig();
    %importConfig.loadImportConfig(AssetImportSettings, "LegacyProjectImport");
diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
index 82d11595e..0eb5f4360 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
@@ -2,7 +2,7 @@ function T3Dpre4ProjectImporter::setupModule(%this)
 {
    %newModuleName = $ProjectImporter::moduleName;
       
-   echo("Creating a new Module named: " @ %newModuleName);
+   $ProjectImporter::log.add("Creating a new Module named: " @ %newModuleName);
    
    %moduleFilePath = "data/" @ %newModuleName;
    %moduleDefinitionFilePath = %moduleFilePath @ "/" @ %newModuleName @ ".module";
@@ -40,7 +40,7 @@ function T3Dpre4ProjectImporter::setupModule(%this)
          %line = strreplace( %line, "@@", %newModuleName );
          
          %file.writeline(%line);
-         echo(%line);
+         //$ProjectImporter::log.add(%line);
       }
       
       %file.close();
@@ -51,7 +51,7 @@ function T3Dpre4ProjectImporter::setupModule(%this)
       %file.close();
       %templateFile.close();
       
-      warnf("CreateNewModule - Something went wrong and we couldn't write the script file!");
+      $ProjectImporter::log.add("CreateNewModule - Something went wrong and we couldn't write the script file!");
    }
    
    //force a refresh of our modules list
@@ -126,7 +126,7 @@ function T3Dpre4ProjectImporter::copyFiles(%this)
       
       if(!pathCopy(%file, %targetFilePath, false))
       {
-         error("Legacy Project Importer, failed to copy file: " @ %file @ " to destination: " @ %targetFilePath);
+         $ProjectImporter::log.add("Legacy Project Importer, failed to copy file: " @ %file @ " to destination: " @ %targetFilePath);
       }
       
       %file = findNextFileMultiExpr( $ProjectImporter::sourceContentFolder @ "/*.*" );
@@ -206,7 +206,7 @@ function T3Dpre4ProjectImporter::beginMaterialFilesImport(%this)
    %objectClassStack = new ArrayObject();
    %fileOutputLines = new ArrayObject();
    
-   echo("Legacy Project Importer - Beginning processing of imported code files");
+   $ProjectImporter::log.add("Legacy Project Importer - Beginning processing of imported code files");
    
    //Walk through and process all code files to update references
    while( %file !$= "" )
@@ -225,7 +225,7 @@ function T3Dpre4ProjectImporter::beginMaterialFilesImport(%this)
       
       if ( $ProjectImporter::fileObject.openForRead( %file ) ) 
       {
-         echo("Legacy Project Importer - Beginning process of file: " @ %file);
+         $ProjectImporter::log.add("Legacy Project Importer - Beginning process of file: " @ %file);
          %lineNum = 0;
          while ( !$ProjectImporter::fileObject.isEOF() ) 
          {
@@ -376,7 +376,7 @@ function T3Dpre4ProjectImporter::beginMaterialFilesImport(%this)
       }
       else
       {
-         error("Legacy Project Importer - File not able to be opened: " @ %file);  
+         $ProjectImporter::log.add("Legacy Project Importer - File not able to be opened: " @ %file);  
       }
       
       if(%fileWasChanged)
@@ -399,7 +399,7 @@ function T3Dpre4ProjectImporter::beginMaterialFilesImport(%this)
       %file = findNextFileMultiExpr( $ProjectImporter::modulePath @ "/*/materials.*" );
    }
    
-   echo("Legacy Project Importer - Processing of imported code files done!");
+   $ProjectImporter::log.add("Legacy Project Importer - Processing of imported code files done!");
    
    %fileOutputLines.delete();
    %objectClassStack.delete();
@@ -418,7 +418,7 @@ function T3Dpre4ProjectImporter::beginCodeFilesImport(%this)
    %objectClassStack = new ArrayObject();
    %fileOutputLines = new ArrayObject();
    
-   echo("Legacy Project Importer - Beginning processing of imported code files");
+   $ProjectImporter::log.add("Legacy Project Importer - Beginning processing of imported code files");
    
    //Walk through and process all code files to update references
    while( %file !$= "" )
@@ -454,7 +454,7 @@ function T3Dpre4ProjectImporter::beginCodeFilesImport(%this)
       
       if ( $ProjectImporter::fileObject.openForRead( %file ) ) 
       {
-         echo("Legacy Project Importer - Beginning process of file: " @ %file);
+         $ProjectImporter::log.add("Legacy Project Importer - Beginning process of file: " @ %file);
          %lineNum = 0;
          while ( !$ProjectImporter::fileObject.isEOF() ) 
          {
@@ -702,7 +702,7 @@ function T3Dpre4ProjectImporter::beginCodeFilesImport(%this)
       }
       else
       {
-         error("Legacy Project Importer - File not able to be opened: " @ %file);  
+         $ProjectImporter::log.add("Legacy Project Importer - File not able to be opened: " @ %file);  
       }
       
       if(%fileWasChanged)
@@ -725,7 +725,7 @@ function T3Dpre4ProjectImporter::beginCodeFilesImport(%this)
       %file = findNextFileMultiExpr( $ProjectImporter::modulePath @ "/*.*" );
    }
    
-   echo("Legacy Project Importer - Processing of imported code files done!");
+   $ProjectImporter::log.add("Legacy Project Importer - Processing of imported code files done!");
    
    //exec common loader files, process the remainder into assets
    
@@ -747,7 +747,7 @@ function T3Dpre4ProjectImporter::processScriptExtensions(%this)
    else
       %file = findFirstFileMultiExpr( $ProjectImporter::modulePath @ "/*/*.tscript", true);
    
-   echo("Legacy Project Importer - Beginning processing of script files that utilize extensions other than: " @ $TorqueScriptFileExtension);
+   $ProjectImporter::log.add("Legacy Project Importer - Beginning processing of script files that utilize extensions other than: " @ $TorqueScriptFileExtension);
    
    //Walk through and process all code files to update references
    while( %file !$= "" )
@@ -767,13 +767,13 @@ function T3Dpre4ProjectImporter::processScriptExtensions(%this)
       %targetFilePath = %filePath @ "/" @ %fileBase @ "." @ $TorqueScriptFileExtension;
       if(!pathCopy(%file, %targetFilePath))
       {
-         error("T3Dpre4ProjectImporter::processScriptExtensions() - Failed to create renamed script file for file: " @ %file);
+         $ProjectImporter::log.add("T3Dpre4ProjectImporter::processScriptExtensions() - Failed to create renamed script file for file: " @ %file);
       }
       else
       {
          if(!fileDelete(%file))
          {
-            error("T3Dpre4ProjectImporter::processScriptExtensions() - Failed to remove old script file for rename: " @ %file);
+            $ProjectImporter::log.add("T3Dpre4ProjectImporter::processScriptExtensions() - Failed to remove old script file for rename: " @ %file);
          }         
       }
       
@@ -789,7 +789,7 @@ function T3Dpre4ProjectImporter::processScriptExtensions(%this)
    ProjectImportWindow-->nextButton.setActive(true);
    Canvas.repaint();
    
-   echo("Legacy Project Importer - Beginning processing of script files extensions complete");
+   $ProjectImporter::log.add("Legacy Project Importer - Beginning processing of script files extensions complete");
 }
 
 //To implement a custom class to have it's fields processed, just utilize this template function
@@ -986,7 +986,7 @@ function T3Dpre4ProjectImporter::processMaterialObject(%this, %file, %objectName
       
       if(isFile(%tamlpath))
       {
-         error("T3Dpre4ProjectImporter::processMaterialObject() - Failed to create as taml file already exists: " @ %file);
+         $ProjectImporter::log.add("T3Dpre4ProjectImporter::processMaterialObject() - Failed to create as taml file already exists: " @ %file);
          return false;
       }
       
@@ -1042,7 +1042,7 @@ function T3Dpre4ProjectImporter::processTerrainMaterialObject(%this, %file, %obj
       
       if(isFile(%tamlpath))
       {
-         error("T3Dpre4ProjectImporter::processTerrainMaterialObject() - Failed to create as taml file already exists: " @ %file);
+         $ProjectImporter::log.add("T3Dpre4ProjectImporter::processTerrainMaterialObject() - Failed to create as taml file already exists: " @ %file);
          return false;
       }
       
@@ -1098,7 +1098,7 @@ function T3Dpre4ProjectImporter::processSFXProfileObject(%this, %file, %objectNa
    //Throw a warn that this file's already been claimed and move on
    if(%soundAsset !$= "")
    {
-      warn("T3Dpre4ProjectImporter::processSFXProfileObject() - attempting to process SFXProfile " @ %objectName 
+      $ProjectImporter::log.add("T3Dpre4ProjectImporter::processSFXProfileObject() - attempting to process SFXProfile " @ %objectName 
                @ " but its filename is already associated to another sound asset. Continuing, but be aware.");
    }  
 
@@ -1112,7 +1112,7 @@ function T3Dpre4ProjectImporter::processSFXProfileObject(%this, %file, %objectNa
       
       if(isFile(%tamlpath))
       {
-         error("T3Dpre4ProjectImporter::processSFXProfileObject() - Failed to create as taml file already exists: " @ %soundFilename);
+         $ProjectImporter::log.add("T3Dpre4ProjectImporter::processSFXProfileObject() - Failed to create as taml file already exists: " @ %soundFilename);
          return false;
       }
       
@@ -1274,7 +1274,7 @@ function processGuiBitmapButtonCtrlField(%line, %originalFieldName, %newFieldNam
    
    if(%outLine !$= %line && %pos != -1 && %endPos != -1 && %value !$= "")
    {
-      echo("Legacy Project Importer - processing legacy field line: " @ %line);
+      $ProjectImporter::log.add("Legacy Project Importer - processing legacy field line: " @ %line);
       
       if(startsWith(%value, "$") || startsWith(%value, "#"))
       {
@@ -1287,7 +1287,7 @@ function processGuiBitmapButtonCtrlField(%line, %originalFieldName, %newFieldNam
       //If we still have nothing, then we fail it out
       if(!isFile(%targetFilename))
       {
-         error("Legacy Project Importer - file described in line could not be found/is not valid");
+         $ProjectImporter::log.add("Legacy Project Importer - file described in line could not be found/is not valid");
          return %line;
       }
       
@@ -1296,7 +1296,7 @@ function processGuiBitmapButtonCtrlField(%line, %originalFieldName, %newFieldNam
       if(%foundAssets != 0)
       {
          %assetId = $ProjectImporter::assetQuery.getAsset(0);
-         echo("Legacy Project Importer - processing of legacy field line's value: " @ %value @ " has found a matching AssetId: " @ %assetId);
+         $ProjectImporter::log.add("Legacy Project Importer - processing of legacy field line's value: " @ %value @ " has found a matching AssetId: " @ %assetId);
       }
      
       if(%assetId !$= "" && AssetDatabase.isDeclaredAsset(%assetId))
@@ -1310,7 +1310,7 @@ function processGuiBitmapButtonCtrlField(%line, %originalFieldName, %newFieldNam
    
    if(%outLine !$= %line)
    {
-      echo("Legacy Project Importer - processing of legacy line: " @ %line @ " has been updated to: " @ %outLine);
+      $ProjectImporter::log.add("Legacy Project Importer - processing of legacy line: " @ %line @ " has been updated to: " @ %outLine);
       return %outLine;  
    }
    else
diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
index cfdd7c8bf..f00941776 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
@@ -10,6 +10,11 @@ function ProjectImportWindow::onWake(%this)
    if(!isObject($ProjectImporter::fileObject))
       $ProjectImporter::fileObject = new FileObject();
       
+   if(!isObject($ProjectImporter::log))
+      $ProjectImporter::log = new ArrayObject();
+   else
+      $ProjectImporter::log.empty();
+      
    %this.importStepNumber = 0;
    %this-->stepsList.clear();
    %this-->stepsList.addRow(0, "Welcome");  
@@ -352,16 +357,33 @@ function ProjectImportWizardPage6::processPage(%this)
 
 function ProjectImportWizardPage7::openPage(%this)
 {
+   //writing console log
+   %logFileObj = new FileObject();
+   
+   %logFileName = "tools/logs/LegacyProjectImport_" @ getTimestamp() @ ".log";
+   
+   if(%logFileObj.openForWrite(%logFileName))
+   {
+      for(%i=0; %i < $ProjectImporter::log.count(); %i++)
+      {
+         %logFileObj.writeLine($ProjectImporter::log.getKey(%i));
+      }
+      
+      %logFileObj.close();
+   }
+   
+   %logFileObj.delete();
 }
 
 function beginProjectImport()
 {
-   echo("===========================================");
-   echo("Beginning Project Import");
-   echo("===========================================");
+   $ProjectImporter::log.add("===========================================");
+   $ProjectImporter::log.add("Beginning Project Import");
+   $ProjectImporter::log.add("===========================================");
    
    $ProjectImporter::assetQuery = new AssetQuery();
    $ProjectImporter::importer = new AssetImporter();
+   $ProjectImporter::importer.dumpLogs = false; //we handle the log dump outselves here
    $ProjectImporter::persistMgr = new PersistenceManager();
    
    //beginMaterialImport();
@@ -388,9 +410,9 @@ function beginProjectImport()
    $ProjectImporter::importer.delete();
    $ProjectImporter::persistMgr.delete();
    
-   echo("===========================================");
-   echo("Finished Project Import");
-   echo("===========================================");
+   $ProjectImporter::log.add("===========================================");
+   $ProjectImporter::log.add("Finished Project Import");
+   $ProjectImporter::log.add("===========================================");
    
    AssetBrowser.refresh(); //update the AB just in case
 }
@@ -538,7 +560,7 @@ function processLegacyField(%line, %originalFieldName, %newFieldName)
    
    if(%outLine !$= %line && %pos != -1 && %endPos != -1 && %value !$= "")
    {
-      echo("Legacy Project Importer - processing legacy field line: " @ %line);
+      $ProjectImporter::log.add("Legacy Project Importer - processing legacy field line: " @ %line);
       
       if(startsWith(%value, "$") || startsWith(%value, "#"))
       {
@@ -580,7 +602,7 @@ function processLegacyField(%line, %originalFieldName, %newFieldName)
             }
             else
             {
-               error("Legacy Project Importer - file described in line could not be found/is not valid");
+               $ProjectImporter::log.add("Legacy Project Importer - file described in line could not be found/is not valid");
                return %line;
             }
          }
@@ -597,7 +619,7 @@ function processLegacyField(%line, %originalFieldName, %newFieldName)
      
       if(%assetId !$= "" && AssetDatabase.isDeclaredAsset(%assetId))
       {
-         echo("Legacy Project Importer - processing of legacy field line's value: " @ %value @ " has found a matching AssetId: " @ %assetId);
+         $ProjectImporter::log.add("Legacy Project Importer - processing of legacy field line's value: " @ %value @ " has found a matching AssetId: " @ %assetId);
          
          //double check if this already had the quotes around the value or not
          if(!strIsMatchExpr("*\"*\"*", %originalValue))
@@ -612,7 +634,7 @@ function processLegacyField(%line, %originalFieldName, %newFieldName)
    
    if(%outLine !$= %line)
    {
-      echo("Legacy Project Importer - processing of legacy line: " @ %line @ " has been updated to: " @ %outLine);
+      $ProjectImporter::log.add("Legacy Project Importer - processing of legacy line: " @ %line @ " has been updated to: " @ %outLine);
       return %outLine;  
    }
    else
@@ -650,7 +672,7 @@ function processLegacyShapeConstructorField(%line)
    if(%foundAssets != 0)
    {
       %assetId = $ProjectImporter::assetQuery.getAsset(0);
-      echo("Legacy Project Importer - processing of legacy shape constructor addSequence line's value: " @ %animSourcePath @ " has found a matching AssetId: " @ %assetId);
+      $ProjectImporter::log.add("Legacy Project Importer - processing of legacy shape constructor addSequence line's value: " @ %animSourcePath @ " has found a matching AssetId: " @ %assetId);
    }
   
    if(%assetId !$= "" && AssetDatabase.isDeclaredAsset(%assetId))
@@ -663,7 +685,7 @@ function processLegacyShapeConstructorField(%line)
    
    if(%outLine !$= %line)
    {
-      echo("Legacy Project Importer - processing of legacy shape constructor addSequence line: " @ %line @ " has been updated to: " @ %outLine);
+      $ProjectImporter::log.add("Legacy Project Importer - processing of legacy shape constructor addSequence line: " @ %line @ " has been updated to: " @ %outLine);
       return %outLine;  
    }
    else
@@ -849,7 +871,7 @@ function findObjectInFiles(%objectName)
       }
       else
       {
-         error("findObjectInFiles() - File not able to be opened: " @ %file);  
+         $ProjectImporter::log.add("findObjectInFiles() - File not able to be opened: " @ %file);  
       }
       
       %file = findNextFileMultiExpr( "*.*" );
@@ -864,9 +886,9 @@ function findObjectInFiles(%objectName)
 //==============================================================================
 function beginShapeImport()
 {
-   echo("===========================================");
-   echo("Importing 3D Shape files");
-   echo("===========================================");
+   $ProjectImporter::log.add("===========================================");
+   $ProjectImporter::log.add("Importing 3D Shape files");
+   $ProjectImporter::log.add("===========================================");
    //First, we need to go through and process all loose shape files. This will
    //get us shape assets, material assets image, assets and animation assets.
    %currentAddress = $ProjectImporter::modulePath;
@@ -904,12 +926,14 @@ function beginShapeImport()
             
             //No asset found associated to this fileas far as we can determine, so time to import it
             
-            warn("Importing 3D Shape file: " @ %file);
+            $ProjectImporter::log.add("Importing 3D Shape file: " @ %file);
             %assetId = $ProjectImporter::importer.autoImportFile(%file);  
+            getImporterLogs();
             
             if(%assetId !$= "")
             {
-               warn("Finished importing 3D Shape file, resulting in asset with an id of: " @ %assetId);
+               $ProjectImporter::log.add("Finished importing 3D Shape file, resulting in asset with an id of: " @ %assetId);
+               $ProjectImporter::log.add("");
             }
          }
       }
@@ -917,9 +941,9 @@ function beginShapeImport()
       %file = findNextFileMultiExpr( %currentAddress @ "/*.*" );
    }
    
-   echo("===========================================");
-   echo("Finished Importing 3D Shape files");
-   echo("===========================================");
+   $ProjectImporter::log.add("===========================================");
+   $ProjectImporter::log.add("Finished Importing 3D Shape files");
+   $ProjectImporter::log.add("===========================================");
 }
 //==============================================================================
 
@@ -928,9 +952,9 @@ function beginShapeImport()
 //==============================================================================
 function beginImageImport()
 {
-   echo("===========================================");
-   echo("Importing Image files");
-   echo("===========================================");
+   $ProjectImporter::log.add("===========================================");
+   $ProjectImporter::log.add("Importing Image files");
+   $ProjectImporter::log.add("===========================================");
    //First, we need to go through and process all loose image files. This will
    //get us image assets, and if the import config deigns, material assets.
    %currentAddress = $ProjectImporter::modulePath;
@@ -960,12 +984,14 @@ function beginImageImport()
       
             //No asset found associated to this fileas far as we can determine, so time to import it
             
-            warn("Importing Image file: " @ %file);
+            $ProjectImporter::log.add("Importing Image file: " @ %file);
             %assetId = $ProjectImporter::importer.autoImportFile(%file);  
+            getImporterLogs();
             
             if(%assetId !$= "")
             {
-               warn("Finished importing Image file, resulting in asset with an id of: " @ %assetId);
+               $ProjectImporter::log.add("Finished importing Image file, resulting in asset with an id of: " @ %assetId);
+               $ProjectImporter::log.add("");
             }
          }
       }
@@ -973,9 +999,9 @@ function beginImageImport()
       %file = findNextFileMultiExpr( %currentAddress @ "/*.*" );
    }
    
-   echo("===========================================");
-   echo("Finished Importing Image files");
-   echo("===========================================");
+   $ProjectImporter::log.add("===========================================");
+   $ProjectImporter::log.add("Finished Importing Image files");
+   $ProjectImporter::log.add("===========================================");
 }
 //==============================================================================
 
@@ -984,9 +1010,9 @@ function beginImageImport()
 //==============================================================================
 function beginTerrainImport()
 {
-   echo("===========================================");
-   echo("Importing Terrain files");
-   echo("===========================================");
+   $ProjectImporter::log.add("===========================================");
+   $ProjectImporter::log.add("Importing Terrain files");
+   $ProjectImporter::log.add("===========================================");
 
    %currentAddress = $ProjectImporter::modulePath;
    
@@ -1015,7 +1041,7 @@ function beginTerrainImport()
             ProjectImportWizardPage5-->processingText.setText("Processing Terrain Asset file: " @ %file);
             Canvas.repaint();
             
-            warn("Importing Terrain file: " @ %file);
+            $ProjectImporter::log.add("Importing Terrain file: " @ %file);
             
             %moduleDef = AssetBrowser.dirHandler.getModuleFromAddress(%file);
             %moduleName = %moduleDef.ModuleID;
@@ -1039,7 +1065,8 @@ function beginTerrainImport()
             {
                AssetDatabase.addDeclaredAsset(%moduleDef, %tamlpath);
                
-               warn("Finished importing Terrain file, resulting in asset with an id of: " @ %moduleName @ ":" @ %assetName);
+               $ProjectImporter::log.add("Finished importing Terrain file, resulting in asset with an id of: " @ %moduleName @ ":" @ %assetName);
+               $ProjectImporter::log.add("");
             }
          }
       }
@@ -1047,9 +1074,9 @@ function beginTerrainImport()
       %file = findNextFileMultiExpr( %currentAddress @ "/*.*" );
    }
    
-   echo("===========================================");
-   echo("Finished Importing Terrain files");
-   echo("===========================================");
+   $ProjectImporter::log.add("===========================================");
+   $ProjectImporter::log.add("Finished Importing Terrain files");
+   $ProjectImporter::log.add("===========================================");
 }
 //==============================================================================
 
@@ -1064,9 +1091,9 @@ function beginTerrainImport()
 //==============================================================================
 function beginGUIImport()
 {
-   echo("===========================================");
-   echo("Importing GUIs");
-   echo("===========================================");
+   $ProjectImporter::log.add("===========================================");
+   $ProjectImporter::log.add("Importing GUIs");
+   $ProjectImporter::log.add("===========================================");
    
    %currentAddress = $ProjectImporter::modulePath;
    
@@ -1128,14 +1155,14 @@ function beginGUIImport()
       %file = findNextFileMultiExpr( %currentAddress @ "/*.*" );
    }
 
-   echo("===========================================");
-   echo("Finished Importing GUIs");
-   echo("===========================================");
+   $ProjectImporter::log.add("===========================================");
+   $ProjectImporter::log.add("Finished Importing GUIs");
+   $ProjectImporter::log.add("===========================================");
 }
 
 function processGUIntoAsset(%guiName, %file)
 {
-   warn("Processing GUI into asset: " @ %guiName @ ", file: " @ %file);
+   $ProjectImporter::log.add("Processing GUI into asset: " @ %guiName @ ", file: " @ %file);
    
    %filePath = filePath(%file);
    %fileName = fileBase(%file);
@@ -1182,9 +1209,9 @@ function processGUIntoAsset(%guiName, %file)
 //==============================================================================
 function beginPostFXImport()
 {
-   echo("===========================================");
-   echo("Importing PostFXs");
-   echo("===========================================");
+   $ProjectImporter::log.add("===========================================");
+   $ProjectImporter::log.add("Importing PostFXs");
+   $ProjectImporter::log.add("===========================================");
    
    %count = PostFXManager.Count();
    for(%i=0; %i < %count; %i++)
@@ -1193,7 +1220,7 @@ function beginPostFXImport()
       
       if(isObject(%postEffect))
       {     
-         echo("Processing import of PostFX: " @ %postEffect.getName());
+         $ProjectImporter::log.add("Processing import of PostFX: " @ %postEffect.getName());
          
          //$ProjectImporter::persistMgr.setDirty(%gui);
       }
@@ -1201,9 +1228,9 @@ function beginPostFXImport()
    
    //$ProjectImporter::persistMgr.saveDirty();
 
-   echo("===========================================");
-   echo("Finished Importing PostFXs");
-   echo("===========================================");
+   $ProjectImporter::log.add("===========================================");
+   $ProjectImporter::log.add("Finished Importing PostFXs");
+   $ProjectImporter::log.add("===========================================");
 }
 //==============================================================================
 
@@ -1212,9 +1239,9 @@ function beginPostFXImport()
 //==============================================================================
 function beginLevelImport()
 {
-   echo("===========================================");
-   echo("Importing Level files");
-   echo("===========================================");
+   $ProjectImporter::log.add("===========================================");
+   $ProjectImporter::log.add("Importing Level files");
+   $ProjectImporter::log.add("===========================================");
 
    %currentAddress = $ProjectImporter::modulePath;
    
@@ -1239,7 +1266,7 @@ function beginLevelImport()
             ProjectImportWizardPage5-->processingText.setText("Processing Level Asset file: " @ %file);
             Canvas.repaint();
             
-            warn("Importing Level file: " @ %file);
+            $ProjectImporter::log.add("Importing Level file: " @ %file);
             
             %moduleName = AssetBrowser.dirHandler.getModuleFromAddress(%file).ModuleId;
 
@@ -1249,7 +1276,7 @@ function beginLevelImport()
             
             if(AssetDatabase.isDeclaredAsset(%moduleName @ ":" @ %assetName))
             {
-               warn("Legacy Project Importer - trying to process a level into an asset that already exists");
+               $ProjectImporter::log.add("Legacy Project Importer - trying to process a level into an asset that already exists");
                return false;  
             }
             
@@ -1329,9 +1356,9 @@ function beginLevelImport()
       %file = findNextFileMultiExpr( %currentAddress @ "/*.*" );
    }
    
-   echo("===========================================");
-   echo("Finished Importing Level files");
-   echo("===========================================");
+   $ProjectImporter::log.add("===========================================");
+   $ProjectImporter::log.add("Finished Importing Level files");
+   $ProjectImporter::log.add("===========================================");
 }
 //==============================================================================
 
@@ -1370,9 +1397,9 @@ function ProjectImporter::deleteAssetDefinitions(%targetFolder)
 
 function doDeleteAssetDefinitions()
 {
-   echo("===========================================");
-   echo("Deleting Asset Definitions");
-   echo("===========================================");
+   $ProjectImporter::log.add("===========================================");
+   $ProjectImporter::log.add("Deleting Asset Definitions");
+   $ProjectImporter::log.add("===========================================");
    
    %currentAddress = $deleteAssetDefsTargetFolder;
    
@@ -1388,27 +1415,27 @@ function doDeleteAssetDefinitions()
       {
          if(fileDelete(%file))
          {
-            echo("File: " @ %file @ " deleted successfully.");  
+            $ProjectImporter::log.add("File: " @ %file @ " deleted successfully.");  
          }
          else
          {
-            error("File: " @ %file @ " failed to delete.");  
+            $ProjectImporter::log.add("File: " @ %file @ " failed to delete.");  
          }
       }
       
       %file = findNextFileMultiExpr( %currentAddress @ "/*.asset.taml" );
    }
 
-   echo("===========================================");
-   echo("Finished Deleting Asset Definitions");
-   echo("===========================================");
+   $ProjectImporter::log.add("===========================================");
+   $ProjectImporter::log.add("Finished Deleting Asset Definitions");
+   $ProjectImporter::log.add("===========================================");
 }
 
 function scanForDuplicateFiles(%toTestFile)
 {
-   echo("===========================================");
-   echo("Scanning for duplicate files!");
-   echo("===========================================");
+   $ProjectImporter::log.add("===========================================");
+   $ProjectImporter::log.add("Scanning for duplicate files!");
+   $ProjectImporter::log.add("===========================================");
    
    //First, wipe out any files inside the folder first
    %file = findFirstFileMultiExpr( "*/*.*", true);
@@ -1452,12 +1479,21 @@ function scanForDuplicateFiles(%toTestFile)
             if(%moduleName !$= "" && %testModuleName !$= "" && %moduleName $= %testModuleName)
             {
                //report the probable duplicate
-               error("Probable duplicate asset detected!");
-               error("Files: " @ %file @ " and " @ %toTestFile @ " have matching names and exist within the same module!");
+               $ProjectImporter::log.add("Probable duplicate asset detected!");
+               $ProjectImporter::log.add("Files: " @ %file @ " and " @ %toTestFile @ " have matching names and exist within the same module!");
             }
          }
       }
       
       %file = findNextFileMultiExpr( "*/*.*" );
    }
+}
+
+function getImporterLogs()
+{
+   %lineCount = $ProjectImporter::importer.getActivityLogLineCount();
+   for(%i=0; %i < %lineCount; %i++)
+   {
+      $ProjectImporter::log.add($ProjectImporter::importer.getActivityLogLine(%i));
+   }
 }
\ No newline at end of file

From e45b959d7d5b056719538ecc1fa845bcfc837729 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Wed, 3 Nov 2021 12:30:52 -0500
Subject: [PATCH 232/399] correct imageassetarrays having a singular texture
 profile as oposed to a type per. while that certainly works for most cases it
 falls apart when dealing with postfx where it's an unnamed array of variable
 types of inputs. shifted the profile assignment to #define
 INIT_IMAGEASSET_ARRAY(name, profile, index) so there's still a really obvious
 point where you can see the default setting, even if it's not in the more
 desireable OG definition spot for postfx in particular, given we can swap
 that, provided an example of how to do just that

---
 Engine/source/T3D/assets/ImageAsset.h         | 15 +++++++++---
 Engine/source/T3D/fx/splash.cpp               |  2 +-
 Engine/source/T3D/fx/splash.h                 |  2 +-
 Engine/source/environment/basicClouds.cpp     |  3 +++
 Engine/source/environment/basicClouds.h       |  4 ++--
 Engine/source/gfx/sim/cubemapData.cpp         |  2 +-
 Engine/source/gfx/sim/cubemapData.h           |  2 +-
 Engine/source/gui/controls/guiPopUpCtrl.cpp   |  4 ++--
 Engine/source/gui/controls/guiPopUpCtrl.h     |  2 +-
 Engine/source/gui/controls/guiPopUpCtrlEx.cpp |  4 ++--
 Engine/source/gui/controls/guiPopUpCtrlEx.h   |  2 +-
 .../source/materials/materialDefinition.cpp   | 24 +++++++++----------
 Engine/source/materials/materialDefinition.h  | 24 +++++++++----------
 Engine/source/postFx/postEffect.cpp           | 22 ++++++++++-------
 Engine/source/postFx/postEffect.h             |  2 +-
 15 files changed, 66 insertions(+), 48 deletions(-)

diff --git a/Engine/source/T3D/assets/ImageAsset.h b/Engine/source/T3D/assets/ImageAsset.h
index d4de538f7..f53cb4fa0 100644
--- a/Engine/source/T3D/assets/ImageAsset.h
+++ b/Engine/source/T3D/assets/ImageAsset.h
@@ -304,13 +304,13 @@ if (m##name##AssetId != StringTable->EmptyString())\
 #pragma region Arrayed Asset Macros
 
 //Arrayed Assets
-#define DECLARE_IMAGEASSET_ARRAY(className, name, profile, max) public: \
+#define DECLARE_IMAGEASSET_ARRAY(className, name, max) public: \
    static const U32 sm##name##Count = max;\
    GFXTexHandle m##name[max];\
    StringTableEntry m##name##Name[max]; \
    StringTableEntry m##name##AssetId[max];\
    AssetPtr<ImageAsset>  m##name##Asset[max];\
-   GFXTextureProfile * m##name##Profile = &profile;\
+   GFXTextureProfile * m##name##Profile[max];\
 public: \
    const StringTableEntry get##name##File(const U32& index) const { return m##name##Name[index]; }\
    void set##name##File(const FileName &_in, const U32& index) { m##name##Name[index] = StringTable->insert(_in.c_str());}\
@@ -374,7 +374,7 @@ public: \
       }\
       if (get##name(index) != StringTable->EmptyString() && m##name##Name[index] != StringTable->insert("texhandle"))\
       {\
-         m##name[index].set(get##name(index), m##name##Profile, avar("%s() - mTextureObject (line %d)", __FUNCTION__, __LINE__));\
+         m##name[index].set(get##name(index), m##name##Profile[index], avar("%s() - mTextureObject (line %d)", __FUNCTION__, __LINE__));\
       }\
       else\
       {\
@@ -445,6 +445,15 @@ public: \
       return ret;\
    }
 
+#define INIT_IMAGEASSET_ARRAY(name, profile, index) \
+{\
+   m##name##Name[index] = StringTable->EmptyString(); \
+   m##name##AssetId[index] = StringTable->EmptyString(); \
+   m##name##Asset[index] = NULL;\
+   m##name[index] = NULL;\
+   m##name##Profile[index] = &profile;\
+}
+
 #define DEF_IMAGEASSET_ARRAY_BINDS(className,name)\
 DefineEngineMethod(className, get##name, const char*, (S32 index), , "get name")\
 {\
diff --git a/Engine/source/T3D/fx/splash.cpp b/Engine/source/T3D/fx/splash.cpp
index 3ae7e54b4..7cc835c93 100644
--- a/Engine/source/T3D/fx/splash.cpp
+++ b/Engine/source/T3D/fx/splash.cpp
@@ -98,7 +98,7 @@ SplashData::SplashData()
    U32 i;
    for (i = 0; i < NUM_TEX; i++)
    {
-      INIT_ASSET_ARRAY(Texture, i);
+      INIT_IMAGEASSET_ARRAY(Texture, GFXStaticTextureSRGBProfile, i);
    }
 
    for( i=0; i<NUM_TIME_KEYS; i++ )
diff --git a/Engine/source/T3D/fx/splash.h b/Engine/source/T3D/fx/splash.h
index b81c074f5..a395739ff 100644
--- a/Engine/source/T3D/fx/splash.h
+++ b/Engine/source/T3D/fx/splash.h
@@ -122,7 +122,7 @@ public:
    F32               times[ NUM_TIME_KEYS ];
    LinearColorF            colors[ NUM_TIME_KEYS ];
 
-   DECLARE_IMAGEASSET_ARRAY(SplashData, Texture, GFXStaticTextureSRGBProfile, NUM_TEX);
+   DECLARE_IMAGEASSET_ARRAY(SplashData, Texture, NUM_TEX);
    DECLARE_IMAGEASSET_ARRAY_SETGET(SplashData, Texture)
 
    ExplosionData*    explosion;
diff --git a/Engine/source/environment/basicClouds.cpp b/Engine/source/environment/basicClouds.cpp
index 462bf573f..f6d6d8bdb 100644
--- a/Engine/source/environment/basicClouds.cpp
+++ b/Engine/source/environment/basicClouds.cpp
@@ -98,6 +98,9 @@ BasicClouds::BasicClouds()
    mTexOffset[0].set( 0.5f, 0.5f );
    mTexOffset[1].set( 0.5f, 0.5f );
    mTexOffset[2].set( 0.5f, 0.5f );
+
+   for (U32 i=0; i< TEX_COUNT;i++)
+      INIT_IMAGEASSET_ARRAY(Texture, GFXStaticTextureSRGBProfile, i);
 }
 
 IMPLEMENT_CO_NETOBJECT_V1( BasicClouds );
diff --git a/Engine/source/environment/basicClouds.h b/Engine/source/environment/basicClouds.h
index 03b31af19..a9f6f874e 100644
--- a/Engine/source/environment/basicClouds.h
+++ b/Engine/source/environment/basicClouds.h
@@ -93,7 +93,7 @@ protected:
    static U32 smVertCount;
    static U32 smTriangleCount;
 
-   DECLARE_IMAGEASSET_ARRAY(BasicClouds, Texture, GFXStaticTextureSRGBProfile, TEX_COUNT);
+   DECLARE_IMAGEASSET_ARRAY(BasicClouds, Texture, TEX_COUNT);
    DECLARE_IMAGEASSET_ARRAY_NET_SETGET(BasicClouds, Texture, -1);
 
    GFXStateBlockRef mStateblock;
@@ -122,4 +122,4 @@ protected:
 };
 
 
-#endif // _BASICCLOUDS_H_
\ No newline at end of file
+#endif // _BASICCLOUDS_H_
diff --git a/Engine/source/gfx/sim/cubemapData.cpp b/Engine/source/gfx/sim/cubemapData.cpp
index 3fbaf4afb..618e1842f 100644
--- a/Engine/source/gfx/sim/cubemapData.cpp
+++ b/Engine/source/gfx/sim/cubemapData.cpp
@@ -44,7 +44,7 @@ CubemapData::CubemapData()
 
    for (U32 i = 0; i < 6; i++)
    {
-      INIT_ASSET_ARRAY(CubeMapFace, i);
+      INIT_IMAGEASSET_ARRAY(CubeMapFace, GFXStaticTextureSRGBProfile, i);
    }
 
    INIT_ASSET(CubeMap);
diff --git a/Engine/source/gfx/sim/cubemapData.h b/Engine/source/gfx/sim/cubemapData.h
index c33cf7021..b6f97a2f9 100644
--- a/Engine/source/gfx/sim/cubemapData.h
+++ b/Engine/source/gfx/sim/cubemapData.h
@@ -76,7 +76,7 @@ protected:
    DECLARE_IMAGEASSET(CubemapData, CubeMap, onCubemapChanged, GFXStaticTextureSRGBProfile);
    DECLARE_ASSET_SETGET(CubemapData, CubeMap);
 
-   DECLARE_IMAGEASSET_ARRAY(CubemapData, CubeMapFace, GFXStaticTextureSRGBProfile, 6);
+   DECLARE_IMAGEASSET_ARRAY(CubemapData, CubeMapFace, 6);
    DECLARE_IMAGEASSET_ARRAY_SETGET(CubemapData, CubeMapFace);
 
    GFXTexHandle mDepthBuff;
diff --git a/Engine/source/gui/controls/guiPopUpCtrl.cpp b/Engine/source/gui/controls/guiPopUpCtrl.cpp
index 8e9eb5c24..2e0f022b5 100644
--- a/Engine/source/gui/controls/guiPopUpCtrl.cpp
+++ b/Engine/source/gui/controls/guiPopUpCtrl.cpp
@@ -278,8 +278,8 @@ GuiPopUpMenuCtrl::GuiPopUpMenuCtrl(void)
    mBackgroundCancel = false; //  Added
    mReverseTextList = false; //  Added - Don't reverse text list if displaying up
 
-   INIT_ASSET_ARRAY(Bitmap, 0);
-   INIT_ASSET_ARRAY(Bitmap, 1);
+   INIT_IMAGEASSET_ARRAY(Bitmap, GFXDefaultGUIProfile, 0);
+   INIT_IMAGEASSET_ARRAY(Bitmap, GFXDefaultGUIProfile, 1);
 
    mBitmapBounds.set(16, 16); //  Added
    mIdMax = -1;
diff --git a/Engine/source/gui/controls/guiPopUpCtrl.h b/Engine/source/gui/controls/guiPopUpCtrl.h
index 4ebc31794..d208fbfd2 100644
--- a/Engine/source/gui/controls/guiPopUpCtrl.h
+++ b/Engine/source/gui/controls/guiPopUpCtrl.h
@@ -126,7 +126,7 @@ protected:
       NumBitmapModes = 2
    };
 
-   DECLARE_IMAGEASSET_ARRAY(GuiPopUpMenuCtrl, Bitmap, GFXDefaultGUIProfile, NumBitmapModes);
+   DECLARE_IMAGEASSET_ARRAY(GuiPopUpMenuCtrl, Bitmap, NumBitmapModes);
    DECLARE_IMAGEASSET_ARRAY_SETGET(GuiPopUpMenuCtrl, Bitmap);
 
    Point2I mBitmapBounds; //  Added
diff --git a/Engine/source/gui/controls/guiPopUpCtrlEx.cpp b/Engine/source/gui/controls/guiPopUpCtrlEx.cpp
index 0a10d870c..fe9b20fa0 100644
--- a/Engine/source/gui/controls/guiPopUpCtrlEx.cpp
+++ b/Engine/source/gui/controls/guiPopUpCtrlEx.cpp
@@ -329,8 +329,8 @@ GuiPopUpMenuCtrlEx::GuiPopUpMenuCtrlEx(void)
    mBackgroundCancel = false; //  Added
    mReverseTextList = false; //  Added - Don't reverse text list if displaying up
 
-   INIT_ASSET_ARRAY(Bitmap, Normal);
-   INIT_ASSET_ARRAY(Bitmap, Depressed);
+   INIT_IMAGEASSET_ARRAY(Bitmap, GFXDefaultGUIProfile, Normal);
+   INIT_IMAGEASSET_ARRAY(Bitmap, GFXDefaultGUIProfile, Depressed);
 
    mBitmapBounds.set(16, 16); //  Added
    mHotTrackItems = false;
diff --git a/Engine/source/gui/controls/guiPopUpCtrlEx.h b/Engine/source/gui/controls/guiPopUpCtrlEx.h
index c3f193156..d3018819e 100644
--- a/Engine/source/gui/controls/guiPopUpCtrlEx.h
+++ b/Engine/source/gui/controls/guiPopUpCtrlEx.h
@@ -127,7 +127,7 @@ class GuiPopUpMenuCtrlEx : public GuiTextCtrl
       NumBitmapModes = 2
    };
 
-   DECLARE_IMAGEASSET_ARRAY(GuiPopUpMenuCtrlEx, Bitmap, GFXDefaultGUIProfile, NumBitmapModes);
+   DECLARE_IMAGEASSET_ARRAY(GuiPopUpMenuCtrlEx, Bitmap, NumBitmapModes);
    DECLARE_IMAGEASSET_ARRAY_SETGET(GuiPopUpMenuCtrlEx, Bitmap);
 
    Point2I mBitmapBounds; //  Added
diff --git a/Engine/source/materials/materialDefinition.cpp b/Engine/source/materials/materialDefinition.cpp
index 34a26a617..5d009004a 100644
--- a/Engine/source/materials/materialDefinition.cpp
+++ b/Engine/source/materials/materialDefinition.cpp
@@ -142,18 +142,18 @@ Material::Material()
       mAccuCoverage[i] = 0.9f;
       mAccuSpecular[i] = 16.0f;
 
-      INIT_ASSET_ARRAY(DiffuseMap, i);
-      INIT_ASSET_ARRAY(OverlayMap, i);
-      INIT_ASSET_ARRAY(LightMap, i);
-      INIT_ASSET_ARRAY(ToneMap, i);
-      INIT_ASSET_ARRAY(DetailMap, i);
-      INIT_ASSET_ARRAY(NormalMap, i);
-      INIT_ASSET_ARRAY(ORMConfigMap, i);
-      INIT_ASSET_ARRAY(RoughMap, i);
-      INIT_ASSET_ARRAY(AOMap, i);
-      INIT_ASSET_ARRAY(MetalMap, i);
-      INIT_ASSET_ARRAY(GlowMap, i);
-      INIT_ASSET_ARRAY(DetailNormalMap, i);
+      INIT_IMAGEASSET_ARRAY(DiffuseMap, GFXStaticTextureSRGBProfile, i);
+      INIT_IMAGEASSET_ARRAY(OverlayMap, GFXStaticTextureProfile, i);
+      INIT_IMAGEASSET_ARRAY(LightMap, GFXStaticTextureProfile, i);
+      INIT_IMAGEASSET_ARRAY(ToneMap, GFXStaticTextureProfile, i);
+      INIT_IMAGEASSET_ARRAY(DetailMap, GFXStaticTextureProfile, i);
+      INIT_IMAGEASSET_ARRAY(NormalMap, GFXNormalMapProfile, i);
+      INIT_IMAGEASSET_ARRAY(ORMConfigMap, GFXStaticTextureProfile, i);
+      INIT_IMAGEASSET_ARRAY(RoughMap, GFXStaticTextureProfile, i);
+      INIT_IMAGEASSET_ARRAY(AOMap, GFXStaticTextureProfile, i);
+      INIT_IMAGEASSET_ARRAY(MetalMap, GFXStaticTextureProfile, i);
+      INIT_IMAGEASSET_ARRAY(GlowMap, GFXStaticTextureProfile, i);
+      INIT_IMAGEASSET_ARRAY(DetailNormalMap, GFXNormalMapProfile, i);
 
       mParallaxScale[i] = 0.0f;
 
diff --git a/Engine/source/materials/materialDefinition.h b/Engine/source/materials/materialDefinition.h
index e29f53695..d087a698a 100644
--- a/Engine/source/materials/materialDefinition.h
+++ b/Engine/source/materials/materialDefinition.h
@@ -207,49 +207,49 @@ public:
    //-----------------------------------------------------------------------
    // Data
    //-----------------------------------------------------------------------
-   DECLARE_IMAGEASSET_ARRAY(Material, DiffuseMap, GFXStaticTextureSRGBProfile, MAX_STAGES);
+   DECLARE_IMAGEASSET_ARRAY(Material, DiffuseMap, MAX_STAGES);
    DECLARE_IMAGEASSET_ARRAY_SETGET(Material, DiffuseMap);
 
    bool     mDiffuseMapSRGB[MAX_STAGES];   // SRGB diffuse
-   DECLARE_IMAGEASSET_ARRAY(Material, OverlayMap, GFXStaticTextureProfile, MAX_STAGES);
+   DECLARE_IMAGEASSET_ARRAY(Material, OverlayMap, MAX_STAGES);
    DECLARE_IMAGEASSET_ARRAY_SETGET(Material, OverlayMap);
 
-   DECLARE_IMAGEASSET_ARRAY(Material, LightMap, GFXStaticTextureProfile, MAX_STAGES);
+   DECLARE_IMAGEASSET_ARRAY(Material, LightMap, MAX_STAGES);
    DECLARE_IMAGEASSET_ARRAY_SETGET(Material, LightMap);
 
-   DECLARE_IMAGEASSET_ARRAY(Material, ToneMap, GFXStaticTextureProfile, MAX_STAGES);
+   DECLARE_IMAGEASSET_ARRAY(Material, ToneMap, MAX_STAGES);
    DECLARE_IMAGEASSET_ARRAY_SETGET(Material, ToneMap);
 
-   DECLARE_IMAGEASSET_ARRAY(Material, DetailMap, GFXStaticTextureProfile, MAX_STAGES);
+   DECLARE_IMAGEASSET_ARRAY(Material, DetailMap, MAX_STAGES);
    DECLARE_IMAGEASSET_ARRAY_SETGET(Material, DetailMap);
 
-   DECLARE_IMAGEASSET_ARRAY(Material, NormalMap, GFXNormalMapProfile, MAX_STAGES);
+   DECLARE_IMAGEASSET_ARRAY(Material, NormalMap, MAX_STAGES);
    DECLARE_IMAGEASSET_ARRAY_SETGET(Material, NormalMap);
 
-   DECLARE_IMAGEASSET_ARRAY(Material, ORMConfigMap, GFXStaticTextureProfile, MAX_STAGES);
+   DECLARE_IMAGEASSET_ARRAY(Material, ORMConfigMap, MAX_STAGES);
    DECLARE_IMAGEASSET_ARRAY_SETGET(Material, ORMConfigMap);
 
    bool     mIsSRGb[MAX_STAGES];
-   DECLARE_IMAGEASSET_ARRAY(Material, RoughMap, GFXStaticTextureProfile, MAX_STAGES);
+   DECLARE_IMAGEASSET_ARRAY(Material, RoughMap, MAX_STAGES);
    DECLARE_IMAGEASSET_ARRAY_SETGET(Material, RoughMap);
 
    bool     mInvertRoughness[MAX_STAGES];
    F32      mRoughnessChan[MAX_STAGES];
-   DECLARE_IMAGEASSET_ARRAY(Material, AOMap, GFXStaticTextureProfile, MAX_STAGES);
+   DECLARE_IMAGEASSET_ARRAY(Material, AOMap, MAX_STAGES);
    DECLARE_IMAGEASSET_ARRAY_SETGET(Material, AOMap);
 
    F32      mAOChan[MAX_STAGES];
-   DECLARE_IMAGEASSET_ARRAY(Material, MetalMap, GFXStaticTextureProfile, MAX_STAGES);
+   DECLARE_IMAGEASSET_ARRAY(Material, MetalMap, MAX_STAGES);
    DECLARE_IMAGEASSET_ARRAY_SETGET(Material, MetalMap);
 
    F32      mMetalChan[MAX_STAGES];
-   DECLARE_IMAGEASSET_ARRAY(Material, GlowMap, GFXStaticTextureProfile, MAX_STAGES);
+   DECLARE_IMAGEASSET_ARRAY(Material, GlowMap, MAX_STAGES);
    DECLARE_IMAGEASSET_ARRAY_SETGET(Material, GlowMap);
 
    F32      mGlowMul[MAX_STAGES];
    /// A second normal map which repeats at the detail map
    /// scale and blended with the base normal map.
-   DECLARE_IMAGEASSET_ARRAY(Material, DetailNormalMap, GFXNormalMapProfile, MAX_STAGES);
+   DECLARE_IMAGEASSET_ARRAY(Material, DetailNormalMap, MAX_STAGES);
    DECLARE_IMAGEASSET_ARRAY_SETGET(Material, DetailNormalMap);
 
    /// The strength scalar for the detail normal map.
diff --git a/Engine/source/postFx/postEffect.cpp b/Engine/source/postFx/postEffect.cpp
index 2f87ffa67..fd6da0612 100644
--- a/Engine/source/postFx/postEffect.cpp
+++ b/Engine/source/postFx/postEffect.cpp
@@ -508,7 +508,7 @@ PostEffect::PostEffect()
 
    for (U32 i = 0; i < NumTextures; i++)
    {
-      INIT_ASSET_ARRAY(Texture, i);
+      INIT_IMAGEASSET_ARRAY(Texture, PostFxTextureProfile, i);
    }
 }
 
@@ -602,9 +602,19 @@ bool PostEffect::onAdd()
    scriptPath.setExtension( String::EmptyString );
 
    // Find additional textures
-   for( S32 i = 0; i < NumTextures; i++ )
+   for (S32 i = 0; i < NumTextures; i++)
    {
       mTextureType[i] = NormalTextureType;
+      String texFilename = getTexture(i);
+
+      // Skip empty stages or ones with variable or target names.
+      if (texFilename.isEmpty() ||
+         texFilename[0] == '$' ||
+         texFilename[0] == '#')
+         continue;
+
+      mTextureProfile[i] = (mTexSRGB[i]) ? &PostFxTextureSRGBProfile : &PostFxTextureProfile;
+      _setTexture(texFilename, i);
    }
 
    // Is the target a named target?
@@ -1625,12 +1635,8 @@ void PostEffect::setTexture( U32 index, const String &texFilePath )
 			texFilePath[0] == '#' )
 		return;
 
-    GFXTextureProfile* profile = &PostFxTextureProfile;
-    if (mTexSRGB[index])
-       profile = &PostFxTextureSRGBProfile;
-
-    // Try to load the texture.
-    mTexture[index].set( texFilePath, profile, avar( "%s() - (line %d)", __FUNCTION__, __LINE__ ) );
+    mTextureProfile[index] = (mTexSRGB[index])? &PostFxTextureSRGBProfile : &PostFxTextureProfile;
+    _setTexture(texFilePath, index);
 
     mTextureType[index] = NormalTextureType;
 }
diff --git a/Engine/source/postFx/postEffect.h b/Engine/source/postFx/postEffect.h
index 287048100..94b457339 100644
--- a/Engine/source/postFx/postEffect.h
+++ b/Engine/source/postFx/postEffect.h
@@ -90,7 +90,7 @@ public:
 
 protected:
 
-   DECLARE_IMAGEASSET_ARRAY(PostEffect, Texture, PostFxTextureProfile, NumTextures);
+   DECLARE_IMAGEASSET_ARRAY(PostEffect, Texture, NumTextures);
    DECLARE_IMAGEASSET_ARRAY_SETGET(PostEffect, Texture);
 
    bool mTexSRGB[NumTextures];

From 400db2da88944e0400c9da20c7b7a562c7cd6ace Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Wed, 3 Nov 2021 18:27:26 -0400
Subject: [PATCH 233/399] * [TAML] BugFix: Correct a delete and new[] mismatch
 in tamlWriteNode reported by ASAN.

---
 Engine/source/persistence/taml/tamlWriteNode.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Engine/source/persistence/taml/tamlWriteNode.cpp b/Engine/source/persistence/taml/tamlWriteNode.cpp
index 7baa138b2..25aaf4515 100644
--- a/Engine/source/persistence/taml/tamlWriteNode.cpp
+++ b/Engine/source/persistence/taml/tamlWriteNode.cpp
@@ -35,7 +35,7 @@ void TamlWriteNode::resetNode( void )
     // Clear fields.
     for( Vector<TamlWriteNode::FieldValuePair*>::iterator itr = mFields.begin(); itr != mFields.end(); ++itr )
     {
-        delete (*itr)->mpValue;
+        delete[] (*itr)->mpValue;
     }
     mFields.clear();
 

From 19e4643707c7bc101c6f6f514b50ab55259cd2dd Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Wed, 3 Nov 2021 21:15:00 -0500
Subject: [PATCH 234/399] new method tsstatic.getNodeTransform used to look up
 a given node's transform by explicit name in a tsstatic object

---
 Engine/source/T3D/tsStatic.cpp | 29 +++++++++++++++++++++++++++++
 Engine/source/T3D/tsStatic.h   |  1 +
 2 files changed, 30 insertions(+)

diff --git a/Engine/source/T3D/tsStatic.cpp b/Engine/source/T3D/tsStatic.cpp
index 169e6d806..8e090ef9f 100644
--- a/Engine/source/T3D/tsStatic.cpp
+++ b/Engine/source/T3D/tsStatic.cpp
@@ -54,6 +54,7 @@
 #include "materials/materialFeatureTypes.h"
 #include "console/engineAPI.h"
 #include "T3D/accumulationVolume.h"
+#include "math/mTransform.h"
 
 #include "gui/editor/inspector/group.h"
 #include "console/typeValidators.h"
@@ -1863,3 +1864,31 @@ void TSStatic::setSelectionFlags(U8 flags)
    }
 }
 
+void TSStatic::getNodeTransform(const char *nodeName, const MatrixF &xfm, MatrixF *outMat)
+{
+
+    S32 nodeIDx = getShapeResource()->findNode(nodeName);
+
+    MatrixF mountTransform = mShapeInstance->mNodeTransforms[nodeIDx];
+    mountTransform.mul(xfm);
+    const Point3F &scale = getScale();
+    // The position of the mount point needs to be scaled.
+    Point3F position = mountTransform.getPosition();
+    position.convolve(scale);
+    mountTransform.setPosition(position);
+    // Also we would like the object to be scaled to the model.
+    outMat->mul(mObjToWorld, mountTransform);
+    return;
+}
+
+
+DefineEngineMethod(TSStatic, getNodeTransform, TransformF, (const char *nodeName), ,
+   "@brief Get the world transform of the specified mount slot.\n\n"
+
+   "@param slot Image slot to query\n"
+   "@return the mount transform\n\n")
+{
+   MatrixF xf(true);
+   object->getNodeTransform(nodeName, MatrixF::Identity, &xf);
+   return xf;
+}
diff --git a/Engine/source/T3D/tsStatic.h b/Engine/source/T3D/tsStatic.h
index 03c74c651..835310c3d 100644
--- a/Engine/source/T3D/tsStatic.h
+++ b/Engine/source/T3D/tsStatic.h
@@ -276,6 +276,7 @@ public:
    void updateMaterials();
 
    bool isAnimated() { return mPlayAmbient; }
+   void getNodeTransform(const char *nodeName, const MatrixF &xfm, MatrixF *outMat);
 
    virtual void getUtilizedAssets(Vector<StringTableEntry>* usedAssetsList);
 

From e211f502e8f229b9110e087e8a18f4f949d3aeb1 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Thu, 4 Nov 2021 15:44:43 -0500
Subject: [PATCH 235/399] better handle old style references to named texture
 targets

---
 Engine/source/T3D/assets/ImageAsset.h | 7 ++++++-
 Engine/source/postFx/postEffect.cpp   | 2 +-
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/Engine/source/T3D/assets/ImageAsset.h b/Engine/source/T3D/assets/ImageAsset.h
index f53cb4fa0..927d8e03e 100644
--- a/Engine/source/T3D/assets/ImageAsset.h
+++ b/Engine/source/T3D/assets/ImageAsset.h
@@ -405,7 +405,12 @@ public: \
       else if (m##name##AssetId[index] != StringTable->EmptyString())\
          return m##name##AssetId[index];\
       else if (m##name##Name[index] != StringTable->EmptyString())\
-         return StringTable->insert(Platform::makeRelativePathName(m##name##Name[index], Platform::getMainDotCsDir()));\
+      {\
+         if (String(m##name##Name[index]).startsWith("#") || String(m##name##Name[index]).startsWith("$"))\
+            return StringTable->insert(m##name##Name[index]);\
+         else\
+            return StringTable->insert(Platform::makeRelativePathName(m##name##Name[index], Platform::getMainDotCsDir()));\
+      }\
       else\
          return StringTable->EmptyString();\
    }\
diff --git a/Engine/source/postFx/postEffect.cpp b/Engine/source/postFx/postEffect.cpp
index fd6da0612..ca6baeb89 100644
--- a/Engine/source/postFx/postEffect.cpp
+++ b/Engine/source/postFx/postEffect.cpp
@@ -1122,7 +1122,7 @@ void PostEffect::_setupConstants( const SceneRenderState *state )
 
 void PostEffect::_setupTexture( U32 stage, GFXTexHandle &inputTex, const RectI *inTexViewport )
 {
-   const String &texFilename = mTextureName[ stage ];
+   const String &texFilename = getTexture( stage );
 
    GFXTexHandle theTex;
    NamedTexTarget *namedTarget = NULL;

From b3cd08520e89f6757096dd2df6198a152b83090c Mon Sep 17 00:00:00 2001
From: JeffR <Areloch@gmail.com>
Date: Fri, 5 Nov 2021 17:49:48 -0500
Subject: [PATCH 236/399] Disables generation of the materials script files by
 the internal shape import processor. Material script files are now only
 generated by the AssetImporter as part of the shape injest process. Renames
 validateImportingAssets to hasImportIssues for AssetImporter console method
 for clarity Updated console method documentation for AssetImporter methods
 Fixed logical error for material asset generation if the import config was
 set to use existing materials but one was not found. Fixed logical error when
 a shapeFile has a material with a texture mapped to it is not in the same
 directory as the shape, it would not correctly find the texture Adjusts
 AssetImport window logic so it will display the window in the event of import
 issues being detected, or the asset is being re-imported. Updates the
 AssetImport window activity log to use the new AssetImporter's log for
 consistency.

---
 Engine/source/T3D/assets/assetImporter.cpp    |  34 +++---
 .../T3D/assets/assetImporter_ScriptBinding.h  | 101 ++++++++----------
 Engine/source/ts/assimp/assimpShapeLoader.cpp |   1 +
 .../source/ts/collada/colladaShapeLoader.cpp  |   2 +
 .../assetBrowser/scripts/assetImport.tscript  |  13 +--
 .../scripts/assetImportConfig.tscript         |  12 ---
 6 files changed, 64 insertions(+), 99 deletions(-)

diff --git a/Engine/source/T3D/assets/assetImporter.cpp b/Engine/source/T3D/assets/assetImporter.cpp
index 65c18d664..2b284f5a5 100644
--- a/Engine/source/T3D/assets/assetImporter.cpp
+++ b/Engine/source/T3D/assets/assetImporter.cpp
@@ -1617,6 +1617,7 @@ void AssetImporter::processMaterialAsset(AssetImportObject* assetItem)
       }
    }
 
+   bool foundExistingMaterial = false;
    if (activeImportConfig->UseExistingMaterials)
    {
       //So if the material already exists, we should just use that. So first, let's find out if it already exists
@@ -1651,9 +1652,11 @@ void AssetImporter::processMaterialAsset(AssetImportObject* assetItem)
       {
          //We found a match, so just modify our asset item's info to point against it. This will create the asset definition, but otherwise leave the material definition as-is.
          assetItem->filePath = (Torque::Path)(mat->getFilename());
+         foundExistingMaterial = true;
       }
    }
-   else
+
+   if(!foundExistingMaterial)
    {
       if (activeImportConfig->AlwaysAddMaterialSuffix) //we only opt to force on the suffix if we're not obligating using the original material defs
       {
@@ -1811,19 +1814,6 @@ void AssetImporter::processMaterialAsset(AssetImportObject* assetItem)
                }
             }
          }
-
-         /*for (U32 i = 0; i < assetItem->childAssetItems.size(); i++)
-         {
-            AssetImportObject* childAssetItem = assetItem->childAssetItems[i];
-
-            if (childAssetItem->skip || childAssetItem->processed || childAssetItem->assetType != String("ImageAsset"))
-               continue;
-
-            if (childAssetItem->imageSuffixType == String("Albedo"))
-            {
-               assetItem->diffuseImageAsset = % childAssetItem;
-            }
-         }*/
       }
    }
    
@@ -1963,7 +1953,7 @@ void AssetImporter::processShapeMaterialInfo(AssetImportObject* assetItem, S32 m
    else
    {
       Torque::Path filePath = materialItemValue;
-      String fullFilePath = filePath.getFullFileName().c_str();
+      String fullFilePath = filePath.getFullPath().c_str();
       String shapePathBase = assetItem->filePath.getRootAndPath();
 
       if (fullFilePath.isNotEmpty())
@@ -1977,24 +1967,26 @@ void AssetImporter::processShapeMaterialInfo(AssetImportObject* assetItem, S32 m
             fullFilePath = fullFilePath.replace(" (Not Found)", "");
             fullFilePath = fullFilePath.replace(" (not found)", "");
 
-            String testFileName = shapePathBase + "/" + fullFilePath;
-            if (Platform::isFile(testFileName.c_str()))
+            if(filePath.getPath().isEmpty())
+               fullFilePath = shapePathBase + "/" + fullFilePath;
+ 
+            if (Platform::isFile(fullFilePath.c_str()))
             {
-               filePath = testFileName;
+               filePath = Torque::Path(fullFilePath);
             }
             else
             {
                //Hmm, didn't find it. It could be that the in-model filename could be different by virtue of
                //image extension. Some files have source content files like psd's, but the mesh was exported to use
                //a dds or png, etc
-               Torque::Path testFilePath = testFileName;
+               Torque::Path testFilePath = fullFilePath;
                String imgFileName = AssetImporter::findImagePath(testFilePath.getPath() + "/" + testFilePath.getFileName());
                if (imgFileName.isNotEmpty())
                   filePath = imgFileName;
             }
          }
  
-         matAssetItem = addImportingAsset("MaterialAsset", shapePathBase + "/", assetItem, matName);
+         matAssetItem = addImportingAsset("MaterialAsset", shapePathBase + "/" + matName, assetItem, matName);
          AssetImportObject* imageAssetItem = addImportingAsset("ImageAsset", filePath, matAssetItem, "");
 
          String suffixType;
@@ -2831,7 +2823,7 @@ Torque::Path AssetImporter::importMaterialAsset(AssetImportObject* assetItem)
          }
 
          assetFieldName = mapFieldName + "Asset";
-         mapFieldName += "[0]";
+         assetFieldName += "[0]";
 
          //String path = childItem->filePath.getFullFileName();
          //dSprintf(lineBuffer, 1024, "   %s = \"%s\";", mapFieldName.c_str(), path.c_str());
diff --git a/Engine/source/T3D/assets/assetImporter_ScriptBinding.h b/Engine/source/T3D/assets/assetImporter_ScriptBinding.h
index e52da2c52..aa50c82de 100644
--- a/Engine/source/T3D/assets/assetImporter_ScriptBinding.h
+++ b/Engine/source/T3D/assets/assetImporter_ScriptBinding.h
@@ -6,113 +6,114 @@
 //Console Functions
 
 DefineEngineMethod(AssetImportConfig, loadImportConfig, void, (Settings* configSettings, String configName), (nullAsType<Settings*>(), ""),
-   "Creates a new script asset using the targetFilePath.\n"
-   "@return The bool result of calling exec")
+   "Loads the provided import config to the importer.\n"
+   "@param configSettings A Settings object containing the import configs.\n"
+   "@param configName The specific name of the config to be used.")
 {
    return object->loadImportConfig(configSettings, configName);
 }
 
 DefineEngineMethod(AssetImporter, setTargetPath, void, (String path), (""),
-   "Creates a new script asset using the targetFilePath.\n"
-   "@return The bool result of calling exec")
+   "Sets the target path the importing assets will be put into.\n"
+   "@param A string of the target path.")
 {
    return object->setTargetPath(path);
 }
 
 DefineEngineMethod(AssetImporter, resetImportSession, void, (bool forceResetSession), (false),
-   "Creates a new script asset using the targetFilePath.\n"
-   "@return The bool result of calling exec")
+   "Resets the importer's import session. All existing import items, logs, etc will be cleared.")
 {
    return object->resetImportSession(forceResetSession);
 }
 
 DefineEngineMethod(AssetImporter, dumpActivityLog, void, (), ,
-   "Creates a new script asset using the targetFilePath.\n"
-   "@return The bool result of calling exec")
+   "Dumps the import activity log. If the importer is set to, it will save to file, otherwise dump to console.")
 {
    return object->dumpActivityLog();
 }
 
 DefineEngineMethod(AssetImporter, getActivityLogLineCount, S32, (),,
-   "Creates a new script asset using the targetFilePath.\n"
-   "@return The bool result of calling exec")
+   "Gets the number of lines in the import activity log.\n"
+   "@return The number of lines in the import activity log.")
 {
    return object->getActivityLogLineCount();
 }
 
-DefineEngineMethod(AssetImporter, getActivityLogLine, String, (S32 i), (0),
-   "Creates a new script asset using the targetFilePath.\n"
-   "@return The bool result of calling exec")
+DefineEngineMethod(AssetImporter, getActivityLogLine, String, (S32 index), (0),
+   "Gets a specific line in the import activity log.\n"
+   "@param index The index of the line to be returned.\n"
+   "@return The string of the requested line of the activity log")
 {
-   return object->getActivityLogLine(i);
+   return object->getActivityLogLine(index);
 }
 
 DefineEngineMethod(AssetImporter, autoImportFile, String, (String path, String typeHint), ("", ""),
-   "Creates a new script asset using the targetFilePath.\n"
-   "@return The bool result of calling exec")
+   "Run the full import process on a specific file.\n"
+   "@return If import is successful, the assetId of the new asset. If it failed, an empty string.")
 {
    return object->autoImportFile(path, typeHint);
 }
 
 DefineEngineMethod(AssetImporter, addImportingFile, AssetImportObject*, (String path), (""),
-   "Creates a new script asset using the targetFilePath.\n"
-   "@return The bool result of calling exec")
+   "Adds a filepath to the current importing session.\n"
+   "@param path The path to the file to be imported.\n"
+   "@return The AssetImportObject from the import session.")
 {
    return object->addImportingFile(path);
 }
 
 DefineEngineMethod(AssetImporter, addImportingAssetItem, void, (AssetImportObject* assetItem, AssetImportObject* parentItem), (nullAsType< AssetImportObject*>(), nullAsType< AssetImportObject*>()),
-   "Creates a new script asset using the targetFilePath.\n"
-   "@return The bool result of calling exec")
+   "Adds an existing AssetImportObject to the current improting session.\n"
+   "@param assetItem The AssetImportObject to be added to the import session.\n"
+   "@param parentItem An AssetImportObject that to act as the parent of the item being added.")
 {
    return object->addImportingAssetItem(assetItem, parentItem);
 }
 
 DefineEngineMethod(AssetImporter, processImportingAssets, void, (), ,
-   "Creates a new script asset using the targetFilePath.\n"
-   "@return The bool result of calling exec")
+   "Processes the importing assets.")
 {
    return object->processImportAssets();
 }
 
-DefineEngineMethod(AssetImporter, validateImportingAssets, bool, (), ,
-   "Creates a new script asset using the targetFilePath.\n"
-   "@return The bool result of calling exec")
+DefineEngineMethod(AssetImporter, hasImportIssues, bool, (), ,
+   "Validates the status of the importing items.\n"
+   "@return False if there are no issues, true if there are importing issues")
 {
    return object->validateAssets();
 }
 
 DefineEngineMethod(AssetImporter, resolveAssetItemIssues, void, (AssetImportObject* assetItem), (nullAsType< AssetImportObject*>()),
-   "Creates a new script asset using the targetFilePath.\n"
-   "@return The bool result of calling exec")
+   "Runs the issue resolver to attempt to correct any simple issues, such as utilizing the config's settings to resolve collisions.")
 {
    object->resolveAssetItemIssues(assetItem);
 }
 
 DefineEngineMethod(AssetImporter, importAssets, void, (),,
-   "Creates a new script asset using the targetFilePath.\n"
-   "@return The bool result of calling exec")
+   "Runs the actual import action on the items.")
 {
    return object->importAssets();
 }
 
 DefineEngineMethod(AssetImporter, getAssetItemCount, S32, (),,
-   "Creates a new script asset using the targetFilePath.\n"
-   "@return The bool result of calling exec")
+   "Gets the number of importing asset items.\n"
+   "@return The number of importing asset items")
 {
    return object->getAssetItemCount();
 }
 
 DefineEngineMethod(AssetImporter, getAssetItem, AssetImportObject*, (S32 index), (0),
-   "Creates a new script asset using the targetFilePath.\n"
-   "@return The bool result of calling exec")
+   "Gets a specific import asset item.\n"
+   "@param index The index of the AssetImportObject to be returned.\n"
+   "@return AssetImportObject")
 {
    return object->getAssetItem(index);
 }
 
 DefineEngineMethod(AssetImporter, getAssetItemChildCount, S32, (AssetImportObject* assetItem), (nullAsType< AssetImportObject*>()),
-   "Creates a new script asset using the targetFilePath.\n"
-   "@return The bool result of calling exec")
+   "Gets number of child items for a given importing asset item.\n"
+   "@param assetItem The AssetImportObject to get the number of children of.\n"
+   "@return The number of child items")
 {
    if (assetItem == nullptr)
       return 0;
@@ -121,8 +122,10 @@ DefineEngineMethod(AssetImporter, getAssetItemChildCount, S32, (AssetImportObjec
 }
 
 DefineEngineMethod(AssetImporter, getAssetItemChild, AssetImportObject*, (AssetImportObject* assetItem, S32 index), (nullAsType< AssetImportObject*>(), 0),
-   "Creates a new script asset using the targetFilePath.\n"
-   "@return The bool result of calling exec")
+   "Gets a specific child item of a given importing asset item.\n"
+   "@param assetItem The AssetImportObject to get the child from.\n"
+   "@param index The index of the child to get.\n"
+   "@return The child AssetImportObect")
 {
    if (assetItem == nullptr)
       return nullptr;
@@ -131,31 +134,15 @@ DefineEngineMethod(AssetImporter, getAssetItemChild, AssetImportObject*, (AssetI
 }
 
 DefineEngineMethod(AssetImporter, deleteImportingAsset, void, (AssetImportObject* assetItem), (nullAsType< AssetImportObject*>()),
-   "Creates a new script asset using the targetFilePath.\n"
-   "@return The bool result of calling exec")
+   "Deletes an importing AssetImportObject from the import session.\n"
+   "@param assetItem The AssetImportObject to delete.")
 {
    return object->deleteImportingAsset(assetItem);
 }
 
 DefineEngineMethod(AssetImporter, setImportConfig, void, (AssetImportConfig* importConfig), (nullAsType< AssetImportConfig*>()),
-   "Creates a new script asset using the targetFilePath.\n"
-   "@return The bool result of calling exec")
+   "Sets the import config to be used via a AssetImportConfig object.\n"
+   "@param importConfig The AssetImportConfig object to use.")
 {
    return object->setImportConfig(importConfig);
 }
-
-
-/*DefineEngineFunction(enumColladaForImport, bool, (const char* shapePath, const char* ctrl, bool loadCachedDts), ("", "", true),
-   "(string shapePath, GuiTreeViewCtrl ctrl) Collect scene information from "
-   "a COLLADA file and store it in a GuiTreeView control. This function is "
-   "used by the COLLADA import gui to show a preview of the scene contents "
-   "prior to import, and is probably not much use for anything else.\n"
-   "@param shapePath COLLADA filename\n"
-   "@param ctrl GuiTreeView control to add elements to\n"
-   "@param loadCachedDts dictates if it should try and load the cached dts file if it exists"
-   "@return true if successful, false otherwise\n"
-   "@ingroup Editors\n"
-   "@internal")
-{
-   return enumColladaForImport(shapePath, ctrl, loadCachedDts);
-}*/
diff --git a/Engine/source/ts/assimp/assimpShapeLoader.cpp b/Engine/source/ts/assimp/assimpShapeLoader.cpp
index 17b0a970b..6659f1092 100644
--- a/Engine/source/ts/assimp/assimpShapeLoader.cpp
+++ b/Engine/source/ts/assimp/assimpShapeLoader.cpp
@@ -425,6 +425,7 @@ bool AssimpShapeLoader::fillGuiTreeView(const char* sourceShapePath, GuiTreeView
 
 void AssimpShapeLoader::updateMaterialsScript(const Torque::Path &path)
 {
+   return;
    Torque::Path scriptPath(path);
    scriptPath.setFileName("materials");
    scriptPath.setExtension(TORQUE_SCRIPT_EXTENSION);
diff --git a/Engine/source/ts/collada/colladaShapeLoader.cpp b/Engine/source/ts/collada/colladaShapeLoader.cpp
index 8021d25f1..7884e1a63 100644
--- a/Engine/source/ts/collada/colladaShapeLoader.cpp
+++ b/Engine/source/ts/collada/colladaShapeLoader.cpp
@@ -461,6 +461,8 @@ void updateMaterialsScript(const Torque::Path &path, bool copyTextures = false)
       return;
 #endif
 
+   return;
+
    Torque::Path scriptPath(path);
    scriptPath.setFileName("materials");
    scriptPath.setExtension(TORQUE_SCRIPT_EXTENSION);
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImport.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImport.tscript
index 1b42f482f..14023d9b2 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImport.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImport.tscript
@@ -85,8 +85,6 @@ function ImportAssetWindow::onWake(%this)
    %this.importer.targetPath = AssetImportTargetAddress.getText();
    %this.importer.targetModuleId = AssetImportTargetModule.getText();
    
-   ImportActivityLog.empty();
-   
    %this.refresh();
 }
 
@@ -519,7 +517,8 @@ function ImportAssetWindow::doRefresh(%this)
    if(ImportAssetWindow.importConfigsList.count() != 0 
       && EditorSettings.value("Assets/AssetImporDefaultConfig") !$= "" 
       && EditorSettings.value("Assets/AutoImport", false) == true
-      && ImportAssetWindow.hasImportIssues == false
+      && ImportAssetWindow.hasImportIssues() == false
+      && AssetBrowser.isAssetReImport == false
       && ImportAssetWindow.allowAutoImport)
    {
       AssetImportCtrl.setHidden(true);
@@ -722,11 +721,7 @@ function NewAssetsPanelInputs::onRightMouseDown(%this)
 //
 function ImportAssetWindow::removeImportingAsset(%this)
 {
-   ImportActivityLog.add("Removing Asset from Import");
-   
    %this.importer.deleteImportingAsset(ImportAssetActions.assetItem);
-   
-   //ImportAssetWindow.refresh();
 }
 
 function ImportAssetWindow::addNewImportingAsset(%this, %filterType)
@@ -924,9 +919,9 @@ function ImportAssetWindow::toggleLogWindow()
    }
       
    ImportLogTextList.clear();
-   for(%i=0; %i < ImportActivityLog.count(); %i++)
+   for(%i=0; %i < ImportAssetWindow.importer.getActivityLogLineCount(); %i++)
    {
-      ImportLogTextList.addRow(%i, ImportActivityLog.getKey(%i));
+      ImportLogTextList.addRow(%i,ImportAssetWindow.importer.getActivityLogLine(%i));
    }
 }
 //
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfig.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfig.tscript
index 44be3b3ce..39ed541db 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfig.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfig.tscript
@@ -3,12 +3,6 @@ function ImportAssetConfigList::onSelect( %this, %id, %text )
    //Apply our settings to the assets
    echo("Changed our import config!");
    
-   if(ImportActivityLog.count() != 0)
-      ImportActivityLog.add("");
-      
-   ImportActivityLog.add("Asset Import Configs set to " @ %text);
-   ImportActivityLog.add("");
-   
    ImportAssetWindow.activeImportConfigIndex = %id;
    //ImportAssetWindow.activeImportConfig = ImportAssetWindow.importConfigsList.getKey(%id);
    
@@ -236,12 +230,6 @@ function ImportAssetOptionsWindow::saveAssetOptions(%this)
 {
    %success = AssetImportSettings.write();
    
-   if(ImportActivityLog.count() != 0)
-      ImportActivityLog.add("");
-      
-   ImportActivityLog.add("Asset Import Configs saved, refreshing Import session");
-   ImportActivityLog.add("");
-   
    ImportAssetWindow.refresh();
    ImportAssetOptionsWindow.setVisible(0);   
 }

From a6a7d6e1a1768bb4ef9f37652d218af36e06bf92 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Sat, 6 Nov 2021 20:34:12 -0400
Subject: [PATCH 237/399] * [Tokenizer] BugFix: Correct a malloc/delete
 mismatch in the tokenizer programming.

---
 Engine/source/core/tokenizer.cpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/Engine/source/core/tokenizer.cpp b/Engine/source/core/tokenizer.cpp
index 6d155d18a..e34c35819 100644
--- a/Engine/source/core/tokenizer.cpp
+++ b/Engine/source/core/tokenizer.cpp
@@ -109,7 +109,10 @@ void Tokenizer::setBuffer(const char* buffer, U32 bufferSize)
 void Tokenizer::setSingleTokens(const char* singleTokens)
 {
    if (mSingleTokens)
-      SAFE_DELETE(mSingleTokens);
+   {
+      free(mSingleTokens);
+      mSingleTokens = NULL;
+   }
 
    if (singleTokens)
       mSingleTokens = dStrdup(singleTokens);

From 3fdd7266e340f87b6c1e97ec78de7c9f65fd2265 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Sat, 6 Nov 2021 22:56:05 -0400
Subject: [PATCH 238/399] Better Architecture detection strategy if compiling
 on Apple Silicon

---
 Tools/CMake/torque3d.cmake | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/Tools/CMake/torque3d.cmake b/Tools/CMake/torque3d.cmake
index 0629e944a..eadc2673a 100644
--- a/Tools/CMake/torque3d.cmake
+++ b/Tools/CMake/torque3d.cmake
@@ -745,14 +745,13 @@ if (APPLE AND NOT IOS)
     set(ARCHITECTURE_STRING_APPLE "x86_64;arm64")
     set(DEPLOYMENT_TARGET_APPLE "10.13")
   else()
-    check_c_compiler_flag("-arch arm64" armSupportedApple)
-    if(armSupportedApple)
+    if (CMAKE_SYSTEM_PROCESSOR MATCHES "arm64")
       set(ARCHITECTURE_STRING_APPLE "arm64")
       set(DEPLOYMENT_TARGET_APPLE "11.0")
     else()
       set(ARCHITECTURE_STRING_APPLE "x86_64")
       set(DEPLOYMENT_TARGET_APPLE "10.9")
-    endif() 
+    endif()
   endif()
 
   set(CMAKE_OSX_ARCHITECTURES ${ARCHITECTURE_STRING_APPLE} CACHE STRING "OSX Architecture" FORCE)

From a3351390c6d1ff642a04ccbf0478c0a9a894edb3 Mon Sep 17 00:00:00 2001
From: Areloch <Areloch@gmail.com>
Date: Sat, 6 Nov 2021 22:36:59 -0500
Subject: [PATCH 239/399] Expands handling of the collada enumerator so if the
 material is not named the same as the image file, it performs a lookup to
 find the associated material.

---
 Engine/source/T3D/assets/assetImporter.cpp | 70 +++++++++++++++++++++-
 1 file changed, 67 insertions(+), 3 deletions(-)

diff --git a/Engine/source/T3D/assets/assetImporter.cpp b/Engine/source/T3D/assets/assetImporter.cpp
index 2b284f5a5..4fbac249c 100644
--- a/Engine/source/T3D/assets/assetImporter.cpp
+++ b/Engine/source/T3D/assets/assetImporter.cpp
@@ -1158,12 +1158,76 @@ static bool enumColladaForImport(const char* shapePath, GuiTreeViewCtrl* tree, b
       {
          domImage* img = libraryImages->getImage_array()[j];
 
-         S32 materialID = tree->findItemByName(_GetNameOrId(img));
+         String imageName = _GetNameOrId(img);
+
+         S32 materialID = tree->findItemByName(imageName.c_str());
 
          if (materialID == 0)
-            continue;
+         {
+            bool materialFound = false;
+            String matName = "";
 
-         tree->setItemValue(materialID, img->getInit_from()->getValue().str().c_str());
+            //If we don't have an immediate name match, we'll have to actually go look it up
+            for (S32 e = 0; e < root->getLibrary_effects_array().getCount(); e++)
+            {
+               const domLibrary_effects* libraryEffects = root->getLibrary_effects_array()[e];
+
+               for (S32 f = 0; f < libraryEffects->getEffect_array().getCount(); f++)
+               {
+                  domEffect* efct = libraryEffects->getEffect_array()[f];
+
+                  String effectName = efct->getID();
+
+                  for (S32 p = 0; p < efct->getFx_profile_abstract_array().getCount(); p++)
+                  {
+                     domProfile_COMMON* profile = daeSafeCast<domProfile_COMMON>(efct->getFx_profile_abstract_array()[p]);
+
+                     for (S32 n = 0; n < profile->getNewparam_array().getCount(); n++)
+                     {
+                        domCommon_newparam_typeRef param = profile->getNewparam_array()[n];
+                        String paramName = param->getSid();
+                        if (paramName.endsWith("-surface"))
+                        {
+                           //ok it's surface data, parse out the name
+                           String surfaceName = paramName.substr(0, paramName.length() - 8);
+                           if (surfaceName == imageName)
+                           {
+                              //got a match!
+                              matName = effectName;
+                              if (matName.endsWith("-effect"))
+                              {
+                                 matName = matName.substr(0, matName.length() - 7);
+                                 materialFound = true;
+                                 break;
+                              }
+                           }
+                        }
+                     }
+
+                     if (materialFound)
+                        break;
+                  }
+
+                  if (materialFound)
+                  {
+                     materialID = tree->findItemByName(matName.c_str());
+                  }
+
+                  if (materialID != 0)
+                     break;
+               }
+            }
+
+            //if we STILL haven't found a match, then yes, we've failed
+            if (materialID == 0)
+               continue;
+         }
+
+         String imagePath = img->getInit_from()->getValue().str().c_str();
+         if (imagePath.startsWith("/"))
+            imagePath = imagePath.substr(1, imagePath.length() - 1);
+
+         tree->setItemValue(materialID, StringTable->insert(imagePath.c_str()));
       }
    }
 

From 733b71ccad97827a88b076a59728c4b13d7e923e Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Sun, 7 Nov 2021 14:52:25 -0600
Subject: [PATCH 240/399] fill out a %this variable for trigger callbacks

---
 Engine/source/T3D/trigger.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/Engine/source/T3D/trigger.cpp b/Engine/source/T3D/trigger.cpp
index e6b1d2027..1d075d7c3 100644
--- a/Engine/source/T3D/trigger.cpp
+++ b/Engine/source/T3D/trigger.cpp
@@ -731,7 +731,8 @@ void Trigger::potentialEnterObject(GameBase* enter)
 
       if(evalCmD(&mEnterCommand))
       {
-         String command = String("%obj = ") + enter->getIdString() + ";" + mEnterCommand;
+         String command = String("%obj = ") + enter->getIdString() + ";";
+         command = command + String("%this = ") + getIdString() + ";" + mEnterCommand;
          Con::evaluate(command.c_str());
       }
 
@@ -779,7 +780,8 @@ void Trigger::processTick(const Move* move)
             
             if (evalCmD(&mLeaveCommand))
             {
-               String command = String("%obj = ") + remove->getIdString() + ";" + mLeaveCommand;
+               String command = String("%obj = ") + remove->getIdString() + ";";
+               command = command + String("%this = ") + getIdString() + ";" + mLeaveCommand;
                Con::evaluate(command.c_str());
             }
             if (testTrippable() && testCondition())

From a8116bbaf5abac5e2181af8026fddba7debc58c6 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Mon, 8 Nov 2021 15:31:07 -0500
Subject: [PATCH 241/399] * [AssetImporter] BugFix: Correct ASAN reported out
 of bounds reads in the asset import programming.

---
 Engine/source/T3D/assets/assetImporter.cpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/Engine/source/T3D/assets/assetImporter.cpp b/Engine/source/T3D/assets/assetImporter.cpp
index 65c18d664..c168e77f0 100644
--- a/Engine/source/T3D/assets/assetImporter.cpp
+++ b/Engine/source/T3D/assets/assetImporter.cpp
@@ -721,27 +721,27 @@ String AssetImporter::parseImageSuffixes(String assetName, String* suffixType)
       {
          case 0:
             suffixList = activeImportConfig->DiffuseTypeSuffixes;
-            suffixType->insert(0, "Albedo", 10);
+            suffixType->insert(0, "Albedo", 6);
             break;
          case 1:
             suffixList = activeImportConfig->NormalTypeSuffixes;
-            suffixType->insert(0, "Normal", 10);
+            suffixType->insert(0, "Normal", 6);
             break;
          case 2:
             suffixList = activeImportConfig->RoughnessTypeSuffixes;
-            suffixType->insert(0, "Roughness", 10);
+            suffixType->insert(0, "Roughness", 9);
             break;
          case 3:
             suffixList = activeImportConfig->AOTypeSuffixes;
-            suffixType->insert(0, "AO", 10);
+            suffixType->insert(0, "AO", 2);
             break;
          case 4:
             suffixList = activeImportConfig->MetalnessTypeSuffixes;
-            suffixType->insert(0, "Metalness", 10);
+            suffixType->insert(0, "Metalness", 9);
             break;
          case 5:
             suffixList = activeImportConfig->PBRTypeSuffixes;
-            suffixType->insert(0, "ORMConfig", 10);
+            suffixType->insert(0, "ORMConfig", 9);
             break;
          default:
             suffixList = "";

From 8fa652a3278eae91471d7b525e9c9a364935c3b7 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Mon, 8 Nov 2021 16:07:44 -0600
Subject: [PATCH 242/399] by request, changed fspin and the new "rotation"  for
 bitmap gui elements to a more generic "angle" to preserve thedistinction
 between rotating a gui and rotating a 3d object.

---
 Engine/source/gfx/gfxDrawUtil.cpp            | 34 ++++++++++----------
 Engine/source/gfx/gfxDrawUtil.h              | 16 ++++-----
 Engine/source/gui/controls/guiBitmapCtrl.cpp |  8 ++---
 Engine/source/gui/controls/guiBitmapCtrl.h   |  2 +-
 4 files changed, 30 insertions(+), 30 deletions(-)

diff --git a/Engine/source/gfx/gfxDrawUtil.cpp b/Engine/source/gfx/gfxDrawUtil.cpp
index a806bef80..1dd9f5fca 100644
--- a/Engine/source/gfx/gfxDrawUtil.cpp
+++ b/Engine/source/gfx/gfxDrawUtil.cpp
@@ -303,54 +303,54 @@ U32 GFXDrawUtil::drawTextN( GFont *font, const Point2F &ptDraw, const UTF16 *in_
 //-----------------------------------------------------------------------------
 // Draw Bitmaps
 //-----------------------------------------------------------------------------
-void GFXDrawUtil::drawBitmap( GFXTextureObject* texture, const Point2I &in_rAt, const GFXBitmapFlip in_flip, const GFXTextureFilterType filter , bool in_wrap /*= true*/, F32 fSpin)
+void GFXDrawUtil::drawBitmap( GFXTextureObject* texture, const Point2I &in_rAt, const GFXBitmapFlip in_flip, const GFXTextureFilterType filter , bool in_wrap /*= true*/, F32 angle)
 {
-   drawBitmap(texture,Point2F((F32)in_rAt.x,(F32)in_rAt.y),in_flip,filter,in_wrap, fSpin);
+   drawBitmap(texture,Point2F((F32)in_rAt.x,(F32)in_rAt.y),in_flip,filter,in_wrap, angle);
 }
 
-void GFXDrawUtil::drawBitmapStretch( GFXTextureObject* texture, const RectI &dstRect, const GFXBitmapFlip in_flip, const GFXTextureFilterType filter , bool in_wrap /*= true*/, F32 fSpin)
+void GFXDrawUtil::drawBitmapStretch( GFXTextureObject* texture, const RectI &dstRect, const GFXBitmapFlip in_flip, const GFXTextureFilterType filter , bool in_wrap /*= true*/, F32 angle)
 {
-   drawBitmapStretch(texture,RectF((F32)dstRect.point.x,(F32)dstRect.point.y,(F32)dstRect.extent.x,(F32)dstRect.extent.y),in_flip,filter,in_wrap, fSpin);
+   drawBitmapStretch(texture,RectF((F32)dstRect.point.x,(F32)dstRect.point.y,(F32)dstRect.extent.x,(F32)dstRect.extent.y),in_flip,filter,in_wrap, angle);
 }
 
-void GFXDrawUtil::drawBitmapSR( GFXTextureObject* texture, const Point2I &in_rAt, const RectI &srcRect, const GFXBitmapFlip in_flip, const GFXTextureFilterType filter , bool in_wrap /*= true*/, F32 fSpin)
+void GFXDrawUtil::drawBitmapSR( GFXTextureObject* texture, const Point2I &in_rAt, const RectI &srcRect, const GFXBitmapFlip in_flip, const GFXTextureFilterType filter , bool in_wrap /*= true*/, F32 angle)
 {
-   drawBitmapSR(texture,Point2F((F32)in_rAt.x,(F32)in_rAt.y),RectF((F32)srcRect.point.x,(F32)srcRect.point.y,(F32)srcRect.extent.x,(F32)srcRect.extent.y),in_flip,filter,in_wrap, fSpin);
+   drawBitmapSR(texture,Point2F((F32)in_rAt.x,(F32)in_rAt.y),RectF((F32)srcRect.point.x,(F32)srcRect.point.y,(F32)srcRect.extent.x,(F32)srcRect.extent.y),in_flip,filter,in_wrap, angle);
 }
 
-void GFXDrawUtil::drawBitmapStretchSR( GFXTextureObject *texture, const RectI &dstRect, const RectI &srcRect, const GFXBitmapFlip in_flip, const GFXTextureFilterType filter , bool in_wrap /*= true*/, F32 fSpin)
+void GFXDrawUtil::drawBitmapStretchSR( GFXTextureObject *texture, const RectI &dstRect, const RectI &srcRect, const GFXBitmapFlip in_flip, const GFXTextureFilterType filter , bool in_wrap /*= true*/, F32 angle)
 {
    RectF dstRectF = RectF((F32)dstRect.point.x,(F32)dstRect.point.y,(F32)dstRect.extent.x,(F32)dstRect.extent.y);
    RectF srcRectF = RectF((F32)srcRect.point.x,(F32)srcRect.point.y,(F32)srcRect.extent.x,(F32)srcRect.extent.y);
-   drawBitmapStretchSR(texture,dstRectF,srcRectF,in_flip,filter,in_wrap, fSpin);
+   drawBitmapStretchSR(texture,dstRectF,srcRectF,in_flip,filter,in_wrap, angle);
 }
 
-void GFXDrawUtil::drawBitmap( GFXTextureObject*texture, const Point2F &in_rAt, const GFXBitmapFlip in_flip /*= GFXBitmapFlip_None*/, const GFXTextureFilterType filter /*= GFXTextureFilterPoint */ , bool in_wrap /*= true*/, F32 fSpin)
+void GFXDrawUtil::drawBitmap( GFXTextureObject*texture, const Point2F &in_rAt, const GFXBitmapFlip in_flip /*= GFXBitmapFlip_None*/, const GFXTextureFilterType filter /*= GFXTextureFilterPoint */ , bool in_wrap /*= true*/, F32 angle)
 {
    AssertFatal( texture != 0, "No texture specified for drawBitmap()" );
 
    RectI subRegion( 0, 0, texture->mBitmapSize.x, texture->mBitmapSize.y );
    RectI stretch( in_rAt.x, in_rAt.y, texture->mBitmapSize.x, texture->mBitmapSize.y );
-   drawBitmapStretchSR( texture, stretch, subRegion, in_flip, filter, in_wrap, fSpin);
+   drawBitmapStretchSR( texture, stretch, subRegion, in_flip, filter, in_wrap, angle);
 }
 
-void GFXDrawUtil::drawBitmapStretch( GFXTextureObject*texture, const RectF &dstRect, const GFXBitmapFlip in_flip /*= GFXBitmapFlip_None*/, const GFXTextureFilterType filter /*= GFXTextureFilterPoint */ , bool in_wrap /*= true*/, F32 fSpin)
+void GFXDrawUtil::drawBitmapStretch( GFXTextureObject*texture, const RectF &dstRect, const GFXBitmapFlip in_flip /*= GFXBitmapFlip_None*/, const GFXTextureFilterType filter /*= GFXTextureFilterPoint */ , bool in_wrap /*= true*/, F32 angle)
 {
    AssertFatal( texture != 0, "No texture specified for drawBitmapStretch()" );
 
    RectF subRegion( 0.f, 0.f, (F32)texture->mBitmapSize.x, (F32)texture->mBitmapSize.y );
-   drawBitmapStretchSR( texture, dstRect, subRegion, in_flip, filter, in_wrap, fSpin);
+   drawBitmapStretchSR( texture, dstRect, subRegion, in_flip, filter, in_wrap, angle);
 }
 
-void GFXDrawUtil::drawBitmapSR( GFXTextureObject*texture, const Point2F &in_rAt, const RectF &srcRect, const GFXBitmapFlip in_flip /*= GFXBitmapFlip_None*/, const GFXTextureFilterType filter /*= GFXTextureFilterPoint */ , bool in_wrap /*= true*/, F32 fSpin)
+void GFXDrawUtil::drawBitmapSR( GFXTextureObject*texture, const Point2F &in_rAt, const RectF &srcRect, const GFXBitmapFlip in_flip /*= GFXBitmapFlip_None*/, const GFXTextureFilterType filter /*= GFXTextureFilterPoint */ , bool in_wrap /*= true*/, F32 angle)
 {
    AssertFatal( texture != 0, "No texture specified for drawBitmapSR()" );
 
    RectF stretch( in_rAt.x, in_rAt.y, srcRect.len_x(), srcRect.len_y() );
-   drawBitmapStretchSR( texture, stretch, srcRect, in_flip, filter, in_wrap, fSpin);
+   drawBitmapStretchSR( texture, stretch, srcRect, in_flip, filter, in_wrap, angle);
 }
 
-void GFXDrawUtil::drawBitmapStretchSR( GFXTextureObject* texture, const RectF &dstRect, const RectF &srcRect, const GFXBitmapFlip in_flip /*= GFXBitmapFlip_None*/, const GFXTextureFilterType filter /*= GFXTextureFilterPoint */ , bool in_wrap /*= true*/, F32 fSpin)
+void GFXDrawUtil::drawBitmapStretchSR( GFXTextureObject* texture, const RectF &dstRect, const RectF &srcRect, const GFXBitmapFlip in_flip /*= GFXBitmapFlip_None*/, const GFXTextureFilterType filter /*= GFXTextureFilterPoint */ , bool in_wrap /*= true*/, F32 angle)
 {
    // Sanity if no texture is specified.
    if(!texture)
@@ -395,7 +395,7 @@ void GFXDrawUtil::drawBitmapStretchSR( GFXTextureObject* texture, const RectF &d
    verts[2].texCoord.set( texLeft,  texBottom );
    verts[3].texCoord.set( texRight, texBottom );
 
-   if (fSpin != 0.0f)
+   if (angle != 0.0f)
    {
       U32 i = 0;
       Point3F points[4];
@@ -410,7 +410,7 @@ void GFXDrawUtil::drawBitmapStretchSR( GFXTextureObject* texture, const RectF &d
          dstRect.point.y + dstRect.extent.y / 2.0f, 0.0);
 
       //rotate points by mulitplying by a rotation matrix
-      MatrixF rotMatrix(EulerF(0.0, 0.0, mDegToRad(fSpin)));
+      MatrixF rotMatrix(EulerF(0.0, 0.0, mDegToRad(angle)));
       for (i = 0; i < 4; i++)
       {
          rotMatrix.mulP(points[i]);
diff --git a/Engine/source/gfx/gfxDrawUtil.h b/Engine/source/gfx/gfxDrawUtil.h
index a60c81624..7c74e1d9d 100644
--- a/Engine/source/gfx/gfxDrawUtil.h
+++ b/Engine/source/gfx/gfxDrawUtil.h
@@ -93,15 +93,15 @@ public:
    //-----------------------------------------------------------------------------
    // Draw Bitmaps
    //-----------------------------------------------------------------------------  
-   void drawBitmap( GFXTextureObject*texture, const Point2F &in_rAt, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true, F32 fSpin = 0.0f);
-   void drawBitmapSR( GFXTextureObject*texture, const Point2F &in_rAt, const RectF &srcRect, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true, F32 fSpin = 0.0f);
-   void drawBitmapStretch( GFXTextureObject*texture, const RectF &dstRect, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true, F32 fSpin = 0.0f);
-   void drawBitmapStretchSR( GFXTextureObject*texture, const RectF &dstRect, const RectF &srcRect, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true, F32 fSpin = 0.0f);
+   void drawBitmap( GFXTextureObject*texture, const Point2F &in_rAt, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true, F32 angle = 0.0f);
+   void drawBitmapSR( GFXTextureObject*texture, const Point2F &in_rAt, const RectF &srcRect, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true, F32 angle = 0.0f);
+   void drawBitmapStretch( GFXTextureObject*texture, const RectF &dstRect, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true, F32 angle = 0.0f);
+   void drawBitmapStretchSR( GFXTextureObject*texture, const RectF &dstRect, const RectF &srcRect, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true, F32 angle = 0.0f);
 
-   void drawBitmap( GFXTextureObject*texture, const Point2I &in_rAt, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true, F32 fSpin = 0.0f);
-   void drawBitmapSR( GFXTextureObject*texture, const Point2I &in_rAt, const RectI &srcRect, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true, F32 fSpin = 0.0f);
-   void drawBitmapStretch( GFXTextureObject*texture, const RectI &dstRect, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true, F32 fSpin = 0.0f);
-   void drawBitmapStretchSR( GFXTextureObject*texture, const RectI &dstRect, const RectI &srcRect, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true, F32 fSpin = 0.0f);
+   void drawBitmap( GFXTextureObject*texture, const Point2I &in_rAt, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true, F32 angle = 0.0f);
+   void drawBitmapSR( GFXTextureObject*texture, const Point2I &in_rAt, const RectI &srcRect, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true, F32 angle = 0.0f);
+   void drawBitmapStretch( GFXTextureObject*texture, const RectI &dstRect, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true, F32 angle = 0.0f);
+   void drawBitmapStretchSR( GFXTextureObject*texture, const RectI &dstRect, const RectI &srcRect, const GFXBitmapFlip in_flip = GFXBitmapFlip_None, const GFXTextureFilterType filter = GFXTextureFilterPoint , bool in_wrap = true, F32 angle = 0.0f);
 
    //-----------------------------------------------------------------------------
    // Draw 3D Shapes
diff --git a/Engine/source/gui/controls/guiBitmapCtrl.cpp b/Engine/source/gui/controls/guiBitmapCtrl.cpp
index ecbe288f7..82a106bcf 100644
--- a/Engine/source/gui/controls/guiBitmapCtrl.cpp
+++ b/Engine/source/gui/controls/guiBitmapCtrl.cpp
@@ -58,7 +58,7 @@ ConsoleDocClass( GuiBitmapCtrl,
 GuiBitmapCtrl::GuiBitmapCtrl(void)
  : mStartPoint( 0, 0 ),
    mColor(ColorI::WHITE),
-   mRotation(0),
+   mAngle(0),
    mWrap( false )
 {
    INIT_ASSET(Bitmap);
@@ -85,7 +85,7 @@ void GuiBitmapCtrl::initPersistFields()
       addField( "wrap",   TypeBool,     Offset( mWrap, GuiBitmapCtrl ),
          "If true, the bitmap is tiled inside the control rather than stretched to fit." );
 
-      addField("rotation", TypeF32, Offset(mRotation, GuiBitmapCtrl), "rotation");
+      addField("angle", TypeF32, Offset(mAngle, GuiBitmapCtrl), "rotation");
       
    endGroup( "Bitmap" );
 
@@ -190,14 +190,14 @@ void GuiBitmapCtrl::onRender(Point2I offset, const RectI &updateRect)
 								      ((texture->mBitmapSize.y*y)+offset.y)-yshift,
 								      texture->mBitmapSize.x,
 								      texture->mBitmapSize.y);
-               GFX->getDrawUtil()->drawBitmapStretchSR(texture, dstRegion, srcRegion, GFXBitmapFlip_None, GFXTextureFilterLinear, mRotation);
+               GFX->getDrawUtil()->drawBitmapStretchSR(texture, dstRegion, srcRegion, GFXBitmapFlip_None, GFXTextureFilterLinear, mAngle);
 				}
 
 		}
 		else
       {
          RectI rect(offset, getExtent());
-         GFX->getDrawUtil()->drawBitmapStretch(mBitmap, rect, GFXBitmapFlip_None, GFXTextureFilterLinear, false, mRotation);
+         GFX->getDrawUtil()->drawBitmapStretch(mBitmap, rect, GFXBitmapFlip_None, GFXTextureFilterLinear, false, mAngle);
       }
    }
 
diff --git a/Engine/source/gui/controls/guiBitmapCtrl.h b/Engine/source/gui/controls/guiBitmapCtrl.h
index 42e3c8a8f..44a6a18ed 100644
--- a/Engine/source/gui/controls/guiBitmapCtrl.h
+++ b/Engine/source/gui/controls/guiBitmapCtrl.h
@@ -44,7 +44,7 @@ class GuiBitmapCtrl : public GuiControl
             
       Point2I mStartPoint;
       ColorI   mColor;
-      F32     mRotation;
+      F32     mAngle;
 
       /// If true, bitmap tiles inside control.  Otherwise stretches.
       bool mWrap;

From f9496559c9ed98e7515b4320ce75a33dc2e4c46f Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Tue, 9 Nov 2021 01:05:42 -0600
Subject: [PATCH 243/399] fix fbx importer lookup for setting formatScaleFactor

---
 Engine/source/ts/assimp/assimpShapeLoader.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Engine/source/ts/assimp/assimpShapeLoader.cpp b/Engine/source/ts/assimp/assimpShapeLoader.cpp
index 6659f1092..d1b201ecd 100644
--- a/Engine/source/ts/assimp/assimpShapeLoader.cpp
+++ b/Engine/source/ts/assimp/assimpShapeLoader.cpp
@@ -177,11 +177,11 @@ void AssimpShapeLoader::enumerateScene()
 
       // Setup default units for shape format
       String importFormat;
-      if (getMetaString("SourceAsset_Format", importFormat))
+
+      const aiImporterDesc* importerDescription = aiGetImporterDesc(shapePath.getExtension().c_str());
+      if (importerDescription->mName == "Autodesk FBX Importer")
       {
-         // FBX uses cm as standard unit, so convert to meters
-         if (importFormat.equal("Autodesk FBX Importer", String::NoCase))
-            ColladaUtils::getOptions().formatScaleFactor = 0.01f;
+         ColladaUtils::getOptions().formatScaleFactor = 0.01f;
       }
 
       // Set import options (if they are not set to override)

From 227b1e3f51a8906b82b029ebadea7dfd55672a7e Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Wed, 10 Nov 2021 19:20:03 -0500
Subject: [PATCH 244/399] * Feature: Implement a TurretObjectType bit for
 typemasks.

---
 Engine/source/T3D/gameFunctions.cpp      | 1 +
 Engine/source/T3D/objectTypes.h          | 4 ++++
 Engine/source/T3D/turret/turretShape.cpp | 2 +-
 3 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/Engine/source/T3D/gameFunctions.cpp b/Engine/source/T3D/gameFunctions.cpp
index aa6ea80e3..9535496f5 100644
--- a/Engine/source/T3D/gameFunctions.cpp
+++ b/Engine/source/T3D/gameFunctions.cpp
@@ -668,6 +668,7 @@ static void RegisterGameFunctions()
 // PATHSHAPE
    Con::setIntVariable("$TypeMasks::PathShapeObjectType",     PathShapeObjectType);
 // PATHSHAPE END
+   Con::setIntVariable("$TypeMasks::TurretObjectType", TurretObjectType);
 
    Con::addVariable("Ease::InOut", TypeS32, &gEaseInOut, 
       "InOut ease for curve movement.\n"
diff --git a/Engine/source/T3D/objectTypes.h b/Engine/source/T3D/objectTypes.h
index 063bec7e5..9044205cd 100644
--- a/Engine/source/T3D/objectTypes.h
+++ b/Engine/source/T3D/objectTypes.h
@@ -167,6 +167,10 @@ enum SceneObjectTypes
    PathShapeObjectType = BIT( 28 ),
    // PATHSHAPE END
 
+   /// A turret object.
+   /// @see TurretShape
+   TurretObjectType = BIT(29),
+
    /// @}
 };
 
diff --git a/Engine/source/T3D/turret/turretShape.cpp b/Engine/source/T3D/turret/turretShape.cpp
index 80bdd1d03..17fef5176 100644
--- a/Engine/source/T3D/turret/turretShape.cpp
+++ b/Engine/source/T3D/turret/turretShape.cpp
@@ -257,7 +257,7 @@ ConsoleDocClass( TurretShape,
 
 TurretShape::TurretShape()
 {
-   mTypeMask |= VehicleObjectType | DynamicShapeObjectType;
+   mTypeMask |= VehicleObjectType | DynamicShapeObjectType | TurretObjectType;
    mDataBlock = 0;
 
    allowManualRotation = true;

From 2b15c9e89db3f99833c24206d3336f4ded01f162 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Thu, 11 Nov 2021 16:41:28 -0500
Subject: [PATCH 245/399] * BugFix: Correct the vehicle types double-tapping
 their onAdd and onRemove callbacks - rigidShape handles dispatching the
 script callbacks.

---
 Engine/source/T3D/vehicles/flyingVehicle.cpp  | 4 ----
 Engine/source/T3D/vehicles/hoverVehicle.cpp   | 5 -----
 Engine/source/T3D/vehicles/wheeledVehicle.cpp | 3 ---
 3 files changed, 12 deletions(-)

diff --git a/Engine/source/T3D/vehicles/flyingVehicle.cpp b/Engine/source/T3D/vehicles/flyingVehicle.cpp
index 8426da2c3..255dbc571 100644
--- a/Engine/source/T3D/vehicles/flyingVehicle.cpp
+++ b/Engine/source/T3D/vehicles/flyingVehicle.cpp
@@ -348,9 +348,6 @@ bool FlyingVehicle::onAdd()
       return false;
 
    addToScene();
-
-   if (isServerObject())
-      scriptOnAdd();
    return true;
 }
 
@@ -400,7 +397,6 @@ void FlyingVehicle::onRemove()
    SFX_DELETE( mJetSound );
    SFX_DELETE( mEngineSound );
 
-   scriptOnRemove();
    removeFromScene();
    Parent::onRemove();
 }
diff --git a/Engine/source/T3D/vehicles/hoverVehicle.cpp b/Engine/source/T3D/vehicles/hoverVehicle.cpp
index dbaee9993..cdb080c93 100644
--- a/Engine/source/T3D/vehicles/hoverVehicle.cpp
+++ b/Engine/source/T3D/vehicles/hoverVehicle.cpp
@@ -512,10 +512,6 @@ bool HoverVehicle::onAdd()
       }
    }
 
-
-   if (isServerObject())
-      scriptOnAdd();
-
    return true;
 }
 
@@ -526,7 +522,6 @@ void HoverVehicle::onRemove()
    SFX_DELETE( mEngineSound );
    SFX_DELETE( mFloatSound );
 
-   scriptOnRemove();
    removeFromScene();
    Parent::onRemove();
 }
diff --git a/Engine/source/T3D/vehicles/wheeledVehicle.cpp b/Engine/source/T3D/vehicles/wheeledVehicle.cpp
index 258222847..9dd949bf3 100644
--- a/Engine/source/T3D/vehicles/wheeledVehicle.cpp
+++ b/Engine/source/T3D/vehicles/wheeledVehicle.cpp
@@ -565,8 +565,6 @@ bool WheeledVehicle::onAdd()
       return false;
 
    addToScene();
-   if (isServerObject())
-      scriptOnAdd();
    return true;
 }
 
@@ -588,7 +586,6 @@ void WheeledVehicle::onRemove()
    SFX_DELETE( mSquealSound );
 
    //
-   scriptOnRemove();
    removeFromScene();
    Parent::onRemove();
 }

From 949813956db91966baedb60aff9ef79a71b70f42 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Thu, 11 Nov 2021 22:56:48 -0500
Subject: [PATCH 246/399] Add Object Inheritence Acceptance Test

---
 Engine/source/console/test/ScriptTest.cpp | 40 ++++++++++++++++++++++-
 1 file changed, 39 insertions(+), 1 deletion(-)

diff --git a/Engine/source/console/test/ScriptTest.cpp b/Engine/source/console/test/ScriptTest.cpp
index 05f0582ff..8bfbbfbab 100644
--- a/Engine/source/console/test/ScriptTest.cpp
+++ b/Engine/source/console/test/ScriptTest.cpp
@@ -542,7 +542,7 @@ TEST(Script, TorqueScript_Array_Testing)
    ASSERT_EQ(value2.getInt(), 2);
 }
 
-TEST(Script, Basic_SimObject)
+TEST(Script, SimObject_Tests)
 {
    ConsoleValue object = RunScript(R"(
          return new SimObject(FudgeCollector)
@@ -657,6 +657,44 @@ TEST(Script, Basic_SimObject)
    )");
 
    ASSERT_EQ(fieldOpTest.getInt(), 3);
+
+   ConsoleValue inheritedObjectTest = RunScript(R"(
+      function SimObject::testClass(%this)
+      {
+         return 4;
+      }
+
+      function SuperFooBar::doSuperTest(%this)
+      {
+         return 5;
+      }
+
+      function FooBar::test(%this)
+      {
+         return 2;
+      }
+
+      new SimObject(GrandFooBar)
+      {
+         superClass = "SuperFooBar";
+      };
+
+      new SimObject(Foo : GrandFooBar)
+      {
+         class = "FooBar";
+      };
+
+      new SimObject(Bar : Foo);
+
+      function Bar::doTheAddition(%this)
+      {
+         return %this.testClass() + %this.test() + %this.doSuperTest(); 
+      }
+
+      return Bar.doTheAddition();
+   )");
+
+   ASSERT_EQ(inheritedObjectTest.getInt(), 11);
 }
 
 TEST(Script, Internal_Name)

From b60d51969e2e1dec9c06a2b3bd50625e934498c2 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Sat, 13 Nov 2021 19:05:26 -0600
Subject: [PATCH 247/399] brdf handling corrections 1-handle the brdfTexture in
 linear space, not srgb. 2-clamp surface.NoV across the board for consistency.
 (solves several new and ongoing artifacts)

---
 Engine/source/renderInstance/renderProbeMgr.cpp            | 2 +-
 .../BaseGame/game/core/rendering/shaders/gl/lighting.glsl  | 2 +-
 .../BaseGame/game/core/rendering/shaders/lighting.hlsl     | 7 +++----
 .../lighting/advanced/gl/reflectionProbeArrayP.glsl        | 5 ++---
 .../shaders/lighting/advanced/reflectionProbeArrayP.hlsl   | 3 +--
 5 files changed, 8 insertions(+), 11 deletions(-)

diff --git a/Engine/source/renderInstance/renderProbeMgr.cpp b/Engine/source/renderInstance/renderProbeMgr.cpp
index d39048971..bfbf65815 100644
--- a/Engine/source/renderInstance/renderProbeMgr.cpp
+++ b/Engine/source/renderInstance/renderProbeMgr.cpp
@@ -290,7 +290,7 @@ bool RenderProbeMgr::onAdd()
    }
 
    String brdfTexturePath = GFXTextureManager::getBRDFTexturePath();
-   if (!mBRDFTexture.set(brdfTexturePath, &GFXTexturePersistentSRGBProfile, "BRDFTexture"))
+   if (!mBRDFTexture.set(brdfTexturePath, &GFXTexturePersistentProfile, "BRDFTexture"))
    {
       Con::errorf("RenderProbeMgr::onAdd: Failed to load BRDF Texture");
       return false;
diff --git a/Templates/BaseGame/game/core/rendering/shaders/gl/lighting.glsl b/Templates/BaseGame/game/core/rendering/shaders/gl/lighting.glsl
index ab35bc103..a26b5aa7f 100644
--- a/Templates/BaseGame/game/core/rendering/shaders/gl/lighting.glsl
+++ b/Templates/BaseGame/game/core/rendering/shaders/gl/lighting.glsl
@@ -106,7 +106,7 @@ struct Surface
 
 void updateSurface(inout Surface surface)
 {
-	surface.NdotV = abs(dot(surface.N, surface.V)) + 1e-5f; // avoid artifact
+	surface.NdotV = clamp( dot(surface.N, surface.V), 0.0009765625f,0.9990234375f);  //0.5f/512.0f (512 is size of dfg/brdf lookup tex)
 
     surface.linearRoughness = surface.roughness * surface.roughness;
     surface.linearRoughnessSq = surface.linearRoughness * surface.linearRoughness;
diff --git a/Templates/BaseGame/game/core/rendering/shaders/lighting.hlsl b/Templates/BaseGame/game/core/rendering/shaders/lighting.hlsl
index fd053b60e..13871f1cf 100644
--- a/Templates/BaseGame/game/core/rendering/shaders/lighting.hlsl
+++ b/Templates/BaseGame/game/core/rendering/shaders/lighting.hlsl
@@ -105,10 +105,9 @@ struct Surface
 
 	inline void Update()
 	{
-		NdotV = abs(dot(N, V)) + 1e-5f; // avoid artifact
-   
-      linearRoughness = roughness * roughness;
-      linearRoughnessSq = linearRoughness * linearRoughness;
+		NdotV = clamp( dot(N, V), 0.0009765625f,0.9990234375f); // avoid artifact
+        linearRoughness = roughness * roughness;
+        linearRoughnessSq = linearRoughness * linearRoughness;
 
 		albedo = baseColor.rgb * (1.0f - metalness);
 		f0 = lerp(0.04f, baseColor.rgb, metalness);
diff --git a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/reflectionProbeArrayP.glsl b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/reflectionProbeArrayP.glsl
index c5ffd6f67..8efe15c05 100644
--- a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/reflectionProbeArrayP.glsl
+++ b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/reflectionProbeArrayP.glsl
@@ -202,14 +202,13 @@ void main()
    return;
 #endif
 
-
+   
    //energy conservation
    vec3 F = FresnelSchlickRoughness(surface.NdotV, surface.f0, surface.roughness);
    vec3 kD = 1.0f - F;
    kD *= 1.0f - surface.metalness;
 
-   float dfgNdotV = max( surface.NdotV , 0.0009765625f ); //0.5f/512.0f (512 is size of dfg/brdf lookup tex)
-   vec2 envBRDF = textureLod(BRDFTexture, vec2(dfgNdotV, surface.roughness),0).rg;
+   vec2 envBRDF = textureLod(BRDFTexture, vec2(surface.NdotV, surface.roughness),0).rg;
    specular *= F * envBRDF.x + surface.f90 * envBRDF.y;
    irradiance *= kD * surface.baseColor.rgb;
 
diff --git a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/reflectionProbeArrayP.hlsl b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/reflectionProbeArrayP.hlsl
index aaff0145b..cff06decf 100644
--- a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/reflectionProbeArrayP.hlsl
+++ b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/reflectionProbeArrayP.hlsl
@@ -197,8 +197,7 @@ float4 main(PFXVertToPix IN) : SV_TARGET
    float3 kD = 1.0f - F;
    kD *= 1.0f - surface.metalness;
 
-   float dfgNdotV = max( surface.NdotV , 0.0009765625f ); //0.5f/512.0f (512 is size of dfg/brdf lookup tex)
-   float2 envBRDF = TORQUE_TEX2DLOD(BRDFTexture, float4(dfgNdotV, surface.roughness,0,0)).rg;
+   float2 envBRDF = TORQUE_TEX2DLOD(BRDFTexture, float4(surface.NdotV, surface.roughness,0,0)).rg;
    specular *= F * envBRDF.x + surface.f90 * envBRDF.y;
    irradiance *= kD * surface.baseColor.rgb;
 

From 72ef719c18e8346b3f181d59643fc5ae7baec9c4 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Sat, 13 Nov 2021 19:18:03 -0600
Subject: [PATCH 248/399] kill redundant clamp in forward

---
 .../BaseGame/game/core/rendering/shaders/gl/lighting.glsl      | 3 +--
 Templates/BaseGame/game/core/rendering/shaders/lighting.hlsl   | 3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/Templates/BaseGame/game/core/rendering/shaders/gl/lighting.glsl b/Templates/BaseGame/game/core/rendering/shaders/gl/lighting.glsl
index a26b5aa7f..55d9866ce 100644
--- a/Templates/BaseGame/game/core/rendering/shaders/gl/lighting.glsl
+++ b/Templates/BaseGame/game/core/rendering/shaders/gl/lighting.glsl
@@ -650,8 +650,7 @@ vec4 debugVizForwardProbes(Surface surface,
    vec3 kD = 1.0f - F;
    kD *= 1.0f - surface.metalness;
 
-   float dfgNdotV = max( surface.NdotV , 0.0009765625f ); //0.5f/512.0f (512 is size of dfg/brdf lookup tex)
-   vec2 envBRDF = textureLod(BRDFTexture, vec2(dfgNdotV, surface.roughness),0).rg;
+   vec2 envBRDF = textureLod(BRDFTexture, vec2(surface.NdotV, surface.roughness),0).rg;
    specular *= F * envBRDF.x + surface.f90 * envBRDF.y;
    irradiance *= kD * surface.baseColor.rgb;
 
diff --git a/Templates/BaseGame/game/core/rendering/shaders/lighting.hlsl b/Templates/BaseGame/game/core/rendering/shaders/lighting.hlsl
index 13871f1cf..c91bd21a1 100644
--- a/Templates/BaseGame/game/core/rendering/shaders/lighting.hlsl
+++ b/Templates/BaseGame/game/core/rendering/shaders/lighting.hlsl
@@ -653,8 +653,7 @@ float4 debugVizForwardProbes(Surface surface,
    float3 kD = 1.0f - F;
    kD *= 1.0f - surface.metalness;
 
-   float dfgNdotV = max( surface.NdotV , 0.0009765625f ); //0.5f/512.0f (512 is size of dfg/brdf lookup tex)
-   float2 envBRDF = TORQUE_TEX2DLOD(BRDFTexture, float4(dfgNdotV, surface.roughness,0,0)).rg;
+   float2 envBRDF = TORQUE_TEX2DLOD(BRDFTexture, float4(surface.NdotV, surface.roughness,0,0)).rg;
    specular *= F * envBRDF.x + surface.f90 * envBRDF.y;
    irradiance *= kD * surface.baseColor.rgb;
 

From 97484247ae5c3e7ecb21c2b9abce4f5b0bb2d5ae Mon Sep 17 00:00:00 2001
From: Areloch <Areloch@gmail.com>
Date: Sun, 14 Nov 2021 01:26:04 -0600
Subject: [PATCH 249/399] Fixes Settings window not being able to be brought
 forward over AB Adds checkbox to mark as not showing Import Window each time
 Added loaded import config to import log output Fixed targeted material map
 slot field names Added helper function for playing a sound asset via AssetId
 Updated import config to have some more common suffixes Updated editor
 settings to have Import Window show by default Changed AB context menu from
 listing item as "Refresh Asset" to "Reload Asset" for improved clarity
 Removed unneeded duplicate editor settings window script file

---
 Engine/source/T3D/assets/assetImporter.cpp    |  11 +-
 Engine/source/T3D/assets/assetImporter.h      |  10 +-
 .../utility/scripts/helperFunctions.tscript   |  10 ++
 .../tools/assetBrowser/assetImportConfigs.xml |  12 +-
 .../assetBrowser/scripts/assetImport.tscript  |  15 +-
 .../scripts/assetImportConfig.tscript         |   4 +-
 .../assetBrowser/scripts/popupMenus.tscript   |   4 +-
 .../tools/gui/editorSettingsWindow.ed.tscript |  13 +-
 Templates/BaseGame/game/tools/settings.xml    |   2 +-
 .../worldEditor/scripts/EditorGui.ed.tscript  |   2 -
 .../scripts/editorSettingsWindow.ed.tscript   | 142 ------------------
 11 files changed, 56 insertions(+), 169 deletions(-)
 delete mode 100644 Templates/BaseGame/game/tools/worldEditor/scripts/editorSettingsWindow.ed.tscript

diff --git a/Engine/source/T3D/assets/assetImporter.cpp b/Engine/source/T3D/assets/assetImporter.cpp
index e4ca498eb..2ceb677af 100644
--- a/Engine/source/T3D/assets/assetImporter.cpp
+++ b/Engine/source/T3D/assets/assetImporter.cpp
@@ -2381,6 +2381,9 @@ void AssetImporter::resetImportConfig()
       Settings* importConfigs;
       if (Sim::findObject("AssetImportSettings", importConfigs))
       {
+         dSprintf(importLogBuffer, sizeof(importLogBuffer), "Loading import config: %s!", defaultImportConfig.c_str());
+         activityLog.push_back(importLogBuffer);
+
          //Now load the editor setting-deigned config!
          activeImportConfig->loadImportConfig(importConfigs, defaultImportConfig.c_str());
       }
@@ -2798,7 +2801,7 @@ Torque::Path AssetImporter::importMaterialAsset(AssetImportObject* assetItem)
                }
                else if (imageType == ImageAsset::ImageTypes::Metalness)
                {
-                  mapFieldName = "MetalnessMap";
+                  mapFieldName = "MetalMap";
                }
                else if (imageType == ImageAsset::ImageTypes::AO)
                {
@@ -2806,7 +2809,7 @@ Torque::Path AssetImporter::importMaterialAsset(AssetImportObject* assetItem)
                }
                else if (imageType == ImageAsset::ImageTypes::Roughness)
                {
-                  mapFieldName = "RoughnessMap";
+                  mapFieldName = "RoughMap";
                }
 
                assetFieldName = mapFieldName + "Asset[0]";
@@ -2874,7 +2877,7 @@ Torque::Path AssetImporter::importMaterialAsset(AssetImportObject* assetItem)
          }
          else if (imageType == ImageAsset::ImageTypes::Metalness)
          {
-            mapFieldName = "MetalnessMap";
+            mapFieldName = "MetalMap";
          }
          else if (imageType == ImageAsset::ImageTypes::AO)
          {
@@ -2882,7 +2885,7 @@ Torque::Path AssetImporter::importMaterialAsset(AssetImportObject* assetItem)
          }
          else if (imageType == ImageAsset::ImageTypes::Roughness)
          {
-            mapFieldName = "RoughnessMap";
+            mapFieldName = "RoughMap";
             hasRoughness = true;
          }
 
diff --git a/Engine/source/T3D/assets/assetImporter.h b/Engine/source/T3D/assets/assetImporter.h
index 327b38dca..6605ebe8f 100644
--- a/Engine/source/T3D/assets/assetImporter.h
+++ b/Engine/source/T3D/assets/assetImporter.h
@@ -905,9 +905,15 @@ public:
    /// </summary>
    AssetImportConfig* getImportConfig() { return activeImportConfig; }
 
-   void setImportConfig(AssetImportConfig* importConfig) {
-      if(importConfig != nullptr)
+   void setImportConfig(AssetImportConfig* importConfig)
+   {
+      if (importConfig != nullptr)
+      {
+         dSprintf(importLogBuffer, sizeof(importLogBuffer), "Loading import config: %s!", importConfig->getName());
+         activityLog.push_back(importLogBuffer);
+
          activeImportConfig = importConfig;
+      }
    }
 
    /// <summary>
diff --git a/Templates/BaseGame/game/core/utility/scripts/helperFunctions.tscript b/Templates/BaseGame/game/core/utility/scripts/helperFunctions.tscript
index ee7378bf8..3143eb410 100644
--- a/Templates/BaseGame/game/core/utility/scripts/helperFunctions.tscript
+++ b/Templates/BaseGame/game/core/utility/scripts/helperFunctions.tscript
@@ -642,4 +642,14 @@ function populateAllFonts(%font)
    populateFontCacheRange(%font,24,0,65535);
    populateFontCacheRange(%font,32,0,65535);
    populateFontCacheRange(%font,36,0,65535);
+}
+
+//------------------------------------------------------------------------------
+function playSoundAsset(%soundAssetId)
+{
+   %assetDef = AssetDatabase.acquireAsset(%soundAssetId);
+   if(isObject(%assetDef))
+      %assetDef.playSound();
+   
+   AssetDatabase.releaseAsset(%soundAssetId);
 }
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml b/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml
index ae2e6b034..ad9de2677 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml
+++ b/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml
@@ -26,18 +26,18 @@
             <Setting name="AddedImageSuffix">_image</Setting>
             <Setting name="AlwaysAddImageSuffix">1</Setting>
             <Setting name="AOTypeSuffixes">_AO,_AMBIENT,_AMBIENTOCCLUSION</Setting>
-            <Setting name="CompositeTypeSuffixes">_COMP,_COMPOSITE,_PBR,-COMP,-COMPOSITE,-PBR,_ORM,-ORM</Setting>
+            <Setting name="CompositeTypeSuffixes">_COMP,_COMPOSITE,_PBR,-COMP,-COMPOSITE,-PBR,_ORM,-ORM,_C</Setting>
             <Setting name="Compressed">1</Setting>
             <Setting name="DiffuseTypeSuffixes">_ALBEDO,_DIFFUSE,_ALB,_DIF,_COLOR,_COL</Setting>
             <Setting name="GenerateMaterialOnImport">0</Setting>
             <Setting name="ImageType">N/A</Setting>
             <Setting name="ImportImages">1</Setting>
             <Setting name="IsHDR">0</Setting>
-            <Setting name="MetalnessTypeSuffixes">_METAL,_MET,_METALNESS,_METALLIC</Setting>
-            <Setting name="NormalTypeSuffixes">_NORMAL,_NORM</Setting>
-            <Setting name="RoughnessTypeSuffixes">_ROUGH,_ROUGHNESS</Setting>
+            <Setting name="MetalnessTypeSuffixes">_METAL,_MET,_METALNESS,_METALLIC,_M</Setting>
+            <Setting name="NormalTypeSuffixes">_NORMAL,_NORM,_N</Setting>
+            <Setting name="RoughnessTypeSuffixes">_ROUGH,_ROUGHNESS,_R</Setting>
             <Setting name="Scaling">1.0</Setting>
-            <Setting name="SmoothnessTypeSuffixes">_SMOOTH,_SMOOTHNESS</Setting>
+            <Setting name="SmoothnessTypeSuffixes">_SMOOTH,_SMOOTHNESS,_S</Setting>
             <Setting name="TextureFilteringMode">Bilinear</Setting>
             <Setting name="UseMips">1</Setting>
         </Group>
@@ -45,6 +45,8 @@
             <Setting name="AddedMaterialSuffix">_mat</Setting>
             <Setting name="AlwaysAddMaterialSuffix">0</Setting>
             <Setting name="CreateComposites">1</Setting>
+            <Setting name="CreateORMConfig">1</Setting>
+            <Setting name="IgnoreMaterials">DefaultMaterial</Setting>
             <Setting name="ImportMaterials">1</Setting>
             <Setting name="PopulateMaterialMaps">1</Setting>
             <Setting name="UseDiffuseSuffixOnOriginImage">1</Setting>
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImport.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImport.tscript
index 14023d9b2..f96b1b645 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImport.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImport.tscript
@@ -86,6 +86,8 @@ function ImportAssetWindow::onWake(%this)
    %this.importer.targetModuleId = AssetImportTargetModule.getText();
    
    %this.refresh();
+   
+   toggleImportWindowVizBtn.setStateOn(EditorSettings.value("Assets/AutoImport"));
 }
 
 //
@@ -469,9 +471,7 @@ function ImportAssetWindow::doRefresh(%this)
    ImportAssetWindow.importer.processImportingAssets();
    //%this.processImportAssets();
    
-   //ImportAssetWindow.hasImportIssues = %this.validateAssets();
-   
-   ImportAssetWindow.importer.validateImportingAssets();
+   ImportAssetWindow.hasImportIssues = ImportAssetWindow.importer.hasImportIssues();
    
    AssetImportCtrl-->NewAssetsTree.clear();
    AssetImportCtrl-->NewAssetsTree.insertItem(0, "Importing Assets");
@@ -947,3 +947,12 @@ function ImportAssetModuleList::refresh(%this)
    }
 }
 //
+
+//
+function toggleImportWindowViz()
+{
+   %value = EditorSettings.value("Assets/AutoImport");
+   EditorSettings.setValue("Assets/AutoImport", !%value);
+  
+}
+//
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfig.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfig.tscript
index 39ed541db..175d0f4d5 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfig.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfig.tscript
@@ -66,7 +66,7 @@ function setupImportConfigSettingsList()
       ImportAssetConfigSettingsList.addNewConfigSetting("Materials/ImportMaterials", "Import Materials", "bool", "", "1", "");
       ImportAssetConfigSettingsList.addNewConfigSetting("Materials/AlwaysAddMaterialSuffix", "Always Add Material Suffix", "bool", "", "1", "");
       ImportAssetConfigSettingsList.addNewConfigSetting("Materials/AddedMaterialSuffix", "Added Material Suffix", "string", "", "_mat", "");
-      ImportAssetConfigSettingsList.addNewConfigSetting("Materials/CreateComposites", "Create Composites", "bool", "", "1", "");
+      ImportAssetConfigSettingsList.addNewConfigSetting("Materials/CreateORMConfig", "Create ORM Map", "bool", "", "1", "");
       ImportAssetConfigSettingsList.addNewConfigSetting("Materials/UseDiffuseSuffixOnOriginImage", "Use Diffuse Suffix for Origin Image", "bool", "", "1", "");
       ImportAssetConfigSettingsList.addNewConfigSetting("Materials/UseExistingMaterials", "Use Existing Materials", "bool", "", "1", "");
       ImportAssetConfigSettingsList.addNewConfigSetting("Materials/IgnoreMaterials", "Ignore Materials", "command", "", "", "");
@@ -185,7 +185,7 @@ function ImportAssetOptionsWindow::editImportSettings(%this, %assetItem)
    else if(%assetType $= "MaterialAsset")
    {
       ImportOptionsList.startGroup("Material");
-      ImportOptionsList.addField("CreateComposites", "Create Composite Textures", "bool", "", "1", "", %assetConfigObj);
+      ImportOptionsList.addField("CreateORMConfig", "Create ORM Map", "bool", "", "1", "", %assetConfigObj);
       ImportOptionsList.endGroup();
    }
    else if(%assetType $= "ImageAsset")
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/popupMenus.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/popupMenus.tscript
index 31909cf07..3294387b0 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/popupMenus.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/popupMenus.tscript
@@ -25,7 +25,7 @@ function AssetBrowser::buildPopupMenus(%this)
 
          item[ 0 ] = "Edit Asset" TAB "" TAB "AssetBrowser.editAsset();";
          item[ 1 ] = "Rename Asset" TAB "" TAB "AssetBrowser.renameAsset();";
-         item[ 2 ] = "Refresh Asset" TAB "" TAB "AssetBrowser.refreshAsset();";
+         item[ 2 ] = "Reload Asset" TAB "" TAB "AssetBrowser.refreshAsset();";
          item[ 3 ] = "Asset Properties" TAB "" TAB "AssetBrowser.editAssetInfo();";
          item[ 4 ] = "-";
          Item[ 5 ] = "Duplicate Asset" TAB "" TAB "AssetBrowser.duplicateAsset();";
@@ -50,7 +50,7 @@ function AssetBrowser::buildPopupMenus(%this)
          item[ 0 ] = "Edit Level" TAB "" TAB "AssetBrowser.editAsset();";
          item[ 1 ] = "Append as Sublevel" TAB "" TAB "AssetBrowser.appendSublevel();";
          item[ 2 ] = "Rename Asset" TAB "" TAB "AssetBrowser.renameAsset();";
-         item[ 3 ] = "Refresh Asset" TAB "" TAB "AssetBrowser.refreshAsset();";
+         item[ 3 ] = "Reload Asset" TAB "" TAB "AssetBrowser.refreshAsset();";
          item[ 4 ] = "Asset Properties" TAB "" TAB "AssetBrowser.editAssetInfo();";
          item[ 5 ] = "-";
          Item[ 6 ] = "Duplicate Asset" TAB "" TAB "AssetBrowser.duplicateAsset();";
diff --git a/Templates/BaseGame/game/tools/gui/editorSettingsWindow.ed.tscript b/Templates/BaseGame/game/tools/gui/editorSettingsWindow.ed.tscript
index fea4a1a6d..848a625aa 100644
--- a/Templates/BaseGame/game/tools/gui/editorSettingsWindow.ed.tscript
+++ b/Templates/BaseGame/game/tools/gui/editorSettingsWindow.ed.tscript
@@ -53,26 +53,27 @@ function ESettingsWindow::onWake( %this )
 
 function ESettingsWindow::hideDialog( %this )
 {
-   %this.setVisible(false);
+   Canvas.popDialog(EditorSettingsWindow);
 }
 
 function ESettingsWindow::ToggleVisibility()
 {
-   if ( ESettingsWindow.visible )
+   if(ESettingsWindow.isAwake())
    {
-      ESettingsWindow.setVisible(false);
+      Canvas.popDialog(EditorSettingsWindow);
    }
    else
    {
-      ESettingsWindow.setVisible(true);
+      Canvas.pushDialog(EditorSettingsWindow); 
+      
       ESettingsWindow.selectWindow();
       ESettingsWindow.setCollapseGroup(false);
       
       ESettingsWindowList.clear();
-   }
    
    ESettingsWindowList.setSelectedById( 1 );
 }
+}
 
 function ESettingsWindow::toggleProjectSettings(%this)
 {
@@ -528,7 +529,7 @@ function ESettingsWindow::getAssetEditingSettings(%this)
    }
    
    SettingsInspector.startGroup("Assets Importing");
-   SettingsInspector.addField("Edit Asset Configs", "Edit Asset Import Configs", "button", "Open Asset Import Config Editor", "", "Canvas.pushDialog(AssetImportConfigEditor);");
+   SettingsInspector.addField("Edit Import Configs", "Edit Asset Import Configs", "button", "Open Asset Import Config Editor", "", "Canvas.pushDialog(AssetImportConfigEditor);");
    SettingsInspector.addSettingsField("Assets/AssetImporDefaultConfig", "Default Asset Import Config", "list", "", %formattedConfigList); 
    SettingsInspector.addSettingsField("Assets/AutoImport", "Automatically Import using default config", "bool", "If on, the asset importing process" @
                                                                                                                         "will attempt to automatically import any inbound assets"@
diff --git a/Templates/BaseGame/game/tools/settings.xml b/Templates/BaseGame/game/tools/settings.xml
index 225b2d67e..b7103a680 100644
--- a/Templates/BaseGame/game/tools/settings.xml
+++ b/Templates/BaseGame/game/tools/settings.xml
@@ -35,7 +35,7 @@
         <Setting
             name="AssetImporDefaultConfig">DefaultImportConfig</Setting>
         <Setting
-            name="AutoImport">1</Setting>
+            name="AutoImport">0</Setting>
         <Group
             name="Browser">
             <Setting
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
index 3e950231a..1b6ea6068 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
@@ -158,8 +158,6 @@ function EditorGui::init(%this)
    {
       exec("tools/gui/EditorSettingsWindow.ed.gui");
       exec("tools/gui/editorSettingsWindow.ed." @ $TorqueScriptFileExtension);
-      %this.add( ESettingsWindow );
-      ESettingsWindow.setVisible(false);
       
       // Start the standard settings tabs pages
       /*exec( "~/worldEditor/gui/GeneralSettingsTab.ed.gui" );
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/editorSettingsWindow.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/editorSettingsWindow.ed.tscript
deleted file mode 100644
index 3af447854..000000000
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/editorSettingsWindow.ed.tscript
+++ /dev/null
@@ -1,142 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-function ESettingsWindow::startup( %this )
-{
-   ESettingsWindowTabBook.selectPage( 0 );
-   ESettingsWindowList.setSelectedById( 0 );
-}
-
-function ESettingsWindow::onWake( %this )
-{
-}
-
-function ESettingsWindow::hideDialog( %this )
-{
-   %this.setVisible(false);
-}
-
-function ESettingsWindow::ToggleVisibility()
-{
-   if ( ESettingsWindow.visible  )
-   {
-      ESettingsWindow.setVisible(false);
-   }
-   else
-   {
-      ESettingsWindow.setVisible(true);
-      ESettingsWindow.selectWindow();
-      ESettingsWindow.setCollapseGroup(false);
-   }
-}
-
-function ESettingsWindow::addTabPage( %this, %page )
-{
-   ESettingsWindowTabBook.add( %page );
-   ESettingsWindowList.addRow( ESettingsWindowTabBook.getSelectedPage(), %page.text );
-   ESettingsWindowList.sort(0);
-}
-
-//-----------------------------------------------------------------------------
-
-function ESettingsWindowList::onSelect( %this, %id, %text )
-{
-   ESettingsWindowTabBook.selectPage( %id );
-}
-
-//-----------------------------------------------------------------------------
-// Standard settings GUI classes.  Editors may define their own methods of
-// working with settings and are not required to use these.
-//-----------------------------------------------------------------------------
-
-function ESettingsWindowCheckbox::onWake( %this )
-{
-   %this.setStateOn( EditorSettings.value( %this.editorSettingsValue ));
-}
-
-function ESettingsWindowCheckbox::onClick( %this )
-{
-   EditorSettings.setValue( %this.editorSettingsValue, %this.getValue() );
-   eval(%this.editorSettingsRead);
-}
-
-//-----------------------------------------------------------------------------
-
-function ESettingsWindowTextEdit::onWake( %this )
-{
-   %this.setText( EditorSettings.value( %this.editorSettingsValue ));
-}
-
-function ESettingsWindowTextEdit::onValidate( %this )
-{
-   EditorSettings.setValue( %this.editorSettingsValue, %this.getValue() );
-   eval(%this.editorSettingsRead);
-}
-
-function ESettingsWindowTextEdit::onGainFirstResponder( %this )
-{
-   %this.selectAllText();
-}
-
-//-----------------------------------------------------------------------------
-
-function ESettingsWindowColor::apply( %this, %color )
-{
-   EditorSettings.setValue( %this.editorSettingsValue, %color );
-   eval(%this.editorSettingsRead);
-
-   %this.findObjectByInternalName("ColorEdit", true).setText( %color);
-   %this.findObjectByInternalName("ColorButton", true).color = ColorIntToFloat( %color );
-}
-
-function ESettingsWindowColorEdit::onWake( %this )
-{
-   %this.setText( EditorSettings.value( %this.getParent().editorSettingsValue ));
-}
-
-function ESettingsWindowColorEdit::onValidate( %this )
-{
-   %this.getParent().apply( %this.getValue() );
-}
-
-function ESettingsWindowColorEdit::onGainFirstResponder( %this )
-{
-   %this.selectAllText();
-}
-
-function ESettingsWindowColorButton::onWake( %this )
-{
-   %this.color = ColorIntToFloat( EditorSettings.value( %this.getParent().editorSettingsValue ) );
-}
-
-function ESettingsWindowColorButton::onClick( %this )
-{
-   getColorI( ColorFloatToInt( %this.color ), %this.getId() @ ".apply", %this.getRoot() );
-   //EditorSettings.setValue( %this.editorSettingsValue, %this.getValue() );
-   //eval(%this.editorSettingsRead);
-}
-
-function ESettingsWindowColorButton::apply( %this, %color )
-{
-   %this.getParent().apply(%color);
-   echo("ESettingsWindowColorButton::apply(): " @ %color);
-}

From 2af12c52e100f473a602a801c22f9319082a08f6 Mon Sep 17 00:00:00 2001
From: Areloch <Areloch@gmail.com>
Date: Sun, 14 Nov 2021 01:28:16 -0600
Subject: [PATCH 250/399] Shifted check for FBX importer in assimp shape loader
 code to utilize stringtable

---
 Engine/source/ts/assimp/assimpShapeLoader.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Engine/source/ts/assimp/assimpShapeLoader.cpp b/Engine/source/ts/assimp/assimpShapeLoader.cpp
index d1b201ecd..f0dbd509e 100644
--- a/Engine/source/ts/assimp/assimpShapeLoader.cpp
+++ b/Engine/source/ts/assimp/assimpShapeLoader.cpp
@@ -179,7 +179,7 @@ void AssimpShapeLoader::enumerateScene()
       String importFormat;
 
       const aiImporterDesc* importerDescription = aiGetImporterDesc(shapePath.getExtension().c_str());
-      if (importerDescription->mName == "Autodesk FBX Importer")
+      if (StringTable->insert(importerDescription->mName) == StringTable->insert("Autodesk FBX Importer"))
       {
          ColladaUtils::getOptions().formatScaleFactor = 0.01f;
       }

From 6583134ef288ec5237e47c65741b94e85d468f12 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Sat, 13 Nov 2021 20:22:49 -0500
Subject: [PATCH 251/399] * Adjustment: Initial work on moving x86Unix platform
 code into a more common POSIX platform.

---
 Engine/source/platformMac/macMain.mm          |   8 +-
 Engine/source/platformMac/macMemory.mm        |  73 --
 .../POSIXCPUInfo.cpp}                         |   4 +
 .../POSIXConsole.cpp}                         |   4 +-
 .../POSIXGL.client.cpp}                       |   0
 .../POSIXMain.cpp}                            |   7 +-
 .../POSIXMath.cpp}                            |   5 +
 .../POSIXMemory.cpp}                          |   0
 .../POSIXProcessControl.cpp}                  |   9 +-
 .../POSIXState.h}                             |  15 +-
 .../POSIXStdConsole.h}                        |   0
 .../POSIXStrings.cpp}                         |   0
 .../POSIXTime.cpp}                            |   4 +-
 .../POSIXUtils.cpp}                           |   2 +-
 .../POSIXUtils.h}                             |   0
 .../X11Font.client.cpp}                       |   0
 .../x86UNIXFont.h => platformX11/X11Font.h}   |   0
 Engine/source/platformX86UNIX/gl_types.h      | 983 ------------------
 Engine/source/platformX86UNIX/platformAL.h    | 162 ---
 .../source/platformX86UNIX/threads/mutex.cpp  |  76 --
 .../platformX86UNIX/threads/semaphore.cpp     |  90 --
 .../source/platformX86UNIX/threads/thread.cpp | 159 ---
 .../source/platformX86UNIX/x86UNIXAsmBlit.cpp |  63 --
 .../platformX86UNIX/x86UNIXDlibrary.cpp       |  83 --
 .../platformX86UNIX/x86UNIXInput.client.cpp   | 608 -----------
 .../platformX86UNIX/x86UNIXInputManager.h     | 190 ----
 .../x86UNIXMessageBox.client.cpp              | 507 ---------
 .../platformX86UNIX/x86UNIXMessageBox.h       | 122 ---
 Engine/source/platformX86UNIX/x86UNIXNet.cpp  | 924 ----------------
 .../x86UNIXOGLVideo.client.cpp                | 508 ---------
 .../source/platformX86UNIX/x86UNIXOGLVideo.h  |  58 --
 .../platformX86UNIX/x86UNIXOpenAL.client.cpp  | 285 -----
 .../platformX86UNIX/x86UNIXPlatform.cpp       |  31 -
 .../source/platformX86UNIX/x86UNIXRedbook.cpp | 269 -----
 34 files changed, 33 insertions(+), 5216 deletions(-)
 delete mode 100644 Engine/source/platformMac/macMemory.mm
 rename Engine/source/{platformX86UNIX/x86UNIXCPUInfo.cpp => platformPOSIX/POSIXCPUInfo.cpp} (98%)
 rename Engine/source/{platformX86UNIX/x86UNIXConsole.cpp => platformPOSIX/POSIXConsole.cpp} (99%)
 rename Engine/source/{platformX86UNIX/x86UNIXGL.client.cpp => platformPOSIX/POSIXGL.client.cpp} (100%)
 rename Engine/source/{platformX86UNIX/x86UNIXMain.cpp => platformPOSIX/POSIXMain.cpp} (96%)
 rename Engine/source/{platformX86UNIX/x86UNIXMath.cpp => platformPOSIX/POSIXMath.cpp} (98%)
 rename Engine/source/{platformX86UNIX/x86UNIXMemory.cpp => platformPOSIX/POSIXMemory.cpp} (100%)
 rename Engine/source/{platformX86UNIX/x86UNIXProcessControl.cpp => platformPOSIX/POSIXProcessControl.cpp} (97%)
 rename Engine/source/{platformX86UNIX/x86UNIXState.h => platformPOSIX/POSIXState.h} (95%)
 rename Engine/source/{platformX86UNIX/x86UNIXStdConsole.h => platformPOSIX/POSIXStdConsole.h} (100%)
 rename Engine/source/{platformX86UNIX/x86UNIXStrings.cpp => platformPOSIX/POSIXStrings.cpp} (100%)
 rename Engine/source/{platformX86UNIX/x86UNIXTime.cpp => platformPOSIX/POSIXTime.cpp} (99%)
 rename Engine/source/{platformX86UNIX/x86UNIXUtils.cpp => platformPOSIX/POSIXUtils.cpp} (99%)
 rename Engine/source/{platformX86UNIX/x86UNIXUtils.h => platformPOSIX/POSIXUtils.h} (100%)
 rename Engine/source/{platformX86UNIX/x86UNIXFont.client.cpp => platformX11/X11Font.client.cpp} (100%)
 rename Engine/source/{platformX86UNIX/x86UNIXFont.h => platformX11/X11Font.h} (100%)
 delete mode 100644 Engine/source/platformX86UNIX/gl_types.h
 delete mode 100644 Engine/source/platformX86UNIX/platformAL.h
 delete mode 100644 Engine/source/platformX86UNIX/threads/mutex.cpp
 delete mode 100644 Engine/source/platformX86UNIX/threads/semaphore.cpp
 delete mode 100644 Engine/source/platformX86UNIX/threads/thread.cpp
 delete mode 100644 Engine/source/platformX86UNIX/x86UNIXAsmBlit.cpp
 delete mode 100644 Engine/source/platformX86UNIX/x86UNIXDlibrary.cpp
 delete mode 100644 Engine/source/platformX86UNIX/x86UNIXInput.client.cpp
 delete mode 100644 Engine/source/platformX86UNIX/x86UNIXInputManager.h
 delete mode 100644 Engine/source/platformX86UNIX/x86UNIXMessageBox.client.cpp
 delete mode 100644 Engine/source/platformX86UNIX/x86UNIXMessageBox.h
 delete mode 100644 Engine/source/platformX86UNIX/x86UNIXNet.cpp
 delete mode 100644 Engine/source/platformX86UNIX/x86UNIXOGLVideo.client.cpp
 delete mode 100644 Engine/source/platformX86UNIX/x86UNIXOGLVideo.h
 delete mode 100644 Engine/source/platformX86UNIX/x86UNIXOpenAL.client.cpp
 delete mode 100644 Engine/source/platformX86UNIX/x86UNIXPlatform.cpp
 delete mode 100644 Engine/source/platformX86UNIX/x86UNIXRedbook.cpp

diff --git a/Engine/source/platformMac/macMain.mm b/Engine/source/platformMac/macMain.mm
index b7d8d1478..19fc2b0e2 100644
--- a/Engine/source/platformMac/macMain.mm
+++ b/Engine/source/platformMac/macMain.mm
@@ -23,14 +23,18 @@
 #import "app/mainLoop.h"
 #import "platform/platformInput.h"
 #import "console/console.h"
+#import "platformPOSIX/POSIXStdConsole.h"
+#import "platformPOSIX/POSIXState.h"
 
 extern void InitWindowingSystem();
 
 //------------------------------------------------------------------------------
 void Platform::init()
 {
-   
-   Con::printf("Initializing platform...");
+    StdConsole::create();
+    stdConsole->enable(true);
+
+    Con::printf("Initializing platform...");
    
    // Set the platform variable for the scripts
    Con::setVariable( "$platform", "MacOSX" );
diff --git a/Engine/source/platformMac/macMemory.mm b/Engine/source/platformMac/macMemory.mm
deleted file mode 100644
index fccf28d46..000000000
--- a/Engine/source/platformMac/macMemory.mm
+++ /dev/null
@@ -1,73 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2013 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#import "platform/platform.h"
-#import <stdlib.h>
-#import <string.h>
-#import <mm_malloc.h>
-
-//--------------------------------------
-void* dRealMalloc(dsize_t in_size)
-{
-   return malloc(in_size);
-}
-
-
-//--------------------------------------
-void dRealFree(void* in_pFree)
-{
-   free(in_pFree);
-}
-
-void *dMalloc_aligned(dsize_t in_size, int alignment)
-{
-   return _mm_malloc(in_size, alignment);
-}
-
-void dFree_aligned(void* p)
-{
-   return _mm_free(p);
-}
-
-void* dMemcpy(void *dst, const void *src, dsize_t size)
-{
-   return memcpy(dst,src,size);
-}
-
-
-//--------------------------------------
-void* dMemmove(void *dst, const void *src, dsize_t size)
-{
-   return memmove(dst,src,size);
-}
-
-//--------------------------------------
-void* dMemset(void *dst, int c, dsize_t size)
-{
-   return memset(dst,c,size);
-}
-
-//--------------------------------------
-int dMemcmp(const void *ptr1, const void *ptr2, dsize_t len)
-{
-   return(memcmp(ptr1, ptr2, len));
-}
diff --git a/Engine/source/platformX86UNIX/x86UNIXCPUInfo.cpp b/Engine/source/platformPOSIX/POSIXCPUInfo.cpp
similarity index 98%
rename from Engine/source/platformX86UNIX/x86UNIXCPUInfo.cpp
rename to Engine/source/platformPOSIX/POSIXCPUInfo.cpp
index b3bbd32bb..33b79425e 100644
--- a/Engine/source/platformX86UNIX/x86UNIXCPUInfo.cpp
+++ b/Engine/source/platformPOSIX/POSIXCPUInfo.cpp
@@ -20,6 +20,8 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
+#ifndef __APPLE__
+
 #include "platform/platform.h"
 #include "platformX86UNIX/platformX86UNIX.h"
 #include "console/console.h"
@@ -45,3 +47,5 @@ namespace CPUInfo
        return CONFIG_SingleCoreHTDisabled;
     }
 }; // namespace CPUInfo 
+
+#endif
\ No newline at end of file
diff --git a/Engine/source/platformX86UNIX/x86UNIXConsole.cpp b/Engine/source/platformPOSIX/POSIXConsole.cpp
similarity index 99%
rename from Engine/source/platformX86UNIX/x86UNIXConsole.cpp
rename to Engine/source/platformPOSIX/POSIXConsole.cpp
index 85828b202..5e9f810ec 100644
--- a/Engine/source/platformX86UNIX/x86UNIXConsole.cpp
+++ b/Engine/source/platformPOSIX/POSIXConsole.cpp
@@ -21,8 +21,8 @@
 //-----------------------------------------------------------------------------
 
 #include "platformX86UNIX/platformX86UNIX.h"
-#include "platformX86UNIX/x86UNIXStdConsole.h"
-#include "platformX86UNIX/x86UNIXUtils.h"
+#include "platformPOSIX/POSIXStdConsole.h"
+#include "platformPOSIX/POSIXUtils.h"
 #include "platform/input/event.h"
 #include "platform/platform.h"
 #include "core/util/rawData.h"
diff --git a/Engine/source/platformX86UNIX/x86UNIXGL.client.cpp b/Engine/source/platformPOSIX/POSIXGL.client.cpp
similarity index 100%
rename from Engine/source/platformX86UNIX/x86UNIXGL.client.cpp
rename to Engine/source/platformPOSIX/POSIXGL.client.cpp
diff --git a/Engine/source/platformX86UNIX/x86UNIXMain.cpp b/Engine/source/platformPOSIX/POSIXMain.cpp
similarity index 96%
rename from Engine/source/platformX86UNIX/x86UNIXMain.cpp
rename to Engine/source/platformPOSIX/POSIXMain.cpp
index 1c98ed4e2..dda611967 100644
--- a/Engine/source/platformX86UNIX/x86UNIXMain.cpp
+++ b/Engine/source/platformPOSIX/POSIXMain.cpp
@@ -20,13 +20,15 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
+#ifndef __APPLE__
+
 #include "platform/platform.h"
 #include "platform/platformInput.h"
 #include "console/console.h"
 
 #include "platformX86UNIX/platformX86UNIX.h"
-#include "platformX86UNIX/x86UNIXStdConsole.h"
-#include "platformX86UNIX/x86UNIXState.h"
+#include "platformPOSIX/POSIXStdConsole.h"
+#include "platformPOSIX/POSIXState.h"
 
 extern void InitWindowingSystem();
 
@@ -102,3 +104,4 @@ int main(int argc, const char **argv)
    return TorqueMain(argc, argv);
 }
 #endif
+#endif
\ No newline at end of file
diff --git a/Engine/source/platformX86UNIX/x86UNIXMath.cpp b/Engine/source/platformPOSIX/POSIXMath.cpp
similarity index 98%
rename from Engine/source/platformX86UNIX/x86UNIXMath.cpp
rename to Engine/source/platformPOSIX/POSIXMath.cpp
index ada90c5f5..ef1f089a4 100644
--- a/Engine/source/platformX86UNIX/x86UNIXMath.cpp
+++ b/Engine/source/platformPOSIX/POSIXMath.cpp
@@ -20,6 +20,8 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
+#ifndef __APPLE__
+
 #include "platform/platform.h"
 #include "console/console.h"
 #include "math/mMath.h"
@@ -97,8 +99,10 @@ void Math::init(U32 properties)
    Con::printf("   Installing Standard C extensions");
    mInstallLibrary_C();
 
+#if defined(TORQUE_CPU_X32) || defined(TORQUE_CPU_X64)
    Con::printf("   Installing Assembly extensions");
    mInstallLibrary_ASM();
+#endif
 
    if (properties & CPU_PROP_FPU)
    {
@@ -174,4 +178,5 @@ void Platform::setMathControlStateKnown()
 }
 
 #endif
+#endif
 
diff --git a/Engine/source/platformX86UNIX/x86UNIXMemory.cpp b/Engine/source/platformPOSIX/POSIXMemory.cpp
similarity index 100%
rename from Engine/source/platformX86UNIX/x86UNIXMemory.cpp
rename to Engine/source/platformPOSIX/POSIXMemory.cpp
diff --git a/Engine/source/platformX86UNIX/x86UNIXProcessControl.cpp b/Engine/source/platformPOSIX/POSIXProcessControl.cpp
similarity index 97%
rename from Engine/source/platformX86UNIX/x86UNIXProcessControl.cpp
rename to Engine/source/platformPOSIX/POSIXProcessControl.cpp
index db7d0bdb7..0d8725d0b 100644
--- a/Engine/source/platformX86UNIX/x86UNIXProcessControl.cpp
+++ b/Engine/source/platformPOSIX/POSIXProcessControl.cpp
@@ -20,9 +20,11 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
+#ifndef __APPLE__
+
 #include "platformX86UNIX/platformX86UNIX.h"
-#include "platformX86UNIX/x86UNIXState.h"
-#include "platformX86UNIX/x86UNIXStdConsole.h"
+#include "platformPOSIX/POSIXState.h"
+#include "platformPOSIX/POSIXStdConsole.h"
 #include "platform/platformInput.h"
 #include "windowManager/platformWindow.h"
 #include "windowManager/platformWindowMgr.h"
@@ -130,7 +132,7 @@ void ProcessControlInit()
 
    // we're not interested in the exit status of child processes, so this 
    // prevents zombies from accumulating.
-#if defined(__FreeBSD__)
+#if defined(__FreeBSD__) || defined(__APPLE__)
    signal(SIGCHLD, SIG_IGN);
 #else
    signal(SIGCLD, SIG_IGN);
@@ -232,3 +234,4 @@ void Platform::restartInstance()
 */
    exit(0);
 }
+#endif
\ No newline at end of file
diff --git a/Engine/source/platformX86UNIX/x86UNIXState.h b/Engine/source/platformPOSIX/POSIXState.h
similarity index 95%
rename from Engine/source/platformX86UNIX/x86UNIXState.h
rename to Engine/source/platformPOSIX/POSIXState.h
index 4036f029e..7d35667bc 100644
--- a/Engine/source/platformX86UNIX/x86UNIXState.h
+++ b/Engine/source/platformPOSIX/POSIXState.h
@@ -25,13 +25,9 @@
 //#include "platformX86UNIX/platformGL.h"
 #include "core/strings/stringFunctions.h"
 
-#ifndef TORQUE_DEDICATED
-#include <X11/Xlib.h> // for Display, Window and other X mojo
-#else
 #define Display int
 #define Window int
 #define Screen int
-#endif
 
 #include <libgen.h> // for basename
 
@@ -225,11 +221,6 @@ class DisplayPtrManager
    private:
       Display* openDisplay()
       {
-#ifndef TORQUE_DEDICATED
-         mDisplay = XOpenDisplay(NULL);
-         if (mDisplay != NULL)
-            mOpenedDisplay = true;
-#endif
          return mDisplay;
       }
 
@@ -237,11 +228,7 @@ class DisplayPtrManager
       {
          if (mOpenedDisplay)
          {
-#ifndef TORQUE_DEDICATED
-            XCloseDisplay(mDisplay);
-            mDisplay = NULL;
-            mOpenedDisplay = false;
-#endif
+
          }
       }
    public:
diff --git a/Engine/source/platformX86UNIX/x86UNIXStdConsole.h b/Engine/source/platformPOSIX/POSIXStdConsole.h
similarity index 100%
rename from Engine/source/platformX86UNIX/x86UNIXStdConsole.h
rename to Engine/source/platformPOSIX/POSIXStdConsole.h
diff --git a/Engine/source/platformX86UNIX/x86UNIXStrings.cpp b/Engine/source/platformPOSIX/POSIXStrings.cpp
similarity index 100%
rename from Engine/source/platformX86UNIX/x86UNIXStrings.cpp
rename to Engine/source/platformPOSIX/POSIXStrings.cpp
diff --git a/Engine/source/platformX86UNIX/x86UNIXTime.cpp b/Engine/source/platformPOSIX/POSIXTime.cpp
similarity index 99%
rename from Engine/source/platformX86UNIX/x86UNIXTime.cpp
rename to Engine/source/platformPOSIX/POSIXTime.cpp
index ec3e73642..15d733389 100644
--- a/Engine/source/platformX86UNIX/x86UNIXTime.cpp
+++ b/Engine/source/platformPOSIX/POSIXTime.cpp
@@ -20,6 +20,8 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
+#ifndef __APPLE__
+
 #include "platformX86UNIX/platformX86UNIX.h"
 #include "platform/platformTimer.h"
 #include "time.h"
@@ -158,4 +160,4 @@ void Platform::sleep(U32 ms)
 	// note: this will overflow if you want to sleep for more than 49 days. just so ye know.
 	usleep( ms * 1000 );
 }
-	    
+#endif
diff --git a/Engine/source/platformX86UNIX/x86UNIXUtils.cpp b/Engine/source/platformPOSIX/POSIXUtils.cpp
similarity index 99%
rename from Engine/source/platformX86UNIX/x86UNIXUtils.cpp
rename to Engine/source/platformPOSIX/POSIXUtils.cpp
index a7b0eafa7..b87d92c49 100644
--- a/Engine/source/platformX86UNIX/x86UNIXUtils.cpp
+++ b/Engine/source/platformPOSIX/POSIXUtils.cpp
@@ -32,7 +32,7 @@
 #include <stdlib.h>
 
 #include "platformX86UNIX/platformX86UNIX.h"
-#include "platformX86UNIX/x86UNIXUtils.h"
+#include "platformPOSIX/POSIXUtils.h"
 
 UnixUtils *UUtils = NULL;
 UnixUtils utils; 
diff --git a/Engine/source/platformX86UNIX/x86UNIXUtils.h b/Engine/source/platformPOSIX/POSIXUtils.h
similarity index 100%
rename from Engine/source/platformX86UNIX/x86UNIXUtils.h
rename to Engine/source/platformPOSIX/POSIXUtils.h
diff --git a/Engine/source/platformX86UNIX/x86UNIXFont.client.cpp b/Engine/source/platformX11/X11Font.client.cpp
similarity index 100%
rename from Engine/source/platformX86UNIX/x86UNIXFont.client.cpp
rename to Engine/source/platformX11/X11Font.client.cpp
diff --git a/Engine/source/platformX86UNIX/x86UNIXFont.h b/Engine/source/platformX11/X11Font.h
similarity index 100%
rename from Engine/source/platformX86UNIX/x86UNIXFont.h
rename to Engine/source/platformX11/X11Font.h
diff --git a/Engine/source/platformX86UNIX/gl_types.h b/Engine/source/platformX86UNIX/gl_types.h
deleted file mode 100644
index c74570814..000000000
--- a/Engine/source/platformX86UNIX/gl_types.h
+++ /dev/null
@@ -1,983 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#ifndef _X86UNIX_GL_TYPES_H_
-#define _X86UNIX_GL_TYPES_H_
-
-// added by JMQ:
-#define GL_TEXTURE_MAX_ANISOTROPY_EXT     0x84FE
-#define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF
-
-#define GL_FOG_COORDINATE_SOURCE_EXT      0x8450
-#define GL_FOG_COORDINATE_EXT             0x8451
-#define GL_FRAGMENT_DEPTH_EXT             0x8452
-#define GL_CURRENT_FOG_COORDINATE_EXT     0x8453
-#define GL_FOG_COORDINATE_ARRAY_TYPE_EXT  0x8454
-#define GL_FOG_COORDINATE_ARRAY_STRIDE_EXT 0x8455
-#define GL_FOG_COORDINATE_ARRAY_POINTER_EXT 0x8456
-#define GL_FOG_COORDINATE_ARRAY_EXT       0x8457
-
-#define GL_COMPRESSED_ALPHA_ARB           0x84E9
-#define GL_COMPRESSED_LUMINANCE_ARB       0x84EA
-#define GL_COMPRESSED_LUMINANCE_ALPHA_ARB 0x84EB
-#define GL_COMPRESSED_INTENSITY_ARB       0x84EC
-#define GL_COMPRESSED_RGB_ARB             0x84ED
-#define GL_COMPRESSED_RGBA_ARB            0x84EE
-#define GL_TEXTURE_COMPRESSION_HINT_ARB   0x84EF
-#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB         0x86A0
-#define GL_TEXTURE_COMPRESSED_ARB         0x86A1
-#define GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A2
-#define GL_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A3
-
-#ifndef GL_EXT_packed_pixels
-#define GL_UNSIGNED_BYTE_3_3_2_EXT        0x8032
-#define GL_UNSIGNED_SHORT_4_4_4_4_EXT     0x8033
-#define GL_UNSIGNED_SHORT_5_5_5_1_EXT     0x8034
-#define GL_UNSIGNED_INT_8_8_8_8_EXT       0x8035
-#define GL_UNSIGNED_INT_10_10_10_2_EXT    0x8036
-#endif
-
-#ifndef GL_EXT_paletted_texture
-#define GL_COLOR_INDEX1_EXT               0x80E2
-#define GL_COLOR_INDEX2_EXT               0x80E3
-#define GL_COLOR_INDEX4_EXT               0x80E4
-#define GL_COLOR_INDEX8_EXT               0x80E5
-#define GL_COLOR_INDEX12_EXT              0x80E6
-#define GL_COLOR_INDEX16_EXT              0x80E7
-#define GL_TEXTURE_INDEX_SIZE_EXT         0x80ED
-#endif
-
-#define GL_CLAMP_TO_EDGE_EXT     0x812F
-
-#define GL_V12MTVFMT_EXT                     0x8702
-#define GL_V12MTNVFMT_EXT                     0x8703
-#define GL_V12FTVFMT_EXT                     0x8704
-#define GL_V12FMTVFMT_EXT                     0x8705
-
-#ifndef GL_EXT_texture_env_combine
-#define GL_COMBINE_EXT                    0x8570
-#define GL_COMBINE_RGB_EXT                0x8571
-#define GL_COMBINE_ALPHA_EXT              0x8572
-#define GL_RGB_SCALE_EXT                  0x8573
-#define GL_ADD_SIGNED_EXT                 0x8574
-#define GL_INTERPOLATE_EXT                0x8575
-#define GL_CONSTANT_EXT                   0x8576
-#define GL_PRIMARY_COLOR_EXT              0x8577
-#define GL_PREVIOUS_EXT                   0x8578
-#define GL_SOURCE0_RGB_EXT                0x8580
-#define GL_SOURCE1_RGB_EXT                0x8581
-#define GL_SOURCE2_RGB_EXT                0x8582
-#define GL_SOURCE3_RGB_EXT                0x8583
-#define GL_SOURCE4_RGB_EXT                0x8584
-#define GL_SOURCE5_RGB_EXT                0x8585
-#define GL_SOURCE6_RGB_EXT                0x8586
-#define GL_SOURCE7_RGB_EXT                0x8587
-#define GL_SOURCE0_ALPHA_EXT              0x8588
-#define GL_SOURCE1_ALPHA_EXT              0x8589
-#define GL_SOURCE2_ALPHA_EXT              0x858A
-#define GL_SOURCE3_ALPHA_EXT              0x858B
-#define GL_SOURCE4_ALPHA_EXT              0x858C
-#define GL_SOURCE5_ALPHA_EXT              0x858D
-#define GL_SOURCE6_ALPHA_EXT              0x858E
-#define GL_SOURCE7_ALPHA_EXT              0x858F
-#define GL_OPERAND0_RGB_EXT               0x8590
-#define GL_OPERAND1_RGB_EXT               0x8591
-#define GL_OPERAND2_RGB_EXT               0x8592
-#define GL_OPERAND3_RGB_EXT               0x8593
-#define GL_OPERAND4_RGB_EXT               0x8594
-#define GL_OPERAND5_RGB_EXT               0x8595
-#define GL_OPERAND6_RGB_EXT               0x8596
-#define GL_OPERAND7_RGB_EXT               0x8597
-#define GL_OPERAND0_ALPHA_EXT             0x8598
-#define GL_OPERAND1_ALPHA_EXT             0x8599
-#define GL_OPERAND2_ALPHA_EXT             0x859A
-#define GL_OPERAND3_ALPHA_EXT             0x859B
-#define GL_OPERAND4_ALPHA_EXT             0x859C
-#define GL_OPERAND5_ALPHA_EXT             0x859D
-#define GL_OPERAND6_ALPHA_EXT             0x859E
-#define GL_OPERAND7_ALPHA_EXT             0x859F
-#endif
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-
-
-#define GL_VERSION_1_1   1
-#define GL_VERSION_1_2   1
-
-/*
- *
- * Datatypes
- *
- */
-#ifdef CENTERLINE_CLPP
-#define signed
-#endif
-typedef unsigned int	GLenum;
-typedef unsigned char	GLboolean;
-typedef unsigned int	GLbitfield;
-typedef void		GLvoid;
-typedef signed char	GLbyte;		/* 1-byte signed */
-typedef short		GLshort;	/* 2-byte signed */
-typedef int		GLint;		/* 4-byte signed */
-typedef unsigned char	GLubyte;	/* 1-byte unsigned */
-typedef unsigned short	GLushort;	/* 2-byte unsigned */
-typedef unsigned int	GLuint;		/* 4-byte unsigned */
-typedef int		GLsizei;	/* 4-byte signed */
-typedef float		GLfloat;	/* single precision float */
-typedef float		GLclampf;	/* single precision float in [0,1] */
-typedef double		GLdouble;	/* double precision float */
-typedef double		GLclampd;	/* double precision float in [0,1] */
-
-
-
-/*
- *
- * Constants
- *
- */
-
-/* Boolean values */
-#define GL_FALSE				0x0
-#define GL_TRUE					0x1
-
-/* Data types */
-#define GL_BYTE					0x1400
-#define GL_UNSIGNED_BYTE			0x1401
-#define GL_SHORT				0x1402
-#define GL_UNSIGNED_SHORT			0x1403
-#define GL_INT					0x1404
-#define GL_UNSIGNED_INT				0x1405
-#define GL_FLOAT				0x1406
-#define GL_DOUBLE				0x140A
-#define GL_2_BYTES				0x1407
-#define GL_3_BYTES				0x1408
-#define GL_4_BYTES				0x1409
-
-/* Primitives */
-#define GL_POINTS				0x0000
-#define GL_LINES				0x0001
-#define GL_LINE_LOOP				0x0002
-#define GL_LINE_STRIP				0x0003
-#define GL_TRIANGLES				0x0004
-#define GL_TRIANGLE_STRIP			0x0005
-#define GL_TRIANGLE_FAN				0x0006
-#define GL_QUADS				0x0007
-#define GL_QUAD_STRIP				0x0008
-#define GL_POLYGON				0x0009
-
-/* Vertex Arrays */
-#define GL_VERTEX_ARRAY				0x8074
-#define GL_NORMAL_ARRAY				0x8075
-#define GL_COLOR_ARRAY				0x8076
-#define GL_INDEX_ARRAY				0x8077
-#define GL_TEXTURE_COORD_ARRAY			0x8078
-#define GL_EDGE_FLAG_ARRAY			0x8079
-#define GL_VERTEX_ARRAY_SIZE			0x807A
-#define GL_VERTEX_ARRAY_TYPE			0x807B
-#define GL_VERTEX_ARRAY_STRIDE			0x807C
-#define GL_NORMAL_ARRAY_TYPE			0x807E
-#define GL_NORMAL_ARRAY_STRIDE			0x807F
-#define GL_COLOR_ARRAY_SIZE			0x8081
-#define GL_COLOR_ARRAY_TYPE			0x8082
-#define GL_COLOR_ARRAY_STRIDE			0x8083
-#define GL_INDEX_ARRAY_TYPE			0x8085
-#define GL_INDEX_ARRAY_STRIDE			0x8086
-#define GL_TEXTURE_COORD_ARRAY_SIZE		0x8088
-#define GL_TEXTURE_COORD_ARRAY_TYPE		0x8089
-#define GL_TEXTURE_COORD_ARRAY_STRIDE		0x808A
-#define GL_EDGE_FLAG_ARRAY_STRIDE		0x808C
-#define GL_VERTEX_ARRAY_POINTER			0x808E
-#define GL_NORMAL_ARRAY_POINTER			0x808F
-#define GL_COLOR_ARRAY_POINTER			0x8090
-#define GL_INDEX_ARRAY_POINTER			0x8091
-#define GL_TEXTURE_COORD_ARRAY_POINTER		0x8092
-#define GL_EDGE_FLAG_ARRAY_POINTER		0x8093
-#define GL_V2F					0x2A20
-#define GL_V3F					0x2A21
-#define GL_C4UB_V2F				0x2A22
-#define GL_C4UB_V3F				0x2A23
-#define GL_C3F_V3F				0x2A24
-#define GL_N3F_V3F				0x2A25
-#define GL_C4F_N3F_V3F				0x2A26
-#define GL_T2F_V3F				0x2A27
-#define GL_T4F_V4F				0x2A28
-#define GL_T2F_C4UB_V3F				0x2A29
-#define GL_T2F_C3F_V3F				0x2A2A
-#define GL_T2F_N3F_V3F				0x2A2B
-#define GL_T2F_C4F_N3F_V3F			0x2A2C
-#define GL_T4F_C4F_N3F_V4F			0x2A2D
-
-/* Matrix Mode */
-#define GL_MATRIX_MODE				0x0BA0
-#define GL_MODELVIEW				0x1700
-#define GL_PROJECTION				0x1701
-#define GL_TEXTURE				0x1702
-
-/* Points */
-#define GL_POINT_SMOOTH				0x0B10
-#define GL_POINT_SIZE				0x0B11
-#define GL_POINT_SIZE_GRANULARITY 		0x0B13
-#define GL_POINT_SIZE_RANGE			0x0B12
-
-/* Lines */
-#define GL_LINE_SMOOTH				0x0B20
-#define GL_LINE_STIPPLE				0x0B24
-#define GL_LINE_STIPPLE_PATTERN			0x0B25
-#define GL_LINE_STIPPLE_REPEAT			0x0B26
-#define GL_LINE_WIDTH				0x0B21
-#define GL_LINE_WIDTH_GRANULARITY		0x0B23
-#define GL_LINE_WIDTH_RANGE			0x0B22
-
-/* Polygons */
-#define GL_POINT				0x1B00
-#define GL_LINE					0x1B01
-#define GL_FILL					0x1B02
-#define GL_CW					0x0900
-#define GL_CCW					0x0901
-#define GL_FRONT				0x0404
-#define GL_BACK					0x0405
-#define GL_POLYGON_MODE				0x0B40
-#define GL_POLYGON_SMOOTH			0x0B41
-#define GL_POLYGON_STIPPLE			0x0B42
-#define GL_EDGE_FLAG				0x0B43
-#define GL_CULL_FACE				0x0B44
-#define GL_CULL_FACE_MODE			0x0B45
-#define GL_FRONT_FACE				0x0B46
-#define GL_POLYGON_OFFSET_FACTOR		0x8038
-#define GL_POLYGON_OFFSET_UNITS			0x2A00
-#define GL_POLYGON_OFFSET_POINT			0x2A01
-#define GL_POLYGON_OFFSET_LINE			0x2A02
-#define GL_POLYGON_OFFSET_FILL			0x8037
-
-/* Display Lists */
-#define GL_COMPILE				0x1300
-#define GL_COMPILE_AND_EXECUTE			0x1301
-#define GL_LIST_BASE				0x0B32
-#define GL_LIST_INDEX				0x0B33
-#define GL_LIST_MODE				0x0B30
-
-/* Depth buffer */
-#define GL_NEVER				0x0200
-#define GL_LESS					0x0201
-#define GL_EQUAL				0x0202
-#define GL_LEQUAL				0x0203
-#define GL_GREATER				0x0204
-#define GL_NOTEQUAL				0x0205
-#define GL_GEQUAL				0x0206
-#define GL_ALWAYS				0x0207
-#define GL_DEPTH_TEST				0x0B71
-#define GL_DEPTH_BITS				0x0D56
-#define GL_DEPTH_CLEAR_VALUE			0x0B73
-#define GL_DEPTH_FUNC				0x0B74
-#define GL_DEPTH_RANGE				0x0B70
-#define GL_DEPTH_WRITEMASK			0x0B72
-#define GL_DEPTH_COMPONENT			0x1902
-
-/* Lighting */
-#define GL_LIGHTING				0x0B50
-#define GL_LIGHT0				0x4000
-#define GL_LIGHT1				0x4001
-#define GL_LIGHT2				0x4002
-#define GL_LIGHT3				0x4003
-#define GL_LIGHT4				0x4004
-#define GL_LIGHT5				0x4005
-#define GL_LIGHT6				0x4006
-#define GL_LIGHT7				0x4007
-#define GL_SPOT_EXPONENT			0x1205
-#define GL_SPOT_CUTOFF				0x1206
-#define GL_CONSTANT_ATTENUATION			0x1207
-#define GL_LINEAR_ATTENUATION			0x1208
-#define GL_QUADRATIC_ATTENUATION		0x1209
-#define GL_AMBIENT				0x1200
-#define GL_DIFFUSE				0x1201
-#define GL_SPECULAR				0x1202
-#define GL_SHININESS				0x1601
-#define GL_EMISSION				0x1600
-#define GL_POSITION				0x1203
-#define GL_SPOT_DIRECTION			0x1204
-#define GL_AMBIENT_AND_DIFFUSE			0x1602
-#define GL_COLOR_INDEXES			0x1603
-#define GL_LIGHT_MODEL_TWO_SIDE			0x0B52
-#define GL_LIGHT_MODEL_LOCAL_VIEWER		0x0B51
-#define GL_LIGHT_MODEL_AMBIENT			0x0B53
-#define GL_FRONT_AND_BACK			0x0408
-#define GL_SHADE_MODEL				0x0B54
-#define GL_FLAT					0x1D00
-#define GL_SMOOTH				0x1D01
-#define GL_COLOR_MATERIAL			0x0B57
-#define GL_COLOR_MATERIAL_FACE			0x0B55
-#define GL_COLOR_MATERIAL_PARAMETER		0x0B56
-#define GL_NORMALIZE				0x0BA1
-
-/* User clipping planes */
-#define GL_CLIP_PLANE0				0x3000
-#define GL_CLIP_PLANE1				0x3001
-#define GL_CLIP_PLANE2				0x3002
-#define GL_CLIP_PLANE3				0x3003
-#define GL_CLIP_PLANE4				0x3004
-#define GL_CLIP_PLANE5				0x3005
-
-/* Accumulation buffer */
-#define GL_ACCUM_RED_BITS			0x0D58
-#define GL_ACCUM_GREEN_BITS			0x0D59
-#define GL_ACCUM_BLUE_BITS			0x0D5A
-#define GL_ACCUM_ALPHA_BITS			0x0D5B
-#define GL_ACCUM_CLEAR_VALUE			0x0B80
-#define GL_ACCUM				0x0100
-#define GL_ADD					0x0104
-#define GL_LOAD					0x0101
-#define GL_MULT					0x0103
-#define GL_RETURN				0x0102
-
-/* Alpha testing */
-#define GL_ALPHA_TEST				0x0BC0
-#define GL_ALPHA_TEST_REF			0x0BC2
-#define GL_ALPHA_TEST_FUNC			0x0BC1
-
-/* Blending */
-#define GL_BLEND				0x0BE2
-#define GL_BLEND_SRC				0x0BE1
-#define GL_BLEND_DST				0x0BE0
-#define GL_ZERO					0x0
-#define GL_ONE					0x1
-#define GL_SRC_COLOR				0x0300
-#define GL_ONE_MINUS_SRC_COLOR			0x0301
-#define GL_DST_COLOR				0x0306
-#define GL_ONE_MINUS_DST_COLOR			0x0307
-#define GL_SRC_ALPHA				0x0302
-#define GL_ONE_MINUS_SRC_ALPHA			0x0303
-#define GL_DST_ALPHA				0x0304
-#define GL_ONE_MINUS_DST_ALPHA			0x0305
-#define GL_SRC_ALPHA_SATURATE			0x0308
-#define GL_CONSTANT_COLOR			0x8001
-#define GL_ONE_MINUS_CONSTANT_COLOR		0x8002
-#define GL_CONSTANT_ALPHA			0x8003
-#define GL_ONE_MINUS_CONSTANT_ALPHA		0x8004
-
-/* Render Mode */
-#define GL_FEEDBACK				0x1C01
-#define GL_RENDER				0x1C00
-#define GL_SELECT				0x1C02
-
-/* Feedback */
-#define GL_2D					0x0600
-#define GL_3D					0x0601
-#define GL_3D_COLOR				0x0602
-#define GL_3D_COLOR_TEXTURE			0x0603
-#define GL_4D_COLOR_TEXTURE			0x0604
-#define GL_POINT_TOKEN				0x0701
-#define GL_LINE_TOKEN				0x0702
-#define GL_LINE_RESET_TOKEN			0x0707
-#define GL_POLYGON_TOKEN			0x0703
-#define GL_BITMAP_TOKEN				0x0704
-#define GL_DRAW_PIXEL_TOKEN			0x0705
-#define GL_COPY_PIXEL_TOKEN			0x0706
-#define GL_PASS_THROUGH_TOKEN			0x0700
-#define GL_FEEDBACK_BUFFER_POINTER		0x0DF0
-#define GL_FEEDBACK_BUFFER_SIZE			0x0DF1
-#define GL_FEEDBACK_BUFFER_TYPE			0x0DF2
-
-/* Selection */
-#define GL_SELECTION_BUFFER_POINTER		0x0DF3
-#define GL_SELECTION_BUFFER_SIZE		0x0DF4
-
-/* Fog */
-#define GL_FOG					0x0B60
-#define GL_FOG_MODE				0x0B65
-#define GL_FOG_DENSITY				0x0B62
-#define GL_FOG_COLOR				0x0B66
-#define GL_FOG_INDEX				0x0B61
-#define GL_FOG_START				0x0B63
-#define GL_FOG_END				0x0B64
-#define GL_LINEAR				0x2601
-#define GL_EXP					0x0800
-#define GL_EXP2					0x0801
-
-/* Logic Ops */
-#define GL_LOGIC_OP				0x0BF1
-#define GL_INDEX_LOGIC_OP			0x0BF1
-#define GL_COLOR_LOGIC_OP			0x0BF2
-#define GL_LOGIC_OP_MODE			0x0BF0
-#define GL_CLEAR				0x1500
-#define GL_SET					0x150F
-#define GL_COPY					0x1503
-#define GL_COPY_INVERTED			0x150C
-#define GL_NOOP					0x1505
-#define GL_INVERT				0x150A
-#define GL_AND					0x1501
-#define GL_NAND					0x150E
-#define GL_OR					0x1507
-#define GL_NOR					0x1508
-#define GL_XOR					0x1506
-#define GL_EQUIV				0x1509
-#define GL_AND_REVERSE				0x1502
-#define GL_AND_INVERTED				0x1504
-#define GL_OR_REVERSE				0x150B
-#define GL_OR_INVERTED				0x150D
-
-/* Stencil */
-#define GL_STENCIL_TEST				0x0B90
-#define GL_STENCIL_WRITEMASK			0x0B98
-#define GL_STENCIL_BITS				0x0D57
-#define GL_STENCIL_FUNC				0x0B92
-#define GL_STENCIL_VALUE_MASK			0x0B93
-#define GL_STENCIL_REF				0x0B97
-#define GL_STENCIL_FAIL				0x0B94
-#define GL_STENCIL_PASS_DEPTH_PASS		0x0B96
-#define GL_STENCIL_PASS_DEPTH_FAIL		0x0B95
-#define GL_STENCIL_CLEAR_VALUE			0x0B91
-#define GL_STENCIL_INDEX			0x1901
-#define GL_KEEP					0x1E00
-#define GL_REPLACE				0x1E01
-#define GL_INCR					0x1E02
-#define GL_DECR					0x1E03
-
-/* Buffers, Pixel Drawing/Reading */
-#define GL_NONE					0x0
-#define GL_LEFT					0x0406
-#define GL_RIGHT				0x0407
-/*GL_FRONT					0x0404 */
-/*GL_BACK					0x0405 */
-/*GL_FRONT_AND_BACK				0x0408 */
-#define GL_FRONT_LEFT				0x0400
-#define GL_FRONT_RIGHT				0x0401
-#define GL_BACK_LEFT				0x0402
-#define GL_BACK_RIGHT				0x0403
-#define GL_AUX0					0x0409
-#define GL_AUX1					0x040A
-#define GL_AUX2					0x040B
-#define GL_AUX3					0x040C
-#define GL_COLOR_INDEX				0x1900
-#define GL_RED					0x1903
-#define GL_GREEN				0x1904
-#define GL_BLUE					0x1905
-#define GL_ALPHA				0x1906
-#define GL_LUMINANCE				0x1909
-#define GL_LUMINANCE_ALPHA			0x190A
-#define GL_ALPHA_BITS				0x0D55
-#define GL_RED_BITS				0x0D52
-#define GL_GREEN_BITS				0x0D53
-#define GL_BLUE_BITS				0x0D54
-#define GL_INDEX_BITS				0x0D51
-#define GL_SUBPIXEL_BITS			0x0D50
-#define GL_AUX_BUFFERS				0x0C00
-#define GL_READ_BUFFER				0x0C02
-#define GL_DRAW_BUFFER				0x0C01
-#define GL_DOUBLEBUFFER				0x0C32
-#define GL_STEREO				0x0C33
-#define GL_BITMAP				0x1A00
-#define GL_COLOR				0x1800
-#define GL_DEPTH				0x1801
-#define GL_STENCIL				0x1802
-#define GL_DITHER				0x0BD0
-#define GL_RGB					0x1907
-#define GL_RGBA					0x1908
-
-/* Implementation limits */
-#define GL_MAX_LIST_NESTING			0x0B31
-#define GL_MAX_ATTRIB_STACK_DEPTH		0x0D35
-#define GL_MAX_MODELVIEW_STACK_DEPTH		0x0D36
-#define GL_MAX_NAME_STACK_DEPTH			0x0D37
-#define GL_MAX_PROJECTION_STACK_DEPTH		0x0D38
-#define GL_MAX_TEXTURE_STACK_DEPTH		0x0D39
-#define GL_MAX_EVAL_ORDER			0x0D30
-#define GL_MAX_LIGHTS				0x0D31
-#define GL_MAX_CLIP_PLANES			0x0D32
-#define GL_MAX_TEXTURE_SIZE			0x0D33
-#define GL_MAX_PIXEL_MAP_TABLE			0x0D34
-#define GL_MAX_VIEWPORT_DIMS			0x0D3A
-#define GL_MAX_CLIENT_ATTRIB_STACK_DEPTH	0x0D3B
-
-/* Gets */
-#define GL_ATTRIB_STACK_DEPTH			0x0BB0
-#define GL_CLIENT_ATTRIB_STACK_DEPTH		0x0BB1
-#define GL_COLOR_CLEAR_VALUE			0x0C22
-#define GL_COLOR_WRITEMASK			0x0C23
-#define GL_CURRENT_INDEX			0x0B01
-#define GL_CURRENT_COLOR			0x0B00
-#define GL_CURRENT_NORMAL			0x0B02
-#define GL_CURRENT_RASTER_COLOR			0x0B04
-#define GL_CURRENT_RASTER_DISTANCE		0x0B09
-#define GL_CURRENT_RASTER_INDEX			0x0B05
-#define GL_CURRENT_RASTER_POSITION		0x0B07
-#define GL_CURRENT_RASTER_TEXTURE_COORDS	0x0B06
-#define GL_CURRENT_RASTER_POSITION_VALID	0x0B08
-#define GL_CURRENT_TEXTURE_COORDS		0x0B03
-#define GL_INDEX_CLEAR_VALUE			0x0C20
-#define GL_INDEX_MODE				0x0C30
-#define GL_INDEX_WRITEMASK			0x0C21
-#define GL_MODELVIEW_MATRIX			0x0BA6
-#define GL_MODELVIEW_STACK_DEPTH		0x0BA3
-#define GL_NAME_STACK_DEPTH			0x0D70
-#define GL_PROJECTION_MATRIX			0x0BA7
-#define GL_PROJECTION_STACK_DEPTH		0x0BA4
-#define GL_RENDER_MODE				0x0C40
-#define GL_RGBA_MODE				0x0C31
-#define GL_TEXTURE_MATRIX			0x0BA8
-#define GL_TEXTURE_STACK_DEPTH			0x0BA5
-#define GL_VIEWPORT				0x0BA2
-
-/* Evaluators */
-#define GL_AUTO_NORMAL				0x0D80
-#define GL_MAP1_COLOR_4				0x0D90
-#define GL_MAP1_GRID_DOMAIN			0x0DD0
-#define GL_MAP1_GRID_SEGMENTS			0x0DD1
-#define GL_MAP1_INDEX				0x0D91
-#define GL_MAP1_NORMAL				0x0D92
-#define GL_MAP1_TEXTURE_COORD_1			0x0D93
-#define GL_MAP1_TEXTURE_COORD_2			0x0D94
-#define GL_MAP1_TEXTURE_COORD_3			0x0D95
-#define GL_MAP1_TEXTURE_COORD_4			0x0D96
-#define GL_MAP1_VERTEX_3			0x0D97
-#define GL_MAP1_VERTEX_4			0x0D98
-#define GL_MAP2_COLOR_4				0x0DB0
-#define GL_MAP2_GRID_DOMAIN			0x0DD2
-#define GL_MAP2_GRID_SEGMENTS			0x0DD3
-#define GL_MAP2_INDEX				0x0DB1
-#define GL_MAP2_NORMAL				0x0DB2
-#define GL_MAP2_TEXTURE_COORD_1			0x0DB3
-#define GL_MAP2_TEXTURE_COORD_2			0x0DB4
-#define GL_MAP2_TEXTURE_COORD_3			0x0DB5
-#define GL_MAP2_TEXTURE_COORD_4			0x0DB6
-#define GL_MAP2_VERTEX_3			0x0DB7
-#define GL_MAP2_VERTEX_4			0x0DB8
-#define GL_COEFF				0x0A00
-#define GL_DOMAIN				0x0A02
-#define GL_ORDER				0x0A01
-
-/* Hints */
-#define GL_FOG_HINT				0x0C54
-#define GL_LINE_SMOOTH_HINT			0x0C52
-#define GL_PERSPECTIVE_CORRECTION_HINT		0x0C50
-#define GL_POINT_SMOOTH_HINT			0x0C51
-#define GL_POLYGON_SMOOTH_HINT			0x0C53
-#define GL_DONT_CARE				0x1100
-#define GL_FASTEST				0x1101
-#define GL_NICEST				0x1102
-
-/* Scissor box */
-#define GL_SCISSOR_TEST				0x0C11
-#define GL_SCISSOR_BOX				0x0C10
-
-/* Pixel Mode / Transfer */
-#define GL_MAP_COLOR				0x0D10
-#define GL_MAP_STENCIL				0x0D11
-#define GL_INDEX_SHIFT				0x0D12
-#define GL_INDEX_OFFSET				0x0D13
-#define GL_RED_SCALE				0x0D14
-#define GL_RED_BIAS				0x0D15
-#define GL_GREEN_SCALE				0x0D18
-#define GL_GREEN_BIAS				0x0D19
-#define GL_BLUE_SCALE				0x0D1A
-#define GL_BLUE_BIAS				0x0D1B
-#define GL_ALPHA_SCALE				0x0D1C
-#define GL_ALPHA_BIAS				0x0D1D
-#define GL_DEPTH_SCALE				0x0D1E
-#define GL_DEPTH_BIAS				0x0D1F
-#define GL_PIXEL_MAP_S_TO_S_SIZE		0x0CB1
-#define GL_PIXEL_MAP_I_TO_I_SIZE		0x0CB0
-#define GL_PIXEL_MAP_I_TO_R_SIZE		0x0CB2
-#define GL_PIXEL_MAP_I_TO_G_SIZE		0x0CB3
-#define GL_PIXEL_MAP_I_TO_B_SIZE		0x0CB4
-#define GL_PIXEL_MAP_I_TO_A_SIZE		0x0CB5
-#define GL_PIXEL_MAP_R_TO_R_SIZE		0x0CB6
-#define GL_PIXEL_MAP_G_TO_G_SIZE		0x0CB7
-#define GL_PIXEL_MAP_B_TO_B_SIZE		0x0CB8
-#define GL_PIXEL_MAP_A_TO_A_SIZE		0x0CB9
-#define GL_PIXEL_MAP_S_TO_S			0x0C71
-#define GL_PIXEL_MAP_I_TO_I			0x0C70
-#define GL_PIXEL_MAP_I_TO_R			0x0C72
-#define GL_PIXEL_MAP_I_TO_G			0x0C73
-#define GL_PIXEL_MAP_I_TO_B			0x0C74
-#define GL_PIXEL_MAP_I_TO_A			0x0C75
-#define GL_PIXEL_MAP_R_TO_R			0x0C76
-#define GL_PIXEL_MAP_G_TO_G			0x0C77
-#define GL_PIXEL_MAP_B_TO_B			0x0C78
-#define GL_PIXEL_MAP_A_TO_A			0x0C79
-#define GL_PACK_ALIGNMENT			0x0D05
-#define GL_PACK_LSB_FIRST			0x0D01
-#define GL_PACK_ROW_LENGTH			0x0D02
-#define GL_PACK_SKIP_PIXELS			0x0D04
-#define GL_PACK_SKIP_ROWS			0x0D03
-#define GL_PACK_SWAP_BYTES			0x0D00
-#define GL_UNPACK_ALIGNMENT			0x0CF5
-#define GL_UNPACK_LSB_FIRST			0x0CF1
-#define GL_UNPACK_ROW_LENGTH			0x0CF2
-#define GL_UNPACK_SKIP_PIXELS			0x0CF4
-#define GL_UNPACK_SKIP_ROWS			0x0CF3
-#define GL_UNPACK_SWAP_BYTES			0x0CF0
-#define GL_ZOOM_X				0x0D16
-#define GL_ZOOM_Y				0x0D17
-
-/* Texture mapping */
-#define GL_TEXTURE_ENV				0x2300
-#define GL_TEXTURE_ENV_MODE			0x2200
-#define GL_TEXTURE_1D				0x0DE0
-#define GL_TEXTURE_2D				0x0DE1
-#define GL_TEXTURE_WRAP_S			0x2802
-#define GL_TEXTURE_WRAP_T			0x2803
-#define GL_TEXTURE_MAG_FILTER			0x2800
-#define GL_TEXTURE_MIN_FILTER			0x2801
-#define GL_TEXTURE_ENV_COLOR			0x2201
-#define GL_TEXTURE_GEN_S			0x0C60
-#define GL_TEXTURE_GEN_T			0x0C61
-#define GL_TEXTURE_GEN_MODE			0x2500
-#define GL_TEXTURE_BORDER_COLOR			0x1004
-#define GL_TEXTURE_WIDTH			0x1000
-#define GL_TEXTURE_HEIGHT			0x1001
-#define GL_TEXTURE_BORDER			0x1005
-#define GL_TEXTURE_COMPONENTS			0x1003
-#define GL_TEXTURE_RED_SIZE			0x805C
-#define GL_TEXTURE_GREEN_SIZE			0x805D
-#define GL_TEXTURE_BLUE_SIZE			0x805E
-#define GL_TEXTURE_ALPHA_SIZE			0x805F
-#define GL_TEXTURE_LUMINANCE_SIZE		0x8060
-#define GL_TEXTURE_INTENSITY_SIZE		0x8061
-#define GL_NEAREST_MIPMAP_NEAREST		0x2700
-#define GL_NEAREST_MIPMAP_LINEAR		0x2702
-#define GL_LINEAR_MIPMAP_NEAREST		0x2701
-#define GL_LINEAR_MIPMAP_LINEAR			0x2703
-#define GL_OBJECT_LINEAR			0x2401
-#define GL_OBJECT_PLANE				0x2501
-#define GL_EYE_LINEAR				0x2400
-#define GL_EYE_PLANE				0x2502
-#define GL_SPHERE_MAP				0x2402
-#define GL_DECAL				0x2101
-#define GL_MODULATE				0x2100
-#define GL_NEAREST				0x2600
-#define GL_REPEAT				0x2901
-#define GL_CLAMP				0x2900
-#define GL_S					0x2000
-#define GL_T					0x2001
-#define GL_R					0x2002
-#define GL_Q					0x2003
-#define GL_TEXTURE_GEN_R			0x0C62
-#define GL_TEXTURE_GEN_Q			0x0C63
-
-/* GL 1.1 texturing */
-#define GL_PROXY_TEXTURE_1D			0x8063
-#define GL_PROXY_TEXTURE_2D			0x8064
-#define GL_TEXTURE_PRIORITY			0x8066
-#define GL_TEXTURE_RESIDENT			0x8067
-#define GL_TEXTURE_BINDING_1D			0x8068
-#define GL_TEXTURE_BINDING_2D			0x8069
-#define GL_TEXTURE_INTERNAL_FORMAT		0x1003
-
-/* GL 1.2 texturing */
-#define GL_PACK_SKIP_IMAGES			0x806B
-#define GL_PACK_IMAGE_HEIGHT			0x806C
-#define GL_UNPACK_SKIP_IMAGES			0x806D
-#define GL_UNPACK_IMAGE_HEIGHT			0x806E
-#define GL_TEXTURE_3D				0x806F
-#define GL_PROXY_TEXTURE_3D			0x8070
-#define GL_TEXTURE_DEPTH			0x8071
-#define GL_TEXTURE_WRAP_R			0x8072
-#define GL_MAX_3D_TEXTURE_SIZE			0x8073
-#define GL_TEXTURE_BINDING_3D			0x806A
-
-/* Internal texture formats (GL 1.1) */
-#define GL_ALPHA4				0x803B
-#define GL_ALPHA8				0x803C
-#define GL_ALPHA12				0x803D
-#define GL_ALPHA16				0x803E
-#define GL_LUMINANCE4				0x803F
-#define GL_LUMINANCE8				0x8040
-#define GL_LUMINANCE12				0x8041
-#define GL_LUMINANCE16				0x8042
-#define GL_LUMINANCE4_ALPHA4			0x8043
-#define GL_LUMINANCE6_ALPHA2			0x8044
-#define GL_LUMINANCE8_ALPHA8			0x8045
-#define GL_LUMINANCE12_ALPHA4			0x8046
-#define GL_LUMINANCE12_ALPHA12			0x8047
-#define GL_LUMINANCE16_ALPHA16			0x8048
-#define GL_INTENSITY				0x8049
-#define GL_INTENSITY4				0x804A
-#define GL_INTENSITY8				0x804B
-#define GL_INTENSITY12				0x804C
-#define GL_INTENSITY16				0x804D
-#define GL_R3_G3_B2				0x2A10
-#define GL_RGB4					0x804F
-#define GL_RGB5					0x8050
-#define GL_RGB8					0x8051
-#define GL_RGB10				0x8052
-#define GL_RGB12				0x8053
-#define GL_RGB16				0x8054
-#define GL_RGBA2				0x8055
-#define GL_RGBA4				0x8056
-#define GL_RGB5_A1				0x8057
-#define GL_RGBA8				0x8058
-#define GL_RGB10_A2				0x8059
-#define GL_RGBA12				0x805A
-#define GL_RGBA16				0x805B
-
-/* Utility */
-#define GL_VENDOR				0x1F00
-#define GL_RENDERER				0x1F01
-#define GL_VERSION				0x1F02
-#define GL_EXTENSIONS				0x1F03
-
-/* Errors */
-#define GL_NO_ERROR 				0x0
-#define GL_INVALID_VALUE			0x0501
-#define GL_INVALID_ENUM				0x0500
-#define GL_INVALID_OPERATION			0x0502
-#define GL_STACK_OVERFLOW			0x0503
-#define GL_STACK_UNDERFLOW			0x0504
-#define GL_OUT_OF_MEMORY			0x0505
-
-
-/* OpenGL 1.2 */
-#define GL_RESCALE_NORMAL			0x803A
-#define GL_CLAMP_TO_EDGE			0x812F
-#define GL_MAX_ELEMENTS_VERTICES		0x80E8
-#define GL_MAX_ELEMENTS_INDICES			0x80E9
-#define GL_BGR					0x80E0
-#define GL_BGRA					0x80E1
-#define GL_UNSIGNED_BYTE_3_3_2			0x8032
-#define GL_UNSIGNED_BYTE_2_3_3_REV		0x8362
-#define GL_UNSIGNED_SHORT_5_6_5			0x8363
-#define GL_UNSIGNED_SHORT_5_6_5_REV		0x8364
-#define GL_UNSIGNED_SHORT_4_4_4_4		0x8033
-#define GL_UNSIGNED_SHORT_4_4_4_4_REV		0x8365
-#define GL_UNSIGNED_SHORT_5_5_5_1		0x8034
-#define GL_UNSIGNED_SHORT_1_5_5_5_REV		0x8366
-#define GL_UNSIGNED_INT_8_8_8_8			0x8035
-#define GL_UNSIGNED_INT_8_8_8_8_REV		0x8367
-#define GL_UNSIGNED_INT_10_10_10_2		0x8036
-#define GL_UNSIGNED_INT_2_10_10_10_REV		0x8368
-#define GL_LIGHT_MODEL_COLOR_CONTROL		0x81F8
-#define GL_SINGLE_COLOR				0x81F9
-#define GL_SEPARATE_SPECULAR_COLOR		0x81FA
-#define GL_TEXTURE_MIN_LOD			0x813A
-#define GL_TEXTURE_MAX_LOD			0x813B
-#define GL_TEXTURE_BASE_LEVEL			0x813C
-#define GL_TEXTURE_MAX_LEVEL			0x813D
-#define GL_SMOOTH_POINT_SIZE_RANGE		0x0B12
-#define GL_SMOOTH_POINT_SIZE_GRANULARITY	0x0B13
-#define GL_SMOOTH_LINE_WIDTH_RANGE		0x0B22
-#define GL_SMOOTH_LINE_WIDTH_GRANULARITY	0x0B23
-#define GL_ALIASED_POINT_SIZE_RANGE		0x846D
-#define GL_ALIASED_LINE_WIDTH_RANGE		0x846E
-
-
-
-/*
- * OpenGL 1.2 imaging subset (NOT IMPLEMENTED BY MESA)
- */
-/* GL_EXT_color_table */
-#define GL_COLOR_TABLE				0x80D0
-#define GL_POST_CONVOLUTION_COLOR_TABLE		0x80D1
-#define GL_POST_COLOR_MATRIX_COLOR_TABLE	0x80D2
-#define GL_PROXY_COLOR_TABLE			0x80D3
-#define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE	0x80D4
-#define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE	0x80D5
-#define GL_COLOR_TABLE_SCALE			0x80D6
-#define GL_COLOR_TABLE_BIAS			0x80D7
-#define GL_COLOR_TABLE_FORMAT			0x80D8
-#define GL_COLOR_TABLE_WIDTH			0x80D9
-#define GL_COLOR_TABLE_RED_SIZE			0x80DA
-#define GL_COLOR_TABLE_GREEN_SIZE		0x80DB
-#define GL_COLOR_TABLE_BLUE_SIZE		0x80DC
-#define GL_COLOR_TABLE_ALPHA_SIZE		0x80DD
-#define GL_COLOR_TABLE_LUMINANCE_SIZE		0x80DE
-#define GL_COLOR_TABLE_INTENSITY_SIZE		0x80DF
-/* GL_EXT_convolution and GL_HP_convolution_border_modes */
-#define GL_CONVOLUTION_1D			0x8010
-#define GL_CONVOLUTION_2D			0x8011
-#define GL_SEPARABLE_2D				0x8012
-#define GL_CONVOLUTION_BORDER_MODE		0x8013
-#define GL_CONVOLUTION_FILTER_SCALE		0x8014
-#define GL_CONVOLUTION_FILTER_BIAS		0x8015
-#define GL_REDUCE				0x8016
-#define GL_CONVOLUTION_FORMAT			0x8017
-#define GL_CONVOLUTION_WIDTH			0x8018
-#define GL_CONVOLUTION_HEIGHT			0x8019
-#define GL_MAX_CONVOLUTION_WIDTH		0x801A
-#define GL_MAX_CONVOLUTION_HEIGHT		0x801B
-#define GL_POST_CONVOLUTION_RED_SCALE		0x801C
-#define GL_POST_CONVOLUTION_GREEN_SCALE		0x801D
-#define GL_POST_CONVOLUTION_BLUE_SCALE		0x801E
-#define GL_POST_CONVOLUTION_ALPHA_SCALE		0x801F
-#define GL_POST_CONVOLUTION_RED_BIAS		0x8020
-#define GL_POST_CONVOLUTION_GREEN_BIAS		0x8021
-#define GL_POST_CONVOLUTION_BLUE_BIAS		0x8022
-#define GL_POST_CONVOLUTION_ALPHA_BIAS		0x8023
-#define GL_CONSTANT_BORDER			0x8151
-#define GL_REPLICATE_BORDER			0x8153
-#define GL_CONVOLUTION_BORDER_COLOR		0x8154
-/* GL_SGI_color_matrix */
-#define GL_COLOR_MATRIX				0x80B1
-#define GL_COLOR_MATRIX_STACK_DEPTH		0x80B2
-#define GL_MAX_COLOR_MATRIX_STACK_DEPTH		0x80B3
-#define GL_POST_COLOR_MATRIX_RED_SCALE		0x80B4
-#define GL_POST_COLOR_MATRIX_GREEN_SCALE	0x80B5
-#define GL_POST_COLOR_MATRIX_BLUE_SCALE		0x80B6
-#define GL_POST_COLOR_MATRIX_ALPHA_SCALE	0x80B7
-#define GL_POST_COLOR_MATRIX_RED_BIAS		0x80B8
-#define GL_POST_COLOR_MATRIX_GREEN_BIAS		0x80B9
-#define GL_POST_COLOR_MATRIX_BLUE_BIAS		0x80BA
-#define GL_POST_COLOR_MATRIX_ALPHA_BIAS		0x80BB
-/* GL_EXT_histogram */
-#define GL_HISTOGRAM				0x8024
-#define GL_PROXY_HISTOGRAM			0x8025
-#define GL_HISTOGRAM_WIDTH			0x8026
-#define GL_HISTOGRAM_FORMAT			0x8027
-#define GL_HISTOGRAM_RED_SIZE			0x8028
-#define GL_HISTOGRAM_GREEN_SIZE			0x8029
-#define GL_HISTOGRAM_BLUE_SIZE			0x802A
-#define GL_HISTOGRAM_ALPHA_SIZE			0x802B
-#define GL_HISTOGRAM_LUMINANCE_SIZE		0x802C
-#define GL_HISTOGRAM_SINK			0x802D
-#define GL_MINMAX				0x802E
-#define GL_MINMAX_FORMAT			0x802F
-#define GL_MINMAX_SINK				0x8030
-#define GL_TABLE_TOO_LARGE			0x8031
-/* GL_EXT_blend_color, GL_EXT_blend_minmax */
-#define GL_BLEND_EQUATION			0x8009
-#define GL_MIN					0x8007
-#define GL_MAX					0x8008
-#define GL_FUNC_ADD				0x8006
-#define GL_FUNC_SUBTRACT			0x800A
-#define GL_FUNC_REVERSE_SUBTRACT		0x800B
-#define	GL_BLEND_COLOR				0x8005
-
-
-/* glPush/PopAttrib bits */
-#define GL_CURRENT_BIT				0x00000001
-#define GL_POINT_BIT				0x00000002
-#define GL_LINE_BIT				0x00000004
-#define GL_POLYGON_BIT				0x00000008
-#define GL_POLYGON_STIPPLE_BIT			0x00000010
-#define GL_PIXEL_MODE_BIT			0x00000020
-#define GL_LIGHTING_BIT				0x00000040
-#define GL_FOG_BIT				0x00000080
-#define GL_DEPTH_BUFFER_BIT			0x00000100
-#define GL_ACCUM_BUFFER_BIT			0x00000200
-#define GL_STENCIL_BUFFER_BIT			0x00000400
-#define GL_VIEWPORT_BIT				0x00000800
-#define GL_TRANSFORM_BIT			0x00001000
-#define GL_ENABLE_BIT				0x00002000
-#define GL_COLOR_BUFFER_BIT			0x00004000
-#define GL_HINT_BIT				0x00008000
-#define GL_EVAL_BIT				0x00010000
-#define GL_LIST_BIT				0x00020000
-#define GL_TEXTURE_BIT				0x00040000
-#define GL_SCISSOR_BIT				0x00080000
-#define GL_ALL_ATTRIB_BITS			0x000FFFFF
-
-
-#define GL_CLIENT_PIXEL_STORE_BIT		0x00000001
-#define GL_CLIENT_VERTEX_ARRAY_BIT		0x00000002
-#define GL_ALL_CLIENT_ATTRIB_BITS 		0xFFFFFFFF
-
-/*
- * GL_ARB_multitexture (ARB extension 1 and OpenGL 1.2.1)
- */
-#define GL_TEXTURE0_ARB				0x84C0
-#define GL_TEXTURE1_ARB				0x84C1
-#define GL_TEXTURE2_ARB				0x84C2
-#define GL_TEXTURE3_ARB				0x84C3
-#define GL_TEXTURE4_ARB				0x84C4
-#define GL_TEXTURE5_ARB				0x84C5
-#define GL_TEXTURE6_ARB				0x84C6
-#define GL_TEXTURE7_ARB				0x84C7
-#define GL_TEXTURE8_ARB				0x84C8
-#define GL_TEXTURE9_ARB				0x84C9
-#define GL_TEXTURE10_ARB			0x84CA
-#define GL_TEXTURE11_ARB			0x84CB
-#define GL_TEXTURE12_ARB			0x84CC
-#define GL_TEXTURE13_ARB			0x84CD
-#define GL_TEXTURE14_ARB			0x84CE
-#define GL_TEXTURE15_ARB			0x84CF
-#define GL_TEXTURE16_ARB			0x84D0
-#define GL_TEXTURE17_ARB			0x84D1
-#define GL_TEXTURE18_ARB			0x84D2
-#define GL_TEXTURE19_ARB			0x84D3
-#define GL_TEXTURE20_ARB			0x84D4
-#define GL_TEXTURE21_ARB			0x84D5
-#define GL_TEXTURE22_ARB			0x84D6
-#define GL_TEXTURE23_ARB			0x84D7
-#define GL_TEXTURE24_ARB			0x84D8
-#define GL_TEXTURE25_ARB			0x84D9
-#define GL_TEXTURE26_ARB			0x84DA
-#define GL_TEXTURE27_ARB			0x84DB
-#define GL_TEXTURE28_ARB			0x84DC
-#define GL_TEXTURE29_ARB			0x84DD
-#define GL_TEXTURE30_ARB			0x84DE
-#define GL_TEXTURE31_ARB			0x84DF
-#define GL_ACTIVE_TEXTURE_ARB			0x84E0
-#define GL_CLIENT_ACTIVE_TEXTURE_ARB		0x84E1
-#define GL_MAX_TEXTURE_UNITS_ARB		0x84E2
-
-#define GL_COMBINE                        0x8570
-#define GL_COMBINE_RGB                    0x8571
-#define GL_COMBINE_ALPHA                  0x8572
-#define GL_SOURCE0_RGB                    0x8580
-#define GL_SOURCE1_RGB                    0x8581
-#define GL_SOURCE2_RGB                    0x8582
-#define GL_SOURCE0_ALPHA                  0x8588
-#define GL_SOURCE1_ALPHA                  0x8589
-#define GL_SOURCE2_ALPHA                  0x858A
-#define GL_OPERAND0_RGB                   0x8590
-#define GL_OPERAND1_RGB                   0x8591
-#define GL_OPERAND2_RGB                   0x8592
-#define GL_OPERAND0_ALPHA                 0x8598
-#define GL_OPERAND1_ALPHA                 0x8599
-#define GL_OPERAND2_ALPHA                 0x859A
-#define GL_RGB_SCALE                      0x8573
-#define GL_ADD_SIGNED                     0x8574
-#define GL_INTERPOLATE                    0x8575
-#define GL_SUBTRACT                       0x84E7
-#define GL_CONSTANT                       0x8576
-#define GL_PRIMARY_COLOR                  0x8577
-#define GL_PREVIOUS                       0x8578
-#define GL_DOT3_RGB                       0x86AE
-#define GL_DOT3_RGBA                      0x86AF
-
-
-
-
-
-#endif // #ifndef _X86UNIX_GL_TYPES_H_
diff --git a/Engine/source/platformX86UNIX/platformAL.h b/Engine/source/platformX86UNIX/platformAL.h
deleted file mode 100644
index 8bb7bed85..000000000
--- a/Engine/source/platformX86UNIX/platformAL.h
+++ /dev/null
@@ -1,162 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#ifndef _PLATFORMAL_H_
-#define _PLATFORMAL_H_
-
-#ifndef _PLATFORM_H_
-#include "platform/platform.h"
-#endif
-#define AL_NO_PROTOTYPES
-#include <al/al.h>
-#include <al/alc.h>
-#include <al/alut.h>
-
-// extra enums for win32/miles implementation
-enum {
-   // error values
-   AL_CONTEXT_ALREADY_INSTANTIATED = 0xbaadf00d,
-   AL_ENVIRONMENT_ALREADY_INSTANTIATED,
-   AL_UNSUPPORTED,
-   AL_INVALID_BUFFER,
-   AL_ERROR,
-
-   // context extention
-   ALC_PROVIDER,
-   ALC_PROVIDER_COUNT,
-   ALC_PROVIDER_NAME,
-   ALC_SPEAKER,
-   ALC_SPEAKER_COUNT,
-   ALC_SPEAKER_NAME,
-   ALC_BUFFER_DYNAMIC_MEMORY_SIZE,
-   ALC_BUFFER_DYNAMIC_MEMORY_USAGE,
-   ALC_BUFFER_DYNAMIC_COUNT,
-   ALC_BUFFER_MEMORY_USAGE,
-   ALC_BUFFER_COUNT,
-   ALC_BUFFER_LATENCY,
-
-   // misc 3d params
-   AL_MIN_DISTANCE,
-   AL_MAX_DISTANCE,
-   AL_CONE_OUTER_GAIN,
-   
-   // relative with pos(0,0,0) won't work for ambient sounds with miles
-   AL_SOURCE_AMBIENT,
-   AL_PAN,
-   
-   // other extensions
-   AL_BUFFER_KEEP_RESIDENT,
-   AL_FORMAT_WAVE_EXT,
-
-   // Environment extensions:
-   AL_ENV_EFFECT_VOLUME_EXT,
-   AL_ENV_FLAGS_EXT,
-   AL_ENV_DAMPING_EXT,
-   AL_ENV_ENVIRONMENT_SIZE_EXT,
-   AL_ENV_ROOM_VOLUME_EXT,
-};
-
-enum {
-   // sample level environment:
-   AL_ENV_SAMPLE_REVERB_MIX_EXT = 0,
-   AL_ENV_SAMPLE_DIRECT_EXT,
-   AL_ENV_SAMPLE_DIRECT_HF_EXT,
-   AL_ENV_SAMPLE_ROOM_EXT,
-   AL_ENV_SAMPLE_ROOM_HF_EXT,
-   AL_ENV_SAMPLE_OBSTRUCTION_EXT,
-   AL_ENV_SAMPLE_OBSTRUCTION_LF_RATIO_EXT,
-   AL_ENV_SAMPLE_OCCLUSION_EXT,
-   AL_ENV_SAMPLE_OCCLUSION_LF_RATIO_EXT,
-   AL_ENV_SAMPLE_OCCLUSION_ROOM_RATIO_EXT,
-   AL_ENV_SAMPLE_ROOM_ROLLOFF_EXT,
-   AL_ENV_SAMPLE_AIR_ABSORPTION_EXT,
-   AL_ENV_SAMPLE_OUTSIDE_VOLUME_HF_EXT,
-   AL_ENV_SAMPLE_FLAGS_EXT,
-
-   AL_ENV_SAMPLE_COUNT,
-};
-
-// room types: same as miles/eax
-enum {
-    AL_ENVIRONMENT_GENERIC = 0,
-    AL_ENVIRONMENT_PADDEDCELL,
-    AL_ENVIRONMENT_ROOM,
-    AL_ENVIRONMENT_BATHROOM,
-    AL_ENVIRONMENT_LIVINGROOM,
-    AL_ENVIRONMENT_STONEROOM,
-    AL_ENVIRONMENT_AUDITORIUM,
-    AL_ENVIRONMENT_CONCERTHALL,
-    AL_ENVIRONMENT_CAVE,
-    AL_ENVIRONMENT_ARENA,
-    AL_ENVIRONMENT_HANGAR,
-    AL_ENVIRONMENT_CARPETEDHALLWAY,
-    AL_ENVIRONMENT_HALLWAY,
-    AL_ENVIRONMENT_STONECORRIDOR,
-    AL_ENVIRONMENT_ALLEY,
-    AL_ENVIRONMENT_FOREST,
-    AL_ENVIRONMENT_CITY,
-    AL_ENVIRONMENT_MOUNTAINS,
-    AL_ENVIRONMENT_QUARRY,
-    AL_ENVIRONMENT_PLAIN,
-    AL_ENVIRONMENT_PARKINGLOT,
-    AL_ENVIRONMENT_SEWERPIPE,
-    AL_ENVIRONMENT_UNDERWATER,
-    AL_ENVIRONMENT_DRUGGED,
-    AL_ENVIRONMENT_DIZZY,
-    AL_ENVIRONMENT_PSYCHOTIC,
-
-    AL_ENVIRONMENT_COUNT
-};
-
-// declare OpenAL functions
-#define AL_EXTENSION(ext_name) extern bool gDoesSupport_##ext_name;
-#define AL_FUNCTION(fn_return,fn_name,fn_args) extern fn_return (FN_CDECL *fn_name)fn_args;
-#define AL_EXT_FUNCTION(ext_name,fn_return,fn_name,fn_args) extern fn_return (FN_CDECL *fn_name)fn_args;
-#ifndef _OPENALFN_H_
-#include <openALFn.h>
-#endif
-
-namespace Audio
-{
-
-bool libraryInit(const char *library);
-void libraryInitExtensions();
-void libraryShutdown();
-
-inline bool doesSupportIASIG()
-{
-   return gDoesSupport_AL_EXT_IASIG;
-}   
-
-inline bool doesSupportDynamix()
-{
-   return gDoesSupport_AL_EXT_DYNAMIX;
-}  
-
-// helpers
-F32 DBToLinear(F32 value);
-F32 linearToDB(F32 value);
-
-}  // end namespace Audio
-
-
-#endif  // _H_PLATFORMAL_
diff --git a/Engine/source/platformX86UNIX/threads/mutex.cpp b/Engine/source/platformX86UNIX/threads/mutex.cpp
deleted file mode 100644
index c3d5acfe9..000000000
--- a/Engine/source/platformX86UNIX/threads/mutex.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#include "console/console.h"
-#include "platformX86UNIX/platformX86UNIX.h"
-#include "platform/threads/mutex.h"
-#include "core/util/safeDelete.h"
-
-#include <pthread.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <errno.h>
-
-struct PlatformMutexData
-{
-   pthread_mutex_t mutex;
-};
-
-Mutex::Mutex()
-{
-   mData = new PlatformMutexData;
-   pthread_mutexattr_t attr;
-
-   pthread_mutexattr_init(&attr);
-   pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
-
-   pthread_mutex_init(&mData->mutex, &attr);
-}
-
-Mutex::~Mutex()
-{
-   AssertFatal(mData, "Mutex::destroyMutex: invalid mutex");
-   pthread_mutex_destroy(&mData->mutex);
-   SAFE_DELETE(mData);
-}
-
-bool Mutex::lock(bool block)
-{
-   if(mData == NULL)
-      return false;
-   if(block)
-   {
-	   return pthread_mutex_lock(&mData->mutex) == 0;
-   }
-   else
-   {
-	   return pthread_mutex_trylock(&mData->mutex) == 0;
-   }
-}
-
-void Mutex::unlock()
-{
-   if(mData == NULL)
-      return;
-   pthread_mutex_unlock(&mData->mutex);
-}
diff --git a/Engine/source/platformX86UNIX/threads/semaphore.cpp b/Engine/source/platformX86UNIX/threads/semaphore.cpp
deleted file mode 100644
index 6c994af4d..000000000
--- a/Engine/source/platformX86UNIX/threads/semaphore.cpp
+++ /dev/null
@@ -1,90 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#include "platformX86UNIX/platformX86UNIX.h"
-#include "platform/threads/semaphore.h"
-// Instead of that mess that was here before, lets use the SDL lib to deal
-// with the semaphores.
-
-#include <SDL.h>
-#include <SDL_thread.h>
-
-struct PlatformSemaphore
-{
-   SDL_sem *semaphore;
-
-   PlatformSemaphore(S32 initialCount)
-   {
-       semaphore = SDL_CreateSemaphore(initialCount);
-       AssertFatal(semaphore, "PlatformSemaphore constructor - Failed to create SDL Semaphore.");
-   }
-
-   ~PlatformSemaphore()
-   {
-       SDL_DestroySemaphore(semaphore);
-   }
-};
-
-Semaphore::Semaphore(S32 initialCount)
-{
-  mData = new PlatformSemaphore(initialCount);
-}
-
-Semaphore::~Semaphore()
-{
-  AssertFatal(mData, "Semaphore destructor - Invalid semaphore.");
-  delete mData;
-}
-
-bool Semaphore::acquire(bool block, S32 timeoutMS)
-{
-   AssertFatal(mData && mData->semaphore, "Semaphore::acquire - Invalid semaphore.");
-   if (block)
-   {
-      // Semaphore acquiring is different from the MacOS/Win realization because SDL_SemWaitTimeout() with "infinite" timeout can be too heavy on some platforms.
-      // (see "man SDL_SemWaitTimeout(3)" for more info)
-      // "man" states to avoid the use of SDL_SemWaitTimeout at all, but at current stage this looks like a valid and working solution, so keeping it this way.
-      // [bank / Feb-2010]
-      if (timeoutMS == -1)
-      {
-         if (SDL_SemWait(mData->semaphore) < 0)
-            AssertFatal(false, "Semaphore::acquie - Wait failed.");
-      }
-      else
-      {
-         if (SDL_SemWaitTimeout(mData->semaphore, timeoutMS) < 0)
-            AssertFatal(false, "Semaphore::acquie - Wait with timeout failed.");
-      }
-      return (true);
-   }
-   else
-   {
-      int res = SDL_SemTryWait(mData->semaphore);
-      return (res == 0);
-   }
-}
-
-void Semaphore::release()
-{
-   AssertFatal(mData, "Semaphore::releaseSemaphore - Invalid semaphore.");
-   SDL_SemPost(mData->semaphore);
-}
diff --git a/Engine/source/platformX86UNIX/threads/thread.cpp b/Engine/source/platformX86UNIX/threads/thread.cpp
deleted file mode 100644
index 74e184c91..000000000
--- a/Engine/source/platformX86UNIX/threads/thread.cpp
+++ /dev/null
@@ -1,159 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#include <pthread.h>
-#include "platform/threads/thread.h"
-#include "platform/threads/semaphore.h"
-#include "platform/threads/mutex.h"
-#include <stdlib.h>
-
-class PlatformThreadData
-{
-public:
-   ThreadRunFunction       mRunFunc;
-   void*                   mRunArg;
-   Thread*                 mThread;
-   Semaphore               mGateway; // default count is 1
-   pthread_t               mThreadID;
-   bool                    mDead;
-};
-
-ThreadManager::MainThreadId ThreadManager::smMainThreadId;
-
-//-----------------------------------------------------------------------------
-// Function:    ThreadRunHandler
-// Summary:     Calls Thread::run() with the thread's specified run argument.
-//               Neccesary because Thread::run() is provided as a non-threaded
-//               way to execute the thread's run function. So we have to keep
-//               track of the thread's lock here.
-static void *ThreadRunHandler(void * arg)
-{
-   PlatformThreadData *mData = reinterpret_cast<PlatformThreadData*>(arg);
-   Thread *thread = mData->mThread;
-
-   // mThreadID is filled in twice, once here and once in pthread_create().
-   // We fill in mThreadID here as well as in pthread_create() because addThread()
-   // can execute before pthread_create() returns and sets mThreadID.
-   // The value from pthread_create() and pthread_self() are guaranteed to be equivalent (but not identical)
-   mData->mThreadID = pthread_self();
-   
-   ThreadManager::addThread(thread);
-   thread->run(mData->mRunArg);
-   ThreadManager::removeThread(thread);
-
-   bool autoDelete = thread->autoDelete;
-   
-   mData->mThreadID = 0;
-   mData->mDead = true;
-   mData->mGateway.release();
-   
-   if( autoDelete )
-      delete thread;
-      
-   // return value for pthread lib's benefit
-   return NULL;
-   // the end of this function is where the created pthread will die.
-}
-
-//-----------------------------------------------------------------------------
-Thread::Thread(ThreadRunFunction func, void* arg, bool start_thread, bool autodelete)
-{
-   AssertFatal( !start_thread, "Thread::Thread() - auto-starting threads from ctor has been disallowed since the run() method is virtual" );
-
-   mData = new PlatformThreadData;
-   mData->mRunFunc = func;
-   mData->mRunArg = arg;
-   mData->mThread = this;
-   mData->mThreadID = 0;
-   mData->mDead = false;
-   autoDelete = autodelete;
-}
-
-Thread::~Thread()
-{
-   stop();
-   if( isAlive() )
-      join();
-
-   delete mData;
-}
-
-void Thread::start( void* arg )
-{
-   // cause start to block out other pthreads from using this Thread, 
-   // at least until ThreadRunHandler exits.
-   mData->mGateway.acquire();
-
-   // reset the shouldStop flag, so we'll know when someone asks us to stop.
-   shouldStop = false;
-   
-   mData->mDead = false;
-   
-   if( !mData->mRunArg )
-      mData->mRunArg = arg;
-
-   pthread_create(&mData->mThreadID, NULL, ThreadRunHandler, mData);
-}
-
-bool Thread::join()
-{
-   // not using pthread_join here because pthread_join cannot deal
-   // with multiple simultaneous calls.
-   
-   mData->mGateway.acquire();
-   AssertFatal( !isAlive(), "Thread::join() - thread not dead after join()" );
-   mData->mGateway.release();
-   
-   return true;
-}
-
-void Thread::run(void* arg)
-{
-   if(mData->mRunFunc)
-      mData->mRunFunc(arg);
-}
-
-bool Thread::isAlive()
-{
-   return ( !mData->mDead );
-}
-
-dsize_t Thread::getId()
-{
-   return (dsize_t)mData->mThreadID;
-}
-
-void Thread::_setName( const char* )
-{
-   // Not supported.  Wading through endless lists of Thread-1, Thread-2, Thread-3, ... trying to find
-   // that one thread you are looking for is just so much fun.
-}
-
-dsize_t ThreadManager::getCurrentThreadId()
-{
-   return (dsize_t)pthread_self();
-}
-
-bool ThreadManager::compare(dsize_t threadId_1, dsize_t threadId_2)
-{
-   return pthread_equal((pthread_t)threadId_1, (pthread_t)threadId_2);
-}
diff --git a/Engine/source/platformX86UNIX/x86UNIXAsmBlit.cpp b/Engine/source/platformX86UNIX/x86UNIXAsmBlit.cpp
deleted file mode 100644
index be3dad3b6..000000000
--- a/Engine/source/platformX86UNIX/x86UNIXAsmBlit.cpp
+++ /dev/null
@@ -1,63 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#include "math/mMath.h"
-#include "gfx/bitmap/bitmapUtils.h"
-
-//--------------------------------------------------------------------------
-void bitmapExtrude5551_asm(const void *srcMip, void *mip, U32 height, U32 width)
-{
-   const U16 *src = (const U16 *) srcMip;
-   U16 *dst = (U16 *) mip;
-   U32 stride = width << 1;
-
-   for(U32 y = 0; y < height; y++)
-   {
-      for(U32 x = 0; x < width; x++)
-      {
-         U32 a = src[0];
-         U32 b = src[1];
-         U32 c = src[stride];
-         U32 d = src[stride+1];
-         dst[x] = ((((a >> 11) + (b >> 11) + (c >> 11) + (d >> 11)) >> 2) << 11) |
-                  (((  ((a >> 6) & 0x1f) + ((b >> 6) & 0x1f) + ((c >> 6) & 0x1f) + ((d >> 6) & 0x1F) ) >> 2) << 6) |
-                  ((( ((a >> 1) & 0x1F) + ((b >> 1) & 0x1F) + ((c >> 1) & 0x1f) + ((d >> 1) & 0x1f)) >> 2) << 1);
-         src += 2;
-      }
-      src += stride;
-      dst += width;
-   }
-}
-
-//--------------------------------------------------------------------------
-void PlatformBlitInit()
-{
-   bitmapExtrude5551 = bitmapExtrude5551_asm;
-   bitmapExtrudeRGB  = bitmapExtrudeRGB_c;
-
-   if (Platform::SystemInfo.processor.properties & CPU_PROP_MMX)
-   {
-      // JMQ: haven't bothered porting mmx bitmap funcs because they don't
-      // seem to offer a big performance boost right now.
-   }
-}
-
diff --git a/Engine/source/platformX86UNIX/x86UNIXDlibrary.cpp b/Engine/source/platformX86UNIX/x86UNIXDlibrary.cpp
deleted file mode 100644
index fae1564a2..000000000
--- a/Engine/source/platformX86UNIX/x86UNIXDlibrary.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#include "platform/types.h"
-#include "platform/platformDlibrary.h"
-
-#include <dlfcn.h>
-
-class x86UNIXDLibrary: public DLibrary
-{
-    void*   mLibHandle;
-public:
-    x86UNIXDLibrary();
-    virtual ~x86UNIXDLibrary();
-
-    bool open(const char* file);
-    void close();
-    virtual void *bind(const char *name);
-};
-
-x86UNIXDLibrary::x86UNIXDLibrary()
-{
-    mLibHandle = 0;
-}
-
-x86UNIXDLibrary::~x86UNIXDLibrary()
-{
-    close();
-}
-
-bool x86UNIXDLibrary::open(const char* file)
-{
-    mLibHandle = dlopen(file, RTLD_LAZY);
-    if( !mLibHandle )
-        return false;
-
-    return true;
-}
-
-void x86UNIXDLibrary::close()
-{
-    if( mLibHandle )
-    {
-        dlclose(mLibHandle);
-        mLibHandle = 0;
-    }
-}
-
-void* x86UNIXDLibrary::bind(const char *name)
-{
-    return mLibHandle ? dlsym(mLibHandle, name) : 0;
-}
-
-DLibraryRef OsLoadLibrary(const char* file)
-{
-    x86UNIXDLibrary* library = new x86UNIXDLibrary();
-    if (!library->open(file)) 
-    {
-        delete library;
-        library = 0;
-    }
-    return library;
-}
-
diff --git a/Engine/source/platformX86UNIX/x86UNIXInput.client.cpp b/Engine/source/platformX86UNIX/x86UNIXInput.client.cpp
deleted file mode 100644
index 2776601a7..000000000
--- a/Engine/source/platformX86UNIX/x86UNIXInput.client.cpp
+++ /dev/null
@@ -1,608 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-#ifndef TORQUE_SDL
-#include "platformX86UNIX/platformX86UNIX.h"
-#include "platform/platformInput.h"
-#include "platform/platformVideo.h"
-#include "platform/event.h"
-#include "platform/gameInterface.h"
-#include "console/console.h"
-#include "platformX86UNIX/x86UNIXState.h"
-#include "platformX86UNIX/x86UNIXInputManager.h"
-
-#include <X11/Xlib.h>
-#include <X11/Xatom.h>
-#include <X11/keysym.h>
-
-#include <SDL/SDL.h>
-
-#ifdef LOG_INPUT
-#include <time.h>
-#include <stdarg.h>
-#include <fcntl.h>
-#include <platformX86UNIX/x86UNIXUtils.h>
-
-extern int x86UNIXOpen(const char *path, int oflag);
-extern int x86UNIXClose(int fd);
-extern ssize_t x86UNIXWrite(int fd, const void *buf, size_t nbytes);
-#endif
-
-class XClipboard
-{
-   private:
-      Atom mClipboardProperty;
-      Atom mClipboard;
-      Atom mPrimary;
-      bool mInitialized;
-      U8 *mXData;
-      char *mTData;
-      S32 mTDataSize;
-
-      void init();
-      void freeXData();
-      void freeTData();
-      void checkTDataSize(S32 requestedSize);
-   public:
-      XClipboard();
-      ~XClipboard();
-
-      bool setClipboard(const char *text);
-      const char* getClipboard();
-      void handleSelectionRequest(XSelectionRequestEvent& request);
-};
-
-// Static class variables:
-InputManager*  Input::smManager;
-
-// smActive is not maintained under unix.  Use Input::isActive()
-// instead
-bool           Input::smActive = false;
-
-// unix platform state
-extern x86UNIXPlatformState * x86UNIXState;
-
-extern AsciiData AsciiTable[NUM_KEYS];
-
-static XClipboard xclipboard;
-
-#ifdef LOG_INPUT
-S32 gInputLog = -1;
-#endif 
-
-//------------------------------------------------------------------------------
-void Input::init()
-{
-   Con::printf( "Input Init:" );
-
-   destroy();
-
-#ifdef LOG_INPUT
-   struct tm* newTime;
-   time_t aclock;
-   time( &aclock );
-   newTime = localtime( &aclock );
-   asctime( newTime );
-
-   gInputLog = x86UNIXOpen("input.log", O_WRONLY | O_CREAT);
-   log("Input log opened at %s\n", asctime( newTime ) );
-   log("Operating System:\n" );
-   log("  %s", UUtils->getOSName());
-   log("\n");
-#endif
-
-   smActive = false;
-   smManager = NULL;
-
-   UInputManager *uInputManager = new UInputManager;
-   if ( !uInputManager->enable() )
-   {
-      Con::errorf( "   Failed to enable Input Manager." );
-      delete uInputManager;
-      return;
-   }
-
-   uInputManager->init();
-
-   smManager = uInputManager;
-
-   Con::printf("   Input initialized");
-   Con::printf(" ");
-}
-
-//------------------------------------------------------------------------------
-ConsoleFunction( isJoystickDetected, bool, 1, 1, "isJoystickDetected()" )
-{
-   argc; argv;
-   UInputManager* manager = dynamic_cast<UInputManager*>(Input::getManager());
-   if (manager)
-      return manager->joystickDetected();
-   else
-      return false;
-}
-
-//------------------------------------------------------------------------------
-ConsoleFunction( getJoystickAxes, const char*, 2, 2, "getJoystickAxes( instance )" )
-{
-   argc; argv;
-   UInputManager* manager = dynamic_cast<UInputManager*>(Input::getManager());
-   if (manager)
-      return manager->getJoystickAxesString(dAtoi(argv[1]));
-   else
-      return "";
-}
-
-//------------------------------------------------------------------------------
-U16 Input::getKeyCode( U16 asciiCode )
-{
-   U16 keyCode = 0;
-   U16 i;
-   
-   // This is done three times so the lowerkey will always
-   // be found first. Some foreign keyboards have duplicate
-   // chars on some keys.
-   for ( i = KEY_FIRST; i < NUM_KEYS && !keyCode; i++ )
-   {
-      if ( AsciiTable[i].lower.ascii == asciiCode )
-      {
-         keyCode = i;
-         break;
-      };
-   }
-
-   for ( i = KEY_FIRST; i < NUM_KEYS && !keyCode; i++ )
-   {
-      if ( AsciiTable[i].upper.ascii == asciiCode )
-      {
-         keyCode = i;
-         break;
-      };
-   }
-
-   for ( i = KEY_FIRST; i < NUM_KEYS && !keyCode; i++ )
-   {
-      if ( AsciiTable[i].goofy.ascii == asciiCode )
-      {
-         keyCode = i;
-         break;
-      };
-   }
-
-   return( keyCode );
-}
-
-//-----------------------------------------------------------------------------
-//
-// This function gets the standard ASCII code corresponding to our key code
-// and the existing modifier key state.
-//
-//-----------------------------------------------------------------------------
-U16 Input::getAscii( U16 keyCode, KEY_STATE keyState )
-{
-   if ( keyCode >= NUM_KEYS )
-      return 0;
-
-   switch ( keyState )
-   {
-      case STATE_LOWER:
-         return AsciiTable[keyCode].lower.ascii;
-      case STATE_UPPER:
-         return AsciiTable[keyCode].upper.ascii;
-      case STATE_GOOFY:
-         return AsciiTable[keyCode].goofy.ascii;
-      default:
-         return(0);
-            
-   }
-}
-
-//------------------------------------------------------------------------------
-void Input::destroy()
-{   
-#ifdef LOG_INPUT
-   if ( gInputLog != -1 )
-   {
-      log( "*** CLOSING LOG ***\n" );
-      x86UNIXClose(gInputLog);
-      gInputLog = -1;
-   }
-#endif
-
-   if ( smManager && smManager->isEnabled() )
-   {
-      smManager->disable();
-      delete smManager;
-      smManager = NULL;
-   }
-}
-
-//------------------------------------------------------------------------------
-bool Input::enable()
-{   
-   if ( smManager && !smManager->isEnabled() )
-      return( smManager->enable() );
-   
-   return( false );
-}
-
-//------------------------------------------------------------------------------
-void Input::disable()
-{
-   if ( smManager && smManager->isEnabled() )
-      smManager->disable();
-}
-
-//------------------------------------------------------------------------------
-void Input::activate()
-{
-   if ( smManager && smManager->isEnabled() && !isActive())
-   {
-#ifdef LOG_INPUT
-      Input::log( "Activating Input...\n" );
-#endif
-      UInputManager* uInputManager = dynamic_cast<UInputManager*>( smManager );
-      if ( uInputManager )
-         uInputManager->activate();
-   }
-}
-
-//------------------------------------------------------------------------------
-void Input::deactivate()
-{
-   if ( smManager && smManager->isEnabled() && isActive() )
-   {
-#ifdef LOG_INPUT
-      Input::log( "Deactivating Input...\n" );
-#endif
-      UInputManager* uInputManager = dynamic_cast<UInputManager*>( smManager );
-      if ( uInputManager )
-         uInputManager->deactivate();
-   }
-}
-
-//------------------------------------------------------------------------------
-void Input::reactivate()
-{
-   Input::deactivate();
-   Input::activate();
-}
-
-//------------------------------------------------------------------------------
-bool Input::isEnabled()
-{
-   if ( smManager )
-      return smManager->isEnabled();
-   return false;
-}
-
-//------------------------------------------------------------------------------
-bool Input::isActive()
-{
-   UInputManager* uInputManager = dynamic_cast<UInputManager*>( smManager );
-   if ( uInputManager )
-      return uInputManager->isActive();
-   return false;
-}
-
-//------------------------------------------------------------------------------
-void Input::process()
-{
-   if ( smManager )
-      smManager->process();
-}
-
-//------------------------------------------------------------------------------
-InputManager* Input::getManager()
-{
-   return smManager;
-}
-
-#ifdef LOG_INPUT
-//------------------------------------------------------------------------------
-void Input::log( const char* format, ... )
-{
-   if ( gInputLog == -1)
-      return;
-   
-   va_list argptr;
-   va_start( argptr, format );
-
-   const int BufSize = 4096;
-   char buffer[BufSize];
-   dVsprintf( buffer, BufSize, format, argptr );
-   x86UNIXWrite(gInputLog, buffer, dStrlen( buffer ));
-   va_end( argptr );
-}
-
-ConsoleFunction( inputLog, void, 2, 2, "inputLog( string )" )
-{
-   argc;
-   Input::log( "%s\n", (const char*)argv[1] );
-}
-#endif // LOG_INPUT
-
-//------------------------------------------------------------------------------
-void NotifySelectionEvent(XEvent& event)
-{
-   // somebody sent us a select event
-   if (event.type == SelectionRequest)
-      xclipboard.handleSelectionRequest(event.xselectionrequest);
-}
-
-//------------------------------------------------------------------------------
-const char* Platform::getClipboard()
-{
-   return xclipboard.getClipboard();
-}
-
-//------------------------------------------------------------------------------
-bool Platform::setClipboard(const char *text)
-{
-   return xclipboard.setClipboard(text);
-}
-
-//-----------------------------------------------------------------------------
-// XClipboard members
-XClipboard::XClipboard()
-{
-   mInitialized = false;
-   mXData = 0;
-   mTData = 0;
-   mTDataSize = 0;
-}
-
-//------------------------------------------------------------------------------
-XClipboard::~XClipboard()
-{
-   freeXData();
-   freeTData();
-}
-
-//------------------------------------------------------------------------------
-void XClipboard::init()
-{
-   DisplayPtrManager xdisplay;
-   Display* display = xdisplay.getDisplayPointer();
-
-   mClipboardProperty = XInternAtom(display, 
-      "TORQUE_CLIPBOARD_ATOM", False);
-   mClipboard = XInternAtom(display, "CLIPBOARD", 
-      False);
-   mPrimary = XA_PRIMARY; //XInternAtom(display, "PRIMARY", False);
-   mXData = NULL;
-   mTData = NULL;
-   mTDataSize = 0;
-
-   mInitialized = true;
-}
-
-//------------------------------------------------------------------------------
-inline void XClipboard::freeXData()
-{
-   if (mXData != NULL)
-   {
-      XFree(mXData);
-      mXData = NULL;
-   }
-}
-
-//------------------------------------------------------------------------------
-inline void XClipboard::freeTData()
-{
-   if (mTData != NULL)
-   {
-      dRealFree(mTData);
-      mTData = NULL;
-      mTDataSize = 0;
-   }
-}
-
-//
-// JMQ: As you might expect, X clipboard usage is bizarre.  I 
-// found this document to be useful.
-//
-// http://www.freedesktop.org/standards/clipboards.txt 
-//
-// JMQ: later note: programming the X clipboard is not just
-// bizarre, it SUCKS.  No wonder so many apps have
-// clipboard problems.
-//
-//------------------------------------------------------------------------------
-const char* XClipboard::getClipboard()
-{
-   DisplayPtrManager xdisplay;
-   Display* display = xdisplay.getDisplayPointer();
-
-   if (!mInitialized)
-      init();
-
-   // find the owner of the clipboard
-   Atom targetSelection = mClipboard;
-   Window clipOwner = XGetSelectionOwner(display, 
-      targetSelection);
-   if (clipOwner == None)
-   {
-      // It seems like KDE/QT reads the clipboard but doesn't set it.
-      // This is a bug, that supposedly will be fixed in QT3.
-      // I tried working around this by using
-      // PRIMARY instead of CLIPBOARD, but this has some nonintuitive
-      // side effects.  So, no pasting from KDE apps for now.
-      //targetSelection = mPrimary;
-      //clipOwner = XGetSelectionOwner(display, targetSelection);
-   }
-
-   if (clipOwner == None)
-      // oh well
-      return "";
-
-   // request that the owner convert the selection to a string
-   XConvertSelection(display, targetSelection, 
-      XA_STRING, mClipboardProperty, x86UNIXState->getWindow(), CurrentTime);
-
-   // flush the output buffer to make sure the selection request event gets 
-   // sent now
-   XFlush(display);
-
-   XEvent xevent;
-
-   // if our window is the current owner, (e.g. copy from one part of
-   // torque and paste to another), then we just sent an event to our
-   // window that won't get processed until we get back to the event
-   // loop in x86Unixwindow.  So look for selection request events in
-   // the event queue immediately and handle them.
-   while (XCheckTypedWindowEvent(display, 
-             x86UNIXState->getWindow(), SelectionRequest, &xevent))
-      handleSelectionRequest(xevent.xselectionrequest);
-  
-   // poll for the SelectionNotify event for 5 seconds.  in most cases 
-   // we should get the event very quickly
-   U32 startTime = Platform::getRealMilliseconds();
-   bool timeOut = false;
-   while (!XCheckTypedWindowEvent(display, 
-             x86UNIXState->getWindow(), SelectionNotify, &xevent) &&
-      !timeOut)
-   {
-      // we'll be spinning here, but who cares
-      if ((Platform::getRealMilliseconds() - startTime) > 5000)
-         timeOut = true;
-   }
-
-   if (timeOut)
-   {
-      Con::warnf(ConsoleLogEntry::General, 
-         "XClipboard: waited too long for owner to convert selection");
-      return "";
-   }
-
-   if (xevent.xselection.property == None)
-      return "";
-
-   // free the X data from a previous get
-   freeXData();
-
-   // grab the string data from the property 
-   Atom actual_type;
-   int actual_format;
-   unsigned long bytes_after;
-   unsigned long nitems;
-   // query the property length the 250000 is "the length in 32-bit
-   // multiples of the data to be retrieved".  so we support up to a
-   // million bytes of returned data.
-   int numToRetrieve = 250000;
-   int status = XGetWindowProperty(display, 
-      x86UNIXState->getWindow(),
-      mClipboardProperty, 0, numToRetrieve, True, XA_STRING, 
-      &actual_type, &actual_format, &nitems, &bytes_after, &mXData);
-
-   // we should have returned OK, with string type, 8bit data,
-   // and > 0 items.
-   if ((status != Success) || (actual_type != XA_STRING) || 
-      (actual_format != 8) || (nitems == 0))
-      return "";
-
-   // if there is data left in the clipboard, warn about it
-   if (bytes_after > 0)
-      Con::warnf(ConsoleLogEntry::General, 
-         "XClipboard: some data was not retrieved");
-
-   return reinterpret_cast<const char *>(mXData);
-}
-
-//------------------------------------------------------------------------------
-void XClipboard::checkTDataSize(S32 requestedSize)
-{
-   if (mTDataSize < requestedSize)
-   {
-      freeTData();
-      mTData = static_cast<char*>(dRealMalloc(sizeof(char) * requestedSize));
-      AssertFatal(mTData, "unable to allocate clipboard buffer data!");
-      mTDataSize = requestedSize;
-   }
-}
-
-//------------------------------------------------------------------------------
-bool XClipboard::setClipboard(const char *text)
-{
-   DisplayPtrManager xdisplay;
-   Display* display = xdisplay.getDisplayPointer();
-
-   if (!mInitialized)
-      init();
-
-   // get the length of the text
-   S32 len = dStrlen(text) + 1;
-   
-   // reallocate the storage buffer if necessary
-   checkTDataSize(len);
-
-   // copy the data into the storage buffer
-   dStrcpy(mTData, text, mTDataSize);
-
-   // tell X that we own the clipboard.  (we'll get events
-   // if an app tries to paste)
-   XSetSelectionOwner(display, mClipboard, 
-      x86UNIXState->getWindow(), CurrentTime);
-
-   return true;
-}
-
-//------------------------------------------------------------------------------
-void XClipboard::handleSelectionRequest(XSelectionRequestEvent& request)
-{
-   DisplayPtrManager xdisplay;
-   Display* display = xdisplay.getDisplayPointer();
-
-   // init our response
-   XSelectionEvent notify;
-
-   notify.type = SelectionNotify;
-   notify.display = display;
-   notify.requestor = request.requestor;
-   notify.selection = request.selection;
-   notify.target = XA_STRING;
-   notify.property = None;
-   notify.time = CurrentTime;
-
-   // make sure the owner is our window, and that the
-   // requestor wants the clipboard
-   if (request.owner == x86UNIXState->getWindow() && 
-      request.selection == mClipboard)
-   {
-      notify.property = request.property;
-      // check to see if they did not set the property
-      if (notify.property == None)
-         notify.property = mClipboardProperty;
-
-      // get the length of the data in the clipboard
-      S32 length = dStrlen(mTData);
-      // set the property on the requestor window
-      XChangeProperty(display, request.requestor, 
-         notify.property, XA_STRING,
-         8, PropModeReplace, reinterpret_cast<const unsigned char*>(mTData), 
-         length);
-   }
-   XSendEvent(display, notify.requestor, False, 0, 
-      reinterpret_cast<XEvent*>(&notify));
-
-   // flush the output buffer to send the event now
-   XFlush(display);
-}
-#endif
diff --git a/Engine/source/platformX86UNIX/x86UNIXInputManager.h b/Engine/source/platformX86UNIX/x86UNIXInputManager.h
deleted file mode 100644
index 1df78c9a5..000000000
--- a/Engine/source/platformX86UNIX/x86UNIXInputManager.h
+++ /dev/null
@@ -1,190 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#ifndef _X86UNIXINPUTMANAGER_H_
-#define _X86UNIXINPUTMANAGER_H_
-
-#include "core/util/tVector.h"
-#include "platform/platformInput.h"
-#include "platformX86UNIX/platformX86UNIX.h"
-
-#include <SDL/SDL_events.h>
-
-#define NUM_KEYS ( KEY_OEM_102 + 1 )
-#define KEY_FIRST KEY_ESCAPE
-
-struct AsciiData
-{
-   struct KeyData
-   {
-      U16   ascii;
-      bool  isDeadChar;
-   };
-
-   KeyData upper;
-   KeyData lower;
-   KeyData goofy;
-};
-
-struct _SDL_Joystick;
-
-struct JoystickAxisInfo
-{
-      S32 type;
-      S32 minValue;
-      S32 maxValue;
-};
-
-//------------------------------------------------------------------------------
-class JoystickInputDevice : public InputDevice
-{   
-  public:
-    JoystickInputDevice(U8 deviceID);
-    ~JoystickInputDevice();
-    
-    bool activate();
-    bool deactivate();
-    bool isActive() { return( mActive ); }
-    
-    U8 getDeviceType() { return( JoystickDeviceType ); }
-    U8 getDeviceID() { return( mDeviceID ); }
-    const char* getName();
-    const char* getJoystickAxesString();
-
-    void loadJoystickInfo();
-    void loadAxisInfo();
-    JoystickAxisInfo& getAxisInfo(int axisNum) { return mAxisList[axisNum]; }
-
-    bool process();
-    void reset();
-    
-  private:
-    bool mActive;
-    U8 mDeviceID;
-    SDL_Joystick* mStick;
-    Vector<JoystickAxisInfo> mAxisList;
-    Vector<bool> mButtonState;
-    Vector<U8> mHatState;
-
-    S32 mNumAxes; 
-    S32 mNumButtons;
-    S32 mNumHats;
-    S32 mNumBalls;
-};
-
-//------------------------------------------------------------------------------
-class UInputManager : public InputManager
-{
-   friend bool JoystickInputDevice::process(); // for joystick event funcs
-   friend void JoystickInputDevice::reset(); 
-
-   public:
-      UInputManager();
-
-      void init();
-      bool enable();
-      void disable();
-      void activate();
-      void deactivate();
-      void setWindowLocked(bool locked);
-      bool isActive()               { return( mActive ); }
-
-      void onDeleteNotify( SimObject* object );
-      bool onAdd();
-      void onRemove();
-
-      void process();
-
-      bool enableKeyboard();
-      void disableKeyboard();
-      bool isKeyboardEnabled()      { return( mKeyboardEnabled ); }
-      bool activateKeyboard();
-      void deactivateKeyboard();
-      bool isKeyboardActive()       { return( mKeyboardActive ); }
-
-      bool enableMouse();
-      void disableMouse();
-      bool isMouseEnabled()         { return( mMouseEnabled ); }
-      bool activateMouse();
-      void deactivateMouse();
-      bool isMouseActive()          { return( mMouseActive ); }          
-
-      bool enableJoystick();
-      void disableJoystick();
-      bool isJoystickEnabled()      { return( mJoystickEnabled ); }
-      bool activateJoystick();
-      void deactivateJoystick();
-      bool isJoystickActive()       { return( mJoystickActive ); }          
-
-      void setLocking(bool enabled);
-      bool getLocking() { return mLocking; }
-
-      const char* getJoystickAxesString( U32 deviceID );
-      bool joystickDetected()       { return mJoystickList.size() > 0; }
-   private:
-      typedef SimGroup Parent;
-      // the following vector is just for quick access during event processing.
-      // it does not manage the cleanup of the JoystickInputDevice objects
-      Vector<JoystickInputDevice*> mJoystickList;
-
-      bool mKeyboardEnabled;
-      bool mMouseEnabled;
-      bool mJoystickEnabled;
-
-      bool mKeyboardActive;
-      bool mMouseActive;
-      bool mJoystickActive;
-
-      bool mActive;
-
-      // Device state variables
-      S32 mModifierKeys;
-      bool mKeyboardState[256];
-      bool mMouseButtonState[3];
-
-      // last mousex and y are maintained when window is unlocked
-      S32 mLastMouseX;
-      S32 mLastMouseY;
-
-      void initJoystick();
-
-      void resetKeyboardState();
-      void resetMouseState();
-      void resetInputState();
-
-      void lockInput();
-      void unlockInput();
-      bool mLocking;
-
-      void joyHatEvent(U8 deviceID, U8 hatNum, 
-          U8 prevHatState, U8 currHatState);
-      void joyButtonEvent(U8 deviceID, U8 buttonNum, bool pressed);
-      void joyButtonEvent(const SDL_Event& event);
-      void joyAxisEvent(const SDL_Event& event);
-      void joyAxisEvent(U8 deviceID, U8 axisNum, S16 axisValue);
-      void mouseButtonEvent(const SDL_Event& event);
-      void mouseMotionEvent(const SDL_Event& event);
-      void keyEvent(const SDL_Event& event);
-      bool processKeyEvent(InputEventInfo &event);
-};
-
-#endif  // _H_X86UNIXINPUTMANAGER_
diff --git a/Engine/source/platformX86UNIX/x86UNIXMessageBox.client.cpp b/Engine/source/platformX86UNIX/x86UNIXMessageBox.client.cpp
deleted file mode 100644
index 05d2b17ff..000000000
--- a/Engine/source/platformX86UNIX/x86UNIXMessageBox.client.cpp
+++ /dev/null
@@ -1,507 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-#include <X11/Xatom.h>
-
-#include "platformX86UNIX/x86UNIXMessageBox.h"
-
-#define MessageBox_MaxWinWidth 800
-#define MessageBox_MaxWinHeight 600
-#define MessageBox_MinWinWidth 450
-
-#define MessageBox_ButtonBoxWidth 60
-#define MessageBox_ButtonBoxHeight 22
-#define MessageBox_ButtonSpacer 20
-#define MessageBox_ButtonVMargin 10
-#define MessageBox_ButtonHMargin 10
-
-#define MessageBox_LineSpacer 2
-#define MessageBox_LineVMargin 10
-#define MessageBox_LineHMargin 10
-
-XMessageBoxButton::XMessageBoxButton()
-{
-   strcpy(mLabel, "");
-   mClickVal = -1;
-   mLabelWidth = mX = mY = mWidth = mHeight = mMouseX = mMouseX = -1;
-   mMouseDown = false;
-}
-
-XMessageBoxButton::XMessageBoxButton(const char* label, int clickVal)
-{
-   strncpy(mLabel, label, LabelSize);
-   mClickVal = clickVal;
-   mLabelWidth = mX = mY = mWidth = mHeight = mMouseX = mMouseX = -1;
-   mMouseDown = false;
-}
-
-XMessageBox::XMessageBox(Display* display)
-{
-   mMessage = "";
-   mFS = NULL;
-   mDisplay = display;
-}
-
-XMessageBox::~XMessageBox()
-{
-   clearMessageLines();
-   if (mDisplay != NULL)
-   {
-      mDisplay = NULL;
-   }
-}
-
-int XMessageBox::alertOK(const char *windowTitle, const char *message)
-{
-   mMessage = message;
-   mTitle = windowTitle;
-   mButtons.clear();
-   mButtons.push_back(XMessageBoxButton("OK", OK));
-   return show();
-}
-
-int XMessageBox::alertOKCancel(const char *windowTitle, const char *message)
-{
-   mMessage = message;
-   mTitle = windowTitle;
-   mButtons.clear();
-   mButtons.push_back(XMessageBoxButton("OK", OK));
-   mButtons.push_back(XMessageBoxButton("Cancel", Cancel));
-   return show();
-}
-
-int XMessageBox::alertRetryCancel(const char *windowTitle, const char *message)
-{
-   mMessage = message;
-   mTitle = windowTitle;
-   mButtons.clear();
-   mButtons.push_back(XMessageBoxButton("Retry", Retry));
-   mButtons.push_back(XMessageBoxButton("Cancel", Cancel));
-   return show();
-}
-
-int XMessageBox::alertAssert(const char *windowTitle, const char *message)
-{
-    mMessage = message;
-    mTitle = windowTitle;
-    mButtons.clear();
-    mButtons.push_back(XMessageBoxButton("Exit", OK));
-    mButtons.push_back(XMessageBoxButton("Ignore", Cancel));
-    mButtons.push_back(XMessageBoxButton("Ignore All", IgnoreAll));
-    mButtons.push_back(XMessageBoxButton("Debug", Retry));
-    return show();
-}
-
-void XMessageBox::repaint()
-{
-   int white = WhitePixel(mDisplay, DefaultScreen(mDisplay));
-   int black = BlackPixel(mDisplay, DefaultScreen(mDisplay));
-
-   int x = 0;
-   int y = 0;
-
-   // line V margin
-   y = y + MessageBox_LineVMargin * 2;
-
-   // line H margin 
-   x = MessageBox_LineHMargin;
-
-   XSetForeground(mDisplay, mGC, black);
-   for (unsigned int i = 0; i < mMessageLines.size(); ++i)
-   {
-      XDrawString(mDisplay, mWin, mGC, x, y, mMessageLines[i], 
-         strlen(mMessageLines[i]));
-      if (i < (mMessageLines.size() - 1))
-         y = y + MessageBox_LineSpacer + mFontHeight;
-   }
-   XFlush(mDisplay);
-
-   // line V margin
-   y = y + MessageBox_LineVMargin;
-
-   int maxButWidth = MessageBox_ButtonBoxWidth;
-   int maxButHeight = MessageBox_ButtonBoxHeight;
-
-   // compute size of text labels on buttons
-   int fgColor, bgColor;
-
-   int fontDirection, fontAscent, fontDescent;
-   Vector<XMessageBoxButton>::iterator iter;
-   for (iter = mButtons.begin(); iter != mButtons.end(); ++iter)
-   {
-      XCharStruct strInfo;
-      XTextExtents(mFS, iter->getLabel(), strlen(iter->getLabel()), 
-         &fontDirection, &fontAscent, &fontDescent,
-         &strInfo);
-//       if (maxButWidth < strInfo.width)
-//          maxButWidth = strInfo.width;
-//       if (maxButHeight < (strInfo.ascent + strInfo.descent))
-//          maxButHeight = (strInfo.ascent + strInfo.descent);
-      iter->setLabelWidth(strInfo.width);
-   }
-   int buttonBoxWidth = maxButWidth;
-   int buttonBoxHeight = maxButHeight;
-
-   // draw buttons
-   // button V margin
-   y = y + MessageBox_ButtonVMargin;
-
-   // center the buttons 
-   x = MessageBox_ButtonHMargin + (mMBWidth - getButtonLineWidth()) / 2;
-
-   for (iter = mButtons.begin(); iter != mButtons.end(); ++iter)
-   {
-      if (iter->drawReverse())
-      {
-         fgColor = white;
-         bgColor = black;
-      }
-      else
-      {
-         fgColor = black;
-         bgColor = white;
-      }
-
-      XSetForeground(mDisplay, mGC, bgColor);
-      XFillRectangle(mDisplay, mWin, mGC, x, y, 
-         buttonBoxWidth, buttonBoxHeight);
-      XSetForeground(mDisplay, mGC, fgColor);
-      XDrawRectangle(mDisplay, mWin, mGC, x, y, 
-         buttonBoxWidth, buttonBoxHeight);
-      XDrawString(mDisplay, mWin, mGC, 
-         x + ((buttonBoxWidth - iter->getLabelWidth()) / 2),
-         y + mFontAscent + ((buttonBoxHeight - mFontAscent) / 2),
-         iter->getLabel(),
-         strlen(iter->getLabel()));
-      iter->setButtonRect(x, y, buttonBoxWidth, buttonBoxHeight);
-      x = x + buttonBoxWidth + MessageBox_ButtonSpacer;
-   }   
-}
-
-template <class Type>
-static inline Type max(Type v1, Type v2)
-{
-   if (v1 <= v2)
-      return v2;
-   else
-      return v1;
-}
-
-template <class Type>
-static inline Type min(Type v1, Type v2)
-{
-   if (v1 > v2)
-      return v2;
-   else
-      return v1;
-}
-
-void XMessageBox::clearMessageLines()
-{
-   Vector<char*>::iterator iter;
-   for (iter = mMessageLines.begin(); iter != mMessageLines.end(); ++iter)
-      delete [] *iter;
-   mMessageLines.clear();
-}
-
-void XMessageBox::splitMessage()
-{
-   clearMessageLines();
-   if (mMessage == NULL || strlen(mMessage)==0)
-      // JMQTODO: what to do with empty strings?
-      return;
-
-   // need to break message up in to lines, and store lines in 
-   // mMessageLines
-
-   int numChars = strlen(mMessage);
-   const int ScratchBufSize = 2048;
-   char scratchBuf[ScratchBufSize];
-   memset(scratchBuf, 0, ScratchBufSize);
-
-   int fontDirection, fontAscent, fontDescent;
-   XCharStruct strInfo;
-
-   char *curChar = const_cast<char*>(mMessage);
-   char *endChar;
-   char *curWrapped = scratchBuf;
-   int curWidth = 0;
-   int maxWidth = mMaxWindowWidth - (MessageBox_LineHMargin);
-
-   while ( // while pointers are in range...
-      (curChar - mMessage) < numChars &&
-      (curWrapped - scratchBuf) < ScratchBufSize)
-   {
-      // look for next space in remaining string
-      endChar = index(curChar, ' ');
-      if (endChar == NULL)
-         endChar = index(curChar, '\0');
-
-      if (endChar != NULL)
-         // increment one char past the space to include it
-         endChar++;
-      else
-         // otherwise, set the endchar to one char ahead
-         endChar = curChar + 1;
-
-      // compute length of substr
-      int len = endChar - curChar;
-      XTextExtents(mFS, curChar, len, 
-         &fontDirection, &fontAscent, &fontDescent,
-         &strInfo);
-      // if its too big, time to add a new line...
-      if ((curWidth + strInfo.width) > maxWidth)
-      {
-         // create a new block for the line and add it
-         *curWrapped = '\0';
-         int len = strlen(scratchBuf);
-         char* line = new char[len+1];
-         strncpy(line, scratchBuf, len+1); // +1 gets the null char
-         mMessageLines.push_back(line);
-         
-         // reset curWrapped to the beginning of the scratch buffer
-         curWrapped = scratchBuf;
-         curWidth = 0;
-      }
-      // copy the current string into curWrapped if we have enough room
-      int bytesRemaining = 
-         ScratchBufSize - (curWrapped - scratchBuf);
-      if (bytesRemaining >= len)
-         strncpy(curWrapped, curChar, len);
-
-      curWrapped += len;
-      curWidth += strInfo.width;
-      curChar = endChar;
-   }
-
-   // make a final line out of any leftover stuff in the scratch buffer
-   if (curWrapped != scratchBuf)
-   {
-      *curWrapped = '\0';
-      int len = strlen(scratchBuf);
-      char* line = new char[len+1];
-      strncpy(line, scratchBuf, len+1); // +1 gets the null char
-      mMessageLines.push_back(line);
-   }
-}
-
-int XMessageBox::loadFont()
-{
-  // load the font
-   mFS = XLoadQueryFont(mDisplay, 
-      "-*-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*");
-   
-   if (mFS == NULL)
-      mFS = XLoadQueryFont(mDisplay, "fixed");
-
-   if (mFS == NULL)
-      return -1;
-
-   // dummy call to XTextExtents to get the font specs
-   XCharStruct strInfo;
-   
-   XTextExtents(mFS, "foo", 1, 
-      &mFontDirection, &mFontAscent, &mFontDescent,
-      &strInfo);
-
-   mFontHeight = mFontAscent + mFontDescent;
-   return 0;
-}
-
-int XMessageBox::getButtonLineWidth()
-{
-   return mButtons.size() * MessageBox_ButtonBoxWidth +
-      (mButtons.size() - 1) * MessageBox_ButtonSpacer +
-      MessageBox_ButtonHMargin * 2;
-}
-
-void XMessageBox::setDimensions()
-{
-   mMBWidth = MessageBox_MaxWinWidth;
-   mMBHeight = MessageBox_MaxWinHeight;
-
-   // determine width of button line
-   int buttonWidth = getButtonLineWidth();
-
-   // if there is only one line, the desired width is the greater of the 
-   // line width and the buttonWidth, otherwise the lineWidth is the 
-   // max possible width which we already set.
-   if (mMessageLines.size() == 1)
-   {
-      XCharStruct strInfo;
-      int fontDirection, fontAscent, fontDescent;
-
-      XTextExtents(mFS, mMessageLines[0], strlen(mMessageLines[0]), 
-         &fontDirection, &fontAscent, &fontDescent,
-         &strInfo);
-
-      mMBWidth = max(MessageBox_LineHMargin * 2 + strInfo.width,
-         buttonWidth);
-      mMBWidth = max(mMBWidth, MessageBox_MinWinWidth);
-   }
-
-   // determine the height of the button line
-   int buttonHeight = MessageBox_ButtonBoxHeight + 
-      MessageBox_ButtonVMargin * 2;
-
-   int lineHeight = mFontHeight * mMessageLines.size() +
-      (mMessageLines.size() - 1) * MessageBox_LineSpacer +
-      MessageBox_LineVMargin * 2;
-
-   mMBHeight = buttonHeight + lineHeight;
-}
-
-int XMessageBox::show()
-{
-   if (mDisplay == NULL)
-      return -1;
-
-   int retVal = 0;
-   retVal = loadFont();
-   if (retVal < 0)
-      return retVal;
-
-   // set the maximum window dimensions
-   mScreenWidth = DisplayWidth(mDisplay, DefaultScreen(mDisplay));
-   mScreenHeight = DisplayHeight(mDisplay, DefaultScreen(mDisplay));
-   mMaxWindowWidth = min(mScreenWidth, MessageBox_MaxWinWidth);
-   mMaxWindowHeight = min(mScreenHeight, MessageBox_MaxWinHeight);
-
-   // split the message into a vector of lines
-   splitMessage();
-
-   // set the dialog dimensions
-   setDimensions();
-
-   mWin = XCreateSimpleWindow(
-      mDisplay,
-      DefaultRootWindow(mDisplay),
-      (mScreenWidth - mMBWidth) / 2,  (mScreenHeight - mMBHeight) / 2,
-      mMBWidth, mMBHeight,
-      1, 
-      BlackPixel(mDisplay, DefaultScreen(mDisplay)),
-      WhitePixel(mDisplay, DefaultScreen(mDisplay)));
-
-   mGC = XCreateGC(mDisplay, mWin, 0, 0);
-
-   XSetFont(mDisplay, mGC, mFS->fid);
-
-   // set input mask
-   XSelectInput(mDisplay, mWin, 
-      ExposureMask | PointerMotionMask | ButtonPressMask | ButtonReleaseMask);
-
-   // set wm protocols in case they hit X
-   Atom wm_delete_window = 
-      XInternAtom(mDisplay, "WM_DELETE_WINDOW", False);
-   Atom wm_protocols = 
-      XInternAtom(mDisplay, "WM_PROTOCOLS", False);
-   XSetWMProtocols (mDisplay, mWin, &wm_delete_window, 1);
-   // set pop up dialog hint
-   XSetTransientForHint(mDisplay, mWin, mWin);
-   
-   // set title
-   XTextProperty wtitle;
-   wtitle.value = (unsigned char *)mTitle;
-   wtitle.encoding = XA_STRING;
-   wtitle.format = 8;
-   wtitle.nitems = strlen(mTitle);
-   XSetWMName(mDisplay, mWin, &wtitle);
-
-   // show window
-   XMapRaised(mDisplay, mWin);
-   // move it in case some bozo window manager repositioned it
-   XMoveWindow(mDisplay, mWin, 
-      (mScreenWidth - mMBWidth) / 2,  (mScreenHeight - mMBHeight) / 2);
-   // raise it to top
-   XRaiseWindow(mDisplay, mWin);
-
-   XMessageBoxButton* clickedButton = NULL;
-   XEvent event;
-   Vector<XMessageBoxButton>::iterator iter;
-   bool done = false;
-   while (!done)
-   {
-      XNextEvent(mDisplay, &event);
-      switch (event.type)
-      {
-         case Expose:
-            repaint();
-            break;
-         case MotionNotify:
-            for (iter = mButtons.begin(); iter != mButtons.end(); ++iter)
-               iter->setMouseCoordinates(event.xmotion.x, event.xmotion.y);
-            break;
-         case ButtonPress:
-            for (iter = mButtons.begin(); iter != mButtons.end(); ++iter)
-            {
-               if (iter->pointInRect(event.xbutton.x, event.xbutton.y))
-               {
-                  iter->setMouseDown(true);
-                  iter->setMouseCoordinates(event.xbutton.x, event.xbutton.y);
-                  break;
-               }
-            }
-            break;
-         case ButtonRelease:
-            for (iter = mButtons.begin(); iter != mButtons.end(); ++iter)
-            {
-               if (iter->pointInRect(event.xbutton.x, event.xbutton.y) &&
-                  iter->isMouseDown())
-               {
-                  // we got a winner!
-                  clickedButton = iter;
-                  done = true;
-                  break;
-               }
-            }
-            if (clickedButton == NULL)
-            {
-               // user released outside a button.  clear the button states
-               for (iter = mButtons.begin(); iter != mButtons.end(); ++iter)
-                  iter->setMouseDown(false);
-            }
-            break;
-         case ClientMessage:
-            if (event.xclient.message_type == wm_protocols &&
-               event.xclient.data.l[0] == static_cast<long>(wm_delete_window))
-               done = true;
-            break;
-      }
-      repaint();
-   }
-
-   XUnmapWindow(mDisplay, mWin);
-   XDestroyWindow(mDisplay, mWin);
-   XFreeGC(mDisplay, mGC);
-   XFreeFont(mDisplay, mFS);
-
-   if (clickedButton != NULL)
-      return clickedButton->getClickVal();
-   else
-      return -1;
-}
diff --git a/Engine/source/platformX86UNIX/x86UNIXMessageBox.h b/Engine/source/platformX86UNIX/x86UNIXMessageBox.h
deleted file mode 100644
index 3d9a7e5d4..000000000
--- a/Engine/source/platformX86UNIX/x86UNIXMessageBox.h
+++ /dev/null
@@ -1,122 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#ifndef _X86UNIXMESSAGEBOX_H_
-#define _X86UNIXMESSAGEBOX_H_
-
-#include <X11/Xlib.h>
-#include "core/util/tVector.h"
-
-class XMessageBoxButton
-{
-   public:
-      XMessageBoxButton();
-      XMessageBoxButton(const char* label, int clickVal);
-
-      const char *getLabel() { return static_cast<const char*>(mLabel); }
-      int getClickVal() { return mClickVal; }
-
-      int getLabelWidth() { return mLabelWidth; }
-      void setLabelWidth(int width) { mLabelWidth = width; }
-
-      void setButtonRect(int x, int y, int width, int height)
-      {
-         mX = x;
-         mY = y;
-         mWidth = width;
-         mHeight = height;
-      }
-      void setMouseCoordinates(int x, int y)
-      {
-         mMouseX = x;
-         mMouseY = y;
-      }
-
-      bool drawReverse()
-      {
-         return mMouseDown && pointInRect(mMouseX, mMouseY);
-      }
-
-      bool pointInRect(int x, int y)
-      {
-         if (x >= mX && x <= (mX+mWidth) &&
-            y >= mY && y <= (mY+mHeight))
-            return true;
-         return false;
-      }
-
-      void setMouseDown(bool mouseDown) { mMouseDown = mouseDown; }
-      bool isMouseDown() { return mMouseDown; }
-
-   private:
-      static const int LabelSize = 100;
-      char mLabel[LabelSize];
-      int mClickVal;
-      int mLabelWidth;
-      int mX, mY, mWidth, mHeight;
-      int mMouseX, mMouseY;
-      bool mMouseDown;
-};
-
-class XMessageBox
-{
-   public:
-      static const int OK = 1;
-      static const int Cancel = 2;
-      static const int Retry = 3;
-      static const int IgnoreAll = 4;
-
-      XMessageBox(Display* display);
-      ~XMessageBox();
-
-      int alertOK(const char *windowTitle, const char *message);
-      int alertOKCancel(const char *windowTitle, const char *message);
-      int alertRetryCancel(const char *windowTitle, const char *message);
-      int alertAssert(const char *windowTitle, const char *message);
-   private:
-      int show();
-      void repaint();
-      void splitMessage();
-      void clearMessageLines();
-      int loadFont();
-      void setDimensions();
-      int getButtonLineWidth();
-
-      const char* mMessage;
-      const char* mTitle;
-      Vector<XMessageBoxButton> mButtons;
-      Vector<char*> mMessageLines;
-
-      Display* mDisplay;
-      GC mGC;
-      Window mWin;
-      XFontStruct* mFS;
-      int mFontHeight;
-      int mFontAscent;
-      int mFontDescent;
-      int mFontDirection;
-
-      int mScreenWidth, mScreenHeight, mMaxWindowWidth, mMaxWindowHeight;
-      int mMBWidth, mMBHeight;
-};
-
-#endif // #define _X86UNIXMESSAGEBOX_H_
diff --git a/Engine/source/platformX86UNIX/x86UNIXNet.cpp b/Engine/source/platformX86UNIX/x86UNIXNet.cpp
deleted file mode 100644
index 2cfb81521..000000000
--- a/Engine/source/platformX86UNIX/x86UNIXNet.cpp
+++ /dev/null
@@ -1,924 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-#if 0
-
-#include "platformX86UNIX/platformX86UNIX.h"
-#include "platform/platform.h"
-#include "platform/event.h"
-#include "platform/platformNetAsync.h"
-
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/poll.h>
-#include <arpa/inet.h>
-#include <netdb.h>
-#include <netinet/in.h>
-#include <errno.h>
-
-/* for PROTO_IPX */
-#if defined(__linux__)
-#include <net/if_ppp.h>
-#include <sys/ioctl.h>   /* ioctl() */
-#include <net/ppp_defs.h>
-#elif defined(__OpenBSD__) || defined(__FreeBSD__)
-#include <sys/ioctl.h>   /* ioctl() */
-#include <net/ppp_defs.h>
-#endif
-
-#include <netipx/ipx.h>
-#include <stdlib.h>
-
-#include "console/console.h"
-#include "platform/gameInterface.h"
-#include "core/fileStream.h"
-#include "core/tVector.h"
-
-static Net::Error getLastError();
-static S32 defaultPort = 28000;
-static S32 netPort = 0;
-static int ipxSocket = InvalidSocket;
-static int udpSocket = InvalidSocket;
-
-// local enum for socket states for polled sockets
-enum SocketState
-{
-   InvalidState,
-   Connected,
-   ConnectionPending,
-   Listening,
-   NameLookupRequired
-};
-
-// the Socket structure helps us keep track of the
-// above states
-struct Socket
-{
-      Socket()
-      {
-         fd = InvalidSocket;
-         state = InvalidState;
-         remoteAddr[0] = 0;
-         remotePort = -1;
-      }
-
-      NetSocket fd;
-      S32 state;
-      char remoteAddr[256];
-      S32 remotePort;
-};
-
-// list of polled sockets
-static Vector<Socket*> gPolledSockets;
-
-static Socket* addPolledSocket(NetSocket& fd, S32 state,
-                               char* remoteAddr = NULL, S32 port = -1)
-{
-   Socket* sock = new Socket();
-   sock->fd = fd;
-   sock->state = state;
-   if (remoteAddr)
-      dStrcpy(sock->remoteAddr, remoteAddr, 256);
-   if (port != -1)
-      sock->remotePort = port;
-   gPolledSockets.push_back(sock);
-   return sock;
-}
-
-enum {
-   MaxConnections = 1024,
-};
-
-S32 Poll(NetSocket fd, S32 eventMask, S32 timeoutMs)
-{
-   pollfd pfd;
-   S32 retVal;
-   pfd.fd = fd;
-   pfd.events = eventMask;
-
-   retVal = poll(&pfd, 1, timeoutMs);
-   return retVal;
-   if (retVal <= 0)
-      return retVal;
-   else
-      return pfd.revents;
-}
-
-bool Net::init()
-{
-   NetAsync::startAsync();
-   return(true);
-}
-
-void Net::shutdown()
-{
-   while (gPolledSockets.size() > 0)
-      closeConnectTo(gPolledSockets[0]->fd);
-   
-   closePort();
-   NetAsync::stopAsync();
-}
-
-static void netToIPSocketAddress(const NetAddress *address, struct sockaddr_in *sockAddr)
-{
-   dMemset(sockAddr, 0, sizeof(struct sockaddr_in));
-   sockAddr->sin_family = AF_INET;
-   sockAddr->sin_port = htons(address->port);
-   char tAddr[20];
-   dSprintf(tAddr, 20, "%d.%d.%d.%d\n", address->netNum[0], address->netNum[1], address->netNum[2], address->netNum[3]);
-//fprintf(stdout,"netToIPSocketAddress(): %s\n",tAddr);fflush(NULL);
-   sockAddr->sin_addr.s_addr = inet_addr(tAddr);
-//   sockAddr->sin_addr.s_addr = address->netNum[0];  // hopefully this will work.
-}
-
-static void IPSocketToNetAddress(const struct sockaddr_in *sockAddr, NetAddress *address)
-{
-   address->type = NetAddress::IPAddress;
-   address->port = htons(sockAddr->sin_port);
-   char *tAddr;
-   tAddr = inet_ntoa(sockAddr->sin_addr);
-//fprintf(stdout,"IPSocketToNetAddress(): %s\n",tAddr);fflush(NULL);
-   U8 nets[4];
-   nets[0] = atoi(strtok(tAddr, "."));
-   nets[1] = atoi(strtok(NULL, "."));
-   nets[2] = atoi(strtok(NULL, "."));
-   nets[3] = atoi(strtok(NULL, "."));
-//fprintf(stdout,"0 = %d, 1 = %d, 2 = %d, 3 = %d\n", nets[0], nets[1], nets[2], nets[3]);
-   address->netNum[0] = nets[0];
-   address->netNum[1] = nets[1];
-   address->netNum[2] = nets[2];
-   address->netNum[3] = nets[3];
-}
-
-static void netToIPXSocketAddress(const NetAddress *address, sockaddr_ipx *sockAddr)
-{
-#if !defined(__FreeBSD__)
-   dMemset(sockAddr, 0, sizeof(sockaddr_ipx));
-   sockAddr->sipx_family = AF_INET;
-   sockAddr->sipx_port = htons(address->port);
-   sockAddr->sipx_network = address->netNum[0];
-   sockAddr->sipx_node[0] = address->nodeNum[0];
-   sockAddr->sipx_node[1] = address->nodeNum[1];
-   sockAddr->sipx_node[2] = address->nodeNum[2];
-   sockAddr->sipx_node[3] = address->nodeNum[3];
-   sockAddr->sipx_node[4] = address->nodeNum[4];
-   sockAddr->sipx_node[5] = address->nodeNum[5];
-#endif
-}
-
-static void IPXSocketToNetAddress(const sockaddr_ipx *sockAddr, NetAddress *address)
-{
-#if !defined(__FreeBSD__)
-   address->type = NetAddress::IPXAddress;
-   address->port = htons(sockAddr->sipx_port);
-   address->netNum[0]  = sockAddr->sipx_network;
-   address->nodeNum[0] = sockAddr->sipx_node[0];
-   address->nodeNum[1] = sockAddr->sipx_node[1];
-   address->nodeNum[2] = sockAddr->sipx_node[2];
-   address->nodeNum[3] = sockAddr->sipx_node[3];
-   address->nodeNum[4] = sockAddr->sipx_node[4];
-   address->nodeNum[5] = sockAddr->sipx_node[5];
-#endif
-}
-
-NetSocket Net::openListenPort(U16 port)
-{
-   if(Game->isJournalReading())
-   {
-      U32 ret;
-      Game->journalRead(&ret);
-      return NetSocket(ret);
-   }
-   NetSocket sock = openSocket();
-   if (sock == InvalidSocket)
-   {
-      Con::errorf("Unable to open listen socket: %s", strerror(errno));
-      return InvalidSocket;
-   }
-
-   if (bind(sock, port) != NoError)
-   {
-      Con::errorf("Unable to bind port %d: %s", port, strerror(errno));
-      ::close(sock);
-      return InvalidSocket;
-   }
-   if (listen(sock, 4) != NoError)
-   {
-      Con::errorf("Unable to listen on port %d: %s", port, strerror(errno));
-      ::close(sock);
-      return InvalidSocket;
-   }
-
-   setBlocking(sock, false);
-   addPolledSocket(sock, Listening);
-   if (Game->isJournalWriting())
-      Game->journalWrite(U32(sock));
-   return sock;
-}
-
-NetSocket Net::openConnectTo(const char *addressString)
-{
-   if(!dStrnicmp(addressString, "ipx:", 4))
-      return InvalidSocket;
-   if(!dStrnicmp(addressString, "ip:", 3))
-      addressString += 3;  // eat off the ip:
-   char remoteAddr[256];
-   dStrcpy(remoteAddr, addressString, 256);
-      
-   char *portString = dStrchr(remoteAddr, ':');
-
-   U16 port;
-   if(portString)
-   {
-      *portString++ = 0;
-      port = htons(dAtoi(portString));
-   }
-   else
-      port = htons(defaultPort);
-
-   if(!dStricmp(remoteAddr, "broadcast"))
-      return InvalidSocket;
-
-   if(Game->isJournalReading())
-   {
-      U32 ret;
-      Game->journalRead(&ret);
-      return NetSocket(ret);
-   }
-   NetSocket sock = openSocket();
-   setBlocking(sock, false);
-
-   sockaddr_in ipAddr;
-   dMemset(&ipAddr, 0, sizeof(ipAddr));
-   
-   if (inet_aton(remoteAddr, &ipAddr.sin_addr) != 0)
-   {
-      ipAddr.sin_port = port;
-      ipAddr.sin_family = AF_INET;
-      if(::connect(sock, (struct sockaddr *)&ipAddr, sizeof(ipAddr)) == -1 &&
-         errno != EINPROGRESS)
-      {
-         Con::errorf("Error connecting %s: %s", 
-		     addressString, strerror(errno));
-         ::close(sock);
-         sock = InvalidSocket;
-      }
-      if(sock != InvalidSocket) {
-         // add this socket to our list of polled sockets
-         addPolledSocket(sock, ConnectionPending);
-      }
-   }
-   else
-   {
-      // need to do an asynchronous name lookup.  first, add the socket
-      // to the polled list
-      addPolledSocket(sock, NameLookupRequired, remoteAddr, port);
-      // queue the lookup
-      gNetAsync.queueLookup(remoteAddr, sock);
-   }
-   if(Game->isJournalWriting())
-      Game->journalWrite(U32(sock));
-   return sock;
-}
-
-void Net::closeConnectTo(NetSocket sock)
-{
-   if(Game->isJournalReading())
-      return;
-
-   // if this socket is in the list of polled sockets, remove it
-   for (int i = 0; i < gPolledSockets.size(); ++i)
-      if (gPolledSockets[i]->fd == sock)
-      {
-         delete gPolledSockets[i];
-         gPolledSockets.erase(i);
-         break;
-      }
-   
-   closeSocket(sock);
-}
-
-Net::Error Net::sendtoSocket(NetSocket socket, const U8 *buffer, int bufferSize)
-{
-   if(Game->isJournalReading())
-   {
-      U32 e;
-      Game->journalRead(&e);
-      
-      return (Net::Error) e;
-   }
-   Net::Error e = send(socket, buffer, bufferSize);
-   if(Game->isJournalWriting())
-      Game->journalWrite(U32(e));
-   return e;
-}
-
-bool Net::openPort(S32 port)
-{
-   if(udpSocket != InvalidSocket)
-      close(udpSocket);
-   if(ipxSocket != InvalidSocket)
-      close(ipxSocket);
-      
-   udpSocket = socket(AF_INET, SOCK_DGRAM, 0);
-   ipxSocket = socket(AF_IPX, SOCK_DGRAM, 0);
-
-   if(udpSocket != InvalidSocket)
-   {
-      Net::Error error;
-      error = bind(udpSocket, port);
-      if(error == NoError)
-         error = setBufferSize(udpSocket, 32768);
-      if(error == NoError)
-         error = setBroadcast(udpSocket, true);
-      if(error == NoError)
-         error = setBlocking(udpSocket, false);
-      if(error == NoError)
-         Con::printf("UDP initialized on port %d", port);
-      else
-      {
-         close(udpSocket);
-         udpSocket = InvalidSocket;
-         Con::printf("Unable to initialize UDP - error %d", error);
-      }
-   }
-   if(ipxSocket != InvalidSocket)
-   {
-      Net::Error error = NoError;
-      sockaddr_ipx ipxAddress;   
-      memset((char *)&ipxAddress, 0, sizeof(ipxAddress));
-      ipxAddress.sipx_family = AF_IPX;
-      ipxAddress.sipx_port = htons(port);
-      S32 err = ::bind(ipxSocket, (struct sockaddr *)&ipxAddress, sizeof(ipxAddress));
-      if(err)
-         error = getLastError();
-      if(error == NoError)
-         error = setBufferSize(ipxSocket, 32768);
-      if(error == NoError)
-         error = setBroadcast(ipxSocket, true);
-      if(error == NoError)
-         error = setBlocking(ipxSocket, false);
-      if(error == NoError)
-         Con::printf("IPX initialized on port %d", port);
-      else
-      {
-         close(ipxSocket);
-         ipxSocket = InvalidSocket;
-         Con::printf("Unable to initialize IPX - error %d", error);
-      }
-   }
-   netPort = port;
-   return ipxSocket != InvalidSocket || udpSocket != InvalidSocket;
-}
-
-void Net::closePort()
-{
-   if(ipxSocket != InvalidSocket)
-      close(ipxSocket);
-   if(udpSocket != InvalidSocket)
-      close(udpSocket);
-}
-
-Net::Error Net::sendto(const NetAddress *address, const U8 *buffer, S32 bufferSize)
-{
-   if(Game->isJournalReading())
-      return NoError;
-
-   if(address->type == NetAddress::IPXAddress)
-   {
-      sockaddr_ipx ipxAddr;
-      netToIPXSocketAddress(address, &ipxAddr);
-      if(::sendto(ipxSocket, (const char*)buffer, bufferSize, 0,
-                  (sockaddr *) &ipxAddr, sizeof(sockaddr_ipx)) == -1)
-         return getLastError();
-      else
-         return NoError;
-   }
-   else
-   {
-      sockaddr_in ipAddr;
-      netToIPSocketAddress(address, &ipAddr);
-      if(::sendto(udpSocket, (const char*)buffer, bufferSize, 0,
-                  (sockaddr *) &ipAddr, sizeof(sockaddr_in)) == -1)
-         return getLastError();
-      else
-         return NoError;
-   }
-}
-
-void Net::process()
-{
-   sockaddr sa;
-
-   PacketReceiveEvent receiveEvent;
-   for(;;)
-   {
-      U32 addrLen = sizeof(sa);
-      S32 bytesRead = -1;
-      if(udpSocket != InvalidSocket)
-         bytesRead = recvfrom(udpSocket, (char *) receiveEvent.data, MaxPacketDataSize, 0, &sa, &addrLen);
-      if(bytesRead == -1 && ipxSocket != InvalidSocket)
-      {
-         addrLen = sizeof(sa);
-         bytesRead = recvfrom(ipxSocket, (char *) receiveEvent.data, MaxPacketDataSize, 0, &sa, &addrLen);
-      }
-      
-      if(bytesRead == -1)
-         break;
-      
-      if(sa.sa_family == AF_INET)
-         IPSocketToNetAddress((sockaddr_in *) &sa, &receiveEvent.sourceAddress);
-      else if(sa.sa_family == AF_IPX)
-         IPXSocketToNetAddress((sockaddr_ipx *) &sa, &receiveEvent.sourceAddress);
-      else
-         continue;
-         
-      NetAddress &na = receiveEvent.sourceAddress;
-      if(na.type == NetAddress::IPAddress &&
-         na.netNum[0] == 127 &&
-         na.netNum[1] == 0 &&
-         na.netNum[2] == 0 &&
-         na.netNum[3] == 1 &&
-         na.port == netPort)
-         continue;
-      if(bytesRead <= 0)
-         continue;
-      receiveEvent.size = PacketReceiveEventHeaderSize + bytesRead;
-      Game->postEvent(receiveEvent);
-   }
-
-   // process the polled sockets.  This blob of code performs functions
-   // similar to WinsockProc in winNet.cc
-
-   if (gPolledSockets.size() == 0)
-      return;
-
-   static ConnectedNotifyEvent notifyEvent;
-   static ConnectedAcceptEvent acceptEvent;
-   static ConnectedReceiveEvent cReceiveEvent;
-
-   S32 optval;
-   socklen_t optlen = sizeof(S32);
-   S32 bytesRead;
-   Net::Error err;
-   bool removeSock = false;
-   Socket *currentSock = NULL;
-   sockaddr_in ipAddr;
-   NetSocket incoming = InvalidSocket;
-   char out_h_addr[1024];
-   int out_h_length = 0;
-
-   for (S32 i = 0; i < gPolledSockets.size(); 
-        /* no increment, this is done at end of loop body */)
-   {
-      removeSock = false;
-      currentSock = gPolledSockets[i];
-      switch (currentSock->state)
-      {
-         case InvalidState:
-            Con::errorf("Error, InvalidState socket in polled sockets list");
-            break;
-         case ConnectionPending:
-            notifyEvent.tag = currentSock->fd;
-            // see if it is now connected
-            if (getsockopt(currentSock->fd, SOL_SOCKET, SO_ERROR, 
-                           &optval, &optlen) == -1)
-            {
-               Con::errorf("Error getting socket options: %s", strerror(errno));
-               notifyEvent.state = ConnectedNotifyEvent::ConnectFailed;
-               Game->postEvent(notifyEvent);
-               removeSock = true;
-            }
-            else
-            {
-               if (optval == EINPROGRESS)
-                  // still connecting...
-                  break;
-
-               if (optval == 0)
-               {
-                  // connected
-                  notifyEvent.state = ConnectedNotifyEvent::Connected;
-                  Game->postEvent(notifyEvent);
-                  currentSock->state = Connected;
-               }
-               else
-               {
-                  // some kind of error
-                  Con::errorf("Error connecting: %s", strerror(errno));
-                  notifyEvent.state = ConnectedNotifyEvent::ConnectFailed;
-                  Game->postEvent(notifyEvent);
-                  removeSock = true;
-               }
-            }
-            break;
-         case Connected:
-            bytesRead = 0;
-            // try to get some data
-            err = Net::recv(currentSock->fd, cReceiveEvent.data, 
-                            MaxPacketDataSize, &bytesRead);
-            if(err == Net::NoError)
-            {
-               if (bytesRead > 0)
-               {
-                  // got some data, post it
-                  cReceiveEvent.tag = currentSock->fd;
-                  cReceiveEvent.size = ConnectedReceiveEventHeaderSize + 
-                     bytesRead;
-                  Game->postEvent(cReceiveEvent);
-               }
-               else 
-               {
-                  // zero bytes read means EOF
-                  if (bytesRead < 0)
-                     // ack! this shouldn't happen
-                     Con::errorf("Unexpected error on socket: %s", 
-                                 strerror(errno));
-
-                  notifyEvent.tag = currentSock->fd;
-                  notifyEvent.state = ConnectedNotifyEvent::Disconnected;
-                  Game->postEvent(notifyEvent);
-                  removeSock = true;
-               }
-            }
-            else if (err != Net::NoError && err != Net::WouldBlock)
-            {
-               Con::errorf("Error reading from socket: %s", strerror(errno));
-               notifyEvent.tag = currentSock->fd;
-               notifyEvent.state = ConnectedNotifyEvent::Disconnected;
-               Game->postEvent(notifyEvent);
-               removeSock = true;
-            }
-            break;
-         case NameLookupRequired:
-            // is the lookup complete?
-            if (!gNetAsync.checkLookup(
-                   currentSock->fd, out_h_addr, &out_h_length, 
-                   sizeof(out_h_addr)))
-               break;
-            
-            notifyEvent.tag = currentSock->fd;
-            if (out_h_length == -1)
-            {
-               Con::errorf("DNS lookup failed: %s", currentSock->remoteAddr);
-               notifyEvent.state = ConnectedNotifyEvent::DNSFailed;
-               removeSock = true;
-            }
-            else
-            {
-               // try to connect
-               dMemcpy(&(ipAddr.sin_addr.s_addr), out_h_addr, out_h_length);
-               ipAddr.sin_port = currentSock->remotePort;
-               ipAddr.sin_family = AF_INET;
-               if(::connect(currentSock->fd, (struct sockaddr *)&ipAddr, 
-                            sizeof(ipAddr)) == -1)
-               {
-                  if (errno == EINPROGRESS)
-                  {
-                     notifyEvent.state = ConnectedNotifyEvent::DNSResolved;
-                     currentSock->state = ConnectionPending;
-                  }
-                  else
-                  {
-                     Con::errorf("Error connecting to %s: %s", 
-                                 currentSock->remoteAddr, strerror(errno));
-                     notifyEvent.state = ConnectedNotifyEvent::ConnectFailed;
-                     removeSock = true;
-                  }
-               }
-               else
-               {
-                  notifyEvent.state = ConnectedNotifyEvent::Connected;
-                  currentSock->state = Connected;
-               }
-            }
-            Game->postEvent(notifyEvent);			
-            break;
-    	 case Listening:
-            incoming = 
-               Net::accept(currentSock->fd, &acceptEvent.address);
-            if(incoming != InvalidSocket)
-            {
-               acceptEvent.portTag = currentSock->fd;
-               acceptEvent.connectionTag = incoming;
-               setBlocking(incoming, false);
-               addPolledSocket(incoming, Connected);
-               Game->postEvent(acceptEvent);
-            }
-            break;
-      }
-
-      // only increment index if we're not removing the connection, since 
-      // the removal will shift the indices down by one
-      if (removeSock)
-         closeConnectTo(currentSock->fd);
-      else
-         i++;
-   }
-}
-                 
-NetSocket Net::openSocket()
-{
-   int retSocket;
-   retSocket = socket(AF_INET, SOCK_STREAM, 0);
-
-   if(retSocket == InvalidSocket)
-      return InvalidSocket;
-   else
-      return retSocket;
-}
-
-Net::Error Net::closeSocket(NetSocket socket)
-{
-   if(socket != InvalidSocket)
-   {
-      if(!close(socket))
-         return NoError;
-      else
-         return getLastError();
-   }
-   else
-      return NotASocket;
-}
-
-Net::Error Net::connect(NetSocket socket, const NetAddress *address)
-{
-   if(address->type != NetAddress::IPAddress)
-      return WrongProtocolType;
-   sockaddr_in socketAddress;
-   netToIPSocketAddress(address, &socketAddress);
-   if(!::connect(socket, (sockaddr *) &socketAddress, sizeof(socketAddress)))
-      return NoError;
-   return getLastError();
-}
-
-Net::Error Net::listen(NetSocket socket, S32 backlog)
-{
-   if(!::listen(socket, backlog))
-      return NoError;
-   return getLastError();
-}
-
-NetSocket Net::accept(NetSocket acceptSocket, NetAddress *remoteAddress)
-{
-   sockaddr_in socketAddress;
-   U32 addrLen = sizeof(socketAddress);
-   
-   int retVal = ::accept(acceptSocket, (sockaddr *) &socketAddress, &addrLen);
-   if(retVal != InvalidSocket)
-   {
-      IPSocketToNetAddress(&socketAddress, remoteAddress);
-      return retVal;
-   }
-   return InvalidSocket;
-}
-
-Net::Error Net::bind(NetSocket socket, U16 port)
-{
-   S32 error;
-   
-   sockaddr_in socketAddress;
-   dMemset((char *)&socketAddress, 0, sizeof(socketAddress));
-   socketAddress.sin_family = AF_INET;
-   // It's entirely possible that there are two NIC cards.
-   // We let the user specify which one the server runs on.
-
-   // thanks to [TPG]P1aGu3 for the name
-   const char* serverIP = Con::getVariable( "Pref::Net::BindAddress" );
-   // serverIP is guaranteed to be non-0.
-   AssertFatal( serverIP, "serverIP is NULL!" );
-
-   if( serverIP[0] != '\0' ) {
-      // we're not empty
-      socketAddress.sin_addr.s_addr = inet_addr( serverIP );
-
-      if( socketAddress.sin_addr.s_addr != INADDR_NONE ) {
-	 Con::printf( "Binding server port to %s", serverIP );
-      } else {
-	 Con::warnf( ConsoleLogEntry::General,
-		     "inet_addr() failed for %s while binding!",
-		     serverIP );
-	 socketAddress.sin_addr.s_addr = INADDR_ANY;
-      }
-
-   } else {
-      Con::printf( "Binding server port to default IP" );
-      socketAddress.sin_addr.s_addr = INADDR_ANY;
-   }
-
-   socketAddress.sin_port = htons(port);
-   error = ::bind(socket, (sockaddr *) &socketAddress, sizeof(socketAddress));
-
-   if(!error)
-      return NoError;
-   return getLastError();
-}
-
-Net::Error Net::setBufferSize(NetSocket socket, S32 bufferSize)
-{
-   S32 error;
-   error = setsockopt(socket, SOL_SOCKET, SO_RCVBUF, (char *) &bufferSize, sizeof(bufferSize));
-   if(!error)
-      error = setsockopt(socket, SOL_SOCKET, SO_SNDBUF, (char *) &bufferSize, sizeof(bufferSize));
-   if(!error)
-      return NoError;
-   return getLastError();
-}
-
-Net::Error Net::setBroadcast(NetSocket socket, bool broadcast)
-{
-   S32 bc = broadcast;
-   S32 error = setsockopt(socket, SOL_SOCKET, SO_BROADCAST, (char*)&bc, sizeof(bc));
-   if(!error)
-      return NoError;
-   return getLastError();   
-}
-
-Net::Error Net::setBlocking(NetSocket socket, bool blockingIO)
-{
-   int notblock = !blockingIO;
-   S32 error = ioctl(socket, FIONBIO, &notblock);
-   if(!error)
-      return NoError;
-   return getLastError();   
-}
-
-Net::Error Net::send(NetSocket socket, const U8 *buffer, S32 bufferSize)
-{
-   // Poll for write status.  this blocks.  should really
-   // do this in a separate thread or set it up so that the data can
-   // get queued and sent later
-   // JMQTODO
-   Poll(socket, POLLOUT, 10000);
-
-   S32 error = ::send(socket, (const char*)buffer, bufferSize, 0);
-   if(error != -1)
-      return NoError;
-
-   return getLastError();
-}
-
-Net::Error Net::recv(NetSocket socket, U8 *buffer, S32 bufferSize, S32 *bytesRead)
-{
-   *bytesRead = ::recv(socket, (char*)buffer, bufferSize, 0);
-   if(*bytesRead == -1)
-      return getLastError();
-   return NoError;
-}
-
-bool Net::compareAddresses(const NetAddress *a1, const NetAddress *a2)
-{
-   if((a1->type != a2->type)  || 
-      (*((U32 *)a1->netNum) != *((U32 *)a2->netNum)) ||
-      (a1->port != a2->port))
-      return false;
-
-   if(a1->type == NetAddress::IPAddress)
-      return true;
-   for(S32 i = 0; i < 6; i++)
-      if(a1->nodeNum[i] != a2->nodeNum[i])
-         return false;
-   return true;
-}
-
-bool Net::stringToAddress(const char *addressString, NetAddress *address)
-{
-   if(dStrnicmp(addressString, "ipx:", 4))
-   {
-      // assume IP if it doesn't have ipx: at the front.
-      
-      if(!dStrnicmp(addressString, "ip:", 3))
-         addressString += 3;  // eat off the ip:
-      
-      sockaddr_in ipAddr;
-      char remoteAddr[256];
-      if(strlen(addressString) > 255)
-         return false;
-         
-      dStrcpy(remoteAddr, addressString, 256);
-         
-      char *portString = dStrchr(remoteAddr, ':');
-      if(portString)
-         *portString++ = '\0';
-      
-      struct hostent *hp;
-      if(!dStricmp(remoteAddr, "broadcast"))
-         ipAddr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
-      else
-      {
-         if (inet_aton(remoteAddr,&ipAddr.sin_addr) == 0) // error
-         {
-            if((hp = gethostbyname(remoteAddr)) == 0)
-               return false;
-            else
-               memcpy(&ipAddr.sin_addr.s_addr, hp->h_addr, sizeof(in_addr));
-         }
-      }
-      if(portString)
-         ipAddr.sin_port = htons(dAtoi(portString));
-      else
-         ipAddr.sin_port = htons(defaultPort);
-      ipAddr.sin_family = AF_INET;
-      IPSocketToNetAddress(&ipAddr, address);
-      return true;
-   }
-   else
-   {
-      S32 i;
-      S32 port;
-
-      address->type = NetAddress::IPXAddress;      
-      for(i = 0; i < 6; i++)
-         address->nodeNum[i] = 0xFF;
-         
-      // it's an IPX string
-      addressString += 4;
-      if(!dStricmp(addressString, "broadcast"))
-      {
-         address->port = defaultPort;
-         return true;
-      }
-      else if(sscanf(addressString, "broadcast:%d", &port) == 1)
-      {
-         address->port = port;
-         return true;
-      }
-      else
-      {
-         S32 nodeNum[6];
-         S32 netNum[4];
-         S32 count = dSscanf(addressString, "%2x%2x%2x%2x:%2x%2x%2x%2x%2x%2x:%d",
-                             &netNum[0], &netNum[1], &netNum[2], &netNum[3],
-                             &nodeNum[0], &nodeNum[1], &nodeNum[2], &nodeNum[3], &nodeNum[4], &nodeNum[5], 
-                             &port);
-      
-         if(count == 10)
-         {
-            port = defaultPort;
-            count++;
-         }
-         if(count != 11)
-            return false;
-
-         for(i = 0; i < 6; i++)
-            address->nodeNum[i] = nodeNum[i];
-         for(i = 0; i < 4; i++)
-            address->netNum[i] = netNum[i];
-         address->port = port;
-         return true;
-      }
-   }
-}
-
-void Net::addressToString(const NetAddress *address, char addressString[256])
-{
-   if(address->type == NetAddress::IPAddress)
-   {
-      sockaddr_in ipAddr;
-      netToIPSocketAddress(address, &ipAddr);
-      
-      if(ipAddr.sin_addr.s_addr == htonl(INADDR_BROADCAST))
-         dSprintf(addressString, 256, "IP:Broadcast:%d", ntohs(ipAddr.sin_port));
-      else
-         dSprintf(addressString, 256, "IP:%s:%d", inet_ntoa(ipAddr.sin_addr),
-                  ntohs(ipAddr.sin_port));
-//         dSprintf(addressString, 256, "IP:%d:%d", ipAddr.sin_addr.s_addr,
-//            ntohs(ipAddr.sin_port));
-   }
-   else
-   {
-      return;
-      dSprintf(addressString, 256, "IPX:%.2X%.2X%.2X%.2X:%.2X%.2X%.2X%.2X%.2X%.2X:%d",
-               address->netNum[0], address->netNum[1], address->netNum[2], address->netNum[3], 
-               address->nodeNum[0], address->nodeNum[1], address->nodeNum[2], address->nodeNum[3], address->nodeNum[4], address->nodeNum[5], 
-               address->port);
-   }
-}
-
-Net::Error getLastError()
-{
-   if (errno == EAGAIN)
-      return Net::WouldBlock;
-   return Net::UnknownError;
-}
-
-#endif
diff --git a/Engine/source/platformX86UNIX/x86UNIXOGLVideo.client.cpp b/Engine/source/platformX86UNIX/x86UNIXOGLVideo.client.cpp
deleted file mode 100644
index 9db3236c5..000000000
--- a/Engine/source/platformX86UNIX/x86UNIXOGLVideo.client.cpp
+++ /dev/null
@@ -1,508 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-#if 0
-#include "console/console.h"
-#include "platform/event.h"
-#include "platform/gameInterface.h"
-
-#include "platformX86UNIX/platformX86UNIX.h"
-#include "platformX86UNIX/platformGL.h"
-#include "platformX86UNIX/x86UNIXOGLVideo.h"
-#include "platformX86UNIX/x86UNIXState.h"
-
-#include <SDL/SDL.h>
-#include <SDL/SDL_syswm.h>
-#include <SDL/SDL_version.h>
-
-//------------------------------------------------------------------------------
-bool InitOpenGL()
-{
-   DisplayDevice::init();
-
-   // Get the video settings from the prefs:
-   const char* resString = Con::getVariable( "$pref::Video::resolution" );
-   dsize_t tempBufLen = dStrlen(resString) + 1;
-   char* tempBuf = new char[tempBufLen];
-   dStrcpy( tempBuf, resString, tempBufLen );
-   char* temp = dStrtok( tempBuf, " x\0" );
-   U32 width = ( temp ? dAtoi( temp ) : 800 );
-   temp = dStrtok( NULL, " x\0" );
-   U32 height = ( temp ? dAtoi( temp ) : 600 );
-   temp = dStrtok( NULL, "\0" );
-   U32 bpp = ( temp ? dAtoi( temp ) : 16 );
-   delete [] tempBuf;
-
-   bool fullScreen = Con::getBoolVariable( "$pref::Video::fullScreen" );
-
-   // the only supported video device in unix is OpenGL
-   if ( !Video::setDevice( "OpenGL", width, height, bpp, fullScreen ) )
-   {
-      Con::errorf("Unable to create default OpenGL mode: %d %d %d %d",
-         width, height, bpp, fullScreen);
-
-      // if we can't create the default, attempt to create a "safe" window
-      if ( !Video::setDevice( "OpenGL", 640, 480, 16, true ) )
-      {
-         DisplayErrorAlert("Could not find a compatible OpenGL display " \
-            "resolution.  Please check your driver configuration.");
-         return false;
-      }
-   }
-
-   return true;
-}
-
-//------------------------------------------------------------------------------
-bool OpenGLDevice::smCanSwitchBitDepth = false;
-
-//------------------------------------------------------------------------------
-OpenGLDevice::OpenGLDevice()
-{
-   initDevice();
-}
-
-//------------------------------------------------------------------------------
-OpenGLDevice::~OpenGLDevice()
-{
-}
-
-//------------------------------------------------------------------------------
-void OpenGLDevice::addResolution(S32 width, S32 height, bool check)
-{
-   Point2I desktopSize = x86UNIXState->getDesktopSize();
-   U32 desktopBpp = x86UNIXState->getDesktopBpp();
-
-   // don't allow any resolution under this size
-   if (width < 640 || height < 480)
-      return;
-
-   if (check)
-   {
-      // don't allow resolutions that exceed the current desktop size
-      if (width > desktopSize.x || height > desktopSize.y)
-         return;
-   }
-
-   if (smCanSwitchBitDepth)
-   {
-      // add both 16 and 32 bit resolutions
-      mResolutionList.push_back(Resolution(width, height, 16));
-      mResolutionList.push_back(Resolution(width, height, 32));
-   }
-   else
-   {
-      // add just the desktop resolution
-      mResolutionList.push_back(Resolution(width, height, desktopBpp));
-   }
-}
-
-//------------------------------------------------------------------------------
-void OpenGLDevice::initDevice()
-{
-   mDeviceName = "OpenGL";
-   mFullScreenOnly = false;
-}
-
-//------------------------------------------------------------------------------
-void OpenGLDevice::loadResolutions()
-{
-   mResolutionList.clear();
-
-   // X cannot switch bit depths on the fly.  In case this feature is
-   // implemented someday, calling this function will let you take
-   // advantage of it
-   if (Con::getBoolVariable("$pref::Unix::CanSwitchBitDepth"))
-      smCanSwitchBitDepth = true;
-
-   // add some default resolutions
-   addResolution(640, 480);
-   addResolution(800, 600);
-   addResolution(1024, 768);
-   addResolution(1152, 864);
-   addResolution(1280, 1024);
-   addResolution(1600, 1200);
-
-   // specifying full screen should give us the resolutions that the
-   // X server allows
-   SDL_Rect** modes = SDL_ListModes(NULL, SDL_FULLSCREEN);
-   if (modes &&
-      (modes != (SDL_Rect **)-1))
-   {
-      for (int i = 0; modes[i] != NULL; ++i)
-      {
-         // do we already have this mode?
-         bool found = false;
-         for (Vector<Resolution>::iterator iter = mResolutionList.begin();
-              iter != mResolutionList.end();
-              ++iter)
-         {
-            if (iter->w == modes[i]->w && iter->h == modes[i]->h)
-            {
-               found = true;
-               break;
-            }
-         }
-         if (!found)
-            // don't check these resolutions because they should be OK
-            // (and checking might drop resolutions that are higher than the
-            // current desktop bpp)
-            addResolution(modes[i]->w, modes[i]->h, false);
-      }
-   }
-}
-
-//------------------------------------------------------------------------------
-bool OpenGLDevice::activate( U32 width, U32 height, U32 bpp, bool fullScreen )
-{
-   if (!setScreenMode(width, height, bpp, fullScreen))
-   {
-      Con::printf("Unable to set screen mode.");
-      return false;
-   }
-
-   // Output some driver info to the console
-   const char* vendorString   = (const char*) glGetString( GL_VENDOR );
-   const char* rendererString = (const char*) glGetString( GL_RENDERER );
-   const char* versionString  = (const char*) glGetString( GL_VERSION );
-   Con::printf( "OpenGL driver information:" );
-   if ( vendorString )
-      Con::printf( "  Vendor: %s", vendorString );
-   if ( rendererString )
-      Con::printf( "  Renderer: %s", rendererString );
-   if ( versionString )
-      Con::printf( "  Version: %s", versionString );
-
-   GL_EXT_Init();
-
-   Con::setVariable( "$pref::Video::displayDevice", mDeviceName );
-
-   // Do this here because we now know about the extensions:
-   if ( gGLState.suppSwapInterval )
-      setVerticalSync(
-         !Con::getBoolVariable( "$pref::Video::disableVerticalSync" ) );
-   Con::setBoolVariable("$pref::OpenGL::allowTexGen", true);
-
-   return true;
-}
-
-
-//------------------------------------------------------------------------------
-void OpenGLDevice::shutdown()
-{
-   // Shutdown is deferred to Platform::shutdown()
-}
-
-//------------------------------------------------------------------------------
-static void PrintGLAttributes()
-{
-   int doubleBuf;
-   int bufferSize, depthSize, stencilSize;
-   int red, green, blue, alpha;
-   int aRed, aGreen, aBlue, aAlpha;
-
-   SDL_GL_GetAttribute(SDL_GL_DOUBLEBUFFER, &doubleBuf);
-   SDL_GL_GetAttribute(SDL_GL_BUFFER_SIZE, &bufferSize);
-   SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &depthSize);
-   SDL_GL_GetAttribute(SDL_GL_STENCIL_SIZE, &stencilSize);
-   SDL_GL_GetAttribute(SDL_GL_RED_SIZE, &red);
-   SDL_GL_GetAttribute(SDL_GL_GREEN_SIZE, &green);
-   SDL_GL_GetAttribute(SDL_GL_BLUE_SIZE, &blue);
-   SDL_GL_GetAttribute(SDL_GL_ALPHA_SIZE, &alpha);
-   SDL_GL_GetAttribute(SDL_GL_ACCUM_RED_SIZE, &aRed);
-   SDL_GL_GetAttribute(SDL_GL_ACCUM_GREEN_SIZE, &aGreen);
-   SDL_GL_GetAttribute(SDL_GL_ACCUM_BLUE_SIZE, &aBlue);
-   SDL_GL_GetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, &aAlpha);
-
-   Con::printf("OpenGL Attributes:");
-   Con::printf("  DoubleBuffer: %d", doubleBuf);
-   Con::printf("  BufferSize: %d, DepthSize: %d, StencilSize: %d",
-      bufferSize, depthSize, stencilSize);
-   Con::printf("  Red: %d, Green: %d, Blue: %d, Alpha: %d",
-      red, green, blue, alpha);
-   Con::printf("  Accum Red: %d, Green: %d, Blue: %d, Alpha: %d",
-      aRed, aGreen, aBlue, aAlpha);
-}
-
-//------------------------------------------------------------------------------
-bool OpenGLDevice::setScreenMode( U32 width, U32 height, U32 bpp,
-   bool fullScreen, bool forceIt, bool repaint )
-{
-   // load resolutions, this is done lazily so that we can check the setting
-   // of smCanSwitchBitDepth, which may be overridden by console
-   if (mResolutionList.size()==0)
-      loadResolutions();
-
-   if (mResolutionList.size()==0)
-   {
-      Con::printf("No resolutions available!");
-      return false;
-   }
-
-   if (bpp == 0)
-   {
-      // bpp comes in as "0" when it is set to "Default"
-      bpp = x86UNIXState->getDesktopBpp();
-   }
-
-   if (height == 0 || width == 0)
-   {
-      // paranoia check.  set it to the default to prevent crashing
-      width = 800;
-      height = 600;
-   }
-
-   U32 desktopDepth = x86UNIXState->getDesktopBpp();
-   // if we can't switch bit depths and the requested bpp is not equal to
-   // the desktop bpp, set bpp to the desktop bpp
-   if (!smCanSwitchBitDepth &&
-      bpp != desktopDepth)
-   {
-      bpp = desktopDepth;
-   }
-
-   bool IsInList = false;
-
-   Resolution NewResolution( width, height, bpp );
-
-   // See if the desired resolution is in the list
-   if ( mResolutionList.size() )
-   {
-      for ( int i = 0; i < mResolutionList.size(); i++ )
-      {
-         if ( width == mResolutionList[i].w
-              && height == mResolutionList[i].h
-              && bpp == mResolutionList[i].bpp )
-         {
-            IsInList = true;
-            break;
-         }
-      }
-
-      if ( !IsInList )
-      {
-         Con::printf( "Selected resolution not available: %d %d %d",
-            width, height, bpp);
-         return false;
-      }
-   }
-   else
-   {
-      AssertFatal( false, "No resolution list found!!" );
-   }
-
-   // Here if we found a matching resolution in the list
-
-   bool needResurrect = false;
-   if (x86UNIXState->windowCreated())
-   {
-      Con::printf( "Killing the texture manager..." );
-      Game->textureKill();
-      needResurrect = true;
-   }
-
-   // Set the desired GL Attributes
-   SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
-// JMQ: NVIDIA 2802+ doesn't like this setting for stencil size
-//   SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
-   SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 0);
-   SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE, 0);
-   SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE, 0);
-   SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE, 0);
-   SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, 0);
-//    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
-//    SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
-//    SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 6);
-//    SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
-
-   U32 flags = SDL_OPENGL;
-   if (fullScreen)
-      flags |= SDL_FULLSCREEN;
-
-   Con::printf( "Setting screen mode to %dx%dx%d (%s)...", width, height,
-      bpp, ( fullScreen ? "fs" : "w" ) );
-
-   // set the new video mode
-   if (SDL_SetVideoMode(width, height, bpp, flags) == NULL)
-   {
-      Con::printf("Unable to set SDL Video Mode: %s", SDL_GetError());
-      return false;
-   }
-
-   PrintGLAttributes();
-
-   // clear screen here to prevent buffer garbage from being displayed when
-   // video mode is switched
-   glClearColor(0.0, 0.0, 0.0, 0.0);
-   glClear(GL_COLOR_BUFFER_BIT);
-   glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-
-   if ( needResurrect )
-   {
-      // Reload the textures:
-      Con::printf( "Resurrecting the texture manager..." );
-      Game->textureResurrect();
-   }
-
-   if ( gGLState.suppSwapInterval )
-      setVerticalSync( !Con::getBoolVariable( "$pref::Video::disableVerticalSync" ) );
-
-   // reset the window in platform state
-   SDL_SysWMinfo sysinfo;
-   SDL_VERSION(&sysinfo.version);
-   if (SDL_GetWMInfo(&sysinfo) == 0)
-   {
-      Con::printf("Unable to set SDL Video Mode: %s", SDL_GetError());
-      return false;
-   }
-   x86UNIXState->setWindow(sysinfo.info.x11.window);
-
-   // set various other parameters
-   x86UNIXState->setWindowCreated(true);
-   smCurrentRes = NewResolution;
-   Platform::setWindowSize ( width, height );
-   smIsFullScreen = fullScreen;
-   Con::setBoolVariable( "$pref::Video::fullScreen", smIsFullScreen );
-   char tempBuf[15];
-   dSprintf( tempBuf, sizeof( tempBuf ), "%d %d %d",
-      smCurrentRes.w, smCurrentRes.h, smCurrentRes.bpp );
-   Con::setVariable( "$pref::Video::resolution", tempBuf );
-
-   // post a TORQUE_SETVIDEOMODE user event
-   SDL_Event event;
-   event.type = SDL_USEREVENT;
-   event.user.code = TORQUE_SETVIDEOMODE;
-   event.user.data1 = NULL;
-   event.user.data2 = NULL;
-   SDL_PushEvent(&event);
-
-   // reset the caption
-   SDL_WM_SetCaption(x86UNIXState->getWindowName(), NULL);
-
-   // repaint
-   if ( repaint )
-      Con::evaluate( "resetCanvas();" );
-
-   return true;
-}
-
-//------------------------------------------------------------------------------
-void OpenGLDevice::swapBuffers()
-{
-   SDL_GL_SwapBuffers();
-}
-
-//------------------------------------------------------------------------------
-const char* OpenGLDevice::getDriverInfo()
-{
-   const char* vendorString   = (const char*) glGetString( GL_VENDOR );
-   const char* rendererString = (const char*) glGetString( GL_RENDERER );
-   const char* versionString  = (const char*) glGetString( GL_VERSION );
-   const char* extensionsString = (const char*) glGetString( GL_EXTENSIONS );
-
-   U32 bufferLen = ( vendorString ? dStrlen( vendorString ) : 0 )
-                 + ( rendererString ? dStrlen( rendererString ) : 0 )
-                 + ( versionString  ? dStrlen( versionString ) : 0 )
-                 + ( extensionsString ? dStrlen( extensionsString ) : 0 )
-                 + 4;
-
-   char* returnString = Con::getReturnBuffer( bufferLen );
-   dSprintf( returnString, bufferLen, "%s\t%s\t%s\t%s",
-      ( vendorString ? vendorString : "" ),
-      ( rendererString ? rendererString : "" ),
-      ( versionString ? versionString : "" ),
-      ( extensionsString ? extensionsString : "" ) );
-
-   return( returnString );
-}
-
-//------------------------------------------------------------------------------
-bool OpenGLDevice::getGammaCorrection(F32 &g)
-{
-   U16 redtable[256];
-   U16 greentable[256];
-   U16 bluetable[256];
-
-   if (SDL_GetGammaRamp(redtable, greentable, bluetable) == -1)
-   {
-      Con::warnf("getGammaCorrection error: %s", SDL_GetError());
-      return false;
-   }
-
-   F32 csum = 0.0;
-   U32 ccount = 0;
-
-   for (U16 i = 0; i < 256; ++i)
-   {
-      if (i != 0 && redtable[i] != 0 && redtable[i] != 65535)
-      {
-         F64 b = (F64) i/256.0;
-         F64 a = (F64) redtable[i]/65535.0;
-         F32 c = (F32) (mLog(a)/mLog(b));
-
-         csum += c;
-         ++ccount;
-      }
-   }
-   g = csum/ccount;
-
-   return true;
-}
-
-//------------------------------------------------------------------------------
-bool OpenGLDevice::setGammaCorrection(F32 g)
-{
-   U16 redtable[256];
-   U16 greentable[256];
-   U16 bluetable[256];
-
-   for (U16 i = 0; i < 256; ++i)
-      redtable[i] = static_cast<U16>(mPow((F32) i/256.0f, g) * 65535.0f);
-   dMemcpy(greentable,redtable,256*sizeof(U16));
-   dMemcpy(bluetable,redtable,256*sizeof(U16));
-
-   S32 ok = SDL_SetGammaRamp(redtable, greentable, bluetable);
-   if (ok == -1)
-      Con::warnf("Error setting gamma correction: %s", SDL_GetError());
-
-   return ok != -1;
-}
-
-//------------------------------------------------------------------------------
-bool OpenGLDevice::setVerticalSync( bool on )
-{
-   Con::printf("WARNING: OpenGLDevice::setVerticalSync is unimplemented %s %d\n", __FILE__, __LINE__);
-   return false;
-#if 0
-   if ( !gGLState.suppSwapInterval )
-      return( false );
-
-   return( qwglSwapIntervalEXT( on ? 1 : 0 ) );
-#endif
-}
-
-//------------------------------------------------------------------------------
-DisplayDevice* OpenGLDevice::create()
-{
-   return new OpenGLDevice();
-}
-
-#endif // 0
\ No newline at end of file
diff --git a/Engine/source/platformX86UNIX/x86UNIXOGLVideo.h b/Engine/source/platformX86UNIX/x86UNIXOGLVideo.h
deleted file mode 100644
index 63eb5c050..000000000
--- a/Engine/source/platformX86UNIX/x86UNIXOGLVideo.h
+++ /dev/null
@@ -1,58 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#ifndef _X86UNIXOGLVIDEO_H_
-#define _X86UNIXOGLVIDEO_H_
-
-#ifndef _PLATFORMVIDEO_H_
-#include "platform/platformVideo.h"
-#endif
-
-class OpenGLDevice : public DisplayDevice
-{
-      static bool smCanSwitchBitDepth;
-
-      bool mRestoreGamma;
-      U16  mOriginalRamp[256*3];
-
-      void addResolution(S32 width, S32 height, bool check=true);
-
-   public:
-      OpenGLDevice();
-      virtual ~OpenGLDevice();
-
-      void initDevice();
-      bool activate( U32 width, U32 height, U32 bpp, bool fullScreen );
-      void shutdown();
-      void destroy();
-      bool setScreenMode( U32 width, U32 height, U32 bpp, bool fullScreen, bool forceIt = false, bool repaint = true );
-      void swapBuffers();
-      const char* getDriverInfo();
-      bool getGammaCorrection(F32 &g);
-      bool setGammaCorrection(F32 g);
-      bool setVerticalSync( bool on );
-      void loadResolutions();
-
-      static DisplayDevice* create();
-};
-
-#endif // _H_X86UNIXOGLVIDEO
diff --git a/Engine/source/platformX86UNIX/x86UNIXOpenAL.client.cpp b/Engine/source/platformX86UNIX/x86UNIXOpenAL.client.cpp
deleted file mode 100644
index 8e0c021ac..000000000
--- a/Engine/source/platformX86UNIX/x86UNIXOpenAL.client.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-#if 0
-#include "platformX86UNIX/platformX86UNIX.h"
-#include "console/console.h"
-
-#include <dlfcn.h>
-
-#include <al/altypes.h>
-#include <al/alctypes.h>
-#define INITGUID
-#include <al/eaxtypes.h>
-
-
-// Define the OpenAL and Extension Stub functions
-#define AL_FUNCTION(fn_return, fn_name, fn_args, fn_value) fn_return stub_##fn_name fn_args{ fn_value }
-#include <al/al_func.h>
-#include <al/alc_func.h>
-#include <al/eax_func.h>
-#undef AL_FUNCTION
-
-
-// Declare the OpenAL and Extension Function pointers
-// And initialize them to the stub functions
-#define AL_FUNCTION(fn_return,fn_name,fn_args, fn_value) fn_return (*fn_name)fn_args = stub_##fn_name;
-#include <al/al_func.h>
-#include <al/alc_func.h>
-#include <al/eax_func.h>
-#undef AL_FUNCTION
-
-// Declarations for the "emulated" functions (al functions that don't 
-// exist in the loki openal implementation)
-ALboolean emu_alGetBoolean(ALenum param);
-ALint emu_alGetInteger(ALenum param);
-ALfloat emu_alGetFloat(ALenum param);
-ALdouble emu_alGetDouble(ALenum param);
-void emu_alListeneri( ALenum param, ALint value );
-void emu_alGetListener3f(ALenum pname,ALfloat *v1,ALfloat *v2,ALfloat *v3);
-ALCdevice* emu_alcGetContextsDevice(ALCcontext *context);
-
-static void *dlHandle = NULL;
-static char* dlError = "no error";
-
-/*!   Get an "emulated" function address and bind it to the function pointer
-*/
-static bool bindEmulatedFunction(void *&fnAddress, const char *name)
-{
-   fnAddress = NULL;
-
-   if (dStrcmp(name, "alGetBoolean")==0)
-      fnAddress = (void*)&emu_alGetBoolean;
-   else if (dStrcmp(name, "alGetInteger")==0)
-      fnAddress = (void*)&emu_alGetInteger;
-   else if (dStrcmp(name, "alGetFloat")==0)
-      fnAddress = (void*)&emu_alGetFloat;
-   else if (dStrcmp(name, "alGetDouble")==0)
-      fnAddress = (void*)&emu_alGetDouble;
-   else if (dStrcmp(name, "alListeneri")==0)
-      fnAddress = (void*)&emu_alListeneri;
-   else if (dStrcmp(name, "alGetListener3f")==0)
-      fnAddress = (void*)&emu_alGetListener3f;
-   else if (dStrcmp(name, "alcGetContextsDevice")==0)
-      fnAddress = (void*)&emu_alcGetContextsDevice;
-
-   return fnAddress != NULL;
-}
-
-/*!   Get a function address from the OpenAL DLL and bind it to the 
-*     function pointer
-*/
-static bool bindFunction( void *&fnAddress, const char *name )
-{
-   fnAddress = dlsym(dlHandle, name);
-   if( !fnAddress )
-      if (bindEmulatedFunction(fnAddress, name))
-         Con::warnf(ConsoleLogEntry::General, " Missing OpenAL function '%s', using emulated function", name);
-      else
-         Con::errorf(ConsoleLogEntry::General, " Missing OpenAL function '%s'", name);
-   return (fnAddress != NULL);
-}
-
-/*!   Get a function address for an OpenAL extension function and bind it 
-*     to it's function pointer
-*/
-static bool bindExtensionFunction( void *&fnAddress, const char *name )
-{
-   fnAddress = alGetProcAddress( (ALubyte*)name );
-   if( !fnAddress )
-      Con::errorf(ConsoleLogEntry::General, " Missing OpenAL Extension function '%s'", name);
-   return (fnAddress != NULL);
-}
-
-/*!   Bind the functions in the OpenAL DLL to the al interface functions  
-*/
-static bool bindOpenALFunctions()
-{
-   bool result = true;
-   #define AL_FUNCTION(fn_return, fn_name, fn_args, fn_value) result &= bindFunction( *(void**)&fn_name, #fn_name);
-   #include <al/al_func.h>
-   #include <al/alc_func.h>
-   #undef AL_FUNCTION
-   return result;
-}
-
-/*!   Bind the stub functions to the al interface functions  
-*/
-static void unbindOpenALFunctions()
-{
-   #define AL_FUNCTION(fn_return, fn_name, fn_args, fn_value) fn_name = stub_##fn_name;
-   #include <al/al_func.h>
-   #include <al/alc_func.h>
-   #include <al/eax_func.h>
-   #undef AL_FUNCTION
-}
-
-/*!   Bind the EAX Extension functions to the EAX interface functions  
-*/
-static bool bindEAXFunctions()
-{
-   bool result = true;
-   #define AL_FUNCTION(fn_return, fn_name, fn_args, fn_value) result &= bindExtensionFunction( *(void**)&fn_name, #fn_name);
-   #include <al/eax_func.h>
-   #undef AL_FUNCTION
-   return result;
-}
-
-// Definitions for the emulated functions
-ALboolean emu_alGetBoolean(ALenum param)
-{
-   ALboolean alboolean;
-   alGetBooleanv(param, &alboolean);
-   return alboolean;
-}
-
-ALint emu_alGetInteger(ALenum param)
-{
-   ALint alint;
-   alGetIntegerv(param, &alint);
-   return alint;
-}
-
-ALfloat emu_alGetFloat(ALenum param)
-{
-   ALfloat alfloat;
-   alGetFloatv(param, &alfloat);
-   return alfloat;
-}
-
-ALdouble emu_alGetDouble(ALenum param)
-{
-   ALdouble aldouble;
-   alGetDoublev(param, &aldouble);
-   return aldouble;
-}
-
-void emu_alGetListener3f(ALenum pname,ALfloat *v0,ALfloat *v1,ALfloat *v2)
-{
-   ALfloat ptArray[10];
-   ptArray[0] = *v0;
-   ptArray[1] = *v1;
-   ptArray[2] = *v2;
-   alGetListenerfv(pname, ptArray);
-   *v0 = ptArray[0];
-   *v1 = ptArray[1];
-   *v2 = ptArray[2];
-}
-
-void emu_alListeneri( ALenum param, ALint value )
-{
-   alListenerf(param, static_cast<ALfloat>(value));
-}
-
-ALCdevice* emu_alcGetContextsDevice(ALCcontext *context)
-{
-   // this function isn't emulated
-   AssertFatal(false, "alcGetContextsDevice is not available");
-   return NULL;
-}
-
-namespace Audio
-{
-
-/*!   Shutdown and Unload the OpenAL DLL  
-*/
-void OpenALDLLShutdown()
-{
-   if (dlHandle != NULL)
-   {
-      dlclose(dlHandle);
-      // FreeBSD didn't like that const dlerror() was returning.
-      if ((dlError = (char *)dlerror()) != NULL)
-         Con::errorf(ConsoleLogEntry::General, " Error unloading OpenAL Library: %s", dlError);
-   }
-   dlHandle = NULL;
-
-   unbindOpenALFunctions();   
-}   
-
-/*!   Dynamically Loads the OpenAL DLL if present and binds all the functions.
-*     If there is no DLL or an unexpected error occurs binding functions the
-*     stub functions are automatically bound.
-*/
-bool OpenALDLLInit()
-{
-   OpenALDLLShutdown();
-
-   const char* libName = "libopenal.so";
-
-   // these are relative to the current working directory
-   const char* searchPath[] = {
-      "lib",
-      "tplib", // superceeded by "lib", here for backass compatibility
-      "", // i.e.: current working directory
-      NULL // this must be last
-   }; 
-
-   char openalPath[4096];
-   for (int i = 0; searchPath[i] != NULL; ++i)
-   {   
-      dSprintf(openalPath, sizeof(openalPath), "%s/%s/%s",
-         Platform::getWorkingDirectory(), 
-         searchPath[i],
-         libName);
-         
-      Con::printf("		Searching for OpenAl at location : %s", openalPath);
-      dlHandle = dlopen(openalPath, RTLD_NOW);
-      if (dlHandle != NULL)
-      {
-         // found it
-         Con::printf("   Loading OpenAL: %s", openalPath);
-         break;
-      }
-   }
-   
-   if (dlHandle == NULL)
-   {
-      // couldn't find it in our searchPath, try the system path
-      dlHandle = dlopen(libName, RTLD_NOW);
-      if (dlHandle != NULL)
-         Con::printf("   Loading OpenAL from system (dlopen) path");
-   }
-
-   if (dlHandle != NULL)
-   {
-      // if the DLL loaded bind the OpenAL function pointers
-      if(bindOpenALFunctions())
-      {
-         // if EAX is available bind it's function pointers
-         if (alIsExtensionPresent((ALubyte*)"EAX" ))
-            bindEAXFunctions();
-         return(true);
-      }
-
-      // an error occured, shutdown
-      OpenALDLLShutdown();
-   }
-   else
-   {
-      Con::errorf(ConsoleLogEntry::General, " Error loading OpenAL Library: %s", dlerror());
-   }
-   return(false);
-}
-
-} // end namespace Audio
-
-#endif //0
\ No newline at end of file
diff --git a/Engine/source/platformX86UNIX/x86UNIXPlatform.cpp b/Engine/source/platformX86UNIX/x86UNIXPlatform.cpp
deleted file mode 100644
index 4d72a7bbd..000000000
--- a/Engine/source/platformX86UNIX/x86UNIXPlatform.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-#include "platform/platform.h"
-#ifndef TORQUE_SDL
-bool Platform::openWebBrowser(const char* webAddress)
-{
-   String startingURL(webAddress);
-   String filteredURL;
-
-   U32 length = startingURL.length();
-   for(U32 i = 0; i < length; i++)
-   {
-      filteredURL = filteredURL + '\\' + startingURL[i];
-   }
-
-   String runCommand = "URL=" + filteredURL + "; xdg-open $URL > /dev/null 2> /dev/null";
-
-   S32 statusCode;
-   statusCode = system(runCommand.c_str());
-
-   if(statusCode == 0)
-   {
-      return true;
-   }
-
-   return false;
-}
-#endif
-#ifdef TORQUE_DEDICATED
-// XA: New class for the unix unicode font
-class PlatformFont;
-PlatformFont *createPlatformFont(const char *name, dsize_t size, U32 charset /* = TGE_ANSI_CHARSET */) { return NULL; }
-#endif
diff --git a/Engine/source/platformX86UNIX/x86UNIXRedbook.cpp b/Engine/source/platformX86UNIX/x86UNIXRedbook.cpp
deleted file mode 100644
index d24902230..000000000
--- a/Engine/source/platformX86UNIX/x86UNIXRedbook.cpp
+++ /dev/null
@@ -1,269 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#include "console/console.h"
-#include "platformX86UNIX/platformX86UNIX.h"
-#include "platform/platformRedBook.h"
-#include "core/strings/stringFunctions.h"
-
-#if defined(__linux__)
-#include <linux/cdrom.h>
-#include <sys/ioctl.h>
-#include <errno.h>
-#include <string.h>
-#endif
-
-#include <SDL.h>
-
-class SDL_CD; // TODO SDL remove
-
-class UnixRedBookDevice : public RedBookDevice
-{
-#if !defined(__FreeBSD__)
-   private:
-      S32 mDeviceId;
-      SDL_CD *mCD;
-      cdrom_volctrl mOriginalVolume;
-      bool mVolumeInitialized;
-#endif
-      bool mPlaying;
-
-      void openVolume();
-      void closeVolume();
-      void setLastError(const char *);
-
-   public:
-      UnixRedBookDevice();
-      ~UnixRedBookDevice();
-
-      bool open();
-      bool close();
-      bool play(U32);
-      bool stop();
-      bool getTrackCount(U32 *);
-      bool getVolume(F32 *);
-      bool setVolume(F32);
-
-      bool isPlaying() { return mPlaying; }
-      bool updateStatus();
-      void setDeviceInfo(S32 deviceId, const char *deviceName);
-};
-
-//-------------------------------------------------------------------------------
-// Class: UnixRedBookDevice
-//-------------------------------------------------------------------------------
-UnixRedBookDevice::UnixRedBookDevice()
-{
-#if !defined(__FreeBSD__)
-   mVolumeInitialized = false;
-   mDeviceId = -1;
-   mDeviceName = NULL;
-   mCD = NULL;
-   mPlaying = false;
-#endif	// !defined(__FreeBSD__)
-}
-
-//------------------------------------------------------------------------------
-UnixRedBookDevice::~UnixRedBookDevice()
-{
-#if !defined(__FreeBSD__)
-   close();
-#endif	// !defined(__FreeBSD__)
-}
-
-//------------------------------------------------------------------------------
-bool UnixRedBookDevice::updateStatus()
-{
-   return false; // TODO LINUX
-}
-
-//------------------------------------------------------------------------------
-void UnixRedBookDevice::setDeviceInfo(S32 deviceId, const char *deviceName)
-{
-#if !defined(__FreeBSD__)
-   mDeviceId = deviceId;
-   dsize_t deviceNameLen = dStrlen(deviceName) + 1;
-   mDeviceName = new char[deviceNameLen];
-   dStrcpy(mDeviceName, deviceName, deviceNameLen);
-#endif	// !defined(__FreeBSD__)
-}
-
-//------------------------------------------------------------------------------
-bool UnixRedBookDevice::open()
-{
-   return false; // TODO LINUX
-}
-
-//------------------------------------------------------------------------------
-bool UnixRedBookDevice::close()
-{
-   return false; // TODO LINUX
-}
-
-//------------------------------------------------------------------------------
-bool UnixRedBookDevice::play(U32 track)
-{
-   return false; // TODO LINUX
-}
-
-//------------------------------------------------------------------------------
-bool UnixRedBookDevice::stop()
-{
-   return false; // TODO LINUX
-}
-
-//------------------------------------------------------------------------------
-bool UnixRedBookDevice::getTrackCount(U32 * numTracks)
-{
-   return false; // TODO LINUX
-}
-
-template <class Type>
-static inline Type max(Type v1, Type v2)
-{
-#if !defined(__FreeBSD__)
-   if (v1 <= v2)
-      return v2;
-   else
-      return v1;
-#endif	// !defined(__FreeBSD__)
-}
-//------------------------------------------------------------------------------
-bool UnixRedBookDevice::getVolume(F32 * volume)
-{
-#if !defined(__FreeBSD__)
-   if(!mAcquired)
-   {
-      setLastError("Device has not been acquired");
-      return(false);
-   }
-
-   if(!mVolumeInitialized)
-   {
-      setLastError("Volume failed to initialize");
-      return(false);
-   }
-
-#if defined(__linux__)
-   AssertFatal(0, "SDL CD not implemented");
-   return true;
-#else
-   return(false);
-#endif
-#endif	// !defined(__FreeBSD__)
-}
-
-//------------------------------------------------------------------------------
-bool UnixRedBookDevice::setVolume(F32 volume)
-{
-#if !defined(__FreeBSD__)
-   if(!mAcquired)
-   {
-      setLastError("Device has not been acquired");
-      return(false);
-   }
-
-   if(!mVolumeInitialized)
-   {
-      setLastError("Volume failed to initialize");
-      return(false);
-   }
-
-#if defined(__linux__)
-   AssertFatal(0, "SDL CD not implemented");
-   return true;
-#else
-   return(false);
-#endif
-#endif	// !defined(__FreeBSD__)
-}
-
-//------------------------------------------------------------------------------
-void UnixRedBookDevice::openVolume()
-{
-#if !defined(__FreeBSD__)
-// Its unforunate that we have to do it this way, but SDL does not currently
-// support setting CD audio volume
-#if defined(__linux__)
-   AssertFatal(0, "SDL CD not implemented");
-#else
-   setLastError("Volume failed to initialize");
-#endif
-#endif	// !defined(__FreeBSD__)
-}
-
-void UnixRedBookDevice::closeVolume()
-{
-#if !defined(__FreeBSD__)
-   if(!mVolumeInitialized)
-      return;
-
-#if defined(__linux__)
-   AssertFatal(0, "SDL CD not implemented");
-#endif
-
-   mVolumeInitialized = false;
-#endif	// !defined(__FreeBSD__)
-}
-
-//------------------------------------------------------------------------------
-void UnixRedBookDevice::setLastError(const char * error)
-{
-#if !defined(__FreeBSD__)
-   RedBook::setLastError(error);
-#endif	// !defined(__FreeBSD__)
-}
-
-//------------------------------------------------------------------------------
-void InstallRedBookDevices()
-{
-
-}
-
-//------------------------------------------------------------------------------
-void PollRedbookDevices()
-{
-#if !defined(__FreeBSD__)
-   UnixRedBookDevice *device = dynamic_cast<UnixRedBookDevice*>(RedBook::getCurrentDevice());
-
-   if (device == NULL || !device->isPlaying())
-      return;
-
-   static const U32 PollDelay = 1000;
-
-   static U32 lastPollTime = 0;
-   U32 curTime = Platform::getVirtualMilliseconds();
-
-   if (lastPollTime != 0 &&
-      (curTime - lastPollTime) < PollDelay)
-      return;
-
-   lastPollTime = curTime;
-
-   if (device->isPlaying())
-   {
-      device->updateStatus();
-      if (!device->isPlaying())
-         RedBook::handleCallback(RedBook::PlayFinished);
-   }
-#endif	// !defined(__FreeBSD__)
-}

From a24149ba3b0783d59e6fd95c46ddb101c75d87da Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Sun, 14 Nov 2021 14:05:16 -0500
Subject: [PATCH 252/399] * Adjustment: Tweak the include paths for
 platformPOSIX.h.

---
 Engine/source/platformPOSIX/POSIXConsole.cpp  |    2 +-
 Engine/source/platformPOSIX/POSIXFileio.cpp   | 1263 ++++++++++++++++-
 Engine/source/platformPOSIX/POSIXMemory.cpp   |    2 +-
 Engine/source/platformPOSIX/POSIXState.h      |    2 +-
 Engine/source/platformPOSIX/POSIXStrings.cpp  |    2 +-
 Engine/source/platformPOSIX/POSIXUtils.cpp    |    2 +-
 .../platformPOSIX.h}                          |    4 +-
 .../source/platformX86UNIX/x86UNIXFileio.cpp  | 1261 ----------------
 8 files changed, 1264 insertions(+), 1274 deletions(-)
 rename Engine/source/{platformX86UNIX/platformX86UNIX.h => platformPOSIX/platformPOSIX.h} (97%)
 delete mode 100644 Engine/source/platformX86UNIX/x86UNIXFileio.cpp

diff --git a/Engine/source/platformPOSIX/POSIXConsole.cpp b/Engine/source/platformPOSIX/POSIXConsole.cpp
index 5e9f810ec..28ed43be8 100644
--- a/Engine/source/platformPOSIX/POSIXConsole.cpp
+++ b/Engine/source/platformPOSIX/POSIXConsole.cpp
@@ -20,7 +20,7 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "platformX86UNIX/platformX86UNIX.h"
+#include "platformPOSIX/platformPOSIX.h"
 #include "platformPOSIX/POSIXStdConsole.h"
 #include "platformPOSIX/POSIXUtils.h"
 #include "platform/input/event.h"
diff --git a/Engine/source/platformPOSIX/POSIXFileio.cpp b/Engine/source/platformPOSIX/POSIXFileio.cpp
index 8bdcea7b5..a9e6a7046 100644
--- a/Engine/source/platformPOSIX/POSIXFileio.cpp
+++ b/Engine/source/platformPOSIX/POSIXFileio.cpp
@@ -1,3 +1,62 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2012 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+
+/* JMQ:
+
+   Here's the scoop on unix file IO.  The windows platform makes some
+   assumptions about fileio: 1) the file system is case-insensitive, and
+   2) the platform can write to the directory in which
+   the game is running.  Both of these are usually false on linux.  So, to
+   compensate, we "route" created files and directories to the user's home
+   directory (see GetPrefPath()).  When a file is to be accessed, the code
+   looks in the home directory first.  If the file is not found there and the
+   open mode is read only, the code will look in the game installation
+   directory.  Files are never created or modified in the game directory.
+
+   For case-sensitivity, the MungePath code will test whether a given path
+   specified by the engine exists.  If not, it will use the ResolvePathCaseInsensitive function
+   which will try to determine if an actual filesystem path matches the
+   specified path case insensitive.  If one is found, the actual path
+   transparently (we hope) replaces the one requested by the engine.
+
+   The preference directory is global to all torque executables with the same
+   name.  You should make sure you keep it clean if you build from multiple
+   torque development trees.
+*/
+
+#if defined(__FreeBSD__)
+#include <sys/types.h>
+#endif
+#include <utime.h>
+
+/* these are for reading directors, getting stats, etc. */
+#include <dirent.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <stdlib.h>
+
 #include "core/fileio.h"
 #include "core/util/tVector.h"
 #include "core/stringTable.h"
@@ -7,10 +66,6 @@
 #include "cinterface/c_controlInterface.h"
 #include "core/volume.h"
 
-/* these are for reading directors, getting stats, etc. */
-#include <dirent.h>
-#include <sys/stat.h>
-
 const int MaxPath = PATH_MAX;
 
 //------------------------------------------------------------------------------
@@ -87,4 +142,1202 @@ bool ResolvePathCaseInsensitive(char* pathName, S32 pathNameSize, bool requiredA
 
     dStrncpy(pathName, tempBuf, pathNameSize);
     return foundMatch;
-}
\ No newline at end of file
+}
+
+#ifndef __APPLE__
+
+// evil hack to get around insane X windows #define-happy header files
+#ifdef Status
+#undef Status
+#endif
+
+#include "platformX86UNIX/platformX86UNIX.h"
+
+extern int x86UNIXOpen(const char *path, int oflag);
+extern int x86UNIXClose(int fd);
+extern ssize_t x86UNIXRead(int fd, void *buf, size_t nbytes);
+extern ssize_t x86UNIXWrite(int fd, const void *buf, size_t nbytes);
+extern bool ResolvePathCaseInsensitive(char* pathName, S32 pathNameSize, bool requiredAbsolute);
+
+const int MaxPath = PATH_MAX;
+
+namespace
+{
+    const char sTempDir[] = "/tmp/";
+
+    static char sBinPathName[MaxPath] = "";
+    static char *sBinName = sBinPathName;
+    bool sUseRedirect = true;
+}
+
+StringTableEntry osGetTemporaryDirectory()
+{
+    return StringTable->insert(sTempDir);
+}
+
+// Various handy utility functions:
+//------------------------------------------------------------------------------
+// find all \ in a path and convert them in place to /
+static void ForwardSlash(char *str)
+{
+    while(*str)
+    {
+        if(*str == '\\')
+            *str = '/';
+        str++;
+    }
+}
+
+//------------------------------------------------------------------------------
+// copy a file from src to dest
+static bool CopyFile(const char* src, const char* dest)
+{
+    S32 srcFd = x86UNIXOpen(src, O_RDONLY);
+    S32 destFd = x86UNIXOpen(dest, O_WRONLY | O_CREAT | O_TRUNC);
+    bool error = false;
+
+    if (srcFd != -1 && destFd != -1)
+    {
+        const int BufSize = 8192;
+        char buf[BufSize];
+        S32 bytesRead = 0;
+        while ((bytesRead = x86UNIXRead(srcFd, buf, BufSize)) > 0)
+        {
+            // write data
+            if (x86UNIXWrite(destFd, buf, bytesRead) == -1)
+            {
+                error = true;
+                break;
+            }
+        }
+
+        if (bytesRead == -1)
+            error = true;
+    }
+
+    if (srcFd != -1)
+        x86UNIXClose(srcFd);
+    if (destFd != -1)
+        x86UNIXClose(destFd);
+
+    if (error)
+    {
+        Con::errorf("Error copying file: %s, %s", src, dest);
+        remove(dest);
+    }
+    return error;
+}
+
+bool dPathCopy(const char *fromName, const char *toName, bool nooverwrite)
+{
+    return CopyFile(fromName,toName);
+}
+
+//-----------------------------------------------------------------------------
+static char sgPrefDir[MaxPath];
+static bool sgPrefDirInitialized = false;
+
+// get the "pref dir", which is where game output files are stored.  the pref
+// dir is ~/PREF_DIR_ROOT/PREF_DIR_GAME_NAME
+static const char* GetPrefDir()
+{
+    if (sgPrefDirInitialized)
+        return sgPrefDir;
+
+    if (sUseRedirect)
+    {
+        const char *home = getenv("HOME");
+        AssertFatal(home, "HOME environment variable must be set");
+
+        dSprintf(sgPrefDir, MaxPath, "%s/%s/%s",
+                 home, PREF_DIR_ROOT, PREF_DIR_GAME_NAME);
+    }
+    else
+    {
+        getcwd(sgPrefDir, MaxPath);
+    }
+
+    sgPrefDirInitialized = true;
+    return sgPrefDir;
+}
+
+//-----------------------------------------------------------------------------
+// Returns true if the pathname exists, false otherwise.  If isFile is true,
+// the pathname is assumed to be a file path, and only the directory part
+// will be examined (everything before last /)
+bool DirExists(char* pathname, bool isFile)
+{
+    static char testpath[20000];
+    dStrncpy(testpath, pathname, sizeof(testpath));
+    if (isFile)
+    {
+        // find the last / and make it into null
+        char* lastSlash = dStrrchr(testpath, '/');
+        if (lastSlash != NULL)
+            *lastSlash = 0;
+    }
+    return Platform::isDirectory(testpath);
+}
+
+//-----------------------------------------------------------------------------
+// Munge the specified path.
+static void MungePath(char* dest, S32 destSize,
+                      const char* src, const char* absolutePrefix)
+{
+    char tempBuf[MaxPath];
+    dStrncpy(dest, src, MaxPath);
+
+    // translate all \ to /
+    ForwardSlash(dest);
+
+    // if it is relative, make it absolute with the absolutePrefix
+    if (dest[0] != '/')
+    {
+        AssertFatal(absolutePrefix, "Absolute Prefix must not be NULL");
+
+        dSprintf(tempBuf, MaxPath, "%s/%s",
+                 absolutePrefix, dest);
+
+        // copy the result back into dest
+        dStrncpy(dest, tempBuf, destSize);
+    }
+
+    // if the path exists, we're done
+    struct stat filestat;
+    if (stat(dest, &filestat) != -1)
+        return;
+
+    // otherwise munge the case of the path
+    ResolvePathCaseInsensitive(dest, destSize, true);
+}
+
+//-----------------------------------------------------------------------------
+enum
+{
+    TOUCH,
+    DELETE
+};
+
+//-----------------------------------------------------------------------------
+// perform a modification on the specified file.  allowed modifications are
+// specified in the enum above.
+bool ModifyFile(const char * name, S32 modType)
+{
+    if(!name || (dStrlen(name) >= MaxPath) || dStrstr(name, "../") != NULL)
+        return(false);
+
+    // if its absolute skip it
+    if (name[0]=='/' || name[0]=='\\')
+        return(false);
+
+    // only modify files in home directory
+    char prefPathName[MaxPath];
+    MungePath(prefPathName, MaxPath, name, GetPrefDir());
+
+    if (modType == TOUCH)
+        return(utime(prefPathName, 0) != -1);
+    else if (modType == DELETE)
+        return (remove(prefPathName) == 0);
+    else
+        AssertFatal(false, "Unknown File Mod type");
+    return false;
+}
+
+//-----------------------------------------------------------------------------
+static bool RecurseDumpPath(const char *path, const char* relativePath, const char *pattern, Vector<Platform::FileInfo> &fileVector, S32 currentDepth = 0, S32 recurseDepth = -1)
+{
+    char search[1024];
+
+    dSprintf(search, sizeof(search), "%s", path, pattern);
+
+    DIR *directory = opendir(search);
+
+    if (directory == NULL)
+        return false;
+
+    struct dirent *fEntry;
+    fEntry = readdir(directory);		// read the first "file" in the directory
+
+    if (fEntry == NULL)
+    {
+        closedir(directory);
+        return false;
+    }
+
+    do
+    {
+        char filename[BUFSIZ+1];
+        struct stat fStat;
+
+        dSprintf(filename, sizeof(filename), "%s/%s", search, fEntry->d_name); // "construct" the file name
+        stat(filename, &fStat); // get the file stats
+
+        if ( (fStat.st_mode & S_IFMT) == S_IFDIR )
+        {
+            // Directory
+            // skip . and .. directories
+            if (dStrcmp(fEntry->d_name, ".") == 0 || dStrcmp(fEntry->d_name, "..") == 0)
+                continue;
+
+            // skip excluded directories
+            if( Platform::isExcludedDirectory(fEntry->d_name))
+                continue;
+
+
+            char child[MaxPath];
+            dSprintf(child, sizeof(child), "%s/%s", path, fEntry->d_name);
+            char* childRelative = NULL;
+            char childRelativeBuf[MaxPath];
+            if (relativePath)
+            {
+                dSprintf(childRelativeBuf, sizeof(childRelativeBuf), "%s/%s",
+                         relativePath, fEntry->d_name);
+                childRelative = childRelativeBuf;
+            }
+            if (currentDepth < recurseDepth || recurseDepth == -1 )
+                RecurseDumpPath(child, childRelative, pattern, fileVector, currentDepth+1, recurseDepth);
+        }
+        else
+        {
+            // File
+
+            // add it to the list
+            fileVector.increment();
+            Platform::FileInfo& rInfo = fileVector.last();
+
+            if (relativePath)
+                rInfo.pFullPath = StringTable->insert(relativePath);
+            else
+                rInfo.pFullPath = StringTable->insert(path);
+            rInfo.pFileName = StringTable->insert(fEntry->d_name);
+            rInfo.fileSize  = fStat.st_size;
+            //dPrintf("Adding file: %s/%s\n", rInfo.pFullPath, rInfo.pFileName);
+        }
+
+    } while( (fEntry = readdir(directory)) != NULL );
+
+    closedir(directory);
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+bool dFileDelete(const char * name)
+{
+    return ModifyFile(name, DELETE);
+}
+
+//-----------------------------------------------------------------------------
+bool dFileTouch(const char * name)
+{
+    return ModifyFile(name, TOUCH);
+}
+
+bool dFileRename(const char *oldName, const char *newName)
+{
+    AssertFatal( oldName != NULL && newName != NULL, "dFileRename - NULL file name" );
+
+    // only modify files in home directory
+    TempAlloc<char> oldPrefPathName(MaxPath);
+    TempAlloc<char> newPrefPathName(MaxPath);
+    MungePath(oldPrefPathName, MaxPath, oldName, GetPrefDir());
+    MungePath(newPrefPathName, MaxPath, newName, GetPrefDir());
+
+    return rename(oldPrefPathName, newPrefPathName) == 0;
+}
+
+//-----------------------------------------------------------------------------
+// Constructors & Destructor
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+// After construction, the currentStatus will be Closed and the capabilities
+// will be 0.
+//-----------------------------------------------------------------------------
+File::File()
+        : currentStatus(Closed), capability(0)
+{
+    //    AssertFatal(sizeof(int) == sizeof(void *), "File::File: cannot cast void* to int");
+
+    handle = (void *)NULL;
+}
+
+//-----------------------------------------------------------------------------
+// insert a copy constructor here... (currently disabled)
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+// Destructor
+//-----------------------------------------------------------------------------
+File::~File()
+{
+    close();
+    handle = (void *)NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Open a file in the mode specified by openMode (Read, Write, or ReadWrite).
+// Truncate the file if the mode is either Write or ReadWrite and truncate is
+// true.
+//
+// Sets capability appropriate to the openMode.
+// Returns the currentStatus of the file.
+//-----------------------------------------------------------------------------
+File::FileStatus File::open(const char *filename, const AccessMode openMode)
+{
+    AssertFatal(NULL != filename, "File::open: NULL filename");
+    AssertWarn(NULL == handle, "File::open: handle already valid");
+
+    // Close the file if it was already open...
+    if (Closed != currentStatus)
+        close();
+
+    char prefPathName[MaxPath];
+    char gamePathName[MaxPath];
+    char cwd[MaxPath];
+    getcwd(cwd, MaxPath);
+    MungePath(prefPathName, MaxPath, filename, GetPrefDir());
+    MungePath(gamePathName, MaxPath, filename, cwd);
+
+    int oflag;
+    struct stat filestat;
+    handle = (void *)dRealMalloc(sizeof(int));
+
+    switch (openMode)
+    {
+        case Read:
+            oflag = O_RDONLY;
+            break;
+        case Write:
+            oflag = O_WRONLY | O_CREAT | O_TRUNC;
+            break;
+        case ReadWrite:
+            oflag = O_RDWR | O_CREAT;
+            // if the file does not exist copy it before reading/writing
+            if (stat(prefPathName, &filestat) == -1)
+                bool ret = CopyFile(gamePathName, prefPathName);
+            break;
+        case WriteAppend:
+            oflag = O_WRONLY | O_CREAT | O_APPEND;
+            // if the file does not exist copy it before appending
+            if (stat(prefPathName, &filestat) == -1)
+                bool ret = CopyFile(gamePathName, prefPathName);
+            break;
+        default:
+            AssertFatal(false, "File::open: bad access mode");    // impossible
+    }
+
+    // if we are writing, make sure output path exists
+    if (openMode == Write || openMode == ReadWrite || openMode == WriteAppend)
+        Platform::createPath(prefPathName);
+
+    int fd = -1;
+    fd = x86UNIXOpen(prefPathName, oflag);
+    if (fd == -1 && openMode == Read)
+        // for read only files we can use the gamePathName
+        fd = x86UNIXOpen(gamePathName, oflag);
+
+    dMemcpy(handle, &fd, sizeof(int));
+
+#ifdef DEBUG
+    //   fprintf(stdout,"fd = %d, handle = %d\n", fd, *((int *)handle));
+#endif
+
+    if (*((int *)handle) == -1)
+    {
+        // handle not created successfully
+        Con::errorf("Can't open file: %s", filename);
+        return setStatus();
+    }
+    else
+    {
+        // successfully created file, so set the file capabilities...
+        switch (openMode)
+        {
+            case Read:
+                capability = U32(FileRead);
+                break;
+            case Write:
+            case WriteAppend:
+                capability = U32(FileWrite);
+                break;
+            case ReadWrite:
+                capability = U32(FileRead)  |
+                             U32(FileWrite);
+                break;
+            default:
+                AssertFatal(false, "File::open: bad access mode");
+        }
+        return currentStatus = Ok;                                // success!
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Get the current position of the file pointer.
+//-----------------------------------------------------------------------------
+U32 File::getPosition() const
+{
+    AssertFatal(Closed != currentStatus, "File::getPosition: file closed");
+    AssertFatal(NULL != handle, "File::getPosition: invalid file handle");
+
+#ifdef DEBUG
+    //   fprintf(stdout, "handle = %d\n",*((int *)handle));fflush(stdout);
+#endif
+    return (U32) lseek(*((int *)handle), 0, SEEK_CUR);
+}
+
+//-----------------------------------------------------------------------------
+// Set the position of the file pointer.
+// Absolute and relative positioning is supported via the absolutePos
+// parameter.
+//
+// If positioning absolutely, position MUST be positive - an IOError results if
+// position is negative.
+// Position can be negative if positioning relatively, however positioning
+// before the start of the file is an IOError.
+//
+// Returns the currentStatus of the file.
+//-----------------------------------------------------------------------------
+File::FileStatus File::setPosition(S32 position, bool absolutePos)
+{
+    AssertFatal(Closed != currentStatus, "File::setPosition: file closed");
+    AssertFatal(NULL != handle, "File::setPosition: invalid file handle");
+
+    if (Ok != currentStatus && EOS != currentStatus)
+        return currentStatus;
+
+    U32 finalPos = 0;
+
+    if (absolutePos)
+    {
+        AssertFatal(0 <= position, "File::setPosition: negative absolute position");
+
+        // position beyond EOS is OK
+        finalPos = lseek(*((int *)handle), position, SEEK_SET);
+    }
+    else
+    {
+        AssertFatal((getPosition() >= (U32)abs(position) && 0 > position) || 0 <= position, "File::setPosition: negative relative position");
+
+        // position beyond EOS is OK
+        finalPos = lseek(*((int *)handle), position, SEEK_CUR);
+    }
+
+    if (0xffffffff == finalPos)
+        return setStatus();                                        // unsuccessful
+    else if (finalPos >= getSize())
+        return currentStatus = EOS;                                // success, at end of file
+    else
+        return currentStatus = Ok;                                // success!
+}
+
+//-----------------------------------------------------------------------------
+// Get the size of the file in bytes.
+// It is an error to query the file size for a Closed file, or for one with an
+// error status.
+//-----------------------------------------------------------------------------
+U32 File::getSize() const
+{
+    AssertWarn(Closed != currentStatus, "File::getSize: file closed");
+    AssertFatal(NULL != handle, "File::getSize: invalid file handle");
+
+    if (Ok == currentStatus || EOS == currentStatus)
+    {
+        long	currentOffset = getPosition();                  // keep track of our current position
+        long	fileSize;
+        lseek(*((int *)handle), 0, SEEK_END);                     // seek to the end of the file
+        fileSize = getPosition();                               // get the file size
+        lseek(*((int *)handle), currentOffset, SEEK_SET);         // seek back to our old offset
+        return fileSize;                                        // success!
+    }
+    else
+        return 0;                                               // unsuccessful
+}
+
+//-----------------------------------------------------------------------------
+// Flush the file.
+// It is an error to flush a read-only file.
+// Returns the currentStatus of the file.
+//-----------------------------------------------------------------------------
+File::FileStatus File::flush()
+{
+    AssertFatal(Closed != currentStatus, "File::flush: file closed");
+    AssertFatal(NULL != handle, "File::flush: invalid file handle");
+    AssertFatal(true == hasCapability(FileWrite), "File::flush: cannot flush a read-only file");
+
+    if (fsync(*((int *)handle)) == 0)
+        return currentStatus = Ok;                                // success!
+    else
+        return setStatus();                                       // unsuccessful
+}
+
+//-----------------------------------------------------------------------------
+// Close the File.
+//
+// Returns the currentStatus
+//-----------------------------------------------------------------------------
+File::FileStatus File::close()
+{
+    // if the handle is non-NULL, close it if necessary and free it
+    if (NULL != handle)
+    {
+        // make a local copy of the handle value and
+        // free the handle
+        int handleVal = *((int *)handle);
+        dRealFree(handle);
+        handle = (void *)NULL;
+
+        // close the handle if it is valid
+        if (handleVal != -1 && x86UNIXClose(handleVal) != 0)
+            return setStatus();                                    // unsuccessful
+    }
+    // Set the status to closed
+    return currentStatus = Closed;
+}
+
+//-----------------------------------------------------------------------------
+// Self-explanatory.
+//-----------------------------------------------------------------------------
+File::FileStatus File::getStatus() const
+{
+    return currentStatus;
+}
+
+//-----------------------------------------------------------------------------
+// Sets and returns the currentStatus when an error has been encountered.
+//-----------------------------------------------------------------------------
+File::FileStatus File::setStatus()
+{
+    Con::printf("File IO error: %s", strerror(errno));
+    return currentStatus = IOError;
+}
+
+//-----------------------------------------------------------------------------
+// Sets and returns the currentStatus to status.
+//-----------------------------------------------------------------------------
+File::FileStatus File::setStatus(File::FileStatus status)
+{
+    return currentStatus = status;
+}
+
+//-----------------------------------------------------------------------------
+// Read from a file.
+// The number of bytes to read is passed in size, the data is returned in src.
+// The number of bytes read is available in bytesRead if a non-Null pointer is
+// provided.
+//-----------------------------------------------------------------------------
+File::FileStatus File::read(U32 size, char *dst, U32 *bytesRead)
+{
+#ifdef DEBUG
+    //   fprintf(stdout,"reading %d bytes\n",size);fflush(stdout);
+#endif
+    AssertFatal(Closed != currentStatus, "File::read: file closed");
+    AssertFatal(NULL != handle, "File::read: invalid file handle");
+    AssertFatal(NULL != dst, "File::read: NULL destination pointer");
+    AssertFatal(true == hasCapability(FileRead), "File::read: file lacks capability");
+    AssertWarn(0 != size, "File::read: size of zero");
+
+    /* show stats for this file */
+#ifdef DEBUG
+    //struct stat st;
+ //fstat(*((int *)handle), &st);
+ //fprintf(stdout,"file size = %d\n", st.st_size);
+#endif
+    /****************************/
+
+    if (Ok != currentStatus || 0 == size)
+        return currentStatus;
+    else
+    {
+        long lastBytes;
+        long *bytes = (NULL == bytesRead) ? &lastBytes : (long *)bytesRead;
+        if ( (*((U32 *)bytes) = x86UNIXRead(*((int *)handle), dst, size)) == -1)
+        {
+#ifdef DEBUG
+            //   fprintf(stdout,"unsuccessful: %d\n", *((U32 *)bytes));fflush(stdout);
+#endif
+            return setStatus();                                    // unsuccessful
+        } else {
+            //            dst[*((U32 *)bytes)] = '\0';
+            if (*((U32 *)bytes) != size || *((U32 *)bytes) == 0) {
+#ifdef DEBUG
+                //  fprintf(stdout,"end of stream: %d\n", *((U32 *)bytes));fflush(stdout);
+#endif
+                return currentStatus = EOS;                        // end of stream
+            }
+        }
+    }
+    //    dst[*bytesRead] = '\0';
+#ifdef DEBUG
+    //fprintf(stdout, "We read:\n");
+ //fprintf(stdout, "====================================================\n");
+ //fprintf(stdout, "%s\n",dst);
+ //fprintf(stdout, "====================================================\n");
+ //fprintf(stdout,"read ok: %d\n", *bytesRead);fflush(stdout);
+#endif
+    return currentStatus = Ok;                                    // successfully read size bytes
+}
+
+//-----------------------------------------------------------------------------
+// Write to a file.
+// The number of bytes to write is passed in size, the data is passed in src.
+// The number of bytes written is available in bytesWritten if a non-Null
+// pointer is provided.
+//-----------------------------------------------------------------------------
+File::FileStatus File::write(U32 size, const char *src, U32 *bytesWritten)
+{
+    // JMQ: despite the U32 parameters, the maximum filesize supported by this
+    // function is probably the max value of S32, due to the unix syscall
+    // api.
+    AssertFatal(Closed != currentStatus, "File::write: file closed");
+    AssertFatal(NULL != handle, "File::write: invalid file handle");
+    AssertFatal(NULL != src, "File::write: NULL source pointer");
+    AssertFatal(true == hasCapability(FileWrite), "File::write: file lacks capability");
+    AssertWarn(0 != size, "File::write: size of zero");
+
+    if ((Ok != currentStatus && EOS != currentStatus) || 0 == size)
+        return currentStatus;
+    else
+    {
+        S32 numWritten = x86UNIXWrite(*((int *)handle), src, size);
+        if (numWritten < 0)
+            return setStatus();
+
+        if (bytesWritten)
+            *bytesWritten = static_cast<U32>(numWritten);
+        return currentStatus = Ok;
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Self-explanatory.  JMQ: No explanation needed.  Move along.  These aren't
+// the droids you're looking for.
+//-----------------------------------------------------------------------------
+bool File::hasCapability(Capability cap) const
+{
+    return (0 != (U32(cap) & capability));
+}
+
+//-----------------------------------------------------------------------------
+S32 Platform::compareFileTimes(const FileTime &a, const FileTime &b)
+{
+    if(a > b)
+        return 1;
+    if(a < b)
+        return -1;
+    return 0;
+}
+
+//-----------------------------------------------------------------------------
+static bool GetFileTimes(const char *filePath, FileTime *createTime, FileTime *modifyTime)
+{
+    struct stat fStat;
+
+    if (stat(filePath, &fStat) == -1)
+        return false;
+
+    if(createTime)
+    {
+        // no where does SysV/BSD UNIX keep a record of a file's
+        // creation time.  instead of creation time I'll just use
+        // changed time for now.
+        *createTime = fStat.st_ctime;
+    }
+    if(modifyTime)
+    {
+        *modifyTime = fStat.st_mtime;
+    }
+
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+bool Platform::getFileTimes(const char *filePath, FileTime *createTime, FileTime *modifyTime)
+{
+    char pathName[MaxPath];
+
+    // if it starts with cwd, we need to strip that off so that we can look for
+    // the file in the pref dir
+    char cwd[MaxPath];
+    getcwd(cwd, MaxPath);
+    if (dStrstr(filePath, cwd) == filePath)
+        filePath = filePath + dStrlen(cwd) + 1;
+
+    // if its relative, first look in the pref dir
+    if (filePath[0] != '/' && filePath[0] != '\\')
+    {
+        MungePath(pathName, MaxPath, filePath, GetPrefDir());
+        if (GetFileTimes(pathName, createTime, modifyTime))
+            return true;
+    }
+
+    // here if the path is absolute or not in the pref dir
+    MungePath(pathName, MaxPath, filePath, cwd);
+    return GetFileTimes(pathName, createTime, modifyTime);
+}
+
+//-----------------------------------------------------------------------------
+bool Platform::createPath(const char *file)
+{
+    char pathbuf[MaxPath];
+    const char *dir;
+    pathbuf[0] = 0;
+    U32 pathLen = 0;
+
+    // all paths should be created in home directory
+    char prefPathName[MaxPath];
+    MungePath(prefPathName, MaxPath, file, GetPrefDir());
+    file = prefPathName;
+
+    // does the directory exist already?
+    if (DirExists(prefPathName, true)) // true means that the path is a filepath
+        return true;
+
+    while((dir = dStrchr(file, '/')) != NULL)
+    {
+        dStrncpy(pathbuf + pathLen, file, dir - file);
+        pathbuf[pathLen + dir-file] = 0;
+        bool ret = mkdir(pathbuf, 0700);
+        pathLen += dir - file;
+        pathbuf[pathLen++] = '/';
+        file = dir + 1;
+    }
+    return true;
+}
+
+// JMQ: Platform:cdFileExists in unimplemented
+//------------------------------------------------------------------------------
+// bool Platform::cdFileExists(const char *filePath, const char *volumeName,
+//    S32 serialNum)
+// {
+// }
+
+//-----------------------------------------------------------------------------
+bool Platform::dumpPath(const char *path, Vector<Platform::FileInfo> &fileVector, int depth)
+{
+    const char* pattern = "*";
+
+    // if it is not absolute, dump the pref dir first
+    if (path[0] != '/' && path[0] != '\\')
+    {
+        char prefPathName[MaxPath];
+        MungePath(prefPathName, MaxPath, path, GetPrefDir());
+        RecurseDumpPath(prefPathName, path, pattern, fileVector, 0, depth);
+    }
+
+    // munge the requested path and dump it
+    char mungedPath[MaxPath];
+    char cwd[MaxPath];
+    getcwd(cwd, MaxPath);
+    MungePath(mungedPath, MaxPath, path, cwd);
+    return RecurseDumpPath(mungedPath, path, pattern, fileVector, 0, depth);
+}
+
+//-----------------------------------------------------------------------------
+StringTableEntry Platform::getCurrentDirectory()
+{
+    char cwd_buf[2048];
+    getcwd(cwd_buf, 2047);
+    return StringTable->insert(cwd_buf);
+}
+
+//-----------------------------------------------------------------------------
+bool Platform::setCurrentDirectory(StringTableEntry newDir)
+{
+    if (Platform::getWebDeployment())
+        return true;
+
+    TempAlloc< UTF8 > buf( dStrlen( newDir ) + 2 );
+
+    dStrcpy( buf, newDir, buf.size );
+
+    ForwardSlash( buf );
+    return chdir( buf ) == 0;
+}
+
+//-----------------------------------------------------------------------------
+const char *Platform::getUserDataDirectory()
+{
+    return StringTable->insert( GetPrefDir() );
+}
+
+//-----------------------------------------------------------------------------
+StringTableEntry Platform::getUserHomeDirectory()
+{
+    char *home = getenv( "HOME" );
+    return StringTable->insert( home );
+}
+
+StringTableEntry Platform::getExecutablePath()
+{
+    if( !sBinPathName[0] )
+    {
+        const char *cpath;
+        if( (cpath = torque_getexecutablepath()) )
+        {
+            dStrncpy(sBinPathName, cpath, sizeof(sBinPathName));
+            chdir(sBinPathName);
+        }
+        else
+        {
+            getcwd(sBinPathName, sizeof(sBinPathName)-1);
+        }
+    }
+
+    return StringTable->insert(sBinPathName);
+}
+
+//-----------------------------------------------------------------------------
+bool Platform::isFile(const char *pFilePath)
+{
+    if (!pFilePath || !*pFilePath)
+        return false;
+    // Get file info
+    struct stat fStat;
+    if (stat(pFilePath, &fStat) < 0)
+    {
+        // Since file does not exist on disk see if it exists in a zip file loaded
+        return Torque::FS::IsFile(pFilePath);
+    }
+
+    // if the file is a "regular file" then true
+    if ( (fStat.st_mode & S_IFMT) == S_IFREG)
+        return true;
+    // must be some other file (directory, device, etc.)
+    return false;
+}
+
+//-----------------------------------------------------------------------------
+S32 Platform::getFileSize(const char *pFilePath)
+{
+    if (!pFilePath || !*pFilePath)
+        return -1;
+    // Get the file info
+    struct stat fStat;
+    if (stat(pFilePath, &fStat) < 0)
+        return -1;
+    // if the file is a "regular file" then return the size
+    if ( (fStat.st_mode & S_IFMT) == S_IFREG)
+        return fStat.st_size;
+    // Must be something else or we can't read the file.
+    return -1;
+}
+
+//-----------------------------------------------------------------------------
+bool Platform::isDirectory(const char *pDirPath)
+{
+    if (!pDirPath || !*pDirPath)
+        return false;
+
+    // Get file info
+    struct stat fStat;
+    if (stat(pDirPath, &fStat) < 0)
+        return false;
+
+    // if the file is a Directory then true
+    if ( (fStat.st_mode & S_IFMT) == S_IFDIR)
+        return true;
+
+    return false;
+}
+
+//-----------------------------------------------------------------------------
+bool Platform::isSubDirectory(const char *pParent, const char *pDir)
+{
+    if (!pParent || !*pDir)
+        return false;
+
+    // this is somewhat of a brute force method but we need to be 100% sure
+    // that the user cannot enter things like ../dir or /dir etc,...
+    DIR *directory;
+
+    directory = opendir(pParent);
+    if (directory == NULL)
+        return false;
+
+    struct dirent *fEntry;
+    fEntry = readdir(directory);
+    if ( fEntry == NULL )
+    {
+        closedir(directory);
+        return false;
+    }
+
+    do
+    {
+        char dirBuf[MaxPath];
+        struct stat fStat;
+
+        dSprintf(dirBuf, sizeof(dirBuf), "%s/%s", pParent, fEntry->d_name);
+        if (stat(dirBuf, &fStat) < 0)
+            continue;
+        // if it is a directory...
+        if ( (fStat.st_mode & S_IFMT) == S_IFDIR)
+        {
+            // and the names match
+            if (dStrcmp(pDir, fEntry->d_name ) == 0)
+            {
+                // then we have a real sub directory
+                closedir(directory);
+                return true;
+            }
+        }
+    } while( (fEntry = readdir(directory)) != NULL );
+
+    closedir(directory);
+    return false;
+}
+
+//-----------------------------------------------------------------------------
+
+
+// This is untested -- BJG
+
+bool Platform::fileTimeToString(FileTime * time, char * string, U32 strLen)
+{
+    if(!time || !string)
+        return(false);
+
+    dSprintf(string, strLen, "%ld", *time);
+    return(true);
+}
+
+bool Platform::stringToFileTime(const char * string, FileTime * time)
+{
+    if(!time || !string)
+        return(false);
+
+    *time = dAtoi(string);
+
+    return(true);
+}
+
+bool Platform::hasSubDirectory(const char *pPath)
+{
+    if (!pPath)
+        return false;
+
+    struct dirent *d;
+    DIR           *dip;
+    dip = opendir(pPath);
+    if (dip == NULL)
+        return false;
+
+    while ((d = readdir(dip)))
+    {
+        bool isDir = false;
+        if (d->d_type == DT_UNKNOWN)
+        {
+            char child [1024];
+            if ((pPath[dStrlen(pPath) - 1] == '/'))
+                dSprintf(child, 1024, "%s%s", pPath, d->d_name);
+            else
+                dSprintf(child, 1024, "%s/%s", pPath, d->d_name);
+            isDir = Platform::isDirectory (child);
+        }
+        else if (d->d_type & DT_DIR)
+            isDir = true;
+        if( isDir )
+        {
+            // Skip the . and .. directories
+            if (dStrcmp(d->d_name, ".") == 0 ||dStrcmp(d->d_name, "..") == 0)
+                continue;
+            if (Platform::isExcludedDirectory(d->d_name))
+                continue;
+            Platform::clearExcludedDirectories();
+            closedir(dip);
+            return true;
+        }
+    }
+    closedir(dip);
+    Platform::clearExcludedDirectories();
+    return false;
+}
+
+bool Platform::fileDelete(const char * name)
+{
+    return ModifyFile(name, DELETE);
+}
+
+static bool recurseDumpDirectories(const char *basePath, const char *subPath, Vector<StringTableEntry> &directoryVector, S32 currentDepth, S32 recurseDepth, bool noBasePath)
+{
+    char Path[1024];
+    DIR *dip;
+    struct dirent *d;
+
+    dsize_t trLen = basePath ? dStrlen(basePath) : 0;
+    dsize_t subtrLen = subPath ? dStrlen(subPath) : 0;
+    char trail = trLen > 0 ? basePath[trLen - 1] : '\0';
+    char subTrail = subtrLen > 0 ? subPath[subtrLen - 1] : '\0';
+    char subLead = subtrLen > 0 ? subPath[0] : '\0';
+
+    if (trail == '/')
+    {
+        if (subPath && (dStrncmp(subPath, "", 1) != 0))
+        {
+            if (subTrail == '/')
+                dSprintf(Path, 1024, "%s%s", basePath, subPath);
+            else
+                dSprintf(Path, 1024, "%s%s/", basePath, subPath);
+        }
+        else
+            dSprintf(Path, 1024, "%s", basePath);
+    }
+    else
+    {
+        if (subPath && (dStrncmp(subPath, "", 1) != 0))
+        {
+            if (subTrail == '/')
+                dSprintf(Path, 1024, "%s%s", basePath, subPath);
+            else
+                dSprintf(Path, 1024, "%s%s/", basePath, subPath);
+        }
+        else
+            dSprintf(Path, 1024, "%s/", basePath);
+    }
+
+    dip = opendir(Path);
+    if (dip == NULL)
+        return false;
+
+    //////////////////////////////////////////////////////////////////////////
+    // add path to our return list ( provided it is valid )
+    //////////////////////////////////////////////////////////////////////////
+    if (!Platform::isExcludedDirectory(subPath))
+    {
+        if (noBasePath)
+        {
+            // We have a path and it's not an empty string or an excluded directory
+            if ( (subPath && (dStrncmp (subPath, "", 1) != 0)) )
+                directoryVector.push_back(StringTable->insert(subPath));
+        }
+        else
+        {
+            if ( (subPath && (dStrncmp(subPath, "", 1) != 0)) )
+            {
+                char szPath[1024];
+                dMemset(szPath, 0, 1024);
+                if (trail == '/')
+                {
+                    if ((basePath[dStrlen(basePath) - 1]) != '/')
+                        dSprintf(szPath, 1024, "%s%s", basePath, &subPath[1]);
+                    else
+                        dSprintf(szPath, 1024, "%s%s", basePath, subPath);
+                }
+                else
+                {
+                    if ((basePath[dStrlen(basePath) - 1]) != '/')
+                        dSprintf(szPath, 1024, "%s%s", basePath, subPath);
+                    else
+                        dSprintf(szPath, 1024, "%s/%s", basePath, subPath);
+                }
+
+                directoryVector.push_back(StringTable->insert(szPath));
+            }
+            else
+                directoryVector.push_back(StringTable->insert(basePath));
+        }
+    }
+    //////////////////////////////////////////////////////////////////////////
+    // Iterate through and grab valid directories
+    //////////////////////////////////////////////////////////////////////////
+
+    while ((d = readdir(dip)))
+    {
+        bool	isDir;
+        isDir = false;
+        if (d->d_type == DT_UNKNOWN)
+        {
+            char child [1024];
+            if (Path[dStrlen(Path) - 1] == '/')
+                dSprintf(child, 1024, "%s%s", Path, d->d_name);
+            else
+                dSprintf(child, 1024, "%s/%s", Path, d->d_name);
+            isDir = Platform::isDirectory (child);
+        }
+        else if (d->d_type & DT_DIR)
+            isDir = true;
+
+        if ( isDir )
+        {
+            if (dStrcmp(d->d_name, ".") == 0 ||
+                dStrcmp(d->d_name, "..") == 0)
+                continue;
+            if (Platform::isExcludedDirectory(d->d_name))
+                continue;
+            if ( (subPath && (dStrncmp(subPath, "", 1) != 0)) )
+            {
+                char child[1024];
+                if ((subPath[dStrlen(subPath) - 1] == '/'))
+                    dSprintf(child, 1024, "%s%s", subPath, d->d_name);
+                else
+                    dSprintf(child, 1024, "%s/%s", subPath, d->d_name);
+                if (currentDepth < recurseDepth || recurseDepth == -1 )
+                    recurseDumpDirectories(basePath, child, directoryVector,
+                                           currentDepth + 1, recurseDepth,
+                                           noBasePath);
+            }
+            else
+            {
+                char child[1024];
+                if ( (basePath[dStrlen(basePath) - 1]) == '/')
+                    dStrcpy (child, d->d_name, 1024);
+                else
+                    dSprintf(child, 1024, "/%s", d->d_name);
+                if (currentDepth < recurseDepth || recurseDepth == -1)
+                    recurseDumpDirectories(basePath, child, directoryVector,
+                                           currentDepth + 1, recurseDepth,
+                                           noBasePath);
+            }
+        }
+    }
+    closedir(dip);
+    return true;
+}
+
+bool Platform::dumpDirectories(const char *path, Vector<StringTableEntry> &directoryVector, S32 depth, bool noBasePath)
+{
+#ifdef TORQUE_POSIX_PATH_CASE_INSENSITIVE
+    dsize_t pathLength = dStrlen(path);
+    char* caseSensitivePath = new char[pathLength + 1];
+
+    // Load path into temporary buffer
+    dMemcpy(caseSensitivePath, path, pathLength);
+    caseSensitivePath[pathLength] = 0x00;
+    ResolvePathCaseInsensitive(caseSensitivePath, pathLength, false);
+#else
+    const char* caseSensitivePath = path;
+#endif
+
+    bool retVal = recurseDumpDirectories(caseSensitivePath, "", directoryVector, -1, depth, noBasePath);
+    clearExcludedDirectories();
+
+#ifdef TORQUE_POSIX_PATH_CASE_INSENSITIVE
+    delete[] caseSensitivePath;
+#endif
+    return retVal;
+}
+
+StringTableEntry Platform::getExecutableName()
+{
+    return StringTable->insert(sBinName);
+}
+
+extern "C"
+{
+void setExePathName(const char* exePathName)
+{
+    if (exePathName == NULL)
+        sBinPathName[0] = '\0';
+    else
+        dStrncpy(sBinPathName, exePathName, sizeof(sBinPathName));
+
+    // set the base exe name field
+    char *binName = dStrrchr(sBinPathName, '/');
+    if( !binName )
+        binName = sBinPathName;
+    else
+        *binName++ = '\0';
+    sBinName = binName;
+}
+}
+#endif
\ No newline at end of file
diff --git a/Engine/source/platformPOSIX/POSIXMemory.cpp b/Engine/source/platformPOSIX/POSIXMemory.cpp
index ad08a313f..32b92c52c 100644
--- a/Engine/source/platformPOSIX/POSIXMemory.cpp
+++ b/Engine/source/platformPOSIX/POSIXMemory.cpp
@@ -20,7 +20,7 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "platformX86UNIX/platformX86UNIX.h"
+#include "platformPOSIX/platformPOSIX.h"
 #include <stdlib.h>
 #include <mm_malloc.h>
 
diff --git a/Engine/source/platformPOSIX/POSIXState.h b/Engine/source/platformPOSIX/POSIXState.h
index 7d35667bc..dec62b2ee 100644
--- a/Engine/source/platformPOSIX/POSIXState.h
+++ b/Engine/source/platformPOSIX/POSIXState.h
@@ -21,7 +21,7 @@
 //-----------------------------------------------------------------------------
 
 #include "math/mPoint2.h"
-#include "platformX86UNIX/platformX86UNIX.h"
+#include "platformPOSIX/platformPOSIX.h"
 //#include "platformX86UNIX/platformGL.h"
 #include "core/strings/stringFunctions.h"
 
diff --git a/Engine/source/platformPOSIX/POSIXStrings.cpp b/Engine/source/platformPOSIX/POSIXStrings.cpp
index f531409d9..f4b69c16b 100644
--- a/Engine/source/platformPOSIX/POSIXStrings.cpp
+++ b/Engine/source/platformPOSIX/POSIXStrings.cpp
@@ -20,7 +20,7 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "platformX86UNIX/platformX86UNIX.h"
+#include "platformPOSIX/platformPOSIX.h"
 #include "core/strings/stringFunctions.h"
 #include <stdarg.h>
 #include <ctype.h>
diff --git a/Engine/source/platformPOSIX/POSIXUtils.cpp b/Engine/source/platformPOSIX/POSIXUtils.cpp
index b87d92c49..fc5c416ff 100644
--- a/Engine/source/platformPOSIX/POSIXUtils.cpp
+++ b/Engine/source/platformPOSIX/POSIXUtils.cpp
@@ -31,7 +31,7 @@
 #include <sys/wait.h>
 #include <stdlib.h>
 
-#include "platformX86UNIX/platformX86UNIX.h"
+#include "platformPOSIX/platformPOSIX.h"
 #include "platformPOSIX/POSIXUtils.h"
 
 UnixUtils *UUtils = NULL;
diff --git a/Engine/source/platformX86UNIX/platformX86UNIX.h b/Engine/source/platformPOSIX/platformPOSIX.h
similarity index 97%
rename from Engine/source/platformX86UNIX/platformX86UNIX.h
rename to Engine/source/platformPOSIX/platformPOSIX.h
index 19481dd31..0f4d7828b 100644
--- a/Engine/source/platformX86UNIX/platformX86UNIX.h
+++ b/Engine/source/platformPOSIX/platformPOSIX.h
@@ -20,8 +20,7 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#ifndef _PLATFORMX86UNIX_H_
-#define _PLATFORMX86UNIX_H_
+#pragma once
 
 #ifndef _PLATFORM_H_
 #include "platform/platform.h"
@@ -66,4 +65,3 @@ extern "C"
    // x86UNIX doesn't have a way to automatically get the executable file name
    void setExePathName(const char* exePathName);
 }
-#endif
diff --git a/Engine/source/platformX86UNIX/x86UNIXFileio.cpp b/Engine/source/platformX86UNIX/x86UNIXFileio.cpp
deleted file mode 100644
index d702d6417..000000000
--- a/Engine/source/platformX86UNIX/x86UNIXFileio.cpp
+++ /dev/null
@@ -1,1261 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
- /* JMQ:
-
-    Here's the scoop on unix file IO.  The windows platform makes some
-    assumptions about fileio: 1) the file system is case-insensitive, and
-    2) the platform can write to the directory in which
-    the game is running.  Both of these are usually false on linux.  So, to
-    compensate, we "route" created files and directories to the user's home
-    directory (see GetPrefPath()).  When a file is to be accessed, the code
-    looks in the home directory first.  If the file is not found there and the
-    open mode is read only, the code will look in the game installation
-    directory.  Files are never created or modified in the game directory.
-
-    For case-sensitivity, the MungePath code will test whether a given path
-    specified by the engine exists.  If not, it will use the ResolvePathCaseInsensitive function
-    which will try to determine if an actual filesystem path matches the
-    specified path case insensitive.  If one is found, the actual path
-    transparently (we hope) replaces the one requested by the engine.
-
-    The preference directory is global to all torque executables with the same
-    name.  You should make sure you keep it clean if you build from multiple
-    torque development trees.
- */
-
- // evil hack to get around insane X windows #define-happy header files
- #ifdef Status
- #undef Status
- #endif
-
- #include "platformX86UNIX/platformX86UNIX.h"
- #include "core/fileio.h"
- #include "core/util/tVector.h"
- #include "core/stringTable.h"
- #include "console/console.h"
- #include "core/strings/stringFunctions.h"
- #include "util/tempAlloc.h"
- #include "cinterface/c_controlInterface.h"
- #include "core/volume.h"
-
- #if defined(__FreeBSD__)
-    #include <sys/types.h>
- #endif
- #include <utime.h>
-
- /* these are for reading directors, getting stats, etc. */
- #include <dirent.h>
- #include <sys/types.h>
- #include <sys/stat.h>
- #include <unistd.h>
- #include <fcntl.h>
- #include <errno.h>
- #include <stdlib.h>
-
- extern int x86UNIXOpen(const char *path, int oflag);
- extern int x86UNIXClose(int fd);
- extern ssize_t x86UNIXRead(int fd, void *buf, size_t nbytes);
- extern ssize_t x86UNIXWrite(int fd, const void *buf, size_t nbytes);
- extern bool ResolvePathCaseInsensitive(char* pathName, S32 pathNameSize, bool requiredAbsolute);
-
- const int MaxPath = PATH_MAX;
-
- namespace
- {
-   const char sTempDir[] = "/tmp/";
-
-   static char sBinPathName[MaxPath] = "";
-   static char *sBinName = sBinPathName;
-   bool sUseRedirect = true;
- }
-
- StringTableEntry osGetTemporaryDirectory()
- {
-    return StringTable->insert(sTempDir);
- }
-
- // Various handy utility functions:
- //------------------------------------------------------------------------------
- // find all \ in a path and convert them in place to /
- static void ForwardSlash(char *str)
- {
-    while(*str)
-    {
-       if(*str == '\\')
-          *str = '/';
-       str++;
-    }
- }
-
- //------------------------------------------------------------------------------
- // copy a file from src to dest
- static bool CopyFile(const char* src, const char* dest)
- {
-    S32 srcFd = x86UNIXOpen(src, O_RDONLY);
-    S32 destFd = x86UNIXOpen(dest, O_WRONLY | O_CREAT | O_TRUNC);
-    bool error = false;
-
-    if (srcFd != -1 && destFd != -1)
-    {
-       const int BufSize = 8192;
-       char buf[BufSize];
-       S32 bytesRead = 0;
-       while ((bytesRead = x86UNIXRead(srcFd, buf, BufSize)) > 0)
-       {
-          // write data
-          if (x86UNIXWrite(destFd, buf, bytesRead) == -1)
-          {
-             error = true;
-             break;
-          }
-       }
-
-       if (bytesRead == -1)
-          error = true;
-    }
-
-    if (srcFd != -1)
-       x86UNIXClose(srcFd);
-    if (destFd != -1)
-       x86UNIXClose(destFd);
-
-    if (error)
-    {
-       Con::errorf("Error copying file: %s, %s", src, dest);
-       remove(dest);
-    }
-    return error;
- }
-
-bool dPathCopy(const char *fromName, const char *toName, bool nooverwrite)
-{
- 	return CopyFile(fromName,toName);
-}
-
- //-----------------------------------------------------------------------------
- static char sgPrefDir[MaxPath];
- static bool sgPrefDirInitialized = false;
-
- // get the "pref dir", which is where game output files are stored.  the pref
- // dir is ~/PREF_DIR_ROOT/PREF_DIR_GAME_NAME
- static const char* GetPrefDir()
- {
-    if (sgPrefDirInitialized)
-       return sgPrefDir;
-
-    if (sUseRedirect)
-    {
-       const char *home = getenv("HOME");
-       AssertFatal(home, "HOME environment variable must be set");
-
-       dSprintf(sgPrefDir, MaxPath, "%s/%s/%s",
-          home, PREF_DIR_ROOT, PREF_DIR_GAME_NAME);
-    }
-    else
-    {
-       getcwd(sgPrefDir, MaxPath);
-    }
-
-    sgPrefDirInitialized = true;
-    return sgPrefDir;
- }
-
- //-----------------------------------------------------------------------------
- // Returns true if the pathname exists, false otherwise.  If isFile is true,
- // the pathname is assumed to be a file path, and only the directory part
- // will be examined (everything before last /)
- bool DirExists(char* pathname, bool isFile)
- {
-    static char testpath[20000];
-    dStrncpy(testpath, pathname, sizeof(testpath));
-    if (isFile)
-    {
-       // find the last / and make it into null
-       char* lastSlash = dStrrchr(testpath, '/');
-       if (lastSlash != NULL)
-          *lastSlash = 0;
-    }
-    return Platform::isDirectory(testpath);
- }
-
- //-----------------------------------------------------------------------------
- // Munge the specified path.
- static void MungePath(char* dest, S32 destSize,
-    const char* src, const char* absolutePrefix)
- {
-    char tempBuf[MaxPath];
-    dStrncpy(dest, src, MaxPath);
-
-    // translate all \ to /
-    ForwardSlash(dest);
-
-    // if it is relative, make it absolute with the absolutePrefix
-    if (dest[0] != '/')
-    {
-       AssertFatal(absolutePrefix, "Absolute Prefix must not be NULL");
-
-       dSprintf(tempBuf, MaxPath, "%s/%s",
-          absolutePrefix, dest);
-
-       // copy the result back into dest
-       dStrncpy(dest, tempBuf, destSize);
-    }
-
-    // if the path exists, we're done
-    struct stat filestat;
-    if (stat(dest, &filestat) != -1)
-       return;
-
-    // otherwise munge the case of the path
-     ResolvePathCaseInsensitive(dest, destSize, true);
- }
-
- //-----------------------------------------------------------------------------
- enum
- {
-    TOUCH,
-    DELETE
- };
-
- //-----------------------------------------------------------------------------
- // perform a modification on the specified file.  allowed modifications are
- // specified in the enum above.
- bool ModifyFile(const char * name, S32 modType)
- {
-    if(!name || (dStrlen(name) >= MaxPath) || dStrstr(name, "../") != NULL)
-       return(false);
-
-    // if its absolute skip it
-    if (name[0]=='/' || name[0]=='\\')
-       return(false);
-
-    // only modify files in home directory
-    char prefPathName[MaxPath];
-    MungePath(prefPathName, MaxPath, name, GetPrefDir());
-
-    if (modType == TOUCH)
-       return(utime(prefPathName, 0) != -1);
-    else if (modType == DELETE)
-       return (remove(prefPathName) == 0);
-    else
-       AssertFatal(false, "Unknown File Mod type");
-    return false;
- }
-
- //-----------------------------------------------------------------------------
- static bool RecurseDumpPath(const char *path, const char* relativePath, const char *pattern, Vector<Platform::FileInfo> &fileVector, S32 currentDepth = 0, S32 recurseDepth = -1)
- {
-    char search[1024];
-
-    dSprintf(search, sizeof(search), "%s", path, pattern);
-
-    DIR *directory = opendir(search);
-
-    if (directory == NULL)
-       return false;
-
-    struct dirent *fEntry;
-    fEntry = readdir(directory);		// read the first "file" in the directory
-
-    if (fEntry == NULL)
-    {
-       closedir(directory);
-       return false;
-    }
-
-    do
-    {
-       char filename[BUFSIZ+1];
-       struct stat fStat;
-
-       dSprintf(filename, sizeof(filename), "%s/%s", search, fEntry->d_name); // "construct" the file name
-       stat(filename, &fStat); // get the file stats
-
-       if ( (fStat.st_mode & S_IFMT) == S_IFDIR )
-       {
-          // Directory
-          // skip . and .. directories
-          if (dStrcmp(fEntry->d_name, ".") == 0 || dStrcmp(fEntry->d_name, "..") == 0)
-             continue;
-
- 		// skip excluded directories
- 		if( Platform::isExcludedDirectory(fEntry->d_name))
- 			continue;
-
-
-          char child[MaxPath];
-          dSprintf(child, sizeof(child), "%s/%s", path, fEntry->d_name);
-          char* childRelative = NULL;
-          char childRelativeBuf[MaxPath];
-          if (relativePath)
-          {
-             dSprintf(childRelativeBuf, sizeof(childRelativeBuf), "%s/%s",
-                relativePath, fEntry->d_name);
-             childRelative = childRelativeBuf;
-          }
-          if (currentDepth < recurseDepth || recurseDepth == -1 )
-            RecurseDumpPath(child, childRelative, pattern, fileVector, currentDepth+1, recurseDepth);
-       }
-       else
-       {
-          // File
-
-          // add it to the list
-          fileVector.increment();
-          Platform::FileInfo& rInfo = fileVector.last();
-
-          if (relativePath)
-             rInfo.pFullPath = StringTable->insert(relativePath);
-          else
-             rInfo.pFullPath = StringTable->insert(path);
-          rInfo.pFileName = StringTable->insert(fEntry->d_name);
-          rInfo.fileSize  = fStat.st_size;
-          //dPrintf("Adding file: %s/%s\n", rInfo.pFullPath, rInfo.pFileName);
-       }
-
-    } while( (fEntry = readdir(directory)) != NULL );
-
-    closedir(directory);
-    return true;
- }
-
- //-----------------------------------------------------------------------------
- bool dFileDelete(const char * name)
- {
-    return ModifyFile(name, DELETE);
- }
-
- //-----------------------------------------------------------------------------
- bool dFileTouch(const char * name)
- {
-    return ModifyFile(name, TOUCH);
- }
-
- bool dFileRename(const char *oldName, const char *newName)
- {
-    AssertFatal( oldName != NULL && newName != NULL, "dFileRename - NULL file name" );
-
-    // only modify files in home directory
-    TempAlloc<char> oldPrefPathName(MaxPath);
-    TempAlloc<char> newPrefPathName(MaxPath);
-    MungePath(oldPrefPathName, MaxPath, oldName, GetPrefDir());
-    MungePath(newPrefPathName, MaxPath, newName, GetPrefDir());
-
-    return rename(oldPrefPathName, newPrefPathName) == 0;
- }
-
- //-----------------------------------------------------------------------------
- // Constructors & Destructor
- //-----------------------------------------------------------------------------
-
- //-----------------------------------------------------------------------------
- // After construction, the currentStatus will be Closed and the capabilities
- // will be 0.
- //-----------------------------------------------------------------------------
- File::File()
- : currentStatus(Closed), capability(0)
- {
- //    AssertFatal(sizeof(int) == sizeof(void *), "File::File: cannot cast void* to int");
-
-     handle = (void *)NULL;
- }
-
- //-----------------------------------------------------------------------------
- // insert a copy constructor here... (currently disabled)
- //-----------------------------------------------------------------------------
-
- //-----------------------------------------------------------------------------
- // Destructor
- //-----------------------------------------------------------------------------
- File::~File()
- {
-     close();
-     handle = (void *)NULL;
- }
-
- //-----------------------------------------------------------------------------
- // Open a file in the mode specified by openMode (Read, Write, or ReadWrite).
- // Truncate the file if the mode is either Write or ReadWrite and truncate is
- // true.
- //
- // Sets capability appropriate to the openMode.
- // Returns the currentStatus of the file.
- //-----------------------------------------------------------------------------
- File::FileStatus File::open(const char *filename, const AccessMode openMode)
- {
-    AssertFatal(NULL != filename, "File::open: NULL filename");
-    AssertWarn(NULL == handle, "File::open: handle already valid");
-
-    // Close the file if it was already open...
-    if (Closed != currentStatus)
-       close();
-
-    char prefPathName[MaxPath];
-    char gamePathName[MaxPath];
-    char cwd[MaxPath];
-    getcwd(cwd, MaxPath);
-    MungePath(prefPathName, MaxPath, filename, GetPrefDir());
-    MungePath(gamePathName, MaxPath, filename, cwd);
-
-    int oflag;
-    struct stat filestat;
-    handle = (void *)dRealMalloc(sizeof(int));
-
-    switch (openMode)
-    {
-       case Read:
-          oflag = O_RDONLY;
-          break;
-       case Write:
-          oflag = O_WRONLY | O_CREAT | O_TRUNC;
-          break;
-       case ReadWrite:
-          oflag = O_RDWR | O_CREAT;
-          // if the file does not exist copy it before reading/writing
-          if (stat(prefPathName, &filestat) == -1)
-             bool ret = CopyFile(gamePathName, prefPathName);
-          break;
-       case WriteAppend:
-          oflag = O_WRONLY | O_CREAT | O_APPEND;
-          // if the file does not exist copy it before appending
-          if (stat(prefPathName, &filestat) == -1)
-              bool ret = CopyFile(gamePathName, prefPathName);
-          break;
-       default:
-          AssertFatal(false, "File::open: bad access mode");    // impossible
-    }
-
-    // if we are writing, make sure output path exists
-    if (openMode == Write || openMode == ReadWrite || openMode == WriteAppend)
-        Platform::createPath(prefPathName);
-
-    int fd = -1;
-    fd = x86UNIXOpen(prefPathName, oflag);
-    if (fd == -1 && openMode == Read)
-       // for read only files we can use the gamePathName
-       fd = x86UNIXOpen(gamePathName, oflag);
-
-    dMemcpy(handle, &fd, sizeof(int));
-
- #ifdef DEBUG
- //   fprintf(stdout,"fd = %d, handle = %d\n", fd, *((int *)handle));
- #endif
-
-    if (*((int *)handle) == -1)
-    {
-       // handle not created successfully
-       Con::errorf("Can't open file: %s", filename);
-       return setStatus();
-    }
-    else
-    {
-       // successfully created file, so set the file capabilities...
-       switch (openMode)
-       {
-          case Read:
-             capability = U32(FileRead);
-             break;
-          case Write:
-          case WriteAppend:
-             capability = U32(FileWrite);
-             break;
-          case ReadWrite:
-             capability = U32(FileRead)  |
-                U32(FileWrite);
-             break;
-          default:
-             AssertFatal(false, "File::open: bad access mode");
-       }
-       return currentStatus = Ok;                                // success!
-    }
- }
-
- //-----------------------------------------------------------------------------
- // Get the current position of the file pointer.
- //-----------------------------------------------------------------------------
- U32 File::getPosition() const
- {
-     AssertFatal(Closed != currentStatus, "File::getPosition: file closed");
-     AssertFatal(NULL != handle, "File::getPosition: invalid file handle");
-
- #ifdef DEBUG
- //   fprintf(stdout, "handle = %d\n",*((int *)handle));fflush(stdout);
- #endif
-     return (U32) lseek(*((int *)handle), 0, SEEK_CUR);
- }
-
- //-----------------------------------------------------------------------------
- // Set the position of the file pointer.
- // Absolute and relative positioning is supported via the absolutePos
- // parameter.
- //
- // If positioning absolutely, position MUST be positive - an IOError results if
- // position is negative.
- // Position can be negative if positioning relatively, however positioning
- // before the start of the file is an IOError.
- //
- // Returns the currentStatus of the file.
- //-----------------------------------------------------------------------------
- File::FileStatus File::setPosition(S32 position, bool absolutePos)
- {
-     AssertFatal(Closed != currentStatus, "File::setPosition: file closed");
-     AssertFatal(NULL != handle, "File::setPosition: invalid file handle");
-
-     if (Ok != currentStatus && EOS != currentStatus)
-         return currentStatus;
-
-     U32 finalPos = 0;
-
-     if (absolutePos)
-     {
-         AssertFatal(0 <= position, "File::setPosition: negative absolute position");
-
-         // position beyond EOS is OK
-         finalPos = lseek(*((int *)handle), position, SEEK_SET);
-     }
-     else
-     {
-         AssertFatal((getPosition() >= (U32)abs(position) && 0 > position) || 0 <= position, "File::setPosition: negative relative position");
-
-         // position beyond EOS is OK
-         finalPos = lseek(*((int *)handle), position, SEEK_CUR);
-     }
-
-     if (0xffffffff == finalPos)
-         return setStatus();                                        // unsuccessful
-     else if (finalPos >= getSize())
-         return currentStatus = EOS;                                // success, at end of file
-     else
-         return currentStatus = Ok;                                // success!
- }
-
- //-----------------------------------------------------------------------------
- // Get the size of the file in bytes.
- // It is an error to query the file size for a Closed file, or for one with an
- // error status.
- //-----------------------------------------------------------------------------
- U32 File::getSize() const
- {
-     AssertWarn(Closed != currentStatus, "File::getSize: file closed");
-     AssertFatal(NULL != handle, "File::getSize: invalid file handle");
-
-     if (Ok == currentStatus || EOS == currentStatus)
-     {
- 	long	currentOffset = getPosition();                  // keep track of our current position
- 	long	fileSize;
- 	lseek(*((int *)handle), 0, SEEK_END);                     // seek to the end of the file
- 	fileSize = getPosition();                               // get the file size
- 	lseek(*((int *)handle), currentOffset, SEEK_SET);         // seek back to our old offset
-         return fileSize;                                        // success!
-     }
-     else
-         return 0;                                               // unsuccessful
- }
-
- //-----------------------------------------------------------------------------
- // Flush the file.
- // It is an error to flush a read-only file.
- // Returns the currentStatus of the file.
- //-----------------------------------------------------------------------------
- File::FileStatus File::flush()
- {
-     AssertFatal(Closed != currentStatus, "File::flush: file closed");
-     AssertFatal(NULL != handle, "File::flush: invalid file handle");
-     AssertFatal(true == hasCapability(FileWrite), "File::flush: cannot flush a read-only file");
-
-     if (fsync(*((int *)handle)) == 0)
-         return currentStatus = Ok;                                // success!
-     else
-         return setStatus();                                       // unsuccessful
- }
-
- //-----------------------------------------------------------------------------
- // Close the File.
- //
- // Returns the currentStatus
- //-----------------------------------------------------------------------------
- File::FileStatus File::close()
- {
-    // if the handle is non-NULL, close it if necessary and free it
-    if (NULL != handle)
-    {
-       // make a local copy of the handle value and
-       // free the handle
-       int handleVal = *((int *)handle);
-       dRealFree(handle);
-       handle = (void *)NULL;
-
-       // close the handle if it is valid
-       if (handleVal != -1 && x86UNIXClose(handleVal) != 0)
-          return setStatus();                                    // unsuccessful
-    }
-    // Set the status to closed
-    return currentStatus = Closed;
- }
-
- //-----------------------------------------------------------------------------
- // Self-explanatory.
- //-----------------------------------------------------------------------------
- File::FileStatus File::getStatus() const
- {
-     return currentStatus;
- }
-
- //-----------------------------------------------------------------------------
- // Sets and returns the currentStatus when an error has been encountered.
- //-----------------------------------------------------------------------------
- File::FileStatus File::setStatus()
- {
-    Con::printf("File IO error: %s", strerror(errno));
-    return currentStatus = IOError;
- }
-
- //-----------------------------------------------------------------------------
- // Sets and returns the currentStatus to status.
- //-----------------------------------------------------------------------------
- File::FileStatus File::setStatus(File::FileStatus status)
- {
-     return currentStatus = status;
- }
-
- //-----------------------------------------------------------------------------
- // Read from a file.
- // The number of bytes to read is passed in size, the data is returned in src.
- // The number of bytes read is available in bytesRead if a non-Null pointer is
- // provided.
- //-----------------------------------------------------------------------------
- File::FileStatus File::read(U32 size, char *dst, U32 *bytesRead)
- {
- #ifdef DEBUG
- //   fprintf(stdout,"reading %d bytes\n",size);fflush(stdout);
- #endif
-     AssertFatal(Closed != currentStatus, "File::read: file closed");
-     AssertFatal(NULL != handle, "File::read: invalid file handle");
-     AssertFatal(NULL != dst, "File::read: NULL destination pointer");
-     AssertFatal(true == hasCapability(FileRead), "File::read: file lacks capability");
-     AssertWarn(0 != size, "File::read: size of zero");
-
- /* show stats for this file */
- #ifdef DEBUG
- //struct stat st;
- //fstat(*((int *)handle), &st);
- //fprintf(stdout,"file size = %d\n", st.st_size);
- #endif
- /****************************/
-
-     if (Ok != currentStatus || 0 == size)
-         return currentStatus;
-     else
-     {
-         long lastBytes;
-         long *bytes = (NULL == bytesRead) ? &lastBytes : (long *)bytesRead;
-         if ( (*((U32 *)bytes) = x86UNIXRead(*((int *)handle), dst, size)) == -1)
-         {
- #ifdef DEBUG
- //   fprintf(stdout,"unsuccessful: %d\n", *((U32 *)bytes));fflush(stdout);
- #endif
-            return setStatus();                                    // unsuccessful
-         } else {
- //            dst[*((U32 *)bytes)] = '\0';
-             if (*((U32 *)bytes) != size || *((U32 *)bytes) == 0) {
- #ifdef DEBUG
- //  fprintf(stdout,"end of stream: %d\n", *((U32 *)bytes));fflush(stdout);
- #endif
-                 return currentStatus = EOS;                        // end of stream
-             }
-         }
-     }
- //    dst[*bytesRead] = '\0';
- #ifdef DEBUG
- //fprintf(stdout, "We read:\n");
- //fprintf(stdout, "====================================================\n");
- //fprintf(stdout, "%s\n",dst);
- //fprintf(stdout, "====================================================\n");
- //fprintf(stdout,"read ok: %d\n", *bytesRead);fflush(stdout);
- #endif
-     return currentStatus = Ok;                                    // successfully read size bytes
- }
-
- //-----------------------------------------------------------------------------
- // Write to a file.
- // The number of bytes to write is passed in size, the data is passed in src.
- // The number of bytes written is available in bytesWritten if a non-Null
- // pointer is provided.
- //-----------------------------------------------------------------------------
- File::FileStatus File::write(U32 size, const char *src, U32 *bytesWritten)
- {
-    // JMQ: despite the U32 parameters, the maximum filesize supported by this
-    // function is probably the max value of S32, due to the unix syscall
-    // api.
-    AssertFatal(Closed != currentStatus, "File::write: file closed");
-    AssertFatal(NULL != handle, "File::write: invalid file handle");
-    AssertFatal(NULL != src, "File::write: NULL source pointer");
-    AssertFatal(true == hasCapability(FileWrite), "File::write: file lacks capability");
-    AssertWarn(0 != size, "File::write: size of zero");
-
-    if ((Ok != currentStatus && EOS != currentStatus) || 0 == size)
-       return currentStatus;
-    else
-    {
-       S32 numWritten = x86UNIXWrite(*((int *)handle), src, size);
-       if (numWritten < 0)
-          return setStatus();
-
-       if (bytesWritten)
-          *bytesWritten = static_cast<U32>(numWritten);
-       return currentStatus = Ok;
-    }
- }
-
- //-----------------------------------------------------------------------------
- // Self-explanatory.  JMQ: No explanation needed.  Move along.  These aren't
- // the droids you're looking for.
- //-----------------------------------------------------------------------------
- bool File::hasCapability(Capability cap) const
- {
-     return (0 != (U32(cap) & capability));
- }
-
- //-----------------------------------------------------------------------------
- S32 Platform::compareFileTimes(const FileTime &a, const FileTime &b)
- {
-    if(a > b)
-       return 1;
-    if(a < b)
-       return -1;
-    return 0;
- }
-
- //-----------------------------------------------------------------------------
- static bool GetFileTimes(const char *filePath, FileTime *createTime, FileTime *modifyTime)
- {
-    struct stat fStat;
-
-    if (stat(filePath, &fStat) == -1)
-       return false;
-
-    if(createTime)
-    {
-       // no where does SysV/BSD UNIX keep a record of a file's
-       // creation time.  instead of creation time I'll just use
-       // changed time for now.
-       *createTime = fStat.st_ctime;
-    }
-    if(modifyTime)
-    {
-       *modifyTime = fStat.st_mtime;
-    }
-
-    return true;
- }
-
- //-----------------------------------------------------------------------------
- bool Platform::getFileTimes(const char *filePath, FileTime *createTime, FileTime *modifyTime)
- {
-    char pathName[MaxPath];
-
-    // if it starts with cwd, we need to strip that off so that we can look for
-    // the file in the pref dir
-    char cwd[MaxPath];
-    getcwd(cwd, MaxPath);
-    if (dStrstr(filePath, cwd) == filePath)
-       filePath = filePath + dStrlen(cwd) + 1;
-
-    // if its relative, first look in the pref dir
-    if (filePath[0] != '/' && filePath[0] != '\\')
-    {
-       MungePath(pathName, MaxPath, filePath, GetPrefDir());
-       if (GetFileTimes(pathName, createTime, modifyTime))
-          return true;
-    }
-
-    // here if the path is absolute or not in the pref dir
-    MungePath(pathName, MaxPath, filePath, cwd);
-    return GetFileTimes(pathName, createTime, modifyTime);
- }
-
- //-----------------------------------------------------------------------------
- bool Platform::createPath(const char *file)
- {
-    char pathbuf[MaxPath];
-    const char *dir;
-    pathbuf[0] = 0;
-    U32 pathLen = 0;
-
-    // all paths should be created in home directory
-    char prefPathName[MaxPath];
-    MungePath(prefPathName, MaxPath, file, GetPrefDir());
-    file = prefPathName;
-
-    // does the directory exist already?
-    if (DirExists(prefPathName, true)) // true means that the path is a filepath
-       return true;
-
-    while((dir = dStrchr(file, '/')) != NULL)
-    {
-       dStrncpy(pathbuf + pathLen, file, dir - file);
-       pathbuf[pathLen + dir-file] = 0;
-       bool ret = mkdir(pathbuf, 0700);
-       pathLen += dir - file;
-       pathbuf[pathLen++] = '/';
-       file = dir + 1;
-    }
-    return true;
- }
-
- // JMQ: Platform:cdFileExists in unimplemented
- //------------------------------------------------------------------------------
- // bool Platform::cdFileExists(const char *filePath, const char *volumeName,
- //    S32 serialNum)
- // {
- // }
-
- //-----------------------------------------------------------------------------
- bool Platform::dumpPath(const char *path, Vector<Platform::FileInfo> &fileVector, int depth)
- {
-    const char* pattern = "*";
-
-    // if it is not absolute, dump the pref dir first
-    if (path[0] != '/' && path[0] != '\\')
-    {
-       char prefPathName[MaxPath];
-       MungePath(prefPathName, MaxPath, path, GetPrefDir());
-       RecurseDumpPath(prefPathName, path, pattern, fileVector, 0, depth);
-    }
-
-    // munge the requested path and dump it
-    char mungedPath[MaxPath];
-    char cwd[MaxPath];
-    getcwd(cwd, MaxPath);
-    MungePath(mungedPath, MaxPath, path, cwd);
-    return RecurseDumpPath(mungedPath, path, pattern, fileVector, 0, depth);
- }
-
- //-----------------------------------------------------------------------------
- StringTableEntry Platform::getCurrentDirectory()
- {
-    char cwd_buf[2048];
-    getcwd(cwd_buf, 2047);
-    return StringTable->insert(cwd_buf);
- }
-
- //-----------------------------------------------------------------------------
- bool Platform::setCurrentDirectory(StringTableEntry newDir)
- {
-    if (Platform::getWebDeployment())
-       return true;
-
-    TempAlloc< UTF8 > buf( dStrlen( newDir ) + 2 );
-
-    dStrcpy( buf, newDir, buf.size );
-
-    ForwardSlash( buf );
-    return chdir( buf ) == 0;
- }
-
- //-----------------------------------------------------------------------------
- const char *Platform::getUserDataDirectory()
- {
-    return StringTable->insert( GetPrefDir() );
- }
-
- //-----------------------------------------------------------------------------
- StringTableEntry Platform::getUserHomeDirectory()
- {
-    char *home = getenv( "HOME" );
-    return StringTable->insert( home );
- }
-
- StringTableEntry Platform::getExecutablePath()
-{
-   if( !sBinPathName[0] )
-   {
-      const char *cpath;
-      if( (cpath = torque_getexecutablepath()) )
-      {
-         dStrncpy(sBinPathName, cpath, sizeof(sBinPathName));
-         chdir(sBinPathName);
-      }
-      else
-      {
-         getcwd(sBinPathName, sizeof(sBinPathName)-1);
-      }
-   }
-
-   return StringTable->insert(sBinPathName);
-}
-
- //-----------------------------------------------------------------------------
- bool Platform::isFile(const char *pFilePath)
- {
-    if (!pFilePath || !*pFilePath)
-       return false;
-    // Get file info
-    struct stat fStat;
-    if (stat(pFilePath, &fStat) < 0)
-    {
-       // Since file does not exist on disk see if it exists in a zip file loaded
-       return Torque::FS::IsFile(pFilePath);
-    }
-
-    // if the file is a "regular file" then true
-    if ( (fStat.st_mode & S_IFMT) == S_IFREG)
-       return true;
-    // must be some other file (directory, device, etc.)
-    return false;
- }
-
- //-----------------------------------------------------------------------------
- S32 Platform::getFileSize(const char *pFilePath)
- {
-   if (!pFilePath || !*pFilePath)
-     return -1;
-   // Get the file info
-   struct stat fStat;
-   if (stat(pFilePath, &fStat) < 0)
-     return -1;
-   // if the file is a "regular file" then return the size
-   if ( (fStat.st_mode & S_IFMT) == S_IFREG)
-     return fStat.st_size;
-   // Must be something else or we can't read the file.
-   return -1;
- }
-
- //-----------------------------------------------------------------------------
- bool Platform::isDirectory(const char *pDirPath)
- {
-    if (!pDirPath || !*pDirPath)
-       return false;
-
-    // Get file info
-    struct stat fStat;
-    if (stat(pDirPath, &fStat) < 0)
-       return false;
-
-    // if the file is a Directory then true
-    if ( (fStat.st_mode & S_IFMT) == S_IFDIR)
-       return true;
-
-    return false;
- }
-
- //-----------------------------------------------------------------------------
- bool Platform::isSubDirectory(const char *pParent, const char *pDir)
- {
-    if (!pParent || !*pDir)
-       return false;
-
-    // this is somewhat of a brute force method but we need to be 100% sure
-    // that the user cannot enter things like ../dir or /dir etc,...
-    DIR *directory;
-
-    directory = opendir(pParent);
-    if (directory == NULL)
-       return false;
-
-    struct dirent *fEntry;
-    fEntry = readdir(directory);
-    if ( fEntry == NULL )
-    {
-       closedir(directory);
-       return false;
-    }
-
-    do
-    {
-       char dirBuf[MaxPath];
-       struct stat fStat;
-
-       dSprintf(dirBuf, sizeof(dirBuf), "%s/%s", pParent, fEntry->d_name);
-       if (stat(dirBuf, &fStat) < 0)
-          continue;
-       // if it is a directory...
-       if ( (fStat.st_mode & S_IFMT) == S_IFDIR)
-       {
-          // and the names match
-          if (dStrcmp(pDir, fEntry->d_name ) == 0)
-          {
-             // then we have a real sub directory
-             closedir(directory);
-             return true;
-          }
-       }
-    } while( (fEntry = readdir(directory)) != NULL );
-
-    closedir(directory);
-    return false;
- }
-
- //-----------------------------------------------------------------------------
-
-
- // This is untested -- BJG
-
- bool Platform::fileTimeToString(FileTime * time, char * string, U32 strLen)
- {
-    if(!time || !string)
-       return(false);
-
-    dSprintf(string, strLen, "%ld", *time);
-    return(true);
- }
-
- bool Platform::stringToFileTime(const char * string, FileTime * time)
- {
-    if(!time || !string)
-       return(false);
-
-    *time = dAtoi(string);
-
-    return(true);
- }
-
- bool Platform::hasSubDirectory(const char *pPath)
- {
-   if (!pPath)
-     return false;
-
-   struct dirent *d;
-   DIR           *dip;
-   dip = opendir(pPath);
-   if (dip == NULL)
-     return false;
-
-   while ((d = readdir(dip)))
-     {
-	bool isDir = false;
-	if (d->d_type == DT_UNKNOWN)
-	{
-		char child [1024];
-		if ((pPath[dStrlen(pPath) - 1] == '/'))
-			dSprintf(child, 1024, "%s%s", pPath, d->d_name);
-		else
-			dSprintf(child, 1024, "%s/%s", pPath, d->d_name);
-		isDir = Platform::isDirectory (child);
-	}
-	else if (d->d_type & DT_DIR)
-		isDir = true;
-	  	if( isDir )
-	  	{
- 	  	// Skip the . and .. directories
- 	  	if (dStrcmp(d->d_name, ".") == 0 ||dStrcmp(d->d_name, "..") == 0)
- 		    continue;
- 		if (Platform::isExcludedDirectory(d->d_name))
- 		    continue;
- 		  Platform::clearExcludedDirectories();
- 		  closedir(dip);
- 		  return true;
- 	}
-     }
-   closedir(dip);
-   Platform::clearExcludedDirectories();
-   return false;
- }
-
- bool Platform::fileDelete(const char * name)
- {
-   return ModifyFile(name, DELETE);
- }
-
- static bool recurseDumpDirectories(const char *basePath, const char *subPath, Vector<StringTableEntry> &directoryVector, S32 currentDepth, S32 recurseDepth, bool noBasePath)
- {
-   char Path[1024];
-   DIR *dip;
-   struct dirent *d;
-
-   dsize_t trLen = basePath ? dStrlen(basePath) : 0;
-   dsize_t subtrLen = subPath ? dStrlen(subPath) : 0;
-   char trail = trLen > 0 ? basePath[trLen - 1] : '\0';
-   char subTrail = subtrLen > 0 ? subPath[subtrLen - 1] : '\0';
-   char subLead = subtrLen > 0 ? subPath[0] : '\0';
-
-   if (trail == '/')
-   {
-      if (subPath && (dStrncmp(subPath, "", 1) != 0))
-      {
-         if (subTrail == '/')
-            dSprintf(Path, 1024, "%s%s", basePath, subPath);
-         else
-            dSprintf(Path, 1024, "%s%s/", basePath, subPath);
-      }
-      else
-         dSprintf(Path, 1024, "%s", basePath);
-   }
-   else
-   {
-      if (subPath && (dStrncmp(subPath, "", 1) != 0))
-      {
-         if (subTrail == '/')
-            dSprintf(Path, 1024, "%s%s", basePath, subPath);
-         else
-            dSprintf(Path, 1024, "%s%s/", basePath, subPath);
-      }
-      else
-         dSprintf(Path, 1024, "%s/", basePath);
-   }
-
-   dip = opendir(Path);
-   if (dip == NULL)
-     return false;
-
-   //////////////////////////////////////////////////////////////////////////
-   // add path to our return list ( provided it is valid )
-   //////////////////////////////////////////////////////////////////////////
-   if (!Platform::isExcludedDirectory(subPath))
-   {
-      if (noBasePath)
-      {
-         // We have a path and it's not an empty string or an excluded directory
-         if ( (subPath && (dStrncmp (subPath, "", 1) != 0)) )
-            directoryVector.push_back(StringTable->insert(subPath));
-      }
-      else
-      {
-         if ( (subPath && (dStrncmp(subPath, "", 1) != 0)) )
-         {
-            char szPath[1024];
-            dMemset(szPath, 0, 1024);
-            if (trail == '/')
-            {
-               if ((basePath[dStrlen(basePath) - 1]) != '/')
-                  dSprintf(szPath, 1024, "%s%s", basePath, &subPath[1]);
-               else
-                  dSprintf(szPath, 1024, "%s%s", basePath, subPath);
-            }
-            else
-            {
-               if ((basePath[dStrlen(basePath) - 1]) != '/')
-                  dSprintf(szPath, 1024, "%s%s", basePath, subPath);
-               else
-                  dSprintf(szPath, 1024, "%s/%s", basePath, subPath);
-            }
-
-            directoryVector.push_back(StringTable->insert(szPath));
-         }
-         else
-            directoryVector.push_back(StringTable->insert(basePath));
-      }
-   }
-   //////////////////////////////////////////////////////////////////////////
-   // Iterate through and grab valid directories
-   //////////////////////////////////////////////////////////////////////////
-
-	while ((d = readdir(dip)))
-	{
-		bool	isDir;
-		isDir = false;
-		if (d->d_type == DT_UNKNOWN)
-		{
-			char child [1024];
-			if (Path[dStrlen(Path) - 1] == '/')
-				dSprintf(child, 1024, "%s%s", Path, d->d_name);
-			else
-				dSprintf(child, 1024, "%s/%s", Path, d->d_name);
-			isDir = Platform::isDirectory (child);
-		}
-		else if (d->d_type & DT_DIR)
-		isDir = true;
-
-       if ( isDir )
- 	{
- 	  if (dStrcmp(d->d_name, ".") == 0 ||
- 	      dStrcmp(d->d_name, "..") == 0)
- 	    continue;
- 	  if (Platform::isExcludedDirectory(d->d_name))
- 	    continue;
- 	  if ( (subPath && (dStrncmp(subPath, "", 1) != 0)) )
- 	    {
- 	      char child[1024];
- 	      if ((subPath[dStrlen(subPath) - 1] == '/'))
- 		dSprintf(child, 1024, "%s%s", subPath, d->d_name);
- 	      else
- 		dSprintf(child, 1024, "%s/%s", subPath, d->d_name);
- 	      if (currentDepth < recurseDepth || recurseDepth == -1 )
- 		recurseDumpDirectories(basePath, child, directoryVector,
- 				       currentDepth + 1, recurseDepth,
- 				       noBasePath);
- 	    }
- 	  else
- 	    {
- 	      char child[1024];
- 	      if ( (basePath[dStrlen(basePath) - 1]) == '/')
- 		dStrcpy (child, d->d_name, 1024);
- 	      else
- 		dSprintf(child, 1024, "/%s", d->d_name);
- 	      if (currentDepth < recurseDepth || recurseDepth == -1)
- 		recurseDumpDirectories(basePath, child, directoryVector,
- 				       currentDepth + 1, recurseDepth,
- 				       noBasePath);
- 	    }
- 	}
-     }
-   closedir(dip);
-   return true;
- }
-
- bool Platform::dumpDirectories(const char *path, Vector<StringTableEntry> &directoryVector, S32 depth, bool noBasePath)
- {
-#ifdef TORQUE_POSIX_PATH_CASE_INSENSITIVE
-   dsize_t pathLength = dStrlen(path);
-   char* caseSensitivePath = new char[pathLength + 1];
-
-   // Load path into temporary buffer
-   dMemcpy(caseSensitivePath, path, pathLength);
-   caseSensitivePath[pathLength] = 0x00;
-   ResolvePathCaseInsensitive(caseSensitivePath, pathLength, false);
-#else
-   const char* caseSensitivePath = path;
-#endif
-
-   bool retVal = recurseDumpDirectories(caseSensitivePath, "", directoryVector, -1, depth, noBasePath);
-   clearExcludedDirectories();
-
-#ifdef TORQUE_POSIX_PATH_CASE_INSENSITIVE
-   delete[] caseSensitivePath;
-#endif
-   return retVal;
- }
-
-StringTableEntry Platform::getExecutableName()
-{
-   return StringTable->insert(sBinName);
-}
-
-extern "C"
-{
-   void setExePathName(const char* exePathName)
-   {
-      if (exePathName == NULL)
-         sBinPathName[0] = '\0';
-      else
-         dStrncpy(sBinPathName, exePathName, sizeof(sBinPathName));
-
-      // set the base exe name field
-      char *binName = dStrrchr(sBinPathName, '/');
-      if( !binName )
-         binName = sBinPathName;
-      else
-         *binName++ = '\0';
-      sBinName = binName;
-   }
-}

From 247b12e79549e78e270050a766701ef00e011f78 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Sun, 14 Nov 2021 14:45:42 -0500
Subject: [PATCH 253/399] * BugFix: Correct many include paths and build
 platformX11 on non-Apple Unix.

---
 Engine/source/platformPOSIX/POSIXCPUInfo.cpp        |  2 +-
 Engine/source/platformPOSIX/POSIXFileio.cpp         |  4 +---
 Engine/source/platformPOSIX/POSIXMain.cpp           |  2 +-
 Engine/source/platformPOSIX/POSIXProcessControl.cpp |  2 +-
 Engine/source/platformPOSIX/POSIXTime.cpp           |  2 +-
 Engine/source/platformX11/X11Font.client.cpp        |  4 ++--
 Tools/CMake/torque3d.cmake                          | 10 +++++++---
 7 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/Engine/source/platformPOSIX/POSIXCPUInfo.cpp b/Engine/source/platformPOSIX/POSIXCPUInfo.cpp
index 33b79425e..279d23f1a 100644
--- a/Engine/source/platformPOSIX/POSIXCPUInfo.cpp
+++ b/Engine/source/platformPOSIX/POSIXCPUInfo.cpp
@@ -23,7 +23,7 @@
 #ifndef __APPLE__
 
 #include "platform/platform.h"
-#include "platformX86UNIX/platformX86UNIX.h"
+#include "platformPOSIX/platformPOSIX.h"
 #include "console/console.h"
 #include "core/stringTable.h"
 #include "core/strings/stringFunctions.h"
diff --git a/Engine/source/platformPOSIX/POSIXFileio.cpp b/Engine/source/platformPOSIX/POSIXFileio.cpp
index a9e6a7046..c21e427ba 100644
--- a/Engine/source/platformPOSIX/POSIXFileio.cpp
+++ b/Engine/source/platformPOSIX/POSIXFileio.cpp
@@ -151,7 +151,7 @@ bool ResolvePathCaseInsensitive(char* pathName, S32 pathNameSize, bool requiredA
 #undef Status
 #endif
 
-#include "platformX86UNIX/platformX86UNIX.h"
+#include "platformPOSIX/platformPOSIX.h"
 
 extern int x86UNIXOpen(const char *path, int oflag);
 extern int x86UNIXClose(int fd);
@@ -159,8 +159,6 @@ extern ssize_t x86UNIXRead(int fd, void *buf, size_t nbytes);
 extern ssize_t x86UNIXWrite(int fd, const void *buf, size_t nbytes);
 extern bool ResolvePathCaseInsensitive(char* pathName, S32 pathNameSize, bool requiredAbsolute);
 
-const int MaxPath = PATH_MAX;
-
 namespace
 {
     const char sTempDir[] = "/tmp/";
diff --git a/Engine/source/platformPOSIX/POSIXMain.cpp b/Engine/source/platformPOSIX/POSIXMain.cpp
index dda611967..3e873a27b 100644
--- a/Engine/source/platformPOSIX/POSIXMain.cpp
+++ b/Engine/source/platformPOSIX/POSIXMain.cpp
@@ -26,7 +26,7 @@
 #include "platform/platformInput.h"
 #include "console/console.h"
 
-#include "platformX86UNIX/platformX86UNIX.h"
+#include "platformPOSIX/platformPOSIX.h"
 #include "platformPOSIX/POSIXStdConsole.h"
 #include "platformPOSIX/POSIXState.h"
 
diff --git a/Engine/source/platformPOSIX/POSIXProcessControl.cpp b/Engine/source/platformPOSIX/POSIXProcessControl.cpp
index 0d8725d0b..745240dd5 100644
--- a/Engine/source/platformPOSIX/POSIXProcessControl.cpp
+++ b/Engine/source/platformPOSIX/POSIXProcessControl.cpp
@@ -22,7 +22,7 @@
 
 #ifndef __APPLE__
 
-#include "platformX86UNIX/platformX86UNIX.h"
+#include "platformPOSIX/platformPOSIX.h"
 #include "platformPOSIX/POSIXState.h"
 #include "platformPOSIX/POSIXStdConsole.h"
 #include "platform/platformInput.h"
diff --git a/Engine/source/platformPOSIX/POSIXTime.cpp b/Engine/source/platformPOSIX/POSIXTime.cpp
index 15d733389..2519b479f 100644
--- a/Engine/source/platformPOSIX/POSIXTime.cpp
+++ b/Engine/source/platformPOSIX/POSIXTime.cpp
@@ -22,7 +22,7 @@
 
 #ifndef __APPLE__
 
-#include "platformX86UNIX/platformX86UNIX.h"
+#include "platformPOSIX/platformPOSIX.h"
 #include "platform/platformTimer.h"
 #include "time.h"
 #include <errno.h>
diff --git a/Engine/source/platformX11/X11Font.client.cpp b/Engine/source/platformX11/X11Font.client.cpp
index 402392c9a..2cdfbacac 100644
--- a/Engine/source/platformX11/X11Font.client.cpp
+++ b/Engine/source/platformX11/X11Font.client.cpp
@@ -26,8 +26,8 @@
 #include "console/console.h"
 #include "core/strings/unicode.h"
 #include "core/stringTable.h"
-#include "platformX86UNIX/platformX86UNIX.h"
-#include "platformX86UNIX/x86UNIXFont.h"
+#include "platformPOSIX/platformPOSIX.h"
+#include "platformX11/X11Font.h"
 
 // Needed by createFont
 #include <X11/Xlib.h>
diff --git a/Tools/CMake/torque3d.cmake b/Tools/CMake/torque3d.cmake
index eadc2673a..759e64f01 100644
--- a/Tools/CMake/torque3d.cmake
+++ b/Tools/CMake/torque3d.cmake
@@ -80,7 +80,7 @@ if(WIN32)
     set(ALSOFT_INSTALL_HRTF_DATA OFF CACHE BOOL "Install HRTF definition files" FORCE)
     set(ALSOFT_INSTALL_AMBDEC_PRESETS OFF CACHE BOOL "Install AmbDec presets" FORCE)
     set(ALSOFT_EMBED_HRTF_DATA OFF CACHE BOOL "Embed the HRTF data (increases library footprint)" FORCE)
-    
+
     add_subdirectory( ${libDir}/openal-soft ${CMAKE_CURRENT_BINARY_DIR}/openal-soft)
 endif()
 
@@ -241,7 +241,7 @@ if(WIN32)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -wd4018")
     # warning C4244: 'initializing' : conversion from 'XXX' to 'XXX', possible loss of data
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -wd4244")
-	if(TORQUE_SFX_DirectX) 
+	if(TORQUE_SFX_DirectX)
 		if( TORQUE_CPU_X64 )
 			link_directories($ENV{DXSDK_DIR}/Lib/x64)
 		else()
@@ -599,11 +599,15 @@ if(APPLE)
     addPath("${srcDir}/platformPOSIX")
 endif()
 
+if (UNIX AND NOT APPLE)
+    addPath("${srcDir}/platformX11")
+endif()
+
 if(UNIX AND NOT APPLE)
     # linux_dedicated
     if(TORQUE_DEDICATED)
 		addPath("${srcDir}/windowManager/dedicated")
-		# ${srcDir}/platformX86UNIX/*.client.* files are not needed
+		# ${srcDir}/UNIX/*.client.* files are not needed
 		# @todo: move to separate file
 		file( GLOB tmp_files
              ${srcDir}/platformX86UNIX/*.cpp

From eb24b63be49d8c8ee551a3089ae12978a5267b21 Mon Sep 17 00:00:00 2001
From: Areloch <Areloch@gmail.com>
Date: Sun, 14 Nov 2021 21:39:51 -0600
Subject: [PATCH 254/399] Shifts utilization of gui elements in editors that
 point to 'normal' image assets to utilize generated previews instead. This
 reduces console spam about mismatched texture profiles and improves
 stability.

---
 Engine/source/T3D/assets/ImageAsset.cpp       |  15 +-
 .../assetBrowser/scripts/assetBrowser.tscript |  47 ++++
 .../convexEditor/convexEditorGui.tscript      |  10 +-
 .../tools/decalEditor/decalEditorGui.tscript  |  33 +--
 .../BaseGame/game/tools/gui/uvEditor.ed.gui   |   3 +-
 .../scripts/materialEditor.ed.tscript         | 209 ++++++------------
 .../particleParticleEditor.ed.tscript         |  26 +--
 .../scripts/editors/terrainEditor.ed.tscript  |   4 +-
 .../interfaces/terrainMaterialDlg.ed.tscript  |  98 ++------
 9 files changed, 168 insertions(+), 277 deletions(-)

diff --git a/Engine/source/T3D/assets/ImageAsset.cpp b/Engine/source/T3D/assets/ImageAsset.cpp
index eb5f5036d..af55747ca 100644
--- a/Engine/source/T3D/assets/ImageAsset.cpp
+++ b/Engine/source/T3D/assets/ImageAsset.cpp
@@ -549,7 +549,20 @@ bool GuiInspectorTypeImageAssetPtr::renderTooltip(const Point2I& hoverPos, const
    if (!filename || !filename[0])
       return false;
 
-   GFXTexHandle texture(filename, &GFXStaticTextureSRGBProfile, avar("%s() - tooltip texture (line %d)", __FUNCTION__, __LINE__));
+   StringTableEntry previewFilename = filename;
+   if (Con::isFunction("getAssetPreviewImage"))
+   {
+      ConsoleValue consoleRet = Con::executef("getAssetPreviewImage", filename);
+      previewFilename = StringTable->insert(consoleRet.getString());
+
+      if (AssetDatabase.isDeclaredAsset(previewFilename))
+      {
+         ImageAsset* previewAsset = AssetDatabase.acquireAsset<ImageAsset>(previewFilename);
+         previewFilename = previewAsset->getImagePath();
+      }
+   }
+
+   GFXTexHandle texture(previewFilename, &GFXStaticTextureSRGBProfile, avar("%s() - tooltip texture (line %d)", __FUNCTION__, __LINE__));
    if (texture.isNull())
       return false;
 
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
index d3e2996e0..3dd803a62 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
@@ -2488,3 +2488,50 @@ function AssetBrowser::importLooseFiles(%this)
    echo("Adding loose files at directory " @ %this.dirHandler.currentAddress);
    LooseFileAuditWindow.showDialog(%this.dirHandler.currentAddress);  
 }
+
+//
+function getAssetPreviewImage(%asset)
+{
+   if(isFile(%asset))
+   {
+      %aq = new AssetQuery();
+      %assetsFound = AssetDatabase.findAssetLooseFile(%aq, %asset);
+      if(%assetsFound != 0)
+      {
+         %asset = %aq.getAsset(0);
+      }
+      else
+      {
+         %previewPath = %asset;
+      }
+      
+      %aq.delete();
+   }
+   
+   if(AssetDatabase.isDeclaredAsset(%asset))
+   {
+      %moduleName = AssetDatabase.getAssetModule(%asset).ModuleId;
+      %assetName = AssetDatabase.getAssetName(%asset);
+      %previewAssetName = "ToolsModule:" @ %moduleName @ "_" @ %assetName @ "_PreviewImage";
+      
+      if(AssetDatabase.isDeclaredAsset(%previewAssetName))
+      {
+         %previewDef = AssetDatabase.acquireAsset(%previewAssetName);  
+         %previewPath = %previewDef.getImagePath();
+         AssetDatabase.releaseAsset(%previewAssetName);
+      }
+      else
+      {
+         %previewPath = %asset;  
+      }
+   }
+   else
+   {
+      %previewPath = %asset;
+   }
+   
+   if(%previewPath $= "")
+      %previewPath = "ToolsModule:unknownImage_image";
+   
+   return %previewPath;
+}
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/convexEditor/convexEditorGui.tscript b/Templates/BaseGame/game/tools/convexEditor/convexEditorGui.tscript
index 65266a382..253508d75 100644
--- a/Templates/BaseGame/game/tools/convexEditor/convexEditorGui.tscript
+++ b/Templates/BaseGame/game/tools/convexEditor/convexEditorGui.tscript
@@ -38,7 +38,7 @@ function ConvexEditorGui::onWake( %this )
 		   %mat = %matName;
 		}
 		
-		ConvexEditorOptionsWindow-->matPreviewBtn.setBitmap(%mat.getDiffuseMap(0));
+		ConvexEditorOptionsWindow-->matPreviewBtn.setBitmap( getAssetPreviewImage(%mat.getDiffuseMap(0)));
 		
 		ConvexEditorOptionsWindow.activeMaterial = %mat;
 	}
@@ -76,7 +76,7 @@ function ConvexEditorGui::onSelectionChanged( %this, %shape, %face )
 
    ConvexEditorOptionsWindow-->defMatPreviewBtn.setText("");
    %shapeMat = %shape.getMaterial();
-   ConvexEditorOptionsWindow-->defMatPreviewBtn.setBitmap(%shapeMat.getDiffuseMap(0));
+   ConvexEditorOptionsWindow-->defMatPreviewBtn.setBitmap(getAssetPreviewImage(%shapeMat.getDiffuseMap(0)));
 
    ConvexEditorOptionsWindow.activeShape = %shape;
       
@@ -175,7 +175,7 @@ function ConvexEditorMaterialBtn::gotMaterialName(%this, %name)
       }
    }
 
-   ConvexEditorOptionsWindow-->matPreviewBtn.setBitmap(%diffusemap);
+   ConvexEditorOptionsWindow-->matPreviewBtn.setBitmap(getAssetPreviewImage(%diffusemap));
 
    ConvexEditorOptionsWindow.activeMaterial = %materialAsset.materialDefinitionName;
 }
@@ -191,7 +191,7 @@ function ConvexEditorMaterialLiftBtn::onClick(%this)
 {
    %mat = ConvexEditorGui.getSelectedFaceMaterial();
    ConvexEditorOptionsWindow.activeMaterial = %mat;
-   ConvexEditorOptionsWindow-->matPreviewBtn.setBitmap(%mat.getDiffuseMap(0));
+   ConvexEditorOptionsWindow-->matPreviewBtn.setBitmap(getAssetPreviewImage(%mat.getDiffuseMap(0)));
 }
 
 function ConvexEditorMaterialResetBtn::onClick(%this)
@@ -240,7 +240,7 @@ function ConvexEditorDefaultMaterialBtn::gotMaterialName(%this, %name)
       }
    }
 
-   ConvexEditorOptionsWindow-->defMatPreviewBtn.setBitmap(%diffusemap);
+   ConvexEditorOptionsWindow-->defMatPreviewBtn.setBitmap(getAssetPreviewImage(%diffusemap));
 
    ConvexEditorOptionsWindow.activeShape.setMaterial(%name);
 
diff --git a/Templates/BaseGame/game/tools/decalEditor/decalEditorGui.tscript b/Templates/BaseGame/game/tools/decalEditor/decalEditorGui.tscript
index 0138d5331..3257ab7cd 100644
--- a/Templates/BaseGame/game/tools/decalEditor/decalEditorGui.tscript
+++ b/Templates/BaseGame/game/tools/decalEditor/decalEditorGui.tscript
@@ -326,51 +326,40 @@ function DecalInspector::removeDirty()
 
 function DecalEditorGui::updateDecalPreview( %this, %material )
 {
+   %previewImage = "";
+   
    if( isObject( %material ) )
    {
-      DecalPreviewWindow-->decalPreview.setBitmap( %material.getDiffuseMap(0) );
+      %previewImage = %material.getDiffuseMap(0);
    }
    else
    {
       if(AssetDatabase.isDeclaredAsset(%material))
       {
-         %assetDef = AssetDatabase.acquireAsset(%material);
-         %difMap = %assetDef.materialDefinitionName.getDiffuseMap(0);
-         AssetDatabase.acquireAsset(%material);
-         
-         if(%difMap !$= "" && %difMap !$= "Core_Rendering:missingTexture")
-         {
-            DecalPreviewWindow-->decalPreview.setBitmap( %difMap );
-            return;
+         %previewImage = %material;
          }
       }
-      DecalPreviewWindow-->decalPreview.setBitmap("ToolsModule:unknownImage_image");
+   
+   DecalPreviewWindow-->decalPreview.setBitmap( getAssetPreviewImage(%previewImage) );
    }
-}
 
 function DecalEditorGui::updateInstancePreview( %this, %material )
 {
+   %previewImage = "";
+   
    if( isObject( %material ) )
    {
-      DecalPreviewWindow-->instancePreview.setBitmap( %material.getDiffuseMap(0) );      
+      %previewImage = %material.getDiffuseMap(0);
    }
    else
    {
       if(AssetDatabase.isDeclaredAsset(%material))
       {
-         %assetDef = AssetDatabase.acquireAsset(%material);
-         %difMap = %assetDef.materialDefinitionName.getDiffuseMap(0);
-         AssetDatabase.acquireAsset(%material);
-         
-         if(%difMap !$= "" && %difMap !$= "Core_Rendering:missingTexture")
-         {
-            DecalPreviewWindow-->instancePreview.setBitmap( %difMap );
-            return;
+         %previewImage = %material;
          }
       }
       
-      DecalPreviewWindow-->instancePreview.setBitmap("ToolsModule:unknownImage_image");   
-}
+   DecalPreviewWindow-->instancePreview.setBitmap( getAssetPreviewImage(%previewImage) ); 
 }
 
 function DecalEditorGui::rebuildInstanceTree( %this )
diff --git a/Templates/BaseGame/game/tools/gui/uvEditor.ed.gui b/Templates/BaseGame/game/tools/gui/uvEditor.ed.gui
index bddecffc3..c83c11b67 100644
--- a/Templates/BaseGame/game/tools/gui/uvEditor.ed.gui
+++ b/Templates/BaseGame/game/tools/gui/uvEditor.ed.gui
@@ -512,7 +512,8 @@ function UVEditor::showDialog( %this, %applyCallback, %obj, %uv)
       else if( %material.cubemap.cubeFace[0] !$= "" )
          %previewImage = %material.cubemap.cubeFace[0];
          }
-   UVEditor-->bitmapPreview.setBitmap(%previewImage);
+   
+   UVEditor-->bitmapPreview.setBitmap(getAssetPreviewImage(%previewImage));
    
    // Set up the color popup
    %popup = UVEditor-->colorPopup;
diff --git a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
index 4cf7ba4a6..124ae856a 100644
--- a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
@@ -804,174 +804,92 @@ function MaterialEditorGui::guiSync( %this, %material )
    %layer = MaterialEditorGui.currentLayer;
    
    //Diffuse
-   if((%material).getDiffuseMap(%layer) !$= "" && (%material).getDiffuseMapAsset(%layer) !$= $MaterialEditor::emptyMaterialImage) 
-   {
-      %difAsset = (%material).getDiffuseMapAsset(%layer);
-      MaterialEditorPropertiesWindow-->diffuseMapNameText.setText( (%material).getDiffuseMapAsset(%layer) );      
-      MaterialEditorPropertiesWindow-->diffuseMapDisplayBitmap.setBitmap( (%material).getDiffuseMap(%layer) );
-   }
-   else
-   {
-      MaterialEditorPropertiesWindow-->diffuseMapNameText.setText( "None" );
-      MaterialEditorPropertiesWindow-->diffuseMapDisplayBitmap.setBitmap( $MaterialEditor::emptyMaterialImage );
-   }
+   %diffuseMap = (%material).getDiffuseMap(%layer);
+   %diffuseMapText = %diffuseMap !$= "" && %diffuseMap !$=$MaterialEditor::emptyMaterialImage ? (%material).getDiffuseMapAsset(%layer) : "None";
+   MaterialEditorPropertiesWindow-->diffuseMapNameText.setText( %diffuseMapText );      
+   MaterialEditorPropertiesWindow-->diffuseMapDisplayBitmap.setBitmap( getAssetPreviewImage(%diffuseMap) );
  
    //Normal
-   if((%material).getNormalMap(%layer) !$= "" && (%material).getNormalMap(%layer) !$= $MaterialEditor::emptyMaterialImage) 
-   {
-      MaterialEditorPropertiesWindow-->normalMapNameText.setText( (%material).getNormalMapAsset(%layer) );      
-      MaterialEditorPropertiesWindow-->normalMapDisplayBitmap.setBitmap( (%material).getNormalMap(%layer) );
-   }
-   else
-   {
-      MaterialEditorPropertiesWindow-->normalMapNameText.setText( "None" );
-      MaterialEditorPropertiesWindow-->normalMapDisplayBitmap.setBitmap( $MaterialEditor::emptyMaterialImage );
-   }
+   %normalMap = (%material).getNormalMap(%layer);
+   %normalMapText = %normalMap !$= "" && %normalMap !$=$MaterialEditor::emptyMaterialImage ? (%material).getNormalMapAsset(%layer) : "None";
+   MaterialEditorPropertiesWindow-->normalMapNameText.setText( %normalMapText );      
+   MaterialEditorPropertiesWindow-->normalMapDisplayBitmap.setBitmap( getAssetPreviewImage(%normalMap) );
    
    //ORM Config
-   if((%material).getORMConfigMap(%layer) !$= "" && (%material).getORMConfigMap(%layer) !$= $MaterialEditor::emptyMaterialImage) 
+   %ormMap = (%material).getNormalMap(%layer);
+   %hasOrmMap = (%ormMap !$= "" && %ormMap !$=$MaterialEditor::emptyMaterialImage);
+   %ormMapText = %hasOrmMap ? (%material).getNormalMapAsset(%layer) : "None";
+   MaterialEditorPropertiesWindow-->ORMConfigMapNameText.setText(%ormMapText );      
+   MaterialEditorPropertiesWindow-->ORMConfigMapDisplayBitmap.setBitmap( getAssetPreviewImage(%ormMap) );
+
+   //show or hide depending on if we have a map assigned here
+   MaterialEditorPropertiesWindow-->RoughnessTextEdit.setVisible(!%hasOrmMap);
+   MaterialEditorPropertiesWindow-->RoughnessSlider.setVisible(!%hasOrmMap);
+   MaterialEditorPropertiesWindow-->MetalnessTextEdit.setVisible(!%hasOrmMap);
+   MaterialEditorPropertiesWindow-->MetalnessSlider.setVisible(!%hasOrmMap);
+   
+   if(%hasOrmMap)
    {
-      MaterialEditorPropertiesWindow-->ORMConfigMapNameText.setText( (%material).getORMConfigMapAsset(%layer) );      
-      MaterialEditorPropertiesWindow-->ORMConfigMapDisplayBitmap.setBitmap( (%material).getORMConfigMap(%layer) );
-      //hide unused
-      MaterialEditorPropertiesWindow-->RoughnessTextEdit.setVisible(false);
-      MaterialEditorPropertiesWindow-->RoughnessSlider.setVisible(false);
-      MaterialEditorPropertiesWindow-->MetalnessTextEdit.setVisible(false);
-      MaterialEditorPropertiesWindow-->MetalnessSlider.setVisible(false);
-      
       MaterialEditorPropertiesWindow-->isSRGBCheckbox.setValue((%material).isSRGB[%layer]);
       MaterialEditorPropertiesWindow-->invertRoughnessCheckbox.setValue((%material).invertRoughness[%layer]);
-      //show used
-      MaterialEditorPropertiesWindow-->isSRGBCheckbox.setVisible(true);
-      MaterialEditorPropertiesWindow-->invertRoughnessCheckbox.setVisible(true);
-
    }
-   else
-   {
-      MaterialEditorPropertiesWindow-->ORMConfigMapNameText.setText( "None" );
-      MaterialEditorPropertiesWindow-->ORMConfigMapDisplayBitmap.setBitmap( $MaterialEditor::emptyMaterialImage );
       
-      MaterialEditorPropertiesWindow-->RoughnessTextEdit.setText((%material).Roughness[%layer]);
-      MaterialEditorPropertiesWindow-->RoughnessSlider.setValue((%material).Roughness[%layer]);
-      MaterialEditorPropertiesWindow-->MetalnessTextEdit.setText((%material).Metalness[%layer]);
-      MaterialEditorPropertiesWindow-->MetalnessSlider.setValue((%material).Metalness[%layer]);   
-      //show used   
-      MaterialEditorPropertiesWindow-->RoughnessTextEdit.setVisible(true);
-      MaterialEditorPropertiesWindow-->RoughnessSlider.setVisible(true);
-      MaterialEditorPropertiesWindow-->MetalnessTextEdit.setVisible(true);
-      MaterialEditorPropertiesWindow-->MetalnessSlider.setVisible(true);
-      
-      //hide unused
-      MaterialEditorPropertiesWindow-->isSRGBCheckbox.setVisible(false);
-      MaterialEditorPropertiesWindow-->invertRoughnessCheckbox.setVisible(false);
-   }
+   MaterialEditorPropertiesWindow-->isSRGBCheckbox.setVisible(%hasOrmMap);
+   MaterialEditorPropertiesWindow-->invertRoughnessCheckbox.setVisible(%hasOrmMap);
    
    //AOMap
-   if((%material).getAOMap(%layer) !$= "" && (%material).getAOMap(%layer) !$= $MaterialEditor::emptyMaterialImage) 
-   {
-      MaterialEditorPropertiesWindow-->aoMapNameText.setText( (%material).getAOMapAsset(%layer) );      
-      MaterialEditorPropertiesWindow-->aoMapDisplayBitmap.setBitmap( (%material).getAOMap(%layer) );
-   }
-   else
-   {
-      MaterialEditorPropertiesWindow-->aoMapNameText.setText( "None" );
-      MaterialEditorPropertiesWindow-->aoMapDisplayBitmap.setBitmap( $MaterialEditor::emptyMaterialImage );
-   }
+   %aoMap = (%material).getAOMap(%layer);
+   %aoMapText = %aoMap !$= "" && %aoMap !$=$MaterialEditor::emptyMaterialImage ? (%material).getAOMapAsset(%layer) : "None";
+   MaterialEditorPropertiesWindow-->aoMapNameText.setText( %aoMapText );      
+   MaterialEditorPropertiesWindow-->aoMapDisplayBitmap.setBitmap( getAssetPreviewImage(%aoMap) );
+   
    //RoughMap
-   if((%material).getRoughMap(%layer) !$= "" && (%material).getRoughMap(%layer) !$= $MaterialEditor::emptyMaterialImage) 
-   {
-      MaterialEditorPropertiesWindow-->roughMapNameText.setText( (%material).getRoughMapAsset(%layer) );      
-      MaterialEditorPropertiesWindow-->roughMapDisplayBitmap.setBitmap( (%material).getRoughMap(%layer) );
-   }
-   else
-   {
-      MaterialEditorPropertiesWindow-->roughMapNameText.setText( "None" );
-      MaterialEditorPropertiesWindow-->roughMapDisplayBitmap.setBitmap( $MaterialEditor::emptyMaterialImage );
-   }
+   %roughMap = (%material).getRoughMap(%layer);
+   %roughMapText = %roughMap !$= "" && %roughMap !$=$MaterialEditor::emptyMaterialImage ? (%material).getRoughMapAsset(%layer) : "None";
+   MaterialEditorPropertiesWindow-->roughMapNameText.setText( %roughMapText );      
+   MaterialEditorPropertiesWindow-->roughMapDisplayBitmap.setBitmap( getAssetPreviewImage(%roughMap) );
    
    //MetalMap
-   if((%material).getMetalMap(%layer) !$= "" && (%material).getMetalMap(%layer) !$= $MaterialEditor::emptyMaterialImage) 
-   {
-      MaterialEditorPropertiesWindow-->metalMapNameText.setText( (%material).getMetalMapAsset(%layer) );      
-      MaterialEditorPropertiesWindow-->metalMapDisplayBitmap.setBitmap( (%material).getMetalMap(%layer) );
-   }
-   else
-   {
-      MaterialEditorPropertiesWindow-->metalMapNameText.setText( "None" );
-      MaterialEditorPropertiesWindow-->metalMapDisplayBitmap.setBitmap( $MaterialEditor::emptyMaterialImage );
-   }
+   %metalMap = (%material).getMetalMap(%layer);
+   %metalMapText = %metalMap !$= "" && %metalMap !$=$MaterialEditor::emptyMaterialImage ? (%material).getMetalMapAsset(%layer) : "None";
+   MaterialEditorPropertiesWindow-->metalMapNameText.setText( %metalMapText );      
+   MaterialEditorPropertiesWindow-->metalMapDisplayBitmap.setBitmap( getAssetPreviewImage(%metalMap) );
    
    //GlowMap
-   if((%material).getGlowMap(%layer) !$= "" && (%material).getGlowMap(%layer) !$= $MaterialEditor::emptyMaterialImage) 
-   {
-      MaterialEditorPropertiesWindow-->glowMapNameText.setText( (%material).getGlowMapAsset(%layer) );      
-      MaterialEditorPropertiesWindow-->glowMapDisplayBitmap.setBitmap( (%material).getGlowMap(%layer) );
-   }
-   else
-   {
-      MaterialEditorPropertiesWindow-->glowMapNameText.setText( "None" );
-      MaterialEditorPropertiesWindow-->glowMapDisplayBitmap.setBitmap( $MaterialEditor::emptyMaterialImage );
-   }
+   %glowMap = (%material).getGlowMap(%layer);
+   %glowMapText = %glowMap !$= "" && %glowMap !$=$MaterialEditor::emptyMaterialImage ? (%material).getGlowMapAsset(%layer) : "None";
+   MaterialEditorPropertiesWindow-->glowMapNameText.setText( %glowMapText );      
+   MaterialEditorPropertiesWindow-->glowMapDisplayBitmap.setBitmap( getAssetPreviewImage(%glowMap) );
       
    //Overlay
-   if((%material).getOverlayMap(%layer) !$= "" && (%material).getOverlayMap(%layer) !$= $MaterialEditor::emptyMaterialImage) 
-   {
-      MaterialEditorPropertiesWindow-->overlayMapNameText.setText( (%material).getOverlayMapAsset(%layer) );      
-      MaterialEditorPropertiesWindow-->overlayMapDisplayBitmap.setBitmap( (%material).getOverlayMap(%layer) );
-   }
-   else
-   {
-      MaterialEditorPropertiesWindow-->overlayMapNameText.setText( "None" );
-      MaterialEditorPropertiesWindow-->overlayMapDisplayBitmap.setBitmap( $MaterialEditor::emptyMaterialImage );
-   }
+   %overlayMap = (%material).getOverlayMap(%layer);
+   %overlayMapText = %overlayMap !$= "" && %overlayMap !$=$MaterialEditor::emptyMaterialImage ? (%material).getOverlayMapAsset(%layer) : "None";
+   MaterialEditorPropertiesWindow-->overlayMapNameText.setText( %overlayMapText );      
+   MaterialEditorPropertiesWindow-->overlayMapDisplayBitmap.setBitmap( getAssetPreviewImage(%overlayMap) );
    
    //Detail
-   if((%material).getDetailMap(%layer) !$= "" && (%material).getDetailMap(%layer) !$= $MaterialEditor::emptyMaterialImage) 
-   {
-      MaterialEditorPropertiesWindow-->detailMapNameText.setText( (%material).getDetailMapAsset(%layer) );      
-      MaterialEditorPropertiesWindow-->detailMapDisplayBitmap.setBitmap( (%material).getDetailMap(%layer) );
-   }
-   else
-   {
-      MaterialEditorPropertiesWindow-->detailMapNameText.setText( "None" );
-      MaterialEditorPropertiesWindow-->detailMapDisplayBitmap.setBitmap( $MaterialEditor::emptyMaterialImage );
-   }
+   %detailMap = (%material).getDetailMap(%layer);
+   %detailMapText = %detailMap !$= "" && %detailMap !$=$MaterialEditor::emptyMaterialImage ? (%material).getDetailMapAsset(%layer) : "None";
+   MaterialEditorPropertiesWindow-->detailMapNameText.setText( %detailMapText );      
+   MaterialEditorPropertiesWindow-->detailMapDisplayBitmap.setBitmap( getAssetPreviewImage(%detailMap) );
    
    //Detail Normal
-   if((%material).getDetailNormalMap(%layer) !$= "" && (%material).getDetailNormalMap(%layer) !$= $MaterialEditor::emptyMaterialImage) 
-   {
-      MaterialEditorPropertiesWindow-->detailNormalMapNameText.setText( (%material).getDetailNormalMapAsset(%layer) );      
-      MaterialEditorPropertiesWindow-->detailNormalMapDisplayBitmap.setBitmap( (%material).getDetailNormalMap(%layer) );
-   }
-   else
-   {
-      MaterialEditorPropertiesWindow-->detailNormalMapNameText.setText( "None" );
-      MaterialEditorPropertiesWindow-->detailNormalMapDisplayBitmap.setBitmap( $MaterialEditor::emptyMaterialImage );
-   }
+   %detailNormalMap = (%material).getDetailNormalMap(%layer);
+   %detailNormalMapText = %detailNormalMap !$= "" && %detailNormalMap !$=$MaterialEditor::emptyMaterialImage ? (%material).getDetailNormalMapAsset(%layer) : "None";
+   MaterialEditorPropertiesWindow-->detailNormalMapNameText.setText( %detailNormalMapText );      
+   MaterialEditorPropertiesWindow-->detailNormalMapDisplayBitmap.setBitmap( getAssetPreviewImage(%detailNormalMap) );
    
    //Light
-   if((%material).getLightMap(%layer) !$= "" && (%material).getLightMap(%layer) !$= $MaterialEditor::emptyMaterialImage) 
-   {
-      MaterialEditorPropertiesWindow-->lightMapNameText.setText( (%material).getLightMapAsset(%layer) );      
-      MaterialEditorPropertiesWindow-->lightMapDisplayBitmap.setBitmap( (%material).getLightMap(%layer) );
-   }
-   else
-   {
-      MaterialEditorPropertiesWindow-->lightMapNameText.setText( "None" );
-      MaterialEditorPropertiesWindow-->lightMapDisplayBitmap.setBitmap( $MaterialEditor::emptyMaterialImage );
-   }
+   %lightMap = (%material).getLightMap(%layer);
+   %lightMapText = %lightMap !$= "" && %lightMap !$=$MaterialEditor::emptyMaterialImage ? (%material).getLightMapAsset(%layer) : "None";
+   MaterialEditorPropertiesWindow-->lightMapNameText.setText( %lightMapText );      
+   MaterialEditorPropertiesWindow-->lightMapDisplayBitmap.setBitmap( getAssetPreviewImage(%lightMap) );
    
    //Tone
-   if((%material).getToneMap(%layer) !$= "" && (%material).getToneMap(%layer) !$= $MaterialEditor::emptyMaterialImage) 
-   {
-      MaterialEditorPropertiesWindow-->toneMapNameText.setText( (%material).getToneMapAsset(%layer) );      
-      MaterialEditorPropertiesWindow-->toneMapDisplayBitmap.setBitmap( (%material).getToneMap(%layer) );
-   }
-   else
-   {
-      MaterialEditorPropertiesWindow-->toneMapNameText.setText( "None" );
-      MaterialEditorPropertiesWindow-->toneMapDisplayBitmap.setBitmap( $MaterialEditor::emptyMaterialImage );
-   }
+   %toneMap = (%material).getToneMap(%layer);
+   %toneMapText = %toneMap !$= "" && %toneMap !$=$MaterialEditor::emptyMaterialImage ? (%material).getToneMapAsset(%layer) : "None";
+   MaterialEditorPropertiesWindow-->toneMapNameText.setText( %toneMapText );      
+   MaterialEditorPropertiesWindow-->toneMapDisplayBitmap.setBitmap( getAssetPreviewImage(%toneMap) );
    
    MaterialEditorPropertiesWindow-->accuScaleTextEdit.setText((%material).accuScale[%layer]);
    MaterialEditorPropertiesWindow-->accuScaleTextEdit.setText((%material).accuScale[%layer]);
@@ -1254,12 +1172,9 @@ function MaterialEditorGui::doUpdateTextureMap( %this, %assetId )
       %bitmapCtrl = MaterialEditorPropertiesWindow.findObjectByInternalName( %type @ "MapDisplayBitmap", true );
       %textCtrl = MaterialEditorPropertiesWindow.findObjectByInternalName( %type @ "MapNameText", true );
    
-      %assetDef = AssetDatabase.acquireAsset(%assetId);
-
-      %texture = %assetDef.getImagePath();
+      %texture = getAssetPreviewImage(%assetId);
    
-      //%texture = MaterialEditorGui.openFile("texture");
-      if( %texture !$= "" )
+      if( %texture !$= "" && %texture !$= $MaterialEditor::emptyMaterialImage)
       {         
          %bitmapCtrl.setBitmap(%texture);
       
diff --git a/Templates/BaseGame/game/tools/particleEditor/particleParticleEditor.ed.tscript b/Templates/BaseGame/game/tools/particleEditor/particleParticleEditor.ed.tscript
index e1a34fe4b..64486e92e 100644
--- a/Templates/BaseGame/game/tools/particleEditor/particleParticleEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/particleEditor/particleParticleEditor.ed.tscript
@@ -57,24 +57,11 @@ function PE_ParticleEditor::guiSync( %this )
    %popup.sort();
    %popup.setSelected( %data );
          
-   %bitmap = %data.getTexture();//MaterialEditorGui.searchForTexture( %data.getName(), %data.getTexture() );
-   if( %bitmap !$= "" )
-   {
-      PE_ParticleEditor-->PEP_previewImage.setBitmap( %bitmap );
-      
-      %text = %data.getTextureAsset();
-      if(%text $= "")
-         %text = %bitmap;
-         
-      PE_ParticleEditor-->PEP_previewImageName.setText( %text );
-      PE_ParticleEditor-->PEP_previewImageName.tooltip = %bitmap;
-   }
-   else
-   {
-      PE_ParticleEditor-->PEP_previewImage.setBitmap( "" );
-      PE_ParticleEditor-->PEP_previewImageName.setText( "None" );
-      PE_ParticleEditor-->PEP_previewImageName.tooltip = "None";
-   }
+   %bitmap = %data.getTexture();
+   %bitmapText = %bitmap !$= "" && %bitmap !$= $MaterialEditor::emptyMaterialImage ? %data.getTextureAsset() : "None";
+   PE_ParticleEditor-->PEP_previewImageName.setText( %bitmapText );    
+   PE_ParticleEditor-->PEP_previewImageName.tooltip = %bitmapText;  
+   PE_ParticleEditor-->PEP_previewImage.setBitmap( getAssetPreviewImage(%bitmap) );
    
    PE_ParticleEditor-->PEP_inverseAlpha.setValue( %data.useInvAlpha );
    
@@ -396,6 +383,9 @@ function PE_ParticleEditor::loadNewParticle( %this, %particle )
    else
       %particle = PEP_ParticleSelector.getSelected();
       
+   if( !isObject( %particle ) )
+      return;
+      
    PE_ParticleEditor.currParticle = %particle;
    
    error("PE_ParticleEditor::loadNewParticle() - Loading particle: " @ %particle.getName());
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/editors/terrainEditor.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/editors/terrainEditor.ed.tscript
index e9f39b003..68d03f4e8 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/editors/terrainEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/editors/terrainEditor.ed.tscript
@@ -62,7 +62,7 @@ function TerrainEditor::setPaintMaterial( %this, %matIndex, %terrainMat )
    ETerrainMaterialSelected.selectedMatIndex = %matIndex;
    ETerrainMaterialSelected.selectedMat = %terrainMat;
    
-   ETerrainMaterialSelected.setBitmap(%terrainMat.getDiffuseMap());
+   ETerrainMaterialSelected.setBitmap(getAssetPreviewImage(%terrainMat.getDiffuseMap()));
 
    ETerrainMaterialSelectedEdit.Visible = isObject(%terrainMat);
    TerrainTextureText.text = %terrainMat.getInternalName();
@@ -141,7 +141,7 @@ function EPainter::updateLayers( %this, %matIndex )
       };
 
       %ctrl.setText( %matInternalName );
-      %ctrl.setBitmap( %mat.getDiffuseMap() );
+      %ctrl.setBitmap( getAssetPreviewImage(%mat.getDiffuseMap()) );
 
       %tooltip = %matInternalName;
       if(%i < 9)
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript
index 0a47f96ee..5429008ea 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript
@@ -296,7 +296,7 @@ function TerrainMaterialDlg::changeTerrainMatMapAsset(%this)
       %image = $TerrainMaterialEditor::emptyMaterialImage;
    }
 
-   %targetMap.setBitmap( %image );  
+   %targetMap.setBitmap( getAssetPreviewImage(%image) );  
 
    %targetMapName = %targetMap @ "AssetId";
    %targetMapName.setText(%imgAsset);
@@ -420,99 +420,35 @@ function TerrainMaterialDlg::setActiveMaterial( %this, %mat )
 
       //
       %imgPath = %mat.getDiffuseMap();
-      if(%imgPath $= "")
-         %imgPath = $TerrainMaterialEditor::emptyMaterialImage;
-
-      %this-->texBaseMap.setBitmap( %imgPath );
-      
-      if(%imgPath !$= $TerrainMaterialEditor::emptyMaterialImage)
-      {
-         %imgAsset = %mat.getDiffuseMapAsset();
-         if(%imgAsset $= "")
-            %imgAsset = %imgPath;
-         %this-->diffuseMapAssetId.setText( %imgAsset );
-      }
-      else
-      {
-         %this-->diffuseMapAssetId.setText( "None" );  
-      }
+      %imgPathText = %imgPath !$= "" && %imgPath !$= $TerrainMaterialEditor::emptyMaterialImage ? %mat.getDiffuseMapAsset() : "None";
+      %this-->diffuseMapAssetId.setText( %imgPathText );
+      %this-->texBaseMap.setBitmap( getAssetPreviewImage(%imgPath) );
 
       //
       %imgPath = %mat.getNormalMap();
-      if(%imgPath $= "")
-         %imgPath = $TerrainMaterialEditor::emptyMaterialImage;
-
-      %this-->texNormalMap.setBitmap( %imgPath );
-      
-      if(%imgPath !$= $TerrainMaterialEditor::emptyMaterialImage)
-      {
-         %imgAsset = %mat.getNormalMapAsset();
-         if(%imgAsset $= "")
-            %imgAsset = %imgPath;
-         %this-->normalMapAssetId.setText( %imgAsset );
-      }
-      else
-      {
-         %this-->normalMapAssetId.setText( "None" );  
-      }
+      %imgPathText = %imgPath !$= "" && %imgPath !$= $TerrainMaterialEditor::emptyMaterialImage ? %mat.getNormalMapAsset() : "None";
+      %this-->normalMapAssetId.setText( %imgPathText );
+      %this-->texNormalMap.setBitmap( getAssetPreviewImage(%imgPath) );
 
       //
       %imgPath = %mat.getORMConfigMap();
-      if(%imgPath $= "")
-         %imgPath = $TerrainMaterialEditor::emptyMaterialImage;
-
-      %this-->texORMConfigMap.setBitmap( %imgPath );
-      
-      if(%imgPath !$= $TerrainMaterialEditor::emptyMaterialImage)
-      {
-         %imgAsset = %mat.getORMConfigMapAsset();
-         if(%imgAsset $= "")
-            %imgAsset = %imgPath;
-         %this-->ORMMapAssetId.setText( %imgAsset );
-      }
-      else
-      {
-         %this-->ORMMapAssetId.setText( "None" );  
-      }
+      %imgPathText = %imgPath !$= "" && %imgPath !$= $TerrainMaterialEditor::emptyMaterialImage ? %mat.getORMConfigMapAsset() : "None";
+      %this-->ORMMapAssetId.setText( %imgPathText );
+      %this-->texORMConfigMap.setBitmap( getAssetPreviewImage(%imgPath) );
        
       //
       %imgPath = %mat.getDetailMap();
-      if(%imgPath $= "")
-         %imgPath = $TerrainMaterialEditor::emptyMaterialImage;
-
-      %this-->texDetailMap.setBitmap( %imgPath );
-      
-      if(%imgPath !$= $TerrainMaterialEditor::emptyMaterialImage)
-      {
-         %imgAsset = %mat.getDetailMapAsset();
-         if(%imgAsset $= "")
-            %imgAsset = %imgPath;
-         %this-->detailMapAssetId.setText( %imgAsset );
-      }
-      else
-      {
-         %this-->detailMapAssetId.setText( "None" );  
-      }
+      %imgPathText = %imgPath !$= "" && %imgPath !$= $TerrainMaterialEditor::emptyMaterialImage ? %mat.getDetailMapAsset() : "None";
+      %this-->detailMapAssetId.setText( %imgPathText );
+      %this-->texDetailMap.setBitmap( getAssetPreviewImage(%imgPath) );
       
       //
       %imgPath = %mat.getMacroMap();
-      if(%imgPath $= "")
-         %imgPath = $TerrainMaterialEditor::emptyMaterialImage;
-
-      %this-->texMacroMap.setBitmap( %imgPath );
-
-      if(%imgPath !$= $TerrainMaterialEditor::emptyMaterialImage)
-      {
-         %imgAsset = %mat.getMacroMapAsset();
-         if(%imgAsset $= "")
-            %imgAsset = %imgPath;
-         %this-->macroMapAssetId.setText( %imgAsset );
-      }
-      else
-      {
-         %this-->macroMapAssetId.setText( "None" );  
-      }      
+      %imgPathText = %imgPath !$= "" && %imgPath !$= $TerrainMaterialEditor::emptyMaterialImage ? %mat.getMacroMapAsset() : "None";
+      %this-->macroMapAssetId.setText( %imgPathText );
+      %this-->texMacroMap.setBitmap( getAssetPreviewImage(%imgPath) );
       
+      //
       %this-->detSizeCtrl.setText( %mat.detailSize );
       %this-->baseSizeCtrl.setText( %mat.diffuseSize );
       %this-->detStrengthCtrl.setText( %mat.detailStrength );

From 6474413aaf3a718cc9efe3779c6c444d63f102f1 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Tue, 16 Nov 2021 12:40:22 -0600
Subject: [PATCH 255/399] fix reported ASAN crash

---
 Engine/source/postFx/postEffect.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Engine/source/postFx/postEffect.cpp b/Engine/source/postFx/postEffect.cpp
index ca6baeb89..94b0ce7dc 100644
--- a/Engine/source/postFx/postEffect.cpp
+++ b/Engine/source/postFx/postEffect.cpp
@@ -1644,7 +1644,7 @@ void PostEffect::setTexture( U32 index, const String &texFilePath )
 void PostEffect::setTexture(U32 index, const GFXTexHandle& texHandle)
 {
    // Set the new texture name.
-   mTextureName[index] = "";
+   mTextureName[index] = StringTable->EmptyString();
    mTexture[index].free();
 
    // Skip empty stages or ones with variable or target names.

From 2e0310885675adbbcdf9b8b3315dea27a253ce9b Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Tue, 16 Nov 2021 23:56:52 -0500
Subject: [PATCH 256/399] Optionally allow to treat script assert as warning

This commit allows us to treat variable use before assign errors and local variables inside of the global scope as warnings instead of asserts. This will allow for easier porting of legacy scripts. It is highly recommended use this as an aid to port scripts, but can be used in production if needbe.
---
 Engine/source/console/astNodes.cpp     | 10 ++++--
 Engine/source/console/codeBlock.cpp    |  6 ++--
 Engine/source/console/compiledEval.cpp |  3 +-
 Engine/source/console/compiler.cpp     | 47 +++++++++++++++++++++++---
 Engine/source/console/compiler.h       |  2 ++
 Engine/source/console/console.cpp      |  4 ++-
 6 files changed, 60 insertions(+), 12 deletions(-)

diff --git a/Engine/source/console/astNodes.cpp b/Engine/source/console/astNodes.cpp
index c34c4b38d..0c69fbc5c 100644
--- a/Engine/source/console/astNodes.cpp
+++ b/Engine/source/console/astNodes.cpp
@@ -57,11 +57,16 @@ namespace Compiler
 using namespace Compiler;
 
 FuncVars gEvalFuncVars;
+FuncVars gGlobalScopeFuncVars;
 FuncVars* gFuncVars = NULL;
 
 inline FuncVars* getFuncVars(S32 lineNumber)
 {
-   AssertISV(gFuncVars, avar("Attemping to use local variable in global scope. File: %s Line: %d", CodeBlock::smCurrentParser->getCurrentFile(), lineNumber));
+   if (gFuncVars == &gGlobalScopeFuncVars)
+   {
+      const char* str = avar("Attemping to use local variable in global scope. File: %s Line: %d", CodeBlock::smCurrentParser->getCurrentFile(), lineNumber);
+      scriptErrorHandler(str);
+   }
    return gFuncVars;
 }
 
@@ -1552,8 +1557,7 @@ U32 FunctionDeclStmtNode::compileStmt(CodeStream& codeStream, U32 ip)
       tbl->add(fnName, nameSpace, varName);
    }
 
-   // In eval mode, global func vars are allowed.
-   gFuncVars = gIsEvalCompile ? &gEvalFuncVars : NULL;
+   gFuncVars = gIsEvalCompile ? &gEvalFuncVars : &gGlobalScopeFuncVars;
 
    return ip;
 }
diff --git a/Engine/source/console/codeBlock.cpp b/Engine/source/console/codeBlock.cpp
index f03ec25f6..46b40d441 100644
--- a/Engine/source/console/codeBlock.cpp
+++ b/Engine/source/console/codeBlock.cpp
@@ -38,6 +38,7 @@ CodeBlock *    CodeBlock::smCurrentCodeBlock = NULL;
 ConsoleParser *CodeBlock::smCurrentParser = NULL;
 
 extern FuncVars gEvalFuncVars;
+extern FuncVars gGlobalScopeFuncVars;
 extern FuncVars* gFuncVars;
 
 //-------------------------------------------------------------------------
@@ -637,8 +638,7 @@ ConsoleValue CodeBlock::compileExec(StringTableEntry fileName, const char *inStr
    
    // we are an eval compile if we don't have a file name associated (no exec)
    gIsEvalCompile = fileName == NULL;
-   // In eval mode, global func vars are allowed.
-   gFuncVars = gIsEvalCompile ? &gEvalFuncVars : NULL;
+   gFuncVars = gIsEvalCompile ? &gEvalFuncVars : &gGlobalScopeFuncVars;
 
    // Set up the parser.
    smCurrentParser = getParserForFile(fileName);
@@ -678,7 +678,7 @@ ConsoleValue CodeBlock::compileExec(StringTableEntry fileName, const char *inStr
    codeStream.emit(OP_RETURN_VOID);
    codeStream.emitCodeStream(&codeSize, &code, &lineBreakPairs);
    
-   S32 localRegisterCount = gIsEvalCompile ? gEvalFuncVars.count() : 0;
+   S32 localRegisterCount = gIsEvalCompile ? gEvalFuncVars.count() : gGlobalScopeFuncVars.count();
 
    consoleAllocReset();
 
diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index e9862c7ee..126cf4b01 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -691,7 +691,8 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          setFrame = -1;
 
       // Do we want this code to execute using a new stack frame?
-      if (setFrame < 0)
+      // compiling a file will force setFrame to 0, forcing us to get a new frame.
+      if (setFrame <= 0)
       {
          // argc is the local count for eval
          gEvalState.pushFrame(NULL, NULL, argc);
diff --git a/Engine/source/console/compiler.cpp b/Engine/source/console/compiler.cpp
index 13839feda..f898b8984 100644
--- a/Engine/source/console/compiler.cpp
+++ b/Engine/source/console/compiler.cpp
@@ -35,6 +35,13 @@
 #include "console/simBase.h"
 
 extern FuncVars gEvalFuncVars;
+extern FuncVars gGlobalScopeFuncVars;
+extern FuncVars *gFuncVars;
+
+namespace Con
+{
+extern bool scriptWarningsAsAsserts;
+};
 
 namespace Compiler
 {
@@ -124,12 +131,24 @@ namespace Compiler
       getFunctionStringTable().reset();
       getIdentTable().reset();
       getFunctionVariableMappingTable().reset();
-      gEvalFuncVars.clear();
+      gGlobalScopeFuncVars.clear();
+      gFuncVars = gIsEvalCompile ? &gEvalFuncVars : &gGlobalScopeFuncVars;
    }
 
    void *consoleAlloc(U32 size) { return gConsoleAllocator.alloc(size); }
    void consoleAllocReset() { gConsoleAllocator.freeBlocks(); }
 
+   void scriptErrorHandler(const char* str)
+   {
+      if (Con::scriptWarningsAsAsserts)
+      {
+         AssertISV(false, str);
+      }
+      else
+      {
+         Con::warnf(ConsoleLogEntry::Type::Script, "%s", str);
+      }
+   }
 }
 
 //-------------------------------------------------------------------------
@@ -141,7 +160,11 @@ S32 FuncVars::assign(StringTableEntry var, TypeReq currentType, S32 lineNumber,
    std::unordered_map<StringTableEntry, Var>::iterator found = vars.find(var);
    if (found != vars.end())
    {
-      AssertISV(!found->second.isConstant, avar("Reassigning variable %s when it is a constant. File: %s Line : %d", var, CodeBlock::smCurrentParser->getCurrentFile(), lineNumber));
+      if (found->second.isConstant)
+      {
+         const char* str = avar("Script Warning: Reassigning variable %s when it is a constant. File: %s Line : %d", var, CodeBlock::smCurrentParser->getCurrentFile(), lineNumber);
+         scriptErrorHandler(str);
+      }
       return found->second.reg;
    }
 
@@ -155,7 +178,15 @@ S32 FuncVars::assign(StringTableEntry var, TypeReq currentType, S32 lineNumber,
 S32 FuncVars::lookup(StringTableEntry var, S32 lineNumber)
 {
    std::unordered_map<StringTableEntry, Var>::iterator found = vars.find(var);
-   AssertISV(found != vars.end(), avar("Variable %s referenced before used when compiling script. File: %s Line: %d", var, CodeBlock::smCurrentParser->getCurrentFile(), lineNumber));
+   
+   if (found == vars.end())
+   {
+      const char* str = avar("Script Warning: Variable %s referenced before used when compiling script. File: %s Line: %d", var, CodeBlock::smCurrentParser->getCurrentFile(), lineNumber);
+      scriptErrorHandler(str);
+      
+      return assign(var, TypeReqString, lineNumber, false);
+   }
+   
    return found->second.reg;
 }
 
@@ -163,7 +194,15 @@ TypeReq FuncVars::lookupType(StringTableEntry var, S32 lineNumber)
 {
    std::unordered_map<StringTableEntry, Var>::iterator found = vars.find(var);
 
-   AssertISV(found != vars.end(), avar("Variable %s referenced before used when compiling script. File: %s Line: %d", var, CodeBlock::smCurrentParser->getCurrentFile(), lineNumber));
+   if (found == vars.end())
+   {
+      const char* str = avar("Script Warning: Variable %s referenced before used when compiling script. File: %s Line: %d", var, CodeBlock::smCurrentParser->getCurrentFile(), lineNumber);
+      scriptErrorHandler(str);
+      
+      assign(var, TypeReqString, lineNumber, false);
+      return vars.find(var)->second.currentType;
+   }
+   
    return found->second.currentType;
 }
 
diff --git a/Engine/source/console/compiler.h b/Engine/source/console/compiler.h
index 24067257f..612923939 100644
--- a/Engine/source/console/compiler.h
+++ b/Engine/source/console/compiler.h
@@ -275,6 +275,8 @@ namespace Compiler
    void *consoleAlloc(U32 size);
    void consoleAllocReset();
 
+   void scriptErrorHandler(const char* str);
+
    extern bool gSyntaxError;
    extern bool gIsEvalCompile;
 };
diff --git a/Engine/source/console/console.cpp b/Engine/source/console/console.cpp
index 14e75f0f8..59fca1874 100644
--- a/Engine/source/console/console.cpp
+++ b/Engine/source/console/console.cpp
@@ -274,6 +274,7 @@ static Vector< String > sInstantGroupStack( __FILE__, __LINE__ );
 static DataChunker consoleLogChunker;
 static Vector<ConsoleLogEntry> consoleLog(__FILE__, __LINE__);
 static bool consoleLogLocked;
+bool scriptWarningsAsAsserts = true;
 static bool logBufferEnabled=true;
 static S32 printLevel = 10;
 static FileStream consoleLogFile;
@@ -353,7 +354,7 @@ void init()
    ConsoleConstructor::setup();
 
    // Set up the parser(s)
-   CON_ADD_PARSER(CMD, TORQUE_SCRIPT_EXTENSION,   true);   // TorqueScript
+   CON_ADD_PARSER(CMD, (char*)TORQUE_SCRIPT_EXTENSION, true);   // TorqueScript
 
    // Setup the console types.
    ConsoleBaseType::initialize();
@@ -377,6 +378,7 @@ void init()
    addVariable("Con::objectCopyFailures", TypeS32, &gObjectCopyFailures, "If greater than zero then it counts the number of object creation "
       "failures based on a missing copy object and does not report an error..\n"
       "@ingroup Console\n");
+   addVariable("Con::scriptWarningsAsAsserts", TypeBool, &scriptWarningsAsAsserts, "If true, script warnings (outside of syntax errors) will be treated as fatal asserts.");
 
    // Current script file name and root
    addVariable( "Con::File", TypeString, &gCurrentFile, "The currently executing script file.\n"

From d1fde1f54bde62d154cbc0a87a7e231890acbe16 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Wed, 17 Nov 2021 21:58:17 -0500
Subject: [PATCH 257/399] * Cleanup: Fully remove the DisplayPtrManager class
 as it was not actually being used by anything.

---
 Engine/source/platformPOSIX/POSIXState.h | 94 +-----------------------
 1 file changed, 1 insertion(+), 93 deletions(-)

diff --git a/Engine/source/platformPOSIX/POSIXState.h b/Engine/source/platformPOSIX/POSIXState.h
index dec62b2ee..4aaa2fa43 100644
--- a/Engine/source/platformPOSIX/POSIXState.h
+++ b/Engine/source/platformPOSIX/POSIXState.h
@@ -33,12 +33,8 @@
 
 typedef void (*LockFunc_t)(void);
 
-class DisplayPtrManager;
-
 class x86UNIXPlatformState
 {
-      friend class DisplayPtrManager;
-
    private:
       Point2I              mDesktopSize;
       Point2I              mWindowSize;
@@ -170,92 +166,4 @@ class x86UNIXPlatformState
       }
 };
 
-extern x86UNIXPlatformState  * x86UNIXState;
-
-class DisplayPtrManager
-{
-      // static interface
-   private:
-      static bool sgDisplayLocked;
-      static LockFunc_t sgLockFunc;
-      static LockFunc_t sgUnlockFunc;
-
-      static bool lockDisplay() 
-      { 
-         if (!sgDisplayLocked && sgLockFunc) 
-         {
-            sgLockFunc(); 
-            sgDisplayLocked = true;
-            return true;
-         }
-         else 
-            return false;
-      }
-      static void unlockDisplay() 
-      {
-         if (sgDisplayLocked && sgUnlockFunc) 
-         {
-            sgUnlockFunc();
-            sgDisplayLocked = false;
-         }
-      }
-
-      //friend Display* x86UNIXPlatformState::getDisplayPointer();
-     
-   public:
-      static void setDisplayLockFunction(LockFunc_t lockFunc) 
-          { sgLockFunc = lockFunc; }
-      static void setDisplayUnlockFunction(LockFunc_t unlockFunc) 
-          { sgUnlockFunc = unlockFunc; }
-
-      // nonstatic interface
-   private:
-      bool mAcquiredLock; // true if this instance acquired the display lock
-      // (multiple instances of DisplayPtrManager can coexist, but only 
-      // the first to access the display pointer will be responsible for 
-      // acquiring and releasing the lock)
-      bool mOpenedDisplay; // true if this instance created a display pointer
-      // because the one in platform state was null.
-      Display* mDisplay;
-
-   private:
-      Display* openDisplay()
-      {
-         return mDisplay;
-      }
-
-      void closeDisplay()
-      {
-         if (mOpenedDisplay)
-         {
-
-         }
-      }
-   public:
-      DisplayPtrManager() 
-      {
-         mAcquiredLock = false;
-         mOpenedDisplay = false;
-         mDisplay = NULL;
-      }
-
-      ~DisplayPtrManager()
-      {
-         if (mAcquiredLock)
-         {
-            DisplayPtrManager::unlockDisplay();
-            mAcquiredLock = false;
-         }
-         closeDisplay();
-      }
-
-      Display* getDisplayPointer()
-      {
-         Display* display = x86UNIXState->getDisplayPointer();
-         if (display == NULL)
-            return openDisplay();
-
-         mAcquiredLock = DisplayPtrManager::lockDisplay();
-         return display;
-      }
-};
+extern x86UNIXPlatformState  * x86UNIXState;
\ No newline at end of file

From 88cfa4533b77bc5d9e78b382272d7a13bdf978df Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Wed, 17 Nov 2021 22:08:08 -0500
Subject: [PATCH 258/399] * Cleanup: Remove a comment referencing the
 now-removed DisplayPtrManager.

---
 Engine/source/platformPOSIX/POSIXState.h | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/Engine/source/platformPOSIX/POSIXState.h b/Engine/source/platformPOSIX/POSIXState.h
index 4aaa2fa43..381379495 100644
--- a/Engine/source/platformPOSIX/POSIXState.h
+++ b/Engine/source/platformPOSIX/POSIXState.h
@@ -54,13 +54,7 @@ class x86UNIXPlatformState
       bool                 mCDAudioEnabled;
       bool                 mDSleep;
       bool                 mUseRedirect;
-
-      // Access to the display* needs to be controlled because the SDL event
-      // loop runs in a separate thread.  If you need the display pointer,
-      // use the DisplayPtrManager class.  See the clipboard functions in 
-      // x86unixinput.cc for an example.
-      //Display *getDisplayPointer() { return mDisplay; }
-
+      
    public:
       U32      currentTime;
 

From 04b0883a3141241f6ddb4508eae25b34a173e6b7 Mon Sep 17 00:00:00 2001
From: Areloch <Areloch@gmail.com>
Date: Fri, 19 Nov 2021 23:14:06 -0600
Subject: [PATCH 259/399] Assimp checks against lowercase extensions, so we
 force the extension of the file to lower before fetching the importer. Also
 adds sanity check that the importer was actually found before we try and use
 it.

---
 Engine/source/ts/assimp/assimpShapeLoader.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/Engine/source/ts/assimp/assimpShapeLoader.cpp b/Engine/source/ts/assimp/assimpShapeLoader.cpp
index f0dbd509e..0ffa6bd11 100644
--- a/Engine/source/ts/assimp/assimpShapeLoader.cpp
+++ b/Engine/source/ts/assimp/assimpShapeLoader.cpp
@@ -178,8 +178,9 @@ void AssimpShapeLoader::enumerateScene()
       // Setup default units for shape format
       String importFormat;
 
-      const aiImporterDesc* importerDescription = aiGetImporterDesc(shapePath.getExtension().c_str());
-      if (StringTable->insert(importerDescription->mName) == StringTable->insert("Autodesk FBX Importer"))
+      String fileExt = String::ToLower(shapePath.getExtension());
+      const aiImporterDesc* importerDescription = aiGetImporterDesc(fileExt.c_str());
+      if (importerDescription && StringTable->insert(importerDescription->mName) == StringTable->insert("Autodesk FBX Importer"))
       {
          ColladaUtils::getOptions().formatScaleFactor = 0.01f;
       }

From 7ac62f42a370c342a29475990798b7db129146da Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Sat, 20 Nov 2021 19:07:48 -0500
Subject: [PATCH 260/399] Fixed a leak with console stack in the interpreter.

Issue was pushing a new frame in the global scope. Everytime a global scope was called, 1 ConsoleValue got allocated that was never freed. After 4096 'global scope' function calls, the engine would blow. Also cleans up an extra rogue usage of push/pop with the saver helper.
---
 Engine/source/console/compiledEval.cpp | 1 -
 Engine/source/console/console.cpp      | 4 ++--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index 126cf4b01..0b2e66b4b 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -696,7 +696,6 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
       {
          // argc is the local count for eval
          gEvalState.pushFrame(NULL, NULL, argc);
-         gCallStack.pushFrame(0);
          popFrame = true;
       }
       else
diff --git a/Engine/source/console/console.cpp b/Engine/source/console/console.cpp
index 59fca1874..d9ba1dcff 100644
--- a/Engine/source/console/console.cpp
+++ b/Engine/source/console/console.cpp
@@ -1628,9 +1628,9 @@ static ConsoleValue _internalExecute(SimObject *object, S32 argc, ConsoleValue a
       ICallMethod *com = dynamic_cast<ICallMethod *>(object);
       if(com)
       {
-         gCallStack.pushFrame(0);
+         ConsoleStackFrameSaver saver;
+         saver.save();
          com->callMethodArgList(argc, argv, false);
-         gCallStack.popFrame();
       }
    }
 

From 05278654624265669156201f342215245c736757 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Sun, 21 Nov 2021 14:28:51 -0600
Subject: [PATCH 261/399] set cubemapsaver profile to one that preserves sizes
 also aug size mismatches for the popup so they're reported

---
 Engine/source/gfx/D3D11/gfxD3D11TextureObject.cpp | 4 ++--
 Engine/source/gfx/bitmap/cubemapSaver.cpp         | 2 +-
 Engine/source/gfx/gl/gfxGLTextureObject.cpp       | 4 ++--
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Engine/source/gfx/D3D11/gfxD3D11TextureObject.cpp b/Engine/source/gfx/D3D11/gfxD3D11TextureObject.cpp
index 4cb555558..24af3e0ae 100644
--- a/Engine/source/gfx/D3D11/gfxD3D11TextureObject.cpp
+++ b/Engine/source/gfx/D3D11/gfxD3D11TextureObject.cpp
@@ -198,8 +198,8 @@ bool GFXD3D11TextureObject::copyToBmp(GBitmap* bmp)
 
    PROFILE_START(GFXD3D11TextureObject_copyToBmp);
 
-   AssertFatal(bmp->getWidth() == getWidth(), "GFXD3D11TextureObject::copyToBmp - source/dest width does not match");
-   AssertFatal(bmp->getHeight() == getHeight(), "GFXD3D11TextureObject::copyToBmp - source/dest height does not match");
+   AssertFatal(bmp->getWidth() == getWidth(), avar("GFXGLTextureObject::copyToBmp - Width mismatch: %i vs %i", bmp->getWidth(), getWidth()));
+   AssertFatal(bmp->getHeight() == getHeight(), avar("GFXGLTextureObject::copyToBmp - Height mismatch: %i vs %i", bmp->getHeight(), getHeight()));
    const U32 mipLevels = getMipLevels();
 
    bmp->setHasTransparency(mHasTransparency);
diff --git a/Engine/source/gfx/bitmap/cubemapSaver.cpp b/Engine/source/gfx/bitmap/cubemapSaver.cpp
index a27dd323f..734fe19cc 100644
--- a/Engine/source/gfx/bitmap/cubemapSaver.cpp
+++ b/Engine/source/gfx/bitmap/cubemapSaver.cpp
@@ -56,7 +56,7 @@ namespace CubemapSaver
       for (U32 face = 0; face < CubeFaces; face++)
       {
          pTextures[face].set(faceSize, faceSize, targetFmt,
-            &GFXStaticTextureProfile, avar("%s() - (line %d)", __FUNCTION__, __LINE__),
+            &GFXTexturePersistentProfile, avar("%s() - (line %d)", __FUNCTION__, __LINE__),
             mipLevels, GFXTextureManager::AA_MATCH_BACKBUFFER);
 
          // yep t3d has funky z up, need to change the face order
diff --git a/Engine/source/gfx/gl/gfxGLTextureObject.cpp b/Engine/source/gfx/gl/gfxGLTextureObject.cpp
index 1d5c043e4..e7dd88d4e 100644
--- a/Engine/source/gfx/gl/gfxGLTextureObject.cpp
+++ b/Engine/source/gfx/gl/gfxGLTextureObject.cpp
@@ -162,8 +162,8 @@ bool GFXGLTextureObject::copyToBmp(GBitmap * bmp)
    if (mFormat != GFXFormatR16G16B16A16F && mFormat != GFXFormatR8G8B8A8 && mFormat != GFXFormatR8G8B8A8_LINEAR_FORCE && mFormat != GFXFormatR8G8B8A8_SRGB)
 	   return false;
 
-   AssertFatal(bmp->getWidth() == getWidth(), "GFXGLTextureObject::copyToBmp - invalid size");
-   AssertFatal(bmp->getHeight() == getHeight(), "GFXGLTextureObject::copyToBmp - invalid size");
+   AssertFatal(bmp->getWidth() == getWidth(), avar("GFXGLTextureObject::copyToBmp - Width mismatch: %i vs %i", bmp->getWidth(), getWidth()));
+   AssertFatal(bmp->getHeight() == getHeight(), avar("GFXGLTextureObject::copyToBmp - Height mismatch: %i vs %i", bmp->getHeight(), getHeight()));
 
    PROFILE_SCOPE(GFXGLTextureObject_copyToBmp);
 

From d58cf398a92553ea7445e3b1e74d05d63c6eec4e Mon Sep 17 00:00:00 2001
From: rextimmy <rextimm777@gmail.com>
Date: Mon, 22 Nov 2021 12:30:08 +1000
Subject: [PATCH 262/399] make use of folder properties in cmake

---
 CMakeLists.txt             |  2 ++
 Tools/CMake/basics.cmake   |  3 +++
 Tools/CMake/torque3d.cmake | 17 +++++++++++++++++
 3 files changed, 22 insertions(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index c1b20657a..682d5db70 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,5 +1,7 @@
 cmake_minimum_required (VERSION 3.10.2)
 
+set_property(GLOBAL PROPERTY USE_FOLDERS TRUE)
+set(TORQUE_LIBS_FOLDER_NAME "Libs" CACHE STRING "The solution folder name to place all libs under")
 set(TORQUE_APP_NAME "" CACHE STRING "the app name")
 
 set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/temp" CACHE PATH "default install path" FORCE )
diff --git a/Tools/CMake/basics.cmake b/Tools/CMake/basics.cmake
index 9a88a9d82..e8b023a9b 100644
--- a/Tools/CMake/basics.cmake
+++ b/Tools/CMake/basics.cmake
@@ -340,6 +340,9 @@ macro(finishLibrary)
     #endforeach()
 
     _postTargetProcess()
+
+    #set the folder property name
+    set_target_properties(${PROJECT_NAME} PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
 endmacro()
 
 # macro to add an executable
diff --git a/Tools/CMake/torque3d.cmake b/Tools/CMake/torque3d.cmake
index 759e64f01..1d7e3ef1a 100644
--- a/Tools/CMake/torque3d.cmake
+++ b/Tools/CMake/torque3d.cmake
@@ -969,3 +969,20 @@ if(TORQUE_TEMPLATE)
         INSTALL(FILES "${CMAKE_SOURCE_DIR}/Templates/${TORQUE_TEMPLATE}/DeletePrefs.bat"      DESTINATION "${TORQUE_APP_DIR}")
     endif()
 endif()
+
+###############################################################################
+# Properties folder
+###############################################################################
+# we only need to add libs that we add via add_subdirectory command, basics.cmake
+# will take care of the other source libs added via addLib 
+
+if(TORQUE_SFX_OPENAL AND WIN32)
+    set_target_properties(OpenAL PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
+     #why is openal adding these two?
+    set_target_properties(common PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
+    set_target_properties(ex-common PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
+endif()
+
+if(TORQUE_SDL)
+    set_target_properties(SDL2 PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
+endif()
\ No newline at end of file

From ba7082bea17373a78c1342c1b0b0dd3912e220ad Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Tue, 23 Nov 2021 10:32:49 -0500
Subject: [PATCH 263/399] * BugFix: Correct the inability to build on MacOS due
 to differing target names on MacOS.

---
 Tools/CMake/torque3d.cmake | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/Tools/CMake/torque3d.cmake b/Tools/CMake/torque3d.cmake
index 1d7e3ef1a..b3006d965 100644
--- a/Tools/CMake/torque3d.cmake
+++ b/Tools/CMake/torque3d.cmake
@@ -984,5 +984,11 @@ if(TORQUE_SFX_OPENAL AND WIN32)
 endif()
 
 if(TORQUE_SDL)
-    set_target_properties(SDL2 PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
+    # Apple config has slightly different target names
+    if (APPLE)
+        set_target_properties(SDL2main PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
+        set_target_properties(SDL2-static PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
+    else()
+        set_target_properties(SDL2 PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
+    endif()
 endif()
\ No newline at end of file

From f1a48df6763dc61c962d1fcf26d3d5abb8266622 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Wed, 24 Nov 2021 09:16:09 -0500
Subject: [PATCH 264/399] * [GuiInspectorField] BugFix: Correct data corruption
 potential caused by casting the result of Con::evaluatef directly to a const
 char.

---
 Engine/source/gui/editor/inspector/field.cpp | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/Engine/source/gui/editor/inspector/field.cpp b/Engine/source/gui/editor/inspector/field.cpp
index 6ee578512..75d219730 100644
--- a/Engine/source/gui/editor/inspector/field.cpp
+++ b/Engine/source/gui/editor/inspector/field.cpp
@@ -318,7 +318,8 @@ void GuiInspectorField::setData( const char* data, bool callbacks )
          {
             char buffer[ 2048 ];
             expandEscape( buffer, newValue );
-            newValue = (const char*)Con::evaluatef( "$f = \"%s\"; return ( %s );", oldValue.c_str(), buffer );
+            ConsoleValue result = Con::evaluatef("$f = \"%s\"; return ( %s );", oldValue.c_str(), buffer);
+            newValue = result.getString();
             Con::evaluatef("$f=0;");
          }
          else if(    type == TypeS32Vector
@@ -354,13 +355,13 @@ void GuiInspectorField::setData( const char* data, bool callbacks )
                char buffer[ 2048 ];
                expandEscape( buffer, newComponentExpr );
 
-               const char* newComponentVal = Con::evaluatef( "$f = \"%s\"; $v = \"%s\"; return ( %s );",
-                  oldComponentVal, oldValue.c_str(), buffer );
+               ConsoleValue result = Con::evaluatef("$f = \"%s\"; $v = \"%s\"; return ( %s );",
+                  oldComponentVal, oldValue.c_str(), buffer);
                Con::evaluatef("$f=0;$v=0;");
 
                if( !isFirst )
                   strNew.append( ' ' );
-               strNew.append( newComponentVal );
+               strNew.append( result.getString() );
                
                isFirst = false;
             }

From 4dea3810b99f2ff48b5f1204a0560a0567f6b530 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Wed, 24 Nov 2021 13:46:18 -0500
Subject: [PATCH 265/399] * [SFXDescription] BugFix: Correct a data corruption
 issue in converting legacy channel values.

---
 Engine/source/sfx/sfxDescription.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Engine/source/sfx/sfxDescription.cpp b/Engine/source/sfx/sfxDescription.cpp
index 143e0a31e..8cd93b6b2 100644
--- a/Engine/source/sfx/sfxDescription.cpp
+++ b/Engine/source/sfx/sfxDescription.cpp
@@ -454,7 +454,8 @@ bool SFXDescription::onAdd()
    const char* channelValue = getDataField( sChannel, NULL );
    if( channelValue && channelValue[ 0 ] )
    {
-      const char* group = Con::evaluatef( "return sfxOldChannelToGroup( %s );", channelValue );
+      ConsoleValue result = Con::evaluatef( "return sfxOldChannelToGroup( %s );", channelValue );
+      const char* group = result.getString();
       if( !Sim::findObject( group, mSourceGroup ) )
          Con::errorf( "SFXDescription::onAdd - could not resolve channel '%s' to SFXSource", channelValue );
    }

From 41e5988c4608cb3d957709ce9a606d2387d803aa Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Wed, 24 Nov 2021 14:14:24 -0500
Subject: [PATCH 266/399] * BugFix: Correct a scoping error with ConsoleValue
 in the updated code in GuiInspectorField.

---
 Engine/source/gui/editor/inspector/field.cpp | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/Engine/source/gui/editor/inspector/field.cpp b/Engine/source/gui/editor/inspector/field.cpp
index 75d219730..752ba61d2 100644
--- a/Engine/source/gui/editor/inspector/field.cpp
+++ b/Engine/source/gui/editor/inspector/field.cpp
@@ -314,12 +314,13 @@ void GuiInspectorField::setData( const char* data, bool callbacks )
          
          String newValue = strData;
          S32 type= mField->type;
+         ConsoleValue evaluationResult;
          if( type == TypeS8 || type == TypeS32 || type == TypeF32 )
          {
             char buffer[ 2048 ];
             expandEscape( buffer, newValue );
-            ConsoleValue result = Con::evaluatef("$f = \"%s\"; return ( %s );", oldValue.c_str(), buffer);
-            newValue = result.getString();
+            evaluationResult = Con::evaluatef("$f = \"%s\"; return ( %s );", oldValue.c_str(), buffer);
+            newValue = evaluationResult.getString();
             Con::evaluatef("$f=0;");
          }
          else if(    type == TypeS32Vector
@@ -355,13 +356,13 @@ void GuiInspectorField::setData( const char* data, bool callbacks )
                char buffer[ 2048 ];
                expandEscape( buffer, newComponentExpr );
 
-               ConsoleValue result = Con::evaluatef("$f = \"%s\"; $v = \"%s\"; return ( %s );",
+               evaluationResult = Con::evaluatef("$f = \"%s\"; $v = \"%s\"; return ( %s );",
                   oldComponentVal, oldValue.c_str(), buffer);
                Con::evaluatef("$f=0;$v=0;");
 
                if( !isFirst )
                   strNew.append( ' ' );
-               strNew.append( result.getString() );
+               strNew.append( evaluationResult.getString() );
                
                isFirst = false;
             }

From 1816b3ca0cd11756e190c3352bcb762ccc840035 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Thu, 25 Nov 2021 19:39:44 -0600
Subject: [PATCH 267/399] modular source work from @marauder2k7: augments the
 modular inclusion of sourcefiles via confining it to /source/ directories
 only to prevent strays. additionally, adds a /lib/ filter for full on library
 inclusion

---
 Tools/CMake/basics.cmake   | 14 +++++++++++++
 Tools/CMake/torque3d.cmake | 43 +++++++++++++-------------------------
 2 files changed, 29 insertions(+), 28 deletions(-)

diff --git a/Tools/CMake/basics.cmake b/Tools/CMake/basics.cmake
index e8b023a9b..83e9e1952 100644
--- a/Tools/CMake/basics.cmake
+++ b/Tools/CMake/basics.cmake
@@ -104,6 +104,20 @@ macro(addPathRec dir)
     addPath("${dir}" "REC")
 endmacro()
 
+###############################################################################
+###  Gameplay Modules Lib Check
+###############################################################################
+macro(subDirCmake result curdir)
+	file(GLOB children RELATIVE ${curdir} ${curdir}/*)
+	set(dirList "")
+	foreach(child ${children})
+		if(IS_DIRECTORY ${curdir}/${child})
+			LIST(APPEND dirList ${curdir}/${child})
+		endif()
+	endforeach()
+	set(${result} ${dirList})
+endmacro()
+
 ###############################################################################
 ### Definition Handling
 ###############################################################################
diff --git a/Tools/CMake/torque3d.cmake b/Tools/CMake/torque3d.cmake
index b3006d965..e49ccefe0 100644
--- a/Tools/CMake/torque3d.cmake
+++ b/Tools/CMake/torque3d.cmake
@@ -80,7 +80,7 @@ if(WIN32)
     set(ALSOFT_INSTALL_HRTF_DATA OFF CACHE BOOL "Install HRTF definition files" FORCE)
     set(ALSOFT_INSTALL_AMBDEC_PRESETS OFF CACHE BOOL "Install AmbDec presets" FORCE)
     set(ALSOFT_EMBED_HRTF_DATA OFF CACHE BOOL "Embed the HRTF data (increases library footprint)" FORCE)
-
+    
     add_subdirectory( ${libDir}/openal-soft ${CMAKE_CURRENT_BINARY_DIR}/openal-soft)
 endif()
 
@@ -241,7 +241,7 @@ if(WIN32)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -wd4018")
     # warning C4244: 'initializing' : conversion from 'XXX' to 'XXX', possible loss of data
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -wd4244")
-	if(TORQUE_SFX_DirectX)
+	if(TORQUE_SFX_DirectX) 
 		if( TORQUE_CPU_X64 )
 			link_directories($ENV{DXSDK_DIR}/Lib/x64)
 		else()
@@ -384,10 +384,20 @@ addPathRec("${projectSrcDir}")
 # Load module-based files
 if(EXISTS ${TORQUE_APP_DIR}/game/data)
     message("Reading modules in ${TORQUE_APP_DIR}/game/data path...")
-
-    addInclude("${TORQUE_APP_DIR}/game/data")
-    addPathRec("${TORQUE_APP_DIR}/game/data")
+	
+	subDirCmake(MODULEDIRS ${TORQUE_APP_DIR}/game/data)
+	foreach(modDir ${MODULEDIRS})
+		addInclude("${modDir}/source")
+		addPathRec("${modDir}/source")
+		file(GLOB modules "${modDir}/lib/*.cmake")
+		foreach(module ${modules})
+			set(moduleLibDir "${modDir}/lib")
+			include(${module})
+		endforeach()
+		
+	endforeach()
 endif()
+
 if(EXISTS ${TORQUE_APP_DIR}/game/tools)
     message("Reading modules in ${TORQUE_APP_DIR}/game/tools path...")
 
@@ -969,26 +979,3 @@ if(TORQUE_TEMPLATE)
         INSTALL(FILES "${CMAKE_SOURCE_DIR}/Templates/${TORQUE_TEMPLATE}/DeletePrefs.bat"      DESTINATION "${TORQUE_APP_DIR}")
     endif()
 endif()
-
-###############################################################################
-# Properties folder
-###############################################################################
-# we only need to add libs that we add via add_subdirectory command, basics.cmake
-# will take care of the other source libs added via addLib 
-
-if(TORQUE_SFX_OPENAL AND WIN32)
-    set_target_properties(OpenAL PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
-     #why is openal adding these two?
-    set_target_properties(common PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
-    set_target_properties(ex-common PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
-endif()
-
-if(TORQUE_SDL)
-    # Apple config has slightly different target names
-    if (APPLE)
-        set_target_properties(SDL2main PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
-        set_target_properties(SDL2-static PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
-    else()
-        set_target_properties(SDL2 PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
-    endif()
-endif()
\ No newline at end of file

From 583014de6094d4e57e25c9702f45735f23f5003e Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Thu, 25 Nov 2021 19:49:56 -0600
Subject: [PATCH 268/399] fix erroneous clipout

---
 Tools/CMake/basics.cmake | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/Tools/CMake/basics.cmake b/Tools/CMake/basics.cmake
index 83e9e1952..ef6de9bea 100644
--- a/Tools/CMake/basics.cmake
+++ b/Tools/CMake/basics.cmake
@@ -496,3 +496,26 @@ if(MSVC)
         SET("CMAKE_RUNTIME_OUTPUT_DIRECTORY_${CONF}" "${projectOutDir}")
     ENDFOREACH()
 endif()
+
+###############################################################################
+# Properties folder
+###############################################################################
+# we only need to add libs that we add via add_subdirectory command, basics.cmake
+# will take care of the other source libs added via addLib 
+
+if(TORQUE_SFX_OPENAL AND WIN32)
+    set_target_properties(OpenAL PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
+     #why is openal adding these two?
+    set_target_properties(common PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
+    set_target_properties(ex-common PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
+endif()
+
+if(TORQUE_SDL)
+    # Apple config has slightly different target names
+    if (APPLE)
+        set_target_properties(SDL2main PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
+        set_target_properties(SDL2-static PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
+    else()
+        set_target_properties(SDL2 PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
+    endif()
+endif()
\ No newline at end of file

From 490b8271e862a54aee77f6af7f775a755189bb52 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Thu, 25 Nov 2021 19:51:34 -0600
Subject: [PATCH 269/399] fix erroneous clipout

---
 Tools/CMake/basics.cmake   | 23 -----------------------
 Tools/CMake/torque3d.cmake | 23 +++++++++++++++++++++++
 2 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/Tools/CMake/basics.cmake b/Tools/CMake/basics.cmake
index ef6de9bea..83e9e1952 100644
--- a/Tools/CMake/basics.cmake
+++ b/Tools/CMake/basics.cmake
@@ -496,26 +496,3 @@ if(MSVC)
         SET("CMAKE_RUNTIME_OUTPUT_DIRECTORY_${CONF}" "${projectOutDir}")
     ENDFOREACH()
 endif()
-
-###############################################################################
-# Properties folder
-###############################################################################
-# we only need to add libs that we add via add_subdirectory command, basics.cmake
-# will take care of the other source libs added via addLib 
-
-if(TORQUE_SFX_OPENAL AND WIN32)
-    set_target_properties(OpenAL PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
-     #why is openal adding these two?
-    set_target_properties(common PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
-    set_target_properties(ex-common PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
-endif()
-
-if(TORQUE_SDL)
-    # Apple config has slightly different target names
-    if (APPLE)
-        set_target_properties(SDL2main PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
-        set_target_properties(SDL2-static PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
-    else()
-        set_target_properties(SDL2 PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
-    endif()
-endif()
\ No newline at end of file
diff --git a/Tools/CMake/torque3d.cmake b/Tools/CMake/torque3d.cmake
index e49ccefe0..76c2af805 100644
--- a/Tools/CMake/torque3d.cmake
+++ b/Tools/CMake/torque3d.cmake
@@ -979,3 +979,26 @@ if(TORQUE_TEMPLATE)
         INSTALL(FILES "${CMAKE_SOURCE_DIR}/Templates/${TORQUE_TEMPLATE}/DeletePrefs.bat"      DESTINATION "${TORQUE_APP_DIR}")
     endif()
 endif()
+
+###############################################################################
+# Properties folder
+###############################################################################
+# we only need to add libs that we add via add_subdirectory command, basics.cmake
+# will take care of the other source libs added via addLib 
+
+if(TORQUE_SFX_OPENAL AND WIN32)
+    set_target_properties(OpenAL PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
+     #why is openal adding these two?
+    set_target_properties(common PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
+    set_target_properties(ex-common PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
+endif()
+
+if(TORQUE_SDL)
+    # Apple config has slightly different target names
+    if (APPLE)
+        set_target_properties(SDL2main PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
+        set_target_properties(SDL2-static PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
+    else()
+        set_target_properties(SDL2 PROPERTIES FOLDER ${TORQUE_LIBS_FOLDER_NAME})
+    endif()
+endif()
\ No newline at end of file

From a5944aff19bd99046993d7d2b7ce1cafc39b261e Mon Sep 17 00:00:00 2001
From: Areloch <Areloch@gmail.com>
Date: Fri, 26 Nov 2021 16:40:15 -0600
Subject: [PATCH 270/399] Adjusted callback handling of asset inspector fields
 when invoking AB to select asset for more consistent behavior and better
 handling of updating the objects and inspector Added logic to forcefully
 acquire newly imported asset definition to better try and ensure it's loaded
 immediately after import Added logic to asset importer so if a file is not
 found for an importing material asset, if populate maps is on, then it will
 try and find a matching image asset in the destination module Added logic to
 tsStatic to better handle fields being updated via the editor, forcing
 updates and refreshes of the shape and materialSlots Fixed handling of
 guiBitmapButtonCtrl so it will update the bitmap used when edited via the Gui
 Editor Updated image ref to the hudFill image asset for the console GUI
 Cleaned up names for the default camera model/material Defaulted import
 config to utilize the Prune action instead of rename for more predictable
 default behavior Added icons next to AB's preview slider bar for additional
 visual feedback of slider intent Added missing checkbox to asset import
 window and cleaned up scaling behavior Fixed handling of drag-n-drop behavior
 in GUI editor so it doesn't block further interaction Added logic for
 drag-n-drop of image assets to GUI Editor so it will create a GuiBitmapCtrl
 with the image Added handling for drag-n-drop import of folders of assets to
 AB/Asset Import Added missing asset import config option to indicate if
 config supported import of sound assets Added logic when opening asset import
 config editor, where if there is a default import config set in the settings,
 it will open that one by default Hid the collision section of the import
 config editor, as those options are currently unutilized Improved behavior
 for Create New Folder window in the AB, now always pushing to the front, and
 also selecting the text by default, so the user can just start typing the new
 name Also added return and escape key accelerators to Create New Folder
 window for better UX Fixed display of editor windows, adding a distinct blue
 color to highlighted windows' title bar and fixing display of
 minimize/maximize/window/close buttons Moved GUIEditor's onControlDropped
 function to the AB script to match placement of sibling world editor function
 Fixed issue with material editor where the ORM Config map slot was getting
 the normal map instead of the correct ORM map

---
 Engine/source/T3D/assets/CubemapAsset.cpp     |    2 +-
 Engine/source/T3D/assets/GUIAsset.cpp         |    2 +-
 Engine/source/T3D/assets/ImageAsset.cpp       |    6 +-
 Engine/source/T3D/assets/MaterialAsset.cpp    |    4 +-
 Engine/source/T3D/assets/ParticleAsset.cpp    |    2 +-
 Engine/source/T3D/assets/ShapeAsset.cpp       |    5 +-
 Engine/source/T3D/assets/TerrainAsset.cpp     |    2 +-
 .../T3D/assets/TerrainMaterialAsset.cpp       |    2 +-
 Engine/source/T3D/assets/assetImporter.cpp    |   62 +-
 .../source/T3D/assets/stateMachineAsset.cpp   |    2 +-
 Engine/source/T3D/tsStatic.cpp                |   11 +-
 .../gui/buttons/guiBitmapButtonCtrl.cpp       |   27 +-
 .../source/gui/buttons/guiBitmapButtonCtrl.h  |    5 +-
 .../game/core/console/guis/console.gui        |    2 +-
 .../core/console/scripts/profiles.tscript     |    4 +-
 .../core/gameObjects/shapes/Camera.asset.taml |    5 -
 .../core/gameObjects/shapes/Green.asset.taml  |    7 +
 .../gameObjects/{images => shapes}/camera.png |  Bin
 .../core/gameObjects/shapes/camera.tscript    |    2 +-
 .../camera_image.asset.taml                   |    0
 .../core/gameObjects/shapes/green.tscript     |  196 +++
 .../rendering/materials/moon_noglow.tscript   |    9 +
 .../rendering/materials/moon_wglow.tscript    |    9 +
 .../tools/assetBrowser/assetImportConfigs.xml |    1 +
 .../tools/assetBrowser/guis/assetBrowser.gui  |   34 +-
 .../tools/assetBrowser/guis/assetImport.gui   | 1055 +++++++++--------
 .../tools/assetBrowser/guis/newFolder.gui     |    4 +-
 .../assetBrowser/scripts/assetBrowser.tscript |   71 +-
 .../assetBrowser/scripts/assetImport.tscript  |   16 +-
 .../scripts/assetImportConfig.tscript         |    1 +
 .../scripts/assetImportConfigEditor.tscript   |    5 +-
 .../scripts/assetTypes/creatorObj.tscript     |    1 +
 .../scripts/assetTypes/folder.tscript         |    4 +-
 .../tools/gui/images/stencilIcons/larger.png  |  Bin 15389 -> 1544 bytes
 .../tools/gui/images/stencilIcons/smaller.png |  Bin 15374 -> 1565 bytes
 .../BaseGame/game/tools/gui/images/window.png |  Bin 6786 -> 7565 bytes
 .../guiEditor/scripts/guiEditor.ed.tscript    |   24 -
 .../scripts/materialEditor.ed.tscript         |    4 +-
 38 files changed, 979 insertions(+), 607 deletions(-)
 create mode 100644 Templates/BaseGame/game/core/gameObjects/shapes/Green.asset.taml
 rename Templates/BaseGame/game/core/gameObjects/{images => shapes}/camera.png (100%)
 rename Templates/BaseGame/game/core/gameObjects/{images => shapes}/camera_image.asset.taml (100%)
 create mode 100644 Templates/BaseGame/game/core/gameObjects/shapes/green.tscript
 create mode 100644 Templates/BaseGame/game/core/rendering/materials/moon_noglow.tscript
 create mode 100644 Templates/BaseGame/game/core/rendering/materials/moon_wglow.tscript

diff --git a/Engine/source/T3D/assets/CubemapAsset.cpp b/Engine/source/T3D/assets/CubemapAsset.cpp
index 8c132ea74..0ecb56f8d 100644
--- a/Engine/source/T3D/assets/CubemapAsset.cpp
+++ b/Engine/source/T3D/assets/CubemapAsset.cpp
@@ -199,7 +199,7 @@ GuiControl* GuiInspectorTypeCubemapAssetPtr::constructEditControl()
    // Change filespec
    char szBuffer[512];
    dSprintf(szBuffer, sizeof(szBuffer), "AssetBrowser.showDialog(\"CubemapAsset\", \"AssetBrowser.changeAsset\", %d, %s);",
-      mInspector->getInspectObject(), mCaption);
+      mInspector->getIdString(), mCaption);
    mBrowseButton->setField("Command", szBuffer);
 
    setDataField(StringTable->insert("object"), NULL, String::ToString(mInspector->getInspectObject()).c_str());
diff --git a/Engine/source/T3D/assets/GUIAsset.cpp b/Engine/source/T3D/assets/GUIAsset.cpp
index cacc3f9be..acef864db 100644
--- a/Engine/source/T3D/assets/GUIAsset.cpp
+++ b/Engine/source/T3D/assets/GUIAsset.cpp
@@ -257,7 +257,7 @@ GuiControl* GuiInspectorTypeGUIAssetPtr::constructEditControl()
    // Change filespec
    char szBuffer[512];
    dSprintf(szBuffer, sizeof(szBuffer), "AssetBrowser.showDialog(\"GUIAsset\", \"AssetBrowser.changeAsset\", %d, %s);",
-      mInspector->getComponentGroupTargetId(), mCaption);
+      mInspector->getIdString(), mCaption);
    mBrowseButton->setField("Command", szBuffer);
 
    // Create "Open in ShapeEditor" button
diff --git a/Engine/source/T3D/assets/ImageAsset.cpp b/Engine/source/T3D/assets/ImageAsset.cpp
index af55747ca..2c5f9f341 100644
--- a/Engine/source/T3D/assets/ImageAsset.cpp
+++ b/Engine/source/T3D/assets/ImageAsset.cpp
@@ -480,7 +480,7 @@ GuiControl* GuiInspectorTypeImageAssetPtr::constructEditControl()
    // Change filespec
    char szBuffer[512];
    dSprintf(szBuffer, sizeof(szBuffer), "AssetBrowser.showDialog(\"ImageAsset\", \"AssetBrowser.changeAsset\", %s, %s);",
-      mInspector->getInspectObject()->getIdString(), mCaption);
+      mInspector->getIdString(), mCaption);
    mBrowseButton->setField("Command", szBuffer);
 
    setDataField(StringTable->insert("targetObject"), NULL, mInspector->getInspectObject()->getIdString());
@@ -488,11 +488,9 @@ GuiControl* GuiInspectorTypeImageAssetPtr::constructEditControl()
    // Create "Open in ShapeEditor" button
    mImageEdButton = new GuiBitmapButtonCtrl();
 
-   dSprintf(szBuffer, sizeof(szBuffer), "ShapeEditorPlugin.openShapeAssetId(%d.getText());", retCtrl->getId());
-   mImageEdButton->setField("Command", szBuffer);
-
    char bitmapName[512] = "ToolsModule:GameTSCtrl_image";
    mImageEdButton->setBitmap(StringTable->insert(bitmapName));
+   mImageEdButton->setHidden(true);
 
    mImageEdButton->setDataField(StringTable->insert("Profile"), NULL, "GuiButtonProfile");
    mImageEdButton->setDataField(StringTable->insert("tooltipprofile"), NULL, "GuiToolTipProfile");
diff --git a/Engine/source/T3D/assets/MaterialAsset.cpp b/Engine/source/T3D/assets/MaterialAsset.cpp
index e51f9a709..f2197cf01 100644
--- a/Engine/source/T3D/assets/MaterialAsset.cpp
+++ b/Engine/source/T3D/assets/MaterialAsset.cpp
@@ -432,8 +432,8 @@ GuiControl* GuiInspectorTypeMaterialAssetPtr::constructEditControl()
 
    // Change filespec
    char szBuffer[512];
-   dSprintf(szBuffer, sizeof(szBuffer), "AssetBrowser.showDialog(\"MaterialAsset\", \"AssetBrowser.changeAsset\", %s, \"\");",
-      getIdString());
+   dSprintf(szBuffer, sizeof(szBuffer), "AssetBrowser.showDialog(\"MaterialAsset\", \"AssetBrowser.changeAsset\", %s, %s);",
+      mInspector->getIdString(), mCaption);
    mBrowseButton->setField("Command", szBuffer);
 
    setDataField(StringTable->insert("targetObject"), NULL, mInspector->getInspectObject()->getIdString());
diff --git a/Engine/source/T3D/assets/ParticleAsset.cpp b/Engine/source/T3D/assets/ParticleAsset.cpp
index 566611355..24005973e 100644
--- a/Engine/source/T3D/assets/ParticleAsset.cpp
+++ b/Engine/source/T3D/assets/ParticleAsset.cpp
@@ -151,7 +151,7 @@ GuiControl* GuiInspectorTypeParticleAssetPtr::constructEditControl()
    // Change filespec
    char szBuffer[512];
    dSprintf(szBuffer, sizeof(szBuffer), "AssetBrowser.showDialog(\"ParticleAsset\", \"AssetBrowser.changeAsset\", %d, %s);",
-      mInspector->getComponentGroupTargetId(), mCaption);
+      mInspector->getIdString(), mCaption);
    mBrowseButton->setField("Command", szBuffer);
 
    // Create "Open in ShapeEditor" button
diff --git a/Engine/source/T3D/assets/ShapeAsset.cpp b/Engine/source/T3D/assets/ShapeAsset.cpp
index 7a8628238..99becc8a6 100644
--- a/Engine/source/T3D/assets/ShapeAsset.cpp
+++ b/Engine/source/T3D/assets/ShapeAsset.cpp
@@ -49,6 +49,7 @@
 #ifdef TORQUE_TOOLS
 #include "ts/tsLastDetail.h"
 #endif
+#include "util/imposterCapture.h"
 
 StringTableEntry ShapeAsset::smNoShapeAssetFallback = NULL;
 
@@ -599,8 +600,8 @@ GuiControl* GuiInspectorTypeShapeAssetPtr::constructEditControl()
 
    // Change filespec
    char szBuffer[512];
-   dSprintf(szBuffer, sizeof(szBuffer), "AssetBrowser.showDialog(\"ShapeAsset\", \"AssetBrowser.changeAsset\", %s, %s);", 
-      mInspector->getInspectObject()->getIdString(), mCaption);
+   dSprintf(szBuffer, sizeof(szBuffer), "AssetBrowser.showDialog(\"ShapeAsset\", \"AssetBrowser.changeAsset\", %s, %s);",
+      mInspector->getIdString(), mCaption);
    mBrowseButton->setField("Command", szBuffer);
 
    setDataField(StringTable->insert("targetObject"), NULL, mInspector->getInspectObject()->getIdString());
diff --git a/Engine/source/T3D/assets/TerrainAsset.cpp b/Engine/source/T3D/assets/TerrainAsset.cpp
index 70ce8786b..2887cea2d 100644
--- a/Engine/source/T3D/assets/TerrainAsset.cpp
+++ b/Engine/source/T3D/assets/TerrainAsset.cpp
@@ -465,7 +465,7 @@ GuiControl* GuiInspectorTypeTerrainAssetPtr::constructEditControl()
    // Change filespec
    char szBuffer[512];
    dSprintf(szBuffer, sizeof(szBuffer), "AssetBrowser.showDialog(\"TerrainAsset\", \"AssetBrowser.changeAsset\", %s, %s);",
-      mInspector->getInspectObject()->getIdString(), mCaption);
+      mInspector->getIdString(), mCaption);
    mBrowseButton->setField("Command", szBuffer);
 
    setDataField(StringTable->insert("targetObject"), NULL, mInspector->getInspectObject()->getIdString());
diff --git a/Engine/source/T3D/assets/TerrainMaterialAsset.cpp b/Engine/source/T3D/assets/TerrainMaterialAsset.cpp
index b4d0c4214..ee5a36004 100644
--- a/Engine/source/T3D/assets/TerrainMaterialAsset.cpp
+++ b/Engine/source/T3D/assets/TerrainMaterialAsset.cpp
@@ -264,7 +264,7 @@ GuiControl* GuiInspectorTypeTerrainMaterialAssetPtr::constructEditControl()
    // Change filespec
    char szBuffer[512];
    dSprintf(szBuffer, sizeof(szBuffer), "AssetBrowser.showDialog(\"TerrainMaterialAsset\", \"AssetBrowser.changeAsset\", %d, %s);",
-      mInspector->getComponentGroupTargetId(), mCaption);
+      mInspector->getIdString(), mCaption);
    mMatPreviewButton->setField("Command", szBuffer);
 
    mMatPreviewButton->setDataField(StringTable->insert("Profile"), NULL, "GuiButtonProfile");
diff --git a/Engine/source/T3D/assets/assetImporter.cpp b/Engine/source/T3D/assets/assetImporter.cpp
index 2ceb677af..5d3d66180 100644
--- a/Engine/source/T3D/assets/assetImporter.cpp
+++ b/Engine/source/T3D/assets/assetImporter.cpp
@@ -1820,6 +1820,32 @@ void AssetImporter::processMaterialAsset(AssetImportObject* assetItem)
                   }
                   else
                   {
+                     //Check to see if our target module has a matching assetId for this slot already
+                     String testAssetId = targetModuleId + ":" + assetItem->cleanAssetName + StringUnit::getUnit(suffixList.c_str(), i, ",;\t");
+                     bool localAssetFound = false;
+
+                     if (AssetDatabase.isDeclaredAsset(testAssetId.c_str()))
+                        localAssetFound = true;
+
+                     if (localAssetFound == false)
+                        //Didn't work, try checking the common default type suffix
+                        testAssetId = targetModuleId + ":" + assetItem->cleanAssetName + StringUnit::getUnit(suffixList.c_str(), i, ",;\t") + activeImportConfig->AddedImageSuffix;
+
+                     if (localAssetFound)
+                     {
+                        //got a match!
+                        ImageAsset* foundImageAsset = AssetDatabase.acquireAsset<ImageAsset>(testAssetId.c_str());
+                        imagePath = foundImageAsset->getImagePath();
+
+                        AssetImportObject* newImageAssetObj = addImportingAsset("ImageAsset", imagePath, assetItem, "");
+
+                        newImageAssetObj->imageSuffixType = ImageAsset::getImageTypeNameFromType((ImageAsset::ImageTypes)t);
+                        newImageAssetObj->importStatus = AssetImportObject::UseForDependencies; //we aren't going to actually IMPORT an already imported asset,
+                                                                                                //so mark it as dependency use only
+                        matchedImageTypes[t] = newImageAssetObj;
+                        break;
+                     }
+
                      if (materialImageNoSuffix.isNotEmpty())
                      {
                         testPath = assetItem->filePath.getRootAndPath();
@@ -1837,6 +1863,32 @@ void AssetImporter::processMaterialAsset(AssetImportObject* assetItem)
                            matchedImageTypes[t] = newImageAssetObj;
                            break;
                         }
+
+                        //Check to see if our target module has a matching assetId for this slot already based on our trimmed mat name
+                        testAssetId = targetModuleId + ":" + materialImageNoSuffix + StringUnit::getUnit(suffixList.c_str(), i, ",;\t");
+                        bool localAssetFound = false;
+
+                        if (AssetDatabase.isDeclaredAsset(testAssetId.c_str()))
+                           localAssetFound = true;
+
+                        if (localAssetFound == false)
+                           //Didn't work, try checking the common default type suffix
+                           testAssetId = targetModuleId + ":" + materialImageNoSuffix + StringUnit::getUnit(suffixList.c_str(), i, ",;\t") + activeImportConfig->AddedImageSuffix;
+
+                        if (localAssetFound)
+                        {
+                           //got a match!
+                           ImageAsset* foundImageAsset = AssetDatabase.acquireAsset<ImageAsset>(testAssetId.c_str());
+                           imagePath = foundImageAsset->getImagePath();
+
+                           AssetImportObject* newImageAssetObj = addImportingAsset("ImageAsset", imagePath, assetItem, "");
+
+                           newImageAssetObj->imageSuffixType = ImageAsset::getImageTypeNameFromType((ImageAsset::ImageTypes)t);
+                           newImageAssetObj->importStatus = AssetImportObject::UseForDependencies; //we aren't going to actually IMPORT an already imported asset,
+                                                                                                   //so mark it as dependency use only
+                           matchedImageTypes[t] = newImageAssetObj;
+                           break;
+                        }
                      }
                   }
                }
@@ -2538,6 +2590,9 @@ void AssetImporter::importAssets(AssetImportObject* assetItem)
          {
             bool registerSuccess = AssetDatabase.addDeclaredAsset(moduleDef, assetPath.getFullPath().c_str());
 
+            String assetIdStr = item->moduleName + ":" + item->assetName;
+            StringTableEntry assetId = StringTable->insert(assetIdStr.c_str());
+
             if (!registerSuccess)
             {
                dSprintf(importLogBuffer, sizeof(importLogBuffer), "AssetImporter::importAssets - Failed to successfully register new asset at path %s to moduleId %s", assetPath.getFullPath().c_str(), targetModuleId.c_str());
@@ -2548,9 +2603,6 @@ void AssetImporter::importAssets(AssetImportObject* assetItem)
                //Any special-case post-reg stuff here
                if (item->assetType == String("ShapeAsset"))
                {
-                  String assetIdStr = item->moduleName + ":" + item->assetName;
-                  StringTableEntry assetId = StringTable->insert(assetIdStr.c_str());
-
                   //forcefully update it's shape constructor
                   TSShapeConstructor* tss = TSShapeConstructor::findShapeConstructorByAssetId(assetId);
 
@@ -2558,6 +2610,10 @@ void AssetImporter::importAssets(AssetImportObject* assetItem)
                      tss->setShapeAssetId(assetId);
                }
             }
+
+            //Go ahead and force the asset to load now just to kick it for immediate use
+            AssetBase* assetDef = AssetDatabase.acquireAsset<AssetBase>(assetId);
+            AssetDatabase.releaseAsset(assetId);
          }
          else
          {
diff --git a/Engine/source/T3D/assets/stateMachineAsset.cpp b/Engine/source/T3D/assets/stateMachineAsset.cpp
index 888898bf3..c35b34d51 100644
--- a/Engine/source/T3D/assets/stateMachineAsset.cpp
+++ b/Engine/source/T3D/assets/stateMachineAsset.cpp
@@ -185,7 +185,7 @@ GuiControl* GuiInspectorTypeStateMachineAssetPtr::constructEditControl()
    // Change filespec
    char szBuffer[512];
    dSprintf(szBuffer, sizeof(szBuffer), "AssetBrowser.showDialog(\"StateMachineAsset\", \"AssetBrowser.changeAsset\", %d, %s);",
-      mInspector->getComponentGroupTargetId(), mCaption);
+      mInspector->getIdString(), mCaption);
    mBrowseButton->setField("Command", szBuffer);
 
    // Create "Open in ShapeEditor" button
diff --git a/Engine/source/T3D/tsStatic.cpp b/Engine/source/T3D/tsStatic.cpp
index 8e090ef9f..dc3200f18 100644
--- a/Engine/source/T3D/tsStatic.cpp
+++ b/Engine/source/T3D/tsStatic.cpp
@@ -1086,15 +1086,16 @@ void TSStatic::unpackUpdate(NetConnection* con, BitStream* stream)
 
       stream->read(&mForceDetail);
 
-   if (stream->readFlag())
-      mAnimOffset = stream->readFloat(7);
+      if (stream->readFlag())
+         mAnimOffset = stream->readFloat(7);
 
-   if (stream->readFlag())
-      mAnimSpeed = stream->readSignedFloat(7) * AnimSpeedMax;
+      if (stream->readFlag())
+         mAnimSpeed = stream->readSignedFloat(7) * AnimSpeedMax;
 
       mPlayAmbient = stream->readFlag();
 
-
+      //update our shape, figuring that it likely changed
+      _createShape();
    }
 
    mUseAlphaFade = stream->readFlag();
diff --git a/Engine/source/gui/buttons/guiBitmapButtonCtrl.cpp b/Engine/source/gui/buttons/guiBitmapButtonCtrl.cpp
index 23c451fab..8e5e0fd76 100644
--- a/Engine/source/gui/buttons/guiBitmapButtonCtrl.cpp
+++ b/Engine/source/gui/buttons/guiBitmapButtonCtrl.cpp
@@ -232,32 +232,7 @@ void GuiBitmapButtonCtrl::inspectPostApply()
 {
    Parent::inspectPostApply();
 
-   Torque::Path path( mBitmapName );
-   const String& fileName = path.getFileName();
-   
-   if( mUseStates )
-   {
-      // If the filename points to a single state, automatically
-      // cut off the state part.  Makes it easy to select files in
-      // the editor without having to go in and manually cut off the
-      // state parts all the time.
-      
-      static String s_n = "_n";
-      static String s_d = "_d";
-      static String s_h = "_h";
-      static String s_i = "_i";
-      
-      if(    fileName.endsWith( s_n )
-          || fileName.endsWith( s_d )
-          || fileName.endsWith( s_h )
-          || fileName.endsWith( s_i ) )
-      {
-         path.setFileName( fileName.substr( 0, fileName.length() - 2 ) );
-         path.setExtension( String::EmptyString );
-      }
-   }
-   
-   setBitmap( StringTable->insert(path.getFullPath().c_str()) );
+   setBitmap(getBitmap());
 
    // if the extent is set to (0,0) in the gui editor and appy hit, this control will
    // set it's extent to be exactly the size of the normal bitmap (if present)
diff --git a/Engine/source/gui/buttons/guiBitmapButtonCtrl.h b/Engine/source/gui/buttons/guiBitmapButtonCtrl.h
index 1791c563a..000a77d0b 100644
--- a/Engine/source/gui/buttons/guiBitmapButtonCtrl.h
+++ b/Engine/source/gui/buttons/guiBitmapButtonCtrl.h
@@ -157,7 +157,10 @@ class GuiBitmapButtonCtrl : public GuiButtonCtrl
       
       /// @}
 
-      void onBitmapChange() {}
+      void onBitmapChange()
+      {
+         setBitmap(getBitmap());
+      }
 
    public:
                            
diff --git a/Templates/BaseGame/game/core/console/guis/console.gui b/Templates/BaseGame/game/core/console/guis/console.gui
index 3c5c217a6..daf013102 100644
--- a/Templates/BaseGame/game/core/console/guis/console.gui
+++ b/Templates/BaseGame/game/core/console/guis/console.gui
@@ -66,7 +66,7 @@ $guiContent = new GuiControl(ConsoleDlg) {
       canSaveDynamicFields = "0";
 
       new GuiBitmapCtrl() {
-         bitmap = "data/ui/art/hudfill.png";
+         bitmapAsset = "Core_GUI:hudFill";
          color = "255 255 255 255";
          wrap = "0";
          position = "0 0";
diff --git a/Templates/BaseGame/game/core/console/scripts/profiles.tscript b/Templates/BaseGame/game/core/console/scripts/profiles.tscript
index b83dd4fa7..fa358c3ca 100644
--- a/Templates/BaseGame/game/core/console/scripts/profiles.tscript
+++ b/Templates/BaseGame/game/core/console/scripts/profiles.tscript
@@ -50,11 +50,13 @@ new GuiControlProfile(GuiConsoleTextProfile)
    category = "Core";
 };
 
+$ConsoleDefaultFillColor = "0 0 0 175";
+
 if(!isObject(ConsoleScrollProfile))
 new GuiControlProfile(ConsoleScrollProfile : GuiScrollProfile)
 {
 	opaque = true;
-	fillColor = "0 0 0 175";
+	fillColor = $ConsoleDefaultFillColor;
 	border = 1;
 	//borderThickness = 0;
 	borderColor = "0 0 0";
diff --git a/Templates/BaseGame/game/core/gameObjects/shapes/Camera.asset.taml b/Templates/BaseGame/game/core/gameObjects/shapes/Camera.asset.taml
index bd49ffbb6..0f15637ff 100644
--- a/Templates/BaseGame/game/core/gameObjects/shapes/Camera.asset.taml
+++ b/Templates/BaseGame/game/core/gameObjects/shapes/Camera.asset.taml
@@ -1,6 +1 @@
-<ShapeAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="Camera"
-    fileName="@assetFile=camera.dts"
     constuctorFileName="@assetFile=camera.tscript" />
diff --git a/Templates/BaseGame/game/core/gameObjects/shapes/Green.asset.taml b/Templates/BaseGame/game/core/gameObjects/shapes/Green.asset.taml
new file mode 100644
index 000000000..4eaaebab9
--- /dev/null
+++ b/Templates/BaseGame/game/core/gameObjects/shapes/Green.asset.taml
@@ -0,0 +1,7 @@
+<MaterialAsset
+    canSave="true"
+    canSaveDynamicFields="true"
+    AssetName="Green"
+    scriptFile="@assetFile=green"
+    materialDefinitionName="Green"
+    originalFilePath="D:/Gamedev/Projects/Catographer/GameBuild/Templates/BaseGame/game/core/gameObjects/shapes/green" />
diff --git a/Templates/BaseGame/game/core/gameObjects/images/camera.png b/Templates/BaseGame/game/core/gameObjects/shapes/camera.png
similarity index 100%
rename from Templates/BaseGame/game/core/gameObjects/images/camera.png
rename to Templates/BaseGame/game/core/gameObjects/shapes/camera.png
diff --git a/Templates/BaseGame/game/core/gameObjects/shapes/camera.tscript b/Templates/BaseGame/game/core/gameObjects/shapes/camera.tscript
index 87d053808..6211dea72 100644
--- a/Templates/BaseGame/game/core/gameObjects/shapes/camera.tscript
+++ b/Templates/BaseGame/game/core/gameObjects/shapes/camera.tscript
@@ -1,5 +1,5 @@
 
-singleton TSShapeConstructor(cameradts)
+singleton TSShapeConstructor(cameradts2)
 {
    baseShapeAsset = "Core_GameObjects:Camera";
    singleDetailSize = "0";
diff --git a/Templates/BaseGame/game/core/gameObjects/images/camera_image.asset.taml b/Templates/BaseGame/game/core/gameObjects/shapes/camera_image.asset.taml
similarity index 100%
rename from Templates/BaseGame/game/core/gameObjects/images/camera_image.asset.taml
rename to Templates/BaseGame/game/core/gameObjects/shapes/camera_image.asset.taml
diff --git a/Templates/BaseGame/game/core/gameObjects/shapes/green.tscript b/Templates/BaseGame/game/core/gameObjects/shapes/green.tscript
new file mode 100644
index 000000000..9ea7a7bd0
--- /dev/null
+++ b/Templates/BaseGame/game/core/gameObjects/shapes/green.tscript
@@ -0,0 +1,196 @@
+//--- OBJECT WRITE BEGIN ---
+new Material(OctahedronMat) {
+   mapTo = "green";
+   diffuseColor[0] = "0 1 0 1";
+   diffuseColor[1] = "1 1 1 1";
+   diffuseColor[2] = "1 1 1 1";
+   diffuseColor[3] = "1 1 1 1";
+   DiffuseMap[0] = "core/gameObjects/images/camera";
+   diffuseMapSRGB[0] = "1";
+   diffuseMapSRGB[1] = "1";
+   diffuseMapSRGB[2] = "1";
+   diffuseMapSRGB[3] = "1";
+   detailScale[0] = "2 2";
+   detailScale[1] = "2 2";
+   detailScale[2] = "2 2";
+   detailScale[3] = "2 2";
+   detailNormalMapStrength[0] = "1";
+   detailNormalMapStrength[1] = "1";
+   detailNormalMapStrength[2] = "1";
+   detailNormalMapStrength[3] = "1";
+   roughness[0] = "1";
+   roughness[1] = "1";
+   roughness[2] = "1";
+   roughness[3] = "1";
+   metalness[0] = "0";
+   metalness[1] = "0";
+   metalness[2] = "0";
+   metalness[3] = "0";
+   glowMul[0] = "0";
+   glowMul[1] = "0";
+   glowMul[2] = "0";
+   glowMul[3] = "0";
+   accuEnabled[0] = "0";
+   accuEnabled[1] = "0";
+   accuEnabled[2] = "0";
+   accuEnabled[3] = "0";
+   accuScale[0] = "1";
+   accuScale[1] = "1";
+   accuScale[2] = "1";
+   accuScale[3] = "1";
+   accuDirection[0] = "1";
+   accuDirection[1] = "1";
+   accuDirection[2] = "1";
+   accuDirection[3] = "1";
+   accuStrength[0] = "0.6";
+   accuStrength[1] = "0.6";
+   accuStrength[2] = "0.6";
+   accuStrength[3] = "0.6";
+   accuCoverage[0] = "0.9";
+   accuCoverage[1] = "0.9";
+   accuCoverage[2] = "0.9";
+   accuCoverage[3] = "0.9";
+   accuSpecular[0] = "16";
+   accuSpecular[1] = "16";
+   accuSpecular[2] = "16";
+   accuSpecular[3] = "16";
+   isSRGB[0] = "0";
+   isSRGB[1] = "0";
+   isSRGB[2] = "0";
+   isSRGB[3] = "0";
+   invertRoughness[0] = "0";
+   invertRoughness[1] = "0";
+   invertRoughness[2] = "0";
+   invertRoughness[3] = "0";
+   roughnessChan[0] = "0";
+   roughnessChan[1] = "0";
+   roughnessChan[2] = "0";
+   roughnessChan[3] = "0";
+   AOChan[0] = "1";
+   AOChan[1] = "1";
+   AOChan[2] = "1";
+   AOChan[3] = "1";
+   metalChan[0] = "2";
+   metalChan[1] = "2";
+   metalChan[2] = "2";
+   metalChan[3] = "2";
+   glow[0] = "0";
+   glow[1] = "0";
+   glow[2] = "0";
+   glow[3] = "0";
+   parallaxScale[0] = "0";
+   parallaxScale[1] = "0";
+   parallaxScale[2] = "0";
+   parallaxScale[3] = "0";
+   useAnisotropic[0] = "1";
+   useAnisotropic[1] = "1";
+   useAnisotropic[2] = "1";
+   useAnisotropic[3] = "1";
+   vertLit[0] = "0";
+   vertLit[1] = "0";
+   vertLit[2] = "0";
+   vertLit[3] = "0";
+   vertColor[0] = "0";
+   vertColor[1] = "0";
+   vertColor[2] = "0";
+   vertColor[3] = "0";
+   minnaertConstant[0] = "-1";
+   minnaertConstant[1] = "-1";
+   minnaertConstant[2] = "-1";
+   minnaertConstant[3] = "-1";
+   subSurface[0] = "0";
+   subSurface[1] = "0";
+   subSurface[2] = "0";
+   subSurface[3] = "0";
+   subSurfaceColor[0] = "1 0.2 0.2 1";
+   subSurfaceColor[1] = "1 0.2 0.2 1";
+   subSurfaceColor[2] = "1 0.2 0.2 1";
+   subSurfaceColor[3] = "1 0.2 0.2 1";
+   subSurfaceRolloff[0] = "0.2";
+   subSurfaceRolloff[1] = "0.2";
+   subSurfaceRolloff[2] = "0.2";
+   subSurfaceRolloff[3] = "0.2";
+   emissive[0] = "0";
+   emissive[1] = "0";
+   emissive[2] = "0";
+   emissive[3] = "0";
+   foreground[0] = "0";
+   foreground[1] = "0";
+   foreground[2] = "0";
+   foreground[3] = "0";
+   doubleSided = "0";
+   animFlags[0] = "0x00000000";
+   animFlags[1] = "0x00000000";
+   animFlags[2] = "0x00000000";
+   animFlags[3] = "0x00000000";
+   scrollDir[0] = "0 0";
+   scrollDir[1] = "0 0";
+   scrollDir[2] = "0 0";
+   scrollDir[3] = "0 0";
+   scrollSpeed[0] = "0";
+   scrollSpeed[1] = "0";
+   scrollSpeed[2] = "0";
+   scrollSpeed[3] = "0";
+   rotSpeed[0] = "0";
+   rotSpeed[1] = "0";
+   rotSpeed[2] = "0";
+   rotSpeed[3] = "0";
+   rotPivotOffset[0] = "0 0";
+   rotPivotOffset[1] = "0 0";
+   rotPivotOffset[2] = "0 0";
+   rotPivotOffset[3] = "0 0";
+   waveType[0] = "Sin";
+   waveType[1] = "Sin";
+   waveType[2] = "Sin";
+   waveType[3] = "Sin";
+   waveFreq[0] = "0";
+   waveFreq[1] = "0";
+   waveFreq[2] = "0";
+   waveFreq[3] = "0";
+   waveAmp[0] = "0";
+   waveAmp[1] = "0";
+   waveAmp[2] = "0";
+   waveAmp[3] = "0";
+   sequenceFramePerSec[0] = "0";
+   sequenceFramePerSec[1] = "0";
+   sequenceFramePerSec[2] = "0";
+   sequenceFramePerSec[3] = "0";
+   sequenceSegmentSize[0] = "0";
+   sequenceSegmentSize[1] = "0";
+   sequenceSegmentSize[2] = "0";
+   sequenceSegmentSize[3] = "0";
+   cellIndex[0] = "0 0";
+   cellIndex[1] = "0 0";
+   cellIndex[2] = "0 0";
+   cellIndex[3] = "0 0";
+   cellLayout[0] = "0 0";
+   cellLayout[1] = "0 0";
+   cellLayout[2] = "0 0";
+   cellLayout[3] = "0 0";
+   cellSize[0] = "0";
+   cellSize[1] = "0";
+   cellSize[2] = "0";
+   cellSize[3] = "0";
+   bumpAtlas[0] = "0";
+   bumpAtlas[1] = "0";
+   bumpAtlas[2] = "0";
+   bumpAtlas[3] = "0";
+   castShadows = "0";
+   planarReflection = "0";
+   translucent = "1";
+   translucentBlendOp = "PreMul";
+   translucentZWrite = "0";
+   alphaTest = "0";
+   alphaRef = "1";
+   dynamicCubemap = "0";
+   showFootprints = "1";
+   showDust = "0";
+   effectColor[0] = "0 0 0 0";
+   effectColor[1] = "0 0 0 0";
+   footstepSoundId = "-1";
+   impactSoundId = "-1";
+   ImpactFXIndex = "-1";
+   canSave = "1";
+   canSaveDynamicFields = "1";
+};
+//--- OBJECT WRITE END ---
diff --git a/Templates/BaseGame/game/core/rendering/materials/moon_noglow.tscript b/Templates/BaseGame/game/core/rendering/materials/moon_noglow.tscript
new file mode 100644
index 000000000..b9e69c0da
--- /dev/null
+++ b/Templates/BaseGame/game/core/rendering/materials/moon_noglow.tscript
@@ -0,0 +1,9 @@
+//--- OBJECT WRITE BEGIN ---
+singleton Material(moon_noglow) {
+   mapTo="moon_noglow";
+   DiffuseMapAsset = "Core_Rendering:moon_noglow_image";
+   emissive = true;
+   translucent = true;
+   vertColor[ 0 ] = true;
+};
+//--- OBJECT WRITE END ---
diff --git a/Templates/BaseGame/game/core/rendering/materials/moon_wglow.tscript b/Templates/BaseGame/game/core/rendering/materials/moon_wglow.tscript
new file mode 100644
index 000000000..ad87ba5a3
--- /dev/null
+++ b/Templates/BaseGame/game/core/rendering/materials/moon_wglow.tscript
@@ -0,0 +1,9 @@
+//--- OBJECT WRITE BEGIN ---
+singleton Material(moon_wglow) {
+   mapTo="moon_wglow";
+   DiffuseMapAsset = "Core_Rendering:moon_wglow_image";
+   emissive = true;
+   translucent = true;
+   vertColor[ 0 ] = true;
+};
+//--- OBJECT WRITE END ---
diff --git a/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml b/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml
index ad9de2677..8417b1fa4 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml
+++ b/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml
@@ -19,6 +19,7 @@
             <Setting name="AddDirectoryPrefixToAssetName">0</Setting>
             <Setting name="AutomaticallyPromptMissingFiles">0</Setting>
             <Setting name="DuplicatAutoResolution">AutoPrune</Setting>
+            <Setting name="DuplicateAutoResolution">AutoPrune</Setting>
             <Setting name="PreventImportWithErrors">1</Setting>
             <Setting name="WarningsAsErrors">0</Setting>
         </Group>
diff --git a/Templates/BaseGame/game/tools/assetBrowser/guis/assetBrowser.gui b/Templates/BaseGame/game/tools/assetBrowser/guis/assetBrowser.gui
index 59e7beb10..e03d27ecb 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/guis/assetBrowser.gui
+++ b/Templates/BaseGame/game/tools/assetBrowser/guis/assetBrowser.gui
@@ -1084,6 +1084,22 @@ $guiContent = new GuiControl(AssetBrowser) {
          canSave = "1";
          canSaveDynamicFields = "0";
       };
+      new GuiBitmapCtrl() {
+         bitmapAsset = "ToolsModule:smaller_image";
+         position = "5 588";
+         extent = "20 20";
+         minExtent = "8 2";
+         horizSizing = "left";
+         vertSizing = "top";
+         profile = "ToolsGuiDefaultProfile";
+         visible = "1";
+         active = "1";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "0";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
       new GuiSliderCtrl() {
          range = "0 2";
          ticks = "5";
@@ -1092,7 +1108,7 @@ $guiContent = new GuiControl(AssetBrowser) {
          useFillBar = "0";
          fillBarColor = "255 255 255 255";
          renderTicks = "0";
-         position = "8 588";
+         position = "28 590";
          extent = "75 20";
          minExtent = "8 2";
          horizSizing = "right";
@@ -1109,6 +1125,22 @@ $guiContent = new GuiControl(AssetBrowser) {
          canSave = "1";
          canSaveDynamicFields = "0";
       };
+      new GuiBitmapCtrl() {
+         bitmapAsset = "ToolsModule:larger_image";
+         position = "103 588";
+         extent = "20 20";
+         minExtent = "8 2";
+         horizSizing = "left";
+         vertSizing = "top";
+         profile = "ToolsGuiDefaultProfile";
+         visible = "1";
+         active = "1";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "0";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
    };
 };
 //--- OBJECT WRITE END ---
diff --git a/Templates/BaseGame/game/tools/assetBrowser/guis/assetImport.gui b/Templates/BaseGame/game/tools/assetBrowser/guis/assetImport.gui
index 0f725dbd8..ccac94a50 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/guis/assetImport.gui
+++ b/Templates/BaseGame/game/tools/assetBrowser/guis/assetImport.gui
@@ -14,522 +14,6 @@ $guiContent = new GuiControl(AssetImportCtrl) {
    canSave = "1";
    canSaveDynamicFields = "1";
 
-   new GuiWindowCtrl(ImportAssetWindow) {
-      text = "Import Assets";
-      resizeWidth = "1";
-      resizeHeight = "1";
-      canMove = "1";
-      canClose = "0";
-      canMinimize = "0";
-      canMaximize = "0";
-      canCollapse = "0";
-      edgeSnap = "1";
-      margin = "0 0 0 0";
-      padding = "0 0 0 0";
-      anchorTop = "1";
-      anchorBottom = "0";
-      anchorLeft = "1";
-      anchorRight = "0";
-      position = "132 80";
-      extent = "733 582";
-      minExtent = "48 92";
-      horizSizing = "center";
-      vertSizing = "center";
-      profile = "ToolsGuiWindowProfile";
-      visible = "1";
-      active = "1";
-      tooltipProfile = "ToolsGuiToolTipProfile";
-      hovertime = "1000";
-      isContainer = "1";
-      canSave = "1";
-      canSaveDynamicFields = "0";
-
-      new GuiTextCtrl() {
-         text = "Target Path:";
-         maxLength = "1024";
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
-         position = "12 30";
-         extent = "116 17";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "ToolsGuiTextProfile";
-         visible = "1";
-         active = "1";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiTextEditCtrl(AssetImportTargetAddress) {
-         historySize = "0";
-         tabComplete = "0";
-         sinkAllKeyEvents = "0";
-         password = "0";
-         passwordMask = "*";
-         maxLength = "1024";
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
-         position = "135 30";
-         extent = "569 18";
-         minExtent = "8 2";
-         horizSizing = "width";
-         vertSizing = "bottom";
-         profile = "ToolsGuiTextEditProfile";
-         visible = "1";
-         active = "0";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiBitmapButtonCtrl() {
-         bitmapAsset = "ToolsModule:iconOpen_image";
-         bitmapMode = "Centered";
-         autoFitExtents = "0";
-         useModifiers = "0";
-         useStates = "1";
-         masked = "0";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "707 27";
-         extent = "22 22";
-         minExtent = "8 2";
-         horizSizing = "left";
-         vertSizing = "bottom";
-         profile = "ToolsGuiButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "SelectAssetPath.showDialog(AssetBrowser.dirHandler.currentAddress, \"assetImportUpdatePath\");\nSelectAssetPathWindow.selectWindow();";
-         tooltipProfile = "GuiToolTipProfile";
-         tooltip = "New Module";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiTextCtrl() {
-         text = "Target Module:";
-         maxLength = "1024";
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
-         position = "12 54";
-         extent = "116 17";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "ToolsGuiTextProfile";
-         visible = "1";
-         active = "1";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiTextEditCtrl(AssetImportTargetModule) {
-         historySize = "0";
-         tabComplete = "0";
-         sinkAllKeyEvents = "0";
-         password = "0";
-         passwordMask = "*";
-         maxLength = "1024";
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
-         position = "135 53";
-         extent = "569 18";
-         minExtent = "8 2";
-         horizSizing = "width";
-         vertSizing = "bottom";
-         profile = "ToolsGuiTextEditProfile";
-         visible = "1";
-         active = "0";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiTextCtrl() {
-         text = "Import Options Config:";
-         maxLength = "1024";
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
-         position = "12 79";
-         extent = "116 17";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "ToolsGuiTextProfile";
-         visible = "1";
-         active = "1";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiPopUpMenuCtrlEx(ImportAssetConfigList) {
-         maxPopupHeight = "200";
-         sbUsesNAColor = "0";
-         reverseTextList = "0";
-         bitmapBounds = "16 16";
-         hotTrackCallback = "0";
-         maxLength = "1024";
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
-         position = "135 78";
-         extent = "569 22";
-         minExtent = "8 2";
-         horizSizing = "width";
-         vertSizing = "bottom";
-         profile = "ToolsGuiPopUpMenuProfile";
-         visible = "1";
-         active = "1";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiBitmapButtonCtrl() {
-         bitmapAsset = "ToolsModule:save_as_n_image";
-         bitmapMode = "Centered";
-         autoFitExtents = "0";
-         useModifiers = "0";
-         useStates = "1";
-         masked = "0";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "711 77";
-         extent = "15 22";
-         minExtent = "8 2";
-         horizSizing = "left";
-         vertSizing = "bottom";
-         profile = "ToolsGuiButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "Canvas.pushDialog(AssetImportConfigEditor);";
-         tooltipProfile = "GuiToolTipProfile";
-         tooltip = "Edit Config";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiSplitContainer() {
-         orientation = "Vertical";
-         splitterSize = "2";
-         splitPoint = "182 100";
-         fixedPanel = "None";
-         fixedSize = "100";
-         docking = "None";
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
-         position = "5 102";
-         extent = "723 447";
-         minExtent = "64 64";
-         horizSizing = "width";
-         vertSizing = "height";
-         profile = "ToolsGuiSolidDefaultProfile";
-         visible = "1";
-         active = "1";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-
-         new GuiPanel() {
-            docking = "Client";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "0 0";
-            extent = "180 447";
-            minExtent = "16 16";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "ToolsGuiSolidDefaultProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "1";
-            internalName = "Panel1";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-
-            new GuiScrollCtrl() {
-               willFirstRespond = "1";
-               hScrollBar = "alwaysOff";
-               vScrollBar = "dynamic";
-               lockHorizScroll = "0";
-               lockVertScroll = "0";
-               constantThumbHeight = "0";
-               childMargin = "0 0";
-               mouseWheelScrollSpeed = "-1";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
-               anchorTop = "1";
-               anchorBottom = "0";
-               anchorLeft = "1";
-               anchorRight = "0";
-               position = "3 3";
-               extent = "180 444";
-               minExtent = "100 50";
-               horizSizing = "width";
-               vertSizing = "height";
-               profile = "ToolsGuiScrollProfile";
-               visible = "1";
-               active = "1";
-               tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "1";
-               canSave = "1";
-               canSaveDynamicFields = "0";
-
-               new GuiMouseEventCtrl(NewAssetsPanelInputs) {
-                  lockMouse = "0";
-                  position = "1 0";
-                  extent = "339 467";
-                  minExtent = "8 2";
-                  horizSizing = "width";
-                  vertSizing = "height";
-                  profile = "GuiDefaultProfile";
-                  visible = "1";
-                  active = "1";
-                  tooltipProfile = "GuiToolTipProfile";
-                  hovertime = "1000";
-                  isContainer = "0";
-                  canSave = "1";
-                  canSaveDynamicFields = "0";
-               };
-               new GuiTreeViewCtrl() {
-                  tabSize = "16";
-                  textOffset = "2";
-                  fullRowSelect = "0";
-                  itemHeight = "21";
-                  destroyTreeOnSleep = "1";
-                  mouseDragging = "1";
-                  multipleSelections = "1";
-                  deleteObjectAllowed = "1";
-                  dragToItemAllowed = "1";
-                  clearAllOnSingleSelection = "1";
-                  showRoot = "1";
-                  useInspectorTooltips = "0";
-                  tooltipOnWidthOnly = "0";
-                  showObjectIds = "1";
-                  showClassNames = "1";
-                  showObjectNames = "1";
-                  showInternalNames = "1";
-                  showClassNameForUnnamedObjects = "0";
-                  compareToObjectID = "1";
-                  canRenameObjects = "1";
-                  renameInternal = "0";
-                  position = "1 1";
-                  extent = "180 444";
-                  minExtent = "8 2";
-                  horizSizing = "width";
-                  vertSizing = "height";
-                  profile = "ToolsGuiTreeViewProfile";
-                  visible = "1";
-                  active = "1";
-                  tooltipProfile = "GuiToolTipProfile";
-                  hovertime = "1000";
-                  isContainer = "1";
-                  internalName = "NewAssetsTree";
-                  class = "NewAssetsViewTree";
-                  canSave = "1";
-                  canSaveDynamicFields = "0";
-               };
-            };
-         };
-         new GuiPanel() {
-            docking = "Client";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "184 0";
-            extent = "539 447";
-            minExtent = "16 16";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "ToolsGuiSolidDefaultProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "1";
-            internalName = "panel2";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-
-            new GuiScrollCtrl() {
-               willFirstRespond = "1";
-               hScrollBar = "dynamic";
-               vScrollBar = "dynamic";
-               lockHorizScroll = "0";
-               lockVertScroll = "0";
-               constantThumbHeight = "0";
-               childMargin = "0 0";
-               mouseWheelScrollSpeed = "-1";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
-               anchorTop = "1";
-               anchorBottom = "0";
-               anchorLeft = "1";
-               anchorRight = "0";
-               position = "0 0";
-               extent = "539 447";
-               minExtent = "8 2";
-               horizSizing = "width";
-               vertSizing = "height";
-               profile = "ToolsGuiScrollProfile";
-               visible = "1";
-               active = "1";
-               tooltipProfile = "GuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "1";
-               canSave = "1";
-               canSaveDynamicFields = "0";
-
-               new GuiVariableInspector() {
-                  dividerMargin = "5";
-                  showCustomFields = "1";
-                  stackingType = "Vertical";
-                  horizStacking = "Left to Right";
-                  vertStacking = "Top to Bottom";
-                  padding = "1";
-                  dynamicSize = "1";
-                  dynamicNonStackExtent = "0";
-                  dynamicPos = "0";
-                  changeChildSizeToFit = "1";
-                  changeChildPosition = "1";
-                  position = "1 1";
-                  extent = "522 615";
-                  minExtent = "16 16";
-                  horizSizing = "width";
-                  vertSizing = "height";
-                  profile = "ToolsGuiDefaultProfile";
-                  visible = "1";
-                  active = "1";
-                  tooltipProfile = "GuiToolTipProfile";
-                  hovertime = "1000";
-                  isContainer = "1";
-                  internalName = "NewAssetsInspector";
-                  canSave = "1";
-                  canSaveDynamicFields = "0";
-               };
-            };
-         };
-      };
-      new GuiButtonCtrl(DoAssetImportButton) {
-         text = "Done";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "589 553";
-         extent = "64 22";
-         minExtent = "8 2";
-         horizSizing = "left";
-         vertSizing = "top";
-         profile = "ToolsGuiButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "ImportAssetWindow.ImportAssets();";
-         tooltipProfile = "ToolsGuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl() {
-         text = "Cancel";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "657 553";
-         extent = "64 22";
-         minExtent = "8 2";
-         horizSizing = "left";
-         vertSizing = "top";
-         profile = "ToolsGuiButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "ImportAssetWindow.close();";
-         tooltipProfile = "ToolsGuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiBitmapButtonCtrl(ImportLogButton) {
-         bitmapAsset = "ToolsModule:iconInformation_image";
-         bitmapMode = "Centered";
-         autoFitExtents = "0";
-         useModifiers = "0";
-         useStates = "1";
-         masked = "0";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "5 555";
-         extent = "22 22";
-         minExtent = "8 2";
-         horizSizing = "left";
-         vertSizing = "bottom";
-         profile = "ToolsGuiButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "ImportAssetWindow.toggleLogWindow();";
-         tooltipProfile = "GuiToolTipProfile";
-         tooltip = "View Import Log";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-   };
    new GuiWindowCtrl(ImportAssetConfigEditorWindow) {
       text = "Import Options Config";
       resizeWidth = "1";
@@ -689,5 +173,544 @@ $guiContent = new GuiControl(AssetImportCtrl) {
          };
       };
    };
+   new GuiWindowCtrl(ImportAssetWindow) {
+      text = "Import Assets";
+      resizeWidth = "1";
+      resizeHeight = "1";
+      canMove = "1";
+      canClose = "0";
+      canMinimize = "0";
+      canMaximize = "0";
+      canCollapse = "0";
+      edgeSnap = "1";
+      margin = "0 0 0 0";
+      padding = "0 0 0 0";
+      anchorTop = "1";
+      anchorBottom = "0";
+      anchorLeft = "1";
+      anchorRight = "0";
+      position = "145 93";
+      extent = "733 582";
+      minExtent = "48 92";
+      horizSizing = "center";
+      vertSizing = "center";
+      profile = "ToolsGuiWindowProfile";
+      visible = "1";
+      active = "1";
+      tooltipProfile = "ToolsGuiToolTipProfile";
+      hovertime = "1000";
+      isContainer = "1";
+      canSave = "1";
+      canSaveDynamicFields = "0";
+
+      new GuiTextCtrl() {
+         text = "Target Path:";
+         maxLength = "1024";
+         margin = "0 0 0 0";
+         padding = "0 0 0 0";
+         anchorTop = "1";
+         anchorBottom = "0";
+         anchorLeft = "1";
+         anchorRight = "0";
+         position = "12 30";
+         extent = "116 17";
+         minExtent = "8 2";
+         horizSizing = "right";
+         vertSizing = "bottom";
+         profile = "ToolsGuiTextProfile";
+         visible = "1";
+         active = "1";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "1";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      new GuiTextEditCtrl(AssetImportTargetAddress) {
+         historySize = "0";
+         tabComplete = "0";
+         sinkAllKeyEvents = "0";
+         password = "0";
+         passwordMask = "*";
+         text = "data/";
+         maxLength = "1024";
+         margin = "0 0 0 0";
+         padding = "0 0 0 0";
+         anchorTop = "1";
+         anchorBottom = "0";
+         anchorLeft = "1";
+         anchorRight = "0";
+         position = "135 30";
+         extent = "569 18";
+         minExtent = "8 2";
+         horizSizing = "width";
+         vertSizing = "bottom";
+         profile = "ToolsGuiTextEditProfile";
+         visible = "1";
+         active = "0";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "1";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      new GuiBitmapButtonCtrl() {
+         BitmapAsset = "ToolsModule:iconOpen_image";
+         bitmapMode = "Centered";
+         autoFitExtents = "0";
+         useModifiers = "0";
+         useStates = "1";
+         masked = "0";
+         groupNum = "-1";
+         buttonType = "PushButton";
+         useMouseEvents = "0";
+         position = "707 27";
+         extent = "22 22";
+         minExtent = "8 2";
+         horizSizing = "left";
+         vertSizing = "bottom";
+         profile = "ToolsGuiButtonProfile";
+         visible = "1";
+         active = "1";
+         command = "SelectAssetPath.showDialog(AssetBrowser.dirHandler.currentAddress, \"assetImportUpdatePath\");\nSelectAssetPathWindow.selectWindow();";
+         tooltipProfile = "GuiToolTipProfile";
+         tooltip = "New Module";
+         hovertime = "1000";
+         isContainer = "0";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      new GuiTextCtrl() {
+         text = "Target Module:";
+         maxLength = "1024";
+         margin = "0 0 0 0";
+         padding = "0 0 0 0";
+         anchorTop = "1";
+         anchorBottom = "0";
+         anchorLeft = "1";
+         anchorRight = "0";
+         position = "12 54";
+         extent = "116 17";
+         minExtent = "8 2";
+         horizSizing = "right";
+         vertSizing = "bottom";
+         profile = "ToolsGuiTextProfile";
+         visible = "1";
+         active = "1";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "1";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      new GuiTextEditCtrl(AssetImportTargetModule) {
+         historySize = "0";
+         tabComplete = "0";
+         sinkAllKeyEvents = "0";
+         password = "0";
+         passwordMask = "*";
+         maxLength = "1024";
+         margin = "0 0 0 0";
+         padding = "0 0 0 0";
+         anchorTop = "1";
+         anchorBottom = "0";
+         anchorLeft = "1";
+         anchorRight = "0";
+         position = "135 53";
+         extent = "569 18";
+         minExtent = "8 2";
+         horizSizing = "width";
+         vertSizing = "bottom";
+         profile = "ToolsGuiTextEditProfile";
+         visible = "1";
+         active = "0";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "1";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      new GuiTextCtrl() {
+         text = "Import Options Config:";
+         maxLength = "1024";
+         margin = "0 0 0 0";
+         padding = "0 0 0 0";
+         anchorTop = "1";
+         anchorBottom = "0";
+         anchorLeft = "1";
+         anchorRight = "0";
+         position = "12 79";
+         extent = "116 17";
+         minExtent = "8 2";
+         horizSizing = "right";
+         vertSizing = "bottom";
+         profile = "ToolsGuiTextProfile";
+         visible = "1";
+         active = "1";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "1";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      new GuiPopUpMenuCtrlEx(ImportAssetConfigList) {
+         maxPopupHeight = "200";
+         sbUsesNAColor = "0";
+         reverseTextList = "0";
+         bitmapBounds = "16 16";
+         hotTrackCallback = "0";
+         text = "DefaultImportConfig";
+         maxLength = "1024";
+         margin = "0 0 0 0";
+         padding = "0 0 0 0";
+         anchorTop = "1";
+         anchorBottom = "0";
+         anchorLeft = "1";
+         anchorRight = "0";
+         position = "135 78";
+         extent = "569 22";
+         minExtent = "8 2";
+         horizSizing = "width";
+         vertSizing = "bottom";
+         profile = "ToolsGuiPopUpMenuProfile";
+         visible = "1";
+         active = "1";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "1";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      new GuiBitmapButtonCtrl() {
+         BitmapAsset = "ToolsModule:save_as_n_image";
+         bitmapMode = "Centered";
+         autoFitExtents = "0";
+         useModifiers = "0";
+         useStates = "1";
+         masked = "0";
+         groupNum = "-1";
+         buttonType = "PushButton";
+         useMouseEvents = "0";
+         position = "711 77";
+         extent = "15 22";
+         minExtent = "8 2";
+         horizSizing = "left";
+         vertSizing = "bottom";
+         profile = "ToolsGuiButtonProfile";
+         visible = "1";
+         active = "1";
+         command = "Canvas.pushDialog(AssetImportConfigEditor);";
+         tooltipProfile = "GuiToolTipProfile";
+         tooltip = "Edit Config";
+         hovertime = "1000";
+         isContainer = "0";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      new GuiSplitContainer() {
+         orientation = "Vertical";
+         splitterSize = "2";
+         splitPoint = "182 100";
+         fixedPanel = "None";
+         fixedSize = "100";
+         docking = "None";
+         margin = "0 0 0 0";
+         padding = "0 0 0 0";
+         anchorTop = "1";
+         anchorBottom = "0";
+         anchorLeft = "1";
+         anchorRight = "0";
+         position = "5 102";
+         extent = "723 447";
+         minExtent = "64 64";
+         horizSizing = "width";
+         vertSizing = "height";
+         profile = "ToolsGuiSolidDefaultProfile";
+         visible = "1";
+         active = "1";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "1";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+
+         new GuiPanel() {
+            docking = "Client";
+            margin = "0 0 0 0";
+            padding = "0 0 0 0";
+            anchorTop = "1";
+            anchorBottom = "0";
+            anchorLeft = "1";
+            anchorRight = "0";
+            position = "0 0";
+            extent = "180 447";
+            minExtent = "16 16";
+            horizSizing = "right";
+            vertSizing = "bottom";
+            profile = "ToolsGuiSolidDefaultProfile";
+            visible = "1";
+            active = "1";
+            tooltipProfile = "GuiToolTipProfile";
+            hovertime = "1000";
+            isContainer = "1";
+            internalName = "Panel1";
+            canSave = "1";
+            canSaveDynamicFields = "0";
+
+            new GuiBitmapButtonCtrl(ImportLogButton) {
+               bitmapAsset = "ToolsModule:iconInformation_image";
+               bitmapMode = "Centered";
+               autoFitExtents = "0";
+               useModifiers = "0";
+               useStates = "1";
+               masked = "0";
+               groupNum = "-1";
+               buttonType = "PushButton";
+               useMouseEvents = "0";
+               position = "5 0";
+               extent = "22 22";
+               minExtent = "8 2";
+               horizSizing = "right";
+               vertSizing = "bottom";
+               profile = "ToolsGuiButtonProfile";
+               visible = "1";
+               active = "1";
+               command = "ImportAssetWindow.toggleLogWindow();";
+               tooltipProfile = "GuiToolTipProfile";
+               tooltip = "View Import Log";
+               hovertime = "1000";
+               isContainer = "0";
+               canSave = "1";
+               canSaveDynamicFields = "0";
+            };
+            new GuiScrollCtrl() {
+               willFirstRespond = "1";
+               hScrollBar = "alwaysOff";
+               vScrollBar = "dynamic";
+               lockHorizScroll = "0";
+               lockVertScroll = "0";
+               constantThumbHeight = "0";
+               childMargin = "0 0";
+               mouseWheelScrollSpeed = "-1";
+               margin = "0 0 0 0";
+               padding = "0 0 0 0";
+               anchorTop = "1";
+               anchorBottom = "0";
+               anchorLeft = "1";
+               anchorRight = "0";
+               position = "3 22";
+               extent = "180 426";
+               minExtent = "100 50";
+               horizSizing = "width";
+               vertSizing = "height";
+               profile = "ToolsGuiScrollProfile";
+               visible = "1";
+               active = "1";
+               tooltipProfile = "ToolsGuiToolTipProfile";
+               hovertime = "1000";
+               isContainer = "1";
+               canSave = "1";
+               canSaveDynamicFields = "0";
+
+               new GuiMouseEventCtrl(NewAssetsPanelInputs) {
+                  lockMouse = "0";
+                  position = "1 0";
+                  extent = "339 449";
+                  minExtent = "8 2";
+                  horizSizing = "width";
+                  vertSizing = "height";
+                  profile = "GuiDefaultProfile";
+                  visible = "1";
+                  active = "1";
+                  tooltipProfile = "GuiToolTipProfile";
+                  hovertime = "1000";
+                  isContainer = "0";
+                  canSave = "1";
+                  canSaveDynamicFields = "0";
+               };
+               new GuiTreeViewCtrl() {
+                  tabSize = "16";
+                  textOffset = "2";
+                  fullRowSelect = "0";
+                  itemHeight = "21";
+                  destroyTreeOnSleep = "1";
+                  mouseDragging = "1";
+                  multipleSelections = "1";
+                  deleteObjectAllowed = "1";
+                  dragToItemAllowed = "1";
+                  clearAllOnSingleSelection = "1";
+                  showRoot = "1";
+                  useInspectorTooltips = "0";
+                  tooltipOnWidthOnly = "0";
+                  showObjectIds = "1";
+                  showClassNames = "1";
+                  showObjectNames = "1";
+                  showInternalNames = "1";
+                  showClassNameForUnnamedObjects = "0";
+                  compareToObjectID = "1";
+                  canRenameObjects = "1";
+                  renameInternal = "0";
+                  position = "1 1";
+                  extent = "102 21";
+                  minExtent = "8 2";
+                  horizSizing = "width";
+                  vertSizing = "height";
+                  profile = "ToolsGuiTreeViewProfile";
+                  visible = "1";
+                  active = "1";
+                  tooltipProfile = "GuiToolTipProfile";
+                  hovertime = "1000";
+                  isContainer = "1";
+                  internalName = "NewAssetsTree";
+                  class = "NewAssetsViewTree";
+                  canSave = "1";
+                  canSaveDynamicFields = "0";
+               };
+            };
+         };
+         new GuiPanel() {
+            docking = "Client";
+            margin = "0 0 0 0";
+            padding = "0 0 0 0";
+            anchorTop = "1";
+            anchorBottom = "0";
+            anchorLeft = "1";
+            anchorRight = "0";
+            position = "184 0";
+            extent = "539 447";
+            minExtent = "16 16";
+            horizSizing = "right";
+            vertSizing = "bottom";
+            profile = "ToolsGuiSolidDefaultProfile";
+            visible = "1";
+            active = "1";
+            tooltipProfile = "GuiToolTipProfile";
+            hovertime = "1000";
+            isContainer = "1";
+            internalName = "panel2";
+            canSave = "1";
+            canSaveDynamicFields = "0";
+
+            new GuiScrollCtrl() {
+               willFirstRespond = "1";
+               hScrollBar = "dynamic";
+               vScrollBar = "dynamic";
+               lockHorizScroll = "0";
+               lockVertScroll = "0";
+               constantThumbHeight = "0";
+               childMargin = "0 0";
+               mouseWheelScrollSpeed = "-1";
+               margin = "0 0 0 0";
+               padding = "0 0 0 0";
+               anchorTop = "1";
+               anchorBottom = "0";
+               anchorLeft = "1";
+               anchorRight = "0";
+               position = "0 0";
+               extent = "539 447";
+               minExtent = "8 2";
+               horizSizing = "width";
+               vertSizing = "height";
+               profile = "ToolsGuiScrollProfile";
+               visible = "1";
+               active = "1";
+               tooltipProfile = "GuiToolTipProfile";
+               hovertime = "1000";
+               isContainer = "1";
+               canSave = "1";
+               canSaveDynamicFields = "0";
+
+               new GuiVariableInspector() {
+                  dividerMargin = "5";
+                  showCustomFields = "1";
+                  stackingType = "Vertical";
+                  horizStacking = "Left to Right";
+                  vertStacking = "Top to Bottom";
+                  padding = "1";
+                  dynamicSize = "1";
+                  dynamicNonStackExtent = "0";
+                  dynamicPos = "0";
+                  changeChildSizeToFit = "1";
+                  changeChildPosition = "1";
+                  position = "1 1";
+                  extent = "522 615";
+                  minExtent = "16 16";
+                  horizSizing = "width";
+                  vertSizing = "height";
+                  profile = "ToolsGuiDefaultProfile";
+                  visible = "1";
+                  active = "1";
+                  tooltipProfile = "GuiToolTipProfile";
+                  hovertime = "1000";
+                  isContainer = "1";
+                  internalName = "NewAssetsInspector";
+                  canSave = "1";
+                  canSaveDynamicFields = "0";
+               };
+            };
+         };
+      };
+      new GuiButtonCtrl(DoAssetImportButton) {
+         text = "Done";
+         groupNum = "-1";
+         buttonType = "PushButton";
+         useMouseEvents = "0";
+         position = "589 553";
+         extent = "64 22";
+         minExtent = "8 2";
+         horizSizing = "left";
+         vertSizing = "top";
+         profile = "ToolsGuiButtonProfile";
+         visible = "1";
+         active = "1";
+         command = "ImportAssetWindow.ImportAssets();";
+         tooltipProfile = "ToolsGuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "0";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      new GuiButtonCtrl() {
+         text = "Cancel";
+         groupNum = "-1";
+         buttonType = "PushButton";
+         useMouseEvents = "0";
+         position = "657 553";
+         extent = "64 22";
+         minExtent = "8 2";
+         horizSizing = "left";
+         vertSizing = "top";
+         profile = "ToolsGuiButtonProfile";
+         visible = "1";
+         active = "1";
+         command = "ImportAssetWindow.close();";
+         tooltipProfile = "ToolsGuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "0";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      new GuiCheckBoxCtrl(toggleImportWindowVizBtn) {
+         text = "Don\'t show this every time";
+         groupNum = "-1";
+         buttonType = "ToggleButton";
+         useMouseEvents = "0";
+         position = "416 551";
+         extent = "177 30";
+         minExtent = "8 2";
+         horizSizing = "left";
+         vertSizing = "top";
+         profile = "ToolsGuiCheckBoxProfile";
+         visible = "1";
+         active = "1";
+         command = "toggleImportWindowViz();";
+         tooltipProfile = "GuiToolTipProfile";
+         tooltip = "If checked, this will make the importer run silently without prompting the window each time, using the Default Import Config";
+         hovertime = "1000";
+         isContainer = "0";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+   };
 };
 //--- OBJECT WRITE END ---
diff --git a/Templates/BaseGame/game/tools/assetBrowser/guis/newFolder.gui b/Templates/BaseGame/game/tools/assetBrowser/guis/newFolder.gui
index 7030b5e40..924b1a256 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/guis/newFolder.gui
+++ b/Templates/BaseGame/game/tools/assetBrowser/guis/newFolder.gui
@@ -47,7 +47,7 @@ $guiContent = new GuiControl(AssetBrowser_newFolder) {
       canSaveDynamicFields = "0";
 
       new GuiButtonCtrl() {
-         text = "Select";
+         text = "OK";
          groupNum = "-1";
          buttonType = "PushButton";
          useMouseEvents = "0";
@@ -65,6 +65,7 @@ $guiContent = new GuiControl(AssetBrowser_newFolder) {
          isContainer = "0";
          canSave = "1";
          canSaveDynamicFields = "0";
+         accelerator = "return";
       };
       new GuiButtonCtrl() {
          text = "Cancel";
@@ -85,6 +86,7 @@ $guiContent = new GuiControl(AssetBrowser_newFolder) {
          isContainer = "0";
          canSave = "1";
          canSaveDynamicFields = "0";
+         accelerator = "escape";
       };
       new GuiTextEditCtrl(AssetBrowser_newFolderNameTxt) {
          historySize = "0";
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
index 3dd803a62..283030684 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
@@ -279,6 +279,7 @@ function AssetBrowser::selectAsset( %this, %asset )
       %this.changeAsset();
    }
    
+   if(isObject(Inspector))
    Inspector.refresh();
    
    AssetBrowser.hideDialog();
@@ -985,14 +986,31 @@ function AssetBrowser::toggleTagFilterPopup(%this)
 
 function AssetBrowser::changeAsset(%this)
 {
+   %targetObject = %this.fieldTargetObject;
+   %inspectorObject = "";
+   
+   if(%this.fieldTargetObject.isInNamespaceHierarchy("GuiInspector"))
+   {
+      %inspectorObject = %this.fieldTargetObject;
+      %targetObject = %inspectorObject.getInspectObject();
+   }
+   
    //alright, we've selectd an asset for a field, so time to set it!
    if(%this.fieldTargetName $= "")
-      %cmd = %this.fieldTargetObject @ ".apply(\""@ %this.selectedAsset @ "\");";
+      %cmd = %targetObject @ ".apply(\""@ %this.selectedAsset @ "\");";
    else
-      %cmd = %this.fieldTargetObject @ "." @ %this.fieldTargetName @ "=\"" @ %this.selectedAsset @ "\";";
-   echo("Changing asset via the " @ %cmd @ " command");
+      %cmd = %targetObject @ "." @ %this.fieldTargetName @ "=\"" @ %this.selectedAsset @ "\";";
+   //echo("Changing asset via the " @ %cmd @ " command");
    eval(%cmd);
    
+   //Force update our object with the field change
+   %targetObject.inspectPostApply();
+   
+   if(isObject(%inspectorObject))
+   {
+      %inspectorObject.refresh();
+   }
+   
    //Flag us as dirty for editing purposes
    EWorldEditor.setSceneAsDirty();
 }
@@ -2317,6 +2335,53 @@ function EWorldEditor::onControlDropped( %this, %payload, %position )
    EWorldEditor.isDirty = true;
 }
 
+function GuiEditor::onControlDropped(%this, %payload, %position)
+{  
+   Canvas.popDialog(EditorDragAndDropLayer);
+   // Make sure we have the right kind of D&D.
+   
+   if( !%payload.parentGroup.isInNamespaceHierarchy( "GuiDragAndDropControlType_GuiControl" ) &&
+         !%payload.parentGroup.isInNamespaceHierarchy( "AssetPreviewControlType_AssetDrop" ))
+      return;
+      
+   if( %payload.dragSourceControl == %this )
+      return;
+
+   %pos = %payload.getGlobalPosition();
+   %x = getWord(%pos, 0);
+   %y = getWord(%pos, 1);
+   
+   if(%payload.assetType !$= "Creator")
+   {
+      //dealing with an actual asset, so build the assetName
+      %assetId = %payload.moduleName @ ":" @ %payload.assetName;
+      %assetType = AssetDatabase.getAssetType(%assetId);
+      
+      if(%assetType $= "ImageAsset")
+      {
+         %cmd = "return new guiBitmapCtrl();";
+         %ctrl = eval( %cmd ); 
+         %ctrl.bitmap = %assetId;
+      }
+   }
+   else
+   {
+      %className = %payload.assetName;
+      %cmd = "return new " @ %className @ "();";
+      %ctrl = eval( %cmd );
+   }
+
+   %this.addNewCtrl(%ctrl);
+   
+   %ctrl.setPositionGlobal(%x, %y);
+   %this.setFirstResponder();
+   
+   if(EditorSettings.value("AssetManagement/Assets/closeBrowserOnDragAction", false))
+   {
+      AssetBrowser.hideDialog();  
+   }
+}
+
 function AssetBrowserFilterTree::onControlDropped( %this, %payload, %position )
 {
    Canvas.popDialog(EditorDragAndDropLayer);
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImport.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImport.tscript
index f96b1b645..89f294486 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImport.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImport.tscript
@@ -181,6 +181,20 @@ function AssetBrowser::onBeginDropFiles( %this )
 
 function AssetBrowser::onDropFile( %this, %filePath )
 {
+   if(fileExt(%filePath) $= "")
+   {
+      //we're dealing with a folder, so we gotta parse through it  
+      
+      %file = findFirstFile( %filePath @ "/*" );
+      while( %file !$= "" )
+      {      
+         %this.onDropFile(%file);
+         %file = findNextFile( %filePath @ "/*" );
+      }
+      
+      return;
+   }
+   
    if(!AssetBrowser.isAwake() || !AssetBrowser.isVisible())
    {
       if(GuiEditorIsActive())
@@ -501,7 +515,7 @@ function ImportAssetWindow::doRefresh(%this)
    }
    if(%this.autoRenamedAssets != 0)
    {
-      %ImportActionSummary = %ImportActionSummary SPC %this.autoRenamedAssets @ " Auto Renamed|";
+      %ImportActionSummary = %ImportActionSummary SPC %this.autoRenamedAssets @ " Automatically Renamed|";
    }
    
    if(%ImportActionSummary !$= "")
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfig.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfig.tscript
index 175d0f4d5..787983fe1 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfig.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfig.tscript
@@ -109,6 +109,7 @@ function setupImportConfigSettingsList()
       ImportAssetConfigSettingsList.addNewConfigSetting("Images/GenerateMaterialOnImport", "Generate Material On Import", "bool", "", "1", "");
 
       //Sounds
+      ImportAssetConfigSettingsList.addNewConfigSetting("Images/ImportSounds", "Import Sounds", "bool", "", "1", "");
       ImportAssetConfigSettingsList.addNewConfigSetting("Sounds/VolumeAdjust", "Volume Adjustment", "float", "", "1.0", "");
       ImportAssetConfigSettingsList.addNewConfigSetting("Sounds/PitchAdjust", "Pitch Adjustment", "float", "", "1.0", "");
       ImportAssetConfigSettingsList.addNewConfigSetting("Sounds/Compressed", "Is Compressed", "bool", "", "0", "");
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfigEditor.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfigEditor.tscript
index effa43f52..929c1ddfe 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfigEditor.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfigEditor.tscript
@@ -1,6 +1,9 @@
 function AssetImportConfigEditor::onWake(%this)
 {
    %this.refresh();
+   
+   %index = AssetImportConfigList.findTextIndex(EditorSettings.value("Assets/AssetImporDefaultConfig", ""));
+   AssetImportConfigList.setSelectedRow(%index);
 }
 
 function AssetImportConfigEditor::refresh(%this)
@@ -41,7 +44,7 @@ function AssetImportConfigList::onSelect( %this, %id, %text )
    %this.populateConfigListByGroup("Images");
    %this.populateConfigListByGroup("Sounds");
    %this.populateConfigListByGroup("Animations");
-   %this.populateConfigListByGroup("Collision");
+   //%this.populateConfigListByGroup("Collision");
    
    ImportOptionsConfigList.update();  
 }
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/creatorObj.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/creatorObj.tscript
index 1dec09e34..44c84bec7 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/creatorObj.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/creatorObj.tscript
@@ -6,6 +6,7 @@ function AssetBrowser::buildCreatorPreview(%this, %assetDef, %previewData)
             
    %previewData.assetName = %name;
    %previewData.assetPath = "";
+   %previewData.moduleName = "";
    
    %previewData.previewImage = "ToolsModule:" @ %class @ "_image";
    
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/folder.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/folder.tscript
index 33dd9a98b..8817cc337 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/folder.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/folder.tscript
@@ -1,7 +1,9 @@
 function AssetBrowser::createNewFolder(%this)
 {
    AssetBrowser_newFolderNameTxt.text = "NewFolder";
-   Canvas.pushDialog(AssetBrowser_newFolder);
+   Canvas.pushDialog(AssetBrowser_newFolder, 99, true);
+
+   AssetBrowser_newFolderNameTxt.selectAllText();
 }
 
 function AssetBrowser::doCreateNewFolder(%this)
diff --git a/Templates/BaseGame/game/tools/gui/images/stencilIcons/larger.png b/Templates/BaseGame/game/tools/gui/images/stencilIcons/larger.png
index 4f5d73310dca5211a7e69b92d834df08fd3ffecb..b7aba1dad58f7b51ac2c1c08f947c0182a47b746 100644
GIT binary patch
delta 1508
zcmZuxX*3iH6dp2$#xnL~8(Y!HI;gCJ!BBcK*+XQCEHjMkW-^wsWX;UO*g|Dj!+R;)
zFdm-0P$5Y?NwzE_#e39w@ATuH`{RB;zH{$)@BPj#2qW`k$P?J#MW7w=m#&6Fu|a_t
zA3tv>J{;=}^$zpF003bV%T(K-DJW0E+q1}YqCy-KSFfSff=GWW(;q?4_rIREUBZ9U
zljQ9r_;(^oFiqxd<W2%98EffVXgw%kajF8_)&4%5X3zz%+vxEzD7A=uBCUQt)@>Zz
z{kg7wX%FZ^*l#eHAT7hv>Wr5dr;AhjQxPu6TH}rf1>@05QGCAp>IEUm0}$%QMzkh*
zMA-ZWGcki1KChLXnq4+4>5%%)GE3dY^Mz{B7MO}x<7hU&xZ4%|dS10#{DV%-x3U+H
zvs=dlD>om>&BC+@)je}o>!`Nrd{zvNUZo7`$$3dA3$V+TKNFC#ftD{7x9NI?f!&b4
zIVBs_iT)j;J0<L?G_7n~YE_W-dbOdH$plG6{3Z32KR*Tc?ure^jnUV!!alPebP}z-
z-{CZTgObVLE14_7$mV9W?>vgX-sv!DT0GsYc``Z1C;n+zwc1^co;$E+K-}(g^n+I6
zK~+P7%#mthu}!X&P&H1^)X$35sF+PR<HcTBcl~_LA4oLosZrvr(zESXu*$usAt8Xr
zuT?yxDXw#}mm!);tZd}Ou{4W-W-oZO(-*i`BpX*wYC4ncA-la*o@T3Vw_qg#nO%v|
z4ms^ipS!EQ;1~YMZj6~#;jI-6v%jL>6hXKZ%$jY)3ix>)w^FrlzIzFlHI5dj>S*hz
zUq9h8f$z)rZ_TM$aWssa2pM{|+)8cH33y%)jHBdh2bPbK_*BZ}r6T4!`HcRw)f;!F
z7Czmcs)<x<aT^sKv+y07i@A75RJ*V^q3BHo!|xUt;iWgi;9;H-AWuSxzyXpIo?w*(
zYGSB}QlR%zPldGmz{$5g&XF5mbgkH|P^Z{O_v`|`CA%K`un%lfAC88yawoyQHG|9c
zCyLiaOzb{o#18S><VYFqgnVu^WVZ3F@ooMb?!c@xBk8021-sm6(M)`;lMD#}V2k%L
zHT?x;YI^8+!lC64j82QrG_dS6mh5u3E59d#fRWE#dl>71Kr?MC9XY_|HN%yp-g5Wh
zGFcQ3C+rI5i&3$ca;1fYU`03>{19E;lSnb;bpomcSq<vm3kzMvvG^dB$oqNzLc~fZ
zbA3TkyT!{RtYp>AQZcV%S-)0T2&JGJB;8qrwY4o(Cf&K{YcL)rp3Nqm8J4z~fNVzS
z(|s0ctfV6<YRb$7=6lX789SLvkNW~?!F*tSEf0nF8%#D&jhD<IA$oI(;6)*j$mP-~
z+4;vE;VE=y75c8h7x13Azak?fuaoS-ZOeq3n2Q62ugaQLnI|WmSx$7>0Z9>3T?v{^
zM?K~ojk!-Lbo1|n+Ma3C?Xm;1jCdN_UTt@C%}fG)MJD$Re_Nj5o{8qHZAfTC12IOZ
zI(Wm3z%ZTH)m0ZB&i`bJjk6Hnn<3e2ZP$aj&C=Sv4<8N%<7=B*##p#rfI>ypyu{25
z<k*1ic0@{OD4eyunj1kdqIU&}F*3uvdjS9dr>C`r*+Gr~^lP$Sd1lIr5da`O>H-op
z4;B$t<6Z9gVta5qF_akseejm1MtD1*!p0+sIDiE%?pBb)2c<Uv-C-FwA~l$BfoIcf
zqOyEz+H`3X%SGhkg0Qj4L5(>$$UkHI#oV>RqB)JCobH!``*Rt4bxHQ&Q52PhAM6G~
zU$o`6_szvVOcBJILIemvpzQ2s#zZdicYNIKk5yTVbuY@fHq3_j{}JA#E{qNhq&t25
zhS7g8tph?86e;$dJ*@DrphIjKkNHI1T3uR#$*suLU0<2}noMS$hkV^OQPnZDrUd`!
wHZgBF=NL6;ojw%&k)rb7I0vG>V|cUL(LA{p#p2PVgB=1;NE@?S6OY(`07$yB3;+NC

literal 15389
zcmeI3du$X%9LE=eLJKIC@=}AFQ!GU8cK2TGt#^m*T}z7|l(s-oqilDl?b^HB<96G-
ztBUo7;3L+GC@K&i#Gp|k2)+;vT4*Xt#79t!rbvPi2=)&HT71mjb9%jFF!9g1Y<s`X
ze1G5B`OI&o`_HbeT{wSY;gy9HMNO=!_SV5~N&gvlDf}He`b-1-DhO3CS1D@zWc_Cp
z_56#|Dax^4ZfMjReYfzU5-<sp(gaM=KnSWS$~i9@62vy3(M_O54!R6yKK$4~%aY5m
z%;sZ#ArEMkt2@J>zH?!N*x4pJB*Q#+p)<-ug8<M3IvVf?RX*x6#C>@f>&=XTj!U#Q
zm!VuAkZ$zV(jFxYXq(Aq6j?JzmpV+G&FbK|xwM((EDXmoW`~jEcxx%o+3DoR;4Xxb
zGb}apb>6DvaPTjep;gmDJi|mH5mUrsQo=0^=WsX}*36jAMyN2Vv7jbIjY0L=gh|TB
z3sf;IhcsCU(z>tEq_k@;gFzoC{YlO%5K0deRFmu=MJ6hQ7|z5pd6Im-3#SDFIWtwQ
z4rFGQb3nBr76MEiP?h$u2%!AhT(_WVl^t+ONkkW6RM`Q7T23oTO#6h|!~QsENo0T@
z1Yn8^DR4RG5^7a6MQv5`08Dr1#i+^6d06N@dDB2t&XcD1B+}wFl~`&gEM(pj27;!9
z8x+OwPLykH>h5Wehn~Gm4oXTyo#SM()tQ>f7y+-K0XM8^E39TCYi=-eyoKX!wi{TE
zXIaD~q0I8|DU#eA8{uK**)ra0MLiH@wg=pUlAs9}<$`L5`}ll(O;FW@pa^QbZa8<7
zEK9u2!HPne!)!D=ETXZAvjU^TEW$q}3v1y@ORW~MEI!HM=_9PYirB8#P|{k0*4DBr
zuiakhwVORv99L;At0=RSdu&!qg~!f0Z1$8bk~-2Bgyjw(RfUy6e0zt4unP2D<1(bS
zP5L}Y)<AsU@$$&2Chw;_|NV?e&D;+(cP6@}yfdx9IU}hV=QM`QRI^GNqF)r2;fXHz
z5mx#N{uj(SERdUkZg7}tS%q6ChK#SzTR&Ip!OG#SsSdw<kqeVv9(bDZf~cR^ZdHJb
z>ty05T&gW|Q;7_HpoAdDnqFM_j!4fxMx+%4hi&()t(vfktMZ$uO0yOb!l1kb?g-2w
zlrS8gk>6Qt6@o25ax*DtsfO$nC!?>LUmm__iPqt3nX12$YwwgqzF7$e1kEi6gciVr
zf-O!a)0i34nf?#JdlbJChKCt&TbxX;W+Y2L`}NX>l!SOaa871KTeiMY-}wIaxW3fP
z!Vi4ffS+V4+MS)c{KBbdcXnzfb4gIv+~(wHS<Oh6{tqevqaHq#0k_>|v)G(Wc5`+{
ztsDjZMz0LdQdQp}aB9h<?4F#N%kyR;J;}^OF(406@mfi=!pAfCWXPl+4TqOedSm|2
zL1s$-voUH%20>|HV}c8d2o(@qC=F~(aA6Ul0)h*rfsF|+EFx4uaG^A?F~NmJgbD~Q
zlm<2?xUh&&0l|gRz{Ug@77;2SxKJ9{nBc-9LIngDN&_1cTv$Y?fZ#%DU}J&{iwG4E
zTqq4}OmJZlp#p*nrGbqJE-WHcKyaZnura}fMT80nE|dl~Cb+POPyxY((!j<97ZwpJ
zAh=K(*qGqLB0>cO7fJ&g6I@tCsDR)?X<%c53yTO95L_q?Y)o)r5upNt3#EaL2`(%m
zR6uZ{G_dgnaTR7>wgf@=hGhi4O8IiZcTxBnCM{Oi`6#M$7DaVENKt?M1HVsDR69#i
zCs$Au{~Se4Q+n>~t)i&WqiVe64bdM?{rJ^Wd+Fk;fvfh7K2$UJ{?mPRyVjk)>E<;X
zTQB+k+1;ncubgT+->u%UadD4w%ieJdkL;RpqPXmmu1Pd{jTuL$uU8NC4!F*IDgJ$B
z?4GATHH<y8Wb)U2zx>kE>w1V9rC*&J9y!)w+41e*U*gf7Z)~{tU1zj6*4H*qKG=V}
ziQDnWhA$3y{<fbfX+AMYJbZVxuXx6U-(TpQSUl(PnVYsd7awCgW2b(<>8a0tm1ou!
zRZe|nO5gKqdv3dIA8)8W;GHuV7-FifzT()%wM|d#`F7<sL)~Y)H`Tr_yt8NP*{-@N
zo`E?x&)CAR?iaTi7EGS7CAOw$fn|ba^Ut29>-%@^70+JLcVyt4`>vx0Tb|oGImaX$
zKA1Z6P5sb&({B7}^T0=o{%St)=A_8M!JUV%G0$RWcI*!J-@W<I&kqgN+Yb(Iy?y(-
z^^q@^-gn=l#cPh<dZc;ws0qe()at1VD9`v=T`xU+X!LbsMdNROv|ZmHq8-!U{^a=l
zwh!lRc`VlV+VolLBMY{DaCyn6-SZ1dKI^V3DCzC4EGXI6?JX$T-|cyS%_`5TqHSCM
zQIw_Um2HR5ohx{D{~e>pOoG=*Fte!l$>p8*oT@+GQ`tpTWUj=z)ef#2OKo4WdVImS
S!Xo_z-kQpV-nS}NJn%2AIqYZv

diff --git a/Templates/BaseGame/game/tools/gui/images/stencilIcons/smaller.png b/Templates/BaseGame/game/tools/gui/images/stencilIcons/smaller.png
index c1520a5120492f4c22bfbe2172af38a04d1b75b4..de6acb30c743b9944bd3a41fbcb31ee53e45ddc0 100644
GIT binary patch
delta 1529
zcmeCHn9DOkxt{4^RY*ihP-3}4K~a8MW=^U?No7H*LTW{38UsVct+&$yi|#1!wB5IK
z?Qc+Nd0>%{u+03$$KTD7`DL5m`dqgAlIWYWLC5>ie*@2${~v32<XdQP?_Mx1sqf-r
z4$Blh36*-ebbq@wudR}9oPTlg-8y!j$qT0cb-MqLwQTSHgxmG=UoF0SbK~PBvKjU}
zSf|XKX_&G5gsjJpEtmI|&phwgDZgy9|3=YAMRoi5*$ihL;^^JM-5DQlXMEDelj~gN
zQHeek#>Wbr;ex-`%-_AFTJeEt)ur?DxAn>`&pB+*JgPo-+uSc(>%5otiwefi{F&^k
z7T)FmtM}q1iNAAVIWIb{+flDxI{TE=!HrISk?UPe4zHBBoh7OJ^ASJCeS@p7YL5D<
zwLNNPGSxC!vHsrzW>vO#IWK1Nzp%^o>@k)vQgT>)@R^D?Gxs#+CoF0EvKCG?KVRc9
zZNg4Lo0$SUJ@T`w&1$yVvPdQC6)VlxTN@yL{%fm|+Rn;W@rDaGX1%&J{m#vw_0N-=
zL<O#>79V2iUZ38vsw6&olSOwp`}GIsRsFA(F?h7x=}OwLi}|O=B9W8Qn*|+@v)Hjt
z-ORF1!Qs^u=~Yh@gc#L7p6M;`nWnEjKP^X}VWH5`1~qTSH3B9sHTj(0D=b8LS4mwp
z$-E|{+P1>bt-E->mYSH4?ySg7IjWvqp7p^#(}GT|OgYz->l52|v*?uN^rj`MB1g17
z=o^Hr3v#|HwfbsEu`c_x^MZV~j}qOjJ_SmdXWn3n={_5kwR5VUtoO?Hb+%=%S3Zwp
zyLM}WU|XL>&XS4lJ6Ghc>c2AY<llKxxmkN0eC>A!H{X0C*7U4w(PYVvLIr{Co($Zx
z)Q#uYYp~3FqGmila!!ZQsw<q!FRHLLEfjvep!@FJJNi2<SNvXn=ZC1J`NhB7MR|*U
zJG?XAE`B8{^7dLChtJwA%Wf#L&X=FVrT*u^^^@1Dp8q#GV0{4@){A<u{i`_fqx_Y6
zlIX-zmZDrP1_s8~OlRi+PiJRPimwMHd0;}HQ#;Yt<FJFw(fHt{i$oo@JFHSxG$lBO
z90^<%!NR?C?S)m%Czr-wSfc1zSSS+1%~z)rCL1%Sw6s8!<siR+xw*QlxaP-t&xNjQ
z*pL6MD1Tr0oljtu>#|w7!VRk;-E4%!f?tMS{NAPaWwCg&#H1N3-G#e7x5&hQumAAj
ztKN~#QS*NnmuO2)W|W&)(f6{=b&sRX=FFFKzIQU~=xZK%e&jJ*?1Uc^UvD~{Kc|?F
z+r~IS<?-huj7f&qj}!@S-m_51UzlAqba9R1(@lpeyEjMaZ2o2Yll!k^uIj<kS%*6k
zI0KI;IJrr(iX<w!taj__w0PSd{exY$z9**MXeU>~lL!Y+EtTW^|Je8MHr*UNId76Z
z&zAi+z8&XyaGNzt^!7iyZEtUJKB#3|x20`=2y2?X=X#SZ4+Jl4=8cIlH>u>`afgv@
zUdhP`GAF%*Poy<|H~zKE<U%=j$-13;uYNE5#h|is^;78w4+JF627asRE-yFv{_XwD
zs(Sm)M~lP{POL~h$-uzCmgMd30;H=L&KP~aku*_Jyq<x*#M9T6{VBJoh=KfN?Y4Gc
z-066_IEDa=rMm}tn+!x69)>?==sU!*VdCN)6SXb6q#ra^TV9wI{^OrE=gJySLGFla
zrMypHJ`-RN6i{Gda&c(j;1FO$VyC{GSK#x0?pyCqf8|%H>^Yg3@1XkgpKs(jMJA?t
z7Y7!Wjs}=kz4-pG6K+)<R#sZ}<ao;a=Rf^jYP4_juU-Bng8${-13~9(?1HBiL)1$>
zwMy~(H#4|@eZ|inO>c;`j7ka)ED$GbeRuzR>edX)&p+-=pPEy%Oy{`(BS_lhROyMB
zn`W*@vOgq$3-5U=InnO^%)R=nVNODK(Xs#hGuiL|Uud&D@01XR56}K){Kld2WBzX5
R<-mYt@O1TaS?83{1OPxBrsV(t

literal 15374
zcmeI3eQXnD9LH~SDr_+D4FS!(REbPz@2+dR_0n~2?dFCQ#+b4hbi3Z&w#(YPa(AQM
z)JQ~;5tJ7<P%*}d8kB$u8i|;=5HldS;7ewVN;GaUf+ACl4n>2{_4QfT^323PpXRpy
z_B`L;_qpfu{GMm`&-K=?xMz0$!hC`tX4lnv8^E_<{LHup{0@!wH-fL3q1tARAPR0U
zesYKxUYt)5&RtStliuW8&hkpo!U>9Bv_yg-pe6`cMI^-WouW?q#db+9H;unPXd)${
z+_c8-qkSQd*df*SsN(9L6^(pPC+`$Y74CdjgarmcQRm1=Fd%Deq}&wsWkGB-QzkMh
z(L2jcmBxT%ldqoiD5^->Ep{_cTN$#{X<_U(C&Mfytu#|YF*Id$ni+<*m9mV3jDJk-
zd=R-*p^a_u*2IScf0dg$bUnmUR5%>Agi9=n+D<V}r<0<sl+|hm3bWQN>s-VvYq!Tt
z5<Xs0<5el7ONvYyzMNm_(#uUIW1!?GKCfUXIgqTy*#U}FgbPuOg{HD3`FvMS3kEZ0
zYI=j1npwsHwZ`s{NHvI>(xvhukl&u^7BszjJ(yA)(KL*z*Nd{A(MsTxKA|o(5Ctvp
zlo$|$AVmWdn2d7?btt-`btqW?CcCp@)TOp8ER3G4X<|gml4kV8(xNpLTWS|5WY(jK
zoUW*iiV|?g%C$am_oT-|E?y(af)dt>T~xX{RWm6g(aY(g8`QK7RI{13Hd-0BgkkOW
zB{aj*G-MJ}rg``jL2B!s;$da!GS<$(9*{EK1MES8)46H6z}m?^J|9~rYdR<MVx89w
z=5CQBfwgf?r=6kO%>FV)Fw>mPZstlIwAs%)Xq$r<95$;zI?2iDQ>?uT-(}QL+*&ZK
z%WAw1N43*o_0%v-wXLkGtfbOox0O_R9E{WMNZ3NDQ*A|6S}zJUsuGND?+~YIqOohr
zO^I!jJP+bE5Z!mIlwqo|`*CEypDC%S`vK;zShtXMrllxnC^hAr#E_b5T1f-+D^&@c
z=v)9|Wvt+T!JNSYx(VP0hN+b_uywkj@r`*K=jv*4-Q?CpM?jk9!X%dmoMtS?8z;6~
z<G|v&sOSloXiMExEW;QmCdjm=(<<L7>Dk8!cZl+&?Vh$(V^&dBb`wo$)5Dx9R<?s3
zfjER>hLbb0JM$f!+%5`kDgiCgke=eAj8zLrlNT-4I(aP<^*43xT>{UxDQb|@-BOTi
z7paik?xIqSsWDy2{{XB<2`DN!%tUvIi^|jtWf^C`QQCkK7p(`zMNMf-*Ebm(KhPD`
zms)A?0Z$v?6HkS^(^H$ToC<fRr=~LRlO^44jgOYr3}qSrpkgpqgNHKF?XcTR>@F(3
zIX$CZiim+GuLRCg&DbGeYVoA>o{X8zSu>%YcxJ2^pa-aEt;AZv;~97|q>_(@lglW%
zG5_ZvHKqUA7`DTMz%-CC#)U)#3otI21~SIDkceOb#s$+r#uyh85iG#CU>e96<3b{W
z1sE4h0~upnNJOvz<AP}*V~h)l2o_*mFb!mkaUl`G0*ni$fs8ROBqCUValtf@F~)^N
z1Pd@Om<BS&xR8io0mcQ>K*kss5)mxGxL_K{7~?`Bf&~~COamEXTu4N)0ONvbAY+UR
zi3k>8Trdq}jBz0m!2*m6rh$wxE+isYfN{YzkTJ%EL<9>kE|>-~#<-A(U;)Mj(?G@;
z7ZMRHz_?%<$oPu5@>4HciZXb^G7Mg&TrzT@0=$Mv^0f^<g6LU95F0iU#GjYJ_gRAI
zq6y;1R)S!kBZ!-ooh?H(1d(&0&Rf|S`Rd&1qw78-Z>;`w&a=5Ay$|M|Kk?eDefsvk
zmv#SrF9$}=Lhfxv7r!}hY~i_*%7#0xJN29Gv*HUk5LFxCYc9DVd2L^&6khs!X<%^A
zm*Jrwlv86L{e0QqHvZCBLE#){-};O6+kKVAkGjjYQ3CzJaNxIFzujEidFdbj?%uYY
zgZ||Y&w765YquObv+=K4iyvfeJawpV)e(N*i+|kp%B-XHM+#R}E!gzk)rZ!+vi0CK
z{F=PF{>Ax^9k@JHyM?@G(aEjlOyTGJi6sNJ4}Wp*8_Zp{dTUX8^OC)`<7c|Qdf&9A
zpyuPBw)fYcriYK6p3^+AZTQ`@=bsvxcYo1sheJcTd2@|R*x@?p*?BR%tEi>**9EUH
zjW@?SpCEFK>w(fSt@&{O@#9*ve~dplIzLY1?X^$6I{fbb{x9}4jLXkZMZZ5{+5dU|
z%)M`UigvY(cWx=}Jfq(9^w-1d7HprfY2LCtPr;(c2cEqC=qFXZtsMiA4I{1Rax2b1
z)N8u7VdIXxyLZlBJAUu?EqAWm>S<l-*_~sEy!1Quruh#nzHXMe4|ts1JTWqnyJ_ML
z<xTH<J%!Iqj0}y=vygc+;43G0M$VzCimQmt)=dRDg=b~sjorHH72bnYt&jf;6w%xs

diff --git a/Templates/BaseGame/game/tools/gui/images/window.png b/Templates/BaseGame/game/tools/gui/images/window.png
index cc07494dfad42cc22417f8ca531581c250efb279..d9e9a9d6d6fcb8eed44704b395b0d7edd40b0a4d 100644
GIT binary patch
literal 7565
zcmZWuRZtz!uH~QyDDLj=6nB^64#l-N9NgWlXmNLUIJmpJd-390^!3i2H}B&mlVoR2
zl8@|}{H#c2MQJ1id;|yx2qak<3Dtj5<e#|#VgGrLZz=W=5O_c@b!`__V|P+VCkG2F
zTXRwuPe*f7a}O(ve<kbHnL3GtZ7GtU^-%_pN5;IkQ(kagZ$dc0L|JS)jWKo1^aNtG
z%U*)Z>rL~=&-W{~&jEj4T^kd6PVTNIu9j7wW69>Lo~MO1kI$~pp&8w`j|Gt0?J?3!
ze(%h+-_+~f-|3tC1H?mTYHmLv`|-D|Qa{Ce&w~y4;F>?4^+M5aS+vjYo4$VBQ$09>
z{%h06SI<6w4c0y$p0t6(-?CUd4%{94w*B8bRA&uw`1~JOYX9aTCakbQe>CU6arzxG
z7kml@>=?eI3-b$)4E%IV!&#ewyJZ2r5W1f}-E^qDw38qA7_Ry2s|eSu*M9m&?(kOT
zH11q_O@=uh&Xjc99d_>r2RnwnHc#gE?+l(heR6!LZ(LB?L{}r5!u4<*M?Qn*m{ztx
zuOC_V4TC4GEN}OI=<Y<7`Oil`Jm_|R@^`1r_9LWh%CqC}{OPG3+B)ab{~4`O(@B_n
zAD5JHko%cti1JqI@5eXCOYeMa>kBGi)K1m%t^Z=K_<2i*zCTS<ayq<{{xtCMl8a6-
zYSeCAV_UazqsW%{s-nAh#Jg(tZ28vI#BlBmDK^-Q5uM*&*tiz@yP<LDb)OJa^}Dpu
ziKKwUtd}b3%_Jpfe}=NuOF#1p(_Q#H$v-?02R%UyIdrjUR#r2H&f=w7Rcxy$-sBry
zX`;1t`Ek6dBJXixs9IMDx*UC5vZ@?IR~WucMcc3MHkDm}u><POzS|csEq}k#YZ{qu
z<IBAw#Pth7lg9T<R*@#~RTcU=&2h)rIL-BX%fLw5Th%#UQCZ!+Rg&zsX?3jcwq>_K
zF_P=JFH4i_bY@lRKa=s=bfKj4%IW;cXLFgv>5ox7lR~0%;7GTlxCc!m%S&M@#K&%s
z3_w_C_|eji+r?g*wRRK?Pv)tao}6`<%*Kw}dUp!GYI{v+6F!<k-SW@i{_L2<E57VW
z;4NJA9osa#d(5n=_S@sygf2&nqyyqv_K1(XB<`1uEcd5!rC#pJt|pmzrqb6wI_{bT
z@`t&XHiI;e3U4NfClwn*IA-=-lHTqOrUfdm{bUILR8Q8m{4^z=P}QHPvF9I_VIo{c
z*$#|I8aFTt{GG!^SdINy@a2v9zDS>{y+3sXI8rPQIZ{3}a)zU26DiQPr&~$-yMo^-
zF=zc7Btg#)sBe{9jUKq5!=_S)!)HIKt=B(TKjtdj7noaO7f-WFYIWH^7QIxf$yyE<
zRuSdleUN%{*jm|~9C#-a9yD+)&NDYv0x3_E+dJ3D`Wfgz#oZ##n$n^~QI@}<B0A6_
zY*t5t9vK^&IM<Idsy9ayD!SKgVdu-%!p~mpeW<j=ez7RcvS3=yYDQ|wn`-x~TPEPb
zvgxVlHY#|It)Y6J4P2nT7@=hEgRC5vv(IxDjtFV_5PI&obDHtZ)qlAQ{q!?orYIVM
zmya-4KD8Q7{(F07{97`AQfEHHJWIC3*HUw@grlsng#m=DyJXzP*f%|JFLP6?S6a<G
zv&LSp-(AyI%ETdqRAr5Fc2gu$KJTtu+z^dpb*!6O46Qb^oz6^CXJ6luq)&*zGZE;?
zE-29S>LG_+#_J<crPoqT>66Nysq~)qiyf2bs37RaSY`8;1$BSpg)%>9)@@yreZC*m
zyYKXMc|B^ySFW_y0Mvy0D}k>%uCYClX~DQ}{bDo(M`an&HMFrQQ{wK|rQj`e!ItuQ
zg3@KAuCAe+2;6g>dY84RY?D9dU%H8<>I#>Le4_MM#>#^YO;rHD`x6_{-dM-^u{In`
zE$q_UVbD&;L^YCS%omu{^OYhJV@j;-Z>o*oPax1xg%B9`X|i=R-R`m8VO7EPMBllG
zMsoy=2{03XE~}t2lbN(s24wM*C5>^?!U}hQuA!Lnk~<25446yLdWBU*a^c2-lH&5K
z5f|`(@G?1QaVZk4=+Bf5!wSCe$>_!gBS!)J3UB7q@(8P4y!F;64%_beo?uXag9|fQ
zN#u;%tjdyQcS2I)3K|-AxF*+&h-mRe_~T5HZcBjXxqa`lIbvH~O+r6}1AXyzX%<Dk
zs?biTQn1d+m%C_kE=M5R!U^^!WLiF^>rrZUG$nNz3{$>4Y$G}WyfwTY8JG`UyCE0W
z-{Dw!eaBjea5R=*xds3`E|kK&KhNj>Hk&|>ljYP?Q}Wor(xOxCA!Kig<_madXB#Lx
zpvC{D8wGeKOA})={%O+DXllkfDZI(R&QE;ioB9@laSwpF(&oX-1{t9^I|p40{uHtw
zb12gm))(G25IQpfn5+Rftcx!RSYF<oP(0i-K!{*izaXr#C4F@f`ygWH{B&=9ahL9}
zXcN1<b>t!gOzedk(}AlRQXA`*A1X$GI&$Lxbr=}!Oc5xsBW4YQ#viGgy{?2zl3jEx
zA_Vv+0-gFWyptYSXHRe2kPKzSDj67ZYiUgIwh5Udr8g8pFgV6V3bV37E=}mHL77We
z(YBnoPdQ)c)ce}DkQ#qg2FjHzz=n!qm=63)nI}9pM;?p93f#|LelZ3Rv3iPq3?k3O
zqR}}1E*1=us&l9n7oD?6x&+?O!w`ck)^wlE8jypvXk$;M`ArFx3y2rfL$O{oQ>7ez
zxV*K=hT<5lg6H{&EyX<vVOAy&nJKWW;xeb{`SQ1-DaX??TaP^$w=x(rdSt^}zcmDd
znaMZ4q~aU*Q6aTQrluHcX&V^Di;SwNAQ$w4zD92IbOe#ws8wFO7EQ0Urf1>s5hTTs
zexM+!(h5ND1gHlNT)^!^<*X)=PKQW{X4!tPDhpeklhQz?2pPdevJwY~vfb@Js;-Ee
zkK$Ck1aENL?6$C=hpU0RMBp7?mlK{46Fm2+o9>m2MI#m>8DZejej>)MEFI_z|J8n|
zPnz?D(6<b+gnXJt%?ml9!5Q77MHYX;JRXR~)J9d6&Vu^rR`o*sXlZaILY2nL;?VdQ
zfIcJcm2m_Drgu#ybF|5Q6N;0d|KP1uaP29zp0Mg6-xyTA73RiT@?OYI+|kMU5a{fS
z-ALTVA<ALP?w0>LxSRI7ednBei=_<OBwjm+(N^NrvDL$QEboCAij`R)4D8+!fz#5(
z<UEIRUG)~VRb@CN?-n62s&oc6sW=LYWJ0?<iDY66Kwjjm4Uv%Xr@xY`xKY9f41OlZ
z8i`7mbXxK)A%}g$XT&6y7^{4VR=|upraVpKitHfU#h3;vYZh~7$LAgBI<?(Ea?>z}
z7DT6UL!14A2{;znS{*GejC6}4=&&E-3SvSThZw%>mUr>(qWOLzJqXQfi#R5&Hx9{J
z7cnZ>1mOG<_l=O8oU5aj+mLhqJRLRod*%^8C(nJ_Hh?W&&(dFHfdq&Jh}RWIEv5k=
z85~0hRCxZrg-6TNW3(BuhDw)GBqhr;C#|lOoFmD*6y?H@U@;Vn8en&A@Mp#FnkdNX
zmQu-^)t5m<fV<P^mA6DAV-<ralo1h=@bqXDcR{O;n|QQkf{I8+Y|9I>S;(1lh~TYA
zjhSyru`g6yNkOCGT7*zwNIY+f)t%tjcGm)_qcr9>2(ER<2*UB^MR5^);n78@FF545
z%`dQv9F<qi(H33JlA-CNuN}2ghg1z)2bx4d{;F_^Ly&zoi9Y!zOF^sNBEecoq$1OR
zq+aI=s|?*a5Lm#28b-7#HLs*?{LqA59fnD5q|M5Ms^Q#(y_l_p)y^AcgXIXA4bY^X
z$1^-<x;}p+fNe;Y7#nNmcH5+rM3IQ1QN}J?9EHWPHe0q)ye0q%xK22+$x#M~le(=Q
zxQICQK4S1fyzPviT7AdIJ1OoWhe=1a-Oe*QTO;?EQ3BNM$0XW?tUys@OxB2+&-L0(
zp~l-Vll_Fx#}}0+peS<Ia;+FrHzXp@D-8_v%da}}Xq#w=41uZ-e?|2Lf1tO@;ahFC
zRhTxXb7c#`F#Q>KUp!<$Ob>F1)K(Bo2O!4Pe+1?in%S|dPoFg*F{YxSa8|qM!>i=z
zUlI%iYzHRyTG(QawU>@y4`dZ7Y@4N6%-$hoGNMYXsHc-xHpg~I(!<kkw<L)va;hY$
zu%yg72%nPH^%C-Z(^pWiGc@4p^|NNMn#xgRj!MD6Sl=ji3956RD-pLQG-qqb@1~=q
zscEsEr_Il(+=uzo!2lz=n@BQ?I#JAq?ozpfK~()H{<o0!FNp=JotN7;md?BJ$S}fw
zk$#&Z>%y-%a%kQ|Ok*rKy-xVVf<$-X!gp*Yp?K(bkv+;*r`gvwca>kQ`~--u@7K6}
zku6Nqqiu`0gw(QC-S6yt&LIa(IK7(DQ1V$pe)6#A2%e)mD0GeX>L_>52>eW7t-JI%
zKPP<9Zl{$msS1-o4TL-r`Oy~Tr&MS|0kpq%F^SX#CQ_TY_0&z&^|uavGK)<zFR!FH
zwH=P4?h57Navm_GL*~ru&UV)o+8~(^2`P`cu`q(dJQ9gJk*L3_Z^z2Dy>TPH<Aq8D
z9`u>&6qa2W<24Ql-o`hl+H);E)1?|J<N->m4_wpDo8V%-xjMpVDNX6g0}KHH#pF-s
zL)^ZkF@|h&xXv#kEB6yE+NA48yOF>5&S4ySV64M0f>rHgxOUO&+PkfVnGV5@ds@aA
z$#l&za<uW|*$rt53^~5xNEOE6<^@4H+(CEup}}C8j3$+IF&C8V<we@uJ4eXmZR)t=
zkjwbPH(Jl}ci2R;@B*}Oy{!qVDEaMD*AT2-#aax_j21NkPuUU(8|2V{vvK5yC=XlY
zEiU?({D(PKrY`-=`Gk=0Y9#2_B8NU(awI|E=26F~q`iwK2Rt%v?>&h}U<RKDdqWj;
z8FA*Ys?L7*A9!=&J&pu$+G%ChpVnN(CThWp%>|_<TbP1W5g0;3cpH(Q^NVt9e9U<W
z+Bj|5@s`>d@K7-=J-1b-ig_H0%o=HyJE%ZbFr;*v#Rr77wDopA%7rBLSsnN2aE<h(
zk9P2UegN5zeSs2412Z4c(utFrcwv91n*O(~cvvMDiJE|%Fry^c-#$GNh<7xuH@cue
zv|VxBkf5i+uiDnR5MId3MaT*q-VBsuR<$=TV>MI{zL+J@F+2=Cm3s_W#nt2od0dML
zg|h{x?T~9Bs72T=FeE3d$!#LdsXTK8-KwJ+NmBQgP~m!|TjbE$d#Ya39^H{JBYc+V
z%yJO(J94!**@yMFaK+vLN~#(1lspZN11id0Pfj?BFs?1NN!g8Tdbqi$;_otfKh!`I
zY-@W$oQsW`J)AA|{U2dYN+pSLc&z^2D=TGGT^Xlk%uM9I)>6T9N|pW>_e!}Ke}>(o
zFIg<bEHyx7{xR6UhgIq%y9Fl7tY5A+^U?(B@ZzD(to1$Z6iTZKe1Q@A2%Uq$LNa?8
zNKuPlbQ-H2yAaOMBuR&8ZNX}Zv0CgazmlovYkOM0r*aMhC46wVu!Bo>&BDZXR#>g#
zgE{%k1LG63z$xX147aXDbDaHPUcO&Qz9G{Mrh@H03)O{a0s*p;0{P7*j3l6;lukd{
z%X+9>%pglf+-o-JzuJN80R$oGhRmjZ-q|3Ihi&@xrtXQ%;!K&=4y#mMLyadND1%z;
zuTTQfn2he6^!={20o7%1CErCl%6i-}UfrhhOXB=3SVU;6n?vFsWb_&kqCOx-@!P3^
zJ`|%W)pL<Y31`Lu7NmiaaK*G<LuS-S62D+Gws*|5`e34$?+JQt*8%hGbFZLyaU8uL
zHXKpgmrVlJ%e#&yC1$JWQc+EuWEBHYiY`?6xOb6H8XF(^E3{YX1!xj$D}>Ed8O04&
zmUdQ?Aa(#_6#jOk7UpNkS7%_<_xbC>`gn9im!e<UNf|qG&L~y@plcpFf_w>DIdjl)
zXvh<h`!Hab8P{Fx+y;5(SKJt@$FMb~6F(8dtbm`OsesO%`0PwZf=fT#y=usz*h0(`
zwvME@YAB7tzk5x>kr2&+H;c<v`OL*KjA=v7JsTpan9pd5m9zR9=iimEf$cra4GnwY
z-i|BxH|QIaPON}(sP42*%gMOw>p5Yc4=lXH{RS!hI0vGZAWthjI4r<Ow$)J7f3Q&s
zz6e1`=LG?bJ;9;z(?L&C{``nt2%jI`sk|A1IWJ>Pbe2^qX;fCC{}e@}`=`j%6W$3y
z-}~N|q8bFBePU?jH`%1s`^>0G;$bea4m!QLx55*9x=ksxK>rrejkeJaFAmQ47`;(T
zd@<KE{azQP$Pw#|;L94W{`&#4YYh*2U{Y+%_V+VC`cw%UTR5&`MwWY5Qp@Ql&s|~^
zfgS2Acb3j;eezBnQVAhin`9fnW+pL)C33D@b^J%RAU5Hzg=-yho;M_xi7U(=F((Rn
z9zcs5f9KwDO3lmRl;I8m{G5njbHeObh}$mdb~Gs_f>jtfI`Fm?skjU}J~DHOmG-x2
zFnhH+U(wW#TGS<p5GT1NTIn0Zx3%=FWaJ}@)*V(LzjspIEb>wFF%hG*6$`0qaAfhg
z>>2tf=(V+v|8ZoT+Urm;s%PqLWBRCo-}SjoNpr_8uzDlRD=%EEokU2#q!c(wJHsIW
zjBPJw=_9RKnG{oms}O?4Q=}mabA<Q7{Bpy;$Ee~$z?+EjxG*AnwN7Yc>b3T?O~Wkc
z1!aaw#Jfud5qwE;j-bw9lP4<FK#evu!$b?=a-XS&DsBvZYW}j@g0J}ZWo^FXRUdkk
zyZ*ze@cQ^Q#ACv){T!<b`Z51B{~?4QB5GR6R-sT0(hYXN^-A%GPH>iEQvs6+t0h#f
zI0MFu#du@+lAp`}+ZVnN?eBQ9c|Ta@m(8TVs@0&8uSYUd4?<%qlb0b+mJo5ZE1G@S
zR2;%yhtNm;r3{_k`D%|dDd~)L2G14RMmX<qLW!GHV?bCAWmktq)%oy@p(o5AgzlD(
zN}kiof>+@o*T5-2;dX2WWn6pz-npYFM>RLZQFSREz?d3cjDF=cAQ-*y{_Xe7Yt9@_
z;ZX^utq?|xQ2PPHP<PJ5k{a$u9Jr{?xBvO^eSzDk#l*!>tM8=&@)X^{x%1;GMI@wx
zBQxK_1p|rY=%8`T-9X4&Iz|({y=b-Ka`5W9M3;HOaeUP9E*`p8IlV(j1O?QzRQRXV
z`>FcN{+GRQY}1r8<UhlP$nu`Ew|GpX=>(eGhh+LYxn%}GCe9zFzl8><m3vnVe<=9B
zdAfT%{kVkn@9F8_U%rOL^Is!Fdufoq^G)*i{>gfq?fTg%?abXazD36LJo5zp>KG6T
z))M*26J_-rjnL6Qm7#G|4c8C{Z0?>iQ-_ZeEBicspBb*kbMVRI7krgI!E6hZ$Hz?%
z7oQ-n6QCv;K-OJ_)PlxDa!jxuU&zBSWl{NwR#a1pRrKQ&TA3Uo!?IS}x>tGXBovPz
zT@GsRCw}v*3zgYIxox`(j2X~ZCin5G<71%2JXHE~nEa5yE+aJS_d(Cv!%qb*BzrAr
zo7LMAZMV5e+ETYtvkQ+7g>nq?Ghk9j1h<2G`7ru#h44$wnG}9c=(VHe>8lcN8~iO0
zshgV>!Z2yU)4hkZtZTg<rn^$?t#<nGaxgQX6ZPE3&7;)e!CdUVtUi9st3mBn%~V2A
zhgV36UqHUIvA=cPeJ1%tSZ3m~^ez*p|HZjr>q^OfCRfSUPw>v)%jE9r*PFYN?Z;N)
z=Vj!Sa4ZbX2laB{MsvT#$JP|RZv}eSrNf3pxIf<u993CCu|+YoP5~OB<^KLe=Dhl@
zDh7Uc?7jX)wwrNF5b12x`@N&y)8fmvzAw&x>>T6E=!o=*=0L5<#f)%I)y^AtOR;|X
z=WxqC-Q7%U=qgxDo|}8A&k2l;rZU*jTT1P{LInxo<pI%5)&$QWd<19X`byj_C7(?O
z(vQavf$}-+lgAbk#bS|cWjjDcw^o_qJ30ujj4fuSXMgX6w5)7>ltOBai-W!}&^Wqg
z0nJkvlw>?lQqJ>7$h#G9&<EJxi=L#@_(fn433`PZfVHBNhQvwQ*%&fw;7G4vemBA2
zz@&212wueI-%S!Tc-5ZyeQ$ZMdfB4y5D(_Iuh^+2&sDj%9ChCDnIx?m@Lj$2;)uK_
z0qr%K*u`=klJ=NM?jLQzc6sLWPM)lwzBfhA5Wf)k3#PcO23``Kw_ynKgUz3wye&}0
zJCUycjP2Y=)OoVx+dl+2mX`H*xnExjgm^osRtTIUABIpTY*(M^P$g4fn;>PP1w~A@
zAr4W9yAfJH3vPy<wG0mAXLdM;o`uP8Bb6rIYbP(I`Sg)@P|(FcT6TpA@v<ry=zQ)3
z?DNc<LH|~oJLz-B<I}8=es&7Y+`HIiZ5~qJ`WQZuEG3|>w25Gzfl@L_Nz7ex`pEy0
zClkqXW-IX(tHTw8PF?VjP3mh7Q>&gXe0p7RK26}WK2lftqy1-z*Vi2s`B*8%feRIY
zgwshR)%qbzKJ)6n7<|XwWs56<<-85Md^?~uXZ258s{=Qt1>VC%Fz)AV>EDL{>mQuk
z&;E*{7CuGr`124DfKV%Oab;O?@&DyS{xKn0z6pXd10sY&hHAwHSfUIOd}d`qMxyG2
zDizw$h{e^j6~SZ0hO<RvvLFzq9wM?Iqb8AFmaD5H7IYs9DmOQcBo5t;zihr_72L?X
zhx--i2^qCQvLwR}BcMV@N&p>O?Nnp#DT?{N5XTfZF|Ax0BU-kJ(D3Q{`hj_{@q6y8
zvkL=W5`Z|tBknXzvQt!`(dsnoDH4j2g>LY8@Bmgn{yE{iVZtHH85vRFs}beF-5|h(
zZDr62qp>p|T?qpYOQX<-?69HVGrI9RW8;h9U&MDjJE}g{jDZLvc$Gm?F)2J4Ok*;M
zN~x$wo{MnZXE-AN7(Mnj1f$>DBJlK-BPbtmJsq5lYDxBq!e5$tRv$-zyBjdpSQ{Tg
zEf?$XyS}hBO<_IiFc!kHwH!^mXtRw-dV1U(o+#i=0BnxSSUlmFoZ6^G;M3Qa5{_AS
zM3<VjuB9i?3j}3(<srfDE-LPn%A;4byF16z<5jwszi{J_Q(uCI`Pe_M3f4qUTH;^y
zf|z7~S~dCif_IeBafX0E9{i61QW%g4{(*2VvI>%Lhlp613~*MUB{>KPNLN`2QFV{?
zi#0jL0an!E8&C?x_3AxpXHCM9(3bj^V=l)EZIHNG@Cngmg{t)%F3wQ#^A!>_C;HCJ
z<6sg#gGuqe@pRi*)T(jo#?kgljb^5O^LTgd&IOk<fKfuCs<}dA*RRG-cS-ojuja~o
z$#;F`9lsaXR28`V-6n=thi!n>Rt;#kVIOA9lm1Y1-cs)9yW`Mavw;neA$#t(LG{_=
z1Qz$_LWH22?3n`Vuh~Kp_xvHiz>I4lXax@vvD0gV0J<Qq&geX(EAnJy5@?>V6(OQc
z^IBg%@I<%7k`ko+4<R^XzB^vvLV6E$Ke@&=2e8|`R`i<bbsmVQ(EO8Z@X_ZBS<A5;
zIb+k(c6c70$G^#a457-tEJi1=42A%Ostv@YAoW(93YcRTZ)cJ?d<79C<tp6a026>5
zX5TOpHbQ#FU**xo$#Ah>eAwL0(>_f&Wmf+d4gqnZ=%3Ca?Sw3w>VwX)9*{p`MsIY&
zmX4r(PZ<AtspJg%jJS6KdkQ;q0^`))mj%ha#moy+qs?7b4kbjZKy)o?6@>Nbl>F~2
z|10Xei(9+REgdew|4~fQ|DXXUym>ELCY&T8Wq^OF$WpMq^71Pq#On*WMOSLul`-Of
zd;h<8{<4iAEGT3K=<M<zy*mh=^hMGA|5g7*(oEGqHPe{>B`G+49UBC%e_i8WHwbt?
z^q5o0Z|?}QPak;VZvVO(!RWnO`uG!$%)NG8z3c$M6MU{y*#9>bJb#09{dj)MPowYs
PA5>OSQKCl7DCmCxC4WN|

literal 6786
zcmZ`-Wl$RokPRB3xEFURMOxem9yA0>ky1Rky9KwF;uP0Hf#Oi0xKrHSJ-9=lNbmdR
z?q+W0?&iIHJM(sD|Lva_4bf1-!=b_f004MkWqIg7UFM(i#KQbXy;V{i0RXaaUmZPn
zsHqo&v#S%##@>>_-N)II!P46X_Rq>vMTV6wi)d!}Upulobe}q!MK>6*?$M``sRrXI
z-LZs;F)G<-R1jz6x#O?oUf`Xwpe2cRY16L#eH6FQ`u+DM#I}!z&{`FexgFj&Zd{p}
zXxwrB0jD(r@w?R+=~Y=AC!9R5?C9U-IOP9D+Ze44ej#KsF_PmnXO~bF91>XBGC%(P
z9+8<N?SQxmY+duWY6yI$dC{d8eGwuI2T~kA9p<K^mSJ(b8*Oq)`xp%(A9~-@ujF3v
zdl5Y$0PTTDZn$TAWn`Rl8hdRO^<|?-TV>0&+oNN$RMo&eGW`ibHoBGg^mxGuN0j@H
z!9C}hJ!Z_{4u=k0NO4D+F#eTBOQ{!sN!C*z7VpX%mceu6hP3_oaO*LWi|qo#%9ich
zfNaOw-u*`2R$uAp+R9mo|J4;6>)|x5G48#7equCu4>k4a!C)o3(MF1`Y^0UO%lEg*
z(0;1s)l+xi!@Xsmo6g?Y;-B8=S`(v>H+^rDMFVzuh_}YLz900@rz85{e<5aQFV%!c
zQt&**a~Ks}>FdcHb3)Z447baQjP$Eeu!!8)$+uBoRxgI{)YkPqY|*%s?-bX$(ihNM
zbh0Krnx#lZ#Dg_%GBS~*US~Ih(y74|#0l2PvbNR?iDc%V(&1&v5Mj>3H0V$%K$H81
z#&v`f@uAlFM=Hb&%$f?dwJDm1n5zrUL+u>uh1XH}zN!sZ{9H0P$_D!#$ILc$xS8G&
zDbm>NXerV<T!ZgNM5agTM#PqnhpVcC0CktI$|@WFcxFPET#B>37CjnQ3F<w&quI0l
zhf0gHpK}C}w#&Tw4>?U8V;O#yqwDeq?UxCHJgJvLVI)~ByD>5M`vcxum>kwsS&N5e
z*F#yZuuKBBupNC%sOwkl{sEJfvEuDDH)KMS@f9rUG%!Q>ul8OH6sc)3#^I6s7HPEx
zA6Po1aO_c!Z;nq3i4VSI9vyy=gsBCbtsTP-CA^I}8P9s|`1dBiJBf}YC^%V`%ij4e
z@g4E;XPutvHUOuVOc%0Vnu;{`EV})Yv3NAWS`V6@fO+Dk%bmDoQ7OH*9+@*JiEC&x
zPB2!-t3R9H)Exdjs!R%76b(Bi*Q(^FpzkhUj@z{pU8Li8lW0ig_wdW{yW#J=SvcNr
zwzvAI<~B8hO4*;AJ;mwBZ8m!-RSpj~|8?V7T(3VZ#_ugVu4+Yd*%Bb(m(T5bl5g4V
zA8|5yvLe@zi51&}8Nh#a$5%_QU8<UL7qM`^<e6S4+ReXUy`%=|IW%`rLGc|(VR1;T
z-JhH+%dcKeclhNC<4rLePm=lcD$A-8Qj+W-_>OvKn;a~j>D83{$JVAd{=LwL5f?#|
z@prG_o>b*akX8G3nt8-2L|Zre`^Zeu4POaE0f_|Oq@fCTmf71kPD-m&NWEBPBGaX7
z#Xse)LY>Nl;za=Fs$RQAK(LoljY9dZ{1c_@1W5~(A5g@*aO10EUh7cXWVqW#iy^78
zB2<fCS3NqMCkbq&mxDjV@^XMO(-$|CPxBJ$x?U9bD{c;^s)_MDLItxC#7HM8?J%*9
z@=&w^iPMjdfekr2QB1*wrPps`i-dlKlJ(+z$SOXvZc<@)pcv&PN|z7lO)@GZh3aD^
zElUL9o^c@@$!<4k(<yUp;FK7&zr5(&h@WJZgq?%o01_E)R7x~j<v39VMD=*9>>GGc
zOaSlRU?wZuGuaQ9*^E<7j()_f<qkyEZhjk-qfvMEagyT7J)<F5+OF4<VB$O5P0bEi
zdH;%vZCNu@16!xvECI&Yd%anctbXLvY&3N-J+WHU1hPUSlEQ<6a_L_Qr0)LaxgiI=
zW?%g^(Jo&&r7F&HUY#P=gZUUu$`AlJ(3;b*D}Qqp#GIk4BJJK=K3d}hVG6P=4<Joh
zqoF=`*G?1sT&ozl=2|x;cte^@p--eTiQ?D;q-q92NQkXvU`$6Og_u)FgSwU_ymMGS
zdJy5hXn0$X99p^Jd#A*ZQ^N$xsl^$hfMMChj4Tu`5Ayh+8P3%XU!wzAi#&9dFpjMP
z-NrR+N|LHQ4X&s^Oc;9Al7+)xr>v-KngR@a+@V^wzuFRR-Q_`TMEY4&xi~8VaP95f
z#(v&TwY+_5!W~Vmb#^!6FK1oFGkaRp>$>$fove*Mv$=RvlKk%l2a?(|CH~cqBgMEg
z6dPqvJ+K_@lj+@H)W3C3v-PJA23LsICrBg9+1(1UFF}~&XirkUPLSuGfDEFjKhlVO
zQ36iO91o}Zdz#gcRLGK?z2jrZG8?99rC54LZ~P&ohli(v8mm|0H8k}>@)c?jGr(G>
z48S0VW*bO#+&*m6Vq)<oo7eNH5Aw}plZG*?Jmb6N^bbdZj~e3{tGeQ8`>=@gOSv0!
z3CUc~e2+&o%*)Jiy9<To?sNQNT{*wLHh<5^YhVZefXg*A4iH<19V?t>a1;}J^ljKA
zHD%RtY#+oya@D9aBPrIv?<HSpsVNAfFwN-*U9tH&n+dzg2Rf_U+YI7+rH5U+%LjV>
z=@yiViz#gBg&C|++}sr!@_E8nIp$^&hl3SeUQ%mSiJ9#%J81mHZv>nl#Y<pEO(2xL
z<{Lq#_GLE5XCGo2S_94!<r16^%XmWg9>sEp2?;BqV}-UTpUl2nwMJW<2x?W6ps17<
zDXizHh|fzo+Y{%R2=BktZ%%A-!od6d3yot~C=?lO4+`#$m<%X}L7Wm_js)8Q6tcZZ
z>q%oi#4iEwD%FOl_H0{HzDSu>)sQNJ2)rYeSZaSb#XOIJYp6fs0wTbLT|$W@F}9_(
z<cl9tcI_E<D%(ysH^F{;sMSZ9ZG;~0>(!NHyuYMCiacN7WOIB~n3TXW0f#q<lNp+J
z$bbF}Z)I@8s7)o!|3T6w7fRAlS$p;q5d_?0W)Ui})zCC~-D+Sni0=C*l5Bk;Augn#
zwJh|d7FDpLdgJuIrG-*cuhl-LO7r6+9tX}INZ$t7z|)JVsyYSD6IEBj^|t$=<Scb=
zcWvv2&1b~_u4U3Ns)d`OGA~<Oroo6yBGcJUh&33uM}In7f;q$-o#YK_enYU|1t(z+
zx)6ymrxGhuvVWtNlgUfU@=?cGrG=fgQ>WGDuC;cqZc>F`jq~S#*J5P1J??qqJ4ii3
z<4w{bFM@X#;n4|^?3QvalQ_xmD&eKaUop7&i-`C(2NX5?(8XSYr_k^cyt&_hUOOPP
z4m;M-Rse30e_lP$j7Td2H*il1!Ylx6UlNmuF<k-|e<lnlEI^>lQ`@Rr?JU2%ChJ8q
z_g^I$oF@yMByDhK5iF&L9C2j1H1U`|zD?t-?Rjf}<HvR_yq5S=Cas<~8Xd%4=UJ<?
zi&bA=n*5VUWV@21Ilp@J(t1I|<}5ghj718sdYxGVm2TDh+n8Nw7o!r(-kaKCi13-A
zoOm48$}**N;a$pR>?guqQwX3(KGO7D4TuZ0#GrZKgkc%U$1HJf<nR;A3s0WeI*diR
zGWOM*Rh}D^lE~(*In{Xlhn=XY<p|@J*_WBt)I~RbKD9Nh`i9l|8Z`Y5s!2xtp3Y3T
zQC&5fM{~b%*U~ze#>PL15&?}&c|)xa3dwKSu8;X<GFnNzQGG!(eScoW0J37kW`=k-
z?V8-+hwg42L}_)zW#~=zM81TS3HCt7pfq#r3HI3t3^^0VWnJba+}8xU3!3uQ`NnsZ
zF!>AjBhThAzOXOKax$n=HFwy!EB3^8nR{VN8xg^$GEhSVp6*veM*Ajw=hqBN!CAqa
zh4g4IOak#U8)TVoT}Lf`{@FS%X-!8$Z#}3C;#p`@rV??(43`DR<I$PsWI0M?3;A_J
z?;Lc9H;bq-t3PnvU|JC4_2}}g4<Niy%L#)Fk5iJ-)%F3K)|f5Yt7#vGaI^?{2U}uV
zdhkPwBgo0xP!nvFQYDUhZ5Z$Q3u0Ve^!JK_`z?b<_1ZY}@8xiG-y7n7TiU|y$Wth>
zH5+8{Ku<o4aen>uxtUP(EXK6>?}Wbys_LWP^?;~>$q`F<eq%y=7Z{v5P#0(}^+w^r
z?$9raH^bQb%vADivQrtHu}yerSTkHY*$TcR@g`^O`3y=IW+g=#$JQDHypqa7Qt!GD
zrAO$3jclYiI@{Dg>UAj4_3V*}GnnDCdyVYbEO@6vC?ki^c?Vez+Zkpv9$$+l<k(Lo
zMjV#O%IGkj65%a}Kn-WCRA0SA#rRp4zh$epMf~BLyCn|Rxw>-9?qvpZ3<=6MK;2%9
zucvdM5QGx8UoBSz1?kZlc=U0lI>W~L3mAiABt~Mx%EDIZFI*+GZ2b7?d9Y5fsWxaB
z<02@NaL1XrJ>?|7=)IN_D%8s8O3J5V90coD_SUqx(~dy~LN#K;P(`C0ftjfr80r%i
zf@nJ0;!6_iXz0ojZThqmEG)pbp+5%03OLB_R~S_Kps&is89gBqU%7sUF_(8?(w8Ms
z1kV!k)gApcFO%m?GZh#t#8U)O7sPDXL5K{K-DiNjmBj;ypD({VSTs+tN9~tx<HNe?
zv=L$@Q3M8F^mGG(kLlBKZBiXCOz1i6tMQLBm9xHpii`e+4?ajKABfGJhnn<2QHXdc
z)UZcG1$siwLll#K8VBpjo>GXYYUov5iL_E-UefW%QLt+ZZV{sdh%7nP^<N%eEHXX}
zf1yjm<B>FA6NwqqJ-Z>X0!k#rv_>0CjeLA;(eD9)z)aykv~fSHCjjMJls7{;P`*oc
zJ*OzCUg^*ad@-`GF3BNOl@eS)Uq8Db^#(N4n}!l*4ExyAMnQ`4N4xy)DE^S%pk=WH
z-Jy8uRqc9w`u04|zh0M+7_Iev3P9;aAakdXW`wZ9O#?G~(j8$^(YQ0NbgX*(70Yaf
z<E=NlYsk$(yIeR{OMmt+kc>%x=82H=z|BV^`O!J_*F)vOcXBZv13kWRg9?Rhn{W_I
z<Tu5tl78qlKr!x(V?OfWt-l(+J1T})@8qDI7GkHLJa4W3$IEub`?8N7<T5T67#WHR
z%4*_bj1C$d#=ByQ++W&sR1ggIg9UWjG)~p;X(@vEWK|X?DJz`>3-R)p&B6%xOX@=W
z8v9LHv9(}B$kzb__4W9cN=;EH*wA$?_~j5~*ZVq*V`x^N1Zk=gVpPc=2I>izlPOLG
zS6_sSjlKMMD~FV@vKiLS;+7_xD<wrjv)5S>-oDe16Il>%!o*N63w(Cf54D5_2#RDu
z2cteMEbDy@BT#W>qmv9Z4)4nJr{<G)4JV#-l4`jX_nwO2q!H;cj$)UV291+xbd#?d
zksfr46DB;RP}(R!D^e|1{aZ~RG2L>Or&pUcns$xw1zr8NRpnmlhF&67F<A!IhkYNE
zb8f&fr+0ix2vEVm@{2W{{Y{>Pfe`X~XxC3AR9`a|bk-DWOvpzW7zb7L1M!_;i5BR%
z&v?_ht!$*3CeE3Z8j6;@3nB`ERvBJSieg!L+*hOEChu(?q@l&UzZS@gjQOB|kF@+W
zc0Bx!9=fnyns`b>6+tFld@`O`zY)cO(UQ8OuOxN(kyIsS5nXb7j+tVCS0F{Z8<Z#9
zKWojxr4K-n&;O$son6~ySc69}u13UnFKgX(O33<9(Y@%Q=~w&;C;dFDgt7XaE6y|?
z@!PjXd%#Vn9pY<H47_wc*4jA~a~K`Nxl>D1vYf-WdVT{YGIcOWRiAFdJgr<DI`Bz{
z@-3!5Vd^dLQ;tGl>;e~R$wh~Ep-ZnCM9v<b-$qpsBWT9>DVD5*Rl<LryK1vyE_)13
ztiw;Ekre~mS@7s~Kuy|$qh8KfJDE#`U*<IY(=kU)>?<Wa{OqaiH%gGtd=HAE(N5P4
zKOUw%BJf|jOTv4l{uq`Yh+<-ibfJXVQ(FG^>s(;@q*gFoF-HGsU2K4`Y(@$>-`Dx@
z0wlK`|HqSM#vQsQ_hTyF0iS;&m$H3)`mdB|(p*ZF&2!qz`zNsq)5^IptHazWgxikF
z=!Olv_0KdY@&3n;BcO#35%Z^#I?+d`?h=L?fqf`~u9}vpN`Q?4NxAlo#Gp@6_#lG9
zP+D<=E9mLj_IWKr>el?fbQmvTLGb$Zku8TVDiRS1?`81qT?4w`)0jCA_lv*J##J86
zE)8|=EtmtR&}RSM*FO~*Eg6IPZG=o6bN^=KYTsG5WZc&&OET!h@lARh7Ff`ESNT2i
z#+&g}7>z`w!}A?EqXJbPqWTv~93AL2YW0%BXh9GD?0y~dEk6^RQk>(MWJLmVxbSzf
zEIXHn%F28WI;}_1OQh)s#fpOo?DbIflB=AU5bRtl^tye*YdrBZ2HOsCtR=t~*KgPu
zF|xCuu8Dq<(~r0;5p+afT<24*!>uBQ8%BZ_&afsBi0EwwfuM|>`hF`rT{6L0hd{O)
zJB?L8l^cd6Qh%z!71eRKyfgEFn4dXy6`IVeTXzzPK0HrPg6Z=`9c^s&1M`9bSY?K-
zQEhRTMi;-!h;{bZ6^fKL<Gx?s_S^{5-kbD+i>9$N_?V>EcIC^h1I8#ywd2T?q~~0q
zzXAzS&?A3Ktot1zZs7b>WBwiIw|{aS?ES9B?T>Z-m6MsX>G0OCWAa0j--c0%55a|W
z)47$1?(yyWGLT~tcXnNUMKPg>m9oZwxbPhDhP9~uz<XI#5z67iU@=0xp5l^bv3k(>
z=~8<cp#K;K8~4?Ma0VDDu#sk`*aSA}4bQqg$LXy~dWVkp>VGr6F_gR-9q2xpa3fHy
z%I~-}HB!~QIv2>`5OL{?j}S-0kEj@2nlvWvdKOc(^}3~v%mE&-oQ_d+RNhQOqv!oC
z+Dz-6dX8q+vmcaqX2BDq638<tQtZEXL2)K|0WA^*=hOBe^FX>8=>V_fcy?O2g^748
z_utCr1j4G_t7#)CE;AtVrNuOwNQv`4&AwE4e8~$BVS7q9Pg#nxoGG=>vhq&q_Lj=J
zzza9xW2K<2ziB#D)h_&))Kgv4Th2yuUmYeVkMR^D&IXG2o!+o*E%FviV+^Hy%uEcD
z%k9oUx7r@arz|v~-^_uD(VmH0um~vy629|pd=@LC`A+9sPJw431&pb6kQ+CjaT|6U
zV;K%Z+IgS$lHWjdG}Uk1>wI(F^jy5N+^@7T6?Kzu#)1p%lWojRiKsUU`w6>$dLpe=
znSQ>tY^eFs7+2Q2JUu;oINKU<^}cG;$31@afkXzjaNx5A$|JM7LifF0-GAcjW~*Wu
zJ6zCkFJUM0dGX#iQ2d<0@yv<1?~&T<cvpz?R<Z3-8oQuFvW3N%6aYX8vyqd7faT==
zJCOY+hRq5{kW}u0kcMk&7cr3mKSzmJlxUF4E6}ihQmBS3;Z%sFwO$is2(WPS#D>^)
zb>;T`2>o1FiC-DQaEG?Fby&F1#JZMBYS8PwnGkn%D(Z74C1b6V2J=t{WH@G){$hc-
zm6`36nWFPynJB`(CMfg5HVloCGpZgG+xpJ|fx5XFjg*9h(TFtDrC#dCj?9KGpInh{
zm0A^l4GG67lxX^<O7F-1rv2JZer6b(pe79?`Dfa4cRsFkstW-ZomuxGidwp|tVR*L
z6e_#yq;<Zm`S(*FiUmVNzQ)TCGm*|f6fuO%u4lnD@dW{czon1=B<(;4-eEHTM*T6t
z&;mafzLPX8;}bk!4QI`J=yQ=$44&YbC>I|?)@%!C25s;=7d1Z3V)8wJecLJ&;)0$X
zHny58IQ=?z@%gST2EHGwfDB~w0j;@{{JTNHhIwA2nTB@s#RM`DuzG(q8X8n{g`tng
zCNE9I%JYfM=o!#*#kJsGz5kyK9Dr%2sw58x`WNyXN$USN*v`uOZU6v&@4tnT!i7)$
zj|p@Kt1AGvaZ$)I$T-0fVE_Q?DOet)<Gpl}4${;Hk%o`c4rzEX^j4#){#n8+c|xg-
z0Z|c?P=vMFdF;}6rkn#;WTUvye%aq)$YWo$eV;Tkw>H^c@{G;o^g*>nfAjWi#bU~*
zF}?824>8taWs4q#8kucHgt8<$_t9e25``mM?WaKn=3p_PU+%DTM3*aN2zHG#P-~xV
z;o<Fl=hO7z85eNk=~p{{RFS6tm1Xer0_ldUurxuQqHF2;89mpx^|MrEo&+_63SDLc
z3=93a>osW<0Aht_urEKK@vLnf0O3thdHPs|6ay#v)tsVi*BhK@2VE?PHlDOarc3_N
zdF235o_2pNgz+mE$_~VNBTwUlK~rdBfPW>-LV?K|Z>hiPcQ#s1%?(K8g53`Jby&l0
zZ0p71pNtSI!ETOtohm<BAr-po2`g@675w|sL5zcffCq4*y}~;7cN;M)*f?MXx0Dy4
zo5ZphTSM~NpX(TM&esG==`6)80l7w6koV&cDl+cKxTfzICTcgWSPZna?vpePG!Ikp
zczwG9*aE(4xJMPms}|^@4zdjzn)<VfDqVuoG?TKJnn*HHF9A|}dq^<+#kYjv;>oX_
zylcdLE}<-Os|-OH0J=`hLEkhl^EI?RWyi!;MOU#@-lSH#_RP2j^pRuQAW6W{-9;pE
zCsj}Y|FY~cQS!uypsac#!QZ*0$92*?T|GyLBZQSfnB#w;<UeQs&i_wTV*wn;#~z7-
zR+041R-TxtZF|NFo2oJZ^#6}}Ci&W?**JCtgaDNPj~r0aXB|CO1^_DLT>ZR%AFCx&
ziISSOYs1aV47Kwh(EV~gTLZY-!_2wyL+PO0qIg==4L;}L4$v6-<2C;Z<$oLw;-Xqd
Z>B2*0AN63r`R5q`U<D2NN?DVT{{T0%!Sw(D

diff --git a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditor.ed.tscript b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditor.ed.tscript
index 823fa39b3..bdbab3018 100644
--- a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditor.ed.tscript
@@ -668,30 +668,6 @@ function GuiEditor::onControlDragged( %this, %payload, %position )
 
 //---------------------------------------------------------------------------------------------
 
-function GuiEditor::onControlDropped(%this, %payload, %position)
-{  
-   // Make sure we have the right kind of D&D.
-   
-   if( !%payload.parentGroup.isInNamespaceHierarchy( "GuiDragAndDropControlType_GuiControl" ) &&
-         !%payload.parentGroup.isInNamespaceHierarchy( "AssetPreviewControlType_AssetDrop" ))
-      return;
-
-   %pos = %payload.getGlobalPosition();
-   %x = getWord(%pos, 0);
-   %y = getWord(%pos, 1);
-
-   %asset = %payload.assetName;
-   %cmd = "return new " @ %asset @ "();";
-   %ctrl = eval( %cmd );
-
-   %this.addNewCtrl(%ctrl);
-   
-   %ctrl.setPositionGlobal(%x, %y);
-   %this.setFirstResponder();
-}
-
-//---------------------------------------------------------------------------------------------
-
 function GuiEditor::onGainFirstResponder(%this)
 {
    %this.enableMenuItems(true);
diff --git a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
index 124ae856a..2af4b9795 100644
--- a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
@@ -816,9 +816,9 @@ function MaterialEditorGui::guiSync( %this, %material )
    MaterialEditorPropertiesWindow-->normalMapDisplayBitmap.setBitmap( getAssetPreviewImage(%normalMap) );
    
    //ORM Config
-   %ormMap = (%material).getNormalMap(%layer);
+   %ormMap = (%material).getORMConfigMap(%layer);
    %hasOrmMap = (%ormMap !$= "" && %ormMap !$=$MaterialEditor::emptyMaterialImage);
-   %ormMapText = %hasOrmMap ? (%material).getNormalMapAsset(%layer) : "None";
+   %ormMapText = %hasOrmMap ? (%material).getORMConfigMapAsset(%layer) : "None";
    MaterialEditorPropertiesWindow-->ORMConfigMapNameText.setText(%ormMapText );      
    MaterialEditorPropertiesWindow-->ORMConfigMapDisplayBitmap.setBitmap( getAssetPreviewImage(%ormMap) );
 

From d074343b5052341f584b2e89042ac3d0d2cfc61a Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Fri, 26 Nov 2021 20:13:59 -0600
Subject: [PATCH 271/399] adds colorization to GuiBitmapButtonCtrl

---
 Engine/source/gui/buttons/guiBitmapButtonCtrl.cpp | 6 ++++--
 Engine/source/gui/buttons/guiBitmapButtonCtrl.h   | 1 +
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/Engine/source/gui/buttons/guiBitmapButtonCtrl.cpp b/Engine/source/gui/buttons/guiBitmapButtonCtrl.cpp
index 8e5e0fd76..65672f4e6 100644
--- a/Engine/source/gui/buttons/guiBitmapButtonCtrl.cpp
+++ b/Engine/source/gui/buttons/guiBitmapButtonCtrl.cpp
@@ -128,7 +128,7 @@ GuiBitmapButtonCtrl::GuiBitmapButtonCtrl()
    mUseStates = true;
    setExtent( 140, 30 );
    mMasked = false;
-
+   mColor = ColorI::WHITE;
    INIT_ASSET(Bitmap);
 }
 
@@ -142,6 +142,7 @@ void GuiBitmapButtonCtrl::initPersistFields()
          "If useStates is false, this will be the file that renders on the control.  Otherwise, this will "
          "specify the default texture name to which the various state and modifier suffixes are appended "
          "to find the per-state and per-modifier (if enabled) textures.");
+      addField("color", TypeColorI, Offset(mColor, GuiBitmapButtonCtrl), "color mul");
 
       addField( "bitmapMode", TYPEID< BitmapMode >(), Offset( mBitmapMode, GuiBitmapButtonCtrl ),
          "Behavior for fitting the bitmap to the control extents.\n"
@@ -545,7 +546,8 @@ void GuiBitmapButtonCtrl::onRender(Point2I offset, const RectI& updateRect)
 void GuiBitmapButtonCtrl::renderButton( GFXTexHandle &texture, const Point2I &offset, const RectI& updateRect )
 {
    GFX->getDrawUtil()->clearBitmapModulation();
-   
+   GFX->getDrawUtil()->setBitmapModulation(mColor);
+
    switch( mBitmapMode )
    {
       case BitmapStretched:
diff --git a/Engine/source/gui/buttons/guiBitmapButtonCtrl.h b/Engine/source/gui/buttons/guiBitmapButtonCtrl.h
index 000a77d0b..575fc4603 100644
--- a/Engine/source/gui/buttons/guiBitmapButtonCtrl.h
+++ b/Engine/source/gui/buttons/guiBitmapButtonCtrl.h
@@ -126,6 +126,7 @@ class GuiBitmapButtonCtrl : public GuiButtonCtrl
       
       ///
       Textures mTextures[ NumModifiers ];
+      ColorI   mColor;
       
       virtual void renderButton( GFXTexHandle &texture, const Point2I& offset, const RectI& updateRect );
       

From 93faa243acbea80bd56a7ca9214fd1838e9d736f Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Sat, 27 Nov 2021 00:32:25 -0600
Subject: [PATCH 272/399] cleanups for sound assets removed redundant
 get<foo>Profile calls, correctly used a few in proxmine

---
 Engine/source/T3D/proximityMine.cpp           |  8 ++++----
 Engine/source/T3D/rigidShape.cpp              | 12 ++++++------
 Engine/source/T3D/rigidShape.h                | 16 ----------------
 Engine/source/T3D/vehicles/flyingVehicle.cpp  |  4 ++--
 Engine/source/T3D/vehicles/flyingVehicle.h    |  7 -------
 Engine/source/T3D/vehicles/hoverVehicle.cpp   |  6 +++---
 Engine/source/T3D/vehicles/hoverVehicle.h     |  7 -------
 Engine/source/T3D/vehicles/vehicle.cpp        | 14 +++++++-------
 Engine/source/T3D/vehicles/vehicle.h          | 17 -----------------
 Engine/source/T3D/vehicles/wheeledVehicle.cpp |  6 +++---
 Engine/source/T3D/vehicles/wheeledVehicle.h   |  9 ---------
 11 files changed, 25 insertions(+), 81 deletions(-)

diff --git a/Engine/source/T3D/proximityMine.cpp b/Engine/source/T3D/proximityMine.cpp
index 683021255..2c96c9e3a 100644
--- a/Engine/source/T3D/proximityMine.cpp
+++ b/Engine/source/T3D/proximityMine.cpp
@@ -426,8 +426,8 @@ void ProximityMine::processTick( const Move* move )
                   mAnimThread = mShapeInstance->addThread();
                   mShapeInstance->setSequence( mAnimThread, mDataBlock->armingSequence, 0.0f );
                }
-               if ( mDataBlock->getArmSound() )
-                  SFX->playOnce( mDataBlock->getArmSoundAsset()->getSfxProfile(), &getRenderTransform() );
+               if ( mDataBlock->getArmSoundProfile() )
+                  SFX->playOnce( mDataBlock->getArmSoundProfile(), &getRenderTransform() );
             }
             break;
 
@@ -467,8 +467,8 @@ void ProximityMine::processTick( const Move* move )
                   mAnimThread = mShapeInstance->addThread();
                   mShapeInstance->setSequence( mAnimThread, mDataBlock->triggerSequence, 0.0f );
                }
-               if ( mDataBlock->getTriggerSound() )
-                  SFX->playOnce( mDataBlock->getTriggerSoundAsset()->getSfxProfile(), &getRenderTransform() );
+               if ( mDataBlock->getTriggerSoundProfile() )
+                  SFX->playOnce( mDataBlock->getTriggerSoundProfile(), &getRenderTransform() );
 
                if ( isServerObject() )
                   mDataBlock->onTriggered_callback( this, sql.mList[0] );
diff --git a/Engine/source/T3D/rigidShape.cpp b/Engine/source/T3D/rigidShape.cpp
index 01b830db0..256dc723b 100644
--- a/Engine/source/T3D/rigidShape.cpp
+++ b/Engine/source/T3D/rigidShape.cpp
@@ -1172,27 +1172,27 @@ void RigidShape::updatePos(F32 dt)
             if (collSpeed >= mDataBlock->softImpactSpeed)
                impactSound = RigidShapeData::Body::SoftImpactSound;
 
-         if (impactSound != -1 && mDataBlock->getBodySounds(impactSound) != NULL)
-            SFX->playOnce(mDataBlock->getBodySoundProfile(impactSound), &getTransform());
+         if (impactSound != -1 && mDataBlock->getBodySoundsProfile(impactSound))
+            SFX->playOnce(mDataBlock->getBodySoundsProfile(impactSound), &getTransform());
       }
 
       // Water volume sounds
       F32 vSpeed = getVelocity().len();
       if (!inLiquid && mWaterCoverage >= 0.8f) {
          if (vSpeed >= mDataBlock->hardSplashSoundVel)
-            SFX->playOnce(mDataBlock->getWaterSoundProfile(RigidShapeData::ImpactHard), &getTransform());
+            SFX->playOnce(mDataBlock->getWaterSoundsProfile(RigidShapeData::ImpactHard), &getTransform());
          else
             if (vSpeed >= mDataBlock->medSplashSoundVel)
-               SFX->playOnce(mDataBlock->getWaterSoundProfile(RigidShapeData::ImpactMedium), &getTransform());
+               SFX->playOnce(mDataBlock->getWaterSoundsProfile(RigidShapeData::ImpactMedium), &getTransform());
             else
                if (vSpeed >= mDataBlock->softSplashSoundVel)
-                  SFX->playOnce(mDataBlock->getWaterSoundProfile(RigidShapeData::ImpactSoft), &getTransform());
+                  SFX->playOnce(mDataBlock->getWaterSoundsProfile(RigidShapeData::ImpactSoft), &getTransform());
          inLiquid = true;
       }
       else
          if (inLiquid && mWaterCoverage < 0.8f) {
             if (vSpeed >= mDataBlock->exitSplashSoundVel)
-               SFX->playOnce(mDataBlock->getWaterSoundProfile(RigidShapeData::ExitWater), &getTransform());
+               SFX->playOnce(mDataBlock->getWaterSoundsProfile(RigidShapeData::ExitWater), &getTransform());
             inLiquid = false;
          }
    }
diff --git a/Engine/source/T3D/rigidShape.h b/Engine/source/T3D/rigidShape.h
index ef3ead6e5..c96c10c50 100644
--- a/Engine/source/T3D/rigidShape.h
+++ b/Engine/source/T3D/rigidShape.h
@@ -66,14 +66,6 @@ class RigidShapeData : public ShapeBaseData
    DECLARE_SOUNDASSET_ARRAY(RigidShapeData, BodySounds, Body::Sounds::MaxSounds)
    DECLARE_ASSET_ARRAY_SETGET(RigidShapeData, BodySounds);
 
-   SFXProfile* getBodySoundProfile(U32 id)
-   {
-      if (mBodySoundsAsset[id] != NULL)
-         return mBodySoundsAsset[id]->getSfxProfile();
-
-      return NULL;
-   }
-
    enum RigidShapeConsts
    {
       VC_NUM_DUST_EMITTERS = 1,
@@ -94,14 +86,6 @@ class RigidShapeData : public ShapeBaseData
    DECLARE_SOUNDASSET_ARRAY(RigidShapeData, WaterSounds, Sounds::MaxSounds)
    DECLARE_ASSET_ARRAY_SETGET(RigidShapeData, WaterSounds);
 
-   SFXProfile* getWaterSoundProfile(U32 id)
-   {
-      if (mWaterSoundsAsset[id] != NULL)
-         return mWaterSoundsAsset[id]->getSfxProfile();
-
-      return NULL;
-   }
-
    F32 exitSplashSoundVel;
    F32 softSplashSoundVel;
    F32 medSplashSoundVel;
diff --git a/Engine/source/T3D/vehicles/flyingVehicle.cpp b/Engine/source/T3D/vehicles/flyingVehicle.cpp
index 255dbc571..075b62bbc 100644
--- a/Engine/source/T3D/vehicles/flyingVehicle.cpp
+++ b/Engine/source/T3D/vehicles/flyingVehicle.cpp
@@ -367,10 +367,10 @@ bool FlyingVehicle::onNewDataBlock(GameBaseData* dptr, bool reload)
       SFX_DELETE( mEngineSound );
 
       if ( mDataBlock->getFlyingSounds(FlyingVehicleData::EngineSound) )
-         mEngineSound = SFX->createSource( mDataBlock->getFlyingSoundProfile(FlyingVehicleData::EngineSound), &getTransform() );
+         mEngineSound = SFX->createSource( mDataBlock->getFlyingSoundsProfile(FlyingVehicleData::EngineSound), &getTransform() );
 
       if ( mDataBlock->getFlyingSounds(FlyingVehicleData::JetSound))
-         mJetSound = SFX->createSource( mDataBlock->getFlyingSoundProfile(FlyingVehicleData::JetSound), &getTransform() );
+         mJetSound = SFX->createSource( mDataBlock->getFlyingSoundsProfile(FlyingVehicleData::JetSound), &getTransform() );
    }
 
    // Jet Sequences
diff --git a/Engine/source/T3D/vehicles/flyingVehicle.h b/Engine/source/T3D/vehicles/flyingVehicle.h
index f0a45edd3..37071c2a4 100644
--- a/Engine/source/T3D/vehicles/flyingVehicle.h
+++ b/Engine/source/T3D/vehicles/flyingVehicle.h
@@ -47,13 +47,6 @@ struct FlyingVehicleData: public VehicleData {
    };
    DECLARE_SOUNDASSET_ARRAY(FlyingVehicleData, FlyingSounds, Sounds::MaxSounds);
    DECLARE_ASSET_ARRAY_SETGET(FlyingVehicleData, FlyingSounds);
-   SFXProfile* getFlyingSoundProfile(U32 id)
-   {
-      if (mFlyingSoundsAsset[id] != NULL)
-         return mFlyingSoundsAsset[id]->getSfxProfile();
-
-      return NULL;
-   }
 
    enum Jets {
       // These enums index into a static name list.
diff --git a/Engine/source/T3D/vehicles/hoverVehicle.cpp b/Engine/source/T3D/vehicles/hoverVehicle.cpp
index cdb080c93..03ba6a855 100644
--- a/Engine/source/T3D/vehicles/hoverVehicle.cpp
+++ b/Engine/source/T3D/vehicles/hoverVehicle.cpp
@@ -543,13 +543,13 @@ bool HoverVehicle::onNewDataBlock(GameBaseData* dptr, bool reload)
       SFX_DELETE( mJetSound );
 
       if ( mDataBlock->getHoverSounds(HoverVehicleData::EngineSound) )
-         mEngineSound = SFX->createSource( mDataBlock->getHoverSoundProfile(HoverVehicleData::EngineSound), &getTransform() );
+         mEngineSound = SFX->createSource( mDataBlock->getHoverSoundsProfile(HoverVehicleData::EngineSound), &getTransform() );
 
       if ( !mDataBlock->getHoverSounds(HoverVehicleData::FloatSound) )
-         mFloatSound = SFX->createSource( mDataBlock->getHoverSoundProfile(HoverVehicleData::FloatSound), &getTransform() );
+         mFloatSound = SFX->createSource( mDataBlock->getHoverSoundsProfile(HoverVehicleData::FloatSound), &getTransform() );
 
       if ( mDataBlock->getHoverSounds(HoverVehicleData::JetSound) )
-         mJetSound = SFX->createSource( mDataBlock->getHoverSoundProfile(HoverVehicleData::JetSound), &getTransform() );
+         mJetSound = SFX->createSource( mDataBlock->getHoverSoundsProfile(HoverVehicleData::JetSound), &getTransform() );
    }
 
    // Todo: Uncomment if this is a "leaf" class
diff --git a/Engine/source/T3D/vehicles/hoverVehicle.h b/Engine/source/T3D/vehicles/hoverVehicle.h
index 8f666a76a..dd76d40a3 100644
--- a/Engine/source/T3D/vehicles/hoverVehicle.h
+++ b/Engine/source/T3D/vehicles/hoverVehicle.h
@@ -47,13 +47,6 @@ class HoverVehicleData : public VehicleData
       MaxSounds
    };
    DECLARE_SOUNDASSET_ARRAY(HoverVehicleData, HoverSounds, Sounds::MaxSounds);
-   SFXProfile* getHoverSoundProfile(U32 id)
-   {
-      if (mHoverSoundsAsset[id] != NULL)
-         return mHoverSoundsAsset[id]->getSfxProfile();
-
-      return NULL;
-   }
 
    enum Jets {
       // These enums index into a static name list.
diff --git a/Engine/source/T3D/vehicles/vehicle.cpp b/Engine/source/T3D/vehicles/vehicle.cpp
index 2fad95b6d..327c3e1ab 100644
--- a/Engine/source/T3D/vehicles/vehicle.cpp
+++ b/Engine/source/T3D/vehicles/vehicle.cpp
@@ -893,7 +893,7 @@ bool Vehicle::onNewDataBlock(GameBaseData* dptr,bool reload)
       SFX_DELETE( mWakeSound );
 
       if ( mDataBlock->getVehicleWaterSounds(VehicleData::Wake) != NULL )
-         mWakeSound = SFX->createSource( mDataBlock->getVehicleWaterSoundProfile(VehicleData::Wake), &getTransform() );
+         mWakeSound = SFX->createSource( mDataBlock->getVehicleWaterSoundsProfile(VehicleData::Wake), &getTransform() );
    }
 
    return true;
@@ -1156,27 +1156,27 @@ void Vehicle::updatePos(F32 dt)
             if (collSpeed >= mDataBlock->softImpactSpeed)
                impactSound = VehicleData::Body::SoftImpactSound;
 
-         if (impactSound != -1 && mDataBlock->getVehicleBodySounds(impactSound) != NULL)
-            SFX->playOnce( mDataBlock->getVehicleBodySoundProfile(impactSound), &getTransform() );
+         if (impactSound != -1 && mDataBlock->getVehicleBodySoundsProfile(impactSound) != NULL)
+            SFX->playOnce( mDataBlock->getVehicleBodySoundsProfile(impactSound), &getTransform() );
       }
 
       // Water volume sounds
       F32 vSpeed = getVelocity().len();
       if (!inLiquid && mWaterCoverage >= 0.8f) {
          if (vSpeed >= mDataBlock->hardSplashSoundVel)
-            SFX->playOnce( mDataBlock->getVehicleWaterSoundProfile(VehicleData::ImpactHard), &getTransform() );
+            SFX->playOnce( mDataBlock->getVehicleWaterSoundsProfile(VehicleData::ImpactHard), &getTransform() );
          else
             if (vSpeed >= mDataBlock->medSplashSoundVel)
-               SFX->playOnce( mDataBlock->getVehicleWaterSoundProfile(VehicleData::ImpactMedium), &getTransform() );
+               SFX->playOnce( mDataBlock->getVehicleWaterSoundsProfile(VehicleData::ImpactMedium), &getTransform() );
          else
             if (vSpeed >= mDataBlock->softSplashSoundVel)
-               SFX->playOnce( mDataBlock->getVehicleWaterSoundProfile(VehicleData::ImpactSoft), &getTransform() );
+               SFX->playOnce( mDataBlock->getVehicleWaterSoundsProfile(VehicleData::ImpactSoft), &getTransform() );
          inLiquid = true;
       }
       else
          if(inLiquid && mWaterCoverage < 0.8f) {
             if (vSpeed >= mDataBlock->exitSplashSoundVel)
-               SFX->playOnce( mDataBlock->getVehicleWaterSoundProfile(VehicleData::ExitWater), &getTransform() );
+               SFX->playOnce( mDataBlock->getVehicleWaterSoundsProfile(VehicleData::ExitWater), &getTransform() );
          inLiquid = false;
       }
    }
diff --git a/Engine/source/T3D/vehicles/vehicle.h b/Engine/source/T3D/vehicles/vehicle.h
index 2e6440662..a0ce918c7 100644
--- a/Engine/source/T3D/vehicles/vehicle.h
+++ b/Engine/source/T3D/vehicles/vehicle.h
@@ -51,15 +51,6 @@ struct VehicleData : public RigidShapeData
 
    DECLARE_SOUNDASSET_ARRAY(VehicleData, VehicleBodySounds, Body::Sounds::MaxSounds)
 
-   SFXProfile* getVehicleBodySoundProfile(U32 id)
-   {
-      if (mVehicleBodySoundsAsset[id] != NULL)
-         return mVehicleBodySoundsAsset[id]->getSfxProfile();
-
-      return NULL;
-   }
-
-
    enum VehicleConsts
    {
       VC_NUM_DUST_EMITTERS = 1,
@@ -82,14 +73,6 @@ struct VehicleData : public RigidShapeData
 
   DECLARE_SOUNDASSET_ARRAY(VehicleData, VehicleWaterSounds, Sounds::MaxSounds)
 
-  SFXProfile* getVehicleWaterSoundProfile(U32 id)
-  {
-     if (mVehicleWaterSoundsAsset[id] != NULL)
-        return mVehicleWaterSoundsAsset[id]->getSfxProfile();
-
-     return NULL;
-  }
-
    F32 exitSplashSoundVel;
    F32 softSplashSoundVel;
    F32 medSplashSoundVel;
diff --git a/Engine/source/T3D/vehicles/wheeledVehicle.cpp b/Engine/source/T3D/vehicles/wheeledVehicle.cpp
index 9dd949bf3..f912f5058 100644
--- a/Engine/source/T3D/vehicles/wheeledVehicle.cpp
+++ b/Engine/source/T3D/vehicles/wheeledVehicle.cpp
@@ -686,13 +686,13 @@ bool WheeledVehicle::onNewDataBlock(GameBaseData* dptr, bool reload)
       SFX_DELETE( mJetSound );
 
       if ( mDataBlock->getWheeledVehicleSounds(WheeledVehicleData::EngineSound) )
-         mEngineSound = SFX->createSource( mDataBlock->getWheeledVehicleSound(WheeledVehicleData::EngineSound), &getTransform() );
+         mEngineSound = SFX->createSource( mDataBlock->getWheeledVehicleSoundsProfile(WheeledVehicleData::EngineSound), &getTransform() );
 
       if ( mDataBlock->getWheeledVehicleSounds(WheeledVehicleData::SquealSound) )
-         mSquealSound = SFX->createSource( mDataBlock->getWheeledVehicleSound(WheeledVehicleData::SquealSound), &getTransform() );
+         mSquealSound = SFX->createSource( mDataBlock->getWheeledVehicleSoundsProfile(WheeledVehicleData::SquealSound), &getTransform() );
 
       if ( mDataBlock->getWheeledVehicleSounds(WheeledVehicleData::JetSound) )
-         mJetSound = SFX->createSource( mDataBlock->getWheeledVehicleSound(WheeledVehicleData::JetSound), &getTransform() );
+         mJetSound = SFX->createSource( mDataBlock->getWheeledVehicleSoundsProfile(WheeledVehicleData::JetSound), &getTransform() );
    }
 
    scriptOnNewDataBlock();
diff --git a/Engine/source/T3D/vehicles/wheeledVehicle.h b/Engine/source/T3D/vehicles/wheeledVehicle.h
index 56f5997a9..93f197757 100644
--- a/Engine/source/T3D/vehicles/wheeledVehicle.h
+++ b/Engine/source/T3D/vehicles/wheeledVehicle.h
@@ -121,15 +121,6 @@ struct WheeledVehicleData: public VehicleData
 
    DECLARE_SOUNDASSET_ARRAY(WheeledVehicleData, WheeledVehicleSounds, Sounds::MaxSounds);
 
-   SFXProfile* getWheeledVehicleSound(U32 id)
-   {
-      if (mWheeledVehicleSoundsAsset[id] != NULL)
-         return mWheeledVehicleSoundsAsset[id]->getSfxProfile();
-
-      return NULL;
-   }
-
-
    ParticleEmitterData* tireEmitter;
 
    F32 maxWheelSpeed;            // Engine torque is scale based on wheel speed

From 663335e55611d1b64862a072277641111eb63afd Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Sat, 27 Nov 2021 14:29:30 -0600
Subject: [PATCH 273/399] TSStatic::updateMaterials() crashfix

---
 Engine/source/T3D/tsStatic.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Engine/source/T3D/tsStatic.cpp b/Engine/source/T3D/tsStatic.cpp
index dc3200f18..546f490c3 100644
--- a/Engine/source/T3D/tsStatic.cpp
+++ b/Engine/source/T3D/tsStatic.cpp
@@ -1587,7 +1587,7 @@ U32 TSStatic::getNumDetails()
 
 void TSStatic::updateMaterials()
 {
-   if (mChangingMaterials.empty() || !mShape)
+   if (mChangingMaterials.empty() || !mShapeInstance)
       return;
 
    TSMaterialList* pMatList = mShapeInstance->getMaterialList();

From 1b282e0baff4e012ac7538e270d58303c5d6399b Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Mon, 29 Nov 2021 13:52:45 -0600
Subject: [PATCH 274/399] use internalname for terrain layers stops bugs like
 spaces in filenames and the like from occuring due to pointing right at the
 diffuse flat file name, as well as corruption from using a different diffuse
 in the material later

(cherry picked from commit c1227dbdd0dd61c25970eeaac128c6cbe5d25947)
---
 Engine/source/terrain/terrFile.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/Engine/source/terrain/terrFile.cpp b/Engine/source/terrain/terrFile.cpp
index 2ff9f6333..ca9985f5b 100644
--- a/Engine/source/terrain/terrFile.cpp
+++ b/Engine/source/terrain/terrFile.cpp
@@ -259,8 +259,7 @@ void TerrainFile::_initMaterialInstMapping()
    
    for( U32 i = 0; i < mMaterials.size(); ++ i )
    {
-      Torque::Path path( mMaterials[ i ]->getDiffuseMap());
-      mMaterialInstMapping.push_back( path.getFileName() );
+      mMaterialInstMapping.push_back(mMaterials[i]->getInternalName());
    }
    
    mMaterialInstMapping.mapMaterials();

From de379f8b25b4a72bab771934e06c91c52ed500f8 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Tue, 30 Nov 2021 18:19:58 -0600
Subject: [PATCH 275/399] fix metal sound entry for playerdata

---
 .../scripts/pre40/T3Dpre4ProjectImporter.tscript                | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
index 0eb5f4360..041cabbc9 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
@@ -946,7 +946,7 @@ $rigidEntriesList = $rigidEntriesList SPC "waterWakeSound waterWakeSoundAsset";
 T3Dpre4ProjectImporter::genProcessor("RigidShapeData",$rigidEntriesList);
 // - PlayerData
 $PlayerEntriesList = "shapeFP shapeFPAsset shapeNameFP shapeFPAsset";
-$PlayerEntriesList = $PlayerEntriesList SPC "FootSoftSound FootSoftAsset FootHardSound FootHardAsset FootMetalSound FootMetal";
+$PlayerEntriesList = $PlayerEntriesList SPC "FootSoftSound FootSoftAsset FootHardSound FootHardAsset FootMetalSound FootMetalAsset";
 $PlayerEntriesList = $PlayerEntriesList SPC "FootSnowSound FootSnowAsset FootShallowSound FootShallowSplashAsset";
 $PlayerEntriesList = $PlayerEntriesList SPC "FootWadingSound FootWadingAsset FootUnderwaterSound FootUnderWaterAsset";
 $PlayerEntriesList = $PlayerEntriesList SPC "FootBubblesSound FootBubblesAsset movingBubblesSound MoveBubblesAsset";

From a0a3608c348f013ce0eeca1e291a2efb2f524637 Mon Sep 17 00:00:00 2001
From: rextimmy <rextimm777@gmail.com>
Date: Thu, 2 Dec 2021 20:40:15 +1000
Subject: [PATCH 276/399] * Torque now requires c++17 due to new torque script
 code * Minimum version of cmake is now beyond 3.6.0, no need to check for
 that when selecting VS_STARTUP_PROJECT

---
 Tools/CMake/torque3d.cmake | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/Tools/CMake/torque3d.cmake b/Tools/CMake/torque3d.cmake
index 76c2af805..46b41ef19 100644
--- a/Tools/CMake/torque3d.cmake
+++ b/Tools/CMake/torque3d.cmake
@@ -48,8 +48,6 @@ if(UNIX)
             set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -msse")
         endif()
     endif()
-
-    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
 endif()
 
 ###############################################################################
@@ -658,8 +656,11 @@ finishExecutable()
 ###############################################################################
 ###############################################################################
 
+# Torque requires c++17
+target_compile_features(${TORQUE_APP_NAME} PRIVATE cxx_std_17)
+
 # Set Visual Studio startup project
-if((${CMAKE_VERSION} VERSION_EQUAL 3.6.0) OR (${CMAKE_VERSION} VERSION_GREATER 3.6.0) AND MSVC)
+if(MSVC)
 set_property(DIRECTORY ${CMAKE_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT ${TORQUE_APP_NAME})
 endif()
 

From 58f6431ff009ce7850bbff6207f151fb42124275 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Fri, 3 Dec 2021 16:37:22 -0500
Subject: [PATCH 277/399] * BugFix: Correct compilation for MacOS by explicitly
 specifying C++11 for all libraries and C++17 for the engine itself.

---
 Tools/CMake/basics.cmake   | 6 ++++++
 Tools/CMake/torque3d.cmake | 3 ---
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/Tools/CMake/basics.cmake b/Tools/CMake/basics.cmake
index 83e9e1952..dbd6f9a71 100644
--- a/Tools/CMake/basics.cmake
+++ b/Tools/CMake/basics.cmake
@@ -348,6 +348,8 @@ macro(finishLibrary)
         add_library("${PROJECT_NAME}" SHARED ${${PROJECT_NAME}_files})
     endif()
 
+    target_compile_features(${PROJECT_NAME} PRIVATE cxx_std_11)
+
     # omg - only use the first folder ... otherwise we get lots of header name collisions
     #foreach(dir ${${PROJECT_NAME}_paths})
     addInclude("${firstDir}")
@@ -384,6 +386,10 @@ macro(finishExecutable)
     else()
         add_executable("${PROJECT_NAME}" WIN32 ${${PROJECT_NAME}_files})
     endif()
+
+    # Torque requires c++17
+    target_compile_features(${PROJECT_NAME} PRIVATE cxx_std_17)
+
     addInclude("${firstDir}")
 
     _postTargetProcess()
diff --git a/Tools/CMake/torque3d.cmake b/Tools/CMake/torque3d.cmake
index 46b41ef19..2f5a0b6ac 100644
--- a/Tools/CMake/torque3d.cmake
+++ b/Tools/CMake/torque3d.cmake
@@ -656,9 +656,6 @@ finishExecutable()
 ###############################################################################
 ###############################################################################
 
-# Torque requires c++17
-target_compile_features(${TORQUE_APP_NAME} PRIVATE cxx_std_17)
-
 # Set Visual Studio startup project
 if(MSVC)
 set_property(DIRECTORY ${CMAKE_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT ${TORQUE_APP_NAME})

From 5fa7c62ba938d6190e9c80ca16645207a594f935 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Fri, 3 Dec 2021 20:33:02 -0500
Subject: [PATCH 278/399] * BugFix: Don't use the register keyword in the
 console grammar files.

---
 Engine/source/console/bison.simple | 20 ++++++++++----------
 Engine/source/console/cmdgram.cpp  | 20 ++++++++++----------
 2 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/Engine/source/console/bison.simple b/Engine/source/console/bison.simple
index 0fb74ce71..24a8670cb 100644
--- a/Engine/source/console/bison.simple
+++ b/Engine/source/console/bison.simple
@@ -166,9 +166,9 @@ __yy_memcpy (from, to, count)
      char *to;
      int count;
 {
-  register char *f = from;
-  register char *t = to;
-  register int i = count;
+  char *f = from;
+  char *t = to;
+  int i = count;
 
   while (i-- > 0)
     *t++ = *f++;
@@ -181,9 +181,9 @@ __yy_memcpy (from, to, count)
 static void
 __yy_memcpy (char *from, char *to, int count)
 {
-  register char *f = from;
-  register char *t = to;
-  register int i = count;
+  char *f = from;
+  char *t = to;
+  int i = count;
 
   while (i-- > 0)
     *t++ = *f++;
@@ -211,10 +211,10 @@ int
 yyparse(YYPARSE_PARAM)
      YYPARSE_PARAM_DECL
 {
-  register int yystate;
-  register int yyn;
-  register short *yyssp;
-  register YYSTYPE *yyvsp;
+  int yystate;
+  int yyn;
+  short *yyssp;
+  YYSTYPE *yyvsp;
   int yyerrstatus;	/*  number of tokens to shift before error messages enabled */
   int yychar1 = 0;		/*  lookahead token as an internal (translated) token number */
 
diff --git a/Engine/source/console/cmdgram.cpp b/Engine/source/console/cmdgram.cpp
index aab109792..3bf0131d6 100644
--- a/Engine/source/console/cmdgram.cpp
+++ b/Engine/source/console/cmdgram.cpp
@@ -1247,9 +1247,9 @@ __yy_memcpy (from, to, count)
      char *to;
      int count;
 {
-  register char *f = from;
-  register char *t = to;
-  register int i = count;
+  char *f = from;
+  char *t = to;
+  int i = count;
 
   while (i-- > 0)
     *t++ = *f++;
@@ -1262,9 +1262,9 @@ __yy_memcpy (from, to, count)
 static void
 __yy_memcpy (char *from, char *to, int count)
 {
-  register char *f = from;
-  register char *t = to;
-  register int i = count;
+  char *f = from;
+  char *t = to;
+  int i = count;
 
   while (i-- > 0)
     *t++ = *f++;
@@ -1292,10 +1292,10 @@ int
 yyparse(YYPARSE_PARAM)
      YYPARSE_PARAM_DECL
 {
-  register int yystate;
-  register int yyn;
-  register short *yyssp;
-  register YYSTYPE *yyvsp;
+  int yystate;
+  int yyn;
+  short *yyssp;
+  YYSTYPE *yyvsp;
   int yyerrstatus;	/*  number of tokens to shift before error messages enabled */
   int yychar1 = 0;		/*  lookahead token as an internal (translated) token number */
 

From a30e9c6242e8684661cbb900d1b3565ea7961603 Mon Sep 17 00:00:00 2001
From: Areloch <Areloch@gmail.com>
Date: Sat, 4 Dec 2021 22:47:10 -0600
Subject: [PATCH 279/399] Removes the Library tabs from the World and GUI
 editors to avoid confusion. Adjusts the creation namespace from
 ECreatorWindow to a dummy object ObjectCreator to handle invoking for
 creation

---
 .../tools/VPathEditor/Scripts/Editor.tscript  |   2 +-
 .../tools/VPathEditor/Scripts/Plugin.tscript  |   2 +-
 .../assetBrowser/scripts/assetBrowser.tscript |   5 +-
 .../scripts/assetTypes/creatorObj.tscript     |   2 +-
 .../assetTypes/datablockObjects.tscript       |   4 +-
 .../scripts/assetTypes/gameObject.tscript     |   4 +-
 .../scripts/assetTypes/prefab.tscript         |   2 +-
 .../scripts/assetTypes/sound.tscript          |   2 +-
 .../assetBrowser/scripts/creator.tscript      |   2 +-
 .../game/tools/gui/colladaImport.ed.gui       |   2 +-
 .../game/tools/guiEditor/gui/guiEditor.ed.gui |  70 ----
 .../guiEditor/scripts/guiEditor.ed.tscript    |   5 -
 .../game/tools/navEditor/main.tscript         |  10 +-
 .../gui/WorldEditorTreeWindow.ed.gui          | 325 ------------------
 .../worldEditor/gui/objectBuilderGui.ed.gui   |  42 +--
 .../worldEditor/scripts/EditorGui.ed.tscript  |  14 +-
 .../scripts/editors/creator.ed.tscript        |  70 ++--
 17 files changed, 83 insertions(+), 480 deletions(-)

diff --git a/Templates/BaseGame/game/tools/VPathEditor/Scripts/Editor.tscript b/Templates/BaseGame/game/tools/VPathEditor/Scripts/Editor.tscript
index c940eddcc..363e17bde 100644
--- a/Templates/BaseGame/game/tools/VPathEditor/Scripts/Editor.tscript
+++ b/Templates/BaseGame/game/tools/VPathEditor/Scripts/Editor.tscript
@@ -136,7 +136,7 @@ function VPathTreeView::DeleteSelectedPaths( %this )
 function VPathTreeView::CreatePath( %this )
 {
     // Create Path Object.
-    EWCreatorWindow.createObject( "ObjectBuilderGui.buildObject( \"VPath\" );" );
+    ObjectCreator.createObject( "ObjectBuilderGui.buildObject( \"VPath\" );" );
 }
 
 //-----------------------------------------------------------------------------
diff --git a/Templates/BaseGame/game/tools/VPathEditor/Scripts/Plugin.tscript b/Templates/BaseGame/game/tools/VPathEditor/Scripts/Plugin.tscript
index 287b94ec3..e264f9312 100644
--- a/Templates/BaseGame/game/tools/VPathEditor/Scripts/Plugin.tscript
+++ b/Templates/BaseGame/game/tools/VPathEditor/Scripts/Plugin.tscript
@@ -105,7 +105,7 @@ function VPathEditorPlugin::onWorldEditorStartup( %this )
     //
     //----------------------------------------------------------------------
     
-    EWCreatorWindow.registerMissionObject( "VPath", "VPath", "", "Level" );
+    ObjectCreator.registerMissionObject( "VPath", "VPath", "", "Level" );
 }
 
 //EditorGui.setEditor(\"VPathEditorPlugin\");
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
index 283030684..bd7c78f90 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
@@ -35,6 +35,9 @@ function AssetBrowser::initialize(%this)
    if(!isObject(AssetPreviewArray))
       new ArrayObject(AssetPreviewArray);
       
+   if(!isObject(ObjectCreator))
+      new ScriptObject(ObjectCreator);
+      
    if(!isObject(%this.dirHandler))
    {
       %this.dirHandler = makedirectoryHandler(AssetBrowser-->filterTree, "cache,shaderCache", ""); 
@@ -2301,7 +2304,7 @@ function EWorldEditor::onControlDropped( %this, %payload, %position )
 
    %assetType = %payload.assetType;
    
-   %pos = EWCreatorWindow.getCreateObjectPosition(); //LocalClientConnection.camera.position; 
+   %pos = ObjectCreator.getCreateObjectPosition(); //LocalClientConnection.camera.position; 
    %module = %payload.moduleName;
    %asset = %payload.assetName;
    
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/creatorObj.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/creatorObj.tscript
index 44c84bec7..709a28148 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/creatorObj.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/creatorObj.tscript
@@ -37,7 +37,7 @@ function AssetBrowser::onCreatorEditorDropped(%this, %assetDef, %position)
    %camPos = LocalClientConnection.camera.getPosition();
    %rayResult = containerRayCast(%camPos, %targetPosition, -1);
    
-   %pos = EWCreatorWindow.getCreateObjectPosition();
+   %pos = ObjectCreator.getCreateObjectPosition();
 
    if(%rayResult != 0)
    {
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/datablockObjects.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/datablockObjects.tscript
index a0aad9382..86bd497b5 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/datablockObjects.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/datablockObjects.tscript
@@ -88,7 +88,7 @@ function spawnDatablockObject(%datablock)
    %cmd = %class @ "::create(" @ %name @ ");";
    
    %shapePath = ( %datablock.shapeAsset !$= "" ) ? %datablock.shapeFile : %datablock.shapeName;
-   %createCmd = "EWCreatorWindow.createObject( \"" @ %cmd @ "\" );";
+   %createCmd = "ObjectCreator.createObject( \"" @ %cmd @ "\" );";
    return eval(%createCmd);//eval("showImportDialog( \"" @ %shapePath @ "\", \"" @ %createCmd @ "\" );");
 }
 
@@ -171,7 +171,7 @@ function AssetBrowser::onDatablockEditorDropped(%this, %assetDef, %position)
    %camPos = LocalClientConnection.camera.getPosition();
    %rayResult = containerRayCast(%camPos, %targetPosition, -1);
    
-   %pos = EWCreatorWindow.getCreateObjectPosition();
+   %pos = ObjectCreator.getCreateObjectPosition();
 
    if(%rayResult != 0)
    {
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/gameObject.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/gameObject.tscript
index e3a5014ad..bdf079ad0 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/gameObject.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/gameObject.tscript
@@ -109,7 +109,7 @@ function AssetBrowser::dragAndDropGameObjectAsset(%this, %assetDef, %dropTarget)
          
          getScene(0).add(%gameObject);
          
-         %pos = EWCreatorWindow.getCreateObjectPosition(); //LocalClientConnection.camera.position; 
+         %pos = ObjectCreator.getCreateObjectPosition(); //LocalClientConnection.camera.position; 
       
          %gameObject.position = %pos;
          
@@ -131,7 +131,7 @@ function AssetBrowser::onGameObjectAssetEditorDropped(%this, %assetDef, %positio
    %camPos = LocalClientConnection.camera.getPosition();
    %rayResult = containerRayCast(%camPos, %targetPosition, -1);
    
-   %pos = EWCreatorWindow.getCreateObjectPosition();
+   %pos = ObjectCreator.getCreateObjectPosition();
 
    if(%rayResult != 0)
    {
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/prefab.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/prefab.tscript
index f4b42a66b..a40302e22 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/prefab.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/prefab.tscript
@@ -38,7 +38,7 @@ function AssetBrowser::onPrefabEditorDropped(%this, %assetDef, %position)
    %camPos = LocalClientConnection.camera.getPosition();
    %rayResult = containerRayCast(%camPos, %targetPosition, -1);
    
-   %pos = EWCreatorWindow.getCreateObjectPosition();
+   %pos = ObjectCreator.getCreateObjectPosition();
 
    if(%rayResult != 0)
    {
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/sound.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/sound.tscript
index 3322964bc..04ab8d508 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/sound.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/sound.tscript
@@ -45,7 +45,7 @@ function AssetBrowser::onSoundAssetEditorDropped(%this, %assetDef, %position)
    %camPos = LocalClientConnection.camera.getPosition();
    %rayResult = containerRayCast(%camPos, %targetPosition, -1);
    
-   %pos = EWCreatorWindow.getCreateObjectPosition();
+   %pos = ObjectCreator.getCreateObjectPosition();
 
    if(%rayResult != 0)
    {
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript
index 8971087c5..26bc7202b 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript
@@ -178,7 +178,7 @@ function AssetBrowser::addCreatorClass(%this, %class, %name, %buildfunc)
       else
          %cmd = "ObjectBuilderGui." @ %method @ "();";
 
-      %buildfunc = "ObjectBuilderGui.newObjectCallback = \"AssetBrowser.onFinishCreateObject\"; EWCreatorWindow.createObject( \"" @ %cmd @ "\" );";
+      %buildfunc = "ObjectBuilderGui.newObjectCallback = \"AssetBrowser.onFinishCreateObject\"; ObjectCreator.createObject( \"" @ %cmd @ "\" );";
    }
    
    %args = new ScriptObject();
diff --git a/Templates/BaseGame/game/tools/gui/colladaImport.ed.gui b/Templates/BaseGame/game/tools/gui/colladaImport.ed.gui
index ebd2c822a..d7fc1bce0 100644
--- a/Templates/BaseGame/game/tools/gui/colladaImport.ed.gui
+++ b/Templates/BaseGame/game/tools/gui/colladaImport.ed.gui
@@ -1251,7 +1251,7 @@ function ColladaImportDlg::showDialog(%this, %shapePath, %cmd)
    %this.cmd = %cmd;
 
    // Only allow loading lights if creating a new scene object
-   %canLoadLights = (strstr(%this.cmd, "EWCreatorWindow.create") != -1);
+   %canLoadLights = (strstr(%this.cmd, "ObjectCreator.create") != -1);
 
    // Check for an existing TSShapeConstructor object. Need to exec the script
    // manually as the DAE resource may not have been loaded yet
diff --git a/Templates/BaseGame/game/tools/guiEditor/gui/guiEditor.ed.gui b/Templates/BaseGame/game/tools/guiEditor/gui/guiEditor.ed.gui
index 0560ff57b..a71ce2a07 100644
--- a/Templates/BaseGame/game/tools/guiEditor/gui/guiEditor.ed.gui
+++ b/Templates/BaseGame/game/tools/guiEditor/gui/guiEditor.ed.gui
@@ -1010,76 +1010,6 @@ $guiContent = new GuiControl(GuiEditorGui, EditorGuiGroup) {
                };
             };
             
-            new GuiTabPageCtrl() {
-               fitBook = "1";
-               text = "Library";
-               maxLength = "1024";
-               docking = "client";
-               Margin = "-1 0 0 0";
-               Padding = "0 0 0 0";
-               AnchorTop = "1";
-               AnchorBottom = "0";
-               AnchorLeft = "1";
-               AnchorRight = "0";
-               isContainer = "1";
-               Profile = "ToolsGuiTabPageProfile";
-               HorizSizing = "width";
-               VertSizing = "height";
-               position = "0 20";
-               Extent = "223 734";
-               MinExtent = "8 2";
-               canSave = "1";
-               Visible = "0";
-               tooltipprofile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
-               canSaveDynamicFields = "0";
-               internalName = "toolboxPage";
-
-               new GuiScrollCtrl() {
-                  canSaveDynamicFields = "0";
-                  Enabled = "1";
-                  isContainer = "1";
-                  Profile = "ToolsGuiScrollProfile";
-                  HorizSizing = "width";
-                  VertSizing = "height";
-                  position = "0 0";
-                  MinExtent = "8 2";
-                  canSave = "1";
-                  Visible = "1";
-                  hovertime = "1000";
-                  willFirstRespond = "1";
-                  hScrollBar = "alwaysOff";
-                  vScrollBar = "dynamic";
-                  lockHorizScroll = "true";
-                  lockVertScroll = "false";
-                  constantThumbHeight = "0";
-                  childMargin = "0 0";
-                  docking = "client";
-
-                  new GuiStackControl(GuiEditorToolbox) {
-                     StackingType = "Vertical";
-                     HorizStacking = "Left to Right";
-                     VertStacking = "Top to Bottom";
-                     Padding = "2";
-                     DynamicSize = "1";
-                     ChangeChildSizeToFit = "1";
-                     ChangeChildPosition = "1";
-                     isContainer = "1";
-                     Profile = "ToolsGuiDefaultProfile";
-                     HorizSizing = "width";
-                     VertSizing = "bottom";
-                     position = "3 3";
-                     Extent = "419 10008";
-                     MinExtent = "16 16";
-                     canSave = "1";
-                     Visible = "1";
-                     tooltipprofile = "ToolsGuiToolTipProfile";
-                     hovertime = "1000";
-                     canSaveDynamicFields = "0";
-                  };
-               };
-            };
-         
             new GuiTabPageCtrl() {
                fitBook = "1";
                text = "Profiles";
diff --git a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditor.ed.tscript b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditor.ed.tscript
index bdbab3018..b124b99f3 100644
--- a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditor.ed.tscript
@@ -1023,11 +1023,6 @@ function GuiEditorGui::onWake( %this )
 
    %this.initSettings();
    %this.readSettings();
-   
-   // Initialize toolbox.
-
-   if( !GuiEditorToolbox.isInitialized )
-      GuiEditorToolbox.initialize();
 
    // Set up initial menu toggle states.
    
diff --git a/Templates/BaseGame/game/tools/navEditor/main.tscript b/Templates/BaseGame/game/tools/navEditor/main.tscript
index e901cb401..28303a576 100644
--- a/Templates/BaseGame/game/tools/navEditor/main.tscript
+++ b/Templates/BaseGame/game/tools/navEditor/main.tscript
@@ -91,13 +91,13 @@ function NavEditorPlugin::onWorldEditorStartup(%this)
    ENavEditorSettingsPage.init();
 
    // Add items to World Editor Creator
-   EWCreatorWindow.beginGroup("Navigation");
+   ObjectCreator.beginGroup("Navigation");
 
-      EWCreatorWindow.registerMissionObject("CoverPoint", "Cover point");
-      EWCreatorWindow.registerMissionObject("NavPath", "Nav Path");
-	  EWCreatorWindow.registerMissionObject("NavMesh", "Navigation mesh");
+      ObjectCreator.registerMissionObject("CoverPoint", "Cover point");
+      ObjectCreator.registerMissionObject("NavPath", "Nav Path");
+	  ObjectCreator.registerMissionObject("NavMesh", "Navigation mesh");
 
-   EWCreatorWindow.endGroup();
+   ObjectCreator.endGroup();
 }
 
 function ENavEditorSettingsPage::init(%this)
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/WorldEditorTreeWindow.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/WorldEditorTreeWindow.ed.gui
index 44b200abd..45bc34cae 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/WorldEditorTreeWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/WorldEditorTreeWindow.ed.gui
@@ -176,331 +176,6 @@ $guiContent = new GuiControl() {
                };
             };
          };
-         new GuiTabPageCtrl(EWCreatorWindow) {
-            canSaveDynamicFields = "0";
-            internalName = "CreatorWindow";
-            Enabled = "1";
-            isContainer = "1";
-            Profile = "ToolsGuiEditorTabPage";
-            HorizSizing = "width";
-            VertSizing = "height";
-            position = "0 19";
-            Extent = "208 274";
-            MinExtent = "8 2";
-            canSave = "1";
-            Visible = "1";
-            hovertime = "1000";
-            Margin = "0 0 0 0";
-            Padding = "0 0 0 0";
-            AnchorTop = "1";
-            AnchorBottom = "0";
-            AnchorLeft = "1";
-            AnchorRight = "0";
-            text = "Library";
-            maxLength = "1024";
-            
-            new GuiControl() {
-            canSaveDynamicFields = "0";
-            Enabled = "1";
-            isContainer = "0";
-            Profile = "GuiInspectorProfile";
-            HorizSizing = "width";
-            VertSizing = "bottom";
-            position = "0 0";
-            Extent = "198 271";
-            MinExtent = "8 2";
-            canSave = "0";
-            Visible = "1";
-         };
-         new GuiBitmapBorderCtrl() {
-            canSaveDynamicFields = "0";
-            Enabled = "1";
-            isContainer = "0";
-            Profile = "ToolsGuiTabBorderProfile";
-            HorizSizing = "width";
-            VertSizing = "bottom";
-            position = "5 5";
-            Extent = "198 271";
-            MinExtent = "8 2";
-            canSave = "0";
-            Visible = "1";
-            hovertime = "1000";
-         };
-         new GuiBitmapBorderCtrl() {
-            canSaveDynamicFields = "0";
-            Enabled = "1";
-            isContainer = "0";
-            Profile = "ToolsGuiTabBorderProfile";
-            HorizSizing = "width";
-            VertSizing = "bottom";
-            position = "0 25";
-            Extent = "198 246";
-            MinExtent = "8 2";
-            canSave = "0";
-            Visible = "1";
-            hovertime = "1000";
-         };
-            new GuiContainer() {
-               canSaveDynamicFields = "0";
-               Enabled = "1";
-               isContainer = "0";
-               Profile = "ToolsGuiTransparentProfile";
-               HorizSizing = "width";
-               VertSizing = "height";
-               Position = "-4 47";
-               Extent = "206 228";
-               MinExtent = "8 2";
-               canSave = "1";
-               Visible = "1";
-               tooltipprofile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
-               Margin = "0 0 0 0";
-               Padding = "0 0 0 0";
-               AnchorTop = "1";
-               AnchorBottom = "0";
-               AnchorLeft = "1";
-               AnchorRight = "0";
-
-               new GuiScrollCtrl() {
-                  canSaveDynamicFields = "0";
-                  Enabled = "1";
-                  isContainer = "1";
-                  Profile = "EditorLightScrollProfile";
-                  HorizSizing = "width";
-                  VertSizing = "bottom";
-                  Position = "4 4";
-                  Extent = "198 220";
-                  MinExtent = "8 2";
-                  canSave = "1";
-                  Visible = "1";
-                  tooltipprofile = "ToolsGuiToolTipProfile";
-                  profile = "ToolsGuiScrollProfile";
-                  hovertime = "1000";
-                  Docking = "Client";
-                  Margin = "0 0 0 0";
-                  Padding = "0 0 0 0";
-                  AnchorTop = "1";
-                  AnchorBottom = "0";
-                  AnchorLeft = "1";
-                  AnchorRight = "0";
-                  willFirstRespond = "1";
-                  hScrollBar = "dynamic";
-                  vScrollBar = "alwaysOff";
-                  lockHorizScroll = "false";
-                  lockVertScroll = "true";
-                  constantThumbHeight = "0";
-                  childMargin = "0 6";
-
-                  new GuiDynamicCtrlArrayControl(CreatorIconArray) {
-                     canSaveDynamicFields = "0";
-                     Enabled = "1";
-                     isContainer = "1";
-                     Profile = "ToolsGuiTransparentProfile";
-                     HorizSizing = "width";
-                     VertSizing = "height";
-                     Position = "1 1";
-                     Extent = "197 218";
-                     MinExtent = "8 2";
-                     canSave = "1";
-                     Visible = "1";
-                     tooltipprofile = "ToolsGuiToolTipProfile";
-                     hovertime = "1000";
-                     colCount = "20";
-                     colSize = "64";
-                     rowCount = "0";
-                     RowSize = "32";
-                     rowSpacing = "4";
-                     colSpacing = "4";
-                     frozen = "0";
-                     autoCellSize = "1";
-                     fillRowFirst = "0";
-                     dynamicSize = "1";
-                  };
-               };
-            };
-            new GuiControl() {
-               canSaveDynamicFields = "0";
-               Enabled = "1";
-               isContainer = "1";
-               Profile = "ToolsGuiDefaultProfile";
-               HorizSizing = "width";
-               VertSizing = "bottom";
-               Position = "-3 2";
-               Extent = "202 55";
-               MinExtent = "8 2";
-               canSave = "1";
-               Visible = "1";
-               tooltipprofile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
-
-               new GuiBitmapButtonCtrl(CreatorNavUpButton) {
-                  canSaveDynamicFields = "0";
-                  Enabled = "1";
-                  isContainer = "0";
-                  Profile = "ToolsGuiButtonProfile";
-                  HorizSizing = "right";
-                  VertSizing = "bottom";
-                  Position = "9 28";
-                  Extent = "20 19";
-                  MinExtent = "8 2";
-                  canSave = "1";
-                  Visible = "1";
-                  Command = "EWCreatorWindow.navigateUp();";
-                  tooltipprofile = "ToolsGuiToolTipProfile";
-                  hovertime = "1000";
-                  groupNum = "0";
-                  buttonType = "PushButton";
-                  
-                  Bitmap = "ToolsModule:folderUp_image";
-                  autoSize = "0";
-               };
-               new GuiPopUpMenuCtrl(CreatorPopupMenu) {
-                  canSaveDynamicFields = "0";
-                  Enabled = "1";
-                  isContainer = "0";
-                  Profile = "ToolsGuiPopUpMenuProfile";
-                  HorizSizing = "width";
-                  VertSizing = "bottom";
-                  Position = "32 28";
-                  Extent = "163 18";
-                  MinExtent = "8 2";
-                  canSave = "1";
-                  Visible = "1";
-                  tooltipprofile = "ToolsGuiToolTipProfile";
-                  hovertime = "1000";
-                  Margin = "0 0 0 0";
-                  Padding = "0 0 0 0";
-                  AnchorTop = "1";
-                  AnchorBottom = "0";
-                  AnchorLeft = "1";
-                  AnchorRight = "0";
-                  text = "Objects";
-                  maxLength = "1024";
-                  maxPopupHeight = "200";
-                  sbUsesNAColor = "0";
-                  reverseTextList = "0";
-                  bitmapBounds = "16 16";
-               };
-               new GuiTabBookCtrl(CreatorTabBook) {
-                  canSaveDynamicFields = "0";
-                  Enabled = "1";
-                  isContainer = "1";
-                  Profile = "ToolsGuiTabBookProfile";
-                  HorizSizing = "width";
-                  VertSizing = "bottom";
-                  Position = "0 4";
-                  Extent = "201 25";
-                  MinExtent = "8 2";
-                  canSave = "1";
-                  Visible = "1";
-                  tooltipprofile = "ToolsGuiToolTipProfile";
-                  hovertime = "1000";
-                  Docking = "None";
-                  Margin = "0 0 0 0";
-                  Padding = "0 0 0 0";
-                  AnchorTop = "1";
-                  AnchorBottom = "0";
-                  AnchorLeft = "1";
-                  AnchorRight = "0";
-                  TabPosition = "Top";
-                  TabMargin = "0";
-                  MinTabWidth = "49";
-
-                  new GuiTabPageCtrl() {
-                     canSaveDynamicFields = "0";
-                     Enabled = "1";
-                     isContainer = "1";
-                     Profile = "ToolsGuiTabPageProfile";
-                     HorizSizing = "width";
-                     VertSizing = "height";
-                     Position = "0 0";
-                     Extent = "0 0";
-                     MinExtent = "0 0";
-                     canSave = "1";
-                     Visible = "0";
-                     tooltipprofile = "ToolsGuiToolTipProfile";
-                     hovertime = "1000";
-                     Margin = "0 0 0 0";
-                     Padding = "0 0 0 0";
-                     AnchorTop = "1";
-                     AnchorBottom = "0";
-                     AnchorLeft = "1";
-                     AnchorRight = "0";
-                     text = "Scripted";
-                     maxLength = "1024";
-                  };
-                  new GuiTabPageCtrl() {
-                     canSaveDynamicFields = "0";
-                     Enabled = "1";
-                     isContainer = "1";
-                     Profile = "ToolsGuiTabPageProfile";
-                     HorizSizing = "width";
-                     VertSizing = "height";
-                     Position = "0 0";
-                     Extent = "0 0";
-                     MinExtent = "0 0";
-                     canSave = "1";
-                     Visible = "0";
-                     tooltipprofile = "ToolsGuiToolTipProfile";
-                     hovertime = "1000";
-                     Margin = "0 0 0 0";
-                     Padding = "0 0 0 0";
-                     AnchorTop = "1";
-                     AnchorBottom = "0";
-                     AnchorLeft = "1";
-                     AnchorRight = "0";
-                     text = "Meshes";
-                     maxLength = "1024";
-                  };
-                  new GuiTabPageCtrl() {
-                     canSaveDynamicFields = "0";
-                     Enabled = "1";
-                     isContainer = "1";
-                     Profile = "ToolsGuiTabPageProfile";
-                     HorizSizing = "width";
-                     VertSizing = "height";
-                     Position = "0 0";
-                     Extent = "0 0";
-                     MinExtent = "0 0";
-                     canSave = "1";
-                     Visible = "1";
-                     tooltipprofile = "ToolsGuiToolTipProfile";
-                     hovertime = "1000";
-                     Margin = "0 0 0 0";
-                     Padding = "0 0 0 0";
-                     AnchorTop = "1";
-                     AnchorBottom = "0";
-                     AnchorLeft = "1";
-                     AnchorRight = "0";
-                     text = "Level";
-                     maxLength = "1024";
-                  };
-                  new GuiTabPageCtrl() {
-                     canSaveDynamicFields = "0";
-                     Enabled = "1";
-                     isContainer = "1";
-                     Profile = "ToolsGuiTabPageProfile";
-                     HorizSizing = "width";
-                     VertSizing = "height";
-                     Position = "0 0";
-                     Extent = "0 0";
-                     MinExtent = "0 0";
-                     canSave = "1";
-                     Visible = "1";
-                     tooltipprofile = "ToolsGuiToolTipProfile";
-                     hovertime = "1000";
-                     Margin = "0 0 0 0";
-                     Padding = "0 0 0 0";
-                     AnchorTop = "1";
-                     AnchorBottom = "0";
-                     AnchorLeft = "1";
-                     AnchorRight = "0";
-                     text = "Prefabs";
-                     maxLength = "1024";
-                  };
-               };
-            };
-         };
       };
       new GuiBitmapButtonCtrl() {
          canSaveDynamicFields = "0";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/objectBuilderGui.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/objectBuilderGui.ed.gui
index 8dafe0357..e34860771 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/objectBuilderGui.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/objectBuilderGui.ed.gui
@@ -973,7 +973,7 @@ function ObjectBuilderGui::processNewObject(%this, %obj)
    if( %this.objectGroup !$= "" )
       %this.objectGroup.add( %obj );
    else
-      EWCreatorWindow.objectGroup.add( %obj );
+      ObjectCreator.objectGroup.add( %obj );
       
    // If we were given a callback to call after the
    // object has been created, do so now.  Also clear
@@ -1148,9 +1148,9 @@ function ObjectBuilderGui::buildBasicClouds(%this)
 
 function ObjectBuilderGui::checkExists( %this, %classname )
 {
-   for ( %i = 0; %i < EWCreatorWindow.objectGroup.getCount(); %i++ )
+   for ( %i = 0; %i < ObjectCreator.objectGroup.getCount(); %i++ )
    {                                                   
-      %obj = EWCreatorWindow.objectGroup.getObject( %i );
+      %obj = ObjectCreator.objectGroup.getObject( %i );
       if ( %obj.getClassName() $= %classname ) 
          return true;
    } 
@@ -1425,7 +1425,7 @@ function ObjectBuilderGui::buildPlayerDropPoint(%this)
    %this.addField("spawnClass",     "TypeString",    "Spawn Class", "Player");
    %this.addField("spawnDatablock", "TypeDataBlock", "Spawn Data", "PlayerData DefaultPlayerData");
 
-   if( EWCreatorWindow.objectGroup.getID() == getScene(0).getID() )
+   if( ObjectCreator.objectGroup.getID() == getScene(0).getID() )
    {
       if( !isObject("PlayerDropPoints") )
          getScene(0).add( new SimGroup("PlayerDropPoints") );
@@ -1445,7 +1445,7 @@ function ObjectBuilderGui::buildObserverDropPoint(%this)
    %this.addField("spawnClass",     "TypeString",    "Spawn Class", "Camera");
    %this.addField("spawnDatablock", "TypeDataBlock", "Spawn Data", "CameraData Observer");
 
-   if( EWCreatorWindow.objectGroup.getID() == getScene(0).getID() )
+   if( ObjectCreator.objectGroup.getID() == getScene(0).getID() )
    {
       if( !isObject("ObserverDropPoints") )
          getScene(0).add( new SimGroup("ObserverDropPoints") );
@@ -1508,7 +1508,7 @@ function PhysicsEntityData::create(%data)
 {
    %obj = new PhysicsEntity() {
       dataBlock = %data;
-      parentGroup = EWCreatorWindow.objectGroup;
+      parentGroup = ObjectCreator.objectGroup;
    };
    return %obj;
 }
@@ -1517,7 +1517,7 @@ function StaticShapeData::create(%data)
 {
    %obj = new StaticShape() {
       dataBlock = %data;
-      parentGroup = EWCreatorWindow.objectGroup;
+      parentGroup = ObjectCreator.objectGroup;
    };
    return %obj;
 }
@@ -1529,13 +1529,13 @@ function MissionMarkerData::create(%block)
       case "WayPointMarker":
          %obj = new WayPoint() {
             dataBlock = %block;
-            parentGroup = EWCreatorWindow.objectGroup;
+            parentGroup = ObjectCreator.objectGroup;
          };
          return(%obj);
       case "SpawnSphereMarker":
          %obj = new SpawnSphere() {
             datablock = %block;
-            parentGroup = EWCreatorWindow.objectGroup;
+            parentGroup = ObjectCreator.objectGroup;
          };
          return(%obj);
    }
@@ -1548,7 +1548,7 @@ function ItemData::create(%data)
    %obj = new Item()
    {
       dataBlock = %data;
-      parentGroup = EWCreatorWindow.objectGroup;
+      parentGroup = ObjectCreator.objectGroup;
       static = true;
       rotate = true;
    };
@@ -1561,7 +1561,7 @@ function TurretShapeData::create(%block)
       dataBlock = %block;
       static = true;
       respawn = true;
-      parentGroup = EWCreatorWindow.objectGroup;
+      parentGroup = ObjectCreator.objectGroup;
    };
    return %obj;
 }
@@ -1572,7 +1572,7 @@ function AITurretShapeData::create(%block)
       dataBlock = %block;
       static = true;
       respawn = true;
-      parentGroup = EWCreatorWindow.objectGroup;
+      parentGroup = ObjectCreator.objectGroup;
    };
    return %obj;
 }
@@ -1581,7 +1581,7 @@ function WheeledVehicleData::create(%block)
 {
    %obj = new WheeledVehicle() {
       dataBlock = %block;
-      parentGroup = EWCreatorWindow.objectGroup;
+      parentGroup = ObjectCreator.objectGroup;
    };
    return %obj;
 }
@@ -1591,7 +1591,7 @@ function FlyingVehicleData::create(%block)
    %obj = new FlyingVehicle()
    {
       dataBlock = %block;
-      parentGroup = EWCreatorWindow.objectGroup;
+      parentGroup = ObjectCreator.objectGroup;
    };
    return(%obj);
 }
@@ -1601,7 +1601,7 @@ function HoverVehicleData::create(%block)
    %obj = new HoverVehicle()
    {
       dataBlock = %block;
-      parentGroup = EWCreatorWindow.objectGroup;
+      parentGroup = ObjectCreator.objectGroup;
    };
    return(%obj);
 }
@@ -1610,7 +1610,7 @@ function RigidShapeData::create(%data)
 {
    %obj = new RigidShape() {
       dataBlock = %data;
-      parentGroup = EWCreatorWindow.objectGroup;
+      parentGroup = ObjectCreator.objectGroup;
    };
    return %obj;
 }
@@ -1620,7 +1620,7 @@ function PhysicsShapeData::create( %datablock )
    %obj = new PhysicsShape()
    {
 		dataBlock = %datablock;
-		parentGroup = EWCreatorWindow.objectGroup;
+		parentGroup = ObjectCreator.objectGroup;
 		
       invulnerable = false;
       damageRadius = 0;
@@ -1637,7 +1637,7 @@ function ProximityMineData::create( %datablock )
    %obj = new ProximityMine()
    {
       dataBlock = %dataBlock;
-      parentGroup = EWCreatorWindow.objectGroup;
+      parentGroup = ObjectCreator.objectGroup;
       static = true;    // mines created by the editor are static, and armed immediately
    };
 
@@ -1660,7 +1660,7 @@ function ParticleEmitterData::create( %datablock )
    %obj = new ParticleEmitter()
    {
       dataBlock = %datablock;
-      parentGroup = EWCreatorWindow.objectGroup;
+      parentGroup = ObjectCreator.objectGroup;
    };
    return %obj;
 }
@@ -1670,7 +1670,7 @@ function PrecipitationData::create(%datablock)
    %obj = new Precipitation()
    {
       dataBlock = %datablock;
-      parentGroup = EWCreatorWindow.objectGroup;
+      parentGroup = ObjectCreator.objectGroup;
    };
    return %obj;
 }
@@ -1680,7 +1680,7 @@ function TriggerData::create(%datablock)
    %obj = new Trigger()
    {
       dataBlock = %datablock;
-      parentGroup = EWCreatorWindow.objectGroup;
+      parentGroup = ObjectCreator.objectGroup;
       polyhedron = "-0.5 0.5 0.0 1.0 0.0 0.0 0.0 -1.0 0.0 0.0 0.0 1.0";
    };
    return %obj;
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
index 1b6ea6068..1ba706257 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
@@ -216,7 +216,7 @@ function EditorGui::init(%this)
    ETerrainEditor.init();
 
    //Creator.init();
-   EWCreatorWindow.init();
+   ObjectCreator.init();
    ObjectBuilderGui.init();
 
    %this.setMenuDefaultState();
@@ -873,7 +873,7 @@ function WorldEditorPlugin::onActivated( %this )
    EditorGui.menuBar.insert( EditorGui.worldMenu, EditorGui.menuBar.dynamicItemInsertPos );
    EWorldEditor.makeFirstResponder(true);
    EditorTree.open($scenesRootGroup,true);
-   EWCreatorWindow.setNewObjectGroup(getScene(0));
+   ObjectCreator.setNewObjectGroup(getScene(0));
    
    EditorTree.expandItem(1);
    EditorTree.buildVisibleTree(true);
@@ -1521,8 +1521,8 @@ function EditorTree::onDeleteObject( %this, %object )
    if( %object.locked )
       return true;
    
-   if( %object == EWCreatorWindow.objectGroup )
-      EWCreatorWindow.setNewObjectGroup( getScene(0) );
+   if( %object == ObjectCreator.objectGroup )
+      ObjectCreator.setNewObjectGroup( getScene(0) );
 
    // Append it to our list.
    %this.undoDeleteList = %this.undoDeleteList TAB %object;
@@ -1620,7 +1620,7 @@ function EditorTree::onDragDropped(%this)
 
 function EditorTree::onAddGroupSelected(%this, %group)
 {
-   EWCreatorWindow.setNewObjectGroup(%group);
+   ObjectCreator.setNewObjectGroup(%group);
 }
 
 function EditorTree::onRightMouseUp( %this, %itemId, %mouse, %obj )
@@ -1706,7 +1706,7 @@ function EditorTree::onRightMouseUp( %this, %itemId, %mouse, %obj )
             %popup.item[ 5 ] = "Toggle Hide Children" TAB "" TAB "EWorldEditor.toggleHideChildren( " @ %popup.object @ " );";
             
             %popup.item[ 8 ] = "-";
-            %popup.item[ 9 ] = "Add New Objects Here" TAB "" TAB "EWCreatorWindow.setNewObjectGroup( " @ %popup.object @ " );";
+            %popup.item[ 9 ] = "Add New Objects Here" TAB "" TAB "ObjectCreator.setNewObjectGroup( " @ %popup.object @ " );";
             %popup.item[ 10 ] = "Add Children to Selection" TAB "" TAB "EWorldEditor.selectAllObjectsInSet( " @ %popup.object @ ", false );";
             %popup.item[ 11 ] = "Remove Children from Selection" TAB "" TAB "EWorldEditor.selectAllObjectsInSet( " @ %popup.object @ ", true );";
             
@@ -2276,7 +2276,7 @@ function EWorldEditor::convertSelectionToConvexShape( %this )
 
 function EWorldEditor::getNewObjectGroup( %this )
 {
-   return EWCreatorWindow.getNewObjectGroup();
+   return ObjectCreator.getNewObjectGroup();
 }
 
 function EWorldEditor::deleteMissionObject( %this, %object )
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/editors/creator.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/editors/creator.ed.tscript
index 8fce4a3fd..201347e2e 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/editors/creator.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/editors/creator.ed.tscript
@@ -21,7 +21,7 @@
 //-----------------------------------------------------------------------------
 
 
-function EWCreatorWindow::init( %this )
+function ObjectCreator::init( %this )
 {
    // Just so we can recall this method for testing changes
    // without restarting.
@@ -113,23 +113,23 @@ function EWCreatorWindow::init( %this )
    %this.endGroup(); 
 }
 
-function EWCreatorWindow::onWake( %this )
+function ObjectCreator::onWake( %this )
 {
    CreatorTabBook.selectPage( 0 );
    CreatorTabBook.onTabSelected( "Scripted" );
 }
 
-function EWCreatorWindow::beginGroup( %this, %group )
+function ObjectCreator::beginGroup( %this, %group )
 {
    %this.currentGroup = %group;   
 }
 
-function EWCreatorWindow::endGroup( %this, %group )
+function ObjectCreator::endGroup( %this, %group )
 {
    %this.currentGroup = "";
 }
 
-function EWCreatorWindow::getCreateObjectPosition()
+function ObjectCreator::getCreateObjectPosition()
 {
    %focusPoint = LocalClientConnection.getControlObject().getLookAtPoint();
    if( %focusPoint $= "" )
@@ -138,7 +138,7 @@ function EWCreatorWindow::getCreateObjectPosition()
       return getWord( %focusPoint, 1 ) SPC getWord( %focusPoint, 2 ) SPC getWord( %focusPoint, 3 );
 }
 
-function EWCreatorWindow::registerMissionObject( %this, %class, %name, %buildfunc, %group )
+function ObjectCreator::registerMissionObject( %this, %class, %name, %buildfunc, %group )
 {
    if( !isClass(%class) )
       return;
@@ -150,7 +150,7 @@ function EWCreatorWindow::registerMissionObject( %this, %class, %name, %buildfun
    
    if ( %class $= "" || %group $= "" )
    {
-      warn( "EWCreatorWindow::registerMissionObject, invalid parameters!" );
+      warn( "ObjectCreator::registerMissionObject, invalid parameters!" );
       return;  
    }
 
@@ -162,12 +162,12 @@ function EWCreatorWindow::registerMissionObject( %this, %class, %name, %buildfun
    %this.array.push_back( %group, %args );
 }
 
-function EWCreatorWindow::getNewObjectGroup( %this )
+function ObjectCreator::getNewObjectGroup( %this )
 {
    return %this.objectGroup;
 }
 
-function EWCreatorWindow::setNewObjectGroup( %this, %group )
+function ObjectCreator::setNewObjectGroup( %this, %group )
 {
    if( %this.objectGroup )
    {
@@ -182,7 +182,7 @@ function EWCreatorWindow::setNewObjectGroup( %this, %group )
    EditorTree.markItem( %itemId );
 }
 
-function EWCreatorWindow::createStatic( %this, %file )
+function ObjectCreator::createStatic( %this, %file )
 {
    if ( !$missionRunning )
       return;
@@ -200,7 +200,7 @@ function EWCreatorWindow::createStatic( %this, %file )
    %this.onObjectCreated( %objId );
 }
 
-function EWCreatorWindow::createPrefab( %this, %file )
+function ObjectCreator::createPrefab( %this, %file )
 {
    if ( !$missionRunning )
       return;
@@ -218,7 +218,7 @@ function EWCreatorWindow::createPrefab( %this, %file )
    %this.onObjectCreated( %objId );
 }
 
-function EWCreatorWindow::createObject( %this, %cmd )
+function ObjectCreator::createObject( %this, %cmd )
 {
    if ( !$missionRunning )
       return;
@@ -236,7 +236,7 @@ function EWCreatorWindow::createObject( %this, %cmd )
    return %objId;
 }
 
-function EWCreatorWindow::onFinishCreateObject( %this, %objId )
+function ObjectCreator::onFinishCreateObject( %this, %objId )
 {
    %this.objectGroup.add( %objId );
 
@@ -251,7 +251,7 @@ function EWCreatorWindow::onFinishCreateObject( %this, %objId )
    %this.onObjectCreated( %objId );
 }
 
-function EWCreatorWindow::onObjectCreated( %this, %objId )
+function ObjectCreator::onObjectCreated( %this, %objId )
 {
    // Can we submit an undo action?
    if ( isObject( %objId ) )
@@ -270,12 +270,12 @@ function CreatorTabBook::onTabSelected( %this, %text, %idx )
 {
    if ( %this.isAwake() )
    {
-      EWCreatorWindow.tab = %text;      
-      EWCreatorWindow.navigate( "" );
+      ObjectCreator.tab = %text;      
+      ObjectCreator.navigate( "" );
    }
 }
 
-function EWCreatorWindow::navigate( %this, %address )
+function ObjectCreator::navigate( %this, %address )
 {
    CreatorIconArray.frozen = true;
    CreatorIconArray.clear();  
@@ -535,7 +535,7 @@ function EWCreatorWindow::navigate( %this, %address )
    CreatorPopupMenu.tooltip = %str;
 }
 
-function EWCreatorWindow::navigateDown( %this, %folder )
+function ObjectCreator::navigateDown( %this, %folder )
 {
    if ( %this.address $= "" )
       %address = %folder;
@@ -548,7 +548,7 @@ function EWCreatorWindow::navigateDown( %this, %folder )
    %this.schedule( 1, "navigate", %address );
 }
 
-function EWCreatorWindow::navigateUp( %this )
+function ObjectCreator::navigateUp( %this )
 {
    %count = getWordCount( %this.address );
    
@@ -563,7 +563,7 @@ function EWCreatorWindow::navigateUp( %this )
    %this.navigate( %address );
 }
 
-function EWCreatorWindow::setListView( %this, %noupdate )
+function ObjectCreator::setListView( %this, %noupdate )
 {
    //CreatorIconArray.clear();
    //CreatorIconArray.setVisible( false );
@@ -576,7 +576,7 @@ function EWCreatorWindow::setListView( %this, %noupdate )
       %this.navigate( %this.address );
 }
 
-//function EWCreatorWindow::setIconView( %this )
+//function ObjectCreator::setIconView( %this )
 //{
    //echo( "setIconView" );
    //
@@ -590,7 +590,7 @@ function EWCreatorWindow::setListView( %this, %noupdate )
    //%this.navigate( %this.address );
 //}
 
-function EWCreatorWindow::findIconCtrl( %this, %name )
+function ObjectCreator::findIconCtrl( %this, %name )
 {
    for ( %i = 0; %i < %this.contentCtrl.getCount(); %i++ )
    {
@@ -602,7 +602,7 @@ function EWCreatorWindow::findIconCtrl( %this, %name )
    return -1;
 }
 
-function EWCreatorWindow::createIcon( %this )
+function ObjectCreator::createIcon( %this )
 {
    %ctrl = new GuiIconButtonCtrl()
    {            
@@ -630,11 +630,11 @@ function EWCreatorWindow::createIcon( %this )
    return %ctrl;
 }
 
-function EWCreatorWindow::addFolderIcon( %this, %text )
+function ObjectCreator::addFolderIcon( %this, %text )
 {
    %ctrl = %this.createIcon();
       
-   %ctrl.altCommand = "EWCreatorWindow.navigateDown(\"" @ %text @ "\");";
+   %ctrl.altCommand = "ObjectCreator.navigateDown(\"" @ %text @ "\");";
    %ctrl.iconBitmap = "tools/gui/images/folder.png";   
    %ctrl.text = %text;
    %ctrl.tooltip = %text;     
@@ -646,7 +646,7 @@ function EWCreatorWindow::addFolderIcon( %this, %text )
    %this.contentCtrl.addGuiControl( %ctrl );   
 }
 
-function EWCreatorWindow::addMissionObjectIcon( %this, %class, %name, %buildfunc )
+function ObjectCreator::addMissionObjectIcon( %this, %class, %name, %buildfunc )
 {
    %ctrl = %this.createIcon();      
 
@@ -661,7 +661,7 @@ function EWCreatorWindow::addMissionObjectIcon( %this, %class, %name, %buildfunc
    else
       %cmd = "ObjectBuilderGui." @ %method @ "();";
 
-   %ctrl.altCommand = "ObjectBuilderGui.newObjectCallback = \"EWCreatorWindow.onFinishCreateObject\"; EWCreatorWindow.createObject( \"" @ %cmd @ "\" );";
+   %ctrl.altCommand = "ObjectBuilderGui.newObjectCallback = \"ObjectCreator.onFinishCreateObject\"; ObjectCreator.createObject( \"" @ %cmd @ "\" );";
    %ctrl.iconBitmap = EditorIconRegistry::findIconByClassName( %class );
    %ctrl.text = %name;
    %ctrl.class = "CreatorMissionObjectIconBtn";   
@@ -673,7 +673,7 @@ function EWCreatorWindow::addMissionObjectIcon( %this, %class, %name, %buildfunc
    %this.contentCtrl.addGuiControl( %ctrl );
 }
 
-function EWCreatorWindow::addShapeIcon( %this, %datablock )
+function ObjectCreator::addShapeIcon( %this, %datablock )
 {
    %ctrl = %this.createIcon();
    
@@ -683,7 +683,7 @@ function EWCreatorWindow::addShapeIcon( %this, %datablock )
       
    %shapePath = ( %datablock.shapeFile !$= "" ) ? %datablock.shapeFile : %datablock.shapeName;
    
-   %createCmd = "EWCreatorWindow.createObject( \\\"" @ %cmd @ "\\\" );";
+   %createCmd = "ObjectCreator.createObject( \\\"" @ %cmd @ "\\\" );";
    %ctrl.altCommand = "showImportDialog( \"" @ %shapePath @ "\", \"" @ %createCmd @ "\" );";
 
    %ctrl.iconBitmap = EditorIconRegistry::findIconByClassName( %class );
@@ -697,7 +697,7 @@ function EWCreatorWindow::addShapeIcon( %this, %datablock )
    %this.contentCtrl.addGuiControl( %ctrl );   
 }
 
-function EWCreatorWindow::addStaticIcon( %this, %fullPath )
+function ObjectCreator::addStaticIcon( %this, %fullPath )
 {
    %ctrl = %this.createIcon();
    
@@ -709,7 +709,7 @@ function EWCreatorWindow::addStaticIcon( %this, %fullPath )
           "Date Created: " @ fileCreatedTime( %fullPath ) NL
           "Last Modified: " @ fileModifiedTime( %fullPath );
 
-   %createCmd = "EWCreatorWindow.createStatic( \\\"" @ %fullPath @ "\\\" );";
+   %createCmd = "ObjectCreator.createStatic( \\\"" @ %fullPath @ "\\\" );";
    %ctrl.altCommand = "showImportDialog( \"" @ %fullPath @ "\", \"" @ %createCmd @ "\" );";
 
    %ctrl.iconBitmap = ( ( %ext $= ".dts" ) ? EditorIconRegistry::findIconByClassName( "TSStatic" ) : "tools/gui/images/iconCollada" );
@@ -723,7 +723,7 @@ function EWCreatorWindow::addStaticIcon( %this, %fullPath )
    %this.contentCtrl.addGuiControl( %ctrl );   
 }
 
-function EWCreatorWindow::addPrefabIcon( %this, %fullPath )
+function ObjectCreator::addPrefabIcon( %this, %fullPath )
 {
    %ctrl = %this.createIcon();
    
@@ -735,7 +735,7 @@ function EWCreatorWindow::addPrefabIcon( %this, %fullPath )
           "Date Created: " @ fileCreatedTime( %fullPath ) NL
           "Last Modified: " @ fileModifiedTime( %fullPath );
 
-   %ctrl.altCommand = "EWCreatorWindow.createPrefab( \"" @ %fullPath @ "\" );";
+   %ctrl.altCommand = "ObjectCreator.createPrefab( \"" @ %fullPath @ "\" );";
    %ctrl.iconBitmap = EditorIconRegistry::findIconByClassName( "Prefab" );
    %ctrl.text = %file;
    %ctrl.class = "CreatorPrefabIconBtn";
@@ -750,7 +750,7 @@ function EWCreatorWindow::addPrefabIcon( %this, %fullPath )
 function CreatorPopupMenu::onSelect( %this, %id, %text )
 {   
    %split = strreplace( %text, "/", " " );
-   EWCreatorWindow.navigate( %split );  
+   ObjectCreator.navigate( %split );  
 }
 
 function alphaIconCompare( %a, %b )
@@ -779,7 +779,7 @@ function genericCreateObject( %class )
    
    %cmd = "return new " @ %class @ "();";
    
-   %obj = EWCreatorWindow.createObject( %cmd );   
+   %obj = ObjectCreator.createObject( %cmd );   
    
    // In case the caller wants it.
    return %obj;   

From c6c2e9139fcdaa9c059bfe1c4997f1b11e3fa482 Mon Sep 17 00:00:00 2001
From: Areloch <Areloch@gmail.com>
Date: Sun, 5 Dec 2021 11:00:02 -0600
Subject: [PATCH 280/399] Cleans up some core execution behavior Removes a
 duplicated material definition Fixes up PostFX init'ing order so it inits
 before trying to load the prefs Adds a skip of loading the CoreModule's
 materials so we don't double-execute any of them Fixes a typo for the
 Vignette PostFX's name so it properly integrates

---
 .../core/gameObjects/shapes/materials.tscript | 17 ----------
 .../game/core/postFX/images/materials.tscript | 32 -------------------
 .../game/core/postFX/scripts/postFx.tscript   | 26 +++++++--------
 .../core/rendering/Core_Rendering.tscript     |  4 +--
 .../rendering/scripts/graphicsOptions.tscript |  2 +-
 .../game/core/utility/scripts/module.tscript  |  3 ++
 6 files changed, 19 insertions(+), 65 deletions(-)
 delete mode 100644 Templates/BaseGame/game/core/postFX/images/materials.tscript

diff --git a/Templates/BaseGame/game/core/gameObjects/shapes/materials.tscript b/Templates/BaseGame/game/core/gameObjects/shapes/materials.tscript
index 9cc31fbbe..1ff2dc498 100644
--- a/Templates/BaseGame/game/core/gameObjects/shapes/materials.tscript
+++ b/Templates/BaseGame/game/core/gameObjects/shapes/materials.tscript
@@ -55,23 +55,6 @@ singleton Material(CameraMat)
 };
 
 //--- camera.dts MATERIALS END ---
-//--- noshape.dts MATERIALS BEGIN ---
-singleton Material(noshape_NoShape)
-{
-   mapTo = "NoShape";
-
-	diffuseMapAsset[0] = "";
-
-	diffuseColor[0] = "0.8 0.003067 0 .8";
-	emissive[0] = 0;
-
-	doubleSided = false;
-	translucent = 1;
-	translucentBlendOp = "LerpAlpha";
-	castShadows = false;
-};
-
-//--- noshape.dts MATERIALS END ---
 
 //--- noshapetext.dae MATERIALS BEGIN ---
 singleton Material(noshapetext_lambert1)
diff --git a/Templates/BaseGame/game/core/postFX/images/materials.tscript b/Templates/BaseGame/game/core/postFX/images/materials.tscript
deleted file mode 100644
index df1abcfbc..000000000
--- a/Templates/BaseGame/game/core/postFX/images/materials.tscript
+++ /dev/null
@@ -1,32 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-singleton Material( Empty )
-{
-};
-
-singleton Material(WarningMaterial) {
-   detailMapAsset[0] = "Core_PostFX:missingTexture_image";
-   diffuseColor[0] = "25 16 0";
-   emissive[0] = false;
-   translucent = false;
-};
diff --git a/Templates/BaseGame/game/core/postFX/scripts/postFx.tscript b/Templates/BaseGame/game/core/postFX/scripts/postFx.tscript
index cbea8fe1f..24035a97f 100644
--- a/Templates/BaseGame/game/core/postFX/scripts/postFx.tscript
+++ b/Templates/BaseGame/game/core/postFX/scripts/postFx.tscript
@@ -20,21 +20,21 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-singleton ShaderData( PFX_PassthruShader )
-{   
-   DXVertexShaderFile 	= $Core::CommonShaderPath @ "/postFX/postFxV.hlsl";
-   DXPixelShaderFile 	= $Core::CommonShaderPath @ "/postFX/passthruP.hlsl";
-         
-   OGLVertexShaderFile  = $Core::CommonShaderPath @ "/postFX/gl/postFxV.glsl";
-   OGLPixelShaderFile   = $Core::CommonShaderPath @ "/postFX/gl/passthruP.glsl";
-      
-   samplerNames[0] = "$inputTex";
-   
-   pixVersion = 2.0;
-};
-
 function postFXInit()
 {
+   singleton ShaderData( PFX_PassthruShader )
+   {   
+      DXVertexShaderFile 	= $Core::CommonShaderPath @ "/postFX/postFxV.hlsl";
+      DXPixelShaderFile 	= $Core::CommonShaderPath @ "/postFX/passthruP.hlsl";
+            
+      OGLVertexShaderFile  = $Core::CommonShaderPath @ "/postFX/gl/postFxV.glsl";
+      OGLPixelShaderFile   = $Core::CommonShaderPath @ "/postFX/gl/passthruP.glsl";
+         
+      samplerNames[0] = "$inputTex";
+      
+      pixVersion = 2.0;
+   };
+
    //Load the core postFX files themselves
    if (!$Server::Dedicated)
    {
diff --git a/Templates/BaseGame/game/core/rendering/Core_Rendering.tscript b/Templates/BaseGame/game/core/rendering/Core_Rendering.tscript
index 142f04783..eb18dfe8a 100644
--- a/Templates/BaseGame/game/core/rendering/Core_Rendering.tscript
+++ b/Templates/BaseGame/game/core/rendering/Core_Rendering.tscript
@@ -59,11 +59,11 @@ function Core_Rendering::initClient(%this)
    
    configureCanvas();
    
+   postFXInit();
+   
    //Autodetect settings if it's our first time
    if($pref::Video::autoDetect)
       AutodetectGraphics();
-
-   postFXInit();
    
    closeSplashWindow();
    
diff --git a/Templates/BaseGame/game/core/rendering/scripts/graphicsOptions.tscript b/Templates/BaseGame/game/core/rendering/scripts/graphicsOptions.tscript
index 40fcc9e6d..a03745ccb 100644
--- a/Templates/BaseGame/game/core/rendering/scripts/graphicsOptions.tscript
+++ b/Templates/BaseGame/game/core/rendering/scripts/graphicsOptions.tscript
@@ -811,7 +811,7 @@ function AutodetectGraphics_Apply(%shaderVer, %intel, %videoMem )
    PostFXManager.settingsEffectSetEnabled(HDRPostFX, $pref::PostFX::EnableHDR);
    PostFXManager.settingsEffectSetEnabled(DepthOfFieldPostFX, $pref::PostFX::EnableDOF);
    PostFXManager.settingsEffectSetEnabled(LightRayPostFX, $pref::PostFX::EnableLightRays);
-   PostFXManager.settingsEffectSetEnabled(VignettePostEffect, $pref::PostFX::EnableVignette);
+   PostFXManager.settingsEffectSetEnabled(VignettePostFX, $pref::PostFX::EnableVignette);
    
    echo("Graphics quality settings have been auto detected.");
 }
diff --git a/Templates/BaseGame/game/core/utility/scripts/module.tscript b/Templates/BaseGame/game/core/utility/scripts/module.tscript
index 1f6a755d1..2b102eb9e 100644
--- a/Templates/BaseGame/game/core/utility/scripts/module.tscript
+++ b/Templates/BaseGame/game/core/utility/scripts/module.tscript
@@ -44,6 +44,9 @@ function loadModuleMaterials(%moduleGroup)
          if(%module.group !$= %moduleGroup)
             continue;  
       }
+
+      if(%module.ModuleId $= "CoreModule") //the core container module is a special case that has some path complications
+         continue;                  //so we'll skip it so it doesn't complicate the other core modules' path tests
       
       %modulePath = %module.ModulePath;
       

From 73b023a4b716162b9a1edff0f1634b5571747179 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Wed, 8 Dec 2021 21:00:50 -0500
Subject: [PATCH 281/399] Fix console warning when calling void functions in
 console

Forgot to add this check when rewriting the interpreter.
---
 Engine/source/console/compiledEval.cpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index 0b2e66b4b..c439f57bf 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -2022,7 +2022,11 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
                      break;
                   }
 
-                  Con::warnf(ConsoleLogEntry::General, "%s: Call to %s in %s uses result of void function call.", getFileLine(ip - 4), fnName, functionName);
+                  if (Con::getBoolVariable("$Con::warnVoidAssignment", true))
+                  {
+                     Con::warnf(ConsoleLogEntry::General, "%s: Call to %s in %s uses result of void function call.", getFileLine(ip - 4), fnName, functionName);
+                  }
+                  
                   stack[_STK + 1].setEmptyString();
                   _STK++;
 

From a8b3d874a10d14c4d4ea719bf83343b714507bff Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Fri, 10 Dec 2021 00:01:26 -0600
Subject: [PATCH 282/399] Fixes mapping of imposter images to be packed as part
 of the shape asset, and fixes paths to be formatted more sanely.

---
 Engine/source/T3D/assets/ShapeAsset.cpp    | 67 ++++++++++++++++++++++
 Engine/source/T3D/assets/ShapeAsset.h      | 19 ++++++
 Engine/source/T3D/assets/assetImporter.cpp |  9 +++
 Engine/source/ts/tsLastDetail.cpp          | 46 +++++++++++++--
 Engine/source/ts/tsLastDetail.h            | 17 +++++-
 Engine/source/ts/tsShape.cpp               | 33 +++++++++++
 Engine/source/ts/tsShape.h                 |  2 +
 7 files changed, 186 insertions(+), 7 deletions(-)

diff --git a/Engine/source/T3D/assets/ShapeAsset.cpp b/Engine/source/T3D/assets/ShapeAsset.cpp
index 99becc8a6..c532d2370 100644
--- a/Engine/source/T3D/assets/ShapeAsset.cpp
+++ b/Engine/source/T3D/assets/ShapeAsset.cpp
@@ -129,6 +129,13 @@ ShapeAsset::ShapeAsset()
    mConstructorFileName = StringTable->EmptyString();
    mFilePath = StringTable->EmptyString();
    mConstructorFilePath = StringTable->EmptyString();
+
+   mDiffuseImposterFileName = StringTable->EmptyString();
+   mDiffuseImposterPath = StringTable->EmptyString();
+   mNormalImposterFileName = StringTable->EmptyString();
+   mNormalImposterPath = StringTable->EmptyString();
+
+
    mLoadedState = AssetErrCode::NotLoaded;
 }
 
@@ -162,6 +169,12 @@ void ShapeAsset::initPersistFields()
       &setShapeFile, &getShapeFile, "Path to the shape file we want to render");
    addProtectedField("constuctorFileName", TypeAssetLooseFilePath, Offset(mConstructorFileName, ShapeAsset),
       &setShapeConstructorFile, &getShapeConstructorFile, "Path to the shape file we want to render");
+
+   addProtectedField("diffuseImposterFileName", TypeAssetLooseFilePath, Offset(mDiffuseImposterFileName, ShapeAsset),
+      &setDiffuseImposterFile, &getDiffuseImposterFile, "Path to the diffuse imposter file we want to render");
+   addProtectedField("normalImposterFileName", TypeAssetLooseFilePath, Offset(mNormalImposterFileName, ShapeAsset),
+      &setNormalImposterFile, &getNormalImposterFile, "Path to the normal imposter file we want to render");
+
 }
 
 void ShapeAsset::setDataField(StringTableEntry slotName, StringTableEntry array, StringTableEntry value)
@@ -193,6 +206,20 @@ void ShapeAsset::initializeAsset()
 
    mConstructorFilePath = getOwned() ? expandAssetFilePath(mConstructorFilePath) : mConstructorFilePath;
 
+   mDiffuseImposterPath = getOwned() ? expandAssetFilePath(mDiffuseImposterFileName) : mDiffuseImposterFileName;
+   if (mDiffuseImposterPath == StringTable->EmptyString())
+   {
+      String diffusePath = String(mFilePath) + "_imposter.dds";
+      mDiffuseImposterPath = StringTable->insert(diffusePath.c_str());
+   }
+
+   mNormalImposterPath = getOwned() ? expandAssetFilePath(mNormalImposterFileName) : mNormalImposterFileName;
+   if (mNormalImposterPath == StringTable->EmptyString())
+   {
+      String normalPath = String(mFilePath) + "_imposter_normals.dds";
+      mNormalImposterPath = StringTable->insert(normalPath.c_str());
+   }
+
    loadShape();
 }
 
@@ -232,6 +259,42 @@ void ShapeAsset::setShapeConstructorFile(const char* pShapeConstructorFile)
    refreshAsset();
 }
 
+void ShapeAsset::setDiffuseImposterFile(const char* pImageFile)
+{
+   // Sanity!
+   AssertFatal(pImageFile != NULL, "Cannot use a NULL image file.");
+
+   // Fetch image file.
+   pImageFile = StringTable->insert(pImageFile, true);
+
+   // Ignore no change,
+   if (pImageFile == mDiffuseImposterFileName)
+      return;
+
+   mDiffuseImposterFileName = getOwned() ? expandAssetFilePath(pImageFile) : pImageFile;
+
+   // Refresh the asset.
+   refreshAsset();
+}
+
+void ShapeAsset::setNormalImposterFile(const char* pImageFile)
+{
+   // Sanity!
+   AssertFatal(pImageFile != NULL, "Cannot use a NULL image file.");
+
+   // Fetch image file.
+   pImageFile = StringTable->insert(pImageFile, true);
+
+   // Ignore no change,
+   if (pImageFile == mNormalImposterFileName)
+      return;
+
+   mNormalImposterFileName = getOwned() ? expandAssetFilePath(pImageFile) : pImageFile;
+
+   // Refresh the asset.
+   refreshAsset();
+}
+
 void ShapeAsset::_onResourceChanged(const Torque::Path &path)
 {
    if (path != Torque::Path(mFilePath) )
@@ -292,6 +355,10 @@ bool ShapeAsset::loadShape()
       return false; //if it failed to load, bail out
    }
 
+   mShape->setupBillboardDetails(mFilePath, mDiffuseImposterPath, mNormalImposterPath);
+
+   //If they exist, grab our imposters here and bind them to our shapeAsset
+
    bool hasBlends = false;
 
    //Now that we've successfully loaded our shape and have any materials and animations loaded
diff --git a/Engine/source/T3D/assets/ShapeAsset.h b/Engine/source/T3D/assets/ShapeAsset.h
index 36a0a68c1..7288ec515 100644
--- a/Engine/source/T3D/assets/ShapeAsset.h
+++ b/Engine/source/T3D/assets/ShapeAsset.h
@@ -73,6 +73,12 @@ protected:
    StringTableEntry   mConstructorFilePath;
    Resource<TSShape>	 mShape;
 
+   StringTableEntry   mDiffuseImposterFileName;
+   StringTableEntry   mDiffuseImposterPath;
+
+   StringTableEntry   mNormalImposterFileName;
+   StringTableEntry   mNormalImposterPath;
+
    //Material assets we're dependent on and use
    Vector<StringTableEntry> mMaterialAssetIds;
    Vector<AssetPtr<MaterialAsset>> mMaterialAssets;
@@ -170,6 +176,15 @@ public:
    inline StringTableEntry getShapeFilePath(void) const { return mFilePath; };
    inline StringTableEntry getShapeConstructorFilePath(void) const { return mConstructorFilePath; };
 
+   //Imposter images
+   void                    setDiffuseImposterFile(const char* pImageFile);
+   inline StringTableEntry getDiffuseImposterFile(void) const { return mDiffuseImposterFileName; };
+   inline StringTableEntry getDiffuseImposterFilePath(void) const { return mDiffuseImposterPath; };
+
+   void                    setNormalImposterFile(const char* pImageFile);
+   inline StringTableEntry getNormalImposterFile(void) const { return mNormalImposterFileName; };
+   inline StringTableEntry getNormalImposterFilePath(void) const { return mNormalImposterPath; };
+
    static U32 getAssetByFilename(StringTableEntry fileName, AssetPtr<ShapeAsset>* shapeAsset);
 
    static StringTableEntry getAssetIdByFilename(StringTableEntry fileName);
@@ -188,6 +203,10 @@ protected:
    static bool setShapeConstructorFile(void* obj, const char* index, const char* data) { static_cast<ShapeAsset*>(obj)->setShapeConstructorFile(data); return false; }
    static const char* getShapeConstructorFile(void* obj, const char* data) { return static_cast<ShapeAsset*>(obj)->getShapeConstructorFile(); }
 
+   static bool setDiffuseImposterFile(void* obj, StringTableEntry index, StringTableEntry data) { static_cast<ShapeAsset*>(obj)->setDiffuseImposterFile(data); return false; }
+   static const char* getDiffuseImposterFile(void* obj, const char* data) { return static_cast<ShapeAsset*>(obj)->getDiffuseImposterFile(); }
+   static bool setNormalImposterFile(void* obj, StringTableEntry index, StringTableEntry data) { static_cast<ShapeAsset*>(obj)->setNormalImposterFile(data); return false; }
+   static const char* getNormalImposterFile(void* obj, const char* data) { return static_cast<ShapeAsset*>(obj)->getNormalImposterFile(); }
 };
 
 #ifdef TORQUE_TOOLS
diff --git a/Engine/source/T3D/assets/assetImporter.cpp b/Engine/source/T3D/assets/assetImporter.cpp
index 5d3d66180..7c0bda9ae 100644
--- a/Engine/source/T3D/assets/assetImporter.cpp
+++ b/Engine/source/T3D/assets/assetImporter.cpp
@@ -3062,6 +3062,15 @@ Torque::Path AssetImporter::importShapeAsset(AssetImportObject* assetItem)
       }
    }
 
+   if (Con::getBoolVariable("$TSLastDetail::dumpImposters", false))
+   {
+      String imposterPath = assetItem->assetName + "_imposter.png";
+      String normalsPath = assetItem->assetName + "_imposter_normals.png";
+
+      newAsset->setDiffuseImposterFile(imposterPath.c_str());
+      newAsset->setNormalImposterFile(normalsPath.c_str());
+   }
+
    Taml tamlWriter;
    bool importSuccessful = tamlWriter.write(newAsset, tamlPath.c_str());
 
diff --git a/Engine/source/ts/tsLastDetail.cpp b/Engine/source/ts/tsLastDetail.cpp
index 9af2c22fa..950b4c5f6 100644
--- a/Engine/source/ts/tsLastDetail.cpp
+++ b/Engine/source/ts/tsLastDetail.cpp
@@ -86,6 +86,8 @@ TSLastDetail::TSLastDetail(   TSShape *shape,
    mCenter = mShape->center;
 
    mCachePath = cachePath;
+   mDiffusePath = mCachePath + "_imposter.dds";
+   mNormalPath = mCachePath + "_imposter_normals.dds";
 
    mMaterial = NULL;
    mMatInstance = NULL;
@@ -94,6 +96,38 @@ TSLastDetail::TSLastDetail(   TSShape *shape,
    smLastDetails.push_back( this );  
 }
 
+TSLastDetail::TSLastDetail(TSShape* shape,
+   const String& cachePath,
+   const String& diffusePath,
+   const String& normalPath,
+   U32 numEquatorSteps,
+   U32 numPolarSteps,
+   F32 polarAngle,
+   bool includePoles,
+   S32 dl, S32 dim)
+{
+   mNumEquatorSteps = getMax(numEquatorSteps, (U32)1);
+   mNumPolarSteps = numPolarSteps;
+   mPolarAngle = polarAngle;
+   mIncludePoles = includePoles;
+   mShape = shape;
+   mDl = dl;
+   mDim = getMax(dim, (S32)32);
+
+   mRadius = mShape->mRadius;
+   mCenter = mShape->center;
+
+   mCachePath = cachePath;
+   mDiffusePath = diffusePath;
+   mNormalPath = normalPath;
+
+   mMaterial = NULL;
+   mMatInstance = NULL;
+
+   // Store this in the static list.
+   smLastDetails.push_back(this);
+}
+
 TSLastDetail::~TSLastDetail()
 {
    SAFE_DELETE( mMatInstance );
@@ -189,7 +223,8 @@ void TSLastDetail::update( bool forceUpdate )
 
    // Do we need to update the imposter?
    const String diffuseMapPath = _getDiffuseMapPath();
-   if (  forceUpdate || 
+   bool isFile = Platform::isFile(diffuseMapPath.c_str());
+   if (  forceUpdate || !Platform::isFile(diffuseMapPath.c_str()) ||
          Platform::compareModifiedTimes( diffuseMapPath, shapeFile ) <= 0 )
       _update();
 
@@ -218,8 +253,9 @@ void TSLastDetail::update( bool forceUpdate )
    // Setup the material for this imposter.
    mMaterial = MATMGR->allocateAndRegister( String::EmptyString );
    mMaterial->mAutoGenerated = true;
-   mMaterial->_setDiffuseMap(diffuseMapPath,0);
-   mMaterial->_setNormalMap(_getNormalMapPath(), 0);
+   mMaterial->setDiffuseMapFile(diffuseMapPath, 0);
+   mMaterial->setNormalMapFile(_getNormalMapPath(), 0);
+
    mMaterial->mImposterLimits.set( (mNumPolarSteps * 2) + 1, mNumEquatorSteps, mPolarAngle, mIncludePoles );
    mMaterial->mTranslucent = true;
    mMaterial->mTranslucentBlendOp = Material::None;
@@ -466,8 +502,8 @@ void TSLastDetail::_update()
    // Should we dump the images?
    if ( Con::getBoolVariable( "$TSLastDetail::dumpImposters", false ) )
    {
-      String imposterPath = mCachePath + ".imposter.png";
-      String normalsPath = mCachePath + ".imposter_normals.png";
+      String imposterPath = _getDiffuseMapPath();
+      String normalsPath = _getNormalMapPath();
 
       FileStream stream;
       if ( stream.open( imposterPath, Torque::FS::File::Write  ) )
diff --git a/Engine/source/ts/tsLastDetail.h b/Engine/source/ts/tsLastDetail.h
index abfb3bac1..05e3c9dcb 100644
--- a/Engine/source/ts/tsLastDetail.h
+++ b/Engine/source/ts/tsLastDetail.h
@@ -92,6 +92,9 @@ protected:
    /// where we'll be storing our cache for rendered imposters.
    String mCachePath;
 
+   String mDiffusePath;
+   String mNormalPath;
+
    /// The shape detail level to capture into
    /// the imposters.
    S32 mDl;
@@ -148,10 +151,10 @@ protected:
    void _validateDim();
 
    /// Helper which returns the imposter diffuse map path.
-   String _getDiffuseMapPath() const { return mCachePath + ".imposter.dds"; }
+   String _getDiffuseMapPath() const { return mDiffusePath; }
 
    /// Helper which returns the imposter normal map path.
-   String _getNormalMapPath() const { return mCachePath + ".imposter_normals.dds"; }
+   String _getNormalMapPath() const { return mNormalPath; }
 
 public:
 
@@ -164,6 +167,16 @@ public:
                   S32 dl, 
                   S32 dim );
 
+   TSLastDetail(TSShape* shape,
+                  const String& cachePath,
+                  const String& diffusePath,
+                  const String& normalPath,
+                  U32 numEquatorSteps,
+                  U32 numPolarSteps,
+                  F32 polarAngle,
+                  bool includePoles,
+                  S32 dl, S32 dim);
+
    ~TSLastDetail();
 
    /// Global preference for rendering imposters to shadows.
diff --git a/Engine/source/ts/tsShape.cpp b/Engine/source/ts/tsShape.cpp
index 36825014b..e6eb2f4fd 100644
--- a/Engine/source/ts/tsShape.cpp
+++ b/Engine/source/ts/tsShape.cpp
@@ -969,6 +969,39 @@ void TSShape::setupBillboardDetails( const String &cachePath )
    }
 }
 
+void TSShape::setupBillboardDetails(const String& cachePath, const String& diffsePath, const String& normalPath)
+{
+   // set up billboard details -- only do this once, meaning that
+   // if we add a sequence to the shape we don't redo the billboard
+   // details...
+   if (!billboardDetails.empty())
+      return;
+
+   for (U32 i = 0; i < details.size(); i++)
+   {
+      const Detail& det = details[i];
+
+      if (det.subShapeNum >= 0)
+         continue; // not a billboard detail
+
+      while (billboardDetails.size() <= i)
+         billboardDetails.push_back(NULL);
+
+      billboardDetails[i] = new TSLastDetail(this,
+         cachePath,
+         diffsePath,
+         normalPath,
+         det.bbEquatorSteps,
+         det.bbPolarSteps,
+         det.bbPolarAngle,
+         det.bbIncludePoles,
+         det.bbDetailLevel,
+         det.bbDimension);
+
+      billboardDetails[i]->update();
+   }
+}
+
 void TSShape::initMaterialList()
 {
    S32 numSubShapes = subShapeFirstObject.size();
diff --git a/Engine/source/ts/tsShape.h b/Engine/source/ts/tsShape.h
index 164e378a9..c2a3fc1c4 100644
--- a/Engine/source/ts/tsShape.h
+++ b/Engine/source/ts/tsShape.h
@@ -429,6 +429,8 @@ class TSShape
 
    void setupBillboardDetails( const String &cachePath );
 
+   void setupBillboardDetails(const String& cachePath, const String& diffsePath, const String& normalPath);
+
    /// Inits object list (no geometry buffers)
    void initObjects();
 

From cc45f9e9a4a3ef5627dc93472c4e148ec1574a5b Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Mon, 13 Dec 2021 00:04:24 -0500
Subject: [PATCH 283/399] * BugFix: Fix a Windows ASAN reported allocation
 mismatch error.

---
 Engine/source/sim/netConnection.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Engine/source/sim/netConnection.h b/Engine/source/sim/netConnection.h
index 3503275ef..8f8edb48a 100644
--- a/Engine/source/sim/netConnection.h
+++ b/Engine/source/sim/netConnection.h
@@ -692,6 +692,7 @@ public:
 
       PacketNotify *nextPacket;  ///< Next packet sent.
       PacketNotify();
+      virtual ~PacketNotify() = default;
    };
    virtual PacketNotify *allocNotify();
    PacketNotify *mNotifyQueueHead;  ///< Head of packet notify list.

From 434c6c26fec233d5a7292255ed190883016d04f4 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Mon, 13 Dec 2021 15:56:14 -0600
Subject: [PATCH 284/399] A clean implementation of Lukas' Fix side projection
 #684 PR with Az's addendum fix rolled in

---
 .../source/terrain/glsl/terrFeatureGLSL.cpp   | 243 +++++-----------
 .../source/terrain/hlsl/terrFeatureHLSL.cpp   | 259 +++++-------------
 Engine/source/terrain/terrMaterial.cpp        |   4 +
 3 files changed, 147 insertions(+), 359 deletions(-)

diff --git a/Engine/source/terrain/glsl/terrFeatureGLSL.cpp b/Engine/source/terrain/glsl/terrFeatureGLSL.cpp
index 3b66006ce..70d31857d 100644
--- a/Engine/source/terrain/glsl/terrFeatureGLSL.cpp
+++ b/Engine/source/terrain/glsl/terrFeatureGLSL.cpp
@@ -223,29 +223,16 @@ void TerrainBaseMapFeatGLSL::processVert( Vector<ShaderComponent*> &componentLis
    output = meta;
 
    // Generate the incoming texture var.
-   Var *inTex;
-   {
-      Var *inPos = (Var*)LangElement::find( "inPosition" );
-      if ( !inPos )
-         inPos = (Var*)LangElement::find( "position" );
+   Var* inPos = (Var*)LangElement::find("inPosition");
+   if (!inPos)
+      inPos = (Var*)LangElement::find("position");
 
-      inTex = new Var( "texCoord", "vec3" );
+   Var* inTex = new Var("texCoord", "vec3");
 
-      Var *oneOverTerrainSize = _getUniformVar( "oneOverTerrainSize", "float", cspPass );
+   Var* oneOverTerrainSize = _getUniformVar("oneOverTerrainSize", "float", cspPass);
 
-      // NOTE: The y coord here should be negative to have
-      // the texture maps not end up flipped which also caused
-      // normal and parallax mapping to be incorrect.
-      //
-      // This mistake early in development means that the layer
-      // id bilinear blend depends on it being that way.
-      //
-      // So instead i fixed this by flipping the base and detail
-      // coord y scale to compensate when rendering.
-      //
-      meta->addStatement( new GenOp( "   @ = @.xyz * vec3( @, @, -@ );\r\n", 
-         new DecOp( inTex ), inPos, oneOverTerrainSize, oneOverTerrainSize, oneOverTerrainSize ) );
-   }
+   meta->addStatement(new GenOp("   @ = @.xyz * vec3( @, @, @ );\r\n",
+      new DecOp(inTex), inPos, oneOverTerrainSize, oneOverTerrainSize, oneOverTerrainSize));
 
    ShaderConnector *connectComp = dynamic_cast<ShaderConnector *>( componentList[C_CONNECTOR] );
 
@@ -253,21 +240,27 @@ void TerrainBaseMapFeatGLSL::processVert( Vector<ShaderComponent*> &componentLis
    Var *outTex = connectComp->getElement( RT_TEXCOORD );
    outTex->setName( "outTexCoord" );
    outTex->setStructName( "OUT" );
-   outTex->setType( "vec3" );
+   outTex->setType( "vec4" );
    meta->addStatement( new GenOp( "   @.xy = @.xy;\r\n", outTex, inTex ) );
 
    // If this shader has a side projected layer then we 
    // pass the dot product between the +Y and the normal
-   // thru outTexCoord.z for use in blending the textures.
+   // thru outTexCoord.z and w for use in blending the textures.
    if ( fd.features.hasFeature( MFT_TerrainSideProject ) )
    {
-      Var *inNormal = (Var*)LangElement::find( "normal" );
+      Var* inNormal = (Var*)LangElement::find("normal");
+      meta->addStatement(
+         new GenOp("   @.z = clamp(abs( dot( normalize( vec3( @.x, @.y, 0 ) ), vec3( 0, 1, 0 ) ) ), 0.0, 1.0);\r\n",
+            outTex, inNormal, inNormal));
       meta->addStatement( 
-         new GenOp( "   @.z = pow( abs( dot( normalize( vec3( @.x, @.y, 0 ) ), vec3( 0, 1, 0 ) ) ), 10.0 );\r\n", 
-            outTex, inNormal, inNormal ) );
+         new GenOp("   @.w = 1.0 - abs( dot( normalize( @.xyz ), vec3( 0, 0, 1 ) ) );\r\n",
+            outTex, inNormal));
    }
    else
-      meta->addStatement( new GenOp( "   @.z = 0;\r\n", outTex ) );
+   {
+      meta->addStatement(new GenOp("   @.z = 0;\r\n", outTex));
+      meta->addStatement(new GenOp("   @.w = 0;\r\n", outTex));
+   }
 
    // HACK: This is sort of lazy... we generate the tanget
    // vector here so that we're sure it exists in the parallax
@@ -289,7 +282,7 @@ void TerrainBaseMapFeatGLSL::processPix(  Vector<ShaderComponent*> &componentLis
                                           const MaterialFeatureData &fd )
 {
    // grab connector texcoord register
-   Var *texCoord = getInTexCoord( "texCoord", "vec3", componentList );
+   Var *texCoord = getInTexCoord( "texCoord", "vec4", componentList );
 
    // create texture var
    Var *diffuseMap = new Var;
@@ -446,8 +439,8 @@ void TerrainDetailMapFeatGLSL::processVert(  Vector<ShaderComponent*> &component
    meta->addStatement( new GenOp( "   @.xyz = @ * @.xyx;\r\n", outTex, inTex, new IndexOp(detScaleAndFade, detailIndex) ) );
 
    // And sneak the detail fade thru the w detailCoord.
-   meta->addStatement( new GenOp( "   @.w = clamp( ( @.z - @ ) * @.w, 0.0, 1.0 );\r\n", 
-                                    outTex, new IndexOp(detScaleAndFade, detailIndex), dist, new IndexOp(detScaleAndFade, detailIndex)) );
+   meta->addStatement(new GenOp("   @.w = clamp( ( @.z - @ ) * @.w, 0.0, 1.0 );\r\n",
+      outTex, new IndexOp(detScaleAndFade, detailIndex), dist, new IndexOp(detScaleAndFade, detailIndex)));
 
    output = meta;
 }
@@ -562,8 +555,12 @@ void TerrainDetailMapFeatGLSL::processPix(   Vector<ShaderComponent*> &component
   // amount so that it fades out with the layer blending.
    if (fd.features.hasFeature(MFT_TerrainSideProject, detailIndex))
    {
-	   meta->addStatement(new GenOp("   @ = ( lerp( tex2D( @, vec3(@.yz, @.x) ), tex2D( @, vec3(@.xz, @.x) ), @.z ) * 2.0 ) - 1.0;\r\n",
-		   detailColor, detailMap, inDet, new IndexOp(detailInfo, detailIndex), detailMap, inDet, new IndexOp(detailInfo, detailIndex), inTex));
+      meta->addStatement(new GenOp("   @ = ( lerp( tex2D( @, vec3(@.xy, @.x) ), lerp( tex2D( @, vec3(@.yz, @.x) ), tex2D( @, vec3(@.xz, @.x) ), @.z ), @.w) * 2.0 ) - 1.0;\r\n",
+         detailColor,
+         detailMap, inDet, new IndexOp(detailInfo, detailIndex),
+         detailMap, inDet, new IndexOp(detailInfo, detailIndex),
+         detailMap, inDet, new IndexOp(detailInfo, detailIndex),
+         inTex, inTex));
    }
    else
    {
@@ -574,7 +571,7 @@ void TerrainDetailMapFeatGLSL::processPix(   Vector<ShaderComponent*> &component
    meta->addStatement(new GenOp("   @ *= @.y * @.w;\r\n",
       detailColor, new IndexOp(detailInfo, detailIndex), inDet));
 
-   if (!fd.features.hasFeature(MFT_TerrainHeightBlend))
+   if (!fd.features.hasFeature(MFT_TerrainNormalMap))
    {
       // Check to see if we have a gbuffer normal.
       Var* gbNormal = (Var*)LangElement::find("gbNormal");
@@ -834,8 +831,12 @@ void TerrainMacroMapFeatGLSL::processPix(   Vector<ShaderComponent*> &componentL
    //
    if ( fd.features.hasFeature( MFT_TerrainSideProject, detailIndex ) )
    {
-      meta->addStatement( new GenOp( "      @ = ( lerp( tex2D( @, @.yz ), tex2D( @, @.xz ), @.z ) * 2.0 ) - 1.0;\r\n", 
-                                                detailColor, detailMap, inDet, detailMap, inDet, inTex ) );
+      meta->addStatement(new GenOp("   @ = ( lerp( tex2D( @, vec3(@.xy, @.x) ), lerp( tex2D( @, vec3(@.yz, @.x) ), tex2D( @, vec3(@.xz, @.x) ), @.z ), @.w) * 2.0 ) - 1.0;\r\n",
+         detailColor,
+         detailMap, inDet, new IndexOp(detailInfo, detailIndex),
+         detailMap, inDet, new IndexOp(detailInfo, detailIndex),
+         detailMap, inDet, new IndexOp(detailInfo, detailIndex),
+         inTex, inTex));
    }
    else
    {
@@ -940,8 +941,11 @@ void TerrainNormalMapFeatGLSL::processPix(   Vector<ShaderComponent*> &component
    LangElement *texOp;
    if ( fd.features.hasFeature( MFT_TerrainSideProject, normalIndex ) )
    {
-      texOp = new GenOp( "lerp( tex2D( @, vec3(@.yz, @.x) ), tex2D( @, vec3(@.xz, @.x) ), @.z )",
-         normalMap, inDet, new IndexOp(detailInfo, normalIndex), normalMap, inDet, inTex, new IndexOp(detailInfo, normalIndex));
+      texOp = new GenOp("lerp( tex2D( @, float3(@.xy, @.x) ), lerp( tex2D( @, float3(@.yz, @.x) ), tex2D( @, float3(@.xz, @.x) ), @.z ), @.w )",
+         normalMap, inDet, new IndexOp(detailInfo, normalIndex),
+         normalMap, inDet, new IndexOp(detailInfo, normalIndex),
+         normalMap, inDet, new IndexOp(detailInfo, normalIndex),
+         inTex, inTex);
    }
    else
       texOp = new GenOp( String::ToString("tex2D(@, vec3(@.xy, @.x))", normalIndex), normalMap, inDet, new IndexOp(detailInfo, normalIndex));
@@ -954,7 +958,7 @@ void TerrainNormalMapFeatGLSL::processPix(   Vector<ShaderComponent*> &component
    LangElement *bumpNormDecl = new DecOp( bumpNorm );
    meta->addStatement( expandNormalMap( texOp, bumpNormDecl, bumpNorm, fd ) );
 
-   if (!fd.features.hasFeature(MFT_TerrainHeightBlend))
+   if (!fd.features.hasFeature(MFT_TerrainNormalMap))
    {
       Var* viewToTangent = getInViewToTangent(componentList);
 
@@ -1059,100 +1063,22 @@ ShaderFeature::Resources TerrainLightMapFeatGLSL::getResources( const MaterialFe
    return res;
 }
 
-//standard matInfo map contains data of the form .r = bitflags, .g = (will contain AO), 
-//.b = specular strength, a= spec power. 
-
-
 void TerrainORMMapFeatGLSL::processVert(Vector<ShaderComponent*> &componentList,
 	const MaterialFeatureData &fd)
 {
-	const S32 detailIndex = getProcessIndex();
+   // We only need to process normals during the deferred.
+   if (!fd.features.hasFeature(MFT_DeferredConditioner))
+      return;
 
-	// Grab incoming texture coords... the base map feature
-	// made sure this was created.
-	Var *inTex = (Var*)LangElement::find("texCoord");
-	AssertFatal(inTex, "The texture coord is missing!");
+   MultiLine* meta = new MultiLine;
 
-	// Grab the input position.
-	Var *inPos = (Var*)LangElement::find("inPosition");
-	if (!inPos)
-		inPos = (Var*)LangElement::find("position");
-
-	// Get the object space eye position.
-	Var *eyePos = _getUniformVar("eyePos", "vec3", cspPotentialPrimitive);
-
-	MultiLine *meta = new MultiLine;
-
-	// If we have parallax mapping then make sure we've sent
-	// the negative view vector to the pixel shader.
-	if (fd.features.hasFeature(MFT_TerrainParallaxMap) &&
-		!LangElement::find("outNegViewTS"))
+   if (!fd.features.hasFeature(MFT_TerrainHeightBlend))
 	{
-		// Get the object to tangent transform which
-		// will consume 3 output registers.
-		Var *objToTangentSpace = getOutObjToTangentSpace(componentList, meta, fd);
-
-		// Now use a single output register to send the negative
-		// view vector in tangent space to the pixel shader.
-		ShaderConnector *connectComp = dynamic_cast<ShaderConnector *>(componentList[C_CONNECTOR]);
-		Var *outNegViewTS = connectComp->getElement(RT_TEXCOORD);
-		outNegViewTS->setName("outNegViewTS");
-		outNegViewTS->setStructName("OUT");
-		outNegViewTS->setType("vec3");
-		meta->addStatement(new GenOp("   @ =  @ * vec3( @ - @.xyz );\r\n",
-			outNegViewTS, objToTangentSpace, eyePos, inPos));
+      // Make sure the world to tangent transform
+      // is created and available for the pixel shader.
+      getOutViewToTangent(componentList, meta, fd);
 	}
 
-	// Get the distance from the eye to this vertex.
-	Var *dist = (Var*)LangElement::find("dist");
-	if (!dist)
-	{
-		dist = new Var;
-		dist->setType("float");
-		dist->setName("dist");
-
-		meta->addStatement(new GenOp("   @ = distance( @.xyz, @ );\r\n",
-			new DecOp(dist), inPos, eyePos));
-	}
-
-	// grab connector texcoord register
-	ShaderConnector *connectComp = dynamic_cast<ShaderConnector *>(componentList[C_CONNECTOR]);
-	Var *outTex = (Var*)LangElement::find(String::ToString("detCoord%d", detailIndex));
-	if (outTex == NULL)
-	{
-      outTex = new Var;
-		outTex = connectComp->getElement(RT_TEXCOORD);
-		outTex->setName(String::ToString("detCoord%d", detailIndex));
-		outTex->setStructName("OUT");
-		outTex->setType("vec4");
-	}
-	// Get the detail scale and fade info.
-	Var *detScaleAndFade = (Var*)LangElement::find("detailScaleAndFade");
-	if (detScaleAndFade == NULL)
-	{
-      detScaleAndFade = new Var;
-		detScaleAndFade->setType("vec4");
-		detScaleAndFade->setName("detailScaleAndFade");
-		detScaleAndFade->uniform = true;
-		detScaleAndFade->constSortPos = cspPotentialPrimitive;
-	}
-
-   detScaleAndFade->arraySize = mMax(detScaleAndFade->arraySize, detailIndex + 1);
-
-	// Setup the detail coord.
-	//
-	// NOTE: You see here we scale the texture coord by 'xyx'
-	// to generate the detail coord.  This y is here because
-	// its scale is flipped to correct for the non negative y
-	// in texCoord.
-	//
-	// See TerrainBaseMapFeatGLSL::processVert().
-	//
-	meta->addStatement(new GenOp("   @.xyz = @ * @.xyx;\r\n", outTex, inTex, new IndexOp(detScaleAndFade, detailIndex)));
-
-	// And sneak the detail fade thru the w detailCoord.
-	meta->addStatement(new GenOp("   @.w = clamp( ( @.z - @ ) * @.w, 0.0, 1.0 );\r\n",
-		outTex, new IndexOp(detScaleAndFade, detailIndex), dist, new IndexOp(detScaleAndFade, detailIndex)));
 
 	output = meta;
 }
@@ -1180,8 +1106,11 @@ void TerrainORMMapFeatGLSL::processPix(Vector<ShaderComponent*> &componentList,
 	
 	if (fd.features.hasFeature(MFT_TerrainSideProject, compositeIndex))
 	{
-		texOp = new GenOp("lerp( tex2D( @, vec3(@.yz, @.x) ), tex2D( @, vec3(@.xz, @.x) ), @.z )",
-			ormConfigMap, inDet, new IndexOp(detailInfo, compositeIndex), ormConfigMap, inDet, new IndexOp(detailInfo, compositeIndex), inTex);
+      texOp = new GenOp("lerp( tex2D( @, vec3(@.xy, @.x) ), lerp( tex2D( @, vec3(@.yz, @.x) ), tex2D( @, vec3(@.xz, @.x) ), @.z ), @.w )",
+            ormConfigMap, inDet, new IndexOp(detailInfo, compositeIndex),
+            ormConfigMap, inDet, new IndexOp(detailInfo, compositeIndex),
+            ormConfigMap, inDet, new IndexOp(detailInfo, compositeIndex),
+            inTex, inTex);
 	}
 	else
 		texOp = new GenOp("tex2D(@, vec3(@.xy, @.x))", ormConfigMap, inDet, new IndexOp(detailInfo, compositeIndex));
@@ -1332,6 +1261,13 @@ void TerrainHeightMapBlendGLSL::processPix(Vector<ShaderComponent*>& componentLi
 
    MultiLine* meta = new MultiLine;
 
+   Var* detailTot = (Var*)LangElement::find("detailTot");
+   if (detailTot == NULL)
+   {
+      detailTot = new Var("detailTot", "float");
+      meta->addStatement(new GenOp("@=0;\r\n", new DecOp(detailTot)));
+   }
+
    // Count the number of detail textures
    int detailCount = 0;
    while (true)
@@ -1391,11 +1327,11 @@ void TerrainHeightMapBlendGLSL::processPix(Vector<ShaderComponent*>& componentLi
          }
          else
          {
-            meta->addStatement(new GenOp("      @ = clamp(0.5 + @, 0.0, 1.0);\r\n",
+            meta->addStatement(new GenOp("      @ = clamp(@, 0.0, 1.0);\r\n",
                detailH, blendDepth));
          }
 
-         meta->addStatement(new GenOp("      @ = max((@ * 2.0f - 1.0f) * @ + 0.5f, 0.0f);\r\n",
+         meta->addStatement(new GenOp("      @ = max((@ * 2.0f - 1.0f) * @, 0.0f);\r\n",
             detailH, detailH, blendContrast));
 
          meta->addStatement(new GenOp("   }\r\n"));
@@ -1453,6 +1389,7 @@ void TerrainHeightMapBlendGLSL::processPix(Vector<ShaderComponent*>& componentLi
          meta->addStatement(new GenOp("   @ = max(@ + @ - @, 0);\r\n",
             new DecOp(detailB), detailH, detailBlend, ma));
       }
+      meta->addStatement(new GenOp("   @ += @;\r\n", detailTot, detailB));
    }
 
    meta->addStatement(new GenOp("\r\n"));
@@ -1478,22 +1415,7 @@ void TerrainHeightMapBlendGLSL::processPix(Vector<ShaderComponent*>& componentLi
       meta->addStatement(new GenOp("@.rgb * @", detailColor, detailB));
    }
 
-   meta->addStatement(new GenOp(") / ("));
-
-   for (S32 idx = 0; idx < detailCount; ++idx)
-   {
-      Var* detailB = (Var*)LangElement::find(String::ToString("detailB%d", idx));
-
-      if (idx > 0)
-      {
-         meta->addStatement(new GenOp(" + "));
-      }
-
-      meta->addStatement(new GenOp("@", detailB));
-   }
-
-
-   meta->addStatement(new GenOp(");\r\n"));
+   meta->addStatement(new GenOp(") / @;\r\n", detailTot));
 
    meta->addStatement(new GenOp("   @.rgb = toLinear(clamp(@.rgb, 0, 1));\r\n",
       outColor, outColor));
@@ -1532,23 +1454,7 @@ void TerrainHeightMapBlendGLSL::processPix(Vector<ShaderComponent*>& componentLi
       }
    }
 
-   meta->addStatement(new GenOp(") / ("));
-
-   for (S32 idx = 0; idx < detailCount; ++idx)
-   {
-      Var* detailB = (Var*)LangElement::find(String::ToString("detailB%d", idx));
-
-      if (idx > 0)
-      {
-         meta->addStatement(new GenOp(" + "));
-      }
-
-      meta->addStatement(new GenOp("@", detailB));
-   }
-
-
-   meta->addStatement(new GenOp(");\r\n"));
-
+   meta->addStatement(new GenOp(") / @;\r\n", detailTot));
 
    meta->addStatement(new GenOp("\r\n"));
 
@@ -1635,22 +1541,7 @@ void TerrainHeightMapBlendGLSL::processPix(Vector<ShaderComponent*>& componentLi
          }
       }
 
-      meta->addStatement(new GenOp(") / ("));
-
-      for (S32 idx = 0; idx < detailCount; ++idx)
-      {
-         Var* normalDetailB = (Var*)LangElement::find(String::ToString("normalDetailB%d", idx));
-
-         if (idx > 0)
-         {
-            meta->addStatement(new GenOp(" + "));
-         }
-
-         meta->addStatement(new GenOp("@", normalDetailB));
-      }
-
-
-      meta->addStatement(new GenOp(");\r\n"));
+      meta->addStatement(new GenOp(") / @;\r\n", detailTot));
    }
 
 
diff --git a/Engine/source/terrain/hlsl/terrFeatureHLSL.cpp b/Engine/source/terrain/hlsl/terrFeatureHLSL.cpp
index 362a012a3..eec280197 100644
--- a/Engine/source/terrain/hlsl/terrFeatureHLSL.cpp
+++ b/Engine/source/terrain/hlsl/terrFeatureHLSL.cpp
@@ -270,58 +270,52 @@ Var* TerrainFeatHLSL::_getMacroIdStrengthParallax()
 }
 
 
-void TerrainBaseMapFeatHLSL::processVert( Vector<ShaderComponent*> &componentList, 
-                                          const MaterialFeatureData &fd )
+void TerrainBaseMapFeatHLSL::processVert(Vector<ShaderComponent*>& componentList,
+   const MaterialFeatureData& fd)
 {
-   MultiLine *meta = new MultiLine;
+   MultiLine* meta = new MultiLine;
    output = meta;
 
    // Generate the incoming texture var.
-   Var *inTex;
-   {
-      Var *inPos = (Var*)LangElement::find( "inPosition" );
-      if ( !inPos )
-         inPos = (Var*)LangElement::find( "position" );
 
-      inTex = new Var( "texCoord", "float3" );
+   Var* inPos = (Var*)LangElement::find("inPosition");
+   if (!inPos)
+      inPos = (Var*)LangElement::find("position");
 
-      Var *oneOverTerrainSize = _getUniformVar( "oneOverTerrainSize", "float", cspPass );
+   Var* inTex = new Var("texCoord", "float3");
 
-      // NOTE: The y coord here should be negative to have
-      // the texture maps not end up flipped which also caused
-      // normal and parallax mapping to be incorrect.
-      //
-      // This mistake early in development means that the layer
-      // id bilinear blend depends on it being that way.
-      //
-      // So instead i fixed this by flipping the base and detail
-      // coord y scale to compensate when rendering.
-      //
-      meta->addStatement( new GenOp( "   @ = @.xyz * float3( @, @, -@ );\r\n", 
-         new DecOp( inTex ), inPos, oneOverTerrainSize, oneOverTerrainSize, oneOverTerrainSize ) );
-   }
+   Var* oneOverTerrainSize = _getUniformVar("oneOverTerrainSize", "float", cspPass);
 
-   ShaderConnector *connectComp = dynamic_cast<ShaderConnector *>( componentList[C_CONNECTOR] );
+   meta->addStatement(new GenOp("   @ = @.xyz * @;\r\n",
+      new DecOp(inTex), inPos, oneOverTerrainSize));
+
+   ShaderConnector* connectComp = dynamic_cast<ShaderConnector*>(componentList[C_CONNECTOR]);
 
    // Pass the texture coord to the pixel shader.
-   Var *outTex = connectComp->getElement( RT_TEXCOORD );
-   outTex->setName( "outTexCoord" );
-   outTex->setStructName( "OUT" );
-   outTex->setType( "float3" );
-   meta->addStatement( new GenOp( "   @.xy = @.xy;\r\n", outTex, inTex ) );
+   Var* outTex = connectComp->getElement(RT_TEXCOORD);
+   outTex->setName("outTexCoord");
+   outTex->setStructName("OUT");
+   outTex->setType("float4");
+   meta->addStatement(new GenOp("   @.xy = @.xy;\r\n", outTex, inTex));
 
    // If this shader has a side projected layer then we 
    // pass the dot product between the +Y and the normal
    // thru outTexCoord.z for use in blending the textures.
-   if ( fd.features.hasFeature( MFT_TerrainSideProject ) )
+   if (fd.features.hasFeature(MFT_TerrainSideProject))
    {
-      Var *inNormal = (Var*)LangElement::find( "normal" );
+      Var* inNormal = (Var*)LangElement::find("normal");
       meta->addStatement( 
-         new GenOp( "   @.z = pow( abs( dot( normalize( float3( @.x, @.y, 0 ) ), float3( 0, 1, 0 ) ) ), 10.0 );\r\n", 
-            outTex, inNormal, inNormal ) );
+         new GenOp("   @.z = clamp(abs( dot( normalize( float3( @.x, @.y, 0 ) ), float3( 0, 1, 0 ) ) ), 0.0, 1.0);\r\n",
+            outTex, inNormal, inNormal));
+      meta->addStatement(
+         new GenOp("   @.w = 1.0 - abs( dot( normalize( @.xyz ), float3( 0, 0, 1 ) ) );\r\n",
+            outTex, inNormal));
    }
    else
-      meta->addStatement( new GenOp( "   @.z = 0;\r\n", outTex ) );
+   {
+      meta->addStatement(new GenOp("   @.z = 0;\r\n", outTex));
+      meta->addStatement(new GenOp("   @.w = 0;\r\n", outTex));
+   }
 
    // HACK: This is sort of lazy... we generate the tanget
    // vector here so that we're sure it exists in the parallax
@@ -341,7 +335,7 @@ void TerrainBaseMapFeatHLSL::processPix(Vector<ShaderComponent*>& componentList,
    const MaterialFeatureData& fd)
 {
    // grab connector texcoord register
-   Var* texCoord = getInTexCoord("texCoord", "float3", componentList);
+   Var *texCoord = getInTexCoord( "texCoord", "float4", componentList );
 
    // create texture var
    Var* diffuseMap = new Var;
@@ -501,8 +495,8 @@ void TerrainDetailMapFeatHLSL::processVert(  Vector<ShaderComponent*> &component
    meta->addStatement( new GenOp( "   @.xyz = @ * @.xyx;\r\n", outTex, inTex, new IndexOp(detScaleAndFade, detailIndex) ) );
 
    // And sneak the detail fade thru the w detailCoord.
-   meta->addStatement( new GenOp( "   @.w = clamp( ( @.z - @ ) * @.w, 0.0, 1.0 );\r\n", 
-                                    outTex, new IndexOp(detScaleAndFade, detailIndex), dist, new IndexOp(detScaleAndFade, detailIndex)) );
+   meta->addStatement(new GenOp("   @.w = clamp( ( @.z - @ ) * @.w, 0.0, 1.0 );\r\n",
+      outTex, new IndexOp(detScaleAndFade, detailIndex), dist, new IndexOp(detScaleAndFade, detailIndex)));
 
    output = meta;
 }
@@ -623,8 +617,12 @@ void TerrainDetailMapFeatHLSL::processPix(   Vector<ShaderComponent*> &component
 
    if (fd.features.hasFeature(MFT_TerrainSideProject, detailIndex))
    {
-      meta->addStatement(new GenOp("   @ = ( lerp( @.Sample( @, float3(@.yz, @.x) ), @.Sample( @, float3(@.xz, @.x) ), @.z ) * 2.0 ) - 1.0;\r\n",
-         detailColor, detailMapArray, detailMapSampler, inDet, new IndexOp(detailInfo, detailIndex), detailMapArray, detailMapSampler, inDet, new IndexOp(detailInfo, detailIndex), inTex));
+      meta->addStatement(new GenOp("   @ = ( lerp( @.Sample( @, float3(@.xy, @.x) ), lerp( @.Sample( @, float3(@.yz, @.x) ), @.Sample( @, float3(@.xz, @.x) ), @.z ), @.w) * 2.0 ) - 1.0;\r\n",
+         detailColor,
+         detailMapArray, detailMapSampler, inDet, new IndexOp(detailInfo, detailIndex),
+         detailMapArray, detailMapSampler, inDet, new IndexOp(detailInfo, detailIndex),
+         detailMapArray, detailMapSampler, inDet, new IndexOp(detailInfo, detailIndex),
+         inTex, inTex));
    }
    else
    {
@@ -635,7 +633,7 @@ void TerrainDetailMapFeatHLSL::processPix(   Vector<ShaderComponent*> &component
    meta->addStatement(new GenOp("   @ *= @.y * @.w;\r\n",
       detailColor, new IndexOp(detailInfo, detailIndex), inDet));
 
-   if (!fd.features.hasFeature(MFT_TerrainHeightBlend))
+   if (!fd.features.hasFeature(MFT_TerrainNormalMap))
    {
       // Check to see if we have a gbuffer normal.
       Var* gbNormal = (Var*)LangElement::find("gbNormal");
@@ -902,8 +900,12 @@ void TerrainMacroMapFeatHLSL::processPix(   Vector<ShaderComponent*> &componentL
    //
    if (fd.features.hasFeature(MFT_TerrainSideProject, detailIndex))
    {
-      meta->addStatement(new GenOp("   @ = ( lerp( @.Sample( @, float3(@.yz, @.x) ), @.Sample( @, float3(@.xz, @.x) ), @.z ) * 2.0 ) - 1.0;\r\n",
-         detailColor, detailMapArray, detailMapSampler, inDet, new IndexOp(detailInfo, detailIndex), detailMapArray, detailMapSampler, inDet, new IndexOp(detailInfo, detailIndex), inTex));
+      meta->addStatement(new GenOp("   @ = ( lerp( @.Sample( @, float3(@.xy, @.x) ), lerp( @.Sample( @, float3(@.yz, @.x) ), @.Sample( @, float3(@.xz, @.x) ), @.z ), @.w ) * 2.0 ) - 1.0;\r\n",
+         detailColor,
+         detailMapArray, detailMapSampler, inDet, new IndexOp(detailInfo, detailIndex),
+         detailMapArray, detailMapSampler, inDet, new IndexOp(detailInfo, detailIndex),
+         detailMapArray, detailMapSampler, inDet, new IndexOp(detailInfo, detailIndex),
+         inTex, inTex));
    }
    else
    {
@@ -1007,8 +1009,11 @@ void TerrainNormalMapFeatHLSL::processPix(   Vector<ShaderComponent*> &component
 
    if (fd.features.hasFeature(MFT_TerrainSideProject, normalIndex))
    {
-      texOp = new GenOp("lerp( @.Sample( @, float3(@.yz, @.x) ), @.Sample( @, float3(@.xz, @.x) ), @.z )",
-         normalMapArray, normalMapSampler, inDet, new IndexOp(detailInfo, normalIndex), normalMapArray, normalMapSampler, inDet, new IndexOp(detailInfo, normalIndex), inTex);
+      texOp = new GenOp("lerp( @.Sample( @, float3(@.xy, @.x) ), lerp( @.Sample( @, float3(@.yz, @.x) ), @.Sample( @, float3(@.xz, @.x) ), @.z ), @.w )",
+         normalMapArray, normalMapSampler, inDet, new IndexOp(detailInfo, normalIndex),
+         normalMapArray, normalMapSampler, inDet, new IndexOp(detailInfo, normalIndex),
+         normalMapArray, normalMapSampler, inDet, new IndexOp(detailInfo, normalIndex),
+         inTex, inTex);
    }
    else
       texOp = new GenOp("@.Sample(@, float3(@.xy, @.x))", normalMapArray, normalMapSampler, inDet, new IndexOp(detailInfo, normalIndex));
@@ -1021,7 +1026,7 @@ void TerrainNormalMapFeatHLSL::processPix(   Vector<ShaderComponent*> &component
    LangElement* bumpNormDecl = new DecOp(bumpNorm);
    meta->addStatement(expandNormalMap(texOp, bumpNormDecl, bumpNorm, fd));
 
-   if (!fd.features.hasFeature(MFT_TerrainHeightBlend))
+   if (!fd.features.hasFeature(MFT_TerrainNormalMap))
    {
       Var* viewToTangent = getInViewToTangent(componentList);
 
@@ -1131,98 +1136,22 @@ ShaderFeature::Resources TerrainLightMapFeatHLSL::getResources( const MaterialFe
    return res;
 }
 
-//standard matInfo map contains data of the form .r = bitflags, .g = (will contain AO), 
-//.b = specular strength, a= spec power. 
-
 void TerrainORMMapFeatHLSL::processVert(Vector<ShaderComponent*> &componentList,
    const MaterialFeatureData &fd)
 {
-   const S32 detailIndex = getProcessIndex();
+   // We only need to process normals during the deferred.
+   if (!fd.features.hasFeature(MFT_DeferredConditioner))
+      return;
 
-   // Grab incoming texture coords... the base map feature
-   // made sure this was created.
-   Var *inTex = (Var*)LangElement::find("texCoord");
-   AssertFatal(inTex, "The texture coord is missing!");
+   MultiLine* meta = new MultiLine;
 
-   // Grab the input position.
-   Var *inPos = (Var*)LangElement::find("inPosition");
-   if (!inPos)
-      inPos = (Var*)LangElement::find("position");
-
-   // Get the object space eye position.
-   Var *eyePos = _getUniformVar("eyePos", "float3", cspPotentialPrimitive);
-
-   MultiLine *meta = new MultiLine;
-
-   // If we have parallax mapping then make sure we've sent
-   // the negative view vector to the pixel shader.
-   if (fd.features.hasFeature(MFT_TerrainParallaxMap) &&
-      !LangElement::find("outNegViewTS"))
+   if (!fd.features.hasFeature(MFT_TerrainHeightBlend))
    {
-      // Get the object to tangent transform which
-      // will consume 3 output registers.
-      Var *objToTangentSpace = getOutObjToTangentSpace(componentList, meta, fd);
-
-      // Now use a single output register to send the negative
-      // view vector in tangent space to the pixel shader.
-      ShaderConnector *connectComp = dynamic_cast<ShaderConnector *>(componentList[C_CONNECTOR]);
-      Var *outNegViewTS = connectComp->getElement(RT_TEXCOORD);
-      outNegViewTS->setName("outNegViewTS");
-      outNegViewTS->setStructName("OUT");
-      outNegViewTS->setType("float3");
-      meta->addStatement(new GenOp("   @ = mul( @, float3( @ - @.xyz ) );\r\n",
-         outNegViewTS, objToTangentSpace, eyePos, inPos));
+      // Make sure the world to tangent transform
+      // is created and available for the pixel shader.
+      getOutViewToTangent(componentList, meta, fd);
    }
 
-   // Get the distance from the eye to this vertex.
-   Var *dist = (Var*)LangElement::find("dist");
-   if (!dist)
-   {
-      dist = new Var;
-      dist->setType("float");
-      dist->setName("dist");
-
-      meta->addStatement(new GenOp("   @ = distance( @.xyz, @ );\r\n",
-         new DecOp(dist), inPos, eyePos));
-   }
-
-   // grab connector texcoord register
-   ShaderConnector *connectComp = dynamic_cast<ShaderConnector *>(componentList[C_CONNECTOR]);
-   Var *outTex = (Var*)LangElement::find(String::ToString("detCoord%d", detailIndex));
-   if (outTex == NULL)
-   {
-      outTex = connectComp->getElement(RT_TEXCOORD);
-      outTex->setName(String::ToString("detCoord%d", detailIndex));
-      outTex->setStructName("OUT");
-      outTex->setType("float4");
-   }
-   // Get the detail scale and fade info.
-   Var *detScaleAndFade = (Var*)LangElement::find("detailScaleAndFade");
-   if (detScaleAndFade == NULL)
-   {
-      detScaleAndFade = new Var;
-      detScaleAndFade->setType("float4");
-      detScaleAndFade->setName("detailScaleAndFade");
-      detScaleAndFade->uniform = true;
-      detScaleAndFade->constSortPos = cspPotentialPrimitive;
-   }
-
-   detScaleAndFade->arraySize = mMax(detScaleAndFade->arraySize, detailIndex + 1);
-
-   // Setup the detail coord.
-   //
-   // NOTE: You see here we scale the texture coord by 'xyx'
-   // to generate the detail coord.  This y is here because
-   // its scale is flipped to correct for the non negative y
-   // in texCoord.
-   //
-   // See TerrainBaseMapFeatHLSL::processVert().
-   //
-   meta->addStatement(new GenOp("   @.xyz = @ * @.xyx;\r\n", outTex, inTex, new IndexOp(detScaleAndFade, detailIndex)));
-
-   // And sneak the detail fade thru the w detailCoord.
-   meta->addStatement(new GenOp("   @.w = clamp( ( @.z - @ ) * @.w, 0.0, 1.0 );\r\n",
-      outTex, new IndexOp(detScaleAndFade, detailIndex), dist, new IndexOp(detScaleAndFade, detailIndex)));
 
    output = meta;
 }
@@ -1251,8 +1180,11 @@ void TerrainORMMapFeatHLSL::processPix(Vector<ShaderComponent*> &componentList,
    Var* ormMapSampler = _getOrmMapSampler();
    if (fd.features.hasFeature(MFT_TerrainSideProject, compositeIndex))
    {
-      texOp = new GenOp("lerp( @.Sample( @, float3(@.yz, @.x) ), @.Sample( @, float3(@.xz, @.x) ), @.z )",
-         ormMapArray, ormMapSampler, inDet, new IndexOp(detailInfo, compositeIndex), ormMapArray, ormMapSampler, inDet, new IndexOp(detailInfo, compositeIndex), inTex);
+      texOp = new GenOp("lerp( @.Sample( @, float3(@.xy, @.x) ), lerp( @.Sample( @, float3(@.yz, @.x) ), @.Sample( @, float3(@.xz, @.x) ), @.z ), @.w )",
+         ormMapArray, ormMapSampler, inDet, new IndexOp(detailInfo, compositeIndex),
+         ormMapArray, ormMapSampler, inDet, new IndexOp(detailInfo, compositeIndex),
+         ormMapArray, ormMapSampler, inDet, new IndexOp(detailInfo, compositeIndex),
+         inTex, inTex);
    }
    else
       texOp = new GenOp("@.Sample(@, float3(@.xy, @.x))", ormMapArray, ormMapSampler, inDet, new IndexOp(detailInfo, compositeIndex));
@@ -1402,6 +1334,13 @@ void TerrainHeightMapBlendHLSL::processPix(Vector<ShaderComponent*>& componentLi
 
    MultiLine* meta = new MultiLine;
 
+   Var* detailTot = (Var*)LangElement::find("detailTot");
+   if (detailTot == NULL)
+   {
+      detailTot = new Var("detailTot","float");
+      meta->addStatement(new GenOp("@=0;\r\n", new DecOp(detailTot)));
+   }
+
    // Count number of detail layers
    int detailCount = 0;
    while (true)
@@ -1461,11 +1400,11 @@ void TerrainHeightMapBlendHLSL::processPix(Vector<ShaderComponent*>& componentLi
          }
          else
          {
-            meta->addStatement(new GenOp("      @ = clamp(0.5 + @, 0.0, 1.0);\r\n",
+            meta->addStatement(new GenOp("      @ = clamp(@, 0.0, 1.0);\r\n",
                detailH, blendDepth));
          }
 
-         meta->addStatement(new GenOp("      @ = max((@ * 2.0f - 1.0f) * @ + 0.5f, 0.0f);\r\n",
+         meta->addStatement(new GenOp("      @ = max((@ * 2.0f - 1.0f) * @, 0.0f);\r\n",
             detailH, detailH, blendContrast));
 
          meta->addStatement(new GenOp("   }\r\n"));
@@ -1522,6 +1461,7 @@ void TerrainHeightMapBlendHLSL::processPix(Vector<ShaderComponent*>& componentLi
          meta->addStatement(new GenOp("   @ = max(@ + @ - @, 0);\r\n",
             new DecOp(detailB), detailH, detailBlend, ma));
       }
+      meta->addStatement(new GenOp("   @ += @;\r\n", detailTot, detailB));
    }
 
    meta->addStatement(new GenOp("\r\n"));
@@ -1547,23 +1487,7 @@ void TerrainHeightMapBlendHLSL::processPix(Vector<ShaderComponent*>& componentLi
       meta->addStatement(new GenOp("@.rgb * @", detailColor, detailB));
    }
 
-   meta->addStatement(new GenOp(") / ("));
-
-   for (S32 idx = 0; idx < detailCount; ++idx)
-   {
-      Var* detailB = (Var*)LangElement::find(String::ToString("detailB%d", idx));
-
-      if (idx > 0)
-      {
-         meta->addStatement(new GenOp(" + "));
-      }
-
-      meta->addStatement(new GenOp("@", detailB));
-   }
-
-
-   meta->addStatement(new GenOp(");\r\n"));
-
+   meta->addStatement(new GenOp(") / @;\r\n", detailTot));
    meta->addStatement(new GenOp("   @.rgb = toLinear(clamp(@.rgb, 0, 1));\r\n",
       outColor, outColor));
 
@@ -1601,23 +1525,7 @@ void TerrainHeightMapBlendHLSL::processPix(Vector<ShaderComponent*>& componentLi
       }
    }
 
-   meta->addStatement(new GenOp(") / ("));
-
-   for (S32 idx = 0; idx < detailCount; ++idx)
-   {
-      Var* detailB = (Var*)LangElement::find(String::ToString("detailB%d", idx));
-
-      if (idx > 0)
-      {
-         meta->addStatement(new GenOp(" + "));
-      }
-
-      meta->addStatement(new GenOp("@", detailB));
-   }
-
-
-   meta->addStatement(new GenOp(");\r\n"));
-
+   meta->addStatement(new GenOp(") / @;\r\n", detailTot));
 
    meta->addStatement(new GenOp("\r\n"));
 
@@ -1704,22 +1612,7 @@ void TerrainHeightMapBlendHLSL::processPix(Vector<ShaderComponent*>& componentLi
          }
       }
 
-      meta->addStatement(new GenOp(") / ("));
-
-      for (S32 idx = 0; idx < detailCount; ++idx)
-      {
-         Var* normalDetailB = (Var*)LangElement::find(String::ToString("normalDetailB%d", idx));
-
-         if (idx > 0)
-         {
-            meta->addStatement(new GenOp(" + "));
-         }
-
-         meta->addStatement(new GenOp("@", normalDetailB));
-      }
-
-
-      meta->addStatement(new GenOp(");\r\n"));
+      meta->addStatement(new GenOp(") / @;\r\n", detailTot));
    }
 
 
diff --git a/Engine/source/terrain/terrMaterial.cpp b/Engine/source/terrain/terrMaterial.cpp
index 8a7683078..1ddaf21f5 100644
--- a/Engine/source/terrain/terrMaterial.cpp
+++ b/Engine/source/terrain/terrMaterial.cpp
@@ -26,6 +26,10 @@
 #include "gfx/gfxTextureManager.h"
 #include "gfx/bitmap/gBitmap.h"
 
+#ifdef TORQUE_TOOLS
+#include "console\persistenceManager.h"
+#endif
+
 #include <string>
 
 

From a76613604a807c12d1b5d0f12cc2ccf97312bbcb Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Mon, 13 Dec 2021 20:36:50 -0600
Subject: [PATCH 285/399] augments playSoundAsset adds hooks to the garbage
 collector exposes an (optional) position. adds a ServerPlaySound +
 clientCMDPlaySound command pair to trip that for all clients

---
 .../clientServer/scripts/server/audio.tscript  |  7 +++++++
 .../utility/scripts/helperFunctions.tscript    | 18 ++++++++++++++----
 2 files changed, 21 insertions(+), 4 deletions(-)

diff --git a/Templates/BaseGame/game/core/clientServer/scripts/server/audio.tscript b/Templates/BaseGame/game/core/clientServer/scripts/server/audio.tscript
index 67b2fbf5e..627701371 100644
--- a/Templates/BaseGame/game/core/clientServer/scripts/server/audio.tscript
+++ b/Templates/BaseGame/game/core/clientServer/scripts/server/audio.tscript
@@ -38,3 +38,10 @@ function ServerPlay3D(%profile,%transform)
       ClientGroup.getObject(%idx).play3D(%profile,%transform);
 }
 
+function ServerPlaySound(%profile,%pos)
+{
+   // Play the given sound profile at the given position on every client
+   // The sound will be transmitted as an event, not attached to any object.
+   for(%idx = 0; %idx < ClientGroup.getCount(); %idx++)
+      commandToClient(ClientGroup.getObject(%idx), PlaySound, %pos);
+}
\ No newline at end of file
diff --git a/Templates/BaseGame/game/core/utility/scripts/helperFunctions.tscript b/Templates/BaseGame/game/core/utility/scripts/helperFunctions.tscript
index 3143eb410..98d616529 100644
--- a/Templates/BaseGame/game/core/utility/scripts/helperFunctions.tscript
+++ b/Templates/BaseGame/game/core/utility/scripts/helperFunctions.tscript
@@ -645,11 +645,21 @@ function populateAllFonts(%font)
 }
 
 //------------------------------------------------------------------------------
-function playSoundAsset(%soundAssetId)
+function clientCMDPlaySound(%soundAssetId,%pos)
+{
+    playSoundAsset(%soundAssetId,%pos);
+}
+
+function playSoundAsset(%soundAssetId,%pos)
 {
    %assetDef = AssetDatabase.acquireAsset(%soundAssetId);
+   %handle = 0;
    if(isObject(%assetDef))
-      %assetDef.playSound();
-   
-   AssetDatabase.releaseAsset(%soundAssetId);
+   {
+      %handle = %assetDef.playSound(%pos);
+      if( isObject( ClientMissionCleanup ) )
+         ClientMissionCleanup.add(%handle);
+  }
+  AssetDatabase.releaseAsset(%soundAssetId);
+  return %handle;
 }
\ No newline at end of file

From deb994cb13f6b70959143d1af68cd5cf67e0f185 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Tue, 14 Dec 2021 19:44:44 -0500
Subject: [PATCH 286/399] * BugFix: Correct a windows-only pathing issue in
 terrMaterial.

---
 Engine/source/terrain/terrMaterial.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Engine/source/terrain/terrMaterial.cpp b/Engine/source/terrain/terrMaterial.cpp
index 1ddaf21f5..fa3b21f0a 100644
--- a/Engine/source/terrain/terrMaterial.cpp
+++ b/Engine/source/terrain/terrMaterial.cpp
@@ -27,7 +27,7 @@
 #include "gfx/bitmap/gBitmap.h"
 
 #ifdef TORQUE_TOOLS
-#include "console\persistenceManager.h"
+#include "console/persistenceManager.h"
 #endif
 
 #include <string>

From d1dbfad0c72b4e332ab5698a8a896024e90355ed Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Tue, 14 Dec 2021 19:11:18 -0500
Subject: [PATCH 287/399] * [MacOS] BugFix: Correct the MacOS executable not
 being output to the game directory when no build configuration is provided.

---
 Tools/CMake/basics.cmake | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

diff --git a/Tools/CMake/basics.cmake b/Tools/CMake/basics.cmake
index dbd6f9a71..89d2c43dd 100644
--- a/Tools/CMake/basics.cmake
+++ b/Tools/CMake/basics.cmake
@@ -386,7 +386,7 @@ macro(finishExecutable)
     else()
         add_executable("${PROJECT_NAME}" WIN32 ${${PROJECT_NAME}_files})
     endif()
-
+    
     # Torque requires c++17
     target_compile_features(${PROJECT_NAME} PRIVATE cxx_std_17)
 
@@ -478,18 +478,13 @@ else()
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_CXX_FLAGS}")
 endif()
 
-if(UNIX AND NOT APPLE)
+if(UNIX)
 	SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${projectOutDir}")
 	set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${projectOutDir}")
 	SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG "${projectOutDir}")
 	set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG "${projectOutDir}")
-endif()
-
-if(APPLE)
-  SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE "${projectOutDir}")
-  set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE "${projectOutDir}")
-  SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG "${projectOutDir}")
-  set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG "${projectOutDir}")
+    SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE "${projectOutDir}")
+    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE "${projectOutDir}")
 endif()
 
 # fix the debug/release subfolders on windows

From bd979aa5cfeb2b7a94b7e73a276f4e1aa610a13b Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Tue, 14 Dec 2021 22:23:23 -0500
Subject: [PATCH 288/399] * Adjustment: Minor formatting fix in basics.cmake.

---
 Tools/CMake/basics.cmake | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Tools/CMake/basics.cmake b/Tools/CMake/basics.cmake
index 89d2c43dd..c0fc10426 100644
--- a/Tools/CMake/basics.cmake
+++ b/Tools/CMake/basics.cmake
@@ -386,7 +386,7 @@ macro(finishExecutable)
     else()
         add_executable("${PROJECT_NAME}" WIN32 ${${PROJECT_NAME}_files})
     endif()
-    
+
     # Torque requires c++17
     target_compile_features(${PROJECT_NAME} PRIVATE cxx_std_17)
 
@@ -483,8 +483,8 @@ if(UNIX)
 	set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${projectOutDir}")
 	SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG "${projectOutDir}")
 	set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG "${projectOutDir}")
-    SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE "${projectOutDir}")
-    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE "${projectOutDir}")
+	SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE "${projectOutDir}")
+	set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE "${projectOutDir}")
 endif()
 
 # fix the debug/release subfolders on windows

From e1398895b304df817d87176ca5b7ccfccd2da520 Mon Sep 17 00:00:00 2001
From: rextimmy <rextimm777@gmail.com>
Date: Wed, 15 Dec 2021 20:09:18 +1000
Subject: [PATCH 289/399] fix opengl device not returning the correct
 anisotropic value

---
 Engine/source/gfx/gl/gfxGLDevice.cpp | 1 -
 Engine/source/gfx/gl/gfxGLDevice.h   | 4 +---
 2 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/Engine/source/gfx/gl/gfxGLDevice.cpp b/Engine/source/gfx/gl/gfxGLDevice.cpp
index d5a73760b..e550b2f88 100644
--- a/Engine/source/gfx/gl/gfxGLDevice.cpp
+++ b/Engine/source/gfx/gl/gfxGLDevice.cpp
@@ -247,7 +247,6 @@ GFXGLDevice::GFXGLDevice(U32 adapterIndex) :
       mActiveTextureType[i] = GL_ZERO;
 
    mNumVertexStream = 2;
-   mSupportsAnisotropic = false;
 
    for(int i = 0; i < GS_COUNT; ++i)
       mModelViewProjSC[i] = NULL;
diff --git a/Engine/source/gfx/gl/gfxGLDevice.h b/Engine/source/gfx/gl/gfxGLDevice.h
index bec934367..3a42db9d6 100644
--- a/Engine/source/gfx/gl/gfxGLDevice.h
+++ b/Engine/source/gfx/gl/gfxGLDevice.h
@@ -152,7 +152,7 @@ public:
    virtual void setupGenericShaders( GenericShaderType type = GSColor );
    
    ///
-   bool supportsAnisotropic() const { return mSupportsAnisotropic; }
+   bool supportsAnisotropic() const { return mCapabilities.anisotropicFiltering; }
 
    GFXGLStateCache* getOpenglCache() { return mOpenglStateCache; }
 
@@ -235,8 +235,6 @@ private:
    void* mPixelFormat;
 
    F32 mPixelShaderVersion;
-   
-   bool mSupportsAnisotropic;   
 
    U32 mNumVertexStream;
    

From 7c32abd026ba9655314215384d340e013cd58a59 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Thu, 16 Dec 2021 18:25:14 -0600
Subject: [PATCH 290/399] fix ServerPlaySound

---
 .../game/core/clientServer/scripts/server/audio.tscript         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Templates/BaseGame/game/core/clientServer/scripts/server/audio.tscript b/Templates/BaseGame/game/core/clientServer/scripts/server/audio.tscript
index 627701371..7cc7abd60 100644
--- a/Templates/BaseGame/game/core/clientServer/scripts/server/audio.tscript
+++ b/Templates/BaseGame/game/core/clientServer/scripts/server/audio.tscript
@@ -43,5 +43,5 @@ function ServerPlaySound(%profile,%pos)
    // Play the given sound profile at the given position on every client
    // The sound will be transmitted as an event, not attached to any object.
    for(%idx = 0; %idx < ClientGroup.getCount(); %idx++)
-      commandToClient(ClientGroup.getObject(%idx), PlaySound, %pos);
+      commandToClient(ClientGroup.getObject(%idx), 'PlaySound',%profile, %pos);
 }
\ No newline at end of file

From b70faae38fb154e7c0af97c2bd33c9027d011925 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Fri, 24 Dec 2021 17:26:45 -0600
Subject: [PATCH 291/399] Updates the handling of the baking of shape asset
 previews to generate them with support for view angle control to improve
 visibility, as well as supporting overriding of a material in the preview
 bake Also utilizes the updated bake handling to have material asset previews
 render as a sphere shape asset, overriding with the material asset's
 material, improving distinction of what is a material asset vs image asset
 Also updates the sphere preview mesh to be more generic and not only for
 reflection probes

---
 Engine/source/T3D/assets/ShapeAsset.cpp       | 103 +++++++++++++---
 Engine/source/T3D/assets/ShapeAsset.h         |   2 +-
 .../source/T3D/lighting/reflectionProbe.cpp   |   2 +-
 .../scripts/assetTypes/material.tscript       |  16 +--
 .../scripts/assetTypes/shape.tscript          |  16 +--
 .../resources/ReflectProbeSphere.asset.taml   |   6 -
 .../tools/resources/ReflectProbeSphere.dae    | 115 ------------------
 .../resources/ReflectProbeSphere.tscript      |  11 --
 .../resources/previewSphereShape.asset.taml   |   6 +
 .../tools/resources/previewSphereShape.dae    | 101 +++++++++++++++
 10 files changed, 206 insertions(+), 172 deletions(-)
 delete mode 100644 Templates/BaseGame/game/tools/resources/ReflectProbeSphere.asset.taml
 delete mode 100644 Templates/BaseGame/game/tools/resources/ReflectProbeSphere.dae
 delete mode 100644 Templates/BaseGame/game/tools/resources/ReflectProbeSphere.tscript
 create mode 100644 Templates/BaseGame/game/tools/resources/previewSphereShape.asset.taml
 create mode 100644 Templates/BaseGame/game/tools/resources/previewSphereShape.dae

diff --git a/Engine/source/T3D/assets/ShapeAsset.cpp b/Engine/source/T3D/assets/ShapeAsset.cpp
index c532d2370..c145965a1 100644
--- a/Engine/source/T3D/assets/ShapeAsset.cpp
+++ b/Engine/source/T3D/assets/ShapeAsset.cpp
@@ -51,6 +51,9 @@
 #endif
 #include "util/imposterCapture.h"
 
+#include "ts/tsShapeInstance.h"
+#include "gfx/bitmap/imageUtils.h"
+
 StringTableEntry ShapeAsset::smNoShapeAssetFallback = NULL;
 
 //-----------------------------------------------------------------------------
@@ -560,25 +563,94 @@ ShapeAnimationAsset* ShapeAsset::getAnimation(S32 index)
 }
 
 #ifdef TORQUE_TOOLS
-const char* ShapeAsset::generateCachedPreviewImage(S32 resolution)
+const char* ShapeAsset::generateCachedPreviewImage(S32 resolution, String overrideMaterial)
 {
    if (!mShape)
       return "";
 
-   TSLastDetail* dt = new TSLastDetail(mShape,
-      mFilePath,
-      1,
-      0,
-      0,
-      false,
-      0,
-      resolution);
+   // We're gonna render... make sure we can.
+   bool sceneBegun = GFX->canCurrentlyRender();
+   if (!sceneBegun)
+      GFX->beginScene();
 
-   dt->update();
+   // We need to create our own instance to render with.
+   TSShapeInstance* shape = new TSShapeInstance(mShape, true);
 
-   delete dt;
+   if(overrideMaterial.isNotEmpty())
+      shape->reSkin(overrideMaterial, mShape->materialList->getMaterialName(0));
 
-   return mFilePath;
+   // Animate the shape once.
+   shape->animate(0);
+
+   // So we don't have to change it everywhere.
+   const GFXFormat format = GFXFormatR8G8B8A8;
+
+   GBitmap* imposter = NULL;
+   GBitmap* imposterNrml = NULL;
+
+   ImposterCapture* imposterCap = new ImposterCapture();
+
+   static const MatrixF topXfm(EulerF(-M_PI_F / 2.0f, 0, 0));
+   static const MatrixF bottomXfm(EulerF(M_PI_F / 2.0f, 0, 0));
+
+   MatrixF angMat;
+
+   S32 mip = 0;
+
+   PROFILE_START(ShapeAsset_generateCachedPreviewImage);
+
+   //dMemset(destBmp.getWritableBits(mip), 0, destBmp.getWidth(mip) * destBmp.getHeight(mip) * GFXFormat_getByteSize(format));
+
+   F32 rotX = -(mDegToRad(60.0) - 0.5f * M_PI_F);
+   F32 rotZ = -(mDegToRad(45.0) - 0.5f * M_PI_F);
+
+   // We capture the images in a particular order which must
+   // match the order expected by the imposter renderer.
+
+   imposterCap->begin(shape, 0, resolution, mShape->mRadius, mShape->center);
+
+   angMat.mul(MatrixF(EulerF(rotX, 0, 0)),
+      MatrixF(EulerF(0, 0, rotZ)));
+
+   imposterCap->capture(angMat, &imposter, &imposterNrml);
+
+   imposterCap->end();
+
+   PROFILE_END(); // ShapeAsset_generateCachedPreviewImage
+
+   delete imposterCap;
+   delete shape;
+
+   String dumpPath = String(mFilePath) + "_Preview.dds";
+
+   char* returnBuffer = Con::getReturnBuffer(dumpPath.length());
+   dSprintf(returnBuffer, dumpPath.length(), "%s", dumpPath.c_str());
+
+   /*FileStream stream;
+   if (stream.open(dumpPath, Torque::FS::File::Write))
+      destBmp.writeBitmap("png", stream);
+   stream.close();*/
+   
+   DDSFile* ddsDest = DDSFile::createDDSFileFromGBitmap(imposter);
+   ImageUtil::ddsCompress(ddsDest, GFXFormatBC2);
+
+   // Finally save the imposters to disk.
+   FileStream fs;
+   if (fs.open(returnBuffer, Torque::FS::File::Write))
+   {
+      ddsDest->write(fs);
+      fs.close();
+   }
+
+   delete ddsDest;
+   delete imposter;
+   delete imposterNrml;
+
+   // If we did a begin then end it now.
+   if (!sceneBegun)
+      GFX->endScene();
+
+   return returnBuffer;
 }
 #endif
 
@@ -625,9 +697,12 @@ DefineEngineMethod(ShapeAsset, getStatusString, String, (), , "get status string
 
 
 #ifdef TORQUE_TOOLS
-DefineEngineMethod(ShapeAsset, generateCachedPreviewImage, const char*, (S32 resolution), (256), "")
+DefineEngineMethod(ShapeAsset, generateCachedPreviewImage, const char*, (S32 resolution, const char* overrideMaterialName), (256, ""),
+   "Generates a baked preview image of the given shapeAsset. Only really used for generating Asset Browser icons.\n"
+   "@param resolution Optional field for what resolution to bake the preview image at. Must be pow2\n"
+   "@param overrideMaterialName Optional field for overriding the material used when rendering the shape for the bake.")
 {
-   return object->generateCachedPreviewImage(resolution);
+   return object->generateCachedPreviewImage(resolution, overrideMaterialName);
 }
 
 DefineEngineStaticMethod(ShapeAsset, getAssetIdByFilename, const char*, (const char* filePath), (""),
diff --git a/Engine/source/T3D/assets/ShapeAsset.h b/Engine/source/T3D/assets/ShapeAsset.h
index 7288ec515..c94cd8384 100644
--- a/Engine/source/T3D/assets/ShapeAsset.h
+++ b/Engine/source/T3D/assets/ShapeAsset.h
@@ -191,7 +191,7 @@ public:
    static U32 getAssetById(StringTableEntry assetId, AssetPtr<ShapeAsset>* shapeAsset);
 
 #ifdef TORQUE_TOOLS
-   const char* generateCachedPreviewImage(S32 resolution);
+   const char* generateCachedPreviewImage(S32 resolution, String overrideMaterial = "");
 #endif
 
 protected:
diff --git a/Engine/source/T3D/lighting/reflectionProbe.cpp b/Engine/source/T3D/lighting/reflectionProbe.cpp
index 985f4871c..9361b05f1 100644
--- a/Engine/source/T3D/lighting/reflectionProbe.cpp
+++ b/Engine/source/T3D/lighting/reflectionProbe.cpp
@@ -798,7 +798,7 @@ void ReflectionProbe::createEditorResources()
 
    mEditorShape = NULL;
 
-   String shapeFile = "tools/resources/ReflectProbeSphere.dae";
+   String shapeFile = "tools/resources/previewSphereShape.dae";
 
    // Attempt to get the resource from the ResourceManager
    mEditorShape = ResourceManager::get().load(shapeFile);
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
index 4363209a5..d70c6a4a5 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
@@ -433,7 +433,7 @@ function AssetBrowser::buildMaterialAssetPreview(%this, %assetDef, %previewData)
 
    %generatePreview = false;
 
-   %previewFilePath = %previewPath @ %assetDef.assetName @ "_Preview.png";
+   %previewFilePath = %previewPath @ %assetDef.assetName @ "_Preview.dds";
    if(!isFile(%previewFilePath))
    {
       %generatePreview = true;
@@ -457,17 +457,11 @@ function AssetBrowser::buildMaterialAssetPreview(%this, %assetDef, %previewData)
    
    if(isObject(%assetDef.materialDefinitionName))
    {
-      	if(isFile(%assetDef.materialDefinitionName.getDiffuseMap(0)))
-         {
-            %difMap = %assetDef.materialDefinitionName.getDiffuseMap(0);
-         }
-      	else if(%assetDef.materialDefinitionName.getDiffuseMapAsset(0) !$= "")
-      	{
-         %imgAsset = AssetDatabase.acquireAsset(%assetDef.materialDefinitionName.getDiffuseMapAsset(0));
-            %difMap = %imgAsset.getImagePath();
-   		}
+         %previewShapeDef = AssetDatabase.acquireAsset("ToolsModule:previewSphereShape");
+         %generatedFilePath = %previewShapeDef.generateCachedPreviewImage(256, %assetDef.materialDefinitionName);
       
-         %success = saveScaledImage(%difMap, %previewFilePath);
+         pathCopy(%generatedFilePath, %previewFilePath);
+         fileDelete(%generatedFilePath);
 
          %previewAsset = new ImageAsset()
          {
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
index 89f981438..f497a2e55 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
@@ -258,7 +258,7 @@ function AssetBrowser::buildShapeAssetPreview(%this, %assetDef, %previewData)
    
    %generatePreview = false;
    
-   %previewFilePath = %previewPath @ %assetDef.assetName @ "_Preview.png";
+   %previewFilePath = %previewPath @ %assetDef.assetName @ "_Preview.dds";
    if(!isFile(%previewFilePath) || (compareFileTimes(%assetDef.getShapeFile(), %previewFilePath) == 1))
    {
       %generatePreview = true;
@@ -272,21 +272,11 @@ function AssetBrowser::buildShapeAssetPreview(%this, %assetDef, %previewData)
       
       //This is slightly hacky, but we're going to utilize the imposter/last detail system
       //to generate our previews for us and then clean up the unneeded bits
-      %oldImposterSetting = $TSLastDetail::dumpImposters;
-      $TSLastDetail::dumpImposters = true;
       
       %filePath = %assetDef.generateCachedPreviewImage();
       
-      %imposterPath = %filePath @ ".imposter.png";
-      pathCopy(%imposterPath, %previewFilePath);
-      
-      //cleanup
-      fileDelete(%imposterPath);
-      fileDelete(%filePath @ ".imposter.dds");
-      fileDelete(%filePath @ ".imposter_normals.png");
-      fileDelete(%filePath @ ".imposter_normals.dds");
-      
-      $TSLastDetail::dumpImposters = %oldImposterSetting;
+      pathCopy(%filePath, %previewFilePath);
+      fileDelete(%filePath); //cleanup
       
       %previewAsset = new ImageAsset()
       {
diff --git a/Templates/BaseGame/game/tools/resources/ReflectProbeSphere.asset.taml b/Templates/BaseGame/game/tools/resources/ReflectProbeSphere.asset.taml
deleted file mode 100644
index dfdd62395..000000000
--- a/Templates/BaseGame/game/tools/resources/ReflectProbeSphere.asset.taml
+++ /dev/null
@@ -1,6 +0,0 @@
-<ShapeAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="ReflectProbeSphere"
-    fileName="@assetFile=ReflectProbeSphere.dae"
-    constuctorFileName="@assetFile=ReflectProbeSphere.tscript" />
diff --git a/Templates/BaseGame/game/tools/resources/ReflectProbeSphere.dae b/Templates/BaseGame/game/tools/resources/ReflectProbeSphere.dae
deleted file mode 100644
index b488de77a..000000000
--- a/Templates/BaseGame/game/tools/resources/ReflectProbeSphere.dae
+++ /dev/null
@@ -1,115 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<COLLADA xmlns="http://www.collada.org/2005/11/COLLADASchema" version="1.4.1">
-<asset>
-	<contributor>
-		<author> Anonymous </author>
-		<authoring_tool> Collada Exporter for Blender 2.6+, by Juan Linietsky (juan@codenix.com) </authoring_tool>
-	</contributor>
-	<created>2016-09-06T21:59:07Z     </created>
-	<modified>2016-09-06T21:59:07Z</modified>
-	<unit meter="1.0" name="meter"/>
-	<up_axis>Z_UP</up_axis>
-</asset>
-<library_images>
-</library_images>
-<library_effects>
-	<effect id="id-fx-2" name="ReflectProbePreviewMat-fx">
-		<profile_COMMON>
-			<technique sid="common">
-				<blinn>
-					<emission>
-						<color>  0.0 0.0 0.0 1.0  </color>
-					</emission>
-					<ambient>
-						<color>  0.0 0.0 0.0 1.0  </color>
-					</ambient>
-					<diffuse>
-						<color>  0.3737608488464481 0.3737608488464481 0.3737608488464481 1.0 </color>
-					</diffuse>
-					<specular>
-						<color>  0.0 0.0 0.0 1.0 </color>
-					</specular>
-					<shininess>
-						<float>50</float>
-					</shininess>
-					<reflective>
-						<color>  1.0 1.0 1.0 1.0 </color>
-					</reflective>
-					<index_of_refraction>
-						<float>4.0</float>
-					</index_of_refraction>
-				</blinn>
-				<extra>
-					<technique profile="FCOLLADA">
-					</technique>
-					<technique profile="GOOGLEEARTH">
-						<double_sided>0</double_sided>
-					</technique>
-				</extra>
-			</technique>
-		</profile_COMMON>
-	</effect>
-</library_effects>
-<library_materials>
-	<material id="id-material-3" name="ReflectProbePreviewMat">
-		<instance_effect url="#id-fx-2"/>
-	</material>
-</library_materials>
-<library_geometries>
-	<geometry id="id-mesh-4" name="Sphere">
-		<mesh>
-			<source id="id-mesh-4-positions">
-				<float_array id="id-mesh-4-positions-array" count="1446"> -0.49039262533187866 0.0 0.09754517674446106 -0.49039262533187866 0.09754519164562225 3.774895063202166e-08 -0.5 0.0 3.774895063202166e-08 -0.09754516184329987 0.0 0.49039262533187866 1.2401747184753731e-08 -6.234699867491145e-08 0.5 -0.09567085653543472 0.019030148163437843 0.49039262533187866 1.6292068494294654e-07 0.0 -0.5 -0.09754504263401031 0.0 -0.49039265513420105 -0.09567073732614517 0.019030125811696053 -0.49039265513420105 -0.4809698760509491 0.09567089378833771 -0.09754510223865509 -0.49039265513420105 0.0 -0.09754510223865509 -0.1876651495695114 0.03732895478606224 0.4619397521018982 -0.19134172797203064 0.0 0.4619397521018982 -0.4619397819042206 0.0 -0.19134163856506348 -0.4530637264251709 0.09012001007795334 -0.19134163856506348 -0.27778512239456177 0.0 0.41573479771614075 -0.2724475562572479 0.054193224757909775 0.41573479771614075 -0.4077465832233429 0.08110587298870087 -0.2777850925922394 -0.41573482751846313 0.0 -0.2777850925922394 -0.34675994515419006 0.06897487491369247 0.3535533845424652 -0.3535533845424652 0.0 0.3535533845424652 -0.3535533845424652 0.0 -0.3535533845424652 -0.34675994515419006 0.06897487491369247 -0.3535533845424652 -0.4077465832233429 0.08110587298870087 0.2777850925922394 -0.41573482751846313 0.0 0.2777850925922394 -0.27244752645492554 0.05419321730732918 -0.41573482751846313 -0.2777850925922394 0.0 -0.41573482751846313 -0.4530636966228485 0.09012000262737274 0.19134171307086945 -0.4619397521018982 0.0 0.19134171307086945 -0.18766506016254425 0.03732893615961075 -0.46193981170654297 -0.19134163856506348 0.0 -0.46193981170654297 -0.4809698462486267 0.09567088633775711 0.09754517674446106 -0.17677661776542664 0.07322333753108978 -0.46193981170654297 -0.4530636668205261 0.187665194272995 0.09754517674446106 -0.0901198536157608 0.03732893243432045 -0.49039265513420105 -0.4619397222995758 0.19134177267551422 3.774895063202166e-08 -0.09011997282505035 0.03732898086309433 0.49039262533187866 -0.4530636668205261 0.187665194272995 -0.09754510223865509 -0.1767767071723938 0.07322336733341217 0.4619397521018982 -0.4267766773700714 0.17677675187587738 -0.19134163856506348 -0.2566399574279785 0.10630382597446442 0.41573479771614075 -0.3840888440608978 0.1590948849916458 -0.2777850925922394 -0.32664069533348083 0.13529908657073975 0.3535533845424652 -0.32664069533348083 0.13529908657073975 -0.3535533845424652 -0.3840888440608978 0.1590948849916458 0.2777850925922394 -0.25663992762565613 0.10630381107330322 -0.41573482751846313 -0.426776647567749 0.1767767369747162 0.19134171307086945 -0.3840888440608978 0.2566400468349457 -0.19134163856506348 -0.34567081928253174 0.23096996545791626 -0.2777850925922394 -0.2939688563346863 0.19642382860183716 0.3535533845424652 -0.2939688563346863 0.19642382860183716 -0.3535533845424652 -0.34567081928253174 0.23096996545791626 0.2777850925922394 -0.23096981644630432 0.15432921051979065 -0.41573482751846313 -0.38408881425857544 0.2566400468349457 0.19134171307086945 -0.15909473598003387 0.10630381107330322 -0.46193981170654297 -0.40774649381637573 0.2724476158618927 0.09754517674446106 -0.08110571652650833 0.05419320985674858 -0.49039265513420105 -0.41573473811149597 0.27778521180152893 3.774895063202166e-08 -0.08110581338405609 0.05419328436255455 0.49039262533187866 -0.40774649381637573 0.2724476158618927 -0.09754510223865509 -0.15909481048583984 0.1063038557767868 0.4619397521018982 -0.2309698462486267 0.15432922542095184 0.41573479771614075 -0.06897471845149994 0.06897486746311188 -0.49039265513420105 -0.3467598557472229 0.3467600345611572 0.09754517674446106 -0.35355329513549805 0.35355350375175476 3.774895063202166e-08 -0.0689748004078865 0.06897496432065964 0.49039262533187866 -0.3467598557472229 0.3467600345611572 -0.09754510223865509 -0.1352989822626114 0.13529914617538452 0.4619397521018982 -0.32664069533348083 0.3266408145427704 -0.19134163856506348 -0.19642367959022522 0.19642384350299835 0.41573479771614075 -0.2939688265323639 0.2939690053462982 -0.2777850925922394 -0.24999994039535522 0.25000008940696716 0.3535533845424652 -0.24999994039535522 0.25000008940696716 -0.3535533845424652 -0.2939688265323639 0.2939690053462982 0.2777850925922394 -0.19642364978790283 0.19642382860183716 -0.41573482751846313 -0.32664066553115845 0.3266408145427704 0.19134171307086945 -0.1352989375591278 0.13529908657073975 -0.46193981170654297 -0.19642364978790283 0.2939690053462982 0.3535533845424652 -0.19642364978790283 0.2939690053462982 -0.3535533845424652 -0.23096978664398193 0.3456709682941437 0.2777850925922394 -0.15432903170585632 0.23096996545791626 -0.41573482751846313 -0.25663989782333374 0.3840889632701874 0.19134171307086945 -0.10630366206169128 0.159094899892807 -0.46193981170654297 -0.272447407245636 0.40774664282798767 0.09754517674446106 -0.054193053394556046 0.08110586553812027 -0.49039265513420105 -0.2777850031852722 0.4157349169254303 3.774895063202166e-08 -0.05419311672449112 0.08110596984624863 0.49039262533187866 -0.272447407245636 0.40774664282798767 -0.09754510223865509 -0.10630369931459427 0.15909495949745178 0.4619397521018982 -0.25663992762565613 0.3840889632701874 -0.19134163856506348 -0.1543290615081787 0.23096999526023865 0.41573479771614075 -0.23096978664398193 0.3456709682941437 -0.2777850925922394 -0.1913415789604187 0.46193987131118774 3.774895063202166e-08 -0.0373288132250309 0.09012012183666229 0.49039262533187866 -0.037328775972127914 0.09012000262737274 -0.49039265513420105 -0.1876649558544159 0.4530637562274933 -0.09754510223865509 -0.07322321087121964 0.17677684128284454 0.4619397521018982 -0.17677661776542664 0.4267767667770386 -0.19134163856506348 -0.10630366206169128 0.25664010643959045 0.41573479771614075 -0.1590946912765503 0.38408899307250977 -0.2777850925922394 -0.13529890775680542 0.3266408443450928 0.3535533845424652 -0.13529890775680542 0.3266408443450928 -0.3535533845424652 -0.1590946912765503 0.38408899307250977 0.2777850925922394 -0.1063036322593689 0.25664007663726807 -0.41573482751846313 -0.17677658796310425 0.4267767667770386 0.19134171307086945 -0.07322318851947784 0.17677676677703857 -0.46193981170654297 -0.1876649558544159 0.4530637562274933 0.09754517674446106 -0.08110568672418594 0.40774667263031006 -0.2777850925922394 -0.06897471100091934 0.3467600643634796 -0.3535533845424652 -0.08110568672418594 0.40774667263031006 0.2777850925922394 -0.05419303476810455 0.2724476456642151 -0.41573482751846313 -0.0901198536157608 0.4530637860298157 0.19134171307086945 -0.03732877969741821 0.1876652091741562 -0.46193981170654297 -0.0956706702709198 0.4809699058532715 0.09754517674446106 -0.019029967486858368 0.09567087888717651 -0.49039265513420105 -0.09754499793052673 0.4903927445411682 3.774895063202166e-08 -0.019029982388019562 0.09567100554704666 0.49039262533187866 -0.0956706702709198 0.4809699058532715 -0.09754510223865509 -0.03732878714799881 0.18766528367996216 0.4619397521018982 -0.09011988341808319 0.4530637860298157 -0.19134163856506348 -0.054193057119846344 0.2724476754665375 0.41573479771614075 -0.06897471100091934 0.3467600643634796 0.3535533845424652 1.6331796359736472e-07 0.09754530340433121 0.49039262533187866 1.5400473785120994e-07 0.09754518419504166 -0.49039265513420105 1.8939499568659812e-07 0.5000001192092896 3.774895063202166e-08 1.9684557628352195e-07 0.49039262533187866 -0.09754510223865509 1.595926732989028e-07 0.1913418471813202 0.4619397521018982 1.1488918971735984e-07 0.46193984150886536 -0.19134163856506348 1.558673830004409e-07 0.2777852416038513 0.41573479771614075 1.6704325389582664e-07 0.4157348871231079 -0.2777850925922394 1.595926732989028e-07 0.3535534739494324 0.3535533845424652 1.595926732989028e-07 0.3535534739494324 -0.3535533845424652 1.6704325389582664e-07 0.4157348871231079 0.2777850925922394 1.7076854419428855e-07 0.27778518199920654 -0.41573482751846313 1.3724093150813133e-07 0.46193984150886536 0.19134171307086945 1.5214209270197898e-07 0.19134177267551422 -0.46193981170654297 1.9684557628352195e-07 0.49039262533187866 0.09754517674446106 0.06897501647472382 0.3467600345611572 0.3535533845424652 0.08110601454973221 0.40774664282798767 0.2777850925922394 0.06897501647472382 0.3467600345611572 -0.3535533845424652 0.05419337376952171 0.2724476158618927 -0.41573482751846313 0.09012012928724289 0.4530637860298157 0.19134171307086945 0.03732908144593239 0.187665194272995 -0.46193981170654297 0.09567105025053024 0.4809698462486267 0.09754517674446106 0.01903027668595314 0.09567087888717651 -0.49039265513420105 0.09754537045955658 0.4903927445411682 3.774895063202166e-08 0.019030308350920677 0.09567099809646606 0.49039262533187866 0.09567105025053024 0.4809698462486267 -0.09754510223865509 0.03732910379767418 0.18766526877880096 0.4619397521018982 0.0901201069355011 0.4530637860298157 -0.19134163856506348 0.054193370044231415 0.2724476754665375 0.41573479771614075 0.08110601454973221 0.40774664282798767 -0.2777850925922394 0.18766531348228455 0.4530636668205261 -0.09754510223865509 0.07322350889444351 0.17677681148052216 0.4619397521018982 0.17677682638168335 0.4267767667770386 -0.19134163856506348 0.10630396008491516 0.25664007663726807 0.41573479771614075 0.15909501910209656 0.3840889036655426 -0.2777850925922394 0.1352992057800293 0.3266408145427704 0.3535533845424652 0.1352992057800293 0.3266408145427704 -0.3535533845424652 0.15909501910209656 0.3840889036655426 0.2777850925922394 0.10630396008491516 0.2566400170326233 -0.41573482751846313 0.17677685618400574 0.4267767667770386 0.19134171307086945 0.07322347909212112 0.1767767369747162 -0.46193981170654297 0.18766531348228455 0.4530636668205261 0.09754517674446106 0.03732908144593239 0.09011999517679214 -0.49039265513420105 0.19134193658828735 0.46193984150886536 3.774895063202166e-08 0.03732913359999657 0.0901200994849205 0.49039262533187866 0.19642391800880432 0.29396897554397583 -0.3535533845424652 0.1543293297290802 0.23096990585327148 -0.41573482751846313 0.25664013624191284 0.384088933467865 0.19134171307086945 0.10630394518375397 0.15909485518932343 -0.46193981170654297 0.27244770526885986 0.4077465236186981 0.09754517674446106 0.05419335886836052 0.08110585063695908 -0.49039265513420105 0.2777853310108185 0.4157348573207855 3.774895063202166e-08 0.05419342592358589 0.08110594004392624 0.49039262533187866 0.27244770526885986 0.4077465236186981 -0.09754510223865509 0.10630397498607635 0.1590949296951294 0.4619397521018982 0.25664013624191284 0.384088933467865 -0.19134163856506348 0.1543293446302414 0.23096996545791626 0.41573479771614075 0.2309700846672058 0.3456708788871765 -0.2777850925922394 0.19642391800880432 0.29396897554397583 0.3535533845424652 0.2309700846672058 0.3456708788871765 0.2777850925922394 0.32664090394973755 0.3266408145427704 -0.19134163856506348 0.1964239478111267 0.19642379879951477 0.41573479771614075 0.2939690947532654 0.29396888613700867 -0.2777850925922394 0.2500001788139343 0.2500000298023224 0.3535533845424652 0.2500001788139343 0.2500000298023224 -0.3535533845424652 0.2939690947532654 0.29396888613700867 0.2777850925922394 0.19642391800880432 0.1964237540960312 -0.41573482751846313 0.32664090394973755 0.3266408145427704 0.19134171307086945 0.1352992057800293 0.13529904186725616 -0.46193981170654297 0.346760094165802 0.3467599153518677 0.09754517674446106 0.06897501647472382 0.06897485256195068 -0.49039265513420105 0.3535536229610443 0.3535534143447876 3.774895063202166e-08 0.06897509843111038 0.06897492706775665 0.49039262533187866 0.346760094165802 0.3467599153518677 -0.09754510223865509 0.13529925048351288 0.13529911637306213 0.4619397521018982 0.15909498929977417 0.10630377382040024 -0.46193981170654297 0.38408905267715454 0.2566400468349457 0.19134171307086945 0.40774670243263245 0.27244749665260315 0.09754517674446106 0.08110600709915161 0.05419319495558739 -0.49039265513420105 0.41573503613471985 0.27778512239456177 3.774895063202166e-08 0.08110609650611877 0.054193247109651566 0.49039262533187866 0.40774670243263245 0.27244749665260315 -0.09754510223865509 0.15909504890441895 0.10630382597446442 0.4619397521018982 0.38408905267715454 0.2566400468349457 -0.19134163856506348 0.2309700846672058 0.15432918071746826 0.41573479771614075 0.34567102789878845 0.2309698611497879 -0.2777850925922394 0.2939690947532654 0.1964237540960312 0.3535533845424652 0.2939690947532654 0.1964237540960312 -0.3535533845424652 0.34567102789878845 0.2309698611497879 0.2777850925922394 0.23097005486488342 0.15432913601398468 -0.41573482751846313 0.1767769157886505 0.07322335243225098 0.4619397521018982 0.2566401958465576 0.10630379617214203 0.41573479771614075 0.42677685618400574 0.1767767369747162 -0.19134163856506348 0.38408902287483215 0.15909478068351746 -0.2777850925922394 0.32664090394973755 0.13529901206493378 0.3535533845424652 0.32664090394973755 0.13529901206493378 -0.3535533845424652 0.38408902287483215 0.15909478068351746 0.2777850925922394 0.25664013624191284 0.10630375146865845 -0.41573482751846313 0.42677685618400574 0.1767767369747162 0.19134171307086945 0.17677685618400574 0.0732233077287674 -0.46193981170654297 0.45306381583213806 0.18766507506370544 0.09754517674446106 0.09012014418840408 0.03732892498373985 -0.49039265513420105 0.4619399905204773 0.19134169816970825 3.774895063202166e-08 0.09012024104595184 0.03732895851135254 0.49039262533187866 0.45306381583213806 0.18766507506370544 -0.09754510223865509 0.45306387543678284 0.09012001007795334 0.19134171307086945 0.48096996545791626 0.09567080438137054 0.09754517674446106 0.18766529858112335 0.037328921258449554 -0.46193981170654297 0.09567102044820786 0.019030120223760605 -0.49039265513420105 0.49039286375045776 0.09754512459039688 3.774895063202166e-08 0.09567112475633621 0.0190301351249218 0.49039262533187866 0.48096996545791626 0.09567080438137054 -0.09754510223865509 0.18766535818576813 0.03732895106077194 0.4619397521018982 0.45306387543678284 0.09012001007795334 -0.19134163856506348 0.27244776487350464 0.05419321358203888 0.41573479771614075 0.40774667263031006 0.0811057835817337 -0.2777850925922394 0.3467601239681244 0.06897483021020889 0.3535533845424652 0.3467601239681244 0.06897483021020889 -0.3535533845424652 0.40774667263031006 0.0811057835817337 0.2777850925922394 0.27244770526885986 0.05419318005442619 -0.41573482751846313 0.4619399309158325 3.1784249898691996e-08 -0.19134163856506348 0.4157348573207855 -4.2721556070546285e-08 -0.2777850925922394 0.2777853310108185 1.3157798406382426e-08 0.41573479771614075 0.35355353355407715 -1.2919233682850972e-08 0.3535533845424652 0.35355353355407715 -1.2919233682850972e-08 -0.3535533845424652 0.4157348573207855 -4.2721556070546285e-08 0.2777850925922394 0.2777852416038513 -5.468653085927144e-09 -0.41573482751846313 0.4619399309158325 3.1784249898691996e-08 0.19134171307086945 0.19134186208248138 1.981927510996684e-09 -0.46193981170654297 0.49039268493652344 -4.2721556070546285e-08 0.09754517674446106 0.0975453183054924 1.981927510996684e-09 -0.49039265513420105 0.5000001788139343 -5.017213666747011e-08 3.774895063202166e-08 0.09754542261362076 -3.6060079366961872e-09 0.49039262533187866 0.49039268493652344 -4.2721556070546285e-08 -0.09754510223865509 0.19134192168712616 2.0608379003306254e-08 0.4619397521018982 0.09567101299762726 -0.019030114635825157 -0.49039265513420105 0.490392804145813 -0.09754522144794464 3.774895063202166e-08 0.09567110985517502 -0.019030140712857246 0.49039262533187866 0.4809699058532715 -0.09567087888717651 -0.09754510223865509 0.18766532838344574 -0.03732890635728836 0.4619397521018982 0.45306387543678284 -0.09011995047330856 -0.19134163856506348 0.27244776487350464 -0.05419318377971649 0.41573479771614075 0.4077466130256653 -0.08110586553812027 -0.2777850925922394 0.346760094165802 -0.06897486001253128 0.3535533845424652 0.346760094165802 -0.06897486001253128 -0.3535533845424652 0.4077466130256653 -0.08110586553812027 0.2777850925922394 0.2724476754665375 -0.05419318377971649 -0.41573482751846313 0.45306387543678284 -0.09011995047330856 0.19134171307086945 0.18766526877880096 -0.03732891008257866 -0.46193981170654297 0.4809699058532715 -0.09567087888717651 0.09754517674446106 0.2566401958465576 -0.10630376636981964 0.41573479771614075 0.32664087414741516 -0.13529902696609497 0.3535533845424652 0.32664087414741516 -0.13529902696609497 -0.3535533845424652 0.3840888738632202 -0.15909482538700104 0.2777850925922394 0.25664010643959045 -0.10630375146865845 -0.41573482751846313 0.42677685618400574 -0.17677666246891022 0.19134171307086945 0.17677681148052216 -0.0732232928276062 -0.46193981170654297 0.4530637264251709 -0.18766513466835022 0.09754517674446106 0.09012012183666229 -0.03732891008257866 -0.49039265513420105 0.46193990111351013 -0.19134178757667542 3.774895063202166e-08 0.09012021869421005 -0.03732895478606224 0.49039262533187866 0.4530637264251709 -0.18766513466835022 -0.09754510223865509 0.17677687108516693 -0.0732233002781868 0.4619397521018982 0.42677685618400574 -0.17677666246891022 -0.19134163856506348 0.3840888738632202 -0.15909482538700104 -0.2777850925922394 0.4157349169254303 -0.27778518199920654 3.774895063202166e-08 0.08110606670379639 -0.05419323593378067 0.49039262533187866 0.08110597729682922 -0.054193172603845596 -0.49039265513420105 0.4077465832233429 -0.27244752645492554 -0.09754510223865509 0.15909498929977417 -0.10630375891923904 0.4619397521018982 0.38408902287483215 -0.2566399574279785 -0.19134163856506348 0.2309700846672058 -0.15432915091514587 0.41573479771614075 0.3456708490848541 -0.2309698462486267 -0.2777850925922394 0.2939690351486206 -0.19642373919487 0.3535533845424652 0.2939690351486206 -0.19642373919487 -0.3535533845424652 0.3456708490848541 -0.2309698462486267 0.2777850925922394 0.23096999526023865 -0.1543291211128235 -0.41573482751846313 0.38408902287483215 -0.2566399574279785 0.19134171307086945 0.1590949296951294 -0.10630373656749725 -0.46193981170654297 0.4077465832233429 -0.27244752645492554 0.09754517674446106 0.25000011920928955 -0.25 -0.3535533845424652 0.25000011920928955 -0.25 0.3535533845424652 0.29396888613700867 -0.2939688265323639 0.2777850925922394 0.19642384350299835 -0.1964237093925476 -0.41573482751846313 0.32664087414741516 -0.32664069533348083 0.19134171307086945 0.13529913127422333 -0.13529899716377258 -0.46193981170654297 0.34675994515419006 -0.3467598855495453 0.09754517674446106 0.06897498667240143 -0.0689748227596283 -0.49039265513420105 0.3535534739494324 -0.35355344414711 3.774895063202166e-08 0.0689750611782074 -0.06897490471601486 0.49039262533187866 0.34675994515419006 -0.3467598855495453 -0.09754510223865509 0.1352991759777069 -0.13529902696609497 0.4619397521018982 0.32664087414741516 -0.32664069533348083 -0.19134163856506348 0.19642393290996552 -0.1964237540960312 0.41573479771614075 0.29396888613700867 -0.2939688265323639 -0.2777850925922394 0.05419332906603813 -0.08110581338405609 -0.49039265513420105 0.27244752645492554 -0.40774646401405334 -0.09754510223865509 0.10630390048027039 -0.15909482538700104 0.4619397521018982 0.25664013624191284 -0.3840888440608978 -0.19134163856506348 0.154329314827919 -0.2309698909521103 0.41573479771614075 0.2309698909521103 -0.34567075967788696 -0.2777850925922394 0.19642385840415955 -0.29396888613700867 0.3535533845424652 0.19642385840415955 -0.29396888613700867 -0.3535533845424652 0.2309698909521103 -0.34567075967788696 0.2777850925922394 0.15432924032211304 -0.2309698462486267 -0.41573482751846313 0.25664013624191284 -0.3840888440608978 0.19134171307086945 0.1063038557767868 -0.15909478068351746 -0.46193981170654297 0.27244752645492554 -0.40774646401405334 0.09754517674446106 0.27778518199920654 -0.41573482751846313 3.774895063202166e-08 0.05419338867068291 -0.08110590279102325 0.49039262533187866 0.106303870677948 -0.25663992762565613 -0.41573482751846313 0.17677685618400574 -0.4267766773700714 0.19134171307086945 0.07322340458631516 -0.17677663266658783 -0.46193981170654297 0.18766511976718903 -0.45306357741355896 0.09754517674446106 0.0373290590941906 -0.09011994302272797 -0.49039265513420105 0.19134177267551422 -0.4619397521018982 3.774895063202166e-08 0.03732910379767418 -0.09012004733085632 0.49039262533187866 0.18766511976718903 -0.45306357741355896 -0.09754510223865509 0.07322343438863754 -0.1767766773700714 0.4619397521018982 0.17677685618400574 -0.4267766773700714 -0.19134163856506348 0.10630391538143158 -0.2566399872303009 0.41573479771614075 0.15909484028816223 -0.3840887248516083 -0.2777850925922394 0.13529913127422333 -0.3266407251358032 0.3535533845424652 0.13529913127422333 -0.3266407251358032 -0.3535533845424652 0.15909484028816223 -0.3840887248516083 0.2777850925922394 0.019030287861824036 -0.09567093104124069 0.49039262533187866 0.03732905164361 -0.18766510486602783 0.4619397521018982 0.09012013673782349 -0.4530636966228485 -0.19134163856506348 0.05419333279132843 -0.2724475562572479 0.41573479771614075 0.08110587298870087 -0.40774640440940857 -0.2777850925922394 0.06897494196891785 -0.34675994515419006 0.3535533845424652 0.06897494196891785 -0.34675994515419006 -0.3535533845424652 0.08110587298870087 -0.40774640440940857 0.2777850925922394 0.05419331043958664 -0.27244749665260315 -0.41573482751846313 0.09012013673782349 -0.4530636966228485 0.19134171307086945 0.03732902929186821 -0.18766506016254425 -0.46193981170654297 0.09567087143659592 -0.48096969723701477 0.09754517674446106 0.019030267372727394 -0.09567081928253174 -0.49039265513420105 0.09754522144794464 -0.4903925955295563 3.774895063202166e-08 0.09567087143659592 -0.48096969723701477 -0.09754510223865509 1.595926732989028e-07 -0.4619397222995758 0.19134171307086945 1.297903509112075e-07 -0.2777850329875946 -0.41573482751846313 1.2606506061274558e-07 -0.19134162366390228 -0.46193981170654297 4.783396434504539e-08 -0.49039241671562195 0.09754517674446106 1.5773002814967185e-07 -0.09754512459039688 -0.49039265513420105 7.018570613581687e-08 -0.49999991059303284 3.774895063202166e-08 1.558673830004409e-07 -0.09754522889852524 0.49039262533187866 4.783396434504539e-08 -0.49039241671562195 -0.09754510223865509 1.4096622180659324e-07 -0.19134168326854706 0.4619397521018982 1.595926732989028e-07 -0.4619397222995758 -0.19134163856506348 1.4096622180659324e-07 -0.2777850925922394 0.41573479771614075 7.018570613581687e-08 -0.4157346189022064 -0.2777850925922394 9.253744792658836e-08 -0.3535533547401428 0.3535533845424652 9.253744792658836e-08 -0.3535533547401428 -0.3535533845424652 7.018570613581687e-08 -0.4157346189022064 0.2777850925922394 -0.09011981636285782 -0.4530636668205261 -0.19134163856506348 -0.05419304221868515 -0.27244752645492554 0.41573479771614075 -0.08110573142766953 -0.4077463448047638 -0.2777850925922394 -0.06897474825382233 -0.3467599153518677 0.3535533845424652 -0.06897474825382233 -0.3467599153518677 -0.3535533845424652 -0.08110573142766953 -0.4077463448047638 0.2777850925922394 -0.05419304221868515 -0.27244746685028076 -0.41573482751846313 -0.09011981636285782 -0.4530636668205261 0.19134171307086945 -0.037328772246837616 -0.18766504526138306 -0.46193981170654297 -0.09567076712846756 -0.4809696078300476 0.09754517674446106 -0.019029950723052025 -0.09567081928253174 -0.49039265513420105 -0.0975450798869133 -0.4903925061225891 3.774895063202166e-08 -0.019029973074793816 -0.0956709235906601 0.49039262533187866 -0.09567076712846756 -0.4809696078300476 -0.09754510223865509 -0.03732876852154732 -0.18766510486602783 0.4619397521018982 -0.10630360245704651 -0.25663986802101135 -0.41573482751846313 -0.07322314381599426 -0.17677660286426544 -0.46193981170654297 -0.17677652835845947 -0.426776647567749 0.19134171307086945 -0.18766498565673828 -0.453063428401947 0.09754517674446106 -0.03732874244451523 -0.09011994302272797 -0.49039265513420105 -0.1913416087627411 -0.46193960309028625 3.774895063202166e-08 -0.03732878342270851 -0.09012003988027573 0.49039262533187866 -0.18766498565673828 -0.453063428401947 -0.09754510223865509 -0.07322315126657486 -0.17677666246891022 0.4619397521018982 -0.17677652835845947 -0.426776647567749 -0.19134163856506348 -0.1063036173582077 -0.25663992762565613 0.41573479771614075 -0.1590946763753891 -0.3840886354446411 -0.2777850925922394 -0.1352989226579666 -0.32664066553115845 0.3535533845424652 -0.1352989226579666 -0.32664066553115845 -0.3535533845424652 -0.1590946763753891 -0.3840886354446411 0.2777850925922394 -0.10630360245704651 -0.15909478068351746 0.4619397521018982 -0.15432898700237274 -0.23096981644630432 0.41573479771614075 -0.2566398084163666 -0.38408881425857544 -0.19134163856506348 -0.23096969723701477 -0.345670610666275 -0.2777850925922394 -0.19642361998558044 -0.2939688265323639 0.3535533845424652 -0.19642361998558044 -0.2939688265323639 -0.3535533845424652 -0.23096969723701477 -0.345670610666275 0.2777850925922394 -0.15432895720005035 -0.23096975684165955 -0.41573482751846313 -0.2566398084163666 -0.38408881425857544 0.19134171307086945 -0.10630358010530472 -0.15909472107887268 -0.46193981170654297 -0.2724473476409912 -0.407746285200119 0.09754517674446106 -0.05419300124049187 -0.0811058059334755 -0.49039265513420105 -0.27778497338294983 -0.4157346189022064 3.774895063202166e-08 -0.05419306457042694 -0.08110588788986206 0.49039262533187866 -0.2724473476409912 -0.407746285200119 -0.09754510223865509 -0.3266405463218689 -0.32664069533348083 0.19134171307086945 -0.3467596769332886 -0.3467596769332886 0.09754517674446106 -0.06897465884685516 -0.0689748153090477 -0.49039265513420105 -0.3535532057285309 -0.3535531759262085 3.774895063202166e-08 -0.06897473335266113 -0.06897488236427307 0.49039262533187866 -0.3467596769332886 -0.3467596769332886 -0.09754510223865509 -0.13529884815216064 -0.1352989673614502 0.4619397521018982 -0.3266405463218689 -0.32664069533348083 -0.19134163856506348 -0.19642357528209686 -0.19642366468906403 0.41573479771614075 -0.29396867752075195 -0.29396864771842957 -0.2777850925922394 -0.24999986588954926 -0.24999992549419403 0.3535533845424652 -0.24999986588954926 -0.24999992549419403 -0.3535533845424652 -0.29396867752075195 -0.29396864771842957 0.2777850925922394 -0.19642353057861328 -0.19642361998558044 -0.41573482751846313 -0.13529881834983826 -0.1352989375591278 -0.46193981170654297 -0.3840886652469635 -0.25663992762565613 -0.19134163856506348 -0.34567058086395264 -0.2309696525335312 -0.2777850925922394 -0.29396873712539673 -0.19642364978790283 0.3535533845424652 -0.29396873712539673 -0.19642364978790283 -0.3535533845424652 -0.34567058086395264 -0.2309696525335312 0.2777850925922394 -0.2309696525335312 -0.15432903170585632 -0.41573482751846313 -0.3840886652469635 -0.25663992762565613 0.19134171307086945 -0.15909460186958313 -0.10630368441343307 -0.46193981170654297 -0.40774622559547424 -0.27244728803634644 0.09754517674446106 -0.08110564947128296 -0.0541931614279747 -0.49039265513420105 -0.41573455929756165 -0.27778491377830505 3.774895063202166e-08 -0.08110573142766953 -0.05419321358203888 0.49039262533187866 -0.40774622559547424 -0.27244728803634644 -0.09754510223865509 -0.15909463167190552 -0.10630370676517487 0.4619397521018982 -0.23096969723701477 -0.1543290615081787 0.41573479771614075 -0.09011978656053543 -0.037328895181417465 -0.49039265513420105 -0.4619394540786743 -0.19134151935577393 3.774895063202166e-08 -0.09011988341808319 -0.03732892870903015 0.49039262533187866 -0.45306330919265747 -0.18766489624977112 -0.09754510223865509 -0.17677649855613708 -0.07322325557470322 0.4619397521018982 -0.4267764687538147 -0.17677664756774902 -0.19134163856506348 -0.2566397786140442 -0.10630369186401367 0.41573479771614075 -0.38408854603767395 -0.15909460186958313 -0.2777850925922394 -0.3266405761241913 -0.1352989375591278 0.3535533845424652 -0.3266405761241913 -0.1352989375591278 -0.3535533845424652 -0.38408854603767395 -0.15909460186958313 0.2777850925922394 -0.2566397190093994 -0.10630366206169128 -0.41573482751846313 -0.4267764687538147 -0.17677664756774902 0.19134171307086945 -0.1767764687538147 -0.07322324067354202 -0.46193981170654297 -0.45306330919265747 -0.18766489624977112 0.09754517674446106 -0.34675976634025574 -0.06897476315498352 -0.3535533845424652 -0.34675976634025574 -0.06897476315498352 0.3535533845424652 -0.40774619579315186 -0.08110565692186356 0.2777850925922394 -0.27244725823402405 -0.054193101823329926 -0.41573482751846313 -0.4530634880065918 -0.09011993557214737 0.19134171307086945 -0.18766489624977112 -0.03732886165380478 -0.46193981170654297 -0.4809694290161133 -0.0956706702709198 0.09754517674446106 -0.0956706628203392 -0.019030101597309113 -0.49039265513420105 -0.49039226770401 -0.09754499047994614 3.774895063202166e-08 -0.09567075967788696 -0.019030112773180008 0.49039262533187866 -0.4809694290161133 -0.0956706702709198 -0.09754510223865509 -0.1876649260520935 -0.037328869104385376 0.4619397521018982 -0.4530634880065918 -0.09011993557214737 -0.19134163856506348 -0.2724473178386688 -0.05419312044978142 0.41573479771614075 -0.40774619579315186 -0.08110565692186356 -0.2777850925922394</float_array>
-				<technique_common>
-				<accessor source="#id-mesh-4-positions-array" count="482" stride="3">
-					<param name="X" type="float"/>
-					<param name="Y" type="float"/>
-					<param name="Z" type="float"/>
-				</accessor>
-				</technique_common>
-			</source>
-			<source id="id-mesh-4-normals">
-				<float_array id="id-mesh-4-normals-array" count="1446"> -0.9809869527816772 0.0 0.19391460716724396 -0.9807733297348022 0.19507431983947754 0.0 -1.0 0.0 0.0 -0.20096439123153687 0.0 0.9795831441879272 0.0 0.0 1.0 -0.19708853960037231 0.039185766130685806 0.9795831441879272 0.0 0.0 -1.0 -0.20096439123153687 0.0 -0.9795831441879272 -0.19708853960037231 0.039185766130685806 -0.9795831441879272 -0.9621570706367493 0.191381573677063 -0.19391460716724396 -0.9809869527816772 0.0 -0.19391460716724396 -0.3804132342338562 0.07565538585186005 0.921689510345459 -0.3878597319126129 0.0 0.921689510345459 -0.9247413277626038 0.0 -0.3805353045463562 -0.9069795608520508 0.18039490282535553 -0.3805353045463562 -0.5597705245018005 0.0 0.8286385536193848 -0.5489974617958069 0.10919522494077682 0.8286385536193848 -0.8173161745071411 0.16257210075855255 -0.5527512431144714 -0.8333384394645691 0.0 -0.5527512431144714 -0.6964934468269348 0.13852351903915405 0.7040314674377441 -0.7101352214813232 0.0 0.7040314674377441 -0.7101352214813232 0.0 -0.7040314674377441 -0.6964934468269348 0.13852351903915405 -0.7040314674377441 -0.8173161745071411 0.16257210075855255 0.5527512431144714 -0.8333384394645691 0.0 0.5527512431144714 -0.5489974617958069 0.10919522494077682 -0.8286385536193848 -0.5597705245018005 0.0 -0.8286385536193848 -0.9069795608520508 0.18039490282535553 0.3805353045463562 -0.9247413277626038 0.0 0.3805353045463562 -0.3804132342338562 0.07565538585186005 -0.921689510345459 -0.3878597319126129 0.0 -0.921689510345459 -0.9621570706367493 0.191381573677063 0.19391460716724396 -0.3583483397960663 0.14841151237487793 -0.921689510345459 -0.9063386917114258 0.3754081726074219 0.19391460716724396 -0.18564409017562866 0.07690664380788803 -0.9795831441879272 -0.9238563179969788 0.382671594619751 0.0 -0.18564409017562866 0.07690664380788803 0.9795831441879272 -0.9063386917114258 0.3754081726074219 -0.19391460716724396 -0.3583483397960663 0.14841151237487793 0.921689510345459 -0.8543656468391418 0.35389262437820435 -0.3805353045463562 -0.5171361565589905 0.2142094224691391 0.8286385536193848 -0.7698904275894165 0.3188879191875458 -0.5527512431144714 -0.6560564041137695 0.2717368006706238 0.7040314674377441 -0.6560564041137695 0.2717368006706238 -0.7040314674377441 -0.7698904275894165 0.3188879191875458 0.5527512431144714 -0.5171361565589905 0.2142094224691391 -0.8286385536193848 -0.8543656468391418 0.35386210680007935 0.3805353045463562 -0.7689138650894165 0.5137485861778259 -0.3805353045463562 -0.6928922533988953 0.46296578645706177 -0.5527512431144714 -0.5904415845870972 0.39451277256011963 0.7040314674377441 -0.5904415845870972 0.39451277256011963 -0.7040314674377441 -0.6928922533988953 0.46296578645706177 0.5527512431144714 -0.46540728211402893 0.3109835982322693 -0.8286385536193848 -0.7689138650894165 0.5137485861778259 0.3805353045463562 -0.32248908281326294 0.2154911905527115 -0.921689510345459 -0.8156682252883911 0.5449995398521423 0.19391460716724396 -0.1670888364315033 0.1116367056965828 -0.9795831441879272 -0.8314462900161743 0.5555589199066162 0.0 -0.1670888364315033 0.1116367056965828 0.9795831441879272 -0.8156682252883911 0.5449995398521423 -0.19391460716724396 -0.32248908281326294 0.2154911905527115 0.921689510345459 -0.46540728211402893 0.3109835982322693 0.8286385536193848 -0.1420941799879074 0.1420941799879074 -0.9795831441879272 -0.6936551928520203 0.6936551928520203 0.19391460716724396 -0.7070833444595337 0.7070833444595337 0.0 -0.1420941799879074 0.1420941799879074 0.9795831441879272 -0.6936551928520203 0.6936551928520203 -0.19391460716724396 -0.27426984906196594 0.27426984906196594 0.921689510345459 -0.6538895964622498 0.6538895964622498 -0.3805353045463562 -0.395794540643692 0.395794540643692 0.8286385536193848 -0.5892513990402222 0.5892513990402222 -0.5527512431144714 -0.5021210312843323 0.5021210312843323 0.7040314674377441 -0.5021210312843323 0.5021210312843323 -0.7040314674377441 -0.5892513990402222 0.5892513990402222 0.5527512431144714 -0.395794540643692 0.395794540643692 -0.8286385536193848 -0.6538895964622498 0.6538895964622498 0.3805353045463562 -0.27426984906196594 0.27426984906196594 -0.921689510345459 -0.39451277256011963 0.5904415845870972 0.7040314674377441 -0.39451277256011963 0.5904415845870972 -0.7040314674377441 -0.46296578645706177 0.6928922533988953 0.5527512431144714 -0.3109835982322693 0.46540728211402893 -0.8286385536193848 -0.5137485861778259 0.7689138650894165 0.3805353045463562 -0.2154911905527115 0.32248908281326294 -0.921689510345459 -0.5449995398521423 0.8156682252883911 0.19391460716724396 -0.1116367056965828 0.1670888364315033 -0.9795831441879272 -0.5555589199066162 0.8314462900161743 0.0 -0.1116367056965828 0.1670888364315033 0.9795831441879272 -0.5449995398521423 0.8156682252883911 -0.19391460716724396 -0.2154911905527115 0.32248908281326294 0.921689510345459 -0.5137485861778259 0.7689138650894165 -0.3805353045463562 -0.3109835982322693 0.46540728211402893 0.8286385536193848 -0.46296578645706177 0.6928922533988953 -0.5527512431144714 -0.382671594619751 0.9238563179969788 0.0 -0.07690664380788803 0.18564409017562866 0.9795831441879272 -0.07690664380788803 0.18564409017562866 -0.9795831441879272 -0.3754081726074219 0.9063386917114258 -0.19391460716724396 -0.14841151237487793 0.3583483397960663 0.921689510345459 -0.35386210680007935 0.8543656468391418 -0.3805353045463562 -0.2142094224691391 0.5171361565589905 0.8286385536193848 -0.3188879191875458 0.7698904275894165 -0.5527512431144714 -0.2717368006706238 0.6560564041137695 0.7040314674377441 -0.2717368006706238 0.6560564041137695 -0.7040314674377441 -0.3188879191875458 0.7698904275894165 0.5527512431144714 -0.2142094224691391 0.5171361565589905 -0.8286385536193848 -0.35386210680007935 0.8543656468391418 0.3805353045463562 -0.14841151237487793 0.3583483397960663 -0.921689510345459 -0.3754081726074219 0.9063386917114258 0.19391460716724396 -0.16257210075855255 0.8173161745071411 -0.5527512431144714 -0.13852351903915405 0.6964934468269348 -0.7040314674377441 -0.16257210075855255 0.8173161745071411 0.5527512431144714 -0.10919522494077682 0.5489974617958069 -0.8286385536193848 -0.18039490282535553 0.9069795608520508 0.3805353045463562 -0.07565538585186005 0.3804132342338562 -0.921689510345459 -0.191381573677063 0.9621570706367493 0.19391460716724396 -0.039185766130685806 0.19708853960037231 -0.9795831441879272 -0.19507431983947754 0.9807733297348022 0.0 -0.039185766130685806 0.19708853960037231 0.9795831441879272 -0.191381573677063 0.9621570706367493 -0.19391460716724396 -0.07565538585186005 0.3804132342338562 0.921689510345459 -0.18039490282535553 0.9069795608520508 -0.3805353045463562 -0.10919522494077682 0.5489974617958069 0.8286385536193848 -0.13852351903915405 0.6964934468269348 0.7040314674377441 0.0 0.20096439123153687 0.9795831441879272 0.0 0.20096439123153687 -0.9795831441879272 0.0 1.0 0.0 0.0 0.9809869527816772 -0.19391460716724396 0.0 0.3878597319126129 0.921689510345459 0.0 0.9247413277626038 -0.3805353045463562 0.0 0.5597705245018005 0.8286385536193848 0.0 0.8333384394645691 -0.5527512431144714 0.0 0.7101352214813232 0.7040314674377441 0.0 0.7101352214813232 -0.7040314674377441 0.0 0.8333384394645691 0.5527512431144714 0.0 0.5597705245018005 -0.8286385536193848 0.0 0.9247413277626038 0.3805353045463562 0.0 0.3878597319126129 -0.921689510345459 0.0 0.9809869527816772 0.19391460716724396 0.13852351903915405 0.6964934468269348 0.7040314674377441 0.16257210075855255 0.8173161745071411 0.5527512431144714 0.13852351903915405 0.6964934468269348 -0.7040314674377441 0.10919522494077682 0.5489974617958069 -0.8286385536193848 0.18039490282535553 0.9069795608520508 0.3805353045463562 0.07565538585186005 0.3804132342338562 -0.921689510345459 0.191381573677063 0.9621570706367493 0.19391460716724396 0.039185766130685806 0.19708853960037231 -0.9795831441879272 0.19507431983947754 0.9807733297348022 0.0 0.039185766130685806 0.19708853960037231 0.9795831441879272 0.191381573677063 0.9621570706367493 -0.19391460716724396 0.07565538585186005 0.3804132342338562 0.921689510345459 0.18039490282535553 0.9069795608520508 -0.3805353045463562 0.10919522494077682 0.5489974617958069 0.8286385536193848 0.16257210075855255 0.8173161745071411 -0.5527512431144714 0.3754081726074219 0.9063386917114258 -0.19391460716724396 0.14841151237487793 0.3583483397960663 0.921689510345459 0.35386210680007935 0.8543656468391418 -0.3805353045463562 0.2142094224691391 0.5171361565589905 0.8286385536193848 0.3188879191875458 0.7698904275894165 -0.5527512431144714 0.2717368006706238 0.6560564041137695 0.7040314674377441 0.2717368006706238 0.6560564041137695 -0.7040314674377441 0.3188879191875458 0.7698904275894165 0.5527512431144714 0.2142094224691391 0.5171361565589905 -0.8286385536193848 0.35386210680007935 0.8543656468391418 0.3805353045463562 0.14841151237487793 0.3583483397960663 -0.921689510345459 0.3754081726074219 0.9063386917114258 0.19391460716724396 0.07690664380788803 0.18564409017562866 -0.9795831441879272 0.382671594619751 0.9238563179969788 0.0 0.07690664380788803 0.18564409017562866 0.9795831441879272 0.39451277256011963 0.5904415845870972 -0.7040314674377441 0.3109835982322693 0.46540728211402893 -0.8286385536193848 0.5137485861778259 0.7689138650894165 0.3805353045463562 0.2154911905527115 0.32248908281326294 -0.921689510345459 0.5449995398521423 0.8156682252883911 0.19391460716724396 0.1116367056965828 0.1670888364315033 -0.9795831441879272 0.5555589199066162 0.8314462900161743 0.0 0.1116367056965828 0.1670888364315033 0.9795831441879272 0.5449995398521423 0.8156682252883911 -0.19391460716724396 0.2154911905527115 0.32248908281326294 0.921689510345459 0.5137485861778259 0.7689138650894165 -0.3805353045463562 0.3109835982322693 0.46540728211402893 0.8286385536193848 0.46296578645706177 0.6928922533988953 -0.5527512431144714 0.39451277256011963 0.5904415845870972 0.7040314674377441 0.46296578645706177 0.6928922533988953 0.5527512431144714 0.6538895964622498 0.6538895964622498 -0.3805353045463562 0.395794540643692 0.395794540643692 0.8286385536193848 0.5892513990402222 0.5892513990402222 -0.5527512431144714 0.5021210312843323 0.5021210312843323 0.7040314674377441 0.5021210312843323 0.5021210312843323 -0.7040314674377441 0.5892513990402222 0.5892513990402222 0.5527512431144714 0.395794540643692 0.395794540643692 -0.8286385536193848 0.6538895964622498 0.6538895964622498 0.3805353045463562 0.27426984906196594 0.27426984906196594 -0.921689510345459 0.6936551928520203 0.6936551928520203 0.19391460716724396 0.1420941799879074 0.1420941799879074 -0.9795831441879272 0.7070833444595337 0.7070833444595337 0.0 0.1420941799879074 0.1420941799879074 0.9795831441879272 0.6936551928520203 0.6936551928520203 -0.19391460716724396 0.27426984906196594 0.27426984906196594 0.921689510345459 0.32248908281326294 0.2154911905527115 -0.921689510345459 0.7689138650894165 0.5137485861778259 0.3805353045463562 0.8156682252883911 0.5449995398521423 0.19391460716724396 0.1670888364315033 0.1116367056965828 -0.9795831441879272 0.8314462900161743 0.5555589199066162 0.0 0.1670888364315033 0.1116367056965828 0.9795831441879272 0.8156682252883911 0.5449995398521423 -0.19391460716724396 0.32248908281326294 0.2154911905527115 0.921689510345459 0.7689138650894165 0.5137485861778259 -0.3805353045463562 0.46540728211402893 0.3109835982322693 0.8286385536193848 0.6928922533988953 0.46296578645706177 -0.5527512431144714 0.5904415845870972 0.39451277256011963 0.7040314674377441 0.5904415845870972 0.39451277256011963 -0.7040314674377441 0.6928922533988953 0.46296578645706177 0.5527512431144714 0.46540728211402893 0.3109835982322693 -0.8286385536193848 0.3583483397960663 0.14841151237487793 0.921689510345459 0.5171361565589905 0.2142094224691391 0.8286385536193848 0.8543656468391418 0.35386210680007935 -0.3805353045463562 0.7698904275894165 0.3188879191875458 -0.5527512431144714 0.6560564041137695 0.2717368006706238 0.7040314674377441 0.6560564041137695 0.2717368006706238 -0.7040314674377441 0.7698904275894165 0.3188879191875458 0.5527512431144714 0.5171361565589905 0.2142094224691391 -0.8286385536193848 0.8543656468391418 0.35386210680007935 0.3805353045463562 0.3583483397960663 0.14841151237487793 -0.921689510345459 0.9063386917114258 0.3754081726074219 0.19391460716724396 0.18564409017562866 0.07690664380788803 -0.9795831441879272 0.9238563179969788 0.382671594619751 0.0 0.18564409017562866 0.07690664380788803 0.9795831441879272 0.9063386917114258 0.3754081726074219 -0.19391460716724396 0.9069795608520508 0.18039490282535553 0.3805353045463562 0.9621570706367493 0.191381573677063 0.19391460716724396 0.3804132342338562 0.07565538585186005 -0.921689510345459 0.19708853960037231 0.039185766130685806 -0.9795831441879272 0.9807733297348022 0.19507431983947754 0.0 0.19708853960037231 0.039185766130685806 0.9795831441879272 0.9621570706367493 0.191381573677063 -0.19391460716724396 0.3804132342338562 0.07565538585186005 0.921689510345459 0.9069795608520508 0.18039490282535553 -0.3805353045463562 0.5489974617958069 0.10919522494077682 0.8286385536193848 0.8173161745071411 0.16257210075855255 -0.5527512431144714 0.6964934468269348 0.13852351903915405 0.7040314674377441 0.6964934468269348 0.13852351903915405 -0.7040314674377441 0.8173161745071411 0.16257210075855255 0.5527512431144714 0.5489974617958069 0.10919522494077682 -0.8286385536193848 0.9247413277626038 0.0 -0.3805353045463562 0.8333384394645691 0.0 -0.5527512431144714 0.5597705245018005 0.0 0.8286385536193848 0.7101352214813232 0.0 0.7040314674377441 0.7101352214813232 0.0 -0.7040314674377441 0.8333384394645691 0.0 0.5527512431144714 0.5597705245018005 0.0 -0.8286385536193848 0.9247413277626038 0.0 0.3805353045463562 0.3878597319126129 0.0 -0.921689510345459 0.9809869527816772 0.0 0.19391460716724396 0.20096439123153687 0.0 -0.9795831441879272 1.0 0.0 0.0 0.20096439123153687 0.0 0.9795831441879272 0.9809869527816772 0.0 -0.19391460716724396 0.3878597319126129 0.0 0.921689510345459 0.19708853960037231 -0.039185766130685806 -0.9795831441879272 0.9807733297348022 -0.19507431983947754 0.0 0.19708853960037231 -0.039185766130685806 0.9795831441879272 0.9621570706367493 -0.191381573677063 -0.19391460716724396 0.3804132342338562 -0.07565538585186005 0.921689510345459 0.9069795608520508 -0.18039490282535553 -0.3805353045463562 0.5489974617958069 -0.10919522494077682 0.8286385536193848 0.8173161745071411 -0.16257210075855255 -0.5527512431144714 0.6964934468269348 -0.13852351903915405 0.7040314674377441 0.6964934468269348 -0.13852351903915405 -0.7040314674377441 0.8173161745071411 -0.16257210075855255 0.5527512431144714 0.5489974617958069 -0.10919522494077682 -0.8286385536193848 0.9069795608520508 -0.18039490282535553 0.3805353045463562 0.3804132342338562 -0.07565538585186005 -0.921689510345459 0.9621570706367493 -0.191381573677063 0.19391460716724396 0.5171361565589905 -0.2142094224691391 0.8286385536193848 0.6560564041137695 -0.2717368006706238 0.7040314674377441 0.6560564041137695 -0.2717368006706238 -0.7040314674377441 0.7698904275894165 -0.3188879191875458 0.5527512431144714 0.5171361565589905 -0.2142094224691391 -0.8286385536193848 0.8543656468391418 -0.35389262437820435 0.3805353045463562 0.3583483397960663 -0.14841151237487793 -0.921689510345459 0.9063386917114258 -0.3754081726074219 0.19391460716724396 0.18564409017562866 -0.07690664380788803 -0.9795831441879272 0.9238563179969788 -0.382671594619751 0.0 0.18564409017562866 -0.07690664380788803 0.9795831441879272 0.9063386917114258 -0.3754081726074219 -0.19391460716724396 0.3583483397960663 -0.14841151237487793 0.921689510345459 0.8543656468391418 -0.35386210680007935 -0.3805353045463562 0.7698904275894165 -0.3188879191875458 -0.5527512431144714 0.8314462900161743 -0.5555589199066162 0.0 0.1670888364315033 -0.1116367056965828 0.9795831441879272 0.1670888364315033 -0.1116367056965828 -0.9795831441879272 0.8156682252883911 -0.5449995398521423 -0.19391460716724396 0.32248908281326294 -0.2154911905527115 0.921689510345459 0.7689138650894165 -0.5137485861778259 -0.3805353045463562 0.46540728211402893 -0.3109835982322693 0.8286385536193848 0.6928922533988953 -0.46296578645706177 -0.5527512431144714 0.5904415845870972 -0.39451277256011963 0.7040314674377441 0.5904415845870972 -0.39451277256011963 -0.7040314674377441 0.6928922533988953 -0.46296578645706177 0.5527512431144714 0.46540728211402893 -0.3109835982322693 -0.8286385536193848 0.7689138650894165 -0.5137485861778259 0.3805353045463562 0.32248908281326294 -0.2154911905527115 -0.921689510345459 0.8156682252883911 -0.5449995398521423 0.19391460716724396 0.5021210312843323 -0.5021210312843323 -0.7040314674377441 0.5021210312843323 -0.5021210312843323 0.7040314674377441 0.5892513990402222 -0.5892513990402222 0.5527512431144714 0.395794540643692 -0.395794540643692 -0.8286385536193848 0.6538895964622498 -0.6538895964622498 0.3805353045463562 0.27426984906196594 -0.27426984906196594 -0.921689510345459 0.6936551928520203 -0.6936551928520203 0.19391460716724396 0.1420941799879074 -0.1420941799879074 -0.9795831441879272 0.7070833444595337 -0.7070833444595337 0.0 0.1420941799879074 -0.1420941799879074 0.9795831441879272 0.6936551928520203 -0.6936551928520203 -0.19391460716724396 0.27426984906196594 -0.27426984906196594 0.921689510345459 0.6538895964622498 -0.6538895964622498 -0.3805353045463562 0.395794540643692 -0.395794540643692 0.8286385536193848 0.5892513990402222 -0.5892513990402222 -0.5527512431144714 0.1116367056965828 -0.1670888364315033 -0.9795831441879272 0.5449995398521423 -0.8156682252883911 -0.19391460716724396 0.2154911905527115 -0.32248908281326294 0.921689510345459 0.5137485861778259 -0.7689138650894165 -0.3805353045463562 0.3109835982322693 -0.46540728211402893 0.8286385536193848 0.46296578645706177 -0.6928922533988953 -0.5527512431144714 0.39451277256011963 -0.5904415845870972 0.7040314674377441 0.39451277256011963 -0.5904415845870972 -0.7040314674377441 0.46296578645706177 -0.6928922533988953 0.5527512431144714 0.3109835982322693 -0.46540728211402893 -0.8286385536193848 0.5137485861778259 -0.7689138650894165 0.3805353045463562 0.2154911905527115 -0.32248908281326294 -0.921689510345459 0.5449995398521423 -0.8156682252883911 0.19391460716724396 0.5555589199066162 -0.8314462900161743 0.0 0.1116367056965828 -0.1670888364315033 0.9795831441879272 0.2142094224691391 -0.5171361565589905 -0.8286385536193848 0.35386210680007935 -0.8543656468391418 0.3805353045463562 0.14841151237487793 -0.3583483397960663 -0.921689510345459 0.3754081726074219 -0.9063386917114258 0.19391460716724396 0.07690664380788803 -0.18564409017562866 -0.9795831441879272 0.382671594619751 -0.9238563179969788 0.0 0.07687612622976303 -0.18564409017562866 0.9795831441879272 0.3754081726074219 -0.9063386917114258 -0.19391460716724396 0.14841151237487793 -0.3583483397960663 0.921689510345459 0.35386210680007935 -0.8543656468391418 -0.3805353045463562 0.2142094224691391 -0.5171361565589905 0.8286385536193848 0.3188879191875458 -0.7698904275894165 -0.5527512431144714 0.2717368006706238 -0.6560564041137695 0.7040314674377441 0.2717368006706238 -0.6560564041137695 -0.7040314674377441 0.3188879191875458 -0.7698904275894165 0.5527512431144714 0.039185766130685806 -0.19708853960037231 0.9795831441879272 0.07565538585186005 -0.3804132342338562 0.921689510345459 0.18039490282535553 -0.9069795608520508 -0.3805353045463562 0.10919522494077682 -0.5489974617958069 0.8286385536193848 0.16257210075855255 -0.8173161745071411 -0.5527512431144714 0.13852351903915405 -0.6964934468269348 0.7040314674377441 0.13852351903915405 -0.6964934468269348 -0.7040314674377441 0.16257210075855255 -0.8173161745071411 0.5527512431144714 0.10919522494077682 -0.5489974617958069 -0.8286385536193848 0.18039490282535553 -0.9069795608520508 0.3805353045463562 0.07565538585186005 -0.3804132342338562 -0.921689510345459 0.191381573677063 -0.9621570706367493 0.19391460716724396 0.039185766130685806 -0.19708853960037231 -0.9795831441879272 0.19507431983947754 -0.9807733297348022 0.0 0.191381573677063 -0.9621570706367493 -0.19391460716724396 0.0 -0.9247413277626038 0.3805353045463562 0.0 -0.5597705245018005 -0.8286385536193848 0.0 -0.3878597319126129 -0.921689510345459 0.0 -0.9809869527816772 0.19391460716724396 0.0 -0.20096439123153687 -0.9795831441879272 0.0 -1.0 0.0 0.0 -0.20096439123153687 0.9795831441879272 0.0 -0.9809869527816772 -0.19391460716724396 0.0 -0.3878597319126129 0.921689510345459 0.0 -0.9247413277626038 -0.3805353045463562 0.0 -0.5597705245018005 0.8286385536193848 0.0 -0.8333384394645691 -0.5527512431144714 0.0 -0.7101352214813232 0.7040314674377441 0.0 -0.7101352214813232 -0.7040314674377441 0.0 -0.8333384394645691 0.5527512431144714 -0.18039490282535553 -0.9069795608520508 -0.3805353045463562 -0.10919522494077682 -0.5489974617958069 0.8286385536193848 -0.16257210075855255 -0.8173161745071411 -0.5527512431144714 -0.13852351903915405 -0.6964934468269348 0.7040314674377441 -0.13852351903915405 -0.6964934468269348 -0.7040314674377441 -0.16257210075855255 -0.8173161745071411 0.5527512431144714 -0.10919522494077682 -0.5489974617958069 -0.8286385536193848 -0.18039490282535553 -0.9069795608520508 0.3805353045463562 -0.07565538585186005 -0.3804132342338562 -0.921689510345459 -0.191381573677063 -0.9621570706367493 0.19391460716724396 -0.039185766130685806 -0.19708853960037231 -0.9795831441879272 -0.19507431983947754 -0.9807733297348022 0.0 -0.039185766130685806 -0.19708853960037231 0.9795831441879272 -0.191381573677063 -0.9621570706367493 -0.19391460716724396 -0.07565538585186005 -0.3804132342338562 0.921689510345459 -0.2142094224691391 -0.5171361565589905 -0.8286385536193848 -0.14841151237487793 -0.3583483397960663 -0.921689510345459 -0.35389262437820435 -0.8543656468391418 0.3805353045463562 -0.3754081726074219 -0.9063386917114258 0.19391460716724396 -0.07690664380788803 -0.18564409017562866 -0.9795831441879272 -0.382671594619751 -0.9238563179969788 0.0 -0.07687612622976303 -0.18564409017562866 0.9795831441879272 -0.3754081726074219 -0.9063386917114258 -0.19391460716724396 -0.14841151237487793 -0.3583483397960663 0.921689510345459 -0.35386210680007935 -0.8543656468391418 -0.3805353045463562 -0.2142094224691391 -0.5171361565589905 0.8286385536193848 -0.3188879191875458 -0.7698904275894165 -0.5527512431144714 -0.2717368006706238 -0.6560564041137695 0.7040314674377441 -0.2717368006706238 -0.6560564041137695 -0.7040314674377441 -0.3188879191875458 -0.7698904275894165 0.5527512431144714 -0.2154911905527115 -0.32248908281326294 0.921689510345459 -0.3109835982322693 -0.46540728211402893 0.8286385536193848 -0.5137485861778259 -0.7689138650894165 -0.3805353045463562 -0.46296578645706177 -0.6928922533988953 -0.5527512431144714 -0.39451277256011963 -0.5904415845870972 0.7040314674377441 -0.39451277256011963 -0.5904415845870972 -0.7040314674377441 -0.46296578645706177 -0.6928922533988953 0.5527512431144714 -0.3109835982322693 -0.46540728211402893 -0.8286385536193848 -0.5137485861778259 -0.7689138650894165 0.3805353045463562 -0.2154911905527115 -0.32248908281326294 -0.921689510345459 -0.5449995398521423 -0.8156682252883911 0.19391460716724396 -0.1116367056965828 -0.1670888364315033 -0.9795831441879272 -0.5555589199066162 -0.8314462900161743 0.0 -0.1116367056965828 -0.1670888364315033 0.9795831441879272 -0.5449995398521423 -0.8156682252883911 -0.19391460716724396 -0.6538895964622498 -0.6538895964622498 0.3805353045463562 -0.6936551928520203 -0.6936551928520203 0.19391460716724396 -0.1420941799879074 -0.1420941799879074 -0.9795831441879272 -0.7070833444595337 -0.7070833444595337 0.0 -0.1420941799879074 -0.1420941799879074 0.9795831441879272 -0.6936551928520203 -0.6936551928520203 -0.19391460716724396 -0.27426984906196594 -0.27426984906196594 0.921689510345459 -0.6538895964622498 -0.6538895964622498 -0.3805353045463562 -0.395794540643692 -0.395794540643692 0.8286385536193848 -0.5892513990402222 -0.5892513990402222 -0.5527512431144714 -0.5021210312843323 -0.5021210312843323 0.7040314674377441 -0.5021210312843323 -0.5021210312843323 -0.7040314674377441 -0.5892513990402222 -0.5892513990402222 0.5527512431144714 -0.395794540643692 -0.395794540643692 -0.8286385536193848 -0.27426984906196594 -0.27426984906196594 -0.921689510345459 -0.7689138650894165 -0.5137485861778259 -0.3805353045463562 -0.6928922533988953 -0.46296578645706177 -0.5527512431144714 -0.5904415845870972 -0.39451277256011963 0.7040314674377441 -0.5904415845870972 -0.39451277256011963 -0.7040314674377441 -0.6928922533988953 -0.46296578645706177 0.5527512431144714 -0.46540728211402893 -0.3109835982322693 -0.8286385536193848 -0.7689138650894165 -0.5137485861778259 0.3805353045463562 -0.32248908281326294 -0.2154911905527115 -0.921689510345459 -0.8156682252883911 -0.5449995398521423 0.19391460716724396 -0.1670888364315033 -0.1116367056965828 -0.9795831441879272 -0.8314462900161743 -0.5555589199066162 0.0 -0.1670888364315033 -0.1116367056965828 0.9795831441879272 -0.8156682252883911 -0.5449995398521423 -0.19391460716724396 -0.32248908281326294 -0.2154911905527115 0.921689510345459 -0.46540728211402893 -0.3109835982322693 0.8286385536193848 -0.18564409017562866 -0.07690664380788803 -0.9795831441879272 -0.9238563179969788 -0.382671594619751 0.0 -0.18564409017562866 -0.07690664380788803 0.9795831441879272 -0.9063386917114258 -0.3754081726074219 -0.19391460716724396 -0.3583483397960663 -0.14841151237487793 0.921689510345459 -0.8543656468391418 -0.35386210680007935 -0.3805353045463562 -0.5171361565589905 -0.2142094224691391 0.8286385536193848 -0.7698904275894165 -0.3188879191875458 -0.5527512431144714 -0.6560564041137695 -0.2717368006706238 0.7040314674377441 -0.6560564041137695 -0.2717368006706238 -0.7040314674377441 -0.7698904275894165 -0.3188879191875458 0.5527512431144714 -0.5171361565589905 -0.2142094224691391 -0.8286385536193848 -0.8543656468391418 -0.35386210680007935 0.3805353045463562 -0.3583483397960663 -0.14841151237487793 -0.921689510345459 -0.9063386917114258 -0.3754081726074219 0.19391460716724396 -0.6964934468269348 -0.13852351903915405 -0.7040314674377441 -0.6964934468269348 -0.13852351903915405 0.7040314674377441 -0.8173161745071411 -0.16257210075855255 0.5527512431144714 -0.5489974617958069 -0.10919522494077682 -0.8286385536193848 -0.9069795608520508 -0.18039490282535553 0.3805353045463562 -0.3804132342338562 -0.07565538585186005 -0.921689510345459 -0.9621570706367493 -0.191381573677063 0.19391460716724396 -0.19708853960037231 -0.039185766130685806 -0.9795831441879272 -0.9807733297348022 -0.19507431983947754 0.0 -0.19708853960037231 -0.039185766130685806 0.9795831441879272 -0.9621570706367493 -0.191381573677063 -0.19391460716724396 -0.3804132342338562 -0.07565538585186005 0.921689510345459 -0.9069795608520508 -0.18039490282535553 -0.3805353045463562 -0.5489974617958069 -0.10919522494077682 0.8286385536193848 -0.8173161745071411 -0.16257210075855255 -0.5527512431144714</float_array>
-				<technique_common>
-				<accessor source="#id-mesh-4-normals-array" count="482" stride="3">
-					<param name="X" type="float"/>
-					<param name="Y" type="float"/>
-					<param name="Z" type="float"/>
-				</accessor>
-				</technique_common>
-			</source>
-			<vertices id="id-mesh-4-vertices">
-				<input semantic="POSITION" source="#id-mesh-4-positions"/>
-			</vertices>
-			<triangles count="960" material="id-trimat-5">
-				<input semantic="VERTEX" source="#id-mesh-4-vertices" offset="0"/>
-				<input semantic="NORMAL" source="#id-mesh-4-normals" offset="0"/>
-				<p> 0 1 2 3 4 5 6 7 8 2 9 10 3 11 12 13 9 14 15 11 16 13 17 18 15 19 20 21 17 22 20 23 24 21 25 26 24 27 28 26 29 30 28 31 0 30 8 7 25 32 29 27 33 31 29 34 8 31 35 1 5 4 36 6 8 34 9 35 37 5 38 11 14 37 39 11 40 16 14 41 17 16 42 19 22 41 43 19 44 23 22 45 25 23 46 27 41 47 48 40 49 42 43 48 50 42 51 44 43 52 45 44 53 46 45 54 32 33 53 55 32 56 34 33 57 35 36 4 58 6 34 56 35 59 37 36 60 38 37 47 39 38 61 40 54 62 56 57 63 64 58 4 65 6 56 62 57 66 59 58 67 60 59 68 47 60 69 61 48 68 70 61 71 49 48 72 50 49 73 51 50 74 52 51 75 53 52 76 54 53 63 55 69 77 71 70 78 72 73 77 79 74 78 80 73 81 75 76 80 82 75 83 63 76 84 62 64 83 85 65 4 86 6 62 84 64 87 66 65 88 67 66 89 68 67 90 69 70 89 91 83 92 85 86 4 93 6 84 94 85 95 87 86 96 88 87 97 89 88 98 90 91 97 99 90 100 77 78 99 101 79 100 102 78 103 80 79 104 81 82 103 105 83 104 106 82 94 84 101 107 108 100 109 102 101 110 103 102 111 104 103 112 105 106 111 113 94 112 114 106 115 92 93 4 116 6 94 114 92 117 95 93 118 96 95 119 97 96 120 98 99 119 107 100 120 121 116 4 122 6 114 123 117 124 125 116 126 118 117 127 119 118 128 120 107 127 129 120 130 121 107 131 108 121 132 109 110 131 133 109 134 111 112 133 135 113 134 136 114 135 123 113 124 115 132 137 138 133 139 140 132 141 134 133 142 135 136 141 143 123 142 144 136 145 124 122 4 146 6 123 144 124 147 125 126 146 148 125 149 127 126 150 128 129 149 151 128 137 130 129 139 131 145 152 147 146 153 148 147 154 149 150 153 155 151 154 156 150 157 137 151 158 139 137 159 138 139 160 140 138 161 141 142 160 162 143 161 163 142 164 144 143 165 145 146 4 166 6 144 164 160 167 168 159 169 161 160 170 162 163 169 171 162 172 164 163 173 165 166 4 174 6 164 172 152 173 175 166 176 153 152 177 154 153 178 155 156 177 179 155 180 157 156 167 158 159 180 181 175 182 177 176 183 178 177 184 179 178 185 180 179 186 167 180 187 181 168 186 188 181 189 169 168 190 170 171 189 191 172 190 192 171 193 173 174 4 194 6 172 192 173 195 175 174 196 176 188 197 190 191 198 199 192 197 200 191 201 193 194 4 202 6 192 200 195 201 203 194 204 196 195 205 182 196 206 183 184 205 207 185 206 208 184 209 186 187 208 210 188 209 211 187 198 189 206 212 213 207 214 215 206 216 208 207 217 209 208 218 210 211 217 219 210 220 198 211 221 197 199 220 222 197 223 200 199 224 201 202 4 225 6 200 223 201 226 203 202 212 204 203 214 205 222 227 228 223 229 230 222 231 224 225 4 232 6 223 230 224 233 226 225 234 212 226 235 214 212 236 213 215 235 237 213 238 216 215 239 217 216 240 218 217 241 219 218 227 220 219 229 221 237 242 243 238 244 245 237 246 239 238 247 240 241 246 248 240 249 227 241 250 229 228 249 251 230 250 252 228 253 231 232 4 254 6 230 252 231 255 233 232 256 234 233 242 235 236 256 244 250 257 252 251 258 253 254 4 259 6 252 257 253 260 255 254 261 256 255 262 242 256 263 244 243 262 264 245 263 265 243 266 246 247 265 267 246 268 248 247 269 249 248 270 250 251 269 271 265 272 273 264 274 266 267 273 275 266 276 268 267 277 269 270 276 278 271 277 279 257 278 280 271 281 258 259 4 282 6 257 280 260 281 283 259 284 261 260 285 262 261 272 263 264 285 286 279 287 281 282 4 288 6 280 289 281 290 283 282 291 284 283 292 285 284 293 272 286 292 294 272 295 273 286 296 274 275 295 297 276 296 298 275 299 277 276 300 278 279 299 301 280 300 289 294 302 296 297 303 304 296 305 298 297 306 299 298 307 300 301 306 308 300 309 289 287 308 310 288 4 311 6 289 309 287 312 290 288 313 291 290 314 292 291 315 293 294 314 316 295 315 303 6 309 317 310 318 312 311 319 313 312 320 314 313 321 315 316 320 322 303 321 323 316 324 302 304 323 325 302 326 305 304 327 306 307 326 328 308 327 329 307 317 309 308 330 310 311 4 331 324 332 326 325 333 327 328 332 334 329 333 335 317 334 336 329 337 330 331 4 338 6 317 336 330 339 318 331 340 319 318 341 320 319 342 321 322 341 343 323 342 344 324 343 345 325 344 346 340 347 348 339 349 341 340 350 342 343 349 351 344 350 352 343 353 345 346 352 354 345 355 332 346 356 333 334 355 357 335 356 358 334 359 336 335 360 337 338 4 347 6 336 359 337 361 339 354 362 356 357 363 364 358 362 365 357 366 359 358 367 360 347 4 368 6 359 366 361 367 369 348 368 370 361 371 349 348 372 350 351 371 373 352 372 374 351 375 353 352 376 354 355 375 363 369 377 371 370 378 372 373 377 379 374 378 380 373 381 375 376 380 382 375 383 363 376 384 362 364 383 385 365 384 386 364 387 366 365 388 367 368 4 389 6 366 387 369 388 390 370 389 391 385 392 393 386 394 395 385 396 387 386 397 388 389 4 398 6 387 396 388 399 390 389 400 391 390 401 377 391 402 378 379 401 403 380 402 404 379 405 381 380 406 382 381 392 383 382 394 384 402 407 408 403 409 410 404 408 411 403 412 405 406 411 413 405 414 392 406 415 394 393 414 416 395 415 417 393 418 396 395 419 397 398 4 420 6 396 418 399 419 421 398 407 400 399 409 401 417 422 423 416 424 418 417 425 419 420 4 426 6 418 424 421 425 427 420 428 407 421 429 409 407 430 408 410 429 431 408 432 411 410 433 412 413 432 434 412 435 414 413 422 415 414 436 416 431 437 438 430 439 432 431 440 433 434 439 441 435 440 442 434 443 422 435 444 436 423 443 445 436 446 424 425 445 447 426 4 448 6 424 446 425 449 427 426 450 428 427 437 429 428 451 430 444 452 446 445 453 447 448 4 454 6 446 452 447 455 449 450 454 456 449 457 437 451 456 458 438 457 459 439 458 460 438 461 440 441 460 462 440 463 442 441 464 443 442 465 444 445 464 466 459 467 461 462 468 469 461 470 463 462 471 464 463 472 465 466 471 473 452 472 474 466 475 453 454 4 476 6 452 474 453 477 455 454 478 456 455 479 457 456 480 458 459 479 481 458 468 460 476 4 3 6 474 7 475 10 477 478 3 12 477 13 479 480 12 15 479 18 481 468 15 20 481 21 467 469 20 24 467 26 470 471 24 28 470 30 472 473 28 0 472 7 474 475 0 2 0 31 1 2 1 9 3 5 11 13 10 9 15 12 11 13 14 17 15 16 19 21 18 17 20 19 23 21 22 25 24 23 27 26 25 29 28 27 31 30 29 8 25 45 32 27 46 33 29 32 34 31 33 35 9 1 35 5 36 38 14 9 37 11 38 40 14 39 41 16 40 42 22 17 41 19 42 44 22 43 45 23 44 46 41 39 47 40 61 49 43 41 48 42 49 51 43 50 52 44 51 53 45 52 54 33 46 53 32 54 56 33 55 57 35 57 59 36 58 60 37 59 47 38 60 61 54 76 62 57 55 63 57 64 66 58 65 67 59 66 68 60 67 69 48 47 68 61 69 71 48 70 72 49 71 73 50 72 74 51 73 75 52 74 76 53 75 63 69 90 77 70 91 78 73 71 77 74 72 78 73 79 81 76 74 80 75 81 83 76 82 84 64 63 83 64 85 87 65 86 88 66 87 89 67 88 90 70 68 89 83 106 92 85 92 95 86 93 96 87 95 97 88 96 98 91 89 97 90 98 100 78 91 99 79 77 100 78 101 103 79 102 104 82 80 103 83 81 104 82 105 94 101 99 107 100 121 109 101 108 110 102 109 111 103 110 112 106 104 111 94 105 112 106 113 115 92 115 117 93 116 118 95 117 119 96 118 120 99 97 119 100 98 120 117 115 124 116 122 126 117 125 127 118 126 128 107 119 127 120 128 130 107 129 131 121 130 132 110 108 131 109 132 134 112 110 133 113 111 134 114 112 135 113 136 124 132 130 137 133 131 139 132 138 141 133 140 142 136 134 141 123 135 142 136 143 145 124 145 147 126 122 146 125 147 149 126 148 150 129 127 149 128 150 137 129 151 139 145 165 152 146 166 153 147 152 154 150 148 153 151 149 154 150 155 157 151 156 158 137 157 159 139 158 160 138 159 161 142 140 160 143 141 161 142 162 164 143 163 165 160 158 167 159 181 169 160 168 170 163 161 169 162 170 172 163 171 173 152 165 173 166 174 176 152 175 177 153 176 178 156 154 177 155 178 180 156 179 167 159 157 180 175 195 182 176 196 183 177 182 184 178 183 185 179 184 186 180 185 187 168 167 186 181 187 189 168 188 190 171 169 189 172 170 190 171 191 193 173 193 195 174 194 196 188 211 197 191 189 198 192 190 197 191 199 201 195 193 201 194 202 204 195 203 205 196 204 206 184 182 205 185 183 206 184 207 209 187 185 208 188 186 209 187 210 198 206 204 212 207 205 214 206 213 216 207 215 217 208 216 218 211 209 217 210 218 220 211 219 221 199 198 220 197 221 223 199 222 224 201 224 226 202 225 212 203 226 214 222 220 227 223 221 229 222 228 231 224 231 233 225 232 234 226 233 235 212 234 236 215 214 235 213 236 238 215 237 239 216 238 240 217 239 241 218 240 227 219 241 229 237 235 242 238 236 244 237 243 246 238 245 247 241 239 246 240 247 249 241 248 250 228 227 249 230 229 250 228 251 253 231 253 255 232 254 256 233 255 242 236 234 256 250 270 257 251 271 258 253 258 260 254 259 261 255 260 262 256 261 263 243 242 262 245 244 263 243 264 266 247 245 265 246 266 268 247 267 269 248 268 270 251 249 269 265 263 272 264 286 274 267 265 273 266 274 276 267 275 277 270 268 276 271 269 277 257 270 278 271 279 281 260 258 281 259 282 284 260 283 285 261 284 272 264 262 285 279 301 287 281 287 290 282 288 291 283 290 292 284 291 293 286 285 292 272 293 295 286 294 296 275 273 295 276 274 296 275 297 299 276 298 300 279 277 299 280 278 300 294 316 302 297 295 303 296 302 305 297 304 306 298 305 307 301 299 306 300 307 309 287 301 308 287 310 312 288 311 313 290 312 314 291 313 315 294 292 314 295 293 315 310 330 318 311 331 319 312 318 320 313 319 321 316 314 320 303 315 321 316 322 324 304 303 323 302 324 326 304 325 327 307 305 326 308 306 327 307 328 317 308 329 330 324 345 332 325 346 333 328 326 332 329 327 333 317 328 334 329 335 337 330 337 339 331 338 340 318 339 341 319 340 342 322 320 341 323 321 342 324 322 343 325 323 344 340 338 347 339 361 349 340 348 350 343 341 349 344 342 350 343 351 353 346 344 352 345 353 355 346 354 356 334 332 355 335 333 356 334 357 359 335 358 360 337 360 361 354 376 362 357 355 363 358 356 362 357 364 366 358 365 367 361 360 367 348 347 368 361 369 371 348 370 372 351 349 371 352 350 372 351 373 375 352 374 376 355 353 375 369 390 377 370 391 378 373 371 377 374 372 378 373 379 381 376 374 380 375 381 383 376 382 384 364 363 383 365 362 384 364 385 387 365 386 388 369 367 388 370 368 389 385 383 392 386 384 394 385 393 396 386 395 397 388 397 399 389 398 400 390 399 401 391 400 402 379 377 401 380 378 402 379 403 405 380 404 406 381 405 392 382 406 394 402 400 407 403 401 409 404 402 408 403 410 412 406 404 411 405 412 414 406 413 415 393 392 414 395 394 415 393 416 418 395 417 419 399 397 419 398 420 407 399 421 409 417 415 422 416 436 424 417 423 425 421 419 425 420 426 428 421 427 429 407 428 430 410 409 429 408 430 432 410 431 433 413 411 432 412 433 435 413 434 422 414 435 436 431 429 437 430 451 439 431 438 440 434 432 439 435 433 440 434 441 443 435 442 444 423 422 443 436 444 446 425 423 445 425 447 449 426 448 450 427 449 437 428 450 451 444 465 452 445 466 453 447 453 455 450 448 454 449 455 457 451 450 456 438 437 457 439 451 458 438 459 461 441 439 460 440 461 463 441 462 464 442 463 465 445 443 464 459 481 467 462 460 468 461 467 470 462 469 471 463 470 472 466 464 471 452 465 472 466 473 475 453 475 477 454 476 478 455 477 479 456 478 480 459 457 479 458 480 468 475 2 10 478 476 3 477 10 13 480 478 12 479 13 18 468 480 15 481 18 21 469 468 20 467 21 26 471 469 24 470 26 30 473 471 28 472 30 7 475 473 0 </p>
-			</triangles>
-		</mesh>
-	</geometry>
-</library_geometries>
-<library_controllers>
-</library_controllers>
-<library_cameras>
-</library_cameras>
-<library_lights>
-</library_lights>
-<library_visual_scenes>
-	<visual_scene id="id-scene-1" name="scene">
-		<node id="Sphere" name="Sphere" type="NODE">
-			<matrix sid="transform"> 1.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 1.0  </matrix>
-			<instance_geometry url="#id-mesh-4">
-				<bind_material>
-					<technique_common>
-						<instance_material symbol="id-trimat-5" target="#id-material-3"/>
-					</technique_common>
-				</bind_material>
-			</instance_geometry>
-		</node>
-	</visual_scene>
-</library_visual_scenes>
-<scene>
-	<instance_visual_scene url="#id-scene-1" />
-</scene>
-</COLLADA>
diff --git a/Templates/BaseGame/game/tools/resources/ReflectProbeSphere.tscript b/Templates/BaseGame/game/tools/resources/ReflectProbeSphere.tscript
deleted file mode 100644
index 649009a49..000000000
--- a/Templates/BaseGame/game/tools/resources/ReflectProbeSphere.tscript
+++ /dev/null
@@ -1,11 +0,0 @@
-
-singleton TSShapeConstructor(ReflectProbeSpheredae)
-{
-   baseShapeAsset = "ToolsModule:ReflectProbeSphere";
-   singleDetailSize = "0";
-   flipUVCoords = "0";
-   JoinIdenticalVerts = "0";
-   reverseWindingOrder = "0";
-   removeRedundantMats = "0";
-   animFPS = "2";
-};
diff --git a/Templates/BaseGame/game/tools/resources/previewSphereShape.asset.taml b/Templates/BaseGame/game/tools/resources/previewSphereShape.asset.taml
new file mode 100644
index 000000000..b58ba0be8
--- /dev/null
+++ b/Templates/BaseGame/game/tools/resources/previewSphereShape.asset.taml
@@ -0,0 +1,6 @@
+<ShapeAsset
+    canSave="true"
+    canSaveDynamicFields="true"
+    AssetName="previewSphereShape"
+    fileName="@assetFile=previewSphereShape.dae"
+    constuctorFileName="@assetFile=previewSphereShape.tscript" />
diff --git a/Templates/BaseGame/game/tools/resources/previewSphereShape.dae b/Templates/BaseGame/game/tools/resources/previewSphereShape.dae
new file mode 100644
index 000000000..50afb94e9
--- /dev/null
+++ b/Templates/BaseGame/game/tools/resources/previewSphereShape.dae
@@ -0,0 +1,101 @@
+<?xml version="1.0" encoding="utf-8"?>
+<COLLADA xmlns="http://www.collada.org/2005/11/COLLADASchema" version="1.4.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <asset>
+    <contributor>
+      <author>Blender User</author>
+      <authoring_tool>Blender 3.0.0 commit date:2021-12-02, commit time:18:35, hash:f1cca3055776</authoring_tool>
+    </contributor>
+    <created>2021-12-24T16:51:50</created>
+    <modified>2021-12-24T16:51:50</modified>
+    <unit name="meter" meter="1"/>
+    <up_axis>Z_UP</up_axis>
+  </asset>
+  <library_effects>
+    <effect id="ReflectProbePreviewMat-effect">
+      <profile_COMMON>
+        <technique sid="common">
+          <lambert>
+            <emission>
+              <color sid="emission">0 0 0 1</color>
+            </emission>
+            <diffuse>
+              <color sid="diffuse">0.3737609 0.3737609 0.3737609 1</color>
+            </diffuse>
+            <index_of_refraction>
+              <float sid="ior">4</float>
+            </index_of_refraction>
+          </lambert>
+        </technique>
+      </profile_COMMON>
+    </effect>
+  </library_effects>
+  <library_images/>
+  <library_materials>
+    <material id="ReflectProbePreviewMat-material" name="ReflectProbePreviewMat">
+      <instance_effect url="#ReflectProbePreviewMat-effect"/>
+    </material>
+  </library_materials>
+  <library_geometries>
+    <geometry id="Sphere-mesh" name="Sphere">
+      <mesh>
+        <source id="Sphere-mesh-positions">
+          <float_array id="Sphere-mesh-positions-array" count="1446">-0.4903926 0 0.09754514 -0.4903926 0.09754514 0 -0.5 0 0 -0.09754514 0 0.4903926 0 0 0.5 -0.09567081 0.01903015 0.4903926 1.62921e-7 0 -0.5 -0.09754502 0 -0.4903926 -0.0956707 0.01903009 -0.4903926 -0.4809699 0.09567087 -0.09754508 -0.4903926 0 -0.09754508 -0.1876651 0.03732895 0.4619398 -0.1913417 0 0.4619398 -0.4619398 0 -0.1913416 -0.4530637 0.09012001 -0.1913416 -0.2777851 0 0.4157348 -0.2724475 0.05419319 0.4157348 -0.4077466 0.08110582 -0.2777851 -0.4157348 0 -0.2777851 -0.3467599 0.06897485 0.3535534 -0.3535534 0 0.3535534 -0.3535534 0 -0.3535534 -0.3467599 0.06897485 -0.3535534 -0.4077466 0.08110582 0.2777851 -0.4157348 0 0.2777851 -0.2724475 0.05419319 -0.4157348 -0.2777851 0 -0.4157348 -0.4530637 0.09011995 0.1913417 -0.4619398 0 0.1913417 -0.187665 0.03732889 -0.4619398 -0.1913416 0 -0.4619398 -0.4809699 0.09567087 0.09754514 -0.1767766 0.07322329 -0.4619398 -0.4530637 0.1876652 0.09754514 -0.09011983 0.03732889 -0.4903926 -0.4619398 0.1913418 0 -0.09011995 0.03732895 0.4903926 -0.4530637 0.1876652 -0.09754508 -0.1767767 0.07322335 0.4619398 -0.4267767 0.1767767 -0.1913416 -0.25664 0.1063038 0.4157348 -0.3840888 0.1590949 -0.2777851 -0.3266407 0.135299 0.3535534 -0.3266407 0.135299 -0.3535534 -0.3840888 0.1590949 0.2777851 -0.2566399 0.1063038 -0.4157348 -0.4267767 0.1767767 0.1913417 -0.3840888 0.25664 -0.1913416 -0.3456708 0.2309699 -0.2777851 -0.2939689 0.1964238 0.3535534 -0.2939689 0.1964238 -0.3535534 -0.3456708 0.2309699 0.2777851 -0.2309698 0.1543292 -0.4157348 -0.3840888 0.25664 0.1913417 -0.1590947 0.1063038 -0.4619398 -0.4077465 0.2724477 0.09754514 -0.0811057 0.05419319 -0.4903926 -0.4157347 0.2777852 0 -0.08110576 0.05419325 0.4903926 -0.4077465 0.2724477 -0.09754508 -0.1590948 0.1063038 0.4619398 -0.2309698 0.1543292 0.4157348 -0.06897467 0.06897485 -0.4903926 -0.3467599 0.34676 0.09754514 -0.3535533 0.3535535 0 -0.06897479 0.06897497 0.4903926 -0.3467599 0.34676 -0.09754508 -0.135299 0.1352991 0.4619398 -0.3266407 0.3266409 -0.1913416 -0.1964237 0.1964238 0.4157348 -0.2939688 0.293969 -0.2777851 -0.2499999 0.2500001 0.3535534 -0.2499999 0.2500001 -0.3535534 -0.2939688 0.293969 0.2777851 -0.1964236 0.1964238 -0.4157348 -0.3266407 0.3266409 0.1913417 -0.1352989 0.135299 -0.4619398 -0.1964236 0.293969 0.3535534 -0.1964236 0.293969 -0.3535534 -0.2309697 0.3456709 0.2777851 -0.154329 0.2309699 -0.4157348 -0.2566399 0.3840889 0.1913417 -0.1063036 0.1590949 -0.4619398 -0.2724474 0.4077466 0.09754514 -0.05419301 0.08110582 -0.4903926 -0.277785 0.415735 0 -0.05419307 0.08110594 0.4903926 -0.2724474 0.4077466 -0.09754508 -0.1063036 0.1590949 0.4619398 -0.2566399 0.3840889 -0.1913416 -0.154329 0.23097 0.4157348 -0.2309697 0.3456709 -0.2777851 -0.1913416 0.4619399 0 -0.03732877 0.09012007 0.4903926 -0.03732877 0.09011995 -0.4903926 -0.1876649 0.4530637 -0.09754508 -0.07322317 0.1767768 0.4619398 -0.1767766 0.4267768 -0.1913416 -0.1063036 0.2566401 0.4157348 -0.1590946 0.384089 -0.2777851 -0.1352989 0.3266409 0.3535534 -0.1352989 0.3266409 -0.3535534 -0.1590946 0.384089 0.2777851 -0.1063036 0.2566401 -0.4157348 -0.1767765 0.4267768 0.1913417 -0.07322317 0.1767767 -0.4619398 -0.1876649 0.4530637 0.09754514 -0.08110564 0.4077467 -0.2777851 -0.06897467 0.34676 -0.3535534 -0.08110564 0.4077467 0.2777851 -0.05419301 0.2724477 -0.4157348 -0.09011983 0.4530638 0.1913417 -0.03732877 0.1876652 -0.4619398 -0.09567064 0.4809699 0.09754514 -0.01902991 0.09567087 -0.4903926 -0.09754496 0.4903928 0 -0.01902997 0.09567099 0.4903926 -0.09567064 0.4809699 -0.09754508 -0.03732877 0.1876652 0.4619398 -0.09011983 0.4530638 -0.1913416 -0.05419301 0.2724477 0.4157348 -0.06897467 0.34676 0.3535534 1.63318e-7 0.09754526 0.4903926 1.54005e-7 0.09754514 -0.4903926 1.89395e-7 0.5000001 0 1.96846e-7 0.4903926 -0.09754508 1.59593e-7 0.1913418 0.4619398 0 0.4619398 -0.1913416 1.55867e-7 0.2777853 0.4157348 1.67043e-7 0.4157349 -0.2777851 1.59593e-7 0.3535535 0.3535534 1.59593e-7 0.3535535 -0.3535534 1.67043e-7 0.4157349 0.2777851 1.70769e-7 0.2777852 -0.4157348 1.37241e-7 0.4619398 0.1913417 1.52142e-7 0.1913418 -0.4619398 1.96846e-7 0.4903926 0.09754514 0.06897497 0.34676 0.3535534 0.081106 0.4077466 0.2777851 0.06897497 0.34676 -0.3535534 0.05419331 0.2724477 -0.4157348 0.09012013 0.4530638 0.1913417 0.03732907 0.1876652 -0.4619398 0.09567105 0.4809699 0.09754514 0.01903027 0.09567087 -0.4903926 0.09754532 0.4903928 0 0.01903027 0.09567099 0.4903926 0.09567105 0.4809699 -0.09754508 0.03732907 0.1876652 0.4619398 0.09012007 0.4530638 -0.1913416 0.05419331 0.2724477 0.4157348 0.081106 0.4077466 -0.2777851 0.1876653 0.4530637 -0.09754508 0.07322347 0.1767768 0.4619398 0.1767768 0.4267768 -0.1913416 0.1063039 0.2566401 0.4157348 0.159095 0.3840889 -0.2777851 0.1352992 0.3266409 0.3535534 0.1352992 0.3266409 -0.3535534 0.159095 0.3840889 0.2777851 0.1063039 0.25664 -0.4157348 0.1767768 0.4267768 0.1913417 0.07322347 0.1767767 -0.4619398 0.1876653 0.4530637 0.09754514 0.03732907 0.09011995 -0.4903926 0.1913419 0.4619398 0 0.03732913 0.09012007 0.4903926 0.1964239 0.293969 -0.3535534 0.1543293 0.2309699 -0.4157348 0.2566401 0.3840889 0.1913417 0.1063039 0.1590948 -0.4619398 0.2724477 0.4077466 0.09754514 0.05419331 0.08110582 -0.4903926 0.2777853 0.4157348 0 0.05419337 0.08110594 0.4903926 0.2724477 0.4077466 -0.09754508 0.1063039 0.1590949 0.4619398 0.2566401 0.3840889 -0.1913416 0.1543293 0.2309699 0.4157348 0.23097 0.3456709 -0.2777851 0.1964239 0.293969 0.3535534 0.23097 0.3456709 0.2777851 0.3266409 0.3266409 -0.1913416 0.196424 0.1964238 0.4157348 0.2939691 0.2939689 -0.2777851 0.2500002 0.25 0.3535534 0.2500002 0.25 -0.3535534 0.2939691 0.2939689 0.2777851 0.1964239 0.1964237 -0.4157348 0.3266409 0.3266409 0.1913417 0.1352992 0.135299 -0.4619398 0.3467601 0.3467599 0.09754514 0.06897497 0.06897485 -0.4903926 0.3535536 0.3535534 0 0.06897509 0.06897491 0.4903926 0.3467601 0.3467599 -0.09754508 0.1352992 0.1352991 0.4619398 0.1590949 0.1063038 -0.4619398 0.3840891 0.25664 0.1913417 0.4077467 0.2724475 0.09754514 0.081106 0.05419319 -0.4903926 0.415735 0.2777851 0 0.08110606 0.05419319 0.4903926 0.4077467 0.2724475 -0.09754508 0.159095 0.1063038 0.4619398 0.3840891 0.25664 -0.1913416 0.23097 0.1543291 0.4157348 0.345671 0.2309699 -0.2777851 0.2939691 0.1964237 0.3535534 0.2939691 0.1964237 -0.3535534 0.345671 0.2309699 0.2777851 0.23097 0.1543291 -0.4157348 0.1767769 0.07322335 0.4619398 0.2566402 0.1063038 0.4157348 0.4267768 0.1767767 -0.1913416 0.384089 0.1590948 -0.2777851 0.3266409 0.135299 0.3535534 0.3266409 0.135299 -0.3535534 0.384089 0.1590948 0.2777851 0.2566401 0.1063037 -0.4157348 0.4267768 0.1767767 0.1913417 0.1767768 0.07322329 -0.4619398 0.4530638 0.1876651 0.09754514 0.09012013 0.03732889 -0.4903926 0.46194 0.1913416 0 0.09012019 0.03732895 0.4903926 0.4530638 0.1876651 -0.09754508 0.4530639 0.09012001 0.1913417 0.48097 0.09567075 0.09754514 0.1876652 0.03732889 -0.4619398 0.09567099 0.01903009 -0.4903926 0.4903929 0.09754508 0 0.09567111 0.01903009 0.4903926 0.48097 0.09567075 -0.09754508 0.1876653 0.03732889 0.4619398 0.4530639 0.09012001 -0.1913416 0.2724478 0.05419319 0.4157348 0.4077467 0.08110576 -0.2777851 0.3467601 0.06897479 0.3535534 0.3467601 0.06897479 -0.3535534 0.4077467 0.08110576 0.2777851 0.2724477 0.05419313 -0.4157348 0.4619399 0 -0.1913416 0.4157348 0 -0.2777851 0.2777853 0 0.4157348 0.3535535 0 0.3535534 0.3535535 0 -0.3535534 0.4157348 0 0.2777851 0.2777853 0 -0.4157348 0.4619399 0 0.1913417 0.1913418 0 -0.4619398 0.4903926 0 0.09754514 0.09754532 0 -0.4903926 0.5000002 0 0 0.09754538 0 0.4903926 0.4903926 0 -0.09754508 0.1913419 0 0.4619398 0.09567099 -0.01903009 -0.4903926 0.4903928 -0.0975452 0 0.09567105 -0.01903009 0.4903926 0.4809699 -0.09567087 -0.09754508 0.1876653 -0.03732889 0.4619398 0.4530639 -0.09011989 -0.1913416 0.2724478 -0.05419313 0.4157348 0.4077466 -0.08110582 -0.2777851 0.3467601 -0.06897485 0.3535534 0.3467601 -0.06897485 -0.3535534 0.4077466 -0.08110582 0.2777851 0.2724477 -0.05419313 -0.4157348 0.4530639 -0.09011989 0.1913417 0.1876652 -0.03732889 -0.4619398 0.4809699 -0.09567087 0.09754514 0.2566402 -0.1063038 0.4157348 0.3266409 -0.135299 0.3535534 0.3266409 -0.135299 -0.3535534 0.3840889 -0.1590948 0.2777851 0.2566401 -0.1063037 -0.4157348 0.4267768 -0.1767767 0.1913417 0.1767768 -0.07322329 -0.4619398 0.4530637 -0.1876651 0.09754514 0.09012007 -0.03732889 -0.4903926 0.4619399 -0.1913418 0 0.09012019 -0.03732895 0.4903926 0.4530637 -0.1876651 -0.09754508 0.1767768 -0.07322329 0.4619398 0.4267768 -0.1767767 -0.1913416 0.3840889 -0.1590948 -0.2777851 0.415735 -0.2777852 0 0.08110606 -0.05419319 0.4903926 0.08110594 -0.05419313 -0.4903926 0.4077466 -0.2724475 -0.09754508 0.1590949 -0.1063038 0.4619398 0.384089 -0.25664 -0.1913416 0.23097 -0.1543291 0.4157348 0.3456709 -0.2309698 -0.2777851 0.293969 -0.1964237 0.3535534 0.293969 -0.1964237 -0.3535534 0.3456709 -0.2309698 0.2777851 0.23097 -0.1543291 -0.4157348 0.384089 -0.25664 0.1913417 0.1590949 -0.1063037 -0.4619398 0.4077466 -0.2724475 0.09754514 0.2500001 -0.25 -0.3535534 0.2500001 -0.25 0.3535534 0.2939689 -0.2939688 0.2777851 0.1964238 -0.1964237 -0.4157348 0.3266409 -0.3266407 0.1913417 0.1352991 -0.135299 -0.4619398 0.3467599 -0.3467599 0.09754514 0.06897497 -0.06897479 -0.4903926 0.3535535 -0.3535534 0 0.06897503 -0.06897491 0.4903926 0.3467599 -0.3467599 -0.09754508 0.1352992 -0.135299 0.4619398 0.3266409 -0.3266407 -0.1913416 0.1964239 -0.1964237 0.4157348 0.2939689 -0.2939688 -0.2777851 0.05419331 -0.08110576 -0.4903926 0.2724475 -0.4077464 -0.09754508 0.1063039 -0.1590948 0.4619398 0.2566401 -0.3840888 -0.1913416 0.1543293 -0.2309699 0.4157348 0.2309699 -0.3456708 -0.2777851 0.1964238 -0.2939689 0.3535534 0.1964238 -0.2939689 -0.3535534 0.2309699 -0.3456708 0.2777851 0.1543292 -0.2309698 -0.4157348 0.2566401 -0.3840888 0.1913417 0.1063038 -0.1590948 -0.4619398 0.2724475 -0.4077464 0.09754514 0.2777852 -0.4157348 0 0.05419337 -0.08110588 0.4903926 0.1063038 -0.2566399 -0.4157348 0.1767768 -0.4267767 0.1913417 0.07322341 -0.1767766 -0.4619398 0.1876651 -0.4530636 0.09754514 0.03732901 -0.09011989 -0.4903926 0.1913418 -0.4619398 0 0.03732907 -0.09012001 0.4903926 0.1876651 -0.4530636 -0.09754508 0.07322341 -0.1767767 0.4619398 0.1767768 -0.4267767 -0.1913416 0.1063039 -0.25664 0.4157348 0.1590948 -0.3840887 -0.2777851 0.1352991 -0.3266407 0.3535534 0.1352991 -0.3266407 -0.3535534 0.1590948 -0.3840887 0.2777851 0.01903027 -0.09567093 0.4903926 0.03732901 -0.1876651 0.4619398 0.09012013 -0.4530637 -0.1913416 0.05419331 -0.2724475 0.4157348 0.08110582 -0.4077464 -0.2777851 0.06897491 -0.3467599 0.3535534 0.06897491 -0.3467599 -0.3535534 0.08110582 -0.4077464 0.2777851 0.05419325 -0.2724475 -0.4157348 0.09012013 -0.4530637 0.1913417 0.03732901 -0.187665 -0.4619398 0.09567081 -0.4809697 0.09754514 0.01903027 -0.09567081 -0.4903926 0.0975452 -0.4903926 0 0.09567081 -0.4809697 -0.09754508 1.59593e-7 -0.4619398 0.1913417 1.2979e-7 -0.277785 -0.4157348 1.26065e-7 -0.1913416 -0.4619398 0 -0.4903924 0.09754514 1.5773e-7 -0.09754508 -0.4903926 0 -0.4999999 0 1.55867e-7 -0.0975452 0.4903926 0 -0.4903924 -0.09754508 1.40966e-7 -0.1913416 0.4619398 1.59593e-7 -0.4619398 -0.1913416 1.40966e-7 -0.2777851 0.4157348 0 -0.4157346 -0.2777851 0 -0.3535534 0.3535534 0 -0.3535534 -0.3535534 0 -0.4157346 0.2777851 -0.09011977 -0.4530637 -0.1913416 -0.05419301 -0.2724475 0.4157348 -0.0811057 -0.4077463 -0.2777851 -0.06897473 -0.3467599 0.3535534 -0.06897473 -0.3467599 -0.3535534 -0.0811057 -0.4077463 0.2777851 -0.05419301 -0.2724475 -0.4157348 -0.09011977 -0.4530637 0.1913417 -0.03732872 -0.187665 -0.4619398 -0.09567075 -0.4809696 0.09754514 -0.01902991 -0.09567081 -0.4903926 -0.09754508 -0.4903925 0 -0.01902997 -0.09567093 0.4903926 -0.09567075 -0.4809696 -0.09754508 -0.03732872 -0.1876651 0.4619398 -0.1063036 -0.2566398 -0.4157348 -0.07322311 -0.1767766 -0.4619398 -0.1767765 -0.4267767 0.1913417 -0.1876649 -0.4530634 0.09754514 -0.03732872 -0.09011989 -0.4903926 -0.1913416 -0.4619396 0 -0.03732877 -0.09012001 0.4903926 -0.1876649 -0.4530634 -0.09754508 -0.07322311 -0.1767767 0.4619398 -0.1767765 -0.4267767 -0.1913416 -0.1063036 -0.2566399 0.4157348 -0.1590946 -0.3840886 -0.2777851 -0.1352989 -0.3266407 0.3535534 -0.1352989 -0.3266407 -0.3535534 -0.1590946 -0.3840886 0.2777851 -0.1063036 -0.1590948 0.4619398 -0.154329 -0.2309698 0.4157348 -0.2566398 -0.3840888 -0.1913416 -0.2309697 -0.3456706 -0.2777851 -0.1964236 -0.2939688 0.3535534 -0.1964236 -0.2939688 -0.3535534 -0.2309697 -0.3456706 0.2777851 -0.154329 -0.2309697 -0.4157348 -0.2566398 -0.3840888 0.1913417 -0.1063035 -0.1590947 -0.4619398 -0.2724474 -0.4077463 0.09754514 -0.05419296 -0.08110576 -0.4903926 -0.277785 -0.4157346 0 -0.05419301 -0.08110588 0.4903926 -0.2724474 -0.4077463 -0.09754508 -0.3266406 -0.3266407 0.1913417 -0.3467597 -0.3467597 0.09754514 -0.06897461 -0.06897479 -0.4903926 -0.3535532 -0.3535532 0 -0.06897473 -0.06897485 0.4903926 -0.3467597 -0.3467597 -0.09754508 -0.1352988 -0.135299 0.4619398 -0.3266406 -0.3266407 -0.1913416 -0.1964235 -0.1964237 0.4157348 -0.2939687 -0.2939686 -0.2777851 -0.2499998 -0.2499999 0.3535534 -0.2499998 -0.2499999 -0.3535534 -0.2939687 -0.2939686 0.2777851 -0.1964235 -0.1964236 -0.4157348 -0.1352988 -0.1352989 -0.4619398 -0.3840886 -0.2566399 -0.1913416 -0.3456706 -0.2309696 -0.2777851 -0.2939687 -0.1964236 0.3535534 -0.2939687 -0.1964236 -0.3535534 -0.3456706 -0.2309696 0.2777851 -0.2309696 -0.154329 -0.4157348 -0.3840886 -0.2566399 0.1913417 -0.1590946 -0.1063036 -0.4619398 -0.4077462 -0.2724473 0.09754514 -0.08110564 -0.05419313 -0.4903926 -0.4157345 -0.2777849 0 -0.0811057 -0.05419319 0.4903926 -0.4077462 -0.2724473 -0.09754508 -0.1590946 -0.1063037 0.4619398 -0.2309697 -0.154329 0.4157348 -0.09011977 -0.03732889 -0.4903926 -0.4619395 -0.1913415 0 -0.09011983 -0.03732889 0.4903926 -0.4530633 -0.1876649 -0.09754508 -0.1767765 -0.07322323 0.4619398 -0.4267765 -0.1767766 -0.1913416 -0.2566398 -0.1063036 0.4157348 -0.3840885 -0.1590946 -0.2777851 -0.3266406 -0.1352989 0.3535534 -0.3266406 -0.1352989 -0.3535534 -0.3840885 -0.1590946 0.2777851 -0.2566397 -0.1063036 -0.4157348 -0.4267765 -0.1767766 0.1913417 -0.1767764 -0.07322323 -0.4619398 -0.4530633 -0.1876649 0.09754514 -0.3467597 -0.06897473 -0.3535534 -0.3467597 -0.06897473 0.3535534 -0.4077462 -0.08110564 0.2777851 -0.2724472 -0.05419307 -0.4157348 -0.4530635 -0.09011989 0.1913417 -0.1876649 -0.03732883 -0.4619398 -0.4809694 -0.09567064 0.09754514 -0.09567064 -0.01903009 -0.4903926 -0.4903923 -0.09754496 0 -0.09567075 -0.01903009 0.4903926 -0.4809694 -0.09567064 -0.09754508 -0.1876649 -0.03732883 0.4619398 -0.4530635 -0.09011989 -0.1913416 -0.2724473 -0.05419307 0.4157348 -0.4077462 -0.08110564 -0.2777851</float_array>
+          <technique_common>
+            <accessor source="#Sphere-mesh-positions-array" count="482" stride="3">
+              <param name="X" type="float"/>
+              <param name="Y" type="float"/>
+              <param name="Z" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="Sphere-mesh-normals">
+          <float_array id="Sphere-mesh-normals-array" count="1446">-0.9810172 0 0.1939206 -0.9807879 0.1950772 0 -1 0 0 -0.2009674 0 0.979598 0 0 1 -0.1970922 0.03918647 0.9796015 0 0 -1 -0.2009674 0 -0.979598 -0.1970922 0.03918647 -0.9796015 -0.9621686 0.1913838 -0.1939169 -0.9810172 0 -0.1939206 -0.3804228 0.0756573 0.9217128 -0.3878701 0 0.9217141 -0.9247629 0 -0.3805441 -0.9069971 0.1803984 -0.3805426 -0.5597748 0 0.8286449 -0.5490075 0.1091972 0.8286537 -0.8173288 0.1625746 -0.5527598 -0.8333439 0 -0.5527549 -0.6965101 0.1385268 0.7040483 -0.7101522 0 0.7040483 -0.7101522 0 -0.7040483 -0.6965101 0.1385268 -0.7040483 -0.8173288 0.1625746 0.5527598 -0.8333439 0 0.5527549 -0.5490075 0.1091972 -0.8286537 -0.5597748 0 -0.8286449 -0.9069971 0.1803984 0.3805426 -0.9247629 0 0.3805441 -0.3804228 0.0756573 -0.9217128 -0.3878701 0 -0.9217141 -0.9621686 0.1913838 0.1939169 -0.3583571 0.1484152 -0.9217122 -0.9063459 0.3754112 0.1939162 -0.1856477 0.07690811 -0.979602 -0.9238803 0.3826816 0 -0.1856477 0.07690811 0.979602 -0.9063459 0.3754112 -0.1939162 -0.3583571 0.1484152 0.9217122 -0.854371 0.3538948 -0.3805376 -0.5171472 0.214214 0.8286563 -0.7699079 0.3188951 -0.5527638 -0.6560856 0.2717489 0.7040628 -0.6560856 0.2717489 -0.7040628 -0.7699079 0.3188951 0.5527638 -0.5171472 0.214214 -0.8286563 -0.8543801 0.3538681 0.3805418 -0.7689241 0.5137555 -0.3805404 -0.6929023 0.4629725 -0.5527593 -0.5904647 0.3945282 0.704059 -0.5904647 0.3945282 -0.704059 -0.6929023 0.4629725 0.5527593 -0.4654174 0.3109903 -0.8286566 -0.7689241 0.5137555 0.3805404 -0.3224976 0.2154968 -0.9217139 -0.8156918 0.5450153 0.1939202 -0.1670918 0.1116387 -0.9796006 -0.8314677 0.5555732 0 -0.1670918 0.1116387 0.9796006 -0.8156918 0.5450153 -0.1939202 -0.3224976 0.2154968 0.9217139 -0.4654174 0.3109903 0.8286566 -0.1420966 0.1420966 -0.9796006 -0.6936836 0.6936836 0.1939225 -0.7071068 0.7071068 0 -0.1420966 0.1420966 0.9796006 -0.6936836 0.6936836 -0.1939225 -0.2742754 0.2742754 0.9217082 -0.6539059 0.6539059 -0.3805448 -0.3958047 0.3958047 0.8286599 -0.5892608 0.5892608 -0.55276 -0.5021433 0.5021433 0.7040627 -0.5021433 0.5021433 -0.7040627 -0.5892608 0.5892608 0.55276 -0.3958047 0.3958047 -0.8286599 -0.6539059 0.6539059 0.3805448 -0.2742754 0.2742754 -0.9217082 -0.3945282 0.5904647 0.704059 -0.3945282 0.5904647 -0.704059 -0.4629725 0.6929023 0.5527593 -0.3109903 0.4654174 -0.8286566 -0.5137555 0.7689241 0.3805404 -0.2154968 0.3224976 -0.9217139 -0.5450153 0.8156918 0.1939202 -0.1116387 0.1670918 -0.9796006 -0.5555732 0.8314677 0 -0.1116387 0.1670918 0.9796006 -0.5450153 0.8156918 -0.1939202 -0.2154968 0.3224976 0.9217139 -0.5137555 0.7689241 -0.3805404 -0.3109903 0.4654174 0.8286566 -0.4629725 0.6929023 -0.5527593 -0.3826816 0.9238803 0 -0.07690811 0.1856477 0.979602 -0.07690811 0.1856477 -0.979602 -0.3754112 0.9063459 -0.1939162 -0.1484152 0.3583571 0.9217122 -0.3538681 0.8543801 -0.3805418 -0.214214 0.5171472 0.8286563 -0.3188951 0.7699079 -0.5527638 -0.2717489 0.6560856 0.7040628 -0.2717489 0.6560856 -0.7040628 -0.3188951 0.7699079 0.5527638 -0.214214 0.5171472 -0.8286563 -0.3538681 0.8543801 0.3805418 -0.1484152 0.3583571 -0.9217122 -0.3754112 0.9063459 0.1939162 -0.1625746 0.8173288 -0.5527598 -0.1385268 0.6965101 -0.7040483 -0.1625746 0.8173288 0.5527598 -0.1091972 0.5490075 -0.8286537 -0.1803984 0.9069971 0.3805426 -0.0756573 0.3804228 -0.9217128 -0.1913838 0.9621686 0.1939169 -0.03918647 0.1970922 -0.9796015 -0.1950772 0.9807879 0 -0.03918647 0.1970922 0.9796015 -0.1913838 0.9621686 -0.1939169 -0.0756573 0.3804228 0.9217128 -0.1803984 0.9069971 -0.3805426 -0.1091972 0.5490075 0.8286537 -0.1385268 0.6965101 0.7040483 0 0.2009674 0.979598 0 0.2009674 -0.979598 0 1 0 0 0.9810172 -0.1939206 0 0.3878701 0.9217141 0 0.9247629 -0.3805441 0 0.5597748 0.8286449 0 0.8333439 -0.5527549 0 0.7101522 0.7040483 0 0.7101522 -0.7040483 0 0.8333439 0.5527549 0 0.5597748 -0.8286449 0 0.9247629 0.3805441 0 0.3878701 -0.9217141 0 0.9810172 0.1939206 0.1385268 0.6965101 0.7040483 0.1625746 0.8173288 0.5527598 0.1385268 0.6965101 -0.7040483 0.1091972 0.5490075 -0.8286537 0.1803984 0.9069971 0.3805426 0.0756573 0.3804228 -0.9217128 0.1913838 0.9621686 0.1939169 0.03918647 0.1970922 -0.9796015 0.1950772 0.9807879 0 0.03918647 0.1970922 0.9796015 0.1913838 0.9621686 -0.1939169 0.0756573 0.3804228 0.9217128 0.1803984 0.9069971 -0.3805426 0.1091972 0.5490075 0.8286537 0.1625746 0.8173288 -0.5527598 0.3754112 0.9063459 -0.1939162 0.1484152 0.3583571 0.9217122 0.3538948 0.854371 -0.3805376 0.214214 0.5171472 0.8286563 0.3188951 0.7699079 -0.5527638 0.2717489 0.6560856 0.7040628 0.2717489 0.6560856 -0.7040628 0.3188951 0.7699079 0.5527638 0.214214 0.5171472 -0.8286563 0.3538948 0.854371 0.3805376 0.1484152 0.3583571 -0.9217122 0.3754112 0.9063459 0.1939162 0.07690811 0.1856477 -0.979602 0.3826816 0.9238803 0 0.07690811 0.1856477 0.979602 0.3945282 0.5904647 -0.704059 0.3109903 0.4654174 -0.8286566 0.5137555 0.7689241 0.3805404 0.2154968 0.3224976 -0.9217139 0.5450153 0.8156918 0.1939202 0.1116387 0.1670918 -0.9796006 0.5555732 0.8314677 0 0.1116387 0.1670918 0.9796006 0.5450153 0.8156918 -0.1939202 0.2154968 0.3224976 0.9217139 0.5137555 0.7689241 -0.3805404 0.3109903 0.4654174 0.8286566 0.4629725 0.6929023 -0.5527593 0.3945282 0.5904647 0.704059 0.4629725 0.6929023 0.5527593 0.6539059 0.6539059 -0.3805448 0.3958047 0.3958047 0.8286599 0.5892608 0.5892608 -0.55276 0.5021433 0.5021433 0.7040627 0.5021433 0.5021433 -0.7040627 0.5892608 0.5892608 0.55276 0.3958047 0.3958047 -0.8286599 0.6539059 0.6539059 0.3805448 0.2742754 0.2742754 -0.9217082 0.6936836 0.6936836 0.1939225 0.1420966 0.1420966 -0.9796006 0.7071068 0.7071068 0 0.1420966 0.1420966 0.9796006 0.6936836 0.6936836 -0.1939225 0.2742754 0.2742754 0.9217082 0.3224976 0.2154968 -0.9217139 0.7689241 0.5137555 0.3805404 0.8156918 0.5450153 0.1939202 0.1670918 0.1116387 -0.9796006 0.8314677 0.5555732 0 0.1670918 0.1116387 0.9796006 0.8156918 0.5450153 -0.1939202 0.3224976 0.2154968 0.9217139 0.7689241 0.5137555 -0.3805404 0.4654174 0.3109903 0.8286566 0.6929023 0.4629725 -0.5527593 0.5904647 0.3945282 0.704059 0.5904647 0.3945282 -0.704059 0.6929023 0.4629725 0.5527593 0.4654174 0.3109903 -0.8286566 0.3583571 0.1484152 0.9217122 0.5171472 0.214214 0.8286563 0.8543801 0.3538681 -0.3805418 0.7699079 0.3188951 -0.5527638 0.6560856 0.2717489 0.7040628 0.6560856 0.2717489 -0.7040628 0.7699079 0.3188951 0.5527638 0.5171472 0.214214 -0.8286563 0.8543801 0.3538681 0.3805418 0.3583571 0.1484152 -0.9217122 0.9063459 0.3754112 0.1939162 0.1856477 0.07690811 -0.979602 0.9238803 0.3826816 0 0.1856477 0.07690811 0.979602 0.9063459 0.3754112 -0.1939162 0.9069971 0.1803984 0.3805426 0.9621686 0.1913838 0.1939169 0.3804228 0.0756573 -0.9217128 0.1970922 0.03918647 -0.9796015 0.9807879 0.1950772 0 0.1970922 0.03918647 0.9796015 0.9621686 0.1913838 -0.1939169 0.3804228 0.0756573 0.9217128 0.9069971 0.1803984 -0.3805426 0.5490075 0.1091972 0.8286537 0.8173288 0.1625746 -0.5527598 0.6965101 0.1385268 0.7040483 0.6965101 0.1385268 -0.7040483 0.8173288 0.1625746 0.5527598 0.5490075 0.1091972 -0.8286537 0.9247629 0 -0.3805441 0.8333439 0 -0.5527549 0.5597748 0 0.8286449 0.7101522 0 0.7040483 0.7101522 0 -0.7040483 0.8333439 0 0.5527549 0.5597748 0 -0.8286449 0.9247629 0 0.3805441 0.3878701 0 -0.9217141 0.9810172 0 0.1939206 0.2009674 0 -0.979598 1 0 0 0.2009674 0 0.979598 0.9810172 0 -0.1939206 0.3878701 0 0.9217141 0.1970922 -0.03918647 -0.9796015 0.9807879 -0.1950772 0 0.1970922 -0.03918647 0.9796015 0.9621686 -0.1913838 -0.1939169 0.3804228 -0.0756573 0.9217128 0.9069971 -0.1803984 -0.3805426 0.5490075 -0.1091972 0.8286537 0.8173288 -0.1625746 -0.5527598 0.6965101 -0.1385268 0.7040483 0.6965101 -0.1385268 -0.7040483 0.8173288 -0.1625746 0.5527598 0.5490075 -0.1091972 -0.8286537 0.9069971 -0.1803984 0.3805426 0.3804228 -0.0756573 -0.9217128 0.9621686 -0.1913838 0.1939169 0.5171472 -0.214214 0.8286563 0.6560856 -0.2717489 0.7040628 0.6560856 -0.2717489 -0.7040628 0.7699079 -0.3188951 0.5527638 0.5171472 -0.214214 -0.8286563 0.8543801 -0.3538681 0.3805418 0.3583571 -0.1484152 -0.9217122 0.9063459 -0.3754112 0.1939162 0.1856477 -0.07690811 -0.979602 0.9238803 -0.3826816 0 0.1856477 -0.07690811 0.979602 0.9063459 -0.3754112 -0.1939162 0.3583571 -0.1484152 0.9217122 0.854371 -0.3538948 -0.3805376 0.7699079 -0.3188951 -0.5527638 0.8314677 -0.5555732 0 0.1670918 -0.1116387 0.9796006 0.1670918 -0.1116387 -0.9796006 0.8156918 -0.5450153 -0.1939202 0.3224976 -0.2154968 0.9217139 0.7689241 -0.5137555 -0.3805404 0.4654174 -0.3109903 0.8286566 0.6929023 -0.4629725 -0.5527593 0.5904647 -0.3945282 0.704059 0.5904647 -0.3945282 -0.704059 0.6929023 -0.4629725 0.5527593 0.4654174 -0.3109903 -0.8286566 0.7689241 -0.5137555 0.3805404 0.3224976 -0.2154968 -0.9217139 0.8156918 -0.5450153 0.1939202 0.5021433 -0.5021433 -0.7040627 0.5021433 -0.5021433 0.7040627 0.5892608 -0.5892608 0.55276 0.3958047 -0.3958047 -0.8286599 0.6539059 -0.6539059 0.3805448 0.2742754 -0.2742754 -0.9217082 0.6936836 -0.6936836 0.1939225 0.1420966 -0.1420966 -0.9796006 0.7071068 -0.7071068 0 0.1420966 -0.1420966 0.9796006 0.6936836 -0.6936836 -0.1939225 0.2742754 -0.2742754 0.9217082 0.6539059 -0.6539059 -0.3805448 0.3958047 -0.3958047 0.8286599 0.5892608 -0.5892608 -0.55276 0.1116387 -0.1670918 -0.9796006 0.5450153 -0.8156918 -0.1939202 0.2154968 -0.3224976 0.9217139 0.5137555 -0.7689241 -0.3805404 0.3109903 -0.4654174 0.8286566 0.4629725 -0.6929023 -0.5527593 0.3945282 -0.5904647 0.704059 0.3945282 -0.5904647 -0.704059 0.4629725 -0.6929023 0.5527593 0.3109903 -0.4654174 -0.8286566 0.5137555 -0.7689241 0.3805404 0.2154968 -0.3224976 -0.9217139 0.5450153 -0.8156918 0.1939202 0.5555732 -0.8314677 0 0.1116387 -0.1670918 0.9796006 0.214214 -0.5171472 -0.8286563 0.3538681 -0.8543801 0.3805418 0.1484152 -0.3583571 -0.9217122 0.3754112 -0.9063459 0.1939162 0.07690811 -0.1856477 -0.979602 0.3826816 -0.9238803 0 0.07687777 -0.1856481 0.9796043 0.3754112 -0.9063459 -0.1939162 0.1484152 -0.3583571 0.9217122 0.3538681 -0.8543801 -0.3805418 0.214214 -0.5171472 0.8286563 0.3188951 -0.7699079 -0.5527638 0.2717489 -0.6560856 0.7040628 0.2717489 -0.6560856 -0.7040628 0.3188951 -0.7699079 0.5527638 0.03918647 -0.1970922 0.9796015 0.0756573 -0.3804228 0.9217128 0.1803984 -0.9069971 -0.3805426 0.1091972 -0.5490075 0.8286537 0.1625746 -0.8173288 -0.5527598 0.1385268 -0.6965101 0.7040483 0.1385268 -0.6965101 -0.7040483 0.1625746 -0.8173288 0.5527598 0.1091972 -0.5490075 -0.8286537 0.1803984 -0.9069971 0.3805426 0.0756573 -0.3804228 -0.9217128 0.1913838 -0.9621686 0.1939169 0.03918647 -0.1970922 -0.9796015 0.1950772 -0.9807879 0 0.1913838 -0.9621686 -0.1939169 0 -0.9247629 0.3805441 0 -0.5597748 -0.8286449 0 -0.3878701 -0.9217141 0 -0.9810172 0.1939206 0 -0.2009674 -0.979598 0 -1 0 0 -0.2009674 0.979598 0 -0.9810172 -0.1939206 0 -0.3878701 0.9217141 0 -0.9247629 -0.3805441 0 -0.5597748 0.8286449 0 -0.8333439 -0.5527549 0 -0.7101522 0.7040483 0 -0.7101522 -0.7040483 0 -0.8333439 0.5527549 -0.1803984 -0.9069971 -0.3805426 -0.1091972 -0.5490075 0.8286537 -0.1625746 -0.8173288 -0.5527598 -0.1385268 -0.6965101 0.7040483 -0.1385268 -0.6965101 -0.7040483 -0.1625746 -0.8173288 0.5527598 -0.1091972 -0.5490075 -0.8286537 -0.1803984 -0.9069971 0.3805426 -0.0756573 -0.3804228 -0.9217128 -0.1913838 -0.9621686 0.1939169 -0.03918647 -0.1970922 -0.9796015 -0.1950772 -0.9807879 0 -0.03918647 -0.1970922 0.9796015 -0.1913838 -0.9621686 -0.1939169 -0.0756573 -0.3804228 0.9217128 -0.214214 -0.5171472 -0.8286563 -0.1484152 -0.3583571 -0.9217122 -0.3538681 -0.8543801 0.3805418 -0.3754112 -0.9063459 0.1939162 -0.07690811 -0.1856477 -0.979602 -0.3826816 -0.9238803 0 -0.07687777 -0.1856481 0.9796043 -0.3754112 -0.9063459 -0.1939162 -0.1484152 -0.3583571 0.9217122 -0.3538681 -0.8543801 -0.3805418 -0.214214 -0.5171472 0.8286563 -0.3188951 -0.7699079 -0.5527638 -0.2717489 -0.6560856 0.7040628 -0.2717489 -0.6560856 -0.7040628 -0.3188951 -0.7699079 0.5527638 -0.2154968 -0.3224976 0.9217139 -0.3109903 -0.4654174 0.8286566 -0.5137555 -0.7689241 -0.3805404 -0.4629725 -0.6929023 -0.5527593 -0.3945282 -0.5904647 0.704059 -0.3945282 -0.5904647 -0.704059 -0.4629725 -0.6929023 0.5527593 -0.3109903 -0.4654174 -0.8286566 -0.5137555 -0.7689241 0.3805404 -0.2154968 -0.3224976 -0.9217139 -0.5450153 -0.8156918 0.1939202 -0.1116387 -0.1670918 -0.9796006 -0.5555732 -0.8314677 0 -0.1116387 -0.1670918 0.9796006 -0.5450153 -0.8156918 -0.1939202 -0.6539059 -0.6539059 0.3805448 -0.6936836 -0.6936836 0.1939225 -0.1420966 -0.1420966 -0.9796006 -0.7071068 -0.7071068 0 -0.1420966 -0.1420966 0.9796006 -0.6936836 -0.6936836 -0.1939225 -0.2742754 -0.2742754 0.9217082 -0.6539059 -0.6539059 -0.3805448 -0.3958047 -0.3958047 0.8286599 -0.5892608 -0.5892608 -0.55276 -0.5021433 -0.5021433 0.7040627 -0.5021433 -0.5021433 -0.7040627 -0.5892608 -0.5892608 0.55276 -0.3958047 -0.3958047 -0.8286599 -0.2742754 -0.2742754 -0.9217082 -0.7689241 -0.5137555 -0.3805404 -0.6929023 -0.4629725 -0.5527593 -0.5904647 -0.3945282 0.704059 -0.5904647 -0.3945282 -0.704059 -0.6929023 -0.4629725 0.5527593 -0.4654174 -0.3109903 -0.8286566 -0.7689241 -0.5137555 0.3805404 -0.3224976 -0.2154968 -0.9217139 -0.8156918 -0.5450153 0.1939202 -0.1670918 -0.1116387 -0.9796006 -0.8314677 -0.5555732 0 -0.1670918 -0.1116387 0.9796006 -0.8156918 -0.5450153 -0.1939202 -0.3224976 -0.2154968 0.9217139 -0.4654174 -0.3109903 0.8286566 -0.1856477 -0.07690811 -0.979602 -0.9238803 -0.3826816 0 -0.1856477 -0.07690811 0.979602 -0.9063459 -0.3754112 -0.1939162 -0.3583571 -0.1484152 0.9217122 -0.8543801 -0.3538681 -0.3805418 -0.5171472 -0.214214 0.8286563 -0.7699079 -0.3188951 -0.5527638 -0.6560856 -0.2717489 0.7040628 -0.6560856 -0.2717489 -0.7040628 -0.7699079 -0.3188951 0.5527638 -0.5171472 -0.214214 -0.8286563 -0.8543801 -0.3538681 0.3805418 -0.3583571 -0.1484152 -0.9217122 -0.9063459 -0.3754112 0.1939162 -0.6965101 -0.1385268 -0.7040483 -0.6965101 -0.1385268 0.7040483 -0.8173288 -0.1625746 0.5527598 -0.5490075 -0.1091972 -0.8286537 -0.9069971 -0.1803984 0.3805426 -0.3804228 -0.0756573 -0.9217128 -0.9621686 -0.1913838 0.1939169 -0.1970922 -0.03918647 -0.9796015 -0.9807879 -0.1950772 0 -0.1970922 -0.03918647 0.9796015 -0.9621686 -0.1913838 -0.1939169 -0.3804228 -0.0756573 0.9217128 -0.9069971 -0.1803984 -0.3805426 -0.5490075 -0.1091972 0.8286537 -0.8173288 -0.1625746 -0.5527598</float_array>
+          <technique_common>
+            <accessor source="#Sphere-mesh-normals-array" count="482" stride="3">
+              <param name="X" type="float"/>
+              <param name="Y" type="float"/>
+              <param name="Z" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="Sphere-mesh-map-0">
+          <float_array id="Sphere-mesh-map-0-array" count="5760">0.9059244 0.648066 0.8793093 0.575425 0.9111002 0.5863247 0.5885478 0.9479513 0.492715 0.901747 0.6003652 0.9365409 0.9925565 0.09833276 0.9612628 0.1561555 0.9490643 0.1517305 0.9111002 0.5863247 0.8854812 0.5141399 0.9157391 0.5245054 0.5885478 0.9479513 0.7432609 0.92181 0.7778791 0.9406516 0.9202389 0.4626654 0.8854812 0.5141399 0.891547 0.4528335 0.8514901 0.8900356 0.7432609 0.92181 0.8089643 0.8738581 0.9202389 0.4626654 0.8979759 0.3915975 0.9249518 0.4008553 0.8514901 0.8900356 0.8377025 0.8171976 0.8776648 0.8314287 0.9303008 0.3391364 0.8979759 0.3915975 0.9053563 0.3305478 0.8776648 0.8314287 0.8537325 0.7578838 0.8910649 0.7708927 0.9303008 0.3391364 0.9146354 0.2698729 0.9369508 0.2776051 0.8910649 0.7708927 0.864425 0.6974942 0.8996179 0.7096431 0.9369508 0.2776051 0.9276896 0.2099514 0.9462066 0.2164527 0.8996179 0.7096431 0.8725281 0.63659 0.9059244 0.648066 0.9462066 0.2164527 0.9490643 0.1517305 0.9612628 0.1561555 0.9146354 0.2698729 0.9091555 0.2014223 0.9276896 0.2099514 0.864425 0.6974942 0.8400784 0.6222586 0.8725281 0.63659 0.9276896 0.2099514 0.9371914 0.1459214 0.9490643 0.1517305 0.8725281 0.63659 0.8481039 0.5616871 0.8793093 0.575425 0.6003652 0.9365409 0.492715 0.901747 0.6036882 0.9244517 0.9925565 0.09833276 0.9490643 0.1517305 0.9371914 0.1459214 0.8854812 0.5141399 0.8481039 0.5616871 0.8555443 0.5009738 0.6003652 0.9365409 0.716214 0.9029137 0.7432609 0.92181 0.891547 0.4528335 0.8555443 0.5009738 0.8629761 0.4402579 0.7432609 0.92181 0.7729267 0.8557598 0.8089643 0.8738581 0.891547 0.4528335 0.8709729 0.379678 0.8979759 0.3915975 0.8089643 0.8738581 0.801494 0.8004049 0.8377025 0.8171976 0.9053563 0.3305478 0.8709729 0.379678 0.8802902 0.3194179 0.8377025 0.8171976 0.8186983 0.7421017 0.8537325 0.7578838 0.9053563 0.3305478 0.8921813 0.2597874 0.9146354 0.2698729 0.8537325 0.7578838 0.8307024 0.6825021 0.864425 0.6974942 0.8709729 0.379678 0.8344583 0.4253514 0.8438495 0.3654333 0.7729267 0.8557598 0.7684796 0.7821101 0.801494 0.8004049 0.8802902 0.3194179 0.8438495 0.3654333 0.8549924 0.3060064 0.801494 0.8004049 0.7858012 0.7244532 0.8186983 0.7421017 0.8802902 0.3194179 0.8694851 0.2475308 0.8921813 0.2597874 0.8186983 0.7421017 0.7984084 0.6654416 0.8307024 0.6825021 0.8921813 0.2597874 0.8905657 0.1909774 0.9091555 0.2014223 0.8400784 0.6222586 0.7984084 0.6654416 0.8085606 0.6057375 0.9091555 0.2014223 0.9257678 0.1388037 0.9371914 0.1459214 0.8400784 0.6222586 0.8174625 0.545684 0.8481039 0.5616871 0.6036882 0.9244517 0.492715 0.901747 0.6018056 0.9123151 0.9925565 0.09833276 0.9371914 0.1459214 0.9257678 0.1388037 0.8481039 0.5616871 0.8258861 0.4854972 0.8555443 0.5009738 0.6036882 0.9244517 0.6929221 0.8844928 0.716214 0.9029137 0.8555443 0.5009738 0.8344583 0.4253514 0.8629761 0.4402579 0.716214 0.9029137 0.7415011 0.8368797 0.7729267 0.8557598 0.8905657 0.1909774 0.9149493 0.1304721 0.9257678 0.1388037 0.8174625 0.545684 0.7778562 0.5877237 0.7872828 0.5280401 0.6018056 0.9123151 0.492715 0.901747 0.5966135 0.9005175 0.9925565 0.09833276 0.9257678 0.1388037 0.9149493 0.1304721 0.8174625 0.545684 0.7963992 0.4682622 0.8258861 0.4854972 0.6018056 0.9123151 0.6716771 0.8668765 0.6929221 0.8844928 0.8258861 0.4854972 0.8058689 0.4085916 0.8344583 0.4253514 0.6929221 0.8844928 0.7132369 0.8180087 0.7415011 0.8368797 0.8438495 0.3654333 0.8058689 0.4085916 0.8164588 0.3492626 0.7415011 0.8368797 0.7379783 0.7631925 0.7684796 0.7821101 0.8438495 0.3654333 0.8292981 0.2906265 0.8549924 0.3060064 0.7684796 0.7821101 0.7547137 0.7057771 0.7858012 0.7244532 0.8549924 0.3060064 0.8463905 0.2333244 0.8694851 0.2475308 0.7858012 0.7244532 0.7673649 0.6470826 0.7984084 0.6654416 0.8694851 0.2475308 0.8718526 0.1787505 0.8905657 0.1909774 0.7984084 0.6654416 0.7778562 0.5877237 0.8085606 0.6057375 0.7132369 0.8180087 0.7093584 0.7443683 0.7379783 0.7631925 0.8164588 0.3492626 0.8029742 0.2736449 0.8292981 0.2906265 0.7547137 0.7057771 0.7093584 0.7443683 0.7250548 0.6868199 0.8463905 0.2333244 0.8029742 0.2736449 0.8226673 0.2174286 0.7547137 0.7057771 0.7373226 0.6281567 0.7673649 0.6470826 0.8718526 0.1787505 0.8226673 0.2174286 0.8529051 0.1648954 0.7673649 0.6470826 0.7477793 0.5689135 0.7778562 0.5877237 0.8718526 0.1787505 0.9049428 0.1210396 0.9149493 0.1304721 0.7872828 0.5280401 0.7477793 0.5689135 0.7574036 0.5094057 0.5966135 0.9005175 0.492715 0.901747 0.5892183 0.8893244 0.9925565 0.09833276 0.9149493 0.1304721 0.9049428 0.1210396 0.7872828 0.5280401 0.7669216 0.4498645 0.7963992 0.4682622 0.5966135 0.9005175 0.6516128 0.8503155 0.6716771 0.8668765 0.7963992 0.4682622 0.777029 0.3905105 0.8058689 0.4085916 0.6716771 0.8668765 0.687114 0.7997211 0.7132369 0.8180087 0.8164588 0.3492626 0.777029 0.3905105 0.7885947 0.3316226 0.7477793 0.5689135 0.7276275 0.4904417 0.7574036 0.5094057 0.5892183 0.8893244 0.492715 0.901747 0.5802933 0.8789367 0.9925565 0.09833276 0.9049428 0.1210396 0.8960399 0.1106414 0.7574036 0.5094057 0.7372524 0.4309325 0.7669216 0.4498645 0.5892183 0.8893244 0.6322468 0.8350224 0.6516128 0.8503155 0.7669216 0.4498645 0.7477135 0.3716894 0.777029 0.3905105 0.6516128 0.8503155 0.6624315 0.7824597 0.687114 0.7997211 0.7885947 0.3316226 0.7477135 0.3716894 0.7599906 0.3130286 0.687114 0.7997211 0.6820942 0.7262273 0.7093584 0.7443683 0.8029742 0.2736449 0.7599906 0.3130286 0.7757045 0.2554866 0.7250548 0.6868199 0.6820942 0.7262273 0.6964557 0.6682395 0.8029742 0.2736449 0.7979819 0.2001475 0.8226673 0.2174286 0.7250548 0.6868199 0.7080108 0.6093447 0.7373226 0.6281567 0.8529051 0.1648954 0.7979819 0.2001475 0.8335457 0.149583 0.7477793 0.5689135 0.7080108 0.6093447 0.718112 0.5499861 0.8529051 0.1648954 0.8960399 0.1106414 0.9049428 0.1210396 0.7757045 0.2554866 0.7303221 0.294062 0.747074 0.2366482 0.6820942 0.7262273 0.6685932 0.650616 0.6964557 0.6682395 0.7757045 0.2554866 0.771851 0.1818418 0.7979819 0.2001475 0.6964557 0.6682395 0.6791713 0.5912767 0.7080108 0.6093447 0.7979819 0.2001475 0.8134869 0.1330032 0.8335457 0.149583 0.718112 0.5499861 0.6791713 0.5912767 0.6886333 0.5315973 0.8960399 0.1106414 0.8134869 0.1330032 0.8886731 0.09943968 0.718112 0.5499861 0.6977451 0.4718118 0.7276275 0.4904417 0.5802933 0.8789367 0.492715 0.901747 0.5702692 0.869516 0.9925565 0.09833276 0.8960399 0.1106414 0.8886731 0.09943968 0.7276275 0.4904417 0.7071703 0.4121221 0.7372524 0.4309325 0.5802933 0.8789367 0.6132923 0.821187 0.6322468 0.8350224 0.7372524 0.4309325 0.7176637 0.3527587 0.7477135 0.3716894 0.6322468 0.8350224 0.6387079 0.7665851 0.6624315 0.7824597 0.7599906 0.3130286 0.7176637 0.3527587 0.7303221 0.294062 0.6820942 0.7262273 0.6387079 0.7665851 0.6557719 0.7092652 0.5702692 0.869516 0.492715 0.901747 0.5594361 0.8611971 0.9925565 0.09833276 0.8886731 0.09943968 0.8835193 0.08763581 0.7071703 0.4121221 0.6675595 0.4541771 0.6764574 0.3941132 0.5702692 0.869516 0.5945719 0.8089805 0.6132923 0.821187 0.7071703 0.4121221 0.6866088 0.3344001 0.7176637 0.3527587 0.6132923 0.821187 0.6156106 0.7524011 0.6387079 0.7665851 0.7303221 0.294062 0.6866088 0.3344001 0.6992201 0.2753812 0.6387079 0.7665851 0.6300765 0.6939069 0.6557719 0.7092652 0.7303221 0.294062 0.7165556 0.2177206 0.747074 0.2366482 0.6557719 0.7092652 0.6412011 0.6344648 0.6685932 0.650616 0.771851 0.1818418 0.7165556 0.2177206 0.7435711 0.1629553 0.6685932 0.650616 0.6505795 0.5745334 0.6791713 0.5912767 0.8134869 0.1330032 0.7435711 0.1629553 0.7922452 0.1153689 0.6886333 0.5315973 0.6505795 0.5745334 0.6591423 0.5143753 0.8886731 0.09943968 0.7922452 0.1153689 0.8835193 0.08763581 0.6886333 0.5315973 0.6675595 0.4541771 0.6977451 0.4718118 0.6412011 0.6344648 0.6047756 0.6805188 0.6140744 0.6202422 0.7435711 0.1629553 0.6835156 0.1994217 0.7121175 0.1440636 0.6412011 0.6344648 0.6220571 0.5596468 0.6505795 0.5745334 0.7435711 0.1629553 0.7689511 0.09693062 0.7922452 0.1153689 0.6591423 0.5143753 0.6220571 0.5596468 0.6294777 0.4989159 0.8835193 0.08763581 0.7689511 0.09693062 0.8816903 0.07549679 0.6591423 0.5143753 0.6369094 0.438188 0.6675595 0.4541771 0.5594361 0.8611971 0.492715 0.901747 0.5480003 0.8540929 0.9925565 0.09833276 0.8835193 0.08763581 0.8816903 0.07549679 0.6675595 0.4541771 0.644928 0.3776025 0.6764574 0.3941132 0.5945719 0.8089805 0.5480003 0.8540929 0.5759748 0.7985563 0.6764574 0.3941132 0.6542994 0.3173459 0.6866088 0.3344001 0.5945719 0.8089805 0.5929102 0.7401679 0.6156106 0.7524011 0.6992201 0.2753812 0.6542994 0.3173459 0.6663029 0.2577343 0.6156106 0.7524011 0.6047756 0.6805188 0.6300765 0.6939069 0.6992201 0.2753812 0.6835156 0.1994217 0.7165556 0.2177206 0.6369094 0.438188 0.6124644 0.3632876 0.644928 0.3776025 0.5480003 0.8540929 0.5574334 0.7900483 0.5759748 0.7985563 0.644928 0.3776025 0.6205583 0.3023672 0.6542994 0.3173459 0.5929102 0.7401679 0.5574334 0.7900483 0.570451 0.7301064 0.6663029 0.2577343 0.6205583 0.3023672 0.6312432 0.2419617 0.5929102 0.7401679 0.5797048 0.6694138 0.6047756 0.6805188 0.6663029 0.2577343 0.6472717 0.1826331 0.6835156 0.1994217 0.6047756 0.6805188 0.5870661 0.6083472 0.6140744 0.6202422 0.6835156 0.1994217 0.6760333 0.1259607 0.7121175 0.1440636 0.6140744 0.6202422 0.5934799 0.5470946 0.6220571 0.5596468 0.7689511 0.09693062 0.6760333 0.1259607 0.7418877 0.07801818 0.6294777 0.4989159 0.5934799 0.5470946 0.5995329 0.4857712 0.7689511 0.09693062 0.885091 0.06341117 0.8816903 0.07549679 0.6294777 0.4989159 0.6056935 0.4244693 0.6369094 0.438188 0.5480003 0.8540929 0.492715 0.901747 0.5361169 0.8482976 0.9925565 0.09833276 0.8816903 0.07549679 0.885091 0.06341117 0.6760333 0.1259607 0.6072647 0.1684171 0.6334344 0.1097899 0.5870661 0.6083472 0.5647808 0.537289 0.5934799 0.5470946 0.6760333 0.1259607 0.7072112 0.05916339 0.7418877 0.07801818 0.5995329 0.4857712 0.5647808 0.537289 0.5692661 0.4754315 0.7418877 0.07801818 0.8970212 0.05201429 0.885091 0.06341117 0.5995329 0.4857712 0.5738912 0.4135942 0.6056935 0.4244693 0.5361169 0.8482976 0.492715 0.901747 0.5239093 0.8438869 0.9925565 0.09833276 0.885091 0.06341117 0.8970212 0.05201429 0.6124644 0.3632876 0.5738912 0.4135942 0.579053 0.3518348 0.5361169 0.8482976 0.5389093 0.7835682 0.5574334 0.7900483 0.6124644 0.3632876 0.5853448 0.2902396 0.6205583 0.3023672 0.5574334 0.7900483 0.5481296 0.7223988 0.570451 0.7301064 0.6312432 0.2419617 0.5853448 0.2902396 0.5938816 0.2289718 0.570451 0.7301064 0.5547546 0.6608514 0.5797048 0.6694138 0.6312432 0.2419617 0.6072647 0.1684171 0.6472717 0.1826331 0.5870661 0.6083472 0.5547546 0.6608514 0.5600842 0.599116 0.579053 0.3518348 0.54882 0.2816787 0.5853448 0.2902396 0.5389093 0.7835682 0.5258811 0.7171856 0.5481296 0.7223988 0.5853448 0.2902396 0.5543729 0.2196655 0.5938816 0.2289718 0.5481296 0.7223988 0.5298588 0.6550331 0.5547546 0.6608514 0.5938816 0.2289718 0.5634034 0.1579628 0.6072647 0.1684171 0.5547546 0.6608514 0.5330832 0.5928134 0.5600842 0.599116 0.6334344 0.1097899 0.5634034 0.1579628 0.5825701 0.0971741 0.5600842 0.599116 0.5359469 0.5305616 0.5647808 0.537289 0.6334344 0.1097899 0.6550087 0.04154175 0.7072112 0.05916339 0.5692661 0.4754315 0.5359469 0.5305616 0.5387045 0.4683001 0.8970212 0.05201429 0.6550087 0.04154175 0.9226238 0.0424422 0.5692661 0.4754315 0.5415746 0.4060484 0.5738912 0.4135942 0.5239093 0.8438869 0.492715 0.901747 0.5114814 0.8409178 0.9925565 0.09833276 0.8970212 0.05201429 0.9226238 0.0424422 0.5738912 0.4135942 0.5448138 0.3438295 0.579053 0.3518348 0.5239093 0.8438869 0.5203842 0.7792032 0.5389093 0.7835682 0.5825701 0.0971741 0.5606263 0.02870553 0.6550087 0.04154175 0.5387045 0.4683001 0.5070113 0.5271458 0.5079368 0.4646666 0.9226238 0.0424422 0.5606263 0.02870553 0.9660401 0.03662568 0.5387045 0.4683001 0.5089053 0.4021884 0.5415746 0.4060484 0.5114814 0.8409178 0.492715 0.901747 0.4989255 0.8394287 0.9925565 0.09833276 0.9226238 0.0424422 0.9660401 0.03662568 0.5448138 0.3438295 0.5089053 0.4021884 0.5100055 0.3397141 0.5114814 0.8409178 0.5018534 0.7770128 0.5203842 0.7792032 0.5448138 0.3438295 0.5113775 0.2772482 0.54882 0.2816787 0.5203842 0.7792032 0.5036659 0.7145629 0.5258811 0.7171856 0.5543729 0.2196655 0.5113775 0.2772482 0.5133026 0.2147992 0.5298588 0.6550331 0.5036659 0.7145629 0.5049827 0.6520974 0.5543729 0.2196655 0.5165018 0.1523888 0.5634034 0.1579628 0.5330832 0.5928134 0.5049827 0.6520974 0.5060548 0.5896236 0.5825701 0.0971741 0.5165018 0.1523888 0.5236635 0.09009742 0.5330832 0.5928134 0.5070113 0.5271458 0.5359469 0.5305616 0.5036659 0.7145629 0.4833196 0.7770274 0.4814598 0.7145795 0.5133026 0.2147992 0.4736044 0.2772619 0.4716574 0.2148125 0.5036659 0.7145629 0.4801106 0.6521146 0.5049827 0.6520974 0.5133026 0.2147992 0.4684262 0.1524026 0.5165018 0.1523888 0.5049827 0.6520974 0.4790142 0.589641 0.5060548 0.5896236 0.5236635 0.09009742 0.4684262 0.1524026 0.4612001 0.09011387 0.5060548 0.5896236 0.4780379 0.5271627 0.5070113 0.5271458 0.5236635 0.09009742 0.4239621 0.02873963 0.5606263 0.02870553 0.5079368 0.4646666 0.4780379 0.5271627 0.4770951 0.4646827 0.5606263 0.02870553 1.019296 0.03663933 0.9660401 0.03662568 0.5079368 0.4646666 0.4761104 0.4022036 0.5089053 0.4021884 0.4989255 0.8394287 0.492715 0.901747 0.486328 0.8394391 0.9925565 0.09833276 0.9660401 0.03662568 1.019296 0.03663933 0.5089053 0.4021884 0.4749941 0.3397284 0.5100055 0.3397141 0.4989255 0.8394287 0.4833196 0.7770274 0.5018534 0.7770128 0.5100055 0.3397141 0.4736044 0.2772619 0.5113775 0.2772482 0.4770951 0.4646827 0.4491014 0.5306118 0.4463269 0.468348 0.01929616 0.03663933 0.3298254 0.04161161 0.06264001 0.04247719 0.4770951 0.4646827 0.4434411 0.4060937 0.4761104 0.4022036 0.486328 0.8394391 0.492715 0.901747 0.4737731 0.8409487 0.9925565 0.09833276 1.019296 0.03663933 1.06264 0.04247719 0.4761104 0.4022036 0.4401866 0.3438721 0.4749941 0.3397284 0.486328 0.8394391 0.4647885 0.7792469 0.4833196 0.7770274 0.4749941 0.3397284 0.4361638 0.281719 0.4736044 0.2772619 0.4833196 0.7770274 0.4592436 0.7172351 0.4814598 0.7145795 0.4716574 0.2148125 0.4361638 0.281719 0.4305911 0.2197046 0.4814598 0.7145795 0.4552333 0.6550847 0.4801106 0.6521146 0.4716574 0.2148125 0.4215336 0.1580027 0.4684262 0.1524026 0.4801106 0.6521146 0.4519847 0.5928651 0.4790142 0.589641 0.4684262 0.1524026 0.4023212 0.09721994 0.4612001 0.09011387 0.4790142 0.589641 0.4491014 0.5306118 0.4780379 0.5271627 0.4612001 0.09011387 0.3298254 0.04161161 0.4239621 0.02873963 0.4305911 0.2197046 0.3996422 0.2903048 0.3910893 0.2290341 0.4552333 0.6550847 0.436993 0.7224807 0.4303352 0.6609367 0.4305911 0.2197046 0.3776866 0.1684792 0.4215336 0.1580027 0.4552333 0.6550847 0.4249814 0.5992012 0.4519847 0.5928651 0.4023212 0.09721994 0.3776866 0.1684792 0.3514931 0.1098571 0.4519847 0.5928651 0.4202656 0.5373717 0.4491014 0.5306118 0.4023212 0.09721994 0.277736 0.05924415 0.3298254 0.04161161 0.4463269 0.468348 0.4202656 0.5373717 0.4157641 0.4755103 0.06264001 0.04247719 0.277736 0.05924415 0.08817166 0.05206078 0.4463269 0.468348 0.4111244 0.4136683 0.4434411 0.4060937 0.4737731 0.8409487 0.492715 0.901747 0.4613473 0.8439381 0.9925565 0.09833276 1.06264 0.04247719 1.088172 0.05206078 0.4434411 0.4060937 0.4059485 0.3519042 0.4401866 0.3438721 0.4737731 0.8409487 0.4462627 0.7836406 0.4647885 0.7792469 0.4401866 0.3438721 0.3996422 0.2903048 0.4361638 0.281719 0.4592436 0.7172351 0.4462627 0.7836406 0.436993 0.7224807 0.277736 0.05924415 0.1000552 0.06346303 0.08817166 0.05206078 0.4157641 0.4755103 0.3793213 0.4245703 0.4111244 0.4136683 0.4613473 0.8439381 0.492715 0.901747 0.449143 0.8483685 0.9925565 0.09833276 1.088172 0.05206078 1.100055 0.06346303 0.4111244 0.4136683 0.3725381 0.3633816 0.4059485 0.3519042 0.4613473 0.8439381 0.4277372 0.7901487 0.4462627 0.7836406 0.4059485 0.3519042 0.3644323 0.3024546 0.3996422 0.2903048 0.4462627 0.7836406 0.4146683 0.7302197 0.436993 0.7224807 0.3910893 0.2290341 0.3644323 0.3024546 0.3537352 0.2420439 0.4303352 0.6609367 0.4146683 0.7302197 0.4053811 0.6695316 0.3910893 0.2290341 0.3376945 0.1827127 0.3776866 0.1684792 0.4249814 0.5992012 0.4053811 0.6695316 0.3979957 0.6084646 0.3776866 0.1684792 0.3089248 0.1260416 0.3514931 0.1098571 0.4249814 0.5992012 0.3915634 0.5472081 0.4202656 0.5373717 0.3514931 0.1098571 0.2431051 0.07810217 0.277736 0.05924415 0.4157641 0.4755103 0.3915634 0.5472081 0.3854953 0.4858791 0.4053811 0.6695316 0.392204 0.7403113 0.3803044 0.6806673 0.3537352 0.2420439 0.3014633 0.1995143 0.3376945 0.1827127 0.3979957 0.6084646 0.3803044 0.6806673 0.370982 0.6203895 0.3376945 0.1827127 0.2728623 0.1441527 0.3089248 0.1260416 0.3979957 0.6084646 0.3629816 0.5597888 0.3915634 0.5472081 0.2431051 0.07810217 0.2728623 0.1441527 0.2160624 0.09701496 0.3854953 0.4858791 0.3629816 0.5597888 0.355547 0.4990501 0.1000552 0.06346303 0.2160624 0.09701496 0.1034273 0.07555043 0.3854953 0.4858791 0.3481036 0.4383131 0.3793213 0.4245703 0.449143 0.8483685 0.492715 0.901747 0.4372645 0.8541828 0.9925565 0.09833276 1.100055 0.06346303 1.103427 0.07555043 0.3725381 0.3633816 0.3481036 0.4383131 0.3400747 0.377718 0.449143 0.8483685 0.4091939 0.7986839 0.4277372 0.7901487 0.3725381 0.3633816 0.3306941 0.3174523 0.3644323 0.3024546 0.4277372 0.7901487 0.392204 0.7403113 0.4146683 0.7302197 0.3537352 0.2420439 0.3306941 0.3174523 0.3186824 0.2578327 0.355547 0.4990501 0.3174503 0.4543229 0.3481036 0.4383131 0.4372645 0.8541828 0.492715 0.901747 0.4258353 0.8613048 0.9925565 0.09833276 1.103427 0.07555043 1.10158 0.08768939 0.3481036 0.4383131 0.3085443 0.3942467 0.3400747 0.377718 0.4372645 0.8541828 0.3905939 0.809134 0.4091939 0.7986839 0.3400747 0.377718 0.2983864 0.3345217 0.3306941 0.3174523 0.4091939 0.7986839 0.3694965 0.7525728 0.392204 0.7403113 0.3186824 0.2578327 0.2983864 0.3345217 0.2857701 0.2754919 0.392204 0.7403113 0.3549953 0.6940838 0.3803044 0.6806673 0.3186824 0.2578327 0.2684326 0.217822 0.3014633 0.1995143 0.370982 0.6203895 0.3549953 0.6940838 0.3438475 0.6346392 0.2728623 0.1441527 0.2684326 0.217822 0.2414228 0.1630486 0.370982 0.6203895 0.3344526 0.5747007 0.3629816 0.5597888 0.2728623 0.1441527 0.1927784 0.1154518 0.2160624 0.09701496 0.355547 0.4990501 0.3344526 0.5747007 0.3258773 0.5145326 0.1034273 0.07555043 0.1927784 0.1154518 0.10158 0.08768939 0.2857701 0.2754919 0.2379202 0.2367545 0.2684326 0.217822 0.3438475 0.6346392 0.3292887 0.7094673 0.3164449 0.6508139 0.2684326 0.217822 0.2131515 0.1819364 0.2414228 0.1630486 0.3438475 0.6346392 0.3058518 0.5914652 0.3344526 0.5747007 0.2414228 0.1630486 0.1715415 0.1330838 0.1927784 0.1154518 0.3258773 0.5145326 0.3058518 0.5914652 0.2963792 0.5317736 0.1927784 0.1154518 0.09641396 0.09949165 0.10158 0.08768939 0.3174503 0.4543229 0.2963792 0.5317736 0.2872596 0.4719741 0.4258353 0.8613048 0.492715 0.901747 0.4150114 0.8696404 0.9925565 0.09833276 1.10158 0.08768939 1.096414 0.09949165 0.3174503 0.4543229 0.2778287 0.4122695 0.3085443 0.3942467 0.4258353 0.8613048 0.3718692 0.8213651 0.3905939 0.809134 0.3085443 0.3942467 0.2673314 0.3528915 0.2983864 0.3345217 0.3905939 0.809134 0.3463891 0.7667828 0.3694965 0.7525728 0.2857701 0.2754919 0.2673314 0.3528915 0.2546709 0.2941809 0.3549953 0.6940838 0.3463891 0.7667828 0.3292887 0.7094673 0.9925565 0.09833276 1.096414 0.09949165 1.089038 0.1106907 0.2872596 0.4719741 0.247742 0.4310891 0.2778287 0.4122695 0.4150114 0.8696404 0.3529083 0.8352231 0.3718692 0.8213651 0.2778287 0.4122695 0.2372796 0.3718289 0.2673314 0.3528915 0.3718692 0.8213651 0.3226514 0.7826805 0.3463891 0.7667828 0.2546709 0.2941809 0.2372796 0.3718289 0.225003 0.3131518 0.3292887 0.7094673 0.3226514 0.7826805 0.3029512 0.7264504 0.2546709 0.2941809 0.2092928 0.2555946 0.2379202 0.2367545 0.3164449 0.6508139 0.3029512 0.7264504 0.2885685 0.668456 0.2379202 0.2367545 0.1870253 0.2002409 0.2131515 0.1819364 0.3164449 0.6508139 0.2770006 0.6095497 0.3058518 0.5914652 0.1715415 0.1330838 0.1870253 0.2002409 0.1514846 0.1496599 0.2963792 0.5317736 0.2770006 0.6095497 0.2668911 0.5501763 0.1715415 0.1330838 0.08903849 0.1106907 0.09641396 0.09949165 0.2963792 0.5317736 0.2573703 0.4906155 0.2872596 0.4719741 0.4150114 0.8696404 0.492715 0.901747 0.4049999 0.8790763 0.2092928 0.2555946 0.162342 0.2175185 0.1870253 0.2002409 0.2885685 0.668456 0.2476739 0.6283716 0.2770006 0.6095497 0.1514846 0.1496599 0.162342 0.2175185 0.1321256 0.1649673 0.2668911 0.5501763 0.2476739 0.6283716 0.2372119 0.5691114 0.08903849 0.1106907 0.1321256 0.1649673 0.08012908 0.1210855 0.2668911 0.5501763 0.2275851 0.5095852 0.2573703 0.4906155 0.4049999 0.8790763 0.492715 0.901747 0.3960925 0.8894771 0.9925565 0.09833276 1.089038 0.1106907 1.080129 0.1210855 0.2573703 0.4906155 0.2180665 0.4500249 0.247742 0.4310891 0.4049999 0.8790763 0.3335328 0.8505368 0.3529083 0.8352231 0.247742 0.4310891 0.2079604 0.390652 0.2372796 0.3718289 0.3529083 0.8352231 0.2979491 0.799961 0.3226514 0.7826805 0.225003 0.3131518 0.2079604 0.390652 0.1963976 0.3317459 0.3029512 0.7264504 0.2979491 0.799961 0.2756667 0.7446073 0.2092928 0.2555946 0.1963976 0.3317459 0.182024 0.2737511 0.2885685 0.668456 0.2756667 0.7446073 0.2599516 0.6870493 0.3335328 0.8505368 0.3887225 0.9006809 0.3134537 0.867116 0.2180665 0.4500249 0.1791153 0.4087299 0.2079604 0.390652 0.3335328 0.8505368 0.2717982 0.8182626 0.2979491 0.799961 0.1963976 0.3317459 0.1791153 0.4087299 0.1685307 0.3493819 0.2756667 0.7446073 0.2717982 0.8182626 0.2470199 0.7634406 0.1963976 0.3317459 0.1556993 0.2907277 0.182024 0.2737511 0.2599516 0.6870493 0.2470199 0.7634406 0.23027 0.7060118 0.182024 0.2737511 0.1386191 0.2334085 0.162342 0.2175185 0.2599516 0.6870493 0.2176133 0.6473003 0.2476739 0.6283716 0.1321256 0.1649673 0.1386191 0.2334085 0.1131775 0.1788164 0.2372119 0.5691114 0.2176133 0.6473003 0.2071207 0.5879223 0.1321256 0.1649673 0.07011771 0.1305137 0.08012908 0.1210855 0.2372119 0.5691114 0.197695 0.5282186 0.2275851 0.5095852 0.3960925 0.8894771 0.492715 0.901747 0.3887225 0.9006809 0.9925565 0.09833276 1.080129 0.1210855 1.070118 0.1305137 0.2275851 0.5095852 0.1885811 0.4684205 0.2180665 0.4500249 0.23027 0.7060118 0.1865485 0.665653 0.2176133 0.6473003 0.1131775 0.1788164 0.1155236 0.2476066 0.09446328 0.1910358 0.2071207 0.5879223 0.1865485 0.665653 0.1764 0.6059286 0.1131775 0.1788164 0.05929529 0.1388404 0.07011771 0.1305137 0.2071207 0.5879223 0.1675031 0.5458543 0.197695 0.5282186 0.3887225 0.9006809 0.492715 0.901747 0.3835681 0.912486 0.9925565 0.09833276 1.070118 0.1305137 1.059295 0.1388404 0.1885811 0.4684205 0.1675031 0.5458543 0.1590852 0.4856469 0.3134537 0.867116 0.3835681 0.912486 0.292185 0.8847473 0.1885811 0.4684205 0.1505197 0.4254812 0.1791153 0.4087299 0.3134537 0.867116 0.243494 0.837141 0.2717982 0.8182626 0.1685307 0.3493819 0.1505197 0.4254812 0.1411362 0.3655441 0.2470199 0.7634406 0.243494 0.837141 0.2164838 0.7823588 0.1685307 0.3493819 0.1300031 0.3060992 0.1556993 0.2907277 0.2470199 0.7634406 0.199155 0.7246842 0.23027 0.7060118 0.1386191 0.2334085 0.1300031 0.3060992 0.1155236 0.2476066 0.1590852 0.4856469 0.1219953 0.4403737 0.1505197 0.4254812 0.292185 0.8847473 0.2120112 0.856019 0.243494 0.837141 0.1411362 0.3655441 0.1219953 0.4403737 0.1140086 0.379776 0.2164838 0.7823588 0.2120112 0.856019 0.1834254 0.8006429 0.1411362 0.3655441 0.1047028 0.3194993 0.1300031 0.3060992 0.199155 0.7246842 0.1834254 0.8006429 0.1662256 0.7423182 0.1300031 0.3060992 0.09282612 0.2598529 0.1155236 0.2476066 0.199155 0.7246842 0.1542308 0.6826973 0.1865485 0.665653 0.09446328 0.1910358 0.09282612 0.2598529 0.07587218 0.2014721 0.1764 0.6059286 0.1542308 0.6826973 0.1448646 0.6224332 0.09446328 0.1910358 0.04786872 0.1459523 0.05929529 0.1388404 0.1764 0.6059286 0.1368486 0.5618414 0.1675031 0.5458543 0.3835681 0.912486 0.492715 0.901747 0.3817437 0.9246256 0.9925565 0.09833276 1.059295 0.1388404 1.047869 0.1459523 0.1590852 0.4856469 0.1368486 0.5618414 0.1294175 0.5011084 0.292185 0.8847473 0.3817437 0.9246256 0.2688526 0.9031792 0.07587218 0.2014721 0.07037049 0.2699261 0.05733662 0.2099915 0.1448646 0.6224332 0.1204835 0.6976624 0.1123972 0.6367389 0.07587218 0.2014721 0.03599351 0.1517553 0.04786872 0.1459523 0.1448646 0.6224332 0.1056304 0.5755556 0.1368486 0.5618414 0.3817437 0.9246256 0.492715 0.901747 0.385161 0.9367107 0.9925565 0.09833276 1.047869 0.1459523 1.035994 0.1517553 0.1368486 0.5618414 0.09947144 0.514253 0.1294175 0.5011084 0.3817437 0.9246256 0.2417302 0.9220808 0.2688526 0.9031792 0.1294175 0.5011084 0.093418 0.45293 0.1219953 0.4403737 0.2688526 0.9031792 0.1758925 0.8741014 0.2120112 0.856019 0.1140086 0.379776 0.093418 0.45293 0.0870012 0.3916786 0.1834254 0.8006429 0.1758925 0.8741014 0.1471639 0.817411 0.1140086 0.379776 0.07963401 0.3306146 0.1047028 0.3194993 0.1834254 0.8006429 0.131156 0.7580731 0.1662256 0.7423182 0.1047028 0.3194993 0.07037049 0.2699261 0.09282612 0.2598529 0.1662256 0.7423182 0.1204835 0.6976624 0.1542308 0.6826973 0.1758925 0.8741014 0.2069531 0.9409168 0.1332573 0.8902431 0.0870012 0.3916786 0.06472045 0.4627382 0.06002157 0.4009161 0.1471639 0.817411 0.1332573 0.8902431 0.1071433 0.8316007 0.0870012 0.3916786 0.05468714 0.3391861 0.07963401 0.3306146 0.131156 0.7580731 0.1071433 0.8316007 0.09378856 0.7710414 0.07963401 0.3306146 0.04805356 0.2776444 0.07037049 0.2699261 0.131156 0.7580731 0.08526748 0.7097733 0.1204835 0.6976624 0.05733662 0.2099915 0.04805356 0.2776444 0.03881853 0.2164819 0.1123972 0.6367389 0.08526748 0.7097733 0.07898485 0.6481801 0.05733662 0.2099915 0.02379328 0.1561736 0.03599351 0.1517553 0.1123972 0.6367389 0.07382827 0.5864241 0.1056304 0.5755556 0.385161 0.9367107 0.492715 0.901747 0.3971338 0.9481052 0.9925565 0.09833276 1.035994 0.1517553 1.023793 0.1561736 0.09947144 0.514253 0.07382827 0.5864241 0.06920558 0.524591 0.385161 0.9367107 0.2069531 0.9409168 0.2417302 0.9220808 0.09947144 0.514253 0.06472045 0.4627382 0.093418 0.45293 0.07898485 0.6481801 0.04874467 0.7183161 0.04474818 0.6561728 0.03881853 0.2164819 0.0113722 0.1591499 0.02379328 0.1561736 0.07898485 0.6481801 0.04151457 0.5939623 0.07382827 0.5864241 0.3971338 0.9481052 0.492715 0.901747 0.4228305 0.9576696 0.9925565 0.09833276 1.023793 0.1561736 1.011372 0.1591499 0.06920558 0.524591 0.04151457 0.5939623 0.03864717 0.5317196 0.3971338 0.9481052 0.1545662 0.9585033 0.2069531 0.9409168 0.06920558 0.524591 0.03589004 0.4694672 0.06472045 0.4627382 0.2069531 0.9409168 0.08236718 0.9028213 0.1332573 0.8902431 0.06002157 0.4009161 0.03589004 0.4694672 0.03302448 0.4072239 0.1332573 0.8902431 0.06327778 0.8420249 0.1071433 0.8316007 0.06002157 0.4009161 0.02979582 0.3450124 0.05468714 0.3391861 0.09378856 0.7710414 0.06327778 0.8420249 0.05428034 0.7803239 0.05468714 0.3391861 0.02581018 0.2828674 0.04805356 0.2776444 0.09378856 0.7710414 0.04874467 0.7183161 0.08526748 0.7097733 0.04805356 0.2776444 0.02029967 0.2208569 0.03881853 0.2164819 0.03302448 0.4072239 0.006959736 0.4728841 0.006001472 0.4104183 0.08236718 0.9028213 0.01638609 0.8475685 0.06327778 0.8420249 0.03302448 0.4072239 0.00492531 0.3479555 0.02979582 0.3450124 0.05428034 0.7803239 0.01638609 0.8475685 0.01321828 0.785167 0.02581018 0.2828674 0.00492531 0.3479555 0.003600955 0.285499 0.05428034 0.7803239 0.01130914 0.7227291 0.04874467 0.7183161 0.02581018 0.2828674 0.001775324 0.2230563 0.02029967 0.2208569 0.04474818 0.6561728 0.01130914 0.7227291 0.009946048 0.6602758 1.0203 0.2208569 0.9988229 0.1606459 1.011372 0.1591499 0.04151457 0.5939623 0.009946048 0.6602758 0.008850932 0.5978149 0.4228305 0.9576696 0.492715 0.901747 0.4663997 0.9634672 0.9925565 0.09833276 1.011372 0.1591499 0.9988229 0.1606459 0.04151457 0.5939623 0.00788486 0.5353502 0.03864717 0.5317196 0.4228305 0.9576696 0.05996555 0.9712674 0.1545662 0.9585033 0.03864717 0.5317196 0.006959736 0.4728841 0.03589004 0.4694672 0.1545662 0.9585033 0.02346807 0.9098559 0.08236718 0.9028213 1.001775 0.2230563 0.9862315 0.1606423 0.9988229 0.1606459 1.009946 0.6602758 0.9760642 0.5977937 1.008851 0.5978149 0.4663997 0.9634672 0.492715 0.901747 0.5197656 0.9634217 0.9925565 0.09833276 0.9988229 0.1606459 0.9862315 0.1606423 1.008851 0.5978149 0.9770506 0.535332 1.007885 0.5353502 1.059966 0.9712674 0.5197656 0.9634217 0.9236539 0.9711539 1.007885 0.5353502 0.9779933 0.4728688 1.00696 0.4728841 1.023468 0.9098559 0.9236539 0.9711539 0.9610577 0.9098034 1.006001 0.4104183 0.9779933 0.4728688 0.9789676 0.4104056 1.016386 0.8475685 0.9610577 0.9098034 0.9683353 0.847529 1.006001 0.4104183 0.9800599 0.3479452 1.004925 0.3479555 1.013218 0.785167 0.9683353 0.847529 0.9715889 0.7851341 1.004925 0.3479555 0.9814017 0.2854908 1.003601 0.285499 1.013218 0.785167 0.9735478 0.7227008 1.011309 0.7227291 1.003601 0.285499 0.9832485 0.2230503 1.001775 0.2230563 1.009946 0.6602758 0.9735478 0.7227008 0.9749442 0.6602513 0.9789676 0.4104056 0.9551903 0.3449817 0.9800599 0.3479452 0.9715889 0.7851341 0.9214769 0.841912 0.9305438 0.7802285 0.9800599 0.3479452 0.9591931 0.2828431 0.9814017 0.2854908 0.9715889 0.7851341 0.9361224 0.7182335 0.9735478 0.7227008 0.9814017 0.2854908 0.9647247 0.2208389 0.9832485 0.2230503 0.9749442 0.6602513 0.9361224 0.7182335 0.9401488 0.6561009 0.9862315 0.1606423 0.9647247 0.2208389 0.9736827 0.1591389 0.9749442 0.6602513 0.9434052 0.5939 0.9760642 0.5977937 0.5197656 0.9634217 0.492715 0.901747 0.5630894 0.9575534 0.9925565 0.09833276 0.9862315 0.1606423 0.9736827 0.1591389 0.9760642 0.5977937 0.9462915 0.5316662 0.9770506 0.535332 0.5197656 0.9634217 0.8298811 0.9582708 0.9236539 0.9711539 0.9770506 0.535332 0.9490651 0.4694219 0.9779933 0.4728688 0.9236539 0.9711539 0.9022539 0.902677 0.9610577 0.9098034 0.9789676 0.4104056 0.9490651 0.4694219 0.951946 0.4071862 0.9610577 0.9098034 0.9214769 0.841912 0.9683353 0.847529 0.5630894 0.9575534 0.492715 0.901747 0.5885478 0.9479513 0.9925565 0.09833276 0.9736827 0.1591389 0.9612628 0.1561555 0.9434052 0.5939 0.9157391 0.5245054 0.9462915 0.5316662 0.8298811 0.9582708 0.5885478 0.9479513 0.7778791 0.9406516 0.9462915 0.5316662 0.9202389 0.4626654 0.9490651 0.4694219 0.9022539 0.902677 0.7778791 0.9406516 0.8514901 0.8900356 0.9490651 0.4694219 0.9249518 0.4008553 0.951946 0.4071862 0.9214769 0.841912 0.8514901 0.8900356 0.8776648 0.8314287 0.951946 0.4071862 0.9303008 0.3391364 0.9551903 0.3449817 0.9305438 0.7802285 0.8776648 0.8314287 0.8910649 0.7708927 0.9551903 0.3449817 0.9369508 0.2776051 0.9591931 0.2828431 0.9361224 0.7182335 0.8910649 0.7708927 0.8996179 0.7096431 0.9591931 0.2828431 0.9462066 0.2164527 0.9647247 0.2208389 0.9401488 0.6561009 0.8996179 0.7096431 0.9059244 0.648066 0.9647247 0.2208389 0.9612628 0.1561555 0.9736827 0.1591389 0.9434052 0.5939 0.9059244 0.648066 0.9111002 0.5863247 0.9059244 0.648066 0.8725281 0.63659 0.8793093 0.575425 0.9111002 0.5863247 0.8793093 0.575425 0.8854812 0.5141399 0.5885478 0.9479513 0.6003652 0.9365409 0.7432609 0.92181 0.9202389 0.4626654 0.9157391 0.5245054 0.8854812 0.5141399 0.8514901 0.8900356 0.7778791 0.9406516 0.7432609 0.92181 0.9202389 0.4626654 0.891547 0.4528335 0.8979759 0.3915975 0.8514901 0.8900356 0.8089643 0.8738581 0.8377025 0.8171976 0.9303008 0.3391364 0.9249518 0.4008553 0.8979759 0.3915975 0.8776648 0.8314287 0.8377025 0.8171976 0.8537325 0.7578838 0.9303008 0.3391364 0.9053563 0.3305478 0.9146354 0.2698729 0.8910649 0.7708927 0.8537325 0.7578838 0.864425 0.6974942 0.9369508 0.2776051 0.9146354 0.2698729 0.9276896 0.2099514 0.8996179 0.7096431 0.864425 0.6974942 0.8725281 0.63659 0.9462066 0.2164527 0.9276896 0.2099514 0.9490643 0.1517305 0.9146354 0.2698729 0.8921813 0.2597874 0.9091555 0.2014223 0.864425 0.6974942 0.8307024 0.6825021 0.8400784 0.6222586 0.9276896 0.2099514 0.9091555 0.2014223 0.9371914 0.1459214 0.8725281 0.63659 0.8400784 0.6222586 0.8481039 0.5616871 0.8854812 0.5141399 0.8793093 0.575425 0.8481039 0.5616871 0.6003652 0.9365409 0.6036882 0.9244517 0.716214 0.9029137 0.891547 0.4528335 0.8854812 0.5141399 0.8555443 0.5009738 0.7432609 0.92181 0.716214 0.9029137 0.7729267 0.8557598 0.891547 0.4528335 0.8629761 0.4402579 0.8709729 0.379678 0.8089643 0.8738581 0.7729267 0.8557598 0.801494 0.8004049 0.9053563 0.3305478 0.8979759 0.3915975 0.8709729 0.379678 0.8377025 0.8171976 0.801494 0.8004049 0.8186983 0.7421017 0.9053563 0.3305478 0.8802902 0.3194179 0.8921813 0.2597874 0.8537325 0.7578838 0.8186983 0.7421017 0.8307024 0.6825021 0.8709729 0.379678 0.8629761 0.4402579 0.8344583 0.4253514 0.7729267 0.8557598 0.7415011 0.8368797 0.7684796 0.7821101 0.8802902 0.3194179 0.8709729 0.379678 0.8438495 0.3654333 0.801494 0.8004049 0.7684796 0.7821101 0.7858012 0.7244532 0.8802902 0.3194179 0.8549924 0.3060064 0.8694851 0.2475308 0.8186983 0.7421017 0.7858012 0.7244532 0.7984084 0.6654416 0.8921813 0.2597874 0.8694851 0.2475308 0.8905657 0.1909774 0.8400784 0.6222586 0.8307024 0.6825021 0.7984084 0.6654416 0.9091555 0.2014223 0.8905657 0.1909774 0.9257678 0.1388037 0.8400784 0.6222586 0.8085606 0.6057375 0.8174625 0.545684 0.8481039 0.5616871 0.8174625 0.545684 0.8258861 0.4854972 0.6036882 0.9244517 0.6018056 0.9123151 0.6929221 0.8844928 0.8555443 0.5009738 0.8258861 0.4854972 0.8344583 0.4253514 0.716214 0.9029137 0.6929221 0.8844928 0.7415011 0.8368797 0.8905657 0.1909774 0.8718526 0.1787505 0.9149493 0.1304721 0.8174625 0.545684 0.8085606 0.6057375 0.7778562 0.5877237 0.8174625 0.545684 0.7872828 0.5280401 0.7963992 0.4682622 0.6018056 0.9123151 0.5966135 0.9005175 0.6716771 0.8668765 0.8258861 0.4854972 0.7963992 0.4682622 0.8058689 0.4085916 0.6929221 0.8844928 0.6716771 0.8668765 0.7132369 0.8180087 0.8438495 0.3654333 0.8344583 0.4253514 0.8058689 0.4085916 0.7415011 0.8368797 0.7132369 0.8180087 0.7379783 0.7631925 0.8438495 0.3654333 0.8164588 0.3492626 0.8292981 0.2906265 0.7684796 0.7821101 0.7379783 0.7631925 0.7547137 0.7057771 0.8549924 0.3060064 0.8292981 0.2906265 0.8463905 0.2333244 0.7858012 0.7244532 0.7547137 0.7057771 0.7673649 0.6470826 0.8694851 0.2475308 0.8463905 0.2333244 0.8718526 0.1787505 0.7984084 0.6654416 0.7673649 0.6470826 0.7778562 0.5877237 0.7132369 0.8180087 0.687114 0.7997211 0.7093584 0.7443683 0.8164588 0.3492626 0.7885947 0.3316226 0.8029742 0.2736449 0.7547137 0.7057771 0.7379783 0.7631925 0.7093584 0.7443683 0.8463905 0.2333244 0.8292981 0.2906265 0.8029742 0.2736449 0.7547137 0.7057771 0.7250548 0.6868199 0.7373226 0.6281567 0.8718526 0.1787505 0.8463905 0.2333244 0.8226673 0.2174286 0.7673649 0.6470826 0.7373226 0.6281567 0.7477793 0.5689135 0.8718526 0.1787505 0.8529051 0.1648954 0.9049428 0.1210396 0.7872828 0.5280401 0.7778562 0.5877237 0.7477793 0.5689135 0.7872828 0.5280401 0.7574036 0.5094057 0.7669216 0.4498645 0.5966135 0.9005175 0.5892183 0.8893244 0.6516128 0.8503155 0.7963992 0.4682622 0.7669216 0.4498645 0.777029 0.3905105 0.6716771 0.8668765 0.6516128 0.8503155 0.687114 0.7997211 0.8164588 0.3492626 0.8058689 0.4085916 0.777029 0.3905105 0.7477793 0.5689135 0.718112 0.5499861 0.7276275 0.4904417 0.7574036 0.5094057 0.7276275 0.4904417 0.7372524 0.4309325 0.5892183 0.8893244 0.5802933 0.8789367 0.6322468 0.8350224 0.7669216 0.4498645 0.7372524 0.4309325 0.7477135 0.3716894 0.6516128 0.8503155 0.6322468 0.8350224 0.6624315 0.7824597 0.7885947 0.3316226 0.777029 0.3905105 0.7477135 0.3716894 0.687114 0.7997211 0.6624315 0.7824597 0.6820942 0.7262273 0.8029742 0.2736449 0.7885947 0.3316226 0.7599906 0.3130286 0.7250548 0.6868199 0.7093584 0.7443683 0.6820942 0.7262273 0.8029742 0.2736449 0.7757045 0.2554866 0.7979819 0.2001475 0.7250548 0.6868199 0.6964557 0.6682395 0.7080108 0.6093447 0.8529051 0.1648954 0.8226673 0.2174286 0.7979819 0.2001475 0.7477793 0.5689135 0.7373226 0.6281567 0.7080108 0.6093447 0.8529051 0.1648954 0.8335457 0.149583 0.8960399 0.1106414 0.7757045 0.2554866 0.7599906 0.3130286 0.7303221 0.294062 0.6820942 0.7262273 0.6557719 0.7092652 0.6685932 0.650616 0.7757045 0.2554866 0.747074 0.2366482 0.771851 0.1818418 0.6964557 0.6682395 0.6685932 0.650616 0.6791713 0.5912767 0.7979819 0.2001475 0.771851 0.1818418 0.8134869 0.1330032 0.718112 0.5499861 0.7080108 0.6093447 0.6791713 0.5912767 0.8960399 0.1106414 0.8335457 0.149583 0.8134869 0.1330032 0.718112 0.5499861 0.6886333 0.5315973 0.6977451 0.4718118 0.7276275 0.4904417 0.6977451 0.4718118 0.7071703 0.4121221 0.5802933 0.8789367 0.5702692 0.869516 0.6132923 0.821187 0.7372524 0.4309325 0.7071703 0.4121221 0.7176637 0.3527587 0.6322468 0.8350224 0.6132923 0.821187 0.6387079 0.7665851 0.7599906 0.3130286 0.7477135 0.3716894 0.7176637 0.3527587 0.6820942 0.7262273 0.6624315 0.7824597 0.6387079 0.7665851 0.7071703 0.4121221 0.6977451 0.4718118 0.6675595 0.4541771 0.5702692 0.869516 0.5594361 0.8611971 0.5945719 0.8089805 0.7071703 0.4121221 0.6764574 0.3941132 0.6866088 0.3344001 0.6132923 0.821187 0.5945719 0.8089805 0.6156106 0.7524011 0.7303221 0.294062 0.7176637 0.3527587 0.6866088 0.3344001 0.6387079 0.7665851 0.6156106 0.7524011 0.6300765 0.6939069 0.7303221 0.294062 0.6992201 0.2753812 0.7165556 0.2177206 0.6557719 0.7092652 0.6300765 0.6939069 0.6412011 0.6344648 0.771851 0.1818418 0.747074 0.2366482 0.7165556 0.2177206 0.6685932 0.650616 0.6412011 0.6344648 0.6505795 0.5745334 0.8134869 0.1330032 0.771851 0.1818418 0.7435711 0.1629553 0.6886333 0.5315973 0.6791713 0.5912767 0.6505795 0.5745334 0.8886731 0.09943968 0.8134869 0.1330032 0.7922452 0.1153689 0.6886333 0.5315973 0.6591423 0.5143753 0.6675595 0.4541771 0.6412011 0.6344648 0.6300765 0.6939069 0.6047756 0.6805188 0.7435711 0.1629553 0.7165556 0.2177206 0.6835156 0.1994217 0.6412011 0.6344648 0.6140744 0.6202422 0.6220571 0.5596468 0.7435711 0.1629553 0.7121175 0.1440636 0.7689511 0.09693062 0.6591423 0.5143753 0.6505795 0.5745334 0.6220571 0.5596468 0.8835193 0.08763581 0.7922452 0.1153689 0.7689511 0.09693062 0.6591423 0.5143753 0.6294777 0.4989159 0.6369094 0.438188 0.6675595 0.4541771 0.6369094 0.438188 0.644928 0.3776025 0.5945719 0.8089805 0.5594361 0.8611971 0.5480003 0.8540929 0.6764574 0.3941132 0.644928 0.3776025 0.6542994 0.3173459 0.5945719 0.8089805 0.5759748 0.7985563 0.5929102 0.7401679 0.6992201 0.2753812 0.6866088 0.3344001 0.6542994 0.3173459 0.6156106 0.7524011 0.5929102 0.7401679 0.6047756 0.6805188 0.6992201 0.2753812 0.6663029 0.2577343 0.6835156 0.1994217 0.6369094 0.438188 0.6056935 0.4244693 0.6124644 0.3632876 0.5480003 0.8540929 0.5361169 0.8482976 0.5574334 0.7900483 0.644928 0.3776025 0.6124644 0.3632876 0.6205583 0.3023672 0.5929102 0.7401679 0.5759748 0.7985563 0.5574334 0.7900483 0.6663029 0.2577343 0.6542994 0.3173459 0.6205583 0.3023672 0.5929102 0.7401679 0.570451 0.7301064 0.5797048 0.6694138 0.6663029 0.2577343 0.6312432 0.2419617 0.6472717 0.1826331 0.6047756 0.6805188 0.5797048 0.6694138 0.5870661 0.6083472 0.6835156 0.1994217 0.6472717 0.1826331 0.6760333 0.1259607 0.6140744 0.6202422 0.5870661 0.6083472 0.5934799 0.5470946 0.7689511 0.09693062 0.7121175 0.1440636 0.6760333 0.1259607 0.6294777 0.4989159 0.6220571 0.5596468 0.5934799 0.5470946 0.7689511 0.09693062 0.7418877 0.07801818 0.885091 0.06341117 0.6294777 0.4989159 0.5995329 0.4857712 0.6056935 0.4244693 0.6760333 0.1259607 0.6472717 0.1826331 0.6072647 0.1684171 0.5870661 0.6083472 0.5600842 0.599116 0.5647808 0.537289 0.6760333 0.1259607 0.6334344 0.1097899 0.7072112 0.05916339 0.5995329 0.4857712 0.5934799 0.5470946 0.5647808 0.537289 0.7418877 0.07801818 0.7072112 0.05916339 0.8970212 0.05201429 0.5995329 0.4857712 0.5692661 0.4754315 0.5738912 0.4135942 0.6124644 0.3632876 0.6056935 0.4244693 0.5738912 0.4135942 0.5361169 0.8482976 0.5239093 0.8438869 0.5389093 0.7835682 0.6124644 0.3632876 0.579053 0.3518348 0.5853448 0.2902396 0.5574334 0.7900483 0.5389093 0.7835682 0.5481296 0.7223988 0.6312432 0.2419617 0.6205583 0.3023672 0.5853448 0.2902396 0.570451 0.7301064 0.5481296 0.7223988 0.5547546 0.6608514 0.6312432 0.2419617 0.5938816 0.2289718 0.6072647 0.1684171 0.5870661 0.6083472 0.5797048 0.6694138 0.5547546 0.6608514 0.579053 0.3518348 0.5448138 0.3438295 0.54882 0.2816787 0.5389093 0.7835682 0.5203842 0.7792032 0.5258811 0.7171856 0.5853448 0.2902396 0.54882 0.2816787 0.5543729 0.2196655 0.5481296 0.7223988 0.5258811 0.7171856 0.5298588 0.6550331 0.5938816 0.2289718 0.5543729 0.2196655 0.5634034 0.1579628 0.5547546 0.6608514 0.5298588 0.6550331 0.5330832 0.5928134 0.6334344 0.1097899 0.6072647 0.1684171 0.5634034 0.1579628 0.5600842 0.599116 0.5330832 0.5928134 0.5359469 0.5305616 0.6334344 0.1097899 0.5825701 0.0971741 0.6550087 0.04154175 0.5692661 0.4754315 0.5647808 0.537289 0.5359469 0.5305616 0.8970212 0.05201429 0.7072112 0.05916339 0.6550087 0.04154175 0.5692661 0.4754315 0.5387045 0.4683001 0.5415746 0.4060484 0.5738912 0.4135942 0.5415746 0.4060484 0.5448138 0.3438295 0.5239093 0.8438869 0.5114814 0.8409178 0.5203842 0.7792032 0.5825701 0.0971741 0.5236635 0.09009742 0.5606263 0.02870553 0.5387045 0.4683001 0.5359469 0.5305616 0.5070113 0.5271458 0.9226238 0.0424422 0.6550087 0.04154175 0.5606263 0.02870553 0.5387045 0.4683001 0.5079368 0.4646666 0.5089053 0.4021884 0.5448138 0.3438295 0.5415746 0.4060484 0.5089053 0.4021884 0.5114814 0.8409178 0.4989255 0.8394287 0.5018534 0.7770128 0.5448138 0.3438295 0.5100055 0.3397141 0.5113775 0.2772482 0.5203842 0.7792032 0.5018534 0.7770128 0.5036659 0.7145629 0.5543729 0.2196655 0.54882 0.2816787 0.5113775 0.2772482 0.5298588 0.6550331 0.5258811 0.7171856 0.5036659 0.7145629 0.5543729 0.2196655 0.5133026 0.2147992 0.5165018 0.1523888 0.5330832 0.5928134 0.5298588 0.6550331 0.5049827 0.6520974 0.5825701 0.0971741 0.5634034 0.1579628 0.5165018 0.1523888 0.5330832 0.5928134 0.5060548 0.5896236 0.5070113 0.5271458 0.5036659 0.7145629 0.5018534 0.7770128 0.4833196 0.7770274 0.5133026 0.2147992 0.5113775 0.2772482 0.4736044 0.2772619 0.5036659 0.7145629 0.4814598 0.7145795 0.4801106 0.6521146 0.5133026 0.2147992 0.4716574 0.2148125 0.4684262 0.1524026 0.5049827 0.6520974 0.4801106 0.6521146 0.4790142 0.589641 0.5236635 0.09009742 0.5165018 0.1523888 0.4684262 0.1524026 0.5060548 0.5896236 0.4790142 0.589641 0.4780379 0.5271627 0.5236635 0.09009742 0.4612001 0.09011387 0.4239621 0.02873963 0.5079368 0.4646666 0.5070113 0.5271458 0.4780379 0.5271627 0.5606263 0.02870553 0.4239621 0.02873963 1.019296 0.03663933 0.5079368 0.4646666 0.4770951 0.4646827 0.4761104 0.4022036 0.5089053 0.4021884 0.4761104 0.4022036 0.4749941 0.3397284 0.4989255 0.8394287 0.486328 0.8394391 0.4833196 0.7770274 0.5100055 0.3397141 0.4749941 0.3397284 0.4736044 0.2772619 0.4770951 0.4646827 0.4780379 0.5271627 0.4491014 0.5306118 0.01929616 0.03663933 0.4239621 0.02873963 0.3298254 0.04161161 0.4770951 0.4646827 0.4463269 0.468348 0.4434411 0.4060937 0.4761104 0.4022036 0.4434411 0.4060937 0.4401866 0.3438721 0.486328 0.8394391 0.4737731 0.8409487 0.4647885 0.7792469 0.4749941 0.3397284 0.4401866 0.3438721 0.4361638 0.281719 0.4833196 0.7770274 0.4647885 0.7792469 0.4592436 0.7172351 0.4716574 0.2148125 0.4736044 0.2772619 0.4361638 0.281719 0.4814598 0.7145795 0.4592436 0.7172351 0.4552333 0.6550847 0.4716574 0.2148125 0.4305911 0.2197046 0.4215336 0.1580027 0.4801106 0.6521146 0.4552333 0.6550847 0.4519847 0.5928651 0.4684262 0.1524026 0.4215336 0.1580027 0.4023212 0.09721994 0.4790142 0.589641 0.4519847 0.5928651 0.4491014 0.5306118 0.4612001 0.09011387 0.4023212 0.09721994 0.3298254 0.04161161 0.4305911 0.2197046 0.4361638 0.281719 0.3996422 0.2903048 0.4552333 0.6550847 0.4592436 0.7172351 0.436993 0.7224807 0.4305911 0.2197046 0.3910893 0.2290341 0.3776866 0.1684792 0.4552333 0.6550847 0.4303352 0.6609367 0.4249814 0.5992012 0.4023212 0.09721994 0.4215336 0.1580027 0.3776866 0.1684792 0.4519847 0.5928651 0.4249814 0.5992012 0.4202656 0.5373717 0.4023212 0.09721994 0.3514931 0.1098571 0.277736 0.05924415 0.4463269 0.468348 0.4491014 0.5306118 0.4202656 0.5373717 0.06264001 0.04247719 0.3298254 0.04161161 0.277736 0.05924415 0.4463269 0.468348 0.4157641 0.4755103 0.4111244 0.4136683 0.4434411 0.4060937 0.4111244 0.4136683 0.4059485 0.3519042 0.4737731 0.8409487 0.4613473 0.8439381 0.4462627 0.7836406 0.4401866 0.3438721 0.4059485 0.3519042 0.3996422 0.2903048 0.4592436 0.7172351 0.4647885 0.7792469 0.4462627 0.7836406 0.277736 0.05924415 0.2431051 0.07810217 0.1000552 0.06346303 0.4157641 0.4755103 0.3854953 0.4858791 0.3793213 0.4245703 0.4111244 0.4136683 0.3793213 0.4245703 0.3725381 0.3633816 0.4613473 0.8439381 0.449143 0.8483685 0.4277372 0.7901487 0.4059485 0.3519042 0.3725381 0.3633816 0.3644323 0.3024546 0.4462627 0.7836406 0.4277372 0.7901487 0.4146683 0.7302197 0.3910893 0.2290341 0.3996422 0.2903048 0.3644323 0.3024546 0.4303352 0.6609367 0.436993 0.7224807 0.4146683 0.7302197 0.3910893 0.2290341 0.3537352 0.2420439 0.3376945 0.1827127 0.4249814 0.5992012 0.4303352 0.6609367 0.4053811 0.6695316 0.3776866 0.1684792 0.3376945 0.1827127 0.3089248 0.1260416 0.4249814 0.5992012 0.3979957 0.6084646 0.3915634 0.5472081 0.3514931 0.1098571 0.3089248 0.1260416 0.2431051 0.07810217 0.4157641 0.4755103 0.4202656 0.5373717 0.3915634 0.5472081 0.4053811 0.6695316 0.4146683 0.7302197 0.392204 0.7403113 0.3537352 0.2420439 0.3186824 0.2578327 0.3014633 0.1995143 0.3979957 0.6084646 0.4053811 0.6695316 0.3803044 0.6806673 0.3376945 0.1827127 0.3014633 0.1995143 0.2728623 0.1441527 0.3979957 0.6084646 0.370982 0.6203895 0.3629816 0.5597888 0.2431051 0.07810217 0.3089248 0.1260416 0.2728623 0.1441527 0.3854953 0.4858791 0.3915634 0.5472081 0.3629816 0.5597888 0.1000552 0.06346303 0.2431051 0.07810217 0.2160624 0.09701496 0.3854953 0.4858791 0.355547 0.4990501 0.3481036 0.4383131 0.3725381 0.3633816 0.3793213 0.4245703 0.3481036 0.4383131 0.449143 0.8483685 0.4372645 0.8541828 0.4091939 0.7986839 0.3725381 0.3633816 0.3400747 0.377718 0.3306941 0.3174523 0.4277372 0.7901487 0.4091939 0.7986839 0.392204 0.7403113 0.3537352 0.2420439 0.3644323 0.3024546 0.3306941 0.3174523 0.355547 0.4990501 0.3258773 0.5145326 0.3174503 0.4543229 0.3481036 0.4383131 0.3174503 0.4543229 0.3085443 0.3942467 0.4372645 0.8541828 0.4258353 0.8613048 0.3905939 0.809134 0.3400747 0.377718 0.3085443 0.3942467 0.2983864 0.3345217 0.4091939 0.7986839 0.3905939 0.809134 0.3694965 0.7525728 0.3186824 0.2578327 0.3306941 0.3174523 0.2983864 0.3345217 0.392204 0.7403113 0.3694965 0.7525728 0.3549953 0.6940838 0.3186824 0.2578327 0.2857701 0.2754919 0.2684326 0.217822 0.370982 0.6203895 0.3803044 0.6806673 0.3549953 0.6940838 0.2728623 0.1441527 0.3014633 0.1995143 0.2684326 0.217822 0.370982 0.6203895 0.3438475 0.6346392 0.3344526 0.5747007 0.2728623 0.1441527 0.2414228 0.1630486 0.1927784 0.1154518 0.355547 0.4990501 0.3629816 0.5597888 0.3344526 0.5747007 0.1034273 0.07555043 0.2160624 0.09701496 0.1927784 0.1154518 0.2857701 0.2754919 0.2546709 0.2941809 0.2379202 0.2367545 0.3438475 0.6346392 0.3549953 0.6940838 0.3292887 0.7094673 0.2684326 0.217822 0.2379202 0.2367545 0.2131515 0.1819364 0.3438475 0.6346392 0.3164449 0.6508139 0.3058518 0.5914652 0.2414228 0.1630486 0.2131515 0.1819364 0.1715415 0.1330838 0.3258773 0.5145326 0.3344526 0.5747007 0.3058518 0.5914652 0.1927784 0.1154518 0.1715415 0.1330838 0.09641396 0.09949165 0.3174503 0.4543229 0.3258773 0.5145326 0.2963792 0.5317736 0.3174503 0.4543229 0.2872596 0.4719741 0.2778287 0.4122695 0.4258353 0.8613048 0.4150114 0.8696404 0.3718692 0.8213651 0.3085443 0.3942467 0.2778287 0.4122695 0.2673314 0.3528915 0.3905939 0.809134 0.3718692 0.8213651 0.3463891 0.7667828 0.2857701 0.2754919 0.2983864 0.3345217 0.2673314 0.3528915 0.3549953 0.6940838 0.3694965 0.7525728 0.3463891 0.7667828 0.2872596 0.4719741 0.2573703 0.4906155 0.247742 0.4310891 0.4150114 0.8696404 0.4049999 0.8790763 0.3529083 0.8352231 0.2778287 0.4122695 0.247742 0.4310891 0.2372796 0.3718289 0.3718692 0.8213651 0.3529083 0.8352231 0.3226514 0.7826805 0.2546709 0.2941809 0.2673314 0.3528915 0.2372796 0.3718289 0.3292887 0.7094673 0.3463891 0.7667828 0.3226514 0.7826805 0.2546709 0.2941809 0.225003 0.3131518 0.2092928 0.2555946 0.3164449 0.6508139 0.3292887 0.7094673 0.3029512 0.7264504 0.2379202 0.2367545 0.2092928 0.2555946 0.1870253 0.2002409 0.3164449 0.6508139 0.2885685 0.668456 0.2770006 0.6095497 0.1715415 0.1330838 0.2131515 0.1819364 0.1870253 0.2002409 0.2963792 0.5317736 0.3058518 0.5914652 0.2770006 0.6095497 0.1715415 0.1330838 0.1514846 0.1496599 0.08903849 0.1106907 0.2963792 0.5317736 0.2668911 0.5501763 0.2573703 0.4906155 0.2092928 0.2555946 0.182024 0.2737511 0.162342 0.2175185 0.2885685 0.668456 0.2599516 0.6870493 0.2476739 0.6283716 0.1514846 0.1496599 0.1870253 0.2002409 0.162342 0.2175185 0.2668911 0.5501763 0.2770006 0.6095497 0.2476739 0.6283716 0.08903849 0.1106907 0.1514846 0.1496599 0.1321256 0.1649673 0.2668911 0.5501763 0.2372119 0.5691114 0.2275851 0.5095852 0.2573703 0.4906155 0.2275851 0.5095852 0.2180665 0.4500249 0.4049999 0.8790763 0.3960925 0.8894771 0.3335328 0.8505368 0.247742 0.4310891 0.2180665 0.4500249 0.2079604 0.390652 0.3529083 0.8352231 0.3335328 0.8505368 0.2979491 0.799961 0.225003 0.3131518 0.2372796 0.3718289 0.2079604 0.390652 0.3029512 0.7264504 0.3226514 0.7826805 0.2979491 0.799961 0.2092928 0.2555946 0.225003 0.3131518 0.1963976 0.3317459 0.2885685 0.668456 0.3029512 0.7264504 0.2756667 0.7446073 0.3335328 0.8505368 0.3960925 0.8894771 0.3887225 0.9006809 0.2180665 0.4500249 0.1885811 0.4684205 0.1791153 0.4087299 0.3335328 0.8505368 0.3134537 0.867116 0.2717982 0.8182626 0.1963976 0.3317459 0.2079604 0.390652 0.1791153 0.4087299 0.2756667 0.7446073 0.2979491 0.799961 0.2717982 0.8182626 0.1963976 0.3317459 0.1685307 0.3493819 0.1556993 0.2907277 0.2599516 0.6870493 0.2756667 0.7446073 0.2470199 0.7634406 0.182024 0.2737511 0.1556993 0.2907277 0.1386191 0.2334085 0.2599516 0.6870493 0.23027 0.7060118 0.2176133 0.6473003 0.1321256 0.1649673 0.162342 0.2175185 0.1386191 0.2334085 0.2372119 0.5691114 0.2476739 0.6283716 0.2176133 0.6473003 0.1321256 0.1649673 0.1131775 0.1788164 0.07011771 0.1305137 0.2372119 0.5691114 0.2071207 0.5879223 0.197695 0.5282186 0.2275851 0.5095852 0.197695 0.5282186 0.1885811 0.4684205 0.23027 0.7060118 0.199155 0.7246842 0.1865485 0.665653 0.1131775 0.1788164 0.1386191 0.2334085 0.1155236 0.2476066 0.2071207 0.5879223 0.2176133 0.6473003 0.1865485 0.665653 0.1131775 0.1788164 0.09446328 0.1910358 0.05929529 0.1388404 0.2071207 0.5879223 0.1764 0.6059286 0.1675031 0.5458543 0.1885811 0.4684205 0.197695 0.5282186 0.1675031 0.5458543 0.3134537 0.867116 0.3887225 0.9006809 0.3835681 0.912486 0.1885811 0.4684205 0.1590852 0.4856469 0.1505197 0.4254812 0.3134537 0.867116 0.292185 0.8847473 0.243494 0.837141 0.1685307 0.3493819 0.1791153 0.4087299 0.1505197 0.4254812 0.2470199 0.7634406 0.2717982 0.8182626 0.243494 0.837141 0.1685307 0.3493819 0.1411362 0.3655441 0.1300031 0.3060992 0.2470199 0.7634406 0.2164838 0.7823588 0.199155 0.7246842 0.1386191 0.2334085 0.1556993 0.2907277 0.1300031 0.3060992 0.1590852 0.4856469 0.1294175 0.5011084 0.1219953 0.4403737 0.292185 0.8847473 0.2688526 0.9031792 0.2120112 0.856019 0.1411362 0.3655441 0.1505197 0.4254812 0.1219953 0.4403737 0.2164838 0.7823588 0.243494 0.837141 0.2120112 0.856019 0.1411362 0.3655441 0.1140086 0.379776 0.1047028 0.3194993 0.199155 0.7246842 0.2164838 0.7823588 0.1834254 0.8006429 0.1300031 0.3060992 0.1047028 0.3194993 0.09282612 0.2598529 0.199155 0.7246842 0.1662256 0.7423182 0.1542308 0.6826973 0.09446328 0.1910358 0.1155236 0.2476066 0.09282612 0.2598529 0.1764 0.6059286 0.1865485 0.665653 0.1542308 0.6826973 0.09446328 0.1910358 0.07587218 0.2014721 0.04786872 0.1459523 0.1764 0.6059286 0.1448646 0.6224332 0.1368486 0.5618414 0.1590852 0.4856469 0.1675031 0.5458543 0.1368486 0.5618414 0.292185 0.8847473 0.3835681 0.912486 0.3817437 0.9246256 0.07587218 0.2014721 0.09282612 0.2598529 0.07037049 0.2699261 0.1448646 0.6224332 0.1542308 0.6826973 0.1204835 0.6976624 0.07587218 0.2014721 0.05733662 0.2099915 0.03599351 0.1517553 0.1448646 0.6224332 0.1123972 0.6367389 0.1056304 0.5755556 0.1368486 0.5618414 0.1056304 0.5755556 0.09947144 0.514253 0.3817437 0.9246256 0.385161 0.9367107 0.2417302 0.9220808 0.1294175 0.5011084 0.09947144 0.514253 0.093418 0.45293 0.2688526 0.9031792 0.2417302 0.9220808 0.1758925 0.8741014 0.1140086 0.379776 0.1219953 0.4403737 0.093418 0.45293 0.1834254 0.8006429 0.2120112 0.856019 0.1758925 0.8741014 0.1140086 0.379776 0.0870012 0.3916786 0.07963401 0.3306146 0.1834254 0.8006429 0.1471639 0.817411 0.131156 0.7580731 0.1047028 0.3194993 0.07963401 0.3306146 0.07037049 0.2699261 0.1662256 0.7423182 0.131156 0.7580731 0.1204835 0.6976624 0.1758925 0.8741014 0.2417302 0.9220808 0.2069531 0.9409168 0.0870012 0.3916786 0.093418 0.45293 0.06472045 0.4627382 0.1471639 0.817411 0.1758925 0.8741014 0.1332573 0.8902431 0.0870012 0.3916786 0.06002157 0.4009161 0.05468714 0.3391861 0.131156 0.7580731 0.1471639 0.817411 0.1071433 0.8316007 0.07963401 0.3306146 0.05468714 0.3391861 0.04805356 0.2776444 0.131156 0.7580731 0.09378856 0.7710414 0.08526748 0.7097733 0.05733662 0.2099915 0.07037049 0.2699261 0.04805356 0.2776444 0.1123972 0.6367389 0.1204835 0.6976624 0.08526748 0.7097733 0.05733662 0.2099915 0.03881853 0.2164819 0.02379328 0.1561736 0.1123972 0.6367389 0.07898485 0.6481801 0.07382827 0.5864241 0.09947144 0.514253 0.1056304 0.5755556 0.07382827 0.5864241 0.385161 0.9367107 0.3971338 0.9481052 0.2069531 0.9409168 0.09947144 0.514253 0.06920558 0.524591 0.06472045 0.4627382 0.07898485 0.6481801 0.08526748 0.7097733 0.04874467 0.7183161 0.03881853 0.2164819 0.02029967 0.2208569 0.0113722 0.1591499 0.07898485 0.6481801 0.04474818 0.6561728 0.04151457 0.5939623 0.06920558 0.524591 0.07382827 0.5864241 0.04151457 0.5939623 0.3971338 0.9481052 0.4228305 0.9576696 0.1545662 0.9585033 0.06920558 0.524591 0.03864717 0.5317196 0.03589004 0.4694672 0.2069531 0.9409168 0.1545662 0.9585033 0.08236718 0.9028213 0.06002157 0.4009161 0.06472045 0.4627382 0.03589004 0.4694672 0.1332573 0.8902431 0.08236718 0.9028213 0.06327778 0.8420249 0.06002157 0.4009161 0.03302448 0.4072239 0.02979582 0.3450124 0.09378856 0.7710414 0.1071433 0.8316007 0.06327778 0.8420249 0.05468714 0.3391861 0.02979582 0.3450124 0.02581018 0.2828674 0.09378856 0.7710414 0.05428034 0.7803239 0.04874467 0.7183161 0.04805356 0.2776444 0.02581018 0.2828674 0.02029967 0.2208569 0.03302448 0.4072239 0.03589004 0.4694672 0.006959736 0.4728841 0.08236718 0.9028213 0.02346807 0.9098559 0.01638609 0.8475685 0.03302448 0.4072239 0.006001472 0.4104183 0.00492531 0.3479555 0.05428034 0.7803239 0.06327778 0.8420249 0.01638609 0.8475685 0.02581018 0.2828674 0.02979582 0.3450124 0.00492531 0.3479555 0.05428034 0.7803239 0.01321828 0.785167 0.01130914 0.7227291 0.02581018 0.2828674 0.003600955 0.285499 0.001775324 0.2230563 0.04474818 0.6561728 0.04874467 0.7183161 0.01130914 0.7227291 1.0203 0.2208569 1.001775 0.2230563 0.9988229 0.1606459 0.04151457 0.5939623 0.04474818 0.6561728 0.009946048 0.6602758 0.04151457 0.5939623 0.008850932 0.5978149 0.00788486 0.5353502 0.4228305 0.9576696 0.4663997 0.9634672 0.05996555 0.9712674 0.03864717 0.5317196 0.00788486 0.5353502 0.006959736 0.4728841 0.1545662 0.9585033 0.05996555 0.9712674 0.02346807 0.9098559 1.001775 0.2230563 0.9832485 0.2230503 0.9862315 0.1606423 1.009946 0.6602758 0.9749442 0.6602513 0.9760642 0.5977937 1.008851 0.5978149 0.9760642 0.5977937 0.9770506 0.535332 0.05996555 0.9712674 0.4663997 0.9634672 0.5197656 0.9634217 1.007885 0.5353502 0.9770506 0.535332 0.9779933 0.4728688 1.023468 0.9098559 1.059966 0.9712674 0.9236539 0.9711539 1.006001 0.4104183 1.00696 0.4728841 0.9779933 0.4728688 1.016386 0.8475685 1.023468 0.9098559 0.9610577 0.9098034 1.006001 0.4104183 0.9789676 0.4104056 0.9800599 0.3479452 1.013218 0.785167 1.016386 0.8475685 0.9683353 0.847529 1.004925 0.3479555 0.9800599 0.3479452 0.9814017 0.2854908 1.013218 0.785167 0.9715889 0.7851341 0.9735478 0.7227008 1.003601 0.285499 0.9814017 0.2854908 0.9832485 0.2230503 1.009946 0.6602758 1.011309 0.7227291 0.9735478 0.7227008 0.9789676 0.4104056 0.951946 0.4071862 0.9551903 0.3449817 0.9715889 0.7851341 0.9683353 0.847529 0.9214769 0.841912 0.9800599 0.3479452 0.9551903 0.3449817 0.9591931 0.2828431 0.9715889 0.7851341 0.9305438 0.7802285 0.9361224 0.7182335 0.9814017 0.2854908 0.9591931 0.2828431 0.9647247 0.2208389 0.9749442 0.6602513 0.9735478 0.7227008 0.9361224 0.7182335 0.9862315 0.1606423 0.9832485 0.2230503 0.9647247 0.2208389 0.9749442 0.6602513 0.9401488 0.6561009 0.9434052 0.5939 0.9760642 0.5977937 0.9434052 0.5939 0.9462915 0.5316662 0.5197656 0.9634217 0.5630894 0.9575534 0.8298811 0.9582708 0.9770506 0.535332 0.9462915 0.5316662 0.9490651 0.4694219 0.9236539 0.9711539 0.8298811 0.9582708 0.9022539 0.902677 0.9789676 0.4104056 0.9779933 0.4728688 0.9490651 0.4694219 0.9610577 0.9098034 0.9022539 0.902677 0.9214769 0.841912 0.9434052 0.5939 0.9111002 0.5863247 0.9157391 0.5245054 0.8298811 0.9582708 0.5630894 0.9575534 0.5885478 0.9479513 0.9462915 0.5316662 0.9157391 0.5245054 0.9202389 0.4626654 0.9022539 0.902677 0.8298811 0.9582708 0.7778791 0.9406516 0.9490651 0.4694219 0.9202389 0.4626654 0.9249518 0.4008553 0.9214769 0.841912 0.9022539 0.902677 0.8514901 0.8900356 0.951946 0.4071862 0.9249518 0.4008553 0.9303008 0.3391364 0.9305438 0.7802285 0.9214769 0.841912 0.8776648 0.8314287 0.9551903 0.3449817 0.9303008 0.3391364 0.9369508 0.2776051 0.9361224 0.7182335 0.9305438 0.7802285 0.8910649 0.7708927 0.9591931 0.2828431 0.9369508 0.2776051 0.9462066 0.2164527 0.9401488 0.6561009 0.9361224 0.7182335 0.8996179 0.7096431 0.9647247 0.2208389 0.9462066 0.2164527 0.9612628 0.1561555 0.9434052 0.5939 0.9401488 0.6561009 0.9059244 0.648066</float_array>
+          <technique_common>
+            <accessor source="#Sphere-mesh-map-0-array" count="2880" stride="2">
+              <param name="S" type="float"/>
+              <param name="T" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <vertices id="Sphere-mesh-vertices">
+          <input semantic="POSITION" source="#Sphere-mesh-positions"/>
+        </vertices>
+        <triangles material="ReflectProbePreviewMat-material" count="960">
+          <input semantic="VERTEX" source="#Sphere-mesh-vertices" offset="0"/>
+          <input semantic="NORMAL" source="#Sphere-mesh-normals" offset="1"/>
+          <input semantic="TEXCOORD" source="#Sphere-mesh-map-0" offset="2" set="0"/>
+          <p>0 0 0 1 1 1 2 2 2 3 3 3 4 4 4 5 5 5 6 6 6 7 7 7 8 8 8 2 2 9 9 9 10 10 10 11 3 3 12 11 11 13 12 12 14 13 13 15 9 9 16 14 14 17 15 15 18 11 11 19 16 16 20 13 13 21 17 17 22 18 18 23 15 15 24 19 19 25 20 20 26 21 21 27 17 17 28 22 22 29 20 20 30 23 23 31 24 24 32 21 21 33 25 25 34 26 26 35 24 24 36 27 27 37 28 28 38 26 26 39 29 29 40 30 30 41 28 28 42 31 31 43 0 0 44 30 30 45 8 8 46 7 7 47 25 25 48 32 32 49 29 29 50 27 27 51 33 33 52 31 31 53 29 29 54 34 34 55 8 8 56 31 31 57 35 35 58 1 1 59 5 5 60 4 4 61 36 36 62 6 6 63 8 8 64 34 34 65 9 9 66 35 35 67 37 37 68 5 5 69 38 38 70 11 11 71 14 14 72 37 37 73 39 39 74 11 11 75 40 40 76 16 16 77 14 14 78 41 41 79 17 17 80 16 16 81 42 42 82 19 19 83 22 22 84 41 41 85 43 43 86 19 19 87 44 44 88 23 23 89 22 22 90 45 45 91 25 25 92 23 23 93 46 46 94 27 27 95 41 41 96 47 47 97 48 48 98 40 40 99 49 49 100 42 42 101 43 43 102 48 48 103 50 50 104 42 42 105 51 51 106 44 44 107 43 43 108 52 52 109 45 45 110 44 44 111 53 53 112 46 46 113 45 45 114 54 54 115 32 32 116 33 33 117 53 53 118 55 55 119 32 32 120 56 56 121 34 34 122 33 33 123 57 57 124 35 35 125 36 36 126 4 4 127 58 58 128 6 6 129 34 34 130 56 56 131 35 35 132 59 59 133 37 37 134 36 36 135 60 60 136 38 38 137 37 37 138 47 47 139 39 39 140 38 38 141 61 61 142 40 40 143 54 54 144 62 62 145 56 56 146 57 57 147 63 63 148 64 64 149 58 58 150 4 4 151 65 65 152 6 6 153 56 56 154 62 62 155 57 57 156 66 66 157 59 59 158 58 58 159 67 67 160 60 60 161 59 59 162 68 68 163 47 47 164 60 60 165 69 69 166 61 61 167 48 48 168 68 68 169 70 70 170 61 61 171 71 71 172 49 49 173 48 48 174 72 72 175 50 50 176 49 49 177 73 73 178 51 51 179 50 50 180 74 74 181 52 52 182 51 51 183 75 75 184 53 53 185 52 52 186 76 76 187 54 54 188 53 53 189 63 63 190 55 55 191 69 69 192 77 77 193 71 71 194 70 70 195 78 78 196 72 72 197 73 73 198 77 77 199 79 79 200 74 74 201 78 78 202 80 80 203 73 73 204 81 81 205 75 75 206 76 76 207 80 80 208 82 82 209 75 75 210 83 83 211 63 63 212 76 76 213 84 84 214 62 62 215 64 64 216 83 83 217 85 85 218 65 65 219 4 4 220 86 86 221 6 6 222 62 62 223 84 84 224 64 64 225 87 87 226 66 66 227 65 65 228 88 88 229 67 67 230 66 66 231 89 89 232 68 68 233 67 67 234 90 90 235 69 69 236 70 70 237 89 89 238 91 91 239 83 83 240 92 92 241 85 85 242 86 86 243 4 4 244 93 93 245 6 6 246 84 84 247 94 94 248 85 85 249 95 95 250 87 87 251 86 86 252 96 96 253 88 88 254 87 87 255 97 97 256 89 89 257 88 88 258 98 98 259 90 90 260 91 91 261 97 97 262 99 99 263 90 90 264 100 100 265 77 77 266 78 78 267 99 99 268 101 101 269 79 79 270 100 100 271 102 102 272 78 78 273 103 103 274 80 80 275 79 79 276 104 104 277 81 81 278 82 82 279 103 103 280 105 105 281 83 83 282 104 104 283 106 106 284 82 82 285 94 94 286 84 84 287 101 101 288 107 107 289 108 108 290 100 100 291 109 109 292 102 102 293 101 101 294 110 110 295 103 103 296 102 102 297 111 111 298 104 104 299 103 103 300 112 112 301 105 105 302 106 106 303 111 111 304 113 113 305 94 94 306 112 112 307 114 114 308 106 106 309 115 115 310 92 92 311 93 93 312 4 4 313 116 116 314 6 6 315 94 94 316 114 114 317 92 92 318 117 117 319 95 95 320 93 93 321 118 118 322 96 96 323 95 95 324 119 119 325 97 97 326 96 96 327 120 120 328 98 98 329 99 99 330 119 119 331 107 107 332 100 100 333 120 120 334 121 121 335 116 116 336 4 4 337 122 122 338 6 6 339 114 114 340 123 123 341 117 117 342 124 124 343 125 125 344 116 116 345 126 126 346 118 118 347 117 117 348 127 127 349 119 119 350 118 118 351 128 128 352 120 120 353 107 107 354 127 127 355 129 129 356 120 120 357 130 130 358 121 121 359 107 107 360 131 131 361 108 108 362 121 121 363 132 132 364 109 109 365 110 110 366 131 131 367 133 133 368 109 109 369 134 134 370 111 111 371 112 112 372 133 133 373 135 135 374 113 113 375 134 134 376 136 136 377 114 114 378 135 135 379 123 123 380 113 113 381 124 124 382 115 115 383 132 132 384 137 137 385 138 138 386 133 133 387 139 139 388 140 140 389 132 132 390 141 141 391 134 134 392 133 133 393 142 142 394 135 135 395 136 136 396 141 141 397 143 143 398 123 123 399 142 142 400 144 144 401 136 136 402 145 145 403 124 124 404 122 122 405 4 4 406 146 146 407 6 6 408 123 123 409 144 144 410 124 124 411 147 147 412 125 125 413 126 126 414 146 146 415 148 148 416 125 125 417 149 149 418 127 127 419 126 126 420 150 150 421 128 128 422 129 129 423 149 149 424 151 151 425 128 128 426 137 137 427 130 130 428 129 129 429 139 139 430 131 131 431 145 145 432 152 152 433 147 147 434 146 146 435 153 153 436 148 148 437 147 147 438 154 154 439 149 149 440 150 150 441 153 153 442 155 155 443 151 151 444 154 154 445 156 156 446 150 150 447 157 157 448 137 137 449 151 151 450 158 158 451 139 139 452 137 137 453 159 159 454 138 138 455 139 139 456 160 160 457 140 140 458 138 138 459 161 161 460 141 141 461 142 142 462 160 160 463 162 162 464 143 143 465 161 161 466 163 163 467 142 142 468 164 164 469 144 144 470 143 143 471 165 165 472 145 145 473 146 146 474 4 4 475 166 166 476 6 6 477 144 144 478 164 164 479 160 160 480 167 167 481 168 168 482 159 159 483 169 169 484 161 161 485 160 160 486 170 170 487 162 162 488 163 163 489 169 169 490 171 171 491 162 162 492 172 172 493 164 164 494 163 163 495 173 173 496 165 165 497 166 166 498 4 4 499 174 174 500 6 6 501 164 164 502 172 172 503 152 152 504 173 173 505 175 175 506 166 166 507 176 176 508 153 153 509 152 152 510 177 177 511 154 154 512 153 153 513 178 178 514 155 155 515 156 156 516 177 177 517 179 179 518 155 155 519 180 180 520 157 157 521 156 156 522 167 167 523 158 158 524 159 159 525 180 180 526 181 181 527 175 175 528 182 182 529 177 177 530 176 176 531 183 183 532 178 178 533 177 177 534 184 184 535 179 179 536 178 178 537 185 185 538 180 180 539 179 179 540 186 186 541 167 167 542 180 180 543 187 187 544 181 181 545 168 168 546 186 186 547 188 188 548 181 181 549 189 189 550 169 169 551 168 168 552 190 190 553 170 170 554 171 171 555 189 189 556 191 191 557 172 172 558 190 190 559 192 192 560 171 171 561 193 193 562 173 173 563 174 174 564 4 4 565 194 194 566 6 6 567 172 172 568 192 192 569 173 173 570 195 195 571 175 175 572 174 174 573 196 196 574 176 176 575 188 188 576 197 197 577 190 190 578 191 191 579 198 198 580 199 199 581 192 192 582 197 197 583 200 200 584 191 191 585 201 201 586 193 193 587 194 194 588 4 4 589 202 202 590 6 6 591 192 192 592 200 200 593 195 195 594 201 201 595 203 203 596 194 194 597 204 204 598 196 196 599 195 195 600 205 205 601 182 182 602 196 196 603 206 206 604 183 183 605 184 184 606 205 205 607 207 207 608 185 185 609 206 206 610 208 208 611 184 184 612 209 209 613 186 186 614 187 187 615 208 208 616 210 210 617 188 188 618 209 209 619 211 211 620 187 187 621 198 198 622 189 189 623 206 206 624 212 212 625 213 213 626 207 207 627 214 214 628 215 215 629 206 206 630 216 216 631 208 208 632 207 207 633 217 217 634 209 209 635 208 208 636 218 218 637 210 210 638 211 211 639 217 217 640 219 219 641 210 210 642 220 220 643 198 198 644 211 211 645 221 221 646 197 197 647 199 199 648 220 220 649 222 222 650 197 197 651 223 223 652 200 200 653 199 199 654 224 224 655 201 201 656 202 202 657 4 4 658 225 225 659 6 6 660 200 200 661 223 223 662 201 201 663 226 226 664 203 203 665 202 202 666 212 212 667 204 204 668 203 203 669 214 214 670 205 205 671 222 222 672 227 227 673 228 228 674 223 223 675 229 229 676 230 230 677 222 222 678 231 231 679 224 224 680 225 225 681 4 4 682 232 232 683 6 6 684 223 223 685 230 230 686 224 224 687 233 233 688 226 226 689 225 225 690 234 234 691 212 212 692 226 226 693 235 235 694 214 214 695 212 212 696 236 236 697 213 213 698 215 215 699 235 235 700 237 237 701 213 213 702 238 238 703 216 216 704 215 215 705 239 239 706 217 217 707 216 216 708 240 240 709 218 218 710 217 217 711 241 241 712 219 219 713 218 218 714 227 227 715 220 220 716 219 219 717 229 229 718 221 221 719 237 237 720 242 242 721 243 243 722 238 238 723 244 244 724 245 245 725 237 237 726 246 246 727 239 239 728 238 238 729 247 247 730 240 240 731 241 241 732 246 246 733 248 248 734 240 240 735 249 249 736 227 227 737 241 241 738 250 250 739 229 229 740 228 228 741 249 249 742 251 251 743 230 230 744 250 250 745 252 252 746 228 228 747 253 253 748 231 231 749 232 232 750 4 4 751 254 254 752 6 6 753 230 230 754 252 252 755 231 231 756 255 255 757 233 233 758 232 232 759 256 256 760 234 234 761 233 233 762 242 242 763 235 235 764 236 236 765 256 256 766 244 244 767 250 250 768 257 257 769 252 252 770 251 251 771 258 258 772 253 253 773 254 254 774 4 4 775 259 259 776 6 6 777 252 252 778 257 257 779 253 253 780 260 260 781 255 255 782 254 254 783 261 261 784 256 256 785 255 255 786 262 262 787 242 242 788 256 256 789 263 263 790 244 244 791 243 243 792 262 262 793 264 264 794 245 245 795 263 263 796 265 265 797 243 243 798 266 266 799 246 246 800 247 247 801 265 265 802 267 267 803 246 246 804 268 268 805 248 248 806 247 247 807 269 269 808 249 249 809 248 248 810 270 270 811 250 250 812 251 251 813 269 269 814 271 271 815 265 265 816 272 272 817 273 273 818 264 264 819 274 274 820 266 266 821 267 267 822 273 273 823 275 275 824 266 266 825 276 276 826 268 268 827 267 267 828 277 277 829 269 269 830 270 270 831 276 276 832 278 278 833 271 271 834 277 277 835 279 279 836 257 257 837 278 278 838 280 280 839 271 271 840 281 281 841 258 258 842 259 259 843 4 4 844 282 282 845 6 6 846 257 257 847 280 280 848 260 260 849 281 281 850 283 283 851 259 259 852 284 284 853 261 261 854 260 260 855 285 285 856 262 262 857 261 261 858 272 272 859 263 263 860 264 264 861 285 285 862 286 286 863 279 279 864 287 287 865 281 281 866 282 282 867 4 4 868 288 288 869 6 6 870 280 280 871 289 289 872 281 281 873 290 290 874 283 283 875 282 282 876 291 291 877 284 284 878 283 283 879 292 292 880 285 285 881 284 284 882 293 293 883 272 272 884 286 286 885 292 292 886 294 294 887 272 272 888 295 295 889 273 273 890 286 286 891 296 296 892 274 274 893 275 275 894 295 295 895 297 297 896 276 276 897 296 296 898 298 298 899 275 275 900 299 299 901 277 277 902 276 276 903 300 300 904 278 278 905 279 279 906 299 299 907 301 301 908 280 280 909 300 300 910 289 289 911 294 294 912 302 302 913 296 296 914 297 297 915 303 303 916 304 304 917 296 296 918 305 305 919 298 298 920 297 297 921 306 306 922 299 299 923 298 298 924 307 307 925 300 300 926 301 301 927 306 306 928 308 308 929 300 300 930 309 309 931 289 289 932 287 287 933 308 308 934 310 310 935 288 288 936 4 4 937 311 311 938 6 6 939 289 289 940 309 309 941 287 287 942 312 312 943 290 290 944 288 288 945 313 313 946 291 291 947 290 290 948 314 314 949 292 292 950 291 291 951 315 315 952 293 293 953 294 294 954 314 314 955 316 316 956 295 295 957 315 315 958 303 303 959 6 6 960 309 309 961 317 317 962 310 310 963 318 318 964 312 312 965 311 311 966 319 319 967 313 313 968 312 312 969 320 320 970 314 314 971 313 313 972 321 321 973 315 315 974 316 316 975 320 320 976 322 322 977 303 303 978 321 321 979 323 323 980 316 316 981 324 324 982 302 302 983 304 304 984 323 323 985 325 325 986 302 302 987 326 326 988 305 305 989 304 304 990 327 327 991 306 306 992 307 307 993 326 326 994 328 328 995 308 308 996 327 327 997 329 329 998 307 307 999 317 317 1000 309 309 1001 308 308 1002 330 330 1003 310 310 1004 311 311 1005 4 4 1006 331 331 1007 324 324 1008 332 332 1009 326 326 1010 325 325 1011 333 333 1012 327 327 1013 328 328 1014 332 332 1015 334 334 1016 329 329 1017 333 333 1018 335 335 1019 317 317 1020 334 334 1021 336 336 1022 329 329 1023 337 337 1024 330 330 1025 331 331 1026 4 4 1027 338 338 1028 6 6 1029 317 317 1030 336 336 1031 330 330 1032 339 339 1033 318 318 1034 331 331 1035 340 340 1036 319 319 1037 318 318 1038 341 341 1039 320 320 1040 319 319 1041 342 342 1042 321 321 1043 322 322 1044 341 341 1045 343 343 1046 323 323 1047 342 342 1048 344 344 1049 324 324 1050 343 343 1051 345 345 1052 325 325 1053 344 344 1054 346 346 1055 340 340 1056 347 347 1057 348 348 1058 339 339 1059 349 349 1060 341 341 1061 340 340 1062 350 350 1063 342 342 1064 343 343 1065 349 349 1066 351 351 1067 344 344 1068 350 350 1069 352 352 1070 343 343 1071 353 353 1072 345 345 1073 346 346 1074 352 352 1075 354 354 1076 345 345 1077 355 355 1078 332 332 1079 346 346 1080 356 356 1081 333 333 1082 334 334 1083 355 355 1084 357 357 1085 335 335 1086 356 356 1087 358 358 1088 334 334 1089 359 359 1090 336 336 1091 335 335 1092 360 360 1093 337 337 1094 338 338 1095 4 4 1096 347 347 1097 6 6 1098 336 336 1099 359 359 1100 337 337 1101 361 361 1102 339 339 1103 354 354 1104 362 362 1105 356 356 1106 357 357 1107 363 363 1108 364 364 1109 358 358 1110 362 362 1111 365 365 1112 357 357 1113 366 366 1114 359 359 1115 358 358 1116 367 367 1117 360 360 1118 347 347 1119 4 4 1120 368 368 1121 6 6 1122 359 359 1123 366 366 1124 361 361 1125 367 367 1126 369 369 1127 348 348 1128 368 368 1129 370 370 1130 361 361 1131 371 371 1132 349 349 1133 348 348 1134 372 372 1135 350 350 1136 351 351 1137 371 371 1138 373 373 1139 352 352 1140 372 372 1141 374 374 1142 351 351 1143 375 375 1144 353 353 1145 352 352 1146 376 376 1147 354 354 1148 355 355 1149 375 375 1150 363 363 1151 369 369 1152 377 377 1153 371 371 1154 370 370 1155 378 378 1156 372 372 1157 373 373 1158 377 377 1159 379 379 1160 374 374 1161 378 378 1162 380 380 1163 373 373 1164 381 381 1165 375 375 1166 376 376 1167 380 380 1168 382 382 1169 375 375 1170 383 383 1171 363 363 1172 376 376 1173 384 384 1174 362 362 1175 364 364 1176 383 383 1177 385 385 1178 365 365 1179 384 384 1180 386 386 1181 364 364 1182 387 387 1183 366 366 1184 365 365 1185 388 388 1186 367 367 1187 368 368 1188 4 4 1189 389 389 1190 6 6 1191 366 366 1192 387 387 1193 369 369 1194 388 388 1195 390 390 1196 370 370 1197 389 389 1198 391 391 1199 385 385 1200 392 392 1201 393 393 1202 386 386 1203 394 394 1204 395 395 1205 385 385 1206 396 396 1207 387 387 1208 386 386 1209 397 397 1210 388 388 1211 389 389 1212 4 4 1213 398 398 1214 6 6 1215 387 387 1216 396 396 1217 388 388 1218 399 399 1219 390 390 1220 389 389 1221 400 400 1222 391 391 1223 390 390 1224 401 401 1225 377 377 1226 391 391 1227 402 402 1228 378 378 1229 379 379 1230 401 401 1231 403 403 1232 380 380 1233 402 402 1234 404 404 1235 379 379 1236 405 405 1237 381 381 1238 380 380 1239 406 406 1240 382 382 1241 381 381 1242 392 392 1243 383 383 1244 382 382 1245 394 394 1246 384 384 1247 402 402 1248 407 407 1249 408 408 1250 403 403 1251 409 409 1252 410 410 1253 404 404 1254 408 408 1255 411 411 1256 403 403 1257 412 412 1258 405 405 1259 406 406 1260 411 411 1261 413 413 1262 405 405 1263 414 414 1264 392 392 1265 406 406 1266 415 415 1267 394 394 1268 393 393 1269 414 414 1270 416 416 1271 395 395 1272 415 415 1273 417 417 1274 393 393 1275 418 418 1276 396 396 1277 395 395 1278 419 419 1279 397 397 1280 398 398 1281 4 4 1282 420 420 1283 6 6 1284 396 396 1285 418 418 1286 399 399 1287 419 419 1288 421 421 1289 398 398 1290 407 407 1291 400 400 1292 399 399 1293 409 409 1294 401 401 1295 417 417 1296 422 422 1297 423 423 1298 416 416 1299 424 424 1300 418 418 1301 417 417 1302 425 425 1303 419 419 1304 420 420 1305 4 4 1306 426 426 1307 6 6 1308 418 418 1309 424 424 1310 421 421 1311 425 425 1312 427 427 1313 420 420 1314 428 428 1315 407 407 1316 421 421 1317 429 429 1318 409 409 1319 407 407 1320 430 430 1321 408 408 1322 410 410 1323 429 429 1324 431 431 1325 408 408 1326 432 432 1327 411 411 1328 410 410 1329 433 433 1330 412 412 1331 413 413 1332 432 432 1333 434 434 1334 412 412 1335 435 435 1336 414 414 1337 413 413 1338 422 422 1339 415 415 1340 414 414 1341 436 436 1342 416 416 1343 431 431 1344 437 437 1345 438 438 1346 430 430 1347 439 439 1348 432 432 1349 431 431 1350 440 440 1351 433 433 1352 434 434 1353 439 439 1354 441 441 1355 435 435 1356 440 440 1357 442 442 1358 434 434 1359 443 443 1360 422 422 1361 435 435 1362 444 444 1363 436 436 1364 423 423 1365 443 443 1366 445 445 1367 436 436 1368 446 446 1369 424 424 1370 425 425 1371 445 445 1372 447 447 1373 426 426 1374 4 4 1375 448 448 1376 6 6 1377 424 424 1378 446 446 1379 425 425 1380 449 449 1381 427 427 1382 426 426 1383 450 450 1384 428 428 1385 427 427 1386 437 437 1387 429 429 1388 428 428 1389 451 451 1390 430 430 1391 444 444 1392 452 452 1393 446 446 1394 445 445 1395 453 453 1396 447 447 1397 448 448 1398 4 4 1399 454 454 1400 6 6 1401 446 446 1402 452 452 1403 447 447 1404 455 455 1405 449 449 1406 450 450 1407 454 454 1408 456 456 1409 449 449 1410 457 457 1411 437 437 1412 451 451 1413 456 456 1414 458 458 1415 438 438 1416 457 457 1417 459 459 1418 439 439 1419 458 458 1420 460 460 1421 438 438 1422 461 461 1423 440 440 1424 441 441 1425 460 460 1426 462 462 1427 440 440 1428 463 463 1429 442 442 1430 441 441 1431 464 464 1432 443 443 1433 442 442 1434 465 465 1435 444 444 1436 445 445 1437 464 464 1438 466 466 1439 459 459 1440 467 467 1441 461 461 1442 462 462 1443 468 468 1444 469 469 1445 461 461 1446 470 470 1447 463 463 1448 462 462 1449 471 471 1450 464 464 1451 463 463 1452 472 472 1453 465 465 1454 466 466 1455 471 471 1456 473 473 1457 452 452 1458 472 472 1459 474 474 1460 466 466 1461 475 475 1462 453 453 1463 454 454 1464 4 4 1465 476 476 1466 6 6 1467 452 452 1468 474 474 1469 453 453 1470 477 477 1471 455 455 1472 454 454 1473 478 478 1474 456 456 1475 455 455 1476 479 479 1477 457 457 1478 456 456 1479 480 480 1480 458 458 1481 459 459 1482 479 479 1483 481 481 1484 458 458 1485 468 468 1486 460 460 1487 476 476 1488 4 4 1489 3 3 1490 6 6 1491 474 474 1492 7 7 1493 475 475 1494 10 10 1495 477 477 1496 478 478 1497 3 3 1498 12 12 1499 477 477 1500 13 13 1501 479 479 1502 480 480 1503 12 12 1504 15 15 1505 479 479 1506 18 18 1507 481 481 1508 468 468 1509 15 15 1510 20 20 1511 481 481 1512 21 21 1513 467 467 1514 469 469 1515 20 20 1516 24 24 1517 467 467 1518 26 26 1519 470 470 1520 471 471 1521 24 24 1522 28 28 1523 470 470 1524 30 30 1525 472 472 1526 473 473 1527 28 28 1528 0 0 1529 472 472 1530 7 7 1531 474 474 1532 475 475 1533 0 0 1534 2 2 1535 0 0 1536 31 31 1537 1 1 1538 2 2 1539 1 1 1540 9 9 1541 3 3 1542 5 5 1543 11 11 1544 13 13 1545 10 10 1546 9 9 1547 15 15 1548 12 12 1549 11 11 1550 13 13 1551 14 14 1552 17 17 1553 15 15 1554 16 16 1555 19 19 1556 21 21 1557 18 18 1558 17 17 1559 20 20 1560 19 19 1561 23 23 1562 21 21 1563 22 22 1564 25 25 1565 24 24 1566 23 23 1567 27 27 1568 26 26 1569 25 25 1570 29 29 1571 28 28 1572 27 27 1573 31 31 1574 30 30 1575 29 29 1576 8 8 1577 25 25 1578 45 45 1579 32 32 1580 27 27 1581 46 46 1582 33 33 1583 29 29 1584 32 32 1585 34 34 1586 31 31 1587 33 33 1588 35 35 1589 9 9 1590 1 1 1591 35 35 1592 5 5 1593 36 36 1594 38 38 1595 14 14 1596 9 9 1597 37 37 1598 11 11 1599 38 38 1600 40 40 1601 14 14 1602 39 39 1603 41 41 1604 16 16 1605 40 40 1606 42 42 1607 22 22 1608 17 17 1609 41 41 1610 19 19 1611 42 42 1612 44 44 1613 22 22 1614 43 43 1615 45 45 1616 23 23 1617 44 44 1618 46 46 1619 41 41 1620 39 39 1621 47 47 1622 40 40 1623 61 61 1624 49 49 1625 43 43 1626 41 41 1627 48 48 1628 42 42 1629 49 49 1630 51 51 1631 43 43 1632 50 50 1633 52 52 1634 44 44 1635 51 51 1636 53 53 1637 45 45 1638 52 52 1639 54 54 1640 33 33 1641 46 46 1642 53 53 1643 32 32 1644 54 54 1645 56 56 1646 33 33 1647 55 55 1648 57 57 1649 35 35 1650 57 57 1651 59 59 1652 36 36 1653 58 58 1654 60 60 1655 37 37 1656 59 59 1657 47 47 1658 38 38 1659 60 60 1660 61 61 1661 54 54 1662 76 76 1663 62 62 1664 57 57 1665 55 55 1666 63 63 1667 57 57 1668 64 64 1669 66 66 1670 58 58 1671 65 65 1672 67 67 1673 59 59 1674 66 66 1675 68 68 1676 60 60 1677 67 67 1678 69 69 1679 48 48 1680 47 47 1681 68 68 1682 61 61 1683 69 69 1684 71 71 1685 48 48 1686 70 70 1687 72 72 1688 49 49 1689 71 71 1690 73 73 1691 50 50 1692 72 72 1693 74 74 1694 51 51 1695 73 73 1696 75 75 1697 52 52 1698 74 74 1699 76 76 1700 53 53 1701 75 75 1702 63 63 1703 69 69 1704 90 90 1705 77 77 1706 70 70 1707 91 91 1708 78 78 1709 73 73 1710 71 71 1711 77 77 1712 74 74 1713 72 72 1714 78 78 1715 73 73 1716 79 79 1717 81 81 1718 76 76 1719 74 74 1720 80 80 1721 75 75 1722 81 81 1723 83 83 1724 76 76 1725 82 82 1726 84 84 1727 64 64 1728 63 63 1729 83 83 1730 64 64 1731 85 85 1732 87 87 1733 65 65 1734 86 86 1735 88 88 1736 66 66 1737 87 87 1738 89 89 1739 67 67 1740 88 88 1741 90 90 1742 70 70 1743 68 68 1744 89 89 1745 83 83 1746 106 106 1747 92 92 1748 85 85 1749 92 92 1750 95 95 1751 86 86 1752 93 93 1753 96 96 1754 87 87 1755 95 95 1756 97 97 1757 88 88 1758 96 96 1759 98 98 1760 91 91 1761 89 89 1762 97 97 1763 90 90 1764 98 98 1765 100 100 1766 78 78 1767 91 91 1768 99 99 1769 79 79 1770 77 77 1771 100 100 1772 78 78 1773 101 101 1774 103 103 1775 79 79 1776 102 102 1777 104 104 1778 82 82 1779 80 80 1780 103 103 1781 83 83 1782 81 81 1783 104 104 1784 82 82 1785 105 105 1786 94 94 1787 101 101 1788 99 99 1789 107 107 1790 100 100 1791 121 121 1792 109 109 1793 101 101 1794 108 108 1795 110 110 1796 102 102 1797 109 109 1798 111 111 1799 103 103 1800 110 110 1801 112 112 1802 106 106 1803 104 104 1804 111 111 1805 94 94 1806 105 105 1807 112 112 1808 106 106 1809 113 113 1810 115 115 1811 92 92 1812 115 115 1813 117 117 1814 93 93 1815 116 116 1816 118 118 1817 95 95 1818 117 117 1819 119 119 1820 96 96 1821 118 118 1822 120 120 1823 99 99 1824 97 97 1825 119 119 1826 100 100 1827 98 98 1828 120 120 1829 117 117 1830 115 115 1831 124 124 1832 116 116 1833 122 122 1834 126 126 1835 117 117 1836 125 125 1837 127 127 1838 118 118 1839 126 126 1840 128 128 1841 107 107 1842 119 119 1843 127 127 1844 120 120 1845 128 128 1846 130 130 1847 107 107 1848 129 129 1849 131 131 1850 121 121 1851 130 130 1852 132 132 1853 110 110 1854 108 108 1855 131 131 1856 109 109 1857 132 132 1858 134 134 1859 112 112 1860 110 110 1861 133 133 1862 113 113 1863 111 111 1864 134 134 1865 114 114 1866 112 112 1867 135 135 1868 113 113 1869 136 136 1870 124 124 1871 132 132 1872 130 130 1873 137 137 1874 133 133 1875 131 131 1876 139 139 1877 132 132 1878 138 138 1879 141 141 1880 133 133 1881 140 140 1882 142 142 1883 136 136 1884 134 134 1885 141 141 1886 123 123 1887 135 135 1888 142 142 1889 136 136 1890 143 143 1891 145 145 1892 124 124 1893 145 145 1894 147 147 1895 126 126 1896 122 122 1897 146 146 1898 125 125 1899 147 147 1900 149 149 1901 126 126 1902 148 148 1903 150 150 1904 129 129 1905 127 127 1906 149 149 1907 128 128 1908 150 150 1909 137 137 1910 129 129 1911 151 151 1912 139 139 1913 145 145 1914 165 165 1915 152 152 1916 146 146 1917 166 166 1918 153 153 1919 147 147 1920 152 152 1921 154 154 1922 150 150 1923 148 148 1924 153 153 1925 151 151 1926 149 149 1927 154 154 1928 150 150 1929 155 155 1930 157 157 1931 151 151 1932 156 156 1933 158 158 1934 137 137 1935 157 157 1936 159 159 1937 139 139 1938 158 158 1939 160 160 1940 138 138 1941 159 159 1942 161 161 1943 142 142 1944 140 140 1945 160 160 1946 143 143 1947 141 141 1948 161 161 1949 142 142 1950 162 162 1951 164 164 1952 143 143 1953 163 163 1954 165 165 1955 160 160 1956 158 158 1957 167 167 1958 159 159 1959 181 181 1960 169 169 1961 160 160 1962 168 168 1963 170 170 1964 163 163 1965 161 161 1966 169 169 1967 162 162 1968 170 170 1969 172 172 1970 163 163 1971 171 171 1972 173 173 1973 152 152 1974 165 165 1975 173 173 1976 166 166 1977 174 174 1978 176 176 1979 152 152 1980 175 175 1981 177 177 1982 153 153 1983 176 176 1984 178 178 1985 156 156 1986 154 154 1987 177 177 1988 155 155 1989 178 178 1990 180 180 1991 156 156 1992 179 179 1993 167 167 1994 159 159 1995 157 157 1996 180 180 1997 175 175 1998 195 195 1999 182 182 2000 176 176 2001 196 196 2002 183 183 2003 177 177 2004 182 182 2005 184 184 2006 178 178 2007 183 183 2008 185 185 2009 179 179 2010 184 184 2011 186 186 2012 180 180 2013 185 185 2014 187 187 2015 168 168 2016 167 167 2017 186 186 2018 181 181 2019 187 187 2020 189 189 2021 168 168 2022 188 188 2023 190 190 2024 171 171 2025 169 169 2026 189 189 2027 172 172 2028 170 170 2029 190 190 2030 171 171 2031 191 191 2032 193 193 2033 173 173 2034 193 193 2035 195 195 2036 174 174 2037 194 194 2038 196 196 2039 188 188 2040 211 211 2041 197 197 2042 191 191 2043 189 189 2044 198 198 2045 192 192 2046 190 190 2047 197 197 2048 191 191 2049 199 199 2050 201 201 2051 195 195 2052 193 193 2053 201 201 2054 194 194 2055 202 202 2056 204 204 2057 195 195 2058 203 203 2059 205 205 2060 196 196 2061 204 204 2062 206 206 2063 184 184 2064 182 182 2065 205 205 2066 185 185 2067 183 183 2068 206 206 2069 184 184 2070 207 207 2071 209 209 2072 187 187 2073 185 185 2074 208 208 2075 188 188 2076 186 186 2077 209 209 2078 187 187 2079 210 210 2080 198 198 2081 206 206 2082 204 204 2083 212 212 2084 207 207 2085 205 205 2086 214 214 2087 206 206 2088 213 213 2089 216 216 2090 207 207 2091 215 215 2092 217 217 2093 208 208 2094 216 216 2095 218 218 2096 211 211 2097 209 209 2098 217 217 2099 210 210 2100 218 218 2101 220 220 2102 211 211 2103 219 219 2104 221 221 2105 199 199 2106 198 198 2107 220 220 2108 197 197 2109 221 221 2110 223 223 2111 199 199 2112 222 222 2113 224 224 2114 201 201 2115 224 224 2116 226 226 2117 202 202 2118 225 225 2119 212 212 2120 203 203 2121 226 226 2122 214 214 2123 222 222 2124 220 220 2125 227 227 2126 223 223 2127 221 221 2128 229 229 2129 222 222 2130 228 228 2131 231 231 2132 224 224 2133 231 231 2134 233 233 2135 225 225 2136 232 232 2137 234 234 2138 226 226 2139 233 233 2140 235 235 2141 212 212 2142 234 234 2143 236 236 2144 215 215 2145 214 214 2146 235 235 2147 213 213 2148 236 236 2149 238 238 2150 215 215 2151 237 237 2152 239 239 2153 216 216 2154 238 238 2155 240 240 2156 217 217 2157 239 239 2158 241 241 2159 218 218 2160 240 240 2161 227 227 2162 219 219 2163 241 241 2164 229 229 2165 237 237 2166 235 235 2167 242 242 2168 238 238 2169 236 236 2170 244 244 2171 237 237 2172 243 243 2173 246 246 2174 238 238 2175 245 245 2176 247 247 2177 241 241 2178 239 239 2179 246 246 2180 240 240 2181 247 247 2182 249 249 2183 241 241 2184 248 248 2185 250 250 2186 228 228 2187 227 227 2188 249 249 2189 230 230 2190 229 229 2191 250 250 2192 228 228 2193 251 251 2194 253 253 2195 231 231 2196 253 253 2197 255 255 2198 232 232 2199 254 254 2200 256 256 2201 233 233 2202 255 255 2203 242 242 2204 236 236 2205 234 234 2206 256 256 2207 250 250 2208 270 270 2209 257 257 2210 251 251 2211 271 271 2212 258 258 2213 253 253 2214 258 258 2215 260 260 2216 254 254 2217 259 259 2218 261 261 2219 255 255 2220 260 260 2221 262 262 2222 256 256 2223 261 261 2224 263 263 2225 243 243 2226 242 242 2227 262 262 2228 245 245 2229 244 244 2230 263 263 2231 243 243 2232 264 264 2233 266 266 2234 247 247 2235 245 245 2236 265 265 2237 246 246 2238 266 266 2239 268 268 2240 247 247 2241 267 267 2242 269 269 2243 248 248 2244 268 268 2245 270 270 2246 251 251 2247 249 249 2248 269 269 2249 265 265 2250 263 263 2251 272 272 2252 264 264 2253 286 286 2254 274 274 2255 267 267 2256 265 265 2257 273 273 2258 266 266 2259 274 274 2260 276 276 2261 267 267 2262 275 275 2263 277 277 2264 270 270 2265 268 268 2266 276 276 2267 271 271 2268 269 269 2269 277 277 2270 257 257 2271 270 270 2272 278 278 2273 271 271 2274 279 279 2275 281 281 2276 260 260 2277 258 258 2278 281 281 2279 259 259 2280 282 282 2281 284 284 2282 260 260 2283 283 283 2284 285 285 2285 261 261 2286 284 284 2287 272 272 2288 264 264 2289 262 262 2290 285 285 2291 279 279 2292 301 301 2293 287 287 2294 281 281 2295 287 287 2296 290 290 2297 282 282 2298 288 288 2299 291 291 2300 283 283 2301 290 290 2302 292 292 2303 284 284 2304 291 291 2305 293 293 2306 286 286 2307 285 285 2308 292 292 2309 272 272 2310 293 293 2311 295 295 2312 286 286 2313 294 294 2314 296 296 2315 275 275 2316 273 273 2317 295 295 2318 276 276 2319 274 274 2320 296 296 2321 275 275 2322 297 297 2323 299 299 2324 276 276 2325 298 298 2326 300 300 2327 279 279 2328 277 277 2329 299 299 2330 280 280 2331 278 278 2332 300 300 2333 294 294 2334 316 316 2335 302 302 2336 297 297 2337 295 295 2338 303 303 2339 296 296 2340 302 302 2341 305 305 2342 297 297 2343 304 304 2344 306 306 2345 298 298 2346 305 305 2347 307 307 2348 301 301 2349 299 299 2350 306 306 2351 300 300 2352 307 307 2353 309 309 2354 287 287 2355 301 301 2356 308 308 2357 287 287 2358 310 310 2359 312 312 2360 288 288 2361 311 311 2362 313 313 2363 290 290 2364 312 312 2365 314 314 2366 291 291 2367 313 313 2368 315 315 2369 294 294 2370 292 292 2371 314 314 2372 295 295 2373 293 293 2374 315 315 2375 310 310 2376 330 330 2377 318 318 2378 311 311 2379 331 331 2380 319 319 2381 312 312 2382 318 318 2383 320 320 2384 313 313 2385 319 319 2386 321 321 2387 316 316 2388 314 314 2389 320 320 2390 303 303 2391 315 315 2392 321 321 2393 316 316 2394 322 322 2395 324 324 2396 304 304 2397 303 303 2398 323 323 2399 302 302 2400 324 324 2401 326 326 2402 304 304 2403 325 325 2404 327 327 2405 307 307 2406 305 305 2407 326 326 2408 308 308 2409 306 306 2410 327 327 2411 307 307 2412 328 328 2413 317 317 2414 308 308 2415 329 329 2416 330 330 2417 324 324 2418 345 345 2419 332 332 2420 325 325 2421 346 346 2422 333 333 2423 328 328 2424 326 326 2425 332 332 2426 329 329 2427 327 327 2428 333 333 2429 317 317 2430 328 328 2431 334 334 2432 329 329 2433 335 335 2434 337 337 2435 330 330 2436 337 337 2437 339 339 2438 331 331 2439 338 338 2440 340 340 2441 318 318 2442 339 339 2443 341 341 2444 319 319 2445 340 340 2446 342 342 2447 322 322 2448 320 320 2449 341 341 2450 323 323 2451 321 321 2452 342 342 2453 324 324 2454 322 322 2455 343 343 2456 325 325 2457 323 323 2458 344 344 2459 340 340 2460 338 338 2461 347 347 2462 339 339 2463 361 361 2464 349 349 2465 340 340 2466 348 348 2467 350 350 2468 343 343 2469 341 341 2470 349 349 2471 344 344 2472 342 342 2473 350 350 2474 343 343 2475 351 351 2476 353 353 2477 346 346 2478 344 344 2479 352 352 2480 345 345 2481 353 353 2482 355 355 2483 346 346 2484 354 354 2485 356 356 2486 334 334 2487 332 332 2488 355 355 2489 335 335 2490 333 333 2491 356 356 2492 334 334 2493 357 357 2494 359 359 2495 335 335 2496 358 358 2497 360 360 2498 337 337 2499 360 360 2500 361 361 2501 354 354 2502 376 376 2503 362 362 2504 357 357 2505 355 355 2506 363 363 2507 358 358 2508 356 356 2509 362 362 2510 357 357 2511 364 364 2512 366 366 2513 358 358 2514 365 365 2515 367 367 2516 361 361 2517 360 360 2518 367 367 2519 348 348 2520 347 347 2521 368 368 2522 361 361 2523 369 369 2524 371 371 2525 348 348 2526 370 370 2527 372 372 2528 351 351 2529 349 349 2530 371 371 2531 352 352 2532 350 350 2533 372 372 2534 351 351 2535 373 373 2536 375 375 2537 352 352 2538 374 374 2539 376 376 2540 355 355 2541 353 353 2542 375 375 2543 369 369 2544 390 390 2545 377 377 2546 370 370 2547 391 391 2548 378 378 2549 373 373 2550 371 371 2551 377 377 2552 374 374 2553 372 372 2554 378 378 2555 373 373 2556 379 379 2557 381 381 2558 376 376 2559 374 374 2560 380 380 2561 375 375 2562 381 381 2563 383 383 2564 376 376 2565 382 382 2566 384 384 2567 364 364 2568 363 363 2569 383 383 2570 365 365 2571 362 362 2572 384 384 2573 364 364 2574 385 385 2575 387 387 2576 365 365 2577 386 386 2578 388 388 2579 369 369 2580 367 367 2581 388 388 2582 370 370 2583 368 368 2584 389 389 2585 385 385 2586 383 383 2587 392 392 2588 386 386 2589 384 384 2590 394 394 2591 385 385 2592 393 393 2593 396 396 2594 386 386 2595 395 395 2596 397 397 2597 388 388 2598 397 397 2599 399 399 2600 389 389 2601 398 398 2602 400 400 2603 390 390 2604 399 399 2605 401 401 2606 391 391 2607 400 400 2608 402 402 2609 379 379 2610 377 377 2611 401 401 2612 380 380 2613 378 378 2614 402 402 2615 379 379 2616 403 403 2617 405 405 2618 380 380 2619 404 404 2620 406 406 2621 381 381 2622 405 405 2623 392 392 2624 382 382 2625 406 406 2626 394 394 2627 402 402 2628 400 400 2629 407 407 2630 403 403 2631 401 401 2632 409 409 2633 404 404 2634 402 402 2635 408 408 2636 403 403 2637 410 410 2638 412 412 2639 406 406 2640 404 404 2641 411 411 2642 405 405 2643 412 412 2644 414 414 2645 406 406 2646 413 413 2647 415 415 2648 393 393 2649 392 392 2650 414 414 2651 395 395 2652 394 394 2653 415 415 2654 393 393 2655 416 416 2656 418 418 2657 395 395 2658 417 417 2659 419 419 2660 399 399 2661 397 397 2662 419 419 2663 398 398 2664 420 420 2665 407 407 2666 399 399 2667 421 421 2668 409 409 2669 417 417 2670 415 415 2671 422 422 2672 416 416 2673 436 436 2674 424 424 2675 417 417 2676 423 423 2677 425 425 2678 421 421 2679 419 419 2680 425 425 2681 420 420 2682 426 426 2683 428 428 2684 421 421 2685 427 427 2686 429 429 2687 407 407 2688 428 428 2689 430 430 2690 410 410 2691 409 409 2692 429 429 2693 408 408 2694 430 430 2695 432 432 2696 410 410 2697 431 431 2698 433 433 2699 413 413 2700 411 411 2701 432 432 2702 412 412 2703 433 433 2704 435 435 2705 413 413 2706 434 434 2707 422 422 2708 414 414 2709 435 435 2710 436 436 2711 431 431 2712 429 429 2713 437 437 2714 430 430 2715 451 451 2716 439 439 2717 431 431 2718 438 438 2719 440 440 2720 434 434 2721 432 432 2722 439 439 2723 435 435 2724 433 433 2725 440 440 2726 434 434 2727 441 441 2728 443 443 2729 435 435 2730 442 442 2731 444 444 2732 423 423 2733 422 422 2734 443 443 2735 436 436 2736 444 444 2737 446 446 2738 425 425 2739 423 423 2740 445 445 2741 425 425 2742 447 447 2743 449 449 2744 426 426 2745 448 448 2746 450 450 2747 427 427 2748 449 449 2749 437 437 2750 428 428 2751 450 450 2752 451 451 2753 444 444 2754 465 465 2755 452 452 2756 445 445 2757 466 466 2758 453 453 2759 447 447 2760 453 453 2761 455 455 2762 450 450 2763 448 448 2764 454 454 2765 449 449 2766 455 455 2767 457 457 2768 451 451 2769 450 450 2770 456 456 2771 438 438 2772 437 437 2773 457 457 2774 439 439 2775 451 451 2776 458 458 2777 438 438 2778 459 459 2779 461 461 2780 441 441 2781 439 439 2782 460 460 2783 440 440 2784 461 461 2785 463 463 2786 441 441 2787 462 462 2788 464 464 2789 442 442 2790 463 463 2791 465 465 2792 445 445 2793 443 443 2794 464 464 2795 459 459 2796 481 481 2797 467 467 2798 462 462 2799 460 460 2800 468 468 2801 461 461 2802 467 467 2803 470 470 2804 462 462 2805 469 469 2806 471 471 2807 463 463 2808 470 470 2809 472 472 2810 466 466 2811 464 464 2812 471 471 2813 452 452 2814 465 465 2815 472 472 2816 466 466 2817 473 473 2818 475 475 2819 453 453 2820 475 475 2821 477 477 2822 454 454 2823 476 476 2824 478 478 2825 455 455 2826 477 477 2827 479 479 2828 456 456 2829 478 478 2830 480 480 2831 459 459 2832 457 457 2833 479 479 2834 458 458 2835 480 480 2836 468 468 2837 475 475 2838 2 2 2839 10 10 2840 478 478 2841 476 476 2842 3 3 2843 477 477 2844 10 10 2845 13 13 2846 480 480 2847 478 478 2848 12 12 2849 479 479 2850 13 13 2851 18 18 2852 468 468 2853 480 480 2854 15 15 2855 481 481 2856 18 18 2857 21 21 2858 469 469 2859 468 468 2860 20 20 2861 467 467 2862 21 21 2863 26 26 2864 471 471 2865 469 469 2866 24 24 2867 470 470 2868 26 26 2869 30 30 2870 473 473 2871 471 471 2872 28 28 2873 472 472 2874 30 30 2875 7 7 2876 475 475 2877 473 473 2878 0 0 2879</p>
+        </triangles>
+      </mesh>
+    </geometry>
+  </library_geometries>
+  <library_visual_scenes>
+    <visual_scene id="Scene" name="Scene">
+      <node id="Sphere" name="Sphere" type="NODE">
+        <matrix sid="transform">1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1</matrix>
+        <instance_geometry url="#Sphere-mesh" name="Sphere">
+          <bind_material>
+            <technique_common>
+              <instance_material symbol="ReflectProbePreviewMat-material" target="#ReflectProbePreviewMat-material">
+                <bind_vertex_input semantic="UVMap" input_semantic="TEXCOORD" input_set="0"/>
+              </instance_material>
+            </technique_common>
+          </bind_material>
+        </instance_geometry>
+      </node>
+    </visual_scene>
+  </library_visual_scenes>
+  <scene>
+    <instance_visual_scene url="#Scene"/>
+  </scene>
+</COLLADA>
\ No newline at end of file

From cde1d68f78960905f10ae33fb93637e55efd0506 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Sat, 25 Dec 2021 12:30:31 -0600
Subject: [PATCH 292/399] Fixes handling in the generic creator function to
 deal with commands formatted with "return " at the start AND without Fixes
 assignment of default material to convex shape when the toolbar button is
 pressed to create a 1u cube automatically.

---
 .../BaseGame/game/tools/convexEditor/convexEditorGui.tscript  | 2 ++
 .../game/tools/worldEditor/scripts/editors/creator.ed.tscript | 4 ++++
 2 files changed, 6 insertions(+)

diff --git a/Templates/BaseGame/game/tools/convexEditor/convexEditorGui.tscript b/Templates/BaseGame/game/tools/convexEditor/convexEditorGui.tscript
index 253508d75..09215601a 100644
--- a/Templates/BaseGame/game/tools/convexEditor/convexEditorGui.tscript
+++ b/Templates/BaseGame/game/tools/convexEditor/convexEditorGui.tscript
@@ -51,6 +51,8 @@ function ConvexEditorGui::onSleep( %this )
 function ConvexEditorGui::createConvexBox( %this )
 {
    %obj = genericCreateObject( "ConvexShape" );
+   %obj.setMaterial(%this.materialName); //set whatever the editor has as it's default material to the new one
+   
    %this.handleDeselect();
    %this.selectConvex( %obj );
    %this.dropSelectionAtScreenCenter();
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/editors/creator.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/editors/creator.ed.tscript
index 201347e2e..7ec1015a7 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/editors/creator.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/editors/creator.ed.tscript
@@ -227,6 +227,10 @@ function ObjectCreator::createObject( %this, %cmd )
       %this.setNewObjectGroup( getScene(0) );
 
    pushInstantGroup();
+   
+   if(startsWith(%cmd, "return "))
+      %objId = eval(%cmd);
+   else
    %objId = eval("return " @ %cmd);
    popInstantGroup();
    

From 165459c90be228427a6d12ed9f5fcc40bd5fd8c0 Mon Sep 17 00:00:00 2001
From: Lukas Aldershaab <lpjoergensen@gmail.com>
Date: Sun, 2 Jan 2022 12:18:25 +0100
Subject: [PATCH 293/399] Improve tinyXml2 output formatting

---
 Engine/source/persistence/taml/fsTinyXml.cpp | 422 +++++++++++++------
 Engine/source/persistence/taml/fsTinyXml.h   |  25 ++
 2 files changed, 308 insertions(+), 139 deletions(-)

diff --git a/Engine/source/persistence/taml/fsTinyXml.cpp b/Engine/source/persistence/taml/fsTinyXml.cpp
index e0dc53572..09da8d16b 100644
--- a/Engine/source/persistence/taml/fsTinyXml.cpp
+++ b/Engine/source/persistence/taml/fsTinyXml.cpp
@@ -26,6 +26,182 @@
 
 #include "console/console.h"
 
+
+// Re-implement private functionality in TinyXML2
+
+static const char LINE_FEED = static_cast<char>(0x0a);			// all line endings are normalized to LF
+static const char LF = LINE_FEED;
+static const char CARRIAGE_RETURN = static_cast<char>(0x0d);			// CR gets filtered out
+static const char CR = CARRIAGE_RETURN;
+static const char SINGLE_QUOTE = '\'';
+static const char DOUBLE_QUOTE = '\"';
+
+struct Entity {
+   const char* pattern;
+   int length;
+   char value;
+};
+
+static const int NUM_ENTITIES = 5;
+static const Entity entities[NUM_ENTITIES] = {
+    { "quot", 4,	DOUBLE_QUOTE },
+    { "amp", 3,		'&'  },
+    { "apos", 4,	SINGLE_QUOTE },
+    { "lt",	2, 		'<'	 },
+    { "gt",	2,		'>'	 }
+};
+
+VfsXMLPrinter::VfsXMLPrinter(FileStream& stream, bool compact, int depth)
+   : XMLPrinter(NULL, compact, depth),
+     m_Stream(stream),
+     _depth(depth)
+{
+   for (int i = 0; i < ENTITY_RANGE; ++i) {
+      _entityFlag[i] = false;
+      _restrictedEntityFlag[i] = false;
+   }
+   for (int i = 0; i < NUM_ENTITIES; ++i) {
+      const char entityValue = entities[i].value;
+      const unsigned char flagIndex = static_cast<unsigned char>(entityValue);
+      TIXMLASSERT(flagIndex < ENTITY_RANGE);
+      _entityFlag[flagIndex] = true;
+   }
+   _restrictedEntityFlag[static_cast<unsigned char>('&')] = true;
+   _restrictedEntityFlag[static_cast<unsigned char>('<')] = true;
+   _restrictedEntityFlag[static_cast<unsigned char>('>')] = true;	// not required, but consistency is nice
+}
+
+VfsXMLPrinter::~VfsXMLPrinter()
+{
+   m_Stream.flush();
+   m_Stream.close();
+}
+
+void VfsXMLPrinter::PrintString(const char* p, bool restricted)
+{
+   // Look for runs of bytes between entities to print.
+   const char* q = p;
+
+   if (_processEntities) {
+      const bool* flag = restricted ? _restrictedEntityFlag : _entityFlag;
+      while (*q) {
+         TIXMLASSERT(p <= q);
+         // Remember, char is sometimes signed. (How many times has that bitten me?)
+         if (*q > 0 && *q < ENTITY_RANGE) {
+            // Check for entities. If one is found, flush
+            // the stream up until the entity, write the
+            // entity, and keep looking.
+            if (flag[static_cast<unsigned char>(*q)]) {
+               while (p < q) {
+                  const size_t delta = q - p;
+                  const int toPrint = (INT_MAX < delta) ? INT_MAX : static_cast<int>(delta);
+                  Write(p, toPrint);
+                  p += toPrint;
+               }
+               bool entityPatternPrinted = false;
+               for (int i = 0; i < NUM_ENTITIES; ++i) {
+                  if (entities[i].value == *q) {
+                     Putc('&');
+                     Write(entities[i].pattern, entities[i].length);
+                     Putc(';');
+                     entityPatternPrinted = true;
+                     break;
+                  }
+               }
+               if (!entityPatternPrinted) {
+                  // TIXMLASSERT( entityPatternPrinted ) causes gcc -Wunused-but-set-variable in release
+                  TIXMLASSERT(false);
+               }
+               ++p;
+            }
+         }
+         ++q;
+         TIXMLASSERT(p <= q);
+      }
+      // Flush the remaining string. This will be the entire
+      // string if an entity wasn't found.
+      if (p < q) {
+         const size_t delta = q - p;
+         const int toPrint = (INT_MAX < delta) ? INT_MAX : static_cast<int>(delta);
+         Write(p, toPrint);
+      }
+   }
+   else {
+      Write(p);
+   }
+}
+
+bool VfsXMLPrinter::VisitEnter(const tinyxml2::XMLDocument& doc)
+{
+   _processEntities = doc.ProcessEntities();
+   return XMLPrinter::VisitEnter(doc);
+}
+
+bool VfsXMLPrinter::VisitExit(const tinyxml2::XMLElement& element)
+{
+   _depth--;
+   return XMLPrinter::VisitExit(element);
+}
+
+
+// Add VFS friendly implementations of output functions
+
+void VfsXMLPrinter::Print(const char* format, ...)
+{
+   va_list     va;
+   va_start(va, format);
+
+   m_Stream.writeFormattedBuffer(format, va);
+
+   va_end(va);
+}
+
+void VfsXMLPrinter::Write(const char* data, size_t size)
+{
+   m_Stream.write(size, data);
+}
+
+void VfsXMLPrinter::Putc(char ch)
+{
+   m_Stream.write(static_cast<U8>(ch));
+}
+
+// Overwrite Visitation of elements to add newlines before attributes
+
+bool VfsXMLPrinter::VisitEnter(const tinyxml2::XMLElement& element, const tinyxml2::XMLAttribute* attribute)
+{
+   const tinyxml2::XMLElement* parentElem = 0;
+   if (element.Parent()) {
+      parentElem = element.Parent()->ToElement();
+   }
+   const bool compactMode = parentElem ? CompactMode(*parentElem) : CompactMode(element);
+   OpenElement(element.Name(), compactMode);
+   _depth++;
+   while (attribute) {
+      PushAttribute(attribute->Name(), attribute->Value(), compactMode);
+      attribute = attribute->Next();
+   }
+   return true;
+}
+
+void VfsXMLPrinter::PushAttribute(const char* name, const char* value, bool compactMode)
+{
+   TIXMLASSERT(_elementJustOpened);
+   if (compactMode)
+   {
+      Putc(' ');
+   }
+   else
+   {
+      Putc('\n');
+      PrintSpace(_depth);
+   }
+   Write(name);
+   Write("=\"");
+   PrintString(value, false);
+   Putc('\"');
+}
+
 bool VfsXMLDocument::LoadFile(const char* pFilename)
 {
    // Expand the file-path.
@@ -61,6 +237,113 @@ bool VfsXMLDocument::LoadFile(const char* pFilename)
    return true;
 }
 
+bool VfsXMLDocument::LoadFile(FileStream& stream)
+{
+   // Delete the existing data:
+   Clear();
+   // Clear shadowed error
+   ClearError();
+   //TODO: Can't clear location, investigate if this gives issues.
+   //doc.location.Clear();
+
+   // Get the file size, so we can pre-allocate the string. HUGE speed impact.
+   long length = stream.getStreamSize();
+
+   // Strange case, but good to handle up front.
+   if (length <= 0)
+   {
+      SetError(tinyxml2::XML_ERROR_EMPTY_DOCUMENT, 0, 0);
+      return false;
+   }
+
+   // Subtle bug here. TinyXml did use fgets. But from the XML spec:
+   // 2.11 End-of-Line Handling
+   // <snip>
+   // <quote>
+   // ...the XML processor MUST behave as if it normalized all line breaks in external 
+   // parsed entities (including the document entity) on input, before parsing, by translating 
+   // both the two-character sequence #xD #xA and any #xD that is not followed by #xA to 
+   // a single #xA character.
+   // </quote>
+   //
+   // It is not clear fgets does that, and certainly isn't clear it works cross platform. 
+   // Generally, you expect fgets to translate from the convention of the OS to the c/unix
+   // convention, and not work generally.
+
+   /*
+   while( fgets( buf, sizeof(buf), file ) )
+   {
+   data += buf;
+   }
+   */
+
+   char* buf = new char[length + 1];
+   buf[0] = 0;
+
+   if (!stream.read(length, buf))
+   {
+      delete[] buf;
+      SetError(tinyxml2::XML_ERROR_FILE_COULD_NOT_BE_OPENED, 0, 0);
+      return false;
+   }
+
+   // Process the buffer in place to normalize new lines. (See comment above.)
+   // Copies from the 'p' to 'q' pointer, where p can advance faster if
+   // a newline-carriage return is hit.
+   //
+   // Wikipedia:
+   // Systems based on ASCII or a compatible character set use either LF  (Line feed, '\n', 0x0A, 10 in decimal) or 
+   // CR (Carriage return, '\r', 0x0D, 13 in decimal) individually, or CR followed by LF (CR+LF, 0x0D 0x0A)...
+   //                * LF:    Multics, Unix and Unix-like systems (GNU/Linux, AIX, Xenix, Mac OS X, FreeBSD, etc.), BeOS, Amiga, RISC OS, and others
+   //                * CR+LF: DEC RT-11 and most other early non-Unix, non-IBM OSes, CP/M, MP/M, DOS, OS/2, Microsoft Windows, Symbian OS
+   //                * CR:    Commodore 8-bit machines, Apple II family, Mac OS up to version 9 and OS-9
+
+   const char* p = buf; // the read head
+   char* q = buf; // the write head
+   const char CR = 0x0d;
+   const char LF = 0x0a;
+
+   buf[length] = 0;
+   while (*p)
+   {
+      assert(p < (buf + length));
+      assert(q <= (buf + length));
+      assert(q <= p);
+
+      if (*p == CR)
+      {
+         *q++ = LF;
+         p++;
+         if (*p == LF)
+         {
+            // check for CR+LF (and skip LF)
+            p++;
+         }
+      }
+      else
+      {
+         *q++ = *p++;
+      }
+   }
+   assert(q <= (buf + length));
+   *q = 0;
+
+   Parse(buf, length);
+
+   delete[] buf;
+   return !Error();
+}
+
+bool VfsXMLDocument::SaveFile(FileStream& stream)
+{
+   // Clear any error from the last save, otherwise it will get reported
+   // for *this* call.
+   ClearError();
+   VfsXMLPrinter printer(stream, false, 0);
+   Print(&printer);
+   return !Error();
+}
+
 bool VfsXMLDocument::SaveFile(const char* pFilename)
 {
    // Expand the file-name into the file-path buffer.
@@ -118,142 +401,3 @@ void VfsXMLDocument::SetError(tinyxml2::XMLError error, int lineNum, const char*
    _errorStr.SetStr(buffer);
    delete[] buffer;
 }
-
-VfsXMLPrinter::VfsXMLPrinter(FileStream& stream, bool compact, int depth)
-   : XMLPrinter(NULL, compact, depth),
-     m_Stream(stream)
-{
-}
-
-VfsXMLPrinter::~VfsXMLPrinter()
-{
-   m_Stream.flush();
-   m_Stream.close();
-}
-
-void VfsXMLPrinter::Print(const char* format, ...)
-{
-   va_list     va;
-   va_start(va, format);
-
-   m_Stream.writeFormattedBuffer(format, va);
-
-   va_end(va);
-}
-
-void VfsXMLPrinter::Write(const char* data, size_t size)
-{
-   m_Stream.write(size, data);
-}
-
-void VfsXMLPrinter::Putc(char ch)
-{
-   m_Stream.write(static_cast<U8>(ch));
-}
-
-bool VfsXMLDocument::LoadFile(FileStream& stream)
-{
-   // Delete the existing data:
-   Clear();
-   // Clear shadowed error
-   ClearError();
-   //TODO: Can't clear location, investigate if this gives issues.
-   //doc.location.Clear();
-
-   // Get the file size, so we can pre-allocate the string. HUGE speed impact.
-   long length = stream.getStreamSize();
-
-   // Strange case, but good to handle up front.
-   if (length <= 0)
-   {
-      SetError(tinyxml2::XML_ERROR_EMPTY_DOCUMENT, 0, 0);
-      return false;
-   }
-
-   // Subtle bug here. TinyXml did use fgets. But from the XML spec:
-   // 2.11 End-of-Line Handling
-   // <snip>
-   // <quote>
-   // ...the XML processor MUST behave as if it normalized all line breaks in external 
-   // parsed entities (including the document entity) on input, before parsing, by translating 
-   // both the two-character sequence #xD #xA and any #xD that is not followed by #xA to 
-   // a single #xA character.
-   // </quote>
-   //
-   // It is not clear fgets does that, and certainly isn't clear it works cross platform. 
-   // Generally, you expect fgets to translate from the convention of the OS to the c/unix
-   // convention, and not work generally.
-
-   /*
-   while( fgets( buf, sizeof(buf), file ) )
-   {
-   data += buf;
-   }
-   */
-
-   char* buf = new char[length + 1];
-   buf[0] = 0;
-
-   if (!stream.read(length, buf))
-   {
-      delete [] buf;
-      SetError(tinyxml2::XML_ERROR_FILE_COULD_NOT_BE_OPENED, 0, 0);
-      return false;
-   }
-
-   // Process the buffer in place to normalize new lines. (See comment above.)
-   // Copies from the 'p' to 'q' pointer, where p can advance faster if
-   // a newline-carriage return is hit.
-   //
-   // Wikipedia:
-   // Systems based on ASCII or a compatible character set use either LF  (Line feed, '\n', 0x0A, 10 in decimal) or 
-   // CR (Carriage return, '\r', 0x0D, 13 in decimal) individually, or CR followed by LF (CR+LF, 0x0D 0x0A)...
-   //                * LF:    Multics, Unix and Unix-like systems (GNU/Linux, AIX, Xenix, Mac OS X, FreeBSD, etc.), BeOS, Amiga, RISC OS, and others
-   //                * CR+LF: DEC RT-11 and most other early non-Unix, non-IBM OSes, CP/M, MP/M, DOS, OS/2, Microsoft Windows, Symbian OS
-   //                * CR:    Commodore 8-bit machines, Apple II family, Mac OS up to version 9 and OS-9
-
-   const char* p = buf; // the read head
-   char* q = buf; // the write head
-   const char CR = 0x0d;
-   const char LF = 0x0a;
-
-   buf[length] = 0;
-   while (*p)
-   {
-      assert(p < (buf+length));
-      assert(q <= (buf+length));
-      assert(q <= p);
-
-      if (*p == CR)
-      {
-         *q++ = LF;
-         p++;
-         if (*p == LF)
-         {
-            // check for CR+LF (and skip LF)
-            p++;
-         }
-      }
-      else
-      {
-         *q++ = *p++;
-      }
-   }
-   assert(q <= (buf+length));
-   *q = 0;
-
-   Parse(buf, length);
-
-   delete [] buf;
-   return !Error();
-}
-
-bool VfsXMLDocument::SaveFile(FileStream& stream)
-{
-   // Clear any error from the last save, otherwise it will get reported
-   // for *this* call.
-   ClearError();
-   VfsXMLPrinter printer(stream, false, 0);
-   Print(&printer);
-   return !Error();
-}
diff --git a/Engine/source/persistence/taml/fsTinyXml.h b/Engine/source/persistence/taml/fsTinyXml.h
index 2a83cb614..8c10463dc 100644
--- a/Engine/source/persistence/taml/fsTinyXml.h
+++ b/Engine/source/persistence/taml/fsTinyXml.h
@@ -40,10 +40,35 @@ public:
    VfsXMLPrinter(FileStream& stream, bool compact = false, int depth = 0);
    ~VfsXMLPrinter() override;
 
+   // Re-implement private functionality in TinyXML2 library, this is just a copy-paste job
+   void PrintString(const char*, bool restrictedEntitySet);	// prints out, after detecting entities.
+
+   virtual bool VisitEnter(const tinyxml2::XMLDocument& /*doc*/);
+   virtual bool VisitExit(const tinyxml2::XMLElement& element);
+
+   // Add VFS friendly implementations of output functions
    void Print(const char* format, ...) override;
    void Write(const char* data, size_t size) override;
+   inline void Write(const char* data) { Write(data, strlen(data)); }
    void Putc(char ch) override;
+
+   // Overwrite Visitation of elements to add newlines before attributes
+   virtual bool VisitEnter(const tinyxml2::XMLElement& element, const tinyxml2::XMLAttribute* attribute);
+   void PushAttribute(const char* name, const char* value, bool compactMode);
+
+   // Accept a virtual FileStream instead of a FILE pointer
    FileStream& m_Stream;
+
+   // Track private fields that are necessary for private functionality in TinyXML2
+   int _depth;
+   bool _processEntities;
+
+   enum {
+      ENTITY_RANGE = 64,
+      BUF_SIZE = 200
+   };
+   bool _entityFlag[ENTITY_RANGE];
+   bool _restrictedEntityFlag[ENTITY_RANGE];
 };
 
 class VfsXMLDocument : public tinyxml2::XMLDocument

From 5abd66dfa3101899f583a6ff3471ec97359269a2 Mon Sep 17 00:00:00 2001
From: Lukas Aldershaab <lpjoergensen@gmail.com>
Date: Mon, 3 Jan 2022 21:10:26 +0100
Subject: [PATCH 294/399] Split PrettyPrinting functionality from VFS printing

---
 Engine/source/persistence/taml/fsTinyXml.cpp | 254 ++++++++-----------
 Engine/source/persistence/taml/fsTinyXml.h   | 107 +++++++-
 2 files changed, 212 insertions(+), 149 deletions(-)

diff --git a/Engine/source/persistence/taml/fsTinyXml.cpp b/Engine/source/persistence/taml/fsTinyXml.cpp
index 09da8d16b..32eb5de38 100644
--- a/Engine/source/persistence/taml/fsTinyXml.cpp
+++ b/Engine/source/persistence/taml/fsTinyXml.cpp
@@ -26,49 +26,10 @@
 
 #include "console/console.h"
 
-
-// Re-implement private functionality in TinyXML2
-
-static const char LINE_FEED = static_cast<char>(0x0a);			// all line endings are normalized to LF
-static const char LF = LINE_FEED;
-static const char CARRIAGE_RETURN = static_cast<char>(0x0d);			// CR gets filtered out
-static const char CR = CARRIAGE_RETURN;
-static const char SINGLE_QUOTE = '\'';
-static const char DOUBLE_QUOTE = '\"';
-
-struct Entity {
-   const char* pattern;
-   int length;
-   char value;
-};
-
-static const int NUM_ENTITIES = 5;
-static const Entity entities[NUM_ENTITIES] = {
-    { "quot", 4,	DOUBLE_QUOTE },
-    { "amp", 3,		'&'  },
-    { "apos", 4,	SINGLE_QUOTE },
-    { "lt",	2, 		'<'	 },
-    { "gt",	2,		'>'	 }
-};
-
 VfsXMLPrinter::VfsXMLPrinter(FileStream& stream, bool compact, int depth)
    : XMLPrinter(NULL, compact, depth),
-     m_Stream(stream),
-     _depth(depth)
+     m_Stream(stream)
 {
-   for (int i = 0; i < ENTITY_RANGE; ++i) {
-      _entityFlag[i] = false;
-      _restrictedEntityFlag[i] = false;
-   }
-   for (int i = 0; i < NUM_ENTITIES; ++i) {
-      const char entityValue = entities[i].value;
-      const unsigned char flagIndex = static_cast<unsigned char>(entityValue);
-      TIXMLASSERT(flagIndex < ENTITY_RANGE);
-      _entityFlag[flagIndex] = true;
-   }
-   _restrictedEntityFlag[static_cast<unsigned char>('&')] = true;
-   _restrictedEntityFlag[static_cast<unsigned char>('<')] = true;
-   _restrictedEntityFlag[static_cast<unsigned char>('>')] = true;	// not required, but consistency is nice
 }
 
 VfsXMLPrinter::~VfsXMLPrinter()
@@ -77,72 +38,6 @@ VfsXMLPrinter::~VfsXMLPrinter()
    m_Stream.close();
 }
 
-void VfsXMLPrinter::PrintString(const char* p, bool restricted)
-{
-   // Look for runs of bytes between entities to print.
-   const char* q = p;
-
-   if (_processEntities) {
-      const bool* flag = restricted ? _restrictedEntityFlag : _entityFlag;
-      while (*q) {
-         TIXMLASSERT(p <= q);
-         // Remember, char is sometimes signed. (How many times has that bitten me?)
-         if (*q > 0 && *q < ENTITY_RANGE) {
-            // Check for entities. If one is found, flush
-            // the stream up until the entity, write the
-            // entity, and keep looking.
-            if (flag[static_cast<unsigned char>(*q)]) {
-               while (p < q) {
-                  const size_t delta = q - p;
-                  const int toPrint = (INT_MAX < delta) ? INT_MAX : static_cast<int>(delta);
-                  Write(p, toPrint);
-                  p += toPrint;
-               }
-               bool entityPatternPrinted = false;
-               for (int i = 0; i < NUM_ENTITIES; ++i) {
-                  if (entities[i].value == *q) {
-                     Putc('&');
-                     Write(entities[i].pattern, entities[i].length);
-                     Putc(';');
-                     entityPatternPrinted = true;
-                     break;
-                  }
-               }
-               if (!entityPatternPrinted) {
-                  // TIXMLASSERT( entityPatternPrinted ) causes gcc -Wunused-but-set-variable in release
-                  TIXMLASSERT(false);
-               }
-               ++p;
-            }
-         }
-         ++q;
-         TIXMLASSERT(p <= q);
-      }
-      // Flush the remaining string. This will be the entire
-      // string if an entity wasn't found.
-      if (p < q) {
-         const size_t delta = q - p;
-         const int toPrint = (INT_MAX < delta) ? INT_MAX : static_cast<int>(delta);
-         Write(p, toPrint);
-      }
-   }
-   else {
-      Write(p);
-   }
-}
-
-bool VfsXMLPrinter::VisitEnter(const tinyxml2::XMLDocument& doc)
-{
-   _processEntities = doc.ProcessEntities();
-   return XMLPrinter::VisitEnter(doc);
-}
-
-bool VfsXMLPrinter::VisitExit(const tinyxml2::XMLElement& element)
-{
-   _depth--;
-   return XMLPrinter::VisitExit(element);
-}
-
 
 // Add VFS friendly implementations of output functions
 
@@ -166,42 +61,6 @@ void VfsXMLPrinter::Putc(char ch)
    m_Stream.write(static_cast<U8>(ch));
 }
 
-// Overwrite Visitation of elements to add newlines before attributes
-
-bool VfsXMLPrinter::VisitEnter(const tinyxml2::XMLElement& element, const tinyxml2::XMLAttribute* attribute)
-{
-   const tinyxml2::XMLElement* parentElem = 0;
-   if (element.Parent()) {
-      parentElem = element.Parent()->ToElement();
-   }
-   const bool compactMode = parentElem ? CompactMode(*parentElem) : CompactMode(element);
-   OpenElement(element.Name(), compactMode);
-   _depth++;
-   while (attribute) {
-      PushAttribute(attribute->Name(), attribute->Value(), compactMode);
-      attribute = attribute->Next();
-   }
-   return true;
-}
-
-void VfsXMLPrinter::PushAttribute(const char* name, const char* value, bool compactMode)
-{
-   TIXMLASSERT(_elementJustOpened);
-   if (compactMode)
-   {
-      Putc(' ');
-   }
-   else
-   {
-      Putc('\n');
-      PrintSpace(_depth);
-   }
-   Write(name);
-   Write("=\"");
-   PrintString(value, false);
-   Putc('\"');
-}
-
 bool VfsXMLDocument::LoadFile(const char* pFilename)
 {
    // Expand the file-path.
@@ -340,7 +199,8 @@ bool VfsXMLDocument::SaveFile(FileStream& stream)
    // for *this* call.
    ClearError();
    VfsXMLPrinter printer(stream, false, 0);
-   Print(&printer);
+   PrettyXMLPrinter prettyPrinter(printer);
+   Print(&prettyPrinter);
    return !Error();
 }
 
@@ -401,3 +261,111 @@ void VfsXMLDocument::SetError(tinyxml2::XMLError error, int lineNum, const char*
    _errorStr.SetStr(buffer);
    delete[] buffer;
 }
+
+
+// Overwrite Visitation of elements to add newlines before attributes
+PrettyXMLPrinter::PrettyXMLPrinter(VfsXMLPrinter& innerPrinter, int depth)
+   : mInnerPrinter(innerPrinter),
+   _depth(depth)
+{
+   for (int i = 0; i < ENTITY_RANGE; ++i) {
+      _entityFlag[i] = false;
+      _restrictedEntityFlag[i] = false;
+   }
+   for (int i = 0; i < NUM_ENTITIES; ++i) {
+      const char entityValue = entities[i].value;
+      const unsigned char flagIndex = static_cast<unsigned char>(entityValue);
+      TIXMLASSERT(flagIndex < ENTITY_RANGE);
+      _entityFlag[flagIndex] = true;
+   }
+   _restrictedEntityFlag[static_cast<unsigned char>('&')] = true;
+   _restrictedEntityFlag[static_cast<unsigned char>('<')] = true;
+   _restrictedEntityFlag[static_cast<unsigned char>('>')] = true;	// not required, but consistency is nice
+}
+
+void PrettyXMLPrinter::PrintString(const char* p, bool restricted)
+{
+   // Look for runs of bytes between entities to print.
+   const char* q = p;
+
+   if (_processEntities) {
+      const bool* flag = restricted ? _restrictedEntityFlag : _entityFlag;
+      while (*q) {
+         TIXMLASSERT(p <= q);
+         // Remember, char is sometimes signed. (How many times has that bitten me?)
+         if (*q > 0 && *q < ENTITY_RANGE) {
+            // Check for entities. If one is found, flush
+            // the stream up until the entity, write the
+            // entity, and keep looking.
+            if (flag[static_cast<unsigned char>(*q)]) {
+               while (p < q) {
+                  const size_t delta = q - p;
+                  const int toPrint = (INT_MAX < delta) ? INT_MAX : static_cast<int>(delta);
+                  mInnerPrinter.Write(p, toPrint);
+                  p += toPrint;
+               }
+               bool entityPatternPrinted = false;
+               for (int i = 0; i < NUM_ENTITIES; ++i) {
+                  if (entities[i].value == *q) {
+                     mInnerPrinter.Putc('&');
+                     mInnerPrinter.Write(entities[i].pattern, entities[i].length);
+                     mInnerPrinter.Putc(';');
+                     entityPatternPrinted = true;
+                     break;
+                  }
+               }
+               if (!entityPatternPrinted) {
+                  // TIXMLASSERT( entityPatternPrinted ) causes gcc -Wunused-but-set-variable in release
+                  TIXMLASSERT(false);
+               }
+               ++p;
+            }
+         }
+         ++q;
+         TIXMLASSERT(p <= q);
+      }
+      // Flush the remaining string. This will be the entire
+      // string if an entity wasn't found.
+      if (p < q) {
+         const size_t delta = q - p;
+         const int toPrint = (INT_MAX < delta) ? INT_MAX : static_cast<int>(delta);
+         mInnerPrinter.Write(p, toPrint);
+      }
+   }
+   else {
+      mInnerPrinter.Write(p);
+   }
+}
+
+bool PrettyXMLPrinter::VisitEnter(const tinyxml2::XMLElement& element, const tinyxml2::XMLAttribute* attribute)
+{
+   const tinyxml2::XMLElement* parentElem = 0;
+   if (element.Parent()) {
+      parentElem = element.Parent()->ToElement();
+   }
+   const bool compactMode = parentElem ? mInnerPrinter.CompactMode(*parentElem) : mInnerPrinter.CompactMode(element);
+   mInnerPrinter.OpenElement(element.Name(), compactMode);
+   _depth++;
+   while (attribute) {
+      PushAttribute(attribute->Name(), attribute->Value(), compactMode);
+      attribute = attribute->Next();
+   }
+   return true;
+}
+
+void PrettyXMLPrinter::PushAttribute(const char* name, const char* value, bool compactMode)
+{
+   if (compactMode)
+   {
+      mInnerPrinter.Putc(' ');
+   }
+   else
+   {
+      mInnerPrinter.Putc('\n');
+      mInnerPrinter.PrintSpace(_depth);
+   }
+   mInnerPrinter.Write(name);
+   mInnerPrinter.Write("=\"");
+   PrintString(value, false);
+   mInnerPrinter.Putc('\"');
+}
diff --git a/Engine/source/persistence/taml/fsTinyXml.h b/Engine/source/persistence/taml/fsTinyXml.h
index 8c10463dc..972e05794 100644
--- a/Engine/source/persistence/taml/fsTinyXml.h
+++ b/Engine/source/persistence/taml/fsTinyXml.h
@@ -41,19 +41,16 @@ public:
    ~VfsXMLPrinter() override;
 
    // Re-implement private functionality in TinyXML2 library, this is just a copy-paste job
-   void PrintString(const char*, bool restrictedEntitySet);	// prints out, after detecting entities.
-
-   virtual bool VisitEnter(const tinyxml2::XMLDocument& /*doc*/);
-   virtual bool VisitExit(const tinyxml2::XMLElement& element);
+   bool CompactMode(const tinyxml2::XMLElement& element) override { return tinyxml2::XMLPrinter::CompactMode(element); }
 
    // Add VFS friendly implementations of output functions
    void Print(const char* format, ...) override;
    void Write(const char* data, size_t size) override;
    inline void Write(const char* data) { Write(data, strlen(data)); }
    void Putc(char ch) override;
+   void PrintSpace(int depth) override { tinyxml2::XMLPrinter::PrintSpace(depth); }
 
    // Overwrite Visitation of elements to add newlines before attributes
-   virtual bool VisitEnter(const tinyxml2::XMLElement& element, const tinyxml2::XMLAttribute* attribute);
    void PushAttribute(const char* name, const char* value, bool compactMode);
 
    // Accept a virtual FileStream instead of a FILE pointer
@@ -63,10 +60,12 @@ public:
    int _depth;
    bool _processEntities;
 
-   enum {
+   enum
+   {
       ENTITY_RANGE = 64,
       BUF_SIZE = 200
    };
+
    bool _entityFlag[ENTITY_RANGE];
    bool _restrictedEntityFlag[ENTITY_RANGE];
 };
@@ -152,4 +151,100 @@ public:
    }
 };
 
+class PrettyXMLPrinter : public tinyxml2::XMLPrinter
+{
+   // Re-implement private functionality in TinyXML2
+   static const char LINE_FEED = static_cast<char>(0x0a); // all line endings are normalized to LF
+   static const char LF = LINE_FEED;
+   static const char CARRIAGE_RETURN = static_cast<char>(0x0d); // CR gets filtered out
+   static const char CR = CARRIAGE_RETURN;
+   static const char SINGLE_QUOTE = '\'';
+   static const char DOUBLE_QUOTE = '\"';
+
+   struct Entity
+   {
+      const char* pattern;
+      int length;
+      char value;
+   };
+
+   static const int NUM_ENTITIES = 5;
+   static constexpr  Entity entities[NUM_ENTITIES] = {
+      {"quot", 4, DOUBLE_QUOTE},
+      {"amp", 3, '&'},
+      {"apos", 4, SINGLE_QUOTE},
+      {"lt", 2, '<'},
+      {"gt", 2, '>'}
+   };
+public:
+   PrettyXMLPrinter(VfsXMLPrinter& innerPrinter, int depth = 0);
+
+   /// Visit a document.
+   virtual bool VisitEnter(const tinyxml2::XMLDocument& doc)
+   {
+      _processEntities = doc.ProcessEntities();
+      return mInnerPrinter.VisitEnter(doc);
+   }
+
+   /// Visit a document.
+   virtual bool VisitExit(const tinyxml2::XMLDocument& doc)
+   {
+      return mInnerPrinter.VisitExit(doc);
+   }
+
+   /// Visit an element.
+   virtual bool VisitEnter(const tinyxml2::XMLElement& element, const tinyxml2::XMLAttribute* firstAttribute);
+   /// Visit an element.
+   virtual bool VisitExit(const tinyxml2::XMLElement& element)
+   {
+      _depth--;
+      return mInnerPrinter.VisitExit(element);
+   }
+
+   /// Visit a declaration.
+   virtual bool Visit(const tinyxml2::XMLDeclaration& declaration)
+   {
+      return mInnerPrinter.Visit(declaration);
+   }
+
+   /// Visit a text node.
+   virtual bool Visit(const tinyxml2::XMLText& text)
+   {
+      return mInnerPrinter.Visit(text);
+   }
+
+   /// Visit a comment node.
+   virtual bool Visit(const tinyxml2::XMLComment& comment)
+   {
+      return mInnerPrinter.Visit(comment);
+   }
+
+   /// Visit an unknown node.
+   virtual bool Visit(const tinyxml2::XMLUnknown& unknown)
+   {
+      return mInnerPrinter.Visit(unknown);
+   }
+
+   void PushAttribute(const char* name, const char* value, bool compactMode);
+
+   // Re-implement private functionality in TinyXML2 library, this is just a copy-paste job
+   void PrintString(const char*, bool restrictedEntitySet); // prints out, after detecting entities.
+   VfsXMLPrinter& mInnerPrinter;
+
+   // Track private fields that are necessary for private functionality in TinyXML2
+   int _depth;
+   bool _processEntities;
+   bool _compactMode;
+
+   enum
+   {
+      ENTITY_RANGE = 64,
+      BUF_SIZE = 200
+   };
+
+   bool _entityFlag[ENTITY_RANGE];
+   bool _restrictedEntityFlag[ENTITY_RANGE];
+};
+
+
 #endif //_FSTINYXML_H_

From 3ef57168b200a6bbca4e9971afd21378594a8a48 Mon Sep 17 00:00:00 2001
From: Lukas Aldershaab <lpjoergensen@gmail.com>
Date: Mon, 3 Jan 2022 21:16:34 +0100
Subject: [PATCH 295/399] Cleanup fsTinyXml implementation

---
 Engine/source/persistence/taml/fsTinyXml.cpp | 22 +++++-----
 Engine/source/persistence/taml/fsTinyXml.h   | 42 +++++++-------------
 2 files changed, 26 insertions(+), 38 deletions(-)

diff --git a/Engine/source/persistence/taml/fsTinyXml.cpp b/Engine/source/persistence/taml/fsTinyXml.cpp
index 32eb5de38..961d96b0e 100644
--- a/Engine/source/persistence/taml/fsTinyXml.cpp
+++ b/Engine/source/persistence/taml/fsTinyXml.cpp
@@ -266,21 +266,21 @@ void VfsXMLDocument::SetError(tinyxml2::XMLError error, int lineNum, const char*
 // Overwrite Visitation of elements to add newlines before attributes
 PrettyXMLPrinter::PrettyXMLPrinter(VfsXMLPrinter& innerPrinter, int depth)
    : mInnerPrinter(innerPrinter),
-   _depth(depth)
+   mDepth(depth)
 {
    for (int i = 0; i < ENTITY_RANGE; ++i) {
-      _entityFlag[i] = false;
-      _restrictedEntityFlag[i] = false;
+      mEntityFlag[i] = false;
+      mRestrictedEntityFlag[i] = false;
    }
    for (int i = 0; i < NUM_ENTITIES; ++i) {
       const char entityValue = entities[i].value;
       const unsigned char flagIndex = static_cast<unsigned char>(entityValue);
       TIXMLASSERT(flagIndex < ENTITY_RANGE);
-      _entityFlag[flagIndex] = true;
+      mEntityFlag[flagIndex] = true;
    }
-   _restrictedEntityFlag[static_cast<unsigned char>('&')] = true;
-   _restrictedEntityFlag[static_cast<unsigned char>('<')] = true;
-   _restrictedEntityFlag[static_cast<unsigned char>('>')] = true;	// not required, but consistency is nice
+   mRestrictedEntityFlag[static_cast<unsigned char>('&')] = true;
+   mRestrictedEntityFlag[static_cast<unsigned char>('<')] = true;
+   mRestrictedEntityFlag[static_cast<unsigned char>('>')] = true;	// not required, but consistency is nice
 }
 
 void PrettyXMLPrinter::PrintString(const char* p, bool restricted)
@@ -288,8 +288,8 @@ void PrettyXMLPrinter::PrintString(const char* p, bool restricted)
    // Look for runs of bytes between entities to print.
    const char* q = p;
 
-   if (_processEntities) {
-      const bool* flag = restricted ? _restrictedEntityFlag : _entityFlag;
+   if (mProcessEntities) {
+      const bool* flag = restricted ? mRestrictedEntityFlag : mEntityFlag;
       while (*q) {
          TIXMLASSERT(p <= q);
          // Remember, char is sometimes signed. (How many times has that bitten me?)
@@ -345,7 +345,7 @@ bool PrettyXMLPrinter::VisitEnter(const tinyxml2::XMLElement& element, const tin
    }
    const bool compactMode = parentElem ? mInnerPrinter.CompactMode(*parentElem) : mInnerPrinter.CompactMode(element);
    mInnerPrinter.OpenElement(element.Name(), compactMode);
-   _depth++;
+   mDepth++;
    while (attribute) {
       PushAttribute(attribute->Name(), attribute->Value(), compactMode);
       attribute = attribute->Next();
@@ -362,7 +362,7 @@ void PrettyXMLPrinter::PushAttribute(const char* name, const char* value, bool c
    else
    {
       mInnerPrinter.Putc('\n');
-      mInnerPrinter.PrintSpace(_depth);
+      mInnerPrinter.PrintSpace(mDepth);
    }
    mInnerPrinter.Write(name);
    mInnerPrinter.Write("=\"");
diff --git a/Engine/source/persistence/taml/fsTinyXml.h b/Engine/source/persistence/taml/fsTinyXml.h
index 972e05794..c4a0d55c2 100644
--- a/Engine/source/persistence/taml/fsTinyXml.h
+++ b/Engine/source/persistence/taml/fsTinyXml.h
@@ -40,34 +40,19 @@ public:
    VfsXMLPrinter(FileStream& stream, bool compact = false, int depth = 0);
    ~VfsXMLPrinter() override;
 
-   // Re-implement private functionality in TinyXML2 library, this is just a copy-paste job
+   // Re-implement protected functionality in TinyXML2 library, and make it public
+   // (This is a bit dirty, but it's necessary for the PrettyXMLPrinter)
    bool CompactMode(const tinyxml2::XMLElement& element) override { return tinyxml2::XMLPrinter::CompactMode(element); }
+   void PrintSpace(int depth) override { tinyxml2::XMLPrinter::PrintSpace(depth); }
+   inline void Write(const char* data) { Write(data, strlen(data)); }
 
    // Add VFS friendly implementations of output functions
    void Print(const char* format, ...) override;
    void Write(const char* data, size_t size) override;
-   inline void Write(const char* data) { Write(data, strlen(data)); }
    void Putc(char ch) override;
-   void PrintSpace(int depth) override { tinyxml2::XMLPrinter::PrintSpace(depth); }
-
-   // Overwrite Visitation of elements to add newlines before attributes
-   void PushAttribute(const char* name, const char* value, bool compactMode);
 
    // Accept a virtual FileStream instead of a FILE pointer
    FileStream& m_Stream;
-
-   // Track private fields that are necessary for private functionality in TinyXML2
-   int _depth;
-   bool _processEntities;
-
-   enum
-   {
-      ENTITY_RANGE = 64,
-      BUF_SIZE = 200
-   };
-
-   bool _entityFlag[ENTITY_RANGE];
-   bool _restrictedEntityFlag[ENTITY_RANGE];
 };
 
 class VfsXMLDocument : public tinyxml2::XMLDocument
@@ -182,7 +167,7 @@ public:
    /// Visit a document.
    virtual bool VisitEnter(const tinyxml2::XMLDocument& doc)
    {
-      _processEntities = doc.ProcessEntities();
+      mProcessEntities = doc.ProcessEntities();
       return mInnerPrinter.VisitEnter(doc);
    }
 
@@ -197,7 +182,7 @@ public:
    /// Visit an element.
    virtual bool VisitExit(const tinyxml2::XMLElement& element)
    {
-      _depth--;
+      mDepth--;
       return mInnerPrinter.VisitExit(element);
    }
 
@@ -224,17 +209,20 @@ public:
    {
       return mInnerPrinter.Visit(unknown);
    }
-
+   
    void PushAttribute(const char* name, const char* value, bool compactMode);
 
    // Re-implement private functionality in TinyXML2 library, this is just a copy-paste job
    void PrintString(const char*, bool restrictedEntitySet); // prints out, after detecting entities.
+
+   // The inner printer we are wrapping, we only support VfsXMLPrinter based classes because
+   // stock tinyxml printer is very closed
    VfsXMLPrinter& mInnerPrinter;
 
    // Track private fields that are necessary for private functionality in TinyXML2
-   int _depth;
-   bool _processEntities;
-   bool _compactMode;
+   int mDepth;
+   bool mProcessEntities;
+   bool mCompactMode;
 
    enum
    {
@@ -242,8 +230,8 @@ public:
       BUF_SIZE = 200
    };
 
-   bool _entityFlag[ENTITY_RANGE];
-   bool _restrictedEntityFlag[ENTITY_RANGE];
+   bool mEntityFlag[ENTITY_RANGE];
+   bool mRestrictedEntityFlag[ENTITY_RANGE];
 };
 
 

From 15ef8b4fbea85ca0fafd228bd58dd768299e9aac Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Mon, 3 Jan 2022 20:57:10 -0600
Subject: [PATCH 296/399] Cleaned up implementation of #712 Also updates other
 game classes like the shapebase to utilize the sound asset hooks properly.

---
 Engine/source/T3D/assets/SoundAsset.cpp       |  13 +-
 Engine/source/T3D/fx/explosion.cpp            |   9 +-
 Engine/source/T3D/gameBase/gameConnection.cpp |  83 +++++++------
 Engine/source/T3D/gameBase/gameConnection.h   |   4 +-
 .../T3D/gameBase/gameConnectionEvents.cpp     | 104 +++++++++++++++-
 .../T3D/gameBase/gameConnectionEvents.h       |  20 ++++
 Engine/source/T3D/shapeBase.cpp               |  62 ++++++----
 Engine/source/T3D/shapeBase.h                 |  13 +-
 Engine/source/T3D/shapeImage.cpp              |  62 ++++++----
 Engine/source/sfx/sfxPlayList.cpp             |   8 +-
 Engine/source/sfx/sfxProfile.cpp              |  10 +-
 Engine/source/sfx/sfxSystem.cpp               | 111 ++++--------------
 12 files changed, 312 insertions(+), 187 deletions(-)

diff --git a/Engine/source/T3D/assets/SoundAsset.cpp b/Engine/source/T3D/assets/SoundAsset.cpp
index 45f78bc48..06a30b7e4 100644
--- a/Engine/source/T3D/assets/SoundAsset.cpp
+++ b/Engine/source/T3D/assets/SoundAsset.cpp
@@ -218,6 +218,9 @@ bool SoundAsset::loadSound()
       {
          Con::errorf("SoundAsset::initializeAsset: Attempted to load file %s but it was not valid!", mSoundFile);
          mLoadedState = BadFileReference;
+         mSFXProfile.setDescription(NULL);
+         mSFXProfile.setSoundFileName(StringTable->insert(StringTable->EmptyString()));
+         mSFXProfile.setPreload(false);
          return false;
       }
       else
@@ -257,7 +260,7 @@ StringTableEntry SoundAsset::getAssetIdByFileName(StringTableEntry fileName)
    if (fileName == StringTable->EmptyString())
       return StringTable->EmptyString();
 
-   StringTableEntry materialAssetId = "";
+   StringTableEntry soundAssetId = StringTable->EmptyString();
 
    AssetQuery query;
    U32 foundCount = AssetDatabase.findAssetType(&query, "SoundAsset");
@@ -268,7 +271,7 @@ StringTableEntry SoundAsset::getAssetIdByFileName(StringTableEntry fileName)
          SoundAsset* soundAsset = AssetDatabase.acquireAsset<SoundAsset>(query.mAssetList[i]);
          if (soundAsset && soundAsset->getSoundPath() == fileName)
          {
-            materialAssetId = soundAsset->getAssetId();
+            soundAssetId = soundAsset->getAssetId();
             AssetDatabase.releaseAsset(query.mAssetList[i]);
             break;
          }
@@ -276,7 +279,7 @@ StringTableEntry SoundAsset::getAssetIdByFileName(StringTableEntry fileName)
       }
    }
 
-   return materialAssetId;
+   return soundAssetId;
 }
 
 U32 SoundAsset::getAssetById(StringTableEntry assetId, AssetPtr<SoundAsset>* soundAsset)
@@ -330,8 +333,8 @@ DefineEngineMethod(SoundAsset, getSoundPath, const char*, (), , "")
 }
 
 DefineEngineMethod(SoundAsset, playSound, S32, (Point3F position), (Point3F::Zero),
-   "Gets the number of materials for this shape asset.\n"
-   "@return Material count.\n")
+   "Plays the sound for this asset.\n"
+   "@return (sound plays).\n")
 {
    if (object->getSfxProfile())
    {
diff --git a/Engine/source/T3D/fx/explosion.cpp b/Engine/source/T3D/fx/explosion.cpp
index 88a5a9432..d73d1bc01 100644
--- a/Engine/source/T3D/fx/explosion.cpp
+++ b/Engine/source/T3D/fx/explosion.cpp
@@ -859,9 +859,6 @@ bool ExplosionData::preload(bool server, String &errorStr)
    if (Parent::preload(server, errorStr) == false)
       return false;
 
-   if (!server && !getSoundProfile())
-      return false;
-
    if( !server )
    {
 
@@ -870,12 +867,18 @@ bool ExplosionData::preload(bool server, String &errorStr)
          _setSound(getSound());
 
          if (!getSoundProfile())
+         {
             Con::errorf(ConsoleLogEntry::General, "SplashData::preload: Cant get an sfxProfile for splash.");
+            return false;
+         }
       }
 
       if (!particleEmitter && particleEmitterId != 0)
          if (Sim::findObject(particleEmitterId, particleEmitter) == false)
+         {
             Con::errorf(ConsoleLogEntry::General, "Error, unable to load particle emitter for explosion datablock");
+            return false;
+         }
    }
 
    if (mExplosionShapeAsset.notNull()) {
diff --git a/Engine/source/T3D/gameBase/gameConnection.cpp b/Engine/source/T3D/gameBase/gameConnection.cpp
index f759a03da..0331e3764 100644
--- a/Engine/source/T3D/gameBase/gameConnection.cpp
+++ b/Engine/source/T3D/gameBase/gameConnection.cpp
@@ -1562,33 +1562,50 @@ void GameConnection::packetDropped(PacketNotify *note)
 
 //----------------------------------------------------------------------------
 
-void GameConnection::play2D(SFXProfile* profile)
+void GameConnection::play2D(StringTableEntry assetId)
 {
-   postNetEvent(new Sim2DAudioEvent(profile));
+   if (AssetDatabase.isDeclaredAsset(assetId))
+   {
+
+      AssetPtr<SoundAsset> tempSoundAsset;
+      tempSoundAsset = assetId;
+
+      postNetEvent(new SimSoundAssetEvent(tempSoundAsset));
+
+   }
 }
 
-void GameConnection::play3D(SFXProfile* profile, const MatrixF *transform)
+void GameConnection::play3D(StringTableEntry assetId, const MatrixF *transform)
 {
    if ( !transform )
-      play2D(profile);
+      play2D(assetId);
 
-   else if ( !mControlObject )
-      postNetEvent(new Sim3DAudioEvent(profile,transform));
-
-   else
+   if (AssetDatabase.isDeclaredAsset(assetId))
    {
-      // TODO: Maybe improve this to account for the duration
-      // of the sound effect and if the control object can get
-      // into hearing range within time?
 
-      // Only post the event if it's within audible range
-      // of the control object.
-      Point3F ear,pos;
-      transform->getColumn(3,&pos);
-      mControlObject->getTransform().getColumn(3,&ear);
-      if ((ear - pos).len() < profile->getDescription()->mMaxDistance)
-         postNetEvent(new Sim3DAudioEvent(profile,transform));
-   } 
+      AssetPtr<SoundAsset> tempSoundAsset;
+      tempSoundAsset = assetId;
+
+      if (!mControlObject)
+         postNetEvent(new SimSoundAssetEvent(tempSoundAsset, transform));
+      else
+      {
+         // TODO: Maybe improve this to account for the duration
+         // of the sound effect and if the control object can get
+         // into hearing range within time?
+
+         // Only post the event if it's within audible range
+         // of the control object.
+         tempSoundAsset->getSfxDescription();
+         Point3F ear, pos;
+         transform->getColumn(3, &pos);
+         mControlObject->getTransform().getColumn(3, &ear);
+         if ((ear - pos).len() < tempSoundAsset->getSfxDescription()->mMaxDistance)
+            postNetEvent(new SimSoundAssetEvent(tempSoundAsset, transform));
+      }
+
+   }
+
 }
 
 void GameConnection::doneScopingScene()
@@ -2010,49 +2027,49 @@ DefineEngineMethod( GameConnection, isControlObjectRotDampedCamera, bool, (),,
    return object->isControlObjectRotDampedCamera();
 }
 
-DefineEngineMethod( GameConnection, play2D, bool, (SFXProfile* profile),,
+DefineEngineMethod( GameConnection, play2D, bool, (StringTableEntry assetId),,
    "@brief Used on the server to play a 2D sound that is not attached to any object.\n\n"
 
-   "@param profile The SFXProfile that defines the sound to play.\n\n"
+   "@param assetID The SoundAsset ID that defines the sound to play.\n"
 
    "@tsexample\n"
-   "function ServerPlay2D(%profile)\n"
+   "function ServerPlay2D(%assetId)\n"
    "{\n"
-   "   // Play the given sound profile on every client.\n"
+   "   // Play the given sound asset on every client.\n"
    "   // The sounds will be transmitted as an event, not attached to any object.\n"
    "   for(%idx = 0; %idx < ClientGroup.getCount(); %idx++)\n"
-   "      ClientGroup.getObject(%idx).play2D(%profile);\n"
+   "      ClientGroup.getObject(%idx).play2D(%assetId);\n"
    "}\n"
    "@endtsexample\n\n")
 {
-   if(!profile)
+   if(assetId == StringTable->EmptyString())
       return false;
 
-   object->play2D(profile);
+   object->play2D(assetId);
    return true;
 }
 
-DefineEngineMethod( GameConnection, play3D, bool, (SFXProfile* profile, TransformF location),,
+DefineEngineMethod( GameConnection, play3D, bool, (StringTableEntry assetId, TransformF location),,
    "@brief Used on the server to play a 3D sound that is not attached to any object.\n\n"
    
-   "@param profile The SFXProfile that defines the sound to play.\n"
+   "@param assetID The SoundAsset ID that defines the sound to play.\n"
    "@param location The position and orientation of the 3D sound given in the form of \"x y z ax ay az aa\".\n\n"
 
    "@tsexample\n"
-   "function ServerPlay3D(%profile,%transform)\n"
+   "function ServerPlay3D(%assetId,%transform)\n"
    "{\n"
-   "   // Play the given sound profile at the given position on every client\n"
+   "   // Play the given sound asset at the given position on every client\n"
    "   // The sound will be transmitted as an event, not attached to any object.\n"
    "   for(%idx = 0; %idx < ClientGroup.getCount(); %idx++)\n"
-   "      ClientGroup.getObject(%idx).play3D(%profile,%transform);\n"
+   "      ClientGroup.getObject(%idx).play3D(%assetID,%transform);\n"
    "}\n"
    "@endtsexample\n\n")
 {
-   if(!profile)
+   if(assetId == StringTable->EmptyString())
       return false;
 
    MatrixF mat = location.getMatrix();
-   object->play3D(profile,&mat);
+   object->play3D(assetId,&mat);
    return true;
 }
 
diff --git a/Engine/source/T3D/gameBase/gameConnection.h b/Engine/source/T3D/gameBase/gameConnection.h
index c735fb62c..64cdb3cbd 100644
--- a/Engine/source/T3D/gameBase/gameConnection.h
+++ b/Engine/source/T3D/gameBase/gameConnection.h
@@ -352,8 +352,8 @@ public:
    /// @name Sound
    /// @{
 
-   void play2D(SFXProfile *profile);
-   void play3D(SFXProfile *profile, const MatrixF *transform);
+   void play2D(StringTableEntry assetId);
+   void play3D(StringTableEntry assetId, const MatrixF *transform);
    /// @}
 
    /// @name Misc.
diff --git a/Engine/source/T3D/gameBase/gameConnectionEvents.cpp b/Engine/source/T3D/gameBase/gameConnectionEvents.cpp
index 4aff2ce64..d2c3badce 100644
--- a/Engine/source/T3D/gameBase/gameConnectionEvents.cpp
+++ b/Engine/source/T3D/gameBase/gameConnectionEvents.cpp
@@ -47,6 +47,7 @@
 
 //--------------------------------------------------------------------------
 IMPLEMENT_CO_CLIENTEVENT_V1(SimDataBlockEvent);
+IMPLEMENT_CO_CLIENTEVENT_V1(SimSoundAssetEvent);
 IMPLEMENT_CO_CLIENTEVENT_V1(Sim2DAudioEvent);
 IMPLEMENT_CO_CLIENTEVENT_V1(Sim3DAudioEvent);
 IMPLEMENT_CO_CLIENTEVENT_V1(SetMissionCRCEvent);
@@ -293,6 +294,104 @@ void SimDataBlockEvent::process(NetConnection *cptr)
 
 //----------------------------------------------------------------------------
 
+static F32 SoundPosAccuracy = 0.5;
+static S32 SoundRotBits = 8;
+
+SimSoundAssetEvent::SimSoundAssetEvent(AssetPtr<SoundAsset> asset, const MatrixF* mat)
+{
+   // cant get here unless the asset is declared.
+   mAsset = asset;
+
+   if (mat)
+      mTransform = *mat;
+}
+
+void SimSoundAssetEvent::pack(NetConnection* con, BitStream* stream)
+{
+   NetStringHandle assetIdStr = mAsset->getAssetId();
+   con->packNetStringHandleU(stream, assetIdStr);
+
+   // only stream if this is a 3d sound asset.
+   if (mAsset->is3D())
+   {
+      SFXDescription* ad = mAsset->getSfxDescription();
+      if (stream->writeFlag(ad->mConeInsideAngle || ad->mConeOutsideAngle))
+      {
+         QuatF q(mTransform);
+         q.normalize();
+
+         // LH - we can get a valid quat that's very slightly over 1 in and so
+         // this fails (barely) check against zero.  So use some error-
+         AssertFatal((1.0 - ((q.x * q.x) + (q.y * q.y) + (q.z * q.z))) >= (0.0 - 0.001),
+            "QuatF::normalize() is broken in Sim3DAudioEvent");
+
+         stream->writeSignedFloat(q.x, SoundRotBits);
+         stream->writeSignedFloat(q.y, SoundRotBits);
+         stream->writeSignedFloat(q.z, SoundRotBits);
+         stream->writeFlag(q.w < 0.0);
+      }
+
+      Point3F pos;
+      mTransform.getColumn(3, &pos);
+      stream->writeCompressedPoint(pos, SoundPosAccuracy);
+   }
+
+}
+
+void SimSoundAssetEvent::write(NetConnection* con, BitStream* stream)
+{
+   // Just do the normal pack...
+   pack(con, stream);
+}
+
+void SimSoundAssetEvent::unpack(NetConnection* con, BitStream* stream)
+{
+
+   StringTableEntry temp = StringTable->insert(con->unpackNetStringHandleU(stream).getString());
+   if (AssetDatabase.isDeclaredAsset(temp))
+   {
+      AssetPtr<SoundAsset> tempSoundAsset;
+      tempSoundAsset = temp;
+
+      mAsset = temp;
+   }
+
+   if (mAsset->is3D())
+   {
+      if (stream->readFlag()) {
+         QuatF q;
+         q.x = stream->readSignedFloat(SoundRotBits);
+         q.y = stream->readSignedFloat(SoundRotBits);
+         q.z = stream->readSignedFloat(SoundRotBits);
+         F32 value = ((q.x * q.x) + (q.y * q.y) + (q.z * q.z));
+         // #ifdef __linux
+               // Hmm, this should never happen, but it does...
+         if (value > 1.f)
+            value = 1.f;
+         // #endif
+         q.w = mSqrt(1.f - value);
+         if (stream->readFlag())
+            q.w = -q.w;
+         q.setMatrix(&mTransform);
+      }
+      else
+         mTransform.identity();
+
+      Point3F pos;
+      stream->readCompressedPoint(&pos, SoundPosAccuracy);
+      mTransform.setColumn(3, pos);
+   }
+}
+
+void SimSoundAssetEvent::process(NetConnection* con)
+{
+
+   if (mAsset->is3D())
+      SFX->playOnce(mAsset->getSfxProfile(), &mTransform);
+   else
+      SFX->playOnce(mAsset->getSfxProfile());
+
+}
 
 Sim2DAudioEvent::Sim2DAudioEvent(SFXProfile *profile)
 {
@@ -321,11 +420,6 @@ void Sim2DAudioEvent::process(NetConnection *)
       SFX->playOnce( mProfile );
 }
 
-//----------------------------------------------------------------------------
-
-static F32 SoundPosAccuracy = 0.5;
-static S32 SoundRotBits = 8;
-
 Sim3DAudioEvent::Sim3DAudioEvent(SFXProfile *profile,const MatrixF* mat)
 {
    mProfile = profile;
diff --git a/Engine/source/T3D/gameBase/gameConnectionEvents.h b/Engine/source/T3D/gameBase/gameConnectionEvents.h
index b9652a940..ede198645 100644
--- a/Engine/source/T3D/gameBase/gameConnectionEvents.h
+++ b/Engine/source/T3D/gameBase/gameConnectionEvents.h
@@ -39,6 +39,9 @@
 #include "core/stream/bitStream.h"
 #endif
 
+#include "T3D/assets/SoundAsset.h"
+
+
 
 class QuitEvent : public SimEvent
 {
@@ -102,6 +105,23 @@ class SimDataBlockEvent : public NetEvent
       DECLARE_CATEGORY( "Game Networking" );
 };
 
+class SimSoundAssetEvent : public NetEvent
+{
+private:
+   AssetPtr<SoundAsset> mAsset;
+   MatrixF mTransform;
+
+public:
+   typedef NetEvent Parent;
+   
+   SimSoundAssetEvent(AssetPtr<SoundAsset> asset = NULL, const MatrixF* mat = NULL);
+   void pack(NetConnection*, BitStream* bstream);
+   void write(NetConnection*, BitStream* bstream);
+   void unpack(NetConnection*, BitStream* bstream);
+   void process(NetConnection*);
+   DECLARE_CONOBJECT(SimSoundAssetEvent);
+};
+
 class Sim2DAudioEvent: public NetEvent
 {
   private:
diff --git a/Engine/source/T3D/shapeBase.cpp b/Engine/source/T3D/shapeBase.cpp
index 4730ee6b7..dab20b693 100644
--- a/Engine/source/T3D/shapeBase.cpp
+++ b/Engine/source/T3D/shapeBase.cpp
@@ -1009,7 +1009,7 @@ ShapeBase::ShapeBase()
 
    for (i = 0; i < MaxSoundThreads; i++) {
       mSoundThread[i].play = false;
-      mSoundThread[i].profile = 0;
+      mSoundThread[i].asset = 0;
       mSoundThread[i].sound = 0;
    }
 
@@ -2233,24 +2233,30 @@ void ShapeBase::applyImpulse(const Point3F&,const VectorF&)
 
 //----------------------------------------------------------------------------
 
-void ShapeBase::playAudio(U32 slot,SFXTrack* profile)
+void ShapeBase::playAudio(U32 slot, StringTableEntry assetId)
 {
    AssertFatal( slot < MaxSoundThreads, "ShapeBase::playAudio() bad slot index" );
-   Sound& st = mSoundThread[slot];
-   if( profile && ( !st.play || st.profile != profile ) ) 
+   if (AssetDatabase.isDeclaredAsset(assetId))
+   {
+      AssetPtr<SoundAsset> tempSoundAsset;
+      tempSoundAsset = assetId;
+
+      SoundThread& st = mSoundThread[slot];
+      if (tempSoundAsset && (!st.play || st.asset != tempSoundAsset))
    {
       setMaskBits(SoundMaskN << slot);
       st.play = true;
-      st.profile = profile;
+         st.asset = tempSoundAsset;
       updateAudioState(st);
    }
+   }
 }
 
 void ShapeBase::stopAudio(U32 slot)
 {
    AssertFatal( slot < MaxSoundThreads, "ShapeBase::stopAudio() bad slot index" );
 
-   Sound& st = mSoundThread[slot];
+   SoundThread& st = mSoundThread[slot];
    if ( st.play ) 
    {
       st.play = false;
@@ -2263,7 +2269,7 @@ void ShapeBase::updateServerAudio()
 {
    // Timeout non-looping sounds
    for (S32 i = 0; i < MaxSoundThreads; i++) {
-      Sound& st = mSoundThread[i];
+      SoundThread& st = mSoundThread[i];
       if (st.play && st.timeout && st.timeout < Sim::getCurrentTime()) {
          clearMaskBits(SoundMaskN << i);
          st.play = false;
@@ -2271,17 +2277,18 @@ void ShapeBase::updateServerAudio()
    }
 }
 
-void ShapeBase::updateAudioState(Sound& st)
+void ShapeBase::updateAudioState(SoundThread& st)
 {
    SFX_DELETE( st.sound );
 
-   if ( st.play && st.profile ) 
+   if ( st.play && st.asset ) 
    {
       if ( isGhost() ) 
       {
-         if ( Sim::findObject( SimObjectId((uintptr_t)st.profile), st.profile ) )
+         // if asset is valid, play
+         if (st.asset->isAssetValid() )
          {
-            st.sound = SFX->createSource( st.profile, &getTransform() );
+            st.sound = SFX->createSource( st.asset->getSfxProfile() , &getTransform() );
             if ( st.sound )
                st.sound->play();
          }
@@ -2292,12 +2299,17 @@ void ShapeBase::updateAudioState(Sound& st)
       {
          // Non-looping sounds timeout on the server
          st.timeout = 0;
-         if ( !st.profile->getDescription()->mIsLooping )
+         if ( !st.asset->getSfxDescription()->mIsLooping )
             st.timeout = Sim::getCurrentTime() + sAudioTimeout;
       }
    }
    else
+   {
+      // st.sound was not stopped before. If this causes issues remove.
       st.play = false;
+      if (st.sound)
+         st.sound->stop();
+   }
 }
 
 void ShapeBase::updateAudioPos()
@@ -3122,13 +3134,15 @@ U32 ShapeBase::packUpdate(NetConnection *con, U32 mask, BitStream *stream)
 
    if (stream->writeFlag(mask & SoundMask)) {
       for (S32 i = 0; i < MaxSoundThreads; i++) {
-         Sound& st = mSoundThread[i];
+         SoundThread& st = mSoundThread[i];
          if (stream->writeFlag(mask & (SoundMaskN << i)))
             if (stream->writeFlag(st.play))
-               stream->writeRangedU32(st.profile->getId(),DataBlockObjectIdFirst,
-                                      DataBlockObjectIdLast);
+            {
+               NetStringHandle assetIdStr = st.asset->getAssetId();
+               con->packNetStringHandleU(stream, assetIdStr);
       }
    }
+   }
 
    if (stream->writeFlag(mask & ImageMask)) {
       for (S32 i = 0; i < MaxMountedImages; i++)
@@ -3242,12 +3256,18 @@ void ShapeBase::unpackUpdate(NetConnection *con, BitStream *stream)
       {
          if ( stream->readFlag() ) 
          {
-            Sound& st = mSoundThread[i];
+            SoundThread& st = mSoundThread[i];
             st.play = stream->readFlag();
             if ( st.play ) 
             {
-               st.profile = (SFXTrack*)(uintptr_t)stream->readRangedU32(  DataBlockObjectIdFirst,
-                                                                DataBlockObjectIdLast );
+               StringTableEntry temp = StringTable->insert(con->unpackNetStringHandleU(stream).getString());
+               if (AssetDatabase.isDeclaredAsset(temp))
+               {
+                  AssetPtr<SoundAsset> tempSoundAsset;
+                  tempSoundAsset = temp;
+
+                  st.asset = temp;
+               }
             }
 
             if ( isProperlyAdded() )
@@ -3777,7 +3797,7 @@ DefineEngineMethod( ShapeBase, isHidden, bool, (),,
 }
 
 //----------------------------------------------------------------------------
-DefineEngineMethod( ShapeBase, playAudio, bool, ( S32 slot, SFXTrack* track ),,
+DefineEngineMethod( ShapeBase, playAudio, bool, ( S32 slot, StringTableEntry assetId),,
    "@brief Attach a sound to this shape and start playing it.\n\n"
 
    "@param slot Audio slot index for the sound (valid range is 0 - 3)\n" // 3 = ShapeBase::MaxSoundThreads-1
@@ -3786,8 +3806,8 @@ DefineEngineMethod( ShapeBase, playAudio, bool, ( S32 slot, SFXTrack* track ),,
    
    "@see stopAudio()\n")
 {
-   if (track && slot >= 0 && slot < ShapeBase::MaxSoundThreads) {
-      object->playAudio(slot,track);
+   if (assetId && slot >= 0 && slot < ShapeBase::MaxSoundThreads) {
+      object->playAudio(slot, assetId);
       return true;
    }
    return false;
diff --git a/Engine/source/T3D/shapeBase.h b/Engine/source/T3D/shapeBase.h
index 920289385..6ef0fd985 100644
--- a/Engine/source/T3D/shapeBase.h
+++ b/Engine/source/T3D/shapeBase.h
@@ -265,6 +265,7 @@ struct ShapeBaseImageData: public GameBaseData {
       F32 emitterTime;              ///<
       S32 emitterNode[MaxShapes];   ///< Node ID on the shape to emit from
       SoundAsset* sound;
+      SFXTrack* soundTrack;         ///<Holdover for special, non-asset cases like SFXPlaylists
    };
    /// @name State Data
    /// Individual state data used to initialize struct array
@@ -744,13 +745,13 @@ protected:
 
    /// @name Scripted Sound
    /// @{
-   struct Sound {
+   struct SoundThread {
       bool play;                    ///< Are we playing this sound?
       SimTime timeout;              ///< Time until we stop playing this sound.
-      SFXTrack* profile;            ///< Profile on server
+      AssetPtr<SoundAsset> asset; ///< Asset on server
       SFXSource* sound;             ///< Sound on client
    };
-   Sound mSoundThread[MaxSoundThreads];
+   SoundThread mSoundThread[MaxSoundThreads];
    /// @}
 
    /// @name Scripted Animation Threads
@@ -1114,7 +1115,7 @@ protected:
 
    /// Updates the audio state of the supplied sound
    /// @param   st   Sound
-   void updateAudioState(Sound& st);
+   void updateAudioState(SoundThread& st);
 
    /// Recalculates the spacial sound based on the current position of the object
    /// emitting the sound.
@@ -1328,9 +1329,7 @@ public:
 
    /// Plays an audio sound from a mounted object
    /// @param   slot    Mount slot ID
-   /// @param   track   Audio track to play
-   void playAudio(U32 slot,SFXTrack* track);
-   void playAudio( U32 slot, SFXProfile* profile ) { playAudio( slot, ( SFXTrack* ) profile ); }
+   void playAudio(U32 slot, StringTableEntry assetId);
 
    /// Stops audio from a mounted object
    /// @param   slot   Mount slot ID
diff --git a/Engine/source/T3D/shapeImage.cpp b/Engine/source/T3D/shapeImage.cpp
index ee5d62476..88d5f837c 100644
--- a/Engine/source/T3D/shapeImage.cpp
+++ b/Engine/source/T3D/shapeImage.cpp
@@ -133,6 +133,7 @@ ShapeBaseImageData::StateData::StateData()
    spin = IgnoreSpin;
    recoil = NoRecoil;
    sound = NULL;
+   soundTrack = NULL;
    emitter = NULL;
    shapeSequence = NULL;
    shapeSequenceScale = true;
@@ -372,6 +373,19 @@ bool ShapeBaseImageData::onAdd()
 
          //_setstateSound(getstateSound(i),i);
          s.sound = getstateSoundAsset(i);
+         if (s.sound == NULL && mstateSoundName[i] != StringTable->EmptyString())
+         {
+            //ok, so we've got some sort of special-case here like a fallback or SFXPlaylist. So do the hook-up now
+            SFXTrack* sndTrack;
+            if (!Sim::findObject(mstateSoundName[i], sndTrack))
+            {
+               Con::errorf("ShapeBaseImageData::onAdd() - attempted to find sound %s but failed!", mstateSoundName[i]);
+            }
+            else
+            {
+               s.soundTrack = sndTrack;
+            }
+         }
          s.script = stateScript[i];
          s.emitter = stateEmitter[i];
          s.emitterTime = stateEmitterTime[i];
@@ -2580,7 +2594,7 @@ bool ShapeBase::hasImageState(U32 imageSlot, const char* state)
    return false;
 }
 
-void ShapeBase::setImageState(U32 imageSlot, U32 newState,bool force)
+void ShapeBase::setImageState(U32 imageSlot, U32 newState, bool force)
 {
    if (!mMountedImageList[imageSlot].dataBlock)
       return;
@@ -2611,12 +2625,12 @@ void ShapeBase::setImageState(U32 imageSlot, U32 newState,bool force)
    // Eject shell casing on every state change (client side only)
    ShapeBaseImageData::StateData& nextStateData = image.dataBlock->state[newState];
    if (isGhost() && nextStateData.ejectShell) {
-      ejectShellCasing( imageSlot );
+      ejectShellCasing(imageSlot);
    }
 
    // Shake camera on client.
    if (isGhost() && nextStateData.fire && image.dataBlock->shakeCamera) {
-      shakeCamera( imageSlot );
+      shakeCamera(imageSlot);
    }
 
    // Server must animate the shape if it is a firestate...
@@ -2632,12 +2646,12 @@ void ShapeBase::setImageState(U32 imageSlot, U32 newState,bool force)
    if (!force && image.state == &image.dataBlock->state[newState]) {
       image.delayTime = image.state->timeoutValue;
       if (image.state->script && !isGhost())
-         scriptCallback(imageSlot,image.state->script);
+         scriptCallback(imageSlot, image.state->script);
 
       // If this is a flash sequence, we need to select a new position for the
       //  animation if we're returning to that state...
       F32 randomPos = Platform::getRandom();
-      for (U32 i=0; i<ShapeBaseImageData::MaxShapes; ++i)
+      for (U32 i = 0; i < ShapeBaseImageData::MaxShapes; ++i)
       {
          if (!image.dataBlock->shapeIsValid[i] || (i != imageShapeIndex && !image.doAnimateAllShapes))
             continue;
@@ -2665,7 +2679,7 @@ void ShapeBase::setImageState(U32 imageSlot, U32 newState,bool force)
 
    // Mount pending images
    if (image.nextImage != InvalidImagePtr && stateData.allowImageChange) {
-      setImage(imageSlot,image.nextImage,image.nextSkinNameHandle,image.nextLoaded);
+      setImage(imageSlot, image.nextImage, image.nextSkinNameHandle, image.nextLoaded);
       return;
    }
 
@@ -2673,16 +2687,16 @@ void ShapeBase::setImageState(U32 imageSlot, U32 newState,bool force)
    // (the first key frame should be it's off state).
    // We need to do this across all image shapes to make sure we have no hold overs when switching
    // rendering shapes while in the middle of a state change.
-   for (U32 i=0; i<ShapeBaseImageData::MaxShapes; ++i)
+   for (U32 i = 0; i < ShapeBaseImageData::MaxShapes; ++i)
    {
       // If we are to do a sequence transition then we need to keep the previous animThread active
       if (image.animThread[i] && image.animThread[i]->getSequence()->isCyclic() && (stateData.sequenceNeverTransition || !(stateData.sequenceTransitionIn || lastState->sequenceTransitionOut))) {
-         image.shapeInstance[i]->setPos(image.animThread[i],0);
-         image.shapeInstance[i]->setTimeScale(image.animThread[i],0);
+         image.shapeInstance[i]->setPos(image.animThread[i], 0);
+         image.shapeInstance[i]->setTimeScale(image.animThread[i], 0);
       }
       if (image.flashThread[i]) {
-         image.shapeInstance[i]->setPos(image.flashThread[i],0);
-         image.shapeInstance[i]->setTimeScale(image.flashThread[i],0);
+         image.shapeInstance[i]->setPos(image.flashThread[i], 0);
+         image.shapeInstance[i]->setTimeScale(image.flashThread[i], 0);
       }
    }
 
@@ -2695,10 +2709,10 @@ void ShapeBase::setImageState(U32 imageSlot, U32 newState,bool force)
    if (image.delayTime <= 0 || !stateData.waitForTimeout) 
    {
       if ((ns = stateData.transition.loaded[image.loaded]) != -1) {
-         setImageState(imageSlot,ns);
+         setImageState(imageSlot, ns);
          return;
       }
-      for (U32 i=0; i<ShapeBaseImageData::MaxGenericTriggers; ++i)
+      for (U32 i = 0; i < ShapeBaseImageData::MaxGenericTriggers; ++i)
       {
          if ((ns = stateData.transition.genericTrigger[i][image.genericTrigger[i]]) != -1) {
             setImageState(imageSlot, ns);
@@ -2707,7 +2721,7 @@ void ShapeBase::setImageState(U32 imageSlot, U32 newState,bool force)
       }
       //if (!imageData.usesEnergy)
          if ((ns = stateData.transition.ammo[image.ammo]) != -1) {
-            setImageState(imageSlot,ns);
+         setImageState(imageSlot, ns);
             return;
          }
       if ((ns = stateData.transition.target[image.target]) != -1) {
@@ -2723,11 +2737,11 @@ void ShapeBase::setImageState(U32 imageSlot, U32 newState,bool force)
          return;
       }
       if ((ns = stateData.transition.trigger[image.triggerDown]) != -1) {
-         setImageState(imageSlot,ns);
+         setImageState(imageSlot, ns);
          return;
       }
       if ((ns = stateData.transition.altTrigger[image.altTriggerDown]) != -1) {
-         setImageState(imageSlot,ns);
+         setImageState(imageSlot, ns);
          return;
       }
    }
@@ -2752,7 +2766,7 @@ void ShapeBase::setImageState(U32 imageSlot, U32 newState,bool force)
 
    // Apply recoil
    if (stateData.recoil != ShapeBaseImageData::StateData::NoRecoil)
-      onImageRecoil(imageSlot,stateData.recoil);
+      onImageRecoil(imageSlot, stateData.recoil);
 
    // Apply image state animation on mounting shape
    if (stateData.shapeSequence && stateData.shapeSequence[0])
@@ -2764,17 +2778,25 @@ void ShapeBase::setImageState(U32 imageSlot, U32 newState,bool force)
    // lastState does not return an id for the prev state so we keep track of it.
    if (lastState->sound && lastState->sound->getSfxProfile()->getDescription()->mIsLooping)
    {  
-      for(Vector<SFXSource*>::iterator i = image.mSoundSources.begin(); i != image.mSoundSources.end(); i++)      
+      for (Vector<SFXSource*>::iterator i = image.mSoundSources.begin(); i != image.mSoundSources.end(); i++)
          SFX_DELETE((*i));    
 
       image.mSoundSources.clear();  
    }  
 
    // Play sound
-   if( stateData.sound && isGhost() )
+   if (isGhost())
+   {
+      if (stateData.sound)
    {
       const Point3F& velocity         = getVelocity();
-      image.addSoundSource(SFX->createSource(stateData.sound->getSfxProfile(), &getRenderTransform(), &velocity ));
+         image.addSoundSource(SFX->createSource(stateData.sound->getSfxProfile(), &getRenderTransform(), &velocity));
+      }
+      if (stateData.soundTrack)
+      {
+         const Point3F& velocity = getVelocity();
+         image.addSoundSource(SFX->createSource(stateData.soundTrack, &getRenderTransform(), &velocity));
+      }
    }
 
    // Play animation
diff --git a/Engine/source/sfx/sfxPlayList.cpp b/Engine/source/sfx/sfxPlayList.cpp
index 0e56d4607..ea186c125 100644
--- a/Engine/source/sfx/sfxPlayList.cpp
+++ b/Engine/source/sfx/sfxPlayList.cpp
@@ -352,15 +352,19 @@ bool SFXPlayList::preload( bool server, String& errorStr )
    {
       for( U32 i = 0; i < NUM_SLOTS; ++ i )
       {
-         _setTrack(getTrack(i),i);
+         StringTableEntry track = getTrack(i);
+         if (track != StringTable->EmptyString())
+         {
+            _setTrack(getTrack(i), i);
          if (!getTrackProfile(i))
          {
             Con::errorf("SFXPlayList::Preload() - unable to find sfxProfile for asset %s", mTrackAssetId[i]);
             return false;
          }
             
-         if( !sfxResolve( &mSlots.mState[ i ], errorStr ) )
+            if (!sfxResolve(&mSlots.mState[i], errorStr))
             return false;
+         }
       }
    }
       
diff --git a/Engine/source/sfx/sfxProfile.cpp b/Engine/source/sfx/sfxProfile.cpp
index 4cd6a8cdb..ab3bc44ab 100644
--- a/Engine/source/sfx/sfxProfile.cpp
+++ b/Engine/source/sfx/sfxProfile.cpp
@@ -35,6 +35,7 @@
 #include "core/stream/bitStream.h"
 #include "core/resourceManager.h"
 #include "console/engineAPI.h"
+#include "core/stream/fileStream.h"
 
 using namespace Torque;
 
@@ -283,8 +284,13 @@ bool SFXProfile::_preloadBuffer()
 
 Resource<SFXResource>& SFXProfile::getResource()
 {
-   if( !mResource && mFilename != StringTable->EmptyString())
-      mResource = SFXResource::load( mFilename );
+   char buf[1024];
+   FileName fullFilename = String(Platform::makeFullPathName(mFilename, buf, sizeof(buf)));
+
+   if (!mResource && SFXResource::exists(fullFilename))
+      mResource = SFXResource::load(mFilename);
+   else
+      mResource = NULL;
 
    return mResource;
 }
diff --git a/Engine/source/sfx/sfxSystem.cpp b/Engine/source/sfx/sfxSystem.cpp
index 3d793995e..d23880bfd 100644
--- a/Engine/source/sfx/sfxSystem.cpp
+++ b/Engine/source/sfx/sfxSystem.cpp
@@ -1581,133 +1581,70 @@ DefineEngineFunction( sfxPlay, S32, ( const char * trackName, const char * point
 //-----------------------------------------------------------------------------
 
 static ConsoleDocFragment _sPlayOnce1(
-   "@brief Create a play-once source for the given @a track.\n\n"
+   "@brief Create a play-once source for the given @a asset.\n\n"
    "Once playback has finished, the source will be automatically deleted in the next sound system update.\n"
    "@param track The sound datablock.\n"
    "@return A newly created temporary source in \"Playing\" state or 0 if the operation failed.\n\n"
    "@ref SFXSource_playonce\n\n"
    "@ingroup SFX",
    NULL,
-   "SFXSource sfxPlayOnce( SFXTrack track );"
+   "SFXSource sfxPlayOnce( StringTableEntry assetID );"
 );
 static ConsoleDocFragment _sPlayOnce2(
-   "@brief Create a play-once source for the given given @a track and position the source's 3D sound at the given coordinates "
-      "only if the track's description is set up for 3D sound).\n\n"
+   "@brief Create a play-once source for the given given @a asset and position the source's 3D sound at the given coordinates "
+      "only if the asset is set up for 3D sound).\n\n"
    "Once playback has finished, the source will be automatically deleted in the next sound system update.\n"
-   "@param track The sound datablock.\n"
+   "@param assetId The sound asset.\n"
    "@param x The X coordinate of the 3D sound position.\n"
    "@param y The Y coordinate of the 3D sound position.\n"
    "@param z The Z coordinate of the 3D sound position.\n"
-   "@param fadeInTime If >=0, this overrides the SFXDescription::fadeInTime value on the track's description.\n"
+   "@param fadeInTime If >=0, this overrides the SFXDescription::fadeInTime value on the asset's definition.\n"
    "@return A newly created temporary source in \"Playing\" state or 0 if the operation failed.\n\n"
    "@tsexample\n"
-      "// Immediately start playing the given track.  Fade it in to full volume over 5 seconds.\n"
-      "sfxPlayOnce( MusicTrack, 0, 0, 0, 5.f );\n"
+      "// Immediately start playing the given asset.  Fade it in to full volume over 5 seconds.\n"
+      "sfxPlayOnce( ExampleModule:MusicTrack, 0, 0, 0, 5.f );\n"
    "@endtsexample\n\n"
    "@ref SFXSource_playonce\n\n"
    "@ingroup SFX",
    NULL,
-   "SFXSource sfxPlayOnce( SFXTrack track, float x, float y, float z, float fadeInTime=-1 );"
-);
-static ConsoleDocFragment _sPlayOnce3(
-   "@brief Create a new temporary SFXProfile from the given @a description and @a filename, then create a play-once source "
-      "for it and start playback.\n\n"
-   "Once playback has finished, the source will be automatically deleted in the next sound system update.  If not referenced "
-      "otherwise by then, the temporary SFXProfile will also be deleted.\n"
-   "@param description The description to use for playback.\n"
-   "@param filename Path to the sound file to play.\n"
-   "@return A newly created temporary source in \"Playing\" state or 0 if the operation failed.\n\n"
-   "@tsexample\n"
-   "// Play a sound effect file once.\n"
-   "sfxPlayOnce( AudioEffects, \"art/sound/weapons/Weapon_pickup\" );\n"
-   "@endtsexample\n\n"
-   "@ref SFXSource_playonce\n\n"
-   "@ingroup SFX",
-   NULL,
-   "SFXSource sfxPlayOnce( SFXDescription description, string filename );"
-);
-static ConsoleDocFragment _sPlayOnce4(
-   "@brief Create a new temporary SFXProfile from the given @a description and @a filename, then create a play-once source "
-      "for it and start playback.  Position the source's 3D sound at the given coordinates (only if the description "
-      "is set up for 3D sound).\n\n"
-   "Once playback has finished, the source will be automatically deleted in the next sound system update.  If not referenced "
-      "otherwise by then, the temporary SFXProfile will also be deleted.\n"
-   "@param description The description to use for playback.\n"
-   "@param filename Path to the sound file to play.\n"
-   "@param x The X coordinate of the 3D sound position.\n"
-   "@param y The Y coordinate of the 3D sound position.\n"
-   "@param z The Z coordinate of the 3D sound position.\n"
-   "@param fadeInTime If >=0, this overrides the SFXDescription::fadeInTime value on the track's description.\n"
-   "@return A newly created temporary source in \"Playing\" state or 0 if the operation failed.\n\n"
-   "@tsexample\n"
-   "// Play a sound effect file once using a 3D sound with a default falloff placed at the origin.\n"
-   "sfxPlayOnce( AudioDefault3D, \"art/sound/weapons/Weapon_pickup\", 0, 0, 0 );\n"
-   "@endtsexample\n\n"
-   "@ref SFXSource_playonce\n\n"
-   "@ingroup SFX",
-   NULL,
-   "SFXSource sfxPlayOnce( SFXDescription description, string filename, float x, float y, float z, float fadeInTime=-1 );"
+   "SFXSource sfxPlayOnce( StringTableEntry assetID, float x, float y, float z, float fadeInTime=-1 );"
 );
 
-DefineEngineFunction( sfxPlayOnce, S32, ( const char * sfxType, const char * arg0, const char * arg1, const char * arg2, const char * arg3, const char* arg4 ), ("", "", "", "", "-1.0f"),
+DefineEngineFunction( sfxPlayOnce, S32, (StringTableEntry assetId, const char* arg0, const char * arg1, const char * arg2, const char * arg3 ), (StringTable->EmptyString(), "", "", "", "-1.0f"),
    "SFXSource sfxPlayOnce( ( SFXTrack track | SFXDescription description, string filename ) [, float x, float y, float z, float fadeInTime=-1 ] ) "
    "Create a new play-once source for the given profile or description+filename and start playback of the source.\n"
    "@hide" )
 {
    SFXDescription* description = NULL;
-   SFXTrack* track = dynamic_cast< SFXTrack* >( Sim::findObject( sfxType ) );
-   if( !track )
-   {
-      description = dynamic_cast< SFXDescription* >( Sim::findObject( sfxType ) );
-      if( !description )
+   if (assetId == StringTable->EmptyString())
       {
-         Con::errorf( "sfxPlayOnce - Unable to locate sound track/description '%s'", sfxType );
+         Con::errorf( "sfxPlayOnce - Must Define a sound asset");
          return 0;
       }
-   }
 
    SFXSource* source = NULL;
-   if( track )
+
+   if (AssetDatabase.isDeclaredAsset(assetId))
    {
-      // In this overloaded use, arg0..arg2 are x, y, z, and arg3 is the fadeInTime.
-      if (String::isEmpty(arg0))
+
+      AssetPtr<SoundAsset> tempSoundAsset;
+      tempSoundAsset = assetId;
+
+      if (String::isEmpty(arg0) || !tempSoundAsset->is3D())
       {
-         source = SFX->playOnce( track );
+         source = SFX->playOnce(tempSoundAsset->getSfxProfile());
       }
       else
       {
          MatrixF transform;
-         transform.set( EulerF( 0, 0, 0 ), Point3F( dAtof( arg0 ), dAtof( arg1 ),dAtof( arg2 ) ) );
-         source = SFX->playOnce( track, &transform, NULL, dAtof( arg3 ) );
-      }
+         transform.set(EulerF(0, 0, 0), Point3F(dAtof(arg0), dAtof(arg1), dAtof(arg2)));
+         source = SFX->playOnce(tempSoundAsset->getSfxProfile(), &transform, NULL, dAtof(arg3));
    }
-   else if( description )
-   {
-      // In this overload, arg0 is the filename, arg1..arg3 are x, y, z, and arg4 is fadeInTime.
-      SFXProfile* tempProfile = new SFXProfile( description, StringTable->insert( arg0 ), true );
-      if( !tempProfile->registerObject() )
-      {
-         Con::errorf( "sfxPlayOnce - unable to create profile" );
-         delete tempProfile;
       }
       else
       {
-         if (String::isEmpty(arg1))
-            source = SFX->playOnce( tempProfile );
-         else
-         {
-            MatrixF transform;
-            transform.set( EulerF( 0, 0, 0 ), Point3F( dAtof( arg1 ), dAtof( arg2 ),dAtof( arg3 ) ) );
-            source = SFX->playOnce( tempProfile, &transform, NULL, dAtof( arg4 ) );
-         }
-         
-         // Set profile to auto-delete when SFXSource releases its reference.
-         // Also add to root group so the profile will get deleted when the
-         // Sim system is shut down before the SFXSource has played out.
-
-         tempProfile->setAutoDelete( true );
-         Sim::getRootGroup()->addObject( tempProfile );
-      }
+      Con::errorf("sfxPlayOnce - Could not locate assetId '%s'", assetId);
+      return 0;
    }
 
    if( !source )

From ecd35df7e9e92c48b177d96725218053510e92b4 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Thu, 20 Jan 2022 01:14:43 -0600
Subject: [PATCH 297/399] Implementation of updated handling of Legacy Project
 importer to better seperate out importer versions as well as more explicit
 processing of incoming content

---
 Engine/source/T3D/assets/GUIAsset.cpp         |    2 +-
 Engine/source/T3D/assets/ShapeAsset.cpp       |    4 +-
 Engine/source/T3D/assets/assetImporter.cpp    |   26 +-
 Engine/source/persistence/taml/taml.cpp       |    5 +
 .../persistence/taml/taml_ScriptBinding.h     |    6 +-
 .../tools/assetBrowser/assetImportConfigs.xml |    2 +-
 .../projectImporter/guis/projectImporter.gui  | 1271 +++++---------
 .../pre40/T3Dpre4ProjectImporter.tscript      | 1376 +++++++++++++++
 .../pre40/pre40ImporterGuis.asset.taml        |    7 +
 .../importers/pre40/pre40ImporterGuis.gui     |  129 ++
 .../importers/pre40/pre40ImporterGuis.tscript |   92 +
 .../game/tools/projectImporter/main.tscript   |    5 -
 .../pre40/T3Dpre4ProjectImporter.tscript      | 1320 --------------
 .../scripts/projectImporter.tscript           | 1525 +++++++++++------
 14 files changed, 3107 insertions(+), 2663 deletions(-)
 create mode 100644 Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript
 create mode 100644 Templates/BaseGame/game/tools/projectImporter/importers/pre40/pre40ImporterGuis.asset.taml
 create mode 100644 Templates/BaseGame/game/tools/projectImporter/importers/pre40/pre40ImporterGuis.gui
 create mode 100644 Templates/BaseGame/game/tools/projectImporter/importers/pre40/pre40ImporterGuis.tscript
 delete mode 100644 Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript

diff --git a/Engine/source/T3D/assets/GUIAsset.cpp b/Engine/source/T3D/assets/GUIAsset.cpp
index acef864db..a8f4fe0f3 100644
--- a/Engine/source/T3D/assets/GUIAsset.cpp
+++ b/Engine/source/T3D/assets/GUIAsset.cpp
@@ -102,7 +102,7 @@ void GUIAsset::initPersistFields()
       &setScriptFile, &getScriptFile, "Path to the script file for the gui");
 
    addProtectedField("GUIFile", TypeAssetLooseFilePath, Offset(mGUIFile, GUIAsset),
-      &setScriptFile, &getScriptFile, "Path to the gui file");
+      &setGUIFile, &getGUIFile, "Path to the gui file");
 }
 
 //------------------------------------------------------------------------------
diff --git a/Engine/source/T3D/assets/ShapeAsset.cpp b/Engine/source/T3D/assets/ShapeAsset.cpp
index c145965a1..fb3be2341 100644
--- a/Engine/source/T3D/assets/ShapeAsset.cpp
+++ b/Engine/source/T3D/assets/ShapeAsset.cpp
@@ -623,8 +623,8 @@ const char* ShapeAsset::generateCachedPreviewImage(S32 resolution, String overri
 
    String dumpPath = String(mFilePath) + "_Preview.dds";
 
-   char* returnBuffer = Con::getReturnBuffer(dumpPath.length());
-   dSprintf(returnBuffer, dumpPath.length(), "%s", dumpPath.c_str());
+   char* returnBuffer = Con::getReturnBuffer(128);
+   dSprintf(returnBuffer, 128, "%s", dumpPath.c_str());
 
    /*FileStream stream;
    if (stream.open(dumpPath, Torque::FS::File::Write))
diff --git a/Engine/source/T3D/assets/assetImporter.cpp b/Engine/source/T3D/assets/assetImporter.cpp
index 7c0bda9ae..7bb109f02 100644
--- a/Engine/source/T3D/assets/assetImporter.cpp
+++ b/Engine/source/T3D/assets/assetImporter.cpp
@@ -2099,22 +2099,28 @@ void AssetImporter::processShapeMaterialInfo(AssetImportObject* assetItem, S32 m
                String imgFileName = AssetImporter::findImagePath(testFilePath.getPath() + "/" + testFilePath.getFileName());
                if (imgFileName.isNotEmpty())
                   filePath = imgFileName;
+               else
+                  filePath = ""; //no luck, so we just won't try importing in the image
             }
          }
  
          matAssetItem = addImportingAsset("MaterialAsset", shapePathBase + "/" + matName, assetItem, matName);
-         AssetImportObject* imageAssetItem = addImportingAsset("ImageAsset", filePath, matAssetItem, "");
 
-         String suffixType;
-         String suffix = parseImageSuffixes(imageAssetItem->assetName, &suffixType);
-         if (suffix.isNotEmpty())
+         if (!filePath.isEmpty())
          {
-            imageAssetItem->imageSuffixType = suffixType;
-         }
-         else
-         {
-            //we'll assume it's albedo
-            imageAssetItem->imageSuffixType = "Albedo";
+            AssetImportObject* imageAssetItem = addImportingAsset("ImageAsset", filePath, matAssetItem, "");
+
+            String suffixType;
+            String suffix = parseImageSuffixes(imageAssetItem->assetName, &suffixType);
+            if (suffix.isNotEmpty())
+            {
+               imageAssetItem->imageSuffixType = suffixType;
+            }
+            else
+            {
+               //we'll assume it's albedo
+               imageAssetItem->imageSuffixType = "Albedo";
+            }
          }
       }
       else
diff --git a/Engine/source/persistence/taml/taml.cpp b/Engine/source/persistence/taml/taml.cpp
index b05b0d8bc..2bfd104b9 100644
--- a/Engine/source/persistence/taml/taml.cpp
+++ b/Engine/source/persistence/taml/taml.cpp
@@ -217,6 +217,11 @@ ImplementEnumType(_TamlFormatMode,
 
       FileStream stream;
 
+      if (StringTable->insert("c://.asset.taml") == StringTable->insert(mFilePathBuffer))
+      {
+         bool asdfasdf = true;
+      }
+
       // File opened?
       if (!stream.open(mFilePathBuffer, Torque::FS::File::Write))
       {
diff --git a/Engine/source/persistence/taml/taml_ScriptBinding.h b/Engine/source/persistence/taml/taml_ScriptBinding.h
index 6e4a3ed09..841fadb8f 100644
--- a/Engine/source/persistence/taml/taml_ScriptBinding.h
+++ b/Engine/source/persistence/taml/taml_ScriptBinding.h
@@ -256,8 +256,10 @@ DefineEngineFunction(TamlWrite, bool, (SimObject* simObject, const char* filenam
    }
    else
    {
-         // No, so warn.
-         Con::warnf( "TamlWrite() - Setting binary compression is only valid for XML formatting." );
+#ifdef TORQUE_DEBUG
+      // No, so warn.
+      Con::warnf( "TamlWrite() - Setting binary compression is only valid for XML formatting." );
+#endif
    }
 
    // Turn-off auto-formatting.
diff --git a/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml b/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml
index 8417b1fa4..faa7ab1e6 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml
+++ b/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml
@@ -100,7 +100,7 @@
             <Setting name="LOSCollisionMeshPrefix">LOS</Setting>
         </Group>
         <Group name="General">
-            <Setting name="AddDirectoryPrefixToAssetName">1</Setting>
+            <Setting name="AddDirectoryPrefixToAssetName">0</Setting>
             <Setting name="AutomaticallyPromptMissingFiles">0</Setting>
             <Setting name="DuplicateAutoResolution">FolderPrefix</Setting>
             <Setting name="PreventImportWithErrors">1</Setting>
diff --git a/Templates/BaseGame/game/tools/projectImporter/guis/projectImporter.gui b/Templates/BaseGame/game/tools/projectImporter/guis/projectImporter.gui
index 480e71704..bed599d3e 100644
--- a/Templates/BaseGame/game/tools/projectImporter/guis/projectImporter.gui
+++ b/Templates/BaseGame/game/tools/projectImporter/guis/projectImporter.gui
@@ -45,25 +45,27 @@ $guiContent = new GuiControl(ProjectImportCtrl) {
       canSave = "1";
       canSaveDynamicFields = "0";
 
-      new GuiSplitContainer() {
-         orientation = "Vertical";
-         splitterSize = "2";
-         splitPoint = "152 100";
-         fixedPanel = "FirstPanel";
-         fixedSize = "100";
-         docking = "None";
+      new GuiScrollCtrl(ProejctImportPageContainer) {
+         willFirstRespond = "1";
+         hScrollBar = "dynamic";
+         vScrollBar = "dynamic";
+         lockHorizScroll = "0";
+         lockVertScroll = "0";
+         constantThumbHeight = "0";
+         childMargin = "0 0";
+         mouseWheelScrollSpeed = "-1";
          margin = "0 0 0 0";
          padding = "0 0 0 0";
          anchorTop = "1";
          anchorBottom = "0";
          anchorLeft = "1";
          anchorRight = "0";
-         position = "6 24";
-         extent = "531 445";
-         minExtent = "64 64";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "ToolsGuiSolidDefaultProfile";
+         position = "0 25";
+         extent = "541 437";
+         minExtent = "8 2";
+         horizSizing = "width";
+         vertSizing = "height";
+         profile = "ToolsGuiScrollProfile";
          visible = "1";
          active = "1";
          tooltipProfile = "GuiToolTipProfile";
@@ -72,844 +74,497 @@ $guiContent = new GuiControl(ProjectImportCtrl) {
          canSave = "1";
          canSaveDynamicFields = "0";
 
-         new GuiPanel() {
-            docking = "Client";
+         new GuiContainer(ProjectImportWizardPage0) {
             margin = "0 0 0 0";
             padding = "0 0 0 0";
             anchorTop = "1";
             anchorBottom = "0";
             anchorLeft = "1";
             anchorRight = "0";
-            position = "0 0";
-            extent = "150 445";
-            minExtent = "16 16";
-            horizSizing = "right";
+            position = "1 1";
+            extent = "365 429";
+            minExtent = "8 2";
+            horizSizing = "width";
             vertSizing = "bottom";
             profile = "GuiDefaultProfile";
-            visible = "1";
+            visible = "0";
             active = "1";
             tooltipProfile = "GuiToolTipProfile";
             hovertime = "1000";
             isContainer = "1";
-            internalName = "Panel1";
+            internalName = "page0";
+            hidden = "1";
             canSave = "1";
             canSaveDynamicFields = "0";
 
-            new GuiScrollCtrl() {
-               willFirstRespond = "1";
-               hScrollBar = "dynamic";
-               vScrollBar = "dynamic";
-               lockHorizScroll = "0";
-               lockVertScroll = "0";
-               constantThumbHeight = "0";
-               childMargin = "0 0";
-               mouseWheelScrollSpeed = "-1";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
-               anchorTop = "1";
-               anchorBottom = "0";
-               anchorLeft = "1";
-               anchorRight = "0";
-               position = "0 0";
-               extent = "150 445";
+            new GuiMLTextCtrl() {
+               lineSpacing = "2";
+               allowColorChars = "0";
+               maxChars = "-1";
+               text = "Welcome! This project importer will assist you in importing in legacy projects into this build of Torque3D.";
+               useURLMouseCursor = "0";
+               position = "23 21";
+               extent = "328 28";
                minExtent = "8 2";
-               horizSizing = "width";
-               vertSizing = "height";
-               profile = "ToolsGuiScrollProfile";
+               horizSizing = "right";
+               vertSizing = "bottom";
+               profile = "ToolsGuiMLTextProfile";
                visible = "1";
                active = "1";
                tooltipProfile = "GuiToolTipProfile";
                hovertime = "1000";
-               isContainer = "1";
+               isContainer = "0";
+               canSave = "1";
+               canSaveDynamicFields = "0";
+            };
+            new GuiMLTextCtrl() {
+               lineSpacing = "2";
+               allowColorChars = "0";
+               maxChars = "-1";
+               text = "To continue, click Next.";
+               useURLMouseCursor = "0";
+               position = "23 77";
+               extent = "328 14";
+               minExtent = "8 2";
+               horizSizing = "right";
+               vertSizing = "bottom";
+               profile = "ToolsGuiMLTextProfile";
+               visible = "1";
+               active = "1";
+               tooltipProfile = "GuiToolTipProfile";
+               hovertime = "1000";
+               isContainer = "0";
                canSave = "1";
                canSaveDynamicFields = "0";
-
-               new GuiTextListCtrl() {
-                  columns = "0";
-                  fitParentWidth = "1";
-                  clipColumnText = "0";
-                  rowHeightPadding = "2";
-                  position = "1 1";
-                  extent = "135 128";
-                  minExtent = "8 2";
-                  horizSizing = "width";
-                  vertSizing = "height";
-                  profile = "ToolsGuiDefaultProfile";
-                  visible = "1";
-                  active = "1";
-                  tooltipProfile = "GuiToolTipProfile";
-                  hovertime = "1000";
-                  isContainer = "1";
-                  internalName = "stepsList";
-                  canSave = "1";
-                  canSaveDynamicFields = "0";
-               };
-               new GuiControl() {
-                  position = "1 1";
-                  extent = "150 445";
-                  minExtent = "8 2";
-                  horizSizing = "right";
-                  vertSizing = "bottom";
-                  profile = "GuiDefaultProfile";
-                  visible = "1";
-                  active = "1";
-                  tooltipProfile = "GuiToolTipProfile";
-                  hovertime = "1000";
-                  isContainer = "1";
-                  canSave = "1";
-                  canSaveDynamicFields = "0";
-               };
             };
          };
-         new GuiPanel() {
-            docking = "Client";
+         new GuiContainer(ProjectImportWizardPage1) {
             margin = "0 0 0 0";
             padding = "0 0 0 0";
             anchorTop = "1";
             anchorBottom = "0";
             anchorLeft = "1";
             anchorRight = "0";
-            position = "154 0";
-            extent = "377 445";
-            minExtent = "16 16";
-            horizSizing = "right";
+            position = "1 1";
+            extent = "539 429";
+            minExtent = "8 2";
+            horizSizing = "width";
             vertSizing = "bottom";
             profile = "GuiDefaultProfile";
-            visible = "1";
+            visible = "0";
             active = "1";
             tooltipProfile = "GuiToolTipProfile";
             hovertime = "1000";
             isContainer = "1";
-            internalName = "panel2";
+            internalName = "page1";
+            hidden = "1";
             canSave = "1";
             canSaveDynamicFields = "0";
 
-            new GuiScrollCtrl() {
-               willFirstRespond = "1";
-               hScrollBar = "dynamic";
-               vScrollBar = "dynamic";
-               lockHorizScroll = "0";
-               lockVertScroll = "0";
-               constantThumbHeight = "0";
-               childMargin = "0 0";
-               mouseWheelScrollSpeed = "-1";
+            new GuiMLTextCtrl() {
+               lineSpacing = "2";
+               allowColorChars = "0";
+               maxChars = "-1";
+               text = "First, you must select what version of Torque3D the prior project\'s content is coming from.";
+               useURLMouseCursor = "0";
+               position = "23 21";
+               extent = "328 28";
+               minExtent = "8 2";
+               horizSizing = "right";
+               vertSizing = "bottom";
+               profile = "ToolsGuiMLTextProfile";
+               visible = "0";
+               active = "1";
+               tooltipProfile = "GuiToolTipProfile";
+               hovertime = "1000";
+               isContainer = "0";
+               hidden = "1";
+               canSave = "1";
+               canSaveDynamicFields = "0";
+            };
+            new GuiPopUpMenuCtrl() {
+               maxPopupHeight = "200";
+               sbUsesNAColor = "0";
+               reverseTextList = "0";
+               bitmapBounds = "16 16";
+               maxLength = "1024";
                margin = "0 0 0 0";
                padding = "0 0 0 0";
                anchorTop = "1";
                anchorBottom = "0";
                anchorLeft = "1";
                anchorRight = "0";
-               position = "0 0";
-               extent = "377 445";
+               position = "138 104";
+               extent = "268 18";
                minExtent = "8 2";
-               horizSizing = "width";
-               vertSizing = "height";
-               profile = "ToolsGuiScrollProfile";
-               visible = "1";
+               horizSizing = "center";
+               vertSizing = "bottom";
+               profile = "ToolsGuiPopUpMenuProfile";
+               visible = "0";
                active = "1";
                tooltipProfile = "GuiToolTipProfile";
                hovertime = "1000";
                isContainer = "1";
+               internalName = "previousContentVersionPopup";
+               hidden = "1";
                canSave = "1";
                canSaveDynamicFields = "0";
+            };
+            new GuiMLTextCtrl() {
+               lineSpacing = "2";
+               allowColorChars = "0";
+               maxChars = "-1";
+               text = "Now that that\'s selected, press Next to continue.";
+               useURLMouseCursor = "0";
+               position = "23 181";
+               extent = "328 14";
+               minExtent = "8 2";
+               horizSizing = "right";
+               vertSizing = "bottom";
+               profile = "ToolsGuiMLTextProfile";
+               visible = "0";
+               active = "1";
+               tooltipProfile = "GuiToolTipProfile";
+               hovertime = "1000";
+               isContainer = "0";
+               hidden = "1";
+               canSave = "1";
+               canSaveDynamicFields = "0";
+            };
+         };
+         new GuiContainer(ProjectImportWizardPage2) {
+            margin = "0 0 0 0";
+            padding = "0 0 0 0";
+            anchorTop = "1";
+            anchorBottom = "0";
+            anchorLeft = "1";
+            anchorRight = "0";
+            position = "1 1";
+            extent = "538 429";
+            minExtent = "8 2";
+            horizSizing = "width";
+            vertSizing = "bottom";
+            profile = "GuiDefaultProfile";
+            visible = "0";
+            active = "1";
+            tooltipProfile = "GuiToolTipProfile";
+            hovertime = "1000";
+            isContainer = "1";
+            internalName = "page2";
+            hidden = "1";
+            canSave = "1";
+            canSaveDynamicFields = "0";
 
-               new GuiContainer(ProjectImportWizardPage0) {
-                  margin = "0 0 0 0";
-                  padding = "0 0 0 0";
-                  anchorTop = "1";
-                  anchorBottom = "0";
-                  anchorLeft = "1";
-                  anchorRight = "0";
-                  position = "1 1";
-                  extent = "365 429";
-                  minExtent = "8 2";
-                  horizSizing = "right";
-                  vertSizing = "bottom";
-                  profile = "GuiDefaultProfile";
-                  visible = "0";
-                  active = "1";
-                  tooltipProfile = "GuiToolTipProfile";
-                  hovertime = "1000";
-                  isContainer = "1";
-                  internalName = "page0";
-                  hidden = "1";
-                  canSave = "1";
-                  canSaveDynamicFields = "0";
+            new GuiMLTextCtrl() {
+               lineSpacing = "2";
+               allowColorChars = "0";
+               maxChars = "-1";
+               text = "Next, where is the previous project\'s content?";
+               useURLMouseCursor = "0";
+               position = "23 21";
+               extent = "328 14";
+               minExtent = "8 2";
+               horizSizing = "right";
+               vertSizing = "bottom";
+               profile = "ToolsGuiMLTextProfile";
+               visible = "0";
+               active = "1";
+               tooltipProfile = "GuiToolTipProfile";
+               hovertime = "1000";
+               isContainer = "0";
+               hidden = "1";
+               canSave = "1";
+               canSaveDynamicFields = "0";
+            };
+            new GuiMLTextCtrl() {
+               lineSpacing = "2";
+               allowColorChars = "0";
+               maxChars = "-1";
+               text = "Now, point to the folder to be imported.";
+               useURLMouseCursor = "0";
+               position = "123 221";
+               extent = "328 14";
+               minExtent = "8 2";
+               horizSizing = "right";
+               vertSizing = "bottom";
+               profile = "ToolsGuiMLTextProfile";
+               visible = "0";
+               active = "1";
+               tooltipProfile = "GuiToolTipProfile";
+               hovertime = "1000";
+               isContainer = "0";
+               hidden = "1";
+               canSave = "1";
+               canSaveDynamicFields = "0";
+            };
+            new GuiButtonCtrl() {
+               text = "Find Folder";
+               groupNum = "-1";
+               buttonType = "PushButton";
+               useMouseEvents = "0";
+               position = "123 246";
+               extent = "330 30";
+               minExtent = "8 2";
+               horizSizing = "right";
+               vertSizing = "bottom";
+               profile = "ToolsGuiButtonProfile";
+               visible = "0";
+               active = "1";
+               command = "ProjectImportWindow.selectOGFolder();";
+               tooltipProfile = "GuiToolTipProfile";
+               hovertime = "1000";
+               isContainer = "0";
+               internalName = "selectOriginalContentFolderBtn";
+               hidden = "1";
+               canSave = "1";
+               canSaveDynamicFields = "0";
+            };
+            new GuiMLTextCtrl() {
+               lineSpacing = "2";
+               allowColorChars = "0";
+               maxChars = "-1";
+               useURLMouseCursor = "0";
+               position = "23 341";
+               extent = "500 14";
+               minExtent = "8 2";
+               horizSizing = "center";
+               vertSizing = "bottom";
+               profile = "ToolsGuiMLTextProfile";
+               visible = "0";
+               active = "1";
+               tooltipProfile = "GuiToolTipProfile";
+               hovertime = "1000";
+               isContainer = "0";
+               internalName = "targetImportingPath";
+               hidden = "1";
+               canSave = "1";
+               canSaveDynamicFields = "0";
+            };
+         };
+         new GuiContainer(ProjectImportWizardPage3) {
+            margin = "0 0 0 0";
+            padding = "0 0 0 0";
+            anchorTop = "1";
+            anchorBottom = "0";
+            anchorLeft = "1";
+            anchorRight = "0";
+            position = "1 1";
+            extent = "539 429";
+            minExtent = "8 2";
+            horizSizing = "right";
+            vertSizing = "bottom";
+            profile = "GuiDefaultProfile";
+            visible = "0";
+            active = "1";
+            tooltipProfile = "GuiToolTipProfile";
+            hovertime = "1000";
+            isContainer = "1";
+            internalName = "page3";
+            hidden = "1";
+            canSave = "1";
+            canSaveDynamicFields = "0";
 
-                  new GuiMLTextCtrl() {
-                     lineSpacing = "2";
-                     allowColorChars = "0";
-                     maxChars = "-1";
-                     text = "Welcome! This project importer will assist you in importing in legacy projects into this build of Torque3D.";
-                     useURLMouseCursor = "0";
-                     useTypeOverTime = "0";
-                     typeOverTimeSpeedMS = "10";
-                     typeoutSoundRate = "-1";
-                     position = "23 21";
-                     extent = "328 28";
-                     minExtent = "8 2";
-                     horizSizing = "right";
-                     vertSizing = "bottom";
-                     profile = "ToolsGuiMLTextProfile";
-                     visible = "1";
-                     active = "1";
-                     tooltipProfile = "GuiToolTipProfile";
-                     hovertime = "1000";
-                     isContainer = "0";
-                     canSave = "1";
-                     canSaveDynamicFields = "0";
-                  };
-                  new GuiMLTextCtrl() {
-                     lineSpacing = "2";
-                     allowColorChars = "0";
-                     maxChars = "-1";
-                     text = "To continue, click Next.";
-                     useURLMouseCursor = "0";
-                     useTypeOverTime = "0";
-                     typeOverTimeSpeedMS = "10";
-                     typeoutSoundRate = "-1";
-                     position = "23 77";
-                     extent = "328 14";
-                     minExtent = "8 2";
-                     horizSizing = "right";
-                     vertSizing = "bottom";
-                     profile = "ToolsGuiMLTextProfile";
-                     visible = "1";
-                     active = "1";
-                     tooltipProfile = "GuiToolTipProfile";
-                     hovertime = "1000";
-                     isContainer = "0";
-                     canSave = "1";
-                     canSaveDynamicFields = "0";
-                  };
-               };
-               new GuiContainer(ProjectImportWizardPage1) {
-                  margin = "0 0 0 0";
-                  padding = "0 0 0 0";
-                  anchorTop = "1";
-                  anchorBottom = "0";
-                  anchorLeft = "1";
-                  anchorRight = "0";
-                  position = "1 1";
-                  extent = "365 429";
-                  minExtent = "8 2";
-                  horizSizing = "right";
-                  vertSizing = "bottom";
-                  profile = "GuiDefaultProfile";
-                  visible = "0";
-                  active = "1";
-                  tooltipProfile = "GuiToolTipProfile";
-                  hovertime = "1000";
-                  isContainer = "1";
-                  internalName = "page1";
-                  hidden = "1";
-                  canSave = "1";
-                  canSaveDynamicFields = "0";
+            new GuiMLTextCtrl() {
+               lineSpacing = "2";
+               allowColorChars = "0";
+               maxChars = "-1";
+               text = "Under normal circumstances, all game content in Torque3D is grouped together in packages named Modules. These are placed into the game\'s data/ directory, which the system automatically scans on start. ";
+               useURLMouseCursor = "0";
+               position = "23 21";
+               extent = "328 56";
+               minExtent = "8 2";
+               horizSizing = "right";
+               vertSizing = "bottom";
+               profile = "ToolsGuiMLTextProfile";
+               visible = "0";
+               active = "1";
+               tooltipProfile = "GuiToolTipProfile";
+               hovertime = "1000";
+               isContainer = "0";
+               hidden = "1";
+               canSave = "1";
+               canSaveDynamicFields = "0";
+            };
+            new GuiMLTextCtrl() {
+               lineSpacing = "2";
+               allowColorChars = "0";
+               maxChars = "-1";
+               text = "To port your legacy content, first we need a module to port the content into. Please provide a module name in the text field below, and the importer will create a new module folder for you.";
+               useURLMouseCursor = "0";
+               position = "23 85";
+               extent = "325 42";
+               minExtent = "8 2";
+               horizSizing = "right";
+               vertSizing = "bottom";
+               profile = "ToolsGuiMLTextProfile";
+               visible = "0";
+               active = "1";
+               tooltipProfile = "GuiToolTipProfile";
+               hovertime = "1000";
+               isContainer = "0";
+               hidden = "1";
+               canSave = "1";
+               canSaveDynamicFields = "0";
+            };
+            new GuiMLTextCtrl() {
+               lineSpacing = "2";
+               allowColorChars = "0";
+               maxChars = "-1";
+               text = "For your convenience, we\'ve pre-populated the field with the name of the folder you\'d selected to import, but you can change it to whatever you want the module to be!";
+               useURLMouseCursor = "0";
+               position = "119 157";
+               extent = "325 42";
+               minExtent = "8 2";
+               horizSizing = "center";
+               vertSizing = "bottom";
+               profile = "ToolsGuiMLTextProfile";
+               visible = "0";
+               active = "1";
+               tooltipProfile = "GuiToolTipProfile";
+               hovertime = "1000";
+               isContainer = "0";
+               hidden = "1";
+               canSave = "1";
+               canSaveDynamicFields = "0";
+            };
+            new GuiTextEditCtrl() {
+               historySize = "0";
+               tabComplete = "0";
+               sinkAllKeyEvents = "0";
+               password = "0";
+               passwordMask = "*";
+               maxLength = "1024";
+               margin = "0 0 0 0";
+               padding = "0 0 0 0";
+               anchorTop = "1";
+               anchorBottom = "0";
+               anchorLeft = "1";
+               anchorRight = "0";
+               position = "175 215";
+               extent = "209 18";
+               minExtent = "8 2";
+               horizSizing = "right";
+               vertSizing = "bottom";
+               profile = "GuiTextEditProfile";
+               visible = "0";
+               active = "1";
+               tooltipProfile = "GuiToolTipProfile";
+               hovertime = "1000";
+               isContainer = "1";
+               internalName = "newModuleName";
+               hidden = "1";
+               canSave = "1";
+               canSaveDynamicFields = "0";
+            };
+         };
+         new GuiContainer(ProjectImportWizardPage4) {
+            margin = "0 0 0 0";
+            padding = "0 0 0 0";
+            anchorTop = "1";
+            anchorBottom = "0";
+            anchorLeft = "1";
+            anchorRight = "0";
+            position = "1 1";
+            extent = "539 429";
+            minExtent = "8 2";
+            horizSizing = "right";
+            vertSizing = "bottom";
+            profile = "GuiDefaultProfile";
+            visible = "0";
+            active = "1";
+            tooltipProfile = "GuiToolTipProfile";
+            hovertime = "1000";
+            isContainer = "1";
+            internalName = "page4";
+            hidden = "1";
+            canSave = "1";
+            canSaveDynamicFields = "0";
 
-                  new GuiMLTextCtrl() {
-                     lineSpacing = "2";
-                     allowColorChars = "0";
-                     maxChars = "-1";
-                     text = "First, you must select what version of Torque3D the prior project\'s content is coming from.";
-                     useURLMouseCursor = "0";
-                     useTypeOverTime = "0";
-                     typeOverTimeSpeedMS = "10";
-                     typeoutSoundRate = "-1";
-                     position = "23 21";
-                     extent = "328 28";
-                     minExtent = "8 2";
-                     horizSizing = "right";
-                     vertSizing = "bottom";
-                     profile = "ToolsGuiMLTextProfile";
-                     visible = "1";
-                     active = "1";
-                     tooltipProfile = "GuiToolTipProfile";
-                     hovertime = "1000";
-                     isContainer = "0";
-                     canSave = "1";
-                     canSaveDynamicFields = "0";
-                  };
-                  new GuiPopUpMenuCtrl() {
-                     maxPopupHeight = "200";
-                     sbUsesNAColor = "0";
-                     reverseTextList = "0";
-                     bitmapBounds = "16 16";
-                     maxLength = "1024";
-                     margin = "0 0 0 0";
-                     padding = "0 0 0 0";
-                     anchorTop = "1";
-                     anchorBottom = "0";
-                     anchorLeft = "1";
-                     anchorRight = "0";
-                     position = "50 104";
-                     extent = "268 18";
-                     minExtent = "8 2";
-                     horizSizing = "right";
-                     vertSizing = "bottom";
-                     profile = "ToolsGuiPopUpMenuProfile";
-                     visible = "1";
-                     active = "1";
-                     tooltipProfile = "GuiToolTipProfile";
-                     hovertime = "1000";
-                     isContainer = "1";
-                     internalName = "previousContentVersionPopup";
-                     canSave = "1";
-                     canSaveDynamicFields = "0";
-                  };
-                  new GuiMLTextCtrl() {
-                     lineSpacing = "2";
-                     allowColorChars = "0";
-                     maxChars = "-1";
-                     text = "Now that that\'s selected, press Next to continue.";
-                     useURLMouseCursor = "0";
-                     useTypeOverTime = "0";
-                     typeOverTimeSpeedMS = "10";
-                     typeoutSoundRate = "-1";
-                     position = "23 181";
-                     extent = "328 14";
-                     minExtent = "8 2";
-                     horizSizing = "right";
-                     vertSizing = "bottom";
-                     profile = "ToolsGuiMLTextProfile";
-                     visible = "1";
-                     active = "1";
-                     tooltipProfile = "GuiToolTipProfile";
-                     hovertime = "1000";
-                     isContainer = "0";
-                     canSave = "1";
-                     canSaveDynamicFields = "0";
-                  };
-               };
-               new GuiContainer(ProjectImportWizardPage2) {
-                  margin = "0 0 0 0";
-                  padding = "0 0 0 0";
-                  anchorTop = "1";
-                  anchorBottom = "0";
-                  anchorLeft = "1";
-                  anchorRight = "0";
-                  position = "1 1";
-                  extent = "365 429";
-                  minExtent = "8 2";
-                  horizSizing = "right";
-                  vertSizing = "bottom";
-                  profile = "GuiDefaultProfile";
-                  visible = "1";
-                  active = "1";
-                  tooltipProfile = "GuiToolTipProfile";
-                  hovertime = "1000";
-                  isContainer = "1";
-                  internalName = "page2";
-                  canSave = "1";
-                  canSaveDynamicFields = "0";
+            new GuiMLTextCtrl() {
+               lineSpacing = "2";
+               allowColorChars = "0";
+               maxChars = "-1";
+               text = "Before we run the actual import, we\'ll start by preprocessing the files so we know what we\'re working with. This may take a moment.";
+               useURLMouseCursor = "0";
+               position = "23 21";
+               extent = "328 42";
+               minExtent = "8 2";
+               horizSizing = "right";
+               vertSizing = "bottom";
+               profile = "ToolsGuiMLTextProfile";
+               visible = "1";
+               active = "1";
+               tooltipProfile = "GuiToolTipProfile";
+               hovertime = "1000";
+               isContainer = "0";
+               canSave = "1";
+               canSaveDynamicFields = "0";
+            };
+            new GuiMLTextCtrl() {
+               lineSpacing = "2";
+               allowColorChars = "0";
+               maxChars = "-1";
+               text = "Done!";
+               useURLMouseCursor = "0";
+               position = "107 181";
+               extent = "328 14";
+               minExtent = "8 2";
+               horizSizing = "center";
+               vertSizing = "bottom";
+               profile = "ToolsGuiMLTextProfile";
+               visible = "0";
+               active = "1";
+               tooltipProfile = "GuiToolTipProfile";
+               hovertime = "1000";
+               isContainer = "0";
+               internalName = "preprocessCompleteText";
+               hidden = "1";
+               canSave = "1";
+               canSaveDynamicFields = "0";
+            };
+         };
+         new GuiContainer(ProjectImportWizardFinalPage) {
+            margin = "0 0 0 0";
+            padding = "0 0 0 0";
+            anchorTop = "1";
+            anchorBottom = "0";
+            anchorLeft = "1";
+            anchorRight = "0";
+            position = "1 1";
+            extent = "539 429";
+            minExtent = "8 2";
+            horizSizing = "width";
+            vertSizing = "bottom";
+            profile = "GuiDefaultProfile";
+            visible = "0";
+            active = "1";
+            tooltipProfile = "GuiToolTipProfile";
+            hovertime = "1000";
+            isContainer = "1";
+            hidden = "1";
+            canSave = "1";
+            canSaveDynamicFields = "0";
 
-                  new GuiMLTextCtrl() {
-                     lineSpacing = "2";
-                     allowColorChars = "0";
-                     maxChars = "-1";
-                     text = "Next, where is the previous project\'s content?";
-                     useURLMouseCursor = "0";
-                     useTypeOverTime = "0";
-                     typeOverTimeSpeedMS = "10";
-                     typeoutSoundRate = "-1";
-                     position = "23 21";
-                     extent = "328 14";
-                     minExtent = "8 2";
-                     horizSizing = "right";
-                     vertSizing = "bottom";
-                     profile = "ToolsGuiMLTextProfile";
-                     visible = "1";
-                     active = "1";
-                     tooltipProfile = "GuiToolTipProfile";
-                     hovertime = "1000";
-                     isContainer = "0";
-                     canSave = "1";
-                     canSaveDynamicFields = "0";
-                  };
-                  new GuiRadioCtrl() {
-                     text = "Existing folder in current project\'s data/ folder";
-                     groupNum = "-1";
-                     buttonType = "RadioButton";
-                     useMouseEvents = "0";
-                     position = "22 53";
-                     extent = "320 52";
-                     minExtent = "8 2";
-                     horizSizing = "right";
-                     vertSizing = "bottom";
-                     profile = "ToolsGuiRadioProfile";
-                     visible = "1";
-                     active = "1";
-                     tooltipProfile = "GuiToolTipProfile";
-                     hovertime = "1000";
-                     isContainer = "0";
-                     internalName = "internalFolderBtn";
-                     canSave = "1";
-                     canSaveDynamicFields = "0";
-                  };
-                  new GuiRadioCtrl() {
-                     text = "Existing folder not in the current project\'s data/ folder";
-                     groupNum = "-1";
-                     buttonType = "RadioButton";
-                     useMouseEvents = "0";
-                     position = "22 109";
-                     extent = "320 52";
-                     minExtent = "8 2";
-                     horizSizing = "right";
-                     vertSizing = "bottom";
-                     profile = "ToolsGuiRadioProfile";
-                     visible = "1";
-                     active = "1";
-                     tooltipProfile = "GuiToolTipProfile";
-                     hovertime = "1000";
-                     isContainer = "0";
-                     internalName = "externalFolderBtn";
-                     canSave = "1";
-                     canSaveDynamicFields = "0";
-                  };
-                  new GuiRadioCtrl() {
-                     text = "Core and Tools";
-                     groupNum = "-1";
-                     buttonType = "RadioButton";
-                     useMouseEvents = "0";
-                     position = "22 157";
-                     extent = "320 52";
-                     minExtent = "8 2";
-                     horizSizing = "right";
-                     vertSizing = "bottom";
-                     profile = "ToolsGuiRadioProfile";
-                     visible = "1";
-                     active = "1";
-                     tooltipProfile = "GuiToolTipProfile";
-                     hovertime = "1000";
-                     isContainer = "0";
-                     internalName = "coreAndToolsBtn";
-                     canSave = "1";
-                     canSaveDynamicFields = "0";
-                  };
-                  new GuiMLTextCtrl() {
-                     lineSpacing = "2";
-                     allowColorChars = "0";
-                     maxChars = "-1";
-                     text = "Now, point to the folder to be imported.";
-                     useURLMouseCursor = "0";
-                     useTypeOverTime = "0";
-                     typeOverTimeSpeedMS = "10";
-                     typeoutSoundRate = "-1";
-                     position = "23 221";
-                     extent = "328 14";
-                     minExtent = "8 2";
-                     horizSizing = "right";
-                     vertSizing = "bottom";
-                     profile = "ToolsGuiMLTextProfile";
-                     visible = "1";
-                     active = "1";
-                     tooltipProfile = "GuiToolTipProfile";
-                     hovertime = "1000";
-                     isContainer = "0";
-                     canSave = "1";
-                     canSaveDynamicFields = "0";
-                  };
-                  new GuiButtonCtrl() {
-                     text = "Find Folder";
-                     groupNum = "-1";
-                     buttonType = "PushButton";
-                     useMouseEvents = "0";
-                     position = "19 246";
-                     extent = "330 30";
-                     minExtent = "8 2";
-                     horizSizing = "right";
-                     vertSizing = "bottom";
-                     profile = "ToolsGuiButtonProfile";
-                     visible = "1";
-                     active = "1";
-                     command = "ProjectImportWindow.selectOGFolder();";
-                     tooltipProfile = "GuiToolTipProfile";
-                     hovertime = "1000";
-                     isContainer = "0";
-                     internalName = "selectOriginalContentFolderBtn";
-                     canSave = "1";
-                     canSaveDynamicFields = "0";
-                  };
-                  new GuiMLTextCtrl() {
-                     lineSpacing = "2";
-                     allowColorChars = "0";
-                     maxChars = "-1";
-                     useURLMouseCursor = "0";
-                     useTypeOverTime = "0";
-                     typeOverTimeSpeedMS = "10";
-                     typeoutSoundRate = "-1";
-                     position = "23 341";
-                     extent = "328 14";
-                     minExtent = "8 2";
-                     horizSizing = "right";
-                     vertSizing = "bottom";
-                     profile = "ToolsGuiMLTextProfile";
-                     visible = "1";
-                     active = "1";
-                     tooltipProfile = "GuiToolTipProfile";
-                     hovertime = "1000";
-                     isContainer = "0";
-                     internalName = "targetImportingPath";
-                     canSave = "1";
-                     canSaveDynamicFields = "0";
-                  };
-               };
-               new GuiContainer(ProjectImportWizardPage3) {
-                  margin = "0 0 0 0";
-                  padding = "0 0 0 0";
-                  anchorTop = "1";
-                  anchorBottom = "0";
-                  anchorLeft = "1";
-                  anchorRight = "0";
-                  position = "1 1";
-                  extent = "365 429";
-                  minExtent = "8 2";
-                  horizSizing = "right";
-                  vertSizing = "bottom";
-                  profile = "GuiDefaultProfile";
-                  visible = "0";
-                  active = "1";
-                  tooltipProfile = "GuiToolTipProfile";
-                  hovertime = "1000";
-                  isContainer = "1";
-                  internalName = "page3";
-                  hidden = "1";
-                  canSave = "1";
-                  canSaveDynamicFields = "0";
-
-                  new GuiMLTextCtrl() {
-                     lineSpacing = "2";
-                     allowColorChars = "0";
-                     maxChars = "-1";
-                     text = "Under normal circumstances, all game content in Torque3D is grouped together in packages named Modules. These are placed into the game\'s data/ directory, which the system automatically scans on start. ";
-                     useURLMouseCursor = "0";
-                     useTypeOverTime = "0";
-                     typeOverTimeSpeedMS = "10";
-                     typeoutSoundRate = "-1";
-                     position = "23 21";
-                     extent = "328 56";
-                     minExtent = "8 2";
-                     horizSizing = "right";
-                     vertSizing = "bottom";
-                     profile = "ToolsGuiMLTextProfile";
-                     visible = "1";
-                     active = "1";
-                     tooltipProfile = "GuiToolTipProfile";
-                     hovertime = "1000";
-                     isContainer = "0";
-                     canSave = "1";
-                     canSaveDynamicFields = "0";
-                  };
-                  new GuiMLTextCtrl() {
-                     lineSpacing = "2";
-                     allowColorChars = "0";
-                     maxChars = "-1";
-                     text = "To port your legacy content, first we need a module to port the content into. Please provide a module name in the text field below, and the importer will create a new module folder for you.";
-                     useURLMouseCursor = "0";
-                     useTypeOverTime = "0";
-                     typeOverTimeSpeedMS = "10";
-                     typeoutSoundRate = "-1";
-                     position = "23 85";
-                     extent = "325 42";
-                     minExtent = "8 2";
-                     horizSizing = "right";
-                     vertSizing = "bottom";
-                     profile = "ToolsGuiMLTextProfile";
-                     visible = "1";
-                     active = "1";
-                     tooltipProfile = "GuiToolTipProfile";
-                     hovertime = "1000";
-                     isContainer = "0";
-                     canSave = "1";
-                     canSaveDynamicFields = "0";
-                  };
-                  new GuiMLTextCtrl() {
-                     lineSpacing = "2";
-                     allowColorChars = "0";
-                     maxChars = "-1";
-                     text = "For your convenience, we\'ve pre-populated the field with the name of the folder you\'d selected to import, but you can change it to whatever you want the module to be!";
-                     useURLMouseCursor = "0";
-                     useTypeOverTime = "0";
-                     typeOverTimeSpeedMS = "10";
-                     typeoutSoundRate = "-1";
-                     position = "23 157";
-                     extent = "325 42";
-                     minExtent = "8 2";
-                     horizSizing = "right";
-                     vertSizing = "bottom";
-                     profile = "ToolsGuiMLTextProfile";
-                     visible = "1";
-                     active = "1";
-                     tooltipProfile = "GuiToolTipProfile";
-                     hovertime = "1000";
-                     isContainer = "0";
-                     canSave = "1";
-                     canSaveDynamicFields = "0";
-                  };
-                  new GuiTextEditCtrl() {
-                     historySize = "0";
-                     tabComplete = "0";
-                     sinkAllKeyEvents = "0";
-                     password = "0";
-                     passwordMask = "*";
-                     maxLength = "1024";
-                     margin = "0 0 0 0";
-                     padding = "0 0 0 0";
-                     anchorTop = "1";
-                     anchorBottom = "0";
-                     anchorLeft = "1";
-                     anchorRight = "0";
-                     position = "79 215";
-                     extent = "209 18";
-                     minExtent = "8 2";
-                     horizSizing = "right";
-                     vertSizing = "bottom";
-                     profile = "GuiTextEditProfile";
-                     visible = "1";
-                     active = "1";
-                     tooltipProfile = "GuiToolTipProfile";
-                     hovertime = "1000";
-                     isContainer = "1";
-                     internalName = "newModuleName";
-                     canSave = "1";
-                     canSaveDynamicFields = "0";
-                  };
-               };
-               new GuiContainer(ProjectImportWizardPage4) {
-                  margin = "0 0 0 0";
-                  padding = "0 0 0 0";
-                  anchorTop = "1";
-                  anchorBottom = "0";
-                  anchorLeft = "1";
-                  anchorRight = "0";
-                  position = "1 1";
-                  extent = "365 429";
-                  minExtent = "8 2";
-                  horizSizing = "right";
-                  vertSizing = "bottom";
-                  profile = "GuiDefaultProfile";
-                  visible = "0";
-                  active = "1";
-                  tooltipProfile = "GuiToolTipProfile";
-                  hovertime = "1000";
-                  isContainer = "1";
-                  internalName = "page4";
-                  hidden = "1";
-                  canSave = "1";
-                  canSaveDynamicFields = "0";
-
-                  new GuiMLTextCtrl() {
-                     lineSpacing = "2";
-                     allowColorChars = "0";
-                     maxChars = "-1";
-                     useURLMouseCursor = "0";
-                     useTypeOverTime = "0";
-                     typeOverTimeSpeedMS = "10";
-                     typeoutSoundRate = "-1";
-                     position = "23 21";
-                     extent = "328 14";
-                     minExtent = "8 2";
-                     horizSizing = "right";
-                     vertSizing = "bottom";
-                     profile = "ToolsGuiMLTextProfile";
-                     visible = "1";
-                     active = "1";
-                     tooltipProfile = "GuiToolTipProfile";
-                     hovertime = "1000";
-                     isContainer = "0";
-                     internalName = "fileCopyText";
-                     canSave = "1";
-                     canSaveDynamicFields = "0";
-                  };
-               };
-               new GuiContainer(ProjectImportWizardPage5) {
-                  margin = "0 0 0 0";
-                  padding = "0 0 0 0";
-                  anchorTop = "1";
-                  anchorBottom = "0";
-                  anchorLeft = "1";
-                  anchorRight = "0";
-                  position = "1 1";
-                  extent = "365 429";
-                  minExtent = "8 2";
-                  horizSizing = "right";
-                  vertSizing = "bottom";
-                  profile = "GuiDefaultProfile";
-                  visible = "0";
-                  active = "1";
-                  tooltipProfile = "GuiToolTipProfile";
-                  hovertime = "1000";
-                  isContainer = "1";
-                  internalName = "page5";
-                  hidden = "1";
-                  canSave = "1";
-                  canSaveDynamicFields = "0";
-
-                  new GuiMLTextCtrl() {
-                     lineSpacing = "2";
-                     allowColorChars = "0";
-                     maxChars = "-1";
-                     text = "Now we actually run the import of the files and content. This will process the original files into assets, and updating any references in scripts to utilize the new AssetIDs.";
-                     useURLMouseCursor = "0";
-                     useTypeOverTime = "0";
-                     typeOverTimeSpeedMS = "10";
-                     typeoutSoundRate = "-1";
-                     position = "23 21";
-                     extent = "328 42";
-                     minExtent = "8 2";
-                     horizSizing = "right";
-                     vertSizing = "bottom";
-                     profile = "ToolsGuiMLTextProfile";
-                     visible = "1";
-                     active = "1";
-                     tooltipProfile = "GuiToolTipProfile";
-                     hovertime = "1000";
-                     isContainer = "0";
-                     canSave = "1";
-                     canSaveDynamicFields = "0";
-                  };
-                  new GuiMLTextCtrl() {
-                     lineSpacing = "2";
-                     allowColorChars = "0";
-                     maxChars = "-1";
-                     text = "Processing...";
-                     useURLMouseCursor = "0";
-                     useTypeOverTime = "0";
-                     typeOverTimeSpeedMS = "10";
-                     typeoutSoundRate = "-1";
-                     position = "64 141";
-                     extent = "245 14";
-                     minExtent = "8 2";
-                     horizSizing = "right";
-                     vertSizing = "bottom";
-                     profile = "ToolsGuiDefaultProfile";
-                     visible = "1";
-                     active = "1";
-                     tooltipProfile = "GuiToolTipProfile";
-                     hovertime = "1000";
-                     isContainer = "0";
-                     internalName = "processingText";
-                     canSave = "1";
-                     canSaveDynamicFields = "0";
-                  };
-               };
-               new GuiContainer(ProjectImportWizardPage6) {
-                  margin = "0 0 0 0";
-                  padding = "0 0 0 0";
-                  anchorTop = "1";
-                  anchorBottom = "0";
-                  anchorLeft = "1";
-                  anchorRight = "0";
-                  position = "1 1";
-                  extent = "365 429";
-                  minExtent = "8 2";
-                  horizSizing = "right";
-                  vertSizing = "bottom";
-                  profile = "GuiDefaultProfile";
-                  visible = "0";
-                  active = "1";
-                  tooltipProfile = "GuiToolTipProfile";
-                  hovertime = "1000";
-                  isContainer = "1";
-                  internalName = "page6";
-                  hidden = "1";
-                  canSave = "1";
-                  canSaveDynamicFields = "0";
-
-                  new GuiMLTextCtrl() {
-                     lineSpacing = "2";
-                     allowColorChars = "0";
-                     maxChars = "-1";
-                     text = "We\'ll now go through and process any script files to ensure they use the currently designated extension.";
-                     useURLMouseCursor = "0";
-                     useTypeOverTime = "0";
-                     typeOverTimeSpeedMS = "10";
-                     typeoutSoundRate = "-1";
-                     position = "23 21";
-                     extent = "328 28";
-                     minExtent = "8 2";
-                     horizSizing = "right";
-                     vertSizing = "bottom";
-                     profile = "ToolsGuiMLTextProfile";
-                     visible = "1";
-                     active = "1";
-                     tooltipProfile = "GuiToolTipProfile";
-                     hovertime = "1000";
-                     isContainer = "0";
-                     canSave = "1";
-                     canSaveDynamicFields = "0";
-                  };
-                  new GuiMLTextCtrl() {
-                     lineSpacing = "2";
-                     allowColorChars = "0";
-                     maxChars = "-1";
-                     text = "Processing...";
-                     useURLMouseCursor = "0";
-                     useTypeOverTime = "0";
-                     typeOverTimeSpeedMS = "10";
-                     typeoutSoundRate = "-1";
-                     position = "64 141";
-                     extent = "245 14";
-                     minExtent = "8 2";
-                     horizSizing = "right";
-                     vertSizing = "bottom";
-                     profile = "ToolsGuiDefaultProfile";
-                     visible = "1";
-                     active = "1";
-                     tooltipProfile = "GuiToolTipProfile";
-                     hovertime = "1000";
-                     isContainer = "0";
-                     internalName = "processingText";
-                     canSave = "1";
-                     canSaveDynamicFields = "0";
-                  };
-               };
-               new GuiContainer(ProjectImportWizardPage7) {
-                  margin = "0 0 0 0";
-                  padding = "0 0 0 0";
-                  anchorTop = "1";
-                  anchorBottom = "0";
-                  anchorLeft = "1";
-                  anchorRight = "0";
-                  position = "1 1";
-                  extent = "365 429";
-                  minExtent = "8 2";
-                  horizSizing = "right";
-                  vertSizing = "bottom";
-                  profile = "GuiDefaultProfile";
-                  visible = "0";
-                  active = "1";
-                  tooltipProfile = "GuiToolTipProfile";
-                  hovertime = "1000";
-                  isContainer = "1";
-                  internalName = "page7";
-                  hidden = "1";
-                  canSave = "1";
-                  canSaveDynamicFields = "0";
-
-                  new GuiMLTextCtrl() {
-                     lineSpacing = "2";
-                     allowColorChars = "0";
-                     maxChars = "-1";
-                     text = "And with that, your legacy project content has been imported in as a Torque3D 4.0 ready module!";
-                     useURLMouseCursor = "0";
-                     useTypeOverTime = "0";
-                     typeOverTimeSpeedMS = "10";
-                     typeoutSoundRate = "-1";
-                     position = "23 141";
-                     extent = "328 28";
-                     minExtent = "8 2";
-                     horizSizing = "right";
-                     vertSizing = "bottom";
-                     profile = "ToolsGuiMLTextProfile";
-                     visible = "1";
-                     active = "1";
-                     tooltipProfile = "GuiToolTipProfile";
-                     hovertime = "1000";
-                     isContainer = "0";
-                     canSave = "1";
-                     canSaveDynamicFields = "0";
-                  };
-               };
+            new GuiMLTextCtrl() {
+               lineSpacing = "2";
+               allowColorChars = "0";
+               maxChars = "-1";
+               text = "And with that, your legacy project content has been imported in as a Torque3D-ready module!";
+               useURLMouseCursor = "0";
+               position = "119 173";
+               extent = "328 28";
+               minExtent = "8 2";
+               horizSizing = "right";
+               vertSizing = "bottom";
+               profile = "ToolsGuiMLTextProfile";
+               visible = "0";
+               active = "1";
+               tooltipProfile = "GuiToolTipProfile";
+               hovertime = "1000";
+               isContainer = "0";
+               hidden = "1";
+               canSave = "1";
+               canSaveDynamicFields = "0";
             };
          };
       };
@@ -956,32 +611,6 @@ $guiContent = new GuiControl(ProjectImportCtrl) {
          canSave = "1";
          canSaveDynamicFields = "0";
       };
-      new GuiBitmapButtonCtrl() {
-         bitmapAsset = "ToolsModule:iconInformation_image";
-         bitmapMode = "Centered";
-         autoFitExtents = "0";
-         useModifiers = "0";
-         useStates = "1";
-         masked = "0";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "-187 555";
-         extent = "22 22";
-         minExtent = "8 2";
-         horizSizing = "left";
-         vertSizing = "bottom";
-         profile = "ToolsGuiButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "ImportAssetWindow.toggleLogWindow();";
-         tooltipProfile = "GuiToolTipProfile";
-         tooltip = "View Import Log";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
    };
 };
 //--- OBJECT WRITE END ---
diff --git a/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript
new file mode 100644
index 000000000..693d22a6c
--- /dev/null
+++ b/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript
@@ -0,0 +1,1376 @@
+function T3Dpre4ProjectImporter::init()
+{
+   //register this importer option to the project importer listing
+   if(isObject(T3Dpre4ProjectImporter))
+      T3Dpre4ProjectImporter.delete();
+      
+   new ScriptObject(T3Dpre4ProjectImporter);
+   
+   //Now we register the importer so it shows in the listing
+   $ProjectImporter::importerList.add("Pre-4.0 T3D Project", T3Dpre4ProjectImporter); 
+   
+   %result = AssetDatabase.acquireAsset("ToolsModule:pre40ImporterGuis");
+}
+
+T3Dpre4ProjectImporter::init(); //kick off the setup
+
+function T3Dpre4ProjectImporter::setupPages(%this)
+{
+   ProjectImportWindow.addImporterPage(Pre40ImporterPage0);
+   ProjectImportWindow.addImporterPage(Pre40ImporterPage1);
+   
+   ProjectImportWindow.refreshPage();
+}
+
+//
+//
+function T3Dpre4ProjectImporter::setupModule(%this)
+{
+   %newModuleName = $ProjectImporter::moduleName;
+      
+   projectImporterLog("Setup up Module named: " @ %newModuleName);
+   
+   %moduleFilePath = "data/" @ %newModuleName;
+   %moduleDefinitionFilePath = %moduleFilePath @ "/" @ %newModuleName @ ".module";
+   %moduleScriptFilePath = %moduleFilePath @ "/" @ %newModuleName @ "." @ $TorqueScriptFileExtension;
+   
+   if(!isImportingFile($ProjectImporter::sourceContentFolder @ "/" @ %newModuleName @ ".module"))
+   {
+      %newModule = new ModuleDefinition()
+      {
+         ModuleId = %newModuleName;
+         versionId = 1;
+         ScriptFile = %newModuleName @ "." @ $TorqueScriptFileExtension;
+         CreateFunction="onCreate";
+         DestroyFunction="onDestroy";
+         Group = "Game";
+         
+         new DeclaredAssets()
+         {
+            Extension = "asset.taml";
+            Recurse = true;
+         };
+      };
+      
+      TAMLWrite(%newModule, %moduleDefinitionFilePath); 
+   }
+   
+   //if we don't already have a incoming file that matches this, then we'll want to make a new one
+   if(!isImportingFile($ProjectImporter::sourceContentFolder @ "/" @ %newModuleName @ ".cs") && 
+      !isImportingFile($ProjectImporter::sourceContentFolder @ "/" @ %newModuleName @ "." @ $TorqueScriptFileExtension))
+   {
+      //Now generate the script file for it
+      %file = new FileObject();
+      %templateFile = new FileObject();
+      
+      %moduleTemplateCodeFilePath = AssetBrowser.templateFilesPath @ "module.tscript.template";
+      
+      if(%file.openForWrite(%moduleScriptFilePath) && %templateFile.openForRead(%moduleTemplateCodeFilePath))
+      {
+         while( !%templateFile.isEOF() )
+         {
+            %line = %templateFile.readline();
+            %line = strreplace( %line, "@@", %newModuleName );
+            
+            %file.writeline(%line);
+            //projectImporterLog(%line);
+         }
+         
+         %file.close();
+         %templateFile.close();
+      }
+      else
+      {
+         %file.close();
+         %templateFile.close();
+         
+         projectImporterLog("CreateNewModule - Something went wrong and we couldn't write the script file!");
+      }
+   }
+   
+   //force a refresh of our modules list
+   ModuleDatabase.ignoreLoadedGroups(true);
+   ModuleDatabase.scanModules( "data", false );
+   %success = ModuleDatabase.loadExplicit(%newModuleName, 1);
+   ModuleDatabase.ignoreLoadedGroups(false);
+   
+   //force a reload of the Module lists
+   AssetBrowser.refresh();
+}
+
+/*function T3Dpre4ProjectImporter::copyFiles(%this)
+{
+   %currentPage = ProjectImportWindow.getCurrentPage();
+   
+   %currentPage-->fileCopyText.setText("Beginning copy of files to new module folder now. This may take a few minutes...");
+   Canvas.repaint();
+   
+   %file = findFirstFileMultiExpr( $ProjectImporter::sourceContentFolder @ "/*.*", true);
+   
+   while( %file !$= "" )
+   {
+      %filePath = filePath(%file);
+      %fileName = fileName(%file);
+      %fileBase = fileBase(%file);
+      %fileExt = fileExt(%file);
+      
+      if(endsWith(%fileName, ".asset.taml"))
+      {
+         %fileBase = strreplace(%fileBase, ".asset", "");
+         %fileExt = ".asset.taml";
+      }
+      
+      if(%fileExt $= ".dll" || %fileExt $= ".log" || %fileExt $= ".exe" || %fileExt $= ".manifest"|| %fileExt $= ".h" ||
+         %fileExt $= ".cpp" || %fileExt $= ".so" || %fileExt $= ".do" || %fileExt $= ".lib" ||%fileExt $= ".exp")
+      {
+         %file = findNextFileMultiExpr( $ProjectImporter::sourceContentFolder @ "/*.*" );
+         continue;
+      }
+      
+      //filter out some unneeded folders
+      %slashCount = getTokenCount(%filePath, "/");
+      %topFolder = getToken(%filePath, "/", %slashCount-1);
+      if(%topFolder $= "")
+         %topFolder = getToken(%filePath, "/", %slashCount-2);
+         
+      if(%topFolder $= "creator" || %topFolder $= "tools" || %topFolder $= "web")
+      {
+         %file = findNextFileMultiExpr( $ProjectImporter::sourceContentFolder @ "/*.*" );
+         continue;
+      }
+      
+      %targetFilePath = strReplace(%file, $ProjectImporter::sourceContentFolder, $ProjectImporter::modulePath);
+      
+      %sanitizedFilename = sanitizeString(%fileBase);
+      if(startsWith(%sanitizedFilename, "_"))
+      {
+         %sanitizedFilename = substr(%sanitizedFilename, 1, -1);
+      }
+      if(%sanitizedFilename !$= %fileBase)
+      {
+         %targetFilePath = filePath(%targetFilePath) @ "/" @ %sanitizedFilename @ %fileExt;
+      }
+      
+      %targetFolder = filePath(%targetFilePath);
+      
+      if(!isDirectory(%targetFolder))
+      {
+         DirectoryHandler::createFolder(0, %targetFolder);
+      }
+      
+      if(!pathCopy(%file, %targetFilePath, false))
+      {
+         projectImporterLog("Legacy Project Importer, failed to copy file: " @ %file @ " to destination: " @ %targetFilePath);
+      }
+      
+      %file = findNextFileMultiExpr( $ProjectImporter::sourceContentFolder @ "/*.*" );
+   }
+   
+   //
+   //Now that we've done that, we'll load and scan the module for asset defs
+   %file = findFirstFileMultiExpr( $ProjectImporter::modulePath @ "/*.asset.taml", true);
+   
+   while( %file !$= "" )
+   {
+      %moduleName = AssetBrowser.dirHandler.getModuleFromAddress(%file).ModuleId;
+      %moduleDef = ModuleDatabase.findModule(%moduleName, 1);
+      
+      AssetDatabase.addDeclaredAsset(%moduleDef, %file);
+      
+      %file = findNextFileMultiExpr( $ProjectImporter::modulePath @ "/*.asset.taml" );
+   }
+   //
+   
+   %currentPage-->fileCopyText.setValue("File copy done! Press Next to continue.");
+   
+   ProjectImportWindow-->nextButton.setActive(true);
+   Canvas.repaint();
+}
+
+function T3Dpre4ProjectImporter::processImportedFiles(%this)
+{
+   if($ProjectImporter::importMode $= "CoreAndTools")
+   {
+      $ProjectImporter::modulePath = "Core";
+      %this.doImport();
+      
+      $ProjectImporter::modulePath = "Tools";
+      %this.doImport();
+   }
+   else
+   {
+      %this.doImport();
+   }
+   
+   %currentPage = ProjectImportWindow.getCurrentPage();
+   
+   %currentPage-->processingText.setText("Processing of files done! Press Next to continue.");
+   ProjectImportWindow-->nextButton.setActive(true);
+   Canvas.repaint();
+}*/
+
+function T3Dpre4ProjectImporter::doContentImport(%this)
+{
+   //Store off the current default import config
+   %this.defaultConfig = EditorSettings.value("Assets/AssetImporDefaultConfig", "");
+   EditorSettings.setValue("Assets/AssetImporDefaultConfig", "LegacyProjectImport");
+
+   //Update asset content
+   beginImageImport();
+   
+   %this.beginMaterialFilesImport();
+   
+   beginShapeImport();
+   beginTerrainImport();
+   
+   %this.beginSoundProfilesImport();
+}
+
+function T3Dpre4ProjectImporter::doScriptImport(%this)
+{
+   beginLevelImport();
+   beginGUIImport();
+   
+   %this.beginScriptFilesImport();
+   
+   %this.beginAssetAndModuleImport();
+   
+   %this.writeImportingFiles();
+   
+   EditorSettings.setValue("Assets/AssetImporDefaultConfig", %this.defaultConfig);
+}
+
+function T3Dpre4ProjectImporter::writeImportingObject(%this, %arrayObj)
+{
+   if(!isObject(%arrayObj) || %arrayObj.skip)
+      return;
+      
+   for(%i=0; %i < %arrayObj.count(); %i++)
+   {
+      %objectLine = %arrayObj.getKey(%i);
+      if(isObject(%objectLine))
+      {
+         if(%objectLine.skip == false)
+         {
+            %this.writeImportingObject(%objectLine);
+         }
+      }
+      else
+      {
+         $ProjectImporter::fileObject.writeLine(%objectLine);
+      }
+   }
+}  
+
+function T3Dpre4ProjectImporter::writeImportingFiles(%this)
+{
+   //First, we need to go through and process all loose image files. This will
+   //get us shape assets, and if the import config deigns, material assets.
+   %currentAddress = $ProjectImporter::modulePath;
+   
+   for(%i=0; %i < $ProjectImporter::FileList.count(); %i++)
+   {
+      %file = $ProjectImporter::FileList.getKey(%i);
+      %rootFileSectionObject = $ProjectImporter::FileList.getValue(%i);
+      
+      if(!%rootFileSectionObject.skip && !%rootFileSectionObject.binaryFile)
+      {
+         %path = filePath(%rootFileSectionObject.fileDestination);
+            
+         if(!IsDirectory(%path))
+         {
+            DirectoryHandler::createFolder(0, %path);  
+         }
+         
+         if ( $ProjectImporter::fileObject.openForWrite( %rootFileSectionObject.fileDestination ) ) 
+         {
+            %this.writeImportingObject(%rootFileSectionObject);
+            
+            $ProjectImporter::fileObject.close();
+         }
+      }
+      
+      if($ProjectImporter::useExistingModule)
+      {
+         //clean up legact files if they've been renamed or whatnot
+         if(%file !$= %rootFileSectionObject.fileDestination)
+         {
+            fileDelete(%file);  
+         }
+      }
+   }
+}
+
+//
+function T3Dpre4ProjectImporter::processMaterialObjects(%this, %arrayObj)
+{
+   if(!isObject(%arrayObj))
+      return;
+      
+   //We only really care about materials for this
+   if(%arrayObj.elementType $= "function" ||
+      (%arrayObj.elementType $= "Object" && %arrayObj.classType !$= "Material" && %arrayObj.classType !$= "CustomMaterial"))
+   {
+      return;  
+   }
+   
+   for(%e=0; %e < %arrayObj.count(); %e++)
+   {
+      %lineObj = %arrayObj.getKey(%e);
+      if(isObject(%lineObj))
+      {
+         if( %lineObj.elementType $= "Object")
+         {
+            if(%lineObj.classType $= "Material" || %lineObj.classType $= "CustomMaterial")
+            {
+               %materialName = %lineObj.objectName;
+               if(%materialName $= "")
+               {
+                  %mapToName = findObjectField(%lineObj, "mapTo");
+                  %lineObj.objectName = %mapToName @ "_mat";
+               }
+               
+               %sanitizedName = sanitizeString(%materialName);
+               if(startsWith(%sanitizedName, "_"))
+               {
+                  %sanitizedName = getSubStr(%sanitizedName, 1, -1);
+               }
+               
+               projectImporterLog("processMaterialObjects() - beginning processing of material: " @ %sanitizedName);
+               
+               if(%lineObj.objectName !$= %sanitizedName)
+                  renameObjectName(%lineObj, %sanitizedName);
+                  
+               //Now, we process the fields to be asset-ified on our object
+               for(%l=0; %l < %lineObj.count(); %l++)
+               {
+                  %objectCodeLine = %lineObj.getKey(%l);
+                  if(!isObject(%objectCodeLine))
+                  {
+                     %resultLine = T3Dpre4ProjectImporter.processMaterialLine(%objectCodeLine);
+                     if(%resultLine !$= %objectCodeLine)
+                     {
+                        projectImporterLog("   processed line: " @ %resultLine @ " from: " @ %objectCodeLine);
+                        %lineObj.setKey(%resultLine, %l);
+                     }
+                  }
+               }
+               
+               //This walks through the class heirarchy so in the event we get a
+               //class that has a shared common root class like with water or materials
+               //we can process with that class to cover the probability space
+               
+               %inheritanceList = getClassHierarchy(%lineObj.classType);
+               for (%classDepth = 0; %classDepth < getWordCount(%inheritanceList); %classDepth++)
+               {
+                  %subclass = getWord(%inheritanceList, %classDepth);
+                  %processFunction = "process" @ %subclass @ "Object";
+                  if(T3Dpre4ProjectImporter.isMethod(%processFunction))
+                  {
+                     T3Dpre4ProjectImporter.call(%processFunction, %lineObj, %sanitizedName);
+                  }
+               }
+            }
+            else if(%lineObj.classType $= "TerrainMaterial")
+            {
+               %intName = findObjectField(%lineObj, "internalName");
+               %materialName = %intName @ "_terrainMat";
+               
+               %sanitizedName = sanitizeString(%materialName);
+               if(startsWith(%sanitizedName, "_"))
+               {
+                  %sanitizedName = getSubStr(%sanitizedName, 1, -1);
+               }
+               
+               if(%intName !$= %sanitizedName)
+                  setObjectField(%lineObj, "internalName", %sanitizedName);
+                  
+               //Now, we process the fields to be asset-ified on our object
+               for(%l=0; %l < %lineObj.count(); %l++)
+               {
+                  %objectCodeLine = %lineObj.getKey(%l);
+                  if(!isObject(%objectCodeLine))
+                  {
+                     %resultLine = T3Dpre4ProjectImporter.processTerrainMaterialLine(%objectCodeLine);
+                     if(%resultLine !$= %objectCodeLine)
+                     {
+                        projectImporterLog("   processed line: " @ %resultLine @ " from: " @ %objectCodeLine);
+                        %lineObj.setKey(%resultLine, %l);
+                     }
+                  }
+               }
+               
+               //This walks through the class heirarchy so in the event we get a
+               //class that has a shared common root class like with water or materials
+               //we can process with that class to cover the probability space
+               
+               %inheritanceList = getClassHierarchy(%lineObj.classType);
+               for (%classDepth = 0; %classDepth < getWordCount(%inheritanceList); %classDepth++)
+               {
+                  %subclass = getWord(%inheritanceList, %classDepth);
+                  %processFunction = "process" @ %subclass @ "Object";
+                  if(T3Dpre4ProjectImporter.isMethod(%processFunction))
+                  {
+                     T3Dpre4ProjectImporter.call(%processFunction, %lineObj, %sanitizedName);
+                  }
+               }
+            }
+            else
+            {
+               continue;  
+            }
+            /**/
+            %oN = %lineObj.objectName;
+            
+            %lineObj.processed = true;
+            %lineObj.skip = true;
+         }
+         
+         //Recurse down as needed
+         %this.processMaterialObjects(%lineObj);
+      }
+   }
+}
+
+function T3Dpre4ProjectImporter::beginMaterialFilesImport(%this)
+{
+   projectImporterLog("===========================================");
+   projectImporterLog("Importing Material definitions");
+   projectImporterLog("===========================================");
+   
+   for(%i=0; %i < $ProjectImporter::FileList.count(); %i++)
+   {
+      %file = $ProjectImporter::FileList.getKey(%i);
+      %rootFileSectionObject = $ProjectImporter::FileList.getValue(%i);
+      
+      $ProjectImporter::currentFilePath = filePath(%rootFileSectionObject.fileDestination) @ "/"; //give context to the file we're processing
+      
+      if(%rootFileSectionObject.binaryFile == true || %rootFileSectionObject.imported == true)
+         continue;
+         
+      %this.processMaterialObjects(%rootFileSectionObject);
+   }
+   
+   projectImporterLog("===========================================");
+   projectImporterLog("Importing Material definitions finished");
+   projectImporterLog("===========================================");
+}
+
+//
+function T3Dpre4ProjectImporter::processSoundProfileObjects(%this, %arrayObj)
+{
+   if(!isObject(%arrayObj))
+      return;
+      
+   //We only really care about materials for this
+   if((%arrayObj.elementType $= "Object" && %arrayObj.classType !$= "SFXProfile"))
+   {
+      return;  
+   }
+   
+   for(%e=0; %e < %arrayObj.count(); %e++)
+   {
+      %lineObj = %arrayObj.getKey(%e);
+      if(isObject(%lineObj))
+      {
+         if( %lineObj.elementType $= "Object")
+         {
+            if(%lineObj.classType $= "SFXProfile")
+            {
+               %profileName = %lineObj.objectName;
+               
+               %sanitizedName = sanitizeString(%profileName);
+               if(startsWith(%sanitizedName, "_"))
+               {
+                  %sanitizedName = getSubStr(%sanitizedName, 1, -1);
+               }
+               
+               projectImporterLog("processSoundProfileObjects() - beginning processing of SFXProfile: " @ %sanitizedName);
+               
+               if(%lineObj.objectName !$= %sanitizedName)
+                  renameObjectName(%lineObj, %sanitizedName);
+               
+               //This walks through the class heirarchy so in the event we get a
+               //class that has a shared common root class like with water or materials
+               //we can process with that class to cover the probability space
+               %inheritanceList = getClassHierarchy(%lineObj.classType);
+               for (%classDepth = 0; %classDepth < getWordCount(%inheritanceList); %classDepth++)
+               {
+                  %subclass = getWord(%inheritanceList, %classDepth);
+                  %processFunction = "process" @ %subclass @ "Object";
+                  if(T3Dpre4ProjectImporter.isMethod(%processFunction))
+                  {
+                     T3Dpre4ProjectImporter.call(%processFunction, %lineObj, %sanitizedName);
+                  }
+               }
+               
+               //Now, we process the fields to be asset-ified on our object
+               for(%l=0; %l < %lineObj.count(); %l++)
+               {
+                  %objectCodeLine = %lineObj.getKey(%l);
+                  if(!isObject(%objectCodeLine))
+                  {
+                     %resultLine = T3Dpre4ProjectImporter.processSFXProfileLine(%objectCodeLine);
+                     if(%resultLine !$= %objectCodeLine)
+                     {
+                        projectImporterLog("   processed line: " @ %resultLine @ " from: " @ %objectCodeLine);
+                        %lineObj.setKey(%resultLine, %l);
+                     }
+                  }
+               }
+            }
+            else
+            {
+               continue;  
+            }
+            
+            %lineObj.processed = true;
+            %lineObj.skip = true;
+         }
+         
+         //Recurse down as needed
+         %this.processSoundProfileObjects(%lineObj);
+      }
+   }
+}
+
+function T3Dpre4ProjectImporter::beginSoundProfilesImport(%this)
+{
+   projectImporterLog("===========================================");
+   projectImporterLog("Importing Sound Profiles");
+   projectImporterLog("===========================================");
+   
+   for(%i=0; %i < $ProjectImporter::FileList.count(); %i++)
+   {
+      %file = $ProjectImporter::FileList.getKey(%i);
+      %rootFileSectionObject = $ProjectImporter::FileList.getValue(%i);
+      
+      $ProjectImporter::currentFilePath = filePath(%rootFileSectionObject.fileDestination) @ "/"; //give context to the file we're processing
+      
+      if(%rootFileSectionObject.binaryFile == true || %rootFileSectionObject.imported == true)
+         continue;
+         
+      %this.processSoundProfileObjects(%rootFileSectionObject);
+   }
+   
+   projectImporterLog("===========================================");
+   projectImporterLog("Importing Sound Profiles finished");
+   projectImporterLog("===========================================");
+}
+
+//
+function T3Dpre4ProjectImporter::processScripts(%this, %arrayObj)
+{
+   if(!isObject(%arrayObj))
+      return;
+      
+   //We only really care about materials for this
+   if((%arrayObj.elementType $= "Object" && (%arrayObj.classType $= "Material" || %arrayObj.classType $= "CustomMaterial" || %arrayObj.classType $= "TerrainMaterial")))
+   {
+      return;  
+   }
+   
+   for(%e=0; %e < %arrayObj.count(); %e++)
+   {
+      %lineObj = %arrayObj.getKey(%e);
+      if(isObject(%lineObj) && !%lineObj.skip)
+      {
+         if( %lineObj.elementType $= "Object")
+         {
+            %sanitizedName = sanitizeString(%lineObj.objectName);
+            if(startsWith(%sanitizedName, "_"))
+            {
+               %sanitizedName = getSubStr(%sanitizedName, 1, -1);
+            }
+            
+            if(%sanitizedName !$= "")
+               projectImporterLog("processScriptObjects() - beginning processing of object: " @ %lineObj.classType @ "(" @ %sanitizedName @ ")");
+            else
+               projectImporterLog("processScriptObjects() - beginning processing of object: " @ %lineObj.classType @ "()");
+            
+            if(%lineObj.objectName !$= %sanitizedName && %lineObj.objectName !$= "")
+               renameObjectName(%lineObj, %sanitizedName);
+            
+            //This walks through the class heirarchy so in the event we get a
+            //class that has a shared common root class like with water or materials
+            //we can process with that class to cover the probability space
+            
+            %inheritanceList = getClassHierarchy(%lineObj.classType);
+            for (%classDepth = 0; %classDepth < getWordCount(%inheritanceList); %classDepth++)
+            {
+               %subclass = getWord(%inheritanceList, %classDepth);
+               %processFunction = "process" @ %subclass @ "Object";
+               
+               if(T3Dpre4ProjectImporter.isMethod(%processFunction))
+               {
+                  T3Dpre4ProjectImporter.call(%processFunction, %lineObj, %sanitizedName);
+               }
+               
+               //Now, we process the fields to be asset-ified on our object
+               for(%l=0; %l < %lineObj.count(); %l++)
+               {
+                  %objectCodeLine = %lineObj.getKey(%l);
+                  if(!isObject(%objectCodeLine))
+                  {
+                     %processLineFunction = "process" @ %subclass @ "Line";
+                     if(T3Dpre4ProjectImporter.isMethod(%processLineFunction))
+                     {
+                        %resultLine = T3Dpre4ProjectImporter.call(%processLineFunction, %objectCodeLine);
+
+                        if(%resultLine !$= %objectCodeLine)
+                        {
+                           projectImporterLog("   processed line: " @ %resultLine @ " from: " @ %objectCodeLine);
+                           %lineObj.setKey(%resultLine, %l);
+                        }
+                     }
+                  }
+               }
+            }
+            
+            %lineObj.processed = true;
+         }
+         else if(%lineObj.elementType $= "function")
+         {
+            //Now, we process the fields to be asset-ified on our object
+            for(%l=0; %l < %lineObj.count(); %l++)
+            {
+               %functionCodeLine = %lineObj.getKey(%l);
+               if(!isObject(%functionCodeLine))
+               {
+                  %resultLine = %functionCodeLine;
+                  
+                  if(strIsMatchExpr("*exec(*.cs*)*", %functionCodeLine) || strIsMatchExpr("*exec(*.tscript*)*", %functionCodeLine))
+                  {
+                     %scriptExtRemovedLine = strReplace(%functionCodeLine, ".cs", "");
+                     %scriptExtRemovedLine = strReplace(%scriptExtRemovedLine, ".tscript", "");
+                     %resultLine = %scriptExtRemovedLine;
+                  }
+                  else if(strIsMatchExpr("*queueexec(*.cs*)*", %functionCodeLine) || strIsMatchExpr("*queueexec(*.tscript*)*", %functionCodeLine))
+                  {
+                     %scriptExtRemovedLine = strReplace(%functionCodeLine, ".cs", "");
+                     %scriptExtRemovedLine = strReplace(%scriptExtRemovedLine, ".tscript", "");
+                     %resultLine = %scriptExtRemovedLine;
+                  }
+                  else if(strIsMatchExpr("*registerDatablock(*.cs*)*", %functionCodeLine) || strIsMatchExpr("*registerDatablock(*.tscript*)*", %functionCodeLine))
+                  {
+                     %scriptExtRemovedLine = strReplace(%functionCodeLine, ".cs", "");
+                     %scriptExtRemovedLine = strReplace(%scriptExtRemovedLine, ".tscript", "");
+                     %resultLine = %scriptExtRemovedLine;
+                  }
+                  else if(strIsMatchExpr("*%this.addSequence(\"*);", %functionCodeLine))
+                  {
+                     %resultLine = processLegacyShapeConstructorField(%functionCodeLine);
+                  }
+                  
+                  if(%resultLine !$= %functionCodeLine)
+                  {
+                     %lineObj.setKey(%resultLine, %l);
+                  }
+               }
+            } 
+            
+            %lineObj.processed = true; 
+         }
+         
+         //Recurse down as needed
+         %this.processScripts(%lineObj);
+      }
+   }
+}
+
+function T3Dpre4ProjectImporter::beginScriptFilesImport(%this)
+{
+   //First, we need to go through and process all loose image files. This will
+   //get us shape assets, and if the import config deigns, material assets.
+   %currentAddress = $ProjectImporter::modulePath;
+   
+   for(%i=0; %i < $ProjectImporter::FileList.count(); %i++)
+   {
+      %file = $ProjectImporter::FileList.getKey(%i);
+      %rootFileSectionObject = $ProjectImporter::FileList.getValue(%i);
+      //%file = %rootFileSectionObject.fileDestination;
+      
+      //if(%rootFileSectionObject.imported == true)
+      //   continue;
+      
+      %filename = %rootFileSectionObject.fileName;
+      %fileExt = %rootFileSectionObject.fileExt;
+      %fileBase = %rootFileSectionObject.fileBase;
+      %filePath = filePath(%file);
+      
+      if(%fileExt !$= ".cs" && 
+         %fileExt !$= ".tscript" && 
+         %fileExt !$= ".mis" && 
+         %fileExt !$= ".gui" && 
+         %fileExt !$= ".prefab")
+      {
+         continue;
+      }
+      
+      $ProjectImporter::currentFilePath = filePath(%rootFileSectionObject.fileDestination) @ "/";
+      
+      projectImporterLog("T3Dpre4ProjectImporter::beginScriptFilesImport() - Processing script file: " @ %file);
+      %this.processScripts(%rootFileSectionObject);
+   }
+   
+   projectImporterLog("Legacy Project Importer - Processing of imported code files done!");
+}
+
+//
+function T3Dpre4ProjectImporter::processModuleFile(%this, %moduleObj)
+{
+   if(!isObject(%moduleObj))
+      return;
+      
+   %moduleObj.echo();
+      
+   //really, we only care here about ensuring the file extensions are cleaned up
+   for(%l=0; %l < %moduleObj.count(); %l++)
+   {
+      %line = %moduleObj.getKey(%l);
+      if(strIsMatchExpr("*.cs\"", %line))
+      {
+         %resultLine = strReplace(%line, ".cs\"", "\"");
+         %moduleObj.setKey(%resultLine, %l);
+      }
+   }
+}
+
+function T3Dpre4ProjectImporter::processAssetFile(%this, %assetObj)
+{
+   if(!isObject(%assetObj))
+      return;
+      
+   %assetObj.echo();
+      
+   //really, we only care here about ensuring the file extensions are cleaned up
+   for(%l=0; %l < %assetObj.count(); %l++)
+   {
+      %line = %assetObj.getKey(%l);
+      if(strIsMatchExpr("*.cs\"", %line))
+      {
+         %resultLine = strReplace(%line, ".cs\"", "\"");
+         %assetObj.setKey(%resultLine, %l);
+      }
+   }
+}
+
+function T3Dpre4ProjectImporter::beginAssetAndModuleImport(%this)
+{
+   //First, we need to go through and process all loose image files. This will
+   //get us shape assets, and if the import config deigns, material assets.
+   %currentAddress = $ProjectImporter::modulePath;
+   
+   for(%i=0; %i < $ProjectImporter::FileList.count(); %i++)
+   {
+      %file = $ProjectImporter::FileList.getKey(%i);
+      %rootFileSectionObject = $ProjectImporter::FileList.getValue(%i);
+      
+      %filename = %rootFileSectionObject.fileName;
+      %fileExt = %rootFileSectionObject.fileExt;
+      %fileBase = %rootFileSectionObject.fileBase;
+      %filePath = filePath(%file);
+      
+      if(%fileExt $= ".module")
+      {
+         projectImporterLog("T3Dpre4ProjectImporter::beginAssetAndModuleImport() - processing file: " @ %file);
+         $ProjectImporter::currentFilePath = filePath(%rootFileSectionObject.fileDestination) @ "/";
+         %this.processModuleFile(%rootFileSectionObject);
+         %rootFileSectionObject.processed = true;
+      }
+      else if(%fileExt $= ".asset.taml")
+      {
+         projectImporterLog("T3Dpre4ProjectImporter::beginAssetAndModuleImport() - processing file: " @ %file);
+         $ProjectImporter::currentFilePath = filePath(%rootFileSectionObject.fileDestination) @ "/";
+         %this.processAssetFile(%rootFileSectionObject);
+         %rootFileSectionObject.processed = true;
+      }
+   }
+   
+   projectImporterLog("Legacy Project Importer - Processing of imported asset and module files done!");
+}
+
+//To implement a custom class to have it's fields processed, just utilize this template function
+//and replace the class/field spaces as appropriate
+/*
+function T3Dpre4ProjectImporter::process<ClassName>Line(%this, %line)
+{
+   %outLine = processLegacyField(%line, "<originalFilenameField>", "<newAssetField>");
+  
+   if(%outLine !$= %line)
+      return %outLine;
+   else
+      return %line;
+}
+*/
+//==============================================================================
+// Misc Object Classes
+//==============================================================================
+function T3Dpre4ProjectImporter::genProcessor(%classType, %conversionMap)
+{
+    %stryng = "function T3Dpre4ProjectImporter::process" @%classType@ "Line(%this, %line){\n";
+    %count = getWordCount(%conversionMap);
+    for (%i = 0; %i<%count; %i+=2)
+    {
+        %stryng = %stryng @ " %outLine = processLegacyField(%line,\""@ getWord(%conversionMap,%i)@ "\",\""@ getWord(%conversionMap,%i+1)@"\");\n";
+        %stryng = %stryng @ "  if(%outLine !$= %line) return %outLine;\n";
+    }
+    %stryng = %stryng @ " return %line;\n}";
+    eval(%stryng);
+}
+
+T3Dpre4ProjectImporter::genProcessor("TSShapeConstructor", "baseShape baseShapeAsset shapeName shapeAsset");
+T3Dpre4ProjectImporter::genProcessor("BasicClouds", "texture textureAsset");
+T3Dpre4ProjectImporter::genProcessor("CloudLayer", "texture textureAsset");
+T3Dpre4ProjectImporter::genProcessor("DecalRoad", "material materialAsset");
+T3Dpre4ProjectImporter::genProcessor("MeshRoad", "topMaterial topMaterialAsset bottomMaterial bottomMaterialAsset sideMaterial sideMaterialAsset");
+T3Dpre4ProjectImporter::genProcessor("ScatterSky", "moonMat moonMatAsset");
+T3Dpre4ProjectImporter::genProcessor("Sun", "coronaMaterial coronaMaterialAsset");
+T3Dpre4ProjectImporter::genProcessor("VolumetricFog", "shape ShapeAsset texture textureAsset");
+T3Dpre4ProjectImporter::genProcessor("WaterObject", "rippleTex rippleTexAsset foamTex foamTexAsset depthGradientTex depthGradientTexAsset");
+T3Dpre4ProjectImporter::genProcessor("ConvexShape", "material materialAsset");
+T3Dpre4ProjectImporter::genProcessor("RenderMesh", "material materialAsset");
+T3Dpre4ProjectImporter::genProcessor("RenderShape", "shape shapeAsset");
+T3Dpre4ProjectImporter::genProcessor("GroundCover", "material materialAsset shape shapeAsset shapeFilename shapeAsset");
+T3Dpre4ProjectImporter::genProcessor("GroundPlane", "material materialAsset");
+T3Dpre4ProjectImporter::genProcessor("LevelInfo", "accuTexture accuTextureAsset");
+T3Dpre4ProjectImporter::genProcessor("TSStatic", "shape shapeAsset shapeName shapeAsset");
+T3Dpre4ProjectImporter::genProcessor("TSForestItemData", "shape shapeAsset shapeName shapeAsset shapeFile shapeAsset");
+T3Dpre4ProjectImporter::genProcessor("TerrainBlock", "terrainFile terrainAsset");
+T3Dpre4ProjectImporter::genProcessor("afxMagicMissileData", "projectileShape projectileShapeAsset projectileShapeName projectileShapeAsset sound projectileSoundAsset");
+T3Dpre4ProjectImporter::genProcessor("afxBillboardData", "texture textureAsset");
+T3Dpre4ProjectImporter::genProcessor("afxModelData", "shapeName shapeAsset shapeFile shapeAsset");
+T3Dpre4ProjectImporter::genProcessor("afxZodiacData", "texture textureAsset");
+T3Dpre4ProjectImporter::genProcessor("afxZodiacPlaneData", "texture textureAsset");
+T3Dpre4ProjectImporter::genProcessor("sfxEmitter", "track soundAsset filename soundAsset");
+T3Dpre4ProjectImporter::genProcessor("LightningData", "thunderSounds ThunderSoundAsset strikeSound StrikeSoundAsset");
+//==============================================================================
+// Levels
+//==============================================================================
+function T3Dpre4ProjectImporter::processMissionGroupLine(%this, %line, %missionName)
+{
+   %outline = strreplace(%line, "SimGroup(MissionGroup)", "Scene(" @ %missionName @ ")");
+   
+   if(%outLine !$= %line)
+      return %outLine;
+   else
+      return %line;
+}
+
+function T3Dpre4ProjectImporter::processLevelInfoLine(%this, %line)
+{
+   %outline = strreplace(%line, "ScriptObject(MissionInfo)", "LevelInfo(theLevelInfo)");
+   
+   if(%outLine !$= %line)
+      return %outLine;
+   else
+      return %line;
+}
+
+function T3Dpre4ProjectImporter::processSkyLine(%this, %line)
+{
+   %outline = strreplace(%line, "Sky", "Skybox");
+   
+   if(%outLine !$= %line)
+      return %outLine;
+   else
+      return %line;
+}
+
+function T3Dpre4ProjectImporter::processWaterLine(%this, %line)
+{
+   %outline = strreplace(%line, "Water", "WaterPlane");
+   
+   if(%outLine !$= %line)
+      return %outLine;
+   else
+      return %line;
+}
+
+//==============================================================================
+// GUIs
+//==============================================================================
+T3Dpre4ProjectImporter::genProcessor("GuiIconButtonCtrl", "bitmap bitmapAsset iconBitmap bitmapAsset");
+T3Dpre4ProjectImporter::genProcessor("GuiToolboxButtonCtrl", "normalBitmap normalBitmapAsset loweredBitmap loweredBitmapAsset hoverBitmap hoverBitmapAsset");
+T3Dpre4ProjectImporter::genProcessor("GuiBitmapCtrl", "bitmap bitmapAsset");
+T3Dpre4ProjectImporter::genProcessor("GuiMaterialCtrl", "material materialAsset");
+T3Dpre4ProjectImporter::genProcessor("GuiCursor", "bitmap bitmapAsset");
+T3Dpre4ProjectImporter::genProcessor("GuiChunkedBitmapCtrl", "bitmap bitmapAsset");
+T3Dpre4ProjectImporter::genProcessor("GuiProgressBitmap", "bitmap bitmapAsset");
+T3Dpre4ProjectImporter::genProcessor("GuiMissionArea", "handleBitmap handleBitmapAsset");
+T3Dpre4ProjectImporter::genProcessor("WorldEditor", "selectHandle selectHandleAsset defaultHandle defaultHandleAsset lockedHandle lockedHandleAsset");
+T3Dpre4ProjectImporter::genProcessor("GuiControlProfile", "bitmap bitmapAsset");
+T3Dpre4ProjectImporter::genProcessor("GuiMLTextCtrl", "deniedSound deniedSoundAsset");
+
+function T3Dpre4ProjectImporter::processGuiBitmapButtonCtrlLine(%this, %line)
+{
+   %outLine = processGuiBitmapButtonCtrlField(%line, "bitmap", "bitmapAsset");
+   if(%outLine !$= %line) return %outLine;
+   
+   return %line;
+}
+
+//==============================================================================
+// Datablocks
+//==============================================================================
+T3Dpre4ProjectImporter::genProcessor("ForestItemData", "shape shapeAsset");
+T3Dpre4ProjectImporter::genProcessor("CubeMapData", "cubemapFace cubeMapFaceAsset cubemap cubemapAsset cubeFace cubeMapFaceAsset");
+T3Dpre4ProjectImporter::genProcessor("DebrisData", "shape shapeAsset shapeFile shapeAsset");
+T3Dpre4ProjectImporter::genProcessor("DecalData", "material materialAsset");
+T3Dpre4ProjectImporter::genProcessor("ExplosionData", "explosionShape explosionShapeAsset");
+T3Dpre4ProjectImporter::genProcessor("ParticleData", "texture textureAsset textureName textureAsset textureExt textureExtAsset textureExtName textureExtAsset");
+T3Dpre4ProjectImporter::genProcessor("PrecipitationData", "drop dropAsset dropTexture dropAsset splash splashAsset splashTexture splashAsset soundProfile soundAsset");
+T3Dpre4ProjectImporter::genProcessor("SplashData", "texture textureAsset soundProfile SoundAsset");
+T3Dpre4ProjectImporter::genProcessor("LightFlareData", "flareTexture flareTextureAsset");
+T3Dpre4ProjectImporter::genProcessor("PhysicsDebrisData", "shape shapeAsset shapeFile shapeAsset");
+T3Dpre4ProjectImporter::genProcessor("PhysicsShapeData", "shape shapeAsset shapeName shapeAsset");
+T3Dpre4ProjectImporter::genProcessor("ProjectileData", "projectileShape projectileShapeAsset projectileShapeName projectileShapeAsset sound projectileSoundAsset");
+T3Dpre4ProjectImporter::genProcessor("ShapeBaseData", "shapeFile shapeAsset shape shapeAsset debrisShape debrisShapeAsset debrisShapeName debrisShapeAsset");
+T3Dpre4ProjectImporter::genProcessor("ShapeBaseImageData", "shape shapeAsset[0] shapeFP shapeAsset[1] shapeFile shapeAsset[0] shapeFileFP shapeAsset[1] stateSound stateSoundAsset");
+T3Dpre4ProjectImporter::genProcessor("ProximityMineData","armingSound ArmSoundAsset TriggerSound TriggerSoundAsset");
+T3Dpre4ProjectImporter::genProcessor("WheeledVehicleTire", "shape shapeAsset shapeFile shapeAsset");
+T3Dpre4ProjectImporter::genProcessor("WheeledVehicleData", "engineSound engineSoundAsset squealSound squealSoundAsset");
+T3Dpre4ProjectImporter::genProcessor("FlyingVehicleData", "engineSound engineSoundAsset jetSound jetSoundAsset");
+T3Dpre4ProjectImporter::genProcessor("HoverVehicleData", "engineSound engineSoundAsset jetSound jetSoundAsset floatSound floatSoundAsset");
+
+//==============================================================================
+// Datablocks - Long Lists
+//==============================================================================
+// - RigidShapeData
+$rigidEntriesList = "softImpactSound softImpactSoundAsset hardImpactSound hardImpactSoundAsset";
+$rigidEntriesList = $rigidEntriesList SPC "exitingWater exitingWaterAsset impactWaterEasy impactWaterEasyAsset";
+$rigidEntriesList = $rigidEntriesList SPC "impactWaterMedium impactWaterMediumAsset impactWaterHard impactWaterHardAsset";
+$rigidEntriesList = $rigidEntriesList SPC "waterWakeSound waterWakeSoundAsset";
+T3Dpre4ProjectImporter::genProcessor("RigidShapeData",$rigidEntriesList);
+// - PlayerData
+$PlayerEntriesList = "shapeFP shapeFPAsset shapeNameFP shapeFPAsset";
+$PlayerEntriesList = $PlayerEntriesList SPC "FootSoftSound FootSoftAsset FootHardSound FootHardAsset FootMetalSound FootMetalAsset";
+$PlayerEntriesList = $PlayerEntriesList SPC "FootSnowSound FootSnowAsset FootShallowSound FootShallowSplashAsset";
+$PlayerEntriesList = $PlayerEntriesList SPC "FootWadingSound FootWadingAsset FootUnderwaterSound FootUnderWaterAsset";
+$PlayerEntriesList = $PlayerEntriesList SPC "FootBubblesSound FootBubblesAsset movingBubblesSound MoveBubblesAsset";
+$PlayerEntriesList = $PlayerEntriesList SPC "waterBreathSound WaterBreathAsset";
+$PlayerEntriesList = $PlayerEntriesList SPC "impactSoftSound ImpactSoftAsset impactHardSound impactHardAsset";
+$PlayerEntriesList = $PlayerEntriesList SPC "impactMetalSound ImpactMetalAsset impactSnowSound impactSnowAsset";
+$PlayerEntriesList = $PlayerEntriesList SPC "impactWaterEasy impactWaterEasyAsset impactWaterMedium impactWaterMediumAsset impactWaterHard impactWaterHardAsset";
+$PlayerEntriesList = $PlayerEntriesList SPC "exitingWater ExitWaterAsset";
+T3Dpre4ProjectImporter::genProcessor("PlayerData", $PlayerEntriesList);
+// - Material
+$MaterialEntriesList = "baseTex diffuseMapAsset diffuseMap diffuseMapAsset";
+$MaterialEntriesList = $MaterialEntriesList SPC "lightMap lightMapAsset toneMap toneMapAsset";
+$MaterialEntriesList = $MaterialEntriesList SPC "detailTex detailMapAsset detailMap detailMapAsset detailNormalMap detailNormalMapAsset";
+$MaterialEntriesList = $MaterialEntriesList SPC "overlayTex overlayMapAsset overlayMap overlayMapAsset";
+$MaterialEntriesList = $MaterialEntriesList SPC "bumpTex normalMapAsset normalMap normalMapAsset";
+$MaterialEntriesList = $MaterialEntriesList SPC "ormConfigMap ormConfigMapAsset roughMap roughMapAsset";
+$MaterialEntriesList = $MaterialEntriesList SPC "aoMap aoMapAsset metalMap metalMapAsset";
+$MaterialEntriesList = $MaterialEntriesList SPC "glowMap glowMapAsset";
+$MaterialEntriesList = $MaterialEntriesList SPC "customFootstepSound customFootstepSoundAsset customImpactSound customImpactSoundAsset";
+T3Dpre4ProjectImporter::genProcessor("Material", $MaterialEntriesList);
+//==============================================================================
+// Materials
+//==============================================================================
+function T3Dpre4ProjectImporter::processMaterialObject(%this, %fileObject, %objectName)
+{
+   %matAsset = MaterialAsset::getAssetIdByMaterialName(%objectName);
+   
+   if(%matAsset $= "" || %matAsset $= "Core_Rendering:NoMaterial")
+   {
+      %assetName = %objectName;
+   
+      %moduleName = AssetBrowser.dirHandler.getModuleFromAddress($ProjectImporter::modulePath).ModuleId;
+      
+      %assetPath = $ProjectImporter::currentFilePath @ "/";   
+      
+      %tamlpath = %assetPath @ %assetName @ ".asset.taml";
+      %scriptPath = %assetPath @ %assetName @ "." @ $TorqueScriptFileExtension;//%fileObject.fileDestination;
+      
+      if(isFile(%tamlpath))
+      {
+         projectImporterLog("T3Dpre4ProjectImporter::processMaterialObject() - Failed to create as taml file already exists: " @ %fileObject.fileName);
+         return false;
+      }
+      
+      %asset = new MaterialAsset()
+      {
+         AssetName = %assetName;
+         versionId = 1;
+         shaderData = "";
+         materialDefinitionName = %assetName;
+         scriptFile = fileBase(%scriptPath);
+      };
+      
+      //Now we make our scripted definition "real", and append it to our asset
+      //so it is serialized.
+      /*%objectDefinition = "";
+      for(%l=0; %l < %fileObject.count(); %l++)
+      {
+         %objectLine = %fileObject.getKey(%l);  
+         if(!isObject(%objectLine))
+         {
+            %objectDefinition = %objectDefinition @ %objectLine;
+         }
+      }
+      
+      eval(%objectDefinition);
+      
+      if(isObject(%objectName))
+      {
+         %asset.add(%objectName);
+      }*/
+      
+      if(!isDirectory(%assetPath))
+      {
+         DirectoryHandler::createFolder(0, %assetPath);
+      }
+      
+      %success = false;
+      if(TamlWrite(%asset, %tamlpath))
+      {
+         //now write the script file
+         if ( $ProjectImporter::fileObject.openForWrite( %scriptPath ) ) 
+         {
+            for(%i=0; %i < %fileObject.count(); %i++)
+            {
+               %objectLine = %fileObject.getKey(%i);
+               if(isObject(%objectLine))
+               {
+                  %defineLine = %fileObject.getKey(0);
+                  $ProjectImporter::fileObject.writeLine(%defineLine);
+               }
+               else
+               {
+                  $ProjectImporter::fileObject.writeLine(%objectLine);
+               }
+            }
+            
+            $ProjectImporter::fileObject.close();
+         }
+         
+         %moduleDef = ModuleDatabase.findModule(%moduleName, 1);
+                  
+         %success = AssetDatabase.addDeclaredAsset(%moduleDef, %tamlpath);
+      }
+         
+      if(!%success)
+         return false;
+   }
+   
+   return false;
+}
+
+function T3Dpre4ProjectImporter::processTerrainMaterialLine(%this, %line)
+{
+   %outLine = processLegacyField(%line, "diffuseMap", "diffuseMapAsset");
+   if(%outLine !$= %line) return %outLine;
+   %outLine = processLegacyField(%line, "normalMap", "normalMapAsset");
+   if(%outLine !$= %line) return %outLine;
+   %outLine = processLegacyField(%line, "detailMap", "detailMapAsset");
+   if(%outLine !$= %line) return %outLine;
+   %outLine = processLegacyField(%line, "ORMConfigMap", "ORMConfigMapAsset");
+   if(%outLine !$= %line) return %outLine;
+   %outLine = processLegacyField(%line, "macroMap", "macroMapAsset");
+   if(%outLine !$= %line) return %outLine;
+   return %line;
+}
+
+function T3Dpre4ProjectImporter::processTerrainMaterialObject(%this, %fileObject, %objectName)
+{
+   %matAsset = TerrainMaterialAsset::getAssetIdByMaterialName(%objectName);
+   
+   if(%matAsset $= "" || %matAsset $= "Core_Rendering:noMaterial")
+   {
+      %assetName = %objectName;
+   
+      %moduleName = AssetBrowser.dirHandler.getModuleFromAddress($ProjectImporter::modulePath).ModuleId;
+      
+      %assetPath = $ProjectImporter::currentFilePath @ "/"; 
+      
+      %tamlpath = %assetPath @ %assetName @ ".asset.taml";
+      %scriptPath = %assetPath @ %assetName @ "." @ $TorqueScriptFileExtension;//%fileObject.fileDestination;
+      
+      if(isFile(%tamlpath))
+      {
+         projectImporterLog("T3Dpre4ProjectImporter::processTerrainMaterialObject() - Failed to create as taml file already exists: " @ %fileObject.fileName);
+         return false;
+      }
+      
+      %asset = new TerrainMaterialAsset()
+      {
+         AssetName = %assetName;
+         versionId = 1;
+         shaderData = "";
+         materialDefinitionName = %objectName;
+         scriptFile = fileName(%scriptPath);
+      };
+      
+      %success = false;
+      if(TamlWrite(%asset, %tamlpath))
+      {
+         %moduleDef = ModuleDatabase.findModule(%moduleName, 1);
+         
+         %success = AssetDatabase.addDeclaredAsset(%moduleDef, %tamlpath);
+      }
+      
+      if(!%success)
+         return false;
+   }
+   
+   return false;
+}
+//==============================================================================
+// PostEffects
+//==============================================================================
+T3Dpre4ProjectImporter::genProcessor("PostEffect", "texture textureAsset");
+
+//==============================================================================
+// Sounds
+// Sounds are a little weird because there's so much data tied up in a given sound
+// source. So our approach is find old SFXProfiles and process those into sound assets
+// by cross-referencing the filename for existing asset definitions.
+// Using existing SFXProfiles allows us to also injest the descriptions, giving us
+// our meta-properties on the sound asset itself.
+//==============================================================================
+T3Dpre4ProjectImporter::genProcessor("SFXAmbience", "soundTrack soundTrackAsset");
+T3Dpre4ProjectImporter::genProcessor("SFXPlayList", "track trackAsset");
+
+function T3Dpre4ProjectImporter::processSFXProfileLine(%this, %line)
+{
+   return %line;
+}
+
+function T3Dpre4ProjectImporter::processSFXProfileObject(%this, %file, %objectName)
+{
+   %soundFilename = findObjectField(%file, "filename");
+   
+   %soundFilename = sanitizeFilename(%soundFilename);
+   
+   if(fileExt(%soundFilename) $= "")
+   {
+      %soundFilename = testFilenameExtensions(%soundFilename);  
+   }
+
+   %soundAsset = SoundAsset::getAssetIdByFilename(%soundFilename);
+   
+   //Throw a warn that this file's already been claimed and move on
+   if(%soundAsset !$= "")
+   {
+      projectImporterLog("T3Dpre4ProjectImporter::processSFXProfileObject() - attempting to process SFXProfile " @ %objectName 
+               @ " but its filename is already associated to another sound asset. Continuing, but be aware.");
+   }  
+
+   %assetName = %objectName;
+
+   %moduleName = AssetBrowser.dirHandler.getModuleFromAddress(%soundFilename).ModuleId;
+   
+   %assetPath = filePath(%soundFilename) @ "/";   
+   
+   %tamlpath = %assetPath @ %assetName @ ".asset.taml";
+   
+   if(isFile(%tamlpath))
+   {
+      projectImporterLog("T3Dpre4ProjectImporter::processSFXProfileObject() - Failed to create as taml file already exists: " @ %soundFilename);
+      return false;
+   }
+   
+   %asset = new SoundAsset()
+   {
+      AssetName = %assetName;
+      versionId = 1;
+      shaderData = "";
+      soundFile = fileBase(%soundFilename) @ fileExt(%soundFilename);
+   };
+   
+   %descriptionName = findObjectField(%file, "description");
+   
+   if(%descriptionName !$= "")
+   {
+      //Optimization, see if we already have this description by happenstance
+      if(isObject(%descriptionName))
+      {
+         %asset.sourceGroup = %descriptionName.sourceGroup;
+         %asset.volume = %descriptionName.volume;
+         %asset.pitch = %descriptionName.pitch;
+         %asset.isLooping = %descriptionName.isLooping;
+         %asset.priority = %descriptionName.priority;
+         %asset.useHardware = %descriptionName.useHardware;
+         %asset.is3D = %descriptionName.is3D;
+         %asset.minDistance = %descriptionName.minDistance;
+         %asset.maxDistance = %descriptionName.maxDistance;
+         %asset.scatterDistance = %descriptionName.scatterDistance;
+         %asset.coneInsideAngle = %descriptionName.coneInsideAngle;            
+         %asset.coneOutsideAngle = %descriptionName.coneOutsideAngle;         
+         %asset.coneOutsideVolume = %descriptionName.coneOutsideVolume;
+         %asset.rolloffFactor = %descriptionName.rolloffFactor;
+         %asset.isStreaming = %descriptionName.isStreaming;
+      }
+      else
+      {
+         %objFileFinder = "";
+         //first check our cache
+         if(isObject($ProjectImporter::SFXDescriptionCache) && 
+            $ProjectImporter::SFXDescriptionCache.getIndexFromKey(%descriptionName) !$= "")
+         {
+            %key = $ProjectImporter::SFXDescriptionCache.getIndexFromKey(%descriptionName);
+            %objFileFinder = $ProjectImporter::SFXDescriptionCache.getValue(%key);
+         }
+         else
+         {
+            %objFileFinder = findObjectInFiles(%descriptionName);
+         }
+         
+         if(%objFileFinder !$= "")
+         {
+            %valueArray = new ArrayObject();
+               
+            %fileObj = getField(%objFileFinder, 0);
+               
+            %valueArray.add("sourceGroup" SPC findObjectField(%fileObj, "sourceGroup"));
+            %valueArray.add("volume" SPC findObjectField(%fileObj, "volume"));
+            %valueArray.add("pitch" SPC findObjectField(%fileObj, "pitch"));
+            %valueArray.add("isLooping" SPC findObjectField(%fileObj, "isLooping"));
+            %valueArray.add("priority" SPC findObjectField(%fileObj, "priority"));
+            %valueArray.add("useHardware" SPC findObjectField(%fileObj, "useHardware"));
+            %valueArray.add("is3D" SPC findObjectField(%fileObj, "is3D"));
+            %valueArray.add("minDistance" SPC findObjectField(%fileObj, "minDistance"));
+            %valueArray.add("maxDistance" SPC findObjectField(%fileObj, "maxDistance"));
+            %valueArray.add("scatterDistance" SPC findObjectField(%fileObj, "scatterDistance"));
+            %valueArray.add("coneInsideAngle" SPC findObjectField(%fileObj, "coneInsideAngle"));
+            %valueArray.add("coneOutsideAngle" SPC findObjectField(%fileObj, "coneOutsideAngle"));
+            %valueArray.add("coneOutsideVolume" SPC findObjectField(%fileObj, "coneOutsideVolume"));
+            %valueArray.add("rolloffFactor" SPC findObjectField(%fileObj, "rolloffFactor"));
+            %valueArray.add("isStreaming" SPC findObjectField(%fileObj, "isStreaming"));
+            
+            if(isObject($ProjectImporter::SFXDescriptionCache))
+            {
+               $ProjectImporter::SFXDescriptionCache.add(%descriptionName, %objFileFinder);
+            }
+            
+            for(%v=0; %v < %valueArray.Count(); %v++)
+            {
+               %varSet = %valueArray.getKey(%v);
+               %var = getWord(%varSet, 0);
+               %varVal = getWord(%varSet, 1);
+
+               if(%varVal !$= "")
+                  %asset.setFieldValue(%var, %varVal);
+            }
+         
+            %valueArray.delete();
+         }
+      }
+   }
+  
+   %success = false; 
+   if(TamlWrite(%asset, %tamlpath))
+   {
+      %moduleDef = ModuleDatabase.findModule(%moduleName, 1);
+      
+      %success = AssetDatabase.addDeclaredAsset(%moduleDef, %tamlpath);
+   }
+   
+   if(!%success)
+      return false;
+   
+   %file.skip = true;
+   
+   return true;
+}
+
+function T3Dpre4ProjectImporter::processAudioProfileObject(%this, %file, %objectName)
+{
+   return %this.processSFXProfileObject(%file, %objectName);
+}
+      
+function T3Dpre4ProjectImporter::processSFXDescriptionObject(%this, %file, %objectName)
+{
+   //$ProjectImporter::ToRemoveObjectList.add(%objectName, %file TAB 0);
+   
+   return true;
+}
+
+function T3Dpre4ProjectImporter::processAudioDescriptionObject(%this, %file, %objectName)
+{
+   $ProjectImporter::ToRemoveObjectList.add(%objectName, %file TAB 0);
+   
+   return true;
+}
+
+//==============================================================================
+// Misc Utility functions
+//==============================================================================
+//This is functionally identical to processLegacyField, but we have to special-snowflake our asset lookups
+//due to it using suffix-based indirections
+function processGuiBitmapButtonCtrlField(%line, %originalFieldName, %newFieldName)
+{
+   if(!strIsMatchExpr("*"@%originalFieldName@"=*\"*\";*", %line) && 
+      !strIsMatchExpr("*"@%originalFieldName@"[*=*\"*\";*", %line) &&
+      !strIsMatchExpr("*"@%originalFieldName@" *=*\"*\";*", %line))
+      return %line;
+      
+   %outLine = strreplace(%line, %originalFieldName, %newFieldName);
+   
+   //get the value
+   %value = "";
+   %pos = strpos(%outLine, "= \"");
+   if(%pos != -1)
+   {
+     %endPos = strpos(%outLine, "\";", %pos); 
+     
+     %value = getSubStr(%outLine, %pos+3, %endPos-%pos-3);
+   }
+   else
+   {
+      %pos = strpos(%outLine, "=\"");
+      if(%pos != -1)
+      {
+        %endPos = strpos(%outLine, "\";", %pos); 
+        
+        %value = getSubStr(%outLine, %pos+2, %endPos-%pos-2);
+      }
+   }
+   
+   if(%outLine !$= %line && %pos != -1 && %endPos != -1 && %value !$= "")
+   {
+      projectImporterLog("Legacy Project Importer - processing legacy field line: " @ %line);
+      
+      if(startsWith(%value, "$") || startsWith(%value, "#"))
+      {
+         //These are going to be texture/render targets, and we can leave them alone
+         return %line;
+      }
+      
+      %targetFilename = sanitizeFilename(%value);
+      
+      //If we still have nothing, then we fail it out
+      if(!isFile(%targetFilename))
+      {
+         projectImporterLog("Legacy Project Importer - file described in line could not be found/is not valid");
+         return %line;
+      }
+      
+      $ProjectImporter::assetQuery.clear();
+      %foundAssets = AssetDatabase.findAssetLooseFile($ProjectImporter::assetQuery, %targetFilename);
+      if(%foundAssets != 0)
+      {
+         %assetId = $ProjectImporter::assetQuery.getAsset(0);
+         projectImporterLog("Legacy Project Importer - processing of legacy field line's value: " @ %value @ " has found a matching AssetId: " @ %assetId);
+      }
+     
+      if(%assetId !$= "" && AssetDatabase.isDeclaredAsset(%assetId))
+      {
+         //if (%assetId.getStatusString() $= "Ok")
+         %outLine = strReplace(%outLine, %value, %assetId);
+         //else
+         //   error("Asset assignment failure:", %assetId, getStatusString());
+      }
+   }
+   
+   if(%outLine !$= %line)
+   {
+      projectImporterLog("Legacy Project Importer - processing of legacy line: " @ %line @ " has been updated to: " @ %outLine);
+      return %outLine;  
+   }
+   else
+   {
+      return %line;  
+   }
+}
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/projectImporter/importers/pre40/pre40ImporterGuis.asset.taml b/Templates/BaseGame/game/tools/projectImporter/importers/pre40/pre40ImporterGuis.asset.taml
new file mode 100644
index 000000000..32d091f0c
--- /dev/null
+++ b/Templates/BaseGame/game/tools/projectImporter/importers/pre40/pre40ImporterGuis.asset.taml
@@ -0,0 +1,7 @@
+<GUIAsset
+    canSave="true"
+    canSaveDynamicFields="true"
+    AssetName="pre40ImporterGuis"
+    GUIFile="@assetFile=pre40ImporterGuis.gui"
+    ScriptFile="@assetFile=pre40ImporterGuis.tscript"
+    VersionId="1" />
diff --git a/Templates/BaseGame/game/tools/projectImporter/importers/pre40/pre40ImporterGuis.gui b/Templates/BaseGame/game/tools/projectImporter/importers/pre40/pre40ImporterGuis.gui
new file mode 100644
index 000000000..6cbd3eb5c
--- /dev/null
+++ b/Templates/BaseGame/game/tools/projectImporter/importers/pre40/pre40ImporterGuis.gui
@@ -0,0 +1,129 @@
+//--- OBJECT WRITE BEGIN ---
+new GuiContainer(Pre40ImporterPage0) {
+   margin = "0 0 0 0";
+   padding = "0 0 0 0";
+   anchorTop = "1";
+   anchorBottom = "0";
+   anchorLeft = "1";
+   anchorRight = "0";
+   position = "1 1";
+   extent = "539 429";
+   minExtent = "8 2";
+   horizSizing = "width";
+   vertSizing = "bottom";
+   profile = "GuiDefaultProfile";
+   visible = "1";
+   active = "1";
+   tooltipProfile = "GuiToolTipProfile";
+   hovertime = "1000";
+   isContainer = "1";
+   canSave = "1";
+   canSaveDynamicFields = "1";
+
+   new GuiMLTextCtrl() {
+      lineSpacing = "2";
+      allowColorChars = "0";
+      maxChars = "-1";
+      text = "Next, we'll import in content files, such as image, models and sounds.";
+      useURLMouseCursor = "0";
+      position = "111 21";
+      extent = "328 28";
+      minExtent = "8 2";
+      horizSizing = "right";
+      vertSizing = "bottom";
+      profile = "ToolsGuiMLTextProfile";
+      visible = "1";
+      active = "1";
+      tooltipProfile = "GuiToolTipProfile";
+      hovertime = "1000";
+      isContainer = "0";
+      canSave = "1";
+      canSaveDynamicFields = "0";
+   };
+   new GuiMLTextCtrl() {
+      lineSpacing = "2";
+      allowColorChars = "0";
+      maxChars = "-1";
+      text = "Processing...";
+      useURLMouseCursor = "0";
+      position = "152 141";
+      extent = "245 14";
+      minExtent = "8 2";
+      horizSizing = "right";
+      vertSizing = "bottom";
+      profile = "ToolsGuiDefaultProfile";
+      visible = "1";
+      active = "1";
+      tooltipProfile = "GuiToolTipProfile";
+      hovertime = "1000";
+      isContainer = "0";
+      internalName = "processingText";
+      canSave = "1";
+      canSaveDynamicFields = "0";
+   };
+};
+
+new GuiContainer(Pre40ImporterPage1) {
+   margin = "0 0 0 0";
+   padding = "0 0 0 0";
+   anchorTop = "1";
+   anchorBottom = "0";
+   anchorLeft = "1";
+   anchorRight = "0";
+   position = "1 1";
+   extent = "539 429";
+   minExtent = "8 2";
+   horizSizing = "width";
+   vertSizing = "bottom";
+   profile = "GuiDefaultProfile";
+   visible = "1";
+   active = "1";
+   tooltipProfile = "GuiToolTipProfile";
+   hovertime = "1000";
+   isContainer = "1";
+   canSave = "1";
+   canSaveDynamicFields = "1";
+
+   new GuiMLTextCtrl() {
+      lineSpacing = "2";
+      allowColorChars = "0";
+      maxChars = "-1";
+      text = "Now, we'll import in script-based files such as guis, levels and scripts.";
+      useURLMouseCursor = "0";
+      position = "111 21";
+      extent = "328 28";
+      minExtent = "8 2";
+      horizSizing = "right";
+      vertSizing = "bottom";
+      profile = "ToolsGuiMLTextProfile";
+      visible = "1";
+      active = "1";
+      tooltipProfile = "GuiToolTipProfile";
+      hovertime = "1000";
+      isContainer = "0";
+      canSave = "1";
+      canSaveDynamicFields = "0";
+   };
+   new GuiMLTextCtrl() {
+      lineSpacing = "2";
+      allowColorChars = "0";
+      maxChars = "-1";
+      text = "Processing...";
+      useURLMouseCursor = "0";
+      position = "152 141";
+      extent = "245 14";
+      minExtent = "8 2";
+      horizSizing = "right";
+      vertSizing = "bottom";
+      profile = "ToolsGuiDefaultProfile";
+      visible = "1";
+      active = "1";
+      tooltipProfile = "GuiToolTipProfile";
+      hovertime = "1000";
+      isContainer = "0";
+      internalName = "processingText";
+      canSave = "1";
+      canSaveDynamicFields = "0";
+   };
+};
+//--- OBJECT WRITE END ---
diff --git a/Templates/BaseGame/game/tools/projectImporter/importers/pre40/pre40ImporterGuis.tscript b/Templates/BaseGame/game/tools/projectImporter/importers/pre40/pre40ImporterGuis.tscript
new file mode 100644
index 000000000..4ad259602
--- /dev/null
+++ b/Templates/BaseGame/game/tools/projectImporter/importers/pre40/pre40ImporterGuis.tscript
@@ -0,0 +1,92 @@
+function Pre40ImporterPage0::openPage(%this)
+{
+   ProjectImportWindow-->nextButton.setActive(false);
+   %this-->processingText.setText("Processing...");
+   Canvas.repaint();
+   
+   //copy binary files over
+   for(%i=0; %i < $ProjectImporter::FileList.count(); %i++)
+   {
+      %file = $ProjectImporter::FileList.getKey(%i);
+      %rootFileSectionObject = $ProjectImporter::FileList.getValue(%i);
+      if(%rootFileSectionObject.binaryFile == true)
+      {
+         %filePath = filePath(%file);
+         %fileName = %rootFileSectionObject.fileName;
+         %fileBase = %rootFileSectionObject.fileBase;
+         %fileExt = %rootFileSectionObject.fileExt;
+         
+         //filter out some unneeded folders
+         %slashCount = getTokenCount(%filePath, "/");
+         %topFolder = getToken(%filePath, "/", %slashCount-1);
+         if(%topFolder $= "")
+            %topFolder = getToken(%filePath, "/", %slashCount-2);
+            
+         if(%topFolder $= "creator" || %topFolder $= "tools" || %topFolder $= "web")
+         {
+            %file = findNextFileMultiExpr( $ProjectImporter::sourceContentFolder @ "/*.*" );
+            continue;
+         }
+         
+         %targetFilePath = strReplace(%file, $ProjectImporter::sourceContentFolder, $ProjectImporter::modulePath);
+         
+         %sanitizedFilename = sanitizeString(%fileBase);
+         if(startsWith(%sanitizedFilename, "_"))
+         {
+            %sanitizedFilename = substr(%sanitizedFilename, 1, -1);
+         }
+         if(%sanitizedFilename !$= %fileBase)
+         {
+            %targetFilePath = filePath(%targetFilePath) @ "/" @ %sanitizedFilename @ %fileExt;
+         }
+         
+         %targetFolder = filePath(%targetFilePath);
+         
+         if(!isDirectory(%targetFolder))
+         {
+            DirectoryHandler::createFolder(0, %targetFolder);
+         }
+         
+         if(!pathCopy(%file, %targetFilePath, false))
+         {
+            $ProjectImporter::log.add("Legacy Project Importer, failed to copy file: " @ %file @ " to destination: " @ %targetFilePath);
+            continue;
+         }
+         
+         %rootFileSectionObject.localPath = %targetFilePath;
+         
+         //If it was an asset definition file, go ahead and register it
+         if(%rootFileSectionObject.isAssetFile)
+         {
+            %moduleName = AssetBrowser.dirHandler.getModuleFromAddress(%targetFilePath).ModuleId;
+            %moduleDef = ModuleDatabase.findModule(%moduleName, 1);
+            
+            AssetDatabase.addDeclaredAsset(%moduleDef, %targetFilePath);
+         }
+      }
+   } 
+   
+   //Now, we need to do some initial importing processing
+   T3Dpre4ProjectImporter.doContentImport(); 
+   
+   //Once that's done, update the text of the UI
+   %this-->processingText.setText("Done!");
+   ProjectImportWindow-->nextButton.setActive(true);
+   Canvas.repaint();
+}
+
+function Pre40ImporterPage1::openPage(%this)
+{
+   ProjectImportWindow-->nextButton.setActive(false);
+   %this-->processingText.setText("Processing...");
+   Canvas.repaint();
+   
+   //Now, we need to do some initial importing processing
+   T3Dpre4ProjectImporter.doScriptImport();
+   
+   //Once that's done, update the text of the UI
+   %this-->processingText.setText("Done!");
+   ProjectImportWindow-->nextButton.setActive(true);
+   Canvas.repaint();
+}
+
diff --git a/Templates/BaseGame/game/tools/projectImporter/main.tscript b/Templates/BaseGame/game/tools/projectImporter/main.tscript
index da7fd3a3b..b7e871f1c 100644
--- a/Templates/BaseGame/game/tools/projectImporter/main.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/main.tscript
@@ -24,11 +24,6 @@ function initializeProjectImporter()
    echo(" % - Initializing Project Importer");  
    
    exec("./scripts/projectImporter." @ $TorqueScriptFileExtension);
-   
-   //Versioned actions
-   exec("./scripts/pre40/T3Dpre4ProjectImporter." @ $TorqueScriptFileExtension);
-   
-   
    exec("./guis/projectImporter.gui");
    
    new ScriptObject( ProjectImporterPlugin )
diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
deleted file mode 100644
index 041cabbc9..000000000
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/pre40/T3Dpre4ProjectImporter.tscript
+++ /dev/null
@@ -1,1320 +0,0 @@
-function T3Dpre4ProjectImporter::setupModule(%this)
-{
-   %newModuleName = $ProjectImporter::moduleName;
-      
-   $ProjectImporter::log.add("Creating a new Module named: " @ %newModuleName);
-   
-   %moduleFilePath = "data/" @ %newModuleName;
-   %moduleDefinitionFilePath = %moduleFilePath @ "/" @ %newModuleName @ ".module";
-   %moduleScriptFilePath = %moduleFilePath @ "/" @ %newModuleName @ "." @ $TorqueScriptFileExtension;
-   
-   %newModule = new ModuleDefinition()
-   {
-      ModuleId = %newModuleName;
-      versionId = 1;
-      ScriptFile = %newModuleName @ "." @ $TorqueScriptFileExtension;
-      CreateFunction="onCreate";
-	   DestroyFunction="onDestroy";
-	   Group = "Game";
-      
-      new DeclaredAssets()
-      {
-         Extension = "asset.taml";
-         Recurse = true;
-      };
-   };
-   
-   TAMLWrite(%newModule, %moduleDefinitionFilePath); 
-   
-   //Now generate the script file for it
-   %file = new FileObject();
-   %templateFile = new FileObject();
-   
-   %moduleTemplateCodeFilePath = AssetBrowser.templateFilesPath @ "module.tscript.template";
-   
-   if(%file.openForWrite(%moduleScriptFilePath) && %templateFile.openForRead(%moduleTemplateCodeFilePath))
-   {
-      while( !%templateFile.isEOF() )
-      {
-         %line = %templateFile.readline();
-         %line = strreplace( %line, "@@", %newModuleName );
-         
-         %file.writeline(%line);
-         //$ProjectImporter::log.add(%line);
-      }
-      
-      %file.close();
-      %templateFile.close();
-   }
-   else
-   {
-      %file.close();
-      %templateFile.close();
-      
-      $ProjectImporter::log.add("CreateNewModule - Something went wrong and we couldn't write the script file!");
-   }
-   
-   //force a refresh of our modules list
-   ModuleDatabase.ignoreLoadedGroups(true);
-   ModuleDatabase.scanModules( "data", false );
-   %success = ModuleDatabase.loadExplicit(%newModuleName, 1);
-   ModuleDatabase.ignoreLoadedGroups(false);
-   
-   //force a reload of the Module lists
-   AssetBrowser.refresh();
-}
-
-function T3Dpre4ProjectImporter::copyFiles(%this)
-{
-   %currentPage = ProjectImportWindow.getCurrentPage();
-   
-   %currentPage-->fileCopyText.setText("Beginning copy of files to new module folder now. This may take a few minutes...");
-   Canvas.repaint();
-   
-   %file = findFirstFileMultiExpr( $ProjectImporter::sourceContentFolder @ "/*.*", true);
-   
-   while( %file !$= "" )
-   {
-      %filePath = filePath(%file);
-      %fileName = fileName(%file);
-      %fileBase = fileBase(%file);
-      %fileExt = fileExt(%file);
-      
-      if(endsWith(%fileName, ".asset.taml"))
-      {
-         %fileBase = strreplace(%fileBase, ".asset", "");
-         %fileExt = ".asset.taml";
-      }
-      
-      if(%fileExt $= ".dll" || %fileExt $= ".log" || %fileExt $= ".exe" || %fileExt $= ".manifest"|| %fileExt $= ".h" ||
-         %fileExt $= ".cpp" || %fileExt $= ".so" || %fileExt $= ".do" || %fileExt $= ".lib" ||%fileExt $= ".exp")
-      {
-         %file = findNextFileMultiExpr( $ProjectImporter::sourceContentFolder @ "/*.*" );
-         continue;
-      }
-      
-      //filter out some unneeded folders
-      %slashCount = getTokenCount(%filePath, "/");
-      %topFolder = getToken(%filePath, "/", %slashCount-1);
-      if(%topFolder $= "")
-         %topFolder = getToken(%filePath, "/", %slashCount-2);
-         
-      if(%topFolder $= "creator" || %topFolder $= "tools" || %topFolder $= "web")
-      {
-         %file = findNextFileMultiExpr( $ProjectImporter::sourceContentFolder @ "/*.*" );
-         continue;
-      }
-      
-      %targetFilePath = strReplace(%file, $ProjectImporter::sourceContentFolder, $ProjectImporter::modulePath);
-      
-      %sanitizedFilename = sanitizeString(%fileBase);
-      if(startsWith(%sanitizedFilename, "_"))
-      {
-         %sanitizedFilename = substr(%sanitizedFilename, 1, -1);
-      }
-      if(%sanitizedFilename !$= %fileBase)
-      {
-         %targetFilePath = filePath(%targetFilePath) @ "/" @ %sanitizedFilename @ %fileExt;
-      }
-      
-      %targetFolder = filePath(%targetFilePath);
-      
-      if(!isDirectory(%targetFolder))
-      {
-         DirectoryHandler::createFolder(0, %targetFolder);
-      }
-      
-      if(!pathCopy(%file, %targetFilePath, false))
-      {
-         $ProjectImporter::log.add("Legacy Project Importer, failed to copy file: " @ %file @ " to destination: " @ %targetFilePath);
-      }
-      
-      %file = findNextFileMultiExpr( $ProjectImporter::sourceContentFolder @ "/*.*" );
-   }
-   
-   //
-   //Now that we've done that, we'll load and scan the module for asset defs
-   %file = findFirstFileMultiExpr( $ProjectImporter::modulePath @ "/*.asset.taml", true);
-   
-   while( %file !$= "" )
-   {
-      %moduleName = AssetBrowser.dirHandler.getModuleFromAddress(%file).ModuleId;
-      %moduleDef = ModuleDatabase.findModule(%moduleName, 1);
-      
-      AssetDatabase.addDeclaredAsset(%moduleDef, %file);
-      
-      %file = findNextFileMultiExpr( $ProjectImporter::modulePath @ "/*.asset.taml" );
-   }
-   //
-   
-   %currentPage-->fileCopyText.setValue("File copy done! Press Next to continue.");
-   
-   ProjectImportWindow-->nextButton.setActive(true);
-   Canvas.repaint();
-}
-
-function T3Dpre4ProjectImporter::processImportedFiles(%this)
-{
-   if($ProjectImporter::importMode $= "CoreAndTools")
-   {
-      $ProjectImporter::modulePath = "Core";
-      %this.doImport();
-      
-      $ProjectImporter::modulePath = "Tools";
-      %this.doImport();
-   }
-   else
-   {
-      %this.doImport();
-   }
-   
-   %currentPage = ProjectImportWindow.getCurrentPage();
-   
-   %currentPage-->processingText.setText("Processing of files done! Press Next to continue.");
-   ProjectImportWindow-->nextButton.setActive(true);
-   Canvas.repaint();
-}
-
-function T3Dpre4ProjectImporter::doImport(%this)
-{
-   //Store off the current default import config
-   %defaultConfig = EditorSettings.value("Assets/AssetImporDefaultConfig", "");
-   EditorSettings.setValue("Assets/AssetImporDefaultConfig", "LegacyProjectImport");
-
-   //Update asset content
-   beginImageImport();
-   
-   %this.beginMaterialFilesImport();
-   
-   beginShapeImport();
-   beginTerrainImport();
-   beginLevelImport();
-   beginGUIImport();
-   
-   %this.beginCodeFilesImport();
-   
-   EditorSettings.setValue("Assets/AssetImporDefaultConfig", %defaultConfig);
-}
-
-function T3Dpre4ProjectImporter::beginMaterialFilesImport(%this)
-{
-   %currentPage = ProjectImportWindow.getCurrentPage();
-   
-   //First, wipe out any files inside the folder first
-   %file = findFirstFileMultiExpr( $ProjectImporter::modulePath @ "/*/materials.*", true);
-   
-   %objectClassStack = new ArrayObject();
-   %fileOutputLines = new ArrayObject();
-   
-   $ProjectImporter::log.add("Legacy Project Importer - Beginning processing of imported code files");
-   
-   //Walk through and process all code files to update references
-   while( %file !$= "" )
-   {      
-      %fileWasChanged = false;
-      
-      %filename = fileName(%file);
-      %fileBase = fileBase(%file);
-      %fileExt = fileExt(%file);
-      %filePath = filePath(%file);
-      
-      $ProjectImporter::currentFilePath = %filePath @ "/";
-      
-      %currentPage-->processingText.setText("Processing material script file: " @ %file);
-      Canvas.repaint();
-      
-      if ( $ProjectImporter::fileObject.openForRead( %file ) ) 
-      {
-         $ProjectImporter::log.add("Legacy Project Importer - Beginning process of file: " @ %file);
-         %lineNum = 0;
-         while ( !$ProjectImporter::fileObject.isEOF() ) 
-         {
-            %line = $ProjectImporter::fileObject.readLine();
-            %trimmedLine = trim(%line);
-            
-            if(strIsMatchExpr("*new*(*)*", %line) && strpos(%line, "::") == -1)
-            {
-               %className = findObjectClass(%line, "new");
-               if (%className $= "") continue;
-
-               if(%className !$= "Material" && %className !$= "CustomMaterial" && %className !$= "TerrainMaterial" && %className !$= "CubemapData")
-                  {
-                     %lineNum++;
-                     %fileOutputLines.push_back(%line);
-                     continue;
-                  }
-                  
-                  %objectClassStack.push_back(%className);
-               
-               %objectName = findObjectName(%line, "new");
-               
-               if(%objectName $= "" && %className $= "TerrainMaterial")
-                  {
-                  %intName = findObjectField("internalName");
-                  %objectName = %intName @ "_terrainMat";
-                  %line = strReplace(%line, "()", "(" @ %intName @ ")");
-                  
-                  %fileWasChanged = true;
-                  }
-               else if(%objectName $= "" && %className $= "Material")
-               {
-                  %mapToName = findObjectField("mapTo");
-                  %objectName = %mapToName @ "_mat";
-                  %line = strReplace(%line, "()", "(" @ %mapToName @ ")");
-                  
-                  %fileWasChanged = true;
-               }
-                  
-               %sanitizedName = sanitizeString(%objectName);
-               if(startsWith(%sanitizedName, "_"))
-               {
-                  %sanitizedName = substr(%sanitizedName, 1, -1);
-               }
-               if(%sanitizedName !$= %objectName)
-               {
-                  %line = strReplace(%line, %objectName, %sanitizedName);
-                  
-                  %fileWasChanged = true;
-               }
-                  
-                  if(%objectClassStack.count() == 1)
-                  {
-                  %currentObjClass = %objectClassStack.getKey(%objectClassStack.count()-1);
-                  
-                     //we only process top-level objects directly                 
-                     %inheritanceList = getClassHierarchy(%currentObjClass);
-                     for (%classDepth =0; %classDepth<getWordCount(%inheritanceList); %classDepth++)
-                     {
-                        %subclass = getWord(%inheritanceList, %classDepth);
-                        %processFunction = "process" @ %subclass @ "Object";
-                        if(%this.isMethod(%processFunction))
-                        {
-                           %this.call(%processFunction, %file, %objectName);
-                        }
-                     }
-                  }
-               }
-            else if(strIsMatchExpr("*singleton*(*)*", %line))
-            {
-               %className = findObjectClass(%line, "singleton");
-               
-               if(%className !$= "Material" && %className !$= "CustomMaterial" && %className !$= "TerrainMaterial" && %className !$= "CubemapData")
-                  {
-                     %lineNum++;
-                     %fileOutputLines.push_back(%line);
-                     continue;
-                  }
-                  
-                  %objectClassStack.push_back(%className);
-               
-               %objectName = findObjectName(%line, "singleton");
-                  
-               %sanitizedName = sanitizeString(%objectName);
-               if(startsWith(%sanitizedName, "_"))
-               {
-                  %sanitizedName = substr(%sanitizedName, 1, -1);
-               }
-               if(%sanitizedName !$= %objectName)
-               {
-                  %line = strReplace(%line, %objectName, %sanitizedName);
-                  
-                  %fileWasChanged = true;
-               }
-               
-                  if(%objectClassStack.count() == 1)
-                  {
-                  %currentObjClass = %objectClassStack.getKey(%objectClassStack.count()-1);
-                  
-                     //we only process top-level objects directly                 
-                     %inheritanceList = getClassHierarchy(%currentObjClass);
-                     for (%classDepth =0; %classDepth<getWordCount(%inheritanceList); %classDepth++)
-                     {
-                        %subclass = getWord(%inheritanceList, %classDepth);
-                        %processFunction = "process" @ %subclass @ "Object";
-                        if(%this.isMethod(%processFunction))
-                        {
-                           %this.call(%processFunction, %file, %objectName);
-                        }
-                     }
-                  }
-               }
-            else if(strIsMatchExpr("*};*", %line))
-            {
-               //hit the end of an object, pop our object stack
-               %objectClassStack.pop_back();
-            }
-            else
-            {
-               if(%objectClassStack.count() != 0)
-               {
-                  %currentObjClass = %objectClassStack.getKey(%objectClassStack.count()-1);
-                  
-                  %inheritanceList = getClassHierarchy(%currentObjClass);
-                  for (%classDepth =0; %classDepth<getWordCount(%inheritanceList); %classDepth++)
-                  {
-                     %subclass = getWord(%inheritanceList, %classDepth);
-                     %processFunction = "process" @ %subclass @ "Line";
-                     if(%this.isMethod(%processFunction))
-                     {
-                        %outLine = %this.call(%processFunction, %line);
-
-                        if(%line !$= %outLine)
-                        {
-                           %fileWasChanged = true;
-                           %line = %outLine;
-                        }
-                     }
-                  }
-               }
-            }
-            %lineNum++;
-            
-            %fileOutputLines.push_back(%line);
-         }
-         
-         $ProjectImporter::fileObject.close();
-      }
-      else
-      {
-         $ProjectImporter::log.add("Legacy Project Importer - File not able to be opened: " @ %file);  
-      }
-      
-      if(%fileWasChanged)
-      {
-         $ProjectImporter::fileObject.openForWrite(%file);
-
-         for(%l = 0; %l < %fileOutputLines.count(); %l++)
-         {
-            %outLine = %fileOutputLines.getKey(%l);
-            
-            $ProjectImporter::fileObject.writeline(%outLine);
-         }
-         
-         $ProjectImporter::fileObject.close();
-      }
-      
-      %fileOutputLines.empty();
-      %objectClassStack.empty();
-      
-      %file = findNextFileMultiExpr( $ProjectImporter::modulePath @ "/*/materials.*" );
-   }
-   
-   $ProjectImporter::log.add("Legacy Project Importer - Processing of imported code files done!");
-   
-   %fileOutputLines.delete();
-   %objectClassStack.delete();
-   
-   //now exec the materials
-   loadModuleMaterials("Game");
-}
-
-function T3Dpre4ProjectImporter::beginCodeFilesImport(%this)
-{
-   %currentPage = ProjectImportWindow.getCurrentPage();
-   
-   //First, wipe out any files inside the folder first
-   %file = findFirstFileMultiExpr( $ProjectImporter::modulePath @ "/*.*", true);
-   
-   %objectClassStack = new ArrayObject();
-   %fileOutputLines = new ArrayObject();
-   
-   $ProjectImporter::log.add("Legacy Project Importer - Beginning processing of imported code files");
-   
-   //Walk through and process all code files to update references
-   while( %file !$= "" )
-   {      
-      if(!endsWith(%file, "cs") && 
-         !endsWith(%file, "tscript") && 
-         !endsWith(%file, "mis") && 
-         !endsWith(%file, "gui") && 
-         !endsWith(%file, "prefab"))
-      {
-         %file = findNextFileMultiExpr( $ProjectImporter::modulePath @ "/*.*" );
-         continue;
-      }
-      
-      %fileWasChanged = false;
-      
-      %filename = fileName(%file);
-      %fileBase = fileBase(%file);
-      %fileExt = fileExt(%file);
-      %filePath = filePath(%file);
-      
-      if(%filename $= "materials.cs" || %filename $= "materials.tscript" )
-      {
-         //we already handled materials script files, so skip
-         %file = findNextFileMultiExpr( $ProjectImporter::modulePath @ "/*.*" );
-         continue;
-      }
-      
-      $ProjectImporter::currentFilePath = %filePath @ "/";
-      
-      %currentPage-->processingText.setText("Processing file: " @ %file);
-      Canvas.repaint();
-      
-      if ( $ProjectImporter::fileObject.openForRead( %file ) ) 
-      {
-         $ProjectImporter::log.add("Legacy Project Importer - Beginning process of file: " @ %file);
-         %lineNum = 0;
-         while ( !$ProjectImporter::fileObject.isEOF() ) 
-         {
-            %line = $ProjectImporter::fileObject.readLine();
-            %trimmedLine = trim(%line);
-            
-            if(strIsMatchExpr("*new*(*)*", %line) && strpos(%line, "::") == -1)
-            {
-               %className = findObjectClass(%line, "new");
-               if (%className $= "") continue;
-               
-               %objectClassStack.push_back(%className);
-               
-               %objectName = findObjectName(%line, "new");
-               
-               if(strIsMatchExpr("*%guiContent*=*new*", %line))
-               {
-                  %line = strReplace(%line, "%guiContent", "$guiContent");
-                  %fileWasChanged = true;
-               }
-               
-               if(%objectName !$= "")
-               {
-                  %sanitizedName = sanitizeString(%objectName);
-                  if(startsWith(%sanitizedName, "_"))
-                  {
-                     %sanitizedName = substr(%sanitizedName, 1, -1);
-                  }
-                  if(%sanitizedName !$= %objectName)
-                  {
-                     %line = strReplace(%line, %objectName, %sanitizedName);
-                     
-                     %fileWasChanged = true;
-                  }
-                  
-                  if(%objectClassStack.count() == 1)
-                  {
-                     %currentObjClass = %objectClassStack.getKey(%objectClassStack.count()-1);
-                     
-                     //we only process top-level objects directly                     
-                     %inheritanceList = getClassHierarchy(%currentObjClass);
-                     for (%classDepth =0; %classDepth<getWordCount(%inheritanceList); %classDepth++)
-                     {
-                        %subclass = getWord(%inheritanceList, %classDepth);
-                        %processFunction = "process" @ %subclass @ "Object";
-                        if(%this.isMethod(%processFunction))
-                        {
-                           %this.call(%processFunction, %file, %objectName);
-                        }
-                     }
-                  }
-               }
-               
-               //special handling here
-               if(%fileExt $= ".mis")
-               {
-                  if(%className $= "SimGroup" && %objectName $= "MissionGroup") 
-                  {
-                     if(%this.isMethod("processMissionGroupLine"))
-                     {
-                        %outLine = %this.call("processMissionGroupLine", %line, %fileBase);
-                        
-                        if(%line !$= %outLine)
-                        {
-                           %fileWasChanged = true;
-                           %line = %outLine;
-                        }
-                     }
-                  }
-                  else if(%className $= "ScriptObject" && %objectName $= "MissionInfo") 
-                  {
-                     if(%this.isMethod("processLevelInfoLine"))
-                     {
-                        %outLine = %this.call("processLevelInfoLine", %line);
-                        
-                        if(%line !$= %outLine)
-                        {
-                           %fileWasChanged = true;
-                           %line = %outLine;
-                        }
-                     }
-                  }
-                  else if(%className $= "Sky") 
-                  {
-                     if(%this.isMethod("processSkyLine"))
-                     {
-                        %outLine = %this.call("processSkyLine", %line);
-                        
-                        if(%line !$= %outLine)
-                        {
-                           %fileWasChanged = true;
-                           %line = %outLine;
-                        }
-                     }
-                  }
-                  else if(%className $= "Water") 
-                  {
-                     if(%this.isMethod("processWaterLine"))
-                     {
-                        %outLine = %this.call("processWaterLine", %line);
-                        
-                        if(%line !$= %outLine)
-                        {
-                           %fileWasChanged = true;
-                           %line = %outLine;
-                        }
-                     }
-                  }
-               }
-            }
-            else if(strIsMatchExpr("*singleton*(*)*", %line))
-            {
-               %className = findObjectClass(%line, "singleton");
-               
-               %objectClassStack.push_back(%className);
-               
-               %objectName = findObjectName(%line, "singleton");
-               
-               if(%objectName !$= "")
-               {
-                  %sanitizedName = sanitizeString(%objectName);
-                  if(startsWith(%sanitizedName, "_"))
-                  {
-                     %sanitizedName = substr(%sanitizedName, 1, -1);
-                  }
-                  if(%sanitizedName !$= %objectName)
-                  {
-                     %line = strReplace(%line, %objectName, %sanitizedName);
-                     
-                     %fileWasChanged = true;
-                  }
-               
-                  if(%objectClassStack.count() == 1)
-                  {
-                     %currentObjClass = %objectClassStack.getKey(%objectClassStack.count()-1);
-                     
-                     //we only process top-level objects directly
-                     %inheritanceList = getClassHierarchy(%currentObjClass);
-                     for (%classDepth =0; %classDepth<getWordCount(%inheritanceList); %classDepth++)
-                     {
-                        %subclass = getWord(%inheritanceList, %classDepth);
-                        %processFunction = "process" @ %subclass @ "Object";
-                        if(%this.isMethod(%processFunction))
-                        {
-                           %this.call(%processFunction, %file, %objectName);
-                        }
-                     }
-                  }
-               }
-            }
-            else if(strIsMatchExpr("*datablock*(*)*", %line) && (strPos(%line, "registerDatablock") == -1))
-            {
-               %className = findObjectClass(%line, "datablock");
-               
-               %objectClassStack.push_back(%className);
-               
-               %objectName = findObjectName(%line, "datablock");
-               
-               if(%objectName !$= "")
-               {
-                  if(%objectClassStack.count() == 1)
-                  {
-                     %currentObjClass = %objectClassStack.getKey(%objectClassStack.count()-1);
-                     
-                     //we only process top-level objects directly
-                     %inheritanceList = getClassHierarchy(%currentObjClass);
-                     for (%classDepth =0; %classDepth<getWordCount(%inheritanceList); %classDepth++)
-                     {
-                        %subclass = getWord(%inheritanceList, %classDepth);
-                        %processFunction = "process" @ %subclass @ "Object";
-                        if(%this.isMethod(%processFunction))
-                        {
-                           %this.call(%processFunction, %file, %objectName);
-                        } 
-                     }
-                  }
-               }
-            }
-            else if(strIsMatchExpr("*};*", %line))
-            {
-               //hit the end of an object, pop our object stack
-               %objectClassStack.pop_back();
-            }
-            else if(strIsMatchExpr("*exec(*.cs*)*", %line) || strIsMatchExpr("*exec(*.tscript*)*", %line))
-            {
-               %scriptExtRemovedLine = strReplace(%line, ".cs", "");
-               %scriptExtRemovedLine = strReplace(%scriptExtRemovedLine, ".tscript", "");
-               %line = %scriptExtRemovedLine;
-               %fileWasChanged = true;
-            }
-            else if(strIsMatchExpr("*queueexec(*.cs*)*", %line) || strIsMatchExpr("*queueexec(*.tscript*)*", %line))
-            {
-               %scriptExtRemovedLine = strReplace(%line, ".cs", "");
-               %scriptExtRemovedLine = strReplace(%scriptExtRemovedLine, ".tscript", "");
-               %line = %scriptExtRemovedLine;
-               %fileWasChanged = true;
-            }
-            else if(strIsMatchExpr("*registerDatablock(*.cs*)*", %line) || strIsMatchExpr("*registerDatablock(*.tscript*)*", %line))
-            {
-               %scriptExtRemovedLine = strReplace(%line, ".cs", "");
-               %scriptExtRemovedLine = strReplace(%scriptExtRemovedLine, ".tscript", "");
-               %line = %scriptExtRemovedLine;
-               %fileWasChanged = true;
-               
-            }
-            else if(strIsMatchExpr("*%this.addSequence(\"*);", %line))
-            {
-               %outLine = processLegacyShapeConstructorField(%line);
-               if(%line !$= %outLine)
-               {
-                  %fileWasChanged = true;
-                  %line = %outLine;
-               }
-            }
-            else
-            {
-               if(%objectClassStack.count() != 0)
-               {
-                  %currentObjClass = %objectClassStack.getKey(%objectClassStack.count()-1);
-                  
-                  %inheritanceList = getClassHierarchy(%currentObjClass);
-                  for (%classDepth =0; %classDepth<getWordCount(%inheritanceList); %classDepth++)
-                  {
-                     %subclass = getWord(%inheritanceList, %classDepth);
-                     %processFunction = "process" @ %subclass @ "Line";
-                     if(%this.isMethod(%processFunction))
-                     {
-                        %outLine = %this.call(%processFunction, %line);
-
-                        if(%line !$= %outLine)
-                        {
-                           %fileWasChanged = true;
-                           %line = %outLine;
-                        }
-                      }
-                  }
-               }
-            }
-            %lineNum++;
-            
-            %fileOutputLines.push_back(%line);
-         }
-         
-         $ProjectImporter::fileObject.close();
-      }
-      else
-      {
-         $ProjectImporter::log.add("Legacy Project Importer - File not able to be opened: " @ %file);  
-      }
-      
-      if(%fileWasChanged)
-      {
-         $ProjectImporter::fileObject.openForWrite(%file);
-
-         for(%l = 0; %l < %fileOutputLines.count(); %l++)
-         {
-            %outLine = %fileOutputLines.getKey(%l);
-            
-            $ProjectImporter::fileObject.writeline(%outLine);
-         }
-         
-         $ProjectImporter::fileObject.close();
-      }
-      
-      %fileOutputLines.empty();
-      %objectClassStack.empty();
-      
-      %file = findNextFileMultiExpr( $ProjectImporter::modulePath @ "/*.*" );
-   }
-   
-   $ProjectImporter::log.add("Legacy Project Importer - Processing of imported code files done!");
-   
-   //exec common loader files, process the remainder into assets
-   
-   //beginMaterialImport();
-   //beginGUIImport();
-   //beginTerrainMaterialImport();
-   //beginTerrainImport();
-   
-   %fileOutputLines.delete();
-   %objectClassStack.delete();
-}
-
-function T3Dpre4ProjectImporter::processScriptExtensions(%this)
-{
-   %currentPage = ProjectImportWindow.getCurrentPage();
-   
-   if($TorqueScriptFileExtension $= "tscript")
-      %file = findFirstFileMultiExpr( $ProjectImporter::modulePath @ "/*/*.cs", true);
-   else
-      %file = findFirstFileMultiExpr( $ProjectImporter::modulePath @ "/*/*.tscript", true);
-   
-   $ProjectImporter::log.add("Legacy Project Importer - Beginning processing of script files that utilize extensions other than: " @ $TorqueScriptFileExtension);
-   
-   //Walk through and process all code files to update references
-   while( %file !$= "" )
-   {      
-      %fileWasChanged = false;
-      
-      %filename = fileName(%file);
-      %fileBase = fileBase(%file);
-      %fileExt = fileExt(%file);
-      %filePath = filePath(%file);
-      
-      $ProjectImporter::currentFilePath = %filePath @ "/";
-      
-      %currentPage-->processingText.setText("Processing material script file: " @ %file);
-      Canvas.repaint();
-      
-      %targetFilePath = %filePath @ "/" @ %fileBase @ "." @ $TorqueScriptFileExtension;
-      if(!pathCopy(%file, %targetFilePath))
-      {
-         $ProjectImporter::log.add("T3Dpre4ProjectImporter::processScriptExtensions() - Failed to create renamed script file for file: " @ %file);
-      }
-      else
-      {
-         if(!fileDelete(%file))
-         {
-            $ProjectImporter::log.add("T3Dpre4ProjectImporter::processScriptExtensions() - Failed to remove old script file for rename: " @ %file);
-         }         
-      }
-      
-      if($TorqueScriptFileExtension $= "tscript")
-         %file = findNextFileMultiExpr( $ProjectImporter::modulePath @ "/*/*.cs");
-      else
-         %file = findNextFileMultiExpr( $ProjectImporter::modulePath @ "/*/*.tscript");
-   }
-   
-   %currentPage = ProjectImportWindow.getCurrentPage();
-   
-   %currentPage-->processingText.setText("Processing of script files done! Press Next to continue.");
-   ProjectImportWindow-->nextButton.setActive(true);
-   Canvas.repaint();
-   
-   $ProjectImporter::log.add("Legacy Project Importer - Beginning processing of script files extensions complete");
-}
-
-//To implement a custom class to have it's fields processed, just utilize this template function
-//and replace the class/field spaces as appropriate
-/*
-function T3Dpre4ProjectImporter::process<ClassName>Line(%this, %line)
-{
-   %outLine = processLegacyField(%line, "<originalFilenameField>", "<newAssetField>");
-  
-   if(%outLine !$= %line)
-      return %outLine;
-   else
-      return %line;
-}
-*/
-//==============================================================================
-// Misc Object Classes
-//==============================================================================
-function T3Dpre4ProjectImporter::genProcessor(%classType, %conversionMap)
-{
-    %stryng = "function T3Dpre4ProjectImporter::process" @%classType@ "Line(%this, %line){\n";
-    %count = getWordCount(%conversionMap);
-    for (%i = 0; %i<%count; %i+=2)
-    {
-        %stryng = %stryng @ " %outLine = processLegacyField(%line,\""@ getWord(%conversionMap,%i)@ "\",\""@ getWord(%conversionMap,%i+1)@"\");\n";
-        %stryng = %stryng @ "  if(%outLine !$= %line) return %outLine;\n";
-    }
-    %stryng = %stryng @ " return %line;\n}";
-    eval(%stryng);
-}
-
-T3Dpre4ProjectImporter::genProcessor("TSShapeConstructor", "baseShape baseShapeAsset shapeName shapeAsset");
-T3Dpre4ProjectImporter::genProcessor("BasicClouds", "texture textureAsset");
-T3Dpre4ProjectImporter::genProcessor("CloudLayer", "texture textureAsset");
-T3Dpre4ProjectImporter::genProcessor("DecalRoad", "material materialAsset");
-T3Dpre4ProjectImporter::genProcessor("MeshRoad", "topMaterial topMaterialAsset bottomMaterial bottomMaterialAsset sideMaterial sideMaterialAsset");
-T3Dpre4ProjectImporter::genProcessor("ScatterSky", "moonMat moonMatAsset");
-T3Dpre4ProjectImporter::genProcessor("Sun", "coronaMaterial coronaMaterialAsset");
-T3Dpre4ProjectImporter::genProcessor("VolumetricFog", "shape ShapeAsset texture textureAsset");
-T3Dpre4ProjectImporter::genProcessor("WaterObject", "rippleTex rippleTexAsset foamTex foamTexAsset depthGradientTex depthGradientTexAsset");
-T3Dpre4ProjectImporter::genProcessor("ConvexShape", "material materialAsset");
-T3Dpre4ProjectImporter::genProcessor("RenderMesh", "material materialAsset");
-T3Dpre4ProjectImporter::genProcessor("RenderShape", "shape shapeAsset");
-T3Dpre4ProjectImporter::genProcessor("GroundCover", "material materialAsset shape shapeAsset shapeFilename shapeAsset");
-T3Dpre4ProjectImporter::genProcessor("GroundPlane", "material materialAsset");
-T3Dpre4ProjectImporter::genProcessor("LevelInfo", "accuTexture accuTextureAsset");
-T3Dpre4ProjectImporter::genProcessor("TSStatic", "shape shapeAsset shapeName shapeAsset");
-T3Dpre4ProjectImporter::genProcessor("TSForestItemData", "shape shapeAsset shapeName shapeAsset shapeFile shapeAsset");
-T3Dpre4ProjectImporter::genProcessor("TerrainBlock", "terrainFile terrainAsset");
-T3Dpre4ProjectImporter::genProcessor("afxMagicMissileData", "projectileShape projectileShapeAsset projectileShapeName projectileShapeAsset sound projectileSoundAsset");
-T3Dpre4ProjectImporter::genProcessor("afxBillboardData", "texture textureAsset");
-T3Dpre4ProjectImporter::genProcessor("afxModelData", "shapeName shapeAsset shapeFile shapeAsset");
-T3Dpre4ProjectImporter::genProcessor("afxZodiacData", "texture textureAsset");
-T3Dpre4ProjectImporter::genProcessor("afxZodiacPlaneData", "texture textureAsset");
-T3Dpre4ProjectImporter::genProcessor("sfxEmitter", "track soundAsset filename soundAsset");
-T3Dpre4ProjectImporter::genProcessor("LightningData", "thunderSounds ThunderSoundAsset strikeSound StrikeSoundAsset");
-//==============================================================================
-// Levels
-//==============================================================================
-function T3Dpre4ProjectImporter::processMissionGroupLine(%this, %line, %missionName)
-{
-   %outline = strreplace(%line, "SimGroup(MissionGroup)", "Scene(" @ %missionName @ ")");
-   
-   if(%outLine !$= %line)
-      return %outLine;
-   else
-      return %line;
-}
-
-function T3Dpre4ProjectImporter::processLevelInfoLine(%this, %line)
-{
-   %outline = strreplace(%line, "ScriptObject(MissionInfo)", "LevelInfo(theLevelInfo)");
-   
-   if(%outLine !$= %line)
-      return %outLine;
-   else
-      return %line;
-}
-
-function T3Dpre4ProjectImporter::processSkyLine(%this, %line)
-{
-   %outline = strreplace(%line, "Sky", "Skybox");
-   
-   if(%outLine !$= %line)
-      return %outLine;
-   else
-      return %line;
-}
-
-function T3Dpre4ProjectImporter::processWaterLine(%this, %line)
-{
-   %outline = strreplace(%line, "Water", "WaterPlane");
-   
-   if(%outLine !$= %line)
-      return %outLine;
-   else
-      return %line;
-}
-
-//==============================================================================
-// GUIs
-//==============================================================================
-T3Dpre4ProjectImporter::genProcessor("GuiIconButtonCtrl", "bitmap bitmapAsset iconBitmap bitmapAsset");
-T3Dpre4ProjectImporter::genProcessor("GuiToolboxButtonCtrl", "normalBitmap normalBitmapAsset loweredBitmap loweredBitmapAsset hoverBitmap hoverBitmapAsset");
-T3Dpre4ProjectImporter::genProcessor("GuiBitmapCtrl", "bitmap bitmapAsset");
-T3Dpre4ProjectImporter::genProcessor("GuiMaterialCtrl", "material materialAsset");
-T3Dpre4ProjectImporter::genProcessor("GuiCursor", "bitmap bitmapAsset");
-T3Dpre4ProjectImporter::genProcessor("GuiChunkedBitmapCtrl", "bitmap bitmapAsset");
-T3Dpre4ProjectImporter::genProcessor("GuiProgressBitmap", "bitmap bitmapAsset");
-T3Dpre4ProjectImporter::genProcessor("GuiMissionArea", "handleBitmap handleBitmapAsset");
-T3Dpre4ProjectImporter::genProcessor("WorldEditor", "selectHandle selectHandleAsset defaultHandle defaultHandleAsset lockedHandle lockedHandleAsset");
-T3Dpre4ProjectImporter::genProcessor("GuiControlProfile", "bitmap bitmapAsset");
-T3Dpre4ProjectImporter::genProcessor("GuiMLTextCtrl", "deniedSound deniedSoundAsset");
-
-function T3Dpre4ProjectImporter::processGuiBitmapButtonCtrlLine(%this, %line)
-{
-   %outLine = processGuiBitmapButtonCtrlField(%line, "bitmap", "bitmapAsset");
-   if(%outLine !$= %line) return %outLine;
-   
-   return %line;
-}
-
-//==============================================================================
-// Datablocks
-//==============================================================================
-T3Dpre4ProjectImporter::genProcessor("ForestItemData", "shape shapeAsset");
-T3Dpre4ProjectImporter::genProcessor("CubeMapData", "cubemapFace cubeMapFaceAsset cubemap cubemapAsset cubeFace cubeMapFaceAsset");
-T3Dpre4ProjectImporter::genProcessor("DebrisData", "shape shapeAsset shapeFile shapeAsset");
-T3Dpre4ProjectImporter::genProcessor("DecalData", "material materialAsset");
-T3Dpre4ProjectImporter::genProcessor("ExplosionData", "explosionShape explosionShapeAsset");
-T3Dpre4ProjectImporter::genProcessor("ParticleData", "texture textureAsset textureName textureAsset textureExt textureExtAsset textureExtName textureExtAsset");
-T3Dpre4ProjectImporter::genProcessor("PrecipitationData", "drop dropAsset dropTexture dropAsset splash splashAsset splashTexture splashAsset soundProfile soundAsset");
-T3Dpre4ProjectImporter::genProcessor("SplashData", "texture textureAsset soundProfile SoundAsset");
-T3Dpre4ProjectImporter::genProcessor("LightFlareData", "flareTexture flareTextureAsset");
-T3Dpre4ProjectImporter::genProcessor("PhysicsDebrisData", "shape shapeAsset shapeFile shapeAsset");
-T3Dpre4ProjectImporter::genProcessor("PhysicsShapeData", "shape shapeAsset shapeName shapeAsset");
-T3Dpre4ProjectImporter::genProcessor("ProjectileData", "projectileShape projectileShapeAsset projectileShapeName projectileShapeAsset sound projectileSoundAsset");
-T3Dpre4ProjectImporter::genProcessor("ShapeBaseData", "shapeFile shapeAsset shape shapeAsset debrisShape debrisShapeAsset debrisShapeName debrisShapeAsset");
-T3Dpre4ProjectImporter::genProcessor("ShapeBaseImageData", "shape shapeAsset[0] shapeFP shapeAsset[1] shapeFile shapeAsset[0] shapeFileFP shapeAsset[1] stateSound stateSoundAsset");
-T3Dpre4ProjectImporter::genProcessor("ProximityMineData","armingSound ArmSoundAsset TriggerSound TriggerSoundAsset");
-T3Dpre4ProjectImporter::genProcessor("WheeledVehicleTire", "shape shapeAsset shapeFile shapeAsset");
-T3Dpre4ProjectImporter::genProcessor("WheeledVehicleData", "engineSound engineSoundAsset squealSound squealSoundAsset");
-T3Dpre4ProjectImporter::genProcessor("FlyingVehicleData", "engineSound engineSoundAsset jetSound jetSoundAsset");
-T3Dpre4ProjectImporter::genProcessor("HoverVehicleData", "engineSound engineSoundAsset jetSound jetSoundAsset floatSound floatSoundAsset");
-
-//==============================================================================
-// Datablocks - Long Lists
-//==============================================================================
-// - RigidShapeData
-$rigidEntriesList = "softImpactSound softImpactSoundAsset hardImpactSound hardImpactSoundAsset";
-$rigidEntriesList = $rigidEntriesList SPC "exitingWater exitingWaterAsset impactWaterEasy impactWaterEasyAsset";
-$rigidEntriesList = $rigidEntriesList SPC "impactWaterMedium impactWaterMediumAsset impactWaterHard impactWaterHardAsset";
-$rigidEntriesList = $rigidEntriesList SPC "waterWakeSound waterWakeSoundAsset";
-T3Dpre4ProjectImporter::genProcessor("RigidShapeData",$rigidEntriesList);
-// - PlayerData
-$PlayerEntriesList = "shapeFP shapeFPAsset shapeNameFP shapeFPAsset";
-$PlayerEntriesList = $PlayerEntriesList SPC "FootSoftSound FootSoftAsset FootHardSound FootHardAsset FootMetalSound FootMetalAsset";
-$PlayerEntriesList = $PlayerEntriesList SPC "FootSnowSound FootSnowAsset FootShallowSound FootShallowSplashAsset";
-$PlayerEntriesList = $PlayerEntriesList SPC "FootWadingSound FootWadingAsset FootUnderwaterSound FootUnderWaterAsset";
-$PlayerEntriesList = $PlayerEntriesList SPC "FootBubblesSound FootBubblesAsset movingBubblesSound MoveBubblesAsset";
-$PlayerEntriesList = $PlayerEntriesList SPC "waterBreathSound WaterBreathAsset";
-$PlayerEntriesList = $PlayerEntriesList SPC "impactSoftSound ImpactSoftAsset impactHardSound impactHardAsset";
-$PlayerEntriesList = $PlayerEntriesList SPC "impactMetalSound ImpactMetalAsset impactSnowSound impactSnowAsset";
-$PlayerEntriesList = $PlayerEntriesList SPC "impactWaterEasy impactWaterEasyAsset impactWaterMedium impactWaterMediumAsset impactWaterHard impactWaterHardAsset";
-$PlayerEntriesList = $PlayerEntriesList SPC "exitingWater ExitWaterAsset";
-T3Dpre4ProjectImporter::genProcessor("PlayerData", $PlayerEntriesList);
-// - Material
-$MaterialEntriesList = "baseTex diffuseMapAsset diffuseMap diffuseMapAsset";
-$MaterialEntriesList = $MaterialEntriesList SPC "lightMap lightMapAsset toneMap toneMapAsset";
-$MaterialEntriesList = $MaterialEntriesList SPC "detailTex detailMapAsset detailMap detailMapAsset detailNormalMap detailNormalMapAsset";
-$MaterialEntriesList = $MaterialEntriesList SPC "overlayTex overlayMapAsset overlayMap overlayMapAsset";
-$MaterialEntriesList = $MaterialEntriesList SPC "bumpTex normalMapAsset normalMap normalMapAsset";
-$MaterialEntriesList = $MaterialEntriesList SPC "ormConfigMap ormConfigMapAsset roughMap roughMapAsset";
-$MaterialEntriesList = $MaterialEntriesList SPC "aoMap aoMapAsset metalMap metalMapAsset";
-$MaterialEntriesList = $MaterialEntriesList SPC "glowMap glowMapAsset";
-$MaterialEntriesList = $MaterialEntriesList SPC "customFootstepSound customFootstepSoundAsset customImpactSound customImpactSoundAsset";
-T3Dpre4ProjectImporter::genProcessor("Material", $MaterialEntriesList);
-//==============================================================================
-// Materials
-//==============================================================================
-function T3Dpre4ProjectImporter::processMaterialObject(%this, %file, %objectName)
-{
-   %matAsset = MaterialAsset::getAssetIdByMaterialName(%objectName);
-   
-   if(%matAsset $= "" || %matAsset $= "Core_Rendering:NoMaterial")
-   {
-      %assetName = %objectName;
-   
-      %moduleName = AssetBrowser.dirHandler.getModuleFromAddress(%file).ModuleId;
-      
-      %assetPath = filePath(%file) @ "/";   
-      
-      %tamlpath = %assetPath @ %assetName @ ".asset.taml";
-      
-      if(isFile(%tamlpath))
-      {
-         $ProjectImporter::log.add("T3Dpre4ProjectImporter::processMaterialObject() - Failed to create as taml file already exists: " @ %file);
-         return false;
-      }
-      
-      %asset = new MaterialAsset()
-      {
-         AssetName = %assetName;
-         versionId = 1;
-         shaderData = "";
-         materialDefinitionName = %assetName;
-         scriptFile = fileBase(%file);
-      };
-      
-      TamlWrite(%asset, %tamlpath);
-      
-      %moduleDef = ModuleDatabase.findModule(%moduleName, 1);
-      %success = AssetDatabase.addDeclaredAsset(%moduleDef, %tamlpath);
-      
-      if(!%success)
-         return false;
-   }
-   
-   return false;
-}
-
-function T3Dpre4ProjectImporter::processTerrainMaterialLine(%this, %line)
-{
-   %outLine = processLegacyField(%line, "diffuseMap", "diffuseMapAsset");
-   if(%outLine !$= %line) return %outLine;
-   %outLine = processLegacyField(%line, "normalMap", "normalMapAsset");
-   if(%outLine !$= %line) return %outLine;
-   %outLine = processLegacyField(%line, "detailMap", "detailMapAsset");
-   if(%outLine !$= %line) return %outLine;
-   %outLine = processLegacyField(%line, "ORMConfigMap", "ORMConfigMapAsset");
-   if(%outLine !$= %line) return %outLine;
-   %outLine = processLegacyField(%line, "macroMap", "macroMapAsset");
-   if(%outLine !$= %line) return %outLine;
-   return %line;
-}
-
-function T3Dpre4ProjectImporter::processTerrainMaterialObject(%this, %file, %objectName)
-{
-   %matAsset = TerrainMaterialAsset::getAssetIdByMaterialName(%objectName);
-   
-   if(%matAsset $= "" || %matAsset $= "Core_Rendering:noMaterial")
-   {
-      %assetName = %objectName;
-   
-      %moduleName = AssetBrowser.dirHandler.getModuleFromAddress(%file).ModuleId;
-      
-      %assetPath = filePath(%file) @ "/";   
-      
-      %tamlpath = %assetPath @ %assetName @ ".asset.taml";
-      
-      if(isFile(%tamlpath))
-      {
-         $ProjectImporter::log.add("T3Dpre4ProjectImporter::processTerrainMaterialObject() - Failed to create as taml file already exists: " @ %file);
-         return false;
-      }
-      
-      %asset = new TerrainMaterialAsset()
-      {
-         AssetName = %assetName;
-         versionId = 1;
-         shaderData = "";
-         materialDefinitionName = %objectName;
-         scriptFile = fileName(%file);
-      };
-      
-      TamlWrite(%asset, %tamlpath);
-      
-      %moduleDef = ModuleDatabase.findModule(%moduleName, 1);
-      %success = AssetDatabase.addDeclaredAsset(%moduleDef, %tamlpath);
-      
-      if(!%success)
-         return false;
-   }
-   
-   return false;
-}
-//==============================================================================
-// PostEffects
-//==============================================================================
-T3Dpre4ProjectImporter::genProcessor("PostEffect", "texture textureAsset");
-
-//==============================================================================
-// Sounds
-// Sounds are a little weird because there's so much data tied up in a given sound
-// source. So our approach is find old SFXProfiles and process those into sound assets
-// by cross-referencing the filename for existing asset definitions.
-// Using existing SFXProfiles allows us to also injest the descriptions, giving us
-// our meta-properties on the sound asset itself.
-//==============================================================================
-T3Dpre4ProjectImporter::genProcessor("SFXAmbience", "soundTrack soundTrackAsset");
-T3Dpre4ProjectImporter::genProcessor("SFXPlayList", "track trackAsset");
-
-function T3Dpre4ProjectImporter::processSFXProfileLine(%this, %line)
-{
-   return %line;
-}
-
-function T3Dpre4ProjectImporter::processSFXProfileObject(%this, %file, %objectName)
-{
-   %soundFilename = findObjectField("filename");
-   
-   %soundFilename = sanitizeFilename(%soundFilename);
-
-   %soundAsset = SoundAsset::getAssetIdByFilename(%soundFilename);
-   
-   //Throw a warn that this file's already been claimed and move on
-   if(%soundAsset !$= "")
-   {
-      $ProjectImporter::log.add("T3Dpre4ProjectImporter::processSFXProfileObject() - attempting to process SFXProfile " @ %objectName 
-               @ " but its filename is already associated to another sound asset. Continuing, but be aware.");
-   }  
-
-      %assetName = %objectName;
-   
-      %moduleName = AssetBrowser.dirHandler.getModuleFromAddress(%soundFilename).ModuleId;
-      
-      %assetPath = filePath(%soundFilename) @ "/";   
-      
-      %tamlpath = %assetPath @ %assetName @ ".asset.taml";
-      
-      if(isFile(%tamlpath))
-      {
-         $ProjectImporter::log.add("T3Dpre4ProjectImporter::processSFXProfileObject() - Failed to create as taml file already exists: " @ %soundFilename);
-         return false;
-      }
-      
-      %asset = new SoundAsset()
-      {
-         AssetName = %assetName;
-         versionId = 1;
-         shaderData = "";
-         soundFile = fileBase(%soundFilename) @ fileExt(%soundFilename);
-      };
-      
-      %descriptionName = findObjectField("description");
-      
-      if(%descriptionName !$= "")
-      {
-         //Optimization, see if we already have this description by happenstance
-         if(isObject(%descriptionName))
-         {
-            %asset.sourceGroup = %descriptionName.sourceGroup;
-            %asset.volume = %descriptionName.volume;
-            %asset.pitch = %descriptionName.pitch;
-            %asset.isLooping = %descriptionName.isLooping;
-            %asset.priority = %descriptionName.priority;
-            %asset.useHardware = %descriptionName.useHardware;
-            %asset.is3D = %descriptionName.is3D;
-            %asset.minDistance = %descriptionName.minDistance;
-            %asset.maxDistance = %descriptionName.maxDistance;
-            %asset.scatterDistance = %descriptionName.scatterDistance;
-            %asset.coneInsideAngle = %descriptionName.coneInsideAngle;            
-            %asset.coneOutsideAngle = %descriptionName.coneOutsideAngle;         
-            %asset.coneOutsideVolume = %descriptionName.coneOutsideVolume;
-            %asset.rolloffFactor = %descriptionName.rolloffFactor;
-            %asset.isStreaming = %descriptionName.isStreaming;
-         }
-         else
-         {
-         %objFileFinder = "";
-         //first check our cache
-         if(isObject($ProjectImporter::SFXDescriptionCache) && 
-            $ProjectImporter::SFXDescriptionCache.getIndexFromKey(%descriptionName) !$= "")
-         {
-            %key = $ProjectImporter::SFXDescriptionCache.getIndexFromKey(%descriptionName);
-            %objFileFinder = $ProjectImporter::SFXDescriptionCache.getValue(%key);
-         }
-         else
-         {
-            %objFileFinder = findObjectInFiles(%descriptionName);
-         }
-         
-            if(%objFileFinder !$= "")
-            {
-               %valueArray = new ArrayObject();
-               
-            %fileObj = getField(%objFileFinder, 0);
-               
-            %valueArray.add("sourceGroup" SPC findObjectField("sourceGroup", %fileObj));
-            %valueArray.add("volume" SPC findObjectField("volume", %fileObj));
-            %valueArray.add("pitch" SPC findObjectField("pitch", %fileObj));
-            %valueArray.add("isLooping" SPC findObjectField("isLooping", %fileObj));
-            %valueArray.add("priority" SPC findObjectField("priority", %fileObj));
-            %valueArray.add("useHardware" SPC findObjectField("useHardware", %fileObj));
-            %valueArray.add("is3D" SPC findObjectField("is3D", %fileObj));
-            %valueArray.add("minDistance" SPC findObjectField("minDistance", %fileObj));
-            %valueArray.add("maxDistance" SPC findObjectField("maxDistance", %fileObj));
-            %valueArray.add("scatterDistance" SPC findObjectField("scatterDistance", %fileObj));
-            %valueArray.add("coneInsideAngle" SPC findObjectField("coneInsideAngle", %fileObj));
-            %valueArray.add("coneOutsideAngle" SPC findObjectField("coneOutsideAngle", %fileObj));
-            %valueArray.add("coneOutsideVolume" SPC findObjectField("coneOutsideVolume", %fileObj));
-            %valueArray.add("rolloffFactor" SPC findObjectField("rolloffFactor", %fileObj));
-            %valueArray.add("isStreaming" SPC findObjectField("isStreaming", %fileObj));
-            
-            if(isObject($ProjectImporter::SFXDescriptionCache))
-            {
-               $ProjectImporter::SFXDescriptionCache.add(%descriptionName, %objFileFinder);
-            }
-               
-               for(%v=0; %v < %valueArray.Count(); %v++)
-               {
-                  %varSet = %valueArray.getKey(%v);
-                  %var = getWord(%varSet, 0);
-                  %varVal = getWord(%varSet, 1);
-
-                  if(%varVal !$= "")
-                     %asset.setFieldValue(%var, %varVal);
-               }
-            
-            %valueArray.delete();
-            }
-         }
-      }
-      
-      TamlWrite(%asset, %tamlpath);
-      
-      %moduleDef = ModuleDatabase.findModule(%moduleName, 1);
-      %success = AssetDatabase.addDeclaredAsset(%moduleDef, %tamlpath);
-      
-      if(!%success)
-         return false;
-   
-   //Now mark the original SFXProfile for removal from the file as it's redundant
-   //now that we have the asset def
-   $ProjectImporter::ToRemoveObjectList.add(%objectName, %file TAB 0);
-   
-   return true;
-}
-
-function T3Dpre4ProjectImporter::processAudioProfileObject(%this, %file, %objectName)
-   {
-   return %this.processSFXProfileObject(%file, %objectName);
-      }
-      
-function T3Dpre4ProjectImporter::processSFXDescriptionObject(%this, %file, %objectName)
-      {
-   $ProjectImporter::ToRemoveObjectList.add(%objectName, %file TAB 0);
-   
-   return true;
-}
-
-function T3Dpre4ProjectImporter::processAudioDescriptionObject(%this, %file, %objectName)
-{
-   $ProjectImporter::ToRemoveObjectList.add(%objectName, %file TAB 0);
-   
-   return true;
-}
-
-//==============================================================================
-// Misc Utility functions
-//==============================================================================
-//This is functionally identical to processLegacyField, but we have to special-snowflake our asset lookups
-//due to it using suffix-based indirections
-function processGuiBitmapButtonCtrlField(%line, %originalFieldName, %newFieldName)
-{
-   if(!strIsMatchExpr("*"@%originalFieldName@"=*\"*\";*", %line) && 
-      !strIsMatchExpr("*"@%originalFieldName@"[*=*\"*\";*", %line) &&
-      !strIsMatchExpr("*"@%originalFieldName@" *=*\"*\";*", %line))
-      return %line;
-      
-   %outLine = strreplace(%line, %originalFieldName, %newFieldName);
-   
-   //get the value
-   %value = "";
-   %pos = strpos(%outLine, "= \"");
-   if(%pos != -1)
-   {
-     %endPos = strpos(%outLine, "\";", %pos); 
-     
-     %value = getSubStr(%outLine, %pos+3, %endPos-%pos-3);
-   }
-   else
-   {
-      %pos = strpos(%outLine, "=\"");
-      if(%pos != -1)
-      {
-        %endPos = strpos(%outLine, "\";", %pos); 
-        
-        %value = getSubStr(%outLine, %pos+2, %endPos-%pos-2);
-      }
-   }
-   
-   if(%outLine !$= %line && %pos != -1 && %endPos != -1 && %value !$= "")
-   {
-      $ProjectImporter::log.add("Legacy Project Importer - processing legacy field line: " @ %line);
-      
-      if(startsWith(%value, "$") || startsWith(%value, "#"))
-      {
-         //These are going to be texture/render targets, and we can leave them alone
-         return %line;
-      }
-      
-      %targetFilename = sanitizeFilename(%value);
-      
-      //If we still have nothing, then we fail it out
-      if(!isFile(%targetFilename))
-      {
-         $ProjectImporter::log.add("Legacy Project Importer - file described in line could not be found/is not valid");
-         return %line;
-      }
-      
-      $ProjectImporter::assetQuery.clear();
-      %foundAssets = AssetDatabase.findAssetLooseFile($ProjectImporter::assetQuery, %targetFilename);
-      if(%foundAssets != 0)
-      {
-         %assetId = $ProjectImporter::assetQuery.getAsset(0);
-         $ProjectImporter::log.add("Legacy Project Importer - processing of legacy field line's value: " @ %value @ " has found a matching AssetId: " @ %assetId);
-      }
-     
-      if(%assetId !$= "" && AssetDatabase.isDeclaredAsset(%assetId))
-      {
-         //if (%assetId.getStatusString() $= "Ok")
-         %outLine = strReplace(%outLine, %value, %assetId);
-         //else
-         //   error("Asset assignment failure:", %assetId, getStatusString());
-      }
-   }
-   
-   if(%outLine !$= %line)
-   {
-      $ProjectImporter::log.add("Legacy Project Importer - processing of legacy line: " @ %line @ " has been updated to: " @ %outLine);
-      return %outLine;  
-   }
-   else
-   {
-      return %line;  
-   }
-}
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
index f00941776..8688df941 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
@@ -1,5 +1,7 @@
 $ProjectImporter::rootDir = "tools";
 
+$ProjectImporter::writeToConsole = false;
+
 function ProjectImporter::beginProjectImport()
 {
    Canvas.pushDialog(ProjectImportCtrl);
@@ -15,20 +17,36 @@ function ProjectImportWindow::onWake(%this)
    else
       $ProjectImporter::log.empty();
       
+   if(!isObject($ProjectImporter::importerList))
+      $ProjectImporter::importerList = new ArrayObject();
+   else
+      $ProjectImporter::importerList.empty();
+      
+   //This array is for containing the importer pages for the wizard
+   if(!isObject($ProjectImporter::importerPageList))
+      $ProjectImporter::importerPageList = new ArrayObject();
+   else
+      $ProjectImporter::importerPageList.empty();
+      
    %this.importStepNumber = 0;
-   %this-->stepsList.clear();
-   %this-->stepsList.addRow(0, "Welcome");  
-   %this-->stepsList.addRow(1, "Previous Project Ver.");
-   %this-->stepsList.addRow(2, "Locate Previous Project Content");
-   %this-->stepsList.addRow(3, "Set New Module Name");
-   %this-->stepsList.addRow(4, "Copy Old Files");
-   %this-->stepsList.addRow(5, "Update Script Extensions");
-   %this-->stepsList.addRow(6, "Import");
-   %this-->stepsList.addRow(7, "Done");
    
-   %this.stepCount = %this-->stepsList.rowCount()-1;
+   ProejctImportPageContainer.callOnChildren("setHidden", true);
    
-   %this.showPage(0);
+   $ProjectImporter::importerPageList.add(ProjectImportWizardPage0);
+   $ProjectImporter::importerPageList.add(ProjectImportWizardPage1);
+   $ProjectImporter::importerPageList.add(ProjectImportWizardPage2);
+   $ProjectImporter::importerPageList.add(ProjectImportWizardPage3);
+   $ProjectImporter::importerPageList.add(ProjectImportWizardPage4);
+   
+   %this.setStep(0);
+   
+   //now we iterate over our importers to get them registered and set up
+   for( %file = findFirstFile( "tools/projectImporter/importers/*." @ $TorqueScriptFileExtension );
+           %file !$= "";
+           %file = findNextFile( "tools/projectImporter/importers/*." @ $TorqueScriptFileExtension ))
+   {
+      exec( %file );
+   }
 }
 
 function ProjectImportWindow::previousStep(%this)
@@ -38,12 +56,14 @@ function ProjectImportWindow::previousStep(%this)
       
    %this.importStepNumber--;
    
+   %this.pageChanged = true;
+   
    %this.showPage(%this.importStepNumber);
 }
 
 function ProjectImportWindow::nextStep(%this)
 {
-   if(%this.importStepNumber == %this.stepCount)
+   if(%this.importStepNumber == $ProjectImporter::importerPageList.count())
    {
       Canvas.popDialog(ProjectImportCtrl);
       return;  
@@ -51,12 +71,14 @@ function ProjectImportWindow::nextStep(%this)
    
    %this.importStepNumber++;
    
+   %this.pageChanged = true;
+   
    %this.showPage(%this.importStepNumber);
 }
 
 function ProjectImportWindow::setStep(%this, %stepNum)
 {
-   if(%stepNum >= %this.stepCount)
+   if(%stepNum >= $ProjectImporter::importerPageList.count())
    {
       Canvas.popDialog(ProjectImportCtrl);
       return;  
@@ -67,6 +89,8 @@ function ProjectImportWindow::setStep(%this, %stepNum)
    
    %this.importStepNumber = %stepNum;
    
+   %this.pageChanged = true;
+   
    %this.showPage(%this.importStepNumber);
 }
 
@@ -95,27 +119,42 @@ function ProjectImportWindow::selectOGFolder(%this)
    %dlg.delete();
 }
 
+function ProjectImportWindow::refreshPage(%this)
+{
+   for(%i=0; %i < $ProjectImporter::importerPageList.count(); %i++)
+   {
+      %page = $ProjectImporter::importerPageList.getKey(%i); 
+      %page.setHidden(true);
+      %page.callOnChildren("setHidden", true);
+   }  
+   
+   %page = $ProjectImporter::importerPageList.getKey(%this.importStepNumber);
+   %page.setHidden(false);
+   %page.callOnChildren("setHidden", false);
+}
+
 function ProjectImportWindow::showPage(%this, %pageIndex)
 {
-   if(%pageIndex < 0 || %pageIndex > %this.stepCount)
+   if(%pageIndex < 0 || %pageIndex > $ProjectImporter::importerPageList.count())
       return;
       
    %this.importStepNumber = %pageIndex;
-   %this-->stepsList.clearSelection();
-   %this-->stepsList.setSelectedById(%this.importStepNumber);
    
-   for(%i=0; %i < %this-->stepsList.rowCount(); %i++)
+   %this.refreshPage();
+   
+   if(%this.pageChanged)
    {
-      (ProjectImportWizardPage @ %i).setHidden(true);
+      //run page logic
+      %page = $ProjectImporter::importerPageList.getKey(%this.importStepNumber);
+      %page.openPage();
    }
    
-   (ProjectImportWizardPage @ %this.importStepNumber).setHidden(false);
-   (ProjectImportWizardPage @ %this.importStepNumber).openPage();
+   %this.pageChanged = false;
 }
 
 function ProjectImportWindow::getCurrentPage(%this)
 {
-   return (ProjectImportWizardPage @ %this.importStepNumber);
+   return $ProjectImporter::importerPageList.getKey(%this.importStepNumber);
 }
 
 function ProjectImportWizardPage0::openPage(%this)
@@ -123,24 +162,19 @@ function ProjectImportWizardPage0::openPage(%this)
    ProjectImportWindow-->backButton.setHidden(true);
 }
 
-function ProjectImportWizardPage0::processPage(%this)
-{
-}
-
 function ProjectImportWizardPage1::openPage(%this)
 {
    ProjectImportWindow-->backButton.setHidden(false);
    
    %this-->previousContentVersionPopup.clear();
-   //this-->previousContentVersionPopup.add("Torque Game Engine");
-   //%this-->previousContentVersionPopup.add("Torque Shader Engine");
-   %this-->previousContentVersionPopup.add("Torque 3D Pre-4.0");
-}
-
-function ProjectImportWizardPage1::processPage(%this)
-{
+   
+   for(%i=0; %i < $ProjectImporter::importerList.count(); %i++)
+   {
+      %this-->previousContentVersionPopup.add($ProjectImporter::importerList.getKey(%i));
+   }
 }
 
+//Select destination folder
 function ProjectImportWizardPage2::openPage(%this)
 {
    %version = ProjectImportWizardPage1-->previousContentVersionPopup.getSelected();
@@ -151,45 +185,73 @@ function ProjectImportWizardPage2::openPage(%this)
       return;
    }
    
-   ProjectImportWizardPage2-->internalFolderBtn.setStateOn(false);
-   ProjectImportWizardPage2-->externalFolderBtn.setStateOn(false);
-   ProjectImportWizardPage2-->coreAndToolsBtn.setStateOn(false);
    $ProjectImporter::sourceContentFolder = "";
    %this-->targetImportingPath.setText("");
    
    Canvas.repaint(); //force it to refresh the page so we're up to date.
    
-   switch$(%version)
-   {
-      case 0:
-         $ProjectImporter::versionMode = "T3Dpre4Project";
-      default:
-         $ProjectImporter::versionMode = "T3Dpre4Project";
-   }
+   $ProjectImporter::versionMode = $ProjectImporter::importerList.getKey(%version);
    
    if(isObject($ProjectImporter::importTool))
       $ProjectImporter::importTool.delete();
       
-   $ProjectImporter::importTool = new ScriptObject($ProjectImporter::versionMode @ "Importer");
+   $ProjectImporter::importTool = $ProjectImporter::importerList.getValue(%version);
    
-   if(isObject($ProjectImporter::SFXDescriptionCache))
-      $ProjectImporter::SFXDescriptionCache.delete();
+   //if(isObject($ProjectImporter::SFXDescriptionCache))
+   //   $ProjectImporter::SFXDescriptionCache.delete();
       
-   $ProjectImporter::SFXDescriptionCache = new ArrayObject();
+   //$ProjectImporter::SFXDescriptionCache = new ArrayObject();
    
-   if(isObject($ProjectImporter::ToRemoveObjectList))
-      $ProjectImporter::ToRemoveObjectList.delete();
+   //if(isObject($ProjectImporter::ToRemoveObjectList))
+   //   $ProjectImporter::ToRemoveObjectList.delete();
       
-   $ProjectImporter::ToRemoveObjectList = new ArrayObject();
-}
-
-function ProjectImportWizardPage2::processPage(%this)
-{
+   //$ProjectImporter::ToRemoveObjectList = new ArrayObject();
+   
+   $ProjectImporter::importTool.setupPages(); //Have the importer register it's pages
+   
+   //And then add our final page 
+   $ProjectImporter::importerPageList.add(ProjectImportWizardFinalPage);
 }
 
 function ProjectImportWizardPage3::openPage(%this)
 {
-   if(ProjectImportWizardPage2-->internalFolderBtn.isStateOn())
+   %dataFullPath = makeFullPath("data/");
+   %coreFullPath = makeFullPath("core/");
+   %toolsFullPath = makeFullPath("tools/");
+   if(startsWith(makeFullPath("data/"), $ProjectImporter::sourceContentFolder))
+   {
+      %moduleDef = AssetBrowser.dirHandler.getModuleFromAddress(makeRelativePath($ProjectImporter::sourceContentFolder));
+      if(isObject(%moduleDef))
+      {
+         //already a valid module in place so just skip this step  
+         $ProjectImporter::useExistingModule = true;
+         $ProjectImporter::moduleName = %moduleDef.moduleId;
+         $ProjectImporter::modulePath = "data/" @ $ProjectImporter::moduleName;
+         ProjectImportWindow.setStep(4);
+      }
+   }
+   else if(startsWith(makeFullPath("core/"), $ProjectImporter::sourceContentFolder) ||
+            startsWith(makeFullPath("tools/"), $ProjectImporter::sourceContentFolder))
+   {
+      ProjectImportWindow.setStep(5);
+   }
+   else
+   {
+      %slashCount = getTokenCount($ProjectImporter::sourceContentFolder, "/");
+      %topFolder = getToken($ProjectImporter::sourceContentFolder, "/", %slashCount-1);
+      if(%topFolder $= "")
+         %topFolder = getToken($ProjectImporter::sourceContentFolder, "/", %slashCount-2);
+         
+      //clean up invalid characters and stuff
+      %topFolder = sanitizeString(%topFolder);
+     
+      $ProjectImporter::useExistingModule = false;
+      $ProjectImporter::moduleName = %topFolder; //preseed the module name
+      $ProjectImporter::modulePath = "data/" @ $ProjectImporter::moduleName;
+      
+      ProjectImportWizardPage3-->newModuleName.setText($ProjectImporter::moduleName);
+   }
+   /*if(ProjectImportWizardPage2-->internalFolderBtn.isStateOn())
    {
       $ProjectImporter::importMode = "InternalFolder";
    }
@@ -246,15 +308,373 @@ function ProjectImportWizardPage3::openPage(%this)
    else if($ProjectImporter::importMode $= "CoreAndTools")
    {
       ProjectImportWindow.setStep(5);
-   }
+   }*/
 }
 
-function ProjectImportWizardPage3::processPage(%this)
+//
+function preprocessImportingFiles()
 {
+   //========================================================
+   //BEGIN THE PREPROCESS
+   if(isObject($ProjectImporter::FileList))
+      $ProjectImporter::FileList.delete();
+      
+   $ProjectImporter::FileList = new ArrayObject();
+   
+   %file = findFirstFileMultiExpr( $ProjectImporter::sourceContentFolder @ "/*.*", true);
+   
+   //First, we go through and tabulate all valid files we'll want to copy over into 
+   //our destination point. We're not copying them yet, but we're building the list
+   while( %file !$= "" )
+   {
+      %fileExt = fileExt(%file);
+      
+      if(%fileExt $= ".dll" || %fileExt $= ".log" || %fileExt $= ".exe" || %fileExt $= ".manifest"|| %fileExt $= ".h" ||
+         %fileExt $= ".cpp" || %fileExt $= ".so" || %fileExt $= ".do" || %fileExt $= ".lib" ||%fileExt $= ".exp")
+      {
+         %file = findNextFileMultiExpr( $ProjectImporter::sourceContentFolder @ "/*.*" );
+         continue;
+      }
+      
+      %fileArrayObj = new ArrayObject();
+      
+      %fileArrayObj.fileDestination = strreplace(%file, $ProjectImporter::sourceContentFolder, $ProjectImporter::modulePath);
+      %fileArrayObj.fileDestination = sanitizeFilename(%fileArrayObj.fileDestination);
+      
+      %fileArrayObj.imported = false;
+      
+      //if it was a cs file, we'll be changing the eventual destination extension to comply to 
+      //our set script extension
+      if(fileExt(%fileArrayObj.fileDestination) $= ".cs") 
+      {
+         %fileArrayObj.fileDestination = filePath(%fileArrayObj.fileDestination) @ "/" @ fileBase(%fileArrayObj.fileDestination) @ "." @ $TorqueScriptFileExtension;  
+      }
+      
+      $ProjectImporter::FileList.add(%file, %fileArrayObj);
+      
+      %file = findNextFileMultiExpr( $ProjectImporter::sourceContentFolder @ "/*.*" );
+   }
+   
+   $ProjectImporter::fileElementStack = new ArrayObject();
+   
+   //Now that we've got the list of files we consider to be valid to import,
+   //we'll preprocess them. This lets us 'understand' the contents and for 
+   //script-type files, we can parse them to figure out object defines and the like
+   //which will simplify things when we actually apply any changes to update it to
+   //the new project format later
+   for(%i=0; %i < $ProjectImporter::FileList.count(); %i++)
+   {
+      %file = $ProjectImporter::FileList.getKey(%i);
+      %rootFileSectionObject = $ProjectImporter::FileList.getValue(%i);
+      
+      %fileExt = fileExt(%file);
+      
+      %rootFileSectionObject.fileName = fileName(%file);
+      %rootFileSectionObject.fileBase = fileBase(%file);
+      %rootFileSectionObject.fileExt = %fileExt;
+      
+      if(endsWith(%file, ".asset.taml"))
+      {
+         %rootFileSectionObject.fileExt = ".asset.taml";
+         %rootFileSectionObject.isAssetFile = true;
+      }
+      else if(%fileExt !$= ".cs" && %fileExt !$= ".tscript" && %fileExt !$= ".gui" &&
+         %fileExt !$= ".mis" && %fileExt !$= ".prefab" && %fileExt !$= ".module")
+      {
+         //we don't do this for binary files, for...obvious reasons
+         
+         %rootFileSectionObject.binaryFile = true;
+         
+         if(isImageFormat(%fileExt))
+            %rootFileSectionObject.isImageFile = true;
+         else if(isShapeFormat(%fileExt))
+            %rootFileSectionObject.isShapeFile = true;
+         else if(isSoundFormat(%fileExt))
+            %rootFileSectionObject.isSoundFile = true;
+         else if(%fileExt $= ".ter")
+            %rootFileSectionObject.isTerrainFile = true;
+         continue;
+      }
+         
+      %rootFileSectionObject.binaryFile = false;
+      %currentFileSectionObject = %rootFileSectionObject;
+      %insideFunction = false;
+      %insideObjectBlock = false;
+      %insideCommentBlock = false;
+      
+      if ( $ProjectImporter::fileObject.openForRead( %file ) ) 
+      {
+         echo("Processing File: " @ %file);
+         echo("-------------------------------------");
+         
+         while ( !$ProjectImporter::fileObject.isEOF() ) 
+         {
+            %line = $ProjectImporter::fileObject.readLine();
+            
+            if(strIsMatchExpr("*new*(*)*", %line) && !strIsMatchExpr("*\"*new*(*)*\"*", %line))
+            {
+               %start = strpos(%line, "new ");
+               %end = strpos(%line, "(", %start);
+
+               if(%start != -1 && %end != -1)
+               {
+                  %className = getSubStr(%line, %start + 4, %end-%start-4);
+               }
+               
+               %nameEnd = strpos(%line, ")", %end);
+               
+               %objectName = getSubStr(%line, %end+1, %nameEnd-%end-1);
+               
+               %inheritanceSplit = strpos(%objectName, ":");
+               if(%inheritanceSplit != -1)
+               {
+                  %objectName = getSubStr(%objectName, 0, %inheritanceSplit);
+               }
+               
+               %parentFileSectionObject = %currentFileSectionObject;
+               
+               %currentFileSectionObject = new ArrayObject();
+               %currentFileSectionObject.elementType = "object";
+               %currentFileSectionObject.classType = %className;
+               %currentFileSectionObject.objectName = %objectName;
+               %currentFileSectionObject.fileName = %file;
+               %currentFileSectionObject.skip = false;
+               %currentFileSectionObject.fileDestination = %rootFileSectionObject.fileDestination;
+               %insideObjectBlock = true;
+               
+               %currentFileSectionObject.add(%line);
+
+               %parentFileSectionObject.add(%currentFileSectionObject);
+               
+               //Now for a sanity check, see if we kill the object on the same line as we make it
+               //sometimes people try and be 'efficient' with their code linecount wise
+               if(strIsMatchExpr("*};*", %line))
+               {
+                  %currentFileSectionObject = %parentFileSectionObject;
+                  
+                  %insideFunction = false;
+                  %insideObjectBlock = false;
+                  
+                  if(%currentFileSectionObject.elementType $= "function")
+                     %insideFunction = true;
+                  if(%currentFileSectionObject.elementType $= "object")
+                     %insideObjectBlock = true;
+               }
+            }
+            else if(strIsMatchExpr("*datablock*(*)*", %line))
+            {
+               %start = strpos(%line, "datablock ");
+               %end = strpos(%line, "(", %start);
+
+               if(%start != -1 && %end != -1)
+               {
+                  %className = getSubStr(%line, %start + 10, %end-%start-10);
+               }
+               
+               %nameEnd = strpos(%line, ")", %end);
+               
+               %objectName = getSubStr(%line, %end+1, %nameEnd-%end-1);
+               
+               %inheritanceSplit = strpos(%objectName, ":");
+               if(%inheritanceSplit != -1)
+               {
+                  %objectName = getSubStr(%objectName, 0, %inheritanceSplit);
+               }
+               
+               %parentFileSectionObject = %currentFileSectionObject;
+               
+               %currentFileSectionObject = new ArrayObject();
+               %currentFileSectionObject.elementType = "object";
+               %currentFileSectionObject.classType = %className;
+               %currentFileSectionObject.objectName = %objectName;
+               %currentFileSectionObject.fileName = %file;
+               %currentFileSectionObject.skip = false;
+               %currentFileSectionObject.fileDestination = %rootFileSectionObject.fileDestination;
+               %insideObjectBlock = true;
+               
+               %currentFileSectionObject.add(%line);
+
+               %parentFileSectionObject.add(%currentFileSectionObject);
+               
+               //Now for a sanity check, see if we kill the object on the same line as we make it
+               //sometimes people try and be 'efficient' with their code linecount wise
+               if(strIsMatchExpr("*};*", %line))
+               {
+                  %currentFileSectionObject = %parentFileSectionObject;
+                  
+                  %insideFunction = false;
+                  %insideObjectBlock = false;
+                  
+                  if(%currentFileSectionObject.elementType $= "function")
+                     %insideFunction = true;
+                  if(%currentFileSectionObject.elementType $= "object")
+                     %insideObjectBlock = true;
+               }
+            }
+            else if(strIsMatchExpr("*singleton*(*)*", %line))
+            {
+               %start = strpos(%line, "singleton ");
+               %end = strpos(%line, "(", %start);
+
+               if(%start != -1 && %end != -1)
+               {
+                  %className = getSubStr(%line, %start + 10, %end-%start-10);
+               }
+               
+               %nameEnd = strpos(%line, ")", %end);
+               
+               %objectName = getSubStr(%line, %end+1, %nameEnd-%end-1);
+               
+               %inheritanceSplit = strpos(%objectName, ":");
+               if(%inheritanceSplit != -1)
+               {
+                  %objectName = getSubStr(%objectName, 0, %inheritanceSplit);
+               }
+
+               %parentFileSectionObject = %currentFileSectionObject;
+               
+               %currentFileSectionObject = new ArrayObject();
+               %currentFileSectionObject.elementType = "object";
+               %currentFileSectionObject.classType = %className;
+               %currentFileSectionObject.objectName = %objectName;
+               %currentFileSectionObject.fileName = %file;
+               %currentFileSectionObject.skip = false;
+               %currentFileSectionObject.fileDestination = %rootFileSectionObject.fileDestination;
+               %insideObjectBlock = true;
+               
+               %currentFileSectionObject.add(%line);
+
+               %parentFileSectionObject.add(%currentFileSectionObject);
+               
+               //Now for a sanity check, see if we kill the object on the same line as we make it
+               //sometimes people try and be 'efficient' with their code linecount wise
+               if(strIsMatchExpr("*};*", %line))
+               {
+                  %currentFileSectionObject = %parentFileSectionObject;
+                  
+                  %insideFunction = false;
+                  %insideObjectBlock = false;
+                  
+                  if(%currentFileSectionObject.elementType $= "function")
+                     %insideFunction = true;
+                  if(%currentFileSectionObject.elementType $= "object")
+                     %insideObjectBlock = true;
+               }
+            }
+            else if(strIsMatchExpr("*function*(*)*", %line))
+            {
+               %start = strpos(%line, "function ");
+               %end = strpos(%line, "(", %start);
+
+               if(%start != -1 && %end != -1)
+               {
+                  %functionName = getSubStr(%line, %start + 9, %end-%start-9);
+               }
+               
+               %parentFileSectionObject = %currentFileSectionObject;
+               
+               %currentFileSectionObject = new ArrayObject();
+               %currentFileSectionObject.elementType = "function";
+               %currentFileSectionObject.functionName = %functionName;
+               %currentFileSectionObject.fileDestination = %rootFileSectionObject.fileDestination;
+               %currentFileSectionObject.scopeDepth = 0;
+               
+               %insideFunction = true;
+               %insideObjectBlock = false;
+               
+               %currentFileSectionObject.add(%line);
+               
+               %parentFileSectionObject.add(%currentFileSectionObject);
+               
+               if(strIsMatchExpr("*{*", %line))
+               {
+                  %currentFileSectionObject.scopeDepth++;
+               }
+               if(strIsMatchExpr("*}*", %line))
+               {
+                  %currentFileSectionObject.scopeDepth--;
+                  
+                  if(%currentFileSectionObject.scopeDepth == 0) //we've fully backed out of the function scope, so resolve back to the parent
+                  {
+                     %currentFileSectionObject = %parentFileSectionObject;
+                  
+                     %insideFunction = false;
+                     %insideObjectBlock = false;
+                     
+                     if(%currentFileSectionObject.elementType $= "function")
+                        %insideFunction = true;
+                     if(%currentFileSectionObject.elementType $= "object")
+                        %insideObjectBlock = true;
+                  }
+               }
+            }
+            else
+            {
+               %currentFileSectionObject.add(%line);
+               
+               if(%insideFunction && strIsMatchExpr("*{*", %line))
+               {
+                  %currentFileSectionObject.scopeDepth++;
+               }
+               if(%insideFunction && strIsMatchExpr("*}*", %line))
+               {
+                  %currentFileSectionObject.scopeDepth--;
+                  
+                  if(%currentFileSectionObject.scopeDepth == 0) //we've fully backed out of the function scope, so resolve back to the parent
+                  {
+                     %currentFileSectionObject = %parentFileSectionObject;
+                  
+                     %insideFunction = false;
+                     %insideObjectBlock = false;
+                     
+                     if(%currentFileSectionObject.elementType $= "function")
+                        %insideFunction = true;
+                     if(%currentFileSectionObject.elementType $= "object")
+                        %insideObjectBlock = true;
+                  }
+               }
+               else if(%insideObjectBlock && strIsMatchExpr("*};*", %line) && !strIsMatchExpr("*\"*};*\";*", %line))
+               {
+                  %currentFileSectionObject = %parentFileSectionObject;
+                  
+                  %insideFunction = false;
+                  %insideObjectBlock = false;
+                  
+                  if(%currentFileSectionObject.elementType $= "function")
+                     %insideFunction = true;
+                  if(%currentFileSectionObject.elementType $= "object")
+                     %insideObjectBlock = true;
+               }
+               else if(!%insideFunction && !%insideObjectBlock)
+               {
+                  if(strIsMatchExpr("*/\**", %line))
+                  {
+                     %insideCommentBlock = true;
+                  }
+                  else if(%insideCommentBlock && strIsMatchExpr("*\*/*", %line))
+                  {
+                     %insideCommentBlock = false;
+                  }
+                  else if(!%insideCommentBlock && !strIsMatchExpr("*//*", %line))
+                  {
+                     %rootFileSectionObject.hasNonCommentFloatingCode = true;
+                  }
+               }
+            }
+         }
+      }
+      
+      $ProjectImporter::fileObject.close();
+   }
 }
+//
 
 function ProjectImportWizardPage4::openPage(%this)
 {
+   ProjectImportWindow-->preprocessCompleteText.setHidden(true);
+   
+   Canvas.repaint();
+   
    ProjectImportWindow-->backButton.setHidden(true);
    ProjectImportWindow-->nextButton.setActive(false);
       
@@ -270,14 +690,10 @@ function ProjectImportWizardPage4::openPage(%this)
    %sourcePath = $ProjectImporter::sourceContentFolder;
    %targetPath = makeFullPath($ProjectImporter::modulePath);
    
-   //If the source path starts with the module target path at all, we're already that folder, or a subfolder in it, so skip filecopy
-   if(!startsWith(%sourcePath, %targetPath))
-      $ProjectImporter::importTool.copyFiles();
-   else
-      ProjectImportWindow.nextStep();
+   preprocessImportingFiles();
       
    //if we gen'd a new module setup, double check we didn't copy over a module script file under a legacy extension
-   if(!$ProjectImporter::useExistingModule)
+   /*if(!$ProjectImporter::useExistingModule)
    {
       %newModuleName = $ProjectImporter::moduleName;
       %moduleFilePath = "data/" @ %newModuleName;
@@ -291,11 +707,12 @@ function ProjectImportWizardPage4::openPage(%this)
             fileDelete(%moduleFilePath @ "/" @ %newModuleName @ "." @ $TorqueScriptFileExtension);
          }
       }
-   }
-}
+   }*/
 
-function ProjectImportWizardPage4::processPage(%this)
-{
+   ProjectImportWindow-->nextButton.setActive(true);
+   ProjectImportWindow-->preprocessCompleteText.setHidden(false);
+   
+   Canvas.repaint();
 }
 
 function ProjectImportWizardPage5::openPage(%this)
@@ -306,10 +723,6 @@ function ProjectImportWizardPage5::openPage(%this)
    $ProjectImporter::importTool.processImportedFiles();
 }
 
-function ProjectImportWizardPage5::processPage(%this)
-{
-}
-
 function ProjectImportWizardPage6::openPage(%this)
 {
    ProjectImportWindow-->nextButton.setActive(false);
@@ -351,11 +764,7 @@ function ProjectImportWizardPage6::openPage(%this)
    }
 }
 
-function ProjectImportWizardPage6::processPage(%this)
-{
-}
-
-function ProjectImportWizardPage7::openPage(%this)
+function ProjectImportWizardFinalPage::openPage(%this)
 {
    //writing console log
    %logFileObj = new FileObject();
@@ -375,11 +784,19 @@ function ProjectImportWizardPage7::openPage(%this)
    %logFileObj.delete();
 }
 
+//
+function ProjectImportWindow::addImporterPage(%this, %page)
+{
+   ProejctImportPageContainer.add(%page);
+   $ProjectImporter::importerPageList.add(%page);
+}
+//
+
 function beginProjectImport()
 {
-   $ProjectImporter::log.add("===========================================");
-   $ProjectImporter::log.add("Beginning Project Import");
-   $ProjectImporter::log.add("===========================================");
+   projectImporterLog("===========================================");
+   projectImporterLog("Beginning Project Import");
+   projectImporterLog("===========================================");
    
    $ProjectImporter::assetQuery = new AssetQuery();
    $ProjectImporter::importer = new AssetImporter();
@@ -410,9 +827,9 @@ function beginProjectImport()
    $ProjectImporter::importer.delete();
    $ProjectImporter::persistMgr.delete();
    
-   $ProjectImporter::log.add("===========================================");
-   $ProjectImporter::log.add("Finished Project Import");
-   $ProjectImporter::log.add("===========================================");
+   projectImporterLog("===========================================");
+   projectImporterLog("Finished Project Import");
+   projectImporterLog("===========================================");
    
    AssetBrowser.refresh(); //update the AB just in case
 }
@@ -478,7 +895,7 @@ function sanitizeFilename(%file)
       %targetFilename = %targetPath @ "/" @ %targetName @ %targetExt;
    }
    
-   if(!isFile(%targetFilename))
+   /*if(!isFile(%targetFilename))
    {
       %bitmapFile = %targetPath @ "/" @ %targetName @ "_n" @ %targetExt;
       if(isFile(%bitmapFile))
@@ -497,9 +914,22 @@ function sanitizeFilename(%file)
       return %file;
    }
    else
-   {
+   {*/
       return %targetFilename;
+   //}
+}
+
+function isImportingFile(%checkFile)
+{
+   for(%i=0; %i < $ProjectImporter::FileList.count(); %i++)
+   {
+      %file = $ProjectImporter::FileList.getKey(%i);
+      
+      if(%file $= %checkFile)
+         return true;
    }
+   
+   return false;
 }
 
 function testFilenameExtensions(%filename)
@@ -560,7 +990,7 @@ function processLegacyField(%line, %originalFieldName, %newFieldName)
    
    if(%outLine !$= %line && %pos != -1 && %endPos != -1 && %value !$= "")
    {
-      $ProjectImporter::log.add("Legacy Project Importer - processing legacy field line: " @ %line);
+      projectImporterLog("Legacy Project Importer - processing legacy field line: " @ %line);
       
       if(startsWith(%value, "$") || startsWith(%value, "#"))
       {
@@ -570,6 +1000,12 @@ function processLegacyField(%line, %originalFieldName, %newFieldName)
          
       %targetFilename = sanitizeFilename(%value);
       
+      %fileExt = fileExt(%targetFilename);
+      if(%fileExt $= "")
+      {
+         %targetFilename = testFilenameExtensions(%targetFilename);
+      }
+      
       if(isObject(%targetFilename))
       {
          //likely a material name, so handle it that way
@@ -591,18 +1027,17 @@ function processLegacyField(%line, %originalFieldName, %newFieldName)
       {
          if(!isFile(%targetFilename))
          {
-            if(%originalFieldName $= "soundProfile")
+            //We may just have a discrete name we need to look up instead
+            $ProjectImporter::assetQuery.clear();
+            %foundAssets = AssetDatabase.findAssetName($ProjectImporter::assetQuery, %targetFilename);
+            if(%foundAssets != 0)
             {
-               $ProjectImporter::assetQuery.clear();
-               %foundAssets = AssetDatabase.findAssetName($ProjectImporter::assetQuery, %targetFilename);
-               if(%foundAssets != 0)
-               {
-                  %assetId = $ProjectImporter::assetQuery.getAsset(0);  
-               }
+               %assetId = $ProjectImporter::assetQuery.getAsset(0);  
             }
             else
             {
-               $ProjectImporter::log.add("Legacy Project Importer - file described in line could not be found/is not valid");
+               //Ultimately, we didn't find it and need to cut our losses
+               projectImporterLog("Legacy Project Importer - file described in line could not be found/is not valid");
                return %line;
             }
          }
@@ -619,7 +1054,7 @@ function processLegacyField(%line, %originalFieldName, %newFieldName)
      
       if(%assetId !$= "" && AssetDatabase.isDeclaredAsset(%assetId))
       {
-         $ProjectImporter::log.add("Legacy Project Importer - processing of legacy field line's value: " @ %value @ " has found a matching AssetId: " @ %assetId);
+         projectImporterLog("Legacy Project Importer - processing of legacy field line's value: " @ %value @ " has found a matching AssetId: " @ %assetId);
          
          //double check if this already had the quotes around the value or not
          if(!strIsMatchExpr("*\"*\"*", %originalValue))
@@ -634,7 +1069,7 @@ function processLegacyField(%line, %originalFieldName, %newFieldName)
    
    if(%outLine !$= %line)
    {
-      $ProjectImporter::log.add("Legacy Project Importer - processing of legacy line: " @ %line @ " has been updated to: " @ %outLine);
+      projectImporterLog("Legacy Project Importer - processing of legacy line: " @ %line @ " has been updated to: " @ %outLine);
       return %outLine;  
    }
    else
@@ -672,7 +1107,7 @@ function processLegacyShapeConstructorField(%line)
    if(%foundAssets != 0)
    {
       %assetId = $ProjectImporter::assetQuery.getAsset(0);
-      $ProjectImporter::log.add("Legacy Project Importer - processing of legacy shape constructor addSequence line's value: " @ %animSourcePath @ " has found a matching AssetId: " @ %assetId);
+      projectImporterLog("Legacy Project Importer - processing of legacy shape constructor addSequence line's value: " @ %animSourcePath @ " has found a matching AssetId: " @ %assetId);
    }
   
    if(%assetId !$= "" && AssetDatabase.isDeclaredAsset(%assetId))
@@ -685,7 +1120,7 @@ function processLegacyShapeConstructorField(%line)
    
    if(%outLine !$= %line)
    {
-      $ProjectImporter::log.add("Legacy Project Importer - processing of legacy shape constructor addSequence line: " @ %line @ " has been updated to: " @ %outLine);
+      projectImporterLog("Legacy Project Importer - processing of legacy shape constructor addSequence line: " @ %line @ " has been updated to: " @ %outLine);
       return %outLine;  
    }
    else
@@ -694,256 +1129,226 @@ function processLegacyShapeConstructorField(%line)
    }
 }
 
-function findObjectClass(%line, %createWord)
+function renameObjectName(%object, %newName)
 {
-   //we have a new object, add it to the stack
-   //substr to peel the class name
-   %start = strpos(%line, %createWord @ " ");
-   %end = strpos(%line, "(", %start);
-   %createLen = strlen(%createWord @ " ");
-   
-   if(%start != -1 && %end != -1)
+   for(%e=0; %e < %object.count(); %e++)
    {
-      %className = getSubStr(%line, %start + %createLen, %end-%start-%createLen);
-      
-      %className = trim(%className);
-      
-      return %className;
-   }
-   
-   return ""; 
-}
-
-function findObjectName(%line, %createWord)
-{
-   //we have a new object, add it to the stack
-   //substr to peel the class name
-   %start = strpos(%line, %createWord @ " ");
-   %end = strpos(%line, "(", %start);
-   
-   %nameEnd = strpos(%line, ")", %end);
-   
-   %objectName = getSubStr(%line, %end+1, %nameEnd-%end-1);
-   
-   if(%objectName !$= "")
-   {
-      if(strpos(%objectName, ":") != -1)
+      %objectLine = %object.getKey(%e);
+      if(!isObject(%objectLine))
       {
-         %objectName = getSubStr(%objectName, 0, strpos(%objectName, ":"));
-      }
-      
-      if(strpos(%objectName, ",") != -1)
-      {
-         %objectName = getSubStr(%objectName, 0, strpos(%objectName, ","));
-      }
-      
-      %objectName = trim(%objectName);
-   }
-   
-   return %objectName; 
-}
-
-function findObjectField(%fieldName, %fileObj)
-{
-   if(%fileObj $= "")
-      %fileObj = $ProjectImporter::fileObject;
-      
-   %value = "";
-   %peekLineOffset = 0;
-   %peekLine = %fileObj.peekLine(%peekLineOffset);
-   while(!strIsMatchExpr("*};*", %peekLine) && 
-         !strIsMatchExpr("*singleton*(*)*", %peekLine) && 
-         !strIsMatchExpr("*new*(*)*", %peekLine) && 
-         !strIsMatchExpr("*datablock*(*)*", %peekLine)&& 
-         !strIsMatchExpr("\n", %peekLine) && 
-         !strIsMatchExpr("\r", %peekLine))
-   {
-      if(strpos(strlwr(%peekLine), strlwr(%fieldName)) != -1)
-      {
-         %value = "";
-         %pos = strpos(%peekLine, "= \"");
-         if(%pos != -1)
+         if(strIsMatchExpr("*singleton*(*)*", %objectLine) && 
+            strIsMatchExpr("*new*(*)*", %objectLine) && 
+            strIsMatchExpr("*datablock*(*)*", %objectLine))
          {
-           %endPos = strpos(%peekLine, "\";", %pos); 
-           
-           %value = getSubStr(%peekLine, %pos+3, %endPos-%pos-3);
-           break;
-         }
-         
-            %pos = strpos(%peekLine, "=\"");
-            if(%pos != -1)
-            {
-              %endPos = strpos(%peekLine, "\";", %pos); 
-              
-              %value = getSubStr(%peekLine, %pos+2, %endPos-%pos-2);
-              break;
-            }
-         
-         %pos = strpos(%peekLine, "= ");
-         if(%pos != -1)
-         {
-           %endPos = strpos(%peekLine, ";", %pos); 
-           
-           %value = getSubStr(%peekLine, %pos+2, %endPos-%pos-2);
-           break;
-         }
-
-         %pos = strpos(%peekLine, "=");
-         if(%pos != -1)
-         {
-           %endPos = strpos(%peekLine, ";", %pos); 
-           
-           %value = getSubStr(%peekLine, %pos+2, %endPos-%pos-2);
-           break;
+            %newLine = strreplace(%object.objectName, %newName);
+            
+            echo("renameObjectName() - lines changed from:");
+            echo(%objectLine);
+            echo("to:");
+            echo(%newLine);
+            
+            %object.setKey(%newLine, %e);
          }  
       }
-      
-      %peekLineOffset++;
-      %peekLine = %fileObj.peekLine(%peekLineOffset);
-   }  
-   
-   return %value;
-}
-
-function findObjectInFiles(%objectName)
-{
-   //First, wipe out any files inside the folder first
-   %file = findFirstFileMultiExpr( "*.*", true);
-   
-   %fileObj = new FileObject();
-   
-   while( %file !$= "" )
-   {      
-      %filename = fileName(%file);
-      %fileBase = fileBase(%file);
-      %fileExt = fileExt(%file);
-      %filePath = filePath(%file);
-      
-      if ( %fileObj.openForRead( %file ) ) 
-      {
-         %lineNum = 0;
-         while ( !%fileObj.isEOF() ) 
-         {
-            %line = %fileObj.readLine();
-            %trimmedLine = trim(%line);
-            
-            if(strIsMatchExpr("*new*(*)*", %line) && strpos(%line, "::") == -1)
-            {
-               %className = findObjectClass(%line, "new");
-               if (%className $= "") continue;
-
-               %objName = findObjectName(%line, "new");
-               
-               if(%objectName $= %objName)
-               {
-                  return %fileObj TAB %file TAB %lineNum;
-               }
-            }
-            else if(strIsMatchExpr("*datablock*(*)*", %line) && strpos(%line, "::") == -1)
-            {
-               %className = findObjectClass(%line, "datablock");
-               if (%className $= "") continue;
-
-               %objName = findObjectName(%line, "datablock");
-               
-               if(%objectName $= %objName)
-               {
-                  return %fileObj TAB %file TAB %lineNum;
-               }
-            }
-            else if(strIsMatchExpr("*singleton*(*)*", %line) && strpos(%line, "::") == -1)
-            {
-               %className = findObjectClass(%line, "singleton");
-               if (%className $= "") continue;
-
-               %objName = findObjectName(%line, "singleton");
-               
-               if(%objectName $= %objName)
-               {
-                  return %fileObj TAB %file TAB %lineNum;
-               }
-            }
-            
-            %lineNum++;
-         }
-         
-         %fileObj.close();
-      }
-      else
-      {
-         $ProjectImporter::log.add("findObjectInFiles() - File not able to be opened: " @ %file);  
-      }
-      
-      %file = findNextFileMultiExpr( "*.*" );
    }
-
-   %fileObj.delete();
-   
-   return "";
 }
+
+function findObjectField(%object, %fieldName)
+{
+   %return = "";
+   for(%e=0; %e < %object.count(); %e++)
+   {
+      %objectLine = %object.getKey(%e);
+      if(!isObject(%objectLine))
+      {
+         if(!strIsMatchExpr("*};*", %objectLine) && 
+            !strIsMatchExpr("*singleton*(*)*", %objectLine) && 
+            !strIsMatchExpr("*new*(*)*", %objectLine) && 
+            !strIsMatchExpr("*datablock*(*)*", %objectLine)&& 
+            !strIsMatchExpr("\n", %objectLine) && 
+            !strIsMatchExpr("\r", %objectLine))
+         {
+            if(strpos(strlwr(%objectLine), strlwr(%fieldName)) != -1)
+            {
+               %pos = strpos(%objectLine, "= \"");
+               if(%pos != -1)
+               {
+                 %endPos = strpos(%objectLine, "\";", %pos); 
+                 
+                 %return = getSubStr(%objectLine, %pos+3, %endPos-%pos-3);
+                 break;
+               }
+               
+               %pos = strpos(%objectLine, "=\"");
+               if(%pos != -1)
+               {
+                 %endPos = strpos(%objectLine, "\";", %pos); 
+                 
+                 %return = getSubStr(%objectLine, %pos+2, %endPos-%pos-2);
+                 break;
+               }
+               
+               %pos = strpos(%objectLine, "= ");
+               if(%pos != -1)
+               {
+                 %endPos = strpos(%objectLine, ";", %pos); 
+                 
+                 %return = getSubStr(%objectLine, %pos+2, %endPos-%pos-2);
+                 break;
+               }
+
+               %pos = strpos(%objectLine, "=");
+               if(%pos != -1)
+               {
+                 %endPos = strpos(%objectLine, ";", %pos); 
+                 
+                 %return = getSubStr(%objectLine, %pos+2, %endPos-%pos-2);
+                 break;
+               }  
+            }
+         }  
+      }
+   }
+   
+   return %return;
+}
+
+function setObjectField(%object, %fieldName, %newValue)
+{
+   for(%e=0; %e < %object.count(); %e++)
+   {
+      %objectLine = %object.getKey(%e);
+      if(!isObject(%objectLine))
+      {
+         if(!strIsMatchExpr("*};*", %objectLine) && 
+            !strIsMatchExpr("*singleton*(*)*", %objectLine) && 
+            !strIsMatchExpr("*new*(*)*", %objectLine) && 
+            !strIsMatchExpr("*datablock*(*)*", %objectLine)&& 
+            !strIsMatchExpr("\n", %objectLine) && 
+            !strIsMatchExpr("\r", %objectLine))
+         {
+            if(strpos(strlwr(%objectLine), strlwr(%fieldName)) != -1)
+            {
+               %pos = strpos(%objectLine, "= \"");
+               if(%pos != -1)
+               {
+                 %endPos = strpos(%objectLine, "\";", %pos); 
+                 
+                 %value = getSubStr(%objectLine, %pos+3, %endPos-%pos-3);
+                 %editedLine = strreplace(%objectLine, %value, %newValue);
+                 %object.setKey(%editedLine, %e);
+                 break;
+               }
+               
+               %pos = strpos(%objectLine, "=\"");
+               if(%pos != -1)
+               {
+                 %endPos = strpos(%objectLine, "\";", %pos); 
+                 
+                 %value = getSubStr(%objectLine, %pos+2, %endPos-%pos-2);
+                 %editedLine = strreplace(%objectLine, %value, %newValue);
+                 %object.setKey(%editedLine, %e);
+                 break;
+               }
+               
+               %pos = strpos(%objectLine, "= ");
+               if(%pos != -1)
+               {
+                 %endPos = strpos(%objectLine, ";", %pos); 
+                 
+                 %value = getSubStr(%objectLine, %pos+2, %endPos-%pos-2);
+                 %editedLine = strreplace(%objectLine, %value, %newValue);
+                 %object.setKey(%editedLine, %e);
+                 break;
+               }
+
+               %pos = strpos(%objectLine, "=");
+               if(%pos != -1)
+               {
+                 %endPos = strpos(%objectLine, ";", %pos); 
+                 
+                 %value = getSubStr(%objectLine, %pos+2, %endPos-%pos-2);
+                 %editedLine = strreplace(%objectLine, %value, %newValue);
+                 %object.setKey(%editedLine, %e);
+                 break;
+               }  
+            }
+         }  
+      }
+   }
+}
+
+function projectImporterLog(%line)
+{
+   if($ProjectImporter::writeToConsole)
+      echo(%line);
+      
+   $ProjectImporter::log.add(%line);
+}
+
 //==============================================================================
 //Shape Importing
 //==============================================================================
 function beginShapeImport()
 {
-   $ProjectImporter::log.add("===========================================");
-   $ProjectImporter::log.add("Importing 3D Shape files");
-   $ProjectImporter::log.add("===========================================");
-   //First, we need to go through and process all loose shape files. This will
-   //get us shape assets, material assets image, assets and animation assets.
+   projectImporterLog("===========================================");
+   projectImporterLog("Importing 3D Shape files");
+   projectImporterLog("===========================================");
+   
+   //First, we need to go through and process all loose image files. This will
+   //get us shape assets, and if the import config deigns, material assets.
    %currentAddress = $ProjectImporter::modulePath;
    
-   //First, wipe out any files inside the folder first
-   %file = findFirstFileMultiExpr( %currentAddress @ "/*.*", true);
-   
-   while( %file !$= "" )
-   {      
-      if(endsWith(%file, "cached.dts"))
-      {
-         %file = findNextFileMultiExpr( %currentAddress @ "/*.*" );
-         continue;
-      }
-      
-      %filename = fileName(%file);
-      %fileExt = fileExt(%file);
-      %filePath = filePath(%file);
-      
-      //Specific exclusions
-      if(endsWith(%filename, "cached.dts"))
-      {
-         %file = findNextFileMultiExpr( %currentAddress @ "/*.*" );
-         continue;
-      }
+   for(%i=0; %i < $ProjectImporter::FileList.count(); %i++)
+   {
+      %file = $ProjectImporter::FileList.getKey(%i);
+      %rootFileSectionObject = $ProjectImporter::FileList.getValue(%i);
+      %destinationPath = %rootFileSectionObject.fileDestination;
+      if(isFile(%file) && %rootFileSectionObject.isShapeFile == true && %rootFileSectionObject.imported == false)
+      {    
+         if(!IsDirectory(filePath(%destinationPath)))
+         {
+            DirectoryHandler::createFolder(0, filePath(%destinationPath));  
+         }
+         
+         if(!pathCopy(%file, %destinationPath, false))
+         {
+            projectImporterLog("ProjectImporter::beginShapeImport() - failed to copy shape: " @ %file @
+                                    " to destination: " @ %destinationPath);
+            continue;
+         }
+           
+         if(endsWith(%destinationPath, "cached.dts"))
+         {
+            continue;
+         }
          
-      if(isShapeFormat(%fileExt))
-      {
          $ProjectImporter::assetQuery.clear();
-         %assetsFound = AssetDatabase.findAssetLooseFile($ProjectImporter::assetQuery, %file);
+         %assetsFound = AssetDatabase.findAssetLooseFile($ProjectImporter::assetQuery, %destinationPath);
          if(%assetsFound == 0)
          {
-            ProjectImportWizardPage5-->processingText.setText("Processing Shape Asset file: " @ %file);
+            //ProjectImportWizardPage5-->processingText.setText("Processing Shape Asset file: " @ %file);
             Canvas.repaint();
             
             //No asset found associated to this fileas far as we can determine, so time to import it
-            
-            $ProjectImporter::log.add("Importing 3D Shape file: " @ %file);
-            %assetId = $ProjectImporter::importer.autoImportFile(%file);  
+            projectImporterLog("Importing 3D Shape file: " @ %destinationPath);
+            %assetId = $ProjectImporter::importer.autoImportFile(%destinationPath);  
             getImporterLogs();
             
             if(%assetId !$= "")
             {
-               $ProjectImporter::log.add("Finished importing 3D Shape file, resulting in asset with an id of: " @ %assetId);
-               $ProjectImporter::log.add("");
+               projectImporterLog("Finished importing 3D Shape file, resulting in asset with an id of: " @ %assetId);
+               projectImporterLog("");
+               
+               %rootFileSectionObject.imported = true;
             }
          }
       }
-      
-      %file = findNextFileMultiExpr( %currentAddress @ "/*.*" );
    }
    
-   $ProjectImporter::log.add("===========================================");
-   $ProjectImporter::log.add("Finished Importing 3D Shape files");
-   $ProjectImporter::log.add("===========================================");
+   projectImporterLog("===========================================");
+   projectImporterLog("Finished Importing 3D Shape files");
+   projectImporterLog("===========================================");
 }
 //==============================================================================
 
@@ -952,56 +1357,62 @@ function beginShapeImport()
 //==============================================================================
 function beginImageImport()
 {
-   $ProjectImporter::log.add("===========================================");
-   $ProjectImporter::log.add("Importing Image files");
-   $ProjectImporter::log.add("===========================================");
+   projectImporterLog("===========================================");
+   projectImporterLog("Importing Image files");
+   projectImporterLog("===========================================");
+   
    //First, we need to go through and process all loose image files. This will
    //get us image assets, and if the import config deigns, material assets.
    %currentAddress = $ProjectImporter::modulePath;
    
-   //First, wipe out any files inside the folder first
-   %file = findFirstFileMultiExpr( %currentAddress @ "/*.*", true);
-   
-   while( %file !$= "" )
-   {      
-      %filename = fileName(%file);
-      %fileExt = fileExt(%file);
-      %filePath = filePath(%file);
-      
-      if(isImageFormat(%fileExt))
-      {
-         if(%filename $= "skybox_1.png")
+   for(%i=0; %i < $ProjectImporter::FileList.count(); %i++)
+   {
+      %file = $ProjectImporter::FileList.getKey(%i);
+      %rootFileSectionObject = $ProjectImporter::FileList.getValue(%i);
+      %destinationPath = %rootFileSectionObject.fileDestination;
+      if(isFile(%file) && %rootFileSectionObject.isImageFile == true && %rootFileSectionObject.imported == false)
+      {    
+         if(!IsDirectory(filePath(%destinationPath)))
          {
-            %aefgadfg = true;
+            DirectoryHandler::createFolder(0, filePath(%destinationPath));  
          }
          
+         if(!pathCopy(%file, %destinationPath, false))
+         {
+            projectImporterLog("ProjectImporter::beginImageImport() - failed to copy image: " @ %file @
+                                    " to destination: " @ %destinationPath);
+            continue;
+         }
+         
+         projectImporterLog("Beginning of Import of Image file: " @ %file);
+         
          $ProjectImporter::assetQuery.clear();
-         %assetsFound = AssetDatabase.findAssetLooseFile($ProjectImporter::assetQuery, %file);
+         %assetsFound = AssetDatabase.findAssetLooseFile($ProjectImporter::assetQuery, %destinationPath);
          if(%assetsFound == 0)
          {
-            ProjectImportWizardPage5-->processingText.setText("Processing Image Asset file: " @ %file);
+            //ProjectImportWizardPage5-->processingText.setText("Processing Image Asset file: " @ %file);
             Canvas.repaint();
       
             //No asset found associated to this fileas far as we can determine, so time to import it
             
-            $ProjectImporter::log.add("Importing Image file: " @ %file);
-            %assetId = $ProjectImporter::importer.autoImportFile(%file);  
+            projectImporterLog("  No Existing ImageAsset found. Continuing Import.");
+            %assetId = $ProjectImporter::importer.autoImportFile(%destinationPath);  
             getImporterLogs();
             
             if(%assetId !$= "")
             {
-               $ProjectImporter::log.add("Finished importing Image file, resulting in asset with an id of: " @ %assetId);
-               $ProjectImporter::log.add("");
+               projectImporterLog("Finished importing Image file, resulting in asset with an id of: " @ %assetId);
+               projectImporterLog("");
+               
+               %rootFileSectionObject.imported = true;
             }
          }
       }
-      
-      %file = findNextFileMultiExpr( %currentAddress @ "/*.*" );
    }
    
-   $ProjectImporter::log.add("===========================================");
-   $ProjectImporter::log.add("Finished Importing Image files");
-   $ProjectImporter::log.add("===========================================");
+   projectImporterLog("===========================================");
+   projectImporterLog("Finished Importing Image files");
+   projectImporterLog("===========================================");
 }
 //==============================================================================
 
@@ -1010,47 +1421,61 @@ function beginImageImport()
 //==============================================================================
 function beginTerrainImport()
 {
-   $ProjectImporter::log.add("===========================================");
-   $ProjectImporter::log.add("Importing Terrain files");
-   $ProjectImporter::log.add("===========================================");
+   projectImporterLog("===========================================");
+   projectImporterLog("Importing Terrain files");
+   projectImporterLog("===========================================");
 
+   //First, we need to go through and process all loose image files. This will
+   //get us shape assets, and if the import config deigns, material assets.
    %currentAddress = $ProjectImporter::modulePath;
    
-   //First, wipe out any files inside the folder first
-   %file = findFirstFileMultiExpr( %currentAddress @ "/*.*", true);
-   
-   while( %file !$= "" )
-   {      
-      %fileName = fileName(%file);
-      %fileExt = fileExt(%file);
-      %filePath = filePath(%file);
-      if(%fileExt $= ".ter")
-      {
+   for(%i=0; %i < $ProjectImporter::FileList.count(); %i++)
+   {
+      %file = $ProjectImporter::FileList.getKey(%i);
+      %rootFileSectionObject = $ProjectImporter::FileList.getValue(%i);
+      %destinationPath = %rootFileSectionObject.fileDestination;
+      if(isFile(%file) && %rootFileSectionObject.isTerrainFile == true && %rootFileSectionObject.imported == false)
+      {    
+         /*%filename = %rootFileSectionObject.fileName;
+         %fileExt = %rootFileSectionObject.fileExt;
+         %filePath = filePath(%file);
+         
          %sanitizedFile = sanitizeFilename(%file);
          if(%sanitizedFile !$= %file)
          {
             %file = %sanitizedFile;
             %fileName = fileName(%file); 
             %filePath = filePath(%file);
+         }*/
+         if(!IsDirectory(filePath(%destinationPath)))
+         {
+            DirectoryHandler::createFolder(0, filePath(%destinationPath));  
+         }
+         
+         if(!pathCopy(%file, %destinationPath, false))
+         {
+            projectImporterLog("ProjectImporter::beginTerrainImport() - failed to copy terrain: " @ %file @
+                                    " to destination: " @ %destinationPath);
+            continue;
          }
             
          $ProjectImporter::assetQuery.clear();
-         %assetsFound = AssetDatabase.findAssetLooseFile($ProjectImporter::assetQuery, %file);
+         %assetsFound = AssetDatabase.findAssetLooseFile($ProjectImporter::assetQuery, %destinationPath);
          if(%assetsFound == 0)
          {
-            ProjectImportWizardPage5-->processingText.setText("Processing Terrain Asset file: " @ %file);
+            //ProjectImportWizardPage5-->processingText.setText("Processing Terrain Asset file: " @ %file);
             Canvas.repaint();
             
-            $ProjectImporter::log.add("Importing Terrain file: " @ %file);
+            projectImporterLog("Importing Terrain file: " @ %destinationPath);
             
-            %moduleDef = AssetBrowser.dirHandler.getModuleFromAddress(%file);
+            %moduleDef = AssetBrowser.dirHandler.getModuleFromAddress(%destinationPath);
             %moduleName = %moduleDef.ModuleID;
             %modulePath = %moduleDef.ModulePath;
                
             //test import config here for forcing type suffixes
-            %assetName = fileBase(%file);
+            %assetName = fileBase(%destinationPath);
             
-            %assetPath = %filePath @ "/";
+            %assetPath = filePath(%destinationPath) @ "/";
             
             %tamlpath = %assetPath @ %assetName @ ".asset.taml";
             
@@ -1058,15 +1483,90 @@ function beginTerrainImport()
             {
                AssetName = %assetName;
                versionId = 1;
-               terrainFile = %fileName;
+               terrainFile = fileName(%destinationPath);
             };
             
             if(TamlWrite(%asset, %tamlpath))
             {
                AssetDatabase.addDeclaredAsset(%moduleDef, %tamlpath);
                
-               $ProjectImporter::log.add("Finished importing Terrain file, resulting in asset with an id of: " @ %moduleName @ ":" @ %assetName);
-               $ProjectImporter::log.add("");
+               projectImporterLog("Finished importing Terrain file, resulting in asset with an id of: " @ %moduleName @ ":" @ %assetName);
+               projectImporterLog("");
+               
+               %rootFileSectionObject.imported = true;
+            }
+         }
+      }
+   }
+   
+   projectImporterLog("===========================================");
+   projectImporterLog("Finished Importing Terrain files");
+   projectImporterLog("===========================================");
+}
+//==============================================================================
+
+//==============================================================================
+//Sound Importing
+//==============================================================================
+function beginSoundImport()
+{
+   projectImporterLog("===========================================");
+   projectImporterLog("Importing Sound files");
+   projectImporterLog("===========================================");
+
+   //First, we need to go through and process all loose image files. This will
+   //get us shape assets, and if the import config deigns, material assets.
+   %currentAddress = $ProjectImporter::modulePath;
+   
+   for(%i=0; %i < $ProjectImporter::FileList.count(); %i++)
+   {
+      %file = $ProjectImporter::FileList.getKey(%i);
+      %rootFileSectionObject = $ProjectImporter::FileList.getValue(%i);
+      %destinationPath = %rootFileSectionObject.fileDestination;
+      if(isFile(%file) && %rootFileSectionObject.isSoundFile == true && %rootFileSectionObject.imported == false)
+      {    
+         /*%filename = %rootFileSectionObject.fileName;
+         %fileExt = %rootFileSectionObject.fileExt;
+         %filePath = filePath(%file);
+         
+         %sanitizedFile = sanitizeFilename(%file);
+         if(%sanitizedFile !$= %file)
+         {
+            %file = %sanitizedFile;
+            %fileName = fileName(%file); 
+            %filePath = filePath(%file);
+         }*/
+         if(!IsDirectory(filePath(%destinationPath)))
+         {
+            DirectoryHandler::createFolder(0, filePath(%destinationPath));  
+         }
+         
+         if(!pathCopy(%file, %destinationPath, false))
+         {
+            projectImporterLog("ProjectImporter::beginSoundImport() - failed to copy sound: " @ %file @
+                                    " to destination: " @ %destinationPath);
+            continue;
+         }
+            
+         $ProjectImporter::assetQuery.clear();
+         %assetsFound = AssetDatabase.findAssetLooseFile($ProjectImporter::assetQuery, %destinationPath);
+         if(%assetsFound == 0)
+         {
+            //ProjectImportWizardPage5-->processingText.setText("Processing Image Asset file: " @ %file);
+            Canvas.repaint();
+      
+            //No asset found associated to this fileas far as we can determine, so time to import it
+            
+            projectImporterLog("  No Existing SoundAsset found. Continuing Import.");
+            %assetId = $ProjectImporter::importer.autoImportFile(%destinationPath);  
+            getImporterLogs();
+            
+            if(%assetId !$= "")
+            {
+               projectImporterLog("Finished importing Sound file, resulting in asset with an id of: " @ %assetId);
+               projectImporterLog("");
+               
+                %rootFileSectionObject.imported = true;
             }
          }
       }
@@ -1074,95 +1574,97 @@ function beginTerrainImport()
       %file = findNextFileMultiExpr( %currentAddress @ "/*.*" );
    }
    
-   $ProjectImporter::log.add("===========================================");
-   $ProjectImporter::log.add("Finished Importing Terrain files");
-   $ProjectImporter::log.add("===========================================");
+   projectImporterLog("===========================================");
+   projectImporterLog("Finished Importing Sound files");
+   projectImporterLog("===========================================");
 }
 //==============================================================================
 
-//==============================================================================
-//Sound Importing
-//==============================================================================
-
-//==============================================================================
-
 //==============================================================================
 //Gui Importing
 //==============================================================================
 function beginGUIImport()
 {
-   $ProjectImporter::log.add("===========================================");
-   $ProjectImporter::log.add("Importing GUIs");
-   $ProjectImporter::log.add("===========================================");
+   projectImporterLog("===========================================");
+   projectImporterLog("Importing GUIs");
+   projectImporterLog("===========================================");
    
+   //First, we need to go through and process all loose image files. This will
+   //get us shape assets, and if the import config deigns, material assets.
    %currentAddress = $ProjectImporter::modulePath;
    
-   //First, wipe out any files inside the folder first
-   %file = findFirstFileMultiExpr( %currentAddress @ "/*.*", true);
-   
-   while( %file !$= "" )
-   {      
-      %fileName = fileName(%file);
-      %fileExt = fileExt(%file);
-      %filePath = filePath(%file);
-      if(%fileExt $= ".gui")
-      {
+   for(%i=0; %i < $ProjectImporter::FileList.count(); %i++)
+   {
+      %file = $ProjectImporter::FileList.getKey(%i);
+      %rootFileSectionObject = $ProjectImporter::FileList.getValue(%i);
+      %destinationPath = %rootFileSectionObject.fileDestination;
+      if(isFile(%file) && %rootFileSectionObject.fileExt $= ".gui" && %rootFileSectionObject.imported == false)
+      {   
          $ProjectImporter::assetQuery.clear();
-         %assetsFound = AssetDatabase.findAssetLooseFile($ProjectImporter::assetQuery, %file);
+         %assetsFound = AssetDatabase.findAssetLooseFile($ProjectImporter::assetQuery, %destinationPath);
          if(%assetsFound == 0)
          {
-            ProjectImportWizardPage5-->processingText.setText("Processing GUI Asset file: " @ %file);
+            //ProjectImportWizardPage5-->processingText.setText("Processing GUI Asset file: " @ %file);
             Canvas.repaint();
             
-            if ( $ProjectImporter::fileObject.openForRead( %file ) ) 
+            %guiObjectName = "";
+            
+            //find our root GUI item
+            for(%g = 0; %g < %rootFileSectionObject.count(); %g++)
             {
-               while ( !$ProjectImporter::fileObject.isEOF() ) 
+               %fileElement = %rootFileSectionObject.getKey(%g);
+               if(%fileElement.elementType $= "Object")
                {
-                  %line = $ProjectImporter::fileObject.readLine();
-                  
-                  if(strIsMatchExpr("*new*(*)*", %line))
+                  %guiObjectName = %fileElement.objectName;
+                  %delcareLine = %fileElement.getKey(0);
+                  if(startsWith(%delcareLine, "%guiContent"))
                   {
-                     %start = strpos(%line, "new ");
-                     %end = strpos(%line, "(", %start);
-
-                     if(%start != -1 && %end != -1)
+                     %equalPos = strPos(%delcareLine, "=");
+                     if(%equalPos != -1)
                      {
-                        %className = getSubStr(%line, %start + 4, %end-%start-4);
+                          %declareSubStr = getSubStr(%delcareLine, %equalPos + 1);
+                          
+                          //update the line to remove the unneeded local var
+                          %fileElement.setKey(%declareSubStr, 0);
                      }
-                     
-                     %nameEnd = strpos(%line, ")", %end);
-                     
-                     %objectName = getSubStr(%line, %end+1, %nameEnd-%end-1);
-                     
-                     if(%objectName !$= "")
-                     {
-                        if(strpos(%objectName, ":") != -1)
-                        {
-                           %objectName = getSubStr(%objectName, 0, strpos(%objectName, ":"));
-                        }
-                     }
-                     
-                     processGUIntoAsset(%objectName, %file);
-                     break;
                   }
+                  break;
                }
             }
             
-            $ProjectImporter::fileObject.close();
+            if(%guiObjectName $= "")
+            {
+               projectImporterLog("ProjectImporter::beginGUIImport() - failed to find root GUI control in file: " @ %file);
+               continue;
+            }
+
+            if(!IsDirectory(filePath(%destinationPath)))
+            {
+               DirectoryHandler::createFolder(0, filePath(%destinationPath));  
+            }
+
+            if(!pathCopy(%file, %destinationPath, false))
+            {
+               projectImporterLog("ProjectImporter::beginGUIImport() - failed to copy GUI: " @ %file @
+                  " to destination: " @ %destinationPath);
+               continue;
+            }
+
+            processGUIntoAsset(%guiObjectName, %destinationPath);
+            
+            %rootFileSectionObject.imported = true;
          }
       }
-      
-      %file = findNextFileMultiExpr( %currentAddress @ "/*.*" );
    }
 
-   $ProjectImporter::log.add("===========================================");
-   $ProjectImporter::log.add("Finished Importing GUIs");
-   $ProjectImporter::log.add("===========================================");
+   projectImporterLog("===========================================");
+   projectImporterLog("Finished Importing GUIs");
+   projectImporterLog("===========================================");
 }
 
 function processGUIntoAsset(%guiName, %file)
 {
-   $ProjectImporter::log.add("Processing GUI into asset: " @ %guiName @ ", file: " @ %file);
+   projectImporterLog("Processing GUI into asset: " @ %guiName @ ", file: " @ %file);
    
    %filePath = filePath(%file);
    %fileName = fileBase(%file);
@@ -1177,9 +1679,9 @@ function processGUIntoAsset(%guiName, %file)
    %tamlpath = %assetPath @ %assetName @ ".asset.taml";
    
    %scriptFile = "";
-   if(isFile(%filePath @ "/" @ %fileName @ ".cs"))
+   if(isImportingFile(%filePath @ "/" @ %fileName @ ".tscript"))
    {
-      %scriptFile = %fileName @ ".cs";
+      %scriptFile = %fileName @ ".tscript";
    }
    
    %asset = new GUIAsset()
@@ -1190,9 +1692,10 @@ function processGUIntoAsset(%guiName, %file)
       guiFile = fileName(%file);
    };
    
-   TamlWrite(%asset, %tamlpath);
-	
-	AssetDatabase.addDeclaredAsset(%moduleDef, %tamlpath);
+   if(TamlWrite(%asset, %tamlpath))
+   {
+      AssetDatabase.addDeclaredAsset(%moduleDef, %tamlpath);
+   }
 	
 	return %tamlpath;    
 }
@@ -1209,9 +1712,9 @@ function processGUIntoAsset(%guiName, %file)
 //==============================================================================
 function beginPostFXImport()
 {
-   $ProjectImporter::log.add("===========================================");
-   $ProjectImporter::log.add("Importing PostFXs");
-   $ProjectImporter::log.add("===========================================");
+   projectImporterLog("===========================================");
+   projectImporterLog("Importing PostFXs");
+   projectImporterLog("===========================================");
    
    %count = PostFXManager.Count();
    for(%i=0; %i < %count; %i++)
@@ -1220,7 +1723,7 @@ function beginPostFXImport()
       
       if(isObject(%postEffect))
       {     
-         $ProjectImporter::log.add("Processing import of PostFX: " @ %postEffect.getName());
+         projectImporterLog("Processing import of PostFX: " @ %postEffect.getName());
          
          //$ProjectImporter::persistMgr.setDirty(%gui);
       }
@@ -1228,9 +1731,9 @@ function beginPostFXImport()
    
    //$ProjectImporter::persistMgr.saveDirty();
 
-   $ProjectImporter::log.add("===========================================");
-   $ProjectImporter::log.add("Finished Importing PostFXs");
-   $ProjectImporter::log.add("===========================================");
+   projectImporterLog("===========================================");
+   projectImporterLog("Finished Importing PostFXs");
+   projectImporterLog("===========================================");
 }
 //==============================================================================
 
@@ -1239,36 +1742,50 @@ function beginPostFXImport()
 //==============================================================================
 function beginLevelImport()
 {
-   $ProjectImporter::log.add("===========================================");
-   $ProjectImporter::log.add("Importing Level files");
-   $ProjectImporter::log.add("===========================================");
+   projectImporterLog("===========================================");
+   projectImporterLog("Importing Level files");
+   projectImporterLog("===========================================");
 
+   //First, we need to go through and process all loose image files. This will
+   //get us shape assets, and if the import config deigns, material assets.
    %currentAddress = $ProjectImporter::modulePath;
    
-   //First, wipe out any files inside the folder first
-   %file = findFirstFileMultiExpr( %currentAddress @ "/*.*", true);
-   
-   while( %file !$= "" )
-   {      
-      %fileName = fileName(%file);
-      %fileExt = fileExt(%file);
-      %filePath = filePath(%file);
-      %fileBase = fileBase(%file);
-      
-      if(%fileExt $= ".mis")
-      {
+   for(%i=0; %i < $ProjectImporter::FileList.count(); %i++)
+   {
+      %file = $ProjectImporter::FileList.getKey(%i);
+      %rootFileSectionObject = $ProjectImporter::FileList.getValue(%i);
+      %destinationPath = %rootFileSectionObject.fileDestination;
+      if(isFile(%file) && %rootFileSectionObject.fileExt $= ".mis" && %rootFileSectionObject.imported == false)
+      {    
+         %fileName = fileName(%destinationPath);
+         %fileExt = fileExt(%destinationPath);
+         %fileBase = fileBase(%destinationPath);
+         %filePath = filePath(%destinationPath);
+         
+         if(!IsDirectory(filePath(%destinationPath)))
+         {
+            DirectoryHandler::createFolder(0, filePath(%destinationPath));  
+         }
+         
+         if(!pathCopy(%file, %destinationPath, false))
+         {
+            projectImporterLog("ProjectImporter::beginLevelImport() - failed to copy level: " @ %file @
+                                    " to destination: " @ %destinationPath);
+            continue;
+         }
+         
          %newAsset = false;
          
          $ProjectImporter::assetQuery.clear();
-         %assetsFound = AssetDatabase.findAssetLooseFile($ProjectImporter::assetQuery, %file);
+         %assetsFound = AssetDatabase.findAssetLooseFile($ProjectImporter::assetQuery, %destinationPath);
          if(%assetsFound == 0)
          {
-            ProjectImportWizardPage5-->processingText.setText("Processing Level Asset file: " @ %file);
+            //ProjectImportWizardPage5-->processingText.setText("Processing Level Asset file: " @ %file);
             Canvas.repaint();
             
-            $ProjectImporter::log.add("Importing Level file: " @ %file);
+            projectImporterLog("Importing Level file: " @ %file);
             
-            %moduleName = AssetBrowser.dirHandler.getModuleFromAddress(%file).ModuleId;
+            %moduleName = AssetBrowser.dirHandler.getModuleFromAddress(%destinationPath).ModuleId;
 
             %assetName = %fileBase;
             
@@ -1276,7 +1793,7 @@ function beginLevelImport()
             
             if(AssetDatabase.isDeclaredAsset(%moduleName @ ":" @ %assetName))
             {
-               $ProjectImporter::log.add("Legacy Project Importer - trying to process a level into an asset that already exists");
+               projectImporterLog("Legacy Project Importer - trying to process a level into an asset that already exists");
                return false;  
             }
             
@@ -1301,24 +1818,28 @@ function beginLevelImport()
          }
 
          //Time to process the associated files 
-            if(isFile(%filePath @ "/" @ %fileBase @ ".decal"))
-            {
-               %asset.decalsFile = %fileBase @ ".decal";
-            }
-            if(isFile(%filePath @ "/" @ %fileBase @ ".forest"))
-            {
-               %asset.forestFile = %fileBase @ ".forest";
-            }
-            if(isFile(%filePath @ "/" @ %fileBase @ ".nav"))
-            {
-               %asset.decalsFile = %fileBase @ ".nav";
-            }
-            if(isFile(%filePath @ "/" @ %fileBase @ ".postfx.preset"))
-            {
-               %asset.postFXPresetFile = %fileBase @ ".postfx.preset";
-            }
-            
-            if(isFile(%filePath @ "/" @ %fileBase @ ".png"))
+         if(isFile(%filePath @ "/" @ %fileBase @ ".decal"))
+         {
+            %asset.decalsFile = %fileBase @ ".decal";
+         }
+         else if(isFile(%filePath @ "/" @ %fileBase @ "mis.decal"))
+         {
+            %asset.decalsFile = %fileBase @ "mis.decal";
+         }
+         if(isFile(%filePath @ "/" @ %fileBase @ ".forest"))
+         {
+            %asset.forestFile = %fileBase @ ".forest";
+         }
+         if(isFile(%filePath @ "/" @ %fileBase @ ".nav"))
+         {
+            %asset.decalsFile = %fileBase @ ".nav";
+         }
+         if(isFile(%filePath @ "/" @ %fileBase @ ".postfx.preset"))
+         {
+            %asset.postFXPresetFile = %fileBase @ ".postfx.preset";
+         }
+         
+         if(isFile(%filePath @ "/" @ %fileBase @ ".png"))
                %previewImageAsset = ImageAsset::getAssetIdByFilename(%filePath @ "/" @ %fileBase @ ".png");
          else if(isFile(%filePath @ "/" @ %fileBase @ "_preview.png"))
             %previewImageAsset = ImageAsset::getAssetIdByFilename(%filePath @ "/" @ %fileBase @ "_preview.png");
@@ -1337,28 +1858,30 @@ function beginLevelImport()
          
          if(%previewImageAsset !$= "")
          {
-               %asset.addAssetDependencyField(previewImageAsset, %previewImageAsset);
+            %asset.addAssetDependencyField(previewImageAsset, %previewImageAsset);
+         }
+         
+         if(TamlWrite(%asset, %tamlpath))
+         {
+            if(%newAsset)
+            {
+               %moduleDef = ModuleDatabase.findModule(%moduleName, 1);
+            
+               %success = AssetDatabase.addDeclaredAsset(%moduleDef, %tamlpath);
+            }
+            else
+            {
+               %asset.refreshAsset();
             }
-            
-            TamlWrite(%asset, %tamlpath);
-            
-         if(%newAsset)
-         {
-            %moduleDef = ModuleDatabase.findModule(%moduleName, 1);
-            %success = AssetDatabase.addDeclaredAsset(%moduleDef, %tamlpath);
-         }
-         else
-         {
-            %asset.refreshAsset();
          }
+         
+         %rootFileSectionObject.imported = true;
       }
-      
-      %file = findNextFileMultiExpr( %currentAddress @ "/*.*" );
    }
    
-   $ProjectImporter::log.add("===========================================");
-   $ProjectImporter::log.add("Finished Importing Level files");
-   $ProjectImporter::log.add("===========================================");
+   projectImporterLog("===========================================");
+   projectImporterLog("Finished Importing Level files");
+   projectImporterLog("===========================================");
 }
 //==============================================================================
 
@@ -1397,9 +1920,9 @@ function ProjectImporter::deleteAssetDefinitions(%targetFolder)
 
 function doDeleteAssetDefinitions()
 {
-   $ProjectImporter::log.add("===========================================");
-   $ProjectImporter::log.add("Deleting Asset Definitions");
-   $ProjectImporter::log.add("===========================================");
+   projectImporterLog("===========================================");
+   projectImporterLog("Deleting Asset Definitions");
+   projectImporterLog("===========================================");
    
    %currentAddress = $deleteAssetDefsTargetFolder;
    
@@ -1415,27 +1938,27 @@ function doDeleteAssetDefinitions()
       {
          if(fileDelete(%file))
          {
-            $ProjectImporter::log.add("File: " @ %file @ " deleted successfully.");  
+            projectImporterLog("File: " @ %file @ " deleted successfully.");  
          }
          else
          {
-            $ProjectImporter::log.add("File: " @ %file @ " failed to delete.");  
+            projectImporterLog("File: " @ %file @ " failed to delete.");  
          }
       }
       
       %file = findNextFileMultiExpr( %currentAddress @ "/*.asset.taml" );
    }
 
-   $ProjectImporter::log.add("===========================================");
-   $ProjectImporter::log.add("Finished Deleting Asset Definitions");
-   $ProjectImporter::log.add("===========================================");
+   projectImporterLog("===========================================");
+   projectImporterLog("Finished Deleting Asset Definitions");
+   projectImporterLog("===========================================");
 }
 
 function scanForDuplicateFiles(%toTestFile)
 {
-   $ProjectImporter::log.add("===========================================");
-   $ProjectImporter::log.add("Scanning for duplicate files!");
-   $ProjectImporter::log.add("===========================================");
+   projectImporterLog("===========================================");
+   projectImporterLog("Scanning for duplicate files!");
+   projectImporterLog("===========================================");
    
    //First, wipe out any files inside the folder first
    %file = findFirstFileMultiExpr( "*/*.*", true);
@@ -1479,8 +2002,8 @@ function scanForDuplicateFiles(%toTestFile)
             if(%moduleName !$= "" && %testModuleName !$= "" && %moduleName $= %testModuleName)
             {
                //report the probable duplicate
-               $ProjectImporter::log.add("Probable duplicate asset detected!");
-               $ProjectImporter::log.add("Files: " @ %file @ " and " @ %toTestFile @ " have matching names and exist within the same module!");
+               projectImporterLog("Probable duplicate asset detected!");
+               projectImporterLog("Files: " @ %file @ " and " @ %toTestFile @ " have matching names and exist within the same module!");
             }
          }
       }
@@ -1494,6 +2017,6 @@ function getImporterLogs()
    %lineCount = $ProjectImporter::importer.getActivityLogLineCount();
    for(%i=0; %i < %lineCount; %i++)
    {
-      $ProjectImporter::log.add($ProjectImporter::importer.getActivityLogLine(%i));
+      projectImporterLog($ProjectImporter::importer.getActivityLogLine(%i));
    }
 }
\ No newline at end of file

From 728aa83481954fc43f52d387475c19352023a753 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Thu, 20 Jan 2022 17:48:01 -0600
Subject: [PATCH 298/399] Comments and cleanup

---
 .../pre40/T3Dpre4ProjectImporter.tscript      | 156 ++-----
 .../importers/pre40/pre40ImporterGuis.tscript |   7 +
 .../scripts/projectImporter.tscript           | 421 ++++++++----------
 3 files changed, 222 insertions(+), 362 deletions(-)

diff --git a/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript
index 693d22a6c..c494c5029 100644
--- a/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript
@@ -1,3 +1,7 @@
+//==============================================================================
+// Initialization function that registers this importer to the main Project Importer
+// allowing it to be selected/invoked in the main Project Importer wizard
+//==============================================================================
 function T3Dpre4ProjectImporter::init()
 {
    //register this importer option to the project importer listing
@@ -14,6 +18,10 @@ function T3Dpre4ProjectImporter::init()
 
 T3Dpre4ProjectImporter::init(); //kick off the setup
 
+//==============================================================================
+// Sets up and registers the pages for this particular version importer
+// to the Project Importer for navigating through with the import process
+//==============================================================================
 function T3Dpre4ProjectImporter::setupPages(%this)
 {
    ProjectImportWindow.addImporterPage(Pre40ImporterPage0);
@@ -22,8 +30,9 @@ function T3Dpre4ProjectImporter::setupPages(%this)
    ProjectImportWindow.refreshPage();
 }
 
-//
-//
+//==============================================================================
+// Sets up the target module
+//==============================================================================
 function T3Dpre4ProjectImporter::setupModule(%this)
 {
    %newModuleName = $ProjectImporter::moduleName;
@@ -98,117 +107,9 @@ function T3Dpre4ProjectImporter::setupModule(%this)
    AssetBrowser.refresh();
 }
 
-/*function T3Dpre4ProjectImporter::copyFiles(%this)
-{
-   %currentPage = ProjectImportWindow.getCurrentPage();
-   
-   %currentPage-->fileCopyText.setText("Beginning copy of files to new module folder now. This may take a few minutes...");
-   Canvas.repaint();
-   
-   %file = findFirstFileMultiExpr( $ProjectImporter::sourceContentFolder @ "/*.*", true);
-   
-   while( %file !$= "" )
-   {
-      %filePath = filePath(%file);
-      %fileName = fileName(%file);
-      %fileBase = fileBase(%file);
-      %fileExt = fileExt(%file);
-      
-      if(endsWith(%fileName, ".asset.taml"))
-      {
-         %fileBase = strreplace(%fileBase, ".asset", "");
-         %fileExt = ".asset.taml";
-      }
-      
-      if(%fileExt $= ".dll" || %fileExt $= ".log" || %fileExt $= ".exe" || %fileExt $= ".manifest"|| %fileExt $= ".h" ||
-         %fileExt $= ".cpp" || %fileExt $= ".so" || %fileExt $= ".do" || %fileExt $= ".lib" ||%fileExt $= ".exp")
-      {
-         %file = findNextFileMultiExpr( $ProjectImporter::sourceContentFolder @ "/*.*" );
-         continue;
-      }
-      
-      //filter out some unneeded folders
-      %slashCount = getTokenCount(%filePath, "/");
-      %topFolder = getToken(%filePath, "/", %slashCount-1);
-      if(%topFolder $= "")
-         %topFolder = getToken(%filePath, "/", %slashCount-2);
-         
-      if(%topFolder $= "creator" || %topFolder $= "tools" || %topFolder $= "web")
-      {
-         %file = findNextFileMultiExpr( $ProjectImporter::sourceContentFolder @ "/*.*" );
-         continue;
-      }
-      
-      %targetFilePath = strReplace(%file, $ProjectImporter::sourceContentFolder, $ProjectImporter::modulePath);
-      
-      %sanitizedFilename = sanitizeString(%fileBase);
-      if(startsWith(%sanitizedFilename, "_"))
-      {
-         %sanitizedFilename = substr(%sanitizedFilename, 1, -1);
-      }
-      if(%sanitizedFilename !$= %fileBase)
-      {
-         %targetFilePath = filePath(%targetFilePath) @ "/" @ %sanitizedFilename @ %fileExt;
-      }
-      
-      %targetFolder = filePath(%targetFilePath);
-      
-      if(!isDirectory(%targetFolder))
-      {
-         DirectoryHandler::createFolder(0, %targetFolder);
-      }
-      
-      if(!pathCopy(%file, %targetFilePath, false))
-      {
-         projectImporterLog("Legacy Project Importer, failed to copy file: " @ %file @ " to destination: " @ %targetFilePath);
-      }
-      
-      %file = findNextFileMultiExpr( $ProjectImporter::sourceContentFolder @ "/*.*" );
-   }
-   
-   //
-   //Now that we've done that, we'll load and scan the module for asset defs
-   %file = findFirstFileMultiExpr( $ProjectImporter::modulePath @ "/*.asset.taml", true);
-   
-   while( %file !$= "" )
-   {
-      %moduleName = AssetBrowser.dirHandler.getModuleFromAddress(%file).ModuleId;
-      %moduleDef = ModuleDatabase.findModule(%moduleName, 1);
-      
-      AssetDatabase.addDeclaredAsset(%moduleDef, %file);
-      
-      %file = findNextFileMultiExpr( $ProjectImporter::modulePath @ "/*.asset.taml" );
-   }
-   //
-   
-   %currentPage-->fileCopyText.setValue("File copy done! Press Next to continue.");
-   
-   ProjectImportWindow-->nextButton.setActive(true);
-   Canvas.repaint();
-}
-
-function T3Dpre4ProjectImporter::processImportedFiles(%this)
-{
-   if($ProjectImporter::importMode $= "CoreAndTools")
-   {
-      $ProjectImporter::modulePath = "Core";
-      %this.doImport();
-      
-      $ProjectImporter::modulePath = "Tools";
-      %this.doImport();
-   }
-   else
-   {
-      %this.doImport();
-   }
-   
-   %currentPage = ProjectImportWindow.getCurrentPage();
-   
-   %currentPage-->processingText.setText("Processing of files done! Press Next to continue.");
-   ProjectImportWindow-->nextButton.setActive(true);
-   Canvas.repaint();
-}*/
-
+//==============================================================================
+// Import content file types such as images, sounds, materials, etc
+//==============================================================================
 function T3Dpre4ProjectImporter::doContentImport(%this)
 {
    //Store off the current default import config
@@ -226,6 +127,9 @@ function T3Dpre4ProjectImporter::doContentImport(%this)
    %this.beginSoundProfilesImport();
 }
 
+//==============================================================================
+// Import script-based files like guis, levels and scripts
+//==============================================================================
 function T3Dpre4ProjectImporter::doScriptImport(%this)
 {
    beginLevelImport();
@@ -240,6 +144,9 @@ function T3Dpre4ProjectImporter::doScriptImport(%this)
    EditorSettings.setValue("Assets/AssetImporDefaultConfig", %this.defaultConfig);
 }
 
+//==============================================================================
+// Writes out the importing file to the new destination
+//==============================================================================
 function T3Dpre4ProjectImporter::writeImportingObject(%this, %arrayObj)
 {
    if(!isObject(%arrayObj) || %arrayObj.skip)
@@ -301,7 +208,10 @@ function T3Dpre4ProjectImporter::writeImportingFiles(%this)
    }
 }
 
-//
+//==============================================================================
+// Processes through the importing files for material definitions and generates
+// the new assets into the destination module
+//==============================================================================
 function T3Dpre4ProjectImporter::processMaterialObjects(%this, %arrayObj)
 {
    if(!isObject(%arrayObj))
@@ -456,7 +366,10 @@ function T3Dpre4ProjectImporter::beginMaterialFilesImport(%this)
    projectImporterLog("===========================================");
 }
 
-//
+//==============================================================================
+// Processes through the importing files for SFXProfile definitions and
+// generates the new assest into the destination module
+//==============================================================================
 function T3Dpre4ProjectImporter::processSoundProfileObjects(%this, %arrayObj)
 {
    if(!isObject(%arrayObj))
@@ -558,7 +471,11 @@ function T3Dpre4ProjectImporter::beginSoundProfilesImport(%this)
    projectImporterLog("===========================================");
 }
 
-//
+//==============================================================================
+// Processes through the importing files for scripted object definitions and
+// updates their names and fields to be asset-compliant, converting filepaths
+// to assetIds where valid
+//==============================================================================
 function T3Dpre4ProjectImporter::processScripts(%this, %arrayObj)
 {
    if(!isObject(%arrayObj))
@@ -716,14 +633,15 @@ function T3Dpre4ProjectImporter::beginScriptFilesImport(%this)
    projectImporterLog("Legacy Project Importer - Processing of imported code files done!");
 }
 
-//
+//==============================================================================
+// Processes through the importing files for module and asset definitions and
+// updates them to be compliant
+//==============================================================================
 function T3Dpre4ProjectImporter::processModuleFile(%this, %moduleObj)
 {
    if(!isObject(%moduleObj))
       return;
       
-   %moduleObj.echo();
-      
    //really, we only care here about ensuring the file extensions are cleaned up
    for(%l=0; %l < %moduleObj.count(); %l++)
    {
diff --git a/Templates/BaseGame/game/tools/projectImporter/importers/pre40/pre40ImporterGuis.tscript b/Templates/BaseGame/game/tools/projectImporter/importers/pre40/pre40ImporterGuis.tscript
index 4ad259602..816b5cf80 100644
--- a/Templates/BaseGame/game/tools/projectImporter/importers/pre40/pre40ImporterGuis.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/importers/pre40/pre40ImporterGuis.tscript
@@ -1,3 +1,7 @@
+//==============================================================================
+// We first copy over binary files(images, shapes, sounds, etc) to the destination
+// module, then run the processing/import on them to generate the assets
+//==============================================================================
 function Pre40ImporterPage0::openPage(%this)
 {
    ProjectImportWindow-->nextButton.setActive(false);
@@ -75,6 +79,9 @@ function Pre40ImporterPage0::openPage(%this)
    Canvas.repaint();
 }
 
+//==============================================================================
+// This page actually invokes the processing of the script-based files and objects
+//==============================================================================
 function Pre40ImporterPage1::openPage(%this)
 {
    ProjectImportWindow-->nextButton.setActive(false);
diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
index 8688df941..ab47a18a9 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
@@ -7,8 +7,24 @@ function ProjectImporter::beginProjectImport()
    Canvas.pushDialog(ProjectImportCtrl);
 }
 
+//==============================================================================
+// Wake-up and initial setup
+//==============================================================================
 function ProjectImportWindow::onWake(%this)
 {
+   if(isObject($ProjectImporter::assetQuery))
+      $ProjectImporter::assetQuery.delete();
+   $ProjectImporter::assetQuery = new AssetQuery();
+      
+   if(isObject($ProjectImporter::importer))
+      $ProjectImporter::importer.delete();
+   $ProjectImporter::importer = new AssetImporter();
+   $ProjectImporter::importer.dumpLogs = false; //we handle the log dump outselves here
+   
+   if(isObject($ProjectImporter::persistMgr))
+      $ProjectImporter::persistMgr.delete();
+   $ProjectImporter::persistMgr = new PersistenceManager();
+   
    if(!isObject($ProjectImporter::fileObject))
       $ProjectImporter::fileObject = new FileObject();
       
@@ -49,6 +65,9 @@ function ProjectImportWindow::onWake(%this)
    }
 }
 
+//==============================================================================
+// Page Navigation
+//==============================================================================
 function ProjectImportWindow::previousStep(%this)
 {
    if(%this.importStepNumber == 0)
@@ -63,7 +82,7 @@ function ProjectImportWindow::previousStep(%this)
 
 function ProjectImportWindow::nextStep(%this)
 {
-   if(%this.importStepNumber == $ProjectImporter::importerPageList.count())
+   if(%this.importStepNumber == $ProjectImporter::importerPageList.count()-1)
    {
       Canvas.popDialog(ProjectImportCtrl);
       return;  
@@ -157,11 +176,17 @@ function ProjectImportWindow::getCurrentPage(%this)
    return $ProjectImporter::importerPageList.getKey(%this.importStepNumber);
 }
 
+//==============================================================================
+// Welcome page
+//==============================================================================
 function ProjectImportWizardPage0::openPage(%this)
 {
    ProjectImportWindow-->backButton.setHidden(true);
 }
 
+//==============================================================================
+// Select the specific version importer
+//==============================================================================
 function ProjectImportWizardPage1::openPage(%this)
 {
    ProjectImportWindow-->backButton.setHidden(false);
@@ -174,7 +199,9 @@ function ProjectImportWizardPage1::openPage(%this)
    }
 }
 
-//Select destination folder
+//==============================================================================
+// Set Source Folder
+//==============================================================================
 function ProjectImportWizardPage2::openPage(%this)
 {
    %version = ProjectImportWizardPage1-->previousContentVersionPopup.getSelected();
@@ -197,24 +224,21 @@ function ProjectImportWizardPage2::openPage(%this)
       
    $ProjectImporter::importTool = $ProjectImporter::importerList.getValue(%version);
    
-   //if(isObject($ProjectImporter::SFXDescriptionCache))
-   //   $ProjectImporter::SFXDescriptionCache.delete();
-      
-   //$ProjectImporter::SFXDescriptionCache = new ArrayObject();
-   
-   //if(isObject($ProjectImporter::ToRemoveObjectList))
-   //   $ProjectImporter::ToRemoveObjectList.delete();
-      
-   //$ProjectImporter::ToRemoveObjectList = new ArrayObject();
-   
    $ProjectImporter::importTool.setupPages(); //Have the importer register it's pages
    
    //And then add our final page 
    $ProjectImporter::importerPageList.add(ProjectImportWizardFinalPage);
 }
 
+//==============================================================================
+// Prepwork for import and getting the target module name
+//==============================================================================
 function ProjectImportWizardPage3::openPage(%this)
 {
+   projectImporterLog("===========================================");
+   projectImporterLog("Beginning Project Import");
+   projectImporterLog("===========================================");
+   
    %dataFullPath = makeFullPath("data/");
    %coreFullPath = makeFullPath("core/");
    %toolsFullPath = makeFullPath("tools/");
@@ -251,67 +275,108 @@ function ProjectImportWizardPage3::openPage(%this)
       
       ProjectImportWizardPage3-->newModuleName.setText($ProjectImporter::moduleName);
    }
-   /*if(ProjectImportWizardPage2-->internalFolderBtn.isStateOn())
-   {
-      $ProjectImporter::importMode = "InternalFolder";
-   }
-   else if(ProjectImportWizardPage2-->externalFolderBtn.isStateOn())
-   {
-      $ProjectImporter::importMode = "ExternalFolder";
-   }
-   else if(ProjectImportWizardPage2-->coreAndToolsBtn.isStateOn())
-   {
-      $ProjectImporter::importMode = "CoreAndTools";
-   }
-   else
-   {
-      ProjectImportWindow.previousStep();
-      toolsMessageBoxOK("Folder Type Required", "You must indicate if the folder is an internal or external folder.");
-      return;
-   }
-   
-   if($ProjectImporter::sourceContentFolder $= "" && $ProjectImporter::importMode !$= "CoreAndTools")
-   {
-      ProjectImportWindow.previousStep();
-      toolsMessageBoxOK("Source Folder Required", "You must select the original folder to import files from.");
-      return;
-   }
-      
-   if($ProjectImporter::importMode $= "InternalFolder")
-   {
-      %moduleDef = AssetBrowser.dirHandler.getModuleFromAddress(makeRelativePath($ProjectImporter::sourceContentFolder));
-      if(isObject(%moduleDef))
-      {
-         //already a valid module in place so just skip this step  
-         $ProjectImporter::useExistingModule = true;
-         $ProjectImporter::moduleName = %moduleDef.moduleId;
-         $ProjectImporter::modulePath = "data/" @ $ProjectImporter::moduleName;
-         ProjectImportWindow.setStep(4);
-      }
-   }
-   else if($ProjectImporter::importMode $= "ExternalFolder")
-   {
-      %slashCount = getTokenCount($ProjectImporter::sourceContentFolder, "/");
-      %topFolder = getToken($ProjectImporter::sourceContentFolder, "/", %slashCount-1);
-      if(%topFolder $= "")
-         %topFolder = getToken($ProjectImporter::sourceContentFolder, "/", %slashCount-2);
-         
-      //clean up invalid characters and stuff
-      %topFolder = sanitizeString(%topFolder);
-     
-      $ProjectImporter::useExistingModule = false;
-      $ProjectImporter::moduleName = %topFolder; //preseed the module name
-      $ProjectImporter::modulePath = "data/" @ $ProjectImporter::moduleName;
-      
-      ProjectImportWizardPage3-->newModuleName.setText($ProjectImporter::moduleName);
-   }
-   else if($ProjectImporter::importMode $= "CoreAndTools")
-   {
-      ProjectImportWindow.setStep(5);
-   }*/
 }
 
-//
+//==============================================================================
+// Run the preprocessing of all incoming files
+//==============================================================================
+function ProjectImportWizardPage4::openPage(%this)
+{
+   ProjectImportWindow-->preprocessCompleteText.setHidden(true);
+   
+   Canvas.repaint();
+   
+   ProjectImportWindow-->backButton.setHidden(true);
+   ProjectImportWindow-->nextButton.setActive(false);
+      
+   if(!$ProjectImporter::useExistingModule)
+      $ProjectImporter::moduleName = ProjectImportWizardPage3-->newModuleName.getText();
+      
+   $ProjectImporter::modulePath = "data/" @ $ProjectImporter::moduleName;
+      
+   if(!$ProjectImporter::useExistingModule)
+      $ProjectImporter::importTool.setupModule();
+      
+   //Do some sanity checking here to sidestep the copy if we're already in-place
+   %sourcePath = $ProjectImporter::sourceContentFolder;
+   %targetPath = makeFullPath($ProjectImporter::modulePath);
+   
+   preprocessImportingFiles();
+      
+   //if we gen'd a new module setup, double check we didn't copy over a module script file under a legacy extension
+   /*if(!$ProjectImporter::useExistingModule)
+   {
+      %newModuleName = $ProjectImporter::moduleName;
+      %moduleFilePath = "data/" @ %newModuleName;
+      
+      if($TorqueScriptFileExtension !$= "cs")
+   {
+         %moduleScriptFilePath = %moduleFilePath @ "/" @ %newModuleName @ ".cs";
+         if(isFile(%moduleScriptFilePath))
+   {
+            //yep, that exists, so we'll assume it was the file we wanted, so remove the generated one
+            fileDelete(%moduleFilePath @ "/" @ %newModuleName @ "." @ $TorqueScriptFileExtension);
+   }
+   }
+   }*/
+   
+   ProjectImportWindow-->nextButton.setActive(true);
+   ProjectImportWindow-->preprocessCompleteText.setHidden(false);
+   
+   Canvas.repaint();
+}
+
+//==============================================================================
+// Write out the logs and clean up
+//==============================================================================
+function ProjectImportWizardFinalPage::openPage(%this)
+{
+   projectImporterLog("===========================================");
+   projectImporterLog("Finished Project Import");
+   projectImporterLog("===========================================");
+   
+   //writing console log
+   %logFileObj = new FileObject();
+   
+   %logFileName = "tools/logs/LegacyProjectImport_" @ getTimestamp() @ ".log";
+      
+   if(%logFileObj.openForWrite(%logFileName))
+   {
+      for(%i=0; %i < $ProjectImporter::log.count(); %i++)
+      {
+         %logFileObj.writeLine($ProjectImporter::log.getKey(%i));
+      }
+      
+      %logFileObj.close();
+   }
+         
+   %logFileObj.delete();
+   
+   $ProjectImporter::assetQuery.delete();
+   $ProjectImporter::importer.delete();
+   $ProjectImporter::persistMgr.delete();
+     
+   AssetBrowser.refresh(); //update the AB just in case
+}
+      
+//==============================================================================
+// Registers a version importer's page for display in the wizard
+//==============================================================================
+function ProjectImportWindow::addImporterPage(%this, %page)
+{
+   ProejctImportPageContainer.add(%page);
+   $ProjectImporter::importerPageList.add(%page);
+}
+
+//==============================================================================
+// Utility functions needed for processing and importing files. These are common
+// functions that'll pretty much be used regardless of version being targeted
+//==============================================================================
+//==============================================================================
+// Runs through the files in the source directory and preprocessing them.
+// All valid files are added to a list, and script-based files are pre-parsed 
+// so the importer can easily process their contents later
+//==============================================================================
 function preprocessImportingFiles()
 {
    //========================================================
@@ -667,173 +732,11 @@ function preprocessImportingFiles()
       $ProjectImporter::fileObject.close();
    }
 }
-//
-
-function ProjectImportWizardPage4::openPage(%this)
-{
-   ProjectImportWindow-->preprocessCompleteText.setHidden(true);
-   
-   Canvas.repaint();
-   
-   ProjectImportWindow-->backButton.setHidden(true);
-   ProjectImportWindow-->nextButton.setActive(false);
-      
-   if(!$ProjectImporter::useExistingModule)
-      $ProjectImporter::moduleName = ProjectImportWizardPage3-->newModuleName.getText();
-      
-   $ProjectImporter::modulePath = "data/" @ $ProjectImporter::moduleName;
-      
-   if(!$ProjectImporter::useExistingModule)
-      $ProjectImporter::importTool.setupModule();
-      
-   //Do some sanity checking here to sidestep the copy if we're already in-place
-   %sourcePath = $ProjectImporter::sourceContentFolder;
-   %targetPath = makeFullPath($ProjectImporter::modulePath);
-   
-   preprocessImportingFiles();
-      
-   //if we gen'd a new module setup, double check we didn't copy over a module script file under a legacy extension
-   /*if(!$ProjectImporter::useExistingModule)
-   {
-      %newModuleName = $ProjectImporter::moduleName;
-      %moduleFilePath = "data/" @ %newModuleName;
-      
-      if($TorqueScriptFileExtension !$= "cs")
-      {
-         %moduleScriptFilePath = %moduleFilePath @ "/" @ %newModuleName @ ".cs";
-         if(isFile(%moduleScriptFilePath))
-         {
-            //yep, that exists, so we'll assume it was the file we wanted, so remove the generated one
-            fileDelete(%moduleFilePath @ "/" @ %newModuleName @ "." @ $TorqueScriptFileExtension);
-         }
-      }
-   }*/
-
-   ProjectImportWindow-->nextButton.setActive(true);
-   ProjectImportWindow-->preprocessCompleteText.setHidden(false);
-   
-   Canvas.repaint();
-}
-
-function ProjectImportWizardPage5::openPage(%this)
-{
-   ProjectImportWindow-->nextButton.setActive(false);
-   Canvas.repaint();
-   
-   $ProjectImporter::importTool.processImportedFiles();
-}
-
-function ProjectImportWizardPage6::openPage(%this)
-{
-   ProjectImportWindow-->nextButton.setActive(false);
-   Canvas.repaint();
-   
-   if($ProjectImporter::importMode $= "CoreAndTools")
-   {
-      $ProjectImporter::modulePath = "Core";
-      $ProjectImporter::importTool.processScriptExtensions();
-      
-      $ProjectImporter::modulePath = "Tools";
-      $ProjectImporter::importTool.processScriptExtensions();
-   }
-   else
-   {
-      $ProjectImporter::importTool.processScriptExtensions();
-   }
-   
-   //All good? now go through and wipe any objects flagged in our files for deletion
-   %objRemovePM = new PersistenceManager();
-   
-   for(%o = 0; %o < $ProjectImporter::ToRemoveObjectList.count(); %o++)
-   {
-      %name = $ProjectImporter::ToRemoveObjectList.getKey(%o);
-      %file = getField($ProjectImporter::ToRemoveObjectList.getValue(%o),0);
-      
-      if(%name !$= "" && isFile(%file))
-      {
-         if(!isObject(%name))
-         {
-            //spoof it
-            %tmpObj = new SimObject(%name); 
-            %objRemovePM.setDirty(%name, %file);
-         }
-         %objRemovePM.removeObjectFromFile(%name, %file);
-         
-         %tmpObj.delete();
-      }      
-   }
-}
-
-function ProjectImportWizardFinalPage::openPage(%this)
-{
-   //writing console log
-   %logFileObj = new FileObject();
-   
-   %logFileName = "tools/logs/LegacyProjectImport_" @ getTimestamp() @ ".log";
-   
-   if(%logFileObj.openForWrite(%logFileName))
-   {
-      for(%i=0; %i < $ProjectImporter::log.count(); %i++)
-      {
-         %logFileObj.writeLine($ProjectImporter::log.getKey(%i));
-      }
-      
-      %logFileObj.close();
-   }
-   
-   %logFileObj.delete();
-}
-
-//
-function ProjectImportWindow::addImporterPage(%this, %page)
-{
-   ProejctImportPageContainer.add(%page);
-   $ProjectImporter::importerPageList.add(%page);
-}
-//
-
-function beginProjectImport()
-{
-   projectImporterLog("===========================================");
-   projectImporterLog("Beginning Project Import");
-   projectImporterLog("===========================================");
-   
-   $ProjectImporter::assetQuery = new AssetQuery();
-   $ProjectImporter::importer = new AssetImporter();
-   $ProjectImporter::importer.dumpLogs = false; //we handle the log dump outselves here
-   $ProjectImporter::persistMgr = new PersistenceManager();
-   
-   //beginMaterialImport();
-   
-   //beginTerrainMaterialImport();
-   
-   //beginShapeImport();
-   
-   beginImageImport();
-   
-   beginDatablockImport();
-   
-   beginGUIImport();
-   
-   beginTerrainImport();
-   
-   //postFX imports'll need to look up render target names and ensure assets for those exist
-   //otherwise they need to be generated
-   beginPostFXImport();
-   
-   beginMiscObjectImport();
-   
-   $ProjectImporter::assetQuery.delete();
-   $ProjectImporter::importer.delete();
-   $ProjectImporter::persistMgr.delete();
-   
-   projectImporterLog("===========================================");
-   projectImporterLog("Finished Project Import");
-   projectImporterLog("===========================================");
-   
-   AssetBrowser.refresh(); //update the AB just in case
-}
+   
 
+//==============================================================================
+// Sanitized a filename so that it doesn't contain any invalid formatting/characters
+//==============================================================================
 function sanitizeFilename(%file)
 {
    if(startsWith(%file, "./"))
@@ -919,6 +822,9 @@ function sanitizeFilename(%file)
    //}
 }
 
+//==============================================================================
+// Checks if the file in question is part of our pre-scanned list of importing files
+//==============================================================================
 function isImportingFile(%checkFile)
 {
    for(%i=0; %i < $ProjectImporter::FileList.count(); %i++)
@@ -932,6 +838,10 @@ function isImportingFile(%checkFile)
    return false;
 }
 
+//==============================================================================
+// Takes a filename lacking an extension and then checks common file extensions
+// to see if we can find the actual file in question
+//==============================================================================
 function testFilenameExtensions(%filename)
 {
    %ext = fileExt(%filename);  
@@ -966,6 +876,9 @@ function testFilenameExtensions(%filename)
    return %filename;
 }
 
+//==============================================================================
+// Parses a line from a script to replace the original field name with the new one
+//==============================================================================
 function processLegacyField(%line, %originalFieldName, %newFieldName)
 { 
    if(!strIsMatchExpr("*"@%originalFieldName@"=*;*", %line) && 
@@ -1078,6 +991,9 @@ function processLegacyField(%line, %originalFieldName, %newFieldName)
    }
 }
 
+//==============================================================================
+// Parses a line from a shape constructor file to asset-ify addSequence() calls
+//==============================================================================
 function processLegacyShapeConstructorField(%line)
 {
    if(!strIsMatchExpr("*%this.addSequence(\"*);", %line))
@@ -1129,6 +1045,9 @@ function processLegacyShapeConstructorField(%line)
    }
 }
 
+//==============================================================================
+// Replaces the name of the object in the declaration line
+//==============================================================================
 function renameObjectName(%object, %newName)
 {
    for(%e=0; %e < %object.count(); %e++)
@@ -1153,6 +1072,9 @@ function renameObjectName(%object, %newName)
    }
 }
 
+//==============================================================================
+// Find the value of an object's field
+//==============================================================================
 function findObjectField(%object, %fieldName)
 {
    %return = "";
@@ -1213,6 +1135,9 @@ function findObjectField(%object, %fieldName)
    return %return;
 }
 
+//==============================================================================
+// Sets the value of an object's field
+//==============================================================================
 function setObjectField(%object, %fieldName, %newValue)
 {
    for(%e=0; %e < %object.count(); %e++)
@@ -1278,6 +1203,10 @@ function setObjectField(%object, %fieldName, %newValue)
    }
 }
 
+//==============================================================================
+// Takes a string and adds it to the importer's log. Optionally can print the line
+// directly to console for debugging purposes
+//==============================================================================
 function projectImporterLog(%line)
 {
    if($ProjectImporter::writeToConsole)
@@ -1701,12 +1630,6 @@ function processGUIntoAsset(%guiName, %file)
 }
 //==============================================================================
 
-//==============================================================================
-//Misc Object Type Converion
-//==============================================================================
-
-//==============================================================================
-
 //==============================================================================
 //PostFX conversion
 //==============================================================================
@@ -1885,6 +1808,10 @@ function beginLevelImport()
 }
 //==============================================================================
 
+//==============================================================================
+// Cleas out existing *.asset.taml files from a target. Only really used for
+// testing purposes currently.
+//==============================================================================
 function deleteAssetDefinitions()
 {
    %dlg = new OpenFolderDialog()
@@ -1954,6 +1881,10 @@ function doDeleteAssetDefinitions()
    projectImporterLog("===========================================");
 }
 
+//==============================================================================
+// Tests a file in the game dir to see if there's a possible duplicate file that
+// may cause an asset collision
+//==============================================================================
 function scanForDuplicateFiles(%toTestFile)
 {
    projectImporterLog("===========================================");
@@ -2012,6 +1943,10 @@ function scanForDuplicateFiles(%toTestFile)
    }
 }
 
+//==============================================================================
+// Pulls the logs from the asset importer and adds it to the project importer's 
+// logs
+//==============================================================================
 function getImporterLogs()
 {
    %lineCount = $ProjectImporter::importer.getActivityLogLineCount();

From ed13bdfdd297f34305de58d0e1b64e0bb4c3a1b5 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Fri, 21 Jan 2022 16:01:44 -0600
Subject: [PATCH 299/399] Changes the -> syntax check from exclusively checking
 simgroups to checking simsets, allowing both to be used

---
 Engine/source/console/compiledEval.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Engine/source/console/compiledEval.cpp b/Engine/source/console/compiledEval.cpp
index c439f57bf..3a6aa76e5 100644
--- a/Engine/source/console/compiledEval.cpp
+++ b/Engine/source/console/compiledEval.cpp
@@ -1620,17 +1620,17 @@ ConsoleValue CodeBlock::exec(U32 ip, const char* functionName, Namespace* thisNa
          ++ip; // To skip the recurse flag if the object wasnt found
          if (curObject)
          {
-            SimGroup* group = dynamic_cast<SimGroup*>(curObject);
-            if (group)
+            SimSet* set = dynamic_cast<SimSet*>(curObject);
+            if (set)
             {
                StringTableEntry intName = StringTable->insert(stack[_STK].getString());
                bool recurse = code[ip - 1];
-               SimObject* obj = group->findObjectByInternalName(intName, recurse);
+               SimObject* obj = set->findObjectByInternalName(intName, recurse);
                stack[_STK].setInt(obj ? obj->getId() : 0);
             }
             else
             {
-               Con::errorf(ConsoleLogEntry::Script, "%s: Attempt to use -> on non-group %s of class %s.", getFileLine(ip - 2), curObject->getName(), curObject->getClassName());
+               Con::errorf(ConsoleLogEntry::Script, "%s: Attempt to use -> on non-set %s of class %s.", getFileLine(ip - 2), curObject->getName(), curObject->getClassName());
                stack[_STK].setInt(0);
             }
          }

From bed3be278c5d6395e34fb15b81b38a71bf25cc7e Mon Sep 17 00:00:00 2001
From: OTHGMars <mmars1149@aol.com>
Date: Fri, 21 Jan 2022 19:47:41 -0500
Subject: [PATCH 300/399] GuiBitmapCtrl named texture fixes. Adds
 StringTableEntry when bitmap is set via setBitmapHandle. Prevents existing
 bitmap handles from being dropped in onWake (they are preserved in onSleep).

---
 Engine/source/gui/controls/guiBitmapCtrl.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/Engine/source/gui/controls/guiBitmapCtrl.cpp b/Engine/source/gui/controls/guiBitmapCtrl.cpp
index 82a106bcf..499311831 100644
--- a/Engine/source/gui/controls/guiBitmapCtrl.cpp
+++ b/Engine/source/gui/controls/guiBitmapCtrl.cpp
@@ -98,7 +98,8 @@ bool GuiBitmapCtrl::onWake()
       return false;
    setActive(true);
 
-   setBitmap(getBitmap());
+   if (mBitmapName != StringTable->insert("texhandle"))
+      setBitmap(getBitmap());
    return true;
 }
 
@@ -152,7 +153,7 @@ void GuiBitmapCtrl::setBitmapHandle(GFXTexHandle handle, bool resize)
 {
    mBitmap = handle;
 
-   mBitmapName = String("texhandle");
+   mBitmapName = StringTable->insert("texhandle");
 
    // Resize the control to fit the bitmap
    if (resize) 

From eeff4d858a27e048eba6d3f6314f0aeafaa660d7 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Sat, 22 Jan 2022 03:27:22 -0600
Subject: [PATCH 301/399] clean up ambiguous reference

---
 Engine/source/T3D/assets/assetImporter.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Engine/source/T3D/assets/assetImporter.cpp b/Engine/source/T3D/assets/assetImporter.cpp
index 7bb109f02..de603d1fc 100644
--- a/Engine/source/T3D/assets/assetImporter.cpp
+++ b/Engine/source/T3D/assets/assetImporter.cpp
@@ -2100,7 +2100,7 @@ void AssetImporter::processShapeMaterialInfo(AssetImportObject* assetItem, S32 m
                if (imgFileName.isNotEmpty())
                   filePath = imgFileName;
                else
-                  filePath = ""; //no luck, so we just won't try importing in the image
+                  filePath = Torque::Path(""); //no luck, so we just won't try importing in the image
             }
          }
  

From 630285def638f98538925f30c8aaa7fca811621c Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Sun, 30 Jan 2022 11:50:16 -0600
Subject: [PATCH 302/399] Shifts handling of material and terrain material
 definitions to be written into the asset definition taml file instead of
 having an extra loose file Also updates importers to correctly handle this
 change Adds ability for taml XML serialization to properly assign array'd
 fields Adds 'inheritFrom' field to simobjects for when objects with parent
 objects are serialized AssetBase how inherits from SimGroup so it can have
 objects like material definitions embedded in them for save/load in the taml
 definition file Updated loading/handling logic in terrain material asset to
 be more similar to regular material assets

---
 Engine/source/T3D/assets/ImageAsset.cpp       |   4 +-
 Engine/source/T3D/assets/MaterialAsset.cpp    |  70 +++-
 Engine/source/T3D/assets/MaterialAsset.h      |   4 +
 .../T3D/assets/TerrainMaterialAsset.cpp       | 322 ++++++++++++++++--
 .../source/T3D/assets/TerrainMaterialAsset.h  |  53 ++-
 Engine/source/T3D/assets/assetImporter.cpp    | 206 +++--------
 Engine/source/assets/assetBase.h              |   4 +-
 Engine/source/assets/assetDefinition.h        |   4 +-
 Engine/source/console/simObject.cpp           |  51 ++-
 Engine/source/console/simObject.h             |   5 +
 .../source/materials/materialDefinition.cpp   |   3 +-
 .../persistence/taml/xml/tamlXmlReader.cpp    |  18 +-
 .../tools/assetBrowser/assetImportConfigs.xml |   3 +-
 .../assetBrowser/scripts/assetBrowser.tscript |   1 -
 .../scripts/assetTypes/material.tscript       |   8 +-
 .../assetTypes/terrainMaterial.tscript        |  58 ++--
 .../scripts/materialEditor.ed.tscript         |  18 +-
 .../pre40/T3Dpre4ProjectImporter.tscript      | 166 ++++++---
 .../scripts/projectImporter.tscript           |  87 ++++-
 .../interfaces/terrainMaterialDlg.ed.tscript  |  24 +-
 20 files changed, 791 insertions(+), 318 deletions(-)

diff --git a/Engine/source/T3D/assets/ImageAsset.cpp b/Engine/source/T3D/assets/ImageAsset.cpp
index 2c5f9f341..d49cfbf85 100644
--- a/Engine/source/T3D/assets/ImageAsset.cpp
+++ b/Engine/source/T3D/assets/ImageAsset.cpp
@@ -58,7 +58,7 @@ StringTableEntry ImageAsset::smNoImageAssetFallback = NULL;
 
 IMPLEMENT_CONOBJECT(ImageAsset);
 
-ConsoleType(ImageAssetPtr, TypeImageAssetPtr, const char*, ASSET_ID_FIELD_PREFIX)
+ConsoleType(ImageAssetPtr, TypeImageAssetPtr, const char*, "")
 
 //-----------------------------------------------------------------------------
 
@@ -85,7 +85,7 @@ ConsoleSetType(TypeImageAssetPtr)
    Con::warnf("(TypeImageAssetPtr) - Cannot set multiple args to a single asset.");
 }
 
-ConsoleType(assetIdString, TypeImageAssetId, const char*, ASSET_ID_FIELD_PREFIX)
+ConsoleType(assetIdString, TypeImageAssetId, const char*, "")
 
 ConsoleGetType(TypeImageAssetId)
 {
diff --git a/Engine/source/T3D/assets/MaterialAsset.cpp b/Engine/source/T3D/assets/MaterialAsset.cpp
index f2197cf01..6eb4ea200 100644
--- a/Engine/source/T3D/assets/MaterialAsset.cpp
+++ b/Engine/source/T3D/assets/MaterialAsset.cpp
@@ -154,8 +154,9 @@ void MaterialAsset::initPersistFields()
    Parent::initPersistFields();
 
    //addField("shaderGraph", TypeRealString, Offset(mShaderGraphFile, MaterialAsset), "");
-   addProtectedField("scriptFile", TypeAssetLooseFilePath, Offset(mScriptFile, MaterialAsset),
-      &setScriptFile, &getScriptFile, "Path to the file containing the material definition.");
+   //addProtectedField("scriptFile", TypeAssetLooseFilePath, Offset(mScriptFile, MaterialAsset),
+   //   &setScriptFile, &getScriptFile, "Path to the file containing the material definition.");
+   addField("scriptFile", TypeAssetLooseFilePath, Offset(mScriptFile, MaterialAsset), "");
 
    addField("materialDefinitionName", TypeString, Offset(mMatDefinitionName, MaterialAsset), "Name of the material definition this asset is for.");
 }
@@ -173,7 +174,16 @@ void MaterialAsset::initializeAsset()
       return;
    }
 
-   if (Torque::FS::IsScriptFile(mScriptPath))
+   if (mMatDefinitionName == StringTable->insert("DetailBlue"))
+   {
+      bool asdfsd = true;
+   }
+
+   if (size() != 0 && mScriptPath == StringTable->EmptyString())
+   {
+      mLoadedState = EmbeddedDefinition;
+   }
+   else if (Torque::FS::IsScriptFile(mScriptPath))
    {
       if (!Sim::findObject(mMatDefinitionName))
       {
@@ -230,7 +240,6 @@ void MaterialAsset::setScriptFile(const char* pScriptFile)
    // Sanity!
    AssertFatal(pScriptFile != NULL, "Cannot use a NULL script file.");
 
-   // Fetch image file.
    pScriptFile = StringTable->insert(pScriptFile, true);
 
    // Update.
@@ -245,9 +254,28 @@ void MaterialAsset::setScriptFile(const char* pScriptFile)
 void MaterialAsset::loadMaterial()
 {
    if (mMaterialDefinition)
-      SAFE_DELETE(mMaterialDefinition);
+   {
+      mMaterialDefinition->safeDeleteObject();
+   }
 
-   if ((mLoadedState == ScriptLoaded || mLoadedState == DefinitionAlreadyExists) && mMatDefinitionName != StringTable->EmptyString())
+   if (mLoadedState == EmbeddedDefinition)
+   {
+      if (size() != 0)
+      {
+         for (U32 i = 0; i < size(); i++)
+         {
+            mMaterialDefinition = dynamic_cast<Material*>(getObject(i));
+            if (mMaterialDefinition)
+            {
+               mLoadedState = Ok;
+               mMaterialDefinition->setInternalName(getAssetId());
+               mMaterialDefinition->reload();
+               return;
+            }
+         }
+      }
+   }
+   else if ((mLoadedState == ScriptLoaded || mLoadedState == DefinitionAlreadyExists) && mMatDefinitionName != StringTable->EmptyString())
    {
       Material* matDef;
       if (!Sim::findObject(mMatDefinitionName, matDef))
@@ -260,7 +288,7 @@ void MaterialAsset::loadMaterial()
       mMaterialDefinition = matDef;
 
       mLoadedState = Ok;
-
+      mMaterialDefinition->setInternalName(getAssetId());
       mMaterialDefinition->reload();
       return;
    }
@@ -296,11 +324,11 @@ U32 MaterialAsset::getAssetByMaterialName(StringTableEntry matName, AssetPtr<Mat
       //handle noshape not being loaded itself
       if ((*matAsset)->mLoadedState == BadFileReference)
       {
-         Con::warnf("ShapeAsset::getAssetByMaterialName - Finding of associated with aterial name %s failed, and fallback asset reported error of Bad File Reference.", matName);
+         Con::warnf("MaterialAsset::getAssetByMaterialName - Finding of associated with aterial name %s failed, and fallback asset reported error of Bad File Reference.", matName);
          return AssetErrCode::BadFileReference;
       }
 
-      Con::warnf("ShapeAsset::getAssetByMaterialName - Finding of associated with aterial name %s failed, utilizing fallback asset", matName);
+      Con::warnf("MaterialAsset::getAssetByMaterialName - Finding of associated with aterial name %s failed, utilizing fallback asset", matName);
 
       (*matAsset)->mLoadedState = AssetErrCode::UsingFallback;
       return AssetErrCode::UsingFallback;
@@ -388,6 +416,17 @@ U32 MaterialAsset::getAssetById(StringTableEntry assetId, AssetPtr<MaterialAsset
    }
 }
 
+SimObjectPtr<Material> MaterialAsset::findMaterialDefinitionByAssetId(StringTableEntry assetId)
+{
+   SimSet* matSet = MATMGR->getMaterialSet();
+   if (matSet)
+   {
+      SimObjectPtr<Material> matDef = dynamic_cast<Material*>(matSet->findObjectByInternalName(assetId));
+      return matDef;
+   }
+   return nullptr;
+}
+
 #ifdef TORQUE_TOOLS
 DefineEngineStaticMethod(MaterialAsset, getAssetIdByMaterialName, const char*, (const char* materialName), (""),
    "Queries the Asset Database to see if any asset exists that is associated with the provided material name.\n"
@@ -396,6 +435,19 @@ DefineEngineStaticMethod(MaterialAsset, getAssetIdByMaterialName, const char*, (
    return MaterialAsset::getAssetIdByMaterialName(StringTable->insert(materialName));
 }
 
+//MaterialAsset::findMaterialDefinitionByAssetId("Prototyping:Detail")
+DefineEngineStaticMethod(MaterialAsset, findMaterialDefinitionByAssetId, S32, (const char* assetId), (""),
+   "Queries the MaterialSet to see if any MaterialDefinition exists that is associated to the provided assetId.\n"
+   "@return The MaterialDefinition Id associated to the assetId, if any")
+{
+   SimObjectPtr<Material> matDef = MaterialAsset::findMaterialDefinitionByAssetId(StringTable->insert(assetId));
+   if (matDef.isNull())
+      return SimObjectId(0);
+   else
+      return matDef->getId();
+}
+
+
 DefineEngineMethod(MaterialAsset, getScriptPath, const char*, (), ,
    "Queries the Asset Database to see if any asset exists that is associated with the provided material name.\n"
    "@return The AssetId of the associated asset, if any.")
diff --git a/Engine/source/T3D/assets/MaterialAsset.h b/Engine/source/T3D/assets/MaterialAsset.h
index a6dff23c8..561f02fe5 100644
--- a/Engine/source/T3D/assets/MaterialAsset.h
+++ b/Engine/source/T3D/assets/MaterialAsset.h
@@ -48,7 +48,9 @@
 #include "sim/netConnection.h"
 #endif
 
+#ifndef _GUI_INSPECTOR_TYPES_H_
 #include "gui/editor/guiInspectorTypes.h"
+#endif
 
 #include "materials/matTextureTarget.h"
 #include "materials/materialDefinition.h"
@@ -75,6 +77,7 @@ public:
    {
       ScriptLoaded = AssetErrCode::Extended,
       DefinitionAlreadyExists,
+      EmbeddedDefinition,
       Extended
    };
 
@@ -108,6 +111,7 @@ public:
    /// <returns>AssetId of matching asset.</returns>
    static StringTableEntry getAssetIdByMaterialName(StringTableEntry matName);
    static U32 getAssetById(StringTableEntry assetId, AssetPtr<MaterialAsset>* materialAsset);
+   static SimObjectPtr<Material> findMaterialDefinitionByAssetId(StringTableEntry assetId);
    static U32 getAssetByMaterialName(StringTableEntry matName, AssetPtr<MaterialAsset>* matAsset);
 
    /// Declare Console Object.
diff --git a/Engine/source/T3D/assets/TerrainMaterialAsset.cpp b/Engine/source/T3D/assets/TerrainMaterialAsset.cpp
index ee5a36004..3ef54d856 100644
--- a/Engine/source/T3D/assets/TerrainMaterialAsset.cpp
+++ b/Engine/source/T3D/assets/TerrainMaterialAsset.cpp
@@ -40,6 +40,10 @@
 #include "assets/assetPtr.h"
 #endif
 
+#include "T3D/assets/assetImporter.h"
+
+StringTableEntry TerrainMaterialAsset::smNoTerrainMaterialAssetFallback = NULL;
+
 //-----------------------------------------------------------------------------
 
 IMPLEMENT_CONOBJECT(TerrainMaterialAsset);
@@ -85,6 +89,35 @@ ConsoleSetType(TypeTerrainMaterialAssetPtr)
    Con::warnf("(TypeTerrainMaterialAssetPtr) - Cannot set multiple args to a single asset.");
 }
 
+
+ConsoleType(assetIdString, TypeTerrainMaterialAssetId, const char*, ASSET_ID_FIELD_PREFIX)
+
+ConsoleGetType(TypeTerrainMaterialAssetId)
+{
+   // Fetch asset Id.
+   return *((const char**)(dptr));
+}
+
+ConsoleSetType(TypeTerrainMaterialAssetId)
+{
+   // Was a single argument specified?
+   if (argc == 1)
+   {
+      // Yes, so fetch field value.
+      const char* pFieldValue = argv[0];
+
+      // Fetch asset Id.
+      StringTableEntry* assetId = (StringTableEntry*)(dptr);
+
+      // Update asset value.
+      *assetId = StringTable->insert(pFieldValue);
+
+      return;
+   }
+
+   // Warn.
+   Con::warnf("(TypeTerrainMaterialAssetId) - Cannot set multiple args to a single asset.");
+}
 //-----------------------------------------------------------------------------
 
 TerrainMaterialAsset::TerrainMaterialAsset()
@@ -92,24 +125,41 @@ TerrainMaterialAsset::TerrainMaterialAsset()
    mScriptFile = StringTable->EmptyString();
    mScriptPath = StringTable->EmptyString();
    mMatDefinitionName = StringTable->EmptyString();
+   mMaterialDefinition = nullptr;
+   mFXMaterialDefinition = nullptr;
 }
 
 //-----------------------------------------------------------------------------
 
 TerrainMaterialAsset::~TerrainMaterialAsset()
 {
+   if (mMaterialDefinition)
+      mMaterialDefinition->safeDeleteObject();
+   if (mFXMaterialDefinition)
+      mFXMaterialDefinition->safeDeleteObject();
 }
 
 //-----------------------------------------------------------------------------
 
+void TerrainMaterialAsset::consoleInit()
+{
+   Parent::consoleInit();
+   Con::addVariable("$Core::NoTerrainMaterialAssetFallback", TypeString, &smNoTerrainMaterialAssetFallback,
+      "The assetId of the material to display when the requested material asset is missing.\n"
+      "@ingroup GFX\n");
+   
+   smNoTerrainMaterialAssetFallback = StringTable->insert(Con::getVariable("$Core::NoTerrainMaterialAssetFallback"));
+}
+
 void TerrainMaterialAsset::initPersistFields()
 {
    // Call parent.
    Parent::initPersistFields();
 
    //addField("shaderGraph", TypeRealString, Offset(mShaderGraphFile, TerrainMaterialAsset), "");
-   addProtectedField("scriptFile", TypeAssetLooseFilePath, Offset(mScriptFile, TerrainMaterialAsset),
-      &setScriptFile, &getScriptFile, "Path to the file containing the material definition.");
+   //addProtectedField("scriptFile", TypeAssetLooseFilePath, Offset(mScriptFile, TerrainMaterialAsset),
+   //   &setScriptFile, &getScriptFile, "Path to the file containing the material definition.");
+   addField("scriptFile", TypeAssetLooseFilePath, Offset(mScriptFile, TerrainMaterialAsset), "");
 
    addField("materialDefinitionName", TypeString, Offset(mMatDefinitionName, TerrainMaterialAsset), "Name of the material definition this asset is for.");
 }
@@ -121,28 +171,71 @@ void TerrainMaterialAsset::initializeAsset()
 
    mScriptPath = getOwned() ? expandAssetFilePath(mScriptFile) : mScriptPath;
 
-   if (Torque::FS::IsScriptFile(mScriptPath))
-      Con::executeFile(mScriptPath, false, false);
+   if (mMatDefinitionName == StringTable->EmptyString())
+   {
+      mLoadedState = Failed;
+      return;
+   }
+
+   if (mMatDefinitionName == StringTable->insert("DetailBlue"))
+   {
+      bool asdfsd = true;
+   }
+
+   if (size() != 0 && mScriptPath == StringTable->EmptyString())
+   {
+      mLoadedState = EmbeddedDefinition;
+   }
+   else if (Torque::FS::IsScriptFile(mScriptPath))
+   {
+      if (!Sim::findObject(mMatDefinitionName))
+      {
+          if (Con::executeFile(mScriptPath, false, false))
+          {
+              mLoadedState = ScriptLoaded;
+          }
+          else
+          {
+              mLoadedState = Failed;
+          }
+      }
+      else
+      {
+         mLoadedState = DefinitionAlreadyExists;
+      }
+   }
+
+   loadMaterial();
 }
 
 void TerrainMaterialAsset::onAssetRefresh()
 {
    mScriptPath = getOwned() ? expandAssetFilePath(mScriptFile) : mScriptPath;
 
-   if (Torque::FS::IsScriptFile(mScriptPath))
-      Con::executeFile(mScriptPath, false, false);
-
-   if (mMatDefinitionName != StringTable->EmptyString())
+   if (mMatDefinitionName == StringTable->EmptyString())
    {
-      TerrainMaterial* matDef;
-      if (!Sim::findObject(mMatDefinitionName, matDef))
-      {
-         Con::errorf("TerrainMaterialAsset: Unable to find the Material %s", mMatDefinitionName);
+      mLoadedState = Failed;
          return;
       }
 
-      //matDef->reload();
+   if (Torque::FS::IsScriptFile(mScriptPath))
+   {
+      //Since we're refreshing, we can assume that the file we're executing WILL have an existing definition.
+      //But that definition, whatever it is, is the 'correct' one, so we enable the Replace Existing behavior
+      //when the engine encounters a named object conflict.
+      String redefineBehaviorPrev = Con::getVariable("$Con::redefineBehavior");
+      Con::setVariable("$Con::redefineBehavior", "replaceExisting");
+
+      if (Con::executeFile(mScriptPath, false, false))
+         mLoadedState = ScriptLoaded;
+      else
+         mLoadedState = Failed;
+
+      //And now that we've executed, switch back to the prior behavior
+      Con::setVariable("$Con::redefineBehavior", redefineBehaviorPrev.c_str());
    }
+
+   loadMaterial();
 }
 
 void TerrainMaterialAsset::setScriptFile(const char* pScriptFile)
@@ -152,10 +245,6 @@ void TerrainMaterialAsset::setScriptFile(const char* pScriptFile)
 
    pScriptFile = StringTable->insert(pScriptFile, true);
 
-   // Ignore no change,
-   if (pScriptFile == mScriptFile)
-      return;
-
    // Update.
    mScriptFile = getOwned() ? expandAssetFilePath(pScriptFile) : pScriptFile;
 
@@ -165,41 +254,185 @@ void TerrainMaterialAsset::setScriptFile(const char* pScriptFile)
 
 //------------------------------------------------------------------------------
 
+void TerrainMaterialAsset::loadMaterial()
+{
+   if (mMaterialDefinition)
+      mMaterialDefinition->safeDeleteObject();
+   if (mFXMaterialDefinition)
+      mFXMaterialDefinition->safeDeleteObject();
+
+   if (mLoadedState == EmbeddedDefinition)
+   {
+      if (size() != 0)
+      {
+         for (U32 i = 0; i < size(); i++)
+         {
+            mMaterialDefinition = dynamic_cast<TerrainMaterial*>(getObject(i));
+            if (mMaterialDefinition)
+            {
+               mLoadedState = Ok;
+               mMaterialDefinition->setInternalName(getAssetId());
+               continue;
+            }
+
+            //Otherwise, check if it's our FX material
+            mFXMaterialDefinition = dynamic_cast<Material*>(getObject(i));
+            if (mFXMaterialDefinition)
+            {
+               //mMaterialDefinition->setInternalName(getAssetId());
+               mFXMaterialDefinition->reload();
+               continue;
+            }
+
+         }
+      }
+   }
+   else if ((mLoadedState == ScriptLoaded || mLoadedState == DefinitionAlreadyExists) && mMatDefinitionName != StringTable->EmptyString())
+   {
+      TerrainMaterial* matDef;
+      if (!Sim::findObject(mMatDefinitionName, matDef))
+      {
+         Con::errorf("TerrainMaterialAsset: Unable to find the Material %s", mMatDefinitionName);
+         mLoadedState = BadFileReference;
+         return;
+      }
+
+      mMaterialDefinition = matDef;
+
+      mLoadedState = Ok;
+      mMaterialDefinition->setInternalName(getAssetId());
+      return;
+   }
+
+   mLoadedState = Failed;
+}
+
+//------------------------------------------------------------------------------
+
 void TerrainMaterialAsset::copyTo(SimObject* object)
 {
    // Call to parent.
    Parent::copyTo(object);
 }
 
-StringTableEntry TerrainMaterialAsset::getAssetIdByMaterialName(StringTableEntry matName)
+//------------------------------------------------------------------------------
+U32 TerrainMaterialAsset::getAssetByMaterialName(StringTableEntry matName, AssetPtr<TerrainMaterialAsset>* matAsset)
 {
-   StringTableEntry materialAssetId = StringTable->EmptyString();
-
-   AssetQuery* query = new AssetQuery();
-   U32 foundCount = AssetDatabase.findAssetType(query, "TerrainMaterialAsset");
-   if (foundCount == 0)
+   AssetQuery query;
+   U32 foundAssetcount = AssetDatabase.findAssetType(&query, "TerrainMaterialAsset");
+   if (foundAssetcount == 0)
    {
       //Didn't work, so have us fall back to a placeholder asset
-      materialAssetId = StringTable->insert("Core_Rendering:noMaterial");
+      matAsset->setAssetId(TerrainMaterialAsset::smNoTerrainMaterialAssetFallback);
+
+      if (matAsset->isNull())
+      {
+         //Well that's bad, loading the fallback failed.
+         Con::warnf("TerrainMaterialAsset::getAssetByMaterialName - Finding of asset associated with material name %s failed with no fallback asset", matName);
+         return AssetErrCode::Failed;
+      }
+
+      //handle noshape not being loaded itself
+      if ((*matAsset)->mLoadedState == BadFileReference)
+      {
+         Con::warnf("TerrainMaterialAsset::getAssetByMaterialName - Finding of associated with aterial name %s failed, and fallback asset reported error of Bad File Reference.", matName);
+         return AssetErrCode::BadFileReference;
+      }
+
+      Con::warnf("TerrainMaterialAsset::getAssetByMaterialName - Finding of associated with aterial name %s failed, utilizing fallback asset", matName);
+
+      (*matAsset)->mLoadedState = AssetErrCode::UsingFallback;
+      return AssetErrCode::UsingFallback;
    }
    else
+   {
+      for (U32 i = 0; i < foundAssetcount; i++)
+      {
+         TerrainMaterialAsset* tMatAsset = AssetDatabase.acquireAsset<TerrainMaterialAsset>(query.mAssetList[i]);
+         if (tMatAsset && tMatAsset->getMaterialDefinitionName() == matName)
+         {
+            matAsset->setAssetId(query.mAssetList[i]);
+            AssetDatabase.releaseAsset(query.mAssetList[i]);
+            return (*matAsset)->mLoadedState;
+         }
+         AssetDatabase.releaseAsset(query.mAssetList[i]); //cleanup if that's not the one we needed
+      }
+   }
+
+   //Somehow we failed to bind an asset, so just use the fallback and mark the failure
+   matAsset->setAssetId(TerrainMaterialAsset::smNoTerrainMaterialAssetFallback);
+   (*matAsset)->mLoadedState = AssetErrCode::UsingFallback;
+   return AssetErrCode::UsingFallback;
+
+}
+
+StringTableEntry TerrainMaterialAsset::getAssetIdByMaterialName(StringTableEntry matName)
+{
+   if (matName == StringTable->EmptyString())
+      return StringTable->EmptyString();
+
+   StringTableEntry materialAssetId = TerrainMaterialAsset::smNoTerrainMaterialAssetFallback;
+
+   AssetQuery query;
+   U32 foundCount = AssetDatabase.findAssetType(&query, "TerrainMaterialAsset");
+   if (foundCount != 0)
    {
       for (U32 i = 0; i < foundCount; i++)
       {
-         TerrainMaterialAsset* matAsset = AssetDatabase.acquireAsset<TerrainMaterialAsset>(query->mAssetList[i]);
+         TerrainMaterialAsset* matAsset = AssetDatabase.acquireAsset<TerrainMaterialAsset>(query.mAssetList[i]);
          if (matAsset && matAsset->getMaterialDefinitionName() == matName)
          {
             materialAssetId = matAsset->getAssetId();
-            AssetDatabase.releaseAsset(query->mAssetList[i]);
+            AssetDatabase.releaseAsset(query.mAssetList[i]);
             break;
          }
-         AssetDatabase.releaseAsset(query->mAssetList[i]);
+         AssetDatabase.releaseAsset(query.mAssetList[i]);
       }
    }
 
    return materialAssetId;
 }
 
+U32 TerrainMaterialAsset::getAssetById(StringTableEntry assetId, AssetPtr<TerrainMaterialAsset>* materialAsset)
+{
+   (*materialAsset) = assetId;
+   if (materialAsset->notNull())
+   {
+      return (*materialAsset)->mLoadedState;
+   }
+   else
+   {
+      //Didn't work, so have us fall back to a placeholder asset
+      materialAsset->setAssetId(TerrainMaterialAsset::smNoTerrainMaterialAssetFallback);
+      if (materialAsset->isNull())
+      {
+         //Well that's bad, loading the fallback failed.
+         Con::warnf("TerrainMaterialAsset::getAssetById - Finding of asset with id %s failed with no fallback asset", assetId);
+         return AssetErrCode::Failed;
+      }
+      //handle noshape not being loaded itself
+      if ((*materialAsset)->mLoadedState == BadFileReference)
+      {
+         Con::warnf("TerrainMaterialAsset::getAssetById - Finding of asset with id %s failed, and fallback asset reported error of Bad File Reference.", assetId);
+         return AssetErrCode::BadFileReference;
+      }
+      Con::warnf("TerrainMaterialAsset::getAssetById - Finding of asset with id %s failed, utilizing fallback asset", assetId);
+      (*materialAsset)->mLoadedState = AssetErrCode::UsingFallback;
+      return AssetErrCode::UsingFallback;
+   }
+}
+SimObjectPtr<TerrainMaterial> TerrainMaterialAsset::findMaterialDefinitionByAssetId(StringTableEntry assetId)
+{
+   SimSet* terrainMatSet;
+   if (!Sim::findObject("TerrainMaterialSet", terrainMatSet))
+   {
+      return nullptr;
+   }
+
+   SimObjectPtr<TerrainMaterial> matDef = dynamic_cast<TerrainMaterial*>(terrainMatSet->findObjectByInternalName(assetId));
+   return matDef;
+}
+
 #ifdef TORQUE_TOOLS
 DefineEngineStaticMethod(TerrainMaterialAsset, getAssetIdByMaterialName, const char*, (const char* materialName), (""),
    "Queries the Asset Database to see if any asset exists that is associated with the provided material name.\n"
@@ -207,6 +440,26 @@ DefineEngineStaticMethod(TerrainMaterialAsset, getAssetIdByMaterialName, const c
 {
    return TerrainMaterialAsset::getAssetIdByMaterialName(StringTable->insert(materialName));
 }
+
+//MaterialAsset::findMaterialDefinitionByAssetId("Prototyping:Detail")
+DefineEngineStaticMethod(TerrainMaterialAsset, findMaterialDefinitionByAssetId, S32, (const char* assetId), (""),
+   "Queries the MaterialSet to see if any MaterialDefinition exists that is associated to the provided assetId.\n"
+   "@return The MaterialDefinition Id associated to the assetId, if any")
+{
+   SimObjectPtr<TerrainMaterial> matDef = TerrainMaterialAsset::findMaterialDefinitionByAssetId(StringTable->insert(assetId));
+   if (matDef.isNull())
+      return SimObjectId(0);
+   else
+      return matDef->getId();
+}
+
+
+DefineEngineMethod(TerrainMaterialAsset, getScriptPath, const char*, (), ,
+   "Queries the Asset Database to see if any asset exists that is associated with the provided material name.\n"
+   "@return The AssetId of the associated asset, if any.")
+{
+   return object->getScriptPath();
+}
 #endif
 //-----------------------------------------------------------------------------
 // GuiInspectorTypeAssetId
@@ -343,3 +596,18 @@ DefineEngineMethod(GuiInspectorTypeTerrainMaterialAssetPtr, setMaterialAsset, vo
 
    return object->setMaterialAsset(assetId);
 }
+
+IMPLEMENT_CONOBJECT(GuiInspectorTypeTerrainMaterialAssetId);
+
+ConsoleDocClass(GuiInspectorTypeTerrainMaterialAssetId,
+   "@brief Inspector field type for Terrain Material Assets\n\n"
+   "Editor use only.\n\n"
+   "@internal"
+);
+
+void GuiInspectorTypeTerrainMaterialAssetId::consoleInit()
+{
+   Parent::consoleInit();
+
+   ConsoleBaseType::getType(TypeTerrainMaterialAssetId)->setInspectorFieldType("GuiInspectorTypeTerrainMaterialAssetId");
+}
diff --git a/Engine/source/T3D/assets/TerrainMaterialAsset.h b/Engine/source/T3D/assets/TerrainMaterialAsset.h
index e0a60e391..dfa3c3ef1 100644
--- a/Engine/source/T3D/assets/TerrainMaterialAsset.h
+++ b/Engine/source/T3D/assets/TerrainMaterialAsset.h
@@ -47,7 +47,13 @@
 #include "gui/editor/guiInspectorTypes.h"
 #endif
 
+#ifndef _TERRMATERIAL_H_
 #include "terrain/terrMaterial.h"
+#endif
+
+#ifndef _MATERIALDEFINITION_H_
+#include "materials/materialDefinition.h"
+#endif
 
 //-----------------------------------------------------------------------------
 class TerrainMaterialAsset : public AssetBase
@@ -58,23 +64,53 @@ class TerrainMaterialAsset : public AssetBase
    StringTableEntry        mScriptPath;
    StringTableEntry        mMatDefinitionName;
 
+   SimObjectPtr<TerrainMaterial>  mMaterialDefinition;
+
+   SimObjectPtr<Material>  mFXMaterialDefinition;
+
+public:
+   static StringTableEntry smNoTerrainMaterialAssetFallback;
+   
+   enum TerrainMaterialAssetErrCode
+   {
+      ScriptLoaded = AssetErrCode::Extended,
+      DefinitionAlreadyExists,
+      EmbeddedDefinition,
+      Extended
+   };
+
 public:
    TerrainMaterialAsset();
    virtual ~TerrainMaterialAsset();
+   /// Set up some global script interface stuff.
+   static void consoleInit();
 
    /// Engine.
    static void initPersistFields();
    virtual void copyTo(SimObject* object);
 
-   static StringTableEntry getAssetIdByMaterialName(StringTableEntry matName);
+   void loadMaterial();
 
    StringTableEntry getMaterialDefinitionName() { return mMatDefinitionName; }
+   SimObjectPtr<TerrainMaterial> getMaterialDefinition() { return mMaterialDefinition; }
 
    void                    setScriptFile(const char* pScriptFile);
    inline StringTableEntry getScriptFile(void) const { return mScriptFile; };
 
    inline StringTableEntry getScriptPath(void) const { return mScriptPath; };
 
+   /// <summary>
+   /// Looks for any assets that uses the provided Material Definition name.
+   /// If none are found, attempts to auto-import the material definition if the
+   /// material definition exists.
+   /// </summary>
+   /// <param name="matName">Material Definition name to look for</param>
+   /// <returns>AssetId of matching asset.</returns>
+   static StringTableEntry getAssetIdByMaterialName(StringTableEntry matName);
+   static U32 getAssetById(StringTableEntry assetId, AssetPtr<TerrainMaterialAsset>* materialAsset);
+   static SimObjectPtr<TerrainMaterial> findMaterialDefinitionByAssetId(StringTableEntry assetId);
+   static U32 getAssetByMaterialName(StringTableEntry matName, AssetPtr<TerrainMaterialAsset>* matAsset);
+
    /// Declare Console Object.
    DECLARE_CONOBJECT(TerrainMaterialAsset);
 
@@ -82,11 +118,16 @@ protected:
    virtual void initializeAsset();
    virtual void onAssetRefresh(void);
 
-   static bool setScriptFile(void *obj, const char *index, const char *data) { static_cast<TerrainMaterialAsset*>(obj)->setScriptFile(data); return false; }
+   static bool setScriptFile(void *obj, const char *index, const char *data) 
+   { 
+	   static_cast<TerrainMaterialAsset*>(obj)->setScriptFile(data); 
+	   return false; 
+   }
    static const char* getScriptFile(void* obj, const char* data) { return static_cast<TerrainMaterialAsset*>(obj)->getScriptFile(); }
 };
 
 DefineConsoleType(TypeTerrainMaterialAssetPtr, TerrainMaterialAsset)
+DefineConsoleType(TypeMaterialAssetId, String)
 
 //-----------------------------------------------------------------------------
 // TypeAssetId GuiInspectorField Class
@@ -107,6 +148,14 @@ public:
    virtual bool updateRects();
    void setMaterialAsset(String assetId);
 };
+class GuiInspectorTypeTerrainMaterialAssetId : public GuiInspectorTypeTerrainMaterialAssetPtr
+{
+   typedef GuiInspectorTypeTerrainMaterialAssetPtr Parent;
+public:
+
+   DECLARE_CONOBJECT(GuiInspectorTypeTerrainMaterialAssetId);
+   static void consoleInit();
+};
 
 #endif // _ASSET_BASE_H_
 
diff --git a/Engine/source/T3D/assets/assetImporter.cpp b/Engine/source/T3D/assets/assetImporter.cpp
index de603d1fc..f965bd42c 100644
--- a/Engine/source/T3D/assets/assetImporter.cpp
+++ b/Engine/source/T3D/assets/assetImporter.cpp
@@ -609,14 +609,32 @@ AssetImportObject* AssetImporter::addImportingAsset(String assetType, Torque::Pa
    assetImportObj->registerObject();
 
    //sanitize
-   assetName.replace(' ', '_');
-   assetName.replace('~', '_');
-   assetName.replace('`', '_');
-   assetName.replace('-', '_');
-   assetName.replace('*', '_');
-   assetName.replace('-', '_');
-   assetName.replace('+', '_');
-   assetName.replace('&', '_');
+   String processedString = assetName;
+
+   U32 start;
+   U32 end;
+   String firstNumber = String::GetFirstNumber(processedString, start, end);
+   if (!firstNumber.isEmpty() && processedString.startsWith(firstNumber.c_str()))
+      processedString = processedString.replace(firstNumber, "");
+
+   processedString = processedString.replace(" ", "_");
+
+   U32 len = processedString.length() + 1;
+   char* sanitizedStr = Con::getReturnBuffer(len);
+   dStrcpy(sanitizedStr, processedString.c_str(), len);
+
+   U32 pos = dStrcspn(sanitizedStr, "-+*/%$&�=()[].?\\\"#,;!~<>|�^{}");
+   while (pos < dStrlen(sanitizedStr))
+   {
+      dStrcpy(sanitizedStr + pos, sanitizedStr + pos + 1, len - pos);
+      pos = dStrcspn(sanitizedStr, "-+*/%$&�=()[].?\\\"#,;!~<>|�^{}");
+   }
+
+   //If we did, indeed, modify the name, update it now
+   if (String(sanitizedStr) != assetName)
+   {
+      assetName = sanitizedStr;
+   }
 
    assetImportObj->assetType = assetType;
    assetImportObj->filePath = filePath;
@@ -2725,8 +2743,6 @@ Torque::Path AssetImporter::importMaterialAsset(AssetImportObject* assetItem)
    StringTableEntry assetName = StringTable->insert(assetItem->assetName.c_str());
 
    String tamlPath = targetPath + "/" + assetName + ".asset.taml";
-   String scriptName = assetItem->assetName + "." TORQUE_SCRIPT_EXTENSION;
-   String scriptPath = targetPath + "/" + scriptName;
    String originalPath = assetItem->filePath.getFullPath().c_str();
 
    char qualifiedFromFile[2048];
@@ -2734,10 +2750,8 @@ Torque::Path AssetImporter::importMaterialAsset(AssetImportObject* assetItem)
    Platform::makeFullPathName(originalPath.c_str(), qualifiedFromFile, sizeof(qualifiedFromFile));
 
    newAsset->setAssetName(assetName);
-   newAsset->setScriptFile(scriptName.c_str());
    newAsset->setDataField(StringTable->insert("originalFilePath"), nullptr, qualifiedFromFile);
    newAsset->setDataField(StringTable->insert("materialDefinitionName"), nullptr, assetName);
-   
 
    //iterate through and write out the material maps dependencies
    S32 dependencySlotId = 0;
@@ -2759,16 +2773,6 @@ Torque::Path AssetImporter::importMaterialAsset(AssetImportObject* assetItem)
       dependencySlotId++;
    }
 
-   Taml tamlWriter;
-   bool importSuccessful = tamlWriter.write(newAsset, tamlPath.c_str());
-
-   if (!importSuccessful)
-   {
-      dSprintf(importLogBuffer, sizeof(importLogBuffer), "Error! Unable to write asset taml file %s", tamlPath.c_str());
-      activityLog.push_back(importLogBuffer);
-      return "";
-   }
-
    //build the ORMConfig file if we're flagged to and have valid image maps
    if (activeImportConfig->CreateORMConfig)
    {
@@ -2807,109 +2811,12 @@ Torque::Path AssetImporter::importMaterialAsset(AssetImportObject* assetItem)
       }
    }
 
-   FileObject* file = new FileObject();
-   file->registerObject();
-
-   if (activeImportConfig->UseExistingMaterials && Platform::isFile(qualifiedFromFile))
+   //If we're not using existing materials, or the material in question doesn't actually already exist, spool it up
+   if (!activeImportConfig->UseExistingMaterials || !Sim::findObject(assetName))
    {
-      //Now write the script file containing our material out
-      //There's 2 ways to do this. If we're in-place importing an existing asset, we can see if the definition existed already, like in an old
-      //materials.tscript file. if it does, we can just find the object by name, and save it out to our new file
-      //If not, we'll just generate one
-      Material* existingMat = MATMGR->getMaterialDefinitionByName(assetName);
-
-      //It's also possible that, for legacy models, the material hooks in via the material's mapTo field, and the material name is something completely different
-      //So we'll check for that as well if we didn't find it by name up above
-      if (existingMat == nullptr)
-         existingMat = MATMGR->getMaterialDefinitionByMapTo(assetName);
-
-      if (existingMat == nullptr && assetItem->assetName != assetItem->cleanAssetName)
-      {
-         existingMat = MATMGR->getMaterialDefinitionByName(assetItem->cleanAssetName);
-         if (existingMat == nullptr)
-            existingMat = MATMGR->getMaterialDefinitionByMapTo(assetItem->cleanAssetName);
-      }
-
-      if (existingMat)
-      {
-         PersistenceManager* persistMgr;
-         if (Sim::findObject("ImageAssetValidator", persistMgr))
-         {
-            for (U32 i = 0; i < assetItem->childAssetItems.size(); i++)
-            {
-               AssetImportObject* childItem = assetItem->childAssetItems[i];
-
-               if (childItem->canImport() || childItem->assetType.compare("ImageAsset") != 0)
-                  continue;
-
-               String path = childItem->filePath.getFullFileName();
-
-               String mapFieldName = "";
-               String assetFieldName = "";
-
-               ImageAsset::ImageTypes imageType = ImageAsset::getImageTypeFromName(childItem->imageSuffixType);
-
-               if (imageType == ImageAsset::ImageTypes::Albedo || childItem->imageSuffixType.isEmpty())
-               {
-                  mapFieldName = "DiffuseMap";
-               }
-               else if (imageType == ImageAsset::ImageTypes::Normal)
-               {
-                  mapFieldName = "NormalMap";
-               }
-               else if (imageType == ImageAsset::ImageTypes::ORMConfig)
-               {
-                  mapFieldName = "ORMConfig";
-               }
-               else if (imageType == ImageAsset::ImageTypes::Metalness)
-               {
-                  mapFieldName = "MetalMap";
-               }
-               else if (imageType == ImageAsset::ImageTypes::AO)
-               {
-                  mapFieldName = "AOMap";
-               }
-               else if (imageType == ImageAsset::ImageTypes::Roughness)
-               {
-                  mapFieldName = "RoughMap";
-               }
-
-               assetFieldName = mapFieldName + "Asset[0]";
-               mapFieldName += "[0]";
-
-               //If there's already an existing image map file on the material definition in this slot, don't override it
-               if (!path.isEmpty())
-                  existingMat->writeField(mapFieldName.c_str(), path.c_str());
-
-               String targetAsset = targetModuleId + ":" + childItem->assetName;
-
-               existingMat->writeField(assetFieldName.c_str(), targetAsset.c_str());
-            }
-
-            persistMgr->setDirty(existingMat);
-         }
-         else
-         {
-            Con::errorf("ImageAssetValidator not found!");
-         }
-      }
-      else
-      {
-         dSprintf(importLogBuffer, sizeof(importLogBuffer), "Error! Failed to find original material definition %s!", assetName);
-         activityLog.push_back(importLogBuffer);
-         return tamlPath;
-      }
-   }
-   else if (file->openForWrite(scriptPath.c_str()))
-   {
-      file->writeLine((U8*)"//--- OBJECT WRITE BEGIN ---");
-
-      char lineBuffer[1024];
-      dSprintf(lineBuffer, 1024, "singleton Material(%s) {", assetName);
-      file->writeLine((U8*)lineBuffer);
-
-      dSprintf(lineBuffer, 1024, "   mapTo=\"%s\";", assetName);
-      file->writeLine((U8*)lineBuffer);
+      Material* newMat = new Material();
+      newMat->registerObject(assetName);
+      newMat->mMapTo = assetName;
 
       bool hasRoughness = false;
       for (U32 i = 0; i < assetItem->childAssetItems.size(); i++)
@@ -2919,63 +2826,58 @@ Torque::Path AssetImporter::importMaterialAsset(AssetImportObject* assetItem)
          if ((!childItem->canImport() && childItem->importStatus != AssetImportObject::UseForDependencies) || childItem->assetType.compare("ImageAsset") != 0)
             continue;
 
-         String mapFieldName = "";
-
-         String assetFieldName = "";
-
          ImageAsset::ImageTypes imageType = ImageAsset::getImageTypeFromName(childItem->imageSuffixType);
 
+         String assetMapFillIn = targetModuleId + ":" + childItem->assetName;
+         StringTableEntry assetMapFillInStr = StringTable->insert(assetMapFillIn.c_str());
+
          if (imageType == ImageAsset::ImageTypes::Albedo || childItem->imageSuffixType.isEmpty())
          {
-            mapFieldName = "DiffuseMap";
+            newMat->mDiffuseMapAssetId[0] = assetMapFillInStr;
          }
          else if (imageType == ImageAsset::ImageTypes::Normal)
          {
-            mapFieldName = "NormalMap";
+            newMat->mNormalMapAssetId[0] = assetMapFillInStr;
          }
          else if (imageType == ImageAsset::ImageTypes::ORMConfig)
          {
-            mapFieldName = "ORMConfigMap";
+            newMat->mORMConfigMapAssetId[0] = assetMapFillInStr;
          }
          else if (imageType == ImageAsset::ImageTypes::Metalness)
          {
-            mapFieldName = "MetalMap";
+            newMat->mMetalMapAssetId[0] = assetMapFillInStr;
          }
          else if (imageType == ImageAsset::ImageTypes::AO)
          {
-            mapFieldName = "AOMap";
+            newMat->mAOMapAssetId[0] = assetMapFillInStr;
          }
          else if (imageType == ImageAsset::ImageTypes::Roughness)
          {
-            mapFieldName = "RoughMap";
+            newMat->mRoughMapAssetId[0] = assetMapFillInStr;
             hasRoughness = true;
          }
-
-         assetFieldName = mapFieldName + "Asset";
-         assetFieldName += "[0]";
-
-         //String path = childItem->filePath.getFullFileName();
-         //dSprintf(lineBuffer, 1024, "   %s = \"%s\";", mapFieldName.c_str(), path.c_str());
-         //file->writeLine((U8*)lineBuffer);
-
-         dSprintf(lineBuffer, 1024, "   %s = \"%s:%s\";", assetFieldName.c_str(), targetModuleId.c_str(), childItem->assetName.c_str());
-         file->writeLine((U8*)lineBuffer);
       }
 
       if (hasRoughness)
       {
-         file->writeLine((U8*)"   invertSmoothness = true;");
-         
+         newMat->mInvertRoughness[0] = true;
       }
 
-      file->writeLine((U8*)"};");
-      file->writeLine((U8*)"//--- OBJECT WRITE END ---");
-
-      file->close();
+      newAsset->addObject(newMat);
    }
-   else
+   else 
    {
-      dSprintf(importLogBuffer, sizeof(importLogBuffer), "Error! Unable to write asset script file %s", scriptPath.c_str());
+      dSprintf(importLogBuffer, sizeof(importLogBuffer), "Set to use an existing material, so avoiding writing a material definition to new asset definition for material: %s", assetName);
+      activityLog.push_back(importLogBuffer);
+      return "";
+   }
+
+   Taml tamlWriter;
+   bool importSuccessful = tamlWriter.write(newAsset, tamlPath.c_str());
+
+   if (!importSuccessful)
+   {
+      dSprintf(importLogBuffer, sizeof(importLogBuffer), "Error! Unable to write asset taml file %s", tamlPath.c_str());
       activityLog.push_back(importLogBuffer);
       return "";
    }
diff --git a/Engine/source/assets/assetBase.h b/Engine/source/assets/assetBase.h
index d4efc6a8a..516376663 100644
--- a/Engine/source/assets/assetBase.h
+++ b/Engine/source/assets/assetBase.h
@@ -55,11 +55,11 @@ extern StringTableEntry assetAutoUnloadField;
 //#define ASSET_BASE_AUTOUNLOAD_FIELD        "AssetAutoUnload"
 
 //-----------------------------------------------------------------------------
-class AssetBase : public SimObject
+class AssetBase : public SimGroup
 {
    friend class AssetManager;
 
-   typedef SimObject Parent;
+   typedef SimGroup Parent;
 
 protected:
    AssetManager*           mpOwningAssetManager;
diff --git a/Engine/source/assets/assetDefinition.h b/Engine/source/assets/assetDefinition.h
index 0d3b1c964..fb5720394 100644
--- a/Engine/source/assets/assetDefinition.h
+++ b/Engine/source/assets/assetDefinition.h
@@ -35,8 +35,8 @@
 #include "console/sim.h"
 #endif
 
-#ifndef _SIMOBJECT_H_
-#include "console/simObject.h"
+#ifndef _SIMSET_H_
+#include "console/simset.h"
 #endif
 
 #ifndef _CONSOLEOBJECT_H_
diff --git a/Engine/source/console/simObject.cpp b/Engine/source/console/simObject.cpp
index 3d485354c..8a54f7299 100644
--- a/Engine/source/console/simObject.cpp
+++ b/Engine/source/console/simObject.cpp
@@ -77,6 +77,7 @@ SimObject::SimObject()
    mObjectName = NULL;
    mOriginalName         = NULL;
    mInternalName         = NULL;
+   mInheritFrom          = NULL;
    nextNameObject        = nullptr;
    nextManagerNameObject = nullptr;
    nextIdObject          = NULL;
@@ -154,6 +155,9 @@ void SimObject::initPersistFields()
 
       addProtectedField( "name", TypeName, Offset(mObjectName, SimObject), &setProtectedName, &defaultProtectedGetFn,
          "Optional global name of this object." );
+
+      addProtectedField("inheritFrom", TypeString, Offset(mInheritFrom, SimObject), &setInheritFrom, &defaultProtectedGetFn,
+         "Optional Name of object to inherit from as a parent.");
                   
    endGroup( "Ungrouped" );
 
@@ -1133,7 +1137,7 @@ const char *SimObject::getPrefixedDataField(StringTableEntry fieldName, const ch
 
 //-----------------------------------------------------------------------------
 
-void SimObject::setPrefixedDataField(StringTableEntry fieldName, const char *array, const char *value)
+void SimObject::setPrefixedDataField(StringTableEntry fieldName, const char *_array, const char *value)
 {
    // Sanity!
    AssertFatal(fieldName != NULL, "Cannot set object field value with NULL field name.");
@@ -1142,7 +1146,7 @@ void SimObject::setPrefixedDataField(StringTableEntry fieldName, const char *arr
    // Set value without prefix if there's no value.
    if (*value == 0)
    {
-      setDataField(fieldName, NULL, value);
+      setDataField(fieldName, _array, value);
       return;
    }
 
@@ -1156,7 +1160,7 @@ void SimObject::setPrefixedDataField(StringTableEntry fieldName, const char *arr
    if (fieldPrefix == StringTable->EmptyString())
    {
       // No, so set the data field in the usual way.
-      setDataField(fieldName, NULL, value);
+      setDataField(fieldName, _array, value);
       return;
    }
 
@@ -1167,23 +1171,23 @@ void SimObject::setPrefixedDataField(StringTableEntry fieldName, const char *arr
    if (dStrnicmp(value, fieldPrefix, fieldPrefixLength) != 0)
    {
       // No, so set the data field in the usual way.
-      setDataField(fieldName, NULL, value);
+      setDataField(fieldName, _array, value);
       return;
    }
 
    // Yes, so set the data excluding the prefix.
-   setDataField(fieldName, NULL, value + fieldPrefixLength);
+   setDataField(fieldName, _array, value + fieldPrefixLength);
 }
 
 //-----------------------------------------------------------------------------
 
-const char *SimObject::getPrefixedDynamicDataField(StringTableEntry fieldName, const char *array, const S32 fieldType)
+const char *SimObject::getPrefixedDynamicDataField(StringTableEntry fieldName, const char *_array, const S32 fieldType)
 {
    // Sanity!
    AssertFatal(fieldName != NULL, "Cannot get field value with NULL field name.");
 
    // Fetch field value.
-   const char* pFieldValue = getDataField(fieldName, array);
+   const char* pFieldValue = getDataField(fieldName, _array);
 
    // Sanity.
    AssertFatal(pFieldValue != NULL, "Field value cannot be NULL.");
@@ -2235,10 +2239,10 @@ bool SimObject::setProtectedName(void *obj, const char *index, const char *data)
 {   
    if (preventNameChanging)
       return false;
-   SimObject *object = static_cast<SimObject*>(obj);
-   
-   if ( object->isProperlyAdded() )
-      object->assignName( data );   
+   SimObject* object = static_cast<SimObject*>(obj);
+
+   if (object->isProperlyAdded())
+      object->assignName(data);
 
    // always return false because we assign the name here
    return false;
@@ -2246,6 +2250,31 @@ bool SimObject::setProtectedName(void *obj, const char *index, const char *data)
 
 //-----------------------------------------------------------------------------
 
+bool SimObject::setInheritFrom(void* obj, const char* index, const char* data)
+{
+   SimObject* object = static_cast<SimObject*>(obj);
+
+   SimObject* parent;
+   if (Sim::findObject(data, parent))
+   {
+      object->setCopySource(parent);
+      object->assignFieldsFrom(parent);
+
+      // copy any substitution statements
+      SimDataBlock* parent_db = dynamic_cast<SimDataBlock*>(parent);
+      if (parent_db)
+      {
+         SimDataBlock* currentNewObject_db = dynamic_cast<SimDataBlock*>(object);
+         if (currentNewObject_db)
+            currentNewObject_db->copySubstitutionsFrom(parent_db);
+      }
+   }
+
+   return true;
+}
+
+//-----------------------------------------------------------------------------
+
 void SimObject::inspectPreApply()
 {
 }
diff --git a/Engine/source/console/simObject.h b/Engine/source/console/simObject.h
index 9cef85f0f..05a9353dc 100644
--- a/Engine/source/console/simObject.h
+++ b/Engine/source/console/simObject.h
@@ -299,6 +299,8 @@ class SimObject: public ConsoleObject, public TamlCallbacks
       SimObject*       nextManagerNameObject;
       SimObject*       nextIdObject;
 
+      StringTableEntry mInheritFrom;
+
       /// SimGroup we're contained in, if any.
       SimGroup*   mGroup;
       
@@ -380,6 +382,9 @@ class SimObject: public ConsoleObject, public TamlCallbacks
       // Object name protected set method
       static bool setProtectedName(void *object, const char *index, const char *data);
 
+      // Sets object to inherit default values from
+      static bool setInheritFrom(void* object, const char* index, const char* data);
+
    public:
       inline void setProgenitorFile(const char* pFile) { mProgenitorFile = StringTable->insert(pFile); }
       inline StringTableEntry getProgenitorFile(void) const { return mProgenitorFile; }
diff --git a/Engine/source/materials/materialDefinition.cpp b/Engine/source/materials/materialDefinition.cpp
index 5d009004a..7b3d2c7de 100644
--- a/Engine/source/materials/materialDefinition.cpp
+++ b/Engine/source/materials/materialDefinition.cpp
@@ -516,7 +516,8 @@ bool Material::writeField(StringTableEntry fieldname, const char* value)
       fieldname == StringTable->insert("overlayTex") ||
       fieldname == StringTable->insert("bumpTex") ||
       fieldname == StringTable->insert("envTex") ||
-      fieldname == StringTable->insert("colorMultiply"))
+      fieldname == StringTable->insert("colorMultiply") ||
+      fieldname == StringTable->insert("internalName"))
       return false;
 
    return Parent::writeField(fieldname, value);
diff --git a/Engine/source/persistence/taml/xml/tamlXmlReader.cpp b/Engine/source/persistence/taml/xml/tamlXmlReader.cpp
index 320248b6f..fb8814260 100644
--- a/Engine/source/persistence/taml/xml/tamlXmlReader.cpp
+++ b/Engine/source/persistence/taml/xml/tamlXmlReader.cpp
@@ -293,8 +293,22 @@ void TamlXmlReader::parseAttributes( tinyxml2::XMLElement* pXmlElement, SimObjec
                 attributeName == tamlNamedObjectName )
             continue;
 
-        // Set the field.
-        pSimObject->setPrefixedDataField(attributeName, NULL, pAttribute->Value());
+        //See if we have any sort of array index
+        S32 suffixNum;
+        String trimmedName = String::GetTrailingNumber(attributeName, suffixNum);
+        if (!trimmedName.equal(attributeName))
+        {
+           char arrayIndexStr[32];
+           dItoa(suffixNum, arrayIndexStr);
+
+           // Set the field.
+           pSimObject->setPrefixedDataField(StringTable->insert(trimmedName.c_str()), arrayIndexStr, pAttribute->Value());
+        }
+        else
+        {
+           // Set the field.
+           pSimObject->setPrefixedDataField(attributeName, NULL, pAttribute->Value());
+        }
     }
 }
 
diff --git a/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml b/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml
index faa7ab1e6..3cfa5da83 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml
+++ b/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml
@@ -47,7 +47,7 @@
             <Setting name="AlwaysAddMaterialSuffix">0</Setting>
             <Setting name="CreateComposites">1</Setting>
             <Setting name="CreateORMConfig">1</Setting>
-            <Setting name="IgnoreMaterials">DefaultMaterial</Setting>
+            <Setting name="IgnoreMaterials">DefaultMaterial,ColorEffect*</Setting>
             <Setting name="ImportMaterials">1</Setting>
             <Setting name="PopulateMaterialMaps">1</Setting>
             <Setting name="UseDiffuseSuffixOnOriginImage">1</Setting>
@@ -130,6 +130,7 @@
             <Setting name="AlwaysAddMaterialSuffix">1</Setting>
             <Setting name="CreateComposites">1</Setting>
             <Setting name="ImportMaterials">1</Setting>
+            <Setting name="IgnoreMaterials">DefaultMaterial,ColorEffect*</Setting>
             <Setting name="PopulateMaterialMaps">1</Setting>
             <Setting name="UseDiffuseSuffixOnOriginImage">1</Setting>
             <Setting name="UseExistingMaterials">1</Setting>
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
index bd7c78f90..c385a5f0c 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
@@ -2444,7 +2444,6 @@ function AssetBrowserFilterTree::onControlDropped( %this, %payload, %position )
 
 function AssetBrowserFilterTree::onDragDropped( %this )
 {
-   %asdgadfhg =true;
 }
 
 function AssetBrowser::hasLooseFilesInDir(%this)
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
index d70c6a4a5..18305b920 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
@@ -8,7 +8,6 @@ function AssetBrowser::createMaterialAsset(%this)
    %assetPath = AssetBrowser.dirHandler.currentAddress @ "/";   
    
    %tamlpath = %assetPath @ %assetName @ ".asset.taml";
-   %scriptPath = %assetPath @ %assetName @ "." @ $TorqueScriptFileExtension;
    
    %asset = new MaterialAsset()
    {
@@ -16,13 +15,13 @@ function AssetBrowser::createMaterialAsset(%this)
       versionId = 1;
       materialDefinitionName = %assetName;
       scriptFile = %assetName @ "." @ $TorqueScriptFileExtension;
+      
+      new Material(%assetName) {
+      };
    };
    
    TamlWrite(%asset, %tamlpath);
    
-   %mat = new Material(%assetName);
-   %mat.save(%scriptPath);
-   
    %moduleDef = ModuleDatabase.findModule(%moduleName, 1);
 	AssetDatabase.addDeclaredAsset(%moduleDef, %tamlpath);
 
@@ -42,6 +41,7 @@ function AssetBrowser::editMaterialAsset(%this, %assetDef)
    
    EditorGui.setEditor(MaterialEditorPlugin);
    
+   MaterialEditorGui.currentMaterialAsset = %assetDef.getAssetId();
    MaterialEditorGui.currentMaterial = %assetDef.materialDefinitionName;
    MaterialEditorGui.setActiveMaterial( %assetDef.materialDefinitionName );
    
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrainMaterial.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrainMaterial.tscript
index 51bc88d54..ad1212e11 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrainMaterial.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrainMaterial.tscript
@@ -15,10 +15,37 @@ function AssetBrowser::createTerrainMaterialAsset(%this)
    {
       AssetName = %assetName;
       versionId = 1;
-      scriptFile = %assetName @ "." @ $TorqueScriptFileExtension;
       materialDefinitionName = %assetName;
    };
    
+   %matDef = new TerrainMaterial(%assetName)
+   {
+      internalName = %moduleName @ ":" @ %assetName;
+      diffuseMap = "";
+      detailMap = "";
+      detailSize = "10";
+      isManaged = "1";
+      detailBrightness = "1";
+      Enabled = "1";
+      diffuseSize = "200";
+   };
+   
+   %fxMatDef = new Material("TerrainFX_" @ %assetName)
+   {
+      mapTo = %assetName;
+      footstepSoundId = 0;
+      terrainMaterials = "1";
+      ShowDust = "1";
+      showFootprints = "1";
+      materialTag0 = "Terrain";
+      effectColor[0] = "0.42 0.42 0 1";
+      effectColor[1] = "0.42 0.42 0 1";
+      impactSoundId = "0";
+   };
+   
+   %asset.add(%matDef);
+   %asset.add(%fxMatDef);
+   
    TamlWrite(%asset, %tamlpath);
    
    %moduleDef = ModuleDatabase.findModule(%moduleName, 1);
@@ -28,35 +55,6 @@ function AssetBrowser::createTerrainMaterialAsset(%this)
 
 	AssetBrowser.refresh();
 	
-	//AssetBrowserFilterTree.onSelect(%smItem);
-	
-	%file = new FileObject();
-	%templateFile = new FileObject();
-	
-	%templateFilePath = %this.templateFilesPath @ "terrainMaterial." @ $TorqueScriptFileExtension @ ".template";
-   
-   if(%file.openForWrite(%scriptPath) && %templateFile.openForRead(%templateFilePath))
-   {
-      while( !%templateFile.isEOF() )
-      {
-         %line = %templateFile.readline();
-         %line = strreplace( %line, "@", %assetName );
-         
-         %file.writeline(%line);
-         //echo(%line);
-      }
-      
-      %file.close();
-      %templateFile.close();
-   }
-   else
-   {
-      %file.close();
-      %templateFile.close();
-      
-      warnf("CreateNewTerrainMaterialAsset - Something went wrong and we couldn't write thescript file!");
-   }
-   
    //If we've got the terrain mat editor open, go ahead and update it all
    TerrainMaterialDlg.onWake();
    
diff --git a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
index 2af4b9795..882ec9dc2 100644
--- a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
@@ -269,6 +269,7 @@ function SubMaterialSelector::onSelect( %this )
       }
       else
       {
+         MaterialEditorGui.currentMaterialAsset = %material;
          %assetDef = AssetDatabase.acquireAsset(%material);
          %material = %assetDef.materialDefinitionName;  
       }
@@ -1906,6 +1907,7 @@ function MaterialEditorGui::saveDialogDontSave( %this, %material )
    
    if(AssetDatabase.isDeclaredAsset(%material))
    {
+      MaterialEditorGui.currentMaterialAsset = %material;
       %material = AssetDatabase.acquireAsset(%material).materialDefinitionName;
    }
    
@@ -1916,6 +1918,7 @@ function MaterialEditorGui::saveDialogSave( %this, %material )
 {
    if(AssetDatabase.isDeclaredAsset(%material))
    {
+      MaterialEditorGui.currentMaterialAsset = %material;
       %material = AssetDatabase.acquireAsset(%material).materialDefinitionName;
    }
       
@@ -1945,8 +1948,18 @@ function MaterialEditorGui::save( %this )
    if( %currentMaterial.isAutoGenerated() ) 
       %currentMaterial.setAutoGenerated( false ); 
      
-   // Save the material using the persistence manager
-   matEd_PersistMan.saveDirty();   
+   if(MaterialEditorGui.currentMaterialAsset !$= "")
+   {
+      MaterialEditorGui.copyMaterials( materialEd_previewMaterial, notDirtyMaterial );
+      
+      %assetDef = AssetDatabase.acquireAsset(MaterialEditorGui.currentMaterialAsset);
+      %assetDef.saveAsset(); //write it out
+   }
+   else
+   {
+      // Save the material using the persistence manager
+      matEd_PersistMan.saveDirty();   
+   }
    
    // Clean up the Material Editor
    MaterialEditorGui.copyMaterials( materialEd_previewMaterial, notDirtyMaterial );
@@ -2211,6 +2224,7 @@ function MaterialEditorGui::changeMaterial(%this, %fromMaterial, %toMaterial)
    if(AssetDatabase.isDeclaredAsset(%toMaterial))
    {
       %isMatAsset = true;
+      MaterialEditorGui.currentMaterialAsset = %toMaterial;
       %assetDef = AssetDatabase.acquireAsset(%toMaterial);
       %toMaterialDefinition = %assetDef.materialDefinitionName;
       %filename = %assetDef.getScriptPath();
diff --git a/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript
index c494c5029..e109d2f5e 100644
--- a/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript
@@ -200,7 +200,7 @@ function T3Dpre4ProjectImporter::writeImportingFiles(%this)
       if($ProjectImporter::useExistingModule)
       {
          //clean up legact files if they've been renamed or whatnot
-         if(%file !$= %rootFileSectionObject.fileDestination)
+         if(makeRelativePath(%file) !$= %rootFileSectionObject.fileDestination)
          {
             fileDelete(%file);  
          }
@@ -659,8 +659,6 @@ function T3Dpre4ProjectImporter::processAssetFile(%this, %assetObj)
    if(!isObject(%assetObj))
       return;
       
-   %assetObj.echo();
-      
    //really, we only care here about ensuring the file extensions are cleaned up
    for(%l=0; %l < %assetObj.count(); %l++)
    {
@@ -691,6 +689,9 @@ function T3Dpre4ProjectImporter::beginAssetAndModuleImport(%this)
       
       if(%fileExt $= ".module")
       {
+         if(%rootFileSectionObject.skip)
+            continue;
+            
          projectImporterLog("T3Dpre4ProjectImporter::beginAssetAndModuleImport() - processing file: " @ %file);
          $ProjectImporter::currentFilePath = filePath(%rootFileSectionObject.fileDestination) @ "/";
          %this.processModuleFile(%rootFileSectionObject);
@@ -698,6 +699,9 @@ function T3Dpre4ProjectImporter::beginAssetAndModuleImport(%this)
       }
       else if(%fileExt $= ".asset.taml")
       {
+         if(%rootFileSectionObject.skip)
+            continue;
+            
          projectImporterLog("T3Dpre4ProjectImporter::beginAssetAndModuleImport() - processing file: " @ %file);
          $ProjectImporter::currentFilePath = filePath(%rootFileSectionObject.fileDestination) @ "/";
          %this.processAssetFile(%rootFileSectionObject);
@@ -913,12 +917,11 @@ function T3Dpre4ProjectImporter::processMaterialObject(%this, %fileObject, %obje
          versionId = 1;
          shaderData = "";
          materialDefinitionName = %assetName;
-         scriptFile = fileBase(%scriptPath);
       };
       
       //Now we make our scripted definition "real", and append it to our asset
       //so it is serialized.
-      /*%objectDefinition = "";
+      %objectDefinition = "";
       for(%l=0; %l < %fileObject.count(); %l++)
       {
          %objectLine = %fileObject.getKey(%l);  
@@ -932,8 +935,14 @@ function T3Dpre4ProjectImporter::processMaterialObject(%this, %fileObject, %obje
       
       if(isObject(%objectName))
       {
+         //if we created it successfully, set up inheritance for serialization if needed
+         if(%fileObject.parentName !$= "")
+         {
+            %objectName.setFieldValue("inheritFrom",%fileObject.parentName);
+         }
+               
          %asset.add(%objectName);
-      }*/
+      }
       
       if(!isDirectory(%assetPath))
       {
@@ -943,26 +952,6 @@ function T3Dpre4ProjectImporter::processMaterialObject(%this, %fileObject, %obje
       %success = false;
       if(TamlWrite(%asset, %tamlpath))
       {
-         //now write the script file
-         if ( $ProjectImporter::fileObject.openForWrite( %scriptPath ) ) 
-         {
-            for(%i=0; %i < %fileObject.count(); %i++)
-            {
-               %objectLine = %fileObject.getKey(%i);
-               if(isObject(%objectLine))
-               {
-                  %defineLine = %fileObject.getKey(0);
-                  $ProjectImporter::fileObject.writeLine(%defineLine);
-               }
-               else
-               {
-                  $ProjectImporter::fileObject.writeLine(%objectLine);
-               }
-            }
-            
-            $ProjectImporter::fileObject.close();
-         }
-         
          %moduleDef = ModuleDatabase.findModule(%moduleName, 1);
                   
          %success = AssetDatabase.addDeclaredAsset(%moduleDef, %tamlpath);
@@ -971,6 +960,43 @@ function T3Dpre4ProjectImporter::processMaterialObject(%this, %fileObject, %obje
       if(!%success)
          return false;
    }
+   else
+   {
+      //process an existing material asset, if needbe
+      %assetDef = AssetDatabase.acquireAsset(%matAsset);
+      
+      %assetScriptPath = %assetDef.getScriptPath();
+      
+      if(isFile(%assetScriptPath) && isObject(%objectName))
+      {
+         //Regular material in a companion file, so we'll want to write it to the
+         //asset def file instead of the loose file
+         %assetDef.scriptFile = ""; //clear the old script path reference
+         %assetDef.add(%objectName); //child the definition to the asset def
+
+         if(%fileObject.parentName !$= "")
+         {
+            %objectName.setFieldValue("inheritFrom",%fileObject.parentName);
+         }
+         
+         if(%assetDef.saveAsset())
+         {
+            %fileObject.processed = true;
+            %fileObject.skip = true; //don't write the def back out to script, it's not needed now
+            
+            %assetFileObj = findFileInImporting(makeFullPath(AssetDatabase.getAssetFilePath(%matAsset)));
+            
+            echo(%assetFileObj.fileDestination);
+            %assetFileObj.processed = true;
+            %assetFileObj.skip = true; //this asset definition has been processed
+                                       //so nothing else need be done
+         }
+         else
+         {
+            projectImporterLog("T3Dpre4ProjectImporter::processMaterialObject() - failed to save out modified material asset for: " @ %matAsset);  
+         }
+      }
+   }
    
    return false;
 }
@@ -1017,9 +1043,36 @@ function T3Dpre4ProjectImporter::processTerrainMaterialObject(%this, %fileObject
          versionId = 1;
          shaderData = "";
          materialDefinitionName = %objectName;
-         scriptFile = fileName(%scriptPath);
       };
       
+      //Now we make our scripted definition "real", and append it to our asset
+      //so it is serialized.
+      %objectDefinition = "";
+      for(%l=0; %l < %fileObject.count(); %l++)
+      {
+         %objectLine = %fileObject.getKey(%l);  
+         if(!isObject(%objectLine))
+         {
+            %objectDefinition = %objectDefinition @ %objectLine;
+         }
+      }
+      
+      //Shift to object name, internal name will be used for assetID store
+      %objectDefinition.name = findObjectField(%fileObject, "internalName");
+      
+      eval(%objectDefinition);
+      
+      if(isObject(%objectName))
+      {
+         //if we created it successfully, set up inheritance for serialization if needed
+         if(%fileObject.parentName !$= "")
+         {
+            %objectName.setFieldValue("inheritFrom",%fileObject.parentName);
+         }
+               
+         %asset.add(%objectName);
+      }
+      
       %success = false;
       if(TamlWrite(%asset, %tamlpath))
       {
@@ -1031,6 +1084,43 @@ function T3Dpre4ProjectImporter::processTerrainMaterialObject(%this, %fileObject
       if(!%success)
          return false;
    }
+   else
+   {
+      //process an existing material asset, if needbe
+      %assetDef = AssetDatabase.acquireAsset(%matAsset);
+      
+      %assetScriptPath = %assetDef.getScriptPath();
+      
+      if(isFile(%assetScriptPath) && isObject(%objectName))
+      {
+         //Regular material in a companion file, so we'll want to write it to the
+         //asset def file instead of the loose file
+         %assetDef.scriptFile = ""; //clear the old script path reference
+         %assetDef.add(%objectName); //child the definition to the asset def
+
+         if(%fileObject.parentName !$= "")
+         {
+            %objectName.setFieldValue("inheritFrom",%fileObject.parentName);
+         }
+         
+         if(%assetDef.saveAsset())
+         {
+            %fileObject.processed = true;
+            %fileObject.skip = true; //don't write the def back out to script, it's not needed now
+            
+            %assetFileObj = findFileInImporting(makeFullPath(AssetDatabase.getAssetFilePath(%matAsset)));
+            
+            echo(%assetFileObj.fileDestination);
+            %assetFileObj.processed = true;
+            %assetFileObj.skip = true; //this asset definition has been processed
+                                       //so nothing else need be done
+         }
+         else
+         {
+            projectImporterLog("T3Dpre4ProjectImporter::processTerrainMaterialObject() - failed to save out modified material asset for: " @ %matAsset);  
+         }
+      }
+   }
    
    return false;
 }
@@ -1122,25 +1212,12 @@ function T3Dpre4ProjectImporter::processSFXProfileObject(%this, %file, %objectNa
       }
       else
       {
-         %objFileFinder = "";
-         //first check our cache
-         if(isObject($ProjectImporter::SFXDescriptionCache) && 
-            $ProjectImporter::SFXDescriptionCache.getIndexFromKey(%descriptionName) !$= "")
-         {
-            %key = $ProjectImporter::SFXDescriptionCache.getIndexFromKey(%descriptionName);
-            %objFileFinder = $ProjectImporter::SFXDescriptionCache.getValue(%key);
-         }
-         else
-         {
-            %objFileFinder = findObjectInFiles(%descriptionName);
-         }
+         %fileObj = findObjectInFiles(%descriptionName);
          
-         if(%objFileFinder !$= "")
+         if(%fileObj !$= "")
          {
             %valueArray = new ArrayObject();
                
-            %fileObj = getField(%objFileFinder, 0);
-               
             %valueArray.add("sourceGroup" SPC findObjectField(%fileObj, "sourceGroup"));
             %valueArray.add("volume" SPC findObjectField(%fileObj, "volume"));
             %valueArray.add("pitch" SPC findObjectField(%fileObj, "pitch"));
@@ -1157,10 +1234,7 @@ function T3Dpre4ProjectImporter::processSFXProfileObject(%this, %file, %objectNa
             %valueArray.add("rolloffFactor" SPC findObjectField(%fileObj, "rolloffFactor"));
             %valueArray.add("isStreaming" SPC findObjectField(%fileObj, "isStreaming"));
             
-            if(isObject($ProjectImporter::SFXDescriptionCache))
-            {
-               $ProjectImporter::SFXDescriptionCache.add(%descriptionName, %objFileFinder);
-            }
+            %fileObj.skip = true;
             
             for(%v=0; %v < %valueArray.Count(); %v++)
             {
diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
index ab47a18a9..e4156ff23 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
@@ -242,7 +242,7 @@ function ProjectImportWizardPage3::openPage(%this)
    %dataFullPath = makeFullPath("data/");
    %coreFullPath = makeFullPath("core/");
    %toolsFullPath = makeFullPath("tools/");
-   if(startsWith(makeFullPath("data/"), $ProjectImporter::sourceContentFolder))
+   if(startsWith($ProjectImporter::sourceContentFolder, makeFullPath("data/")))
    {
       %moduleDef = AssetBrowser.dirHandler.getModuleFromAddress(makeRelativePath($ProjectImporter::sourceContentFolder));
       if(isObject(%moduleDef))
@@ -254,8 +254,8 @@ function ProjectImportWizardPage3::openPage(%this)
          ProjectImportWindow.setStep(4);
       }
    }
-   else if(startsWith(makeFullPath("core/"), $ProjectImporter::sourceContentFolder) ||
-            startsWith(makeFullPath("tools/"), $ProjectImporter::sourceContentFolder))
+   else if(startsWith($ProjectImporter::sourceContentFolder, makeFullPath("core/")) ||
+            startsWith($ProjectImporter::sourceContentFolder, makeFullPath("tools/")))
    {
       ProjectImportWindow.setStep(5);
    }
@@ -490,9 +490,11 @@ function preprocessImportingFiles()
                
                %objectName = getSubStr(%line, %end+1, %nameEnd-%end-1);
                
+               %parentName = "";
                %inheritanceSplit = strpos(%objectName, ":");
                if(%inheritanceSplit != -1)
                {
+                  %parentName = getSubStr(%objectName, %inheritanceSplit + 1);
                   %objectName = getSubStr(%objectName, 0, %inheritanceSplit);
                }
                
@@ -502,6 +504,7 @@ function preprocessImportingFiles()
                %currentFileSectionObject.elementType = "object";
                %currentFileSectionObject.classType = %className;
                %currentFileSectionObject.objectName = %objectName;
+               %currentFileSectionObject.parentName = %parentName;
                %currentFileSectionObject.fileName = %file;
                %currentFileSectionObject.skip = false;
                %currentFileSectionObject.fileDestination = %rootFileSectionObject.fileDestination;
@@ -510,6 +513,7 @@ function preprocessImportingFiles()
                %currentFileSectionObject.add(%line);
 
                %parentFileSectionObject.add(%currentFileSectionObject);
+               %currentFileSectionObject.parentElement = %parentFileSectionObject;
                
                //Now for a sanity check, see if we kill the object on the same line as we make it
                //sometimes people try and be 'efficient' with their code linecount wise
@@ -540,9 +544,11 @@ function preprocessImportingFiles()
                
                %objectName = getSubStr(%line, %end+1, %nameEnd-%end-1);
                
+               %parentName = "";
                %inheritanceSplit = strpos(%objectName, ":");
                if(%inheritanceSplit != -1)
                {
+                  %parentName = getSubStr(%objectName, %inheritanceSplit + 1);
                   %objectName = getSubStr(%objectName, 0, %inheritanceSplit);
                }
                
@@ -552,6 +558,7 @@ function preprocessImportingFiles()
                %currentFileSectionObject.elementType = "object";
                %currentFileSectionObject.classType = %className;
                %currentFileSectionObject.objectName = %objectName;
+               %currentFileSectionObject.parentName = %parentName;
                %currentFileSectionObject.fileName = %file;
                %currentFileSectionObject.skip = false;
                %currentFileSectionObject.fileDestination = %rootFileSectionObject.fileDestination;
@@ -560,6 +567,7 @@ function preprocessImportingFiles()
                %currentFileSectionObject.add(%line);
 
                %parentFileSectionObject.add(%currentFileSectionObject);
+               %currentFileSectionObject.parentElement = %parentFileSectionObject;
                
                //Now for a sanity check, see if we kill the object on the same line as we make it
                //sometimes people try and be 'efficient' with their code linecount wise
@@ -590,9 +598,11 @@ function preprocessImportingFiles()
                
                %objectName = getSubStr(%line, %end+1, %nameEnd-%end-1);
                
+               %parentName = "";
                %inheritanceSplit = strpos(%objectName, ":");
                if(%inheritanceSplit != -1)
                {
+                  %parentName = getSubStr(%objectName, %inheritanceSplit + 1);
                   %objectName = getSubStr(%objectName, 0, %inheritanceSplit);
                }
 
@@ -602,6 +612,7 @@ function preprocessImportingFiles()
                %currentFileSectionObject.elementType = "object";
                %currentFileSectionObject.classType = %className;
                %currentFileSectionObject.objectName = %objectName;
+               %currentFileSectionObject.parentName = %parentName;
                %currentFileSectionObject.fileName = %file;
                %currentFileSectionObject.skip = false;
                %currentFileSectionObject.fileDestination = %rootFileSectionObject.fileDestination;
@@ -610,6 +621,7 @@ function preprocessImportingFiles()
                %currentFileSectionObject.add(%line);
 
                %parentFileSectionObject.add(%currentFileSectionObject);
+               %currentFileSectionObject.parentElement = %parentFileSectionObject;
                
                //Now for a sanity check, see if we kill the object on the same line as we make it
                //sometimes people try and be 'efficient' with their code linecount wise
@@ -650,6 +662,7 @@ function preprocessImportingFiles()
                %currentFileSectionObject.add(%line);
                
                %parentFileSectionObject.add(%currentFileSectionObject);
+               %currentFileSectionObject.parentElement = %parentFileSectionObject;
                
                if(strIsMatchExpr("*{*", %line))
                {
@@ -838,6 +851,48 @@ function isImportingFile(%checkFile)
    return false;
 }
 
+//==============================================================================
+// Returns the file object of the file in question is part of our pre-scanned list of importing files
+//==============================================================================
+function findFileInImporting(%checkFile)
+{
+   for(%i=0; %i < $ProjectImporter::FileList.count(); %i++)
+   {
+      %file = $ProjectImporter::FileList.getKey(%i);
+      
+      if(%file $= %checkFile)
+         return $ProjectImporter::FileList.getValue(%i);
+   }
+   
+   return "";
+}
+
+//==============================================================================
+// Checks if the object in question is defined in any of our pre-scanned list of importing files
+//==============================================================================
+function findObjectInFiles(%objectName, %arrayObj)
+{
+   if(%arrayObj $= "")
+      %arrayObj = $ProjectImporter::FileList;
+      
+   for(%i=0; %i < %arrayObj.count(); %i++)
+   {
+      %objectLine = %arrayObj.getKey(%i);
+      if(isObject(%objectLine))
+      {
+         if(%objectLine.objectName $= %objectName)
+            return %objectLine;
+            
+         //If this object isn't it, try recursing any children
+         %result = findObjectInFiles(%objectName, %objectLine);
+         if(%result !$= "")
+            return %result;
+      }
+   }
+   
+   return "";
+}
+
 //==============================================================================
 // Takes a filename lacking an extension and then checks common file extensions
 // to see if we can find the actual file in question
@@ -1215,6 +1270,32 @@ function projectImporterLog(%line)
    $ProjectImporter::log.add(%line);
 }
 
+//==============================================================================
+// Traverses the object delcaration stack backwards to find the root file object
+//==============================================================================
+function getParentFileObjectFromObject(%object)
+{
+   while(%object.parentElement !$= "")
+   {
+      %object = %object.parentElement;
+   }
+   
+   return %object;
+}
+
+//==============================================================================
+// Traverses the object delcaration stack backwards to find the root file object
+//==============================================================================
+function getParentFileObjectFromObject(%object)
+{
+   while(%object.parentElement !$= "")
+   {
+      %object = %object.parentElement;
+   }
+   
+   return %object;
+}
+
 //==============================================================================
 //Shape Importing
 //==============================================================================
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript
index 5429008ea..b49cef39a 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript
@@ -77,9 +77,6 @@ function TerrainMaterialDlg::showByObjectId( %this, %matObjectId, %onApplyCallba
 
 function TerrainMaterialDlg::onWake( %this )
 {
-   if( !isObject( ETerrainMaterialPersistMan ) )
-      new PersistenceManager( ETerrainMaterialPersistMan );
-      
    if( !isObject( TerrainMaterialDlgNewGroup ) )
       new SimGroup( TerrainMaterialDlgNewGroup );
    if( !isObject( TerrainMaterialDlgDeleteGroup ) )
@@ -156,9 +153,6 @@ function TerrainMaterialDlg::dialogApply( %this )
    // Make sure we save any changes to the current selection.
    %this.saveDirtyMaterial( %this.activeMat );
    
-   // Save all changes.
-   ETerrainMaterialPersistMan.saveDirty();
-   
    // Delete the snapshot.
    TerrainMaterialDlgSnapshot.delete();
 
@@ -191,10 +185,6 @@ function TerrainMaterialDlg::closeDialog( %this )
    
    %this.restoreMaterials();
    
-   // Clear the persistence manager state.
-   
-   ETerrainMaterialPersistMan.clearAll();
-   
    // Delete all new object we have created.
    
    TerrainMaterialDlgNewGroup.clear();
@@ -599,17 +589,9 @@ function TerrainMaterialDlg::saveDirtyMaterial( %this, %mat )
    %mat.isSRGB = %isSRGB;
    %mat.invertRoughness = %invertRoughness;
    
-   // Mark the material as dirty and needing saving.
-   
-   %fileName = %mat.getFileName();
-   if( %fileName $= "" )
-   {
-      error("TerrainMaterialDlg::saveDirtyMaterial() - terrain material doesn't have a fileName set to save to.");
-      return;
-      //%fileName = "data/terrains/materials." @ $TorqueScriptFileExtension;
-   }
-      
-   ETerrainMaterialPersistMan.setDirty( %mat, %fileName ); 
+   //Save the material asset
+   %assetDef = AssetDatabase.acquireAsset(%mat.internalName);
+   %assetDef.saveAsset();
 }
 
 //-----------------------------------------------------------------------------

From 5e1eb80bc1ba469f839a7b6bac87ce35899be0f6 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Sun, 30 Jan 2022 19:14:36 -0600
Subject: [PATCH 303/399] Fixed handling issue where it would misparse lines
 that would contain new/singleton/datablock keywords fixed incorrect getSubStr
 function invoke

---
 .../importers/pre40/pre40ImporterGuis.tscript               | 2 +-
 .../tools/projectImporter/scripts/projectImporter.tscript   | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Templates/BaseGame/game/tools/projectImporter/importers/pre40/pre40ImporterGuis.tscript b/Templates/BaseGame/game/tools/projectImporter/importers/pre40/pre40ImporterGuis.tscript
index 816b5cf80..10b7fb96a 100644
--- a/Templates/BaseGame/game/tools/projectImporter/importers/pre40/pre40ImporterGuis.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/importers/pre40/pre40ImporterGuis.tscript
@@ -37,7 +37,7 @@ function Pre40ImporterPage0::openPage(%this)
          %sanitizedFilename = sanitizeString(%fileBase);
          if(startsWith(%sanitizedFilename, "_"))
          {
-            %sanitizedFilename = substr(%sanitizedFilename, 1, -1);
+            %sanitizedFilename = getSubstr(%sanitizedFilename, 1, -1);
          }
          if(%sanitizedFilename !$= %fileBase)
          {
diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
index e4156ff23..af600e8c3 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
@@ -476,7 +476,7 @@ function preprocessImportingFiles()
          {
             %line = $ProjectImporter::fileObject.readLine();
             
-            if(strIsMatchExpr("*new*(*)*", %line) && !strIsMatchExpr("*\"*new*(*)*\"*", %line))
+            if(strIsMatchExpr("* new*(*)*", %line))
             {
                %start = strpos(%line, "new ");
                %end = strpos(%line, "(", %start);
@@ -530,7 +530,7 @@ function preprocessImportingFiles()
                      %insideObjectBlock = true;
                }
             }
-            else if(strIsMatchExpr("*datablock*(*)*", %line))
+            else if(strIsMatchExpr("* datablock*(*)*", %line))
             {
                %start = strpos(%line, "datablock ");
                %end = strpos(%line, "(", %start);
@@ -584,7 +584,7 @@ function preprocessImportingFiles()
                      %insideObjectBlock = true;
                }
             }
-            else if(strIsMatchExpr("*singleton*(*)*", %line))
+            else if(strIsMatchExpr("* singleton*(*)*", %line))
             {
                %start = strpos(%line, "singleton ");
                %end = strpos(%line, "(", %start);

From b4e346aa3ff7556ed62b322e54c521d38a430c00 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Mon, 31 Jan 2022 20:57:57 -0600
Subject: [PATCH 304/399] Adjustments to save out code when writing fields such
 that if the TAML writer is marked as not writing defaults, it doesn't. And
 makes the regular simobject save out not write default values as the default
 behavior

---
 Engine/source/console/simObject.cpp     | 12 ++++++++
 Engine/source/persistence/taml/taml.cpp | 37 +++++++++++++++++++------
 2 files changed, 41 insertions(+), 8 deletions(-)

diff --git a/Engine/source/console/simObject.cpp b/Engine/source/console/simObject.cpp
index 8a54f7299..1a76e23fe 100644
--- a/Engine/source/console/simObject.cpp
+++ b/Engine/source/console/simObject.cpp
@@ -304,6 +304,10 @@ bool SimObject::writeField(StringTableEntry fieldname, const char* value)
 void SimObject::writeFields(Stream &stream, U32 tabStop)
 {
    // Write static fields.
+
+   // Create a default object of the same type
+   ConsoleObject* defaultConObject = ConsoleObject::create(getClassName());
+   SimObject* defaultObject = dynamic_cast<SimObject*>(defaultConObject);
    
    const AbstractClassRep::FieldList &list = getFieldList();
 
@@ -332,6 +336,11 @@ void SimObject::writeFields(Stream &stream, U32 tabStop)
          if (!writeField(f->pFieldname, valCopy))
             continue;
 
+         //If the field hasn't been changed from the default value, then don't bother writing it out
+         const char* defaultValueCheck = defaultObject->getDataField(f->pFieldname, array);
+         if (dStricmp(defaultValueCheck, valCopy) == 0)
+            continue;
+
          val = valCopy;
 
          U32 expandedBufferSize = ( nBufferSize  * 2 ) + dStrlen(f->pFieldname) + 32;
@@ -366,6 +375,9 @@ void SimObject::writeFields(Stream &stream, U32 tabStop)
    
    if(mFieldDictionary && mCanSaveFieldDictionary)
       mFieldDictionary->writeFields(this, stream, tabStop);
+
+   // Cleanup our created default object
+   delete defaultConObject;
 }
 
 //-----------------------------------------------------------------------------
diff --git a/Engine/source/persistence/taml/taml.cpp b/Engine/source/persistence/taml/taml.cpp
index 2bfd104b9..782731a80 100644
--- a/Engine/source/persistence/taml/taml.cpp
+++ b/Engine/source/persistence/taml/taml.cpp
@@ -217,11 +217,6 @@ ImplementEnumType(_TamlFormatMode,
 
       FileStream stream;
 
-      if (StringTable->insert("c://.asset.taml") == StringTable->insert(mFilePathBuffer))
-      {
-         bool asdfasdf = true;
-      }
-
       // File opened?
       if (!stream.open(mFilePathBuffer, Torque::FS::File::Write))
       {
@@ -643,6 +638,19 @@ ImplementEnumType(_TamlFormatMode,
       // Fetch field count.
       const U32 fieldCount = fieldList.size();
 
+      ConsoleObject* defaultConObject;
+      SimObject* defaultObject;
+      if (!getWriteDefaults())
+      {
+         // Create a default object of the same type
+         defaultConObject = ConsoleObject::create(pSimObject->getClassName());
+         defaultObject = dynamic_cast<SimObject*>(defaultConObject);
+      
+         // ***Really*** shouldn't happen
+         if (!defaultObject)
+            return;
+      }
+
       // Iterate fields.
       U8 arrayDepth = 0;
       TamlCustomNode* currentArrayNode = NULL;
@@ -709,9 +717,6 @@ ImplementEnumType(_TamlFormatMode,
             if (!pFieldValue)
                pFieldValue = StringTable->EmptyString();
 
-            if (pField->type == TypeBool)
-               pFieldValue = dAtob(pFieldValue) ? "true" : "false";
-
             U32 nBufferSize = dStrlen(pFieldValue) + 1;
             FrameTemp<char> valueCopy(nBufferSize);
             dStrcpy((char *)valueCopy, pFieldValue, nBufferSize);
@@ -720,9 +725,19 @@ ImplementEnumType(_TamlFormatMode,
             if (!pSimObject->writeField(fieldName, valueCopy))
                continue;
 
+            if (!getWriteDefaults())
+            {
+               //If the field hasn't been changed from the default value, then don't bother writing it out
+               if (dStricmp(defaultObject->getDataField(fieldName, indexBuffer), pFieldValue) == 0)
+                  continue;
+            }
+
             // Reassign field value.
             pFieldValue = valueCopy;
 
+            if (pField->type == TypeBool)
+               pFieldValue = dAtob(pFieldValue) ? "true" : "false";
+
             // Detect and collapse relative path information
             char fnBuf[1024];
             if ((S32)pField->type == TypeFilename)
@@ -741,6 +756,12 @@ ImplementEnumType(_TamlFormatMode,
             }
          }
       }
+
+      if (!getWriteDefaults())
+      {
+         // Cleanup our created default object
+         delete defaultConObject;
+      }
    }
 
    //-----------------------------------------------------------------------------

From 696c2e2eec35df9dd39333cd258232ef02c768f8 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Wed, 2 Feb 2022 01:11:33 -0600
Subject: [PATCH 305/399] Add sanity check for default value results checking
 when filtering out default values Add additional utility functions for
 updating parsed object data in the project importer Adds logic to find and
 associate FX materials to their terrainMaterials and adding them to the
 terrian material asset if found on project importer

---
 Engine/source/console/simObject.cpp           |   2 +-
 Engine/source/persistence/taml/taml.cpp       |   3 +-
 .../pre40/T3Dpre4ProjectImporter.tscript      | 139 +++++++++++++++++-
 .../scripts/projectImporter.tscript           | 116 +++++++++++++--
 4 files changed, 242 insertions(+), 18 deletions(-)

diff --git a/Engine/source/console/simObject.cpp b/Engine/source/console/simObject.cpp
index 1a76e23fe..3552f4dd1 100644
--- a/Engine/source/console/simObject.cpp
+++ b/Engine/source/console/simObject.cpp
@@ -338,7 +338,7 @@ void SimObject::writeFields(Stream &stream, U32 tabStop)
 
          //If the field hasn't been changed from the default value, then don't bother writing it out
          const char* defaultValueCheck = defaultObject->getDataField(f->pFieldname, array);
-         if (dStricmp(defaultValueCheck, valCopy) == 0)
+         if (defaultValueCheck != '\0' && dStricmp(defaultValueCheck, valCopy) == 0)
             continue;
 
          val = valCopy;
diff --git a/Engine/source/persistence/taml/taml.cpp b/Engine/source/persistence/taml/taml.cpp
index 782731a80..5200dcf28 100644
--- a/Engine/source/persistence/taml/taml.cpp
+++ b/Engine/source/persistence/taml/taml.cpp
@@ -728,7 +728,8 @@ ImplementEnumType(_TamlFormatMode,
             if (!getWriteDefaults())
             {
                //If the field hasn't been changed from the default value, then don't bother writing it out
-               if (dStricmp(defaultObject->getDataField(fieldName, indexBuffer), pFieldValue) == 0)
+               const char* fieldData = defaultObject->getDataField(fieldName, indexBuffer);
+               if (fieldData != '\0' && dStricmp(fieldData, pFieldValue) == 0)
                   continue;
             }
 
diff --git a/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript
index e109d2f5e..c6ac5c2b2 100644
--- a/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript
@@ -892,6 +892,77 @@ T3Dpre4ProjectImporter::genProcessor("Material", $MaterialEntriesList);
 //==============================================================================
 function T3Dpre4ProjectImporter::processMaterialObject(%this, %fileObject, %objectName)
 {
+   //first, lets do a bit of use-case checking. Materials are sometimes companion to 
+   //a terrain material for effects and game physics behavior and may not be immediately
+   //obviously assocated. Lets check for that first before processing this as a regular material
+   %mapTo = findObjectField(%fileObject, "mapTo");
+   if(%mapTo !$= "")
+   {
+      %terrainMatAsset = "";
+      %terrainMat = "";
+      if(isObject(%mapTo) && %mapTo.getClassName() $= "TerrainMaterial")
+      {
+         //If the terrain material already exists as a full object, look up it's
+         //asset to associate this FX material to it
+         %terrainMatAsset = TerrainMaterialAsset::getAssetIdByMaterialName(%mapTo.getName());
+         
+         //Now we make our scripted definition "real", and append it to our asset
+         //so it is serialized.
+         %objectDefinition = "";
+         for(%l=0; %l < %fileObject.count(); %l++)
+         {
+            %objectLine = %fileObject.getKey(%l);  
+            if(!isObject(%objectLine))
+            {
+               %objectDefinition = %objectDefinition @ %objectLine;
+            }
+         }
+         
+         eval(%objectDefinition);
+         
+         if(isObject(%objectName))
+         {
+            %terrainMatAsset.add(%objectName);
+            
+            %terrainMatAsset.saveAsset();
+            %fileObject.processed = true;
+            %fileObject.skip = true; //don't write the def back out to script, it's not needed now
+         }
+         
+         return false;
+      }
+      else
+      {
+         //No existing object, so probably incoming with the import, so lets go
+         //look for it
+         %terrMatList = getObjectsInFilesByClass("TerrainMaterial");
+         for(%i=0; %i < getFieldCount(%terrMatList); %i++)
+         {
+            %terrainMatObj = getField(%terrMatList, %i);
+            if(%terrainMatObj.objectName $= %mapTo)
+            {
+               %terrainMat = %terrainMatObj;
+            }
+            else
+            {
+               %terrainObjIntName = findObjectField(%terrainMatObj, "internalName");
+               if(%terrainObjIntName $= %mapTo)
+               {
+                  %terrainMat = %terrainMatObj;
+               }
+            }
+            
+            if(%terrainMat !$= "")
+            {
+               //found it, not imported yet, so mark it for later
+               %terrainMat.FXMaterial = %fileObject;
+               
+               return false;
+            }
+         }
+      }
+   }
+   
    %matAsset = MaterialAsset::getAssetIdByMaterialName(%objectName);
    
    if(%matAsset $= "" || %matAsset $= "Core_Rendering:NoMaterial")
@@ -1045,6 +1116,8 @@ function T3Dpre4ProjectImporter::processTerrainMaterialObject(%this, %fileObject
          materialDefinitionName = %objectName;
       };
       
+      renameObjectName(%fileObject, %objectName);
+      
       //Now we make our scripted definition "real", and append it to our asset
       //so it is serialized.
       %objectDefinition = "";
@@ -1057,9 +1130,6 @@ function T3Dpre4ProjectImporter::processTerrainMaterialObject(%this, %fileObject
          }
       }
       
-      //Shift to object name, internal name will be used for assetID store
-      %objectDefinition.name = findObjectField(%fileObject, "internalName");
-      
       eval(%objectDefinition);
       
       if(isObject(%objectName))
@@ -1072,6 +1142,69 @@ function T3Dpre4ProjectImporter::processTerrainMaterialObject(%this, %fileObject
                
          %asset.add(%objectName);
       }
+      else
+      {
+         error("T3Dpre4ProjectImporter::processTerrainMaterialObject() - failed to parse terrainmat object: ");
+         echo(%objectDefinition);
+      }
+      
+      if(%fileObject.FXMaterial $= "")
+      {
+         //on the off-chance it exists, try scanning for FX materials associated
+         //to this terrain material
+         %fxMat = findObjectInFiles("TerrainFX_" @ %objectName);
+         if(%fxMat !$= "" && %objectName.classType $= "Material")
+         {
+            %fileObject.FXMaterial = %fxMat;
+         }
+         else
+         {
+            %fxMatList = getObjectsInFilesByClass("Material");
+            for(%i=0; %i < getFieldCount(%fxMatList); %i++)
+            {
+               %fxMatObj = getField(%fxMatList, %i);
+               %fxMatObjMapTo = findObjectField(%fxMatObj, "mapTo");
+               if(%fxMatObjMapTo $= %objectName)
+               {
+                  %fileObject.FXMaterial = %fxMatObj;
+                  break;
+               }
+            }
+         }
+      }
+      
+      if(%fileObject.FXMaterial !$= "")
+      {
+         //Ensure our mapto is up to date for any name sanitize/tweaks
+         setObjectField(%fileObject.FXMaterial, "mapTo", %objectName);
+         
+         //we associated to an FX material, so process that now
+         %objectDefinition = "";
+         for(%l=0; %l < %fileObject.FXMaterial.count(); %l++)
+         {
+            %objectLine = %fileObject.FXMaterial.getKey(%l);  
+            if(!isObject(%objectLine))
+            {
+               %objectDefinition = %objectDefinition @ %objectLine;
+            }
+         }
+         
+         eval(%objectDefinition);
+         
+         if(isObject(%fileObject.FXMaterial.objectName))
+         {
+            //if we created it successfully, set up inheritance for serialization if needed
+            if(%fileObject.FXMaterial.parentName !$= "")
+            {
+               %fileObject.FXMaterial.setFieldValue("inheritFrom",%fileObject.FXMaterial.parentName);
+            }
+                  
+            %asset.add(%fileObject.FXMaterial.objectName);
+         }
+         
+         %fileObject.FXMaterial.processed = true;
+         %fileObject.FXMaterial.skip = true;
+      }  
       
       %success = false;
       if(TamlWrite(%asset, %tamlpath))
diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
index af600e8c3..2e98c9b03 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
@@ -870,11 +870,8 @@ function findFileInImporting(%checkFile)
 //==============================================================================
 // Checks if the object in question is defined in any of our pre-scanned list of importing files
 //==============================================================================
-function findObjectInFiles(%objectName, %arrayObj)
+function findObjectInFilesRecurse(%objectName, %arrayObj)
 {
-   if(%arrayObj $= "")
-      %arrayObj = $ProjectImporter::FileList;
-      
    for(%i=0; %i < %arrayObj.count(); %i++)
    {
       %objectLine = %arrayObj.getKey(%i);
@@ -884,7 +881,7 @@ function findObjectInFiles(%objectName, %arrayObj)
             return %objectLine;
             
          //If this object isn't it, try recursing any children
-         %result = findObjectInFiles(%objectName, %objectLine);
+         %result = findObjectInFilesRecurse(%objectName, %objectLine);
          if(%result !$= "")
             return %result;
       }
@@ -893,6 +890,65 @@ function findObjectInFiles(%objectName, %arrayObj)
    return "";
 }
 
+function findObjectInFiles(%objectName)
+{
+   for(%i=0; %i < $ProjectImporter::FileList.count(); %i++)
+   {
+      %objectLine = $ProjectImporter::FileList.getValue(%i);
+      if(isObject(%objectLine))
+      {
+         if(%objectLine.objectName $= %objectName)
+            return %objectLine;
+            
+         //If this object isn't it, try recursing any children
+         %result = findObjectInFilesRecurse(%objectName, %objectLine);
+         if(%result !$= "")
+            return %result;
+      }
+   }
+   
+   return "";
+}
+
+//==============================================================================
+// Checks if the object in question is defined in any of our pre-scanned list of importing files
+//==============================================================================
+function getObjectsInFilesByClassRecurse(%className, %arrayObj)
+{
+   for(%i=0; %i < %arrayObj.count(); %i++)
+   {
+      %objectLine = %arrayObj.getKey(%i);
+      if(isObject(%objectLine))
+      {
+         if(%objectLine.classType $= %className)
+            $ProjectImporter::queryList = $ProjectImporter::queryList TAB %objectLine;
+            
+         //If this object isn't it, try recursing any children
+         getObjectsInFilesByClassRecurse(%className, %objectLine);
+      }
+   }
+}
+
+function getObjectsInFilesByClass(%className)
+{
+   $ProjectImporter::queryList = "";
+      
+   for(%i=0; %i < $ProjectImporter::FileList.count(); %i++)
+   {
+      %objectLine = $ProjectImporter::FileList.getValue(%i);
+      if(isObject(%objectLine))
+      {
+         if(%objectLine.classType $= %className)
+            $ProjectImporter::queryList = $ProjectImporter::queryList TAB %objectLine;
+            
+         //If this object isn't it, try recursing any children
+         getObjectsInFilesByClassRecurse(%className, %objectLine);
+      }
+   }
+   
+   return ltrim($ProjectImporter::queryList);
+}
+
 //==============================================================================
 // Takes a filename lacking an extension and then checks common file extensions
 // to see if we can find the actual file in question
@@ -1110,18 +1166,30 @@ function renameObjectName(%object, %newName)
       %objectLine = %object.getKey(%e);
       if(!isObject(%objectLine))
       {
-         if(strIsMatchExpr("*singleton*(*)*", %objectLine) && 
-            strIsMatchExpr("*new*(*)*", %objectLine) && 
+         if(strIsMatchExpr("*singleton*(*)*", %objectLine) || 
+            strIsMatchExpr("*new*(*)*", %objectLine) || 
             strIsMatchExpr("*datablock*(*)*", %objectLine))
          {
-            %newLine = strreplace(%object.objectName, %newName);
-            
-            echo("renameObjectName() - lines changed from:");
-            echo(%objectLine);
-            echo("to:");
-            echo(%newLine);
+            if(%object.objectName $= "")
+            {
+               %start = strpos(%objectLine, "(");
+               %end = strpos(%objectLine, ")", %start);
+               
+               %preString = getSubStr(%objectLine, 0, %start+1);
+               %postString = getSubStr(%objectLine, %end);
+               
+               %renamedString = %preString @ %newName @ %postString;
+               
+               %newLine = %renamedString;
+            }
+            else
+            {
+               %newLine = strreplace(%objectLine, %object.objectName, %newName);
+            }
             
             %object.setKey(%newLine, %e);
+            
+            %object.objectName = %newName;
          }  
       }
    }
@@ -1258,6 +1326,28 @@ function setObjectField(%object, %fieldName, %newValue)
    }
 }
 
+//==============================================================================
+// Inserts a new field to an object's block in the preprocessed data
+//==============================================================================
+function insertObjectLine(%object, %newLine)
+{
+   for(%e=0; %e < %object.count(); %e++)
+   {
+      %objectLine = %object.getKey(%e);
+      
+      if(strIsMatchExpr("*{*", %objectLine) || 
+            strIsMatchExpr("*singleton*(*)*", %objectLine) || 
+            strIsMatchExpr("*new*(*)*", %objectLine) || 
+            strIsMatchExpr("*datablock*(*)*", %objectLine))
+      {
+         continue;
+      }
+      
+      %object.insert(%newLine, "", %e);
+      return;
+   }
+}
+
 //==============================================================================
 // Takes a string and adds it to the importer's log. Optionally can print the line
 // directly to console for debugging purposes

From 79eebdd5f3541b9608ad529fca209e425d6ed144 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Sat, 12 Feb 2022 15:53:40 -0600
Subject: [PATCH 306/399] Cleaned and repacked work to update the probe bin and
 reflection probe behavior to clean and standardize it.

---
 .../T3D/lighting/boxEnvironmentProbe.cpp      |   4 +-
 .../source/T3D/lighting/reflectionProbe.cpp   |  45 +-
 Engine/source/T3D/lighting/reflectionProbe.h  |  79 +-
 Engine/source/T3D/lighting/skylight.cpp       |   4 +-
 .../T3D/lighting/sphereEnvironmentProbe.cpp   |  77 +-
 .../T3D/lighting/sphereEnvironmentProbe.h     |   4 -
 Engine/source/environment/scatterSky.cpp      |   8 -
 .../source/renderInstance/renderProbeMgr.cpp  | 810 +++++++++---------
 Engine/source/renderInstance/renderProbeMgr.h | 437 ++++++----
 .../shaderGen/GLSL/shaderFeatureGLSL.cpp      | 147 ++--
 .../shaderGen/HLSL/shaderFeatureHLSL.cpp      |  70 +-
 Engine/source/shaderGen/shaderGenVars.cpp     |  14 +-
 Engine/source/shaderGen/shaderGenVars.h       |  10 +-
 .../reflectionProbeArrayPostFX.tscript        |   2 +
 .../core/rendering/shaders/gl/lighting.glsl   |  82 +-
 .../game/core/rendering/shaders/lighting.hlsl |  86 +-
 .../lighting/advanced/gl/pointLightP.glsl     |  32 +
 .../advanced/gl/reflectionProbeArrayP.glsl    |  64 +-
 .../lighting/advanced/gl/spotLightP.glsl      |  35 +
 .../lighting/advanced/gl/vectorLightP.glsl    |  33 +-
 .../lighting/advanced/pointLightP.hlsl        |   9 +-
 .../advanced/reflectionProbeArrayP.hlsl       |  63 +-
 .../shaders/lighting/advanced/spotLightP.hlsl |   9 +-
 .../lighting/advanced/vectorLightP.hlsl       |   1 -
 24 files changed, 1113 insertions(+), 1012 deletions(-)

diff --git a/Engine/source/T3D/lighting/boxEnvironmentProbe.cpp b/Engine/source/T3D/lighting/boxEnvironmentProbe.cpp
index a08691d1c..e532acd3c 100644
--- a/Engine/source/T3D/lighting/boxEnvironmentProbe.cpp
+++ b/Engine/source/T3D/lighting/boxEnvironmentProbe.cpp
@@ -77,7 +77,7 @@ ConsoleDocClass(BoxEnvironmentProbe,
 BoxEnvironmentProbe::BoxEnvironmentProbe() : ReflectionProbe()
 {
    mCaptureMask = REFLECTION_PROBE_CAPTURE_TYPEMASK;
-   mProbeShapeType = ProbeRenderInst::Box;
+   mProbeShapeType = ProbeInfo::Box;
    mAtten = 0.0;
 }
 
@@ -158,7 +158,7 @@ void BoxEnvironmentProbe::unpackUpdate(NetConnection *conn, BitStream *stream)
 
 void BoxEnvironmentProbe::updateProbeParams()
 {
-   mProbeShapeType = ProbeRenderInst::Box;
+   mProbeShapeType = ProbeInfo::Box;
    mProbeInfo.mAtten = mAtten;
 
    Parent::updateProbeParams();
diff --git a/Engine/source/T3D/lighting/reflectionProbe.cpp b/Engine/source/T3D/lighting/reflectionProbe.cpp
index 9361b05f1..1715ac758 100644
--- a/Engine/source/T3D/lighting/reflectionProbe.cpp
+++ b/Engine/source/T3D/lighting/reflectionProbe.cpp
@@ -73,8 +73,8 @@ ConsoleDocClass(ReflectionProbe,
 ImplementEnumType(ReflectProbeType,
    "Type of mesh data available in a shape.\n"
    "@ingroup gameObjects")
-{ ProbeRenderInst::Sphere, "Sphere", "Sphere shaped" },
-{ ProbeRenderInst::Box, "Box", "Box shape" }
+{ ReflectionProbe::ProbeInfo::Sphere, "Sphere", "Sphere shaped" },
+{ ReflectionProbe::ProbeInfo::Box, "Box", "Box shape" }
 EndImplementEnumType;
 
 ImplementEnumType(ReflectionModeEnum,
@@ -97,7 +97,7 @@ ReflectionProbe::ReflectionProbe()
 
    mTypeMask = LightObjectType | MarkerObjectType;
 
-   mProbeShapeType = ProbeRenderInst::Box;
+   mProbeShapeType = ProbeInfo::Box;
 
    mReflectionModeType = BakedCubemap;
 
@@ -121,8 +121,6 @@ ReflectionProbe::ReflectionProbe()
    mRefreshRateMS = 200;
    mDynamicLastBakeMS = 0;
 
-   mMaxDrawDistance = 75;
-
    mResourcesCreated = false;
    mPrefilterSize = 64;
    mPrefilterMipLevels = mLog2(F32(mPrefilterSize));
@@ -239,7 +237,7 @@ bool ReflectionProbe::_setRadius(void *object, const char *index, const char *da
 {
    ReflectionProbe* probe = reinterpret_cast<ReflectionProbe*>(object);
 
-   if (probe->mProbeShapeType != ProbeRenderInst::Sphere)
+   if (probe->mProbeShapeType != ProbeInfo::Sphere)
       return false;
 
    probe->mObjScale = Point3F(probe->mRadius, probe->mRadius, probe->mRadius);
@@ -291,7 +289,7 @@ bool ReflectionProbe::onAdd()
       if (!mPersistentId)
          mPersistentId = getOrCreatePersistentId();
 
-      mProbeUniqueID = String::ToString(mPersistentId->getUUID().getHash());
+      mProbeUniqueID = mPersistentId->getUUID().toString();
    }
 
    // Refresh this object's material (if any)
@@ -312,7 +310,7 @@ void ReflectionProbe::onRemove()
 {
    if (isClientObject())
    {
-      PROBEMGR->unregisterProbe(mProbeInfo.mProbeIdx);
+      PROBEMGR->unregisterProbe(&mProbeInfo);
    }
 
    // Remove this object from the scene
@@ -461,10 +459,10 @@ void ReflectionProbe::unpackUpdate(NetConnection *conn, BitStream *stream)
 
    if (stream->readFlag())  // StaticDataMask
    {
-      U32 shapeType = ProbeRenderInst::Sphere;
+      U32 shapeType = ProbeInfo::Sphere;
       stream->read(&shapeType);
 
-      mProbeShapeType = (ProbeRenderInst::ProbeShapeType)shapeType;
+      mProbeShapeType = (ProbeInfo::ProbeShapeType)shapeType;
 
       stream->read(&mRadius);
 
@@ -497,6 +495,8 @@ void ReflectionProbe::unpackUpdate(NetConnection *conn, BitStream *stream)
 //-----------------------------------------------------------------------------
 void ReflectionProbe::updateProbeParams()
 {
+   mProbeInfo.mObject = this;
+
    if (!mResourcesCreated)
    {
       if (!createClientResources())
@@ -507,12 +507,12 @@ void ReflectionProbe::updateProbeParams()
 
    mProbeInfo.mProbeShapeType = mProbeShapeType;
 
-   if (mProbeShapeType == ProbeRenderInst::Sphere)
+   if (mProbeShapeType == ProbeInfo::Sphere)
       mObjScale.set(mRadius, mRadius, mRadius);
 
    Box3F bounds;
 
-   if (mProbeShapeType == ProbeRenderInst::Skylight)
+   if (mProbeShapeType == ProbeInfo::Skylight)
    {
       mProbeInfo.mPosition = Point3F::Zero;
       mProbeInfo.mTransform = MatrixF::Identity;
@@ -564,8 +564,6 @@ void ReflectionProbe::updateProbeParams()
       else
          processDynamicCubemap();
    }
-
-   PROBEMGR->updateProbes();
 }
 
 void ReflectionProbe::processDynamicCubemap()
@@ -575,7 +573,7 @@ void ReflectionProbe::processDynamicCubemap()
 
 void ReflectionProbe::processBakedCubemap()
 {
-   mProbeInfo.mIsEnabled = false;
+   //mProbeInfo.mIsEnabled = false;
 
    if ((mReflectionModeType != BakedCubemap) || mProbeUniqueID.isEmpty())
       return;
@@ -611,7 +609,7 @@ void ReflectionProbe::processBakedCubemap()
 
    if (mEnabled && mProbeInfo.mPrefilterCubemap->isInitialized() && mProbeInfo.mIrradianceCubemap->isInitialized())
    {
-      mProbeInfo.mIsEnabled = true;
+      //mProbeInfo.mIsEnabled = true;
 
       mCubemapDirty = false;
 
@@ -622,6 +620,11 @@ void ReflectionProbe::processBakedCubemap()
       mProbeInfo.mPrefilterCubemap.free();
       mProbeInfo.mIrradianceCubemap.free();
    }
+   else
+   {
+      //if we failed, disable
+      mProbeInfo.mIsEnabled = false;
+   }
 }
 
 void ReflectionProbe::processStaticCubemap()
@@ -811,16 +814,16 @@ void ReflectionProbe::createEditorResources()
 
 void ReflectionProbe::prepRenderImage(SceneRenderState *state)
 {
-   if (!mEnabled || !RenderProbeMgr::smRenderReflectionProbes)
+   if (!mEnabled || (!RenderProbeMgr::smRenderReflectionProbes && Con::getVariable("$Probes::Capturing", "0") == "0"))
       return;
 
    Point3F distVec = getRenderPosition() - state->getCameraPosition();
    F32 dist = distVec.len();
 
    //Culling distance. Can be adjusted for performance options considerations via the scalar
-   if (dist > mMaxDrawDistance * Con::getFloatVariable("$pref::GI::ProbeDrawDistScale", 1.0))
+   if (dist > RenderProbeMgr::smMaxProbeDrawDistance * Con::getFloatVariable("$pref::GI::ProbeDrawDistScale", 1.0))
    {
-      mProbeInfo.mScore = mMaxDrawDistance;
+      mProbeInfo.mScore = RenderProbeMgr::smMaxProbeDrawDistance;
       return;
    }
 
@@ -842,7 +845,7 @@ void ReflectionProbe::prepRenderImage(SceneRenderState *state)
 
    //mProbeInfo.mScore *= mMax(mAbs(mDot(vect, state->getCameraTransform().getForwardVector())),0.001f);
 
-   PROBEMGR->submitProbe(mProbeInfo);
+   PROBEMGR->submitProbe(&mProbeInfo);
 
 #ifdef TORQUE_TOOLS
    if (ReflectionProbe::smRenderPreviewProbes && gEditingMission && mPrefilterMap != nullptr)
@@ -938,7 +941,7 @@ void ReflectionProbe::_onRenderViz(ObjectRenderInst *ri,
    ColorI color = ColorI(255, 0, 255, 63);
 
    const MatrixF worldToObjectXfm = mObjToWorld;
-   if (mProbeShapeType == ProbeRenderInst::Sphere)
+   if (mProbeShapeType == ProbeInfo::Sphere)
    {
       draw->drawSphere(desc, mRadius, getPosition(), color);
    }
diff --git a/Engine/source/T3D/lighting/reflectionProbe.h b/Engine/source/T3D/lighting/reflectionProbe.h
index 017cd21df..af6947338 100644
--- a/Engine/source/T3D/lighting/reflectionProbe.h
+++ b/Engine/source/T3D/lighting/reflectionProbe.h
@@ -41,10 +41,6 @@
 #include "renderInstance/renderPassManager.h"
 #endif
 
-#ifndef RENDER_PROBE_MGR_H
-#include "renderInstance/renderProbeMgr.h"
-#endif
-
 class BaseMatInstance;
 
 //-----------------------------------------------------------------------------
@@ -74,6 +70,67 @@ public:
       DynamicCubemap = 5,
    };
 
+   /// <summary>
+   /// This contains all the important data the Probe uses for rendering.
+   /// </summary>
+   struct ProbeInfo
+   {
+      bool mIsEnabled;
+
+      MatrixF mTransform;
+
+      ReflectionProbe* mObject;
+
+      F32 mRadius;
+
+      bool mDirty;
+
+      Box3F mBounds;
+      Point3F mExtents;
+      Point3F mPosition;
+      Point3F mProbeRefOffset;
+      Point3F mProbeRefScale;
+      F32 mAtten;
+
+      F32 mScore;
+
+      GFXCubemapHandle mPrefilterCubemap;
+      GFXCubemapHandle mIrradianceCubemap;
+
+      /// The priority of this light used for
+      /// light and shadow scoring.
+      F32 mPriority;
+
+      enum ProbeShapeType
+      {
+         Box = 0,            
+         Sphere = 1,               
+         Skylight = 2
+      };
+
+      ProbeShapeType mProbeShapeType;
+
+   public:
+
+      ProbeInfo() : mScore(0) {}
+      ~ProbeInfo() {}
+
+      // Copies data passed in from light
+      void set(const ProbeInfo* probeInfo);
+
+      // Accessors
+      const MatrixF& getTransform() const { return mTransform; }
+      void setTransform(const MatrixF& xfm) { mTransform = xfm; }
+
+      Point3F getPosition() const { return mPosition; }
+      void setPosition(const Point3F& pos) { mPosition = pos; }
+
+      void setPriority(F32 priority) { mPriority = priority; }
+      F32 getPriority() const { return mPriority; }
+
+      void clear();
+   };
+
 protected:
 
    // Networking masks
@@ -124,7 +181,7 @@ protected:
    /// <summary>
    /// The shape of the probe
    /// </summary>
-   ProbeRenderInst::ProbeShapeType mProbeShapeType;
+   ProbeInfo::ProbeShapeType mProbeShapeType;
 
    /// <summary>
    /// This is effectively a packed cache of the probe data actually utilized for rendering.
@@ -132,7 +189,7 @@ protected:
    /// When the manager goes to render it has the compacted data to read over more efficiently for setting up what probes should
    /// Actually render in that frame
    /// </summary>
-   ProbeRenderInst mProbeInfo;
+   ProbeInfo mProbeInfo;
 
    /// <summary>
    /// Used to dictate what sort of cubemap the probes use when using IBL
@@ -166,14 +223,13 @@ protected:
    CubemapData *mStaticCubemap;
    GFXCubemapHandle  mDynamicCubemap;
 
-   String cubeDescName;
-   U32 cubeDescId;
-   ReflectorDesc *reflectorDesc;
+   //String cubeDescName;
+   //U32 cubeDescId;
+   //ReflectorDesc *reflectorDesc;
 
    //Utilized in dynamic reflections
    //CubeReflector mCubeReflector;
 
-   ///Prevents us from saving out the cubemaps(for now) but allows us the full HDR range on the in-memory cubemap captures
    bool mUseHDRCaptures;
 
    //irridiance resources
@@ -196,7 +252,6 @@ protected:
    U32 mDynamicLastBakeMS;
    U32 mRefreshRateMS;
 
-   F32 mMaxDrawDistance;
 
    bool mResourcesCreated;
    U32 mCaptureMask;
@@ -313,7 +368,7 @@ public:
    void bake();
 };
 
-typedef ProbeRenderInst::ProbeShapeType ReflectProbeType;
+typedef ReflectionProbe::ProbeInfo::ProbeShapeType ReflectProbeType;
 DefineEnumType(ReflectProbeType);
 
 typedef ReflectionProbe::ReflectionModeType ReflectionModeEnum;
diff --git a/Engine/source/T3D/lighting/skylight.cpp b/Engine/source/T3D/lighting/skylight.cpp
index 36036100b..09d813050 100644
--- a/Engine/source/T3D/lighting/skylight.cpp
+++ b/Engine/source/T3D/lighting/skylight.cpp
@@ -148,7 +148,7 @@ void Skylight::unpackUpdate(NetConnection *conn, BitStream *stream)
 
 void Skylight::updateProbeParams()
 {
-   mProbeShapeType = ProbeRenderInst::Skylight;
+   mProbeShapeType = ProbeInfo::Skylight;
    Parent::updateProbeParams();
 }
 
@@ -167,7 +167,7 @@ void Skylight::prepRenderImage(SceneRenderState *state)
    // Get a handy pointer to our RenderPassmanager
    //RenderPassManager *renderPass = state->getRenderPass();
 
-   PROBEMGR->submitProbe(mProbeInfo);
+   PROBEMGR->submitProbe(&mProbeInfo);
 
 #ifdef TORQUE_TOOLS
    if (Skylight::smRenderPreviewProbes && gEditingMission && mEditorShapeInst && mPrefilterMap != nullptr)
diff --git a/Engine/source/T3D/lighting/sphereEnvironmentProbe.cpp b/Engine/source/T3D/lighting/sphereEnvironmentProbe.cpp
index 54e97b19f..b3e0865a7 100644
--- a/Engine/source/T3D/lighting/sphereEnvironmentProbe.cpp
+++ b/Engine/source/T3D/lighting/sphereEnvironmentProbe.cpp
@@ -77,7 +77,7 @@ ConsoleDocClass(SphereEnvironmentProbe,
 SphereEnvironmentProbe::SphereEnvironmentProbe() : ReflectionProbe()
 {
    mCaptureMask = REFLECTION_PROBE_CAPTURE_TYPEMASK;
-   mProbeShapeType = ProbeRenderInst::Sphere;
+   mProbeShapeType = ProbeInfo::Sphere;
 }
 
 SphereEnvironmentProbe::~SphereEnvironmentProbe()
@@ -144,83 +144,10 @@ void SphereEnvironmentProbe::unpackUpdate(NetConnection *conn, BitStream *stream
 
 void SphereEnvironmentProbe::updateProbeParams()
 {
-   mProbeShapeType = ProbeRenderInst::Sphere;
+   mProbeShapeType = ProbeInfo::Sphere;
    Parent::updateProbeParams();
 }
 
-void SphereEnvironmentProbe::prepRenderImage(SceneRenderState *state)
-{
-   if (!mEnabled || !ReflectionProbe::smRenderPreviewProbes)
-      return;
-
-#ifdef TORQUE_TOOLS
-   if (ReflectionProbe::smRenderPreviewProbes && gEditingMission && mEditorShapeInst && mPrefilterMap != nullptr)
-   {
-      GFXTransformSaver saver;
-
-      // Calculate the distance of this object from the camera
-      Point3F cameraOffset;
-      getRenderTransform().getColumn(3, &cameraOffset);
-      cameraOffset -= state->getDiffuseCameraPosition();
-      F32 dist = cameraOffset.len();
-      if (dist < 0.01f)
-         dist = 0.01f;
-
-      // Set up the LOD for the shape
-      F32 invScale = (1.0f / getMax(getMax(mObjScale.x, mObjScale.y), mObjScale.z));
-
-      mEditorShapeInst->setDetailFromDistance(state, dist * invScale);
-
-      // Make sure we have a valid level of detail
-      if (mEditorShapeInst->getCurrentDetail() < 0)
-         return;
-
-      BaseMatInstance* probePrevMat = mEditorShapeInst->getMaterialList()->getMaterialInst(0);
-
-      setPreviewMatParameters(state, probePrevMat);
-
-      // GFXTransformSaver is a handy helper class that restores
-      // the current GFX matrices to their original values when
-      // it goes out of scope at the end of the function
-
-      // Set up our TS render state      
-      TSRenderState rdata;
-      rdata.setSceneState(state);
-      rdata.setFadeOverride(1.0f);
-
-      // We might have some forward lit materials
-      // so pass down a query to gather lights.
-      LightQuery query;
-      query.init(getWorldSphere());
-      rdata.setLightQuery(&query);
-
-      // Set the world matrix to the objects render transform
-      MatrixF mat = getRenderTransform();
-      mat.scale(Point3F(1, 1, 1));
-      GFX->setWorldMatrix(mat);
-
-      // Animate the the shape
-      mEditorShapeInst->animate();
-
-      // Allow the shape to submit the RenderInst(s) for itself
-      mEditorShapeInst->render(rdata);
-
-      saver.restore();
-   }
-
-   // If the light is selected or light visualization
-   // is enabled then register the callback.
-   const bool isSelectedInEditor = (gEditingMission && isSelected());
-   if (isSelectedInEditor)
-   {
-      ObjectRenderInst *ri = state->getRenderPass()->allocInst<ObjectRenderInst>();
-      ri->renderDelegate.bind(this, &ReflectionProbe::_onRenderViz);
-      ri->type = RenderPassManager::RIT_Editor;
-      state->getRenderPass()->addInst(ri);
-   }
-#endif
-}
-
 void SphereEnvironmentProbe::setPreviewMatParameters(SceneRenderState* renderState, BaseMatInstance* mat)
 {
    Parent::setPreviewMatParameters(renderState, mat);
diff --git a/Engine/source/T3D/lighting/sphereEnvironmentProbe.h b/Engine/source/T3D/lighting/sphereEnvironmentProbe.h
index dc3c9a1a6..3df0b98b5 100644
--- a/Engine/source/T3D/lighting/sphereEnvironmentProbe.h
+++ b/Engine/source/T3D/lighting/sphereEnvironmentProbe.h
@@ -98,10 +98,6 @@ public:
    // use the same Materials.
    //--------------------------------------------------------------------------
    virtual void updateProbeParams();
-
-   // This is the function that allows this object to submit itself for rendering
-   void prepRenderImage(SceneRenderState *state);
-
    void setPreviewMatParameters(SceneRenderState* renderState, BaseMatInstance* mat);
 };
 
diff --git a/Engine/source/environment/scatterSky.cpp b/Engine/source/environment/scatterSky.cpp
index 36ab28ecf..5de3bdd94 100644
--- a/Engine/source/environment/scatterSky.cpp
+++ b/Engine/source/environment/scatterSky.cpp
@@ -970,14 +970,6 @@ void ScatterSky::_render( ObjectRenderInst *ri, SceneRenderState *state, BaseMat
    xform *= GFX->getViewMatrix();
    xform *=  GFX->getWorldMatrix();
 
-   if(state->isReflectPass())
-   {
-      static MatrixF rotMat(EulerF(0.0, 0.0, M_PI_F));
-      xform.mul(rotMat);
-      rotMat.set(EulerF(M_PI_F, 0.0, 0.0));
-      xform.mul(rotMat);
-   }
-
    mShaderConsts->setSafe( mModelViewProjSC, xform );
    mShaderConsts->setSafe( mMiscSC, miscParams );
    mShaderConsts->setSafe( mSphereRadiiSC, sphereRadii );
diff --git a/Engine/source/renderInstance/renderProbeMgr.cpp b/Engine/source/renderInstance/renderProbeMgr.cpp
index bfbf65815..268bba5e5 100644
--- a/Engine/source/renderInstance/renderProbeMgr.cpp
+++ b/Engine/source/renderInstance/renderProbeMgr.cpp
@@ -20,13 +20,8 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 #include "renderProbeMgr.h"
-#include "console/consoleTypes.h"
-#include "scene/sceneObject.h"
-#include "materials/materialManager.h"
-#include "scene/sceneRenderState.h"
 #include "math/util/sphereMesh.h"
 #include "math/util/matrixSet.h"
-#include "materials/processedMaterial.h"
 #include "renderInstance/renderDeferredMgr.h"
 #include "math/mPolyhedron.impl.h"
 #include "gfx/gfxTransformSaver.h"
@@ -34,90 +29,60 @@
 #include "gfx/gfxDebugEvent.h"
 #include "shaderGen/shaderGenVars.h"
 #include "materials/shaderData.h"
-
-#include "gfx/gfxTextureManager.h"
 #include "scene/reflectionManager.h"
 
 #include "postFx/postEffect.h"
 #include "T3D/lighting/reflectionProbe.h"
 #include "T3D/lighting/IBLUtilities.h"
+#include "T3D/Scene.h"
 
 //For our cameraQuery setup
 #include "T3D/gameTSCtrl.h"
 
-#include "T3D/Scene.h"
 
 #define TORQUE_GFX_VISUAL_DEBUG //renderdoc debugging
 
 IMPLEMENT_CONOBJECT(RenderProbeMgr);
 
 ConsoleDocClass( RenderProbeMgr, 
-   "@brief A render bin which uses object callbacks for rendering.\n\n"
-   "This render bin gathers object render instances and calls its delegate "
-   "method to perform rendering.  It is used infrequently for specialized "
-   "scene objects which perform custom rendering.\n\n"
+   "@brief This render bin handles the rendering of reflection probes to provide IBL\n"
+   "lighting for PBR\n\n"
+   "Probes when added to the scene, are registered to the Manager, and then during the steps\n"
+   "leading up to the frame being rendered, the probes submit to the Manager that they are ready to be rendered\n"
+   "resulting in them being added to the active list.\n"
+   "When the manager is invoked to render, it processes the active probe list and finds the best probes based on\n"
+   "settings like max probes per frame, probe score, etc to get the final list of probes to be submitted to the shader.\n\n"
    "@ingroup RenderBin\n" );
 
 RenderProbeMgr *RenderProbeMgr::smProbeManager = NULL;
 
+// This variable is a global toggle on if reflection probes should be rendered or not
 bool RenderProbeMgr::smRenderReflectionProbes = true;
+
+// This variable defines the maximum draw distance of a probe.
 F32 RenderProbeMgr::smMaxProbeDrawDistance = 100;
+
+// This variable defines the maximum number of probes that can be rendered in a single frame in deferred
 S32 RenderProbeMgr::smMaxProbesPerFrame = 8;
 
-S32 QSORT_CALLBACK AscendingReflectProbeInfluence(const void* a, const void* b)
-{
-   // Debug Profiling.
-   PROFILE_SCOPE(AdvancedLightBinManager_AscendingReflectProbeInfluence);
-
-   // Fetch asset definitions.
-   const ProbeRenderInst* pReflectProbeA = (*(ProbeRenderInst**)a);
-   const ProbeRenderInst* pReflectProbeB = (*(ProbeRenderInst**)b);
-   //sort by score
-   return  pReflectProbeA->mScore - pReflectProbeB->mScore;
-}
+S32 RenderProbeMgr::smProbeBakeResolution = 64;
 
 //
 //
 ProbeRenderInst::ProbeRenderInst() :
-   mIsEnabled(true),
-   mTransform(true),
-   mDirty(false),
-   mPriority(1.0f),
-   mScore(0.0f),
-   mPrefilterCubemap(NULL),
-   mIrradianceCubemap(NULL),
-   mRadius(1.0f),
-   mProbeRefOffset(0, 0, 0),
-   mProbeRefScale(1,1,1),
-   mAtten(0.0),
    mCubemapIndex(0),
-   mProbeIdx(0),
-   mProbeShapeType(Box)
+   mProbeInfo(nullptr)
 {
 }
 
 ProbeRenderInst::~ProbeRenderInst()
 {
-   if (mPrefilterCubemap && mPrefilterCubemap.isValid())
-   {
-      mPrefilterCubemap.free();
-   }
-   if (mIrradianceCubemap && mIrradianceCubemap.isValid())
-   {
-      mIrradianceCubemap.free();
-   }
 }
 
-void ProbeRenderInst::set(const ProbeRenderInst *probeInfo)
+void ProbeRenderInst::set(const ProbeRenderInst *probe)
 {
-   mTransform = probeInfo->mTransform;
-   mPrefilterCubemap = probeInfo->mPrefilterCubemap;
-   mIrradianceCubemap = probeInfo->mIrradianceCubemap;
-   mRadius = probeInfo->mRadius;
-   mProbeShapeType = probeInfo->mProbeShapeType;
-   mBounds = probeInfo->mBounds;
-   mScore = probeInfo->mScore;
-   mAtten = probeInfo->mAtten;
+   mCubemapIndex = probe->mCubemapIndex;
+   mProbeInfo = probe->mProbeInfo;
 }
 
 //
@@ -125,16 +90,17 @@ void ProbeRenderInst::set(const ProbeRenderInst *probeInfo)
 ProbeShaderConstants::ProbeShaderConstants()
    : mInit(false),
    mShader(NULL),
-   mProbePositionSC(NULL),
-   mProbeRefPosSC(NULL),
-   mRefScaleSC(NULL),
-   mProbeConfigDataSC(NULL),
-   mProbeSpecularCubemapSC(NULL),
-   mProbeIrradianceCubemapSC(NULL),
+   mProbePositionArraySC(NULL),
+   mProbeRefPosArraySC(NULL),
+   mRefScaleArraySC(NULL),
+   mProbeConfigDataArraySC(NULL),
+   mProbeSpecularCubemapArraySC(NULL),
+   mProbeIrradianceCubemapArraySC(NULL),
    mProbeCountSC(NULL),
    mBRDFTextureMap(NULL),
    mSkylightCubemapIdxSC(NULL),
-   mWorldToObjArraySC(NULL)
+   mWorldToObjArraySC(NULL),
+   mMaxProbeDrawDistanceSC(NULL)
 {
 }
 
@@ -159,29 +125,31 @@ void ProbeShaderConstants::init(GFXShader* shader)
    }
    
    //Reflection Probes
-   mProbePositionSC = shader->getShaderConstHandle(ShaderGenVars::probePosition);
-   mProbeRefPosSC = shader->getShaderConstHandle(ShaderGenVars::probeRefPos);
-   mRefScaleSC = shader->getShaderConstHandle(ShaderGenVars::refScale);
+   mProbePositionArraySC = shader->getShaderConstHandle(ShaderGenVars::probePositionArray);
+   mProbeRefPosArraySC = shader->getShaderConstHandle(ShaderGenVars::probeRefPosArray);
+   mRefScaleArraySC = shader->getShaderConstHandle(ShaderGenVars::refScaleArray);
    mWorldToObjArraySC = shader->getShaderConstHandle(ShaderGenVars::worldToObjArray);
-   mProbeConfigDataSC = shader->getShaderConstHandle(ShaderGenVars::probeConfigData);
-   mProbeSpecularCubemapSC = shader->getShaderConstHandle(ShaderGenVars::specularCubemapAR);
-   mProbeIrradianceCubemapSC = shader->getShaderConstHandle(ShaderGenVars::irradianceCubemapAR);
+   mProbeConfigDataArraySC = shader->getShaderConstHandle(ShaderGenVars::probeConfigDataArray);
+   mProbeSpecularCubemapArraySC = shader->getShaderConstHandle(ShaderGenVars::specularCubemapAR);
+   mProbeIrradianceCubemapArraySC = shader->getShaderConstHandle(ShaderGenVars::irradianceCubemapAR);
    mProbeCountSC = shader->getShaderConstHandle(ShaderGenVars::probeCount);
 
    mBRDFTextureMap = shader->getShaderConstHandle(ShaderGenVars::BRDFTextureMap);
 
    mSkylightCubemapIdxSC = shader->getShaderConstHandle(ShaderGenVars::skylightCubemapIdx);
 
+   mMaxProbeDrawDistanceSC = shader->getShaderConstHandle(ShaderGenVars::maxProbeDrawDistance);
+
    mInit = true;
 }
 
 bool ProbeShaderConstants::isValid()
 {
-   if (mProbePositionSC->isValid() ||
-      mProbeConfigDataSC->isValid() ||
-      mRefScaleSC->isValid() ||
-      mProbeSpecularCubemapSC->isValid() ||
-      mProbeIrradianceCubemapSC->isValid())
+   if (mProbePositionArraySC->isValid() ||
+      mProbeConfigDataArraySC->isValid() ||
+      mRefScaleArraySC->isValid() ||
+      mProbeSpecularCubemapArraySC->isValid() ||
+      mProbeIrradianceCubemapArraySC->isValid())
       return true;
 
    return false;
@@ -199,11 +167,9 @@ RenderProbeMgr::RenderProbeMgr()
 : RenderBinManager(RenderPassManager::RIT_Probes, 1.0f, 1.0f),
    mLastShader(nullptr),
    mLastConstants(nullptr),
-	mProbesDirty(false),
    mHasSkylight(false),
    mSkylightCubemapIdx(-1),
    mCubeMapCount(0),
-   mDefaultSkyLight(nullptr),
    mUseHDRCaptures(true)
 {
    mEffectiveProbeCount = 0;
@@ -220,9 +186,6 @@ RenderProbeMgr::RenderProbeMgr()
    {
       mCubeMapSlots[i] = false;
    }
-
-   mPrefilterSize = 64;
-   mPrefilterMipLevels = mLog2(F32(mPrefilterSize)) + 1;
 }
 
 RenderProbeMgr::RenderProbeMgr(RenderInstType riType, F32 renderOrder, F32 processAddOrder)
@@ -231,17 +194,12 @@ RenderProbeMgr::RenderProbeMgr(RenderInstType riType, F32 renderOrder, F32 proce
    mCubeMapCount = 0;
    dMemset(mCubeMapSlots, false, sizeof(mCubeMapSlots));
    mCubeSlotCount = PROBE_ARRAY_SLOT_BUFFER_SIZE;
-   mDefaultSkyLight = nullptr;
    mEffectiveProbeCount = 0;
    mHasSkylight = false;
    mSkylightCubemapIdx = -1;
    mLastConstants = nullptr;
    mMipCount = 0;
-   mProbesDirty = false;
    mUseHDRCaptures = true;
-
-   mPrefilterSize = 64;
-   mPrefilterMipLevels = mLog2(F32(mPrefilterSize)) + 1;
 }
 
 RenderProbeMgr::~RenderProbeMgr()
@@ -266,29 +224,10 @@ bool RenderProbeMgr::onAdd()
    mPrefilterArray = GFXCubemapArrayHandle(GFX->createCubemapArray());
 
    //pre-allocate a few slots
-   mIrradianceArray->init(PROBE_ARRAY_SLOT_BUFFER_SIZE, PROBE_IRRAD_SIZE, PROBE_FORMAT);
-   mPrefilterArray->init(PROBE_ARRAY_SLOT_BUFFER_SIZE, PROBE_PREFILTER_SIZE, PROBE_FORMAT);
+   mIrradianceArray->init(PROBE_ARRAY_SLOT_BUFFER_SIZE, RenderProbeMgr::smProbeBakeResolution, PROBE_FORMAT);
+   mPrefilterArray->init(PROBE_ARRAY_SLOT_BUFFER_SIZE, RenderProbeMgr::smProbeBakeResolution, PROBE_FORMAT);
    mCubeSlotCount = PROBE_ARRAY_SLOT_BUFFER_SIZE;
 
-   //create our own default default skylight
-   mDefaultSkyLight = new ProbeRenderInst;
-   mDefaultSkyLight->mProbeShapeType = ProbeRenderInst::Skylight;
-   mDefaultSkyLight->mIsEnabled = false;
-
-   String defaultIrradMapPath = GFXTextureManager::getDefaultIrradianceCubemapPath();
-   if (!mDefaultSkyLight->mIrradianceCubemap.set(defaultIrradMapPath))
-   {
-      Con::errorf("RenderProbeMgr::onAdd: Failed to load default irradiance cubemap");
-      return false;
-   }
-
-   String defaultPrefilterPath = GFXTextureManager::getDefaultPrefilterCubemapPath();
-   if (!mDefaultSkyLight->mPrefilterCubemap.set(defaultPrefilterPath))
-   {
-      Con::errorf("RenderProbeMgr::onAdd: Failed to load default prefilter cubemap");
-      return false;
-   }
-
    String brdfTexturePath = GFXTextureManager::getBRDFTexturePath();
    if (!mBRDFTexture.set(brdfTexturePath, &GFXTexturePersistentProfile, "BRDFTexture"))
    {
@@ -316,22 +255,103 @@ void RenderProbeMgr::consoleInit()
    // Vars for debug rendering while the RoadEditor is open, only used if smEditorOpen is true.
    Con::addVariable("$pref::maxProbeDrawDistance", TypeF32, &RenderProbeMgr::smMaxProbeDrawDistance, "Max distance for reflection probes to render.\n");
    Con::addVariable("$pref::MaxProbesPerFrame", TypeS32, &RenderProbeMgr::smMaxProbesPerFrame, "Max number of Environment Probes that can be rendered per-frame.\n");
+   Con::addVariable("$pref::ReflectionProbes::BakeResolution", TypeS32, &RenderProbeMgr::smProbeBakeResolution, "");
+   
 }
 
-void RenderProbeMgr::registerProbe(ProbeRenderInst* newProbe)
+//=============================================================================
+// Utility functions for processing and setting up the probes for rendering
+//=============================================================================
+S32 QSORT_CALLBACK RenderProbeMgr::_probeScoreCmp(const ProbeRenderInst* a, const  ProbeRenderInst* b)
+{
+   F32 diff = a->mProbeInfo->mScore - b->mProbeInfo->mScore;
+   return diff > 0 ? 1 : diff < 0 ? -1 : 0;
+}
+void RenderProbeMgr::getBestProbes(const Point3F& objPosition, ProbeDataSet* probeDataSet)
+{
+   PROFILE_SCOPE(ProbeManager_getBestProbes);
+
+   //Array rendering
+   U32 probeCount = mActiveProbes.size();
+
+   Vector<S8> bestPickProbes;
+   bestPickProbes.setSize(probeDataSet->maxProbeCount);
+   bestPickProbes.fill(-1);
+
+   mHasSkylight = false;
+   probeDataSet->skyLightIdx = -1;
+
+   probeDataSet->effectiveProbeCount = 0;
+   for (U32 i = 0; i < probeCount; i++)
+   {
+      //Check if we've already got a skylight. If we do and we've otherwise filled to our max amounto of probes alloewed, then bail
+      if (mHasSkylight && probeDataSet->effectiveProbeCount >= probeDataSet->maxProbeCount)
+         break;
+
+      const ProbeRenderInst& curEntry = mActiveProbes[i];
+
+      //Obviously, if the probe is marked as not enabled, we skip
+      if (!curEntry.mProbeInfo->mIsEnabled)
+         continue;
+
+      if (curEntry.mProbeInfo->mProbeShapeType != ReflectionProbe::ProbeInfo::Skylight)
+      {
+         if (probeDataSet->effectiveProbeCount < probeDataSet->maxProbeCount)
+         {
+            bestPickProbes[probeDataSet->effectiveProbeCount] = i;
+            probeDataSet->effectiveProbeCount++;
+         }
+      }
+      else
+      {
+         probeDataSet->skyLightIdx = curEntry.mCubemapIndex;
+         mHasSkylight = true;
+      }
+   }
+
+   //If we, for whatever reason, have nothing, bail now
+   if (mHasSkylight == false && probeDataSet->effectiveProbeCount == 0)
+      return;
+
+   //Grab our best probe picks
+   for (U32 i = 0; i < bestPickProbes.size(); i++)
+   {
+      if (bestPickProbes[i] == -1)
+         continue;
+
+      const ProbeRenderInst& curEntry = mActiveProbes[bestPickProbes[i]];
+      probeDataSet->probeConfigArray[i] = Point4F(curEntry.mProbeInfo->mProbeShapeType,
+         curEntry.mProbeInfo->mRadius,
+         curEntry.mProbeInfo->mAtten,
+         curEntry.mCubemapIndex);
+
+      MatrixF p2A = curEntry.mProbeInfo->mTransform;
+      probeDataSet->probeWorldToObjArray[i] = p2A;
+      p2A.inverse();
+      probeDataSet->refScaleArray[i] = curEntry.mProbeInfo->mProbeRefScale / p2A.getScale();
+
+      Point3F probePos = curEntry.mProbeInfo->mObject->getPosition();
+      Point3F refPos = probePos + curEntry.mProbeInfo->mProbeRefOffset * probeDataSet->refScaleArray[i].asPoint3F();
+
+      probeDataSet->probePositionArray[i] = Point4F(probePos.x, probePos.y, probePos.z, 0);
+      probeDataSet->probeRefPositionArray[i] = Point4F(refPos.x, refPos.y, refPos.z, 0);
+
+   }
+}
+
+void RenderProbeMgr::registerProbe(ReflectionProbe::ProbeInfo* newProbe)
 {
    //Can't have over the probe limit
    if (mRegisteredProbes.size() + 1 >= PROBE_MAX_COUNT)
       return;
 
-   mRegisteredProbes.push_back(newProbe);
-
-   newProbe->mProbeIdx = mRegisteredProbes.size() - 1;
+   ProbeRenderInst newProbeRenderInst;
+   newProbeRenderInst.mProbeInfo = newProbe;
 
    const U32 cubeIndex = _findNextEmptyCubeSlot();
    if (cubeIndex == INVALID_CUBE_SLOT)
    {
-      Con::warnf("RenderProbeMgr::addProbe: Invalid cubemap slot.");
+      Con::warnf("RenderProbeMgr::registerProbe() - Invalid cubemap slot.");
       return;
    }
 
@@ -342,8 +362,8 @@ void RenderProbeMgr::registerProbe(ProbeRenderInst* newProbe)
       GFXCubemapArrayHandle irr = GFXCubemapArrayHandle(GFX->createCubemapArray());
       GFXCubemapArrayHandle prefilter = GFXCubemapArrayHandle(GFX->createCubemapArray());
 
-      irr->init(mCubeSlotCount + PROBE_ARRAY_SLOT_BUFFER_SIZE, PROBE_IRRAD_SIZE, PROBE_FORMAT);
-      prefilter->init(mCubeSlotCount + PROBE_ARRAY_SLOT_BUFFER_SIZE, PROBE_PREFILTER_SIZE, PROBE_FORMAT);
+      irr->init(mCubeSlotCount + PROBE_ARRAY_SLOT_BUFFER_SIZE, RenderProbeMgr::smProbeBakeResolution, PROBE_FORMAT);
+      prefilter->init(mCubeSlotCount + PROBE_ARRAY_SLOT_BUFFER_SIZE, RenderProbeMgr::smProbeBakeResolution, PROBE_FORMAT);
 
       mIrradianceArray->copyTo(irr);
       mPrefilterArray->copyTo(prefilter);
@@ -355,50 +375,40 @@ void RenderProbeMgr::registerProbe(ProbeRenderInst* newProbe)
       mCubeSlotCount += PROBE_ARRAY_SLOT_BUFFER_SIZE;
    }
 
-   newProbe->mCubemapIndex = cubeIndex;
+   newProbeRenderInst.mCubemapIndex = cubeIndex;
    //mark cubemap slot as taken
    mCubeMapSlots[cubeIndex] = true;
    mCubeMapCount++;
 
-#ifdef TORQUE_DEBUG
-   Con::warnf("RenderProbeMgr::registerProbe: Registered probe %u to cubeIndex %u", newProbe->mProbeIdx, cubeIndex);
-#endif
+   mRegisteredProbes.push_back(newProbeRenderInst);
 
-   mProbesDirty = true;
+#ifdef TORQUE_DEBUG
+   Con::warnf("RenderProbeMgr::registerProbe() - Registered probe %u to cubeIndex %u", newProbe->mObject->getId(), cubeIndex);
+#endif
 }
 
-void RenderProbeMgr::unregisterProbe(U32 probeIdx)
+void RenderProbeMgr::unregisterProbe(ReflectionProbe::ProbeInfo* probeInfo)
 {
-   //Mostly for consolidation, but also lets us sanity check or prep any other data we need for rendering this in one place at time of flagging for render
-   if (probeIdx >= mRegisteredProbes.size())
+   ProbeRenderInst* probe = findProbeInst(probeInfo);
+   if (probe == nullptr)
       return;
 
-   if (mRegisteredProbes[probeIdx]->mCubemapIndex == INVALID_CUBE_SLOT)
+   if (probe->mCubemapIndex == INVALID_CUBE_SLOT)
       return;
 
    //mark cubemap slot as available now
-   mCubeMapSlots[mRegisteredProbes[probeIdx]->mCubemapIndex] = false;
+   mCubeMapSlots[probe->mCubemapIndex] = false;
    mCubeMapCount--;
 
-   mRegisteredProbes.erase(probeIdx);
-
-   //recalculate all the probe's indicies just to be sure
-   for (U32 i = 0; i < mRegisteredProbes.size(); i++)
-   {
-      mRegisteredProbes[i]->mProbeIdx = i;
-   }
-
-   //rebuild our probe data
-   mProbesDirty = true;
+   mRegisteredProbes.erase(probe);
 }
 
-void RenderProbeMgr::submitProbe(const ProbeRenderInst& newProbe)
+void RenderProbeMgr::submitProbe(ReflectionProbe::ProbeInfo* probe)
 {
-   mActiveProbes.push_back(newProbe);
+   ProbeRenderInst* probeInst = findProbeInst(probe);
+   mActiveProbes.push_back(*probeInst);
 }
 
-//
-//
 PostEffect* RenderProbeMgr::getProbeArrayEffect()
 {
    if (!mProbeArrayEffect)
@@ -407,40 +417,46 @@ PostEffect* RenderProbeMgr::getProbeArrayEffect()
 
       if (!mProbeArrayEffect)
          return nullptr;
+
+      mProbeArrayEffect->setShaderConst("$numProbes", (S32)0);
+      mProbeArrayEffect->setShaderConst("$skylightCubemapIdx", (S32)-1);
+
+      mProbeArrayEffect->setShaderConst("$cubeMips", (float)0);
+      mProbeArrayEffect->setShaderConst("$maxProbeDrawDistance", smMaxProbeDrawDistance);
+
    }
    return mProbeArrayEffect;
 }
 
-//remove
-//Con::setIntVariable("lightMetrics::activeReflectionProbes", mReflectProbeBin.size());
-//Con::setIntVariable("lightMetrics::culledReflectProbes", 0/*mNumLightsCulled*/);
-//
-
-void RenderProbeMgr::updateProbes()
+void RenderProbeMgr::updateProbeTexture(ReflectionProbe::ProbeInfo* probeInfo)
 {
-	mProbesDirty = true;
-}
+   //If we don't have a registered probe, there's no point in updating the cubemap array for it
+   ProbeRenderInst* probe = findProbeInst(probeInfo);
+   if (probe == nullptr)
+      return;
 
-void RenderProbeMgr::updateProbeTexture(ProbeRenderInst* probeInfo)
-{
-   if (probeInfo->mIrradianceCubemap.isNull() || !probeInfo->mIrradianceCubemap->isInitialized())
+   //Some basic sanity checking that we have valid cubemaps to work with
+   if (probeInfo->mIrradianceCubemap.isNull() || !probeInfo->mIrradianceCubemap->isInitialized() ||
+      probeInfo->mIrradianceCubemap->getSize() != RenderProbeMgr::smProbeBakeResolution)
    {
       Con::errorf("RenderProbeMgr::updateProbeTexture() - tried to update a probe's texture with an invalid or uninitialized irradiance map!");
       return;
    }
 
-   if (probeInfo->mPrefilterCubemap.isNull() || !probeInfo->mPrefilterCubemap->isInitialized())
+   if (probeInfo->mPrefilterCubemap.isNull() || !probeInfo->mPrefilterCubemap->isInitialized() ||
+      probeInfo->mPrefilterCubemap->getSize() != RenderProbeMgr::smProbeBakeResolution)
    {
       Con::errorf("RenderProbeMgr::updateProbeTexture() - tried to update a probe's texture with an invalid or uninitialized specular map!");
       return;
    }
 
-   const U32 cubeIndex = probeInfo->mCubemapIndex;
+   //Run the update on the array pair with the probe's cubemaps and index
+   const U32 cubeIndex = probe->mCubemapIndex;
    mIrradianceArray->updateTexture(probeInfo->mIrradianceCubemap, cubeIndex);
    mPrefilterArray->updateTexture(probeInfo->mPrefilterCubemap, cubeIndex);
 
 #ifdef TORQUE_DEBUG
-   Con::warnf("UpdatedProbeTexture - probeIdx: %u on cubeIndex %u, Irrad validity: %d, Prefilter validity: %d", probeInfo->mProbeIdx, cubeIndex,
+   Con::warnf("UpdatedProbeTexture - probe id: %u on cubeIndex %u, Irrad validity: %d, Prefilter validity: %d", probeInfo->mObject->getId(), cubeIndex,
       probeInfo->mIrradianceCubemap->isInitialized(), probeInfo->mPrefilterCubemap->isInitialized());
 #endif
 }
@@ -450,21 +466,165 @@ void RenderProbeMgr::reloadTextures()
    U32 probeCount = mRegisteredProbes.size();
    for (U32 i = 0; i < probeCount; i++)
    {
-      updateProbeTexture(mRegisteredProbes[i]);
+      updateProbeTexture(mRegisteredProbes[i].mProbeInfo);
+   }
+}
+
+void RenderProbeMgr::bakeProbe(ReflectionProbe* probe)
+{
+   GFXDEBUGEVENT_SCOPE(RenderProbeMgr_Bake, ColorI::WHITE);
+
+   Con::warnf("RenderProbeMgr::bakeProbe() - Beginning bake!");
+   U32 startMSTime = Platform::getRealMilliseconds();
+
+   String path = Con::getVariable("$pref::ReflectionProbes::CurrentLevelPath", "levels/");
+   U32 resolution = Con::getIntVariable("$pref::ReflectionProbes::BakeResolution", 64);
+   U32 prefilterMipLevels = mLog2(F32(resolution)) + 1;
+   bool renderWithProbes = Con::getIntVariable("$pref::ReflectionProbes::RenderWithProbes", false);
+
+   ReflectionProbe* clientProbe = nullptr;
+
+   if (probe->isServerObject())
+      clientProbe = static_cast<ReflectionProbe*>(probe->getClientObject());
+   else
+      return;
+
+   if (clientProbe == nullptr)
+      return;
+
+   String probePrefilterPath = clientProbe->getPrefilterMapPath();
+   String probeIrradPath = clientProbe->getIrradianceMapPath();
+
+   if (clientProbe->mReflectionModeType != ReflectionProbe::DynamicCubemap)
+   {
+      //Prep our bake path
+      if (probePrefilterPath.isEmpty() || probeIrradPath.isEmpty())
+      {
+         Con::errorf("RenderProbeMgr::bake() - Unable to bake our captures because probe doesn't have a path set");
+         return;
+   }
    }
 
-   mProbesDirty = true;
+   // Save the current transforms so we can restore
+   // it for child control rendering below.
+   GFXTransformSaver saver;
+
+   bool probeRenderState = RenderProbeMgr::smRenderReflectionProbes;
+
+   F32 farPlane = 1000.0f;
+
+   ReflectorDesc reflDesc;
+   reflDesc.texSize = resolution;
+   reflDesc.farDist = farPlane;
+   reflDesc.detailAdjust = 1;
+   reflDesc.objectTypeMask = probe->mProbeShapeType == ReflectionProbe::ProbeInfo::Skylight ? SKYLIGHT_CAPTURE_TYPEMASK : REFLECTION_PROBE_CAPTURE_TYPEMASK;
+
+   CubeReflector cubeRefl;
+   cubeRefl.registerReflector(probe, &reflDesc);
+
+   ReflectParams reflParams;
+
+   //need to get the query somehow. Likely do some sort of get function to fetch from the guiTSControl that's active
+   CameraQuery query; //need to get the last cameraQuery
+   query.fov = 90; //90 degree slices for each of the 6 sides
+   query.nearPlane = 0.1f;
+   query.farPlane = farPlane;
+   query.headMatrix = MatrixF();
+   query.cameraMatrix = clientProbe->getTransform();
+
+   Frustum culler;
+   culler.set(false,
+      query.fov,
+      1.0f,
+      query.nearPlane,
+      query.farPlane,
+      query.cameraMatrix);
+
+   S32 stereoTarget = GFX->getCurrentStereoTarget();
+
+   Point2I maxRes(2048, 2048); //basically a boundary so we don't go over this and break stuff
+
+   reflParams.culler = culler;
+   reflParams.eyeId = stereoTarget;
+   reflParams.query = &query;
+   reflParams.startOfUpdateMs = startMSTime;
+   reflParams.viewportExtent = maxRes;
+
+   if (!renderWithProbes)
+      RenderProbeMgr::smRenderReflectionProbes = false;
+
+   GFXFormat reflectFormat;
+
+   if (mUseHDRCaptures)
+      reflectFormat = GFXFormatR16G16B16A16F;
+   else
+      reflectFormat = GFXFormatR8G8B8A8;
+   const GFXFormat oldRefFmt = REFLECTMGR->getReflectFormat();
+   REFLECTMGR->setReflectFormat(reflectFormat);
+
+   cubeRefl.updateReflection(reflParams, clientProbe->getTransform().getPosition() + clientProbe->mProbeRefOffset);
+
+   //Now, save out the maps
+   //create irridiance cubemap
+   if (cubeRefl.getCubemap())
+   {
+      //Just to ensure we're prepped for the generation
+      clientProbe->createClientResources();
+
+      //Prep it with whatever resolution we've dictated for our bake
+      clientProbe->mIrridianceMap->mCubemap->initDynamic(resolution, reflectFormat);
+      clientProbe->mPrefilterMap->mCubemap->initDynamic(resolution, reflectFormat);
+
+      GFXTextureTargetRef renderTarget = GFX->allocRenderToTextureTarget(false);
+
+      IBLUtilities::GenerateIrradianceMap(renderTarget, cubeRefl.getCubemap(), clientProbe->mIrridianceMap->mCubemap);
+      IBLUtilities::GeneratePrefilterMap(renderTarget, cubeRefl.getCubemap(), prefilterMipLevels, clientProbe->mPrefilterMap->mCubemap);
+
+      U32 endMSTime = Platform::getRealMilliseconds();
+      F32 diffTime = F32(endMSTime - startMSTime);
+      Con::warnf("RenderProbeMgr::bake() - Finished Capture! Took %g milliseconds", diffTime);
+      Con::warnf("RenderProbeMgr::bake() - Beginning save now!");
+
+      IBLUtilities::SaveCubeMap(clientProbe->getIrradianceMapPath(), clientProbe->mIrridianceMap->mCubemap);
+      IBLUtilities::SaveCubeMap(clientProbe->getPrefilterMapPath(), clientProbe->mPrefilterMap->mCubemap);
+   }
+   else
+   {
+      Con::errorf("RenderProbeMgr::bake() - Didn't generate a valid scene capture cubemap, unable to generate prefilter and irradiance maps!");
+   }
+
+   if (!renderWithProbes)
+      RenderProbeMgr::smRenderReflectionProbes = probeRenderState;
+
+   cubeRefl.unregisterReflector();
+
+   U32 endMSTime = Platform::getRealMilliseconds();
+   F32 diffTime = F32(endMSTime - startMSTime);
+
+   probe->setMaskBits(-1);
+
+   Con::warnf("RenderProbeMgr::bake() - Finished bake! Took %g milliseconds", diffTime);
+   REFLECTMGR->setReflectFormat(oldRefFmt);
 }
 
-void RenderProbeMgr::_setupPerFrameParameters(const SceneRenderState *state)
+void RenderProbeMgr::bakeProbes()
 {
-   PROFILE_SCOPE(RenderProbeMgr_SetupPerFrameParameters);
+   Vector<ReflectionProbe*> probes;
 
-   mProbeData = ProbeDataSet(smMaxProbesPerFrame);
+   Scene::getRootScene()->findObjectByType<ReflectionProbe>(probes);
 
-   getBestProbes(state->getCameraPosition(), &mProbeData);
+   for (U32 i = 0; i < probes.size(); i++)
+   {
+      if (probes[i]->isClientObject())
+         continue;
+
+      bakeProbe(probes[i]);
+   }
 }
 
+//=============================================================================
+// Forward Rendering functions
+//=============================================================================
 ProbeShaderConstants* RenderProbeMgr::getProbeShaderConstants(GFXShaderConstBuffer* buffer)
 {
    if (!buffer)
@@ -510,16 +670,45 @@ ProbeShaderConstants* RenderProbeMgr::getProbeShaderConstants(GFXShaderConstBuff
    return mLastConstants;
 }
 
+void RenderProbeMgr::setProbeInfo(ProcessedMaterial *pmat,
+   const Material *mat,
+   const SceneData &sgData,
+   const SceneRenderState *state,
+   U32 pass,
+   GFXShaderConstBuffer *shaderConsts)
+{
+   // Skip this if we're rendering from the deferred bin.
+   if (sgData.binType == SceneData::DeferredBin)
+      return;
+
+   PROFILE_SCOPE(ProbeManager_setProbeInfo);
+
+   ProbeShaderConstants *psc = getProbeShaderConstants(shaderConsts);
+
+   // NOTE: If you encounter a crash from this point forward
+   // while setting a shader constant its probably because the
+   // mConstantLookup has bad shaders/constants in it.
+   //
+   // This is a known crash bug that can occur if materials/shaders
+   // are reloaded and the light manager is not reset.
+   //
+   // We should look to fix this by clearing the table.
+   MatrixSet matSet = state->getRenderPass()->getMatrixSet();
+
+   // Update the forward shading light constants.
+   _update4ProbeConsts(sgData, matSet, psc, shaderConsts);
+}
+
 void RenderProbeMgr::setupSGData(SceneData& data, const SceneRenderState* state, LightInfo* light)
 {
    //ensure they're sorted for forward rendering
    mActiveProbes.sort(_probeScoreCmp);
 }
 
-void RenderProbeMgr::_update4ProbeConsts(const SceneData &sgData,
-   MatrixSet &matSet,
-   ProbeShaderConstants *probeShaderConsts,
-   GFXShaderConstBuffer *shaderConsts)
+void RenderProbeMgr::_update4ProbeConsts(const SceneData& sgData,
+   MatrixSet& matSet,
+   ProbeShaderConstants* probeShaderConsts,
+   GFXShaderConstBuffer* shaderConsts)
 {
    PROFILE_SCOPE(ProbeManager_Update4ProbeConsts);
 
@@ -548,136 +737,46 @@ void RenderProbeMgr::_update4ProbeConsts(const SceneData &sgData,
          probeConfigAlignedArray[i] = probeSet.probeConfigArray[i];
       }
 
+      if (probeSet.effectiveProbeCount != 0)
+      {
       shaderConsts->setSafe(probeShaderConsts->mProbeCountSC, (S32)probeSet.effectiveProbeCount);
 
-      shaderConsts->setSafe(probeShaderConsts->mProbePositionSC, probePositionAlignedArray);
-      shaderConsts->setSafe(probeShaderConsts->mProbeRefPosSC, probeRefPositionAlignedArray);
+         shaderConsts->setSafe(probeShaderConsts->mProbePositionArraySC, probePositionAlignedArray);
+         shaderConsts->setSafe(probeShaderConsts->mProbeRefPosArraySC, probeRefPositionAlignedArray);
 
-      if(probeShaderConsts->isValid())
-         shaderConsts->set(probeShaderConsts->mWorldToObjArraySC, probeSet.probeWorldToObjArray.address(), probeSet.effectiveProbeCount, GFXSCT_Float4x4);
+         if (probeShaderConsts->isValid())
+            shaderConsts->set(probeShaderConsts->mWorldToObjArraySC, probeSet.probeWorldToObjArray.address(), probeSet.probeWorldToObjArray.size(), GFXSCT_Float4x4);
 
-      shaderConsts->setSafe(probeShaderConsts->mRefScaleSC, refScaleAlignedArray);
-      shaderConsts->setSafe(probeShaderConsts->mProbeConfigDataSC, probeConfigAlignedArray);
+         shaderConsts->setSafe(probeShaderConsts->mRefScaleArraySC, refScaleAlignedArray);
+         shaderConsts->setSafe(probeShaderConsts->mProbeConfigDataArraySC, probeConfigAlignedArray);
+      }
+
+      if (probeShaderConsts->mBRDFTextureMap->getSamplerRegister() != -1 && mBRDFTexture.isValid())
+         GFX->setTexture(probeShaderConsts->mBRDFTextureMap->getSamplerRegister(), mBRDFTexture);
 
       shaderConsts->setSafe(probeShaderConsts->mSkylightCubemapIdxSC, (float)probeSet.skyLightIdx);
 
-      if(probeShaderConsts->mBRDFTextureMap->getSamplerRegister() != -1 && mBRDFTexture.isValid())
-         GFX->setTexture(probeShaderConsts->mBRDFTextureMap->getSamplerRegister(), mBRDFTexture);
+      if (probeShaderConsts->mProbeSpecularCubemapArraySC->getSamplerRegister() != -1)
+         GFX->setCubeArrayTexture(probeShaderConsts->mProbeSpecularCubemapArraySC->getSamplerRegister(), mPrefilterArray);
+      if (probeShaderConsts->mProbeIrradianceCubemapArraySC->getSamplerRegister() != -1)
+         GFX->setCubeArrayTexture(probeShaderConsts->mProbeIrradianceCubemapArraySC->getSamplerRegister(), mIrradianceArray);
 
-      if(probeShaderConsts->mProbeSpecularCubemapSC->getSamplerRegister() != -1)
-         GFX->setCubeArrayTexture(probeShaderConsts->mProbeSpecularCubemapSC->getSamplerRegister(), mPrefilterArray);
-      if(probeShaderConsts->mProbeIrradianceCubemapSC->getSamplerRegister() != -1)
-         GFX->setCubeArrayTexture(probeShaderConsts->mProbeIrradianceCubemapSC->getSamplerRegister(), mIrradianceArray);
+      shaderConsts->setSafe(probeShaderConsts->mMaxProbeDrawDistanceSC, smMaxProbeDrawDistance);
    }
 }
 
-S32 QSORT_CALLBACK RenderProbeMgr::_probeScoreCmp(const ProbeRenderInst* a, const  ProbeRenderInst* b)
+//=============================================================================
+// Deferred Rendering Functions
+//=============================================================================
+void RenderProbeMgr::_setupPerFrameParameters(const SceneRenderState* state)
 {
-   F32 diff = a->getScore() - b->getScore();
-   return diff > 0 ? 1 : diff < 0 ? -1 : 0;
+   PROFILE_SCOPE(RenderProbeMgr_SetupPerFrameParameters);
+
+   mProbeData = ProbeDataSet(smMaxProbesPerFrame);
+
+   getBestProbes(state->getCameraPosition(), &mProbeData);
 }
 
-void RenderProbeMgr::getBestProbes(const Point3F& objPosition, ProbeDataSet* probeDataSet)
-{
-   PROFILE_SCOPE(ProbeManager_getBestProbes);
-
-   //Array rendering
-   U32 probeCount = mActiveProbes.size();
-
-   Vector<S8> bestPickProbes;
-   bestPickProbes.setSize(probeDataSet->maxProbeCount);
-   bestPickProbes.fill(-1);
-
-   probeDataSet->effectiveProbeCount = 0;
-   for (U32 i = 0; i < probeCount; i++)
-   {
-      if (probeDataSet->skyLightIdx != -1 && probeDataSet->effectiveProbeCount >= probeDataSet->maxProbeCount)
-         break;
-
-      const ProbeRenderInst& curEntry = mActiveProbes[i];
-      if (!curEntry.mIsEnabled)
-         continue;
-
-      if (curEntry.mProbeShapeType != ProbeRenderInst::Skylight)
-      {
-         if (probeDataSet->effectiveProbeCount < probeDataSet->maxProbeCount)
-         {
-            bestPickProbes[probeDataSet->effectiveProbeCount] = i;
-            probeDataSet->effectiveProbeCount++;
-         }
-      }
-      else
-      {
-         probeDataSet->skyLightIdx = curEntry.mCubemapIndex;
-      }
-   }
-
-   //Grab our best probe picks
-   for (U32 i = 0; i < bestPickProbes.size(); i++)
-   {
-      if (bestPickProbes[i] == -1)
-         continue;
-
-      const ProbeRenderInst& curEntry = mActiveProbes[bestPickProbes[i]];
-
-      MatrixF p2A = curEntry.getTransform();
-      p2A.inverse();
-      probeDataSet->refScaleArray[i] = curEntry.mProbeRefScale / p2A.getScale();
-
-      Point3F probePos = curEntry.getPosition();
-      Point3F refPos = probePos + curEntry.mProbeRefOffset * probeDataSet->refScaleArray[i].asPoint3F();
-      probeDataSet->probeWorldToObjArray[i] = curEntry.getTransform();
-
-      probeDataSet->probePositionArray[i] = Point4F(probePos.x, probePos.y, probePos.z, 0);
-      probeDataSet->probeRefPositionArray[i] = Point4F(refPos.x, refPos.y, refPos.z, 0);
-
-      probeDataSet->probeConfigArray[i] = Point4F(curEntry.mProbeShapeType,
-         curEntry.mRadius,
-         curEntry.mAtten,
-         curEntry.mCubemapIndex);
-   }
-}
-
-void RenderProbeMgr::getProbeTextureData(ProbeTextureArrayData* probeTextureSet)
-{
-   probeTextureSet->BRDFTexture = mBRDFTexture;
-   probeTextureSet->prefilterArray = mPrefilterArray;
-   probeTextureSet->irradianceArray = mIrradianceArray;
-}
-
-void RenderProbeMgr::setProbeInfo(ProcessedMaterial *pmat,
-   const Material *mat,
-   const SceneData &sgData,
-   const SceneRenderState *state,
-   U32 pass,
-   GFXShaderConstBuffer *shaderConsts)
-{
-
-   // Skip this if we're rendering from the deferred bin.
-   if (sgData.binType == SceneData::DeferredBin)
-      return;
-
-   PROFILE_SCOPE(ProbeManager_setProbeInfo);
-
-   ProbeShaderConstants *psc = getProbeShaderConstants(shaderConsts);
-
-   // NOTE: If you encounter a crash from this point forward
-   // while setting a shader constant its probably because the
-   // mConstantLookup has bad shaders/constants in it.
-   //
-   // This is a known crash bug that can occur if materials/shaders
-   // are reloaded and the light manager is not reset.
-   //
-   // We should look to fix this by clearing the table.
-   MatrixSet matSet = state->getRenderPass()->getMatrixSet();
-
-   // Update the forward shading light constants.
-   _update4ProbeConsts(sgData, matSet, psc, shaderConsts);
-}
-
-//-----------------------------------------------------------------------------
-// render objects
-//-----------------------------------------------------------------------------
 void RenderProbeMgr::render( SceneRenderState *state )
 {
    if (getProbeArrayEffect() == nullptr)
@@ -695,7 +794,7 @@ void RenderProbeMgr::render( SceneRenderState *state )
    _setupPerFrameParameters(state);
 
    // Early out if nothing to draw.
-   if (!RenderProbeMgr::smRenderReflectionProbes || (!state->isDiffusePass() && !state->isReflectPass()) || (mProbeData.effectiveProbeCount == 0 && mProbeData.skyLightIdx == -1))
+   if ((!RenderProbeMgr::smRenderReflectionProbes && Con::getVariable("$Probes::Capturing", "0") == "0") || (!mHasSkylight && mProbeData.effectiveProbeCount == 0))
    {
       getProbeArrayEffect()->setSkip(true);
       mActiveProbes.clear();
@@ -717,7 +816,7 @@ void RenderProbeMgr::render( SceneRenderState *state )
    String useDebugContrib = Con::getVariable("$Probes::showProbeContrib", "0");
    mProbeArrayEffect->setShaderMacro("DEBUGVIZ_CONTRIB", useDebugContrib);
 
-   if(mProbeData.skyLightIdx != -1 && mProbeData.effectiveProbeCount == 0)
+   if(mHasSkylight && mProbeData.effectiveProbeCount == 0)
       mProbeArrayEffect->setShaderMacro("SKYLIGHT_ONLY", "1");
    else
       mProbeArrayEffect->setShaderMacro("SKYLIGHT_ONLY", "0");
@@ -725,6 +824,8 @@ void RenderProbeMgr::render( SceneRenderState *state )
    String probePerFrame = Con::getVariable("$pref::MaxProbesPerFrame", "8");
    mProbeArrayEffect->setShaderMacro("MAX_PROBES", probePerFrame);
 
+   String probeCapturing = Con::getVariable("$Probes::Capturing", "0");
+   mProbeArrayEffect->setShaderMacro("CAPTURING", probeCapturing);
    //ssao mask
    if (AdvancedLightBinManager::smUseSSAOMask)
    {
@@ -785,166 +886,17 @@ void RenderProbeMgr::render( SceneRenderState *state )
    mProbeArrayEffect->setShaderConst("$worldToObjArray", mProbeData.probeWorldToObjArray);
    mProbeArrayEffect->setShaderConst("$refScaleArray", mProbeData.refScaleArray);
    mProbeArrayEffect->setShaderConst("$probeConfigData", mProbeData.probeConfigArray);
+   mProbeArrayEffect->setShaderConst("$maxProbeDrawDistance", smMaxProbeDrawDistance);
 
    // Make sure the effect is gonna render.
    getProbeArrayEffect()->setSkip(false);
-
-   mActiveProbes.clear();
 }
 
-void RenderProbeMgr::bakeProbe(ReflectionProbe *probe)
-{
-   GFXDEBUGEVENT_SCOPE(RenderProbeMgr_Bake, ColorI::WHITE);
+//=============================================================================
+// Console functions
+//=============================================================================
 
-   Con::warnf("RenderProbeMgr::bakeProbe() - Beginning bake!");
-   U32 startMSTime = Platform::getRealMilliseconds();
 
-   String path = Con::getVariable("$pref::ReflectionProbes::CurrentLevelPath", "levels/");
-   U32 resolution = Con::getIntVariable("$pref::ReflectionProbes::BakeResolution", 64);
-   U32 prefilterMipLevels = mLog2(F32(resolution)) + 1;
-   bool renderWithProbes = Con::getIntVariable("$pref::ReflectionProbes::RenderWithProbes", false);
-
-   ReflectionProbe* clientProbe = nullptr;
-
-   if (probe->isServerObject())
-      clientProbe = static_cast<ReflectionProbe*>(probe->getClientObject());
-   else
-      return;
-
-   if (clientProbe == nullptr)
-      return;
-
-   String probePrefilterPath = clientProbe->getPrefilterMapPath();
-   String probeIrradPath = clientProbe->getIrradianceMapPath();
-
-   if (clientProbe->mReflectionModeType != ReflectionProbe::DynamicCubemap)
-   {
-      //Prep our bake path
-      if (probePrefilterPath.isEmpty() || probeIrradPath.isEmpty())
-      {
-         Con::errorf("RenderProbeMgr::bake() - Unable to bake our captures because probe doesn't have a path set");
-         return;
-      }
-   }
-
-   // Save the current transforms so we can restore
-   // it for child control rendering below.
-   GFXTransformSaver saver;
-
-   bool probeRenderState = RenderProbeMgr::smRenderReflectionProbes;
-
-   F32 farPlane = 1000.0f;
-
-   ReflectorDesc reflDesc;
-   reflDesc.texSize = resolution;
-   reflDesc.farDist = farPlane;
-   reflDesc.detailAdjust = 1;
-   reflDesc.objectTypeMask = probe->mProbeShapeType == ProbeRenderInst::ProbeShapeType::Skylight ? SKYLIGHT_CAPTURE_TYPEMASK : REFLECTION_PROBE_CAPTURE_TYPEMASK;
-
-   CubeReflector cubeRefl;
-   cubeRefl.registerReflector(probe, &reflDesc);
-
-   ReflectParams reflParams;
-
-   //need to get the query somehow. Likely do some sort of get function to fetch from the guiTSControl that's active
-   CameraQuery query; //need to get the last cameraQuery
-   query.fov = 90; //90 degree slices for each of the 6 sides
-   query.nearPlane = 0.1f;
-   query.farPlane = farPlane;
-   query.headMatrix = MatrixF();
-   query.cameraMatrix = clientProbe->getTransform();
-
-   Frustum culler;
-   culler.set(false,
-      query.fov,
-      1.0f,
-      query.nearPlane,
-      query.farPlane,
-      query.cameraMatrix);
-
-   S32 stereoTarget = GFX->getCurrentStereoTarget();
-
-   Point2I maxRes(2048, 2048); //basically a boundary so we don't go over this and break stuff
-
-   reflParams.culler = culler;
-   reflParams.eyeId = stereoTarget;
-   reflParams.query = &query;
-   reflParams.startOfUpdateMs = startMSTime;
-   reflParams.viewportExtent = maxRes;
-
-   if (!renderWithProbes)
-      RenderProbeMgr::smRenderReflectionProbes = false;
-
-   GFXFormat reflectFormat;
-
-   if (mUseHDRCaptures)
-      reflectFormat = GFXFormatR16G16B16A16F;
-   else
-      reflectFormat = GFXFormatR8G8B8A8;
-   const GFXFormat oldRefFmt = REFLECTMGR->getReflectFormat();
-   REFLECTMGR->setReflectFormat(reflectFormat);
-   
-   mProbeArrayEffect->setShaderConst("$CAPTURING", true);
-   cubeRefl.updateReflection(reflParams, clientProbe->getTransform().getPosition()+clientProbe->mProbeRefOffset);
-   mProbeArrayEffect->setShaderConst("$CAPTURING", false);
-
-   //Now, save out the maps
-   //create irridiance cubemap
-   if (cubeRefl.getCubemap())
-   {
-      //Just to ensure we're prepped for the generation
-      clientProbe->createClientResources();
-
-      //Prep it with whatever resolution we've dictated for our bake
-      clientProbe->mIrridianceMap->mCubemap->initDynamic(resolution, reflectFormat);
-      clientProbe->mPrefilterMap->mCubemap->initDynamic(resolution, reflectFormat);
-
-      GFXTextureTargetRef renderTarget = GFX->allocRenderToTextureTarget(false);
-
-      IBLUtilities::GenerateIrradianceMap(renderTarget, cubeRefl.getCubemap(), clientProbe->mIrridianceMap->mCubemap);
-      IBLUtilities::GeneratePrefilterMap(renderTarget, cubeRefl.getCubemap(), prefilterMipLevels, clientProbe->mPrefilterMap->mCubemap);
-
-      U32 endMSTime = Platform::getRealMilliseconds();
-      F32 diffTime = F32(endMSTime - startMSTime);
-      Con::warnf("RenderProbeMgr::bake() - Finished Capture! Took %g milliseconds", diffTime);
-      Con::warnf("RenderProbeMgr::bake() - Beginning save now!");
-
-      IBLUtilities::SaveCubeMap(clientProbe->getIrradianceMapPath(), clientProbe->mIrridianceMap->mCubemap);
-      IBLUtilities::SaveCubeMap(clientProbe->getPrefilterMapPath(), clientProbe->mPrefilterMap->mCubemap);
-   }
-   else
-   {
-      Con::errorf("RenderProbeMgr::bake() - Didn't generate a valid scene capture cubemap, unable to generate prefilter and irradiance maps!");
-   }
-
-   if (!renderWithProbes)
-      RenderProbeMgr::smRenderReflectionProbes = probeRenderState;
-
-   cubeRefl.unregisterReflector();
-
-   U32 endMSTime = Platform::getRealMilliseconds();
-   F32 diffTime = F32(endMSTime - startMSTime);
-
-   probe->setMaskBits(-1);
-
-   Con::warnf("RenderProbeMgr::bake() - Finished bake! Took %g milliseconds", diffTime);
-   REFLECTMGR->setReflectFormat(oldRefFmt);
-}
-
-void RenderProbeMgr::bakeProbes()
-{
-   Vector<ReflectionProbe*> probes;
-
-   Scene::getRootScene()->findObjectByType<ReflectionProbe>(probes);
-
-   for (U32 i = 0; i < probes.size(); i++)
-   {
-      if (probes[i]->isClientObject())
-         continue;
-
-      bakeProbe(probes[i]);
-   }
-}
 
 DefineEngineMethod(RenderProbeMgr, bakeProbe, void, (ReflectionProbe* probe), (nullAsType< ReflectionProbe*>()),
    "@brief Bakes the cubemaps for a reflection probe\n\n.")
@@ -955,5 +907,7 @@ DefineEngineMethod(RenderProbeMgr, bakeProbe, void, (ReflectionProbe* probe), (n
 
 DefineEngineMethod(RenderProbeMgr, bakeProbes, void, (),, "@brief Iterates over all reflection probes in the scene and bakes their cubemaps\n\n.")
 {
+   Con::setVariable("$Probes::Capturing", "1");
    object->bakeProbes();
+   Con::setVariable("$Probes::Capturing", "0");
 }
diff --git a/Engine/source/renderInstance/renderProbeMgr.h b/Engine/source/renderInstance/renderProbeMgr.h
index c9dbd69bd..3708f2e1e 100644
--- a/Engine/source/renderInstance/renderProbeMgr.h
+++ b/Engine/source/renderInstance/renderProbeMgr.h
@@ -39,7 +39,7 @@
 #include "gfx/gfxVertexBuffer.h"
 #endif
 
-#include "core/util/systemInterfaceList.h"
+//#include "core/util/systemInterfaceList.h"
 
 #ifndef _MATERIALS_PROCESSEDSHADERMATERIAL_H_
 #include "materials/processedShaderMaterial.h"
@@ -52,52 +52,23 @@
 #include "scene/reflector.h"
 #endif
 
-static U32 MAXPROBECOUNT = 50;
+#ifndef REFLECTIONPROBE_H
+#include "T3D/lighting/reflectionProbe.h"
+#endif
 
 class PostEffect;
 class ReflectionProbe;
 
+/// <summary>
+/// A simple container for a ReflectionProbe's ProbeInfo and index for it's associated
+/// cubemaps in the cubemap array pair
+/// </summary>
 struct ProbeRenderInst
 {
-   bool mIsEnabled;
-
-   MatrixF mTransform;
-
-   F32 mRadius;
-
-   bool mDirty;
-
-   Box3F mBounds;
-   Point3F mExtents;
-   Point3F mPosition;
-   Point3F mProbeRefOffset;
-   Point3F mProbeRefScale;
-   F32 mAtten;
-
-   GFXCubemapHandle mPrefilterCubemap;
-   GFXCubemapHandle mIrradianceCubemap;
-
-   /// The priority of this light used for
-   /// light and shadow scoring.
-   F32 mPriority;
-
-   /// A temporary which holds the score used
-   /// when prioritizing lights for rendering.
-   F32 mScore;
-
-   enum ProbeShapeType
-   {
-      Box = 0,            ///< Sphere shaped
-      Sphere = 1,               ///< Box-based shape
-      Skylight = 2
-   };
-
-   ProbeShapeType mProbeShapeType;
+   ReflectionProbe::ProbeInfo* mProbeInfo;
 
    U32 mCubemapIndex;
 
-   U32 mProbeIdx;
-
 public:
 
    ProbeRenderInst();
@@ -105,28 +76,11 @@ public:
 
    // Copies data passed in from light
    void set(const ProbeRenderInst *probeInfo);
-
-   // Accessors
-   const MatrixF& getTransform() const { return mTransform; }
-   void setTransform(const MatrixF &xfm) { mTransform = xfm; }
-
-   Point3F getPosition() const { return mPosition; }
-   void setPosition(const Point3F &pos) { mPosition = pos; }
-
-   void setPriority(F32 priority) { mPriority = priority; }
-   F32 getPriority() const { return mPriority; }
-
-   void setScore(F32 score) { mScore = score; }
-   F32 getScore() const { return mScore; }
-
-   void clear();
-
-   inline bool operator ==(const ProbeRenderInst& b) const
-   {
-      return mProbeIdx == b.mProbeIdx;
-   }
 };
 
+/// <summary>
+/// A container for all the shader consts needed for rendering probes in forward mode
+/// </summary>
 struct ProbeShaderConstants
 {
    bool mInit;
@@ -134,19 +88,21 @@ struct ProbeShaderConstants
    GFXShaderRef mShader;
    
    //Reflection Probes
-   GFXShaderConstHandle *mProbePositionSC;
-   GFXShaderConstHandle *mProbeRefPosSC;
-   GFXShaderConstHandle *mRefScaleSC;
+   GFXShaderConstHandle *mProbePositionArraySC;
+   GFXShaderConstHandle *mProbeRefPosArraySC;
+   GFXShaderConstHandle *mRefScaleArraySC;
    GFXShaderConstHandle *mWorldToObjArraySC;
-   GFXShaderConstHandle *mProbeConfigDataSC;
-   GFXShaderConstHandle *mProbeSpecularCubemapSC;
-   GFXShaderConstHandle *mProbeIrradianceCubemapSC;
+   GFXShaderConstHandle *mProbeConfigDataArraySC;
+   GFXShaderConstHandle *mProbeSpecularCubemapArraySC;
+   GFXShaderConstHandle *mProbeIrradianceCubemapArraySC;
    GFXShaderConstHandle *mProbeCountSC;
 
    GFXShaderConstHandle *mBRDFTextureMap;
 
    GFXShaderConstHandle *mSkylightCubemapIdxSC;
 
+   GFXShaderConstHandle* mMaxProbeDrawDistanceSC;
+
    ProbeShaderConstants();
    ~ProbeShaderConstants();
 
@@ -159,6 +115,10 @@ struct ProbeShaderConstants
 
 typedef Map<GFXShader*, ProbeShaderConstants*> ProbeConstantMap;
 
+/// <summary>
+/// A container for processed and packed probe data. This is made when we get the frame's
+/// best probes, and is passed to the shader for actual rendering.
+/// </summary>
 struct ProbeDataSet
 {
    Vector<Point4F> probePositionArray;
@@ -198,18 +158,10 @@ struct ProbeDataSet
 
       probeWorldToObjArray.setSize(maxProbeCount);
 
-      skyLightIdx = -1;
       effectiveProbeCount = 0;
    }
 };
 
-struct ProbeTextureArrayData
-{
-   GFXTexHandle BRDFTexture;
-   GFXCubemapArrayHandle prefilterArray;
-   GFXCubemapArrayHandle irradianceArray;
-};
-
 //**************************************************************************
 // RenderObjectMgr
 //**************************************************************************
@@ -217,11 +169,6 @@ class RenderProbeMgr : public RenderBinManager
 {
    typedef RenderBinManager Parent;
 
-   Vector<ProbeRenderInst*> mRegisteredProbes;
-
-   bool mProbesDirty;
-   
-   Vector<ProbeRenderInst>  mActiveProbes;
 public:
    //maximum number of allowed probes
    static const U32 PROBE_MAX_COUNT = 250;
@@ -230,51 +177,161 @@ public:
    //number of slots to allocate at once in the cubemap array
    static const U32 PROBE_ARRAY_SLOT_BUFFER_SIZE = 10;
 
-   static const U32 PROBE_IRRAD_SIZE = 64;
-   static const U32 PROBE_PREFILTER_SIZE = 64;
+   //These dictate the default resolution size for the probe arrays
    static const GFXFormat PROBE_FORMAT = GFXFormatR16G16B16A16F;// GFXFormatR8G8B8A8;// when hdr fixed GFXFormatR16G16B16A16F; look into bc6h compression
    static const U32 INVALID_CUBE_SLOT = U32_MAX;
 
    static F32 smMaxProbeDrawDistance;
    static S32 smMaxProbesPerFrame;
-
+   static S32 smProbeBakeResolution;
+   SceneRenderState *mState;
 private:
-   //Array rendering
-   U32 mEffectiveProbeCount;
-   S32 mMipCount;
+   /// <summary>
+   /// List of registered probes. These are not necessarily rendered in a given frame
+   /// but the Probe Manager is aware of them and they have cubemap array slots allocated
+   /// </summary>
+   Vector<ProbeRenderInst>    mRegisteredProbes;
 
+   /// <summary>
+   /// List of active probes. These are ones that are not only registered, but submitted by the probe itself as
+   /// ready to be rendered. Likely to be rendered in the current frame, settings-dependent.
+   /// </summary>
+   Vector<ProbeRenderInst>    mActiveProbes;
+
+   /// <summary>
+   /// The PostEffect used to actually rendered the probes into the frame when in deferred mode
+   /// </summary>
+   SimObjectPtr<PostEffect>   mProbeArrayEffect;
+
+   /// <summary>
+   /// Do we have a active skylight probe
+   /// </summary>
    bool            mHasSkylight;
+
+   /// <summary>
+   /// If we have a skylight, what's the array pair index for it?
+   /// </summary>
    S32             mSkylightCubemapIdx;
 
-   //number of cubemaps
+   /// <summary>
+   /// The 'effective' probe count. This tracks the number of probes that are actually going to be rendered
+   /// </summary>
+   U32                        mEffectiveProbeCount;
+   //
+   //Array rendering
+
+   /// <summary>
+   /// The number of mips the cubemap array has. Mips are used in the PBR calcs for handling roughness
+   /// </summary>
+   S32                        mMipCount;
+
+   /// <summary>
+   /// The number of cubemaps registered in our array pair
+   /// </summary>
    U32 mCubeMapCount;
-   //number of cubemap slots allocated
+
+   /// <summary>
+   /// The number of allocated slots for the array pair. Rather than adding slots one at a time to the arrays
+   /// We allocate in chunks so we don't have to resize/rebuild the arrays as often
+   /// </summary>
    U32 mCubeSlotCount;
-   //array of cubemap slots, due to the editor these may be mixed around as probes are added and deleted
+
+   /// <summary>
+   /// List indicating if a given allocated slot is actually in use.
+   /// Due to the editor these may be mixed around as probes are added and deleted
+   /// </summary>
+   /// <returns></returns>
    bool mCubeMapSlots[PROBE_MAX_COUNT];
 
+   /// <summary>
+   /// The prefilter cubemap array
+   /// </summary>
    GFXCubemapArrayHandle mPrefilterArray;
+
+   /// <summary>
+   /// The irradiance cubemap array
+   /// </summary>
    GFXCubemapArrayHandle mIrradianceArray;
 
    //Utilized in forward rendering
+
+   /// <summary>
+   /// This is used to look up already-made ProbeShaderConsts for a given shader
+   /// This allows us to avoid having to rebuild the consts each frame if it's a shader
+   /// we've already handled before.
+   /// </summary>
    ProbeConstantMap mConstantLookup;
+
+   /// <summary>
+   /// The last shader we rendered(in forward mode). With this, we can shortcut the constant
+   /// lookup if the shader being processed and the last one are the same.
+   /// </summary>
    GFXShaderRef mLastShader;
+
+   /// <summary>
+   /// THe previous shader constants. When used in conjunction with the mLastShader, we can skip
+   /// having to do a lookup to find an existing ProbeShaderConstants, saving overhead on batched
+   /// rendering
+   /// </summary>
    ProbeShaderConstants* mLastConstants;
 
-   //
-   SimObjectPtr<PostEffect> mProbeArrayEffect;
-
-   //Default skylight, used for shape editors, etc
-   ProbeRenderInst* mDefaultSkyLight;
-
+   /// <summary>
+   /// The BRDF texture used in PBR math calculations
+   /// </summary>
    GFXTexHandle mBRDFTexture;
 
+   /// <summary>
+   /// Processed best probe selection list of the current frame when rendering in deferred mode.
+   /// </summary>
    ProbeDataSet mProbeData;
-   ///Prevents us from saving out the cubemaps(for now) but allows us the full HDR range on the in-memory cubemap captures
+
+   /// <summary>
+   /// Allows us the full HDR range on the in-memory cubemap captures
+   /// </summary>
    bool mUseHDRCaptures;
 
-   U32 mPrefilterMipLevels;
-   U32 mPrefilterSize;
+protected:
+   /// The current active light manager.
+   static RenderProbeMgr* smProbeManager;
+
+   //=============================================================================
+   // Internal Management/Utility Functions
+   //=============================================================================
+
+   /// <summary>
+   /// Simple utility function that finds the next free cubemap slot for the cubemap array
+   /// </summary>
+   /// <returns>U32 index of next available slot</returns>
+   U32 _findNextEmptyCubeSlot()
+   {
+      for (U32 i = 0; i < PROBE_MAX_COUNT; i++)
+      {
+         if (!mCubeMapSlots[i])
+            return i;
+      }
+      return INVALID_CUBE_SLOT;
+   }
+
+   /// <summary>
+   /// Utility function to quickly find a ProbeRenderInst in association to a
+   /// ReflectionProbe's ProbeInfo
+   /// </summary>
+   /// <param name="probeInfo"></param>
+   /// <returns>Associated ProbeRederInst to param's probeInfo. Null if no matches found</returns>
+   ProbeRenderInst* findProbeInst(ReflectionProbe::ProbeInfo* probeInfo)
+   {
+      for (U32 i = 0; i < mRegisteredProbes.size(); i++)
+      {
+         auto asd = mRegisteredProbes[i];
+         if (mRegisteredProbes[i].mProbeInfo == probeInfo)
+         {
+            return &mRegisteredProbes[i];
+         }
+      }
+
+      return nullptr;
+   }
+
 public:
    RenderProbeMgr();
    RenderProbeMgr(RenderInstType riType, F32 renderOrder, F32 processAddOrder);
@@ -286,75 +343,139 @@ public:
    static void initPersistFields();
    static void consoleInit();
 
+   virtual void addElement(RenderInst* inst) {};
    DECLARE_CONOBJECT(RenderProbeMgr);
 
-protected:
-   /// The current active light manager.
-   static RenderProbeMgr *smProbeManager;
-
-   /// This helper function sets the shader constansts
-   /// for the stock 4 light forward lighting code.
-   void _update4ProbeConsts(const SceneData &sgData,
-      MatrixSet &matSet,
-      ProbeShaderConstants *probeShaderConsts,
-      GFXShaderConstBuffer *shaderConsts);
-
-   void _setupStaticParameters();
-   void _setupPerFrameParameters(const SceneRenderState *state);
-   virtual void addElement(RenderInst* inst) {};
-   virtual void render(SceneRenderState * state);
-
-   ProbeShaderConstants* getProbeShaderConstants(GFXShaderConstBuffer* buffer);
-
-   PostEffect* getProbeArrayEffect();
-
-
-   U32 _findNextEmptyCubeSlot()
-   {
-      for (U32 i = 0; i < PROBE_MAX_COUNT; i++)
-      {
-         if (!mCubeMapSlots[i])
-            return i;
-      }
-      return INVALID_CUBE_SLOT;
-   }
-
-public:
-   // RenderBinMgr
-   void updateProbes();
-
-   /// Returns the active LM.
-   static inline RenderProbeMgr* getProbeManager();
-
-   void registerProbe(ProbeRenderInst* newProbe);
-   void unregisterProbe(U32 probeIdx);
-   void submitProbe(const ProbeRenderInst& newProbe);
-
-   static S32 QSORT_CALLBACK _probeScoreCmp(const ProbeRenderInst* a, const  ProbeRenderInst* b);
-
-   virtual void setProbeInfo(ProcessedMaterial *pmat,
-	   const Material *mat,
-	   const SceneData &sgData,
-	   const SceneRenderState *state,
-	   U32 pass,
-	   GFXShaderConstBuffer *shaderConsts);
-
-   void setupSGData(SceneData& data, const SceneRenderState* state, LightInfo* light);
-   
-   void updateProbeTexture(ProbeRenderInst* probeInfo);
-
-   void reloadTextures();
-
-   /// Debug rendering
+   /// <summary>
+   /// Static flag used to indicate if probes should be rendered at all. Used for debugging
+   /// </summary>
    static bool smRenderReflectionProbes;
 
-   void bakeProbe(ReflectionProbe *probeInfo);
+   //=============================================================================
+   // Utility functions for processing and setting up the probes for rendering
+   //=============================================================================
+
+   /// <summary>
+   /// Sorts probes based on their score values. These scores are calculated by the probes themselves based on size, distance from camera, etc
+   /// </summary>
+   static S32 QSORT_CALLBACK _probeScoreCmp(const ProbeRenderInst* a, const  ProbeRenderInst* b);
+
+   /// <summary>
+   /// Builds a dataset of the best probes to be rendered this frame.
+   /// </summary>
+   /// <param name="objPosition"></param>
+   /// <param name="probeDataSet"></param>
+
+   void getBestProbes(const Point3F& objPosition, ProbeDataSet* probeDataSet);
+
+   /// <summary>
+   /// This function adds a ReflectionProbe to the registered list and also allocates
+   /// a slot in the cubemap array pair for its use
+   /// </summary>
+   /// <param name="probeInfo">The probe info to be registered to the bin</param>
+   void registerProbe(ReflectionProbe::ProbeInfo* probeInfo);
+
+   /// <summary>
+   /// This function removes the ReflectionProbe from the registered list, and marks it's cubemap
+   /// array slots as unused, allowing them to be freed.
+   /// </summary>
+   /// <param name="probeInfo">The probe info to be un-registered to the bin</param>
+   void unregisterProbe(ReflectionProbe::ProbeInfo* probeInfo);
+
+   /// <summary>
+   /// This function is for registering a ReflectionProbe's probe info
+   /// as being rendered in the current frame. This is distinct from
+   /// registered probes in that registered probes are any 'real' probe
+   /// in the scene, but they may not necessarily render
+   /// Active(submmitted) probes are intended to actual be rendered this frame
+   /// </summary>
+   /// <param name="probe">The ProbeInfo being submitted to be rendered</param>
+   void submitProbe(ReflectionProbe::ProbeInfo* probe);
+
+   /// <summary>
+   /// Gets the PostEffect used by the bin for rendering the probe array in deferred
+   /// </summary>
+   /// <returns>the PostEffect object</returns>
+   PostEffect* getProbeArrayEffect();
+
+   /// <summary>
+   /// Finds the associated cubemap array slot for the incoming ProbeInfo and updates the array's texture(s) from it
+   /// </summary>
+   /// <param name="probeInfo"></param>
+   void updateProbeTexture(ReflectionProbe::ProbeInfo* probeInfo);
+
+   /// <summary>
+   /// Forces an update for all registered probes' cubemaps
+   /// </summary>
+   void reloadTextures();
+
+   /// <summary>
+   /// Takes a reflection probe and runs the cubemap bake process on it, outputting the resulting files to disk
+   /// </summary>
+   void bakeProbe(ReflectionProbe* probe);
+
+   /// <summary>
+   /// Runs the cubemap bake on all probes in the current scene
+   /// </summary>
    void bakeProbes();
 
-   void getProbeTextureData(ProbeTextureArrayData* probeTextureSet);
-   S32 getSkylightIndex() { return mSkylightCubemapIdx; }
-   //accumulates the best fit of probes given the object position
-   void getBestProbes(const Point3F& objPosition, ProbeDataSet* probeDataSet);
+   /// <summary>
+   /// Returns the active Probe Manager.
+   /// </summary>
+   static inline RenderProbeMgr* getProbeManager();
+
+   //=============================================================================
+   // Forward Rendering functions
+   //=============================================================================
+
+   /// <summary>
+   /// This function returns or builds a ProbeShaderConsts containing needed data for
+   /// rendering probes in forward mode
+   /// </summary>
+   /// <param name="buffer">The GFXShaderConstBuffer used to build or fetch the Probe Consts</param>
+   ProbeShaderConstants* getProbeShaderConstants(GFXShaderConstBuffer* buffer);
+
+   /// <summary>
+   /// Sets up the probe data required for doing a render in forward mode.
+   /// </summary>
+   virtual void setProbeInfo(ProcessedMaterial* pmat,
+      const Material* mat,
+      const SceneData& sgData,
+      const SceneRenderState* state,
+	   U32 pass,
+      GFXShaderConstBuffer* shaderConsts);
+
+   /// <summary>
+   /// Invoked as part of the setup in preperation to render an object in forward mode. Used to ensure the probes are
+   /// sorted ahead of render.
+   /// </summary>
+   /// <param name="state"></param>
+   void setupSGData(SceneData& data, const SceneRenderState* state, LightInfo* light);
+   
+   /// <summary>
+   /// Sets up and binds all the shader const data required for rendering probes/IBL for a forward-rendered material.
+   /// </summary>
+   /// <returns></returns>
+   void _update4ProbeConsts(const SceneData& sgData,
+      MatrixSet& matSet,
+      ProbeShaderConstants* probeShaderConsts,
+      GFXShaderConstBuffer* shaderConsts);
+
+   //=============================================================================
+   // Deferred Rendering Functions
+   //=============================================================================
+
+   /// <summary>
+   /// Ensures the probes are properly sorted before we render them in deferred mode
+   /// </summary>
+   void _setupPerFrameParameters(const SceneRenderState *state);
+
+   /// <summary>
+   /// Renders the sorted probes list via a PostEffect to draw them into the buffer data in deferred mode.
+   /// </summary>
+   virtual void render(SceneRenderState * state);
+
+   virtual void clear() { mActiveProbes.clear(); Parent::clear(); }
 };
 
 RenderProbeMgr* RenderProbeMgr::getProbeManager()
diff --git a/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp b/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
index 69af7ef5c..94b457c75 100644
--- a/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
+++ b/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
@@ -758,7 +758,7 @@ Var* ShaderFeatureGLSL::getWsView( Var *wsPosition, MultiLine *meta )
          eyePos->constSortPos = cspPass;
       }
 		
-      meta->addStatement( new GenOp( "   @ = normalize( @ - @ );\r\n", 
+      meta->addStatement( new GenOp( "   @ = @ - @;\r\n", 
 												new DecOp( wsView ), eyePos, wsPosition ) );
    }
 	
@@ -838,79 +838,66 @@ Var* ShaderFeatureGLSL::addOutDetailTexCoord(   Vector<ShaderComponent*> &compon
 
 Var* ShaderFeatureGLSL::getSurface(Vector<ShaderComponent*>& componentList, MultiLine* meta, const MaterialFeatureData& fd)
 {
-   ShaderConnector* connectComp = dynamic_cast<ShaderConnector*>(componentList[C_CONNECTOR]);
-
-   Var* diffuseColor = (Var*)LangElement::find(getOutputTargetVarName(ShaderFeature::DefaultTarget));
-
-   Var* ormConfig = (Var*)LangElement::find("ORMConfig");
-   if (!ormConfig)
-   {
-      Var* metalness = (Var*)LangElement::find("metalness");
-      if (!metalness)
-      {
-         metalness = new Var("metalness", "float");
-         metalness->uniform = true;
-         metalness->constSortPos = cspPotentialPrimitive;
-      }
-
-      Var* roughness = (Var*)LangElement::find("roughness");
-      if (!roughness)
-      {
-         roughness = new Var("roughness", "float");
-         roughness->uniform = true;
-         roughness->constSortPos = cspPotentialPrimitive;
-      }
-
-      ormConfig = new Var("ORMConfig", "vec4");
-      LangElement* colorDecl = new DecOp(ormConfig);
-      meta->addStatement(new GenOp("   @ = vec4(0.0,1.0,@,@);\r\n", colorDecl, roughness, metalness)); //reconstruct ormConfig, no ao darkening
-   }
-
-   Var* normal = (Var*)LangElement::find("normal");
-   if (!normal)
-   {
-      normal = new Var("normal", "vec3");
-      meta->addStatement(new GenOp("  @;\r\n\n", new DecOp(normal)));
-
-      Var* wsNormal = (Var*)LangElement::find("wsNormal");
-      if (!fd.features[MFT_NormalMap])
-      {
-         if (!wsNormal)
-            wsNormal = getInWorldNormal(componentList);
-         meta->addStatement(new GenOp("  @ = normalize( @ );\r\n\n", normal, wsNormal));
-      }
-      else
-      {
-         meta->addStatement(new GenOp("   @ = normalize(  @ );\r\n", normal, wsNormal));
-      }
-   }
-
-   Var* wsEyePos = (Var*)LangElement::find("eyePosWorld");
-
-   if (!wsEyePos)
-   {
-      wsEyePos = new Var("eyePosWorld", "vec3");
-      wsEyePos->uniform = true;
-      wsEyePos->constSortPos = cspPass;
-   }
-
-   Var* wsPosition = getInWsPosition(componentList);
-   Var* wsView = getWsView(wsPosition, meta);
-
-   Var* surface = (Var*)LangElement::find("surface");
+   Var *surface = (Var *)LangElement::find("surface");
 
    if (!surface)
    {
+	   Var* diffuseColor = (Var*)LangElement::find(getOutputTargetVarName(ShaderFeature::DefaultTarget));
+	
+	   Var* ormConfig = (Var*)LangElement::find("ORMConfig");
+	   if (!ormConfig)
+	   {
+	      Var* metalness = (Var*)LangElement::find("metalness");
+	      if (!metalness)
+	      {
+	         metalness = new Var("metalness", "float");
+	         metalness->uniform = true;
+	         metalness->constSortPos = cspPotentialPrimitive;
+	      }
+	
+	      Var* roughness = (Var*)LangElement::find("roughness");
+	      if (!roughness)
+	      {
+	         roughness = new Var("roughness", "float");
+	         roughness->uniform = true;
+	         roughness->constSortPos = cspPotentialPrimitive;
+	      }
+	
+	      ormConfig = new Var("ORMConfig", "vec4");
+	      LangElement* colorDecl = new DecOp(ormConfig);
+	      meta->addStatement(new GenOp("   @ = vec4(0.0,1.0,@,@);\r\n", colorDecl, roughness, metalness)); //reconstruct ormConfig, no ao darkening
+	   }
+	
+	   Var* normal = (Var*)LangElement::find("normal");
+	   if (!normal)
+	   {
+	      normal = new Var("normal", "vec3");
+	      meta->addStatement(new GenOp("  @;\r\n\n", new DecOp(normal)));
+	
+         Var *wsNormal = (Var *)LangElement::find("wsNormal");
+	         if (!wsNormal)
+	            wsNormal = getInWorldNormal(componentList);
+
+	         meta->addStatement(new GenOp("   @ = normalize(  @ );\r\n", normal, wsNormal));
+	      }
+	
+	   Var* wsEyePos = (Var*)LangElement::find("eyePosWorld");
+	
+	   if (!wsEyePos)
+	   {
+	      wsEyePos = new Var("eyePosWorld", "vec3");
+	      wsEyePos->uniform = true;
+	      wsEyePos->constSortPos = cspPass;
+	   }
+	
+	   Var* wsPosition = getInWsPosition(componentList);
+	   Var* wsView = getWsView(wsPosition, meta);
+
       surface = new Var("surface", "Surface");
-      meta->addStatement(new GenOp("  @ = createForwardSurface(@,@,@,@,@,@);\r\n\n", new DecOp(surface), diffuseColor, normal, ormConfig,
+      meta->addStatement(new GenOp("  @ = createForwardSurface(@,normalize(@),@,@,@,@);\r\n\n", new DecOp(surface), diffuseColor, normal, ormConfig,
          wsPosition, wsEyePos, wsView));
    }
 
-   /*Var* surface = (Var*)LangElement::find("surface");
-   if (!surface)
-   {
-      surface = new Var("surface", "float");
-   }*/
    return surface;
 }
 //****************************************************************************
@@ -3003,12 +2990,12 @@ void ReflectionProbeFeatGLSL::processPix(Vector<ShaderComponent*>& componentList
    inRefPosArray->uniform = true;
    inRefPosArray->constSortPos = cspPotentialPrimitive;
 
-   Var * refScaleArray = new Var("inRefScale", "vec4");
+   Var * refScaleArray = new Var("inRefScaleArray", "vec4");
    refScaleArray->arraySize = MAX_FORWARD_PROBES;
    refScaleArray->uniform = true;
    refScaleArray->constSortPos = cspPotentialPrimitive;
 
-   Var * probeConfigData = new Var("inProbeConfigData", "vec4");
+   Var * probeConfigData = new Var("inProbeConfigDataArray", "vec4");
    probeConfigData->arraySize = MAX_FORWARD_PROBES;
    probeConfigData->uniform = true;
    probeConfigData->constSortPos = cspPotentialPrimitive;
@@ -3026,12 +3013,12 @@ void ReflectionProbeFeatGLSL::processPix(Vector<ShaderComponent*>& componentList
    BRDFTexture->sampler = true;
    BRDFTexture->constNum = Var::getTexUnitNum();     // used as texture unit num here
    
-   Var * specularCubemapAR = new Var("inSpecularCubemapAR", "samplerCubeArray");
+   Var * specularCubemapAR = new Var("SpecularCubemapAR", "samplerCubeArray");
    specularCubemapAR->uniform = true;
    specularCubemapAR->sampler = true;
    specularCubemapAR->constNum = Var::getTexUnitNum();
 
-   Var * irradianceCubemapAR = new Var("inIrradianceCubemapAR", "samplerCubeArray");
+   Var * irradianceCubemapAR = new Var("IrradianceCubemapAR", "samplerCubeArray");
    irradianceCubemapAR->uniform = true;
    irradianceCubemapAR->sampler = true;
    irradianceCubemapAR->constNum = Var::getTexUnitNum();
@@ -3044,14 +3031,24 @@ void ReflectionProbeFeatGLSL::processPix(Vector<ShaderComponent*>& componentList
       return;
    }
 
+   Var* eyePos = (Var*)LangElement::find("eyePosWorld");
+   if (!eyePos)
+   {
+      eyePos = new Var;
+      eyePos->setType("vec3");
+      eyePos->setName("eyePosWorld");
+      eyePos->uniform = true;
+      eyePos->constSortPos = cspPotentialPrimitive;
+   }
+
    Var *curColor = (Var*)LangElement::find(getOutputTargetVarName(ShaderFeature::DefaultTarget));
       
    //Reflection vec
-   String computeForwardProbes = String("   @.rgb = computeForwardProbes(@,@,@,@,@,@,@,@,\r\n\t\t");
+   String computeForwardProbes = String("   @.rgb = computeForwardProbes(@,@,@,@,@,@,@,@,@,\r\n\t\t");
    computeForwardProbes += String("@,@,\r\n\t\t");
    computeForwardProbes += String("@,@).rgb; \r\n");
 
-   meta->addStatement(new GenOp(computeForwardProbes.c_str(), curColor, surface, cubeMips, numProbes, worldToObjArray, probeConfigData, inProbePosArray, refScaleArray, inRefPosArray,
+   meta->addStatement(new GenOp(computeForwardProbes.c_str(), curColor, surface, cubeMips, numProbes, worldToObjArray, probeConfigData, inProbePosArray, refScaleArray, inRefPosArray, eyePos,
       skylightCubemapIdx, BRDFTexture,
       irradianceCubemapAR, specularCubemapAR));
 
@@ -3078,9 +3075,9 @@ void ReflectionProbeFeatGLSL::setTexData(Material::StageData& stageDat,
       passData.mSamplerNames[texIndex] = "BRDFTexture";
       passData.mTexType[texIndex++] = Material::Standard;
       // assuming here that it is a scenegraph cubemap
-      passData.mSamplerNames[texIndex] = "inSpecularCubemapAR";
+      passData.mSamplerNames[texIndex] = "SpecularCubemapAR";
       passData.mTexType[texIndex++] = Material::SGCube;
-      passData.mSamplerNames[texIndex] = "inIrradianceCubemapAR";
+      passData.mSamplerNames[texIndex] = "IrradianceCubemapAR";
       passData.mTexType[texIndex++] = Material::SGCube;
    }
 }
diff --git a/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp b/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
index c53e939e0..a294f5f85 100644
--- a/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
+++ b/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
@@ -764,7 +764,7 @@ Var* ShaderFeatureHLSL::getWsView( Var *wsPosition, MultiLine *meta )
          eyePos->constSortPos = cspPass;
       }
 
-      meta->addStatement( new GenOp( "   @ = normalize( @ - @ );\r\n", 
+      meta->addStatement( new GenOp( "   @ = @ - @;\r\n", 
          new DecOp( wsView ), eyePos, wsPosition ) );
    }
 
@@ -844,14 +844,16 @@ Var* ShaderFeatureHLSL::addOutDetailTexCoord(   Vector<ShaderComponent*> &compon
 
 Var* ShaderFeatureHLSL::getSurface(Vector<ShaderComponent*>& componentList, MultiLine* meta, const MaterialFeatureData& fd)
 {
-   ShaderConnector* connectComp = dynamic_cast<ShaderConnector*>(componentList[C_CONNECTOR]);
+   Var *surface = (Var *)LangElement::find("surface");
 
-   Var* diffuseColor = (Var*)LangElement::find(getOutputTargetVarName(ShaderFeature::DefaultTarget));
+   if (!surface)
+   {
+      Var *diffuseColor = (Var *)LangElement::find(getOutputTargetVarName(ShaderFeature::DefaultTarget));
 
-   Var* ormConfig = (Var*)LangElement::find("ORMConfig");
+      Var *ormConfig = (Var *)LangElement::find("ORMConfig");
    if (!ormConfig)
    {
-      Var* metalness = (Var*)LangElement::find("metalness");
+         Var *metalness = (Var *)LangElement::find("metalness");
       if (!metalness)
       {
          metalness = new Var("metalness", "float");
@@ -859,7 +861,7 @@ Var* ShaderFeatureHLSL::getSurface(Vector<ShaderComponent*>& componentList, Mult
          metalness->constSortPos = cspPotentialPrimitive;
       }
 
-      Var* roughness = (Var*)LangElement::find("roughness");
+         Var *roughness = (Var *)LangElement::find("roughness");
       if (!roughness)
       {
          roughness = new Var("roughness", "float");
@@ -868,30 +870,24 @@ Var* ShaderFeatureHLSL::getSurface(Vector<ShaderComponent*>& componentList, Mult
       }
 
       ormConfig = new Var("ORMConfig", "float4");
-      LangElement* colorDecl = new DecOp(ormConfig);
+         LangElement *colorDecl = new DecOp(ormConfig);
       meta->addStatement(new GenOp("   @ = float4(0.0,1.0,@,@);\r\n", colorDecl, roughness, metalness)); //reconstruct matinfo, no ao darkening
    }
 
-   Var* normal = (Var*)LangElement::find("normal");
+      Var *normal = (Var *)LangElement::find("normal");
    if (!normal)
    {
       normal = new Var("normal", "float3");
       meta->addStatement(new GenOp("  @;\r\n\n", new DecOp(normal)));
 
-      Var* wsNormal = (Var*)LangElement::find("wsNormal");
-      if (!fd.features[MFT_NormalMap])
-      {
+         Var *wsNormal = (Var *)LangElement::find("wsNormal");
          if (!wsNormal)
             wsNormal = getInWorldNormal(componentList);
-         meta->addStatement(new GenOp("  @ = normalize( @ );\r\n\n", normal, wsNormal));
-      }
-      else
-      {
+
          meta->addStatement(new GenOp("   @ = normalize(  @ );\r\n", normal, wsNormal));
       }      
-   }
 
-   Var* wsEyePos = (Var*)LangElement::find("eyePosWorld");
+      Var *wsEyePos = (Var *)LangElement::find("eyePosWorld");
 
    if (!wsEyePos)
    {
@@ -900,15 +896,11 @@ Var* ShaderFeatureHLSL::getSurface(Vector<ShaderComponent*>& componentList, Mult
       wsEyePos->constSortPos = cspPass;
    }
 
-   Var* wsPosition = getInWsPosition(componentList);
-   Var* wsView = getWsView(wsPosition, meta);
+      Var *wsPosition = getInWsPosition(componentList);
+      Var *wsView = getWsView(wsPosition, meta);
 
-   Var* surface = (Var*)LangElement::find("surface");
-
-   if (!surface)
-   {
       surface = new Var("surface", "Surface");
-      meta->addStatement(new GenOp("  @ = createForwardSurface(@,@,@,@,@,@);\r\n\n", new DecOp(surface), diffuseColor, normal, ormConfig,
+      meta->addStatement(new GenOp("  @ = createForwardSurface(@,normalize(@),@,@,@,@);\r\n\n", new DecOp(surface), diffuseColor, normal, ormConfig,
          wsPosition, wsEyePos, wsView));
    }
 
@@ -3076,12 +3068,12 @@ void ReflectionProbeFeatHLSL::processPix(Vector<ShaderComponent*> &componentList
    inRefPosArray->uniform = true;
    inRefPosArray->constSortPos = cspPotentialPrimitive;
 
-   Var * refScaleArray = new Var("inRefScale", "float4");
+   Var * refScaleArray = new Var("inRefScaleArray", "float4");
    refScaleArray->arraySize = MAX_FORWARD_PROBES;
    refScaleArray->uniform = true;
    refScaleArray->constSortPos = cspPotentialPrimitive;
 
-   Var *probeConfigData = new Var("inProbeConfigData", "float4");
+   Var *probeConfigData = new Var("inProbeConfigDataArray", "float4");
    probeConfigData->arraySize = MAX_FORWARD_PROBES;
    probeConfigData->uniform = true;
    probeConfigData->constSortPos = cspPotentialPrimitive;
@@ -3101,22 +3093,22 @@ void ReflectionProbeFeatHLSL::processPix(Vector<ShaderComponent*> &componentList
    BRDFTextureTex->texture = true;
    BRDFTextureTex->constNum = BRDFTexture->constNum;
 
-   Var *specularCubemapAR = new Var("inSpecularCubemapAR", "SamplerState");
+   Var *specularCubemapAR = new Var("SpecularCubemapAR", "SamplerState");
    specularCubemapAR->uniform = true;
    specularCubemapAR->sampler = true;
    specularCubemapAR->constNum = Var::getTexUnitNum();     // used as texture unit num here
 
-   Var *specularCubemapARTex = new Var("texture_inSpecularCubemapAR", "TextureCubeArray");
+   Var *specularCubemapARTex = new Var("texture_SpecularCubemapAR", "TextureCubeArray");
    specularCubemapARTex->uniform = true;
    specularCubemapARTex->texture = true;
    specularCubemapARTex->constNum = specularCubemapAR->constNum;
 
-   Var *irradianceCubemapAR = new Var("inIrradianceCubemapAR", "SamplerState");
+   Var *irradianceCubemapAR = new Var("IrradianceCubemapAR", "SamplerState");
    irradianceCubemapAR->uniform = true;
    irradianceCubemapAR->sampler = true;
    irradianceCubemapAR->constNum = Var::getTexUnitNum();     // used as texture unit num here
 
-   Var *irradianceCubemapARTex = new Var("texture_inIrradianceCubemapAR", "TextureCubeArray");
+   Var *irradianceCubemapARTex = new Var("texture_IrradianceCubemapAR", "TextureCubeArray");
    irradianceCubemapARTex->uniform = true;
    irradianceCubemapARTex->texture = true;
    irradianceCubemapARTex->constNum = irradianceCubemapAR->constNum;
@@ -3138,11 +3130,21 @@ void ReflectionProbeFeatHLSL::processPix(Vector<ShaderComponent*> &componentList
       ibl = new Var("ibl", "float3");
    }
 
-   String computeForwardProbes = String("   @ = computeForwardProbes(@,@,@,@,@,@,@,@,\r\n\t\t");
+   Var* eyePos = (Var*)LangElement::find("eyePosWorld");
+   if (!eyePos)
+   {
+      eyePos = new Var;
+      eyePos->setType("float3");
+      eyePos->setName("eyePosWorld");
+      eyePos->uniform = true;
+      eyePos->constSortPos = cspPass;
+   }
+
+   String computeForwardProbes = String("   @ = computeForwardProbes(@,@,@,@,@,@,@,@,@,\r\n\t\t");
    computeForwardProbes += String("@,TORQUE_SAMPLER2D_MAKEARG(@),\r\n\t\t"); 
    computeForwardProbes += String("TORQUE_SAMPLERCUBEARRAY_MAKEARG(@),TORQUE_SAMPLERCUBEARRAY_MAKEARG(@)).rgb; \r\n");
       
-   meta->addStatement(new GenOp(computeForwardProbes.c_str(), new DecOp(ibl), surface, cubeMips, numProbes, worldToObjArray, probeConfigData, inProbePosArray, refScaleArray, inRefPosArray,
+   meta->addStatement(new GenOp(computeForwardProbes.c_str(), new DecOp(ibl), surface, cubeMips, numProbes, worldToObjArray, probeConfigData, inProbePosArray, refScaleArray, inRefPosArray, eyePos,
       skylightCubemapIdx, BRDFTexture,
       irradianceCubemapAR, specularCubemapAR));
 
@@ -3171,9 +3173,9 @@ void ReflectionProbeFeatHLSL::setTexData(Material::StageData &stageDat,
       passData.mSamplerNames[texIndex] = "BRDFTexture";
       passData.mTexType[texIndex++] = Material::Standard;
       // assuming here that it is a scenegraph cubemap
-      passData.mSamplerNames[texIndex] = "inSpecularCubemapAR";
+      passData.mSamplerNames[texIndex] = "SpecularCubemapAR";
       passData.mTexType[texIndex++] = Material::SGCube;
-      passData.mSamplerNames[texIndex] = "inIrradianceCubemapAR";
+      passData.mSamplerNames[texIndex] = "IrradianceCubemapAR";
       passData.mTexType[texIndex++] = Material::SGCube;
    }
 }
diff --git a/Engine/source/shaderGen/shaderGenVars.cpp b/Engine/source/shaderGen/shaderGenVars.cpp
index 839a4c36b..e7e7296c1 100644
--- a/Engine/source/shaderGen/shaderGenVars.cpp
+++ b/Engine/source/shaderGen/shaderGenVars.cpp
@@ -80,17 +80,19 @@ const String ShaderGenVars::glowMul("$glowMul");
 
 //Reflection Probes - Forward lit. not to be confused with the deferred handwritten vars
 //change to parity once we've got the same arrays used for both routes
-const String ShaderGenVars::probePosition("$inProbePosArray");
-const String ShaderGenVars::probeRefPos("$inRefPosArray");
-const String ShaderGenVars::refScale("$inRefScale");
+const String ShaderGenVars::probePositionArray("$inProbePosArray");
+const String ShaderGenVars::probeRefPosArray("$inRefPosArray");
+const String ShaderGenVars::refScaleArray("$inRefScaleArray");
 const String ShaderGenVars::worldToObjArray("$inWorldToObjArray");
-const String ShaderGenVars::probeConfigData("$inProbeConfigData");
-const String ShaderGenVars::specularCubemapAR("$inSpecularCubemapAR");
-const String ShaderGenVars::irradianceCubemapAR("$inIrradianceCubemapAR");
+const String ShaderGenVars::probeConfigDataArray("$inProbeConfigDataArray");
+const String ShaderGenVars::specularCubemapAR("$SpecularCubemapAR");
+const String ShaderGenVars::irradianceCubemapAR("$IrradianceCubemapAR");
 const String ShaderGenVars::probeCount("$inNumProbes");
 
 const String ShaderGenVars::BRDFTextureMap("$BRDFTexture");
 
+const String ShaderGenVars::maxProbeDrawDistance("$maxProbeDrawDistance");
+
 //Skylight
 const String ShaderGenVars::skylightCubemapIdx("$inSkylightCubemapIdx");
 
diff --git a/Engine/source/shaderGen/shaderGenVars.h b/Engine/source/shaderGen/shaderGenVars.h
index 6c32d4522..c32d97c94 100644
--- a/Engine/source/shaderGen/shaderGenVars.h
+++ b/Engine/source/shaderGen/shaderGenVars.h
@@ -91,17 +91,19 @@ struct ShaderGenVars
    const static String glowMul;
 
    //Reflection Probes
-   const static String probePosition;
-   const static String probeRefPos;
-   const static String refScale;
+   const static String probePositionArray;
+   const static String probeRefPosArray;
+   const static String refScaleArray;
    const static String worldToObjArray;
-   const static String probeConfigData;
+   const static String probeConfigDataArray;
    const static String specularCubemapAR;
    const static String irradianceCubemapAR;
    const static String probeCount;
 
    const static String BRDFTextureMap;
 
+   const static String maxProbeDrawDistance;
+
    //Skylight
    const static String skylightCubemapIdx;
    
diff --git a/Templates/BaseGame/game/core/postFX/scripts/ReflectionProbes/reflectionProbeArrayPostFX.tscript b/Templates/BaseGame/game/core/postFX/scripts/ReflectionProbes/reflectionProbeArrayPostFX.tscript
index c5811c34b..879ec5774 100644
--- a/Templates/BaseGame/game/core/postFX/scripts/ReflectionProbes/reflectionProbeArrayPostFX.tscript
+++ b/Templates/BaseGame/game/core/postFX/scripts/ReflectionProbes/reflectionProbeArrayPostFX.tscript
@@ -15,4 +15,6 @@ singleton PostEffect( reflectionProbeArrayPostFX )
    texture[0] = "#deferred";
    texture[1] = "#color";
    texture[2] = "#matinfo";
+
+   allowReflectPass = true;
 };
diff --git a/Templates/BaseGame/game/core/rendering/shaders/gl/lighting.glsl b/Templates/BaseGame/game/core/rendering/shaders/gl/lighting.glsl
index 55d9866ce..57ee38190 100644
--- a/Templates/BaseGame/game/core/rendering/shaders/gl/lighting.glsl
+++ b/Templates/BaseGame/game/core/rendering/shaders/gl/lighting.glsl
@@ -23,6 +23,8 @@
 #include "./torque.glsl"
 #include "./brdf.glsl"
 
+uniform float maxProbeDrawDistance;
+
 #ifndef TORQUE_SHADERGEN
 #line 27
 // These are the uniforms used by most lighting shaders.
@@ -330,7 +332,7 @@ float defineSphereSpaceInfluence(vec3 wsPosition, vec3 wsProbePosition, float ra
 {
    vec3 L = wsProbePosition.xyz - wsPosition;
    float contribution = 1.0 - length(L) / radius;
-   return contribution;
+   return saturate(contribution);
 }
 
 float getDistBoxToPoint(vec3 pt, vec3 extents)
@@ -342,10 +344,9 @@ float getDistBoxToPoint(vec3 pt, vec3 extents)
 float defineBoxSpaceInfluence(vec3 wsPosition, mat4 worldToObj, float attenuation)
 {
    vec3 surfPosLS = tMul(worldToObj, vec4(wsPosition, 1.0)).xyz;
-   float atten = 1.0 - attenuation;
    float baseVal = 0.25;
    float dist = getDistBoxToPoint(surfPosLS, vec3(baseVal, baseVal, baseVal));
-   return saturate(smoothstep(baseVal + 0.0001, atten*baseVal, dist));
+   return saturate(smoothstep(baseVal, (baseVal-attenuation/2), dist));
 }
 
 // Box Projected IBL Lighting
@@ -367,9 +368,9 @@ vec3 boxProject(vec3 wsPosition, vec3 wsReflectVec, mat4 worldToObj, vec3 refSca
 }
 
 vec4 computeForwardProbes(Surface surface,
-    float cubeMips, int numProbes, mat4x4 worldToObjArray[MAX_FORWARD_PROBES], vec4 probeConfigData[MAX_FORWARD_PROBES], 
-    vec4 inProbePosArray[MAX_FORWARD_PROBES], vec4 refScaleArray[MAX_FORWARD_PROBES], vec4 inRefPosArray[MAX_FORWARD_PROBES],
-    float skylightCubemapIdx, sampler2D BRDFTexture, 
+    float cubeMips, int numProbes, mat4x4 inWorldToObjArray[MAX_FORWARD_PROBES], vec4 inProbeConfigData[MAX_FORWARD_PROBES], 
+    vec4 inProbePosArray[MAX_FORWARD_PROBES], vec4 inRefScaleArray[MAX_FORWARD_PROBES], vec4 inRefPosArray[MAX_FORWARD_PROBES],
+    vec3 wsEyePos, float skylightCubemapIdx, sampler2D BRDFTexture, 
 	samplerCubeArray irradianceCubemapAR, samplerCubeArray specularCubemapAR)
 {
    int i = 0;
@@ -384,47 +385,37 @@ vec4 computeForwardProbes(Surface surface,
   for (i = 0; i < numProbes; ++i)
   {
       contribution[i] = 0;
-
-      if (probeConfigData[i].r == 0) //box
+      float atten = 1.0-(length(wsEyePos-inProbePosArray[i].xyz)/maxProbeDrawDistance);
+      if (inProbeConfigData[i].r == 0) //box
       {
-         contribution[i] = defineBoxSpaceInfluence(surface.P, worldToObjArray[i], probeConfigData[i].b);
-         if (contribution[i] > 0.0)
-            probehits++;
+         contribution[i] = defineBoxSpaceInfluence(surface.P, inWorldToObjArray[i], inProbeConfigData[i].b)*atten;
       }
-      else if (probeConfigData[i].r == 1) //sphere
+      else if (inProbeConfigData[i].r == 1) //sphere
       {
-         contribution[i] = defineSphereSpaceInfluence(surface.P, inProbePosArray[i].xyz, probeConfigData[i].g);
-         if (contribution[i] > 0.0)
-            probehits++;
+         contribution[i] = defineSphereSpaceInfluence(surface.P, inProbePosArray[i].xyz, inProbeConfigData[i].g)*atten;
       }
 
-      contribution[i] = max(contribution[i], 0);
+      if (contribution[i]>0.0)
+         probehits++;
+      else
+         contribution[i] = 0.0;
 
       blendSum += contribution[i];
-      invBlendSum += (1.0f - contribution[i]);
    }
 
-   if (probehits > 1.0)
+   if (probehits > 1.0)//if we overlap
    {
+      invBlendSum = (probehits - blendSum)/(probehits-1); //grab the remainder 
       for (i = 0; i < numProbes; i++)
       {
-         blendFactor[i] = ((contribution[i] / blendSum)) / probehits;
-         blendFactor[i] *= ((contribution[i]) / invBlendSum);
-         blendFactor[i] = saturate(blendFactor[i]);
-         blendFacSum += blendFactor[i];
+         blendFactor[i] = contribution[i]/blendSum; //what % total is this instance
+         blendFactor[i] *= blendFactor[i] / invBlendSum;  //what should we add to sum to 1
+         blendFacSum += blendFactor[i]; //running tally of results
       }
 
-      // Normalize blendVal
-      if (blendFacSum == 0.0f) // Possible with custom weight
-      {
-         blendFacSum = 1.0f;
-      }
-
-      float invBlendSumWeighted = 1.0f / blendFacSum;
       for (i = 0; i < numProbes; ++i)
       {
-         blendFactor[i] *= invBlendSumWeighted;
-         contribution[i] *= blendFactor[i];
+         contribution[i] *= blendFactor[i]/blendFacSum; //normalize
       }
    }
 
@@ -471,8 +462,8 @@ vec4 computeForwardProbes(Surface surface,
       float contrib = contribution[i];
       if (contrib > 0.0f)
       {
-         float cubemapIdx = int(probeConfigData[i].a);
-         vec3 dir = boxProject(surface.P, surface.R, worldToObjArray[i], refScaleArray[i].xyz, inRefPosArray[i].xyz);
+         float cubemapIdx = int(inProbeConfigData[i].a);
+         vec3 dir = boxProject(surface.P, surface.R, inWorldToObjArray[i], inRefScaleArray[i].xyz, inRefPosArray[i].xyz);
 
          irradiance += textureLod(irradianceCubemapAR, vec4(dir, cubemapIdx), 0).xyz * contrib;
          specular += textureLod(specularCubemapAR, vec4(dir, cubemapIdx), lod).xyz * contrib;
@@ -491,8 +482,8 @@ vec4 computeForwardProbes(Surface surface,
    vec3 kD = 1.0f - F;
    kD *= 1.0f - surface.metalness;
 
-   float dfgNdotV = max( surface.NdotV , 0.0009765625f ); //0.5f/512.0f (512 is size of dfg/brdf lookup tex)
-   vec2 envBRDF = textureLod(BRDFTexture, vec2(dfgNdotV, surface.roughness),0).rg;
+   //float dfgNdotV = max( surface.NdotV , 0.0009765625f ); //0.5f/512.0f (512 is size of dfg/brdf lookup tex)
+   vec2 envBRDF = textureLod(BRDFTexture, vec2(surface.NdotV, surface.roughness),0).rg;
    specular *= F * envBRDF.x + surface.f90 * envBRDF.y;
    irradiance *= kD * surface.baseColor.rgb;
 
@@ -504,13 +495,16 @@ vec4 computeForwardProbes(Surface surface,
    float horizonOcclusion = 1.3;
    float horizon = saturate( 1 + horizonOcclusion * dot(surface.R, surface.N));
    horizon *= horizon;
-
+#if CAPTURING == 1
+    return vec4(mix(surface.baseColor.rgb,(irradiance + specular) * horizon,surface.metalness/2),0);
+#else
    return vec4((irradiance + specular) * horizon, 0);//alpha writes disabled
+#endif
 }
 
 vec4 debugVizForwardProbes(Surface surface,
-    float cubeMips, int numProbes, mat4 worldToObjArray[MAX_FORWARD_PROBES], vec4 probeConfigData[MAX_FORWARD_PROBES], 
-    vec4 inProbePosArray[MAX_FORWARD_PROBES], vec4 refScaleArray[MAX_FORWARD_PROBES], vec4 inRefPosArray[MAX_FORWARD_PROBES],
+    float cubeMips, int numProbes, mat4 inWorldToObjArray[MAX_FORWARD_PROBES], vec4 inProbeConfigData[MAX_FORWARD_PROBES], 
+    vec4 inProbePosArray[MAX_FORWARD_PROBES], vec4 inRefScaleArray[MAX_FORWARD_PROBES], vec4 inRefPosArray[MAX_FORWARD_PROBES],
     float skylightCubemapIdx, sampler2D BRDFTexture, 
 	 samplerCubeArray irradianceCubemapAR, samplerCubeArray specularCubemapAR, int showAtten, int showContrib, int showSpec, int showDiff)
 {
@@ -527,15 +521,15 @@ vec4 debugVizForwardProbes(Surface surface,
   {
       contribution[i] = 0;
 
-      if (probeConfigData[i].r == 0) //box
+      if (inProbeConfigData[i].r == 0) //box
       {
-         contribution[i] = defineBoxSpaceInfluence(surface.P, worldToObjArray[i], probeConfigData[i].b);
+         contribution[i] = defineBoxSpaceInfluence(surface.P, inWorldToObjArray[i], inProbeConfigData[i].b);
          if (contribution[i] > 0.0)
             probehits++;
       }
-      else if (probeConfigData[i].r == 1) //sphere
+      else if (inProbeConfigData[i].r == 1) //sphere
       {
-         contribution[i] = defineSphereSpaceInfluence(surface.P, inProbePosArray[i].xyz, probeConfigData[i].g);
+         contribution[i] = defineSphereSpaceInfluence(surface.P, inProbePosArray[i].xyz, inProbeConfigData[i].g);
          if (contribution[i] > 0.0)
             probehits++;
       }
@@ -620,8 +614,8 @@ vec4 debugVizForwardProbes(Surface surface,
       float contrib = contribution[i];
       if (contrib > 0.0f)
       {
-         float cubemapIdx = probeConfigData[i].a;
-         vec3 dir = boxProject(surface.P, surface.R, worldToObjArray[i], refScaleArray[i].xyz, inRefPosArray[i].xyz);
+         float cubemapIdx = inProbeConfigData[i].a;
+         vec3 dir = boxProject(surface.P, surface.R, inWorldToObjArray[i], inRefScaleArray[i].xyz, inRefPosArray[i].xyz);
 
          irradiance += textureLod(irradianceCubemapAR, vec4(dir, cubemapIdx), 0).xyz * contrib;
          specular += textureLod(specularCubemapAR, vec4(dir, cubemapIdx), lod).xyz * contrib;
diff --git a/Templates/BaseGame/game/core/rendering/shaders/lighting.hlsl b/Templates/BaseGame/game/core/rendering/shaders/lighting.hlsl
index c91bd21a1..2a52e6eeb 100644
--- a/Templates/BaseGame/game/core/rendering/shaders/lighting.hlsl
+++ b/Templates/BaseGame/game/core/rendering/shaders/lighting.hlsl
@@ -24,6 +24,9 @@
 #include "./brdf.hlsl"
 #include "./shaderModelAutoGen.hlsl"
 
+//globals
+uniform float3 eyePosWorld;
+uniform float maxProbeDrawDistance;
 #ifndef TORQUE_SHADERGEN
 
 // These are the uniforms used by most lighting shaders.
@@ -333,7 +336,7 @@ float defineSphereSpaceInfluence(float3 wsPosition, float3 wsProbePosition, floa
 {
    float3 L = wsProbePosition.xyz - wsPosition;
    float contribution = 1.0 - length(L) / radius;
-   return contribution;
+   return saturate(contribution);
 }
 
 float getDistBoxToPoint(float3 pt, float3 extents)
@@ -345,10 +348,9 @@ float getDistBoxToPoint(float3 pt, float3 extents)
 float defineBoxSpaceInfluence(float3 wsPosition, float4x4 worldToObj, float attenuation)
 {
    float3 surfPosLS = mul(worldToObj, float4(wsPosition, 1.0)).xyz;
-   float atten = 1.0 - attenuation;
    float baseVal = 0.25;
    float dist = getDistBoxToPoint(surfPosLS, float3(baseVal, baseVal, baseVal));
-   return saturate(smoothstep(baseVal + 0.0001, atten*baseVal, dist));
+   return saturate(smoothstep(baseVal, (baseVal-attenuation/2), dist));
 }
 
 // Box Projected IBL Lighting
@@ -370,9 +372,9 @@ float3 boxProject(float3 wsPosition, float3 wsReflectVec, float4x4 worldToObj, f
 }
 
 float4 computeForwardProbes(Surface surface,
-    float cubeMips, int numProbes, float4x4 worldToObjArray[MAX_FORWARD_PROBES], float4 probeConfigData[MAX_FORWARD_PROBES], 
-    float4 inProbePosArray[MAX_FORWARD_PROBES], float4 refScaleArray[MAX_FORWARD_PROBES], float4 inRefPosArray[MAX_FORWARD_PROBES],
-    float skylightCubemapIdx, TORQUE_SAMPLER2D(BRDFTexture), 
+    float cubeMips, int numProbes, float4x4 inWorldToObjArray[MAX_FORWARD_PROBES], float4 inProbeConfigData[MAX_FORWARD_PROBES], 
+    float4 inProbePosArray[MAX_FORWARD_PROBES], float4 inRefScaleArray[MAX_FORWARD_PROBES], float4 inRefPosArray[MAX_FORWARD_PROBES],
+    float3 wsEyePos, float skylightCubemapIdx, TORQUE_SAMPLER2D(BRDFTexture), 
 	 TORQUE_SAMPLERCUBEARRAY(irradianceCubemapAR), TORQUE_SAMPLERCUBEARRAY(specularCubemapAR))
 {
    int i = 0;
@@ -384,50 +386,41 @@ float4 computeForwardProbes(Surface surface,
    float probehits = 0;
    //Set up our struct data
    float contribution[MAX_FORWARD_PROBES];
+   //Process prooooobes
   for (i = 0; i < numProbes; ++i)
   {
-      contribution[i] = 0;
-
-      if (probeConfigData[i].r == 0) //box
+      contribution[i] = 0.0;
+      float atten = 1.0-(length(wsEyePos-inProbePosArray[i].xyz)/maxProbeDrawDistance);
+      if (inProbeConfigData[i].r == 0) //box
       {
-         contribution[i] = defineBoxSpaceInfluence(surface.P, worldToObjArray[i], probeConfigData[i].b);
-         if (contribution[i] > 0.0)
-            probehits++;
+         contribution[i] = defineBoxSpaceInfluence(surface.P, inWorldToObjArray[i], inProbeConfigData[i].b)*atten;
       }
-      else if (probeConfigData[i].r == 1) //sphere
+      else if (inProbeConfigData[i].r == 1) //sphere
       {
-         contribution[i] = defineSphereSpaceInfluence(surface.P, inProbePosArray[i].xyz, probeConfigData[i].g);
-         if (contribution[i] > 0.0)
-            probehits++;
+         contribution[i] = defineSphereSpaceInfluence(surface.P, inProbePosArray[i].xyz, inProbeConfigData[i].g)*atten;
       }
 
-      contribution[i] = max(contribution[i], 0);
+      if (contribution[i]>0.0)
+         probehits++;
+      else
+         contribution[i] = 0.0;
 
       blendSum += contribution[i];
-      invBlendSum += (1.0f - contribution[i]);
    }
 
-   if (probehits > 1.0)
+   if (probehits > 1.0)//if we overlap
    {
+      invBlendSum = (probehits - blendSum)/(probehits-1); //grab the remainder 
       for (i = 0; i < numProbes; i++)
       {
-         blendFactor[i] = ((contribution[i] / blendSum)) / probehits;
-         blendFactor[i] *= ((contribution[i]) / invBlendSum);
-         blendFactor[i] = saturate(blendFactor[i]);
-         blendFacSum += blendFactor[i];
+         blendFactor[i] = contribution[i]/blendSum; //what % total is this instance
+         blendFactor[i] *= blendFactor[i] / invBlendSum;  //what should we add to sum to 1
+         blendFacSum += blendFactor[i]; //running tally of results
       }
 
-      // Normalize blendVal
-      if (blendFacSum == 0.0f) // Possible with custom weight
-      {
-         blendFacSum = 1.0f;
-      }
-
-      float invBlendSumWeighted = 1.0f / blendFacSum;
       for (i = 0; i < numProbes; ++i)
       {
-         blendFactor[i] *= invBlendSumWeighted;
-         contribution[i] *= blendFactor[i];
+         contribution[i] *= blendFactor[i]/blendFacSum; //normalize
       }
    }
 
@@ -474,8 +467,8 @@ float4 computeForwardProbes(Surface surface,
       float contrib = contribution[i];
       if (contrib > 0.0f)
       {
-         int cubemapIdx = probeConfigData[i].a;
-         float3 dir = boxProject(surface.P, surface.R, worldToObjArray[i], refScaleArray[i].xyz, inRefPosArray[i].xyz);
+         int cubemapIdx = inProbeConfigData[i].a;
+         float3 dir = boxProject(surface.P, surface.R, inWorldToObjArray[i], inRefScaleArray[i].xyz, inRefPosArray[i].xyz);
 
          irradiance += TORQUE_TEXCUBEARRAYLOD(irradianceCubemapAR, dir, cubemapIdx, 0).xyz * contrib;
          specular += TORQUE_TEXCUBEARRAYLOD(specularCubemapAR, dir, cubemapIdx, lod).xyz * contrib;
@@ -494,8 +487,8 @@ float4 computeForwardProbes(Surface surface,
    float3 kD = 1.0f - F;
    kD *= 1.0f - surface.metalness;
 
-   float dfgNdotV = max( surface.NdotV , 0.0009765625f ); //0.5f/512.0f (512 is size of dfg/brdf lookup tex)
-   float2 envBRDF = TORQUE_TEX2DLOD(BRDFTexture, float4(dfgNdotV, surface.roughness,0,0)).rg;
+   //float dfgNdotV = max( surface.NdotV , 0.0009765625f ); //0.5f/512.0f (512 is size of dfg/brdf lookup tex)
+   float2 envBRDF = TORQUE_TEX2DLOD(BRDFTexture, float4(surface.NdotV, surface.roughness,0,0)).rg;
    specular *= F * envBRDF.x + surface.f90 * envBRDF.y;
    irradiance *= kD * surface.baseColor.rgb;
 
@@ -507,13 +500,16 @@ float4 computeForwardProbes(Surface surface,
    float horizonOcclusion = 1.3;
    float horizon = saturate( 1 + horizonOcclusion * dot(surface.R, surface.N));
    horizon *= horizon;
-
+#if CAPTURING == 1
+    return float4(lerp(surface.baseColor.rgb,(irradiance + specular) * horizon,surface.metalness/2),0);
+#else
    return float4((irradiance + specular) * horizon, 0);//alpha writes disabled
+#endif
 }
 
 float4 debugVizForwardProbes(Surface surface,
-    float cubeMips, int numProbes, float4x4 worldToObjArray[MAX_FORWARD_PROBES], float4 probeConfigData[MAX_FORWARD_PROBES], 
-    float4 inProbePosArray[MAX_FORWARD_PROBES], float4 refScaleArray[MAX_FORWARD_PROBES], float4 inRefPosArray[MAX_FORWARD_PROBES],
+    float cubeMips, int numProbes, float4x4 inWorldToObjArray[MAX_FORWARD_PROBES], float4 inProbeConfigData[MAX_FORWARD_PROBES], 
+    float4 inProbePosArray[MAX_FORWARD_PROBES], float4 inRefScaleArray[MAX_FORWARD_PROBES], float4 inRefPosArray[MAX_FORWARD_PROBES],
     float skylightCubemapIdx, TORQUE_SAMPLER2D(BRDFTexture), 
 	 TORQUE_SAMPLERCUBEARRAY(irradianceCubemapAR), TORQUE_SAMPLERCUBEARRAY(specularCubemapAR), int showAtten, int showContrib, int showSpec, int showDiff)
 {
@@ -530,15 +526,15 @@ float4 debugVizForwardProbes(Surface surface,
   {
       contribution[i] = 0;
 
-      if (probeConfigData[i].r == 0) //box
+      if (inProbeConfigData[i].r == 0) //box
       {
-         contribution[i] = defineBoxSpaceInfluence(surface.P, worldToObjArray[i], probeConfigData[i].b);
+         contribution[i] = defineBoxSpaceInfluence(surface.P, inWorldToObjArray[i], inProbeConfigData[i].b);
          if (contribution[i] > 0.0)
             probehits++;
       }
-      else if (probeConfigData[i].r == 1) //sphere
+      else if (inProbeConfigData[i].r == 1) //sphere
       {
-         contribution[i] = defineSphereSpaceInfluence(surface.P, inProbePosArray[i].xyz, probeConfigData[i].g);
+         contribution[i] = defineSphereSpaceInfluence(surface.P, inProbePosArray[i].xyz, inProbeConfigData[i].g);
          if (contribution[i] > 0.0)
             probehits++;
       }
@@ -623,8 +619,8 @@ float4 debugVizForwardProbes(Surface surface,
       float contrib = contribution[i];
       if (contrib > 0.0f)
       {
-         int cubemapIdx = probeConfigData[i].a;
-         float3 dir = boxProject(surface.P, surface.R, worldToObjArray[i], refScaleArray[i].xyz, inRefPosArray[i].xyz);
+         int cubemapIdx = inProbeConfigData[i].a;
+         float3 dir = boxProject(surface.P, surface.R, inWorldToObjArray[i], inRefScaleArray[i].xyz, inRefPosArray[i].xyz);
 
          irradiance += TORQUE_TEXCUBEARRAYLOD(irradianceCubemapAR, dir, cubemapIdx, 0).xyz * contrib;
          specular += TORQUE_TEXCUBEARRAYLOD(specularCubemapAR, dir, cubemapIdx, lod).xyz * contrib;
diff --git a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/pointLightP.glsl b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/pointLightP.glsl
index 429208a29..310a84a0a 100644
--- a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/pointLightP.glsl
+++ b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/pointLightP.glsl
@@ -196,6 +196,38 @@ void main()
       lightCol *= max(cookie.r, max(cookie.g, cookie.b));
    #endif
 
+   #ifdef DIFFUSE_LIGHT_VIZ
+      float attenuation = getDistanceAtt(surfaceToLight.Lu, radius);
+      vec3 factor = lightColor * max(surfaceToLight.NdotL, 0) * shadow * lightIntensity * attenuation;
+
+      vec3 diffuse = BRDF_GetDebugDiffuse(surface,surfaceToLight) * factor;
+      vec3 final = max(0.0f, diffuse);
+      OUT_col = vec4(final, 0);
+      return
+   #endif
+
+   #ifdef SPECULAR_LIGHT_VIZ
+   float attenuation = getDistanceAtt(surfaceToLight.Lu, radius);
+      vec3 factor = lightColor * max(surfaceToLight.NdotL, 0) * shadow * lightIntensity * attenuation;
+
+      vec3 diffuse = BRDF_GetDebugSpecular(surface,surfaceToLight) * factor;
+      vec3 final = max(0.0f, diffuse);
+      OUT_col = vec4(final, 0);
+      return
+   #endif
+
+   #ifdef DETAIL_LIGHTING_VIZ
+      float attenuation = getDistanceAtt(surfaceToLight.Lu, radius);
+      vec3 factor = lightColor * max(surfaceToLight.NdotL, 0) * shadow * lightIntensity * attenuation;
+
+      vec3 diffuse = BRDF_GetDiffuse(surface,surfaceToLight) * factor;
+      vec3 spec = BRDF_GetSpecular(surface,surfaceToLight) * factor;
+
+      vec3 final = max(vec3(0.0f), diffuse + spec * surface.F);
+      OUT_col = vec4(final, 0);
+      return
+   #endif
+
       //get punctual light contribution   
       lighting = getPunctualLight(surface, surfaceToLight, lightCol, lightBrightness, lightInvSqrRange, shadowed);
    }
diff --git a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/reflectionProbeArrayP.glsl b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/reflectionProbeArrayP.glsl
index 8efe15c05..e7fa0e2f8 100644
--- a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/reflectionProbeArrayP.glsl
+++ b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/reflectionProbeArrayP.glsl
@@ -84,78 +84,57 @@ void main()
       {
          contribution[i] = 0;
 
+         float atten =1.0-(length(eyePosWorld-probePosArray[i].xyz)/maxProbeDrawDistance);
          if (probeConfigData[i].r == 0) //box
          {
-            contribution[i] = defineBoxSpaceInfluence(surface.P, worldToObjArray[i], probeConfigData[i].b);
-            if (contribution[i]>0.0)
-               probehits++;
+            contribution[i] = defineBoxSpaceInfluence(surface.P, worldToObjArray[i], probeConfigData[i].b)*atten;
          }
          else if (probeConfigData[i].r == 1) //sphere
          {
-            contribution[i] = defineSphereSpaceInfluence(surface.P, probePosArray[i].xyz, probeConfigData[i].g);
+            contribution[i] = defineSphereSpaceInfluence(surface.P, probePosArray[i].xyz, probeConfigData[i].g)*atten;
+         }
+
             if (contribution[i]>0.0)
                probehits++;
-         }
-
-         contribution[i] = max(contribution[i],0);
+         else
+            contribution[i] = 0;
 
          blendSum += contribution[i];
-         invBlendSum += (1.0f - contribution[i]);
       }
-      // Weight0 = normalized NDF, inverted to have 1 at center, 0 at boundary.
-	   // And as we invert, we need to divide by Num-1 to stay normalized (else sum is > 1). 
-	   // respect constraint B.
-	   // Weight1 = normalized inverted NDF, so we have 1 at center, 0 at boundary
-	   // and respect constraint A.
       
-      if (probehits > 1.0)
+       if (probehits > 1.0)//if we overlap
 	   {
+         invBlendSum = (probehits - blendSum)/(probehits-1); //grab the remainder 
          for (i = 0; i < numProbes; i++)
          {
-               blendFactor[i] = ((contribution[i] / blendSum)) / probehits;
-               blendFactor[i] *= ((contribution[i]) / invBlendSum);
-               blendFactor[i] = saturate(blendFactor[i]);
-               blendFacSum += blendFactor[i];
+               blendFactor[i] = contribution[i]/blendSum; //what % total is this instance
+               blendFactor[i] *= blendFactor[i] / invBlendSum;  //what should we add to sum to 1
+               blendFacSum += blendFactor[i]; //running tally of results
          }
 
-         // Normalize blendVal
-         if (blendFacSum == 0.0f) // Possible with custom weight
-         {
-               blendFacSum = 1.0f;
-         }
-
-         float invBlendSumWeighted = 1.0f / blendFacSum;
          for (i = 0; i < numProbes; ++i)
          {
-               blendFactor[i] *= invBlendSumWeighted;
-               contribution[i] *= blendFactor[i];
+               contribution[i] *= blendFactor[i]/blendFacSum; //normalize
          }
       }
       
 #if DEBUGVIZ_ATTENUATION == 1
-      float contribAlpha = 1;
+      float contribAlpha = 0;
       for (i = 0; i < numProbes; ++i)
       {
-         contribAlpha -= contribution[i];
+         contribAlpha += contribution[i];
       }
 
-      OUT_col = vec4(1 - contribAlpha, 1 - contribAlpha, 1 - contribAlpha, 1);
+      OUT_col = vec4(contribAlpha,contribAlpha,contribAlpha, 1);
       return;
 #endif
 
 #if DEBUGVIZ_CONTRIB == 1
       vec3 finalContribColor = vec3(0, 0, 0);
-      float contribAlpha = 1;
       for (i = 0; i < numProbes; ++i)
       {
-         finalContribColor += contribution[i] *probeContribColors[i].rgb;
-         contribAlpha -= contribution[i];
+         finalContribColor += contribution[i] * vec3(fmod(i+1,2),fmod(i+1,3),fmod(i+1,4));
       }
-
-      //Skylight coloration for anything not covered by probes above
-      if(skylightCubemapIdx != -1)
-      	finalContribColor += vec3(0, 1, 0) * contribAlpha;
-
       OUT_col = vec4(finalContribColor, 1);
       return;
 #endif
@@ -188,7 +167,7 @@ void main()
    }
 #endif
 
-   if (skylightCubemapIdx != -1 && alpha > 0.001)
+   if (skylightCubemapIdx != -1 && alpha >= 0.001)
    {
       irradiance = lerp(irradiance,textureLod(irradianceCubemapAR, vec4(surface.R, skylightCubemapIdx), 0).xyz,alpha);
       specular = lerp(specular,textureLod(specularCubemapAR, vec4(surface.R, skylightCubemapIdx), lod).xyz,alpha);
@@ -220,6 +199,9 @@ void main()
    float horizonOcclusion = 1.3;
    float horizon = saturate( 1 + horizonOcclusion * dot(surface.R, surface.N));
    horizon *= horizon;
-
-   OUT_col = vec4(irradiance + specular, 0);//alpha writes disabled
+#if CAPTURING == 1
+   OUT_col = vec4(mix(surface.baseColor.rgb,(irradiance + specular) * horizon,surface.metalness/2),0);
+#else
+   OUT_col = vec4((irradiance + specular) * horizon, 0);//alpha writes disabled
+#endif
 }
diff --git a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/spotLightP.glsl b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/spotLightP.glsl
index d73aaf25a..6c80cc1eb 100644
--- a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/spotLightP.glsl
+++ b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/spotLightP.glsl
@@ -122,6 +122,41 @@ void main()
       lightCol *= max(cookie.r, max(cookie.g, cookie.b));
    #endif
 
+   #ifdef DIFFUSE_LIGHT_VIZ
+      float attenuation = getDistanceAtt(surfaceToLight.Lu, radius);
+      vec3 factor = lightColor * max(surfaceToLight.NdotL, 0) * shadow * lightIntensity * attenuation;
+
+      vec3 diffuse = BRDF_GetDebugDiffuse(surface,surfaceToLight) * factor;
+      vec3 final = max(0.0f, diffuse) * getSpotAngleAtt(-surfaceToLight.L, lightDirection, lightSpotParams );
+      
+      OUT_col = vec4(final, 0);
+      return;
+   #endif
+
+   #ifdef SPECULAR_LIGHT_VIZ
+   float attenuation = getDistanceAtt(surfaceToLight.Lu, radius);
+      float3 factor = lightColor * max(surfaceToLight.NdotL, 0) * shadow * lightIntensity * attenuation;
+
+      vec3 diffuse = BRDF_GetDebugSpecular(surface,surfaceToLight) * factor;
+      vec3 final = max(0.0f, diffuse) * getSpotAngleAtt(-surfaceToLight.L, lightDirection, lightSpotParams );
+      
+      OUT_col = vec4(final, 0);
+      return;
+   #endif
+
+   #ifdef DETAIL_LIGHTING_VIZ
+      float attenuation = getDistanceAtt(surfaceToLight.Lu, radius);
+      vec3 factor = lightColor * max(surfaceToLight.NdotL, 0) * shadow * lightIntensity * attenuation;
+
+      vec3 diffuse = BRDF_GetDiffuse(surface,surfaceToLight) * factor;
+      vec3 spec = BRDF_GetSpecular(surface,surfaceToLight) * factor;
+
+      vec3 final = max(vec3(0.0f), diffuse + spec * surface.F) * getSpotAngleAtt(-surfaceToLight.L, lightDirection, lightSpotParams );
+      
+      OUT_col = vec4(final, 0);
+      return;
+   #endif
+
       //get Punctual light contribution   
       lighting = getPunctualLight(surface, surfaceToLight, lightCol, lightBrightness, lightInvSqrRange, shadowed);
       //get spot angle attenuation
diff --git a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/vectorLightP.glsl b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/vectorLightP.glsl
index 6ee55321c..0bfa6e0f0 100644
--- a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/vectorLightP.glsl
+++ b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/vectorLightP.glsl
@@ -216,7 +216,7 @@ void main()
 	     lightingColor = shadowed_colors.rgb;
       #endif
       
-      shadow = lerp( shadow, 1.0, saturate( fadeOutAmt ) );
+      shadow = mix( shadow, 1.0, saturate( fadeOutAmt ) );
       
       #ifdef PSSM_DEBUG_RENDER
          if ( fadeOutAmt > 1.0 )
@@ -225,6 +225,37 @@ void main()
 
    #endif //NO_SHADOW
 
+   #ifdef DIFFUSE_LIGHT_VIZ
+      vec3 factor = lightingColor.rgb * max(surfaceToLight.NdotL, 0) * shadow * lightBrightness;
+      vec3 diffuse = BRDF_GetDebugDiffuse(surface,surfaceToLight) * factor;
+
+      vec3 final = max(0.0f, diffuse);
+      
+      OUT_col = vec4(final, 0);
+      return;
+   #endif
+
+   #ifdef SPECULAR_LIGHT_VIZ
+      vec3 factor = lightingColor.rgb * max(surfaceToLight.NdotL, 0) * shadow * lightBrightness;
+      vec3 spec = BRDF_GetDebugSpecular(surface, surfaceToLight) * factor;
+
+      vec3 final = max(0.0f, factor);
+      
+      OUT_col = vec4(final, 0);
+      return;
+   #endif
+
+   #ifdef DETAIL_LIGHTING_VIZ
+      vec3 factor = lightingColor.rgb * max(surfaceToLight.NdotL, 0) * shadow * lightBrightness;
+      vec3 diffuse = BRDF_GetDebugDiffuse(surface,surfaceToLight) * factor;
+      vec3 spec = BRDF_GetDebugSpecular(surface,surfaceToLight) * factor;
+
+      vec3 final = max(0.0f, diffuse + spec);
+      
+      OUT_col = vec4(final, 0);
+      return;
+   #endif
+
    //get directional light contribution   
    vec3 lighting = getDirectionalLight(surface, surfaceToLight, lightingColor.rgb, lightBrightness, shadow);
 
diff --git a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/pointLightP.hlsl b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/pointLightP.hlsl
index faa7a01ae..05a29d66d 100644
--- a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/pointLightP.hlsl
+++ b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/pointLightP.hlsl
@@ -134,7 +134,6 @@ uniform float shadowSoftness;
 uniform float4x4 worldToCamera;
 uniform float3x3 worldToLightProj;
 
-uniform float3 eyePosWorld;
 uniform float4x4 cameraToWorld;
 
 float4 main(   ConvexConnectP IN ) : SV_TARGET
@@ -218,12 +217,12 @@ float4 main(   ConvexConnectP IN ) : SV_TARGET
 
    #ifdef DETAIL_LIGHTING_VIZ
       float attenuation = getDistanceAtt(surfaceToLight.Lu, radius);
-      vec3 factor = lightColor * max(surfaceToLight.NdotL, 0) * shadow * lightIntensity * attenuation;
+      float3 factor = lightColor * max(surfaceToLight.NdotL, 0) * shadow * lightIntensity * attenuation;
 
-      vec3 diffuse = BRDF_GetDiffuse(surface,surfaceToLight) * factor;
-      vec3 spec = BRDF_GetSpecular(surface,surfaceToLight) * factor;
+      float3 diffuse = BRDF_GetDiffuse(surface,surfaceToLight) * factor;
+      float3 spec = BRDF_GetSpecular(surface,surfaceToLight) * factor;
 
-      vec3 final = max(vec3(0.0f), diffuse + spec * surface.F);
+      float3 final = max(float3(0.0f), diffuse + spec * surface.F);
       return final;
    #endif
 
diff --git a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/reflectionProbeArrayP.hlsl b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/reflectionProbeArrayP.hlsl
index cff06decf..83f435de8 100644
--- a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/reflectionProbeArrayP.hlsl
+++ b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/reflectionProbeArrayP.hlsl
@@ -12,7 +12,6 @@ TORQUE_UNIFORM_SAMPLER2D(BRDFTexture, 3);
 uniform float4 rtParams0;
 uniform float4 vsFarPlane;
 uniform float4x4 cameraToWorld;
-uniform float3 eyePosWorld;
 
 //cubemap arrays require all the same size. so shared mips# value
 uniform float cubeMips;
@@ -76,79 +75,58 @@ float4 main(PFXVertToPix IN) : SV_TARGET
       //Process prooooobes
       for (i = 0; i < numProbes; ++i)
       {
-         contribution[i] = 0;
+         contribution[i] = 0.0;
 
+         float atten =1.0-(length(eyePosWorld-probePosArray[i].xyz)/maxProbeDrawDistance);
          if (probeConfigData[i].r == 0) //box
          {
-            contribution[i] = defineBoxSpaceInfluence(surface.P, worldToObjArray[i], probeConfigData[i].b);
-            if (contribution[i]>0.0)
-               probehits++;
+            contribution[i] = defineBoxSpaceInfluence(surface.P, worldToObjArray[i], probeConfigData[i].b)*atten;
          }
          else if (probeConfigData[i].r == 1) //sphere
          {
-            contribution[i] = defineSphereSpaceInfluence(surface.P, probePosArray[i].xyz, probeConfigData[i].g);
+            contribution[i] = defineSphereSpaceInfluence(surface.P, probePosArray[i].xyz, probeConfigData[i].g)*atten;
+         }
+
             if (contribution[i]>0.0)
                probehits++;
-         }
-
-         contribution[i] = max(contribution[i],0);
+         else
+            contribution[i] = 0.0;
 
          blendSum += contribution[i];
-         invBlendSum += (1.0f - contribution[i]);
       }
-      // Weight0 = normalized NDF, inverted to have 1 at center, 0 at boundary.
-	   // And as we invert, we need to divide by Num-1 to stay normalized (else sum is > 1). 
-	   // respect constraint B.
-	   // Weight1 = normalized inverted NDF, so we have 1 at center, 0 at boundary
-	   // and respect constraint A.
       
-      if (probehits > 1.0)
+       if (probehits > 1.0)//if we overlap
 	   {
+         invBlendSum = (probehits - blendSum)/(probehits-1); //grab the remainder 
          for (i = 0; i < numProbes; i++)
          {
-               blendFactor[i] = ((contribution[i] / blendSum)) / probehits;
-               blendFactor[i] *= ((contribution[i]) / invBlendSum);
-               blendFactor[i] = saturate(blendFactor[i]);
-               blendFacSum += blendFactor[i];
+               blendFactor[i] = contribution[i]/blendSum; //what % total is this instance
+               blendFactor[i] *= blendFactor[i] / invBlendSum;  //what should we add to sum to 1
+               blendFacSum += blendFactor[i]; //running tally of results
          }
 
-         // Normalize blendVal
-         if (blendFacSum == 0.0f) // Possible with custom weight
-         {
-               blendFacSum = 1.0f;
-         }
-
-         float invBlendSumWeighted = 1.0f / blendFacSum;
          for (i = 0; i < numProbes; ++i)
          {
-               blendFactor[i] *= invBlendSumWeighted;
-               contribution[i] *= blendFactor[i];
+               contribution[i] *= blendFactor[i]/blendFacSum; //normalize
          }
       }
       
 #if DEBUGVIZ_ATTENUATION == 1
-      float contribAlpha = 1;
+      float contribAlpha = 0;
       for (i = 0; i < numProbes; ++i)
       {
-         contribAlpha -= contribution[i];
+         contribAlpha += contribution[i];
       }
 
-      return float4(1 - contribAlpha, 1 - contribAlpha, 1 - contribAlpha, 1);
+      return float4(contribAlpha,contribAlpha,contribAlpha, 1);
 #endif
 
 #if DEBUGVIZ_CONTRIB == 1
       float3 finalContribColor = float3(0, 0, 0);
-      float contribAlpha = 1;
       for (i = 0; i < numProbes; ++i)
       {
-         finalContribColor += contribution[i] *probeContribColors[i].rgb;
-         contribAlpha -= contribution[i];
+         finalContribColor += contribution[i] * float3(fmod(i+1,2),fmod(i+1,3),fmod(i+1,4));
       }
-
-      //Skylight coloration for anything not covered by probes above
-      if(skylightCubemapIdx != -1)
-         finalContribColor += float3(0, 1, 0) * contribAlpha;
-
       return float4(finalContribColor, 1);
 #endif
    }
@@ -209,6 +187,9 @@ float4 main(PFXVertToPix IN) : SV_TARGET
    float horizonOcclusion = 1.3;
    float horizon = saturate( 1 + horizonOcclusion * dot(surface.R, surface.N));
    horizon *= horizon;
-
+#if CAPTURING == 1
+    return float4(lerp(surface.baseColor.rgb,(irradiance + specular) * horizon,surface.metalness/2),0);
+#else
    return float4((irradiance + specular) * horizon, 0);//alpha writes disabled
+#endif
 }
diff --git a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/spotLightP.hlsl b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/spotLightP.hlsl
index 02e11570a..fb3d4aae0 100644
--- a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/spotLightP.hlsl
+++ b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/spotLightP.hlsl
@@ -67,7 +67,6 @@ uniform float4x4 worldToLightProj;
 uniform float4 lightParams;
 
 uniform float shadowSoftness;
-uniform float3 eyePosWorld;
 
 uniform float4x4 cameraToWorld;
 uniform float4x4 worldToCamera;
@@ -147,12 +146,12 @@ float4 main(   ConvexConnectP IN ) : SV_TARGET
 
    #ifdef DETAIL_LIGHTING_VIZ
       float attenuation = getDistanceAtt(surfaceToLight.Lu, radius);
-      vec3 factor = lightColor * max(surfaceToLight.NdotL, 0) * shadow * lightIntensity * attenuation;
+      float3 factor = lightColor * max(surfaceToLight.NdotL, 0) * shadow * lightIntensity * attenuation;
 
-      vec3 diffuse = BRDF_GetDiffuse(surface,surfaceToLight) * factor;
-      vec3 spec = BRDF_GetSpecular(surface,surfaceToLight) * factor;
+      float3 diffuse = BRDF_GetDiffuse(surface,surfaceToLight) * factor;
+      float3 spec = BRDF_GetSpecular(surface,surfaceToLight) * factor;
 
-      vec3 final = max(vec3(0.0f), diffuse + spec * surface.F) * getSpotAngleAtt(-surfaceToLight.L, lightDirection, lightSpotParams );
+      vec3 final = max(float3(0.0f), diffuse + spec * surface.F) * getSpotAngleAtt(-surfaceToLight.L, lightDirection, lightSpotParams );
       return final;
    #endif
 
diff --git a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/vectorLightP.hlsl b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/vectorLightP.hlsl
index e3b9206d4..d99544dca 100644
--- a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/vectorLightP.hlsl
+++ b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/vectorLightP.hlsl
@@ -42,7 +42,6 @@ uniform float4 lightColor;
 uniform float4 lightAmbient;
 
 uniform float shadowSoftness;
-uniform float3 eyePosWorld;
 
 uniform float4 atlasXOffset;
 uniform float4 atlasYOffset;

From c1a88ec423c7b1560cb4e55281ab65acccece3e0 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Sat, 12 Feb 2022 17:32:30 -0600
Subject: [PATCH 307/399] Complied connect var data in GL to D3D for the
 wsPosition Made the use of ints for the cubemapIdx in the shaders consistent

---
 Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp            | 4 ++--
 .../BaseGame/game/core/rendering/shaders/gl/lighting.glsl     | 2 +-
 .../shaders/lighting/advanced/gl/reflectionProbeArrayP.glsl   | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp b/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
index 94b457c75..fded366a1 100644
--- a/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
+++ b/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
@@ -2960,9 +2960,9 @@ void ReflectionProbeFeatGLSL::processPix(Vector<ShaderComponent*>& componentList
    MultiLine * meta = new MultiLine;
 
    // Now the wsPosition and wsView.
-   Var *wsPosition = getInWsPosition(componentList);
    Var *worldToTangent = getInWorldToTangent(componentList);
    Var *wsNormal = getInWorldNormal(componentList);
+   Var *wsPosition = getInWsPosition(componentList);
    Var *wsView = getWsView(wsPosition, meta);
    
    //Reflection Probe WIP
@@ -3038,7 +3038,7 @@ void ReflectionProbeFeatGLSL::processPix(Vector<ShaderComponent*>& componentList
       eyePos->setType("vec3");
       eyePos->setName("eyePosWorld");
       eyePos->uniform = true;
-      eyePos->constSortPos = cspPotentialPrimitive;
+      eyePos->constSortPos = cspPass;
    }
 
    Var *curColor = (Var*)LangElement::find(getOutputTargetVarName(ShaderFeature::DefaultTarget));
diff --git a/Templates/BaseGame/game/core/rendering/shaders/gl/lighting.glsl b/Templates/BaseGame/game/core/rendering/shaders/gl/lighting.glsl
index 57ee38190..11d9a3047 100644
--- a/Templates/BaseGame/game/core/rendering/shaders/gl/lighting.glsl
+++ b/Templates/BaseGame/game/core/rendering/shaders/gl/lighting.glsl
@@ -462,7 +462,7 @@ vec4 computeForwardProbes(Surface surface,
       float contrib = contribution[i];
       if (contrib > 0.0f)
       {
-         float cubemapIdx = int(inProbeConfigData[i].a);
+         int cubemapIdx = int(inProbeConfigData[i].a);
          vec3 dir = boxProject(surface.P, surface.R, inWorldToObjArray[i], inRefScaleArray[i].xyz, inRefPosArray[i].xyz);
 
          irradiance += textureLod(irradianceCubemapAR, vec4(dir, cubemapIdx), 0).xyz * contrib;
diff --git a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/reflectionProbeArrayP.glsl b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/reflectionProbeArrayP.glsl
index e7fa0e2f8..736a5491d 100644
--- a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/reflectionProbeArrayP.glsl
+++ b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/reflectionProbeArrayP.glsl
@@ -157,7 +157,7 @@ void main()
       float contrib = contribution[i];
       if (contrib > 0.0f)
       {
-         float cubemapIdx = probeConfigData[i].a;
+         int cubemapIdx = int(probeConfigData[i].a);
          vec3 dir = boxProject(surface.P, surface.R, worldToObjArray[i], refScaleArray[i].xyz, refPosArray[i].xyz);
 
          irradiance += textureLod(irradianceCubemapAR, vec4(dir, cubemapIdx), 0).xyz * contrib;

From e04f844240f48360279b9d7f6be9f67f92a47ba8 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Sun, 13 Feb 2022 19:24:01 -0600
Subject: [PATCH 308/399] Scaling correction to probes in deferred mode to
 improve parallax adjustment Ensure that probes are masked to be rendered
 during bake passes so they can contribute during a bake allowing multibakes
 Adjusted order of the connect data for the forward shaders to fix a mis-port
 issue

---
 Engine/source/T3D/objectTypes.h                    | 2 +-
 Engine/source/renderInstance/renderProbeMgr.cpp    | 2 +-
 Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp | 2 +-
 Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Engine/source/T3D/objectTypes.h b/Engine/source/T3D/objectTypes.h
index 9044205cd..bd21310fa 100644
--- a/Engine/source/T3D/objectTypes.h
+++ b/Engine/source/T3D/objectTypes.h
@@ -229,7 +229,7 @@ enum SceneObjectTypeMasks : U32
                                  EnvironmentObjectType ),
 
    SKYLIGHT_CAPTURE_TYPEMASK = (EnvironmentObjectType),
-   REFLECTION_PROBE_CAPTURE_TYPEMASK = (StaticObjectType | StaticShapeObjectType)
+   REFLECTION_PROBE_CAPTURE_TYPEMASK = (StaticObjectType | StaticShapeObjectType | LightObjectType)
 };
 
 #endif
diff --git a/Engine/source/renderInstance/renderProbeMgr.cpp b/Engine/source/renderInstance/renderProbeMgr.cpp
index 268bba5e5..393ad899e 100644
--- a/Engine/source/renderInstance/renderProbeMgr.cpp
+++ b/Engine/source/renderInstance/renderProbeMgr.cpp
@@ -328,7 +328,7 @@ void RenderProbeMgr::getBestProbes(const Point3F& objPosition, ProbeDataSet* pro
       MatrixF p2A = curEntry.mProbeInfo->mTransform;
       probeDataSet->probeWorldToObjArray[i] = p2A;
       p2A.inverse();
-      probeDataSet->refScaleArray[i] = curEntry.mProbeInfo->mProbeRefScale / p2A.getScale();
+      probeDataSet->refScaleArray[i] = curEntry.mProbeInfo->mProbeRefScale / (p2A.getScale()*2);
 
       Point3F probePos = curEntry.mProbeInfo->mObject->getPosition();
       Point3F refPos = probePos + curEntry.mProbeInfo->mProbeRefOffset * probeDataSet->refScaleArray[i].asPoint3F();
diff --git a/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp b/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
index fded366a1..06d146c39 100644
--- a/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
+++ b/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
@@ -2960,9 +2960,9 @@ void ReflectionProbeFeatGLSL::processPix(Vector<ShaderComponent*>& componentList
    MultiLine * meta = new MultiLine;
 
    // Now the wsPosition and wsView.
+   Var *wsPosition = getInWsPosition(componentList);
    Var *worldToTangent = getInWorldToTangent(componentList);
    Var *wsNormal = getInWorldNormal(componentList);
-   Var *wsPosition = getInWsPosition(componentList);
    Var *wsView = getWsView(wsPosition, meta);
    
    //Reflection Probe WIP
diff --git a/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp b/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
index a294f5f85..7361e2eaf 100644
--- a/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
+++ b/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
@@ -3038,9 +3038,9 @@ void ReflectionProbeFeatHLSL::processPix(Vector<ShaderComponent*> &componentList
    MultiLine *meta = new MultiLine;
    
    // Now the wsPosition and wsView.
+   Var* wsPosition = getInWsPosition(componentList);
    Var* worldToTangent = getInWorldToTangent(componentList);
    Var *wsNormal = getInWorldNormal(componentList);
-   Var* wsPosition = getInWsPosition(componentList);
    Var *wsView = getWsView(wsPosition, meta);
    
    //Reflection Probe WIP

From a0f8b29da7ede49baeee858f186ea73d57031302 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Mon, 14 Feb 2022 01:07:39 -0600
Subject: [PATCH 309/399] Improves logical checks for the default value so it's
 more sane and stable Allows creation of polyhedrons via constructor with a
 origin and vector format, allowing to have default polyhedron values on
 triggers and physical zones

---
 Engine/source/T3D/physicalZone.cpp      |  7 ++++
 Engine/source/T3D/trigger.cpp           |  7 ++++
 Engine/source/console/simObject.cpp     |  2 +-
 Engine/source/math/mPolyhedron.h        | 47 +++++++++++++++++++++++++
 Engine/source/persistence/taml/taml.cpp |  2 +-
 5 files changed, 63 insertions(+), 2 deletions(-)

diff --git a/Engine/source/T3D/physicalZone.cpp b/Engine/source/T3D/physicalZone.cpp
index f3028ee45..9603a4f34 100644
--- a/Engine/source/T3D/physicalZone.cpp
+++ b/Engine/source/T3D/physicalZone.cpp
@@ -114,6 +114,13 @@ PhysicalZone::PhysicalZone()
    force_mag = 0.0f;
    orient_force = false;
    fade_amt = 1.0f;
+
+   //Default up a basic square
+   Point3F vecs[3] = { Point3F(1.0, 0.0, 0.0),
+      Point3F(0.0, -1.0, 0.0),
+      Point3F(0.0, 0.0, 1.0) };
+
+   mPolyhedron = Polyhedron(Point3F(-0.5, 0.5, 0.0), vecs);
 }
 
 PhysicalZone::~PhysicalZone()
diff --git a/Engine/source/T3D/trigger.cpp b/Engine/source/T3D/trigger.cpp
index 1d075d7c3..bcf85810b 100644
--- a/Engine/source/T3D/trigger.cpp
+++ b/Engine/source/T3D/trigger.cpp
@@ -173,6 +173,13 @@ Trigger::Trigger()
    mTripOnce = false;
    mTrippedBy = 0xFFFFFFFF;
    mTripCondition = "";
+
+   //Default up a basic square
+   Point3F vecs[3] = { Point3F(1.0, 0.0, 0.0),
+      Point3F(0.0, -1.0, 0.0),
+      Point3F(0.0, 0.0, 1.0) };
+
+   mTriggerPolyhedron = Polyhedron(Point3F(-0.5, 0.5, 0.0), vecs);
 }
 
 Trigger::~Trigger()
diff --git a/Engine/source/console/simObject.cpp b/Engine/source/console/simObject.cpp
index 3552f4dd1..e76263fc7 100644
--- a/Engine/source/console/simObject.cpp
+++ b/Engine/source/console/simObject.cpp
@@ -338,7 +338,7 @@ void SimObject::writeFields(Stream &stream, U32 tabStop)
 
          //If the field hasn't been changed from the default value, then don't bother writing it out
          const char* defaultValueCheck = defaultObject->getDataField(f->pFieldname, array);
-         if (defaultValueCheck != '\0' && dStricmp(defaultValueCheck, valCopy) == 0)
+         if (defaultValueCheck && defaultValueCheck[0] != '\0' && dStricmp(defaultValueCheck, valCopy) == 0)
             continue;
 
          val = valCopy;
diff --git a/Engine/source/math/mPolyhedron.h b/Engine/source/math/mPolyhedron.h
index 4496b219c..e43a0822f 100644
--- a/Engine/source/math/mPolyhedron.h
+++ b/Engine/source/math/mPolyhedron.h
@@ -307,6 +307,53 @@ struct PolyhedronImpl : public Base
          this->mEdgeList = edges;
       }
 
+      PolyhedronImpl(Point3F origin, Point3F vecs[3])
+      {
+         // This setup goes against conventions for Polyhedrons in that it a) sets up
+         // edges with CCW instead of CW order for face[0] and that it b) lets plane
+         // normals face outwards rather than inwards.
+
+         mPointList.setSize(8);
+         mPointList[0] = origin;
+         mPointList[1] = origin + vecs[0];
+         mPointList[2] = origin + vecs[1];
+         mPointList[3] = origin + vecs[2];
+         mPointList[4] = origin + vecs[0] + vecs[1];
+         mPointList[5] = origin + vecs[0] + vecs[2];
+         mPointList[6] = origin + vecs[1] + vecs[2];
+         mPointList[7] = origin + vecs[0] + vecs[1] + vecs[2];
+
+         Point3F normal;
+         mPlaneList.setSize(6);
+
+         mCross(vecs[2], vecs[0], &normal);
+         mPlaneList[0].set(origin, normal);
+         mCross(vecs[0], vecs[1], &normal);
+         mPlaneList[1].set(origin, normal);
+         mCross(vecs[1], vecs[2], &normal);
+         mPlaneList[2].set(origin, normal);
+         mCross(vecs[1], vecs[0], &normal);
+         mPlaneList[3].set(mPointList[7], normal);
+         mCross(vecs[2], vecs[1], &normal);
+         mPlaneList[4].set(mPointList[7], normal);
+         mCross(vecs[0], vecs[2], &normal);
+         mPlaneList[5].set(mPointList[7], normal);
+
+         mEdgeList.setSize(12);
+         mEdgeList[0].vertex[0] = 0;  mEdgeList[0].vertex[1] = 1;  mEdgeList[0].face[0] = 0;  mEdgeList[0].face[1] = 1;
+         mEdgeList[1].vertex[0] = 1;  mEdgeList[1].vertex[1] = 5;  mEdgeList[1].face[0] = 0;  mEdgeList[1].face[1] = 4;
+         mEdgeList[2].vertex[0] = 5;  mEdgeList[2].vertex[1] = 3;  mEdgeList[2].face[0] = 0;  mEdgeList[2].face[1] = 3;
+         mEdgeList[3].vertex[0] = 3;  mEdgeList[3].vertex[1] = 0;  mEdgeList[3].face[0] = 0;  mEdgeList[3].face[1] = 2;
+         mEdgeList[4].vertex[0] = 3;  mEdgeList[4].vertex[1] = 6;  mEdgeList[4].face[0] = 3;  mEdgeList[4].face[1] = 2;
+         mEdgeList[5].vertex[0] = 6;  mEdgeList[5].vertex[1] = 2;  mEdgeList[5].face[0] = 2;  mEdgeList[5].face[1] = 5;
+         mEdgeList[6].vertex[0] = 2;  mEdgeList[6].vertex[1] = 0;  mEdgeList[6].face[0] = 2;  mEdgeList[6].face[1] = 1;
+         mEdgeList[7].vertex[0] = 1;  mEdgeList[7].vertex[1] = 4;  mEdgeList[7].face[0] = 4;  mEdgeList[7].face[1] = 1;
+         mEdgeList[8].vertex[0] = 4;  mEdgeList[8].vertex[1] = 2;  mEdgeList[8].face[0] = 1;  mEdgeList[8].face[1] = 5;
+         mEdgeList[9].vertex[0] = 4;  mEdgeList[9].vertex[1] = 7;  mEdgeList[9].face[0] = 4;  mEdgeList[9].face[1] = 5;
+         mEdgeList[10].vertex[0] = 5; mEdgeList[10].vertex[1] = 7; mEdgeList[10].face[0] = 3; mEdgeList[10].face[1] = 4;
+         mEdgeList[11].vertex[0] = 7; mEdgeList[11].vertex[1] = 6; mEdgeList[11].face[0] = 3; mEdgeList[11].face[1] = 5;
+      }
+
       /// Return the AABB around the polyhedron.
       Box3F getBounds() const
       {
diff --git a/Engine/source/persistence/taml/taml.cpp b/Engine/source/persistence/taml/taml.cpp
index 5200dcf28..a623ba8b1 100644
--- a/Engine/source/persistence/taml/taml.cpp
+++ b/Engine/source/persistence/taml/taml.cpp
@@ -729,7 +729,7 @@ ImplementEnumType(_TamlFormatMode,
             {
                //If the field hasn't been changed from the default value, then don't bother writing it out
                const char* fieldData = defaultObject->getDataField(fieldName, indexBuffer);
-               if (fieldData != '\0' && dStricmp(fieldData, pFieldValue) == 0)
+               if (fieldData && fieldData[0] != '\0' && dStricmp(fieldData, pFieldValue) == 0)
                   continue;
             }
 

From 28bf6c5b8fa84f2b226606af5bf56cdab14fd4c0 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Mon, 14 Feb 2022 08:58:19 -0600
Subject: [PATCH 310/399] Ensures that the capturing flag is toggled regardless
 of how we invoke for a probe to bake(previously it was only done with the
 batch bake)

---
 Engine/source/renderInstance/renderProbeMgr.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/Engine/source/renderInstance/renderProbeMgr.cpp b/Engine/source/renderInstance/renderProbeMgr.cpp
index 393ad899e..a6aedc1b9 100644
--- a/Engine/source/renderInstance/renderProbeMgr.cpp
+++ b/Engine/source/renderInstance/renderProbeMgr.cpp
@@ -477,6 +477,8 @@ void RenderProbeMgr::bakeProbe(ReflectionProbe* probe)
    Con::warnf("RenderProbeMgr::bakeProbe() - Beginning bake!");
    U32 startMSTime = Platform::getRealMilliseconds();
 
+   Con::setVariable("$Probes::Capturing", "1");
+
    String path = Con::getVariable("$pref::ReflectionProbes::CurrentLevelPath", "levels/");
    U32 resolution = Con::getIntVariable("$pref::ReflectionProbes::BakeResolution", 64);
    U32 prefilterMipLevels = mLog2(F32(resolution)) + 1;
@@ -596,6 +598,8 @@ void RenderProbeMgr::bakeProbe(ReflectionProbe* probe)
    if (!renderWithProbes)
       RenderProbeMgr::smRenderReflectionProbes = probeRenderState;
 
+   Con::setVariable("$Probes::Capturing", "0");
+
    cubeRefl.unregisterReflector();
 
    U32 endMSTime = Platform::getRealMilliseconds();
@@ -907,7 +911,5 @@ DefineEngineMethod(RenderProbeMgr, bakeProbe, void, (ReflectionProbe* probe), (n
 
 DefineEngineMethod(RenderProbeMgr, bakeProbes, void, (),, "@brief Iterates over all reflection probes in the scene and bakes their cubemaps\n\n.")
 {
-   Con::setVariable("$Probes::Capturing", "1");
    object->bakeProbes();
-   Con::setVariable("$Probes::Capturing", "0");
 }

From 1f7d06542e76b1ab298061a4361d1b157bceaf36 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Mon, 14 Feb 2022 14:42:15 -0600
Subject: [PATCH 311/399] doublesided material renderfix as per the OG writeup,
 need to apply horizon trick strictly to the specular component

---
 .../BaseGame/game/core/rendering/shaders/gl/lighting.glsl   | 6 +++---
 .../BaseGame/game/core/rendering/shaders/lighting.hlsl      | 6 +++---
 .../shaders/lighting/advanced/gl/reflectionProbeArrayP.glsl | 4 ++--
 .../shaders/lighting/advanced/reflectionProbeArrayP.hlsl    | 4 ++--
 4 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/Templates/BaseGame/game/core/rendering/shaders/gl/lighting.glsl b/Templates/BaseGame/game/core/rendering/shaders/gl/lighting.glsl
index 11d9a3047..185306beb 100644
--- a/Templates/BaseGame/game/core/rendering/shaders/gl/lighting.glsl
+++ b/Templates/BaseGame/game/core/rendering/shaders/gl/lighting.glsl
@@ -496,9 +496,9 @@ vec4 computeForwardProbes(Surface surface,
    float horizon = saturate( 1 + horizonOcclusion * dot(surface.R, surface.N));
    horizon *= horizon;
 #if CAPTURING == 1
-    return vec4(mix(surface.baseColor.rgb,(irradiance + specular) * horizon,surface.metalness/2),0);
+    return vec4(mix(surface.baseColor.rgb,(irradiance + specular* horizon) ,surface.metalness/2),0);
 #else
-   return vec4((irradiance + specular) * horizon, 0);//alpha writes disabled
+   return vec4((irradiance + specular* horizon) , 0);//alpha writes disabled
 #endif
 }
 
@@ -657,5 +657,5 @@ vec4 debugVizForwardProbes(Surface surface,
    float horizon = saturate( 1 + horizonOcclusion * dot(surface.R, surface.N));
    horizon *= horizon;
 
-   return vec4((irradiance + specular) * horizon, 0);//alpha writes disabled
+   return vec4((irradiance + specular* horizon) , 0);//alpha writes disabled
 }
diff --git a/Templates/BaseGame/game/core/rendering/shaders/lighting.hlsl b/Templates/BaseGame/game/core/rendering/shaders/lighting.hlsl
index 2a52e6eeb..35b6d0fd3 100644
--- a/Templates/BaseGame/game/core/rendering/shaders/lighting.hlsl
+++ b/Templates/BaseGame/game/core/rendering/shaders/lighting.hlsl
@@ -501,9 +501,9 @@ float4 computeForwardProbes(Surface surface,
    float horizon = saturate( 1 + horizonOcclusion * dot(surface.R, surface.N));
    horizon *= horizon;
 #if CAPTURING == 1
-    return float4(lerp(surface.baseColor.rgb,(irradiance + specular) * horizon,surface.metalness/2),0);
+    return float4(lerp(surface.baseColor.rgb,(irradiance + specular* horizon) ,surface.metalness/2),0);
 #else
-   return float4((irradiance + specular) * horizon, 0);//alpha writes disabled
+   return float4((irradiance + specular* horizon) , 0);//alpha writes disabled
 #endif
 }
 
@@ -662,5 +662,5 @@ float4 debugVizForwardProbes(Surface surface,
    float horizon = saturate( 1 + horizonOcclusion * dot(surface.R, surface.N));
    horizon *= horizon;
 
-   return float4((irradiance + specular) * horizon, 0);//alpha writes disabled
+   return float4((irradiance + specular* horizon) , 0);//alpha writes disabled
 }
\ No newline at end of file
diff --git a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/reflectionProbeArrayP.glsl b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/reflectionProbeArrayP.glsl
index 736a5491d..813597c95 100644
--- a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/reflectionProbeArrayP.glsl
+++ b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/reflectionProbeArrayP.glsl
@@ -200,8 +200,8 @@ void main()
    float horizon = saturate( 1 + horizonOcclusion * dot(surface.R, surface.N));
    horizon *= horizon;
 #if CAPTURING == 1
-   OUT_col = vec4(mix(surface.baseColor.rgb,(irradiance + specular) * horizon,surface.metalness/2),0);
+   OUT_col = vec4(mix(surface.baseColor.rgb,(irradiance + specular* horizon) ,surface.metalness/2),0);
 #else
-   OUT_col = vec4((irradiance + specular) * horizon, 0);//alpha writes disabled
+   OUT_col = vec4((irradiance + specular* horizon) , 0);//alpha writes disabled
 #endif
 }
diff --git a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/reflectionProbeArrayP.hlsl b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/reflectionProbeArrayP.hlsl
index 83f435de8..1b49a5e41 100644
--- a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/reflectionProbeArrayP.hlsl
+++ b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/reflectionProbeArrayP.hlsl
@@ -188,8 +188,8 @@ float4 main(PFXVertToPix IN) : SV_TARGET
    float horizon = saturate( 1 + horizonOcclusion * dot(surface.R, surface.N));
    horizon *= horizon;
 #if CAPTURING == 1
-    return float4(lerp(surface.baseColor.rgb,(irradiance + specular) * horizon,surface.metalness/2),0);
+    return float4(lerp(surface.baseColor.rgb,(irradiance + specular* horizon) ,surface.metalness/2),0);
 #else
-   return float4((irradiance + specular) * horizon, 0);//alpha writes disabled
+   return result = float4((irradiance + specular* horizon) , 0);//alpha writes disabled   
 #endif
 }

From 540e82b95c9cc4cb626b5824fc9eef3b882d45f9 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Mon, 14 Feb 2022 19:50:37 -0600
Subject: [PATCH 312/399] template mixins need this-> specified

---
 Engine/source/math/mPolyhedron.h | 58 ++++++++++++++++----------------
 1 file changed, 29 insertions(+), 29 deletions(-)

diff --git a/Engine/source/math/mPolyhedron.h b/Engine/source/math/mPolyhedron.h
index e43a0822f..78beaa79f 100644
--- a/Engine/source/math/mPolyhedron.h
+++ b/Engine/source/math/mPolyhedron.h
@@ -313,45 +313,45 @@ struct PolyhedronImpl : public Base
          // edges with CCW instead of CW order for face[0] and that it b) lets plane
          // normals face outwards rather than inwards.
 
-         mPointList.setSize(8);
-         mPointList[0] = origin;
-         mPointList[1] = origin + vecs[0];
-         mPointList[2] = origin + vecs[1];
-         mPointList[3] = origin + vecs[2];
-         mPointList[4] = origin + vecs[0] + vecs[1];
-         mPointList[5] = origin + vecs[0] + vecs[2];
-         mPointList[6] = origin + vecs[1] + vecs[2];
-         mPointList[7] = origin + vecs[0] + vecs[1] + vecs[2];
+         this->mPointList.setSize(8);
+         this->mPointList[0] = origin;
+         this->mPointList[1] = origin + vecs[0];
+         this->mPointList[2] = origin + vecs[1];
+         this->mPointList[3] = origin + vecs[2];
+         this->mPointList[4] = origin + vecs[0] + vecs[1];
+         this->mPointList[5] = origin + vecs[0] + vecs[2];
+         this->mPointList[6] = origin + vecs[1] + vecs[2];
+         this->mPointList[7] = origin + vecs[0] + vecs[1] + vecs[2];
 
          Point3F normal;
-         mPlaneList.setSize(6);
+         this->mPlaneList.setSize(6);
 
          mCross(vecs[2], vecs[0], &normal);
-         mPlaneList[0].set(origin, normal);
+         this->mPlaneList[0].set(origin, normal);
          mCross(vecs[0], vecs[1], &normal);
-         mPlaneList[1].set(origin, normal);
+         this->mPlaneList[1].set(origin, normal);
          mCross(vecs[1], vecs[2], &normal);
-         mPlaneList[2].set(origin, normal);
+         this->mPlaneList[2].set(origin, normal);
          mCross(vecs[1], vecs[0], &normal);
-         mPlaneList[3].set(mPointList[7], normal);
+         this->mPlaneList[3].set(this->mPointList[7], normal);
          mCross(vecs[2], vecs[1], &normal);
-         mPlaneList[4].set(mPointList[7], normal);
+         this->mPlaneList[4].set(this->mPointList[7], normal);
          mCross(vecs[0], vecs[2], &normal);
-         mPlaneList[5].set(mPointList[7], normal);
+         this->mPlaneList[5].set(this->mPointList[7], normal);
 
-         mEdgeList.setSize(12);
-         mEdgeList[0].vertex[0] = 0;  mEdgeList[0].vertex[1] = 1;  mEdgeList[0].face[0] = 0;  mEdgeList[0].face[1] = 1;
-         mEdgeList[1].vertex[0] = 1;  mEdgeList[1].vertex[1] = 5;  mEdgeList[1].face[0] = 0;  mEdgeList[1].face[1] = 4;
-         mEdgeList[2].vertex[0] = 5;  mEdgeList[2].vertex[1] = 3;  mEdgeList[2].face[0] = 0;  mEdgeList[2].face[1] = 3;
-         mEdgeList[3].vertex[0] = 3;  mEdgeList[3].vertex[1] = 0;  mEdgeList[3].face[0] = 0;  mEdgeList[3].face[1] = 2;
-         mEdgeList[4].vertex[0] = 3;  mEdgeList[4].vertex[1] = 6;  mEdgeList[4].face[0] = 3;  mEdgeList[4].face[1] = 2;
-         mEdgeList[5].vertex[0] = 6;  mEdgeList[5].vertex[1] = 2;  mEdgeList[5].face[0] = 2;  mEdgeList[5].face[1] = 5;
-         mEdgeList[6].vertex[0] = 2;  mEdgeList[6].vertex[1] = 0;  mEdgeList[6].face[0] = 2;  mEdgeList[6].face[1] = 1;
-         mEdgeList[7].vertex[0] = 1;  mEdgeList[7].vertex[1] = 4;  mEdgeList[7].face[0] = 4;  mEdgeList[7].face[1] = 1;
-         mEdgeList[8].vertex[0] = 4;  mEdgeList[8].vertex[1] = 2;  mEdgeList[8].face[0] = 1;  mEdgeList[8].face[1] = 5;
-         mEdgeList[9].vertex[0] = 4;  mEdgeList[9].vertex[1] = 7;  mEdgeList[9].face[0] = 4;  mEdgeList[9].face[1] = 5;
-         mEdgeList[10].vertex[0] = 5; mEdgeList[10].vertex[1] = 7; mEdgeList[10].face[0] = 3; mEdgeList[10].face[1] = 4;
-         mEdgeList[11].vertex[0] = 7; mEdgeList[11].vertex[1] = 6; mEdgeList[11].face[0] = 3; mEdgeList[11].face[1] = 5;
+         this->mEdgeList.setSize(12);
+         this->mEdgeList[0].vertex[0] = 0;  this->mEdgeList[0].vertex[1] = 1;  this->mEdgeList[0].face[0] = 0;  this->mEdgeList[0].face[1] = 1;
+         this->mEdgeList[1].vertex[0] = 1;  this->mEdgeList[1].vertex[1] = 5;  this->mEdgeList[1].face[0] = 0;  this->mEdgeList[1].face[1] = 4;
+         this->mEdgeList[2].vertex[0] = 5;  this->mEdgeList[2].vertex[1] = 3;  this->mEdgeList[2].face[0] = 0;  this->mEdgeList[2].face[1] = 3;
+         this->mEdgeList[3].vertex[0] = 3;  this->mEdgeList[3].vertex[1] = 0;  this->mEdgeList[3].face[0] = 0;  this->mEdgeList[3].face[1] = 2;
+         this->mEdgeList[4].vertex[0] = 3;  this->mEdgeList[4].vertex[1] = 6;  this->mEdgeList[4].face[0] = 3;  this->mEdgeList[4].face[1] = 2;
+         this->mEdgeList[5].vertex[0] = 6;  this->mEdgeList[5].vertex[1] = 2;  this->mEdgeList[5].face[0] = 2;  this->mEdgeList[5].face[1] = 5;
+         this->mEdgeList[6].vertex[0] = 2;  this->mEdgeList[6].vertex[1] = 0;  this->mEdgeList[6].face[0] = 2;  this->mEdgeList[6].face[1] = 1;
+         this->mEdgeList[7].vertex[0] = 1;  this->mEdgeList[7].vertex[1] = 4;  this->mEdgeList[7].face[0] = 4;  this->mEdgeList[7].face[1] = 1;
+         this->mEdgeList[8].vertex[0] = 4;  this->mEdgeList[8].vertex[1] = 2;  this->mEdgeList[8].face[0] = 1;  this->mEdgeList[8].face[1] = 5;
+         this->mEdgeList[9].vertex[0] = 4;  this->mEdgeList[9].vertex[1] = 7;  this->mEdgeList[9].face[0] = 4;  this->mEdgeList[9].face[1] = 5;
+         this->mEdgeList[10].vertex[0] = 5; this->mEdgeList[10].vertex[1] = 7; this->mEdgeList[10].face[0] = 3; this->mEdgeList[10].face[1] = 4;
+         this->mEdgeList[11].vertex[0] = 7; this->mEdgeList[11].vertex[1] = 6; this->mEdgeList[11].face[0] = 3; this->mEdgeList[11].face[1] = 5;
       }
 
       /// Return the AABB around the polyhedron.

From ed36cf2c5ce0f568577394588f59ae15b61d2307 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Thu, 17 Feb 2022 18:04:31 -0600
Subject: [PATCH 313/399] Changes for BaseUI Update

---
 Engine/source/T3D/assets/MaterialAsset.cpp    |  6 ++
 Engine/source/T3D/assets/assetImporter.cpp    | 87 ++++++++++++++-----
 Engine/source/T3D/assets/assetImporter.h      | 32 +++++++
 Engine/source/Verve/GUI/VEditorButton.cpp     |  2 +-
 Engine/source/afx/ui/afxSpellButton.cpp       |  2 +-
 Engine/source/console/simDictionary.cpp       |  2 +-
 .../source/gui/buttons/guiBitmapButtonCtrl.h  |  2 +-
 Engine/source/gui/buttons/guiBorderButton.cpp |  2 +-
 .../source/gui/buttons/guiButtonBaseCtrl.cpp  | 22 ++++-
 Engine/source/gui/buttons/guiButtonBaseCtrl.h |  7 +-
 Engine/source/gui/buttons/guiButtonCtrl.cpp   |  5 +-
 Engine/source/gui/buttons/guiCheckBoxCtrl.cpp |  2 +-
 .../source/gui/buttons/guiIconButtonCtrl.cpp  |  4 +-
 .../gui/buttons/guiSwatchButtonCtrl.cpp       |  2 +-
 .../gui/buttons/guiToggleButtonCtrl.cpp       |  4 +-
 .../gui/buttons/guiToolboxButtonCtrl.cpp      |  2 +-
 .../source/gui/controls/guiGradientCtrl.cpp   |  4 +-
 Engine/source/gui/core/guiCanvas.cpp          |  3 +
 Engine/source/gui/utility/guiInputCtrl.cpp    | 10 ++-
 Engine/source/gui/utility/guiInputCtrl.h      |  1 +
 20 files changed, 156 insertions(+), 45 deletions(-)

diff --git a/Engine/source/T3D/assets/MaterialAsset.cpp b/Engine/source/T3D/assets/MaterialAsset.cpp
index 50e75ffa3..e51f9a709 100644
--- a/Engine/source/T3D/assets/MaterialAsset.cpp
+++ b/Engine/source/T3D/assets/MaterialAsset.cpp
@@ -319,6 +319,12 @@ U32 MaterialAsset::getAssetByMaterialName(StringTableEntry matName, AssetPtr<Mat
          AssetDatabase.releaseAsset(query.mAssetList[i]); //cleanup if that's not the one we needed
       }
    }
+
+   //Somehow we failed to bind an asset, so just use the fallback and mark the failure
+   matAsset->setAssetId(MaterialAsset::smNoMaterialAssetFallback);
+   (*matAsset)->mLoadedState = AssetErrCode::UsingFallback;
+   return AssetErrCode::UsingFallback;
+
 }
 
 StringTableEntry MaterialAsset::getAssetIdByMaterialName(StringTableEntry matName)
diff --git a/Engine/source/T3D/assets/assetImporter.cpp b/Engine/source/T3D/assets/assetImporter.cpp
index e9afcc479..8dc898dae 100644
--- a/Engine/source/T3D/assets/assetImporter.cpp
+++ b/Engine/source/T3D/assets/assetImporter.cpp
@@ -104,7 +104,9 @@ AssetImportConfig::AssetImportConfig() :
    importSounds(true),
    VolumeAdjust(false),
    PitchAdjust(false),
-   SoundsCompressed(false)
+   SoundsCompressed(false),
+   AlwaysAddSoundSuffix(false),
+   AddedSoundSuffix("_sound")
 {
 }
 
@@ -316,6 +318,8 @@ void AssetImportConfig::loadImportConfig(Settings* configSettings, String config
    VolumeAdjust = dAtof(configSettings->value(String(configName + "/Sounds/VolumeAdjust").c_str()));
    PitchAdjust = dAtof(configSettings->value(String(configName + "/Sounds/PitchAdjust").c_str()));
    SoundsCompressed = dAtob(configSettings->value(String(configName + "/Sounds/Compressed").c_str()));
+   AlwaysAddSoundSuffix = dAtob(configSettings->value(String(configName + "/Sounds/AlwaysAddSoundSuffix").c_str()));
+   AddedSoundSuffix = configSettings->value(String(configName + "/Sounds/AddedSoundSuffix").c_str());
 }
 
 void AssetImportConfig::CopyTo(AssetImportConfig* target) const
@@ -406,6 +410,8 @@ void AssetImportConfig::CopyTo(AssetImportConfig* target) const
    target->VolumeAdjust = VolumeAdjust;
    target->PitchAdjust = PitchAdjust;
    target->SoundsCompressed = SoundsCompressed;
+   target->AlwaysAddSoundSuffix = AlwaysAddSoundSuffix;
+   target->AddedSoundSuffix = AddedSoundSuffix;
 }
 
 ConsoleDocClass(AssetImportObject,
@@ -607,6 +613,7 @@ AssetImportObject* AssetImporter::addImportingAsset(String assetType, Torque::Pa
    assetName.replace('*', '_');
    assetName.replace('-', '_');
    assetName.replace('+', '_');
+   assetName.replace('&', '_');
 
    assetImportObj->assetType = assetType;
    assetImportObj->filePath = filePath;
@@ -622,6 +629,14 @@ AssetImportObject* AssetImporter::addImportingAsset(String assetType, Torque::Pa
    assetImportObj->importStatus = AssetImportObject::NotProcessed;
    assetImportObj->generatedAsset = false;
 
+   //If the config is marked to always set the directory prefix, do that now
+   if (activeImportConfig->AddDirectoryPrefixToAssetName)
+   {
+      assetName = getFolderPrefixedName(assetImportObj);
+      assetImportObj->assetName = assetName;
+      assetImportObj->cleanAssetName = assetName;
+   }
+
    if (parentItem != nullptr)
    {
       dSprintf(importLogBuffer, sizeof(importLogBuffer), "Added Child Importing Asset to %s", parentItem->assetName.c_str());
@@ -1976,6 +1991,12 @@ void AssetImporter::processSoundAsset(AssetImportObject* assetItem)
    dSprintf(importLogBuffer, sizeof(importLogBuffer), "Preparing Sound for Import: %s", assetItem->assetName.c_str());
    activityLog.push_back(importLogBuffer);
 
+   if (activeImportConfig->AlwaysAddSoundSuffix)
+   {
+      assetItem->assetName += activeImportConfig->AddedSoundSuffix;
+      assetItem->cleanAssetName = assetItem->assetName;
+   }
+
    assetItem->importStatus = AssetImportObject::Processed;
 }
 
@@ -2165,7 +2186,49 @@ void AssetImporter::resolveAssetItemIssues(AssetImportObject* assetItem)
       {
          //Set trailing number
          String renamedAssetName = assetItem->assetName;
-         renamedAssetName = Sim::getUniqueName(renamedAssetName.c_str());
+         String renamedAssetId = assetItem->moduleName + ":" + renamedAssetName;
+
+         String addedSuffix;
+
+         if (assetItem->assetType == String("ShapeAsset"))
+            addedSuffix = activeImportConfig->AddedShapeSuffix;
+         else if (assetItem->assetType == String("MaterialAsset"))
+            addedSuffix = activeImportConfig->AddedMaterialSuffix;
+         else if (assetItem->assetType == String("ImageAsset"))
+            addedSuffix = activeImportConfig->AddedImageSuffix;
+         else if (assetItem->assetType == String("SoundAsset"))
+            addedSuffix = activeImportConfig->AddedSoundSuffix;
+
+         //do the suffix if it isn't already on it
+         if (!renamedAssetName.endsWith(addedSuffix.c_str()))
+         {
+            renamedAssetName += addedSuffix;
+            renamedAssetId = assetItem->moduleName + ":" + renamedAssetName;
+            assetItem->assetName = renamedAssetName;
+         }
+
+         //if still conflicted
+         //add the directory prefix
+         if (AssetDatabase.isDeclaredAsset(renamedAssetId.c_str()))
+         {
+            renamedAssetName = getFolderPrefixedName(assetItem);
+            renamedAssetId = assetItem->moduleName + ":" + renamedAssetName;
+            assetItem->assetName = renamedAssetName;
+         }
+
+         bool appendedNumber = false;
+         U32 uniqueNumber = 0;
+         while (AssetDatabase.isDeclaredAsset(renamedAssetId.c_str()))
+         {
+            uniqueNumber++;
+            renamedAssetId = assetItem->moduleName + ":" + renamedAssetName + String::ToString(uniqueNumber);
+            appendedNumber = true;
+         }
+
+         if (appendedNumber)
+         {
+            renamedAssetName += String::ToString(uniqueNumber);
+         }
 
          //Log it's renaming
          dSprintf(importLogBuffer, sizeof(importLogBuffer), "Asset %s was renamed due to %s as part of the Import Configuration", assetItem->assetName.c_str(), humanReadableReason.c_str());
@@ -2186,25 +2249,7 @@ void AssetImporter::resolveAssetItemIssues(AssetImportObject* assetItem)
       }
       else if (activeImportConfig->DuplicateAutoResolution == String("FolderPrefix"))
       {
-         String renamedAssetName = assetItem->assetName;
-
-         //Set trailing number
-         S32 dirIndex = assetItem->filePath.getDirectoryCount() - 1;
-         while (dirIndex > -1)
-         {
-            renamedAssetName = assetItem->assetName;
-            String owningFolder = assetItem->filePath.getDirectory(dirIndex);
-
-            renamedAssetName = owningFolder + "_" + renamedAssetName;
-
-            if (AssetDatabase.isDeclaredAsset(renamedAssetName))
-            {
-               dirIndex--;
-               continue;
-            }
-
-            break;
-         }
+         String renamedAssetName = getFolderPrefixedName(assetItem);
 
          //Log it's renaming
          dSprintf(importLogBuffer, sizeof(importLogBuffer), "Asset %s was renamed due to %s as part of the Import Configuration", assetItem->assetName.c_str(), humanReadableReason.c_str());
diff --git a/Engine/source/T3D/assets/assetImporter.h b/Engine/source/T3D/assets/assetImporter.h
index b03c89c40..9505d00b1 100644
--- a/Engine/source/T3D/assets/assetImporter.h
+++ b/Engine/source/T3D/assets/assetImporter.h
@@ -409,6 +409,15 @@ public:
    /// </summary>
    bool SoundsCompressed;
 
+   /// When importing an image, this indicates if it should automatically add a standard suffix onto the name
+   /// </summary>
+   bool AlwaysAddSoundSuffix;
+
+   /// <summary>
+   /// If AlwaysAddSoundSuffix is on, this is the suffix to be added
+   /// </summary>
+   String AddedSoundSuffix;
+
 public:
    AssetImportConfig();
    virtual ~AssetImportConfig();
@@ -934,4 +943,27 @@ public:
    //
    void setTargetModuleId(const String& moduleId) { targetModuleId = moduleId; }
    const String& getTargetModuleId() { return targetModuleId; }
+
+   String getFolderPrefixedName(AssetImportObject* assetItem)
+   {
+      String renamedAssetName = assetItem->assetName;
+      S32 dirIndex = assetItem->filePath.getDirectoryCount() - 1;
+      while (dirIndex > -1)
+      {
+         renamedAssetName = assetItem->assetName;
+         String owningFolder = assetItem->filePath.getDirectory(dirIndex);
+
+         renamedAssetName = owningFolder + "_" + renamedAssetName;
+
+         if (AssetDatabase.isDeclaredAsset(renamedAssetName))
+         {
+            dirIndex--;
+            continue;
+         }
+
+         break;
+      }
+
+      return renamedAssetName;
+   }
 };
diff --git a/Engine/source/Verve/GUI/VEditorButton.cpp b/Engine/source/Verve/GUI/VEditorButton.cpp
index 3c32424b4..d86f86e3f 100644
--- a/Engine/source/Verve/GUI/VEditorButton.cpp
+++ b/Engine/source/Verve/GUI/VEditorButton.cpp
@@ -186,7 +186,7 @@ void VEditorButton::onRender( Point2I offset, const RectI& updateRect )
         {
             RectI boundsRect( offset, getExtent() );
 
-            if ( mDepressed || mStateOn || mMouseOver )
+            if ( mDepressed || mStateOn || mHighlighted )
             {
                 renderFilledBorder( boundsRect, mProfile->mBorderColorHL, mProfile->mFillColorHL );
             }
diff --git a/Engine/source/afx/ui/afxSpellButton.cpp b/Engine/source/afx/ui/afxSpellButton.cpp
index 632d2e652..76888a73a 100644
--- a/Engine/source/afx/ui/afxSpellButton.cpp
+++ b/Engine/source/afx/ui/afxSpellButton.cpp
@@ -221,7 +221,7 @@ void afxSpellButton::onRender(Point2I offset, const RectI& updateRect)
 
   if (mActive)
   {
-    if (mMouseOver) state = HILIGHT;
+    if (mHighlighted) state = HILIGHT;
     if (mDepressed || mStateOn) state = DEPRESSED;
   }
   else
diff --git a/Engine/source/console/simDictionary.cpp b/Engine/source/console/simDictionary.cpp
index 93491fd1c..8730a89dd 100644
--- a/Engine/source/console/simDictionary.cpp
+++ b/Engine/source/console/simDictionary.cpp
@@ -53,7 +53,7 @@ void SimNameDictionary::insert(SimObject* obj)
    SimObject* checkForDup = find(obj->getName());
 
    if (checkForDup)
-      Con::warnf("Warning! You have a duplicate datablock name of %s. This can cause problems. You should rename one of them.", obj->getName());
+      Con::warnf("Warning! You have a duplicate object name of %s. This can cause problems. You should rename one of them.", obj->getName());
 
    Mutex::lockMutex(mutex);
 #ifndef USE_NEW_SIMDICTIONARY
diff --git a/Engine/source/gui/buttons/guiBitmapButtonCtrl.h b/Engine/source/gui/buttons/guiBitmapButtonCtrl.h
index 59e7825f1..846cdaedb 100644
--- a/Engine/source/gui/buttons/guiBitmapButtonCtrl.h
+++ b/Engine/source/gui/buttons/guiBitmapButtonCtrl.h
@@ -137,7 +137,7 @@ class GuiBitmapButtonCtrl : public GuiButtonCtrl
          if( mActive )
          {
 				if( mDepressed || mStateOn ) return DEPRESSED;
-            if( mMouseOver ) return HILIGHT;
+            if( mHighlighted ) return HILIGHT;
             return NORMAL;
          }
          else
diff --git a/Engine/source/gui/buttons/guiBorderButton.cpp b/Engine/source/gui/buttons/guiBorderButton.cpp
index 6efc5bc77..24f4a50f3 100644
--- a/Engine/source/gui/buttons/guiBorderButton.cpp
+++ b/Engine/source/gui/buttons/guiBorderButton.cpp
@@ -79,7 +79,7 @@ void GuiBorderButtonCtrl::onRender(Point2I offset, const RectI &updateRect)
          }
       }
 
-      if ( mMouseOver )
+      if ( mHighlighted )
       {
          RectI bounds( offset, getExtent() );
          for ( S32 i=0; i < mProfile->mBorderThickness; i++ )
diff --git a/Engine/source/gui/buttons/guiButtonBaseCtrl.cpp b/Engine/source/gui/buttons/guiButtonBaseCtrl.cpp
index 4621d5fea..b72f1b280 100644
--- a/Engine/source/gui/buttons/guiButtonBaseCtrl.cpp
+++ b/Engine/source/gui/buttons/guiButtonBaseCtrl.cpp
@@ -98,7 +98,7 @@ EndImplementEnumType;
 GuiButtonBaseCtrl::GuiButtonBaseCtrl()
 {
    mDepressed = false;
-   mMouseOver = false;
+   mHighlighted = false;
    mActive = true;
    static StringTableEntry sButton = StringTable->insert( "Button" );
    mButtonText = sButton;
@@ -288,14 +288,14 @@ void GuiButtonBaseCtrl::onMouseEnter(const GuiEvent &event)
    if(isMouseLocked())
    {
       mDepressed = true;
-      mMouseOver = true;
+      mHighlighted = true;
    }
    else
    {
       if ( mActive && mProfile->mSoundButtonOver )
          SFX->playOnce(mProfile->mSoundButtonOver);
 
-      mMouseOver = true;
+      mHighlighted = true;
    }
 }
 
@@ -309,7 +309,7 @@ void GuiButtonBaseCtrl::onMouseLeave(const GuiEvent &)
       onMouseLeave_callback();
    if( isMouseLocked() )
       mDepressed = false;
-   mMouseOver = false;
+   mHighlighted = false;
 }
 
 //-----------------------------------------------------------------------------
@@ -542,3 +542,17 @@ DefineEngineMethod( GuiButtonBaseCtrl, resetState, void, (),,
 {
    object->resetState();
 }
+
+DefineEngineMethod(GuiButtonBaseCtrl, setHighlighted, void, (bool highlighted), (false),
+   "Reset the mousing state of the button.\n\n"
+   "This method should not generally be called.")
+{
+   object->setHighlighted(highlighted);
+}
+
+DefineEngineMethod(GuiButtonBaseCtrl, isHighlighted, bool, (),,
+   "Reset the mousing state of the button.\n\n"
+   "This method should not generally be called.")
+{
+   return object->isHighlighted();
+}
diff --git a/Engine/source/gui/buttons/guiButtonBaseCtrl.h b/Engine/source/gui/buttons/guiButtonBaseCtrl.h
index 0e3be53a7..60f76ea4a 100644
--- a/Engine/source/gui/buttons/guiButtonBaseCtrl.h
+++ b/Engine/source/gui/buttons/guiButtonBaseCtrl.h
@@ -49,7 +49,7 @@ class GuiButtonBaseCtrl : public GuiControl
       StringTableEntry mButtonText;
       StringTableEntry mButtonTextID;
       bool mDepressed;
-      bool mMouseOver;
+      bool mHighlighted;
       bool mStateOn;
       S32 mButtonType;
       S32 mRadioGroup;
@@ -95,7 +95,10 @@ class GuiButtonBaseCtrl : public GuiControl
       bool getStateOn() const { return mStateOn; }
 
       void setDepressed( bool depressed ) { mDepressed = depressed; }
-      void resetState() {mDepressed = false; mMouseOver = false;}
+      void resetState() {mDepressed = false; mHighlighted = false;}
+
+      void setHighlighted(bool highlighted) { mHighlighted = highlighted; }
+      bool isHighlighted() { return mHighlighted; }
 
       void acceleratorKeyPress(U32 index);
       void acceleratorKeyRelease(U32 index);
diff --git a/Engine/source/gui/buttons/guiButtonCtrl.cpp b/Engine/source/gui/buttons/guiButtonCtrl.cpp
index c0d5f4e08..8996f87a9 100644
--- a/Engine/source/gui/buttons/guiButtonCtrl.cpp
+++ b/Engine/source/gui/buttons/guiButtonCtrl.cpp
@@ -83,7 +83,7 @@ bool GuiButtonCtrl::onWake()
 void GuiButtonCtrl::onRender(Point2I      offset,
                              const RectI& updateRect)
 {
-   bool highlight = mMouseOver;
+   bool highlight = mHighlighted;
    bool depressed = mDepressed;
 
    ColorI fontColor   = mActive ? ( highlight ? mProfile->mFontColorHL : mProfile->mFontColor ) : mProfile->mFontColorNA;
@@ -107,7 +107,7 @@ void GuiButtonCtrl::onRender(Point2I      offset,
          indexMultiplier = 4;
       else if ( mDepressed || mStateOn )
          indexMultiplier = 2;
-      else if ( mMouseOver )
+      else if ( mHighlighted )
          indexMultiplier = 3;
 
       renderSizableBitmapBordersFilled( boundsRect, indexMultiplier, mProfile );
@@ -123,3 +123,4 @@ void GuiButtonCtrl::onRender(Point2I      offset,
    //render the children
    renderChildControls( offset, updateRect);
 }
+
diff --git a/Engine/source/gui/buttons/guiCheckBoxCtrl.cpp b/Engine/source/gui/buttons/guiCheckBoxCtrl.cpp
index b7b47b57c..983709c7a 100644
--- a/Engine/source/gui/buttons/guiCheckBoxCtrl.cpp
+++ b/Engine/source/gui/buttons/guiCheckBoxCtrl.cpp
@@ -106,7 +106,7 @@ void GuiCheckBoxCtrl::onRender(Point2I offset, const RectI &updateRect)
    }
 
    ColorI backColor = mActive ? mProfile->mFillColor : mProfile->mFillColorNA;
-   ColorI fontColor = mActive ? (mMouseOver ? mProfile->mFontColorHL : mProfile->mFontColor) : mProfile->mFontColorNA;
+   ColorI fontColor = mActive ? (mHighlighted ? mProfile->mFontColorHL : mProfile->mFontColor) : mProfile->mFontColorNA;
    ColorI insideBorderColor = isFirstResponder() ? mProfile->mBorderColorHL : mProfile->mBorderColor;
 
    // just draw the check box and the text:
diff --git a/Engine/source/gui/buttons/guiIconButtonCtrl.cpp b/Engine/source/gui/buttons/guiIconButtonCtrl.cpp
index c0fb939ff..a84623fa1 100644
--- a/Engine/source/gui/buttons/guiIconButtonCtrl.cpp
+++ b/Engine/source/gui/buttons/guiIconButtonCtrl.cpp
@@ -218,7 +218,7 @@ void GuiIconButtonCtrl::onRender(Point2I offset, const RectI& updateRect)
 
 void GuiIconButtonCtrl::renderButton( Point2I &offset, const RectI& updateRect )
 {
-   bool highlight = mMouseOver;
+   bool highlight = mHighlighted;
    bool depressed = mDepressed;
    
    ColorI fontColor   = mActive ? (highlight ? mProfile->mFontColorHL : mProfile->mFontColor) : mProfile->mFontColorNA;
@@ -236,7 +236,7 @@ void GuiIconButtonCtrl::renderButton( Point2I &offset, const RectI& updateRect )
       else
          renderSlightlyLoweredBox(boundsRect, mProfile);
    }
-   else if(mMouseOver && mActive)
+   else if(mHighlighted && mActive)
    {
       // If there is a bitmap array then render using it.  
       // Otherwise use a standard fill.
diff --git a/Engine/source/gui/buttons/guiSwatchButtonCtrl.cpp b/Engine/source/gui/buttons/guiSwatchButtonCtrl.cpp
index 7db73a05e..dea3e8535 100644
--- a/Engine/source/gui/buttons/guiSwatchButtonCtrl.cpp
+++ b/Engine/source/gui/buttons/guiSwatchButtonCtrl.cpp
@@ -90,7 +90,7 @@ bool GuiSwatchButtonCtrl::onWake()
 
 void GuiSwatchButtonCtrl::onRender( Point2I offset, const RectI &updateRect )
 {
-   bool highlight = mMouseOver;
+   bool highlight = mHighlighted;
 
    ColorI borderColor = mActive ? ( highlight ? mProfile->mBorderColorHL : mProfile->mBorderColor ) : mProfile->mBorderColorNA;
 
diff --git a/Engine/source/gui/buttons/guiToggleButtonCtrl.cpp b/Engine/source/gui/buttons/guiToggleButtonCtrl.cpp
index a2aaaa6c9..8dea6943c 100644
--- a/Engine/source/gui/buttons/guiToggleButtonCtrl.cpp
+++ b/Engine/source/gui/buttons/guiToggleButtonCtrl.cpp
@@ -66,7 +66,7 @@ void GuiToggleButtonCtrl::onPreRender()
 void GuiToggleButtonCtrl::onRender(Point2I      offset,
                                    const RectI& updateRect)
 {
-   bool highlight = mMouseOver;
+   bool highlight = mHighlighted;
    bool depressed = mDepressed;
 
    ColorI fontColor   = mActive ? ( highlight ? mProfile->mFontColorHL : mProfile->mFontColor ) : mProfile->mFontColorNA;
@@ -89,7 +89,7 @@ void GuiToggleButtonCtrl::onRender(Point2I      offset,
          indexMultiplier = 4;
       else if ( mDepressed || mStateOn )
          indexMultiplier = 2;
-      else if ( mMouseOver )
+      else if ( mHighlighted )
          indexMultiplier = 3;
 
 
diff --git a/Engine/source/gui/buttons/guiToolboxButtonCtrl.cpp b/Engine/source/gui/buttons/guiToolboxButtonCtrl.cpp
index 3f1b26f0c..9a9a63831 100644
--- a/Engine/source/gui/buttons/guiToolboxButtonCtrl.cpp
+++ b/Engine/source/gui/buttons/guiToolboxButtonCtrl.cpp
@@ -144,7 +144,7 @@ void GuiToolboxButtonCtrl::onRender(Point2I offset, const RectI& updateRect)
       RectI r(offset, getExtent());
       if ( mDepressed  || mStateOn )
          renderStateRect( mLoweredBitmap , r );
-      else if ( mMouseOver )
+      else if ( mHighlighted )
          renderStateRect( mHoverBitmap , r );
    }
 
diff --git a/Engine/source/gui/controls/guiGradientCtrl.cpp b/Engine/source/gui/controls/guiGradientCtrl.cpp
index 112f3859d..3b5959ae8 100644
--- a/Engine/source/gui/controls/guiGradientCtrl.cpp
+++ b/Engine/source/gui/controls/guiGradientCtrl.cpp
@@ -99,7 +99,7 @@ bool GuiGradientSwatchCtrl::onWake()
 
 void GuiGradientSwatchCtrl::onRender( Point2I offset, const RectI &updateRect )
 {
-   bool highlight = mMouseOver;
+   bool highlight = mHighlighted;
 
    ColorI borderColor = mActive ? ( highlight ? mProfile->mBorderColorHL : mProfile->mBorderColor ) : mProfile->mBorderColorNA;
    RectI renderRect( offset, getExtent() );
@@ -632,4 +632,4 @@ DefineEngineMethod(GuiGradientCtrl, getColor, LinearColorF, (S32 idx), , "Get co
 	}
 
 	return LinearColorF::ONE;
-}
\ No newline at end of file
+}
diff --git a/Engine/source/gui/core/guiCanvas.cpp b/Engine/source/gui/core/guiCanvas.cpp
index 0b894f7c3..95f6213c2 100644
--- a/Engine/source/gui/core/guiCanvas.cpp
+++ b/Engine/source/gui/core/guiCanvas.cpp
@@ -706,6 +706,9 @@ bool GuiCanvas::processInputEvent(InputEventInfo &inputEvent)
       if (mCursorEnabled || mForceMouseToGUI || 
          (mAlwaysHandleMouseButtons && inputEvent.objType == SI_BUTTON) )
       {
+         if (inputEvent.objType != SI_AXIS && inputEvent.action == SI_MAKE)
+            bool asdfasdf = true;
+
          return processMouseEvent(inputEvent);
       }
       break;
diff --git a/Engine/source/gui/utility/guiInputCtrl.cpp b/Engine/source/gui/utility/guiInputCtrl.cpp
index 907d861a9..4c56f9133 100644
--- a/Engine/source/gui/utility/guiInputCtrl.cpp
+++ b/Engine/source/gui/utility/guiInputCtrl.cpp
@@ -61,7 +61,8 @@ ConsoleDocClass( GuiInputCtrl,
 GuiInputCtrl::GuiInputCtrl()
    : mSendAxisEvents(false),
    mSendBreakEvents(false),
-   mSendModifierEvents(false)
+   mSendModifierEvents(false),
+   mIgnoreMouseEvents(false)
 {
 }
 
@@ -76,6 +77,8 @@ void GuiInputCtrl::initPersistFields()
       "If true, break events for all devices will generate callbacks (Default false).");
    addField("sendModifierEvents", TypeBool, Offset(mSendModifierEvents, GuiInputCtrl),
       "If true, Make events will be sent for modifier keys (Default false).");
+   addField("ignoreMouseEvents", TypeBool, Offset(mIgnoreMouseEvents, GuiInputCtrl),
+      "If true, any events from mouse devices will be passed through.");
    endGroup("GuiInputCtrl");
 
    Parent::initPersistFields();
@@ -97,7 +100,7 @@ bool GuiInputCtrl::onWake()
    if ( !Parent::onWake() )
       return( false );
 
-   if( !smDesignTime )
+   if( !smDesignTime && !mIgnoreMouseEvents)
       mouseLock();
       
    setFirstResponder();
@@ -151,6 +154,9 @@ IMPLEMENT_CALLBACK(GuiInputCtrl, onAxisEvent, void, (const char* device, const c
 //------------------------------------------------------------------------------
 bool GuiInputCtrl::onInputEvent( const InputEventInfo &event )
 {
+   if (mIgnoreMouseEvents && event.deviceType == MouseDeviceType)
+      return false;
+
    char deviceString[32];
    if ( event.action == SI_MAKE )
    {
diff --git a/Engine/source/gui/utility/guiInputCtrl.h b/Engine/source/gui/utility/guiInputCtrl.h
index be60371f3..269569693 100644
--- a/Engine/source/gui/utility/guiInputCtrl.h
+++ b/Engine/source/gui/utility/guiInputCtrl.h
@@ -36,6 +36,7 @@ protected:
    bool mSendAxisEvents;
    bool mSendBreakEvents;
    bool mSendModifierEvents;
+   bool mIgnoreMouseEvents;
 
 public:
 

From 40acf752385a87f93eb4b6f0938a9a14196ccc3f Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Thu, 17 Feb 2022 18:21:13 -0600
Subject: [PATCH 314/399] Template changes

---
 .../game/core/gui/scripts/profiles.tscript    |   21 +-
 Templates/BaseGame/game/data/UI/UI.tscript    |    2 +-
 .../game/data/UI/guis/OptionsDlg.asset.taml   |    7 -
 .../game/data/UI/guis/joinServerMenu.gui      |  270 +---
 .../game/data/UI/guis/joinServerMenu.tscript  |   35 +-
 .../BaseGame/game/data/UI/guis/mainMenu.gui   |  210 ++-
 .../game/data/UI/guis/mainMenu.tscript        |   16 +-
 .../BaseGame/game/data/UI/guis/optionsDlg.gui | 1432 -----------------
 .../game/data/UI/guis/optionsMenu.gui         |  547 ++++---
 .../game/data/UI/guis/optionsMenu.tscript     |  203 ++-
 .../game/data/UI/images/scrollBar.png         |  Bin 6643 -> 9187 bytes
 .../game/data/UI/scripts/controlsMenu.tscript |    2 +-
 .../data/UI/scripts/menuInputButtons.tscript  |  341 ----
 .../game/data/UI/scripts/profiles.tscript     |    6 +
 14 files changed, 762 insertions(+), 2330 deletions(-)
 delete mode 100644 Templates/BaseGame/game/data/UI/guis/OptionsDlg.asset.taml
 delete mode 100644 Templates/BaseGame/game/data/UI/guis/optionsDlg.gui
 delete mode 100644 Templates/BaseGame/game/data/UI/scripts/menuInputButtons.tscript

diff --git a/Templates/BaseGame/game/core/gui/scripts/profiles.tscript b/Templates/BaseGame/game/core/gui/scripts/profiles.tscript
index dd0ede04a..57156bbbe 100644
--- a/Templates/BaseGame/game/core/gui/scripts/profiles.tscript
+++ b/Templates/BaseGame/game/core/gui/scripts/profiles.tscript
@@ -26,6 +26,10 @@ if($Gui::fontCacheDirectory $= "")
    $Gui::fontCacheDirectory = expandFilename("data/cache/fonts");
 }
 
+$TextMediumEmphasisColor = "200 200 200";
+$TextHighEmphasisColor = "224 224 224";
+$TextDisabledColor = "108 108 108";
+
 // ----------------------------------------------------------------------------
 // GuiDefaultProfile is a special profile that all other profiles inherit
 // defaults from. It must exist.
@@ -137,13 +141,20 @@ new GuiControlProfile(GuiTextEditProfile)
    category = "Core";
 };
 
-if(!isObject(GuiScrollProfile))
-new GuiControlProfile(GuiScrollProfile)
+if(!isObject(GuiMenuScrollProfile))
+new GuiControlProfile(GuiMenuScrollProfile)
 {
    opaque = true;
-   fillcolor = "255 255 255";
-   fontColor = "0 0 0";
-   fontColorHL = "150 150 150";
+   fontColor = $TextMediumEmphasisColor;
+   fontColorHL = $TextMediumEmphasisColor;
+   fontColorNA = $TextDisabledColor;
+   fontColorSEL = $TextMediumEmphasisColor;
+   fillColor = "40 40 40";
+   fillColorHL = "56 56 56";
+   fillColorNA = "40 40 40";
+   borderColor = "87 87 87";
+   borderColorNA = "0 0 0";
+   borderColorHL = "255 255 255";
    border = true;
    bitmapAsset = "Core_GUI:scrollBar_image";
    hasBitmapArray = true;
diff --git a/Templates/BaseGame/game/data/UI/UI.tscript b/Templates/BaseGame/game/data/UI/UI.tscript
index e0b1670d0..5b8c1ee6a 100644
--- a/Templates/BaseGame/game/data/UI/UI.tscript
+++ b/Templates/BaseGame/game/data/UI/UI.tscript
@@ -36,7 +36,7 @@ function UI::initClient(%this)
    %this.queueExec("./scripts/profiles");
    
    //Now gui files
-   %this.queueExec("./scripts/menuInputButtons");
+   %this.queueExec("./scripts/menuInputHandling");
    
    %this.queueExec("./guis/mainMenu");
    %this.queueExec("./guis/mainMenu.gui");
diff --git a/Templates/BaseGame/game/data/UI/guis/OptionsDlg.asset.taml b/Templates/BaseGame/game/data/UI/guis/OptionsDlg.asset.taml
deleted file mode 100644
index 21467cbc8..000000000
--- a/Templates/BaseGame/game/data/UI/guis/OptionsDlg.asset.taml
+++ /dev/null
@@ -1,7 +0,0 @@
-<GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="OptionsDlg"
-    scriptFile="@assetFile=optionsDlg.gui"
-    GUIFile="@assetFile=optionsDlg.gui"
-    VersionId="1" />
diff --git a/Templates/BaseGame/game/data/UI/guis/joinServerMenu.gui b/Templates/BaseGame/game/data/UI/guis/joinServerMenu.gui
index 4343fe7ad..17a2c4435 100644
--- a/Templates/BaseGame/game/data/UI/guis/joinServerMenu.gui
+++ b/Templates/BaseGame/game/data/UI/guis/joinServerMenu.gui
@@ -14,19 +14,27 @@ $guiContent = new GuiControl(JoinServerMenu) {
    canSave = "1";
    canSaveDynamicFields = "1";
       returnGui = "MainMenuGui";
-      
-   new GuiInputCtrl(JoinServerMenuInputHandler){
-      profile = "GuiInputCtrlProfile";
-      visible = "1";
-      active = "1";
-      position = "0 0";
-      extent = "1024 768";
+
+   new GuiInputCtrl(JoinServerMenuInputHandler) {
+      sendAxisEvents = "1";
+      sendBreakEvents = "1";
+      sendModifierEvents = "0";
+      ignoreMouseEvents = "1";
+      lockMouse = "0";
+      position = "-10 0";
+      extent = "10 10";
       minExtent = "8 2";
       horizSizing = "width";
       vertSizing = "height";
-      sendBreakEvents="1";
+      profile = "GuiInputCtrlProfile";
+      visible = "1";
+      active = "1";
+      tooltipProfile = "GuiToolTipProfile";
+      hovertime = "1000";
+      isContainer = "0";
+      canSave = "1";
+      canSaveDynamicFields = "0";
    };
-
    new GuiControl(JoinServerWindow) {
       position = "48 56";
       extent = "928 655";
@@ -46,7 +54,7 @@ $guiContent = new GuiControl(JoinServerMenu) {
          percent = "100";
          vertical = "0";
          flipClip = "0";
-         bitmap = "data/ui/images/panel.png";
+         BitmapAsset = "UI:panel_image";
          color = "255 255 255 255";
          position = "0 0";
          extent = "927 40";
@@ -89,7 +97,7 @@ $guiContent = new GuiControl(JoinServerMenu) {
          percent = "100";
          vertical = "0";
          flipClip = "0";
-         bitmap = "data/ui/images/panel_low.png";
+         BitmapAsset = "UI:panel_low_image";
          color = "255 255 255 255";
          position = "0 40";
          extent = "927 618";
@@ -105,58 +113,6 @@ $guiContent = new GuiControl(JoinServerMenu) {
          canSave = "1";
          canSaveDynamicFields = "0";
       };
-      new GuiTextCtrl() {
-         text = "Player Name:";
-         maxLength = "255";
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
-         position = "12 47";
-         extent = "109 18";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "MenuSubHeaderText";
-         visible = "1";
-         active = "1";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiTextEditCtrl() {
-         historySize = "0";
-         tabComplete = "0";
-         sinkAllKeyEvents = "0";
-         password = "0";
-         passwordMask = "*";
-         text = "Visitor";
-         maxLength = "255";
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
-         position = "124 47";
-         extent = "144 18";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuTextEditProfile";
-         visible = "1";
-         active = "1";
-         variable = "$pref::Player::Name";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
       new GuiTextCtrl(JS_status) {
          text = "No servers found.";
          maxLength = "255";
@@ -166,7 +122,7 @@ $guiContent = new GuiControl(JoinServerMenu) {
          anchorBottom = "0";
          anchorLeft = "1";
          anchorRight = "0";
-         position = "277 47";
+         position = "392 47";
          extent = "148 18";
          minExtent = "8 8";
          horizSizing = "right";
@@ -324,25 +280,30 @@ $guiContent = new GuiControl(JoinServerMenu) {
          canSave = "1";
          canSaveDynamicFields = "0";
 
-         new GuiTextListCtrl(JS_serverList) {
-            columns = "0 200 270 335 400";
-            fitParentWidth = "1";
-            clipColumnText = "0";
-            rowHeightPadding = "2";
+         new GuiStackControl(JoinServerList) {
+            stackingType = "Vertical";
+            horizStacking = "Left to Right";
+            vertStacking = "Top to Bottom";
+            padding = "10";
+            dynamicSize = "1";
+            dynamicNonStackExtent = "0";
+            dynamicPos = "0";
+            changeChildSizeToFit = "0";
+            changeChildPosition = "1";
             position = "1 1";
-            extent = "888 8";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextArrayProfile";
+            extent = "888 16";
+            minExtent = "16 16";
+            horizSizing = "center";
+            vertSizing = "center";
+            profile = "GuiDefaultProfile";
             visible = "1";
             active = "1";
-            altCommand = "JoinServerDlg.join();";
             tooltipProfile = "GuiToolTipProfile";
             hovertime = "1000";
             isContainer = "1";
             canSave = "1";
             canSaveDynamicFields = "0";
+            class = "MenuList";
          };
       };
       new GuiControl(JS_queryStatus) {
@@ -427,130 +388,9 @@ $guiContent = new GuiControl(JoinServerMenu) {
             canSaveDynamicFields = "0";
          };
       };
-      new GuiButtonCtrl(JoinServerBackBtn) {
-         text = "Return to Menu";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "1";
-         position = "0 583";
-         extent = "160 33";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "0";
-         active = "1";
-         command = "Canvas.popDialog(JoinServerMenu);\n\nif(isObject(JoinServerMenu.returnGui) && JoinServerMenu.returnGui.isMethod(\"onReturnTo\"))    JoinServerMenu.returnGui.onReturnTo();";
-         accelerator = "escape";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         hidden = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl(JoinServerQryLanBtn) {
-         text = "Query Lan";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "1";
-         position = "160 583";
-         extent = "160 33";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "0";
-         active = "1";
-         command = "JoinServerMenu.queryLan();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         hidden = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl(JoinServerQryInternetBtn) {
-         text = "Query Internet";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "1";
-         position = "320 583";
-         extent = "160 33";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "0";
-         active = "1";
-         command = "JoinServerMenu.query();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         hidden = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl(JoinServerRefreshBtn) {
-         text = "Refresh Server";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "1";
-         position = "480 583";
-         extent = "160 33";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "0";
-         active = "1";
-         command = "JoinServerMenu.refresh();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         hidden = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl(JoinServerJoinBtn) {
-         text = "Join Server";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "1";
-         position = "640 583";
-         extent = "160 33";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "0";
-         active = "0";
-         command = "JoinServerMenu.join();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         hidden = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-   };
-   new GuiControl() {
-      position = "189 652";
-      extent = "646 130";
-      minExtent = "8 2";
-      horizSizing = "center";
-      vertSizing = "top";
-      profile = "GuiDefaultProfile";
-      visible = "1";
-      active = "1";
-      tooltipProfile = "GuiToolTipProfile";
-      hovertime = "1000";
-      isContainer = "1";
-      canSave = "1";
-      canSaveDynamicFields = "0";
    };
    new GuiControl(JoinServerButtonHolder) {
-      position = "109 711";
+      position = "116 711";
       extent = "791 40";
       minExtent = "8 2";
       horizSizing = "center";
@@ -567,7 +407,7 @@ $guiContent = new GuiControl(JoinServerMenu) {
 
       new GuiIconButtonCtrl() {
          buttonMargin = "4 4";
-         iconBitmap = "data/ui/images/Inputs/Keyboard & Mouse/Keyboard_Black_Enter";
+         BitmapAsset = "UI:Keyboard_Black_Return_image";
          iconLocation = "Left";
          sizeIconToButton = "1";
          makeIconSquare = "1";
@@ -586,7 +426,7 @@ $guiContent = new GuiControl(JoinServerMenu) {
          profile = "GuiMenuButtonProfile";
          visible = "1";
          active = "1";
-         command = "OptionsMenu.apply();";
+         command = "JoinServerMenu.join();";
          tooltipProfile = "GuiToolTipProfile";
          hovertime = "1000";
          isContainer = "0";
@@ -597,7 +437,7 @@ $guiContent = new GuiControl(JoinServerMenu) {
       };
       new GuiIconButtonCtrl() {
          buttonMargin = "4 4";
-         iconBitmap = "data/ui/images/Inputs/Keyboard & Mouse/Keyboard_Black_Esc";
+         BitmapAsset = "UI:Keyboard_Black_Escape_image";
          iconLocation = "Left";
          sizeIconToButton = "1";
          makeIconSquare = "1";
@@ -616,7 +456,7 @@ $guiContent = new GuiControl(JoinServerMenu) {
          profile = "GuiMenuButtonProfile";
          visible = "1";
          active = "1";
-         command = "OptionsMenu.backOut();";
+         command = "JoinServerMenu.backOut();";
          tooltipProfile = "GuiToolTipProfile";
          hovertime = "1000";
          isContainer = "0";
@@ -627,14 +467,14 @@ $guiContent = new GuiControl(JoinServerMenu) {
       };
       new GuiIconButtonCtrl() {
          buttonMargin = "4 4";
-         iconBitmap = "data/ui/images/Inputs/Keyboard & Mouse/Keyboard_Black_Enter";
+         BitmapAsset = "UI:Keyboard_Black_Q_image";
          iconLocation = "Left";
          sizeIconToButton = "1";
          makeIconSquare = "1";
          textLocation = "Right";
          textMargin = "4";
          autoSize = "0";
-         text = "Prev Tab";
+         text = "Query LAN";
          groupNum = "-1";
          buttonType = "PushButton";
          useMouseEvents = "0";
@@ -644,28 +484,27 @@ $guiContent = new GuiControl(JoinServerMenu) {
          horizSizing = "right";
          vertSizing = "bottom";
          profile = "GuiMenuButtonProfile";
-         visible = "0";
-         active = "0";
-         command = "OptionsMenu.prevTab();";
+         visible = "1";
+         active = "1";
+         command = "JoinServerMenu.queryLan();";
          tooltipProfile = "GuiToolTipProfile";
          hovertime = "1000";
          isContainer = "0";
          internalName = "queryLANButton";
          class = "MenuInputButton";
-         hidden = "1";
          canSave = "1";
          canSaveDynamicFields = "0";
       };
       new GuiIconButtonCtrl() {
          buttonMargin = "4 4";
-         iconBitmap = "data/ui/images/Inputs/Keyboard & Mouse/Keyboard_Black_Esc";
+         BitmapAsset = "UI:Keyboard_Black_E_image";
          iconLocation = "Left";
          sizeIconToButton = "1";
          makeIconSquare = "1";
          textLocation = "Right";
          textMargin = "4";
          autoSize = "0";
-         text = "Next Tab";
+         text = "Query Online";
          groupNum = "-1";
          buttonType = "PushButton";
          useMouseEvents = "0";
@@ -675,28 +514,27 @@ $guiContent = new GuiControl(JoinServerMenu) {
          horizSizing = "right";
          vertSizing = "bottom";
          profile = "GuiMenuButtonProfile";
-         visible = "0";
-         active = "0";
-         command = "OptionsMenu.nextTab();";
+         visible = "1";
+         active = "1";
+         command = "JoinServerMenu.query();";
          tooltipProfile = "GuiToolTipProfile";
          hovertime = "1000";
          isContainer = "0";
          internalName = "queryInternetButton";
          class = "MenuInputButton";
-         hidden = "1";
          canSave = "1";
          canSaveDynamicFields = "0";
       };
       new GuiIconButtonCtrl() {
          buttonMargin = "4 4";
-         bitmapAsset = "UI:Keyboard_Black_R_image";
+         BitmapAsset = "UI:Keyboard_Black_R_image";
          iconLocation = "Left";
          sizeIconToButton = "1";
          makeIconSquare = "1";
          textLocation = "Right";
          textMargin = "4";
          autoSize = "0";
-         text = "Reset";
+         text = "Refresh";
          groupNum = "-1";
          buttonType = "PushButton";
          useMouseEvents = "0";
@@ -708,7 +546,7 @@ $guiContent = new GuiControl(JoinServerMenu) {
          profile = "GuiMenuButtonProfile";
          visible = "1";
          active = "1";
-         command = "OptionsMenu.resetToDefaults();";
+         command = "JoinServerMenu.refresh();";
          tooltipProfile = "GuiToolTipProfile";
          hovertime = "1000";
          isContainer = "0";
diff --git a/Templates/BaseGame/game/data/UI/guis/joinServerMenu.tscript b/Templates/BaseGame/game/data/UI/guis/joinServerMenu.tscript
index e65e85e5d..b2f0eb8eb 100644
--- a/Templates/BaseGame/game/data/UI/guis/joinServerMenu.tscript
+++ b/Templates/BaseGame/game/data/UI/guis/joinServerMenu.tscript
@@ -3,10 +3,12 @@ function JoinServerMenu::onWake()
 {
    // Double check the status. Tried setting this the control
    // inactive to start with, but that didn't seem to work.
-   JoinServerJoinBtn.setActive(JS_serverList.rowCount() > 0);
+   JoinServerJoinBtn.setActive(JoinServerList.getCount() > 0);
    
    JoinServerButtonHolder.setActive();
    
+   JoinServerList.setAsActiveMenuList();
+   
    JoinServerMenuInputHandler.setFirstResponder();
 }   
 
@@ -16,7 +18,7 @@ function JoinServerButtonHolder::onWake(%this)
    %this-->backButton.set("btn_b", "Escape", "Back", "JoinServerMenu.backOut();");
    %this-->refreshButton.set("btn_y", "R", "Refresh", "JoinServerMenu.refresh();");
    %this-->queryLANButton.set("btn_a", "Q", "Query LAN", "JoinServerMenu.queryLan();");
-   %this-->queryInternetButton.set("btn_x", "E", "Query Internet", "JoinServerMenu.query();");
+   %this-->queryInternetButton.set("btn_x", "E", "Query Online", "JoinServerMenu.query();");
 }
 
 function JoinServerMenuInputHandler::onInputEvent(%this, %device, %action, %state)
@@ -110,23 +112,23 @@ function JoinServerMenu::update(%this)
 {
    // Copy the servers into the server list.
    JS_queryStatus.setVisible(false);
-   JS_serverList.clear();
+   JoinServerList.clear();
    %sc = getServerCount();
    for( %i = 0; %i < %sc; %i ++ ) {
       setServerInfo(%i);
-      JS_serverList.addRow( %i,
-         $ServerInfo::Name TAB
-         $ServerInfo::Ping TAB
-         $ServerInfo::PlayerCount @ "/" @ $ServerInfo::MaxPlayers TAB
-         $ServerInfo::Version TAB
-         $ServerInfo::MissionName
-      );
+      %serverBtn = new GuiButtonCtrl(){
+         text = $ServerInfo::Name TAB
+            $ServerInfo::Ping TAB
+            $ServerInfo::PlayerCount @ "/" @ $ServerInfo::MaxPlayers TAB
+            $ServerInfo::Version TAB
+            $ServerInfo::MissionName;
+         profile = GuiJoinServerButtonProfile;      
+         extent = JoinServerList.extent.x SPC 30; 
+      };
+      JoinServerList.add(%serverBtn);
    }
-   JS_serverList.sort(0);
-   JS_serverList.setSelectedRow(0);
-   JS_serverList.scrollVisible(0);
 
-   JoinServerJoinBtn.setActive(JS_serverList.rowCount() > 0);
+   JoinServerJoinBtn.setActive(JoinServerList.getCount() > 0);
 } 
 
 //----------------------------------------
@@ -141,11 +143,9 @@ function onServerQueryStatus(%status, %msg, %value)
 
    switch$ (%status) {
       case "start":
-         JoinServerJoinBtn.setActive(false);
-         JoinServerQryInternetBtn.setActive(false);
          JS_statusText.setText(%msg);
          JS_statusBar.setValue(0);
-         JS_serverList.clear();
+         JoinServerList.clear();
 
       case "ping":
          JS_statusText.setText("Ping Servers");
@@ -156,7 +156,6 @@ function onServerQueryStatus(%status, %msg, %value)
          JS_statusBar.setValue(%value);
 
       case "done":
-         JoinServerQryInternetBtn.setActive(true);
          JS_queryStatus.setVisible(false);
          JS_status.setText(%msg);
          JoinServerMenu.update();
diff --git a/Templates/BaseGame/game/data/UI/guis/mainMenu.gui b/Templates/BaseGame/game/data/UI/guis/mainMenu.gui
index f33c06b1d..4c6c13697 100644
--- a/Templates/BaseGame/game/data/UI/guis/mainMenu.gui
+++ b/Templates/BaseGame/game/data/UI/guis/mainMenu.gui
@@ -1,6 +1,6 @@
 //--- OBJECT WRITE BEGIN ---
 $guiContent = new GuiChunkedBitmapCtrl(MainMenuGui) {
-   bitmapAsset = "UI:background_dark_image";
+   BitmapAsset = "UI:background_dark_image";
    useVariable = "0";
    tile = "0";
    position = "0 0";
@@ -19,15 +19,11 @@ $guiContent = new GuiChunkedBitmapCtrl(MainMenuGui) {
       Enabled = "1";
       isDecoy = "0";
       navigationIndex = "-1";
-      
+
    new GuiBitmapCtrl(MainMenuAppLogo) {
-      bitmapAsset = "UI:Torque_3D_logo_alt_image";
-      bitmapMode = "Stretched";
-      autoFitExtents = "0";
-      useModifiers = "0";
-      useStates = "1";
-      masked = "0";
-      groupNum = "-1";
+      BitmapAsset = "UI:Torque_3D_logo_alt_image";
+      color = "255 255 255 255";
+      wrap = "0";
       position = "550 30";
       extent = "443 139";
       minExtent = "8 2";
@@ -41,26 +37,179 @@ $guiContent = new GuiChunkedBitmapCtrl(MainMenuGui) {
       isContainer = "0";
       canSave = "1";
       canSaveDynamicFields = "1";
+         autoFitExtents = "0";
+         bitmapMode = "Stretched";
+         groupNum = "-1";
+         masked = "0";
          navigationIndex = "-1";
+         useModifiers = "0";
+         useStates = "1";
    };
-
-   new GuiGameListMenuCtrl(MainMenuButtonList) {
-      debugRender = "0";
-      callbackOnInputs = "1";
-      position = "292 103";
-      extent = "439 561";
-      minExtent = "8 2";
+   new GuiStackControl(MainMenuButtonList) {
+      stackingType = "Vertical";
+      horizStacking = "Left to Right";
+      vertStacking = "Top to Bottom";
+      padding = "15";
+      dynamicSize = "0";
+      dynamicNonStackExtent = "0";
+      dynamicPos = "0";
+      changeChildSizeToFit = "1";
+      changeChildPosition = "1";
+      position = "312 111";
+      extent = "400 477";
+      minExtent = "16 16";
       horizSizing = "center";
       vertSizing = "center";
-      profile = "DefaultListMenuProfile";
+      profile = "GuiDefaultProfile";
       visible = "1";
       active = "1";
       tooltipProfile = "GuiToolTipProfile";
       hovertime = "1000";
-      isContainer = "0";
-      class = "UIMenuButtonList";
+      isContainer = "1";
       canSave = "1";
       canSaveDynamicFields = "0";
+      class = "MenuList";
+
+      new GuiButtonCtrl(MainMenuSinglePlayerBtn) {
+         text = "Single Player";
+         groupNum = "-1";
+         buttonType = "PushButton";
+         useMouseEvents = "0";
+         position = "0 0";
+         extent = "400 55";
+         minExtent = "8 2";
+         horizSizing = "right";
+         vertSizing = "bottom";
+         profile = "GuiMenuButtonProfile";
+         visible = "1";
+         active = "1";
+         command = "openSinglePlayerMenu();";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "0";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      new GuiButtonCtrl(MainMenuCreateSrvrBtn) {
+         text = "Create Server";
+         groupNum = "-1";
+         buttonType = "PushButton";
+         useMouseEvents = "0";
+         position = "0 70";
+         extent = "400 55";
+         minExtent = "8 2";
+         horizSizing = "right";
+         vertSizing = "bottom";
+         profile = "GuiMenuButtonProfile";
+         visible = "1";
+         active = "1";
+         command = "openMultiPlayerMenu();";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "0";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      new GuiButtonCtrl(MainMenuJoinSrvrBtn) {
+         text = "Join Server";
+         groupNum = "-1";
+         buttonType = "PushButton";
+         useMouseEvents = "0";
+         position = "0 140";
+         extent = "400 55";
+         minExtent = "8 2";
+         horizSizing = "right";
+         vertSizing = "bottom";
+         profile = "GuiMenuButtonProfile";
+         visible = "1";
+         active = "1";
+         command = "openJoinServerMenu();";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "0";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      new GuiButtonCtrl(MainMenuOptionBtn) {
+         text = "Options";
+         groupNum = "-1";
+         buttonType = "PushButton";
+         useMouseEvents = "0";
+         position = "0 210";
+         extent = "400 55";
+         minExtent = "8 2";
+         horizSizing = "right";
+         vertSizing = "bottom";
+         profile = "GuiMenuButtonProfile";
+         visible = "1";
+         active = "1";
+         command = "openOptionsMenu();";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "0";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      new GuiButtonCtrl(MainMenuWorldEditBtn) {
+         text = "Open World Editor";
+         groupNum = "-1";
+         buttonType = "PushButton";
+         useMouseEvents = "0";
+         position = "0 280";
+         extent = "400 55";
+         minExtent = "8 2";
+         horizSizing = "right";
+         vertSizing = "bottom";
+         profile = "GuiMenuButtonProfile";
+         visible = "1";
+         active = "1";
+         command = "openWorldEditorBtn();";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "0";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      new GuiButtonCtrl(MainMenuGuiEditBtn) {
+         text = "Open GUI Editor";
+         groupNum = "-1";
+         buttonType = "PushButton";
+         useMouseEvents = "0";
+         position = "0 350";
+         extent = "400 55";
+         minExtent = "8 2";
+         horizSizing = "right";
+         vertSizing = "bottom";
+         profile = "GuiMenuButtonProfile";
+         visible = "1";
+         active = "1";
+         command = "openGUIEditorBtn();";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "0";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      new GuiButtonCtrl(MainMenuExitBtn) {
+         text = "Exit";
+         groupNum = "-1";
+         buttonType = "PushButton";
+         useMouseEvents = "0";
+         position = "0 420";
+         extent = "400 55";
+         minExtent = "8 2";
+         horizSizing = "right";
+         vertSizing = "bottom";
+         profile = "GuiMenuButtonProfile";
+         visible = "1";
+         active = "1";
+         command = "exit();";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "0";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
    };
    new GuiControl(MainMenuButtonHolder) {
       position = "189 711";
@@ -80,7 +229,7 @@ $guiContent = new GuiChunkedBitmapCtrl(MainMenuGui) {
 
       new GuiIconButtonCtrl() {
          buttonMargin = "4 4";
-         iconBitmap = "data/ui/images/Inputs/Keyboard & Mouse/Keyboard_Black_Enter";
+         BitmapAsset = "UI:Keyboard_Black_Return_image";
          iconLocation = "Left";
          sizeIconToButton = "1";
          makeIconSquare = "1";
@@ -109,5 +258,26 @@ $guiContent = new GuiChunkedBitmapCtrl(MainMenuGui) {
          canSaveDynamicFields = "0";
       };
    };
+   new GuiInputCtrl(MainMenuInputHandler) {
+      class = "MenuInputHandler";
+      sendAxisEvents = "1";
+      sendBreakEvents = "1";
+      sendModifierEvents = "0";
+      ignoreMouseEvents = "1";
+      lockMouse = "0";
+      position = "-50 0";
+      extent = "10 10";
+      minExtent = "8 2";
+      horizSizing = "width";
+      vertSizing = "height";
+      profile = "GuiInputCtrlProfile";
+      visible = "1";
+      active = "1";
+      tooltipProfile = "GuiToolTipProfile";
+      hovertime = "1000";
+      isContainer = "0";
+      canSave = "1";
+      canSaveDynamicFields = "0";
+   };
 };
 //--- OBJECT WRITE END ---
diff --git a/Templates/BaseGame/game/data/UI/guis/mainMenu.tscript b/Templates/BaseGame/game/data/UI/guis/mainMenu.tscript
index f66551acd..0d830f176 100644
--- a/Templates/BaseGame/game/data/UI/guis/mainMenu.tscript
+++ b/Templates/BaseGame/game/data/UI/guis/mainMenu.tscript
@@ -5,8 +5,9 @@ function MainMenuGui::onAdd(%this)
 
 function MainMenuGui::onWake(%this)
 {
-   MainMenuButtonList.hidden = false; 
+   MainMenuButtonList.setAsActiveMenuList();
    MainMenuButtonHolder.setActive();
+   MainMenuInputHandler.setFirstResponder();
 }
 
 function MainMenuGui::onSleep(%this)
@@ -16,18 +17,7 @@ function MainMenuGui::onSleep(%this)
 
 function MainMenuButtonHolder::onWake(%this)
 {
-   %this-->goButton.set("btn_a", "Return", "Go", "MainMenuButtonList.activateRow();");
-}
-
-function MainMenuButtonList::onAdd(%this)
-{
-   MainMenuButtonList.addRow("Single Player", "openSinglePlayerMenu", 0);
-   MainMenuButtonList.addRow("Create Server", "openMultiPlayerMenu", 4, -15);
-   MainMenuButtonList.addRow("Join Server", "openJoinServerMenu", 4, -15);
-   MainMenuButtonList.addRow("Options", "openOptionsMenu", 6, -15);
-   MainMenuButtonList.addRow("Open World Editor", "openWorldEditorBtn", 6, -15);
-   MainMenuButtonList.addRow("Open GUI Editor", "openGUIEditorBtn", 6, -15);
-   MainMenuButtonList.addRow("Exit Game", "quit", 8, -15);
+   %this-->goButton.set("btn_a", "Return", "Go", "MainMenuButtonList.activate();");
 }
 
 function openSinglePlayerMenu()
diff --git a/Templates/BaseGame/game/data/UI/guis/optionsDlg.gui b/Templates/BaseGame/game/data/UI/guis/optionsDlg.gui
deleted file mode 100644
index b2758c32c..000000000
--- a/Templates/BaseGame/game/data/UI/guis/optionsDlg.gui
+++ /dev/null
@@ -1,1432 +0,0 @@
-//--- OBJECT WRITE BEGIN ---
-$guiContent = new GuiControl(OptionsDlg) {
-   position = "0 0";
-   extent = "1024 768";
-   minExtent = "8 8";
-   horizSizing = "width";
-   vertSizing = "height";
-   profile = "GuiOverlayProfile";
-   visible = "1";
-   active = "1";
-   tooltipProfile = "GuiToolTipProfile";
-   hovertime = "1000";
-   isContainer = "1";
-   canSave = "1";
-   canSaveDynamicFields = "1";
-      fixedAspectRatio = "0";
-
-   new GuiWindowCtrl() {
-      text = "Options";
-      resizeWidth = "0";
-      resizeHeight = "0";
-      canMove = "1";
-      canClose = "1";
-      canMinimize = "0";
-      canMaximize = "0";
-      canCollapse = "0";
-      closeCommand = "Canvas.popDialog(optionsDlg);";
-      edgeSnap = "0";
-      margin = "0 0 0 0";
-      padding = "0 0 0 0";
-      anchorTop = "1";
-      anchorBottom = "0";
-      anchorLeft = "1";
-      anchorRight = "0";
-      position = "323 232";
-      extent = "377 303";
-      minExtent = "8 8";
-      horizSizing = "center";
-      vertSizing = "center";
-      profile = "GuiWindowProfile";
-      visible = "1";
-      active = "1";
-      tooltipProfile = "GuiToolTipProfile";
-      hovertime = "1000";
-      isContainer = "1";
-      canSave = "1";
-      canSaveDynamicFields = "0";
-
-      new GuiButtonCtrl() {
-         text = "Done";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "306 271";
-         extent = "60 23";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "Canvas.popDialog(optionsDlg);";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiBitmapBorderCtrl() {
-         position = "9 55";
-         extent = "358 210";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiTabBorderProfile";
-         visible = "0";
-         active = "1";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "1";
-         internalName = "OptControlsPane";
-         hidden = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-
-         new GuiScrollCtrl() {
-            willFirstRespond = "1";
-            hScrollBar = "alwaysOff";
-            vScrollBar = "alwaysOn";
-            lockHorizScroll = "1";
-            lockVertScroll = "0";
-            constantThumbHeight = "0";
-            childMargin = "0 0";
-            mouseWheelScrollSpeed = "-1";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "5 24";
-            extent = "347 152";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiScrollProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "1";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-
-            new GuiTextListCtrl() {
-               columns = "0 160";
-               fitParentWidth = "1";
-               clipColumnText = "0";
-               position = "1 1";
-               extent = "329 780";
-               minExtent = "8 8";
-               horizSizing = "right";
-               vertSizing = "bottom";
-               profile = "GuiDefaultProfile";
-               visible = "1";
-               active = "1";
-               altCommand = "OptionsDlg.doRemap();";
-               tooltipProfile = "GuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "1";
-               internalName = "OptRemapList";
-               canSave = "1";
-               canSaveDynamicFields = "0";
-            };
-         };
-         new GuiTextCtrl() {
-            text = "Control Name";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "6 6";
-            extent = "64 18";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextCtrl() {
-            text = "Control Binding";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "165 6";
-            extent = "72 18";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-		 
-         new GuiSliderCtrl(OptMouseSensitivity) {  
-            range = "0.02 2";  
-            ticks = "10";  
-            value = "0.75";  
-            isContainer = "0";  
-            Profile = "GuiSliderProfile";  
-            HorizSizing = "right";  
-            VertSizing = "bottom";  
-            position = "105 182";  
-            Extent = "244 18";  
-            MinExtent = "8 2";  
-            canSave = "1";  
-            Visible = "1";  
-            Command = "OptMouseSetSensitivity(OptMouseSensitivity.value);";  
-            tooltipprofile = "GuiToolTipProfile";  
-            hovertime = "1000";  
-            canSaveDynamicFields = "0";  
-         };  
-         new GuiTextCtrl() {  
-            text = "Mouse Sensitivity:"; 
-            maxLength = "255";  
-            Margin = "0 0 0 0";  
-            Padding = "0 0 0 0";  
-            AnchorTop = "1";  
-            AnchorBottom = "0";  
-            AnchorLeft = "1";  
-            AnchorRight = "0";  
-            isContainer = "0";  
-            Profile = "GuiTextProfile";  
-            HorizSizing = "right";  
-            VertSizing = "bottom";  
-            position = "15 182";  
-            Extent = "85 18";  
-            MinExtent = "8 8";  
-            canSave = "1";  
-            Visible = "1";  
-            tooltipprofile = "GuiToolTipProfile";  
-            hovertime = "1000";  
-            canSaveDynamicFields = "0";  
-         };  
-      };
-      new GuiBitmapBorderCtrl() {
-         position = "9 55";
-         extent = "358 210";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiTabBorderProfile";
-         visible = "0";
-         active = "1";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "1";
-         internalName = "OptAudioPane";
-         hidden = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-
-         new GuiMLTextCtrl() {
-            lineSpacing = "2";
-            allowColorChars = "0";
-            maxChars = "-1";
-            useURLMouseCursor = "0";
-            position = "149 10";
-            extent = "190 14";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiMLTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            internalName = "OptAudioInfo";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextCtrl() {
-            text = "Audio Provider:";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "16 16";
-            extent = "75 18";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiPopUpMenuCtrl(OptAudioProviderList) {
-            maxPopupHeight = "200";
-            sbUsesNAColor = "0";
-            reverseTextList = "0";
-            bitmapBounds = "16 16";
-            text = "Null";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "101 15";
-            extent = "240 18";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiPopUpMenuProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextCtrl() {
-            text = "Audio Device:";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "23 48";
-            extent = "75 18";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiPopUpMenuCtrl(OptAudioDeviceList) {
-            maxPopupHeight = "200";
-            sbUsesNAColor = "0";
-            reverseTextList = "0";
-            bitmapBounds = "16 16";
-            text = "SFX Null Device";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "101 47";
-            extent = "240 18";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiPopUpMenuProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiControl() {
-            position = "18 84";
-            extent = "325 17";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiDefaultProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "1";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-
-            new GuiTextCtrl() {
-               text = "Master Volume";
-               maxLength = "255";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
-               anchorTop = "1";
-               anchorBottom = "0";
-               anchorLeft = "1";
-               anchorRight = "0";
-               position = "0 0";
-               extent = "72 18";
-               minExtent = "8 8";
-               horizSizing = "right";
-               vertSizing = "bottom";
-               profile = "GuiAutoSizeTextProfile";
-               visible = "1";
-               active = "1";
-               tooltipProfile = "GuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
-            };
-            new GuiSliderCtrl() {
-               range = "0 1";
-               ticks = "0";
-               snap = "0";
-               value = "0.8";
-               position = "85 1";
-               extent = "240 14";
-               minExtent = "8 8";
-               horizSizing = "right";
-               vertSizing = "bottom";
-               profile = "GuiSliderProfile";
-               visible = "1";
-               active = "1";
-               altCommand = "OptAudioUpdateMasterVolume( $thisControl.value );";
-               tooltipProfile = "GuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               internalName = "OptAudioVolumeMaster";
-               canSave = "1";
-               canSaveDynamicFields = "0";
-            };
-         };
-         new GuiControl() {
-            position = "9 115";
-            extent = "334 17";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiDefaultProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "1";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-
-            new GuiTextCtrl() {
-               text = "Interface Volume";
-               maxLength = "255";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
-               anchorTop = "1";
-               anchorBottom = "0";
-               anchorLeft = "1";
-               anchorRight = "0";
-               position = "0 0";
-               extent = "82 18";
-               minExtent = "8 8";
-               horizSizing = "right";
-               vertSizing = "bottom";
-               profile = "GuiAutoSizeTextProfile";
-               visible = "1";
-               active = "1";
-               tooltipProfile = "GuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
-            };
-            new GuiSliderCtrl() {
-               range = "0 1";
-               ticks = "0";
-               snap = "0";
-               value = "1";
-               position = "94 2";
-               extent = "240 13";
-               minExtent = "8 8";
-               horizSizing = "right";
-               vertSizing = "bottom";
-               profile = "GuiSliderProfile";
-               visible = "1";
-               active = "1";
-               altCommand = "OptAudioUpdateChannelVolume(AudioGui, $thisControl.value);";
-               tooltipProfile = "GuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               internalName = "OptAudioVolumeShell";
-               canSave = "1";
-               canSaveDynamicFields = "0";
-            };
-         };
-         new GuiControl() {
-            position = "18 146";
-            extent = "325 17";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiDefaultProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "1";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-
-            new GuiTextCtrl() {
-               text = "Effects Volume";
-               maxLength = "255";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
-               anchorTop = "1";
-               anchorBottom = "0";
-               anchorLeft = "1";
-               anchorRight = "0";
-               position = "0 0";
-               extent = "74 18";
-               minExtent = "8 8";
-               horizSizing = "right";
-               vertSizing = "bottom";
-               profile = "GuiAutoSizeTextProfile";
-               visible = "1";
-               active = "1";
-               tooltipProfile = "GuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
-            };
-            new GuiSliderCtrl() {
-               range = "0 1";
-               ticks = "0";
-               snap = "0";
-               value = "1";
-               position = "85 2";
-               extent = "240 13";
-               minExtent = "8 8";
-               horizSizing = "right";
-               vertSizing = "bottom";
-               profile = "GuiSliderProfile";
-               visible = "1";
-               active = "1";
-               altCommand = "OptAudioUpdateChannelVolume(AudioEffect, $thisControl.value);";
-               tooltipProfile = "GuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               internalName = "OptAudioVolumeSim";
-               canSave = "1";
-               canSaveDynamicFields = "0";
-            };
-         };
-         new GuiControl() {
-            position = "23 177";
-            extent = "320 17";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiDefaultProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "1";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-
-            new GuiSliderCtrl() {
-               range = "0 1";
-               ticks = "0";
-               snap = "0";
-               value = "1";
-               position = "80 2";
-               extent = "240 13";
-               minExtent = "8 8";
-               horizSizing = "right";
-               vertSizing = "bottom";
-               profile = "GuiSliderProfile";
-               visible = "1";
-               active = "1";
-               altCommand = "OptAudioUpdateChannelVolume(AudioMusic, $thisControl.value);";
-               tooltipProfile = "GuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               internalName = "OptAudioVolumeMusic";
-               canSave = "1";
-               canSaveDynamicFields = "0";
-            };
-            new GuiTextCtrl() {
-               text = "Music Volume";
-               maxLength = "255";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
-               anchorTop = "1";
-               anchorBottom = "0";
-               anchorLeft = "1";
-               anchorRight = "0";
-               position = "0 0";
-               extent = "67 18";
-               minExtent = "8 8";
-               horizSizing = "right";
-               vertSizing = "bottom";
-               profile = "GuiAutoSizeTextProfile";
-               visible = "1";
-               active = "1";
-               tooltipProfile = "GuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
-            };
-         };
-      };
-      new GuiBitmapBorderCtrl() {
-         position = "9 55";
-         extent = "358 210";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiTabBorderProfile";
-         visible = "1";
-         active = "1";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "1";
-         internalName = "OptGraphicsPane";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-
-         new GuiTextCtrl() {
-            text = "Display Driver:";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "11 8";
-            extent = "70 18";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextCtrl() {
-            text = "Resolution:";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "11 35";
-            extent = "53 18";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiCheckBoxCtrl() {
-            text = "Fullscreen";
-            groupNum = "-1";
-            buttonType = "ToggleButton";
-            useMouseEvents = "0";
-            position = "11 62";
-            extent = "85 18";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiCheckBoxProfile";
-            visible = "1";
-            active = "1";
-            command = "OptionsDlg._updateApplyState();";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            internalName = "OptGraphicsFullscreenToggle";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiPopUpMenuCtrl(OptGraphicsDriverMenu) {
-            maxPopupHeight = "200";
-            sbUsesNAColor = "0";
-            reverseTextList = "0";
-            bitmapBounds = "16 16";
-            text = "ATI Radeon HD 5700 Series (D3D9)";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "88 8";
-            extent = "258 18";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiPopUpMenuProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiPopUpMenuCtrl() {
-            maxPopupHeight = "200";
-            sbUsesNAColor = "0";
-            reverseTextList = "0";
-            bitmapBounds = "16 16";
-            text = "1024 x 768  (4:3)";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "67 35";
-            extent = "127 18";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiPopUpMenuProfile";
-            visible = "1";
-            active = "1";
-            command = "OptionsDlg._updateApplyState();";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            internalName = "OptGraphicsResolutionMenu";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextCtrl() {
-            text = "Refresh:";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "207 35";
-            extent = "45 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiPopUpMenuCtrl() {
-            maxPopupHeight = "200";
-            sbUsesNAColor = "0";
-            reverseTextList = "0";
-            bitmapBounds = "16 16";
-            text = "60";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "252 35";
-            extent = "49 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiPopUpMenuProfile";
-            visible = "1";
-            active = "1";
-            command = "OptionsDlg._updateApplyState();";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            internalName = "OptRefreshSelectMenu";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextCtrl() {
-            text = "Mesh Quality:";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "21 91";
-            extent = "62 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiPopUpMenuCtrl() {
-            maxPopupHeight = "200";
-            sbUsesNAColor = "0";
-            reverseTextList = "0";
-            bitmapBounds = "16 16";
-            text = "Low";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "90 91";
-            extent = "78 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiPopUpMenuProfile";
-            visible = "1";
-            active = "1";
-            command = "OptionsDlg._updateApplyState();";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            internalName = "OptMeshQualityPopup";
-            class = "GraphicsQualityPopup";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiPopUpMenuCtrl() {
-            maxPopupHeight = "200";
-            sbUsesNAColor = "0";
-            reverseTextList = "0";
-            bitmapBounds = "16 16";
-            text = "Low";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "90 118";
-            extent = "78 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiPopUpMenuProfile";
-            visible = "1";
-            active = "1";
-            command = "OptionsDlg._updateApplyState();";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            internalName = "OptTextureQualityPopup";
-            class = "GraphicsQualityPopup";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextCtrl() {
-            text = "Texture Quality:";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "11 118";
-            extent = "77 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiPopUpMenuCtrl() {
-            maxPopupHeight = "200";
-            sbUsesNAColor = "0";
-            reverseTextList = "0";
-            bitmapBounds = "16 16";
-            text = "Low";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "90 143";
-            extent = "78 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiPopUpMenuProfile";
-            visible = "1";
-            active = "1";
-            command = "OptionsDlg._updateApplyState();";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            internalName = "OptLightingQualityPopup";
-            class = "GraphicsQualityPopup";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextCtrl() {
-            text = "Lighting Quality:";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "11 143";
-            extent = "73 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextCtrl() {
-            text = "Effect Quality:";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "191 91";
-            extent = "73 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiPopUpMenuCtrl() {
-            maxPopupHeight = "200";
-            sbUsesNAColor = "0";
-            reverseTextList = "0";
-            bitmapBounds = "16 16";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "263 91";
-            extent = "78 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiPopUpMenuProfile";
-            visible = "1";
-            active = "1";
-            command = "OptionsDlg._updateApplyState();";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            internalName = "OptEffectQualityPopup";
-            class = "GraphicsQualityPopup";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextCtrl() {
-            text = "Shader Quality:";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "186 118";
-            extent = "77 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiPopUpMenuCtrl() {
-            maxPopupHeight = "200";
-            sbUsesNAColor = "0";
-            reverseTextList = "0";
-            bitmapBounds = "16 16";
-            text = "Low";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "263 118";
-            extent = "78 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiPopUpMenuProfile";
-            visible = "1";
-            active = "1";
-            command = "OptionsDlg._updateApplyState();";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            internalName = "OptShaderQualityPopup";
-            class = "GraphicsQualityPopup";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextCtrl() {
-            text = "Particle Quality:";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "186 156";
-            extent = "73 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "0";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            hidden = "1";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiPopUpMenuCtrl() {
-            maxPopupHeight = "200";
-            sbUsesNAColor = "0";
-            reverseTextList = "0";
-            bitmapBounds = "16 16";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "263 156";
-            extent = "78 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiPopUpMenuProfile";
-            visible = "0";
-            active = "1";
-            command = "OptionsDlg._updateApplyState();";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            internalName = "OptParticleQualityPopup";
-            class = "GraphicsQualityPopup";
-            hidden = "1";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextCtrl() {
-            text = "Anisotropic Filtering:";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "22 167";
-            extent = "105 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiPopUpMenuCtrl() {
-            maxPopupHeight = "200";
-            sbUsesNAColor = "0";
-            reverseTextList = "0";
-            bitmapBounds = "16 16";
-            text = "Off";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "123 167";
-            extent = "45 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiPopUpMenuProfile";
-            visible = "1";
-            active = "1";
-            command = "OptionsDlg._updateApplyState();";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            internalName = "OptAnisotropicPopup";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiCheckBoxCtrl() {
-            text = "Vertical Sync";
-            groupNum = "-1";
-            buttonType = "ToggleButton";
-            useMouseEvents = "0";
-            position = "92 62";
-            extent = "85 18";
-            minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiCheckBoxProfile";
-            visible = "1";
-            active = "1";
-            command = "OptionsDlg._updateApplyState();";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            internalName = "OptGraphicsVSyncToggle";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiButtonCtrl() {
-            text = "Auto Detect Quality";
-            groupNum = "-1";
-            buttonType = "PushButton";
-            useMouseEvents = "0";
-            position = "205 152";
-            extent = "110 27";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiButtonProfile";
-            visible = "1";
-            active = "1";
-            command = "OptionsDlg._autoDetectQuality();";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiPopUpMenuCtrl() {
-            maxPopupHeight = "200";
-            sbUsesNAColor = "0";
-            reverseTextList = "0";
-            bitmapBounds = "16 16";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "263 62";
-            extent = "78 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiPopUpMenuProfile";
-            visible = "1";
-            active = "1";
-            command = "OptionsDlg._updateApplyState();";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            internalName = "OptAAQualityPopup";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiTextCtrl() {
-            text = "Anti-aliasing";
-            maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "191 62";
-            extent = "73 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
-            profile = "GuiTextProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-         new GuiControl() {
-            position = "0 190";
-            extent = "352 15";
-            minExtent = "8 2";
-            horizSizing = "width";
-            vertSizing = "bottom";
-            profile = "GuiDefaultProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "1";
-            internalName = "GammaSliderContainer";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-
-            new GuiSliderCtrl() {
-               range = "0.001 2.2";
-               ticks = "0";
-               snap = "0";
-               value = "1";
-               position = "76 -1";
-               extent = "268 15";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
-               profile = "GuiSliderProfile";
-               visible = "1";
-               active = "1";
-               variable = "$pref::Video::Gamma";
-               tooltipProfile = "GuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
-            };
-            new GuiTextCtrl() {
-               text = "Gamma:";
-               maxLength = "255";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
-               anchorTop = "1";
-               anchorBottom = "0";
-               anchorLeft = "1";
-               anchorRight = "0";
-               position = "22 -4";
-               extent = "105 18";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
-               profile = "GuiTextProfile";
-               visible = "1";
-               active = "1";
-               tooltipProfile = "GuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
-            };
-         };
-      };
-      new GuiControl() {
-         position = "9 55";
-         extent = "357 208";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiWindowProfile";
-         visible = "0";
-         active = "1";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "1";
-         internalName = "OptNetworkPane";
-         hidden = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl() {
-         text = "Graphics";
-         groupNum = "-1";
-         buttonType = "RadioButton";
-         useMouseEvents = "0";
-         position = "9 33";
-         extent = "117 23";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiButtonTabProfile";
-         visible = "1";
-         active = "1";
-         command = "optionsDlg.setPane(Graphics);";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "OptGraphicsButton";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl() {
-         text = "Audio";
-         groupNum = "-1";
-         buttonType = "RadioButton";
-         useMouseEvents = "0";
-         position = "126 33";
-         extent = "117 23";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiButtonTabProfile";
-         visible = "1";
-         active = "1";
-         command = "optionsDlg.setPane(Audio);";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl() {
-         text = "Controls";
-         groupNum = "-1";
-         buttonType = "RadioButton";
-         useMouseEvents = "0";
-         position = "243 33";
-         extent = "117 23";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiButtonTabProfile";
-         visible = "1";
-         active = "1";
-         command = "optionsDlg.setPane(Controls);";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl() {
-         text = "Apply";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "241 271";
-         extent = "60 23";
-         minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiButtonProfile";
-         visible = "1";
-         active = "0";
-         command = "optionsDlg.applyGraphics();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "apply";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-   };
-   new GuiControl(OptionsButtonHolder) {
-      position = "190 652";
-      extent = "646 130";
-      minExtent = "8 2";
-      horizSizing = "center";
-      vertSizing = "top";
-      profile = "GuiDefaultProfile";
-      visible = "1";
-      active = "1";
-      tooltipProfile = "GuiToolTipProfile";
-      hovertime = "1000";
-      isContainer = "1";
-      canSave = "1";
-      canSaveDynamicFields = "0";
-   };
-};
-//--- OBJECT WRITE END ---
diff --git a/Templates/BaseGame/game/data/UI/guis/optionsMenu.gui b/Templates/BaseGame/game/data/UI/guis/optionsMenu.gui
index 9b76cb979..b7195557c 100644
--- a/Templates/BaseGame/game/data/UI/guis/optionsMenu.gui
+++ b/Templates/BaseGame/game/data/UI/guis/optionsMenu.gui
@@ -23,7 +23,7 @@ $guiContent = new GuiControl(OptionsMenu) {
       position = "48 56";
       extent = "928 655";
       minExtent = "8 2";
-      horizSizing = "center";
+      horizSizing = "aspectCenter";
       vertSizing = "center";
       profile = "GuiDefaultProfile";
       visible = "1";
@@ -38,7 +38,27 @@ $guiContent = new GuiControl(OptionsMenu) {
          percent = "100";
          vertical = "0";
          flipClip = "0";
-         bitmap = "data/ui/images/panel.png";
+         BitmapAsset = "UI:panel_low_image";
+         color = "255 255 255 255";
+         position = "0 40";
+         extent = "927 618";
+         minExtent = "8 2";
+         horizSizing = "width";
+         vertSizing = "bottom";
+         profile = "GuiDefaultProfile";
+         visible = "1";
+         active = "1";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "0";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      new GuiBitmapBarCtrl() {
+         percent = "100";
+         vertical = "0";
+         flipClip = "0";
+         BitmapAsset = "UI:panel_image";
          color = "255 255 255 255";
          position = "0 0";
          extent = "927 40";
@@ -77,179 +97,6 @@ $guiContent = new GuiControl(OptionsMenu) {
          canSave = "1";
          canSaveDynamicFields = "0";
       };
-      new GuiBitmapBarCtrl() {
-         percent = "100";
-         vertical = "0";
-         flipClip = "0";
-         bitmap = "data/ui/images/panel_low.png";
-         color = "255 255 255 255";
-         position = "0 40";
-         extent = "927 618";
-         minExtent = "8 2";
-         horizSizing = "width";
-         vertSizing = "bottom";
-         profile = "GuiDefaultProfile";
-         visible = "1";
-         active = "1";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl() {
-         text = "Display";
-         groupNum = "1";
-         buttonType = "RadioButton";
-         useMouseEvents = "0";
-         position = "114 49";
-         extent = "140 32";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "OptionsMenu.populateDisplaySettingsList();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "DisplayButton";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl() {
-         text = "Graphics";
-         groupNum = "1";
-         buttonType = "RadioButton";
-         useMouseEvents = "0";
-         position = "258 49";
-         extent = "140 32";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "OptionsMenu.populateGraphicsSettingsList();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "GraphicsButton";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl() {
-         text = "Audio";
-         groupNum = "1";
-         buttonType = "RadioButton";
-         useMouseEvents = "0";
-         position = "402 49";
-         extent = "140 32";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "OptionsMenu.populateAudioSettingsList();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "AudioButton";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl() {
-         text = "Keyboard + Mouse";
-         groupNum = "1";
-         buttonType = "RadioButton";
-         useMouseEvents = "0";
-         position = "547 49";
-         extent = "140 32";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "OptionsMenu.populateKeyboardMouseSettingsList();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "KBMButton";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl() {
-         text = "Gamepad";
-         groupNum = "1";
-         buttonType = "RadioButton";
-         useMouseEvents = "0";
-         position = "691 49";
-         extent = "140 32";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "OptionsMenu.populateGamepadSettingsList();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "gamepadButton";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiScrollCtrl() {
-         willFirstRespond = "1";
-         hScrollBar = "alwaysOff";
-         vScrollBar = "dynamic";
-         lockHorizScroll = "1";
-         lockVertScroll = "0";
-         constantThumbHeight = "0";
-         childMargin = "0 0";
-         mouseWheelScrollSpeed = "-1";
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
-         position = "1 83";
-         extent = "622 573";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuScrollProfile";
-         visible = "1";
-         active = "1";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-
-         new GuiGameListMenuCtrl(OptionsMenuSettingsList) {
-            debugRender = "0";
-            callbackOnInputs = "1";
-            position = "1 1";
-            extent = "621 510";
-            minExtent = "8 2";
-            horizSizing = "width";
-            vertSizing = "bottom";
-            profile = "DefaultListMenuProfile";
-            visible = "1";
-            active = "1";
-            tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            class = "UIMenuButtonList";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-      };
       new GuiTextCtrl(OptionName) {
          maxLength = "1024";
          margin = "0 0 0 0";
@@ -258,10 +105,10 @@ $guiContent = new GuiControl(OptionsMenu) {
          anchorBottom = "0";
          anchorLeft = "1";
          anchorRight = "0";
-         position = "635 94";
+         position = "3 606";
          extent = "293 17";
          minExtent = "8 2";
-         horizSizing = "right";
+         horizSizing = "width";
          vertSizing = "bottom";
          profile = "MenuSubHeaderText";
          visible = "1";
@@ -278,10 +125,10 @@ $guiContent = new GuiControl(OptionsMenu) {
          maxChars = "-1";
          text = "This is a placeholder text for an option.";
          useURLMouseCursor = "0";
-         position = "635 126";
+         position = "3 625";
          extent = "293 14";
          minExtent = "8 2";
-         horizSizing = "right";
+         horizSizing = "width";
          vertSizing = "bottom";
          profile = "GuiMLTextProfile";
          visible = "1";
@@ -292,24 +139,286 @@ $guiContent = new GuiControl(OptionsMenu) {
          canSave = "1";
          canSaveDynamicFields = "0";
       };
-   };
-   new GuiControl() {
-      position = "189 652";
-      extent = "646 130";
-      minExtent = "8 2";
-      horizSizing = "center";
-      vertSizing = "top";
-      profile = "GuiDefaultProfile";
-      visible = "1";
-      active = "1";
-      tooltipProfile = "GuiToolTipProfile";
-      hovertime = "1000";
-      isContainer = "1";
-      canSave = "1";
-      canSaveDynamicFields = "0";
+      new GuiSplitContainer() {
+         orientation = "Vertical";
+         splitterSize = "2";
+         splitPoint = "250 100";
+         fixedPanel = "FirstPanel";
+         fixedSize = "250";
+         docking = "None";
+         margin = "0 0 0 0";
+         padding = "0 0 0 0";
+         anchorTop = "1";
+         anchorBottom = "0";
+         anchorLeft = "1";
+         anchorRight = "0";
+         position = "0 48";
+         extent = "928 555";
+         minExtent = "64 64";
+         horizSizing = "width";
+         vertSizing = "bottom";
+         profile = "GuiMenuScrollProfile";
+         visible = "1";
+         active = "1";
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "1";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+
+         new GuiPanel() {
+            docking = "Client";
+            margin = "0 0 0 0";
+            padding = "0 0 0 0";
+            anchorTop = "1";
+            anchorBottom = "0";
+            anchorLeft = "1";
+            anchorRight = "0";
+            position = "0 0";
+            extent = "248 555";
+            minExtent = "16 16";
+            horizSizing = "right";
+            vertSizing = "bottom";
+            profile = "GuiOverlayProfile";
+            visible = "1";
+            active = "1";
+            tooltipProfile = "GuiToolTipProfile";
+            hovertime = "1000";
+            isContainer = "1";
+            internalName = "Panel1";
+            canSave = "1";
+            canSaveDynamicFields = "0";
+
+            new GuiStackControl(OptionsMenuCategoryList) {
+               stackingType = "Vertical";
+               horizStacking = "Left to Right";
+               vertStacking = "Top to Bottom";
+               padding = "10";
+               dynamicSize = "0";
+               dynamicNonStackExtent = "0";
+               dynamicPos = "0";
+               changeChildSizeToFit = "1";
+               changeChildPosition = "1";
+               position = "0 0";
+               extent = "248 555";
+               minExtent = "16 16";
+               horizSizing = "width";
+               vertSizing = "height";
+               profile = "GuiDefaultProfile";
+               visible = "1";
+               active = "1";
+               tooltipProfile = "GuiToolTipProfile";
+               hovertime = "1000";
+               isContainer = "1";
+               class = "MenuList";
+               canSave = "1";
+               canSaveDynamicFields = "0";
+
+               new GuiButtonCtrl(OptionsMenuDisplayBtn) {
+                  text = "Display";
+                  groupNum = "-1";
+                  buttonType = "PushButton";
+                  useMouseEvents = "0";
+                  position = "0 0";
+                  extent = "248 35";
+                  minExtent = "8 2";
+                  horizSizing = "right";
+                  vertSizing = "bottom";
+                  profile = "GuiMenuButtonProfile";
+                  visible = "1";
+                  active = "1";
+                  command = "populateDisplaySettingsList();";
+                  tooltipProfile = "GuiToolTipProfile";
+                  hovertime = "1000";
+                  isContainer = "0";
+                  canSave = "1";
+                  canSaveDynamicFields = "0";
+               };
+               new GuiButtonCtrl(OptionsMenuGraphicsBtn) {
+                  text = "Graphics";
+                  groupNum = "-1";
+                  buttonType = "PushButton";
+                  useMouseEvents = "0";
+                  position = "0 45";
+                  extent = "248 35";
+                  minExtent = "8 2";
+                  horizSizing = "right";
+                  vertSizing = "bottom";
+                  profile = "GuiMenuButtonProfile";
+                  visible = "1";
+                  active = "1";
+                  command = "populateGraphicsSettingsList();";
+                  tooltipProfile = "GuiToolTipProfile";
+                  hovertime = "1000";
+                  isContainer = "0";
+                  canSave = "1";
+                  canSaveDynamicFields = "0";
+               };
+               new GuiButtonCtrl(OptionsMenuAudioBtn) {
+                  text = "Audio";
+                  groupNum = "-1";
+                  buttonType = "PushButton";
+                  useMouseEvents = "0";
+                  position = "0 90";
+                  extent = "248 35";
+                  minExtent = "8 2";
+                  horizSizing = "right";
+                  vertSizing = "bottom";
+                  profile = "GuiMenuButtonProfile";
+                  visible = "1";
+                  active = "1";
+                  command = "populateAudioSettingsList();";
+                  tooltipProfile = "GuiToolTipProfile";
+                  hovertime = "1000";
+                  isContainer = "0";
+                  canSave = "1";
+                  canSaveDynamicFields = "0";
+               };
+               new GuiButtonCtrl(OptionsMenuKBMBtn) {
+                  text = "Keyboard & Mouse";
+                  groupNum = "-1";
+                  buttonType = "PushButton";
+                  useMouseEvents = "0";
+                  position = "0 135";
+                  extent = "248 35";
+                  minExtent = "8 2";
+                  horizSizing = "right";
+                  vertSizing = "bottom";
+                  profile = "GuiMenuButtonProfile";
+                  visible = "1";
+                  active = "1";
+                  command = "populateKeyboardMouseSettingsList();";
+                  tooltipProfile = "GuiToolTipProfile";
+                  hovertime = "1000";
+                  isContainer = "0";
+                  canSave = "1";
+                  canSaveDynamicFields = "0";
+               };
+               new GuiButtonCtrl(OptionsMenuGamepadBtn) {
+                  text = "Gamepad";
+                  groupNum = "-1";
+                  buttonType = "PushButton";
+                  useMouseEvents = "0";
+                  position = "0 180";
+                  extent = "248 35";
+                  minExtent = "8 2";
+                  horizSizing = "right";
+                  vertSizing = "bottom";
+                  profile = "GuiMenuButtonProfile";
+                  visible = "1";
+                  active = "1";
+                  command = "populateGamepadSettingsList();";
+                  tooltipProfile = "GuiToolTipProfile";
+                  hovertime = "1000";
+                  isContainer = "0";
+                  canSave = "1";
+                  canSaveDynamicFields = "0";
+               };
+               new GuiButtonCtrl(OptionsMenuProfileBtn) {
+                  text = "Profile";
+                  groupNum = "-1";
+                  buttonType = "PushButton";
+                  useMouseEvents = "0";
+                  position = "0 225";
+                  extent = "248 35";
+                  minExtent = "8 2";
+                  horizSizing = "right";
+                  vertSizing = "bottom";
+                  profile = "GuiMenuButtonProfile";
+                  visible = "1";
+                  active = "1";
+                  command = "populateProfileSettingsList();";
+                  tooltipProfile = "GuiToolTipProfile";
+                  hovertime = "1000";
+                  isContainer = "0";
+                  canSave = "1";
+                  canSaveDynamicFields = "0";
+               };
+            };
+         };
+         new GuiPanel() {
+            docking = "Client";
+            margin = "0 0 0 0";
+            padding = "0 0 0 0";
+            anchorTop = "1";
+            anchorBottom = "0";
+            anchorLeft = "1";
+            anchorRight = "0";
+            position = "252 0";
+            extent = "676 555";
+            minExtent = "16 16";
+            horizSizing = "right";
+            vertSizing = "bottom";
+            profile = "GuiOverlayProfile";
+            visible = "1";
+            active = "1";
+            tooltipProfile = "GuiToolTipProfile";
+            hovertime = "1000";
+            isContainer = "1";
+            internalName = "panel2";
+            canSave = "1";
+            canSaveDynamicFields = "0";
+
+            new GuiScrollCtrl() {
+               willFirstRespond = "1";
+               hScrollBar = "alwaysOff";
+               vScrollBar = "dynamic";
+               lockHorizScroll = "0";
+               lockVertScroll = "0";
+               constantThumbHeight = "0";
+               childMargin = "0 0";
+               mouseWheelScrollSpeed = "-1";
+               margin = "0 0 0 0";
+               padding = "0 0 0 0";
+               anchorTop = "1";
+               anchorBottom = "0";
+               anchorLeft = "1";
+               anchorRight = "0";
+               position = "0 0";
+               extent = "676 554";
+               minExtent = "8 2";
+               horizSizing = "width";
+               vertSizing = "height";
+               profile = "GuiMenuScrollProfile";
+               visible = "1";
+               active = "1";
+               tooltipProfile = "GuiToolTipProfile";
+               hovertime = "1000";
+               isContainer = "1";
+               canSave = "1";
+               canSaveDynamicFields = "0";
+
+               new GuiStackControl(OptionsMenuSettingsList) {
+                  stackingType = "Vertical";
+                  horizStacking = "Left to Right";
+                  vertStacking = "Top to Bottom";
+                  padding = "5";
+                  dynamicSize = "1";
+                  dynamicNonStackExtent = "0";
+                  dynamicPos = "0";
+                  changeChildSizeToFit = "0";
+                  changeChildPosition = "1";
+                  position = "1 1";
+                  extent = "661 30";
+                  minExtent = "16 16";
+                  horizSizing = "width";
+                  vertSizing = "height";
+                  profile = "GuiDefaultProfile";
+                  visible = "1";
+                  active = "1";
+                  tooltipProfile = "GuiToolTipProfile";
+                  hovertime = "1000";
+                  isContainer = "1";
+                  class = "MenuList";
+                  canSave = "1";
+                  canSaveDynamicFields = "0";
+               };
+            };
+         };
+      };
    };
    new GuiControl(OptionsButtonHolder) {
-      position = "109 711";
+      position = "116 711";
       extent = "791 40";
       minExtent = "8 2";
       horizSizing = "center";
@@ -326,7 +435,7 @@ $guiContent = new GuiControl(OptionsMenu) {
 
       new GuiIconButtonCtrl() {
          buttonMargin = "4 4";
-         iconBitmap = "data/ui/images/Inputs/Keyboard & Mouse/Keyboard_Black_Enter";
+         BitmapAsset = "UI:Keyboard_Black_Return_image";
          iconLocation = "Left";
          sizeIconToButton = "1";
          makeIconSquare = "1";
@@ -345,7 +454,7 @@ $guiContent = new GuiControl(OptionsMenu) {
          profile = "GuiMenuButtonProfile";
          visible = "1";
          active = "1";
-         command = "ChooseLevelDlg.beginLevel();";
+         command = "OptionsMenu.apply();";
          tooltipProfile = "GuiToolTipProfile";
          hovertime = "1000";
          isContainer = "0";
@@ -356,7 +465,7 @@ $guiContent = new GuiControl(OptionsMenu) {
       };
       new GuiIconButtonCtrl() {
          buttonMargin = "4 4";
-         iconBitmap = "data/ui/images/Inputs/Keyboard & Mouse/Keyboard_Black_Esc";
+         BitmapAsset = "UI:Keyboard_Black_Escape_image";
          iconLocation = "Left";
          sizeIconToButton = "1";
          makeIconSquare = "1";
@@ -375,7 +484,7 @@ $guiContent = new GuiControl(OptionsMenu) {
          profile = "GuiMenuButtonProfile";
          visible = "1";
          active = "1";
-         command = "ChooseLevelDlg.backOut();";
+         command = "OptionsMenu.backOut();";
          tooltipProfile = "GuiToolTipProfile";
          hovertime = "1000";
          isContainer = "0";
@@ -386,7 +495,7 @@ $guiContent = new GuiControl(OptionsMenu) {
       };
       new GuiIconButtonCtrl() {
          buttonMargin = "4 4";
-         iconBitmap = "data/ui/images/Inputs/Keyboard & Mouse/Keyboard_Black_Enter";
+         BitmapAsset = "UI:Switch_LB_image";
          iconLocation = "Left";
          sizeIconToButton = "1";
          makeIconSquare = "1";
@@ -403,19 +512,21 @@ $guiContent = new GuiControl(OptionsMenu) {
          horizSizing = "right";
          vertSizing = "bottom";
          profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
+         visible = "0";
+         active = "0";
+         command = "OptionsMenu.prevTab();";
          tooltipProfile = "GuiToolTipProfile";
          hovertime = "1000";
          isContainer = "0";
          internalName = "prevTabButton";
          class = "MenuInputButton";
+         hidden = "1";
          canSave = "1";
          canSaveDynamicFields = "0";
       };
       new GuiIconButtonCtrl() {
          buttonMargin = "4 4";
-         iconBitmap = "data/ui/images/Inputs/Keyboard & Mouse/Keyboard_Black_Esc";
+         BitmapAsset = "UI:Switch_RB_image";
          iconLocation = "Left";
          sizeIconToButton = "1";
          makeIconSquare = "1";
@@ -432,19 +543,21 @@ $guiContent = new GuiControl(OptionsMenu) {
          horizSizing = "right";
          vertSizing = "bottom";
          profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
+         visible = "0";
+         active = "0";
+         command = "OptionsMenu.nextTab();";
          tooltipProfile = "GuiToolTipProfile";
          hovertime = "1000";
          isContainer = "0";
          internalName = "nextTabButton";
          class = "MenuInputButton";
+         hidden = "1";
          canSave = "1";
          canSaveDynamicFields = "0";
       };
       new GuiIconButtonCtrl() {
          buttonMargin = "4 4";
-         iconBitmap = "data/ui/images/Inputs/Keyboard & Mouse/Keyboard_Black_Esc";
+         BitmapAsset = "UI:Keyboard_Black_R_image";
          iconLocation = "Left";
          sizeIconToButton = "1";
          makeIconSquare = "1";
@@ -463,6 +576,7 @@ $guiContent = new GuiControl(OptionsMenu) {
          profile = "GuiMenuButtonProfile";
          visible = "1";
          active = "1";
+         command = "OptionsMenu.resetToDefaults();";
          tooltipProfile = "GuiToolTipProfile";
          hovertime = "1000";
          isContainer = "0";
@@ -472,5 +586,26 @@ $guiContent = new GuiControl(OptionsMenu) {
          canSaveDynamicFields = "0";
       };
    };
+   new GuiInputCtrl(OptionsMenuInputHandler) {
+      sendAxisEvents = "1";
+      sendBreakEvents = "1";
+      sendModifierEvents = "0";
+      ignoreMouseEvents = "1";
+      lockMouse = "0";
+      position = "-50 0";
+      extent = "10 10";
+      minExtent = "8 2";
+      horizSizing = "left";
+      vertSizing = "top";
+      profile = "GuiInputCtrlProfile";
+      visible = "1";
+      active = "1";
+      tooltipProfile = "GuiToolTipProfile";
+      hovertime = "1000";
+      isContainer = "0";
+      class = "MenuInputHandler";
+      canSave = "1";
+      canSaveDynamicFields = "0";
+   };
 };
 //--- OBJECT WRITE END ---
diff --git a/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript b/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
index 63488c8d7..eac532203 100644
--- a/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
+++ b/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
@@ -54,20 +54,22 @@ function OptionsMenu::onWake(%this)
 {
    MainMenuButtonList.hidden = true;
    
-   %this.pageTabIndex = 0;
-   %tab = %this.getTab();
-   %tab.performClick();
+   OptionsMenuCategoryList.setAsActiveMenuList();
    
    OptionsButtonHolder.setActive();
+   
+   OptionsMenuInputHandler.setFirstResponder();
 }
 
 function OptionsButtonHolder::onWake(%this)
 {
-   %this-->prevTabButton.set("btn_l", "", "Prev Tab", "OptionsMenu.prevTab();", true);
-   %this-->nextTabButton.set("btn_r", "", "Next Tab", "OptionsMenu.nextTab();", true);
+   //%this-->prevTabButton.set("btn_l", "", "Prev Tab", "OptionsMenu.prevTab();", true);
+   %this-->nextTabButton.set("btn_a", "", "Select", "OptionsMenuList.activate();", true);
    %this-->resetButton.set("btn_back", "R", "Reset", "OptionsMenu.resetToDefaults();");
    %this-->applyButton.set("btn_start", "Return", "Apply", "OptionsMenu.apply();");
    %this-->backButton.set("btn_b", "Escape", "Back", "OptionsMenu.backOut();");
+   
+   //OptionsMenuCategoryList.getObject(0).performClick();
 }
 
 function OptionsMenu::apply(%this)
@@ -78,7 +80,7 @@ function OptionsMenu::apply(%this)
    }
    else if(%this.pageTabIndex == 1)
    {
-      %this.applyGraphicsSettings();
+      %this.applyGraphicsSettings(); 
    }
    else if(%this.pageTabIndex == 2)
    {
@@ -130,26 +132,24 @@ function OptionsMenuSettingsList::onChange(%this)
    
    if(%currentRowText $= "Display")
    {
-      OptionsMenuList.populateDisplaySettingsList();
+      populateDisplaySettingsList();
    }
    else if(%currentRowText $= "Graphics")
    {
-      OptionsMenuList.populateGraphicsSettingsList();
+      populateGraphicsSettingsList();
    }
    else if(%currentRowText $= "Audio")
    {
-      OptionsMenuList.populateAudioSettingsList();
+      populateAudioSettingsList();
    }
    else if(%currentRowText $= "Keyboard + Mouse")
    {
-      OptionsMenuList.populateKeyboardMouseSettingsList();
+      populateKeyboardMouseSettingsList();
    }
    else if(%currentRowText $= "Gamepad")
    {
-      OptionsMenuList.populateGamepadSettingsList();
+      populateGamepadSettingsList();
    }
-   
-   
 }
 
 function OptionsMenu::prevTab(%this)
@@ -188,10 +188,9 @@ function OptionsMenu::getTab(%this)
       return %this-->DisplayButton;
 }
 
-function OptionsMenu::populateDisplaySettingsList(%this)
+function populateDisplaySettingsList()
 {
-   %this.pageTabIndex = 0;
-   OptionsMenuSettingsList.clearRows();
+   OptionsMenuSettingsList.clear();
    
    OptionName.setText("");
    OptionDescription.setText("");
@@ -221,7 +220,7 @@ function OptionsMenu::populateDisplaySettingsList(%this)
    
    trim(%apiList);
    
-   OptionsMenuSettingsList.addOptionRow("Display API", %apiList, false, "", -1, -30, true, "The display API used for rendering.", %displayDevice);
+   OptionsMenuSettingsList.addOptionRow("Display API", %apiList, false, "",  true, "The display API used for rendering.", %displayDevice);
    
    %numDevices = Canvas.getMonitorCount();
    %devicesList = "";
@@ -235,7 +234,7 @@ function OptionsMenu::populateDisplaySettingsList(%this)
    }
    
    %selectedDevice = getField(%devicesList, $pref::Video::deviceId);
-   OptionsMenuSettingsList.addOptionRow("Display Device", %devicesList, false, "onDisplayModeChange", -1, -30, true, "The display devices the window should be on.", %selectedDevice);
+   OptionsMenuSettingsList.addOptionRow("Display Device", %devicesList, false, "onDisplayModeChange",  true, "The display devices the window should be on.", %selectedDevice);
       
    if (%numDevices > 1)
       OptionsMenuSettingsList.setRowEnabled(1, true);
@@ -243,10 +242,10 @@ function OptionsMenu::populateDisplaySettingsList(%this)
       OptionsMenuSettingsList.setRowEnabled(1, false);
    
    %mode = getField($Video::ModeTags, $pref::Video::deviceMode);
-   OptionsMenuSettingsList.addOptionRow("Window Mode", $Video::ModeTags, false, "onDisplayModeChange", -1, -30, true, "", %mode);
+   OptionsMenuSettingsList.addOptionRow("Window Mode", $Video::ModeTags, false, "onDisplayModeChange",  true, "", %mode);
    
    %resolutionList = getScreenResolutionList($pref::Video::deviceId, $pref::Video::deviceMode);
-   OptionsMenuSettingsList.addOptionRow("Resolution", %resolutionList, false, "onDisplayResChange", -1, -30, true, "Resolution of the game window", _makePrettyResString( $pref::Video::mode ));
+   OptionsMenuSettingsList.addOptionRow("Resolution", %resolutionList, false, "onDisplayResChange",  true, "Resolution of the game window", _makePrettyResString( $pref::Video::mode ));
    
    //If they're doing borderless, the window resolution must match the display resolution
    if(%mode !$= "Borderless")
@@ -254,19 +253,17 @@ function OptionsMenu::populateDisplaySettingsList(%this)
    else
       OptionsMenuSettingsList.setRowEnabled(3, false);
    
-   OptionsMenuSettingsList.addOptionRow("VSync", "No\tYes", false, "", -1, -30, true, "", convertBoolToYesNo(!$pref::Video::disableVerticalSync));
+   OptionsMenuSettingsList.addOptionRow("VSync", "No\tYes", false, "",  true, "", convertBoolToYesNo(!$pref::Video::disableVerticalSync));
 
 
    %refreshList = getScreenRefreshList($pref::Video::mode);
-   OptionsMenuSettingsList.addOptionRow("Refresh Rate", %refreshList, false, "", -1, -30, true, "", $pref::Video::RefreshRate);
+   OptionsMenuSettingsList.addOptionRow("Refresh Rate", %refreshList, false, "",  true, "", $pref::Video::RefreshRate);
    
    //move to gameplay tab
-   OptionsMenuSettingsList.addSliderRow("Field of View", 75, 5, "65 100", "", -1, -30);
+   OptionsMenuSettingsList.addSliderRow("Field of View", 75, 5, "65 100", "");
    
-   OptionsMenuSettingsList.addSliderRow("Brightness", 0.5, 0.1, "0 1", "", -1, -30);
-   OptionsMenuSettingsList.addSliderRow("Contrast", 0.5, 0.1, "0 1", "", -1, -30);
-   
-   OptionsMenuSettingsList.refresh();
+   OptionsMenuSettingsList.addSliderRow("Brightness", 0.5, 0.1, "0 1", "");
+   OptionsMenuSettingsList.addSliderRow("Contrast", 0.5, 0.1, "0 1", "");
 }
 
 function OptionsMenu::applyDisplaySettings(%this)
@@ -290,10 +287,9 @@ function OptionsMenu::applyDisplaySettings(%this)
    export("$pref::*", %prefPath @ "/clientPrefs." @ $TorqueScriptFileExtension, false);
 }
 
-function OptionsMenu::populateGraphicsSettingsList(%this)
+function populateGraphicsSettingsList(%this)
 {
-   %this.pageTabIndex = 1;
-   OptionsMenuSettingsList.clearRows();
+   OptionsMenuSettingsList.clear();
    
    OptionName.setText("");
    OptionDescription.setText("");
@@ -303,26 +299,24 @@ function OptionsMenu::populateGraphicsSettingsList(%this)
    %highMedLow = "Low\tMedium\tHigh";
    %anisoFilter = "Off\t4\t8\t16";
    %aaFilter = "Off\t1\t2\t4";
-   OptionsMenuSettingsList.addOptionRow("Lighting Quality", getQualityLevels(LightingQualityList), false, "", -1, -30, true, "Amount and drawdistance of local lights", getCurrentQualityLevel(LightingQualityList));
-   OptionsMenuSettingsList.addOptionRow("Shadow Quality", getQualityLevels(ShadowQualityList), false, "", -1, -30, true, "Shadow revolution quality", getCurrentQualityLevel(ShadowQualityList));
-   OptionsMenuSettingsList.addOptionRow("Soft Shadow Quality", getQualityLevels(SoftShadowList), false, "", -1, -30, true, "Amount of softening applied to shadowmaps", getCurrentQualityLevel(SoftShadowList));
-   OptionsMenuSettingsList.addOptionRow("Mesh Quality", getQualityLevels(MeshQualityGroup), false, "", -1, -30, true, "Fidelity of rendering of mesh objects", getCurrentQualityLevel(MeshQualityGroup));
-   OptionsMenuSettingsList.addOptionRow("Object Draw Distance", getQualityLevels(MeshDrawDistQualityGroup), false, "", -1, -30, true, "Dictates if and when static objects fade out in the distance", getCurrentQualityLevel(MeshDrawDistQualityGroup));
-   OptionsMenuSettingsList.addOptionRow("Texture Quality", getQualityLevels(TextureQualityGroup), false, "", -1, -30, true, "Fidelity of textures", getCurrentQualityLevel(TextureQualityGroup));
-   OptionsMenuSettingsList.addOptionRow("Terrain Quality", getQualityLevels(TerrainQualityGroup), false, "", -1, -30, true, "Quality level of terrain objects", getCurrentQualityLevel(TerrainQualityGroup));
-   OptionsMenuSettingsList.addOptionRow("Decal Lifetime", getQualityLevels(DecalLifetimeGroup), false, "", -1, -30, true, "How long decals are rendered", getCurrentQualityLevel(DecalLifetimeGroup));
-   OptionsMenuSettingsList.addOptionRow("Ground Cover Density", getQualityLevels(GroundCoverDensityGroup), false, "", -1, -30, true, "Density of ground cover items, such as grass", getCurrentQualityLevel(GroundCoverDensityGroup));
-   OptionsMenuSettingsList.addOptionRow("Shader Quality", getQualityLevels(ShaderQualityGroup), false, "", -1, -30, true, "Dictates the overall shader quality level, adjusting what features are enabled.", getCurrentQualityLevel(ShaderQualityGroup));
-   OptionsMenuSettingsList.addOptionRow("Anisotropic Filtering", %anisoFilter, false, "", -1, -30, true, "Amount of Anisotropic Filtering on textures, which dictates their sharpness at a distance", $pref::Video::defaultAnisotropy);
-   OptionsMenuSettingsList.addOptionRow("Anti-Aliasing", %aaFilter, false, "", -1, -30, true, "Amount of Post-Processing Anti-Aliasing applied to rendering", $pref::Video::AA);
-   OptionsMenuSettingsList.addOptionRow("Parallax", %onOffList, false, "", -1, -30, true, "Whether the surface parallax shader effect is enabled", convertBoolToOnOff(!$pref::Video::disableParallaxMapping));
-   OptionsMenuSettingsList.addOptionRow("Water Reflections", %onOffList, false, "", -1, -30, true, "Whether water reflections are enabled", convertBoolToOnOff(!$pref::Water::disableTrueReflections));
-   OptionsMenuSettingsList.addOptionRow("SSAO", %onOffList, false, "", -1, -30, true, "Whether Screen-Space Ambient Occlusion is enabled", convertBoolToOnOff($pref::PostFX::EnableSSAO));
-   OptionsMenuSettingsList.addOptionRow("Depth of Field", %onOffList, false, "", -1, -30, true, "Whether the Depth of Field effect is enabled", convertBoolToOnOff($pref::PostFX::EnableDOF));
-   OptionsMenuSettingsList.addOptionRow("Vignette", %onOffList, false, "", -1, -30, true, "Whether the vignette effect is enabled", convertBoolToOnOff($pref::PostFX::EnableVignette));
-   OptionsMenuSettingsList.addOptionRow("Light Rays", %onOffList, false, "", -1, -30, true, "Whether the light rays effect is enabled", convertBoolToOnOff($pref::PostFX::EnableLightRays));
-   
-   OptionsMenuSettingsList.refresh();
+   OptionsMenuSettingsList.addOptionRow("Lighting Quality", getQualityLevels(LightingQualityList), false, "",  true, "Amount and drawdistance of local lights", getCurrentQualityLevel(LightingQualityList));
+   OptionsMenuSettingsList.addOptionRow("Shadow Quality", getQualityLevels(ShadowQualityList), false, "",  true, "Shadow revolution quality", getCurrentQualityLevel(ShadowQualityList));
+   OptionsMenuSettingsList.addOptionRow("Soft Shadow Quality", getQualityLevels(SoftShadowList), false, "",  true, "Amount of softening applied to shadowmaps", getCurrentQualityLevel(SoftShadowList));
+   OptionsMenuSettingsList.addOptionRow("Mesh Quality", getQualityLevels(MeshQualityGroup), false, "",  true, "Fidelity of rendering of mesh objects", getCurrentQualityLevel(MeshQualityGroup));
+   OptionsMenuSettingsList.addOptionRow("Object Draw Distance", getQualityLevels(MeshDrawDistQualityGroup), false, "",  true, "Dictates if and when static objects fade out in the distance", getCurrentQualityLevel(MeshDrawDistQualityGroup));
+   OptionsMenuSettingsList.addOptionRow("Texture Quality", getQualityLevels(TextureQualityGroup), false, "",  true, "Fidelity of textures", getCurrentQualityLevel(TextureQualityGroup));
+   OptionsMenuSettingsList.addOptionRow("Terrain Quality", getQualityLevels(TerrainQualityGroup), false, "",  true, "Quality level of terrain objects", getCurrentQualityLevel(TerrainQualityGroup));
+   OptionsMenuSettingsList.addOptionRow("Decal Lifetime", getQualityLevels(DecalLifetimeGroup), false, "",  true, "How long decals are rendered", getCurrentQualityLevel(DecalLifetimeGroup));
+   OptionsMenuSettingsList.addOptionRow("Ground Cover Density", getQualityLevels(GroundCoverDensityGroup), false, "",  true, "Density of ground cover items, such as grass", getCurrentQualityLevel(GroundCoverDensityGroup));
+   OptionsMenuSettingsList.addOptionRow("Shader Quality", getQualityLevels(ShaderQualityGroup), false, "",  true, "Dictates the overall shader quality level, adjusting what features are enabled.", getCurrentQualityLevel(ShaderQualityGroup));
+   OptionsMenuSettingsList.addOptionRow("Anisotropic Filtering", %anisoFilter, false, "",  true, "Amount of Anisotropic Filtering on textures, which dictates their sharpness at a distance", $pref::Video::defaultAnisotropy);
+   OptionsMenuSettingsList.addOptionRow("Anti-Aliasing", %aaFilter, false, "",  true, "Amount of Post-Processing Anti-Aliasing applied to rendering", $pref::Video::AA);
+   OptionsMenuSettingsList.addOptionRow("Parallax", %onOffList, false, "",  true, "Whether the surface parallax shader effect is enabled", convertBoolToOnOff(!$pref::Video::disableParallaxMapping));
+   OptionsMenuSettingsList.addOptionRow("Water Reflections", %onOffList, false, "",  true, "Whether water reflections are enabled", convertBoolToOnOff(!$pref::Water::disableTrueReflections));
+   OptionsMenuSettingsList.addOptionRow("SSAO", %onOffList, false, "",  true, "Whether Screen-Space Ambient Occlusion is enabled", convertBoolToOnOff($pref::PostFX::EnableSSAO));
+   OptionsMenuSettingsList.addOptionRow("Depth of Field", %onOffList, false, "",  true, "Whether the Depth of Field effect is enabled", convertBoolToOnOff($pref::PostFX::EnableDOF));
+   OptionsMenuSettingsList.addOptionRow("Vignette", %onOffList, false, "",  true, "Whether the vignette effect is enabled", convertBoolToOnOff($pref::PostFX::EnableVignette));
+   OptionsMenuSettingsList.addOptionRow("Light Rays", %onOffList, false, "",  true, "Whether the light rays effect is enabled", convertBoolToOnOff($pref::PostFX::EnableLightRays));
 }
 
 function OptionsMenu::applyGraphicsSettings(%this)
@@ -439,10 +433,9 @@ function updateDisplaySettings()
    }
 }
 
-function OptionsMenu::populateAudioSettingsList(%this)
+function populateAudioSettingsList(%this)
 {
-   %this.pageTabIndex = 2;
-   OptionsMenuSettingsList.clearRows();
+   OptionsMenuSettingsList.clear();
    
    OptionName.setText("");
    OptionDescription.setText("");
@@ -477,18 +470,15 @@ function OptionsMenu::populateAudioSettingsList(%this)
          else 
             %audioDeviceList = %audioDeviceList @ "\t" @ %device;  
       }
-         
    }
    
-   OptionsMenuSettingsList.addOptionRow("Audio Provider", %audioProviderList, false, "audioProviderChanged", -1, -15, true, "", $currentAudioProvider);
-   OptionsMenuSettingsList.addOptionRow("Audio Device", %audioDeviceList, false, "", -1, -15, true, $pref::SFX::device);
+   OptionsMenuSettingsList.addOptionRow("Audio Provider", %audioProviderList, false, "audioProviderChanged", true, "", $currentAudioProvider);
+   OptionsMenuSettingsList.addOptionRow("Audio Device", %audioDeviceList, false, "", true, $pref::SFX::device);
    
-   OptionsMenuSettingsList.addSliderRow("Master Volume", $pref::SFX::masterVolume, 0.1, "0 1", "", -1, -30);
-   OptionsMenuSettingsList.addSliderRow("GUI Volume", $pref::SFX::channelVolume[ $GuiAudioType], 0.1, "0 1", "", -1, -30);
-   OptionsMenuSettingsList.addSliderRow("Effects Volume", $pref::SFX::channelVolume[ $SimAudioType ], 0.1, "0 1", "", -1, -30);
-   OptionsMenuSettingsList.addSliderRow("Music Volume", $pref::SFX::channelVolume[ $MusicAudioType ], 0.1, "0 1", "", -1, -30);
-   
-   OptionsMenuSettingsList.refresh();
+   OptionsMenuSettingsList.addSliderRow("Master Volume", $pref::SFX::masterVolume, 0.1, "0 1", "");
+   OptionsMenuSettingsList.addSliderRow("GUI Volume", $pref::SFX::channelVolume[ $GuiAudioType], 0.1, "0 1", "");
+   OptionsMenuSettingsList.addSliderRow("Effects Volume", $pref::SFX::channelVolume[ $SimAudioType ], 0.1, "0 1", "");
+   OptionsMenuSettingsList.addSliderRow("Music Volume", $pref::SFX::channelVolume[ $MusicAudioType ], 0.1, "0 1", "");
 }
 
 function audioProviderChanged()
@@ -498,7 +488,7 @@ function audioProviderChanged()
    $currentAudioProvider = %provider;
    
    //And now refresh the list to get the correct devices
-   OptionsMenu.populateAudioSettingsList();
+   populateAudioSettingsList();
 }
 
 function OptionsMenu::applyAudioSettings(%this)
@@ -531,10 +521,9 @@ function OptionsMenu::applyAudioSettings(%this)
    }
 }
 
-function OptionsMenu::populateKeyboardMouseSettingsList(%this)
+function populateKeyboardMouseSettingsList(%this)
 {
-   %this.pageTabIndex = 3;
-   OptionsMenuSettingsList.clearRows();
+   OptionsMenuSettingsList.clear();
    
    OptionName.setText("");
    OptionDescription.setText("");
@@ -542,13 +531,12 @@ function OptionsMenu::populateKeyboardMouseSettingsList(%this)
    $remapListDevice = "keyboard";
    fillRemapList();
    
-   OptionsMenuSettingsList.refresh();
+   //OptionsMenuSettingsList.refresh();
 }
 
-function OptionsMenu::populateGamepadSettingsList(%this)
+function populateGamepadSettingsList(%this)
 {
-   %this.pageTabIndex = 4;
-   OptionsMenuSettingsList.clearRows();
+   OptionsMenuSettingsList.clear();
    
    OptionName.setText("");
    OptionDescription.setText("");
@@ -586,6 +574,69 @@ function OptionsMenu::backOut(%this)
    }
 }
 
+function OptionsMenuSettingsList::setRowEnabled(%this, %row, %status)
+{
+   %option = %this.getObject(%row);
+   if(isObject(%option))
+   {
+      %option.setEnabled(%status);
+   }
+}
+
+function OptionsMenuSettingsList::addOptionRow(%this, %label, %optionsList, %wrapOptions, %callback, %enabled, %description, %defaultValue)
+{
+   if(%enabled $= "")
+      %enabled = true;
+      
+   %optionsRowSize = 30;
+   %optionColumnWidth = %this.extent.x - 450;//todo, calculate off longest option text?
+      
+   %option = new GuiGameSettingsCtrl() { 
+      class = "MenuOptionsButton";
+      profile = "GuiMenuButtonProfile";
+      horizSizing = "width";
+      vertSizing = "bottom";
+      position = "0 0";
+      extent = %this.extent.x SPC %optionsRowSize;
+      columnSplit = %optionColumnWidth;
+      useMouseEvents = true;
+   };
+   
+   %option.setListSetting(%label, %optionsList, %wrapOptions, %callback, %enabled, %description, %defaultValue);
+
+   %this.add(%option);
+}
+
+function OptionsMenuSettingsList::addSliderRow(%this, %label, %defaultValue, %increment, %range, %callback, %enabled, %description)
+{
+   if(%enabled $= "")
+      %enabled = true;
+      
+   %optionsRowSize = 30;
+   %optionColumnWidth = %this.extent.x - 450;//todo, calculate off longest option text?
+      
+   %option = new GuiGameSettingsCtrl() { 
+      class = "MenuOptionsButton";
+      profile = "GuiMenuButtonProfile";
+      horizSizing = "width";
+      vertSizing = "bottom";
+      position = "0 0";
+      extent = %this.extent.x SPC %optionsRowSize;
+      columnSplit = %optionColumnWidth;
+      useMouseEvents = true;
+   };
+   
+   %option.setSliderSetting(%label, %defaultValue, %increment, %range, %callback, %enabled, %description);
+
+   %this.add(%option);
+}
+
+//
+function OptionsMenuCategoryList::onNavigate(%this, %index)
+{
+   %this.getObject(%index).performClick();
+}
+
 function convertOptionToBool(%val)
 {
    if(%val $= "yes" || %val $= "on")
@@ -685,4 +736,16 @@ function onDisplayResChange(%val)
 
    OptionsMenuSettingsList.setOptions(5, %refreshList);
    OptionsMenuSettingsList.selectOption(5, %newRate);
+}
+
+function MenuOptionsButton::onMouseEnter(%this)
+{
+   OptionName.setText(%this.getLabel());
+   OptionDescription.setText(%this.getToolTip());
+}
+
+function MenuOptionsButton::onMouseLeave(%this)
+{
+   OptionName.setText("");
+   OptionDescription.setText("");
 }
\ No newline at end of file
diff --git a/Templates/BaseGame/game/data/UI/images/scrollBar.png b/Templates/BaseGame/game/data/UI/images/scrollBar.png
index 2699a7662781253fe3ba6bfd00468ba7a97e7ea3..4bd81576ba4217a429431e7806bf690f418ed775 100644
GIT binary patch
literal 9187
zcmeHrXIN8Pw=O76I#NVXh*SX+l2AgBB1NQwbd+K$1PBR9D1y==Akq|6dXXv$3J6jZ
z5RoE9svu23L=dD2(o{SF{r2`dci->a{XF;l+w*x=)|zv^;~itYYmB+FW~90484gw<
zRysO54g-B%3))$hc4V_K(SBh7=S4a?9tnRdJBkIu7eFKtus9D4fO3(D0bu-aSUNht
z;o@W*>1Zj(l^?5o@O>~MoU<WM7S_758lq4p*>2iasQ)-aks!eBN`Y;T?hI<iePwpG
zzvN@@CRfYXWxH72(jecd>D=YMytVVxdE@)cY~qyXi;bApJ1^Y*cTRj&4<b4QI+?Eq
zIMj>yde?2>mSWz*G(3|&y<9K(!nF1Fc+-rZ-w&VfF|Iew+Asc?4_LWe_G8EQfduNn
zhEY#by7uP{mrEHpKLzPG#;z(zo`mE+Uy4`NMBN)-omotuTH@WDs&xK5GZUcp-8dou
z`ZdEm@MT|sTI<rP@1r$%Hg}L3JTUg|W!8nkZ|RSQ;a}~?TAOY>_zapu$!x$(tpw5+
zF=0z>L6aN)^(V(Wxikxhk%e<lKcC^c(UEbzkySjcWNDr~ftx&9`dMfym&vCnPbeVm
zrQ!93lWBHGz3mFmMjA{XjF^hEdw$uoa%QEZIl*?KL$K<w($4lmp!#xsU{G}roN1L?
zqm2E;RXHIQmPT0@O?Xu3mDLYco`KW=r*99PZQkfIPUlybKAZef9cH*0SxlKvd#YmE
zx$`m6d@x{t=;V+#_}E!`XYF|N(1(x#?p9Qe2DKH{cDC>ox3m`zrbCART3@z$s=Hg&
zj9z3HVm3^hCB{OABSyQFblYLJlIco#f`q;9H7i^%=B5?thJ_)p*)k_T<$k|~JHBGD
z$D-Zj9Im2bU}Uyb+SS-WzIJ^eK$IF0t5!8Q@vVVACPneSYtKECC$R@EVKboZMUOf)
zTCT|fk3TCen{&JWu(XlM@FZafGdSimJ{4S%V5&iCD=bJ4Y>vAZR*A2-S{Q8mK0~{7
zTM=k`bzk#-^W-^APo8Mg7jAk@NKUJ#=NRcI<tbYNq*xpH{p2M`^-YO`d3IhlCD+b2
zJk`0$8`!_-GQDF5JLB`?vFD2KEwW9`k2BM0w-zm@>joEK*5{{s@imNPAc+DnI{Uj6
z=IzJj^W#cy=Jzcwz&DSS?LXIRJc`XY`W<<Z+O6+<_~q-OWqw$!Pj%YU9NA3+m;B<D
zPw)`|KhAAg6L)IV2|wqP2d|s5J`w%AWXCrLAC`$H=voX)RNl`p=W3TFnX<u#Z??9W
zG7QJLX|Uqw^|_raV6RouMr=>=kA=Cl++|+#(gv1Y)~t&uwsK4?>nJ(*%3Z7KiN5jE
z9$!*Ue^QOSc(|JOg20Y_+KJ-MbI3z&RT3N7h$Z3GR;Ah7Gd(zsYVVrbTsN=ITN%L-
zn(krhZ6*Un9NvzQqW#mkb*)6_;z1u-nbBftKP9-Ve_wM9)!0+R`ry*nM@G2IO;RUg
zsy-D~U$G%1$;FfkAl3m!p1Koim%IANtzS2?j%H`H@J28PCAY5Ie0<y-V}T>`0^17`
zvkD5!>ZXMU=|UfKFvMIEt>3twUJU}J*Gg+L<EyZ4sjJ<kAJ*e*W@gvFsc=RxE-!Ar
zcqILrDqts_b)`e86MJ`^+fW4`R&+a7)p6hv{muiwXVu=Fk7l(f2NcRrC;`ew-htlQ
zuQ}F9d2$ZSCwm$9FuIu83wfHolVE#$d`8<HmLZ+|b?{a}fob6pGQ+5QpXSMK1`9oB
zz_9G(=j5=fr^Y_n9y=KqUDuzB=d5p@9Mw_wxgRypepezAqZkM<nfb`lf)QtLa$mEi
z$EnmN?%%q?Vzd7!U46O5#&SG4i{fPfzr8yAq~S4vq4WvA_w#U=t8RdfNyOXvdX0-c
zXr`gN;WlC}FVCFz88n`{OMRc8{~BX@03T=2nIp+^muFQ#?s)9%gw<!UtYx0=W8Ee0
z)O+{%D)rl<YZ6bBwd__m+RCFo6$CTc%T0C{+Ev`xV5zNnYAqg=`o^6;nhfCJ2$cMw
z;<~J4*zQ&lQpxltG~T*!)@J@)I5@5R=)}T`j}e;{-X&|`Jk?+5GdJ$~PBtg^z}A^J
zaAIXZ8|Ic*iGUpWi3+SC_(yyJ&&B73uT|GW*A~K)Y_InROw?vHh65vvx<@?j90T>a
zjz^g2Y^NMgEL8D?8ra@*$ZcpJKHDe+=pEgDF<8XpJvh~h&aT#%TWv2TJyPt$atq(X
z@^T7XU~><5tg*ePp*Csx<RRox$81ywb5g1WgS)-mi^i>Dj@*N6?bV1>A_-=}V1iHC
ze{I3iP5b;&)=RUGCJrShXh2HII-0z``5&5>o%jv!OLz@xwk(ys7S!$cR$Rbcf6+i-
zNWAi9wMX*0$JHgr5MR|hT@~Vj1~*+lFXoq+HZV!N?v_f)uVghy9g3L1#D{iu+&_$D
zo$S8pGWBGBf7ek1PQxdtvnuK~_pC@GhdDZmx1N;EcG{3KOQIX_#4&w-xe6xw^@G<B
zvxhW>K8rf&NnNX(^cR1F4Hn>boD*E`xOO9h@1ApZcf?r754F1)X8=Z4qbw=1=W#Yr
zUM?}VbpCg4t}PuXfh-Fc)ZIgr)8)e%!B<sJ%{R1)kN@boJnkwsBj*`ichcAk)M;9u
zY5Q*LEi`)mDx2~Jm#3UH!HXhlLcJ$OTI*fHp%DM*+-p(`MQQC^(ZUsalKOnC{D-wu
zPTQO1jH1(yJ-&gh@nV$pS`&`)=Vb3ALp@e52qu&5MOh#9r*CdX^MWNhJYEd>Ih|-`
z*phhvY8!B^5+i!zqqkXL&vux`aaSH=+jIt2*2)icT%Cgk(9<pZCWX4v3VNQMirO%C
z+t6j^(7i%ho#S@^n@cg@om3v4Bf(#sWVs(a*J$x_F<;bTU?|#UJ6D)RM(QR@?@iQ+
zno?jR&!?qK>VYA{pf5)mbL>f#s?9MEn^~`9fQ>o~;Y&vEW8F^<_@Wfsc%%EJ1@FAf
z(4f|qRH;;Kf6K~U<K((rE`2sotW8wbx%yeJP?W=w5D{_b2Q?m1@mRMD^Z;X*f`{n&
z2d$Y6xJg;YoUvNbW{SVec{+g}VCHpsK6@Su(uV|oo-{hcQNT-$p+gQ2y(^SJf{x#D
zbf^-A$wq#Grf%kO_8mK@>=jqah}J1cT&Gw<O7o#@qGpxT{4w+QcysU3%yUZ{P5Y}4
z#5E54pCFZ1^BuiU5vPu`tK7ZV*7OobyyN90J>ODP4D&^|9qV=hG;ZqWv|e4wjuN~L
zRW<1od2;|ZE`QE-A^WyY>zvJ%9{q;m<YbiT1UkdXT7CxUyJQ$!QSt~e`9>z@^aMNW
zrNM6bqg5^4Ns6rTS3FWK7Kc@5yGM92Pj>6NC^N)Vchc+KPJ2j3_KJZzw)w86HO!oP
zbhEA?hNN|c$Ya^$xZKQQ$$5ey{FYF)^t{aJiRWw7pk|d*o5D`w*|FgTlkMd9NfF3P
zSJkq@RG(+i+rC0Sa_CkQnA^__otZ>J=ROM8=_Fgn2^{8{Nj%NwC_!kS|G0ybHohzo
zm=+{#bT9}Ri(h=!ko$e?T(AYWV#>Tei&3xlf*!F$k1HJbfFBXsoViv+FS67eFBqP_
zW5h?t%jHv$(CEjequlJ2)ox5AKK46W)~2HV(oLw<tj@!tC<4D83<8dvi{&xY6by0K
zGhvA2D{Z{!9S*xz@bsM?f1<I0erncKq>RQ8v5x-I!MOK1mA+d^^V5EM;BoX6*x`T-
zL1+J=?Nz<JX|h$KjlMK$+p*mHwE`BQote`GIZ5aHuKBC9rs@39GqsP2NlSLe;?VR1
zYQQtn!;i1Syy}in^S;w32Ago%cQjKtx@L`~fYbC|{m-Aha`WIn9FkkRZCz$l{JvW(
zOShPN%Q~sNOU+SGPo(A<i-kZ3>ok@m+`O-lv0QYVKHP4*mm%05u*OmPNrF5r%<Q>*
z3yMzo+#BquT-)5UdG46Bx2^@xoja|9<oA>GqXO1D2fxLrYcUxM)f^s5IehQanRPGd
z5lcg>`kUveOi^PiX|3TB%|d>qb8_4rDOGB@xAa<u(QkZ4Yw6bnHJ)#knWlCu-X&x_
zs~NF5&+uV#NhXfP!Rg=~5w}%|H?^^^M#F{4>U`l3XV4eFGbxCE2|dRhox*8Qu!cW`
zj>HIvYl|!9u%>*^eRn*3rM8;agq@6gn0nz&lL*s{mHR#0^4Q6RFN{r6@uJ>D(Y#<2
zWXtA5NaY((hz)P|$ZTf*g{7d#(B3@OypNL0>SM)Rdde3tgcV~MgV)wWBe^A#A+_M+
z;d5y9Ff+N#+f#O2I)OJ4i!Af+3czX9DmQ@=orG`L0GTdorc`d~RMqeU<?Z+{b0YB~
zc}2kv#?cK4+oTF=^Z9XG@7vX99z?+XVQyWGW5wx+5tFW}h&A~w%Z4H@=4Gx^%SQJM
z)}yxJL4)jV{h`?tRF5C|m7YkH^ze&zW5K|ELzlIoqnG3AmzC@4qIEJjL4v~gCnuUb
zvGXDuSV0apzRz8X&ljg7pKP>?e))Xnm}B0E#tj2px^k)lzoCnOozaaW&>KSc>2ntc
z5+uEEmqSJc?K*PVt8OMQt=u46=_v>?CbXW^e%7Ia#IkjVp28Z}jMuQ;(2^=S{6<U9
zEtNOfUD}90S^4`E{97M^dLzCC4Gxnub~<eMj@!i&hOw{$Yo0ee(4i3r$KIl#Tm<En
z2kK-OVhv!-u2RY3r=+2hOcC=b=y-!W5bgNn<O5>VXsr=S=+bm_^9etw2(J@CdAz}f
zA_>Au#bkU_RXxGyu<7PC@6OWO;$)i7S|B$2_#`s3p)*Q4TJg?>jZVA%=Px3U-0J)m
zolyEcdK-IA;zoNm`;9FAMsCOp%R7M|tb4D<6}h*fJZd@pb5xx0yk8n(7A$oQGitV(
zQnf8QGoYP(eN~b6JT-+`x3oT~t_^v(7s<Pfc(vp=hP<lVw>2xsh^TpRHp#Co?)#C{
z>Z~h-YT}iTIxIPo9*0q%w$g&fjBV*SRJp)f$(<GHWnlVTx38D3gEp^EzB^Y{Dnj;8
zg(k~<KD6E`J<{`FTr1T%rM~E5<lAK10k%N1fy6JeAMSwVk)L@xtS(lX>!z|-9XNW0
zckPrT(+?Fb2$P(Sc&qCSTU2Hz{m}YsI!LQWPQ2O7QY5hKD4T#VaX4mQN;@0;@jE+S
zF^>}4Z*u#4(i;~-Hhn#0kGy)sBoJ<JBermBNJaERjGRs5a+mBFOi8X!qnX36Tcmr<
znmUH0n~(SDyB$}dC*Db6lMuA6lsNhI+ZRpj78?Y>z&Ddz!o1kA-h@Ln^S4C5vg+a|
z!q!}=Jsg+i#plMRju5t6`wJMfWl$p}A(EjrULHj}>utC9hdrg@so)?{;m=;hc5V}E
z9)WC!4i1~`+w9-rypzwCG#6K2!^0gJ@)T0)aNrG*lD;ly+N+b|xL`>a%>dqK(%(Ac
zl&>)RV)3=cEXdYAu{61^=yKT?vAi<K6YcrPqWjr-$b+ac_QuyLM=aUjdMD4b=Uab;
z&8hX3vo?NHzH};km>b2%7kz1>>oOByZNIa2vzstur$)bhpK|r#nw3IJYDE#g&*A80
ztA0hk)~a~c6y$?Dx?$Y)lFFT_VjU3+ZyOAFG>+>B>wbN6KoFr8KnWTta%N;zMyRlq
z#09K7;UBSifA}zcxK*%)_&BWe&5|-+u2ormxa{&6#811W`I27JR|ZJxdnHM~XtgAX
z$?K=0!17N+*ez|5OC5=YZg&7x?et+BE}1gZJeTa{4h4YJ93P%7brfzsF7m`9k#Pje
z>&Lx6yO=qnwz5e;YZ7#tg>ghQGWc9WDBo)du5wH5PmI)I$2k$ki_XSM8Yd9%9eXqY
z!wLDk`5q&BDbW*Wlb1xdB(qd{XEZ$$Iv&45`akZZJ7JJ^+f0}@NqMX(kRzl})CI5_
z#r1h6m1{eJgA_DR-9b}F$G5XIhX5|Zk?SGUudwN&)({Uf)h~2(^kFz19diR6oqz3@
z&~{1EF5ghsZ#;FR$@zSq#knKHTDlTC-enVq-W|6-5gOKO<NCVceXqQ0@Acd&71jrg
z%$frCIYF;#RI6A+Cz!9MrY2-Z-Q29t?G|gMP6a-FvQZVl?3ZetFQ`5hoSovY%5#Xc
zW!>=O8eKS#9t*FSLOB`>VH;fW=HhZ*LaMcYAI%h(IK<B6$M6oG|50j%X{95-(Ce*q
zY)RR1-b~)Oj})zUXC4@F)_Z}5K20a{sHbK~$8xjffo|6%-SQ6eOHq-PlbsGAbGD~d
zs>r=obstZt2iuw3LLCa=R~T+z*Ja%&(SKHpUkX`%FIP~%FL1O;)Ag(6`}kICdhwQh
zZsvgDz-7(NvEs97DU|q7udI!xG7UYtAE0hGyMc{TOob`kxB@ZH=Uaso_^W|`PR{AL
z;2r$LyP6z>fM?U3;N{%N8doEYl($G8Kg}FM+y2S(fRYbu18-YC?!TV*;5H$cs&k=S
zcW558v^c-GFs`t$6G-<&ne;-#^Uf3<9hWtZwt;15VyucH;6Vs90f_<m;fb^jE;>3j
zO+O+6<&L2MkQf)7r@GkElX@`#4y`U`t7HN;A?jdUar*uwjHSP+70TZo1xJf%YOt#L
zsnQ7W7zzU5hxhO#tNN*n?eVJ8u6Kv!#Q=K{io3d)oryU>hd{yr6hVq0Fz~b=&Ic-{
z!3t0#p|PqKx_ZATXgzf?R|<uwDlhNr>kIN#01-$o@(?&2E)RyvL!m$#0!Y5-NkRAl
zJ;~y`6hAq1F=P}8N2K5go`79W1d`xQQ5O@V%>#as(`Hep{b+-~9PIY@=*bkcyaBDF
zNV^{zKpqMPs{p}JAQUeDyFG2z#N-caPx3DnX?n{0A&Bx25Lh0M|2GRV<+RVA{{GT}
zY(?8gl()c;3Em_W=ClvSlOq1RQ=*4A`FEe*WX$f+UfdpNtUN8KJ<q?}oG~yl|HEci
zMi(5OxM#78{vC-%{edHTlRWk?Xp}t01B0gpLZ&f8{tZvF|HI%fZ)cBuPbgJg0?K=r
z#XwhGY&QT^Gy#P}tL|N@C_)ugFlZzY3szJFDk2d|KqMHB1|n6UN(dDM9FD|-f1@(+
zBvTNcD9kPujU0rd@hB)MAt8!T6i^X`h65Fqpb9_)T163vQGkIJU|1v)gF^pCVMfBy
zQXAp%dsMqrXd0Cg5(`5kz*wLPS`iIYL?~c@2qY8&1Y;FZN-&s`lCqM@9@Va}s#@j-
z>S9pP&-nI6%smhkEP;fl)eFuOP4FfE3AV!FF_sj>u51ux1tnz#2t*mC09OR7!2bl<
zU`S+I-tMwOz#s^8Zw8H0)uVADX!(P~BU~`@L{FE!30l;uIwTB&LLgZY2p;NUyD<QE
zP4}t+p!O@zRgDQK#BM$8fidXaQu$RZ+6Wi<y{?-4e**s>OqQ+$U(f$Ho<E^~uxODe
zz66rH8OaRkhCxyOGtXav|6sD9EmLF)>7v2^a8v&cr}i^3^=Y;Q(#7BWTVlL^_I|D<
z9=JWJ0D!&vRYjn7Ra6%vBYZGFQ;MeJ&nc8E!qWvqTPS~3$-l;Nf0?i_Bn*i~1C^l|
zC{Pg#0R!PM7zPN3!j!;ZMU;vX_`k7}30R6Rf`rj>p_LKsIn#=0?>PgG|H?C&y@dE9
z8edn;ZW4iMsY@eQ09!$nRh8hXP?*@yrwve(-(4F2b+>A}i-(Dc>hF4}?Jh2=2D=Go
z=}jbh;4q|r*Xdt*^MAqpX8$Wk|0na`VLz>P2*iuDYIUWU`Fj3G_kRKW$zY5_VLZu%
z{}lS~ke{;r_6DKF{Bw-<W}?05<o|fn{mPQvLi%59zq0Rt(F2Y8A18lH-+$!#N3Or6
zz~2J@lU@JF^|uuGTi}1P>;IcvtbcwhV?1g9`+R9%!lx1n0kp4ZCZy3BUAiB;AJhuc
zmsV+~14Mm$G94Y~i`|3%mK>)rZIGE_U~-yynpK4Vr0^(@b02N5#MD4n%gS$fVG!XN
z3KnFV=p`mDIziPF`lv5)qnSX6{XTrD<BNzOsi(_H<<8FG0W2HK`v!?gu}$6cU*wGY
zAZr~>%VLL)&t@`Sg4?Q>Sc5=ehR(y#LxVf^i$>>XkgrVK<ri)Uiv}5I7To*tTHHmg
z7D(yND3|VrQDdvmyzQ0g6+c84sqyLm(%Mv!O6r;#sIKAz0fm9&6;0u@2Cw{jGs+93
zr<;4bMq0+~Qy(Rt($d;cUN)MUT$*^$x#hsb$f&f;acRFOAK%)HP~{~u;k(WF(zAz$
zpH)!5is!u>#b@B9%+1X?g5(tQtk`Qi$zLXvm$iPj3h9NH*nNz<?RAEsklCX8!115$
z?s~3zNa$X3GaKgpbI?8~Yp)Gk#;se8+|EdUr1z6+gX24sOZ>Mbhl23D-6vsi+En*}
I_Jz>@0&<~QH2?qr

delta 6623
zcmV<586f84NAoj~BYzbAdQ@0+Qek%>aB^>EX>4U6ba`-PAZ2)IW&i+q+O3*dawD;o
zMgOr1F9Gwg9E=gYgI>PR1z0LoS$2dwTB;H$GMV}ChC3i-_W%CRG5_Ez*;Y+VrRJ8i
z<tw(>eCJ8E@9RA}8}HBib>Dxl{_(o${_}?CrNCo&zvlfpzJK$2`u%|tKd+BJUpHlb
z&Qm`p`n>V$gh5x<#nvat&xwM6ue;ChrhOvn`P*_n|HtRU_saHPe~*P^ti<_(H+}~f
z?EUHAmBRbq`Cs_ygXcgZ<9P^)pE3N9KXcFQe@@`nv%m6Z=jZkCJ00d__H#h~D^H)-
zUHUnHH%s3ma)18o%Km#q%R6tse|^i}Ijf$t-|BkIhIHl6qJAyqKI6c_qQm`I=DYAe
z@x0vc#&@;dPO7$8>M(ZjOLLx#9~a$n-5s~@<8+e{qu;*p=>7EJzE(r=&CgqasBd?C
zF`<PODz%wZF7UGdipAaQHeHX4Rj#}oM|#J}oT~Z#+kgE1!vFRAj}x7vHh0d}m#3%(
za$X513{_4)If{a~^T}zt`E}+!*uTG2*gyr-O><>|-HvyPk=*az3b)R|Cc~l8zIkzF
zeNI3yTsskr3sk^n7m~})7VnF5<grqpPUJpBKd699Ciz8_K8BDfPW8GrpDFGh>yv*k
z11}UJg@4T0R0`B7R*WfT=B?5~-K3CWN-3w3YHF$HkYi3c=aPj}y@V1=D!G(WODnyG
z8f&V#mRf78z4;b^v1D3qrPbD2?_9LU&bd0rcU~BNgb_y?d6ZE{8-3C~GtM;gEVIrw
z`|>L+Ai%7=%BriazTKvkcHC*_U3T4V_d~CpaDU=SC!ccaX{Ucx&3(r9kE;D$x&K@>
z_o<q{h0<~5chz{glwYTCf|I10Q86DK6)&m)4eeDkTV0G^l~c`Z^TB{so+y)wvz#hM
z1><%;9rsnc-<A8fbu(o5zpb19sd7f8`~Rq%QR%)_?qBQnL)BKla2sxcG==08gba+|
z27mrXVj*@As3&X?DsCpWQKLnC1d!Kuq>S&#!3sUs=JH6}yJ5)F&c|<8huxb}r?G0z
zW4Kku46T>lIe%}?)ooj+$_yN*g$d7gVXxUX%Qq*dc!;T`vSvwVmE+1`IXRtEUC?_W
z)J3j(D2e>%Qg;C94p=v4VFGPA+0<ECLVpZ=dV#gM-H&=ZvmX1dMURp3U-nc=P1@Uv
znX~%c*GLo&Xsu>iA4WSXsOfs*8e^?A&gT6-V-CZ`-j>h3Q@eUfIdf5f(01rVL3$@`
z3qnFGJ?B13@H37)mk^T6w+zhp-OEg?dzLoi;f!PS9(FmjP;iy*J<07ej|pkkJb%L3
zy-(s8G?Oo}yHd~K><7Hhq=T!KxOsub?Xe6F%``(xmb5OnoAKokV>pxUJOl3GkkXZx
z&&#8y#i=L#m`7fRS)0wX+!Hb*G~HgQmTu;5y58bMmG|6i=#z3&v2$nLi)d3i#mz-0
zhB|MJ&+vMjJR>fmHOZmb<{oSEp??j^bUzYjXKI;(G2zK-Cv$rITu~WK?-VEA`j$Oc
z$lICD^~PyEjKs?5uW(8RVd%~6qE?bRI)|3u=ZwSJwo50bOyU`=rIXosrpb&C@v-br
zsO9xhW^x&W)K_nGf6jiMCQwoyAn8R4R68BLj?IQi&2#uTfQt~u2mv4{9Dk(alVEAi
zHZ}(^SEXlC(bRG&&~b^yFkj4gF(8^RmEor5gjOb%np!JmWejw^zpmZGN_lmlE3YPE
zi!;|~+yvlBZjSY!T5fB*H4(cs_UzN97&;55#e<JKwo1ze#Zx}<l$~8IrfmqeF%*$i
z*gK;BHk&G96<0gVvR)@pDSsaNE;6Mgnie?{3?Sz*^ob>-Ah@j+Vzr0tWL6Us|LQ?p
z(2XZ9CaU!@QrvrNDp)-j95&b9;Knewe1S{Oin>x)QQgo_0Z2kE%v;Wa&ao>1W&tl4
zWHSbKcz?<)!=1hgOnb+n0=#*7;!2g2tS~qHfncU-;x0^2bBxR?gnvOIKx&CHiX9n+
z&AdB9M*#R|*xbg=#LBm$#_5?T#$rV0+06TnWruQ-?_=%T)z!`W$WX02w9(bup~5bJ
z$U_(?L7K;<VWk~+lo%R0rCI2az-0H7O9G4SOqs#6CIgOiPxHix(sU>HI`#wxUwl5i
z_$bWuom0ESOl=htYJa2)gDuHHN6f)2s;N4TWzV^g4(Y&remABH!kBO>-0b0r9^J0t
zh*?I<D+5?5F;>ek7>U)r5MBVkE)U=hzvxNNuz-&{^^Kmj9a^CqIQs@FW-05yB70JJ
zI%>KV=`y&R>W~Q_8E|$-J|<F9D(=_hQwVQ}wzYY1i|9V+aDT<R4QyaF84L}4ay~r_
z^_Mkx3D`O-D@sqd4|?k5j^24_1W_N6g5kJ}d9%Wky%NxI4^Z}dY)&W;p^M1XI@)CH
zlIVv$69koD)=qkjP7!?;rAH(KAXH9B<YohobRZDRTu$r*aq7Lzi0yJOe!QojyQgD|
zIewfA9n4;U@qePg|ImA2`7emOtob<eF{b!3_5oe4QXAzM9+wRR##;OU)W|S`p`SJ`
z&+78GgMp`7<66iR(EUuRNfkN@4*tj+{yc^y&_;U+JLm`07j-X{Ab~GsHqCYWc$6Pb
z-x=i6He+StKqJtm;8G6&UmzW06m(WeT}W}65^dzwD1U;UiJiKQ0?}2{0$9>03@zE1
z83bW;A#BEy!GBbPi0ZHA%yUFvN}t#TeSv42%#$w~YMqo&{*o{>U%BE2qCiqm&6OZW
z+(?84;5V2JJw);t3d-(QW6o9euaZ;#ud0_-f>YTMj#+J4G_;*)a(%dZ+Z9PfEXXOw
zw-;p8C4Vqv4I?;re2j5%89aHd*ifTUR}D`3LQ7kgR`z`{@42)L%z(w<OEqX@3m;Q-
zC}EBZ`i&mymWqc)#nCiO2n6bH!R_?SC@W}l2sKi=g2`;slIV3h;`F{kkhDS0Xi&+s
zkPPTozTkW$BZ3G0hpHsDF(MN*9BeIK+ra?`6@LZYP=|Gt4Q4(_KpK6xYG1DM{V^4)
zBjm~g&tB^dgF!4H9>>j!6?m5-xzQ*zAJAZdO#8rytVlZs$QwG!Ucu@mSnb7lLz?%_
zv<<z>3`N)$-$9PMeRGZ!a<OFe$3Wue)HW~)T|?70ho(IosU1^WP!<aKxoP297iZnk
zuYW?^EQhDPF4eksg1rh1(d@X!gg6ivuXW9b8i(vm!*WEJj|?_Qsi7{n5QvKmoDK`#
zLwg-?xP>o;2(;gkVm*fCbV`h9;DSx+cCRfCkT{M9eTBkE*seDZMFeq1l^j@Y_}iwu
zvyGNBuTqDl3v$z=I30tH^37H#THNy33x7r*^t@9aUzgmT10t_BG2g^Vz&^bY`Wfw8
z2t^^>F-AcmXNlq}XURyk5gg=~iC0ZX>YpyfqJ02d-X984rt6K+<O;0A=9^+oIE+^*
zbuqnatm$(+%WhBMf+tuXgb2?!9)N=5aau#wk!3kiyaUD#=|>pO4WQU;tqChajDHPd
zg+dHu+{c1pD<x+nTXJYW+(f&94P-vXEn_Fwm{9G=_`qpg!sRVy218i-F5`s93{mL`
zml%ky6atNxKY-@*A%+M#p#glJ8yLZ-gpC}>f@1&RGitRE2&^sq66f?DpCE%k@DIR(
zs57jpZxs*+Tt<nQpvKH1gEs;RJAdr~47}t+?LlrD=F7{wO9$h_X#dM=x4~HJ&k^8Q
z%kT-G%Sjib$1;J~yh#ZDeMgyZuH6kQ+sqdTpM6npBLNy(YHH^Y1%pPg`)?bDaiwU8
z7f~D_fYvogotRi2VYN#xJ6#om1d!}$#l9FJU*XVlKfI=m22*+>uo^q<#ec<9pj7y^
z0n)-UObCgg->Ua((H!vh4#Zpg_@k~HQ`1+n&x1L4K!=Y8>03LjgsWCR437k}yMlSj
zh<kV#l}Q^#@8U2su4Z{3TLwI%$&_Jqm4^BtPlblDx>S)ouoB+CgX9sB0Gnli!xsQA
zU_~>{k1>>ChLYpN?s7gRaerMdQZBr3;=E~dPsdPW3G}xs0G}Nr=6DNRA7RBjHi-GR
zZoaBnCB(C%S;0xlH#0qh^LHc{7N#MQTyq05Qv`y_1l1V(ygT`|LQmIV8g+ZbjMX8r
zz%z*9;n9ka_C5wb0bcDyQ5(d=5<`SWQ5a*X9nRXn1P{;9aM(wN8Go@d2g&Q&jc7Gn
zI=dpuLdA4b#6LTaB@H>GQ~bwPXaWHTj*;R(nc@7_?tqIyMm5xiR)#>qWc<=(G?bkI
z)#L=3RER~9biJv5-CWwz_7VNc@D~I90ZW)N(1{3`ra17Zv;YdlBlI2i3NxG?ZHZ=+
z48oxkB~=ZC;a{mtzJGEKphiE9_^GNk*h9b*_jaN9&I0&zkKHjYSf^h8Y`=7}L94Ij
zfL3I-8`C+48|j+3RG;D2tqdth`gM9bUWUA{mIby69kgoIT?sQO3+z*A0v3$O^ML7b
zP;>zjft7|U#P_E<2aMyT`B8K5*8rK}zD~!i?C||uhB2ptIDalUQ(JVrg)ahAp;GsA
zYmQ6Zz>oR@95y&S89>Mcu(HKrR$_;zWQw6e(q6PHNeK@{1lFB|lLhfnL(P(p4ts!*
z!J}Gq=cS49-!x4Y%RnP(BHj)qjbywSejz`O2J_9By3@@HBpa<C40e(fRAel6NQafc
z8~u6>snWO8mVYx6OYB+}j&{+kxngpdGwEAx5ExLY(3>>1$N29_-54^ty0c+PKF`qD
zCAsxBYII_3pyVi$x-w!BN-IX(2_ZSJah0!40GMRSQFe|+N<kI~i76sL*GOdNij$1+
z5CR+x=Xfx{CQf1wJS9dcGCK|)2+c>JxcG0I3jSi`xqld0y|i4>_HC(SB76-xGX(O^
zWaPlKByB2!rYKvG6yXn_bS#Eg7EBGOdMr*F3)u#ZvRt%I3<-IR^Ga$LbZ<h(9LV2d
zRcmV;k1Yszw>cR3=1|KZC!|>C)CMW~a#9;K+cpqj$t{zK#SrHJoknMAWkw7EiaBc1
zlxV^6)qjv^cm}%q;szL*vcq{GMq317T8eqA5_G|GQqIngE1QaT+frI(G9MGBPd+kE
zt-%@KJ8EvKC5(J4+&rHZrekoX9aZNJGlni^eN}MpA}vVS@%qfH$8mZtqir)epE`|Y
zB4nVD638)Gf4gTDNFcUTL!q3gjYjQr)5B0*pMOO+tmXnu&;r`XL#Z1cT^Jf!f<IJ`
zbQ5Y>QuZ`rgU9ev^mOvrX9u#^mN*@AsC^*TpW<oStOFeuM7r=F5DSNUl?cAUeqeys
zGm8t=4+$+v$kN|-kJu(__ct>AggrZu1i-~EZQWL-!!find~kqdI`E19ASndH@~Jf7
zkbfn}vyR2xB&1*b+Q4ISBw`XM&3Tvu3>n%Mu3Dla?Xw_Pt{D=WhO2^^9r70q$2UaN
zy+<u2JEnH0+ucK+?JWSBj@p7f0F>B!Xg>|~!K|W@WXy|PHs)#uPD%$=)Lu+O(I1G0
z;d~X<YV5`P$`s3N;y3V#6900z#BZLSAAec?Yl%`A1rOQ)pa4E9#D~~X_%yrrijeAn
z&Pd+l%vqPyBzuSv<41-wOuPofd@Z;~B8Q+mG^GA>D?tmp`yy1FBw;J_+j5oI;yq`S
z2<Iruz+(ZIky!8Du7)51ZBTC=6oD#%XKanOT^%B+<Kj~4;$OK_`e^5Zzqx|+B7gRN
z3UL9sve56ghD216Lzc20n|B%XZT-TFSU?ZsCsx(&+$`EOX&zB_a3zeEU$HBc(XfS4
z8yiR4=}gK+IwT5;O-}(?OiiGL@blM4_VNao(1yp7N*#RdBHe5u_K$Y<w8x&bSx6&j
z>nRUo-BI+KC(;>*z$3!6MLxkJM}MAfXXe4w4>GxfB5>fOsE_hsxvg2xs1J#iNiS)4
z{_TJ?4OE&mb<?)P`n>gd19<zq1;%6BFn%5A0(zMa;yr@xmjfWQeC2>B_X@x<y8h9&
zIulf9VxZ&dIT5IYNnr-sWKeM27BHq-+85N0k*xXKCNFn?TJkk^ToAr3-G6?>)NKQ=
zKz+LBBET3L#3ZkR8_L4_OVXEjnL#QOg&ad0`mtgUVS!<J;!TaS<EBHJQXoQ`XxrOM
zOX!!{^_L+)7?KYfMcuj<iqnQ3?8TVz05&vdtZsBlA)KbYBXq+m3AnXa^zm=$4@j^f
zEEdzOn{pFl#RWO38kWKdnSV`Pnk+PPrRafG(t=$#nI@VWI(abQe}n;yh)r8T^mwQL
zb}V8q@ZFP!)vmmP^-~rc1JSg9h<-+C=<X=%EA8I;gC?QMo+m>)(gfwuOw(oEY3jPo
zik=A$YrWUeoz3eWv`2#kzZE=H`@KOogdI~AwSQEQ#Xw+92xB@d6n||9f^oV(3#9t;
zq&f<Tpv8`%lQPZ-&Fc101n;w5+R||G++FSr>TV_gV+VD+a)m48ij%@OpfFn@Gq)i!
zoYb`sfJyX;AwOm(#3z#tOI1L^;w<^VzB_Z!67a<I==LB&2@dU6EvjvO-C3HwEy~`&
zIs=kAZTJAGm{^bgM}M{t6*h{JX7lK$rF%K}b9vT*8_oPcDhubK^oE8$=1jT-KZ7Q#
zf#-domKp<ur%Gsz>sz5@dMeG^;ha`?MI};ngHKx;q|*#>4(ll%uJv7aWNuw>Pu1S3
zY1;i+8s!=wYnWww&}Gpo7_9NxXf<!ARU57AAg-tGUy!88s(&i#4$9lO-<!F3Z@gOs
z!oIuca7oq`=$%4mGf@*)vXIHXB&!>HxW57bKzCi%C|Is9zmEXKB8={sbXM0;sc_`j
znr<VPI5o!_+|5`wS8xK9WT7G6-oA%DLPgHtOLY&iE*~>yW|C9tFZ-OKY{n7=v^R00
zU>&KhXpo35bAMO_-N7aqP$+Urcfj>WP2fK%k<8IwAzk-k62Q4Vi@dkN#cM~K5O*8y
zq7XgdDgO-D$EpEB#-%bbaoOJPsBGL3dSR=az3A?l+wZ0m_R>9E)(!}b=timo&APX2
zGknG;BK}(52QDetEV#62uePUqp4(^H>u)O}Cj;4-Hh;9F98PAcWFv%o`qKzcI_yLE
zZX8uc)k;*5gzga4^^)|TQvYcG()<$|e*CPW>rYky00D$)LqkwWLqi~Na&Km7Y-Iod
zc$|HaJxIeq9K~PLN<}IT77=mCP@OD@iind`u?QAQTcK44lS{v#Nkfw2;wZQl9Q;_U
zI=DFN>VM!W2!bCVPL58BE>hzEl0u6Z503ls?%w0>9UwF+Of>`JfT~$WDjpNFxm7Xv
ziXa9cU={(1nR+6<n1Sc`x`&UicTt|@eeTcEtK>}v_(bA4rW+RV2J!T!rE}gV4zrS^
z5T6r|8FWG7N3P2*zi}=)Ebz>*kx9)Hhl#~v2Y<^Q%u0qzJVhK)RE_e5tjh}LEzWAC
z##;B}FAU|il{D9B4kL~wB#?v%88wtqfrTio8Yw1Hv>)^E4>|rMxny#c!N{?IDpW|0
zAN&t~cWV|VC)}h^4Cs2X?T-;4xC=Dvw*7r<+szZe{|sDdZGW`^%zTnwZ)=ewpl=(v
zxI}Ji@*Z%x0}MXtk|8;gpQcbK0Pkn?O*x?d7U)@Xdu#3E^a03FSIalR!67hOr0jK%
zcXxO8_V1Zie?M~3a;G;sJD-z7A~1jC2Nnh+C<(%ZP5=M`=Sf6CRCwC$oIP&BKoCX;
z!x@s2GAX%&3!lNcfF<`xEBORSoB)XngfmdkrlgEZ%5Vons*REjyF0VSKWn~iAjE4u
zdAu_Zd(7lYbfpN!B+qj(==*L*Z+T83^Il(G#PdGunr1{q$K#PbX|Y)Rygz@PPV9N}
z`Ml8)O(>EPKWJ4|K|3tVGH70wWpYprDTURLQdkY?f=zr!k_&6XabZn38*IXX^1*7T
z%jNRt)dy>Xy7l>87t?e){quUyG5h_;YPAa5$!4<&nz!HYkw<$QGqWs8M$@t=k`mYx
z><O#>5z`Z=rn{<^tERiEmdk&Z%&O%)qFOGvL%Mx%=*^?1<-+Fx`ly*Q;&T97t-tko
z;tMfXR7@zYsF+YT_{4QSN^MHRNo`8Qxoj#4Sv-9xAM6SC)RjF=h$hl`SE4KI3HAg~
zfDSc}MwRfTc~mESX&!Bo@Ntd;6rcb_!bif#ISNpKjuI4?bXrOHhr@q?Jt0lgpM)PW
z@A>IT4Ec3FV=(~~pa6y8-y`8mC!qsk^oyygs-X7FvMhtzGqWt?H4&PSA)}Z6(V;-z
z1l5qzZiY4?<6cbqKE1RDwC&bRX9t9Iv<Vwc2gJ<v&mqC$>oV*K_S9CwACfVR$DW1=
zYX#NzB!%TZ&?1G6|Eqrpx5?Eu@7`rJiKW)ZYfnRcrU~}cxjk`AiF4Pu=>cKelf;xd
zzoZjI!Urfo0SZunjtkUpPj&4#rH>ETQ+)OmgE?W<0~DYD1t>rVXiwhjPIc|S#sqsB
zn?32%!evigU3$c-2Pi-R3Q&N?W>3`Z9Xi;P-p2R%&)50fEcAbzXObk(En(FI6rcbF
zC_o>?p3*dRZ?W4EXB*fP*PcR+D%7%U=7p~DURJ$Qik8czc;`h?P*D`!rl&T3<6e}W
zI2*0k>!6))x7+qZuaqLC)W7$VaQ71W-YXL)+>+4$4tHyzw}smmdRw?3GW4DQFjb=x
d8bjCkH-1^)Wxo$(c`^V1002ovPDHLkV1hvhrn~?E

diff --git a/Templates/BaseGame/game/data/UI/scripts/controlsMenu.tscript b/Templates/BaseGame/game/data/UI/scripts/controlsMenu.tscript
index 071902d99..b88efa0d6 100644
--- a/Templates/BaseGame/game/data/UI/scripts/controlsMenu.tscript
+++ b/Templates/BaseGame/game/data/UI/scripts/controlsMenu.tscript
@@ -176,7 +176,7 @@ function fillRemapList()
       OptionsMenuSettingsList.addKeybindRow(getField(%keyMap, 0), getButtonBitmap(%device, getField(%keyMap, 1)), "doKeyRemap", -1, -15, true, %description);
    }
 
-   OptionsMenuSettingsList.refresh();
+   //OptionsMenuSettingsList.refresh();
       //OptionsMenu.addRow( %i, %this.buildFullMapString( %i ) );
 }
 
diff --git a/Templates/BaseGame/game/data/UI/scripts/menuInputButtons.tscript b/Templates/BaseGame/game/data/UI/scripts/menuInputButtons.tscript
deleted file mode 100644
index 3d4c76c90..000000000
--- a/Templates/BaseGame/game/data/UI/scripts/menuInputButtons.tscript
+++ /dev/null
@@ -1,341 +0,0 @@
-//==============================================================================
-// Menu Input Buttons
-// This file manages the Menu Input Buttons stuff
-// Any time you have a GUI button that should be clickable AND map to a key input
-// such as a gamepad button, or enter, etc, this stuff can be used
-//==============================================================================
-/*
-Gamepad input reference for 360 controller
-btn_a = A
-btn_b = B
-btn_x = X
-btn_y = Y
-btn_r = Right Bumper
-btn_l = Right Bumper
-upov = Dpad Up
-dpov = Dpad Down
-lpov = Dpad Left
-rpov = Dpad Right
-xaxis = Left Stick | + values = up, - values = down
-yaxis = Left Stick | + values = up, - values = down
-rxaxis = Right Stick | + values = up, - values = down
-ryaxis = Right Stick | + values = up, - values = down
-zaxis = Left Trigger
-rzaxis = Right Trigger
-btn_start = Start
-btn_back = Back/Select
-*/
-
-/// This is used with the main UI menu lists, when a non-axis input event is called
-/// such as pressing a button
-/// It is called from the engine
-function UIMenuButtonList::onInputEvent(%this, %device, %action, %state)
-{
-   if(%state)
-      $activeMenuButtonContainer.processInputs(%device, %action);
-}
-
-/// This is used with the main UI menu lists, when an axis input event is called
-/// such as moving a joystick
-/// It is called from the engine
-function UIMenuButtonList::onAxisEvent(%this, %device, %action, %axisVal)
-{
-   //Skip out of the value is too low as it could just be noise or miscalibrated defaults
-   if(%axisVal < 0.02)
-      return;
-      
-   $activeMenuButtonContainer.processAxisEvent(%device, %action);
-}
-
-/// Sets the command and text for the specified button. If %text and %command
-/// are left empty, the button will be disabled and hidden.
-///
-/// \param %gamepadButton (string) The button to set for when using gamepad input. See the input map reference comment at the top of the file
-/// \param %keyboardButton (string) The button to set for when using keyboard/mouse input.
-/// \param %text (string) The text to display next to the A button graphic.
-/// \param %command (string) The command executed when the A button is pressed.
-/// \param %gamepadOnly (bool) If true, will only show the button when working in the gamepad input mode
-function MenuInputButton::set(%this, %gamepadButton, %keyboardButton, %text, %command, %gamepadOnly)
-{
-   %set = (! ((%text $= "") && (%command $= "")));
-   %this.setText(%text);
-   %this.setActive(%set);
-   %this.setVisible(%set);
-   
-   %this.gamepadButton = %gamepadButton;
-   %this.keyboardButton = %keyboardButton;
-   
-   if(%gamepadOnly $= "")
-      %gamepadOnly = false;
-      
-   %this.gamepadOnly = %gamepadOnly;
-
-   %this.Command = %command;
-}
-
-/// Refreshes the specific button, updating it's visbility status and the displayed input image
-function MenuInputButton::refresh(%this)
-{
-   %set = (! ((%this.text $= "") && (%this.command $= "")));
-   
-   //Special-case of where we're in keyboard+mouse mode, but the menubutton is gamepad only mode, so we early out
-   if(%this.gamepadOnly && $activeControllerType !$= "gamepad")
-      %set = false;
-      
-   %this.setActive(%set);
-   %this.setVisible(%set);
-   
-   if(!%this.isActive())
-      return;
-   
-   if($activeControllerType $= "gamepad")
-   {
-      if(%this.gamepadButton !$= "")
-      {
-         %assetId = "";
-         if($activeControllerName $= "PS4 Controller")
-         { 
-            %assetId = "UI:PS4_";
-            
-            if(%this.gamepadButton $= "btn_a")
-               %assetId = %assetId @ "Cross";
-            else if(%this.gamepadButton $= "btn_b")
-               %assetId = %assetId @ "Circle";
-            else if(%this.gamepadButton $= "btn_x")
-               %assetId = %assetId @ "Square";
-            else if(%this.gamepadButton $= "btn_y")
-               %assetId = %assetId @ "Triangle";
-            else if(%this.gamepadButton $= "btn_l")
-               %assetId = %assetId @ "L1";
-            else if(%this.gamepadButton $= "zaxis")
-               %assetId = %assetId @ "L2";
-            else if(%this.gamepadButton $= "btn_r")
-               %assetId = %assetId @ "R1";
-            else if(%this.gamepadButton $= "rzaxis")
-               %assetId = %assetId @ "R2";
-            else if(%this.gamepadButton $= "btn_start")
-               %assetId = %assetId @ "Options";
-            else if(%this.gamepadButton $= "btn_back")
-               %assetId = %assetId @ "Share";
-         }
-         else if($activeControllerName $= "Nintendo Switch Pro Controller")
-         {
-            %assetId = "UI:Switch_";
-            
-            if(%this.gamepadButton $= "btn_a")
-               %assetId = %assetId @ "B";
-            else if(%this.gamepadButton $= "btn_b")
-               %assetId = %assetId @ "A";
-            else if(%this.gamepadButton $= "btn_x")
-               %assetId = %assetId @ "Y";
-            else if(%this.gamepadButton $= "btn_y")
-               %assetId = %assetId @ "X";
-            else if(%this.gamepadButton $= "btn_l")
-               %assetId = %assetId @ "LB";
-            else if(%this.gamepadButton $= "zaxis")
-               %assetId = %assetId @ "LT";
-            else if(%this.gamepadButton $= "btn_r")
-               %assetId = %assetId @ "RB";
-            else if(%this.gamepadButton $= "rzaxis")
-               %assetId = %assetId @ "RT";
-            else if(%this.gamepadButton $= "btn_start")
-               %assetId = %assetId @ "Plus";
-            else if(%this.gamepadButton $= "btn_back")
-               %assetId = %assetId @ "Minus";
-         }
-         else if($activeControllerName !$= "")
-         {
-            %assetId = "UI:Xbox_";
-            
-            if(%this.gamepadButton $= "btn_a")
-               %assetId = %assetId @ "A";
-            else if(%this.gamepadButton $= "btn_b")
-               %assetId = %assetId @ "B";
-            else if(%this.gamepadButton $= "btn_x")
-               %assetId = %assetId @ "X";
-            else if(%this.gamepadButton $= "btn_y")
-               %assetId = %assetId @ "Y";
-            else if(%this.gamepadButton $= "btn_l")
-               %assetId = %assetId @ "LB";
-            else if(%this.gamepadButton $= "zaxis")
-               %assetId = %assetId @ "LT";
-            else if(%this.gamepadButton $= "btn_r")
-               %assetId = %assetId @ "RB";
-            else if(%this.gamepadButton $= "rzaxis")
-               %assetId = %assetId @ "RT";
-            else if(%this.gamepadButton $= "btn_start")
-               %assetId = %assetId @ "Menu";
-            else if(%this.gamepadButton $= "btn_back")
-               %assetId = %assetId @ "Windows";
-         }
-      } 
-   }
-   else
-   {
-      if(%this.keyboardButton !$= "")
-      {
-         %assetId = "UI:Keyboard_Black_" @ %this.keyboardButton;
-      }
-   }
-   
-   %this.setBitmap(%assetId @ "_image");
-
-   return true;
-}
-
-/// Refreshes a menu input container, updating the buttons inside it
-function MenuInputButtonContainer::refresh(%this)
-{
-   %count = %this.getCount();
-   for(%i=0; %i < %count; %i++)
-   {
-      %btn = %this.getObject(%i);
-      
-      %btn.refresh();
-   }
-}
-
-/// Sets the given MenuInputButtonContainer as the active one. This directs input events
-/// to it's buttons, ensures it's visible, and auto-hides the old active container if it was set
-function MenuInputButtonContainer::setActive(%this)
-{
-   if(isObject($activeMenuButtonContainer))
-      $activeMenuButtonContainer.hidden = true;
-      
-   $activeMenuButtonContainer = %this;
-   $activeMenuButtonContainer.hidden = false;
-   $activeMenuButtonContainer.refresh();
-}
-
-/// Checks the input manager for if we have a gamepad active and gets it's name
-/// If we have one, also sets the active input type to gamepad
-function MenuInputButtonContainer::checkGamepad(%this)
-{
-   %controllerName = SDLInputManager::JoystickNameForIndex(0);
-   
-   $activeControllerName = %controllerName;
-   
-   if($activeControllerName $= "")
-      $activeControllerType = "K&M";
-   else
-      $activeControllerType = "gamepad";     
-}
-   
-/// This is called by the earlier inputs callback that comes from the menu list
-/// this allows us to first check what the input type is, and if the device is different
-/// (such as going from keyboard and mouse to gamepad) we can refresh the buttons to update
-/// the display
-/// Then we process the input to see if it matches to any of the button maps for our 
-/// MenuInputButtons. If we have a match, we execute it's command.
-function MenuInputButtonContainer::processInputs(%this, %device, %action)
-{
-   //check to see if our status has changed
-   %changed = false;
-   
-   %oldDevice = $activeControllerName;
-   
-   %deviceName = stripTrailingNumber(%device);
-   
-   if(%deviceName $= "keyboard" || %deviceName $= "mouse")
-   {
-      if($activeControllerName !$= "K&M")
-         %changed = true;
-         
-      $activeControllerName = "K&M";
-      $activeControllerType = "K&M";
-      Canvas.showCursor();
-   }
-   else
-   {
-      if(%this.checkGamepad())
-      {
-         Canvas.hideCursor();
-      }
-      
-      if($activeControllerType !$= %oldDevice)
-         %changed = true;
-   }
-   
-   if(%changed)
-      %this.refresh();
-      
-   //Now process the input for the button accelerator, if applicable
-   //Set up our basic buttons
-   for(%i=0; %i < %this.getCount(); %i++)
-   {
-      %btn = %this.getObject(%i);
-      
-      if(!%btn.isActive())
-         continue;
-      
-      if($activeControllerType !$= "K&M")
-      {
-         if(%btn.gamepadButton $= %action)
-         {
-            eval(%btn.command);
-         }
-      }
-      else
-      {
-         if(%btn.keyboardButton $= %action)
-         {
-            eval(%btn.command);
-         }
-      }
-   }
-}
-
-/// This is called by the earlier inputs callback that comes from the menu list
-/// this allows us to first check what the input type is, and if the device is different
-/// (such as going from keyboard and mouse to gamepad) we can refresh the buttons to update
-/// the display
-function MenuInputButtonContainer::processAxisEvent(%this, %device, %action, %axisVal)
-{
-   //check to see if our status has changed
-   %changed = false;
-   
-   %oldDevice = $activeControllerName;
-   
-   %deviceName = stripTrailingNumber(%device);
-   
-   if(%deviceName $= "mouse")
-   {
-      if($activeControllerName !$= "K&M")
-         %changed = true;
-         
-      $activeControllerName = "K&M";
-      $activeControllerType = "K&M";
-      Canvas.showCursor();
-   }
-   else
-   {
-      if(%this.checkGamepad())
-      {
-         Canvas.hideCursor();
-      }
-      
-      if($activeControllerType !$= %oldDevice)
-         %changed = true;
-   }
-   
-   if(%changed)
-      %this.refresh();
-}
-
-//
-//
-function onSDLDeviceConnected(%sdlIndex, %deviceName, %deviceType)
-{
-   /*if(GamepadButtonsGui.checkGamepad())
-   {
-      GamepadButtonsGui.hidden = false;  
-   }*/
-}
-
-function onSDLDeviceDisconnected(%sdlIndex)
-{
-   /*if(!GamepadButtonsGui.checkGamepad())
-   {
-      GamepadButtonsGui.hidden = true;
-   }*/   
-}
\ No newline at end of file
diff --git a/Templates/BaseGame/game/data/UI/scripts/profiles.tscript b/Templates/BaseGame/game/data/UI/scripts/profiles.tscript
index c9dfed5b5..3aae4df2a 100644
--- a/Templates/BaseGame/game/data/UI/scripts/profiles.tscript
+++ b/Templates/BaseGame/game/data/UI/scripts/profiles.tscript
@@ -145,6 +145,12 @@ new GuiControlProfile( GuiBlankMenuButtonProfile )
    category = "Core";
 };
 
+if( !isObject( GuiJoinServerButtonProfile ) )
+new GuiControlProfile( GuiJoinServerButtonProfile : GuiMenuButtonProfile )
+{
+   justify = "left";
+};
+
 if( !isObject( GuiMenuTextProfile ) )
 new GuiControlProfile( GuiMenuTextProfile )
 {

From 01de818503eff34fdcfaa9cfe5725dfb68024f81 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Tue, 22 Feb 2022 20:12:39 -0600
Subject: [PATCH 315/399] Ran importer on UI module to ensure guis and images
 are converted to latest standards Updated all UI module controls to utilize a
 more standard structure with stack controls instead of the GameMenu ctrls, as
 well as more standardization of gamepad input handling

---
 .../data/ExampleModule/ExampleModule.tscript  |   6 +
 Templates/BaseGame/game/data/UI/UI.module     |   2 +-
 Templates/BaseGame/game/data/UI/UI.tscript    |   2 +-
 .../data/UI/datablocks/guiSounds.asset.taml   |   2 +-
 .../game/data/UI/datablocks/guiSounds.tscript |   2 +-
 .../data/UI/guis/ChooseLevelDlg.asset.taml    |   6 +-
 .../data/UI/guis/GuiMusicPlayer.asset.taml    |   6 +-
 .../data/UI/guis/IODropdownDlg.asset.taml     |   5 +-
 .../data/UI/guis/JoinServerMenu.asset.taml    |   6 +-
 .../game/data/UI/guis/LoadingGui.asset.taml   |   5 +-
 .../game/data/UI/guis/MainMenuGui.asset.taml  |   6 +-
 .../data/UI/guis/MessageBoxDlg.asset.taml     |   5 +-
 .../data/UI/guis/NetGraphProfile.asset.taml   |   7 -
 .../game/data/UI/guis/OptionsMenu.asset.taml  |   6 +-
 .../game/data/UI/guis/PauseMenu.asset.taml    |   6 +-
 .../game/data/UI/guis/ProfilerGui.asset.taml  |   6 +-
 .../data/UI/guis/RemapConfirmDlg.asset.taml   |   5 +-
 .../game/data/UI/guis/RemapDlg.asset.taml     |   5 +-
 .../game/data/UI/guis/StartupGui.asset.taml   |   6 +-
 .../game/data/UI/guis/chooseLevelDlg.gui      |   4 +-
 .../data/UI/guis/controlsMenuSetting.taml     | 102 ---
 .../game/data/UI/guis/joinServerMenu.gui      |   2 +-
 .../game/data/UI/guis/joinServerMenu.tscript  |   8 +-
 .../BaseGame/game/data/UI/guis/mainMenu.gui   |   4 +-
 .../game/data/UI/guis/mainMenu.tscript        |   3 +-
 .../game/data/UI/guis/messageBoxDlg.gui       |   4 +-
 .../game/data/UI/guis/netGraphGui.gui         |   2 +-
 .../game/data/UI/guis/optionsMenu.gui         | 183 ------
 .../game/data/UI/guis/optionsMenu.tscript     | 581 ++++++++++++------
 .../BaseGame/game/data/UI/guis/pauseMenu.gui  |  49 +-
 .../game/data/UI/guis/pauseMenu.tscript       |  49 +-
 .../game/data/UI/guis/profiler.tscript        |   2 +-
 .../data/UI/guis/recordingsDlg.asset.taml     |   5 +-
 .../BaseGame/game/data/UI/guis/startupGui.gui |   4 +-
 .../game/data/UI/guis/startupGui.tscript      |   2 +-
 .../UI/images/Torque-3D-logo-shortcut.png     | Bin 10728 -> 0 bytes
 .../game/data/UI/images/Torque-3D-logo-w.png  | Bin 19328 -> 0 bytes
 .../game/data/UI/images/Torque-3D-logo.png    | Bin 9063 -> 0 bytes
 .../data/UI/images/Torque-3D-logo_alt.png     | Bin 11616 -> 0 bytes
 .../Torque_3D_logo_alt_image.asset.taml       |   2 +-
 .../UI/images/Torque_3D_logo_image.asset.taml |   2 +-
 .../Torque_3D_logo_shortcut_image.asset.taml  |   2 +-
 .../images/Torque_3D_logo_w_image.asset.taml  |   2 +-
 .../game/data/UI/images/background-dark.png   | Bin 5751 -> 0 bytes
 .../images/background_dark_image.asset.taml   |   8 -
 .../game/data/UI/images/clear-btn_d.png       | Bin 593 -> 0 bytes
 .../game/data/UI/images/clear-btn_h.png       | Bin 595 -> 0 bytes
 .../game/data/UI/images/clear-btn_n.png       | Bin 377 -> 0 bytes
 .../data/UI/images/collapse-toolbar_d.png     | Bin 280 -> 0 bytes
 .../data/UI/images/collapse-toolbar_h.png     | Bin 468 -> 0 bytes
 .../data/UI/images/collapse-toolbar_n.png     | Bin 439 -> 0 bytes
 .../data/UI/images/dropdown-button-arrow.png  | Bin 132 -> 0 bytes
 .../game/data/UI/images/dropdown-textEdit.png | Bin 390 -> 0 bytes
 .../game/data/UI/images/expand-toolbar_d.png  | Bin 278 -> 0 bytes
 .../game/data/UI/images/expand-toolbar_h.png  | Bin 468 -> 0 bytes
 .../game/data/UI/images/expand-toolbar_n.png  | Bin 437 -> 0 bytes
 .../game/data/UI/images/group-border.png      | Bin 1273 -> 0 bytes
 .../game/data/UI/images/inactive-overlay.png  | Bin 131 -> 0 bytes
 .../game/data/UI/images/menu-button.png       | Bin 3559 -> 0 bytes
 .../game/data/UI/images/next-button_d.png     | Bin 279 -> 0 bytes
 .../game/data/UI/images/next-button_h.png     | Bin 549 -> 0 bytes
 .../game/data/UI/images/next-button_n.png     | Bin 484 -> 0 bytes
 .../game/data/UI/images/no-preview.png        | Bin 34615 -> 0 bytes
 .../game/data/UI/images/previous-button_d.png | Bin 290 -> 0 bytes
 .../game/data/UI/images/previous-button_h.png | Bin 561 -> 0 bytes
 .../game/data/UI/images/previous-button_n.png | Bin 494 -> 0 bytes
 .../data/UI/images/selector-button-blank.png  | Bin 744 -> 0 bytes
 .../data/UI/images/selector-button-dark.png   | Bin 1942 -> 0 bytes
 .../images/selector-button-highlight-only.png | Bin 1613 -> 0 bytes
 .../game/data/UI/images/selector-button.png   | Bin 4002 -> 0 bytes
 .../game/data/UI/images/separator-h.png       | Bin 117 -> 0 bytes
 .../game/data/UI/images/separator-v.png       | Bin 118 -> 0 bytes
 .../game/data/UI/images/slider - Copy.png     | Bin 908 -> 0 bytes
 .../game/data/UI/images/slider-w-box.png      | Bin 982 -> 0 bytes
 .../UI/images/slider___Copy_image.asset.taml  |   8 -
 .../game/data/UI/images/tab-border.png        | Bin 1203 -> 0 bytes
 .../game/data/UI/scripts/controlsMenu.tscript |  17 +-
 .../game/data/UI/scripts/cursors.tscript      |   2 +-
 .../game/data/UI/scripts/utility.tscript      | 114 ++--
 .../scripts/projectImporter.tscript           |   8 +-
 80 files changed, 590 insertions(+), 673 deletions(-)
 delete mode 100644 Templates/BaseGame/game/data/UI/guis/NetGraphProfile.asset.taml
 delete mode 100644 Templates/BaseGame/game/data/UI/guis/controlsMenuSetting.taml
 delete mode 100644 Templates/BaseGame/game/data/UI/images/Torque-3D-logo-shortcut.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/Torque-3D-logo-w.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/Torque-3D-logo.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/Torque-3D-logo_alt.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/background-dark.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/background_dark_image.asset.taml
 delete mode 100644 Templates/BaseGame/game/data/UI/images/clear-btn_d.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/clear-btn_h.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/clear-btn_n.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/collapse-toolbar_d.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/collapse-toolbar_h.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/collapse-toolbar_n.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/dropdown-button-arrow.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/dropdown-textEdit.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/expand-toolbar_d.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/expand-toolbar_h.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/expand-toolbar_n.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/group-border.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/inactive-overlay.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/menu-button.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/next-button_d.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/next-button_h.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/next-button_n.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/no-preview.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/previous-button_d.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/previous-button_h.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/previous-button_n.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/selector-button-blank.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/selector-button-dark.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/selector-button-highlight-only.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/selector-button.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/separator-h.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/separator-v.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/slider - Copy.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/slider-w-box.png
 delete mode 100644 Templates/BaseGame/game/data/UI/images/slider___Copy_image.asset.taml
 delete mode 100644 Templates/BaseGame/game/data/UI/images/tab-border.png

diff --git a/Templates/BaseGame/game/data/ExampleModule/ExampleModule.tscript b/Templates/BaseGame/game/data/ExampleModule/ExampleModule.tscript
index 0b233dc61..0f540c0d8 100644
--- a/Templates/BaseGame/game/data/ExampleModule/ExampleModule.tscript
+++ b/Templates/BaseGame/game/data/ExampleModule/ExampleModule.tscript
@@ -81,6 +81,7 @@ function ExampleModule::initClient(%this)
       exec(%prefPath @ "/keybinds." @ $TorqueScriptFileExtension);
       
    %this.queueExec("./scripts/inputCommands");
+   addOptionsMenuCategory("Example Options", "testExampleOptions();");
 }
 
 //This is called when a game session client successfuly connects to a game server. 
@@ -105,4 +106,9 @@ function ExampleModule::onDestroyClientConnection(%this)
 {
    //This will pop the keybind, cleaning it up from the input stack, as it no longer applies
    ExampleMoveMap.pop();
+}
+
+function testExampleOptions()
+{
+   addListOption("Test Option", "This is a test option", $testOptionValue, "OptionA\tOptionB");  
 }
\ No newline at end of file
diff --git a/Templates/BaseGame/game/data/UI/UI.module b/Templates/BaseGame/game/data/UI/UI.module
index 1ab3024a2..ed204d1b1 100644
--- a/Templates/BaseGame/game/data/UI/UI.module
+++ b/Templates/BaseGame/game/data/UI/UI.module
@@ -11,4 +11,4 @@
         canSaveDynamicFields="true"
         Extension="asset.taml"
         Recurse="true" />
-</ModuleDefinition>
\ No newline at end of file
+</ModuleDefinition>
diff --git a/Templates/BaseGame/game/data/UI/UI.tscript b/Templates/BaseGame/game/data/UI/UI.tscript
index 5b8c1ee6a..cd645f86f 100644
--- a/Templates/BaseGame/game/data/UI/UI.tscript
+++ b/Templates/BaseGame/game/data/UI/UI.tscript
@@ -83,4 +83,4 @@ function UI::initClient(%this)
 
 function UI::onCreateClientConnection(%this){}
 
-function UI::onDestroyClientConnection(%this){}
\ No newline at end of file
+function UI::onDestroyClientConnection(%this){}
diff --git a/Templates/BaseGame/game/data/UI/datablocks/guiSounds.asset.taml b/Templates/BaseGame/game/data/UI/datablocks/guiSounds.asset.taml
index 81e2a8e24..7e5a1cada 100644
--- a/Templates/BaseGame/game/data/UI/datablocks/guiSounds.asset.taml
+++ b/Templates/BaseGame/game/data/UI/datablocks/guiSounds.asset.taml
@@ -2,5 +2,5 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="guiSounds"
-    scriptFile="@assetFile=guiSounds.cs"
+    scriptFile="@assetFile=guiSounds"
     VersionId="1" />
diff --git a/Templates/BaseGame/game/data/UI/datablocks/guiSounds.tscript b/Templates/BaseGame/game/data/UI/datablocks/guiSounds.tscript
index 0aab47fb9..4eed5f78a 100644
--- a/Templates/BaseGame/game/data/UI/datablocks/guiSounds.tscript
+++ b/Templates/BaseGame/game/data/UI/datablocks/guiSounds.tscript
@@ -31,4 +31,4 @@ singleton SFXProfile(menuButtonHover)
    preload = true;
    description = AudioGui;
    fileName = "data/ui/sounds/buttonHover";
-};
\ No newline at end of file
+};
diff --git a/Templates/BaseGame/game/data/UI/guis/ChooseLevelDlg.asset.taml b/Templates/BaseGame/game/data/UI/guis/ChooseLevelDlg.asset.taml
index 2d6a987f0..9090ea1af 100644
--- a/Templates/BaseGame/game/data/UI/guis/ChooseLevelDlg.asset.taml
+++ b/Templates/BaseGame/game/data/UI/guis/ChooseLevelDlg.asset.taml
@@ -1,7 +1,5 @@
 <GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
     AssetName="ChooseLevelDlg"
-    scriptFile="@assetFile=chooseLevelDlg.gui"
+    scriptFile="@assetFile=chooseLevelDlg"
     GUIFile="@assetFile=chooseLevelDlg.gui"
-    VersionId="1" />
+    VersionId="1"/>
diff --git a/Templates/BaseGame/game/data/UI/guis/GuiMusicPlayer.asset.taml b/Templates/BaseGame/game/data/UI/guis/GuiMusicPlayer.asset.taml
index 7014d72a6..94601d7a3 100644
--- a/Templates/BaseGame/game/data/UI/guis/GuiMusicPlayer.asset.taml
+++ b/Templates/BaseGame/game/data/UI/guis/GuiMusicPlayer.asset.taml
@@ -1,7 +1,5 @@
 <GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
     AssetName="GuiMusicPlayer"
-    scriptFile="@assetFile=guiMusicPlayer.gui"
+    scriptFile="@assetFile=guiMusicPlayer"
     GUIFile="@assetFile=guiMusicPlayer.gui"
-    VersionId="1" />
+    VersionId="1"/>
diff --git a/Templates/BaseGame/game/data/UI/guis/IODropdownDlg.asset.taml b/Templates/BaseGame/game/data/UI/guis/IODropdownDlg.asset.taml
index b929c70b0..d1d0c8c8e 100644
--- a/Templates/BaseGame/game/data/UI/guis/IODropdownDlg.asset.taml
+++ b/Templates/BaseGame/game/data/UI/guis/IODropdownDlg.asset.taml
@@ -1,7 +1,4 @@
 <GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
     AssetName="IODropdownDlg"
-    scriptFile="@assetFile=IODropdownDlg.ed.gui"
     GUIFile="@assetFile=IODropdownDlg.ed.gui"
-    VersionId="1" />
+    VersionId="1"/>
diff --git a/Templates/BaseGame/game/data/UI/guis/JoinServerMenu.asset.taml b/Templates/BaseGame/game/data/UI/guis/JoinServerMenu.asset.taml
index 0ca202e6d..85da0192a 100644
--- a/Templates/BaseGame/game/data/UI/guis/JoinServerMenu.asset.taml
+++ b/Templates/BaseGame/game/data/UI/guis/JoinServerMenu.asset.taml
@@ -1,7 +1,5 @@
 <GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
     AssetName="JoinServerMenu"
-    scriptFile="@assetFile=joinServerMenu.gui"
+    scriptFile="@assetFile=joinServerMenu"
     GUIFile="@assetFile=joinServerMenu.gui"
-    VersionId="1" />
+    VersionId="1"/>
diff --git a/Templates/BaseGame/game/data/UI/guis/LoadingGui.asset.taml b/Templates/BaseGame/game/data/UI/guis/LoadingGui.asset.taml
index 196bc91e7..fc8ac974c 100644
--- a/Templates/BaseGame/game/data/UI/guis/LoadingGui.asset.taml
+++ b/Templates/BaseGame/game/data/UI/guis/LoadingGui.asset.taml
@@ -1,7 +1,4 @@
 <GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
     AssetName="LoadingGui"
-    scriptFile="@assetFile=loadingGui.gui"
     GUIFile="@assetFile=loadingGui.gui"
-    VersionId="1" />
+    VersionId="1"/>
diff --git a/Templates/BaseGame/game/data/UI/guis/MainMenuGui.asset.taml b/Templates/BaseGame/game/data/UI/guis/MainMenuGui.asset.taml
index 2fd6b7c72..cdd3c6635 100644
--- a/Templates/BaseGame/game/data/UI/guis/MainMenuGui.asset.taml
+++ b/Templates/BaseGame/game/data/UI/guis/MainMenuGui.asset.taml
@@ -1,7 +1,5 @@
 <GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
     AssetName="MainMenuGui"
-    scriptFile="@assetFile=mainMenu.gui"
+    scriptFile="@assetFile=mainMenu"
     GUIFile="@assetFile=mainMenu.gui"
-    VersionId="1" />
+    VersionId="1"/>
diff --git a/Templates/BaseGame/game/data/UI/guis/MessageBoxDlg.asset.taml b/Templates/BaseGame/game/data/UI/guis/MessageBoxDlg.asset.taml
index 9b9d38995..14ff4ba60 100644
--- a/Templates/BaseGame/game/data/UI/guis/MessageBoxDlg.asset.taml
+++ b/Templates/BaseGame/game/data/UI/guis/MessageBoxDlg.asset.taml
@@ -1,7 +1,4 @@
 <GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
     AssetName="MessageBoxDlg"
-    scriptFile="@assetFile=messageBoxDlg.gui"
     GUIFile="@assetFile=messageBoxDlg.gui"
-    VersionId="1" />
+    VersionId="1"/>
diff --git a/Templates/BaseGame/game/data/UI/guis/NetGraphProfile.asset.taml b/Templates/BaseGame/game/data/UI/guis/NetGraphProfile.asset.taml
deleted file mode 100644
index 2ee15e4ea..000000000
--- a/Templates/BaseGame/game/data/UI/guis/NetGraphProfile.asset.taml
+++ /dev/null
@@ -1,7 +0,0 @@
-<GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="NetGraphProfile"
-    scriptFile="@assetFile=netGraphGui.gui"
-    GUIFile="@assetFile=netGraphGui.gui"
-    VersionId="1" />
diff --git a/Templates/BaseGame/game/data/UI/guis/OptionsMenu.asset.taml b/Templates/BaseGame/game/data/UI/guis/OptionsMenu.asset.taml
index a00b4c7d4..0488ea976 100644
--- a/Templates/BaseGame/game/data/UI/guis/OptionsMenu.asset.taml
+++ b/Templates/BaseGame/game/data/UI/guis/OptionsMenu.asset.taml
@@ -1,7 +1,5 @@
 <GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
     AssetName="OptionsMenu"
-    scriptFile="@assetFile=optionsMenu.gui"
+    scriptFile="@assetFile=optionsMenu"
     GUIFile="@assetFile=optionsMenu.gui"
-    VersionId="1" />
+    VersionId="1"/>
diff --git a/Templates/BaseGame/game/data/UI/guis/PauseMenu.asset.taml b/Templates/BaseGame/game/data/UI/guis/PauseMenu.asset.taml
index c3806430a..08a16f03d 100644
--- a/Templates/BaseGame/game/data/UI/guis/PauseMenu.asset.taml
+++ b/Templates/BaseGame/game/data/UI/guis/PauseMenu.asset.taml
@@ -1,7 +1,5 @@
 <GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
     AssetName="PauseMenu"
-    scriptFile="@assetFile=pauseMenu.gui"
+    scriptFile="@assetFile=pauseMenu"
     GUIFile="@assetFile=pauseMenu.gui"
-    VersionId="1" />
+    VersionId="1"/>
diff --git a/Templates/BaseGame/game/data/UI/guis/ProfilerGui.asset.taml b/Templates/BaseGame/game/data/UI/guis/ProfilerGui.asset.taml
index 0e49346ab..09b400893 100644
--- a/Templates/BaseGame/game/data/UI/guis/ProfilerGui.asset.taml
+++ b/Templates/BaseGame/game/data/UI/guis/ProfilerGui.asset.taml
@@ -1,7 +1,5 @@
 <GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
     AssetName="ProfilerGui"
-    scriptFile="@assetFile=profiler.gui"
+    scriptFile="@assetFile=profiler"
     GUIFile="@assetFile=profiler.gui"
-    VersionId="1" />
+    VersionId="1"/>
diff --git a/Templates/BaseGame/game/data/UI/guis/RemapConfirmDlg.asset.taml b/Templates/BaseGame/game/data/UI/guis/RemapConfirmDlg.asset.taml
index 1e3fb30aa..6fc8c874a 100644
--- a/Templates/BaseGame/game/data/UI/guis/RemapConfirmDlg.asset.taml
+++ b/Templates/BaseGame/game/data/UI/guis/RemapConfirmDlg.asset.taml
@@ -1,7 +1,4 @@
 <GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
     AssetName="RemapConfirmDlg"
-    scriptFile="@assetFile=remapConfirmDlg.gui"
     GUIFile="@assetFile=remapConfirmDlg.gui"
-    VersionId="1" />
+    VersionId="1"/>
diff --git a/Templates/BaseGame/game/data/UI/guis/RemapDlg.asset.taml b/Templates/BaseGame/game/data/UI/guis/RemapDlg.asset.taml
index 6b1c4df9a..7ea99e19c 100644
--- a/Templates/BaseGame/game/data/UI/guis/RemapDlg.asset.taml
+++ b/Templates/BaseGame/game/data/UI/guis/RemapDlg.asset.taml
@@ -1,7 +1,4 @@
 <GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
     AssetName="RemapDlg"
-    scriptFile="@assetFile=remapDlg.gui"
     GUIFile="@assetFile=remapDlg.gui"
-    VersionId="1" />
+    VersionId="1"/>
diff --git a/Templates/BaseGame/game/data/UI/guis/StartupGui.asset.taml b/Templates/BaseGame/game/data/UI/guis/StartupGui.asset.taml
index 656157f71..876b039a6 100644
--- a/Templates/BaseGame/game/data/UI/guis/StartupGui.asset.taml
+++ b/Templates/BaseGame/game/data/UI/guis/StartupGui.asset.taml
@@ -1,7 +1,5 @@
 <GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
     AssetName="StartupGui"
-    scriptFile="@assetFile=startupGui.gui"
+    scriptFile="@assetFile=startupGui"
     GUIFile="@assetFile=startupGui.gui"
-    VersionId="1" />
+    VersionId="1"/>
diff --git a/Templates/BaseGame/game/data/UI/guis/chooseLevelDlg.gui b/Templates/BaseGame/game/data/UI/guis/chooseLevelDlg.gui
index fc2ffc57e..775e910f0 100644
--- a/Templates/BaseGame/game/data/UI/guis/chooseLevelDlg.gui
+++ b/Templates/BaseGame/game/data/UI/guis/chooseLevelDlg.gui
@@ -36,7 +36,7 @@ $guiContent = new GuiControl(ChooseLevelDlg) {
          percent = "100";
          vertical = "0";
          flipClip = "0";
-         bitmap = "data/ui/images/panel.png";
+         bitmapAsset = "UI:panel_image";
          color = "255 255 255 255";
          position = "0 0";
          extent = "927 40";
@@ -79,7 +79,7 @@ $guiContent = new GuiControl(ChooseLevelDlg) {
          percent = "100";
          vertical = "0";
          flipClip = "0";
-         bitmap = "data/ui/images/panel_low.png";
+         bitmapAsset = "UI:panel_low_image";
          color = "255 255 255 255";
          position = "0 40";
          extent = "927 618";
diff --git a/Templates/BaseGame/game/data/UI/guis/controlsMenuSetting.taml b/Templates/BaseGame/game/data/UI/guis/controlsMenuSetting.taml
deleted file mode 100644
index e2794ca4a..000000000
--- a/Templates/BaseGame/game/data/UI/guis/controlsMenuSetting.taml
+++ /dev/null
@@ -1,102 +0,0 @@
-<GuiContainer
-    margin="0 0 0 0"
-    padding="0 0 0 0"
-    anchorTop="true"
-    anchorBottom="false"
-    anchorLeft="true"
-    anchorRight="false"
-    position="0 0"
-    extent="700 35"
-    minExtent="8 2"
-    horizSizing="right"
-    vertSizing="bottom"
-    profile="GuiDefaultProfile"
-    visible="true"
-    active="true"
-    tooltipProfile="GuiToolTipProfile"
-    hovertime="1000"
-    isContainer="true"
-    class="GraphicsMenuSetting"
-    canSave="true"
-    canSaveDynamicFields="false">
-    <GuiBitmapCtrl
-        bitmap="data/ui/images/hudfill.png"
-        wrap="false"
-        position="0 0"
-        extent="550 35"
-        minExtent="8 2"
-        horizSizing="right"
-        vertSizing="bottom"
-        profile="GuiDefaultProfile"
-        visible="true"
-        active="true"
-        tooltipProfile="GuiToolTipProfile"
-        hovertime="1000"
-        isContainer="false"
-        canSave="true"
-        canSaveDynamicFields="false" />
-    <GuiTextCtrl
-        text="Move Forward"
-        maxLength="1024"
-        margin="0 0 0 0"
-        padding="0 0 0 0"
-        anchorTop="true"
-        anchorBottom="false"
-        anchorLeft="true"
-        anchorRight="false"
-        position="0 0"
-        extent="550 35"
-        minExtent="8 2"
-        horizSizing="right"
-        vertSizing="bottom"
-        profile="GuiMenuButtonProfile"
-        visible="true"
-        active="true"
-        tooltipProfile="GuiToolTipProfile"
-        hovertime="1000"
-        isContainer="true"
-        internalName="nameText"
-        canSave="true"
-        canSaveDynamicFields="false" />
-    <GuiContainer
-        margin="0 0 0 0"
-        padding="0 0 0 0"
-        anchorTop="true"
-        anchorBottom="false"
-        anchorLeft="true"
-        anchorRight="false"
-        position="550 0"
-        extent="150 35"
-        minExtent="8 2"
-        horizSizing="right"
-        vertSizing="bottom"
-        profile="GuiDefaultProfile"
-        visible="true"
-        active="true"
-        tooltipProfile="GuiToolTipProfile"
-        hovertime="1000"
-        isContainer="true"
-        canSave="true"
-        canSaveDynamicFields="false">
-        <GuiButtonCtrl
-            text="W"
-            groupNum="-1"
-            buttonType="PushButton"
-            useMouseEvents="true"
-            position="0 0"
-            extent="150 35"
-            minExtent="8 8"
-            horizSizing="relative"
-            vertSizing="bottom"
-            profile="GuiMenuButtonProfile"
-            visible="true"
-            active="true"
-            tooltipProfile="GuiToolTipProfile"
-            hovertime="1000"
-            isContainer="false"
-            canSave="true"
-            canSaveDynamicFields="false"
-            internalName="rebindButton"
-            className="ControlsMenuRebindButton"/>
-    </GuiContainer>
-</GuiContainer>
diff --git a/Templates/BaseGame/game/data/UI/guis/joinServerMenu.gui b/Templates/BaseGame/game/data/UI/guis/joinServerMenu.gui
index 17a2c4435..c812e624c 100644
--- a/Templates/BaseGame/game/data/UI/guis/joinServerMenu.gui
+++ b/Templates/BaseGame/game/data/UI/guis/joinServerMenu.gui
@@ -425,7 +425,7 @@ $guiContent = new GuiControl(JoinServerMenu) {
          vertSizing = "bottom";
          profile = "GuiMenuButtonProfile";
          visible = "1";
-         active = "1";
+         active = "0";
          command = "JoinServerMenu.join();";
          tooltipProfile = "GuiToolTipProfile";
          hovertime = "1000";
diff --git a/Templates/BaseGame/game/data/UI/guis/joinServerMenu.tscript b/Templates/BaseGame/game/data/UI/guis/joinServerMenu.tscript
index b2f0eb8eb..1fe75bd46 100644
--- a/Templates/BaseGame/game/data/UI/guis/joinServerMenu.tscript
+++ b/Templates/BaseGame/game/data/UI/guis/joinServerMenu.tscript
@@ -1,10 +1,6 @@
 
-function JoinServerMenu::onWake()
+function JoinServerMenu::onWake(%this)
 {
-   // Double check the status. Tried setting this the control
-   // inactive to start with, but that didn't seem to work.
-   JoinServerJoinBtn.setActive(JoinServerList.getCount() > 0);
-   
    JoinServerButtonHolder.setActive();
    
    JoinServerList.setAsActiveMenuList();
@@ -128,7 +124,7 @@ function JoinServerMenu::update(%this)
       JoinServerList.add(%serverBtn);
    }
 
-   JoinServerJoinBtn.setActive(JoinServerList.getCount() > 0);
+   JoinServerButtonHolder-->joinButton.setActive(JoinServerList.getCount() > 0);
 } 
 
 //----------------------------------------
diff --git a/Templates/BaseGame/game/data/UI/guis/mainMenu.gui b/Templates/BaseGame/game/data/UI/guis/mainMenu.gui
index 4c6c13697..6b1dad9ee 100644
--- a/Templates/BaseGame/game/data/UI/guis/mainMenu.gui
+++ b/Templates/BaseGame/game/data/UI/guis/mainMenu.gui
@@ -1,6 +1,6 @@
 //--- OBJECT WRITE BEGIN ---
 $guiContent = new GuiChunkedBitmapCtrl(MainMenuGui) {
-   BitmapAsset = "UI:background_dark_image";
+   BitmapAsset = "UI:backgrounddark_image";
    useVariable = "0";
    tile = "0";
    position = "0 0";
@@ -203,7 +203,7 @@ $guiContent = new GuiChunkedBitmapCtrl(MainMenuGui) {
          profile = "GuiMenuButtonProfile";
          visible = "1";
          active = "1";
-         command = "exit();";
+         command = "quit();";
          tooltipProfile = "GuiToolTipProfile";
          hovertime = "1000";
          isContainer = "0";
diff --git a/Templates/BaseGame/game/data/UI/guis/mainMenu.tscript b/Templates/BaseGame/game/data/UI/guis/mainMenu.tscript
index 0d830f176..c626c4952 100644
--- a/Templates/BaseGame/game/data/UI/guis/mainMenu.tscript
+++ b/Templates/BaseGame/game/data/UI/guis/mainMenu.tscript
@@ -66,4 +66,5 @@ function MainMenuGui::onReturnTo(%this)
    MainMenuButtonList.hidden = false;
    MainMenuButtonList.setFirstResponder();
    MainMenuButtonHolder.setActive();
-}
\ No newline at end of file
+   MainMenuButtonList.setAsActiveMenuList();
+}
diff --git a/Templates/BaseGame/game/data/UI/guis/messageBoxDlg.gui b/Templates/BaseGame/game/data/UI/guis/messageBoxDlg.gui
index a78ae98d5..91207adff 100644
--- a/Templates/BaseGame/game/data/UI/guis/messageBoxDlg.gui
+++ b/Templates/BaseGame/game/data/UI/guis/messageBoxDlg.gui
@@ -34,7 +34,7 @@ $guiContent = new GuiControl(MessageBoxDlg) {
          percent = "100";
          vertical = "0";
          flipClip = "0";
-         bitmap = "data/ui/images/panel.png";
+         bitmapAsset = "UI:panel_image";
          color = "255 255 255 255";
          position = "0 0";
          extent = "641 40";
@@ -77,7 +77,7 @@ $guiContent = new GuiControl(MessageBoxDlg) {
          percent = "100";
          vertical = "0";
          flipClip = "0";
-         bitmap = "data/ui/images/panel_low.png";
+         bitmapAsset = "UI:panel_low_image";
          color = "255 255 255 255";
          position = "0 40";
          extent = "641 341";
diff --git a/Templates/BaseGame/game/data/UI/guis/netGraphGui.gui b/Templates/BaseGame/game/data/UI/guis/netGraphGui.gui
index be8ba1233..9da782ba7 100644
--- a/Templates/BaseGame/game/data/UI/guis/netGraphGui.gui
+++ b/Templates/BaseGame/game/data/UI/guis/netGraphGui.gui
@@ -554,4 +554,4 @@ function NetGraph::updateNetworkSimulation(%this)
    }
    
    netSimulateLag( %latency, %packetLoss );
-}
\ No newline at end of file
+}
diff --git a/Templates/BaseGame/game/data/UI/guis/optionsMenu.gui b/Templates/BaseGame/game/data/UI/guis/optionsMenu.gui
index b7195557c..a8fc2fb1e 100644
--- a/Templates/BaseGame/game/data/UI/guis/optionsMenu.gui
+++ b/Templates/BaseGame/game/data/UI/guis/optionsMenu.gui
@@ -213,127 +213,6 @@ $guiContent = new GuiControl(OptionsMenu) {
                class = "MenuList";
                canSave = "1";
                canSaveDynamicFields = "0";
-
-               new GuiButtonCtrl(OptionsMenuDisplayBtn) {
-                  text = "Display";
-                  groupNum = "-1";
-                  buttonType = "PushButton";
-                  useMouseEvents = "0";
-                  position = "0 0";
-                  extent = "248 35";
-                  minExtent = "8 2";
-                  horizSizing = "right";
-                  vertSizing = "bottom";
-                  profile = "GuiMenuButtonProfile";
-                  visible = "1";
-                  active = "1";
-                  command = "populateDisplaySettingsList();";
-                  tooltipProfile = "GuiToolTipProfile";
-                  hovertime = "1000";
-                  isContainer = "0";
-                  canSave = "1";
-                  canSaveDynamicFields = "0";
-               };
-               new GuiButtonCtrl(OptionsMenuGraphicsBtn) {
-                  text = "Graphics";
-                  groupNum = "-1";
-                  buttonType = "PushButton";
-                  useMouseEvents = "0";
-                  position = "0 45";
-                  extent = "248 35";
-                  minExtent = "8 2";
-                  horizSizing = "right";
-                  vertSizing = "bottom";
-                  profile = "GuiMenuButtonProfile";
-                  visible = "1";
-                  active = "1";
-                  command = "populateGraphicsSettingsList();";
-                  tooltipProfile = "GuiToolTipProfile";
-                  hovertime = "1000";
-                  isContainer = "0";
-                  canSave = "1";
-                  canSaveDynamicFields = "0";
-               };
-               new GuiButtonCtrl(OptionsMenuAudioBtn) {
-                  text = "Audio";
-                  groupNum = "-1";
-                  buttonType = "PushButton";
-                  useMouseEvents = "0";
-                  position = "0 90";
-                  extent = "248 35";
-                  minExtent = "8 2";
-                  horizSizing = "right";
-                  vertSizing = "bottom";
-                  profile = "GuiMenuButtonProfile";
-                  visible = "1";
-                  active = "1";
-                  command = "populateAudioSettingsList();";
-                  tooltipProfile = "GuiToolTipProfile";
-                  hovertime = "1000";
-                  isContainer = "0";
-                  canSave = "1";
-                  canSaveDynamicFields = "0";
-               };
-               new GuiButtonCtrl(OptionsMenuKBMBtn) {
-                  text = "Keyboard & Mouse";
-                  groupNum = "-1";
-                  buttonType = "PushButton";
-                  useMouseEvents = "0";
-                  position = "0 135";
-                  extent = "248 35";
-                  minExtent = "8 2";
-                  horizSizing = "right";
-                  vertSizing = "bottom";
-                  profile = "GuiMenuButtonProfile";
-                  visible = "1";
-                  active = "1";
-                  command = "populateKeyboardMouseSettingsList();";
-                  tooltipProfile = "GuiToolTipProfile";
-                  hovertime = "1000";
-                  isContainer = "0";
-                  canSave = "1";
-                  canSaveDynamicFields = "0";
-               };
-               new GuiButtonCtrl(OptionsMenuGamepadBtn) {
-                  text = "Gamepad";
-                  groupNum = "-1";
-                  buttonType = "PushButton";
-                  useMouseEvents = "0";
-                  position = "0 180";
-                  extent = "248 35";
-                  minExtent = "8 2";
-                  horizSizing = "right";
-                  vertSizing = "bottom";
-                  profile = "GuiMenuButtonProfile";
-                  visible = "1";
-                  active = "1";
-                  command = "populateGamepadSettingsList();";
-                  tooltipProfile = "GuiToolTipProfile";
-                  hovertime = "1000";
-                  isContainer = "0";
-                  canSave = "1";
-                  canSaveDynamicFields = "0";
-               };
-               new GuiButtonCtrl(OptionsMenuProfileBtn) {
-                  text = "Profile";
-                  groupNum = "-1";
-                  buttonType = "PushButton";
-                  useMouseEvents = "0";
-                  position = "0 225";
-                  extent = "248 35";
-                  minExtent = "8 2";
-                  horizSizing = "right";
-                  vertSizing = "bottom";
-                  profile = "GuiMenuButtonProfile";
-                  visible = "1";
-                  active = "1";
-                  command = "populateProfileSettingsList();";
-                  tooltipProfile = "GuiToolTipProfile";
-                  hovertime = "1000";
-                  isContainer = "0";
-                  canSave = "1";
-                  canSaveDynamicFields = "0";
-               };
             };
          };
          new GuiPanel() {
@@ -493,68 +372,6 @@ $guiContent = new GuiControl(OptionsMenu) {
          canSave = "1";
          canSaveDynamicFields = "0";
       };
-      new GuiIconButtonCtrl() {
-         buttonMargin = "4 4";
-         BitmapAsset = "UI:Switch_LB_image";
-         iconLocation = "Left";
-         sizeIconToButton = "1";
-         makeIconSquare = "1";
-         textLocation = "Right";
-         textMargin = "4";
-         autoSize = "0";
-         text = "Prev Tab";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "0 0";
-         extent = "140 40";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "0";
-         active = "0";
-         command = "OptionsMenu.prevTab();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "prevTabButton";
-         class = "MenuInputButton";
-         hidden = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiIconButtonCtrl() {
-         buttonMargin = "4 4";
-         BitmapAsset = "UI:Switch_RB_image";
-         iconLocation = "Left";
-         sizeIconToButton = "1";
-         makeIconSquare = "1";
-         textLocation = "Right";
-         textMargin = "4";
-         autoSize = "0";
-         text = "Next Tab";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "144 0";
-         extent = "140 40";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "0";
-         active = "0";
-         command = "OptionsMenu.nextTab();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "nextTabButton";
-         class = "MenuInputButton";
-         hidden = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
       new GuiIconButtonCtrl() {
          buttonMargin = "4 4";
          BitmapAsset = "UI:Keyboard_Black_R_image";
diff --git a/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript b/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
index eac532203..48612b943 100644
--- a/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
+++ b/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
@@ -46,12 +46,67 @@
 //headbob
 //FOV
 
+function OptionsMenu::onAdd(%this)
+{
+   if(!isObject(%this.optionsCategories))
+   {
+      %this.optionsCategories = new ArrayObject();
+   }  
+   
+   if(!isObject(%this.unappliedChanges))
+   {
+      %this.unappliedChanges = new ArrayObject();
+   }  
+   
+   addOptionsMenuCategory("Display", "populateDisplaySettingsList();");
+   addOptionsMenuCategory("Graphics", "populateGraphicsSettingsList();");
+   addOptionsMenuCategory("Audio", "populateAudioSettingsList();");
+   addOptionsMenuCategory("Keyboard & Mouse", "populateKeyboardMouseSettingsList();");
+   addOptionsMenuCategory("Gamepad", "populateGamepadSettingsList();");
+}
+
 function OptionsMenuSettingsList::onAdd(%this)
 {
 }
 
+function OptionsMenuSettingsList::getOptionsList(%this, %index)
+{
+     
+}
+
 function OptionsMenu::onWake(%this)
 {
+   for(%i=0; %i < %this.optionsCategories.count(); %i++)
+   {
+      %catName = %this.optionsCategories.getKey(%i);
+      %callback = %this.optionsCategories.getValue(%i);
+      
+      %newCatButton = new GuiButtonCtrl() {
+         text = %catName;
+         groupNum = "-1";
+         buttonType = "PushButton";
+         useMouseEvents = "0";
+         position = "0 180";
+         extent = "248 35";
+         minExtent = "8 2";
+         horizSizing = "right";
+         vertSizing = "bottom";
+         profile = "GuiMenuButtonProfile";
+         visible = "1";
+         active = "1";
+         command = %callback;
+         tooltipProfile = "GuiToolTipProfile";
+         hovertime = "1000";
+         isContainer = "0";
+         canSave = "1";
+         canSaveDynamicFields = "0";
+      };
+      
+      OptionsMenuCategoryList.add(%newCatButton);
+   }
+   
+   %this.unappliedChanges.empty();
+   
    MainMenuButtonList.hidden = true;
    
    OptionsMenuCategoryList.setAsActiveMenuList();
@@ -63,8 +118,6 @@ function OptionsMenu::onWake(%this)
 
 function OptionsButtonHolder::onWake(%this)
 {
-   //%this-->prevTabButton.set("btn_l", "", "Prev Tab", "OptionsMenu.prevTab();", true);
-   %this-->nextTabButton.set("btn_a", "", "Select", "OptionsMenuList.activate();", true);
    %this-->resetButton.set("btn_back", "R", "Reset", "OptionsMenu.resetToDefaults();");
    %this-->applyButton.set("btn_start", "Return", "Apply", "OptionsMenu.apply();");
    %this-->backButton.set("btn_b", "Escape", "Back", "OptionsMenu.backOut();");
@@ -74,19 +127,81 @@ function OptionsButtonHolder::onWake(%this)
 
 function OptionsMenu::apply(%this)
 {
-   if(%this.pageTabIndex == 0)
+   //Now we run through our list of unapplied changes and... apply them.
+   %hasKeybindChanges = false;
+   %hasVideoChanges = false;
+   %hasPostFXChanges = false;
+   %hasAudioChanges = false;
+   for(%i=0; %i < %this.unappliedChanges.count(); %i++)
    {
-      %this.applyDisplaySettings();
+      %targetVar = %this.unappliedChanges.getKey(%i);
+      %newValue = %this.unappliedChanges.getValue(%i);
+      
+      //First, lets just check through our action map names, see if any match
+      %wasKeybind = false;
+      for(%am=0; %am < ActionMapGroup.getCount(); %am++)
+      {
+         %actionMap = ActionMapGroup.getObject(%am);
+   
+         if(%actionMap == GlobalActionMap.getId())
+            continue;
+         
+         %actionMapName = %actionMap.humanReadableName $= "" ? %actionMap.getName() : %actionMap.humanReadableName;
+         if(%actionMapName $= %targetVar)
+         {
+            %hasKeybindChanges = true;
+            %wasKeybind = true;
+            break;
+         }
+      }
+      
+      if(!%wasKeybind)
+      {
+         %currentValue = getVariable(%targetVar);
+         if(%currentValue !$= %newValue)
+         {
+            setVariable(%targetVar, %newValue);
+            
+            //now, lets check for special cases that need additional handling
+            //for updates
+            if ( %targetVar $= "$pref::Video::displayDevice" )
+            {
+               MessageBoxOK( "Change requires restart", "Please restart the game for a display device change to take effect." );
+            }
+            else if(startsWith(%targetVar, "$pref::Graphics::"))
+            {
+               //isolate the quality group name, like $pref::Graphics::LightingQuality
+               //we grab LightingQuality
+               %qualityGroupName = getSubStr(%targetVar, 17);
+               if(isObject(%qualityGroupName @ "List"))
+               {
+                  //yep, it's a quality group, so apply it 
+                  (%qualityGroupName @ "List").applySetting(%newValue); 
+               }
+               
+               if(%qualityGroupName $= "TextureQuality")
+               {
+                  reloadTextures();  
+               }
+            }
+            else if(startsWith(%targetVar, "$pref::PostFX::"))
+            {
+               %hasPostFXChanges = true;
+            }
+            else if(startsWith(%targetVar, "$pref::Video::"))
+            {
+               %hasVideoChanges = true;
+            }
+            else if(startsWith(%targetVar, "$pref::SFX::"))
+            {
+               %hasAudioChanges = true;
+            }
+         }
+      }
    }
-   else if(%this.pageTabIndex == 1)
-   {
-      %this.applyGraphicsSettings(); 
-   }
-   else if(%this.pageTabIndex == 2)
-   {
-      %this.applyAudioSettings();
-   }
-   else if(%this.pageTabIndex == 3 || %this.pageTabIndex == 4)
+   
+   //If we had keybind changes, go ahead and save those out
+   if(%hasKeybindChanges)
    {
       %prefPath = getPrefpath();
       
@@ -108,8 +223,26 @@ function OptionsMenu::apply(%this)
       }
    }
    
+   if(%hasPostFXChanges)
+   {
+      updatePostFXSettings();  
+   }
+   
+   if(%hasVideoChanges)
+   {
+      updateDisplaySettings();
+   }
+   
+   if(%hasAudioChanges)
+   {
+      updateAudioSettings();
+   }
+   
+   //Finally, write our prefs to file
    %prefPath = getPrefpath();
    export("$pref::*", %prefPath @ "/clientPrefs." @ $TorqueScriptFileExtension, false);
+   
+   OptionsMenu.unappliedChanges.empty();
 }
 
 function OptionsMenu::resetToDefaults(%this)
@@ -117,77 +250,9 @@ function OptionsMenu::resetToDefaults(%this)
    MessageBoxOKCancel("", "This will set the graphical settings back to the auto-detected defaults. Do you wish to continue?", "AutodetectGraphics();", "");
 }
 
-function OptionsMenuSettingsList::onChange(%this)
-{
-   %optionName = %this.getRowLabel(%this.getSelectedRow());
-   %tooltipText = %this.getTooltip(%this.getSelectedRow());
-   
-   OptionName.setText(%optionName);
-   OptionDescription.setText(%tooltipText);
-   return;
-   
-   OptionsMenuSettingsList.clearOptions();
-
-   %currentRowText = %this.getRowLabel(%this.getSelectedRow());
-   
-   if(%currentRowText $= "Display")
-   {
-      populateDisplaySettingsList();
-   }
-   else if(%currentRowText $= "Graphics")
-   {
-      populateGraphicsSettingsList();
-   }
-   else if(%currentRowText $= "Audio")
-   {
-      populateAudioSettingsList();
-   }
-   else if(%currentRowText $= "Keyboard + Mouse")
-   {
-      populateKeyboardMouseSettingsList();
-   }
-   else if(%currentRowText $= "Gamepad")
-   {
-      populateGamepadSettingsList();
-   }
-}
-
-function OptionsMenu::prevTab(%this)
-{
-   %this.pageTabIndex--;
-   if(%this.pageTabIndex < 0)
-      %this.pageTabIndex = 4;
-      
-   %tabBtn = %this.getTab();
-   %tabBtn.performClick();
-}
-
-function OptionsMenu::nextTab(%this)
-{
-   %this.pageTabIndex++;
-   if(%this.pageTabIndex > 4)
-      %this.pageTabIndex = 0;
-      
-   %tabBtn = %this.getTab();
-   %tabBtn.performClick();
-}
-
-function OptionsMenu::getTab(%this)
-{
-   if(%this.pageTabIndex == 0)
-      return %this-->DisplayButton;
-   else if(%this.pageTabIndex == 1)
-      return %this-->GraphicsButton;
-   else if(%this.pageTabIndex == 2)
-      return %this-->AudioButton;
-   else if(%this.pageTabIndex == 3)
-      return %this-->KBMButton;
-   else if(%this.pageTabIndex == 4)
-      return %this-->GamepadButton;
-   else 
-      return %this-->DisplayButton;
-}
-
+//
+//
+//
 function populateDisplaySettingsList()
 {
    OptionsMenuSettingsList.clear();
@@ -220,7 +285,7 @@ function populateDisplaySettingsList()
    
    trim(%apiList);
    
-   OptionsMenuSettingsList.addOptionRow("Display API", %apiList, false, "",  true, "The display API used for rendering.", %displayDevice);
+   OptionsMenuSettingsList.addOptionRow("Display API", "$pref::Video::DisplayAPI", %apiList, false, "",  true, "The display API used for rendering.", %displayDevice);
    
    %numDevices = Canvas.getMonitorCount();
    %devicesList = "";
@@ -234,7 +299,7 @@ function populateDisplaySettingsList()
    }
    
    %selectedDevice = getField(%devicesList, $pref::Video::deviceId);
-   OptionsMenuSettingsList.addOptionRow("Display Device", %devicesList, false, "onDisplayModeChange",  true, "The display devices the window should be on.", %selectedDevice);
+   OptionsMenuSettingsList.addOptionRow("Display Device", "$pref::Video::deviceId", %devicesList, false, "", true, "The display devices the window should be on.", %selectedDevice);
       
    if (%numDevices > 1)
       OptionsMenuSettingsList.setRowEnabled(1, true);
@@ -242,10 +307,10 @@ function populateDisplaySettingsList()
       OptionsMenuSettingsList.setRowEnabled(1, false);
    
    %mode = getField($Video::ModeTags, $pref::Video::deviceMode);
-   OptionsMenuSettingsList.addOptionRow("Window Mode", $Video::ModeTags, false, "onDisplayModeChange",  true, "", %mode);
+   OptionsMenuSettingsList.addOptionRow("Window Mode", "$pref::Video::deviceMode", $Video::ModeTags, false, "", true, "", %mode);
    
    %resolutionList = getScreenResolutionList($pref::Video::deviceId, $pref::Video::deviceMode);
-   OptionsMenuSettingsList.addOptionRow("Resolution", %resolutionList, false, "onDisplayResChange",  true, "Resolution of the game window", _makePrettyResString( $pref::Video::mode ));
+   OptionsMenuSettingsList.addOptionRow("Resolution", "$pref::Video::Resolution", %resolutionList, false, "onDisplayResChange",  true, "Resolution of the game window", _makePrettyResString( $pref::Video::mode ));
    
    //If they're doing borderless, the window resolution must match the display resolution
    if(%mode !$= "Borderless")
@@ -253,20 +318,20 @@ function populateDisplaySettingsList()
    else
       OptionsMenuSettingsList.setRowEnabled(3, false);
    
-   OptionsMenuSettingsList.addOptionRow("VSync", "No\tYes", false, "",  true, "", convertBoolToYesNo(!$pref::Video::disableVerticalSync));
+   OptionsMenuSettingsList.addOptionRow("VSync", "$pref::Video::disableVerticalSync", "No\tYes", false, "",  true, "", convertBoolToYesNo(!$pref::Video::disableVerticalSync));
 
 
    %refreshList = getScreenRefreshList($pref::Video::mode);
-   OptionsMenuSettingsList.addOptionRow("Refresh Rate", %refreshList, false, "",  true, "", $pref::Video::RefreshRate);
+   OptionsMenuSettingsList.addOptionRow("Refresh Rate", "$pref::Video::RefreshRate", %refreshList, false, "",  true, "", $pref::Video::RefreshRate);
    
    //move to gameplay tab
-   OptionsMenuSettingsList.addSliderRow("Field of View", 75, 5, "65 100", "");
+   OptionsMenuSettingsList.addSliderRow("Field of View", "", 75, 5, "65 100", "");
    
-   OptionsMenuSettingsList.addSliderRow("Brightness", 0.5, 0.1, "0 1", "");
-   OptionsMenuSettingsList.addSliderRow("Contrast", 0.5, 0.1, "0 1", "");
+   OptionsMenuSettingsList.addSliderRow("Brightness", "", 0.5, 0.1, "0 1", "");
+   OptionsMenuSettingsList.addSliderRow("Contrast", "", 0.5, 0.1, "0 1", "");
 }
 
-function OptionsMenu::applyDisplaySettings(%this)
+/*function OptionsMenu::applyDisplaySettings(%this)
 {
 	%newDevice = OptionsMenuSettingsList.getCurrentOption(0);
 							
@@ -285,9 +350,12 @@ function OptionsMenu::applyDisplaySettings(%this)
    echo("Exporting client prefs");
    %prefPath = getPrefpath();
    export("$pref::*", %prefPath @ "/clientPrefs." @ $TorqueScriptFileExtension, false);
-}
+}*/
 
-function populateGraphicsSettingsList(%this)
+//
+//
+//
+function populateGraphicsSettingsList()
 {
    OptionsMenuSettingsList.clear();
    
@@ -299,90 +367,32 @@ function populateGraphicsSettingsList(%this)
    %highMedLow = "Low\tMedium\tHigh";
    %anisoFilter = "Off\t4\t8\t16";
    %aaFilter = "Off\t1\t2\t4";
-   OptionsMenuSettingsList.addOptionRow("Lighting Quality", getQualityLevels(LightingQualityList), false, "",  true, "Amount and drawdistance of local lights", getCurrentQualityLevel(LightingQualityList));
-   OptionsMenuSettingsList.addOptionRow("Shadow Quality", getQualityLevels(ShadowQualityList), false, "",  true, "Shadow revolution quality", getCurrentQualityLevel(ShadowQualityList));
-   OptionsMenuSettingsList.addOptionRow("Soft Shadow Quality", getQualityLevels(SoftShadowList), false, "",  true, "Amount of softening applied to shadowmaps", getCurrentQualityLevel(SoftShadowList));
-   OptionsMenuSettingsList.addOptionRow("Mesh Quality", getQualityLevels(MeshQualityGroup), false, "",  true, "Fidelity of rendering of mesh objects", getCurrentQualityLevel(MeshQualityGroup));
-   OptionsMenuSettingsList.addOptionRow("Object Draw Distance", getQualityLevels(MeshDrawDistQualityGroup), false, "",  true, "Dictates if and when static objects fade out in the distance", getCurrentQualityLevel(MeshDrawDistQualityGroup));
-   OptionsMenuSettingsList.addOptionRow("Texture Quality", getQualityLevels(TextureQualityGroup), false, "",  true, "Fidelity of textures", getCurrentQualityLevel(TextureQualityGroup));
-   OptionsMenuSettingsList.addOptionRow("Terrain Quality", getQualityLevels(TerrainQualityGroup), false, "",  true, "Quality level of terrain objects", getCurrentQualityLevel(TerrainQualityGroup));
-   OptionsMenuSettingsList.addOptionRow("Decal Lifetime", getQualityLevels(DecalLifetimeGroup), false, "",  true, "How long decals are rendered", getCurrentQualityLevel(DecalLifetimeGroup));
-   OptionsMenuSettingsList.addOptionRow("Ground Cover Density", getQualityLevels(GroundCoverDensityGroup), false, "",  true, "Density of ground cover items, such as grass", getCurrentQualityLevel(GroundCoverDensityGroup));
-   OptionsMenuSettingsList.addOptionRow("Shader Quality", getQualityLevels(ShaderQualityGroup), false, "",  true, "Dictates the overall shader quality level, adjusting what features are enabled.", getCurrentQualityLevel(ShaderQualityGroup));
-   OptionsMenuSettingsList.addOptionRow("Anisotropic Filtering", %anisoFilter, false, "",  true, "Amount of Anisotropic Filtering on textures, which dictates their sharpness at a distance", $pref::Video::defaultAnisotropy);
-   OptionsMenuSettingsList.addOptionRow("Anti-Aliasing", %aaFilter, false, "",  true, "Amount of Post-Processing Anti-Aliasing applied to rendering", $pref::Video::AA);
-   OptionsMenuSettingsList.addOptionRow("Parallax", %onOffList, false, "",  true, "Whether the surface parallax shader effect is enabled", convertBoolToOnOff(!$pref::Video::disableParallaxMapping));
-   OptionsMenuSettingsList.addOptionRow("Water Reflections", %onOffList, false, "",  true, "Whether water reflections are enabled", convertBoolToOnOff(!$pref::Water::disableTrueReflections));
-   OptionsMenuSettingsList.addOptionRow("SSAO", %onOffList, false, "",  true, "Whether Screen-Space Ambient Occlusion is enabled", convertBoolToOnOff($pref::PostFX::EnableSSAO));
-   OptionsMenuSettingsList.addOptionRow("Depth of Field", %onOffList, false, "",  true, "Whether the Depth of Field effect is enabled", convertBoolToOnOff($pref::PostFX::EnableDOF));
-   OptionsMenuSettingsList.addOptionRow("Vignette", %onOffList, false, "",  true, "Whether the vignette effect is enabled", convertBoolToOnOff($pref::PostFX::EnableVignette));
-   OptionsMenuSettingsList.addOptionRow("Light Rays", %onOffList, false, "",  true, "Whether the light rays effect is enabled", convertBoolToOnOff($pref::PostFX::EnableLightRays));
+   OptionsMenuSettingsList.addOptionRow("Lighting Quality", "$pref::Graphics::LightingQuality", getQualityLevels(LightingQualityList), false, "",  true, "Amount and drawdistance of local lights", getCurrentQualityLevel(LightingQualityList));
+   OptionsMenuSettingsList.addOptionRow("Shadow Quality", "$pref::Graphics::ShadowQuality", getQualityLevels(ShadowQualityList), false, "",  true, "Shadow revolution quality", getCurrentQualityLevel(ShadowQualityList));
+   OptionsMenuSettingsList.addOptionRow("Soft Shadow Quality", "$pref::Graphics::SoftShadowQuality", getQualityLevels(SoftShadowList), false, "",  true, "Amount of softening applied to shadowmaps", getCurrentQualityLevel(SoftShadowList));
+   OptionsMenuSettingsList.addOptionRow("Mesh Quality", "$pref::Graphics::MeshQuality", getQualityLevels(MeshQualityGroup), false, "",  true, "Fidelity of rendering of mesh objects", getCurrentQualityLevel(MeshQualityGroup));
+   OptionsMenuSettingsList.addOptionRow("Object Draw Distance", "$pref::Graphics::ObjectDrawDistance", getQualityLevels(MeshDrawDistQualityGroup), false, "",  true, "Dictates if and when static objects fade out in the distance", getCurrentQualityLevel(MeshDrawDistQualityGroup));
+   OptionsMenuSettingsList.addOptionRow("Texture Quality", "$pref::Graphics::TextureQuality", getQualityLevels(TextureQualityGroup), false, "",  true, "Fidelity of textures", getCurrentQualityLevel(TextureQualityGroup));
+   OptionsMenuSettingsList.addOptionRow("Terrain Quality", "$pref::Graphics::TerrainQuality", getQualityLevels(TerrainQualityGroup), false, "",  true, "Quality level of terrain objects", getCurrentQualityLevel(TerrainQualityGroup));
+   OptionsMenuSettingsList.addOptionRow("Decal Lifetime", "$pref::Graphics::DecalLifetime", getQualityLevels(DecalLifetimeGroup), false, "",  true, "How long decals are rendered", getCurrentQualityLevel(DecalLifetimeGroup));
+   OptionsMenuSettingsList.addOptionRow("Ground Cover Density", "$pref::Graphics::GroundCoverDensity", getQualityLevels(GroundCoverDensityGroup), false, "",  true, "Density of ground cover items, such as grass", getCurrentQualityLevel(GroundCoverDensityGroup));
+   OptionsMenuSettingsList.addOptionRow("Shader Quality", "$pref::Graphics::ShaderQuality", getQualityLevels(ShaderQualityGroup), false, "",  true, "Dictates the overall shader quality level, adjusting what features are enabled.", getCurrentQualityLevel(ShaderQualityGroup));
+   OptionsMenuSettingsList.addOptionRow("Anisotropic Filtering", "$pref::Video::defaultAnisotropy", %anisoFilter, false, "",  true, "Amount of Anisotropic Filtering on textures, which dictates their sharpness at a distance", $pref::Video::defaultAnisotropy);
+   OptionsMenuSettingsList.addOptionRow("Anti-Aliasing", "$pref::Video::AA", %aaFilter, false, "",  true, "Amount of Post-Processing Anti-Aliasing applied to rendering", $pref::Video::AA);
+   OptionsMenuSettingsList.addOptionRow("Parallax", "$pref::Video::disableParallaxMapping", %onOffList, false, "",  true, "Whether the surface parallax shader effect is enabled", convertBoolToOnOff(!$pref::Video::disableParallaxMapping));
+   OptionsMenuSettingsList.addOptionRow("Water Reflections", "$pref::Water::disableTrueReflections", %onOffList, false, "",  true, "Whether water reflections are enabled", convertBoolToOnOff(!$pref::Water::disableTrueReflections));
+   OptionsMenuSettingsList.addOptionRow("SSAO", "$pref::PostFX::EnableSSAO", %onOffList, false, "",  true, "Whether Screen-Space Ambient Occlusion is enabled", convertBoolToOnOff($pref::PostFX::EnableSSAO));
+   OptionsMenuSettingsList.addOptionRow("Depth of Field", "$pref::PostFX::EnableDOF", %onOffList, false, "",  true, "Whether the Depth of Field effect is enabled", convertBoolToOnOff($pref::PostFX::EnableDOF));
+   OptionsMenuSettingsList.addOptionRow("Vignette", "$pref::PostFX::EnableVignette", %onOffList, false, "",  true, "Whether the vignette effect is enabled", convertBoolToOnOff($pref::PostFX::EnableVignette));
+   OptionsMenuSettingsList.addOptionRow("Light Rays", "$pref::PostFX::EnableLightRays", %onOffList, false, "",  true, "Whether the light rays effect is enabled", convertBoolToOnOff($pref::PostFX::EnableLightRays));
 }
 
-function OptionsMenu::applyGraphicsSettings(%this)
-{
-   LightingQualityList.applySetting(OptionsMenuSettingsList.getCurrentOption(0));
-   ShadowQualityList.applySetting(OptionsMenuSettingsList.getCurrentOption(1));
-   SoftShadowList.applySetting(OptionsMenuSettingsList.getCurrentOption(2));
-   
-   MeshQualityGroup.applySetting(OptionsMenuSettingsList.getCurrentOption(3));
-   MeshDrawDistQualityGroup.applySetting(OptionsMenuSettingsList.getCurrentOption(4));
-   TextureQualityGroup.applySetting(OptionsMenuSettingsList.getCurrentOption(5));
-   TerrainQualityGroup.applySetting(OptionsMenuSettingsList.getCurrentOption(6));
-   DecalLifetimeGroup.applySetting(OptionsMenuSettingsList.getCurrentOption(7));
-   GroundCoverDensityGroup.applySetting(OptionsMenuSettingsList.getCurrentOption(8));
-   ShaderQualityGroup.applySetting(OptionsMenuSettingsList.getCurrentOption(9));
-   
-   //Update Textures
-   reloadTextures();
-
-   //Update lighting
-   // Set the light manager.  This should do nothing 
-   // if its already set or if its not compatible.   
-   //setLightManager( $pref::lightManager );   
-   
-   $pref::PostFX::EnableSSAO = convertOptionToBool(OptionsMenuSettingsList.getCurrentOption(14));
-   $pref::PostFX::EnableDOF = convertOptionToBool(OptionsMenuSettingsList.getCurrentOption(15));
-   $pref::PostFX::EnableVignette = convertOptionToBool(OptionsMenuSettingsList.getCurrentOption(16));
-   $pref::PostFX::EnableLightRays = convertOptionToBool(OptionsMenuSettingsList.getCurrentOption(17));
-   
-   PostFXManager.settingsEffectSetEnabled(SSAOPostFx, $pref::PostFX::EnableSSAO);
-   PostFXManager.settingsEffectSetEnabled(DOFPostEffect, $pref::PostFX::EnableDOF);
-   PostFXManager.settingsEffectSetEnabled(LightRayPostFX, $pref::PostFX::EnableLightRays);
-   PostFXManager.settingsEffectSetEnabled(vignettePostFX, $pref::PostFX::EnableVignette);
-   
-   $pref::Video::disableParallaxMapping = !convertOptionToBool(OptionsMenuSettingsList.getCurrentOption(12));
-   
-   //water reflections
-   $pref::Water::disableTrueReflections = !convertOptionToBool(OptionsMenuSettingsList.getCurrentOption(13));
-   
-   // Check the anisotropic filtering.   
-   %level = OptionsMenuSettingsList.getCurrentOption(10);
-   if ( %level != $pref::Video::defaultAnisotropy )
-   {                     
-      $pref::Video::defaultAnisotropy = %level;
-   }
-
-   %newFSAA = OptionsMenuSettingsList.getCurrentOption(11);
-   if (%newFSAA $= "off")
-      %newFSAA = 0;
-   if (%newFSAA !$= $pref::Video::AA)
-   {
-      $pref::Video::AA = %newFSAA;
-      configureCanvas();
-   }
-
-   echo("Exporting client prefs");
-   %prefPath = getPrefpath();
-   export("$pref::*", %prefPath @ "/clientPrefs." @ $TorqueScriptFileExtension, false);
-}   
-
 function updateDisplaySettings()
 {
    //Update the display settings now
-   %deviceName = OptionsMenuSettingsList.getCurrentOption(1);
+   %deviceName = getDisplayDeviceName();
    %newDeviceID = getWord(%deviceName, 0) - 1;
-   %deviceModeName = OptionsMenuSettingsList.getCurrentOption(2);
+   %deviceModeName = getField($Video::ModeTags, $pref::Video::deviceMode);
    %newDeviceMode = 0;
    foreach$(%modeName in $Video::ModeTags)
    {
@@ -392,15 +402,15 @@ function updateDisplaySettings()
          %newDeviceMode++;
    }
 
-   %newRes = getWord(OptionsMenuSettingsList.getCurrentOption(3), 0) SPC getWord(OptionsMenuSettingsList.getCurrentOption(3), 2);
+   %newRes = $pref::Video::Resolution;
    %newBpp = 32; // ... its not 1997 anymore.
 	%newFullScreen = %deviceModeName $= "Fullscreen" ? true : false;
-	%newRefresh    = OptionsMenuSettingsList.getCurrentOption(5);
-	%newVsync = !convertOptionToBool(OptionsMenuSettingsList.getCurrentOption(4));	
+	%newRefresh    = $pref::Video::RefreshRate;
+	%newVsync = !$pref::Video::disableVerticalSync;	
 	%newFSAA = $pref::Video::AA;
 	
    // Build the final mode string.
-	%newMode = %newRes SPC %newFullScreen SPC %newBpp SPC %newRefresh SPC %newFSAA;
+	%newMode = $pref::Video::Resolution SPC %newFullScreen SPC %newBpp SPC %newRefresh SPC %newFSAA;
 	
    // Change the video mode.   
    if (  %newMode !$= $pref::Video::mode || %newDeviceID != $pref::Video::deviceId ||
@@ -433,7 +443,18 @@ function updateDisplaySettings()
    }
 }
 
-function populateAudioSettingsList(%this)
+function updatePostFXSettings()
+{
+   PostFXManager.settingsEffectSetEnabled(SSAOPostFx, $pref::PostFX::EnableSSAO);
+   PostFXManager.settingsEffectSetEnabled(DOFPostEffect, $pref::PostFX::EnableDOF);
+   PostFXManager.settingsEffectSetEnabled(LightRayPostFX, $pref::PostFX::EnableLightRays);
+   PostFXManager.settingsEffectSetEnabled(vignettePostFX, $pref::PostFX::EnableVignette);
+}
+
+//
+//
+//
+function populateAudioSettingsList()
 {
    OptionsMenuSettingsList.clear();
    
@@ -472,13 +493,13 @@ function populateAudioSettingsList(%this)
       }
    }
    
-   OptionsMenuSettingsList.addOptionRow("Audio Provider", %audioProviderList, false, "audioProviderChanged", true, "", $currentAudioProvider);
-   OptionsMenuSettingsList.addOptionRow("Audio Device", %audioDeviceList, false, "", true, $pref::SFX::device);
+   OptionsMenuSettingsList.addOptionRow("Audio Provider", "$pref::SFX::AudioProvider", %audioProviderList, false, "audioProviderChanged", true, "", $currentAudioProvider);
+   OptionsMenuSettingsList.addOptionRow("Audio Device", "$pref::SFX::device", %audioDeviceList, false, "", true, $pref::SFX::device);
    
-   OptionsMenuSettingsList.addSliderRow("Master Volume", $pref::SFX::masterVolume, 0.1, "0 1", "");
-   OptionsMenuSettingsList.addSliderRow("GUI Volume", $pref::SFX::channelVolume[ $GuiAudioType], 0.1, "0 1", "");
-   OptionsMenuSettingsList.addSliderRow("Effects Volume", $pref::SFX::channelVolume[ $SimAudioType ], 0.1, "0 1", "");
-   OptionsMenuSettingsList.addSliderRow("Music Volume", $pref::SFX::channelVolume[ $MusicAudioType ], 0.1, "0 1", "");
+   OptionsMenuSettingsList.addSliderRow("Master Volume", "$pref::SFX::masterVolume", $pref::SFX::masterVolume, 0.1, "0 1", "");
+   OptionsMenuSettingsList.addSliderRow("GUI Volume", "$pref::SFX::channelVolume[ $GuiAudioType]", $pref::SFX::channelVolume[ $GuiAudioType], 0.1, "0 1", "");
+   OptionsMenuSettingsList.addSliderRow("Effects Volume", "$pref::SFX::channelVolume[ $SimAudioType ]", $pref::SFX::channelVolume[ $SimAudioType ], 0.1, "0 1", "");
+   OptionsMenuSettingsList.addSliderRow("Music Volume", "$pref::SFX::channelVolume[ $MusicAudioType ]", $pref::SFX::channelVolume[ $MusicAudioType ], 0.1, "0 1", "");
 }
 
 function audioProviderChanged()
@@ -491,21 +512,21 @@ function audioProviderChanged()
    populateAudioSettingsList();
 }
 
-function OptionsMenu::applyAudioSettings(%this)
+function updateAudioSettings()
 {
-   $pref::SFX::masterVolume = OptionsMenuSettingsList.getValue(2);
+   //$pref::SFX::masterVolume = OptionsMenuSettingsList.getValue(2);
    sfxSetMasterVolume( $pref::SFX::masterVolume );
    
-   $pref::SFX::channelVolume[ $GuiAudioType ] = OptionsMenuSettingsList.getValue(3);
-   $pref::SFX::channelVolume[ $SimAudioType ] = OptionsMenuSettingsList.getValue(4);
-   $pref::SFX::channelVolume[ $MusicAudioType ] = OptionsMenuSettingsList.getValue(5);
+   //$pref::SFX::channelVolume[ $GuiAudioType ] = OptionsMenuSettingsList.getValue(3);
+   //$pref::SFX::channelVolume[ $SimAudioType ] = OptionsMenuSettingsList.getValue(4);
+   //$pref::SFX::channelVolume[ $MusicAudioType ] = OptionsMenuSettingsList.getValue(5);
    
    sfxSetChannelVolume( $GuiAudioType, $pref::SFX::channelVolume[ $GuiAudioType ] );
    sfxSetChannelVolume( $SimAudioType, $pref::SFX::channelVolume[ $SimAudioType ] );
    sfxSetChannelVolume( $MusicAudioType, $pref::SFX::channelVolume[ $MusicAudioType ] );
    
-   $pref::SFX::provider = OptionsMenuSettingsList.getCurrentOption(0);
-   $pref::SFX::device = OptionsMenuSettingsList.getCurrentOption(1);
+   //$pref::SFX::provider = OptionsMenuSettingsList.getCurrentOption(0);
+   //$pref::SFX::device = OptionsMenuSettingsList.getCurrentOption(1);
    
    if ( !sfxCreateDevice(  $pref::SFX::provider, 
                            $pref::SFX::device, 
@@ -521,7 +542,10 @@ function OptionsMenu::applyAudioSettings(%this)
    }
 }
 
-function populateKeyboardMouseSettingsList(%this)
+//
+//
+//
+function populateKeyboardMouseSettingsList()
 {
    OptionsMenuSettingsList.clear();
    
@@ -534,7 +558,7 @@ function populateKeyboardMouseSettingsList(%this)
    //OptionsMenuSettingsList.refresh();
 }
 
-function populateGamepadSettingsList(%this)
+function populateGamepadSettingsList()
 {
    OptionsMenuSettingsList.clear();
    
@@ -544,15 +568,30 @@ function populateGamepadSettingsList(%this)
    $remapListDevice = "gamepad";
    fillRemapList();
    
-   OptionsMenuSettingsList.refresh();
+   OptionsMenuSettingsList.updateStack();
 }
 
+//
+//
+//
 function OptionsMenuList::activateRow(%this)
 {
    OptionsMenuSettingsList.setFirstResponder();
 }
 
 function OptionsMenu::backOut(%this)
+{
+   if(%this.unappliedChanges.count() != 0)
+   {
+      MessageBoxOKCancel("Discard Changes?", "You have unapplied changes to your settings, do you wish to continue?", "OptionsMenu.doOptionsMenuBackOut();", "");
+   }
+   else
+   {
+      %this.doOptionsMenuBackOut();
+   }
+}
+
+function OptionsMenu::doOptionsMenuBackOut(%this)
 {
    //save the settings and then back out
    if(OptionsMain.hidden == false)
@@ -583,7 +622,7 @@ function OptionsMenuSettingsList::setRowEnabled(%this, %row, %status)
    }
 }
 
-function OptionsMenuSettingsList::addOptionRow(%this, %label, %optionsList, %wrapOptions, %callback, %enabled, %description, %defaultValue)
+function OptionsMenuSettingsList::addOptionRow(%this, %label, %targetPrefVar, %optionsList, %wrapOptions, %callback, %enabled, %description, %defaultValue)
 {
    if(%enabled $= "")
       %enabled = true;
@@ -600,14 +639,27 @@ function OptionsMenuSettingsList::addOptionRow(%this, %label, %optionsList, %wra
       extent = %this.extent.x SPC %optionsRowSize;
       columnSplit = %optionColumnWidth;
       useMouseEvents = true;
+      previousBitmapAsset = "UI:previousOption_n_image";
+      nextBitmapAsset = "UI:nextOption_n_image";
    };
    
+   %option.targetPrefVar = %targetPrefVar; //create a var-option association
+   
+   //now some override trickery, if we have a value cached for unapplied changes, swapsies the defaultValue out
+   //with the unapplied, allowing us to change options categories without losing changes
+   %unappliedPrefIndex = OptionsMenu.unappliedChanges.getIndexFromValue(%targetPrefVar);
+   if(%unappliedPrefIndex != -1)
+   {
+      %unappliedValue = OptionsMenu.unappliedChanges.getValue(%unappliedPrefIndex);
+      %defaultValue = %unappliedValue;
+   }
+   
    %option.setListSetting(%label, %optionsList, %wrapOptions, %callback, %enabled, %description, %defaultValue);
 
    %this.add(%option);
 }
 
-function OptionsMenuSettingsList::addSliderRow(%this, %label, %defaultValue, %increment, %range, %callback, %enabled, %description)
+function OptionsMenuSettingsList::addSliderRow(%this, %label, %targetPrefVar, %defaultValue, %increment, %range, %callback, %enabled, %description)
 {
    if(%enabled $= "")
       %enabled = true;
@@ -626,11 +678,46 @@ function OptionsMenuSettingsList::addSliderRow(%this, %label, %defaultValue, %in
       useMouseEvents = true;
    };
    
+   %option.targetPrefVar = %targetPrefVar; //create a var-option association
+   
+   //now some override trickery, if we have a value cached for unapplied changes, swapsies the defaultValue out
+   //with the unapplied, allowing us to change options categories without losing changes
+   %unappliedPrefIndex = OptionsMenu.unappliedChanges.getIndexFromValue(%targetPrefVar);
+   if(%unappliedPrefIndex != -1)
+   {
+      %unappliedValue = OptionsMenu.unappliedChanges.getValue(%unappliedPrefIndex);
+      %defaultValue = %unappliedValue;
+   }
+   
    %option.setSliderSetting(%label, %defaultValue, %increment, %range, %callback, %enabled, %description);
 
    %this.add(%option);
 }
 
+function OptionsMenuSettingsList::addKeybindRow(%this, %label, %bitmapName, %callback, %enabled, %description)
+{
+   if(%enabled $= "")
+      %enabled = true;
+      
+   %optionsRowSize = 40;
+   %optionColumnWidth = %this.extent.x - 450;
+      
+   %option = new GuiGameSettingsCtrl() { 
+      class = "MenuOptionsButton";
+      profile = "GuiMenuButtonProfile";
+      horizSizing = "width";
+      vertSizing = "bottom";
+      position = "0 0";
+      extent = %this.extent.x SPC %optionsRowSize;
+      columnSplit = %optionColumnWidth;
+      useMouseEvents = true;
+   };
+   
+   %option.setKeybindSetting(%label, %bitmapName, %callback, %enabled, %description);
+
+   %this.add(%option);
+}
+
 //
 function OptionsMenuCategoryList::onNavigate(%this, %index)
 {
@@ -738,6 +825,24 @@ function onDisplayResChange(%val)
    OptionsMenuSettingsList.selectOption(5, %newRate);
 }
 
+function getDisplayDeviceName()
+{
+   %numDevices = Canvas.getMonitorCount();
+   %devicesList = "";
+   for(%i = 0; %i < %numDevices; %i++)
+   {
+      %device = (%i+1) @ " - " @ Canvas.getMonitorName(%i);
+      if(%i==0)
+         %devicesList = %device;
+      else
+         %devicesList = %devicesList @ "\t" @ %device;
+   }
+   
+   return getField(%devicesList, $pref::Video::deviceId);  
+}
+//
+//
+//
 function MenuOptionsButton::onMouseEnter(%this)
 {
    OptionName.setText(%this.getLabel());
@@ -748,4 +853,84 @@ function MenuOptionsButton::onMouseLeave(%this)
 {
    OptionName.setText("");
    OptionDescription.setText("");
-}
\ No newline at end of file
+}
+
+function MenuOptionsButton::onChange(%this)
+{
+   %optionMode = %this.getMode();
+   %optionName = %this.getLabel();
+   %tooltipText = %this.getTooltip();
+   
+   %targetVar = %this.targetPrefVar;
+   
+   OptionName.setText(%optionName);
+   OptionDescription.setText(%tooltipText);
+   
+   %currentValue = %this.getCurrentOption();
+   if(%currentValue !$= "")
+   {
+      if(%currentValue $= "yes" || %currentValue $= "on")
+         %saveReadyValue = 1;
+      else if(%currentValue $= "no" || %currentValue $= "off")
+         %saveReadyValue = 0;
+      else 
+         %saveReadyValue = %currentValue;
+      
+      %prefIndex = OptionsMenu.unappliedChanges.getIndexFromKey(%targetVar);
+      if(%prefIndex == -1)
+         OptionsMenu.unappliedChanges.add(%targetVar, %saveReadyValue);
+      else
+         OptionsMenu.unappliedChanges.setValue(%saveReadyValue, %prefIndex);
+   }
+}
+
+function OptionsMenu::onKeybindChanged(%this, %actionMap, %keybind)
+{
+   %prefIndex = OptionsMenu.unappliedChanges.getIndexFromKey(%actionMap);
+   if(%prefIndex == -1)
+      OptionsMenu.unappliedChanges.add(%actionMap, %keybind);
+   else
+      OptionsMenu.unappliedChanges.setValue(%keybind, %prefIndex);
+}
+
+//
+// Indicates what category the options item should be added into
+//
+function addOptionsMenuCategory(%categoryName, %selectCallback)
+{
+   OptionsMenu.optionsCategories.add(%categoryName, %selectCallback);
+}
+
+function removeOptionsMenuCategory(%categoryName)
+{
+   %index = OptionsMenu.optionsCategories.getIndexFromKey(%categoryName);
+   if(%index != -1)
+      OptionsMenu.optionsCategories.erase(%index);
+}
+
+function addListOption(%label, %description, %targetPrefVar, %optionsList, %wrapOptions, %callback, %enabled)
+{
+   if(%wrapOptions $= "")
+      %wrapOptions = false;
+      
+   if(%enabled $= "")
+      %enabled = true;
+
+   OptionsMenuSettingsList.addOptionRow(%label, %targetPrefVar, %optionsList, %wrapOptions, %callback, %enabled, %description, %targetPrefVar);
+}
+
+function addSliderOption(%label, %description, %targetPrefVar, %defaultValue, %increment, %range, %callback, %enabled)
+{
+   if(%enabled $= "")
+      %enabled = true;
+
+   OptionsMenuSettingsList.addSliderRow(%label, %targetPrefVar, %defaultValue, %increment, %range, %callback, %enabled, %description);
+}
+
+function addKeybindOption(%label, %description, %bitmapName, %callback, %enabled)
+{
+   if(%enabled $= "")
+      %enabled = true;
+
+   OptionsMenuSettingsList.addSliderRow(%label, %bitmapName, %callback, %enabled, %description);
+}
diff --git a/Templates/BaseGame/game/data/UI/guis/pauseMenu.gui b/Templates/BaseGame/game/data/UI/guis/pauseMenu.gui
index 77356fcdb..0ba6e7ce5 100644
--- a/Templates/BaseGame/game/data/UI/guis/pauseMenu.gui
+++ b/Templates/BaseGame/game/data/UI/guis/pauseMenu.gui
@@ -49,25 +49,31 @@ $guiContent = new GuiControl(PauseMenu) {
       isContainer = "1";
       canSave = "1";
       canSaveDynamicFields = "0";
-
-      new GuiGameListMenuCtrl(PauseMenuList) {
-         debugRender = "0";
-         callbackOnInputs = "1";
-         consumeKeyInputEvents = "1";
+      
+      new GuiStackControl(PauseMenuList) {
+         stackingType = "Vertical";
+         horizStacking = "Left to Right";
+         vertStacking = "Top to Bottom";
+         padding = "15";
+         dynamicSize = "0";
+         dynamicNonStackExtent = "0";
+         dynamicPos = "0";
+         changeChildSizeToFit = "1";
+         changeChildPosition = "1";
          position = "0 0";
          extent = "700 320";
-         minExtent = "8 2";
-         horizSizing = "width";
-         vertSizing = "bottom";
-         profile = "DefaultListMenuProfile";
+         minExtent = "16 16";
+         horizSizing = "center";
+         vertSizing = "center";
+         profile = "GuiDefaultProfile";
          visible = "1";
          active = "1";
          tooltipProfile = "GuiToolTipProfile";
          hovertime = "1000";
-         isContainer = "0";
-         class = "UIMenuButtonList";
+         isContainer = "1";
          canSave = "1";
          canSaveDynamicFields = "0";
+         class = "MenuList";
       };
    };
    new GuiControl(PauseButtonHolder) {
@@ -147,5 +153,26 @@ $guiContent = new GuiControl(PauseMenu) {
          canSaveDynamicFields = "0";
       };
    };
+   new GuiInputCtrl(PauseMenuInputHandler) {
+      class = "MenuInputHandler";
+      sendAxisEvents = "1";
+      sendBreakEvents = "1";
+      sendModifierEvents = "0";
+      ignoreMouseEvents = "1";
+      lockMouse = "0";
+      position = "-50 0";
+      extent = "10 10";
+      minExtent = "8 2";
+      horizSizing = "width";
+      vertSizing = "height";
+      profile = "GuiInputCtrlProfile";
+      visible = "1";
+      active = "1";
+      tooltipProfile = "GuiToolTipProfile";
+      hovertime = "1000";
+      isContainer = "0";
+      canSave = "1";
+      canSaveDynamicFields = "0";
+   };
 };
 //--- OBJECT WRITE END ---
diff --git a/Templates/BaseGame/game/data/UI/guis/pauseMenu.tscript b/Templates/BaseGame/game/data/UI/guis/pauseMenu.tscript
index 8d23b95d2..8751c16ef 100644
--- a/Templates/BaseGame/game/data/UI/guis/pauseMenu.tscript
+++ b/Templates/BaseGame/game/data/UI/guis/pauseMenu.tscript
@@ -8,19 +8,21 @@ function PauseMenu::onWake(%this)
    }
    
    PauseMenuList.hidden = false;
-   PauseMenuList.setFirstResponder();
-   PauseButtonHolder.setActive();
    
-   PauseMenuList.clearRows();
+   PauseMenuList.clear();
    
    if($Tools::loaded && EditorIsActive())
    {
-      PauseMenuList.addRow("Exit Editor", "fastLoadWorldEdit", -1, -30); 
+      %this.addPauseMenuButton("Exit Editor", "fastLoadWorldEdit();"); 
    }
    
-   PauseMenuList.addRow("Options", "openPauseMenuOptions", -1, -30);
-   PauseMenuList.addRow("Exit to Menu", "pauseMenuExitToMenu", -1, -30);
-   PauseMenuList.addRow("Exit to Desktop", "pauseMenuExitToDesktop", -1, -30); 
+   %this.addPauseMenuButton("Options", "openPauseMenuOptions();");
+   %this.addPauseMenuButton("Exit to Menu", "pauseMenuExitToMenu();");
+   %this.addPauseMenuButton("Exit to Desktop", "pauseMenuExitToDesktop();"); 
+   
+   PauseMenuList.setAsActiveMenuList();
+   PauseButtonHolder.setActive();
+   PauseMenuInputHandler.setFirstResponder();
 }
 
 
@@ -36,8 +38,9 @@ function PauseMenu::onSleep(%this)
 function PauseMenu::onReturnTo(%this)
 {
    PauseMenuList.hidden = false;
-   PauseMenuList.setFirstResponder();
+   PauseMenuList.setAsActiveMenuList();
    PauseButtonHolder.setActive();
+   PauseMenuInputHandler.setFirstResponder();
 }
 
 function openPauseMenuOptions()
@@ -61,6 +64,32 @@ function pauseMenuExitToDesktop()
 
 function PauseButtonHolder::onWake(%this)
 {
-   %this-->goButton.set("btn_a", "Return", "OK", "PauseMenuList.activateRow();", true);
+   %this-->goButton.set("btn_a", "Return", "OK", "PauseMenuList.activate();", true);
    %this-->backButton.set("btn_b", "Escape", "Back", "Canvas.popDialog();");
-}
\ No newline at end of file
+}
+
+function PauseMenu::addPauseMenuButton(%this, %buttonText, %buttonCallback)
+{
+   %newButton = new GuiButtonCtrl() {
+      text = %buttonText;
+      groupNum = "-1";
+      buttonType = "PushButton";
+      useMouseEvents = "0";
+      position = "0 0";
+      extent = "400 55";
+      minExtent = "8 2";
+      horizSizing = "right";
+      vertSizing = "bottom";
+      profile = "GuiMenuButtonProfile";
+      visible = "1";
+      active = "1";
+      command = %buttonCallback;
+      tooltipProfile = "GuiToolTipProfile";
+      hovertime = "1000";
+      isContainer = "0";
+      canSave = "1";
+      canSaveDynamicFields = "0";
+   };
+   
+   PauseMenuList.add(%newButton);
+}
diff --git a/Templates/BaseGame/game/data/UI/guis/profiler.tscript b/Templates/BaseGame/game/data/UI/guis/profiler.tscript
index a13d7d9b5..56f88a189 100644
--- a/Templates/BaseGame/game/data/UI/guis/profiler.tscript
+++ b/Templates/BaseGame/game/data/UI/guis/profiler.tscript
@@ -363,4 +363,4 @@ function metrics( %expr )
    }
    else
       $GameCanvas.popDialog(FrameOverlayGui);
-}
\ No newline at end of file
+}
diff --git a/Templates/BaseGame/game/data/UI/guis/recordingsDlg.asset.taml b/Templates/BaseGame/game/data/UI/guis/recordingsDlg.asset.taml
index 7cc7b2168..2b0c337b5 100644
--- a/Templates/BaseGame/game/data/UI/guis/recordingsDlg.asset.taml
+++ b/Templates/BaseGame/game/data/UI/guis/recordingsDlg.asset.taml
@@ -1,7 +1,4 @@
 <GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
     AssetName="recordingsDlg"
-    scriptFile="@assetFile=RecordingsDlg.gui"
     GUIFile="@assetFile=RecordingsDlg.gui"
-    VersionId="1" />
+    VersionId="1"/>
diff --git a/Templates/BaseGame/game/data/UI/guis/startupGui.gui b/Templates/BaseGame/game/data/UI/guis/startupGui.gui
index 647fc1b03..13f2460e3 100644
--- a/Templates/BaseGame/game/data/UI/guis/startupGui.gui
+++ b/Templates/BaseGame/game/data/UI/guis/startupGui.gui
@@ -35,7 +35,7 @@ $guiContent = new GuiFadeinBitmapCtrl(StartupGui) {
       Visible = "1";
       tooltipprofile = "GuiToolTipProfile";
       hovertime = "1000";
-      bitmap = "";
+      bitmapAsset = "";
       wrap = "0";
       command = "StartupGui.click();";
    };
@@ -54,7 +54,7 @@ $guiContent = new GuiFadeinBitmapCtrl(StartupGui) {
       Visible = "1";
       tooltipprofile = "GuiToolTipProfile";
       hovertime = "1000";
-      bitmap = "";
+      bitmapAsset = "";
       wrap = "0";
       command = "StartupGui.click();";
    };
diff --git a/Templates/BaseGame/game/data/UI/guis/startupGui.tscript b/Templates/BaseGame/game/data/UI/guis/startupGui.tscript
index af673c819..a89226d70 100644
--- a/Templates/BaseGame/game/data/UI/guis/startupGui.tscript
+++ b/Templates/BaseGame/game/data/UI/guis/startupGui.tscript
@@ -32,7 +32,7 @@ function loadStartup()
    // A list of the splash screens and logos
    // to cycle through. Note that they have to
    // be in consecutive numerical order
-   StartupGui.bitmap[0]     = "UI:background_dark_image";
+   StartupGui.bitmap[0]     = "UI:backgrounddark_image";
    StartupGui.logo[0]       = "UI:Torque_3D_logo_alt_image";
    StartupGui.logoPos[0]    = "178 251";
    StartupGui.logoExtent[0] = "443 139";
diff --git a/Templates/BaseGame/game/data/UI/images/Torque-3D-logo-shortcut.png b/Templates/BaseGame/game/data/UI/images/Torque-3D-logo-shortcut.png
deleted file mode 100644
index d993d4893f9112747e2099c1f111877db4064a86..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 10728
zcmZ8nWmFqov<=0zxJz*;6nB^4E`dUeyG!w+#a#jvDeggwyF+mZ?p}(!6@BUV-mkZ^
zlF7O=*N)9O`|e0}RXI#FQZxVnfT<u4)C2(F+F<{qQIKH2_vZY_unUr@k{l55`tOt5
zQ38gwpgPOzeE|T_@&0|`02x1sVU5Uc3Mw+ln{WsSe3)r`ickRH9Y6snsqM9V;%680
zS+`-&6Vke}7Dtuky-E>b1))(4+ecc(+DD>mF4GBVHs{h7#&{7tjU(Pe!Z&5X{q|SV
z(+Fuwe!n#qKj>Zl3NDZdt_UrkIzX1qPTkR1>hnATqNkz<!EmeqKRjDk>zaXq`<`6o
zOvll+_gvXkg?^59?W6m|lHFNd=W}Jp?Q#^hR3AVB1VY3>3hpsZGY(PdHs&BcRUg@9
zfExpNVM`E7tnV(60^VN>8kOos+qdlJ)zq4C5M#(Cjlv7S8PE6S@B=CU0$QcIb~ueD
z)VrVN_k*Q6^et=6{ylb~<60t`^n-*Dj+NkWP8Pu-a(Q7i>W(JRHEnm&{1<GhdD~M&
z0GL6%3cv*I!c-VGKX~;9$W5VoXE0}*h59sbnVTb{3#ay}cPM+n*7!4%*b<I4^T`^q
zJO9%!*2;@<C19ypm3nm*5a?k6_~X|(APLZ#UeE*ct>h^;en6J-_zS4ABU%xYu|MTs
zO8HA*!9fg%V~{>nHvh|=DB_xiS_FRS1L5IZXu_$m0-b=2E&rLsHw!??lTK$)DK&M7
zUddsarKu?gF)B@KkyMAzNXd~}9v<m<n2MK1V%9*Nxxz&@M`;gR+sv1T+RpUtt#R0{
zR)B8HK<})}Bg#UZxP0N(2IV_SQvAa?{X9d1_p{}4!<3fh0l3|WUG{zdNdYLduPUpD
zD&>->nLem$iVkR(*y_xa&NHlpbrPiMsNMRdN7KIKf7X{df*RJK^!(~t43Y-Tp?!LP
z?GN2~ekWJ>YUIys3xUip>c@y_uPL~N&$uCzCkHzvbG6t2i0Deh;#F1q)W2z;@!Slw
zn{5C5JhDr9T%s1{I<AVs8JhJTMT<l2L!%U?aJusE+#eO#G|}r^=}%HJpgGwPKiWH`
z&IPNINpHYF?y}_0FZ;0&KI&RBs*ZLeIQr6?Xm!Ta!qO_@hwE&P+rV_XN(7G$fy$*8
zuX$D>yUaoCy(ryYGExh<i7f@17JqrVXw~8aR)eNDo63L*_j$`+?D|T#-`a4_eAd6D
zvF;FVRK)YhMR)87yKAxY<tNWPTZ(50fuCg=MF^0N2j$qoi(fc>4f^V7l?T@pBQmqT
z53wKI<sfr}QzI|ES~G(`$$DD8+B1WLiF(QId4;KgIw(JtxtqXnrA5qcrq8+|*y#8k
zWC**%hD0IQf4->$q$1j}x5))pm&76`Mj|`jg*4NIq#*{I#4%zTv4`!?lJV%JX8on}
z9B%a6QyvOPl}{K}buC5*x|#^IDrBS><f^Z}qkg+dzBCi>pN=opE<yMG?bhGA!fQ5l
zl%yU&4Fwzc7m)MYLkbH6m}d}ctMXpb3tquPDuS819}$R$G?tX{k@8(iiCMO`tC4LS
z!#j=kDJ>onJ!7KY1O`{GiSTCtu<BB?CwTQk73yR|0*OE^t(6bfJQ=}B?t%@se|yEi
zcoHcoPj4oH)Q{^${<>LyLwn8JpH6$oZd|?l6mrUgdiYE$*c^Qs=bz6s$V(9jT#GxH
z;%Q3L$}{OOXr@I1zbSFerSx;=fJMG}QP(+lWec*0d_1714#&@1(fimp#m^gVr>5B@
zf^vr{Uk4}-!Jg5u%o!x+eE<e=G~FwcklSjnM6;2u%Y-3rDKKj6d*vk$Q@BIwxj4+_
zj?72djJCM}IzH~M$<qc%H4=8>YOT(jdTzZLa?h?12t*ax`WGwCAefJRjZSEo1)Z(B
zWix5t7C;CB85}?<g#-!Ve&qi=FN`LsHEgxXSQ}#d0Rp+3pe(1y20?;dOf_Kfsz3mV
zi8`c7dt^6GUW{I8*D5nl5ZgqVhLRuHgtA!*fhaxW#zP<kAkdA$D*+MvYzy6@CTK1L
zc7tu%JwIF_VrJO}zMB~YIy*?&XI)k=MD3|ZcTYO=q)1BiLM&G^-O=XxhF5lMBBE}b
z8fQ*wU)y)eC2l!!4I3NXKfEI1I<8mHz*`Z;MTi-RUYJCQ)E%dJCWEL9$VgMRkCy;g
zR%e*@ShnI94kW3^@O*Eg|M0^!nyz?*l*6bill)_C0rpaIFn0&zek>IK(q(zyi%X&G
z4Cuw;Hzt<FK+UqRJzIvjgaiV`3)aK$+pBDb5XgS+rdGD<Ehh%b5@!8Q>7f;NRaFxT
zVUkjk$i@DFx0R)umd@^ToGEg=Fg5~#OoT4-f58gjx4FxQML}A&NG=81c0{*u?msqX
zyWPxfV62g?kBjLZKravK7GLEfoCndqAD(F;<k1pk6Fp+6TM9a!F%bzSpg$xftM}Q3
z;H)gjr<lX!Hy}`!s+oA=JF+`+kD>-4VX2&Gj<tY^!F1(s<+>dCK~J4EkRz3~6evYQ
zI<J;zB)zaAQ%y$bf@uPuL(^gwUAVrpx^;)D)QCp5kK|FXm56FCF~)|8W^F~k&H+iZ
z>LJ_k$V64)M0zPz9C_;;h65LBo-!nv%Yr+vv?Z-b2y=wVn8-4FTb+T{e2kPa#6Br|
z&R`t4=HBs3VO`ttk9stx_h22Ld1CxgE`wD7?(LDI2VW!Y(9lW+#8w*R=bNM0Q>|m?
zgp03IgyEg>c@S=fC6It%5xYBM*Nj0Zdy=w;4pswhfmZp6;VG?O0#vFyYAF^hY<6Mq
z9e;~L_Qzp}tr0IVVQ#QuazVSBqt}b(j)X7L(_MFDcO>amDAB9700D)i-%_U#VjGGj
z#oK3|!!BRQ&6J56YS6|uXia=^oQ~4~87=tQrW6}R!QH+S1N2zZWcXf!klJ6hw3KKd
zYB{NYI~68Su$}O<Q{N-bhlhjgK5C4h;O1kXL-NHwy>re0XKiVICH;(<PmL8-xDklV
zmN900FX=W|P^IIB*t<{WDkhmd90z65!8YY3MKY6!JS{|pf{eRBk<fy43yr)SPySwy
zNDKw)SS}$uH<2T9wpr{oZ;xPkS8uoZ<*P6%5J36LMeHR{y_!%dogCw^DoMMxj*J-D
z?6x9RufPvCfohW1=E~j*4qw!~ak+to?7ON9)6n=ZOW&7lg9L;U-CaSrD-0`!R%6D4
z)^RF?nq>LfFGH?lzlQQGp+@sXpvMwFuSSw%!*|~!ohNn(vD%34<YU4TDV7Y(jCyLQ
zYna1bQt|>$e4)63G7PQV>WRlW_Z*f3rc)}Y)C^{|jpqD|lX4;^OlZ_mHEaeRr0Yo<
z$J$Vg?K-{-<L;4k&a^48(t`$h^p6-^feACKPjZdP!zv7dk^{qKgK&%@VgVm(SfYNE
zxSDh%S@#t?ED8MhBS&CrX}ZoI)1ysRlD01u1g%z~Pd`3R)|kz#TGM`s_wB~xTw<>D
zj(4XyStbmZ8ugHq1_|sW<K(_?hviWd8og+=@6wc+Y89}|2%)GAD*8+jdP1Mr-m|WV
ze*H`ii+(IpDCLOP3bu09R+CwwH<G1wQW4ySaYpYg->y`0zv&)Pc5t5vh1Aim`j7Cc
z{LCalW3<)3Ro0)Jd2M*#@f|s#WLl@Bnb4AHh(TuwM{kjUR_sJwhgBZLf0TQ;t@Ap;
z_Cs*SPSTjBHtJVoAibq+xy)it2FIr{N<(K()bx5(ziTa^$k+@n*KwDrTu3Y|e`A|1
zACT&3RWH>oLBD}Wfd}#t4-A+rT+!`2B&L1`Cv}$jLVGUSv2R^I)HAp*@9B=Xtkmso
z$23{I^{8)KPsZ+L+4>-WJuSj4QLYfNroTq=J*sVc>eVC=WbP_o^RZMn9<CXA?bnoj
zydIjvB~<ezpA+_`Q1uz^q5gp$eLe)u`jWQAJ~*3-&ZjDZepFL9ccWw6<-vcHaxNda
z{Qj5e?RhdP^n-9au@c*vQxmTVLx@YN496osNl%htrF!)Q&OwTb_PSslUL#58=Fq!j
z^iLsvMaWs_ZzzEEPUDgLQJmF4)24OaGsy-42ktZisp|?-E8B8RHz{dMVUW=nWp-hw
zAnKo~gU@e|N<BhcX+r!nZtm@4?i1GQhadA8YdE(4#t-*{DFm5H5Tcj?MAjZ>{KG0}
z)T#ww0nUTXkUdk!(Wu}{k&`W-xDYvTVs?aEaijj1{X146lVhUKB6mp;NJquolFG+g
z$!vakk6NV~!MC!S@=mB(9Tk{6z*y;w&H_&C(A?oNA)H}4Av?7{@}YkvUC{wm-GcoK
z`x=74NP4oO)vI-35a_#cr>Y4biQcJ9(B!PnD3*Cf4n?N(;ZZFFQsQH;)faTW7yM2{
z5#Ke2vc^aWe=9`=W%Br*N;aTbfFm@QIh4{FOZWG%&B738@@g0%^J*%xx`dU(;P`QQ
z(1Z<KO330*>X5Wx_ml{4>V8G`{z}Lp`AsaiHd}_VUQgEQQEI8od<kZyWoe?m{fEm`
zO7UBot)T(74*F#$W|S)KgtsJ3SM^0Z7!7?|uS#T_YTYgP>rwG|5Im`f(#acPvWwfi
z8kB0yk=<fUymVh!3db~Cj&AHFqg!vCt17x5bRL*h7!AJWC!k?4BW9BBDi82Unoyt-
z8jiD|?oSFey{W&eLhfD3PDrR*V5yy*^5bv{)~1D7`j_McQ&O}nip=gD{^gGjP9y{g
zRt+aL;u@4@C1n%|v$<NO(9txz?u}hW_MJ5+3>EoQl(Xa>&++eEEh#WZFk8P284jWs
z9!8zpY!9>KMIU;+W+DLm5+T%zgC~qk8?zUn4H>%2u$K<;#ObJfR?)wS#LlN4e=32Z
zGH2fY-7))m5ue#~uG5C-7RP#NHt35sVIo5t`6xKpnoZwh77L|rPtj!X?B^K%j6{{T
z%B?&v!UFH@#Uf}@cfCFpAqAQ%Q1B2d^g5oG>^Sb2SvZgD&8g_I5d9g-#q%Mn*HESh
zHbtUBQT$(bH%w-a9Umq9G_o+~jfCzrgX}-krrE|Zmpn+fg{~kFnH&BDXNV_?1xdGP
zuqzg^1(QC#h&gm;T{xXi8zibYQfidHxGpEC^{GKc`(Z&5?bTtj(>upOoBA@&)D$Gm
zs5}AW7dV`#FgyX<r@sur%C1zc;B`|FC>jD;msaIK37?f<Tsep3Lo@KiinX+bfBoNw
zC5+5G4wkPmP}9$h&FbiGs$1u#iMAhK5tl>z-<NV)%DR4m_3mRFdP}!OfSDLivi@~}
zd$*38MZ($6gN2XXk8YTh=g}Z<_Ljtr>wQNUvh8f=6-rg<72387my`+$C+4G1k{`3P
z?GYNzAB+n0eSO?CY*RfDtZr)8O0F?=k6nTVi-GjzLroO3u~Xo^VFA*E*VPq8)RoUv
zt_u0r9uhak^098eP%7D`+HwHlTw6Hmu5qjaw%q<#g5%_{>AE+6QPR#I7~-?gE?qZx
zYQX7wGg<i+uBARBh>KSEsxyWixhsjG-X6at%N#C0f>%I0{opMiGq~-&O7e)ddr{7j
z&Gh%^;MU3@?Q?>IPhUcP+%3!(k&}6p*shKU+B%_+g@0nFxf|wWIltZ$AJ@?vF<HJ<
zo6$GQJ@gs^q4l+8EJV}nE|FIy^8cjOv?m(O?PWFzm3P*w&KoxF$M}O86^c4Zfj0fh
z@*pO|AUv3hXNYr4KTy1R;VX(ni(tV>JIe4A`J_6NvyK`}VMdGsi!qmmsa=|5lrPAQ
z__R8g=69%j${uWno_z}|e{ADw9EgMCOmAzxO=NeM*!!OdeTu@7=Gj!^JFAgc2Y*ad
zs{C1Nh5>&IFTe8iw5ROQFl=eskL@d#r!<wZmz)kUv-m}f1ZsNQT{>QE57RpTq9*(a
zLdldt{Ea=V1U4DPAm2Td$26njUgAVb-@gScnq9Gcf(angzAPx*h3W&9vv3-O&8g@x
zEaNx?8*Ti4CW%7UxD(omn5&XQ7?=uykl&(JIcd)FGlzF3KIWD|4jm%*W#LxgB<h+~
z$l$7Hpu}W(YG}fvNIE+h*X^ICxev`8l|XZR@mNOAbSA*@eT})E!sRh}3HHB~05d{y
zLoHAPK^`7Off~DmT3^kc^dGQ8Qs0_32!uWw1~X8UB}Y8I+hui-`%L)PLWR)So@f19
z^6b^*2sT9Hobe4CfFo?94aBjW6lkoyRZ<ar4PW}IJ>^k;iVtGhYk}rErN>}+2CVE(
zQhcXnEKt^}R{$yaww%Y*mb|qb#nYz>RpwQ;5><?I)6USa3$xN<?X<dUE7+Z72*D-;
zI6lhzFbB`fU`u-Q*RF*Of3YqU%J4G`h)3nLX4n~wBIc=mM8e6E0+ytGR(s8CNME)c
zwGu8GQZ);6F(cP?Cf4#WW0%?S`iufC^tdB4A#NZx>S#yr@TFo9uRA=dG-1F7b1%U%
zjbgr}1v9&vQfg8izGA{q>JV&Lkt*iuf2mZNE|NKSxB67|#+bZYQd81@S*6Z9JNKjn
zuxNKd-m17DVkoQvF|8giRQh6)Qw)I|P2b%np)If;H=KG(q2b(0Dn#1xnGM(|FU5-f
zwW0;wqEg>J@C>es<WOxik^Yj5w@YVYP>G<68zSqh;_Nu-t(7ce&nRnsH>?`H{6;E*
z(@k?iPP)BPs_qmXKUJw7Q=#l*Y+|u4h&qHA*||G>sFyJC(*qGK;uDDd5^vzUFj}Z)
z25$Su)^z}DG)&&A>?7g$cf#``(?rrzCckVX+{JJ<_I)>)(>$)V*MfViU9L6-ED?S;
zuqF8Ip%8G)*o)a4W}-|u4J5a`bAtbPm5;A59{Xs#(^$dEOl{G7c(-BORG%{L9=lvW
z89p3AxlIvm9W$JhD2AU+xD%hlVQEZ=yE$pan#_#1c6ve==tr^IGcs66@+h|G^o}oI
z1x<3&XNHvl@j=L(oo|IDM1ENB8|t^LtM)ZJ%Xf*R>y(d{=)&nWgS?H6FBk*ITlH&K
zFM4)6RQyiE8;W>aYu6e3)S+H$x%3UvhT*ouCdRdi+b(0VsMLHQ(At|m3>mitiP(nP
z0_}&2rw^yS4lBy0p7)o@;7iP;<1xaOzIUz31ER5ZNIrxXqkSE+Kfyn?>j7PIC_!Q<
zldRs<)}P{(Ja`&Q=Ip}A>77<hI4NU{ngI5>cnt3LEcAuSAFmr~i*1(g_!g3RRk)RM
zo25})MrpTBejX4#A7PT3RWTsxOj0|5N%$8>yf#GlMa%l$la!(|_wmx)H_qj&SMw>R
zf7YXEfk8Eyd0IU?C@sezc*?jIQsef(Q@R4zJVSSpMLuf_t44V${Fo!9jDf4wQ+`nP
zJS0OZVr5a``-1&xha3v@^rF*J0m}qCEBnHVSL5SdX&^q?qczaANt6kUs_@~o^>k@Z
zXx+A{0+-3Hx9z~>?MkUiS3TV7rQKIR;tPX?aa@5gPVtc+p;V#hx-PfIL~t?gBq{zH
z*o6)U4LVFcmJga9z=pJ1NK^3v$iG}Q!6)WQEjbrp-8sH#-ujizF^t;4jCY=DLTH;B
z$#-g!#S}%Cg8I>F+Iwk(9-K&!x1j^Nv8<kGND~!dQ&}8iKx$&C+#~(b#D09@(q4o)
zvS3{;ahrsDuvYxjlDCCaVOy9SH)@yMeb>xK_J_*{+e913%zaDD4Y55B8f=+wQ5(P#
zC)q~Dy!otyj196bdd7OhO@`2fW6g?Rezj)m;4n^j&fz<|0=(3t-#!Jqz9&i8^X>NJ
z#UaU@WchXzuy`yVx{-v^%aa!&)#RA??PmU)WkQrZjmXECzi#9kGXjAyv?XTNcZ~c&
zA=p)Ki&a@EKa*v){I{Xua-ms#-{it`Y47GVYGsdqpKpe?^|8d(peUBdtWW!Tb1>N8
zN(uw!gPtd;K$HjlMU};BxL6I8rj5H|lHQMYSogvdbg5GvnAB<rc*x;mp=%b^s+`bt
z+%?7Ofp)w~Sh%NM><Ie!Vjrg0H!b0%Gs&~uCsxg2wYI}|cb%^@NWSd6qEtGWkYL(C
zZ?g6gE#|>;O>*nxV5{S2tL(?Qphniy>i!ea*t}M5+#wMhm1HbG+^qg+*hWZ}8(K9P
z`1MA1**;>geXd@JHXWasBpP<?^J0lg4j3-emt@CUjmLb}arZblaa|m%?mV!<<=Wbu
zT7YGe4$+-ZZqZ7P>9epa>}XzO6-cnMmy8=@vGSXbaS#aF+8udo6KO@ifEEu%<}Tdl
zp3`Z^><BjKNZgO4EJ(Dy6PaK;rm#B^t$Rf{d*x{Z^hlqva&C#4T}?r1;Mm0P*=cn9
z%SzOKVW-V<DGeqc!N<?nDrqIS_YEXpOOvxIGGIyVA%5T&6TEDoTdh{Lv3%e6!aY^6
zN{rvn{gnMcbEo%BUvDij;-qcz+s@q<=%i8d5K=g1Xb0_+lNJhMG_m}4%GS6WKv}a7
z0}LK#<1<h-3j(okjDm+%F#K!}Llwl>e!$TiUZl(xz4mqRJ)k(8(^uhl*B&MsQEtPi
z|JzlS%M2Le6YU#-E$AkUm>9PlmOO0x{X+|m#0HPq6u%EI-V850QQp{);ua!@SQuyt
z1{CN3lncHJ_u>blOIB~CaJ7&Ch|>0j=wQG|RjwAnfV^9)iq1pFq<kQ|$y5!E?FY!!
zrE-mh*^YKHA6>ZEUXxJq(K55l2U$OE+Zq1Kv`3T=TMO}+|3<P2?j6P5`iI>k=1@G+
zm3;>js`_n4#@Q#xm53c+R7?_G&%My12I!5Q;*c>GL2Q*!@^11V!S#9m`i-C>l4>+o
zi>p-^nuOFoVBv2mOw2c1n22R9bnO<w(;4g*u8czmw?(W&JvqP<+h}MD5ocif_gTxe
zY;OR`!?FS|(N_Mv#g8F2d5|g5o0yf>NRUwTyxe23n5L|x)rQ_^FsT;qG`~Z<gYh=8
zeXnrrsWz<gOV22Qs{k<F)F!6)rs$v*O9ET*CBc7`(pP=QT1^nUmkf`|JT3k#*z+*Q
z6*=T>=j(Vl;_IVj`2~GwR%6w8bNaPQyUDVkH6`s%g?Pj<q_Obc=ITbEtF*9U4;D-#
z<=I)DKk8aC!qAy1LDv$bTu0Y3jAsWi`<o<*WT+t2gx=aBbC<WRaIC5U&RUK%3qzBi
z;0alB&6+Zx3iCpMiY`SLLA`z$3!$9~M;pPJf$0X<Oj~|f2k@CTsXT<F6=nhkNroN{
z63YU7#vvv2zE2k!1~r9Eu+l9X@jM6cBnNm4FR;0#*@b+r1rSGeE>o|TC75_s?lyxq
zPds=1{E|uwu$Ni9?Gb9{Ev`X}q<2@FXTmW&mQL|-UNr1R;Mj%13}*X3dIXR*1E7EC
z0v`cSynz97uarE0uNL4wBcF5OtnnULy~2>2O891ypq*ETp}V%e{wfKp96NM3OVd0<
zOnR3OWg`=g<EoKcZ3W)-YM--CQ7Y<qPaYTuXp_#Y95jv!)by4HGIuo#*DDSS4H3=*
zYP1@VVR^aM!z0e|4-WCLiCe;*hbM$U(IVwj9azpvCdD1E;32^bw#(Ntb)g+Xm7rNT
zF5G=XKVkkyU1sB`75kgOfaEe&Nx(6ep_WucvW&pY!Etjl%V{At0Ibbndzw28lxMH0
z(J9q+K-ZBMhXrva5ykXXN}5TRzWWuqyLOzU*2I<i$W1hnLi%rNEt}~$fX87<JHUMK
zyN;mGb<rBkRrn7|mME2&=Iko9Cg``kA}XMaw|a3d`<Wg;9vEmW7NRs<!Z;!v$@h+2
znjYLcVH<+)mW34}p%aolct|N<tYGUGz$u%whI!2=>ScZvy3!mMn_@2lH>n)FB4x+5
zvp-5O4X?=h72*UZnaEFMbF<v6hWMr6v^5r0%sS4xD^Wn&t=Sk9JI}Jrfr@UA5rMle
zD>MVYGpVR=JPMMB9TJih6#Ta*U^Q)ldNq<>w^;3kf`gOf`!{M39o>$o9;eeH)FDhk
z<<+xeKKVW*J<rM0&s;?t1^T|ur8dIC&Dz<C^B)SW>P0dq2M0a;z;QtVb>(YIr)Iu#
zdB@FsmH|L3ZGC`qn|ie&rlL*aRcF*%gVh~4SWQto*GU+5UPcCZkwR;A=v6~5i#JvB
z2qK#%_CQY`dep!QY^&9CaS_M}@3awKWSsB=C$s9UFVBcWV+-(fk`-PU1UGXj{QiwB
z$H*z&+0_|GbiK>O_wG{#6v24Se7m6ucBqlNn+IeT7T+p7&3A>ULaHce$&iYs{+U+j
zrH2cWX;)OHny5S$G#0REb$<&x@xyEwQOYyyK;10fT6x_68-@n-;fF3kOz;uR01q_n
z+DWm}g(l^vy$m8mcS_4ILIY+S0%Z$s2qFB|etqY%ZfHVwmImRXat)Y)^9SZK1%T$@
z>@S-sS&^a{``VvcV%L=3J$5Y9v(lhUH#=m04S~=^>}z^V?r;i9qYtM_-o%1F^&XRz
zG)Rd*FxXqeeRd+AKe{!w`Wh6bY7w7_BYgh}>5rJyB#AlCyNQqzjht03k*^u}hLirZ
z6|fAJ9XB*<nUI<!{rrtxIkptF735=m%fc=)_aD3mK+1fRNaz#YZwG$DH}oQ9PR3A1
zpHKQ?F(=J*W!FbfNU7&c7?!IX{@e`lO<`HAu9#V|e+p1>C?p~4nPFCUh3B}Lxu#p%
zC%GupzMd6sqPmR4*UfkA(?JLM1{tHBF48n*fe#G7Yn_saJ9iNXoYJ~a&n;MQ@dyt=
zvB@z{zB^)fHrunpCtB@cry_wo$|H$OCg$pfuw$bYwz<sC50Xb#J1x}ZlP*T7zrNb=
z-C^N6E*ITQ@mJP7$kwXR`GF;RXFf0DQg@98Ev9O(rI{q*m79g5-PlIoZXFzcDNG)Y
zofev(Qnegn<Dcrd2&jiOw5??dsFR3`VjF%pbN7K_u=`bGNuY232ALY$IYc~K67!|V
z@ePJxOX93kN>e!`Wkiw9Lz(w-<tI;&m*{<bakmaY)+vXpzA(yw%|9-HTMP_qO3fUW
z*k4MM{C?p|GR@ODyF!Il;_iphg~tmWFxBkw>yv*c3#AxYiP(|Gg>#ahOh5IEPX~HL
zs!HW!{vGV_!gHKIOX{4Qh*PJ1E`==L_N3c#K09w<_#>tO<Jei$9b}iN8}mgzjU&d;
z*UG*j7FM8d#|-wvKd$<Q*HMeEB`M4Mg-Uy1^Serm6ERNrN9A0SKjHK=sY*A0B|U<*
zc{UrNVya{p@YHPrg2@~d<vDkxNMvDi{11Lek^5=&qKR2CbU*fMNOEhHc$j9}9N#&v
zIPXmnPwkUG4e_9xJZtQ9M&_JsPqPP;OQNVR9Za~gz!h5$Pr~Y9*$3a#?psZ<%OTp4
zX!g!h6*aZ^s%lT%&%7!t593b$b$&U>lwJ}V`1FXm&m%0=)_`+pyuTZ8hUYmsgU>^1
zd}n$g<NE5v>XmTn<<Ya+u{iKzSm)F05;5z%sa)8N%x*g89j4j7ePt6b&f|OLNA**x
zfs)(D$&t!9b^pn)>)?l7M)4&Puk&}5e%Bf&Eq}7L;;6){MDJF=6h!6M!_|x5wM;sQ
z|6-|buSGOI`uitGmq!Jh<1(7t-Sl{Tf3ZUf5P5yNQWVN^tjh8B!DwiG@hm7(p5Pfx
zE#eIBA+}BnX-op1U-A*rSH1PVIRpW^>n6q8F2FfYbo6-OVjEgOE|VfUVBPx<#qa4N
zrL^qq^;6_@fWkooTz%xbn=_WnF1PW<VGjf?_wU=fK|RJ80@qpx9jPbLxURTiRQ)9K
z-$vFvH!xLZ@M&mN7?@==8u4Xp6bnNcv%P3;rlj9e+)sFR)>*l`^IE*CA$(RLf-*<t
zA5dl8^QtKM72g(TJJT_iGyP*&m@OvG&U~m(Gej4E{X5B<9%FvV1^L-_*7-@;=X$^A
zU!!i0-|f=tU74ESVb)#O>+|R&Oj7W=)rMJ9JPt(c2Me=2A7m6Y7)3iMGQ;>{xt2JI
zV@&9pR;I03BqvWxNYQ<df>h;!z=ylmPNcxHGG>_>p5F}%hAW=GM+knlw)$*mZanQN
zdBVi8tlRZ42WIbjy3CU8rK53RiK>-ZpqS}Wvvd38aTqro2NMO)esfytwSvB;D$S58
zBctF`^A)WFkfHkVtm`!_pXu^KwAt%oo9;gqy*?`$JxnXXl$zuJaL{Jkpuha>p6_7$
zp)sjAFP8Q{ib*0yA%^*H#-Il@=8$x*gc&A}-Z(&DU-(;=6h(`iC3iNXP7#-_-q0?%
zK&x!;J*rcfaEQ9jL)lmVMjJhunmRaqaB!VW6)WQ`z2yN@z-Tr7<oIDq%EVx)G}=W2
zrVfXD(lfuauLhu+7U!+rfEMqoy^So<ueVv%0nbP5XKQVqb}lX#TN}@(o}This<OIL
z@t?Jl|Lv7y8+AZJ)1Pi0fv}f8rJ<qEZ^dN%15KVm-h^~GR!i&c-rioeVi6Z2K>YbY
z&B*uo=dX1Qe2XJF@ds!kOrBPm*QH|_%7-=#!Z5l|g!s~5y&E8Rg4Mgjsy+)v-9^pG
zVjc!a`}6IJ=*CVg|GGMxVY?RqkeZtMer9IoyUJ{qOK<mogcVMig%=4bT)SQ-gsdb`
z7Vw)*`o3Yn^Gzab9R>$?mfzV7dW)34zjSP^)V8j$z5l;n@PgJmt-2MG2n+KmKU7`o
zog5$k20ZOhy`J>F6@NNv+VFqO_CIU+`Lhk9co?d}95@=vNsJ-;1C*6xPBfB=9=WeM
z8<$Es_;l*oCH#Ei6wr46OZ>&9E2oL)Z}t!TzL9@IGDTYovV$Y%Asd>94<3Op?JO#`
z8JSTN_j?K#f7+_{e|_9QR&gr^!|VKG6yeayA6)w9Ok+3Ka?|D7hw}#9lp9ez^t|;y
zFIX@N@MA^D=XPNKUp<EJ;}i2GA?F^x38G%nqz0A1q#Qunaa7gzLY#Z)P6w+lOPq<p
z{}ctkgNo^|tAZ*-hBrNoObYPbA=|jm{Cd{0z~Ae?mu@9y?%KtszGtiZHT{?v1BsRr
z!e+5uAFSyvS+!K;_8Y|ZUC#gc$msQi%&C0~eL>`+AMe*c=X*7Rhqkox{kI;Vnp;%l
z0~!r8{l3;)bBm~wY@fp+s+aR{rw6yc)d5GJHXhQ0_NVzyOf3FUtvG304NA%w&)tyJ
zg=Gn3poV@ob8c;GFXgeZn4>ohInT#do)C!8mK*e~?<V|$5$yKs&wy9|It1eJSRaf3
zXkQFMT^wk+l{Oidqed^6Rdx$i&mBwbAK2MnkyU11=B&gYm+WBJjGE}pEIcw6xwW3b
z^}h#=0(NPsmUv2qFvDi>kN?*gpg37o5>Kq?NMuELZr?^=t~wqY8=E*VFaRC>&K@v$
ze&uP`u-w_w((;O$n};{|Pk8~I{?DyT%t&5O7r*ZOE~1TALBN?qZMSGX7?2Dzln~%T
zXbrx>)SdU$IDgY=*Xzq;%!ZMX(W^QGSPwkE0sv@fX<?#U+y(vTf#K~L37Ok_>0UYi
z+!QG9hKi-vtLy;RU0&V!pj!>&$Fak0b_c;X`#%e1jPLb8q0l2YECWS`GMFOo8a0+E
z1YLKlqKVic9(OJ@Zfo<w=4StRbp3#g;-b#WlxkmM&Bg1=rgb6nf-wNV=y7?W|8f1U
zGXO5v?>w05X_9b(FS|Iw6~)XkxG(J=1@Am~*KL}_`)<v%Njho3^kP3xI{alxA;s_5
zjOy!Mobc&Azg#@!^Y?g|*NF4AHENsdLwOuxhLXKwU{*)GmA~d#LgjZ2eG4~5`4#5=
zHfLF?>QNW3LjR(c$L>&K_|@O1?5?NZ>}I&ogI@^4MkPf@9RFm8MEjX1b39Rw(wh!h
z;_L4e-BTV2cY3>d?+nj}n@Ba^?M)^24m!L{Qx9xbyno{2koxs6`kyq^S=Ocd?B|7J
zQHc9L!PVXHsLaS>m=}W=_MHMAS2W7MHXCHty|FUmf=yCj6a&AAP*Y@+(b(D9c{h{u
za!tiL|7VxWdIh1FNpU7>bzdmT_poJUd{^k>oBw*SGevQs<st&i%*>Yi`};G$eEG6~
zf#w(!2WP8fUYyP>ASj|h_G>2W@j~a#KjFj3iU03HYjXdZ*4cLSfZEm%<75I9WK@Aw
IQpVr@2Vh;nHvj+t

diff --git a/Templates/BaseGame/game/data/UI/images/Torque-3D-logo-w.png b/Templates/BaseGame/game/data/UI/images/Torque-3D-logo-w.png
deleted file mode 100644
index ec197dda39246e2f1f0a95f79d35a68aba584a01..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 19328
zcmV(yLFc}SP)<h;3K|Lk000e1NJLTq00I&K006NF1^@s6kt$Ty0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBVoB1uF+RCwC#T?c#>#n#`spifFbNPtii
zs`P{=EvOVxe29c59g!kW6zM2}4+SBFB8c#zG*c)KqzeLKqql_6qk^;u2?-#Opig<(
z?@k`cySdpieRpr>{C*d*yR)-X&Ybg~GiS~K#km9=QchKoBuSDaNs@e&fGm#$9g-wT
zk|arzlN2|Q%`QQPBuSDaNs>UqE}+4#z(n<tZ%C3PNy>ORk&`5p$$%UTmN2DcbV-t=
z+?FK4hGQ8L$bn)j29%&ek|ZgcB}stc7-j`>(AbjkB$$vSNdg8*5?I)piGf1~5O6p%
zsFG<VNs@9`wu#Rwcs0Lv9<Uk1*ll3i(FZ~T3Q3YAc#vSm-f~pUFU$>Wz_`E$gGRNG
zLDc-lsFEZ}@E`#~J_8r3uQIxoAObjO5UBzgL|Q5&Ny=ZKL4t++1uRrwVt!x&!vjY7
zTkR*IIs{ZmkReHuy_B~E4H8t?UMBNY#Jv0{fCB~{jYUHBb*7Uf`%o%RS#LR(eMc_v
z0uro21PyoqHenEz1L%;-Ns=A=Un)e|Hj?;{Kh;T0ZM7c-YhYmqhM}=Ys19RxNs=T;
zkmQ8+QyuzE)$Sc90z}XP2qz6*Cj$#f60}K0E!$a+Q3)ux0tr?if;WHwHevz^EF|Su
z03wx@Y->68*ypR-k->NZ2^4SuIF|`<?kts2o~q!oNRon2DlZ8X@>4zRrobHqC|LO#
zhyW2lV10OXpeiUI)$WWZ$<d%gf&|}Jva*la%Wa<p6D$-jEr>7!6{G+H2p%9LieDA*
z4G9+Vj}<_Y1P#6p4uB2DooHEW`$)ztlr2qKS}O$YQV0;x$tuM?-oQdCKM6kMj9hF#
zfqd3ZPAW4GnW@^me6|1*R)GkTcY#fq(kfsfm6dM+1YhbyX-1bo#23b{2tZ*=>x3vE
z!3snerDFvifM7(410t+Mq&Vy55~$b%B-o`NfX(u8O55d!lafW3QG_hCGoVmKb(obP
z0@Vru2tbG^W~Ft^5dkcug~HiD!OnZm?X)f1DS!jmqz{}966_+wMF9%ifC<q+f)+%O
zzR%KP!Ha2VmqH{U;NOoxV7vR;sjk4{_k9ge1DocRpTR$mxIm5o6Qs(Og*5^N1OSS6
zQLPoc9WGS?Oeup@<v$CBojtilp3UP#3xrjQUIGSdCyqQPfR=9g=LsZmtOqz-KmjIz
z;0Y!~?%3eXoDyvKmg4dSiv(~`d$W2USk%^%te-@R<~?peg5|OX&60*0aG<eZh#Y7r
zj6}0zgY~<ToHt{&TktWfeUyCBB9ULfg436;SS&+35=^j;9*GMaSb+%IB@kRjW;IJ>
zy%kh0aX3#&s6JSy{5CuG<zv}_lmU(d6vDxT2q3`<M6d=Bq+4HE&iHu)3ke|X*%o%O
z8nMjZ7j_=l;UFff6t`Uf1F&Jgvb6e%a-J8eBX|G_6l;W;62}1%B>9to2^JlLYcb#%
zyh;KHdwyGWNS#C}3t)r3@wM^g6n_=F$_5@={CUWBVPJwbBsC9f1PO>>vGie7PgaOj
z#mrY_%#@Ps3tCi*(pjyvtnjIz1rNTuO%yn+yuA5e<vbSc7L3sLK!OxR7?qK9=|hC$
zB?>dB1f3`?6wb3oh@25y2{Hgfxxqux@C<WoC;k$3*rEjc;^nt(!31k(M3OC=I7<|O
z5NzPql~<T-93a7xF(r_29yn3$A|wO?3SdJXu_DM2k2V4v^R}BsLWEC*%J^NCVgAD9
z1YkVKajg+J&XoW$4QhTU7807qrCqjA3BNCagmuEjj`{HN0U(tZq9QVi^uD*MjYR+l
zAY}ozV&`q0P;DSHga8RrYXl1rL9^R~rGTOhM#2hMND_<YMJsfxzr_nQ*e#}j9sQG7
z`#%6FA1nu$b~qgxJAalyg47y;0}yyGd7us^Qij6;11cki6G^_bWzTLP!tMvO@mO=W
z;uJ_8ONy!u+gC=vq#rLV9O``nOo##!sMZKv5J3V)aO=&Q2~~u@Su&e1g9u@W+W{bg
zH_+f=U9dvgsgz@krA0zzR9{h`jMq{Uut)~*km;;=$qrzGIgntztbqam%zy?i5J9Og
z5Wu*oK!Vjd9{B-4@Ej;sT0EQ>(G+)F0l~Z_N)hmAdl6eX?d))ArxS5Wc!q^_!j@nH
zATkdLkf8Nt0Ei%h#;<~vb%I8avjP@Y00}#rM^!=n$Fo0FfxO4l(g1AELpZ`)R16AH
z+cSYf$2YIZ9dG_&VVw{OCWHbB+}#%_mIP7|fn)8!X#<wCOH~j<+G#dn7oj22I>Fmg
zU?qsawLn-MO_7CPlgc1JtH&3OV=S<Mm#hT#G?Ni0fC*+i%o<1l%zI{O00Q`60Ww4h
zEnJ~wmBXb|L+Fay+b_b}VI|1m1tzSV5z~gOrv((GZO+rT0oZsf+hu(60-_``%PKHo
z8IT~|fr0Ye>=~++!|K^HFQ-d8?N<jD2@2lNMF1S0OIcRTl7Yqi!zu`n%6RPYBEX;z
z><%bIpOHa2HtoK9k6P9MMuVAEJP5NT4bo>u-~{EG7n0=xEKtkF%S7rlL8EdOItu49
z*fnf3%?Z3b_>093D!T&;+GQqR+7c=vtURej%Wh!87C-`b>43x<fdV2(trVz2kL4^`
zq@Yp-2nbQz&v-kWia__G@)H@tnRU=N8a^Twpg5p{G_9564R9Khz6dU86+0;iurgpF
zm271RBv@G^%$}jVLjqb@4lEu%61*KRS@}iS#o3aVBDLe;PgWl^g%YZsmJb1gHo>(H
zk^&0Wpn~Pnkrk({S_ue5S|muF?VSQ9EC&*(z7J*=2NDp0yUZbS5U7;QL@TUVI#t@)
z+0yEm9IAlw@@N-Y5TP)51{k+H4uCfU7c2z2%0bBkM(>ceKM%kpdiy)g*%~Cy^L79e
z#BD4RNC1TNy7zv&b!$$hs^%(7W@cvIT4w%7v%HzAc0C?Ecpy{(makA@GGkzY!rUSP
z+1Sk@!4h@z_Lr~{0EwC<vkX*4+rA`Ah$;f0U=8$XEfOpN2k!&Yw7zGTh_AH3faheA
zHO~>Xc|lHt8JB@g1y1o2B|;S6AmG&@Kxgm(jWj9-PyhnzU<aiDFa{Y8Z=wJ(6``&u
zLI_28tBArDU<yCLi6>~!vtc<a1_td040r}m@T02Je<FZ-R+<g#)>W%lzkaBHKtRZ&
zk3L$aNYSFzJQMx(*PqGv(=$?T|91PtwO_AYXxXaOeu4c%ldp;~E>XuLYB^LBS*{`g
zA%O4>>ieiNfn}@@RqG}XM@tr4I&<AqRrPD1KoJ0RSJ2mBac4~^1BLbZ20)NdVKp<i
zGDwsa@$*^ukg%Q@u$Tn{24jcB@}Mf{OCF?Slz7Yz8#1`)n6cxY52_s8<&j4o4aE7#
zg9i`N(^69pM1THy^n{5MQxyI_W14k1|I<(XydM@QSb%t30>!0y|BpX@Pfxmf^?ZQ>
z1+uPNw`-R`Q7^qdCgBS!^a7QPWDO)}15D}qM!12*E*}9BJvf`Tc+7A}(_0lsf(3Z6
z%MKA%PNO{hKu|%X=$HmHYtbqKpuqK^VAbA+?QrJQspo6dtoeGuf(47xekA$&^<ASz
zj$FKE?b>wVvjU4{{hiylPh_fU`rSKsFI@cPLV^jvVD0x{2Qc9XAc6DDSAhgCM&K34
z-_F(u*5Hb#=QFPzA6EEvkVLy>1r%ue6$Joj0STNLBumSeVcS3}#Po=n6H1gU*-}q2
z!sUy5ckd=&zji$(%lh!2|A64&;Ht%n6)OXmjs5)ms%lv%_V3+0=b1KbjFvo@`$yPO
z*5AH$YyZu(v=fmL5j&QwSdmV^U%bEsFXu}v{$=fKNdhELoGpC`NW4tJ7<LGW&GT#p
z77AOWb%8Wr9!`?1+k=#UQ2u7cV=UUmdwdyz1su@9P0@PN+SRM8z0k4acrE{j#It9k
zKbkvt|BC3C3^VZGvqz7j@4owP`)bvzhd)-RP#MnzmoEOYv2vBFi#d&tJpJsJ^*ggK
z{`md(l;7Py)R$cVAb<03k3AOXT~`#kk&?3W?CH}xH7pgZzy!;q6dVa86hf<mDUjH*
zabw7T+$h@3WZ7sLWM*apc<&*K1@3!U&*1(4{{J8M^Gx_o&NtoZv(myewQJX@+_wF*
z1GFmj_0Ap9r%s-_#CqV589)B4!Zsu}j~S(iz2<;}5Mp5+;Hh|7?nSpty>Nkps4&eq
zYu2dN2NdgsFhBu8M0mGub3K<bpcUc5&p$`ktX+FODX{w~@m&AvPt@$|dGA_M(ysCq
zE6(LORy{2eIY8p)9}{D1)T|YwaNhE~DmJF7e@XwMLBYXQ{rvpO_!Tc6s%53|wo<H$
zja~T0TW=-X3`~fyN;nfpXj~iJGfSKG_s1W7ROii+Bd2IpYVNFAA3Rk0JZ9KDjti$<
z)?f(=L@jZ!jE^8}J&{qLvMR62xz9<qfbt$|q{|s3)(I|vV#vUOMHha$_%lz3%6s?j
zUD&a0+sq!ldR?Hf4rM)CzGO+&Zaun>^($7q3L=<b1}=1f1WCTM@<Bax;6TgDRjRZs
z>F?iC&-Wzh%9W^!K|xWBzyyzXNqG=iwz(9067MLDKtcB=CrQithw?3#NgghfG$eKL
z%+rPN4Hv}^B|p@<qO_?CF(0$Cn&o5Gr+V+YF!~>*o+N#4Ru7lK-zaUOFc>dJW5s1M
zDKXnoW)^mz+bP4d=FFMu4I<upWB6za5Rt1cuMQdV%b<a;j=OjF&M(>b%2lY){&-wm
z7lg5-V2(W;S<AxN8`<L8tVN6cWdZ{uA9>`Fmrk8Xh=l$o-iazysx%<|-o4M@c3VR0
z9c~(09mw3`Yz2@Ib-;~jBV_(3lVryN&fs7LI$R1lz`zl%xQY`M!~liO{&`#_XQqf<
z2#S%kzg&prLHWLdSzlb`k5fmZa=8%xCas$p5H)*O!KfeVGgM2fk@XdO3|#u<;wzqU
zb)Y{41Q9EuW6~)=M4qy*+pr<yl>r0BdxDA3h7E@<UbwIdLjU28WnLCfYA})gNBz(S
zJ0CAua`fSY2j7Ej?wJVssJz&@^IW)dMnR9ELb}U|#UXf1t;Piv-zK|6X*3HUf|@pq
zCX5*qT)Iq|!dZ#I|6bp)Y2&4R`wwI=7?gl<Tk$>)+WQ%5oy>yEV1wPcvu4$C0au>%
zBgc+8qf;K0;`^#epPB`xp$$}nqp(PKZ;;HM%mVzVUP>J&AeG)T)u4UN0?nE6SWdb*
zk&%JrD^}>@`Eb+v4ev1o5xM@}uxWEf``DFpUL7*nJu82-2)x(3Z=W&4h7W(kr0gsL
zL9yappr8kIGkqUgDF*iMcjBK@KIj@$Ik<n0GA&rJXzjXn$6vp8txDN)<rXRU0jU&B
z-cbqjW=<$TLd5BjwgVH{4x0?WhqHAmD{b>;O$(11J-TsFP;gLSU|>*%N|kCGeR$N^
zv04A$OiR0T_s(yr$;l~~H*ef{Z04Lfmlz^aQnbvoKUEV2iYn~%^2n2}Pp_V(`uFSK
zxI)E>L1o;1;~x+ZY*gsC#*EJT|5{Sg+24NqE%o}f>z86;qK-zzuDpTyeKTQ-67f_;
z039r5h&ZNw+7o0|1Af#4RI1kuS=D%M#&4>UH=3m$n9xguJZ}2-@892Zt^V@GOVK@g
z_4<Xu%vU$P8#G*O+N{}1XpMl^&~IY@-o5QwwraH-0}ug5W1l4uCe8x_H}@}U?dsM0
zI(O~zf#)()VA-<W(o$2429zo_6M+X&%D@T`khC9C6iw8Ft8jb{aHCh6nFmRnElnLQ
z;cwpTId$9u{-0VEnmu#o)NyaWeU6cGMV?tVZ~A26Q6on+e!6w*=S!C<6U0LE{_*?o
z_kX!?;n<4h%fFia(MOjVl|L)Z_uqaS?k;N=(daPw`t>V+{rP9ch4beVH*MM!H~*7Q
zuIRKYi(N5U)Vt@)0k6M4{OP)N>poSyM2S)?>T&1x?bNep&;Ib~;{W^J4JuL<HcpdS
zf2*pxUhBnA7cF|vtsG7hSbVS}-Ts=C^nSVW<?DDSJbdurI`_<O9V#!n>$1jfGnBKZ
zPp_&|uU@Qz7jwesZ$om=f{QMXir$=k4R>e^9{5UMH{YZafP3sMyT9MRzao3PWJY@W
zjiP>juTWYLwO>%xud@G6JbQL!tvYpLNXIN<I;!`F3>;Ww=Iq&d;&`|xbUQr21j+;l
zWk(Sz|B##~L(+#?&sh3MsERX)#d^IS_)!$J_2)eInmyU1$e!=N@A~a`-_P&fv*&B9
zKm;WB;4fU;t^8)qojc>|<;#<1eE4A<#n@>N*>O`Px7<*X8}(PJ7!*|NnYL}i=Pg(;
z?bgkkb5}-3w^Hz(2~GVBdUo$#`pl_Q!&a_d^Rast)|C~AfCTeu-m+!4&tqagaew3W
ze!Y8_QOKPpz3ZS!a0|3T?`NYZC_X)22km)T{7@W7T@J8_n(bUOQ`SiJ8#Q`#E=84e
z^~wf95P@x#fD|7Ww=(<hB1Maq-mz_4b4)qO$_mPQy`ReY5C*6!>F+=JT2fLj;O-v~
z@O)Zo>I6pRq_O(ao_k}O#w8d8h;p<<qD)m^2^uVIm<d%gppj>AZQHu_`R~5}VP31J
zpY8&cKF>PC<&n21PJH*urAw1~bnRM3!Q1(fr#_iFib6EGX9EGf`}G@g{o1u@UBf$<
z!c>r&N(_R#BZm(5TfKJeJP5>i*TMabr=wS{To8Zk=zx~Zn-x*eoNlp&_QSX;v_I5c
zBdAKoEI%hqP;i7cYTxDDt5hlIInNh1e6fBfsU?v_QNg8*zyA6&#|Nu+ojT14+lj;}
z8!+r6E>yl^#f4{2pN_-?6M(W`SU6r%lijv|qL`so8wd*&0AV_Cnl@=t*sahfzR<B_
zU)})1o8W9dDkf&ys@RxT3R<Xi9y>9(SSn&yu9`Z0*sx%QVh6%oZ@dw-{i_|*n>20q
zyy!YKXw>+HZQHibgif^t3fvq(=e7pmZ2iRD*#RiZV0&`c0cA!{<2(wytXDZZHQ;v7
zG2_Rl5XvhO#gs)i({7&3{@XnZuP?Z-Se_`$(khX2uTH&sJG8*Wxie>;rvMWyEEHUU
z1?sL1D;+M4Je>7BphbcRB9oh2QB{hFjGTxAAfT^9>Wv$h@7%eQdh_PZG|y*+3l}OJ
z7+5x_Sg~ROsHS)L?OuKQ4y{|aZms&E4VI8Fn^j92X7!pmYu4L`j~p3$EI$4|F2BJg
z5@_APdFl48TWRU{?xiLtU%!0+{_nZI>F@6!P`r5YQl(0l4npm3*oP6bXGb(?`sCtn
zJzn0U(HAUZt>ESd7zsG5&fO59@KlAN6Wz}3+e30I^wj;7?S=w+@}&PYDe06OtY=vw
z;PS?}(WA@EnmacIV>0OT1i{3aQ>UPXaeVf@nzd_B*s^is`A*^C=XLs?<k)dkKIBe3
zwttd>4z2fa@=|RkgmlX>V)*bNH;8x#MX5li!nk8c_eMuW$E{tzJ{9G|(9$vRl~-!D
z3=3;mt$OvwX5Xn7658ry!g07ydKoL^o{^q@|3*skRUQrdH+O}~l`mh(D2-dl6<)Gr
zN$&=Y8ZE=&)7Ype2qFffl;g*9=i=jz9gCay@%;Fs$Ko<jc(g~?uBAGMcdpr_$&-z$
z)u_?P?1iq~dkkB<IurEh)$0dV%2p?S3Xk<$@Nm|yXOSSD8GDWo=yaRwMU(RuTrM3$
ztj2o<3l_|E&jtP`nB8FhhN8V~7iZfolCUpZu57L|A%05y@dUvnhS;e(hvyR$FE(n@
zB<DeBXecaKicWqiLs^Ql1(J3b0;@7+fr+%#)cVjGk$vy^zrO%2r9&1jUYu@H78D*L
z;Uk)@p@wA@8An2-Rf9FCz_msgf(Z9)*%U;aI+3t<+0tb@J$54)<(sR64<9{x-~Eeo
z{~7;e<HoCIMnpW<tVN6GjJ^rM#PPT|;8wg#6$a7eAc&|^t$HK{FfnBEhM}Q_-+beZ
z1}}w&cY^*AT4_QXHVg~z)M?AcEnCtw^3(zmE&KHEKiJGFbYTDfU5gei+`E3`rZikW
za)ZG%_ivy3?|p7i5it3^_d3_DU*FLG0y^LROI5+ky?g(l(>7Rq{?IpwR^YQZs0+{n
zi51J1#!j64-Z`DR7=^Jm3WKfcq%jJO%~fIf6)P5)%OY{>W;%t8BL*3%H&SzfwqnJK
z6*W;ZPO?%k?X!SVr6TX%y&LG~=NAgE;TF*kr%#{Y1`?Agl{*is1XbN}d?Z*LkBsv^
zt3#V?!^GXYbO|s65zs_F?fv&>z@-K+5MjmynrqcZjvc$-x?Q`CPd(LY%;AFvcN%2^
z74QDNdwZMY2{e=vZn;p_!VTYxPe}NE;NZar+O=)_!L?t1)orJK{rWXT$#cQHc@4}!
z#N~^Z68rS-^<LX&pWWmJ5jQc)t4R=4)C&n&`f|5!qpx1RY`E39N3UK(KV7t_v4Xdg
zLVHlCDr(>0_(WhuZuIakK;6czlaHz>XlM3lwGj^B(c8k#!lGkJ@Ca}io;my1yKlb>
zir9dAS#=*dcFZrHH-jrzu8h#<EPP+=v<!y)&GBPK=Zb<^yhMqx_+v-I7=DA*ZVoE4
z%Gpx2=$n>;ijP0}WTX*@fL4g-o@+mO@{}p(SbrOu-kY^(v1(;>^invh)=SqSEUf+f
zxpNyb9(3H!A8`YU`>zjsZJ{nWY7pAMtbpO2It2_IG{_J{Y}vSRRdAKc5gRsbP9p#h
zhRPoTib}!3Gt7Wq|5sjl%?&zADQv^ED+)b$z;?FOQ83u`QFHGaGK*ECm;eezVZU9G
z$@V(;#A4UuB}<OU{wetWOt{t`nj_!=#dB}KiEFL0a%nryw-+y2n!bO}-dvX1dLf|`
zh7TK7l%TC?`h-Q>0Tdv?TFK%bn<@%qkN^s5N3`#D?+%AM3XDJmv_c@RwUa7yrSE_N
z`^JtQ9bp6}1`Qc9s9}T9!ju97M~IRr#+-DUzub1~?CI0TwGx#s6IjtKzd3W~41zut
zde37%|9sg?UAlaYX<b1*peu*mKyT&hm9d}cl>>s%S+i#kMX&^zSp#T61Zv&A6+OyK
zpQS)IvLX=0a$u;uM1PM|8RtqD8x>XG^ZKEm2o0dXwNg5cTDNPL08a?bzJ`%WC%yOH
z0GsiHtt=8Mqcld!Uu(URtnwOXBJgN~CXE{vfj$amAVL62&iZ@d;>A}Wn9zFxD%FS?
zGuopFeKk|nQC2GHAyBy1j4VpJdiAPaU5xUZ{LVWyD_5=dgkAxnmM>r4f8fCV3i)!3
zVgev?UH9(WZ{OBUn^x(40B+lz_Wt{|5I_V<j1=1bK(TUY4-&N9J~Ssn>RCrv0|?$b
zSa^dLs)L@~<L(9qPYAOFaMWK!^x?Fr>phn^U>NPi3l|0w@-<0Ykoqxk0TLpt1tiu3
zX5fN{<s>p<W_!IQ4d`_~Xwab5gfl-<lNNA;iK`peuV1bAVvCkx?HY!L7O_}BAPaMo
zvr%;0Z{VO;U($OiAwGWJD}x5@qnu5lS|xI>JB5eufIC9;%GH0sfN&F~O>34X^=DB~
z!3-u)!2v~PWy7fh?y?JSp9K*<5r%cE@kEWvo;QyjJC=ed7g$@K9A%x*TH@%|qsIUX
zK&2xr5_Up^RKUXJVrQ)|vPLZZ?6Z|e<Ki<g2N2H8P!CXmF5S9)4IK#eX7ZEXeYd5J
z0Yok;Rl2l4Zu<=#G$=^V8UeSj4jMd&<a`I*zR~Qje*OCD`m#W)1l;|DV3p8TzPTe?
zQiC|sav*{%Ku``Nq016<q0Zg`<@m-aBMw-=wx*OXU!h+1-!RJMyafwV2`wE?j}?O5
z{&0!o-o1MX+1GGu=qK~%mnE=3@H{w?=v`hw0{0*hQ6PoZVxi*J=l>QgXryP2fJ+*a
zr%Xv?H7i#L))-eTU$#Xrant6_TPWtHdRtI%<;t3X;NpezKkAj!J+s#h@%zQvwQJ&!
zC){V;H^_hjf=jr~R4>!sefor9fJc(@p{7S!LeK*<r0w*-L8l#$0w5?(9zGdPpH-Xs
zl9Vb_ItNIkrrbD%VGUxzdv<CwqH;v9Sdq&r(X)5&{sOHMES5I_3Xq`jap0w(6%7zT
zyOfdjo~wXM<yh7%YS5@rO}&gZZ`!=iB8Jbo_x`kLi4T=+9)dxiV7vxK1Bq7{W@YW_
z)$QEqUeh9xl=SOWz3*49QbpGq@$rHM$2kZsQy&S>dlM#1*rjKc2nr6aMLF9;u>_zv
zjN(`Ya6uMHIBAsanb?QwaS-I9$2!U`7DL7J&DUSIedLixi)7zOOiVnC$a}cfDXV}T
zcY5Qkx02zhpqN$(yVo076_Cm(IF<J^)ZkL8z(&<8f1dk#0w2bUU}TM;X0km$?Afnp
z;_uhD&lB+p3CH#FLGVrBS|2xvXxqJK&mMY-Vq>BYXx(oR8loE=^QRvZkHc-HI(6U?
ztxr)jg7?7i-ihbV#l!d>-Y>%)KusDoEP6C9J{`C1)y)4GDOucO#0_UQ51npl_|x$H
z1`QiloHA+B{}Ml3lJs7hgwZZtF7Pl-ft+WqtotrCJAG<uYDUDYSr-w@q9XRI69O`s
zZVzqRtXZ$@8*o`;_N-Zl5P92aZNZgJoj9@UnYL|nB3^dw-o1+(U@XLt6)0^<)7IGU
zk^%|TD3!R;ELlgtBnB4`1q&+R(GBmdx8*bG>XmZ>g@fU}jT<-oIN;S+H8ZGPyAIqw
zd0fHtATH#lx5tfpf=8wN{rw9ydGg5`b?em&)w4uEy72SQKYg}rd6L$%4(*@Q-HLl6
z;lz&w3Xdi_q%NR1bNY0m7Lb6{>BUYJ-9RFd@cV#rjF5(8MtzP{j!xm>z1=@%ymc)p
z>8u+_OkoHPMMb~_JY~nB0|z?6vo&(85ogbC`D)j$3<~~YRcDn^JF1M^PB%a3D{=Sk
z-GuCjmjR_pK~S-X04$L35EqbV#aSDqmI=L%2b>uO7fj^bgCUUhGQF9Wb?BCA2lLeC
zFSqH2dUh-70FpA5t5BihjL68*R-t~lJTYq2$Q62nq+0dr`T*p@g`1RuS7ji0vhq9s
z^Uu0vsa&}-3{I7ZD+n@kZ`s8yH<L3Q47PvzvJ)P!GagW_45&UNxvWgHA|fg`Y}_c9
zHDcVjaa#o{E}yexT)ljGSM9oWvw#GQD{=Jj;jku6o9-2CO<>lpF3!k|RKe?Q1638Y
zxcNr0^hwKx<3O7Ae`sikE|A!_Z(kz8x44m>pG3)$CH$Q@P!}&+^!e6p+jW(2`SRs;
z>osl0j2{)g@dc3InKEsf?($dJa^(UjlrYLxRn#3qtQ4Z%9O-!YKd@>;A@LbHv~OSJ
zAH#>g>**VD?8wnIJHOtY&Y*2rY-_gzpJ3CxxpVhDc<>;n4J%iv(n2ARR%&@W@!bBY
z5<ce{2O<}^K-l7`cc71mGTZ8$5GT>H&p!Qp?1TvkHW4(ug(S^R8eU+D#OX4>6X3{G
zDEyMA&!8n@^_n#wdM;_C-AFmrA}nmPLblridk2T!>9IBf1w@v$B`a2>-@17-=P3B%
zk3Sy90iX&a8X%!^cn4K!qgWuQ6fpq63{dEmU8QIrBS68by;=5~t$@z8q@=4uUww7z
z;May7uvt0n4knyBBlJZu!D1JSAwWQ(%^Nl}e{1xp>BUQwsFHo}&h6X3^y$-QhJq08
z-6Dled!~d?zD`R`%{dAlE^mCddv~Z)$5=rF1wm2~U8h5XdpM4p3PriR8AgSk+?e0=
zF1L4ia`{PkdWUNO6_yH}*6|g0+pn#d90G{1wr~4}F@RtVK5*9~Y112>{s}0)XB%@W
zBp7}4W?EXVB`n}&X>@svHP2@*mn-}KoShyi$;mf3Oa?^GkV(Fg^Z&><-z@#^q<2RK
zlrB@xGa>Yg_`ih<7wp>o4T*!LQQd^?EWm6N7Gu@0jBt75v*pXjXJ1#VUOfb|w27Qo
z3Gd;y9l$9EukD|-yE<@yhFK$$Me53Z4u_U!uwMCcz{KXwn=ZdSaiV7aEnBvP+d>l=
zwztthH3fHi+dpsJx_#3KVCgLnLE(P%@Zkfr6{{Z-5(*tRwVth8vu15{OiaR;+qb9T
z0)f+~PbanS&_VOrq<7wVV%m%uBDd!14(2J7Ch6{cIeX^J71rNl09b|6ri~j9y#HT6
z5?x;<Mc>k?XUXKDoJ4{Wtk@A9J9H>AcHFq;b?Ve^>kS~XEfGC>bf07bB1r3tqPTGs
zBkE2LlspxMqvIl6-uUR_kIxq=TC^IxE?%NUhz0z^WakU-I1;oL3e^O?;((Pr?-nRf
z0M`m)#H@Lg_n{+4bq8KRsZ#z5`|YlZ8Mx8<-b)=j>N<tqx|M5p335z@-)`T&*`Z^{
zt+W*xGH_sm8?{f?de*Q}qtG6`dhJFiQ=WUbZ{ODKo2pf-+Qz}OO4X_cJAcxC7a&|j
zfC!f30CkCx=V`~bpbhKR<vOYJ!Gi}mXVTQGU%&pNk3L%D@yCl-(E<<I^y9g6TWZ#>
zy$pd5NVhKH@E7YC9jG&N)c(b`4&3?ew-ebwB6~Zi6G3c2%E3)zd0@3o6qSjwEEQf+
zFI5u+rwb;Mu3R}=p;D#V-uYLoSg{rbIKmNZzyMffJqr&H*Nwip_lG@+lt7M(+^GF(
zzX1bww|e^Nc6k(j_3AZXRLh580_#vUxHDtw^y!+<LPA5J6=1&|6it&SpKPG_%xFi4
z1831Jmo8D$`Lr{0c(-nmr0-t3_{%qQXU|!)V9}x*h~piY$Vw4b7+kA_sPUlt?*04s
za~*p2$^7|&Z@l%^bqX+M2~XSM&@MgmqtW1JVTM#G-qV`(Xq8F5e*K!J`MG$B5~Ze3
z{h*df{=C~a>;Gq3w`rmG^0pmcT~P>jtGHZ1)o2%@-&-T!+Ty(qo=q=w?AWnEXvkwG
z?Wfs4*M9v~vu|oVQL{nA2BC!z%Epz~8Z~H8$UPfusP#<mur(XZuxZcJ!D?H8zNDdG
z-gBz8g7oCo9Lh*fzj6KA^-Dkf{8I+S_gPOi0O$5%X*JQipT{XR>FU+<p4WBi)CpAB
zg=Du4kWe`d8dPT{9HE4|gCpk}(b>{$_lRmFz}Bw$*B-shU+nZ!m|`9ugH;?1&Gzi_
z(o6n9m4h`c5-_%e*TGeJ$^={hr%#A}#}iK6pEq~za;*=*Q%YlFVh1XCJ9o0~A3k{S
zfL@*>-gvVihSFmNIC9a<h=}%j&rT#9k5~9^mF5j_nF0z0Zz)4X80%*8#AgX^_iWy>
z<)E$Gwk<gx7uTzOyS7CX`<ww`^}&Ix&H~BGXVuD;xqw84iWRFlk!M82kw5_rX0v7*
zC95kC3K$&P<q;y=EU=Yo^#AO6^Df=FeOvRW-MaPbKQ-gS4{H$u7aBpE^Y`43<_*$&
z0iMA@2^vX&gC@bHi2Zx_ey#PacHO!S=FOfHs_4i4(ELtR)aS?bzSpfskDd)1=pI<c
zof<c6_*k<REuPhT9u*aJoYSmVrF@Q*2IL-JDgqCYTHRP$ORTnR;AtxWo_GH`Jp8?o
z{p-~6?>$z<#Juz6=FK0TK6!E#j12*IWq7|2gHVMwY}oV5?c0~^+q0*W4Xg)t`7X2X
zK!;1u>&G5@tO%p>2<-!xAi+Xvm0%H9f^-m?d3T#B%$)L{K7Cr(D)H)|L4BJweX=lu
z62w*3rtKLU6&0pujesGh7ku(boGAkV7Z0a3&EJR-BeuYDX}#2c;43{fmLm+mv-!(y
zsd^DTp;cnp(q%m@5QbT0kBNyH49lRE0B(8Quz7PT>9`CF3#&;vmXVda9)BSMe)Dnq
zzg<IS%b_UG@&#?(wmrR1|NbXm?A-Zay^xSqrOE_OeDu-3_1v;?<8<g7p#>;fwrcfi
zN^<hFe+(U3+5+VZDBlsiWtsO8;EuIOh!|`n>zX)A4tegm4B|X^?C8LmL2G_*{P^+P
z^^SusU8YQsTVeG@uu9-sBn;c<jeq<jsB8D`z4cx`bl||(amSC}SLn?4D$8GdLPEyU
zPe0RK;wVwFWWa)t7j(j9x~R{iHtRiuhh=@fY+0CK5TQh`SP`b@8v$wR)DJe9jE}5q
zJ)ZLq@DCsW2H0|;dzUV{yI<1p-Mh~aSfBs}RKF|QHc$o2O=k2`moA4YSE)Mx`S#ED
zK6N5twYQbREvxFz|75{OGp0_htVm);?#WTk@`j(EUsWg8f!ET8YVto$IwPwD${8Fq
z)(WHL4P6II?{o(a9lF2m%dOFRAE{lp?o($@oqCPXDq*JN^SnD^`0$`vbLPDLSfN6i
zGhTSadAsMH+o(`1MYvoAxd_pbW5>iNo;@3{^{ho$So?oYnp6{~%rFK4oZ;(zZ@{as
zzUo%&Em8Sq{@l3@cJJKzlGbm-7hgPU2Kpd~==aJiy30)m_wV1eVbkU`l<|>z<HlvJ
zJgV1tq7g%7r`s<5`t@t9_tMFeCod}u{7Jmxn4riP6h)sed?EDe2hY){AKGB`s1a|C
zO1g68u(x&M?Mah9+PQsu8wml}(1XAJ$^mSyf(48EI*?E;W_Z-41v7z?^D{bYL&Fgh
zca1;S{cb&8{vK`xH31XDnm2v22x^{)7Lr_b|Gxzb8qJ(F>m5B10cqia1xrxB1&q%t
zQF;8_3Tmm|635VC!+IiEaB|%nGGxdqz5KEiqFb?V-mu|W6w6R_OiW_K#*JIHZQuSS
z?_YS=uD$l}-P==7S($+d2=GRX7_kXeDPFs#y<-UW{i@iQFa^&S2g!le^G4WHPw6^~
zZrQr!Dkjh1f*G865~%)LjtCXc3Q#Ouyg0dHP|$QYcwOfGtbK<LBWwgFKtB1V&sZdA
z1`>@`!pLlB7PU?n5ELw^A4cP$BPQ-LgQ4Q@+4JSudXAUbVB)K<c1)iY5mAdmxN0iS
zW=}RLbmY*%KEvL4<1Hf)@%=a7Y@9r0$~lG2js(winS{SQ-#iu{fB&1Wzuu(v!E)ux
zS8_jl$$$qm^P4bkT!c|YI)#V#PCR?|&BhHI7BW(#a5-r5yYGIi2TY*V<e`NlhhUyC
zZzB)^mnmSr?y_bmXud<r@whnMEu!IFy7q0_q)B0l8Mxu{-gmoqhr{J2trwH8U%zrR
zE<Rmhyvv2c(uo5GXqP}lfevO%Rc@Z$5;1MsDDR~X2qyCJG6%DMEcnPHMV#IkE{+X|
zGjMPQzS+!M*8<_4-e~*hL;ne!S-&Zu*njX)M#PL6v-Q@lA;I_(V<$|Q46PGmM~w=?
z5aycShmM^8TD9t_@4o+GUX!NHo;S+u)QN<>t=qNRh{Fpm<1Ms?fB^BQ`Tk2?y6n`8
zrO>8byUtz1JNx5&$36SHyfQj^sZnL0s8y@s-hKOKyMan)4?vNp&E0ujU9oK0QX>n;
z@L|JX*l!hDI$)kKZ=-K7Te4&+EF+FW`^TGa#_91I1e05~Zk;&t%{MC%@Rp%+{r=l;
zJ3rI5ZMa^!zTLfhCjnoRST1Q~iONVWindm$6mnRX-kCi4mpL;dCwYU3F%!m5YuBbt
z5sLQ7_mmyk5|XFCgp-KJakN_ZfXO|*XJ+pM#rPyTt+YAm-HIcmcfWo!v?{k^>C$&!
z9Wvy!PW^yMI~c~ee|y}x%Kv=-{eK!+2D0f!O3LMg`1l{9W1^3(T)id@rDK{mYg%~F
zz=5@!w`ke8O4X{3QNDBf<jFntLPD0{GJ$*M*+olfT)lkxT&3XP89bS{dzUT&(Xp}9
zwCacX{hX+LZk}l6=7}L@FF*zT^G`p<?fGHP@u=viME49kkHUt41A-d8_kVZ)^k(gz
z1OZOp0R#4sC=$0)4}ZFK>n=twT=@CtV{ylh#c$lW@$8y)>rzQ%0o=yiwr!h6HEKN3
z2!dg~gm8JLq`&`YZ0)G3(R$X6zyADFGjNjeL_uc`<@HX%f_Z&?Tp)KFuZ&r_WaQW}
z7Z5C@q7*9XSsOq>JC7sh-i)bJt3dDoeI-0()af#Tfs;%?gNo7DTRh~_Dz{u(tr#y|
zqgb6-?>=OepS!y1x7im-SFS`=3<`=u0Kho)$Jq*v+GgAi?J_%E5)h=<3O{Xh0;g7Z
zR^5}?3KS@S5=R1e@R}Y36ESPnMYoWfGG^Sk*Zl(mf{ikTyE@u;=+GbjmM&X<KP@%&
z(%rjvQ*YnCoeNYHE?lTksZynb{rvn&83}SN`r*6pHayd&%?2WgW$q)vjn-}0kUC)Z
z*Bk%-Vy8ad&)kEt)|Xp0Ki9F-OFIyNb51$?^zXm-?wvdLUl}xLh!FsT&+3JQwt~Om
zBSvH?w15Bc@B0@noKN%y3|jfXdu9L+zB^&uxEUWWTzHv4Xl31d`|SxkHgDP52=bBM
z%T=paZw!Audi7FPxW5T`4Bo$Z@uKe1h`+yoK(S)Q0v`R_--;OJ?M-Xftcg|74ogC!
zz_Mj4Sv?yoRk~CW0>xz)GLp4gmWhk*`py_M^tEXoGOF$uYyZ`>TaT9yTV#z;ZP=zr
z>4pp(Sk$3)R9FEC(z7^F0f!lwP!#>sIJJb6ssk3Z8|J_M6RJ+WMs+}ncRnLB^3whT
z`=>-jN539ixyq9$4GtBL*0~*|1QpfFnCQiWUmF%jnuqSpj;&zT<uf->_$nniIZR8L
zwQcuoc(W&){BY>V(fb%Y3zr0r{rJ;QHzvIE&TFWODmxuU+yp~{7L~DM#w=O8etjCE
zV9{(}cyL_A^y!~YkBFFrVwv*fF_ydr>FD7@JBAG(e$1qwebEGNhhxcEO%heNyg1#c
zag#MLSXFj{=R3Rr{d*2`s-shZf+_Xx(<fIX%jD$b3yjJmw9Q-=H9o0BCCYKYM$dAs
zyK0#&b0iu7G`<nu-^=v+KkM&3`}Sv4u2OZ@%IN6Gdw1{L5ZUq2oZY5P>k)3Da7>}w
zMPbx_EPN!i95r)2hl)~9DaOXG9IBC*={M&sSa7*)xpEVswZ_P&g*Cx%ZQHtKWu@TY
z>245_s?hIpQ9k<k<4cn#PMl`s=*ydSY}*#|WV7Zmtoh8Q$^{oVu&yVL13OXv4H`9C
z4bSArz5&B(@7}qyjnih*7J-PIzIIQ50&`6uu3SlWqGiG*pixzV!G_~Bg|x*_A&Zxv
zNBLubg-nF9W~J#nV8D@1FTOa|J!4zTTWMWON;*4t)~pYz)u=K1;Gx4A3Z64vo}bI*
zQYi)!sq)B`4l2t1d-tx_N(fE%OFv!QNI`Jm)cQTsrp@|+0|rbyYY?536@Y-CrS&sU
zkAzkhh3%HvtWfP8Ug+@7u_H&m5-DKdmgjM!MosL{u_H>IjQYj4q_ae-V#+yQpn?_P
z$a8P)nl<x1ubZ`K(NloZvocSb@bH@bTBJzPTtK2r_wMJN2)<l`I)nsFpfb8@0zPyB
zg?rX)CLB}*FkuE>GELHCJ^y~s-VFDQ?O%lo7w-4v=FJN)UHs(;t4@K|j)eI5?XUFf
z`$qYS72h8-e*75|!EL$)6A?%tZ|Ov|MCiUB_S92fK*v<ALUiliqhE_=%?c4%m9l<o
z)~&lyr(V6qEt)kQ0%z8G-=QIBJxNJUPJ>Gki0y(6x*%|D(zI!G-`>4O9FIG;otK3I
zf+9EY`T+vgia|kBA&6lBG@UeKB|U|dx21xqe232H(9zP<DzSXYlDeD}K8s1KRRBi!
z-Nzp<9+LgH#*PhDU>T{1#}Tgp@mm1neNr!EK==%$eQ?U8kmUc&Q>}^&9Xhmby?XU)
zm-P3qT&{fiIw+lSGcE1Xy?b|WT>9nW*>Au3=FHR?GcGA~N8su)DiAOrfeq5;N#DEY
z%K=@wbg5mdR_)pWrAh^%I2=L+3ms+k(q_eqm^g77q2k4D=l?omjvE);rfr)#<;zzH
zdi?RnOS$<h7{!;u+sgItfB%t@oSbs`(7}UeM~@qKMiF<A5RUS|v2toz3{V5(u>cV)
zc$Zd2nac9rJ9oBi+rIsX?CXmc&VO5_TJ?D}eW|MI*6bS(cWtav%;OM|0tuG8Ik5ZM
zbH_&V_3K}hEmv-l!hgpGYFgxW<8@X%3YY*G&lE((j{+Dx@1uYj9FT+x8UR7t<<LJT
zO{!A5bm=_8e%%-AE<wu%MmzEn?sg@Bc^^9;?_gpnDJl17fAmo<3&#1Mei{vzT(mNP
zR)QB^c;RgrR-F@oKuYseSj)oQx^@fJdma}Tml_otn@ZSDwC#*jZ<28RX3MB%f|z96
z9cx|`GTDLu{Q2j<S7mPpg?<x7{rm>gOe$;wB)G>B`EK{_&}Z7Votu4q?8uS#nlx>?
zPr(bMMhhgEw3%oi!5U0xfd##1DDfs}ttU9h9uT$*D}jtVV^kR^3zcE{MOxfQ+DrF&
zi)PIVZ``!$Jw3|=v?v9XD)lx80Kubg>;_6vqTiYU4b-Jm)*yn1b&Z!*B8PsxdUayC
z3Kg1VUym3*e8_@Di&98=O#?`*<OCvEjwNg$;cmC#?sn^%ef^K2Lpm*9vh*GTZ_)5O
z7x3lcFnCD@x<b(aD5r25%`QmKw7}V=k%{mPBR>q1oezpheKHNcgX7mg74BML>??ur
z9&OY_9A6U6avwN!D1H3cF|+hf=L`rwbL!MTDC<BKIg~*^G2aPfQol^E@s_EWJ4ow|
zR~$KkYVANdvqSG4mT8&G_RE(qpYgnI(4awS3(9E~cqX=Llqyp?Csh8ud-oFDAR?VZ
z*@TeG1|4J<FrhFI$|yo86H(!tDSB2O@T!A<B;W-XK=DxCYE<mX8y`%WGDUAt)UI3i
z=`9;KK1~5`SSWlNa7Y6vaK4+VnD4AoFvlY8L<48ygz79STDc<6>J!hM`^EFRag)Y%
zIVx?t5mCM1vc@BiJesp(<Lc$hyD0OwG?qj`3mYFGUgHF{(#uEBNzf?rrJmUkwQ~Ss
zdQ~xA%0NZCX6wm%c{<%k0uT;#l`tPbkw-3?5gB>0PMtcDHJ+#uto1ywY+%6CPqixa
z!=AnONz9FcgbMC=0gJZ7{4S}}8qTSrq$Xq|{z8#?q-o4#FfzS5WXP$3g9lr|dyWMd
z?uo*4p4SULp1+S^eA}j73)-yVNx+0zh*z!WW&#ZrSfF$yN@PsbK@BJdtBL@ONb?7R
zga{zaA28}mGX;pP9AOL*_kTwiS@VR=s3_W;$Kh5aYv(i;PEr6tI<cTp_DG?x5x$4~
zzF)Cor8xjxl@pH&SH>_bcIh%@a)89mw6q-zmo;bsw&Q>VF2d#kCd@1cEI@^4S%8Uv
zF#{8%mIPFVsd8do-Y6f(D#5~{z`H$pg96%q2AJOfg6fN^v{9qynmwnrLWlwrG@t_s
zOu*e5FpdQLyJ(RjrCE&)lMwulr1z#w>FRlX>coj%lokioA~_-iNRXJ~%-&%QCiK#g
zAXuOwa8Q<H%)kZeOdQ23fV!K8l|@3-Y?pKv4+!gsqa=C9+E6(N2GUuiXg**$3q!GL
zu(U#Gj$c((zsbIF=l1OrkC!Yth9j7uwNm8J@AorOvVjCg%ah}2*pR_R1Iv}`>H)yc
zw{F)ifq=iQTFSJYMFJH}pw85Rg1?NR=%l0R48Wi>Ny?#O<^vcq9<K;&fTFG_`LX~Y
zDucdb+1{$fV_C7;_em8z?QzUF77`Mrj_N1IVv=VngFTNGPtVA>VaHjs9mc`ClO}g9
zSg>HuiJzA*UD}|qTVfEgEUGyM3fj0MSbzxy!8(BgDD;#G>Rxb_ur9Q-TpWc1C>f83
z0%hq0OY3Y3IJK))Lekd{QzDJhN4tc9`)yi44j89LUDn7ohKiRcQ6&dR+)Gap%xkRk
zNA;b+`tB$5=Lc4(RB1r=^<RJenOvt{y&aT!lLTjD-hKrccP1cYbd+~VJ(5YBFj15N
zDX7pBG`PpD(<m#zftgf}1D-{BQ7sB2)*R6m2@!2h@~-F|KrAAA;`%g@ER7%&R4&=u
z0^Q0vL?K)5RWM}<&cp;~EUE(e-1gMBU%%HqulMiS8;J>6Y5AU8TieN#1*LIt20BXI
zd)z=%EaFVy<Utd72{nimtNr~f0!YyYmZAyJg%fNFCkPeKSQ#qA@3Uy*Ob+$O<z199
z#fo1P#rQl9Y`UMGk!v<TCo(cnv37aP6d=V$Mb-1XK9P`cT0x7A;nXAJvFYgH!(nb<
z7?ynv15mYY*X}q6YXnK3Qj>_K4O+x&wk=dKdB@CeLNTyLpqjV<!%kvpEkJRy6pdtA
z&2n-5BxoH@QD$9$WBWRF#%5LhaVI7;lNe@o%*e<%|IiYVMJ>a^s=EJ6#<VK1ut1<J
zYh>N4@kEWvo-ZaGKc4KXRs|AXgbtRW4I7U4ytgVQW+o?#n<XcP7PM(c023vEvsDt+
zZ$d!?5oTZma2z~<6>~dzU}B^Nn1BKooB)Tlv#<L_paMQyfd^0e?YG}9l&er7=elCW
ziV#%nX8;gr!G*58tXL^1Cz2)H20DA*yc?X`iKVkK_gE5<bLM{F>0p_3<x14B;lq;|
z0sv8yLEYyr3kSSedRBp6%$7P-lQI~E$2Gb(%a7Eo%OW4zzO>7armQSNjb|$2%(PZ6
zGl)1(g`_+<{XyHN3Sqxu@yFLYcjej&=y@IkXSqyd!RgqcLy^F;Wt(ST-@1A8q_oEU
zkFH<4_PU>+U#JJrI$tp;=yQaAU}=p|dAFC{qkW)&2~r0s+=Fyb1Pd=ACQ1<VK8%TW
z{hzj6H2siC*p@5~8q4I^x4ivmSb`L@JZV9gVlsIk0S;I)Zsgc8$xzv3Uqi>swX0WG
zWvmEj&qB(%HzOkACC`T^5)uwGm`pjrN@x1snNz2pcY~~Mp7*}py?drj%Fh&3xCB;;
z>AqD0#HAvD2-4Xu4yeEdEI9e{uyF7M4=fcKtGduwI9SZ?MS(-RSW>LA*r<pT1d<5`
z?JPFe0Zvc1Zrzp9%#-wJb4>@-7ytf3;mTF2wDVlnc(HTm0~i)&9##}vOnlwouUhT8
zb#wVeT)c38VW;r$^Mv&w>08qLvFq%zs-Xpd36kwwW+(jd02QoE^*qePJWSO*l>{n4
zq0PgN%RZu&u&?}h0|!*T$)U)Ih+MG+;JFL~`}Zp<XjucfoDmT-J9|d6OgwjP6Gs3+
zYCRE75JZG`>o(W(-ksaG_f@G@{R;x+Zx?HX>g1&j5->qyoiGCsxTbQ{84s-$gU5`{
z%9$c<JMgw%i1dx%-L|6q8h9_&@!~1kt>375<y<dWu_FCOO3Kb$N;`7a>x`5T?TkLF
z?Bhm{E>r!98ac}vfBp4m#{2J2+07b2xLhtShfGl_SzTR}4I(_9E8$YryAvnQL<Bt~
zRwJvd5taf8m4V<yxrb_<P!R_?isL1U5W)o!PM$SpTAU}X63+DTw)F)N!O~ho5>JAQ
zEL<JCGRoU3;pHnqs_>Wqj0x|&Gtx6G_R+&fKHa))dpbu2Z>zH<j4TnJAmYJ;2kFo+
zV&US&=?p9<R)o^F3`nQ~Dne?Vz*+;u1Qw*GZ!-{~%AcjXS7??<B#5v-P{0B0G*%%j
z<p7;7FJHVA?V0fTzyE!L#u5jucR%V<Zw{UR>8GLo0Ri>1uWzQMoov~v)ou%yEL0K7
z(kNf(SlPX2&(FL;#8+Q_Im*i~0@uHf_f8Ea`r68+4PIb^Hs(I5S(1g*rbsJ<sHF&}
z0}jPU+sc=S#vg(<3Mxq%k%WH4j1RwnA+xiu{rvo@YAkV(Dhi@d-~0FOZCAB=_0FD4
z8nYuKKVr~NtUv|p38^XldiCn--j0<JL~Px(X|xH5AT6t{tPxfN307c&wRM72$)kV@
zm9b#t0T>j;8On;K;;<r)h1KnvpPefeg&&Zlkz2WF@sg$Ko7Qi5&wGg@@$A{Im<pDO
z<2eKoEyBV^du9NaG$LlrN+ASLxam|udIc$8xYU$2TzNRu+aI2tu{C4NB~g=x%9276
zMq?S-t{B@GWI`IGMrFxGLy}xE2BS@;B4IEQ$=1+9qv+-m3dz33OkGQI-S2pQzdz6O
z`JT`Dob#OLIp6c1_k9x<hKk3v-KR?78ub?z{xw9<Pc(I;<Q{~S5PUUMeTl`RE6(p<
zziJcZ;Y3&Xp|umRqmF+uom}Un3S+)`wr4V}PJDh|7b3s$?XR+rs{l>@Xl(Njn{sMp
zfs@I<YP-DCg07nY@O||Vu2r7yIinl0$kxPX+j;h;-Z{m%IQ>CiSxQip4v@k<zdOOy
zbpS>o{n0j?JH=1-^BMf0cRT8X@=*PICUM*eC`#Nb^Q;`jv7Gg5a(QRF^M>oOdl%R}
zsd)yPhoM&@SL?3!V*4tb{byX%J#8OUUl#w8&%D)~Fi*vHeX#|wv$kUV?yEUSxpX5|
zqV42Km8NXReUfFTFY_9jCS?J1DbBCVIiK=+{c>zY##DIr;pv^sGVg|{jX4aJFda-C
z$gsx@d&BhXWqzJRcljMEeRRN$^<4ml3|Yc8_b^+X`bVSgY~>SI@A@SdYOfH6Xi%3N
z^?&+edQ#R$I+(2?f;Oj-$zOi8zRyS@B_$*Pjk?>_3EOwRaJa!Ma=N&n$@tvd4J8Ck
z!|NtT-<w?Hlld)hJq=s=_2!~P%mrL6cU)s(;WBkLhdpPKFm=g)8R*VE`;eH}b<xx<
z7~?CnOU=v#Zl==~PN-yPDm~B0{jQj~d|H|EW1oWs^J@dsEuU9wVbWp>hCMOlvlfcP
z(ZN1^7V_bxjbEdgg8&#Hs(-4n_D|@Cl;z^arwODBPNr4~DdX|ae4gHSEB<|+yngLg
zd{cqCMGWH%@HQ58VD7g0xQj<*+s4do6`u#e<rIXcbP%rU{Mr(W3+Mnf9XJ;@9FpnY
zJF1Yc*H$LS>}7XQcfM6JEgzOq00hO_EIn1hYv|ih;!X(VOJhe>rTgu%6Yxr~>>5>@
zKAG$NqwmoAn&fm}q=YW?AAl(tv$LZsyqjWQ+z^dsqd_(mr#kX<OL`xMH$(w?Ao@bS
z@#p-<;T^rpFB&4v5?zc-Yonpp?$CUno*gv3$%!2;j8@Gn11%ZLD7{^C7Jbe1iUhMf
zyt+m|y_1GWtIR^rbiaZ@9?9Iof_B0cDW9B4ND?jEoU%vJl>^sN;`sIcN`#wBpMF2-
zJZl{yKl0+pLr(IsiLNbkM;KpXy0SG1(*W~L`P<;LY{vKCfh)5gD~fs48nG2{b-B=G
zUK>8BO0EDXH<}JPJgOGosiRE>tNkEX*;lAS2>tu(rFanu5qKONOl)<AJ^lLd;pe{R
z-~7WqhJmF0A?RAT;(aEwy}t~Tn_jtBg@&=<=GT;3yjNZYH-Zo$uDcBcW9qE%eCZI>
z&-$#@{2cB<+VEY%f&A7N$8f#5_QMi=so8$jCyPOKU;r=}JRC8$crTtIC9mO6g=;V@
z;nOB=<(>?Ilo$f(UP(iF!I!c8k!a?t`H2qPi<y&hiri}uBT%Tt{;B|gq~oKc@2Zhr
zi)L5)4`Ts&$LxZBbIgad&c?{^6Q@5%`+`s+5DeK5Af9at)AnAKclBMk%ntxd8D=%~
zLKMb@<Fv;QV#1O=gmQi6#{_!`e15!*bYNL7J0FDTYR+*~UV3WBrS7upp5_DsKko@=
zGh%djPBhxO<iYe-^c|>PJ+RY|bxP;Pg}Io5`1%zaV4dY&|KiCAGwFwZZ=Zd{0r^AG
zwO~c_=d!2C!3~!Y#ZWoUysX;G%j6NWExugJE($c$cbR*Hly4d-){VD0dem=mU_3F5
z5RnuYu+<TKFwNjB>I5g_BRl2WdD?eN`l-auKZ0d+w=<pH1EMGytRVeY0eRy-hVbjN
zFa?!D&39dCOM%VZOmcIU_Sw4}Id}d8{+UsT0vY6dV<%)=-aBm;m-@L=&}trUiFTBQ
zerin3(^L9+!$kMuoyfl_g2bcVYZpcUeK?qj#U+&zWC3MC?Vk|PA)U%fTbnT?Y%bXK
z9Mz6~eEz=73}*Xd25Zy|m4igZ6-1joQfotWjeDuOSOzrV;OHmwRy`?EP{n2iZSezA
zYskE89B)U_MlwOLC(TMKy~C;jACQ-TBCNK=YqjQqqx)@ZW(8S-R^u66?4M^L2&4mV
z_B>Tq*>z7?2DkNNOn#oV*1JR>BV1C^dCkz+o|4~?X3~+<r*~VX46fQjtRKgB8klTV
zV179P9`QEbWdZ*!6Fy`{pdhXV$g9@1XF^t8P<E`5x88c~ZH-!bsNNs9QwJ65niYBF
z+EGs&Kq-xTVxLNNgx|z3_<V(W5k=vU)v?>FeygAz6Qqy`M#{mY@e>Rq(JuO|@V=gV
zOW=)~y#=ohxf-_F-71pv#93hpOgz86fM%V$u4kVlt0hQ$Sr1m>T*J1DUfEw4E^ccq
zN8PuCk?SGk<10T-dv?+_-?M_$AA#h=ko1nA<pYU7<2k~Do;7DMn#>X|W#KQjhzyCG
z@G~U5qu`5$4$%@gr#8xd%h>JVa$HwU15m$Aa8&oI6|p0dtRiARL9f=9t5uGzg3|sl
zFGo9X*S~+UfW*}<kV3P@KBT}jnk(+$+q3aW$LKt?c_Nq<Xq}pL5{zSrN01tYtX#Z(
zh7{5cJ8RXQP1T^75YqaxvW8c3K4y&>`5g9;oz;aG<Ly`FlG{(B>Ma81`RxW%O0w@k
zDzzn{)uO;F{RO#Lh%$vDqk(%<Brov_BA!sc!G$aFh@^zuzE$oOMwXRo)rQsv*CpOT
z{ZcNAAdJZZc*oS1eTHEO0aJ>Cs_F5lv2K&}Wy2Kd3nCci{_K=HS<hj?4F_TS4ggj`
zY#3$<j^Sa=7qgmC_i*0NJ0KKkFrxXTyQEi;@mBh)422;vbp{-jmUpGb(kRtM6S|pk
zArV=<z>FJ`in@KTy6RABE%%Z0l=)_en51B`B5t8NYjF-}@hC!8@g)Z!9oYhcsT<Cz
z@&jB8;4&EqG`n9?`kMqAMDr|;o4{T{l#t<^%x$Txbil9(Z~sI5-htRc=1iW77f^S8
zLK7Kaw4$Azq%wj4rb8Uj5$BWoy>)&cAbOMv&PhZ6A3YDqy3gA8cX>{yfl#$DH2dcN
z21>%~vyOf8d1CeYopp`nMGybk&5DIvgz_u2!(y|N^zLizjx}q<O|vGX)=Qxm?fWnB
zHu{&6C*k2&SWc2W_Fu>F{D}Uz$4w+{FSCh~pAJ_yr|r(@75eNQ&IhYeCdy4CXq$z?
zFrB&2$WoL_mbxqskJ<b%@|>IS_~Y=x0p6KX{T@eyYDrdaog+nRokt1>jP&0KBvTyQ
zW#BFhLT*=s;_%&)^<y`kEXnCoH1AU-+Svm8i;X|^#(i(4W(<o6_&@<oF00Bn2{CzD
z>P?)aopWiNm$SCyHdPwL*c=ysvZ62!x*hN4xEXF?;~6X`T}g<%&ymfvG~h|H*t4sA
gAn>anHe~mMj)!uL3rfOt0ZT2AJ;~Xo!itvkAFNWCtpET3

diff --git a/Templates/BaseGame/game/data/UI/images/Torque-3D-logo.png b/Templates/BaseGame/game/data/UI/images/Torque-3D-logo.png
deleted file mode 100644
index e31d42a688a7e560b17237ff60edbf9c0c00dc4d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 9063
zcmbVSg;!MF*B+!(U;wG1yOHi1kf9k$L`uK`=0%Wh5QdU&q*J<vZUm%Dy1OMM1;lUs
z{R!W?>)vzMy{GoxC-!;v6QQH^iV%+)4*&oVLR7&}006BG^&W|Xg?ipui(#V@tas|K
zz<|I1uH25|MAR2tCskt?001BO??wZpXHud*V!J{#m9aO_Ffc?xA)nqf000aC2v|Yi
zbLqrXDwamw{b|rk&FJ<ses9Sj1HU{+En2kVtJFm58VK6>_lT(I!cRi%LfiBf(M(}V
ztf4@qo#z7JZ-Fmr&~*br$AR6fwYr!;cTFM8W5NGn`@PXSKCJSup`RVQL_-KypH}J3
z?w6m<l<JW)B0@;z)r`@CzgY-S(k)m61t<wr#0ieZr~`=ta{$7CdTD<LEDLas$H`&y
zM9K&~xuH7&RxpXGGcRBQ;A-{wn?U|~clnL0^iVC~0M)v)B7J@FHe(_v5fuDQz+|W+
z3gT=gj^?zK9Rri7XLU5M=309W2sKWS`<KDuuDnGIU{5DUhekQsC8RtgeDIeS5NjDG
z-9a`njjHsG5HdIx6lPpv#wLXo{H<A?z!U(ZlRH8a$Nia>EYiswf&-#OHE5<~ErxN<
zw`n4cQB&-@dTv`sq=Y;X;6=iVoJ>vsdx%?*wnNhV;vTjTfHJi*#!p*^{G<aO?kaln
zA*JlJ2L`BCn^ahuU)eX2%Lgd|!XVu1`ZICFJ>`0!V<AC7%BW`~t9Cw;vKj~XJ~c`O
z(G|G-{K!kM6fDj)7@tV9wTJgOcuuTbx}AyuYnz6o<4VUY46+(LGYsT;)ii#v1`kFF
zgKDSv<nRu6u{ZMA9N?Lg<dAkuiBhI2_Q()NhcMX-&Sbw8wnjiV4c=`fXleSQL<U4p
zd`M_2_knoR&8XwKBNuz~9ADPo@-K!$oV($?$zEOJ7yfa~&QH~yWI)bcMCJF_3bP&E
z&f;SqyX_?I7IW8Du+Pmt9=)n@p`Ifx^u8_Sk9iA>tyAduJ<a8ZOo6*AhRduNDl7zh
z*w@mtHIG?Sf8DhXAtnTmSgYYNbMEpCbm~47kzX$!UJ}X6Rk}~!T~G^s(F}LpW*&Y>
zh6XK_4Z6OAd_IC1<vgW*rxS=ROrAM~Po<lN!yLNJmR-XHd_LkjIwXN4!uG+=<#DR$
z?qBUvtE8Ttb7Af;&1z6iH6|BissPN2Pdo=VWeYluS(CP{ecjM9aT)Kg9wDi4??a_N
zrG?E>o?IGwUA9_BLSNImdS>Z<Q~utu@#3A-%m;cj@$U5C<G<EAj@gzHbzM>=VkBYb
zYF+Qy5w<vt<F<P@OqdPz*iv(U>xj3~dOq05M;>3B;arFkVlp6XaT(VVdQYlUUH!F=
zqlvd*jNlgpp<>x>ow7rdr4zQu3du`qk0G%KTF<zERMog4t&d*^z|O|vt<+<~YkC}2
z8n$Sj>Ngts=Jtx=VqoV=g6u8@wKJIz1}Xx;dXLRf+QGg~7jj<^VzokQ#*f>>&AN!o
zc!MB5i`S;CQLx{t0CP=zBPrcUo}ty0|K*u?Yx~l9ln;@ov7_HUa*r1NcD5)er`bdi
zXlBc(Cy8W+-BUc#kh?h@)wjrfoZD(G3>{YSG-d3IO!J#A>Wr{Tv<&id(VrT^VV0!x
ziK>$pm?0ME%{f;*)8#P;!jqWh7%q6uwMWf{8ysGbnF~tL0I^;OZ?eP+n+;<1RKw_S
z8NGE$omELfvqHw+`U&ASyGP&evLm$RkDe_66_5A7_}L4vT@9fdf4Eq5k(g<3eBtNR
z5lKMbqo<YcbpBq)Q5LtX9!iZYa6{I`@n3KQI!d%+psitm7`u~wFC6T(K+v3TLXuuG
z^t9M^0E?vGWlY^DIIG>6_E-7<W5kDN8(_7?NZaROv=0CxJ09uhf=cdcVkdPpEy459
z;cXFHSTDc;`?l|$j^o@fajX&sgok8_7(KUak-|>#*d&iKWnwrx!H+C}CsUEMX|iWw
z5;JE}-Om8Btq^Y$3==g@cIfal@rgHuB`ImWyCk|3N717o*N@-zdD_6BKg36c4M&nJ
z1?PBkU;5JZg@b^lS5EXClSRy5hBe)rP4)&xzR1Qy>DWO?rYWDG4cA>6#=en!%B15R
zKD&DGh63EIkTf{ldPhSZYTFy9DrK8v+JvC0k8<L&H2+PDRK}Zj6!NTIpH)+LCu3U1
zcls*#wL>snQC5KlWKPC;orP1~)N?FkOF9*7stZeaPg9trjlP7oU;-4k46(!$M^I^a
zGN%sOcAJ@T(l5rlc+(N*5AvXWQgl*4+#)UBKM~hCzL~84LRgf9O?5M-0N9*$<;M$-
zf2jdU;-uaLSxIDifqmH3i;vAPIKqmJVM`>Nhl<X;N<T^1WO}9X(h$;P3Z-=NIf(Pj
zSr9Y(jPdOEeoM-AJy+y(X=`G;7H1q3E35yhLS8h6*1f1f5|l^3lXe=A`;kq==^9T(
zR%iW%q1%s{RpJrdjH=XDZk|P5#ZT)zzVGCh>Oa)BsS-7Sawqe(6hpnTy%l~2SHIKB
zrHty^)J6W+Z5R=i$lzvVZBxu$ddYPb#vFDkrc_SOm;_0N-UtIfL&A;iCv!*9TLmuZ
z!d_BQ75vO5Mnag%+akhRO}t|x+e_c>>pX-?Z^H?V>oq_#JIChoU8i5`YGW8&9P5&t
z*$@Zc0tz1Jq-bXnv*W%@-eQ$WdL*odC+ZnOJ&vS0^zZTqt@rnJUSVausq|@~ua;LC
z;N;#D&^k??sB3t)#0+nrj?1bA#z)Pnh;70RyPbOdm~Od6A--;6C1PQp|9TsGA`38Z
z<S2!>6QD5%4Ep>thQ12USqgS+WUcOg0=ASF$6w-`%HWn>Z6k=!Afc`8WJULAg^tC1
zjFg_L#lyi5_6v1HR`uVkqn;%M1c~0!2$A6GG!dwzgZF1_3_f<J7#pu%*Je8W;l1n_
z-V;oyiDs2_`eBX5jGOO5?>6f~hGS(@@*9JfO-e=oD$Y`b8mpiXeA^Rzpfc%b@D40o
z$HkR-c`CZd*OJFkD2V7#8K@h-?!ow-1v64ffPXWCJGS@>KdYG-_{|b_<GMmWli^g_
zrmH)oB_=>eeN)kCT)<7LLpotFExil}{Gt3(+3GH$ahMbsw36A5l-*w}f;ed@XT#3N
zo!;lGdnBALJhB6dLs;4Zc?MDxh#Ef4BKiI-b>(!|xjA`!ddu1qoMs~K%71DV92y^U
z>~CrQZIXDwth>2vx=YgB6>kF(!6y<$_V7YBO5zultB+!MIwM@Y_1hEQKCY5E&X2Hw
zLu6`rYE-_SGAON1^g?fV_=~QV_z-J3M+{I)1p+#AYO5>|ED?h%Yw6%Rm$7XakM2+4
zwdN1<a=oBP2E)=DMKr`GV!8TU3C?I#Bxd^=fu?Lu4-FkmiCJ1yyB&v;8oPg2u%$^7
zwd_FOD}bf&4BU_uw^vHh;@e5_`CPtoC1UH)9z14NPYn)gWg@E^%djPTS-gC8*vM{(
z&}v=AmQGQU3?pLwnRoOO$@Ou|{J9)X12@8xeE+V<e>?s|774&RYv{KEjzKZ=iovkR
zNo|HPKKqgJjfU}r%hNS?$NaO&{3*k*xA;OpVZ8F=a30t1;pSLL<m!5}Zs_`1cGqXF
zo1<DYLET{Mf;1qSxhvbg-+{K~!3|ApjFN_;efs18mvUd7G;iMc(}*}zW<&9|rH|xk
zQ}OopjcfaQb_}<$@$p04+Ji!e*XW!&rn+p&LB_E5GunxaidcA_NNH-iIaPWijJJ=<
z5hi$C(zcdO%*3||!X};~;gs)!gny_!HBkL7gLm+kr<)5Y&a&XBJ)n*D7`|&|+Zk<)
z=kV(Xbm*NSHIkX#k9vc6?Y*++&cPbi=(#pQ!)|SVgxCgs%2k`$^ZSOj4{v*zS<4J!
z{`42fJkOWH_Y~ApS~G7F$xHku4rj>vlM&?#ah%GIc^-ZhO2>6pIgh&>1wL;k*zM8E
zt-jhIHY*Dbzp2C|F<n1bV`;svDxfT5warj4!XYshacA2XTFA@$qBVO<6Kg*s#!pNu
zDHC23Q^uSGqq@=)+p7~CW$f^az3qiqSoWyXHS{EcBua8IKFa{k?A&vNhh`DP{Fdxm
zGtV+7KW#SBVscER3Rb;P^%SOx02iVx$dbEGQ`5WPs3?6~n)Gt`P1c8=Db>q%1!N-M
zw>=Q0GGm9{f{!umG=e%z7&uTt7Lq$uibVn;yjhwyfm%Z1Rs;icNNBe*l=X?cw)6{<
zn9n*Aq1in?Sv~NV&J@a@JlOVo0WTfgn$9q<uXWVCC~GzA06kJ_!RH*h90K0m{*^ii
zu`34Y>g@o^@=YZ>JOw>G8DiQh`}pbXI4ep7AuqJK5;K?3$ANA17>@N&AE>KvEDltp
z?e0?Rizm*15z>s>GG@dShFkHa>Lm~zewLK_$O<6|xf3xunVYs7^AG=RH_^B}zW3iP
zZp`Tyo`oL>eTcPHAK<osRq<pb+AXK##My2Z1T2FohPO{#`($0-<W=A}3YUo8ngYMf
z<*rG8K>67gecz$=CHlp5U<T<8(ZemwKV#wHLm;fO=`+b3)u|R$aPh)N4utr%Zbj|Q
znleMXBaqbjMoT#bH|6<WR=hnJ=Ik$z%bA@wd3q!B_~iWQ@_V!i+IPccv<Kj<;7!63
znld3)2=#VU3sr)q|7W4K#Qr6Ob;LQ5Y3EN{9Y>V9FA!eb6!t}|Qr~ekiQ7Z>#PDrd
zuQ-?i+Ex^LqG;@34KvYW9L6`gi4NiCvJ6X0=3~{`2x1|dy{_j{g~yBgU2C1O0j>8@
z>%4n`e%89ALVHRWVdSeU**lab-YL&wMM5<_J5Ubxg2<3GI(-@~6&*ag07|!}rnSJ`
zAtsa`2bJYSUNU|!Fu{(lyB#;~^$D^@VohZBQ4CLBx#8V%lRtVt$R5o`7ehd%N}pFd
z))KIZ<``F+*qmUgP0jVMd72BP>!z~x`HC`s=!$E{uQDbn0pwD4X$6LLuGBqk8MfA>
zl37rWgDO>}8rk}dE^6>Efs5oy^)H@FJ&z%6{1HAV6&o>&;hvTmQ6+seUT${c(l}~w
zJ)a#DHj8X}t+tp7eNxpDAPf@@&T_Z|tF@T-=p@9%#Tb@SDsoL6W;DB(D?q*;YK;5f
za0pL2N=vGHMrqo<OP-^=WNJa@+>P}O^5w*>KKtzJ>Um~rT>^u}1YXS@d#9($rdkuG
z|GD94=s=e$c=^H8Lh-~W?CP`RtwsM34v?`=_Uf9&2)Z#dM@Is~e!_J1!_~m~$W|oH
z&?8ldAn$^^K19EwmrT5zCg@K)1>cqEqQlx*e-nLar_*nYup(>kaYm|PZ*o5hq$IE6
zoR_Y3Xfa^_)C%&{Sf|-+6i!McAAHqqJuk+)Vi;%i@IG{TbTnd{%ph55R&PxyN4Htq
z=X&bHEA+L+<mbtarB<2_^9Z2!95C4X^7$~>PSwE3uqC_5*9$u5Kv)<QVA$z4nH}Sk
z@l!T8$@o{CIsf*3|6$@FO_5aMrE%BA0q50Xg5!PktB3lz)G|pkm*k%C>b<Od9A42^
zw)N7-;atlhx`r666~wsN5+cG>1ik0uMX%G&d-5tD19pz}tdUkpS?BkYsbtGaqnFo|
zQ3Od@pRqE)&zH>SFOaAswiO8HjLhAOf8G30jP4J!$!E(X=@y?LiA2-z`PJ*|CKnO0
zMbRi^!MdmZrw;b>Gm);FSB+%7@}qGYqGzr0tBK-J^~zeLRRww{c1_;z-^JrQkLhE5
z0>r+uma3EKd)cXFRyG5#u?=nk-6?xUd?>Nh8}&=GHt14*)^?(1vrMDLVXon;^p=OT
zp%~rw`O9cE1;3LsP}KlU%C4Nw3U<*yjFcX|@h|&OIi!W7n@9CG^j(;yr(=B%`s+y;
zkp*ATPK}YbpI%XCDb`i=5;n@iug3e~fOba|xa*RE2{kJ&5Nw3xaD7N6eC($>@N!Io
zx%RI_CpmvBU?!2~qtq2*DwFio&sfwrWL-zAIl0`%=iHTk#onr!!{M+V2p<a@XK!N)
z^I<KjM<Vl*ep&Uqw-wjU7bX4T`sDLp9Nx0ZU4ylVv{w<aDS0>g*t#)57ByK?6s$%S
zFl8-`82f^jyuQpxu^{f&EU?{Ki{47~t)M1Juy<Vv1`=B(uIy*40f>BN9K2{?I$y;h
zbj&rTU*|e!vZLCRMAfkC-S~Op*0rlmS?eU5c#E`q9s^Q+<m^r1%yFjD*tUN`OHms0
zlf1fXTY(^Dp!tFsEArSM0ybjIFZX;q@jD}Oe8)GtCacW4*kQi;V=OmD6zA$f`IPt?
zx#C;BHlt{P|9(eRbDSwAo%L?R{Qdmu#xb@&vMtAzj!ml^c^_lQih%2e`|E!RAc*t1
z5T5em+J2?Hv9QYrv$XX}zyjuZoW4$id!6t^V&fk!!0Cf@Siw|f+WZ=W!AEnUL!{!u
z{u{O5%D>nApqnYN9i1#$af*mPI=Wja?<+8(QC-msXvE$4M7-s%XvH&n$$H_}^)d6N
z*)Sr1Pl1IkfA`+I=gJ)$##iLORdh7PBE{{9kHgq#S)A!;<GGAC)*6so^ES^xRqeZD
z)Y}0Aa>Z~{fE)|4aWmTa;_o0*=wr|R-Pj{u!0m1-Uc4uC`&gFbKeL5ATvMv}9Vr1^
z22$Wf;;+A7T47NayuK~^yvnIICYoNk_kL4sk^^W4&$5{-waL40!OeCH0+B;KSR`Td
ze_jCiwm6ibE^W9Ao_SpAYN{>!w+~$=qm^s3FCv$&7(NY!1GiSk?V?I^#>mOCZO+*t
z%|ZgpnCJT-dYfUehldnyZgsFp)qfi4wQ_;}=(RNXP#mqfj9np4r#Z%gh2u`*{Id7B
z6gZOmzeVidGsKVl3HNgeUe<VhOTFCV73#nJBlOfOz>)V{+bCz&(Sdl=?{mgM9>TNN
zqN-lWG%UT`(gLZ=x|g<0q4*ZU>DYa)NIxQ?6K&|8q_(cp_1*MtOjKlr(3}p7b6t37
z99}DfpI?5zGTrfh!&-OTY6XtpG{mWZe=ennQz7qZHiU1t>}*t9&?a+PLgk#)evvid
z=@cM??Sw0(LA_x3PyFfmWc(52)9<5vXG>!<T(WgsM%e+Dc93S5xViZhCBBH@xet*|
z#%R@u;pxLEgEutH{N<!b62W|C+=5{w3e=*R$xsT}p+-#!rQ)CroQC6B0>PLTF2OYm
zi6PsC>=^XtjhZHlUc6Jqn78){yO+}DMw-dR4P|h~KBJYdBPQuSXE=-$BxgU9cj7RA
zNKgg%14H-)$#s;i=p$86;RH6$+PaY*RS);~`2J0453D-kh+EEnx<+2jE*^ldmc0)k
z{)ybi;`E&a$@@b;3dR5W+N*c-GDp6Wnzxayx&R>vMOS;Ay0cW*+R(Do(b+H|fOhYr
z11G6I2h9iWjkS4zEL$zR#z#f`VT{M)^bl{G{FDCI?8D5EUAjl1!>!{p=+I#7WS1JJ
zoU&UL$~QH&>Ddzzypv2fH)rsC==l@A?a*7~yLzK$!_OJNW<(A5Pb?o}>g=V;(;ok!
zFfu8$wF1{=*Kk=6uljj^GhGAxBu%QHz$OV3LYm_>Y-{i*tld?L=g|OiI1q*EwQHJ#
zF?O2Nji!BtYmR7AJTG>=O?G_UAUH2RiW2E54mXA#RQ+3sp_@76LFXDA`I8Q>^*6g3
zHY7Eb3yJA``yWFi&Ps6^iVygh-K^7;0yd$1GUGj0tgZhb$f#da6d)-yxxWcu^3XV~
zgJ<`Imo$Zn(dZ#G9?y<#mD|@o1SWQbD-k5c<+t6uWyFB-9s{r7^2=mBrq>-U;}#XB
zsgGG&z~a|yp_5EOg5UDaHa{$uE3rvx=l@jZ-7~edVMi?VtrGSf?Q@M#r||V$`h2a#
zd1yywx}DjdQoXAD54(O7o~e_=&G_9>z2}7or@&DLKN_ARdymhyM|4FQ`s&?E*SjSj
z``lI+;2;T!W;Rg=mefW59+VH>W{5gy!%@3&$MYW`aEBQk+#S-X+Df>6DGhxhFFwL9
z7C+|_)p#>|IJG=mV+{4H8)n%t3smYl&=`Lq>$h#~eQ)V9OSn%(0oTgVAJOpi<6-|g
z1IXMpFbFw)pcpYB^u~gHes7sb5t#F_sosPqpSvE(TwJK<)^g&&9OhA~=Ydsf#qN9P
zQ9V)u&#E^p)-$V3K%lnx@%#1YiT!f=ADn(JmAc9l!sM?NuQXGNNm&}Gd@7T&%F=6m
z1&-(fn~Z_kimqjP^p={vsfBxH37RW@A4yXW0^d1u&C5JApbg}`wQ4!PnqpDH(S>kZ
zvN1J^sBxa^s>}v<M$Dd$@2oI37<>$A^SPw0fEtIyZg9r5W)L2Yp{MG(;W)}go^R%^
z{kL(NT}u-9$Bn=o`n#GrwFlGo#CaCoBeMN{F-nrN=S*Q$dc-td%W*G_-4+v4Ij_bV
z(EPUbg)ZJ+;*kuGR+5?FZCjZp|3jd0x@A+En2*ssb8e{Da@URlo)chL;!5t?BbB=W
znb;2r(ZfpboG~)<p8CyKGlpjSyIvbAR@?U3qAX#ZS@n`%e;y^}+vu$SXLtYpLvw5m
zp1+?Jj-!s_X&aeYFwR*a3gBixUVs;xncazBPXR%TxtMLTcGyq*_-yun$AY?e%x(qx
zArQ`eMI1P$LDpBotZC#QuCYD?3xhG23^2oGV8oy_f|?6`vl6p3gr!|5bxM+YCSzjo
zu&R(}@LN})X~XxEl?M*XJ=TWBS{S~3Rwog3%nwoGW=FbMRI296C_g=?`8f5hl6)!W
zCjKS)!o&EU;LPhH2EV%SMJ%=$XW*JTPjRc51<bw^V-j5;92x(mC)pqGy$aYnT`4gZ
z>v}KVa&;2@T=KJ@rja{jOeJ#bHH9n}pQFtSl{^E>GyF_u-**t!-A-*aHxuevQ^9se
zq>g(=Ju53DBS7%CGOLZ7K#3SO*qd;7Am*hH3avnU7|g;AEFCC1x@xMdm{ms;MEK<^
z@jKX<?1;4Gk5*NZ)?1;wW7(zQJ=y4p8II<dz@^7W3V+=L?$eLu8J<WK`~cNcP<|{c
zu$nu@#tWtv-ITm#rs_rVLz^bGss57$l5B(XivhU%VS*XT7EkzrU6|+dfG51}=Yo9K
zU4SR@?k==D2Or6C?##bpoUzKclD7dHH$1NZ%|o>(yOQm*I(H#`pIh1CkvJ1~Iz>ci
z%lK)4Ioe=v7n&QYsAa%YmMlNu5i?K@`y6(4rW7mpmmUy+ah?Nq?c$Jom_{9rFuRLs
zY5xY;_;#I1ALA`Nyxq?g0xnN~WQ%|+8@RWMw0-_`7DGNQ`&DvP^9}|-y8miVJXDQr
zw5^;ht~efLYvC#t>yj*`2Rw>>D8I>-0hx0KbVV!!_nIsn9Y0o2tfSWmm59lqV2(%;
z;mgK%*r<pWe1VmMe>xLD<~*ha;VVhga7Qz^+OEQ9jMk$~`tx!8RqDkXaz%Z=o-Ycp
zfiG3fk%|Bf=wV4q7#)zYxVuN$M{<s$LdV}9vyDR<Wp<+Y{VMpQOs<drsOoBoL#v`U
zCY>l*P<80W7frx=q6{Cv7ZQA>*76>v!&${;sQ!Mig3y{@y>^rKo;o|5i}w@HE8zWm
zOX&Je;qe|8IczZKz<slW?$*m-e>ppbAMGvC(bz=IbG*)ds6-cPOxH0mX;RLk;zur_
zH>(V!uH(&D(01~Lya^xFf~Y<<VT2kTAu4|Vbq6L`a*SsS$zA&r`X!T?E|>Y+i=DL=
zp&6J}5Ce<)Zna)Iv$kS`<?a8j#%-yM#>RO+h?j`*Lx%Lp<u1xm#;KJ76&rWUHeEm*
za+ElqX_w9Ec95s8w`&9AV(rsBXBQpPLpAG8vrpe5hs$0yux#jvxw_+&O1o5=s7@UC
zi01V7w{|WHbax%vd+-@ju6uDvRYkW@|7c030Qfp+4+N;H+r?i#p`XrW|H-EH)y;p#
zy__clLXD7s!rT{hk5_T`gRhb5t8u3_CjH>f&(46J<gu6EH(v|hzbCPvPki{wVT^2V
zfVt%_hky+AAx}Vwje5|Zd>PPR68CqZ-T^QW|H)9iAcM)<NsNuifxe$ls0Hg&LKt4r
zaRNB5b!4OztF$#lK~zIM@8|v3^srw<AF;N|K4)mla1i})c;>lre}l62c>S=tkK_}^
zM&i%q=Lf&%@W9?V7LKz{_(2W;ZW6PG!G6Z6$+9+7D6sF(=f<uo(mKbWnV%{|2&2YM
z%Rc5-ykn8NqTcMwB`o=$u4Vb9fV-INx~t*wUb^|3@=D+DtE_Qn+e@t6Osdn(_+v6J
z4M@PQ2CJ8S8sjxDkv4Dqw&zoL9@uOv1tL0!s15PvO~S5QADUOqEWTA8UvR>(|1R#X
zh#g8yM`5LDcv4&s!RG56<9Z^G#gKSbUvHRn7wk5H3A(ua4UKq=Tss=vvJNrnj~lzb
zFX?lK?+q*Ba`M~VtQZY?^zN}_{kH0Dvbz^VSs^wC`$lhi3Ix)8dhghk=+2%s8ShXW
zNAH_pl7Q^W*0if&u|?;28M#~A`fepSjHDhFt{pn;l;D+z)Sul1Klr$<*Aa~I_G*55
zgo|Rz1m?~`YSJsctLH@|54g+IwaRKLex0j`hkB=@tQ*d!pk3)eLeC`TY0Eku{>UU}
z5@?6SGHHc@Xm%U&{@Ja~_x9AH7LRnCX+Cbn_0hT`n(v}5SDI+J6L^;D){lI}?@XX>
z%T<sV-2oyLvMF)W>oT*yhl+aUyHzw~jmDYEzVq7ti^85(2;0PJ^{M1Ya2$tfu{vz4
zQf14~YoMN9+*k`sZ?-#)!!&nWq6HbjZxBt}M+Mway|0`2$M1;9cUuw}+7x58nWT&H
zqJvizIwYP8Q4LDd2%Wq%V^m5%O}$?Z>#<X(pFi8tbXC#dYIdZ=?4w9g@=9fsWg$5)
z`jtsjek!OpSTzYzt!G^CcyVTycHNeLRyR#zUq#Qk%Y+8Ar@G(l<P5+}R*d17(`nb;
zLU9J39sJ`0IH=4rj$cZf@M5g6B1QEmrIcCQ)l>brnoTg-18h=@f=1zcW`^J6k~CW!
zDJ8m1H8z%Z!dRIM)vs9<+-<n1&u1NSa-;7`<FX(`tm*^lI~{Z1LXEGZU2<NMfD+w#
zkb1fZAgBte?;e5`;@#C8ZbCEumIl2wONsQ$d#Vb#H!EU$i{nZDoGuuQ$~ODrBN@-q
z-c`w7qV)OpqD8$Sb&A=Ayr#~9Ux-y|+8mrs<+3g?H$JCjf?r#mklC^%myB34XAAKt
z%1p*ySSFFK`>*`5Rfsa`WiNBR0ZVZX%VIM52iAQrdyIc%01l~4y~FL4lM$djsS0VI
zaqE3?(x^-Hu5~irzu&Jt$gW-SM<(H40=bPc8vljP`y~^Wjdor1a$(xg=;WJr#Ww|Q
zKT4&vU^W7jMOYF&UY{~7sN6w%AES49*)nu)^pHp^6u-emS2LnwxZ;%dzdNdgf4qm#
zz#b>s{;1F*1YN^dj{gx8(jq=b7AB}xaJq3Mz7#Tmu3P-C=;aXKP#Jqlr1VI|=?W0*
zf20HfGW7>^ptz4Cs3)!aSH#}>XFP#LK}v#9O9pJyj}lHQIG(ht`k0<S|B)=xDvlCZ
z+T6;5TXop*EB=N5dv!|6#?>}+7u|4d_&z27V?|J6u$syq>QT>~2$PKPCZjk7!IoG*
z4Bq-n5E?YOgHcW}x5hsfh9%JoyD*EXhz$rSm}SqUeq!^#P73Lp&i2|B7ah%=23nid
zp+t^)jHudDP=o+UtN-;3i`gi@%_ZIYS;pWz=zleR12>s%2(Y2r-g)KfL8kf{+!TXh
zkHUujSC)v1#FX#W(q;gqD-Bn;y0kG#s};Oa5S1OJP82WW|Cv|{KhX<KLRizlm`Nx~
O3;?361+G%G2>L$+`!gT_

diff --git a/Templates/BaseGame/game/data/UI/images/Torque-3D-logo_alt.png b/Templates/BaseGame/game/data/UI/images/Torque-3D-logo_alt.png
deleted file mode 100644
index 3836f1e7fc26b23ee299fa02570bbed343d2cb50..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 11616
zcmXY1bzD@>*Iq(W8bN86ZUI3;x;rJLVG$|m1%ag-B&AClM2V$YI+t!?X{2H4PG7$M
z-hb|$J9lQzInSK=d}f|`A~n?&@Ng(_0001<lA^3O0DuB}Do0~sJUy>LZ!w=<=r&Sn
zQUE}8j)kh!)zdefm7=y901!?H0K^aj01r>)Kyd)Ta36p|OaK79+X4VyjW!Pe`JM*j
zvXzn1)coY+?&S8#$(c?`MuyJW)#;<HgEauaI%Z{V&gbmz;%ZH7ZVn&eV8e0s)Q*UV
z(KeSD>*(tk24F-E^gfG4K@q0|oBEluqp_QV%&)<CvV5<Ne?Lp_m84iz=4NF_ne-2s
zV`ZundiALgB|h84R2x8QlZ6I~X0#4QP)Z{6<LPYZ?y%xVQt>U!P^y#YkSugyqHz+*
zOY-<z_t%+`Xb$)xTxgc5g?a%<Yv)m(QqDouF;=bDwY9an&Z+|%%I~o%IJuQZxb%*P
zRYrN(;XKNmN@^%SLK_L5qtoL^(HEmkf65z>v<5_BV(q)p3HiS29i{6bq-&}zeNINM
z+81(z#lNNa`t>!BwYm9CFd_f0wYkCf?v4(L7xcv+;T?3}$2zK<@Bv*l8jru38`+*f
z#&%XTbOQizp8&=sMwwjlyML;raF;W1*Kzvj?rGs_4bZf({p`-IE~iTe=I0jR=6(J8
z+%*pX;P6zEmD2SxJup%EX|3RK(ID};;qIc{tbGM?R3~BHzuWPKRcwGRg~5Y4lA4)@
z5F<tel?@oxVM$y_7f6U^)WsWYE_d2d414J2T|$>etDowDclJe)G1k8z<n2M}=R1bZ
zww9RAiXBb+>t{D#eO6&wIMO?q_j#Y)I$AORemiQ`)Zei{_sd0{zJF$UCC3J>lq4Y`
zIy#C}M@T@VuPd<*epeC^*?$#uZ&A%Y2n$|acdgcFP?`9h3=|AGjsJD39YPe%d@b2Z
zUG}|&|A{_78WXRs;)DN6g<nb1VV<1RPj%~-0kN=9gCt2&OHzLyqIP;DWbQlBwfl>-
z90#*(ryfP^WtC0noDFTOkag{!om)ENgbswf;e`<Dz%*i6`S70Ea{br8Ll0d(VR2B7
zJn!bw?{PIjMHcmFAI;v3+HFR(ruNoIwwv_eks~7h@$XgiA5Aob%Z?`Ln_bnXc#3II
zWZi61e)}zL-VfNet4++yefZ%kDaRABIPL$IXxiSy(bmvyeX;YVodeIDn^+|QmrBYn
zWPuuSvPzdh0Rmwvi#(wcm@XBdcxYv!o`rRI5x=P@8x~<X%3aYmlcJ!tJgbcQ<Ld7w
zL$nk9;0C9eu=}|LVN)5ZHUYhKEkmogA#u`1+hNPuC<!xakJA8k1mGXieDvdT?sVaV
ziTm0I)uEjQj@$kgpZ~^<a{n5!=CfA)x%?J5MhwX(;9LOyVS1ihc*^jB?D6YY^n}H;
zo{40FZ<9P_wDd5>>%wX}I;`^$N%9G;^D`1|>D$TE+dCQ~s+M1(ca;Yc=f2o(cR(2T
zLY0FO4?&#f`4tDr34P|p`RT1PwnP3MAv8KnodV}+jx?|WBIbSEg;OZjI&2NkY?_n)
z-nIq*jbA`!z||XGXi>?zRk|n8<ahiict;OgoYLFCMGXSHMRk{5Wohm%5-ZJhk#l!6
zk@6C$w)Edmmr+<5b4=o{)Pw4XX!qRN6xT%8>fe4+cgVNapg>5OeIxL{?k+hzxZXa5
z9f?P-tlZ^X;pa;wgmq#qy05Fb**P@#J@eOTFZk??IVnl_iST>rA;~(Z>U@7Oypu?2
z5At{x*xe47t9V@lhUz2{4P^=ykH?-9K5X`|>{*niBUeeKOs`h_{|0Z5=E7cPDBYf3
znfa{`r}J-1#;`oD_MET=yrT#-NM_)<ITBYw6ZAh0rfu2I3#akkXxh$&k%|a@3a*b&
zIP2|sL&H?vy|_QgFnyTlHq=n5N%@Y3#r_3IRl882KJIb`EnFgjeYQl5%jR+Y+I1^$
z?7B9(jGqmJx!{aZX)nQJQ%fDZ`$8a*+8wnsR76uBB4j{F+fX1g{bx^f`zUH$MTjPz
z<aWItlaF51j@XD|Cf?Se3-^q<$Mo~C)#fg_O2|B+rIWr1usLo=R?=p5Sv7fg!B4SP
z#r~-DF%q<L=}7s(DG{!Y`0Zh@_C7?P1R<456<hnD$?&IJW>C%>l9c_K)|A*ao+g5o
zISALIbSF6JJOp`aN@JFR{B(qr=)c<Ak|0)QWV=|HSh_(|5dQ`on+6jP;McEaS^6l|
zP;`|CA|*u(CUHDs$}Y^jZ;Jl*@!9Ty@R(o~9J4|d7CK%5!%bLdD$WN?AaxTps|a!7
zl$=mxaX1nliSMqUj7X&{x(b~a*$|0(T?VoNzRN<WT+|F4+%b!u6Kqo{8)xB@%VrX9
zh9;Vn{;Iyv!6r~?tA@DMseGjhK^8|KQ)VTmfiUt!YV#1l1FLjJ(XbLTY(jkbw~-@j
z@I@I`<4wl764<$qUR{expaUh}(T9Xui^4Bj>5~*A5$t{&D5`FW--+vCRZuW4rn4F@
z*dcA*v$r06(&fa9%@t26y8h4EPwmJxJ^2kt^%<~;x@bwF=)8kBgev`ek~+8;D=wDF
zm-E?OVLc=vyORG|CuC12_trgTO1_pXQ8N&WznJz3cTXJ(zrB^fNR2S|y%1GG^DPE)
z#vt#AM@v)UaSTVu70QIZ>bV#$sKk^{ds|oaE>Ryx`}fM6#g+{|PZn1Cg0Tl1^sZ1{
zUidr>1B$lnK7LQXL`L;a0w&a$ZO<9BaV`a>qtmbLZaPAjl(ZBd;BjutQ=gFq@9=zj
z4P*~~V|<rQk3X=@gx*5}oU$eZO3_XRXLB1Ktk?u1h5CV{D~T6u(1m-zK7V-J$H-D&
zBt7)5W6sqsj4|1kUUU`F=JE`iLtLn4mQ4-p>`+l8B($j6b@B}3q2UT^p@)(J??MSY
z_?c3P9_PFh^TOCF_|ve0o+@={!GRonmTaay-eg#D8WDyMHe<|h3XyK`G~Q8B0p^pe
z`-GpFt^T&ofa5C&&Tk)&(r)w*3u7=1;G=IT%PXn<aHddwL5SCsvL{W<U`HoPSuajh
z>_`*v+A`G((kD~7o>WCjJb;A=jSZOgq?au8DT&X<Ejn3Yv)GJXPUTlg%(jpGi9S(A
ze~idHU5fq@h%`^dGn<{R<zh$yiWD)VWI6K4jn7!e$%5Oklv*{>kFm2(;P$&bGS-cI
z8akj7ha#2yT!-w0`y5=%-zzE!*&ME{O70?Sh^!V3S#-m?_-rnYX+c|u17(tIb+3A+
z_bYHCps1cFeHRvr^0%8T#?l_OXWm*~I{n-iuwbbV-+-b<(?m&LgrLGAzI?1qor}mr
z=4_-xNUmGls6be~n_t^Rws`%msX1J`R7GR<sHqZ{!!~;8x8XJQUFe|2)GRra$|1K8
zj_($n7;`x3*gd-uJ(5lg3TKib$)j_HC&&E3&F6xiC`FWpB2^931ud(Xp5MsVw+Z!6
z*I19=F8VPfm^|N`><bH^$zCnr5gyObgQDpjAcrj{Ot7If)HGKnv4gyM=bNfiGzl8$
zT4)G*Q~_bI(S}2GqkY6nhqI~es-}38Q5Ks^kdEu%!TO!LLVGe=s4X*0FswHpMhvnM
z#oVe<O|#;wv!2gt+yDM$1+=YPUwsf>9Pb<HB1JnUeuX4}DdIN6+zFv>^o;G{bjQ>8
zr#FiOY~wZ=1NfJ9?eUUCr`h!Dgzp>B5$Ts9(qlDpuXYgd`mAl`oZV>TG#+n-s`3<H
zH5bLXVcSKBU{l7yeeS-sEg3xa4&%kFuLjLH_KVlImN%OO$&<_3zJFL;IZyCfelMGh
zt7&L0rO=5cb(am~&0oGSQTfFT)uD~+Z6on?$tKZFTX1jq+B)WEFdY*83FJfM!c{kl
zifH0S#d>HBYn_j<O>7;QQXn&%rhX%ClT<!s8;1;_Jb<)Stng+$;F2{BsE>giR${ak
zC=1!7U9F>=xr6XM1dT6D)Q3_IcB0Z;#WqY_9f?XgjCA4L_rOoHEo{P<b?0(J4pvtd
z;`Oh+SV}(ENP^w-E?0KIsOwp2AOC89`OLS8-v8}p+xyy{Q8YI?$!cuV#qyA2NcKZT
zsS#WqKI$2pzPDEFN5%WH9R=jf{=VYZ17|!nvLy4pUxCBO;|OdK^vy_oJ0z0~diEf`
z@+N+%f0uTFiV#WyRXHJAl5I$Y_}l8i)ircGw-ce<)?3U4i>ErwuCRl`B<d6knUt`S
zKqMm+mxX_pugRV%_$<BrJy{kv1p6TrEIaGl=)v8vTq6xWC{h&(?)STx-!j-_W?*XH
zXTHlwqyt2-?RH-rcds>z8*aG1u5K@nEABJ5Wq`F2-0qL|)Z4ItuI4c=xlXcNUd(D`
zF2=TL+%P0&{_T3gd3gdG^RG$Nj``o8@g@s;QH5hRlz$gNn7vk4M$lJ|gjD4=hXt5|
z+OABW=3aC1UQ$`5<!^IxS~c@&3-_64Sg)$AZ|`Qhn=Sb7eDP(eRCATdH~R2^E&g5y
zC)^MyD$-SblPx{y_3%Y7Mu#f0QoA^Ks3KxOUtB?q5}#XoKn+|q_Kgk4!HS>7@hYep
z$c#S>v7Uo3Tf^eBc?PHS2{uAlf0;a5uXM7swb~rX0UPw&s;@f2B3DV*#v!o;sf^8r
z(a3X{e6>@mBlA<*E#R@&ai${hxnU_D%JJEbS=y!)sysje>g%^$JVSWw1rH*T$mS&m
zqUkvWJs41MVTD!a*e5<=<mLnVm^Mfu_wi=o_f7AWb!Q7Y0x{|q%BTxM`A%dPon`#+
zH2jV^!$z8zDE#LG`&*-P;Yd%bJs()!gqx`HduRyqdf;&AOoejnX!(p&&i|@0=Py<J
z7%`%*ogm`xSfK5t8(4Eb#eCIm!j-IBAg@092ZYLw4Jt$Gz_6LdDm-(!Xl2D<MH`fA
zJ-o=ETX{bX#}5f+8a+bJKZtOJ=5X5XaweGgAW{-_X-0xPBH^Piq(a)(Tv1Visvs{G
zwtqE|B03MJD*^5nsdnv&H#@7vNxFiZo1O91HHf{tL=X^`$bnN#{%!n=8JbIYjM<1s
zHRf#mno@J<U;dFqYa7=npqQ+;;zu@%S<WPC?uF4H7dB|kMR53B9ZyQH7qMM5mG4!T
za$@#=Z)bScg26no<Z7u5P#)OqLmlE-IcCsoD(ySKF4+BBL19J2SOg1k1EevFQ`}-?
zD)gPIP4%=mdTdbUbR4BXSRf2wN}JO6SRX#507Xm9?+97)qbEab?tW^(`}}R8HAGUZ
z!WPEHJ%8LT(!_fskTfoY%SsC%Fa!#J`$LA7y{QO-KY1m`e37@_;$Q^l_IPu@khD&%
z*%Qt=%r!xiBAB}%b|vR;yCz`s6?wjn>7MpiTgZ}zOF5DH^3Xx$BNO(RoIAZ4h*b^z
zQg0y@Af4K8e7Xu^z&gqgJzoC466>j^K|T@M64ID&K3n}PuD{=qX;U=PaZMVm-iY7`
zI9KPXgfysmN60?q<w`e_S`gJH9f`G&`?0f*5zz@Sl18WbNSJd({Qfzeb8$Tue_wUO
zfVvz}QvqfsHLn(Q{}~`;n<EwOAo;BD<9zqR=_LlDLWBItpt;{1Umzqg&T=cw&PrwY
zR9KK6lo}-NWE6EOKF|Elm?<Ut_+vVfaPuVAl;PJKM4nNq&a<_S1h@7t-6sg3id=mg
zz6qWpZ36Xez1$%0_QrYXAo$@G@&eJ%kT1GsF#4{<YKI~-Efte;&Ai2})u0JD{W3op
z&K-?=P8JnHb{nw2AVNgn1$*ro@G$kJMjm|L8{F`1<lFbtjH~Y<y2xOpFE#<e+bn6-
z$<RkI-nPSCMuRJ`dZ_eigT~?NvUEQwpkb{3p&thfGgXX0syAVc**Hk2YI!UeC%jAi
zCT-@dI+k|p-4fksb<3YXeYKRv>*;XYavySC^kF|yMtqt19db>~&1((4Wc11UEteok
z?pK5WkuUJwQd54LcNHv)lSb%W>D*YCYpT7HswYjgEGF!hQS{u&b*oxG@`gC4i$Dm?
zX?6L+QW|vi{p)egO_BulGP)&u6;E$^Ghg8Qb~+PCY?CSUHRg<OH<fe3kG=j2Uh|}>
zT8rr`C+?p@k>8yRWx9+$P{LR#3^THFOVS0PQ|;Wm$)N2h)nh>Fbp{}-jzhXy%=~GO
z?^wqDahISz$XMD`-gxwK$lojc;C?AA@>u$6M|B+pgY*?W9XEIp&_QN(u}13=VuZ!J
zPXtFY2V(D<ZO%}*fjLajZba|NewSX(Mwg4Ky4g@#GqHFi_98(^V*i@z3CaZbgJmT1
z$L}yK{Z`iN#W$9FB#tI3uHsf_>qqS^E?f0iFR_pEk}3PK2nst6B!veS`nSN@-)7Ka
zG*oko=AGl-5A$m_tGP*?Z%v?c_PS7u<T61E9-2ixd``Z?IIV1fqC$g{BrowZyQ^>C
zt<vSEL6Rz@c0`|!kO*#7bwiAes8iFMJ^f!3OK9%J*y~4`0FpDwIVeA5OU)sBy2yYY
zmNqfEfYDGjKEmO&7fWHLySn3%0*^H%7B5*);UV&LF>jQU$4khrAf+mIl8&rgpGcLi
zHtSOR^R&V9vvu{kxoW#Ryt|vm4%yU}Rbb;`{CjzW`7=bp$A?_!!o5x(d_9``&6`fR
z;wB|u;jrFVu(_|Ie#KV!?4h}!7;WPG09MzeD`pdkY;)b&X>j+^sphZm4<@i#y3iOD
zCkyX#Ue1eTHc?Ta6DmwAk$o%ZbNt<NEtTWfQZa4{wc7fCt;8+L$qh)mzJH_3?4d6D
zIOuRZCflCfjrfcqv}55iaFtNXRYIcJ<=5KLVtrq%E$u-DPnr|Ajo;?@y@K{d8WU91
z)7g(-q?m`MB|U1Xr$IkGWv??VI7r8qJf2~%<CPnij`};Vbi9CqDW!Tb=9e5X*q4G*
zsHG}Ii^Ba0Av)<Z%Rp0WeQAZA=%#6b{^=FTOFQvDp$c0@yF}#$5+4Td4LF*8=-<~E
z(u*Qp_O2|&+o}>F)+`<lg{^diApoK!s$>=XE>R*zU3OelF?z|6D|<OjMO~%$R(f!J
zt*Xx)rc~P1NtZ#A9$2e>s{P59eWGv5`Q=G7Y|&YPH&Xi_lh@e-hH(%R<cv8^)N3yb
zSD7831=<lEUt{EO+UtsX=ch>rOm5P?WPmY5E9pm!pd#oKFtNo3^^lOk7-IBd3KU>V
zu1E?$ZMq$xr!i6?AZ6un9Gm^Ze&K1qwM{_vN;ECbEt*7vs0Sd`5ei6HBBu(u!cKjD
zV?ww?f}$Su=i3YmbA21n@WI~%PK)0nBKfIL6blwA2KxCOwT^_O$N?xky5@pYH7dp|
zHPTwrd~K)ey>7+l)PggGO49LLx$joS6?XQu&=#l_#PQ*_0xDwAS`p?Ff^Xuc`tS>b
z`i^?{UF+1_KZox_iC-QLOyRccj#fHqh$0|9W6RN2TGUGdgAzazW+HrR7mJgO&7w`m
z;N;HHx|uo?@n;@unyF-|70-Cp(-0(i6%>?RUwn4v=K8A6z49c6lQc!$DW`qA-#vS!
z-UHApWfbmMFVNVE!7*vSXvLX9>MFrUoeBwOc5}}=S(5HQF#qlfwsn065v$E0Sz42E
z5ceSDdJ`LweNES(f*J4l=NSF%+XQ_5+K_4#-jMjrvFlP1uWD>Tk$e<nM<Yrq;e+&E
z&^zJWy!bYi*-dB?{7`m3;4+10Ug5cC0<#9K;oLn^W6#E}SQxq=u_vwr3a|r;ZU(qY
zl+w{xgp&m8;v&+|0Xb!tmJX{eZgF@H@TPYLgZR`ePwR{Fj`XJNOhp(bh|nTE9s<V3
z=aE1Nl;IVWnw%>8PatvK`ZsE3qWCpLe1PM7Z}<)g%9&Ed)?q-qwX+5ci{#S;iPc=<
zi|f-cBWRXt-u}dR%`VpOP8n#G*0)~gW<J7{6pb{mrkQbGlurz5a$2~2i=Z)j`EGBa
zzI^$OJXlEoYVlC4-Qi${DO=%rSECbje_hSUzhmuQn^sq7t1Xq+jngcM%9Tt1R>&~^
zP5%%UO+;IyIwDirOFZr3J<G+b$?TNF=Lu^OVmWjrzhyRU@TsZqZc$7=`LfG>wPl1w
z!@#*S{Cc*Phc><W&3)MC^)}?|s#5CCLCzF(uUc1~uDSZ8N`&&-21chPsLUKfLRxFa
zSrs*KCi|Im@vnxku=qjhrNYI;S@UPA5B^BsXr{2Xh~bhIgUn{Ez|WJ7g-;CNk?8pZ
z=^xgK%f(KH65+8JHA;lZoX_evKO<$U6)~p1k2M5!z7d!$CPFOE3#=E#OEXS)PR=6E
zZS+nz?2g7v^w;MkDqhZhCZ{^71Q2Fa<QoLpLOW2zZ1}Z?s+Coj`~U{_&3RH{<Dbbq
z`i6r%x1Uz(X1}0eCW4{E)-!RAS-ig?WTVeNG%KxRFClc~x86c>LdEy*|0C}-MUozm
z3itTbKngzT{h}#6xoW+vjSyPUwu-y)01i8Bs=vCA&@>l>iD}~+#EU-@z7xRU03K)<
z`StO}EA7?(6w6*ean4t-j18j8=O*NxeRGyjhHVwwDjADUlCh68PX@KohA_2W>F$#T
zTI<c%OdWZB)3|@5Xpwsunhi6ZN#)6`rrw|+C@`ix+3<>(PD~6(vy><=oZK>TTFO)L
zCxb5JxJf!P64}Yr6pE>?I>(HF$p_dB>r<oaYi8q6({96C#<9BO8{@aFRFE&{`&gLw
za_FI%Qv>+2+GlI0V0N(sxq*J8-8__u)<(!Su6K$Ze?^I9ZdoDNZsj?FA1p+Kj8<;C
zbE)F-xFHQbSYp;1JMyteKjL6-(Qtuzj^c-rB7`K2H<t7vW23A+T$aJ^s8*%;Ys5sj
zTAb#Bs#UPKG!pw2d20n;xMn)DvGkVRr(DQP$+z=rO2M3!*6sG&$==^Q`63V=9Lz%D
zMDAjXS7)%<18)#At#hy%k75?L^{bT<)J+&lEL#!)CNhoCIS58hFB8tHM5&pw^3rAS
zF?n1Q#@OeC$o?u$EssA@`y%96ACfq&nqXqjMxtKRw-c*)ZJ3=_wUWkXrn{iT0y{GH
z?+!Nb`%KM$Z5B%&_{mo#(FD2RSL+fRR+TMNG6}-u;}vcr1RgUzQVk(0c<T@^q4%FC
zR$gWqi+Da%q#VHdhQhBs()s1VZlup*vIlNQE0!v)Y&kztxz<XBt);-NH|GKhDxWw&
z^?Vs!g@$!!a}ursQUqez*^TE4(NQh@ex<=b$*~FeJ_#+ZcY<st85ml@3+0l!-LnQp
zXy!-yb#M-K=ZOpxBT$@NW3TE7(j+{)7fW>dg329}Eaqa3=i2%OBSGQh38@W^?Tt+N
zltfEn#&ZfoS`%ve^R7F5(Q4R2mO6Isql_rD=F?xwxF39}i1*y<Mx?;br_5AVz^X0H
zb~Z<`{hWfaxw*+*$kx|q9GA~klf;T|Hu)Re(*@@K@P9P+sM?U5SSoK`FCo2LCP<GX
z<^kW28HBB!-c|~w?l6BvN<K<7Zq2J;<om?it1}L;NrCIdeOJblV%*=Tdt4X6N5iZ*
zt25l4v`-QImNNZB=sD7d0)!#)COf5O6&mV)L3i>`yjqrh%k*^$d$*>9-T00tpXuK3
zlq6ZO!6;;N&)#o2!6P!F0zV(EhY3Eqr3qOc6=q3LO5w6}y)cVHa!$CoqkoLFE3j@p
z#(7u*H4t>-B0}>`%pk65aXX{5>UAy^a@b>O%Iz(Wa-XM}1Ch?OJMBkvUt(j)$A#fD
zCrnEdlh$IgB?;6iFB?cJtcUyZJ|`Tl|7?6RVoD+<yEY!blv1CiRbECAV>EnP)Rkwy
zc=A?#NvFT+3(+nWWvW9G#Mo_NM#AsyE^T$pD**|J`_Crznyee?+>mfZD8IL%X}GD|
z;`NLwm=5A=d=;*5T6glb6|-3p-yfDrnFRWx21>o4=M&Bv4;MoiL<2nNJyI*U#oUsz
z)fz~(U1K0eDrt6&+NQE0NLO)zO;FO=JM}wHi6dakq5^T1>eXc3f?u_D`sXhXMO3nw
zx=+-MtSeoUioVGOhRI&bMD@35H}^)tgB(|WhVLbdARD)7HX@~f$mREHM5WP4)zO!y
z$3}L%yG8lUb4BKqkv)Uw7^2@TaoA>6!Fgxx7)GdJUt8_S*E-jTi5yn}{8_v<C3fkt
z6|nhc)l{~8o!ePyu+STVAeofSxXMP$ZbjDuYZYU3=PbA92G*Sk9qHf~u|+wHr^20*
z-=;%@IlP0W_$&<ej>dW2TO7RI{tVI&@hSWw`ZU^fV4rGh8k(3rKsJT)IM)s{J@h>o
z)vAm>mVCZ4U*m)}`qHLFTZ!O+zQ0j5HGM}}4ot__N*DC3daYL~f$}u~5qHRPu$Zbd
zly<>oRL^4mnQxFQ_bjkWW_eT7n7|(oRC0dV^xe>m=8dqXy0I`wjSrE&^@1GX(yrOG
zCED**41Y<y%o_D_fk*mVI2^4I(*|$*AhRygyEG2$d`zbi?4|%6Hja7}cl1~wP3W#L
zekRB;f&T0vaPc`J`9Mr$wUa{YZk6P{f=S21MTaw|^=1mKb#30noA_)Bg<Mvr6b8}Q
zrUTKd5TtLyY2{nh4|xvlf@^DkrL+~Z0@n350)9%7$~r`tIt!URsLfQ%zb<Gk)p?{S
zo<Ty(q3tMlB({2FpMSNXkJoK<t`WKpZHM5hm*Ha0W^yYsfCpG@M9J3>=UY9=GAY<B
z`tBgRe%=Pi0pAEm>Y?L}@OBjUg1`#ofLkk$ihFeJD+F1mhBMNd(H&7_LfGkUd^6*7
zuKlW-?cHeLv5IWH;g&i!UzCTg;q!W|uQN4zP&Y2ypy&2<XtP2KTcy$C_Ej42QGu@A
zb_TR@Id3BLAf{&1{8TIxH3fj>V=R*;;X+B->R>$yiHh^>G%=JiFX4}-S|JJxW>XW6
z;_nT`<fH~U0ye=C7>hqPTcI%;BHc91SawMtL{8yy8wXm>*obe?x^YwX_fH$l)C#F?
zdE~2m5UPWaCtK<d)+OY%{S~rmN&@}WDmT{n+g{U2D0KPJr``}X95Wp8zA?r7o6g}L
zL#9Pw(3+Q}%j-I>%{LCs99;sP7SN_|hvMDe`1~#VrxkcsM3^6B1}ZR&d>y$BD_zEY
zA`A6)Nkkj6O^hJ~I1r=5LwXmk$`y@Gs^o2vLGlyPnTKe86?+!$1`}B5W1A|}X{Y<7
zJJ!<r%L6m?uRJOA3*^%k{IXm3Qt)K}R=Kbbr9eAQg2|f%*;g+nSbOs>)xfW3<-G(;
zGAupOhqctSv6?V~o-R2lz%~r=gekL<t~M!p{`y48mq+VyTorAZgClWV&wp#>7`)^x
zKfUfUcf9tz&7Kcn^snSX3z0b`FU#G}!r|51sj^mFEy7*%_El_V0HUKD+5<ZVqVJ!m
zy<c$@zzE$3J33g{aoAACfn~Q)3gfF>`|?uVhY+OlS6zgk{KVqzJK;Y@l!>TXc(_>j
zvX|F?_K2G2?T*qn>r8A?W<A|)BieNkPYXd~!}IyU0$&*|r+wE1dF1C04=eH_ONnJ2
zdW2$w2ad3XzY>fRQRsnU7S-i(rEk59J14qdfnQWut8PZ9oRgr1DDm7cVWJ6vl44#$
zEEjtAENUe5$Sc5Q%`>mJIR(*Msb|e`XB&&*^q8>V{1_Cf%EK51&}#$cKl5(h)(;tJ
z;^X)|3a)yJ%P@+YZohFel1;e*{0W7I=oEd-DmMKu4z?Engg4gaNpB~xmG!3}(Ggc6
zrYUouvtDzyDGm1pcfh%{!~U<&|1ow`HtseISZ1x9d_h@;dyI;7q6~)Nha5%o-y0f;
zvMWsm2+?QnOFPL%PrfF|#a?(vasH;ne9jUhoiJt|3J-Af$0Ndphh{x~AUP>*BSicR
zcD6ddax7R-(AsQq60PtCt%HGxCHIdmv_z}#oIk;7hk7#&R@)=b33o00ohbGH8g6_8
z!kC-O2g{nV=2(6Nn~(|14UB$_vp;nvj4qFhUlBHycHqEiv!cweDXSPr(WL&EjjVFQ
z=>H*VBxEkjSe=k%?;D=5{Acgo3)wFeYn`3j3@u~`YVdCQohPu}{-h4gyUc*Dg%`u%
zbg?Hme|e$W^Mkh&Km4#yDk!A>+j#iIO!Y6GnRXS7*`uuHIgrclK0}H9bBN1kPq%`;
z5p^c@H5bS<0~88}TWgf!3(O@($vOBC;u0-=b^h@qzD5iKlZu1Ckoq?7@$>JyaPg-6
z^lHD9-`*^u)Evmbp!0bz$!)D~Z(Ej%ccR;74N@3Ixp4Lv_09T`)@en=4OW#;*M5Bo
zNg&I9cv0}tY0+LgM$qbHpo%(j?tCVeYFmI*fU_>*P+pmnErUMtag-bXcR#ih1n|&U
zU6zjg_RBz!<{+VB`NzJ>Q10B2r~%VjvR{NR)rTFU$|KOwL__2!SH!q=`A7w!nCt2~
zzo0k|U7l>XpW5a1PS5*rd%tOOTyo|%SGa|#QtTO)@YI5CUc{f`N!gNfYNBO!plZ?B
zk)*`Vu6>e**plgdO*uPs>Ow*dQ5Mp_wwCrOZQOrFxshtMuNPC)K3kjyNV^>-LLWQ-
zu~5T5PX+Wtg4>3SKVBRhI(WhKF1A|B3OQv{N-YiMjhLAU%i8=LMOx(>v9qQZ1^g^k
z56b;u7xH#Gau7C9J?64EP1vs~p0Gr(jt~an@yn58+Ec7aU3tD&@ETmJ{hN(OYEoQg
zwy+}OKFDRp0!wRCuEXx+{9PO`Zi&QCIO6ZO-0ZF0cN6b7r=DlVAjuUpz$oa!qT=;x
zU?-KLI<d`!;S-JH$+pm~$v3Q-&eRz{><Mb1KJnro(>>*8Tj^UKW@Nn}3Df`_NR{i1
zMtWhB`=5AGJn&`}z1+u7M)WYv9{Gy_sbzpo84l5s2o!a_@T36<75%xdp!Ix#2*u>E
zFrJ#Q?^?5d3l(@gB=~blb?%(vt5d9BE{L2`$(a!4ijS>CoeC;M<Ag7!4Jw@1JX^%C
z<9gO_>?q@S{Hs#V!#ShYy~&$DpKaxmX^;K`J!;>3YZ>b5#lht4FNRxtT%fB?;!Ed?
zJS>fdz$&Q?SW<c1Ct(4h5OGBwimKSKrYxlxV|Cc=OY+!O$<$@x*U$kZMZYGs<(BlJ
zV4mRh@BTFx*AxS0s^s38WV@8EHw>&ZkKXf@`5Q4>d01gg=^)Ts5b*#{CG~OduN3cY
zw=dD<(aqGLF^X+%C$9P^nxKFu+C`Qj;JHG41Uu;xGLkH%iJs^re=><mWOSJ+mzS~z
zf;xa7{}%H!)!nFS+Gt%xWs42?=NZbAz-BHAAlzLZ`9@EGr734Wj1>Q#E$WrL=Z|=q
zm2CC~Iq;p%=EV%nY^+vDI84mLck6ai;r7LUYNziM=v56eAWx*Lp|#3A+=3DKf^&im
zB0So=dpX6o)kfu=ny3`gpwf@Y!w1bW#DVN8Jn4*n$N|!QHVAi%6Se4V%pi=C-Zazh
zrfSa`tpCa;QCHFVTndD|rJAC`JkjAzz5Ev$sT@Fw=Bt%#ZEaXlRX&cayS&Js<2%h2
zW+DcqZI`<{F<Dxa{uJi!;hCbD8{U|gDL%sPB(MH;Jr4qKp>fCS6n1ZP2US|tnD!=j
zvw~>tL<l0PDm8W$QstoKaSjj%YRlS2WzVeGzLdUKW&xFcPgO}G|3*NkA4mFgCGi(#
z3Tf(*2cw@Gyz2RRuFh0CbXobUaBz<(k;{akyx!WV&ahr!jk)<h5!N^Qagb%u8{M);
zQ$+!E+2IJqaPJc0Zy)`kKQoHqJJuf?vxK`M^SvSu?I`Fc<epH8q8pE=PHEOnPpkC-
zS+KXVl`-#nbB;VR0Y}TC{NOqJaB&f5aSE&00tz|i68C>vF#tL0NT!6fV1;1Oa`%Q~
z=70;WY~dtQm^q;~k^lbc)cgHxp-YT_g@<B|7Ji0X06X8)q)8I821>4X#3hm_D2Z^7
z!(R?$NJAMi!Fz(*?hWNVFO_KjMU90Ti4}jAv%)!KOSIegvvzn?wg&pfi8z4}n`4-H
z54z9!Jwo%JI?GPM{5lz9zGi_lQh`9odM1kcv);r3<MYb0_xckm{}aju5MECX-qtfq
zJyT*2PY6jsjY$+>43_<)I>BJGFjXL`8Sa%=n4>maRu2ECqmv{AAinZFCn%HNNIg$L
z@ES(;7@h&v*oCb33s+D+@Q>za{^J=ru~xkR!Ut$S3UjC_lLUG}3Ov}2=SKYpb}1-C
z^#3173zm7iy5}5e9%F8F<_oBO3Lj6>(&;V!@&u9X|2N^p(sYNSDd6c!)h4p18JYeN
z7hbSpbDLUbTgn}d%>AEJ-?31IFvBTzGWhyWid@x}P2+8eWW4u4X~|8IE9cbTkFfQ2
z_5Q^xjvi*17NIJLJGQnXzf5!QGe7Y8<twwk*I%&HoZRIS|M?ySpnm(k#-pGVzc9qL
zdpFr5rN%O2SWFf}X{E0mQtI6HdDv9gN&hZB((lR3*D6@6jVR*tKavY;JVe0Fi?%GH
zjAbzh4$xbbxP&?OC(>1b;q`|$Du(7IDj$!*Ei!~-`72!frH><~_`|Yc|4bSZz2t(?
zm;G_g+lfw&?*p;WXpZ4vBpn;pq+$yaG5pgX(x6l1cb{&497vGlWA+z>e=dQh-}Tau
zsS=j`151?+wI~Arc;x9q&`g^FR;CV5pX`?zCVo=>*-8RDO@Kl6$p>Y#LFrYm_H8hT
z1qnxN1#7smHM;LfDF3A&JPMGgPUzvDl5C~FwP$=pfQV|kEtC5!1IDqThkd}1KmSif
zxGQh&6&5=>T&EP9GGFhKT~tFaWDink1iI2Bnqd2u_*_PL{PV|vup<%VwzdC3Xk}EJ
zb&z5orkM*-k2S1m(D+&8^pv4#(&&=rVXiZ*-UVnQq@C#lzi#lfO#7^d1kanrv$n77
zsQ--czFhNt|I0hd^xu%Wksafa%unv6G73M-uQ;m}{i`Jl`I2?p0UI3PP{u}mYPA|I
z`EKGu##I_@&G2dE3**JV*h(n^C-|&=cR7AcdK{{RYoqym5&rT<z34XC@8AD4Z1fL4
zUq&96^em}pBv>2GFprHusRt1<cxb<pmTF0S@Vuh&|M{?5Bc}N26?3KgH_O7QJ(xi|
zL^aS5T1Vhpr15Xn#b6mIR$`qD6Qc|#{yK&K^GTBlm15UX-j|8gkv5fe!iE;|2~1|j
ze%NigtMgx8KHUuLh?Jxn8MclsLN3_+^%Pq*V*X)7h~7e^iOpU_{9gHD9Z#|^%B22L
aLQ3YUx9FGXuP31{KuJzrwnExG=>Guii$-4n

diff --git a/Templates/BaseGame/game/data/UI/images/Torque_3D_logo_alt_image.asset.taml b/Templates/BaseGame/game/data/UI/images/Torque_3D_logo_alt_image.asset.taml
index b153f46bc..a0e71c485 100644
--- a/Templates/BaseGame/game/data/UI/images/Torque_3D_logo_alt_image.asset.taml
+++ b/Templates/BaseGame/game/data/UI/images/Torque_3D_logo_alt_image.asset.taml
@@ -2,7 +2,7 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="Torque_3D_logo_alt_image"
-    imageFile="@assetFile=Torque-3D-logo_alt.png"
+    imageFile="@assetFile=Torque_3D_logo_alt.png"
     UseMips="true"
     isHDRImage="false"
     imageType="Albedo" />
diff --git a/Templates/BaseGame/game/data/UI/images/Torque_3D_logo_image.asset.taml b/Templates/BaseGame/game/data/UI/images/Torque_3D_logo_image.asset.taml
index da6130ae8..2315a3908 100644
--- a/Templates/BaseGame/game/data/UI/images/Torque_3D_logo_image.asset.taml
+++ b/Templates/BaseGame/game/data/UI/images/Torque_3D_logo_image.asset.taml
@@ -2,7 +2,7 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="Torque_3D_logo_image"
-    imageFile="@assetFile=Torque-3D-logo.png"
+    imageFile="@assetFile=Torque_3D_logo.png"
     UseMips="true"
     isHDRImage="false"
     imageType="Albedo" />
diff --git a/Templates/BaseGame/game/data/UI/images/Torque_3D_logo_shortcut_image.asset.taml b/Templates/BaseGame/game/data/UI/images/Torque_3D_logo_shortcut_image.asset.taml
index f780d2f0d..233a8b4fd 100644
--- a/Templates/BaseGame/game/data/UI/images/Torque_3D_logo_shortcut_image.asset.taml
+++ b/Templates/BaseGame/game/data/UI/images/Torque_3D_logo_shortcut_image.asset.taml
@@ -2,7 +2,7 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="Torque_3D_logo_shortcut_image"
-    imageFile="@assetFile=Torque-3D-logo-shortcut.png"
+    imageFile="@assetFile=Torque_3D_logo_shortcut.png"
     UseMips="true"
     isHDRImage="false"
     imageType="Albedo" />
diff --git a/Templates/BaseGame/game/data/UI/images/Torque_3D_logo_w_image.asset.taml b/Templates/BaseGame/game/data/UI/images/Torque_3D_logo_w_image.asset.taml
index 7d6d2fc14..f7dd36579 100644
--- a/Templates/BaseGame/game/data/UI/images/Torque_3D_logo_w_image.asset.taml
+++ b/Templates/BaseGame/game/data/UI/images/Torque_3D_logo_w_image.asset.taml
@@ -2,7 +2,7 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="Torque_3D_logo_w_image"
-    imageFile="@assetFile=Torque-3D-logo-w.png"
+    imageFile="@assetFile=Torque_3D_logo_w.png"
     UseMips="true"
     isHDRImage="false"
     imageType="Albedo" />
diff --git a/Templates/BaseGame/game/data/UI/images/background-dark.png b/Templates/BaseGame/game/data/UI/images/background-dark.png
deleted file mode 100644
index 13b4bda55c7c7c5ebc87d54bf010a5c06c32cc28..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 5751
zcmeAS@N?(olHy`uVBq!ia0y~yU;#2&7&w@K)Q9>#R~Q(W?pK9GlmsP~D-;yvr)B1(
zDwI?fq$;FVWTr7NRNQ(yJ#f-(1)jG1mahE`DlHEz5)zh~zxepOxpVT_WpiI{<FDm7
z!loS|^q>9Bv9I#?+kdw?Mc!cDDpK4dr}|{V&IObIM4p>g6Y)Ko^Y*WU@7C!{s5xps
z7vDHvSM<i$e@(5q>*e2`>)U)d(|VWdJ-$@8w31tXMb<)gZ@0{keYQFH(czMBs@q~>
zn&;1NcI;VZ;H3P{>CyGM=RJzzSf@WccSz#J^j6h*-_HNqIhTE}(1%yHFQ514PTwuF
zeDUoqk0$%w_WKpJf9a)Uw<F;xb!SdI;ri&g-!MvQ@%+u&idH8?zc0xPj<n@jGa>j|
zw&2wQ&0pKH+<f=_U_NB-v(+m8<AlzIKNdLja`C=eZTrHZtI=9I>REH@%}EmJb_!OW
zGp4f5o~+|5R3W3FZt!_3_u3tm$DB8`oai-}#Ca~`Qq7uoH$Pncb?~A@@l4^LC7G>z
zD%R;QF+6$J+KrK;ckN2O+LLp8>-B`!G%V1YDXbPzV;dW?^!KevM<e%G@$hc{o0DtZ
z;L@?yqm6~7MkTQ8N$<^$1<6eFo6bZsg$pQ@p5l!x66kE0TygA}wOh81_WU#%eTIcM
zl-Nunxe{6zC?@S!)miu`#AHQQ$mJ!G-cuwN9h1;KSG;OQgu&K~w3C~rs%WbC8b*3)
zE}vw{-Dg;8nRZ(9c??(6w15Yz6KWb47EP5}buD7;vRT=d8*2IrUI_AAUz*r|X@}=w
z!3R+}*Md&3EqN8;Wn1!gW3<2RccTs0+IkF1jwCAg+MIID4gTx#cIKV;D=#iP#(hO5
zy*$fc_T88ZHhv{W%!Yg{kIXm|96zT#6K*{)`A*6+<8I+Vw`o=nO=cZ&FepiqE!ntx
z@^4jh_R{}Tr1vX5SKC$Zc+R(k|A}33wd2~UrFTv-nUpJ<9Ocx!QP;es;1GMg-@a>B
z|EKfa>qCbBwB3z9oOeEUe&zi8N)rvs>bEg6Ffg`cIy(n=Iy=LXIxvCHshw!+ao9oT
zX#8a_S1mp<!NL;(b9FkpIwpr~<Ph_UUKq+g*?a#2Pv=RG9%<|lllc>|#%hPf>sJr7
zIGW@Y{QCU5^nxD!pXAgn!Qc1$<GXv0-^nVNX!)2jKW<nR>82$oym@D+;g2o_HiZN+
z#?F~lN_%HCKL4?+y?=dq;Jl}`@6KOb{lu5;hsz_&Wzu3F**<<*wzT-3I^X6=O9bW%
z_e+*IK5}1oT5o@$o|VprGaDv)o)vEIJetIQTK0@ro0pBNOkhawr`9#6xt{Bu%UXIY
z>iZLYo~K)<nq1H1Q|?n$nb5)^X*wmau~lQOl%`tH7WvN~_$~jb>`W<|dho=?2CWc}
zKKVcVb>-P&YU+2E1n|75+W59#P+<qR$?I)@YjbX&6+ZBvCnhtuek<ddnn`i_*%Or)
z<V)|^k(d2Ru3#rKkKM~jik6e+FALCMc%S~o*K)ysu@{lW)!A<!e_=ck5PsVHz(GZW
zs3mVo`^(GAzkPc@Gpyde=wi`wb1Uolz!Hcp$=lt9;XjbYV60yA8Ax#!ctjR6FmMZl
zFeAgPITAoY_7YEDSN13DVysf^>n?VEVPFvK^mK6y0hUhJ4T15>aoE7&$RF>c>?%UP
zwoVoSmTZSTfZEuA*Z_zdfJzv6fH(n&8JK|>Wat4PMpc4a2CHUbjfH8(v=AnP-AxG~
z2M%#JkrMo%(7+xs)D0(Ey9vK*v8S5B<|Z0v9dN!QHJoVdChQS&0F()_+I)avw2T3U
z4dDU`cMxLNoB%WxyA1XyqIKQ@nLpUvL~7mvm8-N4CsN&nHCN$@c)}?SQ}ZBm6ZQmr
z02n!=WeiH>kseUEf)K@6cqk`;f}Df|MeDpXTE+n5gNQ&LWchit9diJbkqDRMgDpRU
zoITjwL`3pOQ8L<B0!Cs25ECfKNe!pbG6oo=C@Bpikl|UU;4~BGd=96bZyD`C5#j0T
K=d#Wzp$PzOvP$Iu

diff --git a/Templates/BaseGame/game/data/UI/images/background_dark_image.asset.taml b/Templates/BaseGame/game/data/UI/images/background_dark_image.asset.taml
deleted file mode 100644
index 95c45a078..000000000
--- a/Templates/BaseGame/game/data/UI/images/background_dark_image.asset.taml
+++ /dev/null
@@ -1,8 +0,0 @@
-<ImageAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="background_dark_image"
-    imageFile="@assetFile=background-dark.png"
-    UseMips="true"
-    isHDRImage="false"
-    imageType="Albedo" />
diff --git a/Templates/BaseGame/game/data/UI/images/clear-btn_d.png b/Templates/BaseGame/game/data/UI/images/clear-btn_d.png
deleted file mode 100644
index 229c71e8bddaa102f495a3dba47004f9c65cd0d4..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 593
zcmV-X0<QguP)<h;3K|Lk000e1NJLTq000dD000dL1^@s6a_i)L0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUz^GQTORCwBAOi4*$V_;wiV;~-^VgYIJ
z^73K`3=AZwdj0zK4BNJC3j=9_Yj}S9HrJH2v=|_5{O9*?E*4hSZ<4C2XLDxFS^}iM
zfz$ytF)+bQ0cmLV^{x8#{X17&XJ^}@moH;M^!w+}<v`*fd6-(bCXfx>0s?QkPn?)w
z6CVEP+t+W**N+`j{PO<2JW!f(R$hMapFe*XQ8a;^<ei(l{`c?SjNiU}W1d%1Y=3;s
znq<>}fcc&U1q&WrzGU<D>sRJ~|Nb$;HG%v9vf=yp@5~EJ%j{0ATbF1a6f`foz5TGU
zkMHBZK=}_JKCu4%`<IyorU~Tf151`D+&Fns@$`oEiIyQDb5kZvIQZ+=FQ%ibRw*#E
zvVI4#|Ni-d&;$ylbsZfkKtITVYyfHa{p&Z==TDzl_RpQ`C$6M?o|}{F?|-2G;LZaD
zD~RS66nv~~V)6)N>b@n56}$ZWa=w55ESxrV$`TGP&c7%D0g8vBl`A{>#l#-3tgkQ2
zR8m^7wz;{KM@Z;(+3GdzvKks+{{Hz34m}oFOoJj$N=5Z+-m>NMzkdJ5{O|8yMqVD?
zKm39MzuDN>{(%B$^X5%VKwbYCk<;G)|Nj|*als698ry$h&@!{I{AFfl{tFTZ1~u4K
f&!0Y90T5sS_@w(H5qG>u00000NkvXXu0mjf2Ztbp

diff --git a/Templates/BaseGame/game/data/UI/images/clear-btn_h.png b/Templates/BaseGame/game/data/UI/images/clear-btn_h.png
deleted file mode 100644
index 5e67cb13b2b4a85172bfa47e74b66993f0b315a2..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 595
zcmV-Z0<8UsP)<h;3K|Lk000e1NJLTq000dD000dL1^@s6a_i)L0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUz^+`lQRCwBAOi4*$W?*12U?3h`U;%0H
z^73K`3=AZwdj0zK4BNJCGhhO7U>Z)GIKgXfZeFjXq_kgNUj7V-2Ju1S$m*D2rhp`p
zl9Fcr{{5R5=;ZW=4<DL<=+B=&tAoU08bN>s#>mglFXG_fcy{jGxe}m8#*ZI9GM_(p
zPV4K}uWDReT(?V0OVju5+t&+J`X6r7>({RxLPA1j0TnU5ee;GTDJjwa)albT#>U3&
zL4koCPoF;ZdGX=}>z_Y=nBbcJ{{71fH0}21PoJ2xva|ipoIP7*Vq(%dVZwyX5fPEM
zf$}_W-n;>6Vum}9nVI=>M@NUoh4be%&z?P7X=ZBLvS8uDP2azNXPP-<rYcbW%eSvz
znScNK#RAtPDk^$l*|KGI-@biQ1=#@7@aOj*#y78Cu>ylRQAAkeFdrZPpa1{=Gs2xW
zapJ^25Y5TSd0R(E=N8C@o}O;)$f)S{??1kax3#zR@eA<(K?!mT3yaSa`unr^czN$E
zUc7iJFaS<0UAAlz7dO|l>C>iXT3T9u1p0>&9^{~y21T5Oh2^KYbLX{x`t-3I=nMva
zet|!dQj))bw*LbK(3UM*m>C%v|1%<|J&=2U{P@8N#BBfm{$pZgW%<Lx$_n<!Utp+#
h)I56d@C-nJ0RZKU_!T%UNAv&y002ovPDHLkV1nFEBVzyn

diff --git a/Templates/BaseGame/game/data/UI/images/clear-btn_n.png b/Templates/BaseGame/game/data/UI/images/clear-btn_n.png
deleted file mode 100644
index ecb13a8d661317f38d3e4214fff3f0312b7b8af0..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 377
zcmV-<0fzpGP)<h;3K|Lk000e1NJLTq000dD000dL1^@s6a_i)L0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUz8%ab#RCwB)l08lXK@5e*yAx893m}0+
z4?=K&2#FewK!JcV4Fw%1pruKQbm>wAA<=LJelEZTKubwTGJIwqVjwiI($lj%e)b#h
zSV}4U^((?ZzW5oeF0X{QG;0x_gI(Zp1%{y0u%eoqB*Be}+Z35ISogfn=j{1}M~e5r
zom^~6<PFZmU-o3Ftwxc~`|t%grt*PxT@s(Tsa(|3ghnPfB-dAyMYsu4E~+@#kR=x!
zAn3v6q|U#1>`il#Z>bB`G@&P}3s^gaM{dn?`64>vd+u<n30q7b5HDGMKKZsi{|^>y
zC)Ag|rg#ir`9=|JM=PFw+g^xf&*YE1hYH5v6--s@cbdf?FJvm;W#*#H1Rw9<U4Q`q
Xq@h=ZBb5SJ00000NkvXXu0mjfavq$!

diff --git a/Templates/BaseGame/game/data/UI/images/collapse-toolbar_d.png b/Templates/BaseGame/game/data/UI/images/collapse-toolbar_d.png
deleted file mode 100644
index 984a63853c4fd48dd65049cdda3025de63842420..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 280
zcmV+z0q6dSP)<h;3K|Lk000e1NJLTq000L7001Ef1^@s66{oTI0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUyx=BPqRCwBAOi4}s&&9#cz`(%B00ZBC
z{P+N*3RyrLJzYHpc6N5S<ooyU1uk8^Iv*@4At}iqARqvjl>hgS0Vv4;mgMH<W)Kn<
zW<Uo_40ym0m%MrXI&R5Tt5#x{Ja^_a!=uMfuuE>;x)r;fhYuV;(S;&;;NSt=u63|?
zz%6O(;J_d!D}&pg-rnB0C5=o>QFLPjLReThZb@}b%@L7I2uePB_z*;W0B5A7%a^0e
egYzdqfB^t3O)<b{;yon*0000<MNUMnLSTXl*lv{o

diff --git a/Templates/BaseGame/game/data/UI/images/collapse-toolbar_h.png b/Templates/BaseGame/game/data/UI/images/collapse-toolbar_h.png
deleted file mode 100644
index 7e3de8387148c02f13b1e7f24f984de37feccf69..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 468
zcmV;_0W1EAP)<h;3K|Lk000e1NJLTq000L7001Ef1^@s66{oTI0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzc1c7*RCwBaQ@c_^F%aF|<O3+NK>Y)0
z9XimShOxs=YQDsp@gJb1gn_Zvu?5E&#SyLef*bddTyF3YCK)zo&)JhrF5V0V0e+4h
z&!GoIxa##X<m+==n=O{N9yuURK*SQP*N=dsnwM393W#xGCjTgBh9DS%*CeD2WLQ@(
zd-NMqWJQ1um_eB+OsRPw%T$R~*8MAczzo4;$qbQ6^L$>dV>0jSi8!D*$CI(frpPId
zoX)3*M|j)3>wnqT_NAKB=~Qb<toza?as>Cw1-x!H26BvM$lT86^U`fnQd^FLPP<cr
zPGyCunGV{Q7jV*OM5cpy&&=c+;;`H88q-x|B~$90w_0#|+|U@x-nxDJ`u*z|$CpsO
zva@DWd#f)2<GCaujUp6k$YZLR-KSllH$&ElJ++92;<+-WHWd<+{$Q41^=VRkL+aM$
zAciOl_BmkXD2RnU>Qqy@lE%w=B^f)Fy&H|PPw->A71`mp00RIT5=iSlljg+$0000<
KMNUMnLSTYWrq$s9

diff --git a/Templates/BaseGame/game/data/UI/images/collapse-toolbar_n.png b/Templates/BaseGame/game/data/UI/images/collapse-toolbar_n.png
deleted file mode 100644
index b36de3ae049d9743a09dc6fc26af740cf9841360..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 439
zcmV;o0Z9IdP)<h;3K|Lk000e1NJLTq000L7001Ef1^@s66{oTI0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzSxH1eRCwBSQcX+4KoFgjo}`B)UhJuO
zuu!2Q;vefT@mE<8g<ONiLm&_^J(Pmb9Cp^3x7jpb4h+f6%X{-SJHf~Mo279aC3kac
zEj>Ox_mJPyDg4SlUjSNW3W5uGwOEk!Lx4uX4pZl7UqAx0i=rnvSAdP_$$A20Su(H_
zvh10InGB}9^1v-*3Cso@F>PaL>L}8isTm_PeHKN5r}hODW+z|w`}Q5O#yHtL&*`VC
zP~)7=kRBzVBuOw+YZy|xe)*kcR2>cgwbuTO8@Fkiwr+iIX4$!2->q9vYwhDG`qk=o
zMb~kBVd5z4oUzQ=+;7}ZXk^<zq_MnNQXIwP3Ahy_)_rUrwy3$i&xWZHMWJJ2P1r5i
zFf9Aao&X^$0y1N~*V>2MX<21r!6szg-dfzih^e4%lbv7^R`VYwdnU3IbzN)k2xeK9
hJ@8zg^|AXCU;u#ob3iiM+rIz+002ovPDHLkV1m|A!NdRn

diff --git a/Templates/BaseGame/game/data/UI/images/dropdown-button-arrow.png b/Templates/BaseGame/game/data/UI/images/dropdown-button-arrow.png
deleted file mode 100644
index 8c420ab85dad8b5ee3ca92464665ae071a471732..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 132
zcmeAS@N?(olHy`uVBq!ia0vp^EFjFm1|(O0oL2{=BuiW)N`mv#O3D+9QW+dm@{>{(
zJaZG%Q-e|yQz{EjrrH1%sd>6MhE&{2%E`$|abUXZ<1r^pL9db1gt1VxgHed#<;qq~
cW)1^}6XL9#0Z$iS1nOY$boFyt=akR{0H4Any8r+H

diff --git a/Templates/BaseGame/game/data/UI/images/dropdown-textEdit.png b/Templates/BaseGame/game/data/UI/images/dropdown-textEdit.png
deleted file mode 100644
index 3966efbb56239be59ee13cddceab917b144882b9..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 390
zcmV;10eSw3P)<h;3K|Lk000e1NJLTq000dD000vR1^@s6OE-s?0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzC`m*?RCwB~Q&Db%Fbs7dAnmg~0N3Dm
zSJ*M=fx<D$4K{82fFFLUonYM`QYUQ#(n2yPC~3mb)J}WBil1Z0c0z~*!0$THoUs+o
zTa;U6$Tk~5n|1iXvy1>^?7l2ZX@QwNIJ_tdJyVq-O;hN*R;|Jf8oKt&?reAz#jswl
zv@I};de2`VaYRw1b@G>k2y~N}rTzTSqF{8F^S*<Z-A?<`rSj&bDlUbDIG)P8JV*-L
z)5SqT2%z-pOcKH{@PkI&X-T)75ICMrevlZ?j;?NaKmy?WIL|b~l5Tj2gY*6$F86K!
zszt%*E`L89;Q8s%zg&Vf55q8(GwVrlf(POD^iWlm{?iSTB=Ld_Z<@vi-PLuyMVTHU
kN}lKEM>pfDsBZxV07vonVb4jntpET307*qoM6N<$f}R+y&Hw-a

diff --git a/Templates/BaseGame/game/data/UI/images/expand-toolbar_d.png b/Templates/BaseGame/game/data/UI/images/expand-toolbar_d.png
deleted file mode 100644
index 462929e95039217cc59fe50d6a95c2b7054ac0b8..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 278
zcmV+x0qOpUP)<h;3K|Lk000e1NJLTq000L7001Ef1^@s66{oTI0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUyxJg7oRCwBAOi4}s&&9#cz`(%B00ZBC
z{P+N*3RyrLJzYHpc6N5S<ooyU1uk8^Iv*@4At}iqARqvjl>hgS0Vv4;mgMH<W)Kn<
zW<Uo_40ym0mArZVI&R5Tt5)KceDwGU!?`o3aof3d>sH*7Al-)#9Kh|`0|)U)I@mj4
zmz0y0VX$?;A?fYyjom>YT}CFR*d@cl!f^+Jx~ArcNG3!}K6>~NM125fq@~N3qsxQy
cCqRG!07OkOz~-BXZ2$lO07*qoM6N<$f=)$pfdBvi

diff --git a/Templates/BaseGame/game/data/UI/images/expand-toolbar_h.png b/Templates/BaseGame/game/data/UI/images/expand-toolbar_h.png
deleted file mode 100644
index c33bcad6985b3862324279bc0f5457755b94f28f..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 468
zcmV;_0W1EAP)<h;3K|Lk000e1NJLTq000L7001Ef1^@s66{oTI0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzc1c7*RCwBaQ@u{ZKn%8hd4P^(2=E4U
zMcrE1vs7$lqjR5xx#At#F=MM%%plelAwdv<sZWr@_Fb;I@Z&0{`aXZ(Io~;WGnrWU
z8GC-F2_VANXcQq|pJivc-rOe032^};2C&;b0?s;#tO_(h^b0fjM={e{!4MKHLW)3!
zbxmZCeq)NP2vCb@m5IWXGh4Dum0V@bzp^c+wN92?Lj=#;os;Ls74yEn5hwG-TsO%V
zI7KcoWZ<oMho^@}{V$K~6L?vPJkJAL_r)eM4ty;NxZkWbN7oPrro?i!3f*g4rU4EI
zLzk-wa-ZCQ#7UaM;PL`&W%b(BKI6~KvP?U*SULMZ&opp)oWgm(?;S!fE8a45JiZPJ
zR*m<QAXj$Q>qS?llb{VTLkjAsY;|aeyj=$>HXDkKfU1h$Gh(W#P&4TdW&oR`Nq&a3
zTN8um?Q=toI@keY`=EJd?T*CDZYvdgmA#wIqEGOnEJb$uEx-Uri&4ja71Rp=0000<
KMNUMnLSTZ?xyoSx

diff --git a/Templates/BaseGame/game/data/UI/images/expand-toolbar_n.png b/Templates/BaseGame/game/data/UI/images/expand-toolbar_n.png
deleted file mode 100644
index 0af2f1bd13809d099ca3a5a5c9ba1dc42b6f66c5..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 437
zcmV;m0ZRUfP)<h;3K|Lk000e1NJLTq000L7001Ef1^@s66{oTI0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzS4l)cRCwBSQcX+4KoFgjoTP^&UhJuO
zuu!2Q;vefT@mE<8g<KPrdI<zf52YY9huv}JZ8ql1fnj&w%X>4~o#5^Dg=ri|$!*BY
zbpP<!V}4Gj=;QPK2_#!fLGVXj%;zL{1kxzkQEDB<g(N7uEHKGX32RKx)(c>3B?F$Y
zwO%=>X`z&@9drv@g0dk;N^TmO`W3-u+KiE!MNwe&sko4$lziUp$nSm5RBnu=@2aBx
z{tJ6eXN!gmYNct4`g&Fzw)&+;bvRI-=QzXGHr@KjvWz??HC?wpRyQl0+1YZdyi5{W
zUN4=}-z_)f`gSe%?Dp<%8~-FuXmPb@UGQXjFw*+wZiCf_ZQoNiaUAu!c4K0>t=SF5
z!{LASY^7JJHJ)q5(e1RYDluRawr*}2FECOnsnf(0O2YO1qqJU$>_lDHiXEXW%d$tF
f>$5J~UjYUHlxB7wIAEv(00000NkvXXu0mjf?KH=8

diff --git a/Templates/BaseGame/game/data/UI/images/group-border.png b/Templates/BaseGame/game/data/UI/images/group-border.png
deleted file mode 100644
index 61234ae1fb3dee29eda38a371165d36b060ee426..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1273
zcmV<V1P1$wP)<h;3K|Lk000e1NJLTq001fg001fo1^@s6#ly*40000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU$n@L1LRCwC#SvzPIK@^>Rq)0SqBM&U{
zK~RE8k;)fTv@rNVFsUphN-&N10jmTOk|LETicKV_m54TpVAK!`|L<7|`4E(7K4ARB
zDus5>J(HaE?!4W7v&qH}czMI@+&44#&Ye5=o}G2_O1ZzkpGs6d@8oj17WcW!E!8%I
zG7SwXm(AMBn08BdCX>0T948-RoKK$0X0t6*Q&aiH#l^fexw~LXm>2UyPMmS3yc8^%
zPN&txvs=#V2iKgriKmXs^9tJFqjWWIBOj#Opr!-61IK}Xx1-s?{L4G0_&?_ilXv4x
zqfZ_btu8MwSK|-wsQY~v)cnk(&+H?8J(|C{sz$fn!M^&){#~l$>@n5f-deC_;MX2J
zsxZHFtA)8SUGF$_vOr$N_B~qGz~m2~oD@4WwsorNs!FYtyCThVSEZ(BX4T=g^Lm1w
z!FRq%(Y|`AS3jc<Cv~l&6_5**^nUE6$45<haxCVR@=D}Nj$a<p%0U1uOeL}MFv2(#
z2tZ${WcR?^$Z@ikN(RYGnG7hakE(@|L4s|Rj2aszuRu{)lmx5FZHXdSgCyM`&REk8
z0u@DP>65Sso~f)<#1w-6X-QZF0;z1&IJw>OAO*=w$<u9aw^a7jxpvjrwAD8lZSX;I
zyD1QJnWq}GrEaI@2l*t&n({nFPh5Gd-h59NoYL0bejO_A4ZrY|mvwVZsn^ezHdWMl
zi#O##dGJknCDJ-deNmOQdkZGUfAxkn<>5nIM949%2g^Yzljy(oWy)Hf<EFN}n}?Zc
zLapFC#cs|9Mu?HF^DdrP%GqLE9C^+^gPwq9Xi@7?hD9wb^UI<uhIxYMYeA<p%Ga1q
zK^r%$SL@13)%@pg+Skx0PVf&S@6;o9F$W`D;8Zduf{z#*WH~5^XfZqf1Q<?@z8X>=
zKP~7s_`nZIkS{YqF~l(je$;4#Z=xBAo(3O1_wqgCBii5tJte9r;~AA?zGq4`(Ts_n
zWQL)#a^A!gm6r6qM+nP?0Sc)kNm@4Xtw-=SGYrxowl6GaQ(5@5B&1Y;X$f*x_i`5k
zxlG?JMp&eYe3Cfrf#}H=#@X;~|BtO`5XzBM3_XQWv3X-F3LkUd8np$mW$;ZD@}tlb
z@grOWzKMePX$!hz`6y0z95fS#p0K!L8Eqx>`_a=%75$H%65feFik{-gOB_87-@a&t
zo=kbNraT|vFoAMIeOeI8_0#*bHBgfWlms3M{F=|;vk&HAk-V?7qf70j+dSQteXuCB
zxme0WXRY7zZQiQU6W{Gki*a6ad*$6z80sP_3%q+`TtsI83dY1J6eRh$8vuYoz-JP{
zd_mbs-aVmUVdndNBq%XE#kqTuz$8gP5_<Q<Lj%j8Z38TzAeF>U;MoS^Nw<l*Ix0X<
zunJEqYTTO=92dLblEiH<HjY;~oP)a=diNy#h{{q)8}uXvQc2E>xEOTzWZpMPmn%SJ
z?(zSC4+0292nh@kvId`u$uPqZCPNED8bgi@LmbC`Ql1P|ln1?_pHA~@{Z%BXuPKfW
j%4_?bDUt6}KLr>7B{DrC{G$C100000NkvXXu0mjfaJE^D

diff --git a/Templates/BaseGame/game/data/UI/images/inactive-overlay.png b/Templates/BaseGame/game/data/UI/images/inactive-overlay.png
deleted file mode 100644
index feab83209cc442c5ad8dc73c2b86e0a8115c4743..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 131
zcmeAS@N?(olHy`uVBq!ia0vp^A|TAc1|)ksWqE;=WQl7;NpOBzNqJ&XDuZK6ep0G}
zXKrG8YEWuoN@d~6R2!foRZkbkkcwMLfBw9D?8~Obq{gPz9LVg>D`Q%4<v<{Fdsia^
bBOAk++056YCV$cfYGCkm^>bP0l+XkKL$W0)

diff --git a/Templates/BaseGame/game/data/UI/images/menu-button.png b/Templates/BaseGame/game/data/UI/images/menu-button.png
deleted file mode 100644
index 3cfa036d8f5ec1d5458b0716efd2ea477cca0c6d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 3559
zcmXw+XH*l44#%qqWh=YvT0r)eB~$h+$R3K90<t%X1sPJ=y8^QJD$u7ONTEzYK(K5X
zGG&xKEJ&3CKHk0e{mx1LImw5doP0?V%%FO7)Ev|R0D#UwU)%gj1+T1|lH$t8t%lwN
z0H}Y4TG|GiJB5J#1O1+Oc)Nmw;r^~**XJHj0D$M;&^ca#qFB0De}Y)-J|3A!#7SDZ
z0_`Hy(w*&)`#~=(GKQw(3vT!LmRuXG|8wr}rR(|cbO|Py1ga|d2eq8#3`S@MUT7K?
za}n9~uyb>77sF2cwE-f$I6Ia@lP>$8pT7Xdg|&C3=D&EmKGZR$`lF#_rjVQMSf1cG
zh?Vs{JgjO98lRX9I8ZMpGN$D(cg4|yWM#Gr1BM+U_x~L1t&cullRR3652VcSP^l4?
zNhd7o?|JE$$$nu%dk;B?m_M(2xm*r8Cpe)*Ov>_F%Y)DlgKYyN2XkdpZ-J=8UkP6z
zjU(Ik`V^Rn@S3#pJyGAi?roxTLI_?mu#ku)NZ4R0x=laq;$b!pXtIEY9_W1iY_obC
zcMfPFFxPZ5_BgEm*Iq4Wx8KX+7M3?DZzImGE0Ez;dJmkE7D?8NX*g<S)8WFA#vCj8
z;$?jJN@RGK7=PKUeOMNP$@k?W=mm{zrqadeqg$|z{=2>}&`P{BB%_3%QXqvdF=QX=
ziUmTOiaR$HMlTa%9eST~P2k~@0PQ_)>Hbg<2KjURPMGUvWAlpbO0`q#anDoGyK!xW
zh6(a>p1{P(4)~q<@V7|^w0x4v8pu&Ii*Q8!Etr0vLr+Xzf?6!dIZ-Lw*4aochS|bU
z2?cH53mTNJE(rQ8*RpCP)KGym5^iqVsnzQ*L!t2Yo@jJ~2Te*d2T_5dZMQRyCv2zn
zjbj)mW|WdI^)5lEJXL=2go#Q@7N;^?|6UyHU&&(q&||~O`jN?z+z&>6L!_8aZ4=Pz
zlzyIVdMTGA>vj4B=TmmldH$KBS1D4=$qHH)NZ~AD3mP2)(C=ryubaJ9AX8oN=qr3J
zJlK{!tH2{m8bmwXCUn}fC>W$pc%nfpCg3}rM}(gKxrt9UC-yDaEOk2hd=PJmV5)dP
zStV2<c)o7m_@ua$M$|ZCto?+4WxzYD$hFP7Eaf3K+qJ1P+wa~yqQ#DuR4HU$KXd;k
z(g~MSA+Y_x6PHT2u%6}6sY$RAnIwWpwc)sSbFPkRr+c7&s|2i!H(BoBvv8+K-%^-f
zF1;)t&>_4HT-VR|yn9s6hd!d}dxo|%w}_eznQ4><-#H=v;&*&`qMg2i9;b|GnB#q3
zP<h=FzW)}Jn0-KcUF&sPQYyzW7weSIwj0eP(Gg)p?t*aps`p)R>r`i&azOKhf+nBN
z-J&i^zIrLG-R3rNxW>WxDT^Kh@+cZ4prOfj=$}~Nc8D{uEu{}c`Y53c*jTBitGTLk
znyj}cZK}UVEjn4)%jU~beKlI^3Auh|#TkX0wl3t+-jPwAi)k6=;+hrS@R*OSF$_e#
zEPkxR=BD!;1yodw>Rd5Iv~PvUPLLd>{na}ysjPWK>V-vX0^8NX5KGRsG@Yj%BlN-)
zZN1-<;zUUIR9JdJwc0Ga^`)J>4N15bA9h{sD6_5r$H)2OlSabc?e+9)YMw@%mp1Nl
zgBh_R-S*#Z-hiomp+B`)h<6n;IT78Rgv(*gi_pXEM{dO>4V&XWgihK->h2}_wB>c4
z=|MCb&!?A-16D3yJiI>NhNu!_nW-7}1S6_Wi6~zx5pDIr97S)(dG7p`3mzi5;;!E7
zb-Pysslak*`s`7uLi-moDVr0_LuI=W7`Fg&=Vgs7I7d-lf*bV=DI!>hd9Qdotq$DG
z`85Ug?KpL3X<d*VRCXij_<hdzpH$GrpdOnesToeWnX$TPW<#4p4T=reTa@O9yA_Q^
z#^JlhxgDFTbv@WkX&>K<qAh4hW?xeHP(sjx0i!Tb#_*&!>7GhMwxKE8{Z<i(a|Zv;
ze%AP|#&uiyK>>^_42ORbpcst!#1JNmXnM6o5O4O$0RQHcN6icK{Wi)SI$e>6*5fod
zAQNw6klE8NXxii><I`_6S-09@0^cDGLM+dsx$ODVgcsJG32oJ35a*|<aP$M(ySKVW
z>Y6lr>KzEwt&$8P<hzZ!Wp|R%@AxfVAR1d7;ddIPcS?kE<@yssqEBsIH|J(ETy(!#
zFIw0S;%?TBoP3}*dIM)gB;1tLajT=eb}PP!XHMGivyjO^PVTpNs<`c@K?GfG<axqb
z%@;7AX1ZmXRtT>{7p0LWS@wb1!@&?O7~i7zu8k#pyDaL&A2#;FwH}<5GB4$4yUg*q
zW8Kke@GQf0L}#r1I_y#j(h=1EOmufk0gNYS_;g`PleK@e;ZYgAwD&qE6xxxM4R}}E
z>^Ld3>34>?=dBiyYP7nRcOW$LLB88UEegcQJr^C^B+$31^BDaJCMigGqxMFAND^d`
z?Jkq3Dml_no1xOg&*xcF8b7Q3T>A#%MvT`gI2tP6o~9`frO+YOeC?Cg<oaK7hEkPw
z<sBCFuct;Ipp;1RxdQ3Q6)b(5?Ci^K-m>N&)5Y~W?DdSzeEXS(eh<7}Yc{&4O6l0j
zD59-Zqgk1uKK<S%*QVtRP5<H(!{~vUDRkK~n3ZrchA(5gJ;7g`7~|++r~1tmb=RL6
zNqL>!lBz%{XfJToQ?h+Cqyz}5auKgo*L*a2ttS<*C&ZtWDbA_eJ67c+45&tk4e5CL
zH?~@}3Q|83pl&vV;ck&wgp;oq*@dQB&v7Xo;m)~Ym$h#{q5{nt{B}l_;%^~MEB^A<
zJ68`*CV!lnoZudr-Fml2hBxbdEF<K!Gz!)4+<BozP}&LI%-+?p$Dz^o&j#bHrcA=t
z-pz^FD@Pc2L9<cT<a-79){4EEs^8$?LZlaSg(ee|M|Pj3DJ-wS-C#l!BHc59Nk(T%
zD1zqbBac^)!VORZ!5$eFKKt@sD1U)Ow!HlPB=3@?U(Azu8n+t)pOk-7948J-pK&lS
zzTJ?LJC~sPPU5CNzWJlXukJblzALpj2js%jrKOzTq*=7v_o(z5kN2iK#Q%rnXV4Nk
zef^x%#a=jI)ObAfwf=TE`@^kLhOU%gx?uQg_2a6@S9;a$IqM(AFu)i_R63tOoBL$K
z*lxY%U*=}dQy2mPfgU(E^q;97wo2gVr})9lls)5OM?KXJMu}KWq)Y$V_mjVLeKAG+
zU;R=b2R?<PJg!BPeSTIe%3>z@2^87Kz^npk-v?D`H8bVOV)Z9Wdf7A97Q1_k!vZHI
zg@hb_drSVVeevzGPLGr@`BC(bWzIe8nK#rV=2?8lM<_FRYA2YPIZ2;olLJA<Z<@4w
zM|ynAs*7i;z33#s46Y=U2i^>c7Qfs+*wz@~Jv7aX!0KfN6XUVM+5uB@4_rBTOP%~f
z$mE}0y8&}UZGM<57`ePV?dkq&Yj0c?a>`H$e-}j)l2OjjJiqIf@2y5!e<QDS-Z7VY
z*{URsRi@hJl!&#6VWCqiFxE*u$?}4fnm>AwCQjGs<AA!_@)B{}o~%}W#z&!7HS$@n
zn60qMu#s#%%ly-|%cVTO*+t(^yjDvJ;TSAdqjziZhNsnf$UMp7O^349KF!6OPJ+zi
zwpPC%<`I_*xAPYvyOY@M%dpXu&6%-H$m-q%@BO+<4e1iz%KO|FjTT8|lQPQ}GBQ=%
zK^B{5r31R9KL;{|+&^F<B2;I)xZOJzW92K=|3FH+R2I}#TwVqGdBkQHmg_>Bo73o*
zr%$o?U)`v1xS)1X^U8%FZLLra&K=D05#za$=hbp~1YIq!Th_GwQkiUHOp@$fh<zo(
znx+f@T#ND0(lRs9()#}ae0BB~glDMg_iAu`dOVp3VY#oYA24Xf-4|UGUvAkz$!h3O
zY6X04)Ky}jg<M?~!mx6k+t%O1DDLj8h)_oJf}yF<L<#fNKS<3a(9KlRkAtPP18(qL
z5o0+rrl?vwT@fCp_pMe9B$jKm-D%RV1fJ|9oWLlG)^>T+I+t|d*~C_Ly<(&S`wCOS
zW{$6IA7`Ize)b5wSh3F#srdq`;yXs3z}qT;J@0Sbde<$hrF%!tlncU|#4Q#gCCV=H
z<8FZV1Gyo#MhVe^7R9<O4zI=6T~awS))Nn_m68>+(=`|&E>mW@<g8^)o)tOz;}Kta
zd7qsd1b$u@L1Z{zv#LqwQvbz!elRU&Y|>`X0~-4Yo9E@zAWDqY&z}+-d=yLpe`NhD
zn=ignNRbReJJ33*QI|d|t8M7dVci?_QYRHgvFrK~d77nw_Tq7cji?@nk`UZJx;bqU
z2-bQez6=1yb-QOY&ZsUePR`ADx!GS_00LtIt8W_scdi~23Yd|e_LW}oTMHX`B~<?U
zc0m9D4b%VZ8X&I#bd>}K8<^+-*Ke?ri}TMj+=gAHRt>c8TR#7`Kixyst3j*N^EUk>
za)`?&dm@v<+xC5&*puKXCw2tw+k4w$_p;Vyk2M4x1V~$#Ln@6&-97&xJ`n_)#QhVa
z7_C<0q7Z+>lpmSz7CK>_)vGXa>P!DGQ13(&#lNvCGhE>MmxXXxP%)|f8~w84JXYzS
zx}su(u>ALx|6!RR5)kD7FT{A9At4W5^4d?}aJ(b`pJoUIQ$CF8?;g;s8b$@+zbL4w
ZSBpO8NK=0oeKjq>KnJS*AI-m_{|h>L*X{rS

diff --git a/Templates/BaseGame/game/data/UI/images/next-button_d.png b/Templates/BaseGame/game/data/UI/images/next-button_d.png
deleted file mode 100644
index 76c3ec0ffbfd0e390d18bf15b641406a1c963304..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 279
zcmeAS@N?(olHy`uVBq!ia0vp^+&~=2!3HE*cE)T6Qj#UE5hcO-X(i=}MX3yqDfvmM
z3ZA)%>8U}fi7AzZCsS>JigtRsIEGZ*dUIWo&smX&Az+(=poWapS<ZhfQfC>z@o$*?
zhV8dl?=!aFoKn4xeZo2Nf4=Qb$;zCp)-ipVh!6ks%DPE^D{?9q{w<lM=A>Dx9i9DW
z-@5CHEdniu-!^_}`*}dN=v;ZV<s^M3!=xh}g8xOP2R*n^&41kT`NRkFoH+{aXfL1g
z;BtrIp^b)YZBv6>vUv|*i@L#DeRZC~n>o$)T~mbY?ZFzA*KO@H&DTlVp33;PS)Y-O
Z!Sa~S%jms^DnL&#c)I$ztaD0e0szoGZ1VsB

diff --git a/Templates/BaseGame/game/data/UI/images/next-button_h.png b/Templates/BaseGame/game/data/UI/images/next-button_h.png
deleted file mode 100644
index f52f5fb4230f07e879e02d61472b07c57d07712c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 549
zcmV+=0^0qFP)<h;3K|Lk000e1NJLTq000XB002=41^@s61i4(d0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUz$4Nv%RCwC#moaX_FcgOWXDpHtp)j!1
zfrS$=A#n*tE`WLguF!ihvT%iRfs_GOCWcOgCTUXJiD@7}oJvtssSg>0-qXkL_v~jv
zlgT7TvAv7&%t^dYr_+a#hr^+@TrOWYNQ8?)a=v3urz2xpTz;W+6qyRv^uk~=B$Fa*
zY7trZc?lJ%X2T_NO4CLKXgbTNCUvD{m}Vo<o4l$hO0njO^Gt>^YPY~Tkd2ce$z(`A
zSFm{3{j7pUGGsRDL1tMpV+>&!sySO(N(;fVWY6>Px?ZdKIygr@9z84;3mir8H9bcT
zKSQ{#tA_9UkIBuZg(!-!TCLy*m)dh=+qMwLF?PEhHk&s@;`3dyZQCkM?RFd6?G_i?
zH&3?FXf)96b}<|dg{<ZcGE0UG=A2_N7@*(p3wM0>B^9J^vSnF{HXe^vpq8OGKg(`@
zDPc4kq4(575CoTb2I&Kvq)6s=Hk-l!@S!1z#rXq!I-TG+j+$?6tXwP5KmRLDro?qz
zvLl(u&>hLB$<Y5bQBQKE{}{8U_?F2oWxPP`H(H?fF_f_CWRxP8)BFdsQLzkZ^0K^V
n`~6-$=BeQMd~WnS_$9yqEFfuLSH_B`00000NkvXXu0mjfAI|j7

diff --git a/Templates/BaseGame/game/data/UI/images/next-button_n.png b/Templates/BaseGame/game/data/UI/images/next-button_n.png
deleted file mode 100644
index 203133732e50b1df6bbd9506cec49f44385cf9be..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 484
zcmV<A0UQ2_P)<h;3K|Lk000e1NJLTq000XB002=41^@s61i4(d0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzhDk(0RCwCVm$7cbKn#Z6h$UMlk|hs7
zhb;8P`jQz+MW;xp6CFyHNHAo`6q5@$+$BfOMx4Y+9&-6G{(ZI&-o7_q2<~<2>=P8+
zw(YFdb&VZ&3=k2N&8;vD6%z#@SPPD4Vq~7_lP=Gm!*~tPGFXzjSBY6BP=OAZn1#Yz
zeMOAFs`Cm16Yd2fQ=s2N5ee+0alltX+9{%Ju=RO7?f|t1WmQ!f&x7^dJ=)Ck+zLbQ
z8C%e;EK4{X{$aeYESPxc)^_`2^&U`(>ag;@-~WwZxO#4HMyn_aV}GbRTk76dt6?AK
zsxC<qNYm7S?;c8)WyYRaqS}i%jv-zyr?9O=Ki2EXHyLfEzl@^D3WMLdfy_?9hvx=9
zYi@u<AQ%D}7sW*&!N`DtF*oQI;t2%7+|XbO1Dzv`b=)NJZV%dA^R5Ykk?9$^7d^@6
z)yBiwU<(9R)dBwky2UI>-Q@=mGD}pHXHn{a?_1VZvZ|8^e0u7drcunPkNJ1EWBngI
a3oroff;ABVIBm%Q0000<MNUMnLSTZF<kEux

diff --git a/Templates/BaseGame/game/data/UI/images/no-preview.png b/Templates/BaseGame/game/data/UI/images/no-preview.png
deleted file mode 100644
index fccdc858bc36d7e390f8f1b75f9604f8855ce112..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 34615
zcmXV%bx<1(_wR9ccc-*KaVuINxD+YU;O-D8?(XhV+$Csmx8m+l+}+(S&-=T7WHOW4
z+3X(up3j~QQ&N;dM<GFhf`USqkp`$hK|#lUe3+47K7KKrb4dF5B6gI}bX2u7b#yUs
zFo6;^wlg%LlCd!`Gf^=yFm|&aG7*G=3SN={i2ih4K50izq#JOfAc{+J%J!n15#mfm
zh1ExZ!o;F8g*vO8PnPJ?ZD(+ofhlm=EmS94tfh-5_%5ScWnBejDRC$>0druqyUGAf
z2ad>Nqx!;HkN3@2CKk@`8z`1<ua7J>Kjx@X;P?CBU}R*dAY(aWc}p1s?2xH~i<-Kr
z`d^Lp_knvKk++8dk?1_^DDxYe1O90)i5XCFl>^$z^TI~!)xVe`qxRnIoshhPFo3FB
z{hN+F{@cAk_VejMWw<2QQ=s~7%e=Man|?t=r-O&sB!j?PsmFOp0HcCkgCn@m#jA)N
zpAhv@Ub4SQkMKGn`w2p_sxlQS`7T*r*a#%~4x8~;C{HZ}v}8H~`gtM8C;gpC=a>S#
zWnZYIq*|)^J~?cv`EmGve-tHYX1+@~`7QfIylUBjDO?>&4O~=oEaWS#{e@ur(9s$y
zg$t&_9FWfn>tEq6ZbdAbOn82P<oi-H`aXmMoZ3c)2UFpUnivI$mLpYv+;0b3ddoBb
zVi|#|i(Eu?nfc>L_6b*rLID;+BejSM6s1d@D2EmQ|Hnp}CV-f-^{c-&9^nFionUgO
z16jW~6Um|xqWG#?c3!Jv>r2p*cu6pk^H8?TTF@=>xKNOR(V~LZ%<mEni_McpFi5~O
zT^}|Rqd*`_EoH)E9$BN+xsrvn=Bb^_Fc}*!p+1UMAWQn<e>j2=eB=b4<5Jb|MfIgx
zbOE~bftTAG#uCIunJP9s6;I3882`IfBdq+X$)(yHdh)LBfYvt&|J;JbFTmZ}8u?ER
z)aLlm>Rfr)%jP^bQRe4yIqwO|43^VMDkqM{oHd@pm7iVnSsdX0vo2DAC7`}b%@LXo
zV-qgmXaAZ2P}w$Vq~D0W&2Qn`|7^NIZ2{>0ihn}yKzE!3)+K~Hlz|39H!f>J!l9T*
zrjTI4eE<(BZRFceW-bakY23U3ohhsE%(Jga%dWQncOi;wMB06mJa%((>RFo+afX-%
zqFBW4<y@jnYHF8k+Nb~XN!Da|GOtH${y0>=%QpcDrgXyvap~H8`E-E4xc~pzSST0&
z3(>6D_w2RiBojRG9aJviQz0DrPa&aN68{;`QRD&O(b=rF!cgbFSG|MEh7+clixo4F
zl-qLhKPQo6rcd9|aJ-Fp=8`_J<94hu!7Wk!x@$|9XY6&}rTx!G{1jtFC+=ie;Fb+_
zQIz7|cvdzDBf)l9AV;8v@c#@_Ct8rIAe1A?)u$rL3bEws{e=ag5ruD>1Ldjx&!_|D
zyGboaaZFCRUYN=q-=*aHgTw@rBGFH8WBz9`{!l0RUN7`YRi_W<P$|@e)KW=H304{-
znmY^P`KpnSuE)-}9#wTXTx@ikOG@PX1i<N`<DemkmN(D@KP_?I))g;_)VWX`Ac28k
zHbOXT8#-kYOIv*Q|5Bh%f3n1J>XqEcbF!?yw(aG%iskio=3=J#y|2gctR3;M@B=lX
z>(DdeB$~Y_mU7*8Te@O@@Vjd0|1K?1UA?!GW$NhV{B3^aeW4R^^vWG|LtEqhCZZbJ
zTH$@Gc(eF;hF_w5;ePDi`>7PHWuPk8|F7e<`StmC<5`H$|AH88`(ip20Z=|1wp}dz
zih7aoD(rRL@$VU<?<#0^?Ab6#>``FCl8I^eTu{|5Oc0Txi|4KzbK*V12fTy&ver{(
zcINo=M|Lneg|_z*TR`>nDk6gj=zPcP{{K#o3!Kw&Sb@G(_f-{noBY9P$o+;XBKR!#
zPL?O~_LwLiH?D6sq5byb{cSnh8#@bA1iG`q>+Rk2$C*S&j_t3}cg*+v8@c=k$*}V9
z7;3%S(Zi!JFlxI-1L-3pf`K}&TQZAK%>)?aK-Y^&ePN83%NU;*7vcLAQdjYR_xJDJ
zakNs4BA66{53_n+^yv&!MDft(@EIaNH}K`9IedlX@xC{u_fu!!-(a)1N7f3j{a>zR
zOn5GoZ=_D%xmJ)oYJ;cf*1h+cY!psCYPWK0b#z-2SYP<+`kPbQ-R%LQIm1A!1=^UK
z3>&X2)ok@V0S=O>3zAv>ztBJY^kG3EQsp{&PZ3n+L6IlV(G2e}Vq(TShd<t`-c@gh
zRqC)!>5%?0CVUDSBmbpc+HZKc(S4fj=DLpigG|uN^4ut9_wL**@c021v+HkNwRhxy
z*@ylE0%JR8ZJF87p4;iRz5j+Cqu!O|pMwwE7qtE)6#i>2B_{iQlr`AH(!!7=|ITm>
zV}tv->-Ajt>U0HDq#x(vduvDCySl!?>$6g2J{bXA*2u`nKs5QjPqWW^hha^V&%5_S
z^OuPyh|u^&r-<tXl+YzoYMXw^R4gh&zyh-FYXa*uv%tnI`upa)fjK_ZdCBiD!HCx}
zZ);DNM)ews6<*s`)h0e$=RppZ!4{Dgy<PW3XSPuL?&mf643us+JNYrw)tAqR=LlEu
zAOdK0UMi=D!>XPMqf;fH<9RS5CPmvltccTj`@Qoei&V5A?l3g0FHETQsm&M>=#dR=
zyDz2v^OG5|1GF=F)BPHzBeZUe@Y643IFGn<m?GiF9m0oo!Iukh=ym=+`}bE$zvFdl
zju>Y$GO#N)tQXs}Tz1i~->m$5LF$k!x4Zkdi`gG*GJ_*_uOn;F5kT$TZ=}K1El#3;
zG+UlGE}zF@FOm=`>GszUN0%YKw>t?xgrAny`MsVT8R~-2HpoMSFT=z`gt7nph6V~f
zEwSxm%BO}<J|#V$cXmd6!!$$JuP5V6($6`?=JSTC5YK*ij9&Z6e;hI;E(DX@CQjM)
zWZemcs_$ZJ+imVQQ-oMX2>j~vdiYU1xJbEgJ6}Ad;;6j3`qYh`&WlALPrIz#6PbsZ
z#)T?<Tj2yeS~j@it+t7l?VxinF1iz3Q=1+#0{I0kyVlokpQ|4M`AL8u`W#&p6h1GP
z=#kqS51T~MPVpE})6lHYqdI4dm&oVvcJB8==OXhHWPKNyD$4(6-R6=i1+LG$wJi>-
z6sSEe8AK*6=t3iHE84gq4^uHSh~;{Z6YYNp`+OfgJ14{G8*D{h@L<1mRiOS5B!*6=
zobO8X*vO|m#waV$@!HeyIqm3t$4q{1JKDt50zrvxz-GaI$3;10bD3-OwR({1y=uw3
zz&2J;az`m|BYxiq;g5oga*&83tYx@ggAqif_?hL=kfL9$8Hw2yi^&%8L%;nlZ6Yuu
zU|o=!nkwS`CYTR3FYERB4*B}}!QM5DuuHT8uI@fe<Sjo+R<TzG`px@U%jXz3yXW#5
z_SoCVS_i`UWrT@oAae7Tv8!XoY+UdT@%_%-SX29G7$5vHRqVXSr9&2pAAXo|56>Qz
zdoEEyCD^C#`wI)lvYhE7z`M3t6d8-Q64e+N8Ql9ZyDF}xjDA|Vzq}!?dF`xNN=E>X
zilmsjO8;}V$9ek#Ljt-lyx-1t_PdMXP9E2OY3GwHXw;v#<(-!DaF1DCeS@vQ$k#{s
z?P0&Y_M5Ode6i=dl(6T;hNw@q#}%rcV-(G1%Ej-WY{zfU=lj^rEBdiJ&4dI5?URh5
zZtU0k`ejT$w*8Z3YZo`+GXGphmU%lQvl^D^*JHkz^4sd02w{;<d#c~wScIbA3ta->
zH19wXOsOR?FMIFUbP@93$A~IR-AOE9OyT8w6B3(U8Ww%JpvCz<!MptM-bAewxDjK5
z`m*=~D==tZu-50j7xNWGKaVqyjCwS0^4|zWx<b3IT|Lm9)f~R6ESr6oHmtwD;Uj2S
zd!vQq&6u(@A1OgTM!f@+u%j^XPLHL%)j@dy>uBGYQ#TbMFy8hz{e=8F<^lWSFT0-j
z3euQ+j!+qN7Vt^R-?EWIb^uJiWzi2*63(uweD(~;@S`x(jfcJ8E&q1iik}jJH4VLA
zD7_!<R8#b|UPOF4b##XSOq8~BGygsnv0tK#GVwb+-`n{-7(5Y4tAD0>h(l!F2lDl2
zGQ2&+w9NSTl>4gkv7_#N)w^C?fM&0_<_hTIBKvmHceaMdhQT%x=2%(Xl!j1+U6^)G
z#d>&yT<I7&*&>-L?8!sI$d?gjQdfqkj&ZQeBIsIT%%=Cfye=lF`b7B37asdhg4QiX
zf0N;Sm$bT;HyqN{!@daRPO1RBmA)Cy1kL&F!#*#&KD+I1VT&c{lG8$Q`J5Q^RN3SF
z()c6_?e}tRmgtZict*Hju5ItDDXDTH*7X=3edYS%1j?Y=-=W}wQdB!$qWC%W;SKqO
z1ia^0>d+f))*M_i-Z3g11##MN{spaE3KgA;B42fAuLs6;PI&Y~fisjI@YQ3}kAXet
ze4^Xz+!%|;@mo~Q@f(yJc}+FHO4a)zR!@7V{axmpxSSa`BG8sW`*U{yBK=8zy>JF5
zc(e$|kG2+zwp&skVwoiXOUluQ4o%zbsT(zb&#-Je>)RC@|6d_kq8%c!?{a@C$LR~~
z;dm%zqV9(xBA8?fo3iFcz@)^1r;T{Z1<nh<OjZpNJ&o3x&qPUz^CrWu26Q(>(Y1ua
zm2yF*!Zb#Q_0nPPM|~DLSQx~uiMHAo*=~%Wfb8*34UI7IQ_0-Y7gG|e4lDK_3Dd)H
zOU($^b`Vkz8$?|e?m!XX)8%@O=*{>qAeTn#Eh@N8cb~KK$%@?TGswB~vh&>vmd|na
zcbzMqHTpO~Eutiojg!e^%p0tiHb^sAwzt}VjaIa(aj~R=AePy;Z10LAwn8UH(BY$Q
zN4y<$>Ew2fd>CfZ%miVF^%0r~y=Im8%U|Ie<agg1%CF=4*|cz)nG_UbG{n1Ot8F@j
zOku)e&e`^d3qHtfs1!RsPvVg81BhT0_#{?*GM;#DxAk^kb-cP3mT-#A*h#k-+f#9d
z7<89N_Y=%Fu!zfN655;luLLM>dYH6A`m!FmYJ}t&D;<G(YQ>egDI(9TrCmBhgnu!;
zrZF+34eDeg?1Hht^6@4TK`Gg1!jvT6q8k|aNF&s3w*Lu>9?gRzG9HX>8F5bXV1HxT
znn;V+M@L^wSG{wfA`DQzBx1JHm?x=P44A&>uV^NT+jcII$zKJ;Kv{93F>a&P22V1a
z(SA#`<?ln0?GqDY65_kG$P&1opYR6Vj_BpR2kKWp)MQ_~I|x=LhF{8?mNes&R`3^F
zjfO9K2K^yBOj~fY_H@r&(U`)nc2=2DYM-*K-|<~=D!cz|2*q#oaN(rntm?7bcSZRw
zg`kE9E_xq3cNY>V+7hG2Y9xtQ<_E<dt$v6WCk-H9kMHg%7v;Ar`GdoKmWq0R7smWO
z)$!(i$`JklZoa|EYnOp&O3LpW#5B}4&r`5VrE|s^cZyvlbxDAQTGC#cy{4O<Cng5V
zs*azJYjr>EOs?ZXyn92mzObXk>3_=q5XS~e?I~wGBKd{3yQ2AH)%wX-z79KSW@0|5
zGDksTI`Jz%{@_r=8{-O_a-3A`1_*jK9pi{qQOig+*eY3FVIkgPJ2mK-mp2|Ef%W$x
z5_RRV<dY~p?F}I)eU>ki3|?32fblhCAo`F}ME~qOcy6Y+)%lk6lq@-roNd7Uo+N2n
zJibT3G0*;Bl7WsH>g6it>JNcN?(unMp~!1&B%1Z)m1$Yal@wD<ic1&xGmtx7H0VS(
z-=u`Ntx1KyaFU{gHc;Jhvdv>*96cXhQ?a|Cj-Vw4+E^;R@!n^rcQec13VPDa`*vaZ
zPgCk9j4!H&|2a@axaB@<hoU!@zR5x!%Qs)?z^)4`TaV1+LUkI!Q<f1&`}Hbi-238O
z`=Q^589vOBNC$p9KUAH~q4DgTo{{V{7RwY{-jzbtm*nPb_pefyh4xI08>$p4H2L~9
z%p~I5A?|MXH(CD&#P=bQTNjlxC@{rq1>ooFD=;KmcPdNACV{Wrc*$VDuNv~@CI*yd
zr$z8zWG?8*ym!B!A6u<IFyco{I|urjpU_{hl;YJG<iJcRlUe2#YdP+ipnvEx<U?Le
z&l{t5)<4QA%EX^~SeA^oH$%K7dPp|-gx!Mz{%-h)lb+sq(_z5~7%U%7>{7(vCyS$%
zH|BE^S@Zvd7p<5V*i!#X>ZCM%!e1+LdH-J++CCreLlq>pHAlOh)=aeD)=|PC<(sQ9
z(#H=`Gg?zz5V>`^KWv8lc~gMS7;{BmaOUnyo>9j6*V#3R&rTot+b}9+iQ>g!<&IR=
zX!~W)I!gS0Bk<5Sa<0nG3ai5N$>J?L*OM2EFr`Jwe;Xe;+^yuhepkykteT{$Sz$aZ
z>Xti1k@|<?_aG<g3eWSUM(;bbSzxnLs7KmgfG;;kZyIb~>YR>|Xey+#{qfJ8W^PEM
zO55SNy)3NEVG0(5`_hU)5<yqNLle#g>R@RgA81(kFE=74nR&(wiuY1s@0piZZ|IaU
z<S4!LF-NVKe#}p-_-jO6=Y2>5<}1Rh*=Z84+1u2_=OnejN>$r>Hz?GiN+#2(zy95I
zQy22C9lxhllCdl8qmDt0)i0-En~#cTy(Flztbvc`>8r)a9t#b@AhtKfnfo;+UKFo?
zL^?T12}`%;qM|=FZtrw8Yze$<1RoFN&{WgCbCX`NJx}&iL5`;nHQV<hAfbHxWiDBl
z@K56zS^AT4wBK=&JRZA#bQdHQQF1$dbJ!scm1@hAUVPN&ADG0reZeu%`b7X0&Qu6<
z;}@05ZNdbik;-yQHd6yVDef}<7=E$9NV1aELk7LX_`I#JzQ@Io3A%Q<br=2!;Xi7c
zuW`9S--M)0anT~f&twECRl+bewy%0#cf6nKy_7c;RIHnucw>oNZ_29+J&ttxMkduK
z#0U@b3jloUk=aMm@9ua-ZhNmSC1}x+TE)1o(XO0Bvfmgnp%KnJyHNQ)S9JYq<@cxH
zLHHp7TXgp^!Wp?K4sr?vc+UUjMpjs!UQ?`c%RWkYq3w3hH)>5)L{tZ{l<&Ro$K*xq
zmvml~N>OIEzrW26vMeXZ+~3I9lx>-HF`Hq+YrLS)uops4QB4gq(eJa4<PAJth@T2j
zBglu(U|2w_N>|1e;VMLj_P#%YSbC|R9VD0tkYRvMmV`6xK!e1Q_;KEF|3;w~(D)NT
z5#CvHpf@GQjwQ`Szm(~8%JjDt6wc+T-K$OP(h9+|{<Q5NgdL_ggf7P-gUG)c8>2}I
znxu_eU$2;a+TEgT4^GdwvvOq;!&i&iIA2W<)3>S4Y)(6x8Fjj`<FaPpAe%+-(U^NS
zJlc<gIRMpVwb>hYd1SI7r&zHAd8T8=NvL=28f)~Wp~20I9Q1<IeVJmy-URKBthI0q
ziz#x$v}(XbZ=$0OLN01O@Dix*{#~v(25xb!vi_vbylftXCQ|zAc<YbH%cb(44BtA)
zXNHAS9Jc>x>f3*S6kQN8l<=Vxi4EJfo#N#EVzW3#@H$dsI=o}M8x|3RLU58?JnoKc
z_zPdmyoldd^riy38~43m*=6KI_3inyYAdMTClB^~-tV(GZP@HF>x~l(GW)n|ErFy8
z@i2D8`u^>LRWKFE1Smlnc54h0{(~o9)?I8R_I@jl?ZZRzj1C9m2+vzFiSgZBD1=Dp
zC|*o!0NYg`b9()zuhV82gPz-ksB87>W=Nw?(RN|L5AUNH(rm}`MmuCJ+TUx(29GS#
zIyS)u*-%39)e*PLn-fodG2W3A!@a*Zc!iQ5_*k0)S#!0W_Z6WOEbG<lO6!`JEmlb1
zrK^2}b_)&g)=Ly2c}?Q07$uvcwoO7le~b=^uX*%^IWwb=r@E>rzmiJQs5ocw0Xpu(
z1VhVSpz9=$(|i9_lG5`HGA1JX0{l+Ii5p4Kfb<E@8lnr(sZQNkMUgc6%K6Imn#@if
zA^?J+g<DWkFpPJQN;2QzRJC;|Y+e!*&$nzIeaM!FjH|ct{LlM|R?N*OsvLX;eW!hH
z_g9VzbLpCWRiE3W-jM8M@Acxlh}RAEu_7I|5=3q*OyHs*8zj86Nz;7&G5AaMyyO^3
z2KPwX%l8kYcVN(Dnki{A*<(a`pL*sm8mwO5QrxT-8o(b41FY}YCP3hkD!U}P=>CwX
zGSIw+no~`Rh)yvz%VRESEmtr|mSoEWV8(TihO74X@X&ATVsFJFv*eA#CTfgWHW7uQ
zc=F;zm?{u|_LU54`VYn!$phqOjuUM%m!R#Y`iC-kv}}|efcPP^k6@}3iCA{Febu|S
zm*PmjBTSI=uzz0(LiDf{#-d-%XRn><lGlNcf?E*|dBtr~yO72TRf~z!=O;&vRv*K*
z?tWc16Bftx*qo%UZ|pPgtIlJO4|u|EEvoc~wA*_Du~eN?z8K#&ShUUkI{xL_D$hS}
z!HPU@SHwqiM8>C2f_bM{MH7r4rHqc?rzOfpL<4jpL3ThJfvebS=1g}fC*5armvQ{}
z7z~}vk7Cutru*%N%4<@f{XbHiPlCn+%j@I9NF)Ye8m>-#Z>f_hTVR9ByL8nS&8z_S
zXf{|P$mVxdQxO#)WvqN~4&a{;G*v_FFFI7T8p7*TrhlMlm*gF@RA6;#*Fh1Q*q<aO
zsz8S~(#CaAru*A1&3OQ(Y>WOkWfpzU$Pe<Os6&Gj_nSDSJK_%-F3Cz%fc~fTdpYPs
zG%mg0F?{WM0<JI&{M4?7&&zDz-tA4+^gLJrz|`b9jnff%UMOjLvi;`@BA_xk>;$bK
z$);l$*nPIv%%=yEZI>lbcZV)A+JnMEuyqJoGNf>k4oP)dj|@q-kUqfAIl6qN)K}za
zrEsIG5R&>p({aQQzq$e=q*Rl8chk>Fys{l#c$y<VFO=<BMPhWRjS^^?(;riwh~hD#
z9~kX73@Yd-$m2Xe1SR*lgCQHqe*Xhs8*v3sT~h1A?)&B8lW&Iz%TWI8xUXOu;(*Ju
zWHB3F+N2W5(_niiZeQM;3N$1-z?WcZNOXJNEbgh#{trCovum;)V2W3|m3!yobIhYe
zP(FWqdiYT1@db7tB1gVR4g!P6ci9EY?7<DWK>;0oz%*0y`umyzG2X7Qj}y?cp)o0E
zHmg3y7E$$~+ztd7{5xXBG<Vv}el?;1o3kPlAUmhGxUb?MLTMR{pY`&v2wu`fz<mLZ
z31fAvIDI4%k)M9GuAR(R<$&T!gaGxyLF2KvH_F<s|IG+qe-ytoYyUw3e0WKN(leI-
zuC#ya>kmQpKzHSML!S*l4GPa#hwpqn!nyd(gCla6lKJ>!;pS-jY>a=L)*cp_aL_&*
z9+Y>geZW=C{JlBWkCBK;mz5BuNWg<IZX@D;)ur3gv-LVo%9ExdN>)G9>*VtMq%#Q^
zrUGesy-@WMW2${Gw7O*V-t1IVAjF{fmoQS8M~o9iEzX2~fKQ2rK+xn7TQA&tIkhV$
zTLo1&-gc*Qb{$jteCN{gsmXB%3B*KTAWFw4ApaUz(wQ_1vcBr@@YA|Yf{kx_0ykE6
zJ8!;BcL(r}kEPTu8FQ)SvE$VQ9}H}8@4_yJd~`~%$vH{gd~|}~O+yI9vcrK=+fS5G
z_+kpLL~N$i_eP=HS+>PS*kJV^nJknd4Iix7Wa^x&-s!kfisG<8jdi2T=f3mZ%%%Oj
zJ-xCK2-J=$<O~y7Z#~XD|3@*FY;Ju*^`JuQyGx0Tu&*BQ!7vQF;G#ubjuJY%kdQXU
zciQh2|9Mo!NWWff_G(~InkogM4dH{z8-}5>U1J*_ufFUe!{i9RU4pDvD7~9}*r`N>
zA4`91cRss#Z&u!~N{H;6%H_LseQjj^=QR=4Z}=&lXKJxJCx00RV%V+E%7YegIA`69
z7*~gjsBGi3J0?Zp#3NML0=I`*=X^qBvqIk|+`lz0MS)C&&;VaCiMa9e@GJo28ZfIF
z+YtyV3g!v?M`RhvOafz>$!CAp6IA&4So7LwtD{X8^XUf{0tH&j0a44II;>>5^(V>K
zX#3ozYhIt<BMid!M|IilhDp%Vi{Y=1{V<`F(5O5h(aE7fm6e7fg2wpu^%lxEi1I)Y
z5Gl&S2G^jDolNy2iOFQq`z9Y15#yxem3(FUQj;qpkG)zyc7gqd2$=^VRDCuxlQ2{T
zs^t>%4NByW2;ey)C4Gm;GsK6N1^Zcv%hHxVYV~CS@jYX=aLm!J<P(q>wUVEQm7PjM
zu(C(Qvi|S-%b46iOty|DQRi`2)@Mq}C~wRnBj3&CL~1_ZuT~Pg#-7g^*x_~s4DwH(
zJ|I0>wRtOcfR;gozv}2b7hH9r#d4t>Q+1|*i;ZQ=Mb`aEYC0o;kcGsH1i)Z&L<C}0
zATFtg&6(5Z7x+$>Dl^bFiGpcBnSl+@JX#}*TPYte;h^<58;=M|i;$J2*ZF8?<-YB`
zh}7;+gnys;4J^0<#q0!H+^_cJXBRgcgoa&5#lU;O7O_++6(1;F(xpK>{a6LdnPH;s
zDv#i+fu>(RH?6Kw9+LgE>C$<<e70KW(&3`PL0n%GDrug-mcx%g23Ho_xDyU}w>*Ls
zXWDZ)F(JXtRZI1i$P-(Qggb;ML`re0gW7~yoCY>cS?hGPp{yLvXnZQZ`f$R~K5dvM
zmpeJScmTzpNZ0%%#YtIGENy5-=tkL3Ni58jVn`BIoOE0XXORX5$F`f_2vPBot@{%L
z{kfx%6ecoTWgF@=&O6M`=fSw8KLyjBrVebCik*?RV5XTUAu#DYY!DT6m%Fo<==>>s
zeFM%3TU~o=(Zuf7Sc@ITE`l&@qpk)veFE$6^>0@rBA*Fn8dn=mS6%*LMMz*^O&wTw
z38{1bSr&RD!9y~a>-Nh{!lCV8pFP*S_MZ7nfreYnR$CJW9#L}d9|#j%$-9umD`u3j
z=Fa%4FjJ|c^}NTc=l*&d!O7WwzgjPlAOj%eCGqo<v`UQvEl=3^M3jG=aMPhsC51^L
zqG=9FTr6A@FN(<FQjcV(swGUjqL@cD4Q7smEy9>`{7*9sX<yj=zd9GwhEzqVYW%1>
z$RNnlMYP<nzWtC0Tv0R@9!IfMBIiP`!kg5M8-@6#JTEbP=x$U=xe<hZ{DKb0TI}$Z
zgt~`yB3tk2TI5-mCEI=d+4+2>lZbuG{9&>XVX|Bj$(*~o$CRiP&tkcv>~yNE>N4lY
z;q=}|aE&hoGcs(_Fi~k6>iT~Tu>A6O($}UNJa67WCGGiiNEl5nP}js~zwhDl2`3JU
zhUALMvNU*4o0!Z2GQ9hf(Gbb^i`P$moftG!+G~HqI+lSB1UjglSX556(o1;)hG{dE
zY7I5|BCJ)|D6GvNT+)IbcSq0boi5gbr0`)=`T<sf0bV)7KA5nQOx%?_SH{0U;sCU%
zYGd@4p#nB0hS`24?5TeOR<(hda^W}Iy(kDA@HGZ?rR?YRGsUbvhjQy*@TTwEe9p%+
zIe&^%MjZ<hRbZ0`P+SaEc2@A-K<BGLPckk+1101FU!j=$Lh+5N(V9<0+^|?03I<V|
zd@YqtJV)4;#0nHtudjCJSl|0GP0b=a?nWhGLXSNsle!zQ6B<WKrs}+vg2o0d=Ok8g
zFnVh@Zo>k(LQITj!N(f_mWYywL6bb<5bc(vcMc_aWh{My9F@8y|FNwL5+`F}m$Rep
zRy(+H{2_%ZIS7qy-ZTW0!T`OgdMOevY=^O-X2gF=zkgy8<_q0Gz#VR%QrwK?uiQK`
zu^uRbLb}0$f7XzP=i>p94$#w0Qdk%nT$olvBrI)&aO82g?q!}cYspm)ZSR^L$Q)l4
zxpCNZ1qqPv3i?i+tHldU1IYkpKWQ7n=t?=1NQ-{0{EJp*Qb|3%zF>)-1N3<_TPGzQ
z>DVS;v2FFzx^dHHxG7r_-x^}>AjShK`<Z{jC1vzGaEb^VwNFfFZlzA?Yks(COQ8^(
z96N?1z_o|b0-KgkK?JDhkH;biQ#$YJ^Y<rMS1+?NvFIfKa%Z^4YI`UggfGXT_xeWI
zxpr=U#v#M#>XG(mpxiO64k9~rTeFS2V6LnfNVF%;rMc9L#y%C#XZig^s3-V(HDWh5
z5wrTyo>WzXkQ#XCfyB)WEAhFs5E9TOI!6W%Zb~`JBxAhZZG?e6as|&|e+}b~{KR#R
z=|BKiS`a)S0=F!P^p@awrgw3ED8Wvzsal)4=$yaWY$9vPJl?KSUkTQIjvS~wG}jew
zhqdp3Z(mLg!)y)RfLXJ(0Nu`)Vx)$R92g<zFxANz9xuJ6DYw6Xby%W)T<x{X>I3RU
zpNWXrK6iJa^Ib#>7zQluoRfhO7@KA35<NwOvax~aUwRFRb|f=L^_r+t<lM8~<~V{I
zvxcUx$uJmE0HFo#nyc8<4ZvlqDjna`(X{fqy8e~*ny;3A?9;IRqKjAzKQThpAt`-S
z^co-AIVkpWRN;B`9R@JW%%4|v*h63E+<i5HWj5|v;mc0T53&1(>cUw>X`iGyDA?q}
zu?};pZ<nnI*KaFNXE^&04@=<x9-#LctX8Zak%1x55kx4DeAhb>la@%t$$FCmu_GZM
znR_A!xryfk>J1U7il6+76-}fHmXB0XsD#NFl-|_YKNRHm)^Ep2olmpEgxj!DKIV$<
zkmFVSx$FB`Ptz_M1V%I7aI)6bAA!HUMhuXVb^}Cv_;aL!*S`LQTw*jIQpeKQ4e%?{
z8J5ZJ0O`bLwe_u>>QPqGW;E_j_5NgjS#y4FIQUC+)vb=86CmnC$033C(R!ve*(5)*
z&gSTdzjO0d9T^)(OoEkM@LeND*Ws*`U4x!5&MFQGd*S%2zE&k7I^Ib?p<;XJ<RPa<
zgH7gQyBP}yANjI@=j&v8_xK4q0&}xJbRT1OjA}~xXD9BqZ_MI{m2!fEA)w}23B*{y
zLkbg0eK>y@){F)GB7xG^1*Ev>6g_^#m8pC)46=WmJjp>{p8z42lfnTy)%aIEd*7#q
zLCq+L;5^srPPB-<)f$##5&FQZIFtG$zy(4RN6nU)1fBXX1{_Q6DDHGHa7;+7VEaR0
zz7F}k*_I|QHF#OxpDkqy6z5MkNh6$c9`L_=4bE@qRGOEwFd7n>+Tv4F*Gv|xz>;S~
zxZr^J2(fH-TWEofyV@6;AT8&W49=ncRx9W^m{FL9-QS<&<c{T7|L}XCjJB?~8@acD
zuD@#0v@L?%=PZwOa+8GhA&hvl#vH-RyR#pX7A+z;Fc_ZF?<=ZnYAj0gUoU7vg3ODZ
zSH^oa3D;U|>QA4o9|56U?YFDv9SE3;nJu0(3fFbN3kN$)#Su0X!Sfu<#4x!@g|0-9
z52<i8oE8OdaX>Ovu8f5IRj7EVp#+noHt6Rnb&6EU!5d@MED^2ckg>L!5f||}rWRW?
zg%J8mPtSwUd8dV^AZeH)FOA2XsH?;W8CWOEuc2}>?222z3=Ists4>V;PeXwXCvPEU
zOwX<~Wc}1)S^-nbuv1fgkd(ErCzfy-20$xO|L9vD?q(DJEhu;uE6IN}K|T?Y2B%}d
zO&n&h?yt;Nek24$R>Pc+g`s&A<-W<zNDl}oOml&(ZYAf`uVRKvu(ekcGI*u^Hi+*T
zHYqdkFfoYijMu=C7D%F6Rxhbl25)^boOHGBeQiQz?y}a5>)%Ien;OnmSQVhQ35SXB
zF?>;z=PRNKHilyvNCz+6Cl3qL%O_|Kim@0=2B{NAk$+7e4El$UJRX@efkS-+2w*JS
zPbh67iJ3BPn;@Yf?HcU31#5h4fi&8A+>;B?Y=hsX%8O_h&U!OS*md(uF{i`)!ihc>
z@8(F-q(Qg=79gNaaNr);RELnkA#5ryjHV@sb@4BDN<`UbK~<}XW`8TCC?s|aY{T~X
z3WQLsL)Xn9RR+aBE46IS6G9#g4A<D!K@sZpBwt=p9RzHD<_X17fm^gQiSnwgq<x1N
z=w@pSSq8r}d=V(JaM4<}y;Z39*l)6DNr}eK{LS*l)K7bXhXPjPM$nR1E1SE+&Ld{v
zNoQF1e5PSv8*baqTq!C-`Te`_!28H6RxmN-VmN{Wt*PM`H=RZ>ZonDiH?ncK`CBv<
z2kDYYdK_!$I8*<S@dvcW5SHEM*j3AcL_l?r1jBy3I<n5U6g$XgX&SP?h!>6|n6g3`
z)44KH&c-BJ@`ftm_C!U7HJ61muoi=<Y4{ZRJT35>`=+Y{(^I^pDkVq&c_hprvGP=!
zY7>g3)MCS|mgp(CVx-hm`HLLU@Nbrpq#uOS7lVf4nqn+Fc+ppI!vpJ*(>YgbI5-Yp
zP{xgMptKy(*&hU<7N0Wg{y?QWAA=*#z1GjHd5G)XPYt=!`{Mnwb>7UmHvj_reOSa0
zOaZpXz`)t5)S^nFCeUENQ8>MC&Y($fI6>pq%ta9z{$VmLZ1NxJ_Hcp~6j`?&2MLI)
zAc7VRg;v!pJ*z6^Crs8r29fudp#^VGd-o#OiRZ8?Pe&_fKvhX)X7PluIk*1EHkBe;
zoUtRHs4NC@DUWJ_vbNn%jPa(k8|ix_{7e~^fO2FQ_ZT`tha|v*I<tG(KCX;f)IjKp
zL!npTpa5QFg}Q#LtG$IG$9uGkb$04tH^HXzN^3LFhJB#CfwwWqobn$XRLQVut2G0*
zaxpa@TP7@XfQ&(=-kZ3f!_<VPS>EqVKYUEHWIM`ulahjDEL0fxg&+wt(yWF*a{OOP
z5$it+NK~JC4pLmmSIai1tFgx4&9mJB9v}T93UbwPGptQ~vkB8;n*g6~PPw>Ap8%jD
ziDB{@OO8_d>-BK$qMMyKta55Py$VB1(M&Y7u%sXbD-`j2>7+u(Ju9ABH#q#;^lT>D
zoSqP6OnDiJ9Gzj(tvl`az|W^(?Mm-cE2-a7-j3UA&8=t4xWsnN2my{J)u+abu>g-Q
zXPox@sQfo(dCx=pf&AK@$-4%&i0m=dtpybF!Tyl&8yL3npytuUGe&VIElmIg%+p3Z
zl3iHa1;ay{Z2vYEwK|Dt-{l~S5yapaaoy+orj#i`^>M{+9YNF((A2aM?UZsMr!&R=
z5f8rzM$3l+aeVb+Kp0kd$5gG)!?ogK{)A*k4m5;S4zV-Wf9Uc~d-BKzWKbh8*i&NY
z#QYh|CfKv0`weAzQsj%a>Mf1hRWNa=fz)Nq6OHS-ey6)B<74B=XKwFnhlgTtTC)|I
zyUSjCIOUzh+Ic#gD>64ID5MlP(Y8*`p^nRUy);ySa**TwEdGytK9ka}W;&U`<DNY7
zVS6VL=AV#$?Nb5*<!TxVZ|Jx`)n$Fxr2v($DOS1!qm`S~=O|vAJ=59mOZQM<+g6+7
zQEU5w=;K+A$qOsHDN}S^6a)lB$eU?w*xgSRXb6ciHf+WY1$5tSkg8zs^kacQ^EGp7
ztcpfUeY*MIU(q*hW8=&_@t;XiIoMC1OsErgaIoQ;VR*(t;Ai$L63bG+JQh=uq}E{o
zZbKwM-pbAGRcqayzVh$d?HOr<ZN|R_o2wQTyD9z2VuBbcrsa3j$y?rU_-C8GGp4cB
zn|pP&#EZn(!G)9KSL#*Yk(<p+Ldh5rQ|Jhjm(n<eCh{bFWZ?E%DubEAHpJv=gHz@I
zhOK$ESHeeQ(Z8*mH*{QQF6gf`|3>iddu?PPKsh|lRdcE<RVxSk@|JB*2{*Y}riT7a
z7}5mU;>#*4ii}tLG{3}&Yq^@0vr_l)ThZH5r>LQg6?psG`f7aRODc3Ok~!DJ=?=xe
zN&--gs7|U0#aP42h?uc_Pxcf>udZ)Ux3a3<bw6f1Z(PvpL|Vbj7HO{Lv!8gjBcq(K
zv0daCy}M}uBUl_+#*)*I0z7JCXb{e8Uxbaff}y~{Avm)9%mmTM2APk@HA}_Fw_KjW
za_ZmsAj&NEg%NZxE6l@MIDSpH3JbwuqS`c(D4Lm$t)T;v(>=jHhH|6%LydSZ^+2n(
zyXBzk{i>)all8~(Q{03{g{87(bGLGMGz7%778Sz+AY0~H4v;NzsOg(EMX-o^y_i_C
zTs(dO0_Jp3k|=I-lM?o|a&8miPAq`$>KC;%ji+%5#i1LW49x~KAhh&n8_*(gMC~0Z
z?nh_~4dDg%;&@hj`bZ%L*<xKaoA9@!buM!gx51_vrnliVw@UA#%7<@~Jui;TN#U34
z1_8wRLF)M#08Zj$r95kDLIagOhpb3#m3Y)cj(suRLpNsAE%HAjsLg+1+@DUzUdZX7
z+nK~3i}tZko#V#n4@nHa+qW?p?Za#9y+0}IgLv25OiWcFWx;YP<sL_~kEjS{N3)@K
zPGzxA8D!wjB|6ZIkzkWW?X#Fg^ywi>OY@3+xG1ctlEHVh5zlYa*Mm$#6L`8Gk^D->
z%T6f%`HQ$+@f`MiMV~N(xWt<cfeyZwHM+f5``NnID3f%eKC1Io4{Gto<>5?<%W3**
zgO>vyy!MSOPdc!EdYUVRAUSV=jR)@n>{nWehO4Z0N(SbcS(HDHsoXbg;YKRA^Jn=<
z#X7p4X}WdVq$4{aKtSMz&WJPCpjjjn4|r$-Q1SYZ_R%kS3c?380hIm}ScT3phGDIQ
zZ@2pczVzOHOi|rDLOQ9bqn*b(D{}O$nG+@dEEF0Q$EVvR3V(p6fUp3j@{yO|iyWjR
z1V@!wOw`}81=rn#G1{iZYG(1M$Yo5y+MauID&HQYX{^!98s*@&OiJ2b1-J4<c-b{V
z@FOGxQ|WhStgPm!DlrFLu+zZ|x-AfxmGY`T+3CaUUK4ANk1G6`NC&^GyUiuYs%{!`
zQT}|gx#mvI4<Gm#fJKk&f)(Mg3{;znB?I$=o5p_%+Q-t-5@xgIk;&Y-xG*+XjHUqc
zmrKc-np6@2Y~#BLJ6j*m9zW+0YH77<Wuf?$;Zy(JUa~BM#-`~DgBC%~riv3r3?1%|
z7}0x+INx^|TCru|853|(eAZgGIe|heQ@61Dd6MnS4pJZ;HC9!FZ&KqRu2U@`#b%aT
z8w}{y!#7yLlG|)40XEyLngV$e55)L_M{n9xhvpRAbrS*7hi-lLEO?9bVi$OhkOpV`
zNx66=K#Lf?N~voh4r`S<Y>Tjx>~4(qn5mV8#j9QCV{P7Nmwz=z_gQI6OE_!-*<xE!
zB$ADy?Wa0OP4m`A0j0rV_FfrY9Sl$8lM?3KY{7#hrB^|LWCk^9;btX+wNi@oDdT69
zV=x#EZ=vuJNGXx6;zFzu&4MGOL3D&yHh=s);cwzO2?c$Trj*ju{cPZWSU+B4OEz^p
zuP$VHoZXTO6jA^5{1B86eJ{ZQDN}872^R}){*uV!zA75QI6**)I_92@xZZ)BuRTS=
zSeAVwB(Z>?QKdL)LP|#2G4<C(?ZNSU)Z>`J`5b=EGimt)4||rA;_T|mT!DQtio5Gd
zp6io&I(F%r)FI>eT@F96k}v~;7F&to+idB`^Bt>g8f8X0%V(4|P>))bRek#W9YW!a
zCDeVTpL&h8VzuBIiyuB;&Wx9ED^kG|x#J2obvILj8nP_>6RDNEk-#|%68Qr+ptV)#
zovZH%x?gEZl4Vsizv-r}?vZG#t>(a1=N8wqKX0^ov~k<YHxQww=-=E|hW_E=fq~zL
zj$TgnM|v~3f<HIcw_YCU7k!QYt9HNl$5&g;c-h(|UKWl?&H;N->aempA1y3!T&OLB
zLiT&((DX}huo4S(?k~Ae=GdOSo83&(3bk)qQkGS%_C=_b?nn<J8OqeuKOKPpHj<!a
z3#B-X{=9KshM6=n(uh^GM>UD-Uj)lEc0zDCBib_-(*?yUrB&d$7kn*p6U{{}rT&*7
z)Dhk_KHg3f>-}*HDi>JYAA!BG+Qi!Dz?qm_?xtCMC7sens=p;Z++Nro%UFR9n8-HB
zt@vV(reo+mK_>;R17&%>CO5l0`CD-jLE(#FoI&w`vR_dFg*+ynBx}K6jfZ4};7UGM
zH={d9Q#v%`Q4s<{p;+F+z|kF1k9{v;xMl_d@rqCmW8(zWK;xvj*N!SEFk=!yt5^FJ
zqi2Tmf+{Rz*cb|YQKWm*$pT`0(6X0xnbAc+c60fJjTI*chqp?ntzBYXpV_q|f(nmS
zr?!#x3IEmgkeaTiaE09a<gLoR8jaAwxGDDYcl>S9nn|EkvOz8CeqOa2qY1J#Sltiw
z__@K8uE++N@Fb0KZ{2l!8r*1;k;SreT{=0VHT_kNL=wW~ey6(+&$eogwxu2tAYE)U
zd%%bnb#Or%WeamRiz?O}82EF3L$L_3vjrVgms_*X6C)*$FA<7wSMEz55i?zumjI%^
zM@w<pXKxg<k_wgsu((7ZL2H5&oGKZovxn&HqbKGQn3(1o!oi9un~yJ3G2V{QJW$Mw
z|7j0XGr5ysq<h^08ONPgv?5Z65a<IUB%n#p$8Ol)Xe@is!{(O<(ORIG-(Kp_CsgKG
zbY|@{8Eq9v-9l(e(ouZYOg6|VZBxwfW`G{7y_l9Hw{1n*Zr!Xo74tRjmgUI+TaPh`
zt?#nlmt{0_Ej`}wZH#xl<Fvu1?svb<%BM}Q%$@~Zhf^#x9<6yo-+@a^W+w@p(_c7f
z!F<rY=F&6W418S$^&PpN|5a@V#ww+ty?i!NE=U(uq%YH2rGWcxP;Fw;gyldePBk(x
z{1SgN4ywUQqDeMOs*knZ7Y&o}fq9-Rg-;#-Voo;1+8aQ&;zM|)eRl+XH7Wi%T;+3t
zYAN4XdZU81(^J&22=U$fNu7v)s-rctoFFw?jN38Fz2m}k7ItWj!NNY50?Pck=+_wV
zQwG~Ftx#$MO*ZTcQ=(upT@mv{N_~S$tLSz<b69L=KRQ(R2c&TunW@8NmI4TvFAm-p
zLyHua-R8EG)!|!NMO;P52JWLRf^K|)uCn9vHOTk?|7<3nKk1in3E&Aziw70kun=rm
zj+o0+^s8VbMWgd$boOQK+}2sKYqhZ|O$>TSv@blHK7G3pT|l6-EH*bu4Yf_B7-RU_
z+<Z8V(39XIJ(%NH-e04JVTiW)7@wCEyq}DBx<w(};4m!vs7)l7e(CQ1kzlrzkONHW
zg-iYH`ReF`RA22g)CdBH8g)F!DWSB;AMz!Kj^H*R7y)E(#u8+}wCD8t-%xOXT1?oe
zI69vEfwu<tXUfVP(>KfJfRL3O4Xm9+fg6iHL%t09@Vm(=*#!@DWO4Z>xk`iH*x~aV
zOH3$DFi?z1fu))bgIN<Tw4hLkW&T<wjaE53412E}k6s)e^<pQS@@}3VCmcmb1OE`G
z$Rmk6;_Z*k@ba@vs;>pZUK2rer4Hxkz}+jrQ+0=~*00hA1?ybf-B7d!lCgPGJ8l2d
z#hRH9y?5W~!|F>o=L1I#xcFnKW@X_W6brP%>ZTHBnho&Hx8XdB^9?vAE)I;HRBySC
zHI^_#qV@*I67~sjY753*R`>VF1okmX7!xYi;q&MAkt{Xvw3rSHu<sdb51tTx5-o_e
zm2&pul>;80*y6XYJUfnI%{+>Y9z%Aw`nB<{4a-zM8$&fvi7}^Gr4y9k)mSa&8T|(a
zR|qvsO(Por)v^ic=$noS56<yS&Y<0=LjNm)QcIJMY~V(#CSYIY^toVL?#H&Z_8fK^
zv%eOVZ1@@(hPpFvkdPekl@N2<d0MsaTb~gDI5am;zKO3i#W#2mI&K^-MQRR07euH|
zy*mAvC0ru?`OLmP)HlRZkjK`sg*BxdN=sBbRT(ql-%XI!F}G|}ZQ4#0@7Tmd3RD{(
zIE*DPNgb^GL-{ef0n$>$SHA9I#*+`zzEuw2yIY{M4dc=;DH%9NK8}{bvj8GX0?rw!
z0;1jO{VugodD*r&w9kTOD5h1b7$t<a$A9yGO6Rq}bFL6{cU?vbjM%h;A`+91W{Uf)
zSx?E2M2M*+pZOuHE6lN7)j9AdjHQJ;fHr6d4btEV_tQtpw#VN6%QQ}n#?hG5HO>s#
z{vgS9ehap#607k>!^5n-@9GHKjE5`Msi8;R6E!p6$aW-Pvml$(<zs%TV$y@~B6;k|
z+%x8p`S#W$d19v8!Ku5&T1T?OAna?W5y^?jE38@>Tra}0=;jATi80`JM+ugp8OdSL
zkc~Il+L$5?{^wqL!EB0xoRAH9=aZW@Q!>sA=B|iaClyihNs?+pA!=43ugf6S>M>!x
z^t3PkYVGVDI1q`#(KHb9eSc-~@Gqdo3+7J98KL}5t7v9kq-?2qbZ6BgOcCQgH!}Jp
zorMC>IV>MFgd1>WF?8({K}RO0VA8WqVU@GbOTxbj#kHY_6H^HuIke~%FGz{WA#`Xa
zc!e7UeY?f-T*b`JD)w@}dc>nzII=V`X`Y@ZsXjIVX!JO3_TX4c#bhnjnpm4QxIUk*
z)Hb7$=`aU3{jT0jM+kUTPlE;SI#?zbR92s9?9ja%UTB+MsG|$@j0{q9`*eY7qJU!k
zkTZ?ZW@`nZvdW#LU(7#^pz~P5vzqvn^?40*ihuRMcL3tnGgQ0!6Sx&G`@XRd4N8=z
z0h%;BhLT`O{4tn*>`n4Y_Y3LnhFAKl5eL=$n@vwr>y`R0hwWzxf9Qri{Bu*G>0?|%
zS&7kYcb!p)*v5T)d}LSAj*_9J=`gCZaG4WvFU*+ppG~&YkJ|HK0KY~fdUU5@7bZ~X
z{FYbo9eY8`Oz@11F%kVT5v2(-gZZd{JexSZGW{y{X+P?Oo|cKSuY|RYMc7Gfj#L1L
z6)MI<%&QoT<Z|JIaS)uikuTd0sQ5PBWg50?OB?}`twY9waY}xmudG#7NmjsYT&?jh
zF1N!^A4GJ{ScRN);;h}m+r5R2Q?<a90s?0SrFdHUlR4wGsd1yoqHXlBpsLlJcQCHp
zwCL|uckLdV12T?NGe6>`+(UTm8V<~NUgE%5R>D{5!bNm@wQ&DmIryN<!icv#w*(&d
z&J?_-T<7w@ak`X$(1Qy!FkyFNHw91)ABZtc9^JoBmfl>LB52C7&V&xy@)iLdA6m$+
z$-vUq)_UE$wg73$Qg0uojr-6C*SUT}X{x+>()ij*8l4EHoPf+g;6==t&g2@uc=FFT
zm8D40$P=O#x1}`0`&&R59JPX(UT%dJV|lu1n42!L0aG1WyM7_P#5<ZsS3#0hJnG|J
z(CuNRv{Ab@OVSYC!h+R^+_BB=WjkV+q!G)vpA`$hk2gd&=QJj=1zemQ%9?CexZuFE
zA?0(33IS8^l2I;mU@P$hwb%eO!e2aI*|QDQY&HeM3|R7u9A+J9v}X2svG^QDl$94)
zm+-#KGX@6!<dokMOFYAeZ3~8j5*%tr9qKM|K-4v|$__bFe>mYHu8fIO=5>?l5BGK>
ziI^ag6fCzGzez=XNqQeW(@_*OGy;ycTc58GKi-LLf^chPb9>)!Q|fr`?xM2djms<S
zxtynwXAcrym4XaVqY3@H0W>^=^3I>t(O>m#GVHNAL*rSx8cDVorH%KUDpf)}AsCDC
z!)QzCIeJN$_gqi&4Sk|lf%?p&Q}zQ}+>29>J^f>nKow)?Pf`^91*GbuTy;HTx<#iB
zxH*PP`Vp;9@v{_REVp8DSYml!3Fop)Ev-ETQznX`8j@3(-sBuTDcWf#aCNqyIz#W#
z|6pz4XvZfNIxXt@oNhfBpS8Q3F-Do720_AH(&y!9vhwhceP$*kamddbVjzkxubC9o
zi9Q%31yC)voS(8l)N)LvS_!x-lST^z4~V|bCG@gK*s5|=QrMVG-S($Vw4e6kq^u};
zU<=U*rHuLh88^FGxy{;q$x-NKr>nw2fg3|T0U!sFeWl6Y@9zT$XDG0I1y@zM?QJ(B
znDFtbK|?s^@W%H^_He%{Nd220m>b!x@;dFe=Bc+@82tcfwv~zUe-B$kU1q7$=o&mP
z`D7q2T7V^bC1;`EJz^!tu`;=p!}y0fxwSD-GtPB`5{(8UPrf?a01x&!=%~cPtMR6h
z<1kGg47@DUZ9lB08nhG}&+vZ|*GSEd_XbU+oNeF#Ky<X#5~oiwyaGlTso#yq1AcwB
zyJ6KRIRAeDM?tv0o5>J;d}Y19ytKZyUh}zQ%$`BPV5_AG!Jzz&ugMUGj9S9gmC6sF
zKdGupE}!1BXKr#bx43meQ52)cVh8tQJg#K3fL01cs~&^94UVO*Kacr7A(V6H^s&kk
z*gA_&=yWj%mo9diVQh=skyb$<HfyJKNjl(4xP0&kxvnR2d*fRix;6^qLq&2r%;yXF
zRw)Xd${0%$HMD$&%OYY3xj3LYR|&<874lw%L|%C@MsGEezsI>;GM!1R8WEyThcPC4
z@JB17&c<`TwHUoZF0f_1TwA)f_S|=0i>b<%E#ttp_TRb)VJtGc!?w9k)i|cMd>W^h
z=+<1N--U#_6e(Yy4SM>DP;K{bDcxEBEX*9Du*tTVHG*zO8iGf=#kTA?QQ^MqbkBO}
zwy-6Igf5kXx_cu<JHv%s8f3_@g=EpZ?S0D0xcIl@k&99}yF0W)u_a}!B-eS@PCq_`
zi^7(IajBHaWRnmc286Bl*(<lvo-0|5vDMU0pSld&`SVLt(}mr;X8~9#a`}XcnKZ4x
zadzwKCRg2U+G}Wl2ahT|p+VIKsr*N7PGhcJvw6Flpd-T;!g32NGfor<7qZBj<YUzq
zwh(gINVp2tnH*G>up=3a98UAj43~~<*#uv=EQmIQN+2C8m|sbt1l5lFkgW#9oEC(S
z7HwPzR<1}dcp@H4jAa3~R+cM3xO~cbyrM!od*vD`1{Yp&%c2yvUU~W4#6*7Q&Y9_%
z0${76$YKaM93WPJRsk)#0_He6ph!Kg4+_%X@FGea;gm06DOfi{JY86)uo@%VX?Uyn
z#v&#5_md4$EWL#&L1XzK-Z0Dh4Q~Y@i5rk}+0hN)Y^I}Nm-LpSM3MJ0<_VXW;S!CH
zkzBWIl29zT723Q{BwRkm%{n(}6vbvVLXi*`Dk5Hk%0hKbPbAdI$y}k3US3{bS*dtQ
z4O|run(j$2;7_eCaKzg8TDb-rAXlN785_&qa?6%tDO)V2DQv;PB$BawKCY^Y6Ro;k
z@*AwDLU_=kqj03Z1Ar&A(M3Y48rKVj3|%a5G+O1=YRs_H1%{6mY*PU%v1Mnpxy3{V
zQjAU@&S)4RU2;%hvMeD7#mOLe<kF-BkVBqo<AvMmo}K$=RyK0Ubf65Eh;ba*<W?IP
z;X)oge%u?5IgrcFbFr5o7ZX(L=!|8=qzZvpE|*$fS}&KYZ5tyJUenTB-qJ2z>vclY
zu>vr<yngD`+i;uRamS9i`7shI#+5>zD%!mub3o2k17ldjqgNOhJfS`a%1B6<OqzjV
zDn)#n6a@ovt*zB)6ZTrI8IK#{V@<csvk;M-3unc}iEOs9AdyEmDy?EAJ}yg#B62AV
zRj@2i<z2dL@fSNT4M}NoN$$i)f36uW<hG<}$BCRR1QP43%@quXk08rTxf?fIGmlvb
z+Jp;nsOjd(MUN?+Nu<;9N+omc+8TU<KDP_(86rL}Q5XEF6;^8r3t|DbzVVIYxom3B
z-q{<rkCkqojm2VAGA6OYQBjSK3PN><9m8o0p-Nv<w9iT`rleAF1H$4>Bgp~C1t>;u
zEcgkxyK1#c_epQDAW<msVG*3u)z3@cAd0+9Q)98L+B96}svYI^L@X#&dDl}ZF>fc%
ztcK4#Z1F**)W2Hj*<pK9N+GJF`Gsf#;YzreMLqkY;Y)#eNj-}zve_iS*6M22r&|v|
zRikP1Qz^32LciNA*jit&o;ZH;N3Whbetc|UVSM`yQ?s)rde<@J8oX!A=76MLz@qmL
zyszqfu2sG7fIEraOu)S0CAAu<#jREw@a-K>#F|Zwf>$htdCMf*UR#7MNh^<}R?ngv
zjMIPFrWqdTEh{U7q!d1%Y+~F;T2iDzF1FL^el1{;xTJ_AWtlGM+Fjq5uRZiCJVb8I
zGVI&JT0G^hwD~WZ*Dn?``Fsjs>)N$-r#qmLwZ#0*${<4PUy(CLF%_%is}P+#cMZ1Z
zzWe(29n&*2g`00)fKU-geb?&Kj*q1`BbU$-wHJ&YFnbyRLLq;9nSh@VrCk7CFc~QA
zs@IzaikaW}&6Z{@1X_tL4z`#T1Qw0ASXQ1-X`{|%5G*AoJrg0Wuc9-<g>36*J5EIQ
zq5<!$z*=~j%?ITrMX@iLgvi$W3LzxIwkFHb;WbE=HJ=RQ|D_pU4@CWtA^!2p%M}J&
zR2$(MA_0zReY+9ii!C1KOP<K~<{Ot_d-26H^K-=m2X7o7&&K2AwrsZZGVF0^+6X(+
zbO#nAfm8nPqIS1CI&UHLfQ@GBX{dPZ+FD$V!2<v?WUVrC_BFOvp6mDQ$jT#|r?iDF
zgj~W&NtVU8&ya|Z9Vc35%~GL{o!)XoE_q2&iYpzi&AhXiPlgM*Cfa=rxnw^H8wXpO
z4jdU!AeSfkc-R{7t<ut6vsVU?8Op3a%;cDYlL-`4T=MF0pq2I7>#twBaA9R^JbT-1
zTc;-TQ_}_dS3oW)NOa!KT~r{B3R-O-HVp$pg#%d5$dUe>n=4WL0>D~duNm&(dcEFa
z#Dq;a<hs1*s7%zXJ}np{Sq6dSszW*Xjpb+B#gbAlGGzIAVL>r(BbUvAkdT|V>>`{x
zRb7|8PZ96YBNZwl!5l(&gCX8!&>1Sq5_wiMZUunwMKU>=2iRJ=R=IR(&Gn83bTff0
zY(Wq~t0XWizXTVIwY4g2XU|+I<kO4WCT`e1H8)=>m9i|u<#k)*(YNpG1s6sRp1KQT
zVN?5YC^Yj0kqEuX0J*Bw2EZ1wq=OcI=~AAa&P1M%NbNAlZ?GfJ?HVVtz7<GVCA7f;
zyOls97wM^B&5WF_#@y7WZW%5ijnz&Jfp{G}vdJd(Q<kj(xdvqnxrBNH3lq|*xH7KB
zVhK`2y<XF}zRfy~bETrfkZ>TTnrNkQE*Rdad9<=xIdS~#ODE3da><)++A=#=+`fG(
zkx-E(<3gKa^r-I-yAQTLwCK#9uJ-SkXm?UYi5b~nf?Tkb%T?fCwOW&j10;85Br3d|
zCVy?!q<rSv1~~7CQsd^lWJ5~gL<LKY6y;hU<kw5lYIAMJlX9zS?2=hyPxI`nC`syl
zS}StmFZcyDWlyIQsZ<=kMXoKat(9v?XK8rnoe~0UsVYfbAv?#|HZ^bG)~l=4=bn2V
z&S+{Xzhme0d)~8?Izt$i&8>|Bn&99PN(#RpNHSp14{KRK9n9eZDgkl<?J{%{8m)aR
zuT~q)7T^~aKQvhb!HYi~PNzY#@_x^>;zZhTLCSEEnj0z7M4~4IA1ZP}LSDmVr?-$>
zBUt2CVvU^gF`<HoD~;xI^GN7rjaaJ-`wIl=M0=&t!^vg|Y{6H^%1UKzt?su*-vewx
zFqlX%9ZQF}z}@bbF0H_J?(Eg6>B7E!i}`$tQh29~YXe!*@a$@1;VE2@LcwJX{TQmM
zs47X-!wuJHG}qVb0B1050LU~$t%xm>Ks6BjVj^-logyh!<eHUtEvpvgsYb~*<|~IR
zD(99ULt?EDpP#n^T8?npABIawBUef-g{VjrL+~}{&Lu*Z3>TJvZ)B;g$dRa0$<IO|
zoy{f7tMw~a)+-*CHC@9N90N&RDK?W;P`AisT(UD~uEKWg=$YBM(!!RpJ$vSgr3`Q`
z_@j}VAJCNRu~mfIZt<wYQ+My)_PNsD)D1i_qx@B+iHU4BNeY9?RhSjEdZS?^yx1b6
ztbyPg`S2E|j#l-2ehP`}iS8}Gr1TbtG!o_E6Z4u~ed$)~<3uRW-;1uzNbV<O>tm5%
z{^W&F((mhaohGfMxd!w%lS#$n@%8oE%1Sjv*ovzd_l#Ejtxew+Zk02qufTTf*x9l1
z?5+D3C#Uk$(?xn-bj><=2-d~)?i8(pbP^feW;y*>#|&B45c-J46eh2yi;NI3wt#ZA
zbYNk2O(VC$DD@wc9AKOoZmxNS{Ny0i%v(ss*~~j?eFTIOgd8q~it>`8<$cOb1O@w6
z#Cb7Gxp}7s)u{4mG;~c9<N@^MEmEeV!}T}VR%&H=y}Vj$(}`Md&kRWF$_NG->S{e=
zmh_&O5Odf7xk|<K<W%97eG8M5`H6{~k*#a_m_YQSE~gjB2ps`84MGhmU<qH#)*>S!
zozt5zb0BO46f^Ryn&pp*oR$f^jzOr%K}eFzOSt2e-ja2v$VEtHS8F>H^9Z@vLLheh
z4l6Dmwvda4OF%B9OBpUf4<R<cF!Eov7>@r+H!QJin;^q!E1S!u*Vn5n%hfip<xRL^
zF_+Yp685}d$GyB#f$hyVFXeK{JKwu|_wHHv@=GLQv=YO0G6csg>DBgU7b*m}`~T=8
zSu!0iNDVt+@uWSORAI~K({SfCo2|8Sty*hP&aX46vgDH9mT)0=9fMTm!=$8ECovH|
zH1780Dja#UX5_FBq@gCOQnU#W!p<iPhJ|8=OEPXozIq7ys#Z(4!fTtR&~6pF<qpW_
z8H=SX#EGlr%352tg=F0puMy?*;aVRsi`^@VLKY<;r2T*Y%dzi$_w^k+r?+ew-?n`c
zkPA-RxPLT^-J`;e(%$`GXa2I-k;AFrN%YMFSi(26waA!GCjhMgxr|%0LV`y_Az|Kt
z7)yG0$(qKTnU2<8k|!!M79u5EKDJLJ_9C<4%;_CSL5S~}C9*BAreu=H-nE4_qkD3a
z%W2$fh*GH{lxet_&5WkW+Bb8@L?W+@kLL>c^vWtR2!u-=Fi7N8SA&^VMy3qYMF}{g
zrRDYKpFauP+}zmQeCftLbK?_Px~d3&1>_nIFyJ5Rn;W6R0^-pCEN8$-^YpbEtz;zM
ztAJv3ok%fYi)Md>&WQ%9Fztd=@hd4*g(hGefkIrNkF&B`;yWx(boUNKLSGyo%Vx^;
zq!!kEL@W?4zJT01m}b*doJ!0>V~w@3=x)Y@61uLE%AQ;<mnxU5?O_X(M0;E%2d8bs
zOf#f^j69<A=dZ!`;tx+QEKW?%6mPzHOQDbk&SfB%ruAEbI`sP19?yRO2sQG6#Sa=V
z!ULF2^?H+NAQ39B)tU{Gx=^g{WPCs;n6+~>ggsMGlUjUDb7ZW1U`x^>2qlWTt&De1
zz&jH2d^Zi<ve2=y$s4x#vy;%7o*bzf)J);7aO9FVp|NM9&sZ*(O|7n00J*$i3y75(
zCkL##7569uge`3Qck3-pKXvLdY%iTSGdWe<wQFW!%h<$Z9w?-d8{KGx!Xt)LsB<|&
z1X$8MQ6O4`4IURu8K7MdFxKlWT7!-3kP&(L$|JE;3-20e6E5AYy_gr<LdYvllxuw?
z4?+vJTtxF8#ns47!^IAOIE%J)QM<||t<1V`Zl59=QY_UCGL}fH6Uls`kXc?{UtL+3
zVk<>Ki8!_k1|9i$Z6KJ1#MT=;a;>e^*Vf)Xb@J_EF#|#39q-<;{e~$D=>)knJ+R~)
z_l#^p?bndQ(*`1xwDU~@Sk9OcI2R2V0l5g_()C8Yg%t(_qJJr8(2S7a1!#MUatc+}
zctToF6#6H+#)*sy@gbfSf7%4fJHzFyQbexhKGp${lug4pX@!$AVQkbnb8|+)PSPjm
z`>hL<NX90o^7%Xo5?7Wj*fLUASkalQkTbV6NX$YG8+#tP0B~WuaDI8$uIc&t@on2C
z^MzC_q0scG?(4SNK}&5k0{ZeHM=0TV^vwuZQosnv1t(AK>eqpF)tY9vcZ}`sH9X-G
zEsq(I(GljcOo;oCdnKcb_|werdnD%DWw<oW7Dq_75L{>}aIRKEtJlf<DYnl(qQM~I
zg!tA;%f}$`IC{R6iKNnT*s|Hw^2+*pxe9+t#O;*|_izdK1+B0W=<es$eDq<ZQa^U=
z?D6Agvzg?Ld*^3ni#v8qClWC=p*9+ZjH}b)5;S7!&0)hSKeXDc3`@?N5LSh$DwVD<
zE-kIYlryXc#T7<JOKOHtELh{ETS#nN=&Cz4jsSZZGw`s8<jQK73>Ql$^S^g4DY668
zHR8_BYyq(q=;>SoGFE+Pza!?OM<htYkd57}88yI`Hkqqd*UROK{{kHDPa`WhO{{c%
zZ;-En@>=Z&KX?-!&(0PX7ACfBpPZjB87{jz)k8?rX~WHILPU*VN{&H;)CLzn4^^~C
zQ(Y`zga?gAlg(4cR_q|lbgJ@fK}I=?mvxNfSTB_~Glwi*z~x+0w3ZGW87?>EVxc98
zZ>U(!+?T}`ZJ!KwbFda>h(|8uzOrd2@-?HvF`r9LOe89m%<^&tz7M=xjoF3XgU>a4
z^_1mYWc3RdmSOw;_utsQeR6ubxc8>{LLm*HOa-X)yat9=eS(Q$;81Ou)Fw~5_YyDy
z=K|P*->k3KtJMY#7!{K-VVZ$=T}<TNAQWLj3bi{fx>IXK&(&bwg>X4a6cLh_6lL|P
zfhA^4!xabEi;R5zBetzmSyEm|K?$5oXuY8jjVM-C-LQWk4hqF$8eog6<k|&L8_+h?
zrxiA@hd6oiGHgeWo}Qa8EiO##*g0J+W`Lwqm!uG<v~(mJ1yaKgRrDp-FJQ5I)M!MS
zM}{*T#EHwx>%h6Hl?Jk8N(#pAiF4#ua)>-CrI|vN>(V8x$~k2dT#jGLaJ3~|Ccc?s
zQA!^Sw;T(__@K|UPQ`q^4!fnW&eJR7FnG$DOem?Ok(x5>l}*^nCdbCISFe^=SF8T8
zwXtl=6}kA_JbZz@`NrF@z4*eZiOKv;H*cAm%uml0D5z0l-ZOmY8wF2jqfPrdJx)CW
zEPgO;M6;<?Ds{MPA-VzZsvGWI=CUBmd1+jUGV*SUAu1ar6B}fih+3S5>t?9=5iY(t
zkdtuH9g_7yE`dd?y$mg>E@~Rg{p*~}!U~D`!bF~bF<n?J22nOvV%XA`=@wFwP9^j6
zV-R#-ySBEpOcrYWgDHI@U<>)$Bw((M8m(1)<Bdz><Jqa{!Ywy%0sI0`ZZ)-*AwYHR
zV_;A)obcrJc0F>v2(a8PimK%EDMZBdBw$=!CEfi9gduEZy8v|*mwH2IJm}>H!DcVt
z7sIYV6djYfk5QJAx)LtRm1wmy33ISrC#)MiChQPZ=RuLJ6tFqW!-!0{umWMVl1M1J
z>1m_0V_-L2DwUX>i^IeQ-g@oYIx%a+eF+k~&by;v)-I+mu8yu=T>}Vy{k4mQLi*14
z?%KI?8W?&q8K)H&eFcQBcfR57eIY_>1X%w01!T0G$(2evRp=})tygOe059FhV*t58
zZe`MT=Ez!PWLbHMJqc!nqEj<Z(0E;|948_{#Y!Oq(5hvK4<H^i^^iacsWg)7FKc)D
zKq7K+u*E_}-Ih?0$ADJxIJUL8$fe^fV_UQ}98o{5R4HQ(H%P=vIJ3({UN`*0wm-Gm
zAnLEbcC<8>1<ab?GPZT=B-|=M((Co6rs*39QX5q}-AlxWM%rFxXj5H;GRzj?X028m
zly=ps4NbS?o!DW~#nerlwY(r};3QPek|4>F!KF2ZZmF~sIWcdj9}NJ}5ZC7eF=ofF
z*D1(~Qgs=&5E2L%o5^Yn*pmW3NoveW#UswJj8|jO2@GrtU~6m)g2eTe6%uQ=P04Ry
zZmZ4xfX$`ht5?ggq3@x^#fjOu((c`}V`CXY%o{Dk%}ooUG94}IG<cAT0ISzj7j4K0
zx8v$+6@CKY0`Q`G`WP!P7PIUY4!ESZkmv;{naMa|3nAI^)Y)MSaD<U5dTRg+1n^R@
z-NM#3yk|YZ?3zV6!^MLKu(otYQB|7Mlbs<jXCi14F1A|@cv*aQwm317h1iO&Zv=s@
z0V9`BO5O=u^m?8-a|N~^K7VrS)`{8K(v5rP;0~cC;Kr(=&-}zAfla-qrFuM(Xq7Mo
z<SLai$h1RfL9|$@Hp=BH4U8Cg*+CyynunaGF}&J~lSjxEf^JUDLWaxOtEM5rNSRwD
z;M=sa8;*6H7DN~#T2SO7sjCDqEW0ez?7-+S5flg)GS>$*gKQ=Y*fMfk6^N~BzCmK!
z^cGh7I6vD`B+MAB(ew3<H!i_;^yum7>B3IKlWS}|t0;=5X+gZ3hYg{I2dW~56>_R;
zaw-oOcHJ;UrvYQN($K6WInz1<xumy*I8pOdd-*j46GKH(#@n)-0<FDix-R&l3T}R~
zmpq^0;vvXDD<zdO>x6h3!gkNcpZtUuGF--Mld1T0Do%A<L14>^ZRuJcVM{JZ42E3P
zyBUxRKzVX9f6FZk<Kx+h$$YCxR3!wtbW`}R532`F?+6tZNJSxGACU_J0c3b}!F;B$
z1z{tgRjuBDSqk5@LPu*6wrEU<+)Qi`@*rG}3|C7d?pK=5y9Sy)2l?hh=38^fWjEh;
zSk^G8O~i33ZPF$xly^o?%nbsu4vD<$iz0XgB16GDJyR%+WdO65mn!YuO&#eitPF4h
z2S`fs$OR__+iR~~1i)HY7~ipDdU~dq%aJu`y5byShQ1%ky8&nYqgBEU8!(@X#SCnd
zlOzx@1IE<~VLAqKAtYBUBHp-44EiLwJQ5T0ypt+1)oJLG<*sg(lt_+O>@CICkfLP`
zT?R#1jiW?DQDX|3V^$ra6O!zzMZ_;|S}aVr@sS=s&3`2l>dZ`W9D>9ZU|a1Pj)_5H
zFPesKCRN~s8sGEj%9S!~FTM0up^)0UcOGC1@GBNm;&HODID|cK1_o7378B&j5n%Ow
zP=8bi7?EKQ0FlC4xdzP3G>xFMT(LS23hQ~g(+vV4#B(&+=vmiWO%8diQfJEz%Tcq<
ztz$Z13)vzsBV0`;F#wj=(-?AL5qfn8Y}v&@m~*K&q#<#m>Y!B2td^@w*VfAAn*V*g
zVM6&%-V}4R3|JMw)-%uiD4C2;OyqX&nVp*}&CZr+RS=cVTqk6Te|dm5Xc1s-#Gs0#
zsVTIwQfaj`qx!l^7m^6)k~+@wO(-0Miz?=M9~)A3(<1UK8h7%|9BDoa^NI#XS0URA
zj0<tu9^xuNtC&jc01=<f;nzTgb}}4fT7(OW(8k)qav3_Z17gZNmMs+00P9Ov%fPwX
zPGdXEhKCfkOx|rBAAIz0y>$&Xpq4k>Ff}(fcEgUTd_D!Y2PIsgAeRpiY?PKF;LD|F
zS$draur_GGY@`n+C$-hpN@cyivP!&JSn0K0tIQEAO^UO4`z=F_1$$r$RD+)pqdr{|
zx_hxDKfZ^n9V&{1i$*knrAeZ?QmA5{NfvZnOt~W=(=YfLvRD^8GF(zSSX2K%7GaBp
zbS|45U$0%ewnlCHgWTvF?)?%Rx!}VAczX5K^RPYlTw=$LX<%DBc21{Kaq5QT<$KW!
zC=5ANd7@Rsu!do%sxmf~g>Af=gMe{)xdQyCY{<Ka7XlXAMqr!x2yr5|)a{L?L9Z~<
z?d2!TwOHkd5oey|+6<B1EU>?10w>~%u`<ZRfeCpwY?(VYWgG}QV2hGIMX|mx1w8~G
zMVi)!M(?6rE|txt2&S))`X1i)dhl$^DRk&1EM<fX&J^h6@#DlzaPo!x>}+x8u9@lS
zLO!3iI{mbq>HZ)P&<n_fVf`KgNJTlUVI1^J6_5)audUT!eqLKzYt&m1FwzV?;?2L^
zoKX$e6ITC2=9N)SD17of+}Lc(?DJ(4E<VE*PvBHap~ZBTse_%KLcEDHhhj2pAse~u
zMKqRbwJLs0L=b_1KFDMeuoX+$@@nPk)wOE1;dWAeM=qa5!d|5L3b)33`SL1kfL!zQ
zV^h<Gn+#8`VliWwp!)TN?P~}*0FXk_D&dF@s-z#E$N_S#tyNc+jcAc1)QK%UHX|zz
zw#+<{ZmT&77HE7HT)Gv+G?X1D>Y~g-jT7M&L}x6=FPfBcMU*^;vcpEC^YuMgXBjla
zNm%WgAzha<Tp}E#Q}K*ZmbkiFC5<pvt3krR5aYzQQqmqPiui>^n&f)<rE^nLg{|8r
zwr!i7n8+oQaby%TQcuARho`Q0#a__?z(s&H)M*X{=kqDpCMNQ<fN^D|0uTnA%XZ7+
zEC6krb`uK}T5-c#FzBM60ME7<Y)L-xsZ<Q&L1t9QTh+7meVx~2U?DSQ+iaQ6%9z#<
zafLf9^Tp40)+B_cyliV5I+KZo*;Kw%BGuGOOY3FQ-fcix`G6fLdR)Hbm0S=4pF4LI
zwxchc9vjczbn_NfRVF9$6NZT!?N=}oIMoH8iWt^N4(jX-0V7P&N`=^>LQGVzHB3)>
zQyhRuFE7hZ!1h8#Qr1a^E!XrGoh|V=Ss8?Qw8ffV=yp1cGt6QvhBXeeRrt)=#ts#&
zavcU|^l0r=nDKv_Szg3pC<g~XAA$D)l$XY`z(4`H%H?X16t!E6#y*a)kc%V=)@!hx
zJ$n@%kBwz%v^YMVgU1@_fuwmE>W3@x>U3`blT*Ro6i0wHVuM+=)M^bH5G`F>gD>HA
zlI_y$R2L?_2#xhYQ{Y470;<v$wpef%i$VMqQ)8H-m1r~1ULqN0F-v=gJ&ry7><H9M
zl36X)_yC9NxPct*u6B}3H`WA<Rf`PpEMqZoJxC||!OI|e_k&ir@R<teUw`c)+zC5&
z5PzGwxe|P(!9}C}eugC6>uo14g3<`EMm1VwjbmZD0_{3~zT9e60L2WiQCpHq?;S<q
zZ1%9gwxpYhSw0a_yK3DoCSqBS?OO^n*uq>(M9Ht2ne9;UQg~4-wiheS9@M-)J+hY(
zO*q2>;bK7|ytYtC=klq_dM==SP3Y;ZfNZPBcf(v{3XGEa+r(c~i^cTbz4Ji3wrm-L
zZzdSM3+Q_!Q>f=!Lg&jPz}gG}BgU!e=~y<KX*5W3{_2%-wboc)Z?FzI5Iy;XfllO#
zlM3e;k8irwCDD!<9WBDdneWyh!vY}5nnK5dTMm=*V;%bwE^Ji=8P!4rd$QS7I+L87
zB(Sx*y1u?%576CUplmBdb-uz0=r3PhJ#ysLcw7alwRPLX;^M@_L=OJhQF?x($P|hU
z{I073K~S@)19DN9!F)aiXtlgtDX&(6XlO=WmLdhemWLd9cZys<tWrtEuqri05*l+@
zW?fzRfY7W8#125z8ST<JV=qIB#l?46Fs<hf2qTNBVO_*KR=sE?xfBZs=*lQ{-I|)p
zudI-^W2>u`ATzcta^X-RO%Jb8Bad9CPhW-&plavNX<~7+Ylf0>YK1B~7k7s&VW!DC
z)j&jmHS)u7<I;^j2zIqhJfV({=Zd9_)*@)Nyu4nmG%D4)2^<(Xk&87eq)zP`=ljeW
zXCU6k8L_52LU|CkH|Ccm<kxM@5!Rg@TM_eR#dbo?1WK``Bad80Yiq2Dt;&E`l8aEx
zl-H`OE7c*46ZP;iTs(3aUs26hUU>_)AO7&<!s5ij!uZz3iF76ri^U9FYuR~&A%-gF
zQzF3H4D^aLqu0fPX9GB5iV{;u%$Ug};2wqPy0o;`Y_{MfRCvh=%_-AC3F6eQSn33h
zg>l&^#*nOD(@bnd%7d5{Aj@;Hj?-K-F(FR04Fc^WvGuFA$jgmz@s!9a9XF5LSWML5
zfQp3-Y?Vq5*cM=SrBV+*Re0nI;^)^jY=zjRk(Z&au2x@u=^Sjpwx*^Edv2TqsG6B6
zW->`*DMt5SS`9HRg}N;yi~wtM0ai-~hQ-e#*EJ%ljmYJQT^FF$`g*;*TB%eU^vjkS
zbs1ez6;)N}*RRui-cBE3zOu*WS}aK9Z2Y*@Lq^kV`MaQrmtadUS#=;6=iRIe6^mAo
z%JOQOk@}*M(Zoc~5S^~U&rssT;Y@F_{V;^RbZG^)mtTGhPHF45Nr;zs@0o-9A)8Io
zqD8N+KO0i*?6s2!uts~3Dl^ioT4(*%siC|7pk+X%5=qh<z7cwbbiJ;}R4SOa*W*~R
zkK`qfc*>*m9i(-h>sc*!g!DW^E<2X=fGxy(Njs3s&SB}6SQhgUtF7fXGHhnRX!Om^
z!MU%kRY`hlrBV+jyd3a)V(4#WMvKPHaq{Hbu$?$@c6z1=p(4bLa6#bv3~nSUL+!|;
z$`xNadbt-+$~%eN8b&`J)FB=eAWRQhS7xNE;!{&`V?S`4YE@ud&Bj`}#!^bumY$`m
z?4D!xmpEpyg~aBgR)!vlJy{WtCc14!Y9bPAsDT98myKL}B*@-~pWZrOF>V5=9i|#=
zi}YtJmWYE5gogmx*RHNrs*Pat%CpmbpV$@(6}%Mg$bn^_eDiJCip9+Mc<!c~=Eugf
zz(8qkzEc6cM1_J|T>0$B-bv(#wK)cmqgIR0Ug?_F&G%v=sphh3GMNM9T3Ipls7q@=
zyQnn+RxqFHV)K=Wp)lrF^pG7q+R$Ty8<zUVFe_#b33vl&o$DTktaf5D;bK*ZCJhw2
zR5Oo2fp9Udk;#zWHl?v_c@+p3u?!3rCkAS(Gqj<i1YV?H<nsEPZxRRk*}2lrozs((
zc|dbwPh_Yf+U2=I2>Rsx=ur-9Gon?!F2#dpy1lbZ2PUHSL{foQ#?%;m&B8B@fUyO0
zczvw~)0iZ>S_G{~8lP)2rb}$gLNTGUtOZ-lSKf*qkudEYettp?qq&I4SvlxJmkpa$
zi8PSML9QB{BU}(8C*$c<!iW>8T)yHemv`$&uj2vwZ}q8Hqar!b|L8(4pW3}=7JffB
zSDKnGP`L~<_F-q;W6<Xk_c5)9%ehBwzD7SDWaT(kJlGArg7}Ek405sn%Bp~N&CC>G
zkJV~}bhUwav89zQgM^rhg$5O(buyN|D6PJ#W(23({>Tz+@%eIv;h435UCeOtj?Y-A
zh2-*X5)QJQ7Pbi&&C084tW?V8^Ql^`Nns0urnYIU0kf_C5iUlZ;bVr=f9|`lBcl`y
z0>-_2=O-s~GqXi{1>l>kcPlPAc+~y473(b&0oJGvLw*HZUFYM$F3<{40q9jM=8__1
zaU3fHqP=4c(}*hRdadb(-HjO%vWgidp2AK$2dmBpBhHgSyt%CuzRBLOB|x>S2)UwY
z8@ZScLwC4_>2i__vl47wXBjRETd<#WCTTcX=OH?#CN?xCYG-1zNsx=rb5$yJ*e+aH
z%48CA^J7~VC*WtXn2yI|)F77^qjnbb`G$T{_cMlR5nzorW-%SP(2c&65m&KMg%hYf
z9_<|q8{DT?udcP4tqL){sTz3>-4J1!Wz`fDTyy6_FKe+0kZ=l2z=Z_Z;%A0{T+9Lx
ziB*rhb%d1`!!{gZcJ*w+Wu&*_adl!cKQ@+GCuXOW<z-T;8H`!zgM=;ApH)RET7--6
z`fC^8c>Pj39pANUHkl;K<b{QCpy6;=_|z@B#E-slA7;(Zb;QT}5yKkoA$EKaLZ^=C
zRWhk~p_R`xP!wfqszC2Tn8px6K-k!75`TJHjU2<6w`~xS%LTTOqkWml#dx!M(F|Tp
zpIO(0`>XXbQDrK2_pzrF;yk=ex@sbCE}w>NYN}CQt1VqyTPxQZf!yT>3R`_zRg|Jd
zYUO<N=xO7tE|xE(ckL!t&hztQ5Kz;v0U9v!nJGEwb0b!|{hcO!Z%KD_1X!awT83V<
zmjsrPYgdxVnBEg^0zpg6&6xosgo>nwv0SZI>!iO9U178=QccHXgk92GoT-D(tvU*D
z!?*UqE^Cfl9*tp`^(D^-h1lX&n*HT3D#Uc&_*u6I*Z7!PEM_X}H8@A$T)`Ccx)kb;
zZm1|li-6i!ua=+tZW$QXmM!CRbEU<t6L3kVrt|O{Ghl4B6E`3|V9qN7tkE8ghSq4<
zNs}%TSV|1&RnTBC$bj3lP{_ar$hEYz20uyT>y=8=2pHk*L^gzx*yEa~RL<_xd|JvO
zWW`eGfi1R$m_8nhoC})-)0!wk0S<5UWvA&$Zl3&;G{wlKCMWZN%QT}Gq@B-ZN^(iy
z1s^Z1xPJcmlZt|O7)96HwoO9Vn9d}OINDa~NpWANnXd@2Mm2lYXb7GmT8DxLY*gXI
zV%R_S^N9+5R`db6CJh5$81-87>b3IPT5V;yf(-SOZs;~8e`hSliIkNI&0_f|61lbE
zP!y~5T4-iLkxMA+(ZoI%(pzAxOO82Ql8Y4I881&HNQSF4maQ7Sj#gIIr6t9oN^<oz
zW@LG;MuX@cXz601kX~Gz0NS->VGOR7qL9u2tms+~rih6Aur|qnSx*J-T#LZY7*<@x
z>2wVBK(7MMw?tB%oh`wG@@f?TXk~eQwOp;N*PB|4iXseEDspy;<y|6l(IvvPhj*r>
z6f3zaHN`-dQM@%@b&fqDt`8coGDQeU4T9t)#TMCfHcO<Zlar)GacOCNeJxOiYrwFj
z_aD6Yx<%MO5YH1Q&cX(tzN#vea{<1mQgOQE>f_Sob1O%HHL46t`e&!vE5ocE>!|w`
zCV$POQ?iuHr;yP>7H(53V5}`KRY>D&jW`_>xDk6_>wJ|W=Tk4L;VqvmWM+k#!pc&I
zF_y&Us$p<y_w~^w<g!CiEFl+nNY+JY8MBToDNf{ILRQvmw4+a@(!rAA;0f1YzzcSM
z;ldI;ID7W$i!YvD+&VEeRoJ<68vdHGT)L<V&ac2AS|uEPz|x(V6?~*pF#s&v1Ezng
z;;s>dg2%^m^uBJ?iA1wnY1EA}Y`Aw@h7T8Q#b`+xEZ0D$QMLR|`OFs!PjuvBN`pDl
zgfX+lK`eRCw6Ai}5Wl48kYDgiigd>1aw*sVyvpSo?Q&GBH3EL78wgvdKQ{u8T<{e|
zOBW$vgp;KK<HEvtJVBNhlS!5O<$6ICRjWjRHIk#*Bt0gCk2Nr2DKR3vA}MfvgU^Cy
zf@Wrlbh@sUYgDDFTk)fTZa}^iF1W)y+rqXN7oXh{jO5L<6k@eOTv`g-F(bDKz=^QA
zT5i))0&{PT1R{nFe#Z#c__$gskzOHX<GdgW4lafmJaXB6J^GXC;*qOdCdCreUl2mY
zSd0XW3yTvFR;N-4n&mVCMvea}iWt_Y4uGm!jm!%Lcf+vaD(fU20@3SbUWrCD7-B{m
zHa43Y%y8KG($YGS)YnMVKvk*8mWkRGJyxq8HrEj^9Hq&7qr-*mhokV<PJlBD^!Q>U
zD^#T2ueqXYE?35xsq%yiW*`JU<KtPw7NWYkS^?zJItdlgz|A3?zw8Hc(fwb#v;q&#
zpI<t5^bEzU9Xn^>@7Zk93>bBx!&3xUBMDec&_GA<4!|+hP>L!Y&?}!Xp-m6ub_P;j
ze^pflLMnIwKO2qKl`CbM@LFA|k`7iaje!^9;D!B4*O4xoI1A6UBn}GZP)WA;l0{xv
zXiv?#He=f~P|AE^yGqf3V=9K2$^&2lYyo&xs~xN=Zg{8|I&w+03oaDZMgZ-CYX+g>
z%xn?D#)KI##%bww1X!atFcxl|;0_HirBg}b%HV=lU1cx)CsNxf))vu#3Ie>&&yN`}
zt-%bxe7Ouifr6D+E0*#TQM**#&OUK)!<oTLL895d(OUS^ML0taOB_}Pg#~9+!B)_z
zkYLP@hKg!TDV8$DVj8Aj*^qibe8gN3hKF!%AaYT4$d7+~0k-k+91R#37sn?i^H_-h
zYcv@ak1)Xn?h5gD$DTkFcE+`9h9%8XtFfyB3<Wl1=zW%rZqIAws&R|guo1A?4R}P8
zKb`Z#G2=ew8(|4d`RETj2$xCZkm#H*5-z*ITXM+3f?J_xEb1o`>UcsOD`f$HX_5;j
z>d*>M{X@t;1&lDRUM<7Vx8GhlapLTjE#ud&#v{NQz0qiBEaMKhZouv*M9L61l%l%F
zjgE)$WL*z69#<zP^AIos?Se@TF(VP3uT<e1xKVE*Y^SKCoD@4vn>{huLPA?<hFpAl
zi=iPyCB$T_vKy)_*0-{6W;TsQ@x%!ulN_JORVt(^V0E>+wpI&liMR0!i>PldT}W(p
zeeT@V%6cpUtdUG$31leP%^i=^-l({{JF>gm(Vt}LdLW+VgJr53gAKlW0lBDp;Nr#Q
z%6ffewPNZasHz_GHqCZhFrkEyHQ2CHS6GU`xsq%?y0n{`amC&yA>(0-1(3RJb#LV#
zNkT1`P3Cf`$$E3WQio7+ZLJzmIzJ4A3-z-M2y@YT1Xv?B>UE7b?bCzKZK4z<mV3H)
z;%Ot&SYb^u2pBV&B<yX+j_F3DwXy<$1);<$M2mFV8ztC`d11ccJ2PppL}{WW4(t4b
zvEYzlb@XwvE#%PR3yFCo7jGj=SO@<B{uT>q*y{D>+FG5KE7og`AzWA-aI{EA1X!cT
zu(Yl`MM<|o-S+l(xuJ14B&)}T!X5$9gG<KfBIDRt4rtevE31fD)UQLR1@R*=ni$|#
zjBfxW)gEG<Z!68)Kx4VH8PhoMB}7u3$k-Nt)%fOVh^6+q5-SLM$HwEuVj7MaFn5g@
zRaYyOM!*KBLlrHCh+Gk1jo9Fq2x%%LNJJP&d*#cpa90zf_l3e<rX0L9m5M{a2#;rG
zinUr30!9cPD;2_A0Jd7j<fm0Z%p4W5PCphB@#f36Je4z3<!iQu3>SkWUC8~LSB7I)
zJm+FxDw<KN2*_0`5e;g+(E_Tq3?c7&ZLM4zA<h*d?TP?vlm_WS*mSXuZSxt&N$dGQ
z_iI;CVMi5({bN{GYkQB2U}U=>V1&m&yMVL6o-bS=_ys6Xtu|=kG{r8V{SP<86vU||
zIB^3D741f|$ffwvCR}2kOX6I%c`QRN<5_A<Nf>oM5cB^3>|JY+6xVg`p2yDYlZ8ci
z#V!aTumKB63*HA3{$atQNUFp<q&P0yE2PLtDFU2Wilo(+?MebHs@Sn3z%ENAU;$U`
zVg)FPgd|HYr;;keQdUKF8E`4T5|)Qx&F;*;=GpmfpP8Q9Jv}|$Gu^W@qEB^A^>p99
zefx30{?57Qo-;WWot$7(e}KXjG`3hgc)5U8NkUO&tf2|>y<&h>Z2sPY;>-x8%|B}L
zM1g=G3ku6q8YPNp^@ox1Xq3%mi^yJ49t!uY9;i~LRA;7)q*0AeB`aiy_vMXTN|Hn_
zT23kon84fAbONiAGnd!vnblBTU&mr{(bOL(j8>yWlp*snL+V|?sxXlU#gm$-z6Rp;
ziawv19YVVR+fZR+g++D;^NlP383|+>8mh50H_wX4lhaeN>my;D^u`~?DU)bCk@Rqm
z^-78`m6pfZwKD0l)!wS97N!!@nuwN@1zY@i6y&O@VPlJEInWl!3ssj)b&gsIXVCuT
z0#+pn=oPOLnjuX-ujsXDp0mLO9fOy?q#52#pDVi<>5Rdkzj1aA{!ReDWX<c^weZwb
z6htO%=8|n*Y1k44l}kMjvZ>UIY8u6BuLgE5Q55*Z8KRI$GQv+4lG5PCcy!QTU0pSI
zF7xMNfnLKbt<kiVKoMo4FdDHiH(Eo*sf3B7#D%8IL$L53gI=i;RXU>;I`@`a8tpRQ
zioDQPTN}Xdtj3z==Ejihh7N`6+O?3tl5WI7zGzC2B)d>4#;l}v4x`9LSWKPKLj;QR
z(o(d=Y;@xja43XJ$Vxau;6>-Ctqp>9LEA-xp(iqb)bKPK9Irry(Nzg6UPQqHTT1DJ
zxif&;GC?QrKw)0@QM(2Ti(yy>CE4u1#u`yhgDlANMWA^l63LN~aZn%1iOtl;RF*St
zFp=||;L}x+!l>^SFKENqXD8s`Z%g*4h(-@t9^5KlFyP1ETVe@-*LZlE$d^G%t|C7e
zE?~K$RSEh0xOwRnMQzUvV3~aDtYcO&Mt3ta3QNzhbelmL+bQBRBphN<>aSf71HXV;
zW1~~NUlk*^qACELDr&Q+9yAm=gQQ*<dp<V@Z~sbV-%3h)3Y0|P<@0;7)KphVX?lnT
z1HXV=1=#6l7Q9@*swjOhA*s?*8X^|ZDiH7p1!PwhEkju`1BH&dV%f=Uvzk%gP_6vN
zVsQ{Il(~K_G%*pyvr#<kQ||R*<_>By%aTT!<orm5EW^CUgfFS1&ZnY%aqh1YkKa-z
zXH6jJ4+i~p^})nEHo_2z#1x&;l1u7LJsKCVDhRNo?7%Vx^vdsNUBx(5R%u3vO6H2?
zsDa<O8Ge5%*T%eg4e@va<mKws5Q;;81abk7D5H$e=jFc&T-0YB>s7XeOAz$4&vH)l
zq87FU)f{Xo?QaSst*r~x)dlc|fM-RfV-pjR>FF40yOtEjQX-cNSQR7jcq(q68I4W0
zUKQ$lRp_L`TrX}Z2MWu9hylE?EMCka;mn^u8{mcI@}*JS1QxfC1{~AC<n^TDDT<jm
zT&lnisW4nZPCYR%YzgY*8p=Zfcu~%dD!&)nE~sMKjW!P00{MzY;^pSs<pNd(0ah}e
z$mCTw#v;E@W#ugaa1=8ZnYUqO>noI3$VpXT(NkHX#<8)<i0oAlI&<yg5L+3K#1jdM
zK`5mCRI|fu@xY|X;g}&@>fE%vCqxFhwDYvnWzw^hs%uzm;>N}rXox^A23yg%9Az+(
zVCjvd0`N=7F+@<nGj##0f=yZm`k+q_uxue&g_*HjApsC5>#eP9lH<o8j{ys&CZi)G
z<3O#59GJl)1DJLiqXxFrgiGb*#bsgSa+0NxOSL1zxzf?-6B#Y9rltyNBWPGtQynzN
zsi`P*M&K87@`%QhR$edNk68icFc+{YM#v;exL|B?_oehfn=M4eU{;aj&QX8&nG(OB
z*|TVFHo*Z_E?v42iNwLe#^eY&iaAM4O%>7xk{7ZZxQK8`>a=Fu4z->rXoem6Fl!Pe
zi<K=59<NuZs;X&hWKD|3z_!>Na`LJNikUZi6{%FZfK@4I#Zo<+0T=8idR1)iwbi+y
zlvAK9Q9!83RdwmoW`Rx5jzf9GwOkrz_~r46Q<E`DT9FAXAxNnZ99hOGQ4qD$ss-)L
z>TC-auWSnG_^3RzF-(!iZ~|36p-QN(shT4PeVv|)0k#Og7@V01QC}D%a{;Tu6hKKE
zQe0mjWTCID5D=>*tFTZrMH<Lv{1KG04S|4f-n<5~e9>J6euc)S@NhxCu3imMu?VP6
zJm~@bNxL<O9#J<fwxITe;6t7Ys<;$t8=3lTlLRh0Yg%yXx;lAQz^v*-QcB3tyMS2~
z#)qY7V?mITcHJ2luqp<yl1WLOu1X)X@B*>PgMuJQ<<<UtW_7`}fax+X!jn03>Qd>l
z1)+686Fq(Kujxn(5O!m9f}HGu7sQ^tJ`ZhC%v%}o5kzeq8$AauE!)b1E#(a(*BNYM
z?_QO!D&Qw4iWoG-gaouA<Cjdn5+<Xk=DZ>H-rvE&!IgL2{qDQ(=Gyz<Lk|~F?Zt~1
zQLVDvxAyY~4jizz<*4@b>C+CqcA-${nP>l2Y5(8-{XbxfRff!erE;0D@Y4AGMVZ?>
zI#&%3537wFI?7^+X^7+i`dY10Dw{7rO$|%Vir*zmKXvDwt#{qMu&r&;J#Dw$xv~|Y
zHhXprG&N|8QF;DgQl2@KOk`ZWQZuVXRm^&iM^v)=WOj(@TtsQFvGj&?MN~%2AQ-?a
znMlfcn<c;B8w~o;&ZefiTW@V#u%Kz-!Z`~THesc?xv{=J7z|d)aegekGxjsAhK2@o
z&Y%6Xb;XJm_SXE{-+V|bKo<1*u~7JL{`woXSMG#-{V)C!zo*`Mv$eGq;QRd_{4+59
zkw+e}q>tpClqaOd2R+8j#e!C7#pN9^w{PFe{rxY^aC{}lm|F4I<xs<vkkA5iTb)I~
zdi{EsRI@8rMu}vxjMK>!v4RfCNEXGqNoG7Juq#EE_%Blq!X?V{7DctI1V1xh<Ft&z
zKA)GSH(^&}V+|XVOt8@g0IQsLlCi~PIyZ;z7s7tP0#2>z>I7!J`pS>dKb?3&U0q#(
zDqxn4faRQ=J9iEs1+)T`Gd|zi`n~V|W09|Wu8%zhld+8oSh2eg4V?*vLlva-6)=~u
zNX#n19Z(cKGJ!!BE^MO44_~|i`~pagjZTKc%p4Yvrw5)TLHW*Q&+^HoCn~t6a+Sz(
zr;yZ9B@$^AqtOEo8+@#$fo~bMDCukx$Q5A@YOICw%z;$22}f*LPdxF&@6Mek%%WcE
z1T0$Bs%A>4okiXU`WC6Ow&;o1Tb%n<ahT<3k2Q%G&dq-=TZUyU!Jwa3pg+>ev^)z3
zSnz-UI|9uOzyXpqIywmzGUK+I4mapgo2w-C)N4V|x5_JoOAvJ8rb_A$uavfeG3N<i
z>U7m;b}FJ6v)Pj)#eaX8^f+{zh(rLhjHw57rNYcoIF=v)N1+n@eej`&$vi}Rzw~Ec
zrkb%r#wpMooJC`(LU|}?8XK1G;ZWjmIDafot+_zdMh(zlE1H_UT@f@uF>ldL$i65%
zw(xj(=gz(d9_YgI=%d}o29GE;jE{%=`}-bxc+D5?@95s}g(F7~rPQ=b!)xwc{r)fB
z+xqxdyVk76(%1LA^7<V<a;URwHI~g={^aDz<D7DLvFEX`babx5();4`d{a-HINsCq
zm5z>8Sg?Y>qztxqtlHhb6C?{OU)=b|h4t7x!6!^lCoE_9C<g(AL4^bbTebT3&$ZvN
zdiCPfpIf~0t_3SsF1S-(n&#FAg8tgN0BBb%7RLg16KCdpDdn9dsVrQIc}wI?VB9U1
zV~2?uQJcw>dQwvzlTwlv*$_sPhk^lrZEe8ol|0Vf7tkwUM6QlXpn#tI+uwYM1pxQX
zyFWJuI7J2r2hqv@{E5fuFP#N7{OqUy^1y~}{6%kv=0!DQ3;tpww&0N04jkmU52||f
zku7}Xxenj3VFOx=@=8fG7$~L?J(R&-rB%F954Qr>OVER2{9Xb?v>fL`v9VBC_o6_g
zpL=fGl`F#o1IOQa=k$xcyH1^Y<J8+Hsql+^J1$?jbnxKo|MAPSyLat*<K*#^Z)5;y
z&z@ZyzqtAIuYP^#;L)M8Lr0D<IJ<D+{QmuW_wN1SnbW`Cz3U}ta|(9@NNw7*W$4TY
zCyxKyg$w5nA5Os^R{HyQu3z6hH1q+Mb?dwL?R$CP@S&ELma{`2Y}>Y@qoWfmCr|wA
z3=$AWCqEZYFw08PaKX@|xw&y6Gl$Q?($=<U&6=g1olEY%d*SW3&s%)Qr?9lN%wfRd
z@qh<0buyNSMdNId14%2eC2(=QROjFxjn=xaY}LRY=cJ!hLghGjJE)_gLoR4-fs&X_
zE3i>9LUna@z52=u5DGv5ph34nba-VQ2P$=<Z=+W$Hh$EMb;VAEVnBgogRkQd)Qr6Z
zUIcvDqA|3gWUj*jMgS=?mIGx7#ZU>ggzV_LW;<*|3xQdv2iJ&V-}&~ph)DtOPQCS}
zauXoB7xnLNzJ2*JL#z7w2K1b^w)V##|Epuijy(8B8~^jaegPmm@Y?H*vuF8yVtae%
zQ%`L_`jY{G6dk*3=N>=_R+cSWzH#GbVAj{ZwiSO-RY!YjI~Jw2{kvbH@<5_Z8@Igo
z-p_k_wuZx@fdK&4OY7EkQ!#8@zHIr^+n(CAX>&t;gUKH2v`T3H6s{vhE&;J3lh!S_
zG+<F~*XZa3J%VU7PU<A{N=-^5BP{+s8NVd8uPH+}A>*E}(ihbzt_dt5WI2LK4jJ7w
z9hEQ(D?ALLm!iXKOy&SMl=<Dc^SJ;k*FYXRIX@x^TtMYKx=|Tw55NK>i|_*QK`R>S
zm+NrCI~2g_fLy>YREXLDShymr;9`yKZr}O#3LFK>2B;!SpN8M%x+vfm^u8@yy0c3H
zt+4A)zqBFOdFQvZDxI@se#_ajXRz{_&n#cJZvA6hzY5HH`swZbThY>z!QA?WhOlf(
zhq{Mf1+7ThJ30Ys*tLFLckz}ZV+1jd9A5%1R-ra58*kU_*|o}F#i);`cJ=CLES4m%
z`{9c>#wQ|PPs+n<Vq!WXo5pC&kMN5(V|hevV2O;SjE}#XzWa_lj>^6CTjc0anmY^N
z<N23H01&_n6aXPYNrlmvIUKtHH!|C5#o=H;04ykO=VVzSiy06{8-8{A48ffFehyaE
z-@lhs{bWL=U9{cP-oIyWO|{qW_vCdq52wfSdSB>+VtC@@@y@Q*z^opbc3FFgt+OGg
z8J0_(N)Kd82v$K3$C^kal_xbkd}DGV;_;^bUcNj!IT=;pj730=#`#G_f;@WYmAx($
zqdPC25?m5U4Ilt8q4ZBe3Xl}O81@1MKD%Ohk*7lqfCB>ng+PzP*>%~C@!=p@Xe16t
zC8Yh~>QEKvRkrmimq5p)5rZ{doq#_xhjeyye)Q1+)dVX0g^7u9_Aa2+NB?sHB&&d4
z3QZ8OHE`(Y{{4H6OOlfK{`;y&c4p|z@bED0GD$|t$Bt9Ej-%x)z?!NmpWpALWznL!
zD?Zz@Y}tHTy1JIEUHj>K?_<k-Yd^i_-lexMx}~LMPV0iE*48;>L2HudC$d>S@-JDh
zupXDgLwHJa8DJBnPw_@5ev}Pb7!VC8mP;SBgpXu6Cw#=OX7CQkLYkef>!$JHq}$?f
z1?(Q!&`m>o*<?+*v<Dx0SQ!I7APXIia{;-aGNUodO~{2Tt5$Wq@WOV$7ImCsgGc)M
zc3@@6l4ZcG-rnuM|NVI?eDvtRj&D3=+&`J0XBwo2&Yr0^HbP0v;Pu#JTYGz-=WX!#
zyKUPJGGO6%c$keRoWF2>EHvhJU01TDy1HuCtQtxLi3K|5J#Dvjbl%b4zPP>P4q7@p
zm*8(FR=DN1+vYYj1pR)gbaM%z7+#b`VLDK$XhdJpwsPrlR#n1RU->a=R=f~+>%L+h
z0?-t8I1c1T28godGDXqpNRcGG2IS#Z5V|Sn0%j@a(yb(skox*|z4qGvZQD|c+vnHb
zzkPek=b*QD*TCT)J^A$>`g{NV>z{wFFW+6Nhi(XEP&Qh%?B2a6?~U#0*$UV?apLuT
z`(7pt1zK&|v{|8G1BVZ`cdSBfhY$axuuwDkqQAQ#w?6q22>2*c7%#WZpB;}U-g-MK
zKKbO6|Mb1@y0@v!B@~K<$K%vnlS$^TlJ)KK27}(bL4|at-{@=+Et#xDeba_$Z1^b5
z!ey`T=*{3b`bm;+KJ%={y$cl~X5MwXj4bwKUCmvIaR!~@A)`EPO)gs5A}(N6k{HCm
zQYMkvRi|E2OPg)JMq#GS-bJ3>HQBp>brT7NxH8bBC}C<=)(NQu-9{|4uIq9c7qDEJ
zalpz%m9)LbXV+(mO-MONR$-K+c(^ftT1yQq(uU>2s0&y(({u7@Qx9l5L+&BD{3J{F
z(3#S|N_pB+f{3dUx`1^Pi82>d_uaRg_C_kSFWKa5S#a;Q7e*~rR^+K&hUEg*&4yXI
zcX8d%Faemgu3J1hI6e;GGAtLcTq$R?(oa0$6+NC3u@Xz%%l1=Ov}c1WE?~I~tK?nO
zd9Bdc+5Hpw_*`)T>yw6720jf2d(8u!Lr_qFR#>i{pDyIMfaQuEy(Mo~Dwvo^l2o+A
zq*QvwVLpam@fT9jDC`23D^B%5P5v(3{-E><Gu^`^$<o0}J6zr!9Vj$ec`4@-y8O%q
zteZ=GzML6xG-##UX-yJ@BArM}Ksszx&0N;w0+uU|Jt|MmXf3%qUSXJJuCLobvI>I|
z8?V9=^tl22T)=Y08pHB>Y>zu!ioROF;iXZaN;Wme)dyX`y6HqtvLx!cxtmG~oeMik
zHe6__8(Y1KGFSIpa^?coO{fwwl4V_ia;_Iz*sKdN1-H#EGnPwyT)=Y0L5Ah^7Lwe-
zmY6g8q(*mC(Ru1&hGCftdFZ}YE?~Lhm;%KBORpmqKAE}58btHN%T6`QWJXnc8J25w
zF9%^sD8Bj3v+j+k2uUP7(-EJP)b=y4H|h0C#?VoK`Xh>FI(@Mu%hXvMRQDtY>U6~^
c`F{Zh02Zk_W8a}ZW&i*H07*qoM6N<$f(4Iw9smFU

diff --git a/Templates/BaseGame/game/data/UI/images/previous-button_d.png b/Templates/BaseGame/game/data/UI/images/previous-button_d.png
deleted file mode 100644
index 688b3034593019b560c95d56ca9ad50633a1d800..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 290
zcmV+-0p0$IP)<h;3K|Lk000e1NJLTq000XB002=41^@s61i4(d0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUy#7RU!RCwC#*C7tWAQT4R$5_yiYII!}
z?of?JPOJymNp^(U>aLQWp}M-VW=GgSOtJO1OWsQ!>dPPUAR&lL*PV&z_HIo(bxiQo
zG};(LQc4m+6k(jEjJ36vwAQ4Q+D*=|s;Zp)s}5;NiF@#a(PGS)F=NIkUe^`Jecxkv
zS(e-o9)<zi^E}VR)FO^C;?ro`7RSyxs_Pn`v-cjyDY=yX^-w|xI8N_5Uw+1n88iML
o{M@z;!s#P+eT?HB!7l*@0K(HIh?3cIX8-^I07*qoM6N<$g3LyKs{jB1

diff --git a/Templates/BaseGame/game/data/UI/images/previous-button_h.png b/Templates/BaseGame/game/data/UI/images/previous-button_h.png
deleted file mode 100644
index 26cf0e8c67dd87290ea60c90d31cb755df60b7bd..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 561
zcmV-10?z%3P)<h;3K|Lk000e1NJLTq000XB002=41^@s61i4(d0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUz(@8`@RCwC#mN9O^FcgM=hbYMiQjl1=
z0t-C>BL_eXU0B$9lCDhj0MLO$6qS*o3}t8TfCx>}q<#)g6KIH2DOD=f(ZiAb^zpyn
zi5)f=3~mA3^Qa@I>5M1#`~A9Y+gB5((<yW?R=1l?-m%QYFbu&HcrtJ76uC0QFHu>3
zy3Q2IOpqltj~r`OQ*qL)SfWmr$+)hfT<Z$UP<12H8(n2AO1|cjeP)U>Dpz0?$jW9A
znJJRv70iF?ezt;2GRTc;khLUPhNfxoeP8r3h{ls-8II%Nd9@OKJpLV-Xa}A&o6T`J
zI4SalX4iGGUazs;zQX_T<M9hOC|u9SeEx_=qXEM(zY0Is9Poo?xqQNA^MY2Z1<Nv1
zn$te><i%nEUDpNKvaD>fVHg+=hoVTjm&s{2v?w?ly<QKUP6wXnMagnbklFbPh8T~>
z*zfl+&4gw~WTf37V)v$tcDs#Qt(E{W`NC?cXTyDWF&d48=QKzEmifXSk4MnKPknMc
zb1NV@$+2JAWC|R|1$QJB8FEKb+GN=OF;Pu&sb7pz%GFO|)dJ<bQh{<#LxEPFj6&pM
zn*X31<;fuO+itf*5CoZ#wC-*)nLMb-_!M9OQh$5K(URvI00000NkvXXu0mjf{|f!F

diff --git a/Templates/BaseGame/game/data/UI/images/previous-button_n.png b/Templates/BaseGame/game/data/UI/images/previous-button_n.png
deleted file mode 100644
index c0b9f4662c6767a69f24d83f3b532a363e36a43b..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 494
zcmV<K0TKR*P)<h;3K|Lk000e1NJLTq000XB002=41^@s61i4(d0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzkV!;ARCwCVmOXBRKoEt;h=z{J&~N~!
zpm7eAE94|OLT*EmL{3F-yP-i!3Z%H&3A=bOKWlcz@=8XU0`xJ=dpkSJ>g)641pwaK
zh{1KW@K4h;sFYfamcsxM<0y(26Sj<r00dV^Z{0sLz3IyAxs1oiEQ2N1Jxa|off{tc
z#Dp4ipg@ejuJZ~56E*^oDbVkthy<Ey9PpWt?i7(5Y<(V=JHWxsFzUJ<KQp`A0_rG=
zVsw9A6a_i}R{dwIsxr|%r!Ome&AZ+AXop;F(Zk_rvd&?$PGMg~S(X<U6i!C&MA*}2
zGqa2Y22&TZEQ2&nXE54e9eJKx;SeozBU!H@Ns_U^r51hOZs*p)6*!LL5e$Ck1~PXF
z-aI$(UULH^0%0VOaZq#u2}TACjJZLl5KkZo=EeY~GSE4~Sj$ZkuePWyHSd@p7@3)o
zd(e}7UT@s&23sJox(@gU(4}UHb=?mTGFw#Sv&cH&=ay|NS=UJfO03go_wV27)XQ87
kUGwX4zklcang0tg0KT&>jr)t45dZ)H07*qoM6N<$f@y!$IRF3v

diff --git a/Templates/BaseGame/game/data/UI/images/selector-button-blank.png b/Templates/BaseGame/game/data/UI/images/selector-button-blank.png
deleted file mode 100644
index e965b3af6f2b9a269f2d363f6118060aaaacfe23..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 744
zcmV<E0vG*>P)<h;3K|Lk000e1NJLTq001Wd006)U1^@s6hvIq<00006VoOIv0RI60
z0RN!9r;`8x010qNS#tmY3ljhU3ljkVnw%H_000McNliru-wGE1BMEP}ychrg0(D75
zK~#9!?VHWD;xG(GCFikV{|ZP2riW>OT4`W<h%2Cg=|QuYfx|%H#LAzNx!DmCd@aTH
z7kyYw#AL6>yUtC~=@hx+zySvwaKHgKA>83`kd%_BYOLNgO(Uv$2b*)@|Eg9YW@7fI
zT~!q^i<8!-Y2<i3E|OA3Y%-Mq2i(82LR2{Q0+LqX{EJBZ$XQf4SM*RNj8@=)0}eRg
zfCCP=`Q9lbi_NMR-JiegMR))BRui+=-_ic_HATm_WmlW2oZ9!h?|{FSf*Jz+44Kvj
z`_z7l0@lY7f1ZmHwdd%uLIAfo+~blIZBSIZhUfEHuGj1Rb0;FF)9K~9=ksmb%H?vI
zH?5CgbKjSY0kKE1S-W&SKm1)OcFOrhkoBGKx{gU0IN(YtG5yvXm<N!w0_Qn$&hh<L
z4`hl8hAKgoYyz%rTUSG#`*d^>N9)S2Rgnw#U*CJ*lmP+UI&jej#f@hhX^j%SM~?LF
zi?zW-dhDh9K8FR%|AW1+Pd7{fT$3IAR&V6+TZaPUw@w9!-|CGXdJee7;UfF3q}2_F
z-|E$KyQ*vs6_t}znHa6W?Ga9$rG&H;m<N!w0_W6a@%>g0WQq!gDq*w&w<$RMR-QTF
zp5X9X$D|d%wE|28zjYYM_QYn*#rUnC;P6`qMiswx)bfSjir571FWj#7x87#*oU@1w
z+uvGBam@&64A{^k=j;-))qZO&*qHn9Tm5kCB=ITlrQvKh0|K};_P1&c*wXu3jc4w^
zg=2r~8qq_QY(<sK3s*|<E@AV-nOSv1-nTFIw|d`=SzCcy1rEP;Oj_|<E5JnXTZe)4
a9lrrbPks?nI<uMp0000<MNUMnLSTY)>Sd1r

diff --git a/Templates/BaseGame/game/data/UI/images/selector-button-dark.png b/Templates/BaseGame/game/data/UI/images/selector-button-dark.png
deleted file mode 100644
index 84ee7e6f30f4eef5b3d2a1440495b16cf3b21f65..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1942
zcmV;H2Wj|;P)<h;3K|Lk000e1NJLTq001Wd006)U1^@s6hvIq<00009a7bBm000XU
z000XU0RWnu7ytkO2XskIMF-ys783*<eshr8000LyNkl<Zc-rloy>8q_5Xb+!B=4lN
z?AVBUt4(v4I!KilFko1<Um-{rz^P&&UEo)6Z6k?aAZ2=8lh)}S*s=9-U*x3F?rAif
z<>|=NMX_fAf_Dp%{Bd??cV_-NM*!htZK;>r#7p~|{Ne^@a0X{^24`@3%UfLYq9}?%
zS(YUc0Ym`s8-N8a_S1ei{}Rq+I3HfC<+3chy;v+JM05_f+~+~;ekD7XTeDn%ssL2Z
zxhhz$1mFNv3>Kk}wg#7F*-pRT_mjzF#;)&&Vf6rJ0E*DR3t%4pZfy&?n;dMqHVz?z
z%0~|PmCZY1{V&C}hu7_`jiWAJdb@Kj9jyal-Z`be6=WMY&xbFxN&)I@xi&jQr99BB
zuqbT{&MDVki^uy8^Q+pB_g}k1IPuy2SC&gzlOL4`0Ja8~t?{?>ZNrsozDUt_nDdS=
zR^2qqX$!CKF!Y~xRPs`B-_B8qzrjY>*dlxjz?6MoBzBdp!SRUW6gP41TG`d$49?&T
z&fpC0BMmlxe?v~jK;P`U3Pkl0aC*OU?#jkUhD=1{5-;MEzN{hpqRY3XT5%@@oUed#
z0!n_4-;0Kqzf@GzKF4QD$UFhYAMDvV_Iq{)fSwY7#{P;`0c1s>V%HE6IS!aNfN>BG
zlZn1qcF>B3JqA;SguD_tZ*ABkV6Mz73FR3SKRlajg9O|z11iN4pHm@Ge9RM8O9AEK
zC|F-ia5T69gPDiKCrScRK&hnl@`N{f1t>!G!nt5@x7myF34e=$<v7<UJnFS$?kLN7
zE8*lYN~m6#UwzgG0C&W0Q?dS8fSW3F6^aK}8XVu!I9$Pi`e7dR0qiiiyX>K)z)ixv
zG&m9-U0X`z62XVG$6$8DQ0+2E0Js<aKEjm@dK&I=CYC4?o*cb+IkY+3lAM@td^r0I
zY%iQ|1z-T!7rR8speJH}LV@DTjEhd1E6$)<Z3*_^!GrH#zkdB!e994k(P;FgoExG4
z>-hcP;NbqNSFe6j;G)-N?4`~vr_43aDw2g5(mf8gP7BxV1%QQe@aI<mkW+mT=F3PN
z)(AJ~7zGWO_s-anX<qCb7T=s%ueU+CU9nc?%9iMEey|y~uDIC7`4zqKc32MX0{9%j
z{%AD%;?l$)j~|VO!&+ri>pwa=`V+t#0Dl8`7mg1APQoz>OV0wp!YiA;w$^dy=+gSi
zaAxAU4kAWNMI>@rDLTT%`J0RA#w!7=^NGA7wfXlt!u8m_GU27JDK&J7NLPkTU0SZh
zgf3yZTHfj!U^8?VKQwE(R5s`vGAh@Qb!{RYb*r*Euf_2z&Ksz4ue?8L!%9j3NMeKT
z(n=P6$ds{W0N(&ZN@B9;2)7XT)6zz2D&%O^ijl*tBixMLOS58aDWQbrBwUOpy0ke1
z<Zznh$R{jD0&LEblrC+`?!^H~v*7<CD$&C7L5N)U0DKnmfqSFT=&KG<$sYjThT|Uq
z$Kf~)3DA@ed!ERI<Z#Zy#a*M42r*NJSI)iKUManF&hpM;0~>#Yn=nA>wdy)2(=_e`
zlW^1HgM)+nZK%R^#|(};M=73vY0haWp-iR+YToMHGY~zg<*m*=1<|(wBu2W&;e09}
zXUY;oxpR(}LP^XypC}<j%f>nQCXw;K4G%vH$BCHua?UO18?Q2Puvnhr)gW0yh;y;W
zAhcS^J2q#h3~Z`dYL!FqQfQedxKwP%=rIVb%Jg1TnfMTDo|-IJ^EY-%1R~*zV37!+
z)#u&|=bDKk;zDr-O2Ij;6qQ&5XUqvcBr2OHiOOb~h)(KdSK$;;YP6LC$7{kT3AodS
znsB99jCjdEZwNN4M8K(4(@zs{XNhV$C87~shfu5sVM)&(Aa#goLWh`LL5F~5wVLIW
zHBbJheoDcaH3XL{6`YjJl&6F<0l7;1nm2^yP07=G+E>E`s;DN)tSkH1Q4LLRZEHEx
zTVZ;u>8+->E}>0tHN6!dt=@`@->mZXG_gZG6W<>ua+1yHtsMgm(_6d1eWH3RfFDHk
z7=QGQEA;;e(_7m$(_7m%(_1%@j+)-OPBXo=Z8N>KZTp1vRscVDh)TYL>8;)1uB5l-
zB1@NgYaUF^BZ)3;Exk2Ywh*~|$SnP#$XlNQc%tO3PXVO#*4q4HUc2Nmy%nann%-)9
zD*)45FV9I$!7;tH=>pSRQyKosW_oKAoawEmx0>Es_eRrO6)+wRncix8YXrOFoO?bT
z4qpIQ`+e(pJU%3%#|=4&s<(P&t~Khd9PFxXI2^uk&OHw=w;S%)7hcbwe-5;+-nuRr
z2gHS>xx<zusZFRlgz2qqDx3EER+!$}zM0<Iwwd1ArJ3H^rkUQ_wwd0#)u_aN--<Q$
zR-X_<G`;l<!0C8AK5Ro3uDjmfw-V9gbpcuSWxsDVz18$qnBHo7t1{<IZ%rsTDVfRi
c*0!qQzoi};?Rr-cr~m)}07*qoM6N<$f+^&!)&Kwi

diff --git a/Templates/BaseGame/game/data/UI/images/selector-button-highlight-only.png b/Templates/BaseGame/game/data/UI/images/selector-button-highlight-only.png
deleted file mode 100644
index 77e01fc741fbc30a882dd268ebb9c5da313f87a7..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1613
zcmV-T2D15yP)<h;3K|Lk000e1NJLTq001Wd006)U1^@s6hvIq<00006VoOIv0RI60
z0RN!9r;`8x010qNS#tmY3ljhU3ljkVnw%H_000McNliru-wGEHA_n?3Gq?Z%1=>kO
zK~#9!?V7!A+(r<9XZH4_lO1;{)3^%U9NUyeo*@X}D)2KHd5XZ#5Tr7Y<QWW?ZgpMy
zl<6Err#q69BD>PuaArv!Y5A<o0t-o$$on{dJ3m4K_zfQFvR-bEmky`=;tuC<4(D(V
z=Wq_^aHp}*lTEidhjTcGb2x`{IL}HvD{+T#IEQmMhjTcGb2v{nJ=xS&G(VIGJ7Pwp
z$uBeFxpBbF$i6l+**V<_`0g_$WGH~4*kMK|l+RWL6AR*%qHbpKK*W7X<wS&;<D^1~
zs#eWNKWPL=Jbprq)vlkdQzaMYiu^NrY~yNmI8Qb|w`9|8&fy%+;T+E49L}>6&q^H5
z;T+E49PX6iZoBES&5wxfy&r{Q9uXK#sm*_XnF!+u)-Ue6!_Maqrp+ND<v+?pi~E*X
z$L5Cou?mVf>iU=#?@1?{qg3|xuRBTP*Z=lQ{1u44S0txiA0xR@^H$}BuqR#y;raA2
z=dJu2|9R09<SA_wf-lZnV*v~e>1eak$bLuS`6M;~K-(=jy5S@iz&Ml~3d`Z}vd3)N
z1kf@Gl7Q?0M#H8o7`{2+nNTya>l}=4Qck0;TA9=|FuoUT2L`t?;LaIL!!|OhwOzCS
zPkOQ7krF7Rmx<};$lxvvn_Hz1uM<?w!1!3c)z0&%sMC^E23w}RVE11blDkMi5dik=
zGipO9Ex*5Ha~y8Tz|I(8zW*`1j}*AQ;#gpW8B=na@n?yhrG3u6UoyC$c;Vv&wo5OG
zBGwTL)cN~c6-Ry~2}r5R47N)9oWVU2p+&+)@q1EsD`Rd{0&Wm+66{CC6kZrM^iur%
zlLD8$IWRy3fCFz01$)bCTun?gRwC9l=`$Mf*$n_dBs+uzL#<QRxd<yUedU3@b1-AU
zQy0u3=72k6v69D7l;`<rC!6W$3e3Ki%=j+=;8F6rCux5t({Uiu@_g<3?*Q;2?JEHI
z2LP@CU<&{@$+P!K?QJkpBs5Nm<wRjDjq@3`yfF;ONO)LTOoZdl2~hZ7IxD>{ow0F-
z4uh0h(7+^|CRz=0s^o$aI#5ghLr-O<sd#GRsHn<PoU;m=(PiX_a?~oI4yq&2Dx;6k
z+_9e9VF*1B(GKV-i`NgbA}clzNqGxW4(chZ=_zs!U_(J-tx}xS6X9z1tX7d^vF&Q9
zvSAOND!E#~nJNy3VUkhO?I*(R#q%`D(dW?uV_8Wk)C)N?`2qlbn2?qH0sw!rjAY9)
zl3kK)oh2FyDs6-#?9xM~tPD{r>g}jDDh|QDsAhHN90$LYP;G>kPTksyx|2IWnCWcY
zCb*q&j#euXdAB?m^(wc)ZrzIb5{TY(>Q=-TK=gBhxDocnCCH`7Js2V)%2p_soRvLf
zmFLX(gHiEcv5J3ZsI}2lD!WX?RLj5CN(+IPb{RtJm0U5K-4C$01IXBOd^N`D(Hd|v
zpkFiTXew+<$5&Jy*bc~28rIgz5L$okTItW#!r{y_HWol+zc#Sz3s$LT2u*TZ;}~p9
zA>;s#IRzD(d89Z?U=SMIO;1l)J@`uvYb`70UZ{1`cZLRbMmJr?w6e{KkV1;|f(X_;
zyzC8|t9#}U-AqKAL-YVjN0D)_E+m(lWYjvPIKkn6pg@u$9b`$QRWtNXzz5I1N;fD@
z(-(f)p&)ub=kwO%B<J&1@Oi7xTg99Cyw&HeK5u=X^VUa*_-?&kzXAZb1c0ilo=TOZ
z>(2lHHk-|BB6?n^<kWd<5Jye#yp@9uUF-Gw6(YV%FUL(nn;PCSg|YM2v0xmK+3S)$
zTN|3Fa|oZe9@E(zG;gh{>Z=38-)z3A*6a5jhfuCxUS9qQK5sp4`Mh<C<b2*bS2^nQ
z)*;L1t;a5(w;sFx$Me>zs=l6(mHYt@W!@T$;fOYG-2uSOX0v&H3{|>s)Vwt)Edg!b
znx}qSB6>a+kX2tkZ}oYr&s)Lgtv+v6Y|iJcJ#~uDTMcO!LA3QRjk*e}kFbyE00000
LNkvXXu0mjfl=J=<

diff --git a/Templates/BaseGame/game/data/UI/images/selector-button.png b/Templates/BaseGame/game/data/UI/images/selector-button.png
deleted file mode 100644
index cd0780068892795e6329d713f48e84fa9f1df8d8..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 4002
zcmV;T4_)wyP)<h;3K|Lk000e1NJLTq001Wd006)U1^@s6hvIq<0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU>L`g(JRCwC#TwSbPMHOB%XP?{K+frI-
z3jKpZBw}L3h<XzquwbwW4?g&$)I=V7;lUpo37QxU5Qz^GOhI4p66C=mF@^^oOn?Lm
zCe;EOH6~(eO4C9M*xF0!{XKinxYqpav-X^seSU7*+%|i|boQOQXXe}ATC--YHRm3o
z0r3Bod1aurSk?$a=;#=!_8~3_EBI=_HQ*X>4Y&qe11`0<j&My)P2Gjn16X!U+n;-!
z2iATR%R|%C(@zgQk=A;svS-hpyPkULDShO~5p6CrMC5Yq^c+1;{f3=u6tO<AbLURj
zwsi~4&&`?!s>9;j={b7dF@4^3ZpXFPUJH4i5A-lSN6%Bgp}nz{>}*Qo5DrnM_Us{T
zg8A8VrWo<LdtP`uJ@5JrHCHz3TN#y)+^3#t?A(Q9E*rh8PTa!)?dP4j_<ib`My&o)
zN=5He&os<k6wIw?a0Q#VNPs9VW#%qTujKf#W2VsM?|I?vqk1KyZ2U*xe*0}$Gcf_$
ziH+*8_;z}Zo_DdtdDppz4jee}YjVAvhYMF<b4~O?YA0a$yy-W*&W&IwE78}JPg;?M
z(O0*9<mgK**NQi3*9Kezt^wD8Yrr+&E*@udMW440?9aV&8ln^3n)uzVb$zZFOj_9p
zfW#2GD`J@)K5iY*Y(P*Va-V9`5zsLJ6`(PYvJWs36v=AI`nOz>>>h&Wcz<4!Qj&du
zr2t9>1Oia40CWg21eOGt_0biPC^8Uh*2j*L$ds!!^kyDKO!P8>x*ua)d>LaXW2MDF
zw}O7P4087Bn5)w>-bPouX2B`<oN|3sz$T;?O;!V{PS3&xkp*Jb0XP*gD=J}@bVaN+
z_Dn{Ac@ef5W9>-c?OCu`LJ34IM%G89A_1%wn2fOma|Emi%|>J~h?r=z2q@?SEPLjW
zhrV{^gZJ)LN^PTU>KFIjb2zqrVfzs&<vSZTUG><V_doD#0vunh6_6(4cQmF}WflPY
z`i&po@yM>*z6jS}w}UqLcuwE7A3kyvUU>Oc`1^m3-j4u(i@(WTDO|1Gz2fGEc8qKQ
zkqXY<%zr=FyX)?6!i$GHaNqA=gXgjFD?fX!2b*u-b>n8B7kTwhukXdC-?3HdSFsM}
z)We#RlFg#Xw-RFn?1y(w0{j4M9bT^er_UUMZ|%ATsGoa5#l}-L`gjpIn@;CKli_uZ
zn};z}@_#?~^b<y84}N13KD%`s{`P*+Gw^4wY{6gOU4RFFa|oXQ{w?s;yY7MSJo>~Z
z@K;M%I;<2-2feseOy^RoRs=@Z+6h^$!z<Dr+rA(r+KjE#LG`ZNSyt<w!PDSk04sAN
zu7MUr2(r9deZaNi;8J75pnGebh`W=EYTW})45Tutxd#q#L>;&!b7HV@mK}Z7O+Ey3
z=O;8=$>3t{b*b>J!52hyoI%0G{Cl1F9mqb+Ns$ECZ?0PAbfTzbidEH&-TQJbnALp%
zDpq=!k$4l91am5MjZ$-`wyzlVx(?hBVod>yg1l(Fl9*f0<5A<8kn8Qel4rj=2@|Ww
zVQzk*XJFs{wZ|)7$#u*d;T~}jdc!HP*6CZ(YGv=D>%EmcTr)8?QXTVzshyr9SDpHW
zZc)DlaZ$w(5HKcKZ9+VXq7Wb)IQVB1eLaVbB(m`G?LqWaM1ZLDg6J{_iS$FOE^fVb
zqd4-)DSdqyw_^KYY`-qhsXPFf0t$7^LCWwZez%kesyhrskzg*Vcd{n+87>ADFyL1m
z1TjIZJ&yq60HZnMER{rwfQ+^Itv&U*+&mDOs$p%Yy)~8%(g85V7>bEC4|GW-5{bI@
z1c!-MCpLc-C~?6UE0~G!B7`91>!)ivRIxhdL?S&ZBH5ul!JMiQT@SF@gmthm`Z1^&
zLn^Wwq0f%c11wyavd`&C3|P#C3T;=BaFLR_7PA;x-SH1I&brT{Nr^}Gvj#(-;KVxi
z0jdUA^+TV1t>}*nT{`EjJnQb?=(deQy?jddEG*tGMi6PO&Uqj@cI2c>fc6<(X4R_-
zr%iZa70340FQ4w(PtgZ(76YZj+=ecJ2&N9@&nj_(gU@8tl>nOmT(kMv{A0}t0TvOE
zSppabCEY~QgEIHp)nwGPIfsC7SD|)6*o6V41h<#=?dW&Hk_?*Wk8WQfFs)sU07_sQ
zB(l^pZMu8<l51EM+rAuV4@_Z)0x443Mvd-+o%nlEcB%l(0tM&5qzA@8wQyu#n>OQ;
zD45U;oMQ-<G^{2-(t;}xWr1%?KNpTM!liJ0#Q|2B<8C?!W&j}=R%gftm9}#2)M-J%
znkYB~ZNMQYTp1mFIG02;B?Yu$vGDXWfF*m?<0V}xI|r62-35gr9CNh+NFC-1xJ=vr
z!s(Y8X`z5M1S}(90y3<Zu$Bapo+Ji{Qt4kvyAgniRd-h)7iGzma-gW72v?!FR^`gJ
zQODT=)+zSacL+%Nb^?@1=-|p&M5`y+!ZL`YUCx@B7o{O|)4R5-)G_6Nbu1VIYEi-J
zCAwEI-f`g0c3{1-^O$H=I%PkH;MxdoOe2XB$D(JDIeb90{R$$cb$3Pc<GGC6E&o<t
zq{NzG%mN!nF|8*3!m^s~m+UHq4|CXH^v{V^I+y8e4(o}r@s?4Ad85xQFuV$B*&;wF
zTGg_QN!MmXn*}keF&AbvLRZHK1c8}HV5nbf=L=J>A@&@&jRo5!P_GKd=!P)~3#6Y#
z%dB$ufMv^=7h!8{7f2be5Uz}GP1>=h7;B_sB+3N`>|74({`b=U+dFT)eg`bhZ7}^F
zpL$qE{G_>kQ~TytO`Ms%;R}EG*zLPtDjBfsDr8TYRcq~E%hb%63*4N&am^fCBm&YY
z(k;UlGPM?!`?8O6xct<M`*(eQ&C>4jv*~?uCH}MNZ_JME-}vR-FI<+vhih8!(drhQ
zLnAng%+6CmWQ$mqq%$|fVy3H`p#`cfdn69jw=rbS=o^BZAjWpyx7R#==+GgUbai<7
z_D!2MnZIv6_~^bn=D)Q2kF-F@v{0SXy+(7WO>Wy-l&&!@O-W^|Vq&G0+U{6@B-#lQ
zB{4=5Z{EDw4CL$ZqV|&~Pr~FRLdAa6f0cqoEDIe8?KbJ6wFoV<irM}xR=l%G4x!ei
zzO6!*#&LD7S+FaT^lUwugqa+!nCZaA_AjS?JUu;anA^U68*JIS4c>q6WY54?UbPuc
zy!#FuKmLwkZfa@@I^UlD$@(^&TA#t`bs5Z{{>@CF{-LRvMUykz#+6OF=X5U50+(Gl
zBWzY}Vf8L^qBX{tJ8n`+cNh{sC6PgU$G*H#mE3NJe%}^Otd(=IjGGa^(v{Uavr81v
zH7kXxI+fDx)G`H5R3m^wm3wnmSX=77oARiWIS|2L1~ZSBIuyEV^E|*9Gjc%YN?>jg
zIOfVlQ2As@u(x`#+FinVx~dD%>>5>5CMtEWsS{yvoB0=ZexaSm?n;7rHp#=_u9sqU
z&x+aY9Lr(O`+#md?rn!bRCVL$4D!f|brvaR24yZbUO5kA%>ORyNgIgLuj0{CG_~O8
zPGC#5SH>&n5xu#WXxi0xb{n+Wq`kWx(Sn*&aS@({6+WhrZhQt7(rH)g^cfeMHeKPI
zKQo|>0cg-XMvWMdI_lqY<54kDnQ-%U<5?Zg&xw*|!&a*cj0Vlg<zCiyWMc?37JFgE
z1MQGGF8dM~Ie{dC7Fcj*U|FW{-MjQz5W#HJzXS+Q#CD!CsmOI*28yaZ)zX5Z$SH4=
zizAJjv$!1QsJ|PBK<19QLiA<?E`k)8^Ge8C8!tGwoAYY)-zLxtUh7=*%h5C0K!MD{
zzNw#kujG?A+yLv=uZOcUGd%<Q_J6(gR_T?D@16eM<r$nokL1i+^oS>{H+*iDggIn%
zK6Bo%uwF@#d41D7ry)u`>o}1v;Q;gF5(6EK3DEW4Kpw7{82eKl^Mt9Lo-=>niv6(v
z9F0TcInj3f;_!2Gy~`?TA#XmMO{2~k0mHZxHJDtTF$z{NCNMFC@o)*q<YZJV)b3-5
zHul4~VGez_c?7sX<I?!0SrImN<rXq4O^6HCT(P+g0U5=e6c8J40>e9sqTYCEzljOR
z^>*JP)B~(+N5<MN`XVuo+kj?a%!-ia=(wn>oZl~U8-3YL*k_N(*CN-(goVh~_@WJ>
zCt`8yW1kZH?*51VQ5d)W>eJ%kd;h8T5)cG6i>%E$9h*h=tat@1poop0Vdo`eFn3`h
zfz=shb66_WT5Fr8qNQ&0CRm$D-O=q#Ovgw3sN|<&5&yb2oN*C9=_?fiHcxHN-gS&i
z4rM^CV~4?B2~A2s+FY8=1`(^$rVvb|j+3`sXy<b!v;t$f5{eT{u7t#h3=vxfm@L8N
zE)7<&B%|)#_(kczD3_ix2|n#Uvq8BH(o46k<tFZQ;E<u2Se9vR3(oQ^Q`>=}BJE<x
zeYUgAbcUX=!=**{Bu1Dw(&c^&<(o+ary)mKP=3yQpadiMv$6afwX^)3-@3f{@R5CW
zF)%MBtH%3g0&h-iVox&@BW!L1l|MI;y31@*co)lTQpi`yY%)NOF<bk+RaD)k%qyQ?
z6fVV~{Kq4-%bzJxF*7;O36rA7z@eVa`ORHG=_VCiln$5@qPiF=%n6n(W&pK&Bi-tz
zsakH)l-YFDrMXx(9rbL!v;Zud&NJ-5oX)`U?1Ce-F5O=O^amR*6)N2%1<Pqjx6LfZ
z&LP}B*>euzb(<O75?JyWJpgEQuuO%zqjPV(wdh9Yt%MWm+I8RxamSM9g6mIkA_u|7
zA#f|Ua`q)y<Rqc$gfdmhSpd^>Xgu`USIz03_JF;{i*Be;BtnQ{Ij4rr-?xr>HGfmx
zfNQ`t;2LlZxQh_nsNW}i1y)<g*>#cqO^Jw~+R3LoF+DwfdgyI?*pH|Yu$ynbc?Uah
zeG@nM&qX$V)9!O62M-=RIxN6Z#JXj~?-Sl~A#`qR#P1Ux8(yp{*x4NAJFIWQ`lh+r
zbEeSC`Fmb?J3a6E4K-KueZm*i&Rr<xn(q^C#LBPc`-Cq^=9=#lUdhZ|S}8Dcz3II5
z`0?ZB=j~Tt{pRsw$9g<r-oAbNc5_IF{r+;kH~ys&zfXASLg?HHj0tv(@O{E3&O0~?
zQb<G?u<+;$644i2(C8}?Wi@Hn23!NK0oQ<Qz%}5y*Z&0=0I^#_V^#$C>i_@%07*qo
IM6N<$f{4Jk(*OVf

diff --git a/Templates/BaseGame/game/data/UI/images/separator-h.png b/Templates/BaseGame/game/data/UI/images/separator-h.png
deleted file mode 100644
index 339c0fbe039e8b5cbdd085230594099c26928157..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 117
zcmeAS@N?(olHy`uVBq!ia0vp^Oh7Ed0V0oZ{G0)#BuiW)N`mv#O3D+9QW+dm@{>{(
zJaZG%Q-e|yQz{EjrrH1%iF>*@hE&{2%E-w0@&CWQFtY@YFPFjrhT;U4EtAg|X#kZl
Nc)I$ztaD0e0sy9+AwB>A

diff --git a/Templates/BaseGame/game/data/UI/images/separator-v.png b/Templates/BaseGame/game/data/UI/images/separator-v.png
deleted file mode 100644
index 6a0f873612cef214add9a2f88ed72dbafe92174c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 118
zcmeAS@N?(olHy`uVBq!ia0vp^GC<74!2~3aY}VEQQj#UE5hcO-X(i=}MX3yqDfvmM
z3ZA)%>8U}fi7AzZCsS>JiX=Q;978H@CFNvfBrGsX`1Ak2{Z(F84g-d-`&k-}TiGQ5
P)i8Lv`njxgN@xNAx)CBs

diff --git a/Templates/BaseGame/game/data/UI/images/slider - Copy.png b/Templates/BaseGame/game/data/UI/images/slider - Copy.png
deleted file mode 100644
index 92fee1e9c13401f0b9fb319b14ebd267b7c1c8a0..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 908
zcmV;719SX|P)<h;3K|Lk000e1NJLTq000*N000~a1^@s6itQw00000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU#E=fc|RCwC7R!e9TK^UG%cGD%zt0ir6
zsaNrFDt#Q(y0z7`P+D41JXo}cDhPr%L7`ADk+z45heAW4^&q~Z(vt^?MKFD!fqD?c
zi_p}1XdX?IeP;b<V;;NNKpWa0W@q-F@Bj9nZ)g5pjB5l19g^WkvoAG{JGTdv>BsNz
zeu<3YC~{d@T`O@7=<fGw#kgCeSJ7JJM~<9WTWgEjKYdah@5hYds0vFw7|mCf!!GE9
z&{*PV?`THLOJDa*q>Bqd8zh+r&1N$TtpK!GELCNikCSDYg%%{_tjFWkfZXnes>n;@
zqR|aj)!gZHXh8b=y;^A;kRu8#6pO{!Mvtd3L02hDKJM?<79kE%E?3>4B+0?(MwHD#
znh=bupw`5N2ruq9KZs6u_7))i@#~}<;40XaEJtI*eV$Cj55Bf2ineZ<81cX|$A?-K
ziRQ$vUFqvirBbh8IBB!lrWT$p@_Epw4{y{Jk<89s7(yreE_ZXgJAlQLOs#F|`{D~e
zk1JU{!ht}*1pQDv9-m=Z)*TLqIgIfHJjnm+Zki*YSv0N&+<5q!9OI!(a(m|ZDWCi2
z+7hQAJOK~#FZBQBsFq0$xe508a5Ng7>+0%qd%a%d^ZA(i`uZ`3VWtE40bY>a7M7V#
zB!+jkHs_9=>37>2j-V5r7a4n<XN+d-({$@p*?Th8SS<6sJv|PW(}_euKor!N_O>=;
z!uTf4JA}`P;v1uD=Z~Jd<ghpz5f8~JW(GAiccLt&RIHwy+D)gC&2C3L5En>b2XVYA
zW9_{!_Y>&<@ydWoCaW7|c%=l304u9lXbBBDP18sKV$fMbp11YLDqKf%e#(kCvbjnH
z0IY2MSwNH|Nr;Cm_2f`8%fP&(pfq1j&P&EykrGAGkevASCV(r$>yDU`^BZRlB!U6C
zWJs>$^wwoAh)RXbi7W=16Mq@GgpA26$sz+uY<nBQsVr&>E0GPzMbJE%h#`yBRq)9|
zM)ez$XR{;UB9VaZPe36jlnmZKpDj2gSsD4W{t>WPgB5pU{)$x*B(ajOltDF2!h9-!
iq)BbrE0*;C1Q-Ck2#=cQD4UW10000<MNUMnLSTX>1gDw+

diff --git a/Templates/BaseGame/game/data/UI/images/slider-w-box.png b/Templates/BaseGame/game/data/UI/images/slider-w-box.png
deleted file mode 100644
index d9ef04961a30ad99f1e8871ef1f292b8a58d99f0..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 982
zcmV;{11bE8P)<h;3K|Lk000e1NJLTq000>P001Qj1^@s6w^2g10000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU#cu7P-RCwCFR!vM3K@@(oZI`u_7W)HS
z_z46E5)-2a4+bql1U-1bs3#7@MD)a635mu~6G-Gn0+OI7O^h)fNi@NO!AOt<2?u@-
z9*T%*X=%IvU1wGbyW4iRJ=m8_JMZl``|W!(^UWYsCMfWq4Q+02T9P!k*TKfx&%D0b
zIAV74Q(YCX9ALy)joJOZchpx&6vet?Mob}N^dtoU6${^z1Pb{oBc|v~N>Z->n@DC(
z^dn?hhVAVwNE{p-MuM=syre-K`>u)#Xl!f(o6S~Sxwf`8L6&6j`TR#QZC~prlSvid
z+}u(e$w530ZEfwknBO1B>68EU^)=Huvgcc$9*<iWGW8YnHBDtQ(Kffo13Td`IA~gJ
z#4>%OPjCcpe23-4*Ecl4pS?Z!vATK~Iiu<8eTHFFyaGybOBf*v0#((zSZ!Ussc*KV
zOSc(IBP*p4NV1{K&1b;)3K*lE;}RUd_RdRpkQHcQ{vA+^sH8cEioJZbKQB(*d>ETm
zuGaa}MSa=Fv8LiO$#h;y@AHDD?T@o!>D`6mNv2*6_aqXDx41j*a=9k%Ha_7s%C58F
zFXwu=WDCZkai-igF-SdCvFG!V4BWm>!3*e*>_?`8!JubxadCuYS^C-62cdY{%V|mO
zPrfEv*U!cyQ>QNWdN!6mk8mtUKTi&Y8cr}=J`yS#jShsv;o0u)ZhuWp4fOW*GG4ED
z6l>Dt*u#5hb>-U;I2DTx9PIAQwsqd{y8?C4-gT3yI9WaFU@BB>UKK8*>A7oteeO!E
zq@o~z9iMO)Iy!(tXb3;o>AT`6pKHBx%T2qhfX53+u`y74whPk8o`uzwE162EM<|a8
zw7SIcYMIM%i)G?$iUZ2&2bNcK>ca7I7FI{%a5zA~1PCEZ@l)(h;K<%ZdJU70*H7+D
zBuN4uf3=Z>TqcahOA4g;Y!Y6wSi+(x<|H9;qX{^~k}4v-QVOC4iG*J!<RFm_Nj|)p
z){rRw=EIPQASxD_kaFdi6B5tLM1tHTR^^iM%c7A8;9Y)Pdz_h^gG9u05|2fJc2*u=
z1O--&o0Fu|gWp$HX0#GRz7I=G$Ox8XW$@SPCyYfpteA|3OwSWi8eA$Txk?$Plvo@;
zPh{kqNPVH$To;KHQH??rm0%x*W>WFkKE!Y<#Qq8}0K%2(y+C}?TL1t607*qoM6N<$
Eg3Ob{L;wH)

diff --git a/Templates/BaseGame/game/data/UI/images/slider___Copy_image.asset.taml b/Templates/BaseGame/game/data/UI/images/slider___Copy_image.asset.taml
deleted file mode 100644
index 3a460e432..000000000
--- a/Templates/BaseGame/game/data/UI/images/slider___Copy_image.asset.taml
+++ /dev/null
@@ -1,8 +0,0 @@
-<ImageAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="slider___Copy_image"
-    imageFile="@assetFile=slider - Copy.png"
-    UseMips="true"
-    isHDRImage="false"
-    imageType="Albedo" />
diff --git a/Templates/BaseGame/game/data/UI/images/tab-border.png b/Templates/BaseGame/game/data/UI/images/tab-border.png
deleted file mode 100644
index 6703924d48fb96552fe11a91696f7c282aea3439..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1203
zcmV;k1WfyhP)<h;3K|Lk000e1NJLTq001fg001fo1^@s6#ly*40000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU$RY^oaRCwC#Sv_bJK@^@lu1FNL5y2vf
z2ud(1Qdy{IVekjRq_Py0JJX0pu!@kF6sdxu*u*=u6{|!sYKVp64_XN(5){NFU{qqQ
z-MZf--{sxg*}dJ(;t%-9GB<Pk=6&<#&3oTXa-K2%-`_8VQn5Jbw*yI(%9V=o^^)2e
z^z{Z(=vjNYVzKCz%jFyfmKLVX$LSY=7q_+VHk+E-R|j%A&v;&LpnFGkXlVRHK(D`R
z`!d3@_oh@Tc`yh)exJl%fuCPLxMABZEv=?$=f3JY3-6xV$?)7C9kE8G0N}BMd(8Yy
zC7^fae4puVZE$+2p1pe`z2?*0eAQl_E1P+E#{yZLo2{8}YIMksV?qeM$QB?k_MR}6
zzTlQ(yzTIDJHHh6cO5w$um{kvH8%UR#*PJw6?FFWo2@O)78F-|>s+T@)zO{{b^^V<
z=wH7wY(L{2P71F802ipY7kw@qE$vBN%q#5`<VsFnowDFy03IettUOGhhX)4mt^~<#
z(_W*VY$ZsSy}TX(SV$a@F2fpRQr$3n0if_G1zwfg5+(2kMTS8VT^$BBc~riPgCjj@
zjrm|XNth9CEj`IFfPQhf5~|0Lfj&cs8A032GjC~-%zqezXOU`{7iFHrxCALrF6IIV
z%&+q##$7Q<U2V?-MRGlL?Xh|DV{>37@CZ`H-O1-w@Umr|4D%f4*L^Nt+hhLK_6p2Z
z%jmzE=C=LL3e%yyDGwhjj6U6g3bP`N-;PET+g?oxjXD4|r+B4=CaKr15}L$b?q6b0
zh8~SA%A;{SQ}t+Cpt=UfVlxhaEO#3>tT*c#8_eR@?>5%(PLkvwCV9zbSc8!+a4ONV
zR-+KOJO_Zt7V|Std?$P6?aK-C`OA{+V;uY;3(0FXgFHquf);&@Yc?a<)A*xjHOZUF
z9OEwblp3gHGX%+c&yuRyjAl==LJ=%0nk$@AZ@u)S6zSP8LLos?q-QfZ^*VWDa!G<w
z1~ut$fkg?%Hd9biA&5~qzGjbV$|Z%d8zrQNIyJe**90`mV^QCy)k_7GY$i(Tv8OO`
zv8U8P$!59^?X@1jmLWFra6F1VAqPVbA%fV%gV-bqb`^_Mhbax431d$@d{GrGHBfqI
zmG0GHGinTAvH}!JFaEQqjCt%IWlu@$WzL=^Z(okZp0qvLy6k1jo|ul%MzJStPqQv*
zFH`me1N!1X-quCkJ%zEZ$h#*^Oe7(RVo&ns4;~~TLHJ<4dUsFU4gLE*ls&m#N^<uE
zQ1oOLKR@c;Ju&{^8T8{23jicY>;yi`d#otZB4azuR)9UhD?F)aac|0iuXn*Eh1*_F
zk5@SQ_F3yW*%QGMWE}P+4H9G+d(!r(D?=_|4>u*qe>cw_Sh<T|&WEzaIDugdWfv{_
z(0es8T74gV>R}v@)e(9wdwjG#i_h1~oIT;xGv>0sd%E<S{?D|g|4;oAU;sZF1oiaL
Ru7dyo002ovPDHLkV1gC9ElvOc

diff --git a/Templates/BaseGame/game/data/UI/scripts/controlsMenu.tscript b/Templates/BaseGame/game/data/UI/scripts/controlsMenu.tscript
index b88efa0d6..101148fbf 100644
--- a/Templates/BaseGame/game/data/UI/scripts/controlsMenu.tscript
+++ b/Templates/BaseGame/game/data/UI/scripts/controlsMenu.tscript
@@ -130,7 +130,7 @@ function fillRemapList()
 {
    %device = $remapListDevice;
    
-	OptionsMenuSettingsList.clearRows();
+	OptionsMenuSettingsList.clear();
 
    //build out our list of action maps
    %actionMapCount = ActionMapGroup.getCount();
@@ -158,7 +158,7 @@ function fillRemapList()
    if($activeRemapControlSet $= "")
       $activeRemapControlSet = getField(%actionMapList, 0);
    
-   OptionsMenuSettingsList.addOptionRow("Control Set", %actionMapList, false, "controlSetChanged", -1, -30, true, "Which keybind control set to edit", $activeRemapControlSet);
+   OptionsMenuSettingsList.addOptionRow("Control Set", "$activeRemapControlSet", %actionMapList, false, "controlSetChanged", true, "Which keybind control set to edit", $activeRemapControlSet);
 	
    for ( %i = 0; %i < $RemapCount; %i++ )
    {
@@ -173,7 +173,9 @@ function fillRemapList()
       %keyMap = buildFullMapString( %i, $RemapActionMap[%i], %device );
       %description = $RemapDescription[%i];
       
-      OptionsMenuSettingsList.addKeybindRow(getField(%keyMap, 0), getButtonBitmap(%device, getField(%keyMap, 1)), "doKeyRemap", -1, -15, true, %description);
+      %buttonImageAsset = getButtonBitmap(%device, getField(%keyMap, 1));
+      
+      OptionsMenuSettingsList.addKeybindRow(getField(%keyMap, 0), %buttonImageAsset, "doKeyRemap", true, %description);
    }
 
    //OptionsMenuSettingsList.refresh();
@@ -182,7 +184,7 @@ function fillRemapList()
 
 function controlSetChanged()
 {
-   $activeRemapControlSet = OptionsMenuSettingsList.getCurrentOption(0);
+   $activeRemapControlSet = OptionsMenuSettingsList.getCurrentOption();
    fillRemapList();
 }
 
@@ -194,6 +196,11 @@ function doKeyRemap( %rowIndex )
 	RemapDlg-->OptRemapText.setValue( "Re-bind \"" @ %name @ "\" to..." );
 	OptRemapInputCtrl.index = %rowIndex;
 	Canvas.pushDialog( RemapDlg );
+	
+	//Let the options menu know
+   %actionMap = $RemapActionMap[%rowIndex];
+   
+   OptionsMenu.onKeybindChanged(%actionMap, %name);
 }
 
 function ControlsMenuRebindButton::onClick(%this)
@@ -327,4 +334,4 @@ function redoMapping( %device, %actionMap, %action, %cmd, %oldIndex, %newIndex )
 	%actionMap.bind( %device, %action, %cmd );
 	
 	fillRemapList();
-}
\ No newline at end of file
+}
diff --git a/Templates/BaseGame/game/data/UI/scripts/cursors.tscript b/Templates/BaseGame/game/data/UI/scripts/cursors.tscript
index d8aa31eeb..ba81636f7 100644
--- a/Templates/BaseGame/game/data/UI/scripts/cursors.tscript
+++ b/Templates/BaseGame/game/data/UI/scripts/cursors.tscript
@@ -37,4 +37,4 @@ else
       renderOffset = "0 0";
       bitmapName = "data/ui/images/defaultCursor";
    };
-}
\ No newline at end of file
+}
diff --git a/Templates/BaseGame/game/data/UI/scripts/utility.tscript b/Templates/BaseGame/game/data/UI/scripts/utility.tscript
index 357a6a182..e73d1c080 100644
--- a/Templates/BaseGame/game/data/UI/scripts/utility.tscript
+++ b/Templates/BaseGame/game/data/UI/scripts/utility.tscript
@@ -10,117 +10,123 @@ function getButtonBitmap(%device, %button)
          %device = "Xbox";
    }
    
-   %path = "";
+   %assetId = "";
    if(%device $= "PS4")
    { 
-      %path = "data/ui/images/inputs/PS4/PS4_";
+      %assetId = "UI:PS4_";
       
       if(%button $= "A" || %button $= "btn_a")
-         %path = %path @ "Cross";
+         %assetId = %assetId @ "Cross";
       else if(%button $= "B" || %button $= "btn_b")
-         %path = %path @ "Circle";
+         %assetId = %assetId @ "Circle";
       else if(%button $= "X" || %button $= "btn_x")
-         %path = %path @ "Square";
+         %assetId = %assetId @ "Square";
       else if(%button $= "Y" || %button $= "btn_y")
-         %path = %path @ "Triangle";
+         %assetId = %assetId @ "Triangle";
       else if(%button $= "LB")
-         %path = %path @ "L1";
+         %assetId = %assetId @ "L1";
       else if(%button $= "LT")
-         %path = %path @ "L2";
+         %assetId = %assetId @ "L2";
       else if(%button $= "RB")
-         %path = %path @ "R1";
+         %assetId = %assetId @ "R1";
       else if(%button $= "RT")
-         %path = %path @ "R2";
+         %assetId = %assetId @ "R2";
       else if(%button $= "thumbrx" || %button $= "thumbry")
-         %path = %path @ "Right_Stick";
+         %assetId = %assetId @ "Right_Stick";
       else if(%button $= "thumblx" || %button $= "thumbly")
-         %path = %path @ "Left_Stick";
+         %assetId = %assetId @ "Left_Stick";
       else if(%button $= "start")
-         %path = %path @ "Options";
+         %assetId = %assetId @ "Options";
       else if(%button $= "back")
-         %path = %path @ "Share";   
+         %assetId = %assetId @ "Share";   
       else if(%button $= "dpadu")
-         %path = %path @ "Dpad_Up";  
+         %assetId = %assetId @ "Dpad_Up";  
       else if(%button $= "dpadd")
-         %path = %path @ "Dpad_Down";  
+         %assetId = %assetId @ "Dpad_Down";  
       else if(%button $= "dpadl")
-         %path = %path @ "Dpad_Left";  
+         %assetId = %assetId @ "Dpad_Left";  
       else if(%button $= "dpadr")
-         %path = %path @ "Dpad_Right";  
+         %assetId = %assetId @ "Dpad_Right";  
+      
+      %assetId = %assetId @ "_image";
    }
    else if(%device $= "Switch")
    {
-      %path = "data/ui/images/inputs/Switch/Switch_";
+      %assetId = "UI:Switch_";
       
       if(%button $= "A" || %button $= "btn_a")
-         %path = %path @ "B";
+         %assetId = %assetId @ "B";
       else if(%button $= "B" || %button $= "btn_b")
-         %path = %path @ "A";
+         %assetId = %assetId @ "A";
       else if(%button $= "X" || %button $= "btn_x")
-         %path = %path @ "Y";
+         %assetId = %assetId @ "Y";
       else if(%button $= "Y" || %button $= "btn_y")
-         %path = %path @ "X";
+         %assetId = %assetId @ "X";
       else if(%button $= "LB")
-         %path = %path @ "LB";
+         %assetId = %assetId @ "LB";
       else if(%button $= "LT")
-         %path = %path @ "LT";
+         %assetId = %assetId @ "LT";
       else if(%button $= "RB")
-         %path = %path @ "RB";
+         %assetId = %assetId @ "RB";
       else if(%button $= "RT")
-         %path = %path @ "RT";
+         %assetId = %assetId @ "RT";
       else if(%button $= "thumbrx" || %button $= "thumbry")
-         %path = %path @ "Right_Stick";
+         %assetId = %assetId @ "Right_Stick";
       else if(%button $= "thumblx" || %button $= "thumbly")
-         %path = %path @ "Left_Stick";
+         %assetId = %assetId @ "Left_Stick";
       else if(%button $= "start")
-         %path = %path @ "Plus";
+         %assetId = %assetId @ "Plus";
       else if(%button $= "back")
-         %path = %path @ "Minus";   
+         %assetId = %assetId @ "Minus";   
       else if(%button $= "dpadu")
-         %path = %path @ "Dpad_Up";  
+         %assetId = %assetId @ "Dpad_Up";  
       else if(%button $= "dpadd")
-         %path = %path @ "Dpad_Down";  
+         %assetId = %assetId @ "Dpad_Down";  
       else if(%button $= "dpadl")
-         %path = %path @ "Dpad_Left";  
+         %assetId = %assetId @ "Dpad_Left";  
       else if(%button $= "dpadr")
-         %path = %path @ "Dpad_Right"; 
+         %assetId = %assetId @ "Dpad_Right"; 
+         
+      %assetId = %assetId @ "_image";
    }
    else if(%device $= "Keyboard" || %device $= "Mouse")
    {
-      %pathBase = "data/ui/images/Inputs/Keyboard & Mouse/Keyboard_Black_";
-      %path = %pathBase @ %button @ ".png";
-      if(!isFile(%path))
-         %path = %pathBase @ "Blank";
+      %assetId = "UI:Keyboard_Black_" @ %button @ "_image";
    }
    else if(%device !$= "")
    {
-      %path = "data/ui/images/inputs/Xbox/Xbox_";
+      %assetId = "UI:Xbox_";
       
       if(%button $= "btn_a")
-         %path = %path @ "B";
+         %assetId = %assetId @ "B";
       else if(%button $= "btn_b")
-         %path = %path @ "A";
+         %assetId = %assetId @ "A";
       else if(%button $= "btn_x")
-         %path = %path @ "Y";
+         %assetId = %assetId @ "Y";
       else if(%button $= "btn_y")
-         %path = %path @ "X";
+         %assetId = %assetId @ "X";
       else if(%button $= "thumbrx" || %button $= "thumbry")
-         %path = %path @ "Right_Stick";
+         %assetId = %assetId @ "Right_Stick";
       else if(%button $= "thumblx" || %button $= "thumbly")
-         %path = %path @ "Left_Stick";
+         %assetId = %assetId @ "Left_Stick";
       else if(%button $= "start")
-         %path = %path @ "Menu";
+         %assetId = %assetId @ "Menu";
       else if(%button $= "back")
-         %path = %path @ "Windows";   
+         %assetId = %assetId @ "Windows";   
       else if(%button $= "dpadu")
-         %path = %path @ "Dpad_Up";  
+         %assetId = %assetId @ "Dpad_Up";  
       else if(%button $= "dpadd")
-         %path = %path @ "Dpad_Down";  
+         %assetId = %assetId @ "Dpad_Down";  
       else if(%button $= "dpadl")
-         %path = %path @ "Dpad_Left";  
+         %assetId = %assetId @ "Dpad_Left";  
       else if(%button $= "dpadr")
-         %path = %path @ "Dpad_Right"; 
+         %assetId = %assetId @ "Dpad_Right"; 
+         
+      %assetId = %assetId @ "_image";
    }
    
-   return %path;
-}
\ No newline at end of file
+   if(!AssetDatabase.isDeclaredAsset(%assetId))
+      %assetId = "UI:Keyboard_Black_Blank_image";
+   
+   return %assetId;
+}
diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
index 2e98c9b03..c149cf3f2 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
@@ -1743,7 +1743,9 @@ function beginGUIImport()
                DirectoryHandler::createFolder(0, filePath(%destinationPath));  
             }
 
-            if(!pathCopy(%file, %destinationPath, false))
+            //Check if we need to even copy in the first place. If we do, ensure
+            //the copy actually worked
+            if((makeRelativePath(%file) !$= %destinationPath) && !pathCopy(%file, %destinationPath, false))
             {
                projectImporterLog("ProjectImporter::beginGUIImport() - failed to copy GUI: " @ %file @
                   " to destination: " @ %destinationPath);
@@ -1779,9 +1781,9 @@ function processGUIntoAsset(%guiName, %file)
    %tamlpath = %assetPath @ %assetName @ ".asset.taml";
    
    %scriptFile = "";
-   if(isImportingFile(%filePath @ "/" @ %fileName @ ".tscript"))
+   if(isImportingFile(makeFullPath(%filePath @ "/" @ %fileName @ "." @ $TorqueScriptFileExtension)))
    {
-      %scriptFile = %fileName @ ".tscript";
+      %scriptFile = %fileName;
    }
    
    %asset = new GUIAsset()

From 938e4930ae1f49cb47f8b27d5bbe4d44637263b8 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Tue, 22 Feb 2022 23:28:28 -0600
Subject: [PATCH 316/399] Git didn't properly actually commit new files.

---
 .../gui/controls/guiGameSettingsCtrl.cpp      | 1121 +++++++++++++++++
 .../source/gui/controls/guiGameSettingsCtrl.h |  313 +++++
 .../game/data/UI/guis/NetGraphGui.asset.taml  |    4 +
 .../game/data/UI/images/Torque_3D_logo.png    |  Bin 0 -> 9063 bytes
 .../data/UI/images/Torque_3D_logo_alt.png     |  Bin 0 -> 11616 bytes
 .../UI/images/Torque_3D_logo_shortcut.png     |  Bin 0 -> 10728 bytes
 .../game/data/UI/images/Torque_3D_logo_w.png  |  Bin 0 -> 19328 bytes
 .../game/data/UI/images/backgrounddark.png    |  Bin 0 -> 5751 bytes
 .../UI/images/backgrounddark_image.asset.taml |    3 +
 .../game/data/UI/images/clearbtn_d.png        |  Bin 0 -> 593 bytes
 .../UI/images/clearbtn_d_image.asset.taml     |    3 +
 .../game/data/UI/images/clearbtn_h.png        |  Bin 0 -> 595 bytes
 .../UI/images/clearbtn_h_image.asset.taml     |    3 +
 .../game/data/UI/images/clearbtn_n.png        |  Bin 0 -> 377 bytes
 .../UI/images/clearbtn_n_image.asset.taml     |    3 +
 .../game/data/UI/images/collapsetoolbar_d.png |  Bin 0 -> 280 bytes
 .../images/collapsetoolbar_d_image.asset.taml |    3 +
 .../game/data/UI/images/collapsetoolbar_h.png |  Bin 0 -> 468 bytes
 .../images/collapsetoolbar_h_image.asset.taml |    3 +
 .../game/data/UI/images/collapsetoolbar_n.png |  Bin 0 -> 439 bytes
 .../images/collapsetoolbar_n_image.asset.taml |    3 +
 .../data/UI/images/dropdownbuttonarrow.png    |  Bin 0 -> 132 bytes
 .../dropdownbuttonarrow_image.asset.taml      |    3 +
 .../game/data/UI/images/dropdowntextEdit.png  |  Bin 0 -> 390 bytes
 .../images/dropdowntextEdit_image.asset.taml  |    3 +
 .../game/data/UI/images/expandtoolbar_d.png   |  Bin 0 -> 278 bytes
 .../images/expandtoolbar_d_image.asset.taml   |    3 +
 .../game/data/UI/images/expandtoolbar_h.png   |  Bin 0 -> 468 bytes
 .../images/expandtoolbar_h_image.asset.taml   |    3 +
 .../game/data/UI/images/expandtoolbar_n.png   |  Bin 0 -> 437 bytes
 .../images/expandtoolbar_n_image.asset.taml   |    3 +
 .../game/data/UI/images/groupborder.png       |  Bin 0 -> 1273 bytes
 .../UI/images/groupborder_image.asset.taml    |    3 +
 .../game/data/UI/images/inactiveoverlay.png   |  Bin 0 -> 131 bytes
 .../images/inactiveoverlay_image.asset.taml   |    3 +
 .../game/data/UI/images/menubutton.png        |  Bin 0 -> 3559 bytes
 .../UI/images/menubutton_image.asset.taml     |    3 +
 .../game/data/UI/images/nextOption_n.png      |  Bin 0 -> 8517 bytes
 .../UI/images/nextOption_n_image.asset.taml   |    8 +
 .../game/data/UI/images/nextbutton_d.png      |  Bin 0 -> 279 bytes
 .../UI/images/nextbutton_d_image.asset.taml   |    3 +
 .../game/data/UI/images/nextbutton_h.png      |  Bin 0 -> 549 bytes
 .../UI/images/nextbutton_h_image.asset.taml   |    3 +
 .../game/data/UI/images/nextbutton_n.png      |  Bin 0 -> 484 bytes
 .../UI/images/nextbutton_n_image.asset.taml   |    3 +
 .../game/data/UI/images/nopreview.png         |  Bin 0 -> 34615 bytes
 .../data/UI/images/nopreview_image.asset.taml |    3 +
 .../game/data/UI/images/previousOption_n.png  |  Bin 0 -> 8194 bytes
 .../images/previousOption_n_image.asset.taml  |    8 +
 .../game/data/UI/images/previousbutton_d.png  |  Bin 0 -> 290 bytes
 .../images/previousbutton_d_image.asset.taml  |    3 +
 .../game/data/UI/images/previousbutton_h.png  |  Bin 0 -> 561 bytes
 .../images/previousbutton_h_image.asset.taml  |    3 +
 .../game/data/UI/images/previousbutton_n.png  |  Bin 0 -> 494 bytes
 .../images/previousbutton_n_image.asset.taml  |    3 +
 .../game/data/UI/images/selectorbutton.png    |  Bin 0 -> 4002 bytes
 .../UI/images/selectorbutton_image.asset.taml |    3 +
 .../data/UI/images/selectorbuttonblank.png    |  Bin 0 -> 744 bytes
 .../selectorbuttonblank_image.asset.taml      |    3 +
 .../data/UI/images/selectorbuttondark.png     |  Bin 0 -> 1942 bytes
 .../selectorbuttondark_image.asset.taml       |    3 +
 .../UI/images/selectorbuttonhighlightonly.png |  Bin 0 -> 1613 bytes
 ...lectorbuttonhighlightonly_image.asset.taml |    3 +
 .../game/data/UI/images/separatorh.png        |  Bin 0 -> 117 bytes
 .../UI/images/separatorh_image.asset.taml     |    3 +
 .../game/data/UI/images/separatorv.png        |  Bin 0 -> 118 bytes
 .../UI/images/separatorv_image.asset.taml     |    3 +
 .../game/data/UI/images/sliderwbox.png        |  Bin 0 -> 982 bytes
 .../UI/images/sliderwbox_image.asset.taml     |    3 +
 .../game/data/UI/images/tabborder.png         |  Bin 0 -> 1203 bytes
 .../data/UI/images/tabborder_image.asset.taml |    3 +
 .../data/UI/scripts/menuInputHandling.tscript |  510 ++++++++
 72 files changed, 2054 insertions(+)
 create mode 100644 Engine/source/gui/controls/guiGameSettingsCtrl.cpp
 create mode 100644 Engine/source/gui/controls/guiGameSettingsCtrl.h
 create mode 100644 Templates/BaseGame/game/data/UI/guis/NetGraphGui.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/Torque_3D_logo.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/Torque_3D_logo_alt.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/Torque_3D_logo_shortcut.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/Torque_3D_logo_w.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/backgrounddark.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/backgrounddark_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/clearbtn_d.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/clearbtn_d_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/clearbtn_h.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/clearbtn_h_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/clearbtn_n.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/clearbtn_n_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/collapsetoolbar_d.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/collapsetoolbar_d_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/collapsetoolbar_h.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/collapsetoolbar_h_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/collapsetoolbar_n.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/collapsetoolbar_n_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/dropdownbuttonarrow.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/dropdownbuttonarrow_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/dropdowntextEdit.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/dropdowntextEdit_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/expandtoolbar_d.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/expandtoolbar_d_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/expandtoolbar_h.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/expandtoolbar_h_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/expandtoolbar_n.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/expandtoolbar_n_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/groupborder.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/groupborder_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/inactiveoverlay.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/inactiveoverlay_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/menubutton.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/menubutton_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/nextOption_n.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/nextOption_n_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/nextbutton_d.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/nextbutton_d_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/nextbutton_h.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/nextbutton_h_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/nextbutton_n.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/nextbutton_n_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/nopreview.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/nopreview_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/previousOption_n.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/previousOption_n_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/previousbutton_d.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/previousbutton_d_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/previousbutton_h.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/previousbutton_h_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/previousbutton_n.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/previousbutton_n_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/selectorbutton.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/selectorbutton_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/selectorbuttonblank.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/selectorbuttonblank_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/selectorbuttondark.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/selectorbuttondark_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/selectorbuttonhighlightonly.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/selectorbuttonhighlightonly_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/separatorh.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/separatorh_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/separatorv.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/separatorv_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/sliderwbox.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/sliderwbox_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/images/tabborder.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/tabborder_image.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/scripts/menuInputHandling.tscript

diff --git a/Engine/source/gui/controls/guiGameSettingsCtrl.cpp b/Engine/source/gui/controls/guiGameSettingsCtrl.cpp
new file mode 100644
index 000000000..1b6516e4a
--- /dev/null
+++ b/Engine/source/gui/controls/guiGameSettingsCtrl.cpp
@@ -0,0 +1,1121 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2012 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+
+#include "guiGameSettingsCtrl.h"
+
+#include "console/consoleTypes.h"
+#include "console/engineAPI.h"
+#include "gfx/gfxDrawUtil.h"
+#include "gui/containers/guiScrollCtrl.h"
+#include "core/strings/stringUnit.h"
+#include "gui/core/guiDefaultControlRender.h"
+
+//-----------------------------------------------------------------------------
+// GuiGameSettingsCtrl
+//-----------------------------------------------------------------------------
+
+GuiGameSettingsCtrl::GuiGameSettingsCtrl() :
+   mLabel(StringTable->EmptyString()),
+   mScriptCallback(StringTable->EmptyString()),
+   mTooltip(StringTable->EmptyString()),
+   mEnabled(true),
+   mSelected(false),
+   mSelectedOption(0),
+   mWrapOptions(false),
+   mMode(Mode::Default),
+   mValue(0),
+   mStepSize(1),
+   mRange(Point2F(0, 1)),
+   mCallbackOnInputs(false),
+   mConsumeKeyInputEvents(false),
+   mArrowSize(30),
+   mColumnSplit(250),
+   mRightPad(20)
+{
+   VECTOR_SET_ASSOCIATION(mOptions);
+
+   // initialize the control callbacks
+   mCallbackOnA = StringTable->EmptyString();
+   mCallbackOnB = mCallbackOnA;
+   mCallbackOnX = mCallbackOnA;
+   mCallbackOnY = mCallbackOnA;
+
+   INIT_ASSET(KeybindBitmap);
+   INIT_ASSET(PreviousBitmap);
+   INIT_ASSET(NextBitmap);
+}
+
+GuiGameSettingsCtrl::~GuiGameSettingsCtrl()
+{
+   mOptions.clear();
+}
+
+void GuiGameSettingsCtrl::onMouseMove(const GuiEvent& event)
+{
+   //check if we're inside an arrow/slider/etc and kick a highlight action
+   Parent::onMouseMove(event);
+}
+
+void GuiGameSettingsCtrl::onMouseUp(const GuiEvent& event)
+{
+   Parent::onMouseUp(event);
+
+   if (isEnabled())
+   {
+      if (mMode == Mode::Default)
+      {
+         activate();
+      }
+      else if (mMode == Mode::OptionList)
+      {
+         S32 xPos = globalToLocalCoord(event.mousePoint).x;
+         clickOption(xPos);
+      }
+      else if (mMode == Mode::Slider)
+      {
+         S32 xPos = globalToLocalCoord(event.mousePoint).x;
+         clickSlider(xPos);
+      }
+      else if (mMode == Mode::Keybind)
+      {
+         S32 xPos = globalToLocalCoord(event.mousePoint).x;
+         clickKeybind(xPos);
+      }
+   }
+}
+
+void GuiGameSettingsCtrl::onRender(Point2I offset, const RectI &updateRect)
+{
+   GFXDrawUtil* drawUtil = GFX->getDrawUtil();
+
+   F32 xScale = (float) getWidth();
+
+   S32 height = getHeight();
+
+   Point2I currentOffset = offset;
+   Point2I extent = getExtent();
+   Point2I textOffset(mProfile->mTextOffset.x * xScale, mProfile->mTextOffset.y);
+   Point2I textExtent(mColumnSplit, height);
+   Point2I iconExtent, iconOffset(0.0f, 0.0f);
+
+   bool highlight = mHighlighted;
+   bool depressed = mDepressed;
+
+   ColorI fontColor = mActive ? (highlight ? mProfile->mFontColorHL : mProfile->mFontColor) : mProfile->mFontColorNA;
+   ColorI fillColor = mActive ? (highlight ? mProfile->mFillColorHL : mProfile->mFillColor) : mProfile->mFillColorNA;
+   ColorI borderColor = mActive ? (highlight ? mProfile->mBorderColorHL : mProfile->mBorderColor) : mProfile->mBorderColorNA;
+
+   RectI boundsRect(offset, getExtent());
+
+   if (!mHasTheme)
+   {
+      if (mProfile->mBorder != 0)
+         renderFilledBorder(boundsRect, borderColor, fillColor, mProfile->mBorderThickness);
+      else
+         GFX->getDrawUtil()->drawRectFill(boundsRect, fillColor);
+   }
+   else
+   {
+      S32 indexMultiplier = 1;
+
+      if (!mActive)
+         indexMultiplier = 4;
+      else if (mDepressed || mStateOn)
+         indexMultiplier = 2;
+      else if (mHighlighted)
+         indexMultiplier = 3;
+
+      renderSizableBitmapBordersFilled(boundsRect, indexMultiplier, mProfile);
+   }
+
+   // render the text
+   drawUtil->setBitmapModulation(fontColor);
+   renderJustifiedText(currentOffset + textOffset, textExtent, mLabel);
+
+   if (mMode == Mode::OptionList)
+   {
+      onRenderListOption(currentOffset);
+   }
+   else if (mMode == Mode::Slider)
+   {
+      onRenderSliderOption(currentOffset);
+   }
+   else if (mMode == Mode::Keybind)
+   {
+      onRenderKeybindOption(currentOffset);
+   }
+
+   renderChildControls(offset, updateRect);
+}
+
+void GuiGameSettingsCtrl::onRenderListOption(Point2I currentOffset)
+{
+   F32 xScale = (float)getWidth();
+
+   S32 height = getHeight();
+
+   GFXDrawUtil* drawer = GFX->getDrawUtil();
+
+   Point2I arrowOffset;
+
+   S32 arrowOffsetY = 0;
+
+   bool hasOptions = (mOptions.size() > 0) && mSelectedOption > -1;
+   if (hasOptions)
+   {
+      if (mPreviousBitmapAsset.notNull())
+      {
+         // render the left arrow
+         bool arrowOnL = (isSelected() || isHighlighted()) && (mWrapOptions || (mSelectedOption > 0));
+         arrowOffset.x = currentOffset.x + mColumnSplit;
+         arrowOffset.y = currentOffset.y + arrowOffsetY;
+
+         drawer->clearBitmapModulation();
+         drawer->drawBitmapStretch(mPreviousBitmap, RectI(arrowOffset, Point2I(mArrowSize, mArrowSize)), GFXBitmapFlip_None, GFXTextureFilterLinear, false);
+      }
+      else
+      {
+         // render the left arrow
+         bool arrowOnL = (isSelected() || isHighlighted()) && (mWrapOptions || (mSelectedOption > 0));
+         arrowOffset.x = currentOffset.x + mColumnSplit;
+         arrowOffset.y = currentOffset.y + height/2;
+
+         drawer->clearBitmapModulation();
+
+         drawer->drawLine(arrowOffset, Point2I(arrowOffset.x + mArrowSize, currentOffset.y), ColorI::WHITE);
+         drawer->drawLine(arrowOffset, Point2I(arrowOffset.x + mArrowSize, currentOffset.y + height), ColorI::WHITE);
+      }
+
+      if (mNextBitmapAsset.notNull())
+      {
+         // render the right arrow
+         bool arrowOnR = (isSelected() || isHighlighted()) && (mWrapOptions || (mSelectedOption < mOptions.size() - 1));
+         arrowOffset.x = currentOffset.x + getWidth() - mRightPad - mArrowSize;
+         arrowOffset.y = currentOffset.y + arrowOffsetY;
+
+         drawer->clearBitmapModulation();
+         drawer->drawBitmapStretch(mNextBitmap, RectI(arrowOffset, Point2I(mArrowSize, mArrowSize)), GFXBitmapFlip_None, GFXTextureFilterLinear, false);
+      }
+      else
+      {
+         // render the left arrow
+         bool arrowOnL = (isSelected() || isHighlighted()) && (mWrapOptions || (mSelectedOption > 0));
+         arrowOffset.x = currentOffset.x + getWidth() - mRightPad;
+         arrowOffset.y = currentOffset.y + height / 2;
+
+         drawer->clearBitmapModulation();
+
+         drawer->drawLine(arrowOffset, Point2I(arrowOffset.x - mArrowSize, currentOffset.y), ColorI::WHITE);
+         drawer->drawLine(arrowOffset, Point2I(arrowOffset.x - mArrowSize, currentOffset.y + height), ColorI::WHITE);
+      }
+
+      // get the appropriate font color
+      ColorI fontColor;
+      if (!mEnabled)
+      {
+         fontColor = mProfile->mFontColorNA;
+      }
+      else if (isSelected())
+      {
+         fontColor = mProfile->mFontColorSEL;
+      }
+      else if (isHighlighted())
+      {
+         fontColor = mProfile->mFontColorHL;
+      }
+      else
+      {
+         fontColor = mProfile->mFontColor;
+      }
+
+      // calculate text to be at the center between the arrows
+      GFont* font = mProfile->mFont;
+      StringTableEntry text = mOptions[mSelectedOption].mDisplayText;
+      S32 textWidth = font->getStrWidth(text);
+      S32 columnWidth = xScale - mRightPad - mColumnSplit;
+      S32 columnCenter = mColumnSplit + (columnWidth >> 1);
+      S32 textStartX = columnCenter - (textWidth >> 1);
+      Point2I textOffset(textStartX, 0);
+
+      // render the option text itself
+      Point2I textExtent(columnWidth, height);
+      drawer->setBitmapModulation(fontColor);
+      renderJustifiedText(currentOffset + Point2I(mColumnSplit, 0), textExtent, text);
+   }
+}
+
+void GuiGameSettingsCtrl::onRenderSliderOption(Point2I currentOffset)
+{
+   F32 xScale = (float)getWidth();
+
+   S32 height = getHeight();
+
+   S32 arrowOffsetY = 0;
+
+   GFXDrawUtil* drawer = GFX->getDrawUtil();
+
+   Point2I arrowOffset;
+   S32 columnSplit = mColumnSplit;
+
+   
+
+   /*if (mPreviousBitmapAsset.notNull())
+   {
+      // render the left arrow
+      bool arrowOnL = (isSelected() || isHighlighted()) && (mWrapOptions || (mSelectedOption > 0));
+      arrowOffset.x = currentOffset.x + columnSplit;
+      arrowOffset.y = currentOffset.y + arrowOffsetY;
+
+      drawer->clearBitmapModulation();
+      drawer->drawBitmapStretch(mPreviousBitmap, RectI(arrowOffset, Point2I(mArrowSize, mArrowSize)), GFXBitmapFlip_None, GFXTextureFilterLinear, false);
+   }
+   else
+   {
+      // render the left arrow
+      bool arrowOnL = (isSelected() || isHighlighted()) && (mWrapOptions || (mSelectedOption > 0));
+      arrowOffset.x = currentOffset.x + mColumnSplit;
+      arrowOffset.y = currentOffset.y + height / 2;
+
+      drawer->clearBitmapModulation();
+
+      drawer->drawLine(arrowOffset, Point2I(arrowOffset.x + mArrowSize, currentOffset.y), ColorI::WHITE);
+      drawer->drawLine(arrowOffset, Point2I(arrowOffset.x + mArrowSize, currentOffset.y + height), ColorI::WHITE);
+   }
+
+   if (mNextBitmapAsset.notNull())
+   {
+      // render the right arrow
+      bool arrowOnR = (isSelected() || isHighlighted()) && (mWrapOptions || (mSelectedOption < mOptions.size() - 1));
+      arrowOffset.x = currentOffset.x + mRightPad * xScale - mArrowSize;
+      arrowOffset.y = currentOffset.y + arrowOffsetY;
+
+      drawer->clearBitmapModulation();
+      drawer->drawBitmapStretch(mNextBitmap, RectI(arrowOffset, Point2I(mArrowSize, mArrowSize)), GFXBitmapFlip_None, GFXTextureFilterLinear, false);
+   }
+   else
+   {
+      // render the left arrow
+      bool arrowOnL = (isSelected() || isHighlighted()) && (mWrapOptions || (mSelectedOption > 0));
+      arrowOffset.x = currentOffset.x + getWidth() - mRightPad;
+      arrowOffset.y = currentOffset.y + height / 2;
+
+      drawer->clearBitmapModulation();
+
+      drawer->drawLine(arrowOffset, Point2I(arrowOffset.x - mArrowSize, currentOffset.y), ColorI::WHITE);
+      drawer->drawLine(arrowOffset, Point2I(arrowOffset.x - mArrowSize, currentOffset.y + height), ColorI::WHITE);
+   }*/
+
+   //Draw the slider bar
+
+   RectI sliderRect;
+
+   S32 sliderOffset = 5;
+
+   RectI optionRect;
+
+   sliderRect.point.x = currentOffset.x + columnSplit + mArrowSize;
+   sliderRect.point.y = currentOffset.y + sliderOffset;
+
+   sliderRect.extent.x = (currentOffset.x + getWidth() - mRightPad - mArrowSize) - sliderRect.point.x;
+   sliderRect.extent.y = height - sliderOffset*2;
+
+   optionRect = sliderRect;
+
+   S32 textWidth = sliderRect.extent.x * 0.3;
+   sliderRect.extent.x -= textWidth;
+
+   //Now adjust the bar to match-to our value
+
+   S32 barStart = sliderRect.point.x;
+   S32 barEnd = sliderRect.point.x + sliderRect.extent.x;
+
+   S32 xPosFill = (((mValue - mRange.x) * (barEnd - barStart)) / (mRange.y - mRange.x)) + barStart;
+
+   RectI fillRect = sliderRect;
+   fillRect.extent.x = xPosFill - sliderRect.point.x;
+
+   ColorI barColor;
+   ColorI barOutlineColor;
+   if (isSelected())
+   {
+      barColor = mProfile->mFontColor;
+      barOutlineColor = mProfile->mFontColorSEL;
+   }
+   else
+   {
+      barColor = mProfile->mFontColor;
+      barOutlineColor = mProfile->mFontColorHL;
+   }
+
+   drawer->drawRectFill(fillRect, barColor);
+
+   drawer->drawRect(sliderRect, barOutlineColor);
+
+   // get the appropriate font color
+   ColorI fontColor;
+   if (!mEnabled)
+   {
+      fontColor = mProfile->mFontColorNA;
+   }
+   else if (isSelected())
+   {
+      fontColor = mProfile->mFontColorSEL;
+   }
+   else if (isHighlighted())
+   {
+      fontColor = mProfile->mFontColorHL;
+   }
+   else
+   {
+      fontColor = mProfile->mFontColor;
+   }
+
+   // calculate text to be at the center between the arrows
+   GFont* font = mProfile->mFont;
+
+   char stringVal[32];
+   dSprintf(stringVal, 32, "%f", mValue);
+
+   S32 stringWidth = font->getStrWidth(stringVal);
+   Point2I textOffset(sliderRect.point.x + sliderRect.extent.x, 0);
+
+   // render the option text itself
+   Point2I textExtent(textWidth, height);
+
+   RectI textRect = optionRect;
+   textRect.point.x = sliderRect.point.x + sliderRect.extent.x;
+   textRect.extent.x = optionRect.extent.x * 0.3;
+
+   drawer->setBitmapModulation(fontColor);
+   renderJustifiedText(textRect.point, textRect.extent, stringVal);
+
+   //drawer->drawRectFill(textRect, ColorI::RED);
+}
+
+void GuiGameSettingsCtrl::onRenderKeybindOption(Point2I currentOffset)
+{
+   F32 xScale = (float)getWidth();
+   S32 columnSplit = mColumnSplit;
+
+   S32 height = getHeight();
+
+   GFXDrawUtil* drawer = GFX->getDrawUtil();
+   //drawer->drawBitmap(mBitmap, )
+
+   Point2I button;
+   button.x = currentOffset.x + columnSplit + (columnSplit / 2.5)/* + (optionWidth / 2)*/;
+   button.y = currentOffset.y;
+
+   Point2I buttonSize;
+   buttonSize.x = height;
+   buttonSize.y = height;
+
+   if (mKeybindBitmapAsset.notNull())
+   {
+      RectI rect(button, buttonSize);
+      drawer->clearBitmapModulation();
+      drawer->drawBitmapStretch(mKeybindBitmap, rect, GFXBitmapFlip_None, GFXTextureFilterLinear, false);
+   }
+
+   //drawer->drawRectFill(button, ColorI::BLUE);
+}
+
+void GuiGameSettingsCtrl::set(const char* label, const char* callback, bool useHighlightIcon, bool enabled, S32 mode, const char* tooltip)
+{
+   mScriptCallback = (dStrlen(callback) > 0) ? StringTable->insert(callback, true) : NULL;
+   mEnabled = enabled;
+   mMode = (Mode)mode;
+   mTooltip = StringTable->insert(tooltip);
+   mLabel = StringTable->insert(label, true);
+}
+
+void GuiGameSettingsCtrl::setListSetting(const char* label, const char* optionsList, bool wrapOptions, const char* callback, bool enabled, const char* tooltip, const char* defaultValue)
+{
+   static StringTableEntry DELIM = StringTable->insert("\t", true);
+
+   Vector<OptionEntry> options(__FILE__, __LINE__);
+
+   S32 defaultOption = 0;
+
+   S32 count = StringUnit::getUnitCount(optionsList, DELIM);
+   for (S32 i = 0; i < count; ++i)
+   {
+      OptionEntry e;
+      const char* option = StringUnit::getUnit(optionsList, i, DELIM);
+      e.mDisplayText = StringTable->insert(option, true);
+      e.mKeyString = e.mDisplayText;
+      options.push_back(e);
+
+      if (String::compare(option, defaultValue) == 0)
+         defaultOption = options.size() - 1;
+   }
+   mOptions = options;
+   bool hasOptions = mOptions.size() > 0;
+   mSelectedOption = (hasOptions) ? defaultOption : NO_OPTION;
+   mWrapOptions = wrapOptions;
+   set(label, callback, true, (hasOptions) ? enabled : false, Mode::OptionList, tooltip);
+}
+
+void GuiGameSettingsCtrl::setSliderSetting(const char* label, F32 defaultValue, F32 increments, Point2F range, const char* callback, bool enabled, const char* tooltip)
+{
+   static StringTableEntry DELIM = StringTable->insert("\t", true);
+
+   mValue = defaultValue;
+   mStepSize = increments;
+   mRange = range;
+
+   set(label, callback, true, enabled, Mode::Slider, tooltip);
+}
+
+void GuiGameSettingsCtrl::setKeybindSetting(const char* label, const char* bitmapName, const char* callback, bool enabled, const char* tooltip)
+{
+   static StringTableEntry DELIM = StringTable->insert("\t", true);
+
+   _setKeybindBitmap(StringTable->insert(bitmapName));
+
+   //if(mBitmap != StringTable->EmptyString())
+   //   mBitmapTex.set(mBitmap, &GFXDefaultGUIProfile, avar("%s() - mTextureObject (line %d)", __FUNCTION__, __LINE__));
+
+   set(label, callback, true, enabled, Mode::Keybind, tooltip);
+}
+
+bool GuiGameSettingsCtrl::onAdd()
+{
+   if( !Parent::onAdd() )
+      return false;
+      
+   return true;
+}
+
+bool GuiGameSettingsCtrl::onWake()
+{
+   if( !Parent::onWake() )
+      return false;
+
+   return true;
+}
+void GuiGameSettingsCtrl::activate()
+{
+   if(isSelected() && isEnabled() && (mScriptCallback != StringTable->EmptyString()))
+   {
+      setThisControl();
+      if (Con::isFunction(mScriptCallback))
+      {
+         Con::executef(mScriptCallback);
+      }
+   }
+}
+
+void GuiGameSettingsCtrl::setSelected()
+{
+   if (!isEnabled())
+      return;
+
+   mSelected = true;
+}
+
+bool GuiGameSettingsCtrl::isEnabled() const
+{
+   return mEnabled;
+}
+
+void GuiGameSettingsCtrl::setEnabled(bool enabled)
+{
+   mEnabled = enabled;
+}
+
+void GuiGameSettingsCtrl::doScriptCommand(StringTableEntry command)
+{
+   if (command && command[0])
+   {
+      setThisControl();
+      Con::evaluate(command, false, __FILE__);
+   }
+}
+
+void GuiGameSettingsCtrl::setThisControl()
+{
+   smThisControl = this;
+}
+
+StringTableEntry GuiGameSettingsCtrl::getLabel() const
+{
+   return mLabel;
+}
+
+void GuiGameSettingsCtrl::setLabel( const char * label)
+{
+   mLabel = StringTable->insert(label, true);
+}
+
+void GuiGameSettingsCtrl::clear()
+{
+   mOptions.clear();
+}
+
+//-----------------------------------------------------------------------------
+// Console stuff (GuiGameSettingsCtrl)
+//-----------------------------------------------------------------------------
+
+StringTableEntry GuiGameSettingsCtrl::getCurrentOption() const
+{
+   if (mSelectedOption != NO_OPTION && !mOptions.empty())
+   {
+      return mOptions[mSelectedOption].mDisplayText;
+   }
+
+   return StringTable->insert("", false);
+}
+
+StringTableEntry GuiGameSettingsCtrl::getCurrentOptionKey() const
+{
+   if (mSelectedOption != NO_OPTION)
+   {
+      return mOptions[mSelectedOption].mKeyString;
+   }
+
+   return StringTable->insert("", false);
+}
+
+S32 GuiGameSettingsCtrl::getCurrentOptionIndex() const
+{
+   if (mSelectedOption != NO_OPTION)
+   {
+      return mSelectedOption;
+   }
+
+   return S32(-1);
+}
+
+bool GuiGameSettingsCtrl::selectOption(const char* theOption)
+{
+   for (Vector<OptionEntry>::iterator anOption = mOptions.begin(); anOption < mOptions.end(); ++anOption)
+   {
+      if (String::compare((*anOption).mDisplayText, theOption) == 0)
+      {
+         S32 newIndex = anOption - mOptions.begin();
+         mSelectedOption = newIndex;
+         return true;
+      }
+   }
+
+   return false;
+}
+
+bool GuiGameSettingsCtrl::selectOptionByKey(const char* optionKey)
+{
+   for (Vector<OptionEntry>::iterator anOption = mOptions.begin(); anOption < mOptions.end(); ++anOption)
+   {
+      if (String::compare((*anOption).mKeyString, optionKey) == 0)
+      {
+         S32 newIndex = anOption - mOptions.begin();
+         mSelectedOption = newIndex;
+         return true;
+      }
+   }
+
+   return false;
+}
+
+bool GuiGameSettingsCtrl::selectOptionByIndex(S32 optionIndex)
+{
+   if (optionIndex < mOptions.size() && optionIndex >= 0)
+   {
+      mSelectedOption = optionIndex;
+      return true;
+   }
+
+   return false;
+}
+
+void GuiGameSettingsCtrl::setOptions(const char* optionsList)
+{
+   static StringTableEntry DELIM = StringTable->insert("\t", true);
+
+   S32 count = StringUnit::getUnitCount(optionsList, DELIM);
+   mOptions.setSize(count);
+   for (S32 i = 0; i < count; ++i)
+   {
+      const char* option = StringUnit::getUnit(optionsList, i, DELIM);
+      OptionEntry e;
+      e.mDisplayText = StringTable->insert(option, true);
+      e.mKeyString = e.mDisplayText;
+      mOptions[i] = e;
+   }
+
+   if (mSelectedOption >= mOptions.size())
+   {
+      mSelectedOption = mOptions.size() - 1;
+   }
+}
+
+void GuiGameSettingsCtrl::addOption(const char* displayText, const char* keyText)
+{
+   OptionEntry e;
+   e.mDisplayText = StringTable->insert(displayText, true);
+   e.mKeyString = (keyText[0] == '\0') ? e.mDisplayText : StringTable->insert(keyText, true);
+
+   mOptions.push_back(e);
+}
+
+void GuiGameSettingsCtrl::clickOption(S32 xPos)
+{
+   F32 xScale = (float)getWidth();
+
+   S32 leftArrowX1 = mColumnSplit;
+   S32 leftArrowX2 = leftArrowX1 + mArrowSize;
+
+   S32 rightArrowX2 = getWidth() - mRightPad;
+   S32 rightArrowX1 = rightArrowX2 - mArrowSize;
+
+   if ((leftArrowX1 <= xPos) && (xPos <= leftArrowX2))
+   {
+      changeOption(-1);
+   }
+   else if ((rightArrowX1 <= xPos) && (xPos <= rightArrowX2))
+   {
+      changeOption(1);
+   }
+}
+
+void GuiGameSettingsCtrl::changeOption(S32 delta)
+{
+   S32 optionCount = mOptions.size();
+
+   S32 newSelection = mSelectedOption + delta;
+   if (optionCount == 0)
+   {
+      newSelection = NO_OPTION;
+   }
+   else if (!mWrapOptions)
+   {
+      newSelection = mClamp(newSelection, 0, optionCount - 1);
+   }
+   else if (newSelection < 0)
+   {
+      newSelection = optionCount - 1;
+   }
+   else if (newSelection >= optionCount)
+   {
+      newSelection = 0;
+   }
+   mSelectedOption = newSelection;
+
+   if (mMode == GuiGameSettingsCtrl::Slider)
+   {
+      mValue += mStepSize * delta;
+
+      mValue = mRound(mValue / mStepSize) * mStepSize;
+
+      if (mValue < mRange.x)
+         mValue = mRange.x;
+      if (mValue > mRange.y)
+         mValue = mRange.y;
+   }
+
+   static StringTableEntry LEFT = StringTable->insert("LEFT", true);
+   static StringTableEntry RIGHT = StringTable->insert("RIGHT", true);
+
+   onChange_callback();
+
+   if (mScriptCallback != NULL && (mSelectedOption != NO_OPTION && mMode != GuiGameSettingsCtrl::Slider))
+   {
+      setThisControl();
+      StringTableEntry direction = NULL;
+      if (delta < 0)
+      {
+         direction = LEFT;
+      }
+      else if (delta > 0)
+      {
+         direction = RIGHT;
+      }
+      if ((direction != NULL) && (Con::isFunction(mScriptCallback)))
+      {
+         Con::executef(mScriptCallback, direction);
+      }
+   }
+}
+IMPLEMENT_CONOBJECT(GuiGameSettingsCtrl);
+
+void GuiGameSettingsCtrl::clickSlider(S32 xPos)
+{
+   F32 xScale = (float)getWidth();
+
+   S32 leftArrowX1 = mColumnSplit;
+   S32 leftArrowX2 = leftArrowX1 + mArrowSize;
+
+   S32 rightArrowX2 = getWidth() - mRightPad;
+   S32 rightArrowX1 = rightArrowX2 - mArrowSize;
+
+   S32 sliderWidth = rightArrowX1 - leftArrowX2;
+   sliderWidth *= 0.6; //remove the number text spacing
+
+   /*if ((leftArrowX1 <= xPos) && (xPos <= leftArrowX2))
+   {
+      mValue -= mStepSize;
+
+      mValue = mRound(mValue / mStepSize) * mStepSize;
+
+      if (mValue < mRange.x)
+         mValue = mRange.x;
+
+   }
+   else if ((rightArrowX1 <= xPos) && (xPos <= rightArrowX2))
+   {
+      //F32 snap = mValue % mStepSize;
+      //mValue.y -= snap;
+
+      mValue += mStepSize;
+
+      mValue = mRound(mValue / mStepSize) * mStepSize;
+
+      if (mValue > mRange.y)
+         mValue = mRange.y;
+   }
+   else
+   {*/
+      //see if we clicked on the sliderbar itself
+      S32 barStart = leftArrowX2;
+      S32 barEnd = barStart + sliderWidth;
+
+      if (xPos >= barStart && xPos <= barEnd)
+      {
+         //find the position
+         F32 newValue = (((xPos - barStart) * (mRange.y - mRange.x)) / (barEnd - barStart)) + mRange.x;
+
+         newValue = mRound(newValue / mStepSize) * mStepSize;
+
+         mValue = newValue;
+      }
+   //}
+
+   onChange_callback();
+}
+
+void GuiGameSettingsCtrl::clickKeybind(S32 xPos)
+{
+   S32 columnSplit = mColumnSplit;
+
+   S32 height = getHeight();
+
+   Point2I button;
+   button.x = columnSplit + (columnSplit / 2.5)/* + (optionWidth / 2)*/;
+   button.y = 0;
+
+   Point2I buttonSize;
+   buttonSize.x = height;
+   buttonSize.y = height;
+
+   RectI rect(button, buttonSize);
+
+   onChange_callback();
+
+   if (rect.pointInRect(Point2I(xPos, getHeight()/2)))
+   {
+      if (mScriptCallback != StringTable->EmptyString())
+      {
+         Con::executef(mScriptCallback, this);
+      }
+   }
+}
+
+F32 GuiGameSettingsCtrl::getValue()
+{
+   return mValue;
+}
+
+void GuiGameSettingsCtrl::setValue(F32 value)
+{
+   mValue = value;
+}
+
+const char* GuiGameSettingsCtrl::getTooltip()
+{
+   return mTooltip;
+}
+
+ConsoleDocClass( GuiGameSettingsCtrl,
+   "@brief A base class for cross platform menu controls that are gamepad friendly.\n\n"
+
+   "This class is used to build row-based menu GUIs that can be easily navigated "
+   "using the keyboard, mouse or gamepad. The desired row can be selected using "
+   "the mouse, or by navigating using the Up and Down buttons.\n\n"
+
+   "@tsexample\n\n"
+   "new GuiGameSettingsCtrl()\n"
+   "{\n"
+   "   debugRender = \"0\";\n"
+   "   callbackOnA = \"applyOptions();\";\n"
+   "   callbackOnB = \"Canvas.setContent(MainMenuGui);\";\n"
+   "   callbackOnX = \"\";\n"
+   "   callbackOnY = \"revertOptions();\";\n"
+   "   //Properties not specific to this control have been omitted from this example.\n"
+   "};\n"
+   "@endtsexample\n\n"
+
+   "@see GuiGameSettingsProfile\n\n"
+
+   "@ingroup GuiGame"
+);
+
+IMPLEMENT_CALLBACK( GuiGameSettingsCtrl, onChange, void, (), (),
+   "Called when the setting's value changes." );
+
+IMPLEMENT_CALLBACK(GuiGameSettingsCtrl, onInputEvent, void, (const char* device, const char* action, bool state),
+   (device, action, state),
+   "@brief Callback that occurs when an input is triggered on this control\n\n"
+   "@param device The device type triggering the input, such as keyboard, mouse, etc\n"
+   "@param action The actual event occuring, such as a key or button\n"
+   "@param state True if the action is being pressed, false if it is being release\n\n");
+
+IMPLEMENT_CALLBACK(GuiGameSettingsCtrl, onAxisEvent, void, (const char* device, const char* action, F32 axisValue),
+   (device, action, axisValue),
+   "@brief Callback that occurs when an axis event is triggered on this control\n\n"
+   "@param device The device type triggering the input, such as mouse, joystick, gamepad, etc\n"
+   "@param action The ActionMap code for the axis\n"
+   "@param axisValue The current value of the axis\n\n");
+
+void GuiGameSettingsCtrl::initPersistFields()
+{
+   INITPERSISTFIELD_IMAGEASSET(KeybindBitmap, GuiGameSettingsCtrl, "Bitmap used to display the bound key for this keybind option.");
+   INITPERSISTFIELD_IMAGEASSET(PreviousBitmap, GuiGameSettingsCtrl, "Bitmap used for the previous button when in list mode.");
+   INITPERSISTFIELD_IMAGEASSET(NextBitmap, GuiGameSettingsCtrl, "Bitmap used for the next button when in list mode.");
+
+   addField("arrowSize", TypeS32, Offset(mArrowSize, GuiGameSettingsCtrl),
+      "Size of the arrow buttons' extents");
+
+   addField("columnSplit", TypeS32, Offset(mColumnSplit, GuiGameSettingsCtrl),
+      "Position of the split between the leftside label and the rightside setting parts");
+
+   addField("rightPad", TypeS32, Offset(mRightPad, GuiGameSettingsCtrl),
+      "Padding between the rightmost edge of the control and right arrow.");
+
+   addField("callbackOnA", TypeString, Offset(mCallbackOnA, GuiGameSettingsCtrl),
+      "Script callback when the 'A' button is pressed. 'A' inputs are Keyboard: A, Return, Space; Gamepad: A, Start" );
+
+   addField("callbackOnB", TypeString, Offset(mCallbackOnB, GuiGameSettingsCtrl),
+      "Script callback when the 'B' button is pressed. 'B' inputs are Keyboard: B, Esc, Backspace, Delete; Gamepad: B, Back" );
+
+   addField("callbackOnX", TypeString, Offset(mCallbackOnX, GuiGameSettingsCtrl),
+      "Script callback when the 'X' button is pressed. 'X' inputs are Keyboard: X; Gamepad: X" );
+
+   addField("callbackOnY", TypeString, Offset(mCallbackOnY, GuiGameSettingsCtrl),
+      "Script callback when the 'Y' button is pressed. 'Y' inputs are Keyboard: Y; Gamepad: Y" );
+
+   addField("callbackOnInputs", TypeBool, Offset(mCallbackOnInputs, GuiGameSettingsCtrl),
+      "Script callback when any inputs are detected, even if they aren't the regular 4 face buttons. Useful for secondary/speciality handling of menu navigation.");
+
+   addField("consumeKeyInputEvents", TypeBool, Offset(mConsumeKeyInputEvents, GuiGameSettingsCtrl),
+      "When callbackOnInputs is active, this indicates if the input event should be consumed, or allowed 'through' to let other things respond to the event as well.");
+   
+
+   Parent::initPersistFields();
+}
+
+DefineEngineMethod( GuiGameSettingsCtrl, isEnabled, bool, (),,
+   "Determines if the control is enabled or disabled.\n\n"
+   "@return True if the control is enabled. False if the control is not enabled." )
+{
+   return object->isEnabled();
+}
+
+DefineEngineMethod( GuiGameSettingsCtrl, setEnabled, void, ( bool enabled ),,
+   "Sets the control's enabled status according to the given parameters.\n\n"
+   "@param enabled Indicate true to enable the control or false to disable it." )
+{
+   object->setEnabled( enabled );
+}
+
+DefineEngineMethod( GuiGameSettingsCtrl, activate, void, (),,
+   "Activates the control. The script callback of the control will be called (if it has one)." )
+{
+   object->activate();
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, getLabel, const char *, (),,
+   "Gets the label displayed.\n\n"
+   "@return The label." )
+{
+   return object->getLabel();
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, setLabel, void, ( const char* label ),,
+   "Sets the label.\n\n"
+   "@param label Text to set as the label.\n" )
+{
+   object->setLabel(label );
+}
+
+DefineEngineMethod( GuiGameSettingsCtrl, setSelected, void, (),,
+   "Sets the control as selected. Can only select enabled controls." )
+{
+   object->setSelected();
+}
+
+DefineEngineMethod( GuiGameSettingsCtrl, getSelected, bool, (),,
+   "Gets if the control is currently selected.\n\n"
+   "@return if the control is selected." )
+{
+   return object->isSelected();
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, clear, void, (), ,
+   "Clears the current options.\n\n")
+{
+   return object->clear();
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, getMode, S32, (), ,
+   "Gets this control's options mode.\n\n")
+{
+   GuiGameSettingsCtrl::Mode mode = object->getMode();
+   if (mode == GuiGameSettingsCtrl::Mode::OptionList)
+      return 0;
+   else if (mode == GuiGameSettingsCtrl::Mode::Slider)
+      return 1;
+   else if (mode == GuiGameSettingsCtrl::Mode::Keybind)
+      return 2;
+   else
+      return -1;
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, setListSetting, void,
+   (const char* label, const char* options, bool wrapOptions, const char* callback, bool enabled, const char* tooltip, const char* defaultValue),
+   (true, "", ""),
+   "Sets this setting to a list.\n\n"
+   "@param label The text to display  as a label.\n"
+   "@param options A tab separated list of options.\n"
+   "@param wrapOptions Specify true to allow options to wrap at each end or false to prevent wrapping.\n"
+   "@param callback Name of a script function to use as a callback when this control is activated.\n"
+   "@param enabled [optional] If this control is initially enabled.")
+{
+   object->setListSetting(label, options, wrapOptions, callback, enabled, tooltip, defaultValue);
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, setSliderSetting, void,
+(const char* label, F32 defaultValue, F32 increment, Point2F range, const char* callback, bool enabled, const char* tooltip),
+(true, ""),
+"Sets this setting to a slider.\n\n"
+"@param label The text to display as a label.\n"
+"@param options A tab separated list of options.\n"
+"@param wrapOptions Specify true to allow options to wrap at each end or false to prevent wrapping.\n"
+"@param callback Name of a script function to use as a callback when this control is activated.\n"
+"@param enabled [optional] If this control is initially enabled.")
+{
+   object->setSliderSetting(label, defaultValue, increment, range, callback, enabled, tooltip);
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, setKeybindSetting, void,
+(const char* label, const char* bitmapName, const char* callback, bool enabled, const char* tooltip),
+(true, ""),
+"Sets this setting to a keybind.\n\n"
+"@param label The text to display as a label.\n"
+"@param options A tab separated list of options.\n"
+"@param wrapOptions Specify true to allow options to wrap at each end or false to prevent wrapping.\n"
+"@param callback Name of a script function to use as a callback when this control is activated.\n"
+"@param enabled [optional] If this control is initially enabled.")
+{
+   object->setKeybindSetting(label, bitmapName, callback, enabled, tooltip);
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, getCurrentOption, const char*, (), ,
+   "Gets the text for the currently selected option .\n\n"
+   "@return A string representing the text currently displayed as the selected option. If there is no such displayed text then the empty string is returned.")
+{
+   return object->getCurrentOption();
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, getCurrentOptionKey, const char*, (), ,
+   "Gets the key string for the currently selected option.\n\n"
+   "@return The key (or id) that was assigned to the selected option. If there is no selected option then the empty string is returned.")
+{
+   return object->getCurrentOptionKey();
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, getCurrentOptionIndex, S32, (), ,
+   "Gets the index into the option list for the currently selected option.\n\n"
+   "@return The index of the selected option. If there is no selected option then -1 is returned.")
+{
+   return object->getCurrentOptionIndex();
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, selectOption, bool, (const char* option), ,
+   "Set the control's current option to the one specified\n\n"
+   "@param option The option to be made active.\n"
+   "@return True if the control contained the option and was set, false otherwise.")
+{
+   return object->selectOption(option);
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, selectOptionByKey, bool, (const char* optionKey), ,
+   "Set the control's current option to the one with the specified key.\n\n"
+   "@param optionKey The key string that was assigned to the option to be made active.\n"
+   "@return True if the control contained the key and the option and was set, false otherwise.")
+{
+   return object->selectOptionByKey(optionKey);
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, selectOptionByIndex, bool, (S32 optionIndex), ,
+   "Set the control's current option to the one at the specified index.\n\n"
+   "@param optionIndex The index of the option to be made active.\n"
+   "@return True if the index was valid and the option and was set, false otherwise.")
+{
+   return object->selectOptionByIndex(optionIndex);
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, setOptions, void, (const char* optionsList), ,
+   "Sets the list of options on the given control.\n\n"
+   "@param optionsList A tab separated list of options for the control.")
+{
+   object->setOptions(optionsList);
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, addOption, void, (const char* displayText, const char* keyText), (""),
+   "Adds an option to the list of options on the given control.\n\n"
+   "@param displayText The text to display for this option.\n"
+   "@param keyText [Optional] The id string to associate with this value. "
+   "If unset, the id will be the same as the display text.\n")
+{
+   object->addOption(displayText, keyText);
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, getValue, F32, (), ,
+   "Sets the list of options on the given control.\n\n"
+   "@param optionsList A tab separated list of options for the control.")
+{
+   return object->getValue();
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, setValue, void, (F32 value), ,
+   "Sets the list of options on the given control.\n\n"
+   "@param optionsList A tab separated list of options for the control.")
+{
+   object->setValue(value);
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, getTooltip, const char*, (), ,
+   "Sets the list of options on the given control.\n\n"
+   "@param optionsList A tab separated list of options for the control.")
+{
+   return object->getTooltip();
+}
diff --git a/Engine/source/gui/controls/guiGameSettingsCtrl.h b/Engine/source/gui/controls/guiGameSettingsCtrl.h
new file mode 100644
index 000000000..d8aac95e8
--- /dev/null
+++ b/Engine/source/gui/controls/guiGameSettingsCtrl.h
@@ -0,0 +1,313 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2012 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+
+#ifndef _GuiGameSettingsCtrl_H_
+#define _GuiGameSettingsCtrl_H_
+
+#include "gui/buttons/guiButtonCtrl.h"
+#include "T3D/assets/ImageAsset.h"
+
+/// \class GuiGameSettingsCtrl
+/// A base class for cross platform menu controls that are gamepad friendly.
+class GuiGameSettingsCtrl : public GuiButtonCtrl
+{
+public:
+   typedef GuiButtonCtrl Parent;
+
+   enum Mode
+   {
+      Default = 0,
+      OptionList,
+      Slider,
+      Keybind,
+      Text
+   };
+
+protected:
+
+   /// \struct OptionEntry
+   /// Display text and ID key for each entry in an option.
+   struct OptionEntry
+   {
+      StringTableEntry mDisplayText;   ///< The text that is displayed for the option
+      StringTableEntry mKeyString;     ///< Key value that is associated with this option
+      OptionEntry() : mDisplayText(StringTable->EmptyString()), mKeyString(StringTable->EmptyString()) {}
+      virtual ~OptionEntry() {}
+   };
+
+
+   StringTableEntry mLabel;            ///< Text to display in the control as a label
+   StringTableEntry mScriptCallback;   ///< Script callback when control is activated
+   StringTableEntry mTooltip;          ///< A descriptive tooltip message for what the control is
+
+   Mode mMode;
+
+   //List options
+   Vector<OptionEntry>        mOptions;         ///< Collection of options available to display
+   S32                        mSelectedOption;  ///< Index into mOptions pointing at the selected option
+   bool                       mWrapOptions;     ///< Determines if options should "wrap around" at the ends
+
+   //Slider option
+   F32                        mValue;           ///< When working as a slider, this contains the value
+   F32                        mStepSize;        ///< When working as a slider, this is the increment levels in the range
+   Point2F                    mRange;           ///< When working as a slider, this sets our min/max range
+
+   //Keybind option
+   DECLARE_IMAGEASSET(GuiGameSettingsCtrl, KeybindBitmap, changeBitmap, GFXDefaultGUIProfile);
+   DECLARE_ASSET_SETGET(GuiGameSettingsCtrl, KeybindBitmap);
+
+   DECLARE_IMAGEASSET(GuiGameSettingsCtrl, PreviousBitmap, changeBitmap, GFXDefaultGUIProfile);
+   DECLARE_ASSET_SETGET(GuiGameSettingsCtrl, PreviousBitmap);
+
+   DECLARE_IMAGEASSET(GuiGameSettingsCtrl, NextBitmap, changeBitmap, GFXDefaultGUIProfile);
+   DECLARE_ASSET_SETGET(GuiGameSettingsCtrl, NextBitmap);
+
+   S32 mArrowSize;
+   S32 mColumnSplit; //Padding between the leftmost edge of the control, and the left side of the 'option'.
+   S32 mRightPad;
+
+   bool mEnabled;
+   bool mSelected;
+
+public:
+   void changeBitmap() {}
+
+   /// Sets the control as selected . Only controls that are enabled can be selected. 
+   virtual void setSelected();
+
+   /// Determines if the specified control is enabled or disabled.
+   ///
+   /// \return True if the specified control is enabled. False if the control is not
+   /// enabled
+   virtual bool isEnabled() const;
+
+   /// Sets a control's enabled status according to the given parameters.
+   ///
+   /// \param enabled Indicate true to enable the control or false to disable it.
+   virtual void setEnabled(bool enabled);
+
+   /// Gets the label displayed on the control.
+   ///
+   /// \return The label for the control.
+   virtual StringTableEntry getLabel() const;
+
+   /// Sets the label on the control.
+   ///
+   /// \param label Text to set as the label.
+   virtual void setLabel(const char * label);
+
+   /// Sets the control to a List setting.
+   ///
+   /// \param label The text to display on the control as a label.
+   /// \param optionsList A tab separated list of options for the control.
+   /// \param wrapOptions Specify true to allow options to wrap at the ends or
+   /// false to prevent wrapping.
+   /// \param callback [optional] Name of a script function to use as a callback
+   /// when this control is activated. Default NULL means no callback.
+   /// \param enabled [optional] If this control is initially enabled. Default true.
+   void setListSetting(const char* label, const char* optionsList, bool wrapOptions, const char* callback,bool enabled, const char* tooltip = "", const char* defaultValue = "");
+
+   /// Sets the control to a Slider setting
+   ///
+   /// \param label The text to display on the control as a label.
+   /// \param defaultValue A float indicating the slider's default value
+   /// \param increments A float indicating the incremental values the slider snaps along between it's range
+   /// \param range A Point2F that indicates the minimum and maximum value range
+   /// \param callback [optional] Name of a script function to use as a callback
+   /// when this control is activated. Default NULL means no callback.
+   /// \param enabled [optional] If this control is initially enabled. Default true.
+   void setSliderSetting(const char* label, F32 defaultValue, F32 increments, Point2F range, const char* callback, bool enabled, const char* tooltip = "");
+
+   /// Sets the control to a Keybind setting
+   ///
+   /// \param label The text to display on the control as a label.
+   /// \param bitmapAssetId The assetId for the button display image
+   /// \param range A Point2F that indicates the minimum and maximum value range
+   /// \param callback [optional] Name of a script function to use as a callback
+   /// when this control is activated. Default NULL means no callback.
+   /// \param enabled [optional] If this control is initially enabled. Default true.
+   void setKeybindSetting(const char* label, const char* bitmapAssetId, const char* callback, bool enabled, const char* tooltip);
+
+   /// Gets the text for the currently selected option of the control.
+   ///
+   /// \return A string representing the text currently displayed as the selected
+   /// option on the control. If there is no such displayed text then the empty
+   /// string is returned.
+   StringTableEntry getCurrentOption() const;
+
+   /// Gets the key string for the currently selected option of the control
+   ///
+   /// \return The key (or id) that was assigned to the selected option on the
+   ///  control. If there is no selected option then the empty string is returned.
+   StringTableEntry getCurrentOptionKey() const;
+
+   /// Gets the index into the option list for the currently selected option of the control.
+   ///
+   /// \return The index of the selected option on the control. If there is no
+   /// selected option then -1 is returned.
+   S32 getCurrentOptionIndex() const;
+
+   /// Attempts to set the control to the specified selected option. The option
+   /// will only be set if the option exists in the control.
+   ///
+   /// \param option The option to be made active.
+   /// \return True if the control contained the option and was set, false otherwise.
+   bool selectOption(const char* option);
+
+   /// Attempts to set the control to the option with the specified key. The
+   /// option will only be set if the key exists in the control.
+   ///
+   /// \param optionKey The key string that was assigned to the option to be made active.
+   /// \return True if the control contained the key and the option and was set, false otherwise.
+   bool selectOptionByKey(const char* optionKey);
+
+   /// Attempts to set the control to the option at the specified index. The option
+   /// will only be set if the index is valid.
+   ///
+   /// \param optionIndex The index of the option to be made active.
+   /// \return True if the index was valid and the option and was set, false otherwise.
+   bool selectOptionByIndex(S32 optionIndex);
+
+   /// Sets the list of options on the control.
+   ///
+   /// \param optionsList A tab separated list of options for the control.
+   void setOptions(const char* optionsList);
+
+   /// Adds an option to the list of options on the control.
+   ///
+   /// \param displayText The text to display for this option.
+   /// \param keyText The id string to associate with this value. If NULL the
+   ///  id will be the same as the display text.
+   void addOption(const char* displayText, const char* keyText);
+
+   /// Activates the control. The script callback of the control will
+   /// be called (if it has one).
+   virtual void activate();
+
+   /// Gets the value
+   ///
+   F32 getValue();
+
+   /// Sets the value
+   ///
+   /// \param value The new value to be set.
+   void setValue(F32 value);
+
+   Mode getMode() { return mMode; }
+
+   /// Gets the tooltip
+   const char* getTooltip();
+
+   GuiGameSettingsCtrl();
+   ~GuiGameSettingsCtrl();
+
+   void onRender(Point2I offset, const RectI &updateRect);
+
+   void onRenderListOption(Point2I currentOffset);
+   void onRenderSliderOption(Point2I currentOffset);
+
+   void onRenderKeybindOption(Point2I currentOffset);
+
+   /// Callback when the object is registered with the sim.
+   ///
+   /// \return True if the profile was successfully added, false otherwise.
+   bool onAdd();
+
+   /// Callback when the control wakes up.
+   bool onWake();
+
+   void clear();
+
+   virtual void onMouseMove(const GuiEvent& event);
+   virtual void onMouseUp(const GuiEvent& event);
+
+   DECLARE_CONOBJECT(GuiGameSettingsCtrl);
+   DECLARE_CATEGORY( "Gui Game" );
+   DECLARE_DESCRIPTION( "Base class for cross platform menu controls that are gamepad friendly." );
+
+   /// Initializes fields accessible through the console.
+   static void initPersistFields();
+
+   static const S32 NO_OPTION = -1; ///< Indicates there is no option
+
+protected:
+   /// Sets up the option
+   ///
+   /// \param label The text to display on the control as a label.
+   /// \param callback Name of a script function to use as a callback when this
+   /// control is activated.
+   /// \param enabled [optional] If this control is initially enabled. Default true.
+   virtual void set(const char* label, const char* callback, bool useHighlightIcon = true, bool enabled = true, S32 mode = 0, const char* tooltip = "");
+
+   /// Sets the script variable $ThisControl to reflect this control.
+   virtual void setThisControl();
+
+   /// @name Callbacks
+   /// @{
+   DECLARE_CALLBACK( void, onChange, () );
+
+   DECLARE_CALLBACK(void, onInputEvent,  (const char* device, const char* action, bool state));
+
+   DECLARE_CALLBACK(void, onAxisEvent, (const char* device, const char* action, F32 axisValue));
+   /// @}
+
+   /// Evaluates some script. If the command is empty then nothing is evaluated.
+   ///
+   /// \param command The script to evaluate.
+   void doScriptCommand(StringTableEntry command);
+
+   StringTableEntry  mCallbackOnA;  ///< Script callback when the 'A' button is pressed
+   StringTableEntry  mCallbackOnB;  ///< Script callback when the 'B' button is pressed
+   StringTableEntry  mCallbackOnX;  ///< Script callback when the 'X' button is pressed
+   StringTableEntry  mCallbackOnY;  ///< Script callback when the 'Y' button is pressed
+
+private:
+   /// Performs a click on the current option. The x position is used to
+   /// determine if the left or right arrow were clicked. If one was clicked, the
+   /// option will be changed. If neither was clicked, the option is unaffected.
+   /// This method should only be called when there is an actively selected control.
+   ///
+   /// \param xPos The x position of the the click, relative to the control.
+   void clickOption(S32 xPos);
+
+   /// Changes the option on the currently selected control.
+   ///
+   /// \param delta The amount to change the option selection by. Typically this
+   /// will be 1 or -1.
+   void changeOption(S32 delta);
+
+   /// Performs a click on the current slider control. The x position is used to
+   /// determine if the left or right arrow were clicked, or if it landed somewhere on the sliderbar.
+   /// If one was clicked, the option will be changed. If neither was clicked, the option is unaffected.
+   /// This method should only be called when there is an actively selected control.
+   ///
+   /// \param xPos The x position of the the click, relative to the control.
+   void clickSlider(S32 xPos);
+
+   void clickKeybind(S32 xPos);
+
+private:
+   bool     mCallbackOnInputs;
+   bool     mConsumeKeyInputEvents;
+};
+
+#endif
diff --git a/Templates/BaseGame/game/data/UI/guis/NetGraphGui.asset.taml b/Templates/BaseGame/game/data/UI/guis/NetGraphGui.asset.taml
new file mode 100644
index 000000000..c73e44804
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/guis/NetGraphGui.asset.taml
@@ -0,0 +1,4 @@
+<GUIAsset
+    AssetName="NetGraphGui"
+    GUIFile="@assetFile=netGraphGui.gui"
+    VersionId="1"/>
diff --git a/Templates/BaseGame/game/data/UI/images/Torque_3D_logo.png b/Templates/BaseGame/game/data/UI/images/Torque_3D_logo.png
new file mode 100644
index 0000000000000000000000000000000000000000..e31d42a688a7e560b17237ff60edbf9c0c00dc4d
GIT binary patch
literal 9063
zcmbVSg;!MF*B+!(U;wG1yOHi1kf9k$L`uK`=0%Wh5QdU&q*J<vZUm%Dy1OMM1;lUs
z{R!W?>)vzMy{GoxC-!;v6QQH^iV%+)4*&oVLR7&}006BG^&W|Xg?ipui(#V@tas|K
zz<|I1uH25|MAR2tCskt?001BO??wZpXHud*V!J{#m9aO_Ffc?xA)nqf000aC2v|Yi
zbLqrXDwamw{b|rk&FJ<ses9Sj1HU{+En2kVtJFm58VK6>_lT(I!cRi%LfiBf(M(}V
ztf4@qo#z7JZ-Fmr&~*br$AR6fwYr!;cTFM8W5NGn`@PXSKCJSup`RVQL_-KypH}J3
z?w6m<l<JW)B0@;z)r`@CzgY-S(k)m61t<wr#0ieZr~`=ta{$7CdTD<LEDLas$H`&y
zM9K&~xuH7&RxpXGGcRBQ;A-{wn?U|~clnL0^iVC~0M)v)B7J@FHe(_v5fuDQz+|W+
z3gT=gj^?zK9Rri7XLU5M=309W2sKWS`<KDuuDnGIU{5DUhekQsC8RtgeDIeS5NjDG
z-9a`njjHsG5HdIx6lPpv#wLXo{H<A?z!U(ZlRH8a$Nia>EYiswf&-#OHE5<~ErxN<
zw`n4cQB&-@dTv`sq=Y;X;6=iVoJ>vsdx%?*wnNhV;vTjTfHJi*#!p*^{G<aO?kaln
zA*JlJ2L`BCn^ahuU)eX2%Lgd|!XVu1`ZICFJ>`0!V<AC7%BW`~t9Cw;vKj~XJ~c`O
z(G|G-{K!kM6fDj)7@tV9wTJgOcuuTbx}AyuYnz6o<4VUY46+(LGYsT;)ii#v1`kFF
zgKDSv<nRu6u{ZMA9N?Lg<dAkuiBhI2_Q()NhcMX-&Sbw8wnjiV4c=`fXleSQL<U4p
zd`M_2_knoR&8XwKBNuz~9ADPo@-K!$oV($?$zEOJ7yfa~&QH~yWI)bcMCJF_3bP&E
z&f;SqyX_?I7IW8Du+Pmt9=)n@p`Ifx^u8_Sk9iA>tyAduJ<a8ZOo6*AhRduNDl7zh
z*w@mtHIG?Sf8DhXAtnTmSgYYNbMEpCbm~47kzX$!UJ}X6Rk}~!T~G^s(F}LpW*&Y>
zh6XK_4Z6OAd_IC1<vgW*rxS=ROrAM~Po<lN!yLNJmR-XHd_LkjIwXN4!uG+=<#DR$
z?qBUvtE8Ttb7Af;&1z6iH6|BissPN2Pdo=VWeYluS(CP{ecjM9aT)Kg9wDi4??a_N
zrG?E>o?IGwUA9_BLSNImdS>Z<Q~utu@#3A-%m;cj@$U5C<G<EAj@gzHbzM>=VkBYb
zYF+Qy5w<vt<F<P@OqdPz*iv(U>xj3~dOq05M;>3B;arFkVlp6XaT(VVdQYlUUH!F=
zqlvd*jNlgpp<>x>ow7rdr4zQu3du`qk0G%KTF<zERMog4t&d*^z|O|vt<+<~YkC}2
z8n$Sj>Ngts=Jtx=VqoV=g6u8@wKJIz1}Xx;dXLRf+QGg~7jj<^VzokQ#*f>>&AN!o
zc!MB5i`S;CQLx{t0CP=zBPrcUo}ty0|K*u?Yx~l9ln;@ov7_HUa*r1NcD5)er`bdi
zXlBc(Cy8W+-BUc#kh?h@)wjrfoZD(G3>{YSG-d3IO!J#A>Wr{Tv<&id(VrT^VV0!x
ziK>$pm?0ME%{f;*)8#P;!jqWh7%q6uwMWf{8ysGbnF~tL0I^;OZ?eP+n+;<1RKw_S
z8NGE$omELfvqHw+`U&ASyGP&evLm$RkDe_66_5A7_}L4vT@9fdf4Eq5k(g<3eBtNR
z5lKMbqo<YcbpBq)Q5LtX9!iZYa6{I`@n3KQI!d%+psitm7`u~wFC6T(K+v3TLXuuG
z^t9M^0E?vGWlY^DIIG>6_E-7<W5kDN8(_7?NZaROv=0CxJ09uhf=cdcVkdPpEy459
z;cXFHSTDc;`?l|$j^o@fajX&sgok8_7(KUak-|>#*d&iKWnwrx!H+C}CsUEMX|iWw
z5;JE}-Om8Btq^Y$3==g@cIfal@rgHuB`ImWyCk|3N717o*N@-zdD_6BKg36c4M&nJ
z1?PBkU;5JZg@b^lS5EXClSRy5hBe)rP4)&xzR1Qy>DWO?rYWDG4cA>6#=en!%B15R
zKD&DGh63EIkTf{ldPhSZYTFy9DrK8v+JvC0k8<L&H2+PDRK}Zj6!NTIpH)+LCu3U1
zcls*#wL>snQC5KlWKPC;orP1~)N?FkOF9*7stZeaPg9trjlP7oU;-4k46(!$M^I^a
zGN%sOcAJ@T(l5rlc+(N*5AvXWQgl*4+#)UBKM~hCzL~84LRgf9O?5M-0N9*$<;M$-
zf2jdU;-uaLSxIDifqmH3i;vAPIKqmJVM`>Nhl<X;N<T^1WO}9X(h$;P3Z-=NIf(Pj
zSr9Y(jPdOEeoM-AJy+y(X=`G;7H1q3E35yhLS8h6*1f1f5|l^3lXe=A`;kq==^9T(
zR%iW%q1%s{RpJrdjH=XDZk|P5#ZT)zzVGCh>Oa)BsS-7Sawqe(6hpnTy%l~2SHIKB
zrHty^)J6W+Z5R=i$lzvVZBxu$ddYPb#vFDkrc_SOm;_0N-UtIfL&A;iCv!*9TLmuZ
z!d_BQ75vO5Mnag%+akhRO}t|x+e_c>>pX-?Z^H?V>oq_#JIChoU8i5`YGW8&9P5&t
z*$@Zc0tz1Jq-bXnv*W%@-eQ$WdL*odC+ZnOJ&vS0^zZTqt@rnJUSVausq|@~ua;LC
z;N;#D&^k??sB3t)#0+nrj?1bA#z)Pnh;70RyPbOdm~Od6A--;6C1PQp|9TsGA`38Z
z<S2!>6QD5%4Ep>thQ12USqgS+WUcOg0=ASF$6w-`%HWn>Z6k=!Afc`8WJULAg^tC1
zjFg_L#lyi5_6v1HR`uVkqn;%M1c~0!2$A6GG!dwzgZF1_3_f<J7#pu%*Je8W;l1n_
z-V;oyiDs2_`eBX5jGOO5?>6f~hGS(@@*9JfO-e=oD$Y`b8mpiXeA^Rzpfc%b@D40o
z$HkR-c`CZd*OJFkD2V7#8K@h-?!ow-1v64ffPXWCJGS@>KdYG-_{|b_<GMmWli^g_
zrmH)oB_=>eeN)kCT)<7LLpotFExil}{Gt3(+3GH$ahMbsw36A5l-*w}f;ed@XT#3N
zo!;lGdnBALJhB6dLs;4Zc?MDxh#Ef4BKiI-b>(!|xjA`!ddu1qoMs~K%71DV92y^U
z>~CrQZIXDwth>2vx=YgB6>kF(!6y<$_V7YBO5zultB+!MIwM@Y_1hEQKCY5E&X2Hw
zLu6`rYE-_SGAON1^g?fV_=~QV_z-J3M+{I)1p+#AYO5>|ED?h%Yw6%Rm$7XakM2+4
zwdN1<a=oBP2E)=DMKr`GV!8TU3C?I#Bxd^=fu?Lu4-FkmiCJ1yyB&v;8oPg2u%$^7
zwd_FOD}bf&4BU_uw^vHh;@e5_`CPtoC1UH)9z14NPYn)gWg@E^%djPTS-gC8*vM{(
z&}v=AmQGQU3?pLwnRoOO$@Ou|{J9)X12@8xeE+V<e>?s|774&RYv{KEjzKZ=iovkR
zNo|HPKKqgJjfU}r%hNS?$NaO&{3*k*xA;OpVZ8F=a30t1;pSLL<m!5}Zs_`1cGqXF
zo1<DYLET{Mf;1qSxhvbg-+{K~!3|ApjFN_;efs18mvUd7G;iMc(}*}zW<&9|rH|xk
zQ}OopjcfaQb_}<$@$p04+Ji!e*XW!&rn+p&LB_E5GunxaidcA_NNH-iIaPWijJJ=<
z5hi$C(zcdO%*3||!X};~;gs)!gny_!HBkL7gLm+kr<)5Y&a&XBJ)n*D7`|&|+Zk<)
z=kV(Xbm*NSHIkX#k9vc6?Y*++&cPbi=(#pQ!)|SVgxCgs%2k`$^ZSOj4{v*zS<4J!
z{`42fJkOWH_Y~ApS~G7F$xHku4rj>vlM&?#ah%GIc^-ZhO2>6pIgh&>1wL;k*zM8E
zt-jhIHY*Dbzp2C|F<n1bV`;svDxfT5warj4!XYshacA2XTFA@$qBVO<6Kg*s#!pNu
zDHC23Q^uSGqq@=)+p7~CW$f^az3qiqSoWyXHS{EcBua8IKFa{k?A&vNhh`DP{Fdxm
zGtV+7KW#SBVscER3Rb;P^%SOx02iVx$dbEGQ`5WPs3?6~n)Gt`P1c8=Db>q%1!N-M
zw>=Q0GGm9{f{!umG=e%z7&uTt7Lq$uibVn;yjhwyfm%Z1Rs;icNNBe*l=X?cw)6{<
zn9n*Aq1in?Sv~NV&J@a@JlOVo0WTfgn$9q<uXWVCC~GzA06kJ_!RH*h90K0m{*^ii
zu`34Y>g@o^@=YZ>JOw>G8DiQh`}pbXI4ep7AuqJK5;K?3$ANA17>@N&AE>KvEDltp
z?e0?Rizm*15z>s>GG@dShFkHa>Lm~zewLK_$O<6|xf3xunVYs7^AG=RH_^B}zW3iP
zZp`Tyo`oL>eTcPHAK<osRq<pb+AXK##My2Z1T2FohPO{#`($0-<W=A}3YUo8ngYMf
z<*rG8K>67gecz$=CHlp5U<T<8(ZemwKV#wHLm;fO=`+b3)u|R$aPh)N4utr%Zbj|Q
znleMXBaqbjMoT#bH|6<WR=hnJ=Ik$z%bA@wd3q!B_~iWQ@_V!i+IPccv<Kj<;7!63
znld3)2=#VU3sr)q|7W4K#Qr6Ob;LQ5Y3EN{9Y>V9FA!eb6!t}|Qr~ekiQ7Z>#PDrd
zuQ-?i+Ex^LqG;@34KvYW9L6`gi4NiCvJ6X0=3~{`2x1|dy{_j{g~yBgU2C1O0j>8@
z>%4n`e%89ALVHRWVdSeU**lab-YL&wMM5<_J5Ubxg2<3GI(-@~6&*ag07|!}rnSJ`
zAtsa`2bJYSUNU|!Fu{(lyB#;~^$D^@VohZBQ4CLBx#8V%lRtVt$R5o`7ehd%N}pFd
z))KIZ<``F+*qmUgP0jVMd72BP>!z~x`HC`s=!$E{uQDbn0pwD4X$6LLuGBqk8MfA>
zl37rWgDO>}8rk}dE^6>Efs5oy^)H@FJ&z%6{1HAV6&o>&;hvTmQ6+seUT${c(l}~w
zJ)a#DHj8X}t+tp7eNxpDAPf@@&T_Z|tF@T-=p@9%#Tb@SDsoL6W;DB(D?q*;YK;5f
za0pL2N=vGHMrqo<OP-^=WNJa@+>P}O^5w*>KKtzJ>Um~rT>^u}1YXS@d#9($rdkuG
z|GD94=s=e$c=^H8Lh-~W?CP`RtwsM34v?`=_Uf9&2)Z#dM@Is~e!_J1!_~m~$W|oH
z&?8ldAn$^^K19EwmrT5zCg@K)1>cqEqQlx*e-nLar_*nYup(>kaYm|PZ*o5hq$IE6
zoR_Y3Xfa^_)C%&{Sf|-+6i!McAAHqqJuk+)Vi;%i@IG{TbTnd{%ph55R&PxyN4Htq
z=X&bHEA+L+<mbtarB<2_^9Z2!95C4X^7$~>PSwE3uqC_5*9$u5Kv)<QVA$z4nH}Sk
z@l!T8$@o{CIsf*3|6$@FO_5aMrE%BA0q50Xg5!PktB3lz)G|pkm*k%C>b<Od9A42^
zw)N7-;atlhx`r666~wsN5+cG>1ik0uMX%G&d-5tD19pz}tdUkpS?BkYsbtGaqnFo|
zQ3Od@pRqE)&zH>SFOaAswiO8HjLhAOf8G30jP4J!$!E(X=@y?LiA2-z`PJ*|CKnO0
zMbRi^!MdmZrw;b>Gm);FSB+%7@}qGYqGzr0tBK-J^~zeLRRww{c1_;z-^JrQkLhE5
z0>r+uma3EKd)cXFRyG5#u?=nk-6?xUd?>Nh8}&=GHt14*)^?(1vrMDLVXon;^p=OT
zp%~rw`O9cE1;3LsP}KlU%C4Nw3U<*yjFcX|@h|&OIi!W7n@9CG^j(;yr(=B%`s+y;
zkp*ATPK}YbpI%XCDb`i=5;n@iug3e~fOba|xa*RE2{kJ&5Nw3xaD7N6eC($>@N!Io
zx%RI_CpmvBU?!2~qtq2*DwFio&sfwrWL-zAIl0`%=iHTk#onr!!{M+V2p<a@XK!N)
z^I<KjM<Vl*ep&Uqw-wjU7bX4T`sDLp9Nx0ZU4ylVv{w<aDS0>g*t#)57ByK?6s$%S
zFl8-`82f^jyuQpxu^{f&EU?{Ki{47~t)M1Juy<Vv1`=B(uIy*40f>BN9K2{?I$y;h
zbj&rTU*|e!vZLCRMAfkC-S~Op*0rlmS?eU5c#E`q9s^Q+<m^r1%yFjD*tUN`OHms0
zlf1fXTY(^Dp!tFsEArSM0ybjIFZX;q@jD}Oe8)GtCacW4*kQi;V=OmD6zA$f`IPt?
zx#C;BHlt{P|9(eRbDSwAo%L?R{Qdmu#xb@&vMtAzj!ml^c^_lQih%2e`|E!RAc*t1
z5T5em+J2?Hv9QYrv$XX}zyjuZoW4$id!6t^V&fk!!0Cf@Siw|f+WZ=W!AEnUL!{!u
z{u{O5%D>nApqnYN9i1#$af*mPI=Wja?<+8(QC-msXvE$4M7-s%XvH&n$$H_}^)d6N
z*)Sr1Pl1IkfA`+I=gJ)$##iLORdh7PBE{{9kHgq#S)A!;<GGAC)*6so^ES^xRqeZD
z)Y}0Aa>Z~{fE)|4aWmTa;_o0*=wr|R-Pj{u!0m1-Uc4uC`&gFbKeL5ATvMv}9Vr1^
z22$Wf;;+A7T47NayuK~^yvnIICYoNk_kL4sk^^W4&$5{-waL40!OeCH0+B;KSR`Td
ze_jCiwm6ibE^W9Ao_SpAYN{>!w+~$=qm^s3FCv$&7(NY!1GiSk?V?I^#>mOCZO+*t
z%|ZgpnCJT-dYfUehldnyZgsFp)qfi4wQ_;}=(RNXP#mqfj9np4r#Z%gh2u`*{Id7B
z6gZOmzeVidGsKVl3HNgeUe<VhOTFCV73#nJBlOfOz>)V{+bCz&(Sdl=?{mgM9>TNN
zqN-lWG%UT`(gLZ=x|g<0q4*ZU>DYa)NIxQ?6K&|8q_(cp_1*MtOjKlr(3}p7b6t37
z99}DfpI?5zGTrfh!&-OTY6XtpG{mWZe=ennQz7qZHiU1t>}*t9&?a+PLgk#)evvid
z=@cM??Sw0(LA_x3PyFfmWc(52)9<5vXG>!<T(WgsM%e+Dc93S5xViZhCBBH@xet*|
z#%R@u;pxLEgEutH{N<!b62W|C+=5{w3e=*R$xsT}p+-#!rQ)CroQC6B0>PLTF2OYm
zi6PsC>=^XtjhZHlUc6Jqn78){yO+}DMw-dR4P|h~KBJYdBPQuSXE=-$BxgU9cj7RA
zNKgg%14H-)$#s;i=p$86;RH6$+PaY*RS);~`2J0453D-kh+EEnx<+2jE*^ldmc0)k
z{)ybi;`E&a$@@b;3dR5W+N*c-GDp6Wnzxayx&R>vMOS;Ay0cW*+R(Do(b+H|fOhYr
z11G6I2h9iWjkS4zEL$zR#z#f`VT{M)^bl{G{FDCI?8D5EUAjl1!>!{p=+I#7WS1JJ
zoU&UL$~QH&>Ddzzypv2fH)rsC==l@A?a*7~yLzK$!_OJNW<(A5Pb?o}>g=V;(;ok!
zFfu8$wF1{=*Kk=6uljj^GhGAxBu%QHz$OV3LYm_>Y-{i*tld?L=g|OiI1q*EwQHJ#
zF?O2Nji!BtYmR7AJTG>=O?G_UAUH2RiW2E54mXA#RQ+3sp_@76LFXDA`I8Q>^*6g3
zHY7Eb3yJA``yWFi&Ps6^iVygh-K^7;0yd$1GUGj0tgZhb$f#da6d)-yxxWcu^3XV~
zgJ<`Imo$Zn(dZ#G9?y<#mD|@o1SWQbD-k5c<+t6uWyFB-9s{r7^2=mBrq>-U;}#XB
zsgGG&z~a|yp_5EOg5UDaHa{$uE3rvx=l@jZ-7~edVMi?VtrGSf?Q@M#r||V$`h2a#
zd1yywx}DjdQoXAD54(O7o~e_=&G_9>z2}7or@&DLKN_ARdymhyM|4FQ`s&?E*SjSj
z``lI+;2;T!W;Rg=mefW59+VH>W{5gy!%@3&$MYW`aEBQk+#S-X+Df>6DGhxhFFwL9
z7C+|_)p#>|IJG=mV+{4H8)n%t3smYl&=`Lq>$h#~eQ)V9OSn%(0oTgVAJOpi<6-|g
z1IXMpFbFw)pcpYB^u~gHes7sb5t#F_sosPqpSvE(TwJK<)^g&&9OhA~=Ydsf#qN9P
zQ9V)u&#E^p)-$V3K%lnx@%#1YiT!f=ADn(JmAc9l!sM?NuQXGNNm&}Gd@7T&%F=6m
z1&-(fn~Z_kimqjP^p={vsfBxH37RW@A4yXW0^d1u&C5JApbg}`wQ4!PnqpDH(S>kZ
zvN1J^sBxa^s>}v<M$Dd$@2oI37<>$A^SPw0fEtIyZg9r5W)L2Yp{MG(;W)}go^R%^
z{kL(NT}u-9$Bn=o`n#GrwFlGo#CaCoBeMN{F-nrN=S*Q$dc-td%W*G_-4+v4Ij_bV
z(EPUbg)ZJ+;*kuGR+5?FZCjZp|3jd0x@A+En2*ssb8e{Da@URlo)chL;!5t?BbB=W
znb;2r(ZfpboG~)<p8CyKGlpjSyIvbAR@?U3qAX#ZS@n`%e;y^}+vu$SXLtYpLvw5m
zp1+?Jj-!s_X&aeYFwR*a3gBixUVs;xncazBPXR%TxtMLTcGyq*_-yun$AY?e%x(qx
zArQ`eMI1P$LDpBotZC#QuCYD?3xhG23^2oGV8oy_f|?6`vl6p3gr!|5bxM+YCSzjo
zu&R(}@LN})X~XxEl?M*XJ=TWBS{S~3Rwog3%nwoGW=FbMRI296C_g=?`8f5hl6)!W
zCjKS)!o&EU;LPhH2EV%SMJ%=$XW*JTPjRc51<bw^V-j5;92x(mC)pqGy$aYnT`4gZ
z>v}KVa&;2@T=KJ@rja{jOeJ#bHH9n}pQFtSl{^E>GyF_u-**t!-A-*aHxuevQ^9se
zq>g(=Ju53DBS7%CGOLZ7K#3SO*qd;7Am*hH3avnU7|g;AEFCC1x@xMdm{ms;MEK<^
z@jKX<?1;4Gk5*NZ)?1;wW7(zQJ=y4p8II<dz@^7W3V+=L?$eLu8J<WK`~cNcP<|{c
zu$nu@#tWtv-ITm#rs_rVLz^bGss57$l5B(XivhU%VS*XT7EkzrU6|+dfG51}=Yo9K
zU4SR@?k==D2Or6C?##bpoUzKclD7dHH$1NZ%|o>(yOQm*I(H#`pIh1CkvJ1~Iz>ci
z%lK)4Ioe=v7n&QYsAa%YmMlNu5i?K@`y6(4rW7mpmmUy+ah?Nq?c$Jom_{9rFuRLs
zY5xY;_;#I1ALA`Nyxq?g0xnN~WQ%|+8@RWMw0-_`7DGNQ`&DvP^9}|-y8miVJXDQr
zw5^;ht~efLYvC#t>yj*`2Rw>>D8I>-0hx0KbVV!!_nIsn9Y0o2tfSWmm59lqV2(%;
z;mgK%*r<pWe1VmMe>xLD<~*ha;VVhga7Qz^+OEQ9jMk$~`tx!8RqDkXaz%Z=o-Ycp
zfiG3fk%|Bf=wV4q7#)zYxVuN$M{<s$LdV}9vyDR<Wp<+Y{VMpQOs<drsOoBoL#v`U
zCY>l*P<80W7frx=q6{Cv7ZQA>*76>v!&${;sQ!Mig3y{@y>^rKo;o|5i}w@HE8zWm
zOX&Je;qe|8IczZKz<slW?$*m-e>ppbAMGvC(bz=IbG*)ds6-cPOxH0mX;RLk;zur_
zH>(V!uH(&D(01~Lya^xFf~Y<<VT2kTAu4|Vbq6L`a*SsS$zA&r`X!T?E|>Y+i=DL=
zp&6J}5Ce<)Zna)Iv$kS`<?a8j#%-yM#>RO+h?j`*Lx%Lp<u1xm#;KJ76&rWUHeEm*
za+ElqX_w9Ec95s8w`&9AV(rsBXBQpPLpAG8vrpe5hs$0yux#jvxw_+&O1o5=s7@UC
zi01V7w{|WHbax%vd+-@ju6uDvRYkW@|7c030Qfp+4+N;H+r?i#p`XrW|H-EH)y;p#
zy__clLXD7s!rT{hk5_T`gRhb5t8u3_CjH>f&(46J<gu6EH(v|hzbCPvPki{wVT^2V
zfVt%_hky+AAx}Vwje5|Zd>PPR68CqZ-T^QW|H)9iAcM)<NsNuifxe$ls0Hg&LKt4r
zaRNB5b!4OztF$#lK~zIM@8|v3^srw<AF;N|K4)mla1i})c;>lre}l62c>S=tkK_}^
zM&i%q=Lf&%@W9?V7LKz{_(2W;ZW6PG!G6Z6$+9+7D6sF(=f<uo(mKbWnV%{|2&2YM
z%Rc5-ykn8NqTcMwB`o=$u4Vb9fV-INx~t*wUb^|3@=D+DtE_Qn+e@t6Osdn(_+v6J
z4M@PQ2CJ8S8sjxDkv4Dqw&zoL9@uOv1tL0!s15PvO~S5QADUOqEWTA8UvR>(|1R#X
zh#g8yM`5LDcv4&s!RG56<9Z^G#gKSbUvHRn7wk5H3A(ua4UKq=Tss=vvJNrnj~lzb
zFX?lK?+q*Ba`M~VtQZY?^zN}_{kH0Dvbz^VSs^wC`$lhi3Ix)8dhghk=+2%s8ShXW
zNAH_pl7Q^W*0if&u|?;28M#~A`fepSjHDhFt{pn;l;D+z)Sul1Klr$<*Aa~I_G*55
zgo|Rz1m?~`YSJsctLH@|54g+IwaRKLex0j`hkB=@tQ*d!pk3)eLeC`TY0Eku{>UU}
z5@?6SGHHc@Xm%U&{@Ja~_x9AH7LRnCX+Cbn_0hT`n(v}5SDI+J6L^;D){lI}?@XX>
z%T<sV-2oyLvMF)W>oT*yhl+aUyHzw~jmDYEzVq7ti^85(2;0PJ^{M1Ya2$tfu{vz4
zQf14~YoMN9+*k`sZ?-#)!!&nWq6HbjZxBt}M+Mway|0`2$M1;9cUuw}+7x58nWT&H
zqJvizIwYP8Q4LDd2%Wq%V^m5%O}$?Z>#<X(pFi8tbXC#dYIdZ=?4w9g@=9fsWg$5)
z`jtsjek!OpSTzYzt!G^CcyVTycHNeLRyR#zUq#Qk%Y+8Ar@G(l<P5+}R*d17(`nb;
zLU9J39sJ`0IH=4rj$cZf@M5g6B1QEmrIcCQ)l>brnoTg-18h=@f=1zcW`^J6k~CW!
zDJ8m1H8z%Z!dRIM)vs9<+-<n1&u1NSa-;7`<FX(`tm*^lI~{Z1LXEGZU2<NMfD+w#
zkb1fZAgBte?;e5`;@#C8ZbCEumIl2wONsQ$d#Vb#H!EU$i{nZDoGuuQ$~ODrBN@-q
z-c`w7qV)OpqD8$Sb&A=Ayr#~9Ux-y|+8mrs<+3g?H$JCjf?r#mklC^%myB34XAAKt
z%1p*ySSFFK`>*`5Rfsa`WiNBR0ZVZX%VIM52iAQrdyIc%01l~4y~FL4lM$djsS0VI
zaqE3?(x^-Hu5~irzu&Jt$gW-SM<(H40=bPc8vljP`y~^Wjdor1a$(xg=;WJr#Ww|Q
zKT4&vU^W7jMOYF&UY{~7sN6w%AES49*)nu)^pHp^6u-emS2LnwxZ;%dzdNdgf4qm#
zz#b>s{;1F*1YN^dj{gx8(jq=b7AB}xaJq3Mz7#Tmu3P-C=;aXKP#Jqlr1VI|=?W0*
zf20HfGW7>^ptz4Cs3)!aSH#}>XFP#LK}v#9O9pJyj}lHQIG(ht`k0<S|B)=xDvlCZ
z+T6;5TXop*EB=N5dv!|6#?>}+7u|4d_&z27V?|J6u$syq>QT>~2$PKPCZjk7!IoG*
z4Bq-n5E?YOgHcW}x5hsfh9%JoyD*EXhz$rSm}SqUeq!^#P73Lp&i2|B7ah%=23nid
zp+t^)jHudDP=o+UtN-;3i`gi@%_ZIYS;pWz=zleR12>s%2(Y2r-g)KfL8kf{+!TXh
zkHUujSC)v1#FX#W(q;gqD-Bn;y0kG#s};Oa5S1OJP82WW|Cv|{KhX<KLRizlm`Nx~
O3;?361+G%G2>L$+`!gT_

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/Torque_3D_logo_alt.png b/Templates/BaseGame/game/data/UI/images/Torque_3D_logo_alt.png
new file mode 100644
index 0000000000000000000000000000000000000000..3836f1e7fc26b23ee299fa02570bbed343d2cb50
GIT binary patch
literal 11616
zcmXY1bzD@>*Iq(W8bN86ZUI3;x;rJLVG$|m1%ag-B&AClM2V$YI+t!?X{2H4PG7$M
z-hb|$J9lQzInSK=d}f|`A~n?&@Ng(_0001<lA^3O0DuB}Do0~sJUy>LZ!w=<=r&Sn
zQUE}8j)kh!)zdefm7=y901!?H0K^aj01r>)Kyd)Ta36p|OaK79+X4VyjW!Pe`JM*j
zvXzn1)coY+?&S8#$(c?`MuyJW)#;<HgEauaI%Z{V&gbmz;%ZH7ZVn&eV8e0s)Q*UV
z(KeSD>*(tk24F-E^gfG4K@q0|oBEluqp_QV%&)<CvV5<Ne?Lp_m84iz=4NF_ne-2s
zV`ZundiALgB|h84R2x8QlZ6I~X0#4QP)Z{6<LPYZ?y%xVQt>U!P^y#YkSugyqHz+*
zOY-<z_t%+`Xb$)xTxgc5g?a%<Yv)m(QqDouF;=bDwY9an&Z+|%%I~o%IJuQZxb%*P
zRYrN(;XKNmN@^%SLK_L5qtoL^(HEmkf65z>v<5_BV(q)p3HiS29i{6bq-&}zeNINM
z+81(z#lNNa`t>!BwYm9CFd_f0wYkCf?v4(L7xcv+;T?3}$2zK<@Bv*l8jru38`+*f
z#&%XTbOQizp8&=sMwwjlyML;raF;W1*Kzvj?rGs_4bZf({p`-IE~iTe=I0jR=6(J8
z+%*pX;P6zEmD2SxJup%EX|3RK(ID};;qIc{tbGM?R3~BHzuWPKRcwGRg~5Y4lA4)@
z5F<tel?@oxVM$y_7f6U^)WsWYE_d2d414J2T|$>etDowDclJe)G1k8z<n2M}=R1bZ
zww9RAiXBb+>t{D#eO6&wIMO?q_j#Y)I$AORemiQ`)Zei{_sd0{zJF$UCC3J>lq4Y`
zIy#C}M@T@VuPd<*epeC^*?$#uZ&A%Y2n$|acdgcFP?`9h3=|AGjsJD39YPe%d@b2Z
zUG}|&|A{_78WXRs;)DN6g<nb1VV<1RPj%~-0kN=9gCt2&OHzLyqIP;DWbQlBwfl>-
z90#*(ryfP^WtC0noDFTOkag{!om)ENgbswf;e`<Dz%*i6`S70Ea{br8Ll0d(VR2B7
zJn!bw?{PIjMHcmFAI;v3+HFR(ruNoIwwv_eks~7h@$XgiA5Aob%Z?`Ln_bnXc#3II
zWZi61e)}zL-VfNet4++yefZ%kDaRABIPL$IXxiSy(bmvyeX;YVodeIDn^+|QmrBYn
zWPuuSvPzdh0Rmwvi#(wcm@XBdcxYv!o`rRI5x=P@8x~<X%3aYmlcJ!tJgbcQ<Ld7w
zL$nk9;0C9eu=}|LVN)5ZHUYhKEkmogA#u`1+hNPuC<!xakJA8k1mGXieDvdT?sVaV
ziTm0I)uEjQj@$kgpZ~^<a{n5!=CfA)x%?J5MhwX(;9LOyVS1ihc*^jB?D6YY^n}H;
zo{40FZ<9P_wDd5>>%wX}I;`^$N%9G;^D`1|>D$TE+dCQ~s+M1(ca;Yc=f2o(cR(2T
zLY0FO4?&#f`4tDr34P|p`RT1PwnP3MAv8KnodV}+jx?|WBIbSEg;OZjI&2NkY?_n)
z-nIq*jbA`!z||XGXi>?zRk|n8<ahiict;OgoYLFCMGXSHMRk{5Wohm%5-ZJhk#l!6
zk@6C$w)Edmmr+<5b4=o{)Pw4XX!qRN6xT%8>fe4+cgVNapg>5OeIxL{?k+hzxZXa5
z9f?P-tlZ^X;pa;wgmq#qy05Fb**P@#J@eOTFZk??IVnl_iST>rA;~(Z>U@7Oypu?2
z5At{x*xe47t9V@lhUz2{4P^=ykH?-9K5X`|>{*niBUeeKOs`h_{|0Z5=E7cPDBYf3
znfa{`r}J-1#;`oD_MET=yrT#-NM_)<ITBYw6ZAh0rfu2I3#akkXxh$&k%|a@3a*b&
zIP2|sL&H?vy|_QgFnyTlHq=n5N%@Y3#r_3IRl882KJIb`EnFgjeYQl5%jR+Y+I1^$
z?7B9(jGqmJx!{aZX)nQJQ%fDZ`$8a*+8wnsR76uBB4j{F+fX1g{bx^f`zUH$MTjPz
z<aWItlaF51j@XD|Cf?Se3-^q<$Mo~C)#fg_O2|B+rIWr1usLo=R?=p5Sv7fg!B4SP
z#r~-DF%q<L=}7s(DG{!Y`0Zh@_C7?P1R<456<hnD$?&IJW>C%>l9c_K)|A*ao+g5o
zISALIbSF6JJOp`aN@JFR{B(qr=)c<Ak|0)QWV=|HSh_(|5dQ`on+6jP;McEaS^6l|
zP;`|CA|*u(CUHDs$}Y^jZ;Jl*@!9Ty@R(o~9J4|d7CK%5!%bLdD$WN?AaxTps|a!7
zl$=mxaX1nliSMqUj7X&{x(b~a*$|0(T?VoNzRN<WT+|F4+%b!u6Kqo{8)xB@%VrX9
zh9;Vn{;Iyv!6r~?tA@DMseGjhK^8|KQ)VTmfiUt!YV#1l1FLjJ(XbLTY(jkbw~-@j
z@I@I`<4wl764<$qUR{expaUh}(T9Xui^4Bj>5~*A5$t{&D5`FW--+vCRZuW4rn4F@
z*dcA*v$r06(&fa9%@t26y8h4EPwmJxJ^2kt^%<~;x@bwF=)8kBgev`ek~+8;D=wDF
zm-E?OVLc=vyORG|CuC12_trgTO1_pXQ8N&WznJz3cTXJ(zrB^fNR2S|y%1GG^DPE)
z#vt#AM@v)UaSTVu70QIZ>bV#$sKk^{ds|oaE>Ryx`}fM6#g+{|PZn1Cg0Tl1^sZ1{
zUidr>1B$lnK7LQXL`L;a0w&a$ZO<9BaV`a>qtmbLZaPAjl(ZBd;BjutQ=gFq@9=zj
z4P*~~V|<rQk3X=@gx*5}oU$eZO3_XRXLB1Ktk?u1h5CV{D~T6u(1m-zK7V-J$H-D&
zBt7)5W6sqsj4|1kUUU`F=JE`iLtLn4mQ4-p>`+l8B($j6b@B}3q2UT^p@)(J??MSY
z_?c3P9_PFh^TOCF_|ve0o+@={!GRonmTaay-eg#D8WDyMHe<|h3XyK`G~Q8B0p^pe
z`-GpFt^T&ofa5C&&Tk)&(r)w*3u7=1;G=IT%PXn<aHddwL5SCsvL{W<U`HoPSuajh
z>_`*v+A`G((kD~7o>WCjJb;A=jSZOgq?au8DT&X<Ejn3Yv)GJXPUTlg%(jpGi9S(A
ze~idHU5fq@h%`^dGn<{R<zh$yiWD)VWI6K4jn7!e$%5Oklv*{>kFm2(;P$&bGS-cI
z8akj7ha#2yT!-w0`y5=%-zzE!*&ME{O70?Sh^!V3S#-m?_-rnYX+c|u17(tIb+3A+
z_bYHCps1cFeHRvr^0%8T#?l_OXWm*~I{n-iuwbbV-+-b<(?m&LgrLGAzI?1qor}mr
z=4_-xNUmGls6be~n_t^Rws`%msX1J`R7GR<sHqZ{!!~;8x8XJQUFe|2)GRra$|1K8
zj_($n7;`x3*gd-uJ(5lg3TKib$)j_HC&&E3&F6xiC`FWpB2^931ud(Xp5MsVw+Z!6
z*I19=F8VPfm^|N`><bH^$zCnr5gyObgQDpjAcrj{Ot7If)HGKnv4gyM=bNfiGzl8$
zT4)G*Q~_bI(S}2GqkY6nhqI~es-}38Q5Ks^kdEu%!TO!LLVGe=s4X*0FswHpMhvnM
z#oVe<O|#;wv!2gt+yDM$1+=YPUwsf>9Pb<HB1JnUeuX4}DdIN6+zFv>^o;G{bjQ>8
zr#FiOY~wZ=1NfJ9?eUUCr`h!Dgzp>B5$Ts9(qlDpuXYgd`mAl`oZV>TG#+n-s`3<H
zH5bLXVcSKBU{l7yeeS-sEg3xa4&%kFuLjLH_KVlImN%OO$&<_3zJFL;IZyCfelMGh
zt7&L0rO=5cb(am~&0oGSQTfFT)uD~+Z6on?$tKZFTX1jq+B)WEFdY*83FJfM!c{kl
zifH0S#d>HBYn_j<O>7;QQXn&%rhX%ClT<!s8;1;_Jb<)Stng+$;F2{BsE>giR${ak
zC=1!7U9F>=xr6XM1dT6D)Q3_IcB0Z;#WqY_9f?XgjCA4L_rOoHEo{P<b?0(J4pvtd
z;`Oh+SV}(ENP^w-E?0KIsOwp2AOC89`OLS8-v8}p+xyy{Q8YI?$!cuV#qyA2NcKZT
zsS#WqKI$2pzPDEFN5%WH9R=jf{=VYZ17|!nvLy4pUxCBO;|OdK^vy_oJ0z0~diEf`
z@+N+%f0uTFiV#WyRXHJAl5I$Y_}l8i)ircGw-ce<)?3U4i>ErwuCRl`B<d6knUt`S
zKqMm+mxX_pugRV%_$<BrJy{kv1p6TrEIaGl=)v8vTq6xWC{h&(?)STx-!j-_W?*XH
zXTHlwqyt2-?RH-rcds>z8*aG1u5K@nEABJ5Wq`F2-0qL|)Z4ItuI4c=xlXcNUd(D`
zF2=TL+%P0&{_T3gd3gdG^RG$Nj``o8@g@s;QH5hRlz$gNn7vk4M$lJ|gjD4=hXt5|
z+OABW=3aC1UQ$`5<!^IxS~c@&3-_64Sg)$AZ|`Qhn=Sb7eDP(eRCATdH~R2^E&g5y
zC)^MyD$-SblPx{y_3%Y7Mu#f0QoA^Ks3KxOUtB?q5}#XoKn+|q_Kgk4!HS>7@hYep
z$c#S>v7Uo3Tf^eBc?PHS2{uAlf0;a5uXM7swb~rX0UPw&s;@f2B3DV*#v!o;sf^8r
z(a3X{e6>@mBlA<*E#R@&ai${hxnU_D%JJEbS=y!)sysje>g%^$JVSWw1rH*T$mS&m
zqUkvWJs41MVTD!a*e5<=<mLnVm^Mfu_wi=o_f7AWb!Q7Y0x{|q%BTxM`A%dPon`#+
zH2jV^!$z8zDE#LG`&*-P;Yd%bJs()!gqx`HduRyqdf;&AOoejnX!(p&&i|@0=Py<J
z7%`%*ogm`xSfK5t8(4Eb#eCIm!j-IBAg@092ZYLw4Jt$Gz_6LdDm-(!Xl2D<MH`fA
zJ-o=ETX{bX#}5f+8a+bJKZtOJ=5X5XaweGgAW{-_X-0xPBH^Piq(a)(Tv1Visvs{G
zwtqE|B03MJD*^5nsdnv&H#@7vNxFiZo1O91HHf{tL=X^`$bnN#{%!n=8JbIYjM<1s
zHRf#mno@J<U;dFqYa7=npqQ+;;zu@%S<WPC?uF4H7dB|kMR53B9ZyQH7qMM5mG4!T
za$@#=Z)bScg26no<Z7u5P#)OqLmlE-IcCsoD(ySKF4+BBL19J2SOg1k1EevFQ`}-?
zD)gPIP4%=mdTdbUbR4BXSRf2wN}JO6SRX#507Xm9?+97)qbEab?tW^(`}}R8HAGUZ
z!WPEHJ%8LT(!_fskTfoY%SsC%Fa!#J`$LA7y{QO-KY1m`e37@_;$Q^l_IPu@khD&%
z*%Qt=%r!xiBAB}%b|vR;yCz`s6?wjn>7MpiTgZ}zOF5DH^3Xx$BNO(RoIAZ4h*b^z
zQg0y@Af4K8e7Xu^z&gqgJzoC466>j^K|T@M64ID&K3n}PuD{=qX;U=PaZMVm-iY7`
zI9KPXgfysmN60?q<w`e_S`gJH9f`G&`?0f*5zz@Sl18WbNSJd({Qfzeb8$Tue_wUO
zfVvz}QvqfsHLn(Q{}~`;n<EwOAo;BD<9zqR=_LlDLWBItpt;{1Umzqg&T=cw&PrwY
zR9KK6lo}-NWE6EOKF|Elm?<Ut_+vVfaPuVAl;PJKM4nNq&a<_S1h@7t-6sg3id=mg
zz6qWpZ36Xez1$%0_QrYXAo$@G@&eJ%kT1GsF#4{<YKI~-Efte;&Ai2})u0JD{W3op
z&K-?=P8JnHb{nw2AVNgn1$*ro@G$kJMjm|L8{F`1<lFbtjH~Y<y2xOpFE#<e+bn6-
z$<RkI-nPSCMuRJ`dZ_eigT~?NvUEQwpkb{3p&thfGgXX0syAVc**Hk2YI!UeC%jAi
zCT-@dI+k|p-4fksb<3YXeYKRv>*;XYavySC^kF|yMtqt19db>~&1((4Wc11UEteok
z?pK5WkuUJwQd54LcNHv)lSb%W>D*YCYpT7HswYjgEGF!hQS{u&b*oxG@`gC4i$Dm?
zX?6L+QW|vi{p)egO_BulGP)&u6;E$^Ghg8Qb~+PCY?CSUHRg<OH<fe3kG=j2Uh|}>
zT8rr`C+?p@k>8yRWx9+$P{LR#3^THFOVS0PQ|;Wm$)N2h)nh>Fbp{}-jzhXy%=~GO
z?^wqDahISz$XMD`-gxwK$lojc;C?AA@>u$6M|B+pgY*?W9XEIp&_QN(u}13=VuZ!J
zPXtFY2V(D<ZO%}*fjLajZba|NewSX(Mwg4Ky4g@#GqHFi_98(^V*i@z3CaZbgJmT1
z$L}yK{Z`iN#W$9FB#tI3uHsf_>qqS^E?f0iFR_pEk}3PK2nst6B!veS`nSN@-)7Ka
zG*oko=AGl-5A$m_tGP*?Z%v?c_PS7u<T61E9-2ixd``Z?IIV1fqC$g{BrowZyQ^>C
zt<vSEL6Rz@c0`|!kO*#7bwiAes8iFMJ^f!3OK9%J*y~4`0FpDwIVeA5OU)sBy2yYY
zmNqfEfYDGjKEmO&7fWHLySn3%0*^H%7B5*);UV&LF>jQU$4khrAf+mIl8&rgpGcLi
zHtSOR^R&V9vvu{kxoW#Ryt|vm4%yU}Rbb;`{CjzW`7=bp$A?_!!o5x(d_9``&6`fR
z;wB|u;jrFVu(_|Ie#KV!?4h}!7;WPG09MzeD`pdkY;)b&X>j+^sphZm4<@i#y3iOD
zCkyX#Ue1eTHc?Ta6DmwAk$o%ZbNt<NEtTWfQZa4{wc7fCt;8+L$qh)mzJH_3?4d6D
zIOuRZCflCfjrfcqv}55iaFtNXRYIcJ<=5KLVtrq%E$u-DPnr|Ajo;?@y@K{d8WU91
z)7g(-q?m`MB|U1Xr$IkGWv??VI7r8qJf2~%<CPnij`};Vbi9CqDW!Tb=9e5X*q4G*
zsHG}Ii^Ba0Av)<Z%Rp0WeQAZA=%#6b{^=FTOFQvDp$c0@yF}#$5+4Td4LF*8=-<~E
z(u*Qp_O2|&+o}>F)+`<lg{^diApoK!s$>=XE>R*zU3OelF?z|6D|<OjMO~%$R(f!J
zt*Xx)rc~P1NtZ#A9$2e>s{P59eWGv5`Q=G7Y|&YPH&Xi_lh@e-hH(%R<cv8^)N3yb
zSD7831=<lEUt{EO+UtsX=ch>rOm5P?WPmY5E9pm!pd#oKFtNo3^^lOk7-IBd3KU>V
zu1E?$ZMq$xr!i6?AZ6un9Gm^Ze&K1qwM{_vN;ECbEt*7vs0Sd`5ei6HBBu(u!cKjD
zV?ww?f}$Su=i3YmbA21n@WI~%PK)0nBKfIL6blwA2KxCOwT^_O$N?xky5@pYH7dp|
zHPTwrd~K)ey>7+l)PggGO49LLx$joS6?XQu&=#l_#PQ*_0xDwAS`p?Ff^Xuc`tS>b
z`i^?{UF+1_KZox_iC-QLOyRccj#fHqh$0|9W6RN2TGUGdgAzazW+HrR7mJgO&7w`m
z;N;HHx|uo?@n;@unyF-|70-Cp(-0(i6%>?RUwn4v=K8A6z49c6lQc!$DW`qA-#vS!
z-UHApWfbmMFVNVE!7*vSXvLX9>MFrUoeBwOc5}}=S(5HQF#qlfwsn065v$E0Sz42E
z5ceSDdJ`LweNES(f*J4l=NSF%+XQ_5+K_4#-jMjrvFlP1uWD>Tk$e<nM<Yrq;e+&E
z&^zJWy!bYi*-dB?{7`m3;4+10Ug5cC0<#9K;oLn^W6#E}SQxq=u_vwr3a|r;ZU(qY
zl+w{xgp&m8;v&+|0Xb!tmJX{eZgF@H@TPYLgZR`ePwR{Fj`XJNOhp(bh|nTE9s<V3
z=aE1Nl;IVWnw%>8PatvK`ZsE3qWCpLe1PM7Z}<)g%9&Ed)?q-qwX+5ci{#S;iPc=<
zi|f-cBWRXt-u}dR%`VpOP8n#G*0)~gW<J7{6pb{mrkQbGlurz5a$2~2i=Z)j`EGBa
zzI^$OJXlEoYVlC4-Qi${DO=%rSECbje_hSUzhmuQn^sq7t1Xq+jngcM%9Tt1R>&~^
zP5%%UO+;IyIwDirOFZr3J<G+b$?TNF=Lu^OVmWjrzhyRU@TsZqZc$7=`LfG>wPl1w
z!@#*S{Cc*Phc><W&3)MC^)}?|s#5CCLCzF(uUc1~uDSZ8N`&&-21chPsLUKfLRxFa
zSrs*KCi|Im@vnxku=qjhrNYI;S@UPA5B^BsXr{2Xh~bhIgUn{Ez|WJ7g-;CNk?8pZ
z=^xgK%f(KH65+8JHA;lZoX_evKO<$U6)~p1k2M5!z7d!$CPFOE3#=E#OEXS)PR=6E
zZS+nz?2g7v^w;MkDqhZhCZ{^71Q2Fa<QoLpLOW2zZ1}Z?s+Coj`~U{_&3RH{<Dbbq
z`i6r%x1Uz(X1}0eCW4{E)-!RAS-ig?WTVeNG%KxRFClc~x86c>LdEy*|0C}-MUozm
z3itTbKngzT{h}#6xoW+vjSyPUwu-y)01i8Bs=vCA&@>l>iD}~+#EU-@z7xRU03K)<
z`StO}EA7?(6w6*ean4t-j18j8=O*NxeRGyjhHVwwDjADUlCh68PX@KohA_2W>F$#T
zTI<c%OdWZB)3|@5Xpwsunhi6ZN#)6`rrw|+C@`ix+3<>(PD~6(vy><=oZK>TTFO)L
zCxb5JxJf!P64}Yr6pE>?I>(HF$p_dB>r<oaYi8q6({96C#<9BO8{@aFRFE&{`&gLw
za_FI%Qv>+2+GlI0V0N(sxq*J8-8__u)<(!Su6K$Ze?^I9ZdoDNZsj?FA1p+Kj8<;C
zbE)F-xFHQbSYp;1JMyteKjL6-(Qtuzj^c-rB7`K2H<t7vW23A+T$aJ^s8*%;Ys5sj
zTAb#Bs#UPKG!pw2d20n;xMn)DvGkVRr(DQP$+z=rO2M3!*6sG&$==^Q`63V=9Lz%D
zMDAjXS7)%<18)#At#hy%k75?L^{bT<)J+&lEL#!)CNhoCIS58hFB8tHM5&pw^3rAS
zF?n1Q#@OeC$o?u$EssA@`y%96ACfq&nqXqjMxtKRw-c*)ZJ3=_wUWkXrn{iT0y{GH
z?+!Nb`%KM$Z5B%&_{mo#(FD2RSL+fRR+TMNG6}-u;}vcr1RgUzQVk(0c<T@^q4%FC
zR$gWqi+Da%q#VHdhQhBs()s1VZlup*vIlNQE0!v)Y&kztxz<XBt);-NH|GKhDxWw&
z^?Vs!g@$!!a}ursQUqez*^TE4(NQh@ex<=b$*~FeJ_#+ZcY<st85ml@3+0l!-LnQp
zXy!-yb#M-K=ZOpxBT$@NW3TE7(j+{)7fW>dg329}Eaqa3=i2%OBSGQh38@W^?Tt+N
zltfEn#&ZfoS`%ve^R7F5(Q4R2mO6Isql_rD=F?xwxF39}i1*y<Mx?;br_5AVz^X0H
zb~Z<`{hWfaxw*+*$kx|q9GA~klf;T|Hu)Re(*@@K@P9P+sM?U5SSoK`FCo2LCP<GX
z<^kW28HBB!-c|~w?l6BvN<K<7Zq2J;<om?it1}L;NrCIdeOJblV%*=Tdt4X6N5iZ*
zt25l4v`-QImNNZB=sD7d0)!#)COf5O6&mV)L3i>`yjqrh%k*^$d$*>9-T00tpXuK3
zlq6ZO!6;;N&)#o2!6P!F0zV(EhY3Eqr3qOc6=q3LO5w6}y)cVHa!$CoqkoLFE3j@p
z#(7u*H4t>-B0}>`%pk65aXX{5>UAy^a@b>O%Iz(Wa-XM}1Ch?OJMBkvUt(j)$A#fD
zCrnEdlh$IgB?;6iFB?cJtcUyZJ|`Tl|7?6RVoD+<yEY!blv1CiRbECAV>EnP)Rkwy
zc=A?#NvFT+3(+nWWvW9G#Mo_NM#AsyE^T$pD**|J`_Crznyee?+>mfZD8IL%X}GD|
z;`NLwm=5A=d=;*5T6glb6|-3p-yfDrnFRWx21>o4=M&Bv4;MoiL<2nNJyI*U#oUsz
z)fz~(U1K0eDrt6&+NQE0NLO)zO;FO=JM}wHi6dakq5^T1>eXc3f?u_D`sXhXMO3nw
zx=+-MtSeoUioVGOhRI&bMD@35H}^)tgB(|WhVLbdARD)7HX@~f$mREHM5WP4)zO!y
z$3}L%yG8lUb4BKqkv)Uw7^2@TaoA>6!Fgxx7)GdJUt8_S*E-jTi5yn}{8_v<C3fkt
z6|nhc)l{~8o!ePyu+STVAeofSxXMP$ZbjDuYZYU3=PbA92G*Sk9qHf~u|+wHr^20*
z-=;%@IlP0W_$&<ej>dW2TO7RI{tVI&@hSWw`ZU^fV4rGh8k(3rKsJT)IM)s{J@h>o
z)vAm>mVCZ4U*m)}`qHLFTZ!O+zQ0j5HGM}}4ot__N*DC3daYL~f$}u~5qHRPu$Zbd
zly<>oRL^4mnQxFQ_bjkWW_eT7n7|(oRC0dV^xe>m=8dqXy0I`wjSrE&^@1GX(yrOG
zCED**41Y<y%o_D_fk*mVI2^4I(*|$*AhRygyEG2$d`zbi?4|%6Hja7}cl1~wP3W#L
zekRB;f&T0vaPc`J`9Mr$wUa{YZk6P{f=S21MTaw|^=1mKb#30noA_)Bg<Mvr6b8}Q
zrUTKd5TtLyY2{nh4|xvlf@^DkrL+~Z0@n350)9%7$~r`tIt!URsLfQ%zb<Gk)p?{S
zo<Ty(q3tMlB({2FpMSNXkJoK<t`WKpZHM5hm*Ha0W^yYsfCpG@M9J3>=UY9=GAY<B
z`tBgRe%=Pi0pAEm>Y?L}@OBjUg1`#ofLkk$ihFeJD+F1mhBMNd(H&7_LfGkUd^6*7
zuKlW-?cHeLv5IWH;g&i!UzCTg;q!W|uQN4zP&Y2ypy&2<XtP2KTcy$C_Ej42QGu@A
zb_TR@Id3BLAf{&1{8TIxH3fj>V=R*;;X+B->R>$yiHh^>G%=JiFX4}-S|JJxW>XW6
z;_nT`<fH~U0ye=C7>hqPTcI%;BHc91SawMtL{8yy8wXm>*obe?x^YwX_fH$l)C#F?
zdE~2m5UPWaCtK<d)+OY%{S~rmN&@}WDmT{n+g{U2D0KPJr``}X95Wp8zA?r7o6g}L
zL#9Pw(3+Q}%j-I>%{LCs99;sP7SN_|hvMDe`1~#VrxkcsM3^6B1}ZR&d>y$BD_zEY
zA`A6)Nkkj6O^hJ~I1r=5LwXmk$`y@Gs^o2vLGlyPnTKe86?+!$1`}B5W1A|}X{Y<7
zJJ!<r%L6m?uRJOA3*^%k{IXm3Qt)K}R=Kbbr9eAQg2|f%*;g+nSbOs>)xfW3<-G(;
zGAupOhqctSv6?V~o-R2lz%~r=gekL<t~M!p{`y48mq+VyTorAZgClWV&wp#>7`)^x
zKfUfUcf9tz&7Kcn^snSX3z0b`FU#G}!r|51sj^mFEy7*%_El_V0HUKD+5<ZVqVJ!m
zy<c$@zzE$3J33g{aoAACfn~Q)3gfF>`|?uVhY+OlS6zgk{KVqzJK;Y@l!>TXc(_>j
zvX|F?_K2G2?T*qn>r8A?W<A|)BieNkPYXd~!}IyU0$&*|r+wE1dF1C04=eH_ONnJ2
zdW2$w2ad3XzY>fRQRsnU7S-i(rEk59J14qdfnQWut8PZ9oRgr1DDm7cVWJ6vl44#$
zEEjtAENUe5$Sc5Q%`>mJIR(*Msb|e`XB&&*^q8>V{1_Cf%EK51&}#$cKl5(h)(;tJ
z;^X)|3a)yJ%P@+YZohFel1;e*{0W7I=oEd-DmMKu4z?Engg4gaNpB~xmG!3}(Ggc6
zrYUouvtDzyDGm1pcfh%{!~U<&|1ow`HtseISZ1x9d_h@;dyI;7q6~)Nha5%o-y0f;
zvMWsm2+?QnOFPL%PrfF|#a?(vasH;ne9jUhoiJt|3J-Af$0Ndphh{x~AUP>*BSicR
zcD6ddax7R-(AsQq60PtCt%HGxCHIdmv_z}#oIk;7hk7#&R@)=b33o00ohbGH8g6_8
z!kC-O2g{nV=2(6Nn~(|14UB$_vp;nvj4qFhUlBHycHqEiv!cweDXSPr(WL&EjjVFQ
z=>H*VBxEkjSe=k%?;D=5{Acgo3)wFeYn`3j3@u~`YVdCQohPu}{-h4gyUc*Dg%`u%
zbg?Hme|e$W^Mkh&Km4#yDk!A>+j#iIO!Y6GnRXS7*`uuHIgrclK0}H9bBN1kPq%`;
z5p^c@H5bS<0~88}TWgf!3(O@($vOBC;u0-=b^h@qzD5iKlZu1Ckoq?7@$>JyaPg-6
z^lHD9-`*^u)Evmbp!0bz$!)D~Z(Ej%ccR;74N@3Ixp4Lv_09T`)@en=4OW#;*M5Bo
zNg&I9cv0}tY0+LgM$qbHpo%(j?tCVeYFmI*fU_>*P+pmnErUMtag-bXcR#ih1n|&U
zU6zjg_RBz!<{+VB`NzJ>Q10B2r~%VjvR{NR)rTFU$|KOwL__2!SH!q=`A7w!nCt2~
zzo0k|U7l>XpW5a1PS5*rd%tOOTyo|%SGa|#QtTO)@YI5CUc{f`N!gNfYNBO!plZ?B
zk)*`Vu6>e**plgdO*uPs>Ow*dQ5Mp_wwCrOZQOrFxshtMuNPC)K3kjyNV^>-LLWQ-
zu~5T5PX+Wtg4>3SKVBRhI(WhKF1A|B3OQv{N-YiMjhLAU%i8=LMOx(>v9qQZ1^g^k
z56b;u7xH#Gau7C9J?64EP1vs~p0Gr(jt~an@yn58+Ec7aU3tD&@ETmJ{hN(OYEoQg
zwy+}OKFDRp0!wRCuEXx+{9PO`Zi&QCIO6ZO-0ZF0cN6b7r=DlVAjuUpz$oa!qT=;x
zU?-KLI<d`!;S-JH$+pm~$v3Q-&eRz{><Mb1KJnro(>>*8Tj^UKW@Nn}3Df`_NR{i1
zMtWhB`=5AGJn&`}z1+u7M)WYv9{Gy_sbzpo84l5s2o!a_@T36<75%xdp!Ix#2*u>E
zFrJ#Q?^?5d3l(@gB=~blb?%(vt5d9BE{L2`$(a!4ijS>CoeC;M<Ag7!4Jw@1JX^%C
z<9gO_>?q@S{Hs#V!#ShYy~&$DpKaxmX^;K`J!;>3YZ>b5#lht4FNRxtT%fB?;!Ed?
zJS>fdz$&Q?SW<c1Ct(4h5OGBwimKSKrYxlxV|Cc=OY+!O$<$@x*U$kZMZYGs<(BlJ
zV4mRh@BTFx*AxS0s^s38WV@8EHw>&ZkKXf@`5Q4>d01gg=^)Ts5b*#{CG~OduN3cY
zw=dD<(aqGLF^X+%C$9P^nxKFu+C`Qj;JHG41Uu;xGLkH%iJs^re=><mWOSJ+mzS~z
zf;xa7{}%H!)!nFS+Gt%xWs42?=NZbAz-BHAAlzLZ`9@EGr734Wj1>Q#E$WrL=Z|=q
zm2CC~Iq;p%=EV%nY^+vDI84mLck6ai;r7LUYNziM=v56eAWx*Lp|#3A+=3DKf^&im
zB0So=dpX6o)kfu=ny3`gpwf@Y!w1bW#DVN8Jn4*n$N|!QHVAi%6Se4V%pi=C-Zazh
zrfSa`tpCa;QCHFVTndD|rJAC`JkjAzz5Ev$sT@Fw=Bt%#ZEaXlRX&cayS&Js<2%h2
zW+DcqZI`<{F<Dxa{uJi!;hCbD8{U|gDL%sPB(MH;Jr4qKp>fCS6n1ZP2US|tnD!=j
zvw~>tL<l0PDm8W$QstoKaSjj%YRlS2WzVeGzLdUKW&xFcPgO}G|3*NkA4mFgCGi(#
z3Tf(*2cw@Gyz2RRuFh0CbXobUaBz<(k;{akyx!WV&ahr!jk)<h5!N^Qagb%u8{M);
zQ$+!E+2IJqaPJc0Zy)`kKQoHqJJuf?vxK`M^SvSu?I`Fc<epH8q8pE=PHEOnPpkC-
zS+KXVl`-#nbB;VR0Y}TC{NOqJaB&f5aSE&00tz|i68C>vF#tL0NT!6fV1;1Oa`%Q~
z=70;WY~dtQm^q;~k^lbc)cgHxp-YT_g@<B|7Ji0X06X8)q)8I821>4X#3hm_D2Z^7
z!(R?$NJAMi!Fz(*?hWNVFO_KjMU90Ti4}jAv%)!KOSIegvvzn?wg&pfi8z4}n`4-H
z54z9!Jwo%JI?GPM{5lz9zGi_lQh`9odM1kcv);r3<MYb0_xckm{}aju5MECX-qtfq
zJyT*2PY6jsjY$+>43_<)I>BJGFjXL`8Sa%=n4>maRu2ECqmv{AAinZFCn%HNNIg$L
z@ES(;7@h&v*oCb33s+D+@Q>za{^J=ru~xkR!Ut$S3UjC_lLUG}3Ov}2=SKYpb}1-C
z^#3173zm7iy5}5e9%F8F<_oBO3Lj6>(&;V!@&u9X|2N^p(sYNSDd6c!)h4p18JYeN
z7hbSpbDLUbTgn}d%>AEJ-?31IFvBTzGWhyWid@x}P2+8eWW4u4X~|8IE9cbTkFfQ2
z_5Q^xjvi*17NIJLJGQnXzf5!QGe7Y8<twwk*I%&HoZRIS|M?ySpnm(k#-pGVzc9qL
zdpFr5rN%O2SWFf}X{E0mQtI6HdDv9gN&hZB((lR3*D6@6jVR*tKavY;JVe0Fi?%GH
zjAbzh4$xbbxP&?OC(>1b;q`|$Du(7IDj$!*Ei!~-`72!frH><~_`|Yc|4bSZz2t(?
zm;G_g+lfw&?*p;WXpZ4vBpn;pq+$yaG5pgX(x6l1cb{&497vGlWA+z>e=dQh-}Tau
zsS=j`151?+wI~Arc;x9q&`g^FR;CV5pX`?zCVo=>*-8RDO@Kl6$p>Y#LFrYm_H8hT
z1qnxN1#7smHM;LfDF3A&JPMGgPUzvDl5C~FwP$=pfQV|kEtC5!1IDqThkd}1KmSif
zxGQh&6&5=>T&EP9GGFhKT~tFaWDink1iI2Bnqd2u_*_PL{PV|vup<%VwzdC3Xk}EJ
zb&z5orkM*-k2S1m(D+&8^pv4#(&&=rVXiZ*-UVnQq@C#lzi#lfO#7^d1kanrv$n77
zsQ--czFhNt|I0hd^xu%Wksafa%unv6G73M-uQ;m}{i`Jl`I2?p0UI3PP{u}mYPA|I
z`EKGu##I_@&G2dE3**JV*h(n^C-|&=cR7AcdK{{RYoqym5&rT<z34XC@8AD4Z1fL4
zUq&96^em}pBv>2GFprHusRt1<cxb<pmTF0S@Vuh&|M{?5Bc}N26?3KgH_O7QJ(xi|
zL^aS5T1Vhpr15Xn#b6mIR$`qD6Qc|#{yK&K^GTBlm15UX-j|8gkv5fe!iE;|2~1|j
ze%NigtMgx8KHUuLh?Jxn8MclsLN3_+^%Pq*V*X)7h~7e^iOpU_{9gHD9Z#|^%B22L
aLQ3YUx9FGXuP31{KuJzrwnExG=>Guii$-4n

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/Torque_3D_logo_shortcut.png b/Templates/BaseGame/game/data/UI/images/Torque_3D_logo_shortcut.png
new file mode 100644
index 0000000000000000000000000000000000000000..d993d4893f9112747e2099c1f111877db4064a86
GIT binary patch
literal 10728
zcmZ8nWmFqov<=0zxJz*;6nB^4E`dUeyG!w+#a#jvDeggwyF+mZ?p}(!6@BUV-mkZ^
zlF7O=*N)9O`|e0}RXI#FQZxVnfT<u4)C2(F+F<{qQIKH2_vZY_unUr@k{l55`tOt5
zQ38gwpgPOzeE|T_@&0|`02x1sVU5Uc3Mw+ln{WsSe3)r`ickRH9Y6snsqM9V;%680
zS+`-&6Vke}7Dtuky-E>b1))(4+ecc(+DD>mF4GBVHs{h7#&{7tjU(Pe!Z&5X{q|SV
z(+Fuwe!n#qKj>Zl3NDZdt_UrkIzX1qPTkR1>hnATqNkz<!EmeqKRjDk>zaXq`<`6o
zOvll+_gvXkg?^59?W6m|lHFNd=W}Jp?Q#^hR3AVB1VY3>3hpsZGY(PdHs&BcRUg@9
zfExpNVM`E7tnV(60^VN>8kOos+qdlJ)zq4C5M#(Cjlv7S8PE6S@B=CU0$QcIb~ueD
z)VrVN_k*Q6^et=6{ylb~<60t`^n-*Dj+NkWP8Pu-a(Q7i>W(JRHEnm&{1<GhdD~M&
z0GL6%3cv*I!c-VGKX~;9$W5VoXE0}*h59sbnVTb{3#ay}cPM+n*7!4%*b<I4^T`^q
zJO9%!*2;@<C19ypm3nm*5a?k6_~X|(APLZ#UeE*ct>h^;en6J-_zS4ABU%xYu|MTs
zO8HA*!9fg%V~{>nHvh|=DB_xiS_FRS1L5IZXu_$m0-b=2E&rLsHw!??lTK$)DK&M7
zUddsarKu?gF)B@KkyMAzNXd~}9v<m<n2MK1V%9*Nxxz&@M`;gR+sv1T+RpUtt#R0{
zR)B8HK<})}Bg#UZxP0N(2IV_SQvAa?{X9d1_p{}4!<3fh0l3|WUG{zdNdYLduPUpD
zD&>->nLem$iVkR(*y_xa&NHlpbrPiMsNMRdN7KIKf7X{df*RJK^!(~t43Y-Tp?!LP
z?GN2~ekWJ>YUIys3xUip>c@y_uPL~N&$uCzCkHzvbG6t2i0Deh;#F1q)W2z;@!Slw
zn{5C5JhDr9T%s1{I<AVs8JhJTMT<l2L!%U?aJusE+#eO#G|}r^=}%HJpgGwPKiWH`
z&IPNINpHYF?y}_0FZ;0&KI&RBs*ZLeIQr6?Xm!Ta!qO_@hwE&P+rV_XN(7G$fy$*8
zuX$D>yUaoCy(ryYGExh<i7f@17JqrVXw~8aR)eNDo63L*_j$`+?D|T#-`a4_eAd6D
zvF;FVRK)YhMR)87yKAxY<tNWPTZ(50fuCg=MF^0N2j$qoi(fc>4f^V7l?T@pBQmqT
z53wKI<sfr}QzI|ES~G(`$$DD8+B1WLiF(QId4;KgIw(JtxtqXnrA5qcrq8+|*y#8k
zWC**%hD0IQf4->$q$1j}x5))pm&76`Mj|`jg*4NIq#*{I#4%zTv4`!?lJV%JX8on}
z9B%a6QyvOPl}{K}buC5*x|#^IDrBS><f^Z}qkg+dzBCi>pN=opE<yMG?bhGA!fQ5l
zl%yU&4Fwzc7m)MYLkbH6m}d}ctMXpb3tquPDuS819}$R$G?tX{k@8(iiCMO`tC4LS
z!#j=kDJ>onJ!7KY1O`{GiSTCtu<BB?CwTQk73yR|0*OE^t(6bfJQ=}B?t%@se|yEi
zcoHcoPj4oH)Q{^${<>LyLwn8JpH6$oZd|?l6mrUgdiYE$*c^Qs=bz6s$V(9jT#GxH
z;%Q3L$}{OOXr@I1zbSFerSx;=fJMG}QP(+lWec*0d_1714#&@1(fimp#m^gVr>5B@
zf^vr{Uk4}-!Jg5u%o!x+eE<e=G~FwcklSjnM6;2u%Y-3rDKKj6d*vk$Q@BIwxj4+_
zj?72djJCM}IzH~M$<qc%H4=8>YOT(jdTzZLa?h?12t*ax`WGwCAefJRjZSEo1)Z(B
zWix5t7C;CB85}?<g#-!Ve&qi=FN`LsHEgxXSQ}#d0Rp+3pe(1y20?;dOf_Kfsz3mV
zi8`c7dt^6GUW{I8*D5nl5ZgqVhLRuHgtA!*fhaxW#zP<kAkdA$D*+MvYzy6@CTK1L
zc7tu%JwIF_VrJO}zMB~YIy*?&XI)k=MD3|ZcTYO=q)1BiLM&G^-O=XxhF5lMBBE}b
z8fQ*wU)y)eC2l!!4I3NXKfEI1I<8mHz*`Z;MTi-RUYJCQ)E%dJCWEL9$VgMRkCy;g
zR%e*@ShnI94kW3^@O*Eg|M0^!nyz?*l*6bill)_C0rpaIFn0&zek>IK(q(zyi%X&G
z4Cuw;Hzt<FK+UqRJzIvjgaiV`3)aK$+pBDb5XgS+rdGD<Ehh%b5@!8Q>7f;NRaFxT
zVUkjk$i@DFx0R)umd@^ToGEg=Fg5~#OoT4-f58gjx4FxQML}A&NG=81c0{*u?msqX
zyWPxfV62g?kBjLZKravK7GLEfoCndqAD(F;<k1pk6Fp+6TM9a!F%bzSpg$xftM}Q3
z;H)gjr<lX!Hy}`!s+oA=JF+`+kD>-4VX2&Gj<tY^!F1(s<+>dCK~J4EkRz3~6evYQ
zI<J;zB)zaAQ%y$bf@uPuL(^gwUAVrpx^;)D)QCp5kK|FXm56FCF~)|8W^F~k&H+iZ
z>LJ_k$V64)M0zPz9C_;;h65LBo-!nv%Yr+vv?Z-b2y=wVn8-4FTb+T{e2kPa#6Br|
z&R`t4=HBs3VO`ttk9stx_h22Ld1CxgE`wD7?(LDI2VW!Y(9lW+#8w*R=bNM0Q>|m?
zgp03IgyEg>c@S=fC6It%5xYBM*Nj0Zdy=w;4pswhfmZp6;VG?O0#vFyYAF^hY<6Mq
z9e;~L_Qzp}tr0IVVQ#QuazVSBqt}b(j)X7L(_MFDcO>amDAB9700D)i-%_U#VjGGj
z#oK3|!!BRQ&6J56YS6|uXia=^oQ~4~87=tQrW6}R!QH+S1N2zZWcXf!klJ6hw3KKd
zYB{NYI~68Su$}O<Q{N-bhlhjgK5C4h;O1kXL-NHwy>re0XKiVICH;(<PmL8-xDklV
zmN900FX=W|P^IIB*t<{WDkhmd90z65!8YY3MKY6!JS{|pf{eRBk<fy43yr)SPySwy
zNDKw)SS}$uH<2T9wpr{oZ;xPkS8uoZ<*P6%5J36LMeHR{y_!%dogCw^DoMMxj*J-D
z?6x9RufPvCfohW1=E~j*4qw!~ak+to?7ON9)6n=ZOW&7lg9L;U-CaSrD-0`!R%6D4
z)^RF?nq>LfFGH?lzlQQGp+@sXpvMwFuSSw%!*|~!ohNn(vD%34<YU4TDV7Y(jCyLQ
zYna1bQt|>$e4)63G7PQV>WRlW_Z*f3rc)}Y)C^{|jpqD|lX4;^OlZ_mHEaeRr0Yo<
z$J$Vg?K-{-<L;4k&a^48(t`$h^p6-^feACKPjZdP!zv7dk^{qKgK&%@VgVm(SfYNE
zxSDh%S@#t?ED8MhBS&CrX}ZoI)1ysRlD01u1g%z~Pd`3R)|kz#TGM`s_wB~xTw<>D
zj(4XyStbmZ8ugHq1_|sW<K(_?hviWd8og+=@6wc+Y89}|2%)GAD*8+jdP1Mr-m|WV
ze*H`ii+(IpDCLOP3bu09R+CwwH<G1wQW4ySaYpYg->y`0zv&)Pc5t5vh1Aim`j7Cc
z{LCalW3<)3Ro0)Jd2M*#@f|s#WLl@Bnb4AHh(TuwM{kjUR_sJwhgBZLf0TQ;t@Ap;
z_Cs*SPSTjBHtJVoAibq+xy)it2FIr{N<(K()bx5(ziTa^$k+@n*KwDrTu3Y|e`A|1
zACT&3RWH>oLBD}Wfd}#t4-A+rT+!`2B&L1`Cv}$jLVGUSv2R^I)HAp*@9B=Xtkmso
z$23{I^{8)KPsZ+L+4>-WJuSj4QLYfNroTq=J*sVc>eVC=WbP_o^RZMn9<CXA?bnoj
zydIjvB~<ezpA+_`Q1uz^q5gp$eLe)u`jWQAJ~*3-&ZjDZepFL9ccWw6<-vcHaxNda
z{Qj5e?RhdP^n-9au@c*vQxmTVLx@YN496osNl%htrF!)Q&OwTb_PSslUL#58=Fq!j
z^iLsvMaWs_ZzzEEPUDgLQJmF4)24OaGsy-42ktZisp|?-E8B8RHz{dMVUW=nWp-hw
zAnKo~gU@e|N<BhcX+r!nZtm@4?i1GQhadA8YdE(4#t-*{DFm5H5Tcj?MAjZ>{KG0}
z)T#ww0nUTXkUdk!(Wu}{k&`W-xDYvTVs?aEaijj1{X146lVhUKB6mp;NJquolFG+g
z$!vakk6NV~!MC!S@=mB(9Tk{6z*y;w&H_&C(A?oNA)H}4Av?7{@}YkvUC{wm-GcoK
z`x=74NP4oO)vI-35a_#cr>Y4biQcJ9(B!PnD3*Cf4n?N(;ZZFFQsQH;)faTW7yM2{
z5#Ke2vc^aWe=9`=W%Br*N;aTbfFm@QIh4{FOZWG%&B738@@g0%^J*%xx`dU(;P`QQ
z(1Z<KO330*>X5Wx_ml{4>V8G`{z}Lp`AsaiHd}_VUQgEQQEI8od<kZyWoe?m{fEm`
zO7UBot)T(74*F#$W|S)KgtsJ3SM^0Z7!7?|uS#T_YTYgP>rwG|5Im`f(#acPvWwfi
z8kB0yk=<fUymVh!3db~Cj&AHFqg!vCt17x5bRL*h7!AJWC!k?4BW9BBDi82Unoyt-
z8jiD|?oSFey{W&eLhfD3PDrR*V5yy*^5bv{)~1D7`j_McQ&O}nip=gD{^gGjP9y{g
zRt+aL;u@4@C1n%|v$<NO(9txz?u}hW_MJ5+3>EoQl(Xa>&++eEEh#WZFk8P284jWs
z9!8zpY!9>KMIU;+W+DLm5+T%zgC~qk8?zUn4H>%2u$K<;#ObJfR?)wS#LlN4e=32Z
zGH2fY-7))m5ue#~uG5C-7RP#NHt35sVIo5t`6xKpnoZwh77L|rPtj!X?B^K%j6{{T
z%B?&v!UFH@#Uf}@cfCFpAqAQ%Q1B2d^g5oG>^Sb2SvZgD&8g_I5d9g-#q%Mn*HESh
zHbtUBQT$(bH%w-a9Umq9G_o+~jfCzrgX}-krrE|Zmpn+fg{~kFnH&BDXNV_?1xdGP
zuqzg^1(QC#h&gm;T{xXi8zibYQfidHxGpEC^{GKc`(Z&5?bTtj(>upOoBA@&)D$Gm
zs5}AW7dV`#FgyX<r@sur%C1zc;B`|FC>jD;msaIK37?f<Tsep3Lo@KiinX+bfBoNw
zC5+5G4wkPmP}9$h&FbiGs$1u#iMAhK5tl>z-<NV)%DR4m_3mRFdP}!OfSDLivi@~}
zd$*38MZ($6gN2XXk8YTh=g}Z<_Ljtr>wQNUvh8f=6-rg<72387my`+$C+4G1k{`3P
z?GYNzAB+n0eSO?CY*RfDtZr)8O0F?=k6nTVi-GjzLroO3u~Xo^VFA*E*VPq8)RoUv
zt_u0r9uhak^098eP%7D`+HwHlTw6Hmu5qjaw%q<#g5%_{>AE+6QPR#I7~-?gE?qZx
zYQX7wGg<i+uBARBh>KSEsxyWixhsjG-X6at%N#C0f>%I0{opMiGq~-&O7e)ddr{7j
z&Gh%^;MU3@?Q?>IPhUcP+%3!(k&}6p*shKU+B%_+g@0nFxf|wWIltZ$AJ@?vF<HJ<
zo6$GQJ@gs^q4l+8EJV}nE|FIy^8cjOv?m(O?PWFzm3P*w&KoxF$M}O86^c4Zfj0fh
z@*pO|AUv3hXNYr4KTy1R;VX(ni(tV>JIe4A`J_6NvyK`}VMdGsi!qmmsa=|5lrPAQ
z__R8g=69%j${uWno_z}|e{ADw9EgMCOmAzxO=NeM*!!OdeTu@7=Gj!^JFAgc2Y*ad
zs{C1Nh5>&IFTe8iw5ROQFl=eskL@d#r!<wZmz)kUv-m}f1ZsNQT{>QE57RpTq9*(a
zLdldt{Ea=V1U4DPAm2Td$26njUgAVb-@gScnq9Gcf(angzAPx*h3W&9vv3-O&8g@x
zEaNx?8*Ti4CW%7UxD(omn5&XQ7?=uykl&(JIcd)FGlzF3KIWD|4jm%*W#LxgB<h+~
z$l$7Hpu}W(YG}fvNIE+h*X^ICxev`8l|XZR@mNOAbSA*@eT})E!sRh}3HHB~05d{y
zLoHAPK^`7Off~DmT3^kc^dGQ8Qs0_32!uWw1~X8UB}Y8I+hui-`%L)PLWR)So@f19
z^6b^*2sT9Hobe4CfFo?94aBjW6lkoyRZ<ar4PW}IJ>^k;iVtGhYk}rErN>}+2CVE(
zQhcXnEKt^}R{$yaww%Y*mb|qb#nYz>RpwQ;5><?I)6USa3$xN<?X<dUE7+Z72*D-;
zI6lhzFbB`fU`u-Q*RF*Of3YqU%J4G`h)3nLX4n~wBIc=mM8e6E0+ytGR(s8CNME)c
zwGu8GQZ);6F(cP?Cf4#WW0%?S`iufC^tdB4A#NZx>S#yr@TFo9uRA=dG-1F7b1%U%
zjbgr}1v9&vQfg8izGA{q>JV&Lkt*iuf2mZNE|NKSxB67|#+bZYQd81@S*6Z9JNKjn
zuxNKd-m17DVkoQvF|8giRQh6)Qw)I|P2b%np)If;H=KG(q2b(0Dn#1xnGM(|FU5-f
zwW0;wqEg>J@C>es<WOxik^Yj5w@YVYP>G<68zSqh;_Nu-t(7ce&nRnsH>?`H{6;E*
z(@k?iPP)BPs_qmXKUJw7Q=#l*Y+|u4h&qHA*||G>sFyJC(*qGK;uDDd5^vzUFj}Z)
z25$Su)^z}DG)&&A>?7g$cf#``(?rrzCckVX+{JJ<_I)>)(>$)V*MfViU9L6-ED?S;
zuqF8Ip%8G)*o)a4W}-|u4J5a`bAtbPm5;A59{Xs#(^$dEOl{G7c(-BORG%{L9=lvW
z89p3AxlIvm9W$JhD2AU+xD%hlVQEZ=yE$pan#_#1c6ve==tr^IGcs66@+h|G^o}oI
z1x<3&XNHvl@j=L(oo|IDM1ENB8|t^LtM)ZJ%Xf*R>y(d{=)&nWgS?H6FBk*ITlH&K
zFM4)6RQyiE8;W>aYu6e3)S+H$x%3UvhT*ouCdRdi+b(0VsMLHQ(At|m3>mitiP(nP
z0_}&2rw^yS4lBy0p7)o@;7iP;<1xaOzIUz31ER5ZNIrxXqkSE+Kfyn?>j7PIC_!Q<
zldRs<)}P{(Ja`&Q=Ip}A>77<hI4NU{ngI5>cnt3LEcAuSAFmr~i*1(g_!g3RRk)RM
zo25})MrpTBejX4#A7PT3RWTsxOj0|5N%$8>yf#GlMa%l$la!(|_wmx)H_qj&SMw>R
zf7YXEfk8Eyd0IU?C@sezc*?jIQsef(Q@R4zJVSSpMLuf_t44V${Fo!9jDf4wQ+`nP
zJS0OZVr5a``-1&xha3v@^rF*J0m}qCEBnHVSL5SdX&^q?qczaANt6kUs_@~o^>k@Z
zXx+A{0+-3Hx9z~>?MkUiS3TV7rQKIR;tPX?aa@5gPVtc+p;V#hx-PfIL~t?gBq{zH
z*o6)U4LVFcmJga9z=pJ1NK^3v$iG}Q!6)WQEjbrp-8sH#-ujizF^t;4jCY=DLTH;B
z$#-g!#S}%Cg8I>F+Iwk(9-K&!x1j^Nv8<kGND~!dQ&}8iKx$&C+#~(b#D09@(q4o)
zvS3{;ahrsDuvYxjlDCCaVOy9SH)@yMeb>xK_J_*{+e913%zaDD4Y55B8f=+wQ5(P#
zC)q~Dy!otyj196bdd7OhO@`2fW6g?Rezj)m;4n^j&fz<|0=(3t-#!Jqz9&i8^X>NJ
z#UaU@WchXzuy`yVx{-v^%aa!&)#RA??PmU)WkQrZjmXECzi#9kGXjAyv?XTNcZ~c&
zA=p)Ki&a@EKa*v){I{Xua-ms#-{it`Y47GVYGsdqpKpe?^|8d(peUBdtWW!Tb1>N8
zN(uw!gPtd;K$HjlMU};BxL6I8rj5H|lHQMYSogvdbg5GvnAB<rc*x;mp=%b^s+`bt
z+%?7Ofp)w~Sh%NM><Ie!Vjrg0H!b0%Gs&~uCsxg2wYI}|cb%^@NWSd6qEtGWkYL(C
zZ?g6gE#|>;O>*nxV5{S2tL(?Qphniy>i!ea*t}M5+#wMhm1HbG+^qg+*hWZ}8(K9P
z`1MA1**;>geXd@JHXWasBpP<?^J0lg4j3-emt@CUjmLb}arZblaa|m%?mV!<<=Wbu
zT7YGe4$+-ZZqZ7P>9epa>}XzO6-cnMmy8=@vGSXbaS#aF+8udo6KO@ifEEu%<}Tdl
zp3`Z^><BjKNZgO4EJ(Dy6PaK;rm#B^t$Rf{d*x{Z^hlqva&C#4T}?r1;Mm0P*=cn9
z%SzOKVW-V<DGeqc!N<?nDrqIS_YEXpOOvxIGGIyVA%5T&6TEDoTdh{Lv3%e6!aY^6
zN{rvn{gnMcbEo%BUvDij;-qcz+s@q<=%i8d5K=g1Xb0_+lNJhMG_m}4%GS6WKv}a7
z0}LK#<1<h-3j(okjDm+%F#K!}Llwl>e!$TiUZl(xz4mqRJ)k(8(^uhl*B&MsQEtPi
z|JzlS%M2Le6YU#-E$AkUm>9PlmOO0x{X+|m#0HPq6u%EI-V850QQp{);ua!@SQuyt
z1{CN3lncHJ_u>blOIB~CaJ7&Ch|>0j=wQG|RjwAnfV^9)iq1pFq<kQ|$y5!E?FY!!
zrE-mh*^YKHA6>ZEUXxJq(K55l2U$OE+Zq1Kv`3T=TMO}+|3<P2?j6P5`iI>k=1@G+
zm3;>js`_n4#@Q#xm53c+R7?_G&%My12I!5Q;*c>GL2Q*!@^11V!S#9m`i-C>l4>+o
zi>p-^nuOFoVBv2mOw2c1n22R9bnO<w(;4g*u8czmw?(W&JvqP<+h}MD5ocif_gTxe
zY;OR`!?FS|(N_Mv#g8F2d5|g5o0yf>NRUwTyxe23n5L|x)rQ_^FsT;qG`~Z<gYh=8
zeXnrrsWz<gOV22Qs{k<F)F!6)rs$v*O9ET*CBc7`(pP=QT1^nUmkf`|JT3k#*z+*Q
z6*=T>=j(Vl;_IVj`2~GwR%6w8bNaPQyUDVkH6`s%g?Pj<q_Obc=ITbEtF*9U4;D-#
z<=I)DKk8aC!qAy1LDv$bTu0Y3jAsWi`<o<*WT+t2gx=aBbC<WRaIC5U&RUK%3qzBi
z;0alB&6+Zx3iCpMiY`SLLA`z$3!$9~M;pPJf$0X<Oj~|f2k@CTsXT<F6=nhkNroN{
z63YU7#vvv2zE2k!1~r9Eu+l9X@jM6cBnNm4FR;0#*@b+r1rSGeE>o|TC75_s?lyxq
zPds=1{E|uwu$Ni9?Gb9{Ev`X}q<2@FXTmW&mQL|-UNr1R;Mj%13}*X3dIXR*1E7EC
z0v`cSynz97uarE0uNL4wBcF5OtnnULy~2>2O891ypq*ETp}V%e{wfKp96NM3OVd0<
zOnR3OWg`=g<EoKcZ3W)-YM--CQ7Y<qPaYTuXp_#Y95jv!)by4HGIuo#*DDSS4H3=*
zYP1@VVR^aM!z0e|4-WCLiCe;*hbM$U(IVwj9azpvCdD1E;32^bw#(Ntb)g+Xm7rNT
zF5G=XKVkkyU1sB`75kgOfaEe&Nx(6ep_WucvW&pY!Etjl%V{At0Ibbndzw28lxMH0
z(J9q+K-ZBMhXrva5ykXXN}5TRzWWuqyLOzU*2I<i$W1hnLi%rNEt}~$fX87<JHUMK
zyN;mGb<rBkRrn7|mME2&=Iko9Cg``kA}XMaw|a3d`<Wg;9vEmW7NRs<!Z;!v$@h+2
znjYLcVH<+)mW34}p%aolct|N<tYGUGz$u%whI!2=>ScZvy3!mMn_@2lH>n)FB4x+5
zvp-5O4X?=h72*UZnaEFMbF<v6hWMr6v^5r0%sS4xD^Wn&t=Sk9JI}Jrfr@UA5rMle
zD>MVYGpVR=JPMMB9TJih6#Ta*U^Q)ldNq<>w^;3kf`gOf`!{M39o>$o9;eeH)FDhk
z<<+xeKKVW*J<rM0&s;?t1^T|ur8dIC&Dz<C^B)SW>P0dq2M0a;z;QtVb>(YIr)Iu#
zdB@FsmH|L3ZGC`qn|ie&rlL*aRcF*%gVh~4SWQto*GU+5UPcCZkwR;A=v6~5i#JvB
z2qK#%_CQY`dep!QY^&9CaS_M}@3awKWSsB=C$s9UFVBcWV+-(fk`-PU1UGXj{QiwB
z$H*z&+0_|GbiK>O_wG{#6v24Se7m6ucBqlNn+IeT7T+p7&3A>ULaHce$&iYs{+U+j
zrH2cWX;)OHny5S$G#0REb$<&x@xyEwQOYyyK;10fT6x_68-@n-;fF3kOz;uR01q_n
z+DWm}g(l^vy$m8mcS_4ILIY+S0%Z$s2qFB|etqY%ZfHVwmImRXat)Y)^9SZK1%T$@
z>@S-sS&^a{``VvcV%L=3J$5Y9v(lhUH#=m04S~=^>}z^V?r;i9qYtM_-o%1F^&XRz
zG)Rd*FxXqeeRd+AKe{!w`Wh6bY7w7_BYgh}>5rJyB#AlCyNQqzjht03k*^u}hLirZ
z6|fAJ9XB*<nUI<!{rrtxIkptF735=m%fc=)_aD3mK+1fRNaz#YZwG$DH}oQ9PR3A1
zpHKQ?F(=J*W!FbfNU7&c7?!IX{@e`lO<`HAu9#V|e+p1>C?p~4nPFCUh3B}Lxu#p%
zC%GupzMd6sqPmR4*UfkA(?JLM1{tHBF48n*fe#G7Yn_saJ9iNXoYJ~a&n;MQ@dyt=
zvB@z{zB^)fHrunpCtB@cry_wo$|H$OCg$pfuw$bYwz<sC50Xb#J1x}ZlP*T7zrNb=
z-C^N6E*ITQ@mJP7$kwXR`GF;RXFf0DQg@98Ev9O(rI{q*m79g5-PlIoZXFzcDNG)Y
zofev(Qnegn<Dcrd2&jiOw5??dsFR3`VjF%pbN7K_u=`bGNuY232ALY$IYc~K67!|V
z@ePJxOX93kN>e!`Wkiw9Lz(w-<tI;&m*{<bakmaY)+vXpzA(yw%|9-HTMP_qO3fUW
z*k4MM{C?p|GR@ODyF!Il;_iphg~tmWFxBkw>yv*c3#AxYiP(|Gg>#ahOh5IEPX~HL
zs!HW!{vGV_!gHKIOX{4Qh*PJ1E`==L_N3c#K09w<_#>tO<Jei$9b}iN8}mgzjU&d;
z*UG*j7FM8d#|-wvKd$<Q*HMeEB`M4Mg-Uy1^Serm6ERNrN9A0SKjHK=sY*A0B|U<*
zc{UrNVya{p@YHPrg2@~d<vDkxNMvDi{11Lek^5=&qKR2CbU*fMNOEhHc$j9}9N#&v
zIPXmnPwkUG4e_9xJZtQ9M&_JsPqPP;OQNVR9Za~gz!h5$Pr~Y9*$3a#?psZ<%OTp4
zX!g!h6*aZ^s%lT%&%7!t593b$b$&U>lwJ}V`1FXm&m%0=)_`+pyuTZ8hUYmsgU>^1
zd}n$g<NE5v>XmTn<<Ya+u{iKzSm)F05;5z%sa)8N%x*g89j4j7ePt6b&f|OLNA**x
zfs)(D$&t!9b^pn)>)?l7M)4&Puk&}5e%Bf&Eq}7L;;6){MDJF=6h!6M!_|x5wM;sQ
z|6-|buSGOI`uitGmq!Jh<1(7t-Sl{Tf3ZUf5P5yNQWVN^tjh8B!DwiG@hm7(p5Pfx
zE#eIBA+}BnX-op1U-A*rSH1PVIRpW^>n6q8F2FfYbo6-OVjEgOE|VfUVBPx<#qa4N
zrL^qq^;6_@fWkooTz%xbn=_WnF1PW<VGjf?_wU=fK|RJ80@qpx9jPbLxURTiRQ)9K
z-$vFvH!xLZ@M&mN7?@==8u4Xp6bnNcv%P3;rlj9e+)sFR)>*l`^IE*CA$(RLf-*<t
zA5dl8^QtKM72g(TJJT_iGyP*&m@OvG&U~m(Gej4E{X5B<9%FvV1^L-_*7-@;=X$^A
zU!!i0-|f=tU74ESVb)#O>+|R&Oj7W=)rMJ9JPt(c2Me=2A7m6Y7)3iMGQ;>{xt2JI
zV@&9pR;I03BqvWxNYQ<df>h;!z=ylmPNcxHGG>_>p5F}%hAW=GM+knlw)$*mZanQN
zdBVi8tlRZ42WIbjy3CU8rK53RiK>-ZpqS}Wvvd38aTqro2NMO)esfytwSvB;D$S58
zBctF`^A)WFkfHkVtm`!_pXu^KwAt%oo9;gqy*?`$JxnXXl$zuJaL{Jkpuha>p6_7$
zp)sjAFP8Q{ib*0yA%^*H#-Il@=8$x*gc&A}-Z(&DU-(;=6h(`iC3iNXP7#-_-q0?%
zK&x!;J*rcfaEQ9jL)lmVMjJhunmRaqaB!VW6)WQ`z2yN@z-Tr7<oIDq%EVx)G}=W2
zrVfXD(lfuauLhu+7U!+rfEMqoy^So<ueVv%0nbP5XKQVqb}lX#TN}@(o}This<OIL
z@t?Jl|Lv7y8+AZJ)1Pi0fv}f8rJ<qEZ^dN%15KVm-h^~GR!i&c-rioeVi6Z2K>YbY
z&B*uo=dX1Qe2XJF@ds!kOrBPm*QH|_%7-=#!Z5l|g!s~5y&E8Rg4Mgjsy+)v-9^pG
zVjc!a`}6IJ=*CVg|GGMxVY?RqkeZtMer9IoyUJ{qOK<mogcVMig%=4bT)SQ-gsdb`
z7Vw)*`o3Yn^Gzab9R>$?mfzV7dW)34zjSP^)V8j$z5l;n@PgJmt-2MG2n+KmKU7`o
zog5$k20ZOhy`J>F6@NNv+VFqO_CIU+`Lhk9co?d}95@=vNsJ-;1C*6xPBfB=9=WeM
z8<$Es_;l*oCH#Ei6wr46OZ>&9E2oL)Z}t!TzL9@IGDTYovV$Y%Asd>94<3Op?JO#`
z8JSTN_j?K#f7+_{e|_9QR&gr^!|VKG6yeayA6)w9Ok+3Ka?|D7hw}#9lp9ez^t|;y
zFIX@N@MA^D=XPNKUp<EJ;}i2GA?F^x38G%nqz0A1q#Qunaa7gzLY#Z)P6w+lOPq<p
z{}ctkgNo^|tAZ*-hBrNoObYPbA=|jm{Cd{0z~Ae?mu@9y?%KtszGtiZHT{?v1BsRr
z!e+5uAFSyvS+!K;_8Y|ZUC#gc$msQi%&C0~eL>`+AMe*c=X*7Rhqkox{kI;Vnp;%l
z0~!r8{l3;)bBm~wY@fp+s+aR{rw6yc)d5GJHXhQ0_NVzyOf3FUtvG304NA%w&)tyJ
zg=Gn3poV@ob8c;GFXgeZn4>ohInT#do)C!8mK*e~?<V|$5$yKs&wy9|It1eJSRaf3
zXkQFMT^wk+l{Oidqed^6Rdx$i&mBwbAK2MnkyU11=B&gYm+WBJjGE}pEIcw6xwW3b
z^}h#=0(NPsmUv2qFvDi>kN?*gpg37o5>Kq?NMuELZr?^=t~wqY8=E*VFaRC>&K@v$
ze&uP`u-w_w((;O$n};{|Pk8~I{?DyT%t&5O7r*ZOE~1TALBN?qZMSGX7?2Dzln~%T
zXbrx>)SdU$IDgY=*Xzq;%!ZMX(W^QGSPwkE0sv@fX<?#U+y(vTf#K~L37Ok_>0UYi
z+!QG9hKi-vtLy;RU0&V!pj!>&$Fak0b_c;X`#%e1jPLb8q0l2YECWS`GMFOo8a0+E
z1YLKlqKVic9(OJ@Zfo<w=4StRbp3#g;-b#WlxkmM&Bg1=rgb6nf-wNV=y7?W|8f1U
zGXO5v?>w05X_9b(FS|Iw6~)XkxG(J=1@Am~*KL}_`)<v%Njho3^kP3xI{alxA;s_5
zjOy!Mobc&Azg#@!^Y?g|*NF4AHENsdLwOuxhLXKwU{*)GmA~d#LgjZ2eG4~5`4#5=
zHfLF?>QNW3LjR(c$L>&K_|@O1?5?NZ>}I&ogI@^4MkPf@9RFm8MEjX1b39Rw(wh!h
z;_L4e-BTV2cY3>d?+nj}n@Ba^?M)^24m!L{Qx9xbyno{2koxs6`kyq^S=Ocd?B|7J
zQHc9L!PVXHsLaS>m=}W=_MHMAS2W7MHXCHty|FUmf=yCj6a&AAP*Y@+(b(D9c{h{u
za!tiL|7VxWdIh1FNpU7>bzdmT_poJUd{^k>oBw*SGevQs<st&i%*>Yi`};G$eEG6~
zf#w(!2WP8fUYyP>ASj|h_G>2W@j~a#KjFj3iU03HYjXdZ*4cLSfZEm%<75I9WK@Aw
IQpVr@2Vh;nHvj+t

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/Torque_3D_logo_w.png b/Templates/BaseGame/game/data/UI/images/Torque_3D_logo_w.png
new file mode 100644
index 0000000000000000000000000000000000000000..ec197dda39246e2f1f0a95f79d35a68aba584a01
GIT binary patch
literal 19328
zcmV(yLFc}SP)<h;3K|Lk000e1NJLTq00I&K006NF1^@s6kt$Ty0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBVoB1uF+RCwC#T?c#>#n#`spifFbNPtii
zs`P{=EvOVxe29c59g!kW6zM2}4+SBFB8c#zG*c)KqzeLKqql_6qk^;u2?-#Opig<(
z?@k`cySdpieRpr>{C*d*yR)-X&Ybg~GiS~K#km9=QchKoBuSDaNs@e&fGm#$9g-wT
zk|arzlN2|Q%`QQPBuSDaNs>UqE}+4#z(n<tZ%C3PNy>ORk&`5p$$%UTmN2DcbV-t=
z+?FK4hGQ8L$bn)j29%&ek|ZgcB}stc7-j`>(AbjkB$$vSNdg8*5?I)piGf1~5O6p%
zsFG<VNs@9`wu#Rwcs0Lv9<Uk1*ll3i(FZ~T3Q3YAc#vSm-f~pUFU$>Wz_`E$gGRNG
zLDc-lsFEZ}@E`#~J_8r3uQIxoAObjO5UBzgL|Q5&Ny=ZKL4t++1uRrwVt!x&!vjY7
zTkR*IIs{ZmkReHuy_B~E4H8t?UMBNY#Jv0{fCB~{jYUHBb*7Uf`%o%RS#LR(eMc_v
z0uro21PyoqHenEz1L%;-Ns=A=Un)e|Hj?;{Kh;T0ZM7c-YhYmqhM}=Ys19RxNs=T;
zkmQ8+QyuzE)$Sc90z}XP2qz6*Cj$#f60}K0E!$a+Q3)ux0tr?if;WHwHevz^EF|Su
z03wx@Y->68*ypR-k->NZ2^4SuIF|`<?kts2o~q!oNRon2DlZ8X@>4zRrobHqC|LO#
zhyW2lV10OXpeiUI)$WWZ$<d%gf&|}Jva*la%Wa<p6D$-jEr>7!6{G+H2p%9LieDA*
z4G9+Vj}<_Y1P#6p4uB2DooHEW`$)ztlr2qKS}O$YQV0;x$tuM?-oQdCKM6kMj9hF#
zfqd3ZPAW4GnW@^me6|1*R)GkTcY#fq(kfsfm6dM+1YhbyX-1bo#23b{2tZ*=>x3vE
z!3snerDFvifM7(410t+Mq&Vy55~$b%B-o`NfX(u8O55d!lafW3QG_hCGoVmKb(obP
z0@Vru2tbG^W~Ft^5dkcug~HiD!OnZm?X)f1DS!jmqz{}966_+wMF9%ifC<q+f)+%O
zzR%KP!Ha2VmqH{U;NOoxV7vR;sjk4{_k9ge1DocRpTR$mxIm5o6Qs(Og*5^N1OSS6
zQLPoc9WGS?Oeup@<v$CBojtilp3UP#3xrjQUIGSdCyqQPfR=9g=LsZmtOqz-KmjIz
z;0Y!~?%3eXoDyvKmg4dSiv(~`d$W2USk%^%te-@R<~?peg5|OX&60*0aG<eZh#Y7r
zj6}0zgY~<ToHt{&TktWfeUyCBB9ULfg436;SS&+35=^j;9*GMaSb+%IB@kRjW;IJ>
zy%kh0aX3#&s6JSy{5CuG<zv}_lmU(d6vDxT2q3`<M6d=Bq+4HE&iHu)3ke|X*%o%O
z8nMjZ7j_=l;UFff6t`Uf1F&Jgvb6e%a-J8eBX|G_6l;W;62}1%B>9to2^JlLYcb#%
zyh;KHdwyGWNS#C}3t)r3@wM^g6n_=F$_5@={CUWBVPJwbBsC9f1PO>>vGie7PgaOj
z#mrY_%#@Ps3tCi*(pjyvtnjIz1rNTuO%yn+yuA5e<vbSc7L3sLK!OxR7?qK9=|hC$
zB?>dB1f3`?6wb3oh@25y2{Hgfxxqux@C<WoC;k$3*rEjc;^nt(!31k(M3OC=I7<|O
z5NzPql~<T-93a7xF(r_29yn3$A|wO?3SdJXu_DM2k2V4v^R}BsLWEC*%J^NCVgAD9
z1YkVKajg+J&XoW$4QhTU7807qrCqjA3BNCagmuEjj`{HN0U(tZq9QVi^uD*MjYR+l
zAY}ozV&`q0P;DSHga8RrYXl1rL9^R~rGTOhM#2hMND_<YMJsfxzr_nQ*e#}j9sQG7
z`#%6FA1nu$b~qgxJAalyg47y;0}yyGd7us^Qij6;11cki6G^_bWzTLP!tMvO@mO=W
z;uJ_8ONy!u+gC=vq#rLV9O``nOo##!sMZKv5J3V)aO=&Q2~~u@Su&e1g9u@W+W{bg
zH_+f=U9dvgsgz@krA0zzR9{h`jMq{Uut)~*km;;=$qrzGIgntztbqam%zy?i5J9Og
z5Wu*oK!Vjd9{B-4@Ej;sT0EQ>(G+)F0l~Z_N)hmAdl6eX?d))ArxS5Wc!q^_!j@nH
zATkdLkf8Nt0Ei%h#;<~vb%I8avjP@Y00}#rM^!=n$Fo0FfxO4l(g1AELpZ`)R16AH
z+cSYf$2YIZ9dG_&VVw{OCWHbB+}#%_mIP7|fn)8!X#<wCOH~j<+G#dn7oj22I>Fmg
zU?qsawLn-MO_7CPlgc1JtH&3OV=S<Mm#hT#G?Ni0fC*+i%o<1l%zI{O00Q`60Ww4h
zEnJ~wmBXb|L+Fay+b_b}VI|1m1tzSV5z~gOrv((GZO+rT0oZsf+hu(60-_``%PKHo
z8IT~|fr0Ye>=~++!|K^HFQ-d8?N<jD2@2lNMF1S0OIcRTl7Yqi!zu`n%6RPYBEX;z
z><%bIpOHa2HtoK9k6P9MMuVAEJP5NT4bo>u-~{EG7n0=xEKtkF%S7rlL8EdOItu49
z*fnf3%?Z3b_>093D!T&;+GQqR+7c=vtURej%Wh!87C-`b>43x<fdV2(trVz2kL4^`
zq@Yp-2nbQz&v-kWia__G@)H@tnRU=N8a^Twpg5p{G_9564R9Khz6dU86+0;iurgpF
zm271RBv@G^%$}jVLjqb@4lEu%61*KRS@}iS#o3aVBDLe;PgWl^g%YZsmJb1gHo>(H
zk^&0Wpn~Pnkrk({S_ue5S|muF?VSQ9EC&*(z7J*=2NDp0yUZbS5U7;QL@TUVI#t@)
z+0yEm9IAlw@@N-Y5TP)51{k+H4uCfU7c2z2%0bBkM(>ceKM%kpdiy)g*%~Cy^L79e
z#BD4RNC1TNy7zv&b!$$hs^%(7W@cvIT4w%7v%HzAc0C?Ecpy{(makA@GGkzY!rUSP
z+1Sk@!4h@z_Lr~{0EwC<vkX*4+rA`Ah$;f0U=8$XEfOpN2k!&Yw7zGTh_AH3faheA
zHO~>Xc|lHt8JB@g1y1o2B|;S6AmG&@Kxgm(jWj9-PyhnzU<aiDFa{Y8Z=wJ(6``&u
zLI_28tBArDU<yCLi6>~!vtc<a1_td040r}m@T02Je<FZ-R+<g#)>W%lzkaBHKtRZ&
zk3L$aNYSFzJQMx(*PqGv(=$?T|91PtwO_AYXxXaOeu4c%ldp;~E>XuLYB^LBS*{`g
zA%O4>>ieiNfn}@@RqG}XM@tr4I&<AqRrPD1KoJ0RSJ2mBac4~^1BLbZ20)NdVKp<i
zGDwsa@$*^ukg%Q@u$Tn{24jcB@}Mf{OCF?Slz7Yz8#1`)n6cxY52_s8<&j4o4aE7#
zg9i`N(^69pM1THy^n{5MQxyI_W14k1|I<(XydM@QSb%t30>!0y|BpX@Pfxmf^?ZQ>
z1+uPNw`-R`Q7^qdCgBS!^a7QPWDO)}15D}qM!12*E*}9BJvf`Tc+7A}(_0lsf(3Z6
z%MKA%PNO{hKu|%X=$HmHYtbqKpuqK^VAbA+?QrJQspo6dtoeGuf(47xekA$&^<ASz
zj$FKE?b>wVvjU4{{hiylPh_fU`rSKsFI@cPLV^jvVD0x{2Qc9XAc6DDSAhgCM&K34
z-_F(u*5Hb#=QFPzA6EEvkVLy>1r%ue6$Joj0STNLBumSeVcS3}#Po=n6H1gU*-}q2
z!sUy5ckd=&zji$(%lh!2|A64&;Ht%n6)OXmjs5)ms%lv%_V3+0=b1KbjFvo@`$yPO
z*5AH$YyZu(v=fmL5j&QwSdmV^U%bEsFXu}v{$=fKNdhELoGpC`NW4tJ7<LGW&GT#p
z77AOWb%8Wr9!`?1+k=#UQ2u7cV=UUmdwdyz1su@9P0@PN+SRM8z0k4acrE{j#It9k
zKbkvt|BC3C3^VZGvqz7j@4owP`)bvzhd)-RP#MnzmoEOYv2vBFi#d&tJpJsJ^*ggK
z{`md(l;7Py)R$cVAb<03k3AOXT~`#kk&?3W?CH}xH7pgZzy!;q6dVa86hf<mDUjH*
zabw7T+$h@3WZ7sLWM*apc<&*K1@3!U&*1(4{{J8M^Gx_o&NtoZv(myewQJX@+_wF*
z1GFmj_0Ap9r%s-_#CqV589)B4!Zsu}j~S(iz2<;}5Mp5+;Hh|7?nSpty>Nkps4&eq
zYu2dN2NdgsFhBu8M0mGub3K<bpcUc5&p$`ktX+FODX{w~@m&AvPt@$|dGA_M(ysCq
zE6(LORy{2eIY8p)9}{D1)T|YwaNhE~DmJF7e@XwMLBYXQ{rvpO_!Tc6s%53|wo<H$
zja~T0TW=-X3`~fyN;nfpXj~iJGfSKG_s1W7ROii+Bd2IpYVNFAA3Rk0JZ9KDjti$<
z)?f(=L@jZ!jE^8}J&{qLvMR62xz9<qfbt$|q{|s3)(I|vV#vUOMHha$_%lz3%6s?j
zUD&a0+sq!ldR?Hf4rM)CzGO+&Zaun>^($7q3L=<b1}=1f1WCTM@<Bax;6TgDRjRZs
z>F?iC&-Wzh%9W^!K|xWBzyyzXNqG=iwz(9067MLDKtcB=CrQithw?3#NgghfG$eKL
z%+rPN4Hv}^B|p@<qO_?CF(0$Cn&o5Gr+V+YF!~>*o+N#4Ru7lK-zaUOFc>dJW5s1M
zDKXnoW)^mz+bP4d=FFMu4I<upWB6za5Rt1cuMQdV%b<a;j=OjF&M(>b%2lY){&-wm
z7lg5-V2(W;S<AxN8`<L8tVN6cWdZ{uA9>`Fmrk8Xh=l$o-iazysx%<|-o4M@c3VR0
z9c~(09mw3`Yz2@Ib-;~jBV_(3lVryN&fs7LI$R1lz`zl%xQY`M!~liO{&`#_XQqf<
z2#S%kzg&prLHWLdSzlb`k5fmZa=8%xCas$p5H)*O!KfeVGgM2fk@XdO3|#u<;wzqU
zb)Y{41Q9EuW6~)=M4qy*+pr<yl>r0BdxDA3h7E@<UbwIdLjU28WnLCfYA})gNBz(S
zJ0CAua`fSY2j7Ej?wJVssJz&@^IW)dMnR9ELb}U|#UXf1t;Piv-zK|6X*3HUf|@pq
zCX5*qT)Iq|!dZ#I|6bp)Y2&4R`wwI=7?gl<Tk$>)+WQ%5oy>yEV1wPcvu4$C0au>%
zBgc+8qf;K0;`^#epPB`xp$$}nqp(PKZ;;HM%mVzVUP>J&AeG)T)u4UN0?nE6SWdb*
zk&%JrD^}>@`Eb+v4ev1o5xM@}uxWEf``DFpUL7*nJu82-2)x(3Z=W&4h7W(kr0gsL
zL9yappr8kIGkqUgDF*iMcjBK@KIj@$Ik<n0GA&rJXzjXn$6vp8txDN)<rXRU0jU&B
z-cbqjW=<$TLd5BjwgVH{4x0?WhqHAmD{b>;O$(11J-TsFP;gLSU|>*%N|kCGeR$N^
zv04A$OiR0T_s(yr$;l~~H*ef{Z04Lfmlz^aQnbvoKUEV2iYn~%^2n2}Pp_V(`uFSK
zxI)E>L1o;1;~x+ZY*gsC#*EJT|5{Sg+24NqE%o}f>z86;qK-zzuDpTyeKTQ-67f_;
z039r5h&ZNw+7o0|1Af#4RI1kuS=D%M#&4>UH=3m$n9xguJZ}2-@892Zt^V@GOVK@g
z_4<Xu%vU$P8#G*O+N{}1XpMl^&~IY@-o5QwwraH-0}ug5W1l4uCe8x_H}@}U?dsM0
zI(O~zf#)()VA-<W(o$2429zo_6M+X&%D@T`khC9C6iw8Ft8jb{aHCh6nFmRnElnLQ
z;cwpTId$9u{-0VEnmu#o)NyaWeU6cGMV?tVZ~A26Q6on+e!6w*=S!C<6U0LE{_*?o
z_kX!?;n<4h%fFia(MOjVl|L)Z_uqaS?k;N=(daPw`t>V+{rP9ch4beVH*MM!H~*7Q
zuIRKYi(N5U)Vt@)0k6M4{OP)N>poSyM2S)?>T&1x?bNep&;Ib~;{W^J4JuL<HcpdS
zf2*pxUhBnA7cF|vtsG7hSbVS}-Ts=C^nSVW<?DDSJbdurI`_<O9V#!n>$1jfGnBKZ
zPp_&|uU@Qz7jwesZ$om=f{QMXir$=k4R>e^9{5UMH{YZafP3sMyT9MRzao3PWJY@W
zjiP>juTWYLwO>%xud@G6JbQL!tvYpLNXIN<I;!`F3>;Ww=Iq&d;&`|xbUQr21j+;l
zWk(Sz|B##~L(+#?&sh3MsERX)#d^IS_)!$J_2)eInmyU1$e!=N@A~a`-_P&fv*&B9
zKm;WB;4fU;t^8)qojc>|<;#<1eE4A<#n@>N*>O`Px7<*X8}(PJ7!*|NnYL}i=Pg(;
z?bgkkb5}-3w^Hz(2~GVBdUo$#`pl_Q!&a_d^Rast)|C~AfCTeu-m+!4&tqagaew3W
ze!Y8_QOKPpz3ZS!a0|3T?`NYZC_X)22km)T{7@W7T@J8_n(bUOQ`SiJ8#Q`#E=84e
z^~wf95P@x#fD|7Ww=(<hB1Maq-mz_4b4)qO$_mPQy`ReY5C*6!>F+=JT2fLj;O-v~
z@O)Zo>I6pRq_O(ao_k}O#w8d8h;p<<qD)m^2^uVIm<d%gppj>AZQHu_`R~5}VP31J
zpY8&cKF>PC<&n21PJH*urAw1~bnRM3!Q1(fr#_iFib6EGX9EGf`}G@g{o1u@UBf$<
z!c>r&N(_R#BZm(5TfKJeJP5>i*TMabr=wS{To8Zk=zx~Zn-x*eoNlp&_QSX;v_I5c
zBdAKoEI%hqP;i7cYTxDDt5hlIInNh1e6fBfsU?v_QNg8*zyA6&#|Nu+ojT14+lj;}
z8!+r6E>yl^#f4{2pN_-?6M(W`SU6r%lijv|qL`so8wd*&0AV_Cnl@=t*sahfzR<B_
zU)})1o8W9dDkf&ys@RxT3R<Xi9y>9(SSn&yu9`Z0*sx%QVh6%oZ@dw-{i_|*n>20q
zyy!YKXw>+HZQHibgif^t3fvq(=e7pmZ2iRD*#RiZV0&`c0cA!{<2(wytXDZZHQ;v7
zG2_Rl5XvhO#gs)i({7&3{@XnZuP?Z-Se_`$(khX2uTH&sJG8*Wxie>;rvMWyEEHUU
z1?sL1D;+M4Je>7BphbcRB9oh2QB{hFjGTxAAfT^9>Wv$h@7%eQdh_PZG|y*+3l}OJ
z7+5x_Sg~ROsHS)L?OuKQ4y{|aZms&E4VI8Fn^j92X7!pmYu4L`j~p3$EI$4|F2BJg
z5@_APdFl48TWRU{?xiLtU%!0+{_nZI>F@6!P`r5YQl(0l4npm3*oP6bXGb(?`sCtn
zJzn0U(HAUZt>ESd7zsG5&fO59@KlAN6Wz}3+e30I^wj;7?S=w+@}&PYDe06OtY=vw
z;PS?}(WA@EnmacIV>0OT1i{3aQ>UPXaeVf@nzd_B*s^is`A*^C=XLs?<k)dkKIBe3
zwttd>4z2fa@=|RkgmlX>V)*bNH;8x#MX5li!nk8c_eMuW$E{tzJ{9G|(9$vRl~-!D
z3=3;mt$OvwX5Xn7658ry!g07ydKoL^o{^q@|3*skRUQrdH+O}~l`mh(D2-dl6<)Gr
zN$&=Y8ZE=&)7Ype2qFffl;g*9=i=jz9gCay@%;Fs$Ko<jc(g~?uBAGMcdpr_$&-z$
z)u_?P?1iq~dkkB<IurEh)$0dV%2p?S3Xk<$@Nm|yXOSSD8GDWo=yaRwMU(RuTrM3$
ztj2o<3l_|E&jtP`nB8FhhN8V~7iZfolCUpZu57L|A%05y@dUvnhS;e(hvyR$FE(n@
zB<DeBXecaKicWqiLs^Ql1(J3b0;@7+fr+%#)cVjGk$vy^zrO%2r9&1jUYu@H78D*L
z;Uk)@p@wA@8An2-Rf9FCz_msgf(Z9)*%U;aI+3t<+0tb@J$54)<(sR64<9{x-~Eeo
z{~7;e<HoCIMnpW<tVN6GjJ^rM#PPT|;8wg#6$a7eAc&|^t$HK{FfnBEhM}Q_-+beZ
z1}}w&cY^*AT4_QXHVg~z)M?AcEnCtw^3(zmE&KHEKiJGFbYTDfU5gei+`E3`rZikW
za)ZG%_ivy3?|p7i5it3^_d3_DU*FLG0y^LROI5+ky?g(l(>7Rq{?IpwR^YQZs0+{n
zi51J1#!j64-Z`DR7=^Jm3WKfcq%jJO%~fIf6)P5)%OY{>W;%t8BL*3%H&SzfwqnJK
z6*W;ZPO?%k?X!SVr6TX%y&LG~=NAgE;TF*kr%#{Y1`?Agl{*is1XbN}d?Z*LkBsv^
zt3#V?!^GXYbO|s65zs_F?fv&>z@-K+5MjmynrqcZjvc$-x?Q`CPd(LY%;AFvcN%2^
z74QDNdwZMY2{e=vZn;p_!VTYxPe}NE;NZar+O=)_!L?t1)orJK{rWXT$#cQHc@4}!
z#N~^Z68rS-^<LX&pWWmJ5jQc)t4R=4)C&n&`f|5!qpx1RY`E39N3UK(KV7t_v4Xdg
zLVHlCDr(>0_(WhuZuIakK;6czlaHz>XlM3lwGj^B(c8k#!lGkJ@Ca}io;my1yKlb>
zir9dAS#=*dcFZrHH-jrzu8h#<EPP+=v<!y)&GBPK=Zb<^yhMqx_+v-I7=DA*ZVoE4
z%Gpx2=$n>;ijP0}WTX*@fL4g-o@+mO@{}p(SbrOu-kY^(v1(;>^invh)=SqSEUf+f
zxpNyb9(3H!A8`YU`>zjsZJ{nWY7pAMtbpO2It2_IG{_J{Y}vSRRdAKc5gRsbP9p#h
zhRPoTib}!3Gt7Wq|5sjl%?&zADQv^ED+)b$z;?FOQ83u`QFHGaGK*ECm;eezVZU9G
z$@V(;#A4UuB}<OU{wetWOt{t`nj_!=#dB}KiEFL0a%nryw-+y2n!bO}-dvX1dLf|`
zh7TK7l%TC?`h-Q>0Tdv?TFK%bn<@%qkN^s5N3`#D?+%AM3XDJmv_c@RwUa7yrSE_N
z`^JtQ9bp6}1`Qc9s9}T9!ju97M~IRr#+-DUzub1~?CI0TwGx#s6IjtKzd3W~41zut
zde37%|9sg?UAlaYX<b1*peu*mKyT&hm9d}cl>>s%S+i#kMX&^zSp#T61Zv&A6+OyK
zpQS)IvLX=0a$u;uM1PM|8RtqD8x>XG^ZKEm2o0dXwNg5cTDNPL08a?bzJ`%WC%yOH
z0GsiHtt=8Mqcld!Uu(URtnwOXBJgN~CXE{vfj$amAVL62&iZ@d;>A}Wn9zFxD%FS?
zGuopFeKk|nQC2GHAyBy1j4VpJdiAPaU5xUZ{LVWyD_5=dgkAxnmM>r4f8fCV3i)!3
zVgev?UH9(WZ{OBUn^x(40B+lz_Wt{|5I_V<j1=1bK(TUY4-&N9J~Ssn>RCrv0|?$b
zSa^dLs)L@~<L(9qPYAOFaMWK!^x?Fr>phn^U>NPi3l|0w@-<0Ykoqxk0TLpt1tiu3
zX5fN{<s>p<W_!IQ4d`_~Xwab5gfl-<lNNA;iK`peuV1bAVvCkx?HY!L7O_}BAPaMo
zvr%;0Z{VO;U($OiAwGWJD}x5@qnu5lS|xI>JB5eufIC9;%GH0sfN&F~O>34X^=DB~
z!3-u)!2v~PWy7fh?y?JSp9K*<5r%cE@kEWvo;QyjJC=ed7g$@K9A%x*TH@%|qsIUX
zK&2xr5_Up^RKUXJVrQ)|vPLZZ?6Z|e<Ki<g2N2H8P!CXmF5S9)4IK#eX7ZEXeYd5J
z0Yok;Rl2l4Zu<=#G$=^V8UeSj4jMd&<a`I*zR~Qje*OCD`m#W)1l;|DV3p8TzPTe?
zQiC|sav*{%Ku``Nq016<q0Zg`<@m-aBMw-=wx*OXU!h+1-!RJMyafwV2`wE?j}?O5
z{&0!o-o1MX+1GGu=qK~%mnE=3@H{w?=v`hw0{0*hQ6PoZVxi*J=l>QgXryP2fJ+*a
zr%Xv?H7i#L))-eTU$#Xrant6_TPWtHdRtI%<;t3X;NpezKkAj!J+s#h@%zQvwQJ&!
zC){V;H^_hjf=jr~R4>!sefor9fJc(@p{7S!LeK*<r0w*-L8l#$0w5?(9zGdPpH-Xs
zl9Vb_ItNIkrrbD%VGUxzdv<CwqH;v9Sdq&r(X)5&{sOHMES5I_3Xq`jap0w(6%7zT
zyOfdjo~wXM<yh7%YS5@rO}&gZZ`!=iB8Jbo_x`kLi4T=+9)dxiV7vxK1Bq7{W@YW_
z)$QEqUeh9xl=SOWz3*49QbpGq@$rHM$2kZsQy&S>dlM#1*rjKc2nr6aMLF9;u>_zv
zjN(`Ya6uMHIBAsanb?QwaS-I9$2!U`7DL7J&DUSIedLixi)7zOOiVnC$a}cfDXV}T
zcY5Qkx02zhpqN$(yVo076_Cm(IF<J^)ZkL8z(&<8f1dk#0w2bUU}TM;X0km$?Afnp
z;_uhD&lB+p3CH#FLGVrBS|2xvXxqJK&mMY-Vq>BYXx(oR8loE=^QRvZkHc-HI(6U?
ztxr)jg7?7i-ihbV#l!d>-Y>%)KusDoEP6C9J{`C1)y)4GDOucO#0_UQ51npl_|x$H
z1`QiloHA+B{}Ml3lJs7hgwZZtF7Pl-ft+WqtotrCJAG<uYDUDYSr-w@q9XRI69O`s
zZVzqRtXZ$@8*o`;_N-Zl5P92aZNZgJoj9@UnYL|nB3^dw-o1+(U@XLt6)0^<)7IGU
zk^%|TD3!R;ELlgtBnB4`1q&+R(GBmdx8*bG>XmZ>g@fU}jT<-oIN;S+H8ZGPyAIqw
zd0fHtATH#lx5tfpf=8wN{rw9ydGg5`b?em&)w4uEy72SQKYg}rd6L$%4(*@Q-HLl6
z;lz&w3Xdi_q%NR1bNY0m7Lb6{>BUYJ-9RFd@cV#rjF5(8MtzP{j!xm>z1=@%ymc)p
z>8u+_OkoHPMMb~_JY~nB0|z?6vo&(85ogbC`D)j$3<~~YRcDn^JF1M^PB%a3D{=Sk
z-GuCjmjR_pK~S-X04$L35EqbV#aSDqmI=L%2b>uO7fj^bgCUUhGQF9Wb?BCA2lLeC
zFSqH2dUh-70FpA5t5BihjL68*R-t~lJTYq2$Q62nq+0dr`T*p@g`1RuS7ji0vhq9s
z^Uu0vsa&}-3{I7ZD+n@kZ`s8yH<L3Q47PvzvJ)P!GagW_45&UNxvWgHA|fg`Y}_c9
zHDcVjaa#o{E}yexT)ljGSM9oWvw#GQD{=Jj;jku6o9-2CO<>lpF3!k|RKe?Q1638Y
zxcNr0^hwKx<3O7Ae`sikE|A!_Z(kz8x44m>pG3)$CH$Q@P!}&+^!e6p+jW(2`SRs;
z>osl0j2{)g@dc3InKEsf?($dJa^(UjlrYLxRn#3qtQ4Z%9O-!YKd@>;A@LbHv~OSJ
zAH#>g>**VD?8wnIJHOtY&Y*2rY-_gzpJ3CxxpVhDc<>;n4J%iv(n2ARR%&@W@!bBY
z5<ce{2O<}^K-l7`cc71mGTZ8$5GT>H&p!Qp?1TvkHW4(ug(S^R8eU+D#OX4>6X3{G
zDEyMA&!8n@^_n#wdM;_C-AFmrA}nmPLblridk2T!>9IBf1w@v$B`a2>-@17-=P3B%
zk3Sy90iX&a8X%!^cn4K!qgWuQ6fpq63{dEmU8QIrBS68by;=5~t$@z8q@=4uUww7z
z;May7uvt0n4knyBBlJZu!D1JSAwWQ(%^Nl}e{1xp>BUQwsFHo}&h6X3^y$-QhJq08
z-6Dled!~d?zD`R`%{dAlE^mCddv~Z)$5=rF1wm2~U8h5XdpM4p3PriR8AgSk+?e0=
zF1L4ia`{PkdWUNO6_yH}*6|g0+pn#d90G{1wr~4}F@RtVK5*9~Y112>{s}0)XB%@W
zBp7}4W?EXVB`n}&X>@svHP2@*mn-}KoShyi$;mf3Oa?^GkV(Fg^Z&><-z@#^q<2RK
zlrB@xGa>Yg_`ih<7wp>o4T*!LQQd^?EWm6N7Gu@0jBt75v*pXjXJ1#VUOfb|w27Qo
z3Gd;y9l$9EukD|-yE<@yhFK$$Me53Z4u_U!uwMCcz{KXwn=ZdSaiV7aEnBvP+d>l=
zwztthH3fHi+dpsJx_#3KVCgLnLE(P%@Zkfr6{{Z-5(*tRwVth8vu15{OiaR;+qb9T
z0)f+~PbanS&_VOrq<7wVV%m%uBDd!14(2J7Ch6{cIeX^J71rNl09b|6ri~j9y#HT6
z5?x;<Mc>k?XUXKDoJ4{Wtk@A9J9H>AcHFq;b?Ve^>kS~XEfGC>bf07bB1r3tqPTGs
zBkE2LlspxMqvIl6-uUR_kIxq=TC^IxE?%NUhz0z^WakU-I1;oL3e^O?;((Pr?-nRf
z0M`m)#H@Lg_n{+4bq8KRsZ#z5`|YlZ8Mx8<-b)=j>N<tqx|M5p335z@-)`T&*`Z^{
zt+W*xGH_sm8?{f?de*Q}qtG6`dhJFiQ=WUbZ{ODKo2pf-+Qz}OO4X_cJAcxC7a&|j
zfC!f30CkCx=V`~bpbhKR<vOYJ!Gi}mXVTQGU%&pNk3L%D@yCl-(E<<I^y9g6TWZ#>
zy$pd5NVhKH@E7YC9jG&N)c(b`4&3?ew-ebwB6~Zi6G3c2%E3)zd0@3o6qSjwEEQf+
zFI5u+rwb;Mu3R}=p;D#V-uYLoSg{rbIKmNZzyMffJqr&H*Nwip_lG@+lt7M(+^GF(
zzX1bww|e^Nc6k(j_3AZXRLh580_#vUxHDtw^y!+<LPA5J6=1&|6it&SpKPG_%xFi4
z1831Jmo8D$`Lr{0c(-nmr0-t3_{%qQXU|!)V9}x*h~piY$Vw4b7+kA_sPUlt?*04s
za~*p2$^7|&Z@l%^bqX+M2~XSM&@MgmqtW1JVTM#G-qV`(Xq8F5e*K!J`MG$B5~Ze3
z{h*df{=C~a>;Gq3w`rmG^0pmcT~P>jtGHZ1)o2%@-&-T!+Ty(qo=q=w?AWnEXvkwG
z?Wfs4*M9v~vu|oVQL{nA2BC!z%Epz~8Z~H8$UPfusP#<mur(XZuxZcJ!D?H8zNDdG
z-gBz8g7oCo9Lh*fzj6KA^-Dkf{8I+S_gPOi0O$5%X*JQipT{XR>FU+<p4WBi)CpAB
zg=Du4kWe`d8dPT{9HE4|gCpk}(b>{$_lRmFz}Bw$*B-shU+nZ!m|`9ugH;?1&Gzi_
z(o6n9m4h`c5-_%e*TGeJ$^={hr%#A}#}iK6pEq~za;*=*Q%YlFVh1XCJ9o0~A3k{S
zfL@*>-gvVihSFmNIC9a<h=}%j&rT#9k5~9^mF5j_nF0z0Zz)4X80%*8#AgX^_iWy>
z<)E$Gwk<gx7uTzOyS7CX`<ww`^}&Ix&H~BGXVuD;xqw84iWRFlk!M82kw5_rX0v7*
zC95kC3K$&P<q;y=EU=Yo^#AO6^Df=FeOvRW-MaPbKQ-gS4{H$u7aBpE^Y`43<_*$&
z0iMA@2^vX&gC@bHi2Zx_ey#PacHO!S=FOfHs_4i4(ELtR)aS?bzSpfskDd)1=pI<c
zof<c6_*k<REuPhT9u*aJoYSmVrF@Q*2IL-JDgqCYTHRP$ORTnR;AtxWo_GH`Jp8?o
z{p-~6?>$z<#Juz6=FK0TK6!E#j12*IWq7|2gHVMwY}oV5?c0~^+q0*W4Xg)t`7X2X
zK!;1u>&G5@tO%p>2<-!xAi+Xvm0%H9f^-m?d3T#B%$)L{K7Cr(D)H)|L4BJweX=lu
z62w*3rtKLU6&0pujesGh7ku(boGAkV7Z0a3&EJR-BeuYDX}#2c;43{fmLm+mv-!(y
zsd^DTp;cnp(q%m@5QbT0kBNyH49lRE0B(8Quz7PT>9`CF3#&;vmXVda9)BSMe)Dnq
zzg<IS%b_UG@&#?(wmrR1|NbXm?A-Zay^xSqrOE_OeDu-3_1v;?<8<g7p#>;fwrcfi
zN^<hFe+(U3+5+VZDBlsiWtsO8;EuIOh!|`n>zX)A4tegm4B|X^?C8LmL2G_*{P^+P
z^^SusU8YQsTVeG@uu9-sBn;c<jeq<jsB8D`z4cx`bl||(amSC}SLn?4D$8GdLPEyU
zPe0RK;wVwFWWa)t7j(j9x~R{iHtRiuhh=@fY+0CK5TQh`SP`b@8v$wR)DJe9jE}5q
zJ)ZLq@DCsW2H0|;dzUV{yI<1p-Mh~aSfBs}RKF|QHc$o2O=k2`moA4YSE)Mx`S#ED
zK6N5twYQbREvxFz|75{OGp0_htVm);?#WTk@`j(EUsWg8f!ET8YVto$IwPwD${8Fq
z)(WHL4P6II?{o(a9lF2m%dOFRAE{lp?o($@oqCPXDq*JN^SnD^`0$`vbLPDLSfN6i
zGhTSadAsMH+o(`1MYvoAxd_pbW5>iNo;@3{^{ho$So?oYnp6{~%rFK4oZ;(zZ@{as
zzUo%&Em8Sq{@l3@cJJKzlGbm-7hgPU2Kpd~==aJiy30)m_wV1eVbkU`l<|>z<HlvJ
zJgV1tq7g%7r`s<5`t@t9_tMFeCod}u{7Jmxn4riP6h)sed?EDe2hY){AKGB`s1a|C
zO1g68u(x&M?Mah9+PQsu8wml}(1XAJ$^mSyf(48EI*?E;W_Z-41v7z?^D{bYL&Fgh
zca1;S{cb&8{vK`xH31XDnm2v22x^{)7Lr_b|Gxzb8qJ(F>m5B10cqia1xrxB1&q%t
zQF;8_3Tmm|635VC!+IiEaB|%nGGxdqz5KEiqFb?V-mu|W6w6R_OiW_K#*JIHZQuSS
z?_YS=uD$l}-P==7S($+d2=GRX7_kXeDPFs#y<-UW{i@iQFa^&S2g!le^G4WHPw6^~
zZrQr!Dkjh1f*G865~%)LjtCXc3Q#Ouyg0dHP|$QYcwOfGtbK<LBWwgFKtB1V&sZdA
z1`>@`!pLlB7PU?n5ELw^A4cP$BPQ-LgQ4Q@+4JSudXAUbVB)K<c1)iY5mAdmxN0iS
zW=}RLbmY*%KEvL4<1Hf)@%=a7Y@9r0$~lG2js(winS{SQ-#iu{fB&1Wzuu(v!E)ux
zS8_jl$$$qm^P4bkT!c|YI)#V#PCR?|&BhHI7BW(#a5-r5yYGIi2TY*V<e`NlhhUyC
zZzB)^mnmSr?y_bmXud<r@whnMEu!IFy7q0_q)B0l8Mxu{-gmoqhr{J2trwH8U%zrR
zE<Rmhyvv2c(uo5GXqP}lfevO%Rc@Z$5;1MsDDR~X2qyCJG6%DMEcnPHMV#IkE{+X|
zGjMPQzS+!M*8<_4-e~*hL;ne!S-&Zu*njX)M#PL6v-Q@lA;I_(V<$|Q46PGmM~w=?
z5aycShmM^8TD9t_@4o+GUX!NHo;S+u)QN<>t=qNRh{Fpm<1Ms?fB^BQ`Tk2?y6n`8
zrO>8byUtz1JNx5&$36SHyfQj^sZnL0s8y@s-hKOKyMan)4?vNp&E0ujU9oK0QX>n;
z@L|JX*l!hDI$)kKZ=-K7Te4&+EF+FW`^TGa#_91I1e05~Zk;&t%{MC%@Rp%+{r=l;
zJ3rI5ZMa^!zTLfhCjnoRST1Q~iONVWindm$6mnRX-kCi4mpL;dCwYU3F%!m5YuBbt
z5sLQ7_mmyk5|XFCgp-KJakN_ZfXO|*XJ+pM#rPyTt+YAm-HIcmcfWo!v?{k^>C$&!
z9Wvy!PW^yMI~c~ee|y}x%Kv=-{eK!+2D0f!O3LMg`1l{9W1^3(T)id@rDK{mYg%~F
zz=5@!w`ke8O4X{3QNDBf<jFntLPD0{GJ$*M*+olfT)lkxT&3XP89bS{dzUT&(Xp}9
zwCacX{hX+LZk}l6=7}L@FF*zT^G`p<?fGHP@u=viME49kkHUt41A-d8_kVZ)^k(gz
z1OZOp0R#4sC=$0)4}ZFK>n=twT=@CtV{ylh#c$lW@$8y)>rzQ%0o=yiwr!h6HEKN3
z2!dg~gm8JLq`&`YZ0)G3(R$X6zyADFGjNjeL_uc`<@HX%f_Z&?Tp)KFuZ&r_WaQW}
z7Z5C@q7*9XSsOq>JC7sh-i)bJt3dDoeI-0()af#Tfs;%?gNo7DTRh~_Dz{u(tr#y|
zqgb6-?>=OepS!y1x7im-SFS`=3<`=u0Kho)$Jq*v+GgAi?J_%E5)h=<3O{Xh0;g7Z
zR^5}?3KS@S5=R1e@R}Y36ESPnMYoWfGG^Sk*Zl(mf{ikTyE@u;=+GbjmM&X<KP@%&
z(%rjvQ*YnCoeNYHE?lTksZynb{rvn&83}SN`r*6pHayd&%?2WgW$q)vjn-}0kUC)Z
z*Bk%-Vy8ad&)kEt)|Xp0Ki9F-OFIyNb51$?^zXm-?wvdLUl}xLh!FsT&+3JQwt~Om
zBSvH?w15Bc@B0@noKN%y3|jfXdu9L+zB^&uxEUWWTzHv4Xl31d`|SxkHgDP52=bBM
z%T=paZw!Audi7FPxW5T`4Bo$Z@uKe1h`+yoK(S)Q0v`R_--;OJ?M-Xftcg|74ogC!
zz_Mj4Sv?yoRk~CW0>xz)GLp4gmWhk*`py_M^tEXoGOF$uYyZ`>TaT9yTV#z;ZP=zr
z>4pp(Sk$3)R9FEC(z7^F0f!lwP!#>sIJJb6ssk3Z8|J_M6RJ+WMs+}ncRnLB^3whT
z`=>-jN539ixyq9$4GtBL*0~*|1QpfFnCQiWUmF%jnuqSpj;&zT<uf->_$nniIZR8L
zwQcuoc(W&){BY>V(fb%Y3zr0r{rJ;QHzvIE&TFWODmxuU+yp~{7L~DM#w=O8etjCE
zV9{(}cyL_A^y!~YkBFFrVwv*fF_ydr>FD7@JBAG(e$1qwebEGNhhxcEO%heNyg1#c
zag#MLSXFj{=R3Rr{d*2`s-shZf+_Xx(<fIX%jD$b3yjJmw9Q-=H9o0BCCYKYM$dAs
zyK0#&b0iu7G`<nu-^=v+KkM&3`}Sv4u2OZ@%IN6Gdw1{L5ZUq2oZY5P>k)3Da7>}w
zMPbx_EPN!i95r)2hl)~9DaOXG9IBC*={M&sSa7*)xpEVswZ_P&g*Cx%ZQHtKWu@TY
z>245_s?hIpQ9k<k<4cn#PMl`s=*ydSY}*#|WV7Zmtoh8Q$^{oVu&yVL13OXv4H`9C
z4bSArz5&B(@7}qyjnih*7J-PIzIIQ50&`6uu3SlWqGiG*pixzV!G_~Bg|x*_A&Zxv
zNBLubg-nF9W~J#nV8D@1FTOa|J!4zTTWMWON;*4t)~pYz)u=K1;Gx4A3Z64vo}bI*
zQYi)!sq)B`4l2t1d-tx_N(fE%OFv!QNI`Jm)cQTsrp@|+0|rbyYY?536@Y-CrS&sU
zkAzkhh3%HvtWfP8Ug+@7u_H&m5-DKdmgjM!MosL{u_H>IjQYj4q_ae-V#+yQpn?_P
z$a8P)nl<x1ubZ`K(NloZvocSb@bH@bTBJzPTtK2r_wMJN2)<l`I)nsFpfb8@0zPyB
zg?rX)CLB}*FkuE>GELHCJ^y~s-VFDQ?O%lo7w-4v=FJN)UHs(;t4@K|j)eI5?XUFf
z`$qYS72h8-e*75|!EL$)6A?%tZ|Ov|MCiUB_S92fK*v<ALUiliqhE_=%?c4%m9l<o
z)~&lyr(V6qEt)kQ0%z8G-=QIBJxNJUPJ>Gki0y(6x*%|D(zI!G-`>4O9FIG;otK3I
zf+9EY`T+vgia|kBA&6lBG@UeKB|U|dx21xqe232H(9zP<DzSXYlDeD}K8s1KRRBi!
z-Nzp<9+LgH#*PhDU>T{1#}Tgp@mm1neNr!EK==%$eQ?U8kmUc&Q>}^&9Xhmby?XU)
zm-P3qT&{fiIw+lSGcE1Xy?b|WT>9nW*>Au3=FHR?GcGA~N8su)DiAOrfeq5;N#DEY
z%K=@wbg5mdR_)pWrAh^%I2=L+3ms+k(q_eqm^g77q2k4D=l?omjvE);rfr)#<;zzH
zdi?RnOS$<h7{!;u+sgItfB%t@oSbs`(7}UeM~@qKMiF<A5RUS|v2toz3{V5(u>cV)
zc$Zd2nac9rJ9oBi+rIsX?CXmc&VO5_TJ?D}eW|MI*6bS(cWtav%;OM|0tuG8Ik5ZM
zbH_&V_3K}hEmv-l!hgpGYFgxW<8@X%3YY*G&lE((j{+Dx@1uYj9FT+x8UR7t<<LJT
zO{!A5bm=_8e%%-AE<wu%MmzEn?sg@Bc^^9;?_gpnDJl17fAmo<3&#1Mei{vzT(mNP
zR)QB^c;RgrR-F@oKuYseSj)oQx^@fJdma}Tml_otn@ZSDwC#*jZ<28RX3MB%f|z96
z9cx|`GTDLu{Q2j<S7mPpg?<x7{rm>gOe$;wB)G>B`EK{_&}Z7Votu4q?8uS#nlx>?
zPr(bMMhhgEw3%oi!5U0xfd##1DDfs}ttU9h9uT$*D}jtVV^kR^3zcE{MOxfQ+DrF&
zi)PIVZ``!$Jw3|=v?v9XD)lx80Kubg>;_6vqTiYU4b-Jm)*yn1b&Z!*B8PsxdUayC
z3Kg1VUym3*e8_@Di&98=O#?`*<OCvEjwNg$;cmC#?sn^%ef^K2Lpm*9vh*GTZ_)5O
z7x3lcFnCD@x<b(aD5r25%`QmKw7}V=k%{mPBR>q1oezpheKHNcgX7mg74BML>??ur
z9&OY_9A6U6avwN!D1H3cF|+hf=L`rwbL!MTDC<BKIg~*^G2aPfQol^E@s_EWJ4ow|
zR~$KkYVANdvqSG4mT8&G_RE(qpYgnI(4awS3(9E~cqX=Llqyp?Csh8ud-oFDAR?VZ
z*@TeG1|4J<FrhFI$|yo86H(!tDSB2O@T!A<B;W-XK=DxCYE<mX8y`%WGDUAt)UI3i
z=`9;KK1~5`SSWlNa7Y6vaK4+VnD4AoFvlY8L<48ygz79STDc<6>J!hM`^EFRag)Y%
zIVx?t5mCM1vc@BiJesp(<Lc$hyD0OwG?qj`3mYFGUgHF{(#uEBNzf?rrJmUkwQ~Ss
zdQ~xA%0NZCX6wm%c{<%k0uT;#l`tPbkw-3?5gB>0PMtcDHJ+#uto1ywY+%6CPqixa
z!=AnONz9FcgbMC=0gJZ7{4S}}8qTSrq$Xq|{z8#?q-o4#FfzS5WXP$3g9lr|dyWMd
z?uo*4p4SULp1+S^eA}j73)-yVNx+0zh*z!WW&#ZrSfF$yN@PsbK@BJdtBL@ONb?7R
zga{zaA28}mGX;pP9AOL*_kTwiS@VR=s3_W;$Kh5aYv(i;PEr6tI<cTp_DG?x5x$4~
zzF)Cor8xjxl@pH&SH>_bcIh%@a)89mw6q-zmo;bsw&Q>VF2d#kCd@1cEI@^4S%8Uv
zF#{8%mIPFVsd8do-Y6f(D#5~{z`H$pg96%q2AJOfg6fN^v{9qynmwnrLWlwrG@t_s
zOu*e5FpdQLyJ(RjrCE&)lMwulr1z#w>FRlX>coj%lokioA~_-iNRXJ~%-&%QCiK#g
zAXuOwa8Q<H%)kZeOdQ23fV!K8l|@3-Y?pKv4+!gsqa=C9+E6(N2GUuiXg**$3q!GL
zu(U#Gj$c((zsbIF=l1OrkC!Yth9j7uwNm8J@AorOvVjCg%ah}2*pR_R1Iv}`>H)yc
zw{F)ifq=iQTFSJYMFJH}pw85Rg1?NR=%l0R48Wi>Ny?#O<^vcq9<K;&fTFG_`LX~Y
zDucdb+1{$fV_C7;_em8z?QzUF77`Mrj_N1IVv=VngFTNGPtVA>VaHjs9mc`ClO}g9
zSg>HuiJzA*UD}|qTVfEgEUGyM3fj0MSbzxy!8(BgDD;#G>Rxb_ur9Q-TpWc1C>f83
z0%hq0OY3Y3IJK))Lekd{QzDJhN4tc9`)yi44j89LUDn7ohKiRcQ6&dR+)Gap%xkRk
zNA;b+`tB$5=Lc4(RB1r=^<RJenOvt{y&aT!lLTjD-hKrccP1cYbd+~VJ(5YBFj15N
zDX7pBG`PpD(<m#zftgf}1D-{BQ7sB2)*R6m2@!2h@~-F|KrAAA;`%g@ER7%&R4&=u
z0^Q0vL?K)5RWM}<&cp;~EUE(e-1gMBU%%HqulMiS8;J>6Y5AU8TieN#1*LIt20BXI
zd)z=%EaFVy<Utd72{nimtNr~f0!YyYmZAyJg%fNFCkPeKSQ#qA@3Uy*Ob+$O<z199
z#fo1P#rQl9Y`UMGk!v<TCo(cnv37aP6d=V$Mb-1XK9P`cT0x7A;nXAJvFYgH!(nb<
z7?ynv15mYY*X}q6YXnK3Qj>_K4O+x&wk=dKdB@CeLNTyLpqjV<!%kvpEkJRy6pdtA
z&2n-5BxoH@QD$9$WBWRF#%5LhaVI7;lNe@o%*e<%|IiYVMJ>a^s=EJ6#<VK1ut1<J
zYh>N4@kEWvo-ZaGKc4KXRs|AXgbtRW4I7U4ytgVQW+o?#n<XcP7PM(c023vEvsDt+
zZ$d!?5oTZma2z~<6>~dzU}B^Nn1BKooB)Tlv#<L_paMQyfd^0e?YG}9l&er7=elCW
ziV#%nX8;gr!G*58tXL^1Cz2)H20DA*yc?X`iKVkK_gE5<bLM{F>0p_3<x14B;lq;|
z0sv8yLEYyr3kSSedRBp6%$7P-lQI~E$2Gb(%a7Eo%OW4zzO>7armQSNjb|$2%(PZ6
zGl)1(g`_+<{XyHN3Sqxu@yFLYcjej&=y@IkXSqyd!RgqcLy^F;Wt(ST-@1A8q_oEU
zkFH<4_PU>+U#JJrI$tp;=yQaAU}=p|dAFC{qkW)&2~r0s+=Fyb1Pd=ACQ1<VK8%TW
z{hzj6H2siC*p@5~8q4I^x4ivmSb`L@JZV9gVlsIk0S;I)Zsgc8$xzv3Uqi>swX0WG
zWvmEj&qB(%HzOkACC`T^5)uwGm`pjrN@x1snNz2pcY~~Mp7*}py?drj%Fh&3xCB;;
z>AqD0#HAvD2-4Xu4yeEdEI9e{uyF7M4=fcKtGduwI9SZ?MS(-RSW>LA*r<pT1d<5`
z?JPFe0Zvc1Zrzp9%#-wJb4>@-7ytf3;mTF2wDVlnc(HTm0~i)&9##}vOnlwouUhT8
zb#wVeT)c38VW;r$^Mv&w>08qLvFq%zs-Xpd36kwwW+(jd02QoE^*qePJWSO*l>{n4
zq0PgN%RZu&u&?}h0|!*T$)U)Ih+MG+;JFL~`}Zp<XjucfoDmT-J9|d6OgwjP6Gs3+
zYCRE75JZG`>o(W(-ksaG_f@G@{R;x+Zx?HX>g1&j5->qyoiGCsxTbQ{84s-$gU5`{
z%9$c<JMgw%i1dx%-L|6q8h9_&@!~1kt>375<y<dWu_FCOO3Kb$N;`7a>x`5T?TkLF
z?Bhm{E>r!98ac}vfBp4m#{2J2+07b2xLhtShfGl_SzTR}4I(_9E8$YryAvnQL<Bt~
zRwJvd5taf8m4V<yxrb_<P!R_?isL1U5W)o!PM$SpTAU}X63+DTw)F)N!O~ho5>JAQ
zEL<JCGRoU3;pHnqs_>Wqj0x|&Gtx6G_R+&fKHa))dpbu2Z>zH<j4TnJAmYJ;2kFo+
zV&US&=?p9<R)o^F3`nQ~Dne?Vz*+;u1Qw*GZ!-{~%AcjXS7??<B#5v-P{0B0G*%%j
z<p7;7FJHVA?V0fTzyE!L#u5jucR%V<Zw{UR>8GLo0Ri>1uWzQMoov~v)ou%yEL0K7
z(kNf(SlPX2&(FL;#8+Q_Im*i~0@uHf_f8Ea`r68+4PIb^Hs(I5S(1g*rbsJ<sHF&}
z0}jPU+sc=S#vg(<3Mxq%k%WH4j1RwnA+xiu{rvo@YAkV(Dhi@d-~0FOZCAB=_0FD4
z8nYuKKVr~NtUv|p38^XldiCn--j0<JL~Px(X|xH5AT6t{tPxfN307c&wRM72$)kV@
zm9b#t0T>j;8On;K;;<r)h1KnvpPefeg&&Zlkz2WF@sg$Ko7Qi5&wGg@@$A{Im<pDO
z<2eKoEyBV^du9NaG$LlrN+ASLxam|udIc$8xYU$2TzNRu+aI2tu{C4NB~g=x%9276
zMq?S-t{B@GWI`IGMrFxGLy}xE2BS@;B4IEQ$=1+9qv+-m3dz33OkGQI-S2pQzdz6O
z`JT`Dob#OLIp6c1_k9x<hKk3v-KR?78ub?z{xw9<Pc(I;<Q{~S5PUUMeTl`RE6(p<
zziJcZ;Y3&Xp|umRqmF+uom}Un3S+)`wr4V}PJDh|7b3s$?XR+rs{l>@Xl(Njn{sMp
zfs@I<YP-DCg07nY@O||Vu2r7yIinl0$kxPX+j;h;-Z{m%IQ>CiSxQip4v@k<zdOOy
zbpS>o{n0j?JH=1-^BMf0cRT8X@=*PICUM*eC`#Nb^Q;`jv7Gg5a(QRF^M>oOdl%R}
zsd)yPhoM&@SL?3!V*4tb{byX%J#8OUUl#w8&%D)~Fi*vHeX#|wv$kUV?yEUSxpX5|
zqV42Km8NXReUfFTFY_9jCS?J1DbBCVIiK=+{c>zY##DIr;pv^sGVg|{jX4aJFda-C
z$gsx@d&BhXWqzJRcljMEeRRN$^<4ml3|Yc8_b^+X`bVSgY~>SI@A@SdYOfH6Xi%3N
z^?&+edQ#R$I+(2?f;Oj-$zOi8zRyS@B_$*Pjk?>_3EOwRaJa!Ma=N&n$@tvd4J8Ck
z!|NtT-<w?Hlld)hJq=s=_2!~P%mrL6cU)s(;WBkLhdpPKFm=g)8R*VE`;eH}b<xx<
z7~?CnOU=v#Zl==~PN-yPDm~B0{jQj~d|H|EW1oWs^J@dsEuU9wVbWp>hCMOlvlfcP
z(ZN1^7V_bxjbEdgg8&#Hs(-4n_D|@Cl;z^arwODBPNr4~DdX|ae4gHSEB<|+yngLg
zd{cqCMGWH%@HQ58VD7g0xQj<*+s4do6`u#e<rIXcbP%rU{Mr(W3+Mnf9XJ;@9FpnY
zJF1Yc*H$LS>}7XQcfM6JEgzOq00hO_EIn1hYv|ih;!X(VOJhe>rTgu%6Yxr~>>5>@
zKAG$NqwmoAn&fm}q=YW?AAl(tv$LZsyqjWQ+z^dsqd_(mr#kX<OL`xMH$(w?Ao@bS
z@#p-<;T^rpFB&4v5?zc-Yonpp?$CUno*gv3$%!2;j8@Gn11%ZLD7{^C7Jbe1iUhMf
zyt+m|y_1GWtIR^rbiaZ@9?9Iof_B0cDW9B4ND?jEoU%vJl>^sN;`sIcN`#wBpMF2-
zJZl{yKl0+pLr(IsiLNbkM;KpXy0SG1(*W~L`P<;LY{vKCfh)5gD~fs48nG2{b-B=G
zUK>8BO0EDXH<}JPJgOGosiRE>tNkEX*;lAS2>tu(rFanu5qKONOl)<AJ^lLd;pe{R
z-~7WqhJmF0A?RAT;(aEwy}t~Tn_jtBg@&=<=GT;3yjNZYH-Zo$uDcBcW9qE%eCZI>
z&-$#@{2cB<+VEY%f&A7N$8f#5_QMi=so8$jCyPOKU;r=}JRC8$crTtIC9mO6g=;V@
z;nOB=<(>?Ilo$f(UP(iF!I!c8k!a?t`H2qPi<y&hiri}uBT%Tt{;B|gq~oKc@2Zhr
zi)L5)4`Ts&$LxZBbIgad&c?{^6Q@5%`+`s+5DeK5Af9at)AnAKclBMk%ntxd8D=%~
zLKMb@<Fv;QV#1O=gmQi6#{_!`e15!*bYNL7J0FDTYR+*~UV3WBrS7upp5_DsKko@=
zGh%djPBhxO<iYe-^c|>PJ+RY|bxP;Pg}Io5`1%zaV4dY&|KiCAGwFwZZ=Zd{0r^AG
zwO~c_=d!2C!3~!Y#ZWoUysX;G%j6NWExugJE($c$cbR*Hly4d-){VD0dem=mU_3F5
z5RnuYu+<TKFwNjB>I5g_BRl2WdD?eN`l-auKZ0d+w=<pH1EMGytRVeY0eRy-hVbjN
zFa?!D&39dCOM%VZOmcIU_Sw4}Id}d8{+UsT0vY6dV<%)=-aBm;m-@L=&}trUiFTBQ
zerin3(^L9+!$kMuoyfl_g2bcVYZpcUeK?qj#U+&zWC3MC?Vk|PA)U%fTbnT?Y%bXK
z9Mz6~eEz=73}*Xd25Zy|m4igZ6-1joQfotWjeDuOSOzrV;OHmwRy`?EP{n2iZSezA
zYskE89B)U_MlwOLC(TMKy~C;jACQ-TBCNK=YqjQqqx)@ZW(8S-R^u66?4M^L2&4mV
z_B>Tq*>z7?2DkNNOn#oV*1JR>BV1C^dCkz+o|4~?X3~+<r*~VX46fQjtRKgB8klTV
zV179P9`QEbWdZ*!6Fy`{pdhXV$g9@1XF^t8P<E`5x88c~ZH-!bsNNs9QwJ65niYBF
z+EGs&Kq-xTVxLNNgx|z3_<V(W5k=vU)v?>FeygAz6Qqy`M#{mY@e>Rq(JuO|@V=gV
zOW=)~y#=ohxf-_F-71pv#93hpOgz86fM%V$u4kVlt0hQ$Sr1m>T*J1DUfEw4E^ccq
zN8PuCk?SGk<10T-dv?+_-?M_$AA#h=ko1nA<pYU7<2k~Do;7DMn#>X|W#KQjhzyCG
z@G~U5qu`5$4$%@gr#8xd%h>JVa$HwU15m$Aa8&oI6|p0dtRiARL9f=9t5uGzg3|sl
zFGo9X*S~+UfW*}<kV3P@KBT}jnk(+$+q3aW$LKt?c_Nq<Xq}pL5{zSrN01tYtX#Z(
zh7{5cJ8RXQP1T^75YqaxvW8c3K4y&>`5g9;oz;aG<Ly`FlG{(B>Ma81`RxW%O0w@k
zDzzn{)uO;F{RO#Lh%$vDqk(%<Brov_BA!sc!G$aFh@^zuzE$oOMwXRo)rQsv*CpOT
z{ZcNAAdJZZc*oS1eTHEO0aJ>Cs_F5lv2K&}Wy2Kd3nCci{_K=HS<hj?4F_TS4ggj`
zY#3$<j^Sa=7qgmC_i*0NJ0KKkFrxXTyQEi;@mBh)422;vbp{-jmUpGb(kRtM6S|pk
zArV=<z>FJ`in@KTy6RABE%%Z0l=)_en51B`B5t8NYjF-}@hC!8@g)Z!9oYhcsT<Cz
z@&jB8;4&EqG`n9?`kMqAMDr|;o4{T{l#t<^%x$Txbil9(Z~sI5-htRc=1iW77f^S8
zLK7Kaw4$Azq%wj4rb8Uj5$BWoy>)&cAbOMv&PhZ6A3YDqy3gA8cX>{yfl#$DH2dcN
z21>%~vyOf8d1CeYopp`nMGybk&5DIvgz_u2!(y|N^zLizjx}q<O|vGX)=Qxm?fWnB
zHu{&6C*k2&SWc2W_Fu>F{D}Uz$4w+{FSCh~pAJ_yr|r(@75eNQ&IhYeCdy4CXq$z?
zFrB&2$WoL_mbxqskJ<b%@|>IS_~Y=x0p6KX{T@eyYDrdaog+nRokt1>jP&0KBvTyQ
zW#BFhLT*=s;_%&)^<y`kEXnCoH1AU-+Svm8i;X|^#(i(4W(<o6_&@<oF00Bn2{CzD
z>P?)aopWiNm$SCyHdPwL*c=ysvZ62!x*hN4xEXF?;~6X`T}g<%&ymfvG~h|H*t4sA
gAn>anHe~mMj)!uL3rfOt0ZT2AJ;~Xo!itvkAFNWCtpET3

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/backgrounddark.png b/Templates/BaseGame/game/data/UI/images/backgrounddark.png
new file mode 100644
index 0000000000000000000000000000000000000000..13b4bda55c7c7c5ebc87d54bf010a5c06c32cc28
GIT binary patch
literal 5751
zcmeAS@N?(olHy`uVBq!ia0y~yU;#2&7&w@K)Q9>#R~Q(W?pK9GlmsP~D-;yvr)B1(
zDwI?fq$;FVWTr7NRNQ(yJ#f-(1)jG1mahE`DlHEz5)zh~zxepOxpVT_WpiI{<FDm7
z!loS|^q>9Bv9I#?+kdw?Mc!cDDpK4dr}|{V&IObIM4p>g6Y)Ko^Y*WU@7C!{s5xps
z7vDHvSM<i$e@(5q>*e2`>)U)d(|VWdJ-$@8w31tXMb<)gZ@0{keYQFH(czMBs@q~>
zn&;1NcI;VZ;H3P{>CyGM=RJzzSf@WccSz#J^j6h*-_HNqIhTE}(1%yHFQ514PTwuF
zeDUoqk0$%w_WKpJf9a)Uw<F;xb!SdI;ri&g-!MvQ@%+u&idH8?zc0xPj<n@jGa>j|
zw&2wQ&0pKH+<f=_U_NB-v(+m8<AlzIKNdLja`C=eZTrHZtI=9I>REH@%}EmJb_!OW
zGp4f5o~+|5R3W3FZt!_3_u3tm$DB8`oai-}#Ca~`Qq7uoH$Pncb?~A@@l4^LC7G>z
zD%R;QF+6$J+KrK;ckN2O+LLp8>-B`!G%V1YDXbPzV;dW?^!KevM<e%G@$hc{o0DtZ
z;L@?yqm6~7MkTQ8N$<^$1<6eFo6bZsg$pQ@p5l!x66kE0TygA}wOh81_WU#%eTIcM
zl-Nunxe{6zC?@S!)miu`#AHQQ$mJ!G-cuwN9h1;KSG;OQgu&K~w3C~rs%WbC8b*3)
zE}vw{-Dg;8nRZ(9c??(6w15Yz6KWb47EP5}buD7;vRT=d8*2IrUI_AAUz*r|X@}=w
z!3R+}*Md&3EqN8;Wn1!gW3<2RccTs0+IkF1jwCAg+MIID4gTx#cIKV;D=#iP#(hO5
zy*$fc_T88ZHhv{W%!Yg{kIXm|96zT#6K*{)`A*6+<8I+Vw`o=nO=cZ&FepiqE!ntx
z@^4jh_R{}Tr1vX5SKC$Zc+R(k|A}33wd2~UrFTv-nUpJ<9Ocx!QP;es;1GMg-@a>B
z|EKfa>qCbBwB3z9oOeEUe&zi8N)rvs>bEg6Ffg`cIy(n=Iy=LXIxvCHshw!+ao9oT
zX#8a_S1mp<!NL;(b9FkpIwpr~<Ph_UUKq+g*?a#2Pv=RG9%<|lllc>|#%hPf>sJr7
zIGW@Y{QCU5^nxD!pXAgn!Qc1$<GXv0-^nVNX!)2jKW<nR>82$oym@D+;g2o_HiZN+
z#?F~lN_%HCKL4?+y?=dq;Jl}`@6KOb{lu5;hsz_&Wzu3F**<<*wzT-3I^X6=O9bW%
z_e+*IK5}1oT5o@$o|VprGaDv)o)vEIJetIQTK0@ro0pBNOkhawr`9#6xt{Bu%UXIY
z>iZLYo~K)<nq1H1Q|?n$nb5)^X*wmau~lQOl%`tH7WvN~_$~jb>`W<|dho=?2CWc}
zKKVcVb>-P&YU+2E1n|75+W59#P+<qR$?I)@YjbX&6+ZBvCnhtuek<ddnn`i_*%Or)
z<V)|^k(d2Ru3#rKkKM~jik6e+FALCMc%S~o*K)ysu@{lW)!A<!e_=ck5PsVHz(GZW
zs3mVo`^(GAzkPc@Gpyde=wi`wb1Uolz!Hcp$=lt9;XjbYV60yA8Ax#!ctjR6FmMZl
zFeAgPITAoY_7YEDSN13DVysf^>n?VEVPFvK^mK6y0hUhJ4T15>aoE7&$RF>c>?%UP
zwoVoSmTZSTfZEuA*Z_zdfJzv6fH(n&8JK|>Wat4PMpc4a2CHUbjfH8(v=AnP-AxG~
z2M%#JkrMo%(7+xs)D0(Ey9vK*v8S5B<|Z0v9dN!QHJoVdChQS&0F()_+I)avw2T3U
z4dDU`cMxLNoB%WxyA1XyqIKQ@nLpUvL~7mvm8-N4CsN&nHCN$@c)}?SQ}ZBm6ZQmr
z02n!=WeiH>kseUEf)K@6cqk`;f}Df|MeDpXTE+n5gNQ&LWchit9diJbkqDRMgDpRU
zoITjwL`3pOQ8L<B0!Cs25ECfKNe!pbG6oo=C@Bpikl|UU;4~BGd=96bZyD`C5#j0T
K=d#Wzp$PzOvP$Iu

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/backgrounddark_image.asset.taml b/Templates/BaseGame/game/data/UI/images/backgrounddark_image.asset.taml
new file mode 100644
index 000000000..185cd6577
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/backgrounddark_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="backgrounddark_image"
+    imageFile="@assetFile=backgrounddark.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/clearbtn_d.png b/Templates/BaseGame/game/data/UI/images/clearbtn_d.png
new file mode 100644
index 0000000000000000000000000000000000000000..229c71e8bddaa102f495a3dba47004f9c65cd0d4
GIT binary patch
literal 593
zcmV-X0<QguP)<h;3K|Lk000e1NJLTq000dD000dL1^@s6a_i)L0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUz^GQTORCwBAOi4*$V_;wiV;~-^VgYIJ
z^73K`3=AZwdj0zK4BNJC3j=9_Yj}S9HrJH2v=|_5{O9*?E*4hSZ<4C2XLDxFS^}iM
zfz$ytF)+bQ0cmLV^{x8#{X17&XJ^}@moH;M^!w+}<v`*fd6-(bCXfx>0s?QkPn?)w
z6CVEP+t+W**N+`j{PO<2JW!f(R$hMapFe*XQ8a;^<ei(l{`c?SjNiU}W1d%1Y=3;s
znq<>}fcc&U1q&WrzGU<D>sRJ~|Nb$;HG%v9vf=yp@5~EJ%j{0ATbF1a6f`foz5TGU
zkMHBZK=}_JKCu4%`<IyorU~Tf151`D+&Fns@$`oEiIyQDb5kZvIQZ+=FQ%ibRw*#E
zvVI4#|Ni-d&;$ylbsZfkKtITVYyfHa{p&Z==TDzl_RpQ`C$6M?o|}{F?|-2G;LZaD
zD~RS66nv~~V)6)N>b@n56}$ZWa=w55ESxrV$`TGP&c7%D0g8vBl`A{>#l#-3tgkQ2
zR8m^7wz;{KM@Z;(+3GdzvKks+{{Hz34m}oFOoJj$N=5Z+-m>NMzkdJ5{O|8yMqVD?
zKm39MzuDN>{(%B$^X5%VKwbYCk<;G)|Nj|*als698ry$h&@!{I{AFfl{tFTZ1~u4K
f&!0Y90T5sS_@w(H5qG>u00000NkvXXu0mjf2Ztbp

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/clearbtn_d_image.asset.taml b/Templates/BaseGame/game/data/UI/images/clearbtn_d_image.asset.taml
new file mode 100644
index 000000000..ef78852ae
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/clearbtn_d_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="clearbtn_d_image"
+    imageFile="@assetFile=clearbtn_d.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/clearbtn_h.png b/Templates/BaseGame/game/data/UI/images/clearbtn_h.png
new file mode 100644
index 0000000000000000000000000000000000000000..5e67cb13b2b4a85172bfa47e74b66993f0b315a2
GIT binary patch
literal 595
zcmV-Z0<8UsP)<h;3K|Lk000e1NJLTq000dD000dL1^@s6a_i)L0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUz^+`lQRCwBAOi4*$W?*12U?3h`U;%0H
z^73K`3=AZwdj0zK4BNJCGhhO7U>Z)GIKgXfZeFjXq_kgNUj7V-2Ju1S$m*D2rhp`p
zl9Fcr{{5R5=;ZW=4<DL<=+B=&tAoU08bN>s#>mglFXG_fcy{jGxe}m8#*ZI9GM_(p
zPV4K}uWDReT(?V0OVju5+t&+J`X6r7>({RxLPA1j0TnU5ee;GTDJjwa)albT#>U3&
zL4koCPoF;ZdGX=}>z_Y=nBbcJ{{71fH0}21PoJ2xva|ipoIP7*Vq(%dVZwyX5fPEM
zf$}_W-n;>6Vum}9nVI=>M@NUoh4be%&z?P7X=ZBLvS8uDP2azNXPP-<rYcbW%eSvz
znScNK#RAtPDk^$l*|KGI-@biQ1=#@7@aOj*#y78Cu>ylRQAAkeFdrZPpa1{=Gs2xW
zapJ^25Y5TSd0R(E=N8C@o}O;)$f)S{??1kax3#zR@eA<(K?!mT3yaSa`unr^czN$E
zUc7iJFaS<0UAAlz7dO|l>C>iXT3T9u1p0>&9^{~y21T5Oh2^KYbLX{x`t-3I=nMva
zet|!dQj))bw*LbK(3UM*m>C%v|1%<|J&=2U{P@8N#BBfm{$pZgW%<Lx$_n<!Utp+#
h)I56d@C-nJ0RZKU_!T%UNAv&y002ovPDHLkV1nFEBVzyn

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/clearbtn_h_image.asset.taml b/Templates/BaseGame/game/data/UI/images/clearbtn_h_image.asset.taml
new file mode 100644
index 000000000..882f3eb59
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/clearbtn_h_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="clearbtn_h_image"
+    imageFile="@assetFile=clearbtn_h.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/clearbtn_n.png b/Templates/BaseGame/game/data/UI/images/clearbtn_n.png
new file mode 100644
index 0000000000000000000000000000000000000000..ecb13a8d661317f38d3e4214fff3f0312b7b8af0
GIT binary patch
literal 377
zcmV-<0fzpGP)<h;3K|Lk000e1NJLTq000dD000dL1^@s6a_i)L0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUz8%ab#RCwB)l08lXK@5e*yAx893m}0+
z4?=K&2#FewK!JcV4Fw%1pruKQbm>wAA<=LJelEZTKubwTGJIwqVjwiI($lj%e)b#h
zSV}4U^((?ZzW5oeF0X{QG;0x_gI(Zp1%{y0u%eoqB*Be}+Z35ISogfn=j{1}M~e5r
zom^~6<PFZmU-o3Ftwxc~`|t%grt*PxT@s(Tsa(|3ghnPfB-dAyMYsu4E~+@#kR=x!
zAn3v6q|U#1>`il#Z>bB`G@&P}3s^gaM{dn?`64>vd+u<n30q7b5HDGMKKZsi{|^>y
zC)Ag|rg#ir`9=|JM=PFw+g^xf&*YE1hYH5v6--s@cbdf?FJvm;W#*#H1Rw9<U4Q`q
Xq@h=ZBb5SJ00000NkvXXu0mjfavq$!

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/clearbtn_n_image.asset.taml b/Templates/BaseGame/game/data/UI/images/clearbtn_n_image.asset.taml
new file mode 100644
index 000000000..343f47f6a
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/clearbtn_n_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="clearbtn_n_image"
+    imageFile="@assetFile=clearbtn_n.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/collapsetoolbar_d.png b/Templates/BaseGame/game/data/UI/images/collapsetoolbar_d.png
new file mode 100644
index 0000000000000000000000000000000000000000..984a63853c4fd48dd65049cdda3025de63842420
GIT binary patch
literal 280
zcmV+z0q6dSP)<h;3K|Lk000e1NJLTq000L7001Ef1^@s66{oTI0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUyx=BPqRCwBAOi4}s&&9#cz`(%B00ZBC
z{P+N*3RyrLJzYHpc6N5S<ooyU1uk8^Iv*@4At}iqARqvjl>hgS0Vv4;mgMH<W)Kn<
zW<Uo_40ym0m%MrXI&R5Tt5#x{Ja^_a!=uMfuuE>;x)r;fhYuV;(S;&;;NSt=u63|?
zz%6O(;J_d!D}&pg-rnB0C5=o>QFLPjLReThZb@}b%@L7I2uePB_z*;W0B5A7%a^0e
egYzdqfB^t3O)<b{;yon*0000<MNUMnLSTXl*lv{o

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/collapsetoolbar_d_image.asset.taml b/Templates/BaseGame/game/data/UI/images/collapsetoolbar_d_image.asset.taml
new file mode 100644
index 000000000..38f99f874
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/collapsetoolbar_d_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="collapsetoolbar_d_image"
+    imageFile="@assetFile=collapsetoolbar_d.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/collapsetoolbar_h.png b/Templates/BaseGame/game/data/UI/images/collapsetoolbar_h.png
new file mode 100644
index 0000000000000000000000000000000000000000..7e3de8387148c02f13b1e7f24f984de37feccf69
GIT binary patch
literal 468
zcmV;_0W1EAP)<h;3K|Lk000e1NJLTq000L7001Ef1^@s66{oTI0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzc1c7*RCwBaQ@c_^F%aF|<O3+NK>Y)0
z9XimShOxs=YQDsp@gJb1gn_Zvu?5E&#SyLef*bddTyF3YCK)zo&)JhrF5V0V0e+4h
z&!GoIxa##X<m+==n=O{N9yuURK*SQP*N=dsnwM393W#xGCjTgBh9DS%*CeD2WLQ@(
zd-NMqWJQ1um_eB+OsRPw%T$R~*8MAczzo4;$qbQ6^L$>dV>0jSi8!D*$CI(frpPId
zoX)3*M|j)3>wnqT_NAKB=~Qb<toza?as>Cw1-x!H26BvM$lT86^U`fnQd^FLPP<cr
zPGyCunGV{Q7jV*OM5cpy&&=c+;;`H88q-x|B~$90w_0#|+|U@x-nxDJ`u*z|$CpsO
zva@DWd#f)2<GCaujUp6k$YZLR-KSllH$&ElJ++92;<+-WHWd<+{$Q41^=VRkL+aM$
zAciOl_BmkXD2RnU>Qqy@lE%w=B^f)Fy&H|PPw->A71`mp00RIT5=iSlljg+$0000<
KMNUMnLSTYWrq$s9

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/collapsetoolbar_h_image.asset.taml b/Templates/BaseGame/game/data/UI/images/collapsetoolbar_h_image.asset.taml
new file mode 100644
index 000000000..231201217
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/collapsetoolbar_h_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="collapsetoolbar_h_image"
+    imageFile="@assetFile=collapsetoolbar_h.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/collapsetoolbar_n.png b/Templates/BaseGame/game/data/UI/images/collapsetoolbar_n.png
new file mode 100644
index 0000000000000000000000000000000000000000..b36de3ae049d9743a09dc6fc26af740cf9841360
GIT binary patch
literal 439
zcmV;o0Z9IdP)<h;3K|Lk000e1NJLTq000L7001Ef1^@s66{oTI0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzSxH1eRCwBSQcX+4KoFgjo}`B)UhJuO
zuu!2Q;vefT@mE<8g<ONiLm&_^J(Pmb9Cp^3x7jpb4h+f6%X{-SJHf~Mo279aC3kac
zEj>Ox_mJPyDg4SlUjSNW3W5uGwOEk!Lx4uX4pZl7UqAx0i=rnvSAdP_$$A20Su(H_
zvh10InGB}9^1v-*3Cso@F>PaL>L}8isTm_PeHKN5r}hODW+z|w`}Q5O#yHtL&*`VC
zP~)7=kRBzVBuOw+YZy|xe)*kcR2>cgwbuTO8@Fkiwr+iIX4$!2->q9vYwhDG`qk=o
zMb~kBVd5z4oUzQ=+;7}ZXk^<zq_MnNQXIwP3Ahy_)_rUrwy3$i&xWZHMWJJ2P1r5i
zFf9Aao&X^$0y1N~*V>2MX<21r!6szg-dfzih^e4%lbv7^R`VYwdnU3IbzN)k2xeK9
hJ@8zg^|AXCU;u#ob3iiM+rIz+002ovPDHLkV1m|A!NdRn

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/collapsetoolbar_n_image.asset.taml b/Templates/BaseGame/game/data/UI/images/collapsetoolbar_n_image.asset.taml
new file mode 100644
index 000000000..9e7afd9c4
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/collapsetoolbar_n_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="collapsetoolbar_n_image"
+    imageFile="@assetFile=collapsetoolbar_n.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/dropdownbuttonarrow.png b/Templates/BaseGame/game/data/UI/images/dropdownbuttonarrow.png
new file mode 100644
index 0000000000000000000000000000000000000000..8c420ab85dad8b5ee3ca92464665ae071a471732
GIT binary patch
literal 132
zcmeAS@N?(olHy`uVBq!ia0vp^EFjFm1|(O0oL2{=BuiW)N`mv#O3D+9QW+dm@{>{(
zJaZG%Q-e|yQz{EjrrH1%sd>6MhE&{2%E`$|abUXZ<1r^pL9db1gt1VxgHed#<;qq~
cW)1^}6XL9#0Z$iS1nOY$boFyt=akR{0H4Any8r+H

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/dropdownbuttonarrow_image.asset.taml b/Templates/BaseGame/game/data/UI/images/dropdownbuttonarrow_image.asset.taml
new file mode 100644
index 000000000..24976a2d6
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/dropdownbuttonarrow_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="dropdownbuttonarrow_image"
+    imageFile="@assetFile=dropdownbuttonarrow.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/dropdowntextEdit.png b/Templates/BaseGame/game/data/UI/images/dropdowntextEdit.png
new file mode 100644
index 0000000000000000000000000000000000000000..3966efbb56239be59ee13cddceab917b144882b9
GIT binary patch
literal 390
zcmV;10eSw3P)<h;3K|Lk000e1NJLTq000dD000vR1^@s6OE-s?0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzC`m*?RCwB~Q&Db%Fbs7dAnmg~0N3Dm
zSJ*M=fx<D$4K{82fFFLUonYM`QYUQ#(n2yPC~3mb)J}WBil1Z0c0z~*!0$THoUs+o
zTa;U6$Tk~5n|1iXvy1>^?7l2ZX@QwNIJ_tdJyVq-O;hN*R;|Jf8oKt&?reAz#jswl
zv@I};de2`VaYRw1b@G>k2y~N}rTzTSqF{8F^S*<Z-A?<`rSj&bDlUbDIG)P8JV*-L
z)5SqT2%z-pOcKH{@PkI&X-T)75ICMrevlZ?j;?NaKmy?WIL|b~l5Tj2gY*6$F86K!
zszt%*E`L89;Q8s%zg&Vf55q8(GwVrlf(POD^iWlm{?iSTB=Ld_Z<@vi-PLuyMVTHU
kN}lKEM>pfDsBZxV07vonVb4jntpET307*qoM6N<$f}R+y&Hw-a

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/dropdowntextEdit_image.asset.taml b/Templates/BaseGame/game/data/UI/images/dropdowntextEdit_image.asset.taml
new file mode 100644
index 000000000..7006d8448
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/dropdowntextEdit_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="dropdowntextEdit_image"
+    imageFile="@assetFile=dropdowntextEdit.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/expandtoolbar_d.png b/Templates/BaseGame/game/data/UI/images/expandtoolbar_d.png
new file mode 100644
index 0000000000000000000000000000000000000000..462929e95039217cc59fe50d6a95c2b7054ac0b8
GIT binary patch
literal 278
zcmV+x0qOpUP)<h;3K|Lk000e1NJLTq000L7001Ef1^@s66{oTI0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUyxJg7oRCwBAOi4}s&&9#cz`(%B00ZBC
z{P+N*3RyrLJzYHpc6N5S<ooyU1uk8^Iv*@4At}iqARqvjl>hgS0Vv4;mgMH<W)Kn<
zW<Uo_40ym0mArZVI&R5Tt5)KceDwGU!?`o3aof3d>sH*7Al-)#9Kh|`0|)U)I@mj4
zmz0y0VX$?;A?fYyjom>YT}CFR*d@cl!f^+Jx~ArcNG3!}K6>~NM125fq@~N3qsxQy
cCqRG!07OkOz~-BXZ2$lO07*qoM6N<$f=)$pfdBvi

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/expandtoolbar_d_image.asset.taml b/Templates/BaseGame/game/data/UI/images/expandtoolbar_d_image.asset.taml
new file mode 100644
index 000000000..45a7de130
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/expandtoolbar_d_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="expandtoolbar_d_image"
+    imageFile="@assetFile=expandtoolbar_d.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/expandtoolbar_h.png b/Templates/BaseGame/game/data/UI/images/expandtoolbar_h.png
new file mode 100644
index 0000000000000000000000000000000000000000..c33bcad6985b3862324279bc0f5457755b94f28f
GIT binary patch
literal 468
zcmV;_0W1EAP)<h;3K|Lk000e1NJLTq000L7001Ef1^@s66{oTI0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzc1c7*RCwBaQ@u{ZKn%8hd4P^(2=E4U
zMcrE1vs7$lqjR5xx#At#F=MM%%plelAwdv<sZWr@_Fb;I@Z&0{`aXZ(Io~;WGnrWU
z8GC-F2_VANXcQq|pJivc-rOe032^};2C&;b0?s;#tO_(h^b0fjM={e{!4MKHLW)3!
zbxmZCeq)NP2vCb@m5IWXGh4Dum0V@bzp^c+wN92?Lj=#;os;Ls74yEn5hwG-TsO%V
zI7KcoWZ<oMho^@}{V$K~6L?vPJkJAL_r)eM4ty;NxZkWbN7oPrro?i!3f*g4rU4EI
zLzk-wa-ZCQ#7UaM;PL`&W%b(BKI6~KvP?U*SULMZ&opp)oWgm(?;S!fE8a45JiZPJ
zR*m<QAXj$Q>qS?llb{VTLkjAsY;|aeyj=$>HXDkKfU1h$Gh(W#P&4TdW&oR`Nq&a3
zTN8um?Q=toI@keY`=EJd?T*CDZYvdgmA#wIqEGOnEJb$uEx-Uri&4ja71Rp=0000<
KMNUMnLSTZ?xyoSx

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/expandtoolbar_h_image.asset.taml b/Templates/BaseGame/game/data/UI/images/expandtoolbar_h_image.asset.taml
new file mode 100644
index 000000000..003d65496
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/expandtoolbar_h_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="expandtoolbar_h_image"
+    imageFile="@assetFile=expandtoolbar_h.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/expandtoolbar_n.png b/Templates/BaseGame/game/data/UI/images/expandtoolbar_n.png
new file mode 100644
index 0000000000000000000000000000000000000000..0af2f1bd13809d099ca3a5a5c9ba1dc42b6f66c5
GIT binary patch
literal 437
zcmV;m0ZRUfP)<h;3K|Lk000e1NJLTq000L7001Ef1^@s66{oTI0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzS4l)cRCwBSQcX+4KoFgjoTP^&UhJuO
zuu!2Q;vefT@mE<8g<KPrdI<zf52YY9huv}JZ8ql1fnj&w%X>4~o#5^Dg=ri|$!*BY
zbpP<!V}4Gj=;QPK2_#!fLGVXj%;zL{1kxzkQEDB<g(N7uEHKGX32RKx)(c>3B?F$Y
zwO%=>X`z&@9drv@g0dk;N^TmO`W3-u+KiE!MNwe&sko4$lziUp$nSm5RBnu=@2aBx
z{tJ6eXN!gmYNct4`g&Fzw)&+;bvRI-=QzXGHr@KjvWz??HC?wpRyQl0+1YZdyi5{W
zUN4=}-z_)f`gSe%?Dp<%8~-FuXmPb@UGQXjFw*+wZiCf_ZQoNiaUAu!c4K0>t=SF5
z!{LASY^7JJHJ)q5(e1RYDluRawr*}2FECOnsnf(0O2YO1qqJU$>_lDHiXEXW%d$tF
f>$5J~UjYUHlxB7wIAEv(00000NkvXXu0mjf?KH=8

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/expandtoolbar_n_image.asset.taml b/Templates/BaseGame/game/data/UI/images/expandtoolbar_n_image.asset.taml
new file mode 100644
index 000000000..f3b62bd23
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/expandtoolbar_n_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="expandtoolbar_n_image"
+    imageFile="@assetFile=expandtoolbar_n.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/groupborder.png b/Templates/BaseGame/game/data/UI/images/groupborder.png
new file mode 100644
index 0000000000000000000000000000000000000000..61234ae1fb3dee29eda38a371165d36b060ee426
GIT binary patch
literal 1273
zcmV<V1P1$wP)<h;3K|Lk000e1NJLTq001fg001fo1^@s6#ly*40000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU$n@L1LRCwC#SvzPIK@^>Rq)0SqBM&U{
zK~RE8k;)fTv@rNVFsUphN-&N10jmTOk|LETicKV_m54TpVAK!`|L<7|`4E(7K4ARB
zDus5>J(HaE?!4W7v&qH}czMI@+&44#&Ye5=o}G2_O1ZzkpGs6d@8oj17WcW!E!8%I
zG7SwXm(AMBn08BdCX>0T948-RoKK$0X0t6*Q&aiH#l^fexw~LXm>2UyPMmS3yc8^%
zPN&txvs=#V2iKgriKmXs^9tJFqjWWIBOj#Opr!-61IK}Xx1-s?{L4G0_&?_ilXv4x
zqfZ_btu8MwSK|-wsQY~v)cnk(&+H?8J(|C{sz$fn!M^&){#~l$>@n5f-deC_;MX2J
zsxZHFtA)8SUGF$_vOr$N_B~qGz~m2~oD@4WwsorNs!FYtyCThVSEZ(BX4T=g^Lm1w
z!FRq%(Y|`AS3jc<Cv~l&6_5**^nUE6$45<haxCVR@=D}Nj$a<p%0U1uOeL}MFv2(#
z2tZ${WcR?^$Z@ikN(RYGnG7hakE(@|L4s|Rj2aszuRu{)lmx5FZHXdSgCyM`&REk8
z0u@DP>65Sso~f)<#1w-6X-QZF0;z1&IJw>OAO*=w$<u9aw^a7jxpvjrwAD8lZSX;I
zyD1QJnWq}GrEaI@2l*t&n({nFPh5Gd-h59NoYL0bejO_A4ZrY|mvwVZsn^ezHdWMl
zi#O##dGJknCDJ-deNmOQdkZGUfAxkn<>5nIM949%2g^Yzljy(oWy)Hf<EFN}n}?Zc
zLapFC#cs|9Mu?HF^DdrP%GqLE9C^+^gPwq9Xi@7?hD9wb^UI<uhIxYMYeA<p%Ga1q
zK^r%$SL@13)%@pg+Skx0PVf&S@6;o9F$W`D;8Zduf{z#*WH~5^XfZqf1Q<?@z8X>=
zKP~7s_`nZIkS{YqF~l(je$;4#Z=xBAo(3O1_wqgCBii5tJte9r;~AA?zGq4`(Ts_n
zWQL)#a^A!gm6r6qM+nP?0Sc)kNm@4Xtw-=SGYrxowl6GaQ(5@5B&1Y;X$f*x_i`5k
zxlG?JMp&eYe3Cfrf#}H=#@X;~|BtO`5XzBM3_XQWv3X-F3LkUd8np$mW$;ZD@}tlb
z@grOWzKMePX$!hz`6y0z95fS#p0K!L8Eqx>`_a=%75$H%65feFik{-gOB_87-@a&t
zo=kbNraT|vFoAMIeOeI8_0#*bHBgfWlms3M{F=|;vk&HAk-V?7qf70j+dSQteXuCB
zxme0WXRY7zZQiQU6W{Gki*a6ad*$6z80sP_3%q+`TtsI83dY1J6eRh$8vuYoz-JP{
zd_mbs-aVmUVdndNBq%XE#kqTuz$8gP5_<Q<Lj%j8Z38TzAeF>U;MoS^Nw<l*Ix0X<
zunJEqYTTO=92dLblEiH<HjY;~oP)a=diNy#h{{q)8}uXvQc2E>xEOTzWZpMPmn%SJ
z?(zSC4+0292nh@kvId`u$uPqZCPNED8bgi@LmbC`Ql1P|ln1?_pHA~@{Z%BXuPKfW
j%4_?bDUt6}KLr>7B{DrC{G$C100000NkvXXu0mjfaJE^D

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/groupborder_image.asset.taml b/Templates/BaseGame/game/data/UI/images/groupborder_image.asset.taml
new file mode 100644
index 000000000..2038044f6
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/groupborder_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="groupborder_image"
+    imageFile="@assetFile=groupborder.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/inactiveoverlay.png b/Templates/BaseGame/game/data/UI/images/inactiveoverlay.png
new file mode 100644
index 0000000000000000000000000000000000000000..feab83209cc442c5ad8dc73c2b86e0a8115c4743
GIT binary patch
literal 131
zcmeAS@N?(olHy`uVBq!ia0vp^A|TAc1|)ksWqE;=WQl7;NpOBzNqJ&XDuZK6ep0G}
zXKrG8YEWuoN@d~6R2!foRZkbkkcwMLfBw9D?8~Obq{gPz9LVg>D`Q%4<v<{Fdsia^
bBOAk++056YCV$cfYGCkm^>bP0l+XkKL$W0)

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/inactiveoverlay_image.asset.taml b/Templates/BaseGame/game/data/UI/images/inactiveoverlay_image.asset.taml
new file mode 100644
index 000000000..f992cbfb6
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/inactiveoverlay_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="inactiveoverlay_image"
+    imageFile="@assetFile=inactiveoverlay.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/menubutton.png b/Templates/BaseGame/game/data/UI/images/menubutton.png
new file mode 100644
index 0000000000000000000000000000000000000000..3cfa036d8f5ec1d5458b0716efd2ea477cca0c6d
GIT binary patch
literal 3559
zcmXw+XH*l44#%qqWh=YvT0r)eB~$h+$R3K90<t%X1sPJ=y8^QJD$u7ONTEzYK(K5X
zGG&xKEJ&3CKHk0e{mx1LImw5doP0?V%%FO7)Ev|R0D#UwU)%gj1+T1|lH$t8t%lwN
z0H}Y4TG|GiJB5J#1O1+Oc)Nmw;r^~**XJHj0D$M;&^ca#qFB0De}Y)-J|3A!#7SDZ
z0_`Hy(w*&)`#~=(GKQw(3vT!LmRuXG|8wr}rR(|cbO|Py1ga|d2eq8#3`S@MUT7K?
za}n9~uyb>77sF2cwE-f$I6Ia@lP>$8pT7Xdg|&C3=D&EmKGZR$`lF#_rjVQMSf1cG
zh?Vs{JgjO98lRX9I8ZMpGN$D(cg4|yWM#Gr1BM+U_x~L1t&cullRR3652VcSP^l4?
zNhd7o?|JE$$$nu%dk;B?m_M(2xm*r8Cpe)*Ov>_F%Y)DlgKYyN2XkdpZ-J=8UkP6z
zjU(Ik`V^Rn@S3#pJyGAi?roxTLI_?mu#ku)NZ4R0x=laq;$b!pXtIEY9_W1iY_obC
zcMfPFFxPZ5_BgEm*Iq4Wx8KX+7M3?DZzImGE0Ez;dJmkE7D?8NX*g<S)8WFA#vCj8
z;$?jJN@RGK7=PKUeOMNP$@k?W=mm{zrqadeqg$|z{=2>}&`P{BB%_3%QXqvdF=QX=
ziUmTOiaR$HMlTa%9eST~P2k~@0PQ_)>Hbg<2KjURPMGUvWAlpbO0`q#anDoGyK!xW
zh6(a>p1{P(4)~q<@V7|^w0x4v8pu&Ii*Q8!Etr0vLr+Xzf?6!dIZ-Lw*4aochS|bU
z2?cH53mTNJE(rQ8*RpCP)KGym5^iqVsnzQ*L!t2Yo@jJ~2Te*d2T_5dZMQRyCv2zn
zjbj)mW|WdI^)5lEJXL=2go#Q@7N;^?|6UyHU&&(q&||~O`jN?z+z&>6L!_8aZ4=Pz
zlzyIVdMTGA>vj4B=TmmldH$KBS1D4=$qHH)NZ~AD3mP2)(C=ryubaJ9AX8oN=qr3J
zJlK{!tH2{m8bmwXCUn}fC>W$pc%nfpCg3}rM}(gKxrt9UC-yDaEOk2hd=PJmV5)dP
zStV2<c)o7m_@ua$M$|ZCto?+4WxzYD$hFP7Eaf3K+qJ1P+wa~yqQ#DuR4HU$KXd;k
z(g~MSA+Y_x6PHT2u%6}6sY$RAnIwWpwc)sSbFPkRr+c7&s|2i!H(BoBvv8+K-%^-f
zF1;)t&>_4HT-VR|yn9s6hd!d}dxo|%w}_eznQ4><-#H=v;&*&`qMg2i9;b|GnB#q3
zP<h=FzW)}Jn0-KcUF&sPQYyzW7weSIwj0eP(Gg)p?t*aps`p)R>r`i&azOKhf+nBN
z-J&i^zIrLG-R3rNxW>WxDT^Kh@+cZ4prOfj=$}~Nc8D{uEu{}c`Y53c*jTBitGTLk
znyj}cZK}UVEjn4)%jU~beKlI^3Auh|#TkX0wl3t+-jPwAi)k6=;+hrS@R*OSF$_e#
zEPkxR=BD!;1yodw>Rd5Iv~PvUPLLd>{na}ysjPWK>V-vX0^8NX5KGRsG@Yj%BlN-)
zZN1-<;zUUIR9JdJwc0Ga^`)J>4N15bA9h{sD6_5r$H)2OlSabc?e+9)YMw@%mp1Nl
zgBh_R-S*#Z-hiomp+B`)h<6n;IT78Rgv(*gi_pXEM{dO>4V&XWgihK->h2}_wB>c4
z=|MCb&!?A-16D3yJiI>NhNu!_nW-7}1S6_Wi6~zx5pDIr97S)(dG7p`3mzi5;;!E7
zb-Pysslak*`s`7uLi-moDVr0_LuI=W7`Fg&=Vgs7I7d-lf*bV=DI!>hd9Qdotq$DG
z`85Ug?KpL3X<d*VRCXij_<hdzpH$GrpdOnesToeWnX$TPW<#4p4T=reTa@O9yA_Q^
z#^JlhxgDFTbv@WkX&>K<qAh4hW?xeHP(sjx0i!Tb#_*&!>7GhMwxKE8{Z<i(a|Zv;
ze%AP|#&uiyK>>^_42ORbpcst!#1JNmXnM6o5O4O$0RQHcN6icK{Wi)SI$e>6*5fod
zAQNw6klE8NXxii><I`_6S-09@0^cDGLM+dsx$ODVgcsJG32oJ35a*|<aP$M(ySKVW
z>Y6lr>KzEwt&$8P<hzZ!Wp|R%@AxfVAR1d7;ddIPcS?kE<@yssqEBsIH|J(ETy(!#
zFIw0S;%?TBoP3}*dIM)gB;1tLajT=eb}PP!XHMGivyjO^PVTpNs<`c@K?GfG<axqb
z%@;7AX1ZmXRtT>{7p0LWS@wb1!@&?O7~i7zu8k#pyDaL&A2#;FwH}<5GB4$4yUg*q
zW8Kke@GQf0L}#r1I_y#j(h=1EOmufk0gNYS_;g`PleK@e;ZYgAwD&qE6xxxM4R}}E
z>^Ld3>34>?=dBiyYP7nRcOW$LLB88UEegcQJr^C^B+$31^BDaJCMigGqxMFAND^d`
z?Jkq3Dml_no1xOg&*xcF8b7Q3T>A#%MvT`gI2tP6o~9`frO+YOeC?Cg<oaK7hEkPw
z<sBCFuct;Ipp;1RxdQ3Q6)b(5?Ci^K-m>N&)5Y~W?DdSzeEXS(eh<7}Yc{&4O6l0j
zD59-Zqgk1uKK<S%*QVtRP5<H(!{~vUDRkK~n3ZrchA(5gJ;7g`7~|++r~1tmb=RL6
zNqL>!lBz%{XfJToQ?h+Cqyz}5auKgo*L*a2ttS<*C&ZtWDbA_eJ67c+45&tk4e5CL
zH?~@}3Q|83pl&vV;ck&wgp;oq*@dQB&v7Xo;m)~Ym$h#{q5{nt{B}l_;%^~MEB^A<
zJ68`*CV!lnoZudr-Fml2hBxbdEF<K!Gz!)4+<BozP}&LI%-+?p$Dz^o&j#bHrcA=t
z-pz^FD@Pc2L9<cT<a-79){4EEs^8$?LZlaSg(ee|M|Pj3DJ-wS-C#l!BHc59Nk(T%
zD1zqbBac^)!VORZ!5$eFKKt@sD1U)Ow!HlPB=3@?U(Azu8n+t)pOk-7948J-pK&lS
zzTJ?LJC~sPPU5CNzWJlXukJblzALpj2js%jrKOzTq*=7v_o(z5kN2iK#Q%rnXV4Nk
zef^x%#a=jI)ObAfwf=TE`@^kLhOU%gx?uQg_2a6@S9;a$IqM(AFu)i_R63tOoBL$K
z*lxY%U*=}dQy2mPfgU(E^q;97wo2gVr})9lls)5OM?KXJMu}KWq)Y$V_mjVLeKAG+
zU;R=b2R?<PJg!BPeSTIe%3>z@2^87Kz^npk-v?D`H8bVOV)Z9Wdf7A97Q1_k!vZHI
zg@hb_drSVVeevzGPLGr@`BC(bWzIe8nK#rV=2?8lM<_FRYA2YPIZ2;olLJA<Z<@4w
zM|ynAs*7i;z33#s46Y=U2i^>c7Qfs+*wz@~Jv7aX!0KfN6XUVM+5uB@4_rBTOP%~f
z$mE}0y8&}UZGM<57`ePV?dkq&Yj0c?a>`H$e-}j)l2OjjJiqIf@2y5!e<QDS-Z7VY
z*{URsRi@hJl!&#6VWCqiFxE*u$?}4fnm>AwCQjGs<AA!_@)B{}o~%}W#z&!7HS$@n
zn60qMu#s#%%ly-|%cVTO*+t(^yjDvJ;TSAdqjziZhNsnf$UMp7O^349KF!6OPJ+zi
zwpPC%<`I_*xAPYvyOY@M%dpXu&6%-H$m-q%@BO+<4e1iz%KO|FjTT8|lQPQ}GBQ=%
zK^B{5r31R9KL;{|+&^F<B2;I)xZOJzW92K=|3FH+R2I}#TwVqGdBkQHmg_>Bo73o*
zr%$o?U)`v1xS)1X^U8%FZLLra&K=D05#za$=hbp~1YIq!Th_GwQkiUHOp@$fh<zo(
znx+f@T#ND0(lRs9()#}ae0BB~glDMg_iAu`dOVp3VY#oYA24Xf-4|UGUvAkz$!h3O
zY6X04)Ky}jg<M?~!mx6k+t%O1DDLj8h)_oJf}yF<L<#fNKS<3a(9KlRkAtPP18(qL
z5o0+rrl?vwT@fCp_pMe9B$jKm-D%RV1fJ|9oWLlG)^>T+I+t|d*~C_Ly<(&S`wCOS
zW{$6IA7`Ize)b5wSh3F#srdq`;yXs3z}qT;J@0Sbde<$hrF%!tlncU|#4Q#gCCV=H
z<8FZV1Gyo#MhVe^7R9<O4zI=6T~awS))Nn_m68>+(=`|&E>mW@<g8^)o)tOz;}Kta
zd7qsd1b$u@L1Z{zv#LqwQvbz!elRU&Y|>`X0~-4Yo9E@zAWDqY&z}+-d=yLpe`NhD
zn=ignNRbReJJ33*QI|d|t8M7dVci?_QYRHgvFrK~d77nw_Tq7cji?@nk`UZJx;bqU
z2-bQez6=1yb-QOY&ZsUePR`ADx!GS_00LtIt8W_scdi~23Yd|e_LW}oTMHX`B~<?U
zc0m9D4b%VZ8X&I#bd>}K8<^+-*Ke?ri}TMj+=gAHRt>c8TR#7`Kixyst3j*N^EUk>
za)`?&dm@v<+xC5&*puKXCw2tw+k4w$_p;Vyk2M4x1V~$#Ln@6&-97&xJ`n_)#QhVa
z7_C<0q7Z+>lpmSz7CK>_)vGXa>P!DGQ13(&#lNvCGhE>MmxXXxP%)|f8~w84JXYzS
zx}su(u>ALx|6!RR5)kD7FT{A9At4W5^4d?}aJ(b`pJoUIQ$CF8?;g;s8b$@+zbL4w
ZSBpO8NK=0oeKjq>KnJS*AI-m_{|h>L*X{rS

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/menubutton_image.asset.taml b/Templates/BaseGame/game/data/UI/images/menubutton_image.asset.taml
new file mode 100644
index 000000000..467c7443f
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/menubutton_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="menubutton_image"
+    imageFile="@assetFile=menubutton.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/nextOption_n.png b/Templates/BaseGame/game/data/UI/images/nextOption_n.png
new file mode 100644
index 0000000000000000000000000000000000000000..ba710b061a2c7c64ceade2461ae2c37051578189
GIT binary patch
literal 8517
zcmeHMc|4SB`=1b!EFqmxW0ECiA7f^$V{9Y)S_;kbU@S9ZmTV=7(jtnKt%&xLoJ3Sw
zPm7AIEyz}qkWzHCyw41k&gpdC^ZWeX|BlZy!*gHX>wDkVa$nc|Jhr&G*w2w$AP0d!
z=1?7MJiy;f(MMJq{N{G=_JTm<>SMi@3p{91P%e)X#0m$Xf*39U1)^C&5J>c+!M!VX
z^^g>7KcCwgAkjx7N|EhG6=L77gC5VL02fc3I93<D8J?YGHCMf|GX3%AiQ&l4UAz6Z
zBlffm9BF=YdvO|p*#BuHR&!%r>)6|4?>`~WYem&r!YEr9Rh$Q7Z!<<-^C;D)6ko4t
zD;GZQuPB^ITO^%vSCe=@Zf8ZI>Y|>mPlI-A^X~i}YC5J@UVH6L_gD@8>Mwrto$g=H
zw|?Ckwf0WtOO=K*krzG7W>aqG*~dQ|AAh)hsJ}{4bKESh&$4D{WVCz7=E6mfj}3ni
zq-}nE`ZEG~A;3MQF1u$yt^C#1>y{J4nuC2WZwv*MC`2{Kd0L+3<wq8F-V?O@#F$tl
zzgcrZW_ajuAR*x4F#__#eC_UsD!h8s)mamylG5e$9j5plXauVCw2Mw!WrL(dN7uDy
z4GuY^XruIH@;CbYt{4xOzTbNS`>S-x_8E-TAKndiD1I24NG;?W-J!ht*l*aP2EVv`
zlXmcvRWqSoZ5Hr7>o>+}ewf%ZBiE{Q6?-V08ymAXeQp5V(4U|esJSQTv+Vo&QGCL-
zz15|A)2%MGraK<FOi_nReRyy=xa{>_o~n}U_1#BKV4h_z?Hmo^^Id1RmY=?M12rn4
zw4}KyA*guPa^jv<w<=s@oqauS9nAFe>jyGdc-}2<@>^-VF9%-U=6L*Md52xD`P;T-
zr!Kthu;0IUhg7PX$%~MpH1soOL$=;o-Bwp=9micpw#RV&7$)LM@KbLe|A@E7Elo$L
zg^<JExofmYQ4f+D?p436dOQ^OGA5-w!^PrhQ=^Mz&mFx`lVcqBxU@FQqIvA5?wOhX
ztpRR~%JN0JiTA1KJ61-|Al-MBpan&=XK^=)3wWEd7opE(Ix=@(zjS|f%7)b)+F2_5
z9$bKq8L$<G<JBw1m3j9HCNypmHx8-sEPLL~2qht_oYk$elE+myITbHbe`&$k@3SX<
z;CcMmZ|mo*>m#U-wC0x>GQErz_&zRIQi!pBA1RwugMaUR#i167p@p*eQSqsgk4}&O
z>OnkQ<yQPa>8*X4VqCt~i~FZn2Ec9%W8OSGz1?T4jqXl6P1~E1H<Y#v_*@vBzbc(r
z;Vy@+IM9@&?Q^zsoUvV_9L?-A^nW7U`Yz1#hKXYrZ3uVVFhhQ8Tt$yD!)t8cN}Z94
zy3GgL`71GT0K*@5W*(l^v_@Ye%d(fdx7@`ZaaD0~-hIEL%oaxjSgW7fF0^2mhV^Y)
z8ZRg0s`2s6#+9XS-ASJ8mp-eO4qTc=ndq>G-HJ;(piS~HWe7q#SM$7Yzcn~pNK3f2
z*JE?>BO$_ENVw^=u~%~2C30ESCgo-GUaZ}cp6a^ptz`MrROxK>=Zm!3gV(QpQ`xRH
zw=TiT-yC+OdqYInRm;kcondBXgK{ID#E1T;F34@iw&&`b8{}Jb?H*AwVO@!|ZGEM2
z8;RMbe@FMeIx7+u<CCQ&agTSQ-20<JEp)}zQkohg;VvP+tJ%)Ho^kb%b(1H*V{xfp
zvMM8wlA~A~k+j4wM47tKM<%;nN}Fw0_}Z5Hlosess;%GkT6rf*P!OYz?pZ=PU*cb1
z@CpBVzUka&IANeQqD#Ymtkz_0mq6xLtxg2pG>rM-#CQs-cl9|Ry{fZEHL<=<qc!FM
zJNFsPE=docbBM4@wUl~5O}3ZWZ>VM;)@CfF{VBH?-*><L)$=UxqL*#Jwmk<OYE-ZX
z2Ra+?I%7}9#zw3=S(O}6c#4RRm(Ln_lR~Fk8>y5%&(V*>4Cu17ckYmuY~5(3vX$io
zTyt!I1s;8+OViGGQ?5PUbEqJ`b*K>$v%qp8A+nlur0i8z862bVNzT+*f3^4g0}t}c
zdsXIm9%z<*O?f0-|641Pa4yQ~7biEm`;*v&1=w>9$E`M&>PgHp=M6g6Ri76Qs}SKs
zTN^s#&y(w|?SyxFYTJJGo|DbHq?B~gU{ts!B{)d9j8rDE0@AYKfr-=c)>xj813vZK
z>+BfUO)e4EGmk1QoOwVg!1}rSqSpn7ZIu@V&Wy)BB`du<dZQ?3UZaYFgXW6MDZWeg
zWa?a*p^R^L-bps_t;DhSB#r=HHw7xP>U)BE8ho#PGCV)TrXwd5V;U|jx$~rN*;p28
zy+N#tYP70`O4%8C?Hf6!&mYiA3dRrKPtf=!pV7vE`KrO)icV$rZTGs@ZDK%$U-94B
zdCU~3JT>%U9yM3t;JmeiXzJan4=r}^M3aekxlL~L?lUnBlHM6oK95*J(?<=OZu#;H
z8g}XE1Bm^q3b!8STpLKtJl|}IfIgZVMh@0IVwq`|5_T*pB~yE)R@f|TGr5xe*zkAF
zrBDGs73-<VdSw4VYgg<3n8BydEhc)}M;d!2!&-DDgV*cib{y5!EPSH9-qTuY{rqvR
ziq;G*by<bEiUd_fW`=d~0>{<bNC%fAsN##&)pO(b=eP8`mq{oVL>!rS_Aw+pm6aUI
zRLhbX!ePQD9Fd8L@WVpyCnw)Ewx!On{blo6gmAyNMxN1g+fjclG&cK$^n{00Dn6Vf
zu|!Y1@90*WtZmMF{3J&|=8Qjk9?)tryx&03Y9Ut&)LW|6RF9sk3wtuaxE!zPQ0M$A
zS$?ku5UEe$`uzHe-%LVR3Nk#CD0i=CzCG|DwMp`VYDaiD<o#B}!=tjZ9d%b94{|(g
z&?3(wslJuas&dpZ>V(Y^c3nQX@E7W;j9%!>K)IWtw$F5;V;!hH#Y-2KCv|%1-C6G)
z^ZVWBV-3csHU07-3S0K$YtBSwbNl$SCrr=u$CHEOcUmiU3j!gZmk4hg+gb%j?R4_9
z3O!;2=o+rbH!93#Hyt@9t1`>f{yh1!yw-0_S7s`=Sx49Vkj&=Y=_k(V`3DdFT9BB&
z^`oCk=-G(^%1w`?{v$1%h>#PS`1-W2)o60kIjh}TvptH>ZaCL}aziida?urw<X6VK
zZF+qC!jn)&A6u?nO`OQuQr3&j5!6_x)mY~a>D`x*4^+LaXwcZ+6f$53^K<!~nP%I(
z??OEX_BtfT>3HMTEO~hB@8x7li%0PpDc9raCu_6FZ%fY)Ir<i|U{1SV*eepZ-wG;z
zmzM(duQVE~$L`#WAQsIZ*GQ8-SkiBIERTG*cv;c9Tc1Mh$Rt-!8-IJMaF2uXHk_84
z--A&Fxzj3_+CvTIq#sZ8DC;xLZWwGmz0l!gMSfESackggRB`~XC^08*g+;IDSg_Q@
zZ}m^0erjVmA-5PRv#g`sLO!1`)3(GejYv7*k?a%gc0S?kyvEtUXy~qM!NpHTd(l)@
zrsm0q)jA<qQsSx%vhVe(^l(=tney;=*Ix9uC=oXo6v~G3YXt>M6kAr_%ET-n4%i+F
z^#&w$mR^uZJdC(wv^^~=M3uhYU$(u%uuCtw{^QI`7AUW{K_DQ{mzLa7FHF`qpOxr(
z@)ymbltH@*1<l-Bdbs)i_<KZOq-^#>mHli*x9640jV-42_y~NUQ<h4XjK6QnOVxM%
zgt)tz1<rChmof%qZ`x+2Z+ZMUHvPyOB}{N~yycJq(?_AsV8;7>4T1XAL3O?_jP=&J
zpRSTB`aSmU7C}3%y>K8D$7X1pswls5T`hMsaq;f%V~umxz(evew*y}3T-=Zqv;Zet
z96DmV8s&E%JE%-C+wYb?Vb1>0s^s@ffA`Igi>^cIS~D_=G9Zu{$t()RjY^?>IopCK
z+Prl;%^j{<X<iRpdC<d8^AXubhaxQNRPWaJHcCux@Cj+Y+}nT*X-F@wB*>M_l(C$5
zTmf;fic~3=*eR2eo11Z9TjqF8aXsv}jXm+_tH&ziWTJDu56w64NjQ)bOHx+nz4yNS
zc`Ia-vYo67410zdgr40xB2-ii9HyJqer(&nSVvu6I$Elmc&J}@M0(`Tp`(!<dOJ$X
z^i}q&r1cBP-S#ER6lx+74_`jbRyNPwr?*3C_CZ8e)!yC0<mep2Qp2TB<M;}-c@+f1
zW>VObj2hH(H($)E!^9-1taKYW37sZ)vYIaa%(3G64vq0`*DXUPJbQQD^q#T!hD4|v
z^iljP%klP;?s++aU5SweW7o?p>>!^J^`XmK#!ds}E|4c!?!h%5%5_l_)YzgT+q8sF
z5uM#tMbx-UPZdzFinmmSEVIbzpesjP7IAJ%cCCb#J{xW6xX~|}ey}8qldzGp`i#xP
z0mSgoz|i0m?BJ((NHv~!&4OLn1A(Y4V1W-C%blG_3{C`s#^lfeM05lfd>Da1%q*k1
zG)5R8fYO0r7TX*)TwMc$vY6&DUt?#KGnWE{upDA}fM=|W7b7-|L1e-#E#%CiNgzQ4
zAfQ2`Bf{ByQnWct%u53Q77Zg|P%%UhW)55K>;|Q9cmNcKz#&j@+i2Dr49r3fYQ|#*
zkvwedrYOKWb6AK#z$GD(QBhHdC@g}*3r3=eL?RM}L1Hj)5CP}Mum!YeIGev%L@~)>
z1MnF<7FWRHu%RMO8l58)n8RS896Ch~N*T7%;Na8*qI)qtU%*6C!5bWC4+ubFP$&W%
zg@I#;$m#l^)Y<u~Hk&`?MbMwfXc`v@K8qkDBEHk$3vAbXo9~Ajd@t~s59tB$IYJ%-
zuw4VN1&gOo$`^P5-+c04P=N672)N-w{`5r)`G9ChY<M^`2nkvxUi$P&?WxXgUv)%r
z2xdia#Tp{?bR?7U6~`6w!o?US0||r!5uhb}kQx0QUi5JLRpUErM3O%(gd4&UaQGn{
z?vHi8ivOf2U<LifJR-@T;GkJQp5aSi#Wsr*fMmmA2t~$GZOmcd2!hFCl5n<UA{LLq
z;4u_CG};zNuqI&16k{CLnu13Yjq%gescgQ0#%2It)LEc9(HM)yV(BzEHi$rj;~01v
zoMwVHhNI9l6y6v^Bmw|>8igy51#VMX`2Tq&qWF@?Zd7v^27wY2i$~nTX@VdQF9O{6
zEH;x9#s4PqVnqO+0-DH8Xgt;!k3kbqXbh2nH6eTh`2ajVxc@|~XcPjC5lfg1k{!rN
z1NQ+df))%Qx$I!EKooEig%i%<d4kmkFo)rdjj_hxL~g8TAbhzEI5B&Y6^)u)t5{Ji
zUGW3y*PNK-cIGfaYOI)66nYZqJTQ1PQK0~B`8F=vg5g5Zus53pE_QPDVwL6JWacmv
zusWbnNN_Pz%Mn9X{1gJF35mi3Xac|n{D9mjG!BkNgEhtrgC=1yBoxjNg(giAenoS5
zUK~!iIZPBBsK}?{)r!Q<V0mTI1hhZXfm{R<j_?OM&<m`fn7>1diYe4=s!WocI1I6u
zCKt{W3ny!>H7yu9iADYl{3j;Q5Ka{PzvKA^{mMe-38FZ>Fjt-{JrrOFe$MkF@K+`e
zu*>lUycp`=81)C78R&UuXOaV`%i+aLo8J?NoV=TKPdH25bf8di`6tmBlexyHtpS+g
z2!dXo6fr_*>|g-wvr{$l%Q))?HNrTEj=}>dIvk6_px`tb&KOQ-G8yn7Iz5PJLdW4u
zP(k0b^Ep9+C>jqS2ZIT34kL?tKGf|?MTLTAGySQ3Zt%TgR0ts2#M6@W`>dJ_{#4`r
z-&o5;)9EN<6BHZ^05~`<2t$Aq0UQ%<f&z@OC^`-g&?oowS6}|YT6?f#iTBLk8Hqu|
z(cm;FFEoyX!ICg&*pzu@NYOdsOKi<Vjq(rCpGpWDfX4zuYsce6hyyQf*(By)w+Ylw
z+XR>!U=Jt#C<i9n4BGB5^{2L_sKJw{qH60Y<Z{DV0Pp*3{jz)i0%!JZT)g=?f2%$n
zHmObFaAUwW6(VqrV*hmd9{?vAoLCI7^8a-1>5$2AO*;mHCQpum$4l_Eiu`(9o!YBl
z=KL>zrfR_datbK)-%0+FfB$vYzwY`+9{5M#f3xdfcl{#|{3Gzc+4cYCF1c?nyZ|<M
z`i=r$XEk3M0pF5Ar0L7-Z6IL~4G2W0;dB`|GK=f5f)9brRuO$>KyvctgM%^xs<W-k
zQ@MpI>T1$zz)kRlrzO>f>;?YU{xR9v#$Dd(el|Kuifiqbpu<g&(t*yL#lfF&kS%@R
zW?$zVTA=6uPOwXd`t`ci;#U!NvNi2}+l4t=+aiCxsCat=6gdz~Cd&4jkhg5Gnw9vs
zSNIm*`@Uy&)rG61HM@QERjkfhXG@gLxvi59cRRG9*IhTU*!@r<(_MF?j{BjFy>1ED
zzQ5MCYo*sG=hgMeK(C?`uA!!1ARYzkp+S8#$b$y?(7GGKH=t)SHMUz0CqyObtsF|Y
wB)j47F9M`@j@|5DWjmFpTARMOpkaH-DtEZm{G#;}pm!luTNj%W>(z<>0S&_o-v9sr

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/nextOption_n_image.asset.taml b/Templates/BaseGame/game/data/UI/images/nextOption_n_image.asset.taml
new file mode 100644
index 000000000..55cce3fdb
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/nextOption_n_image.asset.taml
@@ -0,0 +1,8 @@
+<ImageAsset
+    canSave="true"
+    canSaveDynamicFields="true"
+    AssetName="nextOption_n_image"
+    imageFile="@assetFile=nextOption_n.png"
+    UseMips="true"
+    isHDRImage="false"
+    imageType="GUI" />
diff --git a/Templates/BaseGame/game/data/UI/images/nextbutton_d.png b/Templates/BaseGame/game/data/UI/images/nextbutton_d.png
new file mode 100644
index 0000000000000000000000000000000000000000..76c3ec0ffbfd0e390d18bf15b641406a1c963304
GIT binary patch
literal 279
zcmeAS@N?(olHy`uVBq!ia0vp^+&~=2!3HE*cE)T6Qj#UE5hcO-X(i=}MX3yqDfvmM
z3ZA)%>8U}fi7AzZCsS>JigtRsIEGZ*dUIWo&smX&Az+(=poWapS<ZhfQfC>z@o$*?
zhV8dl?=!aFoKn4xeZo2Nf4=Qb$;zCp)-ipVh!6ks%DPE^D{?9q{w<lM=A>Dx9i9DW
z-@5CHEdniu-!^_}`*}dN=v;ZV<s^M3!=xh}g8xOP2R*n^&41kT`NRkFoH+{aXfL1g
z;BtrIp^b)YZBv6>vUv|*i@L#DeRZC~n>o$)T~mbY?ZFzA*KO@H&DTlVp33;PS)Y-O
Z!Sa~S%jms^DnL&#c)I$ztaD0e0szoGZ1VsB

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/nextbutton_d_image.asset.taml b/Templates/BaseGame/game/data/UI/images/nextbutton_d_image.asset.taml
new file mode 100644
index 000000000..6c616a75a
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/nextbutton_d_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="nextbutton_d_image"
+    imageFile="@assetFile=nextbutton_d.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/nextbutton_h.png b/Templates/BaseGame/game/data/UI/images/nextbutton_h.png
new file mode 100644
index 0000000000000000000000000000000000000000..f52f5fb4230f07e879e02d61472b07c57d07712c
GIT binary patch
literal 549
zcmV+=0^0qFP)<h;3K|Lk000e1NJLTq000XB002=41^@s61i4(d0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUz$4Nv%RCwC#moaX_FcgOWXDpHtp)j!1
zfrS$=A#n*tE`WLguF!ihvT%iRfs_GOCWcOgCTUXJiD@7}oJvtssSg>0-qXkL_v~jv
zlgT7TvAv7&%t^dYr_+a#hr^+@TrOWYNQ8?)a=v3urz2xpTz;W+6qyRv^uk~=B$Fa*
zY7trZc?lJ%X2T_NO4CLKXgbTNCUvD{m}Vo<o4l$hO0njO^Gt>^YPY~Tkd2ce$z(`A
zSFm{3{j7pUGGsRDL1tMpV+>&!sySO(N(;fVWY6>Px?ZdKIygr@9z84;3mir8H9bcT
zKSQ{#tA_9UkIBuZg(!-!TCLy*m)dh=+qMwLF?PEhHk&s@;`3dyZQCkM?RFd6?G_i?
zH&3?FXf)96b}<|dg{<ZcGE0UG=A2_N7@*(p3wM0>B^9J^vSnF{HXe^vpq8OGKg(`@
zDPc4kq4(575CoTb2I&Kvq)6s=Hk-l!@S!1z#rXq!I-TG+j+$?6tXwP5KmRLDro?qz
zvLl(u&>hLB$<Y5bQBQKE{}{8U_?F2oWxPP`H(H?fF_f_CWRxP8)BFdsQLzkZ^0K^V
n`~6-$=BeQMd~WnS_$9yqEFfuLSH_B`00000NkvXXu0mjfAI|j7

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/nextbutton_h_image.asset.taml b/Templates/BaseGame/game/data/UI/images/nextbutton_h_image.asset.taml
new file mode 100644
index 000000000..b084a05a2
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/nextbutton_h_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="nextbutton_h_image"
+    imageFile="@assetFile=nextbutton_h.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/nextbutton_n.png b/Templates/BaseGame/game/data/UI/images/nextbutton_n.png
new file mode 100644
index 0000000000000000000000000000000000000000..203133732e50b1df6bbd9506cec49f44385cf9be
GIT binary patch
literal 484
zcmV<A0UQ2_P)<h;3K|Lk000e1NJLTq000XB002=41^@s61i4(d0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzhDk(0RCwCVm$7cbKn#Z6h$UMlk|hs7
zhb;8P`jQz+MW;xp6CFyHNHAo`6q5@$+$BfOMx4Y+9&-6G{(ZI&-o7_q2<~<2>=P8+
zw(YFdb&VZ&3=k2N&8;vD6%z#@SPPD4Vq~7_lP=Gm!*~tPGFXzjSBY6BP=OAZn1#Yz
zeMOAFs`Cm16Yd2fQ=s2N5ee+0alltX+9{%Ju=RO7?f|t1WmQ!f&x7^dJ=)Ck+zLbQ
z8C%e;EK4{X{$aeYESPxc)^_`2^&U`(>ag;@-~WwZxO#4HMyn_aV}GbRTk76dt6?AK
zsxC<qNYm7S?;c8)WyYRaqS}i%jv-zyr?9O=Ki2EXHyLfEzl@^D3WMLdfy_?9hvx=9
zYi@u<AQ%D}7sW*&!N`DtF*oQI;t2%7+|XbO1Dzv`b=)NJZV%dA^R5Ykk?9$^7d^@6
z)yBiwU<(9R)dBwky2UI>-Q@=mGD}pHXHn{a?_1VZvZ|8^e0u7drcunPkNJ1EWBngI
a3oroff;ABVIBm%Q0000<MNUMnLSTZF<kEux

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/nextbutton_n_image.asset.taml b/Templates/BaseGame/game/data/UI/images/nextbutton_n_image.asset.taml
new file mode 100644
index 000000000..24619f279
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/nextbutton_n_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="nextbutton_n_image"
+    imageFile="@assetFile=nextbutton_n.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/nopreview.png b/Templates/BaseGame/game/data/UI/images/nopreview.png
new file mode 100644
index 0000000000000000000000000000000000000000..fccdc858bc36d7e390f8f1b75f9604f8855ce112
GIT binary patch
literal 34615
zcmXV%bx<1(_wR9ccc-*KaVuINxD+YU;O-D8?(XhV+$Csmx8m+l+}+(S&-=T7WHOW4
z+3X(up3j~QQ&N;dM<GFhf`USqkp`$hK|#lUe3+47K7KKrb4dF5B6gI}bX2u7b#yUs
zFo6;^wlg%LlCd!`Gf^=yFm|&aG7*G=3SN={i2ih4K50izq#JOfAc{+J%J!n15#mfm
zh1ExZ!o;F8g*vO8PnPJ?ZD(+ofhlm=EmS94tfh-5_%5ScWnBejDRC$>0druqyUGAf
z2ad>Nqx!;HkN3@2CKk@`8z`1<ua7J>Kjx@X;P?CBU}R*dAY(aWc}p1s?2xH~i<-Kr
z`d^Lp_knvKk++8dk?1_^DDxYe1O90)i5XCFl>^$z^TI~!)xVe`qxRnIoshhPFo3FB
z{hN+F{@cAk_VejMWw<2QQ=s~7%e=Man|?t=r-O&sB!j?PsmFOp0HcCkgCn@m#jA)N
zpAhv@Ub4SQkMKGn`w2p_sxlQS`7T*r*a#%~4x8~;C{HZ}v}8H~`gtM8C;gpC=a>S#
zWnZYIq*|)^J~?cv`EmGve-tHYX1+@~`7QfIylUBjDO?>&4O~=oEaWS#{e@ur(9s$y
zg$t&_9FWfn>tEq6ZbdAbOn82P<oi-H`aXmMoZ3c)2UFpUnivI$mLpYv+;0b3ddoBb
zVi|#|i(Eu?nfc>L_6b*rLID;+BejSM6s1d@D2EmQ|Hnp}CV-f-^{c-&9^nFionUgO
z16jW~6Um|xqWG#?c3!Jv>r2p*cu6pk^H8?TTF@=>xKNOR(V~LZ%<mEni_McpFi5~O
zT^}|Rqd*`_EoH)E9$BN+xsrvn=Bb^_Fc}*!p+1UMAWQn<e>j2=eB=b4<5Jb|MfIgx
zbOE~bftTAG#uCIunJP9s6;I3882`IfBdq+X$)(yHdh)LBfYvt&|J;JbFTmZ}8u?ER
z)aLlm>Rfr)%jP^bQRe4yIqwO|43^VMDkqM{oHd@pm7iVnSsdX0vo2DAC7`}b%@LXo
zV-qgmXaAZ2P}w$Vq~D0W&2Qn`|7^NIZ2{>0ihn}yKzE!3)+K~Hlz|39H!f>J!l9T*
zrjTI4eE<(BZRFceW-bakY23U3ohhsE%(Jga%dWQncOi;wMB06mJa%((>RFo+afX-%
zqFBW4<y@jnYHF8k+Nb~XN!Da|GOtH${y0>=%QpcDrgXyvap~H8`E-E4xc~pzSST0&
z3(>6D_w2RiBojRG9aJviQz0DrPa&aN68{;`QRD&O(b=rF!cgbFSG|MEh7+clixo4F
zl-qLhKPQo6rcd9|aJ-Fp=8`_J<94hu!7Wk!x@$|9XY6&}rTx!G{1jtFC+=ie;Fb+_
zQIz7|cvdzDBf)l9AV;8v@c#@_Ct8rIAe1A?)u$rL3bEws{e=ag5ruD>1Ldjx&!_|D
zyGboaaZFCRUYN=q-=*aHgTw@rBGFH8WBz9`{!l0RUN7`YRi_W<P$|@e)KW=H304{-
znmY^P`KpnSuE)-}9#wTXTx@ikOG@PX1i<N`<DemkmN(D@KP_?I))g;_)VWX`Ac28k
zHbOXT8#-kYOIv*Q|5Bh%f3n1J>XqEcbF!?yw(aG%iskio=3=J#y|2gctR3;M@B=lX
z>(DdeB$~Y_mU7*8Te@O@@Vjd0|1K?1UA?!GW$NhV{B3^aeW4R^^vWG|LtEqhCZZbJ
zTH$@Gc(eF;hF_w5;ePDi`>7PHWuPk8|F7e<`StmC<5`H$|AH88`(ip20Z=|1wp}dz
zih7aoD(rRL@$VU<?<#0^?Ab6#>``FCl8I^eTu{|5Oc0Txi|4KzbK*V12fTy&ver{(
zcINo=M|Lneg|_z*TR`>nDk6gj=zPcP{{K#o3!Kw&Sb@G(_f-{noBY9P$o+;XBKR!#
zPL?O~_LwLiH?D6sq5byb{cSnh8#@bA1iG`q>+Rk2$C*S&j_t3}cg*+v8@c=k$*}V9
z7;3%S(Zi!JFlxI-1L-3pf`K}&TQZAK%>)?aK-Y^&ePN83%NU;*7vcLAQdjYR_xJDJ
zakNs4BA66{53_n+^yv&!MDft(@EIaNH}K`9IedlX@xC{u_fu!!-(a)1N7f3j{a>zR
zOn5GoZ=_D%xmJ)oYJ;cf*1h+cY!psCYPWK0b#z-2SYP<+`kPbQ-R%LQIm1A!1=^UK
z3>&X2)ok@V0S=O>3zAv>ztBJY^kG3EQsp{&PZ3n+L6IlV(G2e}Vq(TShd<t`-c@gh
zRqC)!>5%?0CVUDSBmbpc+HZKc(S4fj=DLpigG|uN^4ut9_wL**@c021v+HkNwRhxy
z*@ylE0%JR8ZJF87p4;iRz5j+Cqu!O|pMwwE7qtE)6#i>2B_{iQlr`AH(!!7=|ITm>
zV}tv->-Ajt>U0HDq#x(vduvDCySl!?>$6g2J{bXA*2u`nKs5QjPqWW^hha^V&%5_S
z^OuPyh|u^&r-<tXl+YzoYMXw^R4gh&zyh-FYXa*uv%tnI`upa)fjK_ZdCBiD!HCx}
zZ);DNM)ews6<*s`)h0e$=RppZ!4{Dgy<PW3XSPuL?&mf643us+JNYrw)tAqR=LlEu
zAOdK0UMi=D!>XPMqf;fH<9RS5CPmvltccTj`@Qoei&V5A?l3g0FHETQsm&M>=#dR=
zyDz2v^OG5|1GF=F)BPHzBeZUe@Y643IFGn<m?GiF9m0oo!Iukh=ym=+`}bE$zvFdl
zju>Y$GO#N)tQXs}Tz1i~->m$5LF$k!x4Zkdi`gG*GJ_*_uOn;F5kT$TZ=}K1El#3;
zG+UlGE}zF@FOm=`>GszUN0%YKw>t?xgrAny`MsVT8R~-2HpoMSFT=z`gt7nph6V~f
zEwSxm%BO}<J|#V$cXmd6!!$$JuP5V6($6`?=JSTC5YK*ij9&Z6e;hI;E(DX@CQjM)
zWZemcs_$ZJ+imVQQ-oMX2>j~vdiYU1xJbEgJ6}Ad;;6j3`qYh`&WlALPrIz#6PbsZ
z#)T?<Tj2yeS~j@it+t7l?VxinF1iz3Q=1+#0{I0kyVlokpQ|4M`AL8u`W#&p6h1GP
z=#kqS51T~MPVpE})6lHYqdI4dm&oVvcJB8==OXhHWPKNyD$4(6-R6=i1+LG$wJi>-
z6sSEe8AK*6=t3iHE84gq4^uHSh~;{Z6YYNp`+OfgJ14{G8*D{h@L<1mRiOS5B!*6=
zobO8X*vO|m#waV$@!HeyIqm3t$4q{1JKDt50zrvxz-GaI$3;10bD3-OwR({1y=uw3
zz&2J;az`m|BYxiq;g5oga*&83tYx@ggAqif_?hL=kfL9$8Hw2yi^&%8L%;nlZ6Yuu
zU|o=!nkwS`CYTR3FYERB4*B}}!QM5DuuHT8uI@fe<Sjo+R<TzG`px@U%jXz3yXW#5
z_SoCVS_i`UWrT@oAae7Tv8!XoY+UdT@%_%-SX29G7$5vHRqVXSr9&2pAAXo|56>Qz
zdoEEyCD^C#`wI)lvYhE7z`M3t6d8-Q64e+N8Ql9ZyDF}xjDA|Vzq}!?dF`xNN=E>X
zilmsjO8;}V$9ek#Ljt-lyx-1t_PdMXP9E2OY3GwHXw;v#<(-!DaF1DCeS@vQ$k#{s
z?P0&Y_M5Ode6i=dl(6T;hNw@q#}%rcV-(G1%Ej-WY{zfU=lj^rEBdiJ&4dI5?URh5
zZtU0k`ejT$w*8Z3YZo`+GXGphmU%lQvl^D^*JHkz^4sd02w{;<d#c~wScIbA3ta->
zH19wXOsOR?FMIFUbP@93$A~IR-AOE9OyT8w6B3(U8Ww%JpvCz<!MptM-bAewxDjK5
z`m*=~D==tZu-50j7xNWGKaVqyjCwS0^4|zWx<b3IT|Lm9)f~R6ESr6oHmtwD;Uj2S
zd!vQq&6u(@A1OgTM!f@+u%j^XPLHL%)j@dy>uBGYQ#TbMFy8hz{e=8F<^lWSFT0-j
z3euQ+j!+qN7Vt^R-?EWIb^uJiWzi2*63(uweD(~;@S`x(jfcJ8E&q1iik}jJH4VLA
zD7_!<R8#b|UPOF4b##XSOq8~BGygsnv0tK#GVwb+-`n{-7(5Y4tAD0>h(l!F2lDl2
zGQ2&+w9NSTl>4gkv7_#N)w^C?fM&0_<_hTIBKvmHceaMdhQT%x=2%(Xl!j1+U6^)G
z#d>&yT<I7&*&>-L?8!sI$d?gjQdfqkj&ZQeBIsIT%%=Cfye=lF`b7B37asdhg4QiX
zf0N;Sm$bT;HyqN{!@daRPO1RBmA)Cy1kL&F!#*#&KD+I1VT&c{lG8$Q`J5Q^RN3SF
z()c6_?e}tRmgtZict*Hju5ItDDXDTH*7X=3edYS%1j?Y=-=W}wQdB!$qWC%W;SKqO
z1ia^0>d+f))*M_i-Z3g11##MN{spaE3KgA;B42fAuLs6;PI&Y~fisjI@YQ3}kAXet
ze4^Xz+!%|;@mo~Q@f(yJc}+FHO4a)zR!@7V{axmpxSSa`BG8sW`*U{yBK=8zy>JF5
zc(e$|kG2+zwp&skVwoiXOUluQ4o%zbsT(zb&#-Je>)RC@|6d_kq8%c!?{a@C$LR~~
z;dm%zqV9(xBA8?fo3iFcz@)^1r;T{Z1<nh<OjZpNJ&o3x&qPUz^CrWu26Q(>(Y1ua
zm2yF*!Zb#Q_0nPPM|~DLSQx~uiMHAo*=~%Wfb8*34UI7IQ_0-Y7gG|e4lDK_3Dd)H
zOU($^b`Vkz8$?|e?m!XX)8%@O=*{>qAeTn#Eh@N8cb~KK$%@?TGswB~vh&>vmd|na
zcbzMqHTpO~Eutiojg!e^%p0tiHb^sAwzt}VjaIa(aj~R=AePy;Z10LAwn8UH(BY$Q
zN4y<$>Ew2fd>CfZ%miVF^%0r~y=Im8%U|Ie<agg1%CF=4*|cz)nG_UbG{n1Ot8F@j
zOku)e&e`^d3qHtfs1!RsPvVg81BhT0_#{?*GM;#DxAk^kb-cP3mT-#A*h#k-+f#9d
z7<89N_Y=%Fu!zfN655;luLLM>dYH6A`m!FmYJ}t&D;<G(YQ>egDI(9TrCmBhgnu!;
zrZF+34eDeg?1Hht^6@4TK`Gg1!jvT6q8k|aNF&s3w*Lu>9?gRzG9HX>8F5bXV1HxT
znn;V+M@L^wSG{wfA`DQzBx1JHm?x=P44A&>uV^NT+jcII$zKJ;Kv{93F>a&P22V1a
z(SA#`<?ln0?GqDY65_kG$P&1opYR6Vj_BpR2kKWp)MQ_~I|x=LhF{8?mNes&R`3^F
zjfO9K2K^yBOj~fY_H@r&(U`)nc2=2DYM-*K-|<~=D!cz|2*q#oaN(rntm?7bcSZRw
zg`kE9E_xq3cNY>V+7hG2Y9xtQ<_E<dt$v6WCk-H9kMHg%7v;Ar`GdoKmWq0R7smWO
z)$!(i$`JklZoa|EYnOp&O3LpW#5B}4&r`5VrE|s^cZyvlbxDAQTGC#cy{4O<Cng5V
zs*azJYjr>EOs?ZXyn92mzObXk>3_=q5XS~e?I~wGBKd{3yQ2AH)%wX-z79KSW@0|5
zGDksTI`Jz%{@_r=8{-O_a-3A`1_*jK9pi{qQOig+*eY3FVIkgPJ2mK-mp2|Ef%W$x
z5_RRV<dY~p?F}I)eU>ki3|?32fblhCAo`F}ME~qOcy6Y+)%lk6lq@-roNd7Uo+N2n
zJibT3G0*;Bl7WsH>g6it>JNcN?(unMp~!1&B%1Z)m1$Yal@wD<ic1&xGmtx7H0VS(
z-=u`Ntx1KyaFU{gHc;Jhvdv>*96cXhQ?a|Cj-Vw4+E^;R@!n^rcQec13VPDa`*vaZ
zPgCk9j4!H&|2a@axaB@<hoU!@zR5x!%Qs)?z^)4`TaV1+LUkI!Q<f1&`}Hbi-238O
z`=Q^589vOBNC$p9KUAH~q4DgTo{{V{7RwY{-jzbtm*nPb_pefyh4xI08>$p4H2L~9
z%p~I5A?|MXH(CD&#P=bQTNjlxC@{rq1>ooFD=;KmcPdNACV{Wrc*$VDuNv~@CI*yd
zr$z8zWG?8*ym!B!A6u<IFyco{I|urjpU_{hl;YJG<iJcRlUe2#YdP+ipnvEx<U?Le
z&l{t5)<4QA%EX^~SeA^oH$%K7dPp|-gx!Mz{%-h)lb+sq(_z5~7%U%7>{7(vCyS$%
zH|BE^S@Zvd7p<5V*i!#X>ZCM%!e1+LdH-J++CCreLlq>pHAlOh)=aeD)=|PC<(sQ9
z(#H=`Gg?zz5V>`^KWv8lc~gMS7;{BmaOUnyo>9j6*V#3R&rTot+b}9+iQ>g!<&IR=
zX!~W)I!gS0Bk<5Sa<0nG3ai5N$>J?L*OM2EFr`Jwe;Xe;+^yuhepkykteT{$Sz$aZ
z>Xti1k@|<?_aG<g3eWSUM(;bbSzxnLs7KmgfG;;kZyIb~>YR>|Xey+#{qfJ8W^PEM
zO55SNy)3NEVG0(5`_hU)5<yqNLle#g>R@RgA81(kFE=74nR&(wiuY1s@0piZZ|IaU
z<S4!LF-NVKe#}p-_-jO6=Y2>5<}1Rh*=Z84+1u2_=OnejN>$r>Hz?GiN+#2(zy95I
zQy22C9lxhllCdl8qmDt0)i0-En~#cTy(Flztbvc`>8r)a9t#b@AhtKfnfo;+UKFo?
zL^?T12}`%;qM|=FZtrw8Yze$<1RoFN&{WgCbCX`NJx}&iL5`;nHQV<hAfbHxWiDBl
z@K56zS^AT4wBK=&JRZA#bQdHQQF1$dbJ!scm1@hAUVPN&ADG0reZeu%`b7X0&Qu6<
z;}@05ZNdbik;-yQHd6yVDef}<7=E$9NV1aELk7LX_`I#JzQ@Io3A%Q<br=2!;Xi7c
zuW`9S--M)0anT~f&twECRl+bewy%0#cf6nKy_7c;RIHnucw>oNZ_29+J&ttxMkduK
z#0U@b3jloUk=aMm@9ua-ZhNmSC1}x+TE)1o(XO0Bvfmgnp%KnJyHNQ)S9JYq<@cxH
zLHHp7TXgp^!Wp?K4sr?vc+UUjMpjs!UQ?`c%RWkYq3w3hH)>5)L{tZ{l<&Ro$K*xq
zmvml~N>OIEzrW26vMeXZ+~3I9lx>-HF`Hq+YrLS)uops4QB4gq(eJa4<PAJth@T2j
zBglu(U|2w_N>|1e;VMLj_P#%YSbC|R9VD0tkYRvMmV`6xK!e1Q_;KEF|3;w~(D)NT
z5#CvHpf@GQjwQ`Szm(~8%JjDt6wc+T-K$OP(h9+|{<Q5NgdL_ggf7P-gUG)c8>2}I
znxu_eU$2;a+TEgT4^GdwvvOq;!&i&iIA2W<)3>S4Y)(6x8Fjj`<FaPpAe%+-(U^NS
zJlc<gIRMpVwb>hYd1SI7r&zHAd8T8=NvL=28f)~Wp~20I9Q1<IeVJmy-URKBthI0q
ziz#x$v}(XbZ=$0OLN01O@Dix*{#~v(25xb!vi_vbylftXCQ|zAc<YbH%cb(44BtA)
zXNHAS9Jc>x>f3*S6kQN8l<=Vxi4EJfo#N#EVzW3#@H$dsI=o}M8x|3RLU58?JnoKc
z_zPdmyoldd^riy38~43m*=6KI_3inyYAdMTClB^~-tV(GZP@HF>x~l(GW)n|ErFy8
z@i2D8`u^>LRWKFE1Smlnc54h0{(~o9)?I8R_I@jl?ZZRzj1C9m2+vzFiSgZBD1=Dp
zC|*o!0NYg`b9()zuhV82gPz-ksB87>W=Nw?(RN|L5AUNH(rm}`MmuCJ+TUx(29GS#
zIyS)u*-%39)e*PLn-fodG2W3A!@a*Zc!iQ5_*k0)S#!0W_Z6WOEbG<lO6!`JEmlb1
zrK^2}b_)&g)=Ly2c}?Q07$uvcwoO7le~b=^uX*%^IWwb=r@E>rzmiJQs5ocw0Xpu(
z1VhVSpz9=$(|i9_lG5`HGA1JX0{l+Ii5p4Kfb<E@8lnr(sZQNkMUgc6%K6Imn#@if
zA^?J+g<DWkFpPJQN;2QzRJC;|Y+e!*&$nzIeaM!FjH|ct{LlM|R?N*OsvLX;eW!hH
z_g9VzbLpCWRiE3W-jM8M@Acxlh}RAEu_7I|5=3q*OyHs*8zj86Nz;7&G5AaMyyO^3
z2KPwX%l8kYcVN(Dnki{A*<(a`pL*sm8mwO5QrxT-8o(b41FY}YCP3hkD!U}P=>CwX
zGSIw+no~`Rh)yvz%VRESEmtr|mSoEWV8(TihO74X@X&ATVsFJFv*eA#CTfgWHW7uQ
zc=F;zm?{u|_LU54`VYn!$phqOjuUM%m!R#Y`iC-kv}}|efcPP^k6@}3iCA{Febu|S
zm*PmjBTSI=uzz0(LiDf{#-d-%XRn><lGlNcf?E*|dBtr~yO72TRf~z!=O;&vRv*K*
z?tWc16Bftx*qo%UZ|pPgtIlJO4|u|EEvoc~wA*_Du~eN?z8K#&ShUUkI{xL_D$hS}
z!HPU@SHwqiM8>C2f_bM{MH7r4rHqc?rzOfpL<4jpL3ThJfvebS=1g}fC*5armvQ{}
z7z~}vk7Cutru*%N%4<@f{XbHiPlCn+%j@I9NF)Ye8m>-#Z>f_hTVR9ByL8nS&8z_S
zXf{|P$mVxdQxO#)WvqN~4&a{;G*v_FFFI7T8p7*TrhlMlm*gF@RA6;#*Fh1Q*q<aO
zsz8S~(#CaAru*A1&3OQ(Y>WOkWfpzU$Pe<Os6&Gj_nSDSJK_%-F3Cz%fc~fTdpYPs
zG%mg0F?{WM0<JI&{M4?7&&zDz-tA4+^gLJrz|`b9jnff%UMOjLvi;`@BA_xk>;$bK
z$);l$*nPIv%%=yEZI>lbcZV)A+JnMEuyqJoGNf>k4oP)dj|@q-kUqfAIl6qN)K}za
zrEsIG5R&>p({aQQzq$e=q*Rl8chk>Fys{l#c$y<VFO=<BMPhWRjS^^?(;riwh~hD#
z9~kX73@Yd-$m2Xe1SR*lgCQHqe*Xhs8*v3sT~h1A?)&B8lW&Iz%TWI8xUXOu;(*Ju
zWHB3F+N2W5(_niiZeQM;3N$1-z?WcZNOXJNEbgh#{trCovum;)V2W3|m3!yobIhYe
zP(FWqdiYT1@db7tB1gVR4g!P6ci9EY?7<DWK>;0oz%*0y`umyzG2X7Qj}y?cp)o0E
zHmg3y7E$$~+ztd7{5xXBG<Vv}el?;1o3kPlAUmhGxUb?MLTMR{pY`&v2wu`fz<mLZ
z31fAvIDI4%k)M9GuAR(R<$&T!gaGxyLF2KvH_F<s|IG+qe-ytoYyUw3e0WKN(leI-
zuC#ya>kmQpKzHSML!S*l4GPa#hwpqn!nyd(gCla6lKJ>!;pS-jY>a=L)*cp_aL_&*
z9+Y>geZW=C{JlBWkCBK;mz5BuNWg<IZX@D;)ur3gv-LVo%9ExdN>)G9>*VtMq%#Q^
zrUGesy-@WMW2${Gw7O*V-t1IVAjF{fmoQS8M~o9iEzX2~fKQ2rK+xn7TQA&tIkhV$
zTLo1&-gc*Qb{$jteCN{gsmXB%3B*KTAWFw4ApaUz(wQ_1vcBr@@YA|Yf{kx_0ykE6
zJ8!;BcL(r}kEPTu8FQ)SvE$VQ9}H}8@4_yJd~`~%$vH{gd~|}~O+yI9vcrK=+fS5G
z_+kpLL~N$i_eP=HS+>PS*kJV^nJknd4Iix7Wa^x&-s!kfisG<8jdi2T=f3mZ%%%Oj
zJ-xCK2-J=$<O~y7Z#~XD|3@*FY;Ju*^`JuQyGx0Tu&*BQ!7vQF;G#ubjuJY%kdQXU
zciQh2|9Mo!NWWff_G(~InkogM4dH{z8-}5>U1J*_ufFUe!{i9RU4pDvD7~9}*r`N>
zA4`91cRss#Z&u!~N{H;6%H_LseQjj^=QR=4Z}=&lXKJxJCx00RV%V+E%7YegIA`69
z7*~gjsBGi3J0?Zp#3NML0=I`*=X^qBvqIk|+`lz0MS)C&&;VaCiMa9e@GJo28ZfIF
z+YtyV3g!v?M`RhvOafz>$!CAp6IA&4So7LwtD{X8^XUf{0tH&j0a44II;>>5^(V>K
zX#3ozYhIt<BMid!M|IilhDp%Vi{Y=1{V<`F(5O5h(aE7fm6e7fg2wpu^%lxEi1I)Y
z5Gl&S2G^jDolNy2iOFQq`z9Y15#yxem3(FUQj;qpkG)zyc7gqd2$=^VRDCuxlQ2{T
zs^t>%4NByW2;ey)C4Gm;GsK6N1^Zcv%hHxVYV~CS@jYX=aLm!J<P(q>wUVEQm7PjM
zu(C(Qvi|S-%b46iOty|DQRi`2)@Mq}C~wRnBj3&CL~1_ZuT~Pg#-7g^*x_~s4DwH(
zJ|I0>wRtOcfR;gozv}2b7hH9r#d4t>Q+1|*i;ZQ=Mb`aEYC0o;kcGsH1i)Z&L<C}0
zATFtg&6(5Z7x+$>Dl^bFiGpcBnSl+@JX#}*TPYte;h^<58;=M|i;$J2*ZF8?<-YB`
zh}7;+gnys;4J^0<#q0!H+^_cJXBRgcgoa&5#lU;O7O_++6(1;F(xpK>{a6LdnPH;s
zDv#i+fu>(RH?6Kw9+LgE>C$<<e70KW(&3`PL0n%GDrug-mcx%g23Ho_xDyU}w>*Ls
zXWDZ)F(JXtRZI1i$P-(Qggb;ML`re0gW7~yoCY>cS?hGPp{yLvXnZQZ`f$R~K5dvM
zmpeJScmTzpNZ0%%#YtIGENy5-=tkL3Ni58jVn`BIoOE0XXORX5$F`f_2vPBot@{%L
z{kfx%6ecoTWgF@=&O6M`=fSw8KLyjBrVebCik*?RV5XTUAu#DYY!DT6m%Fo<==>>s
zeFM%3TU~o=(Zuf7Sc@ITE`l&@qpk)veFE$6^>0@rBA*Fn8dn=mS6%*LMMz*^O&wTw
z38{1bSr&RD!9y~a>-Nh{!lCV8pFP*S_MZ7nfreYnR$CJW9#L}d9|#j%$-9umD`u3j
z=Fa%4FjJ|c^}NTc=l*&d!O7WwzgjPlAOj%eCGqo<v`UQvEl=3^M3jG=aMPhsC51^L
zqG=9FTr6A@FN(<FQjcV(swGUjqL@cD4Q7smEy9>`{7*9sX<yj=zd9GwhEzqVYW%1>
z$RNnlMYP<nzWtC0Tv0R@9!IfMBIiP`!kg5M8-@6#JTEbP=x$U=xe<hZ{DKb0TI}$Z
zgt~`yB3tk2TI5-mCEI=d+4+2>lZbuG{9&>XVX|Bj$(*~o$CRiP&tkcv>~yNE>N4lY
z;q=}|aE&hoGcs(_Fi~k6>iT~Tu>A6O($}UNJa67WCGGiiNEl5nP}js~zwhDl2`3JU
zhUALMvNU*4o0!Z2GQ9hf(Gbb^i`P$moftG!+G~HqI+lSB1UjglSX556(o1;)hG{dE
zY7I5|BCJ)|D6GvNT+)IbcSq0boi5gbr0`)=`T<sf0bV)7KA5nQOx%?_SH{0U;sCU%
zYGd@4p#nB0hS`24?5TeOR<(hda^W}Iy(kDA@HGZ?rR?YRGsUbvhjQy*@TTwEe9p%+
zIe&^%MjZ<hRbZ0`P+SaEc2@A-K<BGLPckk+1101FU!j=$Lh+5N(V9<0+^|?03I<V|
zd@YqtJV)4;#0nHtudjCJSl|0GP0b=a?nWhGLXSNsle!zQ6B<WKrs}+vg2o0d=Ok8g
zFnVh@Zo>k(LQITj!N(f_mWYywL6bb<5bc(vcMc_aWh{My9F@8y|FNwL5+`F}m$Rep
zRy(+H{2_%ZIS7qy-ZTW0!T`OgdMOevY=^O-X2gF=zkgy8<_q0Gz#VR%QrwK?uiQK`
zu^uRbLb}0$f7XzP=i>p94$#w0Qdk%nT$olvBrI)&aO82g?q!}cYspm)ZSR^L$Q)l4
zxpCNZ1qqPv3i?i+tHldU1IYkpKWQ7n=t?=1NQ-{0{EJp*Qb|3%zF>)-1N3<_TPGzQ
z>DVS;v2FFzx^dHHxG7r_-x^}>AjShK`<Z{jC1vzGaEb^VwNFfFZlzA?Yks(COQ8^(
z96N?1z_o|b0-KgkK?JDhkH;biQ#$YJ^Y<rMS1+?NvFIfKa%Z^4YI`UggfGXT_xeWI
zxpr=U#v#M#>XG(mpxiO64k9~rTeFS2V6LnfNVF%;rMc9L#y%C#XZig^s3-V(HDWh5
z5wrTyo>WzXkQ#XCfyB)WEAhFs5E9TOI!6W%Zb~`JBxAhZZG?e6as|&|e+}b~{KR#R
z=|BKiS`a)S0=F!P^p@awrgw3ED8Wvzsal)4=$yaWY$9vPJl?KSUkTQIjvS~wG}jew
zhqdp3Z(mLg!)y)RfLXJ(0Nu`)Vx)$R92g<zFxANz9xuJ6DYw6Xby%W)T<x{X>I3RU
zpNWXrK6iJa^Ib#>7zQluoRfhO7@KA35<NwOvax~aUwRFRb|f=L^_r+t<lM8~<~V{I
zvxcUx$uJmE0HFo#nyc8<4ZvlqDjna`(X{fqy8e~*ny;3A?9;IRqKjAzKQThpAt`-S
z^co-AIVkpWRN;B`9R@JW%%4|v*h63E+<i5HWj5|v;mc0T53&1(>cUw>X`iGyDA?q}
zu?};pZ<nnI*KaFNXE^&04@=<x9-#LctX8Zak%1x55kx4DeAhb>la@%t$$FCmu_GZM
znR_A!xryfk>J1U7il6+76-}fHmXB0XsD#NFl-|_YKNRHm)^Ep2olmpEgxj!DKIV$<
zkmFVSx$FB`Ptz_M1V%I7aI)6bAA!HUMhuXVb^}Cv_;aL!*S`LQTw*jIQpeKQ4e%?{
z8J5ZJ0O`bLwe_u>>QPqGW;E_j_5NgjS#y4FIQUC+)vb=86CmnC$033C(R!ve*(5)*
z&gSTdzjO0d9T^)(OoEkM@LeND*Ws*`U4x!5&MFQGd*S%2zE&k7I^Ib?p<;XJ<RPa<
zgH7gQyBP}yANjI@=j&v8_xK4q0&}xJbRT1OjA}~xXD9BqZ_MI{m2!fEA)w}23B*{y
zLkbg0eK>y@){F)GB7xG^1*Ev>6g_^#m8pC)46=WmJjp>{p8z42lfnTy)%aIEd*7#q
zLCq+L;5^srPPB-<)f$##5&FQZIFtG$zy(4RN6nU)1fBXX1{_Q6DDHGHa7;+7VEaR0
zz7F}k*_I|QHF#OxpDkqy6z5MkNh6$c9`L_=4bE@qRGOEwFd7n>+Tv4F*Gv|xz>;S~
zxZr^J2(fH-TWEofyV@6;AT8&W49=ncRx9W^m{FL9-QS<&<c{T7|L}XCjJB?~8@acD
zuD@#0v@L?%=PZwOa+8GhA&hvl#vH-RyR#pX7A+z;Fc_ZF?<=ZnYAj0gUoU7vg3ODZ
zSH^oa3D;U|>QA4o9|56U?YFDv9SE3;nJu0(3fFbN3kN$)#Su0X!Sfu<#4x!@g|0-9
z52<i8oE8OdaX>Ovu8f5IRj7EVp#+noHt6Rnb&6EU!5d@MED^2ckg>L!5f||}rWRW?
zg%J8mPtSwUd8dV^AZeH)FOA2XsH?;W8CWOEuc2}>?222z3=Ists4>V;PeXwXCvPEU
zOwX<~Wc}1)S^-nbuv1fgkd(ErCzfy-20$xO|L9vD?q(DJEhu;uE6IN}K|T?Y2B%}d
zO&n&h?yt;Nek24$R>Pc+g`s&A<-W<zNDl}oOml&(ZYAf`uVRKvu(ekcGI*u^Hi+*T
zHYqdkFfoYijMu=C7D%F6Rxhbl25)^boOHGBeQiQz?y}a5>)%Ien;OnmSQVhQ35SXB
zF?>;z=PRNKHilyvNCz+6Cl3qL%O_|Kim@0=2B{NAk$+7e4El$UJRX@efkS-+2w*JS
zPbh67iJ3BPn;@Yf?HcU31#5h4fi&8A+>;B?Y=hsX%8O_h&U!OS*md(uF{i`)!ihc>
z@8(F-q(Qg=79gNaaNr);RELnkA#5ryjHV@sb@4BDN<`UbK~<}XW`8TCC?s|aY{T~X
z3WQLsL)Xn9RR+aBE46IS6G9#g4A<D!K@sZpBwt=p9RzHD<_X17fm^gQiSnwgq<x1N
z=w@pSSq8r}d=V(JaM4<}y;Z39*l)6DNr}eK{LS*l)K7bXhXPjPM$nR1E1SE+&Ld{v
zNoQF1e5PSv8*baqTq!C-`Te`_!28H6RxmN-VmN{Wt*PM`H=RZ>ZonDiH?ncK`CBv<
z2kDYYdK_!$I8*<S@dvcW5SHEM*j3AcL_l?r1jBy3I<n5U6g$XgX&SP?h!>6|n6g3`
z)44KH&c-BJ@`ftm_C!U7HJ61muoi=<Y4{ZRJT35>`=+Y{(^I^pDkVq&c_hprvGP=!
zY7>g3)MCS|mgp(CVx-hm`HLLU@Nbrpq#uOS7lVf4nqn+Fc+ppI!vpJ*(>YgbI5-Yp
zP{xgMptKy(*&hU<7N0Wg{y?QWAA=*#z1GjHd5G)XPYt=!`{Mnwb>7UmHvj_reOSa0
zOaZpXz`)t5)S^nFCeUENQ8>MC&Y($fI6>pq%ta9z{$VmLZ1NxJ_Hcp~6j`?&2MLI)
zAc7VRg;v!pJ*z6^Crs8r29fudp#^VGd-o#OiRZ8?Pe&_fKvhX)X7PluIk*1EHkBe;
zoUtRHs4NC@DUWJ_vbNn%jPa(k8|ix_{7e~^fO2FQ_ZT`tha|v*I<tG(KCX;f)IjKp
zL!npTpa5QFg}Q#LtG$IG$9uGkb$04tH^HXzN^3LFhJB#CfwwWqobn$XRLQVut2G0*
zaxpa@TP7@XfQ&(=-kZ3f!_<VPS>EqVKYUEHWIM`ulahjDEL0fxg&+wt(yWF*a{OOP
z5$it+NK~JC4pLmmSIai1tFgx4&9mJB9v}T93UbwPGptQ~vkB8;n*g6~PPw>Ap8%jD
ziDB{@OO8_d>-BK$qMMyKta55Py$VB1(M&Y7u%sXbD-`j2>7+u(Ju9ABH#q#;^lT>D
zoSqP6OnDiJ9Gzj(tvl`az|W^(?Mm-cE2-a7-j3UA&8=t4xWsnN2my{J)u+abu>g-Q
zXPox@sQfo(dCx=pf&AK@$-4%&i0m=dtpybF!Tyl&8yL3npytuUGe&VIElmIg%+p3Z
zl3iHa1;ay{Z2vYEwK|Dt-{l~S5yapaaoy+orj#i`^>M{+9YNF((A2aM?UZsMr!&R=
z5f8rzM$3l+aeVb+Kp0kd$5gG)!?ogK{)A*k4m5;S4zV-Wf9Uc~d-BKzWKbh8*i&NY
z#QYh|CfKv0`weAzQsj%a>Mf1hRWNa=fz)Nq6OHS-ey6)B<74B=XKwFnhlgTtTC)|I
zyUSjCIOUzh+Ic#gD>64ID5MlP(Y8*`p^nRUy);ySa**TwEdGytK9ka}W;&U`<DNY7
zVS6VL=AV#$?Nb5*<!TxVZ|Jx`)n$Fxr2v($DOS1!qm`S~=O|vAJ=59mOZQM<+g6+7
zQEU5w=;K+A$qOsHDN}S^6a)lB$eU?w*xgSRXb6ciHf+WY1$5tSkg8zs^kacQ^EGp7
ztcpfUeY*MIU(q*hW8=&_@t;XiIoMC1OsErgaIoQ;VR*(t;Ai$L63bG+JQh=uq}E{o
zZbKwM-pbAGRcqayzVh$d?HOr<ZN|R_o2wQTyD9z2VuBbcrsa3j$y?rU_-C8GGp4cB
zn|pP&#EZn(!G)9KSL#*Yk(<p+Ldh5rQ|Jhjm(n<eCh{bFWZ?E%DubEAHpJv=gHz@I
zhOK$ESHeeQ(Z8*mH*{QQF6gf`|3>iddu?PPKsh|lRdcE<RVxSk@|JB*2{*Y}riT7a
z7}5mU;>#*4ii}tLG{3}&Yq^@0vr_l)ThZH5r>LQg6?psG`f7aRODc3Ok~!DJ=?=xe
zN&--gs7|U0#aP42h?uc_Pxcf>udZ)Ux3a3<bw6f1Z(PvpL|Vbj7HO{Lv!8gjBcq(K
zv0daCy}M}uBUl_+#*)*I0z7JCXb{e8Uxbaff}y~{Avm)9%mmTM2APk@HA}_Fw_KjW
za_ZmsAj&NEg%NZxE6l@MIDSpH3JbwuqS`c(D4Lm$t)T;v(>=jHhH|6%LydSZ^+2n(
zyXBzk{i>)all8~(Q{03{g{87(bGLGMGz7%778Sz+AY0~H4v;NzsOg(EMX-o^y_i_C
zTs(dO0_Jp3k|=I-lM?o|a&8miPAq`$>KC;%ji+%5#i1LW49x~KAhh&n8_*(gMC~0Z
z?nh_~4dDg%;&@hj`bZ%L*<xKaoA9@!buM!gx51_vrnliVw@UA#%7<@~Jui;TN#U34
z1_8wRLF)M#08Zj$r95kDLIagOhpb3#m3Y)cj(suRLpNsAE%HAjsLg+1+@DUzUdZX7
z+nK~3i}tZko#V#n4@nHa+qW?p?Za#9y+0}IgLv25OiWcFWx;YP<sL_~kEjS{N3)@K
zPGzxA8D!wjB|6ZIkzkWW?X#Fg^ywi>OY@3+xG1ctlEHVh5zlYa*Mm$#6L`8Gk^D->
z%T6f%`HQ$+@f`MiMV~N(xWt<cfeyZwHM+f5``NnID3f%eKC1Io4{Gto<>5?<%W3**
zgO>vyy!MSOPdc!EdYUVRAUSV=jR)@n>{nWehO4Z0N(SbcS(HDHsoXbg;YKRA^Jn=<
z#X7p4X}WdVq$4{aKtSMz&WJPCpjjjn4|r$-Q1SYZ_R%kS3c?380hIm}ScT3phGDIQ
zZ@2pczVzOHOi|rDLOQ9bqn*b(D{}O$nG+@dEEF0Q$EVvR3V(p6fUp3j@{yO|iyWjR
z1V@!wOw`}81=rn#G1{iZYG(1M$Yo5y+MauID&HQYX{^!98s*@&OiJ2b1-J4<c-b{V
z@FOGxQ|WhStgPm!DlrFLu+zZ|x-AfxmGY`T+3CaUUK4ANk1G6`NC&^GyUiuYs%{!`
zQT}|gx#mvI4<Gm#fJKk&f)(Mg3{;znB?I$=o5p_%+Q-t-5@xgIk;&Y-xG*+XjHUqc
zmrKc-np6@2Y~#BLJ6j*m9zW+0YH77<Wuf?$;Zy(JUa~BM#-`~DgBC%~riv3r3?1%|
z7}0x+INx^|TCru|853|(eAZgGIe|heQ@61Dd6MnS4pJZ;HC9!FZ&KqRu2U@`#b%aT
z8w}{y!#7yLlG|)40XEyLngV$e55)L_M{n9xhvpRAbrS*7hi-lLEO?9bVi$OhkOpV`
zNx66=K#Lf?N~voh4r`S<Y>Tjx>~4(qn5mV8#j9QCV{P7Nmwz=z_gQI6OE_!-*<xE!
zB$ADy?Wa0OP4m`A0j0rV_FfrY9Sl$8lM?3KY{7#hrB^|LWCk^9;btX+wNi@oDdT69
zV=x#EZ=vuJNGXx6;zFzu&4MGOL3D&yHh=s);cwzO2?c$Trj*ju{cPZWSU+B4OEz^p
zuP$VHoZXTO6jA^5{1B86eJ{ZQDN}872^R}){*uV!zA75QI6**)I_92@xZZ)BuRTS=
zSeAVwB(Z>?QKdL)LP|#2G4<C(?ZNSU)Z>`J`5b=EGimt)4||rA;_T|mT!DQtio5Gd
zp6io&I(F%r)FI>eT@F96k}v~;7F&to+idB`^Bt>g8f8X0%V(4|P>))bRek#W9YW!a
zCDeVTpL&h8VzuBIiyuB;&Wx9ED^kG|x#J2obvILj8nP_>6RDNEk-#|%68Qr+ptV)#
zovZH%x?gEZl4Vsizv-r}?vZG#t>(a1=N8wqKX0^ov~k<YHxQww=-=E|hW_E=fq~zL
zj$TgnM|v~3f<HIcw_YCU7k!QYt9HNl$5&g;c-h(|UKWl?&H;N->aempA1y3!T&OLB
zLiT&((DX}huo4S(?k~Ae=GdOSo83&(3bk)qQkGS%_C=_b?nn<J8OqeuKOKPpHj<!a
z3#B-X{=9KshM6=n(uh^GM>UD-Uj)lEc0zDCBib_-(*?yUrB&d$7kn*p6U{{}rT&*7
z)Dhk_KHg3f>-}*HDi>JYAA!BG+Qi!Dz?qm_?xtCMC7sens=p;Z++Nro%UFR9n8-HB
zt@vV(reo+mK_>;R17&%>CO5l0`CD-jLE(#FoI&w`vR_dFg*+ynBx}K6jfZ4};7UGM
zH={d9Q#v%`Q4s<{p;+F+z|kF1k9{v;xMl_d@rqCmW8(zWK;xvj*N!SEFk=!yt5^FJ
zqi2Tmf+{Rz*cb|YQKWm*$pT`0(6X0xnbAc+c60fJjTI*chqp?ntzBYXpV_q|f(nmS
zr?!#x3IEmgkeaTiaE09a<gLoR8jaAwxGDDYcl>S9nn|EkvOz8CeqOa2qY1J#Sltiw
z__@K8uE++N@Fb0KZ{2l!8r*1;k;SreT{=0VHT_kNL=wW~ey6(+&$eogwxu2tAYE)U
zd%%bnb#Or%WeamRiz?O}82EF3L$L_3vjrVgms_*X6C)*$FA<7wSMEz55i?zumjI%^
zM@w<pXKxg<k_wgsu((7ZL2H5&oGKZovxn&HqbKGQn3(1o!oi9un~yJ3G2V{QJW$Mw
z|7j0XGr5ysq<h^08ONPgv?5Z65a<IUB%n#p$8Ol)Xe@is!{(O<(ORIG-(Kp_CsgKG
zbY|@{8Eq9v-9l(e(ouZYOg6|VZBxwfW`G{7y_l9Hw{1n*Zr!Xo74tRjmgUI+TaPh`
zt?#nlmt{0_Ej`}wZH#xl<Fvu1?svb<%BM}Q%$@~Zhf^#x9<6yo-+@a^W+w@p(_c7f
z!F<rY=F&6W418S$^&PpN|5a@V#ww+ty?i!NE=U(uq%YH2rGWcxP;Fw;gyldePBk(x
z{1SgN4ywUQqDeMOs*knZ7Y&o}fq9-Rg-;#-Voo;1+8aQ&;zM|)eRl+XH7Wi%T;+3t
zYAN4XdZU81(^J&22=U$fNu7v)s-rctoFFw?jN38Fz2m}k7ItWj!NNY50?Pck=+_wV
zQwG~Ftx#$MO*ZTcQ=(upT@mv{N_~S$tLSz<b69L=KRQ(R2c&TunW@8NmI4TvFAm-p
zLyHua-R8EG)!|!NMO;P52JWLRf^K|)uCn9vHOTk?|7<3nKk1in3E&Aziw70kun=rm
zj+o0+^s8VbMWgd$boOQK+}2sKYqhZ|O$>TSv@blHK7G3pT|l6-EH*bu4Yf_B7-RU_
z+<Z8V(39XIJ(%NH-e04JVTiW)7@wCEyq}DBx<w(};4m!vs7)l7e(CQ1kzlrzkONHW
zg-iYH`ReF`RA22g)CdBH8g)F!DWSB;AMz!Kj^H*R7y)E(#u8+}wCD8t-%xOXT1?oe
zI69vEfwu<tXUfVP(>KfJfRL3O4Xm9+fg6iHL%t09@Vm(=*#!@DWO4Z>xk`iH*x~aV
zOH3$DFi?z1fu))bgIN<Tw4hLkW&T<wjaE53412E}k6s)e^<pQS@@}3VCmcmb1OE`G
z$Rmk6;_Z*k@ba@vs;>pZUK2rer4Hxkz}+jrQ+0=~*00hA1?ybf-B7d!lCgPGJ8l2d
z#hRH9y?5W~!|F>o=L1I#xcFnKW@X_W6brP%>ZTHBnho&Hx8XdB^9?vAE)I;HRBySC
zHI^_#qV@*I67~sjY753*R`>VF1okmX7!xYi;q&MAkt{Xvw3rSHu<sdb51tTx5-o_e
zm2&pul>;80*y6XYJUfnI%{+>Y9z%Aw`nB<{4a-zM8$&fvi7}^Gr4y9k)mSa&8T|(a
zR|qvsO(Por)v^ic=$noS56<yS&Y<0=LjNm)QcIJMY~V(#CSYIY^toVL?#H&Z_8fK^
zv%eOVZ1@@(hPpFvkdPekl@N2<d0MsaTb~gDI5am;zKO3i#W#2mI&K^-MQRR07euH|
zy*mAvC0ru?`OLmP)HlRZkjK`sg*BxdN=sBbRT(ql-%XI!F}G|}ZQ4#0@7Tmd3RD{(
zIE*DPNgb^GL-{ef0n$>$SHA9I#*+`zzEuw2yIY{M4dc=;DH%9NK8}{bvj8GX0?rw!
z0;1jO{VugodD*r&w9kTOD5h1b7$t<a$A9yGO6Rq}bFL6{cU?vbjM%h;A`+91W{Uf)
zSx?E2M2M*+pZOuHE6lN7)j9AdjHQJ;fHr6d4btEV_tQtpw#VN6%QQ}n#?hG5HO>s#
z{vgS9ehap#607k>!^5n-@9GHKjE5`Msi8;R6E!p6$aW-Pvml$(<zs%TV$y@~B6;k|
z+%x8p`S#W$d19v8!Ku5&T1T?OAna?W5y^?jE38@>Tra}0=;jATi80`JM+ugp8OdSL
zkc~Il+L$5?{^wqL!EB0xoRAH9=aZW@Q!>sA=B|iaClyihNs?+pA!=43ugf6S>M>!x
z^t3PkYVGVDI1q`#(KHb9eSc-~@Gqdo3+7J98KL}5t7v9kq-?2qbZ6BgOcCQgH!}Jp
zorMC>IV>MFgd1>WF?8({K}RO0VA8WqVU@GbOTxbj#kHY_6H^HuIke~%FGz{WA#`Xa
zc!e7UeY?f-T*b`JD)w@}dc>nzII=V`X`Y@ZsXjIVX!JO3_TX4c#bhnjnpm4QxIUk*
z)Hb7$=`aU3{jT0jM+kUTPlE;SI#?zbR92s9?9ja%UTB+MsG|$@j0{q9`*eY7qJU!k
zkTZ?ZW@`nZvdW#LU(7#^pz~P5vzqvn^?40*ihuRMcL3tnGgQ0!6Sx&G`@XRd4N8=z
z0h%;BhLT`O{4tn*>`n4Y_Y3LnhFAKl5eL=$n@vwr>y`R0hwWzxf9Qri{Bu*G>0?|%
zS&7kYcb!p)*v5T)d}LSAj*_9J=`gCZaG4WvFU*+ppG~&YkJ|HK0KY~fdUU5@7bZ~X
z{FYbo9eY8`Oz@11F%kVT5v2(-gZZd{JexSZGW{y{X+P?Oo|cKSuY|RYMc7Gfj#L1L
z6)MI<%&QoT<Z|JIaS)uikuTd0sQ5PBWg50?OB?}`twY9waY}xmudG#7NmjsYT&?jh
zF1N!^A4GJ{ScRN);;h}m+r5R2Q?<a90s?0SrFdHUlR4wGsd1yoqHXlBpsLlJcQCHp
zwCL|uckLdV12T?NGe6>`+(UTm8V<~NUgE%5R>D{5!bNm@wQ&DmIryN<!icv#w*(&d
z&J?_-T<7w@ak`X$(1Qy!FkyFNHw91)ABZtc9^JoBmfl>LB52C7&V&xy@)iLdA6m$+
z$-vUq)_UE$wg73$Qg0uojr-6C*SUT}X{x+>()ij*8l4EHoPf+g;6==t&g2@uc=FFT
zm8D40$P=O#x1}`0`&&R59JPX(UT%dJV|lu1n42!L0aG1WyM7_P#5<ZsS3#0hJnG|J
z(CuNRv{Ab@OVSYC!h+R^+_BB=WjkV+q!G)vpA`$hk2gd&=QJj=1zemQ%9?CexZuFE
zA?0(33IS8^l2I;mU@P$hwb%eO!e2aI*|QDQY&HeM3|R7u9A+J9v}X2svG^QDl$94)
zm+-#KGX@6!<dokMOFYAeZ3~8j5*%tr9qKM|K-4v|$__bFe>mYHu8fIO=5>?l5BGK>
ziI^ag6fCzGzez=XNqQeW(@_*OGy;ycTc58GKi-LLf^chPb9>)!Q|fr`?xM2djms<S
zxtynwXAcrym4XaVqY3@H0W>^=^3I>t(O>m#GVHNAL*rSx8cDVorH%KUDpf)}AsCDC
z!)QzCIeJN$_gqi&4Sk|lf%?p&Q}zQ}+>29>J^f>nKow)?Pf`^91*GbuTy;HTx<#iB
zxH*PP`Vp;9@v{_REVp8DSYml!3Fop)Ev-ETQznX`8j@3(-sBuTDcWf#aCNqyIz#W#
z|6pz4XvZfNIxXt@oNhfBpS8Q3F-Do720_AH(&y!9vhwhceP$*kamddbVjzkxubC9o
zi9Q%31yC)voS(8l)N)LvS_!x-lST^z4~V|bCG@gK*s5|=QrMVG-S($Vw4e6kq^u};
zU<=U*rHuLh88^FGxy{;q$x-NKr>nw2fg3|T0U!sFeWl6Y@9zT$XDG0I1y@zM?QJ(B
znDFtbK|?s^@W%H^_He%{Nd220m>b!x@;dFe=Bc+@82tcfwv~zUe-B$kU1q7$=o&mP
z`D7q2T7V^bC1;`EJz^!tu`;=p!}y0fxwSD-GtPB`5{(8UPrf?a01x&!=%~cPtMR6h
z<1kGg47@DUZ9lB08nhG}&+vZ|*GSEd_XbU+oNeF#Ky<X#5~oiwyaGlTso#yq1AcwB
zyJ6KRIRAeDM?tv0o5>J;d}Y19ytKZyUh}zQ%$`BPV5_AG!Jzz&ugMUGj9S9gmC6sF
zKdGupE}!1BXKr#bx43meQ52)cVh8tQJg#K3fL01cs~&^94UVO*Kacr7A(V6H^s&kk
z*gA_&=yWj%mo9diVQh=skyb$<HfyJKNjl(4xP0&kxvnR2d*fRix;6^qLq&2r%;yXF
zRw)Xd${0%$HMD$&%OYY3xj3LYR|&<874lw%L|%C@MsGEezsI>;GM!1R8WEyThcPC4
z@JB17&c<`TwHUoZF0f_1TwA)f_S|=0i>b<%E#ttp_TRb)VJtGc!?w9k)i|cMd>W^h
z=+<1N--U#_6e(Yy4SM>DP;K{bDcxEBEX*9Du*tTVHG*zO8iGf=#kTA?QQ^MqbkBO}
zwy-6Igf5kXx_cu<JHv%s8f3_@g=EpZ?S0D0xcIl@k&99}yF0W)u_a}!B-eS@PCq_`
zi^7(IajBHaWRnmc286Bl*(<lvo-0|5vDMU0pSld&`SVLt(}mr;X8~9#a`}XcnKZ4x
zadzwKCRg2U+G}Wl2ahT|p+VIKsr*N7PGhcJvw6Flpd-T;!g32NGfor<7qZBj<YUzq
zwh(gINVp2tnH*G>up=3a98UAj43~~<*#uv=EQmIQN+2C8m|sbt1l5lFkgW#9oEC(S
z7HwPzR<1}dcp@H4jAa3~R+cM3xO~cbyrM!od*vD`1{Yp&%c2yvUU~W4#6*7Q&Y9_%
z0${76$YKaM93WPJRsk)#0_He6ph!Kg4+_%X@FGea;gm06DOfi{JY86)uo@%VX?Uyn
z#v&#5_md4$EWL#&L1XzK-Z0Dh4Q~Y@i5rk}+0hN)Y^I}Nm-LpSM3MJ0<_VXW;S!CH
zkzBWIl29zT723Q{BwRkm%{n(}6vbvVLXi*`Dk5Hk%0hKbPbAdI$y}k3US3{bS*dtQ
z4O|run(j$2;7_eCaKzg8TDb-rAXlN785_&qa?6%tDO)V2DQv;PB$BawKCY^Y6Ro;k
z@*AwDLU_=kqj03Z1Ar&A(M3Y48rKVj3|%a5G+O1=YRs_H1%{6mY*PU%v1Mnpxy3{V
zQjAU@&S)4RU2;%hvMeD7#mOLe<kF-BkVBqo<AvMmo}K$=RyK0Ubf65Eh;ba*<W?IP
z;X)oge%u?5IgrcFbFr5o7ZX(L=!|8=qzZvpE|*$fS}&KYZ5tyJUenTB-qJ2z>vclY
zu>vr<yngD`+i;uRamS9i`7shI#+5>zD%!mub3o2k17ldjqgNOhJfS`a%1B6<OqzjV
zDn)#n6a@ovt*zB)6ZTrI8IK#{V@<csvk;M-3unc}iEOs9AdyEmDy?EAJ}yg#B62AV
zRj@2i<z2dL@fSNT4M}NoN$$i)f36uW<hG<}$BCRR1QP43%@quXk08rTxf?fIGmlvb
z+Jp;nsOjd(MUN?+Nu<;9N+omc+8TU<KDP_(86rL}Q5XEF6;^8r3t|DbzVVIYxom3B
z-q{<rkCkqojm2VAGA6OYQBjSK3PN><9m8o0p-Nv<w9iT`rleAF1H$4>Bgp~C1t>;u
zEcgkxyK1#c_epQDAW<msVG*3u)z3@cAd0+9Q)98L+B96}svYI^L@X#&dDl}ZF>fc%
ztcK4#Z1F**)W2Hj*<pK9N+GJF`Gsf#;YzreMLqkY;Y)#eNj-}zve_iS*6M22r&|v|
zRikP1Qz^32LciNA*jit&o;ZH;N3Whbetc|UVSM`yQ?s)rde<@J8oX!A=76MLz@qmL
zyszqfu2sG7fIEraOu)S0CAAu<#jREw@a-K>#F|Zwf>$htdCMf*UR#7MNh^<}R?ngv
zjMIPFrWqdTEh{U7q!d1%Y+~F;T2iDzF1FL^el1{;xTJ_AWtlGM+Fjq5uRZiCJVb8I
zGVI&JT0G^hwD~WZ*Dn?``Fsjs>)N$-r#qmLwZ#0*${<4PUy(CLF%_%is}P+#cMZ1Z
zzWe(29n&*2g`00)fKU-geb?&Kj*q1`BbU$-wHJ&YFnbyRLLq;9nSh@VrCk7CFc~QA
zs@IzaikaW}&6Z{@1X_tL4z`#T1Qw0ASXQ1-X`{|%5G*AoJrg0Wuc9-<g>36*J5EIQ
zq5<!$z*=~j%?ITrMX@iLgvi$W3LzxIwkFHb;WbE=HJ=RQ|D_pU4@CWtA^!2p%M}J&
zR2$(MA_0zReY+9ii!C1KOP<K~<{Ot_d-26H^K-=m2X7o7&&K2AwrsZZGVF0^+6X(+
zbO#nAfm8nPqIS1CI&UHLfQ@GBX{dPZ+FD$V!2<v?WUVrC_BFOvp6mDQ$jT#|r?iDF
zgj~W&NtVU8&ya|Z9Vc35%~GL{o!)XoE_q2&iYpzi&AhXiPlgM*Cfa=rxnw^H8wXpO
z4jdU!AeSfkc-R{7t<ut6vsVU?8Op3a%;cDYlL-`4T=MF0pq2I7>#twBaA9R^JbT-1
zTc;-TQ_}_dS3oW)NOa!KT~r{B3R-O-HVp$pg#%d5$dUe>n=4WL0>D~duNm&(dcEFa
z#Dq;a<hs1*s7%zXJ}np{Sq6dSszW*Xjpb+B#gbAlGGzIAVL>r(BbUvAkdT|V>>`{x
zRb7|8PZ96YBNZwl!5l(&gCX8!&>1Sq5_wiMZUunwMKU>=2iRJ=R=IR(&Gn83bTff0
zY(Wq~t0XWizXTVIwY4g2XU|+I<kO4WCT`e1H8)=>m9i|u<#k)*(YNpG1s6sRp1KQT
zVN?5YC^Yj0kqEuX0J*Bw2EZ1wq=OcI=~AAa&P1M%NbNAlZ?GfJ?HVVtz7<GVCA7f;
zyOls97wM^B&5WF_#@y7WZW%5ijnz&Jfp{G}vdJd(Q<kj(xdvqnxrBNH3lq|*xH7KB
zVhK`2y<XF}zRfy~bETrfkZ>TTnrNkQE*Rdad9<=xIdS~#ODE3da><)++A=#=+`fG(
zkx-E(<3gKa^r-I-yAQTLwCK#9uJ-SkXm?UYi5b~nf?Tkb%T?fCwOW&j10;85Br3d|
zCVy?!q<rSv1~~7CQsd^lWJ5~gL<LKY6y;hU<kw5lYIAMJlX9zS?2=hyPxI`nC`syl
zS}StmFZcyDWlyIQsZ<=kMXoKat(9v?XK8rnoe~0UsVYfbAv?#|HZ^bG)~l=4=bn2V
z&S+{Xzhme0d)~8?Izt$i&8>|Bn&99PN(#RpNHSp14{KRK9n9eZDgkl<?J{%{8m)aR
zuT~q)7T^~aKQvhb!HYi~PNzY#@_x^>;zZhTLCSEEnj0z7M4~4IA1ZP}LSDmVr?-$>
zBUt2CVvU^gF`<HoD~;xI^GN7rjaaJ-`wIl=M0=&t!^vg|Y{6H^%1UKzt?su*-vewx
zFqlX%9ZQF}z}@bbF0H_J?(Eg6>B7E!i}`$tQh29~YXe!*@a$@1;VE2@LcwJX{TQmM
zs47X-!wuJHG}qVb0B1050LU~$t%xm>Ks6BjVj^-logyh!<eHUtEvpvgsYb~*<|~IR
zD(99ULt?EDpP#n^T8?npABIawBUef-g{VjrL+~}{&Lu*Z3>TJvZ)B;g$dRa0$<IO|
zoy{f7tMw~a)+-*CHC@9N90N&RDK?W;P`AisT(UD~uEKWg=$YBM(!!RpJ$vSgr3`Q`
z_@j}VAJCNRu~mfIZt<wYQ+My)_PNsD)D1i_qx@B+iHU4BNeY9?RhSjEdZS?^yx1b6
ztbyPg`S2E|j#l-2ehP`}iS8}Gr1TbtG!o_E6Z4u~ed$)~<3uRW-;1uzNbV<O>tm5%
z{^W&F((mhaohGfMxd!w%lS#$n@%8oE%1Sjv*ovzd_l#Ejtxew+Zk02qufTTf*x9l1
z?5+D3C#Uk$(?xn-bj><=2-d~)?i8(pbP^feW;y*>#|&B45c-J46eh2yi;NI3wt#ZA
zbYNk2O(VC$DD@wc9AKOoZmxNS{Ny0i%v(ss*~~j?eFTIOgd8q~it>`8<$cOb1O@w6
z#Cb7Gxp}7s)u{4mG;~c9<N@^MEmEeV!}T}VR%&H=y}Vj$(}`Md&kRWF$_NG->S{e=
zmh_&O5Odf7xk|<K<W%97eG8M5`H6{~k*#a_m_YQSE~gjB2ps`84MGhmU<qH#)*>S!
zozt5zb0BO46f^Ryn&pp*oR$f^jzOr%K}eFzOSt2e-ja2v$VEtHS8F>H^9Z@vLLheh
z4l6Dmwvda4OF%B9OBpUf4<R<cF!Eov7>@r+H!QJin;^q!E1S!u*Vn5n%hfip<xRL^
zF_+Yp685}d$GyB#f$hyVFXeK{JKwu|_wHHv@=GLQv=YO0G6csg>DBgU7b*m}`~T=8
zSu!0iNDVt+@uWSORAI~K({SfCo2|8Sty*hP&aX46vgDH9mT)0=9fMTm!=$8ECovH|
zH1780Dja#UX5_FBq@gCOQnU#W!p<iPhJ|8=OEPXozIq7ys#Z(4!fTtR&~6pF<qpW_
z8H=SX#EGlr%352tg=F0puMy?*;aVRsi`^@VLKY<;r2T*Y%dzi$_w^k+r?+ew-?n`c
zkPA-RxPLT^-J`;e(%$`GXa2I-k;AFrN%YMFSi(26waA!GCjhMgxr|%0LV`y_Az|Kt
z7)yG0$(qKTnU2<8k|!!M79u5EKDJLJ_9C<4%;_CSL5S~}C9*BAreu=H-nE4_qkD3a
z%W2$fh*GH{lxet_&5WkW+Bb8@L?W+@kLL>c^vWtR2!u-=Fi7N8SA&^VMy3qYMF}{g
zrRDYKpFauP+}zmQeCftLbK?_Px~d3&1>_nIFyJ5Rn;W6R0^-pCEN8$-^YpbEtz;zM
ztAJv3ok%fYi)Md>&WQ%9Fztd=@hd4*g(hGefkIrNkF&B`;yWx(boUNKLSGyo%Vx^;
zq!!kEL@W?4zJT01m}b*doJ!0>V~w@3=x)Y@61uLE%AQ;<mnxU5?O_X(M0;E%2d8bs
zOf#f^j69<A=dZ!`;tx+QEKW?%6mPzHOQDbk&SfB%ruAEbI`sP19?yRO2sQG6#Sa=V
z!ULF2^?H+NAQ39B)tU{Gx=^g{WPCs;n6+~>ggsMGlUjUDb7ZW1U`x^>2qlWTt&De1
zz&jH2d^Zi<ve2=y$s4x#vy;%7o*bzf)J);7aO9FVp|NM9&sZ*(O|7n00J*$i3y75(
zCkL##7569uge`3Qck3-pKXvLdY%iTSGdWe<wQFW!%h<$Z9w?-d8{KGx!Xt)LsB<|&
z1X$8MQ6O4`4IURu8K7MdFxKlWT7!-3kP&(L$|JE;3-20e6E5AYy_gr<LdYvllxuw?
z4?+vJTtxF8#ns47!^IAOIE%J)QM<||t<1V`Zl59=QY_UCGL}fH6Uls`kXc?{UtL+3
zVk<>Ki8!_k1|9i$Z6KJ1#MT=;a;>e^*Vf)Xb@J_EF#|#39q-<;{e~$D=>)knJ+R~)
z_l#^p?bndQ(*`1xwDU~@Sk9OcI2R2V0l5g_()C8Yg%t(_qJJr8(2S7a1!#MUatc+}
zctToF6#6H+#)*sy@gbfSf7%4fJHzFyQbexhKGp${lug4pX@!$AVQkbnb8|+)PSPjm
z`>hL<NX90o^7%Xo5?7Wj*fLUASkalQkTbV6NX$YG8+#tP0B~WuaDI8$uIc&t@on2C
z^MzC_q0scG?(4SNK}&5k0{ZeHM=0TV^vwuZQosnv1t(AK>eqpF)tY9vcZ}`sH9X-G
zEsq(I(GljcOo;oCdnKcb_|werdnD%DWw<oW7Dq_75L{>}aIRKEtJlf<DYnl(qQM~I
zg!tA;%f}$`IC{R6iKNnT*s|Hw^2+*pxe9+t#O;*|_izdK1+B0W=<es$eDq<ZQa^U=
z?D6Agvzg?Ld*^3ni#v8qClWC=p*9+ZjH}b)5;S7!&0)hSKeXDc3`@?N5LSh$DwVD<
zE-kIYlryXc#T7<JOKOHtELh{ETS#nN=&Cz4jsSZZGw`s8<jQK73>Ql$^S^g4DY668
zHR8_BYyq(q=;>SoGFE+Pza!?OM<htYkd57}88yI`Hkqqd*UROK{{kHDPa`WhO{{c%
zZ;-En@>=Z&KX?-!&(0PX7ACfBpPZjB87{jz)k8?rX~WHILPU*VN{&H;)CLzn4^^~C
zQ(Y`zga?gAlg(4cR_q|lbgJ@fK}I=?mvxNfSTB_~Glwi*z~x+0w3ZGW87?>EVxc98
zZ>U(!+?T}`ZJ!KwbFda>h(|8uzOrd2@-?HvF`r9LOe89m%<^&tz7M=xjoF3XgU>a4
z^_1mYWc3RdmSOw;_utsQeR6ubxc8>{LLm*HOa-X)yat9=eS(Q$;81Ou)Fw~5_YyDy
z=K|P*->k3KtJMY#7!{K-VVZ$=T}<TNAQWLj3bi{fx>IXK&(&bwg>X4a6cLh_6lL|P
zfhA^4!xabEi;R5zBetzmSyEm|K?$5oXuY8jjVM-C-LQWk4hqF$8eog6<k|&L8_+h?
zrxiA@hd6oiGHgeWo}Qa8EiO##*g0J+W`Lwqm!uG<v~(mJ1yaKgRrDp-FJQ5I)M!MS
zM}{*T#EHwx>%h6Hl?Jk8N(#pAiF4#ua)>-CrI|vN>(V8x$~k2dT#jGLaJ3~|Ccc?s
zQA!^Sw;T(__@K|UPQ`q^4!fnW&eJR7FnG$DOem?Ok(x5>l}*^nCdbCISFe^=SF8T8
zwXtl=6}kA_JbZz@`NrF@z4*eZiOKv;H*cAm%uml0D5z0l-ZOmY8wF2jqfPrdJx)CW
zEPgO;M6;<?Ds{MPA-VzZsvGWI=CUBmd1+jUGV*SUAu1ar6B}fih+3S5>t?9=5iY(t
zkdtuH9g_7yE`dd?y$mg>E@~Rg{p*~}!U~D`!bF~bF<n?J22nOvV%XA`=@wFwP9^j6
zV-R#-ySBEpOcrYWgDHI@U<>)$Bw((M8m(1)<Bdz><Jqa{!Ywy%0sI0`ZZ)-*AwYHR
zV_;A)obcrJc0F>v2(a8PimK%EDMZBdBw$=!CEfi9gduEZy8v|*mwH2IJm}>H!DcVt
z7sIYV6djYfk5QJAx)LtRm1wmy33ISrC#)MiChQPZ=RuLJ6tFqW!-!0{umWMVl1M1J
z>1m_0V_-L2DwUX>i^IeQ-g@oYIx%a+eF+k~&by;v)-I+mu8yu=T>}Vy{k4mQLi*14
z?%KI?8W?&q8K)H&eFcQBcfR57eIY_>1X%w01!T0G$(2evRp=})tygOe059FhV*t58
zZe`MT=Ez!PWLbHMJqc!nqEj<Z(0E;|948_{#Y!Oq(5hvK4<H^i^^iacsWg)7FKc)D
zKq7K+u*E_}-Ih?0$ADJxIJUL8$fe^fV_UQ}98o{5R4HQ(H%P=vIJ3({UN`*0wm-Gm
zAnLEbcC<8>1<ab?GPZT=B-|=M((Co6rs*39QX5q}-AlxWM%rFxXj5H;GRzj?X028m
zly=ps4NbS?o!DW~#nerlwY(r};3QPek|4>F!KF2ZZmF~sIWcdj9}NJ}5ZC7eF=ofF
z*D1(~Qgs=&5E2L%o5^Yn*pmW3NoveW#UswJj8|jO2@GrtU~6m)g2eTe6%uQ=P04Ry
zZmZ4xfX$`ht5?ggq3@x^#fjOu((c`}V`CXY%o{Dk%}ooUG94}IG<cAT0ISzj7j4K0
zx8v$+6@CKY0`Q`G`WP!P7PIUY4!ESZkmv;{naMa|3nAI^)Y)MSaD<U5dTRg+1n^R@
z-NM#3yk|YZ?3zV6!^MLKu(otYQB|7Mlbs<jXCi14F1A|@cv*aQwm317h1iO&Zv=s@
z0V9`BO5O=u^m?8-a|N~^K7VrS)`{8K(v5rP;0~cC;Kr(=&-}zAfla-qrFuM(Xq7Mo
z<SLai$h1RfL9|$@Hp=BH4U8Cg*+CyynunaGF}&J~lSjxEf^JUDLWaxOtEM5rNSRwD
z;M=sa8;*6H7DN~#T2SO7sjCDqEW0ez?7-+S5flg)GS>$*gKQ=Y*fMfk6^N~BzCmK!
z^cGh7I6vD`B+MAB(ew3<H!i_;^yum7>B3IKlWS}|t0;=5X+gZ3hYg{I2dW~56>_R;
zaw-oOcHJ;UrvYQN($K6WInz1<xumy*I8pOdd-*j46GKH(#@n)-0<FDix-R&l3T}R~
zmpq^0;vvXDD<zdO>x6h3!gkNcpZtUuGF--Mld1T0Do%A<L14>^ZRuJcVM{JZ42E3P
zyBUxRKzVX9f6FZk<Kx+h$$YCxR3!wtbW`}R532`F?+6tZNJSxGACU_J0c3b}!F;B$
z1z{tgRjuBDSqk5@LPu*6wrEU<+)Qi`@*rG}3|C7d?pK=5y9Sy)2l?hh=38^fWjEh;
zSk^G8O~i33ZPF$xly^o?%nbsu4vD<$iz0XgB16GDJyR%+WdO65mn!YuO&#eitPF4h
z2S`fs$OR__+iR~~1i)HY7~ipDdU~dq%aJu`y5byShQ1%ky8&nYqgBEU8!(@X#SCnd
zlOzx@1IE<~VLAqKAtYBUBHp-44EiLwJQ5T0ypt+1)oJLG<*sg(lt_+O>@CICkfLP`
zT?R#1jiW?DQDX|3V^$ra6O!zzMZ_;|S}aVr@sS=s&3`2l>dZ`W9D>9ZU|a1Pj)_5H
zFPesKCRN~s8sGEj%9S!~FTM0up^)0UcOGC1@GBNm;&HODID|cK1_o7378B&j5n%Ow
zP=8bi7?EKQ0FlC4xdzP3G>xFMT(LS23hQ~g(+vV4#B(&+=vmiWO%8diQfJEz%Tcq<
ztz$Z13)vzsBV0`;F#wj=(-?AL5qfn8Y}v&@m~*K&q#<#m>Y!B2td^@w*VfAAn*V*g
zVM6&%-V}4R3|JMw)-%uiD4C2;OyqX&nVp*}&CZr+RS=cVTqk6Te|dm5Xc1s-#Gs0#
zsVTIwQfaj`qx!l^7m^6)k~+@wO(-0Miz?=M9~)A3(<1UK8h7%|9BDoa^NI#XS0URA
zj0<tu9^xuNtC&jc01=<f;nzTgb}}4fT7(OW(8k)qav3_Z17gZNmMs+00P9Ov%fPwX
zPGdXEhKCfkOx|rBAAIz0y>$&Xpq4k>Ff}(fcEgUTd_D!Y2PIsgAeRpiY?PKF;LD|F
zS$draur_GGY@`n+C$-hpN@cyivP!&JSn0K0tIQEAO^UO4`z=F_1$$r$RD+)pqdr{|
zx_hxDKfZ^n9V&{1i$*knrAeZ?QmA5{NfvZnOt~W=(=YfLvRD^8GF(zSSX2K%7GaBp
zbS|45U$0%ewnlCHgWTvF?)?%Rx!}VAczX5K^RPYlTw=$LX<%DBc21{Kaq5QT<$KW!
zC=5ANd7@Rsu!do%sxmf~g>Af=gMe{)xdQyCY{<Ka7XlXAMqr!x2yr5|)a{L?L9Z~<
z?d2!TwOHkd5oey|+6<B1EU>?10w>~%u`<ZRfeCpwY?(VYWgG}QV2hGIMX|mx1w8~G
zMVi)!M(?6rE|txt2&S))`X1i)dhl$^DRk&1EM<fX&J^h6@#DlzaPo!x>}+x8u9@lS
zLO!3iI{mbq>HZ)P&<n_fVf`KgNJTlUVI1^J6_5)audUT!eqLKzYt&m1FwzV?;?2L^
zoKX$e6ITC2=9N)SD17of+}Lc(?DJ(4E<VE*PvBHap~ZBTse_%KLcEDHhhj2pAse~u
zMKqRbwJLs0L=b_1KFDMeuoX+$@@nPk)wOE1;dWAeM=qa5!d|5L3b)33`SL1kfL!zQ
zV^h<Gn+#8`VliWwp!)TN?P~}*0FXk_D&dF@s-z#E$N_S#tyNc+jcAc1)QK%UHX|zz
zw#+<{ZmT&77HE7HT)Gv+G?X1D>Y~g-jT7M&L}x6=FPfBcMU*^;vcpEC^YuMgXBjla
zNm%WgAzha<Tp}E#Q}K*ZmbkiFC5<pvt3krR5aYzQQqmqPiui>^n&f)<rE^nLg{|8r
zwr!i7n8+oQaby%TQcuARho`Q0#a__?z(s&H)M*X{=kqDpCMNQ<fN^D|0uTnA%XZ7+
zEC6krb`uK}T5-c#FzBM60ME7<Y)L-xsZ<Q&L1t9QTh+7meVx~2U?DSQ+iaQ6%9z#<
zafLf9^Tp40)+B_cyliV5I+KZo*;Kw%BGuGOOY3FQ-fcix`G6fLdR)Hbm0S=4pF4LI
zwxchc9vjczbn_NfRVF9$6NZT!?N=}oIMoH8iWt^N4(jX-0V7P&N`=^>LQGVzHB3)>
zQyhRuFE7hZ!1h8#Qr1a^E!XrGoh|V=Ss8?Qw8ffV=yp1cGt6QvhBXeeRrt)=#ts#&
zavcU|^l0r=nDKv_Szg3pC<g~XAA$D)l$XY`z(4`H%H?X16t!E6#y*a)kc%V=)@!hx
zJ$n@%kBwz%v^YMVgU1@_fuwmE>W3@x>U3`blT*Ro6i0wHVuM+=)M^bH5G`F>gD>HA
zlI_y$R2L?_2#xhYQ{Y470;<v$wpef%i$VMqQ)8H-m1r~1ULqN0F-v=gJ&ry7><H9M
zl36X)_yC9NxPct*u6B}3H`WA<Rf`PpEMqZoJxC||!OI|e_k&ir@R<teUw`c)+zC5&
z5PzGwxe|P(!9}C}eugC6>uo14g3<`EMm1VwjbmZD0_{3~zT9e60L2WiQCpHq?;S<q
zZ1%9gwxpYhSw0a_yK3DoCSqBS?OO^n*uq>(M9Ht2ne9;UQg~4-wiheS9@M-)J+hY(
zO*q2>;bK7|ytYtC=klq_dM==SP3Y;ZfNZPBcf(v{3XGEa+r(c~i^cTbz4Ji3wrm-L
zZzdSM3+Q_!Q>f=!Lg&jPz}gG}BgU!e=~y<KX*5W3{_2%-wboc)Z?FzI5Iy;XfllO#
zlM3e;k8irwCDD!<9WBDdneWyh!vY}5nnK5dTMm=*V;%bwE^Ji=8P!4rd$QS7I+L87
zB(Sx*y1u?%576CUplmBdb-uz0=r3PhJ#ysLcw7alwRPLX;^M@_L=OJhQF?x($P|hU
z{I073K~S@)19DN9!F)aiXtlgtDX&(6XlO=WmLdhemWLd9cZys<tWrtEuqri05*l+@
zW?fzRfY7W8#125z8ST<JV=qIB#l?46Fs<hf2qTNBVO_*KR=sE?xfBZs=*lQ{-I|)p
zudI-^W2>u`ATzcta^X-RO%Jb8Bad9CPhW-&plavNX<~7+Ylf0>YK1B~7k7s&VW!DC
z)j&jmHS)u7<I;^j2zIqhJfV({=Zd9_)*@)Nyu4nmG%D4)2^<(Xk&87eq)zP`=ljeW
zXCU6k8L_52LU|CkH|Ccm<kxM@5!Rg@TM_eR#dbo?1WK``Bad80Yiq2Dt;&E`l8aEx
zl-H`OE7c*46ZP;iTs(3aUs26hUU>_)AO7&<!s5ij!uZz3iF76ri^U9FYuR~&A%-gF
zQzF3H4D^aLqu0fPX9GB5iV{;u%$Ug};2wqPy0o;`Y_{MfRCvh=%_-AC3F6eQSn33h
zg>l&^#*nOD(@bnd%7d5{Aj@;Hj?-K-F(FR04Fc^WvGuFA$jgmz@s!9a9XF5LSWML5
zfQp3-Y?Vq5*cM=SrBV+*Re0nI;^)^jY=zjRk(Z&au2x@u=^Sjpwx*^Edv2TqsG6B6
zW->`*DMt5SS`9HRg}N;yi~wtM0ai-~hQ-e#*EJ%ljmYJQT^FF$`g*;*TB%eU^vjkS
zbs1ez6;)N}*RRui-cBE3zOu*WS}aK9Z2Y*@Lq^kV`MaQrmtadUS#=;6=iRIe6^mAo
z%JOQOk@}*M(Zoc~5S^~U&rssT;Y@F_{V;^RbZG^)mtTGhPHF45Nr;zs@0o-9A)8Io
zqD8N+KO0i*?6s2!uts~3Dl^ioT4(*%siC|7pk+X%5=qh<z7cwbbiJ;}R4SOa*W*~R
zkK`qfc*>*m9i(-h>sc*!g!DW^E<2X=fGxy(Njs3s&SB}6SQhgUtF7fXGHhnRX!Om^
z!MU%kRY`hlrBV+jyd3a)V(4#WMvKPHaq{Hbu$?$@c6z1=p(4bLa6#bv3~nSUL+!|;
z$`xNadbt-+$~%eN8b&`J)FB=eAWRQhS7xNE;!{&`V?S`4YE@ud&Bj`}#!^bumY$`m
z?4D!xmpEpyg~aBgR)!vlJy{WtCc14!Y9bPAsDT98myKL}B*@-~pWZrOF>V5=9i|#=
zi}YtJmWYE5gogmx*RHNrs*Pat%CpmbpV$@(6}%Mg$bn^_eDiJCip9+Mc<!c~=Eugf
zz(8qkzEc6cM1_J|T>0$B-bv(#wK)cmqgIR0Ug?_F&G%v=sphh3GMNM9T3Ipls7q@=
zyQnn+RxqFHV)K=Wp)lrF^pG7q+R$Ty8<zUVFe_#b33vl&o$DTktaf5D;bK*ZCJhw2
zR5Oo2fp9Udk;#zWHl?v_c@+p3u?!3rCkAS(Gqj<i1YV?H<nsEPZxRRk*}2lrozs((
zc|dbwPh_Yf+U2=I2>Rsx=ur-9Gon?!F2#dpy1lbZ2PUHSL{foQ#?%;m&B8B@fUyO0
zczvw~)0iZ>S_G{~8lP)2rb}$gLNTGUtOZ-lSKf*qkudEYettp?qq&I4SvlxJmkpa$
zi8PSML9QB{BU}(8C*$c<!iW>8T)yHemv`$&uj2vwZ}q8Hqar!b|L8(4pW3}=7JffB
zSDKnGP`L~<_F-q;W6<Xk_c5)9%ehBwzD7SDWaT(kJlGArg7}Ek405sn%Bp~N&CC>G
zkJV~}bhUwav89zQgM^rhg$5O(buyN|D6PJ#W(23({>Tz+@%eIv;h435UCeOtj?Y-A
zh2-*X5)QJQ7Pbi&&C084tW?V8^Ql^`Nns0urnYIU0kf_C5iUlZ;bVr=f9|`lBcl`y
z0>-_2=O-s~GqXi{1>l>kcPlPAc+~y473(b&0oJGvLw*HZUFYM$F3<{40q9jM=8__1
zaU3fHqP=4c(}*hRdadb(-HjO%vWgidp2AK$2dmBpBhHgSyt%CuzRBLOB|x>S2)UwY
z8@ZScLwC4_>2i__vl47wXBjRETd<#WCTTcX=OH?#CN?xCYG-1zNsx=rb5$yJ*e+aH
z%48CA^J7~VC*WtXn2yI|)F77^qjnbb`G$T{_cMlR5nzorW-%SP(2c&65m&KMg%hYf
z9_<|q8{DT?udcP4tqL){sTz3>-4J1!Wz`fDTyy6_FKe+0kZ=l2z=Z_Z;%A0{T+9Lx
ziB*rhb%d1`!!{gZcJ*w+Wu&*_adl!cKQ@+GCuXOW<z-T;8H`!zgM=;ApH)RET7--6
z`fC^8c>Pj39pANUHkl;K<b{QCpy6;=_|z@B#E-slA7;(Zb;QT}5yKkoA$EKaLZ^=C
zRWhk~p_R`xP!wfqszC2Tn8px6K-k!75`TJHjU2<6w`~xS%LTTOqkWml#dx!M(F|Tp
zpIO(0`>XXbQDrK2_pzrF;yk=ex@sbCE}w>NYN}CQt1VqyTPxQZf!yT>3R`_zRg|Jd
zYUO<N=xO7tE|xE(ckL!t&hztQ5Kz;v0U9v!nJGEwb0b!|{hcO!Z%KD_1X!awT83V<
zmjsrPYgdxVnBEg^0zpg6&6xosgo>nwv0SZI>!iO9U178=QccHXgk92GoT-D(tvU*D
z!?*UqE^Cfl9*tp`^(D^-h1lX&n*HT3D#Uc&_*u6I*Z7!PEM_X}H8@A$T)`Ccx)kb;
zZm1|li-6i!ua=+tZW$QXmM!CRbEU<t6L3kVrt|O{Ghl4B6E`3|V9qN7tkE8ghSq4<
zNs}%TSV|1&RnTBC$bj3lP{_ar$hEYz20uyT>y=8=2pHk*L^gzx*yEa~RL<_xd|JvO
zWW`eGfi1R$m_8nhoC})-)0!wk0S<5UWvA&$Zl3&;G{wlKCMWZN%QT}Gq@B-ZN^(iy
z1s^Z1xPJcmlZt|O7)96HwoO9Vn9d}OINDa~NpWANnXd@2Mm2lYXb7GmT8DxLY*gXI
zV%R_S^N9+5R`db6CJh5$81-87>b3IPT5V;yf(-SOZs;~8e`hSliIkNI&0_f|61lbE
zP!y~5T4-iLkxMA+(ZoI%(pzAxOO82Ql8Y4I881&HNQSF4maQ7Sj#gIIr6t9oN^<oz
zW@LG;MuX@cXz601kX~Gz0NS->VGOR7qL9u2tms+~rih6Aur|qnSx*J-T#LZY7*<@x
z>2wVBK(7MMw?tB%oh`wG@@f?TXk~eQwOp;N*PB|4iXseEDspy;<y|6l(IvvPhj*r>
z6f3zaHN`-dQM@%@b&fqDt`8coGDQeU4T9t)#TMCfHcO<Zlar)GacOCNeJxOiYrwFj
z_aD6Yx<%MO5YH1Q&cX(tzN#vea{<1mQgOQE>f_Sob1O%HHL46t`e&!vE5ocE>!|w`
zCV$POQ?iuHr;yP>7H(53V5}`KRY>D&jW`_>xDk6_>wJ|W=Tk4L;VqvmWM+k#!pc&I
zF_y&Us$p<y_w~^w<g!CiEFl+nNY+JY8MBToDNf{ILRQvmw4+a@(!rAA;0f1YzzcSM
z;ldI;ID7W$i!YvD+&VEeRoJ<68vdHGT)L<V&ac2AS|uEPz|x(V6?~*pF#s&v1Ezng
z;;s>dg2%^m^uBJ?iA1wnY1EA}Y`Aw@h7T8Q#b`+xEZ0D$QMLR|`OFs!PjuvBN`pDl
zgfX+lK`eRCw6Ai}5Wl48kYDgiigd>1aw*sVyvpSo?Q&GBH3EL78wgvdKQ{u8T<{e|
zOBW$vgp;KK<HEvtJVBNhlS!5O<$6ICRjWjRHIk#*Bt0gCk2Nr2DKR3vA}MfvgU^Cy
zf@Wrlbh@sUYgDDFTk)fTZa}^iF1W)y+rqXN7oXh{jO5L<6k@eOTv`g-F(bDKz=^QA
zT5i))0&{PT1R{nFe#Z#c__$gskzOHX<GdgW4lafmJaXB6J^GXC;*qOdCdCreUl2mY
zSd0XW3yTvFR;N-4n&mVCMvea}iWt_Y4uGm!jm!%Lcf+vaD(fU20@3SbUWrCD7-B{m
zHa43Y%y8KG($YGS)YnMVKvk*8mWkRGJyxq8HrEj^9Hq&7qr-*mhokV<PJlBD^!Q>U
zD^#T2ueqXYE?35xsq%yiW*`JU<KtPw7NWYkS^?zJItdlgz|A3?zw8Hc(fwb#v;q&#
zpI<t5^bEzU9Xn^>@7Zk93>bBx!&3xUBMDec&_GA<4!|+hP>L!Y&?}!Xp-m6ub_P;j
ze^pflLMnIwKO2qKl`CbM@LFA|k`7iaje!^9;D!B4*O4xoI1A6UBn}GZP)WA;l0{xv
zXiv?#He=f~P|AE^yGqf3V=9K2$^&2lYyo&xs~xN=Zg{8|I&w+03oaDZMgZ-CYX+g>
z%xn?D#)KI##%bww1X!atFcxl|;0_HirBg}b%HV=lU1cx)CsNxf))vu#3Ie>&&yN`}
zt-%bxe7Ouifr6D+E0*#TQM**#&OUK)!<oTLL895d(OUS^ML0taOB_}Pg#~9+!B)_z
zkYLP@hKg!TDV8$DVj8Aj*^qibe8gN3hKF!%AaYT4$d7+~0k-k+91R#37sn?i^H_-h
zYcv@ak1)Xn?h5gD$DTkFcE+`9h9%8XtFfyB3<Wl1=zW%rZqIAws&R|guo1A?4R}P8
zKb`Z#G2=ew8(|4d`RETj2$xCZkm#H*5-z*ITXM+3f?J_xEb1o`>UcsOD`f$HX_5;j
z>d*>M{X@t;1&lDRUM<7Vx8GhlapLTjE#ud&#v{NQz0qiBEaMKhZouv*M9L61l%l%F
zjgE)$WL*z69#<zP^AIos?Se@TF(VP3uT<e1xKVE*Y^SKCoD@4vn>{huLPA?<hFpAl
zi=iPyCB$T_vKy)_*0-{6W;TsQ@x%!ulN_JORVt(^V0E>+wpI&liMR0!i>PldT}W(p
zeeT@V%6cpUtdUG$31leP%^i=^-l({{JF>gm(Vt}LdLW+VgJr53gAKlW0lBDp;Nr#Q
z%6ffewPNZasHz_GHqCZhFrkEyHQ2CHS6GU`xsq%?y0n{`amC&yA>(0-1(3RJb#LV#
zNkT1`P3Cf`$$E3WQio7+ZLJzmIzJ4A3-z-M2y@YT1Xv?B>UE7b?bCzKZK4z<mV3H)
z;%Ot&SYb^u2pBV&B<yX+j_F3DwXy<$1);<$M2mFV8ztC`d11ccJ2PppL}{WW4(t4b
zvEYzlb@XwvE#%PR3yFCo7jGj=SO@<B{uT>q*y{D>+FG5KE7og`AzWA-aI{EA1X!cT
zu(Yl`MM<|o-S+l(xuJ14B&)}T!X5$9gG<KfBIDRt4rtevE31fD)UQLR1@R*=ni$|#
zjBfxW)gEG<Z!68)Kx4VH8PhoMB}7u3$k-Nt)%fOVh^6+q5-SLM$HwEuVj7MaFn5g@
zRaYyOM!*KBLlrHCh+Gk1jo9Fq2x%%LNJJP&d*#cpa90zf_l3e<rX0L9m5M{a2#;rG
zinUr30!9cPD;2_A0Jd7j<fm0Z%p4W5PCphB@#f36Je4z3<!iQu3>SkWUC8~LSB7I)
zJm+FxDw<KN2*_0`5e;g+(E_Tq3?c7&ZLM4zA<h*d?TP?vlm_WS*mSXuZSxt&N$dGQ
z_iI;CVMi5({bN{GYkQB2U}U=>V1&m&yMVL6o-bS=_ys6Xtu|=kG{r8V{SP<86vU||
zIB^3D741f|$ffwvCR}2kOX6I%c`QRN<5_A<Nf>oM5cB^3>|JY+6xVg`p2yDYlZ8ci
z#V!aTumKB63*HA3{$atQNUFp<q&P0yE2PLtDFU2Wilo(+?MebHs@Sn3z%ENAU;$U`
zVg)FPgd|HYr;;keQdUKF8E`4T5|)Qx&F;*;=GpmfpP8Q9Jv}|$Gu^W@qEB^A^>p99
zefx30{?57Qo-;WWot$7(e}KXjG`3hgc)5U8NkUO&tf2|>y<&h>Z2sPY;>-x8%|B}L
zM1g=G3ku6q8YPNp^@ox1Xq3%mi^yJ49t!uY9;i~LRA;7)q*0AeB`aiy_vMXTN|Hn_
zT23kon84fAbONiAGnd!vnblBTU&mr{(bOL(j8>yWlp*snL+V|?sxXlU#gm$-z6Rp;
ziawv19YVVR+fZR+g++D;^NlP383|+>8mh50H_wX4lhaeN>my;D^u`~?DU)bCk@Rqm
z^-78`m6pfZwKD0l)!wS97N!!@nuwN@1zY@i6y&O@VPlJEInWl!3ssj)b&gsIXVCuT
z0#+pn=oPOLnjuX-ujsXDp0mLO9fOy?q#52#pDVi<>5Rdkzj1aA{!ReDWX<c^weZwb
z6htO%=8|n*Y1k44l}kMjvZ>UIY8u6BuLgE5Q55*Z8KRI$GQv+4lG5PCcy!QTU0pSI
zF7xMNfnLKbt<kiVKoMo4FdDHiH(Eo*sf3B7#D%8IL$L53gI=i;RXU>;I`@`a8tpRQ
zioDQPTN}Xdtj3z==Ejihh7N`6+O?3tl5WI7zGzC2B)d>4#;l}v4x`9LSWKPKLj;QR
z(o(d=Y;@xja43XJ$Vxau;6>-Ctqp>9LEA-xp(iqb)bKPK9Irry(Nzg6UPQqHTT1DJ
zxif&;GC?QrKw)0@QM(2Ti(yy>CE4u1#u`yhgDlANMWA^l63LN~aZn%1iOtl;RF*St
zFp=||;L}x+!l>^SFKENqXD8s`Z%g*4h(-@t9^5KlFyP1ETVe@-*LZlE$d^G%t|C7e
zE?~K$RSEh0xOwRnMQzUvV3~aDtYcO&Mt3ta3QNzhbelmL+bQBRBphN<>aSf71HXV;
zW1~~NUlk*^qACELDr&Q+9yAm=gQQ*<dp<V@Z~sbV-%3h)3Y0|P<@0;7)KphVX?lnT
z1HXV=1=#6l7Q9@*swjOhA*s?*8X^|ZDiH7p1!PwhEkju`1BH&dV%f=Uvzk%gP_6vN
zVsQ{Il(~K_G%*pyvr#<kQ||R*<_>By%aTT!<orm5EW^CUgfFS1&ZnY%aqh1YkKa-z
zXH6jJ4+i~p^})nEHo_2z#1x&;l1u7LJsKCVDhRNo?7%Vx^vdsNUBx(5R%u3vO6H2?
zsDa<O8Ge5%*T%eg4e@va<mKws5Q;;81abk7D5H$e=jFc&T-0YB>s7XeOAz$4&vH)l
zq87FU)f{Xo?QaSst*r~x)dlc|fM-RfV-pjR>FF40yOtEjQX-cNSQR7jcq(q68I4W0
zUKQ$lRp_L`TrX}Z2MWu9hylE?EMCka;mn^u8{mcI@}*JS1QxfC1{~AC<n^TDDT<jm
zT&lnisW4nZPCYR%YzgY*8p=Zfcu~%dD!&)nE~sMKjW!P00{MzY;^pSs<pNd(0ah}e
z$mCTw#v;E@W#ugaa1=8ZnYUqO>noI3$VpXT(NkHX#<8)<i0oAlI&<yg5L+3K#1jdM
zK`5mCRI|fu@xY|X;g}&@>fE%vCqxFhwDYvnWzw^hs%uzm;>N}rXox^A23yg%9Az+(
zVCjvd0`N=7F+@<nGj##0f=yZm`k+q_uxue&g_*HjApsC5>#eP9lH<o8j{ys&CZi)G
z<3O#59GJl)1DJLiqXxFrgiGb*#bsgSa+0NxOSL1zxzf?-6B#Y9rltyNBWPGtQynzN
zsi`P*M&K87@`%QhR$edNk68icFc+{YM#v;exL|B?_oehfn=M4eU{;aj&QX8&nG(OB
z*|TVFHo*Z_E?v42iNwLe#^eY&iaAM4O%>7xk{7ZZxQK8`>a=Fu4z->rXoem6Fl!Pe
zi<K=59<NuZs;X&hWKD|3z_!>Na`LJNikUZi6{%FZfK@4I#Zo<+0T=8idR1)iwbi+y
zlvAK9Q9!83RdwmoW`Rx5jzf9GwOkrz_~r46Q<E`DT9FAXAxNnZ99hOGQ4qD$ss-)L
z>TC-auWSnG_^3RzF-(!iZ~|36p-QN(shT4PeVv|)0k#Og7@V01QC}D%a{;Tu6hKKE
zQe0mjWTCID5D=>*tFTZrMH<Lv{1KG04S|4f-n<5~e9>J6euc)S@NhxCu3imMu?VP6
zJm~@bNxL<O9#J<fwxITe;6t7Ys<;$t8=3lTlLRh0Yg%yXx;lAQz^v*-QcB3tyMS2~
z#)qY7V?mITcHJ2luqp<yl1WLOu1X)X@B*>PgMuJQ<<<UtW_7`}fax+X!jn03>Qd>l
z1)+686Fq(Kujxn(5O!m9f}HGu7sQ^tJ`ZhC%v%}o5kzeq8$AauE!)b1E#(a(*BNYM
z?_QO!D&Qw4iWoG-gaouA<Cjdn5+<Xk=DZ>H-rvE&!IgL2{qDQ(=Gyz<Lk|~F?Zt~1
zQLVDvxAyY~4jizz<*4@b>C+CqcA-${nP>l2Y5(8-{XbxfRff!erE;0D@Y4AGMVZ?>
zI#&%3537wFI?7^+X^7+i`dY10Dw{7rO$|%Vir*zmKXvDwt#{qMu&r&;J#Dw$xv~|Y
zHhXprG&N|8QF;DgQl2@KOk`ZWQZuVXRm^&iM^v)=WOj(@TtsQFvGj&?MN~%2AQ-?a
znMlfcn<c;B8w~o;&ZefiTW@V#u%Kz-!Z`~THesc?xv{=J7z|d)aegekGxjsAhK2@o
z&Y%6Xb;XJm_SXE{-+V|bKo<1*u~7JL{`woXSMG#-{V)C!zo*`Mv$eGq;QRd_{4+59
zkw+e}q>tpClqaOd2R+8j#e!C7#pN9^w{PFe{rxY^aC{}lm|F4I<xs<vkkA5iTb)I~
zdi{EsRI@8rMu}vxjMK>!v4RfCNEXGqNoG7Juq#EE_%Blq!X?V{7DctI1V1xh<Ft&z
zKA)GSH(^&}V+|XVOt8@g0IQsLlCi~PIyZ;z7s7tP0#2>z>I7!J`pS>dKb?3&U0q#(
zDqxn4faRQ=J9iEs1+)T`Gd|zi`n~V|W09|Wu8%zhld+8oSh2eg4V?*vLlva-6)=~u
zNX#n19Z(cKGJ!!BE^MO44_~|i`~pagjZTKc%p4Yvrw5)TLHW*Q&+^HoCn~t6a+Sz(
zr;yZ9B@$^AqtOEo8+@#$fo~bMDCukx$Q5A@YOICw%z;$22}f*LPdxF&@6Mek%%WcE
z1T0$Bs%A>4okiXU`WC6Ow&;o1Tb%n<ahT<3k2Q%G&dq-=TZUyU!Jwa3pg+>ev^)z3
zSnz-UI|9uOzyXpqIywmzGUK+I4mapgo2w-C)N4V|x5_JoOAvJ8rb_A$uavfeG3N<i
z>U7m;b}FJ6v)Pj)#eaX8^f+{zh(rLhjHw57rNYcoIF=v)N1+n@eej`&$vi}Rzw~Ec
zrkb%r#wpMooJC`(LU|}?8XK1G;ZWjmIDafot+_zdMh(zlE1H_UT@f@uF>ldL$i65%
zw(xj(=gz(d9_YgI=%d}o29GE;jE{%=`}-bxc+D5?@95s}g(F7~rPQ=b!)xwc{r)fB
z+xqxdyVk76(%1LA^7<V<a;URwHI~g={^aDz<D7DLvFEX`babx5();4`d{a-HINsCq
zm5z>8Sg?Y>qztxqtlHhb6C?{OU)=b|h4t7x!6!^lCoE_9C<g(AL4^bbTebT3&$ZvN
zdiCPfpIf~0t_3SsF1S-(n&#FAg8tgN0BBb%7RLg16KCdpDdn9dsVrQIc}wI?VB9U1
zV~2?uQJcw>dQwvzlTwlv*$_sPhk^lrZEe8ol|0Vf7tkwUM6QlXpn#tI+uwYM1pxQX
zyFWJuI7J2r2hqv@{E5fuFP#N7{OqUy^1y~}{6%kv=0!DQ3;tpww&0N04jkmU52||f
zku7}Xxenj3VFOx=@=8fG7$~L?J(R&-rB%F954Qr>OVER2{9Xb?v>fL`v9VBC_o6_g
zpL=fGl`F#o1IOQa=k$xcyH1^Y<J8+Hsql+^J1$?jbnxKo|MAPSyLat*<K*#^Z)5;y
z&z@ZyzqtAIuYP^#;L)M8Lr0D<IJ<D+{QmuW_wN1SnbW`Cz3U}ta|(9@NNw7*W$4TY
zCyxKyg$w5nA5Os^R{HyQu3z6hH1q+Mb?dwL?R$CP@S&ELma{`2Y}>Y@qoWfmCr|wA
z3=$AWCqEZYFw08PaKX@|xw&y6Gl$Q?($=<U&6=g1olEY%d*SW3&s%)Qr?9lN%wfRd
z@qh<0buyNSMdNId14%2eC2(=QROjFxjn=xaY}LRY=cJ!hLghGjJE)_gLoR4-fs&X_
zE3i>9LUna@z52=u5DGv5ph34nba-VQ2P$=<Z=+W$Hh$EMb;VAEVnBgogRkQd)Qr6Z
zUIcvDqA|3gWUj*jMgS=?mIGx7#ZU>ggzV_LW;<*|3xQdv2iJ&V-}&~ph)DtOPQCS}
zauXoB7xnLNzJ2*JL#z7w2K1b^w)V##|Epuijy(8B8~^jaegPmm@Y?H*vuF8yVtae%
zQ%`L_`jY{G6dk*3=N>=_R+cSWzH#GbVAj{ZwiSO-RY!YjI~Jw2{kvbH@<5_Z8@Igo
z-p_k_wuZx@fdK&4OY7EkQ!#8@zHIr^+n(CAX>&t;gUKH2v`T3H6s{vhE&;J3lh!S_
zG+<F~*XZa3J%VU7PU<A{N=-^5BP{+s8NVd8uPH+}A>*E}(ihbzt_dt5WI2LK4jJ7w
z9hEQ(D?ALLm!iXKOy&SMl=<Dc^SJ;k*FYXRIX@x^TtMYKx=|Tw55NK>i|_*QK`R>S
zm+NrCI~2g_fLy>YREXLDShymr;9`yKZr}O#3LFK>2B;!SpN8M%x+vfm^u8@yy0c3H
zt+4A)zqBFOdFQvZDxI@se#_ajXRz{_&n#cJZvA6hzY5HH`swZbThY>z!QA?WhOlf(
zhq{Mf1+7ThJ30Ys*tLFLckz}ZV+1jd9A5%1R-ra58*kU_*|o}F#i);`cJ=CLES4m%
z`{9c>#wQ|PPs+n<Vq!WXo5pC&kMN5(V|hevV2O;SjE}#XzWa_lj>^6CTjc0anmY^N
z<N23H01&_n6aXPYNrlmvIUKtHH!|C5#o=H;04ykO=VVzSiy06{8-8{A48ffFehyaE
z-@lhs{bWL=U9{cP-oIyWO|{qW_vCdq52wfSdSB>+VtC@@@y@Q*z^opbc3FFgt+OGg
z8J0_(N)Kd82v$K3$C^kal_xbkd}DGV;_;^bUcNj!IT=;pj730=#`#G_f;@WYmAx($
zqdPC25?m5U4Ilt8q4ZBe3Xl}O81@1MKD%Ohk*7lqfCB>ng+PzP*>%~C@!=p@Xe16t
zC8Yh~>QEKvRkrmimq5p)5rZ{doq#_xhjeyye)Q1+)dVX0g^7u9_Aa2+NB?sHB&&d4
z3QZ8OHE`(Y{{4H6OOlfK{`;y&c4p|z@bED0GD$|t$Bt9Ej-%x)z?!NmpWpALWznL!
zD?Zz@Y}tHTy1JIEUHj>K?_<k-Yd^i_-lexMx}~LMPV0iE*48;>L2HudC$d>S@-JDh
zupXDgLwHJa8DJBnPw_@5ev}Pb7!VC8mP;SBgpXu6Cw#=OX7CQkLYkef>!$JHq}$?f
z1?(Q!&`m>o*<?+*v<Dx0SQ!I7APXIia{;-aGNUodO~{2Tt5$Wq@WOV$7ImCsgGc)M
zc3@@6l4ZcG-rnuM|NVI?eDvtRj&D3=+&`J0XBwo2&Yr0^HbP0v;Pu#JTYGz-=WX!#
zyKUPJGGO6%c$keRoWF2>EHvhJU01TDy1HuCtQtxLi3K|5J#Dvjbl%b4zPP>P4q7@p
zm*8(FR=DN1+vYYj1pR)gbaM%z7+#b`VLDK$XhdJpwsPrlR#n1RU->a=R=f~+>%L+h
z0?-t8I1c1T28godGDXqpNRcGG2IS#Z5V|Sn0%j@a(yb(skox*|z4qGvZQD|c+vnHb
zzkPek=b*QD*TCT)J^A$>`g{NV>z{wFFW+6Nhi(XEP&Qh%?B2a6?~U#0*$UV?apLuT
z`(7pt1zK&|v{|8G1BVZ`cdSBfhY$axuuwDkqQAQ#w?6q22>2*c7%#WZpB;}U-g-MK
zKKbO6|Mb1@y0@v!B@~K<$K%vnlS$^TlJ)KK27}(bL4|at-{@=+Et#xDeba_$Z1^b5
z!ey`T=*{3b`bm;+KJ%={y$cl~X5MwXj4bwKUCmvIaR!~@A)`EPO)gs5A}(N6k{HCm
zQYMkvRi|E2OPg)JMq#GS-bJ3>HQBp>brT7NxH8bBC}C<=)(NQu-9{|4uIq9c7qDEJ
zalpz%m9)LbXV+(mO-MONR$-K+c(^ftT1yQq(uU>2s0&y(({u7@Qx9l5L+&BD{3J{F
z(3#S|N_pB+f{3dUx`1^Pi82>d_uaRg_C_kSFWKa5S#a;Q7e*~rR^+K&hUEg*&4yXI
zcX8d%Faemgu3J1hI6e;GGAtLcTq$R?(oa0$6+NC3u@Xz%%l1=Ov}c1WE?~I~tK?nO
zd9Bdc+5Hpw_*`)T>yw6720jf2d(8u!Lr_qFR#>i{pDyIMfaQuEy(Mo~Dwvo^l2o+A
zq*QvwVLpam@fT9jDC`23D^B%5P5v(3{-E><Gu^`^$<o0}J6zr!9Vj$ec`4@-y8O%q
zteZ=GzML6xG-##UX-yJ@BArM}Ksszx&0N;w0+uU|Jt|MmXf3%qUSXJJuCLobvI>I|
z8?V9=^tl22T)=Y08pHB>Y>zu!ioROF;iXZaN;Wme)dyX`y6HqtvLx!cxtmG~oeMik
zHe6__8(Y1KGFSIpa^?coO{fwwl4V_ia;_Iz*sKdN1-H#EGnPwyT)=Y0L5Ah^7Lwe-
zmY6g8q(*mC(Ru1&hGCftdFZ}YE?~Lhm;%KBORpmqKAE}58btHN%T6`QWJXnc8J25w
zF9%^sD8Bj3v+j+k2uUP7(-EJP)b=y4H|h0C#?VoK`Xh>FI(@Mu%hXvMRQDtY>U6~^
c`F{Zh02Zk_W8a}ZW&i*H07*qoM6N<$f(4Iw9smFU

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/nopreview_image.asset.taml b/Templates/BaseGame/game/data/UI/images/nopreview_image.asset.taml
new file mode 100644
index 000000000..cda718e30
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/nopreview_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="nopreview_image"
+    imageFile="@assetFile=nopreview.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/previousOption_n.png b/Templates/BaseGame/game/data/UI/images/previousOption_n.png
new file mode 100644
index 0000000000000000000000000000000000000000..3a9df0efa941a19848237264182e8e839e95d74e
GIT binary patch
literal 8194
zcmeHMc|276`yXu>TgcKaHI21pR%4qCVaUWFp%JNB&M=sznUSFg(Tx%cWlOSjix#B9
zmFz7l5em_@qz$)K<yPM_L#2DW-S7Rqe&7G{I)^!*=Xu`G=h;7V#JV`GR)GElg+L$*
zBzvMO_?IERW#)jtdHpGF5QyyFP&bOul^P7=@wrS^AOI7F@BkPfVlg2QQP)VCS89)`
zBJpE+oaYQu;;iz87B|zhnx9WtFZCsOpF*ymIIaJ}ZOxTD1E>^nR^a)M<9!1k>Kt76
zB7u|nDg7b&sT-bVx_uN8_SGDF@**@v_))!gU*)h;(vsf{#%E6)?wfxTrSXtpx%d2l
z({Pnjl}5#mH^oQpWNGU^=^d;}tZx!ssIF9BtY7tOXy%0T%MJZzZ{LsS&7uQybSp0C
z?yj~N7;vKPu&RiEv6QB|Q|E^E7}C>XclNejqdOrMH+vgy-rVNxQ~Qkau!)`$yrrVa
z=7VYY`edImgZkmDfhSt|Pmk?*AF5U@@F4hF9zJ!fUuJ#z;>S(7-oB0tSLk*EG3TEj
zH0ykFPqe=8z0U7@x)p|{H*MHWd>uW{<Kb`7VOqY20x=C*DfGRn@_|Khjq1nDVfVG1
z-1Nz*ZY_sk`tnV~KD9x8%<%zc%F5H1nl&jayk#ziR*ui?3#;~gxNr|!=As3?;o{LD
zjc)Yd(*vFml^a@Z+Z#+SG}Tn^n15zQ)LW=vNUCyig07t+s$5s&Mt>>Y|9L{PQpM<O
z8RhXCfqF7BZ&Y-CR{6E@mnCzXpcYwKt2G%Bt1cs(8jy6Ar4j3L?_~twyan`q3Dk$P
zVI}j{9$~dgEzi${zVaaDjFt>03y_|I>xgl<Zi@GsTQu`_cO0wZ=n40X*UOCBy&c*&
z1Qb>^=(SL`p2V@s$~sn>j2tiZ@D2CfT)#v+-u!CI+SLof_FEWUH@|k<(>EimL01mS
zD_pTLsH{EsPF}0i%CVB5&U;%e2fLCEI9UumJbo<e198Oe6~cckX<}g+FIOFPB=GRX
zBaLSsC+J4qA{jTYT2TP$_m@d*xrKgVls8YotgiXIfs@Yat!WCGYVw%5jw|c8*Q!=(
z42H*MXjfG4@%lr?%(vye>|mzVIJ7)_%LJsX9aWJc2P?FuL2aNzP0<^-72Oj)@>)H9
zPwr!NOSX?+(UNX%R`J;+!Gc)qseI}77LsDJg4#*#_K}W8-63s)F(aXtv=$nBPF+q&
zu5?@6omQN^tS%r+J1K3s60+6ZE{W1%)!Awg@0e0vV4r<5hq&bSol2Y|v0M8zJ@~=!
zRodl%_;N1cnq8q!_BB8&QSh94&FG#pzq|YHql+oG6z5kZ?L(N2wVYdVC=J@>y>ZQn
zu(5`kcwtv>@u2R?^Au5mkH5A`&Zw?ok;QTM*IQ*;?6*A)P-_0kcU{l0OZ2em0+sH$
zuVb@-kJoc2y6S&jzw)92%rSS|Xz5EQ+}vkbDn(gZUdOkM5*{pq;sdruQpiJaUhcby
z^JO&oJLiA9&Sx$<=Xm%yDz_AqzK5E2uO(+bF(W}RkYb~`x8}sQTErUfyw`0Lw#u3}
zM2o2kJM+(uKFuq0yx$Qn-vPuqq(<D{zkOf5R0sWTa8HTlX^+rF_a-987I{7#4Doke
zbeP^f=-C($(~e!*_2OmOBCOBzLozk^E!fSj_v!2VPO7+Ka@AhL_AZP5y%~bKNrb<<
z-qx6S<&v`X!s7jYzn}A1g#Ot>IZyrJ0%m8)i!I8p>Yl~t$NN3F*JKUrxMLrw5*`ga
zzEODKknH%JWHtWz5~f+?#FBtBg2n0|P$lDQdbcM!Woe+b5d_uw<=F1Q$R#JdAB=lm
z3A<_+eE;a)Em4Wt5oaFh>{qWvmzJNha)^2rM24?=>E=tk9>ar`y52!=&r7dQ-6-pw
zbaI1Y)Iq>I)Mt6C{bG;p?1mc0x+BLIR9TvBI1+Xuz<;R+60d*U6uPBwrp<aeeg)}P
zPMJfQ?eE)u>dAXkqTJfPg5m%RqFM0v!Ho2hkftFGtTxuA<F4zYUY*hDaGX^sfBM#=
zP78-S2RFQ{bmeb4nU6}od|EHl`pWKGE-1N-(*8rbFV_quM|vtZ6TM;39UXSgaz>OL
zc^wn0Ho*?&jhxFXUJ0#5sjMob(AwTmM&6tqz-<mKV9&o_<xP>x&J_v#mETixYjztb
zX(cVaOnM+PnCD+$kl!5QEG2DR+hIL+0D6v4c^7V{<Yr&0CtdT7<|Z$FV0E3;ydH(R
z{6i>oqKw8d&(c3;$}X5NQXgGuu2-iS$nMjSEo3)YEc6WLTXz{hhK|6R(!77JaUkBF
z5q8W@=SVb(nSNGzgq_eK74`n+c02Q$m>vzzk)Xq9cdOuK>MBaH&Zl%$y3LkZ9IEF)
z^>Z*%)+->zXObMMIRQw1s4e+Ed+=p?x~Aatg-39`g0Ma5J^HHeqWzL~&3IBP`?kn<
zK~W{v`HtV)BQ`}fdM8Uvu^kn%xf`qIMqWU!l@%K9zACTJR!yn$`zh4<aD<BJit2Op
zfmzy_kF_q=)rDj=hEE(l_{$(+LxEyA-KL#jk~dgi+!c2qZohj>X!q^G+Pf^L6z|>h
zsPolam(dTZpINha{@%N{=sA(5F$UM7{-}S!-MsxYW>k>$wxaRESgaCFdF^d?<8~Kn
zUcW0M!e$`4AUSq+L1%{D^93Cp#u{N-9EZ*!#ohOB+(VvmR+Et)&R@P-gRJ1Er21iP
zjr5vJYBJQ6C5sNW%-IqjcQy#wBvg)^`%qiSYgvdsU}=?g^>JEv+3cfB<}@25+a=hi
zc$`ZWdO=XB=D6^Ao^B$xw6RxSP8_W3VE5~mM6a2Yx_P95(DdrqO_!dH*>GcxdN!g|
z!;~LNd$fi1Uq^Rkcg33c+<9-f?x`i^^6sKc@<?+{DYd!3aaaGYCrOb9j>RkGZra@H
zbavJ0wMy26R6?m?wn?t#+1vA$#w)57n{RwYc~wL3^NLR`Mf(&}I<*W($#yg4lNprV
z8!sj1$JgCB@S!QH^=D;l`=+_?v#w{fjkMKj8&#Ub1zb1%#oOBM*hcLK*1KlD&N1Iv
zq|8&wTh!@&GoW|WqIbocC9?glju}0^dXeshA6e}Q38RIoJA&l(b9IVMOWbGObXXio
zUgV~5@qYhe15QSx3u-4)XUmdzIM%YpNJvsf?EC&Ghpe8JA@9!N%Y&c4L<9sD4Sk3<
zI(6{%N5!nLqt2tggg2yY<YG@L{T5}^iqiKsDp%H2C&^V2$SX6+Wo^ARD#ed|@E2qq
zDWwN#cz3e;uN&QV1|>Y<+_^^ia4SWlJe1$Gkn`%{otybj?Wh%t+whG2$ZFh`ZB8(H
zmS+9t3fqy|P~6DN3`P6;X2U4f$LBG!!}PXiuXBzMr#9Pm@5rk+c)>7xS==NOQgz*F
zJfZd7rZaORDq`e<cStS1RvYMYbwLmWA{E23v2h{U*nB#dfv2&|uq1+g-KvERo4oQ}
zH!SS3BI?)#mE70pH*jAO71QeB*IqN&it=ks%)4L;JvCd}QoT?Sd7}b<0UC8*dUr;~
zfunnp-&E(dz#DfCg#TJOeqo!mD8s!#lQ0l*G(8lrtigZlUh^>yvP;=cMip*&mchix
zbv_GHQra{|Gr#t}CtF)bLw=5ER=-)nBfV#Ho;4R7-_onU?@Wn-YPM>^BcWCQ>QfGi
z)mxBvpAMxd6EY6#@0%-^k4&vNloAvpN;h4$eA&=8f#S8y^QOz&@d14Ys?ije^;qv?
zX3?`!6N%6nI=9zasp-+qp2*X*Zwv2fu=JZ)H@N?@yOeg*41X6`SNQLiZ|<F3o0%@$
zAGPJkcteSW9podj#h=nKUJR5uLHZ1N`CI=e(?d^?LUVI%6Cysa@Ap^alD1tMQbhlr
z7hB=yV3FQSQx;j~a<9((%?ozs!OM=`rbjaq^G~I6BX-(sK1;m&1UWYPWOSs@aO6Wc
zq|%sQZ^6kKfIw7#Vu1%`3fU1)=dzJh2A2jPMQk2;kcL3aEk!&kJpd5GXn-$^Lx7J}
zR>NT|1_8d_h>RxlYydx&eJCGT7wY6j4-KH3G2oUKP;(I;1YiR~Don%<<OuL00$hTN
z2S1CKQE-@qMHoPUQ^+nb8!jJ!;gC2a8euD9ZN<VZpfGbjgNb(~+D$=#PXxH1P{_lh
zP{F~$$Y4Vxm+y<hn3<WO&{z}}ivT$gf)I|7Dnf7s+G2=F3?d+)^I1G0i_3wDF{w0e
zkdOd}gLK#wI7p@2ionGw1>$E3yg<l6k-!HWXb;GM!lKcp2s9RfHA7982dQN8XK9XL
z%8Q^sQ6ef2g+ZcGZ1z_Y0-^2JFZ#YIA#ek~ub^B30XK+G2W+<j9HI7fr2?TV@Wm(p
z1q8_c6#y?VNHBfVK>|R$Br!aY!9;;pNwz*+>1q<$<+F@94!$flPa+}ap3cdjf9B%_
z@dG713_1!31lXV@0uUMV6~Fk4*=LEbtPxZGvJsviSI8Ckae3dC`Aq(cppeD<8$Dvm
zU)VvjzOCU?U?nz75&%!+(u2gtk%$C1xPoM`7<inmm6@S27Hf>PvBO|&ai-R$hE_I4
zI74e2V~m-R@icJ~M<Aqf=)fm&7AQ_PVHh(RrltrpV+<XEGo=|JXvR$N6BElcWSW>T
zj7%8QAe{LuuuQ3e|L2{E<BPX)AratMBw7M2S#b%Z3YlC!8?1X4hrtaNd?C59*uXj=
zRqQ5=v7wPM7Gq+9#bHg2j10dpc>sI?Sbt(v3>t~SN+=9E-VVg1f_1=RQ+)vxkK-#L
zhy#wd;RbT~>%i^<5a7ljn9&!K3rhq9Qiz~p&Lk=ZJ-JtjpoHrA4eIBdn8YS?86foJ
zCdHx0gU$nkM-?{;&=!e0$-1}%1B1lN?i?1l*~#5YNR%%$0^9`b4rnwA+|1N=BrKla
zWdYL!Z^H+uLVyU~AT}C<Ltrpqk8#6d@P=4C8n+yc!A}8x=H~L<xZFSjTpS#j*r$@+
zipgZKy)vjm>R;hNEK@wr^iOc07g)@Yf8rK5Q<(Wwo5VYE=@KtZZk!<@PWD=BsxNAi
z7xg{nzaXvi;|6p7JDe}9pHZy%!eA~xz?tt%^9Sg{@8f)n`7@F$IOPOFehBFwjQSIw
zIp}#Z8E+5Da`_?C^sfW9Og>GzCy*r>Ixv`|{o|?h$y^gqw*r$@40?HzME9d|d;xII
zPW8x7>#T3|2qPv9Z497k2tza$ji6F-V2@xh=m;i_#xygb;czBsrX)W;qYJo9VK9{s
zSowkpPk>vAXFkm3Q%8k?XETGTI$!#=V6Yz`F5+oP`gK-K27hYs{%@?M15`5x)d)ZU
z#%44G4m<!Ls5nzB0tc8H(s6(Z-N<CJ8vf4O)!@XE)XYB_iNzo=Xwa!{7#tpp#T#Ma
zQ|6hY#OH`lu{9SD%0ESaDj|pfp9O~2j?ZOF0xucac*ft43G{cz1ehD(499;f2PVf1
z#_n(Br^-@1;PE7Jw_O*+;{~z+{@2<1se1p0&-}}}r1-i2C_bHSQrd>g3jxQJpU^p&
z^Ii4dV4Os7WYNLS|6SeFSti3Z?HCA}Jh=uQFTv9)>hp1Rs#d|w`CtA_^??7S3K;B%
zl7HpjAMX0$u7Bl$f5rSGyMDOqUwPnPG5^S}|2KC*zr64QIN<3!7<`?j+J4>(d=)l_
z=CGOw34knsK%`rXOTZObp1r340+CY{-%^nDOigf6T1X<>N)JI7sjB1F`4T(97oMv~
zL@PJ&KhE7&<oeC?>~3w9kDtY}c0upIB&CuVF;B<bxM;Id@bepF|NAT1c=87`Mbdtq
zPuJOsw2<_^svVn@)Zgvco4payUUMidq|`&2&Sb7ouZ5`8{p0mZg!ky|0n>e*3MRd?
z=gid{mnl)!mMc-ymMxjDEnT9eJ$r`stZ!Vo<I(2n=Ck;RhfDQ!UMohb{E;$S_l?#J
z-8cD)x^rge%1paLA2STsy!P(!NPc;xA>QC^X_e2*Tg(SQU7zw1$fKhalU=mCnsM%Q
z1NHbEis3HW70oy`@L_Kb1+|M-t{K-(Gf)r6*-j~p;g`D298%r&$pNi>uV!C|BUXiO
SI$;mG7ecaiBA&9|9Q7YrM`J?(

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/previousOption_n_image.asset.taml b/Templates/BaseGame/game/data/UI/images/previousOption_n_image.asset.taml
new file mode 100644
index 000000000..9b7fb0568
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/previousOption_n_image.asset.taml
@@ -0,0 +1,8 @@
+<ImageAsset
+    canSave="true"
+    canSaveDynamicFields="true"
+    AssetName="previousOption_n_image"
+    imageFile="@assetFile=previousOption_n.png"
+    UseMips="true"
+    isHDRImage="false"
+    imageType="GUI" />
diff --git a/Templates/BaseGame/game/data/UI/images/previousbutton_d.png b/Templates/BaseGame/game/data/UI/images/previousbutton_d.png
new file mode 100644
index 0000000000000000000000000000000000000000..688b3034593019b560c95d56ca9ad50633a1d800
GIT binary patch
literal 290
zcmV+-0p0$IP)<h;3K|Lk000e1NJLTq000XB002=41^@s61i4(d0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUy#7RU!RCwC#*C7tWAQT4R$5_yiYII!}
z?of?JPOJymNp^(U>aLQWp}M-VW=GgSOtJO1OWsQ!>dPPUAR&lL*PV&z_HIo(bxiQo
zG};(LQc4m+6k(jEjJ36vwAQ4Q+D*=|s;Zp)s}5;NiF@#a(PGS)F=NIkUe^`Jecxkv
zS(e-o9)<zi^E}VR)FO^C;?ro`7RSyxs_Pn`v-cjyDY=yX^-w|xI8N_5Uw+1n88iML
o{M@z;!s#P+eT?HB!7l*@0K(HIh?3cIX8-^I07*qoM6N<$g3LyKs{jB1

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/previousbutton_d_image.asset.taml b/Templates/BaseGame/game/data/UI/images/previousbutton_d_image.asset.taml
new file mode 100644
index 000000000..94d3a330f
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/previousbutton_d_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="previousbutton_d_image"
+    imageFile="@assetFile=previousbutton_d.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/previousbutton_h.png b/Templates/BaseGame/game/data/UI/images/previousbutton_h.png
new file mode 100644
index 0000000000000000000000000000000000000000..26cf0e8c67dd87290ea60c90d31cb755df60b7bd
GIT binary patch
literal 561
zcmV-10?z%3P)<h;3K|Lk000e1NJLTq000XB002=41^@s61i4(d0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUz(@8`@RCwC#mN9O^FcgM=hbYMiQjl1=
z0t-C>BL_eXU0B$9lCDhj0MLO$6qS*o3}t8TfCx>}q<#)g6KIH2DOD=f(ZiAb^zpyn
zi5)f=3~mA3^Qa@I>5M1#`~A9Y+gB5((<yW?R=1l?-m%QYFbu&HcrtJ76uC0QFHu>3
zy3Q2IOpqltj~r`OQ*qL)SfWmr$+)hfT<Z$UP<12H8(n2AO1|cjeP)U>Dpz0?$jW9A
znJJRv70iF?ezt;2GRTc;khLUPhNfxoeP8r3h{ls-8II%Nd9@OKJpLV-Xa}A&o6T`J
zI4SalX4iGGUazs;zQX_T<M9hOC|u9SeEx_=qXEM(zY0Is9Poo?xqQNA^MY2Z1<Nv1
zn$te><i%nEUDpNKvaD>fVHg+=hoVTjm&s{2v?w?ly<QKUP6wXnMagnbklFbPh8T~>
z*zfl+&4gw~WTf37V)v$tcDs#Qt(E{W`NC?cXTyDWF&d48=QKzEmifXSk4MnKPknMc
zb1NV@$+2JAWC|R|1$QJB8FEKb+GN=OF;Pu&sb7pz%GFO|)dJ<bQh{<#LxEPFj6&pM
zn*X31<;fuO+itf*5CoZ#wC-*)nLMb-_!M9OQh$5K(URvI00000NkvXXu0mjf{|f!F

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/previousbutton_h_image.asset.taml b/Templates/BaseGame/game/data/UI/images/previousbutton_h_image.asset.taml
new file mode 100644
index 000000000..9289ba64e
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/previousbutton_h_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="previousbutton_h_image"
+    imageFile="@assetFile=previousbutton_h.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/previousbutton_n.png b/Templates/BaseGame/game/data/UI/images/previousbutton_n.png
new file mode 100644
index 0000000000000000000000000000000000000000..c0b9f4662c6767a69f24d83f3b532a363e36a43b
GIT binary patch
literal 494
zcmV<K0TKR*P)<h;3K|Lk000e1NJLTq000XB002=41^@s61i4(d0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzkV!;ARCwCVmOXBRKoEt;h=z{J&~N~!
zpm7eAE94|OLT*EmL{3F-yP-i!3Z%H&3A=bOKWlcz@=8XU0`xJ=dpkSJ>g)641pwaK
zh{1KW@K4h;sFYfamcsxM<0y(26Sj<r00dV^Z{0sLz3IyAxs1oiEQ2N1Jxa|off{tc
z#Dp4ipg@ejuJZ~56E*^oDbVkthy<Ey9PpWt?i7(5Y<(V=JHWxsFzUJ<KQp`A0_rG=
zVsw9A6a_i}R{dwIsxr|%r!Ome&AZ+AXop;F(Zk_rvd&?$PGMg~S(X<U6i!C&MA*}2
zGqa2Y22&TZEQ2&nXE54e9eJKx;SeozBU!H@Ns_U^r51hOZs*p)6*!LL5e$Ck1~PXF
z-aI$(UULH^0%0VOaZq#u2}TACjJZLl5KkZo=EeY~GSE4~Sj$ZkuePWyHSd@p7@3)o
zd(e}7UT@s&23sJox(@gU(4}UHb=?mTGFw#Sv&cH&=ay|NS=UJfO03go_wV27)XQ87
kUGwX4zklcang0tg0KT&>jr)t45dZ)H07*qoM6N<$f@y!$IRF3v

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/previousbutton_n_image.asset.taml b/Templates/BaseGame/game/data/UI/images/previousbutton_n_image.asset.taml
new file mode 100644
index 000000000..0c793bc45
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/previousbutton_n_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="previousbutton_n_image"
+    imageFile="@assetFile=previousbutton_n.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/selectorbutton.png b/Templates/BaseGame/game/data/UI/images/selectorbutton.png
new file mode 100644
index 0000000000000000000000000000000000000000..cd0780068892795e6329d713f48e84fa9f1df8d8
GIT binary patch
literal 4002
zcmV;T4_)wyP)<h;3K|Lk000e1NJLTq001Wd006)U1^@s6hvIq<0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU>L`g(JRCwC#TwSbPMHOB%XP?{K+frI-
z3jKpZBw}L3h<XzquwbwW4?g&$)I=V7;lUpo37QxU5Qz^GOhI4p66C=mF@^^oOn?Lm
zCe;EOH6~(eO4C9M*xF0!{XKinxYqpav-X^seSU7*+%|i|boQOQXXe}ATC--YHRm3o
z0r3Bod1aurSk?$a=;#=!_8~3_EBI=_HQ*X>4Y&qe11`0<j&My)P2Gjn16X!U+n;-!
z2iATR%R|%C(@zgQk=A;svS-hpyPkULDShO~5p6CrMC5Yq^c+1;{f3=u6tO<AbLURj
zwsi~4&&`?!s>9;j={b7dF@4^3ZpXFPUJH4i5A-lSN6%Bgp}nz{>}*Qo5DrnM_Us{T
zg8A8VrWo<LdtP`uJ@5JrHCHz3TN#y)+^3#t?A(Q9E*rh8PTa!)?dP4j_<ib`My&o)
zN=5He&os<k6wIw?a0Q#VNPs9VW#%qTujKf#W2VsM?|I?vqk1KyZ2U*xe*0}$Gcf_$
ziH+*8_;z}Zo_DdtdDppz4jee}YjVAvhYMF<b4~O?YA0a$yy-W*&W&IwE78}JPg;?M
z(O0*9<mgK**NQi3*9Kezt^wD8Yrr+&E*@udMW440?9aV&8ln^3n)uzVb$zZFOj_9p
zfW#2GD`J@)K5iY*Y(P*Va-V9`5zsLJ6`(PYvJWs36v=AI`nOz>>>h&Wcz<4!Qj&du
zr2t9>1Oia40CWg21eOGt_0biPC^8Uh*2j*L$ds!!^kyDKO!P8>x*ua)d>LaXW2MDF
zw}O7P4087Bn5)w>-bPouX2B`<oN|3sz$T;?O;!V{PS3&xkp*Jb0XP*gD=J}@bVaN+
z_Dn{Ac@ef5W9>-c?OCu`LJ34IM%G89A_1%wn2fOma|Emi%|>J~h?r=z2q@?SEPLjW
zhrV{^gZJ)LN^PTU>KFIjb2zqrVfzs&<vSZTUG><V_doD#0vunh6_6(4cQmF}WflPY
z`i&po@yM>*z6jS}w}UqLcuwE7A3kyvUU>Oc`1^m3-j4u(i@(WTDO|1Gz2fGEc8qKQ
zkqXY<%zr=FyX)?6!i$GHaNqA=gXgjFD?fX!2b*u-b>n8B7kTwhukXdC-?3HdSFsM}
z)We#RlFg#Xw-RFn?1y(w0{j4M9bT^er_UUMZ|%ATsGoa5#l}-L`gjpIn@;CKli_uZ
zn};z}@_#?~^b<y84}N13KD%`s{`P*+Gw^4wY{6gOU4RFFa|oXQ{w?s;yY7MSJo>~Z
z@K;M%I;<2-2feseOy^RoRs=@Z+6h^$!z<Dr+rA(r+KjE#LG`ZNSyt<w!PDSk04sAN
zu7MUr2(r9deZaNi;8J75pnGebh`W=EYTW})45Tutxd#q#L>;&!b7HV@mK}Z7O+Ey3
z=O;8=$>3t{b*b>J!52hyoI%0G{Cl1F9mqb+Ns$ECZ?0PAbfTzbidEH&-TQJbnALp%
zDpq=!k$4l91am5MjZ$-`wyzlVx(?hBVod>yg1l(Fl9*f0<5A<8kn8Qel4rj=2@|Ww
zVQzk*XJFs{wZ|)7$#u*d;T~}jdc!HP*6CZ(YGv=D>%EmcTr)8?QXTVzshyr9SDpHW
zZc)DlaZ$w(5HKcKZ9+VXq7Wb)IQVB1eLaVbB(m`G?LqWaM1ZLDg6J{_iS$FOE^fVb
zqd4-)DSdqyw_^KYY`-qhsXPFf0t$7^LCWwZez%kesyhrskzg*Vcd{n+87>ADFyL1m
z1TjIZJ&yq60HZnMER{rwfQ+^Itv&U*+&mDOs$p%Yy)~8%(g85V7>bEC4|GW-5{bI@
z1c!-MCpLc-C~?6UE0~G!B7`91>!)ivRIxhdL?S&ZBH5ul!JMiQT@SF@gmthm`Z1^&
zLn^Wwq0f%c11wyavd`&C3|P#C3T;=BaFLR_7PA;x-SH1I&brT{Nr^}Gvj#(-;KVxi
z0jdUA^+TV1t>}*nT{`EjJnQb?=(deQy?jddEG*tGMi6PO&Uqj@cI2c>fc6<(X4R_-
zr%iZa70340FQ4w(PtgZ(76YZj+=ecJ2&N9@&nj_(gU@8tl>nOmT(kMv{A0}t0TvOE
zSppabCEY~QgEIHp)nwGPIfsC7SD|)6*o6V41h<#=?dW&Hk_?*Wk8WQfFs)sU07_sQ
zB(l^pZMu8<l51EM+rAuV4@_Z)0x443Mvd-+o%nlEcB%l(0tM&5qzA@8wQyu#n>OQ;
zD45U;oMQ-<G^{2-(t;}xWr1%?KNpTM!liJ0#Q|2B<8C?!W&j}=R%gftm9}#2)M-J%
znkYB~ZNMQYTp1mFIG02;B?Yu$vGDXWfF*m?<0V}xI|r62-35gr9CNh+NFC-1xJ=vr
z!s(Y8X`z5M1S}(90y3<Zu$Bapo+Ji{Qt4kvyAgniRd-h)7iGzma-gW72v?!FR^`gJ
zQODT=)+zSacL+%Nb^?@1=-|p&M5`y+!ZL`YUCx@B7o{O|)4R5-)G_6Nbu1VIYEi-J
zCAwEI-f`g0c3{1-^O$H=I%PkH;MxdoOe2XB$D(JDIeb90{R$$cb$3Pc<GGC6E&o<t
zq{NzG%mN!nF|8*3!m^s~m+UHq4|CXH^v{V^I+y8e4(o}r@s?4Ad85xQFuV$B*&;wF
zTGg_QN!MmXn*}keF&AbvLRZHK1c8}HV5nbf=L=J>A@&@&jRo5!P_GKd=!P)~3#6Y#
z%dB$ufMv^=7h!8{7f2be5Uz}GP1>=h7;B_sB+3N`>|74({`b=U+dFT)eg`bhZ7}^F
zpL$qE{G_>kQ~TytO`Ms%;R}EG*zLPtDjBfsDr8TYRcq~E%hb%63*4N&am^fCBm&YY
z(k;UlGPM?!`?8O6xct<M`*(eQ&C>4jv*~?uCH}MNZ_JME-}vR-FI<+vhih8!(drhQ
zLnAng%+6CmWQ$mqq%$|fVy3H`p#`cfdn69jw=rbS=o^BZAjWpyx7R#==+GgUbai<7
z_D!2MnZIv6_~^bn=D)Q2kF-F@v{0SXy+(7WO>Wy-l&&!@O-W^|Vq&G0+U{6@B-#lQ
zB{4=5Z{EDw4CL$ZqV|&~Pr~FRLdAa6f0cqoEDIe8?KbJ6wFoV<irM}xR=l%G4x!ei
zzO6!*#&LD7S+FaT^lUwugqa+!nCZaA_AjS?JUu;anA^U68*JIS4c>q6WY54?UbPuc
zy!#FuKmLwkZfa@@I^UlD$@(^&TA#t`bs5Z{{>@CF{-LRvMUykz#+6OF=X5U50+(Gl
zBWzY}Vf8L^qBX{tJ8n`+cNh{sC6PgU$G*H#mE3NJe%}^Otd(=IjGGa^(v{Uavr81v
zH7kXxI+fDx)G`H5R3m^wm3wnmSX=77oARiWIS|2L1~ZSBIuyEV^E|*9Gjc%YN?>jg
zIOfVlQ2As@u(x`#+FinVx~dD%>>5>5CMtEWsS{yvoB0=ZexaSm?n;7rHp#=_u9sqU
z&x+aY9Lr(O`+#md?rn!bRCVL$4D!f|brvaR24yZbUO5kA%>ORyNgIgLuj0{CG_~O8
zPGC#5SH>&n5xu#WXxi0xb{n+Wq`kWx(Sn*&aS@({6+WhrZhQt7(rH)g^cfeMHeKPI
zKQo|>0cg-XMvWMdI_lqY<54kDnQ-%U<5?Zg&xw*|!&a*cj0Vlg<zCiyWMc?37JFgE
z1MQGGF8dM~Ie{dC7Fcj*U|FW{-MjQz5W#HJzXS+Q#CD!CsmOI*28yaZ)zX5Z$SH4=
zizAJjv$!1QsJ|PBK<19QLiA<?E`k)8^Ge8C8!tGwoAYY)-zLxtUh7=*%h5C0K!MD{
zzNw#kujG?A+yLv=uZOcUGd%<Q_J6(gR_T?D@16eM<r$nokL1i+^oS>{H+*iDggIn%
zK6Bo%uwF@#d41D7ry)u`>o}1v;Q;gF5(6EK3DEW4Kpw7{82eKl^Mt9Lo-=>niv6(v
z9F0TcInj3f;_!2Gy~`?TA#XmMO{2~k0mHZxHJDtTF$z{NCNMFC@o)*q<YZJV)b3-5
zHul4~VGez_c?7sX<I?!0SrImN<rXq4O^6HCT(P+g0U5=e6c8J40>e9sqTYCEzljOR
z^>*JP)B~(+N5<MN`XVuo+kj?a%!-ia=(wn>oZl~U8-3YL*k_N(*CN-(goVh~_@WJ>
zCt`8yW1kZH?*51VQ5d)W>eJ%kd;h8T5)cG6i>%E$9h*h=tat@1poop0Vdo`eFn3`h
zfz=shb66_WT5Fr8qNQ&0CRm$D-O=q#Ovgw3sN|<&5&yb2oN*C9=_?fiHcxHN-gS&i
z4rM^CV~4?B2~A2s+FY8=1`(^$rVvb|j+3`sXy<b!v;t$f5{eT{u7t#h3=vxfm@L8N
zE)7<&B%|)#_(kczD3_ix2|n#Uvq8BH(o46k<tFZQ;E<u2Se9vR3(oQ^Q`>=}BJE<x
zeYUgAbcUX=!=**{Bu1Dw(&c^&<(o+ary)mKP=3yQpadiMv$6afwX^)3-@3f{@R5CW
zF)%MBtH%3g0&h-iVox&@BW!L1l|MI;y31@*co)lTQpi`yY%)NOF<bk+RaD)k%qyQ?
z6fVV~{Kq4-%bzJxF*7;O36rA7z@eVa`ORHG=_VCiln$5@qPiF=%n6n(W&pK&Bi-tz
zsakH)l-YFDrMXx(9rbL!v;Zud&NJ-5oX)`U?1Ce-F5O=O^amR*6)N2%1<Pqjx6LfZ
z&LP}B*>euzb(<O75?JyWJpgEQuuO%zqjPV(wdh9Yt%MWm+I8RxamSM9g6mIkA_u|7
zA#f|Ua`q)y<Rqc$gfdmhSpd^>Xgu`USIz03_JF;{i*Be;BtnQ{Ij4rr-?xr>HGfmx
zfNQ`t;2LlZxQh_nsNW}i1y)<g*>#cqO^Jw~+R3LoF+DwfdgyI?*pH|Yu$ynbc?Uah
zeG@nM&qX$V)9!O62M-=RIxN6Z#JXj~?-Sl~A#`qR#P1Ux8(yp{*x4NAJFIWQ`lh+r
zbEeSC`Fmb?J3a6E4K-KueZm*i&Rr<xn(q^C#LBPc`-Cq^=9=#lUdhZ|S}8Dcz3II5
z`0?ZB=j~Tt{pRsw$9g<r-oAbNc5_IF{r+;kH~ys&zfXASLg?HHj0tv(@O{E3&O0~?
zQb<G?u<+;$644i2(C8}?Wi@Hn23!NK0oQ<Qz%}5y*Z&0=0I^#_V^#$C>i_@%07*qo
IM6N<$f{4Jk(*OVf

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/selectorbutton_image.asset.taml b/Templates/BaseGame/game/data/UI/images/selectorbutton_image.asset.taml
new file mode 100644
index 000000000..f53884267
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/selectorbutton_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="selectorbutton_image"
+    imageFile="@assetFile=selectorbutton.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/selectorbuttonblank.png b/Templates/BaseGame/game/data/UI/images/selectorbuttonblank.png
new file mode 100644
index 0000000000000000000000000000000000000000..e965b3af6f2b9a269f2d363f6118060aaaacfe23
GIT binary patch
literal 744
zcmV<E0vG*>P)<h;3K|Lk000e1NJLTq001Wd006)U1^@s6hvIq<00006VoOIv0RI60
z0RN!9r;`8x010qNS#tmY3ljhU3ljkVnw%H_000McNliru-wGE1BMEP}ychrg0(D75
zK~#9!?VHWD;xG(GCFikV{|ZP2riW>OT4`W<h%2Cg=|QuYfx|%H#LAzNx!DmCd@aTH
z7kyYw#AL6>yUtC~=@hx+zySvwaKHgKA>83`kd%_BYOLNgO(Uv$2b*)@|Eg9YW@7fI
zT~!q^i<8!-Y2<i3E|OA3Y%-Mq2i(82LR2{Q0+LqX{EJBZ$XQf4SM*RNj8@=)0}eRg
zfCCP=`Q9lbi_NMR-JiegMR))BRui+=-_ic_HATm_WmlW2oZ9!h?|{FSf*Jz+44Kvj
z`_z7l0@lY7f1ZmHwdd%uLIAfo+~blIZBSIZhUfEHuGj1Rb0;FF)9K~9=ksmb%H?vI
zH?5CgbKjSY0kKE1S-W&SKm1)OcFOrhkoBGKx{gU0IN(YtG5yvXm<N!w0_Qn$&hh<L
z4`hl8hAKgoYyz%rTUSG#`*d^>N9)S2Rgnw#U*CJ*lmP+UI&jej#f@hhX^j%SM~?LF
zi?zW-dhDh9K8FR%|AW1+Pd7{fT$3IAR&V6+TZaPUw@w9!-|CGXdJee7;UfF3q}2_F
z-|E$KyQ*vs6_t}znHa6W?Ga9$rG&H;m<N!w0_W6a@%>g0WQq!gDq*w&w<$RMR-QTF
zp5X9X$D|d%wE|28zjYYM_QYn*#rUnC;P6`qMiswx)bfSjir571FWj#7x87#*oU@1w
z+uvGBam@&64A{^k=j;-))qZO&*qHn9Tm5kCB=ITlrQvKh0|K};_P1&c*wXu3jc4w^
zg=2r~8qq_QY(<sK3s*|<E@AV-nOSv1-nTFIw|d`=SzCcy1rEP;Oj_|<E5JnXTZe)4
a9lrrbPks?nI<uMp0000<MNUMnLSTY)>Sd1r

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/selectorbuttonblank_image.asset.taml b/Templates/BaseGame/game/data/UI/images/selectorbuttonblank_image.asset.taml
new file mode 100644
index 000000000..c3f212a24
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/selectorbuttonblank_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="selectorbuttonblank_image"
+    imageFile="@assetFile=selectorbuttonblank.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/selectorbuttondark.png b/Templates/BaseGame/game/data/UI/images/selectorbuttondark.png
new file mode 100644
index 0000000000000000000000000000000000000000..84ee7e6f30f4eef5b3d2a1440495b16cf3b21f65
GIT binary patch
literal 1942
zcmV;H2Wj|;P)<h;3K|Lk000e1NJLTq001Wd006)U1^@s6hvIq<00009a7bBm000XU
z000XU0RWnu7ytkO2XskIMF-ys783*<eshr8000LyNkl<Zc-rloy>8q_5Xb+!B=4lN
z?AVBUt4(v4I!KilFko1<Um-{rz^P&&UEo)6Z6k?aAZ2=8lh)}S*s=9-U*x3F?rAif
z<>|=NMX_fAf_Dp%{Bd??cV_-NM*!htZK;>r#7p~|{Ne^@a0X{^24`@3%UfLYq9}?%
zS(YUc0Ym`s8-N8a_S1ei{}Rq+I3HfC<+3chy;v+JM05_f+~+~;ekD7XTeDn%ssL2Z
zxhhz$1mFNv3>Kk}wg#7F*-pRT_mjzF#;)&&Vf6rJ0E*DR3t%4pZfy&?n;dMqHVz?z
z%0~|PmCZY1{V&C}hu7_`jiWAJdb@Kj9jyal-Z`be6=WMY&xbFxN&)I@xi&jQr99BB
zuqbT{&MDVki^uy8^Q+pB_g}k1IPuy2SC&gzlOL4`0Ja8~t?{?>ZNrsozDUt_nDdS=
zR^2qqX$!CKF!Y~xRPs`B-_B8qzrjY>*dlxjz?6MoBzBdp!SRUW6gP41TG`d$49?&T
z&fpC0BMmlxe?v~jK;P`U3Pkl0aC*OU?#jkUhD=1{5-;MEzN{hpqRY3XT5%@@oUed#
z0!n_4-;0Kqzf@GzKF4QD$UFhYAMDvV_Iq{)fSwY7#{P;`0c1s>V%HE6IS!aNfN>BG
zlZn1qcF>B3JqA;SguD_tZ*ABkV6Mz73FR3SKRlajg9O|z11iN4pHm@Ge9RM8O9AEK
zC|F-ia5T69gPDiKCrScRK&hnl@`N{f1t>!G!nt5@x7myF34e=$<v7<UJnFS$?kLN7
zE8*lYN~m6#UwzgG0C&W0Q?dS8fSW3F6^aK}8XVu!I9$Pi`e7dR0qiiiyX>K)z)ixv
zG&m9-U0X`z62XVG$6$8DQ0+2E0Js<aKEjm@dK&I=CYC4?o*cb+IkY+3lAM@td^r0I
zY%iQ|1z-T!7rR8speJH}LV@DTjEhd1E6$)<Z3*_^!GrH#zkdB!e994k(P;FgoExG4
z>-hcP;NbqNSFe6j;G)-N?4`~vr_43aDw2g5(mf8gP7BxV1%QQe@aI<mkW+mT=F3PN
z)(AJ~7zGWO_s-anX<qCb7T=s%ueU+CU9nc?%9iMEey|y~uDIC7`4zqKc32MX0{9%j
z{%AD%;?l$)j~|VO!&+ri>pwa=`V+t#0Dl8`7mg1APQoz>OV0wp!YiA;w$^dy=+gSi
zaAxAU4kAWNMI>@rDLTT%`J0RA#w!7=^NGA7wfXlt!u8m_GU27JDK&J7NLPkTU0SZh
zgf3yZTHfj!U^8?VKQwE(R5s`vGAh@Qb!{RYb*r*Euf_2z&Ksz4ue?8L!%9j3NMeKT
z(n=P6$ds{W0N(&ZN@B9;2)7XT)6zz2D&%O^ijl*tBixMLOS58aDWQbrBwUOpy0ke1
z<Zznh$R{jD0&LEblrC+`?!^H~v*7<CD$&C7L5N)U0DKnmfqSFT=&KG<$sYjThT|Uq
z$Kf~)3DA@ed!ERI<Z#Zy#a*M42r*NJSI)iKUManF&hpM;0~>#Yn=nA>wdy)2(=_e`
zlW^1HgM)+nZK%R^#|(};M=73vY0haWp-iR+YToMHGY~zg<*m*=1<|(wBu2W&;e09}
zXUY;oxpR(}LP^XypC}<j%f>nQCXw;K4G%vH$BCHua?UO18?Q2Puvnhr)gW0yh;y;W
zAhcS^J2q#h3~Z`dYL!FqQfQedxKwP%=rIVb%Jg1TnfMTDo|-IJ^EY-%1R~*zV37!+
z)#u&|=bDKk;zDr-O2Ij;6qQ&5XUqvcBr2OHiOOb~h)(KdSK$;;YP6LC$7{kT3AodS
znsB99jCjdEZwNN4M8K(4(@zs{XNhV$C87~shfu5sVM)&(Aa#goLWh`LL5F~5wVLIW
zHBbJheoDcaH3XL{6`YjJl&6F<0l7;1nm2^yP07=G+E>E`s;DN)tSkH1Q4LLRZEHEx
zTVZ;u>8+->E}>0tHN6!dt=@`@->mZXG_gZG6W<>ua+1yHtsMgm(_6d1eWH3RfFDHk
z7=QGQEA;;e(_7m$(_7m%(_1%@j+)-OPBXo=Z8N>KZTp1vRscVDh)TYL>8;)1uB5l-
zB1@NgYaUF^BZ)3;Exk2Ywh*~|$SnP#$XlNQc%tO3PXVO#*4q4HUc2Nmy%nann%-)9
zD*)45FV9I$!7;tH=>pSRQyKosW_oKAoawEmx0>Es_eRrO6)+wRncix8YXrOFoO?bT
z4qpIQ`+e(pJU%3%#|=4&s<(P&t~Khd9PFxXI2^uk&OHw=w;S%)7hcbwe-5;+-nuRr
z2gHS>xx<zusZFRlgz2qqDx3EER+!$}zM0<Iwwd1ArJ3H^rkUQ_wwd0#)u_aN--<Q$
zR-X_<G`;l<!0C8AK5Ro3uDjmfw-V9gbpcuSWxsDVz18$qnBHo7t1{<IZ%rsTDVfRi
c*0!qQzoi};?Rr-cr~m)}07*qoM6N<$f+^&!)&Kwi

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/selectorbuttondark_image.asset.taml b/Templates/BaseGame/game/data/UI/images/selectorbuttondark_image.asset.taml
new file mode 100644
index 000000000..4a24af201
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/selectorbuttondark_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="selectorbuttondark_image"
+    imageFile="@assetFile=selectorbuttondark.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/selectorbuttonhighlightonly.png b/Templates/BaseGame/game/data/UI/images/selectorbuttonhighlightonly.png
new file mode 100644
index 0000000000000000000000000000000000000000..77e01fc741fbc30a882dd268ebb9c5da313f87a7
GIT binary patch
literal 1613
zcmV-T2D15yP)<h;3K|Lk000e1NJLTq001Wd006)U1^@s6hvIq<00006VoOIv0RI60
z0RN!9r;`8x010qNS#tmY3ljhU3ljkVnw%H_000McNliru-wGEHA_n?3Gq?Z%1=>kO
zK~#9!?V7!A+(r<9XZH4_lO1;{)3^%U9NUyeo*@X}D)2KHd5XZ#5Tr7Y<QWW?ZgpMy
zl<6Err#q69BD>PuaArv!Y5A<o0t-o$$on{dJ3m4K_zfQFvR-bEmky`=;tuC<4(D(V
z=Wq_^aHp}*lTEidhjTcGb2x`{IL}HvD{+T#IEQmMhjTcGb2v{nJ=xS&G(VIGJ7Pwp
z$uBeFxpBbF$i6l+**V<_`0g_$WGH~4*kMK|l+RWL6AR*%qHbpKK*W7X<wS&;<D^1~
zs#eWNKWPL=Jbprq)vlkdQzaMYiu^NrY~yNmI8Qb|w`9|8&fy%+;T+E49L}>6&q^H5
z;T+E49PX6iZoBES&5wxfy&r{Q9uXK#sm*_XnF!+u)-Ue6!_Maqrp+ND<v+?pi~E*X
z$L5Cou?mVf>iU=#?@1?{qg3|xuRBTP*Z=lQ{1u44S0txiA0xR@^H$}BuqR#y;raA2
z=dJu2|9R09<SA_wf-lZnV*v~e>1eak$bLuS`6M;~K-(=jy5S@iz&Ml~3d`Z}vd3)N
z1kf@Gl7Q?0M#H8o7`{2+nNTya>l}=4Qck0;TA9=|FuoUT2L`t?;LaIL!!|OhwOzCS
zPkOQ7krF7Rmx<};$lxvvn_Hz1uM<?w!1!3c)z0&%sMC^E23w}RVE11blDkMi5dik=
zGipO9Ex*5Ha~y8Tz|I(8zW*`1j}*AQ;#gpW8B=na@n?yhrG3u6UoyC$c;Vv&wo5OG
zBGwTL)cN~c6-Ry~2}r5R47N)9oWVU2p+&+)@q1EsD`Rd{0&Wm+66{CC6kZrM^iur%
zlLD8$IWRy3fCFz01$)bCTun?gRwC9l=`$Mf*$n_dBs+uzL#<QRxd<yUedU3@b1-AU
zQy0u3=72k6v69D7l;`<rC!6W$3e3Ki%=j+=;8F6rCux5t({Uiu@_g<3?*Q;2?JEHI
z2LP@CU<&{@$+P!K?QJkpBs5Nm<wRjDjq@3`yfF;ONO)LTOoZdl2~hZ7IxD>{ow0F-
z4uh0h(7+^|CRz=0s^o$aI#5ghLr-O<sd#GRsHn<PoU;m=(PiX_a?~oI4yq&2Dx;6k
z+_9e9VF*1B(GKV-i`NgbA}clzNqGxW4(chZ=_zs!U_(J-tx}xS6X9z1tX7d^vF&Q9
zvSAOND!E#~nJNy3VUkhO?I*(R#q%`D(dW?uV_8Wk)C)N?`2qlbn2?qH0sw!rjAY9)
zl3kK)oh2FyDs6-#?9xM~tPD{r>g}jDDh|QDsAhHN90$LYP;G>kPTksyx|2IWnCWcY
zCb*q&j#euXdAB?m^(wc)ZrzIb5{TY(>Q=-TK=gBhxDocnCCH`7Js2V)%2p_soRvLf
zmFLX(gHiEcv5J3ZsI}2lD!WX?RLj5CN(+IPb{RtJm0U5K-4C$01IXBOd^N`D(Hd|v
zpkFiTXew+<$5&Jy*bc~28rIgz5L$okTItW#!r{y_HWol+zc#Sz3s$LT2u*TZ;}~p9
zA>;s#IRzD(d89Z?U=SMIO;1l)J@`uvYb`70UZ{1`cZLRbMmJr?w6e{KkV1;|f(X_;
zyzC8|t9#}U-AqKAL-YVjN0D)_E+m(lWYjvPIKkn6pg@u$9b`$QRWtNXzz5I1N;fD@
z(-(f)p&)ub=kwO%B<J&1@Oi7xTg99Cyw&HeK5u=X^VUa*_-?&kzXAZb1c0ilo=TOZ
z>(2lHHk-|BB6?n^<kWd<5Jye#yp@9uUF-Gw6(YV%FUL(nn;PCSg|YM2v0xmK+3S)$
zTN|3Fa|oZe9@E(zG;gh{>Z=38-)z3A*6a5jhfuCxUS9qQK5sp4`Mh<C<b2*bS2^nQ
z)*;L1t;a5(w;sFx$Me>zs=l6(mHYt@W!@T$;fOYG-2uSOX0v&H3{|>s)Vwt)Edg!b
znx}qSB6>a+kX2tkZ}oYr&s)Lgtv+v6Y|iJcJ#~uDTMcO!LA3QRjk*e}kFbyE00000
LNkvXXu0mjfl=J=<

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/selectorbuttonhighlightonly_image.asset.taml b/Templates/BaseGame/game/data/UI/images/selectorbuttonhighlightonly_image.asset.taml
new file mode 100644
index 000000000..e359450c4
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/selectorbuttonhighlightonly_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="selectorbuttonhighlightonly_image"
+    imageFile="@assetFile=selectorbuttonhighlightonly.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/separatorh.png b/Templates/BaseGame/game/data/UI/images/separatorh.png
new file mode 100644
index 0000000000000000000000000000000000000000..339c0fbe039e8b5cbdd085230594099c26928157
GIT binary patch
literal 117
zcmeAS@N?(olHy`uVBq!ia0vp^Oh7Ed0V0oZ{G0)#BuiW)N`mv#O3D+9QW+dm@{>{(
zJaZG%Q-e|yQz{EjrrH1%iF>*@hE&{2%E-w0@&CWQFtY@YFPFjrhT;U4EtAg|X#kZl
Nc)I$ztaD0e0sy9+AwB>A

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/separatorh_image.asset.taml b/Templates/BaseGame/game/data/UI/images/separatorh_image.asset.taml
new file mode 100644
index 000000000..213addd3a
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/separatorh_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="separatorh_image"
+    imageFile="@assetFile=separatorh.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/separatorv.png b/Templates/BaseGame/game/data/UI/images/separatorv.png
new file mode 100644
index 0000000000000000000000000000000000000000..6a0f873612cef214add9a2f88ed72dbafe92174c
GIT binary patch
literal 118
zcmeAS@N?(olHy`uVBq!ia0vp^GC<74!2~3aY}VEQQj#UE5hcO-X(i=}MX3yqDfvmM
z3ZA)%>8U}fi7AzZCsS>JiX=Q;978H@CFNvfBrGsX`1Ak2{Z(F84g-d-`&k-}TiGQ5
P)i8Lv`njxgN@xNAx)CBs

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/separatorv_image.asset.taml b/Templates/BaseGame/game/data/UI/images/separatorv_image.asset.taml
new file mode 100644
index 000000000..6a14f9e54
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/separatorv_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="separatorv_image"
+    imageFile="@assetFile=separatorv.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/sliderwbox.png b/Templates/BaseGame/game/data/UI/images/sliderwbox.png
new file mode 100644
index 0000000000000000000000000000000000000000..d9ef04961a30ad99f1e8871ef1f292b8a58d99f0
GIT binary patch
literal 982
zcmV;{11bE8P)<h;3K|Lk000e1NJLTq000>P001Qj1^@s6w^2g10000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU#cu7P-RCwCFR!vM3K@@(oZI`u_7W)HS
z_z46E5)-2a4+bql1U-1bs3#7@MD)a635mu~6G-Gn0+OI7O^h)fNi@NO!AOt<2?u@-
z9*T%*X=%IvU1wGbyW4iRJ=m8_JMZl``|W!(^UWYsCMfWq4Q+02T9P!k*TKfx&%D0b
zIAV74Q(YCX9ALy)joJOZchpx&6vet?Mob}N^dtoU6${^z1Pb{oBc|v~N>Z->n@DC(
z^dn?hhVAVwNE{p-MuM=syre-K`>u)#Xl!f(o6S~Sxwf`8L6&6j`TR#QZC~prlSvid
z+}u(e$w530ZEfwknBO1B>68EU^)=Huvgcc$9*<iWGW8YnHBDtQ(Kffo13Td`IA~gJ
z#4>%OPjCcpe23-4*Ecl4pS?Z!vATK~Iiu<8eTHFFyaGybOBf*v0#((zSZ!Ussc*KV
zOSc(IBP*p4NV1{K&1b;)3K*lE;}RUd_RdRpkQHcQ{vA+^sH8cEioJZbKQB(*d>ETm
zuGaa}MSa=Fv8LiO$#h;y@AHDD?T@o!>D`6mNv2*6_aqXDx41j*a=9k%Ha_7s%C58F
zFXwu=WDCZkai-igF-SdCvFG!V4BWm>!3*e*>_?`8!JubxadCuYS^C-62cdY{%V|mO
zPrfEv*U!cyQ>QNWdN!6mk8mtUKTi&Y8cr}=J`yS#jShsv;o0u)ZhuWp4fOW*GG4ED
z6l>Dt*u#5hb>-U;I2DTx9PIAQwsqd{y8?C4-gT3yI9WaFU@BB>UKK8*>A7oteeO!E
zq@o~z9iMO)Iy!(tXb3;o>AT`6pKHBx%T2qhfX53+u`y74whPk8o`uzwE162EM<|a8
zw7SIcYMIM%i)G?$iUZ2&2bNcK>ca7I7FI{%a5zA~1PCEZ@l)(h;K<%ZdJU70*H7+D
zBuN4uf3=Z>TqcahOA4g;Y!Y6wSi+(x<|H9;qX{^~k}4v-QVOC4iG*J!<RFm_Nj|)p
z){rRw=EIPQASxD_kaFdi6B5tLM1tHTR^^iM%c7A8;9Y)Pdz_h^gG9u05|2fJc2*u=
z1O--&o0Fu|gWp$HX0#GRz7I=G$Ox8XW$@SPCyYfpteA|3OwSWi8eA$Txk?$Plvo@;
zPh{kqNPVH$To;KHQH??rm0%x*W>WFkKE!Y<#Qq8}0K%2(y+C}?TL1t607*qoM6N<$
Eg3Ob{L;wH)

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/sliderwbox_image.asset.taml b/Templates/BaseGame/game/data/UI/images/sliderwbox_image.asset.taml
new file mode 100644
index 000000000..14abf8088
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/sliderwbox_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="sliderwbox_image"
+    imageFile="@assetFile=sliderwbox.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/tabborder.png b/Templates/BaseGame/game/data/UI/images/tabborder.png
new file mode 100644
index 0000000000000000000000000000000000000000..6703924d48fb96552fe11a91696f7c282aea3439
GIT binary patch
literal 1203
zcmV;k1WfyhP)<h;3K|Lk000e1NJLTq001fg001fo1^@s6#ly*40000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU$RY^oaRCwC#Sv_bJK@^@lu1FNL5y2vf
z2ud(1Qdy{IVekjRq_Py0JJX0pu!@kF6sdxu*u*=u6{|!sYKVp64_XN(5){NFU{qqQ
z-MZf--{sxg*}dJ(;t%-9GB<Pk=6&<#&3oTXa-K2%-`_8VQn5Jbw*yI(%9V=o^^)2e
z^z{Z(=vjNYVzKCz%jFyfmKLVX$LSY=7q_+VHk+E-R|j%A&v;&LpnFGkXlVRHK(D`R
z`!d3@_oh@Tc`yh)exJl%fuCPLxMABZEv=?$=f3JY3-6xV$?)7C9kE8G0N}BMd(8Yy
zC7^fae4puVZE$+2p1pe`z2?*0eAQl_E1P+E#{yZLo2{8}YIMksV?qeM$QB?k_MR}6
zzTlQ(yzTIDJHHh6cO5w$um{kvH8%UR#*PJw6?FFWo2@O)78F-|>s+T@)zO{{b^^V<
z=wH7wY(L{2P71F802ipY7kw@qE$vBN%q#5`<VsFnowDFy03IettUOGhhX)4mt^~<#
z(_W*VY$ZsSy}TX(SV$a@F2fpRQr$3n0if_G1zwfg5+(2kMTS8VT^$BBc~riPgCjj@
zjrm|XNth9CEj`IFfPQhf5~|0Lfj&cs8A032GjC~-%zqezXOU`{7iFHrxCALrF6IIV
z%&+q##$7Q<U2V?-MRGlL?Xh|DV{>37@CZ`H-O1-w@Umr|4D%f4*L^Nt+hhLK_6p2Z
z%jmzE=C=LL3e%yyDGwhjj6U6g3bP`N-;PET+g?oxjXD4|r+B4=CaKr15}L$b?q6b0
zh8~SA%A;{SQ}t+Cpt=UfVlxhaEO#3>tT*c#8_eR@?>5%(PLkvwCV9zbSc8!+a4ONV
zR-+KOJO_Zt7V|Std?$P6?aK-C`OA{+V;uY;3(0FXgFHquf);&@Yc?a<)A*xjHOZUF
z9OEwblp3gHGX%+c&yuRyjAl==LJ=%0nk$@AZ@u)S6zSP8LLos?q-QfZ^*VWDa!G<w
z1~ut$fkg?%Hd9biA&5~qzGjbV$|Z%d8zrQNIyJe**90`mV^QCy)k_7GY$i(Tv8OO`
zv8U8P$!59^?X@1jmLWFra6F1VAqPVbA%fV%gV-bqb`^_Mhbax431d$@d{GrGHBfqI
zmG0GHGinTAvH}!JFaEQqjCt%IWlu@$WzL=^Z(okZp0qvLy6k1jo|ul%MzJStPqQv*
zFH`me1N!1X-quCkJ%zEZ$h#*^Oe7(RVo&ns4;~~TLHJ<4dUsFU4gLE*ls&m#N^<uE
zQ1oOLKR@c;Ju&{^8T8{23jicY>;yi`d#otZB4azuR)9UhD?F)aac|0iuXn*Eh1*_F
zk5@SQ_F3yW*%QGMWE}P+4H9G+d(!r(D?=_|4>u*qe>cw_Sh<T|&WEzaIDugdWfv{_
z(0es8T74gV>R}v@)e(9wdwjG#i_h1~oIT;xGv>0sd%E<S{?D|g|4;oAU;sZF1oiaL
Ru7dyo002ovPDHLkV1gC9ElvOc

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/tabborder_image.asset.taml b/Templates/BaseGame/game/data/UI/images/tabborder_image.asset.taml
new file mode 100644
index 000000000..0e3102520
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/images/tabborder_image.asset.taml
@@ -0,0 +1,3 @@
+<ImageAsset
+    AssetName="tabborder_image"
+    imageFile="@assetFile=tabborder.png"/>
diff --git a/Templates/BaseGame/game/data/UI/scripts/menuInputHandling.tscript b/Templates/BaseGame/game/data/UI/scripts/menuInputHandling.tscript
new file mode 100644
index 000000000..074bb3675
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/scripts/menuInputHandling.tscript
@@ -0,0 +1,510 @@
+//==============================================================================
+// Menu Input Buttons
+// This file manages the Menu Input Buttons stuff
+// Any time you have a GUI button that should be clickable AND map to a key input
+// such as a gamepad button, or enter, etc, this stuff can be used
+//==============================================================================
+/*
+Gamepad input reference for 360 controller
+btn_a = A
+btn_b = B
+btn_x = X
+btn_y = Y
+btn_r = Right Bumper
+btn_l = Right Bumper
+upov = Dpad Up
+dpov = Dpad Down
+lpov = Dpad Left
+rpov = Dpad Right
+xaxis = Left Stick | + values = up, - values = down
+yaxis = Left Stick | + values = up, - values = down
+rxaxis = Right Stick | + values = up, - values = down
+ryaxis = Right Stick | + values = up, - values = down
+zaxis = Left Trigger
+rzaxis = Right Trigger
+btn_start = Start
+btn_back = Back/Select
+*/
+
+/// This is used with the main UI menu lists, when a non-axis input event is called
+/// such as pressing a button
+/// It is called from the engine
+function UIMenuButtonList::onInputEvent(%this, %device, %action, %state)
+{
+   if(%state)
+      $activeMenuButtonContainer.processInputs(%device, %action);
+}
+
+/// This is used with the main UI menu lists, when an axis input event is called
+/// such as moving a joystick
+/// It is called from the engine
+function UIMenuButtonList::onAxisEvent(%this, %device, %action, %axisVal)
+{
+   //Skip out of the value is too low as it could just be noise or miscalibrated defaults
+   if(%axisVal < 0.02)
+      return;
+      
+   $activeMenuButtonContainer.processAxisEvent(%device, %action);
+}
+
+/// Sets the command and text for the specified button. If %text and %command
+/// are left empty, the button will be disabled and hidden.
+///
+/// \param %gamepadButton (string) The button to set for when using gamepad input. See the input map reference comment at the top of the file
+/// \param %keyboardButton (string) The button to set for when using keyboard/mouse input.
+/// \param %text (string) The text to display next to the A button graphic.
+/// \param %command (string) The command executed when the A button is pressed.
+/// \param %gamepadOnly (bool) If true, will only show the button when working in the gamepad input mode
+function MenuInputButton::set(%this, %gamepadButton, %keyboardButton, %text, %command, %gamepadOnly)
+{
+   %set = (! ((%text $= "") && (%command $= "")));
+   %this.setText(%text);
+   %this.setActive(%set);
+   %this.setVisible(%set);
+   
+   %this.gamepadButton = %gamepadButton;
+   %this.keyboardButton = %keyboardButton;
+   
+   if(%gamepadOnly $= "")
+      %gamepadOnly = false;
+      
+   %this.gamepadOnly = %gamepadOnly;
+
+   %this.Command = %command;
+}
+
+/// Refreshes the specific button, updating it's visbility status and the displayed input image
+function MenuInputButton::refresh(%this)
+{
+   %set = (! ((%this.text $= "") && (%this.command $= "")));
+   
+   //Special-case of where we're in keyboard+mouse mode, but the menubutton is gamepad only mode, so we early out
+   if(%this.gamepadOnly && $activeControllerType !$= "gamepad")
+      %set = false;
+      
+   %this.setActive(%set);
+   %this.setVisible(%set);
+   
+   if(!%this.isActive())
+      return;
+   
+   if($activeControllerType $= "gamepad")
+   {
+      if(%this.gamepadButton !$= "")
+      {
+         %assetId = "";
+         if($activeControllerName $= "PS4 Controller")
+         { 
+            %assetId = "UI:PS4_";
+            
+            if(%this.gamepadButton $= "btn_a")
+               %assetId = %assetId @ "Cross";
+            else if(%this.gamepadButton $= "btn_b")
+               %assetId = %assetId @ "Circle";
+            else if(%this.gamepadButton $= "btn_x")
+               %assetId = %assetId @ "Square";
+            else if(%this.gamepadButton $= "btn_y")
+               %assetId = %assetId @ "Triangle";
+            else if(%this.gamepadButton $= "btn_l")
+               %assetId = %assetId @ "L1";
+            else if(%this.gamepadButton $= "zaxis")
+               %assetId = %assetId @ "L2";
+            else if(%this.gamepadButton $= "btn_r")
+               %assetId = %assetId @ "R1";
+            else if(%this.gamepadButton $= "rzaxis")
+               %assetId = %assetId @ "R2";
+            else if(%this.gamepadButton $= "btn_start")
+               %assetId = %assetId @ "Options";
+            else if(%this.gamepadButton $= "btn_back")
+               %assetId = %assetId @ "Share";
+         }
+         else if($activeControllerName $= "Nintendo Switch Pro Controller")
+         {
+            %assetId = "UI:Switch_";
+            
+            if(%this.gamepadButton $= "btn_a")
+               %assetId = %assetId @ "B";
+            else if(%this.gamepadButton $= "btn_b")
+               %assetId = %assetId @ "A";
+            else if(%this.gamepadButton $= "btn_x")
+               %assetId = %assetId @ "Y";
+            else if(%this.gamepadButton $= "btn_y")
+               %assetId = %assetId @ "X";
+            else if(%this.gamepadButton $= "btn_l")
+               %assetId = %assetId @ "LB";
+            else if(%this.gamepadButton $= "zaxis")
+               %assetId = %assetId @ "LT";
+            else if(%this.gamepadButton $= "btn_r")
+               %assetId = %assetId @ "RB";
+            else if(%this.gamepadButton $= "rzaxis")
+               %assetId = %assetId @ "RT";
+            else if(%this.gamepadButton $= "btn_start")
+               %assetId = %assetId @ "Plus";
+            else if(%this.gamepadButton $= "btn_back")
+               %assetId = %assetId @ "Minus";
+         }
+         else if($activeControllerName !$= "")
+         {
+            %assetId = "UI:Xbox_";
+            
+            if(%this.gamepadButton $= "btn_a")
+               %assetId = %assetId @ "A";
+            else if(%this.gamepadButton $= "btn_b")
+               %assetId = %assetId @ "B";
+            else if(%this.gamepadButton $= "btn_x")
+               %assetId = %assetId @ "X";
+            else if(%this.gamepadButton $= "btn_y")
+               %assetId = %assetId @ "Y";
+            else if(%this.gamepadButton $= "btn_l")
+               %assetId = %assetId @ "LB";
+            else if(%this.gamepadButton $= "zaxis")
+               %assetId = %assetId @ "LT";
+            else if(%this.gamepadButton $= "btn_r")
+               %assetId = %assetId @ "RB";
+            else if(%this.gamepadButton $= "rzaxis")
+               %assetId = %assetId @ "RT";
+            else if(%this.gamepadButton $= "btn_start")
+               %assetId = %assetId @ "Menu";
+            else if(%this.gamepadButton $= "btn_back")
+               %assetId = %assetId @ "Windows";
+         }
+      } 
+   }
+   else
+   {
+      if(%this.keyboardButton !$= "")
+      {
+         %assetId = "UI:Keyboard_Black_" @ %this.keyboardButton;
+      }
+   }
+   
+   %this.setBitmap(%assetId @ "_image");
+
+   return true;
+}
+
+/// Refreshes a menu input container, updating the buttons inside it
+function MenuInputButtonContainer::refresh(%this)
+{
+   %count = %this.getCount();
+   for(%i=0; %i < %count; %i++)
+   {
+      %btn = %this.getObject(%i);
+      
+      %btn.refresh();
+   }
+}
+
+/// Sets the given MenuInputButtonContainer as the active one. This directs input events
+/// to it's buttons, ensures it's visible, and auto-hides the old active container if it was set
+function MenuInputButtonContainer::setActive(%this)
+{
+   if(isObject($activeMenuButtonContainer))
+      $activeMenuButtonContainer.hidden = true;
+      
+   $activeMenuButtonContainer = %this;
+   $activeMenuButtonContainer.hidden = false;
+   $activeMenuButtonContainer.refresh();
+}
+
+/// Checks the input manager for if we have a gamepad active and gets it's name
+/// If we have one, also sets the active input type to gamepad
+function MenuInputButtonContainer::checkGamepad(%this)
+{
+   %controllerName = SDLInputManager::JoystickNameForIndex(0);
+   
+   $activeControllerName = %controllerName;
+   
+   if($activeControllerName $= "")
+      $activeControllerType = "K&M";
+   else
+      $activeControllerType = "gamepad";     
+}
+   
+/// This is called by the earlier inputs callback that comes from the menu list
+/// this allows us to first check what the input type is, and if the device is different
+/// (such as going from keyboard and mouse to gamepad) we can refresh the buttons to update
+/// the display
+/// Then we process the input to see if it matches to any of the button maps for our 
+/// MenuInputButtons. If we have a match, we execute it's command.
+function MenuInputButtonContainer::processInputs(%this, %device, %action)
+{
+   //check to see if our status has changed
+   %changed = false;
+   
+   %oldDevice = $activeControllerName;
+   
+   %deviceName = stripTrailingNumber(%device);
+   
+   if(%deviceName $= "keyboard" || %deviceName $= "mouse")
+   {
+      if($activeControllerName !$= "K&M")
+         %changed = true;
+         
+      $activeControllerName = "K&M";
+      $activeControllerType = "K&M";
+      Canvas.showCursor();
+   }
+   else
+   {
+      if(%this.checkGamepad())
+      {
+         Canvas.hideCursor();
+      }
+      
+      if($activeControllerType !$= %oldDevice)
+         %changed = true;
+   }
+   
+   if(%changed)
+      %this.refresh();
+      
+   //Now process the input for the button accelerator, if applicable
+   //Set up our basic buttons
+   for(%i=0; %i < %this.getCount(); %i++)
+   {
+      %btn = %this.getObject(%i);
+      
+      if(!%btn.isActive())
+         continue;
+      
+      if($activeControllerType !$= "K&M")
+      {
+         if(%btn.gamepadButton $= %action)
+         {
+            eval(%btn.command);
+         }
+      }
+      else
+      {
+         if(%btn.keyboardButton $= %action)
+         {
+            eval(%btn.command);
+         }
+      }
+   }
+}
+
+/// This is called by the earlier inputs callback that comes from the menu list
+/// this allows us to first check what the input type is, and if the device is different
+/// (such as going from keyboard and mouse to gamepad) we can refresh the buttons to update
+/// the display
+function MenuInputButtonContainer::processAxisEvent(%this, %device, %action, %axisVal)
+{
+   //check to see if our status has changed
+   %changed = false;
+   
+   %oldDevice = $activeControllerName;
+   
+   %deviceName = stripTrailingNumber(%device);
+   
+   if(%deviceName $= "mouse")
+   {
+      if($activeControllerName !$= "K&M")
+         %changed = true;
+         
+      $activeControllerName = "K&M";
+      $activeControllerType = "K&M";
+      Canvas.showCursor();
+   }
+   else
+   {
+      if(%this.checkGamepad())
+      {
+         Canvas.hideCursor();
+      }
+      
+      if($activeControllerType !$= %oldDevice)
+         %changed = true;
+   }
+   
+   if(%changed)
+      %this.refresh();
+}
+
+//
+//
+function onSDLDeviceConnected(%sdlIndex, %deviceName, %deviceType)
+{
+   /*if(GamepadButtonsGui.checkGamepad())
+   {
+      GamepadButtonsGui.hidden = false;  
+   }*/
+}
+
+function onSDLDeviceDisconnected(%sdlIndex)
+{
+   /*if(!GamepadButtonsGui.checkGamepad())
+   {
+      GamepadButtonsGui.hidden = true;
+   }*/   
+}
+
+//==============================================================================
+// Menu Input processing
+// These functions manage the Menu input processing in general
+// Whenever a MenuInputHandler consumes an input event, it'll process them here
+// This'll let the active menu list be navigated, as well as buttons be processed
+// and ultimately handled by the Input Buttons above
+//==============================================================================
+function MenuInputHandler::onAxisEvent(%this, %device, %action, %value)
+{
+   //this is to force a refresh of the menu
+   if(%value == 1 || %value == -1)
+      $activeMenuButtonContainer.processInputs(%device, %action);
+      
+   if(startsWith(%device, "mouse"))
+      return;   
+   
+   if((%action $= "upov" && %value > 0) || (%action $= "yaxis" && %value == -1))
+   {
+      $activeMenuList.navigateUp();
+   }
+   
+   if((%action $= "dpov" && %value > 0) || (%action $= "yaxis" && %value == 1))
+   {
+      $activeMenuList.navigateDown();
+   }
+   
+   //How we deal with the left and right navigation is dependant on the mode of the
+   //menu list
+   if($activeMenuListMode $= "Settings")
+   {
+      if((%action $= "lpov" && %value > 0) || (%action $= "xaxis" && %value == -1))
+      {
+         echo("Options menu nudged left!");
+         //$activeMenuList.navigateLeft();
+      }
+      
+      if((%action $= "rpov" && %value > 0) || (%action $= "xaxis" && %value == -1))
+      {
+         echo("Options menu nudged right!");
+         //$activeMenuList.navigateRight();
+      }
+   }
+   else
+   {
+      if((%action $= "lpov" && %value > 0) || (%action $= "xaxis" && %value == -1))
+      {
+         $activeMenuList.navigateLeft();
+      }
+      
+      if((%action $= "rpov" && %value > 0) || (%action $= "xaxis" && %value == -1))
+      {
+         $activeMenuList.navigateRight();
+      }
+   } 
+}
+
+function MenuInputHandler::onInputEvent(%this, %device, %action, %state)
+{
+   if(%action $= "upov" || %action $= "dpov" || %action $= "lpov" || %action $= "rpov")
+   {
+      %this.onAxisEvent(%device, %action, %state);
+      return;      
+   }
+   
+   if(%state)
+      $activeMenuButtonContainer.processInputs(%device, %action);
+}
+
+//==============================================================================
+// Menu List processing
+// These functions manage the navigation and activation of the Menu Lists
+//==============================================================================
+
+function MenuList::setAsActiveMenuList(%this, %startPosition, %menuMode)
+{
+   if(%startPosition $= "")
+      %startPosition = "0 0";
+      
+   if(%menuMode $= "")
+      %menuMode = "Menu";
+         
+   $activeMenuList = %this;
+   $activeMenuList.hidden = false; 
+   $activeMenuListPosition = %startPosition;
+   $activeMenuListMode = %menuMode;
+   
+   %this.refresh();
+}
+
+
+function MenuList::activate(%this)
+{
+   //check for a highlighted element
+   if($activeMenuListPosition.y > -1 && $activeMenuListPosition < $activeMenuList.getCount())
+   {
+      %btn = $activeMenuList.getObject($activeMenuListPosition.y);
+      %btn.performClick();
+   }
+}
+
+function MenuList::refresh(%this)
+{
+   %selectedObject = 0;
+   for(%i=0; %i < $activeMenuList.getCount(); %i++)
+   {
+      %btn = $activeMenuList.getObject(%i);
+      
+      %isSelected = %i == $activeMenuListPosition.y;
+      
+      %btn.setHighlighted(%isSelected);
+      
+      if(%isSelected)
+         %selectedObject = %i;
+   }
+   
+   if($activeMenuList.isMethod("onNavigate"))
+      $activeMenuList.onNavigate($activeMenuListPosition.y);
+   
+   %parent = $activeMenuList.getParent();
+   if(%parent.getClassName() $= "GuiScrollCtrl")
+   {
+      %parent.scrollToObject(%selectedObject);
+   }
+}
+
+function MenuList::navigateUp(%this)
+{
+   $activeMenuListPosition.y -= 1;
+   if($activeMenuListPosition.y < 0)
+      $activeMenuListPosition.y = 0;
+      
+   %this.refresh();
+}
+
+function MenuList::navigateDown(%this)
+{
+   $activeMenuListPosition.y += 1;
+   if($activeMenuListPosition.y >= $activeMenuList.getCount())
+      $activeMenuListPosition.y = $activeMenuList.getCount()-1;
+      
+   %this.refresh();
+}
+
+function MenuList::navigateLeft()
+{
+   echo("Menu list navigated left!"); 
+   
+   //Atm, we're only handling specific control types, namely options entries, but
+   //this could readily be expanded upon to handle grids like for inventory screens
+   //or the like
+    
+   %btn = $activeMenuList.getObject($activeMenuListPosition.y);
+   if(%btn.getClassName() $= "GuiGameSettingsCtrl" && %btn.isEnabled())
+   {
+      warnf("MenuList::navigateLeft() - actioned the option" @ %btn @ " to the left");
+   }
+}
+
+function MenuList::navigateRight()
+{
+   echo("Menu list navigated right!");  
+   
+   %btn = $activeMenuList.getObject($activeMenuListPosition.y);
+   if(%btn.getClassName() $= "GuiGameSettingsCtrl" && %btn.isEnabled())
+   {
+      warnf("MenuList::navigateLeft() - actioned the option" @ %btn @ " to the left");
+   }
+}

From 725e2b1575ffafc04cdc57df8ed30bb454663eb1 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Tue, 22 Feb 2022 23:39:52 -0600
Subject: [PATCH 317/399] Typo'd assetId correction

---
 Templates/BaseGame/game/data/UI/guis/loadingGui.gui | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Templates/BaseGame/game/data/UI/guis/loadingGui.gui b/Templates/BaseGame/game/data/UI/guis/loadingGui.gui
index 83357901c..f232a2af9 100644
--- a/Templates/BaseGame/game/data/UI/guis/loadingGui.gui
+++ b/Templates/BaseGame/game/data/UI/guis/loadingGui.gui
@@ -1,6 +1,6 @@
 //--- OBJECT WRITE BEGIN ---
 $guiContent = new GuiChunkedBitmapCtrl(LoadingGui) {
-   bitmapAsset = "UI:background_dark_image";
+   bitmapAsset = "UI:backgrounddark_image";
    useVariable = "0";
    tile = "0";
    position = "0 0";

From 9b4acda7bd942e9b2e8e4cc7173e5c20aad32ce8 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Wed, 23 Feb 2022 00:29:00 -0600
Subject: [PATCH 318/399] Missed clearing the options categories in options
 menu onWake

---
 Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript b/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
index 48612b943..23a09236e 100644
--- a/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
+++ b/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
@@ -76,6 +76,8 @@ function OptionsMenuSettingsList::getOptionsList(%this, %index)
 
 function OptionsMenu::onWake(%this)
 {
+   OptionsMenuCategoryList.clear(); 
+   
    for(%i=0; %i < %this.optionsCategories.count(); %i++)
    {
       %catName = %this.optionsCategories.getKey(%i);

From 8d8432115b105deff608c809e56ac9f979e57f43 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Thu, 24 Feb 2022 00:48:00 -0600
Subject: [PATCH 319/399] Adjusts formatting when parsing for object and
 function definitions in the project importer to be more accurate Adds
 handling for progrommatic new object delcarations where the class type is
 defined via () encapsulated code so the project import doesn't mangle it.

---
 .../scripts/projectImporter.tscript              | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
index c149cf3f2..f7b86be34 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
@@ -476,7 +476,7 @@ function preprocessImportingFiles()
          {
             %line = $ProjectImporter::fileObject.readLine();
             
-            if(strIsMatchExpr("* new*(*)*", %line))
+            if(strIsMatchExpr("*new *(*)*", %line))
             {
                %start = strpos(%line, "new ");
                %end = strpos(%line, "(", %start);
@@ -486,6 +486,14 @@ function preprocessImportingFiles()
                   %className = getSubStr(%line, %start + 4, %end-%start-4);
                }
                
+               if(%className $= "")
+               {
+                  //we clearly have some unusual formatting, potentially a progromattic 
+                  //object block creation going on here. so we'll just skip it and move on  
+                  %currentFileSectionObject.add(%line);
+                  continue;
+               }
+               
                %nameEnd = strpos(%line, ")", %end);
                
                %objectName = getSubStr(%line, %end+1, %nameEnd-%end-1);
@@ -530,7 +538,7 @@ function preprocessImportingFiles()
                      %insideObjectBlock = true;
                }
             }
-            else if(strIsMatchExpr("* datablock*(*)*", %line))
+            else if(strIsMatchExpr("*datablock *(*)*", %line))
             {
                %start = strpos(%line, "datablock ");
                %end = strpos(%line, "(", %start);
@@ -584,7 +592,7 @@ function preprocessImportingFiles()
                      %insideObjectBlock = true;
                }
             }
-            else if(strIsMatchExpr("* singleton*(*)*", %line))
+            else if(strIsMatchExpr("*singleton *(*)*", %line))
             {
                %start = strpos(%line, "singleton ");
                %end = strpos(%line, "(", %start);
@@ -638,7 +646,7 @@ function preprocessImportingFiles()
                      %insideObjectBlock = true;
                }
             }
-            else if(strIsMatchExpr("*function*(*)*", %line))
+            else if(strIsMatchExpr("*function *(*)*", %line))
             {
                %start = strpos(%line, "function ");
                %end = strpos(%line, "(", %start);

From 7659b51ac93a04fb1c8f16b3eb94fa23a98c2822 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Thu, 24 Feb 2022 01:33:14 -0600
Subject: [PATCH 320/399] Added trimming of parsed object names to ensure
 whitespace before and after isn't accidentally processed as invalid
 characters Also made the classname validity check happen on the other
 creation keyword types Added logic so when processing an importing material
 definition that already has an asset, can handle it if the scriptPath doesn't
 have the extension in it already.

---
 .../pre40/T3Dpre4ProjectImporter.tscript      |  6 +++++
 .../scripts/projectImporter.tscript           | 24 ++++++++++++++++++-
 2 files changed, 29 insertions(+), 1 deletion(-)

diff --git a/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript
index c6ac5c2b2..abbe166e0 100644
--- a/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript
@@ -1038,6 +1038,12 @@ function T3Dpre4ProjectImporter::processMaterialObject(%this, %fileObject, %obje
       
       %assetScriptPath = %assetDef.getScriptPath();
       
+      if(fileExt(%assetScriptPath) $= "")
+      {
+         //try the default extension
+         %assetScriptPath = %assetScriptPath @ "." @ $TorqueScriptFileExtension;  
+      }
+      
       if(isFile(%assetScriptPath) && isObject(%objectName))
       {
          //Regular material in a companion file, so we'll want to write it to the
diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
index f7b86be34..13797d2a2 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
@@ -488,7 +488,7 @@ function preprocessImportingFiles()
                
                if(%className $= "")
                {
-                  //we clearly have some unusual formatting, potentially a progromattic 
+                  //we clearly have some unusual formatting, potentially a programmatic 
                   //object block creation going on here. so we'll just skip it and move on  
                   %currentFileSectionObject.add(%line);
                   continue;
@@ -506,6 +506,8 @@ function preprocessImportingFiles()
                   %objectName = getSubStr(%objectName, 0, %inheritanceSplit);
                }
                
+               %objectName = trim(%objectName);
+               
                %parentFileSectionObject = %currentFileSectionObject;
                
                %currentFileSectionObject = new ArrayObject();
@@ -548,6 +550,14 @@ function preprocessImportingFiles()
                   %className = getSubStr(%line, %start + 10, %end-%start-10);
                }
                
+               if(%className $= "")
+               {
+                  //we clearly have some unusual formatting, potentially a programmatic 
+                  //object block creation going on here. so we'll just skip it and move on  
+                  %currentFileSectionObject.add(%line);
+                  continue;
+               }
+               
                %nameEnd = strpos(%line, ")", %end);
                
                %objectName = getSubStr(%line, %end+1, %nameEnd-%end-1);
@@ -560,6 +570,8 @@ function preprocessImportingFiles()
                   %objectName = getSubStr(%objectName, 0, %inheritanceSplit);
                }
                
+               %objectName = trim(%objectName);
+               
                %parentFileSectionObject = %currentFileSectionObject;
                
                %currentFileSectionObject = new ArrayObject();
@@ -602,6 +614,14 @@ function preprocessImportingFiles()
                   %className = getSubStr(%line, %start + 10, %end-%start-10);
                }
                
+               if(%className $= "")
+               {
+                  //we clearly have some unusual formatting, potentially a programmatic 
+                  //object block creation going on here. so we'll just skip it and move on  
+                  %currentFileSectionObject.add(%line);
+                  continue;
+               }
+               
                %nameEnd = strpos(%line, ")", %end);
                
                %objectName = getSubStr(%line, %end+1, %nameEnd-%end-1);
@@ -614,6 +634,8 @@ function preprocessImportingFiles()
                   %objectName = getSubStr(%objectName, 0, %inheritanceSplit);
                }
 
+               %objectName = trim(%objectName);
+
                %parentFileSectionObject = %currentFileSectionObject;
                
                %currentFileSectionObject = new ArrayObject();

From b8b94fdec90863c8c58148fee3095f2d42eddd00 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Fri, 25 Feb 2022 00:03:33 -0600
Subject: [PATCH 321/399] Standardizes project import copy behavior to validate
 if we're in-place importing to avoid erroring out needlessly with a new
 utility function Fixed wrong variable preventing ImportConfig Editor from
 refreshing when selecting different configs Standardized
 DefaultImportConfig's settings against Legacy Import setting, specifically
 collision resolution behavior and appending _mat suffix to materials

---
 .../tools/assetBrowser/assetImportConfigs.xml | 648 ++++++++++++------
 .../assetBrowser/scripts/assetBrowser.tscript |   4 +-
 .../scripts/assetImportConfigEditor.tscript   |   6 +-
 .../importers/pre40/pre40ImporterGuis.tscript |   7 +-
 .../scripts/projectImporter.tscript           |  57 +-
 5 files changed, 467 insertions(+), 255 deletions(-)

diff --git a/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml b/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml
index 3cfa5da83..5c91b3d2a 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml
+++ b/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml
@@ -1,243 +1,459 @@
 <?xml version="1.0" encoding="UTF-8" standalone ="yes"?>
 <AssetImportSettings>
-    <Group name="DefaultImportConfig">
-        <Group name="Animations">
-            <Setting name="animFPS">2</Setting>
-            <Setting name="animTiming">Seconds</Setting>
-            <Setting name="ImportAnimations">1</Setting>
-            <Setting name="SeparateAnimations">1</Setting>
+    <Group
+        name="DefaultImportConfig">
+        <Group
+            name="Animations">
+            <Setting
+                name="animFPS">2</Setting>
+            <Setting
+                name="animTiming">Seconds</Setting>
+            <Setting
+                name="ImportAnimations">1</Setting>
+            <Setting
+                name="SeparateAnimations">1</Setting>
         </Group>
-        <Group name="Collision">
-            <Setting name="CollisionMeshPrefix">Col</Setting>
-            <Setting name="GenCollisionType">CollisionMesh</Setting>
-            <Setting name="GenerateCollisions">1</Setting>
-            <Setting name="GenerateLOSCollisions">1</Setting>
-            <Setting name="GenLOSCollisionType">CollisionMesh</Setting>
-            <Setting name="LOSCollisionMeshPrefix">LOS</Setting>
+        <Group
+            name="Collision">
+            <Setting
+                name="CollisionMeshPrefix">Col</Setting>
+            <Setting
+                name="GenCollisionType">CollisionMesh</Setting>
+            <Setting
+                name="GenerateCollisions">1</Setting>
+            <Setting
+                name="GenerateLOSCollisions">1</Setting>
+            <Setting
+                name="GenLOSCollisionType">CollisionMesh</Setting>
+            <Setting
+                name="LOSCollisionMeshPrefix">LOS</Setting>
         </Group>
-        <Group name="General">
-            <Setting name="AddDirectoryPrefixToAssetName">0</Setting>
-            <Setting name="AutomaticallyPromptMissingFiles">0</Setting>
-            <Setting name="DuplicatAutoResolution">AutoPrune</Setting>
-            <Setting name="DuplicateAutoResolution">AutoPrune</Setting>
-            <Setting name="PreventImportWithErrors">1</Setting>
-            <Setting name="WarningsAsErrors">0</Setting>
+        <Group
+            name="General">
+            <Setting
+                name="AddDirectoryPrefixToAssetName">0</Setting>
+            <Setting
+                name="AutomaticallyPromptMissingFiles">0</Setting>
+            <Setting
+                name="DuplicatAutoResolution">AutoPrune</Setting>
+            <Setting
+                name="DuplicateAutoResolution">FolderPrefix</Setting>
+            <Setting
+                name="PreventImportWithErrors">1</Setting>
+            <Setting
+                name="WarningsAsErrors">0</Setting>
         </Group>
-        <Group name="Images">
-            <Setting name="AddedImageSuffix">_image</Setting>
-            <Setting name="AlwaysAddImageSuffix">1</Setting>
-            <Setting name="AOTypeSuffixes">_AO,_AMBIENT,_AMBIENTOCCLUSION</Setting>
-            <Setting name="CompositeTypeSuffixes">_COMP,_COMPOSITE,_PBR,-COMP,-COMPOSITE,-PBR,_ORM,-ORM,_C</Setting>
-            <Setting name="Compressed">1</Setting>
-            <Setting name="DiffuseTypeSuffixes">_ALBEDO,_DIFFUSE,_ALB,_DIF,_COLOR,_COL</Setting>
-            <Setting name="GenerateMaterialOnImport">0</Setting>
-            <Setting name="ImageType">N/A</Setting>
-            <Setting name="ImportImages">1</Setting>
-            <Setting name="IsHDR">0</Setting>
-            <Setting name="MetalnessTypeSuffixes">_METAL,_MET,_METALNESS,_METALLIC,_M</Setting>
-            <Setting name="NormalTypeSuffixes">_NORMAL,_NORM,_N</Setting>
-            <Setting name="RoughnessTypeSuffixes">_ROUGH,_ROUGHNESS,_R</Setting>
-            <Setting name="Scaling">1.0</Setting>
-            <Setting name="SmoothnessTypeSuffixes">_SMOOTH,_SMOOTHNESS,_S</Setting>
-            <Setting name="TextureFilteringMode">Bilinear</Setting>
-            <Setting name="UseMips">1</Setting>
+        <Group
+            name="Images">
+            <Setting
+                name="AddedImageSuffix">_image</Setting>
+            <Setting
+                name="AlwaysAddImageSuffix">1</Setting>
+            <Setting
+                name="AOTypeSuffixes">_AO,_AMBIENT,_AMBIENTOCCLUSION</Setting>
+            <Setting
+                name="CompositeTypeSuffixes">_COMP,_COMPOSITE,_PBR,-COMP,-COMPOSITE,-PBR,_ORM,-ORM,_C</Setting>
+            <Setting
+                name="Compressed">1</Setting>
+            <Setting
+                name="DiffuseTypeSuffixes">_ALBEDO,_DIFFUSE,_ALB,_DIF,_COLOR,_COL</Setting>
+            <Setting
+                name="GenerateMaterialOnImport">0</Setting>
+            <Setting
+                name="ImageType">N/A</Setting>
+            <Setting
+                name="ImportImages">1</Setting>
+            <Setting
+                name="IsHDR">0</Setting>
+            <Setting
+                name="MetalnessTypeSuffixes">_METAL,_MET,_METALNESS,_METALLIC,_M</Setting>
+            <Setting
+                name="NormalTypeSuffixes">_NORMAL,_NORM,_N</Setting>
+            <Setting
+                name="RoughnessTypeSuffixes">_ROUGH,_ROUGHNESS,_R</Setting>
+            <Setting
+                name="Scaling">1.0</Setting>
+            <Setting
+                name="SmoothnessTypeSuffixes">_SMOOTH,_SMOOTHNESS,_S</Setting>
+            <Setting
+                name="TextureFilteringMode">Bilinear</Setting>
+            <Setting
+                name="UseMips">1</Setting>
         </Group>
-        <Group name="Materials">
-            <Setting name="AddedMaterialSuffix">_mat</Setting>
-            <Setting name="AlwaysAddMaterialSuffix">0</Setting>
-            <Setting name="CreateComposites">1</Setting>
-            <Setting name="CreateORMConfig">1</Setting>
-            <Setting name="IgnoreMaterials">DefaultMaterial,ColorEffect*</Setting>
-            <Setting name="ImportMaterials">1</Setting>
-            <Setting name="PopulateMaterialMaps">1</Setting>
-            <Setting name="UseDiffuseSuffixOnOriginImage">1</Setting>
-            <Setting name="UseExistingMaterials">1</Setting>
+        <Group
+            name="Materials">
+            <Setting
+                name="AddedMaterialSuffix">_mat</Setting>
+            <Setting
+                name="AlwaysAddMaterialSuffix">1</Setting>
+            <Setting
+                name="CreateComposites">1</Setting>
+            <Setting
+                name="CreateORMConfig">1</Setting>
+            <Setting
+                name="IgnoreMaterials">DefaultMaterial,ColorEffect*</Setting>
+            <Setting
+                name="ImportMaterials">1</Setting>
+            <Setting
+                name="PopulateMaterialMaps">1</Setting>
+            <Setting
+                name="UseDiffuseSuffixOnOriginImage">1</Setting>
+            <Setting
+                name="UseExistingMaterials">1</Setting>
         </Group>
-        <Group name="Meshes">
-            <Setting name="AddedShapeSuffix">_shape</Setting>
-            <Setting name="AdjustCenter">0</Setting>
-            <Setting name="AdjustFloor">0</Setting>
-            <Setting name="AlwaysAddShapeSuffix">0</Setting>
-            <Setting name="calcTangentSpace">0</Setting>
-            <Setting name="CollapseSubmeshes">0</Setting>
-            <Setting name="convertLeftHanded">0</Setting>
-            <Setting name="DoScaleOverride">0</Setting>
-            <Setting name="DoUpAxisOverride">0</Setting>
-            <Setting name="findInstances">0</Setting>
-            <Setting name="flipUVCoords">0</Setting>
-            <Setting name="genUVCoords">0</Setting>
-            <Setting name="IgnoreNodeScale">0</Setting>
-            <Setting name="ImportMesh">1</Setting>
-            <Setting name="invertNormals">0</Setting>
-            <Setting name="JoinIdenticalVerts">0</Setting>
-            <Setting name="limitBoneWeights">0</Setting>
-            <Setting name="LODType">TrailingNumber</Setting>
-            <Setting name="removeRedundantMats">0</Setting>
-            <Setting name="reverseWindingOrder">0</Setting>
-            <Setting name="ScaleOverride">1</Setting>
-            <Setting name="TransformUVs">0</Setting>
-            <Setting name="UpAxisOverride">Z_AXIS</Setting>
+        <Group
+            name="Meshes">
+            <Setting
+                name="AddedShapeSuffix">_shape</Setting>
+            <Setting
+                name="AdjustCenter">0</Setting>
+            <Setting
+                name="AdjustFloor">0</Setting>
+            <Setting
+                name="AlwaysAddShapeSuffix">0</Setting>
+            <Setting
+                name="calcTangentSpace">0</Setting>
+            <Setting
+                name="CollapseSubmeshes">0</Setting>
+            <Setting
+                name="convertLeftHanded">0</Setting>
+            <Setting
+                name="DoScaleOverride">0</Setting>
+            <Setting
+                name="DoUpAxisOverride">0</Setting>
+            <Setting
+                name="findInstances">0</Setting>
+            <Setting
+                name="flipUVCoords">0</Setting>
+            <Setting
+                name="genUVCoords">0</Setting>
+            <Setting
+                name="IgnoreNodeScale">0</Setting>
+            <Setting
+                name="ImportMesh">1</Setting>
+            <Setting
+                name="invertNormals">0</Setting>
+            <Setting
+                name="JoinIdenticalVerts">0</Setting>
+            <Setting
+                name="limitBoneWeights">0</Setting>
+            <Setting
+                name="LODType">TrailingNumber</Setting>
+            <Setting
+                name="removeRedundantMats">0</Setting>
+            <Setting
+                name="reverseWindingOrder">0</Setting>
+            <Setting
+                name="ScaleOverride">1</Setting>
+            <Setting
+                name="TransformUVs">0</Setting>
+            <Setting
+                name="UpAxisOverride">Z_AXIS</Setting>
         </Group>
-        <Group name="Sounds">
-            <Setting name="Compressed">0</Setting>
-            <Setting name="PitchAdjust">1.0</Setting>
-            <Setting name="VolumeAdjust">1.0</Setting>
+        <Group
+            name="Sounds">
+            <Setting
+                name="Compressed">0</Setting>
+            <Setting
+                name="PitchAdjust">1.0</Setting>
+            <Setting
+                name="VolumeAdjust">1.0</Setting>
         </Group>
     </Group>
-    <Group name="LegacyProjectImport">
-        <Group name="Animations">
-            <Setting name="animFPS">2</Setting>
-            <Setting name="animTiming">Seconds</Setting>
-            <Setting name="ImportAnimations">1</Setting>
-            <Setting name="SeparateAnimations">1</Setting>
+    <Group
+        name="LegacyProjectImport">
+        <Group
+            name="Animations">
+            <Setting
+                name="animFPS">2</Setting>
+            <Setting
+                name="animTiming">Seconds</Setting>
+            <Setting
+                name="ImportAnimations">1</Setting>
+            <Setting
+                name="SeparateAnimations">1</Setting>
         </Group>
-        <Group name="Collision">
-            <Setting name="CollisionMeshPrefix">Col</Setting>
-            <Setting name="GenCollisionType">CollisionMesh</Setting>
-            <Setting name="GenerateCollisions">1</Setting>
-            <Setting name="GenerateLOSCollisions">1</Setting>
-            <Setting name="GenLOSCollisionType">CollisionMesh</Setting>
-            <Setting name="LOSCollisionMeshPrefix">LOS</Setting>
+        <Group
+            name="Collision">
+            <Setting
+                name="CollisionMeshPrefix">Col</Setting>
+            <Setting
+                name="GenCollisionType">CollisionMesh</Setting>
+            <Setting
+                name="GenerateCollisions">1</Setting>
+            <Setting
+                name="GenerateLOSCollisions">1</Setting>
+            <Setting
+                name="GenLOSCollisionType">CollisionMesh</Setting>
+            <Setting
+                name="LOSCollisionMeshPrefix">LOS</Setting>
         </Group>
-        <Group name="General">
-            <Setting name="AddDirectoryPrefixToAssetName">0</Setting>
-            <Setting name="AutomaticallyPromptMissingFiles">0</Setting>
-            <Setting name="DuplicateAutoResolution">FolderPrefix</Setting>
-            <Setting name="PreventImportWithErrors">1</Setting>
-            <Setting name="WarningsAsErrors">0</Setting>
+        <Group
+            name="General">
+            <Setting
+                name="AddDirectoryPrefixToAssetName">0</Setting>
+            <Setting
+                name="AutomaticallyPromptMissingFiles">0</Setting>
+            <Setting
+                name="DuplicateAutoResolution">FolderPrefix</Setting>
+            <Setting
+                name="PreventImportWithErrors">1</Setting>
+            <Setting
+                name="WarningsAsErrors">0</Setting>
         </Group>
-        <Group name="Images">
-            <Setting name="AddedImageSuffix">_image</Setting>
-            <Setting name="AlwaysAddImageSuffix">1</Setting>
-            <Setting name="AOTypeSuffixes">_AO,_AMBIENT,_AMBIENTOCCLUSION</Setting>
-            <Setting name="CompositeTypeSuffixes">_COMP,_COMPOSITE</Setting>
-            <Setting name="Compressed">1</Setting>
-            <Setting name="DiffuseTypeSuffixes">_ALBEDO,_DIFFUSE,_ALB,_DIF,_COLOR,_COL</Setting>
-            <Setting name="GenerateMaterialOnImport">0</Setting>
-            <Setting name="ImageType">N/A</Setting>
-            <Setting name="ImportImages">1</Setting>
-            <Setting name="IsHDR">0</Setting>
-            <Setting name="MetalnessTypeSuffixes">_METAL,_MET,_METALNESS,_METALLIC</Setting>
-            <Setting name="NormalTypeSuffixes">_NORMAL,_NORM</Setting>
-            <Setting name="RoughnessTypeSuffixes">_ROUGH,_ROUGHNESS</Setting>
-            <Setting name="Scaling">1.0</Setting>
-            <Setting name="SmoothnessTypeSuffixes">_SMOOTH,_SMOOTHNESS</Setting>
-            <Setting name="TextureFilteringMode">Bilinear</Setting>
-            <Setting name="UseMips">1</Setting>
+        <Group
+            name="Images">
+            <Setting
+                name="AddedImageSuffix">_image</Setting>
+            <Setting
+                name="AlwaysAddImageSuffix">1</Setting>
+            <Setting
+                name="AOTypeSuffixes">_AO,_AMBIENT,_AMBIENTOCCLUSION</Setting>
+            <Setting
+                name="CompositeTypeSuffixes">_COMP,_COMPOSITE</Setting>
+            <Setting
+                name="Compressed">1</Setting>
+            <Setting
+                name="DiffuseTypeSuffixes">_ALBEDO,_DIFFUSE,_ALB,_DIF,_COLOR,_COL</Setting>
+            <Setting
+                name="GenerateMaterialOnImport">0</Setting>
+            <Setting
+                name="ImageType">N/A</Setting>
+            <Setting
+                name="ImportImages">1</Setting>
+            <Setting
+                name="IsHDR">0</Setting>
+            <Setting
+                name="MetalnessTypeSuffixes">_METAL,_MET,_METALNESS,_METALLIC</Setting>
+            <Setting
+                name="NormalTypeSuffixes">_NORMAL,_NORM</Setting>
+            <Setting
+                name="RoughnessTypeSuffixes">_ROUGH,_ROUGHNESS</Setting>
+            <Setting
+                name="Scaling">1.0</Setting>
+            <Setting
+                name="SmoothnessTypeSuffixes">_SMOOTH,_SMOOTHNESS</Setting>
+            <Setting
+                name="TextureFilteringMode">Bilinear</Setting>
+            <Setting
+                name="UseMips">1</Setting>
         </Group>
-        <Group name="Materials">
-            <Setting name="AddedMaterialSuffix">_mat</Setting>
-            <Setting name="AlwaysAddMaterialSuffix">1</Setting>
-            <Setting name="CreateComposites">1</Setting>
-            <Setting name="ImportMaterials">1</Setting>
-            <Setting name="IgnoreMaterials">DefaultMaterial,ColorEffect*</Setting>
-            <Setting name="PopulateMaterialMaps">1</Setting>
-            <Setting name="UseDiffuseSuffixOnOriginImage">1</Setting>
-            <Setting name="UseExistingMaterials">1</Setting>
+        <Group
+            name="Materials">
+            <Setting
+                name="AddedMaterialSuffix">_mat</Setting>
+            <Setting
+                name="AlwaysAddMaterialSuffix">1</Setting>
+            <Setting
+                name="CreateComposites">1</Setting>
+            <Setting
+                name="IgnoreMaterials">DefaultMaterial,ColorEffect*</Setting>
+            <Setting
+                name="ImportMaterials">1</Setting>
+            <Setting
+                name="PopulateMaterialMaps">1</Setting>
+            <Setting
+                name="UseDiffuseSuffixOnOriginImage">1</Setting>
+            <Setting
+                name="UseExistingMaterials">1</Setting>
         </Group>
-        <Group name="Meshes">
-            <Setting name="AddedShapeSuffix">_shape</Setting>
-            <Setting name="AdjustCenter">0</Setting>
-            <Setting name="AdjustFloor">0</Setting>
-            <Setting name="AlwaysAddShapeSuffix">0</Setting>
-            <Setting name="calcTangentSpace">0</Setting>
-            <Setting name="CollapseSubmeshes">0</Setting>
-            <Setting name="convertLeftHanded">0</Setting>
-            <Setting name="DoScaleOverride">0</Setting>
-            <Setting name="DoUpAxisOverride">0</Setting>
-            <Setting name="findInstances">0</Setting>
-            <Setting name="flipUVCoords">0</Setting>
-            <Setting name="genUVCoords">0</Setting>
-            <Setting name="IgnoreNodeScale">0</Setting>
-            <Setting name="ImportMesh">1</Setting>
-            <Setting name="invertNormals">0</Setting>
-            <Setting name="JoinIdenticalVerts">0</Setting>
-            <Setting name="limitBoneWeights">0</Setting>
-            <Setting name="LODType">TrailingNumber</Setting>
-            <Setting name="removeRedundantMats">0</Setting>
-            <Setting name="reverseWindingOrder">0</Setting>
-            <Setting name="ScaleOverride">1</Setting>
-            <Setting name="TransformUVs">0</Setting>
-            <Setting name="UpAxisOverride">Z_AXIS</Setting>
+        <Group
+            name="Meshes">
+            <Setting
+                name="AddedShapeSuffix">_shape</Setting>
+            <Setting
+                name="AdjustCenter">0</Setting>
+            <Setting
+                name="AdjustFloor">0</Setting>
+            <Setting
+                name="AlwaysAddShapeSuffix">0</Setting>
+            <Setting
+                name="calcTangentSpace">0</Setting>
+            <Setting
+                name="CollapseSubmeshes">0</Setting>
+            <Setting
+                name="convertLeftHanded">0</Setting>
+            <Setting
+                name="DoScaleOverride">0</Setting>
+            <Setting
+                name="DoUpAxisOverride">0</Setting>
+            <Setting
+                name="findInstances">0</Setting>
+            <Setting
+                name="flipUVCoords">0</Setting>
+            <Setting
+                name="genUVCoords">0</Setting>
+            <Setting
+                name="IgnoreNodeScale">0</Setting>
+            <Setting
+                name="ImportMesh">1</Setting>
+            <Setting
+                name="invertNormals">0</Setting>
+            <Setting
+                name="JoinIdenticalVerts">0</Setting>
+            <Setting
+                name="limitBoneWeights">0</Setting>
+            <Setting
+                name="LODType">TrailingNumber</Setting>
+            <Setting
+                name="removeRedundantMats">0</Setting>
+            <Setting
+                name="reverseWindingOrder">0</Setting>
+            <Setting
+                name="ScaleOverride">1</Setting>
+            <Setting
+                name="TransformUVs">0</Setting>
+            <Setting
+                name="UpAxisOverride">Z_AXIS</Setting>
         </Group>
-        <Group name="Sounds">
-            <Setting name="Compressed">0</Setting>
-            <Setting name="PitchAdjust">1.0</Setting>
-            <Setting name="VolumeAdjust">1.0</Setting>
+        <Group
+            name="Sounds">
+            <Setting
+                name="Compressed">0</Setting>
+            <Setting
+                name="PitchAdjust">1.0</Setting>
+            <Setting
+                name="VolumeAdjust">1.0</Setting>
         </Group>
     </Group>
-    <Group name="NewTest">
-        <Group name="Animations">
-            <Setting name="animFPS">2</Setting>
-            <Setting name="animTiming">Seconds</Setting>
-            <Setting name="ImportAnimations">1</Setting>
-            <Setting name="SeparateAnimations">1</Setting>
+    <Group
+        name="NewTest">
+        <Group
+            name="Animations">
+            <Setting
+                name="animFPS">2</Setting>
+            <Setting
+                name="animTiming">Seconds</Setting>
+            <Setting
+                name="ImportAnimations">1</Setting>
+            <Setting
+                name="SeparateAnimations">1</Setting>
         </Group>
-        <Group name="Collision">
-            <Setting name="CollisionMeshPrefix">Col</Setting>
-            <Setting name="GenCollisionType">CollisionMesh</Setting>
-            <Setting name="GenerateCollisions">1</Setting>
-            <Setting name="GenerateLOSCollisions">1</Setting>
-            <Setting name="GenLOSCollisionType">CollisionMesh</Setting>
-            <Setting name="LOSCollisionMeshPrefix">LOS</Setting>
+        <Group
+            name="Collision">
+            <Setting
+                name="CollisionMeshPrefix">Col</Setting>
+            <Setting
+                name="GenCollisionType">CollisionMesh</Setting>
+            <Setting
+                name="GenerateCollisions">1</Setting>
+            <Setting
+                name="GenerateLOSCollisions">1</Setting>
+            <Setting
+                name="GenLOSCollisionType">CollisionMesh</Setting>
+            <Setting
+                name="LOSCollisionMeshPrefix">LOS</Setting>
         </Group>
-        <Group name="General">
-            <Setting name="AddDirectoryPrefixToAssetName">0</Setting>
-            <Setting name="AutomaticallyPromptMissingFiles">0</Setting>
-            <Setting name="DuplicatAutoResolution">AutoPrune</Setting>
-            <Setting name="PreventImportWithErrors">1</Setting>
-            <Setting name="WarningsAsErrors">0</Setting>
+        <Group
+            name="General">
+            <Setting
+                name="AddDirectoryPrefixToAssetName">0</Setting>
+            <Setting
+                name="AutomaticallyPromptMissingFiles">0</Setting>
+            <Setting
+                name="DuplicatAutoResolution">AutoPrune</Setting>
+            <Setting
+                name="PreventImportWithErrors">1</Setting>
+            <Setting
+                name="WarningsAsErrors">0</Setting>
         </Group>
-        <Group name="Images">
-            <Setting name="AOTypeSuffixes">_AO,_AMBIENT,_AMBIENTOCCLUSION</Setting>
-            <Setting name="Compressed">1</Setting>
-            <Setting name="DiffuseTypeSuffixes">_ALBEDO,_DIFFUSE,_ALB,_DIF,_COLOR,_COL</Setting>
-            <Setting name="GenerateMaterialOnImport">1</Setting>
-            <Setting name="ImageType">N/A</Setting>
-            <Setting name="IsHDR">0</Setting>
-            <Setting name="MetalnessTypeSuffixes">_METAL,_MET,_METALNESS,_METALLIC</Setting>
-            <Setting name="NormalTypeSuffixes">_NORMAL,_NORM</Setting>
-            <Setting name="PBRTypeSuffixes">_COMP,_COMPOSITE,_PBR,-COMP,-COMPOSITE,-PBR,_ORM,-ORM</Setting>
-            <Setting name="RoughnessTypeSuffixes">_ROUGH,_ROUGHNESS</Setting>
-            <Setting name="Scaling">1.0</Setting>
-            <Setting name="SmoothnessTypeSuffixes">_SMOOTH,_SMOOTHNESS</Setting>
-            <Setting name="TextureFilteringMode">Bilinear</Setting>
-            <Setting name="UseMips">1</Setting>
+        <Group
+            name="Images">
+            <Setting
+                name="AOTypeSuffixes">_AO,_AMBIENT,_AMBIENTOCCLUSION</Setting>
+            <Setting
+                name="Compressed">1</Setting>
+            <Setting
+                name="DiffuseTypeSuffixes">_ALBEDO,_DIFFUSE,_ALB,_DIF,_COLOR,_COL</Setting>
+            <Setting
+                name="GenerateMaterialOnImport">1</Setting>
+            <Setting
+                name="ImageType">N/A</Setting>
+            <Setting
+                name="IsHDR">0</Setting>
+            <Setting
+                name="MetalnessTypeSuffixes">_METAL,_MET,_METALNESS,_METALLIC</Setting>
+            <Setting
+                name="NormalTypeSuffixes">_NORMAL,_NORM</Setting>
+            <Setting
+                name="PBRTypeSuffixes">_COMP,_COMPOSITE,_PBR,-COMP,-COMPOSITE,-PBR,_ORM,-ORM</Setting>
+            <Setting
+                name="RoughnessTypeSuffixes">_ROUGH,_ROUGHNESS</Setting>
+            <Setting
+                name="Scaling">1.0</Setting>
+            <Setting
+                name="SmoothnessTypeSuffixes">_SMOOTH,_SMOOTHNESS</Setting>
+            <Setting
+                name="TextureFilteringMode">Bilinear</Setting>
+            <Setting
+                name="UseMips">1</Setting>
         </Group>
-        <Group name="Materials">
-            <Setting name="CreateComposites">1</Setting>
-            <Setting name="ImportMaterials">1</Setting>
-            <Setting name="PopulateMaterialMaps">1</Setting>
-            <Setting name="UseDiffuseSuffixOnOriginImage">1</Setting>
-            <Setting name="UseExistingMaterials">1</Setting>
+        <Group
+            name="Materials">
+            <Setting
+                name="CreateComposites">1</Setting>
+            <Setting
+                name="ImportMaterials">1</Setting>
+            <Setting
+                name="PopulateMaterialMaps">1</Setting>
+            <Setting
+                name="UseDiffuseSuffixOnOriginImage">1</Setting>
+            <Setting
+                name="UseExistingMaterials">1</Setting>
         </Group>
-        <Group name="Meshes">
-            <Setting name="AdjustCenter">0</Setting>
-            <Setting name="AdjustFloor">0</Setting>
-            <Setting name="calcTangentSpace">0</Setting>
-            <Setting name="CollapseSubmeshes">0</Setting>
-            <Setting name="convertLeftHanded">0</Setting>
-            <Setting name="DoScaleOverride">0</Setting>
-            <Setting name="DoUpAxisOverride">0</Setting>
-            <Setting name="findInstances">0</Setting>
-            <Setting name="flipUVCoords">0</Setting>
-            <Setting name="genUVCoords">0</Setting>
-            <Setting name="IgnoreNodeScale">0</Setting>
-            <Setting name="ImportMesh">1</Setting>
-            <Setting name="invertNormals">0</Setting>
-            <Setting name="JoinIdenticalVerts">0</Setting>
-            <Setting name="limitBoneWeights">0</Setting>
-            <Setting name="LODType">TrailingNumber</Setting>
-            <Setting name="removeRedundantMats">0</Setting>
-            <Setting name="reverseWindingOrder">0</Setting>
-            <Setting name="ScaleOverride">1</Setting>
-            <Setting name="TransformUVs">0</Setting>
-            <Setting name="UpAxisOverride">Z_AXIS</Setting>
+        <Group
+            name="Meshes">
+            <Setting
+                name="AdjustCenter">0</Setting>
+            <Setting
+                name="AdjustFloor">0</Setting>
+            <Setting
+                name="calcTangentSpace">0</Setting>
+            <Setting
+                name="CollapseSubmeshes">0</Setting>
+            <Setting
+                name="convertLeftHanded">0</Setting>
+            <Setting
+                name="DoScaleOverride">0</Setting>
+            <Setting
+                name="DoUpAxisOverride">0</Setting>
+            <Setting
+                name="findInstances">0</Setting>
+            <Setting
+                name="flipUVCoords">0</Setting>
+            <Setting
+                name="genUVCoords">0</Setting>
+            <Setting
+                name="IgnoreNodeScale">0</Setting>
+            <Setting
+                name="ImportMesh">1</Setting>
+            <Setting
+                name="invertNormals">0</Setting>
+            <Setting
+                name="JoinIdenticalVerts">0</Setting>
+            <Setting
+                name="limitBoneWeights">0</Setting>
+            <Setting
+                name="LODType">TrailingNumber</Setting>
+            <Setting
+                name="removeRedundantMats">0</Setting>
+            <Setting
+                name="reverseWindingOrder">0</Setting>
+            <Setting
+                name="ScaleOverride">1</Setting>
+            <Setting
+                name="TransformUVs">0</Setting>
+            <Setting
+                name="UpAxisOverride">Z_AXIS</Setting>
         </Group>
-        <Group name="Sounds">
-            <Setting name="Compressed">0</Setting>
-            <Setting name="PitchAdjust">1.0</Setting>
-            <Setting name="VolumeAdjust">1.0</Setting>
+        <Group
+            name="Sounds">
+            <Setting
+                name="Compressed">0</Setting>
+            <Setting
+                name="PitchAdjust">1.0</Setting>
+            <Setting
+                name="VolumeAdjust">1.0</Setting>
         </Group>
     </Group>
 </AssetImportSettings>
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
index c385a5f0c..7d0c1e3da 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
@@ -2491,8 +2491,10 @@ function AssetBrowser::autoImportSimpleLooseFiles(%this)
 
    while( %file !$= "" )
    {      
-      if(!strIsMatchExpr("*.asset.taml", %file) && !strIsMatchExpr("*.taml", %file) && !strIsMatchExpr("*.cached.dts", %file))
+      if(!strIsMatchExpr("*.asset.taml", %file) && !strIsMatchExpr("*.taml", %file) && !strIsMatchExpr("*.cached.dts", %file) 
+         && !strIsMatchExpr("*.cs", %file) && !strIsMatchExpr("*.tscript", %file) && !strIsMatchExpr("*.module", %file))
       {
+         %aq.clear();
          %assetsFound = AssetDatabase.findAssetLooseFile(%aq, %file);
          
          if(%assetsFound == 0)
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfigEditor.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfigEditor.tscript
index 929c1ddfe..d664cfa05 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfigEditor.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImportConfigEditor.tscript
@@ -33,8 +33,8 @@ function AssetImportConfigEditor::apply(%this)
 
 function AssetImportConfigList::onSelect( %this, %id, %text )
 {
-   ImportOptionsConfigList.clearFields();
-   ImportOptionsConfigList.setAutoUpdate(false); //we don't want to be updating every time we add a field in here
+   AssetImportConfigEditorInspector.clearFields();
+   AssetImportConfigEditorInspector.setAutoUpdate(false); //we don't want to be updating every time we add a field in here
    
    %this.currentConfig = %text;
    
@@ -46,7 +46,7 @@ function AssetImportConfigList::onSelect( %this, %id, %text )
    %this.populateConfigListByGroup("Animations");
    //%this.populateConfigListByGroup("Collision");
    
-   ImportOptionsConfigList.update();  
+   AssetImportConfigEditorInspector.update();  
 }
 
 function AssetImportConfigList::populateConfigListByGroup(%this, %groupName)
diff --git a/Templates/BaseGame/game/tools/projectImporter/importers/pre40/pre40ImporterGuis.tscript b/Templates/BaseGame/game/tools/projectImporter/importers/pre40/pre40ImporterGuis.tscript
index 10b7fb96a..4835889e8 100644
--- a/Templates/BaseGame/game/tools/projectImporter/importers/pre40/pre40ImporterGuis.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/importers/pre40/pre40ImporterGuis.tscript
@@ -46,12 +46,7 @@ function Pre40ImporterPage0::openPage(%this)
          
          %targetFolder = filePath(%targetFilePath);
          
-         if(!isDirectory(%targetFolder))
-         {
-            DirectoryHandler::createFolder(0, %targetFolder);
-         }
-         
-         if(!pathCopy(%file, %targetFilePath, false))
+         if(!copyFileToDestination(%file, %targetFilePath))
          {
             $ProjectImporter::log.add("Legacy Project Importer, failed to copy file: " @ %file @ " to destination: " @ %targetFilePath);
             continue;
diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
index 13797d2a2..eccb3b0f6 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
@@ -373,6 +373,28 @@ function ProjectImportWindow::addImporterPage(%this, %page)
 // functions that'll pretty much be used regardless of version being targeted
 //==============================================================================
 //==============================================================================
+// Takes a source file and attempts to copy it to the destination path.
+// If the paths are the same, we just exit out with a success indicator
+//==============================================================================
+function copyFileToDestination(%sourceFile, %destinationFile)
+{
+   %fullSourcePath = makeFullPath(%sourceFile); 
+   %fullDestPath = makeFullPath(%destinationFile); 
+   
+   if(!IsDirectory(filePath(%fullDestPath)))
+   {
+      DirectoryHandler::createFolder(0, filePath(%fullDestPath));  
+   }
+   
+   if(%fullSourcePath $= %fullDestPath)
+      return true; //no need to copy, we're already here!
+      
+   if(!pathCopy(%fullSourcePath, %fullDestPath, false))
+      return false;
+      
+   return true;
+}
+//==============================================================================
 // Runs through the files in the source directory and preprocessing them.
 // All valid files are added to a list, and script-based files are pre-parsed 
 // so the importer can easily process their contents later
@@ -1436,12 +1458,7 @@ function beginShapeImport()
       %destinationPath = %rootFileSectionObject.fileDestination;
       if(isFile(%file) && %rootFileSectionObject.isShapeFile == true && %rootFileSectionObject.imported == false)
       {    
-         if(!IsDirectory(filePath(%destinationPath)))
-         {
-            DirectoryHandler::createFolder(0, filePath(%destinationPath));  
-         }
-         
-         if(!pathCopy(%file, %destinationPath, false))
+         if(!copyFileToDestination(%file, %destinationPath))
          {
             projectImporterLog("ProjectImporter::beginShapeImport() - failed to copy shape: " @ %file @
                                     " to destination: " @ %destinationPath);
@@ -1502,12 +1519,7 @@ function beginImageImport()
       %destinationPath = %rootFileSectionObject.fileDestination;
       if(isFile(%file) && %rootFileSectionObject.isImageFile == true && %rootFileSectionObject.imported == false)
       {    
-         if(!IsDirectory(filePath(%destinationPath)))
-         {
-            DirectoryHandler::createFolder(0, filePath(%destinationPath));  
-         }
-         
-         if(!pathCopy(%file, %destinationPath, false))
+         if(!copyFileToDestination(%file, %destinationPath))
          {
             projectImporterLog("ProjectImporter::beginImageImport() - failed to copy image: " @ %file @
                                     " to destination: " @ %destinationPath);
@@ -1577,12 +1589,8 @@ function beginTerrainImport()
             %fileName = fileName(%file); 
             %filePath = filePath(%file);
          }*/
-         if(!IsDirectory(filePath(%destinationPath)))
-         {
-            DirectoryHandler::createFolder(0, filePath(%destinationPath));  
-         }
          
-         if(!pathCopy(%file, %destinationPath, false))
+         if(!copyFileToDestination(%file, %destinationPath))
          {
             projectImporterLog("ProjectImporter::beginTerrainImport() - failed to copy terrain: " @ %file @
                                     " to destination: " @ %destinationPath);
@@ -1666,12 +1674,8 @@ function beginSoundImport()
             %fileName = fileName(%file); 
             %filePath = filePath(%file);
          }*/
-         if(!IsDirectory(filePath(%destinationPath)))
-         {
-            DirectoryHandler::createFolder(0, filePath(%destinationPath));  
-         }
          
-         if(!pathCopy(%file, %destinationPath, false))
+         if(!copyFileToDestination(%file, %destinationPath))
          {
             projectImporterLog("ProjectImporter::beginSoundImport() - failed to copy sound: " @ %file @
                                     " to destination: " @ %destinationPath);
@@ -1775,7 +1779,7 @@ function beginGUIImport()
 
             //Check if we need to even copy in the first place. If we do, ensure
             //the copy actually worked
-            if((makeRelativePath(%file) !$= %destinationPath) && !pathCopy(%file, %destinationPath, false))
+            if(!copyFileToDestination(%file, %destinationPath))
             {
                projectImporterLog("ProjectImporter::beginGUIImport() - failed to copy GUI: " @ %file @
                   " to destination: " @ %destinationPath);
@@ -1888,12 +1892,7 @@ function beginLevelImport()
          %fileBase = fileBase(%destinationPath);
          %filePath = filePath(%destinationPath);
          
-         if(!IsDirectory(filePath(%destinationPath)))
-         {
-            DirectoryHandler::createFolder(0, filePath(%destinationPath));  
-         }
-         
-         if(!pathCopy(%file, %destinationPath, false))
+         if(!copyFileToDestination(%file, %destinationPath))
          {
             projectImporterLog("ProjectImporter::beginLevelImport() - failed to copy level: " @ %file @
                                     " to destination: " @ %destinationPath);

From 7fe85ab7d5b24086d367b981cdd8df8c3e027929 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Fri, 25 Feb 2022 16:55:05 -0600
Subject: [PATCH 322/399] Fixes saveScaledImage to handle DDS format files,
 since DDS's go through a separate resource loader

---
 Engine/source/gfx/bitmap/gBitmap.cpp | 52 ++++++++++++++++++++--------
 1 file changed, 38 insertions(+), 14 deletions(-)

diff --git a/Engine/source/gfx/bitmap/gBitmap.cpp b/Engine/source/gfx/bitmap/gBitmap.cpp
index b7045d129..97e891fcf 100644
--- a/Engine/source/gfx/bitmap/gBitmap.cpp
+++ b/Engine/source/gfx/bitmap/gBitmap.cpp
@@ -32,6 +32,7 @@
 #include "console/console.h"
 #include "platform/profiler.h"
 #include "console/engineAPI.h"
+#include "gfx/bitmap/ddsFile.h"
 
 using namespace Torque;
 
@@ -1362,30 +1363,48 @@ DefineEngineFunction( getBitmapInfo, String, ( const char *filename ),,
 }
 
 DefineEngineFunction(saveScaledImage, bool, (const char* bitmapSource, const char* bitmapDest, S32 resolutionSize), ("", "", 512),
-   "Returns image info in the following format: width TAB height TAB bytesPerPixel TAB format. "
-   "It will return an empty string if the file is not found.\n"
-   "@ingroup Rendering\n")
+   "Loads an image from the source path, and scales it down to the target resolution before"
+   "Saving it out to the destination path.\n")
 {
-   Resource<GBitmap> image = GBitmap::load(bitmapSource);
-   if (!image)
-      return false;
+   bool isDDS = false;
 
-   Torque::Path sourcePath = Torque::Path(bitmapSource);
-
-   /*if (String("dds").equal(sourcePath.getExtension(), String::NoCase))
+   //First, gotta check the extension, as we have some extra work to do if it's
+   //a DDS file
+   const char* ret = dStrrchr(bitmapSource, '.');
+   if (ret)
    {
-      dds = DDSFile::load(correctPath, scalePower);
+      if (String::ToLower(ret) == String(".dds"))
+         isDDS = true;
+   }
+   else
+   {
+      return false; //no extension? bail out
+   }
+
+   GBitmap* image;
+   if (isDDS)
+   {
+      Resource<DDSFile> dds = DDSFile::load(bitmapSource, 0);
       if (dds != NULL)
       {
+         image = new GBitmap();
          if (!dds->decompressToGBitmap(image))
          {
             delete image;
             image = NULL;
-            return false;
          }
       }
-   }*/
-   if (isPow2(image->getWidth())&& isPow2(image->getHeight()))
+   }
+   else
+   {
+      image = GBitmap::load(bitmapSource);
+   }
+
+   if (!image)
+      return false;
+   Torque::Path sourcePath = Torque::Path(bitmapSource);
+
+   if (isPow2(image->getWidth()) && isPow2(image->getHeight()))
       image->extrudeMipLevels();
 
    U32 mipCount = image->getNumMipLevels();
@@ -1396,9 +1415,14 @@ DefineEngineFunction(saveScaledImage, bool, (const char* bitmapSource, const cha
       image->chopTopMips(mipCount - targetMips);
    }
 
+   //TODO: support different format targets, for now we just force
+   //to png for simplicity
+   Torque::Path destinationPath = Torque::Path(bitmapDest);
+   destinationPath.setExtension("png");
+
    // Open up the file on disk.
    FileStream fs;
-   if (!fs.open(bitmapDest, Torque::FS::File::Write))
+   if (!fs.open(destinationPath.getFullPath(), Torque::FS::File::Write))
    {
       Con::errorf("saveScaledImage() - Failed to open output file '%s'!", bitmapDest);
       return false;

From 3e4cc0a5c6ea062ba443600c1235ad3f6752d87b Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Sun, 6 Mar 2022 13:18:06 -0600
Subject: [PATCH 323/399] fix probe baking typo

---
 .../shaders/lighting/advanced/reflectionProbeArrayP.hlsl        | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/reflectionProbeArrayP.hlsl b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/reflectionProbeArrayP.hlsl
index 1b49a5e41..d9314329e 100644
--- a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/reflectionProbeArrayP.hlsl
+++ b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/reflectionProbeArrayP.hlsl
@@ -190,6 +190,6 @@ float4 main(PFXVertToPix IN) : SV_TARGET
 #if CAPTURING == 1
     return float4(lerp(surface.baseColor.rgb,(irradiance + specular* horizon) ,surface.metalness/2),0);
 #else
-   return result = float4((irradiance + specular* horizon) , 0);//alpha writes disabled   
+   return float4((irradiance + specular* horizon) , 0);//alpha writes disabled   
 #endif
 }

From f1f73e41bd0bb324c1e8b0cc2d617243761e8162 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Sun, 6 Mar 2022 22:55:05 -0600
Subject: [PATCH 324/399] Fixes handlong of loading non-DDS images to better
 handle pointer references with the GBitmap resources. Also adds a sanity
 check for the source or dest strings so they can't be empty strings

---
 Engine/source/gfx/bitmap/gBitmap.cpp | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/Engine/source/gfx/bitmap/gBitmap.cpp b/Engine/source/gfx/bitmap/gBitmap.cpp
index 97e891fcf..ebd3741b1 100644
--- a/Engine/source/gfx/bitmap/gBitmap.cpp
+++ b/Engine/source/gfx/bitmap/gBitmap.cpp
@@ -1368,6 +1368,11 @@ DefineEngineFunction(saveScaledImage, bool, (const char* bitmapSource, const cha
 {
    bool isDDS = false;
 
+   if (bitmapSource == 0 || bitmapSource[0] == '\0' || bitmapDest == 0 || bitmapDest[0] == '\0')
+   {
+      return false;
+   }
+
    //First, gotta check the extension, as we have some extra work to do if it's
    //a DDS file
    const char* ret = dStrrchr(bitmapSource, '.');
@@ -1381,7 +1386,7 @@ DefineEngineFunction(saveScaledImage, bool, (const char* bitmapSource, const cha
       return false; //no extension? bail out
    }
 
-   GBitmap* image;
+   GBitmap* image = NULL;
    if (isDDS)
    {
       Resource<DDSFile> dds = DDSFile::load(bitmapSource, 0);
@@ -1397,7 +1402,8 @@ DefineEngineFunction(saveScaledImage, bool, (const char* bitmapSource, const cha
    }
    else
    {
-      image = GBitmap::load(bitmapSource);
+      Resource<GBitmap> resImage = GBitmap::load(bitmapSource);
+      image = new GBitmap(*resImage);
    }
 
    if (!image)

From 1d5a36c4c078ee5da58fedce1ddeff33ec8a2f2d Mon Sep 17 00:00:00 2001
From: marauder2k7 <ctrl-intelligence@live.co.uk>
Date: Tue, 8 Mar 2022 19:50:36 +0000
Subject: [PATCH 325/399] Spheres for Skies

-Added: SkySphere a full sphere skyBox
-Change: ScatterSky now renders a dome instead of the top face of a cubeSphere
-Change: Creator now has skySphere

TODO: Simplify sphere creation
PossibleMethod: Add the sphere creation functions to one place to be shared around.
---
 Engine/source/environment/scatterSky.cpp      | 167 +++--
 Engine/source/environment/scatterSky.h        |  21 +
 Engine/source/environment/skySphere.cpp       | 645 ++++++++++++++++++
 Engine/source/environment/skySphere.h         | 172 +++++
 .../assetBrowser/scripts/creator.tscript      |   1 +
 .../scripts/editors/creator.ed.tscript        |   1 +
 6 files changed, 966 insertions(+), 41 deletions(-)
 create mode 100644 Engine/source/environment/skySphere.cpp
 create mode 100644 Engine/source/environment/skySphere.h

diff --git a/Engine/source/environment/scatterSky.cpp b/Engine/source/environment/scatterSky.cpp
index 5de3bdd94..12071d558 100644
--- a/Engine/source/environment/scatterSky.cpp
+++ b/Engine/source/environment/scatterSky.cpp
@@ -758,73 +758,146 @@ bool ScatterSky::_initShader()
    return true;
 }
 
+void ScatterSky::clearVectors()
+{
+   tmpVertices.clear();
+   vertsVec.clear();
+}
+
+void ScatterSky::addVertex(Point3F vert)
+{
+   vertsVec.push_back(vert.x);
+   vertsVec.push_back(vert.y);
+   vertsVec.push_back(vert.z);
+}
+
+void ScatterSky::BuildFinalVert()
+{
+   U32 count = vertsVec.size();
+   U32 i, j;
+   for (i = 0, j = 0; i < count; i += 3, j += 2)
+   {
+      FinalVertexData temp;
+      temp.pos.set(Point3F(vertsVec[i], vertsVec[i + 1], vertsVec[i + 2]));
+
+      finalVertData.push_back(temp);
+   }
+}
+
 void ScatterSky::_initVBIB()
 {
+   U32 rings = 18;
+   U32 height = 9;
+   U32 radius = 10;
+
+   F32 x, y, z, xy;                     // vertex position
+
+   F32 ringStep = M_2PI / rings;
+   F32 heightStep = M_HALFPI / height; // M_PI for full sphere.
+   F32 ringAng, heightAng;
+
+   //clear vecs
+   clearVectors();
+
+   for (U32 i = 0; i <= height; ++i)
+   {
+      heightAng = M_PI / 2 - (F32)i * heightStep;
+      xy = radius * mCos(heightAng);
+      z = radius * mSin(heightAng);
+
+      for (U32 j = 0; j <= rings; ++j)
+      {
+         SphereVertex vert;
+         ringAng = j * ringStep;
+         x = xy * mCos(ringAng);
+         y = xy * mSin(ringAng);
+         vert.pos.set(Point3F(x, y, z));
+
+         tmpVertices.push_back(vert);
+      }
+   }
+
+   SphereVertex v1, v2, v3, v4;
+   U32 vi1, vi2 = 0;
+
+   for (U32 i = 0; i < height; ++i)
+   {
+      vi1 = i * (rings + 1);
+      vi2 = (i + 1) * (rings + 1);
+
+      for (U32 j = 0; j < rings; ++j, ++vi1, ++vi2)
+      {
+         v1 = tmpVertices[vi1];
+         v2 = tmpVertices[vi2];
+         v3 = tmpVertices[vi1 + 1];
+         v4 = tmpVertices[vi2 + 1];
+
+         // 1st = triangle.
+         if (i == 0)
+         {
+            // verts for tri.
+            addVertex(v1.pos);
+            addVertex(v2.pos);
+            addVertex(v4.pos);
+         }
+         /* UNCOMMENT WHEN FULL SPHERE
+         else if (i == (height - 1))
+         {
+            // verts for tri.
+            addVertex(v1.pos);
+            addVertex(v2.pos);
+            addVertex(v3.pos);
+         }*/
+         else
+         {
+            // verts for quad.
+            addVertex(v1.pos);
+            addVertex(v2.pos);
+            addVertex(v3.pos);
+
+            addVertex(v3.pos);
+            addVertex(v4.pos);
+            addVertex(v2.pos);
+         }
+      }
+   }
+
+   BuildFinalVert();
+
    // Vertex Buffer...
-   U32 vertStride = 50;
-   U32 strideMinusOne = vertStride - 1;
-   mVertCount = vertStride * vertStride;
-   mPrimCount = strideMinusOne * strideMinusOne * 2;
-
-   Point3F vertScale( 16.0f, 16.0f, 4.0f );
-
-   F32 zOffset = -( mCos( mSqrt( 1.0f ) ) + 0.01f );
+   mVertCount = finalVertData.size();
+   mPrimCount = mVertCount / 3;
 
    mVB.set( GFX, mVertCount, GFXBufferTypeStatic );
    GFXVertexP *pVert = mVB.lock();
    if(!pVert) return;
 
-   for ( U32 y = 0; y < vertStride; y++ )
+   for ( U32 i = 0; i < mVertCount; i++ )
    {
-      F32 v = ( (F32)y / (F32)strideMinusOne - 0.5f ) * 2.0f;
-
-      for ( U32 x = 0; x < vertStride; x++ )
-      {
-         F32 u = ( (F32)x / (F32)strideMinusOne - 0.5f ) * 2.0f;
-
-         F32 sx = u;
-         F32 sy = v;
-         F32 sz = (mCos( mSqrt( sx*sx + sy*sy ) ) * 1.0f) + zOffset;
-         //F32 sz = 1.0f;
-         pVert->point.set( sx, sy, sz );
-         pVert->point *= vertScale;
+         pVert->point.set(finalVertData[i].pos);
 
          pVert->point.normalize();
          pVert->point *= 200000.0f;
-
          pVert++;
-      }
    }
 
    mVB.unlock();
 
    // Primitive Buffer...
-   mPrimBuffer.set( GFX, mPrimCount * 3, mPrimCount, GFXBufferTypeStatic );
+   mPrimBuffer.set( GFX, mVertCount, mPrimCount, GFXBufferTypeStatic );
 
    U16 *pIdx = NULL;
    mPrimBuffer.lock(&pIdx);
    U32 curIdx = 0;
 
-   for ( U32 y = 0; y < strideMinusOne; y++ )
+   for ( U32 i = 0, k = 0; i < mPrimCount; i++, k+=3 )
    {
-      for ( U32 x = 0; x < strideMinusOne; x++ )
-      {
-         U32 offset = x + y * vertStride;
-
-         pIdx[curIdx] = offset;
+         pIdx[curIdx] = k;
          curIdx++;
-         pIdx[curIdx] = offset + 1;
+         pIdx[curIdx] = k + 1;
          curIdx++;
-         pIdx[curIdx] = offset + vertStride + 1;
+         pIdx[curIdx] = k + 2;
          curIdx++;
-
-         pIdx[curIdx] = offset;
-         curIdx++;
-         pIdx[curIdx] = offset + vertStride + 1;
-         curIdx++;
-         pIdx[curIdx] = offset + vertStride;
-         curIdx++;
-      }
    }
 
    mPrimBuffer.unlock();
@@ -963,13 +1036,25 @@ void ScatterSky::_render( ObjectRenderInst *ri, SceneRenderState *state, BaseMat
 
    Point3F camPos2 = state->getCameraPosition();
    MatrixF xfm(true);
-   xfm.setPosition(camPos2 - Point3F(0, 0, mZOffset));
+   xfm.setPosition(Point3F(
+      camPos2.x,
+      camPos2.y,
+      mZOffset) );
+
    GFX->multWorld(xfm);
 
    MatrixF xform(proj);//GFX->getProjectionMatrix());
    xform *= GFX->getViewMatrix();
    xform *=  GFX->getWorldMatrix();
 
+   if(state->isReflectPass())
+   {
+      static MatrixF rotMat(EulerF(0.0, 0.0, M_PI_F));
+      xform.mul(rotMat);
+      rotMat.set(EulerF(M_PI_F, 0.0, 0.0));
+      xform.mul(rotMat);
+   }
+
    mShaderConsts->setSafe( mModelViewProjSC, xform );
    mShaderConsts->setSafe( mMiscSC, miscParams );
    mShaderConsts->setSafe( mSphereRadiiSC, sphereRadii );
diff --git a/Engine/source/environment/scatterSky.h b/Engine/source/environment/scatterSky.h
index 0633e9e23..e544e64a5 100644
--- a/Engine/source/environment/scatterSky.h
+++ b/Engine/source/environment/scatterSky.h
@@ -104,6 +104,27 @@ public:
    ///
    F32 getElevation() const { return mSunElevation; }
 
+   struct SphereVertex
+   {
+      Point3F pos;
+   };
+
+   Vector<SphereVertex> tmpVertices;
+   Vector<F32> vertsVec;
+
+   struct FinalVertexData
+   {
+      Point3F pos;
+   };
+
+   Vector<FinalVertexData> finalVertData;
+
+   void addVertex(Point3F vert);
+
+   void BuildFinalVert();
+
+   void clearVectors();
+
 protected:
 
    void _render( ObjectRenderInst *ri, SceneRenderState *state, BaseMatInstance *overrideMat );
diff --git a/Engine/source/environment/skySphere.cpp b/Engine/source/environment/skySphere.cpp
new file mode 100644
index 000000000..9f52c660c
--- /dev/null
+++ b/Engine/source/environment/skySphere.cpp
@@ -0,0 +1,645 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2012 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+
+#include "platform/platform.h"
+#include "environment/skySphere.h"
+
+#include "console/consoleTypes.h"
+#include "console/engineAPI.h"
+#include "scene/sceneRenderState.h"
+#include "renderInstance/renderPassManager.h"
+#include "gfx/primBuilder.h"
+#include "gfx/gfxTransformSaver.h"
+#include "core/stream/fileStream.h"
+#include "core/stream/bitStream.h"
+#include "materials/materialManager.h"
+#include "materials/materialFeatureTypes.h"
+#include "materials/sceneData.h"
+#include "T3D/gameFunctions.h"
+#include "renderInstance/renderBinManager.h"
+#include "materials/processedMaterial.h"
+#include "gfx/gfxDebugEvent.h"
+#include "math/util/matrixSet.h"
+
+IMPLEMENT_CO_NETOBJECT_V1(SkySphere);
+
+ConsoleDocClass(SkySphere,
+   "@brief Represents the sky with an artist-created spherical map.\n\n"
+
+   "SkySphere is not a directional light and should be used in conjunction with a Sun object.\n\n"
+
+   "@ingroup Atmosphere"
+);
+
+SkySphere::SkySphere()
+{
+   mTypeMask |= EnvironmentObjectType | StaticObjectType;
+   mNetFlags.set(Ghostable | ScopeAlways);
+
+   INIT_ASSET(Material);
+   mMatInstance = NULL;
+
+   mIsVBDirty = false;
+   mPrimCount = 0;
+   mFogBandHeight = 0;
+   mFogPrimCount = 0;
+
+   mMatrixSet = reinterpret_cast<MatrixSet*>(dMalloc_aligned(sizeof(MatrixSet), 16));
+   constructInPlace(mMatrixSet);
+
+   mFogBandMat = NULL;
+   mFogBandMatInst = NULL;
+}
+
+SkySphere::~SkySphere()
+{
+   dFree_aligned(mMatrixSet);
+
+   if (mMatInstance)
+      SAFE_DELETE(mMatInstance);
+
+   SAFE_DELETE(mFogBandMatInst);
+
+   if (mFogBandMat)
+   {
+      mFogBandMat->deleteObject();
+      mFogBandMat = NULL;
+   }
+}
+
+bool SkySphere::onAdd()
+{
+   if (!Parent::onAdd())
+      return false;
+
+   setGlobalBounds();
+   resetWorldBox();
+
+   addToScene();
+
+   if (isClientObject())
+   {
+      _initRender();
+      _updateMaterial();
+   }
+
+   return true;
+}
+
+void SkySphere::onRemove()
+{
+   removeFromScene();
+   Parent::onRemove();
+}
+
+void SkySphere::initPersistFields()
+{
+   addGroup("Sky Sphere");
+
+   INITPERSISTFIELD_MATERIALASSET(Material, SkySphere, "The name of a cubemap material for the sky box.");
+
+   addField("fogBandHeight", TypeF32, Offset(mFogBandHeight, SkySphere),
+      "The height (0-1) of the fog band from the horizon to the top of the SkySphere.");
+
+   endGroup("Sky Sphere");
+
+   Parent::initPersistFields();
+}
+
+void SkySphere::inspectPostApply()
+{
+   Parent::inspectPostApply();
+   _updateMaterial();
+}
+
+U32 SkySphere::packUpdate(NetConnection* conn, U32 mask, BitStream* stream)
+{
+   U32 retMask = Parent::packUpdate(conn, mask, stream);
+
+   PACK_ASSET(conn, Material);
+
+   stream->write(mFogBandHeight);
+
+   return retMask;
+}
+
+void SkySphere::unpackUpdate(NetConnection* conn, BitStream* stream)
+{
+   Parent::unpackUpdate(conn, stream);
+
+   StringTableEntry oldMatName = getMaterial();
+   UNPACK_ASSET(conn, Material);
+   if (oldMatName != getMaterial())
+   {
+      _updateMaterial();
+   }
+
+   F32 bandHeight = 0;
+   stream->read(&bandHeight);
+
+   // If this flag has changed
+   // we need to update the vertex buffer.
+   if ( bandHeight != mFogBandHeight)
+   {
+      mFogBandHeight = bandHeight;
+      mIsVBDirty = true;
+      _initRender();
+   }
+}
+
+void SkySphere::prepRenderImage(SceneRenderState* state)
+{
+   PROFILE_SCOPE(SkySphere_prepRenderImage);
+
+   if (state->isShadowPass() ||
+      mVB.isNull() ||
+      mFogBandVB.isNull() ||
+      !mMatInstance)
+      return;
+
+   mMatrixSet->setSceneView(GFX->getWorldMatrix());
+   mMatrixSet->setSceneProjection(GFX->getProjectionMatrix());
+
+   ObjectRenderInst* ri = state->getRenderPass()->allocInst<ObjectRenderInst>();
+   ri->renderDelegate.bind(this, &SkySphere::_renderObject);
+   ri->type = RenderPassManager::RIT_Sky;
+   ri->defaultKey = 10;
+   ri->defaultKey2 = 0;
+   state->getRenderPass()->addInst(ri);
+}
+
+void SkySphere::_renderObject(ObjectRenderInst* ri, SceneRenderState* state, BaseMatInstance* mi)
+{
+   GFXDEBUGEVENT_SCOPE(SkySphere_RenderObject, ColorI::WHITE);
+
+   GFXTransformSaver saver;
+   GFX->setVertexBuffer(mVB);
+
+   MatrixF worldMat = MatrixF::Identity;
+   worldMat.setPosition(Point3F(
+      state->getCameraPosition().x,
+      state->getCameraPosition().y,
+      state->getCameraPosition().z));
+
+   SceneData sgData;
+   sgData.init(state);
+   sgData.objTrans = &worldMat;
+
+   mMatrixSet->restoreSceneViewProjection();
+   mMatrixSet->setWorld(worldMat);
+   if (state->isReflectPass())
+      mMatrixSet->setProjection(state->getSceneManager()->getNonClipProjection());
+
+   while (mMatInstance->setupPass(state, sgData))
+   {
+      mMatInstance->setTransforms(*mMatrixSet, state);
+      mMatInstance->setSceneInfo(state, sgData);
+
+      GFX->drawPrimitive(GFXTriangleList, 0, mPrimCount);
+   }
+
+   // Draw render band.
+   if (mFogBandHeight > 0 && mFogBandMatInst)
+   {
+      const FogData& fog = state->getSceneManager()->getFogData();
+      if (mLastFogColor != fog.color)
+      {
+         mLastFogColor = fog.color;
+         _initRender();
+      }
+
+      // Just need it to follow the camera... no rotation.
+      MatrixF camPosMat(MatrixF::Identity);
+      camPosMat.setPosition(worldMat.getPosition());
+      sgData.objTrans = &camPosMat;
+      mMatrixSet->setWorld(*sgData.objTrans);
+
+      while (mFogBandMatInst->setupPass(state, sgData))
+      {
+         mFogBandMatInst->setTransforms(*mMatrixSet, state);
+         mFogBandMatInst->setSceneInfo(state, sgData);
+
+         GFX->setVertexBuffer(mFogBandVB);
+         GFX->drawPrimitive(GFXTriangleList, 0, mFogPrimCount);
+      }
+   }
+}
+
+void SkySphere::clearVectors()
+{
+   tmpVertices.clear();
+   finalFogVertex.clear();
+   tempFogVertex.clear();
+   colVec.clear();
+   fogVerts.clear();
+   vertsVec.clear();
+   normsVec.clear();
+   texCoordVec.clear();
+   finalVertData.clear();
+}
+
+void SkySphere::addVertex(Point3F vert)
+{
+   vertsVec.push_back(vert.x);
+   vertsVec.push_back(vert.y);
+   vertsVec.push_back(vert.z);
+}
+
+void SkySphere::addNormal(Point3F nor)
+{
+   normsVec.push_back(nor.x);
+   normsVec.push_back(nor.y);
+   normsVec.push_back(nor.z);
+}
+
+void SkySphere::addTexcoord(F32 s, F32 t)
+{
+   texCoordVec.push_back(s);
+   texCoordVec.push_back(t);
+}
+
+void SkySphere::addColor(ColorI col)
+{
+   colVec.push_back(col);
+}
+
+void SkySphere::BuildFinalVert()
+{
+   U32 count = vertsVec.size();
+   U32 i, j;
+   for (i = 0, j = 0; i < count; i += 3, j += 2)
+   {
+      FinalVertexData temp;
+      temp.pos.set(Point3F(vertsVec[i], vertsVec[i + 1], vertsVec[i + 2]));
+      temp.nor.set(Point3F(normsVec[i], normsVec[i + 1], normsVec[i + 2]));
+      temp.s = texCoordVec[j];
+      temp.t = texCoordVec[j+1];
+
+      finalVertData.push_back(temp);
+   }
+}
+
+void SkySphere::BuildFinalFogVert()
+{
+   U32 count = vertsVec.size();
+   U32 i, j;
+   for (i = 0, j = 0; i < count; i+=3, j++ )
+   {
+      FogVertex temp;
+      temp.pos.set(Point3F(vertsVec[i], vertsVec[i + 1], vertsVec[i + 2]));
+      temp.col = colVec[j];
+
+      finalFogVertex.push_back(temp);
+   }
+}
+
+void SkySphere::_initRender()
+{
+   U32 rings = 32;
+   U32 height = 16;
+   U32 radius = 1;
+
+   F32 x, y, z, xy;                              // vertex position
+   F32 nx, ny, nz, lengthInv = 1.0f / radius;       // normal
+   F32 s, t;                                     // texCoord
+
+   F32 ringStep = M_2PI / rings;
+   F32 heightStep = M_PI / height; // M_HALFPI for dome.
+   F32 ringAng, heightAng;
+
+   //clear vecs
+   clearVectors();
+
+   for (U32 i = 0; i <= height; ++i)
+   {
+      heightAng = M_PI / 2 - (F32)i * heightStep;
+      F32 xy = radius * mCos(heightAng);
+      F32 z = radius * mSin(heightAng);
+
+      for (U32 j = 0; j <= rings; ++j)
+      {
+         SphereVertex vert;
+         ringAng = j * ringStep;
+         x = xy * mCos(ringAng);
+         y = xy * mSin(ringAng);
+         vert.pos.set(Point3F(x,y,z));
+
+         nx = x * lengthInv;
+         ny = y * lengthInv;
+         nz = z * lengthInv;
+         vert.nor.set(Point3F(nx, ny, nz));
+
+         s = (F32)j / rings;
+         t = (F32)i / height;
+         vert.s = s;
+         vert.t = t;
+
+         tmpVertices.push_back(vert);
+      }
+   }
+
+   SphereVertex v1, v2, v3, v4;
+   U32 vi1, vi2 = 0;
+
+   for (U32 i = 0; i < height; ++i)
+   {
+      vi1 = i * (rings + 1);
+      vi2 = (i + 1) * (rings + 1);
+
+      for (U32 j = 0; j < rings; ++j, ++vi1, ++vi2)
+      {
+         v1 = tmpVertices[vi1];
+         v2 = tmpVertices[vi2];
+         v3 = tmpVertices[vi1 + 1];
+         v4 = tmpVertices[vi2 + 1];
+
+         // 1st = triangle.
+         if (i == 0)
+         {
+            // verts for tri.
+            addVertex(v1.pos);
+            addVertex(v2.pos);
+            addVertex(v4.pos);
+
+            // texcoords for tri.
+            addTexcoord(v1.s, v1.t);
+            addTexcoord(v2.s, v2.t);
+            addTexcoord(v4.s, v4.t);
+
+            // normals for tri.
+            addNormal(v1.nor);
+            addNormal(v2.nor);
+            addNormal(v4.nor);
+         }
+         else if (i == (height - 1))
+         {
+            // verts for tri.
+            addVertex(v1.pos);
+            addVertex(v2.pos);
+            addVertex(v3.pos);
+
+            // texcoords for tri.
+            addTexcoord(v1.s, v1.t);
+            addTexcoord(v2.s, v2.t);
+            addTexcoord(v3.s, v3.t);
+
+            // normals for quad.
+            addNormal(v1.nor);
+            addNormal(v2.nor);
+            addNormal(v3.nor);
+         }
+         else
+         {
+            // verts for quad.
+            addVertex(v1.pos);
+            addVertex(v2.pos);
+            addVertex(v3.pos);
+
+            addVertex(v3.pos);
+            addVertex(v4.pos);
+            addVertex(v2.pos);
+
+            // texcoords for quad.
+            addTexcoord(v1.s, v1.t);
+            addTexcoord(v2.s, v2.t);
+            addTexcoord(v3.s, v3.t);
+
+            addTexcoord(v3.s, v3.t);
+            addTexcoord(v4.s, v4.t);
+            addTexcoord(v2.s, v2.t);
+
+            // normals for quad.
+            addNormal(v1.nor);
+            addNormal(v2.nor);
+            addNormal(v3.nor);
+
+            addNormal(v3.nor);
+            addNormal(v4.nor);
+            addNormal(v2.nor);
+         }
+      }
+   }
+
+   BuildFinalVert();
+
+   GFXVertexPNT* tmpVerts = NULL;
+   U32 vertCount = finalVertData.size();
+   tmpVerts = new GFXVertexPNT[(vertCount)];
+   mPrimCount = vertCount / 3;
+
+   for (U32 i = 0; i < vertCount; i++)
+   {
+      tmpVerts[i].point.set(finalVertData[i].pos);
+      tmpVerts[i].normal.set(finalVertData[i].nor);
+      tmpVerts[i].texCoord.set(finalVertData[i].s, finalVertData[i].t);
+   }
+
+   if (mVB.isNull() || mIsVBDirty)
+   {
+      mVB.set(GFX, vertCount, GFXBufferTypeStatic);
+      mIsVBDirty = false;
+   }
+
+   GFXVertexPNT* vertPtr = mVB.lock();
+   if (!vertPtr)
+   {
+      delete[] tmpVerts;
+      return;
+   }
+
+   dMemcpy(vertPtr, tmpVerts, sizeof(GFXVertexPNT) * vertCount);
+
+   mVB.unlock();
+
+   // Clean up temp verts.
+   delete[] tmpVerts;
+
+   // Grab the fog color.
+   ColorI fogColor(mLastFogColor.red * 255, mLastFogColor.green * 255, mLastFogColor.blue * 255);
+   ColorI fogColorAlpha(mLastFogColor.red * 255, mLastFogColor.green * 255, mLastFogColor.blue * 255, 0);
+
+   clearVectors();
+
+   U32 stepCount = 16;
+   F32 cylStep = M_2PI / stepCount;
+   F32 cylAngle;
+   F32 cylRadius = 10;
+
+   for (U32 i = 0; i <= stepCount; ++i)
+   {
+      cylAngle = (F32)i * cylStep;
+      fogVerts.push_back(mCos(cylAngle));
+      fogVerts.push_back(mSin(cylAngle));
+   }
+
+   for (U32 i = 0; i < 2; ++i)
+   {
+      for (U32 j = 0, k = 0; j <= stepCount; ++j, k += 2)
+      {
+         FogVertex temp;
+         F32 ux = fogVerts[k];
+         F32 uy = fogVerts[k+1];
+
+         if (i > 0)
+         {
+            temp.pos.set(Point3F((ux * cylRadius), (uy * cylRadius), mFogBandHeight));
+            temp.col = fogColorAlpha;
+         }
+         else
+         {
+            temp.pos.set(Point3F((ux * cylRadius), (uy * cylRadius), -mFogBandHeight));
+            temp.col = fogColor;
+         }
+
+         tempFogVertex.push_back(temp);
+      }
+   }
+
+   FogVertex f1, f2, f3, f4;
+   U32 k1 = 0;
+   U32 k2 = stepCount + 1;
+
+   for (U32 i = 0; i < stepCount; ++i, ++k1, ++k2)
+   {
+      f1 = tempFogVertex[k1];
+      f2 = tempFogVertex[k1 + 1];
+      f3 = tempFogVertex[k2];
+      f4 = tempFogVertex[k2 + 1];
+      addVertex(f3.pos);
+      addVertex(f2.pos);
+      addVertex(f4.pos);
+      addColor(f3.col);
+      addColor(f2.col);
+      addColor(f4.col);
+      addVertex(f1.pos);
+      addVertex(f2.pos);
+      addVertex(f3.pos);
+      addColor(f1.col);
+      addColor(f2.col);
+      addColor(f3.col);
+   }
+
+   BuildFinalFogVert();
+
+   U32 fogVertCount = finalFogVertex.size();
+   mFogPrimCount = fogVertCount / 3;
+
+   if (mFogBandVB.isNull())
+      mFogBandVB.set(GFX, fogVertCount, GFXBufferTypeStatic);
+
+   GFXVertexPC* bandVertPtr = mFogBandVB.lock();
+   if (!bandVertPtr) return;
+      
+   for (U32 i = 0; i < fogVertCount; i++)
+   {
+      bandVertPtr[i].point.set(finalFogVertex[i].pos);
+      bandVertPtr[i].color.set(finalFogVertex[i].col);
+   }
+
+   mFogBandVB.unlock();
+
+   SAFE_DELETE(mFogBandMatInst);
+   if (mFogBandMat)
+   {
+      mFogBandMat->deleteObject();
+      mFogBandMat = NULL;
+   }
+
+   // Setup the material for this imposter.
+   mFogBandMat = MATMGR->allocateAndRegister(String::EmptyString);
+   mFogBandMat->mAutoGenerated = true;
+   mFogBandMat->mTranslucent = true;
+   mFogBandMat->mVertColor[0] = true;
+   mFogBandMat->mDoubleSided = true;
+   mFogBandMat->mEmissive[0] = true;
+
+   FeatureSet features = MATMGR->getDefaultFeatures();
+   features.addFeature(MFT_isBackground);
+   mFogBandMatInst = mFogBandMat->createMatInstance();
+   mFogBandMatInst->init(features, getGFXVertexFormat<GFXVertexPC>());
+}
+
+void SkySphere::onStaticModified(const char* slotName, const char* newValue)
+{
+   Parent::onStaticModified(slotName, newValue);
+
+   if (dStricmp(slotName, "material") == 0)
+      setMaskBits(0xFFFFFFFF);
+}
+
+void SkySphere::_initMaterial()
+{
+   if (mMatInstance)
+      SAFE_DELETE(mMatInstance);
+
+   if (mMaterial)
+      mMatInstance = mMaterial->createMatInstance();
+   else
+      mMatInstance = MATMGR->createMatInstance("WarningMaterial");
+
+   // We want to disable culling and z write.
+   GFXStateBlockDesc desc;
+   desc.setCullMode(GFXCullNone);
+   desc.setBlend(true);
+   desc.setZReadWrite(true, false);
+   desc.zFunc = GFXCmpLessEqual;
+   mMatInstance->addStateBlockDesc(desc);
+
+   // Also disable lighting on the skysphere material by default.
+   FeatureSet features = MATMGR->getDefaultFeatures();
+   features.removeFeature(MFT_RTLighting);
+   features.removeFeature(MFT_Visibility);
+   features.addFeature(MFT_isBackground);
+
+   // Now initialize the material.
+   mMatInstance->init(features, getGFXVertexFormat<GFXVertexPNT>());
+}
+
+void SkySphere::_updateMaterial()
+{
+   if (!getMaterialResource().isValid())
+   {
+      //If our materialDef isn't valid, try setting it
+      _setMaterial(getMaterial());
+   }
+
+   if (getMaterialResource().isValid())
+   {
+      _initMaterial();
+   }
+}
+
+BaseMatInstance* SkySphere::_getMaterialInstance()
+{
+   if (!mMaterial || !mMatInstance || mMatInstance->getMaterial() != mMaterial)
+      _initMaterial();
+
+   if (!mMatInstance)
+      return NULL;
+
+   return mMatInstance;
+}
+
+DefineEngineMethod(SkySphere, postApply, void, (), , "")
+{
+   object->inspectPostApply();
+}
diff --git a/Engine/source/environment/skySphere.h b/Engine/source/environment/skySphere.h
new file mode 100644
index 000000000..37a6fbd12
--- /dev/null
+++ b/Engine/source/environment/skySphere.h
@@ -0,0 +1,172 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2012 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+
+#ifndef _SKYSPHERE_H_
+#define _SKYSPHERE_H_
+
+#ifndef _SCENEOBJECT_H_
+#include "scene/sceneObject.h"
+#endif
+
+#ifndef _GFXDEVICE_H_
+#include "gfx/gfxDevice.h"
+#endif
+
+#ifndef _CUBEMAPDATA_H_
+#include "gfx/sim/cubemapData.h"
+#endif
+
+#ifndef _MATERIALLIST_H_
+#include "materials/materialList.h"
+#endif
+
+#ifndef _GFXVERTEXBUFFER_H_
+#include "gfx/gfxVertexBuffer.h"
+#endif
+
+#ifndef _GFXPRIMITIVEBUFFER_H_
+#include "gfx/gfxPrimitiveBuffer.h"
+#endif
+
+#include "T3D/assets/MaterialAsset.h"
+
+struct SkyMatParams
+{
+   void init(BaseMatInstance* matInst) {};
+};
+
+class MatrixSet;
+
+class SkySphere : public SceneObject
+{
+   typedef SceneObject Parent;
+
+public:
+
+   SkySphere();
+   virtual ~SkySphere();
+
+   DECLARE_CONOBJECT(SkySphere);
+
+   // SimObject
+   void onStaticModified(const char* slotName, const char* newValue);
+
+   // ConsoleObject
+   virtual bool onAdd();
+   virtual void onRemove();
+   static void initPersistFields();
+   virtual void inspectPostApply();
+
+   // NetObject
+   virtual U32 packUpdate(NetConnection* conn, U32 mask, BitStream* stream);
+   virtual void unpackUpdate(NetConnection* conn, BitStream* stream);
+
+   // SceneObject
+   void prepRenderImage(SceneRenderState* state);
+
+   /// Our render delegate.
+   void _renderObject(ObjectRenderInst* ri, SceneRenderState* state, BaseMatInstance* mi);
+
+   void clearVectors();
+
+   void addVertex(Point3F vert);
+
+   void addNormal(Point3F nor);
+
+   void addTexcoord(F32 s, F32 t);
+
+   void addColor(ColorI col);
+
+   void BuildFinalVert();
+
+   void BuildFinalFogVert();
+
+   /// Prepares rendering structures and geometry.
+   void _initRender();
+
+   struct SphereVertex
+   {
+      Point3F pos;
+      Point3F nor;
+      F32 s, t;
+   };
+
+   Vector<SphereVertex> tmpVertices;
+   Vector<F32> vertsVec;
+   Vector<F32> texCoordVec;
+   Vector<F32> normsVec;
+
+   struct FinalVertexData
+   {
+      Point3F pos;
+      Point3F nor;
+      F32 s;
+      F32 t;
+   };
+
+   Vector<FinalVertexData> finalVertData;
+
+   struct FogVertex
+   {
+      // might need normals for smoothing.
+      Point3F pos;
+      ColorI col;
+   };
+
+   Vector<FogVertex> finalFogVertex;
+   Vector<FogVertex> tempFogVertex;
+   Vector<ColorI> colVec;
+   Vector<F32> fogVerts;
+
+protected:
+
+   // Material
+   DECLARE_MATERIALASSET(SkySphere, Material);
+   DECLARE_ASSET_NET_SETGET(SkySphere, Material, -1);
+
+   BaseMatInstance* mMatInstance;
+   SkyMatParams mMatParamHandle;
+
+   GFXVertexBufferHandle<GFXVertexPNT> mVB;
+
+   GFXVertexBufferHandle<GFXVertexPC> mFogBandVB;
+   Material* mFogBandMat;
+   BaseMatInstance* mFogBandMatInst;
+
+   LinearColorF mLastFogColor;
+
+   bool mIsVBDirty;
+   U32 mPrimCount;
+
+   MatrixSet* mMatrixSet;
+
+   F32 mFogBandHeight;
+   U32 mFogPrimCount;
+
+   void _updateMaterial();
+   void _initMaterial();
+
+   BaseMatInstance* _getMaterialInstance();
+
+};
+
+#endif
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript
index 26bc7202b..803a5933a 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript
@@ -26,6 +26,7 @@ function AssetBrowser::loadCreatorClasses(%this)
       %this.addCreatorClass( "RibbonNode",         "Ribbon Emitter" );
       %this.addCreatorClass( "ScatterSky",         "Scatter Sky" );
       %this.addCreatorClass( "SkyBox",             "Sky Box" );
+      %this.addCreatorClass( "SkySphere",          "Sky Sphere" );
       %this.addCreatorClass( "SFXEmitter",         "Sound Emitter" );
       %this.addCreatorClass( "TerrainBlock",       "Terrain Block" );
       %this.addCreatorClass( "VolumetricFog",      "Volumetric Fog" );
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/editors/creator.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/editors/creator.ed.tscript
index 7ec1015a7..9524a7849 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/editors/creator.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/editors/creator.ed.tscript
@@ -37,6 +37,7 @@ function ObjectCreator::init( %this )
       // Removed Prefab as there doesn't really seem to be a point in creating a blank one
       //%this.registerMissionObject( "Prefab",              "Prefab" );
       %this.registerMissionObject( "SkyBox",              "Sky Box" );
+      %this.registerMissionObject( "SkySphere",           "Sky Sphere" );
       %this.registerMissionObject( "CloudLayer",          "Cloud Layer" );
       %this.registerMissionObject( "BasicClouds",         "Basic Clouds" );
       %this.registerMissionObject( "ScatterSky",          "Scatter Sky" );

From bbf92846c21f5abc45d7989d6bed098df373d1a4 Mon Sep 17 00:00:00 2001
From: marauder2k7 <ctrl-intelligence@live.co.uk>
Date: Tue, 8 Mar 2022 19:52:47 +0000
Subject: [PATCH 326/399] Update scatterSky.cpp

---
 Engine/source/environment/scatterSky.cpp | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/Engine/source/environment/scatterSky.cpp b/Engine/source/environment/scatterSky.cpp
index 12071d558..8b5f69a7b 100644
--- a/Engine/source/environment/scatterSky.cpp
+++ b/Engine/source/environment/scatterSky.cpp
@@ -1047,14 +1047,6 @@ void ScatterSky::_render( ObjectRenderInst *ri, SceneRenderState *state, BaseMat
    xform *= GFX->getViewMatrix();
    xform *=  GFX->getWorldMatrix();
 
-   if(state->isReflectPass())
-   {
-      static MatrixF rotMat(EulerF(0.0, 0.0, M_PI_F));
-      xform.mul(rotMat);
-      rotMat.set(EulerF(M_PI_F, 0.0, 0.0));
-      xform.mul(rotMat);
-   }
-
    mShaderConsts->setSafe( mModelViewProjSC, xform );
    mShaderConsts->setSafe( mMiscSC, miscParams );
    mShaderConsts->setSafe( mSphereRadiiSC, sphereRadii );

From 382ee60d8616331564b7cb125e4fda55c85e102d Mon Sep 17 00:00:00 2001
From: marauder2k7 <ctrl-intelligence@live.co.uk>
Date: Tue, 8 Mar 2022 20:18:47 +0000
Subject: [PATCH 327/399] Sky Sorting

-Change: ScatterSky is always drawn behind other sky objects (since it has sun and moon)
---
 Engine/source/environment/scatterSky.cpp | 4 ++--
 Engine/source/environment/skyBox.cpp     | 2 +-
 Engine/source/environment/skySphere.cpp  | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Engine/source/environment/scatterSky.cpp b/Engine/source/environment/scatterSky.cpp
index 8b5f69a7b..e7472973b 100644
--- a/Engine/source/environment/scatterSky.cpp
+++ b/Engine/source/environment/scatterSky.cpp
@@ -651,7 +651,7 @@ void ScatterSky::prepRenderImage( SceneRenderState *state )
    ObjectRenderInst *ri = renderPass->allocInst<ObjectRenderInst>();
    ri->renderDelegate.bind( this, &ScatterSky::_render );
    ri->type = RenderPassManager::RIT_Sky;
-   ri->defaultKey = 10;
+   ri->defaultKey = 15;
    ri->defaultKey2 = 0;
    renderPass->addInst(ri);
 
@@ -700,7 +700,7 @@ void ScatterSky::prepRenderImage( SceneRenderState *state )
 	  moonRI->renderDelegate.bind( this, &ScatterSky::_renderMoon );
 	  moonRI->type = RenderPassManager::RIT_Sky;
       // Render after sky objects and before CloudLayer!
-	  moonRI->defaultKey = 5;
+	  moonRI->defaultKey = 10;
 	  moonRI->defaultKey2 = 0;
       renderPass->addInst(moonRI);
    }
diff --git a/Engine/source/environment/skyBox.cpp b/Engine/source/environment/skyBox.cpp
index 468ecb8dd..8bd378272 100644
--- a/Engine/source/environment/skyBox.cpp
+++ b/Engine/source/environment/skyBox.cpp
@@ -645,4 +645,4 @@ BaseMatInstance* SkyBox::_getMaterialInstance()
 DefineEngineMethod( SkyBox, postApply, void, (), , "")
 {
 	object->inspectPostApply();
-}
\ No newline at end of file
+}
diff --git a/Engine/source/environment/skySphere.cpp b/Engine/source/environment/skySphere.cpp
index 9f52c660c..a367b8854 100644
--- a/Engine/source/environment/skySphere.cpp
+++ b/Engine/source/environment/skySphere.cpp
@@ -182,7 +182,7 @@ void SkySphere::prepRenderImage(SceneRenderState* state)
    ObjectRenderInst* ri = state->getRenderPass()->allocInst<ObjectRenderInst>();
    ri->renderDelegate.bind(this, &SkySphere::_renderObject);
    ri->type = RenderPassManager::RIT_Sky;
-   ri->defaultKey = 10;
+   ri->defaultKey = 9;
    ri->defaultKey2 = 0;
    state->getRenderPass()->addInst(ri);
 }

From 4d336e9ecfdfcb039bd6e461270f667b16ae531c Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Tue, 8 Mar 2022 17:52:42 -0600
Subject: [PATCH 328/399] ensure MissionCleanup exists before .mis load

---
 .../clientServer/scripts/server/levelLoad.tscript   | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/Templates/BaseGame/game/core/clientServer/scripts/server/levelLoad.tscript b/Templates/BaseGame/game/core/clientServer/scripts/server/levelLoad.tscript
index 9bb2457ac..86e0d8b5f 100644
--- a/Templates/BaseGame/game/core/clientServer/scripts/server/levelLoad.tscript
+++ b/Templates/BaseGame/game/core/clientServer/scripts/server/levelLoad.tscript
@@ -86,6 +86,13 @@ function loadMissionStage2()
    // Create the mission group off the ServerGroup
    $instantGroup = ServerGroup;
 
+   // Mission cleanup group.  This is where run time components will reside.  The MissionCleanup
+   // group will be added to the ServerGroup.
+   new SimGroup( MissionCleanup );
+
+   // Make the MissionCleanup group the place where all new objects will automatically be added.
+   $instantGroup = MissionCleanup;
+   
    // Make sure the mission exists
    %file = $Server::MissionFile;
    
@@ -120,12 +127,6 @@ function loadMissionStage2()
    if( isObject( theLevelInfo ) )
       $Server::MissionName = theLevelInfo.levelName;
 
-   // Mission cleanup group.  This is where run time components will reside.  The MissionCleanup
-   // group will be added to the ServerGroup.
-   new SimGroup( MissionCleanup );
-
-   // Make the MissionCleanup group the place where all new objects will automatically be added.
-   $instantGroup = MissionCleanup;
    
    %hasGameMode = callGamemodeFunction("onCreateGame");
    

From 8dcd74ff1832fe83e2dfebb7641098caea6b3834 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Wed, 9 Mar 2022 18:21:47 -0600
Subject: [PATCH 329/399] point baseline fog color at the right target hen in
 deferred mode

---
 Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp | 2 ++
 Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp b/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
index 06d146c39..831808c76 100644
--- a/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
+++ b/Engine/source/shaderGen/GLSL/shaderFeatureGLSL.cpp
@@ -2318,6 +2318,8 @@ void FogFeatGLSL::processPix( Vector<ShaderComponent*> &componentList,
 	
    // Get the out color.
    Var *color = (Var*) LangElement::find(getOutputTargetVarName(ShaderFeature::DefaultTarget));
+   if (fd.features[MFT_isDeferred])
+      color = (Var *)LangElement::find(getOutputTargetVarName(ShaderFeature::RenderTarget1));
    if ( !color )
    {
       color = new Var;
diff --git a/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp b/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
index 7361e2eaf..d4e3acda4 100644
--- a/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
+++ b/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
@@ -2396,6 +2396,8 @@ void FogFeatHLSL::processPix( Vector<ShaderComponent*> &componentList,
 
    // Get the out color.
    Var *color = (Var*) LangElement::find(getOutputTargetVarName(ShaderFeature::DefaultTarget));
+   if (fd.features[MFT_isDeferred])
+      color = (Var *)LangElement::find(getOutputTargetVarName(ShaderFeature::RenderTarget1));
    if ( !color )
    {
       color = new Var;

From 23b908da56c9369446dcd99d23287538c8691d0e Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Tue, 15 Mar 2022 19:26:37 -0500
Subject: [PATCH 330/399] crashfix and projection fix for spotlights with
 cookies

---
 .../lighting/advanced/gl/spotLightP.glsl      | 24 +++++++-------
 .../shaders/lighting/advanced/spotLightP.hlsl | 31 +++++++++----------
 2 files changed, 27 insertions(+), 28 deletions(-)

diff --git a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/spotLightP.glsl b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/spotLightP.glsl
index 6c80cc1eb..5d0079afa 100644
--- a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/spotLightP.glsl
+++ b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/gl/spotLightP.glsl
@@ -96,6 +96,8 @@ void main()
 	if(dist < lightRange)
    {
       SurfaceToLight surfaceToLight = createSurfaceToLight(surface, L);
+      vec3 lightCol = lightColor.rgb;
+      
       #ifdef NO_SHADOW   
          float shadowed = 1.0;      	
       #else
@@ -107,20 +109,18 @@ void main()
          //distance to light in shadow map space
          float distToLight = pxlPosLightProj.z / lightRange;
          float shadowed = softShadow_filter(shadowMap, ssPos.xy/ssPos.w, shadowCoord, shadowSoftness, distToLight, surfaceToLight.NdotL, lightParams.y);
+         #ifdef USE_COOKIE_TEX
+            // Lookup the cookie sample.
+            vec4 cookie = texture(cookieMap, shadowCoord);
+            // Multiply the light with the cookie tex.
+            lightCol *= cookie.rgb;
+            // Use a maximum channel luminance to attenuate 
+            // the lighting else we get specular in the dark
+            // regions of the cookie texture.
+            lightCol *= max(cookie.r, max(cookie.g, cookie.b));
+         #endif
       #endif      
    
-      vec3 lightCol = lightColor.rgb;
-   #ifdef USE_COOKIE_TEX
-
-      // Lookup the cookie sample.
-      vec4 cookie = texture(cookieMap, tMul(worldToLightProj, -surfaceToLight.L));
-      // Multiply the light with the cookie tex.
-      lightCol *= cookie.rgb;
-      // Use a maximum channel luminance to attenuate 
-      // the lighting else we get specular in the dark
-      // regions of the cookie texture.
-      lightCol *= max(cookie.r, max(cookie.g, cookie.b));
-   #endif
 
    #ifdef DIFFUSE_LIGHT_VIZ
       float attenuation = getDistanceAtt(surfaceToLight.Lu, radius);
diff --git a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/spotLightP.hlsl b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/spotLightP.hlsl
index fb3d4aae0..15b4b4e37 100644
--- a/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/spotLightP.hlsl
+++ b/Templates/BaseGame/game/core/rendering/shaders/lighting/advanced/spotLightP.hlsl
@@ -43,7 +43,7 @@ TORQUE_UNIFORM_SAMPLER2D(shadowMap, 1);
 #ifdef USE_COOKIE_TEX
 
 /// The texture for cookie rendering.
-TORQUE_UNIFORM_SAMPLER2D(cookieMap, 3);
+TORQUE_UNIFORM_SAMPLER2D(cookieMap, 2);
 
 #endif
 TORQUE_UNIFORM_SAMPLER2D(colorBuffer, 5);
@@ -101,6 +101,8 @@ float4 main(   ConvexConnectP IN ) : SV_TARGET
 	if(dist < lightRange)
 	{     
       SurfaceToLight surfaceToLight = createSurfaceToLight(surface, L);
+      float3 lightCol = lightColor.rgb;
+      
       #ifdef NO_SHADOW   
          float shadowed = 1.0;      	
       #else
@@ -108,23 +110,20 @@ float4 main(   ConvexConnectP IN ) : SV_TARGET
          float4 pxlPosLightProj = mul( worldToLightProj, float4( surface.P, 1 ) );
          float2 shadowCoord = ( ( pxlPosLightProj.xy / pxlPosLightProj.w ) * 0.5 ) + float2( 0.5, 0.5 );
          shadowCoord.y = 1.0f - shadowCoord.y;
-
-          //distance to light in shadow map space
+         //distance to light in shadow map space
          float distToLight = pxlPosLightProj.z / lightRange;
          float shadowed = softShadow_filter(TORQUE_SAMPLER2D_MAKEARG(shadowMap), ssPos.xy, shadowCoord, shadowSoftness, distToLight, surfaceToLight.NdotL, lightParams.y);
-      #endif      
-
-      float3 lightCol = lightColor.rgb;
-   #ifdef USE_COOKIE_TEX
-      // Lookup the cookie sample.
-      float4 cookie = TORQUE_TEXCUBE(cookieMap, mul(worldToLightProj, -surfaceToLight.L));
-      // Multiply the light with the cookie tex.
-      lightCol *= cookie.rgb;
-      // Use a maximum channel luminance to attenuate 
-      // the lighting else we get specular in the dark
-      // regions of the cookie texture.
-      lightCol *= max(cookie.r, max(cookie.g, cookie.b));
-   #endif
+         #ifdef USE_COOKIE_TEX
+            // Lookup the cookie sample.
+            float4 cookie = TORQUE_TEX2D(cookieMap, shadowCoord);
+            // Multiply the light with the cookie tex.
+            lightCol *= cookie.rgb;
+            // Use a maximum channel luminance to attenuate 
+            // the lighting else we get specular in the dark
+            // regions of the cookie texture.
+            lightCol *= max(cookie.r, max(cookie.g, cookie.b));
+         #endif
+      #endif
 
    #ifdef DIFFUSE_LIGHT_VIZ
       float attenuation = getDistanceAtt(surfaceToLight.Lu, radius);

From 1496ffac6ec9f0b37d38475db5747aee27695b67 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Tue, 15 Mar 2022 21:10:55 -0500
Subject: [PATCH 331/399] Adds a systemCommand console utility function, which
 invokes the standard system() function call, and also has an optional
 callback return parameter.

---
 Engine/source/console/consoleFunctions.cpp | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/Engine/source/console/consoleFunctions.cpp b/Engine/source/console/consoleFunctions.cpp
index a4b50cfcc..099f7090d 100644
--- a/Engine/source/console/consoleFunctions.cpp
+++ b/Engine/source/console/consoleFunctions.cpp
@@ -2859,3 +2859,21 @@ DefineEngineFunction(getTimestamp, const char*, (), ,
 
    return returnBuffer;
 }
+
+#ifdef TORQUE_TOOLS
+DefineEngineFunction(systemCommand, S32, (const char* commandLineAction, const char* callBackFunction), , "", "")
+{
+   if (commandLineAction != "")
+   {
+      S32 result = system(commandLineAction);
+
+      if (callBackFunction != "" && callBackFunction[0])
+      {
+         if (Con::isFunction(callBackFunction))
+            Con::executef(callBackFunction, result);
+      }
+   }
+
+   return -1;
+}
+#endif

From b36776d56748c024a35d067faca4c8ab532bf65b Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Tue, 15 Mar 2022 21:17:37 -0500
Subject: [PATCH 332/399] Tweaks handling of "invisible" files, files which
 start with a ., effectively making them have no filename and only an
 extension. This allows the engine to actually process and work with such
 files.

---
 Engine/source/console/fileSystemFunctions.cpp | 9 +++++++++
 Engine/source/core/volume.cpp                 | 4 ----
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/Engine/source/console/fileSystemFunctions.cpp b/Engine/source/console/fileSystemFunctions.cpp
index eea26a984..010147af2 100644
--- a/Engine/source/console/fileSystemFunctions.cpp
+++ b/Engine/source/console/fileSystemFunctions.cpp
@@ -395,6 +395,15 @@ DefineEngineFunction(isFile, bool, ( const char* fileName ),,
    Con::expandScriptFilename(sgScriptFilenameBuffer, sizeof(sgScriptFilenameBuffer), cleanfilename.c_str());
 
    Torque::Path givenPath(Torque::Path::CompressPath(sgScriptFilenameBuffer));
+
+   if (givenPath.getFileName().isEmpty() && givenPath.getExtension().isNotEmpty())
+   {
+      //specially named or hidden files, like .gitignore parse incorrectly due to having
+      //"no" filename, so we adjust that
+      givenPath.setFileName(String(".") + givenPath.getExtension());
+      givenPath.setExtension("");
+   }
+
    return Torque::FS::IsFile(givenPath);
 }
 
diff --git a/Engine/source/core/volume.cpp b/Engine/source/core/volume.cpp
index d056ee331..c3243623a 100644
--- a/Engine/source/core/volume.cpp
+++ b/Engine/source/core/volume.cpp
@@ -750,10 +750,6 @@ S32 MountSystem::findByPattern( const Path &inBasePath, const String &inFilePatt
 
    while ( dir->read( &attrs ) )
    {
-      // skip hidden files
-      if ( attrs.name.c_str()[0] == '.' )
-         continue;
-
       String   name( attrs.name );
 
       if ( (attrs.flags & FileNode::Directory) && inRecursive )

From 532200ff4337aaca3f4dbcb9d9b6d10de3aaa2ca Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Thu, 17 Mar 2022 00:03:22 -0500
Subject: [PATCH 333/399] Changes the creation of new materials in the material
 editor to go through the new asset interface, which ensures the creation is
 standardized across the board.

---
 .../scripts/assetTypes/material.tscript       |  1 -
 .../scripts/materialEditor.ed.tscript         | 36 ++++---------------
 2 files changed, 6 insertions(+), 31 deletions(-)

diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
index 18305b920..3ea2a285b 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
@@ -14,7 +14,6 @@ function AssetBrowser::createMaterialAsset(%this)
       AssetName = %assetName;
       versionId = 1;
       materialDefinitionName = %assetName;
-      scriptFile = %assetName @ "." @ $TorqueScriptFileExtension;
       
       new Material(%assetName) {
       };
diff --git a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
index 882ec9dc2..56ac83a96 100644
--- a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
@@ -1971,39 +1971,15 @@ function MaterialEditorGui::save( %this )
 
 function MaterialEditorGui::createNewMaterial( %this )
 {
-   AssetBrowser_SelectModule.showDialog("MaterialEditorGui.pickedNewMaterialTargetModule");
-   AssetBrowser_SelectModuleWindow.selectWindow();
+   AssetBrowser.setupCreateNewAsset("MaterialAsset", AssetBrowser.selectedModule, "MaterialEditorGui.onCreateNewMaterialAsset");
 }
 
-function MaterialEditorGui::pickedNewMaterialTargetModule( %this, %module )
+function MaterialEditorGui::onCreateNewMaterialAsset(%this, %newAssetId)
 {
-   %moduleDef = ModuleDatabase.findModule(%module);
-   PE_EmitterEditor.targetModule = %module;
-   MaterialEditorGui.defaultMaterialFile = %moduleDef.ModulePath @ "/scripts/managedData/materials." @ $TorqueScriptFileExtension;
-
-   if(!isDirectory(filePath(MaterialEditorGui.defaultMaterialFile)))
-   {
-      AssetBrowser.dirHandler.createFolder(filePath(MaterialEditorGui.defaultMaterialFile));
-   }
-
-   %action = %this.createUndo(ActionCreateNewMaterial, "Create New Material");
-   %action.object = "";
-   
-   %material = getUniqueName( "newMaterial" );
-   new Material(%material) 
-   {
-      mapTo = "unmapped_mat";
-      parentGroup = RootGroup;
-   };
-   
-   %action.newMaterial = %material.getId();
-   %action.oldMaterial = MaterialEditorGui.currentMaterial;
-   
-   MaterialEditorGui.submitUndo( %action );
-   
-   MaterialEditorGui.currentObject = "";
-   MaterialEditorGui.setMode();
-   MaterialEditorGui.prepareActiveMaterial( %material.getId(), true );
+   //get the new asset definition
+   %assetDef = AssetDatabase.acquireAsset(%newAssetId);
+   if(isObject(%assetDef))
+      AssetBrowser.editMaterialAsset(%assetDef);
 }
 
 function MaterialEditorGui::deleteMaterial( %this )

From 2c999008f1f134509bc3798e6ee6a32661aac612 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Thu, 17 Mar 2022 02:43:18 -0500
Subject: [PATCH 334/399] Fixes and cleans up various issues and error spam for
 core and tools folders Also: Fixes error spam about CreatorIconArray Fixes
 error spam about duplicate uses of various materials Converts a number of
 materials to be packed into the mat assets for cleanliness and preventing
 unwanted duplicate exec's Removed some extraneous misconvert '.asset.taml'
 files Fixes 'cannot compile shader' error when trying to use the viz modes
 Fixed a some instances of guiControlProfiles not being actually defined Fixed
 some instances of guiControlProfiles being duplicated

---
 .../materials/BasicRibbonMat.asset.taml       |   7 +
 .../materials/BasicRibbonMat.tscript          |  27 ++
 .../DefaultDecalRoadMaterial.asset.taml       |  11 +-
 .../DefaultRoadMaterialOther.asset.taml       |  11 +-
 .../DefaultRoadMaterialTop.asset.taml         |  11 +-
 .../materials/TexturedRibbonMat.asset.taml    |   2 +-
 .../materials/TexturedRibbonMat.tscript       |  29 ++
 .../gameObjects/materials/materials.tscript   |  78 ----
 .../gameObjects/shapes/CameraMat.asset.taml   |  17 +-
 .../core/gameObjects/shapes/Green.asset.taml  |   7 -
 .../shapes/OctahedronMat.asset.taml           |  16 +-
 .../core/gameObjects/shapes/green.tscript     | 196 --------
 .../core/gameObjects/shapes/materials.tscript |  95 ----
 .../gameObjects/shapes/noshape.asset.taml     |   1 +
 .../shapes/noshape_NoShape.asset.taml         |   7 -
 .../shapes/noshapetext_lambert1.asset.taml    |   7 -
 .../shapes/noshapetext_noshape_mat.asset.taml |   7 -
 .../game/core/gui/scripts/profiles.tscript    |   8 +
 .../scripts/AL_ConvexLightState.asset.taml    |   7 -
 .../AL_DefaultDeferredMaterial.asset.taml     |   7 -
 .../AL_DefaultShadowMaterial.asset.taml       |   7 -
 .../AL_ParticlePointLightShader.asset.taml    |   7 -
 .../scripts/AL_SpotLightShader.asset.taml     |   7 -
 .../scripts/BL_ProjectedShadowRPM.asset.taml  |   7 -
 .../scripts/IrradianceShader.asset.taml       |   7 -
 .../images/WarningMaterial.asset.taml         |  14 +
 .../core/rendering/images/materials.tscript   |  32 --
 .../Blank_sky/BlankSkyMat.asset.taml          |   2 +-
 ...{materials.tscript => BlankSkyMat.tscript} |   0
 .../{ => NightSkybox}/NightSkyMat.asset.taml  |   2 +-
 .../materials/NightSkybox/NightSkyMat.tscript |  15 +
 .../NightSkybox_1.asset.taml                  |   0
 .../{ => NightSkybox}/NightSkybox_1.png       | Bin
 .../NightSkybox_2.asset.taml                  |   0
 .../{ => NightSkybox}/NightSkybox_2.png       | Bin
 .../NightSkybox_3.asset.taml                  |   0
 .../{ => NightSkybox}/NightSkybox_3.png       | Bin
 .../NightSkybox_4.asset.taml                  |   0
 .../{ => NightSkybox}/NightSkybox_4.png       | Bin
 .../NightSkybox_5.asset.taml                  |   0
 .../{ => NightSkybox}/NightSkybox_5.png       | Bin
 .../NightSkybox_6.asset.taml                  |   0
 .../{ => NightSkybox}/NightSkybox_6.png       | Bin
 .../rendering/materials/NoMaterial.asset.taml |  12 +-
 .../rendering/materials/NoMaterial.tscript    |   6 -
 .../rendering/materials/materials.tscript     |  65 ---
 .../materials/moon_noglow.asset.taml          |  15 +-
 .../materials/moon_noglowMat.asset.taml       |  14 +
 .../materials/moon_wcoronaMat.asset.taml      |  18 +
 .../rendering/materials/moon_wglow.asset.taml |  15 +-
 .../materials/moon_wglowMat.asset.taml        |  14 +
 .../core/rendering/shapes/materials.tscript   |  16 -
 .../rendering/shapes/noShapeMat.asset.taml    |  18 +
 .../core/rendering/shapes/noshape.asset.taml  |   1 +
 .../game/tools/base/images/Black.asset.taml   |  11 +-
 .../game/tools/base/images/Gray.asset.taml    |  11 +-
 .../game/tools/base/images/White.asset.taml   |  11 +-
 .../game/tools/base/images/materials.tscript  |  67 ---
 .../OccluderProxyMaterial.asset.taml          |   7 -
 .../PortalProxyMaterial.asset.taml            |   7 -
 .../TriggerProxyMaterial.asset.taml           |   7 -
 .../convexEditor/ZoneProxyMaterial.asset.taml |   7 -
 .../tools/convexEditor/convexEditor.tscript   |   7 -
 .../images/OccluderProxyMaterial.asset.taml   |  14 +
 .../images/PortalProxyMaterial.asset.taml     |  14 +
 .../images/TriggerProxyMaterial.asset.taml    |  14 +
 .../images/ZoneProxyMaterial.asset.taml       |  14 +
 .../game/tools/convexEditor/main.tscript      |   1 -
 .../game/tools/convexEditor/materials.tscript |  39 --
 .../game/tools/datablockEditor/.asset.taml    |   6 -
 Templates/BaseGame/game/tools/gui/.asset.taml |   6 -
 .../game/tools/gui/profiles.ed.tscript        |  24 +-
 Templates/BaseGame/game/tools/main.tscript    |   1 -
 .../game/tools/materialEditor/gui/.asset.taml |   6 -
 .../meshRoadEditor/meshRoadEditor.tscript     |   7 -
 .../game/tools/navEditor/navEditor.tscript    |   7 -
 .../ReflectProbePreviewMat.asset.taml         |  18 +
 .../game/tools/resources/materials.tscript    |   8 -
 .../tools/riverEditor/riverEditor.tscript     |  10 +-
 .../game/tools/roadEditor/roadEditor.tscript  |   7 -
 .../game/tools/shapeEditor/gui/.asset.taml    |   6 -
 .../game/tools/worldEditor/gui/.asset.taml    |   6 -
 .../gui/AL_ShadowVizOverlayCtrl.asset.taml    |   2 +-
 .../game/tools/worldEditor/main.tscript       |   3 -
 .../worldEditor/scripts/EditorGui.ed.tscript  |   2 +-
 .../scripts/editors/creator.ed.tscript        | 422 ------------------
 .../shaders/Viz_SurfacePropertiesP.hlsl       |   1 -
 87 files changed, 373 insertions(+), 1245 deletions(-)
 create mode 100644 Templates/BaseGame/game/core/gameObjects/materials/BasicRibbonMat.asset.taml
 create mode 100644 Templates/BaseGame/game/core/gameObjects/materials/BasicRibbonMat.tscript
 create mode 100644 Templates/BaseGame/game/core/gameObjects/materials/TexturedRibbonMat.tscript
 delete mode 100644 Templates/BaseGame/game/core/gameObjects/materials/materials.tscript
 delete mode 100644 Templates/BaseGame/game/core/gameObjects/shapes/Green.asset.taml
 delete mode 100644 Templates/BaseGame/game/core/gameObjects/shapes/green.tscript
 delete mode 100644 Templates/BaseGame/game/core/gameObjects/shapes/materials.tscript
 delete mode 100644 Templates/BaseGame/game/core/gameObjects/shapes/noshape_NoShape.asset.taml
 delete mode 100644 Templates/BaseGame/game/core/gameObjects/shapes/noshapetext_lambert1.asset.taml
 delete mode 100644 Templates/BaseGame/game/core/gameObjects/shapes/noshapetext_noshape_mat.asset.taml
 delete mode 100644 Templates/BaseGame/game/core/lighting/scripts/AL_ConvexLightState.asset.taml
 delete mode 100644 Templates/BaseGame/game/core/lighting/scripts/AL_DefaultDeferredMaterial.asset.taml
 delete mode 100644 Templates/BaseGame/game/core/lighting/scripts/AL_DefaultShadowMaterial.asset.taml
 delete mode 100644 Templates/BaseGame/game/core/lighting/scripts/AL_ParticlePointLightShader.asset.taml
 delete mode 100644 Templates/BaseGame/game/core/lighting/scripts/AL_SpotLightShader.asset.taml
 delete mode 100644 Templates/BaseGame/game/core/lighting/scripts/BL_ProjectedShadowRPM.asset.taml
 delete mode 100644 Templates/BaseGame/game/core/lighting/scripts/IrradianceShader.asset.taml
 create mode 100644 Templates/BaseGame/game/core/rendering/images/WarningMaterial.asset.taml
 delete mode 100644 Templates/BaseGame/game/core/rendering/images/materials.tscript
 rename Templates/BaseGame/game/core/rendering/materials/Blank_sky/{materials.tscript => BlankSkyMat.tscript} (100%)
 rename Templates/BaseGame/game/core/rendering/materials/{ => NightSkybox}/NightSkyMat.asset.taml (76%)
 create mode 100644 Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkyMat.tscript
 rename Templates/BaseGame/game/core/rendering/materials/{ => NightSkybox}/NightSkybox_1.asset.taml (100%)
 rename Templates/BaseGame/game/core/rendering/materials/{ => NightSkybox}/NightSkybox_1.png (100%)
 rename Templates/BaseGame/game/core/rendering/materials/{ => NightSkybox}/NightSkybox_2.asset.taml (100%)
 rename Templates/BaseGame/game/core/rendering/materials/{ => NightSkybox}/NightSkybox_2.png (100%)
 rename Templates/BaseGame/game/core/rendering/materials/{ => NightSkybox}/NightSkybox_3.asset.taml (100%)
 rename Templates/BaseGame/game/core/rendering/materials/{ => NightSkybox}/NightSkybox_3.png (100%)
 rename Templates/BaseGame/game/core/rendering/materials/{ => NightSkybox}/NightSkybox_4.asset.taml (100%)
 rename Templates/BaseGame/game/core/rendering/materials/{ => NightSkybox}/NightSkybox_4.png (100%)
 rename Templates/BaseGame/game/core/rendering/materials/{ => NightSkybox}/NightSkybox_5.asset.taml (100%)
 rename Templates/BaseGame/game/core/rendering/materials/{ => NightSkybox}/NightSkybox_5.png (100%)
 rename Templates/BaseGame/game/core/rendering/materials/{ => NightSkybox}/NightSkybox_6.asset.taml (100%)
 rename Templates/BaseGame/game/core/rendering/materials/{ => NightSkybox}/NightSkybox_6.png (100%)
 delete mode 100644 Templates/BaseGame/game/core/rendering/materials/NoMaterial.tscript
 delete mode 100644 Templates/BaseGame/game/core/rendering/materials/materials.tscript
 create mode 100644 Templates/BaseGame/game/core/rendering/materials/moon_noglowMat.asset.taml
 create mode 100644 Templates/BaseGame/game/core/rendering/materials/moon_wcoronaMat.asset.taml
 create mode 100644 Templates/BaseGame/game/core/rendering/materials/moon_wglowMat.asset.taml
 delete mode 100644 Templates/BaseGame/game/core/rendering/shapes/materials.tscript
 create mode 100644 Templates/BaseGame/game/core/rendering/shapes/noShapeMat.asset.taml
 delete mode 100644 Templates/BaseGame/game/tools/base/images/materials.tscript
 delete mode 100644 Templates/BaseGame/game/tools/convexEditor/OccluderProxyMaterial.asset.taml
 delete mode 100644 Templates/BaseGame/game/tools/convexEditor/PortalProxyMaterial.asset.taml
 delete mode 100644 Templates/BaseGame/game/tools/convexEditor/TriggerProxyMaterial.asset.taml
 delete mode 100644 Templates/BaseGame/game/tools/convexEditor/ZoneProxyMaterial.asset.taml
 create mode 100644 Templates/BaseGame/game/tools/convexEditor/images/OccluderProxyMaterial.asset.taml
 create mode 100644 Templates/BaseGame/game/tools/convexEditor/images/PortalProxyMaterial.asset.taml
 create mode 100644 Templates/BaseGame/game/tools/convexEditor/images/TriggerProxyMaterial.asset.taml
 create mode 100644 Templates/BaseGame/game/tools/convexEditor/images/ZoneProxyMaterial.asset.taml
 delete mode 100644 Templates/BaseGame/game/tools/convexEditor/materials.tscript
 delete mode 100644 Templates/BaseGame/game/tools/datablockEditor/.asset.taml
 delete mode 100644 Templates/BaseGame/game/tools/gui/.asset.taml
 delete mode 100644 Templates/BaseGame/game/tools/materialEditor/gui/.asset.taml
 create mode 100644 Templates/BaseGame/game/tools/resources/ReflectProbePreviewMat.asset.taml
 delete mode 100644 Templates/BaseGame/game/tools/resources/materials.tscript
 delete mode 100644 Templates/BaseGame/game/tools/shapeEditor/gui/.asset.taml
 delete mode 100644 Templates/BaseGame/game/tools/worldEditor/gui/.asset.taml

diff --git a/Templates/BaseGame/game/core/gameObjects/materials/BasicRibbonMat.asset.taml b/Templates/BaseGame/game/core/gameObjects/materials/BasicRibbonMat.asset.taml
new file mode 100644
index 000000000..1a26742d6
--- /dev/null
+++ b/Templates/BaseGame/game/core/gameObjects/materials/BasicRibbonMat.asset.taml
@@ -0,0 +1,7 @@
+<MaterialAsset
+    canSave="true"
+    canSaveDynamicFields="true"
+    AssetName="BasicRibbonMat"
+    scriptFile="@assetFile=BasicRibbonMat.tscript"
+    materialDefinitionName="BasicRibbonMat"
+    VersionId="1" />
diff --git a/Templates/BaseGame/game/core/gameObjects/materials/BasicRibbonMat.tscript b/Templates/BaseGame/game/core/gameObjects/materials/BasicRibbonMat.tscript
new file mode 100644
index 000000000..ec38f71f4
--- /dev/null
+++ b/Templates/BaseGame/game/core/gameObjects/materials/BasicRibbonMat.tscript
@@ -0,0 +1,27 @@
+singleton ShaderData( BasicRibbonShader )
+{
+   DXVertexShaderFile   = $Core::CommonShaderPath @ "/ribbons/basicRibbonShaderV.hlsl";
+   DXPixelShaderFile    = $Core::CommonShaderPath @ "/ribbons/basicRibbonShaderP.hlsl";
+ 
+   OGLVertexShaderFile   = $Core::CommonShaderPath @ "/ribbons/gl/basicRibbonShaderV.glsl";
+   OGLPixelShaderFile    = $Core::CommonShaderPath @ "/ribbons/gl/basicRibbonShaderP.glsl";
+ 
+   samplerNames[0] = "$ribTex";
+ 
+   pixVersion = 2.0;
+};
+ 
+singleton CustomMaterial( BasicRibbonMat )
+{
+   shader = BasicRibbonShader;
+   version = 2.0;
+   
+   emissive[0] = true;
+   
+   doubleSided = true;
+   translucent = true;
+   BlendOp = AddAlpha;
+   translucentBlendOp = AddAlpha;
+   
+   preload = true;
+};
\ No newline at end of file
diff --git a/Templates/BaseGame/game/core/gameObjects/materials/DefaultDecalRoadMaterial.asset.taml b/Templates/BaseGame/game/core/gameObjects/materials/DefaultDecalRoadMaterial.asset.taml
index 08f5506ba..94de6281a 100644
--- a/Templates/BaseGame/game/core/gameObjects/materials/DefaultDecalRoadMaterial.asset.taml
+++ b/Templates/BaseGame/game/core/gameObjects/materials/DefaultDecalRoadMaterial.asset.taml
@@ -2,6 +2,13 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="DefaultDecalRoadMaterial"
-    scriptFile="@assetFile=materials.tscript"
     materialDefinitionName="DefaultDecalRoadMaterial"
-    VersionId="1" />
+    VersionId="1">
+    <Material
+        Name="DefaultDecalRoadMaterial">
+        <Material.Stages>
+            <Stages_beginarray
+                DiffuseMapAsset="Core_GameObjects:defaultRoadTextureTop_image"/>
+        </Material.Stages>
+    </Material>
+</MaterialAsset>
diff --git a/Templates/BaseGame/game/core/gameObjects/materials/DefaultRoadMaterialOther.asset.taml b/Templates/BaseGame/game/core/gameObjects/materials/DefaultRoadMaterialOther.asset.taml
index 77164a8b5..d46bd21e3 100644
--- a/Templates/BaseGame/game/core/gameObjects/materials/DefaultRoadMaterialOther.asset.taml
+++ b/Templates/BaseGame/game/core/gameObjects/materials/DefaultRoadMaterialOther.asset.taml
@@ -2,6 +2,13 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="DefaultRoadMaterialOther"
-    scriptFile="@assetFile=materials.tscript"
     materialDefinitionName="DefaultRoadMaterialOther"
-    VersionId="1" />
+    VersionId="1">
+    <Material
+        Name="DefaultRoadMaterialOther">
+        <Material.Stages>
+            <Stages_beginarray
+                DiffuseMapAsset="Core_GameObjects:defaultRoadTextureOther_image"/>
+        </Material.Stages>
+    </Material>
+</MaterialAsset>
diff --git a/Templates/BaseGame/game/core/gameObjects/materials/DefaultRoadMaterialTop.asset.taml b/Templates/BaseGame/game/core/gameObjects/materials/DefaultRoadMaterialTop.asset.taml
index 14a1a15cd..397359da2 100644
--- a/Templates/BaseGame/game/core/gameObjects/materials/DefaultRoadMaterialTop.asset.taml
+++ b/Templates/BaseGame/game/core/gameObjects/materials/DefaultRoadMaterialTop.asset.taml
@@ -2,6 +2,13 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="DefaultRoadMaterialTop"
-    scriptFile="@assetFile=materials.tscript"
     materialDefinitionName="DefaultRoadMaterialTop"
-    VersionId="1" />
+    VersionId="1">
+    <Material
+        Name="DefaultRoadMaterialTop">
+        <Material.Stages>
+            <Stages_beginarray
+                DiffuseMapAsset="Core_GameObjects:defaultRoadTextureTop_image"/>
+        </Material.Stages>
+    </Material>
+</MaterialAsset>
diff --git a/Templates/BaseGame/game/core/gameObjects/materials/TexturedRibbonMat.asset.taml b/Templates/BaseGame/game/core/gameObjects/materials/TexturedRibbonMat.asset.taml
index 930268299..952588c7b 100644
--- a/Templates/BaseGame/game/core/gameObjects/materials/TexturedRibbonMat.asset.taml
+++ b/Templates/BaseGame/game/core/gameObjects/materials/TexturedRibbonMat.asset.taml
@@ -2,6 +2,6 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="TexturedRibbonMat"
-    scriptFile="@assetFile=materials.tscript"
+    scriptFile="@assetFile=TexturedRibbonMat.tscript"
     materialDefinitionName="TexturedRibbonMat"
     VersionId="1" />
diff --git a/Templates/BaseGame/game/core/gameObjects/materials/TexturedRibbonMat.tscript b/Templates/BaseGame/game/core/gameObjects/materials/TexturedRibbonMat.tscript
new file mode 100644
index 000000000..a04ee9ac4
--- /dev/null
+++ b/Templates/BaseGame/game/core/gameObjects/materials/TexturedRibbonMat.tscript
@@ -0,0 +1,29 @@
+singleton ShaderData( TexturedRibbonShader )
+{
+   DXVertexShaderFile   = $Core::CommonShaderPath @ "/ribbons/texRibbonShaderV.hlsl";
+   DXPixelShaderFile    = $Core::CommonShaderPath @ "/ribbons/texRibbonShaderP.hlsl";
+   
+   OGLVertexShaderFile   = $Core::CommonShaderPath @ "/ribbons/gl/texRibbonShaderV.glsl";
+   OGLPixelShaderFile    = $Core::CommonShaderPath @ "/ribbons/gl/texRibbonShaderP.glsl";
+   
+   samplerNames[0] = "$ribTex";
+   
+   pixVersion = 2.0;
+};
+ 
+singleton CustomMaterial( TexturedRibbonMat )
+{
+   shader = TexturedRibbonShader;
+   version = 2.0;
+   
+   emissive[0] = true;
+   
+   doubleSided = true;
+   translucent = true;
+   BlendOp = AddAlpha;
+   translucentBlendOp = AddAlpha;
+
+   sampler["ribTex"] = "core/gameObjects/images/ribTex.png";
+   
+   preload = true;
+};
\ No newline at end of file
diff --git a/Templates/BaseGame/game/core/gameObjects/materials/materials.tscript b/Templates/BaseGame/game/core/gameObjects/materials/materials.tscript
deleted file mode 100644
index 27ab97d94..000000000
--- a/Templates/BaseGame/game/core/gameObjects/materials/materials.tscript
+++ /dev/null
@@ -1,78 +0,0 @@
-singleton ShaderData( BasicRibbonShader )
-{
-   DXVertexShaderFile   = $Core::CommonShaderPath @ "/ribbons/basicRibbonShaderV.hlsl";
-   DXPixelShaderFile    = $Core::CommonShaderPath @ "/ribbons/basicRibbonShaderP.hlsl";
- 
-   OGLVertexShaderFile   = $Core::CommonShaderPath @ "/ribbons/gl/basicRibbonShaderV.glsl";
-   OGLPixelShaderFile    = $Core::CommonShaderPath @ "/ribbons/gl/basicRibbonShaderP.glsl";
- 
-   samplerNames[0] = "$ribTex";
- 
-   pixVersion = 2.0;
-};
- 
-singleton CustomMaterial( BasicRibbonMat )
-{
-   shader = BasicRibbonShader;
-   version = 2.0;
-   
-   emissive[0] = true;
-   
-   doubleSided = true;
-   translucent = true;
-   BlendOp = AddAlpha;
-   translucentBlendOp = AddAlpha;
-   
-   preload = true;
-};
-
-singleton ShaderData( TexturedRibbonShader )
-{
-   DXVertexShaderFile   = $Core::CommonShaderPath @ "/ribbons/texRibbonShaderV.hlsl";
-   DXPixelShaderFile    = $Core::CommonShaderPath @ "/ribbons/texRibbonShaderP.hlsl";
-   
-   OGLVertexShaderFile   = $Core::CommonShaderPath @ "/ribbons/gl/texRibbonShaderV.glsl";
-   OGLPixelShaderFile    = $Core::CommonShaderPath @ "/ribbons/gl/texRibbonShaderP.glsl";
-   
-   samplerNames[0] = "$ribTex";
-   
-   pixVersion = 2.0;
-};
- 
-singleton CustomMaterial( TexturedRibbonMat )
-{
-   shader = TexturedRibbonShader;
-   version = 2.0;
-   
-   emissive[0] = true;
-   
-   doubleSided = true;
-   translucent = true;
-   BlendOp = AddAlpha;
-   translucentBlendOp = AddAlpha;
-
-   sampler["ribTex"] = "core/gameObjects/images/ribTex.png";
-   
-   preload = true;
-};
-
-singleton Material(DefaultDecalRoadMaterial)
-{
-   diffuseMapAsset[0] = "Core_GameObjects:defaultRoadTextureTop_image";
-   mapTo = "unmapped_mat";
-   materialTag0 = "RoadAndPath";
-};
-
-singleton Material(DefaultRoadMaterialTop)
-{
-   mapTo = "unmapped_mat";
-   diffuseMapAsset[0] = "Core_GameObjects:defaultRoadTextureTop_image";
-   materialTag0 = "RoadAndPath";
-};
-
-singleton Material(DefaultRoadMaterialOther)
-{
-   mapTo = "unmapped_mat";
-   diffuseMapAsset[0] = "Core_GameObjects:defaultRoadTextureOther_image";
-   materialTag0 = "RoadAndPath";
-};
diff --git a/Templates/BaseGame/game/core/gameObjects/shapes/CameraMat.asset.taml b/Templates/BaseGame/game/core/gameObjects/shapes/CameraMat.asset.taml
index 2b85211c6..60c126d02 100644
--- a/Templates/BaseGame/game/core/gameObjects/shapes/CameraMat.asset.taml
+++ b/Templates/BaseGame/game/core/gameObjects/shapes/CameraMat.asset.taml
@@ -2,6 +2,19 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="CameraMat"
-    scriptFile="@assetFile=materials.tscript"
     materialDefinitionName="CameraMat"
-    VersionId="1" />
+    VersionId="1">
+    <Material
+        Name="CameraMat"
+        doubleSided="1"
+        translucent="1"
+        translucentBlendOp="LerpAlpha"
+        castShadows="0">
+        <Material.Stages>
+            <Stages_beginarray
+                DiffuseMapAsset="Core_GameObjects:camera_image"
+                diffuseColor="0 0.627451 1 1"
+                emissive="1"/>
+        </Material.Stages>
+    </Material>
+</MaterialAsset>
diff --git a/Templates/BaseGame/game/core/gameObjects/shapes/Green.asset.taml b/Templates/BaseGame/game/core/gameObjects/shapes/Green.asset.taml
deleted file mode 100644
index 4eaaebab9..000000000
--- a/Templates/BaseGame/game/core/gameObjects/shapes/Green.asset.taml
+++ /dev/null
@@ -1,7 +0,0 @@
-<MaterialAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="Green"
-    scriptFile="@assetFile=green"
-    materialDefinitionName="Green"
-    originalFilePath="D:/Gamedev/Projects/Catographer/GameBuild/Templates/BaseGame/game/core/gameObjects/shapes/green" />
diff --git a/Templates/BaseGame/game/core/gameObjects/shapes/OctahedronMat.asset.taml b/Templates/BaseGame/game/core/gameObjects/shapes/OctahedronMat.asset.taml
index 95227b6bb..9a877ebce 100644
--- a/Templates/BaseGame/game/core/gameObjects/shapes/OctahedronMat.asset.taml
+++ b/Templates/BaseGame/game/core/gameObjects/shapes/OctahedronMat.asset.taml
@@ -2,6 +2,18 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="OctahedronMat"
-    scriptFile="@assetFile=materials.tscript"
     materialDefinitionName="OctahedronMat"
-    VersionId="1" />
+    VersionId="1">
+    <Material
+        Name="OctahedronMat"
+        mapTo="green"
+        translucent="1"
+        translucentBlendOp="PreMul"
+        castShadows="0">
+        <Material.Stages>
+            <Stages_beginarray
+                DiffuseMapAsset="Core_GameObjects:camera_image"
+                diffuseColor="0 1 0 1"/>
+        </Material.Stages>
+    </Material>
+</MaterialAsset>
diff --git a/Templates/BaseGame/game/core/gameObjects/shapes/green.tscript b/Templates/BaseGame/game/core/gameObjects/shapes/green.tscript
deleted file mode 100644
index 9ea7a7bd0..000000000
--- a/Templates/BaseGame/game/core/gameObjects/shapes/green.tscript
+++ /dev/null
@@ -1,196 +0,0 @@
-//--- OBJECT WRITE BEGIN ---
-new Material(OctahedronMat) {
-   mapTo = "green";
-   diffuseColor[0] = "0 1 0 1";
-   diffuseColor[1] = "1 1 1 1";
-   diffuseColor[2] = "1 1 1 1";
-   diffuseColor[3] = "1 1 1 1";
-   DiffuseMap[0] = "core/gameObjects/images/camera";
-   diffuseMapSRGB[0] = "1";
-   diffuseMapSRGB[1] = "1";
-   diffuseMapSRGB[2] = "1";
-   diffuseMapSRGB[3] = "1";
-   detailScale[0] = "2 2";
-   detailScale[1] = "2 2";
-   detailScale[2] = "2 2";
-   detailScale[3] = "2 2";
-   detailNormalMapStrength[0] = "1";
-   detailNormalMapStrength[1] = "1";
-   detailNormalMapStrength[2] = "1";
-   detailNormalMapStrength[3] = "1";
-   roughness[0] = "1";
-   roughness[1] = "1";
-   roughness[2] = "1";
-   roughness[3] = "1";
-   metalness[0] = "0";
-   metalness[1] = "0";
-   metalness[2] = "0";
-   metalness[3] = "0";
-   glowMul[0] = "0";
-   glowMul[1] = "0";
-   glowMul[2] = "0";
-   glowMul[3] = "0";
-   accuEnabled[0] = "0";
-   accuEnabled[1] = "0";
-   accuEnabled[2] = "0";
-   accuEnabled[3] = "0";
-   accuScale[0] = "1";
-   accuScale[1] = "1";
-   accuScale[2] = "1";
-   accuScale[3] = "1";
-   accuDirection[0] = "1";
-   accuDirection[1] = "1";
-   accuDirection[2] = "1";
-   accuDirection[3] = "1";
-   accuStrength[0] = "0.6";
-   accuStrength[1] = "0.6";
-   accuStrength[2] = "0.6";
-   accuStrength[3] = "0.6";
-   accuCoverage[0] = "0.9";
-   accuCoverage[1] = "0.9";
-   accuCoverage[2] = "0.9";
-   accuCoverage[3] = "0.9";
-   accuSpecular[0] = "16";
-   accuSpecular[1] = "16";
-   accuSpecular[2] = "16";
-   accuSpecular[3] = "16";
-   isSRGB[0] = "0";
-   isSRGB[1] = "0";
-   isSRGB[2] = "0";
-   isSRGB[3] = "0";
-   invertRoughness[0] = "0";
-   invertRoughness[1] = "0";
-   invertRoughness[2] = "0";
-   invertRoughness[3] = "0";
-   roughnessChan[0] = "0";
-   roughnessChan[1] = "0";
-   roughnessChan[2] = "0";
-   roughnessChan[3] = "0";
-   AOChan[0] = "1";
-   AOChan[1] = "1";
-   AOChan[2] = "1";
-   AOChan[3] = "1";
-   metalChan[0] = "2";
-   metalChan[1] = "2";
-   metalChan[2] = "2";
-   metalChan[3] = "2";
-   glow[0] = "0";
-   glow[1] = "0";
-   glow[2] = "0";
-   glow[3] = "0";
-   parallaxScale[0] = "0";
-   parallaxScale[1] = "0";
-   parallaxScale[2] = "0";
-   parallaxScale[3] = "0";
-   useAnisotropic[0] = "1";
-   useAnisotropic[1] = "1";
-   useAnisotropic[2] = "1";
-   useAnisotropic[3] = "1";
-   vertLit[0] = "0";
-   vertLit[1] = "0";
-   vertLit[2] = "0";
-   vertLit[3] = "0";
-   vertColor[0] = "0";
-   vertColor[1] = "0";
-   vertColor[2] = "0";
-   vertColor[3] = "0";
-   minnaertConstant[0] = "-1";
-   minnaertConstant[1] = "-1";
-   minnaertConstant[2] = "-1";
-   minnaertConstant[3] = "-1";
-   subSurface[0] = "0";
-   subSurface[1] = "0";
-   subSurface[2] = "0";
-   subSurface[3] = "0";
-   subSurfaceColor[0] = "1 0.2 0.2 1";
-   subSurfaceColor[1] = "1 0.2 0.2 1";
-   subSurfaceColor[2] = "1 0.2 0.2 1";
-   subSurfaceColor[3] = "1 0.2 0.2 1";
-   subSurfaceRolloff[0] = "0.2";
-   subSurfaceRolloff[1] = "0.2";
-   subSurfaceRolloff[2] = "0.2";
-   subSurfaceRolloff[3] = "0.2";
-   emissive[0] = "0";
-   emissive[1] = "0";
-   emissive[2] = "0";
-   emissive[3] = "0";
-   foreground[0] = "0";
-   foreground[1] = "0";
-   foreground[2] = "0";
-   foreground[3] = "0";
-   doubleSided = "0";
-   animFlags[0] = "0x00000000";
-   animFlags[1] = "0x00000000";
-   animFlags[2] = "0x00000000";
-   animFlags[3] = "0x00000000";
-   scrollDir[0] = "0 0";
-   scrollDir[1] = "0 0";
-   scrollDir[2] = "0 0";
-   scrollDir[3] = "0 0";
-   scrollSpeed[0] = "0";
-   scrollSpeed[1] = "0";
-   scrollSpeed[2] = "0";
-   scrollSpeed[3] = "0";
-   rotSpeed[0] = "0";
-   rotSpeed[1] = "0";
-   rotSpeed[2] = "0";
-   rotSpeed[3] = "0";
-   rotPivotOffset[0] = "0 0";
-   rotPivotOffset[1] = "0 0";
-   rotPivotOffset[2] = "0 0";
-   rotPivotOffset[3] = "0 0";
-   waveType[0] = "Sin";
-   waveType[1] = "Sin";
-   waveType[2] = "Sin";
-   waveType[3] = "Sin";
-   waveFreq[0] = "0";
-   waveFreq[1] = "0";
-   waveFreq[2] = "0";
-   waveFreq[3] = "0";
-   waveAmp[0] = "0";
-   waveAmp[1] = "0";
-   waveAmp[2] = "0";
-   waveAmp[3] = "0";
-   sequenceFramePerSec[0] = "0";
-   sequenceFramePerSec[1] = "0";
-   sequenceFramePerSec[2] = "0";
-   sequenceFramePerSec[3] = "0";
-   sequenceSegmentSize[0] = "0";
-   sequenceSegmentSize[1] = "0";
-   sequenceSegmentSize[2] = "0";
-   sequenceSegmentSize[3] = "0";
-   cellIndex[0] = "0 0";
-   cellIndex[1] = "0 0";
-   cellIndex[2] = "0 0";
-   cellIndex[3] = "0 0";
-   cellLayout[0] = "0 0";
-   cellLayout[1] = "0 0";
-   cellLayout[2] = "0 0";
-   cellLayout[3] = "0 0";
-   cellSize[0] = "0";
-   cellSize[1] = "0";
-   cellSize[2] = "0";
-   cellSize[3] = "0";
-   bumpAtlas[0] = "0";
-   bumpAtlas[1] = "0";
-   bumpAtlas[2] = "0";
-   bumpAtlas[3] = "0";
-   castShadows = "0";
-   planarReflection = "0";
-   translucent = "1";
-   translucentBlendOp = "PreMul";
-   translucentZWrite = "0";
-   alphaTest = "0";
-   alphaRef = "1";
-   dynamicCubemap = "0";
-   showFootprints = "1";
-   showDust = "0";
-   effectColor[0] = "0 0 0 0";
-   effectColor[1] = "0 0 0 0";
-   footstepSoundId = "-1";
-   impactSoundId = "-1";
-   ImpactFXIndex = "-1";
-   canSave = "1";
-   canSaveDynamicFields = "1";
-};
-//--- OBJECT WRITE END ---
diff --git a/Templates/BaseGame/game/core/gameObjects/shapes/materials.tscript b/Templates/BaseGame/game/core/gameObjects/shapes/materials.tscript
deleted file mode 100644
index 1ff2dc498..000000000
--- a/Templates/BaseGame/game/core/gameObjects/shapes/materials.tscript
+++ /dev/null
@@ -1,95 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-singleton Material(OctahedronMat)
-{
-   mapTo = "green";
-
-   diffuseMapAsset[0] = "Core_GameObjects:camera_image";
-
-   translucent = "1";
-   translucentBlendOp = "PreMul";
-   emissive = "0";
-   castShadows = "0";
-
-   diffuseColor[0] = "0 1 0 1";
-};
-
-//--- camera.dts MATERIALS BEGIN ---
-singleton Material(CameraMat)
-{
-   mapTo = "pasted__phongE1";
-
-	diffuseMapAsset[0] = "Core_GameObjects:camera_image";
-
-	diffuseColor[0] = "0 0.627451 1 1";
-	specular[0] = "1 1 1 1";
-	specularPower[0] = 211;
-	pixelSpecular[0] = 1;
-	emissive[0] = 1;
-
-	doubleSided = 1;
-	translucent = true;
-	translucentBlendOp = "LerpAlpha";
-   castShadows = false;
-   materialTag0 = "Miscellaneous";
-};
-
-//--- camera.dts MATERIALS END ---
-
-//--- noshapetext.dae MATERIALS BEGIN ---
-singleton Material(noshapetext_lambert1)
-{
-   mapTo = "lambert1";
-
-	diffuseMapAsset[0] = "";
-
-	diffuseColor[0] = "0.4 0.4 0.4 1";
-	specular[0] = "1 1 1 1";
-	specularPower[0] = 8;
-	pixelSpecular[0] = false;
-	emissive[0] = true;
-
-	doubleSided = false;
-	translucent = false;
-	translucentBlendOp = "None";
-};
-
-singleton Material(noshapetext_noshape_mat)
-{
-   mapTo = "noshape_mat";
-
-	diffuseMapAsset[0] = "";
-
-	diffuseColor[0] = "0.4 0.3504 0.363784 0.33058";
-	specular[0] = "1 1 1 1";
-	specularPower[0] = 8;
-	pixelSpecular[0] = false;
-	emissive[0] = true;
-
-	doubleSided = false;
-	translucent = true;
-	translucentBlendOp = "None";
-};
-
-//--- noshapetext.dae MATERIALS END ---
-
diff --git a/Templates/BaseGame/game/core/gameObjects/shapes/noshape.asset.taml b/Templates/BaseGame/game/core/gameObjects/shapes/noshape.asset.taml
index aec6b87ba..82726bd6c 100644
--- a/Templates/BaseGame/game/core/gameObjects/shapes/noshape.asset.taml
+++ b/Templates/BaseGame/game/core/gameObjects/shapes/noshape.asset.taml
@@ -3,4 +3,5 @@
     canSaveDynamicFields="true"
     AssetName="noshape"
     fileName="@assetFile=noshape.dts"
+    materialSlot0="@asset=Core_Rendering:noShapeMat"
     constuctorFileName="@assetFile=noshape.tscript" />
diff --git a/Templates/BaseGame/game/core/gameObjects/shapes/noshape_NoShape.asset.taml b/Templates/BaseGame/game/core/gameObjects/shapes/noshape_NoShape.asset.taml
deleted file mode 100644
index 140cfb8dd..000000000
--- a/Templates/BaseGame/game/core/gameObjects/shapes/noshape_NoShape.asset.taml
+++ /dev/null
@@ -1,7 +0,0 @@
-<MaterialAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="noshape_NoShape"
-    scriptFile="@assetFile=materials.tscript"
-    materialDefinitionName="noshape_NoShape"
-    VersionId="1" />
diff --git a/Templates/BaseGame/game/core/gameObjects/shapes/noshapetext_lambert1.asset.taml b/Templates/BaseGame/game/core/gameObjects/shapes/noshapetext_lambert1.asset.taml
deleted file mode 100644
index 03690b6fe..000000000
--- a/Templates/BaseGame/game/core/gameObjects/shapes/noshapetext_lambert1.asset.taml
+++ /dev/null
@@ -1,7 +0,0 @@
-<MaterialAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="noshapetext_lambert1"
-    scriptFile="@assetFile=materials.tscript"
-    materialDefinitionName="noshapetext_lambert1"
-    VersionId="1" />
diff --git a/Templates/BaseGame/game/core/gameObjects/shapes/noshapetext_noshape_mat.asset.taml b/Templates/BaseGame/game/core/gameObjects/shapes/noshapetext_noshape_mat.asset.taml
deleted file mode 100644
index 1fec80c57..000000000
--- a/Templates/BaseGame/game/core/gameObjects/shapes/noshapetext_noshape_mat.asset.taml
+++ /dev/null
@@ -1,7 +0,0 @@
-<MaterialAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="noshapetext_noshape_mat"
-    scriptFile="@assetFile=materials.tscript"
-    materialDefinitionName="noshapetext_noshape_mat"
-    VersionId="1" />
diff --git a/Templates/BaseGame/game/core/gui/scripts/profiles.tscript b/Templates/BaseGame/game/core/gui/scripts/profiles.tscript
index 57156bbbe..f09e1d542 100644
--- a/Templates/BaseGame/game/core/gui/scripts/profiles.tscript
+++ b/Templates/BaseGame/game/core/gui/scripts/profiles.tscript
@@ -245,3 +245,11 @@ new GuiControlProfile( GuiSliderProfile )
    bitmapAsset = "Core_GUI:slider_image";
    category = "Core";
 };
+
+//
+if(!isObject(GuiScrollProfile))
+new GuiControlProfile(GuiScrollProfile)
+{
+	bitmapAsset = "Core_GUI:scrollBar_image";
+   category = "Core";
+};
diff --git a/Templates/BaseGame/game/core/lighting/scripts/AL_ConvexLightState.asset.taml b/Templates/BaseGame/game/core/lighting/scripts/AL_ConvexLightState.asset.taml
deleted file mode 100644
index 1c3b81a5a..000000000
--- a/Templates/BaseGame/game/core/lighting/scripts/AL_ConvexLightState.asset.taml
+++ /dev/null
@@ -1,7 +0,0 @@
-<MaterialAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="AL_ConvexLightState"
-    scriptFile="@assetFile=advancedLighting_Shaders.tscript"
-    materialDefinitionName="AL_ConvexLightState"
-    VersionId="1" />
diff --git a/Templates/BaseGame/game/core/lighting/scripts/AL_DefaultDeferredMaterial.asset.taml b/Templates/BaseGame/game/core/lighting/scripts/AL_DefaultDeferredMaterial.asset.taml
deleted file mode 100644
index b5567f4b1..000000000
--- a/Templates/BaseGame/game/core/lighting/scripts/AL_DefaultDeferredMaterial.asset.taml
+++ /dev/null
@@ -1,7 +0,0 @@
-<MaterialAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="AL_DefaultDeferredMaterial"
-    scriptFile="@assetFile=advancedLighting_Shaders.tscript"
-    materialDefinitionName="AL_DefaultDeferredMaterial"
-    VersionId="1" />
diff --git a/Templates/BaseGame/game/core/lighting/scripts/AL_DefaultShadowMaterial.asset.taml b/Templates/BaseGame/game/core/lighting/scripts/AL_DefaultShadowMaterial.asset.taml
deleted file mode 100644
index 5e1bd8133..000000000
--- a/Templates/BaseGame/game/core/lighting/scripts/AL_DefaultShadowMaterial.asset.taml
+++ /dev/null
@@ -1,7 +0,0 @@
-<MaterialAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="AL_DefaultShadowMaterial"
-    scriptFile="@assetFile=advancedLighting_Shaders.tscript"
-    materialDefinitionName="AL_DefaultShadowMaterial"
-    VersionId="1" />
diff --git a/Templates/BaseGame/game/core/lighting/scripts/AL_ParticlePointLightShader.asset.taml b/Templates/BaseGame/game/core/lighting/scripts/AL_ParticlePointLightShader.asset.taml
deleted file mode 100644
index 3cf0aef47..000000000
--- a/Templates/BaseGame/game/core/lighting/scripts/AL_ParticlePointLightShader.asset.taml
+++ /dev/null
@@ -1,7 +0,0 @@
-<MaterialAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="AL_ParticlePointLightShader"
-    scriptFile="@assetFile=advancedLighting_Shaders.tscript"
-    materialDefinitionName="AL_ParticlePointLightShader"
-    VersionId="1" />
diff --git a/Templates/BaseGame/game/core/lighting/scripts/AL_SpotLightShader.asset.taml b/Templates/BaseGame/game/core/lighting/scripts/AL_SpotLightShader.asset.taml
deleted file mode 100644
index e521008e8..000000000
--- a/Templates/BaseGame/game/core/lighting/scripts/AL_SpotLightShader.asset.taml
+++ /dev/null
@@ -1,7 +0,0 @@
-<MaterialAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="AL_SpotLightShader"
-    scriptFile="@assetFile=advancedLighting_Shaders.tscript"
-    materialDefinitionName="AL_SpotLightShader"
-    VersionId="1" />
diff --git a/Templates/BaseGame/game/core/lighting/scripts/BL_ProjectedShadowRPM.asset.taml b/Templates/BaseGame/game/core/lighting/scripts/BL_ProjectedShadowRPM.asset.taml
deleted file mode 100644
index 0911fb3fd..000000000
--- a/Templates/BaseGame/game/core/lighting/scripts/BL_ProjectedShadowRPM.asset.taml
+++ /dev/null
@@ -1,7 +0,0 @@
-<MaterialAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="BL_ProjectedShadowRPM"
-    scriptFile="@assetFile=basicLighting_Init.tscript"
-    materialDefinitionName="BL_ProjectedShadowRPM"
-    VersionId="1" />
diff --git a/Templates/BaseGame/game/core/lighting/scripts/IrradianceShader.asset.taml b/Templates/BaseGame/game/core/lighting/scripts/IrradianceShader.asset.taml
deleted file mode 100644
index a525eecbb..000000000
--- a/Templates/BaseGame/game/core/lighting/scripts/IrradianceShader.asset.taml
+++ /dev/null
@@ -1,7 +0,0 @@
-<MaterialAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="IrradianceShader"
-    scriptFile="@assetFile=advancedLighting_Shaders.tscript"
-    materialDefinitionName="IrradianceShader"
-    VersionId="1" />
diff --git a/Templates/BaseGame/game/core/rendering/images/WarningMaterial.asset.taml b/Templates/BaseGame/game/core/rendering/images/WarningMaterial.asset.taml
new file mode 100644
index 000000000..0fb53d08c
--- /dev/null
+++ b/Templates/BaseGame/game/core/rendering/images/WarningMaterial.asset.taml
@@ -0,0 +1,14 @@
+<MaterialAsset
+    canSave="true"
+    canSaveDynamicFields="true"
+    AssetName="WarningMaterial"
+    materialDefinitionName="WarningMaterial"
+    VersionId="1">
+    <Material
+        Name="WarningMaterial">
+        <Material.Stages>
+            <Stages_beginarray
+                DiffuseMapAsset="Core_Rendering:missingTexture_image"/>
+        </Material.Stages>
+    </Material>
+</MaterialAsset>
\ No newline at end of file
diff --git a/Templates/BaseGame/game/core/rendering/images/materials.tscript b/Templates/BaseGame/game/core/rendering/images/materials.tscript
deleted file mode 100644
index 48d7bb61e..000000000
--- a/Templates/BaseGame/game/core/rendering/images/materials.tscript
+++ /dev/null
@@ -1,32 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-singleton Material( Empty )
-{
-};
-
-singleton Material(WarningMaterial) {
-   detailMapAsset[0] = "Core_Rendering:missingTexture_image";
-   diffuseColor[0] = "25 16 0";
-   emissive[0] = false;
-   translucent = false;
-};
diff --git a/Templates/BaseGame/game/core/rendering/materials/Blank_sky/BlankSkyMat.asset.taml b/Templates/BaseGame/game/core/rendering/materials/Blank_sky/BlankSkyMat.asset.taml
index e6c3bb76b..6fa2808fb 100644
--- a/Templates/BaseGame/game/core/rendering/materials/Blank_sky/BlankSkyMat.asset.taml
+++ b/Templates/BaseGame/game/core/rendering/materials/Blank_sky/BlankSkyMat.asset.taml
@@ -2,6 +2,6 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="BlankSkyMat"
-    scriptFile="@assetFile=materials.tscript"
+    scriptFile="@assetFile=BlankSkyMat.tscript"
     materialDefinitionName="BlankSkyMat"
     VersionId="1" />
diff --git a/Templates/BaseGame/game/core/rendering/materials/Blank_sky/materials.tscript b/Templates/BaseGame/game/core/rendering/materials/Blank_sky/BlankSkyMat.tscript
similarity index 100%
rename from Templates/BaseGame/game/core/rendering/materials/Blank_sky/materials.tscript
rename to Templates/BaseGame/game/core/rendering/materials/Blank_sky/BlankSkyMat.tscript
diff --git a/Templates/BaseGame/game/core/rendering/materials/NightSkyMat.asset.taml b/Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkyMat.asset.taml
similarity index 76%
rename from Templates/BaseGame/game/core/rendering/materials/NightSkyMat.asset.taml
rename to Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkyMat.asset.taml
index 318f83ca2..02261e337 100644
--- a/Templates/BaseGame/game/core/rendering/materials/NightSkyMat.asset.taml
+++ b/Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkyMat.asset.taml
@@ -2,6 +2,6 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="NightSkyMat"
-    scriptFile="@assetFile=materials.tscript"
+    scriptFile="@assetFile=NightSkyMat.tscript"
     materialDefinitionName="NightSkyMat"
     VersionId="1" />
diff --git a/Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkyMat.tscript b/Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkyMat.tscript
new file mode 100644
index 000000000..47ccfa7a5
--- /dev/null
+++ b/Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkyMat.tscript
@@ -0,0 +1,15 @@
+singleton CubemapData( NightCubemap )
+{
+   cubeMapFaceAsset[0] = "Core_Rendering:NightSkybox_1";
+   cubeMapFaceAsset[1] = "Core_Rendering:NightSkybox_2";
+   cubeMapFaceAsset[2] = "Core_Rendering:NightSkybox_3";
+   cubeMapFaceAsset[3] = "Core_Rendering:NightSkybox_4";
+   cubeMapFaceAsset[4] = "Core_Rendering:NightSkybox_5";
+   cubeMapFaceAsset[5] = "Core_Rendering:NightSkybox_6";
+};
+
+singleton Material( NightSkyMat )
+{
+   cubemap = NightCubemap;
+   materialTag0 = "Skies";
+};
\ No newline at end of file
diff --git a/Templates/BaseGame/game/core/rendering/materials/NightSkybox_1.asset.taml b/Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkybox_1.asset.taml
similarity index 100%
rename from Templates/BaseGame/game/core/rendering/materials/NightSkybox_1.asset.taml
rename to Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkybox_1.asset.taml
diff --git a/Templates/BaseGame/game/core/rendering/materials/NightSkybox_1.png b/Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkybox_1.png
similarity index 100%
rename from Templates/BaseGame/game/core/rendering/materials/NightSkybox_1.png
rename to Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkybox_1.png
diff --git a/Templates/BaseGame/game/core/rendering/materials/NightSkybox_2.asset.taml b/Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkybox_2.asset.taml
similarity index 100%
rename from Templates/BaseGame/game/core/rendering/materials/NightSkybox_2.asset.taml
rename to Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkybox_2.asset.taml
diff --git a/Templates/BaseGame/game/core/rendering/materials/NightSkybox_2.png b/Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkybox_2.png
similarity index 100%
rename from Templates/BaseGame/game/core/rendering/materials/NightSkybox_2.png
rename to Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkybox_2.png
diff --git a/Templates/BaseGame/game/core/rendering/materials/NightSkybox_3.asset.taml b/Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkybox_3.asset.taml
similarity index 100%
rename from Templates/BaseGame/game/core/rendering/materials/NightSkybox_3.asset.taml
rename to Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkybox_3.asset.taml
diff --git a/Templates/BaseGame/game/core/rendering/materials/NightSkybox_3.png b/Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkybox_3.png
similarity index 100%
rename from Templates/BaseGame/game/core/rendering/materials/NightSkybox_3.png
rename to Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkybox_3.png
diff --git a/Templates/BaseGame/game/core/rendering/materials/NightSkybox_4.asset.taml b/Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkybox_4.asset.taml
similarity index 100%
rename from Templates/BaseGame/game/core/rendering/materials/NightSkybox_4.asset.taml
rename to Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkybox_4.asset.taml
diff --git a/Templates/BaseGame/game/core/rendering/materials/NightSkybox_4.png b/Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkybox_4.png
similarity index 100%
rename from Templates/BaseGame/game/core/rendering/materials/NightSkybox_4.png
rename to Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkybox_4.png
diff --git a/Templates/BaseGame/game/core/rendering/materials/NightSkybox_5.asset.taml b/Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkybox_5.asset.taml
similarity index 100%
rename from Templates/BaseGame/game/core/rendering/materials/NightSkybox_5.asset.taml
rename to Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkybox_5.asset.taml
diff --git a/Templates/BaseGame/game/core/rendering/materials/NightSkybox_5.png b/Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkybox_5.png
similarity index 100%
rename from Templates/BaseGame/game/core/rendering/materials/NightSkybox_5.png
rename to Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkybox_5.png
diff --git a/Templates/BaseGame/game/core/rendering/materials/NightSkybox_6.asset.taml b/Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkybox_6.asset.taml
similarity index 100%
rename from Templates/BaseGame/game/core/rendering/materials/NightSkybox_6.asset.taml
rename to Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkybox_6.asset.taml
diff --git a/Templates/BaseGame/game/core/rendering/materials/NightSkybox_6.png b/Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkybox_6.png
similarity index 100%
rename from Templates/BaseGame/game/core/rendering/materials/NightSkybox_6.png
rename to Templates/BaseGame/game/core/rendering/materials/NightSkybox/NightSkybox_6.png
diff --git a/Templates/BaseGame/game/core/rendering/materials/NoMaterial.asset.taml b/Templates/BaseGame/game/core/rendering/materials/NoMaterial.asset.taml
index 918d7099b..5ee1c0deb 100644
--- a/Templates/BaseGame/game/core/rendering/materials/NoMaterial.asset.taml
+++ b/Templates/BaseGame/game/core/rendering/materials/NoMaterial.asset.taml
@@ -2,5 +2,13 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="NoMaterial"
-    scriptFile="@assetFile=NoMaterial"
-    materialDefinitionName="NoMaterial" />
+    materialDefinitionName="NoMaterial">
+    <Material
+        Name="NoMaterial"
+        mapTo="NoMaterial">
+        <Material.Stages>
+            <Stages_beginarray
+                DiffuseMapAsset="Core_Rendering:warnMat_image"/>
+        </Material.Stages>
+    </Material>
+</MaterialAsset>
diff --git a/Templates/BaseGame/game/core/rendering/materials/NoMaterial.tscript b/Templates/BaseGame/game/core/rendering/materials/NoMaterial.tscript
deleted file mode 100644
index fc6fb1d4f..000000000
--- a/Templates/BaseGame/game/core/rendering/materials/NoMaterial.tscript
+++ /dev/null
@@ -1,6 +0,0 @@
-//--- OBJECT WRITE BEGIN ---
-singleton Material(NoMaterial) {
-   mapTo="NoMaterial";
-   DiffuseMapAsset[0] = "Core_Rendering:warnMat_image";
-};
-//--- OBJECT WRITE END ---
diff --git a/Templates/BaseGame/game/core/rendering/materials/materials.tscript b/Templates/BaseGame/game/core/rendering/materials/materials.tscript
deleted file mode 100644
index 3943b491b..000000000
--- a/Templates/BaseGame/game/core/rendering/materials/materials.tscript
+++ /dev/null
@@ -1,65 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-//--- OBJECT WRITE BEGIN ---
-
-singleton CubemapData( NightCubemap )
-{
-   cubeMapFaceAsset[0] = "Core_Rendering:NightSkybox_1";
-   cubeMapFaceAsset[1] = "Core_Rendering:NightSkybox_2";
-   cubeMapFaceAsset[2] = "Core_Rendering:NightSkybox_3";
-   cubeMapFaceAsset[3] = "Core_Rendering:NightSkybox_4";
-   cubeMapFaceAsset[4] = "Core_Rendering:NightSkybox_5";
-   cubeMapFaceAsset[5] = "Core_Rendering:NightSkybox_6";
-};
-
-singleton Material( NightSkyMat )
-{
-   cubemap = NightCubemap;
-   materialTag0 = "Skies";
-};
-
-singleton Material(moon_noglow) {
-   mapTo="moon_noglow";
-   DiffuseMapAsset = "Core_Rendering:moon_noglow_image";
-   emissive = true;
-   translucent = true;
-   vertColor[ 0 ] = true;
-};
-
-singleton Material(moon_wglow) {
-   mapTo="moon_wglow";
-   DiffuseMapAsset = "Core_Rendering:moon_wglow_image";
-   emissive = true;
-   translucent = true;
-   vertColor[ 0 ] = true;
-};
-
-singleton Material(moon_wcorona) {
-   mapTo="moon_wcorona";
-   DiffuseMapAsset = "Core_Rendering:moon_wcorona_image";
-   emissive = true;
-   translucent = true;
-   vertColor[ 0 ] = true;
-};
-
-//--- OBJECT WRITE END ---
diff --git a/Templates/BaseGame/game/core/rendering/materials/moon_noglow.asset.taml b/Templates/BaseGame/game/core/rendering/materials/moon_noglow.asset.taml
index 372a4037b..76e9d5d00 100644
--- a/Templates/BaseGame/game/core/rendering/materials/moon_noglow.asset.taml
+++ b/Templates/BaseGame/game/core/rendering/materials/moon_noglow.asset.taml
@@ -2,6 +2,17 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="moon_noglow"
-    scriptFile="@assetFile=moon_noglow.tscript"
     materialDefinitionName="moon_noglow"
-    imageMap0="@Asset=Core_Rendering:moon_noglow_image"/>
+    VersionId="1">
+    <Material
+        Name="moon_noglow"
+        mapTo="moon_noglow"
+        emissive="1"
+        translucent="1">
+        <Material.Stages>
+            <Stages_beginarray
+                DiffuseMapAsset="Core_Rendering:moon_noglow_image"
+                vertColor="1";/>
+        </Material.Stages>
+    </Material>
+</MaterialAsset>
\ No newline at end of file
diff --git a/Templates/BaseGame/game/core/rendering/materials/moon_noglowMat.asset.taml b/Templates/BaseGame/game/core/rendering/materials/moon_noglowMat.asset.taml
new file mode 100644
index 000000000..afb79ab61
--- /dev/null
+++ b/Templates/BaseGame/game/core/rendering/materials/moon_noglowMat.asset.taml
@@ -0,0 +1,14 @@
+<MaterialAsset
+    canSave="true"
+    canSaveDynamicFields="true"
+    AssetName="OccluderProxyMaterial"
+    materialDefinitionName="OccluderProxyMaterial"
+    VersionId="1">
+    <Material
+        Name="OccluderProxyMaterial">
+        <Material.Stages>
+            <Stages_beginarray
+                DiffuseMapAsset="ToolsModule:occluderProxyImage_image"/>
+        </Material.Stages>
+    </Material>
+</MaterialAsset>
\ No newline at end of file
diff --git a/Templates/BaseGame/game/core/rendering/materials/moon_wcoronaMat.asset.taml b/Templates/BaseGame/game/core/rendering/materials/moon_wcoronaMat.asset.taml
new file mode 100644
index 000000000..2db4a12c1
--- /dev/null
+++ b/Templates/BaseGame/game/core/rendering/materials/moon_wcoronaMat.asset.taml
@@ -0,0 +1,18 @@
+<MaterialAsset
+    canSave="true"
+    canSaveDynamicFields="true"
+    AssetName="moon_wcorona"
+    materialDefinitionName="moon_wcorona"
+    VersionId="1">
+    <Material
+        Name="moon_wcorona"
+        mapTo="moon_wcorona"
+        emissive="1"
+        translucent="1">
+        <Material.Stages>
+            <Stages_beginarray
+                DiffuseMapAsset="Core_Rendering:moon_wcorona_image"
+                vertColor="1";/>
+        </Material.Stages>
+    </Material>
+</MaterialAsset>
\ No newline at end of file
diff --git a/Templates/BaseGame/game/core/rendering/materials/moon_wglow.asset.taml b/Templates/BaseGame/game/core/rendering/materials/moon_wglow.asset.taml
index 846b4c6d3..a37a06a6d 100644
--- a/Templates/BaseGame/game/core/rendering/materials/moon_wglow.asset.taml
+++ b/Templates/BaseGame/game/core/rendering/materials/moon_wglow.asset.taml
@@ -2,6 +2,17 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="moon_wglow"
-    scriptFile="@assetFile=moon_wglow.tscript"
     materialDefinitionName="moon_wglow"
-    imageMap0="@Asset=Core_Rendering:moon_wglow_image"/>
+    VersionId="1">
+    <Material
+        Name="moon_wglow"
+        mapTo="moon_wglow"
+        emissive="1"
+        translucent="1">
+        <Material.Stages>
+            <Stages_beginarray
+                DiffuseMapAsset="Core_Rendering:moon_wglow_image"
+                vertColor="1";/>
+        </Material.Stages>
+    </Material>
+</MaterialAsset>
\ No newline at end of file
diff --git a/Templates/BaseGame/game/core/rendering/materials/moon_wglowMat.asset.taml b/Templates/BaseGame/game/core/rendering/materials/moon_wglowMat.asset.taml
new file mode 100644
index 000000000..afb79ab61
--- /dev/null
+++ b/Templates/BaseGame/game/core/rendering/materials/moon_wglowMat.asset.taml
@@ -0,0 +1,14 @@
+<MaterialAsset
+    canSave="true"
+    canSaveDynamicFields="true"
+    AssetName="OccluderProxyMaterial"
+    materialDefinitionName="OccluderProxyMaterial"
+    VersionId="1">
+    <Material
+        Name="OccluderProxyMaterial">
+        <Material.Stages>
+            <Stages_beginarray
+                DiffuseMapAsset="ToolsModule:occluderProxyImage_image"/>
+        </Material.Stages>
+    </Material>
+</MaterialAsset>
\ No newline at end of file
diff --git a/Templates/BaseGame/game/core/rendering/shapes/materials.tscript b/Templates/BaseGame/game/core/rendering/shapes/materials.tscript
deleted file mode 100644
index 0fd1ca716..000000000
--- a/Templates/BaseGame/game/core/rendering/shapes/materials.tscript
+++ /dev/null
@@ -1,16 +0,0 @@
-//--- noshape.dts MATERIALS BEGIN ---
-singleton Material(noshape_NoShape)
-{
-    mapTo = "NoShape";
-
-    diffuseMapAsset[0] = "";
-    diffuseColor[0] = "0.8 0.003067 0 .8";
-    emissive[0] = 0;
-    doubleSided = false;
-    translucent = 1;
-    translucentBlendOp = "LerpAlpha";
-    castShadows = false;
-    materialTag0 = "WorldEditor";
-};
-
-//--- noshape.dts MATERIALS END ---
diff --git a/Templates/BaseGame/game/core/rendering/shapes/noShapeMat.asset.taml b/Templates/BaseGame/game/core/rendering/shapes/noShapeMat.asset.taml
new file mode 100644
index 000000000..0a2fb3cb1
--- /dev/null
+++ b/Templates/BaseGame/game/core/rendering/shapes/noShapeMat.asset.taml
@@ -0,0 +1,18 @@
+<MaterialAsset
+    canSave="true"
+    canSaveDynamicFields="true"
+    AssetName="NoShapeMat"
+    materialDefinitionName="NoShapeMat"
+    VersionId="1">
+    <Material
+        Name="NoShapeMat"
+        mapTo="NoShape"
+        translucent="1";
+        translucentBlendOp="LerpAlpha";
+        castShadows="0">
+        <Material.Stages>
+            <Stages_beginarray
+                diffuseColor="0.8 0.003067 0 .8"/>
+        </Material.Stages>
+    </Material>
+</MaterialAsset>
diff --git a/Templates/BaseGame/game/core/rendering/shapes/noshape.asset.taml b/Templates/BaseGame/game/core/rendering/shapes/noshape.asset.taml
index cf670d251..000c68d9d 100644
--- a/Templates/BaseGame/game/core/rendering/shapes/noshape.asset.taml
+++ b/Templates/BaseGame/game/core/rendering/shapes/noshape.asset.taml
@@ -3,4 +3,5 @@
     canSaveDynamicFields="true"
     AssetName="noshape"
     fileName="@assetFile=noshape.dts"
+    materialSlot0="@asset=Core_Rendering:NoShapeMat"
     VersionId="1" />
diff --git a/Templates/BaseGame/game/tools/base/images/Black.asset.taml b/Templates/BaseGame/game/tools/base/images/Black.asset.taml
index b8cf9af8a..a419f0f87 100644
--- a/Templates/BaseGame/game/tools/base/images/Black.asset.taml
+++ b/Templates/BaseGame/game/tools/base/images/Black.asset.taml
@@ -2,6 +2,13 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="Black"
-    scriptFile="@assetFile=materials.tscript"
     materialDefinitionName="Black"
-    VersionId="1" />
+    VersionId="1">
+    <Material
+        Name="Black">
+        <Material.Stages>
+            <Stages_beginarray
+                DiffuseMapAsset="ToolsModule:black_image"/>
+        </Material.Stages>
+    </Material>
+</MaterialAsset>
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/base/images/Gray.asset.taml b/Templates/BaseGame/game/tools/base/images/Gray.asset.taml
index 358ce1109..83ae65616 100644
--- a/Templates/BaseGame/game/tools/base/images/Gray.asset.taml
+++ b/Templates/BaseGame/game/tools/base/images/Gray.asset.taml
@@ -2,6 +2,13 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="Gray"
-    scriptFile="@assetFile=materials.tscript"
     materialDefinitionName="Gray"
-    VersionId="1" />
+    VersionId="1">
+    <Material
+        Name="Gray">
+        <Material.Stages>
+            <Stages_beginarray
+                DiffuseMapAsset="ToolsModule:gray_image"/>
+        </Material.Stages>
+    </Material>
+</MaterialAsset>
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/base/images/White.asset.taml b/Templates/BaseGame/game/tools/base/images/White.asset.taml
index 062281c3e..1ef43d42c 100644
--- a/Templates/BaseGame/game/tools/base/images/White.asset.taml
+++ b/Templates/BaseGame/game/tools/base/images/White.asset.taml
@@ -2,6 +2,13 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="White"
-    scriptFile="@assetFile=materials.tscript"
     materialDefinitionName="White"
-    VersionId="1" />
+    VersionId="1">
+    <Material
+        Name="White">
+        <Material.Stages>
+            <Stages_beginarray
+                DiffuseMapAsset="ToolsModule:white_image"/>
+        </Material.Stages>
+    </Material>
+</MaterialAsset>
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/base/images/materials.tscript b/Templates/BaseGame/game/tools/base/images/materials.tscript
deleted file mode 100644
index b1525a317..000000000
--- a/Templates/BaseGame/game/tools/base/images/materials.tscript
+++ /dev/null
@@ -1,67 +0,0 @@
-//-----------------------------------------------------------------------------
-// Torque
-// Copyright GarageGames, LLC 2011
-//-----------------------------------------------------------------------------
-
-singleton Material(White)
-{
-   diffuseMapAsset[0] = "ToolsModule:white_image";
-};
-
-singleton Material(Gray)
-{
-   diffuseMapAsset[0] = "ToolsModule:gray_image";
-};
-
-singleton Material(Black)
-{
-   diffuseMapAsset[0] = "ToolsModule:black_image";
-};
-
-singleton Material(Grid_512_Black)
-{
-   diffuseMapAsset[0] = "ToolsModule:512_black_image";
-};
-
-singleton Material(Grid_512_ForestGreen)
-{
-   diffuseMapAsset[0] = "ToolsModule:512_forestgreen_image";
-};
-
-singleton Material(Grid_512_ForestGreen_Lines)
-{
-   diffuseMapAsset[0] = "ToolsModule:512_forestgreen_lines_image";
-};
-
-singleton Material(Grid_512_Green)
-{
-   diffuseMapAsset[0] = "ToolsModule:512_green_image";
-};
-
-singleton Material(Grid_512_Grey)
-{
-   diffuseMapAsset[0] = "ToolsModule:512_grey_image";
-};
-
-singleton Material(Grid_512_Grey_Base)
-{
-   diffuseMapAsset[0] = "ToolsModule:512_grey_base_image";
-};
-
-singleton Material(Grid_512_Orange)
-{
-   diffuseMapAsset[0] = "ToolsModule:512_orange_image";
-   translucent = "0";
-   translucentBlendOp = "PreMul";
-   mapTo = "512_orange.png";
-};
-
-singleton Material(Grid_512_Orange_Lines)
-{
-   diffuseMapAsset[0] = "ToolsModule:512_orange_lines_image";
-};
-
-singleton Material(Grid_512_Red)
-{
-   diffuseMapAsset[0] = "ToolsModule:512_red_image";
-};
diff --git a/Templates/BaseGame/game/tools/convexEditor/OccluderProxyMaterial.asset.taml b/Templates/BaseGame/game/tools/convexEditor/OccluderProxyMaterial.asset.taml
deleted file mode 100644
index 3e9048f43..000000000
--- a/Templates/BaseGame/game/tools/convexEditor/OccluderProxyMaterial.asset.taml
+++ /dev/null
@@ -1,7 +0,0 @@
-<MaterialAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="OccluderProxyMaterial"
-    scriptFile="@assetFile=materials.tscript"
-    materialDefinitionName="OccluderProxyMaterial"
-    VersionId="1" />
diff --git a/Templates/BaseGame/game/tools/convexEditor/PortalProxyMaterial.asset.taml b/Templates/BaseGame/game/tools/convexEditor/PortalProxyMaterial.asset.taml
deleted file mode 100644
index ac08480eb..000000000
--- a/Templates/BaseGame/game/tools/convexEditor/PortalProxyMaterial.asset.taml
+++ /dev/null
@@ -1,7 +0,0 @@
-<MaterialAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="PortalProxyMaterial"
-    scriptFile="@assetFile=materials.tscript"
-    materialDefinitionName="PortalProxyMaterial"
-    VersionId="1" />
diff --git a/Templates/BaseGame/game/tools/convexEditor/TriggerProxyMaterial.asset.taml b/Templates/BaseGame/game/tools/convexEditor/TriggerProxyMaterial.asset.taml
deleted file mode 100644
index ac5eea347..000000000
--- a/Templates/BaseGame/game/tools/convexEditor/TriggerProxyMaterial.asset.taml
+++ /dev/null
@@ -1,7 +0,0 @@
-<MaterialAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="TriggerProxyMaterial"
-    scriptFile="@assetFile=materials.tscript"
-    materialDefinitionName="TriggerProxyMaterial"
-    VersionId="1" />
diff --git a/Templates/BaseGame/game/tools/convexEditor/ZoneProxyMaterial.asset.taml b/Templates/BaseGame/game/tools/convexEditor/ZoneProxyMaterial.asset.taml
deleted file mode 100644
index efde833a2..000000000
--- a/Templates/BaseGame/game/tools/convexEditor/ZoneProxyMaterial.asset.taml
+++ /dev/null
@@ -1,7 +0,0 @@
-<MaterialAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="ZoneProxyMaterial"
-    scriptFile="@assetFile=materials.tscript"
-    materialDefinitionName="ZoneProxyMaterial"
-    VersionId="1" />
diff --git a/Templates/BaseGame/game/tools/convexEditor/convexEditor.tscript b/Templates/BaseGame/game/tools/convexEditor/convexEditor.tscript
index 859667bc1..deb211fbf 100644
--- a/Templates/BaseGame/game/tools/convexEditor/convexEditor.tscript
+++ b/Templates/BaseGame/game/tools/convexEditor/convexEditor.tscript
@@ -44,10 +44,3 @@ singleton GuiControlProfile (GuiDisabledTextEditProfile)
    canKeyFocus = false;   
    category = "Editor";
 };
-
-singleton GuiControlProfile (GuiSimpleBorderProfile)
-{
-   opaque = false;   
-   border = 1;   
-   category = "Editor";
-};
diff --git a/Templates/BaseGame/game/tools/convexEditor/images/OccluderProxyMaterial.asset.taml b/Templates/BaseGame/game/tools/convexEditor/images/OccluderProxyMaterial.asset.taml
new file mode 100644
index 000000000..afb79ab61
--- /dev/null
+++ b/Templates/BaseGame/game/tools/convexEditor/images/OccluderProxyMaterial.asset.taml
@@ -0,0 +1,14 @@
+<MaterialAsset
+    canSave="true"
+    canSaveDynamicFields="true"
+    AssetName="OccluderProxyMaterial"
+    materialDefinitionName="OccluderProxyMaterial"
+    VersionId="1">
+    <Material
+        Name="OccluderProxyMaterial">
+        <Material.Stages>
+            <Stages_beginarray
+                DiffuseMapAsset="ToolsModule:occluderProxyImage_image"/>
+        </Material.Stages>
+    </Material>
+</MaterialAsset>
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/convexEditor/images/PortalProxyMaterial.asset.taml b/Templates/BaseGame/game/tools/convexEditor/images/PortalProxyMaterial.asset.taml
new file mode 100644
index 000000000..dafb6a648
--- /dev/null
+++ b/Templates/BaseGame/game/tools/convexEditor/images/PortalProxyMaterial.asset.taml
@@ -0,0 +1,14 @@
+<MaterialAsset
+    canSave="true"
+    canSaveDynamicFields="true"
+    AssetName="PortalProxyMaterial"
+    materialDefinitionName="PortalProxyMaterial"
+    VersionId="1">
+    <Material
+        Name="PortalProxyMaterial">
+        <Material.Stages>
+            <Stages_beginarray
+                DiffuseMapAsset="ToolsModule:portalProxyImage_image"/>
+        </Material.Stages>
+    </Material>
+</MaterialAsset>
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/convexEditor/images/TriggerProxyMaterial.asset.taml b/Templates/BaseGame/game/tools/convexEditor/images/TriggerProxyMaterial.asset.taml
new file mode 100644
index 000000000..ba793c53f
--- /dev/null
+++ b/Templates/BaseGame/game/tools/convexEditor/images/TriggerProxyMaterial.asset.taml
@@ -0,0 +1,14 @@
+<MaterialAsset
+    canSave="true"
+    canSaveDynamicFields="true"
+    AssetName="TriggerProxyMaterial"
+    materialDefinitionName="TriggerProxyMaterial"
+    VersionId="1">
+    <Material
+        Name="TriggerProxyMaterial">
+        <Material.Stages>
+            <Stages_beginarray
+                DiffuseMapAsset="ToolsModule:triggerProxyImage_image"/>
+        </Material.Stages>
+    </Material>
+</MaterialAsset>
diff --git a/Templates/BaseGame/game/tools/convexEditor/images/ZoneProxyMaterial.asset.taml b/Templates/BaseGame/game/tools/convexEditor/images/ZoneProxyMaterial.asset.taml
new file mode 100644
index 000000000..80f575f30
--- /dev/null
+++ b/Templates/BaseGame/game/tools/convexEditor/images/ZoneProxyMaterial.asset.taml
@@ -0,0 +1,14 @@
+<MaterialAsset
+    canSave="true"
+    canSaveDynamicFields="true"
+    AssetName="ZoneProxyMaterial"
+    materialDefinitionName="ZoneProxyMaterial"
+    VersionId="1">
+    <Material
+        Name="ZoneProxyMaterial">
+        <Material.Stages>
+            <Stages_beginarray
+                DiffuseMapAsset="ToolsModule:zoneProxyImage_image"/>
+        </Material.Stages>
+    </Material>
+</MaterialAsset>
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/convexEditor/main.tscript b/Templates/BaseGame/game/tools/convexEditor/main.tscript
index 3930f5b11..7d04d55c8 100644
--- a/Templates/BaseGame/game/tools/convexEditor/main.tscript
+++ b/Templates/BaseGame/game/tools/convexEditor/main.tscript
@@ -29,7 +29,6 @@ function initializeConvexEditor()
    exec( "./convexEditorToolbar.ed.gui" );
    exec( "./convexEditorGui." @ $TorqueScriptFileExtension );
    exec( "./convexEditorSidebarGui.gui" );
-   exec( "./materials." @ $TorqueScriptFileExtension );
 
    ConvexEditorGui.setVisible( false );  
    ConvexEditorOptionsWindow.setVisible( false );  
diff --git a/Templates/BaseGame/game/tools/convexEditor/materials.tscript b/Templates/BaseGame/game/tools/convexEditor/materials.tscript
deleted file mode 100644
index bd2e37c17..000000000
--- a/Templates/BaseGame/game/tools/convexEditor/materials.tscript
+++ /dev/null
@@ -1,39 +0,0 @@
-singleton Material( ZoneProxyMaterial )
-{
-   mapTo = "ZoneProxyMaterial";
-   diffuseMapAsset[0] = "ToolsModule:zoneProxyImage_image";
-   materialTag0 = "TestMaterial";
-   translucent = true;
-   translucentBlendOp = "LerpAlpha";
-   castShadows = false;
-};
-
-singleton Material( TriggerProxyMaterial )
-{
-   mapTo = "TriggerProxyMaterial";
-   diffuseMapAsset[0] = "ToolsModule:triggerProxyImage_image";
-   materialTag0 = "TestMaterial";
-   translucent = true;
-   translucentBlendOp = "PreMul";
-   castShadows = false;
-};
-
-singleton Material( PortalProxyMaterial )
-{
-   mapTo = "PortalProxyMaterial";
-   diffuseMapAsset[0] = "ToolsModule:portalProxyImage_image";
-   materialTag0 = "TestMaterial";
-   translucent = true;
-   translucentBlendOp = "PreMul";
-   castShadows = false;
-};
-
-singleton Material( OccluderProxyMaterial )
-{
-   mapTo = "OccluderProxyMaterial";
-   diffuseMapAsset[0] = "ToolsModule:occluderProxyImage_image";
-   materialTag0 = "TestMaterial";
-   translucent = true;
-   translucentBlendOp = "PreMul";
-   castShadows = false;
-};
diff --git a/Templates/BaseGame/game/tools/datablockEditor/.asset.taml b/Templates/BaseGame/game/tools/datablockEditor/.asset.taml
deleted file mode 100644
index fd3c1a4cb..000000000
--- a/Templates/BaseGame/game/tools/datablockEditor/.asset.taml
+++ /dev/null
@@ -1,6 +0,0 @@
-<GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    scriptFile="@assetFile=DatablockEditorTreeWindow.ed.gui"
-    GUIFile="@assetFile=DatablockEditorTreeWindow.ed.gui"
-    VersionId="1" />
diff --git a/Templates/BaseGame/game/tools/gui/.asset.taml b/Templates/BaseGame/game/tools/gui/.asset.taml
deleted file mode 100644
index 5995b2ea7..000000000
--- a/Templates/BaseGame/game/tools/gui/.asset.taml
+++ /dev/null
@@ -1,6 +0,0 @@
-<GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    scriptFile="@assetFile=guiObjectInspector.ed.gui"
-    GUIFile="@assetFile=guiObjectInspector.ed.gui"
-    VersionId="1" />
diff --git a/Templates/BaseGame/game/tools/gui/profiles.ed.tscript b/Templates/BaseGame/game/tools/gui/profiles.ed.tscript
index 492423e3d..2b2cec671 100644
--- a/Templates/BaseGame/game/tools/gui/profiles.ed.tscript
+++ b/Templates/BaseGame/game/tools/gui/profiles.ed.tscript
@@ -698,22 +698,6 @@ new GuiControlProfile( ToolsGuiFormProfile : ToolsGuiTextProfile )
 
 // ----------------------------------------------------------------------------
 
-singleton GuiControlProfile( GuiEditorClassProfile )
-{
-   opaque = true;
-   fillColor = "232 232 232";
-   border = 1;
-   borderColor   = "42 42 42 140";
-   borderColorHL = "127 127 127";
-   fontColor = "215 215 215";
-   fontColorHL = "50 50 50";
-   fixedExtent = true;
-   justify = "center";
-   bitmapAsset = "ToolsModule:scrollBar_image";
-   hasBitmapArray = true;
-   category = "Editor";
-};
-
 singleton GuiControlProfile( GuiBackFillProfile )
 {
    opaque = true;
@@ -1246,3 +1230,11 @@ singleton GuiControlProfile (IconDropdownProfile)
    
    fillColor = EditorSettings.value("Theme/headerColor");
 };
+
+//
+singleton GuiControlProfile (GuiSimpleBorderProfile)
+{
+   opaque = false;   
+   border = 1;   
+   category = "Editor";
+};
diff --git a/Templates/BaseGame/game/tools/main.tscript b/Templates/BaseGame/game/tools/main.tscript
index 218d7d88d..b44a27f99 100644
--- a/Templates/BaseGame/game/tools/main.tscript
+++ b/Templates/BaseGame/game/tools/main.tscript
@@ -82,7 +82,6 @@ function onStart()
    // Common GUI stuff.
    exec( "./gui/cursors.ed." @ $TorqueScriptFileExtension );
    exec( "./gui/messageBoxes/messageBox.ed." @ $TorqueScriptFileExtension );
-   exec( "./editorClasses/gui/panels/navPanelProfiles.ed." @ $TorqueScriptFileExtension );
    
    // Make sure we get editor profiles before any GUI's
    // BUG: these dialogs are needed earlier in the init sequence, and should be moved to
diff --git a/Templates/BaseGame/game/tools/materialEditor/gui/.asset.taml b/Templates/BaseGame/game/tools/materialEditor/gui/.asset.taml
deleted file mode 100644
index 5711ba647..000000000
--- a/Templates/BaseGame/game/tools/materialEditor/gui/.asset.taml
+++ /dev/null
@@ -1,6 +0,0 @@
-<GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    scriptFile="@assetFile=guiMaterialPreviewWindow.ed.gui"
-    GUIFile="@assetFile=guiMaterialPreviewWindow.ed.gui"
-    VersionId="1" />
diff --git a/Templates/BaseGame/game/tools/meshRoadEditor/meshRoadEditor.tscript b/Templates/BaseGame/game/tools/meshRoadEditor/meshRoadEditor.tscript
index 112562d82..eee393d87 100644
--- a/Templates/BaseGame/game/tools/meshRoadEditor/meshRoadEditor.tscript
+++ b/Templates/BaseGame/game/tools/meshRoadEditor/meshRoadEditor.tscript
@@ -43,11 +43,4 @@ singleton GuiControlProfile (GuiDisabledTextEditProfile)
    tab = false;
    canKeyFocus = false;   
    category = "Editor";
-};
-
-singleton GuiControlProfile (GuiSimpleBorderProfile)
-{
-   opaque = false;   
-   border = 1;   
-   category = "Editor";
 };
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/navEditor/navEditor.tscript b/Templates/BaseGame/game/tools/navEditor/navEditor.tscript
index 8fc2b15ba..bbe6fe8b0 100644
--- a/Templates/BaseGame/game/tools/navEditor/navEditor.tscript
+++ b/Templates/BaseGame/game/tools/navEditor/navEditor.tscript
@@ -351,10 +351,3 @@ singleton GuiControlProfile(NavEditorProfile)
    fillColor = "192 192 192 192";
    category = "Editor";
 };
-
-singleton GuiControlProfile(GuiSimpleBorderProfile)
-{
-   opaque = false;   
-   border = 1;   
-   category = "Editor";
-};
diff --git a/Templates/BaseGame/game/tools/resources/ReflectProbePreviewMat.asset.taml b/Templates/BaseGame/game/tools/resources/ReflectProbePreviewMat.asset.taml
new file mode 100644
index 000000000..e136ff6b4
--- /dev/null
+++ b/Templates/BaseGame/game/tools/resources/ReflectProbePreviewMat.asset.taml
@@ -0,0 +1,18 @@
+<MaterialAsset
+    canSave="true"
+    canSaveDynamicFields="true"
+    AssetName="ReflectProbePreviewMat"
+    materialDefinitionName="ReflectProbePreviewMat"
+    VersionId="1">
+    <Material
+        Name="ReflectProbePreviewMat"
+        mapTo="ReflectProbePreviewMat">
+        <Material.Stages>
+            <Stages_beginarray
+                DiffuseMapAsset="ToolsModule:occluderProxyImage_image"
+                diffuseColor="1 1 1 1"
+                roughness="0"
+                metalness="1"/>
+        </Material.Stages>
+    </Material>
+</MaterialAsset>
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/resources/materials.tscript b/Templates/BaseGame/game/tools/resources/materials.tscript
deleted file mode 100644
index 2ba9fec86..000000000
--- a/Templates/BaseGame/game/tools/resources/materials.tscript
+++ /dev/null
@@ -1,8 +0,0 @@
-singleton Material(ReflectProbePreviewMat)
-{
-   mapTo = "ReflectProbePreviewMat";
-   diffuseColor[0] = "1 1 1 1";
-   roughness[0] = "0";
-   metalness[0] = "1";
-   translucentBlendOp = "None";
-};
diff --git a/Templates/BaseGame/game/tools/riverEditor/riverEditor.tscript b/Templates/BaseGame/game/tools/riverEditor/riverEditor.tscript
index 83da8b85c..944bafed2 100644
--- a/Templates/BaseGame/game/tools/riverEditor/riverEditor.tscript
+++ b/Templates/BaseGame/game/tools/riverEditor/riverEditor.tscript
@@ -26,12 +26,4 @@ singleton GuiControlProfile( RiverEditorProfile )
    opaque = true;
    fillColor = "192 192 192 192";
    category = "Editor";
-};
-
-singleton GuiControlProfile (GuiSimpleBorderProfile)
-{
-   opaque = false;   
-   border = 1;   
-   category = "Editor";
-};
- 
\ No newline at end of file
+};
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/roadEditor/roadEditor.tscript b/Templates/BaseGame/game/tools/roadEditor/roadEditor.tscript
index 0822050b0..0bfe5ef43 100644
--- a/Templates/BaseGame/game/tools/roadEditor/roadEditor.tscript
+++ b/Templates/BaseGame/game/tools/roadEditor/roadEditor.tscript
@@ -28,13 +28,6 @@ singleton GuiControlProfile( RoadEditorProfile )
    category = "Editor";
 };
 
-singleton GuiControlProfile (GuiSimpleBorderProfile)
-{
-   opaque = false;   
-   border = 1;   
-   category = "Editor";
-};
-
 singleton GuiCursor(RoadEditorMoveCursor)
 {
    hotSpot = "4 4";
diff --git a/Templates/BaseGame/game/tools/shapeEditor/gui/.asset.taml b/Templates/BaseGame/game/tools/shapeEditor/gui/.asset.taml
deleted file mode 100644
index 8bf949aa2..000000000
--- a/Templates/BaseGame/game/tools/shapeEditor/gui/.asset.taml
+++ /dev/null
@@ -1,6 +0,0 @@
-<GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    scriptFile="@assetFile=shapeEdSelectWindow.ed.gui"
-    GUIFile="@assetFile=shapeEdSelectWindow.ed.gui"
-    VersionId="1" />
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/.asset.taml b/Templates/BaseGame/game/tools/worldEditor/gui/.asset.taml
deleted file mode 100644
index 36b7991fa..000000000
--- a/Templates/BaseGame/game/tools/worldEditor/gui/.asset.taml
+++ /dev/null
@@ -1,6 +0,0 @@
-<GUIAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    scriptFile="@assetFile=WorldEditorTreeWindow.ed.gui"
-    GUIFile="@assetFile=WorldEditorTreeWindow.ed.gui"
-    VersionId="1" />
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/AL_ShadowVizOverlayCtrl.asset.taml b/Templates/BaseGame/game/tools/worldEditor/gui/AL_ShadowVizOverlayCtrl.asset.taml
index ab14cd613..4c92556c3 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/AL_ShadowVizOverlayCtrl.asset.taml
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/AL_ShadowVizOverlayCtrl.asset.taml
@@ -2,6 +2,6 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="AL_ShadowVizOverlayCtrl"
-    scriptFile="@assetFile=shadowViz.gui"
+    scriptFile="@assetFile=shadowViz.tscript"
     GUIFile="@assetFile=shadowViz.gui"
     VersionId="1" />
diff --git a/Templates/BaseGame/game/tools/worldEditor/main.tscript b/Templates/BaseGame/game/tools/worldEditor/main.tscript
index 0d975d380..ef0dfdc05 100644
--- a/Templates/BaseGame/game/tools/worldEditor/main.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/main.tscript
@@ -68,10 +68,7 @@ function initializeWorldEditor()
    exec("./scripts/cameraCommands.ed." @ $TorqueScriptFileExtension);
    exec("./scripts/probeBake.ed." @ $TorqueScriptFileExtension);
    exec("./scripts/visibility/visibilityLayer.ed." @ $TorqueScriptFileExtension);
-   exec("./scripts/visibility/lightViz." @ $TorqueScriptFileExtension);
-   exec("./scripts/visibility/shadowViz." @ $TorqueScriptFileExtension);
    exec("./scripts/visibility/probeViz." @ $TorqueScriptFileExtension);
-   exec("./scripts/visibility/miscViz." @ $TorqueScriptFileExtension);
    
    exec("tools/gui/postFxEditor." @ $TorqueScriptFileExtension );
    exec("tools/gui/renderTargetVisualizer.ed." @ $TorqueScriptFileExtension);
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
index 1ba706257..ef1b9292b 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
@@ -216,7 +216,7 @@ function EditorGui::init(%this)
    ETerrainEditor.init();
 
    //Creator.init();
-   ObjectCreator.init();
+   //ObjectCreator.init();
    ObjectBuilderGui.init();
 
    %this.setMenuDefaultState();
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/editors/creator.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/editors/creator.ed.tscript
index 9524a7849..fc047c19b 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/editors/creator.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/editors/creator.ed.tscript
@@ -20,104 +20,8 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-
-function ObjectCreator::init( %this )
-{
-   // Just so we can recall this method for testing changes
-   // without restarting.
-   if ( isObject( %this.array ) )
-      %this.array.delete();
-      
-   %this.array = new ArrayObject();
-   %this.array.caseSensitive = true; 
-   %this.setListView( true );
-   
-   %this.beginGroup( "Environment" );
-   
-      // Removed Prefab as there doesn't really seem to be a point in creating a blank one
-      //%this.registerMissionObject( "Prefab",              "Prefab" );
-      %this.registerMissionObject( "SkyBox",              "Sky Box" );
-      %this.registerMissionObject( "SkySphere",           "Sky Sphere" );
-      %this.registerMissionObject( "CloudLayer",          "Cloud Layer" );
-      %this.registerMissionObject( "BasicClouds",         "Basic Clouds" );
-      %this.registerMissionObject( "ScatterSky",          "Scatter Sky" );
-      %this.registerMissionObject( "Sun",                 "Basic Sun" );
-      %this.registerMissionObject( "Lightning" );
-      %this.registerMissionObject( "WaterBlock",          "Water Block" );
-      %this.registerMissionObject( "SFXEmitter",          "Sound Emitter" );
-      %this.registerMissionObject( "Precipitation" );
-      %this.registerMissionObject( "ParticleEmitterNode", "Particle Emitter" );
-      %this.registerMissionObject( "VolumetricFog", "Volumetric Fog" );
-      %this.registerMissionObject( "RibbonNode", "Ribbon" );
-      
-      // Legacy features. Users should use Ground Cover and the Forest Editor.   
-      //%this.registerMissionObject( "fxShapeReplicator",   "Shape Replicator" );
-      //%this.registerMissionObject( "fxFoliageReplicator", "Foliage Replicator" );
-      
-      %this.registerMissionObject( "PointLight",          "Point Light" );
-      %this.registerMissionObject( "SpotLight",           "Spot Light" );
-      
-      %this.registerMissionObject( "BoxEnvironmentProbe",       "Box Environment Probe" );
-      %this.registerMissionObject( "SphereEnvironmentProbe",    "Sphere Environment Probe" );
-      %this.registerMissionObject( "Skylight",       "Skylight" );
-      
-      %this.registerMissionObject( "GroundCover",         "Ground Cover" );
-      %this.registerMissionObject( "TerrainBlock",        "Terrain Block" );
-      %this.registerMissionObject( "GroundPlane",         "Ground Plane" );
-      %this.registerMissionObject( "WaterPlane",          "Water Plane" );
-      %this.registerMissionObject( "PxCloth",             "Cloth" );
-      %this.registerMissionObject( "ForestWindEmitter",   "Wind Emitter" );
-               
-      %this.registerMissionObject( "DustEmitter", "Dust Emitter" );
-      %this.registerMissionObject( "DustSimulation", "Dust Simulation" );
-      %this.registerMissionObject( "DustEffecter", "Dust Effecter" );
-      
-   %this.endGroup();
-
-   %this.beginGroup( "Level" );
-   
-      %this.registerMissionObject( "MissionArea",  "Mission Area" );
-      %this.registerMissionObject( "Path" );
-      %this.registerMissionObject( "Marker",       "Path Node" );
-      %this.registerMissionObject( "Trigger" );
-      %this.registerMissionObject( "PhysicalZone", "Physical Zone" );
-      %this.registerMissionObject( "Camera" );
-      %this.registerMissionObject( "LevelInfo",    "Level Info" );
-      %this.registerMissionObject( "TimeOfDay",    "Time of Day" );
-      %this.registerMissionObject( "Zone",         "Zone" );
-      %this.registerMissionObject( "Portal",       "Zone Portal" );
-      %this.registerMissionObject( "SpawnSphere",  "Player Spawn Sphere", "PlayerDropPoint" );
-      %this.registerMissionObject( "SpawnSphere",  "Observer Spawn Sphere", "ObserverDropPoint" );
-      %this.registerMissionObject( "SpawnSphere",  "General Spawn Sphere", "GeneralDropPoint" );
-      %this.registerMissionObject( "SFXSpace",      "Sound Space" );
-      %this.registerMissionObject( "OcclusionVolume", "Occlusion Volume" );
-      %this.registerMissionObject( "AccumulationVolume", "Accumulation Volume" );
-      %this.registerMissionObject("NavMesh", "Navigation mesh");
-      %this.registerMissionObject("NavPath", "Path");
-      %this.registerMissionObject( "Entity",       "Entity" );
-      %this.registerMissionObject( "NotesObject",       "Note" );
-      
-   %this.endGroup();
-   
-   %this.beginGroup( "System" );
-   
-      %this.registerMissionObject( "SimGroup" );
-      
-   %this.endGroup();  
-
-   %this.beginGroup( "ExampleObjects" );
-   
-      %this.registerMissionObject( "RenderObjectExample" );
-      %this.registerMissionObject( "RenderMeshExample" );
-      %this.registerMissionObject( "RenderShapeExample" );
-      
-   %this.endGroup(); 
-}
-
 function ObjectCreator::onWake( %this )
 {
-   CreatorTabBook.selectPage( 0 );
-   CreatorTabBook.onTabSelected( "Scripted" );
 }
 
 function ObjectCreator::beginGroup( %this, %group )
@@ -159,8 +63,6 @@ function ObjectCreator::registerMissionObject( %this, %class, %name, %buildfunc,
    %args.val[0] = %class;
    %args.val[1] = %name;
    %args.val[2] = %buildfunc;
-   
-   %this.array.push_back( %group, %args );
 }
 
 function ObjectCreator::getNewObjectGroup( %this )
@@ -271,330 +173,6 @@ function ObjectCreator::onObjectCreated( %this, %objId )
    EWorldEditor.dropSelection( true );
 }
 
-function CreatorTabBook::onTabSelected( %this, %text, %idx )
-{
-   if ( %this.isAwake() )
-   {
-      ObjectCreator.tab = %text;      
-      ObjectCreator.navigate( "" );
-   }
-}
-
-function ObjectCreator::navigate( %this, %address )
-{
-   CreatorIconArray.frozen = true;
-   CreatorIconArray.clear();  
-   CreatorPopupMenu.clear();       
-        
-   if ( %this.tab $= "Scripted" )
-   {
-      %category = getWord( %address, 1 );                  
-      %dataGroup = "DataBlockGroup";
-      
-      for ( %i = 0; %i < %dataGroup.getCount(); %i++ )
-      {
-         %obj = %dataGroup.getObject(%i);
-         // echo ("Obj: " @ %obj.getName() @ " - " @ %obj.category );
-         
-         if ( %obj.category $= "" && %obj.category == 0 )
-            continue;
-            
-         // Add category to popup menu if not there already
-         if ( CreatorPopupMenu.findText( %obj.category ) == -1 )
-            CreatorPopupMenu.add( %obj.category );
-         
-         if ( %address $= "" )
-         {         
-            %ctrl = %this.findIconCtrl( %obj.category );
-            if ( %ctrl == -1 )
-            {
-               %this.addFolderIcon( %obj.category );
-            }    
-         }
-         else if ( %address $= %obj.category )
-         {            
-            %ctrl = %this.findIconCtrl( %obj.getName() );
-            if ( %ctrl == -1 )
-               %this.addShapeIcon( %obj );
-         }
-      }
-   }
-   
-   if ( %this.tab $= "Meshes" )
-   {      
-      %fullPath = findFirstFileMultiExpr( getFormatExtensions() );
-      
-      while ( %fullPath !$= "" )
-      {
-         if (strstr(%fullPath, "cached.dts") != -1)
-         {
-            %fullPath = findNextFileMultiExpr( getFormatExtensions() );
-            continue;
-         }
-
-         %fullPath = makeRelativePath( %fullPath, getMainDotCSDir() );                                  
-         %splitPath = strreplace( %fullPath, " ", "_" );
-         %splitPath = strreplace( %splitPath, "/", " " );
-         if( getWord(%splitPath, 0) $= "tools" )
-         {
-            %fullPath = findNextFileMultiExpr( getFormatExtensions() );
-            continue;
-         }
-                      
-         %dirCount = getWordCount( %splitPath ) - 1;
-         
-         %pathFolders = getWords( %splitPath, 0, %dirCount - 1 );         
-         
-         // Add this file's path (parent folders) to the
-         // popup menu if it isn't there yet.
-         %temp = strreplace( %pathFolders, " ", "/" );         
-         %temp = strreplace( %temp, "_", " " );
-         %r = CreatorPopupMenu.findText( %temp );
-         if ( %r == -1 )
-         {
-            CreatorPopupMenu.add( %temp );
-         }
-         
-         // Is this file in the current folder?        
-         if ( stricmp( %pathFolders, %address ) == 0 )
-         {
-            %this.addStaticIcon( %fullPath );
-         }
-         // Then is this file in a subfolder we need to add
-         // a folder icon for?
-         else
-         {
-            %wordIdx = 0;
-            %add = false;
-            
-            if ( %address $= "" )
-            {
-               %add = true;
-               %wordIdx = 0;
-            }
-            else
-            {
-               for ( ; %wordIdx < %dirCount; %wordIdx++ )
-               {
-                  %temp = getWords( %splitPath, 0, %wordIdx );
-                  if ( stricmp( %temp, %address ) == 0 )
-                  {                  
-                     %add = true;
-                     %wordIdx++;
-                     break;  
-                  }
-               }
-            }
-            
-            if ( %add == true )
-            {               
-               %folder = getWord( %splitPath, %wordIdx );
-               
-               %ctrl = %this.findIconCtrl( %folder );
-               if ( %ctrl == -1 )
-                  %this.addFolderIcon( %folder );
-            }
-         }         
-
-         %fullPath = findNextFileMultiExpr( getFormatExtensions() );
-      }
-   }
-   
-   if ( %this.tab $= "Level" )
-   {         
-      // Add groups to popup menu
-      %array = %this.array;
-      %array.sortk();
-      
-      %count = %array.count();
-      
-      if ( %count > 0 )
-      {
-         %lastGroup = "";
-         
-         for ( %i = 0; %i < %count; %i++ )
-         {
-            %group = %array.getKey( %i );
-
-            if ( %group !$= %lastGroup )
-            {
-               CreatorPopupMenu.add( %group );
-               
-               if ( %address $= "" )
-                  %this.addFolderIcon( %group );                                             
-            }               
-            
-            if ( %address $= %group )
-            {
-               %args = %array.getValue( %i );
-               %class = %args.val[0];
-               %name = %args.val[1];
-               %func = %args.val[2];
-
-               %this.addMissionObjectIcon( %class, %name, %func );
-            }
-            
-            %lastGroup = %group;
-         }
-      }
-   }   
-   
-   if ( %this.tab $= "Prefabs" )
-   {      
-      %expr = "*.prefab";
-      %fullPath = findFirstFile( %expr );
-      
-      while ( %fullPath !$= "" )
-      {         
-         %fullPath = makeRelativePath( %fullPath, getMainDotCSDir() );                                  
-         %splitPath = strreplace( %fullPath, " ", "_" );
-         %splitPath = strreplace( %splitPath, "/", " " );
-         if( getWord(%splitPath, 0) $= "tools" )
-         {
-            %fullPath = findNextFile( %expr );
-            continue;
-         }
-                      
-         %dirCount = getWordCount( %splitPath ) - 1;
-         
-         %pathFolders = getWords( %splitPath, 0, %dirCount - 1 );         
-         
-         // Add this file's path (parent folders) to the
-         // popup menu if it isn't there yet.
-         %temp = strreplace( %pathFolders, " ", "/" );         
-         %temp = strreplace( %temp, "_", " " );
-         %r = CreatorPopupMenu.findText( %temp );
-         if ( %r == -1 )
-         {
-            CreatorPopupMenu.add( %temp );
-         }
-         
-         // Is this file in the current folder?        
-         if ( (%dirCount == 0 && %address $= "") || stricmp( %pathFolders, %address ) == 0 )
-         {
-            %this.addPrefabIcon( %fullPath );            
-         }
-         // Then is this file in a subfolder we need to add
-         // a folder icon for?
-         else
-         {
-            %wordIdx = 0;
-            %add = false;
-            
-            if ( %address $= "" )
-            {
-               %add = true;
-               %wordIdx = 0;
-            }
-            else
-            {
-               for ( ; %wordIdx < %dirCount; %wordIdx++ )
-               {
-                  %temp = getWords( %splitPath, 0, %wordIdx );
-                  if ( stricmp( %temp, %address ) == 0 )
-                  {                  
-                     %add = true;
-                     %wordIdx++;
-                     break;  
-                  }
-               }
-            }
-            
-            if ( %add == true )
-            {               
-               %folder = getWord( %splitPath, %wordIdx );
-               
-               %ctrl = %this.findIconCtrl( %folder );
-               if ( %ctrl == -1 )
-                  %this.addFolderIcon( %folder );
-            }
-         }         
-
-         %fullPath = findNextFile( %expr );
-      }
-   } 
-   
-   CreatorIconArray.sort( "alphaIconCompare" );
-   
-   for ( %i = 0; %i < CreatorIconArray.getCount(); %i++ )
-   {
-      CreatorIconArray.getObject(%i).autoSize = false;         
-   }
-   
-   CreatorIconArray.frozen = false;
-   CreatorIconArray.refresh();
-   
-   // Recalculate the array for the parent guiScrollCtrl
-   CreatorIconArray.getParent().computeSizes();  
-   
-   %this.address = %address;
-
-   CreatorPopupMenu.sort();
-
-   %str = strreplace( %address, " ", "/" );
-   %r = CreatorPopupMenu.findText( %str );
-   if ( %r != -1 )
-      CreatorPopupMenu.setSelected( %r, false );
-   else
-      CreatorPopupMenu.setText( %str );
-   CreatorPopupMenu.tooltip = %str;
-}
-
-function ObjectCreator::navigateDown( %this, %folder )
-{
-   if ( %this.address $= "" )
-      %address = %folder;
-   else   
-      %address = %this.address SPC %folder;
-
-   // Because this is called from an IconButton::onClick command
-   // we have to wait a tick before actually calling navigate, else
-   // we would delete the button out from under itself.
-   %this.schedule( 1, "navigate", %address );
-}
-
-function ObjectCreator::navigateUp( %this )
-{
-   %count = getWordCount( %this.address );
-   
-   if ( %count == 0 )
-      return;
-      
-   if ( %count == 1 )
-      %address = "";
-   else      
-      %address = getWords( %this.address, 0, %count - 2 );
-      
-   %this.navigate( %address );
-}
-
-function ObjectCreator::setListView( %this, %noupdate )
-{
-   //CreatorIconArray.clear();
-   //CreatorIconArray.setVisible( false );
-   
-   CreatorIconArray.setVisible( true );
-   %this.contentCtrl = CreatorIconArray;   
-   %this.isList = true;
-   
-   if ( %noupdate == true )
-      %this.navigate( %this.address );
-}
-
-//function ObjectCreator::setIconView( %this )
-//{
-   //echo( "setIconView" );
-   //
-   //CreatorIconStack.clear();
-   //CreatorIconStack.setVisible( false );
-   //
-   //CreatorIconArray.setVisible( true );
-   //%this.contentCtrl = CreatorIconArray;
-   //%this.isList = false;
-   //
-   //%this.navigate( %this.address );
-//}
-
 function ObjectCreator::findIconCtrl( %this, %name )
 {
    for ( %i = 0; %i < %this.contentCtrl.getCount(); %i++ )
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/visibility/shaders/Viz_SurfacePropertiesP.hlsl b/Templates/BaseGame/game/tools/worldEditor/scripts/visibility/shaders/Viz_SurfacePropertiesP.hlsl
index b489519a7..519de284e 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/visibility/shaders/Viz_SurfacePropertiesP.hlsl
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/visibility/shaders/Viz_SurfacePropertiesP.hlsl
@@ -33,7 +33,6 @@ TORQUE_UNIFORM_SAMPLER2D(backbufferTex, 4);
 TORQUE_UNIFORM_SAMPLER2D(glowBuffer, 5);
 
 uniform float mode;
-uniform float3 eyePosWorld;
 uniform float4x4 cameraToWorld;
 
 float4 main( PFXVertToPix IN ) : TORQUE_TARGET0

From 87ea262ef020bbfd5d367504a80dcba64e5ea29b Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Thu, 17 Mar 2022 03:09:11 -0500
Subject: [PATCH 335/399] Fixes handling of the setEditor commands so that the
 dropdown Editors menubar entry properly works

---
 .../worldEditor/scripts/menuHandlers.ed.tscript    | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/menuHandlers.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/menuHandlers.ed.tscript
index a2ea3b015..c0beb15f7 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/menuHandlers.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/menuHandlers.ed.tscript
@@ -910,10 +910,18 @@ function EditorMenuEditPaste()
 
 function EditorToolsMenu::onSelectItem(%this, %id)
 {
-   %toolName = getField( %this.item[%id], 2 );  
+   %tool = getField( %this.item[%id], 2 ); 
 
-   %paletteName = "";
-   EditorGui.setEditor(%toolName, %paletteName  );
+   if(isObject(%tool)) 
+   {
+      %paletteName = "";
+      EditorGui.setEditor(%tool, %paletteName  );
+   }
+   else
+   {
+      //it's an embedded command, so we'll just execute it
+      eval(%tool);  
+   }
    
    %this.checkRadioItem(0, %this.getItemCount(), %id);
    return true;

From d883575d0fe0f7230c2584c9d9e60a3c5ef48176 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Thu, 17 Mar 2022 17:38:41 -0500
Subject: [PATCH 336/399] fix compilation flaws

---
 Engine/source/assets/assetDefinition.h     | 2 +-
 Engine/source/console/consoleFunctions.cpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Engine/source/assets/assetDefinition.h b/Engine/source/assets/assetDefinition.h
index fb5720394..1a2a2ba1b 100644
--- a/Engine/source/assets/assetDefinition.h
+++ b/Engine/source/assets/assetDefinition.h
@@ -36,7 +36,7 @@
 #endif
 
 #ifndef _SIMSET_H_
-#include "console/simset.h"
+#include "console/simSet.h"
 #endif
 
 #ifndef _CONSOLEOBJECT_H_
diff --git a/Engine/source/console/consoleFunctions.cpp b/Engine/source/console/consoleFunctions.cpp
index 099f7090d..4b43518e5 100644
--- a/Engine/source/console/consoleFunctions.cpp
+++ b/Engine/source/console/consoleFunctions.cpp
@@ -2861,7 +2861,7 @@ DefineEngineFunction(getTimestamp, const char*, (), ,
 }
 
 #ifdef TORQUE_TOOLS
-DefineEngineFunction(systemCommand, S32, (const char* commandLineAction, const char* callBackFunction), , "", "")
+DefineEngineFunction(systemCommand, S32, (const char* commandLineAction, const char* callBackFunction), (""), "")
 {
    if (commandLineAction != "")
    {

From 8cea8ec01149e475b8dcf9d90bf60594d3691412 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Sat, 19 Mar 2022 13:03:33 -0500
Subject: [PATCH 337/399] extended callonModules hooks for baseline playgui
 used for the noticeSystem chathud injection sample

---
 .../game/data/gameUI/GUIs/playGui.tscript     | 71 +------------------
 1 file changed, 3 insertions(+), 68 deletions(-)

diff --git a/Templates/BaseGame/game/data/gameUI/GUIs/playGui.tscript b/Templates/BaseGame/game/data/gameUI/GUIs/playGui.tscript
index 2f175c025..82ce8a552 100644
--- a/Templates/BaseGame/game/data/gameUI/GUIs/playGui.tscript
+++ b/Templates/BaseGame/game/data/gameUI/GUIs/playGui.tscript
@@ -32,31 +32,17 @@ function PlayGui::onWake(%this)
 
    $enableDirectInput = "1";
    activateDirectInput();
-
-   // Message hud dialog
-   if ( isObject( MainChatHud ) )
-   {
-      Canvas.pushDialog( MainChatHud );
-      chatHud.attach(HudMessageVector);
-   }      
    
    // just update the action map here
    if(isObject(moveMap))
       moveMap.push();
-
-   // hack city - these controls are floating around and need to be clamped
-   if ( isFunction( "refreshCenterTextCtrl" ) )
-      schedule(0, 0, "refreshCenterTextCtrl");
-   if ( isFunction( "refreshBottomTextCtrl" ) )
-      schedule(0, 0, "refreshBottomTextCtrl");
       
    callOnModules("Playgui_onWake");
 }
 
 function PlayGui::onSleep(%this)
 {
-   if ( isObject( MainChatHud ) )
-      Canvas.popDialog( MainChatHud );
+   callOnModules("Playgui_onSleep");
    
    // pop the keymaps
    if(isObject(moveMap))
@@ -65,60 +51,9 @@ function PlayGui::onSleep(%this)
 
 function PlayGui::clearHud( %this )
 {
+   callOnModules("Playgui_clearHud");
    Canvas.popDialog( MainChatHud );
 
    while ( %this.getCount() > 0 )
       %this.getObject( 0 ).delete();
-}
-
-//-----------------------------------------------------------------------------
-
-function refreshBottomTextCtrl()
-{
-   BottomPrintText.position = "0 0";
-}
-
-function refreshCenterTextCtrl()
-{
-   CenterPrintText.position = "0 0";
-}
-
-/*function PlayGui::onRightMouseDown(%this)
-{
-   %this.nocursor = true;
-   Canvas.checkCursor();
-}
-
-function PlayGui::onRightMouseUp(%this)
-{
-   %this.nocursor = false;
-   Canvas.checkCursor();
-}*/
-
-/*function PlayGui::onInputEvent(%this, %device, %action, %state)
-{
-   if(%device $= "mouse0" && %action $= "button1")
-   {
-      if(%state == 1)
-      {
-         %this.nocursor = true;
-         Canvas.checkCursor();
-      }
-      else 
-      {
-         %this.nocursor = false;
-         Canvas.checkCursor();
-      }
-   }
-   else if(%device $= "keyboard")
-   {
-      if(%action $= "w")
-         moveforward(%state);
-      else if(%action $= "a")
-         moveleft(%state);
-      else if(%action $= "s")
-         movebackward(%state);
-      else if(%action $= "d")
-         moveright(%state);
-   }
-}*/
\ No newline at end of file
+}
\ No newline at end of file

From b3342ff7e6709eaee86b3bf311d635270a8104ff Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Sun, 20 Mar 2022 03:17:31 -0500
Subject: [PATCH 338/399] Adds handling for import of files marked as
 ShapeAnimationAsset Adds filetype handling of dsqs for importing Improves
 logic checks to prevent incorrectly redundantly processing incoming assets
 for collisions, which could mark all assets as colliding instead of all but
 the first. Adds better handling for assets marked as for dependency usage
 when importing Improves rules for writing originalFilePath only if it's
 actually from an external directory, and the file actually exists to prevent
 polluting in redundant or garbage data Fixes issue where MaterialEditor was
 not tracking the currently material assetId if the material was changed via
 the dropdown selector Adds a sanity check to shapeAnimationAsset load so if
 the resource does not load properly it doesn't hard crash but instead logs
 the error and returns safely.

---
 .../source/T3D/assets/ShapeAnimationAsset.cpp |   2 +-
 Engine/source/T3D/assets/assetImporter.cpp    | 117 ++++++++++++++++--
 Engine/source/T3D/assets/assetImporter.h      |  18 ++-
 .../tools/assetBrowser/assetImportConfigs.xml |   2 +-
 .../assetBrowser/scripts/assetImport.tscript  |   3 +-
 .../scripts/assetTypes/image.tscript          |   7 +-
 .../scripts/assetTypes/material.tscript       |   8 +-
 .../scripts/assetTypes/shape.tscript          |   7 +-
 .../scripts/materialEditor.ed.tscript         |  10 ++
 .../scripts/projectImporter.tscript           |   3 +
 10 files changed, 160 insertions(+), 17 deletions(-)

diff --git a/Engine/source/T3D/assets/ShapeAnimationAsset.cpp b/Engine/source/T3D/assets/ShapeAnimationAsset.cpp
index 50d668a1f..f7e1b6aa5 100644
--- a/Engine/source/T3D/assets/ShapeAnimationAsset.cpp
+++ b/Engine/source/T3D/assets/ShapeAnimationAsset.cpp
@@ -151,7 +151,7 @@ void ShapeAnimationAsset::initializeAsset(void)
 
       mSourceShape = ResourceManager::get().load(mFilePath);
 
-      if (!mSourceShape->addSequence("ambient", "", mAnimationName, mStartFrame, mEndFrame, mPadRotation, mPadTransforms))
+      if (!mSourceShape || !mSourceShape->addSequence("ambient", "", mAnimationName, mStartFrame, mEndFrame, mPadRotation, mPadTransforms))
       {
          Con::errorf("ShapeAnimationAsset::initializeAsset - Unable to do initial setup of the animation clip named %s for asset %s", mAnimationName, getAssetName());
          return;
diff --git a/Engine/source/T3D/assets/assetImporter.cpp b/Engine/source/T3D/assets/assetImporter.cpp
index f965bd42c..932874fbd 100644
--- a/Engine/source/T3D/assets/assetImporter.cpp
+++ b/Engine/source/T3D/assets/assetImporter.cpp
@@ -79,6 +79,8 @@ AssetImportConfig::AssetImportConfig() :
    SeparateAnimationPrefix(""),
    animTiming("FrameCount"),
    animFPS(false),
+   AlwaysAddShapeAnimationSuffix(true),
+   AddedShapeAnimationSuffix("_anim"),
    GenerateCollisions(false),
    GenCollisionType(""),
    CollisionMeshPrefix(""),
@@ -190,6 +192,8 @@ void AssetImportConfig::initPersistFields()
       addField("SeparateAnimationPrefix", TypeRealString, Offset(SeparateAnimationPrefix, AssetImportConfig), "If separating animations out from a source file, what prefix should be added to the names for grouping association");
       addField("animTiming", TypeRealString, Offset(animTiming, AssetImportConfig), "Defines the animation timing for the given animation sequence. Options are FrameTime, Seconds, Milliseconds");
       addField("animFPS", TypeBool, Offset(animFPS, AssetImportConfig), "The FPS of the animation sequence");
+      addField("AlwaysAddShapeAnimationSuffix", TypeBool, Offset(AlwaysAddShapeAnimationSuffix, AssetImportConfig), "When importing a shape animation, this indicates if it should automatically add a standard suffix onto the name");
+      addField("AddedShapeAnimationSuffix", TypeString, Offset(AddedShapeAnimationSuffix, AssetImportConfig), " If AlwaysAddShapeAnimationSuffix is on, this is the suffix to be added");
    endGroup("Animation");
 
    addGroup("Collision");
@@ -287,6 +291,8 @@ void AssetImportConfig::loadImportConfig(Settings* configSettings, String config
    SeparateAnimationPrefix = configSettings->value(String(configName + "/Animations/SeparateAnimationPrefix").c_str());
    animTiming = configSettings->value(String(configName + "/Animations/animTiming").c_str());
    animFPS = dAtof(configSettings->value(String(configName + "/Animations/animFPS").c_str()));
+   AlwaysAddShapeAnimationSuffix = dAtob(configSettings->value(String(configName + "/Animations/AlwaysAddShapeAnimationSuffix").c_str()));
+   AddedShapeAnimationSuffix = configSettings->value(String(configName + "/Animations/AddedShapeAnimationSuffix").c_str());
 
    //Collisions
    GenerateCollisions = dAtob(configSettings->value(String(configName + "/Collision/GenerateCollisions").c_str()));
@@ -379,6 +385,8 @@ void AssetImportConfig::CopyTo(AssetImportConfig* target) const
    target->SeparateAnimationPrefix = SeparateAnimationPrefix;
    target->animTiming = animTiming;
    target->animFPS = animFPS;
+   target->AlwaysAddShapeAnimationSuffix = AlwaysAddShapeAnimationSuffix;
+   target->AddedShapeAnimationSuffix = AddedShapeAnimationSuffix;
 
    //Collisions
    target->GenerateCollisions = GenerateCollisions;
@@ -1531,13 +1539,15 @@ void AssetImporter::processImportAssets(AssetImportObject* assetItem)
 		{
 		   processMaterialAsset(item);
 		}
-		/*else if (item->assetType == String("ShapeAnimationAsset"))
-		   ShapeAnimationAsset::prepareAssetForImport(this, item);*/
+      else if (item->assetType == String("ShapeAnimationAsset"))
+      {
+         processShapeAnimationAsset(item);
+      }
 		else
 		{
 		   String processCommand = "process";
 		   processCommand += item->assetType;
-		   if(isMethod(processCommand.c_str()))
+         if (isMethod(processCommand.c_str()))
 		      Con::executef(this, processCommand.c_str(), item);
 		}
 
@@ -2048,6 +2058,73 @@ void AssetImporter::processShapeAsset(AssetImportObject* assetItem)
    assetItem->importStatus = AssetImportObject::Processed;
 }
 
+void AssetImporter::processShapeAnimationAsset(AssetImportObject* assetItem)
+{
+   dSprintf(importLogBuffer, sizeof(importLogBuffer), "Preparing Shape Animation for Import: %s", assetItem->assetName.c_str());
+   activityLog.push_back(importLogBuffer);
+
+   String filePath = assetItem->filePath.getFullPath();
+   String fileName = assetItem->filePath.getFileName();
+   String fileExt = assetItem->filePath.getExtension();
+
+   if (assetItem->shapeInfo == nullptr)
+   {
+      GuiTreeViewCtrl* shapeInfo = new GuiTreeViewCtrl();
+      shapeInfo->registerObject();
+
+      if (fileExt.compare("dae") == 0)
+      {
+         enumColladaForImport(filePath, shapeInfo, false);
+      }
+      else if (fileExt.compare("dts") == 0 || fileExt.compare("dsq") == 0)
+      {
+         enumDTSForImport(filePath, shapeInfo);
+      }
+      else
+      {
+         // Check if a cached DTS is available => no need to import the source file
+         // if we can load the DTS instead
+
+         AssimpShapeLoader loader;
+         loader.fillGuiTreeView(filePath.c_str(), shapeInfo);
+      }
+
+      assetItem->shapeInfo = shapeInfo;
+   }
+
+   if (activeImportConfig->AlwaysAddShapeAnimationSuffix)
+   {
+      assetItem->assetName += activeImportConfig->AddedShapeAnimationSuffix;
+      assetItem->cleanAssetName = assetItem->assetName;
+   }
+
+   S32 animCount = dAtoi(assetItem->shapeInfo->getDataField(StringTable->insert("_animCount"), nullptr));
+
+   dSprintf(importLogBuffer, sizeof(importLogBuffer), "   Shape Animation Info: Anim Count: %i", animCount);
+   activityLog.push_back(importLogBuffer);
+
+   AssetImportConfig* cachedConfig = new AssetImportConfig();;
+   cachedConfig->registerObject();
+   activeImportConfig->CopyTo(cachedConfig);
+
+   if (!activeImportConfig->UseManualShapeConfigRules)
+   {
+      //Try and load a sis file if it exists for this format
+      activeImportConfig->loadSISFile(assetItem->filePath);
+   }
+
+   if (activeImportConfig->ImportAnimations && animCount > 0)
+   {
+      
+   }
+
+   //restore the cached version just in case we loaded a sis file
+   cachedConfig->CopyTo(activeImportConfig);
+   cachedConfig->deleteObject();
+
+   assetItem->importStatus = AssetImportObject::Processed;
+}
+
 void AssetImporter::processShapeMaterialInfo(AssetImportObject* assetItem, S32 materialItemId)
 {
    String matName = assetItem->shapeInfo->getItemText(materialItemId);
@@ -2188,9 +2265,20 @@ bool AssetImporter::validateAssets()
 
 void AssetImporter::validateAsset(AssetImportObject* assetItem)
 {
-   if (assetItem->importStatus == AssetImportObject::Skipped || assetItem->importStatus == AssetImportObject::NotProcessed)
+   if (assetItem->importStatus == AssetImportObject::Skipped || assetItem->importStatus == AssetImportObject::NotProcessed
+      || assetItem->importStatus == AssetImportObject::UseForDependencies)
       return;
 
+   //If this item's already been marked as being in error, don't bother with it. It knows what it did.
+   //This avoids running collision checks on an item already known to have a collision, which could erroneously
+   //mark the original, not-colliding item as colliding with this item, invaliding both
+   if (assetItem->status == String("Error") || assetItem->statusType.isNotEmpty())
+   {
+      importIssues = true;
+      return;
+   }
+
+   //Runm this item against our other importing assets and check for any collisions
    if (checkAssetForCollision(assetItem))
    {
       importIssues = true;
@@ -2294,7 +2382,7 @@ bool AssetImporter::checkAssetForCollision(AssetImportObject* assetItemToCheck,
    {
       AssetImportObject* importingAsset = itemList[i];
 
-      if (importingAsset->importStatus == AssetImportObject::Skipped)
+      if (importingAsset->importStatus == AssetImportObject::Skipped || importingAsset->importStatus == AssetImportObject::UseForDependencies)
          continue;
 
       if ((assetItemToCheck->assetName.compare(importingAsset->assetName) == 0) && (assetItemToCheck->getId() != importingAsset->getId()))
@@ -2584,6 +2672,10 @@ void AssetImporter::importAssets(AssetImportObject* assetItem)
       {
          assetPath = importMaterialAsset(item);
       }
+      else if (item->assetType == String("ShapeAnimationAsset"))
+      {
+         assetPath = importShapeAnimationAsset(item);
+      }
       else
       {
          finalImportedAssetPath = String::EmptyString;
@@ -2625,7 +2717,7 @@ void AssetImporter::importAssets(AssetImportObject* assetItem)
             else
             {
                //Any special-case post-reg stuff here
-               if (item->assetType == String("ShapeAsset"))
+               if (item->assetType == String("ShapeAsset") || item->assetType == String("ShapeAnimationAsset"))
                {
                   //forcefully update it's shape constructor
                   TSShapeConstructor* tss = TSShapeConstructor::findShapeConstructorByAssetId(assetId);
@@ -2692,7 +2784,7 @@ Torque::Path AssetImporter::importImageAsset(AssetImportObject* assetItem)
 
    //If it's not a re-import, check that the file isn't being in-place imported. If it isn't, store off the original
    //file path for reimporting support later
-   if (!isReimport && String::compare(qualifiedFromFile, qualifiedToFile))
+   if (!isReimport && String::compare(qualifiedFromFile, qualifiedToFile) && Platform::isFile(qualifiedFromFile))
    {
       newAsset->setDataField(StringTable->insert("originalFilePath"), nullptr, qualifiedFromFile);
    }
@@ -2750,7 +2842,12 @@ Torque::Path AssetImporter::importMaterialAsset(AssetImportObject* assetItem)
    Platform::makeFullPathName(originalPath.c_str(), qualifiedFromFile, sizeof(qualifiedFromFile));
 
    newAsset->setAssetName(assetName);
+
+   if (!isReimport && Platform::isFile(qualifiedFromFile))
+   {
    newAsset->setDataField(StringTable->insert("originalFilePath"), nullptr, qualifiedFromFile);
+   }
+
    newAsset->setDataField(StringTable->insert("materialDefinitionName"), nullptr, assetName);
 
    //iterate through and write out the material maps dependencies
@@ -2930,7 +3027,7 @@ Torque::Path AssetImporter::importShapeAsset(AssetImportObject* assetItem)
 
    //If it's not a re-import, check that the file isn't being in-place imported. If it isn't, store off the original
    //file path for reimporting support later
-   if (!isReimport && String::compare(qualifiedFromFile, qualifiedToFile))
+   if (!isReimport && String::compare(qualifiedFromFile, qualifiedToFile) && Platform::isFile(qualifiedFromFile))
    {
       newAsset->setDataField(StringTable->insert("originalFilePath"), nullptr, qualifiedFromFile);
    }
@@ -3205,7 +3302,7 @@ Torque::Path AssetImporter::importSoundAsset(AssetImportObject* assetItem)
 
    //If it's not a re-import, check that the file isn't being in-place imported. If it isn't, store off the original
    //file path for reimporting support later
-   if (!isReimport && String::compare(qualifiedFromFile, qualifiedToFile))
+   if (!isReimport && String::compare(qualifiedFromFile, qualifiedToFile) && Platform::isFile(qualifiedFromFile))
    {
       newAsset->setDataField(StringTable->insert("originalFilePath"), nullptr, qualifiedFromFile);
    }
@@ -3261,7 +3358,7 @@ Torque::Path AssetImporter::importShapeAnimationAsset(AssetImportObject* assetIt
 
    //If it's not a re-import, check that the file isn't being in-place imported. If it isn't, store off the original
    //file path for reimporting support later
-   if (!isReimport && String::compare(qualifiedFromFile, qualifiedToFile))
+   if (!isReimport && String::compare(qualifiedFromFile, qualifiedToFile) && Platform::isFile(qualifiedFromFile))
    {
       newAsset->setDataField(StringTable->insert("originalFilePath"), nullptr, qualifiedFromFile);
    }
diff --git a/Engine/source/T3D/assets/assetImporter.h b/Engine/source/T3D/assets/assetImporter.h
index 6605ebe8f..4e2fc53aa 100644
--- a/Engine/source/T3D/assets/assetImporter.h
+++ b/Engine/source/T3D/assets/assetImporter.h
@@ -261,6 +261,16 @@ public:
    /// </summary>
    F32 animFPS;
 
+   /// <summary>
+   /// When importing a shape animation, this indicates if it should automatically add a standard suffix onto the name
+   /// </summary>
+   bool AlwaysAddShapeAnimationSuffix;
+
+   /// <summary>
+   /// If AlwaysAddShapeAnimationSuffix is on, this is the suffix to be added
+   /// </summary>
+   String AddedShapeAnimationSuffix;
+
    //
    //Collision
    /// <summary>
@@ -800,11 +810,17 @@ public:
    void processMaterialAsset(AssetImportObject* assetItem);
 
    /// <summary>
-   /// Process a specific AssetImportObject that is an ShapeAsset type to prepare it for importing
+   /// Process a specific AssetImportObject that is an ShapeAnimationAsset type to prepare it for importing
    /// <para>@param assetItem, The AssetImportObject to process</para>
    /// </summary>
    void processShapeAsset(AssetImportObject* assetItem);
 
+   /// <summary>
+   /// Process a specific AssetImportObject that is an ShapeAsset type to prepare it for importing
+   /// <para>@param assetItem, The AssetImportObject to process</para>
+   /// </summary>
+   void processShapeAnimationAsset(AssetImportObject* assetItem);
+
    /// <summary>
    /// Process a specific ShapeAsset AssetImportObject with a material id in order to parse and handle the materials listed in the shape file
    /// <para>@param assetItem, The AssetImportObject to process</para>
diff --git a/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml b/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml
index 5c91b3d2a..285c9d235 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml
+++ b/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml
@@ -195,7 +195,7 @@
             <Setting
                 name="AutomaticallyPromptMissingFiles">0</Setting>
             <Setting
-                name="DuplicateAutoResolution">FolderPrefix</Setting>
+                name="DuplicateAutoResolution">AutoPrune</Setting>
             <Setting
                 name="PreventImportWithErrors">1</Setting>
             <Setting
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImport.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImport.tscript
index 89f294486..0e9977c5c 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImport.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetImport.tscript
@@ -108,7 +108,8 @@ function isShapeFormat(%fileExt)
    (%fileExt $= ".gltf") || 
    (%fileExt $= ".glb") || 
    (%fileExt $= ".obj") || 
-   (%fileExt $= ".blend"))
+   (%fileExt $= ".blend") || 
+   (%fileExt $= ".dsq"))
       return true;
       
    return false;
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/image.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/image.tscript
index 81e0e56cd..f39d35349 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/image.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/image.tscript
@@ -148,10 +148,15 @@ function AssetBrowser::importImageAsset(%this, %assetItem)
       assetName = %assetName;
       versionId = 1;
       imageFile = fileName(%filePath);
-      originalFilePath = %filePath;
       imageType = %assetItem.imageType;
    };
    
+   //No point in indicating the original path data if it was imported in-place
+   if(!startsWith(makeFullPath(%filePath), getMainDotCsDir()))
+   {
+      %newAsset.originalFilePath = %filePath;
+   }
+   
    %assetImportSuccessful = TAMLWrite(%newAsset, %assetPath @ "/" @ %assetName @ ".asset.taml"); 
    
    //and copy the file into the relevent directory
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
index 3ea2a285b..880ff115e 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
@@ -321,10 +321,16 @@ function AssetBrowser::importMaterialAsset(%this, %assetItem)
       versionId = 1;
       shaderGraph = %sgfPath;
       scriptFile = %assetName @ "." @ $TorqueScriptFileExtension;
-      originalFilePath = %filePath;
       materialDefinitionName = %assetName;
    };
    
+   //No point in indicating the original path data if it was imported in-place
+   %mainPath = getMainDotCsDir();
+   if(!startsWith(makeFullPath(%filePath), getMainDotCsDir()))
+   {
+      %newAsset.originalFilePath = %filePath;
+   }
+   
    //check dependencies
    %dependencySlotId = 0;
    for(%i=0; %i < %assetItem.childAssetItems.count(); %i++)
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
index f497a2e55..7ce0acb1b 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
@@ -131,10 +131,15 @@ function AssetBrowser::importShapeAsset(%this, %assetItem)
       assetName = %assetName;
       versionId = 1;
       fileName = fileName(%filePath);
-      originalFilePath = %filePath;
       isNewShape = true;
    };
    
+   //No point in indicating the original path data if it was imported in-place
+   if(!startsWith(makeFullPath(%filePath), getMainDotCsDir()))
+   {
+      %newAsset.originalFilePath = %filePath;
+   }
+   
    //check dependencies
    %dependencySlotId = 0;
    for(%i=0; %i < %assetItem.childAssetItems.count(); %i++)
diff --git a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
index 56ac83a96..d157c817a 100644
--- a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
@@ -290,6 +290,15 @@ function SubMaterialSelector::onSelect( %this )
       if( MaterialEditorGui.currentObject.isMethod("postApply") )
          MaterialEditorGui.currentObject.postApply();*/
    }
+   else
+   {
+      %materialAssetId = MaterialAsset::getAssetIdByMaterialName(%material);
+      if(%materialAssetId !$= "" && %materialAssetId !$= $Core::NoMaterialAssetFallback)
+      {
+         MaterialEditorGui.currentMaterialAsset = %materialAssetId;
+         %assetDef = AssetDatabase.acquireAsset(%material);
+      }
+   }
 
    MaterialEditorGui.prepareActiveMaterial( %material.getId() );
 }
@@ -1950,6 +1959,7 @@ function MaterialEditorGui::save( %this )
      
    if(MaterialEditorGui.currentMaterialAsset !$= "")
    {
+      echo("Attempting to save material: " @ MaterialEditorGui.currentMaterialAsset);
       MaterialEditorGui.copyMaterials( materialEd_previewMaterial, notDirtyMaterial );
       
       %assetDef = AssetDatabase.acquireAsset(MaterialEditorGui.currentMaterialAsset);
diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
index eccb3b0f6..32d791227 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
@@ -1029,6 +1029,8 @@ function testFilenameExtensions(%filename)
       return %filename @ ".dae";
    else if(isFile(%filename @ ".dds"))
       return %filename @ ".dds";
+   else if(isFile(%filename @ ".dsq"))
+      return %filename @ ".dsq";
    else if(isFile(%filename @ ".ogg"))
       return %filename @ ".ogg";
    else if(isFile(%filename @ ".wav"))
@@ -2101,6 +2103,7 @@ function scanForDuplicateFiles(%toTestFile)
       //We only really care about content files for this
       if(!endsWith(%file, "dts") &&
          !endsWith(%file, "dae") && 
+         !endsWith(%file, "dsq") && 
          !endsWith(%file, "fbx") &&
          !endsWith(%file, "ter") &&
          !endsWith(%file, "png") &&

From cf8659735b47ea7d124003d41c7fb93464be0f19 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Sun, 20 Mar 2022 16:17:06 -0500
Subject: [PATCH 339/399] Adjusts handling so if a file being processed for
 importing is not actually imported as a new, successful asset it does not
 return an id, allowing tooling to only worry about actual new assets. Adds
 utility functions to TerrainBlock to be able to replace names of materials in
 the terrain file, mostly used for importing legacy files Adjusts terrainblock
 save asset logic to be able to save on a non-networked terrainblock such as
 when loaded temporarily on the server, for tooling purposes. Changes handling
 of not-found terrain materials when loading a terrain block so it will create
 a dummy terrain material with the same name as the not-found, but set the
 texture as the Warning image, instead of thrashing the original material
 names data Adds logic for testing newly imported terrain files' materials and
 if needbe, replacing them with the new terrain material asset ids. Adds logic
 in the project importer for if a would-be level asset's name already exists,
 we attempt to slap a "Level" suffix onto it to sidestep collisions. Changed
 LegacyImport config to try always adding shape suffix to help minimize
 probable naming collisions. Fixed handling of mission file's MissionGroup
 defines by specially checking for MissionGroup objects and processing the
 line into a Scene() declaration instead.

---
 Engine/source/T3D/assets/assetImporter.cpp    |  5 +-
 Engine/source/terrain/terrData.cpp            | 48 +++++++++++++++-
 Engine/source/terrain/terrData.h              | 13 +++++
 Engine/source/terrain/terrMaterial.cpp        | 27 +++++----
 .../tools/assetBrowser/assetImportConfigs.xml |  2 +-
 .../pre40/T3Dpre4ProjectImporter.tscript      | 49 +++++++++++++---
 .../scripts/projectImporter.tscript           | 56 ++++++++++++++++++-
 7 files changed, 176 insertions(+), 24 deletions(-)

diff --git a/Engine/source/T3D/assets/assetImporter.cpp b/Engine/source/T3D/assets/assetImporter.cpp
index f965bd42c..a3d1a4e21 100644
--- a/Engine/source/T3D/assets/assetImporter.cpp
+++ b/Engine/source/T3D/assets/assetImporter.cpp
@@ -2534,7 +2534,10 @@ StringTableEntry AssetImporter::autoImportFile(Torque::Path filePath, String typ
 
    dumpActivityLog();
 
-   if (hasIssues)
+   if (hasIssues ||
+      assetItem->importStatus == AssetImportObject::Skipped ||
+      assetItem->importStatus == AssetImportObject::UseForDependencies ||
+      assetItem->importStatus == AssetImportObject::Error)
    {
       return StringTable->EmptyString();
    }
diff --git a/Engine/source/terrain/terrData.cpp b/Engine/source/terrain/terrData.cpp
index 532e0cc19..29523e609 100644
--- a/Engine/source/terrain/terrData.cpp
+++ b/Engine/source/terrain/terrData.cpp
@@ -480,16 +480,21 @@ bool TerrainBlock::saveAsset()
 
       AssetDatabase.findAssetType(pAssetQuery, "TerrainMaterialAsset");
 
-      TerrainBlock* clientTerr = static_cast<TerrainBlock*>(getClientObject());
+      TerrainBlock* terr = static_cast<TerrainBlock*>(getClientObject());
+      if (!terr)
+      {
+         Con::warnf("No active client terrain while trying to save asset. Could be a server action, but should check to be sure!");
+         terr = this;
+      }
 
       for (U32 i = 0; i < pAssetQuery->mAssetList.size(); i++)
       {
          //Acquire it so we can check it for matches
          AssetPtr<TerrainMaterialAsset> terrMatAsset = pAssetQuery->mAssetList[i];
 
-         for (U32 m = 0; m < clientTerr->mFile->mMaterials.size(); m++)
+         for (U32 m = 0; m < terr->mFile->mMaterials.size(); m++)
          {
-            StringTableEntry intMatName = clientTerr->mFile->mMaterials[m]->getInternalName();
+            StringTableEntry intMatName = terr->mFile->mMaterials[m]->getInternalName();
 
             StringTableEntry assetMatDefName = terrMatAsset->getMaterialDefinitionName();
             if (assetMatDefName == intMatName)
@@ -1456,6 +1461,25 @@ void TerrainBlock::getUtilizedAssets(Vector<StringTableEntry>* usedAssetsList)
 // Console Methods
 //-----------------------------------------------------------------------------
 
+bool TerrainBlock::renameTerrainMaterial(StringTableEntry oldMatName, StringTableEntry newMatName)
+{
+   TerrainMaterial* newMat = TerrainMaterial::findOrCreate(newMatName);
+   if (!newMat)
+      return false;
+
+   U32 terrainMaterialCount = mFile->mMaterials.size();
+   for (U32 i = 0; i < terrainMaterialCount; i++)
+   {
+      if (mFile->mMaterials[i]->getInternalName() == oldMatName)
+      {
+         TerrainMaterial* oldMat = mFile->mMaterials[i];
+         mFile->mMaterials[i] = newMat;
+      }
+   }
+
+   return true;
+}
+
 DefineEngineMethod( TerrainBlock, save, bool, ( const char* fileName),,
 				   "@brief Saves the terrain block's terrain file to the specified file name.\n\n"
 
@@ -1623,3 +1647,21 @@ DefineEngineMethod(TerrainBlock, setTerrain, bool, (const char* terrain), , "Ter
 {
    return object->_setTerrain(StringTable->insert(terrain));
 }
+
+DefineEngineMethod(TerrainBlock, getTerrainMaterialCount, S32, (), , "Gets the number of terrain materials for this block")
+{
+   return object->getTerrainMaterialCount();
+}
+
+DefineEngineMethod(TerrainBlock, getTerrainMaterialName, const char*, (S32 index), , "Gets the number of terrain materials for this block")
+{
+   if (index < 0 || index >= object->getTerrainMaterialCount())
+      return StringTable->EmptyString();
+
+   return object->getTerrainMaterialName(index);
+}
+
+DefineEngineMethod(TerrainBlock, renameTerrainMaterial, bool, (const char* oldMaterialName, const char* newMaterialName), , "Updates the terrain material from the original to the new name in the file. Mostly used for import/conversions.")
+{
+   return object->renameTerrainMaterial(StringTable->insert(oldMaterialName), StringTable->insert(newMaterialName));
+}
diff --git a/Engine/source/terrain/terrData.h b/Engine/source/terrain/terrData.h
index cc1479004..07a023371 100644
--- a/Engine/source/terrain/terrData.h
+++ b/Engine/source/terrain/terrData.h
@@ -522,6 +522,19 @@ public:
       return true;
    }
  
+   bool renameTerrainMaterial(StringTableEntry oldMatName, StringTableEntry newMatName);
+   S32 getTerrainMaterialCount() {
+      if (mFile)
+         return mFile->mMaterials.size();
+      return 0;
+   }
+
+   StringTableEntry getTerrainMaterialName(S32 index) {
+      if (mFile)
+         return mFile->mMaterials[index]->getInternalName();
+
+      return StringTable->EmptyString();
+   }
 protected:
    bool mUpdateBasetex;
    bool mIgnoreZodiacs;
diff --git a/Engine/source/terrain/terrMaterial.cpp b/Engine/source/terrain/terrMaterial.cpp
index fa3b21f0a..289c9a16f 100644
--- a/Engine/source/terrain/terrMaterial.cpp
+++ b/Engine/source/terrain/terrMaterial.cpp
@@ -30,6 +30,8 @@
 #include "console/persistenceManager.h"
 #endif
 
+#include "T3D/assets/TerrainMaterialAsset.h"
+
 #include <string>
 
 
@@ -166,6 +168,18 @@ TerrainMaterial* TerrainMaterial::findOrCreate( const char *nameOrPath )
    if ( mat )
       return mat;
 
+   StringTableEntry assetId = TerrainMaterialAsset::getAssetIdByMaterialName(nameOrPath);
+   if (assetId != StringTable->EmptyString())
+   {
+      TerrainMaterialAsset* terrMatAsset = AssetDatabase.acquireAsset<TerrainMaterialAsset>(assetId);
+      if (terrMatAsset)
+      {
+         mat = terrMatAsset->getMaterialDefinition();
+         if (mat)
+            return mat;
+      }
+   }
+
    // We didn't find it... so see if its a path to a
    // file.  If it is lets assume its the texture.
    if ( GBitmap::sFindFiles( nameOrPath, NULL ) )
@@ -178,15 +192,9 @@ TerrainMaterial* TerrainMaterial::findOrCreate( const char *nameOrPath )
       return mat;
    }
 
-   // Ok... return a debug material then.
-   mat = dynamic_cast<TerrainMaterial*>( set->findObjectByInternalName( StringTable->insert( "warning_material" ) ) );
-   if ( !mat )
-   {
-      // This shouldn't happen.... the warning_texture should
-      // have already been defined in script, but we put this
-      // fallback here just in case it gets "lost".
+   // Ok... return a placeholder material then.
       mat = new TerrainMaterial();
-      mat->setInternalName( "warning_material" );
+   mat->setInternalName(nameOrPath);
       mat->_setDiffuseMap(GFXTextureManager::getWarningTexturePath());
       mat->mDiffuseSize = 500;
       mat->_setDetailMap(StringTable->EmptyString());
@@ -195,8 +203,7 @@ TerrainMaterial* TerrainMaterial::findOrCreate( const char *nameOrPath )
 	   mat->mMacroSize = 200;
       mat->registerObject();
       
-      Sim::getRootGroup()->addObject( mat );
-   }
+   Sim::getRootGroup()->addObject(mat);
 
    return mat;
 }
diff --git a/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml b/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml
index 5c91b3d2a..b74012fb2 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml
+++ b/Templates/BaseGame/game/tools/assetBrowser/assetImportConfigs.xml
@@ -110,7 +110,7 @@
             <Setting
                 name="AdjustFloor">0</Setting>
             <Setting
-                name="AlwaysAddShapeSuffix">0</Setting>
+                name="AlwaysAddShapeSuffix">1</Setting>
             <Setting
                 name="calcTangentSpace">0</Setting>
             <Setting
diff --git a/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript
index abbe166e0..00f890cf1 100644
--- a/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript
@@ -353,6 +353,7 @@ function T3Dpre4ProjectImporter::beginMaterialFilesImport(%this)
       %file = $ProjectImporter::FileList.getKey(%i);
       %rootFileSectionObject = $ProjectImporter::FileList.getValue(%i);
       
+      $ProjectImporter::currentFile = %rootFileSectionObject.fileDestination;
       $ProjectImporter::currentFilePath = filePath(%rootFileSectionObject.fileDestination) @ "/"; //give context to the file we're processing
       
       if(%rootFileSectionObject.binaryFile == true || %rootFileSectionObject.imported == true)
@@ -458,6 +459,7 @@ function T3Dpre4ProjectImporter::beginSoundProfilesImport(%this)
       %file = $ProjectImporter::FileList.getKey(%i);
       %rootFileSectionObject = $ProjectImporter::FileList.getValue(%i);
       
+      $ProjectImporter::currentFile = %rootFileSectionObject.fileDestination;
       $ProjectImporter::currentFilePath = filePath(%rootFileSectionObject.fileDestination) @ "/"; //give context to the file we're processing
       
       if(%rootFileSectionObject.binaryFile == true || %rootFileSectionObject.imported == true)
@@ -523,17 +525,24 @@ function T3Dpre4ProjectImporter::processScripts(%this, %arrayObj)
                   T3Dpre4ProjectImporter.call(%processFunction, %lineObj, %sanitizedName);
                }
                
-               //Now, we process the fields to be asset-ified on our object
-               for(%l=0; %l < %lineObj.count(); %l++)
+               //we're gunna handle the mission group definition lines specially because we need to process against an object's NAME
+               //rather than just the className
+               if(%lineObj.objectName $= "MissionGroup")
                {
-                  %objectCodeLine = %lineObj.getKey(%l);
-                  if(!isObject(%objectCodeLine))
+                  $ProjectImporter::assetQuery.clear();
+                  %assetsFound = AssetDatabase.findAssetLooseFile($ProjectImporter::assetQuery, $ProjectImporter::currentFile);
+                  if(%assetsFound != 0)
                   {
-                     %processLineFunction = "process" @ %subclass @ "Line";
-                     if(T3Dpre4ProjectImporter.isMethod(%processLineFunction))
+                     //ok, valid level asset  
+                     %levelAssetId = $ProjectImporter::assetQuery.getAsset(0);
+                     %levelName = AssetDatabase.getAssetName(%levelAssetId);
+                     
+                     //Now, we process the fields to be asset-ified on our object
+                     for(%l=0; %l < %lineObj.count(); %l++)
                      {
-                        %resultLine = T3Dpre4ProjectImporter.call(%processLineFunction, %objectCodeLine);
-
+                        %objectCodeLine = %lineObj.getKey(%l);
+                        %resultLine = T3Dpre4ProjectImporter.processMissionGroupLine(%objectCodeLine, %levelName);
+                        
                         if(%resultLine !$= %objectCodeLine)
                         {
                            projectImporterLog("   processed line: " @ %resultLine @ " from: " @ %objectCodeLine);
@@ -542,6 +551,28 @@ function T3Dpre4ProjectImporter::processScripts(%this, %arrayObj)
                      }
                   }
                }
+               else //regular convertwork
+               {
+                  //Now, we process the fields to be asset-ified on our object
+                  for(%l=0; %l < %lineObj.count(); %l++)
+                  {
+                     %objectCodeLine = %lineObj.getKey(%l);
+                     if(!isObject(%objectCodeLine))
+                     {
+                        %processLineFunction = "process" @ %subclass @ "Line";
+                        if(T3Dpre4ProjectImporter.isMethod(%processLineFunction))
+                        {
+                           %resultLine = T3Dpre4ProjectImporter.call(%processLineFunction, %objectCodeLine);
+
+                           if(%resultLine !$= %objectCodeLine)
+                           {
+                              projectImporterLog("   processed line: " @ %resultLine @ " from: " @ %objectCodeLine);
+                              %lineObj.setKey(%resultLine, %l);
+                           }
+                        }
+                     }
+                  }
+               }
             }
             
             %lineObj.processed = true;
@@ -624,6 +655,7 @@ function T3Dpre4ProjectImporter::beginScriptFilesImport(%this)
          continue;
       }
       
+      $ProjectImporter::currentFile = %rootFileSectionObject.fileDestination;
       $ProjectImporter::currentFilePath = filePath(%rootFileSectionObject.fileDestination) @ "/";
       
       projectImporterLog("T3Dpre4ProjectImporter::beginScriptFilesImport() - Processing script file: " @ %file);
@@ -693,6 +725,7 @@ function T3Dpre4ProjectImporter::beginAssetAndModuleImport(%this)
             continue;
             
          projectImporterLog("T3Dpre4ProjectImporter::beginAssetAndModuleImport() - processing file: " @ %file);
+         $ProjectImporter::currentFile = %rootFileSectionObject.fileDestination;
          $ProjectImporter::currentFilePath = filePath(%rootFileSectionObject.fileDestination) @ "/";
          %this.processModuleFile(%rootFileSectionObject);
          %rootFileSectionObject.processed = true;
diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
index eccb3b0f6..76051b570 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
@@ -1613,6 +1613,21 @@ function beginTerrainImport()
             //test import config here for forcing type suffixes
             %assetName = fileBase(%destinationPath);
             
+            if(AssetDatabase.isDeclaredAsset(%moduleName @ ":" @ %assetName))
+            {
+               //Attempt to rename it to avoid collisions
+               if(!endsWith(%assetName, "Terrain") && !AssetDatabase.isDeclaredAsset(%moduleName @ ":" @ %assetName @ "Terrain"))
+               {
+                  %assetName = %assetName @ "Terrain";
+               }
+               else
+               {
+                  //Nope, there's already a matching one for that too, so just bail
+                  projectImporterLog("Legacy Project Importer - Error - trying to process a Terrain into an asset that already exists");
+                  return false;  
+               }
+            }
+            
             %assetPath = filePath(%destinationPath) @ "/";
             
             %tamlpath = %assetPath @ %assetName @ ".asset.taml";
@@ -1628,6 +1643,36 @@ function beginTerrainImport()
             {
                AssetDatabase.addDeclaredAsset(%moduleDef, %tamlpath);
                
+               //we probably need to update the terrainMaterial references if any of them got renamed, so lets do that now
+               %terrBlock = new TerrainBlock(tmp) {
+                  terrainAsset = %moduleName @ ":" @ %assetName;
+               };
+               
+               %matNamesChanged = false;
+               %terrMatCount = %terrBlock.getTerrainMaterialCount();
+               for(%tm = 0; %tm < %terrMatCount; %tm++)
+               {
+                  %terrMatName = %terrBlock.getTerrainMaterialName(%tm);
+                  %terrMatAssetId = TerrainMaterialAsset::getAssetIdByMaterialName(%terrMatName);
+                  if(%terrMatAssetId $= "")
+                  {
+                     //k, one didn't map right, lets try and fix it
+                     %terrMatAssetId = TerrainMaterialAsset::getAssetIdByMaterialName(%terrMatName @ "_terrainMat");
+                     if(%terrMatAssetId !$= "")
+                     {
+                        //Ok, success, lets run the rename
+                        if(%terrBlock.renameTerrainMaterial(%terrMatName, %terrMatName @ "_terrainMat"))
+                           %matNamesChanged = true;
+                     }
+                  }
+               }
+               
+               if(%matNamesChanged)
+               {
+                  %terrBlock.saveAsset();
+                  %terrBlock.delete();
+               }
+               
                projectImporterLog("Finished importing Terrain file, resulting in asset with an id of: " @ %moduleName @ ":" @ %assetName);
                projectImporterLog("");
                
@@ -1918,9 +1963,18 @@ function beginLevelImport()
             
             if(AssetDatabase.isDeclaredAsset(%moduleName @ ":" @ %assetName))
             {
-               projectImporterLog("Legacy Project Importer - trying to process a level into an asset that already exists");
+               //Attempt to rename it to avoid collisions
+               if(!endsWith(%assetName, "Level") && !AssetDatabase.isDeclaredAsset(%moduleName @ ":" @ %assetName @ "Level"))
+               {
+                  %assetName = %assetName @ "Level";
+               }
+               else
+               {
+                  //Nope, there's already a matching one for that too, so just bail
+                  projectImporterLog("Legacy Project Importer - Error - trying to process a level into an asset that already exists");
                return false;  
             }
+            }
             
             %assetPath = %filePath @ "/";
             %tamlpath = %assetPath @ %assetName @ ".asset.taml";

From 26044677c13084d688414d5012c704839e7dd120 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Sun, 20 Mar 2022 16:42:21 -0500
Subject: [PATCH 340/399] Made renaming of terrain materials on importing
 terrainblocks to use the full assetId, as it should

---
 .../game/tools/projectImporter/scripts/projectImporter.tscript  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
index 76051b570..f8a50e797 100644
--- a/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/scripts/projectImporter.tscript
@@ -1661,7 +1661,7 @@ function beginTerrainImport()
                      if(%terrMatAssetId !$= "")
                      {
                         //Ok, success, lets run the rename
-                        if(%terrBlock.renameTerrainMaterial(%terrMatName, %terrMatName @ "_terrainMat"))
+                        if(%terrBlock.renameTerrainMaterial(%terrMatName, %terrMatAssetId))
                            %matNamesChanged = true;
                      }
                   }

From 26142746393e9478b2c498d25c059da496e6ce64 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Wed, 23 Mar 2022 01:43:08 -0500
Subject: [PATCH 341/399] update sdl to https://github.com/libsdl-org/SDL
 22March 2022

---
 Engine/lib/sdl/{.hgignore => .gitignore}      |    71 +-
 Engine/lib/sdl/.hgtags                        |    40 -
 Engine/lib/sdl/Android.mk                     |    24 +-
 Engine/lib/sdl/BUGS.txt                       |     8 +-
 Engine/lib/sdl/CMakeLists.txt                 |  1701 +-
 Engine/lib/sdl/INSTALL.txt                    |    19 +-
 Engine/lib/sdl/{COPYING.txt => LICENSE.txt}   |     4 +-
 Engine/lib/sdl/Makefile.in                    |    12 +-
 Engine/lib/sdl/Makefile.minimal               |    25 +-
 Engine/lib/sdl/Makefile.os2                   |   223 +-
 Engine/lib/sdl/Makefile.pandora               |    12 +-
 Engine/lib/sdl/Makefile.psp                   |    96 -
 Engine/lib/sdl/Makefile.wiz                   |    80 -
 Engine/lib/sdl/{README.txt => README.md}      |    10 +-
 Engine/lib/sdl/SDL2.spec.in                   |     2 +-
 Engine/lib/sdl/SDL2Config.cmake               |   120 +-
 Engine/lib/sdl/TODO.txt                       |     2 +-
 .../lib/sdl/VisualC-WinRT/SDL2-WinRT.nuspec   |    23 -
 .../lib/sdl/VisualC-WinRT/SDL2-WinRT.targets  |    38 -
 .../SDL2main-WinRT-NonXAML.nuspec             |    22 -
 .../SDL2main-WinRT-NonXAML.targets            |    10 -
 .../tests/loopwave/Assets/Logo.png            |   Bin 801 -> 0 bytes
 .../tests/loopwave/Assets/SmallLogo.png       |   Bin 329 -> 0 bytes
 .../tests/loopwave/Assets/SplashScreen.png    |   Bin 2146 -> 0 bytes
 .../tests/loopwave/Assets/StoreLogo.png       |   Bin 429 -> 0 bytes
 .../tests/loopwave/Package.appxmanifest       |    42 -
 .../loopwave/loopwave_VS2012_TemporaryKey.pfx |   Bin 2504 -> 0 bytes
 .../tests/testthread/Assets/Logo.png          |   Bin 801 -> 0 bytes
 .../tests/testthread/Assets/SmallLogo.png     |   Bin 329 -> 0 bytes
 .../tests/testthread/Assets/SplashScreen.png  |   Bin 2146 -> 0 bytes
 .../tests/testthread/Assets/StoreLogo.png     |   Bin 429 -> 0 bytes
 .../tests/testthread/Package.appxmanifest     |    42 -
 .../testthread_VS2012_TemporaryKey.pfx        |   Bin 2504 -> 0 bytes
 Engine/lib/sdl/VisualC.html                   |   146 -
 Engine/lib/sdl/WhatsNew.txt                   |   112 +
 Engine/lib/sdl/Xcode-iOS/Demos/Info.plist     |     4 +
 .../sdl/Xcode-iOS/Demos/src/accelerometer.c   |     2 +-
 .../lib/sdl/Xcode-iOS/Demos/src/fireworks.c   |    12 +-
 Engine/lib/sdl/Xcode-iOS/Demos/src/mixer.c    |     2 +-
 Engine/lib/sdl/Xcode-iOS/Demos/src/touch.c    |    38 +-
 .../SDL iOS Application/Default-568h@2x.png   |   Bin 83791 -> 0 bytes
 .../Template/SDL iOS Application/Default.png  |   Bin 18383 -> 0 bytes
 .../Template/SDL iOS Application/Icon.png     |   Bin 2409 -> 0 bytes
 .../Template/SDL iOS Application/Info.plist   |    28 -
 .../TemplateIcon.icns                         |   Bin 34248 -> 0 bytes
 .../TemplateInfo.plist                        |    10 -
 .../project.pbxproj                           |   500 -
 .../Template/SDL iOS Application/main.c       |   100 -
 Engine/lib/sdl/Xcode/SDL/Info-Framework.plist |     4 +-
 .../Xcode/SDL/SDL.xcodeproj/project.pbxproj   |  1332 +-
 Engine/lib/sdl/Xcode/SDL/hidapi/Info.plist    |    22 -
 .../SDL/pkg-support/resources/License.txt     |     2 +-
 Engine/lib/sdl/acinclude/alsa.m4              |    11 +-
 Engine/lib/sdl/acinclude/esd.m4               |    68 +-
 Engine/lib/sdl/acinclude/libtool.m4           |  2628 +-
 Engine/lib/sdl/acinclude/ltoptions.m4         |   127 +-
 Engine/lib/sdl/acinclude/ltsugar.m4           |     7 +-
 Engine/lib/sdl/acinclude/ltversion.m4         |    12 +-
 Engine/lib/sdl/acinclude/lt~obsolete.m4       |     7 +-
 Engine/lib/sdl/acinclude/pkg.m4               |   275 +
 Engine/lib/sdl/acinclude/pkg_config.m4        |   133 -
 .../lib/sdl/android-project/app/build.gradle  |     8 +-
 .../android-project/app/jni/src/Android.mk    |     2 +-
 .../app/src/main/AndroidManifest.xml          |    16 +-
 .../app/HIDDeviceBLESteamController.java      |     6 +-
 .../java/org/libsdl/app/HIDDeviceManager.java |    67 +-
 .../main/java/org/libsdl/app/SDLActivity.java |   263 +-
 .../java/org/libsdl/app/SDLAudioManager.java  |     4 +
 .../org/libsdl/app/SDLControllerManager.java  |    38 +-
 Engine/lib/sdl/android-project/build.gradle   |     6 +-
 .../gradle/wrapper/gradle-wrapper.jar         |   Bin 53636 -> 54213 bytes
 .../gradle/wrapper/gradle-wrapper.properties  |     6 +-
 Engine/lib/sdl/autogen.sh                     |    18 +-
 .../lib/sdl/build-scripts/checker-buildbot.sh |     2 +-
 .../{g++-fat.sh => clang++-fat.sh}            |    59 +-
 .../{gcc-fat.sh => clang-fat.sh}              |    93 +-
 .../sdl/build-scripts/codechecker-buildbot.sh |    59 +
 Engine/lib/sdl/build-scripts/config.guess     |  1611 +-
 Engine/lib/sdl/build-scripts/config.sub       |  3022 +-
 Engine/lib/sdl/build-scripts/config.sub.patch |    72 -
 .../sdl/build-scripts/emscripten-buildbot.sh  |     2 +-
 Engine/lib/sdl/build-scripts/fnsince.pl       |   174 +
 .../sdl/build-scripts/git-pre-push-hook.pl    |    80 +
 Engine/lib/sdl/build-scripts/install-sh       |   414 +-
 Engine/lib/sdl/build-scripts/iosbuild.sh      |   190 -
 Engine/lib/sdl/build-scripts/ltmain.sh        |  5631 +-
 Engine/lib/sdl/build-scripts/mkinstalldirs    |    26 +-
 Engine/lib/sdl/build-scripts/os2-buildbot.sh  |     7 +-
 Engine/lib/sdl/build-scripts/showrev.sh       |     8 +-
 .../lib/sdl/build-scripts/update-copyright.sh |     2 +-
 Engine/lib/sdl/build-scripts/updaterev.sh     |     5 +-
 Engine/lib/sdl/build-scripts/wikiheaders.pl   |  1258 +
 Engine/lib/sdl/build-scripts/winrtbuild.ps1   |     2 +-
 Engine/lib/sdl/cmake/macros.cmake             |    66 +-
 Engine/lib/sdl/cmake/sdlchecks.cmake          |   720 +-
 Engine/lib/sdl/configure                      |  5390 +-
 Engine/lib/sdl/configure.ac                   |  1575 +-
 Engine/lib/sdl/debian/changelog               |   150 -
 Engine/lib/sdl/debian/compat                  |     1 -
 Engine/lib/sdl/debian/control                 |    76 -
 Engine/lib/sdl/debian/copyright               |   351 -
 Engine/lib/sdl/debian/docs                    |     4 -
 Engine/lib/sdl/debian/libsdl2-dev.install     |     9 -
 Engine/lib/sdl/debian/libsdl2-dev.manpages    |     1 -
 Engine/lib/sdl/debian/libsdl2.install         |     1 -
 Engine/lib/sdl/debian/rules                   |    54 -
 Engine/lib/sdl/debian/sdl2-config.1           |    86 -
 Engine/lib/sdl/debian/source/format           |     1 -
 Engine/lib/sdl/debian/watch                   |     2 -
 Engine/lib/sdl/docs/README-android.md         |    93 +-
 Engine/lib/sdl/docs/README-dynapi.md          |    42 +-
 Engine/lib/sdl/docs/README-git.md             |    19 +
 Engine/lib/sdl/docs/README-hg.md              |    22 +-
 Engine/lib/sdl/docs/README-ios.md             |    79 +-
 Engine/lib/sdl/docs/README-kmsbsd.md          |    27 +
 Engine/lib/sdl/docs/README-linux.md           |    38 +-
 Engine/lib/sdl/docs/README-macos.md           |   286 +
 Engine/lib/sdl/docs/README-macosx.md          |   240 -
 Engine/lib/sdl/docs/README-os2.md             |    44 +-
 Engine/lib/sdl/docs/README-psp.md             |    35 +-
 Engine/lib/sdl/docs/README-raspberrypi.md     |    54 +-
 Engine/lib/sdl/docs/README-riscos.md          |    41 +
 Engine/lib/sdl/docs/README-visualc.md         |   114 +
 Engine/lib/sdl/docs/README-vita.md            |    30 +
 Engine/lib/sdl/docs/README-winrt.md           |    55 +-
 Engine/lib/sdl/docs/README.md                 |    16 +-
 Engine/lib/sdl/include/SDL.h                  |   122 +-
 Engine/lib/sdl/include/SDL_assert.h           |   131 +-
 Engine/lib/sdl/include/SDL_atomic.h           |   170 +-
 Engine/lib/sdl/include/SDL_audio.h            |  1259 +-
 Engine/lib/sdl/include/SDL_bits.h             |    17 +-
 Engine/lib/sdl/include/SDL_blendmode.h        |   101 +-
 Engine/lib/sdl/include/SDL_clipboard.h        |    37 +-
 Engine/lib/sdl/include/SDL_config.h           |     6 +-
 Engine/lib/sdl/include/SDL_config.h.cmake     |    95 +-
 Engine/lib/sdl/include/SDL_config.h.in        |    63 +-
 Engine/lib/sdl/include/SDL_config_android.h   |    12 +-
 .../lib/sdl/include/SDL_config_emscripten.h   |   216 +
 Engine/lib/sdl/include/SDL_config_iphoneos.h  |    10 +-
 Engine/lib/sdl/include/SDL_config_macosx.h    |    18 +-
 Engine/lib/sdl/include/SDL_config_minimal.h   |     5 +-
 Engine/lib/sdl/include/SDL_config_os2.h       |    57 +-
 Engine/lib/sdl/include/SDL_config_pandora.h   |     7 +-
 Engine/lib/sdl/include/SDL_config_psp.h       |   165 -
 Engine/lib/sdl/include/SDL_config_windows.h   |    65 +-
 Engine/lib/sdl/include/SDL_config_winrt.h     |    35 +-
 Engine/lib/sdl/include/SDL_config_wiz.h       |   149 -
 Engine/lib/sdl/include/SDL_copying.h          |     2 +-
 Engine/lib/sdl/include/SDL_cpuinfo.h          |   400 +-
 Engine/lib/sdl/include/SDL_egl.h              |  1186 +-
 Engine/lib/sdl/include/SDL_endian.h           |   157 +-
 Engine/lib/sdl/include/SDL_error.h            |    89 +-
 Engine/lib/sdl/include/SDL_events.h           |   481 +-
 Engine/lib/sdl/include/SDL_filesystem.h       |   121 +-
 Engine/lib/sdl/include/SDL_gamecontroller.h   |   711 +-
 Engine/lib/sdl/include/SDL_gesture.h          |    42 +-
 Engine/lib/sdl/include/SDL_haptic.h           |   514 +-
 Engine/lib/sdl/include/SDL_hidapi.h           |   451 +
 Engine/lib/sdl/include/SDL_hints.h            |  2560 +-
 Engine/lib/sdl/include/SDL_joystick.h         |   707 +-
 Engine/lib/sdl/include/SDL_keyboard.h         |   246 +-
 Engine/lib/sdl/include/SDL_keycode.h          |    12 +-
 Engine/lib/sdl/include/SDL_loadso.h           |    50 +-
 Engine/lib/sdl/include/SDL_locale.h           |    66 +-
 Engine/lib/sdl/include/SDL_log.h              |   231 +-
 Engine/lib/sdl/include/SDL_main.h             |    89 +-
 Engine/lib/sdl/include/SDL_messagebox.h       |    93 +-
 Engine/lib/sdl/include/SDL_metal.h            |    59 +-
 Engine/lib/sdl/include/SDL_misc.h             |    34 +-
 Engine/lib/sdl/include/SDL_mouse.h            |   358 +-
 Engine/lib/sdl/include/SDL_mutex.h            |   352 +-
 Engine/lib/sdl/include/SDL_name.h             |     2 +-
 Engine/lib/sdl/include/SDL_opengl.h           |     2 +-
 Engine/lib/sdl/include/SDL_opengles.h         |     2 +-
 Engine/lib/sdl/include/SDL_opengles2.h        |     4 +-
 Engine/lib/sdl/include/SDL_pixels.h           |   233 +-
 Engine/lib/sdl/include/SDL_platform.h         |    41 +-
 Engine/lib/sdl/include/SDL_power.h            |    33 +-
 Engine/lib/sdl/include/SDL_quit.h             |     2 +-
 Engine/lib/sdl/include/SDL_rect.h             |   234 +-
 Engine/lib/sdl/include/SDL_render.h           |  1669 +-
 Engine/lib/sdl/include/SDL_revision.h         |     2 +-
 Engine/lib/sdl/include/SDL_revision.h.cmake   |     6 +
 Engine/lib/sdl/include/SDL_rwops.h            |   638 +-
 Engine/lib/sdl/include/SDL_scancode.h         |     2 +-
 Engine/lib/sdl/include/SDL_sensor.h           |   118 +-
 Engine/lib/sdl/include/SDL_shape.h            |    65 +-
 Engine/lib/sdl/include/SDL_stdinc.h           |   126 +-
 Engine/lib/sdl/include/SDL_surface.h          |   710 +-
 Engine/lib/sdl/include/SDL_system.h           |   446 +-
 Engine/lib/sdl/include/SDL_syswm.h            |    70 +-
 Engine/lib/sdl/include/SDL_test.h             |     2 +-
 Engine/lib/sdl/include/SDL_test_assert.h      |     4 +-
 Engine/lib/sdl/include/SDL_test_common.h      |    29 +-
 Engine/lib/sdl/include/SDL_test_compare.h     |     2 +-
 Engine/lib/sdl/include/SDL_test_crc32.h       |     2 +-
 Engine/lib/sdl/include/SDL_test_font.h        |     6 +-
 Engine/lib/sdl/include/SDL_test_fuzzer.h      |    54 +-
 Engine/lib/sdl/include/SDL_test_harness.h     |    12 +-
 Engine/lib/sdl/include/SDL_test_images.h      |     2 +-
 Engine/lib/sdl/include/SDL_test_log.h         |     2 +-
 Engine/lib/sdl/include/SDL_test_md5.h         |     2 +-
 Engine/lib/sdl/include/SDL_test_memory.h      |     2 +-
 Engine/lib/sdl/include/SDL_test_random.h      |     4 +-
 Engine/lib/sdl/include/SDL_thread.h           |   328 +-
 Engine/lib/sdl/include/SDL_timer.h            |   151 +-
 Engine/lib/sdl/include/SDL_touch.h            |    64 +-
 Engine/lib/sdl/include/SDL_types.h            |     2 +-
 Engine/lib/sdl/include/SDL_version.h          |   118 +-
 Engine/lib/sdl/include/SDL_video.h            |  1712 +-
 Engine/lib/sdl/include/SDL_vulkan.h           |   235 +-
 Engine/lib/sdl/include/begin_code.h           |    23 +-
 Engine/lib/sdl/include/close_code.h           |     2 +-
 Engine/lib/sdl/sdl2-config.cmake.in           |    72 +-
 Engine/lib/sdl/sdl2.m4                        |    42 +-
 Engine/lib/sdl/sdl2.pc.in                     |     2 +-
 Engine/lib/sdl/src/SDL.c                      |    96 +-
 Engine/lib/sdl/src/SDL_assert.c               |     2 +-
 Engine/lib/sdl/src/SDL_assert_c.h             |     2 +-
 Engine/lib/sdl/src/SDL_dataqueue.c            |     4 +-
 Engine/lib/sdl/src/SDL_dataqueue.h            |     2 +-
 Engine/lib/sdl/src/SDL_error.c                |     2 +-
 Engine/lib/sdl/src/SDL_error_c.h              |     2 +-
 Engine/lib/sdl/src/SDL_hints.c                |     2 +-
 Engine/lib/sdl/src/SDL_hints_c.h              |     2 +-
 Engine/lib/sdl/src/SDL_internal.h             |     7 +-
 Engine/lib/sdl/src/SDL_log.c                  |    15 +-
 Engine/lib/sdl/src/atomic/SDL_atomic.c        |    28 +-
 Engine/lib/sdl/src/atomic/SDL_spinlock.c      |    30 +-
 Engine/lib/sdl/src/audio/SDL_audio.c          |   225 +-
 Engine/lib/sdl/src/audio/SDL_audio_c.h        |     2 +-
 Engine/lib/sdl/src/audio/SDL_audiocvt.c       |   523 +-
 Engine/lib/sdl/src/audio/SDL_audiodev.c       |    12 +-
 Engine/lib/sdl/src/audio/SDL_audiodev_c.h     |     2 +-
 Engine/lib/sdl/src/audio/SDL_audiotypecvt.c   |     2 +-
 Engine/lib/sdl/src/audio/SDL_mixer.c          |   120 +-
 Engine/lib/sdl/src/audio/SDL_sysaudio.h       |    30 +-
 Engine/lib/sdl/src/audio/SDL_wave.c           |    10 +-
 Engine/lib/sdl/src/audio/SDL_wave.h           |     4 +-
 Engine/lib/sdl/src/audio/aaudio/SDL_aaudio.c  |   462 +
 Engine/lib/sdl/src/audio/aaudio/SDL_aaudio.h  |    53 +
 .../sdl/src/audio/aaudio/SDL_aaudiofuncs.h    |    80 +
 .../lib/sdl/src/audio/alsa/SDL_alsa_audio.c   |   450 +-
 .../lib/sdl/src/audio/alsa/SDL_alsa_audio.h   |     2 +-
 .../sdl/src/audio/android/SDL_androidaudio.c  |    27 +-
 .../sdl/src/audio/android/SDL_androidaudio.h  |     2 +-
 Engine/lib/sdl/src/audio/arts/SDL_artsaudio.c |    40 +-
 Engine/lib/sdl/src/audio/arts/SDL_artsaudio.h |     2 +-
 .../sdl/src/audio/coreaudio/SDL_coreaudio.h   |     2 +-
 .../sdl/src/audio/coreaudio/SDL_coreaudio.m   |    97 +-
 .../src/audio/directsound/SDL_directsound.c   |    53 +-
 .../src/audio/directsound/SDL_directsound.h   |     2 +-
 Engine/lib/sdl/src/audio/disk/SDL_diskaudio.c |    68 +-
 Engine/lib/sdl/src/audio/disk/SDL_diskaudio.h |     4 +-
 Engine/lib/sdl/src/audio/dsp/SDL_dspaudio.c   |    29 +-
 Engine/lib/sdl/src/audio/dsp/SDL_dspaudio.h   |     2 +-
 .../lib/sdl/src/audio/dummy/SDL_dummyaudio.c  |    19 +-
 .../lib/sdl/src/audio/dummy/SDL_dummyaudio.h  |     4 +-
 .../audio/emscripten/SDL_emscriptenaudio.c    |    57 +-
 .../audio/emscripten/SDL_emscriptenaudio.h    |     2 +-
 Engine/lib/sdl/src/audio/esd/SDL_esdaudio.c   |    16 +-
 Engine/lib/sdl/src/audio/esd/SDL_esdaudio.h   |     2 +-
 .../sdl/src/audio/fusionsound/SDL_fsaudio.c   |    41 +-
 .../sdl/src/audio/fusionsound/SDL_fsaudio.h   |     2 +-
 .../lib/sdl/src/audio/haiku/SDL_haikuaudio.cc |    33 +-
 .../lib/sdl/src/audio/haiku/SDL_haikuaudio.h  |     2 +-
 Engine/lib/sdl/src/audio/jack/SDL_jackaudio.c |    15 +-
 Engine/lib/sdl/src/audio/jack/SDL_jackaudio.h |     2 +-
 Engine/lib/sdl/src/audio/nacl/SDL_naclaudio.c |    16 +-
 Engine/lib/sdl/src/audio/nacl/SDL_naclaudio.h |     2 +-
 Engine/lib/sdl/src/audio/nas/SDL_nasaudio.c   |    80 +-
 Engine/lib/sdl/src/audio/nas/SDL_nasaudio.h   |     2 +-
 .../sdl/src/audio/netbsd/SDL_netbsdaudio.c    |   137 +-
 .../sdl/src/audio/netbsd/SDL_netbsdaudio.h    |     2 +-
 .../lib/sdl/src/audio/openslES/SDL_openslES.c |   112 +-
 .../lib/sdl/src/audio/openslES/SDL_openslES.h |     2 +-
 Engine/lib/sdl/src/audio/os2/SDL_os2audio.c   |    90 +-
 Engine/lib/sdl/src/audio/os2/SDL_os2audio.h   |     2 +-
 Engine/lib/sdl/src/audio/paudio/SDL_paudio.c  |    82 +-
 Engine/lib/sdl/src/audio/paudio/SDL_paudio.h  |     2 +-
 .../lib/sdl/src/audio/pipewire/SDL_pipewire.c |  1276 +
 .../lib/sdl/src/audio/pipewire/SDL_pipewire.h |    47 +
 Engine/lib/sdl/src/audio/psp/SDL_pspaudio.c   |   104 +-
 Engine/lib/sdl/src/audio/psp/SDL_pspaudio.h   |     2 +-
 .../sdl/src/audio/pulseaudio/SDL_pulseaudio.c |   157 +-
 .../sdl/src/audio/pulseaudio/SDL_pulseaudio.h |     8 +-
 Engine/lib/sdl/src/audio/qsa/SDL_qsa_audio.c  |   127 +-
 Engine/lib/sdl/src/audio/qsa/SDL_qsa_audio.h  |     5 +-
 .../lib/sdl/src/audio/sndio/SDL_sndioaudio.c  |    35 +-
 .../lib/sdl/src/audio/sndio/SDL_sndioaudio.h  |     2 +-
 Engine/lib/sdl/src/audio/sun/SDL_sunaudio.c   |    15 +-
 Engine/lib/sdl/src/audio/sun/SDL_sunaudio.h   |     2 +-
 Engine/lib/sdl/src/audio/vita/SDL_vitaaudio.c |   183 +
 Engine/lib/sdl/src/audio/vita/SDL_vitaaudio.h |    45 +
 Engine/lib/sdl/src/audio/wasapi/SDL_wasapi.c  |   167 +-
 Engine/lib/sdl/src/audio/wasapi/SDL_wasapi.h  |     5 +-
 .../sdl/src/audio/wasapi/SDL_wasapi_win32.c   |    34 +-
 .../sdl/src/audio/wasapi/SDL_wasapi_winrt.cpp |    29 +-
 Engine/lib/sdl/src/audio/winmm/SDL_winmm.c    |    44 +-
 Engine/lib/sdl/src/audio/winmm/SDL_winmm.h    |     2 +-
 Engine/lib/sdl/src/core/android/SDL_android.c |   114 +-
 Engine/lib/sdl/src/core/android/SDL_android.h |     7 +-
 .../lib/sdl/src/core/android/keyinfotable.h   |     2 +-
 .../src/core/freebsd/SDL_evdev_kbd_freebsd.c  |    28 +-
 Engine/lib/sdl/src/core/linux/SDL_dbus.c      |    31 +-
 Engine/lib/sdl/src/core/linux/SDL_dbus.h      |     2 +-
 Engine/lib/sdl/src/core/linux/SDL_evdev.c     |    42 +-
 Engine/lib/sdl/src/core/linux/SDL_evdev.h     |     2 +-
 .../src/core/linux/SDL_evdev_capabilities.c   |    51 +-
 .../src/core/linux/SDL_evdev_capabilities.h   |     5 +-
 Engine/lib/sdl/src/core/linux/SDL_evdev_kbd.c |     8 +-
 Engine/lib/sdl/src/core/linux/SDL_evdev_kbd.h |     2 +-
 .../linux/SDL_evdev_kbd_default_accents.h     |     2 +-
 .../core/linux/SDL_evdev_kbd_default_keymap.h |     2 +-
 Engine/lib/sdl/src/core/linux/SDL_fcitx.c     |     7 +-
 Engine/lib/sdl/src/core/linux/SDL_fcitx.h     |     2 +-
 Engine/lib/sdl/src/core/linux/SDL_ibus.c      |    11 +-
 Engine/lib/sdl/src/core/linux/SDL_ibus.h      |     2 +-
 Engine/lib/sdl/src/core/linux/SDL_ime.c       |    10 +-
 Engine/lib/sdl/src/core/linux/SDL_ime.h       |     2 +-
 .../lib/sdl/src/core/linux/SDL_threadprio.c   |     6 +-
 Engine/lib/sdl/src/core/linux/SDL_udev.c      |   156 +-
 Engine/lib/sdl/src/core/linux/SDL_udev.h      |     3 +-
 Engine/lib/sdl/src/core/openbsd/SDL_wscons.h  |    27 +
 .../lib/sdl/src/core/openbsd/SDL_wscons_kbd.c |   841 +
 .../sdl/src/core/openbsd/SDL_wscons_mouse.c   |   134 +
 Engine/lib/sdl/src/core/os2/SDL_os2.c         |     4 +-
 Engine/lib/sdl/src/core/os2/SDL_os2.h         |    11 +-
 .../lib/sdl/src/core/os2/geniconv/geniconv.c  |   118 +-
 .../lib/sdl/src/core/os2/geniconv/geniconv.h  |    24 +-
 Engine/lib/sdl/src/core/os2/geniconv/makefile |     2 +-
 Engine/lib/sdl/src/core/os2/geniconv/os2cp.c  |    81 +-
 Engine/lib/sdl/src/core/os2/geniconv/os2cp.h  |     2 +-
 .../lib/sdl/src/core/os2/geniconv/os2iconv.c  |    82 +-
 .../lib/sdl/src/core/os2/geniconv/sys2utf8.c  |   102 +-
 Engine/lib/sdl/src/core/os2/geniconv/test.c   |     2 +-
 Engine/lib/sdl/src/core/os2/iconv2.lbc        |     4 +
 Engine/lib/sdl/src/core/unix/SDL_poll.c       |    29 +-
 Engine/lib/sdl/src/core/unix/SDL_poll.h       |     7 +-
 Engine/lib/sdl/src/core/windows/SDL_directx.h |     2 +-
 Engine/lib/sdl/src/core/windows/SDL_hid.c     |     4 +-
 Engine/lib/sdl/src/core/windows/SDL_hid.h     |     2 +-
 Engine/lib/sdl/src/core/windows/SDL_windows.c |    90 +-
 Engine/lib/sdl/src/core/windows/SDL_windows.h |    31 +-
 Engine/lib/sdl/src/core/windows/SDL_xinput.c  |    10 +-
 Engine/lib/sdl/src/core/windows/SDL_xinput.h  |     2 +-
 .../src/core/winrt/SDL_winrtapp_common.cpp    |     2 +-
 .../sdl/src/core/winrt/SDL_winrtapp_common.h  |     2 +-
 .../src/core/winrt/SDL_winrtapp_direct3d.cpp  |    86 +-
 .../src/core/winrt/SDL_winrtapp_direct3d.h    |     2 +-
 .../sdl/src/core/winrt/SDL_winrtapp_xaml.cpp  |     4 +-
 .../sdl/src/core/winrt/SDL_winrtapp_xaml.h    |     2 +-
 Engine/lib/sdl/src/cpuinfo/SDL_cpuinfo.c      |   232 +-
 Engine/lib/sdl/src/dynapi/SDL_dynapi.c        |    10 +-
 Engine/lib/sdl/src/dynapi/SDL_dynapi.h        |     6 +-
 .../lib/sdl/src/dynapi/SDL_dynapi_overrides.h |    78 +-
 Engine/lib/sdl/src/dynapi/SDL_dynapi_procs.h  |    90 +-
 Engine/lib/sdl/src/dynapi/gendynapi.pl        |    22 +-
 .../lib/sdl/src/events/SDL_clipboardevents.c  |     2 +-
 .../sdl/src/events/SDL_clipboardevents_c.h    |     2 +-
 Engine/lib/sdl/src/events/SDL_displayevents.c |     2 +-
 .../lib/sdl/src/events/SDL_displayevents_c.h  |     2 +-
 Engine/lib/sdl/src/events/SDL_dropevents.c    |     2 +-
 Engine/lib/sdl/src/events/SDL_dropevents_c.h  |     2 +-
 Engine/lib/sdl/src/events/SDL_events.c        |   389 +-
 Engine/lib/sdl/src/events/SDL_events_c.h      |     2 +-
 Engine/lib/sdl/src/events/SDL_gesture.c       |     8 +-
 Engine/lib/sdl/src/events/SDL_gesture_c.h     |     2 +-
 Engine/lib/sdl/src/events/SDL_keyboard.c      |    68 +-
 Engine/lib/sdl/src/events/SDL_keyboard_c.h    |     2 +-
 Engine/lib/sdl/src/events/SDL_mouse.c         |   266 +-
 Engine/lib/sdl/src/events/SDL_mouse_c.h       |    14 +-
 Engine/lib/sdl/src/events/SDL_quit.c          |     4 +-
 Engine/lib/sdl/src/events/SDL_sysevents.h     |     2 +-
 Engine/lib/sdl/src/events/SDL_touch.c         |    19 +-
 Engine/lib/sdl/src/events/SDL_touch_c.h       |     3 +-
 Engine/lib/sdl/src/events/SDL_windowevents.c  |    10 +-
 .../lib/sdl/src/events/SDL_windowevents_c.h   |     2 +-
 Engine/lib/sdl/src/events/blank_cursor.h      |     2 +-
 Engine/lib/sdl/src/events/default_cursor.h    |     3 +-
 .../sdl/src/{video/x11 => events}/imKStoUCS.c |     7 +-
 .../sdl/src/{video/x11 => events}/imKStoUCS.h |     2 +-
 Engine/lib/sdl/src/events/scancodes_darwin.h  |     2 +-
 Engine/lib/sdl/src/events/scancodes_linux.h   |     2 +-
 Engine/lib/sdl/src/events/scancodes_windows.h |     2 +-
 Engine/lib/sdl/src/events/scancodes_xfree86.h |     2 +-
 Engine/lib/sdl/src/file/SDL_rwops.c           |   259 +-
 .../src/file/cocoa/SDL_rwopsbundlesupport.h   |     2 +-
 .../src/file/cocoa/SDL_rwopsbundlesupport.m   |     2 +-
 .../filesystem/android/SDL_sysfilesystem.c    |     2 +-
 .../src/filesystem/cocoa/SDL_sysfilesystem.m  |     2 +-
 .../src/filesystem/dummy/SDL_sysfilesystem.c  |     2 +-
 .../filesystem/emscripten/SDL_sysfilesystem.c |    13 +-
 .../src/filesystem/haiku/SDL_sysfilesystem.cc |     2 +-
 .../src/filesystem/nacl/SDL_sysfilesystem.c   |     2 +-
 .../src/filesystem/os2/SDL_sysfilesystem.c    |    32 +-
 .../src/filesystem/psp/SDL_sysfilesystem.c    |    79 +
 .../src/filesystem/riscos/SDL_sysfilesystem.c |   210 +
 .../src/filesystem/unix/SDL_sysfilesystem.c   |   100 +-
 .../src/filesystem/vita/SDL_sysfilesystem.c   |    95 +
 .../filesystem/windows/SDL_sysfilesystem.c    |    28 +-
 .../filesystem/winrt/SDL_sysfilesystem.cpp    |     2 +-
 Engine/lib/sdl/src/haptic/SDL_haptic.c        |     2 +-
 Engine/lib/sdl/src/haptic/SDL_haptic_c.h      |     2 +-
 Engine/lib/sdl/src/haptic/SDL_syshaptic.h     |     2 +-
 .../sdl/src/haptic/android/SDL_syshaptic.c    |     4 +-
 .../lib/sdl/src/haptic/darwin/SDL_syshaptic.c |     4 +-
 .../sdl/src/haptic/darwin/SDL_syshaptic_c.h   |     2 +-
 .../lib/sdl/src/haptic/dummy/SDL_syshaptic.c  |     2 +-
 .../lib/sdl/src/haptic/linux/SDL_syshaptic.c  |    19 +-
 .../sdl/src/haptic/windows/SDL_dinputhaptic.c |    64 +-
 .../src/haptic/windows/SDL_dinputhaptic_c.h   |     6 +-
 .../src/haptic/windows/SDL_windowshaptic.c    |    18 +-
 .../src/haptic/windows/SDL_windowshaptic_c.h  |     2 +-
 .../sdl/src/haptic/windows/SDL_xinputhaptic.c |    19 +-
 .../src/haptic/windows/SDL_xinputhaptic_c.h   |     6 +-
 Engine/lib/sdl/src/hidapi/SDL_hidapi.c        |  1129 +-
 Engine/lib/sdl/src/hidapi/SDL_hidapi_c.h      |    35 +
 Engine/lib/sdl/src/hidapi/android/hid.cpp     |   297 +-
 Engine/lib/sdl/src/hidapi/hidapi/hidapi.h     |    73 +-
 Engine/lib/sdl/src/hidapi/ios/hid.m           |   121 +-
 Engine/lib/sdl/src/hidapi/libusb/hid.c        |   272 +-
 Engine/lib/sdl/src/hidapi/linux/hid.c         |    67 +-
 Engine/lib/sdl/src/hidapi/linux/hid.cpp       |   333 -
 Engine/lib/sdl/src/hidapi/mac/hid.c           |   103 +-
 Engine/lib/sdl/src/hidapi/windows/hid.c       |   154 +-
 .../lib/sdl/src/joystick/SDL_gamecontroller.c |   238 +-
 .../sdl/src/joystick/SDL_gamecontrollerdb.h   |    84 +-
 Engine/lib/sdl/src/joystick/SDL_joystick.c    |   412 +-
 Engine/lib/sdl/src/joystick/SDL_joystick_c.h  |    14 +-
 Engine/lib/sdl/src/joystick/SDL_sysjoystick.h |    24 +-
 .../src/joystick/android/SDL_sysjoystick.c    |    30 +-
 .../src/joystick/android/SDL_sysjoystick_c.h  |     2 +-
 .../sdl/src/joystick/bsd/SDL_bsdjoystick.c    |    33 +-
 Engine/lib/sdl/src/joystick/controller_type.h |    86 +-
 .../src/joystick/darwin/SDL_iokitjoystick.c   |    53 +-
 .../src/joystick/darwin/SDL_iokitjoystick_c.h |     2 +-
 .../sdl/src/joystick/dummy/SDL_sysjoystick.c  |    17 +-
 .../src/joystick/emscripten/SDL_sysjoystick.c |    17 +-
 .../joystick/emscripten/SDL_sysjoystick_c.h   |     2 +-
 .../src/joystick/haiku/SDL_haikujoystick.cc   |    15 +-
 .../src/joystick/hidapi/SDL_hidapi_gamecube.c |   436 +-
 .../sdl/src/joystick/hidapi/SDL_hidapi_luna.c |   463 +
 .../sdl/src/joystick/hidapi/SDL_hidapi_ps4.c  |   278 +-
 .../sdl/src/joystick/hidapi/SDL_hidapi_ps5.c  |   460 +-
 .../src/joystick/hidapi/SDL_hidapi_rumble.c   |    11 +-
 .../src/joystick/hidapi/SDL_hidapi_rumble.h   |     2 +-
 .../src/joystick/hidapi/SDL_hidapi_stadia.c   |   331 +
 .../src/joystick/hidapi/SDL_hidapi_steam.c    |   257 +-
 .../src/joystick/hidapi/SDL_hidapi_switch.c   |   401 +-
 .../src/joystick/hidapi/SDL_hidapi_xbox360.c  |    74 +-
 .../src/joystick/hidapi/SDL_hidapi_xbox360w.c |    56 +-
 .../src/joystick/hidapi/SDL_hidapi_xboxone.c  |   253 +-
 .../src/joystick/hidapi/SDL_hidapijoystick.c  |   510 +-
 .../joystick/hidapi/SDL_hidapijoystick_c.h    |    23 +-
 .../hidapi/steam/controller_constants.h       |     2 +-
 .../hidapi/steam/controller_structs.h         |    37 +
 .../src/joystick/iphoneos/SDL_mfijoystick.m   |   521 +-
 .../src/joystick/iphoneos/SDL_mfijoystick_c.h |     3 +-
 .../sdl/src/joystick/linux/SDL_sysjoystick.c  |   638 +-
 .../src/joystick/linux/SDL_sysjoystick_c.h    |     8 +-
 .../sdl/src/joystick/os2/SDL_os2joystick.c    |   799 +
 .../sdl/src/joystick/psp/SDL_sysjoystick.c    |   135 +-
 .../lib/sdl/src/joystick/sort_controllers.py  |     2 +-
 .../src/joystick/steam/SDL_steamcontroller.c  |     2 +-
 .../src/joystick/steam/SDL_steamcontroller.h  |     2 +-
 Engine/lib/sdl/src/joystick/usb_ids.h         |    73 +-
 .../joystick/virtual/SDL_virtualjoystick.c    |    41 +-
 .../joystick/virtual/SDL_virtualjoystick_c.h  |     2 +-
 .../sdl/src/joystick/vita/SDL_sysjoystick.c   |   425 +
 .../src/joystick/windows/SDL_dinputjoystick.c |   725 +-
 .../joystick/windows/SDL_dinputjoystick_c.h   |     3 +-
 .../sdl/src/joystick/windows/SDL_mmjoystick.c |   452 -
 .../joystick/windows/SDL_rawinputjoystick.c   |   230 +-
 .../joystick/windows/SDL_rawinputjoystick_c.h |     2 +-
 .../windows/SDL_windows_gaming_input.c        |   334 +-
 .../joystick/windows/SDL_windowsjoystick.c    |   195 +-
 .../joystick/windows/SDL_windowsjoystick_c.h  |     4 +-
 .../src/joystick/windows/SDL_xinputjoystick.c |    31 +-
 .../joystick/windows/SDL_xinputjoystick_c.h   |     3 +-
 Engine/lib/sdl/src/libm/math_libm.h           |     2 +-
 Engine/lib/sdl/src/libm/math_private.h        |     2 +-
 .../lib/sdl/src/loadso/dlopen/SDL_sysloadso.c |     2 +-
 .../lib/sdl/src/loadso/dummy/SDL_sysloadso.c  |     2 +-
 Engine/lib/sdl/src/loadso/os2/SDL_sysloadso.c |     4 +-
 .../sdl/src/loadso/windows/SDL_sysloadso.c    |     4 +-
 Engine/lib/sdl/src/locale/SDL_locale.c        |     4 +-
 Engine/lib/sdl/src/locale/SDL_syslocale.h     |     2 +-
 .../sdl/src/locale/android/SDL_syslocale.c    |     2 +-
 .../lib/sdl/src/locale/dummy/SDL_syslocale.c  |     2 +-
 .../sdl/src/locale/emscripten/SDL_syslocale.c |     2 +-
 .../lib/sdl/src/locale/haiku/SDL_syslocale.cc |     2 +-
 .../lib/sdl/src/locale/macosx/SDL_syslocale.m |     2 +-
 .../lib/sdl/src/locale/unix/SDL_syslocale.c   |     2 +-
 .../sdl/src/locale/windows/SDL_syslocale.c    |    12 +-
 .../lib/sdl/src/locale/winrt/SDL_syslocale.c  |     2 +-
 .../lib/sdl/src/main/dummy/SDL_dummy_main.c   |     3 -
 Engine/lib/sdl/src/main/haiku/SDL_BApp.h      |    53 +-
 Engine/lib/sdl/src/main/haiku/SDL_BeApp.cc    |     2 +-
 Engine/lib/sdl/src/main/haiku/SDL_BeApp.h     |     2 +-
 Engine/lib/sdl/src/main/nacl/SDL_nacl_main.c  |     2 +-
 Engine/lib/sdl/src/main/psp/SDL_psp_main.c    |    19 +-
 .../lib/sdl/src/main/uikit/SDL_uikit_main.c   |     2 +
 .../sdl/src/main/windows/SDL_windows_main.c   |    23 +-
 Engine/lib/sdl/src/main/windows/version.rc    |    10 +-
 Engine/lib/sdl/src/misc/SDL_sysurl.h          |     2 +-
 Engine/lib/sdl/src/misc/SDL_url.c             |     2 +-
 Engine/lib/sdl/src/misc/android/SDL_sysurl.c  |     2 +-
 Engine/lib/sdl/src/misc/dummy/SDL_sysurl.c    |     2 +-
 .../lib/sdl/src/misc/emscripten/SDL_sysurl.c  |    37 +
 Engine/lib/sdl/src/misc/haiku/SDL_sysurl.cc   |     2 +-
 Engine/lib/sdl/src/misc/ios/SDL_sysurl.m      |     2 +-
 Engine/lib/sdl/src/misc/macosx/SDL_sysurl.m   |    10 +-
 Engine/lib/sdl/src/misc/riscos/SDL_sysurl.c   |     2 +-
 Engine/lib/sdl/src/misc/unix/SDL_sysurl.c     |     9 +-
 Engine/lib/sdl/src/misc/vita/SDL_sysurl.c     |    44 +
 Engine/lib/sdl/src/misc/windows/SDL_sysurl.c  |     4 +-
 Engine/lib/sdl/src/misc/winrt/SDL_sysurl.cpp  |     8 +-
 Engine/lib/sdl/src/power/SDL_power.c          |     5 +-
 Engine/lib/sdl/src/power/SDL_syspower.h       |     3 +-
 .../lib/sdl/src/power/android/SDL_syspower.c  |     2 +-
 .../sdl/src/power/emscripten/SDL_syspower.c   |     2 +-
 Engine/lib/sdl/src/power/haiku/SDL_syspower.c |     6 +-
 Engine/lib/sdl/src/power/linux/SDL_syspower.c |    77 +-
 .../lib/sdl/src/power/macosx/SDL_syspower.c   |     2 +-
 Engine/lib/sdl/src/power/psp/SDL_syspower.c   |     2 +-
 Engine/lib/sdl/src/power/uikit/SDL_syspower.h |     2 +-
 Engine/lib/sdl/src/power/uikit/SDL_syspower.m |     2 +-
 Engine/lib/sdl/src/power/vita/SDL_syspower.c  |    68 +
 .../lib/sdl/src/power/windows/SDL_syspower.c  |     2 +-
 .../lib/sdl/src/power/winrt/SDL_syspower.cpp  |     2 +-
 Engine/lib/sdl/src/render/SDL_d3dmath.c       |     2 +-
 Engine/lib/sdl/src/render/SDL_d3dmath.h       |     2 +-
 Engine/lib/sdl/src/render/SDL_render.c        |  1916 +-
 Engine/lib/sdl/src/render/SDL_sysrender.h     |    59 +-
 Engine/lib/sdl/src/render/SDL_yuv_sw.c        |    41 +-
 Engine/lib/sdl/src/render/SDL_yuv_sw_c.h      |    10 +-
 .../sdl/src/render/direct3d/SDL_render_d3d.c  |   462 +-
 .../sdl/src/render/direct3d/SDL_shaders_d3d.c |     2 +-
 .../sdl/src/render/direct3d/SDL_shaders_d3d.h |     2 +-
 .../src/render/direct3d11/SDL_render_d3d11.c  |   550 +-
 .../render/direct3d11/SDL_render_winrt.cpp    |     2 +-
 .../src/render/direct3d11/SDL_render_winrt.h  |     2 +-
 .../src/render/direct3d11/SDL_shaders_d3d11.c |    12 +-
 .../src/render/direct3d11/SDL_shaders_d3d11.h |     4 +-
 .../sdl/src/render/metal/SDL_render_metal.m   |   515 +-
 .../src/render/metal/SDL_shaders_metal.metal  |    25 +-
 .../src/render/metal/SDL_shaders_metal_ios.h  |  3426 +-
 .../metal/SDL_shaders_metal_iphonesimulator.h |  3842 +-
 .../src/render/metal/SDL_shaders_metal_osx.h  |  3454 +-
 .../src/render/metal/SDL_shaders_metal_tvos.h |  3426 +-
 .../metal/SDL_shaders_metal_tvsimulator.h     |  3929 +-
 .../lib/sdl/src/render/opengl/SDL_glfuncs.h   |    26 +-
 .../lib/sdl/src/render/opengl/SDL_render_gl.c |   815 +-
 .../sdl/src/render/opengl/SDL_shaders_gl.c    |    60 +-
 .../sdl/src/render/opengl/SDL_shaders_gl.h    |    10 +-
 .../sdl/src/render/opengles/SDL_glesfuncs.h   |     7 +-
 .../sdl/src/render/opengles/SDL_render_gles.c |   357 +-
 .../sdl/src/render/opengles2/SDL_gles2funcs.h |     3 +-
 .../src/render/opengles2/SDL_render_gles2.c   |   999 +-
 .../src/render/opengles2/SDL_shaders_gles2.c  |   423 +-
 .../src/render/opengles2/SDL_shaders_gles2.h  |    56 +-
 .../lib/sdl/src/render/psp/SDL_render_psp.c   |   834 +-
 .../src/render/software/SDL_blendfillrect.c   |     6 +-
 .../src/render/software/SDL_blendfillrect.h   |     2 +-
 .../sdl/src/render/software/SDL_blendline.c   |     4 +-
 .../sdl/src/render/software/SDL_blendline.h   |     2 +-
 .../sdl/src/render/software/SDL_blendpoint.c  |     6 +-
 .../sdl/src/render/software/SDL_blendpoint.h  |     2 +-
 Engine/lib/sdl/src/render/software/SDL_draw.h |    10 +-
 .../sdl/src/render/software/SDL_drawline.c    |    10 +-
 .../sdl/src/render/software/SDL_drawline.h    |     2 +-
 .../sdl/src/render/software/SDL_drawpoint.c   |     6 +-
 .../sdl/src/render/software/SDL_drawpoint.h   |     2 +-
 .../sdl/src/render/software/SDL_render_sw.c   |   435 +-
 .../sdl/src/render/software/SDL_render_sw_c.h |     2 +-
 .../lib/sdl/src/render/software/SDL_rotate.c  |   234 +-
 .../lib/sdl/src/render/software/SDL_rotate.h  |     8 +-
 .../sdl/src/render/software/SDL_triangle.c    |   888 +
 .../sdl/src/render/software/SDL_triangle.h    |    42 +
 .../src/render/vitagxm/SDL_render_vita_gxm.c  |  1042 +
 .../vitagxm/SDL_render_vita_gxm_memory.c      |   117 +
 .../vitagxm/SDL_render_vita_gxm_memory.h      |    40 +
 .../vitagxm/SDL_render_vita_gxm_shaders.h     |   280 +
 .../vitagxm/SDL_render_vita_gxm_tools.c       |  1239 +
 .../vitagxm/SDL_render_vita_gxm_tools.h       |    70 +
 .../vitagxm/SDL_render_vita_gxm_types.h       |   201 +
 .../src/render/vitagxm/shader_src/clear_f.cg  |     4 +
 .../src/render/vitagxm/shader_src/clear_v.cg  |     4 +
 .../src/render/vitagxm/shader_src/color_f.cg  |     4 +
 .../src/render/vitagxm/shader_src/color_v.cg  |    13 +
 .../render/vitagxm/shader_src/texture_f.cg    |     4 +
 .../render/vitagxm/shader_src/texture_v.cg    |    14 +
 Engine/lib/sdl/src/sensor/SDL_sensor.c        |     7 +-
 Engine/lib/sdl/src/sensor/SDL_sensor_c.h      |     2 +-
 Engine/lib/sdl/src/sensor/SDL_syssensor.h     |     3 +-
 .../src/sensor/android/SDL_androidsensor.c    |     2 +-
 .../src/sensor/android/SDL_androidsensor.h    |     2 +-
 .../sensor/coremotion/SDL_coremotionsensor.h  |     2 +-
 .../sensor/coremotion/SDL_coremotionsensor.m  |     2 +-
 .../sdl/src/sensor/dummy/SDL_dummysensor.c    |     2 +-
 .../sdl/src/sensor/dummy/SDL_dummysensor.h    |     2 +-
 .../lib/sdl/src/sensor/vita/SDL_vitasensor.c  |   219 +
 .../lib/sdl/src/sensor/vita/SDL_vitasensor.h  |    30 +
 .../src/sensor/windows/SDL_windowssensor.c    |    14 +-
 .../src/sensor/windows/SDL_windowssensor.h    |     2 +-
 Engine/lib/sdl/src/stdlib/SDL_crc32.c         |     2 +-
 Engine/lib/sdl/src/stdlib/SDL_getenv.c        |    16 +-
 Engine/lib/sdl/src/stdlib/SDL_iconv.c         |    97 +-
 Engine/lib/sdl/src/stdlib/SDL_malloc.c        |     7 +-
 Engine/lib/sdl/src/stdlib/SDL_qsort.c         |     2 +-
 Engine/lib/sdl/src/stdlib/SDL_stdlib.c        |    83 +-
 Engine/lib/sdl/src/stdlib/SDL_string.c        |   382 +-
 Engine/lib/sdl/src/stdlib/SDL_strtokr.c       |     7 +-
 Engine/lib/sdl/src/test/SDL_test_assert.c     |     4 +-
 Engine/lib/sdl/src/test/SDL_test_common.c     |   597 +-
 Engine/lib/sdl/src/test/SDL_test_compare.c    |     2 +-
 Engine/lib/sdl/src/test/SDL_test_crc32.c      |     2 +-
 Engine/lib/sdl/src/test/SDL_test_font.c       |    62 +-
 Engine/lib/sdl/src/test/SDL_test_fuzzer.c     |     2 +-
 Engine/lib/sdl/src/test/SDL_test_harness.c    |    43 +-
 Engine/lib/sdl/src/test/SDL_test_imageBlit.c  |     2 +-
 .../sdl/src/test/SDL_test_imageBlitBlend.c    |     2 +-
 Engine/lib/sdl/src/test/SDL_test_imageFace.c  |     2 +-
 .../sdl/src/test/SDL_test_imagePrimitives.c   |     2 +-
 .../src/test/SDL_test_imagePrimitivesBlend.c  |     2 +-
 Engine/lib/sdl/src/test/SDL_test_log.c        |     2 +-
 Engine/lib/sdl/src/test/SDL_test_md5.c        |     2 +-
 Engine/lib/sdl/src/test/SDL_test_memory.c     |     7 +-
 Engine/lib/sdl/src/test/SDL_test_random.c     |     5 +-
 Engine/lib/sdl/src/thread/SDL_systhread.h     |     2 +-
 Engine/lib/sdl/src/thread/SDL_thread.c        |     8 +-
 Engine/lib/sdl/src/thread/SDL_thread_c.h      |     4 +-
 .../lib/sdl/src/thread/generic/SDL_syscond.c  |    53 +-
 .../sdl/src/thread/generic/SDL_syscond_c.h    |    42 +
 .../lib/sdl/src/thread/generic/SDL_sysmutex.c |     8 +-
 .../sdl/src/thread/generic/SDL_sysmutex_c.h   |     2 +-
 .../lib/sdl/src/thread/generic/SDL_syssem.c   |     8 +-
 .../sdl/src/thread/generic/SDL_systhread.c    |     2 +-
 .../sdl/src/thread/generic/SDL_systhread_c.h  |     2 +-
 .../lib/sdl/src/thread/generic/SDL_systls.c   |     2 +-
 Engine/lib/sdl/src/thread/os2/SDL_sysmutex.c  |     8 +-
 Engine/lib/sdl/src/thread/os2/SDL_syssem.c    |     8 +-
 Engine/lib/sdl/src/thread/os2/SDL_systhread.c |     2 +-
 .../lib/sdl/src/thread/os2/SDL_systhread_c.h  |     2 +-
 Engine/lib/sdl/src/thread/os2/SDL_systls.c    |     2 +-
 Engine/lib/sdl/src/thread/os2/SDL_systls_c.h  |     2 +-
 Engine/lib/sdl/src/thread/psp/SDL_syscond.c   |     8 +-
 Engine/lib/sdl/src/thread/psp/SDL_sysmutex.c  |   108 +-
 .../lib/sdl/src/thread/psp/SDL_sysmutex_c.h   |     2 +-
 Engine/lib/sdl/src/thread/psp/SDL_syssem.c    |    14 +-
 Engine/lib/sdl/src/thread/psp/SDL_systhread.c |    10 +-
 .../lib/sdl/src/thread/psp/SDL_systhread_c.h  |     2 +-
 .../lib/sdl/src/thread/pthread/SDL_syscond.c  |    10 +-
 .../lib/sdl/src/thread/pthread/SDL_sysmutex.c |     8 +-
 .../sdl/src/thread/pthread/SDL_sysmutex_c.h   |     2 +-
 .../lib/sdl/src/thread/pthread/SDL_syssem.c   |    10 +-
 .../sdl/src/thread/pthread/SDL_systhread.c    |    43 +-
 .../sdl/src/thread/pthread/SDL_systhread_c.h  |     2 +-
 .../lib/sdl/src/thread/pthread/SDL_systls.c   |     2 +-
 .../lib/sdl/src/thread/stdcpp/SDL_syscond.cpp |    17 +-
 .../sdl/src/thread/stdcpp/SDL_sysmutex.cpp    |    13 +-
 .../sdl/src/thread/stdcpp/SDL_sysmutex_c.h    |     2 +-
 .../sdl/src/thread/stdcpp/SDL_systhread.cpp   |     8 +-
 .../sdl/src/thread/stdcpp/SDL_systhread_c.h   |     2 +-
 Engine/lib/sdl/src/thread/vita/SDL_syscond.c  |   224 +
 Engine/lib/sdl/src/thread/vita/SDL_sysmutex.c |   149 +
 .../lib/sdl/src/thread/vita/SDL_sysmutex_c.h  |    23 +
 Engine/lib/sdl/src/thread/vita/SDL_syssem.c   |   162 +
 .../lib/sdl/src/thread/vita/SDL_systhread.c   |   138 +
 .../lib/sdl/src/thread/vita/SDL_systhread_c.h |    26 +
 .../sdl/src/thread/windows/SDL_syscond_cv.c   |   299 +
 .../lib/sdl/src/thread/windows/SDL_sysmutex.c |   259 +-
 .../sdl/src/thread/windows/SDL_sysmutex_c.h   |    74 +
 .../lib/sdl/src/thread/windows/SDL_syssem.c   |   378 +-
 .../sdl/src/thread/windows/SDL_systhread.c    |     6 +-
 .../sdl/src/thread/windows/SDL_systhread_c.h  |     2 +-
 .../lib/sdl/src/thread/windows/SDL_systls.c   |     2 +-
 Engine/lib/sdl/src/timer/SDL_timer.c          |   124 +-
 Engine/lib/sdl/src/timer/SDL_timer_c.h        |     2 +-
 Engine/lib/sdl/src/timer/dummy/SDL_systimer.c |     6 +-
 Engine/lib/sdl/src/timer/haiku/SDL_systimer.c |     8 +-
 Engine/lib/sdl/src/timer/os2/SDL_systimer.c   |    42 +-
 Engine/lib/sdl/src/timer/psp/SDL_systimer.c   |    19 +-
 Engine/lib/sdl/src/timer/unix/SDL_systimer.c  |    44 +-
 Engine/lib/sdl/src/timer/vita/SDL_systimer.c  |    89 +
 .../lib/sdl/src/timer/windows/SDL_systimer.c  |    68 +-
 Engine/lib/sdl/src/video/SDL_RLEaccel.c       |    16 +-
 Engine/lib/sdl/src/video/SDL_RLEaccel_c.h     |     2 +-
 Engine/lib/sdl/src/video/SDL_blit.c           |     6 +-
 Engine/lib/sdl/src/video/SDL_blit.h           |    50 +-
 Engine/lib/sdl/src/video/SDL_blit_0.c         |    85 +-
 Engine/lib/sdl/src/video/SDL_blit_1.c         |     2 +-
 Engine/lib/sdl/src/video/SDL_blit_A.c         |    91 +-
 Engine/lib/sdl/src/video/SDL_blit_N.c         |    75 +-
 Engine/lib/sdl/src/video/SDL_blit_auto.c      |  1682 +-
 Engine/lib/sdl/src/video/SDL_blit_auto.h      |     2 +-
 Engine/lib/sdl/src/video/SDL_blit_copy.c      |     4 +-
 Engine/lib/sdl/src/video/SDL_blit_copy.h      |     2 +-
 Engine/lib/sdl/src/video/SDL_blit_slow.c      |    84 +-
 Engine/lib/sdl/src/video/SDL_blit_slow.h      |     2 +-
 Engine/lib/sdl/src/video/SDL_bmp.c            |    57 +-
 Engine/lib/sdl/src/video/SDL_clipboard.c      |     2 +-
 Engine/lib/sdl/src/video/SDL_egl.c            |   312 +-
 Engine/lib/sdl/src/video/SDL_egl_c.h          |     9 +-
 Engine/lib/sdl/src/video/SDL_fillrect.c       |    46 +-
 Engine/lib/sdl/src/video/SDL_pixels.c         |    14 +-
 Engine/lib/sdl/src/video/SDL_pixels_c.h       |     2 +-
 Engine/lib/sdl/src/video/SDL_rect.c           |   493 +-
 Engine/lib/sdl/src/video/SDL_rect_c.h         |     2 +-
 Engine/lib/sdl/src/video/SDL_rect_impl.h      |   444 +
 Engine/lib/sdl/src/video/SDL_shape.c          |     2 +-
 .../lib/sdl/src/video/SDL_shape_internals.h   |     2 +-
 Engine/lib/sdl/src/video/SDL_stretch.c        |  1140 +-
 Engine/lib/sdl/src/video/SDL_surface.c        |   394 +-
 Engine/lib/sdl/src/video/SDL_sysvideo.h       |    26 +-
 Engine/lib/sdl/src/video/SDL_video.c          |   825 +-
 .../lib/sdl/src/video/SDL_vulkan_internal.h   |    10 +-
 Engine/lib/sdl/src/video/SDL_vulkan_utils.c   |   338 +-
 Engine/lib/sdl/src/video/SDL_yuv.c            |     4 +-
 Engine/lib/sdl/src/video/SDL_yuv_c.h          |     2 +-
 .../src/video/android/SDL_androidclipboard.c  |     2 +-
 .../src/video/android/SDL_androidclipboard.h  |     2 +-
 .../sdl/src/video/android/SDL_androidevents.c |    39 +-
 .../sdl/src/video/android/SDL_androidevents.h |     2 +-
 .../lib/sdl/src/video/android/SDL_androidgl.c |     6 +-
 .../lib/sdl/src/video/android/SDL_androidgl.h |     2 +-
 .../src/video/android/SDL_androidkeyboard.c   |     2 +-
 .../src/video/android/SDL_androidkeyboard.h   |     2 +-
 .../src/video/android/SDL_androidmessagebox.c |     2 +-
 .../src/video/android/SDL_androidmessagebox.h |     2 +-
 .../sdl/src/video/android/SDL_androidmouse.c  |     6 +-
 .../sdl/src/video/android/SDL_androidmouse.h  |     2 +-
 .../sdl/src/video/android/SDL_androidtouch.c  |     2 +-
 .../sdl/src/video/android/SDL_androidtouch.h  |     2 +-
 .../sdl/src/video/android/SDL_androidvideo.c  |    50 +-
 .../sdl/src/video/android/SDL_androidvideo.h  |     5 +-
 .../sdl/src/video/android/SDL_androidvulkan.c |     2 +-
 .../sdl/src/video/android/SDL_androidvulkan.h |     2 +-
 .../sdl/src/video/android/SDL_androidwindow.c |    12 +-
 .../sdl/src/video/android/SDL_androidwindow.h |     4 +-
 .../sdl/src/video/cocoa/SDL_cocoaclipboard.h  |     2 +-
 .../sdl/src/video/cocoa/SDL_cocoaclipboard.m  |    10 +-
 .../lib/sdl/src/video/cocoa/SDL_cocoaevents.h |     4 +-
 .../lib/sdl/src/video/cocoa/SDL_cocoaevents.m |   107 +-
 .../sdl/src/video/cocoa/SDL_cocoakeyboard.h   |     4 +-
 .../sdl/src/video/cocoa/SDL_cocoakeyboard.m   |    19 +-
 .../sdl/src/video/cocoa/SDL_cocoamessagebox.h |     2 +-
 .../sdl/src/video/cocoa/SDL_cocoamessagebox.m |    29 +-
 .../sdl/src/video/cocoa/SDL_cocoametalview.h  |     3 +-
 .../sdl/src/video/cocoa/SDL_cocoametalview.m  |    26 +-
 .../lib/sdl/src/video/cocoa/SDL_cocoamodes.h  |     2 +-
 .../lib/sdl/src/video/cocoa/SDL_cocoamodes.m  |    69 +-
 .../lib/sdl/src/video/cocoa/SDL_cocoamouse.h  |     3 +-
 .../lib/sdl/src/video/cocoa/SDL_cocoamouse.m  |    84 +-
 .../sdl/src/video/cocoa/SDL_cocoamousetap.m   |   286 -
 .../lib/sdl/src/video/cocoa/SDL_cocoaopengl.h |     2 +-
 .../lib/sdl/src/video/cocoa/SDL_cocoaopengl.m |     4 +-
 .../sdl/src/video/cocoa/SDL_cocoaopengles.h   |     2 +-
 .../sdl/src/video/cocoa/SDL_cocoaopengles.m   |     5 +-
 .../lib/sdl/src/video/cocoa/SDL_cocoashape.h  |     2 +-
 .../lib/sdl/src/video/cocoa/SDL_cocoashape.m  |     2 +-
 .../lib/sdl/src/video/cocoa/SDL_cocoavideo.h  |     2 +-
 .../lib/sdl/src/video/cocoa/SDL_cocoavideo.m  |    20 +-
 .../lib/sdl/src/video/cocoa/SDL_cocoavulkan.h |     2 +-
 .../lib/sdl/src/video/cocoa/SDL_cocoavulkan.m |     2 +-
 .../lib/sdl/src/video/cocoa/SDL_cocoawindow.h |    15 +-
 .../lib/sdl/src/video/cocoa/SDL_cocoawindow.m |   425 +-
 .../sdl/src/video/directfb/SDL_DirectFB_WM.c  |    19 +-
 .../sdl/src/video/directfb/SDL_DirectFB_WM.h  |     2 +-
 .../sdl/src/video/directfb/SDL_DirectFB_dyn.c |     2 +-
 .../sdl/src/video/directfb/SDL_DirectFB_dyn.h |     2 +-
 .../src/video/directfb/SDL_DirectFB_events.c  |    33 +-
 .../src/video/directfb/SDL_DirectFB_events.h  |     2 +-
 .../src/video/directfb/SDL_DirectFB_modes.c   |     2 +-
 .../src/video/directfb/SDL_DirectFB_modes.h   |     2 +-
 .../src/video/directfb/SDL_DirectFB_mouse.c   |     4 +-
 .../src/video/directfb/SDL_DirectFB_mouse.h   |     2 +-
 .../src/video/directfb/SDL_DirectFB_opengl.c  |     4 +-
 .../src/video/directfb/SDL_DirectFB_opengl.h  |     2 +-
 .../src/video/directfb/SDL_DirectFB_render.c  |   223 +-
 .../src/video/directfb/SDL_DirectFB_render.h  |     2 +-
 .../src/video/directfb/SDL_DirectFB_shape.c   |     4 +-
 .../src/video/directfb/SDL_DirectFB_shape.h   |     2 +-
 .../src/video/directfb/SDL_DirectFB_video.c   |     8 +-
 .../src/video/directfb/SDL_DirectFB_video.h   |     6 +-
 .../src/video/directfb/SDL_DirectFB_vulkan.c  |     2 +-
 .../src/video/directfb/SDL_DirectFB_vulkan.h  |     2 +-
 .../src/video/directfb/SDL_DirectFB_window.c  |    29 +-
 .../src/video/directfb/SDL_DirectFB_window.h  |     5 +-
 .../lib/sdl/src/video/dummy/SDL_nullevents.c  |     2 +-
 .../sdl/src/video/dummy/SDL_nullevents_c.h    |     2 +-
 .../sdl/src/video/dummy/SDL_nullframebuffer.c |    12 +-
 .../src/video/dummy/SDL_nullframebuffer_c.h   |     2 +-
 .../lib/sdl/src/video/dummy/SDL_nullvideo.c   |     4 +-
 .../lib/sdl/src/video/dummy/SDL_nullvideo.h   |     2 +-
 .../video/emscripten/SDL_emscriptenevents.c   |    32 +-
 .../video/emscripten/SDL_emscriptenevents.h   |     2 +-
 .../emscripten/SDL_emscriptenframebuffer.c    |    13 +-
 .../emscripten/SDL_emscriptenframebuffer.h    |     2 +-
 .../video/emscripten/SDL_emscriptenmouse.c    |     2 +-
 .../video/emscripten/SDL_emscriptenmouse.h    |     2 +-
 .../video/emscripten/SDL_emscriptenopengles.c |     2 +-
 .../video/emscripten/SDL_emscriptenopengles.h |     2 +-
 .../video/emscripten/SDL_emscriptenvideo.c    |    43 +-
 .../video/emscripten/SDL_emscriptenvideo.h    |     2 +-
 Engine/lib/sdl/src/video/haiku/SDL_BApp.h     |   431 +
 Engine/lib/sdl/src/video/haiku/SDL_BWin.h     |   422 +-
 .../lib/sdl/src/video/haiku/SDL_bclipboard.cc |     2 +-
 .../lib/sdl/src/video/haiku/SDL_bclipboard.h  |     2 +-
 Engine/lib/sdl/src/video/haiku/SDL_bevents.cc |     2 +-
 Engine/lib/sdl/src/video/haiku/SDL_bevents.h  |     2 +-
 .../sdl/src/video/haiku/SDL_bframebuffer.cc   |   152 +-
 .../sdl/src/video/haiku/SDL_bframebuffer.h    |     2 +-
 .../lib/sdl/src/video/haiku/SDL_bkeyboard.cc  |     2 +-
 .../lib/sdl/src/video/haiku/SDL_bkeyboard.h   |     2 +-
 .../sdl/src/video/haiku/SDL_bmessagebox.cc    |     2 +-
 .../lib/sdl/src/video/haiku/SDL_bmessagebox.h |     2 +-
 Engine/lib/sdl/src/video/haiku/SDL_bmodes.cc  |     6 +-
 Engine/lib/sdl/src/video/haiku/SDL_bmodes.h   |     2 +-
 Engine/lib/sdl/src/video/haiku/SDL_bopengl.cc |    38 +-
 Engine/lib/sdl/src/video/haiku/SDL_bopengl.h  |     2 +-
 Engine/lib/sdl/src/video/haiku/SDL_bvideo.cc  |   134 +-
 Engine/lib/sdl/src/video/haiku/SDL_bvideo.h   |     2 +-
 Engine/lib/sdl/src/video/haiku/SDL_bwindow.cc |    11 +-
 Engine/lib/sdl/src/video/haiku/SDL_bwindow.h  |     5 +-
 Engine/lib/sdl/src/video/khronos/EGL/egl.h    |    89 +-
 Engine/lib/sdl/src/video/khronos/EGL/eglext.h |   276 +-
 .../sdl/src/video/khronos/EGL/eglplatform.h   |    95 +-
 .../sdl/src/video/khronos/KHR/khrplatform.h   |    26 +-
 .../lib/sdl/src/video/kmsdrm/SDL_kmsdrmdyn.c  |     4 +-
 .../lib/sdl/src/video/kmsdrm/SDL_kmsdrmdyn.h  |     3 +-
 .../sdl/src/video/kmsdrm/SDL_kmsdrmevents.c   |     7 +-
 .../sdl/src/video/kmsdrm/SDL_kmsdrmevents.h   |     3 +-
 .../sdl/src/video/kmsdrm/SDL_kmsdrmmouse.c    |   627 +-
 .../sdl/src/video/kmsdrm/SDL_kmsdrmmouse.h    |    19 +-
 .../sdl/src/video/kmsdrm/SDL_kmsdrmopengles.c |   355 +-
 .../sdl/src/video/kmsdrm/SDL_kmsdrmopengles.h |     7 +-
 .../lib/sdl/src/video/kmsdrm/SDL_kmsdrmsym.h  |    61 +-
 .../sdl/src/video/kmsdrm/SDL_kmsdrmvideo.c    |  2107 +-
 .../sdl/src/video/kmsdrm/SDL_kmsdrmvideo.h    |   137 +-
 .../sdl/src/video/kmsdrm/SDL_kmsdrmvulkan.c   |   269 +-
 .../sdl/src/video/kmsdrm/SDL_kmsdrmvulkan.h   |     8 +-
 .../kmsdrm_legacy/SDL_kmsdrm_legacy_dyn.c     |   167 -
 .../kmsdrm_legacy/SDL_kmsdrm_legacy_mouse.c   |   502 -
 .../SDL_kmsdrm_legacy_opengles.c              |   152 -
 .../SDL_kmsdrm_legacy_opengles.h              |    48 -
 .../kmsdrm_legacy/SDL_kmsdrm_legacy_sym.h     |    99 -
 .../kmsdrm_legacy/SDL_kmsdrm_legacy_video.c   |   934 -
 .../kmsdrm_legacy/SDL_kmsdrm_legacy_video.h   |   132 -
 .../lib/sdl/src/video/nacl/SDL_naclevents.c   |     2 +-
 .../lib/sdl/src/video/nacl/SDL_naclevents_c.h |     2 +-
 Engine/lib/sdl/src/video/nacl/SDL_naclglue.c  |     2 +-
 .../lib/sdl/src/video/nacl/SDL_naclopengles.c |     6 +-
 .../lib/sdl/src/video/nacl/SDL_naclopengles.h |     2 +-
 Engine/lib/sdl/src/video/nacl/SDL_naclvideo.c |     2 +-
 Engine/lib/sdl/src/video/nacl/SDL_naclvideo.h |     2 +-
 .../lib/sdl/src/video/nacl/SDL_naclwindow.c   |     5 +-
 .../lib/sdl/src/video/nacl/SDL_naclwindow.h   |     2 +-
 .../src/video/offscreen/SDL_offscreenevents.c |     2 +-
 .../video/offscreen/SDL_offscreenevents_c.h   |     2 +-
 .../offscreen/SDL_offscreenframebuffer.c      |    10 +-
 .../offscreen/SDL_offscreenframebuffer_c.h    |     2 +-
 .../src/video/offscreen/SDL_offscreenopengl.c |     8 +-
 .../src/video/offscreen/SDL_offscreenopengl.h |     2 +-
 .../src/video/offscreen/SDL_offscreenvideo.c  |     2 +-
 .../src/video/offscreen/SDL_offscreenvideo.h  |     2 +-
 .../src/video/offscreen/SDL_offscreenwindow.c |     2 +-
 .../src/video/offscreen/SDL_offscreenwindow.h |     2 +-
 .../src/video/os2/{my_gradd.h => SDL_gradd.h} |     6 +-
 Engine/lib/sdl/src/video/os2/SDL_os2dive.c    |    14 +-
 .../lib/sdl/src/video/os2/SDL_os2messagebox.c |    72 +-
 .../lib/sdl/src/video/os2/SDL_os2messagebox.h |     2 +-
 Engine/lib/sdl/src/video/os2/SDL_os2mouse.c   |     2 +-
 Engine/lib/sdl/src/video/os2/SDL_os2mouse.h   |     2 +-
 Engine/lib/sdl/src/video/os2/SDL_os2output.h  |     2 +-
 Engine/lib/sdl/src/video/os2/SDL_os2util.c    |    11 +-
 Engine/lib/sdl/src/video/os2/SDL_os2util.h    |     2 +-
 Engine/lib/sdl/src/video/os2/SDL_os2video.c   |    69 +-
 Engine/lib/sdl/src/video/os2/SDL_os2video.h   |     2 +-
 Engine/lib/sdl/src/video/os2/SDL_os2vman.c    |    17 +-
 .../lib/sdl/src/video/pandora/SDL_pandora.c   |    11 +-
 .../lib/sdl/src/video/pandora/SDL_pandora.h   |     3 +-
 .../src/video/pandora/SDL_pandora_events.c    |     2 +-
 .../src/video/pandora/SDL_pandora_events.h    |     2 +-
 Engine/lib/sdl/src/video/psp/SDL_pspevents.c  |     3 +-
 .../lib/sdl/src/video/psp/SDL_pspevents_c.h   |     2 +-
 Engine/lib/sdl/src/video/psp/SDL_pspgl.c      |     2 +-
 Engine/lib/sdl/src/video/psp/SDL_pspgl_c.h    |     2 +-
 Engine/lib/sdl/src/video/psp/SDL_pspmouse.c   |     2 +-
 Engine/lib/sdl/src/video/psp/SDL_pspmouse_c.h |     2 +-
 Engine/lib/sdl/src/video/psp/SDL_pspvideo.c   |    19 +-
 Engine/lib/sdl/src/video/psp/SDL_pspvideo.h   |     3 +-
 Engine/lib/sdl/src/video/qnx/gl.c             |     6 +-
 .../sdl/src/video/raspberry/SDL_rpievents.c   |     2 +-
 .../sdl/src/video/raspberry/SDL_rpievents_c.h |     2 +-
 .../sdl/src/video/raspberry/SDL_rpimouse.c    |     2 +-
 .../sdl/src/video/raspberry/SDL_rpimouse.h    |     2 +-
 .../sdl/src/video/raspberry/SDL_rpiopengles.c |     2 +-
 .../sdl/src/video/raspberry/SDL_rpiopengles.h |     2 +-
 .../sdl/src/video/raspberry/SDL_rpivideo.c    |     8 +-
 .../sdl/src/video/raspberry/SDL_rpivideo.h    |     3 +-
 .../SDL_riscosdefs.h}                         |    48 +-
 .../sdl/src/video/riscos/SDL_riscosevents.c   |   178 +
 .../SDL_riscosevents_c.h}                     |    19 +-
 .../src/video/riscos/SDL_riscosframebuffer.c  |   126 +
 .../SDL_riscosframebuffer_c.h}                |    28 +-
 .../src/video/riscos/SDL_riscosmessagebox.c   |    68 +
 .../SDL_riscosmessagebox.h}                   |    14 +-
 .../sdl/src/video/riscos/SDL_riscosmodes.c    |   315 +
 .../sdl/src/video/riscos/SDL_riscosmodes.h    |    33 +
 .../sdl/src/video/riscos/SDL_riscosvideo.c    |   124 +
 .../SDL_riscosvideo.h}                        |    26 +-
 .../sdl/src/video/riscos/SDL_riscoswindow.c   |    78 +
 .../sdl/src/video/riscos/SDL_riscoswindow.h   |    42 +
 .../sdl/src/video/riscos/scancodes_riscos.h   |   158 +
 Engine/lib/sdl/src/video/sdlgenblit.pl        |   125 +-
 .../src/video/uikit/SDL_uikitappdelegate.h    |     2 +-
 .../src/video/uikit/SDL_uikitappdelegate.m    |     2 +-
 .../sdl/src/video/uikit/SDL_uikitclipboard.h  |     2 +-
 .../sdl/src/video/uikit/SDL_uikitclipboard.m  |     2 +-
 .../lib/sdl/src/video/uikit/SDL_uikitevents.h |     3 +-
 .../lib/sdl/src/video/uikit/SDL_uikitevents.m |   107 +-
 .../sdl/src/video/uikit/SDL_uikitmessagebox.h |     2 +-
 .../sdl/src/video/uikit/SDL_uikitmessagebox.m |     4 +-
 .../sdl/src/video/uikit/SDL_uikitmetalview.h  |     3 +-
 .../sdl/src/video/uikit/SDL_uikitmetalview.m  |    10 +-
 .../lib/sdl/src/video/uikit/SDL_uikitmodes.h  |     2 +-
 .../lib/sdl/src/video/uikit/SDL_uikitmodes.m  |     2 +-
 .../sdl/src/video/uikit/SDL_uikitopengles.h   |     2 +-
 .../sdl/src/video/uikit/SDL_uikitopengles.m   |     6 +-
 .../sdl/src/video/uikit/SDL_uikitopenglview.h |     2 +-
 .../sdl/src/video/uikit/SDL_uikitopenglview.m |     2 +-
 .../lib/sdl/src/video/uikit/SDL_uikitvideo.h  |     2 +-
 .../lib/sdl/src/video/uikit/SDL_uikitvideo.m  |    16 +-
 .../lib/sdl/src/video/uikit/SDL_uikitview.h   |     2 +-
 .../lib/sdl/src/video/uikit/SDL_uikitview.m   |     4 +-
 .../src/video/uikit/SDL_uikitviewcontroller.h |     2 +-
 .../src/video/uikit/SDL_uikitviewcontroller.m |    15 +-
 .../lib/sdl/src/video/uikit/SDL_uikitvulkan.h |     2 +-
 .../lib/sdl/src/video/uikit/SDL_uikitvulkan.m |     2 +-
 .../lib/sdl/src/video/uikit/SDL_uikitwindow.h |     4 +-
 .../lib/sdl/src/video/uikit/SDL_uikitwindow.m |    36 +-
 Engine/lib/sdl/src/video/uikit/keyinfotable.h |     2 +-
 .../sdl/src/video/vita/SDL_vitaframebuffer.c  |   116 +
 .../sdl/src/video/vita/SDL_vitaframebuffer.h  |    27 +
 Engine/lib/sdl/src/video/vita/SDL_vitagl.c    |   235 +
 Engine/lib/sdl/src/video/vita/SDL_vitagl_c.h  |    57 +
 .../lib/sdl/src/video/vita/SDL_vitagl_pvr.c   |   103 +
 .../lib/sdl/src/video/vita/SDL_vitagl_pvr_c.h |    35 +
 .../lib/sdl/src/video/vita/SDL_vitakeyboard.c |   203 +
 .../lib/sdl/src/video/vita/SDL_vitakeyboard.h |    33 +
 .../sdl/src/video/vita/SDL_vitamessagebox.c   |   150 +
 .../sdl/src/video/vita/SDL_vitamessagebox.h   |    33 +
 Engine/lib/sdl/src/video/vita/SDL_vitamouse.c |    94 +
 .../lib/sdl/src/video/vita/SDL_vitamouse_c.h  |    33 +
 Engine/lib/sdl/src/video/vita/SDL_vitatouch.c |   194 +
 Engine/lib/sdl/src/video/vita/SDL_vitatouch.h |    35 +
 Engine/lib/sdl/src/video/vita/SDL_vitavideo.c |   601 +
 Engine/lib/sdl/src/video/vita/SDL_vitavideo.h |   115 +
 .../src/video/vivante/SDL_vivanteopengles.c   |     2 +-
 .../src/video/vivante/SDL_vivanteopengles.h   |     2 +-
 .../src/video/vivante/SDL_vivanteplatform.c   |     2 +-
 .../src/video/vivante/SDL_vivanteplatform.h   |     2 +-
 .../sdl/src/video/vivante/SDL_vivantevideo.c  |     2 +-
 .../sdl/src/video/vivante/SDL_vivantevideo.h  |     2 +-
 .../sdl/src/video/vivante/SDL_vivantevulkan.c |     2 +-
 .../sdl/src/video/vivante/SDL_vivantevulkan.h |     2 +-
 .../src/video/wayland/SDL_waylandclipboard.c  |    80 +-
 .../src/video/wayland/SDL_waylandclipboard.h  |     2 +-
 .../video/wayland/SDL_waylanddatamanager.c    |    25 +-
 .../video/wayland/SDL_waylanddatamanager.h    |     2 +-
 .../sdl/src/video/wayland/SDL_waylanddyn.c    |     8 +-
 .../sdl/src/video/wayland/SDL_waylanddyn.h    |    70 +-
 .../sdl/src/video/wayland/SDL_waylandevents.c |   938 +-
 .../src/video/wayland/SDL_waylandevents_c.h   |    70 +-
 .../src/video/wayland/SDL_waylandkeyboard.c   |   154 +
 .../src/video/wayland/SDL_waylandkeyboard.h   |    42 +
 .../src/video/wayland/SDL_waylandmessagebox.c |   195 +
 .../src/video/wayland/SDL_waylandmessagebox.h |    33 +
 .../sdl/src/video/wayland/SDL_waylandmouse.c  |   274 +-
 .../sdl/src/video/wayland/SDL_waylandmouse.h  |     4 +-
 .../src/video/wayland/SDL_waylandopengles.c   |   132 +-
 .../src/video/wayland/SDL_waylandopengles.h   |     6 +-
 .../sdl/src/video/wayland/SDL_waylandsym.h    |    93 +-
 .../sdl/src/video/wayland/SDL_waylandtouch.c  |    14 +-
 .../sdl/src/video/wayland/SDL_waylandtouch.h  |     3 +-
 .../sdl/src/video/wayland/SDL_waylandvideo.c  |   454 +-
 .../sdl/src/video/wayland/SDL_waylandvideo.h  |    53 +-
 .../sdl/src/video/wayland/SDL_waylandvulkan.c |     2 +-
 .../sdl/src/video/wayland/SDL_waylandvulkan.h |     2 +-
 .../sdl/src/video/wayland/SDL_waylandwindow.c |  1521 +-
 .../sdl/src/video/wayland/SDL_waylandwindow.h |    64 +-
 Engine/lib/sdl/src/video/windows/SDL_msctf.h  |     2 +-
 Engine/lib/sdl/src/video/windows/SDL_vkeys.h  |     2 +-
 .../src/video/windows/SDL_windowsclipboard.c  |     2 +-
 .../src/video/windows/SDL_windowsclipboard.h  |     2 +-
 .../sdl/src/video/windows/SDL_windowsevents.c |   737 +-
 .../sdl/src/video/windows/SDL_windowsevents.h |     5 +-
 .../video/windows/SDL_windowsframebuffer.c    |     2 +-
 .../video/windows/SDL_windowsframebuffer.h    |     2 +-
 .../src/video/windows/SDL_windowskeyboard.c   |   311 +-
 .../src/video/windows/SDL_windowskeyboard.h   |     4 +-
 .../src/video/windows/SDL_windowsmessagebox.c |    20 +-
 .../src/video/windows/SDL_windowsmessagebox.h |     2 +-
 .../sdl/src/video/windows/SDL_windowsmodes.c  |    85 +-
 .../sdl/src/video/windows/SDL_windowsmodes.h  |     2 +-
 .../sdl/src/video/windows/SDL_windowsmouse.c  |    88 +-
 .../sdl/src/video/windows/SDL_windowsmouse.h  |     4 +-
 .../sdl/src/video/windows/SDL_windowsopengl.c |     2 +-
 .../sdl/src/video/windows/SDL_windowsopengl.h |     2 +-
 .../src/video/windows/SDL_windowsopengles.c   |     5 +-
 .../src/video/windows/SDL_windowsopengles.h   |     2 +-
 .../sdl/src/video/windows/SDL_windowsshape.c  |     2 +-
 .../sdl/src/video/windows/SDL_windowsshape.h  |     2 +-
 .../src/video/windows/SDL_windowstaskdialog.h |     2 +-
 .../sdl/src/video/windows/SDL_windowsvideo.c  |    58 +-
 .../sdl/src/video/windows/SDL_windowsvideo.h  |    15 +-
 .../sdl/src/video/windows/SDL_windowsvulkan.c |     2 +-
 .../sdl/src/video/windows/SDL_windowsvulkan.h |     2 +-
 .../sdl/src/video/windows/SDL_windowswindow.c |   360 +-
 .../sdl/src/video/windows/SDL_windowswindow.h |    14 +-
 Engine/lib/sdl/src/video/windows/wmmsg.h      |     4 +-
 .../sdl/src/video/winrt/SDL_winrtevents.cpp   |     2 +-
 .../sdl/src/video/winrt/SDL_winrtevents_c.h   |     4 +-
 .../sdl/src/video/winrt/SDL_winrtgamebar.cpp  |     4 +-
 .../src/video/winrt/SDL_winrtgamebar_cpp.h    |     2 +-
 .../sdl/src/video/winrt/SDL_winrtkeyboard.cpp |     2 +-
 .../src/video/winrt/SDL_winrtmessagebox.cpp   |     2 +-
 .../sdl/src/video/winrt/SDL_winrtmessagebox.h |     2 +-
 .../sdl/src/video/winrt/SDL_winrtmouse.cpp    |     2 +-
 .../sdl/src/video/winrt/SDL_winrtmouse_c.h    |     2 +-
 .../sdl/src/video/winrt/SDL_winrtopengles.cpp |     2 +-
 .../sdl/src/video/winrt/SDL_winrtopengles.h   |     2 +-
 .../src/video/winrt/SDL_winrtpointerinput.cpp |    63 +-
 .../sdl/src/video/winrt/SDL_winrtvideo.cpp    |   102 +-
 .../sdl/src/video/winrt/SDL_winrtvideo_cpp.h  |     2 +-
 .../lib/sdl/src/video/x11/SDL_x11clipboard.c  |    82 +-
 .../lib/sdl/src/video/x11/SDL_x11clipboard.h  |    16 +-
 Engine/lib/sdl/src/video/x11/SDL_x11dyn.c     |     6 +-
 Engine/lib/sdl/src/video/x11/SDL_x11dyn.h     |     6 +-
 Engine/lib/sdl/src/video/x11/SDL_x11events.c  |   524 +-
 Engine/lib/sdl/src/video/x11/SDL_x11events.h  |     4 +-
 .../sdl/src/video/x11/SDL_x11framebuffer.c    |     4 +-
 .../sdl/src/video/x11/SDL_x11framebuffer.h    |     2 +-
 .../lib/sdl/src/video/x11/SDL_x11keyboard.c   |    12 +-
 .../lib/sdl/src/video/x11/SDL_x11keyboard.h   |     2 +-
 .../lib/sdl/src/video/x11/SDL_x11messagebox.c |    50 +-
 .../lib/sdl/src/video/x11/SDL_x11messagebox.h |     2 +-
 Engine/lib/sdl/src/video/x11/SDL_x11modes.c   |    93 +-
 Engine/lib/sdl/src/video/x11/SDL_x11modes.h   |     2 +-
 Engine/lib/sdl/src/video/x11/SDL_x11mouse.c   |    31 +-
 Engine/lib/sdl/src/video/x11/SDL_x11mouse.h   |     2 +-
 Engine/lib/sdl/src/video/x11/SDL_x11opengl.c  |    41 +-
 Engine/lib/sdl/src/video/x11/SDL_x11opengl.h  |     3 +-
 .../lib/sdl/src/video/x11/SDL_x11opengles.c   |     2 +-
 .../lib/sdl/src/video/x11/SDL_x11opengles.h   |     2 +-
 Engine/lib/sdl/src/video/x11/SDL_x11shape.c   |    10 +-
 Engine/lib/sdl/src/video/x11/SDL_x11shape.h   |     2 +-
 Engine/lib/sdl/src/video/x11/SDL_x11sym.h     |    30 +-
 Engine/lib/sdl/src/video/x11/SDL_x11touch.c   |     2 +-
 Engine/lib/sdl/src/video/x11/SDL_x11touch.h   |     2 +-
 Engine/lib/sdl/src/video/x11/SDL_x11video.c   |    56 +-
 Engine/lib/sdl/src/video/x11/SDL_x11video.h   |     9 +-
 Engine/lib/sdl/src/video/x11/SDL_x11vulkan.c  |     2 +-
 Engine/lib/sdl/src/video/x11/SDL_x11vulkan.h  |     2 +-
 Engine/lib/sdl/src/video/x11/SDL_x11window.c  |   316 +-
 Engine/lib/sdl/src/video/x11/SDL_x11window.h  |    17 +-
 Engine/lib/sdl/src/video/x11/SDL_x11xfixes.c  |   206 +
 Engine/lib/sdl/src/video/x11/SDL_x11xfixes.h  |    41 +
 Engine/lib/sdl/src/video/x11/SDL_x11xinput2.c |    46 +-
 Engine/lib/sdl/src/video/x11/SDL_x11xinput2.h |     4 +-
 Engine/lib/sdl/src/video/x11/edid-parse.c     |    10 +-
 Engine/lib/sdl/src/video/yuv2rgb/yuv_rgb.c    |     2 +-
 .../sdl/src/video/yuv2rgb/yuv_rgb_sse_func.h  |    16 +-
 Engine/lib/sdl/test/CMakeLists.txt            |   217 +-
 Engine/lib/sdl/test/Makefile.in               |    65 +-
 Engine/lib/sdl/test/Makefile.os2              |    54 +-
 Engine/lib/sdl/test/README                    |     2 +
 Engine/lib/sdl/test/acinclude.m4              |    48 +-
 Engine/lib/sdl/test/autogen.sh                |    17 +-
 Engine/lib/sdl/test/checkkeys.c               |    16 +-
 Engine/lib/sdl/test/checkkeysthreads.c        |   285 +
 Engine/lib/sdl/test/configure                 |   282 +-
 Engine/lib/sdl/test/configure.ac              |    57 +-
 Engine/lib/sdl/test/controllermap.c           |    56 +-
 Engine/lib/sdl/test/loopwave.c                |     2 +-
 Engine/lib/sdl/test/loopwavequeue.c           |     2 +-
 Engine/lib/sdl/test/testatomic.c              |    28 +-
 Engine/lib/sdl/test/testaudiocapture.c        |     2 +-
 Engine/lib/sdl/test/testaudiohotplug.c        |     2 +-
 Engine/lib/sdl/test/testaudioinfo.c           |     2 +-
 Engine/lib/sdl/test/testautomation.c          |     2 +-
 Engine/lib/sdl/test/testautomation_audio.c    |    20 +-
 .../lib/sdl/test/testautomation_clipboard.c   |    15 +-
 Engine/lib/sdl/test/testautomation_events.c   |    12 +-
 Engine/lib/sdl/test/testautomation_hints.c    |   106 +-
 Engine/lib/sdl/test/testautomation_keyboard.c |    62 +-
 Engine/lib/sdl/test/testautomation_main.c     |     8 +-
 Engine/lib/sdl/test/testautomation_mouse.c    |    23 +-
 Engine/lib/sdl/test/testautomation_pixels.c   |    28 +-
 Engine/lib/sdl/test/testautomation_platform.c |    73 +-
 Engine/lib/sdl/test/testautomation_rect.c     |    60 +-
 Engine/lib/sdl/test/testautomation_render.c   |   137 +-
 Engine/lib/sdl/test/testautomation_rwops.c    |    46 +-
 Engine/lib/sdl/test/testautomation_sdltest.c  |     9 +-
 Engine/lib/sdl/test/testautomation_stdlib.c   |    32 +
 Engine/lib/sdl/test/testautomation_video.c    |   228 +-
 Engine/lib/sdl/test/testbounds.c              |     2 +-
 Engine/lib/sdl/test/testcustomcursor.c        |     4 +-
 Engine/lib/sdl/test/testdisplayinfo.c         |     2 +-
 Engine/lib/sdl/test/testdraw2.c               |    35 +-
 Engine/lib/sdl/test/testdrawchessboard.c      |     6 +-
 Engine/lib/sdl/test/testdropfile.c            |     2 +-
 Engine/lib/sdl/test/testerror.c               |     2 +-
 Engine/lib/sdl/test/testevdev.c               |     2 +-
 Engine/lib/sdl/test/testfile.c                |     2 +-
 Engine/lib/sdl/test/testfilesystem.c          |     2 +-
 Engine/lib/sdl/test/testgamecontroller.c      |   213 +-
 Engine/lib/sdl/test/testgeometry.c            |   303 +
 Engine/lib/sdl/test/testgesture.c             |     9 +-
 Engine/lib/sdl/test/testgl2.c                 |     6 +-
 Engine/lib/sdl/test/testgles.c                |     2 +-
 Engine/lib/sdl/test/testgles2.c               |    20 +-
 Engine/lib/sdl/test/testgles2_sdf.c           |   805 +
 .../lib/sdl/test/testgles2_sdf_img_normal.bmp |   Bin 0 -> 68122 bytes
 Engine/lib/sdl/test/testgles2_sdf_img_sdf.bmp |   Bin 0 -> 72202 bytes
 Engine/lib/sdl/test/testhaptic.c              |    24 +-
 Engine/lib/sdl/test/testhotplug.c             |     2 +-
 Engine/lib/sdl/test/testiconv.c               |    12 +-
 Engine/lib/sdl/test/testime.c                 |     8 +-
 Engine/lib/sdl/test/testintersections.c       |     2 +-
 Engine/lib/sdl/test/testjoystick.c            |    39 +-
 Engine/lib/sdl/test/testkeys.c                |     2 +-
 Engine/lib/sdl/test/testloadso.c              |     4 +-
 Engine/lib/sdl/test/testlocale.c              |     2 +-
 Engine/lib/sdl/test/testlock.c                |     2 +-
 Engine/lib/sdl/test/testmessage.c             |    18 +-
 Engine/lib/sdl/test/testmouse.c               |   197 +
 Engine/lib/sdl/test/testmultiaudio.c          |    20 +-
 Engine/lib/sdl/test/testnative.c              |     4 +-
 Engine/lib/sdl/test/testnative.h              |     2 +-
 Engine/lib/sdl/test/testnativeos2.c           |    46 +-
 Engine/lib/sdl/test/testnativew32.c           |     2 +-
 Engine/lib/sdl/test/testnativex11.c           |     2 +-
 Engine/lib/sdl/test/testoffscreen.c           |     2 +-
 Engine/lib/sdl/test/testoverlay2.c            |     3 +-
 Engine/lib/sdl/test/testplatform.c            |    43 +-
 Engine/lib/sdl/test/testpower.c               |     6 +-
 Engine/lib/sdl/test/testqsort.c               |     6 +-
 Engine/lib/sdl/test/testrelative.c            |     8 +-
 Engine/lib/sdl/test/testrendercopyex.c        |     2 +-
 Engine/lib/sdl/test/testrendertarget.c        |     4 +-
 Engine/lib/sdl/test/testresample.c            |     2 +-
 Engine/lib/sdl/test/testrumble.c              |    10 +-
 Engine/lib/sdl/test/testscale.c               |     4 +-
 Engine/lib/sdl/test/testsem.c                 |   248 +-
 Engine/lib/sdl/test/testsensor.c              |     8 +-
 Engine/lib/sdl/test/testshader.c              |     2 +-
 Engine/lib/sdl/test/testshape.c               |     2 +-
 Engine/lib/sdl/test/testsprite2.c             |   221 +-
 Engine/lib/sdl/test/testspriteminimal.c       |    10 +-
 Engine/lib/sdl/test/teststreaming.c           |     6 +-
 Engine/lib/sdl/test/testsurround.c            |   200 +
 Engine/lib/sdl/test/testthread.c              |     2 +-
 Engine/lib/sdl/test/testtimer.c               |    24 +-
 Engine/lib/sdl/test/testurl.c                 |     2 +-
 Engine/lib/sdl/test/testver.c                 |    10 +-
 Engine/lib/sdl/test/testviewport.c            |     8 +-
 Engine/lib/sdl/test/testvulkan.c              |   848 +-
 Engine/lib/sdl/test/testwm2.c                 |   144 +-
 Engine/lib/sdl/test/testyuv.c                 |     2 +-
 Engine/lib/sdl/test/testyuv_cvt.c             |     8 +-
 Engine/lib/sdl/test/testyuv_cvt.h             |     2 +-
 Engine/lib/sdl/test/torturethread.c           |     2 +-
 .../lib/sdl/test/unifont-13.0.06-license.txt  |    90 +
 Engine/lib/sdl/test/unifont-13.0.06.hex       | 57086 ++++++++++++++++
 Engine/lib/sdl/visualtest/Makefile.in         |     7 +
 Engine/lib/sdl/visualtest/README.txt          |     2 +-
 Engine/lib/sdl/visualtest/acinclude.m4        |    84 +-
 Engine/lib/sdl/visualtest/autogen.sh          |    17 +-
 Engine/lib/sdl/visualtest/compile             |     1 -
 Engine/lib/sdl/visualtest/config.h            |    23 -
 Engine/lib/sdl/visualtest/config.h.in         |    22 -
 Engine/lib/sdl/visualtest/configure           |  1095 +-
 Engine/lib/sdl/visualtest/configure.ac        |    41 +
 Engine/lib/sdl/visualtest/configure.in        |   166 -
 Engine/lib/sdl/visualtest/depcomp             |     1 -
 .../SDL_visualtest_action_configparser.h      |     4 +-
 .../SDL_visualtest_exhaustive_variator.h      |     2 +-
 .../include/SDL_visualtest_parsehelper.h      |     2 +-
 .../include/SDL_visualtest_process.h          |     6 +-
 .../include/SDL_visualtest_random_variator.h  |     2 +-
 .../include/SDL_visualtest_rwhelper.h         |     2 +-
 .../include/SDL_visualtest_screenshot.h       |     2 +-
 .../include/SDL_visualtest_sut_configparser.h |     2 +-
 .../include/SDL_visualtest_variator_common.h  |     2 +-
 .../include/SDL_visualtest_variators.h        |     2 +-
 Engine/lib/sdl/visualtest/install-sh          |     1 -
 Engine/lib/sdl/visualtest/missing             |     1 -
 .../sdl/visualtest/src/action_configparser.c  |    19 +-
 .../sdl/visualtest/src/harness_argparser.c    |    10 +-
 .../sdl/visualtest/src/linux/linux_process.c  |    25 +-
 Engine/lib/sdl/visualtest/src/mischelper.c    |     4 +-
 Engine/lib/sdl/visualtest/src/parsehelper.c   |     8 +-
 Engine/lib/sdl/visualtest/src/rwhelper.c      |     4 +-
 Engine/lib/sdl/visualtest/src/screenshot.c    |     8 +-
 .../lib/sdl/visualtest/src/sut_configparser.c |     4 +-
 Engine/lib/sdl/visualtest/src/testharness.c   |    19 +-
 .../lib/sdl/visualtest/src/variator_common.c  |     6 +-
 .../sdl/visualtest/src/variator_exhaustive.c  |     5 +-
 .../lib/sdl/visualtest/src/variator_random.c  |     8 +-
 Engine/lib/sdl/visualtest/src/variators.c     |     6 +-
 .../visualtest/src/windows/windows_process.c  |    13 +-
 .../src/windows/windows_screenshot.c          |    12 +-
 Engine/lib/sdl/visualtest/stamp-h1            |     1 -
 Engine/lib/sdl/visualtest/unittest/testquit.c |     2 +-
 .../idle-inhibit-unstable-v1.xml              |    83 +
 ...keyboard-shortcuts-inhibit-unstable-v1.xml |   143 +
 ...org-kde-kwin-server-decoration-manager.xml |    94 -
 .../text-input-unstable-v3.xml                |   452 +
 Engine/lib/sdl/wayland-protocols/wayland.xml  |   212 +-
 .../wayland-protocols/xdg-activation-v1.xml   |   186 +
 .../xdg-shell-unstable-v6.xml                 |  1044 -
 .../lib/sdl/wayland-protocols/xdg-shell.xml   |   198 +-
 1225 files changed, 148950 insertions(+), 51674 deletions(-)
 rename Engine/lib/sdl/{.hgignore => .gitignore} (80%)
 delete mode 100644 Engine/lib/sdl/.hgtags
 rename Engine/lib/sdl/{COPYING.txt => LICENSE.txt} (90%)
 delete mode 100644 Engine/lib/sdl/Makefile.psp
 delete mode 100644 Engine/lib/sdl/Makefile.wiz
 rename Engine/lib/sdl/{README.txt => README.md} (71%)
 delete mode 100644 Engine/lib/sdl/VisualC-WinRT/SDL2-WinRT.nuspec
 delete mode 100644 Engine/lib/sdl/VisualC-WinRT/SDL2-WinRT.targets
 delete mode 100644 Engine/lib/sdl/VisualC-WinRT/SDL2main-WinRT-NonXAML.nuspec
 delete mode 100644 Engine/lib/sdl/VisualC-WinRT/SDL2main-WinRT-NonXAML.targets
 delete mode 100644 Engine/lib/sdl/VisualC-WinRT/tests/loopwave/Assets/Logo.png
 delete mode 100644 Engine/lib/sdl/VisualC-WinRT/tests/loopwave/Assets/SmallLogo.png
 delete mode 100644 Engine/lib/sdl/VisualC-WinRT/tests/loopwave/Assets/SplashScreen.png
 delete mode 100644 Engine/lib/sdl/VisualC-WinRT/tests/loopwave/Assets/StoreLogo.png
 delete mode 100644 Engine/lib/sdl/VisualC-WinRT/tests/loopwave/Package.appxmanifest
 delete mode 100644 Engine/lib/sdl/VisualC-WinRT/tests/loopwave/loopwave_VS2012_TemporaryKey.pfx
 delete mode 100644 Engine/lib/sdl/VisualC-WinRT/tests/testthread/Assets/Logo.png
 delete mode 100644 Engine/lib/sdl/VisualC-WinRT/tests/testthread/Assets/SmallLogo.png
 delete mode 100644 Engine/lib/sdl/VisualC-WinRT/tests/testthread/Assets/SplashScreen.png
 delete mode 100644 Engine/lib/sdl/VisualC-WinRT/tests/testthread/Assets/StoreLogo.png
 delete mode 100644 Engine/lib/sdl/VisualC-WinRT/tests/testthread/Package.appxmanifest
 delete mode 100644 Engine/lib/sdl/VisualC-WinRT/tests/testthread/testthread_VS2012_TemporaryKey.pfx
 delete mode 100644 Engine/lib/sdl/VisualC.html
 delete mode 100644 Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/Default-568h@2x.png
 delete mode 100644 Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/Default.png
 delete mode 100644 Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/Icon.png
 delete mode 100644 Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/Info.plist
 delete mode 100644 Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/___PROJECTNAME___.xcodeproj/TemplateIcon.icns
 delete mode 100644 Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/___PROJECTNAME___.xcodeproj/TemplateInfo.plist
 delete mode 100644 Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/___PROJECTNAME___.xcodeproj/project.pbxproj
 delete mode 100644 Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/main.c
 delete mode 100644 Engine/lib/sdl/Xcode/SDL/hidapi/Info.plist
 create mode 100644 Engine/lib/sdl/acinclude/pkg.m4
 delete mode 100644 Engine/lib/sdl/acinclude/pkg_config.m4
 rename Engine/lib/sdl/build-scripts/{g++-fat.sh => clang++-fat.sh} (52%)
 mode change 100755 => 100644
 rename Engine/lib/sdl/build-scripts/{gcc-fat.sh => clang-fat.sh} (53%)
 mode change 100755 => 100644
 create mode 100644 Engine/lib/sdl/build-scripts/codechecker-buildbot.sh
 delete mode 100644 Engine/lib/sdl/build-scripts/config.sub.patch
 create mode 100644 Engine/lib/sdl/build-scripts/fnsince.pl
 create mode 100644 Engine/lib/sdl/build-scripts/git-pre-push-hook.pl
 delete mode 100755 Engine/lib/sdl/build-scripts/iosbuild.sh
 create mode 100644 Engine/lib/sdl/build-scripts/wikiheaders.pl
 delete mode 100644 Engine/lib/sdl/debian/changelog
 delete mode 100644 Engine/lib/sdl/debian/compat
 delete mode 100644 Engine/lib/sdl/debian/control
 delete mode 100644 Engine/lib/sdl/debian/copyright
 delete mode 100644 Engine/lib/sdl/debian/docs
 delete mode 100644 Engine/lib/sdl/debian/libsdl2-dev.install
 delete mode 100644 Engine/lib/sdl/debian/libsdl2-dev.manpages
 delete mode 100644 Engine/lib/sdl/debian/libsdl2.install
 delete mode 100755 Engine/lib/sdl/debian/rules
 delete mode 100644 Engine/lib/sdl/debian/sdl2-config.1
 delete mode 100644 Engine/lib/sdl/debian/source/format
 delete mode 100644 Engine/lib/sdl/debian/watch
 create mode 100644 Engine/lib/sdl/docs/README-git.md
 create mode 100644 Engine/lib/sdl/docs/README-kmsbsd.md
 create mode 100644 Engine/lib/sdl/docs/README-macos.md
 delete mode 100644 Engine/lib/sdl/docs/README-macosx.md
 create mode 100644 Engine/lib/sdl/docs/README-riscos.md
 create mode 100644 Engine/lib/sdl/docs/README-visualc.md
 create mode 100644 Engine/lib/sdl/docs/README-vita.md
 create mode 100644 Engine/lib/sdl/include/SDL_config_emscripten.h
 delete mode 100644 Engine/lib/sdl/include/SDL_config_psp.h
 delete mode 100644 Engine/lib/sdl/include/SDL_config_wiz.h
 create mode 100644 Engine/lib/sdl/include/SDL_hidapi.h
 create mode 100644 Engine/lib/sdl/include/SDL_revision.h.cmake
 create mode 100644 Engine/lib/sdl/src/audio/aaudio/SDL_aaudio.c
 create mode 100644 Engine/lib/sdl/src/audio/aaudio/SDL_aaudio.h
 create mode 100644 Engine/lib/sdl/src/audio/aaudio/SDL_aaudiofuncs.h
 create mode 100644 Engine/lib/sdl/src/audio/pipewire/SDL_pipewire.c
 create mode 100644 Engine/lib/sdl/src/audio/pipewire/SDL_pipewire.h
 create mode 100644 Engine/lib/sdl/src/audio/vita/SDL_vitaaudio.c
 create mode 100644 Engine/lib/sdl/src/audio/vita/SDL_vitaaudio.h
 create mode 100644 Engine/lib/sdl/src/core/openbsd/SDL_wscons.h
 create mode 100644 Engine/lib/sdl/src/core/openbsd/SDL_wscons_kbd.c
 create mode 100644 Engine/lib/sdl/src/core/openbsd/SDL_wscons_mouse.c
 create mode 100644 Engine/lib/sdl/src/core/os2/iconv2.lbc
 rename Engine/lib/sdl/src/{video/x11 => events}/imKStoUCS.c (99%)
 rename Engine/lib/sdl/src/{video/x11 => events}/imKStoUCS.h (96%)
 create mode 100644 Engine/lib/sdl/src/filesystem/psp/SDL_sysfilesystem.c
 create mode 100644 Engine/lib/sdl/src/filesystem/riscos/SDL_sysfilesystem.c
 create mode 100644 Engine/lib/sdl/src/filesystem/vita/SDL_sysfilesystem.c
 create mode 100644 Engine/lib/sdl/src/hidapi/SDL_hidapi_c.h
 delete mode 100644 Engine/lib/sdl/src/hidapi/linux/hid.cpp
 create mode 100644 Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_luna.c
 create mode 100644 Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_stadia.c
 create mode 100644 Engine/lib/sdl/src/joystick/os2/SDL_os2joystick.c
 create mode 100644 Engine/lib/sdl/src/joystick/vita/SDL_sysjoystick.c
 delete mode 100644 Engine/lib/sdl/src/joystick/windows/SDL_mmjoystick.c
 create mode 100644 Engine/lib/sdl/src/misc/emscripten/SDL_sysurl.c
 create mode 100644 Engine/lib/sdl/src/misc/vita/SDL_sysurl.c
 create mode 100644 Engine/lib/sdl/src/power/vita/SDL_syspower.c
 create mode 100644 Engine/lib/sdl/src/render/software/SDL_triangle.c
 create mode 100644 Engine/lib/sdl/src/render/software/SDL_triangle.h
 create mode 100644 Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm.c
 create mode 100644 Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_memory.c
 create mode 100644 Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_memory.h
 create mode 100644 Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_shaders.h
 create mode 100644 Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_tools.c
 create mode 100644 Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_tools.h
 create mode 100644 Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_types.h
 create mode 100644 Engine/lib/sdl/src/render/vitagxm/shader_src/clear_f.cg
 create mode 100644 Engine/lib/sdl/src/render/vitagxm/shader_src/clear_v.cg
 create mode 100644 Engine/lib/sdl/src/render/vitagxm/shader_src/color_f.cg
 create mode 100644 Engine/lib/sdl/src/render/vitagxm/shader_src/color_v.cg
 create mode 100644 Engine/lib/sdl/src/render/vitagxm/shader_src/texture_f.cg
 create mode 100644 Engine/lib/sdl/src/render/vitagxm/shader_src/texture_v.cg
 create mode 100644 Engine/lib/sdl/src/sensor/vita/SDL_vitasensor.c
 create mode 100644 Engine/lib/sdl/src/sensor/vita/SDL_vitasensor.h
 create mode 100644 Engine/lib/sdl/src/thread/generic/SDL_syscond_c.h
 create mode 100644 Engine/lib/sdl/src/thread/vita/SDL_syscond.c
 create mode 100644 Engine/lib/sdl/src/thread/vita/SDL_sysmutex.c
 create mode 100644 Engine/lib/sdl/src/thread/vita/SDL_sysmutex_c.h
 create mode 100644 Engine/lib/sdl/src/thread/vita/SDL_syssem.c
 create mode 100644 Engine/lib/sdl/src/thread/vita/SDL_systhread.c
 create mode 100644 Engine/lib/sdl/src/thread/vita/SDL_systhread_c.h
 create mode 100644 Engine/lib/sdl/src/thread/windows/SDL_syscond_cv.c
 create mode 100644 Engine/lib/sdl/src/thread/windows/SDL_sysmutex_c.h
 create mode 100644 Engine/lib/sdl/src/timer/vita/SDL_systimer.c
 create mode 100644 Engine/lib/sdl/src/video/SDL_rect_impl.h
 delete mode 100644 Engine/lib/sdl/src/video/cocoa/SDL_cocoamousetap.m
 create mode 100644 Engine/lib/sdl/src/video/haiku/SDL_BApp.h
 delete mode 100644 Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_dyn.c
 delete mode 100644 Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_mouse.c
 delete mode 100644 Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_opengles.c
 delete mode 100644 Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_opengles.h
 delete mode 100644 Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_sym.h
 delete mode 100644 Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_video.c
 delete mode 100644 Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_video.h
 rename Engine/lib/sdl/src/video/os2/{my_gradd.h => SDL_gradd.h} (99%)
 rename Engine/lib/sdl/src/video/{kmsdrm_legacy/SDL_kmsdrm_legacy_dyn.h => riscos/SDL_riscosdefs.h} (55%)
 create mode 100644 Engine/lib/sdl/src/video/riscos/SDL_riscosevents.c
 rename Engine/lib/sdl/src/video/{cocoa/SDL_cocoamousetap.h => riscos/SDL_riscosevents_c.h} (70%)
 create mode 100644 Engine/lib/sdl/src/video/riscos/SDL_riscosframebuffer.c
 rename Engine/lib/sdl/src/video/{kmsdrm_legacy/SDL_kmsdrm_legacy_mouse.h => riscos/SDL_riscosframebuffer_c.h} (65%)
 create mode 100644 Engine/lib/sdl/src/video/riscos/SDL_riscosmessagebox.c
 rename Engine/lib/sdl/src/video/{kmsdrm_legacy/SDL_kmsdrm_legacy_events.h => riscos/SDL_riscosmessagebox.h} (76%)
 create mode 100644 Engine/lib/sdl/src/video/riscos/SDL_riscosmodes.c
 create mode 100644 Engine/lib/sdl/src/video/riscos/SDL_riscosmodes.h
 create mode 100644 Engine/lib/sdl/src/video/riscos/SDL_riscosvideo.c
 rename Engine/lib/sdl/src/video/{kmsdrm_legacy/SDL_kmsdrm_legacy_events.c => riscos/SDL_riscosvideo.h} (71%)
 create mode 100644 Engine/lib/sdl/src/video/riscos/SDL_riscoswindow.c
 create mode 100644 Engine/lib/sdl/src/video/riscos/SDL_riscoswindow.h
 create mode 100644 Engine/lib/sdl/src/video/riscos/scancodes_riscos.h
 create mode 100644 Engine/lib/sdl/src/video/vita/SDL_vitaframebuffer.c
 create mode 100644 Engine/lib/sdl/src/video/vita/SDL_vitaframebuffer.h
 create mode 100644 Engine/lib/sdl/src/video/vita/SDL_vitagl.c
 create mode 100644 Engine/lib/sdl/src/video/vita/SDL_vitagl_c.h
 create mode 100644 Engine/lib/sdl/src/video/vita/SDL_vitagl_pvr.c
 create mode 100644 Engine/lib/sdl/src/video/vita/SDL_vitagl_pvr_c.h
 create mode 100644 Engine/lib/sdl/src/video/vita/SDL_vitakeyboard.c
 create mode 100644 Engine/lib/sdl/src/video/vita/SDL_vitakeyboard.h
 create mode 100644 Engine/lib/sdl/src/video/vita/SDL_vitamessagebox.c
 create mode 100644 Engine/lib/sdl/src/video/vita/SDL_vitamessagebox.h
 create mode 100644 Engine/lib/sdl/src/video/vita/SDL_vitamouse.c
 create mode 100644 Engine/lib/sdl/src/video/vita/SDL_vitamouse_c.h
 create mode 100644 Engine/lib/sdl/src/video/vita/SDL_vitatouch.c
 create mode 100644 Engine/lib/sdl/src/video/vita/SDL_vitatouch.h
 create mode 100644 Engine/lib/sdl/src/video/vita/SDL_vitavideo.c
 create mode 100644 Engine/lib/sdl/src/video/vita/SDL_vitavideo.h
 create mode 100644 Engine/lib/sdl/src/video/wayland/SDL_waylandkeyboard.c
 create mode 100644 Engine/lib/sdl/src/video/wayland/SDL_waylandkeyboard.h
 create mode 100644 Engine/lib/sdl/src/video/wayland/SDL_waylandmessagebox.c
 create mode 100644 Engine/lib/sdl/src/video/wayland/SDL_waylandmessagebox.h
 create mode 100644 Engine/lib/sdl/src/video/x11/SDL_x11xfixes.c
 create mode 100644 Engine/lib/sdl/src/video/x11/SDL_x11xfixes.h
 create mode 100644 Engine/lib/sdl/test/checkkeysthreads.c
 create mode 100644 Engine/lib/sdl/test/testgeometry.c
 create mode 100644 Engine/lib/sdl/test/testgles2_sdf.c
 create mode 100644 Engine/lib/sdl/test/testgles2_sdf_img_normal.bmp
 create mode 100644 Engine/lib/sdl/test/testgles2_sdf_img_sdf.bmp
 create mode 100644 Engine/lib/sdl/test/testmouse.c
 create mode 100644 Engine/lib/sdl/test/testsurround.c
 create mode 100644 Engine/lib/sdl/test/unifont-13.0.06-license.txt
 create mode 100644 Engine/lib/sdl/test/unifont-13.0.06.hex
 delete mode 100644 Engine/lib/sdl/visualtest/compile
 delete mode 100644 Engine/lib/sdl/visualtest/config.h
 delete mode 100644 Engine/lib/sdl/visualtest/config.h.in
 create mode 100644 Engine/lib/sdl/visualtest/configure.ac
 delete mode 100644 Engine/lib/sdl/visualtest/configure.in
 delete mode 100644 Engine/lib/sdl/visualtest/depcomp
 delete mode 100644 Engine/lib/sdl/visualtest/install-sh
 delete mode 100644 Engine/lib/sdl/visualtest/missing
 delete mode 100644 Engine/lib/sdl/visualtest/stamp-h1
 create mode 100644 Engine/lib/sdl/wayland-protocols/idle-inhibit-unstable-v1.xml
 create mode 100644 Engine/lib/sdl/wayland-protocols/keyboard-shortcuts-inhibit-unstable-v1.xml
 delete mode 100644 Engine/lib/sdl/wayland-protocols/org-kde-kwin-server-decoration-manager.xml
 create mode 100644 Engine/lib/sdl/wayland-protocols/text-input-unstable-v3.xml
 create mode 100644 Engine/lib/sdl/wayland-protocols/xdg-activation-v1.xml
 delete mode 100644 Engine/lib/sdl/wayland-protocols/xdg-shell-unstable-v6.xml

diff --git a/Engine/lib/sdl/.hgignore b/Engine/lib/sdl/.gitignore
similarity index 80%
rename from Engine/lib/sdl/.hgignore
rename to Engine/lib/sdl/.gitignore
index 3e3f68fd6..fd27cb76a 100644
--- a/Engine/lib/sdl/.hgignore
+++ b/Engine/lib/sdl/.gitignore
@@ -1,4 +1,3 @@
-syntax:glob
 aclocal.m4
 autom4te*
 config.cache
@@ -9,11 +8,35 @@ Makefile
 Makefile.rules
 sdl2-config
 sdl2-config.cmake
+sdl2-config-version.cmake
 sdl2.pc
 SDL2.spec
 build
 gen
 Build
+buildbot
+
+*.so
+*.so.*
+*.dll
+*.exe
+*.o
+*.obj
+*.lib
+*.a
+*.la
+*.dSYM
+*,e1f
+*,ff8
+*.lnk
+*.err
+*.exp
+*.map
+*.orig
+*~
+*.swp
+*.tmp
+*.rej
 
 # for CMake
 CMakeFiles/
@@ -21,10 +44,6 @@ CMakeCache.txt
 cmake_install.cmake
 cmake_uninstall.cmake
 SDL2ConfigVersion.cmake
-*.a
-*.la
-*.so
-*.so.*
 .ninja_*
 *.ninja
 
@@ -33,12 +52,6 @@ SDL2ConfigVersion.cmake
 cmake-build-*
 
 # for Xcode
-*.orig
-*.swp
-*.tmp
-*.rej
-*~
-*.o
 *.mode1*
 *.perspective*
 *.pbxuser
@@ -48,24 +61,31 @@ xcuserdata
 *.xcworkspace
 
 # for Visual C++
+.vs
 Debug
 Release
 *.user
 *.ncb
 *.suo
 *.sdf
+VisualC/tests/controllermap/axis.bmp
+VisualC/tests/controllermap/button.bmp
+VisualC/tests/controllermap/controllermap.bmp
+VisualC/tests/controllermap/controllermap_back.bmp
 VisualC/tests/loopwave/sample.wav
 VisualC/tests/testautomation/CompareSurfaces0001_Reference.bmp
 VisualC/tests/testautomation/CompareSurfaces0001_TestOutput.bmp
 VisualC/tests/testgamecontroller/axis.bmp
 VisualC/tests/testgamecontroller/button.bmp
 VisualC/tests/testgamecontroller/controllermap.bmp
+VisualC/tests/testgamecontroller/controllermap_back.bmp
 VisualC/tests/testoverlay2/moose.dat
 VisualC/tests/testrendertarget/icon.bmp
 VisualC/tests/testrendertarget/sample.bmp
 VisualC/tests/testscale/icon.bmp
 VisualC/tests/testscale/sample.bmp
 VisualC/tests/testsprite2/icon.bmp
+VisualC/tests/testyuv/testyuv.bmp
 VisualC/visualtest/icon.bmp
 VisualC/visualtest/testquit.actions
 VisualC/visualtest/testquit.config
@@ -79,14 +99,8 @@ VisualC/visualtest/testsprite2_sample.parameters
 # for Android
 android-project/local.properties
 
-test/aclocal.m4
-test/autom4te*
-test/config.cache
-test/config.log
-test/config.status
-test/Makefile
-test/SDL2.dll
 test/checkkeys
+test/checkkeysthreads
 test/controllermap
 test/loopwave
 test/loopwavequeue
@@ -102,9 +116,11 @@ test/testdraw2
 test/testdrawchessboard
 test/testdropfile
 test/testerror
+test/testevdev
 test/testfile
 test/testfilesystem
 test/testgamecontroller
+test/testgeometry
 test/testgesture
 test/testgl2
 test/testgles
@@ -118,8 +134,10 @@ test/testintersections
 test/testjoystick
 test/testkeys
 test/testloadso
+test/testlocale
 test/testlock
 test/testmessage
+test/testmouse
 test/testmultiaudio
 test/testnative
 test/testoverlay2
@@ -139,17 +157,22 @@ test/testshape
 test/testsprite2
 test/testspriteminimal
 test/teststreaming
+test/testsurround
 test/testthread
 test/testtimer
+test/testurl
 test/testver
 test/testviewport
 test/testvulkan
 test/testwm2
 test/testyuv
 test/torturethread
-test/*.exe
-test/*,e1f
-test/*,ff8
-test/*.dSYM
-buildbot
-test/buildbot
+
+builddir/
+debian/*.debhelper.log
+debian/*.substvars
+debian/*.tar.gz
+debian/.debhelper/
+debian/files
+debian/libsdl*/
+debian/tmp/
diff --git a/Engine/lib/sdl/.hgtags b/Engine/lib/sdl/.hgtags
deleted file mode 100644
index 1d0b38c22..000000000
--- a/Engine/lib/sdl/.hgtags
+++ /dev/null
@@ -1,40 +0,0 @@
-0afe0e38e02cf2048e93582f01c52fbb91d3c7bb release-1.2.7
-230b156829ed13b31134d96f689c917981f57b84 release-1.2.5
-27cab50ec9c746e886ce0f3fdaa0b0cdc55a594f release-1.2.11
-2fe3fbd2bff50165b3cad33bf40d70b3bb3c9fd0 release-1.2.3
-3c052d3bcc76c899dfd4846be76243a78e8c7180 release-1.2.4
-3c5eed71a3320962551af3b3dfbee0c99fcf0086 release-1.2.10
-4867f7f7dd3426d1dbbeef48b3f3b3aa19590cc4 release-1.2.12
-6e28dae59e3baf4447c83e833a8d2ac912536f5b release-1.2.1
-7c2589fb8d4df54c6faabd3faebd0c0e73f67879 release-1.2.13
-86de11faf082881ad9b73a1a1d78733ca07f8db8 release-1.2.6
-bb051fa871aa0b53ea57df56a446cec3bb85924c release-1.2.2
-cfcb2e1c36ebe9809577adf768b0ec53e8768af9 release-1.2.8
-e044e7c70a50a2f54d14ee20d0933e904e5853b6 release-1.2.9
-f14cf9d71233934811774f941d0de121d5f96ccf release-1.2.14
-39c22a953456f6c9e2c8993c8ff973824104102a pre-touch-removal
-ccf5fbfa2afabab429ad911308f362201a94d810 macosx_10_4_supported
-d6a8fa507a45d9de7258e51585eab3e45c415149 release-2.0.0
-a8bd63b33636715f2cf6e7d36ab7201acbd478fe release-2.0.1
-a8bd63b33636715f2cf6e7d36ab7201acbd478fe release-2.0.1
-715a01415ac9305b9f8ec72b99fcf8cc9dd64dde release-2.0.1
-715a01415ac9305b9f8ec72b99fcf8cc9dd64dde release-2.0.1
-9ec71e56071cc80eda6691a3f8719ed5395dfcfb release-2.0.1
-9ec71e56071cc80eda6691a3f8719ed5395dfcfb release-2.0.1
-0000000000000000000000000000000000000000 release-2.0.1
-0000000000000000000000000000000000000000 release-2.0.1
-b9663c77f5c95ebf05f3c18e80619caae8ae1460 release-2.0.1
-be2102f000d0d2d9bab75e9703a1d503d0f6bb33 release-2.0.2
-f285b9487756ff681f76c85644222c03a7bfa1c7 release-2.0.3
-f285b9487756ff681f76c85644222c03a7bfa1c7 release-2.0.3
-704a0bfecf754e4e1383f83c7d5118b00cae26ea release-2.0.3
-e12c387305129c847b3928a123300b113782fe3f release-2.0.4
-007dfe83abf81b1ff5df40186f65e8e64987b825 release-2.0.5
-8df7a59b55283aa09889522369a2b32674c048de release-2.0.6
-2088cd828335797d73d151e3288d899f77204862 release-2.0.7
-f1084c419f33610cf274e309a8b2798d2ae665c7 release-2.0.8
-8feb5da6f2fb75703bde2c06813375af984a57f0 release-2.0.9
-bc90ce38f1e27ace54b83bebf987993002504f7f release-2.0.10
-78d0bb6f3b8f9b8f2a76cb357a407bc7ace57234 release-2.0.12
-78d0bb6f3b8f9b8f2a76cb357a407bc7ace57234 release-2.0.12
-355a4f94a782747a990b2fedaebc7bebd280e153 release-2.0.12
diff --git a/Engine/lib/sdl/Android.mk b/Engine/lib/sdl/Android.mk
index 0d2916766..4308d40f9 100755
--- a/Engine/lib/sdl/Android.mk
+++ b/Engine/lib/sdl/Android.mk
@@ -20,6 +20,7 @@ LOCAL_SRC_FILES := \
 	$(wildcard $(LOCAL_PATH)/src/audio/*.c) \
 	$(wildcard $(LOCAL_PATH)/src/audio/android/*.c) \
 	$(wildcard $(LOCAL_PATH)/src/audio/dummy/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/audio/aaudio/*.c) \
 	$(wildcard $(LOCAL_PATH)/src/audio/openslES/*.c) \
 	$(LOCAL_PATH)/src/atomic/SDL_atomic.c.arm \
 	$(LOCAL_PATH)/src/atomic/SDL_spinlock.c.arm \
@@ -30,6 +31,8 @@ LOCAL_SRC_FILES := \
 	$(wildcard $(LOCAL_PATH)/src/file/*.c) \
 	$(wildcard $(LOCAL_PATH)/src/haptic/*.c) \
 	$(wildcard $(LOCAL_PATH)/src/haptic/android/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/hidapi/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/hidapi/android/*.cpp) \
 	$(wildcard $(LOCAL_PATH)/src/joystick/*.c) \
 	$(wildcard $(LOCAL_PATH)/src/joystick/android/*.c) \
 	$(wildcard $(LOCAL_PATH)/src/joystick/hidapi/*.c) \
@@ -56,8 +59,6 @@ LOCAL_SRC_FILES := \
 	$(wildcard $(LOCAL_PATH)/src/video/yuv2rgb/*.c) \
 	$(wildcard $(LOCAL_PATH)/src/test/*.c))
 
-LOCAL_SHARED_LIBRARIES := hidapi
-
 LOCAL_CFLAGS += -DGL_GLEXT_PROTOTYPES
 LOCAL_CFLAGS += \
 	-Wall -Wextra \
@@ -77,7 +78,6 @@ LOCAL_CFLAGS += \
 
 # Warnings we haven't fixed (yet)
 LOCAL_CFLAGS += -Wno-unused-parameter -Wno-sign-compare
- 
 
 LOCAL_LDLIBS := -ldl -lGLESv1_CM -lGLESv2 -lOpenSLES -llog -landroid
 
@@ -120,22 +120,4 @@ LOCAL_MODULE_FILENAME := libSDL2main
 
 include $(BUILD_STATIC_LIBRARY)
 
-###########################
-#
-# hidapi library
-#
-###########################
-
-include $(CLEAR_VARS)
-
-LOCAL_CPPFLAGS += -std=c++11
-
-LOCAL_SRC_FILES := src/hidapi/android/hid.cpp
-
-LOCAL_MODULE := libhidapi
-LOCAL_LDLIBS := -llog
-
-include $(BUILD_SHARED_LIBRARY)
-
 $(call import-module,android/cpufeatures)
-
diff --git a/Engine/lib/sdl/BUGS.txt b/Engine/lib/sdl/BUGS.txt
index a8e6b952e..b1463e777 100644
--- a/Engine/lib/sdl/BUGS.txt
+++ b/Engine/lib/sdl/BUGS.txt
@@ -1,7 +1,7 @@
 
-Bugs are now managed in the SDL bug tracker, here:
+Bugs are now managed in the SDL issue tracker, here:
 
-    https://bugzilla.libsdl.org/
+    https://github.com/libsdl-org/SDL/issues
 
 You may report bugs there, and search to see if a given issue has already
  been reported, discussed, and maybe even fixed.
@@ -11,6 +11,6 @@ You may also find help at the SDL forums/mailing list:
 
     https://discourse.libsdl.org/
 
-Bug reports are welcome here, but we really appreciate if you use Bugzilla, as
- bugs discussed on the mailing list may be forgotten or missed.
+Bug reports are welcome here, but we really appreciate if you use the issue
+ tracker, as bugs discussed on the mailing list may be forgotten or missed.
 
diff --git a/Engine/lib/sdl/CMakeLists.txt b/Engine/lib/sdl/CMakeLists.txt
index b9b9eb620..59bacf0f5 100644
--- a/Engine/lib/sdl/CMakeLists.txt
+++ b/Engine/lib/sdl/CMakeLists.txt
@@ -1,22 +1,34 @@
-if(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_BINARY_DIR})
-  message(FATAL_ERROR "Prevented in-tree built. Please create a build directory outside of the SDL source code and call cmake from there")
+if(${CMAKE_CURRENT_SOURCE_DIR} STREQUAL ${CMAKE_CURRENT_BINARY_DIR})
+  message(FATAL_ERROR "Prevented in-tree build. Please create a build directory outside of the SDL source code and run \"cmake -S ${CMAKE_SOURCE_DIR} -B .\" from there")
 endif()
 
 cmake_minimum_required(VERSION 3.0.0)
 project(SDL2 C CXX)
 
-if(WINDOWS_STORE)
-  enable_language(CXX)
-  cmake_minimum_required(VERSION 3.11)
-  add_definitions(-DSDL_BUILDING_WINRT=1 -ZW)
-  link_libraries(
-    -nodefaultlib:vccorlib$<$<CONFIG:Debug>:d>
-    -nodefaultlib:msvcrt$<$<CONFIG:Debug>:d>
-    vccorlib$<$<CONFIG:Debug>:d>.lib
-    msvcrt$<$<CONFIG:Debug>:d>.lib
-  )
+if (HAIKU)
+  set(LINKER_LANGUAGE CXX)
 endif()
 
+# This is a virtual "library" that just exists to collect up compiler and
+#  linker options that used to be global to this CMake project. When you
+#  specify it as part of a real library's target_link_libraries(), that
+#  library will also gain all those build options too. This is meant to
+#  modularize old calls to the global add_definitions and include_directories,
+#  etc. See https://github.com/libsdl-org/SDL/issues/4150
+add_library(sdl-build-options INTERFACE)
+
+if(WINDOWS_STORE)
+  cmake_minimum_required(VERSION 3.11.0)
+  target_compile_definitions(sdl-build-options INTERFACE "-DSDL_BUILDING_WINRT=1")
+  target_compile_options(sdl-build-options INTERFACE "-ZW")
+endif()
+
+# Build in parallel under Visual Studio. Not enabled by default.
+if(MSVC)
+  target_compile_options(sdl-build-options INTERFACE "/MP")
+endif(MSVC)
+
+
 # !!! FIXME: this should probably do "MACOSX_RPATH ON" as a target property
 # !!! FIXME:  for the SDL2 shared library (so you get an
 # !!! FIXME:  install_name ("soname") of "@rpath/libSDL-whatever.dylib"
@@ -34,6 +46,7 @@ include(CheckSymbolExists)
 include(CheckCSourceCompiles)
 include(CheckCSourceRuns)
 include(CheckCCompilerFlag)
+include(CheckCXXCompilerFlag)
 include(CheckTypeSize)
 include(CheckStructHasMember)
 include(CMakeDependentOption)
@@ -53,12 +66,12 @@ include(${SDL2_SOURCE_DIR}/cmake/sdlchecks.cmake)
 # set SDL_BINARY_AGE and SDL_INTERFACE_AGE to 0.
 set(SDL_MAJOR_VERSION 2)
 set(SDL_MINOR_VERSION 0)
-set(SDL_MICRO_VERSION 14)
-set(SDL_INTERFACE_AGE 0)
-set(SDL_BINARY_AGE 14)
+set(SDL_MICRO_VERSION 21)
+set(SDL_INTERFACE_AGE 3)
+set(SDL_BINARY_AGE 21)
 set(SDL_VERSION "${SDL_MAJOR_VERSION}.${SDL_MINOR_VERSION}.${SDL_MICRO_VERSION}")
 # the following should match the versions in Xcode project file:
-set(DYLIB_CURRENT_VERSION 15.0.0)
+set(DYLIB_CURRENT_VERSION 19.3.0)
 set(DYLIB_COMPATIBILITY_VERSION 1.0.0)
 
 # Set defaults preventing destination file conflicts
@@ -131,8 +144,12 @@ elseif(APPLE)
     set(MACOSX TRUE)
   elseif(CMAKE_SYSTEM_NAME MATCHES ".*tvOS.*")
     set(TVOS TRUE)
+  elseif(CMAKE_SYSTEM_NAME MATCHES ".*iOS.*")
+    # !!! FIXME: remove the version check when we start requiring >= 3.14.0
+    if(CMAKE_VERSION VERSION_LESS 3.14)
+      set(IOS TRUE)
+    endif()
   endif()
-  # TODO: iOS?
 elseif(CMAKE_SYSTEM_NAME MATCHES "BeOS.*")
   message_error("BeOS support has been removed as of SDL 2.0.2.")
 elseif(CMAKE_SYSTEM_NAME MATCHES "Haiku.*")
@@ -152,22 +169,19 @@ else()
   set(UNIX_OR_MAC_SYS OFF)
 endif()
 
-if (UNIX_OR_MAC_SYS AND NOT EMSCRIPTEN) # JavaScript does not yet have threading support, so disable pthreads when building for Emscripten.
+# Emscripten pthreads work, but you need to have a non-pthread fallback build
+#  for systems without support. It's not currently enough to not use
+#  pthread functions in a pthread-build; it won't start up on unsupported
+#  browsers. As such, you have to explicitly enable it on Emscripten builds
+#  for the time being. This default with change to ON once this becomes
+#  commonly supported in browsers or the Emscripten teams makes a single
+#  binary work everywhere.
+if (UNIX_OR_MAC_SYS AND NOT EMSCRIPTEN)
   set(SDL_PTHREADS_ENABLED_BY_DEFAULT ON)
 else()
   set(SDL_PTHREADS_ENABLED_BY_DEFAULT OFF)
 endif()
 
-# Default option knobs
-if(APPLE OR ARCH_64)
-  if(NOT "${CMAKE_OSX_ARCHITECTURES}" MATCHES "arm")
-    set(OPT_DEF_SSEMATH ON)
-  endif()
-endif()
-if(UNIX OR MINGW OR MSYS)
-  set(OPT_DEF_LIBC ON)
-endif()
-
 # The hidraw support doesn't catch Xbox, PS4 and Nintendo controllers,
 #  so we'll just use libusb when it's available. libusb does not support iOS,
 #  so we default to yes on iOS.
@@ -177,9 +191,6 @@ if((WINDOWS AND NOT WINDOWS_STORE) OR IOS OR TVOS OR ANDROID)
 else()
   set(HIDAPI_SKIP_LIBUSB FALSE)
 endif()
-if (HIDAPI_SKIP_LIBUSB)
-  set(OPT_DEF_HIDAPI ON)
-endif()
 
 # On the other hand, *BSD specifically uses libusb only, so we make a special
 #  case just for them.
@@ -190,12 +201,17 @@ else()
 endif()
 
 # Compiler info
-if(CMAKE_COMPILER_IS_GNUCC)
-  set(USE_GCC TRUE)
-  set(OPT_DEF_ASM TRUE)
-elseif(CMAKE_C_COMPILER_ID MATCHES "Clang")
+if(CMAKE_C_COMPILER_ID MATCHES "Clang")
   set(USE_CLANG TRUE)
   set(OPT_DEF_ASM TRUE)
+  # Visual Studio 2019 v16.2 added support for Clang/LLVM.
+  # Check if a Visual Studio project is being generated with the Clang toolset.
+  if(MSVC)
+    set(MSVC_CLANG TRUE)
+  endif()
+elseif(CMAKE_COMPILER_IS_GNUCC)
+  set(USE_GCC TRUE)
+  set(OPT_DEF_ASM TRUE)
 elseif(MSVC_VERSION GREATER 1400) # VisualStudio 8.0+
   set(OPT_DEF_ASM TRUE)
   #set(CMAKE_C_FLAGS "/ZI /WX- /
@@ -207,24 +223,27 @@ if(USE_GCC OR USE_CLANG)
   set(OPT_DEF_GCC_ATOMICS ON)
 endif()
 
-# Default flags, if not set otherwise
-if("$ENV{CFLAGS}" STREQUAL "")
-  if(CMAKE_BUILD_TYPE STREQUAL "")
-    if(USE_GCC OR USE_CLANG)
-      set(CMAKE_C_FLAGS "-g -O3")
-    endif()
+# Default option knobs
+if(APPLE OR ARCH_64 OR MSVC_CLANG)
+  if(NOT "${CMAKE_OSX_ARCHITECTURES}" MATCHES "arm")
+    set(OPT_DEF_SSEMATH ON)
   endif()
-else()
-  set(CMAKE_C_FLAGS "$ENV{CFLAGS}")
-  list(APPEND EXTRA_CFLAGS "$ENV{CFLAGS}")
 endif()
-if(NOT ("$ENV{CFLAGS}" STREQUAL "")) # Hackish, but does the trick on Win32
-  list(APPEND EXTRA_LDFLAGS "$ENV{LDFLAGS}")
+if(UNIX OR MINGW OR MSYS OR (USE_CLANG AND NOT WINDOWS) OR VITA OR PSP)
+  set(OPT_DEF_LIBC ON)
+endif()
+
+if(NOT ("$ENV{CFLAGS}" STREQUAL ""))
+  if(CMAKE_VERSION VERSION_LESS 3.11.0)
+     message(WARNING "SDL's CMakeLists.txt no longer checks the CFLAGS environment.")
+     message(WARNING "Please use CMake's CMAKE_C_FLAGS and CMAKE_BUILD_TYPE variables directly.")
+     message(WARNING "Or upgrade to CMake >= 3.11.0, which respects the CFLAGS environment var.")
+  endif()
 endif()
 
 if(MSVC)
-  option(FORCE_STATIC_VCRT "Force /MT for static VC runtimes" OFF)
-  if(FORCE_STATIC_VCRT)
+  option(SDL_FORCE_STATIC_VCRT "Force /MT for static VC runtimes" OFF)
+  if(SDL_FORCE_STATIC_VCRT)
     foreach(flag_var
         CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
         CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO)
@@ -234,12 +253,23 @@ if(MSVC)
     endforeach()
   endif()
 
-  # Make sure /RTC1 is disabled, otherwise it will use functions from the CRT
-  foreach(flag_var
-      CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
-      CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO)
-    string(REGEX REPLACE "/RTC(su|[1su])" "" ${flag_var} "${${flag_var}}")
-  endforeach(flag_var)
+  if(NOT SDL_LIBC)
+    # Make sure /RTC1 is disabled, otherwise it will use functions from the CRT
+    foreach(flag_var
+        CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
+        CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO)
+      string(REGEX REPLACE "/RTC(su|[1su])" "" ${flag_var} "${${flag_var}}")
+    endforeach(flag_var)
+  endif()
+
+  if(MSVC_CLANG)
+    # clang-cl treats /W4 as '-Wall -Wextra' -- we don't need -Wextra
+    foreach(flag_var
+        CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
+        CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO)
+      string(REGEX REPLACE "/W4" "/W3" ${flag_var} "${${flag_var}}")
+    endforeach(flag_var)
+  endif()
 endif()
 
 # Those are used for pkg-config and friends, so that the SDL2.pc, sdl2-config,
@@ -261,9 +291,9 @@ set(ORIG_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
 
 if(CYGWIN)
   # We build SDL on cygwin without the UNIX emulation layer
-  include_directories("-I/usr/include/mingw")
+  target_include_directories(sdl-build-options INTERFACE "/usr/include/mingw")
   set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -mno-cygwin")
-  check_c_source_compiles("int main(int argc, char **argv) {}"
+  check_c_source_compiles("int main(int argc, char **argv) { return 0; }"
     HAVE_GCC_NO_CYGWIN)
   set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS})
   if(HAVE_GCC_NO_CYGWIN)
@@ -273,13 +303,16 @@ if(CYGWIN)
   set(SDL_CFLAGS "${SDL_CFLAGS} -I/usr/include/mingw")
 endif()
 
-add_definitions(-DUSING_GENERATED_CONFIG_H)
 # General includes
-include_directories(${SDL2_BINARY_DIR}/include ${SDL2_SOURCE_DIR}/include)
-if(USE_GCC OR USE_CLANG)
+target_compile_definitions(sdl-build-options INTERFACE "-DUSING_GENERATED_CONFIG_H")
+target_include_directories(sdl-build-options BEFORE INTERFACE "${SDL2_BINARY_DIR}/include")
+target_include_directories(sdl-build-options INTERFACE "${SDL2_SOURCE_DIR}/include")
+# Note: The clang toolset for Visual Studio does not support the '-idirafter' option.
+if(USE_GCC OR (USE_CLANG AND NOT MSVC_CLANG))
+  # !!! FIXME: do we _need_ to mess with CMAKE_C_FLAGS here?
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -idirafter \"${SDL2_SOURCE_DIR}/src/video/khronos\"")
 else()
-  include_directories(${SDL2_SOURCE_DIR}/src/video/khronos)
+  target_include_directories(sdl-build-options INTERFACE "${SDL2_SOURCE_DIR}/src/video/khronos")
 endif()
 
 # All these ENABLED_BY_DEFAULT vars will default to ON if not specified, so
@@ -288,14 +321,21 @@ set(OPT_DEF_ASM TRUE)
 if(EMSCRIPTEN)
   # Set up default values for the currently supported set of subsystems:
   # Emscripten/Javascript does not have assembly support, a dynamic library
-  # loading architecture, low-level CPU inspection or multithreading.
+  # loading architecture, or low-level CPU inspection.
+
+  # SDL_THREADS_ENABLED_BY_DEFAULT now defaults to ON, but pthread support might be disabled by default.
+  # !!! FIXME: most of these subsystems should default to ON if there are dummy implementations to be used.
+
   set(OPT_DEF_ASM FALSE)
   set(SDL_SHARED_ENABLED_BY_DEFAULT OFF)
   set(SDL_ATOMIC_ENABLED_BY_DEFAULT OFF)
-  set(SDL_THREADS_ENABLED_BY_DEFAULT OFF)
   set(SDL_LOADSO_ENABLED_BY_DEFAULT OFF)
   set(SDL_CPUINFO_ENABLED_BY_DEFAULT OFF)
-  set(SDL_DLOPEN_ENABLED_BY_DEFAULT OFF)
+endif()
+
+if(VITA OR PSP)
+  set(SDL_SHARED_ENABLED_BY_DEFAULT OFF)
+  set(SDL_LOADSO_ENABLED_BY_DEFAULT OFF)
 endif()
 
 # When defined, respect CMake's BUILD_SHARED_LIBS setting:
@@ -317,9 +357,11 @@ if (NOT DEFINED SDL_SHARED_ENABLED_BY_DEFAULT)
   endif()
 endif()
 
+set(LONGESTOPTIONNAME 0)  # set_option and friends will change this.
+
 set(SDL_SUBSYSTEMS
-    Atomic Audio Video Render Events Joystick Haptic Power Threads Timers
-    File Loadso CPUinfo Filesystem Dlopen Sensor Locale)
+    Atomic Audio Video Render Events Joystick Haptic Hidapi Power Threads Timers
+    File Loadso CPUinfo Filesystem Sensor Locale Misc)
 foreach(_SUB ${SDL_SUBSYSTEMS})
   string(TOUPPER ${_SUB} _OPT)
   if (NOT DEFINED SDL_${_OPT}_ENABLED_BY_DEFAULT)
@@ -328,77 +370,86 @@ foreach(_SUB ${SDL_SUBSYSTEMS})
   option(SDL_${_OPT} "Enable the ${_SUB} subsystem" ${SDL_${_OPT}_ENABLED_BY_DEFAULT})
 endforeach()
 
-option_string(ASSERTIONS "Enable internal sanity checks (auto/disabled/release/enabled/paranoid)" "auto")
-#set_option(DEPENDENCY_TRACKING "Use gcc -MMD -MT dependency tracking" ON)
-set_option(LIBC                "Use the system C library" ${OPT_DEF_LIBC})
-set_option(GCC_ATOMICS         "Use gcc builtin atomics" ${OPT_DEF_GCC_ATOMICS})
-set_option(ASSEMBLY            "Enable assembly routines" ${OPT_DEF_ASM})
-set_option(SSEMATH             "Allow GCC to use SSE floating point math" ${OPT_DEF_SSEMATH})
-set_option(MMX                 "Use MMX assembly routines" ${OPT_DEF_ASM})
-set_option(3DNOW               "Use 3Dnow! MMX assembly routines" ${OPT_DEF_ASM})
-set_option(SSE                 "Use SSE assembly routines" ${OPT_DEF_ASM})
-set_option(SSE2                "Use SSE2 assembly routines" ${OPT_DEF_SSEMATH})
-set_option(SSE3                "Use SSE3 assembly routines" ${OPT_DEF_SSEMATH})
-set_option(ALTIVEC             "Use Altivec assembly routines" ${OPT_DEF_ASM})
-set_option(ARMSIMD             "use SIMD assembly blitters on ARM" OFF)
-set_option(ARMNEON             "use NEON assembly blitters on ARM" OFF)
-set_option(DISKAUDIO           "Support the disk writer audio driver" ON)
-set_option(DUMMYAUDIO          "Support the dummy audio driver" ON)
-set_option(VIDEO_DIRECTFB      "Use DirectFB video driver" OFF)
-dep_option(DIRECTFB_SHARED     "Dynamically load directfb support" ON "VIDEO_DIRECTFB" OFF)
-set_option(VIDEO_DUMMY         "Use dummy video driver" ON)
-set_option(VIDEO_OPENGL        "Include OpenGL support" ON)
-set_option(VIDEO_OPENGLES      "Include OpenGL ES support" ON)
-set_option(PTHREADS            "Use POSIX threads for multi-threading" ${SDL_PTHREADS_ENABLED_BY_DEFAULT})
-dep_option(PTHREADS_SEM        "Use pthread semaphores" ON "PTHREADS" OFF)
-set_option(SDL_DLOPEN          "Use dlopen for shared object loading" ${SDL_DLOPEN_ENABLED_BY_DEFAULT})
-dep_option(OSS                 "Support the OSS audio API" ON "UNIX_SYS OR RISCOS" OFF)
-set_option(ALSA                "Support the ALSA audio API" ${UNIX_SYS})
-dep_option(ALSA_SHARED         "Dynamically load ALSA audio support" ON "ALSA" OFF)
-set_option(JACK                "Support the JACK audio API" ${UNIX_SYS})
-dep_option(JACK_SHARED         "Dynamically load JACK audio support" ON "JACK" OFF)
-set_option(ESD                 "Support the Enlightened Sound Daemon" ${UNIX_SYS})
-dep_option(ESD_SHARED          "Dynamically load ESD audio support" ON "ESD" OFF)
-set_option(PULSEAUDIO          "Use PulseAudio" ${UNIX_SYS})
-dep_option(PULSEAUDIO_SHARED   "Dynamically load PulseAudio support" ON "PULSEAUDIO" OFF)
-set_option(ARTS                "Support the Analog Real Time Synthesizer" ${UNIX_SYS})
-dep_option(ARTS_SHARED         "Dynamically load aRts audio support" ON "ARTS" OFF)
-set_option(NAS                 "Support the NAS audio API" ${UNIX_SYS})
-set_option(NAS_SHARED          "Dynamically load NAS audio API" ${UNIX_SYS})
-set_option(SNDIO               "Support the sndio audio API" ${UNIX_SYS})
-dep_option(SNDIO_SHARED        "Dynamically load the sndio audio API" ${UNIX_SYS} ON "SNDIO" OFF)
-set_option(FUSIONSOUND         "Use FusionSound audio driver" OFF)
-dep_option(FUSIONSOUND_SHARED  "Dynamically load fusionsound audio support" ON "FUSIONSOUND" OFF)
-set_option(LIBSAMPLERATE       "Use libsamplerate for audio rate conversion" ${UNIX_SYS})
-dep_option(LIBSAMPLERATE_SHARED "Dynamically load libsamplerate" ON "LIBSAMPLERATE" OFF)
-set_option(RPATH               "Use an rpath when linking SDL" ${UNIX_SYS})
-set_option(CLOCK_GETTIME       "Use clock_gettime() instead of gettimeofday()" OFF)
-set_option(VIDEO_X11           "Use X11 video driver" ${UNIX_SYS})
-set_option(VIDEO_WAYLAND       "Use Wayland video driver" ${UNIX_SYS})
-dep_option(WAYLAND_SHARED      "Dynamically load Wayland support" ON "VIDEO_WAYLAND" OFF)
-dep_option(VIDEO_WAYLAND_QT_TOUCH  "QtWayland server support for Wayland video driver" ON "VIDEO_WAYLAND" OFF)
-set_option(VIDEO_RPI           "Use Raspberry Pi video driver" ${UNIX_SYS})
-dep_option(X11_SHARED          "Dynamically load X11 support" ON "VIDEO_X11" OFF)
-set(SDL_X11_OPTIONS Xcursor Xinerama XInput Xrandr Xscrnsaver XShape Xvm)
+# Allow some projects to be built conditionally.
+set_option(SDL2_DISABLE_SDL2MAIN   "Disable building/installation of SDL2main" OFF)
+set_option(SDL2_DISABLE_UNINSTALL  "Disable uninstallation of SDL2" OFF)
+
+option_string(SDL_ASSERTIONS "Enable internal sanity checks (auto/disabled/release/enabled/paranoid)" "auto")
+#set_option(SDL_DEPENDENCY_TRACKING "Use gcc -MMD -MT dependency tracking" ON)
+set_option(SDL_LIBC                "Use the system C library" ${OPT_DEF_LIBC})
+set_option(SDL_GCC_ATOMICS         "Use gcc builtin atomics" ${OPT_DEF_GCC_ATOMICS})
+set_option(SDL_ASSEMBLY            "Enable assembly routines" ${OPT_DEF_ASM})
+set_option(SDL_SSEMATH             "Allow GCC to use SSE floating point math" ${OPT_DEF_SSEMATH})
+set_option(SDL_MMX                 "Use MMX assembly routines" ${OPT_DEF_ASM})
+set_option(SDL_3DNOW               "Use 3Dnow! MMX assembly routines" ${OPT_DEF_ASM})
+set_option(SDL_SSE                 "Use SSE assembly routines" ${OPT_DEF_ASM})
+set_option(SDL_SSE2                "Use SSE2 assembly routines" ${OPT_DEF_SSEMATH})
+set_option(SDL_SSE3                "Use SSE3 assembly routines" ${OPT_DEF_SSEMATH})
+set_option(SDL_ALTIVEC             "Use Altivec assembly routines" ${OPT_DEF_ASM})
+set_option(SDL_ARMSIMD             "use SIMD assembly blitters on ARM" OFF)
+set_option(SDL_ARMNEON             "use NEON assembly blitters on ARM" OFF)
+set_option(SDL_DISKAUDIO           "Support the disk writer audio driver" ON)
+set_option(SDL_DUMMYAUDIO          "Support the dummy audio driver" ON)
+set_option(SDL_DIRECTFB            "Use DirectFB video driver" OFF)
+dep_option(SDL_DIRECTFB_SHARED     "Dynamically load directfb support" ON "SDL_DIRECTFB" OFF)
+set_option(SDL_DUMMYVIDEO          "Use dummy video driver" ON)
+set_option(SDL_OPENGL              "Include OpenGL support" ON)
+set_option(SDL_OPENGLES            "Include OpenGL ES support" ON)
+set_option(SDL_PTHREADS            "Use POSIX threads for multi-threading" ${SDL_PTHREADS_ENABLED_BY_DEFAULT})
+dep_option(SDL_PTHREADS_SEM        "Use pthread semaphores" ON "SDL_PTHREADS" OFF)
+dep_option(SDL_OSS                 "Support the OSS audio API" ON "UNIX_SYS OR RISCOS" OFF)
+set_option(SDL_ALSA                "Support the ALSA audio API" ${UNIX_SYS})
+dep_option(SDL_ALSA_SHARED         "Dynamically load ALSA audio support" ON "SDL_ALSA" OFF)
+set_option(SDL_JACK                "Support the JACK audio API" ${UNIX_SYS})
+dep_option(SDL_JACK_SHARED         "Dynamically load JACK audio support" ON "SDL_JACK" OFF)
+set_option(SDL_ESD                 "Support the Enlightened Sound Daemon" ${UNIX_SYS})
+dep_option(SDL_ESD_SHARED          "Dynamically load ESD audio support" ON "SDL_ESD" OFF)
+set_option(SDL_PIPEWIRE            "Use Pipewire audio" ${UNIX_SYS})
+dep_option(SDL_PIPEWIRE_SHARED     "Dynamically load Pipewire support" ON "SDL_PIPEWIRE" OFF)
+set_option(SDL_PULSEAUDIO          "Use PulseAudio" ${UNIX_SYS})
+dep_option(SDL_PULSEAUDIO_SHARED   "Dynamically load PulseAudio support" ON "SDL_PULSEAUDIO" OFF)
+set_option(SDL_ARTS                "Support the Analog Real Time Synthesizer" ${UNIX_SYS})
+dep_option(SDL_ARTS_SHARED         "Dynamically load aRts audio support" ON "SDL_ARTS" OFF)
+set_option(SDL_NAS                 "Support the NAS audio API" ${UNIX_SYS})
+dep_option(SDL_NAS_SHARED          "Dynamically load NAS audio support" ON "SDL_NAS" OFF)
+set_option(SDL_SNDIO               "Support the sndio audio API" ${UNIX_SYS})
+dep_option(SDL_SNDIO_SHARED        "Dynamically load the sndio audio API" ${UNIX_SYS} ON "SDL_SNDIO" OFF)
+set_option(SDL_FUSIONSOUND         "Use FusionSound audio driver" OFF)
+dep_option(SDL_FUSIONSOUND_SHARED  "Dynamically load fusionsound audio support" ON "SDL_FUSIONSOUND" OFF)
+set_option(SDL_LIBSAMPLERATE       "Use libsamplerate for audio rate conversion" ${UNIX_SYS})
+dep_option(SDL_LIBSAMPLERATE_SHARED "Dynamically load libsamplerate" ON "SDL_LIBSAMPLERATE" OFF)
+set_option(SDL_RPATH               "Use an rpath when linking SDL" ${UNIX_SYS})
+set_option(SDL_CLOCK_GETTIME       "Use clock_gettime() instead of gettimeofday()" ${UNIX_SYS})
+set_option(SDL_X11                 "Use X11 video driver" ${UNIX_SYS})
+dep_option(SDL_X11_SHARED          "Dynamically load X11 support" ON "SDL_X11" OFF)
+set(SDL_X11_OPTIONS Xcursor Xdbe Xinerama XInput Xfixes Xrandr Xscrnsaver XShape Xvm)
 foreach(_SUB ${SDL_X11_OPTIONS})
-  string(TOUPPER "VIDEO_X11_${_SUB}" _OPT)
-  dep_option(${_OPT}           "Enable ${_SUB} support" ON "VIDEO_X11" OFF)
+  string(TOUPPER "SDL_X11_${_SUB}" _OPT)
+  dep_option(${_OPT}               "Enable ${_SUB} support" ON "SDL_X11" OFF)
 endforeach()
-set_option(VIDEO_COCOA         "Use Cocoa video driver" ${APPLE})
-set_option(DIRECTX             "Use DirectX for Windows audio/video" ${WINDOWS})
-set_option(WASAPI              "Use the Windows WASAPI audio driver" ${WINDOWS})
-set_option(RENDER_D3D          "Enable the Direct3D render driver" ${WINDOWS})
-set_option(RENDER_METAL        "Enable the Metal render driver" ${APPLE})
-set_option(VIDEO_VIVANTE       "Use Vivante EGL video driver" ${UNIX_SYS})
-dep_option(VIDEO_VULKAN        "Enable Vulkan support" ON "ANDROID OR APPLE OR LINUX OR WINDOWS" OFF)
-set_option(VIDEO_METAL         "Enable Metal support" ${APPLE})
-set_option(VIDEO_KMSDRM        "Use KMS DRM video driver" ${UNIX_SYS})
-dep_option(KMSDRM_SHARED       "Dynamically load KMS DRM support" ON "VIDEO_KMSDRM" OFF)
-set_option(VIDEO_OFFSCREEN     "Use offscreen video driver" OFF)
-option_string(BACKGROUNDING_SIGNAL "number to use for magic backgrounding signal or 'OFF'" "OFF")
-option_string(FOREGROUNDING_SIGNAL "number to use for magic foregrounding signal or 'OFF'" "OFF")
-set_option(HIDAPI              "Use HIDAPI for low level joystick drivers" ${OPT_DEF_HIDAPI})
-set_option(JOYSTICK_VIRTUAL    "Enable the virtual-joystick driver" ON)
+set_option(SDL_WAYLAND             "Use Wayland video driver" ${UNIX_SYS})
+dep_option(SDL_WAYLAND_SHARED      "Dynamically load Wayland support" ON "SDL_WAYLAND" OFF)
+dep_option(SDL_WAYLAND_LIBDECOR    "Use client-side window decorations on Wayland" ON "SDL_WAYLAND" OFF)
+dep_option(SDL_WAYLAND_LIBDECOR_SHARED     "Dynamically load libdecor support" ON "SDL_WAYLAND_LIBDECOR" OFF)
+dep_option(SDL_WAYLAND_QT_TOUCH    "QtWayland server support for Wayland video driver" ON "SDL_WAYLAND" OFF)
+set_option(SDL_RPI                 "Use Raspberry Pi video driver" ${UNIX_SYS})
+set_option(SDL_COCOA               "Use Cocoa video driver" ${APPLE})
+set_option(SDL_DIRECTX             "Use DirectX for Windows audio/video" ${WINDOWS})
+set_option(SDL_XINPUT              "Use Xinput for Windows" ${WINDOWS})
+set_option(SDL_WASAPI              "Use the Windows WASAPI audio driver" ${WINDOWS})
+set_option(SDL_RENDER_D3D          "Enable the Direct3D render driver" ${WINDOWS})
+set_option(SDL_RENDER_METAL        "Enable the Metal render driver" ${APPLE})
+set_option(SDL_VIVANTE             "Use Vivante EGL video driver" ${UNIX_SYS})
+dep_option(SDL_VULKAN              "Enable Vulkan support" ON "ANDROID OR APPLE OR LINUX OR WINDOWS" OFF)
+set_option(SDL_METAL               "Enable Metal support" ${APPLE})
+set_option(SDL_KMSDRM              "Use KMS DRM video driver" ${UNIX_SYS})
+dep_option(SDL_KMSDRM_SHARED       "Dynamically load KMS DRM support" ON "SDL_KMSDRM" OFF)
+set_option(SDL_OFFSCREEN           "Use offscreen video driver" OFF)
+option_string(SDL_BACKGROUNDING_SIGNAL "number to use for magic backgrounding signal or 'OFF'" OFF)
+option_string(SDL_FOREGROUNDING_SIGNAL "number to use for magic foregrounding signal or 'OFF'" OFF)
+set_option(SDL_HIDAPI_JOYSTICK     "Use HIDAPI for low level joystick drivers" ON)
+set_option(SDL_VIRTUAL_JOYSTICK    "Enable the virtual-joystick driver" ON)
+set_option(SDL_ASAN                "Use AddressSanitizer to detect memory errors" OFF)
 
 set(SDL_SHARED ${SDL_SHARED_ENABLED_BY_DEFAULT} CACHE BOOL "Build a shared version of the library")
 set(SDL_STATIC ${SDL_STATIC_ENABLED_BY_DEFAULT} CACHE BOOL "Build a static version of the library")
@@ -406,6 +457,11 @@ set(SDL_STATIC ${SDL_STATIC_ENABLED_BY_DEFAULT} CACHE BOOL "Build a static versi
 dep_option(SDL_STATIC_PIC      "Static version of the library should be built with Position Independent Code" OFF "SDL_STATIC" OFF)
 set_option(SDL_TEST            "Build the test directory" OFF)
 
+if(VITA)
+  set_option(VIDEO_VITA_PIB  "Build with PSVita piglet gles2 support" OFF)
+  set_option(VIDEO_VITA_PVR  "Build with PSVita PVR gles/gles2 support" OFF)
+endif()
+
 # General source files
 file(GLOB SOURCE_FILES
   ${SDL2_SOURCE_DIR}/src/*.c
@@ -415,7 +471,9 @@ file(GLOB SOURCE_FILES
   ${SDL2_SOURCE_DIR}/src/dynapi/*.c
   ${SDL2_SOURCE_DIR}/src/events/*.c
   ${SDL2_SOURCE_DIR}/src/file/*.c
+  ${SDL2_SOURCE_DIR}/src/joystick/*.c
   ${SDL2_SOURCE_DIR}/src/haptic/*.c
+  ${SDL2_SOURCE_DIR}/src/hidapi/*.c
   ${SDL2_SOURCE_DIR}/src/libm/*.c
   ${SDL2_SOURCE_DIR}/src/locale/*.c
   ${SDL2_SOURCE_DIR}/src/misc/*.c
@@ -430,34 +488,38 @@ file(GLOB SOURCE_FILES
   ${SDL2_SOURCE_DIR}/src/video/yuv2rgb/*.c)
 
 
-if(ASSERTIONS STREQUAL "auto")
+if(SDL_ASSERTIONS STREQUAL "auto")
   # Do nada - use optimization settings to determine the assertion level
-elseif(ASSERTIONS STREQUAL "disabled")
+elseif(SDL_ASSERTIONS STREQUAL "disabled")
   set(SDL_DEFAULT_ASSERT_LEVEL 0)
-elseif(ASSERTIONS STREQUAL "release")
+elseif(SDL_ASSERTIONS STREQUAL "release")
   set(SDL_DEFAULT_ASSERT_LEVEL 1)
-elseif(ASSERTIONS STREQUAL "enabled")
+elseif(SDL_ASSERTIONS STREQUAL "enabled")
   set(SDL_DEFAULT_ASSERT_LEVEL 2)
-elseif(ASSERTIONS STREQUAL "paranoid")
+elseif(SDL_ASSERTIONS STREQUAL "paranoid")
   set(SDL_DEFAULT_ASSERT_LEVEL 3)
 else()
   message_error("unknown assertion level")
 endif()
-set(HAVE_ASSERTIONS ${ASSERTIONS})
+set(HAVE_ASSERTIONS ${SDL_ASSERTIONS})
 
-if(NOT BACKGROUNDING_SIGNAL STREQUAL "OFF")
-  add_definitions("-DSDL_BACKGROUNDING_SIGNAL=${BACKGROUNDING_SIGNAL}")
+if(NOT SDL_BACKGROUNDING_SIGNAL STREQUAL "OFF")
+  target_compile_definitions(sdl-build-options INTERFACE "-DSDL_BACKGROUNDING_SIGNAL=${SDL_BACKGROUNDING_SIGNAL}")
 endif()
 
-if(NOT FOREGROUNDING_SIGNAL STREQUAL "OFF")
-  add_definitions("-DSDL_FOREGROUNDING_SIGNAL=${FOREGROUNDING_SIGNAL}")
+if(NOT SDL_FOREGROUNDING_SIGNAL STREQUAL "OFF")
+  target_compile_definitions(sdl-build-options INTERFACE "-DSDL_FOREGROUNDING_SIGNAL=${SDL_FOREGROUNDING_SIGNAL}")
 endif()
 
 # Compiler option evaluation
 if(USE_GCC OR USE_CLANG)
   # Check for -Wall first, so later things can override pieces of it.
+  # Note: clang-cl treats -Wall as -Weverything (which is very loud),
+  #       /W3 as -Wall, and /W4 as -Wall -Wextra.  So: /W3 is enough.
   check_c_compiler_flag(-Wall HAVE_GCC_WALL)
-  if(HAVE_GCC_WALL)
+  if(MSVC_CLANG)
+    list(APPEND EXTRA_CFLAGS "/W3")
+  elseif(HAVE_GCC_WALL)
     list(APPEND EXTRA_CFLAGS "-Wall")
     if(HAIKU)
       set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-multichar")
@@ -483,10 +545,10 @@ if(USE_GCC OR USE_CLANG)
         #if !defined(__GNUC__) || __GNUC__ < 3
         #error Dependency tracking requires GCC 3.0 or newer
         #endif
-        int main(int argc, char **argv) { }" HAVE_DEPENDENCY_TRACKING)
+        int main(int argc, char **argv) { return 0; }" HAVE_DEPENDENCY_TRACKING)
   endif()
 
-  if(GCC_ATOMICS)
+  if(SDL_GCC_ATOMICS)
     check_c_source_compiles("int main(int argc, char **argv) {
         int a;
         void *x, *y, *z;
@@ -494,17 +556,19 @@ if(USE_GCC OR USE_CLANG)
         __sync_lock_test_and_set(&x, y);
         __sync_fetch_and_add(&a, 1);
         __sync_bool_compare_and_swap(&a, 5, 10);
-        __sync_bool_compare_and_swap(&x, y, z); }" HAVE_GCC_ATOMICS)
+        __sync_bool_compare_and_swap(&x, y, z);
+        return 0; }" HAVE_GCC_ATOMICS)
     if(NOT HAVE_GCC_ATOMICS)
       check_c_source_compiles("int main(int argc, char **argv) {
           int a;
           __sync_lock_test_and_set(&a, 1);
-          __sync_lock_release(&a); }" HAVE_GCC_SYNC_LOCK_TEST_AND_SET)
+          __sync_lock_release(&a);
+          return 0; }" HAVE_GCC_SYNC_LOCK_TEST_AND_SET)
     endif()
   endif()
 
   set(CMAKE_REQUIRED_FLAGS "-mpreferred-stack-boundary=2")
-  check_c_source_compiles("int x = 0; int main(int argc, char **argv) {}"
+  check_c_source_compiles("int x = 0; int main(int argc, char **argv) { return 0; }"
     HAVE_GCC_PREFERRED_STACK_BOUNDARY)
   set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS})
 
@@ -513,7 +577,7 @@ if(USE_GCC OR USE_CLANG)
       #if !defined(__GNUC__) || __GNUC__ < 4
       #error SDL only uses visibility attributes in GCC 4 or newer
       #endif
-      int main(int argc, char **argv) {}" HAVE_GCC_FVISIBILITY)
+      int main(int argc, char **argv) { return 0; }" HAVE_GCC_FVISIBILITY)
   if(HAVE_GCC_FVISIBILITY)
     list(APPEND EXTRA_CFLAGS "-fvisibility=hidden")
   endif()
@@ -528,23 +592,32 @@ if(USE_GCC OR USE_CLANG)
     list(APPEND EXTRA_LDFLAGS "-Wl,-undefined,error")
     list(APPEND EXTRA_LDFLAGS "-Wl,-compatibility_version,${DYLIB_COMPATIBILITY_VERSION}")
     list(APPEND EXTRA_LDFLAGS "-Wl,-current_version,${DYLIB_CURRENT_VERSION}")
-  else()
+  elseif(NOT OPENBSD)
     set(CMAKE_REQUIRED_FLAGS "-Wl,--no-undefined")
     check_c_compiler_flag("" HAVE_NO_UNDEFINED)
     set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS})
-    if(HAVE_NO_UNDEFINED)
+    if(HAVE_NO_UNDEFINED AND NOT (USE_CLANG AND WINDOWS))
       list(APPEND EXTRA_LDFLAGS "-Wl,--no-undefined")
     endif()
   endif()
+
+  # Force color diagnostics when one of these conditions are met
+  if(DEFINED ENV{CI} OR DEFINED ENV{USE_CCACHE} OR CMAKE_GENERATOR MATCHES Ninja)
+    if(EMSCRIPTEN OR (USE_GCC AND NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 4.9))
+      list(APPEND EXTRA_CFLAGS -fdiagnostics-color=always)
+    elseif(USE_CLANG AND NOT CMAKE_C_COMPILER_ID MATCHES AppleClang)
+      list(APPEND EXTRA_CFLAGS -fcolor-diagnostics)
+    endif()
+  endif()
 endif()
 
-if(ASSEMBLY)
+if(SDL_ASSEMBLY)
   if(USE_GCC OR USE_CLANG)
     set(SDL_ASSEMBLY_ROUTINES 1)
     # TODO: Those all seem to be quite GCC specific - needs to be
     # reworked for better compiler support
     set(HAVE_ASSEMBLY TRUE)
-    if(MMX)
+    if(SDL_MMX)
       set(CMAKE_REQUIRED_FLAGS "-mmmx")
       check_c_source_compiles("
           #ifdef __MINGW32__
@@ -560,14 +633,14 @@ if(ASSEMBLY)
           #ifndef __MMX__
           #error Assembler CPP flag not enabled
           #endif
-          int main(int argc, char **argv) { }" HAVE_MMX)
+          int main(int argc, char **argv) { return 0; }" HAVE_MMX)
       if(HAVE_MMX)
         list(APPEND EXTRA_CFLAGS "-mmmx")
       endif()
       set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS})
     endif()
 
-    if(3DNOW)
+    if(SDL_3DNOW)
       set(CMAKE_REQUIRED_FLAGS "-m3dnow")
       check_c_source_compiles("
           #include <mm3dnow.h>
@@ -577,6 +650,7 @@ if(ASSEMBLY)
           int main(int argc, char **argv) {
             void *p = 0;
             _m_prefetch(p);
+            return 0;
           }" HAVE_3DNOW)
       if(HAVE_3DNOW)
         list(APPEND EXTRA_CFLAGS "-m3dnow")
@@ -584,7 +658,7 @@ if(ASSEMBLY)
       set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS})
     endif()
 
-    if(SSE)
+    if(SDL_SSE)
       set(CMAKE_REQUIRED_FLAGS "-msse")
       check_c_source_compiles("
           #ifdef __MINGW32__
@@ -600,14 +674,14 @@ if(ASSEMBLY)
           #ifndef __SSE__
           #error Assembler CPP flag not enabled
           #endif
-          int main(int argc, char **argv) { }" HAVE_SSE)
+          int main(int argc, char **argv) { return 0; }" HAVE_SSE)
       if(HAVE_SSE)
         list(APPEND EXTRA_CFLAGS "-msse")
       endif()
       set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS})
     endif()
 
-    if(SSE2)
+    if(SDL_SSE2)
       set(CMAKE_REQUIRED_FLAGS "-msse2")
       check_c_source_compiles("
           #ifdef __MINGW32__
@@ -623,14 +697,14 @@ if(ASSEMBLY)
           #ifndef __SSE2__
           #error Assembler CPP flag not enabled
           #endif
-          int main(int argc, char **argv) { }" HAVE_SSE2)
+          int main(int argc, char **argv) { return 0; }" HAVE_SSE2)
       if(HAVE_SSE2)
         list(APPEND EXTRA_CFLAGS "-msse2")
       endif()
       set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS})
     endif()
 
-    if(SSE3)
+    if(SDL_SSE3)
       set(CMAKE_REQUIRED_FLAGS "-msse3")
       check_c_source_compiles("
           #ifdef __MINGW32__
@@ -646,40 +720,41 @@ if(ASSEMBLY)
           #ifndef __SSE3__
           #error Assembler CPP flag not enabled
           #endif
-          int main(int argc, char **argv) { }" HAVE_SSE3)
+          int main(int argc, char **argv) { return 0; }" HAVE_SSE3)
       if(HAVE_SSE3)
         list(APPEND EXTRA_CFLAGS "-msse3")
       endif()
       set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS})
     endif()
 
-    if(NOT SSEMATH)
-      if(SSE OR SSE2 OR SSE3)
+    if(NOT SDL_SSEMATH)
+      if(SDL_SSE OR SDL_SSE2 OR SDL_SSE3)
         if(USE_GCC)
           check_c_compiler_flag(-mfpmath=387 HAVE_FP_387)
           if(HAVE_FP_387)
             list(APPEND EXTRA_CFLAGS "-mfpmath=387")
           endif()
         endif()
-        set(HAVE_SSEMATH TRUE)
       endif()
+    else()
+      set(HAVE_SSEMATH TRUE)
     endif()
 
     check_include_file("immintrin.h" HAVE_IMMINTRIN_H)
 
-    if(ALTIVEC)
+    if(SDL_ALTIVEC)
       set(CMAKE_REQUIRED_FLAGS "-maltivec")
       check_c_source_compiles("
           #include <altivec.h>
           vector unsigned int vzero() {
               return vec_splat_u32(0);
           }
-          int main(int argc, char **argv) { }" HAVE_ALTIVEC_H_HDR)
+          int main(int argc, char **argv) { return 0; }" HAVE_ALTIVEC_H_HDR)
       check_c_source_compiles("
           vector unsigned int vzero() {
               return vec_splat_u32(0);
           }
-          int main(int argc, char **argv) { }" HAVE_ALTIVEC)
+          int main(int argc, char **argv) { return 0; }" HAVE_ALTIVEC)
       set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS})
       if(HAVE_ALTIVEC OR HAVE_ALTIVEC_H_HDR)
         set(HAVE_ALTIVEC TRUE) # if only HAVE_ALTIVEC_H_HDR is set
@@ -691,7 +766,7 @@ if(ASSEMBLY)
       endif()
     endif()
 
-    if(ARMSIMD)
+    if(SDL_ARMSIMD)
       set(ORIG_CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
       set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -x assembler-with-cpp")
       check_c_source_compiles("
@@ -717,7 +792,7 @@ if(ASSEMBLY)
       endif()
     endif()
 
-    if(ARMNEON)
+    if(SDL_ARMNEON)
       set(ORIG_CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
       set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -x assembler-with-cpp")
       check_c_source_compiles("
@@ -755,18 +830,14 @@ if(ASSEMBLY)
     set(HAVE_SSE TRUE)
     set(HAVE_SSE2 TRUE)
     set(HAVE_SSE3 TRUE)
+    check_include_file("immintrin.h" HAVE_IMMINTRIN_H)
     set(SDL_ASSEMBLY_ROUTINES 1)
   endif()
-# TODO:
-#else()
-#  if(USE_GCC OR USE_CLANG)
-#    list(APPEND EXTRA_CFLAGS "-mno-sse" "-mno-sse2" "-mno-sse3" "-mno-mmx")
-#  endif()
 endif()
 
 # TODO: Can't deactivate on FreeBSD? w/o LIBC, SDL_stdinc.h can't define
 # anything.
-if(LIBC)
+if(SDL_LIBC)
   if(WINDOWS AND NOT MINGW)
     set(HAVE_LIBC TRUE)
     foreach(_HEADER stdio.h string.h wchar.h ctype.h math.h limits.h)
@@ -777,28 +848,26 @@ if(LIBC)
     set(HAVE_SIGNAL_H 1)
     foreach(_FN
             malloc calloc realloc free qsort abs memset memcpy memmove memcmp
-            wcslen wcsdup wcsstr wcscmp wcsncmp _wcsicmp _wcsnicmp
+            wcslen _wcsdup wcsdup wcsstr wcscmp wcsncmp _wcsicmp _wcsnicmp
             strlen _strrev _strupr _strlwr strchr strrchr strstr itoa _ltoa
             _ultoa strtol strtoul strtoll strtod atoi atof strcmp strncmp
-            _stricmp _strnicmp strtok_s sscanf
+            _stricmp _strnicmp sscanf
             acos acosf asin asinf atan atanf atan2 atan2f ceil ceilf
             copysign copysignf cos cosf exp expf fabs fabsf floor floorf fmod fmodf
-            log logf log10 log10f pow powf scalbn scalbnf sin sinf sqrt sqrtf tan tanf
-            trunc truncf)
+            log logf log10 log10f lround lroundf pow powf round roundf scalbn scalbnf
+            sin sinf sqrt sqrtf tan tanf trunc truncf)
       string(TOUPPER ${_FN} _UPPER)
       set(HAVE_${_UPPER} 1)
     endforeach()
-    if(NOT CYGWIN AND NOT MINGW)
-      set(HAVE_ALLOCA 1)
-    endif()
+    set(HAVE_ALLOCA 1)
     set(HAVE_M_PI 1)
-    add_definitions(-D_USE_MATH_DEFINES) # needed for M_PI
+    target_compile_definitions(sdl-build-options INTERFACE "-D_USE_MATH_DEFINES") # needed for M_PI
     set(STDC_HEADERS 1)
   else()
     set(HAVE_LIBC TRUE)
     check_include_file(sys/types.h HAVE_SYS_TYPES_H)
     foreach(_HEADER
-            stdio.h stdlib.h stddef.h stdarg.h malloc.h memory.h string.h limits.h
+            stdio.h stdlib.h stddef.h stdarg.h malloc.h memory.h string.h limits.h float.h
             strings.h wchar.h inttypes.h stdint.h ctype.h math.h iconv.h signal.h libunwind.h)
       string(TOUPPER "HAVE_${_HEADER}" _UPPER)
       string(REPLACE "." "_" _HAVE_H ${_UPPER})
@@ -812,14 +881,14 @@ if(LIBC)
     # TODO: refine the mprotect check
     check_c_source_compiles("#include <sys/types.h>
                              #include <sys/mman.h>
-                             int main() { }" HAVE_MPROTECT)
+                             int main(void) { return 0; }" HAVE_MPROTECT)
     foreach(_FN
             strtod malloc calloc realloc free getenv setenv putenv unsetenv
             qsort abs bcopy memset memcpy memmove memcmp strlen strlcpy strlcat
-            _strrev _strupr _strlwr strchr strrchr strstr strtok_r itoa _ltoa
-            _uitoa _ultoa strtol strtoul _i64toa _ui64toa strtoll strtoull
+            _strrev _strupr _strlwr index rindex strchr strrchr strstr strtok_r
+            itoa _ltoa _uitoa _ultoa strtol strtoul _i64toa _ui64toa strtoll strtoull
             atoi atof strcmp strncmp _stricmp strcasecmp _strnicmp strncasecmp
-            wcscmp wcsdup wcslcat wcslcpy wcslen wcsncmp wcsstr
+            wcscmp _wcsdup wcsdup wcslcat wcslcpy wcslen wcsncmp wcsstr
             wcscasecmp _wcsicmp wcsncasecmp _wcsnicmp
             sscanf vsscanf vsnprintf fopen64 fseeko fseeko64 _Exit
             )
@@ -843,23 +912,27 @@ if(LIBC)
       foreach(_FN
               atan atan2 atanf atan2f ceil ceilf copysign copysignf cos cosf
               exp expf fabs fabsf floor floorf fmod fmodf log logf log10 log10f
-              pow powf scalbn scalbnf sin sinf sqrt sqrtf tan tanf acos acosf
-              asin asinf trunc truncf)
+              lround lroundf pow powf round roundf scalbn scalbnf sin sinf sqrt
+              sqrtf tan tanf acos acosf asin asinf trunc truncf)
         string(TOUPPER ${_FN} _UPPER)
         set(_HAVEVAR "HAVE_${_UPPER}")
         check_symbol_exists("${_FN}" "math.h" ${_HAVEVAR})
       endforeach()
       set(CMAKE_REQUIRED_LIBRARIES)
-      list(APPEND EXTRA_LIBS m)
+      if(NOT VITA)
+        list(APPEND EXTRA_LIBS m)
+      endif()
     endif()
 
     check_library_exists(iconv iconv_open "" HAVE_LIBICONV)
-    check_library_exists(c iconv_open "" HAVE_BUILTIN_ICONV)
-    if(HAVE_BUILTIN_ICONV)
-      set(HAVE_ICONV 1)
-    elseif(HAVE_LIBICONV)
+    if(HAVE_LIBICONV)
       list(APPEND EXTRA_LIBS iconv)
       set(HAVE_ICONV 1)
+    else()
+      check_library_exists(c iconv_open "" HAVE_BUILTIN_ICONV)
+      if(HAVE_BUILTIN_ICONV)
+        set(HAVE_ICONV 1)
+      endif()
     endif()
 
     if(NOT APPLE)
@@ -892,10 +965,6 @@ foreach(_SUB ${SDL_SUBSYSTEMS})
     set(SDL_${_OPT}_DISABLED 1)
   endif()
 endforeach()
-if(SDL_JOYSTICK)
-  file(GLOB JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/*.c)
-  set(SOURCE_FILES ${SOURCE_FILES} ${JOYSTICK_SOURCES})
-endif()
 if(SDL_HAPTIC)
   if(NOT SDL_JOYSTICK)
     # Haptic requires some private functions from the joystick subsystem.
@@ -904,37 +973,44 @@ if(SDL_HAPTIC)
 endif()
 
 
-# TODO: in configure.ac, the test for LOADSO and SDL_DLOPEN is a bit weird:
-# if LOADSO is not wanted, SDL_LOADSO_DISABLED is set
-# If however on Unix or APPLE dlopen() is detected via CheckDLOPEN(),
-# SDL_LOADSO_DISABLED will not be set, regardless of the LOADSO settings
-
 # General SDL subsystem options, valid for all platforms
 if(SDL_AUDIO)
   # CheckDummyAudio/CheckDiskAudio - valid for all platforms
-  if(DUMMYAUDIO)
+  if(SDL_DUMMYAUDIO)
     set(SDL_AUDIO_DRIVER_DUMMY 1)
     file(GLOB DUMMYAUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/dummy/*.c)
     set(SOURCE_FILES ${SOURCE_FILES} ${DUMMYAUDIO_SOURCES})
     set(HAVE_DUMMYAUDIO TRUE)
+    set(HAVE_SDL_AUDIO TRUE)
   endif()
-  if(DISKAUDIO)
+  if(SDL_DISKAUDIO)
     set(SDL_AUDIO_DRIVER_DISK 1)
     file(GLOB DISKAUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/disk/*.c)
     set(SOURCE_FILES ${SOURCE_FILES} ${DISKAUDIO_SOURCES})
     set(HAVE_DISKAUDIO TRUE)
+    set(HAVE_SDL_AUDIO TRUE)
   endif()
 endif()
 
-if(SDL_DLOPEN)
+if(UNIX OR APPLE)
   # Relevant for Unix/Darwin only
-  if(UNIX OR APPLE)
-    CheckDLOPEN()
+  set(DYNAPI_NEEDS_DLOPEN 1)
+  CheckDLOPEN()
+  if(SDL_LOADSO AND HAVE_DLOPEN)
+    set(SDL_LOADSO_DLOPEN 1)
+    file(GLOB DLOPEN_SOURCES ${SDL2_SOURCE_DIR}/src/loadso/dlopen/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${DLOPEN_SOURCES})
+    set(HAVE_SDL_LOADSO TRUE)
   endif()
 endif()
 
+if(UNIX OR APPLE OR HAIKU OR RISCOS)
+  CheckO_CLOEXEC()
+endif()
+
 if(SDL_JOYSTICK)
-  if(JOYSTICK_VIRTUAL)
+  if(SDL_VIRTUAL_JOYSTICK)
+    set(HAVE_VIRTUAL_JOYSTICK TRUE)
     set(SDL_JOYSTICK_VIRTUAL 1)
     file(GLOB JOYSTICK_VIRTUAL_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/virtual/*.c)
     set(SOURCE_FILES ${SOURCE_FILES} ${JOYSTICK_VIRTUAL_SOURCES})
@@ -942,18 +1018,18 @@ if(SDL_JOYSTICK)
 endif()
 
 if(SDL_VIDEO)
-  if(VIDEO_DUMMY)
+  if(SDL_DUMMYVIDEO)
     set(SDL_VIDEO_DRIVER_DUMMY 1)
     file(GLOB VIDEO_DUMMY_SOURCES ${SDL2_SOURCE_DIR}/src/video/dummy/*.c)
     set(SOURCE_FILES ${SOURCE_FILES} ${VIDEO_DUMMY_SOURCES})
-    set(HAVE_VIDEO_DUMMY TRUE)
+    set(HAVE_DUMMYVIDEO TRUE)
     set(HAVE_SDL_VIDEO TRUE)
   endif()
-  if(VIDEO_OFFSCREEN)
+  if(SDL_OFFSCREEN)
     set(SDL_VIDEO_DRIVER_OFFSCREEN 1)
     file(GLOB VIDEO_OFFSCREEN_SOURCES ${SDL2_SOURCE_DIR}/src/video/offscreen/*.c)
     set(SOURCE_FILES ${SOURCE_FILES} ${VIDEO_OFFSCREEN_SOURCES})
-    set(HAVE_VIDEO_OFFSCREEN TRUE)
+    set(HAVE_OFFSCREEN TRUE)
     set(HAVE_SDL_VIDEO TRUE)
   endif()
 endif()
@@ -963,9 +1039,11 @@ if(ANDROID)
   file(GLOB ANDROID_CORE_SOURCES ${SDL2_SOURCE_DIR}/src/core/android/*.c)
   set(SOURCE_FILES ${SOURCE_FILES} ${ANDROID_CORE_SOURCES} ${ANDROID_NDK}/sources/android/cpufeatures/cpu-features.c)
 
-  file(GLOB ANDROID_MISC_SOURCES ${SDL2_SOURCE_DIR}/src/misc/android/*.c)
-  set(SOURCE_FILES ${SOURCE_FILES} ${ANDROID_MISC_SOURCES})
-  set(HAVE_SDL_MISC TRUE)
+  if(SDL_MISC)
+    file(GLOB ANDROID_MISC_SOURCES ${SDL2_SOURCE_DIR}/src/misc/android/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${ANDROID_MISC_SOURCES})
+    set(HAVE_SDL_MISC TRUE)
+  endif()
 
   # SDL_spinlock.c Needs to be compiled in ARM mode.
   # There seems to be no better way currently to set the ARM mode.
@@ -983,6 +1061,18 @@ if(ANDROID)
     set(SDL_AUDIO_DRIVER_ANDROID 1)
     file(GLOB ANDROID_AUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/android/*.c)
     set(SOURCE_FILES ${SOURCE_FILES} ${ANDROID_AUDIO_SOURCES})
+
+    set(SDL_AUDIO_DRIVER_OPENSLES 1)
+    file(GLOB OPENSLES_AUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/openslES/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${OPENSLES_AUDIO_SOURCES})
+
+    find_library(ANDROID_OPENSLES_LIBRARY OpenSLES)
+    list(APPEND EXTRA_LIBS ${ANDROID_DL_LIBRARY} ${ANDROID_OPENSLES_LIBRARY})
+
+    set(SDL_AUDIO_DRIVER_AAUDIO 1)
+    file(GLOB AAUDIO_AUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/aaudio/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${AAUDIO_AUDIO_SOURCES})
+
     set(HAVE_SDL_AUDIO TRUE)
   endif()
   if(SDL_FILESYSTEM)
@@ -997,8 +1087,10 @@ if(ANDROID)
     set(SOURCE_FILES ${SOURCE_FILES} ${ANDROID_HAPTIC_SOURCES})
     set(HAVE_SDL_HAPTIC TRUE)
   endif()
-  if(SDL_JOYSTICK)
+  if(SDL_HIDAPI)
     CheckHIDAPI()
+  endif()
+  if(SDL_JOYSTICK)
     set(SDL_JOYSTICK_ANDROID 1)
     file(GLOB ANDROID_JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/android/*.c ${SDL2_SOURCE_DIR}/src/joystick/steam/*.c)
     set(SOURCE_FILES ${SOURCE_FILES} ${ANDROID_JOYSTICK_SOURCES})
@@ -1046,16 +1138,12 @@ if(ANDROID)
     find_library(ANDROID_LOG_LIBRARY log)
     find_library(ANDROID_LIBRARY_LIBRARY android)
     list(APPEND EXTRA_LIBS ${ANDROID_DL_LIBRARY} ${ANDROID_LOG_LIBRARY} ${ANDROID_LIBRARY_LIBRARY})
-    add_definitions(-DGL_GLEXT_PROTOTYPES)
-
-    if (HAVE_HIDAPI)
-        list(APPEND EXTRA_LIBS hidapi)
-    endif()
+    target_compile_definitions(sdl-build-options INTERFACE "-DGL_GLEXT_PROTOTYPES")
 
     #enable gles
-    if(VIDEO_OPENGLES)
+    if(SDL_OPENGLES)
       set(SDL_VIDEO_OPENGL_EGL 1)
-      set(HAVE_VIDEO_OPENGLES TRUE)
+      set(HAVE_OPENGLES TRUE)
       set(SDL_VIDEO_OPENGL_ES 1)
       set(SDL_VIDEO_RENDER_OGL_ES 1)
       set(SDL_VIDEO_OPENGL_ES2 1)
@@ -1066,18 +1154,17 @@ if(ANDROID)
       list(APPEND EXTRA_LIBS ${OpenGLES1_LIBRARY} ${OpenGLES2_LIBRARY})
     endif()
 
-    CHECK_C_SOURCE_COMPILES("
-    #if defined(__ARM_ARCH) && __ARM_ARCH < 7
-    #error Vulkan doesn't work on this configuration
-    #endif
-    int main()
-    {
-        return 0;
-    }
-    " VULKAN_PASSED_ANDROID_CHECKS)
-    if(NOT VULKAN_PASSED_ANDROID_CHECKS)
-      set(VIDEO_VULKAN OFF)
-      message(STATUS "Vulkan doesn't work on this configuration")
+    if(SDL_VULKAN)
+      CHECK_C_SOURCE_COMPILES("
+      #if defined(__ARM_ARCH) && __ARM_ARCH < 7
+      #error Vulkan doesn't work on this configuration
+      #endif
+      int main(int argc, char **argv) { return 0; }
+      " VULKAN_PASSED_ANDROID_CHECKS)
+      if(VULKAN_PASSED_ANDROID_CHECKS)
+        set(SDL_VIDEO_VULKAN 1)
+        set(HAVE_VULKAN TRUE)
+      endif()
     endif()
   endif()
 
@@ -1086,7 +1173,13 @@ if(ANDROID)
 elseif(EMSCRIPTEN)
   # Hide noisy warnings that intend to aid mostly during initial stages of porting a new
   # project. Uncomment at will for verbose cross-compiling -I/../ path info.
-  add_definitions(-Wno-warn-absolute-paths)
+  target_compile_options(sdl-build-options INTERFACE "-Wno-warn-absolute-paths")
+
+  if(SDL_MISC)
+    file(GLOB EMSRIPTEN_MISC_SOURCES ${SDL2_SOURCE_DIR}/src/misc/emscripten/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${EMSRIPTEN_MISC_SOURCES})
+    set(HAVE_SDL_MISC TRUE)
+  endif()
   if(SDL_AUDIO)
     set(SDL_AUDIO_DRIVER_EMSCRIPTEN 1)
     file(GLOB EM_AUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/emscripten/*.c)
@@ -1122,7 +1215,7 @@ elseif(EMSCRIPTEN)
     set(SOURCE_FILES ${SOURCE_FILES} ${TIMER_SOURCES})
     set(HAVE_SDL_TIMERS TRUE)
 
-    if(CLOCK_GETTIME)
+    if(SDL_CLOCK_GETTIME)
       set(HAVE_CLOCK_GETTIME 1)
     endif()
   endif()
@@ -1133,15 +1226,17 @@ elseif(EMSCRIPTEN)
     set(HAVE_SDL_VIDEO TRUE)
 
     #enable gles
-    if(VIDEO_OPENGLES)
+    if(SDL_OPENGLES)
       set(SDL_VIDEO_OPENGL_EGL 1)
-      set(HAVE_VIDEO_OPENGLES TRUE)
+      set(HAVE_OPENGLES TRUE)
       set(SDL_VIDEO_OPENGL_ES2 1)
       set(SDL_VIDEO_RENDER_OGL_ES2 1)
     endif()
   endif()
 
-elseif(UNIX AND NOT APPLE AND NOT ANDROID AND NOT RISCOS)
+  CheckPTHREAD()
+
+elseif(UNIX AND NOT APPLE AND NOT ANDROID AND NOT RISCOS AND NOT HAIKU)
   if(SDL_AUDIO)
     if(SYSV5 OR SOLARIS OR HPUX)
         set(SDL_AUDIO_DRIVER_SUNAUDIO 1)
@@ -1162,6 +1257,7 @@ elseif(UNIX AND NOT APPLE AND NOT ANDROID AND NOT RISCOS)
     CheckOSS()
     CheckALSA()
     CheckJACK()
+    CheckPipewire()
     CheckPulseAudio()
     CheckESD()
     CheckARTS()
@@ -1176,36 +1272,52 @@ elseif(UNIX AND NOT APPLE AND NOT ANDROID AND NOT RISCOS)
     CheckRPI()
     CheckX11()
     CheckDirectFB()
-    CheckOpenGLX11()
-    CheckOpenGLESX11()
+    # Need to check for EGL first because KMSDRM and Wayland depends on it.
+    CheckEGL()
+    CheckKMSDRM()
+    CheckGLX()
+    CheckOpenGL()
+    CheckOpenGLES()
     CheckWayland()
     CheckVivante()
-    CheckKMSDRM()
+    # FIXME: implement CheckVulkan()
+    if(SDL_VULKAN)
+      set(SDL_VIDEO_VULKAN 1)
+      set(HAVE_VULKAN TRUE)
+    endif()
   endif()
 
   if(UNIX)
     file(GLOB CORE_UNIX_SOURCES ${SDL2_SOURCE_DIR}/src/core/unix/*.c)
     set(SOURCE_FILES ${SOURCE_FILES} ${CORE_UNIX_SOURCES})
-  endif()
 
-  if(LINUX)
     check_c_source_compiles("
         #include <linux/input.h>
         #ifndef EVIOCGNAME
         #error EVIOCGNAME() ioctl not available
         #endif
-        int main(int argc, char** argv) {}" HAVE_INPUT_EVENTS)
+        int main(int argc, char** argv) { return 0; }" HAVE_INPUT_EVENTS)
 
-    check_c_source_compiles("
-        #include <linux/kd.h>
-        #include <linux/keyboard.h>
-
-        int main(int argc, char **argv)
-        {
-            struct kbentry kbe;
-            kbe.kb_table = KG_CTRL;
-            ioctl(0, KDGKBENT, &kbe);
-        }" HAVE_INPUT_KD)
+    if(LINUX)
+      check_c_source_compiles("
+          #include <linux/kd.h>
+          #include <linux/keyboard.h>
+          int main(int argc, char **argv) {
+              struct kbentry kbe;
+              kbe.kb_table = KG_CTRL;
+              ioctl(0, KDGKBENT, &kbe);
+              return 0;
+          }" HAVE_INPUT_KD)
+    elseif(FREEBSD)
+      check_c_source_compiles("
+          #include <sys/kbio.h>
+          #include <sys/ioctl.h>
+          int main(int argc, char **argv) {
+              accentmap_t accTable;
+              ioctl(0, KDENABIO, 1);
+              return 0;
+          }" HAVE_INPUT_KBIO)
+    endif()
 
     if(HAVE_INPUT_EVENTS)
       set(SDL_INPUT_LINUXEV 1)
@@ -1222,10 +1334,15 @@ elseif(UNIX AND NOT APPLE AND NOT ANDROID AND NOT RISCOS)
       set(SDL_INPUT_LINUXKD 1)
     endif()
 
+    if(HAVE_INPUT_KBIO)
+      set(SDL_INPUT_FBSDKBIO 1)
+    endif()
+
     check_include_file("libudev.h" HAVE_LIBUDEV_H)
     check_include_file("sys/inotify.h" HAVE_SYS_INOTIFY_H)
     check_symbol_exists(inotify_init "sys/inotify.h" HAVE_INOTIFY_INIT)
     check_symbol_exists(inotify_init1 "sys/inotify.h" HAVE_INOTIFY_INIT1)
+
     if(HAVE_SYS_INOTIFY_H AND HAVE_INOTIFY_INIT)
       set(HAVE_INOTIFY 1)
     endif()
@@ -1234,7 +1351,7 @@ elseif(UNIX AND NOT APPLE AND NOT ANDROID AND NOT RISCOS)
       pkg_search_module(DBUS dbus-1 dbus)
       if(DBUS_FOUND)
         set(HAVE_DBUS_DBUS_H TRUE)
-        include_directories(${DBUS_INCLUDE_DIRS})
+        target_include_directories(sdl-build-options INTERFACE "${DBUS_INCLUDE_DIRS}")
         list(APPEND EXTRA_LIBS ${DBUS_LIBRARIES})
         # Fcitx need only dbus.
         set(HAVE_FCITX TRUE)
@@ -1243,18 +1360,27 @@ elseif(UNIX AND NOT APPLE AND NOT ANDROID AND NOT RISCOS)
       pkg_search_module(IBUS ibus-1.0 ibus)
       if(IBUS_FOUND)
         set(HAVE_IBUS_IBUS_H TRUE)
-        include_directories(${IBUS_INCLUDE_DIRS})
+        target_include_directories(sdl-build-options INTERFACE "${IBUS_INCLUDE_DIRS}")
         list(APPEND EXTRA_LIBS ${IBUS_LIBRARIES})
       endif()
 
       if (HAVE_IBUS_IBUS_H OR HAVE_FCITX)
-        set(SDL_USE_IME TRUE)
-        add_definitions(-DSDL_USE_IME)   # !!! FIXME: why isn't this a definition and not in SDL_config.h.cmake?
+        set(SDL_USE_IME 1)
       endif()
+
+      if(FREEBSD AND NOT HAVE_INOTIFY)
+        pkg_search_module(INOTIFY libinotify)
+        if(INOTIFY_FOUND)
+          set(HAVE_INOTIFY 1)
+          target_include_directories(sdl-build-options INTERFACE "${INOTIFY_INCLUDE_DIRS}")
+          list(APPEND EXTRA_LIBS ${INOTIFY_LIBRARIES})
+        endif()
+      endif()
+
       if(HAVE_LIBUNWIND_H)
         # We've already found the header, so REQUIRE the lib to be present
         pkg_search_module(UNWIND REQUIRED libunwind)
-        pkg_search_module(UNWIND_GENERIC REQUIRED libunwind-generic)
+        pkg_search_module(UNWIND_GENERIC libunwind-generic)
         list(APPEND EXTRA_LIBS ${UNWIND_LIBRARIES} ${UNWIND_GENERIC_LIBRARIES})
       endif()
     endif()
@@ -1284,6 +1410,10 @@ elseif(UNIX AND NOT APPLE AND NOT ANDROID AND NOT RISCOS)
       set(SOURCE_FILES ${SOURCE_FILES} "${SDL2_SOURCE_DIR}/src/core/linux/SDL_evdev_kbd.c")
     endif()
 
+    if(HAVE_INPUT_KBIO)
+      set(SOURCE_FILES ${SOURCE_FILES} "${SDL2_SOURCE_DIR}/src/core/freebsd/SDL_evdev_kbd_freebsd.c")
+    endif()
+
     # Always compiled for Linux, unconditionally:
     set(SOURCE_FILES ${SOURCE_FILES} "${SDL2_SOURCE_DIR}/src/core/linux/SDL_evdev_capabilities.c")
     set(SOURCE_FILES ${SOURCE_FILES} "${SDL2_SOURCE_DIR}/src/core/linux/SDL_threadprio.c")
@@ -1291,11 +1421,14 @@ elseif(UNIX AND NOT APPLE AND NOT ANDROID AND NOT RISCOS)
     # src/core/unix/*.c is included in a generic if(UNIX) section, elsewhere.
   endif()
 
+  if(SDL_HIDAPI)
+    CheckHIDAPI()
+  endif()
+
   if(SDL_JOYSTICK)
     if(FREEBSD OR NETBSD OR OPENBSD OR BSDI)
       CheckUSBHID()
     endif()
-    CheckHIDAPI()
     if(LINUX AND NOT ANDROID)
       set(SDL_JOYSTICK_LINUX 1)
       file(GLOB JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/linux/*.c ${SDL2_SOURCE_DIR}/src/joystick/steam/*.c)
@@ -1306,7 +1439,7 @@ elseif(UNIX AND NOT APPLE AND NOT ANDROID AND NOT RISCOS)
 
   CheckPTHREAD()
 
-  if(CLOCK_GETTIME)
+  if(SDL_CLOCK_GETTIME)
     check_library_exists(rt clock_gettime "" FOUND_CLOCK_GETTIME)
     if(FOUND_CLOCK_GETTIME)
       list(APPEND EXTRA_LIBS rt)
@@ -1324,9 +1457,11 @@ elseif(UNIX AND NOT APPLE AND NOT ANDROID AND NOT RISCOS)
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DHAVE_LINUX_VERSION_H")
   endif()
 
-  file(GLOB MISC_SOURCES ${SDL2_SOURCE_DIR}/src/misc/unix/*.c)
-  set(SOURCE_FILES ${SOURCE_FILES} ${MISC_SOURCES})
-  set(HAVE_SDL_MISC TRUE)
+  if(SDL_MISC)
+    file(GLOB MISC_SOURCES ${SDL2_SOURCE_DIR}/src/misc/unix/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${MISC_SOURCES})
+    set(HAVE_SDL_MISC TRUE)
+  endif()
 
   if(SDL_POWER)
     if(LINUX)
@@ -1358,7 +1493,7 @@ elseif(UNIX AND NOT APPLE AND NOT ANDROID AND NOT RISCOS)
   endif()
 
   set(SDL_RLD_FLAGS "")
-  if(RPATH AND SDL_SHARED)
+  if(SDL_RPATH AND SDL_SHARED)
     if(BSDI OR FREEBSD OR LINUX OR NETBSD)
       set(CMAKE_REQUIRED_FLAGS "-Wl,--enable-new-dtags")
       check_c_compiler_flag("" HAVE_ENABLE_NEW_DTAGS)
@@ -1380,7 +1515,7 @@ elseif(WINDOWS)
 
   check_c_source_compiles("
     #include <windows.h>
-    int main(int argc, char **argv) { }" HAVE_WIN32_CC)
+    int main(int argc, char **argv) { return 0; }" HAVE_WIN32_CC)
 
   file(GLOB CORE_SOURCES ${SDL2_SOURCE_DIR}/src/core/windows/*.c)
   set(SOURCE_FILES ${SOURCE_FILES} ${CORE_SOURCES})
@@ -1390,7 +1525,7 @@ elseif(WINDOWS)
     list(APPEND SOURCE_FILES ${WINRT_SOURCE_FILES})
   endif()
 
-  if(MSVC)
+  if(MSVC AND NOT SDL_LIBC)
     # Prevent codegen that would use the VC runtime libraries.
     set_property(DIRECTORY . APPEND PROPERTY COMPILE_OPTIONS "/GS-")
     if(NOT ARCH_64)
@@ -1398,42 +1533,28 @@ elseif(WINDOWS)
     endif()
   endif()
 
-  file(GLOB MISC_SOURCES ${SDL2_SOURCE_DIR}/src/misc/windows/*.c)
-  set(SOURCE_FILES ${SOURCE_FILES} ${MISC_SOURCES})
-  set(HAVE_SDL_MISC TRUE)
+  if(SDL_MISC)
+    if(WINDOWS_STORE)
+      file(GLOB MISC_SOURCES ${SDL2_SOURCE_DIR}/src/misc/winrt/*.cpp)
+    else()
+      file(GLOB MISC_SOURCES ${SDL2_SOURCE_DIR}/src/misc/windows/*.c)
+    endif()
+    set(SOURCE_FILES ${SOURCE_FILES} ${MISC_SOURCES})
+    set(HAVE_SDL_MISC TRUE)
+  endif()
 
   # Check for DirectX
-  if(DIRECTX)
+  if(SDL_DIRECTX)
     if(DEFINED MSVC_VERSION AND NOT ${MSVC_VERSION} LESS 1700)
         set(USE_WINSDK_DIRECTX TRUE)
     endif()
-    if(NOT CMAKE_COMPILER_IS_MINGW AND NOT USE_WINSDK_DIRECTX)
+    if(NOT MINGW AND NOT USE_WINSDK_DIRECTX)
       if("$ENV{DXSDK_DIR}" STREQUAL "")
         message_error("DIRECTX requires the \$DXSDK_DIR environment variable to be set")
       endif()
       set(CMAKE_REQUIRED_FLAGS "/I\"$ENV{DXSDK_DIR}\\Include\"")
     endif()
 
-    if(HAVE_WIN32_CC)
-      # xinput.h may need windows.h, but doesn't include it itself.
-      check_c_source_compiles("
-        #include <windows.h>
-        #include <xinput.h>
-        int main(int argc, char **argv) { }" HAVE_XINPUT_H)
-      check_c_source_compiles("
-        #include <windows.h>
-        #include <xinput.h>
-        XINPUT_GAMEPAD_EX x1;
-        int main(int argc, char **argv) { }" HAVE_XINPUT_GAMEPAD_EX)
-      check_c_source_compiles("
-        #include <windows.h>
-        #include <xinput.h>
-        XINPUT_STATE_EX s1;
-        int main(int argc, char **argv) { }" HAVE_XINPUT_STATE_EX)
-    else()
-      check_include_file(xinput.h HAVE_XINPUT_H)
-    endif()
-
     check_include_file(d3d9.h HAVE_D3D_H)
     check_include_file(d3d11_1.h HAVE_D3D11_H)
     check_include_file(ddraw.h HAVE_DDRAW_H)
@@ -1445,38 +1566,68 @@ elseif(WINDOWS)
     check_include_file(dxgi.h HAVE_DXGI_H)
     if(HAVE_D3D_H OR HAVE_D3D11_H OR HAVE_DDRAW_H OR HAVE_DSOUND_H OR HAVE_DINPUT_H)
       set(HAVE_DIRECTX TRUE)
-      if(NOT CMAKE_COMPILER_IS_MINGW AND NOT USE_WINSDK_DIRECTX)
+      if(NOT MINGW AND NOT USE_WINSDK_DIRECTX)
       # TODO: change $ENV{DXSDL_DIR} to get the path from the include checks
-        link_directories($ENV{DXSDK_DIR}\\lib\\${PROCESSOR_ARCH})
-        include_directories($ENV{DXSDK_DIR}\\Include)
+        target_link_directories(sdl-build-options INTERFACE "$$ENV{DXSDK_DIR}\\lib\\${PROCESSOR_ARCH}")
+        target_include_directories(sdl-build-options INTERFACE "$ENV{DXSDK_DIR}\\Include")
       endif()
     endif()
     set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS})
   endif()
 
+  if(SDL_XINPUT)
+    # xinput.h may need windows.h, but does not include it itself.
+    check_c_source_compiles("
+      #include <windows.h>
+      #include <xinput.h>
+      int main(int argc, char **argv) { return 0; }" HAVE_XINPUT_H)
+    check_c_source_compiles("
+      #include <windows.h>
+      #include <xinput.h>
+      XINPUT_GAMEPAD_EX x1;
+      int main(int argc, char **argv) { return 0; }" HAVE_XINPUT_GAMEPAD_EX)
+    check_c_source_compiles("
+      #include <windows.h>
+      #include <xinput.h>
+      XINPUT_STATE_EX s1;
+      int main(int argc, char **argv) { return 0; }" HAVE_XINPUT_STATE_EX)
+    check_c_source_compiles("
+      #define COBJMACROS
+      #include <windows.gaming.input.h>
+      __x_ABI_CWindows_CGaming_CInput_CIGamepadStatics2 *s2;
+      int main(int argc, char **argv) { return 0; }" HAVE_WINDOWS_GAMING_INPUT_H)
+  endif()
+
   # headers needed elsewhere
+  check_include_file(tpcshrd.h HAVE_TPCSHRD_H)
   check_include_file(mmdeviceapi.h HAVE_MMDEVICEAPI_H)
   check_include_file(audioclient.h HAVE_AUDIOCLIENT_H)
   check_include_file(sensorsapi.h HAVE_SENSORSAPI_H)
 
   if(SDL_AUDIO)
     if(NOT WINDOWS_STORE)
-    set(SDL_AUDIO_DRIVER_WINMM 1)
-    file(GLOB WINMM_AUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/winmm/*.c)
-    set(SOURCE_FILES ${SOURCE_FILES} ${WINMM_AUDIO_SOURCES})
+      set(SDL_AUDIO_DRIVER_WINMM 1)
+      file(GLOB WINMM_AUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/winmm/*.c)
+      set(SOURCE_FILES ${SOURCE_FILES} ${WINMM_AUDIO_SOURCES})
+      set(HAVE_SDL_AUDIO TRUE)
     endif()
-    set(HAVE_SDL_AUDIO TRUE)
 
     if(HAVE_DSOUND_H AND NOT WINDOWS_STORE)
       set(SDL_AUDIO_DRIVER_DSOUND 1)
       file(GLOB DSOUND_AUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/directsound/*.c)
       set(SOURCE_FILES ${SOURCE_FILES} ${DSOUND_AUDIO_SOURCES})
+      set(HAVE_SDL_AUDIO TRUE)
     endif()
 
-    if(WASAPI AND HAVE_AUDIOCLIENT_H AND HAVE_MMDEVICEAPI_H AND NOT WINDOWS_STORE)
+    if(SDL_WASAPI AND HAVE_AUDIOCLIENT_H AND HAVE_MMDEVICEAPI_H)
       set(SDL_AUDIO_DRIVER_WASAPI 1)
+      set(HAVE_WASAPI TRUE)
       file(GLOB WASAPI_AUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/wasapi/*.c)
+      if(WINDOWS_STORE)
+        list(APPEND WASAPI_AUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/wasapi/SDL_wasapi_winrt.cpp)
+      endif()
       set(SOURCE_FILES ${SOURCE_FILES} ${WASAPI_AUDIO_SOURCES})
+      set(HAVE_SDL_AUDIO TRUE)
     endif()
   endif()
 
@@ -1488,21 +1639,21 @@ elseif(WINDOWS)
     if(WINDOWS_STORE)
       set(SDL_VIDEO_DRIVER_WINRT 1)
       file(GLOB WIN_VIDEO_SOURCES
-        ${SDL2_SOURCE_DIR}/src/video/winrt/*.c 
+        ${SDL2_SOURCE_DIR}/src/video/winrt/*.c
         ${SDL2_SOURCE_DIR}/src/video/winrt/*.cpp
         ${SDL2_SOURCE_DIR}/src/render/direct3d11/*.cpp
         )
     else()
-    set(SDL_VIDEO_DRIVER_WINDOWS 1)
-    file(GLOB WIN_VIDEO_SOURCES ${SDL2_SOURCE_DIR}/src/video/windows/*.c)
+      set(SDL_VIDEO_DRIVER_WINDOWS 1)
+      file(GLOB WIN_VIDEO_SOURCES ${SDL2_SOURCE_DIR}/src/video/windows/*.c)
     endif()
     set(SOURCE_FILES ${SOURCE_FILES} ${WIN_VIDEO_SOURCES})
 
-    if(RENDER_D3D AND HAVE_D3D_H AND NOT WINDOWS_STORE)
+    if(SDL_RENDER_D3D AND HAVE_D3D_H AND NOT WINDOWS_STORE)
       set(SDL_VIDEO_RENDER_D3D 1)
       set(HAVE_RENDER_D3D TRUE)
     endif()
-    if(RENDER_D3D AND HAVE_D3D11_H)
+    if(SDL_RENDER_D3D AND HAVE_D3D11_H)
       set(SDL_VIDEO_RENDER_D3D11 1)
       set(HAVE_RENDER_D3D TRUE)
     endif()
@@ -1510,17 +1661,19 @@ elseif(WINDOWS)
   endif()
 
   if(SDL_THREADS)
+    set(SDL_THREAD_GENERIC_COND_SUFFIX 1)
     set(SDL_THREAD_WINDOWS 1)
     set(SOURCE_FILES ${SOURCE_FILES}
+      ${SDL2_SOURCE_DIR}/src/thread/generic/SDL_syscond.c
+      ${SDL2_SOURCE_DIR}/src/thread/windows/SDL_syscond_cv.c
       ${SDL2_SOURCE_DIR}/src/thread/windows/SDL_sysmutex.c
       ${SDL2_SOURCE_DIR}/src/thread/windows/SDL_syssem.c
       ${SDL2_SOURCE_DIR}/src/thread/windows/SDL_systhread.c
-      ${SDL2_SOURCE_DIR}/src/thread/windows/SDL_systls.c
-      ${SDL2_SOURCE_DIR}/src/thread/generic/SDL_syscond.c)
+      ${SDL2_SOURCE_DIR}/src/thread/windows/SDL_systls.c)
     set(HAVE_SDL_THREADS TRUE)
   endif()
 
-  if(SDL_SENSOR AND HAVE_SENSORSAPI_H)
+  if(SDL_SENSOR AND HAVE_SENSORSAPI_H AND NOT WINDOWS_STORE)
     set(SDL_SENSOR_WINDOWS 1)
     set(HAVE_SDL_SENSORS TRUE)
     file(GLOB WINDOWS_SENSOR_SOURCES ${SDL2_SOURCE_DIR}/src/sensor/windows/*.c)
@@ -1539,7 +1692,11 @@ elseif(WINDOWS)
   endif()
 
   if(SDL_LOCALE)
-    file(GLOB LOCALE_SOURCES ${SDL2_SOURCE_DIR}/src/locale/windows/*.c)
+    if(WINDOWS_STORE)
+      file(GLOB LOCALE_SOURCES ${SDL2_SOURCE_DIR}/src/locale/winrt/*.c)
+    else()
+      file(GLOB LOCALE_SOURCES ${SDL2_SOURCE_DIR}/src/locale/windows/*.c)
+    endif()
     set(SOURCE_FILES ${SOURCE_FILES} ${LOCALE_SOURCES})
     set(HAVE_SDL_LOCALE TRUE)
   endif()
@@ -1560,8 +1717,15 @@ elseif(WINDOWS)
     list(APPEND EXTRA_LIBS user32 gdi32 winmm imm32 ole32 oleaut32 version uuid advapi32 setupapi shell32)
   endif()
 
-  # TODO: in configure.ac the check for timers is set on
-  # cygwin | mingw32* - does this include mingw32CE?
+  if(WINDOWS_STORE)
+    list(APPEND EXTRA_LIBS
+      -nodefaultlib:vccorlib$<$<CONFIG:Debug>:d>
+      -nodefaultlib:msvcrt$<$<CONFIG:Debug>:d>
+      vccorlib$<$<CONFIG:Debug>:d>.lib
+      msvcrt$<$<CONFIG:Debug>:d>.lib
+    )
+  endif()
+
   if(SDL_TIMERS)
     set(SDL_TIMER_WINDOWS 1)
     file(GLOB TIMER_SOURCES ${SDL2_SOURCE_DIR}/src/timer/windows/*.c)
@@ -1580,43 +1744,54 @@ elseif(WINDOWS)
   set(SOURCE_FILES ${SOURCE_FILES} ${CORE_SOURCES})
 
   if(SDL_VIDEO)
-    if(VIDEO_OPENGL AND NOT WINDOWS_STORE)
+    if(SDL_OPENGL AND NOT WINDOWS_STORE)
       set(SDL_VIDEO_OPENGL 1)
       set(SDL_VIDEO_OPENGL_WGL 1)
       set(SDL_VIDEO_RENDER_OGL 1)
-      set(HAVE_VIDEO_OPENGL TRUE)
+      set(HAVE_OPENGL TRUE)
     endif()
 
-    if(VIDEO_OPENGLES)
+    if(SDL_OPENGLES)
       set(SDL_VIDEO_OPENGL_EGL 1)
       set(SDL_VIDEO_OPENGL_ES2 1)
       set(SDL_VIDEO_RENDER_OGL_ES2 1)
-      set(HAVE_VIDEO_OPENGLES TRUE)
+      set(HAVE_OPENGLES TRUE)
+    endif()
+
+    if(SDL_VULKAN)
+      set(SDL_VIDEO_VULKAN 1)
+      set(HAVE_VULKAN TRUE)
     endif()
   endif()
 
-  if(SDL_JOYSTICK)
+  if(SDL_HIDAPI)
     CheckHIDAPI()
-    # TODO: Remove this hid.c block when SDL_hidapi.c is supported on Windows!
-    if(HAVE_HIDAPI)
-      set(SOURCE_FILES ${SOURCE_FILES} ${SDL2_SOURCE_DIR}/src/hidapi/windows/hid.c)
-    endif()
+  endif()
+
+  if(SDL_JOYSTICK)
     file(GLOB JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/windows/*.c)
     set(SOURCE_FILES ${SOURCE_FILES} ${JOYSTICK_SOURCES})
+
+    if(NOT WINDOWS_STORE)
+      set(SDL_JOYSTICK_RAWINPUT 1)
+    endif()
     if(HAVE_DINPUT_H)
       set(SDL_JOYSTICK_DINPUT 1)
       list(APPEND EXTRA_LIBS dinput8)
     endif()
     if(HAVE_XINPUT_H)
-      set(SDL_JOYSTICK_XINPUT 1)
-    endif()
-    if(NOT HAVE_DINPUT_H AND NOT HAVE_XINPUT_H)
-      set(SDL_JOYSTICK_WINMM 1)
+      if(NOT WINDOWS_STORE)
+        set(SDL_JOYSTICK_XINPUT 1)
+        set(HAVE_XINPUT TRUE)
+      endif()
+      if(HAVE_WINDOWS_GAMING_INPUT_H)
+        set(SDL_JOYSTICK_WGI 1)
+      endif()
     endif()
     set(HAVE_SDL_JOYSTICK TRUE)
 
     if(SDL_HAPTIC)
-      if(HAVE_DINPUT_H OR HAVE_XINPUT_H)
+      if((HAVE_DINPUT_H OR HAVE_XINPUT_H) AND NOT WINDOWS_STORE)
         file(GLOB HAPTIC_SOURCES ${SDL2_SOURCE_DIR}/src/haptic/windows/*.c)
         if(HAVE_DINPUT_H)
           set(SDL_HAPTIC_DINPUT 1)
@@ -1638,8 +1813,11 @@ elseif(WINDOWS)
   if(MINGW OR CYGWIN)
     list(APPEND EXTRA_LIBS mingw32)
     list(APPEND EXTRA_LDFLAGS "-mwindows")
-    set(SDL_CFLAGS "${SDL_CFLAGS} -Dmain=SDL_main")
-    list(APPEND SDL_LIBS "-lmingw32" "-lSDL2main" "-mwindows")
+    list(APPEND SDL_LIBS "-lmingw32" "-mwindows")
+    if(NOT SDL2_DISABLE_SDL2MAIN)
+      set(SDL_CFLAGS "${SDL_CFLAGS} -Dmain=SDL_main")
+      list(APPEND SDL_LIBS "-lSDL2main")
+    endif(NOT SDL2_DISABLE_SDL2MAIN)
   endif()
 
 elseif(APPLE)
@@ -1654,29 +1832,32 @@ elseif(APPLE)
     set(SDL_FRAMEWORK_CARBON 1)
   endif()
   set(SDL_FRAMEWORK_FOUNDATION 1)
+  set(SDL_FRAMEWORK_COREVIDEO 1)
 
   # Requires the darwin file implementation
   if(SDL_FILE)
     file(GLOB EXTRA_SOURCES ${SDL2_SOURCE_DIR}/src/file/cocoa/*.m)
     set(SOURCE_FILES ${EXTRA_SOURCES} ${SOURCE_FILES})
-    # !!! FIXME: modern CMake doesn't need "LANGUAGE C" for Objective-C.
-    set_source_files_properties(${EXTRA_SOURCES} PROPERTIES LANGUAGE C)
     set(HAVE_SDL_FILE TRUE)
-    # !!! FIXME: why is COREVIDEO inside this if() block?
-    set(SDL_FRAMEWORK_COREVIDEO 1)
-  else()
-    message_error("SDL_FILE must be enabled to build on MacOS X")
   endif()
 
-  file(GLOB MISC_SOURCES ${SDL2_SOURCE_DIR}/src/misc/macosx/*.m)
-  set(SOURCE_FILES ${SOURCE_FILES} ${MISC_SOURCES})
-  set(HAVE_SDL_MISC TRUE)
+  if(IOS OR TVOS)
+    file(GLOB SDLMAIN_SOURCES ${SDL2_SOURCE_DIR}/src/main/uikit/*.c)
+  endif()
+
+  if(SDL_MISC)
+    if(IOS OR TVOS)
+      file(GLOB MISC_SOURCES ${SDL2_SOURCE_DIR}/src/misc/ios/*.m)
+    else()
+      file(GLOB MISC_SOURCES ${SDL2_SOURCE_DIR}/src/misc/macosx/*.m)
+    endif()
+    set(SOURCE_FILES ${SOURCE_FILES} ${MISC_SOURCES})
+    set(HAVE_SDL_MISC TRUE)
+  endif()
 
   if(SDL_AUDIO)
     set(SDL_AUDIO_DRIVER_COREAUDIO 1)
     file(GLOB AUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/coreaudio/*.m)
-    # !!! FIXME: modern CMake doesn't need "LANGUAGE C" for Objective-C.
-    set_source_files_properties(${AUDIO_SOURCES} PROPERTIES LANGUAGE C)
     set(SOURCE_FILES ${SOURCE_FILES} ${AUDIO_SOURCES})
     set(HAVE_SDL_AUDIO TRUE)
     set(SDL_FRAMEWORK_COREAUDIO 1)
@@ -1684,30 +1865,52 @@ elseif(APPLE)
     set(SDL_FRAMEWORK_AVFOUNDATION 1)
   endif()
 
-  if(SDL_JOYSTICK)
+  if(SDL_HIDAPI)
     CheckHIDAPI()
-    if(HAVE_HIDAPI)
-      if(IOS OR TVOS)
-        set(SOURCE_FILES ${SOURCE_FILES} ${SDL2_SOURCE_DIR}/src/hidapi/ios/hid.m)
-        set(SDL_FRAMEWORK_COREBLUETOOTH 1)
-      endif()
-    endif()
+  endif()
+
+  if(SDL_JOYSTICK)
+    file(GLOB MFI_JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/iphoneos/*.m)
     if(IOS OR TVOS)
-      file(GLOB JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/iphoneos/*.m ${SDL2_SOURCE_DIR}/src/joystick/steam/*.c)
+      file(GLOB JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/steam/*.c)
       set(SDL_JOYSTICK_MFI 1)
       if(IOS)
         set(SDL_FRAMEWORK_COREMOTION 1)
       endif()
       set(SDL_FRAMEWORK_GAMECONTROLLER 1)
-      set(HAVE_SDL_SENSORS 1)
+      set(SDL_FRAMEWORK_COREHAPTICS 1)
     else()
-      file(GLOB JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/darwin/*.c ${SDL2_SOURCE_DIR}/src/joystick/iphoneos/*.m)
-      # FIXME: add checks for SDL_JOYSTICK_MFI???
+      file(GLOB JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/darwin/*.c)
+      set_source_files_properties(${MFI_JOYSTICK_SOURCES} PROPERTIES COMPILE_FLAGS -fobjc-weak)
+      check_objc_source_compiles("
+          #include <AvailabilityMacros.h>
+          #include <TargetConditionals.h>
+          #import <Foundation/Foundation.h>
+          #import <GameController/GameController.h>
+          #if MAC_OS_X_VERSION_MIN_REQUIRED < 1080
+          #error GameController framework doesn't work on this configuration
+          #endif
+          #if TARGET_CPU_X86
+          #error GameController framework doesn't work on this configuration
+          #endif
+          int main() { return 0; }" HAVE_FRAMEWORK_GAMECONTROLLER)
+      check_objc_source_compiles("
+          #include <AvailabilityMacros.h>
+          #include <TargetConditionals.h>
+          #import <Foundation/Foundation.h>
+          #import <CoreHaptics/CoreHaptics.h>
+          int main() { return 0; }" HAVE_FRAMEWORK_COREHAPTICS)
+      if(HAVE_FRAMEWORK_GAMECONTROLLER AND HAVE_FRAMEWORK_COREHAPTICS)
+        # Only enable MFI if we also have CoreHaptics to ensure rumble works
+        set(SDL_JOYSTICK_MFI 1)
+        set(SDL_FRAMEWORK_GAMECONTROLLER 1)
+        set(SDL_FRAMEWORK_COREHAPTICS 1)
+      endif()
       set(SDL_JOYSTICK_IOKIT 1)
       set(SDL_FRAMEWORK_IOKIT 1)
       set(SDL_FRAMEWORK_FF 1)
     endif()
-    set(SOURCE_FILES ${SOURCE_FILES} ${JOYSTICK_SOURCES})
+    set(SOURCE_FILES ${SOURCE_FILES} ${JOYSTICK_SOURCES} ${MFI_JOYSTICK_SOURCES})
     set(HAVE_SDL_JOYSTICK TRUE)
   endif()
 
@@ -1723,9 +1926,6 @@ elseif(APPLE)
     endif()
     set(SOURCE_FILES ${SOURCE_FILES} ${HAPTIC_SOURCES})
     set(HAVE_SDL_HAPTIC TRUE)
-    if(NOT SDL_JOYSTICK)
-      message(FATAL_ERROR "SDL_HAPTIC requires SDL_JOYSTICK to be enabled")
-    endif()
   endif()
 
   if(SDL_POWER)
@@ -1757,8 +1957,6 @@ elseif(APPLE)
   if(SDL_FILESYSTEM)
     set(SDL_FILESYSTEM_COCOA 1)
     file(GLOB FILESYSTEM_SOURCES ${SDL2_SOURCE_DIR}/src/filesystem/cocoa/*.m)
-    # !!! FIXME: modern CMake doesn't need "LANGUAGE C" for Objective-C.
-    set_source_files_properties(${FILESYSTEM_SOURCES} PROPERTIES LANGUAGE C)
     set(SOURCE_FILES ${SOURCE_FILES} ${FILESYSTEM_SOURCES})
     set(HAVE_SDL_FILESYSTEM TRUE)
   endif()
@@ -1783,17 +1981,18 @@ elseif(APPLE)
       set(SDL_IPHONE_LAUNCHSCREEN 1)
       file(GLOB UIKITVIDEO_SOURCES ${SDL2_SOURCE_DIR}/src/video/uikit/*.m)
       set(SOURCE_FILES ${SOURCE_FILES} ${UIKITVIDEO_SOURCES})
+      set(HAVE_SDL_VIDEO TRUE)
     else()
       CheckCOCOA()
-      if(VIDEO_OPENGL)
+      if(SDL_OPENGL)
         set(SDL_VIDEO_OPENGL 1)
         set(SDL_VIDEO_OPENGL_CGL 1)
         set(SDL_VIDEO_RENDER_OGL 1)
-        set(HAVE_VIDEO_OPENGL TRUE)
+        set(HAVE_OPENGL TRUE)
       endif()
     endif()
 
-    if(VIDEO_OPENGLES)
+    if(SDL_OPENGLES)
       if(IOS OR TVOS)
         set(SDL_FRAMEWORK_OPENGLES 1)
         set(SDL_VIDEO_OPENGL_ES 1)
@@ -1803,47 +2002,38 @@ elseif(APPLE)
       endif()
       set(SDL_VIDEO_OPENGL_ES2 1)
       set(SDL_VIDEO_RENDER_OGL_ES2 1)
-      set(HAVE_VIDEO_OPENGLES TRUE)
+      set(HAVE_OPENGLES TRUE)
     endif()
 
-    if(VIDEO_VULKAN OR VIDEO_METAL OR RENDER_METAL)
-      set(ORIG_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
-      set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -ObjC")
-      check_c_source_compiles("
+    if(SDL_VULKAN OR SDL_METAL OR SDL_RENDER_METAL)
+      check_objc_source_compiles("
         #include <AvailabilityMacros.h>
         #import <Metal/Metal.h>
         #import <QuartzCore/CAMetalLayer.h>
 
-        #if TARGET_OS_SIMULATOR || (!TARGET_CPU_X86_64 && !TARGET_CPU_ARM64)
+        #if (!TARGET_CPU_X86_64 && !TARGET_CPU_ARM64)
         #error Metal doesn't work on this configuration
         #endif
-        int main()
-        {
-            return 0;
-        }
-        " HAVE_FRAMEWORK_METAL)
-      set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS})
+        int main(int argc, char **argv) { return 0; }" HAVE_FRAMEWORK_METAL)
       if(HAVE_FRAMEWORK_METAL)
         set(SDL_FRAMEWORK_METAL 1)
         set(SDL_FRAMEWORK_QUARTZCORE 1)
-      else()
-        set(VIDEO_VULKAN 0)
-        set(VIDEO_METAL 0)
-        set(RENDER_METAL 0)
+        if(SDL_VULKAN)
+          set(SDL_VIDEO_VULKAN 1)
+          set(HAVE_VULKAN TRUE)
+        endif()
+        if(SDL_METAL)
+          set(SDL_VIDEO_METAL 1)
+          set(HAVE_METAL TRUE)
+        endif()
+        if(SDL_RENDER_METAL)
+          file(GLOB RENDER_METAL_SOURCES ${SDL2_SOURCE_DIR}/src/render/metal/*.m)
+          set(SOURCE_FILES ${SOURCE_FILES} ${RENDER_METAL_SOURCES})
+          set(SDL_VIDEO_RENDER_METAL 1)
+          set(HAVE_RENDER_METAL TRUE)
+        endif()
       endif()
     endif()
-
-    if(VIDEO_METAL)
-      set(SDL_VIDEO_METAL 1)
-      set(HAVE_VIDEO_METAL TRUE)
-    endif()
-
-    if(RENDER_METAL)
-      file(GLOB RENDER_METAL_SOURCES ${SDL2_SOURCE_DIR}/src/render/metal/*.m)
-      set(SOURCE_FILES ${SOURCE_FILES} ${RENDER_METAL_SOURCES})
-      set(SDL_VIDEO_RENDER_METAL 1)
-      set(HAVE_RENDER_METAL TRUE)
-    endif()
   endif()
 
   # Actually load the frameworks at the end so we don't duplicate include.
@@ -1897,7 +2087,9 @@ elseif(APPLE)
   endif()
   if(SDL_FRAMEWORK_GAMECONTROLLER)
     find_library(GAMECONTROLLER GameController)
-    list(APPEND EXTRA_LIBS ${GAMECONTROLLER})
+    if(GAMECONTROLLER)
+      list(APPEND EXTRA_LDFLAGS "-Wl,-weak_framework,GameController")
+    endif()
   endif()
   if(SDL_FRAMEWORK_METAL)
     if(IOS OR TVOS)
@@ -1923,34 +2115,58 @@ elseif(APPLE)
     find_library(UIKIT UIKit)
     list(APPEND EXTRA_LIBS ${UIKIT})
   endif()
+  if(SDL_FRAMEWORK_COREHAPTICS)
+    find_library(COREHAPTICS CoreHaptics)
+    if(COREHAPTICS)
+      list(APPEND EXTRA_LDFLAGS "-Wl,-weak_framework,CoreHaptics")
+    endif()
+  endif()
 
   CheckPTHREAD()
 
 elseif(HAIKU)
-  file(GLOB MISC_SOURCES ${SDL2_SOURCE_DIR}/src/misc/haiku/*.cc)
-  set(SOURCE_FILES ${SOURCE_FILES} ${MISC_SOURCES})
-  set(HAVE_SDL_MISC TRUE)
+  if(SDL_AUDIO)
+    set(SDL_AUDIO_DRIVER_HAIKU 1)
+    file(GLOB HAIKU_AUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/haiku/*.cc)
+    set(SOURCE_FILES ${SOURCE_FILES} ${HAIKU_AUDIO_SOURCES})
+    set(HAVE_SDL_AUDIO TRUE)
+  endif()
+
+  if(SDL_JOYSTICK)
+    set(SDL_JOYSTICK_HAIKU 1)
+    file(GLOB HAIKU_JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/haiku/*.cc)
+    set(SOURCE_FILES ${SOURCE_FILES} ${HAIKU_JOYSTICK_SOURCES})
+    set(HAVE_SDL_JOYSTICK TRUE)
+  endif()
+
+  if(SDL_MISC)
+    file(GLOB MISC_SOURCES ${SDL2_SOURCE_DIR}/src/misc/haiku/*.cc)
+    set(SOURCE_FILES ${SOURCE_FILES} ${MISC_SOURCES})
+    set(HAVE_SDL_MISC TRUE)
+  endif()
 
   if(SDL_VIDEO)
     set(SDL_VIDEO_DRIVER_HAIKU 1)
-    file(GLOB HAIKUVIDEO_SOURCES ${SDL2_SOURCE_DIR}/src/video/haiku/*.c)
+    file(GLOB HAIKUVIDEO_SOURCES ${SDL2_SOURCE_DIR}/src/video/haiku/*.cc)
     set(SOURCE_FILES ${SOURCE_FILES} ${HAIKUVIDEO_SOURCES})
     set(HAVE_SDL_VIDEO TRUE)
 
-    if(VIDEO_OPENGL)
+    if(SDL_OPENGL)
       # TODO: Use FIND_PACKAGE(OpenGL) instead
       set(SDL_VIDEO_OPENGL 1)
-      set(SDL_VIDEO_OPENGL_BGL 1)
+      set(SDL_VIDEO_OPENGL_HAIKU 1)
       set(SDL_VIDEO_RENDER_OGL 1)
       list(APPEND EXTRA_LIBS GL)
-      set(HAVE_VIDEO_OPENGL TRUE)
+      set(HAVE_OPENGL TRUE)
     endif()
   endif()
 
-  set(SDL_FILESYSTEM_HAIKU 1)
-  file(GLOB FILESYSTEM_SOURCES ${SDL2_SOURCE_DIR}/src/filesystem/haiku/*.cc)
-  set(SOURCE_FILES ${SOURCE_FILES} ${FILESYSTEM_SOURCES})
-  set(HAVE_SDL_FILESYSTEM TRUE)
+  if(SDL_FILESYSTEM)
+    set(SDL_FILESYSTEM_HAIKU 1)
+    file(GLOB FILESYSTEM_SOURCES ${SDL2_SOURCE_DIR}/src/filesystem/haiku/*.cc)
+    set(SOURCE_FILES ${SOURCE_FILES} ${FILESYSTEM_SOURCES})
+    set(HAVE_SDL_FILESYSTEM TRUE)
+  endif()
 
   if(SDL_TIMERS)
     set(SDL_TIMER_HAIKU 1)
@@ -1959,18 +2175,45 @@ elseif(HAIKU)
     set(HAVE_SDL_TIMERS TRUE)
   endif()
 
+  if(SDL_POWER)
+    set(SDL_POWER_HAIKU 1)
+    file(GLOB HAIKU_POWER_SOURCES ${SDL2_SOURCE_DIR}/src/power/haiku/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${HAIKU_POWER_SOURCES})
+    set(HAVE_SDL_POWER TRUE)
+  endif()
+
   if(SDL_LOCALE)
     file(GLOB LOCALE_SOURCES ${SDL2_SOURCE_DIR}/src/locale/haiku/*.cc)
     set(SOURCE_FILES ${SOURCE_FILES} ${LOCALE_SOURCES})
     set(HAVE_SDL_LOCALE TRUE)
   endif()
 
+  file(GLOB MAIN_SOURCES ${SDL2_SOURCE_DIR}/src/main/haiku/*.cc)
+  set(SOURCE_FILES ${SOURCE_FILES} ${MAIN_SOURCES})
+
   CheckPTHREAD()
+  list(APPEND EXTRA_LIBS root be media game device textencoding)
 
 elseif(RISCOS)
-  file(GLOB MISC_SOURCES ${SDL2_SOURCE_DIR}/src/misc/riscos/*.c)
-  set(SOURCE_FILES ${SOURCE_FILES} ${MISC_SOURCES})
-  set(HAVE_SDL_MISC TRUE)
+  if(SDL_MISC)
+    file(GLOB MISC_SOURCES ${SDL2_SOURCE_DIR}/src/misc/riscos/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${MISC_SOURCES})
+    set(HAVE_SDL_MISC TRUE)
+  endif()
+
+  if(SDL_VIDEO)
+    set(SDL_VIDEO_DRIVER_RISCOS 1)
+    file(GLOB RISCOSVIDEO_SOURCES ${SDL2_SOURCE_DIR}/src/video/riscos/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${RISCOSVIDEO_SOURCES})
+    set(HAVE_SDL_VIDEO TRUE)
+  endif()
+
+  if(SDL_FILESYSTEM)
+    set(SDL_FILESYSTEM_RISCOS 1)
+    file(GLOB FILESYSTEM_SOURCES ${SDL2_SOURCE_DIR}/src/filesystem/riscos/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${FILESYSTEM_SOURCES})
+    set(HAVE_SDL_FILESYSTEM TRUE)
+  endif()
 
   if(SDL_TIMERS)
     set(SDL_TIMER_UNIX 1)
@@ -1978,7 +2221,7 @@ elseif(RISCOS)
     set(SOURCE_FILES ${SOURCE_FILES} ${TIMER_SOURCES})
     set(HAVE_SDL_TIMERS TRUE)
 
-    if(CLOCK_GETTIME)
+    if(SDL_CLOCK_GETTIME)
       set(HAVE_CLOCK_GETTIME 1)
     endif()
   endif()
@@ -1988,11 +2231,302 @@ elseif(RISCOS)
   if(SDL_AUDIO)
     CheckOSS()
   endif()
+
+elseif(VITA)
+  # SDL_spinlock.c Needs to be compiled in ARM mode.
+  check_c_compiler_flag(-marm HAVE_ARM_MODE)
+  if(HAVE_ARM_MODE)
+    set_source_files_properties(${SDL2_SOURCE_DIR}/src/atomic/SDL_spinlock.c PROPERTIES COMPILE_FLAGS -marm)
+  endif()
+
+  if(SDL_MISC)
+    file(GLOB MISC_SOURCES ${SDL2_SOURCE_DIR}/src/misc/vita/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${MISC_SOURCES})
+    set(HAVE_SDL_MISC TRUE)
+  endif()
+
+  if(SDL_AUDIO)
+    set(SDL_AUDIO_DRIVER_VITA 1)
+    file(GLOB VITA_AUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/vita/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${VITA_AUDIO_SOURCES})
+    set(HAVE_SDL_AUDIO TRUE)
+  endif()
+  if(SDL_FILESYSTEM)
+    set(SDL_FILESYSTEM_VITA 1)
+    file(GLOB VITA_FILESYSTEM_SOURCES ${SDL2_SOURCE_DIR}/src/filesystem/vita/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${VITA_FILESYSTEM_SOURCES})
+    set(HAVE_SDL_FILESYSTEM TRUE)
+  endif()
+  if(SDL_JOYSTICK)
+    set(SDL_JOYSTICK_VITA 1)
+    file(GLOB VITA_JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/vita/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${VITA_JOYSTICK_SOURCES})
+    set(HAVE_SDL_JOYSTICK TRUE)
+  endif()
+  if(SDL_POWER)
+    set(SDL_POWER_VITA 1)
+    file(GLOB VITA_POWER_SOURCES ${SDL2_SOURCE_DIR}/src/power/vita/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${VITA_POWER_SOURCES})
+    set(HAVE_SDL_POWER TRUE)
+  endif()
+  if(SDL_THREADS)
+    set(SDL_THREAD_VITA 1)
+    set(SOURCE_FILES ${SOURCE_FILES}
+      ${SDL2_SOURCE_DIR}/src/thread/vita/SDL_sysmutex.c
+      ${SDL2_SOURCE_DIR}/src/thread/vita/SDL_syssem.c
+      ${SDL2_SOURCE_DIR}/src/thread/vita/SDL_systhread.c
+      ${SDL2_SOURCE_DIR}/src/thread/vita/SDL_syscond.c
+      ${SDL2_SOURCE_DIR}/src/thread/generic/SDL_systls.c)
+    set(HAVE_SDL_THREADS TRUE)
+  endif()
+  if(SDL_TIMERS)
+    set(SDL_TIMER_VITA 1)
+    file(GLOB TIMER_SOURCES ${SDL2_SOURCE_DIR}/src/timer/vita/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${TIMER_SOURCES})
+    set(HAVE_SDL_TIMERS TRUE)
+  endif()
+  if(SDL_SENSOR)
+    set(SDL_SENSOR_VITA 1)
+    set(HAVE_SDL_SENSORS TRUE)
+    file(GLOB VITA_SENSOR_SOURCES ${SDL2_SOURCE_DIR}/src/sensor/vita/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${VITA_SENSOR_SOURCES})
+  endif()
+  if(SDL_VIDEO)
+    set(SDL_VIDEO_DRIVER_VITA 1)
+    file(GLOB VITA_VIDEO_SOURCES ${SDL2_SOURCE_DIR}/src/video/vita/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${VITA_VIDEO_SOURCES})
+    set(HAVE_SDL_VIDEO TRUE)
+
+    if(VIDEO_VITA_PIB)
+      check_include_file(pib.h HAVE_PIGS_IN_BLANKET_H)
+
+      if(HAVE_PIGS_IN_BLANKET_H)
+        set(SDL_VIDEO_OPENGL_ES2 1)
+        list(APPEND EXTRA_LIBS
+          pib
+        )
+        set(HAVE_VITA_PIB ON)
+        set(SDL_VIDEO_VITA_PIB 1)
+      else()
+        set(HAVE_VITA_PIB OFF)
+      endif()
+    endif()
+
+    if(VIDEO_VITA_PVR)
+      check_include_file(gpu_es4/psp2_pvr_hint.h HAVE_PVR_H)
+      if(HAVE_PVR_H)
+        target_compile_definitions(sdl-build-options INTERFACE "-D__psp2__")
+        set(SDL_VIDEO_OPENGL_EGL 1)
+        set(HAVE_OPENGLES TRUE)
+        set(SDL_VIDEO_OPENGL_ES 1)
+        set(SDL_VIDEO_RENDER_OGL_ES 1)
+        set(SDL_VIDEO_OPENGL_ES2 1)
+        set(SDL_VIDEO_RENDER_OGL_ES2 1)
+
+        list(APPEND EXTRA_LIBS
+          libgpu_es4_ext_stub_weak
+          libIMGEGL_stub_weak
+        )
+        set(HAVE_VITA_PVR ON)
+        set(SDL_VIDEO_VITA_PVR 1)
+      else()
+        set(HAVE_VITA_PVR OFF)
+      endif()
+    endif()
+
+    set(SDL_VIDEO_RENDER_VITA_GXM 1)
+
+    list(APPEND EXTRA_LIBS
+      SceGxm_stub
+      SceDisplay_stub
+      SceCtrl_stub
+      SceAppMgr_stub
+      SceAudio_stub
+      SceSysmodule_stub
+      SceDisplay_stub
+      SceCtrl_stub
+      SceIofilemgr_stub
+      SceCommonDialog_stub
+      SceTouch_stub
+      SceHid_stub
+      SceMotion_stub
+      ScePower_stub
+      SceProcessmgr_stub
+      m
+    )
+    if(HAVE_VITA_PIB)
+        list(PREPEND EXTRA_LIBS
+          pib
+          libScePiglet_stub
+          SceShaccCg_stub
+          taihen_stub
+        )
+    endif()
+    if(HAVE_VITA_PVR)
+        list(PREPEND EXTRA_LIBS
+          SceIme_stub
+        )
+    endif()
+  endif()
+
+#  set(HAVE_ARMSIMD TRUE)
+#  set(SDL_ARM_SIMD_BLITTERS 1)
+#  file(GLOB ARMSIMD_SOURCES ${SDL2_SOURCE_DIR}/src/video/arm/pixman-arm-simd*.S)
+#  set(SOURCE_FILES ${SOURCE_FILES} ${ARMSIMD_SOURCES})
+
+#  set(HAVE_ARMNEON TRUE)
+#  set(SDL_ARM_NEON_BLITTERS 1)
+#  file(GLOB ARMNEON_SOURCES ${SDL2_SOURCE_DIR}/src/video/arm/pixman-arm-neon*.S)
+#  set(SOURCE_FILES ${SOURCE_FILES} ${ARMNEON_SOURCES})
+
+#  set_property(SOURCE ${SDL2_SOURCE_DIR}/src/video/arm/pixman-arm-simd-asm.S PROPERTY LANGUAGE C)
+#  set_property(SOURCE ${SDL2_SOURCE_DIR}/src/video/arm/pixman-arm-neon-asm.S PROPERTY LANGUAGE C)
+
+  target_compile_definitions(sdl-build-options INTERFACE "-D__VITA__")
+  target_compile_definitions(sdl-build-options INTERFACE "-Dmemcpy=sceClibMemcpy")
+  target_compile_definitions(sdl-build-options INTERFACE "-Dmemset=sceClibMemset")
+  target_compile_definitions(sdl-build-options INTERFACE "-Dmemmove=sceClibMemmove")
+  target_compile_definitions(sdl-build-options INTERFACE "-Dmemcmp=sceClibMemcmp")
+
+#  CheckPTHREAD()
+
+elseif(PSP)
+ file(GLOB PSP_MAIN_SOURCES ${SDL2_SOURCE_DIR}/src/main/psp/*.c)
+ set(SDLMAIN_SOURCES ${SDLMAIN_SOURCES} ${PSP_MAIN_SOURCES})
+
+  if(SDL_AUDIO)
+    set(SDL_AUDIO_DRIVER_PSP 1)
+    file(GLOB PSP_AUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/psp/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${PSP_AUDIO_SOURCES})
+    set(HAVE_SDL_AUDIO TRUE)
+  endif()
+  if(SDL_FILESYSTEM)
+    set(SDL_FILESYSTEM_PSP 1)
+    file(GLOB PSP_FILESYSTEM_SOURCES ${SDL2_SOURCE_DIR}/src/filesystem/psp/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${PSP_FILESYSTEM_SOURCES})
+    set(HAVE_SDL_FILESYSTEM TRUE)
+  endif()
+  if(SDL_JOYSTICK)
+    set(SDL_JOYSTICK_PSP 1)
+    file(GLOB PSP_JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/psp/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${PSP_JOYSTICK_SOURCES})
+    set(HAVE_SDL_JOYSTICK TRUE)
+  endif()
+  if(SDL_POWER)
+    set(SDL_POWER_PSP 1)
+    file(GLOB PSP_POWER_SOURCES ${SDL2_SOURCE_DIR}/src/power/psp/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${PSP_POWER_SOURCES})
+    set(HAVE_SDL_POWER TRUE)
+  endif()
+  if(SDL_THREADS)
+    set(SDL_THREAD_PSP 1)
+    file(GLOB PSP_THREAD_SOURCES ${SDL2_SOURCE_DIR}/src/thread/generic/SDL_systls.c ${SDL2_SOURCE_DIR}/src/thread/psp/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${PSP_THREAD_SOURCES})
+    set(HAVE_SDL_THREADS TRUE)
+  endif()
+  if(SDL_TIMERS)
+    set(SDL_TIMER_PSP 1)
+    file(GLOB PSP_TIMER_SOURCES ${SDL2_SOURCE_DIR}/src/timer/psp/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${PSP_TIMER_SOURCES})
+    set(HAVE_SDL_TIMERS TRUE)
+  endif()
+  if(SDL_VIDEO)
+    set(SDL_VIDEO_DRIVER_PSP 1)
+    set(SDL_VIDEO_RENDER_PSP 1)
+    file(GLOB PSP_VIDEO_SOURCES ${SDL2_SOURCE_DIR}/src/video/psp/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${PSP_VIDEO_SOURCES})
+    set(SDL_VIDEO_OPENGL 1)
+    set(HAVE_SDL_VIDEO TRUE)
+  endif()
+
+  list(APPEND EXTRA_LIBS
+      psppower
+      pspctrl
+      psphprm
+      pspge
+      pspgu
+      pspdisplay
+      pspvfpu
+      pspaudio
+      pspvram
+      GL
+    )
+
+elseif(OS2)
+  list(APPEND EXTRA_CFLAGS "-DOS2EMX_PLAIN_CHAR")
+
+  file(GLOB CORE_SOURCES ${SDL2_SOURCE_DIR}/src/core/os2/*.c)
+  set(SOURCE_FILES ${SOURCE_FILES} ${CORE_SOURCES})
+  if(NOT (HAVE_ICONV AND HAVE_ICONV_H))
+    file(GLOB CORE_SOURCES ${SDL2_SOURCE_DIR}/src/core/os2/geniconv/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${CORE_SOURCES})
+  endif()
+
+  if(SDL_THREADS)
+    set(SDL_THREAD_OS2 1)
+    file(GLOB OS2_THREAD_SOURCES ${SDL2_SOURCE_DIR}/src/thread/os2/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${OS2_THREAD_SOURCES})
+    set(HAVE_SDL_THREADS TRUE)
+  endif()
+
+  if(SDL_TIMERS)
+    set(SDL_TIMER_UNIX 1)
+    file(GLOB OS2_TIMER_SOURCES ${SDL2_SOURCE_DIR}/src/timer/os2/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${OS2_TIMER_SOURCES})
+    set(HAVE_SDL_TIMERS TRUE)
+  endif()
+
+  if(SDL_LOADSO)
+    set(SDL_LOADSO_OS2 1)
+    file(GLOB OS2_LOADSO_SOURCES ${SDL2_SOURCE_DIR}/src/loadso/os2/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${OS2_LOADSO_SOURCES})
+    set(HAVE_SDL_LOADSO TRUE)
+  endif()
+
+  if(SDL_FILESYSTEM)
+    set(SDL_FILESYSTEM_OS2 1)
+    file(GLOB FILESYSTEM_SOURCES ${SDL2_SOURCE_DIR}/src/filesystem/os2/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${FILESYSTEM_SOURCES})
+    set(HAVE_SDL_FILESYSTEM TRUE)
+  endif()
+
+  if(SDL_LOCALE)
+    file(GLOB LOCALE_SOURCES ${SDL2_SOURCE_DIR}/src/locale/unix/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${LOCALE_SOURCES})
+    set(HAVE_SDL_LOCALE TRUE)
+  endif()
+
+  if(SDL_VIDEO)
+    set(SDL_VIDEO_DRIVER_OS2 1)
+    file(GLOB OS2_VIDEO_SOURCES ${SDL2_SOURCE_DIR}/src/video/os2/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${OS2_VIDEO_SOURCES})
+    set(HAVE_SDL_VIDEO TRUE)
+  endif()
+
+  if(SDL_AUDIO)
+    set(SDL_AUDIO_DRIVER_OS2 1)
+    file(GLOB OS2_AUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/os2/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${OS2_AUDIO_SOURCES})
+    set(HAVE_SDL_AUDIO TRUE)
+    list(APPEND EXTRA_LIBS mmpm2)
+  endif()
+
+  if(SDL_JOYSTICK)
+    set(SDL_JOYSTICK_OS2 1)
+    file(GLOB OS2_JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/os2/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${OS2_JOYSTICK_SOURCES})
+    set(HAVE_SDL_JOYSTICK TRUE)
+  endif()
+
+  if(SDL_HIDAPI)
+    CheckHIDAPI()
+  endif()
 endif()
 
-if(VIDEO_VULKAN)
-  set(SDL_VIDEO_VULKAN 1)
-  set(HAVE_VIDEO_VULKAN TRUE)
+if(HAVE_VULKAN AND NOT SDL_LOADSO)
+  message(STATUS "Vulkan support is available, but disabled because there's no loadso.")
+  set(HAVE_VULKAN FALSE)
+  set(SDL_VIDEO_VULKAN 0)
 endif()
 
 # Dummies
@@ -2003,12 +2537,20 @@ endif()
 # so it always adds a dummy, without checking, if it was actually requested.
 # This leads to missing internal references on building, since the
 # src/X/*.c does not get included.
+if(NOT HAVE_SDL_AUDIO)
+  set(SDL_AUDIO_DRIVER_DUMMY 1)
+  file(GLOB AUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/dummy/*.c)
+  set(SOURCE_FILES ${SOURCE_FILES} ${AUDIO_SOURCES})
+endif()
+if(NOT HAVE_SDL_VIDEO)
+  set(SDL_VIDEO_DRIVER_DUMMY 1)
+  file(GLOB VIDEO_SOURCES ${SDL2_SOURCE_DIR}/src/video/dummy/*.c)
+  set(SOURCE_FILES ${SOURCE_FILES} ${VIDEO_SOURCES})
+endif()
 if(NOT HAVE_SDL_JOYSTICK)
   set(SDL_JOYSTICK_DUMMY 1)
-  if(SDL_JOYSTICK AND NOT APPLE) # results in unresolved symbols on OSX
-    file(GLOB JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/dummy/*.c)
-    set(SOURCE_FILES ${SOURCE_FILES} ${JOYSTICK_SOURCES})
-  endif()
+  file(GLOB JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/dummy/*.c)
+  set(SOURCE_FILES ${SOURCE_FILES} ${JOYSTICK_SOURCES})
 endif()
 if(NOT HAVE_SDL_HAPTIC)
   set(SDL_HAPTIC_DUMMY 1)
@@ -2021,24 +2563,24 @@ if(NOT HAVE_SDL_SENSORS)
   set(SOURCE_FILES ${SOURCE_FILES} ${SENSORS_SOURCES})
 endif()
 if(NOT HAVE_SDL_LOADSO)
-  set(SDL_LOADSO_DISABLED 1)
+  set(SDL_LOADSO_DUMMY 1)
   file(GLOB LOADSO_SOURCES ${SDL2_SOURCE_DIR}/src/loadso/dummy/*.c)
   set(SOURCE_FILES ${SOURCE_FILES} ${LOADSO_SOURCES})
 endif()
 if(NOT HAVE_SDL_FILESYSTEM)
-  set(SDL_FILESYSTEM_DISABLED 1)
+  set(SDL_FILESYSTEM_DUMMY 1)
   file(GLOB FILESYSTEM_SOURCES ${SDL2_SOURCE_DIR}/src/filesystem/dummy/*.c)
   set(SOURCE_FILES ${SOURCE_FILES} ${FILESYSTEM_SOURCES})
 endif()
 if(NOT HAVE_SDL_LOCALE)
-  set(SDL_LOCALE_DISABLED 1)
+  set(SDL_LOCALE_DUMMY 1)
   file(GLOB LOCALE_SOURCES ${SDL2_SOURCE_DIR}/src/locale/dummy/*.c)
   set(SOURCE_FILES ${SOURCE_FILES} ${LOCALE_SOURCES})
 endif()
 if(NOT HAVE_SDL_MISC)
-  set(SDL_MISC_DISABLED 1)
-  file(GLOB LOCALE_SOURCES ${SDL2_SOURCE_DIR}/src/misc/dummy/*.c)
-  set(SOURCE_FILES ${SOURCE_FILES} ${LOCALE_SOURCES})
+  set(SDL_MISC_DUMMY 1)
+  file(GLOB MISC_SOURCES ${SDL2_SOURCE_DIR}/src/misc/dummy/*.c)
+  set(SOURCE_FILES ${SOURCE_FILES} ${MISC_SOURCES})
 endif()
 
 # We always need to have threads and timers around
@@ -2048,7 +2590,7 @@ if(NOT HAVE_SDL_THREADS)
   set(SOURCE_FILES ${SOURCE_FILES} ${THREADS_SOURCES})
 endif()
 if(NOT HAVE_SDL_TIMERS)
-  set(SDL_TIMERS_DISABLED 1)
+  set(SDL_TIMER_DUMMY 1)
   file(GLOB TIMER_SOURCES ${SDL2_SOURCE_DIR}/src/timer/dummy/*.c)
   set(SOURCE_FILES ${SOURCE_FILES} ${TIMER_SOURCES})
 endif()
@@ -2081,17 +2623,42 @@ listtostr(EXTRA_CFLAGS _EXTRA_CFLAGS)
 set(EXTRA_CFLAGS ${_EXTRA_CFLAGS})
 
 # Compat helpers for the configuration files
-if(NOT CMAKE_HOST_WIN32)
-  # TODO: we need a Windows script, too
-  execute_process(COMMAND sh ${SDL2_SOURCE_DIR}/build-scripts/updaterev.sh
-    WORKING_DIRECTORY ${SDL2_BINARY_DIR})
+find_package(Git)
+if(Git_FOUND)
+  execute_process(COMMAND
+    "${GIT_EXECUTABLE}" remote get-url origin
+    WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
+    RESULT_VARIABLE GIT_URL_STATUS
+    OUTPUT_VARIABLE GIT_URL
+    ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+  execute_process(COMMAND
+    "${GIT_EXECUTABLE}" rev-list --max-count=1 HEAD~..
+    WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
+    RESULT_VARIABLE GIT_REVISION_STATUS
+    OUTPUT_VARIABLE GIT_REVISION
+    ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+  if(GIT_URL_STATUS EQUAL 0 OR GIT_REVISION_STATUS EQUAL 0)
+    set(SDL_REVISION "${GIT_URL}@${GIT_REVISION}")
+  else()
+    set(SDL_REVISION "")
+  endif()
+else()
+  set(SDL_REVISION "")
 endif()
-if(NOT WINDOWS OR CYGWIN)
+
+configure_file("${SDL2_SOURCE_DIR}/include/SDL_revision.h.cmake"
+  "${SDL2_BINARY_DIR}/include/SDL_revision.h")
+
+if(NOT WINDOWS OR CYGWIN OR MINGW)
+
   set(prefix ${CMAKE_INSTALL_PREFIX})
+
   set(exec_prefix "\${prefix}")
-  set(libdir "\${exec_prefix}/lib${LIB_SUFFIX}")
-  set(bindir "\${exec_prefix}/bin")
-  set(includedir "\${prefix}/include")
+  set(libdir "${CMAKE_INSTALL_FULL_LIBDIR}")
+  set(bindir "${CMAKE_INSTALL_FULL_BINDIR}")
+  set(includedir "${CMAKE_INSTALL_FULL_INCLUDEDIR}")
   if(SDL_STATIC)
     set(ENABLE_STATIC_TRUE "")
     set(ENABLE_STATIC_FALSE "#")
@@ -2100,24 +2667,34 @@ if(NOT WINDOWS OR CYGWIN)
     set(ENABLE_STATIC_FALSE "")
   endif()
   if(SDL_SHARED)
-    set(PKG_CONFIG_LIBS_PRIV "
+    set(PKGCONFIG_LIBS_PRIV "
 Libs.private:")
     set(ENABLE_SHARED_TRUE "")
     set(ENABLE_SHARED_FALSE "#")
   else()
-    set(PKG_CONFIG_LIBS_PRIV "")
+    set(PKGCONFIG_LIBS_PRIV "")
     set(ENABLE_SHARED_TRUE "#")
     set(ENABLE_SHARED_FALSE "")
   endif()
 
   # Clean up the different lists
-  listtostr(EXTRA_LIBS _EXTRA_LIBS "-l")
-  set(SDL_STATIC_LIBS ${EXTRA_LDFLAGS} ${_EXTRA_LIBS})
-  list(REMOVE_DUPLICATES SDL_STATIC_LIBS)
-  listtostr(SDL_STATIC_LIBS _SDL_STATIC_LIBS)
-  set(SDL_STATIC_LIBS ${_SDL_STATIC_LIBS})
-  listtostr(SDL_LIBS _SDL_LIBS)
-  set(SDL_LIBS ${_SDL_LIBS})
+  if (VITA)
+    listtostrrev(EXTRA_LIBS _EXTRA_LIBS "-l")
+    set(SDL_STATIC_LIBS ${SDL_LIBS} ${EXTRA_LDFLAGS} ${_EXTRA_LIBS})
+    list(REMOVE_DUPLICATES SDL_STATIC_LIBS)
+    listtostrrev(SDL_STATIC_LIBS _SDL_STATIC_LIBS)
+    set(SDL_STATIC_LIBS ${_SDL_STATIC_LIBS})
+    listtostrrev(SDL_LIBS _SDL_LIBS)
+    set(SDL_LIBS ${_SDL_LIBS})
+  else()
+    listtostr(EXTRA_LIBS _EXTRA_LIBS "-l")
+    set(SDL_STATIC_LIBS ${SDL_LIBS} ${EXTRA_LDFLAGS} ${_EXTRA_LIBS})
+    list(REMOVE_DUPLICATES SDL_STATIC_LIBS)
+    listtostr(SDL_STATIC_LIBS _SDL_STATIC_LIBS)
+    set(SDL_STATIC_LIBS ${_SDL_STATIC_LIBS})
+    listtostr(SDL_LIBS _SDL_LIBS)
+    set(SDL_LIBS ${_SDL_LIBS})
+  endif()
 
   # MESSAGE(STATUS "SDL_LIBS: ${SDL_LIBS}")
   # MESSAGE(STATUS "SDL_STATIC_LIBS: ${SDL_STATIC_LIBS}")
@@ -2132,6 +2709,71 @@ Libs.private:")
     "${SDL2_BINARY_DIR}/SDL2.spec" @ONLY)
 endif()
 
+macro(check_add_debug_flag FLAG SUFFIX)
+    check_c_compiler_flag(${FLAG} HAS_C_FLAG_${SUFFIX})
+    if (HAS_C_FLAG_${SUFFIX})
+        set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${FLAG}")
+    endif()
+
+    check_cxx_compiler_flag(${FLAG} HAS_CXX_${SUFFIX})
+    if (HAS_CXX_${SUFFIX})
+        set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${FLAG}")
+    endif()
+endmacro()
+
+macro(asan_check_add_debug_flag ASAN_FLAG)
+    check_add_debug_flag("-fsanitize=${ASAN_FLAG}" "${ASAN_FLAG}")
+    if(HAS_C_${ASAN_FLAG} OR HAS_CXX_${ASAN_FLAG})
+      set(HAVE_ASAN ON)
+    endif()
+endmacro()
+
+macro(asan_check_add_debug_flag2 ASAN_FLAG)
+    # for some sanitize flags we have to manipulate the CMAKE_REQUIRED_LIBRARIES:
+    # http://cmake.3232098.n2.nabble.com/CHECK-CXX-COMPILER-FLAG-doesn-t-give-correct-result-for-fsanitize-address-tp7600216p7600217.html
+
+    set(FLAG "-fsanitize=${ASAN_FLAG}")
+
+    set (STORED_REQLIBS ${CMAKE_REQUIRED_LIBRARIES})
+    set (CMAKE_REQUIRED_LIBRARIES "${FLAG};asan")
+    check_c_compiler_flag (${FLAG} HAS_C_FLAG_${ASAN_FLAG})
+    check_cxx_compiler_flag (${FLAG} HAS_CXX_FLAG_${ASAN_FLAG})
+    set (CMAKE_REQUIRED_LIBRARIES ${STORED_REQLIBS})
+
+    if (HAS_C_FLAG_${ASAN_FLAG})
+        set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${FLAG}")
+    endif()
+
+    if (HAS_CXX_${ASAN_FLAG})
+        set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${FLAG}")
+    endif()
+
+    if(HAS_C_${ASAN_FLAG} OR HAS_CXX_${ASAN_FLAG})
+      set(HAVE_ASAN ON)
+    endif()
+endmacro()
+
+# enable AddressSanitizer if supported
+if (SDL_ASAN)
+  asan_check_add_debug_flag2("address")
+  asan_check_add_debug_flag("bool")
+  asan_check_add_debug_flag("bounds")
+  asan_check_add_debug_flag("enum")
+  asan_check_add_debug_flag("float-cast-overflow")
+  asan_check_add_debug_flag("float-divide-by-zero")
+  asan_check_add_debug_flag("nonnull-attribute")
+  asan_check_add_debug_flag("returns-nonnull-attribute")
+  asan_check_add_debug_flag("signed-integer-overflow")
+  asan_check_add_debug_flag("undefined")
+  asan_check_add_debug_flag("vla-bound")
+  asan_check_add_debug_flag("leak")
+  # The object size sanitizer has no effect on unoptimized builds on Clang,
+  # but causes warnings.
+  if((NOT USE_CLANG) OR ("${CMAKE_BUILD_TYPE}" STREQUAL ""))
+    asan_check_add_debug_flag("object-size")
+  endif()
+endif()
+
 ##### Info output #####
 message(STATUS "")
 message(STATUS "SDL2 was configured with the following options:")
@@ -2139,6 +2781,7 @@ message(STATUS "")
 message(STATUS "Platform: ${CMAKE_SYSTEM}")
 message(STATUS "64-bit:   ${ARCH_64}")
 message(STATUS "Compiler: ${CMAKE_C_COMPILER}")
+message(STATUS "Revision: ${SDL_REVISION}")
 message(STATUS "")
 message(STATUS "Subsystems:")
 foreach(_SUB ${SDL_SUBSYSTEMS})
@@ -2149,13 +2792,17 @@ message(STATUS "")
 message(STATUS "Options:")
 list(SORT ALLOPTIONS)
 foreach(_OPT ${ALLOPTIONS})
-  # Longest option is VIDEO_X11_XSCREENSAVER = 22 characters
   # Get the padding
   string(LENGTH ${_OPT} _OPTLEN)
-  math(EXPR _PADLEN "23 - ${_OPTLEN}")
+  math(EXPR _PADLEN "(${LONGESTOPTIONNAME} + 1) - ${_OPTLEN}")
   string(RANDOM LENGTH ${_PADLEN} ALPHABET " " _PADDING)
   message_tested_option(${_OPT} ${_PADDING})
 endforeach()
+if("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
+  message(STATUS "")
+  message(STATUS " CMAKE_C_FLAGS_DEBUG:   ${CMAKE_C_FLAGS_DEBUG}")
+  message(STATUS " CMAKE_CXX_FLAGS_DEBUG: ${CMAKE_CXX_FLAGS_DEBUG}")
+endif()
 message(STATUS "")
 message(STATUS " CFLAGS:        ${CMAKE_C_FLAGS}")
 message(STATUS " EXTRA_CFLAGS:  ${EXTRA_CFLAGS}")
@@ -2181,7 +2828,7 @@ if(WARN_ABOUT_ARM_SIMD_ASM_MIT)
   message(STATUS "uses code licensed under the MIT license. If this is a")
   message(STATUS "problem, please disable that code by rerunning CMake with:")
   message(STATUS "")
-  message(STATUS "    -DARMSIMD=OFF")
+  message(STATUS "    -DSDL_ARMSIMD=OFF")
 endif()
 
 if(WARN_ABOUT_ARM_NEON_ASM_MIT)
@@ -2190,28 +2837,36 @@ if(WARN_ABOUT_ARM_NEON_ASM_MIT)
   message(STATUS "uses code licensed under the MIT license. If this is a")
   message(STATUS "problem, please disable that code by rerunning CMake with:")
   message(STATUS "")
-  message(STATUS "    -DARMNEON=OFF")
+  message(STATUS "    -DSDL_ARMNEON=OFF")
 endif()
 
 # Ensure that the extra cflags are used at compile time
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS}")
 
-# Always build SDLmain
-if(NOT WINDOWS_STORE)
-add_library(SDL2main STATIC ${SDLMAIN_SOURCES})
-target_include_directories(SDL2main PUBLIC "$<BUILD_INTERFACE:${SDL2_SOURCE_DIR}/include>" $<INSTALL_INTERFACE:include> $<INSTALL_INTERFACE:include/SDL2>)
-set(_INSTALL_LIBS "SDL2main")
-if (NOT ANDROID)
-  set_target_properties(SDL2main PROPERTIES DEBUG_POSTFIX "${SDL_CMAKE_DEBUG_POSTFIX}")
-endif()
+if(NOT WINDOWS_STORE AND NOT SDL2_DISABLE_SDL2MAIN)
+  # Build SDLmain
+  add_library(SDL2main STATIC ${SDLMAIN_SOURCES})
+  # alias target for in-tree builds
+  add_library(SDL2::SDL2main ALIAS SDL2main)
+  target_include_directories(SDL2main BEFORE PRIVATE "${SDL2_BINARY_DIR}/include")
+  target_include_directories(SDL2main PUBLIC "$<BUILD_INTERFACE:${SDL2_SOURCE_DIR}/include>" $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}> $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/SDL2>)
+  if (NOT ANDROID)
+    set_target_properties(SDL2main PROPERTIES DEBUG_POSTFIX "${SDL_CMAKE_DEBUG_POSTFIX}")
+  endif()
 endif()
 
-if (ANDROID AND HAVE_HIDAPI)
-  set(_INSTALL_LIBS ${_INSTALL_LIBS} "hidapi")
+if(ANDROID)
+  target_include_directories(sdl-build-options INTERFACE "${ANDROID_NDK}/sources/android/cpufeatures")
+endif()
+
+if(IOS OR TVOS)
+  target_compile_options(sdl-build-options INTERFACE "-fobjc-arc")
 endif()
 
 if(SDL_SHARED)
   add_library(SDL2 SHARED ${SOURCE_FILES} ${VERSION_SOURCES})
+  # alias target for in-tree builds
+  add_library(SDL2::SDL2 ALIAS SDL2)
   if(APPLE)
     set_target_properties(SDL2 PROPERTIES
       MACOSX_RPATH 1
@@ -2219,58 +2874,46 @@ if(SDL_SHARED)
   elseif(UNIX AND NOT ANDROID)
     set_target_properties(SDL2 PROPERTIES
       VERSION ${LT_VERSION}
-      SOVERSION ${LT_REVISION}
+      SOVERSION ${LT_MAJOR}
       OUTPUT_NAME "SDL2-${LT_RELEASE}")
   else()
     if(WINDOWS OR CYGWIN)
       set_target_properties(SDL2 PROPERTIES
         DEFINE_SYMBOL DLL_EXPORT)
+    elseif(OS2)
+      set_target_properties(SDL2 PROPERTIES
+        DEFINE_SYMBOL BUILD_SDL)
     endif()
     set_target_properties(SDL2 PROPERTIES
       VERSION ${SDL_VERSION}
       SOVERSION ${LT_REVISION}
       OUTPUT_NAME "SDL2")
   endif()
-  if(MSVC AND NOT LIBC)
+  # Note: The clang toolset for Visual Studio does not support /NODEFAULTLIB.
+  if(MSVC AND NOT SDL_LIBC AND NOT MSVC_CLANG)
     # Don't try to link with the default set of libraries.
-    set_target_properties(SDL2 PROPERTIES LINK_FLAGS_RELEASE "/NODEFAULTLIB")
-    set_target_properties(SDL2 PROPERTIES LINK_FLAGS_DEBUG "/NODEFAULTLIB")
+    if(NOT WINDOWS_STORE)
+      set_target_properties(SDL2 PROPERTIES LINK_FLAGS_RELEASE "/NODEFAULTLIB")
+      set_target_properties(SDL2 PROPERTIES LINK_FLAGS_DEBUG "/NODEFAULTLIB")
+    endif()
     set_target_properties(SDL2 PROPERTIES STATIC_LIBRARY_FLAGS "/NODEFAULTLIB")
   endif()
-  set(_INSTALL_LIBS "SDL2" ${_INSTALL_LIBS})
   target_link_libraries(SDL2 PRIVATE ${EXTRA_LIBS} ${EXTRA_LDFLAGS})
-  target_include_directories(SDL2 PUBLIC "$<BUILD_INTERFACE:${SDL2_SOURCE_DIR}/include>" $<INSTALL_INTERFACE:include> $<INSTALL_INTERFACE:include/SDL2>)
-  if(ANDROID)
-    target_include_directories(SDL2 PRIVATE ${ANDROID_NDK}/sources/android/cpufeatures)
-  else()
+  target_include_directories(SDL2 BEFORE PRIVATE "${SDL2_BINARY_DIR}/include")
+  target_include_directories(SDL2 PUBLIC "$<BUILD_INTERFACE:${SDL2_SOURCE_DIR}/include>;$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>;$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/SDL2>")
+  # This picks up all the compiler options and such we've accumulated up to here.
+  target_link_libraries(SDL2 PRIVATE $<BUILD_INTERFACE:sdl-build-options>)
+  if(NOT ANDROID)
     set_target_properties(SDL2 PROPERTIES DEBUG_POSTFIX "${SDL_CMAKE_DEBUG_POSTFIX}")
   endif()
-  if(IOS OR TVOS)
-    set_property(TARGET SDL2 APPEND_STRING PROPERTY COMPILE_FLAGS "-fobjc-arc")
-    target_compile_definitions(SDL2 PRIVATE IOS_DYLIB=1)
-  endif()
-endif()
-
-if(ANDROID)
-  if(HAVE_HIDAPI)
-    add_library(hidapi SHARED ${SDL2_SOURCE_DIR}/src/hidapi/android/hid.cpp)
-  endif()
-
-  if(MSVC AND NOT LIBC)
-    # Don't try to link with the default set of libraries.
-    set_target_properties(hidapi PROPERTIES LINK_FLAGS_RELEASE "/NODEFAULTLIB")
-    set_target_properties(hidapi PROPERTIES LINK_FLAGS_DEBUG "/NODEFAULTLIB")
-    set_target_properties(hidapi PROPERTIES STATIC_LIBRARY_FLAGS "/NODEFAULTLIB")
-  endif()
-  if(HAVE_HIDAPI)
-    target_link_libraries(hidapi log)
-  endif()
 endif()
 
 if(SDL_STATIC)
   set (BUILD_SHARED_LIBS FALSE)
   add_library(SDL2-static STATIC ${SOURCE_FILES})
-  if (NOT SDL_SHARED OR NOT WIN32)
+  # alias target for in-tree builds
+  add_library(SDL2::SDL2-static ALIAS SDL2-static)
+  if (NOT SDL_SHARED OR NOT WIN32 OR MINGW)
     set_target_properties(SDL2-static PROPERTIES OUTPUT_NAME "SDL2")
     # Note: Apparently, OUTPUT_NAME must really be unique; even when
     # CMAKE_IMPORT_LIBRARY_SUFFIX or the like are given. Otherwise
@@ -2278,46 +2921,61 @@ if(SDL_STATIC)
     # clobbered, when the suffix is realized via subsequent rename.
   endif()
   set_target_properties(SDL2-static PROPERTIES POSITION_INDEPENDENT_CODE ${SDL_STATIC_PIC})
-  if(MSVC AND NOT LIBC)
+  # Note: The clang toolset for Visual Studio does not support /NODEFAULTLIB.
+  if(MSVC AND NOT SDL_LIBC AND NOT MSVC_CLANG)
     set_target_properties(SDL2-static PROPERTIES LINK_FLAGS_RELEASE "/NODEFAULTLIB")
     set_target_properties(SDL2-static PROPERTIES LINK_FLAGS_DEBUG "/NODEFAULTLIB")
     set_target_properties(SDL2-static PROPERTIES STATIC_LIBRARY_FLAGS "/NODEFAULTLIB")
   endif()
   # TODO: Win32 platforms keep the same suffix .lib for import and static
   # libraries - do we need to consider this?
-  set(_INSTALL_LIBS "SDL2-static" ${_INSTALL_LIBS})
-  target_link_libraries(SDL2-static ${EXTRA_LIBS} ${EXTRA_LDFLAGS})
+  target_link_libraries(SDL2-static PRIVATE ${EXTRA_LIBS} ${EXTRA_LDFLAGS})
+  target_include_directories(SDL2-static BEFORE PRIVATE "${SDL2_BINARY_DIR}/include")
   target_include_directories(SDL2-static PUBLIC "$<BUILD_INTERFACE:${SDL2_SOURCE_DIR}/include>" $<INSTALL_INTERFACE:include> $<INSTALL_INTERFACE:include/SDL2>)
-  if(ANDROID)
-    target_include_directories(SDL2-static PRIVATE ${ANDROID_NDK}/sources/android/cpufeatures)
-  else()
+  # This picks up all the compiler options and such we've accumulated up to here.
+  target_link_libraries(SDL2-static PRIVATE $<BUILD_INTERFACE:sdl-build-options>)
+  if(NOT ANDROID)
     set_target_properties(SDL2-static PROPERTIES DEBUG_POSTFIX "${SDL_CMAKE_DEBUG_POSTFIX}")
   endif()
-  if(IOS OR TVOS)
-    set_property(TARGET SDL2-static APPEND_STRING PROPERTY COMPILE_FLAGS "-fobjc-arc")
-  endif()
 endif()
 
 ##### Tests #####
 
 if(SDL_TEST)
+  include_directories(BEFORE "${SDL2_BINARY_DIR}/include")
+  include_directories(AFTER "${SDL2_SOURCE_DIR}/include")
   file(GLOB TEST_SOURCES ${SDL2_SOURCE_DIR}/src/test/*.c)
   add_library(SDL2_test STATIC ${TEST_SOURCES})
-
   add_subdirectory(test)
 endif()
 
 ##### Installation targets #####
-install(TARGETS ${_INSTALL_LIBS} EXPORT SDL2Targets
-  LIBRARY DESTINATION "lib${LIB_SUFFIX}"
-  ARCHIVE DESTINATION "lib${LIB_SUFFIX}"
-  RUNTIME DESTINATION bin)
+if(SDL_SHARED)
+  install(TARGETS SDL2 EXPORT SDL2Targets
+    LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+    ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+    RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
+endif()
+
+if(NOT WINDOWS_STORE AND NOT SDL2_DISABLE_SDL2MAIN)
+  install(TARGETS SDL2main EXPORT SDL2mainTargets
+    LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+    ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+    RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
+endif()
+
+if(SDL_STATIC)
+  install(TARGETS SDL2-static EXPORT SDL2staticTargets
+    LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+    ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+    RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
+endif()
 
 ##### Export files #####
-if (WINDOWS)
+if (WINDOWS AND NOT MINGW)
   set(PKG_PREFIX "cmake")
 else ()
-  set(PKG_PREFIX "lib${LIB_SUFFIX}/cmake/SDL2")
+  set(PKG_PREFIX "${CMAKE_INSTALL_LIBDIR}/cmake/SDL2")
 endif ()
 
 include(CMakePackageConfigHelpers)
@@ -2326,11 +2984,30 @@ write_basic_package_version_file("${CMAKE_BINARY_DIR}/SDL2ConfigVersion.cmake"
   COMPATIBILITY AnyNewerVersion
 )
 
-install(EXPORT SDL2Targets
-  FILE SDL2Targets.cmake
-  NAMESPACE SDL2::
-  DESTINATION ${PKG_PREFIX}
-)
+if(SDL_SHARED)
+  install(EXPORT SDL2Targets
+    FILE SDL2Targets.cmake
+    NAMESPACE SDL2::
+    DESTINATION ${PKG_PREFIX}
+  )
+endif()
+
+if(NOT WINDOWS_STORE AND NOT SDL2_DISABLE_SDL2MAIN)
+  install(EXPORT SDL2mainTargets
+    FILE SDL2mainTargets.cmake
+    NAMESPACE SDL2::
+    DESTINATION ${PKG_PREFIX}
+  )
+endif()
+
+if(SDL_STATIC)
+  install(EXPORT SDL2staticTargets
+    FILE SDL2staticTargets.cmake
+    NAMESPACE SDL2::
+    DESTINATION ${PKG_PREFIX}
+  )
+endif()
+
 install(
   FILES
     ${CMAKE_CURRENT_SOURCE_DIR}/SDL2Config.cmake
@@ -2346,7 +3023,7 @@ foreach(_FNAME ${BIN_INCLUDE_FILES})
   list(REMOVE_ITEM INCLUDE_FILES ${SDL2_SOURCE_DIR}/include/${_INCNAME})
 endforeach()
 list(APPEND INCLUDE_FILES ${BIN_INCLUDE_FILES})
-install(FILES ${INCLUDE_FILES} DESTINATION include/SDL2)
+install(FILES ${INCLUDE_FILES} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/SDL2)
 
 string(TOUPPER "${CMAKE_BUILD_TYPE}" UPPER_BUILD_TYPE)
 if (UPPER_BUILD_TYPE MATCHES DEBUG)
@@ -2355,16 +3032,16 @@ else()
   set(SOPOSTFIX "")
 endif()
 
-if(NOT (WINDOWS OR CYGWIN))
+if(NOT (WINDOWS OR CYGWIN) OR MINGW)
   if(SDL_SHARED)
     set(SOEXT ${CMAKE_SHARED_LIBRARY_SUFFIX}) # ".so", ".dylib", etc.
     get_target_property(SONAME SDL2 OUTPUT_NAME)
-    if(NOT ANDROID)
+    if(NOT ANDROID AND NOT MINGW AND NOT OS2)
         install(CODE "
           execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink
             \"lib${SONAME}${SOPOSTFIX}${SOEXT}\" \"libSDL2${SOPOSTFIX}${SOEXT}\"
             WORKING_DIRECTORY \"${SDL2_BINARY_DIR}\")")
-        install(FILES ${SDL2_BINARY_DIR}/libSDL2${SOPOSTFIX}${SOEXT} DESTINATION "lib${LIB_SUFFIX}")
+        install(FILES ${SDL2_BINARY_DIR}/libSDL2${SOPOSTFIX}${SOEXT} DESTINATION "${CMAKE_INSTALL_LIBDIR}")
     endif()
   endif()
   if(FREEBSD)
@@ -2372,15 +3049,16 @@ if(NOT (WINDOWS OR CYGWIN))
     install(FILES ${SDL2_BINARY_DIR}/sdl2.pc DESTINATION "libdata/pkgconfig")
   else()
     install(FILES ${SDL2_BINARY_DIR}/sdl2.pc
-      DESTINATION "lib${LIB_SUFFIX}/pkgconfig")
+      DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
   endif()
-  install(PROGRAMS ${SDL2_BINARY_DIR}/sdl2-config DESTINATION bin)
+  install(PROGRAMS ${SDL2_BINARY_DIR}/sdl2-config DESTINATION "${CMAKE_INSTALL_BINDIR}")
   # TODO: what about the .spec file? Is it only needed for RPM creation?
-  install(FILES "${SDL2_SOURCE_DIR}/sdl2.m4" DESTINATION "${CMAKE_INSTALL_FULL_DATAROOTDIR}/aclocal")
+  install(FILES "${SDL2_SOURCE_DIR}/sdl2.m4" DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/aclocal")
 endif()
 
 ##### Uninstall target #####
 
+if(NOT SDL2_DISABLE_UNINSTALL)
 if(NOT TARGET uninstall)
   configure_file(
       "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in"
@@ -2390,3 +3068,4 @@ if(NOT TARGET uninstall)
   add_custom_target(uninstall
       COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
 endif()
+endif(NOT SDL2_DISABLE_UNINSTALL)
diff --git a/Engine/lib/sdl/INSTALL.txt b/Engine/lib/sdl/INSTALL.txt
index 9ee4ef538..5856e2875 100644
--- a/Engine/lib/sdl/INSTALL.txt
+++ b/Engine/lib/sdl/INSTALL.txt
@@ -2,16 +2,16 @@
 To compile and install SDL:
 
     1.  Windows with Visual Studio:
-        * Read VisualC.html
+        * Read ./docs/README-visualc.md
 
         Windows with gcc, either native or cross-compiling:
-        * Read the FAQ at https://wiki.libsdl.org/moin.fcg/FAQWindows
+        * Read the FAQ at https://wiki.libsdl.org/FAQWindows
         * Run './configure; make; make install'
 
-        Mac OS X with Xcode:
+        macOS with Xcode:
         * Read docs/README-macosx.md
 
-        Mac OS X from the command line:
+        macOS from the command line:
         * Run './configure; make; make install'
 
         Linux and other UNIX systems:
@@ -29,12 +29,13 @@ To compile and install SDL:
     2.  Look at the example programs in ./test, and check out the online
         documentation at https://wiki.libsdl.org/
 
-    3.  Join the SDL developer mailing list by sending E-mail to
-    	sdl-request@libsdl.org
-        and put "subscribe" in the subject of the message.
+    3.  Join the SDL developer discussions, sign up on 
+        https://discourse.libsdl.org/
+        and go to the development forum
+        https://discourse.libsdl.org/c/sdl-development/6
 
-        Or alternatively you can use the web interface:
-            https://www.libsdl.org/mailing-list.php
+    4.  Sign up for the announcement list through the web interface:
+        https://www.libsdl.org/mailing-list.php
 
 That's it!
 Sam Lantinga <slouken@libsdl.org>
diff --git a/Engine/lib/sdl/COPYING.txt b/Engine/lib/sdl/LICENSE.txt
similarity index 90%
rename from Engine/lib/sdl/COPYING.txt
rename to Engine/lib/sdl/LICENSE.txt
index 0e2bef3fc..728a3d708 100644
--- a/Engine/lib/sdl/COPYING.txt
+++ b/Engine/lib/sdl/LICENSE.txt
@@ -1,6 +1,4 @@
-
-Simple DirectMedia Layer
-Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
   
 This software is provided 'as-is', without any express or implied
 warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/Makefile.in b/Engine/lib/sdl/Makefile.in
index 57871bedf..81c56fd3a 100644
--- a/Engine/lib/sdl/Makefile.in
+++ b/Engine/lib/sdl/Makefile.in
@@ -29,6 +29,8 @@ INSTALL = @INSTALL@
 AR	= @AR@
 RANLIB	= @RANLIB@
 RC	= @RC@
+LINKER = @LINKER@
+LIBTOOLLINKERTAG = @LIBTOOLLINKERTAG@
 
 TARGET  = libSDL2.la
 OBJECTS = @OBJECTS@
@@ -43,10 +45,11 @@ SDLTEST_TARGET = libSDL2_test.la
 SDLTEST_OBJECTS = @SDLTEST_OBJECTS@
 
 WAYLAND_SCANNER = @WAYLAND_SCANNER@
+WAYLAND_SCANNER_CODE_MODE = @WAYLAND_SCANNER_CODE_MODE@
 
 INSTALL_SDL2_CONFIG = @INSTALL_SDL2_CONFIG@
 
-SRC_DIST = *.txt acinclude Android.mk autogen.sh android-project build-scripts cmake cmake_uninstall.cmake.in configure configure.ac debian docs include Makefile.* sdl2-config.cmake.in sdl2-config-version.cmake.in sdl2-config.in sdl2.m4 sdl2.pc.in SDL2.spec.in SDL2Config.cmake src test VisualC.html VisualC VisualC-WinRT Xcode Xcode-iOS wayland-protocols
+SRC_DIST = *.md *.txt acinclude Android.mk autogen.sh android-project build-scripts cmake cmake_uninstall.cmake.in configure configure.ac docs include Makefile.* sdl2-config.cmake.in sdl2-config-version.cmake.in sdl2-config.in sdl2.m4 sdl2.pc.in SDL2.spec.in SDL2Config.cmake src test VisualC VisualC-WinRT Xcode Xcode-iOS wayland-protocols
 GEN_DIST = SDL2.spec
 
 ifneq ($V,1)
@@ -77,6 +80,7 @@ HDRS = \
 	SDL_gamecontroller.h \
 	SDL_gesture.h \
 	SDL_haptic.h \
+	SDL_hidapi.h \
 	SDL_hints.h \
 	SDL_joystick.h \
 	SDL_keyboard.h \
@@ -151,13 +155,13 @@ update-revision:
 .PHONY: all update-revision install install-bin install-hdrs install-lib install-data uninstall uninstall-bin uninstall-hdrs uninstall-lib uninstall-data clean distclean dist $(OBJECTS:.lo=.d)
 
 $(objects)/$(TARGET): $(GEN_HEADERS) $(GEN_OBJECTS) $(OBJECTS) $(VERSION_OBJECTS)
-	$(RUN_CMD_LTLINK)$(LIBTOOL) --tag=CC --mode=link $(CC) -o $@ $(OBJECTS) $(GEN_OBJECTS) $(VERSION_OBJECTS) $(LDFLAGS) $(EXTRA_LDFLAGS) $(LT_LDFLAGS)
+	$(RUN_CMD_LTLINK)$(LIBTOOL) --tag=$(LIBTOOLLINKERTAG) --mode=link $(LINKER) -o $@ $(OBJECTS) $(GEN_OBJECTS) $(VERSION_OBJECTS) $(LDFLAGS) $(EXTRA_LDFLAGS) $(LT_LDFLAGS)
 
 $(objects)/$(SDLMAIN_TARGET): $(SDLMAIN_OBJECTS)
-	$(RUN_CMD_LTLINK)$(LIBTOOL) --tag=CC --mode=link $(CC) -static -o $@ $(SDLMAIN_OBJECTS) -rpath $(libdir)
+	$(RUN_CMD_LTLINK)$(LIBTOOL) --tag=$(LIBTOOLLINKERTAG) --mode=link $(LINKER) -static -o $@ $(SDLMAIN_OBJECTS) -rpath $(libdir)
 
 $(objects)/$(SDLTEST_TARGET): $(SDLTEST_OBJECTS)
-	$(RUN_CMD_LTLINK)$(LIBTOOL) --tag=CC --mode=link $(CC) -static -o $@ $(SDLTEST_OBJECTS) -rpath $(libdir)
+	$(RUN_CMD_LTLINK)$(LIBTOOL) --tag=$(LIBTOOLLINKERTAG) --mode=link $(LINKER) -static -o $@ $(SDLTEST_OBJECTS) -rpath $(libdir)
 
 install: all install-bin install-hdrs install-lib install-data
 install-bin:
diff --git a/Engine/lib/sdl/Makefile.minimal b/Engine/lib/sdl/Makefile.minimal
index 7f0264974..97ce201ea 100644
--- a/Engine/lib/sdl/Makefile.minimal
+++ b/Engine/lib/sdl/Makefile.minimal
@@ -5,9 +5,12 @@ CFLAGS  = -g -O2 $(INCLUDE)
 AR	= ar
 RANLIB	= ranlib
 
-TARGET  = libSDL.a
+TARGET  = libSDL2.a
+TESTTARGET = libSDL2_test.a
+
 SOURCES = \
 	src/*.c \
+	src/atomic/*.c \
 	src/audio/*.c \
 	src/audio/dummy/*.c \
 	src/cpuinfo/*.c \
@@ -15,30 +18,44 @@ SOURCES = \
 	src/file/*.c \
 	src/haptic/*.c \
 	src/haptic/dummy/*.c \
+	src/hidapi/*.c \
 	src/joystick/*.c \
 	src/joystick/dummy/*.c \
 	src/loadso/dummy/*.c \
 	src/power/*.c \
 	src/filesystem/dummy/*.c \
+	src/locale/*.c \
+	src/locale/dummy/*.c \
+	src/misc/*.c \
+	src/misc/dummy/*.c \
 	src/render/*.c \
 	src/render/software/*.c \
 	src/sensor/*.c \
 	src/sensor/dummy/*.c \
 	src/stdlib/*.c \
+	src/libm/*.c \
 	src/thread/*.c \
 	src/thread/generic/*.c \
 	src/timer/*.c \
 	src/timer/dummy/*.c \
 	src/video/*.c \
+	src/video/yuv2rgb/*.c \
 	src/video/dummy/*.c \
 
-OBJECTS = $(shell echo $(SOURCES) | sed -e 's,\.c,\.o,g')
+TSOURCES = src/test/*.c
 
-all: $(TARGET)
+OBJECTS = $(shell echo $(SOURCES) | sed -e 's,\.c,\.o,g')
+TOBJECTS= $(shell echo $(TSOURCES) | sed -e 's,\.c,\.o,g')
+
+all: $(TARGET) $(TESTTARGET)
 
 $(TARGET): $(OBJECTS)
 	$(AR) crv $@ $^
 	$(RANLIB) $@
 
+$(TESTTARGET): $(TOBJECTS)
+	$(AR) crv $@ $^
+	$(RANLIB) $@
+
 clean:
-	rm -f $(TARGET) $(OBJECTS)
+	rm -f $(TARGET) $(TESTTARGET) $(OBJECTS) $(TOBJECTS)
diff --git a/Engine/lib/sdl/Makefile.os2 b/Engine/lib/sdl/Makefile.os2
index 412e91b58..eb34494c5 100644
--- a/Engine/lib/sdl/Makefile.os2
+++ b/Engine/lib/sdl/Makefile.os2
@@ -1,10 +1,22 @@
 # Open Watcom makefile to build SDL2.dll for OS/2
 # wmake -f Makefile.os2
+#
+# If you have GNU libiconv installed (iconv2.dll), you
+# can compile against it by specifying LIBICONV=1, e.g.:
+# wmake -f Makefile.os2 LIBICONV=1
+#
+# If you have libusb-1.0 installed (usb100.dll, libusb.h), you
+# can compile hidapi joystick support against it (experimental)
+# by specifying HIDAPI=1, e.g.:
+# wmake -f Makefile.os2 HIDAPI=1
 
 LIBNAME = SDL2
-VERSION = 2.0.14
+VERSION = 2.0.21
 DESCRIPTION = Simple DirectMedia Layer 2
 
+LIBICONV=0
+ICONVLIB=$(LIBICONV_LIB)
+
 LIBHOME = .
 DLLFILE = $(LIBHOME)/$(LIBNAME).dll
 LIBFILE = $(LIBHOME)/$(LIBNAME).lib
@@ -12,32 +24,41 @@ LNKFILE = $(LIBNAME).lnk
 
 INCPATH = -I"$(%WATCOM)/h/os2" -I"$(%WATCOM)/h"
 INCPATH+= -Iinclude
-INCPATH+= -I"src/core/os2" -I"src/core/os2/geniconv"
-
-LIBM = libm.lib
-LIBS = mmpm2.lib libuls.lib libconv.lib $(LIBM)
-
-CFLAGS = -bt=os2 -d0 -q -bm -5s -fp5 -fpi87 -sg -oteanbmier -ei
-# max warnings:
-CFLAGS+= -wx
-# newer OpenWatcom versions enable W303 by default
-CFLAGS+= -wcd=303
-# building dll:
-CFLAGS+= -bd
-# the include paths :
-CFLAGS+= $(INCPATH)
-# building SDL itself (for DECLSPEC):
-CFLAGS+= -DBUILD_SDL
 
+LIBM = SDL2libm.lib
+TLIB = SDL2test.lib
+LIBS = mmpm2.lib $(LIBM)
+CFLAGS = -bt=os2 -d0 -q -bm -5s -fp5 -fpi87 -sg -oeatxhn -ei
 # Debug options:
 # - debug messages from OS/2 related code to stdout:
 #CFLAGS+= -DOS2DEBUG
 # - debug messages from OS/2 code via SDL_LogDebug():
 #CFLAGS+= -DOS2DEBUG=2
 
-MSRCS= e_atan2.c e_exp.c e_fmod.c e_log10.c e_log.c e_pow.c e_rem_pio2.c e_sqrt.c &
-       k_cos.c k_rem_pio2.c k_sin.c k_tan.c &
-       s_atan.c s_copysign.c s_cos.c s_fabs.c s_floor.c s_scalbn.c s_sin.c s_tan.c
+# max warnings:
+CFLAGS+= -wx
+# newer OpenWatcom versions enable W303 by default
+CFLAGS+= -wcd=303
+# the include paths :
+CFLAGS+= $(INCPATH)
+CFLAGS_STATIC=$(CFLAGS)
+# building dll:
+CFLAGS_DLL =$(CFLAGS)
+CFLAGS_DLL+= -bd
+# iconv:
+LIBICONV_LIB=iconv2.lib
+!ifeq LIBICONV 1
+CFLAGS_DLL+= -DHAVE_ICONV=1 -DHAVE_ICONV_H=1
+LIBS+= $(ICONVLIB)
+!else
+LIBS+= libuls.lib libconv.lib
+!endif
+# hidapi (libusb):
+!ifeq HIDAPI 1
+CFLAGS_DLL+= -DHAVE_LIBUSB_H=1
+!endif
+# building SDL itself (for DECLSPEC):
+CFLAGS_DLL+= -DBUILD_SDL
 
 SRCS = SDL.c SDL_assert.c SDL_error.c SDL_log.c SDL_dataqueue.c SDL_hints.c
 SRCS+= SDL_getenv.c SDL_iconv.c SDL_malloc.c SDL_qsort.c SDL_stdlib.c SDL_string.c SDL_strtokr.c SDL_crc32.c
@@ -47,10 +68,10 @@ SRCS+= SDL_audio.c SDL_audiocvt.c SDL_audiodev.c SDL_audiotypecvt.c SDL_mixer.c
 SRCS+= SDL_events.c SDL_quit.c SDL_keyboard.c SDL_mouse.c SDL_windowevents.c &
        SDL_clipboardevents.c SDL_dropevents.c SDL_displayevents.c SDL_gesture.c &
        SDL_sensor.c SDL_touch.c
-SRCS+= SDL_haptic.c SDL_gamecontroller.c SDL_joystick.c
+SRCS+= SDL_haptic.c SDL_hidapi.c SDL_gamecontroller.c SDL_joystick.c
 SRCS+= SDL_render.c yuv_rgb.c SDL_yuv.c SDL_yuv_sw.c SDL_blendfillrect.c &
        SDL_blendline.c SDL_blendpoint.c SDL_drawline.c SDL_drawpoint.c &
-       SDL_render_sw.c SDL_rotate.c
+       SDL_render_sw.c SDL_rotate.c SDL_triangle.c
 SRCS+= SDL_blit.c SDL_blit_0.c SDL_blit_1.c SDL_blit_A.c SDL_blit_auto.c &
        SDL_blit_copy.c SDL_blit_N.c SDL_blit_slow.c SDL_fillrect.c SDL_bmp.c &
        SDL_pixels.c SDL_rect.c SDL_RLEaccel.c SDL_shape.c SDL_stretch.c &
@@ -60,15 +81,18 @@ SRCS+= SDL_syscond.c SDL_sysmutex.c SDL_syssem.c SDL_systhread.c SDL_systls.c
 SRCS+= SDL_systimer.c
 SRCS+= SDL_sysloadso.c
 SRCS+= SDL_sysfilesystem.c
-SRCS+= SDL_syshaptic.c SDL_sysjoystick.c
-SRCS+= SDL_virtualjoystick.c
+SRCS+= SDL_os2joystick.c SDL_syshaptic.c SDL_sysjoystick.c SDL_virtualjoystick.c
+SRCS+= SDL_hidapijoystick.c SDL_hidapi_rumble.c SDL_hidapi_gamecube.c SDL_hidapi_luna.c SDL_hidapi_ps4.c SDL_hidapi_ps5.c SDL_hidapi_stadia.c SDL_hidapi_switch.c SDL_hidapi_xbox360.c SDL_hidapi_xbox360w.c SDL_hidapi_xboxone.c SDL_hidapi_steam.c
 SRCS+= SDL_dummyaudio.c SDL_diskaudio.c
 SRCS+= SDL_nullvideo.c SDL_nullframebuffer.c SDL_nullevents.c
 SRCS+= SDL_dummysensor.c
 SRCS+= SDL_locale.c SDL_syslocale.c
 SRCS+= SDL_url.c SDL_sysurl.c
 
-SRCS+= SDL_os2.c geniconv.c os2cp.c os2iconv.c sys2utf8.c
+SRCS+= SDL_os2.c
+!ifeq LIBICONV 0
+SRCS+= geniconv.c os2cp.c os2iconv.c sys2utf8.c
+!endif
 SRCS+= SDL_os2audio.c
 SRCS+= SDL_os2video.c SDL_os2util.c SDL_os2dive.c SDL_os2vman.c &
        SDL_os2mouse.c SDL_os2messagebox.c
@@ -76,19 +100,22 @@ SRCS+= SDL_os2video.c SDL_os2util.c SDL_os2dive.c SDL_os2vman.c &
 SRCS+= SDL_dynapi.c
 
 OBJS = $(SRCS:.c=.obj)
-MOBJS= $(MSRCS:.c=.obj)
 
 .extensions:
 .extensions: .lib .dll .obj .c .asm
 
 .c: ./src;./src/dynapi;./src/audio;./src/cpuinfo;./src/events;./src/file;./src/haptic;./src/joystick;./src/power;./src/render;./src/render/software;./src/sensor;./src/stdlib;./src/thread;./src/timer;./src/video;./src/video/yuv2rgb;./src/atomic;./src/audio/disk;
 .c: ./src/haptic/dummy;./src/joystick/dummy;./src/joystick/virtual;./src/audio/dummy;./src/video/dummy;./src/sensor/dummy;
-.c: ./src/core/os2;./src/core/os2/geniconv;./src/audio/os2;./src/loadso/os2;./src/filesystem/os2;./src/thread/os2;./src/timer/os2;./src/video/os2;
-.c: ./src/locale/;./src/locale/unix;./src/misc;./src/misc/dummy
+.c: ./src/core/os2;./src/audio/os2;./src/loadso/os2;./src/filesystem/os2;./src/joystick/os2;./src/thread/os2;./src/timer/os2;./src/video/os2;
+.c: ./src/core/os2/geniconv;
+.c: ./src/locale/;./src/locale/unix;./src/misc;./src/misc/dummy;./src/joystick/hidapi;./src/hidapi
 
-all: $(DLLFILE) $(LIBFILE) .symbolic
+all: $(DLLFILE) $(LIBFILE) $(TLIB) .symbolic
 
-$(DLLFILE): $(OBJS) $(LIBM) $(LNKFILE)
+build_dll: .symbolic
+    @echo * Compiling dll objects
+
+$(DLLFILE): build_dll $(OBJS) $(LIBM) $(LIBICONV_LIB) $(LNKFILE)
     @echo * Linking: $@
     wlink @$(LNKFILE)
 
@@ -97,36 +124,132 @@ $(LIBFILE): $(DLLFILE)
     wlib -q -b -n -c -pa -s -t -zld -ii -io $* $(DLLFILE)
 
 .c.obj:
-    wcc386 $(CFLAGS) -fo=$^@ $<
+    wcc386 $(CFLAGS_DLL) -fo=$^@ $<
 
 SDL_syscond.obj: "src/thread/generic/SDL_syscond.c"
-    wcc386 $(CFLAGS) -fo=$^@ $<
-
+    wcc386 $(CFLAGS_DLL) -fo=$^@ $<
 SDL_cpuinfo.obj: SDL_cpuinfo.c
-    wcc386 $(CFLAGS) -wcd=200 -fo=$^@ $<
-
-SDL_rwops.obj: SDL_rwops.c
-    wcc386 $(CFLAGS) -wcd=136 -fo=$^@ $<
-
+    wcc386 $(CFLAGS_DLL) -wcd=200 -fo=$^@ $<
 SDL_wave.obj: SDL_wave.c
-    wcc386 $(CFLAGS) -wcd=124 -fo=$^@ $<
-
+    wcc386 $(CFLAGS_DLL) -wcd=124 -fo=$^@ $<
 SDL_blendfillrect.obj: SDL_blendfillrect.c
-    wcc386 $(CFLAGS) -wcd=200 -fo=$^@ $<
-
+    wcc386 $(CFLAGS_DLL) -wcd=200 -fo=$^@ $<
 SDL_blendline.obj: SDL_blendline.c
-    wcc386 $(CFLAGS) -wcd=200 -fo=$^@ $<
-
+    wcc386 $(CFLAGS_DLL) -wcd=200 -fo=$^@ $<
 SDL_blendpoint.obj: SDL_blendpoint.c
-    wcc386 $(CFLAGS) -wcd=200 -fo=$^@ $<
-
+    wcc386 $(CFLAGS_DLL) -wcd=200 -fo=$^@ $<
 SDL_RLEaccel.obj: SDL_RLEaccel.c
-    wcc386 $(CFLAGS) -wcd=201 -fo=$^@ $<
+    wcc386 $(CFLAGS_DLL) -wcd=201 -fo=$^@ $<
+# c99 mode needed because of structs with flexible array members in libusb.h
+SDL_hidapi.obj: SDL_hidapi.c
+    wcc386 $(CFLAGS_DLL) -za99 -fo=$^@ $<
+
+$(LIBICONV_LIB):  "src/core/os2/iconv2.lbc"
+    @echo * Creating: $@
+    wlib -q -b -n -c -pa -s -t -zld -ii -io $@ @$<
+
+# SDL2libm
+MSRCS= e_atan2.c e_exp.c e_fmod.c e_log10.c e_log.c e_pow.c e_rem_pio2.c e_sqrt.c &
+       k_cos.c k_rem_pio2.c k_sin.c k_tan.c &
+       s_atan.c s_copysign.c s_cos.c s_fabs.c s_floor.c s_scalbn.c s_sin.c s_tan.c
+MOBJS= $(MSRCS:.c=.obj)
 
 .c: ./src/libm;
-$(LIBM): $(MOBJS)
+e_atan2.obj: e_atan2.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+e_exp.obj: e_exp.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+e_fmod.obj: e_fmod.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+e_log10.obj: e_log10.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+e_log.obj: e_log.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+e_pow.obj: e_pow.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+e_rem_pio2.obj: e_rem_pio2.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+e_sqrt.obj: e_sqrt.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+k_cos.obj: k_cos.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+k_rem_pio2.obj: k_rem_pio2.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+k_sin.obj: k_sin.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+k_tan.obj: k_tan.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+s_atan.obj: s_atan.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+s_copysign.obj: s_copysign.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+s_cos.obj: s_cos.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+s_fabs.obj: s_fabs.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+s_floor.obj: s_floor.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+s_scalbn.obj: s_scalbn.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+s_sin.obj: s_sin.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+s_tan.obj: s_tan.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+
+build_libm: .symbolic
+    @echo * Compiling libm objects
+$(LIBM): build_libm $(MOBJS)
+    @echo * Creating: $@
     wlib -q -b -n -c -pa -s -t -zld -ii -io $@ $(MOBJS)
 
+# SDL2test
+TSRCS = SDL_test_assert.c SDL_test_common.c SDL_test_compare.c &
+        SDL_test_crc32.c SDL_test_font.c SDL_test_fuzzer.c SDL_test_harness.c &
+        SDL_test_imageBlit.c SDL_test_imageBlitBlend.c SDL_test_imageFace.c &
+        SDL_test_imagePrimitives.c SDL_test_imagePrimitivesBlend.c &
+        SDL_test_log.c SDL_test_md5.c SDL_test_random.c SDL_test_memory.c
+TOBJS= $(TSRCS:.c=.obj)
+
+.c: ./src/test;
+SDL_test_assert.obj: SDL_test_assert.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_common.obj: SDL_test_common.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_compare.obj: SDL_test_compare.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_crc32.obj: SDL_test_crc32.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_font.obj: SDL_test_font.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_fuzzer.obj: SDL_test_fuzzer.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_harness.obj: SDL_test_harness.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_imageBlit.obj: SDL_test_imageBlit.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_imageBlitBlend.obj: SDL_test_imageBlitBlend.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_imageFace.obj: SDL_test_imageFace.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_imagePrimitives.obj: SDL_test_imagePrimitives.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_imagePrimitivesBlend.obj: SDL_test_imagePrimitivesBlend.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_log.obj: SDL_test_log.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_md5.obj: SDL_test_md5.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_random.obj: SDL_test_random.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_memory.obj: SDL_test_memory.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+
+build_tlib: .symbolic
+    @echo * Compiling testlib objects
+$(TLIB): build_tlib $(TOBJS)
+    @echo * Creating: $@
+    wlib -q -b -n -c -pa -s -t -zld -ii -io $@ $(TOBJS)
+
 $(LNKFILE):
     @echo * Creating linker file: $@
     @%create $@
@@ -144,14 +267,16 @@ $(LNKFILE):
     @%append $@ OPTION SHOWDEAD
 
 clean: .SYMBOLIC
-    @ echo * Clean: $(LIBNAME)
+    @echo * Clean: $(LIBNAME)
     @if exist *.obj rm *.obj
     @if exist *.err rm *.err
     @if exist $(LNKFILE) rm $(LNKFILE)
     @if exist $(LIBM) rm $(LIBM)
+    @if exist $(LIBICONV_LIB) rm $(LIBICONV_LIB)
 
 distclean: .SYMBOLIC clean
     @if exist $(LIBHOME)/*.exp rm $(LIBHOME)/*.exp
     @if exist $(LIBHOME)/*.map rm $(LIBHOME)/*.map
     @if exist $(LIBFILE) rm $(LIBFILE)
     @if exist $(DLLFILE) rm $(DLLFILE)
+    @if exist $(TLIB) rm $(TLIB)
diff --git a/Engine/lib/sdl/Makefile.pandora b/Engine/lib/sdl/Makefile.pandora
index f4cb66848..fe2249979 100644
--- a/Engine/lib/sdl/Makefile.pandora
+++ b/Engine/lib/sdl/Makefile.pandora
@@ -10,7 +10,7 @@ CFLAGS  = -O3 -march=armv7-a -mcpu=cortex-a8 -mtune=cortex-a8 -mfloat-abi=softfp
 	-mfpu=neon -ftree-vectorize -ffast-math -fomit-frame-pointer -fno-strict-aliasing -fsingle-precision-constant \
 	-I./include -I$(PNDSDK)/usr/include
 
-TARGET  = libSDL.a
+TARGET  = libSDL2.a
 
 SOURCES = 
 	./src/*.c \
@@ -25,9 +25,14 @@ SOURCES =
 	./src/filesystem/unix/*.c \
 	./src/haptic/*.c \
 	./src/haptic/linux/*.c \
+	./src/hidapi/*.c \
 	./src/joystick/*.c \
 	./src/joystick/linux/*.c \
 	./src/loadso/dlopen/*.c \
+	./src/locale/*.c \
+	./src/locale/unix/*.c \
+	./src/misc/*.c \
+	./src/misc/unix/*.c \
 	./src/power/*.c \
 	./src/sensor/*.c \
 	./src/sensor/dummy/*.c \
@@ -40,11 +45,10 @@ SOURCES =
 	./src/timer/*.c \
 	./src/timer/unix/*.c \
 	./src/video/*.c \
+	./src/video/yuv2rgb/*.c \
 	./src/video/dummy/*.c \
-	./src/video/pandora/SDL_pandora.o \
-	./src/video/pandora/SDL_pandora_events.o \
 	./src/video/x11/*.c \
-	
+	./src/video/pandora/*.c
 
 OBJECTS = $(shell echo $(SOURCES) | sed -e 's,\.c,\.o,g')
 
diff --git a/Engine/lib/sdl/Makefile.psp b/Engine/lib/sdl/Makefile.psp
deleted file mode 100644
index 16c540023..000000000
--- a/Engine/lib/sdl/Makefile.psp
+++ /dev/null
@@ -1,96 +0,0 @@
-TARGET_LIB = libSDL2.a
-OBJS= src/SDL.o \
-      src/SDL_assert.o \
-      src/SDL_error.o \
-      src/SDL_hints.o \
-      src/SDL_log.o \
-      src/atomic/SDL_atomic.o \
-      src/atomic/SDL_spinlock.o \
-      src/audio/SDL_audio.o \
-      src/audio/SDL_audiocvt.o \
-      src/audio/SDL_audiodev.o \
-      src/audio/SDL_audiotypecvt.o \
-      src/audio/SDL_mixer.o \
-      src/audio/SDL_wave.o \
-      src/audio/psp/SDL_pspaudio.o \
-      src/cpuinfo/SDL_cpuinfo.o \
-      src/events/SDL_clipboardevents.o \
-      src/events/SDL_dropevents.o \
-      src/events/SDL_events.o \
-      src/events/SDL_gesture.o \
-      src/events/SDL_keyboard.o \
-      src/events/SDL_mouse.o \
-      src/events/SDL_quit.o \
-      src/events/SDL_touch.o \
-      src/events/SDL_windowevents.o \
-      src/file/SDL_rwops.o \
-      src/haptic/SDL_haptic.o \
-      src/haptic/dummy/SDL_syshaptic.o \
-      src/joystick/SDL_joystick.o \
-      src/joystick/SDL_gamecontroller.o \
-      src/joystick/psp/SDL_sysjoystick.o \
-      src/power/SDL_power.o \
-      src/power/psp/SDL_syspower.o \
-      src/filesystem/dummy/SDL_sysfilesystem.o \
-      src/render/SDL_render.o \
-      src/render/SDL_yuv_sw.o \
-      src/render/psp/SDL_render_psp.o \
-      src/render/software/SDL_blendfillrect.o \
-      src/render/software/SDL_blendline.o \
-      src/render/software/SDL_blendpoint.o \
-      src/render/software/SDL_drawline.o \
-      src/render/software/SDL_drawpoint.o \
-      src/render/software/SDL_render_sw.o \
-      src/render/software/SDL_rotate.o \
-      src/sensor/SDL_sensor.o \
-      src/sensor/dummy/SDL_dummysensor.o \
-      src/stdlib/SDL_getenv.o \
-      src/stdlib/SDL_iconv.o \
-      src/stdlib/SDL_malloc.o \
-      src/stdlib/SDL_qsort.o \
-      src/stdlib/SDL_stdlib.o \
-      src/stdlib/SDL_string.o \
-      src/stdlib/SDL_strtokr.o \
-      src/thread/SDL_thread.o \
-      src/thread/generic/SDL_systls.o \
-      src/thread/psp/SDL_syssem.o \
-      src/thread/psp/SDL_systhread.o \
-      src/thread/psp/SDL_sysmutex.o \
-      src/thread/psp/SDL_syscond.o \
-      src/timer/SDL_timer.o \
-      src/timer/psp/SDL_systimer.o \
-      src/video/SDL_RLEaccel.o \
-      src/video/SDL_blit.o \
-      src/video/SDL_blit_0.o \
-      src/video/SDL_blit_1.o \
-      src/video/SDL_blit_A.o \
-      src/video/SDL_blit_N.o \
-      src/video/SDL_blit_auto.o \
-      src/video/SDL_blit_copy.o \
-      src/video/SDL_blit_slow.o \
-      src/video/SDL_bmp.o \
-      src/video/SDL_clipboard.o \
-      src/video/SDL_fillrect.o \
-      src/video/SDL_pixels.o \
-      src/video/SDL_rect.o \
-      src/video/SDL_stretch.o \
-      src/video/SDL_surface.o \
-      src/video/SDL_video.o \
-      src/video/psp/SDL_pspevents.o \
-      src/video/psp/SDL_pspvideo.o \
-      src/video/psp/SDL_pspgl.o \
-      src/video/psp/SDL_pspmouse.o
-
-INCDIR = ./include
-CFLAGS = -g -O2 -G0 -Wall -D__PSP__ -DHAVE_OPENGL
-CXXFLAGS = $(CFLAGS) -fno-exceptions -fno-rtti
-ASFLAGS = $(CFLAGS)
-
-LIBDIR  =
-LIBS = -lGL -lGLU -lglut -lz \
-         -lpspvfpu -lpsphprm -lpspsdk -lpspctrl -lpspumd -lpsprtc -lpsppower -lpspgum -lpspgu -lpspaudiolib -lpspaudio -lpsphttp -lpspssl -lpspwlan \
-         -lpspnet_adhocmatching -lpspnet_adhoc -lpspnet_adhocctl -lm -lpspvram
-
-PSPSDK=$(shell psp-config --pspsdk-path)
-include $(PSPSDK)/lib/build.mak
-
diff --git a/Engine/lib/sdl/Makefile.wiz b/Engine/lib/sdl/Makefile.wiz
deleted file mode 100644
index 8ed58ee76..000000000
--- a/Engine/lib/sdl/Makefile.wiz
+++ /dev/null
@@ -1,80 +0,0 @@
-# Makefile to build the pandora SDL library
-WIZSDK = /mythtv/media/devel/toolchains/openwiz/arm-openwiz-linux-gnu
-
-AR	= $(WIZSDK)/bin/arm-openwiz-linux-gnu-ar
-RANLIB	= $(WIZSDK)/bin/arm-openwiz-linux-gnu-ranlib
-CC = $(WIZSDK)/bin/arm-openwiz-linux-gnu-gcc
-CXX = $(WIZSDK)/bin/arm-openwiz-linux-gnu-g++
-STRIP = $(WIZSDK)/bin/arm-openwiz-linux-gnu-strip
-
-CFLAGS  = -Wall -fPIC -I./include -I$(WIZSDK)/include -DWIZ_GLES_LITE
-
-TARGET_STATIC  = libSDL2.a
-TARGET_SHARED  = libSDL2.so
-
-SOURCES = \
-	./src/*.c \
-	./src/audio/*.c \
-	./src/audio/disk/*.c \
-	./src/audio/dsp/*.c \
-	./src/audio/dummy/*.c \
-	./src/cpuinfo/*.c \
-	./src/events/*.c \
-	./src/file/*.c \
-	./src/haptic/*.c \
-	./src/haptic/linux/*.c \
-	./src/joystick/*.c \
-	./src/joystick/linux/*.c \
-	./src/loadso/dlopen/*.c \
-	./src/sensor/*.c \
-	./src/sensor/dummy/*.c \
-	./src/stdlib/*.c \
-	./src/thread/*.c \
-	./src/thread/pthread/SDL_syscond.c \
-	./src/thread/pthread/SDL_sysmutex.c \
-	./src/thread/pthread/SDL_syssem.c \
-	./src/thread/pthread/SDL_systhread.c \
-	./src/timer/*.c \
-	./src/timer/unix/*.c \
-	./src/video/*.c \
-	./src/video/dummy/*.c \
-	./src/video/pandora/*.c \
-	
-
-OBJECTS = $(shell echo $(SOURCES) | sed -e 's,\.c,\.o,g')
-
-all: config_copy $(TARGET_STATIC) $(TARGET_SHARED)
-
-$(TARGET_STATIC): $(OBJECTS)
-	$(AR) crv $@ $^
-	$(RANLIB) $@
-
-$(TARGET_SHARED):
-	$(CC) -shared -Wl,-soname,$(TARGET_SHARED).0 -o $(TARGET_SHARED).0.0.1  $(OBJECTS)
-	ln -s $(TARGET_SHARED).0.0.1 $(TARGET_SHARED).0
-	ln -s $(TARGET_SHARED).0 $(TARGET_SHARED)
-
-config_copy:
-	cp include/SDL_config_wiz.h include/SDL_config.h
-
-clean:
-	rm -f $(TARGET_STATIC) $(TARGET_SHARED)* $(OBJECTS)
-
-install:
-	mkdir -p $(WIZSDK)/lib
-	mkdir -p $(WIZSDK)/include/SDL2
-	cp -f $(TARGET_STATIC) $(WIZSDK)/lib
-	cp -f $(TARGET_SHARED).0.0.1 $(WIZSDK)/lib
-	rm -f $(WIZSDK)/lib/$(TARGET_SHARED).0 $(WIZSDK)/lib/$(TARGET_SHARED)
-	ln -s $(WIZSDK)/lib/$(TARGET_SHARED).0.0.1 $(WIZSDK)/lib/$(TARGET_SHARED).0
-	ln -s $(WIZSDK)/lib/$(TARGET_SHARED).0 $(WIZSDK)/lib/$(TARGET_SHARED)
-
-	cp $(TARGET_STATIC) ../../toolchain/libs
-	cp $(TARGET_SHARED).0.0.1 ../../toolchain/libs
-	rm -f ../../toolchain/libs/$(TARGET_SHARED).0 ../../toolchain/libs/$(TARGET_SHARED)
-	ln -s ../../toolchain/libs/$(TARGET_SHARED).0.0.1 ../../toolchain/libs/$(TARGET_SHARED).0
-	ln -s ../../toolchain/libs/$(TARGET_SHARED).0 ../../toolchain/libs/$(TARGET_SHARED)
-
-	cp $(TARGET_SHARED).0.0.1 ../nehe_demos/build/$(TARGET_SHARED).0
-	cp -f include/*.h $(WIZSDK)/include/SDL2/
-	cp -f include/*.h ../../toolchain/include/SDL2/
diff --git a/Engine/lib/sdl/README.txt b/Engine/lib/sdl/README.md
similarity index 71%
rename from Engine/lib/sdl/README.txt
rename to Engine/lib/sdl/README.md
index 431ba0e74..d1719bb6f 100644
--- a/Engine/lib/sdl/README.txt
+++ b/Engine/lib/sdl/README.md
@@ -1,11 +1,6 @@
 
-                         Simple DirectMedia Layer
+# Simple DirectMedia Layer (SDL) Version 2.0
 
-                                  (SDL)
-
-                                Version 2.0
-
----
 https://www.libsdl.org/
 
 Simple DirectMedia Layer is a cross-platform development library designed
@@ -18,4 +13,5 @@ More extensive documentation is available in the docs directory, starting
 with README.md
 
 Enjoy!
-	Sam Lantinga				(slouken@libsdl.org)
+
+Sam Lantinga (slouken@libsdl.org)
diff --git a/Engine/lib/sdl/SDL2.spec.in b/Engine/lib/sdl/SDL2.spec.in
index eee5e5d83..812d2d861 100644
--- a/Engine/lib/sdl/SDL2.spec.in
+++ b/Engine/lib/sdl/SDL2.spec.in
@@ -63,7 +63,7 @@ rm -rf $RPM_BUILD_ROOT
 
 %files
 %{__defattr}
-%doc README*.txt COPYING.txt CREDITS.txt BUGS.txt
+%doc README*.txt LICENSE.txt CREDITS.txt BUGS.txt
 %{_libdir}/lib*.%{__soext}.*
 
 %files devel
diff --git a/Engine/lib/sdl/SDL2Config.cmake b/Engine/lib/sdl/SDL2Config.cmake
index 4a5f64602..3e4ebe1e8 100644
--- a/Engine/lib/sdl/SDL2Config.cmake
+++ b/Engine/lib/sdl/SDL2Config.cmake
@@ -1 +1,119 @@
-include("${CMAKE_CURRENT_LIST_DIR}/SDL2Targets.cmake")
+if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/SDL2Targets.cmake")
+  include("${CMAKE_CURRENT_LIST_DIR}/SDL2Targets.cmake")
+endif()
+if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/SDL2mainTargets.cmake")
+  include("${CMAKE_CURRENT_LIST_DIR}/SDL2mainTargets.cmake")
+endif()
+if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/SDL2staticTargets.cmake")
+  include("${CMAKE_CURRENT_LIST_DIR}/SDL2staticTargets.cmake")
+endif()
+
+# on static-only builds create an alias
+if(NOT TARGET SDL2::SDL2 AND TARGET SDL2::SDL2-static)
+  if(CMAKE_VERSION VERSION_LESS "3.18")
+      # Aliasing local targets is not supported on CMake < 3.18, so make it global.
+      set_target_properties(SDL2::SDL2-static PROPERTIES IMPORTED_GLOBAL TRUE)
+  endif()
+  add_library(SDL2::SDL2 ALIAS SDL2::SDL2-static)
+endif()
+
+# provide ${SDL2_LIBRARIES}, ${SDL2_INCLUDE_DIRS} etc, like sdl2-config.cmake does,
+# for compatibility between SDL2 built with autotools and SDL2 built with CMake
+
+# the following seems to work on Windows for both MSVC and MINGW+MSYS and with both SDL2Config/Target.cmake
+# from vcpkg and from building myself with cmake from latest git
+# AND on Linux when building SDL2 (tested current git) with CMake
+
+# the headers are easy - but note that this adds both .../include/ and .../include/SDL2/
+# while the SDL2_INCLUDE_DIRS of sdl2-config.cmake only add ...include/SDL2/
+# But at least if building worked with sdl2-config.cmake it will also work with this.
+get_target_property(SDL2_INCLUDE_DIRS SDL2::SDL2 INTERFACE_INCLUDE_DIRECTORIES)
+
+# get the paths to the files to link against (.lib or .dll.a on Windows, .so or .a on Unix, ...) for both SDL2 and SDL2main
+
+# for the "normal"/release build they could be in lots of different properties..
+set(relprops IMPORTED_IMPLIB_RELEASE IMPORTED_IMPLIB_NOCONFIG IMPORTED_IMPLIB IMPORTED_IMPLIB_MINSIZEREL IMPORTED_IMPLIB_RELWITHDEBINFO
+             IMPORTED_LOCATION_RELEASE IMPORTED_LOCATION_NOCONFIG IMPORTED_LOCATION IMPORTED_LOCATION_MINSIZEREL IMPORTED_LOCATION_RELWITHDEBINFO)
+
+# fewer possibilities for debug builds
+set(dbgprops IMPORTED_IMPLIB_DEBUG IMPORTED_LOCATION_DEBUG)
+
+foreach(prop ${relprops})
+	get_target_property(sdl2implib SDL2::SDL2 ${prop})
+	if(sdl2implib)
+		#message("set sdl2implib from ${prop}")
+		break()
+	endif()
+endforeach()
+
+foreach(prop ${relprops})
+	get_target_property(sdl2mainimplib SDL2::SDL2main ${prop})
+	if(sdl2mainimplib)
+		#message("set sdl2mainimplib from ${prop}")
+		break()
+	endif()
+endforeach()
+
+foreach(prop ${dbgprops})
+	get_target_property(sdl2implibdbg SDL2::SDL2 ${prop})
+	if(sdl2implibdbg)
+		#message("set sdl2implibdbg from ${prop}")
+		break()
+	endif()
+endforeach()
+
+foreach(prop ${dbgprops})
+	get_target_property(sdl2mainimplibdbg SDL2::SDL2main ${prop})
+	if(sdl2mainimplibdbg)
+		#message("set sdl2mainimplibdbg from ${prop}")
+		break()
+	endif()
+endforeach()
+
+if( sdl2implib AND sdl2mainimplib AND sdl2implibdbg AND sdl2mainimplibdbg )
+	# we have both release and debug builds of SDL2 and SDL2main, so use this ugly
+	# generator expression in SDL2_LIBRARIES to support both in MSVC, depending on build type configured there
+	set(SDL2_LIBRARIES $<IF:$<CONFIG:Debug>,${sdl2mainimplibdbg},${sdl2mainimplib}>   $<IF:$<CONFIG:Debug>,${sdl2implibdbg},${sdl2implib}>)
+else()
+	if( (NOT sdl2implib) AND sdl2implibdbg ) # if we only have a debug version of the lib
+		set(sdl2implib ${sdl2implibdbg})
+	endif()
+	if( (NOT sdl2mainimplib) AND sdl2mainimplibdbg ) # if we only have a debug version of the lib
+		set(sdl2mainimplib ${sdl2mainimplibdbg})
+	endif()
+
+	if( sdl2implib AND sdl2mainimplib )
+		set(SDL2_LIBRARIES ${sdl2mainimplib}  ${sdl2implib})
+	elseif(WIN32 OR APPLE) # I think these platforms have a non-dummy SDLmain?
+		message(FATAL_ERROR, "SDL2::SDL2 and/or SDL2::SDL2main don't seem to contain any kind of IMPORTED_IMPLIB* or IMPORTED_LOCATION*")
+	elseif(sdl2implib) # on other platforms just libSDL2 will hopefully do?
+		set(SDL2_LIBRARIES ${sdl2implib})
+		message(STATUS, "No SDL2main lib not found, I hope you don't need it..")
+	else()
+		message(FATAL_ERROR, "SDL2::SDL2 doesn't seem to contain any kind of lib to link against in IMPORTED_IMPLIB* or IMPORTED_LOCATION*")
+	endif()
+
+	# TODO: should something like INTERFACE_LINK_LIBRARIES be appended? or wherever -mwindows and things like that
+	#       might be defined (if they were defined by the CMake build at all; autotools has @SDL_RLD_FLAGS@ @SDL_LIBS@)?
+	#       LINK_DEPENDS? LINK_FLAGS?
+
+endif()
+
+get_filename_component(SDL2_LIBDIR ${sdl2implib} PATH)
+
+# NOTE: SDL2_LIBRARIES now looks like "c:/path/to/SDL2main.lib;c:/path/to/SDL2.lib"
+#       which is different to what it looks like when coming from sdl2-config.cmake
+#       (there it's more like "-L${SDL2_LIBDIR} -lSDL2main -lSDL2" - and also -lmingw32 and -mwindows)
+#       This seems to work with both MSVC and MinGW though, while the other only worked with MinGW
+#   On Linux it looks like "/tmp/sdl2inst/lib/libSDL2main.a;/tmp/sdl2inst/lib/libSDL2-2.0.so.0.14.1" which also seems to work
+
+# the exec prefix is one level up from lib/ - TODO: really, always? at least on Linux there's /usr/lib/x86_64-bla-blub/libSDL2-asdf.so.0 ..
+get_filename_component(SDL2_EXEC_PREFIX ${SDL2_LIBDIR} PATH)
+set(SDL2_PREFIX ${SDL2_EXEC_PREFIX}) # TODO: could this be somewhere else? parent dir of include or sth?
+
+unset(sdl2implib)
+unset(sdl2mainimplib)
+unset(sdl2implibdbg)
+unset(sdl2mainimplibdbg)
+unset(relprops)
+unset(dbgprops)
diff --git a/Engine/lib/sdl/TODO.txt b/Engine/lib/sdl/TODO.txt
index 0cd6c4db4..456a8ae3c 100644
--- a/Engine/lib/sdl/TODO.txt
+++ b/Engine/lib/sdl/TODO.txt
@@ -1,5 +1,5 @@
 Future work roadmap:
- * http://wiki.libsdl.org/moin.cgi/Roadmap
+ * http://wiki.libsdl.org/Roadmap
 
  * Check 1.2 revisions:
 	3554 - Need to resolve semantics for locking keys on different platforms
diff --git a/Engine/lib/sdl/VisualC-WinRT/SDL2-WinRT.nuspec b/Engine/lib/sdl/VisualC-WinRT/SDL2-WinRT.nuspec
deleted file mode 100644
index 3a663d59e..000000000
--- a/Engine/lib/sdl/VisualC-WinRT/SDL2-WinRT.nuspec
+++ /dev/null
@@ -1,23 +0,0 @@
-<?xml version="1.0"?>
-<package >
-  <metadata>
-    <id>SDL2-WinRT</id>
-    <version>2.0.4-Unofficial</version>
-    <authors>Sam Lantinga</authors>
-    <owners>David Ludwig</owners>
-    <licenseUrl>http://libsdl.org/license.php</licenseUrl>
-    <projectUrl>http://libsdl.org</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Unofficial pre-release of LibSDL2, built for WinRT platforms</description>
-    <copyright>Copyright 2015</copyright>
-    <tags>SDL2 SDL LibSDL OpenGL C C++ nativepackage</tags>
-  </metadata>
-  <files>
-    <file src="lib\**\*.dll" target="bin"/>
-    <file src="lib\**\*.lib" target="bin"/>
-    <file src="lib\**\*.pdb" target="bin"/>
-    <file src="..\include\**\*.*" target="include"/>
-    <file src="..\src\**\*.*" target="src"/>
-    <file src="SDL2-WinRT.targets" target="build\native"/>
-  </files>
-</package>
diff --git a/Engine/lib/sdl/VisualC-WinRT/SDL2-WinRT.targets b/Engine/lib/sdl/VisualC-WinRT/SDL2-WinRT.targets
deleted file mode 100644
index 51cddb785..000000000
--- a/Engine/lib/sdl/VisualC-WinRT/SDL2-WinRT.targets
+++ /dev/null
@@ -1,38 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-
-  <PropertyGroup>
-    <LibSDL2-DeviceType Condition="'$(TargetPlatformIdentifier)' == 'Windows' and '$(TargetPlatformVersion)' == '8.1'">WinRT81</LibSDL2-DeviceType>
-    <LibSDL2-DeviceType Condition="'$(TargetPlatformIdentifier)' == 'Windows Phone' and '$(TargetPlatformVersion)' == '8.0'">WinPhone80</LibSDL2-DeviceType>
-    <LibSDL2-DeviceType Condition="'$(TargetPlatformIdentifier)' == 'WindowsPhoneApp' and '$(TargetPlatformVersion)' == '8.1'">WinPhone81</LibSDL2-DeviceType>
-    <LibSDL2-DeviceType Condition="'$(TargetPlatformIdentifier)' == 'UAP'">UWP</LibSDL2-DeviceType>
-
-  	<LibSDL2-BinPath>$(MSBuildThisFileDirectory)..\..\bin\$(LibSDL2-DeviceType)\$(Platform)</LibSDL2-BinPath>
-  </PropertyGroup>
-
-  <Target Name="LibSDL2-DeviceType-Check" BeforeTargets="ResolveAssemblyReferences">
-      <Error Condition="'$(LibSDL2-DeviceType)' == ''" Text="Unable to determine which version of Windows is being built-for" />
-  </Target>
-
-  <ItemDefinitionGroup>
-    <Link>
-      <AdditionalLibraryDirectories>$(LibSDL2-BinPath);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <AdditionalDependencies>SDL2.lib;%(AdditionalDependencies)</AdditionalDependencies>
-    </Link>
-  </ItemDefinitionGroup>
-
-  <ItemDefinitionGroup>
-    <ClCompile>
-      <AdditionalIncludeDirectories>$(MSBuildThisFileDirectory)..\..\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-    </ClCompile>
-  </ItemDefinitionGroup>
-
-  <ItemGroup Label="LibSDL2">
-    <PackagingOutputs Include="$(LibSDL2-BinPath)\SDL2.dll">
-        <OutputGroup>LibSDL2Binaries</OutputGroup>
-        <ProjectName>$(ProjectName)</ProjectName>
-        <TargetPath>%(Filename)%(Extension)</TargetPath>
-    </PackagingOutputs>
-  </ItemGroup>
-
-</Project>
diff --git a/Engine/lib/sdl/VisualC-WinRT/SDL2main-WinRT-NonXAML.nuspec b/Engine/lib/sdl/VisualC-WinRT/SDL2main-WinRT-NonXAML.nuspec
deleted file mode 100644
index 491c32386..000000000
--- a/Engine/lib/sdl/VisualC-WinRT/SDL2main-WinRT-NonXAML.nuspec
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0"?>
-<package >
-  <metadata>
-    <id>SDL2main-WinRT-NonXAML</id>
-    <version>2.0.4-Unofficial</version>
-    <authors>Sam Lantinga</authors>
-    <owners>David Ludwig</owners>
-    <licenseUrl>http://libsdl.org/license.php</licenseUrl>
-    <projectUrl>http://libsdl.org</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>WinMain() function for SDL2 + WinRT + CoreWindow (non-XAML) apps</description>
-    <copyright>Copyright 2015</copyright>
-    <tags>SDL2 SDL LibSDL OpenGL C C++ nativepackage</tags>
-    <dependencies>
-      <dependency id="SDL2-WinRT" version="2.0.4"/>
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\src\main\winrt\SDL_winrt_main_NonXAML.cpp" target="src\main\winrt"/>
-    <file src="SDL2main-WinRT-NonXAML.targets" target="build\native"/>
-  </files>
-</package>
diff --git a/Engine/lib/sdl/VisualC-WinRT/SDL2main-WinRT-NonXAML.targets b/Engine/lib/sdl/VisualC-WinRT/SDL2main-WinRT-NonXAML.targets
deleted file mode 100644
index 4dede303e..000000000
--- a/Engine/lib/sdl/VisualC-WinRT/SDL2main-WinRT-NonXAML.targets
+++ /dev/null
@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-
-  <ItemGroup Label="LibSDL2">
-    <ClCompile Include="$(MSBuildThisFileDirectory)..\..\src\main\winrt\SDL_winrt_main_NonXAML.cpp">
-      <CompileAsWinRT>true</CompileAsWinRT>
-    </ClCompile>
-  </ItemGroup>
-
-</Project>
diff --git a/Engine/lib/sdl/VisualC-WinRT/tests/loopwave/Assets/Logo.png b/Engine/lib/sdl/VisualC-WinRT/tests/loopwave/Assets/Logo.png
deleted file mode 100644
index e26771cb33a49bbef824aa333737181b0a5b09a3..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 801
zcmeAS@N?(olHy`uVBq!ia0vp^(?FPm4M^HB7Cr(}k|nMYCBgY=CFO}lsSJ)O`AMk?
zp1FzXsX?iUDV2pMQ*9U+m=1foIEGZ*dUJQLud<^=L*gE#63Ho!PGzwUb%GPK6&5iF
zt!p@aGNX}6<M7XW5|S^O@_K8GcU#~8zUR`ZM%|n9Dor+T`?Fc{_(!KzcM~{RrX3K9
z5Q<>(PVh|N)M-?0RNcTbjaWgEU8noxUax-n>&3Ay)#!y&O11y2s<nJ)KKpF-5>KEF
zt72@XC1)RvT6Xw=y_`Ce)`nGULLL^lI$kwi^E+dQT7YeXY4GvlRR%kj1x$VZi%Bdd
zz}2Giy=-_$h+v#(S+};)DuE4EM?_^qB_eDeo@&q%StD1F>L|*0ZC2sb-}llSMTM?O
z6{b3iid~yk@VE7q7Wb+P8?H5IYp?pSVcL<YlA&A?-VaXoY4NVHEc9LQYbtA~Rz&fG
zSq@)=-u<?`9I^cOnQHAA^#I!x>E~18m#ygK20HL@6W5woI~Fjlw$fX1U{xQA5a+t0
zH$WNIb=fNpWHo}M9#;K6eszDZKty_|-?j4iocj5#zotrWc;@;w`H@=mjsvS2wXX0_
zY}l$4@^sE?UcC)ji*L=Z&}P!xaL&2((OQlj2dv~pV-ifAS;ZsH1{`D!GY%<eyvhR<
zs$H~ebuZVtCmT*Zk#o4a&4D#MD8fBt_p}ucyx6k+LJCwHx3XyMXgVAv6j~PJY!vd_
zGBEX+sRPiQ|NU7P>yys5WH)f>ZLo5m%6XjuXdbKMR7MEHSyb{m!_{Afji&MT$_sz7
z>1{~MlIFe28FRN(GC_~;#Jp4ADipP+9hh|P#-&`vO-Upt3jE0@YLh(^55uYWl9g)Z
RA3>Rb!PC{xWt~$(69A&hN*MqE

diff --git a/Engine/lib/sdl/VisualC-WinRT/tests/loopwave/Assets/SmallLogo.png b/Engine/lib/sdl/VisualC-WinRT/tests/loopwave/Assets/SmallLogo.png
deleted file mode 100644
index 1eb0d9d528c42f132872e8af4dc563081b0b9aff..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 329
zcmV-P0k-~$P)<h;3K|Lk000e1NJLTq0015U0015c1^@s6J20-I0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUy>q$gGRCwC#*X;?zAP@%N+|i#I!$mrh
zlQ>KU$Rdu>|JH&931_?y6Djl{gb>4nCV5pzDJ?S!mq|4ZejKj%i@j$H{#ML~2Y{DF
z$=}bKPaz+UGt{v(4CTQQXym}&iW8{s!ew~XIE7NLjQpy#I2S$rous$~?f%DHT#B*+
zq=#!zc5=0FEqWFpB%UE(L807on!pidHPLgYO}XEgorrg;PB=8ipgQ5u5`&g_MQaRd
zaU7Ao8XQMuuN21-s0PPTs1%38x_Yl3Fs-|Y4!C-;M-8<ZZS<TqNqib^SMD<4zlFK0
b-U18&d-UZ%OI+v700000NkvXXu0mjfvyO*s

diff --git a/Engine/lib/sdl/VisualC-WinRT/tests/loopwave/Assets/SplashScreen.png b/Engine/lib/sdl/VisualC-WinRT/tests/loopwave/Assets/SplashScreen.png
deleted file mode 100644
index c951e031bdfa0d4ebe68d52647f14caf710ca471..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2146
zcmb_ee{2(V6#s5lN>g@n*v@1<b=M3U|6s-?wu(;ZSjSjm7Y1Z0YO=0bp{Bc`WN|E_
z-fA4z*Z`44la{D-24m8dH56jSm~E7z@kgl6qju4O{=v*9DC!?9Mttw?x}MP~ME`nw
z-+tfcectDN@4bb$w71emi;)mQw{3Q9C8V;KkczbiJ)Ath=IRufn*J6~|F+#b`v<!B
z_(@aGZl9lP<GXkHxB9z#2A}@O-$;l-*XC;4zPC94bwl5z)7;YW@U`4*p+h=!S3Y(B
z{>|s#GQ665=9@Rxy?u0YW0&WN+~=RXpPbVXXL4m7Aq=E6I0%{06TwRn=U9d8>exk>
zD-Z%M3DNQ`bTLSEF=%NFyoHcAkD*Ci<!z`e%=hWWPQScr{MpVjjS`}U#(fs{@?@s(
z=f)Rms4qw77OwBjM0H2b7}+Cp3%?zuQhI}f;W-H+<8;Y^n&WiVVsJRqR%y}ko`?mS
z6ZV-Eg7?Mm8Xq`Y%~#b19im=)8G{(UjHJNY0DdT7;zc{!=0w=e^a@}rLbQt&RR<5b
zqKoy>Xqljo*0E?o$Gi<JD3u@fm{d#YSkaM<dZ-CKSPNHhro*bWN?Pjfbl9HKhiFF5
zzF1`3t!2URK6hfsODWk))M5dXmW3+@*%daJ5ZM3=u2^Dm*o?pa+pW9}6%`$+l7$8!
zchnv%a8)cSha43PN`b6yR7~coSWrp`u<MEn9T^bl$lRnIfThNk0Y^_jNeW2{V-@G|
zT`H+l7fUBksnPWhs(5$Y$zx-Lz={JZ)n%<QrT)-}%4<S_VU(-nzq-QfYd4YAEz@=B
zW5eg)TR$_iM}DBf$jInVb)ua+&>DC4q}}|%*0WghLlK#npw?hecrM}Mw?`E(z5C8<
z8&*b^!{>5?4aT89vdrgBgSc-x6JZD3F^l#*G(@OO*^1D%Eu7?HAy<3k<n+|3Ofo=y
z3mktj2alVo?!FMUB!4yWhreJ1b7w)g;``y;ZRb2Yo`gp--tp&nV>TLqW9N{^#6vso
zVQwY48q7)m{~xQ64RV7{E7Y=&T~?^05Ky`5oNQ8bLgFCPq9co^R09BVRS1OAmH;hU
zC#q(N!gNqm!zU#%sv{r5mm-Uv8b-~a1F-;p^>)pnXfKge4s9?;;MFIr*fixPG}NBA
z6_G5BEmeO6XXh(emkciB{7tA;iwC2^s^VzyU_h0@ae84ACMY`cIDEju=<`q|2QAEv
zW_)W|i|9aknqdmS=#w73eW_csQ$8IhT^vY1^1;X3&J0{%*tcQq!gJpr3w?TJc~@5=
zKV5sM{$3k>b#S$@CTkhIF*{v*u(F&$&Yq1naHxt8Mz2N%7aQ3(^VNRZahk1||7?Bl
z*idzO_u)FhRj4cPzDO>YA>>lxAGaciEiX8Xzp1SVPv91};$OG3cC&8!v3{Jq^kH@8
UTIccK;hzT5*3#}uZuEx!0OwrBv;Y7A

diff --git a/Engine/lib/sdl/VisualC-WinRT/tests/loopwave/Assets/StoreLogo.png b/Engine/lib/sdl/VisualC-WinRT/tests/loopwave/Assets/StoreLogo.png
deleted file mode 100644
index dcb672712c6823a0c91548ded70a8acb85536b4d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 429
zcmV;e0aE^nP)<h;3K|Lk000e1NJLTq001%o001%w1^@s69zTe&0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzPf0{URCwC#+R+KaAP@%Nc=WMjbdiqa
zBpIN?bdiqXduqTy9wJ8X{yRw&LZJomt1)*Mb<46$S7<a{qz%Y`fZ8MT{kQXRzi&4q
z`xfHmopV2n0mks~iXU^lo}4ujQU`PD&=L_i5O0M!K=@`zx}DT9M~Kp`U0m$im=?t8
zr<N9`6;bv0MPoRK>NtYJa1l)bQ5qwGXpZbs7%2oRMd4y35$s&66(fxhNg8W02!vSn
zdlrL2h^Fx+3=$z;kK{0D#MyeJ8WRWZcLSf(PcQ_mLOhrmC}O-tX^0c>5`YvCUZVsc
zG-6#78ubjJ5nA;OX&^K(q=i6ZNE3m?kTwE^AqxZoLskfB3|S&1F=UO9!cY$g2@Lgu
z;9{sJ1P9|X2L`r1#Gs8R{E^$PRrMaC86q<?teSo8;M4n2kIR(0ZXBu^kO8>|<S)Pg
XJ9Ld-yKA-b00000NkvXXu0mjfItQrL

diff --git a/Engine/lib/sdl/VisualC-WinRT/tests/loopwave/Package.appxmanifest b/Engine/lib/sdl/VisualC-WinRT/tests/loopwave/Package.appxmanifest
deleted file mode 100644
index 8cf17aec4..000000000
--- a/Engine/lib/sdl/VisualC-WinRT/tests/loopwave/Package.appxmanifest
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Package xmlns="http://schemas.microsoft.com/appx/2010/manifest">
-
-  <Identity Name="1702c480-cf09-431e-a5e4-b21b283ec818"
-            Publisher="CN=David"
-            Version="1.0.0.0" />
-
-  <Properties>
-    <DisplayName>loopwave_VS2012_WinRT</DisplayName>
-    <PublisherDisplayName>David</PublisherDisplayName>
-    <Logo>Assets\StoreLogo.png</Logo>
-  </Properties>
-
-  <Prerequisites>
-    <OSMinVersion>6.2.1</OSMinVersion>
-    <OSMaxVersionTested>6.2.1</OSMaxVersionTested>
-  </Prerequisites>
-
-  <Resources>
-    <Resource Language="x-generate"/>
-  </Resources>
-
-  <Applications>
-    <Application Id="App"
-        Executable="$targetnametoken$.exe"
-        EntryPoint="loopwave_VS2012_WinRT.App">
-        <VisualElements
-            DisplayName="loopwave_VS2012_WinRT"
-            Logo="Assets\Logo.png"
-            SmallLogo="Assets\SmallLogo.png"
-            Description="loopwave_VS2012_WinRT"
-            ForegroundText="light"
-            BackgroundColor="#464646">
-            <DefaultTile ShowName="allLogos" />
-            <SplashScreen Image="Assets\SplashScreen.png" />
-        </VisualElements>
-    </Application>
-  </Applications>
-  <Capabilities>
-    <Capability Name="internetClient" />
-  </Capabilities>
-</Package>
\ No newline at end of file
diff --git a/Engine/lib/sdl/VisualC-WinRT/tests/loopwave/loopwave_VS2012_TemporaryKey.pfx b/Engine/lib/sdl/VisualC-WinRT/tests/loopwave/loopwave_VS2012_TemporaryKey.pfx
deleted file mode 100644
index 3c07b779f56405e71431543ad8e28b5bbb995690..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2504
zcmY+Ec{tQ-8^?cR#xSxQM3zCxgpA!B3CX^fec$(WM6U=9hHPQ%jj<O(2%YT8ej>}s
zUSkr9#Kg&@4)3pXz3(~K`Qv_`@BMl1`@Zgfo-YQE7-WDzF?d7*9C3kQKsaQBFhR=k
zh;SGl5e#B~44(1mUr&tNFg)WXh}XcNz)$_Ji<Je!P>zQkWALyej1ZjV{}>$34r4~O
zzT(_zQ6VxgFipYmum!R4@3e<CSChmfu$`+#H<00Vw;YkbOS_H+{IcPXazl(=v<gIv
zM$~!)ksRx|N%b+h?bnHUuNP9}zx^RLz?xop1G_HM73B=I{y;-)iHt9;p}qZlsTl4w
z!Of7U+ZR@Hx`e$<;apiGWl0CuT)vLkulbcNJ5k?JPL|$N-qR<o5av|9gKmUQa7iBC
zsNR+qdDov-q!*xgG-Je{v-k{>omc+?d6L!Kf~t$1h?NUv@Zk&~3YQ5tYuZ*N!eXK(
zJjE1cw7SS8YK#jb-63v+o!CvjWh->q#Eeg6&{7IF)%hc5pjs{zoq(O4e~`DM!C<pS
zUs?WRqy5Q%E<q_PxxpAJ-L|ejEW`0jZko*b&2c*$_WLRPi#85P`vmlQR>sEhx1yRL
zy5{a=!}5zyM4Nk2SGE*4mMT%$z0Kh0M2mXonnQ6fQyv!$XMV#M9?}(ljOvP8<B}7S
zyvKU!absWl&tQI#y>RCe!|>f2((*_S@pleL@dAN*g<Z~p%AK?3;l(`Ay+QtnI$UIM
z0_pzS6~1;%K$zLH#}94FJq9zsMZ}Hj-nn#LD$OsaQOP=e+Gi-FwARo#LyEr7;E*zi
zFfe}ZaaNRFlXvpv{iJ)^9r`<|GoJqcY3(fy5wIAjJqZIKHwQWkj?V23R9;Rs*x|@0
zHZt4&a5Qo+8{C|;%bLi3l}0$oG}0dGR{e3a`}pog3qe9%KxW_uG~m<>a_Lz=vFNGQ
zS<1T;m1bhOA$y0?3@+t}o11k;P}{th;w?dSp*E0vvo%Mw*L?8e0?Zfl;zC3<nFBe8
zg;rQgi{l<Q{dPK#5G>c^AUK~JPdvO;^Q!-(!77_a<6=QPD;HTM0a+$Hb?8~U<b}PZ
zVPLCsS_f_Rn`&wx4cpTa_@d`c!<$p~?oF&AS2<VKSnrg!SPij!<yf{j)AQcd`3m6M
zg~_}Nv=14x%Eyzp9hod2!TV0TrJu<&J#DgHWjmyiflBA@Dv!M_ne%6Il&+|!_#lx-
zjMedRim}7zKwis+XS3tB?c<I`dkTf+4<bz^mMb>7k4?@@>dMhSaN0Ihn}!FqEf(&V
zXn*?n+;i8RZ;R~99&AP|rWBG?c2R<gZWYp{n@@vpBZ}i69DQpIYx4i_WodxpUB1Dp
z(<&JwzH%$WEyrO+&^@l_!D+uAr&lF!^2NS%SG*p-@9|Y}8~^r>wo1~Jck^~V``tV=
z#z1yb{f!*C$fh6;@x@BCM9nYw3GOA^fJwVSVz^IS>4xn{bBqVEY1G_(-NjsxW)hzx
z?zo=JUx|u7$Uyf)wj0KJt@S3}hQ^=Fj_g(y7V0W8U#Q6={YufNzHY3z>FJnI>vAec
zf8Z58?bGEWtvYfZqR=L#yPeHT$g=#pc4~S1k0Ki1bEib?^yAD4<MZz)KKEsiVAmvO
z&$J{`a~ba{&nrKt@E35#pp^PZPMgfM#)Dlkil<Jbv9!E!pH?ux%)Ji1-=mi0Y-x4W
zUJ<)=b4*D!i}xe5h>k2~UVpV16?3$I3n^MteaiNEEfj`!NjfrSZk}u%5w~``Gd`b#
zMbDe;eSLe$MDr?HwHyDRM{epC4Pz_<fLDxm#h^m*i}zKEQ3v$t_C}<y=RTgaSF458
zvRo-B3`lmLOP9Yhf#LbvE)l%)a2N~%0074JABdDU5-|X<fEwTdC;?u8BH#@wSwI<3
z0aO8ZP$>cOAXf#IJ6PojX0m@(dw^Z?AX5gz15g0N2jdJ!NW&p82ws&7B5xsL2ABf=
zU<(ci1tP%k0d4>&;5vBzBq4w=nCXBz8VCbfD465GVPSyZUtK7`;;*_WF!KV}!eQ`G
z-@i9!f|ui=b|A81fB@iS`p*mGUzQL5Y583=eYlV6xaUvHPryS_2|8B|%VlHD+=|*<
zlotPtPFb|gp?fc;W#qeBpe6esG+J7Q%CYr{DaVc~kb8i%$)_ak&JXoN7x*j<)o`XQ
z8#L+RwXJo2Wivx)LjTTYi^@{9TG+F&Pld4v@oYF@G?&YG|Dkl`R<uu9OLx!9FG%w_
zGiH+4)BIMiGy^@|wu|BEjY@y69#2Jk<r`v6H>++GXhCBkVMY#0^J30Qt=0R7S3;{F
zJL%^13O3J;WpdmYg-)#8`}*)vz{l-FL92<CTs!6I*8W$6K|ZAY!Go#JI<FM_lXUW^
z-EAR?v6MhS7nDQFfsR9o1ra^W?Fj+GBeY?NE9$#?=A|JvS57I?Fm34mMAU+EQ7FGg
z*7m7W(_2k<EX6GsXQMaP&$oq5jUN@&&FV+A3tu7>NVDUrT|xymV7~3EzxmP{<b~yU
zKO14PJ}WTD24=^H3s}Ric3wkCbifRZx3yfN_Yt=gT(1$Z5xD&gQYzwCR&D0}9W0Hz
z>``)6jtNF2nd!<BEb8|B!eOG{*6)j@N;=-HgwUDp%VPc&^ticc)|iHhC}iY8+0Ljv
zTkH91uZkd4Id7AcNVfQQJL%(lsq`cx{_Hob23`Fs>S+CRI$h>9;&oP~k>ktmxVE#z
zq)IGv^}+|1ZYQ!v7Giw%fP%GAF%^p|{?e}_BV~M)du!f*ak&0~)bV|yaSvhbQ2C^!
zM6HOM^`l|P6~-rJzSUD)RydxZ&c-ZR$^6BTA417`*_yY}GEUEWZ4S-j{0v<wtFaVf
zFNrsU8t5WuV*BF6&i5uzDJAE8-qk8_^ev}GtSE4|HapmR$bN$<sUst9?9iF;A-11d
z8~CJqyG*Lh@tn@w!#^@X7roY!zkI39h%hYKB-sOTe7x#xfE!?&@mPqt&+;iTF^c1$
zP*?V4bCvb_1wX6wfNqhIYkuKA4TK!VU7-TqxuOB{HvRkL<mpE>_cR$J`+CZwm-mh0
z{Sx+lBV*qY*L)#gYWWP?QAr&tSj{oM1c^(^U#k=gQ0IgMVPhUfZG0r^(d!XvBCaqG
zlc6{y7|C-PqmB{9Fu@t6*`W-AFys>Yl`q$?us-|chdhcMb*VSG+^8_5X>E=8(>Iky
ToyCz)S?HfgOO(BupC9bM?VoGZ

diff --git a/Engine/lib/sdl/VisualC-WinRT/tests/testthread/Assets/Logo.png b/Engine/lib/sdl/VisualC-WinRT/tests/testthread/Assets/Logo.png
deleted file mode 100644
index e26771cb33a49bbef824aa333737181b0a5b09a3..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 801
zcmeAS@N?(olHy`uVBq!ia0vp^(?FPm4M^HB7Cr(}k|nMYCBgY=CFO}lsSJ)O`AMk?
zp1FzXsX?iUDV2pMQ*9U+m=1foIEGZ*dUJQLud<^=L*gE#63Ho!PGzwUb%GPK6&5iF
zt!p@aGNX}6<M7XW5|S^O@_K8GcU#~8zUR`ZM%|n9Dor+T`?Fc{_(!KzcM~{RrX3K9
z5Q<>(PVh|N)M-?0RNcTbjaWgEU8noxUax-n>&3Ay)#!y&O11y2s<nJ)KKpF-5>KEF
zt72@XC1)RvT6Xw=y_`Ce)`nGULLL^lI$kwi^E+dQT7YeXY4GvlRR%kj1x$VZi%Bdd
zz}2Giy=-_$h+v#(S+};)DuE4EM?_^qB_eDeo@&q%StD1F>L|*0ZC2sb-}llSMTM?O
z6{b3iid~yk@VE7q7Wb+P8?H5IYp?pSVcL<YlA&A?-VaXoY4NVHEc9LQYbtA~Rz&fG
zSq@)=-u<?`9I^cOnQHAA^#I!x>E~18m#ygK20HL@6W5woI~Fjlw$fX1U{xQA5a+t0
zH$WNIb=fNpWHo}M9#;K6eszDZKty_|-?j4iocj5#zotrWc;@;w`H@=mjsvS2wXX0_
zY}l$4@^sE?UcC)ji*L=Z&}P!xaL&2((OQlj2dv~pV-ifAS;ZsH1{`D!GY%<eyvhR<
zs$H~ebuZVtCmT*Zk#o4a&4D#MD8fBt_p}ucyx6k+LJCwHx3XyMXgVAv6j~PJY!vd_
zGBEX+sRPiQ|NU7P>yys5WH)f>ZLo5m%6XjuXdbKMR7MEHSyb{m!_{Afji&MT$_sz7
z>1{~MlIFe28FRN(GC_~;#Jp4ADipP+9hh|P#-&`vO-Upt3jE0@YLh(^55uYWl9g)Z
RA3>Rb!PC{xWt~$(69A&hN*MqE

diff --git a/Engine/lib/sdl/VisualC-WinRT/tests/testthread/Assets/SmallLogo.png b/Engine/lib/sdl/VisualC-WinRT/tests/testthread/Assets/SmallLogo.png
deleted file mode 100644
index 1eb0d9d528c42f132872e8af4dc563081b0b9aff..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 329
zcmV-P0k-~$P)<h;3K|Lk000e1NJLTq0015U0015c1^@s6J20-I0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUy>q$gGRCwC#*X;?zAP@%N+|i#I!$mrh
zlQ>KU$Rdu>|JH&931_?y6Djl{gb>4nCV5pzDJ?S!mq|4ZejKj%i@j$H{#ML~2Y{DF
z$=}bKPaz+UGt{v(4CTQQXym}&iW8{s!ew~XIE7NLjQpy#I2S$rous$~?f%DHT#B*+
zq=#!zc5=0FEqWFpB%UE(L807on!pidHPLgYO}XEgorrg;PB=8ipgQ5u5`&g_MQaRd
zaU7Ao8XQMuuN21-s0PPTs1%38x_Yl3Fs-|Y4!C-;M-8<ZZS<TqNqib^SMD<4zlFK0
b-U18&d-UZ%OI+v700000NkvXXu0mjfvyO*s

diff --git a/Engine/lib/sdl/VisualC-WinRT/tests/testthread/Assets/SplashScreen.png b/Engine/lib/sdl/VisualC-WinRT/tests/testthread/Assets/SplashScreen.png
deleted file mode 100644
index c951e031bdfa0d4ebe68d52647f14caf710ca471..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2146
zcmb_ee{2(V6#s5lN>g@n*v@1<b=M3U|6s-?wu(;ZSjSjm7Y1Z0YO=0bp{Bc`WN|E_
z-fA4z*Z`44la{D-24m8dH56jSm~E7z@kgl6qju4O{=v*9DC!?9Mttw?x}MP~ME`nw
z-+tfcectDN@4bb$w71emi;)mQw{3Q9C8V;KkczbiJ)Ath=IRufn*J6~|F+#b`v<!B
z_(@aGZl9lP<GXkHxB9z#2A}@O-$;l-*XC;4zPC94bwl5z)7;YW@U`4*p+h=!S3Y(B
z{>|s#GQ665=9@Rxy?u0YW0&WN+~=RXpPbVXXL4m7Aq=E6I0%{06TwRn=U9d8>exk>
zD-Z%M3DNQ`bTLSEF=%NFyoHcAkD*Ci<!z`e%=hWWPQScr{MpVjjS`}U#(fs{@?@s(
z=f)Rms4qw77OwBjM0H2b7}+Cp3%?zuQhI}f;W-H+<8;Y^n&WiVVsJRqR%y}ko`?mS
z6ZV-Eg7?Mm8Xq`Y%~#b19im=)8G{(UjHJNY0DdT7;zc{!=0w=e^a@}rLbQt&RR<5b
zqKoy>Xqljo*0E?o$Gi<JD3u@fm{d#YSkaM<dZ-CKSPNHhro*bWN?Pjfbl9HKhiFF5
zzF1`3t!2URK6hfsODWk))M5dXmW3+@*%daJ5ZM3=u2^Dm*o?pa+pW9}6%`$+l7$8!
zchnv%a8)cSha43PN`b6yR7~coSWrp`u<MEn9T^bl$lRnIfThNk0Y^_jNeW2{V-@G|
zT`H+l7fUBksnPWhs(5$Y$zx-Lz={JZ)n%<QrT)-}%4<S_VU(-nzq-QfYd4YAEz@=B
zW5eg)TR$_iM}DBf$jInVb)ua+&>DC4q}}|%*0WghLlK#npw?hecrM}Mw?`E(z5C8<
z8&*b^!{>5?4aT89vdrgBgSc-x6JZD3F^l#*G(@OO*^1D%Eu7?HAy<3k<n+|3Ofo=y
z3mktj2alVo?!FMUB!4yWhreJ1b7w)g;``y;ZRb2Yo`gp--tp&nV>TLqW9N{^#6vso
zVQwY48q7)m{~xQ64RV7{E7Y=&T~?^05Ky`5oNQ8bLgFCPq9co^R09BVRS1OAmH;hU
zC#q(N!gNqm!zU#%sv{r5mm-Uv8b-~a1F-;p^>)pnXfKge4s9?;;MFIr*fixPG}NBA
z6_G5BEmeO6XXh(emkciB{7tA;iwC2^s^VzyU_h0@ae84ACMY`cIDEju=<`q|2QAEv
zW_)W|i|9aknqdmS=#w73eW_csQ$8IhT^vY1^1;X3&J0{%*tcQq!gJpr3w?TJc~@5=
zKV5sM{$3k>b#S$@CTkhIF*{v*u(F&$&Yq1naHxt8Mz2N%7aQ3(^VNRZahk1||7?Bl
z*idzO_u)FhRj4cPzDO>YA>>lxAGaciEiX8Xzp1SVPv91};$OG3cC&8!v3{Jq^kH@8
UTIccK;hzT5*3#}uZuEx!0OwrBv;Y7A

diff --git a/Engine/lib/sdl/VisualC-WinRT/tests/testthread/Assets/StoreLogo.png b/Engine/lib/sdl/VisualC-WinRT/tests/testthread/Assets/StoreLogo.png
deleted file mode 100644
index dcb672712c6823a0c91548ded70a8acb85536b4d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 429
zcmV;e0aE^nP)<h;3K|Lk000e1NJLTq001%o001%w1^@s69zTe&0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzPf0{URCwC#+R+KaAP@%Nc=WMjbdiqa
zBpIN?bdiqXduqTy9wJ8X{yRw&LZJomt1)*Mb<46$S7<a{qz%Y`fZ8MT{kQXRzi&4q
z`xfHmopV2n0mks~iXU^lo}4ujQU`PD&=L_i5O0M!K=@`zx}DT9M~Kp`U0m$im=?t8
zr<N9`6;bv0MPoRK>NtYJa1l)bQ5qwGXpZbs7%2oRMd4y35$s&66(fxhNg8W02!vSn
zdlrL2h^Fx+3=$z;kK{0D#MyeJ8WRWZcLSf(PcQ_mLOhrmC}O-tX^0c>5`YvCUZVsc
zG-6#78ubjJ5nA;OX&^K(q=i6ZNE3m?kTwE^AqxZoLskfB3|S&1F=UO9!cY$g2@Lgu
z;9{sJ1P9|X2L`r1#Gs8R{E^$PRrMaC86q<?teSo8;M4n2kIR(0ZXBu^kO8>|<S)Pg
XJ9Ld-yKA-b00000NkvXXu0mjfItQrL

diff --git a/Engine/lib/sdl/VisualC-WinRT/tests/testthread/Package.appxmanifest b/Engine/lib/sdl/VisualC-WinRT/tests/testthread/Package.appxmanifest
deleted file mode 100644
index 10deae2d4..000000000
--- a/Engine/lib/sdl/VisualC-WinRT/tests/testthread/Package.appxmanifest
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Package xmlns="http://schemas.microsoft.com/appx/2010/manifest">
-
-  <Identity Name="ca3178f1-b2b2-43bf-97dd-28ee1b7d32c5"
-            Publisher="CN=David"
-            Version="1.0.0.0" />
-
-  <Properties>
-    <DisplayName>testthread_VS2012_WinRT</DisplayName>
-    <PublisherDisplayName>David</PublisherDisplayName>
-    <Logo>Assets\StoreLogo.png</Logo>
-  </Properties>
-
-  <Prerequisites>
-    <OSMinVersion>6.2.1</OSMinVersion>
-    <OSMaxVersionTested>6.2.1</OSMaxVersionTested>
-  </Prerequisites>
-
-  <Resources>
-    <Resource Language="x-generate"/>
-  </Resources>
-
-  <Applications>
-    <Application Id="App"
-        Executable="$targetnametoken$.exe"
-        EntryPoint="testthread_VS2012_WinRT.App">
-        <VisualElements
-            DisplayName="testthread_VS2012_WinRT"
-            Logo="Assets\Logo.png"
-            SmallLogo="Assets\SmallLogo.png"
-            Description="testthread_VS2012_WinRT"
-            ForegroundText="light"
-            BackgroundColor="#464646">
-            <DefaultTile ShowName="allLogos" />
-            <SplashScreen Image="Assets\SplashScreen.png" />
-        </VisualElements>
-    </Application>
-  </Applications>
-  <Capabilities>
-    <Capability Name="internetClient" />
-  </Capabilities>
-</Package>
\ No newline at end of file
diff --git a/Engine/lib/sdl/VisualC-WinRT/tests/testthread/testthread_VS2012_TemporaryKey.pfx b/Engine/lib/sdl/VisualC-WinRT/tests/testthread/testthread_VS2012_TemporaryKey.pfx
deleted file mode 100644
index 97fd1e190077fd22da37b95fd53038fdd2ab7917..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2504
zcmY+Fc|4SB8^@nnj2VNngel8d$8IbUDqEJsG%<*X7>p(Rl2n|rMZ(FxWh-lT5rb?U
z`<mTb5fQRxchviIKJR<Z=RBX!egCfOdtLYP&-1(SR8%7r0>e{L_Yf%YaJ}$-CI~$w
zn~HLRQ&ILHzJsUIZU3u8HxH-MeFE_eI3^J2|E*$VfIzdU@I5>gzK!QbF#I2bn=`|a
z2Meza2ENVKL!tCTa4LLAwDU<KqxZ>t<9ul$t6S@~LT!$@7>n7VbeD5>WH>~pcDUHn
zlayc96V#zEv@4QDw5z`S-KTNxiRO@oUFf7;%vvi@#QYWF6j*!?v-7wD&o$hk;roGR
zjVwc(buh=hjXpjIMx<<{%^Y6t;Y%(WtKrf6Q7ILB1sg>6keMq~_0aU>co<)N$@tue
z7lc{7#PByhuXTc-tn2m4`*%!>M)phlXv){rqO+Jxu93xky1%~lG&fmNvs7B|8auXG
zvobleSVn&Jt=x!dyYE)9uh)B?N%C8+SyMN)TEK4MN-D7=hb2HE+~1D-4V7PH0M>oo
z`nk!ycXLlauis`4kCXW0=R$ya<tizK7dsRtkn!wmMTJqKeVPU3IcM$Um9u;rdz-Ej
zmTw0vqY05qNfzTH9V(%_6j!A-b?4Wth9W+!UCRnJz8NcrC+j(+#usx|5002lQW5z<
zX9PYBXxYWljdjnuGyTb}#V=Xp{7R0P9OC(MZk1Vtas%D}KnHzUt)*0u-6D;=b|6$s
z39Ag`?ry`}rmOR9P`n$5rEw&rtT*YS1b2>shJxKC<9DMECSqCp9IM$y^C;DR6Fn|3
z`D~?XTvl0oHsXorb?9h^%EOn1Q|;U>A4WH3maBEYgsIMBKFLJ<$kEhtQIq%-9oR^^
zRId}j=Z<Nw`NSfiu%j_Yvdu)=*5oRNX+Ue*QmYe8@r2b;)12Q8kA|?Z8MV(?f=Hb>
ztB_n?+GI*(OmVZg_YuN;iuq?IRQ%+Y#D&I7{*#?93!J$^>6~NFXZXc5a~ndGQ#o~h
z=um6x+l}n|7TKCJ!^Qx{WEK`rw<kTWALQmgCx~@y66warn_|;%)hILe*+yJ!IrFKL
z^KpxM6Y<(iBQM7AZSlSG)2K&P?baRf&K@;6TOy1G@=*haPtLNrFZJ3yIDI#cxQP+w
zzBOzZ!#O@;=h5kEl1wdoVgAsKjJJ>beV-Axe0?jrT+85372MU^Dy_4N8DulZ&l0#5
zESf2+biT)6aQsuhx2|sck1`h4&eBKyvw}x=kEQ)eI~5WF=d46tE3?ok6#ge$ch?;V
zGFpst-)WW)R#J_6c;mC<w~2<e<sSVT$Zl4YY(Ls(=0%ettR6>lViQbSnd0Z1&AZ9?
zDEa;Q4#qc=4!kH*eXO`t>hkiJh5}@73x`F9?mGw&PkhvkC&bAG+91~4xJ0&YPX=KX
zW85b1keHkKLQPGYghO<T#`D-ke)Jr0aw!Z2ljRtk_7khH!Bur1Mx>as%Ffg&5QaD5
zl)0tBJszHh(_Jp*NVCixwywqI#V23Zq85pieP`{7quGfWr|Rie!$W+uhOOIq<q9h2
z(q3ZuaAE8G`9I=oSsO)0?U>^%9CSCflir`Wpg+UbWtJ-IY0<w`qKoD)8VC46Y?$sd
zj)+D*#nPO<3w@}RUar>QTE>{Xj#~2cZWX|ID%YG`dO4<jAn-Ai<1((r7%AZGv1suh
z!(5%d(PZx1*M}?xwJ;m!81p2%4R6=K@^1>8P~KU-UzdON_W~L7Zep5rCuN@^KPa%e
zpl!Y2v#sBX&&slq=%M4nSLX1?ziMKY`p$B;zB)oa6iGxEn0Et*9j^_-3^dHeQN^sM
zkkb|zZ`t4a@oazFB<hST0uF}&0Dw392eQlR^XdV3Kn}PAC;|3>1E}(V6sYnbvjZaq
zFjfL*DX@YEi7gn}gDMA*!5#%b7Ocww%Anfetq>>)1OyJDDzQLhiM#~B5O4xpy#RN>
z8ypUR4}b-X!TA?)102Cj3ycE*50JToxfghd2SE926&4`=)#nFhWbjBYJQe2n_s!`M
z*;Lp~5Rsq|02IT2Dv*C!J>r+ud)TPkZ1d+S{IdFBDhwM9Ep%FFyML8uRDBDgGRb{n
zLd|rjInPFLJBYt^6LDzDYn#T$ZDh!;yKbtk@~4ch>OP8d?8?}<+Q0!;jIpr)`m3XQ
zA=KA-7Rk1qQ?3jSQrV5u^S<(K?{9G7oF%=+Go%%B1w$xf1(E}DNBJ12sWq>J<<0bL
zN1-@}4&+bC?pzwF7gM9DrzWT!l(r?7?S|bfZ7rqm*{=%Zeipp|S-Qa-V997E8F4DI
zBuI39(@sshW%{lmt6mUtTAriqC%x4iEl<T*BA=nEQGA7#HIXZ-`FKe}{vti+OU<Cj
zg^0%NoES0L-HVYk7ux;Nnwm@J2JhmK2-q;RI`nA2px8K3X<B%TLssZc$oEi+oOVb#
zNsZiFs5gDDp!Xv*F@5i>zB9q;u1ar+&qeg;mg{IM?rCaiynPJDee7(K^96l3M}x1H
z9raTVWc@bRDpXLPbJDjLPn`l*lD)dp%VTltd#{VxJ_bycoi5po(Lbe<PK$jWAJs{J
z!oBcZ_|5oUCd-BVtXNq(AhJ&qdi64$6zz+Ui@*678Nc@;S&>oQ`N#Y`C34+MiiCZe
z6xCdI`g9Hg)YX-ij25hG2VbZSL>_uoy6$nLRCezMC-J$bQIfkB&QTX%R*}vQXYac{
z>#SGuWp7QxB%B$8>L2{B5!xW2G49Y>9`l(PF-#a&jtPnEQ<w4C-Pf%c6iV$lKXpNz
zl7dtQ5MyTZeiaGgarNi48=lSV&R9Dht|&&I>id|Pz=!NXyRNF{NqYrJ4tebnsJS9q
zMw$s+7n{Ng&0uvq*0^<2&(3s}ekRO<puNZ*nXf8cNNF;jPI0iiAToCvcd5*g2_vp&
zHKqMP!6IJISNybh3w3RxEgKh&J^mWoHr$IeAAvep=mkso&t5w@(rqjH$nb*S3MQHW
zn@!s`NZg$$(0dPuGvSM-<mqfV)yvR1U7q+?*nNj-|ELl|M}%}~d53+@%F>%>+WG?z
zpBgWp2}Y8k&G%gxu3gc_#@rN-bK4lKYd5n@fAmD)_(WoGXv#M@%Aco#G<(n2UNiI=
zIT5dl=fl$@=p>k7(6ey%@NpTL30h#0FtS8ZdqP3%o$%x}I6MFRdaI~^b<*0;3@V!E
S`-p?_$L3!@7-%tneg6fLkX32`

diff --git a/Engine/lib/sdl/VisualC.html b/Engine/lib/sdl/VisualC.html
deleted file mode 100644
index 0631832e8..000000000
--- a/Engine/lib/sdl/VisualC.html
+++ /dev/null
@@ -1,146 +0,0 @@
-<HTML>
-	<HEAD>
-		<TITLE>Using SDL with Microsoft Visual C++</TITLE>
-	</HEAD>
-	<BODY>
-		<H1>
-			Using SDL with Microsoft Visual C++
-		</H1>
-		<H3>
-			by <A HREF="mailto:snowlion@sprynet.com">Lion Kimbro </A>and additions by <A HREF="mailto:james@conceptofzero.net">
-				James Turk</A>
-		</H3>
-		<p>
-			You can either use the precompiled libraries from <A HREF="http://www.libsdl.org/download.php"> the SDL Download web site </A>, or you can build SDL yourself.
-		</p>
-		<H3>
-			Building SDL
-		</H3>
-		<P>
-			Go into the VisualC directory and double-click on the Visual Studio solution for your version of Visual Studio, e.g. <CODE>SDL_VS2008.sln</CODE> This should open up the IDE.
-		</P>
-		<P>
-			There are different solution files for the various
-			versions of the IDE. Please use the appropriate version
-			2008, 2010, 2012 or 2013.
-		</P>
-		<P>
-			Build the <CODE>.dll</CODE> and <CODE>.lib</CODE> files.
-		</P>
-		<P>
-			This is done by right clicking on each project in turn (Projects are listed in 
-			the Workspace panel in the FileView tab), and selecting "Build".
-		</P>
-		<P>
-			You may get a few warnings, but you should not get any errors. You do have to 
-			have at least the DirectX 9 SDK installed, however. The latest 
-			version of DirectX can be downloaded from <A HREF="http://www.microsoft.com">Microsoft</A>.
-		</P>
-		<P>
-			Later, we will refer to the following .lib and .dll files that have just been 
-			generated:
-		</P>
-		<ul>
-    <li> SDL2.dll</li>
-    <li> SDL2.lib</li>
-    <li> SDL2main.lib</li>
-    </ul>
-		<P>
-			Search for these using the Windows Find (Windows-F) utility inside the VisualC directory.
-		</P>
-		<H3>
-			Creating a Project with SDL
-		</H3>
-		<P>
-			Create a project as a Win32 Application.
-		</P>
-		<P>
-			Create a C++ file for your project.
-		</P>
-		<P>
-			Set the C runtime to "Multi-threaded DLL" in the menu: <CODE>Project|Settings|C/C++ 
-				tab|Code Generation|Runtime Library </CODE>.
-		</P>
-		<P>
-			Add the SDL <CODE>include</CODE> directory to your list of includes in the 
-			menu: <CODE>Project|Settings|C/C++ tab|Preprocessor|Additional include directories </CODE>
-			.
-			<br>
-			<STRONG><FONT color="#009900">VC7 Specific: Instead of doing this I find it easier to 
-					add the include and library directories to the list that VC7 keeps. Do this by 
-					selecting Tools|Options|Projects|VC++ Directories and under the "Show 
-					Directories For:" dropbox select "Include Files", and click the "New Directory 
-					Icon" and add the [SDLROOT]\include directory (e.g. If you installed to 
-					c:\SDL\ add c:\SDL\include).&nbsp;Proceed to&nbsp;change the 
-					dropbox selection to "Library Files" and add [SDLROOT]\lib.</FONT></STRONG>
-		</P>
-			<P>
-				The "include directory" I am referring to is the <CODE>include</CODE> folder 
-				within the main SDL directory (the one that this HTML file located within).
-			</P>
-			<P>
-				Now we're going to use the files that we had created earlier in the Build SDL 
-				step.
-			</P>
-			<P>
-				Copy the following files into your Project directory:
-			</P>
-			<ul>
-     <li> SDL2.dll</li>
-     </ul>
-			<P>
-				Add the following files to your project (It is not necessary to copy them to 
-				your project directory):
-			</P>
-			<ul>
-     <li> SDL2.lib </li>
-     <li> SDL2main.lib</li>
-     </ul>
-			<P>
-				(To add them to your project, right click on your project, and select "Add 
-				files to project")
-			</P>
-		<P><STRONG><FONT color="#009900">Instead of adding the files to your project it is more 
-					desirable to add them to the linker options: Project|Properties|Linker|Command 
-					Line and type the names of the libraries to link with in the "Additional 
-					Options:" box.&nbsp; Note: This must be done&nbsp;for&nbsp;each&nbsp;build 
-					configuration (e.g. Release,Debug).</FONT></STRONG></P>
-		<H3>
-			SDL 101, First Day of Class
-		</H3>
-		<P>
-			Now create the basic body of your project. The body of your program should take 
-			the following form:
-			<PRE><CODE>
-#include "SDL.h"
-
-int main( int argc, char* argv[] )
-{
-  // Body of the program goes here.
-  return 0;
-}
-			</CODE></PRE>
-		<P></P>
-		<H3>
-			That's it!
-		</H3>
-		<P>
-			I hope that this document has helped you get through the most difficult part of 
-			using the SDL: installing it. Suggestions for improvements to this document 
-			should be sent to the writers of this document.
-		</P>
-		<P>
-			Thanks to Paulus Esterhazy (pesterhazy@gmx.net), for the work on VC++ port.
-		</P>
-		<P>
-			This document was originally called "VisualC.txt", and was written by <A HREF="mailto:slouken@libsdl.org">
-				Sam Lantinga</A>.
-		</P>
-		<P>
-			Later, it was converted to HTML and expanded into the document that you see 
-			today by <A HREF="mailto:snowlion@sprynet.com">Lion Kimbro</A>.
-		</P>
-		<P>Minor Fixes and Visual C++ 7 Information (In Green) was added by <A HREF="mailto:james@conceptofzero.net">James Turk</A>
-		</P>
-	</BODY>
-</HTML>
diff --git a/Engine/lib/sdl/WhatsNew.txt b/Engine/lib/sdl/WhatsNew.txt
index 651cfc1c3..33382ecea 100644
--- a/Engine/lib/sdl/WhatsNew.txt
+++ b/Engine/lib/sdl/WhatsNew.txt
@@ -1,6 +1,118 @@
 
 This is a list of major changes in SDL's version history.
 
+---------------------------------------------------------------------------
+2.0.22:
+---------------------------------------------------------------------------
+
+General:
+* Added the hint SDL_HINT_JOYSTICK_ROG_CHAKRAM to control whether ROG Chakram mice show up as joysticks
+
+
+---------------------------------------------------------------------------
+2.0.20:
+---------------------------------------------------------------------------
+
+General:
+* SDL_RenderGeometryRaw() takes a pointer to SDL_Color, not int. You can cast color data in SDL_PIXELFORMAT_RGBA32 format (SDL_PIXELFORMAT_ABGR8888 on little endian systems) for this parameter.
+* Improved accuracy of horizontal and vertical line drawing when using OpenGL or OpenGLES
+* Added the hint SDL_HINT_RENDER_LINE_METHOD to control the method of line drawing used, to select speed, correctness, and compatibility.
+
+Windows:
+* Fixed size of custom cursors
+
+Linux:
+* Fixed hotplug controller detection, broken in 2.0.18
+
+
+---------------------------------------------------------------------------
+2.0.18:
+---------------------------------------------------------------------------
+
+General:
+* The SDL wiki documentation and development headers are automatically kept in sync
+* Each function has information about in which version of SDL it was introduced
+* SDL-specific CMake options are now prefixed with 'SDL_'. Be sure to update your CMake build scripts accordingly!
+* Added the hint SDL_HINT_APP_NAME to let SDL know the name of your application for various places it might show up in system information
+* Added SDL_RenderGeometry() and SDL_RenderGeometryRaw() to allow rendering of arbitrary shapes using the SDL 2D render API
+* Added SDL_SetTextureUserData() and SDL_GetTextureUserData() to associate application data with an SDL texture
+* Added SDL_RenderWindowToLogical() and SDL_RenderLogicalToWindow() to convert between window coordinates and logical render coordinates
+* Added SDL_RenderSetVSync() to change whether a renderer present is synchronized with vblank at runtime
+* Added SDL_PremultiplyAlpha() to premultiply alpha on a block of SDL_PIXELFORMAT_ARGB8888 pixels
+* Added a window event SDL_WINDOWEVENT_DISPLAY_CHANGED which is sent when a window changes what display it's centered on
+* Added SDL_GetWindowICCProfile() to query a window's ICC profile, and a window event SDL_WINDOWEVENT_ICCPROF_CHANGED that is sent when it changes
+* Added the hint SDL_HINT_VIDEO_EGL_ALLOW_TRANSPARENCY to allow EGL windows to be transparent instead of opaque
+* SDL_WaitEvent() has been redesigned to use less CPU in most cases
+* Added SDL_SetWindowMouseRect() and SDL_GetWindowMouseRect() to confine the mouse cursor to an area of a window
+* You can now read precise mouse wheel motion using 'preciseX' and 'preciseY' event fields
+* Added SDL_GameControllerHasRumble() and SDL_GameControllerHasRumbleTriggers() to query whether a game controller supports rumble
+* Added SDL_JoystickHasRumble() and SDL_JoystickHasRumbleTriggers() to query whether a joystick supports rumble
+* SDL's hidapi implementation is now available as a public API in SDL_hidapi.h
+
+Windows:
+* Improved relative mouse motion over Windows Remote Desktop
+* Added the hint SDL_HINT_IME_SHOW_UI to show native UI components instead of hiding them (defaults off)
+
+Windows/UWP:
+* WGI is used instead of XInput for better controller support in UWP apps
+
+Linux:
+* Added the hint SDL_HINT_SCREENSAVER_INHIBIT_ACTIVITY_NAME to set the activity that's displayed by the system when the screensaver is disabled
+* Added the hint SDL_HINT_LINUX_JOYSTICK_CLASSIC to control whether /dev/input/js* or /dev/input/event* are used as joystick devices
+* Added the hint SDL_HINT_JOYSTICK_DEVICE to allow the user to specify devices that will be opened in addition to the normal joystick detection
+* Added SDL_LinuxSetThreadPriorityAndPolicy() for more control over a thread priority on Linux
+
+Android:
+* Added support for audio output and capture using AAudio on Android 8.1 and newer
+* Steam Controller support is disabled by default, and can be enabled by setting the hint SDL_HINT_JOYSTICK_HIDAPI_STEAM to "1" before calling SDL_Init()
+
+Apple Arcade:
+* Added SDL_GameControllerGetAppleSFSymbolsNameForButton() and SDL_GameControllerGetAppleSFSymbolsNameForAxis() to support Apple Arcade titles
+
+iOS:
+* Added documentation that the UIApplicationSupportsIndirectInputEvents key must be set to true in your application's Info.plist in order to get real Bluetooth mouse events.
+* Steam Controller support is disabled by default, and can be enabled by setting the hint SDL_HINT_JOYSTICK_HIDAPI_STEAM to "1" before calling SDL_Init()
+
+
+---------------------------------------------------------------------------
+2.0.16:
+---------------------------------------------------------------------------
+General:
+* Added SDL_FlashWindow() to get a user's attention
+* Added SDL_GetAudioDeviceSpec() to get the preferred audio format of a device
+* Added SDL_SetWindowAlwaysOnTop() to dynamically change the SDL_WINDOW_ALWAYS_ON_TOP flag for a window
+* Added SDL_SetWindowKeyboardGrab() to support grabbing the keyboard independently of the mouse
+* Added SDL_SoftStretchLinear() to do bilinear scaling between 32-bit software surfaces
+* Added SDL_UpdateNVTexture() to update streaming NV12/21 textures
+* Added SDL_GameControllerSendEffect() and SDL_JoystickSendEffect() to allow sending custom trigger effects to the DualSense controller
+* Added SDL_GameControllerGetSensorDataRate() to get the sensor data rate for PlayStation and Nintendo Switch controllers
+* Added support for the Amazon Luna game controller
+* Added rumble support for the Google Stadia controller using the HIDAPI driver
+* Added SDL_GameControllerType constants for the Amazon Luna and Google Stadia controllers
+* Added analog rumble for Nintendo Switch Pro controllers using the HIDAPI driver
+* Reduced CPU usage when using SDL_WaitEvent() and SDL_WaitEventTimeout()
+
+Windows:
+* Added SDL_SetWindowsMessageHook() to set a function that is called for all Windows messages
+* Added SDL_RenderGetD3D11Device() to get the D3D11 device used by the SDL renderer
+
+Linux:
+* Greatly improved Wayland support
+* Added support for audio output and capture using Pipewire
+* Added the hint SDL_HINT_AUDIO_INCLUDE_MONITORS to control whether PulseAudio recording should include monitor devices
+* Added the hint SDL_HINT_AUDIO_DEVICE_STREAM_ROLE to describe the role of your application for audio control panels
+
+Android:
+* Added SDL_AndroidShowToast() to show a lightweight notification
+
+iOS:
+* Added support for mouse relative mode on iOS 14.1 and newer
+* Added support for the Xbox Series X controller
+
+tvOS:
+* Added support for the Xbox Series X controller
+
+
 ---------------------------------------------------------------------------
 2.0.14:
 ---------------------------------------------------------------------------
diff --git a/Engine/lib/sdl/Xcode-iOS/Demos/Info.plist b/Engine/lib/sdl/Xcode-iOS/Demos/Info.plist
index fbbaf7f93..aa7b5f6e0 100644
--- a/Engine/lib/sdl/Xcode-iOS/Demos/Info.plist
+++ b/Engine/lib/sdl/Xcode-iOS/Demos/Info.plist
@@ -16,6 +16,8 @@
 	<string>6.0</string>
 	<key>CFBundleName</key>
 	<string>${PRODUCT_NAME}</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0.0</string>
 	<key>CFBundlePackageType</key>
 	<string>APPL</string>
 	<key>CFBundleSignature</key>
@@ -28,5 +30,7 @@
 	<string>iOS Launch Screen</string>
 	<key>UISupportedInterfaceOrientations</key>
 	<array/>
+	<key>UIApplicationSupportsIndirectInputEvents</key>
+	<true/>
 </dict>
 </plist>
diff --git a/Engine/lib/sdl/Xcode-iOS/Demos/src/accelerometer.c b/Engine/lib/sdl/Xcode-iOS/Demos/src/accelerometer.c
index 2cc0123c2..925aee4e3 100644
--- a/Engine/lib/sdl/Xcode-iOS/Demos/src/accelerometer.c
+++ b/Engine/lib/sdl/Xcode-iOS/Demos/src/accelerometer.c
@@ -58,7 +58,7 @@ render(SDL_Renderer *renderer, int w, int h, double deltaTime)
         ay * SDL_IPHONE_MAX_GFORCE / SINT16_MAX * GRAVITY_CONSTANT *
         deltaMilliseconds;
 
-    speed = sqrt(shipData.vx * shipData.vx + shipData.vy * shipData.vy);
+    speed = SDL_sqrt(shipData.vx * shipData.vx + shipData.vy * shipData.vy);
 
     if (speed > 0) {
         /* compensate for friction */
diff --git a/Engine/lib/sdl/Xcode-iOS/Demos/src/fireworks.c b/Engine/lib/sdl/Xcode-iOS/Demos/src/fireworks.c
index 2c4f621f1..600d20bbb 100644
--- a/Engine/lib/sdl/Xcode-iOS/Demos/src/fireworks.c
+++ b/Engine/lib/sdl/Xcode-iOS/Demos/src/fireworks.c
@@ -109,7 +109,7 @@ stepParticles(double deltaTime)
                 }
             } else {
                 float speed =
-                    sqrt(curr->xvel * curr->xvel + curr->yvel * curr->yvel);
+                    SDL_sqrt(curr->xvel * curr->xvel + curr->yvel * curr->yvel);
                 /*      if wind resistance is not powerful enough to stop us completely,
                    then apply winde resistance, otherwise just stop us completely */
                 if (WIND_RESISTANCE * deltaMilliseconds < speed) {
@@ -194,15 +194,15 @@ explodeEmitter(struct particle *emitter)
         /* come up with a random angle and speed for new particle */
         float theta = randomFloat(0, 2.0f * 3.141592);
         float exponent = 3.0f;
-        float speed = randomFloat(0.00, powf(0.17, exponent));
-        speed = powf(speed, 1.0f / exponent);
+        float speed = randomFloat(0.00, SDL_powf(0.17, exponent));
+        speed = SDL_powf(speed, 1.0f / exponent);
 
         /* select the particle at the end of our array */
         struct particle *p = &particles[num_active_particles];
 
         /* set the particles properties */
-        p->xvel = speed * cos(theta);
-        p->yvel = speed * sin(theta);
+        p->xvel = speed * SDL_cos(theta);
+        p->yvel = speed * SDL_sin(theta);
         p->x = emitter->x + emitter->xvel;
         p->y = emitter->y + emitter->yvel;
         p->isActive = 1;
@@ -297,7 +297,7 @@ spawnEmitterParticle(GLfloat x, GLfloat y)
     p->y = screen_h;
     /* set velocity so that terminal point is (x,y) */
     p->xvel = 0;
-    p->yvel = -sqrt(2 * ACCEL * (screen_h - y));
+    p->yvel = -SDL_sqrt(2 * ACCEL * (screen_h - y));
     /* set other attributes */
     p->size = 10 * pointSizeScale;
     p->type = emitter;
diff --git a/Engine/lib/sdl/Xcode-iOS/Demos/src/mixer.c b/Engine/lib/sdl/Xcode-iOS/Demos/src/mixer.c
index 14945ad33..18e33f134 100644
--- a/Engine/lib/sdl/Xcode-iOS/Demos/src/mixer.c
+++ b/Engine/lib/sdl/Xcode-iOS/Demos/src/mixer.c
@@ -111,7 +111,7 @@ loadSound(const char *file, struct sound *s)
         if (SDL_ConvertAudio(&cvt) == -1) {     /* convert the sound */
             fatalError("could not convert .wav");
         }
-        SDL_free(s->buffer);    /* free the original (unconverted) buffer */
+        SDL_free(s->buffer);    /* Free the original (unconverted) buffer */
         s->buffer = cvt.buf;    /* point sound buffer to converted buffer */
         s->length = cvt.len_cvt;        /* set sound buffer's new length */
     }
diff --git a/Engine/lib/sdl/Xcode-iOS/Demos/src/touch.c b/Engine/lib/sdl/Xcode-iOS/Demos/src/touch.c
index 470b9d1bd..918240b82 100644
--- a/Engine/lib/sdl/Xcode-iOS/Demos/src/touch.c
+++ b/Engine/lib/sdl/Xcode-iOS/Demos/src/touch.c
@@ -21,7 +21,7 @@ void
 drawLine(SDL_Renderer *renderer, float startx, float starty, float dx, float dy)
 {
 
-    float distance = sqrt(dx * dx + dy * dy);   /* length of line segment (pythagoras) */
+    float distance = SDL_sqrt(dx * dx + dy * dy);   /* length of line segment (pythagoras) */
     int iterations = distance / PIXELS_PER_ITERATION + 1;       /* number of brush sprites to draw for the line */
     float dx_prime = dx / iterations;   /* x-shift per iteration */
     float dy_prime = dy / iterations;   /* y-shift per iteration */
@@ -81,6 +81,7 @@ main(int argc, char *argv[])
     SDL_Event event;
     SDL_Window *window;         /* main window */
     SDL_Renderer *renderer;
+    SDL_Texture *target;
     int done;                   /* does user want to quit? */
     int w, h;
 
@@ -100,29 +101,38 @@ main(int argc, char *argv[])
     initializeTexture(renderer);
 
     /* fill canvass initially with all black */
+    target = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_TARGET, w, h);
+    SDL_SetRenderTarget(renderer, target);
     SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
     SDL_RenderClear(renderer);
-    SDL_RenderPresent(renderer);
+    SDL_SetRenderTarget(renderer, NULL);
 
     done = 0;
-    while (!done && SDL_WaitEvent(&event)) {
-        switch (event.type) {
-        case SDL_QUIT:
-            done = 1;
-            break;
-        case SDL_MOUSEMOTION:
-            state = SDL_GetMouseState(&x, &y);  /* get its location */
-            SDL_GetRelativeMouseState(&dx, &dy);        /* find how much the mouse moved */
-            if (state & SDL_BUTTON_LMASK) {     /* is the mouse (touch) down? */
-                drawLine(renderer, x - dx, y - dy, dx, dy);       /* draw line segment */
-                SDL_RenderPresent(renderer);
+    while (!done) {
+        while (SDL_PollEvent(&event) == 1) {
+            switch (event.type) {
+            case SDL_QUIT:
+                done = 1;
+                break;
+            case SDL_MOUSEMOTION:
+                state = SDL_GetMouseState(&x, &y);  /* get its location */
+                SDL_GetRelativeMouseState(&dx, &dy);        /* find how much the mouse moved */
+                if (state & SDL_BUTTON_LMASK) {     /* is the mouse (touch) down? */
+                    SDL_SetRenderTarget(renderer, target);
+                    drawLine(renderer, x - dx, y - dy, dx, dy);       /* draw line segment */
+                    SDL_SetRenderTarget(renderer, NULL);
+                }
+                break;
             }
-            break;
         }
+
+        SDL_RenderCopy(renderer, target, NULL, NULL);
+        SDL_RenderPresent(renderer);
     }
 
     /* cleanup */
     SDL_DestroyTexture(brush);
+    SDL_DestroyTexture(target);
     SDL_Quit();
 
     return 0;
diff --git a/Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/Default-568h@2x.png b/Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/Default-568h@2x.png
deleted file mode 100644
index eaea96e9e0acc43f7db73c6cbcb8b6165dc6a0be..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 83791
zcmeFYRa9H;w>3^_ixt=4P-t<t;4g*ZQlQ04aS!fVO7Re^Sdl;}&=z-x;!cW7@Bo40
z?(psRobz4$@4w&0e~gnc2#|{>d$0YhwdR~_KGAP9l?d=?@Gvki2vn36bTBY5KVo1!
zamB#`KJky=0NychU6l<zFfg8x{rmF><7*ZO_z>GuMdLO05*9T+p&<1`I}-*56NZX{
z+*{xI-Nm_N6Lj|G#lf8WvcqeNH{o#@D#UA?IyZ_xr(%tyOSjxUO9`zWes<Y?rZjs&
zcrzUm%Cg&-oqpcH)>NdlI8plk8@mo`Pj<KB?$g}!7Z=0TZEaw~XiOi>-1K+8GRz6Y
zQO}>TA&#>y?poVt1baaWz-v9ne1|v+c(G%|{QC<t_y6HP|A{sK=L-LyUgv*s&HoO;
ze<Be7i8cQ>5dYsi_}^Xjzq{;zcEtbB0`Z^Nx&IXcsEp+>_QN&ytx#h8+TVX$2h`y*
zteYR-zwT+OwK-Jfajtc!fI(_O*bBUm&!0aJV8tY5i}03xlAC_k-;ltH8!hlL9AZ41
zOUw?BvWE7?zgAFC6uJ*p!H*U=?MnBS{XP-@gF>29oC;YNMHU8`1H(#*+5c;)X6f5K
zsE2mepTCiw*UTzOW*9Sd)Lg#4WpR+AM}O+xE%E*LH*(>B{oFIcy8~hTIG}@tsO+~k
zIi}WP3H^q_{``4W(WhJi*65D(&#VH%{*Ta9nU`*z_m!9@WUr;z=$|eykdSL*kdu(i
zZ9Mw(U6xsew3EFM)pz<Sy{DAdm>&L96^5#&;0))k*L)uPUjf<u%LM8XaLZbmrPOvZ
za6C7(Ki!HHP_Y1U+04pnTUF`&c|`W~9}<$pR#MD6COY95QD2xmh?a6%GRt_O8x)&i
zl+zeZT5AD&H9GaB;=h*+C!W1{{E5G_j@xAB(YQp%P%&hbM`Zh)MRPdb&8bke^vjgo
z|1A2O2(w8V&K@&hWg<1h3?-Yti#pT$z3phsiUr#*KI~t`jS<(v)_C;h(HjK?tNPe)
zQF=v6AVt>R1cXh$jkLdcXYCo~%(SF%Gf7X$&}s&rQsK~-6KZ<!zt>DMH`2-feQJOF
z@42f}W+1PcXeM)-o8kOlw@v@-;$og-@pzUAYeLNw5FeV|M&$XAe<S?7IY}UbANr$y
zUf75}srwE0`j6BYD<R(C^ooY5jg(l&60w^v&!{ySzOJk<fWk{6r-2k3v<-ObQD6Sb
za-3HF`XGXpI&e4a0jffZuXhcnugR+C=DHJ@buv*<@K(ZsuB9thcPX~Yl{3ESx1}ym
z<sd(1#qu}rzUsj`;1;#>#4P;f#~>@w6LiCAC8dO|{pgL1#$t|EG19tt?Az2|($CCd
zdegZ1IF`8wH%?9>(aGzu<6IT|4V^@X#;6@I$nr;O?3b9QKs-^6lMdFZS9DiSsYbQ8
zIptzunW`3~P!%zTdMB=t_|)*y8AX!BMA8V7Qq8mx|75+QNOa>{wbz3MQsIHA-h6A<
zikU-P5K7T`@@m49WNX;yWP?lLx5o{AjS^4b_n8LG$bzxI<J;%kXE!wx(ni_5dz$gy
z^?f$2uZt&M;Jl*LpT_-$^D$V~th$mOqg3*mK{Z@zN{3{|OBtG{$E(dtacGhTMGNZj
z=yI+P*a|`8^#}a7%h6Sasy&#E(8wKe@?%5Jp65vUNUUTSgArx=>4UK(W}d%hbX1_I
z6rw<n!yG9ZE#TP{BucCCiM^BPIcJY&UxI^x+H`e8&G_2znFQ_L$1=vMkQRl~FFj+B
zK&^3{mG^`JV=JA<VF~;&yE=&l15@<hHNhcA<B~EL_l;gWT4MsbzKD*R9q%`)Vac_3
z?ah?A&d!Y8{0)_Nj>w0=Lt0>4aBlugQB&8N1PhA|`HB!gZ(jBSf5uuG&Zfrg&4OWZ
zmUFXZah6B}%58=(1_tM&V{&R|FPb+@6ls+gi!UlNFCK@X>^NNy@D)xCmYv?X)T*pK
znen17Pl*(gSF!N5G>`QV`#Xu0se`yZgwn8~`{rbG?im)_DKIwP$E!YOb(>GT>mBE`
z<@<oz?Ri>e^1&vk7{>USRppfh{!5i2?FpKeOgWdg4A;nzxw4099><D2a93Q<`#ziH
zNw82dYIsE5&DS|~?x)+imX;3pX7o2ZenFf8CJPB~8W4|TK=QHHgBE??0F(C;Qf}X-
zq5Uk2erb5*y!<0%t}959=Vo)Pn)_K_omXSXE0rXtv_)9pKT*l)?3x&{OgKO4CDXfI
zt%CI!*BNj_krN%paiVUd$)F$PC+b?z#1X3s?%1AELR;s_#+n5i$Dr)M>5aVn>cG2I
z`N<du>U<1#d9l=)#z077><ne2>jqYwUZi)CTJ>VV#16@4ducdik!~BwGx4p9M9wmT
z+5BdvDg(dKDdLrk+Rp^Gw2?QQl<73(RU!UKbKAItyO~!0?ob_Ott8MIE3=A)dJ>j8
zR$iyuZga4@Gk5t>eEThZY%#5Z`DZVpQS<aC$Bq9clRGmUi`25;mp8>dRP|@nQ{Nn=
zT9fZ4oMuq-5}iUljv%vd>ccD6Hm;`p;CcvBk7uj7a~TnQgIAvIA8FGZEBy_ftCDNP
zdpMa-bTq{#qXc?=DffHcCR?wl?^Gc!W57+2x)yhCZ;dr?=3=g--oWTRTa2aDOhE!d
zz_j=c7exhqB$ry|?H<B(z3qzH1bcc1vJjYoko8O_J0V-IQMS^0L$CsYazZ9)xfcwq
z?IGF4VtS2r4a2n?B0%OvlZEZfhH3NC`cP@*eMh)ILkBVZ)ux+p@UgF%XH}sg<;gYZ
z7ZMWbZHsn0*ML>JIAm={3;Zg;MAhQyTE0^)z%(Zh6WH#zOZxsy)f+0YWY6SO*W7YD
zEzWDw3hcCt^{o_v2=$lp0`Po;eggSubmJF1Kh>T<8jSbx?gCns>3yIdsd(y>oUFZX
z`qBNq4Ah7MgMQSk=!Qj(d!zF7Nk6)3HdVw|g}*zR`U~yukEg9lRJhcZ4K=P|wjY9H
zOBFp>5pwcP{f-XbdUsEsl-=NH2cDeZeM<1J9$7a?!N>d9oNb8&zSL>xIlg=y4Ud0t
zLS4)N8s|j(*Ok;piAK-{){q{2q*UU7yF@T}ORhv6#w1FY!!7il%TCqc(czMB^1-S9
z>Gh-H9j{T-roq^9_~vlWQ;9_x$`!Ea+;FRql(R7<n3AwwX7U@m#cD67ei<KGA8yW$
zpec`sU2p_8Z206)P-OaYJ5gWdfG>j~qQ~uh6ty~05sL~e$m8vycW168a{a^*uaT|{
zWwx9@krv?@`=jk(`Ph-m#skdLB3*T}f6d24u-k)KV3CtCfZGBcy5Dv?N2qIaQT%*2
zWF-x(d}Km}@HjMad9yq?f?>BT5gu61O*rVwP!I@X!cjb@Qx6NKM0ojRk%`F`WzT%u
zB?u3MUESRPNj5bik!oG=0z+FJ)Mt=7Vo=b%;{r#YHmY6X-VQ`Z8kYL_9xVvQ?m%)R
zWJVNTXvyS*@-P~x!r%h4sXcntBSS7(s~h#BZr5w?MC-m9EM#etIr~*ehM6@4*?r9>
zbb+^a|McNKsgKSx;XZ7{hPkfIGBdP2$ZTF{p}^iok>o|p<DWc3qai3T?3#FKADtM?
zUVn$-a&hf>EyG1?Y|>OGd<j*dx-_5!(s!Ve^W>&T+}|~o#iN=|QcA1Tgf#}$5oI<n
z(NBXV_YCRwR+s%aqb;ies9uRjCY1VOvnBOdwc8O!wcQVg<!y+Q_K;+kpeuowFWETM
z_tC?(JWY2Whq$~b>*uAst-d1YvvPmU|MT>B>*n7$Ytz6x;c|G>@8kKGao&;6<yz!@
zzkIG)<s?*!o@iugUPX*hmS;;KB-6@|CYIZV+Xmbi{8rd6=(9FvSH*vAkeY)?*l@M!
z$a(})gFIN*P@2U%6OA6*<mOH3HsDtcDD)ju?!-=YRb|iiv$O%U`+601VV@(NWZ=h}
z%?pp+Ln+jhAeKBiTesUQ@<{u|m2=hOR*Avy$!`?JpV&yf>~l0o?HTN)9Py51kKv%0
z__~S>qkj$`dQ+?yRq>O&swK!PyI@3A+rk%h%*k~|NHiSh;T~*){q~WoPb}&)Etg}9
z_cbP(m)G_BmZFTOl$1?ne%~r><}BzX;-4LxF1x-u0W70zhBG~2{f3r`?(x48)w*PK
zIhh-Wq0}}-FTwnhD$HqW^`bG)p^yp)?J|+8Q>+Q^#p-I0la}>1N1)QxhJ4{#Tqt{t
zeZ>2}Bcd+_KD((i!#BojUz}@cRD~=*xw+5~l$0J_zXY8KB?I^WiHT-1Ua?!RNpPXA
z#5~};baHNFUPfYZhM>(&=7g7f`JlCsI`o}DZ$;f)?&97mHnYJ>BQFfKW<UwxyUGmC
z982x~Chih3`<k26uqbB$Zxetej4i8@Cgk2>EI>N=3YVNbAZ{sX%MyL@!ADXf-nQVi
znrg<>X^rK^z1M>Fi;1hpwbr~QjU5N3(j&vCU@a-nEG5l_zS~{l<XY9HAZ?4^tis6m
z0GPqPIAF;<T9Qq7tuECtnkbA!7EvE&(?cu-eL<E62I`J-Vf+>)I%^#_gzgWCeheX7
z;G36y1J<pc=FyhPthm}vu1?RwBu#K?kV;QSMiZ>#Hd`%yOLJ+Ft#p`0Y`w}*^Pplm
z#6@Mr7B$?NZ}GR8dx<J@+D6A?5zcUYx1@@ttuZ3YvhsQZM^F1JW+DcVWs}}-kGE?;
ziaxuP>%X=M3klwQniI6G;apN;jy!Mvd*kVGdy4s_0Tw6OU|s@oI!d<vum*?wg<3{#
zUM|(Qb;E;CVinvzTN^8A58JdxTN@4|G?RyHWY)%PPOpL#;T)R&^x@jw#%SK7=|;8N
zH27U=e&qQ{3Y+F}3LAsXH@yxodUZ@Urzn)`tjqYx!g~fxpDytqj`HK%D|Zvg4Y01W
z4Ur_d<}$E~U5&))UBcY9TTHlAwdK>ciz^nXlXHTyGSMw;`+-p|beh4u-N|f_JtUVM
z16DIq`V!H4Oxf<gDpJN%HooiWC3#!IsI<BHYtkc)5-cb?1P{3xQaED5F|d~{E>(=p
z7&s!r|44H}+k==QX2ne_<E?6{8{mV7q(m}G_0Hr3rYH9itu`{4gGkxJ{5x1dHM&)`
zT;csi^f)Gw(UqJA6%AE#;Mr7R0W4XZhRUi@h0;#n(pRG%SDR?U!|5ryB1+L&2QN3L
z%qjm!Dowtsnz>E23xp1@U1${MN>nr!3n^b)aD={AHhR3%!U!#9C-=>M2{G<%X&$Lr
zu2zH$K(HtL%O%F|Js3e?Z)oe*30)$>>(2*XsKKIBMN8Z3{JGWMW10)b4D>zAiInFp
z|CF5WU;dbhcik#Y0WgSh7rni=(%;rAF`>c79~Eb!zE@GlA322cLw|}HpWc~W9#3C9
z7Tw`lo8{Nz(cz)ETIj$PEbIDN43HH6OSx{FtUt|^B)zz7n{4Ts?Dqe*yy`U8h*HJm
zYAUKrw5{n{N<Ct1`+UH6-_<SB`7_J0iJ+L{(`B+3GQVVocW37{X^}8f@)~X_vDQ1M
zNn`G^wjRf#(UbniN`}k7JZ=x^0NDHEOKccq5Z{e-6)ajdRQ8i3(1&0J2Q8bJXCm4)
z>6^lYkK4t*M-UYbkt;tS>)VbsO#1Cx@VhIr*Nxj3HArJT!l0e>=j^d*d(EqQs&QH2
zfxK<O@RG05To}PNp`8^~Z3D68*_-7dryinMURH(>H`e0}H@eJMGVjGNd*@<XZqLOv
z=_H34L-thKjwbW1s+SI5Fu};ySg9wWg|XFj0r)Zfi^)e)QV5OmR`61=S63ZRC)fs3
zEk|A?EyGoS8PAZx3P1DR&VHRLhMYBMNFBMN%`6cMkn(g*;*;Xfhpdxh$kLX>+kVHx
z{Swobq~x0?Xm>|qmqL^R@q3y^%A38M<l#roS1t5?n}fBl@2}f$p&wc=X_g<R(|rGq
zMS{vxx6gy10t#bhs$f{8WGmDLXMrd7A7MiF13c_9`2vI7nUkZg!_*L)#C@hoySj;p
z1Giy=+TqGMygBFyZQ3+A03zKg$`h+MgD&MNE)i)CJnIg&>5Y;2jrTDGWDYtWM53<-
zT!IlpF4+ZR4yeZMzppedV1Wz`t$j(gCu4=8{LM;Dy2`|_OCTb%4z;*<Q9flR=x6a+
zD~V(ms}h86Sy;dK=D+U+)hl^5i&!eQV7*xn0$AiHe$|WM1JB3;{5osPN7|$l`<@em
z1eWO~DH(9~0-iRyOph5cm5<K#eZ8BM!64MUC>xQ6yVZxMN|I6>7{Om@N(swz{397<
zPe@&|TNRp-FHrV_K2#g+&HN4KKe1fJf;Md`<fAg3i7wBthD;hOhsXb7Wt+lLk!Y+^
zOQ&z_%$oQrq(m-u`EP0M_L5M5nsUGf@LJ9nq{(K6l&ehmy>3mC36MF~=)A@4L{{7~
z)Eh3UbU1sW*Lw+|^*>WnSQLHosJt~WrRT0%STYh9B~GZ3@|Nlc#^v_b&7*(8ddS6$
ztc6!KOa<Dx+-d{vDSy(yCEL~!++|LF)U2=NalVErd$~VzIj<YfFDW8`e}#pUpUx`K
zP*&|zpW3Xi`zx@J*|kcq;BEiJ-j%Qs#AuIqjOj_CkbQ*na?#xWN)v#1L!+zu!h~K>
zj+W_ktWeP1!`tt)q;4<K(cjYR;D-g+whbW<;GV3UA-s=1SEc8Dh?f54yHl|e7m?o|
zA;$hwi$U;p`aqjsj}|25_*;WB_XtBywA$Bp3!dIz?tEC`(#m4hOfo;{2dnVsF<0?O
z_0c<ViE*MU=E7#ucfIN$C_hTr4j^U>SPRY8jm#_357mL3P6y5rC34M0dd*#0!AJNf
z*fs!%?b`O?wL}uSw4BqB=_b?3xJTJ88JOkIp^t9P1+=Fr-GM8VBmR8b#g~I-Yrm47
zp_=h-DcE|v94B{QCsR+~I`Z~$gAedH=Jt>0w@+#$g8(w(cRds@q{k5oDX0wvmCO>S
z<II44_igL{{@DdbDm7xgsaL!@q^j_2R{D5cp=7I2Jw>lcRCM7e1pV|f6dZHa{BZ5q
z)XK1@31`BepsEF{DiPczOg!81ym<udH@9Uc4Q%5_hv#S4GJNe`u#oGsSQC?mP!Zp-
z#Ko@|2Zw4?*sciaD1clc&-_jnUQgH4Jdx|yhx?~LzA1F2mxO49GDlmgC%xoDc=#+{
z-9!cs=&;ybHP9gobvOal&n@fE-dS|=6K?r(#y=N9?sNEa&_3OG+3sq-woyKKKnkmX
zI#fSH(laWkx|&r5YH2JyFFhJg(#iygV4FpQT@bm~j}FNe`thl#oDanw&h$-;jZ}()
zyq@nJv)$X?o(X;x;}zR`sIO@nZGX6dlPWN4g>1XoTxggZn?b_~SlwQU;c*!Gndsm3
zdB*j>#|?$am+Cx+T1<=X)HF*&1%NlYnT{$5XAkD`^*E}e)J41WOG8^j??Nc`e#p82
zC)vbjxp|{r52sH4wL#TvJ-&6xczO%xs*-GZptxm-Axzc|Le7mxO--0!D3YHKB+{$v
zx>s*~O3v@%9}d+3_;{ora!dde+Rp+n7l)VXT-~-#uh%`Oc`(TuW0_qoN?s+g0^&pc
zLD<s~y+~G--ypn3?vU%#w9C;Mcz2c4v0=QoneWCeo{OnbZ{0+b91=5`)k#$1_VOa_
z@*2H)xv<JXZ}s$dysdRmGTPKH7X2Y8mR~h8DQ;8PTiSz7np6Gy%$^_@wqZ&cLBiJ>
z3^dluRk-ZP5zC2{R2qK_^*JT}E2w~#P)Nhb_Q(pIXvA16BXvH_KaD*9^0ndwkbFa(
z3VDw`<U={aoem`-3foH<@O`WLlyigBdS$HJOuaKRO|PQF(`XK(QsqZ|K#S`pR(5bd
zS)c6@UF&b49YvYSuIRT1#8H__zb;;Ukv6iGyeNcwc<z|&JdN>nkLQC`xlEK)8lZr2
zxn#4Xon2BbUvc)u4=0cKe%6LU=DJm0ffNl=&#>ung}d5eo8k=~p)qBoSKomRWjQ4{
zW+nlSSu=;^QZIx+`U)4fNnhh8TUryUf2sWFExR)B5XP_SN*CbTtZA_1K=uN+4s!IT
z0}x21CnzwMBN;!pc=(0FrEW;m%6K?$2TD&Bnr*Fw800`lCuq|bs3x<H$4W#5H($i-
zG%Utno$Y1Id*T%?=kk&@lJx`<I(}0uKbZLI3G8y(fIgV|wpV>qWi-k_eR6OY&VH1V
zd~(YfWjODY$hz%d@vMTo3lK4@UHHt9lzkWRx*S_`!S#FB&l_vwc<#HFAD{(O8gvwX
zu?rJ)eJ@dsx0hn==!1}B?gJB5MkaufTDqo&@638ONq6#(KO$>XJ8tCmsMh_0cU6OR
znCb(q!FDM>sIJqtwJd(x>*`w7smr!GE1L*oTB3t#8V>-l65i?_t<T3jv5O_q?=x4%
z@W`o7GD{{TMHgNEXXhrMYM)O4OKA2)SU~JT=1zfQnV|+<<4ie<Ol{?|dF@g!!I6D0
zlK&y(1$^G`q<KaQ70E1nd++1BvLz=qLp}ZE)9a!cHrjx7k2$R)+D5<oIB$a7F_Gs!
z-BsLxggKFH38<{~^WgIUY-^)MhB`|Wm~hHH6q^uA@`O1UR9Q8r>T@)Abd%4%HswQ!
z`zeY~TDT|?;GL5_#j&?*SNdC?0Ri7e9VOQx7y6j&l*ey}UgKSH1GL@YXB4{8e)jIi
zGxx&-r@E#~ZDo*x=XKC+@Nb*yaM^UcYHXy<T&f5i4|N{fRd&$!A>Y^arXpu2n0yfu
zJ*A5VR0!EiR5?H|=^CL*<V9zS=Hvj4qDJ&wy)6tYm7^UTBh*7ad#A9kh(lNWB?|RK
z7652=N(4UsM4CyTy^A9M9a?CV>a2%0x_tw$Ug?r#=V&Fd+CP{k2fr&uqE9<H>nu+u
z?{0olQeYlzV}KM%ic}B}%m3F4F#2J$XGSZ2a`T}6=vdlh+rf}B+$0rH-(@nf+JcfT
zht=bRWc2d%I0Pg`<YdyiDrFThYR0q4Ql~|?y#qXNg8q&W0u>~@hoX+geleW!JJm17
zh)cP2!X9I!@pZ2BJ8S(x8>#ENj~`kO0VRYGapHTpC50hMN!`~I|4NjWr?)sos~j@<
z!<H+|G-16=Md>`oGav{k`3i1Q3%rEC>&Dwc;`C?{9+lj&4vqZ-^14p7L7MMP3nz$_
zq13@CJF~))GUY8EVS&@A^*j}ao)W_IRuBeR^5JxbT9$Z73KR5P!G&+Aii7f4>h?E@
zCWCAz3)?>Gp2dT8AX`>?)3#{&LSuvob9%ZS9I}Bmqd(o~Z<zr=5$;lm8Fa3)6=6%C
z;PTKRdW>`(D7xpzyxgwl6EZF4m)0&Y;w&Jdl7wiJ^x;Y`7rpHdaaeWvf{?4Gef4X%
z%xo3>CC0CgrgYV5TC)xUpq(9BFR7UhHz%OhYRS4M*wiBm3N&t+y6c?xg?53F4*AJ2
zZQ5@TL#qp8LDseZk_Rwpa>@xf<5>cGxE)TnHSe2l7oG`dlM4w6^hTp1{dV(Ez&!=6
zpHKre2`CGFb(MR24BiLVLSN$znrxl#yJ<A3mb36`d7eq8S$i+D0%~D=IEgtqKqCy1
zB>?pff2Qx^y1#}ARG|U_FM8WU={shnXZu$9*V!M6*%n&4VPwIlC+Nelj}P0+w-`cO
z`gN_OzQtpmRopRG3q_vyUrA)JmF{km7sYZrDr&YK2V<K>X>`upNJB=}n;Oc7#296i
zN&B)In_@O*!^X=p(Ke*Crr_$2jGqIq*5!_=dG1?mG0i{`Chtu)0BIbU3<xgmU$Z!g
z{ag|gA0=apKlwctMkmAH6*|XZQ^Xd9`V5AtsJ|j-+a~9pHapo%XOC8~kS8x{O<ijD
zX4`9CpVu@(+7{JPmRX{jczeI+|42C38nTl56}F7+>gya~iB05se9yuy-85QTAd;#l
z*5GX!?l|NqjHIXQ>+sqgTeh8R61jwZV^zVy4qex@MNa4#I3A)F`7|l<sU9sF>ju|B
zDl4Z}!u7S>Je^Yk{VLiV3F`Ciw-Kz7-1gRk4=S&0wWt2IXZJbsuO9GcDBB_aylN&f
z<Bu4b>s+~EK2v-);{}k6j4}$p^(~pE;QoyQjfIYBcjN`1C4OlR0;#W8!4q4=AoY(n
zOX!6n#_nm5sqYy%*N$=XFV{Jcd=~2@r#0a|eDf$0cCuG4)6sD!<Xfgj{KT{AZk1No
zf;0)ttcn#9&vMK3Jci{P`%60L?2E8>5!21i8)Z8y;-jwXqh54Uh!;D4+mka)hjVoz
zm#Y{@hvwqahSuKxpZc^I*l^@|-@jj*luQE$nTHm~4ozl40Le&>_)|(mY+?z8aDJfX
z_r4}T{MIgA@gJqvA~T}wR{3-g*&RJc5=;;z%cMdI%oK?}$;H`9BxRj1SDkyd??Ta)
zHFX2ack70PBM5iTU|CqUXcRBiiPLmujbv*xBgTkb{M}EiH~ZHC_11|a{y>K@54yr`
z&!d%SmGN#>nLeqArMwt{p&|t`M|gw35I=cjPMpLlP`0yXT|Fr&!w3KHJz>ao?GNil
z3uVOa6~^q|x!=Z~kDV|Q46Al@XofzTal4wPVnhXKg=COj(0`XT2&}ATG)w~FZ+Aig
zO|b}Bw75s2sC|tkl67@=80kgccX`k_P-OnwiymO}CZh6y5WXR}E|}4Aq+SF~?k0Ax
zJ{Zqyq=qqk-9Y5r3p&zz1)q%5-kzt3HP%!p(DigNUE9;u`(Q6<9lHuao$uZyeb-IE
zKG!(vIta-G3hWa`-~8K4m!;O=-)9Bynu6fnASZ58%Z9cV#rhdbNOecb&QMoI%3kR)
zbPj2}X_)#N)C&-=PTBi4pWBt@52)GI#{g1E0uA<HO3RwrdxZrhqkKvy&2PqOH)#HW
zV6pi~n}7**QMI0RzvhAw775ui)>*8c0W!vMr;Vl@6ktK2UepESO3%cz8XAqiw6wxB
z1b79{CxnE)a8mfUt)`W~@AlwfkPz0Gp71=(A^7N)1;~9Xog0p)*Y{;VAD-n${j8*U
zSp0B@3lF(`RLItg^UV%yVQEZRDR3GD_ik1yM&=)2hb1Hsvkg?l8(0jF9Ht(*(x;hB
zcX=&dXzmzp%eNk2cX6QjV}P;NY~><#P3X~rCk=Pnkj}6z$L2}c9koluCsq}ul9#>3
zw{v3c{WI-{IQlN!C*wP|zWXWlhRY>IUhm30sFWVNTpXS5Hx+72X_0c%0!><J)AnDz
zf4RNOrYJ0BnTRf%t?`8$=o>%5-)$W8e}XD#ZU@g^@bYlGZ+5=B4(4}Cl{%idsV7UI
zj|Ian=c@VK%$8Y`E#Cn{R=1>_dT+C__~-t2GCj?rqz$wV7_ay5pXpa7Sbo!ER>42p
zG?R-;nLcX2A@_93v|x^fgdSkOjWuMD6&!guJGhsgvdB^8=$o3NZ8=<^a6+!Gvk;xE
zQ?-8_u(}#SK2vb()Fq<(6S`dd$hCTG{WfK%CLoB^(iOBfm7V%D+ZlcnKYWrFax2ny
zz1{`Y9||LB@`QJRMQd)P=d&4F+ho&oo&f;_i=++Nu&@8CUjsO;EK_q^A}q3I2W<b)
zMg(GuT}!tjem*e<`^*o;&5vS-ZJ#|}W4(I_7WzKsL?my+o0*q@Ak;G|@-Qre=$4XG
z7pDMI&I|@dRAq9XxQ|<?*r>_MZh@nMIry?|pIgC6Np|PF&9@I{W=q43py|PEj*^;>
zKK!YNhr_w3(pPWIfdlU3*?S*nIG42S%F4a{zx`J)e*jQJi^WnKeIbcM`c#HS$Zj_$
zshOU-QfUDRJHu_agY&@PtJ~tYgHP{oxA~G;Nz4+5toT8CVt<Ec&*{aY8P2q~_FUY{
z<L?J;sW8=gFcbEv>0XoUIm_}W2@LQcxQD7-ooKNx+Bc>&OoMLd*y2Y8WhF;^ONV_6
z`sX~T4Bi{}1tU98q+}j?`2N^k_@Tz}s1d7U`9ix56oaO?AAvm9%x=z-=`I-yW}+S^
z8TuJbvwYc^A9#@Y;d!zfwwK{g)8!)Mg?*g_FiZaiR$cy_b=raQ<DFBtnSIifj#!*F
z?c0xZN~G!&kd|e_d37E9PyNBfMOaO=EjdAOsg_LUi_C$QMna%F^x$^m8X{2l`GBbS
zU=9RmIPbC0aGPJMqgpY*JPVLJMX_(3#c-D7fC>`KX!kh1J0ackyI4$;d3Mg#=j8@V
zLxV8a`qsaaklpP4>$Uk&?|~6BV_{Ia9xzv31rw$|jpf?OYHj$PaiR|n*rrh{rUk4B
zTUQ-9Ac}=HTPr~ZH17vgW7_iO`km6OtaLOa6fF+o8q&+xC_*+%Hh)fEbW>N5A)rRk
zJJ}?#Xp#ccJJB5tiPn2;Q_c)%Uo9=y?H1tnoZ^!i4C^D*=A?9$j(7j5+&X3h@ro02
zfv>IhF|ZiB0t)i+jR(IWM^(r-=={unB}PNrJM?Z(F>5sS-DY>MnK5O^`3T=}cDb~i
z=ng?$-uzgYOSNX}6f?|Xx5I)!S?QLu0JBy#y0Rl`wW!A}t7a>x&r=`t`qW>h)H&X!
zxa-=6tWPuYWT@bI&nv<ixA9za!*03xfBajFR)LZqEqgtme0v`!bc=?|3?b3HWNd&;
z@@bw-3(<UA=LF3|0yJh$St+_SJ|s%e(B-lbzb>@nWPBPA21!J0j5pP-7K&3wr<Acr
z)||VR=xjP_$qehmZ|O4QMB6X-hHkIJXBrz^Ee|^rcJo-A8(hz@Wbe<^Zg<*mSyX%I
z+_FsT$!Y~lor(JDsEgm7Uq%;U=LI&=^--U%dpZSNCeae)L?8H+yZ8iTNr$9lWN-ju
zs{)I(;+eGVv)j|9l<rf1X`uLIn83POOPocoHg?jklGzS`Im2Y=vf87Hv0c}zYf|7T
zN&Qw7q63UaCv^LnvcJ<9Wd~LtS9cwv!J=n2nNx8**TElElH^KFB@|?YL^NwnSd))r
zs&A^$P2ipyfwM{9I55oK%fDuxUbK#;qy(bFOYuWbwJSK>-jQ0K-{8;jtb8BX`x3*J
z*JNXcucg<cyhVffGrU93Bi|&X)+1%VlnBLygWJizII>|$IOZ7?((n&E!Iv;N(Q&S|
zAy{)hhZ#OpIB^s1=`RZr`J$Po6qcaRyMDDa@nLgEOS-dhXy$Uj#dK{$3^9HYcIxQu
z=j!@CGUbdQ_-@TH5EUB_U<Yr5_OFPIAN3NRH!>m~Vy57CkJ&M|J)BF7UgEF-LQB_;
z={%ztbx!=1N$M-+zK~0;hhdlC3(iKT)S+jw!p7NhSChGm>Y~Y_sW9d!i!xrw;cW)~
z2VXPT9qI-BVJk5PZK>#xW2S;O6b;+2hdk0I*X3Tnij}>_1A5AYafwP1>gyh_aUA7h
z4t#pON1*2wtkNjFQZ*xxSCX`qpuXsut`7^*<3%46PS*zLP>=oF5WRX~fN=-#HWa+2
z3toOHU{y_x2N-@#U_f<=&jI%Wh6F(%s0A}b{noAVBB!oOnUgLDn4NZ-9*`M~w&jad
zP#9_!fJJfyaaRT*rX`+VcyYQsUtck`fGiKYh%NB}8nU=oQ2V`1ZS;hF-6IUa6$>dS
zj({Kw-}V>Csy;33Eta}o5y%PH;2AY(ctxz}8}_?~wuq#D=aE?b*V~D5)0N1OBM591
zL5LK1rwZU%T3T9lP0gh_aqzLo$NIL9QGs6p{$iOzx@ZbFU1k%FV2}ABHcwt<xCS;4
zeh`+utadqWzk@%B#g>;O4_S}*Bw}^)n>jf_EiV{pPwQI!NF%j}=eUa3rP4~o`V_?L
zPtMt!c`#_q+^oY=&PwUILX=MO)$7w$#k%iryNGl+s3P)1%t6&tc4L1%Rj^n>0Jq0L
zB_5gO6!O=>jXVs`zf4U4-UX6xohw}Y`-l2TC%b09KQHjuoqAbR06AKh+e+N;7Dowv
zq0330o+;inr}oUGu@0Y=ag67F6pL-R`P0}IthMEVal8@&peUgURC;{#i(G4hLj5IL
z3_!-Ay7_!m!Da^3nXm+Qm91-;E2jt(Q8ixFs^7k=aK+pHqph&M^vt=w-BU24Rj`A$
zh_9lm^65)z&4b;SHWkPGnie@XcbQWDYwWs~Q|6N2b(ocwFXrsLIrLvuWoXShO<x}(
zeBO@!-lO84!W?9bK>^J1=}QL+J<&Sl+XP@Z=hfsSGLBy9Hb^-LzT;Q|2jx(i24`;6
z#;r!dcdWsl>o`Qg`>b^k%Ooq`%zExvz_pUW#kDS-R-Tom_2I48tj__?icRZ)UUjYI
zyuCtEh{mg*38+5{_y8s6rd9SixAT?=%Lx`3&E0fywn?gV@YAQ5F;49<sFecs68-CU
zSuUBt8U%{3I|<So>zNn#^YM>|Ma$REwPcPl5UsbA4@Zo_qX6xDziXC6gd6H}ES{O!
z<;3FKmL8v;Bl?}|vx{x_4XQ=G+f5zlgL_w={?cDd0S8)Ipr~4{&iA+dMUS#O(4ePZ
zV#M2S&WbJ<9xGiUWc^a%vKM%cw8o4_)Ue~mtU4p3<zFYA#YMAX0=+D3Fp|&PFzH71
z2>zJ460r=L^0lS&-L4-lwS}cC>qK0rM(DdCPyZl*0>LI2hjubSX6`M6r|Y1Hn}=(c
zt8F2^<K1U26>U>iC3?*I*}1|p8b9@3z{YL+M~lMI5+yUp7PnQb>SPMoZt+^<Uy=sN
z$GHME65Cz4iUCa=Fw)*%6hOBYw98JUJjQnG?6qNm99ZDzpaINCp5pGNUtTio%P>JE
zQpn~2fCQkHnzUBF`e~4>$B{H-6KOmL2;hK-RMdV9j?b1FeYnYopX{n_zrK^3SgM!w
z5_M|rz|m?aD8ed5tdBLfV*E%)2-yF^03t^-LU^W_IdxX*$*fcGig$;EErL}5fb>)D
z8H~XXlK;*oLr&t`{~Z_>JbUA9ZJryB0!v*Ca%>U}A6_Xj&_PpafH^O2M8On6FK2-k
z1BOor`QeXL<^HAAeaa+rV6qKToHT~e4ZReII2(}ws)`=(svqz2-DcWlzDr;z6qPvQ
zm-S&`t@cFC#K@%2YnT2)>lwFDL%ZQ5Qabp2T>L)MMS8eRVCwPyD2DPprcLz{%@wvf
zKwW>mfH7utRqo0iNXrv{zBHE@-t*&4(Mdcqvi`n9EnBvSVa!1RB(QY5I-n}H%`u_;
zfTw6BwB!n(H+lJf_jvif#|JDSJH(e00vHFR)I^i1)sKc4k6*T&eC4D#wvvu_C{SM3
zs%JBqo9*<V?=7Yf46}dpjGe**NI;MwUsu~tx8UpD1C^w8>4(upcRHgzLR&tQ)sbqd
zNMyHpqO;BcSa?3WhVR?OQPHQAVg;G?7n5}yX?Ul1ADN(A*m6cnjD0o8_kptAZo6_C
z&Y{spDeAo&9!gcGpArg26q^qJIQfvbyuc&v!KEGHMYMT^mrDmmWmHxXUOVG|EY*Z-
z7PT+-I$5Dl;smxI*Sw_*Or|s^FGRW%D87j)sFA#8=RR*h5{;SgN-k)0gXBSdz#hI1
zg1=&pL`yjNkctb+s&T;cbvSi+sQk9$gifzza&`zGchk%MqvXdpZA?P}(@aO$2m#%N
zv*7ujQ>K42;KHqGdS8{NB$L+R1)SZ<OGg~d4p@@o+3%r+_*wvn)l0+ud=7#>XpEh?
zysG9qk-g7s2SE8ZaEF%(07C#vpy5n`-p%DB*Bfqzxv};{)9mLLm<X?*da9Rl;H-OV
z;-yaZJ&N>nPvWQCy^hv^@EUm$=k~Bb?()GzooXcL_uWfXi_!PSmMuv|Ul2Nj))9!*
zfL31D8P){Tb}hsK5j-pZ=8YI@C9|gUxmXMeB#Yw>%_0Xaqgs0eGw`u(3URs;QsN{^
zO&Lo(?b|Jjbi)Bo<WSIE-+uh$Vp$AOJzLy1p95V9tWts1$Ez|7ad~Qi<>A^3wIRr*
zK7w?r7LXR`L<5clBjk7VjREC4_cLS_F19qc7QjhDgLHu*6EM5Bs2*b&u)NO`lb<p7
z3reOkl^kim9+IWmpGSd3Yuyv$O0i0v;qz=w-XpHe{XZCpJcj5hR5vz=%7OF*ys<8I
zM`6Tajn*$ap1<#|n^JDpJk9<Xts2S(L%41CN@SZR@cyoGZcTBHf9Bovuae0OA2{qG
z^Vrr@k=Wf$()Wx#8{w(@y7ykV*0Y+$xT#0O=;PNBUwEL%s&jDji4<S}<(HMzs0X0x
zSniCL{O8wAR<bc<=NizHkXyco)b{HM7oA}=cC%%=+}`98U0#K=xSFEuAI63Dc)+q1
zOk8Q`l7w&Sp43hJnYqy<_2H`hAuVucC?0?}GTslJiA~H#l-bVl%dN)%TBP;izgq{}
z(|+fVv8!tiI8Y$Jf>Iod14^9hd$ja>qPm^_JErer4iguTO@=JKC7}RgD7icJ8koV!
z9_%|u<LqYVN}suLhUH?~($VQ)IlH)GTJNZcF|j>irT;k;9F5!QdU=1~$9olsRh>ea
zf>vr+94b0~QwsqU%@ZMAz<72S4EQj^j#Q~<ydtF0f;mGM?ROMyhg)G?ghy^k{MyAU
zHytb04^Om;S4Yf*<=2~C^jP3z+_4tSTD>P*XF*2UORht&p3x#zkv+F7@$GU+p!@ca
z+YRM<(d%4~+Ntg1_;%kMvOdCUz*Je0IV$xf_9>us?PPj!7IgOAKwZR%l)M>y|G4N9
zDO}-y5R^_kG79&v)?m?Gs@CV%`}!DQLwI3|=Z1*YpEu}+wyM|p6J2uxNf4}9IqxOo
zG%=&wzf;d{hg@XT3ldt<@mFP>uaE?Mzf!Howl54#kt>(0;!N~+Y8PV~w4BI`tykEH
zlOKKzJk7BXBrr=5r1s%|?m(g_P(6X7lj09@%!MU){4j4aY=F##J$=D=gDX~Li`cq|
z4roV=^_-ZHT1F)U<bJ#~XSc>?|8N0+`EEYhY1&xoWX+K^`s&Z!4<#-PqtDvilKN$C
z+w%mQHbvuUUpit|Y$O-yS#dg7Kcy43f5=D-u^0J^!NNk08GA*y7z}S?Toy#x66j%E
z$|)BkS&~(D64|)KVf*mhxg+};$p)A-7+y+Wf9DyiBnve#m|GheQj_vtzBiX%X?4(l
zk+|p@@9vaY>K_Z3S(Me2rfCck+)Mzp<(4JGe_#!a+_$4?5}f_&79S5*jT6uAUDe+n
zh7lv{Dj~6^vcHKw#p~mlc@JH+NTOF9Qb;#m5z5c2@ez>OvrD<{@&ji?maUy1gkhFN
zURli>GL}p@EK3pr(Z#V`VbV<#k-DPE9jv%<dT6rUSf{w#R<$cFMbx~S&p+-m7LN>z
z7YnAgE$|goI>WGw#HECSPr_|(*lhZ|-+-LPDSF#wJ+h03j4y6QDw-p{Elue<l7|3O
z`Axm#i31bnnDJDQibciy$n60dz^}V=(=;BM@e^=S1=1XMx)MJh=F!dHd_Q43lcsNI
zwD`NOG+ss@wC547z5IL^)lz9I_%E7Y)TD`819y0HZ`u?BW6}`G_xR+mSwi;qZ@Ha@
zHb*?t8e1xa7dC)iz?<1|Vp8|Dw4<$nG2}Bu?6&c>jN=^>6LgKpcR-6O0_X+V&ay$y
z-4S8B6oiOLc8cS!pzRSJMA9iu4Hnh<U&XNMXT=M%cKgROhmzGp*9p*jlW=P};_wnD
zC%3a+LBQVBcS5%|o8TtxkTPDDL3kq{hh-xjA584(<@R)$r~(puQ8GqTGkFxo1mUy5
zce~XV$&*B+jqN^x?1j>U1al;3b$FO#ETJk<mhv)b8<HP_l7y(rD(Wg<FB8d1G{pCd
z;Je-*V^Wow<Rb&5f<PIbktt3uyRP*fFB8ewa21W2ZfA>*PDxcjmD%00;@h+g0P^%V
zPE;2q0#FR^Z=KQdH<x!ATw!CS7XcCYpK_lT@$w}j{OQtvEL8XT&p<Ku3&$Qmi&ZQJ
zMw{z~lxZ^q4Pu$-)YzwjIcfXYB{TaS>`6)mZ>^eAdGYLhZYGg?#vwJp0g^q>K`^Y6
zJG09}h}?ZH9)xLSup-kW>;2#d_>1>*30(tva-IUSKLDTd9j>!%cQRDRDs~3Su3sP1
z=$Du8;xscfs$(UCn(pqE(me1Ba}<MEjjXKpUvx>hoG|m*>lr<p-6vKgG0)=H=5P&k
z{`87Bb3Y_lEtyAX*RL_i<*#QDujvPLsoGHeI({4mZ2sBb70o7E8CuJ6p1Mx{^)y8L
zVAut{g++;Ktqv;=i_{FgI(-3)!F2A(=iif)PwIA(Muem9L(Z3kd#g?~4{lm*+XMEd
zZrZBm7C2()cv6LvY=jx+P#L}n8BfxmL}W9ar~P*Q_yp&e8JGC60On(rUMwtF_7QhR
zWyzRb-uFEAXi1K$Io9U6052b}y`9B_xg{~i(Z(X@clxp4yEhh$(agVM-%U+5T(lrh
z?$gk?p8{mk-VFXI_Pyx7iD~{`i*1G4rH3BP2$Lw)=Qr}Cd_(z5`9I*=P^C7y+Q*zJ
z3eA7il|na1ezXS-^Om^YkBbm8&Ze~33<*~5ZISBtZ}5j`l2<S~O(&5XM&NS*-kS6X
z*vlGt7w!`sRf#gC{Hbpy>^l91>Vy>F2FK4kLb0AwvSlw8mfrqDR?)Jwo)TL>CuwT_
z{flK0eUBmDC5x0o%Ww2H+B7f0=W?D(Cfljbh})Gqg86IIUo0U~khy0==a%b+e6#3x
z@w=B;{CkCtG$1Tu;wOSHBWT#-8CI&{!3hVqTQ5E_#jF(Gw{Crs^oY%B_l+xm_*<S!
z>z3G5n1~P;{tB6Yk!Hax_9j3-0v|q`!~Ucv5T?kigghe^uLyV#F3>5_qg{8(WD>5>
z2#btAur~L~_C_xLKodJLhhpa8O62qnuW?cpQu=PqI;%>m(-gYs{LcHL{PVgj;dU_2
z{{FTczPcQQ!tQ_5d!~a~@Xf*xaHNG*lsB>7Y_}y``w4z*`DaELe=%wugdvLquJNJz
z;Cq~CAgguSV?_BXf5}Nmy1n1ORgS&+<q1uAOBfovq3q&>s3zDBW8l(0g1n=WCqnhL
zYB-(Fzy(eXI{=U&Vh(hb>e*o^>)yeq+!N4?jJQ)5!By0V{=^eg(DAsWn1Mm@L4)lg
z)sr`zJ?mRIEGh2GQ)*A;`X{sf+HQ7ZZ&%@g$urB1pU~Lk79UI~9_W`Zj)EQ@E2~+7
zFoGo-Xk%agA$Uv@TR)#V(9xP4ct1g;%RzCi82y3cb?egF@fos4lJ_gI-B-mWHw?RG
z)9EQVb5|tPLZ)xaHQc?D*bRfDo&z)1gI(wKn6H=-JoTrC=K+{yLrSh*+cjCTKLWds
z81Kc4;@X#K&U{q{kiDq8#&VoootQlLMAe_OK5=9bWn>Y|_50k1aYZ46A(u;9zMDN_
z4Xzt6i>GKJ%3dqH;rR4M(TX1@Im$NTLy~F1f>l0ac<wUM^RfN@R~k5S?D7Dm`r!Xp
zTQOqrv-vF5f&7e!1bvzZRoNd0A5v-63H}OovY8XRn)w5j<B8q(IbNTvlouQAw*b7+
z8^J|>Oqgn)i@R4w)7tMq@ppu>)SHd6NS|(5tarb1P;|%5vdksbR>!2J@%PkrkH*9K
zZ&~!c_$Vreq2QVq59Ak(_lapeQZ^`MX0(0iaS`k|yog~lQHTx1NhSBOY+E_+A4MAF
zh(dGF*dtXNQ)yR^myH>OhxD0h!vEI`07{Pt)se~jVi3_0-F1^rN4t8xNB#ZF&+?!t
z3tPAk@8ZhNhim+ZG8A?q+HSPc&g*&Q@kLfR$5Q><dR-Z$px}3hgFn<izdZLT)yvfD
z>p7DOlwElBh($iMpY?a2Fuped)tr#dn)^~A%3oSTGci+nhSe(HM2)|_YIJf}kce(k
zUclD+2|rJQj(~t@=cRJSRRP8Il(Gg+s67oJMh2gszgTJv3`<-ky?}!|ix?Z>N{B48
zA3ColzF{T)h#ki!DVS{9E-Dj}i@5L2b>V;R-7)4Rt<nyhj?j(Iw)QI>Y@TtppxIvf
zB&^YO7Ral$*l`x55HDjmTK7{7dBF9QyJ{|-xr@)!6h@drP0cyx<OQ7bvGr<IWZx*{
zHD`VT0Vt4*po9rC&I?r63qp06`}U?f9mnKWoTrPoMa);B18zOP?M|My+bsd_S8A?s
z1q=$9wONK<lg5<nKkI#7(nfpz&8|VM9VtKUbAr#U&v$7o56T1xcQe)x@1=K<B01@1
zY8=`+tKq?d+aemVxZhGCtC=?Hr1Q$9)28~t@&pZ7k!AME8Z0>S!cXFJq&p<j$~^AZ
zrrH{Y*?%4e!hw23w;&m9P0jwom5vLBgXP;6Z~YZH+EwZ-YHz~BsrJ}bnFDv1hK>A0
z{FW(qYX6U$^mm<T*@{AYpdbax{2C$nZgpW7O?K1Q;B6~#l&FOBB}w^3qPb^|H@cPg
z$xhtMv_c!d!!76D$QZlF!9UKQK6=X@0kApF9=qRIOc<0?q^~2pRBL-X2WfOv0lB`J
zt#`KF_EXo*g{$iUD~r7KV2{*>PH5n$`45xsy5aANZ#YsW-$wh6dFu8`8k!bzVSLqN
z{>N(u9)_zC`}a`+v?+vWKf~&v><EIZD?yaU{@T;hABIvo_b|I)Wqwp=Z2^)1^i?OX
z3eL>{sJjv0_b{2qLikS%1v~)`T3{jbEBPYGA`CdpNC%t^%d%wC^=tTITVq#U*D^fs
zPa%7rP){Ej2uQLzy>)xvk92Sj?>=tSN}$U}57+M^u}mooWuJe<1D=rC!McHkgzOtJ
zy7yYonR6KVMWp-AjD@6b)@VTyqxaHebh0h*t{b1~01GH8^5R7;NuhJ@Hceq!KCOQe
zC*@IOVYCLTs}f1)uDTi#?xcw4QynaW)Pbe<mb=SBqYG;ef5Y>d(;|Ovi|gq*(k<1~
z%3^f!^W(>Pvwfd)5HjJgew@wRrG$eNq~=xHHk&!oeoh+B@be1?6<*>qZEl5jqf#N+
zc4bTJ&>ekeejy>HzB6`xPWAnzo<vKfj0KTs2vWs9H_!euZ+$AZ9^B+3%<>U_yC<xw
z1&t#V5PZx0C9KSdF;P?l`NJhW<AZsyTO9gB0Ii0Cs4*(PD@(%vqh;iIm5)0#AN!&*
z1o5P)u*d$j3cK7D9)%LW@FSy{GRHsBX7LNU4kP<M3G`_%g*^!Z9|aS;n;}?<;Nl&-
zokPmFUsKP6aGaNNEd9LbrKiOv*Pf*l|7lX9H#@j2^jcOuqZvpre|9V$*+M4b^I2!j
zK<`^Ql48`r)EFIrXc;cpslPJTT0qQ^-T2+7i20#P)k;dsbl!ik{X6dk%a-auX~~2F
zw>j_ur0Nj&a>gc=nwJ8^fyO#FJePaI?=VxzlMI}7lR@WBj*br|>ySps>F~WQ=suI0
zcJ%tUvb0zxBj(-?zBpHh35W`Iw+(0$?k@JUEuy}th3CY{)NLo3e*sZoGS{Sg;$aof
z7%ZY5CeE+Ddk46LL(3eMse$lh-Doka8i$;`x;>v5!pIMkbF(#1bZ8xG7V073ZBb%T
zo~LLR+DyySIwxl4C&+gH`495UPS`jRVq#K46-0U4^FdavdTLcjORB$nmiXpEeZ|{k
zdfG87;0Dhev=$&E=Av$%{xUw~+Kqb%rutLCQ?Jb{DD^1sIm<@S04H@#g~~Oq8QofV
zzd<mfOuz=6w#Lg;Y5DSQGwS{1JHt{jgW~B#!C#Liz2a6?GgegrDV@Yy3tHhA_yuT$
zdG679s);(x2-kw{S!L?Jy2Q$*+%Kfm&QdNUMX*}u_Q3XI*(r(!Wpjeuzg`UtxAF!|
z{53!9zv=M)`<ORgh58p$NV<H#ITQN|ncj)hIDcDcZbp+RtX_k4w$~@#GuFQ4G5sVd
zPd3+{rr=eMVzEa4)Y8^4RpR74aGpuOs8HO~jHoYuS7|We)7#yzAZyk->OGs;zqK^F
zGvyweyFs9c#_jR?2BVGXTh1b)z2~;nkLRp1{4r-CR&Vek24840EFl&;1$BODB;iXQ
z@_sJc-cniVh7$dxJX1{0oH+R`s3RwapWT{_0x~RiF*%=3x*`(T*g~R4ax<QE$nGlj
z;f6xoCtsmBx#XA{%Uk^WMU!sjBkyR4R@Q4@oZ9{26Vzt*A;wBC90h{Z5!Bomh@#9v
zyKn|5vvj`EDHbs-pB_Mau>Te&P@m{NK{k}B@uneL6ekOtl~re==M}Jotdu3`klzwK
zTuTVX0f0H8naMTd!XmH2p8vM&=Z<giKec1u=Jr`TFqi>{re?7Q(0^n;{N{(+Np}-4
zPsBQ!G`4n!^?4Jmd+f%(B-V(>atQq1Ij0+Wwaw+yYrmp?xxSCoCdZud;t!ZFNYk4E
zdYF7SiOf&dt`xkYc>48Kp+2zNDO2Rdo{iIY(t@o2L(^4;<N5x5HEyPv?iywo#<a<)
zjhpGZb$54nZaSx#VY*|wbGoOyyPos+KaS_c-Wu0+Uf=lCnZFpz7-nRQ{+1>qb@{bS
zBn_{-v<;f;c19z@M<N-^!HtbLuf^1q+)2CdT%S`>EvuG{OP8s#M(J1ZXe#s0n&B1_
z7bM{&bR(T=vy68r#lwl{=gE0S0O|dzvQcGy;!+bp$ycAF6`2UtOQv~!)|i#*jCtNm
zN`@1US=XHe=mo&xCb+Qt`s;c>FDD5ntO%v$64>Pw;_DJK`K+fNhv4IE;Po8Zj31``
zPK3GtY>%(JZE5W+YGH#s1RPhv^<1*WwlqAcE4!^(SWj>8H+%<1`j0!bqJGGxsnKPH
z&DnI9@>KlCV~09aa+7+;Wp;AfG4czO-VGCKY8vZXhrCyZBvNn%)_Q5kPWeSO^B;J(
zSrL-27$W3eFo+4~B#%<(Z*0j`g;WzqqN^57lgce+8riueK(j?^bWDt`!=`HH3(jSv
zgTA5l+WkWwDDzNuRJ3x^+5)ENDrKV?Q&h1@<UL~0De>*LON=xkF;qV^`w$-MINZ}%
z#TS?`Hd4P7d7XL?WgKDN0-m^|c5bXgG8v`uD8B*Od|eu%$Ll#kp@E|?Meq=nm^V@V
z*{$Wm_A&ztBqliRuI=3!qxSG9S2JFLrb5m{A8qAuF{VS-D|+?OAPFwD6m!bGDg<BB
zL5B%EYSI+uDNd|OwTSsnIf)(w&I>}ag^n>tfA%gc1hR#HH*sDEB$S(X!^9&kUf}yb
z^~|DzD2CHbQss;DILd5tY}yldvgcgBaUa1dE_$!o?Bo?Jv&NX;ET}L{<+c8TC6Ee&
z;3&U-it^=MU46$v2S;LJ{#)-;6Oxpr{YGSCN6h-n(cxXUvZeI3*KApZT0;(7e_@{~
z1-s_HOMR%e;i<KP4s7>tTA~ZuyJDZhiuT?ArcX}M$Vr&e%EA|-rZPbCJ1XQcj~AlM
zhytMn&*~7<Ce~qR{*)PwUp1(TQL9(hlr8!jOqYnujFQ8#*)go&NfPXFMz4X5I{u~G
z)e*_|VAehUo06}r+HFDGD5ez?LD-}e2XG15Xd%&L3|XT<(6ZOp^+sz3sf_Yu<dT>|
zpfL%$Oi?5nCPd>)A|q|Nun~rGyxyR?qVMjEV`Lby+Q~5ASoYeCWfbef_0`v9*L}3q
z0x-Z18JK)I+n~KZU)?o`j8Vy9=Zn+U#un#coMdNr#5hHjH1$xjDYitITf4Ie&gN8R
z)hBY-6+rRp(Wn8_0Q0G|Ka6BHF$@~++)E4DT>ASZzYXuho5KFFBqW8Ix%b>1HJUCv
z^*Vp!^GP29R_^8Fp%44QPj3=cXX;wMy*hKlB<Jmz3!xC1tnQM3`AYk*xEx{tm7!h!
z0JP@MhAFXuum5K+u`EY0O41j=?DuA=oui^`6|=&%kt%~u#woDlh+ME`2$EE9PY1VM
zFCUsBm1X{$0!F>}K2ms`-~-5xJsuP*>_L6U$MCo3>zU@}N{qsj@Nz2>xtjG}hR@bV
zLvP2;>y)%7sKqx>7f+j;^xd?*Mw)1Smne>__u-5=*op5Fkj&Kz`rS+aJp4mzVvy|L
zwtQN3@d=O`&D`K0ZEoM(pBx%t8#irI`y35z81fTCNl8!dIxu^ve<MT5gDZooYR&de
zNZIgMjUJ3MT~r}ZM4WF9EEHa=baf_#^&Ib`%nV`eF#=aOE_}h+c^VeKD^-k)y~9#&
zjjV@R&(0bm{`<o2qbWB4prsZpjg5?Cr!n-ESte;$!*JlSBEy1t3Dgd*O9p)tl6*Z&
z!(@GGsoXi4OQX+_kEP@KZbn|~_SrcHfiQ6>UN(B&n$J(R982QI!Lf2i!t-iA)=NoJ
zY89qeXXptL0#{>Z1Dgoo?2!y}%kDcBY?b^1VI4B`WWCfU0j`|Oa!<8oAtiO&ytO7=
z)V=`<FK1PUq$iP((1anbdlglS>6zOTmkV<T&qP=u%lH)t(-s&y-s=eE=}mph+Uo+R
zV`kn)yDTVIpDRH-7hQ(O|A;Mt=)|Phm}&abJD$9Yd2`Xc3UhVDp8<*ETe@M97LCcm
zr~EM`ZyfVFeq{@c93j^*y2jb$;EyGfA7z}b$>}yX%nN66jEM{ph<F3Q3Z^n`?x+>x
zUKM1ZNyb|p(@XIossQ!p+a$u3)<5UltdpkBC!R4F&m~rj+M{)eDnEzHmHi%1t;e2s
z-XIX+AY(Am_hKGx9u(6)tQNi^DOI5)8o<)S56NV})dL0f`Q|a}EQ7M8ODSe?bf)c$
zn4<ZZsN0iucLP&Yg7H;wq&M3h2|)_d+~+iY(I34IrbSS?q^jd_k+{~Gw_I;`HIAI8
zT`qYzaTBOJd$A_D`uMq{t#E?Bsr2SgMORBWTrvcY_3;vLK$45_6`;5S*kU`11d@)b
zRr8Lm5_If$-q^uIrOFNO>U!dqIuTD7?;_yB%aV$^t`RBt9MV_ro7x5_pH6vD^Sj0_
zE$KZc;xg)!ucpqA?T`L_r4aCnTzQx(yg4YOXs@smCB_X_6og@eVy<_=mEq|Mi;B81
zuM2(`m7OGR>0weS5|6OJ#g6+{B;hJau4!`ZY6xsfk`*AcLvc-on5bslDS7(3VAj=Y
zPLM@R_`Apghgl7OSWR9$+RQng>aTR8-zL?OFw_2J(o2UW`KS1u;&ZA!NTznN{o#nG
zDBQgu#-b{Xdn$oc8WJ!cgWe(Zc;Xcn-!*+98~jBtQvWuocE7T@al~SKW%K#5=lXWr
z=jQdpO}+zHs&zU6axp%P@$?aUW#zNjp%{%HQ_$Y6!?q6K&pqSq->vZAv{OOU%iqUB
zD>ozSw>>^x@(<PyqkDmX12Y#bt<f0N^iM@8@wjX!sG?yENW2Sr^~&uWmufd|w4Y)<
ze;nPVj3HS}A@i81Lh{H$Un;E>Gg{=lY5vLXnDN;3`gU(SORpXvoc@;dd0@|obFkzq
z>m@zbT4QUwH+VW&7(Ka&(f#*tD$O*tJ<=;gjOjGM7Z_JNPQ>W^nF`g+O}@8V&-ExY
zh>TR+Zy*qoBg2S#l3t$b`0!8B$reX3OC*^6G2BtA)=qNIO_=SlTAbDQ(wun>=``&|
z`?F(<+RKq!CHdHl(fFE~@yELRuU|7Mx}|u*mB(3{y0xRJ!O`XTnUt}k{0|xB-ihbO
zIz~pNl8m&8S=97_+IX`Su<MuQE#0>-XKsepO>TRAP8K4g&|xH!P|6(?cq;aPwNJXW
z1xon>j|B?SB(ASTyT<=13?yF^W(CrD?mmtTTce7GuV@w^CTFj#xeJlc&_X(z^6~;h
zy_ctM@gO~K=nGiBo9Bj=Ra+$<CXRVOq@^;LHc=23ZV|I?G481NWQ{($ni4f)ic%#+
z(n2J>pX*vX@USupChe-GVm1C*uigrcw%idsZ}>b2-z-<LDOqsg`G<yw?*xcUI4`l#
zRN#I3LD2v5Qune4#pBOh0+(2D403jSoM16@fwj7<^XnMBuPD0^s2-ZqOQ%~GY%Wa@
z$H{icJb4VM3&H8*)98n*Qs2z%eaI`Pcr<F)n<3N!6T$}0wywVyWWi;xi~pgUg>y5`
zmkpMtxIG=}ddKX}y=c9=eeHVEYT&5FhFT(9Z0e$Axp24Xi1=#Ps#?LkH%S*2Nvs=z
zcL9vNu^3gZr`{{8J;(X=sB~h%e-?FVTwAl!--@=EtwF1|1JUxY(S#$KI@WTw??rvL
zZx>TE3pU-+6V8a?9}FQsf}wobXbLilecP^Q<M+kyH6Cttg*(Am`H{%mGpCbyndc%o
zS-0Vxe92P5lpShk>|`$%ECo4}k_tPnBy`)LM?0rYtD3><U2@k?*Vi^<2$CUhHqINw
zHRvDfl4CYiE5iVYbRT#{ab>wg;y^q@j+JD;VRe3Fki8((Y_t@fISOMeuA681#Z5%Y
z3?qIl5t^tw_yqAQ3kzJWnP-){I$k^W+~oAUJpaPZ4Gq(1sDkL3_m;=HsHy3!YYMw&
z3g3a6W3~6$a`7#04$%#KMs&pW%ix7c%B9(c^D52Q!w&?}Rv23vhcB~_En|kpdQGG~
zRd!Nqhn1IikTAu<;uY~nE9B02-y9(&rp<_a;Y(hQUVW?hP&{X(Vlmw6?d)}!&7coI
ztsvRCxL1#^D)Z2}a?dA<=lMLBl%lRSpEs32t<8>sICJj0X0olWp}yYsuvC7Uuj__B
zilyLdO?1=xrDj>LNb5nQ)<-5^6Gh>24-V76e2nduW#U&to!QV)_{-+r7lvt_wA#mE
zt*%$Z9F{2ZlkD=e@91VT>CpZ+j<QUOGfOYqF>Y9r3_FuuHiZxr;A$eEj;q#fsn#El
zSvyC?-(SyN-nZ|kwvLzQ<|tJIA=bUm_Ta;k?mgMPv%I(=&B7uSWAwbi@sZ$pYqV|f
zKU9}-gWU1$9_F+Y`6RoVcKQ0PH^EY0EVWoLIx5*hbm&qGU6**?s~r@W{Vvl6i+yy!
zfntQ7EN7_9&T@~GGG<Y-u14;%xm9b|74aQ6!t4}w#KlJBCpaimJe;uaqXz@v6|%&c
zx^=ytdAA5ub9gKbt*On#R582G5to}?F$Ot!-Sx0cK2!YR`fuvSSG3Zrn(`x4o4$|O
zV;2AE1m|*5Ke_+n?cG1S2b#<Vv#YtU=I7h!#CJG}X0Z;ILmwJn*M^ORKpCLyKR|zT
z>z(hz56fH$mq+53jl0Y<i_cj$RkW(+$uIziok&{jx{8<wGY~4e_-fJA>4Uc^W!w3_
z?vM3509)+?&IKEZS~T_+xe&XtU~SMhLe=K%`Jwyz=Jj*;v90ZjVGf?!z;+RLYGAgZ
zW!_olqD=8Jmjxe|ZcTs_oL}BDCwgb=Sgx!gjjPWu>ylJ)l4B}qRMB8`uSn5lm|;=Z
zp8F#!E+e)bxn8m-n~COz)f=5;{RrlOPt*6t-|LH{#eYCLd=tzArrguwpk-`XDepc7
ztnAg-ml1|R5P_|1JdWde%IC^yBvW80%X^>L+xZDv3!M<4cFK?}8Gb435z&7N^WNrZ
zZSSW=*{P?1GTBE<^j?BjWMpr7vn(#e^pAc@bc_`DJ^wY5PRX=c?Y!4y^`#$VlE9+a
zu{A3*;*&Gm$XFp@Nlit^%$ppwc=m1%Q^sJ7s2%KcCTE|;;qt$knsaK4TmCvVoC=TH
z(Y?sm%bzxc<xkfk+5X^yk}c3|&w}EUERaiOvfz0acmKbF|L|nvmEtKBa*Toq+vErx
z3v9pieA)xV{@MQVZ=KTIUaO}9*bh{2HqA_OR=i>qWK>j2sx`<1`{>d*4Es(7?R*8l
z=i;C7a%JP_wtQ=0*eQi~WI^M#P(n<VVcjxU($@PTQ!Ir~qViLoVA}kV)Rs8jPgN#6
ztj}3aCX6zWk$%i6ib@%zEl~(KfsQ@eHOu~A&9~91muVTN*;bP#*9iVXu@rwippj7M
z^T13i_R4!*_6yC|YFDd4y7+JTQ%($0A$DZ<I#o1bmHF>4a%Shog+s+Pa{nE`M?75)
zbz1Yd&tD}Ek8iVJrDwNg@AHXm(#SAP4<nb>Mr_|p-_`9C<iIU(+p$y?iU~&(ISmdf
zFw%1y!heS}$UJGZjO!b<RG0}~;>8dVA<WWah(ZADCs~z|EWDo@Oo;@c{@`^%)r)m(
z@|-En+${j)BQiD1UFQga3>=heTuWOZ%7Czpoddd-&Dl#tN-P?q`E=e6{uoiAIzjkF
zQ;gT86jfoHW1n9?q!N_s-qF2?ylcPv#w;W_!6X&m;AcogmK^+NM*-}(Mbl}@`|^O}
zg31^YSv&#TJ6OBoZYpdT|5(O(D%#0>cp8^nNc}Olr%?Ky`!v?OLu6CSozlA^Hew&1
zFOWkHGYOC#=bo)68=ViM&j*wsi*4LzphC=}LXP&0kMx3TkAd^;ynO5F#TPq4O6{4P
z?w_c^%n|^hEZe`jZCadD5M)YtB6?S0l>`e$C!T=Uo?#+<3HEUC2?hSQ=1N56yz3rR
zM~=>?#Zw`a>OB4yFxSKOAsV^yKMIrva(|9sgnmZH`0CuWv1iXcquF3>mb<Zx+F;wQ
zxAtZc4-15Uz_V(l{QJ^+i@4nCh?sBq_tQ5CM5W)c?~jJqPFq0ijE&DO6WT4~d?9L-
zOhtQXio{mZ%!l75_UEp}!}0{hul$$sGZx*><)yoa7ICNCTi8-X^5TgKMs{ppXiu)3
zUoxzxnNyo4NaS#$Z{22_;oI}dRYmXAD>AD|CdrG<{6;4i+p#1>B($`?+woTYI6;@A
zP|Zi-@aF4PWWxQ3yYmm!AK3o-LQ>d)uB~5M<~lg!&v;+YMal*VBp66ANQMv<$A55H
zL$lFt?rC_bYF5i1HxvnLE}YQ|j<H4;6V~&#OQ39Xj4t<Dn*_LF_qi9Bd~dCsfUsW6
zvR=K`y!+j^yT$@??-OSH8p-d@y$c(EQgjfCexnDRR#2nohQNhiyJwkEhIqRs5Oa8*
zoOjmB$%#op{36*5X{H}0xiGY63@FbSac7m_iN3ct6~m5O58Z_#ESwlZWOuw0mEJpd
z&;h0`4qExUS+e&MF32p|F5na7qe#B;>R^^fy3|PKM*hqS%-%C_p(=ufrL+=6P^`O~
z0^&KL&k;#@TH1W)6VvS#C!6icX~4nU`%H0GK$Ps)AipVjA1u?|)I&e@mSD~;0vc{y
z619Enh4ZW|!$2roY?v;uFm7_`fXoL9-MdGnxy(e^3FJq%1(BrXtHK=F^a80Wod}<!
z7ci}08tw*rX1gSgRTbvY<B(s<X%#P}eTe0W_>E{xQ+vuzaS~^KvXuP-P(<t~FOmBN
z#9slons0+Fjm_ui9T?EQyaSX6R+dN9@$<%4>%~lJ^v&9WF=C-Ri31e)Z8n|tfhhh(
zpFPvX!_vNOvgv&c^WjfajWfISX0~z-m{j~~A*wRnd+t%jCFHulzV2=7D~FJ{AkZj4
z=`l<ea9Hv`HDLZ2;AkgCzB!n|3;Uon<I%PFaS|ywd+mj$tR21!%Co-4tSs6K*N=S~
zH8@f@_bm05lc8O+wm|^02H*Z%5O7uLd*=CP?}srpqJIpFUBb(KcwD)mX}bcyJZD=+
zjE-l9>WKEn)&<L9bVPxaPM5m-%{svDo1Jz^3crwTj8_%La)`{lw;aq{cL&^=^^TXi
zblrE8F^!s!gHB2-ev~r(U9%7=tRwk7o{v;t#o_K<O@_FW&=Eb4IzQ!$zso{=l|f6>
znvP1H)7T<koYM!bO?p7>lH{@-H0nS1O0;<2!G4Z#^b&VxmH;nTY_=9;6To0@uO``<
zUY&0o^ht>SWW4;K%*4T=Wek?BxHyii$G-t`qpY@T1Nc1FqxMdFm=;s+xWr@c-!cTw
z72Lrnp{WH9M;RsQf==<TDH|wPu&{lNl0Vc2?Yqs^29=qm9X3sBte0^Q;JetvZS@@T
zCaPLMvh(?H^Z#{rvj4MEvN8>EzPzYyLjRe$B|5>2;qpK>#6D}%Y9#6OkR8uREb+vp
z-N_-3-We*f)A^S4yl0a!jQ9$>vy8x(GWaja;U@!jTHi<bNiJg2va$ZTp|_<t!NBGE
z-C3%aL(USwi%$ORA}<s(+KXvX>Yuw{S~KfQ7Igrd8BW-*Yv2_e?Koq$nBoIx{V-aV
zkv=uFPmh7)aZLoz*2CD3w9aI=Yl02!H%mZzH7Y{bH{8YyHKt?hgFUz-LyTIL1p}B{
zkV+HY(wGuD{VU#H;B$B_kC&|+mKzIIbh%p!NH@06=N3??60i;aW8`Ni_#@ib6i5l)
zyxAXm%Q9}swd2S~>f|5G7}QSS(`9w{5wM~<HVjM~-naqW&UekWWFdgl138TKV1F6V
z!04?dDvR&q<qj@`N1#W_-d=b2repLvpt>d(jx-|v^=r!Y@S!Qa$u=lLwIDfD9h4tB
zbg>Qv+yQo0?5JZ5V#0@@wOgU{h&PMPf}_iVc&6go^SqkWUmdAPEu-2BYF-(dP}a9n
z{;qEhhcegR$u=R$^&Oq!L{lt&-yyj3i`n)_%fYbZzn)l(j&B$@B)VAj3noMctE}@I
zzWws0<gLY~|18bH3d{ouxIy}$myA2LY~w2m(u|W1m8aoi2E?jVNicSL9KaL9%L&>?
z51)$No7VFGDw{#&&cFYEEdUsyJ~B&CCm9ss^F$IMi;BOP%vKipG>d9y83DZOlrb5C
zVank(<{A5SCJpwF+}pqklrcDyqNx_8G5+3<p?b(^gD|jcpM|yjbgSC}6trMt@rWs0
z8V<N)oV!KC&E$@At4WImzipd^%X+~k-|f4K?_U~qZR&PSi?j~1k6Xqcn{pd8w_(h?
zS-9#aY@H%vkYru8t+X$~y*yb@s6dnf21IAjcmoVEk^p5#K0COU8&dJs!$8|c8Z{!*
zsZ5!UeaW&ZQboq=Qi}tjesfD_Xq(+J3fOO&)+hGrSxUdgz1at{3%6c|?b+GdFoG|L
z@^~ATq-&--jgt9VdO!@+PkZmScZyP^vJak5{d>;Qivyavqan_!-(3UduY@6Raepz*
zQ-cf4)Z<Swkrde5nmf`6%TFwHZ<N3391E3~O*HL9?8wg3ic!ARDCJHnU&&c_A{Ci<
zB#VdQ+hcA*sZS9uAF2A$Hpo!KX6|j%J#;l|PYsFCi!d~GTOT_KU3V{Ck~6jS^gRRP
z#?inh5+Pf{^0vHN#f~|Ar-{`9`1(FLrH@y{86LX4gnMCWjjM=O{A2tIlGn9E`)(%^
z&Kj||7KEb76pNIO%k13=jP_z7kQ@T3$*LMbB22GKkx^bLkb}lCUlg#3eQ}5$-=$sm
zM+9892vRaN4V}GH5^9)bExztuB1ajgY2<c;I#@bR_aDd~;RVgbc4ix&D<0#DnyTST
zvXP?|7f(jrlq^k{7ee?x@8E)xJLTNqddYAY9kLVf`Hl*mn3%Q7W=0%Jj34-MBGQn=
zos06`^w$(a#RUs`GA!1gZ~VpKd?~T_&7uW3ITb#~NGMl_qLW-I(?7M^cssiXl>i9Z
z=_DAhtX%SbuSQY}tB8n{a>238vKUPq9x4${^^xk`uShsd^f}OtiJ1ve{bQ%hqb@Z9
zjH`y-u|aOOTW?RrTg!!TGO@tmu^dcl`A-k+U*?Bj_e#wQzUu*+5@9Cpj1*mcck4L*
zst8bb?Qid_3JSK>%cmguUDsm%RDjp=XBWRpR-|>#q%9T^SDf2?KTn>NerW0NW9c!9
ztI*el*?gEmwV+_PUT2TrH+PeubPY@ysimKl3CXN)BFwMVVk!*v!j;<Rbh2RVfG8Qt
zdg!H8u;6lA9kM&(w+r=L{zzq7I}e0G9SW5yrB#)cpRt2?DpXdZ_LYc&KQ?G}u*<p6
z`|uP7u6Hk;diwuvtA^u5xbdcp&*l{3=(_2{&iwDkf!w*jq;C^vEFkT*EdNoCE{q#w
zWD5W~1|GDpzLb`M1#j|c0Bbwhi<x8ix9f+Q|I{T3A?ugZqZ-Y{%#7{3zvweIqvDrn
zzGM2bcjQF4f1Ug&k+tdtx&bq%FtiP+n}Y2}S>~O@<1rJwT5@~+`}iJIRZhVw5$wQz
zEB;a>X~?V~uS|p5PD7*!qu2wLI3(^b>WU!BJ@r&pMLT*x$O7j}&*#_WCv}<bft@JM
zVD^A%GGI#_xX4G^>mAc2l`rLJl&+(EgsRZx8#);!r0l9=k_lmF)R>ou%T<@X!huJ>
zm%{>D21<4WI6X~<&dpD1_WFj&(fd%Fnq5Z$zA`|kf7TeWTIj0Cfn-~yBp2Z1JFoZW
z?jpcKqkM!33JwP3(|O%K{FJb40vI@$hwUxgGl2@D;AqJ1e#8?RkY_=XS_a$E&^P0Z
zUH7FrK?I}E`o?%b8s?@|%re(L+|d|rdv}6Uf%T}=5g${GsMEerG{tP^&5rGthV=Gp
zF@ez-k~lfeumc+x6lnm!e~ytfArb&XpzY}ZzKq1MCU0*K*M&GlBNaK?K#6hV_gg%i
z{obq0>r3~5?r!=k%4JHPpH_A+chwim2(kNE5bA05h}`x0RaiC{@$IV@Sjk5V*Bk3I
zW42#Z>z@^vk<=RLCG!D3lLT3E(b}3QE;qDnA3_K7d<nh?plj-lqQ;TdQZM=M<Q;UN
zRh`R%msV9@IRa*=gc_&B>7PSvWw=Q2!4$hB80qXazU=YJ7NmfiGazCzA^52pU=;#$
z_6~C?UlI?MACV~ra3BcjxKAb`m(daiy$%UJJHFrh_g4rXwW^sloMH-^WALBOhkwj7
z1xHk3Vf*g&nUsaDv}See@i#gmP3!+q;AMWw7v>e10k*tF=S$#nT_&f06fW(|HJ<z!
z(DSkbZBn|`Yh4$u7=Y!ETaKI7?z&P$srbfogkb_a)-3fyVwhE$T0zREE(rCQcxY&v
za3kY})n~Hh(OrX(Z>F7R1MYPE4(r@A*2`;Ab!=758r_$`fQFe#h;2rUA&Dm)?;f$o
zjUXI~scmNyUNVvDz3?aG2;h}A+KmJ&)sv6xjXDidScfou#}9KG+5nTyy=3uiwvw!c
zUX$(1p|Ast^yRQKu;h_UX?&jx`cK&vBU5e9i%rL>SLHAWPL@A=b4lJ$kN$m~Z|+Tg
z-_P1^0#6ZB+}X|};k@N+|HU8MHiTmPv!jFE1}I3uK3W<r3$!8CeA130cnH0<{k#Cx
zGf-#XUFaH%qI)0<#>Sl@r{Cb*w%zK2fvWKVQ{rB$#V(D|`-*$C<%*lITyD)xM{AJ}
z4oLx`HM-p~mG(ESw9ks3An*uT&waAZOup^#?_bT*@r{2qnp&;SX`UltN8?Q1$WW$0
zTr&RptkViu2fH{^PHL9g!z*gWB-sT_dtoj=L#9>q0OU#bcU&2l<{7f8HelOqJ?7-l
zlB5EFnuC>j>fnq`MWf0>BAj`u$jn8igq-M8&hv^Xf+F;CiDUq>DkZ1fIOdcA*1eGm
zRDef*Q;^Xb1?o6HaD;E`Gke`j{h*g>8j_tHkwuAP(R|V53z3&S+<VwaG__4(zs5gj
zeduak`tG^uko7NPQ0ZYOXvXb!@dcnh@!A$!L*^fT$#?!Z7ER~>74jOLzP!yVXrIUA
zF2_%rDaecnEY?Q#&@K)PjgJsUzOsm8DSP>)jx(X9;>uyZ&UV=K2BQ?_VfK<;!+Sv~
zqTnGmRv^BjMFImrN*Mi|)@Yl>E5>|~*6c}5sSEW8Tz(}@?sI*Wr{Gl=&w+6BF6Yge
z<(0stzRub`yf+ap5_Q?Ogf0qv8R4osNcZ~3g9ymK;B13bWYB$6kPC>X@HC9Y(TqHm
z`scX2Mg6=y7-l(nNBjiw1U#SZ0AdJKSo~jF#ziNqJs>j$lu%}p;pu`}5BX3EtIrZ=
zy5^iV{N*pjC*SMvUSq1-EJi~-D6ywKN7kOchcIn8^woa`TWIek@KSV+_48lVHZvEK
zK$#OLvX|xyno0oJv}1FyAovHdFh-GO3s6jpjhv%r=C68dee2~)rlO6Cy0|Tb^Ei}^
zJ!vN3<29#$(+r@~y>Im*k{E@ozV^B%KmcOx9Z76%J`K&ozMnmpp7VACvsnJ79SDut
zQsQGA{rs5GR^54@#gs_0FBE0K|8g^ghjn(-S?IPsfgf#k-m{PdfNgm`qI<S)_&w!5
zogq&546&}o1-3><)qm5J!xN^M!P-AE)WOkMkl$*|01-pu4e6y2kPtcs7N+nb<f-%A
z9Qy?h@aJBWY~FB8$ktDAV^uxa1pn#sdX4!XE*;qB_T;p8$x!MXqEj>Cp<c<H56<7(
z8Vp2F|2yvAF!9I0Evl{X9fIfu>yq52<IQ}sk{gKLAGdTdt>Fi5@uITdQ^sGX*yRHB
zm$TLSl=^r<u@Qd<Du^iLGdX|X^V#SV{PXGV_RXNpbLe?e*)_dcq8(o7Hp(@h%l&H9
z!LM7b5+2vB+blb<)UZR|9bD)N<i&5CV*(MU^t&vv{vyv#Cv8#UIDYV+wht_S0GSXm
zkSnaW-P=4lSTCusmb#R8%O@NkM-r2h!>-Fv2l7S#-j;JuSMI$ElDsq*H$h_Wl#=oU
zdJYZ@=KN28w3vhT-K(|Pq6yrGSXm5q_yA)M1YcU|nNSWiUCjazKzhqb#$TOuEO1Wa
zb2d!*?;bwU=t7=Kq+6oy__XdH{%;wp4T-}am_uOh%X++AVQ;JUhwT){JUQ(@_ee35
z3H?S{;E1a@^(Z-{F&Jjkp5)g4d&J<qn-MU6kCc$_!-)>`Hh@?cdnkW?^cik@d~O|d
z0imp5$Y`XHF25Y$X3CF+>Z=pnV;*ddWj~^0NL79zRTQpqbF<kIkVvT$0)fjAJ<4w)
zV2hzHrXS+xej(g`?&T>wL2)6F1whkji=9--Vuc^Eb+qtu#YORG0`||+a+8Mc&T*>C
z&7Z2~dbsXQWty{U5>wdn5Wx6cp4rrwUs7i)*v6I`3x+Eb`^c)o7zrn_3S$_N3`r>f
z0Ufnv_iXQ7esHp_q9e*7U}W@C^2rOCI6U{$HecNFgJ;Rvgx%j32n#)&olTUeP}Vav
z46HcC84xo9EAo;cP3?><!q+++IvubiUIrDqNy4FEClbF8f&)y-f8f@5&a^2Y_J*BF
zgSxoiqKg%-yC)a?Nx=)beQdk_3SdE-W-t1R78!n_&|j%CkEFz&TJ;>=b>1fk<TLwe
zGY7ZuQkVx@#Zt#oG6{>k|6Q80O9fOhzvw!=kEscY$xZUzZJ_Eu`8rpr;=e`jE85hu
zI|cMo3Je$LqWm{uT7MZm4Io@u?MToJgoy}cb=r{yhrB_LLC@XQU}++-Rv+9uDqrvH
z<BDumn(2eAw&RL^A74Yu?R*8sTmTFM*#Sr`*c7GEo;)$Y*(~>dQqpSX=zi!hS57a#
z{zIp7ERW!k#sV!yEaEo8MkXMiSvT2cJIy8ZCXgmYEoGCz$b*v2w}nVien^N^Wuz}V
z#zUfpO4~=bc%hsm`h9lDl2F~@14?Bgx*P9yfER&wYR?-2E~<zR_q;l-n$2><-`rqF
zGs;=F?%c8pxVhwtxG2NKc^p?-^%Gs2MQ&WyO=5hT#t;C4HfHNA(gCO3H%9>8e%W@e
z*?9KGJ-n{x9!{p~hLFI@x;5fGmk;QsL_VR_t<I<3%TmwlY^{&9t@lF_g3dC#&k8bj
zdZQme?>Ay3a3!Fze>Sb*lYaa%Qo*!bg;>8GOf%6M%yE_k8)MC69abUDZ|8_qI~2u{
z>DDNfZyE2n6v&G-f6j@BT?}O{8Yc0P?yjXN-aR~obG9rwHk`WSL)dZiCi9O9ci@s2
zi>bNdu%xQ=#oHhw9XwEn_=%g6d}QQxI-oN7Lb=H=><;X!P|9pYwD{)hikjU}S&Iv!
zL1F<@)OsrP2Kz&9;hTPoW{*RH)M?7NHtTmc0fjLR2dk}yXAp7A-C0TOU3b3PASW!G
zowCjh=<YN`wnkPv7`=^A_ylp@u0PBwg(#Tfwh!goZNhu=DCdc(HpQ!IoEf~dw!pXY
zR5BO8Y(ll0K$D}ca*g3xY3P{vZwJm{fXJ^uDgC!Ug#)V$HDoMEe3viyqa?yHKp%?Z
z(Zb%<hKj9x9$7o_Yf1m$?i-O*7|Se<x9c68dPT9^(|`E3o37R)fUF(S6=s&ub~921
z&^TuD8CfK?dwl~gN1?|);?HDDG28cWpI-4_y9$Yd$Fna;E}}fDR+#uy%yOFsJHZa-
zI6XXy8ez&$*3^mNg70>Iqq2BD=%G!N;13<?;Q;GVc8-e8iO<u*bNd(Fu*Ely+MSi?
zPrJf*Uae0FqwKugxKaf8P(O6hJg8bhoTqN+uX?vPmV;f&$bOWoDAX{<6r$pj)!kgJ
zMh*$8S3712r3$90R9Oz}QP)+g6RF1Jiv})EEj@$fZJoNF_r%jboyY)Nef=h(V~h(3
ziqB^Q3g?<E(v3?HMFyR~_?jJ`oI0XVeACLZif{Ji@;DM2h|Z6)RFsab_@kXe-cdUO
zfr61hW!lVnu^#zzcKmEL1(IE0jQlg+W7?9idtyY{N8YSKM>t_eh#xFjtsu-wT{@tn
z?PkWONAp-`oAP1V=IjQs5I%@95cT{T!tU52OhO_=Z7M2mbyUG-SFEh}e1s}Ol^`m+
z>qccHeu8zlAU0y>t)oY4ry*;E2MO3mI-9?B0rub}o?;&UP$9EBU&b_rGW?tQq)dIo
zB5`b)z|fqHVPli;CZ_qyuE#~jE>Ce=46)?fpORti)PW)Zx-GNW8+k?3xH0^;bi&$&
zW-ignoGQMa=Tu2BPXRu4%$DWl;GVEl>0dk%93Ruv#J`mv<4L@a63)3&-+CX~2>zLA
zy`lTQo(ryXVSEJ*zLB9$AlTh9Vp=<t)@%NR9~UoI5!<%!{CzqsdzYl;)UB9K)NuVl
zdYyFTp6U6CbY*+*FIVL#%?VTn$p3Y39}0=c%dnB+GV~egFO4Ij_d&8;G<km;x@56*
zB6UBzFJ0`8WfcqO^tO_3FdRXm3W&w1@bSd@vtJf;EsaL|nkqnxHR<kKaVwo~8rvi(
z;=kGdbj3g?9|2$z@DtgDE*U|k=mgxZ0!_Xsj??v62#Fvip`(~oFlkP0o))esQxF4^
zSUycbgW}8@3cN}TmCekSPJScA*0zJSZ2SBm!sg_-?UakH&5ru>l!ccVTmTig$Hw;R
zLNS_rF~UF-DO;RLx@0MP-97MQC<udz2)fSDR$#(>rq7sDzhLX6LI(QgbgN#ESSrYW
zcBd&xycH~Vc>|@akQ+A%pYZxLpDK^g?0q0<f5IL+<Uyz(?<XdFb8QLMuOIRM{w1UV
z(1Sy;s?X=_lFja*UFXaVMIP@{F(gm47#kgTKj|0iZ<A~Yd}DAt+6tC?Bf+E_^C#lB
zji07_qC;E5b(*qCUF0*%$hDYnDFgn%FOVml6PBH|J+Eb*9o3|LD#rECyW7A(hV=o;
z_U4jJD9kL??gH0ep;E_&?y{=@#;(QGQoggY_4(rBTl<m4kaIVB0K#Bsj!(2fHmV;3
zQjJQ;zDpviXVx+@BhI$V*Gh99+tI!sp@%fXrouZs7$QV)<Ra8Gi7Q9-54*aLvCmgN
zcS)Z2Dcfds{IiJ(*e&enfQ2iUwdGipK;SRyJ==31_5XC7FJg-D+9cO3r*Ku(QoBa;
znaAk6i|y8Egs?~2^P127j8;afB-4~jO`QyreeJN=HTkxx@VT13o3eP^rhBdgcCe{C
z-6MxGtM~6n(Vkx%hBvOGT=K7vXFoW1A#zazgjH@yoeE+o?)^8oR5Rx=2`ROamrg<R
zX<u?UL7Au#$dzLAeT5T4`$ws5J`&mQkB~j@#k6%dxRjldw%y@>5%LTcrOtu~1;dCW
zVk6}^ZQlTMS<R*U7jddmoObNVF<v`E;ULjyg#oJ(&58=kuNnZ9*Y#@Cu{k-UY;D)|
zzE>|>te0oxNoBYTd$|4Bmn3wKo#plKBigOj-vjD)Cq&>mgE6k(wF@Lb*AQ*A%rXK<
zP4t|ZM%dMU9~51EF(r{<cGNCBbO*@LYe+zp@5kfDgK@;go2#DDrnbo_AY^=pkr5|@
zsyzs8r?gw#-nM}jz^L*!z&9xS#sbJVfxnpRi=cBNaK}i!7yKv!RN6mcQ$=TTOeGR=
zgA*=ER12(g<K>*%Y0&9|%N)-7;KLip>`4)lhf=tbcrM*`r~V%DwmuHM^t=yYI~my|
z4TN49Wt3w3r(2zN7gDSN@&@<$OHj_#u0l!Ow^QZ~vfzPkta_U`VyH>q$-7Q28m4-7
zbX0?xXrLZA_-8+{)D{MZW><Hl3%#D94^kxlbX_h@Um+KuohxSQKK<eWX9c=KnpyzU
z1Xy$0@$<#k5$*bczlZAHj}c$&{+)OO7MEp`Dt^3F*PL30n3PT-lsv7pfwQUaHex1@
zqa`DanPOdwwKp^Do#g@@<X8fZ6Z)+9W7_mT5@%HCna}6KWX0Ibsf8_StSJd~lFRkx
z2@k|GF#!=fxa$l;Q<yDTBG$A{6WCrU2VRpds)h*}d*|mMZ2j+?QdNf))f%}Pr7)s9
zLC#nD7UG^I+|~0%`0+ApvkV@+A?(#GFCOBK<SFyappYnip)VzeXC^D|!GP{ZYkRC=
zJ6X`Z7buJ-&wF#lNbkxa@-nwSrx(wlFnb)>L!0_KCYW#2JGZc1-Kp~PVn^*<S6I{2
zA02vs_71$u;Pd_2M&kEK)phOlv<H?R7oS@%a7zokuTd)H&bP$cYh|XSn}D`w(t{O2
zzZoD~^EYpis9KWD#)bqBNT9iG6H=`I1q$Fkc3*aV;`)8gL9Mo`(6L(Vwi|RD87mJ$
zTz!vHkw6hVk{7)&{rbOIqXo}pg_M?sQ08wgYU(AY+dhvx%~#VBnXWtNy7v=Gi#})U
zyuHyI<f38aG*amDg#4fRPv!`9w-X$WySndp1u;a4Irx;fy2cTA(nv&(-rFcIE=-{q
zw=a4P$_)-$H?ayo^p`wLU1zO71X-~B`h^n=1No9!4$D}g480*YQ=<YS>sXluS_4v*
zY$Dh<09WNB$MOSAp=8JazWoRr_Xy2lO(rqo5PLng=<nanJ;N!t;+n2_(zA^S?i_yR
zX(S*0M7sZk+Bb}WP#$53UY*!B;h19tW?|@G0CiV2su(z1r;tuM2sp01`%iAl`5F^g
zAjGjh{f9WyVEj?Qlg{m<l6sM(TJkXLAiN$`SFTSY$(#$n)Juu<EiRh__>(`0-f+Yt
z*)2`iUN8^iL@$f3Q{=;Uj^RM6zo=>GS;JC*SaI6~C_Zb>kI#A*Q~}1UIKUI<wp#~c
zN)OzHLavY3Tzt-D(XkTrvu}&$3|i(tS+1~5hUWS-=oXpD(R-+A6#kf3iT=bC^bNNd
zpSO2JO+2`@=ieFgx$I!rsGkCJ*}ak_p~Q}{_t();4<oqzcmQHcGH(KmYlHMJo2%dQ
zEHJ7Y<;3e7d#3<y&+TZF$L(yK({uAY>mR_OXWzdA2}xZX=%U1u;tJn)8Z%=>tlC3Y
z2i*UYsc@7x+xdY`8|2BF;UHqg(im0&I}&!It0WS`38W?;m745Y;%UO?(OAq!BytcD
zn<>VB38A+A71Or-OU0(LQpdolwC9aYbEiv|SBmP2Cn3l)kVEA6mVZp;R%V8x|L1w_
zml{3mqBQ|tN_Nn6%J!>NEW~j>;~bLW<#rxVy13tKhRS%H*bKhJPX(wtT95z$Z=D1W
zKK}9=Vn0z3Dc$90YnE(TmNR$7!@Y69B&!*2qt~}mXQBs9A1{{{sIrosnY`!LwIJ;1
z7@fAJE_@Fsh2^K~Nh5Y!H!$ye8y`P5flJ7}%NII(0$35G6Amdkm?G{Eg>0j@Wa;w8
zlmp@I_VWxSXIr(5kjeKg<yZtcrR~)xZNR)khE-mFJAsI4jW$We(+o>qr|G7NQU?Od
zbRYj`E>+=wBb5q3<Ranb&u-||G6Jg9&6-2`+4rPnL%^a^LB`)>EOC1nXn0{TiFw~!
zWNp`ZKRN_*h%=3G+456ZTq2Xth%tx3cJR*{uvi}}4~Yr|(OamW4fl}2!;y=Qq7tWT
z%%T?a(YXPsKTX4n6B_s%`_x`PlZc9RWb5DN!APM*GX1vsfYHnbC*to-(M=+@KNZCF
z`cD37lk$<*=OL<)*Xe?)?Q%bBTL~-O*wK;EIpri5-)>Q;%mP7vQs@lvE?2Z^{Vc;o
zXG8a)MA*o!W}YxlMY{jA6Xk=u-e}JaHN-zQniQwKsrrM2&jo^o9bx16x($oC;pDZV
zKFlnNw9YuWQE>3QJOfOJK+!&JRs)b=Zdkci2b{<NW6tyJoRa5SvD61|SK*J?4BzuN
z-G6=E_XRx(D4f3Mc2agoPWp_>TpYBd$f*Q-2f+bljlP}H+n=N>JxB7E^g%hj&jwA5
z+1Nldr(X|Dge(X*ak>h*d}UZ|obT<wVb_<9S~>u+!c;w}bJX#%PY}4X$?j|x{xc<i
zU+WT{sfPH69DF+wqF_k2gbHVBqS|mi@r=#z36SY*X|DKW?$;U93X4-i(+Y5X>AoGh
z-3-}{q<;X$`hNXO&lu-kqarPtzq57I&-s-vKQR1mEUT(i$xR*|w`-BNc?iHg-x0+F
z!xpfrLHyZoz2ql>2@2*`8oqzaQvM6D0Kk9pXHO%lcvl^`B7w%I;+L#4A<qZx94PZZ
zK3UuKb!!Jmp%9zl@_YpdBgra>n&oyZnz&if5m>!ej#}R%)ZiC16Zwe3HQI_6iL!pu
z?e!0fxMJTLb3wa+{#ft7n&brqCPh=Eg72H9gI0P-W`AAczIX33r`Db*bRWs{WbOTw
z-}gMa>=82Kq+`<BwsgIV@?j^4YPO5!8!nS##@@HDEDPT(d*4^!nQ%1p%X9P(eNW+c
z;7l<&GUT}a%)!(8<>&WVyE>M+MEW^qm1B;tjL?HT2rd=hXW^#f``+bkII53f)#`Aj
z<=Yj~Yh)B~9_5c-$92<9%RI$wTIOB;aelm-=9iZe4P}%Np#+&I6CLk>|NfOl6R>JD
zeUs%bGhX`XJ+G14U+{e+b>icoBKC<F)+iPV?t@+@LC3JGP)7QB5H9}}*+wzwLBN$C
zjTnM5u59$A`qc4^ClPmPkyvGZi`#6w(`lCx+)W94>BNnY-WJ6}{p*vw9KlWhs19A4
z^l*{nFx=ZhKQi%;?Um#VFC`dWznqPZAiC2E|3*Y%%}_+b&}s19FCmU4c*>GkBJoRK
zNH@Zh++YE3+P|I>wzVyb+OdgrD>&<3rxfNyCROvlDS5+lTyu_Rkph(G_ataU1^xUU
zSf>}V<pvrfs1~KiUMB^C``9oyU5$yR^#9ia@RT;Nr2hQpPO+}^!cZFRO&4n3i}@FK
zRDrO$14<%eeU2C-b&RL8$c)WL=S(~|UvD_H1&y@+Jc27~5gpf<jXB*=I%ztF7hxQ{
zUsuDnbv92;bm<c!tE{Iu%9bnRN|US%)pZFQ%McL0QPG6b_=C&}X>4o>RB7B1QtS&a
z%3iw)5T{(+G0E2YN7v^O<v@_#cfVohW#HuIy-*J0#Pr0_fKdy04}NOpR0<{P$+hH|
z+YpD@(;?lb1V%Kq+Tjte5Lb_Dzu@J?l-X+k>Fcnp_f;850%rLpr&d>gs3#28=U+Xn
zfhoJ#Fh_CsTp&rbSTx^UFT_(yJ<)U^Z)EIZ|6vO*96?U*)y>_b@LI`=$A^h8<&@2$
zWA}wVH>8VR3r<~{P68`Z2}TTP66lknUz<L4UGza6GbOW?*KT>7l{l^Fn21Qysq5Lj
z@CiR_T|cNxUG6HSAKy};UO3mpskh^@zeIt%o1A%G%*uO#L_Nk=GA*~f*bt+Azp|Mo
z>>6LIh4<#pWA?W(ZyKvsck0(i!+&9tq^xjyI=TL|XbAp9p;FV&-rSvb+L-9*r#nh)
z=d)Gil@=>7^htEM1S(cW_<x3?>+6)Qajj+1zDWc^i3vabU}~_E__>!A!q4;{I?%=N
zyLpqDOpf_So`3#Li83EvO)S;C>3DtoqbawhBK96Zt+w;VaEzcA>ld{LpGIePk*@b4
zA8g*E)i|4qMjGcXt(As?ip!L~SGWr2t^Jc!gNDI9zsEZ{PDWfVWM1QMo!f9h{<af{
z6)_<(pL9)L&KV-~+Qn`L@zT}UdhearyK<xd@L~rSJq+vVSGJ$*(1pZcR(Z{MQ+RBB
zO-<u)tbSjWSCx@D!mXj1YHHCxF`nu%I&7#hbd#j1Sb#<!EcKd*hy=FsCzp(j$k5g`
z-32B39Xpp?zWI;hJ^xjv&$?-P4OSz0^^bRNb}dI?bIy95>u!J1@dhiydbtdx`A%Il
zsl1yyP-gv4ELH71Jrl2;92PKCZ7&lsLiI&f6Y1i9!Z`R+dchrQY`=qER<}SIP3#q~
z2|r;<7H!364ew|SA2WWHzapbx&}BrrD#-C2?f;m?Mm7pBuolciVI=)cZGKLYIon_k
z2Tp4dV%zhWgjBJH{qJ5#sT&u3UCswWq3ex?P*ivRg`NG~yq21jt6F2e1^a4l6X`C4
zPdT4Ba9+oaoqA;{b3_*~_vH}n&A)h?f=593vHe^iJRjWkVW7cXlNtuoh%b2$o=6Wv
z!3S=RKkcjRP1jiL>|Fk48hw?KG_o(DLsNESl_~g1+Rcft9+$cd_=0hi-@SQ{I9VHj
zX0bChzY52(l0lgB;XWj!owkwb`@iolOMOnNS|Bmkd<=zUAzSUI0;3Aa*E?6a!W!Oy
zpUft%r=j+C@Fq}4R02IR5;E9Av{!xEOaBkDU2a<$uZ&elmr?%Sx5m&6a+ypTLis8g
zAN22j;J`gdP_*CH6r=E2=`$`-hrB|G5tE9sv(;lHLp!z8Cj6?XHop*7R(x^oJh3nt
zy?x7axSPkDCK{JF*EVO@R=|jsTsxfY2a{Q={&ypuc^W1V5=}v?%edyQGpj)m*X4`F
z<B?;t_SP`-*#6I%&QZ%bG7>z?f+Y3}tp%e>1xvYxaDU&QeZ7KhFFyvn4X;Y%&-}vu
z{a@-^(%Y#oi=S0JUMBn;?~C%x?o!SU+;4zDFnVLQEbq|EwVxJsauivJRtc9HZav4&
z#mGnJRu9|PJ~|%>1}d=44w<41W4ryy`ih*MiE>rwwL((fP)6!Hetr3`o}$2rR+c6_
zho#TrHCvvP9V|I9#F`o!n~ck)Asx_Z;M?8=@S=WZX{ea_`Xe5>){GTh^R@?kA9~I3
z-lQpKNyy8T?N{~Q8}*)(L6$9+22>gcw>Kc^V<G-cjYysvuA<>>U}8qwk28jFPU5ot
z>|!)koyyGT3lv?d3>hfrP_UO?gGR1GnO-uy&)-V{zWI4me!Ns4MNC#)JsiKbAnYLM
zi^)o}0Xju7DsFbZ?x)UP#-xa-^5MnY#}qNjC(Cr6nf;DPC;GDeU%GQBtubbEUDcnE
z8NwTWtlAZgU_@<M^_rbL?dcsU=UPh;qPL)7aGdF{=K^C$zWGVTLfK|5X_-i(k=CFj
z{tx3he3@5TGu`I`-@=H7vy=8uvE1<~o6UU*Yt4>YANg8O-nfiSC3apuU<ckNCwA|2
z;ZLRd0oR$oxMo>cfgIX<`{q!Za5r+crw6O$*@~pcV+tcj$8X`VKzkM3Il0t)!Nd5s
zF>C$Bzu(XyeQ)Z;@EXEEGih69d<qhy6^ae*Ra=_**Z}?GOh$0VHHLuee?|Bp{p%w`
zbYJH&v5skHT~1rte);0i-P9oaThf(lJJf=Th<vm^8#y906#Rc;`HPxw6tAxl6L|i#
zOUX^vulKyUJy@!%bbEZEY++3M27OY$QXx<4ovk3DdVFZF6Q4$ESk~KU%fC<BKSEHq
z;!(o>ErzT&HhXLkEz}-wZQC3g&pdUKkr3(YSNg&<hzf$t)cd}PyGXqWFN>4w>CgL~
zH&HD4YOIsL;qUalEt23UZGz0i_`DnqxBxAQTG=)fZdF~}=LucPNq8@p<tb|MTKe_B
zhXE<;t%)d$G3A=^){+#4P4k3Q7>zW|Pnz$My;}^2A-DhVHiuDQRaagy${c_4NoP(x
zbnlQ#lCBj?Q=&X<=D2U6VPVCh?3VQ5JB>23O2LLS&dxt~o*WZ|2mZWB`Z`qU9r~|1
z5T*edbbAb?PbQ`CsX%Fi@kIXzLf!iCR2YYlx}K}0f3YWOXLWKiT7fscB3*{`L{nZw
zK>@nP>`$wm(#&?ktgy>M-SU^cAEISdHKP-}1mg$3YRyO_5|)u4Ai(>Ie_2Ig)S96s
zn5=hQk`cNbPg9?m`aBF_{*VKAE1II;;LjKiST+ZxR4wjT`NJrWW2<gEsRIdVY#VKl
zAwEmCw?zT03wA_leVpoy@1NwoQp>B}5^A?I<|K!#)w2qFUZ_*JKfE~WMoY3;7BTT)
zC9=NARxW+VCGdIA)?W-!EHd(oo+jpHj#jZUZ1f1R+NFAYa`Gd?cQn@vhibndbur4<
ztw)WlE##%Ybf(2BwEoy>(<zEZ7x>cd5O$}8rNSy<hiFeXE<#e8WyRx|S6*43VA@c5
zc`z)FBd=&WlDA@j@Ma)gLO1smF~(H>>&>i{=I!vPXZ%%S!AZ@kV4?vhAGbt>R`+?!
zn2&m1ZcR$<mSwfC1WvcW(n~NgB;8ZGhyR3Cn5(mus9uey5C7O_Zap?2B1kbrkoaax
zh604TX?;BS+I!Y&w4DZw;gKw|JMZ2K5RF(P-#aM72N93jGAHEFCgt;zZ|ixZDdLl+
zKS1CzrzE`XY~gZUkE0eV$+@lSeZTlz5U|eGBM;VAh}mcj)}{;*l71zJ_nR(YIZa-^
zxqj_BJ5mh`)j$1;B8vJWUyxkOXOltbbd7Yb-nyG*B+E=)ZYu(RAfe~}m3q$m8FAT3
z^|5<!nUl$<_H_RtHT-kSm27JYoKos-0c2#Uo1}a1j`6j3D&=YeXHOJ-^Y(dob{n>8
zgVFqq;elog8?r_{ug^DLZt8sq*j@WHSWQGqF7?&OJ;`y{l`n`mfZ~ZP)^=VnudOa3
zaf_waXw6Nivic-wk`Ng#@`G;#Uo&=|Q|;!>;!@pNf0K24rIo;_%?>4j%&YJO^VL<V
z@Gi%MX|39KHN4vaYTG&zWbG1!POoEHk1&rKFG++vMoU3sO7Fhqd>iq9G+kv>)ZN#m
zyBVZGy1QZM?i>jTMY>xW>5%SDK^SC6DWzK)q(MqbnxXUkJ^!`dFMe<-j(6@ovG+dv
zR9WVnC&O7VkmBfP)3s*S{&={Uh&+#}hDfJ|85<GsA_ed9`J9LihbMJ(=Vk<XHSG=C
zq%vBHx5MaTdm1@n=@W^|#PWb5o<1k0gq1(>5bcC^v-$N1;9eVfUeC6?Y@!QkoBnsD
z{VA|fwwUx4)qIVq8jNkgsveXrH?{*NLF^Ww6;PxsGm1c%g6ml4ggo6PxsQ5h5zbx>
zVonTw)vMv-mm=Ti!z7sXUiQ$m`>NLwJ7c38bu9YLxGmq};g&k^qD-W;iapAH+;`2!
z656fMsbDq_$z;lHWV>&dpm34evpbKYk7LzhxTXR3HXjF^1>zfLPNmE2LDCguWH3Ur
zHZWsK@V-G=hZ|OXkNfM*5oepS^T%eFmx0^Xh>hGUhyi{ke*=pA{$wWjbsL9<QkejW
zVnnVG!JHR?H*SDD3}GiuHo#H9;_)x_YH(kMSM!crNAWR73@;zV$`Ts0hl*d$scJQ=
zYT~&x{23npCh0uLbfFIpK55$)mkQp)HTBo!Wuj>^?DI)-<^u~WR(VkE)t2V~kH{1K
zxfIA37OZ$wG+PBh(cS1nS9MhAL+<CR_D`$+-fM6$u%59w{6-^Oe6#gQsk_-ZE|R{@
z^p$L~Ewao@e_!6AU%yuYWb}U80CmOVERa@}AX%O``oA{<2{BQW)|<7UD(3P1RAK;Y
zXlhAI3bNy%eL2Iu^!iR0hXkWMyNfI5*B{XPfVKGFc1l66@f`i-{-<^i+jJ3ZVMB^=
zs^$bvRn7yKy-Y`*?LHBUfkAH$6(*w4yl66CYeU>{xq6K%y@BQew7uGza<*ce%Du$~
z``u@voed-jHv)*;q<(z7rrYg4M)S4~%pm6%dUHaR0+lKe<t6TlPvsljiVG%YY$o<O
ziss{p{4?SO;)ScqH^`g&+eM>ob@_*_{oV=HBDKiHrZtg+*sn)t!lX60i?QA{`EzF~
z&S4j|S_iGI1`J*OcS-6Sx=2^t-PS(UlJ1L<R7FMv>w+k1))h3QcU)hMf8tyPPDk47
zY`8-Io5_6Nm7!TLsg%2fGnZxpm=FbV!JEwxw<3-SYrvz7z7oo>c>pSKZX^DNG&u()
zp*AJG2qUSX-DAM%E7im7UNz|K->B!~uVT!l{~(6f4&8`8&CCAfY2}t)vdMQ5sfU5E
zhvs#~EmuH#(uMx(Mv_)h*WTI1a_xc!E0TULcd7DTv*il|f-iTbF8$l+0R)5~1zDgR
zIxBiP`@HHk{wfuddbWX5rq;#?2=RI_3fV(L1Wm}n=>g7Vkrs<>1gq;S2aHdwv3Ag2
zXA#qhuhKr)3r<Th_De?10vum2%CXY!=yx1&bqQq8bQxnSyy7|w6XCvkH%V{%N@L>i
zbbnd^2Wv$iCGt-I!pg@h8qcX})a;p$_b%f@A7JeZ?oTPvy%_MQ^U43>LFsn$MTw6d
zAuf2k%N8b;xII0$^b3{azURhG?y37eIR-k6ZGz&Dh}g~gN?sHYvE6+$u1}Y~Kb~}(
zD?d~nyh5v$CsK^dz#`UH{FOn`dAixoJ))3*lK5)NJ*X$mrA+j@yxcgi>fi^{PJ79&
z``DFMyEQcvPh+Z&CVylJkPeE^N00_QNM;)d2>?q6E3gt!YVB&UZ#@Ee2I;exxGYR8
zJj4xQwuy|Upx?(dt{f|TNGT?=IUxf|C>k2C#hb%p85tRo7RegdgK`!xZ;bF5Va%e9
zNITkWv^@8VgwimLC$mmYP4%@ZsZlo&PCc91FmySr>E5_UbeGLFIho`Nm<9|C1Rlx1
zUGiTVU?lRN+C^s6#pt%^Q~_@Pc^Kcb6}{G5^~{RP1DC(O-+I;4Mc@+3fzmq5E!3pO
zsjW7nimPtpOr{O*h5jo)y!ihR1mXFX(q!bymKanRz$}*l^`}aoRjMig<P3iy+ABW}
zxDeuOU%)<mO=K1hCwWqDH~Ri9%htjlSvG|aCvCc3^;bETd><bOf+oFzW(Y+C%Fts`
z&woAheQ+eEPX_FvWJqn~9|Ptsf?j7iR<u+XWNL)<g%5P6BM?M<3TKV$4O_S}B|w;R
zH#40~pczIr8mXryRRtN>H|5o2nf0@rv;$~}MTEUcD;?ni-1Jw}NWTHbGZm>UDCUse
zxs8)cbIHP}k;~!d_zRUg75*m$u#$zg#8Zb^;N^AAs@GLH0D@#^&Jm!X^J?Zn-zW2+
zHGlH1QHDTNn6{dB8w73j;Qzd64s^J?SFM&wIO9AiIUWKQo8Al6qtgKDGw@`eAQ#ST
zsS!;0@&-JKkNW4(Ec7OL7XqP6Q$;WMA}(txdTx9LPWsMq4-{QW<CTEGlmS;kRz^SL
z6EYbDVKUfH1_A*YV+CAI&$cGBOQf>StS$Ar2JbSg1`T<8HGkKsq7ZmxT%<St&dwKS
z1yAf%=_h(sukS5W`I;jAg(2tG;9q%n6s4@MNBKv5^T!W)HfCvmMCP@atI-qo@g6U=
zZ9M?}o<WI9r_P`UfQw;hZ_&3o<tEPWMoEl4Mu2oVv#&U|Tnk%bhP;GpEe6U-Yu>M1
zuNh@hH<@C3eUNm$rtn}#=LJrLnfQy|IXUv{tG66u{u)fGmhkqS%jUi8Y<9f`qN^ZU
zT`Yv+3U*wn_b3RHdaMm&SB6eo`x~q)fBq!AH%T}@R6%!ne&fx#LYEWcK9pd15vje}
z10_)hPMWNOJgo0iwNM5RUm>t^m3sqNMCfkzwYnqHRNvqH`&p@|z@{It^^bViS^zkf
z@2h^ZbKicvV~hLtdW65iT4Y%)OlAX3pA(1@BBqvSJ*2NIs=U5`PgZ5owPI`U)>Wv-
zupF47dEQVj`up)^+k)TM38Y9EvYA;8=>33ksUs)J6t!2Geuo=+5XilMfZe2Za_@I#
zkOE3XyBJj|EB7s8vL8Nz<fOc=6|7^+^4?$E*LMBK&o)n<m5;}^H_wRBITM{Y$X^Vc
z!qeFX0^i2vM0t&cR_nu8F3ata)!c2#JL&<`24ZAg_&Z`aqn1z|;L5zq6_%1J+?&nU
zoXvEkF90Jy){qZ$RU&_+!AH6Eg)IyxHD}t)f7|~s8-=~-F>S(a)EUuPh&NM(QenN>
z-lLhOfVkp4Ov;hYA%rvA-*gnk+6t?(5>U+*uunZ-Y^(QqK=r8mV;|??Rzhu6=IAEH
zK$zq{z(jh14ovrk+>FznPZWmtf4H|lzAD^9L^?j^YHDdANE+(>wSJB?CEKy!E;*As
zShHX%r!mX=2HN;-6NQfKS;s~!Q32uX8zhxc_siGn1nVF(r#4?M2_K8@Ly7B)`)f%m
zDgXHTSR`b5hU^MdB$d(#*4UKbJ+Yt4FjA+J1FL-RpwY#j!9p#jEs>73t=Ssvvg5pz
zKc#@p2o%hbdKrOyQ%>~2B&MD_(Dm6*R80PTrWA6Wkk>*1=e`!PQl-z(n3|p+ONIHo
z;j-wB5*l4<3KnvFbG`ZS&V(6=rOA!w^_=Ll4VC0QvOT<9rjzm@R0Bok3P-CM)m;86
z{e?)d^zCVDmqNW89ycNSS)j6T!Pe}@_4w_!z#C=lIsgEqvIU3&x87y_7kvT+FEgN5
zoLXDcV$YBv2;WR<I}1H*W8C7)y!L6dF&5cTi&UG-hIoSrlC5KXHQt^*cHQA4^ikTc
zgpPk^jdL;yL43<?u3lwoJ=wzmhR@`I9~()@z{0OIkd}n6aU`-U`F(vv{ACGZ4#nf>
zJx8LjZ~M(eJWi<>kda_}!lI^~_^mYMY6<66NIPn{7-|Qh!;MN7h7uzRob7ekf}}Qu
zsn*6ynM?+X73FMw&>i(f|GR;}+X{{YyHPqd`o!b>?(;@T{2_PNbas&1PShFn^(T7u
z;RXfqoZ_<b90Pu-(^~bWd(PFEleNc~3XNQz;D3E~xf4Y}cNUcf?5(h&rif8NHByxN
zdh<%C8h2Ltj~}=Y2r_0?9sPchTN!fb{>g+eY%!3|X3-e~)uQ)wLj>U+JD~+A)e4^X
zjznuaru28~Na8jC;xuqJ`ri=&7$JNqz-4oIinX@0K8>X?C;?cAjosHwDUb1$pBgl9
zfap1S#jEjo-Zb+qpw#v^<gt)rCmC|@Fh(E@<Xo|FYLKZi?eSUd?&yI}fpScRH387+
zAGz}mt@cJ@;<+sYc(O?M91g5h1AaorsDGR98oNvDJ<%JUQ-(A(VZm0Xp~$o3Hx}O{
zCx>`7nX!AUY7f!$U#^HHFs$@d+m}82y{YYG+0K;3THOrWS$E}sHU!a1;L%v`{9^j;
zz`WxTX<08<V-xY3_cAVvDRo5jz$?{&T~=d(vS#@}9x6TL{3_WhvV4u&wB3aqNb>c4
zbdB5cL<0gp4HXg2zT~OT@$zY4Lv&+?F5l7rzBxxlR85~2B2iUKRqMBRwcncgJby7T
zjoExE-krFHzUaAu5se<rW(dW#m@57UitQ_Oi5$YiZ4-jL-(Joz?XX796ZvLi9fGf(
z<wcY<Pz;-6#=t23WWNMbCyCp^5}I|0kqzk7))!Y*_snz>kM)U?G&!96Aiag~tak&h
z`v4D<?rVnaJ@~?~F)pusrsn?0xf)WAW_mRS+KT{%C(tqgxMzVg7w(JJg15UQ&rwZe
zA9beYcN;y}d?mR}S=i}akE&S;Q!YOne-+AzFOHc$>F>ssx-f=cJ&{>2(?Z$!^&j6w
zkcK=9M<>xJ&O$(n%&!)Ph0EOw-cdut#dUE6??DiyOlt*QoS=~PzKii2cdF>m^R@5C
z<I0WRv}*ToKGS|GRRIiH?9TdrqJ4rwlcyk1p>WIpU;u^+2cRRbK%L=*?V*y$s(t~|
z1`s9@guj{f{6SV0b@NRQ{lI{Om%z^}+B-Gu`;MHX`8AWSLV7<!odTrS7#|q>ZG}be
z0Ub)hPS6_X;bBErOWNo8nym}XL!-_nbj1{2O^)9mE(ix?iW?oW0l@H`XKl_cim;n^
zM{{Pyf9%k=q?rfWvxog?%az{vgmL&!`<kP(uEWvFJ-?W+7+Cd}Ek4V3C2$4d=K~-L
zrScU3bqI68m)alU*Yf~c?a6s?P~6pmtO=n+7hUlIP_G5-ieO0|QI$oX?sI{$PkV+!
z$Y(%*T>6@5!F!93>sD%{Kg{l?)AmB~ou%v_ak_TzJt3?ecIlvNh|iIjOpS>=F8-(X
z3Zl>U0@p_e1K(iSCZ}o|UE-t|IPC=f8hcycIgI9KC#*Wjyl4|czV4N=WAT}p2`+s6
z<LJalgh@4N>qM_zZ(6Q^Yo@QtY}qf!rSta{3Rt%vUJ#{hXZto0pcGu%T(A+shX#G^
zSMbdJKCnFC;klii@v#dbk2V1JTf&RzlfCyTKGExZ=1DaCNXFQG|M*r|$sv1(*|Af{
z5xq;N4>sjIr!pjcs;#F73mDaghpCku>Tw(943k#nF!$oDP-#MdIuodN^3S2`=YY{0
z>g?CT!=Q~@@D(hEF?P5CtZ9YURRLAoHXj90`qA6l;nWz`7(1w%qk882E+@dlwN(JW
z;si-jH?{2UJ55e6WjZ2A)&?87NkWA_+|xub8BJn;D&JZBjgzL=rdDnfVOls<s;b*7
zZJpa_@3G|7cVS-=wTJF}E)K+&Z0!9%et*7w=W7qx6J{4mTlh%5wUlMSV!>Jpb=aRF
z^zi|QOuVHZJ0C!cA+>SKsNzVd{I-AkVIWnDsJ-_#f>2LG>yb(^lM;Ou=zYsnSct9k
zRB>h<lKYYpv^M;tVzZURGZ+ivCzHd^-B*kG?V|pC%JE8l3tQ_QUoemR@B`?x>L0q_
zH#@J7R|BeyL^E_YLr33EN-Qm`gxMZ+n;v-3WAf}=?x@Goz+vk%blj=U4!7W#Yd@C)
zNs_j&se<+kxry_gWvpC%*mkRLC#{w@+Nr%g7NhxuqR>~}9-NmOS)2v<u#nK~+;kYs
z{!^0kkEZW}^*(bmI*RKhjWv<jnLGeK2lN_VO*=r7+9>LOm01%*hCnV`Y$7BotHt5#
z*?kB{KKTkv_*SFsIB<y;&%K3j!gn5m!;RL`F_{BMjLktO<ejJ6;wR|B=%n{>;#GMb
zC{kfG@Kj@J|J+~*l|^xWzGZ<43!JZB3WyAmM&`^H3&@mg-!tm7->muzxtm#AS^oR7
z!GrK=W{Jx*f1BVDwfWa_V)$_@SrmCwV*I-g=RvfZ5Y_&$`4pPw7}N@47CSf^r4eta
zQJD@jnFpYD9RUPoXJeD@np(W~`6Id*zu>Qa0|0YLW~}d_1}V~cy*4reBk*v>PJUaw
z?Tn@$HLd%ZB*gJxGz|o(a!G)KoXs4a$=6H+icAtz44I76a8?xj<l|NYsE}F)00h0C
z`&uWDNdVCuu1EveC<>~H#-KIux~&6rxKm!4&9K@RhECgm-FaH(z|N<sh*8^i`d}BQ
z!B6OFurH`dNB-{v8#EpU9d4j9IJNmCB>gycAl*ye=2kpZ2Y3VwG;wN-4mLRDC(CWL
zy121oaAo{6_ylyF!Uc>Kj&{&6PF1-6<f#{rB(NhC9W9X$%nukn(~eP@ZcO51aK4>U
zbX0!@ft-PhdN%n0Y-5Wr;rWji5ufB%deP>h-v+C6;3H~b$j(*N?S*^HNjiH7OF$RG
zVza!udg3_cg8Sb5xKXBJn;tgptXPyZV@e_r$4v4_6J&eB9=Ou$%t!!7h?NotvVK7!
zJD{3}^cCw>)2Z`AiP9atHDxoAjIm@fz>12huM4zhR@3b@K$#pu02?XFFW9>=EV@nX
zr!>eyPMv27H3Eo1ele05(ku?h#ekY<In^0Dstm!`xnJeRpTpdK1xJ3>H^aEL>#CQ1
zC|qYvnarO6DW+t@QXO4N+48=y70@r_m(-L4tVeEnN5SQl*VNp!oVGH@fdLZ2sL$EY
z?$2!#Wo~9!an>KAjy?N$tH_uWw<9)mWEPNl3uA^<Shl~U#d>BkByJ~b47LWs+wGVn
z$yH#p)N<XXt^@Zdkawfahqg|EU{et=_*V9<WaYPZOU|>)|JMTe!jiV<6bqdJsI9@7
zbF{~U>YpBNDr+e#KeV(2n3Jt2u6B^w%dVxL=wkGBlPrQfb$m0PCS_Vh!UJghBR6N_
zNQ7bR>Ez+1xca~xTXVn9&aS7u@O%POY?i`0t=rTP4+7uShoE)kbn8s77SFZv!+K|l
zDWXDTu6b#Z3depgXI;@xoJI(u*f{L`<V>o}8GtEJLYrKbMu|a*lfgM6Bqespt7&i}
zhMx<cLCZDp7V*Vi^`ivP%u^IkH8?2^R)_{(k|7T%k&B9t)u&(rpfQz{xW*hWQWmnv
zA_3PZX0?^nTrOdp7Me56pX9Fwi5V&)qp@5Dh(IpQK~s^4iBVNSml33@q-$-NtEBE3
z)mf<J|6_Uo*v0m4hUU%H4bZ5Cc5?&cjNtWh69L=M$ot(>ac&_F-oLOnxST9?M?{e_
z)Mlw+(v1g<T$(xXtx<LiB-r8jJ#}gJt{}AqS3z5v-zH*dr^*(34eyG#+uDIz;kKwz
zX83XYW^uI0;f6ko1Nxi?p<?EgP=>DtOM%*$<N2-tN$G1rR#sikqe|LzjZr+NIQq+v
z!lilwep|qJ<W2&$hNfoJ?+o!U3B3G*MM5c<W}vB=+n_oy<+idm5;Zrve`vS6k@5jR
zlUVbArcy2lUFvA_B7K58*OMp$l~9fW()tY>1PU630Ep6n9_pxjG72ID5_>=q+p49p
zpkv+Eqwgt6yWojj&_F)DnqE=GHm*nt6GycBi_Mgnpv5mNrdVThc9QZQs~oEt82n4@
zSZq#U90issoh>pll%-{72C1RVpBg@;S;ziYNtk%{*!`@iFYSs3NM-;L@Aw`I^pI~j
zk1N;!0yu*hB_Pz;^5@V?u=(OL2gJbuil!ubEYUHd>Dj9nE7}IsG6okvm*JSaW&9M1
z1-7=v!ijqmMr2Pixh%h}Q7Usv9I-=j^PDAcsXK`c%}dVjuJr4Zl3@0m_I~YHf!ro9
za2SSB7rib8ci0mX0zAAgbo0}pzpnBNj`CdH;`M|q&Ha*Re7sh1^>Qr3qG!r8!7k0*
ztKF!GEAPX0F4B7ICknJErE~C0P=O>!(cG&5%a4ya^)&{g{9RmT1rF@cGW*qzLxRU#
zv0hCIPbQ%v9iul|vCaZWP*E|nTql?DFAYYcHqq6%9sx>j-prR&_xk{eb8r$Dsj;Ye
zcWAXiAJ#ioFGn$Mt+nCjEHkj2wwYpvu65g{Zlxo8DPyUMUUr>_Q8O%S`spCn;xT7i
z_x622i-QsFI%Kw?o|@$wUVFm7iak_>rio28rmg*4aUN0ANWI9-`jMy&FHq0gb#L6C
zv4@j8bL8URr;gN3D7AM9fpAQfDYgBJl3|a<dEClZ9xBP1{q~*T7_n^4c5S7i4*jX9
zY4YmP6#QE2ZqkdxXj<jReBaQ!g(&qR`_PbWINnH){WbvB>Fy4Cc^W+J%EWqx<P_)8
zjS^*<HKdexP-CE^XAna_YZwA)t5}<9n-65|F3ap!&ukEc3|+4U?)$4*RhF8l=WKga
zB4(l4FAiiXsS!j-WI`y~4U9rE31lXwvGlmovWRql$>+s_Eeq(wd}&s(C?;?s0%bz{
z_xoHK{ignT=hu~!{%S+v<_JwsbpBz~oUq;Q>vHDGq^h7#vehp2xsN32V1N0MJi+zX
zmr4UiD$2b62B)8jb%+aotWs`zqB{@1U(W*KN@F-xRV<TxuCQPg>;kRdWX%^|xMTHR
z6Eei9qyoYxmC_gxR_(8b-w46FD2XUFON>H&Uv!`mBxM3w;hm@Ge!L5|g_bl5?&1p)
zt-mdeG_{$Cn|2x!Y?<RMxc@ABC!-hnhK8060dGwew1@KP`TX6PZ^>X<t_b>#CP<P0
zKybljNrpSE)ByG~TEVMz@^f*O!?qhGVmGP@N&F$jxsKu34KiDr+IX=krYQ!X+^{k6
z6~fmgpr9<EM~C34Vm1A;GR6~DdhcIX_DAWJV#?B*SqUGb$Gq0(UL5!JvpipcD4Dab
z9FoD6>Ne5+HY+}IRd|%6&GNDvpY}N;mz`3Xg)f(g+zY(;W$9s)E2^xzpaUmYpmu`_
z3H&aV@MJgN(<2#^9zXS*(Hf3lVB$l#C}kCXr2~Kj(Y?^lQ-)ajs;MmF)Gru|Pe>^v
zR{L(q=SC~;6Dpm87n>kZ+*8i&l=KL*e-wP$_Plzhtq>qiW9N6r&>Px=Dn7jP%^xZZ
zNibYrjb+rrSDj!x_XvdDeJ%V1+XG_IPAYD-@%&trwTXelZa|ngT|Xk9q>hr2SL<+6
zj9x;WQ?vt@9igFvO&RXLcJmKCH9w3|kn#1(627sA*1=#^tZ~2X3RF{L=tpe*N(j!t
zq@(|l9oyCt+=<5<{#To6@7No;ea)n&wOm;n_r4;@6sM{6BP&PM{USvSW&Mw4Vx3SR
z%N(}|z6v%Ef>T2?{>48HNS70zJW%_7UEgDfA<A+x8YeyND3Gg<F+RmB7^CN2J>2H&
zD2XS8AdtGFKsrT7e81`PHBzHjbNg8uXIGFIOi*R1)u46KHU~uxGM)%3^IGA}?^sN1
zEwxS@LXjuiKXQ!KA;S+>0a1G!a&RV$%`P{tf)ya`fwb*NH$DT7H=)*5AXEhDKI#QP
zi~?B~a5}I1Sp47xK?c=x+h`1tZ7J*S$2gl$e3l4;xSt)l*T)hJEyC<`N`5Xq=!c`o
z%0NJ=v5Te1A%qC|42-%cg#R=+G$ChRTyC%2E6RCSbsomN*JO|ey~AbkS6n_R_cc+p
zI}q%v3OSWbxQ%I8spjrFVj@+>QT+OY(fGyW-{W96w}yk;>&ZP7S5TMlZx$c3$#PR6
z3J<Vu;MqktykpSC_-liLwigIahk`f=XDakP*EIJ%){GnQNUjbO6$ymzAw}djDTCn!
zR~<e(7s1@-EvbdgHW!hW!`LCx#S}Q=gWk^57}ClJXQUXqAYFO9RZ~J7ZIopl0CHuv
zc8n6ML5@jsmgv!m{OA)+goG<Y&h}eyrs-g0>>gzgT{m;vpx1p(EK(|nc2!5N9Pg3%
ze9`ZY9Cz08H1wmGFj(!oL-CNH{|||Se|9V|$KN=4BY|vFE?!Q#d3h7}lYjk!F~sHm
zjH!Bzdap%k*KfB2v%~B{(lXFPzxO0-eRWQZy7>#{{msq-g8YNe;m9B?CZcmP$+ZG6
zpC(iiY*nOnSG(MKPa_$-v!F>YydSUyG9xHCb17>+Dc2P1u4_6JO}pz}SlVxwWRQiK
zvd`-4q+(t;hQzjd4??sGJ<T4Ji_&<0CG-QT3&hgS_%0Yh2fI4tvk*OkFEe*3m@BAZ
zYW$G&0}AmZcLjB8rthCig^JT~PSu#y2*xl@j`VMUxGY+R8jvzTtgVcD0J#|e#`MwC
zRL?ABO6+xMck2A5ec6#Z2{;1=)yTipRHv;!Z+!(u?xf^|*COrTvNrVJ8i*O8Fy&Ne
z{JZ>Ax1Gw9iKKO43VnD_shpXi^xYUVu;KrUzWMdLxARS8?F1S`hwZOShVIg#5TJT)
zEAG0<4?_Vekm&hH*daXzJ=EkQHc=gC)^seJmsvSm8a;VY5v5GI$@ckI3&7fV&Tz5i
z13q<-<l{A|^gwO!y^EKowFf&b-qoj7GOIKKRI*8Qs!9N^<<65j2HYYZ0DK85#E^V+
z79_}3nU0cb@E_)@lByEoYWQxH+?%BI`y%}Iz_S*<@5v+J>%>||Rxr0FIUTuewf1h;
zH{`6`p2C2i#`fyhj%jBwQz|Rq_b*-Z28bbq2=VlBkyMeEvD80q&R5k}T2Gae^jJZ<
zAaYvTq4P!m0h{?6^N|@Q$-tw;yxW!9;OJB7Tm3}bq%u|_LsJjJqL+*$kG^@1$~l~w
zkxwk_arBwaBElV>BuGf5j3umCtXOgM3~Goszu`fQx~1h}>Yl<RM)c1}yF0*2gPoR_
z{VrZND~us;Z6iVI1x0<5lTP@nW~b%hNXIvIPWC)PeF~Y@*VMjQz`shi9<=fPR|b1K
ztic+t)cLsgLI{~Xr;hfbS28_y3jEX7V8otL{dg=Ll1D3j4?@SIF6pR=Tz{O?c6%6q
zd*I+Ylo7c6HW&GfC$<$P;rdllQC1;?M8^uGD4T8#VEr#=R}Z(YFL2l4FKJ{I<IW;x
zeYVoUq**Q|fb)ly{>Wfc3nfjAmQb|hx~&KMWYN>W`uX?+EptY^ehtOr!}^P+)I;o#
zDY^fWOx3&wa4`;?#<`?^bg^o2aIS2!Om>ZIPj-xLZ16(Ap{&*4klm1IAw>Lq@pWUp
zqklcUvNU3Q(oVC|%$76HM#+17%V^0*biP>H5d0b89f-Da@p@MRd^Ys~{PIh9aFAu`
z`^{?u$JuM!Qk8mxt(~GS)esAw9Ivo~A2;=$3&Cp2Nul(!`Qv(=5Q+;xiA)#g{aJb<
z$eMvlm`D+k&Z$Vy;OG!(vlOEN^zXXh8Og>(7+D!j%=gw#9(|^Tv##LaqNu{7=<xhE
zytdAN$K#}R$Hb+}kE4N6Pe21L5wF2>h`Z82c6Qii=KWhGJ5y!NREj>;y#_2kzMQ?a
zP}xLkDGH1}(zw<MK>|H1_vN=<ov&cMMGyj%%FnLYNDYhvqJm@lf6U??*myOs0ob`p
z57Tq5h|4P^Rqj_n`imQN(&jX#(jUoQBmPiBf$U$THfzd|loW*&E6!Jt7pV<hSkBMO
zd79vhOKhBkcvRx%QZkS0U4nPP+QI7&;c|U-i%r3}B4*xfP|nm^wA|*e{4vIR$6wRj
z^<oDKegOC0Qa5V59S1iF_zr3Q21wttg(EBLZoALJOeW%<rE+umjhYAk0xJU0@f%M!
z5c<l90kH^)>Ca#;>Y5syq(p`hdQ#4}Y8I}fo%pe>QphT|qKN_`!)_f>XZxmKwH9!r
zLKzP(2htAZ6;DI42^0`@({(c1dMwPSexAGb+MnKAvS88I8^veCKCB3jC`_pxoH)rZ
zc&qL3Kj7m5)Cl7Bu~>Ja*#jAMUNO@`|8Bye-Kdb~(_9waD1XI!x@!LFOfE$tBpHe%
zRa~NG>m^U32I?Wj)b#*gy0fan6FSweyfrjQ_WgaclI=?LGz>IJgh_|P4Ka)di_OF_
zT}5&O#lc+KKDD;b@lvnVPhSM);Vi91a^XWF0{`?3hC<TcXPbK8*`Re@DiXztX71G4
zZ=3jwON1#};6-))IsAwX?vbw#psT!(4O_ewLqRmqjLg;oSLjC;(@Q200^~i0WigK*
zG=p^V=3H+2Xgg%j_=aNl=bys8?fIhWo7Taro6QH7R*B!vjJCnev>tCzk*qNm;D9t8
zW3f<<EVIv1;`)4emdA7dY<fyuuW<H@^F5e8|Mot>!2<227n|B7ljnG+;q!chgRw|t
zAR-V#wgb6}S&2pzoXp9o6ab|Ts}`SHIaaOH%ES}C<V5|Zu4NS{Rv}({%@e)o;ji-k
z;c>6KWb^52U%0ei>VF|4O&=9xyqlO;TV5j+tt%iy5Ee?I3Q&k&j5s4HA>H_@Old&s
z14Qd%{fa3HoKe7Dt<;EZQ3J>CQL#Tc0TnbK;FFN4=ny4aWjf%46r=>vRbkv}P5cbZ
zz$a42rH+Pje_$t9dCUhrqC!+>aj0B1W^=#aR(Y`Am9b+8Fv~0I+G#}7c2zAk%frM*
zT?0>O{)>ltRVZcKX@L(9_;3-6Ct+pu=z7l20QH~X#XfQRR6XfAQh~ebcj&$9@id3~
znv(-@!6VR;s85jcgzUhINEZYUJh|^*V<A-;5Sh)^$-xS(jeDZjD!Ea)1)-&{)hwqb
z(iu(p2t-BViG!*k#<CC+=8B8I>P)602+oCj0z#0#!&AJ4huf`q?q>KwsmB|(StMKT
z)I&Z1CBdsfhf%UupU62XnkYZc%ga@L{sZ+shoY1bHBz6Disft(W`K-%FHS)Ex>bZO
z%Z2&t46hmcoJn`pCD;H`_NH1FTP#zc%z-R$KdQR*zCp8uGC2v#4xFpCiBYEJIB&ff
z3#jsjlK#4Zv5bx1B)iM|wbhc=M#Sra<*5A!sSyRLGk5u^H#Mkj<^m3l?2(}>@hTd#
zQ{E)1spqCyRdV%+?Fy=;Vrfd>0<<0w_qj9JvzzBCBZRGISmWescHd?1VlEhBddkdJ
zL<S8pSMX{y(#@}@Ycj<BM*_|^=#Vf4+CadQ0GO#$Mcyx%0ZYtOWW)E^#oMB(?dV7<
zl7eHoo-QUxg)`6^EbJML?mE3hp|fsUL3$9re2!t<5^r(p$QK$7sDe}*m0&zny?J2-
zl%;9}v)>h^S;_y?$XFXV2wl^Hshr-GjA_24(nxtvMjrrolUEar|K^%!GbwoQv#IBR
z4Nb^Bla=aL-g-!KmU+PE1@jO}P5rySLoVCfAA@4fN5B^M;V&qFy}gawD6Zl8%i}@U
zHit!5l5(MMV)!Xd2~*Y%c2Qf_<f<onhosrjqF;8%{rt_{k^qmVm0fn{i54(WcjIxY
z>{3=;7Kt2<cAF;s!td&|KG1JfI4bPAaT9WAD0X&27<@ZL{Ih<WT5p6AK(6ktCf7y_
zTFhw;ly*Vg7b%R0L+-wwLoPHS|NMflk4C8iZ&WaJOq-odCaGIYN5307mwf#}tcrz@
zeCThKiOWZq?IW#~%8~8%F)V?HhM_>?>>%KjF-_~@qs0SvZO6HA!`^wHa`0fn+uGtb
zw$bn;se$#!*_Powb+6`@i;}$BP3`C7(=*^t)7(hkvI37IcEIcTq3DqiAk-c&WA|>a
zk@3^Cm~P=OkEgA`)?DA`j26G6kv+eQHbXKh3V;j)Pj3I?5cV7zU+}oH&O11=lLsjZ
zLad=We_6D_eb}{5+j9#ac|`@|8P!D-M|bjs0kQ}DwB@*%nXoMia9IvDgD*E3u4gyE
zCx#u){8<KsWI_1rA^Tr{HU>y@wJ{4j8x7S4{rhmV+EH}+yukuwonlt3qR0K{+tu2@
zbnMKVM%x#<&Znnn-=iv0GU}q&G)d<JldFAeAODOslmk#yI1CEt=Fa{duKf4WegEAV
z=KLZh?8SV_tNoF>;`--TdEWf&d@A;ZA%UOc0?qT?+Z*_P8jlWl)`6X)wPFbE_&7OK
z2>HEIo^*!F8IbX|x?Z|Mv}<his@~isOa|vq23>Gl8Sjn&b9|k&PwCV@u1gLb%C;8L
zH5+}d)L`vi#5ciz-}wJnsWM3DzIlry)4bj4`G!Fo4e2l%o7VSwpa@=oPP4m|6`W|j
z)X1JczJx>D@uVc>F{Js;qA`_$VLR{<yKAT<l%b?io8u<rc=VFzpa(7q><~Xop?kj7
zeqrJH*}(N}WAJvu@Hq?^V*{p$@h{G{C(qW<Y2N!ffeoaSjk|nEL|i(;C}C~+*b6X)
zOoian^%s(LzYRjY5tK}4_*(5Flcpy5^TK*?0t+xlJIcKTcnN&uY5C)Z3kaeZG07@a
z>rD}h8@aYb3ctlY{+|4Ju~9Zz_cE1&CUV*DzjAJoiw&BXdn|Y|UvamauxY(p<^alj
zY|JFf?>@`-KT;V}<A<iw2VCK#|9iT(g-P$pWF56IVjdaFw!znz@YTO&KqV&9z>L@v
z>oq!Xc<|3jImL?R_PmUWlEymFiAohRvZrp87;c{vpQtIQ@ZBPC2lshj``H!9MB^J%
z7<0L@01`Rp`X|ZSq!K#zLA$eili`2LZZhToeCplPmz{vh++UKkov0|Gu~kTAABYXu
zA?86(&d+@zPZk<lTJD#N7{TMk>6OVmpu5qoXA1pDBHFvDE4pa+>#Z;L6w1*`zGp1j
z7su!{Tl-TO%F$8oSWE<{$yS9eoIq)J-pf%7|Idpiq3|Rz>M0LjG%*}H%+iz9b85DS
zQZcJ46}W=?^LlXQ=hK9FV3^Mdz>jIt6Atm>L@5tefkrV(WjYBAwAFX8fFse+&;q)E
z^`ED*;K>g+f5PK6HMabuT)P^hr|aFH&jA~h#bHrpw4}`}j@NOoN5NM|97ob_*;yf-
z1uwU*!Ji9He9ZlVBrIM|l6()ow*YVBos}2W4<p#krSDGzrCEdj#Fb<jXvO*2W8v?^
z-s`a&vSyCPCuye^W%o8AHQttN>N2yyad2q*cr_Jd|4K;vMgYGBYkSnAc|4e0tPi05
zK&)?65y`0fU*~|n;&Us~_2gIy?ah<$fdiug+bKgu@4W(3OL{)^+>j_v83bSSH~#$Y
ziQlsBh1>P=wo8ehaGUbxDI0j$@Bb_{7NtyM9yw&3r|?}<gEfTn26@Mf5fnhEzvkHc
z7`A^qpe4T7;miUAIQsf!f!m$vepgp5=W+<dC;su;yE)mMb&fZ|N<%EI4}Bt@=TYAQ
zVNcj6(sr!7PEx$6qUBvyj2^h}3-GZX@TJtsjnGzduc7)N=C2ol524Y1ek*TRgZ8)r
z|NW5|-r+x5{y|%&*XJo|zSdme#jYCg78@8C1sa6&law;hAd6dWgK1r9kw@Dv>A)wc
z=YzL50%AF~r=fj_=t7TDfZRs%0l&faMK<_Gy~z6bU&i0h*1tXw<3@hsdFc}&U`ipi
z2nvslWxKeeuMkVCAOQ1tYZ?^|I9BXTp6T*{MuFE*eI(_ZT_4Lf$b8{jsICr+Enh46
zW<Cu>S{K;`18Bv#er@MCgLda|_eT9EZ4MQd%)8x*Y+~C`ZRjo4&xHm~leZqGUYn?<
z&B08*0JR0?a_#lM;;C@_l6sDhQkeuaMxXgX#w9{oju;H1DjK`kflmR_mJ26OmseNG
zs!Rt5PG8H*bILo`z8Np!%kbyOya9nU<sl>>2xc@lqn9Qws+@HNmf}gsnQq{atU-EI
z|42`ta_dWva@B7Ks^#zaf+WWOu?SLiw(E3-!6zi#=3P;{POr=$(}I9bhO&2c!Q7ke
zz#vsV8r|>w`$D}_v`F)*mFh>9>MWiC_@jNI{%!Q$-Ot<QyucmG8~E<ZDZ#7|Y`Gy8
zd*NHZyV><gNEYygGzRU_L`4k&?RNR9&+MD!Wsk+?^-8qPmqeOCp7onyA#0;Q>&kD{
z6I1HlL5lBh{>TH#4;Z%rhT`=br@V26oZ6}yG&n0thP;3Zq1<r2*tBYk3@x?d{fe-3
zz&(@3%2o!je3prLHSj6pn@KaMuVJy{20`NE>E8J9DZtXUoj}!>d^a6vo|fQ&hY$F=
z?2xl_;|@!5%6T&xec=SgSSnGkbYOUiIY(tG)zQ+*E59lbu+VC|{)K&DF(c0jE30D9
z@gmZM=w5EvQWXt1hOE<_f&0&bV@roO>IrH59*wV$Lb4W`J5UqDLD*9A1SpAA6dRF-
z&F3YQwVPoi>UYx&+Ghz5!DHPivblMUt4}HT(`!pw^#+>-k`F+)i?Gt%5y=?mwA7T6
zc>RjTZ;QOp_g>Ko5V*{?T|?E4o4qhIt${o$3%t8{i*sA&<p$OgN0aW@iy%SBzzrCy
zoWE?F*tFH3i4<n0s?Utu{R3J4XQQpOa#U1K_AhwNLx=`&!kU!x<Ly_Wf679ZJ9j(r
z(edzrwUI4r{*poJ?a55BdTqVH1@Zmx!2L&(fA~2(T9+h)ve|rs<gGBDpy02QAoLW*
zSZCLhjV)ZqeE?~0;xzwr{VD^B2+(n`90}L9MCX-{7va$~dpmm;irQaW5863^14Qml
zDf#g8?BbAW(UV}s2j~TDcN(OK>OWzdxN1Ki<zykLMZc$K_3#zVJ(lAbyY#i_r^7%R
z(959?z`K~}>~jjSl@4e4fRm)*W@VQSWCbYw?4OyjxM!Mc8u8u=TvDCNZ1CMLA3Pc<
ztXtNGz}4afwru0B^&gREPJ4b|^w_vfzvnv&Tc~KH3}@ju4Jm@OY9l#DiDH2UwIb-X
zmj?p^*+6N$ubl1iKN7Ex%_0@VlIwd{BI}!T&aT_b!f{X!K+jt50x%72TSTxQ_x!mH
zn_vDt1a|KE?L*a+-(tI)0c<)}B)?GK>x#o8X+aszibjV%3XpMyi4bdM*n*Iz^*gti
z`g1lDkMV@bCZ{}DqHyrug7o;;(+*-yeW2_i6%`j8+bokeO6{+o);0G(<^oSDrbZlO
z=n#-o&}=S|n(rh4FbGtvZyEay;OaEL*Y=Q@hj4p9Jb5nN`Ir=+sQpd?Pulmd`@Csg
zK9E?PR>Y16W^RJOv>uw|;u0ogG}Q70@A!*sp*oBiYCqRgBv_?Jh=A`s=CEGJwtj4K
zeL3`fuGI`1ce@*I$YVg)$d#dM&&_5i@NG^$Uz{!pLx6X8)-9g|pHGzh32a}+8sI<A
z)?zN$D#Ty!bq#zbzVvB9K3mR{@B`{R(aRHr1A{oAPKo`%@Iep|+y*SvJpNj1nN4*p
zH4(Tw!KcBL;SLUWou>^$9j(vF=X_`Kiq8y~@bx*B82**<v=3F9tK<_i?)IVj+p1M%
zx_Q;&Lm!8fBz1*^9E~?S^JkDG%e+72NjkVls5(;@_WO1M86O@3;8uDt19I}bjR0xi
z?7|anyp8~nT<7LRdC=pDYjENZDKE(=`}6OBS!mb&L&*C;r>%5$F<?0VzbYzE1h(Cr
z*E};fjnzH5zB*#@@^aMivB_*9X#GyCV>S5n5Fg)nKLbIfF0E7nsx!b}UT-a~Wy#_0
z#MC&b`etiKHPe=gMZmG4)QWkaa3_{JOVlHaQ@xaeDTPQ;4@EWkwf|{t%gSgKd`Rl1
z^8pJ>0yY2Cgz=N-N>xC}O>JOT*UQ((rL4|GD7&e6NG!4K<g}eI1Lf!drf9!rc+CH6
z0b=?KE!KmG>H_v&3A-4L@;ugPpKnNhjInd8=`rlO1HJ6RyT<=s;*fMr-2Mg(&HN*R
zetbOJ3SAHlzNacY^*kHKwAmv?0JdNM^xYsBu*6hMQDq@MT5gMc*?W1CH<$E^H<0E0
z7knIYrzrJ!_Jja_=&gP%3wf>;-4Pv|7>DoFhGbbhA8m86kEg2U^@P%RX>wlAC*Y)M
zETU}Ih$Q+KPCgqZo$t6x_WivC=ZPe`?G+yXrqtw4nsmDuQ{*-;+?crqWeryN-nSVp
z2Cclge+Z})$s=p;RLL#3uJ1ZiN?3(K30PI)D;m6KS#Q?r!>__ox#KlItF&I;W9C;K
zro`OW=q`{Gcaw=whrI?|`>v1IdU&25ZEx3rRjhbaU@DSB>}rY9x#u2+A-|m|zRrvB
zufDfEKkgn~pO<lKj`GG|Ni;j}u0MXZ*gOgP;kQ{H{@7C#7|T-l7|arPv(JEk=J;}(
zMP?>3mIiD-pnV)6_4}9eMAoj<aj@ZglDdu=4lG$Rmf+VYTk7TYii$?R-A7*^qJ2KF
z(9dGD+51c-<{sDiM=ooxDT1-*rYI;S&31wzPyF@y;*d13HFQNB`A%8-QtEj(Z+-iK
z7MyhY0F;I?2TOO=TFW97%X~Q0`Xb^>uM|6bPL_BPKvIv-4|fAy@L90eiy3It`gzDA
zID_YL#}Gg@MRO}Ia)xNEM+c|(1?Z%&M)2X0UH9zh=3)`stw7wB)hZNMuF^a9@{)S4
zO1fBNks6k<!2jO<nr}t8#&&OBGo6DZ_~B!h3<LWkeqVCMwocU?u!F5~&f&Ava;RMx
z8O{Fo%k5RjFJ&n=>93O(e_tN)yZQvA{d3gHmH6K`-ZTTNH`X5^*C)#pAA`@pFZb}S
zf!MS?j4%STS^Mu)ozH*qSu=hWv;KvXKhJBwpgeU*(*Mh^^L^B(-EIjv#r`w}d)$0B
z9R8vuAS4mZsSYfrU4L15ArA0yCiz>XN1P}nLJ;W@RHV>rvvAF|+UP2h`mMMME0Kdj
z_GI-(nli0lva9qJXNChVD5D#{a^aAXD3&$phf(9rec@2@>$BVOkUNf){=`?_!J}V@
zUfrCm0MK@8UTx4J+pisVz-6)>@8h~V{<`12SZ8fl%$^_kWv1Hnryw4F4BYdi*BY>f
zt+GljluNX%A3HKl@voU^_jbJft4wRN*F0YEwAkp0eY4t@7pa#MTSZ=ByC>>*4=#5g
zVS~C~1{D=ORB4}iN<XPKyHE|B2ZD@!D@5{Y-nwu;Ro6-n;G2tL&;=fa-%RTdTkf;h
zWR9N6@MM+%S|_fd9`7JV%tRWA@kKzT;fOvBH~E@lA6ZZff_(|B4F^TZ0t!}~>l=7l
z((0&;cA`45fU77whdMtduyH_hoqs`u`4gXuc*JynjUz?T?QkCs{<Y`E6rWbU_-IS#
zgZyq8YglO&;Nwfyd-N#xTj-I|6FyMA{QQ0MLF&#a7yYC&+~AkZ`kw+Sut!*JAe;?k
zth6Ag6ot0f;R!(H_1@e5QRrwGNVHQ5dpiz{)uT#WICMF6<i-N5UMq~TCN&ece+4BY
zO-T_!X%`1@(wzKUMSWlk&)><;Ta^FK+RN;5Wy(9TNb0lwO7BRC>41B_$j1gIOh6rM
z+9FW*(5by)Q6$sMPy^fp+u0~@fJbG|d1vX7>royC!z?{}u(&0%c)tIr1EHfXsiufd
zEa=yWiFsddP@-3ZxtD3j<Fein?#<BmS%LfFN)Q)$^6gQu*`T$dhRA!eQg-(6@F1r@
zb%_S-Ju<F54=(Ei>a{fQgG&_nbKb4&Ud7|!7eo0O`jA(HSMaoo+EmEU0JZz5yJ+w~
z&hP%jYrNS7Z#Sf$CTP#mEp9Ctcj&En0Mmzh4dO|7wgoG|OkmJI2y4zR);kloX|&H8
zbHJVw2)#9RRTr6o>yj@X5EUMs<axG_$!(D%lVV+AvsWcTv6Zi?J~@(CXa~xPDA-yZ
z;0wOo;xMJj+bR!_t}=l77EWfIV*;Ldzx_BJaMCdIR(zbSS1PXZ!JeVr_^n{65n#_!
z0;zd0?hv3Mb&N&_ZYCwMzQFH1T##nDY1KuBYhcn7y1D#pQ)2VV5_VSQ+#zd&#s+#i
z2L!wjZbt{W$le^SjCV>(VD=Gk#68~!%aEazf)r9Eu%q*Q2&tpSCP@A6+mOe`vV6}9
zC4mc-s<v1e7j}s0eyR3-BIBH`!e*DPt#?)gLr!gn{bEtD$^fe`Ig7We4&DW!4-iqn
zLe(`CO4uwx3_eLqO4c$0jb?~AHBv+%Mr!P4!nKkx-^J&pA*#LGm#d&l>&$b0E9|j3
zL*jF~sMe+j{0}_tR~5~JAzvuurL8)Rw(g#4r`F%@t0<Uy%0Yzm*h(60-e!`4#S4=7
zqwGtEOF!s{L|pcJ@5S>nzDsFp`kY#>lC<b8`7dENZjM*xyGhx!gO7tD9<2l$1x~vV
zU`b|7oarN&+X@S~^7IWliRSE)tLnWxG98L#EYM2TVu4A^DlM?3Y56!rm~chsw4wgP
zl|>6&-<w-VjM?5#4ejAiG03p_y+LQ?oj&1|I%-p|*|@#FnyAoL7=7q3lHZF%ND-T9
z??nX(<9%H;UaW8-04+^cW6o3{x>(XsPW>8WuC^1Wf?bW3p!Av4B9MeCTFXT@wYyn-
zniXMIP+SWol~E;yzM7hA_zX=o7s{IMC{zeQra;z`0s`~K;{cylp_H<>4IUWZ30tDT
zghDqkjmagIk<k?xNnF335qLaPMhEt}5v9!v<b%EO*oCHq{zh~t_>?_0=7}T#+@pVD
zk$5ze9k`%~X8K~@yYzH)p?iG%;QqA-m+i;$`b0<d>K(VszvPLX{=Vm(vHhdE5H~Xi
z?~YN5hM*4lh6BM=l&h$iTejo)PmI$s?ICX`5`L&Xik42>U5sI)i-p*S1#)X@OMSK`
z+s}PvpM{mQ=OnDio<Wf5La4x1pS)l7#*x(lODGlOV6mcOLP3aQNIu=W^Ahun(@UT@
zx7g}}i@*L+LcT-n{p6Be$7Z{v83b^H68V1oRs-R~DiOge16*#+$rLpv6{fUrl;oCA
z%kOFY)+G^s|I_Te8B4nDdfpD%`Fr3=J-Je~B*vff`)bx<#**cA1PZX^30*x#eoFBt
zlJskgaLPh$`B$;>)jKhkwsL}+4E8IdrBara8jMGkXVNmVHnW4?R(ke=nuL)LX4_Sa
zs)BF1B_mfU3m2JG^M|lWYkB#EJ~OJ`!iFkv4;Ka7Gplmi9Eof8$$svyHno(e0*e9(
zQKWJ!8ofu+0JIs}ek95$+stUZb<{R$0G*p~EceJ!s#ct7F0FKYt79yyyF(%|BUM;!
z7N6+mrZ6Tsc^F3)7o!lc9;V}~9ZgNolm8a@F%Ak2&ZCxn?aquu>X;U`($;*jh2ox}
zZ$Ra^@@J+Y=cXNr7{xG007!$+xk`^01)XC$%u$RO0NJh3IZveckOF&vf16le{qog1
zCrGh$?!x!#`}Sk>`h8GhhYyG$kGVj@ZAHudk!#4>$0by+O^$$D>5Jr~?d(3r3V@??
z{5Ov-7W|LuyGemZIXgv(LB{lV`J=Utf{_EUFZ;%`nrWfWG#5)$P<G`#4PFd@$N&@e
zoF0!T>ndkHo)Gc>_P{8$?J%w4vw&{2a#y&+?>iU%X%^mZBF1H~2X*)bP67iAgax?e
zTAnEcO%_~vbc9ie<sPUK?_*h=7H(O+6(2GQI$?H2zdMLBUWG@+edFZ^56gc%-90hO
zYXkEo(4x4;Bu7U~H`=E)jlb2J<@;ZjR3S2@Df-(Ie1i@4J(W7?dhm%tzqj{k^V!cG
z?D%-HiF~s@u(}E+<xU7^Z14V}(sE=b8MQC!aE11Pc=k3_n=ImQ0~-K^e`XvpJJ38|
zkMd^7m;4yJ{dEFR=Z3tvz6eS`jVK$7@JBR)XIQw@xPJc|7m;aTG9B6(p#@KJL?`OH
z3IaB+fSvf>^~z$)M;42_dHq^fUc7;KKkfTi@0>E#vxZd5Qy+ivJedV=P2=+}uD5K7
z8bD+-8EIYyLIy>;9yEq*PNwShSDS-4R$5$89w%<lgFkiAOHymTbDdSh??W(~U23<d
z28?=aoxTmUfA4#|mwt%`UrcrU<+rE$SXCBpO)<s=y1U&j+TM?yEwD+~D-S#LUu<sr
zyKIq#;2^%81{g*jt`lqF<PHM2`gW)21xFfQm83sxdkgP+M(et#Ec$9%)#*(fU#eHb
zbv95N_*t(!F12aIS|IRZI{L00_zNG8{){YPliuM2wjc!*-PcX04^oZ`I35ot)Qin-
zwr#%l@qh;&FcW(d^k1>j?#EEZ0Mss5Wsc&7hp8i9?v}Je!X|^R-O<qRBhts?P~+X$
z?$)I5v3nu;^vhNK9K^GLI^4kcV3l4ZAiDC<FQ1muHn?O=uD*9HFeQ+iI<^#h8V;nZ
z%OfQC0RK42p5ba%g1-Qfq6Jqjr}xJQg)eS*X-ijyDzidGljr(LQo|J~vfP>)#AtLg
zlsJai1xAs9!cS4)*$+r$41)m#ao;wYOrO_6?j?m?O^1|ef|JotI>OCXgb_DdrG~T%
zwwIpJvkQ2dw`GnN8!+V;FdjG7mRuF-GU`Tb^jZriL&KGC4_P`Bwp(vyWta;rhnh7_
zJNc(caEVFgSDKyvPNfi|aG`Ui@q|1{0D~UEyR)=kS&9xG2XFgv)`NEaf^Q#z-OEK!
zApEr!9*6W+tQ?F;efi%1qv<OHqUxfqeGripL|Tw;1`viW>F(}Edgu<NC59fP8>9w7
zI+ezuyOEOa9Ln$VzVG*wKg_xJ+_TT#Yp=al!+?#(PKH96#umc#?p5cxZ1Bk7<aYQR
zgyd{o_MH`w*cD9<?i<X2BEPLB&euC}&wF4R5zk)U#Bc<MdI%0$Qr=PR!bjHKiTix^
zBE^6lL{^WFt0%khcwLr*LaLsi<8%{uhk29v!isc{I2#@b%~}^4y^nI==1BSuVnfIz
z(E*Nw12vNYdzO@_z`%b;@!7i^KoEtj)!S*Cb=3zm<P#E!|D^h_z?=Lx@p`$H?$Tpt
z$1dpPKBmoYhd(q>WM~A$DJme{KK`fkA2N;9SV&1Utq<%0&EW?L2USbT(aCqYk`pP=
zdnk9G2hP00IRmOIDe7EmRG<Q@5R6&+qZDmNw#ijSc<#btr|AF&1{J8#0ij``s{^w;
zSR5c=a{SV$O_*U%ZY%W&xBGcuz)Aic@U$Fi6|;5%D*Z&xqi`oja^uka{Uz7MS3t8m
zserRnZL_-L79=zK>U>fRsqQwfwQU%mBaE2sd<g7gEV)S?eQ0BP(*$!elB#`Bn?k{l
z(1XcCL=k3?j^u*Qbi4>^6-2Q{nY*21bRpwtAv5OlhZlew#kk{pQ31ptH!*4E*OGUh
zG1XT}9DgCYCX3p`-_n|T!V(X(KGCsWTx}wSa&I}?=Lyb>Yv&%(22JtMfJr5W)Spng
zGK;4#Qu%$z=Z!jk-@n2iM@%=@Q!#QDgFmhP`VaUGg9_K9bwcPnu_t|;1|_fKrQfB&
z>)mYuC+N`aj*ZqzJ2KtA(wotLtCZYa!oVzPo7VwB8XRbAylZwekOBc!li0)h8}(b?
z@m7!hlFO&qK`s!KVOctIwy^f*Uj4@U6@{2IM3faxM9j*<4@TRs>gwy56d$yc-y0Rv
z=tm~4tqt%NOz#&OeGhjqfX<ftxwMIZM@ncU6i_BEIu|%<b>Qf{pYNY<@T5IIFXjVN
zDJJ#64>NDZy05u;-w&p{6Z`J|d7VIa)p<{bG-}{Rn!d~Zv-5>}XqXt#%pa~EU(DPd
zIMoF3hLNn!0n;Gl+bmJ<&m9u4q}73oiS6U4DMNZKa)^<V-aHc(9<%QY6y6D=|7L<M
zZ9mBMZMvsJ?*}ub@lZ)3Mmm;-fVv5n)0FMK==<Iucer@?XNRRZ^w}z}Z{Foly8OMT
z2WsocjpqAq(;NN2G4$*?ol%AR0A9j+-}>)<6&UdcX=-u@Y^QHC!&sPR%k*)&fIJQ$
zXPBGkM*$SVPLJ?^XQuy1lr_^$nOskHzN99uzis#SjDrLnlLGE{G#GK5E#BbYTbR}4
zf-=n-gj=MSXseGaxB|gzTrK7<k6rYyC`6cxqF{LXu2*+=em6g#U!R0-oAkty`ACVB
zA`V-<zgutk0p^;W)jvPJyCVUbB(&8O#Tr$oFM*c(6V|h`g3_^_|Ba<|G;14ZjRP~2
zo#!{I>=BjlMD<U2ntVIQgPvUI7>jLog)-5V9(#JFAOG^Z-Lnnb#C+~RDJh$@ts}|I
zT020p4vi2BJr1+>1APS@!CANFuUFdg=HA1mRKf(Zv)E@R&%HV4k_+b@Cv0V|0wL?n
zJUH1#f}V;^K|QFPeW2$EuKAik?$%MG&EGeujH<aCKNVk6pAf$!RxT`U{CVr?Fjr$u
z8y|QOD(o{V3e6RkEPTf!Cr3j#Jrm+?q$@Q@PCV-_6sk&siLxb~n`rGT57H)yC<sD$
zx@r^7dSawa8<dqx)Mx>SOJD>toTiDLi6z2mVljCe2tD1UqNmgiP6nzZXa&4uuko>S
zwlxQ=eJ&DTGHcu451IzXg<B+c_p6>xV7(-IIm?OKou@YNo(n9;V(#70`Z=B*<X6=K
zjoEKO&3E~I^ZU)}f3viEj?W}N4v#%+;OT)nWj<Y7S-8P}g4ia_EbP%%&jG&4sHZDA
zF`vSZ=8pIcAAm~3Hi+6mJpC`~RYyn8yLbK<=EAcZF{a3;VTA_{%FW2tVA0#dopzWs
zgu4HB{Pk;$h3_x`S32)fe94?z(dM;@%5f<6fer-&HhAmVz0~3V_U`Ivb7zn{i$4(R
z*FISGgIK`zfB>99hjx2o`tKAl^$|gt1*9v<M~(4G-^}>FlIs5}%~N#fzI(Sm=W4u0
z^SS3lO)UQ36ywSBT;Q9GoU+Hs3E0!`xQshyPd}L|Qif2EItewN{JLK4zc>&E%!u=i
z%D4o0x+x#7JD=%ysnG8pGUK6&dq64Lz70{MOOOMwh7rna@wn~8>MEjC>{PttVd_V$
z>X6H3kKL<IFVv7v9uV9TJCD7$uEy$E#3rn@%qxt7Kk0MsSAGa1hfC8UTte``sgJ*c
zWFqdEb@zsbhR^v_174C7D}^cvhC5{fdVI%G-ylM6o4y5WHmf-lo9_DMmuOT9cu8MS
zg&LhKtePk}?BU2E%Xke4FVa14i@)uD@3o1~RWadpoKw2va^1U0&K`;1t}Zl)pJu6{
zSI^f<g~@jrRt`9^<CYis&i2-ljncE$&Ta^RjZtEuwhAyx1BQrev|a}dBL*}Ly}8nr
zq;NdfFrmxNNd^ixY18-A`QI=d(ENPOR@skM>H(Zcf35YAVZby>?Tg&P3~1x_HGpL{
zq5^|`-#a6N&zeomzI6hEjH+&%J<KLP$b_*Q$u3+Jw#h&FcgO3W{jX0S?~bglN1S}d
zr67#JAfLo67~9xZzbrb$N&kZ!&Ud9BnmZg>C0cBT1j63larn^~2u@EALnYA$Ck*{$
z`0FuGkr^oV>Du+`C~l5_;^`o%0aTL9{5(B3ASL(&ORO92lu44C_4;*GSh%wx-5a77
zIAH!qLP5HI{7|L(<6}P&AR40G@wiOsa?q2ml9sdY3#4f0V}ahaUOrLzzdEGl6X8nH
zYzRHriSA_}b+C9Q8%oe0Acq4E@av}--|Fpby<dXk)4_3XK~Fk7CO1cvvz@4<_cf8J
zGT&jYf&XPhexcn$l6l*><5OKKdOhFY?0(Fiv-l6wH2BPJ#H6Whlb;s~by;0*<QC+L
ztz-hA8n4I0e^;YOAQ^2L^A0#<O6z9;<|;?8=f4Mmu9s>uBaasQN2)TB2ctn``bke|
z7p>s0ZdCaGd;YN)a}t2{Vs1!>&)Z<<MHWgIX6nXeUN}$mC5%uYSjs((t#Dru0N3X2
z%@@(4X*T%Ty$_eAO;vM%bT9d1@CBFY-PPpK&`6>5YvEZy1=fM}?&`qmJmRvF^xYr#
z;A2-{{yq4F(bU4r`M-WJ3E9CGT<FTB-%02ux$_o)uX6CNLrcCG=qS@Ceox$#9!whE
zpLOdOLs}~>|M|k0YvX7^#*^K19uTy4+7Gy>Rf{0O+&{2<I-(3roPtslIB_VZ8^V&&
z%nbjQk6H+(ZYEO(es#*6IqyPLpH4$W!V{GMD?H!;tV2bF)Ctq81MlvPTtzB(=JAqf
zfbXIv$OFfa5B|})Lk<{+H#c0W`N+606TykyuGzn!IdF<AcE?YN{P_^@Z~ozah4P>E
zw(sj}r=MdVIQ)Tp?g4j25~2#2QLBSo$>G~oE9iJ`nurcI*{+70KX*r)Z&e?n5F45R
z$LL~67+AJ39Yj6EUfV67#mXJvk+);6Vd-MDd9^cQs}qE;NaXa3o>48zM3Uxa?Ygo0
zxxa4J>S9QfH;3=32RMAdgcP?5_JJgy1)5I11xEM*Fh&QFKW^)}n;D*%@|k`>&T4h*
zr3AdtsBFSsP_9;rC6y{$36OhD*8Cw6M1wBR;242+R}dAmgO`<_EeoTgBjws90I*6%
zV{JBVCTY>Sj1n$k{-3=F-J9vv8)1%izpuz}eD9T@x1FaI|F{cjB?rm@y@DtGi)@-S
z6~N9$1!0}9RiII^(M)res9YLO9tvN-qXzW@tJ0{NwyVz?p`wVOE@z0Ugxk~MGx&Kd
zLH7%oF*8cW+>99*Y@`Sr2*rlIx@82jd$@+92FfTX*k|3#boSU%6mEi|%74?n;S~uN
zKF5;&Jx$iJPdkVYSdOGP<$JsaY~1WRY!LbC5Vf*d7YfLr>rP9AHK}bm0L@$OkeL)6
z&N$ZF@)|ZJj=A1Fl-L1Ytr&}amqx#>sWGN@cW@*Lw5c;yJdY@(6W`;6uH=wM<ZlSR
zOEm}$*T5LP90R9Xaf!1h%V-k<0isx=Pz(O&?!OZ21o>h)21hOJzH^j}VWLZ$P=)%4
z;}?oh1lUul`@<v{fFjJ9jy5dH=q`3>lqC^d!2brof*-qiyDak_(Mom4?&nxEH>9Xm
zT+HTQ7+Ki}6al87@a%C`rXvHuSFs2VP~V3Q(*fRs6}-Zz;y(}WQMNP)kz{ZTbFHRa
z1<bMpnIH1?8pLrrPOn`jKS=mU`NQMQ_cm+o91%n)bFjgsC6vw!)qmbk$uAI`A*wm1
zx8b>K+rfX|%gn;_=j}b^&^~Q9YdI)K7vty566RxykM~?E%@H+Nb8`#HHfu;GT1!Yo
zpxw$bR6+fQ(qnY>n6w8!0@bx=H;5a0+cDaCd)+x|8gSVft2~^?vX``TG#!<De5VH+
z{P}@nUuHJXZjWd1+)aZCo(uTd1Ay|Gd+yD%^e}lKckkMQgxrTG#^u`WU|$k5Sxrh<
zUJ^-@{}=0eUS+R$039ls9Eb*_2r6Jm)X#F(FT_7l4w4d_>7(8Gx1iPKY5GqsCL40O
z)bk+e<O@m@tZmIs-2oAx*nzbC{a9=qPC>4^gX?a3+WhhXD{i|6=an&ifyV1!UovP2
zw9Re5Q`S4Idm2;Do}UDYJHBa<2XJ+Mns2OVyLlj&{S9A<2<b1V&Y>ToWFRqZiPa+V
zsEMcwc)LUjG{z<N7ng)2@AeGOR%{UF-#gP1*FKMU^<RcLDqJ9YRTRHib>Zg>+yB!J
z>I@{$iPHLwFM>3Zt#GWrzU#OVndFqiVbE)}ap}Da({)@;a#(h(KWTd=t*zTUvwnLM
z^eKOz?(U6Z{P-y#yF!I0Xt%3Xu%R9>eNKi-aW-K%07AB3wQt=0O7frf3?!c|PB8Sv
zZA1_QNC1icRci+ae(v((BG#8HPrK5c`wvn!Gp}&-E8A<nGzDhsw6Yhl3K_YvOBomw
z-0)?B;7Ura0JcmvOcaC%FcvAB{;{7S9krr=B^^(DW}8eJxQ@WYt^tm4i<i&f$3-|%
zG#f3V7LT~|@^?2nU3h@$=K$55-R2hotFlR(6~C+MvbB^DMUB-z$6Wqd*n6gGbV}1S
zr(pZ#$a1AyA#Ur1-Hx5z>@or2epVJz-ydoO`nHerGa%(hplI7*Fm8?>gxbE~cqw}1
ziC##&t8bSPdwd7hNeoBtPUzzj`gZiorG6BYK4nC_^j%WrO+)h@q^U!;eVhtCuJ@v%
z?&8j9*4nqdgY7dhYLhdG^hTSC@*K}->h>2hky+aG@9%Nev?iLw_gOJcLhwcjr3_}Z
z>40e>oyQI~MTuBnq?devZ1D=d)d$$P7NIubIKynK$`l_>f?E;oU*zoSE@!l#$>HCV
z0Lb*<hW)HTQVTqO8$S0@9~Nc|V;f1QM0Lr|iJ`(yOhnZ`ZGXF<st*G)Mj3Y=yX5KP
zY-yC{vj;%w$pH*lKq+ermYMW>!dw5bUSE=Nw8Wt1FR#JNS%9_(xo|*M&6nMQ;CVAE
zy@Ads{O4kRyx|02O3H1^-G<#~0t2eFmt4ZWx-w-+2wvJWqIKahY!mVOtP8(6m*zrZ
zOG-YZC=g~0>lA$^WvBK?V#~K@87xxnNGR;=jMNhRe7xKQ@gQlYEuLg<a3bG&T=f3#
z=@C`Kyk`7pQ~i1DK3RIBACz+&_tb?T$~o4Apg)v_IY~otbb~wD0D$+EazAyp9J)YC
z<9osR87f1;lX^zc(~qT$RM@9oc|Q&f01}Nsd-z5(Fi|s2w5WLXTwaRvt#TxAQaZG3
zzIDEomiN~9&KGipWYsBeg3F3#(wOTjN@Z5xQPe86&jSVXD+x~JY!4c7E<5A%xy6q)
z29Q5U(Uua6^uOgtDA_wMQh%)UYr3yI|34Q%2DU;v+<z4WtKdm|)p+QTlj}vWcxto;
z0wIp0d5a0Mzkk^kV7Wvq3mb094-(JoZan5&One8_n_1~wkz#(NVtbG8$PPAuw6d!<
zcH|Bi|FP*{LYHC@7fkdqzFx&dVM0u0f<}zVj-y_zvNVBt5R-TDC&Q(=g<JeZnm|)?
zao}J`7$|a66jD{}r2X$Fz;Q~vy?;J%%o~v@PoA_>wWPJuXLnB*mW>y4VP_v2@}BKH
z`0Gz*ZmiGM*_J1-kS$9qYZmO}`c66s^gR`V7_ajaNOE(m-MoU-3;wW#`eYJ>nGd9Z
zIdm$i`D|-%{d8uiTS~abG8tb>tA~7$S|E!<1CxQ@4oh!i>X*#hbMgqOPP$ebhOyU>
z2&Cs2M+qAjJ0!>2c7~`;^$igtQdqlmXU`wr3c|0h(Mz9wo7u}=ZCAGozv_6YzNS6t
z$^@&h_|qwq-#kUgY}nycZ)vK6P46R%VdgKk)sS}Jc{J!%{2)}HtGfspy-vjI+Uy@S
zIUo=Hw&lMc#DR{Yfsx4*+Mc-04ggCd#GSWJ07xuer6QWPl_PZRv81sO_k7y#`6w2X
z?!Mf_!G6m>9mYQ)l>>53=3~u#5F6p^1-p*BrT?JWf-&33fh4y3O2YJ<4q>E(jz@2!
zQOLld%(Rw=v847iQ!j_C=;}n$&Z>RAzmvwC8%1q8`1)XZxZC?sN|zq4G~7`v`8`ak
zt9FND(-}Dhd1{bs(v6wrB^(wx8A27?SDOBYja`A17l?vL#%#f>8cyG+&`)rT=NQ9*
z)WtdvC`FI}`{BL|CC(;hMdCB)t*kmB;8%kop&rZ>miGYtyBY^1Rsc|cX|rGcI@asW
zCpH9~6PDzx9Ao&}9g_78KYTXP0}xD?2@A)^hzYaCkD%s0FCG9aZA2*(8>rBkHo1zD
zd4XaZ((p}dzs~5oC6PoLRs$N(UUmzULQDq<#kTxdoPEgt^6kqx2(=SbUN2MHabb{P
zt=_+9!dU#z>$uUHj7EV?QE8YcodZ^F(0?QI=T5wzkC(2;GtkRvaVQws*!eCM_XZp1
zqQ>D4_G<hjFjwZsmu)1VR^3H(oeN0Yr?ButXaboK1$0G?3D#D5$0ZaTG1G#ohhjr9
z)fC$Rga#xz<>g*s&Gb@&CKGh#leRCiu|KmZ(qu5mhl$J0S?@Dd)m`aj;J=d0fOg;3
zI{@~ltp1JA0v7yB8P@XMK!+pH=sEDP7uTE4^8N8&pY=6uB`7hFq*!G@cTnJ~X3B<L
zyh1ow5KmOKIQwrN%CzVxZs`P+cVnT7E8F~lL!qSBj|pfUo$^}**m>@pD_LR8ZHfKY
zl!KB-l2lg%kf&*N$!HR0K<`?@KX-G|rG5{82_Y#c+uK*^eIYKV%C0P!`t$lZKxG&V
z^Hk=VrT!GH)K!aK_@&pgTK72vwc>=~Ua)`RwK$9UD(8P%R;2og)&9Z|#t^EW2JDDi
z%tX_g5Ib9l9SdNb%O>gJg{YPLTn)6>&im?hePyKHs8@{>#1vA|*%@MA5xN-TPL4r#
z?oA+TGr9wb3JZM8B=c?}?9fq{KRb3g3;)R6-Lbkt4QF-Oz}=h#N1}-%cHTO?w#2-R
zIQ|&bq+hUJ>%Y`bns0DT5rQoC!G{a!lv9xwq#WogNwtx@^L3!)0AA%1gglcB+w(WH
zeXVF5_*k!6Ja357G4M3tQ|VdRh2xGjHhJ-%I|5|6*=1rgDVz!zt48S1C7HC#hlYsl
zz=o*e0|RQ5w4s5ggRKnj@s;f&RZZ6hw@uf2b>s7-u!adC2e*n%3&h5U_14uKtCeLe
zBF*Gtmo<?j6nn+<wrcPh-FWg2V3>M<tNTHOz%9M$)RJ^PolYj!+x-QDd?nF`MEdk}
zB+U;j=?oB~fl(yi(%09teZ!}p@I)vl&W1nr3`rz5Yv@ZgC(1D>IZj56E_$j}HQvNP
z#QHx=_5&S*0+4r??VCn+S?I{WR{4C?wX?kr_^hNIU?UbtP1EV?5tjS#B{C6%38qjW
z8I*e6sqW$bP@;+90V)xC|6lCu4UrI_%`p_99+e4S7g}^PGJuXbJ9vNS`|pmV5x-<R
zdI*#v^)Sy;%}3iRF+M=I=RN%OnF%3?@6SnDjPOGjKpg6n0yJN*L*XS+>|!h0UzRP1
zAwH?I-RzyK^k>21QTx6Gm;y%&^{M{Xj?#&e8Or&sb3}GQtYaXg#z098Hto^>T&5()
z6u>F(wMa+$N%|b2t>N2+H_)e64s3EWYhYmU9GS$pVo_(-0SWe3L#C=*zdPS?t#B<a
zao+5n*qD3W-nk2uNEPEhy|XHA7Z*Sa@Xc*t^uqMl)4zAa^mugNV-x|qGGhZF;ei#3
z%%;FQG`}Cr3?H|{iO&tcUO54#ptZYnWmfC3%l})9I-m#(z*_&QRq^Q_!kkLq&tP9A
zD(IcE@b-bit+)nnc@$(VY<W<{Kjk}|a=Q_Njnn4CF;zvc$woWf!qVpju#F{mX{0rp
zQo2Bo+(y3-TI4e1UUCEm%4>1r{~&+`leHtsuUBef?z|upn3C+ODls-mjpCN-ngm>B
zs7Oaal?RiU%6?_4_ZDrfO|LPMw${hrTP(5I3Q6^h4(!V|udHtse!SV!yh~5d?)GdI
z+)eXFvWx7pR(J0m8y$vtg3P2HPa6QJYarD7eS$LZDcTB-7`{8*@4!8qCwMM`%&c`6
z0{WU3JyEY|WnwEV{w2D%xtx$Njv8C#8@=h6Fp`}-_e|(=P?r+JPaL(X1#;7OUQT4<
zx_}=9aIq`?HeRU>_aMm|z$`239r!>w7)Ho}4iDw$B?JB)39wdFbcrS|k^cNQ+X5~Z
zY#%w|)XQeZcz7mo56?~vLHJCdKx51_otNwr!n@_*F;^qUMf}U4MLw6sl6t)enKC27
z#Lh-)jYXJ$4Jfoj0vhJjw|R_)C;QCue^*TDuC)(hk5&Eg?}Rz%WWt>663vZnf!w55
z&0oD{iv|3LWl{Ieh~#0i7JH_ebn{4LalSDy#iC59#wdn=Yf<vIgoNW{5nrx(9v|iG
zXCSNipH=rXA=M!*!l&KOh5i4aCu?%Y)UwZhUFmk1LAHx(%&ipI3*xS}ruln8sIBdX
z*i)qTkWSD(y9^14sA90{JK7_ZPV*k-Kfv<?s{{^L*}QKSOp-klU_I%$R6Db4JMkX?
z2Ep5=f<1E=Y^es%%Y<(0Lwv%s#bC*`cnPr5P<{G^#shc27^Iv<@_FEW&&#8N&V<iD
zKXy#v;d4OVEVO(srvY&1fsYgKkug9P`aeH)x&fGA@elkeECnb&PX+|nD8OCn$k3bd
zX!5QF!m-E~@71K+zU6j*K=>-RW8lkqTC;~Wrr1e>wZPe!u|YE<fxZN6=UyIBek-9f
z^(-Px4pG~mL?_*~C^6^zy*jdLUv{qE4&?9>6BuNun%?u_?4%g)ygCKoa`x<^1bIut
znrA*h^6-Cq^L%JH&FA!wYfgZT7)P7i*V93LBR)X1eB2fc@Wa=BnT!~bY%q#?P#W^Z
zufM=&<cK|eNQ-wlnm|>l08)91L?7{UxO7X=R^JBO^j)$}hltVAJDE7@2=nhY-_wjU
zXMcF#p~>9V#ww3YI5vO!{v$vrzl>$~32RpD;@xQJ<oncw_J2F-6Zzhh?Yt*>^tAfl
z2IbjLk=FSZS5Ok$d*1imzq(8LgYB{aWP(l}XtO@WhJPJ_*p>R-4*e=?$e?~uR0Y_#
zj?bhjbtB`)ziF}$U3kl5dfa29rD7gpfk=XS`#6o_s|J3*N;G{Kpdbib-T>9)boc`8
zwd}LtA;79~>FC|lfe^Ft0a~A@K(>S<dX<0I<bKVIc8mEe7EanT2F`#=9tMPRq63hd
zWhuvZHK*^s`!X841m!f|!_N_geoh)qL)DF$_taHvuN@h6TWNxp-IXi0YJ;qz{I8rX
zR~ys~pxsLWuSd`SP-H~VVE`dS1nJ0jLH_2aVcN}$UtHn$JO9N#SUhddMtjUGH2ZIJ
z+AH-6KA>HaQs4bhl*DU}9s#d$eIQfGYX4bWBX6MmQXh62kUKbNhhnyx-KuUyA?Ehl
zVADQE`JK7Y^dkF%AwGQyTm=&YqquigWR($HGO1zsx%Yv^{;fG0rat=fj4C4NhV<RZ
z71z%MJpCj&dPmG=>~yOFRunQ?hEI*?3q94wQH#Fi&s%gL?_bA01)*!29N#snepS<-
z4a#eX3MRSQFoKYR0lf$)+-|_QNI^R+xvy&pB~Ipzwzd!ssbb+Xght~;y{SzvLZj5K
z2N%T=0UT)S?u`GAmfHcbgAyGGr--T4p497Ale1Ybq}&{X2oihO3Pn3^yYcI@6^R{&
zz?jFc8XtR!!_2KR*iGDx#|cZy6pX0eK5g0Y>#SDruenXO@PLT)W}3io;b@vr)M<lI
z;E!TA!r4n$0xR?05Gal1Ye~5Ij<L!5;ZAPP@7V8hFC$r-4CXHTCp>Bj1^{|UM1A*C
zr}s<$25fF2T`M;mC>8eV6+^u9fX3n$t)gf$bkJ1k8APN`*WbcZ#;{3VcyXLX4MrD2
zwUZ#ljE)}i%vcj61W!M4<Gb(Ed2fqxA&*q3mqEA!yk%xBX>*@EV)>-6S?SxUw2aNd
zyx|*7F$E)RHg3<w@TUDVh%ICG9*8mnS|tK!slt~jUz`ZzN^6slA8dDDAK5IM;dX2T
z4cM0CS3#u}Ba_UTIYtqVg7i^tvA`?p(!wkHE{W33*>j3=PxaHbI<~9#<I?$aqv{vt
zQTY{25o3zcZ{_|c*k#L_ssgI7gPTLb)$c@s5%A(_zDQKSvD)Qoodl~FbE1~X(D0uM
zU)-zrDRgC-2+*s0IS<5tCUFEZ$^YdXKgXw)d=4OIDZ{i6R+_vW+Y|Nzb>w`vB0h|Q
zqEf@TN`lM-rVObcW-Wf>1D|#FqdZmkp#}8&<PK#7HBNswE{cb?j4q*sL>Cnu_VW;`
zq7@GpVM+`P<2PmI+HsK3r#R`;k8Wm4Id2pZW2vb$GNf6>^PTMt#<!WbQ~Syv2C~^G
z?&tv#=5!@ENuw_4*s#WRt2IFELlXV1pBwh|B>)6`Rd#qeNRRzj5g_~$nUl!eosFPk
zOGs!*Pu*V<)fOfHZ%7`YqLMG5WkDCG=@}!ik}uG57<YTlCV5ziZ4E?OD>`Z68|eO;
z@4L&ASUX$2zZTtc<o|mB8i9`Sm}4^mD^GxacbznGMVM68N}fT5ci*3_9$a7$2fLff
zbRbbq?^|swC2E1S<evSNG0_87t58_0{X<ujnLW_u2Zn&|Y~Hm6V%aU4`8j`9OfFVQ
zj-+e<VW%q%1E{4B;pFokZt`TpGQcONUzaHW=zk=kprZtsN+AjKX`CETsfV;F7!+`n
zv@Mt%^2@lysi+6>Ggv&);$<fD4IJ|9SYUQ$=`u#NBu|F~@?OO>XFXk4#qHqYg#k1)
zRc>rDv$RRgfUCh2M;tE!VLe~#$z98aW%`Fc1yc54s0%1DlDpP{q67ope4+Dig#7un
z*l4-WRqvM_9$pZ2;~Dbbv7_3DoqPISR;$4xeAnk2i@tD6#so@8n0eH3%xxzXUT}2A
z&ji^1q+1}--m7S~MAe;(5@lhI9lH1jDk^LVqfth>9xXzk0!||IP>$0zdAf~H(bS#z
z+x*s1fXl|!*8<k85w1`LrBQ4G+6@=jrK&mBHhw_MRb9(ko~Q(bEFQq`c8JvPG*4OS
z$YCe!Jj&>>cJF5K<H$LF6P8d1@`5b>gyM8xY)=em0Cey=gI76}ZI;k?h-*M)AF~-O
z(u|F<7#;c=NU~iEUC5tgARh9PC2aXcHH#Tc>XZ|y?Y>z#QW$IYJbUhw6Tk197#m9k
zgXJfGA7)x$>fK#?`d*v<QyPLbaq%E}zmP(+DYhpzvEyv8>I=K@3YajV8(adSgPWV+
zEsb=WLivhm6e%gSNicBldoT>23~(X=Is?(hRgy}lw!E1Z#k=U8e98zbZsv$POh>)R
z{@b;n+jC}=RZF<uuk#0{t-BHExf9aPSa+}_>4MOW&XGF@@&r42ipV9t%G>Z$r^D;w
z{E$j-4;{6t8I-C~nc>}0d`qWHs1JJ&7MKWrDRxpeYX|^fwQS~OezM=RG^h16|K|$U
zNgz=-G<K-_nqGZ!c8b;Jbw-{%`2#S!V?!8+*^E0YPu&fI$&~+YZ>MLb7iz$t6$~*Z
zDveDh7dCd{N~?$6E0TBxBUpN>WA0x_?EV6K0PXSfTb`wwK#@!tKYcwW&B`ekBi#ea
z<5z1*bYnbmMhw!X)G<!!r#OT_%M=oU-U64Mbj3iS)ORi=lpyE(^IIa6_1x16W9E{M
zWLG{<A&Dv$A5Z#)@o1p|V7|(iU~T>@S)P9VCHN^PY*8!c5eNzjA&$>kn`%Y?J8dk1
z!}?{Og+K%S=10$b;V|hUPN3pSCnj?L@ro1swEdF@%P%KGzLS%VLpo5lLX}Lh&hh<9
zt87MZJR@7O1g|o6+Ar|MjZHL=zBQucY{yubc4n{OB+|JE+xm)bwICdurEAv4lDYI}
zlk@nTq-ZAo$S$Y>3KV{#IUF=G3g{X6iFHonV0<k1KHx$p>KRm=Bo__*f~8xM4uXA~
z$pmL8kDIfC)a^`0f?$qVi*(hR{>0jLvT?2EcyOvj)=r%!DPMp)A9(>pHE#sd;w-L3
zreEpEDBylEE4$|bP{9&Asn8Rw)3v(x2HHqkh)M$iCfmm0hr)RSE!Q+Uuyn!7Svm_}
zdR5&CEg!XHxWw-w4kz=s3R+?`8Bzvt65+NeC6?$|yB#{vb9oIlo)_Bc>yiAx>*NEK
z5S1$pvAI~=!_F<ajYx8f_27Se-<8wI(sQXFJ6&I}gd2w`@7227Px6&jB=Z^RtP!`H
z?pXw`tzS`Lp9oWS<9XTbNBWZ<fxg@1ePA&E!w*tOC4*ldO(AOzzJayrQ@`&H7R&dN
z1p{aAbR=)y4fS<w!Dop@O`CxHU(LIi=cx?HlwPwL8cRF9me_peZ?z;D3om-7WkPij
z^r-4{l}ukFpiVm^5i6u-7F<tJj`GfR(zR?VlK{a3&C2{Uwi^TVbJqBQ&_jz*+^}6^
zv0HWM@JhYrxZ9lQlzu$M2S~CQnx)l@qch{?SC0CM6Kc#b)}gd=^`67*H*Os)YY87F
zrGCg#yIn^;b@h*_0>l80K~oNH*th6tIz<34s^4|9Dev3;!c~i1*p9(_Q7o6qQp+ZN
zC0t;l2C(Kv3pFY<tG)<|FLKG#JA$>v)up63d5@p~dJxZAeyO9i>J5FfUHzwN1Yd;+
zp0U#Y4vAIWd?+Jtj)%I_(l;>n?0B^?TiL;n`XoKW82D{<)U##Nu*Pki$+6u*pt_jU
zD|x+Y^z;Uu@x{f^ZR^SJf5z+7Vk*y;&YXQ^<|8%y#%=1Hs7!*r?G%B<+ioXGK=RVV
z9{aiJR8E~yq|M~7Q(<gl#^gF+d0ITMq%XkAghKra2az!w05bxphX6H$g#5>xw~qmn
zm;A1-(U#kA7dyv{aJN($1YyyhU&<a%V%OU!e0*k+oBwhs6NZcC8eDO_9p4snWOjK1
z#*4j|!ostR=%KdxBdrQ3k`e^^40eV<0uH2_9>y_{2>?O!;m89~(6)4irNovGOl1JE
zS8$R(Qe(1s_jV^*Np&HQkzT5J5&+1*3j-S<$PdtSUWAEL$>p+9KQDoslc2$@do;M7
zG6%$I;d5Ca-NFDck%8!*n@#L#gEx|zqzA0uuN#Kj{&fiLux{!E%v=VrD-FGWFEW~%
z{-W<=w9;@YfF=QalL997a@_*u(*-iGm>x*t_i(4{IA@*4q6kPc$MO1IchrHrhT)3h
zl=*&!f~qK@FEMBahhPU$D$l4yAOY~2hhdT@>@7ZQj6qI;ok~yrRvJLg@Gr{K4w*>*
z*a867XtuU+KqB*&eR#Hs-`KKcsRvhbqNLAkrhv~W0nEduEIvy>kgl?AfN-@1_Xay_
zQ7z9Da)EKQQwznlp%~^stXttEpWXVCI2o`DC=;BV{;+NNy|5NUq@WGZDf`QQq`4TS
zwO%=H90&ciyx){v=?5l}K(mD!5Ow%WdKSp-VhOdB9jeKui_wM0Q-0hk*sEW&TRz^Y
z{lctky0L!Hngo?fey&8mi)&}FRG)9EAFk}MGfZbY^Hyn?&`!X4bN=pV7Fi!}3bSI<
z1hjM221?}V4{l_hx-Hj&f)*1&&%y?xmGDsUB#L)k%}e@r2U&_+LgBx$w?H!fZ!SJ6
zIT{-q?a-hV0bv*=*Pvbg$9&iM^KtP?2fdQdq^~9Pp_)BUyZONH`j_V4j_JMst>4*F
z@U;^_yM2ejr0Z}Hyv4K{{74ARZu>-ev-!hL^p2Zyo9}U+!|nbI3?NK@H<9m4J`yJo
zQqQq@CjOY_fps@V5kyo3zQFV9lQ7ntZ}R#YD8yH5?L--YvN7qdRe^KQggDEgB?2UU
z_JE6ZlZ!bP5Gc)&TJoo`d|{<8wYRYQN5|@YsT?M=rsbkpM%)8)iGniw$jnzZo+e>K
zM!Rz0xgySaX<xk6e3Kuv`chj*j-D+ECXI*Ilp|X>Z;@{#T{a{CRj>pg!;qDi_r=jZ
zr4H0to!}AO+yEHTBK_sj{P5pPhk>Fucp=U^j(U7UNX3mT0q+;Hq2U(koxW!Rf5}95
z1H@C{{LWUs^F+qZ)fUC6n@aeD!^Mk>QqINYCQRWK_J<&OO4(J4FzO&GEwYGP|M_-n
z3jc;mYCBBkwDk0OxoE|y8xYs@wM?O`_wU98L_%Ga58Knc4y7z0XjH&72MgI~S*OO8
z=;Hi2MF^f|uynxI1(ifA+aN&fqciDjnDXfo6L|?-1B}?U4QK<Xi6Ytf#eqN-vtDfe
zp?QW5ec$#8Z|LD%2l_VeEsWkWj+m?)s&+p6FwyW{S@PyEBCjl3Pm9I=qtbK04^tm#
z>?a5vH@`t}Q4_S3tl^8+D=`Sr1XILy7DL`pG)`EE{3!@oW!dDQ2|sLcSj9z`kXs-s
z><)C)UsMgImJ~F%DC1J85U*M(T5(*v`%i;Th_+oeit<xA6CGQ!qoBNC`p?>eeLSF^
zeIL}8??4lF?DsB-V=dCmo~yxmBA1us_d@LOEUD=?Ze1r=Yxpm#8tIuCl7Wni5*$b4
z-U&h_W$Ac(v~D#T^ylRL#q(|_?Rfo{%sP8|&`7euK_-efmwJXzDOAkYjGT?J8g2qN
zJDa~TLnCQwg%NQE?SlY4{Rb9(fT>3>aM$kh4~>rG58wlS;Jzlaztf6`-zqk6JbEHy
z6qgnRS8M#r`LU_dLzyf}k{dv7yQsi?%uMy}$8Hzg78Jnt1sGKtFM2spdy!L?=KMxX
z8aB=o7X|`KuJowZfTzpfChV!l+T<kFSS^beQN$LWO-ss)LziC0Z}hc_i+9$nWy-2{
z4j5GPn?!Rs;|<l1ag>P3Pztk7g75FNK<O}i$!0GLK5JA$y9bEMh95TNG#D5{0ibZf
zML6ER9ZL6WZQ~<=^~qS`l$Ub}nQjhz;WldHdR?p}O<a9^=cBGuC<0}ZxgeVCTyvY5
z;aOpm`6r<>)-~NxxX)3}MmvZZQ8J#a`or^q>}ak9_DdofFedMr0>_omPLwBI<Txfd
z7%tDl<k_?7GF6hkSKUO!0-vT~2(~>-ba|9t3Kbr&B>qLQ=h+wG)`&ox3K09qRFm+k
zS^1Pz%aoL^byCCc4+~aIxp^E;fGLQ&I|+u8L&gHNx5QofB$+HgAvH=1voq^|t`bYq
z2v#y?G&ck+Z4x&=>NCMe$#$e?wQRPdjmUB>oIC2QgcGevm&abCXfF>=71Kcyn?TN{
zyCXGZ%tlxC=>PpEPF0W~`S79vLSnPHAnwOS6sHrTP&{;hpC$M5rMPV8aeKnwLm9l(
zldlmf6Ac5h6dg5;0Z*+vi3B<f=_EA|{U~wSalzH=@f18s&G(++u~jws9D^Rsy*(14
z$c%2Q8u{j<_a=@>ygV8(1<|s}WZppo!3dVU7onU+69nsbKs`>2z>kAT7H(0=<42U3
z>FcmD0$mj4SN)gGT$<}=Q{=q{$-1M^WY*2}oU9Uq3iq`$)MQQf{~3S`A8V)d*favB
zu4~ya+eHSV$)}I%kxLr2^!#%y%0!1H@eT=H4MDk-QCbjH_Te2D%KgYNvFb7hTb8Lk
zPXl#~*zLQY79NM~QV$EvrpDSeg&q(VbIVMb%0uEO4kQ;)vi=9w-ud_9vz+mcy&QGf
zWaiYaJn2O-PKhGuZ~3d@mTrk&bNl@8GQ?&QS^F-L01!sM&6R{yRVW!}`~gmq)?1vT
zx%$h0ACEgWw#xVK<2zNe{T%#gF~XpqXq0QrWX07FoYeI$8QG&9jF$;LUtH$@S@5h0
zb^4F+Et5u(A|&5?0^y{o`taa7lJ2JHmW)ofb{Qa?GStlNzO52C+87|Z;B*?$3@!YL
zODL7U&ZI%mYkx~909`itm+Wr*j>POGu}n<_D-VwD9$D2?y?IkP;eO=h+yXUDoDPo`
zZoTa(`$AJtsPL$6`-)oCirmY?SdV2Rq5EFf%A6GwkbaAlS4&oJ!h2tN*kH%aZ@IMV
zUJB~>Rl#Ka(UW5z7h!(>(PTT!b~dK+CMw>F|DOxsj&=w3*6I8^dZ0}nUOr<_R-v_d
zm!EPZ${TlhjODn^fII6trOEQGv9!poCNBVbJxAe(7b*D3hlVFZ**AzuGRZQN3rEtN
zZaO3X-Ll%W<y(gZ&cB0L5--&0#A2-#Scu7o-wrr@H``6>d@u&)lj60RHa#a!`*-8|
z+vKpeN7Ykim{YLB)#*l6LrUpLOPCkACIMw#M?{Kw1_j~Se~!7IIrLSM0?M%Jf||<j
zC{0WKDNPGg9U`=<_$KPROO&{o4SDL!<#df*i+SOzOx4rRb&V%GlB^71n8-HRVU5zL
z;7uMhq44x!mO-TC%eLB`<6xS}VuMwBgrA}`=qtCR{{fe7D@O)%e+n;loL!NII-XS3
zW#Hl>!EsoE8J+2gVtCuFpW+^Cn%2PN@Rw)kjz^1@27jrb$vQF}xsGJ6Y>J80((0A=
zv}3>XBi=3QO)exx><v@RUpl0dQ7n98Wp7t%G!BmIxY@<EUG94iGU1o)@3;`K_X%3?
zq;n3ua}Io~+Ie^<&Q+Xrp!FlwokAa0%%m{85qoz98Bay^`HiYxl)5kLIa=sYZ?T-9
z1E-kS(Nk78NCw}9%o29hUMDJOd#^Sd;V%9A6cHJb+!D0wAOy7_Ey?%A`s;8Ucs&y$
zjkQ&jic^B=JBbr6Z+cPG6lmI9wCt5$@!)NkhvfDnkj`hBZn2LmK@qcU*RAi~xO)3&
z(aVLS*(;&)AYy%a3DX+dF58!VhT6c6-GKS^w;DnCZf47-Y|Wm@Hv{gezUb2FZqF)G
z2m8vIsX|<_f_};-UH{__z3`Qw;T!?Q)}h?8m5?e@Yh7*yxL-6Bo8AF!!{g8_1^z2B
zi7$9k?sn>hInyZarf)|^&Z=Opom{Vlcxb!z*7+0_YL2b4*jTh@p#e9zJas>U2dp!#
zSDbI(UY4<4F|QOo_Ex6fD{6)*XeqnUqRgPowmSl6;d@ZKjI4}ynU=LsgP)%tm~*U@
zl>1{DB+nGSUs4!yx`~98t9|Xzl~OO_gjz4c{*I7MO(41JJdUu3$(UHNB}k)-_%-l~
zj(NoM_!YX!YqBFd_!aDFU@<RJqhDO6B>fYFDjSQTP@Rkd{(!X+955wGt_dzIPmZaU
z=+gY?(i)qhOIpGzy?T?1SzHH~8Mf5l)}-o1IUyAt1yvmdg}~d;7}5Dvqy2l4rKN#f
zh_x<*$0jX=Nk!oUYJMA4!tqPYkPkt4Ea;N+u(FPvBA9l~*KKi>$1nCcrjn^GGA#1u
z8&5w#QEvNStGyq|T0Z?Yy2~oft|5qH(A!luehGX?dieX9JUiHG9@a&rR+Uj%T`_Av
zcwyaKl#^4tWYjUe#)S20*>`lOX~pY$rO6VtR&Su9v$RP6x%Ds^n}ZA_-UcUyr?B)}
zmXob*T|r_^`JOUIAcWgM$ggq#4{?7jNU^z2`eQIezc;`HnT7a9`5&IoIxs`?!ki3E
zS+c?IH&;<PvHkMb>S;TSbo*{yZgj%1nh;J65_;Oe25bAg1N*!kdoPFyx1Uj}v0{n!
z0GIN71R&?S;PC8+!hKQ~mB!@tl<lp(Uk+WF5leYzX-eBEsf;ef((EH~e+`+kYECZO
z4;OMp<Pyx&>m*by2yYNqGTgjKp(<bdEvui;Wx_ktR`q>eX!*F331krcL95WxRTfZ{
zqfj-Om66RJqg#@Sp1h8B4c;l5U0fK;x6+TYG;}*Cih8L0B?{8#RBYwQs*-lUopSUc
zqo}a8tt|IjD5E9aUF?uFCAzP@Lx6EoV_sasV)mGc(~sz%p{TCBRB2EdJAc?z)*2k)
z?&h2%`&`4TC0s>b?l3K<`L>VjER+eyrt0|EE-K}$q4;s;Xrs+0#hB1Y(dIUPOdxdX
z7S9&+PW6$4mEWoOtpfTdA3?oNS1Iq6yYEMUsvl3LGAKjL@a0i!DU2;cs0yLGm!soM
zGHvM)ae321U1h*mSz}PB{Z}fQP<C0|Dgb{!+U9gB-=+M#ZzD)>*Hh^=%Z6U`MDX<`
zQN7t!-qn&d{K`OBxBZ1|TuJG;f_AEban5#W)sk0R{DfW&+oTqCuBNG~eEU{XG}1_y
zLI>~JXGXxtplU&1JfSidBUCNIPA;O1GpUVAryI9Ee`0EHJc2jYm#nHjw9t-$2h$0W
zV3}SEl7w4-`|3Vr=mJ*rnl^O<tNms^{#wPZ>gs@#Z*chwyF0;}tX8RFIW(D_Zmz83
z6TPV)Sx#y0<E?7T<4h}9r>bK9#N#?Je!z=uI9o(=RP5kG`?gc{OqM>kLE2@vnnPr{
zL3@x^MPy%Hkd;!Zf-%piZa3DZ?;w6mWuYo>!OFvJx^rHpOUaitryu=O^?e*idK~03
z`O)ERHn>-IgZHEc4Q36u2;X^|iCPVHfY6lG5}1>A@OO9yUt#e9Y9hZ&cCd-?tVz&q
z){>jKBRq4X$jk^*rJee($E*Kf?u)}BY(2ujA*9F(1a*)X@ii3jRSXq@_t}4DiBqHX
zRHfxHwT%1V$&ql}Th8jJz3J^}`l4UMu1AA84Ng3y&(Z|LgjQLM=#1B=c!LCB^S3&b
zrJ1q><(F&LK(u-zX1GAf9wv2wNBds{7|d0&57CD&9{b7_Td23PWtA$_m&oc=j<@5A
zmbV@UOR?%!B_BunZ6Qp)X{hQ;rk2a}?~%cI!C+YBVZ~JD*+emcjltg{?U+%{k~vfJ
zI{!m5ip$FhV&^mC%GO5{-A>~|cP-jX^rNOEFe+I@qB8-4*S*Kh$nc>!#O5Lu{4uZc
z^GfaQZ{N#QEHXA?E3!ckpQoH;JYkzLbGG)bsx^7Qi|k~QCrI8&$1prVB|LzgdDCc!
zb(>%58vohnLsj!7=n@c4LO7Gsy`H7-{{?sQl`_F1>_5*ydFs5TCS9hJx5Ll6<it}d
zNn<U_Ca}RXCx-h0Mtm5d?Y^=P^tundMcne^@_WAeI<*Yryf{FN<Tn;0@yVBYt6inv
zsSdNY|K2IfjdnXpGZ!Xypm)@?AC&F>Xj*5xMoxju3azt!bQGzzi0fnFaUvlb&+vSE
zF%Ug{yE5N7X}e>46!M}REHb?pcO_Ws(H*)!m%Up^C}EIqSN^$8=k7-nD*>5|tYQ6u
z6zt!^U=6Dxv~|KG(m^9{eptXxpUF_9IOH$(mHl{@_@N*~t+<VL^_)ke%zpS5#~$3S
zQ%XzQenzoXpS`?YVm?sICIGF{sL6X=sl`MVy~UsnLj7RY?;{yw2}G4aJ|vSuM>?M{
z@-qhltUc1a$8lvFFChQ&vuELO(aTfYiNGS#u-#`N<Chp(PN?NG&w)6@45dealX$&e
z=!VkEKHtg$q6<!nF{!J@l;6fq6ujfn>)~PvixBlQ)bG?>@DZmvWna)PaiK^JB#tK(
zvUM#|+4=b3mwlhZH^?~=r!UUb4W8rx4>AS(n4h}jTPb<y(sTbiqQ2tU7q{1&p|{8G
z9G|GXQ^`AjD`puG<Ph0aHmRbEyJ9uRf#sM)FX>8NR$W>Y?v7T60NzJ4Q~LVw-X#tW
z?*6F(?ehHu@-CL5A*#*p>+fdht)BuAN3~h#g#3L?QU1ddN*Un;O@g)AHmw&MLa1yn
zmmR^GnB8g-=H;EXWt~%n%iEU&STs1=fmPMu`k>0P{PI!*Zril{K^ex_BB<Fi))o@S
zsS<1jub|t<P}baPD{SWW^H{9%-n;vlU6{NQnDuxvTj9Av$v)kd9_ok0!UZl_T@p0R
z?yKz#JCfZ<JAZeK6D`szp5!F9>5>^-U61bNc>79?@nYSTJPqpV7w#W-J6=*wi#fMw
zrrL|_mRQmir?RBJ=gAzt2)F#!N(+B)ExJGAGOq>MK3SP^xG#AXe)zoVGQgE<0YX}G
z>mQxLS7EBSJvvs99>_vylpc{(9}t)Ej)D|+e1}=Uv}^rNnu6z!_l;nqWVXXSkkI-m
z$nUVGVY*Qm+BgW{pnv-LYQ*yZ&RnWc1*bwMjL0XD<suk-k1YVt&)Ty6eqg_5CO$2b
zr@%cXH#{phtXog|?Qi%YuZC+@<vZ-fWf=lR+WHUmV-xMHk(YlgD=v1Trwv-2+jS}_
zCeCDM9A>pG$qwST^fcaQoA4Ua;>*82;O8}%)SX{Hb>wwWT*(q@#q=;?H#`n4ZLG;C
zwV%{2UeT&wD_c3ycHq^9+?MkM0+T0X!yoEPN-t@7kS2LT$9^Axt0qT7{cWV|<$z_y
z=G|wdNiA~eB=doWL!HvNBZ1kAd12}?(l-)jT&{0Fo;MlKjz50v4{&t=ncW!_)?GX6
zJX@&&U0xIL%o%C~H|Na<(gT4AczcBBP~b{sI-9;ojw8R6(NyM;<IOJS_~8E1s3WoJ
zlp9CWcUIXRN$9r6%;0cu)DN>fcg01a@^ag<5KkhAkVhx4;Msg(K9RRvr&XtX`Inru
z-Fd>c<F&12@2t!8tlYBZa{MMzy&^&%k72sD7PpEsn#ag#fH|dpl>2H{89}Meo#Lh6
zQqk4*>BxYm<gw<1^sI&eq^!{lQ8P4SAi?P5{xMTV!<4N;^(&5;{rXF_21WOY#>b}f
zP72Dd&CYC-D{?0>-Nj`_z;CsCIzpyg87F?42O!vLK*}{7=(3sD`In2Rx7-Apks-He
zw>)5tah}=Locks4mY_-nmAeixWaeO=B@HnsH-BT^%r4U}x7zcgj@L`clY+wGz7|NY
zs=>;IgkERRsy2tRukJi!x)YU;wKkWj;MQuUMJ_GKEm_4(oxLS!_c0l5-f?&xy0k{q
z`~YL)PTvC&0x$WT<*)niZKIhR^S$j?)@COjc+!dG^;X2Dg}bcLv;r^?<00;W-XT7R
zB#-HSpD=Lx>hjkezU>X-Cf9=X+q-7Sdi;#9S3Da5N%AG%bFlwofVBA>rsX`+z1d^7
z#-SohwFP!TWOPaBcu7F6Z>M?ZXg>%3q4qUS!7ALT_3hF}Au^u9?e9F!<&3Oqh>P>&
z(|{Plu)*4}1EfVpgd<|1z+^IeO_WtLC2+@I{M+=~iUoe1*}j^V2v!^%-EuNz!!lp-
zv6Z^98as>ovsS$t$Hkf3`hAc7s>a=hOi1FfFIV642tU+XABKkZ^75=Oe&RsDJ!yiS
zf`Uh|Gen7>P&Ej8#KFE1?-`5fMPS8;qlwI_A`P@2&YiE8{&B|xk%`BI7nf|8X;f9L
zIF=hY6czesTc>+Nw}Y;-YS}cyjo{iN#R;R#+k$O<;?Gb8#eUYF;hK|_ulbfwX98I~
zW|v%pHN)yxCq;O2fcvX1y&ychq9cc8Js^F|SkODyatgyNkc*&OJ+~rDa$2l)YSmU$
zb6qls%?an@HdJz^>t~}S9c1E{2NWg$v2IhOo;REcDEcmHKz=2r!W)y!ZE}||yS~@k
zFzfg;YoGlxtN%R(&d7mxS~veLF7PsJ`_L{zpM$6R=lmeQUuQS6^QIl%vG%Hpl59No
z(L}`mU%SWsThrpeYXiZ<eX??}b`>9w&NbM`$+k&j(zd>A++H%(fZI-$s2{V-3)IR4
zP15<e5jnB$v;NIxNj*$|V&LSvbJG=N%Qd`}hnE)?8%r8dz?rl!Xwc+COmUXg4fb9U
z7JyFrttdwYoNB#y>FVnEvK?h9t$v3EB|x}34wLOn4|UZ39o?C{PZ!w(3Ch2f6_cAe
zDMpAUb&5IHL-y}^`d*Pgu0wf}OYE3(-GLh<`7*FK#7&^FUM2bDB?{H|bX@z@>#e(v
zJ!Mn#6s6o3=HK{1TkC=i<o$`*isE#>>Xj|TWeeB_4(P1IYV|gG_S|ZdxYi03`^c6w
zS?j<rhQ*eXmOzD5vlw1Mfk?<yCNzvNTGU#3pZWvT+(17oZ%^2wqfx>DDXzzI(zM}4
zu}$Yv(u}Xvt6=@-T7f+|<;k}~-OYK?S7=%(nbX{OK;dCLHl?|)+MWsNlwG}9Yi_w;
zFa$$Ju$$q9sTH$`>p+U2|JUAk05#RE?V_lt2>5+c1VK=ms1&7138;L6ND~l{5{fh-
z6e*!YY=Bb22PjBK1BtXCU4j%vh)6FXK!AvV5JEx;p#+lL&AI=XIdkruZ|?c$&Odkl
z`I&)X_MWx&+G{=QEzkR|cMm9U)Z@jAg>+X=T9J8h&DZPn*Y{}8ZmafN*8KL3#<^p@
z{%L*hdcJrmiOYNY$tQ_>!`ySbE?W_*lJ-W~mtQ3|{WR4!98Hi-qQ<(s=OK?m=%rTs
zuCg~S`<;?S%l(12w#Od*c?b>KFPY&4+g1nH>d!4<LkHU2uH0HzEe<-QwRGCHUkeTp
zC-e;3lHvj&f(M+<Zq&PXT|Hszky{(0lHPZtMf`o%k+us7THiaCw<Ti&3@+3gU-Io*
zxVTc^?$l@Ey`81Cs-l)JQhwm;@D?G(<r@^-h%U2`%aTFkmP+wCr7GFLTe$F-k>aZ>
zio_pw)sGa^@NbQIKd&n7y^GU-Uj=Bib{ia^-cvtGyb{-6Z@=$&vbZ3f(s$ltfy+{}
zdEszs_KnFa(dDBXcKk+-Djb>_a`>vWr#QGAzW&}L6M@_!rxIUj$;5hJNLbi?KApW6
zqrRepKVxaZ<aMs#spQaakg$oM6zS|ie9e@Oj$XSfX5ooJUBr}r7E&ehS7FBG+_J_R
zPam6^e!lZ^8GF};;*up9v(oq_bs<M|^yZ`$_S5oF9^MTS!#;yNNpvcuvBF+1J2?7<
zU$62ip&l+B0Rfs3SfL71+2Cs0f+NP|eVrC4y6>WxVTc%{`l}MI2CVOSnSA+OuA@Kj
z={OTh+OK|mxkinZ@R{MU#W%ouRo%Pi4+E-I=SJz;>)|o)&`&y#HGIBn;6LTV<0REx
zd+$-YT~s*U;xqK#H;s$);Md&Ybbc`X^*XR{fG>u77*VR4EmEeYV(tH(PtUNcGv1m*
zElDiqX@jzMPTaV+9tjgN)QGr$w-5R%Xo?z<$Z_E0m?qMz^xnnNyO-Z9Ch^C0Jz&@&
z-g;NOovHF3iv1cehv}O5Je`ZMoqu{+ne=Gjgd`6xD*0Y?@<=rB506c=o1`IsL&&L6
z>P0`CA$jc3P<}QUZ8NrdUX|Yv>O|Ixv#u_?qksH_Kv4ZU8nH`lF<^}y5vylggvUtW
zt8foh=nZB5qc0))_bvdD*c(_bQ>;Ee)L)-;9IPLzM8b%(kCA+W%S(;W7;_@4YX{@I
z!z>*oM|4g%k@Ebn-C?gYY)Tz2`V8J)**5<DR=TlS=PA?`SCfFt87GDZZr7FEk-W>V
zF9O-d{KVu04+^Nu6?BuFh%6CG(}Kl(uA2)>+Ges43sD8bcB8LGR*w7xXMR)affEV5
zuJx{68LDe)hUxHfsJN&)Rlv+VzvE5V&b5rawoIwlkr5-qgdDhqZ2wewd;FkzutvU$
zpJ|k-8`&l~Sj@ZX2S9KX*#e5>>}AOGb=zn2pDtULj;7-sD#k~aR1pzhX-x+|ycLU_
z?UW(L58(^lvjX#^Hr&r>CV27aKIS;8eE{*aOC`Nz%oJ&#u#?O9UhHP401g`2h)T8|
z5{q?t6)f<r@p~isI~wuX_OPvoZED(gMLnp~nM)=-_^9O3sASc&YUO<KI;2lBT<%i)
zn|G}H2C#A}!;6w85_e9u`EJaG`A7z|zj=#fpvx>a?zX6~w()mLNr>jeEW@oZ?zc>y
z5Lu5XT?Bwa`DF0fWK;rZM^G8DH^!gt=n4-)mjq7x#u6`I-w+gS?5mHyR<MOKqNlT)
z?$-N~TXh1TDtugAVeG0lJoG6?-lBPsr46+0JAQ85{P759IaVbsnRMRwG~~jG^da#8
z(QZD;WL)&ljWKTxAk`nJM^+nCZ`d@wVdXE?eK;+kJecY3^X<cB`BvC#wWND)r-vRE
z%Mkh8g^{InOt#}hv`hkjY)g6V{V?kW-@RFo`v>p3o64AUdu&zMgR{9F7mQJ!S}k`U
zCRpfY7aegLGSCwKE&1m)+p=HRmR97v3sHr_&C<PRFL+tQ3;|dE^bv2B^xygiQ(b%~
zPu7mAdX%NVyWr<LkgfTEx{ZhdhFhPumFpvEaIV1UrW2;*SzWXQKo?n@ekFyi0{F*3
z4fUNz$0fsW6h^dLBF66x(*)vDpDNwETUKUKA(L6-Gam>KL|3GFl@2U;JHi~zFCV^9
zgcL8K#)?1~rD}RsB2T<~i{b;?Q|u0x*8G+^8VOVDRaMv%7OSW^-;vOMdme}pO#6mX
zS{~F{qoW+=r(@*ps_*Zf-8Q}zS3Kxloho5(X|wfZBUI*XzY0Mz8a>rqHg+`)nh3bl
zDtuB9;of7|8hg8M8r3!A1Z)bp<KkQpgGTf>ud~2$5qCX6u9Z^&MZ-r%+OG_j)}7gC
zYGvx>PazI-FLW6h#JQb5zIWY3@$Shwa%ZedIZ`~B?g@7-AsHn6`~W(C8oT~%6L~<`
zu(3cQX(HOGcq0HVP$xKttsvKy-vu$5BDorRDcakQW0-_i@0}^W?<yu!yKRV4oXGL^
z>+^wzHJ<%mCSX%FFJaHR)g-UDFJ19EP2QD0SNS{B_X;KXJ4xBi)&t#YUKj3YExfrn
zAG9R*>z;xPn{sIZXY=TFKe9CWetnvPmSeL_Wk!p~5VWBShS&_!XbvF2P*W8rqP(iS
z2-UBGf&#^wRKMHwEX-XCfiN<E?3)r|NhiJo>t_?|V0z=eamcwNUGJT(9qI=+?xldn
z^X0XoPlfszp?$ldmtQ;BdrVtM89|BW$}g<8TyabZ`JpqV!cz33IWAJVFYL+3pIulg
zPbSa}r|tIg(JR%y_S}LBL)=b`-z)5@ZkqFZkLGIF)rJ{DqThODRUCMGp{yq3$h*F&
z+&mYwRleJ#O0eKbyWc!+zD&8VflYPIsz|NhTyzg4fbqDARLqwP7R}QmoGIl4oil@@
z;WmEn7yGbk5A!^``}Gy2clHVR^g#7-$`u)v{KeB3$SssEM%70xACvNc%iUMqk_kH}
zQHXcS9(^Nz-5Fl<t|?1M0(Dd`rTlKW8wf}>u>1HhHDei*!{Fl5I;)JhR47vMP}q#_
zmU~~;eX`2!rPJ=4D>Djjd?@*Y({D!1BlK+n$ww)1B?S5!X~^z4EijsI0-U(X=-TV`
z`r~M6dy94&Zetj4p!_h}E5UvqC}XG^rR6k6n(T2AL0%qyMUiR_2V>36N(!SCO1u`Y
z@j`Z2=c3S6+^4q}jv{V5iX6<zM<Ev)kjXhFPBABo<d>30&%mnR5Ul&4uS4@j8<-d1
zR=&?gN@TT?A&!Mr5rtKlN{sl$B#e>!9~Gnq>eGR7w<@nJ(hJM-Yj-BV&?9lAjP*CA
z83eb56yTtMsF~xg{Om_Ky7}jwsqk)-z>51c&;EhDP~G=f>x#k2#vppNO^bz5hP-9V
z{d@fS6!I11l8m7L=Gb$>?`Gg}zb~zteGduso%#k)HYk)VZsSyznwmPwONcsGsaFv6
zF@zZDPv6*($@7+R`iB3lNS5#S94#V0U)%FKcmTG_rx)erCfRCeb3$3{VBdnz>*E@9
z{`DofYfJL;s(1S!g}Ih;o|jIvyWP`{rmAOm!Jchs=*HYLi(n*qyOYIDB<1>F^*8Q&
zb#nl+Wtoa^`S$52Cb9qxPLS>}FPAtmUo0L+_qcj>EL*{}Dc#L72_UWN<r}?1IkENj
zHwLRHMJXTBRLyZ7SE1V0d}-EBy>}5-POsxC<HRo}%%c0a_0=%S9WTb*j!ETT<u_5}
zH?{i_nnuH>C-teG;hBQ<gD}4mS|I?K%1Ghatq<SwYR)->Xg~B`b<Y!q>(U*t_YPEC
z`lG{guOes6t7_-&o805f>#y(JIx|{niLkbu?uB&bj$h2^o+=KN883V%M@*YFgsDv3
zJsm2w@^N;}IKM1alwe_YW&8;t$8>g6F#WN58Q|-_`Xq7p<a3hU*ao*LLmEZb(z+w&
z&Q|M8_NQ*FaDuhMc?8xQM=>qA<kCOQM!B`>J0^4h_B$`!P01Lq;okcTq{|aa3a%1=
zZdmwII*an4GQ+E@y2o1RWl>L}bi1+cHDjYV_bw&lSeM*a701rwnkAV2?*TWWoqOa&
zS~3rhZk8i&`$x!JdEJ3xa*ZZ+f=ATsch*li{Q=}z>D-GKLiT!;fDgRZx==K6-m1cB
z3B~UKpWli~B4w-PX%CpFR@Y0vRhs@o2aY-`-GhWmhv%a%7&8_ze(2eiWYp2%^!QI*
zAs0Nalz|oAHwPf<Xc}SyeNFHL4Fe5=g@R|<t5B<N<KMNqHhf`ns9e{Ja0L8Sez~PG
zKR_SCJe}^pyXFVVtnrh`Bj2q#_6ya1+i76~Jya5it$G~_ZX^jc-qf+Z`V(Vl4;oep
zodEX$`s~ev=XdXDhPgGptnsRrI6AC@?uw8j@(uBgf2bRnt~MSIsph@J{T%MvRdsp1
z9=9}kQs3gVq2uXpKGz-dawWC2UfCOVD5V#3v4CNpCL|?Jbv!ATkTx)|!6_U!7hm<X
zFtQXnq@He=l5A$DZ(#83qwAFOLUyf`=9>&TLZF*nm#Tqzk;GB{BQqZd8$K#mA|YEp
z18`PJo4zTsSuB%&|JpCF->yMKQFmJM8ooZfh3c!8_2T|qu4RDbNz|%D;5Oy`aQCU2
zPLtHlH2N#Gp1JUu`x!o$<PK7cV!s5{%Mtv9_!@>;!}WP1@ZjNIO}JO-n;JLaJNlbX
zl}MLFpRe2ZcU?CZh5D*o)hx|DV}>A2qT5g#P_Jym1u;Sz`C7%&ft^p6v_O3xyeByh
z1Rwt5BjoqyNUr`cgjq?FE;jsfff9JqQ&M4R;&m29rgli;Pb2&(8JEF3sPuHcw?1>{
z5{e>D0-mYW)=kxCbFDWn95yfV9?pDQwCOy>S8QEY72?}`!7uZ}iy?5b%jr;`i!VDf
z8zJh*sjo-D+PK>F=iOg(wqK0S4fk4tu^z}MwL{py=K?&R?TQCAaXMpbmyl224W)sQ
zSw}joo$ul8v<<KJZoYVz=f@rDqin0}E%QWiVJr}A1a~QY6MFB?uE~Oree*4p>XK+&
z>fVNt{+~c4zoR%G#&N_4u~kijmHar!CNe@_I>oXn<E@KG;IiA6-?_|@rJyOdQ}N_6
zLo7dFzdB={e8AyV^BzFLx`G4L+$SGKcoE9NmIj3opm(@&AV;uw)KssmPEUj6l51=(
ztrZ+(T21|++>iwL*i0o0&{5p&$n)yY?!NYr7*<lTGs4(?4FIC@e-=<TbI+HV9F5I;
z7Tg(pa|Wpv<fFFdl|T?QOXZV|`(kKtZ1yF7P+?iDVYEYl+Yb_~up(ty4flQjLrTlb
z{dV*%n{a%F%Wc3S7bV=|kF9X$?E3wg8`z6qmTfw^blB?$w;kkW(|5LsmC%uNok-2d
z)etU_0ib|$>fBsS#E(7(%DJ8JVD~ckBV*P-Q&EuP(Yj;-ayKn4uhUkkNB^=Wmw)wd
zKmoDgL0LpuL3x&+N>`s`Nt0k!YPnNdYVvJc!}m%&wi#1*gu3q40$x`<N?Z!@BIe|G
zZdbr8@0GB168u^v;wYi`!cMDDTJET%YW9st{wv^q!LO+zj&{_J0hLi!N6wz}is)P8
zJEuZ?JZ`6C#g$lm&d3vJHsu6Q8`@=MAqPd4Ym(faqu<onOGcu7OI|ey7+qWtrO)NL
ziGeNdRyO-7njSauwES#QeFMRCc;WWdQ0&XKgeLr6@|omb&Hi90h~$tfR2FG@QZfo$
zsnxAATtaZ$m^5is5eU=(3|I%OSMtGZq~R*(fs<{gu4$eQg?-?<@jFLN-SZfXQH|==
zSLky+g3F=Qk>!iL_;EaRvXfVta^K}N1^Qw<9w5=YvV`^E?w71{4|N9f4_+Pi6S5fM
zHH-Ulq2$VGWFFtUYqpV#@m>7Y?sivAB=dk;l`1);#YC6v<A~caCrutMjMB|pl2^Rb
z!STKwU9~=H%@z0eqtw{SCq@%%<F;D~!I%L<ttO3(b9mFIZYQ5tpoLt<sy?5;ghOm-
zlU%7N$+A=G<XW>NT|Xs^y8BqSTmOPjkbZTBqI~}=qX?>INaWYa`ii;4lh-*8t={Vj
z5%$zlsTus@Q(>caXKW+wcNKFxUbpH&MAy4NCaW4<_6jGqQ`1A_=I4lAyuX(9RCiWi
zjT}#byN4#<6uzTb=_c)8eL!H?_+~LKU`KYI=PJ_@aV=wEx69NQ(R^Nk@Nrn9E<1UQ
z5i<a=&Pr(uTxsVH$4Dq19WJ|KxAhu%-0xJ(AB6-YwpQ|-y@y3+zaeLSx*#TGxd`7t
z*8JYY3)un2`9UnjCn-|SAfQ~SY<!gAKX6>Wi?_efsyt%-w>sGL$L?*I@F~}ML5FV3
zRgcEl1?oiJCm#HBnCW7-{&w~H9k_27R7@Zcy}skdY0zi*y|z{nTdM$oK4jqT82T8V
zD)@VG(@lHCGZK2Bk2L#UHCD7(GTxl57x19y3Np!O)-y+4C>ELfCAw5M9`(_rQ>Aa>
zY-8fFCuZC2BWKN3Pe5OLbTt9p``F<P^|MS6kmIKTT{Bj4%e)${a4gKl?q_jykC}R=
zO0(1jkJ$2>x))0iZ)6G_oSw_!dCNsOxzq`(A{kF0y+TZgnqI<!fZ+mFmhbk#_1F3$
zgAW{(cx)(5X_*+t-Z)wR^uftEFlG76MzBTMqa|LUJn^|hH;vV|-RWE9<%x0b^+?Ye
z=S=#jA223q@HGxVhVPwfcR`S#hrhbr(J(d;M2u2L0md0UCr8MeA?=(S8LzeT7O?g6
ztv3vf3#In-Hkv|SDHa4BivZ}9wsh&GhrXle8=1MLcj|&uB!JX_z1r&mo<<dDYtNjq
ztV#N>j-x+AJfoOhYpCP^Rqr$&;jS0?uR}_@Mwi{ie5%#FZTY5rY{C~hc{vVU=OCD0
z@4;lb)luGkX#OlkNJ^vJrsnFKj-HW0&Ay*{h5(-ocUT@XzCSsaBXJ|J=84~zH8@wB
zQWD%cM8D};pg~nYw~G543g*x8E8X5(gT1W0!#ZWk8+H1e;pH5_Oy!-II^r_oZJ%+d
ztu|xkqlqkK^>hO=Yj#8P3p^yq_Q3qw4fh9+dL9(lYhDkD!ycQmsc-*LFMTd-?_u8H
z;1wBid`_(aM2JgVe6G4pJ?2oq%84v%wKTjVQMSDhaRh+l<B+=>&x+_^L0&C`Q_qxq
zDEicLuQw*Lo@}_LsplE%>b(BErfga6m-hT^`E#K-`F<mc<D>Cxt#%d6Q)ka9ZNmyB
z&yb`!>6yM)zJ!X|dfz%^kQVn7P5?7)*3V1fcQcXY9}$u-ulPycc(wVJr~Lyi4}tq#
zQ68Ee+gc=Tzpw}#tM^rIS@2t+97DWEpwNR*ZLLZ`3aKW0{pf+GwD#s5=vA6%e!=6K
zc2+`v3xipk`lC9pCO|Yac~YYuhx7fa!lPkoakiMId0C4z^1#l}M(~n+!O%GG2XaX8
zlnT-Z03C-9*GyGS$lD_859w*Y>3i+Ha0z__sQ@SawEplNSzhC1tmln0H=gJ;M7o%Y
zoM?J#;dy`QsQ(nIiO_EH(Z}HZ8S%F2ZV}|5H#U>0odXwZ?ep7v@9g>6Z660=5r@8A
zuy|uC;Q1w3*+}q9we#s)=42mz1IyX>L2i#6Dv8Im+_A~!CaR@sF2RoyQa}4hr4DNB
zH|2PYI%oasAjdwoIXHk7;oty}3jEo>_wQZ=#K69J0rUoFc;H{)y*W7kGZ+77F#l=}
z|6k0^-&Xnmmu33zI+#Z8|0MSRdF%XrBO13W#_ZZqBE|yjA{GNQcRwY5)T`HP#r$|6
z4^jzF>eGNNVZUufN3$ThLyrBCHJjQ$O&ELl7%AdbBj<tT;G}DCSLzXG@_r8!N-7r(
zMV41^diXqSUUl9$Wfc!$cK&8K)bm*f^r*KnJ%1&UxR+(h?lfzHM>C#b$%qx$nb7l(
z^NveCZd3dIr9jG8^z1zEIIsJR|6VIrYxfhktmy8z6!vdhU+ZOZyKDNPz2B&(_XWwA
ztyt8L=~HmAz#lr3SN0{shZ;>v`pR(9lj%{CFlRI4i|ll_7^gGJHAsl#`U4^;V`)M+
zx0qY8$vQxk{9cj|znsPSA1#%0Ktb16qL}8Bzj1_k8z12OM={lA`b_n4o9TJD>r~)E
zG^2YSPg;lgjeb`p*M%@YJe3$I7v{`XhFp&quPtz7ebIw%-`MR6$n|AK+kjzBtf(#=
zW(U5zG2nVh)w%=->X!W3U)JC-G6enwX>AU{T~P$xG!U(Bz1%&4BsPXH|71mxR57b*
z5GcDn1wzLpuSYp00(oTbc7ir~JeS{wwvryo=juk5!LXq*fi0%Hoo4P?NEZ23C~3-H
z!{a;6@zJ0FV@#-}!n*=Jth1)mJWH=!WHheqGG>YB(ZjGtixl*I1l9(P!|(v5T`oab
zleQ7l=eQPuavpcND6M$4DaATFy-bH_1S@RK3d5vw)p=0#d6JX7KYtpx!*pv?ny?mm
zs~N7f<e!JZnY%z0j3Ud{z>Le?Bcy^oSj23ZQxEsCu<Sws(GSUt%_uKCDK(PCC?dv{
zp<7J~cD~zUSQ$-7C<`2#RoNdi_lFp*TGH)wry#rK61vGsd}mTUc#D~0yn8hgD01T&
zv#F=~^G{~O_Lda{8cl)0irE@uymv$nwHJ~d2aoRH4(=?Gg%nnLCW<4%xy~Z&n$H<t
z%sg%vFnriDKeS(Rx(G*ByOZY8yNGAnu$?Z6vR5>O7R!jtaPmS<;D%8?!asjAb(E5a
zzK{^yw*wn2aRNco#Z0BTl#1}5_I4QSD6^ql+h=J-xB7Lg5w2E-L%CU;n5|ML+S4Nd
z@anfXPTxw^VHU5D?RBRytoBOK(qYDQrVi4fFK^R5W;>Bcer4I(V%6Gz)g+HrVF?{c
z<Sp2Aw=Q=?;qz9z<d5g1)$R_(YHq>IhSP4*RDy^$-}t_Gf%NUy!%Rb_J%)$nP^^?b
z4Ys0vaAc;u?fX_HgS=GWakLyK60zGFZ4GN$kCSJBj6$<eMAoX2UG>B1khS^4ZI=7U
z<-M42UX1;goqu(&w?NCXU&mPy#Qwlphp+Camd%P`_7*7OA!ge}*(UyWt+ZvDLiW`?
z3Z^>>wDp5YU&;iT8Hffx&XBjgHlyvrPXdYW4%J4=RN6L}SB8=0EaO^ZfjCPcb8E!0
zTd=GFHA1i1JsaU*(9CQX5w3WTa)_`vn|=)r{b|s0&1+lvL`kLR5+MM9Hd(J=r@)Ju
zAJP04pSRs**k0hCtqGJ>hK{7hljaq*@9k3R$~3vc#Up}W!y|U%?ImFx`T6%bk1iMX
zZBHxGn-bBBni>5~jE2zW8~)K0BiZsT;E9V*TOCRi_xe-nyeV;`Ykxx=Xf}RdG!W)i
z>{|ow7hIzdPQhDudkx4;Y^!OLB3Na{lMjTk@Qhj!Vvrhz>fy<7D|)-r-VN~`7!V76
zqq(EoKY+M28Z1_DWuPpjnN5kHm@7Usarbz#{Y#6A>+fs2tINWP3t)%7<H+<9#TYZt
z{Lfmwh5Bv!3LDAI8j3Lval+iiwvwzOaES#7uwYNByY2pH^SRFADiuE7_hjyEojSOK
zoo1_1YOq5lto(i$1&jIBsfB^_Y|s~n#Wfu(VYt*&`oH0QPmlJ)XhP8>d(SevGRXWA
zow35+sXD%syOb=WDD%VXg`BhV8IZv6!v^_QC&g=2X2QFVmwa+VM@e>{9#Lf!wX92)
zDrECYTb&|}@N0=N0Z87+(HKids;()U`h2icF?xv^LDX_;8kg8YTecJu_jcAttJ?V{
z%!F8bJtmISJzX#|G;ci??HUh)I5F3o3W&>gjrJ>_%>1KPQ1;}NK=g23$m+}NgH(!~
zS8(~o_CIx?>uZc3Fa2MUO`FGm<<b;~c6E1Nqg}<dXObC{SQhkqw*#yj9MP3yO4Zy<
zY7QOtk6FFdn?2atwL8D|8UkHz(naqhEAAXXJSZjPk1QxWrf^!ewec<{t+1;v?e%79
z6zUcP{qkrpkfOgbV$ef%E2Bf4hM;>8A{!^8Xk((T@0L$nW^PP}iZ<=|XT`nUYOdLh
z;?w^0peA$oS4tm6vw43Tvbj)Z5X9F5yHqqcEXD(37Z!BJfMr{~x;3R3?I0e_Ca4Ls
zq(~K&(OJAYk5<sGHpH-98ATdhe9s9_3J>yFdMXYJubDAR6YMLf(9MgE14NIFXxXK`
z1Av7z1_!kSR>VZk%umfwf>6enINXlMerjP6#ew%;Fsj7qrJ!@yuZruED4M_A4fYSt
zcv2hU`xxJ4QO(c73Z|M+D(WYEBd|-p-7EOyhN)rb@)@V?(ANpEUhHH*1XL=ru<Xbo
z@q(03E4~plh~w1?nn>K+bhs{>JSLe^k-xro$+~h_T%iTXKX3Ci9d(AS)cO+vZOHfz
zi+(KhJ77M2kZj!kerBZck!z)U;=Z^d{3L5^w>8Tq>3}0}$(H#rR&JK&?wNu?SM@#X
z%)Bjm`8VoJyU1DfhdzFDq-uyCRg<~Qxj8h$MQP}O&E`1KewUw!%YJO{-SsY<v9;9_
zo~Tf>J4EfhnqyZM*7aIFBzccoANJWAv{@N5POBv=(88}A0Q9_8LK!Onf+wkqGT&8{
z&dVBNTYm0<QI#z-a9@nCIlosgCOKj?RbW3(k72|S=$YM>!#gmHPa=8&lY{ZcLQ*0=
zTTh+suHMLSbz&5O)Wl;}a)2{L4U1Q2QIuy&x$B?UA9wnwSk{}0$Yqn^ksPGPony`m
zUlp94xq`4$d?9%{8@9VXbSP-|F_o7;bei@<5X_?PiVt?!I8@GW=@bFK<xN!B{p7fY
zUf3*<MLh~-{NUW2ULr^I)fB7&&*WNe_DNK%k(T!MYoWEEhvP**(o>kDN$&x7=3rPt
zl9O%&L5jYKgsgoD2cuAy7dvQCK)UfQ&E37k;P#48-E*+nfp7QmB<aLozH}(1iu_KN
zQZ??12j>rv#fcQx{;7J_mb^XYPoY!$%ZE5EK6E6a+ddjRtJu`Yu??hUGBWvC4SpDA
zz84r~*7zRC7e2y>gc8<wQQ{o&0BOrs+e@~uzVX0bAaO@_gAtECJj-hF{peKxfg-x^
zxC8Z`ZNa|1^&!jxl>p^9Rl|lqdw3eAivbO0n4CnGF#om?3;+fHwtv!KccsR-#*_D9
zVWk1Hc^*wZ<D~4L?r#jo)d?z0#05%gS(cpgchES452$Bg&fjS}xWCZwCoIPbyP6hg
z1aMX)d}q=cjNksP`16x4gKqD-xapnG{h_g~K&G=<)DJPu8F>SL^Y9EWW^yyg4mUPH
zSN9|RO6W-+JTTXF_1Zug^h_K9M)>yrS6_CO6<#&wl|b7tchlo1Vm(O#=O~{ItoPSb
ziCV49#gG9J%~&gDc2(YBaxgG6x&=(Dyr?f{kOHjw;6wh-leH91KHU}^Y*s8(x0ZIO
zEnv%N!L_=W8o7AI(RiPOf&Xla4q4G;rsQP$)1k@4uK_<|B8?+ji0rzi?Nx*6Eo-q4
zE7V~Y$X?{$CNZ)BHbD%V|5&Y|RSgQYpM*w4>Hd%pm{OZW?VGXrZt*FXAnRnJ)4K{U
zk{GtCk2zZm#^y(^&PiKRKcOP|DXNOFX+b6$fLvH&A8b*%sXHfk7u#LG<nN=B&6r;a
z$!FCAM;sobhlL!1JFLNGqFBu>zRcAJ2Z8=W_!TvOO4xer7B}rp#|N(o;QiO=d&~)Y
z%+owqd(CwXE|ZAqsyh|r4L~9QV|F>cR9ndoPV^&i7tqSl!`&;<w=*5WX9d~GMBRmh
zzNaU`M>)>!Oj5DHe#<0da;TF($&HKE<X|H3+2;RvByFK*1mZM4B|Q6#O|LsvM^keL
za%|Gsv>vppe+1nKc_Jiw_WOs+ty?pINpK-yLmUOOQ6~nhJTLI|{=*;N!M*V=z-0k2
z877{aT*?XT7Ta2)d9og%B9`~<q0HtVe*&sxd&I`7OtpToioNRD+JbAC*=#yHP~yaV
zV#-|N3kJ5bPeUdrus!ncLGXN_nbui7*%m|OxB|QS0ZvnlrYMdB^7z#w$LVL{>Di&t
z4t%=xrO=-G%S^&C|2OMbXLoV=Yt2qRA+A_Pa(l#9yxDLlY?ELJbF5TX58vVYM5cpL
z;@~QMY|HK`yViiP8rZA=eyY?J&VHk<yC@<*C7ipSPjzhH(%F799XRB9uVfSe8C+{k
zw?2aQt=MMjz0ldvw7xx-BJ|f5tVHM&RSK+w_NQ$=(%{JP{CcIM@Ud^z58F!XVmtr5
zn9no)BU<pt*!A$x9CX8*e)51P1rb<sjnv-{*hd@V${2%>Kt?=c%+Mcy1|F08t4Cy+
zF}?&n6Fe=hIGouEt&cOf1lHZ1G+<kaYp*3+PG?lcY%MS*vvij<LwdU51D-m2ew3El
zrr}N|pDsFx{ivjcIZKlnIk8;3w_X7GJZYQriEnzhN|BV=+VqipA2`UhuN^lSh?M1v
zPkz6Z>i3cE$NVAGx`OGE)mi0@Udz!XW8kTgNJpV-Esis~<WD)(#dz9F#VC8?4#^(_
zr__f%(P6J`Edu^ox`x6=oXdM%7DXg_y>?}B%?cuIs2I)qjM+qLH6gduw<1%bm|Qaa
z2Vk2AB1!(Otj-YVJ^}UPSm>(xO8!98W`TSERLGz}>kd4y@ukbvg!9ehSBi@bLagYa
zZUy`5yFng27vYi>w(2Tx=Zt=h*=RfIYSJuE-PA+9O}#>4{|tQ?oOZpzdHOP7{n`Lo
z=K^J;UUVtMpDW?Jkd1UFwqY;)W+!Z?10TFtvpF?K)YZO<%xtCePerpO(^*l2d*j)F
zV@Z#&OsRBKpV<T~I}32kbb|_6xN@@OpmPn0G!_bTupuf12(6Y2Gb5(oa(T0Ig%e!8
z=CkQQ0+~H#;v3KA)>5`^l+$j@4`1-%2H>q1L|03XHRp5h<XRIM@sy=N4z-khi*Mf*
zHXDNyX>AD1PG6)fY%LoZ6Z{Jm44jrVVbFHPV;lgFGzZAVh0C=QU;2aeb+u=8_iY(3
zKu{Ce>sVFW;Z)!qNu^}}eak}GYg=m`<Ug9J8=dCSx45DiGpjPuMc<+?rs(b_@Q!(o
z7wN)$=Iy4!2q3!{V*9BtMCHwClZ8BJwgY~glpoZXTSn{G1Xo6^1<CCBOvSn6u~FR{
zz2bQ&f9AF}^H+Z+Akue&JeRg~cd9)$wnAcCNh+_h$`>~#$Da|V<^i(siR`4@N_36G
z!b?c0vTMT69^0eZ`)<B?3_}1=$j!*;yhwTb^8Lp+F?+gleAuI;_d;T58fz=KS43zI
zS-n-=fmvPfTpEGt-iUK~IK52eqhYPfvqtGXqRV)vm^Ibtr8!vEXf4J)JEFTv5f{6V
z`*tVD<Ia*op|&DO?RDRm(PmJwNq&RFMdOG@d0hB-eqexIrX2se=59{GV1pU^1)yde
zFK8}(YY!f8Bo4(yQjkj@lO;K$b5^qUM)9UT3tRR0mZ+vC(Z{_trXc!=W#gI073yQe
zGKAB*0|@h=Zi&a=E^!SdSr7_cKjuF`cHH^Wn;*LNr7>cGoHEqy6!u=QC$Ho}f*T>@
zsl+`|Y_?Wp9N<#iu8f@Lrf2aL6k4*GhbZ-KGlE1USg0TW(m%XTurEh?SP3}hJh$5-
ziXBy;Ej%m$Wh^dcYTG!mHVhg4mea+zXbZIpT98NA8>Yhx;`H_F`p+8C8&jBMnRZ`U
zLOp#_Zxg@fA7vHM<l0d+$MwXxdt~SqEx4_vdjo0HdY{PtF1v46O{lJ`L-bn#Xob*U
zB{GIk)0NGkPSr1!GVr>7w&<I{hhhOg9~6}Eb1ZFyXgNx6n3nFoN-qGs8ZPmVTh<_8
zhHrsGhx0B9t}_6E1pWSWa#lF*Epy8ed5RdA#5?KFH}7C$ep)W+{NWpg`!1(&q~h>C
zcS2+iVK?#{#0keMAnGSbTDo49lDWE`$mw0UtNP9^uf`+s@RrK>v$iFG?Qn{?=^edS
z)Zn{m^ff(NgJU?1?aU*=q0MvvtXj>@se*@jI)IrAU8`*A6XVo2Q968r!%Q!9lIDyj
zb#N~PqV}n$w!Y;QA*U%QBRpQTE$`qyeM&$moq*01<CiWGcN(oL2_LNR0f4?)%s$g(
z^i6x~PiAA#6Vz`xO&lB{q6Jzs1I7fKbti2D_<o}PLID)BS@6!d&rKv5$)XHT`EqQH
zN59PQ?LbO!XesD(9B}4ZN43_W{PrC`bAR@Sm=J1gj&HB5^sTo}kzZtGg7MpcjL*E1
zcN5U=BFhJlJQn)~%VmM1$=C&xYc2aL8iz<3N$m&S-q*v<uoQ1PQjIrdX>@*z<PT({
zI<cq^!ea)Yjm#}uWOx7WDDaUr&V4dB|9t)eS$>6`q|ow{;oE|4tT_VhVn^$7|LXk(
zKb-He{hf<L>m(i;ys6GI^4Ay=GO*|1I1*y`$BlcN#e`r`le}XgE#{Ht3}0CGgF`1d
zLhjl)gqH0yC8P|km7GoYI~`A_=}4O;OIh*C2Uq&@j_yyU*1Pz#;1VL6ei6KrVqX_Q
zIZ`pDR1PJ_1K^MNeyg`Y*^+Cy#yDQAwg6y%XbmO)SN?ZcAmn=a0U+4$KQ#2ein#o@
zo0-26+kd0`|F0rUt87Ars|Y}%bKGFs6WVVaQUo?X#}Obl#d(zDF@T*m0Q9G?b8wva
zKQB82$W(gF@vm<G`>p<>v%h%Ozu(H4Lz?5SM*c4z_Af5~eU|>k?SFCkFIw$S`F};L
zzZk+luKqs_<-e@eKLGHbhVak${Kwn>eye{1`#*N}7oh+5Tm406f3a2m^Q|BU(x18N
Vcxl*t<p6#RZ<+pqzUln*e*t)SC)EG|

diff --git a/Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/Default.png b/Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/Default.png
deleted file mode 100644
index f91282875ae2654ee5ff9f347921620f358fd85e..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 18383
zcmce;1yI~U6E8>zAtZQkcXxLPgvElp`vSq;VFN4@G{IeiE$(i?f^G=zvccVT;r4q{
z_ui|!dRJFhSGCl#GyCu9?wRTNP0M~$SCz+nPx>AS2?<kCK~@t9>D5QX-v$~oqQ&Th
z4iEA6&Q-y{0|^No@jp7=E2PY9Vnic~t+a|X5>j1!;G;$o;xo0Cf~E=*l0O3y($_E~
zr27}d`#utq7dH~pfjJVAXgU%SkxQc4pd1pCJU~%aTHAN&Xw}Dfe)jq8nTO<KM~@>8
zj&{V?*SCVx<mEuYM)nEzLqX>yC$0(aRi&!szwXv!5x_P90fF1zs{ANg+Q*Jz+w99n
zSeSwh{Qav}>(BryFD}}3?7Y+6Yl%m4WflO^*P(ZxzP|d3^csn}7YPZC8wm%&2nvGv
zSExuI|DSarA!GbsKk+|z{D<;?8{>b|@&An8|G@MAhTeY{=6~VfKLq}(l>hHK{v$L(
zVgDKYe<t<6bRdLAX!5@+_J4TdfA07XFaM3yf9<e)LMuqtOa&r7@hjC=+GR4LiI3GI
zv`9)7_x-C>ei>xMZo`if8RH|Yh#9hcToScZsT&Xb&(|eQ^J*$PSFHIXBEaUcG>8^n
z@b~(Q_mTZ11OygM`v2uSAs;t9`$)j*fyR~0(Ks9Jt%L5=%x^>MY1vq5@N;^!QLR!f
zeB<#Lq&I}aq^*fjDV5ID2nf>fb2*~Xuw4l8W{DkUFj;z&Q<Fthb2yh8qylb3isa*S
z*u8{bzY@VgLj?lpem)di#u`N6qL?P4gur4^Sy;vS+W^M?N->T91_pL`yt4)!d3#^K
ze>My5k=ng`r}QQ3N;`F%y7%Sk=1s!CfACKG>Cx+DRicz+y;gBasb5hr;ZzG^<98O?
zaM%x8Fmqv)rVL9VSUnC$Wfn&URin{hf=19IP+1!~=~Qzv%OX(jXYGq-^W3+4m<wN|
z3VJSLK5KfWVL0#neaV=_Lq9-DXx~Jt@&mWPyJL|$I+30j^8?f@!qyHp*M;6~Mx!Vb
z$Ews964bux4xfz^>QDY-)yC9qR$u+8qcH^DE>yU*vi;O4lIU@9>7w^k>;CCEgSKUU
z_>vszhB2nkQ35*CT9C2<w|ALFF6Siq_|Fa<*MMrN#b+qV2qg3McF7`4Q<flYvkxyX
zPuVL^22?@e2dx;x#Fyl3??ag{P!;(V5~rx;zzbSN0%~ebQ<5Cz0Lz9m^#BQ3|Mdc^
z2C0V+@FFp@!EIdq0*$xCe8fCY(>0U!>x?X-D}QNurtF(OetnsV;0Snr>`Uu8UeVk1
zj4AB($ZoPpn9Tbb3N%OszR8`xG(K@9NK0`U6Xo|fY2o={(IwVG5ir)2v)s~bI03r(
z<Qs2QWs{@<dGvl=jCLPZ52d1?QDhOx|1q28O%29KB(`sniwM8kUwYoz)N2`2sE6Ob
zF{72<sGD`<A#+GH1KaC*3NdqJ3K_lh%UcxaDuo(6Vh;=pezv1rKa1IVz&e}Dd0Wzb
zJu-A05LR!=9o3Y+-1D1nxQ={SsZfDgBB<H=`IfEw`95u7FKY9(|EkC1^*+nD@$D?O
znCo1;SX_@Ej(V*t#oO@`ZyRibuC*Ms?>4$kPAPmoJ;qwwwax{95Waz!QsBsBmQX+^
z#>BjqHa!`bn)tJnG4JaSPy4FMTvs3W4qwYjb?&s}kPm07pf;~btr5q*$!$oF6NeJu
zr%Yx)s>~PQF{))ueLVCc_F!j=4xP2!5^2say9$GX_V_NID_jCyXWN}{+C+cVJ1V(X
z=yKpusOrsizkXx;o~GAs@n9lIeogAJB99m~D=uPe%`Ab3(09^a@E&--_f0D<|A+TU
zC`&P!&ryfPucZD{U&raWuJ0|Pf5kZk1w<6JnzCVS^7RQ{GQGo5(=|n}Cl*_t4%_IM
zE~*H%J~?RDV$ktJ7LPId(_=pjdyLJwkO-bkbujg~x91aI=n`cP$^w73?C9SpTWtO)
zTI@65h(>ocX!DqnfOZQ9VGS)Xe>+p2u?%tKA$eEqLCCr90fS$5o4&vO$q9}OZ=O&P
z%2FX~J~HU`|KtZ4B*5Qzng$?vyy^ftROx!)nQ8?2eYVP)HP$y4JwKlxmU^n6-VX`T
zJaiO1#2#xAzk7N)0om+a2#}E(Cbd?(>u4JXUk=!|*ih6PaGc@HSfIb5(ZIn#b$f34
zTtfms>!WLPRkJs7D^KzdWY|{C<8r0tIz5{@ir@p)sYd(=mG=8ZSK|m3wQI<*sFH=x
zlvU|op1fZCbn5H*9J~8?eS&uTldwzTcoVTr!3*q+xNo*M_CxvH)h88PR&fXk<`v&P
ztsFL_!Y{IB-|tuH5jGUm{yf@w%r$8D=Ua(0v~J08>9W|^sOV^MNb2Kdmn&=iX$@V2
zOB*<czB26$?C<dC7MQ=mz*J%>PTqTANdBXA=Bv{I_|5!{vIcb2Q(C3pLEx-V)nLfs
zv}{d1P94ie9xq|=h#c}U>3!`mEbC^HTt=}9g9uj!9+E$HeC-RbFZ>W^4(662rjz|q
z@}<7gw^K50`SARn01z&&1*X?HLq&#B2D^>L!*SXSi3mv(r$oc;P^^wT+q{n#cW)oF
zRLSm&pusB*FHy7J<rI4Ll_=JWmb^E6e{4RUs*+S0MMUVUpqATj3NQ>%q4~o@-bact
z2}vD(^qwoo4lUFKQAd$DewV#*#}<BBELAj7vn)U(p)dG#O!9aZ!`7XiJHv~msn=m?
zSr`-y@}6{yw_2sVt(FK7^Rjc{CMFH~+GYA;yUsy`AwYFHNX!zwbNMixh<Dm^IaJ~A
zX_uA@eqMWh>e}j|nms8QY=1r)*W<XPapHQ8%%w=%t-L?$Ltp(&phAbHp<=dZe4L=4
ziVFy-=u%N*0WgMnK56#_sdb)T+P(<P!4qTIR4P(ARw&h^Hw_x5@>xf7yB@`Cn$tLk
zl_Qrh&U`-49ZR`)4jtlg51Hmk(ehg#(BYl5!5{wM97-L2sWoc%R5<)gb9|HamTGd+
zsNLrBuRxE}N?jU`JufM7$#dutI!g8NJnUZ42Um#|BmmY?x%7vFzkj4=uCV{8@${U(
z4CCOe5cWTsne2*0k5=Ltk_*#jv)W14tXORHhTRCg+}@+Bt-StG;YIT0OEmjSvs2y}
z%q4AYtGD3O@p5z3OVdizy?;gUswwP&W@rI+UEF9V2^#V+5iK#>O8Hq#Us6mj`B1YQ
zY}j_*QG6Jz|6DOf#+?<X+%?{(EAWAYa;eyAY5j$*6g_(0apinDJ}5@dnVqGAI}@Wx
zlRB$vXI|>A6LdNm6ksFs&z=bCAyu<@|M1q#4s2c0<p0$DgMF;oWw|7m34MMkCM89r
z<wR5+=2Z}qPfmq*KOxU$;_nXyF?0J4GzAeoxg3mg*{%rKr<d4M*3?j*u*mJ@O$H^z
z#F2vzYZqOl;D@)TQulv^ljz%4)(m}pNaX02U|e0huB|lgO=HLB6OY~^{k%3w7Poy?
zk67C&si`MYzOA_dnhqSjWG%oPcHyykPdg)>nJ)<{j!A0}&fpQ#)uoAy^CRfx8o9rh
zTG}!jn^M?n7duDO;30Ia=ixA;DB{+~FAxGT*-FX8_<OVZ)`sH_msYO>B_!cJHfFno
zb4>y){SOZMFJU3BQw49;B8;<YxV%H>KUSRN4xitx@DgdShYGB{<?Y=!FYtdoYJ;+1
zv7Fop@tv7&m5W~nT%fbjqQc(Cu#4ir6?Jed;q)>UD8)mZN>eXJHY5)|r-e7PCTwZG
zF3%XN>_k9@#!5a$F(OiOs=NFf*;rdM-ofxOjew!SNeP}U;dOgFUjyIi;t|5Q@P|i3
z1pmqZdp;N9%!C_y`j*WTwI=s5#RFr;SS24Eaer2O1DjRuJs<d_#)FQh9$oab<LpR_
zlcj|n)?Y<VFCxfqdcsI=uQaU%XV%r_EoH`us8k;}W{2se|F9ZMg7W($Y2p4pPkzrJ
zSRq}|b8m5SKVyU2<gen$_}s5Ev*BfBWl?A903GIHG&+M+AKT-kLtr7W>dgY|a=tTx
zsOW3q%%w`t>EsWoz=wxMmX}=L$Eb)W*Tyl0hn=FdBV7+_{Y#?(-q`;AXZI;qG^3m@
z6%zKbFJK%Ql2jHpE-BYN1=u@o0Hw=Bg&%u=uCNzLs)6ZjLw_<8<C^GJChD`R=YIP0
zW<`P(7_Ho|W7RyFFtBG!*@6XJ#kt@(2fh;q=rR|8)#JD0w{wL})c@EinR~tql0j9x
z^BT)F2}tPmIJ0$bKRI|;6k#^XO$>D_eLwkJ|AlE~Tr}}VDyw24<V&);49gHgW70Ly
zd1B<)AAQtwt!8N!#0k*bs|qUAFkbPupq*LU6Njlz1NCljH2*NCY2B+6YYJRI9WVw3
z@Z%jrGEQvWGEBnt%oWBQqJp}wiE5)P*Pp2(cIxYD=%y$l{vM>M*dQ)?uB%h-2W^x7
zFz>kJCM<^SY(w!SC(*LOP)BE$Z`@7!<XdNG=&vCh^P<fUZ*@6rU_N7WCSp5M>zvPn
z$LD?1XYxMl!6p@8{kD>D?tX67G}}c|{Sz}i-&_Yuq6+5s3{mPz?*M4WQl1Ls4U$WS
z=&t%vP4*|j6X+xr`yVI2O<^nV2f>3*Cm(F)*XSPnfFGF@x30td-*Ofdgpk<0Xe<a-
zU^Us#{<3L0Bd0qfA0p;cR#aR(UulP2&n#I+r2lr6<@9pKD^~dMMiD<g_jew@Q^W{$
zlZul-;74eDMpY6XEYWa)F0fdN>Nbu-<TeW^ZBV`V(@%QihEkjm<F_SDYNE`7mn05@
zu6nt9p8A{OI|Q^>oc`U{FTVw|QjxRj$8?<^_mswA1~l<b=;QlpY`iP(z_xK&_4p1G
zu2@XZO<rgTuqnN%${Lm{ZH{iySJvCO{4qnz*#x|#c*G*JZ+uAJy|?nak8HT)T`vB(
zaPX^;;gHJL#=mVkoF_gGBf$Kq>6_aR=Y-vbbG+ka8~zm}pZ!1Wz)KsyH{ngbe_n;v
znNn*-hep>soffEw-SS{q;e_AWXh?`Q?=RCe0A(C21{N05qu91z^_AI{HfQ-9*BE>y
zi8Ya2Z<dIp?)54-bKL*Q!Z(`D2`3KIvi;m++__ozO~{qp=bxQ-1>rlJhPDvY1xp?;
z=k*7>lk#@qaullp%OUD-4_cpDCfJz8{kLX1PgCEC6WKR-pQiKN9h@BhHEe<^IA4&d
zV^A$zcKNNFC;@lxMy7F^+g+K(POlcXAQBuHw0S-ytt*>Y=uN&s-7uz$r52~@kFR5K
z4(7Z1ch_qw6J*e=LUt?SU%dRgq^cIL`bRMnndzB^R>dnpd6XF@eACK|pOONVmP!}~
zWg`evbY>jS8EstMGG71EB{F0ZNQjANXJ?sKOTBrU@^gnrw?SHmKh+}MhU&AbJ+N|i
zwZY!w_N!4f)%PENw=``?XV}Nd$1-D4D+UKHjlI|Q%TEJ&eaHWu^fPv!uZ1#-bd1^X
z0l<-VhM12}B&cbrpS~W-IyU?k$_wBY6`$F@@C^zXu)!6=-k&^Yr$MnmfS1cl2S0b9
zQ);hn#h01u*CpK|pYb`NejsA2uG<*ROpl8zt(qXaY)M=Fmt4d~f%kTsq?fo$;*HhQ
z2%^&nU~muDhXa7om1oG<h~u_pRk#*Z6ORDVVtyCN1Gp8l#Av^X>0-HugdZ2qf9i7B
zyKOsiNKIp}_*p4w%51ow>enzW+Vk*`Kf<HUBIANQf2Ygq)~v5t=O(6~amUTHqS%a5
zaJE3PEh^|VG%SR$dmiGmBG1I>#-h95vd|=3r2i@`EZj;&H4K+S3y)mR3v{id6-t(v
zBZ-}044bmn?*QI5Sy55EoQ<hiSw-)hPc@blonRnvNl)RgH;NTn-UtK8ZJ#Mg_gP8{
zY@eyy@#r-ZT;={NebY(~!?U9c({`OD_WKAm3Fg+*Y3enF-wV-tmE#e%eCw(=%WRUl
z`c1F(tSDo&rCpSXhK@wfgUtp;Kc&<Uy%-1h;ZFl$_@LtP-^3M4P}q_fmX%{udN$=L
z#Y^z!2+_Kpb<?>dxlPfgruUhSfJ!RCZ~dGe6&t+rmEUG&s~?FGn02xNz<?>*i@Ql<
z7R=32V354Lyg_Ox4mDse5t7n(U50CQt_>|=4G@14CzXs@l!Z`?%Cj(l?J{*W4VUr}
z>vYs^)qNzi<!{ml6K5_bU$vfDoBQDXB{9nEoy#{HBCoyZ+4=G5Jgbpa(2DUjVy8x)
zrkiFJwIk`+_RBef?{`+oBCjr6yD(i}<SQmFU>9CVxml*L^YpR3zw5!m=}nXij=H(K
z@5(D>wStD(BUm^&%Uy-Z{J-MLAa3>RK@X#1T2z8jh0BL@m`CMx3srf6_tTYcV#rpL
zHm@HYvMrQY#_EwVkmn_e`lyw*+T!;hbk!Qv#O!QbE-0_&4l9yQJFZ&>sn)s6Y9M8Z
zN!uJCrnBZJ$qlg5En5CrIKD4ew(}}gcFJBry7zz-dWoti>O;PLueC2AW6bFTL#wU!
za{pB*Qo~_(rrL8t@l9^U)GRK+t;~dcI8{e@4gN1{=-T>Uj<^=g>FQmvP12PbHV8$4
ztxHyeK2uIXN20y{UQ1hZDIK};aJ~bU>9TGDpN-9mFb49H8dKIt5zlb?;LSJ+a@++E
z<_5`=O(kh)>zcx}&iLcNi%yJTuaI@I^&`qzeaj`2WzmLO8yg#k8Wur%$g?jsGYt+M
zxhBgw<6KWCyI$y^hwZ!aQ1{4~U6EXveroy4s}B)<oC%<j%n6F6V!>!znQ4Xa>HazK
zUPDJ^6fW2A)&A5`;&M^C&!zR75xDMctEM&c_D%dHA6nbNcj@v}#0|jxqjf^i)0_vk
z7jzsAy$&_3e(V?%1qjeNY$#_}+Cl*J2hx$++TlYs4xbs}UhtnYZZX-4>T-zp)=Wmy
zJpd~$O`4cb-vu2{iA5$P|Hyq_hVPCSgweo0Eh<ug&}<QQEDLAVLc{4^y?{~kv4p<y
z0W*tFtGH=|g)c&i64eAryf@Eh=Sj;ASht6>b(>No^7U%DEUeqDq-!`zik`B}D3z*C
zOPSYqpHFxH<;?NN0W)R>(hK0cDsmdLXmV&4m0t|0aU8E+Rde!+Tf4rTggyF{Ca3DP
zs^&^|_zgc}8a2d|OBrbHFmw2n$tKB$z=TV%AdAt3HhI5Y@L!pBJ6A~IG|qW`=8mvf
z`q>DMoy`&GaqijAwG|KfD*b_H2qNcA{+px9HGyJrnEL#I6<<c7YCOt03X>+*O}~tT
zeP*uC<lvLfIyu^J1|UJlEu}$S@Nz_zLFxM#34~AVH}yAxYB^Kwn>wwyt^0*qFKoT(
zu$gPh%9EU>kK+eu#aG7(J??%%yHXZByb3ZW`-xqVYB&3dq{#%bxHPi5DJ3Ku=n9EA
zRAdBHWCE6ZI;J%*3*V;Y6Y>lj9pMnnWeU!OK5F+SjSd@;8+BFF{vI;G;PxWZMR=yS
z^hoqy4nBzjKYseEcx~a8w+)xEAYsllU<RKpTU5#IvAWWisw2O(-|e(2jGrC_M~;{2
z6G(YB_Ue+>xeTOWN#Vs<rHj^`1BL>_b@y)ouR!X&QJD8w?04Sx84U~qYnpl*Ggry7
z`sf-y!tn%tCzd9)$uN>2$zs#+>J*XAIN!94nV(==#`U)QQiGNR;(zCNoaf%P>27|V
zxe;AzZ)pBi3|4Rf*~nwv@~Sg%8rrRz(yI@qXg1DG)oV)do1$WbrD&BEs$v`XADjvk
z4Tm^<K?fbvjBL^VEW^8&vB=WJA$cQL6A2DCR3ij~q?8cqF(tzautUxME1n9iY09jH
z3Zu7r;nP&#1>#T$baZFBb2JTGVt){XYeKjf%2WK+@kk~>d$~r@O01?qFMJ*<Es2A~
zY|($e>k*CCUpzeKSs7o#fXJ`z5w0_%aXEwqj&>qEzYJ~ZHg3GApwi7@6(=LHbjl)4
z%O<X>c|U}v0Y;#xzi*7hUd{2VXb1$c&Th9mKqYvCr=ra~)CguAb5#1xiY`ZE{T>r`
z=I-#KHCfS~@+;aA=1Dqg^<o2@wfvLcsLrNq*76q`i;jsdF%6idkX;XbzapoTL%+4t
zt44zYb*;_w+9mBU^;_bf8u>`lQzaGL4=9t4&iQ;`A(wTjpc|QfhHQl$bd<N(`+vJU
zP=8jeB`2rwVI&eTlrjH%3fvoI<bevMBZ+0_Ci%UIbiZ)!0*#WLa<&@ZR(N#G2|Raz
z)nlg21%w6w-nKELj8D5MU)jw@JrN=euZvcyGBt*v=awZVYHBZr=>!ST&?M7F(`z^~
zzp^nveb+g{j4PWL3@aiVlF9(Jmp!{=NS+rDRejz2eI|vqZsN_E=5rMU-Ts#&X#DFg
zRSM^5wr#ZuUhoKcPEJk9<>0g-PR%wOGc$PjQ0OM^Aecd_^c5;pZZKyl$Z6VD4*mVO
z3+k%u{tQXHAjM`Zhoq)vf6a&x_~_qUcJv@dwchHHw`lz_je9Tu_vpU>7pIHiZUJVI
zVYR!!XL|<j!ju$S2(BeR@sXfI7<w(j!I#Uyk#{$6I3E`j=p&J<+6bI~Ce6!}VVSU7
zt+hdOS?mV&mVsPW>Y$eGKZC6j=B1u8P3N&sFbg1R2-o5DTXdau^+<K4atLJ8qQJ7h
zT;}Bm^I0N2yFtf&rV$hT@LcEu{h(9ML{qcQZ}*jA83Lt@adTu13x2=N{qXR2*&`x8
zfM4vi@&50mK0Wx1{qgAMdF?yhphSXg?ci5q^}9;zqx6RsbJ|q~%E#k2RsC+}u?XL7
zGQl+r3NmhR+dUS-YCoLY{5D~Au(wSaa1OFnQkodb6hDcE49UrR+7qKcfb`p+;eIi}
zi=AV3IB|)--&{h5kAwcLEw}qb%%WejBG6X@!yq!3x-9OmU7=SJ^NM(cAC~^SHa4iQ
zi=DOSWabPy&r#bAYH%FbkZi#?T`!flsUp<hn<83+Zw>2|WHz5ag=~0*`O5?5mRJ`_
zuZnYiv)%d4y0C#(o9$uVN<W$eON{QGLYluQs=)({O?t+-+a8c36L#z%a(+Q%@g7EQ
zdjTHm1NDyjWnFG4`b=lp<_*c(!s}U=$E9Xm`v^QeD<OtOwb0?E^o!y7A4Lat*V$z0
z*ql>cdaOY1PcRGRT#qe><OBqgn$|JnL3V2q`;I0U^i>mKNf99#c0KLZv9TP$Hi7MA
zDy4|G`&jjB00WR6O2SpZ1rHtN3p=~|l0-`<bMOGy(GkF@yrg4cDK6~gQ~s3qLWYJC
zPXPsr#D9ROEq_ec1akurelWTMnj1Ow@MpSQE5C{i^>%mI4bVZT2NBLdc<7H8s=ZpU
z_E$x17LH%cLDW4`t<Np1QtU6+9l%3!XJ~Qk`ortKHIt>;EzRI0X~QOqfZYN-g(j0R
z=HkA5Wfo0s0G;-fwh9BJ1Xtw~aRWQux6oPp>cNg<H$T(hgXdR49W&R<_JU+YocF-(
z2q&*BQ!sMK#>zhQ=5X<kkjX-q56D8JPCAjfIN355n$nN3BS3(n{bHf6f9)S&2Kt1#
zBd@~mugLYC*2k%X6@nMY>$HL;CjOe1fy&C-`o`L_V}y0yF^iTwJP3duCcU`no+qj0
z4%u+DP&5dZK0gVP$J)vMt}|=RZ*0j_^&y!m)3u@CMi<vIwo9_-@b*yS>M{pc=0Qq0
zbz5KemyF4ZMeL91&2F!M8^ctcUBPSWX~RaFuCrcW!=ArFsbn$Ny2BzNnlY2}`8>2}
z2;isaNNHwN<0V4GSBp{9V#rclI!Q=1#zhULRw9W=k?muSmMa4D$Pu&DADrJmNgHTr
zOVEV&#uQR3re%sEc4?W}?V)`@RJcX@n9g)Rv6xBj+Nx;h?I`G=YBvK&tZRNC+M8Lz
zqx{LmF;Cd<!fw(ncNcnXG&LGQ0l=q$XcYA=$RZoVGw^&>%LE0IH4pTx%>e2z#Qns4
z=|5!qsAqTV1LAOs=)0f(bu~R&ah>LPwsmFfkL2|Ty=l&^q_Tbgx!bJ0JHHH{Zibz8
z<&?#WWWf9<*X>}+8`tfgu;`U$6+?Y}yQKGL04iBRSi5P}k(b}I*!CtT#osJt{~S&=
z8~+QR1~bL7hD}lR)sBW9zeiXNBAO@bA0DHbH9Nyo<u@F=liruCEf7+^mI2^ToN5=8
zXRG<M+I6kFMInS8<h!-Uc==g`qB_@P3H01k&ha5ry78dzvkNriV%?xnqkf5f7UJcp
zrCZIFf3=^eEdqiC;(Y~&FK8Jyl}!vSrT87@VBO{iudWAeOUWb&=YPf7a&L7ek=%$B
zsgd?S91iJka|yl+pR&gHd%j(z(*JN5wD`uabWAw4Jo6g>H!;k8H$H<f<_&V7qA@3Q
zBUoam=P@v9_3r|RDE5aGjyAs6K@nchow*_X(SoVjPVjZZ@L|W^%>yxAv|X@8o9US*
z_)4YLH^gPVId$I3%s|IZrhNFAgs1G(_Eg0QdDp=n?7O<wn4HQb<#rm^|0rE{pyll>
z`M4WtWgeT8`&F(H(y$O#zrxZGblJKPL2Rx<hxzo|CszHVF27E|UA2Zwk8t_WZX$oa
z8f^{NfMo`^#Z2;xG8%Tvr@{jR*>reK0ug_dxJ=aFQ49KLyBg;l2RN@iQ!nCfOFOfD
zPKx<q{_G|&Ke>HnZJ;%sh$>Imd!{L_d*=F$a-#3__h2;%{$`Iz{@;IrZikq!iP#Ox
zp^feOH7IfMwY0{5tQP92%eK}(8JPtBASJW`U42{OmjE^)#|cp_?O*RY>EA2APTx>v
zxqd(vA71tD&)3U)*0U_4FrH%47?T#6aV8UOe0=S*wov24q%Z~K-#c&?GFf)n+|to~
z3_rXGt0$!by5JI(Fq2l1fBN;h`oM(fvm}ChaVRF)jKe~{DU)jM{n7IFq2TFS+imUG
z>8_t?r?Mg=`0nXds>R!@1OEM7jegV{`&hMa5c~SVG6?HgppCy$O|{c0sX(Wb9NTZT
zPu!2krNX&z?|sn-i)$83|1hCC1BKH`MPw+1RGRn=atNh~Xes^dNQdrNjy_@msstUK
zl<%EzEZ>4UtdDQHB5x@~ciaQ?;|WkgY93Q<brgY3>5(_5e)DA(afLqe>kT1xva|e!
zE=y`?!yY`i7W*t5hD;0?$LmF)yvew({j~vo_7aW$_B8xFQKN(FxA@Uz(*IzEpAzwY
z@eD;nEMmXOVI*3pzqI?K9YToO<>#9v+MA2PCyRMqzJn26kqJPG@ewI4*{kC;zj)Zf
z5=28?Nk=6K2+$Hx#20H;+|SIAyeXkc`zxu92sGTSB+r~Um1nE#d6|n9qgh2*pycvp
z#TMv#G^9t>;uz^iaY!=Odpyo%IB6CZ{W{n*(8f>k4?IB?pGv0%2ZlfhGBNvd;cru`
zO|zDG+r8K#)I-&`O^+dR--8v<iY0qqN)9821Y*8ezp4&2C0VHpvLC)FM=K~SytvNt
zaawAVI@R8sf|aTg5k7`VgK_%J$GI_v$cK4b{{r-)^qeLY(KK|bF0z@UWkV3oqj9@c
zT7;Lb03L92{A0xU;`!p;`Bae$1>?7-9>XXgalD0ZNE-c=<#!pUxrK$_ztsZ}?jZG!
zSsOmHR9hZ_^82#o2%&!>oA@*asW3}gvftPEX{j7{4@NTIAh<uF$+A&)hO?QTvFhp?
zcv-_{tEE_3F6pN6n^dLK9?Xveh(jVFhn?A{b(A$5E3LG(b>;Z-{&jsJGo<88&$`(M
zt8t!6<_ozne9I<T`S9?iD%^sb)OQo@HYF`84g?=80Z23G2B|NPYmvjM|8$OzjjMY5
zbl$`lLK0S_c)Gmowb0M<ikD!QX=xqere@T{7!dnwHM4jNdehqFaa>#)o1#99w@+Wk
zY$tcks$QHBkoF_dvZ}&M==^SvckgV=n&+ogUH32jxnEy>{M6t$%eBt_d|$ZBsvT~S
zy1nC8mmuNUGoszXfcf_HEfQ#bj-rE*!+`O9Xzncfs1*F=gN&>+vDiauyDAsT9o408
z5HU?ypL$po%~QzNk`H0hkUo<5zWhq&_grU%)W+58Cc5|{%;=#XadrNU1@fc;Zt7rp
zL2!;SUiPuQkt$PA^?MI$9CDvS4i3Dm`F@5vuFf;$fr~;knu>X+V5f(pgq>jc*aL^O
zfp=S{o{7*+n26cB@DXVToa#1X)gM}<Ci(a<+tnf9KzMDte!1=QS+{z*5xBcHv3#2?
z88m19UFJv-{O4b(Y1idsq<FozN)O1p`v)RgCTvn>KVaQC6Gmh^@wk(kbyCt<8+bjm
zJhXB<Pn6VjdKSt>w4Ecl%qj6k;G2Z4S`O#k`jJRT{`e)ij7|~5Zb!`(*F8L>!r!ZB
z|H0zAVU{zw7j!T}v=;2}Fx)vpyv%Mt-Ms1{mHqM?@8#rgfs?xK0O_%Sj<%+5I%tQh
z*{nFZThi+0`M9GEN37qx?H4c>E$DuKBte{;v)aJZ=239MlJ<E&hSQ+#`Q%*^<BHfb
z$VI~Eo6x}NEm5wBiS9{MOx&d7IwRvl4W|vf<XG)#cVAHAF}CfCKHh@BgYxF$%S0yZ
z`~fAm$X|#6kU}=7dt;~pcBRHqu+Q*ao}fEC){8(gTd9LFNoBTt$Gs~y3+Ar{LF?Uz
zuWol41_a2Yyy?fdX=s{r4Bq<2qhn(l)F0?2X^;wREp63bP^DGI$49qXEPQPk1m2gv
zFSMdf*v?(@Ioq2JYWH%?oAe<6;2R`3TP^W+-f2k=m-J7I{P4{#Q+E0UBRv{b&-Jej
z2Y=A{L?TN~&tqPxnRD6?af=m|*EI)o;xwF(zNQ8SfZ-bwrc0<RIT0Q~w|9TD#3MEU
z05%h=bun&WR@z5U1}%5X>&%|yEK^NNo}{I8K83C~AE(l5Xw1~&h%tCB9+)L1eTc+5
z>hO7)YU**Gbj(}paq$7G_hl5OI0zBo69StR4?#LUNmJj=T)ju4y%OmOb2$K=KQ)}L
z;y(F%eM$RH40@7%ZpU1X9veF%bV#VqpjgUz0mw>!Oq|tp>R2z_s`nym-X_T26lvD#
zh|OIUwWfl4bcj1G|IAd8>yi5IwGq`v-Q<+h=``ORXXK+)=sBSy!TUEces`OQDCK7<
zLt3g%86-7xrSN(Bajg=u&eE9A8toHAjoY>fAQ)V!Kn8Jk&#hLmtF<p^XWRG~qtS(y
zsc?%$(xQ>?E4-WAyG(f;tcv@h`~x-y&l8meMW+bwq{fd;ztZ>LOM)&IeZm0@i;KfQ
z*n4hI*s#)e?{`gOl%mpr#amY-9@+y30FPMIcNXJrM`V1G85c|AjWhI-WAH0<mx(}l
z+gqmia#Nh;<K~6*GA72=oTRMV5&6sAz;5Pp;I9~HCqEo66ujDgIGm?@bGqzt?6Qn{
zeGK4Pt><HF)3H=N8QC?<sI#BSezX2`H5Y3jmo;e5LzI^M4%sCdW4+dCw`AE{ASO!K
z`=Aj4sulk3C*5a{EcDpU2SqkObH|4h8!tN4`emHL<W+HEHGTE>lGAKsNhG$;BTpzL
zcg)@lt47gyOXGYWu@fYff<HalQU#rKC9EyB?QS3}0YEMyhl3UK0bV2il2=OEb_;dh
zw>5jd8~=Pdz%(REULF1S!p+J#8F+mtlGnonOF>8oU!0G5@q*I%tndlavj6K+lXOYS
z)%0!tH^Sn={(MlBr(6BF0dJ$|@LcG+?Y;hlif9aL4_N=KL}3=#<G%e+C2erLTm{c5
zid3S#M9k+Hg{m|TjtsHhNz!G977Dkf_MkPdB)^-Cr?za6WEqC_b)jKtbNhaKNG9}U
z^Q}h!Hbv50&|be<_txbbS;Y-~LaXt5_TjqAb&%8AV~s_uySrMj$YWKDX%H%IJ>Ma<
z9De!1#&efX&CBx%DDE;jx%=|jSQeM*o0vCM`o&N{4&Sn);qxGNUf1x&(TgNpGd1O)
zraC8!d!a?1Xy7uk!Gn!8JBo-nVpE?G_rnKEqo@1FL}_FA<>)SD*Gmh~Oq_3jtuT}i
zMisd8A9ZBRSl%w3dU#jfdG3tS)llqtwAXZ$tpBJQD-plXKez<QM{qsvz*wNFx+W*@
z(;QZ}{9f8Y;@7^Zm4+`@pQj}x*Auy<Ryw!F9Nu0V-SyXtQTalsd(6*jrRAGBI(&{e
zejftRcre0nh>}zEO2pl157W$o(;s)x6L57NZ%R`@Jgg!o&A6plmFs8Ip)QhsOyaD8
zBbjD3WGhe{JouoG6kC0}@4caQlO045R&;MAZ}PHS&$ZL@V)%#Z&UJDg0-=d5r0ef_
z_?Pnq`qXi<b`=)s5nw8G{-b<a&t<93O@6MC#G@TE@9wnJ^!l!|u$L~DHNoI6=rys`
z&o89V^A}R7=DGR9Pw$MUCnZwvE$2W1K8LMmk=vz{_&a$bh_l-xhcjWsZYE0z{Pz!z
z(YmP#yA2*gBfv7SbUbz|k#~SQh0L$QaQP~EV5jajjtaj2<nlg7NhBBVP4MY+QF@=e
zhgykeS1JzeTVUk$HZ}@pdt}2hOd1?j==!Y2BZngKxEF-*fkU6}_#7K1@9r8%s6dQk
z?-PGkeu^xwT=7~~=*krd9#=@U=+1menX-$D$H1;zE~}((QL@X*b?4tj(VUH)8>!MV
zY=$ZT#C`Z52fF(gJEci^PH1#=Bq;MrzC^mm^M#(>_2YfW8b+Wq8J*7yB;)l*-?ZK&
zsQK|R-6l^l*P(ucwMrRL#o)NNu0T75gZk%kP!->g*7u^Dh&4H_b2|CV^&u>>r2mtw
z;i0t#KC|4|ytDl*kedO&PWh%zTmuJ(<~Fti`0vc&;DqAVAMPV@adEC?3prKaJ-^p=
z5eb~mSIz?b<u}yvsAl*6vR%qCbax`=?2waa{DRGja;Mf#ehC%MIe9$oK7Q_Snbvl?
zT79{Heq`{we<Mp5WefGv($di&004*&fjezMyP(@5r7_m;B|Irs*vT+`5$00c=A4_W
zPnmME(!Ge}qH=!%Ll@aMPkrH1?D7!Nz&|<|W4YMaa*}39H1uq&*KZkP+v-5;C&YA$
ziECL+8;5OXdZ$d6_sBX#1Kh+Gm5^Od0xKPz3eGH;aCDi*2ixw8*g?xJ;Z#k}bvmth
z;O;?&HObCXH(R0W-tW5kwVW!*fgV*)9ErH~3>7OBzm8qY%jO|HfNH(VX?}d4%Tz4?
zw08MfM_=2qDbs~i(DiU9N3G{h)!Fp<5c(odhcB}F$(c;#WDYk|j$Xr@`*Nx?JW3rz
ztzLS1H)X|iOEuB8!L64Ivj(uSyGJalfXlR{3XTH7<q%w@{X3o_u|}5w14`{O88hR_
z^CXID()&MnTs7;hLHC()ksj{2G){(08cO^+)ALgMY*x(03bT!uFGf|_gA<o;6UdD^
zEDrg&pdX|E_NWPI;0H>AO2<7rCj9A{(ySJm_gTcDK`+y++bf+KD$_Xq?8co(*CY)A
z*j+*WOK}{0e<?d{mAQ#!Wf{QsVCp9K!n-E;W4^g7V$HOsmt7_QoGwLA`Dz~@edoG1
z&jwmd4q|s1tvGdF=)@!W87A)$Z@s&d`&&Nw0MznO{6Xdi*Z0J1U!7Y{KpR5taaA>^
z*+RdSp>=Q6u=jwg2_GqwrjwRIwmI5(Iz(a!P62QmD{YyK2rp-@UB@)|)jJf3ni&(A
zHdZx{#s6|uZ9VXGI&JNNdsjA>hyCa0;pS~DTfguybyBq7c+NdMqJsVobCRgA=b(<;
z)73ZuG9jl$AWpIOK8w4$L02&P5OKM^i5kh(TcG=STD~*@Zj#al*-=I-yqa8=^EwP%
zjCTnAaJPjpLq<)?zAw{UYcJ-Ug}+HDFM7l9a&rSuFTAoU<><!hy(<9!guyt&b#pjb
zvzBsb=i)Ayby=~f(Kx&$!G?9-YkD!?D>29=_r67*b~|lZ5r!3L*$h>-luA5Zu?0mY
z5HQdXe}BB%GuHXkY%qRPc1D%<a&f$sB3R+KaQ(@q`zChP8Av>2-|#unT#&SiMlc?R
zBa<K%=z}=CU4o5s=d6UG9`#b(u(;itw)Wu$E;TCmG1=T*%tYaUq0dYg=*^C+8B>St
zjXzUw(wVz#^*8(+qD-Vz4L-c7Sha7+WLgyxJe}G9;?ni<SB%OsqRwDk?HQ5Pm>1OG
ze$Ul$L#Y%SQzsWeMz5GCTd_D(XVNayn3q=VJZ~%O9s{o3LxVH!(QDMof&Jj!<u1?I
z8Ux(IO~9>9E2ippXXB1W{Dwtqex=Nk@Q5X`7MF&9yD26CUK5U4LzgRLTvG6ZtAqfI
zZk=RszLf9q9<D`!H-fv3!<+Q<)^vrAS@%A<Bz#0z%epLFGn#uy=WRIcPY7w)Ifa$;
z{@lJhWizTr!HYIEbDr=I(19`y)U8~R!!ip%1CIVYMuNKRH1|FdoerOpu#nllt$*aw
zxNMaWV-%}&%>4UW;O(?tN%#HJXEl=m6)GK#0MFxIH^=aPmN6x}vYcJv(&?@j_2%j0
zZ{K3=a{m7Ebxs9@_m}HA<H{8FE?1@;^CZmgUO%uCHWV_4eB|aI7|ILCSKB7Cp^_>n
zGgKM_gLe?w$f?Q6r&8G*Z1!^Ynt{fRW5=s0Ueq`kCC&C0f@E)`YnRzW%>V3rlF^UY
z3p_r(YFW18CuS#1D*1sp@l^9f9Qa9>elkQxhT{{Y*iZ=n6>S45d&&aBryT`pV<nsu
zR-HegIW4u1*)%n}BptZ68>C`l*69%1J%1g8RjpArXQ~8XQ(oUct%}*A{>v{cv!D@7
z1xCiVyWFd>?M!CyAWk5-*w`rfBercoQ1?#Vgl6IgAOPXJ6wCsAIP`9U&CE*$pRe9C
z7D-NEX(?F)J}X9%FR)cz#GZ`q>nUhx=fY0N`9vF<TfT)O38B6Coy6_eC}%wkfy{ij
zq+7{An}2@5ocytN0q1v<1a5UxY3E8<<f2dg&@sVd;rf>a60?s5$x6uUyquNtHlI_i
zqU0d%h^zRNUApUVl~<i2g?0fMnC7*A%)ho^iH_c?I|tRY$8T>>lvP#Qv-gV;Dbi-T
zRVL6{<<jPF`y&%8xkxlKmZ`BHYH($K-&bGfvoBZ9Ju=0{#5mzFnSXqTQGKL_Q|ho;
zNQF%~LdZ%)JT)q93Pz)OsAJxZe+vi(QPW6zKOMKo$$^EwA4VdDvCVhCjwIwV(a_Z>
zXsP~k-T#|ah^s=JB3W|_8%3<iMd+b~j5Ejp4TbpYXGBY|X}A6Gi3A!=Jd8CB`I)n0
zw<rG#q~r(9ys?CD?<}U11u6=$v0FU(#J%4jq+yWZft@rO5`G(cM2omMFebTOsn9Kz
z2n~GVrtaN%zjf}PR`UQvBoTvg;&(wrv!nFcFYg)XanKl>9C;3ga4}1#&|jgdP%+F9
zp()Wqb;ZgZ5ZU7bheF9IDS9`0Isq3TvoJX{4S)uZ9Q^TSAEe{b9l!e>QC=cUHF#?S
z>M);rp8$2i2|ujfhhO~^V<RW{tXnxcAvVaJ4r?8qWc7bO&3-w2*re<;_q6^OM;Fng
ztZcW@!-Yc3&!X0S_nh_e7|Rz$K4wR%f$wF0s`|Q}sY5&$654o>A+-(*JOPzMl-?cB
z6~pph!Ig*PYQ1<6Pf{3pAD#MKhIRHH%4g?~_APIyycV-9VL~Ce{?+W<6wOD&&-}LN
z7hN@#sIW*m(CR+Lf|1ZpG=7`lcQmVx7&R*00JpM6TZ{#F*m;}4yC~XN=E46Gl8i3o
zW)JYnGu693_~NM0->Jggo2;oaO&noCtdIUKn2A^XpQYNHCZpK&a&h;=6@M^<$5cgQ
zmhjy~4aGuF$auWt)~mUe1`T|Gj*cQ^<as<_aa1JN=sQT9j^#xCgrtam&j1r;`)=<K
z*8V$)66>ycb{4TBE+%TIZUxZ%CHQ#xr`~Cev$C6Ar<1vXuC)Op7;%|qj;lG_vpHS{
zu?t~a{lhL}6FL#|to*1e5DzpQl*c+)W#nBcVYb&P|ICsC%z(A3W*m3;?BkP?{`Cdj
z%B_FfzPt~WCZVxzGBAibPXXh&@7djie3DoFmqRNH^P{Bundh(J+Wc$tCL_+$Q5&t_
z5+DMC)K)S_{cW5{b~X`Z7#J3~$@(MfUtr?wLya?l77kvxUS<7=w{v}eLm}+RE_CZD
zO(PSvD-3p<)yI*G+9pP|QYtI7Z*)&ZP0>lQGaMTLBj^;<H`$Z66z*ftX(;8Wra@2T
z(Za(cq6?9*{in4wHJe}l6d-C{M%l>O$K2T;J2vy}={jdi4Ok#bXkRFamfNf%8)yD8
zx@yYeVVt!Ip^Ic=B@BONc~=*y&u-(pN0xSvp60ZW3Sc>2X}*^5F|Ii!EWu6mU>Dl;
zJsHuum+Z;g6^^h77W!#KuyjCDqOGe9wzHJEj6Ys3K``bY#Gv9$8#%r2DY^=QWO9_$
z{`n)fH0%p3*efVq_XnN$L;-Q+6g1@Hh_4<RZV_ckR8nsBWv%I&qi!pw&};ED3qvOX
zTtsCMK!Z5qKQSpMIYZ4cLY4BFE?VTuOW#fctVrl?8a<)}$Qe-(#fUjqm^Z)bdCF%K
z^G$?EFl|}vc_?_5H_6%nXn?h8-#7cB!O?}UA<H)G^+sCZv!bfn=c<>Y4+jQ#r>8tw
zDmD!xRA|EFlZZUe2FJQZ$M@)%xQD)=PwKBbux#j*GVB2i&`Y3d4ZR}%8)$KpI~J;3
z^54<RZ`?zO6+Nr1(qK^arF?`%k)w!~t_Gat4e(qbr60lJ0LaM-=S;ds79HugN%QKD
zGj^<+F3tmRL+`2664=KO!QmgI14pNn3US|YV&2gWm`7Mf{|Ih;H+c0VhA<S`1Xko!
zWXqxg<p3Fvq!G{Um3B5ap0N2tFJTh`thZB9v-UJ7aRGO;Clq{ZnKv%KHG|%xAR|1#
z_=LF<M#fv7?c6e#gz$ETLuRN4F%4jLiBYI0KpRvfJ;SfrWt%~(#G<34GR<E!^?jxu
zh{%GRfWb2DKiw*Eg>aekW+*diX>0#nKK5=~*(TWL!4)hTNJ&m6j$<sEiYnl*{=B_S
zaR25FaGPL|q1d@4l6I7r9qPe8w&rKmGm|<Izmq$~pO}m@TVw@Uq#ubM;>IY}raDCA
zsZI08TftzKNrsF=!-Gqeb8I&@zuaXI7B{mbSx*>o;lPoR3$x}Yj%6%bbR;A_)5X9{
z8iw&@an;Apo!;hgaI$c+aB$TybFd`=Nvsgw?XZl4m`7q%bn((WkpXi#UHqmC1tG{6
zL{I<~c2@g`@Y}n(3CqGF+RcbhUn}&gf;d~25uUz4$vB*l-3gnd5$i<RK6CC~l$xGq
zr};iT+es-;exV|-3MR_VBHQ`qKJ(hj&R^T!L_}%$DanZElvr%i?fFbuig()+*j}jS
zu%XrDQ^nfTQNh8sc6JKZvc58b#(~D{%0ZDxFJ3%bUVbaVX1#}(2YC<3T*PsxNmI;G
zq4d!@ISYuK8AK8o2gCXM9xFr^WX{`luaYuZUIhe%;bs5VuSZ4b_s_Ncn;iEL#+bH%
z`u;sUt>P3=9NBh3l?nL*u4N}9wZuk8k4uP)OK?C9yZ?jwY;@Jf)U~zi9S|7u6?*6)
zoI`-cG!$heqWHl{H>Q7|%zYR!QgMggghNiYD{zf1Z~gT0Va{dAR9n}gDHB%)8JZ$y
zf;bZnR|Rr*Mc}waQMCTmjb-GI<*ZVyFN#qmU%;BQ(K6cB*7|l)rfLxvgviF9P{R-k
zqy}3Xocl@y=dDv=pgz4q0J6(R6KAuEov8v{EjKrfsM+3ga_D&|H5&4|cAf}8qf7EX
zgFn80peIQi{`8JT+=%%syU<>I7y=pMb<{@WyJ3Wp1f9Lrh&^ljkw5z24y>!djl=oH
zTRCBa*@Re_0fEMR9TTVtRN4iH;Pum6-_8(o^;ASzoQ}>X;&O<tSF8l|GLc@X@b|g+
zaGgIyB)-f1dl*iA;6$p;)F#3sV7j($cR2alquWr1r3;ZEA<?0m%U@$}$W4rK_gdNj
z3nff454!Cg(AoWwIzPu~D~!hmF%>q%HX{d4Qk6?vS9eE*(_Zintez5w?Gc%t3N9@r
zTpBP=9L}h@BR}b<PoErh9kdY(LZ8`_|Kry~Y#IbyxI^6hsEN@~xAQCQ4X;_Q{Y`n~
z*vH(&nJz+^-;+ZTk^J|+A}<N0c(!wD_oAvkODftM^oN&=-H<PJKbjAFR|R-}F$(Lc
z#!bxexHvF+Hqq7&#feUcyMHJuxA1P5-oCkqyQ}MJr)bK&D~>9JSoK_q#Fas)i_t7J
zHYT$<q>MBvDJVbSQIMjI`uktc*vn3XFot;<lSXWsGAD-4YHQEVxHZ0dS*eG2lM_eq
zkjBXsX<$226JPlSNh3-Q8E`O|>t&c{sa$oYwN<VkUzc4J$RP@7)b*qEb#<DKtcFSC
z2GK6Xq4n(jh|m*8|6V`)u97hPvkq}YUz^{X{$UASV|~kdgH+J7YC^RWf1J9^^+g<x
z1V0!@iNA1O`#&Z^B{e0VJQ?`Ls@)zwS-8dP5JjMo3~IJMt}zPm89RGx4F?Lx1ES!o
z?p>p*R)N(x)v@*L6&gQi>ZUBBA*jgpx_*sRgT$W;?V8f#<dP^2J0{*UaG<n?%vy5`
zDkMrLvVIm+xqOTK3iMGIAD|H`jX(%pk*IXB%<ox8?=-?-R<xG1{h2~BuG+%;ZKRA4
z$=Xne*8`%!>sJbc7~z}X$K3uwAl9VaS-Ut{^GU6NaGsO`+U%IJ3`_A(h>UAr53UTc
zMXJ?Ov+B_rkCVfk2H5U)yixU7>)oLEu%1z+JkMN<n=El2`dOPKi_$v@pAV&^+Q3+Y
zQ~`wHEt)d_j)6Mj+_31RyT6k2N<G{;kh$2ujvNhz0H8r2z&r*ic`shdYER8vG}>rd
zd$@Eu+G*d<nG)0{OXopUz2b4Ef2ezoCx@MiVR;?)4?6EsA&Cvi%lG5_BR=fk`RtWd
zk0Yn&<>JDt7!A?wL4r$xzA_gg;)G-GLe2S=3Ynur?Rc{)31ddk`gd?PN+`b|h6Nz@
zLv&?XW(foWDXTBE%Y@h)0vj3(MFO95MAKYj>zL0VC2s6^7_6jIkiRAzmwUgsjJc6N
zv-F#5Y_JqRe^l3LvWKgrP_ZI3gP1-%6lwf7xx0S3X|hw+yrdYYiue{_LSzh9u_0|8
z9ejW;zQlrmTGeySXm$l@v8>DXUk^U2Nxj|*owTWNErvg*s%J82dj0k6P&e}7gJV}j
zZSj9nNoL+5_K|wE%-22!#wTMg9f1@PCjS^cY{A0h4>H_g*E$UkfB1*eEf70-xPH9t
zXFW#0_A^yF@2mem>dF7lG5$X)H2?3V>Hlj5I-+j;|F&?Qp8;bfl+>uluZ6=apTo=i
zQ%5bXkHnYH6v8f>e-GvtpEKRgQl$}P@0e(BTk=N^=NpPH_v~A-)sg?(FAca_@mt;e
zs&Eecc=}LZjFtT`$7Jx<<9X6&O=Q2AO3(2Q)-qw#+IX<MWX4wwfkE1(ye)N3w=;PH
zEM(GtJgBAf1BU=LyM;A>5koc4gz(vLfm;ZcdR5F!gEw=MOxvj`5lz`V0h^7(CmG^y
zp0h+0oY1IqHRH1!sp^F@STtr5Q+)2tf`pD)Ha}4AdSGXpNHvoeCL6rD-UC4h(-wSr
zav%+NyRYfte4yr$+^I1e+`Q-wc+YS~AgflhYM*<*WxYE!J6Tk5TYY~NK@)^4qqY9<
z(_iMwQiMm+=6QUV>u&O3aJ4i1^L39v@KtS+Sg<RlNs#+6HcTEn3n9r|$Wf1n;<PQ7
zagX0Eg3l>4AmXWG-G=_{jNm%GHVcLIE(ghJvuy<N((Y@;HL3fbNH`mEj%&Y){lB&Q
zu4N$zP4|?^YpdB@k3Y3O>4E?Jhs=w@%OoVUg;nsu3?cf}I1$rwl@0j&^FFuV)?SZ+
zI6~CPy!$|%O;G>$?u3;9HkmU2=j;D6-aTL5d<?K-*4S$i2{{m;-{RLo88#mK5B*s|
z&Bip?LMO+7OZ7#R1~FMz^oKtxP7=)S`Ghd`1NtiV()3bZdVEt31pJVkHW*d0Z6gI)
zKu<*jcj<^%=hLss*NdRoTZB3gGtoZLQPHAZF}gV(Yu$BJHR&vHD0TMI1&J|*Qke}p
z3%s2Ff^d?p8Ka%0Y$aGc#`HoZ=I=V0Bd6nV>X+Gx;L|-MRWG;x&ks6CD0ib5LRlr3
zgq%5uiPYivKepX@_7tFnKu5oN>`=AhOT*vDlable|EjP5lpfCxEQ-{Ol`Zx67o0z8
z)&BVtxAyD9xj|nh_}9J`w%uhMU$tb_ggpwAtLlTU9h7N5UF_%>^_4mM;imJkK!G{j
zSr>nKAGWT(>8Ku7yJJ_nd&`A>ZL>dxvs&cB_x4=vHno+wEVp}kmC^Hm`>f{9oVX_a
zNB`9~JL}^<t~>a=@1IuvpP84_YkBjvS$=pK)_pOsov(b%K2X%MHmluk|Er0`$(EtK
ze!wy-vi$jy>8sotR-dx{yWXev_2gCWOLo{yUUp^%Fh$?b&-uUqOZdg?ufM#lW90sB
z`u{@<==-bb*}XenpWOdX$;y1<>1kFUn*LcbgueLoP29Wbc)y(4=c6Y%7J}mUd6Ca7
zqs6N_SI-6||K`JGt1JJ!NCcYjxA17&EBkN2)b@2n_*NUBrfts?&VkbJ%b3vnmcYcb
zrrC1q)UH+GGr#}#+nU*b*SP%QCHt@kj8hKy1}D{=S>J6p18C+|>B+#%^{@0I`_<=x
zN-b&oEOu7?wKP_)1g7ri=WF8rcVE?hXdFMs2I!<v`+)iH179m|5#Q5QXDc3Kydx&T
zTQ<O%GuF*2X5P`_`!B9<R=&fl(dd}`37BcCCR=>|Kbw~cIG*z9gw>4Tt#3B|x}JU}
zt^ycdU&M^IG%n=gm0GtlzxGqQcHQr<Z+29?lP>61IIzGGSXco^y63!VE!aO#)}8NV
z^wnZM;6WI84?RIWSp?^iBRD0{P8LBNtb!(idVmPjRj}hg5Cy)%0iq94q3qBTw3-Fs
y0(6PC-8hbmAu{C9!h!Mt0>>xF@*lJR<uepLzVO-Sy+sKF5O})!xvX<aXaWFTW)`df

diff --git a/Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/Icon.png b/Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/Icon.png
deleted file mode 100644
index 83f4d10a2103360926a918c368fbc95fece1edd2..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2409
zcmV-v36}PWP)<h;3K|Lk000e1NJLTq002M$002M;0ssI2B@5<>00009a7bBm000XU
z000XU0RWnu7ytkO1ZP1_K>z@;j(q!3lK=n!AY({UO#lFTB>(_`g8%^e{{R4h=>PzA
zFaQARU;qF*m;eA5Z<1fdMgRZ^-$_J4RCwC#nt4!F*BQXiId^;e$|fMlrlP2zxEmK#
zj0@J?u@jqUJGIudsWn4YlBsFjvN*=LO=Q%V*j5s2#JCX~Yt*<jASmucuo~HYEN{8*
zF6W&7@sI!_Zlu+j_x*eC_rCMH-+tynN-21r1%c;W`~ZFcKY$;=58wyz1NZ^_0Dgd<
zMhGDo<F?;{ZR`WGqEuGby4)TJp+T>;Sxj1u@IPiyR8^K`j^%isdklbri$$4#%|4Y|
zSYG9jWd%aW^Q_%sj*SW*Iv{ak>I*TQ!Zz>Nv-2N0dYz_Givqy2tl4A;4Gu_7j2|^5
zIlyjd`m;w*=KcBoOsz&B6hH_ztXR|~CgPzC7~`u&CE=k#W|Qgur|kV+duz?swV7E?
zr&|zshGl$56TOn7)_J+;=H7i@@7$A<cX)g8t<qD+zhh1Mrs|XeN+}@(LKqnyJa6{o
z*MIYK*7qX-R8%`op2%hOT0$s<!0B>7iW3-y>E1QAva0&KbA^3-_jpJSWUT(^FYjhz
zLd<3(fY9re00js^Sy3cO<~UX`>Sb900Pq|KbQ+yjqtj}%8UbUXVoV5O7-Tf)j0RnK
zm1D`<8>am_qu$wYP?lksdn!7u2BF8uzyP~llGUOc#cg>Yx8TYLnOS<XkztS|%blY;
z{(kQC9`Ug(gUYM!p2{uE&N+Fh@EResh12wU?d)k|83u`>_j>W|e-~V)6lesV=eX?s
zM;GX|AFq3pK~GgM5Q0MnBo!21{%r4|8I#7g4v_QBS+D3dnT?nbtwz|j`R#6<J2gHX
zKWcFLg4yf0e)i>&Q%y4mV`4TM)~{HIAo4}g{v#(}dvoobifWC(8!e`tyAO{WIcV0T
z(NCY#X0x^M>am{Ji@J7>YbAs#@798Q-w8qpK+F6#8})DeVa}edD=7tpkS3u|U2gH7
zB1lUelJ(JYomPV}fe^AByMEhlN-085TeYJiI=q!WuehY7va+%j0E@{0C<Op82#KOJ
z^;b(j$jr(+f3>dO)%3NnkU)fB+xIbj6XRc+lIjt?006B<IDe_=#?3n#foq4(g&2>Q
zWFP#R64Ek+2J}vV2vQ0l1U%2){Gn{&vULWXwnI=rLf7aQM+_L3GB7+e=n*ZA8#!q6
zCwqO)6ur{LYsKx=Mh+j(udXal9Wf{}GP0QmMh@vSHf5l*wvJLtDd0KIWY7Z$Z<keO
z=bV_A{!ZU<zg)R)hpMWNVkR^sP_GqykwyursB$0(+XZ0Ls@G>s7@Aj5NGWXw!1LVp
zwQo$CkmB-)PM1efRZ1y>kmp!~UTZSy>*`$@D>g1zy5?Szv{}CqY8v#aircF_^E?+E
z9B`+!tiImaGOL0DtY2(foxS~?Y2$|n*{zDI);rxUk4Pv50B{^@u$Z>~{mXL~uIaRz
zw$0QzU7{p6a6)J`8{6v|6JuQMaMrtAj+z>_)i=^c4@nz6q}ow??fYB#7q1^Xou6~;
z3?`Ie5P}e^`0%ka48yc-Cb!^<B*_BLQ2;oO?HU_dUgc;PfbF{u%v-c-_SB(X$=l2W
z70nF<*erwl^?Y^iwB4C2GT&bUA@H>@h*0(2T0+_i2~m``?K&Xv8~{L;<*10zg!pJl
zmfHoOfA8*NQ<4ojUQyI$01KC`do5#)qqhEjovGu7+bkwburDJmW`nP7H8zc=5#{!H
zf4k(pi`R+;fd>Fc9`Br)<9Uv2kp>!pe=>j`@i7xpdh2yO&kM~$NLBEM8$SK#w|TG3
z7(X^;U|dwV?*tW9j<s8MRaDpT90w?X3>q;w`J2=Eji;Ao<=ClnT8-e9<m<(^KmGjB
znfyyey$(W9@AC9X>OTMFDa~eJ2mk<i7p^+*wZDd`1mgg^B`&IC+W@6yW#8YtCGfo6
zW^D$57=(<58~-UyU%qkWhdVk&goXszBt<E?Rr*6&rSBWp*EvTH>-R$cUWbmJZkR?`
z=5B5M#Fx_vrGyYw#T>^P^*R7Rozoo_61a8E60=d?8~_3U<}ZG)MOJ&<?pagD{%zB;
z2OZt(m3JTb*X1jhMNte34QUCWC@OKeq19|O=v0ia6qOWSy#WE_I7X`xWJU41#pK=z
zTi#vlD+PcMLI?m50NPM88HVFnLWs-lA%qSckho#Rq8{-vjS~m?QKhv~3?EXQzdC+)
z_MF9<0Q1ZjladpAA%vO%EdAXt>{j!Mvjw+GD@0MEga8Nt1*)p@92?#tXy(sG{b|8V
zW|N`8_>YwyHr9SY;H_q3mzap@X(=<(Mm8=3J{8ogIkY@1Vwkq)rC#0QdL(y6K#d6R
z(63KY>l>NNEnX?QdHH(Dow6!Xk`O|HHcR&|QHcqit!Cr@cT3)%b7bG)96-VRxvwPk
zOnAsn{7i`?$!Bu&KH2rTqN-_QMo*uV*7{2MY)Z!JEm`}H4DTBS03AB8|I~@&AGi}g
zgQBXqva$@zB36`?VS{E(o!m4}p7jvAeW!Ha!JOif5|(9ChP{xQGQ35ddPY4U$;#Y6
zuIdzO)AMRYRdqyo*!VG{8rR6j1|WnGN*RP;I}P-0i`(r!lbfG^{z6TaEoD&831dbN
z9@tN()jsykT#E@-RaHtU%d#x{llX0W)<F%=Mu*$-3NBRNbp+aNaj`K;y?WYh)+fAL
zY%QNuNs?V2k1VSpL3WO7haDGVTvJ<DR$l&U##(_xlT-T}O{Tb*==jcYCey>)&XXiD
z#@OqXWJMtuE2?_8#u?KooMjo7Wo1R>xd-~kBT53#K?o#C7DX|A`KH*&ki_`NimGY=
zfZb*d2@VPm3kwPic=Y>=r>a7fQm<EXy4(N|MNt`q@-AHK7#198w?GIHg8RPuwtrGL
zo7JeuD#q%@kH6@h5E~s4>~y&aA*B@#yUo%uG}vaf+U-`8@k!czdzMj*F~(SyWm!=a
zMNw6?rp_gBEJV<ETS^EOcur^#Ua!+Vy;11@yNw^f58wyz1NZ^_0Db^JfFHmQ;0JhK
b<-Y>}gpv5|`ST0$00000NkvXXu0mjff{t_O

diff --git a/Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/Info.plist b/Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/Info.plist
deleted file mode 100644
index b8089dca2..000000000
--- a/Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/Info.plist	
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>CFBundleDevelopmentRegion</key>
-	<string>en</string>
-	<key>CFBundleDisplayName</key>
-	<string>${PRODUCT_NAME}</string>
-	<key>CFBundleExecutable</key>
-	<string>${EXECUTABLE_NAME}</string>
-	<key>CFBundleIconFile</key>
-	<string>Icon</string>
-	<key>CFBundleIdentifier</key>
-	<string>com.yourcompany.${PRODUCT_NAME:identifier}</string>
-	<key>CFBundleInfoDictionaryVersion</key>
-	<string>6.0</string>
-	<key>CFBundleName</key>
-	<string>${PRODUCT_NAME}</string>
-	<key>CFBundlePackageType</key>
-	<string>APPL</string>
-	<key>CFBundleSignature</key>
-	<string>????</string>
-	<key>CFBundleVersion</key>
-	<string>1.0</string>
-	<key>LSRequiresIPhoneOS</key>
-	<false/>
-</dict>
-</plist>
diff --git a/Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/___PROJECTNAME___.xcodeproj/TemplateIcon.icns b/Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/___PROJECTNAME___.xcodeproj/TemplateIcon.icns
deleted file mode 100644
index 4500ce2bbd0e598176a3fa6c4fad8ecf466b7b05..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 34248
zcmeI52V4|a+vsO!3uS?55)DOc6n&GJqKN{6RAXYIX&RHfnlHxKOQINinJpA)0*Ywt
zu^X^OjScKrQ9zU?ih_ddF1u{+=X=g9%MPS`_r3SNzQ22aJ21?g@;r0ObISbpS)D#<
zPCP**T%8_2Xdpq5xdcizbF2?aTbdG|@tULsC6&mMh}<nGzqA5b%odA@vbb8U7IY9&
zOaeq$1!$}p9Vjba@!7H;KbX`o;|{W_%?BT5yqtF{IB)*QcMFi&TEDlnEc4BYA$P9y
z3%!O+s3y5){l=C3`~48HGIa7@Jvt${doEq@;CS*8>w#69QSJKupq;Xk2w5ofM#*mV
z;gV9bQYDv3C6CIB%C%^J$t|NosZ_`$%`&Y)q1#__Rn;t!NTo8FlxpU-?k+7yx<ms{
zhw^V_9^RkyD=RPY&#T6@RZU<aO%@Af<#nu?1!{IHb<(O8|D5-9aRst!pk~><j+KQU
z6aMr4OHi{XP_s>Ob3dvq4jpw1nNe*@_14`fL&KJTlJ-ITAw4P-mtWkF{-|K>N$c^P
zJ?P=KUzs(#lczacQf5}E6;ST_ifi|D?KNwWNdB+Y47%-4YgV#((T2>qiOs3^p=OqY
zwVNW(R*pNnX70qB$YO2WTY6{zH{!{)<zuGYg_=D|tJ-t)=P$lkJ#FK6Nv93yQet`0
z-px;nc3ec~cKn7O?`f}@75ePnVY+5Yb*sEZ_N1z~l2J3Mq(x(B{a@;{_>kE%34-NH
zbUL`no7Zo!AM190#D9t`$bOiR$h{63O!h;EDEEdA>B9eb_%Q-=YdZ``z<<)Qd~R18
zA3m}lwXO4}&%(pg^~EiSWm4v<xJm<33#->vy4-76R3=}FtU1WVjOJfaEJc<atBVQ!
zbVaeGE!KYPYHo|QQWh3M0vNe0t2F`H<IOPEAOd17=49k;#o6Vc#9Uw5Xf;b@3LQdL
zlSD2=zE%SaV$iz?l|{1&BCepPuV?p|L+FNAtO)f`KBGmKSqBjF^Wyvb;?aHXSXUzd
zE-?rc2#|MuDU`HDSm)KP7$Nm}-ar%DNxW6a8k~S$Dbg${k}tEoM(_tst-DLSsYR`Q
zJ+s~35g~sIDk)r61kWt_;AIx!x5s^e-l~0-pYA@$Y&L=3SG2!PyDnd5QlXY}gIH5u
z9$-S(UHcqn4-uj1R#ZJ_>J3?9$&jORNhl%e9$c6=fDpq2&YwTijI359**xufi|`?z
zV6%uHZV)UM!T$jj5hTGTenm#4erNm2%g`E+^3rmyAjNOTj-RbZsO8A9<G&wig!J++
zq2Rd5ar0S)_>Ty^2yK}8WhsisonbN>4JNBaVDy9GXf_)3Mhhz5E2==a+ZH3E(FAdN
z%G}*zf*&hFrc2jW?$;p=oo>+zbbe}uT%wd|B$_A9<;So7d`*oE8a39w$fOo(e6=ct
zq`tBI@vXbnH7yp4R;kvsqIp*o3w5nxrH4wbQR~!toldV-v<j3iEp(Dbo~&TW6#}_f
z;UYtGuP7F%WH~J^67=I$#ZRr09I5*=%MWm?c-Gu35j3+UlICWigw-q&HM=yL=3G@Q
zz?ocdrq=ng#+)XXC;Hh}EdzZ6*7YF+Uby#vVz8cegGCnH9)Dx7){X}I<bJc&ENf}i
zV}q5oG7NSxsu<(j-DljTcis*fF!ls02^uRxKB{J$!J_D{!lQ!0`vV88oa)>4cx9In
zV&wg#oVM2bz5~h-(p>2|!i@5}#a{9o3D$Z|i>=if*|qP81@%?FaeAZ-3EJHEecD>@
zTv%EJ9b5kO>s>tu9_kyTx9Xz$<_3&tvsT>++FI2}Q8dCQ{`D9Wy4`2+$sQll)>^xC
z>UEj;?uTa-vQaOs9x(LM(P(aFwQt;&D;K2LTBSR{S_KWg`8{6hvZAEBPgk!#E70|q
ze7n3v9)h8%8L@W-w$_HD>$eu8)>CH+FF!>{eyX7G?5So*ub8C!qqTZ~wf_A5oi=Nw
zj3jNX-E7us0BbGFPpN9NRs$p(^ag>so5>6lnH8C?-bgyw*;u8@7L8Q%R8n#3`nDTt
zr0-;`(uSsc^`#Xx_i1C*v>U5PNvYg5YVE&ntgbd=l|PdRn+b`yxhpnT+wb!;R_mV|
zE3AqHo)|jXs^!@usnx7ds0?7MX1NO6s?j#NE=Kofh7Jy$bMw>Du_I@nNB81pgRQEi
zw5={h{~WmHZ1$(eV@GB!3mbUu!N7@NtBsY|Rt1gGBP$Wo-X8X?8J&1{!p*QrV5`OY
z#bB%G>w(b|S2aEio1jPPF|qrjCW5V6QRP*zhsCIR?gs<k9DO=^ywR%vI%-$+M3|}Y
z%&ITIwrbHL<*kXKi64wNqkEB`T^Ra3ZL9UGrrc-|)qH<hDWCk#){$S_Ec|D`tq(&d
z+`fH7j%`)8XZrOPswwjI@OR$Myf-9t;G2<|sPvt%x8Dgm4K>wGIItYsYE$9v{Boqa
zRCJ~I8A7cWi>_R~B!l#-nNaXQ&a4)+XSUr|VQMwO!ez4ADonE$RCQ!^jonrSMi$dl
z&9`r69_?(ZElRnjMbjj$K7V6x@gGdJRrd5*bwhbo?SoG9sz}LG;fYnN7U)QID|22=
zQBd-PPLnF0N%4HywS7{h4HR3bu$d)krX+kYR|##abjH7)SZC2YBaSP<V*ky->a=hA
zlVH@DLr4DNI9T`vK}>@__>04Y5(#1wGMNA3&?6y1OoqMVUmPYRcBVVq=l^f}_#PSU
z8~x5#0}>I$l)oDv2?P;1b>eq_aZH@{7BPK3elvJig-14Xn5hv-5X0mjlfLkJkMB$6
zi2Snc{yN-`ZM(nbyr<jeUv7sQL|RRj3`R?)A{SH3)5nh+TMR{rw5WCIjKpN*RlVlR
zfdM`*ck>N+Ys9?W)vy_Ol9-glOU>DF>_)vY1+gjw!X#3>){uip=|Mv(Lpl-hZj67C
zAYI%jzK6S;3x{C67@htYp)08bkHddu;MAk0Bt+~N6D&Vv4q}^bJW`}E<i&`iT<A&g
zQ@mU~IK&%Dbe->+;^pGWcOlpz8%+s_b&w_WB3=8dauI2&eYT1rD?;q2LkWI{7tgJa
z0t>G8VsnZ2s>KeW4T!bj=VXSA5Rt9XM1mKG@8;^}Ap+4rS~SaxBzhExn3C+m&83FK
z4zjEngviU?ljL*{>er_WNw`t%3P2T?!{PE=J;Yw@7r0%{LMz&fz7dgkFGF1%wk<$p
z37;?Y>c;1dIZ&riN-Flx2w-u&+DapUhrAH^-tefw{a;|YioHm#Uk$v#+4XHg<n^;A
zaR+^@c?7hRr~4+LV$xmV1UHDTm%xkUzx+giII8lDek>6bjTK{r_i2WzweEX5sfy+Z
zy;$V9Rmjzt*`=EtH!ZE_u^6$X6A4d|7mL{4K?%EP+UDCLMu8|q8sBsQH3XH4csHlg
z9ZM^Dl!#cfNZee5v<TVDu?3O0c7f$Nng}%L|KSQ6xG}4tzHLPSY0~;WTja%M9bihc
zReAg6(5mgT2Z)>Ab`e3-&1e8~Z<kL(WRa_<5ah=@<hLSr$-eWj6L!c$a}Vc;y|`@O
zF&l2F!R(kCEa6<x;2NlGFF$CwJu&-1Ck=DK(p=q1!s8#~Ru^LfXjhVqSSz8!xE}lx
zh7Px3#QP^<Thm?(sL@qdk0dV_4_DCg?xGve#!MZ*K}&Gh2bd~0gv{Go%TNJr`VH|y
z3OtHOxPMg(8W{@6TOJ-lFAkC0u3;N;Rc~8&vZI2=w~2Hwwg=(62P()EuXzcKm_w{a
zhuTIdh+B5A-K=s{0Y+)vP{KXk%f*G<i`s4J5sb?FFL#pOj$96AW>z|c#fYm}*^S_O
zq<ZmOx<BY3UFJm>eQkTuLHbx)TA@Qa5xG3d3ipKB$s^f|OUz)3vrcoN>B#*|>4Nl>
zy$H6Jws|)hxmrtezJBus7U7zJds|;@H$v#W)pYN<-DsEJirh?T?|hxM5skBJNJBis
z-R(18W5GlNJzaT+AwP<ZEhs?2ls`_eJr=BU$Y&yUtB5vMPfo!-yD(UAZ5L=bF6(Qi
z1-spTk=0{qCbF-k*I<C^o~9$#JQDJHvQID+ux7zjz-8q-<e}fn#?KXHFvZDxzPV{&
zfG#llxt`ohckLyBF}RHbV+e*Yus8b<1{KD1YUvtB3sQ(v$tNZ}h6(>92P^S-;c=;5
z2{iH!cXvFM>|{(OprmTSvV~h6ok$^GWfwlH$AT)TxMnyWc-+C(n{8@ZgotCgG~U%+
zh^Mw#`_#sAeRVr>Juq)c{O?Rn?v-6UyxfSFKL4dgFF<U?@6j+3afvjWVemb>#tW#W
zbH5GcvtW)RdEM^WCtbeZiexcs<+g0(W)Q?LoL9lrN`h9(i_a%nFTFYPtFh5RJPw}T
zUTeW>MP39;K#(NQ6Q*%jkE8Um0FfRk1QC{r_^l-;ew;s7sO_v!<mJM5;gBTP4OF<e
zx}Kwl4lGj~{(gFy%JgD!-dl}4ih|v}$1j)xL#ut(fI(W};gJb*pX)~3fQ6OOo%lx~
zy)xPbKPEi6{o`lC8#zOeQ|Aw(EzOJVM)W^xn=8`1xO^_*y{v^^jP24B2oLTXGqZqy
zwMz?-OI_MfKEdL-Q=aZ#UY@Xuvk2cs%`gRBA&6uaMQ}JTh9*2pLabkjOhB38s}Zm6
zjV}GZonFP9IYp?e^;YJDcYOIg4x7z&>;Bd^>z}|HRrB>f6UXzunL3xsJ$@gyCD%UB
z9M2jnT#dL_r++tV(hlbQpM>1aPf7|8|C)dNYMtRWJZJjk8I$I>GV|0U-m^vDO`ANa
zgt_oMMm*JuNi(K>dz!hRJw&egVN=9YX3hL|2Xnc6fZSUB2_j<ttVz4f%!G%CH=OYN
zB7X8-<{qLJc=(BVpL{!S_HSU$bkn&I#5I5{2qjqw`b>l?1!sa4aJUFQZL*?O5ERl;
z@Yxg48n>q0ISZD~`{^dmz=aI7CP3a-QKAJt`+_sQ?V1Ny%Hm~3YGf%|8NX!F+_VSC
znrLC8F?gPWk1(zvv)N)cQx?k11F!<OaL0nrX3PYfltpZ2+u{gIl9_{VEkZ~VntgF*
z9L6lpY&9?GJ$>V%rOOvC{7sLN&20~WLR~@SW)GzCCOAKemoLn&Le^D`)FLD_5#}^F
zbKp#dbB(Es*<^y(ucyC{?(x2OMf!OiN`!cU$)U3dWt!MVz0N2y5k@hbkiobPP7!?i
z=V_@slq$|hPE0-7iY&%dhTLV8ZFJG8)LN6tXgX+o0qqFSuKYD4B_lOy-RWjz$uP3f
z=eS{@+?SEqK<HBpu115lMcS%W7=JZ%F+oedMs!VIlf61)`wb;BXBr$5m(W_hr@^3A
z)NN_e8Zb;ZZPin#i`l5CIk*4Efm1i+Y&=%2L&j{qL+Bz(*1=<RFX;_>wd4tG)3q&)
z7`g)!H)QC1O$MD_Z!nt8E63itbz=Y4&6~Gx-*>V?W-{wjK`=qbMxV8n_#zVM2<=*(
z2dGjtKWf;YA(yLll!4S53<5n{XGBIyPZ>PT&1#cg)AFSHa!*3IpZdjR*P#nF3X|E8
z%TRU!WoQXqigpk@UZZHPtEsHI-*9%qla?0vh*MX+v;jUulQlmp>p8XZ>e=59<>jwU
z$p7ukwaTYzlS%)x)={bpC_zhTa<y-OBCS&TwC+wp$*r3=Zd|{e7k&KNr3+^Z&K#SP
zeCpWolV{FfDSz}-p@YvPbXv_uhK}>rof?)_OX+$VlyXU9eO=A{x{C5UWp~QT?$$lL
z|LCbiq0t)*dfhJ?$AiyXv(<z~45t9j1hoLG5a`69hKHM1tECeuHCv<BXtMA{t$`5w
z6t^djAkJ9;qfsgXPPQ6ug|<tIiltTyR2&>-j}xd!wF)8$b+U?5b5uCZCh4k%1PG}h
zo>K83VAJmo`pqhp5`I*al7u@7u9S+Sgb1Zb#fK}tqqBf2rBLO8V>-kofCx*agy(`J
z7ZTw&p)H`aJqIlLtVyP9tJNPug+^H`+xkhH1r-|eS_wq~Bc{M0Q?M;`I<!cEL7|Wf
z6a;;yDoD9Po&+HZKCPi|gmeH$5b{-R+3-D`fl_egAfS*7?HZvpXY?23>=wDaWv85N
zwin}!PS(OUecV>4GrDapgzOlcnT*)eTA7S(wC7=jI0SK8E2U&4eC|$3+3*=Q1PG~6
z<_Zz?XYsN`DNjb<LkbHg<GeyC2PaDfGLe)3NfJT=nTstSe1I<#(9x8PZLmM}ltw1~
z%aEFqQWAnbg%UTZRDyrN89*rE;;Tdg4}_oua!^v1L?V!KaTY0rJn6i2ZhR+@uyFz<
z;Xo?R54DlFLX<?RZ!d~kCSmJGw>8<R|7hqewkc%q%pG@S#q6p$TrvPYE^;>#x;+7D
z+E0WiCL@BS$_a@aucH4B5ccPgNYV7<$uqgJ2q2NBGbDPjW!ih8Z@vEd+aYmZQ3oEt
zKDIGCX$^1Pw!AYXPff5JtH}_qA+xp`0TRiM89PEE?~+-sdi(Y28xR;6(6_h0kMBP|
zU;hN5o87&Wd|Z8fdj!1k-h$HridesS34O?y2dXeCx?SJe2^Fam0(}Bff?WgsyTz)|
z?SP<^V3(kPUOqiO++~K{>F<8RV6sny8l$3zol#NK=<b0T!Mr|0TCw2jV0O<}zI*^1
zV!IHaqF;XLgo>17yc2>s0e$-P4HSWB7%iF=O!^MI1bc9YB>VENG9z=F2d%THyC~Q_
zsE7Z6p%H`o`}y{v+7*DRp8ozld-Vwv2ebS2>~|S*+jRjdx>wX06_p1B2!p!?^qPFU
zzEvfwKC&p(uV-*uX$0_)exH3c?z52*{d{|igUOx)AHZ9ST_2#L8|OQtBFY=uDX8ym
zKt(MFKKAjq)k_de2ENt^s7PJ8A>0=<`HnHdn;ApXmY(^{9WFd(jK46L<u?sTk?H4t
z0~EMrX*IB0XSe+56C?^|c^~MYgni?uUrL!9YuNZ3V|#-d?=&Dqr3>hOrIj=QDO%!(
zTWbWoX4=aEq^M-yeddN8H0Xz64L!#KDY6#<q)F@7Jw(A=pJPmEw))_KKair~y+pyJ
z|Dr}9MeXviKfl>KNEpoZo#l`R&QqFqu`?+e=PwTC_IP{pjxtP&m>Mh}_XG`nLRIbM
z2Mu>-t$)aT-+_i)35Mnx;O84SZ0gTtxc}Rg0BcBv{^AA(lrwa=eaabkx)UiX?j4u}
z<DrkAPv8d$CD6u99jBlrI6aOtRqXg+*^UQ{_cv(M+1>l41apIWdH0=O2X9IY1>~K;
zKw&V)dwaVEcvV;L{P|2r1<!{2qzAJDecn0<6=aG(c$F6anJI4BxBeHk<NXmxQN!r&
zeba+odixzl?Y7hagYw~Pouq;F9LdS4b_fG0(xwjZ?irXG%<DbiQ3vUJ!L;<2_Gg3i
z$*ipN4rw4o^&3A9^6~2(m>kS~WieBnb>1JE&hH3Q`doHqo<kawqPtsX#P;*`?VW&o
z+fddv4xsF;pM7xe^(|?a$D}Cty(wAS9Ha!3qN@FiqWoZ<;RXfNR5Ikh=|NjiD^tGU
z#U6nx7^DeEk#aR{tU>-4tL?&I!FBy%>frj$U|O)-oqzZa6y`WM6AVy&6ObYb1{<eG
zAw!<E)E5fm%NRh=>-VNDUbU7fO;*3P9Y9fWFBtsXpq|&N>;-@!xX&Mk5R72(d9jaR
z42sqy3fD7LaP9|q&u)O}{#*~NB(UF;dv+x-81nk|#WP7hV<rJ5)yqXIb~<_iK+*mF
z0ltGowNP*EI6Urpj<lAxsZn51bZusDP(=ETwNGrUKEr?$9a$_`a+;~g{eJ(z;J!Yu
zegEqN18}0&!ZCOr>7Hvd3w}_4K}K5g${#)o@P!$U?DcxJeZ~!VJ2g3zm9`&qqU5D3
z7FRK~lAx6e<_Gxsy&5-u`jjzYy}+<|J)`7Utti;V*W262$FElqOufAWPt%J6)H=u~
z*_-vkXh21(@`6RnmaOWCia;lb2KM&%>(R3h*3zeU5j}Qbneq=fLN8O9!7TqT0TtZ{
z@B7Bo<?{ghwKE$Sr8Pl;nXqj11`LNsEUb)uUm13ZUK#Cz-*yY?6}~jSx`QC6e$XpD
zgVJ#Jh|9LgA`N=3r}vx5a(XegOV55KsAtst^&L@>+vD8P0Z`k3pdc#PH7F>cx3Blx
z2~wDYZocA^=tueTe0=<09hKRDHw7<b`mwrx46vv^reE01`1{Ps6T_mijkDi>JFu63
z4`_n{adUoYgwj8pku-}pXTi$!?FA2EcXDfT<}B8f3}8h!=FR$P_C6*D!mOz2?&Xt5
zj};WxV^;Jy{)hNE%azPLz>1m$v*-OV`wnyI!K^58_WXG>&oP%YU`5A1`YG+lpXSfl
z$6PRh6{!Y!cl&7Bf;qo-W<}$Cg1%caC!e{Az^v%Zk_j`G{Peq>6~Vsw8WIBt!e^qD
zjr~}%+XxXINV9Tq97aUXHZ52oT(bN&0+7VE^*D%MMX46>rrg;^hcGG1v~;s#Unu}Y
z*AkWrRxZk}104_}v_m33W;mGfU_2xS_9LSC4`C6Qxi$hM0!9RPsTdVm=q$-Vj$TL_
zv~b%>p?Jm0-woiUjk%Hw&Tm6cP#PN<(!SZ<e^H8f#d`4fZ6`zU5?6%G82co_c>vBt
zI~Hm@HU8~!DdIJkbcl&|+K`amxCJm!CY%(YAP>vqqgg3y($lieD3N8AiDxvK+8=L&
zL29+m4ukSO+*EaNP3D@c^o?hw9bpil9Rp7*m$vF!X$)jR>L`By?A-Nh*X%C-D-85#
zx7>z-j9c_C)2>uT#r+HUOXB8k-mvY&eVw%v2+Gy*fdNUM);G22<j;%(JqgH!iGWh4
zl$M;%-?4rBu3h<ODlq~Q0s_ilP@9V=2M`d|hJYS79L{Y+Ksq}DGT0E11S25%)B9Hk
zy_k|u?RMFB^zxq|ATc1Iwc2-V2<XxMs_NQ?i?bSA<QM_fCOyS|)RN}%cji}JKY!}z
zp~F9?A3lEeW>upG5Rh&IgWp_0iNJu?Y5AA|sbr0h?w%{VP2KV@E<OC&=^IxrUp#mA
z#JtQiCr+L&ym;;I<3`MY^t#Oq4d;=a0O^4MH8nh{eekIAUU~W5^74why4uH$5``M-
zsMmHRKsNG20M;QiDQzT3q$UCQ2%u_7S`sK5r6aW(&1y(pYllBzoaf9GFdel@0EmYN
zS0Fg*MBqCD;5hi2V52~k?S`_2XfQ;81g1erDy~{(gD_yu0DC9^H6#!kjBCUy7tC@n
zuo0<PN=Wmt!Jan0lb~YbJ9svo4KpGPdnlEwjR--kSoK#>=d7t&$!k?Q2vBFr!(=`M
z#;ppXHCaKnDq7Dl$V`DjsNi5=1J1ZM;Dbqy*g<m$xyT-{#S-$>Z8>mQ0MZVkqnG^+
z-^rxe4k1g2YZ9FJn$yCQwY0QDAO_%p&S8XrN}UD_1NepjLSutAT>Om-90fu6O99Oh
z$lPu0hyH6PK5U%LCPm4BuC(dFB4WTn|1;<Te1A%9gE9huGHw{k(7#d<O?80XkPs)3
z__f93RD6s7!jCP036KD&jsT+}97{=fbbcUE0DYX0rwtzc%ib{m4tVnaiq1cUJZ7b&
z>6uh%D#DOQ-^ml`@vqCj9W&~Kk)y|a^JCVj$FK*LY)|@yw=4g|<%(w*^3-h>{z7ic
z!;q(?uruVTphkoY9TpWG6B8X386FxoV&<MEgvy76tP16YM}PS3s>^2B%@w>U3?<(k
ztp>znzV`>jqgfXl8j}*|8WaBR1P!_u6Pps}5*srtH2nJ`81bAB6ULEIUurPosq2h*
zq*DjSWW@2JK38GE)p6{IAwPi6O1lssp8Whyh(|puBq5H7p`wTw5r~eZMYH0_u#a!T
z-r4@R4TxQQ;7(`6lR8)w=N>yWeB>8jel~n)XcX1108~YUher&Hj7f+iBZl9ChP0~!
z!c%#*GvTR@juFOniy5}$T%$^(s4GYv6BZHIRu}<1WB808=gge+<?ygbG3Xmz5APdx
zeL#4MFBzHJOi0WQfo6)0J_3YCadKK{gsobFI5Osa2@oD_?VfRApebyY30|ojn%H^a
zN8$S+4)h4BW`zsmSVNa%#IrYUq!PC*t>+ma9)&n0RusnyIn_~1S@Pa8rWV+)n<hkp
znvhL^cq&%W{Yooo0>qOZhFj}fctNxm1Q1VYUM+K<4H^tzVhs_q0P)z10MexO$DyJ)
zZYX>_?vQ4yj~rGoH}4>B{;y#oXu8y9u=sX)*jC?(j1|Ul!+<~A<uRZ+aJe($nG-IK
z;|?9Q<WQ9s5D!y>b!r4?h#aeCYN%YcrH=WQ0u7l3hUOYQG&JU`WqT{ZmK{m}5^RJH
z<Hkf+GjzC3??3ZQC&Y6%GByduL*&qqnD5qAKpVFg1aw@2mf#FM&s1?}V$!aMjJGzh
zL*d}mIBx8)kf;?6&_oP*vML6ef)jGET>&OMySEf}kSC@86`CH$jtv<Fo!&vb{(Z1v
zPRL%SxFvtnu8xGKamtYB^f;GcLjfEyAKvgmCu!`>vtdJx<5d+1k8b10kcimSI9}w)
zCmp2k$I(U4YkxLKpU%m-=#U1&)3|S1Y-m_yOmZA|NGemDbv**NTme)1!rHZm9MYKZ
z)a0$4Fgz?YG68qCv9fI#G(p4f4Ta8&jjCvu2f}0C{muNfJ30^^<AdX=Ux&ef;l@VS
z)iUIN8Vd4JV^mD}qCw%YiJKjW1PG6MYa|GB!f!sb%Yywjya(;Z4O_vqU$^QJVWW~a
zID}z%8YBRCvS6rjhF-06$kU^b8+O(q4xN5~p&&h%DNQ~cbpQZQ`7jvz+}McH_5#2F
zJQe{>&x@D{Z#VW4gaOaGlq5#!!4s%1Iz-R}fahvBRuVJ3>At-bFcf}|j>hxINya>a
z%OOk_?QwJh0G_({qQgGU0S6LNHwTZph)LFpHZ@8NcuJ{AP(+5!w$E#<sILI<99xmF
zvVf_`z3#o3xTw(g7yn*w1i+)ZG7HZlgLm7kf*<={_U29NvqY1lad(l!K6q%KaAQVq
zOy0`ccnkxcG)lCBVV^J@Kr0o;j~N>F{x|bhES>emFt96L#MktsDT;Fm3keAg4I35<
zGjC)prvB%lKUlG$$sw$_rU2kkSD#xZSdp${mK5s*(U{2ap+h60pfoO#k+<lf1B+C6
zG<I1%AC?)%3jYBB&z*76Bj*Vg9b$}FDAmK*m`s@ZA`jaJEUb&sL%zC6uZwoU1@Fd2
ze!g<?{SJbhr=JXth)s)QM-Be6*fv+BLC-~me6*pJUW)C~f+4YyUo70%3Gh7KJvAmI
zY*=(G^fxTwkzpaD*TI)G$?}lU<S;6f6Fy?f)+X2w6uy-i#u_*k=uYETai7I6tc7B>
z^C?Vss`d%K8x=E*Zh(>B2oFkNv8!K6B?w$7;i|072a4)pV{&&%rhv6{3-F!dh4G8$
z<}s&#;5!ycP4R`ovscO+jlg&67tLQ3FX+s7Bnk5t&W|r=t~;3Tq|9Bk@W%_x^$hsV
z*~!US^Or21lgC_mf$yk42^lhB<&t^%o%zn}u-G{(;tzG^JB8HDpH?h6^#{I#9e%J6
zPzsy^8|R_0J5VNs#hCHHj{ufxx8`k2g$XMJC7mgc5WvnR3md-l1sI30u4>~wsc=oO
zbhX0QH!U|)s6_Gdb&n8cJt8~nf%h5OAqdzG?e>#lCIQ(9u|rTAP@fF5Cnh+w#}B>$
z<>BXkylSU7ag|7X(tyN&N_h06hJ;fYt3;b>8H5Mk;)+nVi8Pzc$L(mR>CEg=(=w8C
zi}Vh(1Mhc52nbCI4R5eh%~pUr*>HlVkNNTOoQ!o@tJf9+gZZPUkKO@ytiON1zxqh-
z+T5J1E$9CLcd}_OAGu7aQyKRdfE{5^AFKN7H-_hK+_*k>-)+@jc>2^IwjmyaajX6%
z{AD>~Ywe{&iQ`vp+q~mc?H>qF65yIt9i?|uOB)-W$+Zdz_Q-)qaNN-+>3V@jlL7nv
zfV<DerFTmU5AEK$bI+cGXRBI(^*{oaPwaquHUR3;>r|5ZhLbxLfIuh%OJ@+$&OYGt
z<7+UOWExC*8f&kQ9<=u0zJ2@ij$f%&m`n!jE0oR9bpdU%JNrDYt*NPPxJEU#$blkg
z>()2fNKeJ5iB&f)o;iNxx9zz{Pn<8VZqfj!$pVs+z(6$@(6%<v)6(>~qUcU3b=&_|
z*@<aqi?3a|eBu0Q;l{#Krwh+rzJBjdK~KA@k6tC0Ha&U#;K8G+ihFnAr?Rf@L4BiC
zp~0Z1ldI1r8t||*8cNI3=@PXfjKMT%Hm4qu?Xt>_cQB5z(Ed5tW5;%~FzOKj+z~<)
zK1DRd!4L>L_E2gPynSpT><$Exwg8<Ck~uUX0xujp^8v%99ef}+<~&KXXAcHFHg6rG
z?P?1rLMF(SNaG$%c*Jd>2Qwn<{gd=Ju!rg0^LM1D(2%WQwYDAy+>=2gA8xC{=Gx=d
z=GxQd-GjN#D)82UphBJn0Zf1}{lWe{32+J&Y@BEVLkz#2PLv1ycI4L>K09Z0nC#@i
zxw?fVldW(0QwN@od<Ta#;7S7wM+j~_A{n11I2hHyFF4KMi_OJ{lJRJ79qg==DCN`f
zwp1DdVa|h-z}rR!K0YA$Kl2^1lv5g@Gi;1y1d^^cZes&DG{J#1?6w2UMnJpd*ntjs
z>`0_yIu%nM3HTI&!;b(?tO}fc2sn9=)DCw}{zrXwI(iKKZ+P&`r@#6c^@o2H<4?Za
z>5Ou=fU^buoh=ac>GM85>A|Rv+uaThea|H@$?<&B|K4+XWQT{ubK1Yw&Uvk-L(+2z
z2>9SNX*)P?!dJka_aXLlKHu5?bPG7`&pG~{_w<9D^N(}>b<V%e`4?Kix&AoUALsh>
zoLj)T{yNuR=lbhhf1T^EbN}JwPtSSrg~vJ9U+4PkTz{SGuXFu%uD{Op*SY>a?-p?G
zKb-py=l;XF|8VX<ocj;w{^NPCzRvf5=l;XF|8VX<ocj;w{=>QdaPB{x`;X_{0?z%1
zbN}Joe>nFa&i#jT|KZ$!Jnz-l$v>R?561qZ?)lqaBIEmSZ<K1`Uu$@d2mA{V%i;ep
zwC_KHrsr<o_B@a6TNB@d{}Hk6AYU5v(Pz)~`1I4*0Jrw<UlJV8mtKC(M_0G@>O(8A
b$mf1IYH#m`|IBszq&e`P=n)<<3WE4=D!jsj

diff --git a/Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/___PROJECTNAME___.xcodeproj/TemplateInfo.plist b/Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/___PROJECTNAME___.xcodeproj/TemplateInfo.plist
deleted file mode 100644
index 498e37d4f..000000000
--- a/Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/___PROJECTNAME___.xcodeproj/TemplateInfo.plist	
+++ /dev/null
@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>Description</key>
-	<string>This project builds an SDL based project for iPhone OS using C or Objective-C.  It includes everything you need to get up and running with SDL on iPhone.</string>
-	<key>CFBundleIconFile</key>
-	<string>Icon.png</string>
-</dict>
-</plist>
diff --git a/Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/___PROJECTNAME___.xcodeproj/project.pbxproj b/Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/___PROJECTNAME___.xcodeproj/project.pbxproj
deleted file mode 100644
index 8e54e04f7..000000000
--- a/Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/___PROJECTNAME___.xcodeproj/project.pbxproj	
+++ /dev/null
@@ -1,500 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 46;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		1D60589F0D05DD5A006BFB54 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 1D30AB110D05D00D00671497 /* Foundation.framework */; };
-		1DF5F4E00D08C38300B7A737 /* UIKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 1DF5F4DF0D08C38300B7A737 /* UIKit.framework */; };
-		28FD15000DC6FC520079059D /* OpenGLES.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 28FD14FF0DC6FC520079059D /* OpenGLES.framework */; };
-		28FD15080DC6FC5B0079059D /* QuartzCore.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 28FD15070DC6FC5B0079059D /* QuartzCore.framework */; };
-		945C4F53195AF17F00DBBF61 /* Default-568h@2x.png in Resources */ = {isa = PBXBuildFile; fileRef = 945C4F52195AF17F00DBBF61 /* Default-568h@2x.png */; };
-		F3A497AC2555F0BD00E92A8B /* CoreHaptics.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F3A497AB2555F0BD00E92A8B /* CoreHaptics.framework */; settings = {ATTRIBUTES = (Weak, ); }; };
-		F3A497AD2555F0C000E92A8B /* libSDL2.a in Frameworks */ = {isa = PBXBuildFile; fileRef = F3A4978F2555F07100E92A8B /* libSDL2.a */; };
-		F3A497B02555F0FF00E92A8B /* Metal.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F3A497AF2555F0FF00E92A8B /* Metal.framework */; };
-		F3A497B32555F11600E92A8B /* AVFoundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F3A497B22555F11600E92A8B /* AVFoundation.framework */; };
-		FA8B4B97196703B400F8EB7C /* CoreMotion.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = FA8B4B96196703B400F8EB7C /* CoreMotion.framework */; };
-		FAE0E9651BAF967F0098DFA4 /* GameController.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = FAE0E9641BAF967F0098DFA4 /* GameController.framework */; };
-		FD779EDE0E26BA1200F39101 /* CoreAudio.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = FD779EDD0E26BA1200F39101 /* CoreAudio.framework */; };
-		FD77A07D0E26BD8C00F39101 /* Icon.png in Resources */ = {isa = PBXBuildFile; fileRef = FD77A07C0E26BD8C00F39101 /* Icon.png */; };
-		FD77A07F0E26BDA900F39101 /* Default.png in Resources */ = {isa = PBXBuildFile; fileRef = FD77A07E0E26BDA900F39101 /* Default.png */; };
-		FD77A0850E26BDB800F39101 /* AudioToolbox.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = FD77A0840E26BDB800F39101 /* AudioToolbox.framework */; };
-		FD77A09D0E26BDE500F39101 /* main.c in Sources */ = {isa = PBXBuildFile; fileRef = FD77A09C0E26BDE500F39101 /* main.c */; };
-		FDB8BFC60E5A0F6A00980157 /* CoreGraphics.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = FDB8BFC50E5A0F6A00980157 /* CoreGraphics.framework */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXContainerItemProxy section */
-		F3A497862555F07100E92A8B /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 944A65681957463F0094A81E /* SDL.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = BECDF66C0761BA81005FE872;
-			remoteInfo = Framework;
-		};
-		F3A497882555F07100E92A8B /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 944A65681957463F0094A81E /* SDL.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = A7D88B5423E2437C00DCD162;
-			remoteInfo = "Framework-iOS";
-		};
-		F3A4978A2555F07100E92A8B /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 944A65681957463F0094A81E /* SDL.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = A7D88D1523E24BED00DCD162;
-			remoteInfo = "Framework-tvOS";
-		};
-		F3A4978C2555F07100E92A8B /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 944A65681957463F0094A81E /* SDL.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = BECDF6B30761BA81005FE872;
-			remoteInfo = "Static Library";
-		};
-		F3A4978E2555F07100E92A8B /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 944A65681957463F0094A81E /* SDL.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = A7D88E5423E24D3B00DCD162;
-			remoteInfo = "Static Library-iOS";
-		};
-		F3A497902555F07100E92A8B /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 944A65681957463F0094A81E /* SDL.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = A769B23D23E259AE00872273;
-			remoteInfo = "Static Library-tvOS";
-		};
-		F3A497922555F07100E92A8B /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 944A65681957463F0094A81E /* SDL.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = DB31407717554B71006C0E22;
-			remoteInfo = "Shared Library";
-		};
-		F3A497942555F07100E92A8B /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 944A65681957463F0094A81E /* SDL.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = A75FCEB323E25AB700529352;
-			remoteInfo = "Shared Library-iOS";
-		};
-		F3A497962555F07100E92A8B /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 944A65681957463F0094A81E /* SDL.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = A75FD06C23E25AC700529352;
-			remoteInfo = "Shared Library-tvOS";
-		};
-		F3A497982555F07100E92A8B /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 944A65681957463F0094A81E /* SDL.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = BECDF6BE0761BA81005FE872;
-			remoteInfo = "Standard DMG";
-		};
-		F3A4979A2555F07100E92A8B /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 944A65681957463F0094A81E /* SDL.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = A75FDB8C23E4C74400529352;
-			remoteInfo = hidapi;
-		};
-		F3A4979C2555F07100E92A8B /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 944A65681957463F0094A81E /* SDL.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = A75FDB4923E399AC00529352;
-			remoteInfo = "hidapi-iOS";
-		};
-		F3A4979E2555F07100E92A8B /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 944A65681957463F0094A81E /* SDL.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = A75FDB6E23E3A2C900529352;
-			remoteInfo = "hidapi-tvOS";
-		};
-/* End PBXContainerItemProxy section */
-
-/* Begin PBXFileReference section */
-		1D30AB110D05D00D00671497 /* Foundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Foundation.framework; path = System/Library/Frameworks/Foundation.framework; sourceTree = SDKROOT; };
-		1D6058910D05DD3D006BFB54 /* ___PROJECTNAME___.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = "___PROJECTNAME___.app"; sourceTree = BUILT_PRODUCTS_DIR; };
-		1DF5F4DF0D08C38300B7A737 /* UIKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = UIKit.framework; path = System/Library/Frameworks/UIKit.framework; sourceTree = SDKROOT; };
-		28FD14FF0DC6FC520079059D /* OpenGLES.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = OpenGLES.framework; path = System/Library/Frameworks/OpenGLES.framework; sourceTree = SDKROOT; };
-		28FD15070DC6FC5B0079059D /* QuartzCore.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = QuartzCore.framework; path = System/Library/Frameworks/QuartzCore.framework; sourceTree = SDKROOT; };
-		8D1107310486CEB800E47090 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
-		944A65681957463F0094A81E /* SDL.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = SDL.xcodeproj; path = ../../../Xcode/SDL/SDL.xcodeproj; sourceTree = "<group>"; };
-		945C4F52195AF17F00DBBF61 /* Default-568h@2x.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = "Default-568h@2x.png"; sourceTree = "<group>"; };
-		F3A497AB2555F0BD00E92A8B /* CoreHaptics.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreHaptics.framework; path = System/Library/Frameworks/CoreHaptics.framework; sourceTree = SDKROOT; };
-		F3A497AF2555F0FF00E92A8B /* Metal.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Metal.framework; path = System/Library/Frameworks/Metal.framework; sourceTree = SDKROOT; };
-		F3A497B22555F11600E92A8B /* AVFoundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = AVFoundation.framework; path = System/Library/Frameworks/AVFoundation.framework; sourceTree = SDKROOT; };
-		FA8B4B96196703B400F8EB7C /* CoreMotion.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreMotion.framework; path = System/Library/Frameworks/CoreMotion.framework; sourceTree = SDKROOT; };
-		FAE0E9641BAF967F0098DFA4 /* GameController.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = GameController.framework; path = System/Library/Frameworks/GameController.framework; sourceTree = SDKROOT; };
-		FD779EDD0E26BA1200F39101 /* CoreAudio.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreAudio.framework; path = System/Library/Frameworks/CoreAudio.framework; sourceTree = SDKROOT; };
-		FD77A07C0E26BD8C00F39101 /* Icon.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = Icon.png; sourceTree = "<group>"; };
-		FD77A07E0E26BDA900F39101 /* Default.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = Default.png; sourceTree = "<group>"; };
-		FD77A0840E26BDB800F39101 /* AudioToolbox.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = AudioToolbox.framework; path = System/Library/Frameworks/AudioToolbox.framework; sourceTree = SDKROOT; };
-		FD77A09C0E26BDE500F39101 /* main.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = main.c; sourceTree = "<group>"; };
-		FDB8BFC50E5A0F6A00980157 /* CoreGraphics.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreGraphics.framework; path = System/Library/Frameworks/CoreGraphics.framework; sourceTree = SDKROOT; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		1D60588F0D05DD3D006BFB54 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				F3A497AD2555F0C000E92A8B /* libSDL2.a in Frameworks */,
-				FD77A0850E26BDB800F39101 /* AudioToolbox.framework in Frameworks */,
-				F3A497B32555F11600E92A8B /* AVFoundation.framework in Frameworks */,
-				1D60589F0D05DD5A006BFB54 /* Foundation.framework in Frameworks */,
-				FD779EDE0E26BA1200F39101 /* CoreAudio.framework in Frameworks */,
-				FDB8BFC60E5A0F6A00980157 /* CoreGraphics.framework in Frameworks */,
-				F3A497AC2555F0BD00E92A8B /* CoreHaptics.framework in Frameworks */,
-				FA8B4B97196703B400F8EB7C /* CoreMotion.framework in Frameworks */,
-				FAE0E9651BAF967F0098DFA4 /* GameController.framework in Frameworks */,
-				F3A497B02555F0FF00E92A8B /* Metal.framework in Frameworks */,
-				28FD15000DC6FC520079059D /* OpenGLES.framework in Frameworks */,
-				28FD15080DC6FC5B0079059D /* QuartzCore.framework in Frameworks */,
-				1DF5F4E00D08C38300B7A737 /* UIKit.framework in Frameworks */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		19C28FACFE9D520D11CA2CBB /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				1D6058910D05DD3D006BFB54 /* ___PROJECTNAME___.app */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		29B97314FDCFA39411CA2CEA /* CustomTemplate */ = {
-			isa = PBXGroup;
-			children = (
-				945C4F52195AF17F00DBBF61 /* Default-568h@2x.png */,
-				29B97315FDCFA39411CA2CEA /* Sources */,
-				29B97317FDCFA39411CA2CEA /* Resources */,
-				29B97323FDCFA39411CA2CEA /* Frameworks */,
-				19C28FACFE9D520D11CA2CBB /* Products */,
-			);
-			name = CustomTemplate;
-			sourceTree = "<group>";
-		};
-		29B97315FDCFA39411CA2CEA /* Sources */ = {
-			isa = PBXGroup;
-			children = (
-				944A65681957463F0094A81E /* SDL.xcodeproj */,
-				FD77A09C0E26BDE500F39101 /* main.c */,
-			);
-			name = Sources;
-			sourceTree = "<group>";
-		};
-		29B97317FDCFA39411CA2CEA /* Resources */ = {
-			isa = PBXGroup;
-			children = (
-				FD77A07E0E26BDA900F39101 /* Default.png */,
-				FD77A07C0E26BD8C00F39101 /* Icon.png */,
-				8D1107310486CEB800E47090 /* Info.plist */,
-			);
-			name = Resources;
-			sourceTree = "<group>";
-		};
-		29B97323FDCFA39411CA2CEA /* Frameworks */ = {
-			isa = PBXGroup;
-			children = (
-				F3A497B22555F11600E92A8B /* AVFoundation.framework */,
-				F3A497AF2555F0FF00E92A8B /* Metal.framework */,
-				F3A497AB2555F0BD00E92A8B /* CoreHaptics.framework */,
-				FAE0E9641BAF967F0098DFA4 /* GameController.framework */,
-				FA8B4B96196703B400F8EB7C /* CoreMotion.framework */,
-				FDB8BFC50E5A0F6A00980157 /* CoreGraphics.framework */,
-				FD77A0840E26BDB800F39101 /* AudioToolbox.framework */,
-				FD779EDD0E26BA1200F39101 /* CoreAudio.framework */,
-				28FD15070DC6FC5B0079059D /* QuartzCore.framework */,
-				28FD14FF0DC6FC520079059D /* OpenGLES.framework */,
-				1DF5F4DF0D08C38300B7A737 /* UIKit.framework */,
-				1D30AB110D05D00D00671497 /* Foundation.framework */,
-			);
-			name = Frameworks;
-			sourceTree = "<group>";
-		};
-		F3A497772555F07100E92A8B /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				F3A497872555F07100E92A8B /* SDL2.framework */,
-				F3A497892555F07100E92A8B /* SDL2.framework */,
-				F3A4978B2555F07100E92A8B /* SDL2.framework */,
-				F3A4978D2555F07100E92A8B /* libSDL2.a */,
-				F3A4978F2555F07100E92A8B /* libSDL2.a */,
-				F3A497912555F07100E92A8B /* libSDL2.a */,
-				F3A497932555F07100E92A8B /* libSDL2.dylib */,
-				F3A497952555F07100E92A8B /* libSDL2.dylib */,
-				F3A497972555F07100E92A8B /* libSDL2.dylib */,
-				F3A497992555F07100E92A8B /* SDL2 */,
-				F3A4979B2555F07100E92A8B /* hidapi.framework */,
-				F3A4979D2555F07100E92A8B /* hidapi.framework */,
-				F3A4979F2555F07100E92A8B /* hidapi.framework */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXNativeTarget section */
-		1D6058900D05DD3D006BFB54 /* ___PROJECTNAME___ */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 1D6058960D05DD3E006BFB54 /* Build configuration list for PBXNativeTarget "___PROJECTNAME___" */;
-			buildPhases = (
-				1D60588D0D05DD3D006BFB54 /* Resources */,
-				1D60588E0D05DD3D006BFB54 /* Sources */,
-				1D60588F0D05DD3D006BFB54 /* Frameworks */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = "___PROJECTNAME___";
-			productName = "___PROJECTNAME___";
-			productReference = 1D6058910D05DD3D006BFB54 /* ___PROJECTNAME___.app */;
-			productType = "com.apple.product-type.application";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		29B97313FDCFA39411CA2CEA /* Project object */ = {
-			isa = PBXProject;
-			attributes = {
-				LastUpgradeCheck = 0510;
-			};
-			buildConfigurationList = C01FCF4E08A954540054247B /* Build configuration list for PBXProject "___PROJECTNAME___" */;
-			compatibilityVersion = "Xcode 3.2";
-			developmentRegion = English;
-			hasScannedForEncodings = 1;
-			knownRegions = (
-				English,
-				Japanese,
-				French,
-				German,
-			);
-			mainGroup = 29B97314FDCFA39411CA2CEA /* CustomTemplate */;
-			projectDirPath = "";
-			projectReferences = (
-				{
-					ProductGroup = F3A497772555F07100E92A8B /* Products */;
-					ProjectRef = 944A65681957463F0094A81E /* SDL.xcodeproj */;
-				},
-			);
-			projectRoot = "";
-			targets = (
-				1D6058900D05DD3D006BFB54 /* ___PROJECTNAME___ */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXReferenceProxy section */
-		F3A497872555F07100E92A8B /* SDL2.framework */ = {
-			isa = PBXReferenceProxy;
-			fileType = wrapper.framework;
-			path = SDL2.framework;
-			remoteRef = F3A497862555F07100E92A8B /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		F3A497892555F07100E92A8B /* SDL2.framework */ = {
-			isa = PBXReferenceProxy;
-			fileType = wrapper.framework;
-			path = SDL2.framework;
-			remoteRef = F3A497882555F07100E92A8B /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		F3A4978B2555F07100E92A8B /* SDL2.framework */ = {
-			isa = PBXReferenceProxy;
-			fileType = wrapper.framework;
-			path = SDL2.framework;
-			remoteRef = F3A4978A2555F07100E92A8B /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		F3A4978D2555F07100E92A8B /* libSDL2.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libSDL2.a;
-			remoteRef = F3A4978C2555F07100E92A8B /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		F3A4978F2555F07100E92A8B /* libSDL2.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libSDL2.a;
-			remoteRef = F3A4978E2555F07100E92A8B /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		F3A497912555F07100E92A8B /* libSDL2.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libSDL2.a;
-			remoteRef = F3A497902555F07100E92A8B /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		F3A497932555F07100E92A8B /* libSDL2.dylib */ = {
-			isa = PBXReferenceProxy;
-			fileType = "compiled.mach-o.dylib";
-			path = libSDL2.dylib;
-			remoteRef = F3A497922555F07100E92A8B /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		F3A497952555F07100E92A8B /* libSDL2.dylib */ = {
-			isa = PBXReferenceProxy;
-			fileType = "compiled.mach-o.dylib";
-			path = libSDL2.dylib;
-			remoteRef = F3A497942555F07100E92A8B /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		F3A497972555F07100E92A8B /* libSDL2.dylib */ = {
-			isa = PBXReferenceProxy;
-			fileType = "compiled.mach-o.dylib";
-			path = libSDL2.dylib;
-			remoteRef = F3A497962555F07100E92A8B /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		F3A497992555F07100E92A8B /* SDL2 */ = {
-			isa = PBXReferenceProxy;
-			fileType = "compiled.mach-o.executable";
-			path = SDL2;
-			remoteRef = F3A497982555F07100E92A8B /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		F3A4979B2555F07100E92A8B /* hidapi.framework */ = {
-			isa = PBXReferenceProxy;
-			fileType = wrapper.framework;
-			path = hidapi.framework;
-			remoteRef = F3A4979A2555F07100E92A8B /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		F3A4979D2555F07100E92A8B /* hidapi.framework */ = {
-			isa = PBXReferenceProxy;
-			fileType = wrapper.framework;
-			path = hidapi.framework;
-			remoteRef = F3A4979C2555F07100E92A8B /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		F3A4979F2555F07100E92A8B /* hidapi.framework */ = {
-			isa = PBXReferenceProxy;
-			fileType = wrapper.framework;
-			path = hidapi.framework;
-			remoteRef = F3A4979E2555F07100E92A8B /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-/* End PBXReferenceProxy section */
-
-/* Begin PBXResourcesBuildPhase section */
-		1D60588D0D05DD3D006BFB54 /* Resources */ = {
-			isa = PBXResourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				FD77A07D0E26BD8C00F39101 /* Icon.png in Resources */,
-				FD77A07F0E26BDA900F39101 /* Default.png in Resources */,
-				945C4F53195AF17F00DBBF61 /* Default-568h@2x.png in Resources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXResourcesBuildPhase section */
-
-/* Begin PBXSourcesBuildPhase section */
-		1D60588E0D05DD3D006BFB54 /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				FD77A09D0E26BDE500F39101 /* main.c in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin XCBuildConfiguration section */
-		1D6058940D05DD3E006BFB54 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				COPY_PHASE_STRIP = NO;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				GCC_PRECOMPILE_PREFIX_HEADER = YES;
-				GCC_PREFIX_HEADER = "";
-				INFOPLIST_FILE = Info.plist;
-				LIBRARY_SEARCH_PATHS = "$(inherited)";
-				PRODUCT_NAME = "___PROJECTNAME___";
-				USER_HEADER_SEARCH_PATHS = ../../../include;
-			};
-			name = Debug;
-		};
-		1D6058950D05DD3E006BFB54 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				COPY_PHASE_STRIP = YES;
-				GCC_PRECOMPILE_PREFIX_HEADER = YES;
-				GCC_PREFIX_HEADER = "";
-				INFOPLIST_FILE = Info.plist;
-				LIBRARY_SEARCH_PATHS = "$(inherited)";
-				PRODUCT_NAME = "___PROJECTNAME___";
-				USER_HEADER_SEARCH_PATHS = ../../../include;
-			};
-			name = Release;
-		};
-		C01FCF4F08A954540054247B /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
-				GCC_C_LANGUAGE_STANDARD = c99;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				ONLY_ACTIVE_ARCH = YES;
-				OTHER_CFLAGS = "";
-				PREBINDING = NO;
-				SDKROOT = iphoneos;
-			};
-			name = Debug;
-		};
-		C01FCF5008A954540054247B /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
-				GCC_C_LANGUAGE_STANDARD = c99;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				OTHER_CFLAGS = "";
-				PREBINDING = NO;
-				SDKROOT = iphoneos;
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		1D6058960D05DD3E006BFB54 /* Build configuration list for PBXNativeTarget "___PROJECTNAME___" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				1D6058940D05DD3E006BFB54 /* Debug */,
-				1D6058950D05DD3E006BFB54 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		C01FCF4E08A954540054247B /* Build configuration list for PBXProject "___PROJECTNAME___" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				C01FCF4F08A954540054247B /* Debug */,
-				C01FCF5008A954540054247B /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 29B97313FDCFA39411CA2CEA /* Project object */;
-}
diff --git a/Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/main.c b/Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/main.c
deleted file mode 100644
index 52fd9a49a..000000000
--- a/Engine/lib/sdl/Xcode-iOS/Template/SDL iOS Application/main.c	
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- *  rectangles.c
- *  written by Holmes Futrell
- *  use however you want
- */
-
-#include "SDL.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <time.h>
-
-#define SCREEN_WIDTH 320
-#define SCREEN_HEIGHT 480
-
-int
-randomInt(int min, int max)
-{
-    return min + rand() % (max - min + 1);
-}
-
-void
-render(SDL_Renderer *renderer)
-{
-
-    SDL_Rect rect;
-    Uint8 r, g, b;
-
-    /* Clear the screen */
-    SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
-    SDL_RenderClear(renderer);
-
-    /*  Come up with a random rectangle */
-    rect.w = randomInt(64, 128);
-    rect.h = randomInt(64, 128);
-    rect.x = randomInt(0, SCREEN_WIDTH);
-    rect.y = randomInt(0, SCREEN_HEIGHT);
-
-    /* Come up with a random color */
-    r = randomInt(50, 255);
-    g = randomInt(50, 255);
-    b = randomInt(50, 255);
-    SDL_SetRenderDrawColor(renderer, r, g, b, 255);
-
-    /*  Fill the rectangle in the color */
-    SDL_RenderFillRect(renderer, &rect);
-
-    /* update screen */
-    SDL_RenderPresent(renderer);
-}
-
-int
-main(int argc, char *argv[])
-{
-
-    SDL_Window *window;
-    SDL_Renderer *renderer;
-    int done;
-    SDL_Event event;
-
-    /* initialize SDL */
-    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
-        printf("Could not initialize SDL\n");
-        return 1;
-    }
-
-    /* seed random number generator */
-    srand(time(NULL));
-
-    /* create window and renderer */
-    window =
-        SDL_CreateWindow(NULL, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT,
-                         SDL_WINDOW_OPENGL);
-    if (!window) {
-        printf("Could not initialize Window\n");
-        return 1;
-    }
-
-    renderer = SDL_CreateRenderer(window, -1, 0);
-    if (!renderer) {
-        printf("Could not create renderer\n");
-        return 1;
-    }
-
-    /* Enter render loop, waiting for user to quit */
-    done = 0;
-    while (!done) {
-        while (SDL_PollEvent(&event)) {
-            if (event.type == SDL_QUIT) {
-                done = 1;
-            }
-        }
-        render(renderer);
-        SDL_Delay(1);
-    }
-
-    /* shutdown SDL */
-    SDL_Quit();
-
-    return 0;
-}
diff --git a/Engine/lib/sdl/Xcode/SDL/Info-Framework.plist b/Engine/lib/sdl/Xcode/SDL/Info-Framework.plist
index ee9ddd564..19049bd46 100644
--- a/Engine/lib/sdl/Xcode/SDL/Info-Framework.plist
+++ b/Engine/lib/sdl/Xcode/SDL/Info-Framework.plist
@@ -19,10 +19,10 @@
 	<key>CFBundlePackageType</key>
 	<string>FMWK</string>
 	<key>CFBundleShortVersionString</key>
-	<string>2.0.14</string>
+	<string>2.0.21</string>
 	<key>CFBundleSignature</key>
 	<string>SDLX</string>
 	<key>CFBundleVersion</key>
-	<string>2.0.14</string>
+	<string>2.0.21</string>
 </dict>
 </plist>
diff --git a/Engine/lib/sdl/Xcode/SDL/SDL.xcodeproj/project.pbxproj b/Engine/lib/sdl/Xcode/SDL/SDL.xcodeproj/project.pbxproj
index 3ec037324..cd8affb60 100644
--- a/Engine/lib/sdl/Xcode/SDL/SDL.xcodeproj/project.pbxproj
+++ b/Engine/lib/sdl/Xcode/SDL/SDL.xcodeproj/project.pbxproj
@@ -3,7 +3,7 @@
 	archiveVersion = 1;
 	classes = {
 	};
-	objectVersion = 46;
+	objectVersion = 52;
 	objects = {
 
 /* Begin PBXBuildFile section */
@@ -93,6 +93,24 @@
 		75E09169241EA924004729E1 /* SDL_virtualjoystick_c.h in Headers */ = {isa = PBXBuildFile; fileRef = 75E09159241EA924004729E1 /* SDL_virtualjoystick_c.h */; };
 		75E0916A241EA924004729E1 /* SDL_virtualjoystick_c.h in Headers */ = {isa = PBXBuildFile; fileRef = 75E09159241EA924004729E1 /* SDL_virtualjoystick_c.h */; };
 		75E0916B241EA924004729E1 /* SDL_virtualjoystick_c.h in Headers */ = {isa = PBXBuildFile; fileRef = 75E09159241EA924004729E1 /* SDL_virtualjoystick_c.h */; };
+		A1626A3E2617006A003F1973 /* SDL_triangle.c in Sources */ = {isa = PBXBuildFile; fileRef = A1626A3D2617006A003F1973 /* SDL_triangle.c */; };
+		A1626A3F2617006A003F1973 /* SDL_triangle.c in Sources */ = {isa = PBXBuildFile; fileRef = A1626A3D2617006A003F1973 /* SDL_triangle.c */; };
+		A1626A402617006A003F1973 /* SDL_triangle.c in Sources */ = {isa = PBXBuildFile; fileRef = A1626A3D2617006A003F1973 /* SDL_triangle.c */; };
+		A1626A412617006A003F1973 /* SDL_triangle.c in Sources */ = {isa = PBXBuildFile; fileRef = A1626A3D2617006A003F1973 /* SDL_triangle.c */; };
+		A1626A422617006A003F1973 /* SDL_triangle.c in Sources */ = {isa = PBXBuildFile; fileRef = A1626A3D2617006A003F1973 /* SDL_triangle.c */; };
+		A1626A432617006A003F1973 /* SDL_triangle.c in Sources */ = {isa = PBXBuildFile; fileRef = A1626A3D2617006A003F1973 /* SDL_triangle.c */; };
+		A1626A442617006A003F1973 /* SDL_triangle.c in Sources */ = {isa = PBXBuildFile; fileRef = A1626A3D2617006A003F1973 /* SDL_triangle.c */; };
+		A1626A452617006A003F1973 /* SDL_triangle.c in Sources */ = {isa = PBXBuildFile; fileRef = A1626A3D2617006A003F1973 /* SDL_triangle.c */; };
+		A1626A462617006A003F1973 /* SDL_triangle.c in Sources */ = {isa = PBXBuildFile; fileRef = A1626A3D2617006A003F1973 /* SDL_triangle.c */; };
+		A1626A522617008D003F1973 /* SDL_triangle.h in Headers */ = {isa = PBXBuildFile; fileRef = A1626A512617008C003F1973 /* SDL_triangle.h */; };
+		A1626A532617008D003F1973 /* SDL_triangle.h in Headers */ = {isa = PBXBuildFile; fileRef = A1626A512617008C003F1973 /* SDL_triangle.h */; };
+		A1626A542617008D003F1973 /* SDL_triangle.h in Headers */ = {isa = PBXBuildFile; fileRef = A1626A512617008C003F1973 /* SDL_triangle.h */; };
+		A1626A552617008D003F1973 /* SDL_triangle.h in Headers */ = {isa = PBXBuildFile; fileRef = A1626A512617008C003F1973 /* SDL_triangle.h */; };
+		A1626A562617008D003F1973 /* SDL_triangle.h in Headers */ = {isa = PBXBuildFile; fileRef = A1626A512617008C003F1973 /* SDL_triangle.h */; };
+		A1626A572617008D003F1973 /* SDL_triangle.h in Headers */ = {isa = PBXBuildFile; fileRef = A1626A512617008C003F1973 /* SDL_triangle.h */; };
+		A1626A582617008D003F1973 /* SDL_triangle.h in Headers */ = {isa = PBXBuildFile; fileRef = A1626A512617008C003F1973 /* SDL_triangle.h */; };
+		A1626A592617008D003F1973 /* SDL_triangle.h in Headers */ = {isa = PBXBuildFile; fileRef = A1626A512617008C003F1973 /* SDL_triangle.h */; };
+		A1626A5A2617008D003F1973 /* SDL_triangle.h in Headers */ = {isa = PBXBuildFile; fileRef = A1626A512617008C003F1973 /* SDL_triangle.h */; };
 		A7381E961D8B69D600B177DD /* CoreAudio.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = A7381E951D8B69D600B177DD /* CoreAudio.framework */; };
 		A7381E971D8B6A0300B177DD /* AudioToolbox.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = A7381E931D8B69C300B177DD /* AudioToolbox.framework */; };
 		A75FCCFD23E25AB700529352 /* SDL_shaders_metal_tvos.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8E323E2514000DCD162 /* SDL_shaders_metal_tvos.h */; };
@@ -107,7 +125,6 @@
 		A75FCD0723E25AB700529352 /* SDL_glfuncs.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A90E23E2514000DCD162 /* SDL_glfuncs.h */; };
 		A75FCD0823E25AB700529352 /* SDL_atomic.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557CA1595D4D800BBD41B /* SDL_atomic.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCD0923E25AB700529352 /* SDL_rect_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A60C23E2513D00DCD162 /* SDL_rect_c.h */; };
-		A75FCD0A23E25AB700529352 /* SDL_x11xinput2.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71323E2513E00DCD162 /* SDL_x11xinput2.h */; };
 		A75FCD0B23E25AB700529352 /* SDL_shaders_metal_osx.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8E223E2514000DCD162 /* SDL_shaders_metal_osx.h */; };
 		A75FCD0C23E25AB700529352 /* SDL_shaders_metal_ios.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8DF23E2514000DCD162 /* SDL_shaders_metal_ios.h */; };
 		A75FCD0D23E25AB700529352 /* SDL_offscreenwindow.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A5F523E2513D00DCD162 /* SDL_offscreenwindow.h */; };
@@ -123,19 +140,15 @@
 		A75FCD1723E25AB700529352 /* SDL_clipboard.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557CD1595D4D800BBD41B /* SDL_clipboard.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCD1823E25AB700529352 /* SDL_dataqueue.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A57023E2513D00DCD162 /* SDL_dataqueue.h */; };
 		A75FCD1923E25AB700529352 /* SDL_error_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A57523E2513D00DCD162 /* SDL_error_c.h */; };
-		A75FCD1A23E25AB700529352 /* SDL_x11events.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71E23E2513E00DCD162 /* SDL_x11events.h */; };
 		A75FCD1B23E25AB700529352 /* SDL_config.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557CF1595D4D800BBD41B /* SDL_config.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCD1C23E25AB700529352 /* SDL_d3dmath.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8DC23E2514000DCD162 /* SDL_d3dmath.h */; };
-		A75FCD1D23E25AB700529352 /* SDL_x11window.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71723E2513E00DCD162 /* SDL_x11window.h */; };
 		A75FCD1F23E25AB700529352 /* SDL_egl_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A60423E2513D00DCD162 /* SDL_egl_c.h */; };
 		A75FCD2023E25AB700529352 /* SDL_copying.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557D01595D4D800BBD41B /* SDL_copying.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCD2123E25AB700529352 /* yuv_rgb.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A77223E2513E00DCD162 /* yuv_rgb.h */; };
 		A75FCD2223E25AB700529352 /* SDL_dummyaudio.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A87123E2513F00DCD162 /* SDL_dummyaudio.h */; };
 		A75FCD2323E25AB700529352 /* SDL_uikitmessagebox.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A62623E2513D00DCD162 /* SDL_uikitmessagebox.h */; };
-		A75FCD2423E25AB700529352 /* SDL_x11messagebox.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A6FD23E2513E00DCD162 /* SDL_x11messagebox.h */; };
 		A75FCD2523E25AB700529352 /* SDL_thread_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A77823E2513E00DCD162 /* SDL_thread_c.h */; };
 		A75FCD2623E25AB700529352 /* SDL_cocoamessagebox.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A69423E2513E00DCD162 /* SDL_cocoamessagebox.h */; };
-		A75FCD2723E25AB700529352 /* SDL_x11shape.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70123E2513E00DCD162 /* SDL_x11shape.h */; };
 		A75FCD2823E25AB700529352 /* SDL_cpuinfo.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557D11595D4D800BBD41B /* SDL_cpuinfo.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCD2923E25AB700529352 /* SDL_endian.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557D21595D4D800BBD41B /* SDL_endian.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCD2A23E25AB700529352 /* SDL_error.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557D31595D4D800BBD41B /* SDL_error.h */; settings = {ATTRIBUTES = (Public, ); }; };
@@ -144,7 +157,6 @@
 		A75FCD2D23E25AB700529352 /* SDL_gamecontroller.h in Headers */ = {isa = PBXBuildFile; fileRef = A77E6EB3167AB0A90010E40B /* SDL_gamecontroller.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCD2E23E25AB700529352 /* SDL_hidapijoystick_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A7C723E2513E00DCD162 /* SDL_hidapijoystick_c.h */; };
 		A75FCD3023E25AB700529352 /* SDL_pixels_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A74023E2513E00DCD162 /* SDL_pixels_c.h */; };
-		A75FCD3123E25AB700529352 /* SDL_x11modes.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70F23E2513E00DCD162 /* SDL_x11modes.h */; };
 		A75FCD3223E25AB700529352 /* SDL_joystick_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A7D023E2513E00DCD162 /* SDL_joystick_c.h */; };
 		A75FCD3323E25AB700529352 /* vk_sdk_platform.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73D23E2513E00DCD162 /* vk_sdk_platform.h */; };
 		A75FCD3423E25AB700529352 /* blank_cursor.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A93223E2514000DCD162 /* blank_cursor.h */; };
@@ -158,7 +170,6 @@
 		A75FCD3C23E25AB700529352 /* SDL_hints.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557D71595D4D800BBD41B /* SDL_hints.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCD3D23E25AB700529352 /* SDL_blit_slow.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A66323E2513E00DCD162 /* SDL_blit_slow.h */; };
 		A75FCD3E23E25AB700529352 /* SDL_yuv_sw_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8EC23E2514000DCD162 /* SDL_yuv_sw_c.h */; };
-		A75FCD3F23E25AB700529352 /* SDL_x11opengl.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70E23E2513E00DCD162 /* SDL_x11opengl.h */; };
 		A75FCD4023E25AB700529352 /* SDL_windowevents_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A94323E2514000DCD162 /* SDL_windowevents_c.h */; };
 		A75FCD4123E25AB700529352 /* SDL_joystick.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557D91595D4D800BBD41B /* SDL_joystick.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCD4223E25AB700529352 /* SDL_cocoavideo.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A69323E2513E00DCD162 /* SDL_cocoavideo.h */; };
@@ -168,16 +179,12 @@
 		A75FCD4623E25AB700529352 /* SDL_shaders_gl.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A90D23E2514000DCD162 /* SDL_shaders_gl.h */; };
 		A75FCD4723E25AB700529352 /* SDL_systhread_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A78423E2513E00DCD162 /* SDL_systhread_c.h */; };
 		A75FCD4823E25AB700529352 /* SDL_keycode.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557DB1595D4D800BBD41B /* SDL_keycode.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		A75FCD4923E25AB700529352 /* SDL_x11keyboard.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71C23E2513E00DCD162 /* SDL_x11keyboard.h */; };
 		A75FCD4A23E25AB700529352 /* SDL_cocoakeyboard.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A68023E2513E00DCD162 /* SDL_cocoakeyboard.h */; };
 		A75FCD4B23E25AB700529352 /* SDL_uikitvulkan.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A63323E2513D00DCD162 /* SDL_uikitvulkan.h */; };
-		A75FCD4C23E25AB700529352 /* SDL_x11framebuffer.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71823E2513E00DCD162 /* SDL_x11framebuffer.h */; };
-		A75FCD4D23E25AB700529352 /* SDL_x11video.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72023E2513E00DCD162 /* SDL_x11video.h */; };
 		A75FCD4E23E25AB700529352 /* vulkan.hpp in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73223E2513E00DCD162 /* vulkan.hpp */; };
 		A75FCD4F23E25AB700529352 /* SDL_loadso.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557DC1595D4D800BBD41B /* SDL_loadso.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCD5023E25AB700529352 /* gl2ext.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72323E2513E00DCD162 /* gl2ext.h */; };
 		A75FCD5123E25AB700529352 /* SDL_clipboardevents_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A93923E2514000DCD162 /* SDL_clipboardevents_c.h */; };
-		A75FCD5223E25AB700529352 /* SDL_x11touch.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A6FC23E2513E00DCD162 /* SDL_x11touch.h */; };
 		A75FCD5323E25AB700529352 /* SDL_syshaptic_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A5CF23E2513D00DCD162 /* SDL_syshaptic_c.h */; };
 		A75FCD5423E25AB700529352 /* SDL_hints_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8D123E2514000DCD162 /* SDL_hints_c.h */; };
 		A75FCD5523E25AB700529352 /* SDL_audiodev_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A87723E2513F00DCD162 /* SDL_audiodev_c.h */; };
@@ -201,9 +208,7 @@
 		A75FCD6723E25AB700529352 /* SDL_wave.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8A223E2513F00DCD162 /* SDL_wave.h */; };
 		A75FCD6823E25AB700529352 /* SDL_cocoaopengl.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A68D23E2513E00DCD162 /* SDL_cocoaopengl.h */; };
 		A75FCD6923E25AB700529352 /* yuv_rgb_sse_func.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A77023E2513E00DCD162 /* yuv_rgb_sse_func.h */; };
-		A75FCD6A23E25AB700529352 /* imKStoUCS.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71F23E2513E00DCD162 /* imKStoUCS.h */; };
 		A75FCD6B23E25AB700529352 /* SDL_offscreenevents_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A5EE23E2513D00DCD162 /* SDL_offscreenevents_c.h */; };
-		A75FCD6C23E25AB700529352 /* SDL_x11sym.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70D23E2513E00DCD162 /* SDL_x11sym.h */; };
 		A75FCD6D23E25AB700529352 /* SDL_coreaudio.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8BA23E2513F00DCD162 /* SDL_coreaudio.h */; };
 		A75FCD6E23E25AB700529352 /* SDL_draw.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8FA23E2514000DCD162 /* SDL_draw.h */; };
 		A75FCD6F23E25AB700529352 /* SDL_drawline.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8F723E2514000DCD162 /* SDL_drawline.h */; };
@@ -213,7 +218,6 @@
 		A75FCD7323E25AB700529352 /* SDL_yuv_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A76A23E2513E00DCD162 /* SDL_yuv_c.h */; };
 		A75FCD7423E25AB700529352 /* scancodes_xfree86.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A94123E2514000DCD162 /* scancodes_xfree86.h */; };
 		A75FCD7523E25AB700529352 /* SDL_syspower.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A7E223E2513F00DCD162 /* SDL_syspower.h */; };
-		A75FCD7623E25AB700529352 /* SDL_x11clipboard.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71D23E2513E00DCD162 /* SDL_x11clipboard.h */; };
 		A75FCD7723E25AB700529352 /* SDL_name.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557E11595D4D800BBD41B /* SDL_name.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCD7823E25AB700529352 /* eglext.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72A23E2513E00DCD162 /* eglext.h */; };
 		A75FCD7923E25AB700529352 /* SDL_events_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A94223E2514000DCD162 /* SDL_events_c.h */; };
@@ -231,14 +235,12 @@
 		A75FCD8623E25AB700529352 /* SDL_sysjoystick.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A7CF23E2513E00DCD162 /* SDL_sysjoystick.h */; };
 		A75FCD8723E25AB700529352 /* SDL_steamcontroller.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A7A523E2513E00DCD162 /* SDL_steamcontroller.h */; };
 		A75FCD8823E25AB700529352 /* scancodes_linux.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A93623E2514000DCD162 /* scancodes_linux.h */; };
-		A75FCD8923E25AB700529352 /* SDL_x11dyn.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71923E2513E00DCD162 /* SDL_x11dyn.h */; };
 		A75FCD8A23E25AB700529352 /* SDL_touch_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A93723E2514000DCD162 /* SDL_touch_c.h */; };
 		A75FCD8B23E25AB700529352 /* SDL_gamecontrollerdb.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A79E23E2513E00DCD162 /* SDL_gamecontrollerdb.h */; };
 		A75FCD8C23E25AB700529352 /* SDL_cocoavulkan.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A68F23E2513E00DCD162 /* SDL_cocoavulkan.h */; };
 		A75FCD8D23E25AB700529352 /* gl2platform.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72523E2513E00DCD162 /* gl2platform.h */; };
 		A75FCD8E23E25AB700529352 /* SDL_pixels.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557E51595D4D800BBD41B /* SDL_pixels.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCD8F23E25AB700529352 /* vk_layer.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72D23E2513E00DCD162 /* vk_layer.h */; };
-		A75FCD9023E25AB700529352 /* SDL_cocoamousetap.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A68823E2513E00DCD162 /* SDL_cocoamousetap.h */; };
 		A75FCD9123E25AB700529352 /* vk_platform.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73123E2513E00DCD162 /* vk_platform.h */; };
 		A75FCD9223E25AB700529352 /* SDL_cocoametalview.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A68623E2513E00DCD162 /* SDL_cocoametalview.h */; };
 		A75FCD9323E25AB700529352 /* SDL_cocoaopengles.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A69023E2513E00DCD162 /* SDL_cocoaopengles.h */; };
@@ -252,7 +254,6 @@
 		A75FCD9B23E25AB700529352 /* SDL_offscreenopengl.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A5F323E2513D00DCD162 /* SDL_offscreenopengl.h */; };
 		A75FCD9D23E25AB700529352 /* scancodes_darwin.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A93423E2514000DCD162 /* scancodes_darwin.h */; };
 		A75FCD9E23E25AB700529352 /* controller_type.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A7D923E2513E00DCD162 /* controller_type.h */; };
-		A75FCD9F23E25AB700529352 /* SDL_x11opengles.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70323E2513E00DCD162 /* SDL_x11opengles.h */; };
 		A75FCDA023E25AB700529352 /* SDL_uikitclipboard.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A62123E2513D00DCD162 /* SDL_uikitclipboard.h */; };
 		A75FCDA123E25AB700529352 /* vulkan_xlib.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73A23E2513E00DCD162 /* vulkan_xlib.h */; };
 		A75FCDA223E25AB700529352 /* SDL_uikitwindow.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A62723E2513D00DCD162 /* SDL_uikitwindow.h */; };
@@ -267,7 +268,6 @@
 		A75FCDAB23E25AB700529352 /* SDL_blit_copy.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A76623E2513E00DCD162 /* SDL_blit_copy.h */; };
 		A75FCDAC23E25AB700529352 /* SDL_RLEaccel_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A76723E2513E00DCD162 /* SDL_RLEaccel_c.h */; };
 		A75FCDAD23E25AB700529352 /* eglplatform.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72B23E2513E00DCD162 /* eglplatform.h */; };
-		A75FCDAE23E25AB700529352 /* edid.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71423E2513E00DCD162 /* edid.h */; };
 		A75FCDAF23E25AB700529352 /* SDL_revision.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557EB1595D4D800BBD41B /* SDL_revision.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCDB023E25AB700529352 /* SDL_systhread.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A77723E2513E00DCD162 /* SDL_systhread.h */; };
 		A75FCDB123E25AB700529352 /* SDL_rwops.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557EC1595D4D800BBD41B /* SDL_rwops.h */; settings = {ATTRIBUTES = (Public, ); }; };
@@ -319,10 +319,8 @@
 		A75FCDE123E25AB700529352 /* SDL_sysvideo.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A61723E2513D00DCD162 /* SDL_sysvideo.h */; };
 		A75FCDE223E25AB700529352 /* SDL_opengles2_gl2platform.h in Headers */ = {isa = PBXBuildFile; fileRef = AAC070F7195606770073DCDF /* SDL_opengles2_gl2platform.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCDE323E25AB700529352 /* SDL_opengles2_gl2ext.h in Headers */ = {isa = PBXBuildFile; fileRef = AAC070F6195606770073DCDF /* SDL_opengles2_gl2ext.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		A75FCDE423E25AB700529352 /* SDL_x11mouse.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71A23E2513E00DCD162 /* SDL_x11mouse.h */; };
 		A75FCDE523E25AB700529352 /* SDL_dynapi_overrides.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A5D923E2513D00DCD162 /* SDL_dynapi_overrides.h */; };
 		A75FCDE623E25AB700529352 /* SDL_cocoawindow.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A69223E2513E00DCD162 /* SDL_cocoawindow.h */; };
-		A75FCDE723E25AB700529352 /* SDL_x11vulkan.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71523E2513E00DCD162 /* SDL_x11vulkan.h */; };
 		A75FCDE923E25AB700529352 /* SDL_drawline.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8F123E2514000DCD162 /* SDL_drawline.c */; };
 		A75FCDEA23E25AB700529352 /* SDL_yuv.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A67C23E2513E00DCD162 /* SDL_yuv.c */; };
 		A75FCDEB23E25AB700529352 /* SDL_sysfilesystem.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A7FE23E2513F00DCD162 /* SDL_sysfilesystem.m */; };
@@ -335,19 +333,16 @@
 		A75FCDF223E25AB700529352 /* SDL_render_metal.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8DE23E2514000DCD162 /* SDL_render_metal.m */; };
 		A75FCDF323E25AB700529352 /* SDL_clipboard.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A67B23E2513E00DCD162 /* SDL_clipboard.c */; };
 		A75FCDF423E25AB700529352 /* SDL_cocoaevents.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A68923E2513E00DCD162 /* SDL_cocoaevents.m */; };
-		A75FCDF523E25AB700529352 /* SDL_x11messagebox.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71023E2513E00DCD162 /* SDL_x11messagebox.c */; };
 		A75FCDF623E25AB700529352 /* SDL_audiocvt.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8A123E2513F00DCD162 /* SDL_audiocvt.c */; };
 		A75FCDF723E25AB700529352 /* SDL_shape.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A76923E2513E00DCD162 /* SDL_shape.c */; };
 		A75FCDF823E25AB700529352 /* SDL_rotate.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8F423E2514000DCD162 /* SDL_rotate.c */; };
 		A75FCDF923E25AB700529352 /* SDL_coremotionsensor.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A57C23E2513D00DCD162 /* SDL_coremotionsensor.m */; };
 		A75FCDFA23E25AB700529352 /* SDL_touch.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A93E23E2514000DCD162 /* SDL_touch.c */; };
-		A75FCDFB23E25AB700529352 /* SDL_x11events.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70A23E2513E00DCD162 /* SDL_x11events.c */; };
 		A75FCDFC23E25AB700529352 /* SDL_uikitmessagebox.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A61B23E2513D00DCD162 /* SDL_uikitmessagebox.m */; };
 		A75FCDFD23E25AB700529352 /* SDL_thread.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A77923E2513E00DCD162 /* SDL_thread.c */; };
 		A75FCDFE23E25AB700529352 /* SDL_hidapi_xbox360w.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A7C823E2513E00DCD162 /* SDL_hidapi_xbox360w.c */; };
 		A75FCDFF23E25AB700529352 /* SDL_atomic.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A57423E2513D00DCD162 /* SDL_atomic.c */; };
 		A75FCE0023E25AB700529352 /* SDL_displayevents.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A92D23E2514000DCD162 /* SDL_displayevents.c */; };
-		A75FCE0123E25AB700529352 /* SDL_cocoamousetap.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A69723E2513E00DCD162 /* SDL_cocoamousetap.m */; };
 		A75FCE0223E25AB700529352 /* SDL_log.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A5DD23E2513D00DCD162 /* SDL_log.c */; };
 		A75FCE0323E25AB700529352 /* SDL_cocoaopengl.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A67F23E2513E00DCD162 /* SDL_cocoaopengl.m */; };
 		A75FCE0423E25AB700529352 /* SDL_offscreenframebuffer.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A5F223E2513D00DCD162 /* SDL_offscreenframebuffer.c */; };
@@ -362,14 +357,12 @@
 		A75FCE0D23E25AB700529352 /* SDL_systimer.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A5E223E2513D00DCD162 /* SDL_systimer.c */; };
 		A75FCE0E23E25AB700529352 /* SDL_uikitclipboard.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A62A23E2513D00DCD162 /* SDL_uikitclipboard.m */; };
 		A75FCE0F23E25AB700529352 /* SDL_render_sw.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8F923E2514000DCD162 /* SDL_render_sw.c */; };
-		A75FCE1023E25AB700529352 /* SDL_x11video.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70823E2513E00DCD162 /* SDL_x11video.c */; };
 		A75FCE1123E25AB700529352 /* SDL_syssem.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A78323E2513E00DCD162 /* SDL_syssem.c */; };
 		A75FCE1223E25AB700529352 /* SDL_hidapi_xbox360.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A7C223E2513E00DCD162 /* SDL_hidapi_xbox360.c */; };
 		A75FCE1323E25AB700529352 /* SDL_coreaudio.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8BB23E2513F00DCD162 /* SDL_coreaudio.m */; };
 		A75FCE1423E25AB700529352 /* SDL_blendline.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8FB23E2514000DCD162 /* SDL_blendline.c */; };
 		A75FCE1523E25AB700529352 /* SDL_blit_A.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A66423E2513E00DCD162 /* SDL_blit_A.c */; };
 		A75FCE1623E25AB700529352 /* SDL_d3dmath.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8FF23E2514000DCD162 /* SDL_d3dmath.c */; };
-		A75FCE1723E25AB700529352 /* SDL_x11mouse.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70423E2513E00DCD162 /* SDL_x11mouse.c */; };
 		A75FCE1823E25AB700529352 /* SDL_nullvideo.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A60823E2513D00DCD162 /* SDL_nullvideo.c */; };
 		A75FCE1923E25AB700529352 /* SDL_offscreenevents.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A5F023E2513D00DCD162 /* SDL_offscreenevents.c */; };
 		A75FCE1A23E25AB700529352 /* SDL_uikitview.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A62923E2513D00DCD162 /* SDL_uikitview.m */; };
@@ -380,7 +373,6 @@
 		A75FCE1F23E25AB700529352 /* s_copysign.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A91423E2514000DCD162 /* s_copysign.c */; };
 		A75FCE2023E25AB700529352 /* SDL_haptic.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A5C523E2513D00DCD162 /* SDL_haptic.c */; };
 		A75FCE2123E25AB700529352 /* SDL_uikitvulkan.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A62523E2513D00DCD162 /* SDL_uikitvulkan.m */; };
-		A75FCE2223E25AB700529352 /* SDL_x11modes.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A6FE23E2513E00DCD162 /* SDL_x11modes.c */; };
 		A75FCE2323E25AB700529352 /* SDL_cocoametalview.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A69923E2513E00DCD162 /* SDL_cocoametalview.m */; };
 		A75FCE2423E25AB700529352 /* SDL_audiotypecvt.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8A023E2513F00DCD162 /* SDL_audiotypecvt.c */; };
 		A75FCE2523E25AB700529352 /* SDL_uikitevents.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A61C23E2513D00DCD162 /* SDL_uikitevents.m */; };
@@ -410,15 +402,10 @@
 		A75FCE3D23E25AB700529352 /* SDL_hints.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A5AB23E2513D00DCD162 /* SDL_hints.c */; };
 		A75FCE3E23E25AB700529352 /* SDL_hidapi_ps4.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A7C323E2513E00DCD162 /* SDL_hidapi_ps4.c */; };
 		A75FCE3F23E25AB700529352 /* SDL_pixels.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A64D23E2513D00DCD162 /* SDL_pixels.c */; };
-		A75FCE4023E25AB700529352 /* SDL_x11clipboard.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70B23E2513E00DCD162 /* SDL_x11clipboard.c */; };
 		A75FCE4123E25AB700529352 /* SDL_sysloadso.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A86323E2513F00DCD162 /* SDL_sysloadso.c */; };
-		A75FCE4223E25AB700529352 /* SDL_x11xinput2.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70223E2513E00DCD162 /* SDL_x11xinput2.c */; };
 		A75FCE4323E25AB700529352 /* SDL_syspower.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A7EB23E2513F00DCD162 /* SDL_syspower.c */; };
-		A75FCE4423E25AB700529352 /* SDL_x11touch.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71123E2513E00DCD162 /* SDL_x11touch.c */; };
 		A75FCE4523E25AB700529352 /* SDL_iconv.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8D323E2514000DCD162 /* SDL_iconv.c */; };
 		A75FCE4623E25AB700529352 /* s_fabs.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A91523E2514000DCD162 /* s_fabs.c */; };
-		A75FCE4723E25AB700529352 /* SDL_x11shape.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71623E2513E00DCD162 /* SDL_x11shape.c */; };
-		A75FCE4823E25AB700529352 /* imKStoUCS.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70923E2513E00DCD162 /* imKStoUCS.c */; };
 		A75FCE4923E25AB700529352 /* SDL_shaders_metal.metal in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8E023E2514000DCD162 /* SDL_shaders_metal.metal */; };
 		A75FCE4A23E25AB700529352 /* SDL_uikitwindow.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A61A23E2513D00DCD162 /* SDL_uikitwindow.m */; };
 		A75FCE4B23E25AB700529352 /* SDL_render.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8DB23E2514000DCD162 /* SDL_render.c */; };
@@ -433,7 +420,6 @@
 		A75FCE5423E25AB700529352 /* SDL_events.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A93523E2514000DCD162 /* SDL_events.c */; };
 		A75FCE5523E25AB700529352 /* SDL_blit_0.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A66223E2513E00DCD162 /* SDL_blit_0.c */; };
 		A75FCE5623E25AB700529352 /* k_tan.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A92723E2514000DCD162 /* k_tan.c */; };
-		A75FCE5723E25AB700529352 /* SDL_x11vulkan.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70023E2513E00DCD162 /* SDL_x11vulkan.c */; };
 		A75FCE5823E25AB700529352 /* SDL_diskaudio.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8B123E2513F00DCD162 /* SDL_diskaudio.c */; };
 		A75FCE5923E25AB700529352 /* SDL_egl.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A6B623E2513E00DCD162 /* SDL_egl.c */; };
 		A75FCE5A23E25AB700529352 /* SDL_RLEaccel.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A61523E2513D00DCD162 /* SDL_RLEaccel.c */; };
@@ -447,7 +433,6 @@
 		A75FCE6323E25AB700529352 /* SDL_string.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8D523E2514000DCD162 /* SDL_string.c */; };
 		A75FCE6423E25AB700529352 /* SDL_render_gl.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A90F23E2514000DCD162 /* SDL_render_gl.c */; };
 		A75FCE6523E25AB700529352 /* SDL_uikitopengles.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A62323E2513D00DCD162 /* SDL_uikitopengles.m */; };
-		A75FCE6623E25AB700529352 /* SDL_x11opengles.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71B23E2513E00DCD162 /* SDL_x11opengles.c */; };
 		A75FCE6723E25AB700529352 /* SDL_cocoamodes.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A68123E2513E00DCD162 /* SDL_cocoamodes.m */; };
 		A75FCE6823E25AB700529352 /* k_rem_pio2.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A91623E2514000DCD162 /* k_rem_pio2.c */; };
 		A75FCE6A23E25AB700529352 /* SDL_gesture.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A94023E2514000DCD162 /* SDL_gesture.c */; };
@@ -458,7 +443,6 @@
 		A75FCE6F23E25AB700529352 /* SDL_surface.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A61423E2513D00DCD162 /* SDL_surface.c */; };
 		A75FCE7023E25AB700529352 /* SDL_hidapi_xboxone.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A7C523E2513E00DCD162 /* SDL_hidapi_xboxone.c */; };
 		A75FCE7123E25AB700529352 /* SDL_blit_auto.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A63F23E2513D00DCD162 /* SDL_blit_auto.c */; };
-		A75FCE7223E25AB700529352 /* SDL_x11keyboard.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70C23E2513E00DCD162 /* SDL_x11keyboard.c */; };
 		A75FCE7323E25AB700529352 /* SDL_keyboard.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A93823E2514000DCD162 /* SDL_keyboard.c */; };
 		A75FCE7523E25AB700529352 /* SDL_rect.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A63423E2513D00DCD162 /* SDL_rect.c */; };
 		A75FCE7623E25AB700529352 /* SDL_cocoaopengles.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A68223E2513E00DCD162 /* SDL_cocoaopengles.m */; };
@@ -466,7 +450,6 @@
 		A75FCE7823E25AB700529352 /* SDL_hidapi_switch.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A7C623E2513E00DCD162 /* SDL_hidapi_switch.c */; };
 		A75FCE7923E25AB700529352 /* SDL_strtokr.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8D623E2514000DCD162 /* SDL_strtokr.c */; };
 		A75FCE7A23E25AB700529352 /* SDL_clipboardevents.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A93A23E2514000DCD162 /* SDL_clipboardevents.c */; };
-		A75FCE7B23E25AB700529352 /* SDL_x11framebuffer.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70623E2513E00DCD162 /* SDL_x11framebuffer.c */; };
 		A75FCE7C23E25AB700529352 /* k_cos.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A91923E2514000DCD162 /* k_cos.c */; };
 		A75FCE7D23E25AB700529352 /* SDL_hidapijoystick.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A7C423E2513E00DCD162 /* SDL_hidapijoystick.c */; };
 		A75FCE7E23E25AB700529352 /* SDL_malloc.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8D923E2514000DCD162 /* SDL_malloc.c */; };
@@ -487,22 +470,18 @@
 		A75FCE8D23E25AB700529352 /* SDL_steamcontroller.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A7A723E2513E00DCD162 /* SDL_steamcontroller.c */; };
 		A75FCE8E23E25AB700529352 /* SDL_shaders_gles2.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A90723E2514000DCD162 /* SDL_shaders_gles2.c */; };
 		A75FCE8F23E25AB700529352 /* SDL_blit_1.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A6FA23E2513E00DCD162 /* SDL_blit_1.c */; };
-		A75FCE9023E25AB700529352 /* SDL_x11dyn.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70523E2513E00DCD162 /* SDL_x11dyn.c */; };
 		A75FCE9123E25AB700529352 /* SDL_mouse.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A92A23E2514000DCD162 /* SDL_mouse.c */; };
 		A75FCE9223E25AB700529352 /* e_rem_pio2.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A91F23E2514000DCD162 /* e_rem_pio2.c */; };
 		A75FCE9323E25AB700529352 /* SDL_dataqueue.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A92823E2514000DCD162 /* SDL_dataqueue.c */; };
 		A75FCE9423E25AB700529352 /* SDL_sysjoystick.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A7A023E2513E00DCD162 /* SDL_sysjoystick.c */; };
 		A75FCE9523E25AB700529352 /* SDL_cpuinfo.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A77523E2513E00DCD162 /* SDL_cpuinfo.c */; };
 		A75FCE9623E25AB700529352 /* SDL_sensor.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A58223E2513D00DCD162 /* SDL_sensor.c */; };
-		A75FCE9723E25AB700529352 /* SDL_x11window.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70723E2513E00DCD162 /* SDL_x11window.c */; };
 		A75FCE9823E25AB700529352 /* k_sin.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A91723E2514000DCD162 /* k_sin.c */; };
-		A75FCE9923E25AB700529352 /* edid-parse.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71223E2513E00DCD162 /* edid-parse.c */; };
 		A75FCE9A23E25AB700529352 /* SDL_systimer.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A5E823E2513D00DCD162 /* SDL_systimer.c */; };
 		A75FCE9B23E25AB700529352 /* SDL_drawpoint.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8FC23E2514000DCD162 /* SDL_drawpoint.c */; };
 		A75FCE9C23E25AB700529352 /* e_sqrt.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A92423E2514000DCD162 /* e_sqrt.c */; };
 		A75FCE9D23E25AB700529352 /* SDL_cocoavideo.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A68523E2513E00DCD162 /* SDL_cocoavideo.m */; };
 		A75FCE9F23E25AB700529352 /* SDL.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A57123E2513D00DCD162 /* SDL.c */; };
-		A75FCEA023E25AB700529352 /* SDL_x11opengl.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A6FF23E2513E00DCD162 /* SDL_x11opengl.c */; };
 		A75FCEA123E25AB700529352 /* SDL_cocoavulkan.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A68323E2513E00DCD162 /* SDL_cocoavulkan.m */; };
 		A75FCEA223E25AB700529352 /* SDL_uikitappdelegate.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A61E23E2513D00DCD162 /* SDL_uikitappdelegate.m */; };
 		A75FCEA323E25AB700529352 /* SDL_offscreenwindow.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A5EF23E2513D00DCD162 /* SDL_offscreenwindow.c */; };
@@ -525,7 +504,6 @@
 		A75FCEC023E25AC700529352 /* SDL_glfuncs.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A90E23E2514000DCD162 /* SDL_glfuncs.h */; };
 		A75FCEC123E25AC700529352 /* SDL_atomic.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557CA1595D4D800BBD41B /* SDL_atomic.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCEC223E25AC700529352 /* SDL_rect_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A60C23E2513D00DCD162 /* SDL_rect_c.h */; };
-		A75FCEC323E25AC700529352 /* SDL_x11xinput2.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71323E2513E00DCD162 /* SDL_x11xinput2.h */; };
 		A75FCEC423E25AC700529352 /* SDL_shaders_metal_osx.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8E223E2514000DCD162 /* SDL_shaders_metal_osx.h */; };
 		A75FCEC523E25AC700529352 /* SDL_shaders_metal_ios.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8DF23E2514000DCD162 /* SDL_shaders_metal_ios.h */; };
 		A75FCEC623E25AC700529352 /* SDL_offscreenwindow.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A5F523E2513D00DCD162 /* SDL_offscreenwindow.h */; };
@@ -541,19 +519,15 @@
 		A75FCED023E25AC700529352 /* SDL_clipboard.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557CD1595D4D800BBD41B /* SDL_clipboard.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCED123E25AC700529352 /* SDL_dataqueue.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A57023E2513D00DCD162 /* SDL_dataqueue.h */; };
 		A75FCED223E25AC700529352 /* SDL_error_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A57523E2513D00DCD162 /* SDL_error_c.h */; };
-		A75FCED323E25AC700529352 /* SDL_x11events.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71E23E2513E00DCD162 /* SDL_x11events.h */; };
 		A75FCED423E25AC700529352 /* SDL_config.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557CF1595D4D800BBD41B /* SDL_config.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCED523E25AC700529352 /* SDL_d3dmath.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8DC23E2514000DCD162 /* SDL_d3dmath.h */; };
-		A75FCED623E25AC700529352 /* SDL_x11window.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71723E2513E00DCD162 /* SDL_x11window.h */; };
 		A75FCED823E25AC700529352 /* SDL_egl_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A60423E2513D00DCD162 /* SDL_egl_c.h */; };
 		A75FCED923E25AC700529352 /* SDL_copying.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557D01595D4D800BBD41B /* SDL_copying.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCEDA23E25AC700529352 /* yuv_rgb.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A77223E2513E00DCD162 /* yuv_rgb.h */; };
 		A75FCEDB23E25AC700529352 /* SDL_dummyaudio.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A87123E2513F00DCD162 /* SDL_dummyaudio.h */; };
 		A75FCEDC23E25AC700529352 /* SDL_uikitmessagebox.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A62623E2513D00DCD162 /* SDL_uikitmessagebox.h */; };
-		A75FCEDD23E25AC700529352 /* SDL_x11messagebox.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A6FD23E2513E00DCD162 /* SDL_x11messagebox.h */; };
 		A75FCEDE23E25AC700529352 /* SDL_thread_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A77823E2513E00DCD162 /* SDL_thread_c.h */; };
 		A75FCEDF23E25AC700529352 /* SDL_cocoamessagebox.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A69423E2513E00DCD162 /* SDL_cocoamessagebox.h */; };
-		A75FCEE023E25AC700529352 /* SDL_x11shape.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70123E2513E00DCD162 /* SDL_x11shape.h */; };
 		A75FCEE123E25AC700529352 /* SDL_cpuinfo.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557D11595D4D800BBD41B /* SDL_cpuinfo.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCEE223E25AC700529352 /* SDL_endian.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557D21595D4D800BBD41B /* SDL_endian.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCEE323E25AC700529352 /* SDL_error.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557D31595D4D800BBD41B /* SDL_error.h */; settings = {ATTRIBUTES = (Public, ); }; };
@@ -562,7 +536,6 @@
 		A75FCEE623E25AC700529352 /* SDL_gamecontroller.h in Headers */ = {isa = PBXBuildFile; fileRef = A77E6EB3167AB0A90010E40B /* SDL_gamecontroller.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCEE723E25AC700529352 /* SDL_hidapijoystick_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A7C723E2513E00DCD162 /* SDL_hidapijoystick_c.h */; };
 		A75FCEE923E25AC700529352 /* SDL_pixels_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A74023E2513E00DCD162 /* SDL_pixels_c.h */; };
-		A75FCEEA23E25AC700529352 /* SDL_x11modes.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70F23E2513E00DCD162 /* SDL_x11modes.h */; };
 		A75FCEEB23E25AC700529352 /* SDL_joystick_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A7D023E2513E00DCD162 /* SDL_joystick_c.h */; };
 		A75FCEEC23E25AC700529352 /* vk_sdk_platform.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73D23E2513E00DCD162 /* vk_sdk_platform.h */; };
 		A75FCEED23E25AC700529352 /* blank_cursor.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A93223E2514000DCD162 /* blank_cursor.h */; };
@@ -576,7 +549,6 @@
 		A75FCEF523E25AC700529352 /* SDL_hints.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557D71595D4D800BBD41B /* SDL_hints.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCEF623E25AC700529352 /* SDL_blit_slow.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A66323E2513E00DCD162 /* SDL_blit_slow.h */; };
 		A75FCEF723E25AC700529352 /* SDL_yuv_sw_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8EC23E2514000DCD162 /* SDL_yuv_sw_c.h */; };
-		A75FCEF823E25AC700529352 /* SDL_x11opengl.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70E23E2513E00DCD162 /* SDL_x11opengl.h */; };
 		A75FCEF923E25AC700529352 /* SDL_windowevents_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A94323E2514000DCD162 /* SDL_windowevents_c.h */; };
 		A75FCEFA23E25AC700529352 /* SDL_joystick.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557D91595D4D800BBD41B /* SDL_joystick.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCEFB23E25AC700529352 /* SDL_cocoavideo.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A69323E2513E00DCD162 /* SDL_cocoavideo.h */; };
@@ -586,16 +558,12 @@
 		A75FCEFF23E25AC700529352 /* SDL_shaders_gl.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A90D23E2514000DCD162 /* SDL_shaders_gl.h */; };
 		A75FCF0023E25AC700529352 /* SDL_systhread_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A78423E2513E00DCD162 /* SDL_systhread_c.h */; };
 		A75FCF0123E25AC700529352 /* SDL_keycode.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557DB1595D4D800BBD41B /* SDL_keycode.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		A75FCF0223E25AC700529352 /* SDL_x11keyboard.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71C23E2513E00DCD162 /* SDL_x11keyboard.h */; };
 		A75FCF0323E25AC700529352 /* SDL_cocoakeyboard.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A68023E2513E00DCD162 /* SDL_cocoakeyboard.h */; };
 		A75FCF0423E25AC700529352 /* SDL_uikitvulkan.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A63323E2513D00DCD162 /* SDL_uikitvulkan.h */; };
-		A75FCF0523E25AC700529352 /* SDL_x11framebuffer.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71823E2513E00DCD162 /* SDL_x11framebuffer.h */; };
-		A75FCF0623E25AC700529352 /* SDL_x11video.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72023E2513E00DCD162 /* SDL_x11video.h */; };
 		A75FCF0723E25AC700529352 /* vulkan.hpp in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73223E2513E00DCD162 /* vulkan.hpp */; };
 		A75FCF0823E25AC700529352 /* SDL_loadso.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557DC1595D4D800BBD41B /* SDL_loadso.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCF0923E25AC700529352 /* gl2ext.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72323E2513E00DCD162 /* gl2ext.h */; };
 		A75FCF0A23E25AC700529352 /* SDL_clipboardevents_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A93923E2514000DCD162 /* SDL_clipboardevents_c.h */; };
-		A75FCF0B23E25AC700529352 /* SDL_x11touch.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A6FC23E2513E00DCD162 /* SDL_x11touch.h */; };
 		A75FCF0C23E25AC700529352 /* SDL_syshaptic_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A5CF23E2513D00DCD162 /* SDL_syshaptic_c.h */; };
 		A75FCF0D23E25AC700529352 /* SDL_hints_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8D123E2514000DCD162 /* SDL_hints_c.h */; };
 		A75FCF0E23E25AC700529352 /* SDL_audiodev_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A87723E2513F00DCD162 /* SDL_audiodev_c.h */; };
@@ -619,9 +587,7 @@
 		A75FCF2023E25AC700529352 /* SDL_wave.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8A223E2513F00DCD162 /* SDL_wave.h */; };
 		A75FCF2123E25AC700529352 /* SDL_cocoaopengl.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A68D23E2513E00DCD162 /* SDL_cocoaopengl.h */; };
 		A75FCF2223E25AC700529352 /* yuv_rgb_sse_func.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A77023E2513E00DCD162 /* yuv_rgb_sse_func.h */; };
-		A75FCF2323E25AC700529352 /* imKStoUCS.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71F23E2513E00DCD162 /* imKStoUCS.h */; };
 		A75FCF2423E25AC700529352 /* SDL_offscreenevents_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A5EE23E2513D00DCD162 /* SDL_offscreenevents_c.h */; };
-		A75FCF2523E25AC700529352 /* SDL_x11sym.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70D23E2513E00DCD162 /* SDL_x11sym.h */; };
 		A75FCF2623E25AC700529352 /* SDL_coreaudio.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8BA23E2513F00DCD162 /* SDL_coreaudio.h */; };
 		A75FCF2723E25AC700529352 /* SDL_draw.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8FA23E2514000DCD162 /* SDL_draw.h */; };
 		A75FCF2823E25AC700529352 /* SDL_drawline.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8F723E2514000DCD162 /* SDL_drawline.h */; };
@@ -631,7 +597,6 @@
 		A75FCF2C23E25AC700529352 /* SDL_yuv_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A76A23E2513E00DCD162 /* SDL_yuv_c.h */; };
 		A75FCF2D23E25AC700529352 /* scancodes_xfree86.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A94123E2514000DCD162 /* scancodes_xfree86.h */; };
 		A75FCF2E23E25AC700529352 /* SDL_syspower.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A7E223E2513F00DCD162 /* SDL_syspower.h */; };
-		A75FCF2F23E25AC700529352 /* SDL_x11clipboard.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71D23E2513E00DCD162 /* SDL_x11clipboard.h */; };
 		A75FCF3023E25AC700529352 /* SDL_name.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557E11595D4D800BBD41B /* SDL_name.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCF3123E25AC700529352 /* eglext.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72A23E2513E00DCD162 /* eglext.h */; };
 		A75FCF3223E25AC700529352 /* SDL_events_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A94223E2514000DCD162 /* SDL_events_c.h */; };
@@ -649,14 +614,12 @@
 		A75FCF3F23E25AC700529352 /* SDL_sysjoystick.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A7CF23E2513E00DCD162 /* SDL_sysjoystick.h */; };
 		A75FCF4023E25AC700529352 /* SDL_steamcontroller.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A7A523E2513E00DCD162 /* SDL_steamcontroller.h */; };
 		A75FCF4123E25AC700529352 /* scancodes_linux.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A93623E2514000DCD162 /* scancodes_linux.h */; };
-		A75FCF4223E25AC700529352 /* SDL_x11dyn.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71923E2513E00DCD162 /* SDL_x11dyn.h */; };
 		A75FCF4323E25AC700529352 /* SDL_touch_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A93723E2514000DCD162 /* SDL_touch_c.h */; };
 		A75FCF4423E25AC700529352 /* SDL_gamecontrollerdb.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A79E23E2513E00DCD162 /* SDL_gamecontrollerdb.h */; };
 		A75FCF4523E25AC700529352 /* SDL_cocoavulkan.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A68F23E2513E00DCD162 /* SDL_cocoavulkan.h */; };
 		A75FCF4623E25AC700529352 /* gl2platform.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72523E2513E00DCD162 /* gl2platform.h */; };
 		A75FCF4723E25AC700529352 /* SDL_pixels.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557E51595D4D800BBD41B /* SDL_pixels.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCF4823E25AC700529352 /* vk_layer.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72D23E2513E00DCD162 /* vk_layer.h */; };
-		A75FCF4923E25AC700529352 /* SDL_cocoamousetap.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A68823E2513E00DCD162 /* SDL_cocoamousetap.h */; };
 		A75FCF4A23E25AC700529352 /* vk_platform.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73123E2513E00DCD162 /* vk_platform.h */; };
 		A75FCF4B23E25AC700529352 /* SDL_cocoametalview.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A68623E2513E00DCD162 /* SDL_cocoametalview.h */; };
 		A75FCF4C23E25AC700529352 /* SDL_cocoaopengles.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A69023E2513E00DCD162 /* SDL_cocoaopengles.h */; };
@@ -670,7 +633,6 @@
 		A75FCF5423E25AC700529352 /* SDL_offscreenopengl.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A5F323E2513D00DCD162 /* SDL_offscreenopengl.h */; };
 		A75FCF5623E25AC700529352 /* scancodes_darwin.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A93423E2514000DCD162 /* scancodes_darwin.h */; };
 		A75FCF5723E25AC700529352 /* controller_type.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A7D923E2513E00DCD162 /* controller_type.h */; };
-		A75FCF5823E25AC700529352 /* SDL_x11opengles.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70323E2513E00DCD162 /* SDL_x11opengles.h */; };
 		A75FCF5923E25AC700529352 /* SDL_uikitclipboard.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A62123E2513D00DCD162 /* SDL_uikitclipboard.h */; };
 		A75FCF5A23E25AC700529352 /* vulkan_xlib.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73A23E2513E00DCD162 /* vulkan_xlib.h */; };
 		A75FCF5B23E25AC700529352 /* SDL_uikitwindow.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A62723E2513D00DCD162 /* SDL_uikitwindow.h */; };
@@ -685,7 +647,6 @@
 		A75FCF6423E25AC700529352 /* SDL_blit_copy.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A76623E2513E00DCD162 /* SDL_blit_copy.h */; };
 		A75FCF6523E25AC700529352 /* SDL_RLEaccel_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A76723E2513E00DCD162 /* SDL_RLEaccel_c.h */; };
 		A75FCF6623E25AC700529352 /* eglplatform.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72B23E2513E00DCD162 /* eglplatform.h */; };
-		A75FCF6723E25AC700529352 /* edid.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71423E2513E00DCD162 /* edid.h */; };
 		A75FCF6823E25AC700529352 /* SDL_revision.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557EB1595D4D800BBD41B /* SDL_revision.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCF6923E25AC700529352 /* SDL_systhread.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A77723E2513E00DCD162 /* SDL_systhread.h */; };
 		A75FCF6A23E25AC700529352 /* SDL_rwops.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557EC1595D4D800BBD41B /* SDL_rwops.h */; settings = {ATTRIBUTES = (Public, ); }; };
@@ -737,10 +698,8 @@
 		A75FCF9A23E25AC700529352 /* SDL_sysvideo.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A61723E2513D00DCD162 /* SDL_sysvideo.h */; };
 		A75FCF9B23E25AC700529352 /* SDL_opengles2_gl2platform.h in Headers */ = {isa = PBXBuildFile; fileRef = AAC070F7195606770073DCDF /* SDL_opengles2_gl2platform.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCF9C23E25AC700529352 /* SDL_opengles2_gl2ext.h in Headers */ = {isa = PBXBuildFile; fileRef = AAC070F6195606770073DCDF /* SDL_opengles2_gl2ext.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		A75FCF9D23E25AC700529352 /* SDL_x11mouse.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71A23E2513E00DCD162 /* SDL_x11mouse.h */; };
 		A75FCF9E23E25AC700529352 /* SDL_dynapi_overrides.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A5D923E2513D00DCD162 /* SDL_dynapi_overrides.h */; };
 		A75FCF9F23E25AC700529352 /* SDL_cocoawindow.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A69223E2513E00DCD162 /* SDL_cocoawindow.h */; };
-		A75FCFA023E25AC700529352 /* SDL_x11vulkan.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71523E2513E00DCD162 /* SDL_x11vulkan.h */; };
 		A75FCFA223E25AC700529352 /* SDL_drawline.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8F123E2514000DCD162 /* SDL_drawline.c */; };
 		A75FCFA323E25AC700529352 /* SDL_yuv.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A67C23E2513E00DCD162 /* SDL_yuv.c */; };
 		A75FCFA423E25AC700529352 /* SDL_sysfilesystem.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A7FE23E2513F00DCD162 /* SDL_sysfilesystem.m */; };
@@ -753,19 +712,16 @@
 		A75FCFAB23E25AC700529352 /* SDL_render_metal.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8DE23E2514000DCD162 /* SDL_render_metal.m */; };
 		A75FCFAC23E25AC700529352 /* SDL_clipboard.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A67B23E2513E00DCD162 /* SDL_clipboard.c */; };
 		A75FCFAD23E25AC700529352 /* SDL_cocoaevents.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A68923E2513E00DCD162 /* SDL_cocoaevents.m */; };
-		A75FCFAE23E25AC700529352 /* SDL_x11messagebox.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71023E2513E00DCD162 /* SDL_x11messagebox.c */; };
 		A75FCFAF23E25AC700529352 /* SDL_audiocvt.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8A123E2513F00DCD162 /* SDL_audiocvt.c */; };
 		A75FCFB023E25AC700529352 /* SDL_shape.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A76923E2513E00DCD162 /* SDL_shape.c */; };
 		A75FCFB123E25AC700529352 /* SDL_rotate.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8F423E2514000DCD162 /* SDL_rotate.c */; };
 		A75FCFB223E25AC700529352 /* SDL_coremotionsensor.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A57C23E2513D00DCD162 /* SDL_coremotionsensor.m */; };
 		A75FCFB323E25AC700529352 /* SDL_touch.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A93E23E2514000DCD162 /* SDL_touch.c */; };
-		A75FCFB423E25AC700529352 /* SDL_x11events.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70A23E2513E00DCD162 /* SDL_x11events.c */; };
 		A75FCFB523E25AC700529352 /* SDL_uikitmessagebox.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A61B23E2513D00DCD162 /* SDL_uikitmessagebox.m */; };
 		A75FCFB623E25AC700529352 /* SDL_thread.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A77923E2513E00DCD162 /* SDL_thread.c */; };
 		A75FCFB723E25AC700529352 /* SDL_hidapi_xbox360w.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A7C823E2513E00DCD162 /* SDL_hidapi_xbox360w.c */; };
 		A75FCFB823E25AC700529352 /* SDL_atomic.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A57423E2513D00DCD162 /* SDL_atomic.c */; };
 		A75FCFB923E25AC700529352 /* SDL_displayevents.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A92D23E2514000DCD162 /* SDL_displayevents.c */; };
-		A75FCFBA23E25AC700529352 /* SDL_cocoamousetap.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A69723E2513E00DCD162 /* SDL_cocoamousetap.m */; };
 		A75FCFBB23E25AC700529352 /* SDL_log.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A5DD23E2513D00DCD162 /* SDL_log.c */; };
 		A75FCFBC23E25AC700529352 /* SDL_cocoaopengl.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A67F23E2513E00DCD162 /* SDL_cocoaopengl.m */; };
 		A75FCFBD23E25AC700529352 /* SDL_offscreenframebuffer.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A5F223E2513D00DCD162 /* SDL_offscreenframebuffer.c */; };
@@ -780,14 +736,12 @@
 		A75FCFC623E25AC700529352 /* SDL_systimer.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A5E223E2513D00DCD162 /* SDL_systimer.c */; };
 		A75FCFC723E25AC700529352 /* SDL_uikitclipboard.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A62A23E2513D00DCD162 /* SDL_uikitclipboard.m */; };
 		A75FCFC823E25AC700529352 /* SDL_render_sw.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8F923E2514000DCD162 /* SDL_render_sw.c */; };
-		A75FCFC923E25AC700529352 /* SDL_x11video.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70823E2513E00DCD162 /* SDL_x11video.c */; };
 		A75FCFCA23E25AC700529352 /* SDL_syssem.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A78323E2513E00DCD162 /* SDL_syssem.c */; };
 		A75FCFCB23E25AC700529352 /* SDL_hidapi_xbox360.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A7C223E2513E00DCD162 /* SDL_hidapi_xbox360.c */; };
 		A75FCFCC23E25AC700529352 /* SDL_coreaudio.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8BB23E2513F00DCD162 /* SDL_coreaudio.m */; };
 		A75FCFCD23E25AC700529352 /* SDL_blendline.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8FB23E2514000DCD162 /* SDL_blendline.c */; };
 		A75FCFCE23E25AC700529352 /* SDL_blit_A.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A66423E2513E00DCD162 /* SDL_blit_A.c */; };
 		A75FCFCF23E25AC700529352 /* SDL_d3dmath.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8FF23E2514000DCD162 /* SDL_d3dmath.c */; };
-		A75FCFD023E25AC700529352 /* SDL_x11mouse.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70423E2513E00DCD162 /* SDL_x11mouse.c */; };
 		A75FCFD123E25AC700529352 /* SDL_nullvideo.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A60823E2513D00DCD162 /* SDL_nullvideo.c */; };
 		A75FCFD223E25AC700529352 /* SDL_offscreenevents.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A5F023E2513D00DCD162 /* SDL_offscreenevents.c */; };
 		A75FCFD323E25AC700529352 /* SDL_uikitview.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A62923E2513D00DCD162 /* SDL_uikitview.m */; };
@@ -798,7 +752,6 @@
 		A75FCFD823E25AC700529352 /* s_copysign.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A91423E2514000DCD162 /* s_copysign.c */; };
 		A75FCFD923E25AC700529352 /* SDL_haptic.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A5C523E2513D00DCD162 /* SDL_haptic.c */; };
 		A75FCFDA23E25AC700529352 /* SDL_uikitvulkan.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A62523E2513D00DCD162 /* SDL_uikitvulkan.m */; };
-		A75FCFDB23E25AC700529352 /* SDL_x11modes.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A6FE23E2513E00DCD162 /* SDL_x11modes.c */; };
 		A75FCFDC23E25AC700529352 /* SDL_cocoametalview.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A69923E2513E00DCD162 /* SDL_cocoametalview.m */; };
 		A75FCFDD23E25AC700529352 /* SDL_audiotypecvt.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8A023E2513F00DCD162 /* SDL_audiotypecvt.c */; };
 		A75FCFDE23E25AC700529352 /* SDL_uikitevents.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A61C23E2513D00DCD162 /* SDL_uikitevents.m */; };
@@ -828,15 +781,10 @@
 		A75FCFF623E25AC700529352 /* SDL_hints.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A5AB23E2513D00DCD162 /* SDL_hints.c */; };
 		A75FCFF723E25AC700529352 /* SDL_hidapi_ps4.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A7C323E2513E00DCD162 /* SDL_hidapi_ps4.c */; };
 		A75FCFF823E25AC700529352 /* SDL_pixels.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A64D23E2513D00DCD162 /* SDL_pixels.c */; };
-		A75FCFF923E25AC700529352 /* SDL_x11clipboard.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70B23E2513E00DCD162 /* SDL_x11clipboard.c */; };
 		A75FCFFA23E25AC700529352 /* SDL_sysloadso.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A86323E2513F00DCD162 /* SDL_sysloadso.c */; };
-		A75FCFFB23E25AC700529352 /* SDL_x11xinput2.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70223E2513E00DCD162 /* SDL_x11xinput2.c */; };
 		A75FCFFC23E25AC700529352 /* SDL_syspower.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A7EB23E2513F00DCD162 /* SDL_syspower.c */; };
-		A75FCFFD23E25AC700529352 /* SDL_x11touch.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71123E2513E00DCD162 /* SDL_x11touch.c */; };
 		A75FCFFE23E25AC700529352 /* SDL_iconv.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8D323E2514000DCD162 /* SDL_iconv.c */; };
 		A75FCFFF23E25AC700529352 /* s_fabs.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A91523E2514000DCD162 /* s_fabs.c */; };
-		A75FD00023E25AC700529352 /* SDL_x11shape.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71623E2513E00DCD162 /* SDL_x11shape.c */; };
-		A75FD00123E25AC700529352 /* imKStoUCS.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70923E2513E00DCD162 /* imKStoUCS.c */; };
 		A75FD00223E25AC700529352 /* SDL_shaders_metal.metal in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8E023E2514000DCD162 /* SDL_shaders_metal.metal */; };
 		A75FD00323E25AC700529352 /* SDL_uikitwindow.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A61A23E2513D00DCD162 /* SDL_uikitwindow.m */; };
 		A75FD00423E25AC700529352 /* SDL_render.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8DB23E2514000DCD162 /* SDL_render.c */; };
@@ -851,7 +799,6 @@
 		A75FD00D23E25AC700529352 /* SDL_events.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A93523E2514000DCD162 /* SDL_events.c */; };
 		A75FD00E23E25AC700529352 /* SDL_blit_0.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A66223E2513E00DCD162 /* SDL_blit_0.c */; };
 		A75FD00F23E25AC700529352 /* k_tan.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A92723E2514000DCD162 /* k_tan.c */; };
-		A75FD01023E25AC700529352 /* SDL_x11vulkan.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70023E2513E00DCD162 /* SDL_x11vulkan.c */; };
 		A75FD01123E25AC700529352 /* SDL_diskaudio.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8B123E2513F00DCD162 /* SDL_diskaudio.c */; };
 		A75FD01223E25AC700529352 /* SDL_egl.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A6B623E2513E00DCD162 /* SDL_egl.c */; };
 		A75FD01323E25AC700529352 /* SDL_RLEaccel.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A61523E2513D00DCD162 /* SDL_RLEaccel.c */; };
@@ -865,7 +812,6 @@
 		A75FD01C23E25AC700529352 /* SDL_string.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8D523E2514000DCD162 /* SDL_string.c */; };
 		A75FD01D23E25AC700529352 /* SDL_render_gl.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A90F23E2514000DCD162 /* SDL_render_gl.c */; };
 		A75FD01E23E25AC700529352 /* SDL_uikitopengles.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A62323E2513D00DCD162 /* SDL_uikitopengles.m */; };
-		A75FD01F23E25AC700529352 /* SDL_x11opengles.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71B23E2513E00DCD162 /* SDL_x11opengles.c */; };
 		A75FD02023E25AC700529352 /* SDL_cocoamodes.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A68123E2513E00DCD162 /* SDL_cocoamodes.m */; };
 		A75FD02123E25AC700529352 /* k_rem_pio2.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A91623E2514000DCD162 /* k_rem_pio2.c */; };
 		A75FD02323E25AC700529352 /* SDL_gesture.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A94023E2514000DCD162 /* SDL_gesture.c */; };
@@ -876,7 +822,6 @@
 		A75FD02823E25AC700529352 /* SDL_surface.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A61423E2513D00DCD162 /* SDL_surface.c */; };
 		A75FD02923E25AC700529352 /* SDL_hidapi_xboxone.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A7C523E2513E00DCD162 /* SDL_hidapi_xboxone.c */; };
 		A75FD02A23E25AC700529352 /* SDL_blit_auto.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A63F23E2513D00DCD162 /* SDL_blit_auto.c */; };
-		A75FD02B23E25AC700529352 /* SDL_x11keyboard.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70C23E2513E00DCD162 /* SDL_x11keyboard.c */; };
 		A75FD02C23E25AC700529352 /* SDL_keyboard.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A93823E2514000DCD162 /* SDL_keyboard.c */; };
 		A75FD02E23E25AC700529352 /* SDL_rect.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A63423E2513D00DCD162 /* SDL_rect.c */; };
 		A75FD02F23E25AC700529352 /* SDL_cocoaopengles.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A68223E2513E00DCD162 /* SDL_cocoaopengles.m */; };
@@ -884,7 +829,6 @@
 		A75FD03123E25AC700529352 /* SDL_hidapi_switch.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A7C623E2513E00DCD162 /* SDL_hidapi_switch.c */; };
 		A75FD03223E25AC700529352 /* SDL_strtokr.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8D623E2514000DCD162 /* SDL_strtokr.c */; };
 		A75FD03323E25AC700529352 /* SDL_clipboardevents.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A93A23E2514000DCD162 /* SDL_clipboardevents.c */; };
-		A75FD03423E25AC700529352 /* SDL_x11framebuffer.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70623E2513E00DCD162 /* SDL_x11framebuffer.c */; };
 		A75FD03523E25AC700529352 /* k_cos.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A91923E2514000DCD162 /* k_cos.c */; };
 		A75FD03623E25AC700529352 /* SDL_hidapijoystick.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A7C423E2513E00DCD162 /* SDL_hidapijoystick.c */; };
 		A75FD03723E25AC700529352 /* SDL_malloc.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8D923E2514000DCD162 /* SDL_malloc.c */; };
@@ -905,22 +849,18 @@
 		A75FD04623E25AC700529352 /* SDL_steamcontroller.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A7A723E2513E00DCD162 /* SDL_steamcontroller.c */; };
 		A75FD04723E25AC700529352 /* SDL_shaders_gles2.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A90723E2514000DCD162 /* SDL_shaders_gles2.c */; };
 		A75FD04823E25AC700529352 /* SDL_blit_1.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A6FA23E2513E00DCD162 /* SDL_blit_1.c */; };
-		A75FD04923E25AC700529352 /* SDL_x11dyn.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70523E2513E00DCD162 /* SDL_x11dyn.c */; };
 		A75FD04A23E25AC700529352 /* SDL_mouse.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A92A23E2514000DCD162 /* SDL_mouse.c */; };
 		A75FD04B23E25AC700529352 /* e_rem_pio2.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A91F23E2514000DCD162 /* e_rem_pio2.c */; };
 		A75FD04C23E25AC700529352 /* SDL_dataqueue.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A92823E2514000DCD162 /* SDL_dataqueue.c */; };
 		A75FD04D23E25AC700529352 /* SDL_sysjoystick.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A7A023E2513E00DCD162 /* SDL_sysjoystick.c */; };
 		A75FD04E23E25AC700529352 /* SDL_cpuinfo.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A77523E2513E00DCD162 /* SDL_cpuinfo.c */; };
 		A75FD04F23E25AC700529352 /* SDL_sensor.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A58223E2513D00DCD162 /* SDL_sensor.c */; };
-		A75FD05023E25AC700529352 /* SDL_x11window.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70723E2513E00DCD162 /* SDL_x11window.c */; };
 		A75FD05123E25AC700529352 /* k_sin.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A91723E2514000DCD162 /* k_sin.c */; };
-		A75FD05223E25AC700529352 /* edid-parse.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71223E2513E00DCD162 /* edid-parse.c */; };
 		A75FD05323E25AC700529352 /* SDL_systimer.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A5E823E2513D00DCD162 /* SDL_systimer.c */; };
 		A75FD05423E25AC700529352 /* SDL_drawpoint.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8FC23E2514000DCD162 /* SDL_drawpoint.c */; };
 		A75FD05523E25AC700529352 /* e_sqrt.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A92423E2514000DCD162 /* e_sqrt.c */; };
 		A75FD05623E25AC700529352 /* SDL_cocoavideo.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A68523E2513E00DCD162 /* SDL_cocoavideo.m */; };
 		A75FD05823E25AC700529352 /* SDL.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A57123E2513D00DCD162 /* SDL.c */; };
-		A75FD05923E25AC700529352 /* SDL_x11opengl.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A6FF23E2513E00DCD162 /* SDL_x11opengl.c */; };
 		A75FD05A23E25AC700529352 /* SDL_cocoavulkan.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A68323E2513E00DCD162 /* SDL_cocoavulkan.m */; };
 		A75FD05B23E25AC700529352 /* SDL_uikitappdelegate.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A61E23E2513D00DCD162 /* SDL_uikitappdelegate.m */; };
 		A75FD05C23E25AC700529352 /* SDL_offscreenwindow.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A5EF23E2513D00DCD162 /* SDL_offscreenwindow.c */; };
@@ -941,8 +881,6 @@
 		A75FDAF923E35ED500529352 /* SDL_config_iphoneos.h in Headers */ = {isa = PBXBuildFile; fileRef = A75FDAF523E35EC400529352 /* SDL_config_iphoneos.h */; };
 		A75FDAFA23E35ED600529352 /* SDL_config_iphoneos.h in Headers */ = {isa = PBXBuildFile; fileRef = A75FDAF523E35EC400529352 /* SDL_config_iphoneos.h */; };
 		A75FDAFB23E35ED700529352 /* SDL_config_iphoneos.h in Headers */ = {isa = PBXBuildFile; fileRef = A75FDAF523E35EC400529352 /* SDL_config_iphoneos.h */; };
-		A75FDB5323E39D1C00529352 /* hid.m in Sources */ = {isa = PBXBuildFile; fileRef = A75FDAA523E2792500529352 /* hid.m */; };
-		A75FDB5523E39DAC00529352 /* CoreBluetooth.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = A75FDAC323E28BA700529352 /* CoreBluetooth.framework */; };
 		A75FDB5823E39E6100529352 /* hidapi.h in Headers */ = {isa = PBXBuildFile; fileRef = A75FDB5723E39E6100529352 /* hidapi.h */; };
 		A75FDB5923E39E6100529352 /* hidapi.h in Headers */ = {isa = PBXBuildFile; fileRef = A75FDB5723E39E6100529352 /* hidapi.h */; };
 		A75FDB5A23E39E6100529352 /* hidapi.h in Headers */ = {isa = PBXBuildFile; fileRef = A75FDB5723E39E6100529352 /* hidapi.h */; };
@@ -952,33 +890,6 @@
 		A75FDB5E23E39E6100529352 /* hidapi.h in Headers */ = {isa = PBXBuildFile; fileRef = A75FDB5723E39E6100529352 /* hidapi.h */; };
 		A75FDB5F23E39E6100529352 /* hidapi.h in Headers */ = {isa = PBXBuildFile; fileRef = A75FDB5723E39E6100529352 /* hidapi.h */; };
 		A75FDB6023E39E6100529352 /* hidapi.h in Headers */ = {isa = PBXBuildFile; fileRef = A75FDB5723E39E6100529352 /* hidapi.h */; };
-		A75FDB6123E39E6100529352 /* hidapi.h in Headers */ = {isa = PBXBuildFile; fileRef = A75FDB5723E39E6100529352 /* hidapi.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		A75FDB6423E3A2C900529352 /* hidapi.h in Headers */ = {isa = PBXBuildFile; fileRef = A75FDB5723E39E6100529352 /* hidapi.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		A75FDB6623E3A2C900529352 /* hid.m in Sources */ = {isa = PBXBuildFile; fileRef = A75FDAA523E2792500529352 /* hid.m */; };
-		A75FDB6823E3A2C900529352 /* CoreBluetooth.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = A75FDAC323E28BA700529352 /* CoreBluetooth.framework */; };
-		A75FDB8223E4C74400529352 /* hidapi.h in Headers */ = {isa = PBXBuildFile; fileRef = A75FDB5723E39E6100529352 /* hidapi.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		A75FDB9323E4C8DB00529352 /* hid.c in Sources */ = {isa = PBXBuildFile; fileRef = A75FDB9223E4C8DB00529352 /* hid.c */; };
-		A75FDB9423E4C91300529352 /* IOKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 0073179F0858DECD00B2BC32 /* IOKit.framework */; };
-		A75FDB9523E4C93600529352 /* CoreFoundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 00D0D08310675DD9004B05EF /* CoreFoundation.framework */; };
-		A75FDB9A23E4CAEF00529352 /* hidapi.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = A75FDB8C23E4C74400529352 /* hidapi.framework */; };
-		A75FDB9B23E4CAEF00529352 /* hidapi.framework in Embed Frameworks */ = {isa = PBXBuildFile; fileRef = A75FDB8C23E4C74400529352 /* hidapi.framework */; settings = {ATTRIBUTES = (RemoveHeadersOnCopy, ); }; };
-		A75FDB9D23E4CAFA00529352 /* hidapi.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = A75FDB4923E399AC00529352 /* hidapi.framework */; settings = {ATTRIBUTES = (Weak, ); }; };
-		A75FDBA023E4CAFF00529352 /* hidapi.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = A75FDB6E23E3A2C900529352 /* hidapi.framework */; settings = {ATTRIBUTES = (Weak, ); }; };
-		A75FDBA823E4CB7000529352 /* LICENSE-bsd.txt in Resources */ = {isa = PBXBuildFile; fileRef = A75FDBA323E4CB6F00529352 /* LICENSE-bsd.txt */; };
-		A75FDBA923E4CB7000529352 /* LICENSE-bsd.txt in Resources */ = {isa = PBXBuildFile; fileRef = A75FDBA323E4CB6F00529352 /* LICENSE-bsd.txt */; };
-		A75FDBAA23E4CB7000529352 /* LICENSE-bsd.txt in Resources */ = {isa = PBXBuildFile; fileRef = A75FDBA323E4CB6F00529352 /* LICENSE-bsd.txt */; };
-		A75FDBAB23E4CB7000529352 /* AUTHORS.txt in Resources */ = {isa = PBXBuildFile; fileRef = A75FDBA423E4CB6F00529352 /* AUTHORS.txt */; };
-		A75FDBAC23E4CB7000529352 /* AUTHORS.txt in Resources */ = {isa = PBXBuildFile; fileRef = A75FDBA423E4CB6F00529352 /* AUTHORS.txt */; };
-		A75FDBAD23E4CB7000529352 /* AUTHORS.txt in Resources */ = {isa = PBXBuildFile; fileRef = A75FDBA423E4CB6F00529352 /* AUTHORS.txt */; };
-		A75FDBAE23E4CB7000529352 /* LICENSE-orig.txt in Resources */ = {isa = PBXBuildFile; fileRef = A75FDBA523E4CB6F00529352 /* LICENSE-orig.txt */; };
-		A75FDBAF23E4CB7000529352 /* LICENSE-orig.txt in Resources */ = {isa = PBXBuildFile; fileRef = A75FDBA523E4CB6F00529352 /* LICENSE-orig.txt */; };
-		A75FDBB023E4CB7000529352 /* LICENSE-orig.txt in Resources */ = {isa = PBXBuildFile; fileRef = A75FDBA523E4CB6F00529352 /* LICENSE-orig.txt */; };
-		A75FDBB123E4CB7000529352 /* LICENSE-gpl3.txt in Resources */ = {isa = PBXBuildFile; fileRef = A75FDBA623E4CB6F00529352 /* LICENSE-gpl3.txt */; };
-		A75FDBB223E4CB7000529352 /* LICENSE-gpl3.txt in Resources */ = {isa = PBXBuildFile; fileRef = A75FDBA623E4CB6F00529352 /* LICENSE-gpl3.txt */; };
-		A75FDBB323E4CB7000529352 /* LICENSE-gpl3.txt in Resources */ = {isa = PBXBuildFile; fileRef = A75FDBA623E4CB6F00529352 /* LICENSE-gpl3.txt */; };
-		A75FDBB423E4CB7000529352 /* LICENSE.txt in Resources */ = {isa = PBXBuildFile; fileRef = A75FDBA723E4CB6F00529352 /* LICENSE.txt */; };
-		A75FDBB523E4CB7000529352 /* LICENSE.txt in Resources */ = {isa = PBXBuildFile; fileRef = A75FDBA723E4CB6F00529352 /* LICENSE.txt */; };
-		A75FDBB623E4CB7000529352 /* LICENSE.txt in Resources */ = {isa = PBXBuildFile; fileRef = A75FDBA723E4CB6F00529352 /* LICENSE.txt */; };
 		A75FDBB723E4CBC700529352 /* License.txt in Resources */ = {isa = PBXBuildFile; fileRef = 00794D3F09D0C461003FC8A1 /* License.txt */; };
 		A75FDBB823E4CBC700529352 /* ReadMe.txt in Resources */ = {isa = PBXBuildFile; fileRef = F59C710300D5CB5801000001 /* ReadMe.txt */; };
 		A75FDBB923E4CBC700529352 /* License.txt in Resources */ = {isa = PBXBuildFile; fileRef = 00794D3F09D0C461003FC8A1 /* License.txt */; };
@@ -1009,7 +920,6 @@
 		A769B08D23E259AE00872273 /* SDL_shape_internals.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A60D23E2513D00DCD162 /* SDL_shape_internals.h */; };
 		A769B08E23E259AE00872273 /* SDL_glfuncs.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A90E23E2514000DCD162 /* SDL_glfuncs.h */; };
 		A769B09023E259AE00872273 /* SDL_rect_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A60C23E2513D00DCD162 /* SDL_rect_c.h */; };
-		A769B09123E259AE00872273 /* SDL_x11xinput2.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71323E2513E00DCD162 /* SDL_x11xinput2.h */; };
 		A769B09223E259AE00872273 /* SDL_shaders_metal_osx.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8E223E2514000DCD162 /* SDL_shaders_metal_osx.h */; };
 		A769B09323E259AE00872273 /* SDL_shaders_metal_ios.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8DF23E2514000DCD162 /* SDL_shaders_metal_ios.h */; };
 		A769B09423E259AE00872273 /* SDL_offscreenwindow.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A5F523E2513D00DCD162 /* SDL_offscreenwindow.h */; };
@@ -1021,21 +931,16 @@
 		A769B09D23E259AE00872273 /* SDL_haptic_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A5C623E2513D00DCD162 /* SDL_haptic_c.h */; };
 		A769B09F23E259AE00872273 /* SDL_dataqueue.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A57023E2513D00DCD162 /* SDL_dataqueue.h */; };
 		A769B0A023E259AE00872273 /* SDL_error_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A57523E2513D00DCD162 /* SDL_error_c.h */; };
-		A769B0A123E259AE00872273 /* SDL_x11events.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71E23E2513E00DCD162 /* SDL_x11events.h */; };
 		A769B0A323E259AE00872273 /* SDL_d3dmath.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8DC23E2514000DCD162 /* SDL_d3dmath.h */; };
-		A769B0A423E259AE00872273 /* SDL_x11window.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71723E2513E00DCD162 /* SDL_x11window.h */; };
 		A769B0A623E259AE00872273 /* SDL_egl_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A60423E2513D00DCD162 /* SDL_egl_c.h */; };
 		A769B0A823E259AE00872273 /* yuv_rgb.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A77223E2513E00DCD162 /* yuv_rgb.h */; };
 		A769B0A923E259AE00872273 /* SDL_dummyaudio.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A87123E2513F00DCD162 /* SDL_dummyaudio.h */; };
 		A769B0AA23E259AE00872273 /* SDL_uikitmessagebox.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A62623E2513D00DCD162 /* SDL_uikitmessagebox.h */; };
-		A769B0AB23E259AE00872273 /* SDL_x11messagebox.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A6FD23E2513E00DCD162 /* SDL_x11messagebox.h */; };
 		A769B0AC23E259AE00872273 /* SDL_thread_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A77823E2513E00DCD162 /* SDL_thread_c.h */; };
 		A769B0AD23E259AE00872273 /* SDL_cocoamessagebox.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A69423E2513E00DCD162 /* SDL_cocoamessagebox.h */; };
-		A769B0AE23E259AE00872273 /* SDL_x11shape.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70123E2513E00DCD162 /* SDL_x11shape.h */; };
 		A769B0B323E259AE00872273 /* SDL_blendfillrect.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8F623E2514000DCD162 /* SDL_blendfillrect.h */; };
 		A769B0B523E259AE00872273 /* SDL_hidapijoystick_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A7C723E2513E00DCD162 /* SDL_hidapijoystick_c.h */; };
 		A769B0B623E259AE00872273 /* SDL_pixels_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A74023E2513E00DCD162 /* SDL_pixels_c.h */; };
-		A769B0B723E259AE00872273 /* SDL_x11modes.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70F23E2513E00DCD162 /* SDL_x11modes.h */; };
 		A769B0B823E259AE00872273 /* SDL_joystick_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A7D023E2513E00DCD162 /* SDL_joystick_c.h */; };
 		A769B0B923E259AE00872273 /* vk_sdk_platform.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73D23E2513E00DCD162 /* vk_sdk_platform.h */; };
 		A769B0BA23E259AE00872273 /* blank_cursor.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A93223E2514000DCD162 /* blank_cursor.h */; };
@@ -1046,22 +951,17 @@
 		A769B0C123E259AE00872273 /* SDL_cocoamouse.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A69823E2513E00DCD162 /* SDL_cocoamouse.h */; };
 		A769B0C323E259AE00872273 /* SDL_blit_slow.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A66323E2513E00DCD162 /* SDL_blit_slow.h */; };
 		A769B0C423E259AE00872273 /* SDL_yuv_sw_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8EC23E2514000DCD162 /* SDL_yuv_sw_c.h */; };
-		A769B0C523E259AE00872273 /* SDL_x11opengl.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70E23E2513E00DCD162 /* SDL_x11opengl.h */; };
 		A769B0C623E259AE00872273 /* SDL_windowevents_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A94323E2514000DCD162 /* SDL_windowevents_c.h */; };
 		A769B0C823E259AE00872273 /* SDL_cocoavideo.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A69323E2513E00DCD162 /* SDL_cocoavideo.h */; };
 		A769B0CA23E259AE00872273 /* SDL_uikitevents.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A62D23E2513D00DCD162 /* SDL_uikitevents.h */; };
 		A769B0CB23E259AE00872273 /* SDL_gesture_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A93023E2514000DCD162 /* SDL_gesture_c.h */; };
 		A769B0CC23E259AE00872273 /* SDL_shaders_gl.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A90D23E2514000DCD162 /* SDL_shaders_gl.h */; };
 		A769B0CD23E259AE00872273 /* SDL_systhread_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A78423E2513E00DCD162 /* SDL_systhread_c.h */; };
-		A769B0CF23E259AE00872273 /* SDL_x11keyboard.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71C23E2513E00DCD162 /* SDL_x11keyboard.h */; };
 		A769B0D023E259AE00872273 /* SDL_cocoakeyboard.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A68023E2513E00DCD162 /* SDL_cocoakeyboard.h */; };
 		A769B0D123E259AE00872273 /* SDL_uikitvulkan.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A63323E2513D00DCD162 /* SDL_uikitvulkan.h */; };
-		A769B0D223E259AE00872273 /* SDL_x11framebuffer.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71823E2513E00DCD162 /* SDL_x11framebuffer.h */; };
-		A769B0D323E259AE00872273 /* SDL_x11video.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72023E2513E00DCD162 /* SDL_x11video.h */; };
 		A769B0D423E259AE00872273 /* vulkan.hpp in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73223E2513E00DCD162 /* vulkan.hpp */; };
 		A769B0D623E259AE00872273 /* gl2ext.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72323E2513E00DCD162 /* gl2ext.h */; };
 		A769B0D723E259AE00872273 /* SDL_clipboardevents_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A93923E2514000DCD162 /* SDL_clipboardevents_c.h */; };
-		A769B0D823E259AE00872273 /* SDL_x11touch.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A6FC23E2513E00DCD162 /* SDL_x11touch.h */; };
 		A769B0D923E259AE00872273 /* SDL_syshaptic_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A5CF23E2513D00DCD162 /* SDL_syshaptic_c.h */; };
 		A769B0DA23E259AE00872273 /* SDL_hints_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8D123E2514000DCD162 /* SDL_hints_c.h */; };
 		A769B0DB23E259AE00872273 /* SDL_audiodev_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A87723E2513F00DCD162 /* SDL_audiodev_c.h */; };
@@ -1083,16 +983,13 @@
 		A769B0EF23E259AE00872273 /* SDL_wave.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8A223E2513F00DCD162 /* SDL_wave.h */; };
 		A769B0F023E259AE00872273 /* SDL_cocoaopengl.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A68D23E2513E00DCD162 /* SDL_cocoaopengl.h */; };
 		A769B0F123E259AE00872273 /* yuv_rgb_sse_func.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A77023E2513E00DCD162 /* yuv_rgb_sse_func.h */; };
-		A769B0F223E259AE00872273 /* imKStoUCS.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71F23E2513E00DCD162 /* imKStoUCS.h */; };
 		A769B0F323E259AE00872273 /* SDL_offscreenevents_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A5EE23E2513D00DCD162 /* SDL_offscreenevents_c.h */; };
-		A769B0F423E259AE00872273 /* SDL_x11sym.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70D23E2513E00DCD162 /* SDL_x11sym.h */; };
 		A769B0F523E259AE00872273 /* SDL_coreaudio.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8BA23E2513F00DCD162 /* SDL_coreaudio.h */; };
 		A769B0F623E259AE00872273 /* SDL_draw.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8FA23E2514000DCD162 /* SDL_draw.h */; };
 		A769B0F723E259AE00872273 /* SDL_drawline.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8F723E2514000DCD162 /* SDL_drawline.h */; };
 		A769B0FB23E259AE00872273 /* SDL_yuv_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A76A23E2513E00DCD162 /* SDL_yuv_c.h */; };
 		A769B0FC23E259AE00872273 /* scancodes_xfree86.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A94123E2514000DCD162 /* scancodes_xfree86.h */; };
 		A769B0FD23E259AE00872273 /* SDL_syspower.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A7E223E2513F00DCD162 /* SDL_syspower.h */; };
-		A769B0FE23E259AE00872273 /* SDL_x11clipboard.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71D23E2513E00DCD162 /* SDL_x11clipboard.h */; };
 		A769B10023E259AE00872273 /* eglext.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72A23E2513E00DCD162 /* eglext.h */; };
 		A769B10123E259AE00872273 /* SDL_events_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A94223E2514000DCD162 /* SDL_events_c.h */; };
 		A769B10223E259AE00872273 /* math_private.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A91B23E2514000DCD162 /* math_private.h */; };
@@ -1105,13 +1002,11 @@
 		A769B10C23E259AE00872273 /* SDL_nullevents_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A60B23E2513D00DCD162 /* SDL_nullevents_c.h */; };
 		A769B10D23E259AE00872273 /* SDL_sysjoystick.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A7CF23E2513E00DCD162 /* SDL_sysjoystick.h */; };
 		A769B10E23E259AE00872273 /* scancodes_linux.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A93623E2514000DCD162 /* scancodes_linux.h */; };
-		A769B10F23E259AE00872273 /* SDL_x11dyn.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71923E2513E00DCD162 /* SDL_x11dyn.h */; };
 		A769B11023E259AE00872273 /* SDL_touch_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A93723E2514000DCD162 /* SDL_touch_c.h */; };
 		A769B11123E259AE00872273 /* SDL_gamecontrollerdb.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A79E23E2513E00DCD162 /* SDL_gamecontrollerdb.h */; };
 		A769B11223E259AE00872273 /* SDL_cocoavulkan.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A68F23E2513E00DCD162 /* SDL_cocoavulkan.h */; };
 		A769B11323E259AE00872273 /* gl2platform.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72523E2513E00DCD162 /* gl2platform.h */; };
 		A769B11523E259AE00872273 /* vk_layer.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72D23E2513E00DCD162 /* vk_layer.h */; };
-		A769B11723E259AE00872273 /* SDL_cocoamousetap.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A68823E2513E00DCD162 /* SDL_cocoamousetap.h */; };
 		A769B11823E259AE00872273 /* vk_platform.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73123E2513E00DCD162 /* vk_platform.h */; };
 		A769B11A23E259AE00872273 /* SDL_cocoametalview.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A68623E2513E00DCD162 /* SDL_cocoametalview.h */; };
 		A769B11B23E259AE00872273 /* SDL_cocoaopengles.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A69023E2513E00DCD162 /* SDL_cocoaopengles.h */; };
@@ -1123,7 +1018,6 @@
 		A769B12323E259AE00872273 /* SDL_offscreenopengl.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A5F323E2513D00DCD162 /* SDL_offscreenopengl.h */; };
 		A769B12523E259AE00872273 /* scancodes_darwin.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A93423E2514000DCD162 /* scancodes_darwin.h */; };
 		A769B12623E259AE00872273 /* controller_type.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A7D923E2513E00DCD162 /* controller_type.h */; };
-		A769B12723E259AE00872273 /* SDL_x11opengles.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70323E2513E00DCD162 /* SDL_x11opengles.h */; };
 		A769B12823E259AE00872273 /* SDL_uikitclipboard.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A62123E2513D00DCD162 /* SDL_uikitclipboard.h */; };
 		A769B12923E259AE00872273 /* vulkan_xlib.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73A23E2513E00DCD162 /* vulkan_xlib.h */; };
 		A769B12A23E259AE00872273 /* SDL_uikitwindow.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A62723E2513D00DCD162 /* SDL_uikitwindow.h */; };
@@ -1135,7 +1029,6 @@
 		A769B13323E259AE00872273 /* SDL_blit_copy.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A76623E2513E00DCD162 /* SDL_blit_copy.h */; };
 		A769B13423E259AE00872273 /* SDL_RLEaccel_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A76723E2513E00DCD162 /* SDL_RLEaccel_c.h */; };
 		A769B13523E259AE00872273 /* eglplatform.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72B23E2513E00DCD162 /* eglplatform.h */; };
-		A769B13623E259AE00872273 /* edid.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71423E2513E00DCD162 /* edid.h */; };
 		A769B13823E259AE00872273 /* SDL_systhread.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A77723E2513E00DCD162 /* SDL_systhread.h */; };
 		A769B13B23E259AE00872273 /* SDL_cocoaclipboard.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A68A23E2513E00DCD162 /* SDL_cocoaclipboard.h */; };
 		A769B13C23E259AE00872273 /* SDL_cocoamodes.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A69123E2513E00DCD162 /* SDL_cocoamodes.h */; };
@@ -1168,10 +1061,8 @@
 		A769B16123E259AE00872273 /* usb_ids.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A7CB23E2513E00DCD162 /* usb_ids.h */; };
 		A769B16323E259AE00872273 /* SDL_gles2funcs.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A90623E2514000DCD162 /* SDL_gles2funcs.h */; };
 		A769B16923E259AE00872273 /* SDL_sysvideo.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A61723E2513D00DCD162 /* SDL_sysvideo.h */; };
-		A769B16C23E259AE00872273 /* SDL_x11mouse.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71A23E2513E00DCD162 /* SDL_x11mouse.h */; };
 		A769B16D23E259AE00872273 /* SDL_dynapi_overrides.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A5D923E2513D00DCD162 /* SDL_dynapi_overrides.h */; };
 		A769B16E23E259AE00872273 /* SDL_cocoawindow.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A69223E2513E00DCD162 /* SDL_cocoawindow.h */; };
-		A769B16F23E259AE00872273 /* SDL_x11vulkan.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71523E2513E00DCD162 /* SDL_x11vulkan.h */; };
 		A769B17123E259AE00872273 /* SDL_drawline.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8F123E2514000DCD162 /* SDL_drawline.c */; };
 		A769B17223E259AE00872273 /* SDL_yuv.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A67C23E2513E00DCD162 /* SDL_yuv.c */; };
 		A769B17323E259AE00872273 /* SDL_sysfilesystem.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A7FE23E2513F00DCD162 /* SDL_sysfilesystem.m */; };
@@ -1184,19 +1075,16 @@
 		A769B17A23E259AE00872273 /* SDL_render_metal.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8DE23E2514000DCD162 /* SDL_render_metal.m */; };
 		A769B17B23E259AE00872273 /* SDL_clipboard.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A67B23E2513E00DCD162 /* SDL_clipboard.c */; };
 		A769B17C23E259AE00872273 /* SDL_cocoaevents.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A68923E2513E00DCD162 /* SDL_cocoaevents.m */; };
-		A769B17D23E259AE00872273 /* SDL_x11messagebox.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71023E2513E00DCD162 /* SDL_x11messagebox.c */; };
 		A769B17E23E259AE00872273 /* SDL_audiocvt.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8A123E2513F00DCD162 /* SDL_audiocvt.c */; };
 		A769B17F23E259AE00872273 /* SDL_shape.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A76923E2513E00DCD162 /* SDL_shape.c */; };
 		A769B18023E259AE00872273 /* SDL_rotate.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8F423E2514000DCD162 /* SDL_rotate.c */; };
 		A769B18123E259AE00872273 /* SDL_coremotionsensor.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A57C23E2513D00DCD162 /* SDL_coremotionsensor.m */; };
 		A769B18223E259AE00872273 /* SDL_touch.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A93E23E2514000DCD162 /* SDL_touch.c */; };
-		A769B18423E259AE00872273 /* SDL_x11events.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70A23E2513E00DCD162 /* SDL_x11events.c */; };
 		A769B18523E259AE00872273 /* SDL_uikitmessagebox.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A61B23E2513D00DCD162 /* SDL_uikitmessagebox.m */; };
 		A769B18623E259AE00872273 /* SDL_thread.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A77923E2513E00DCD162 /* SDL_thread.c */; };
 		A769B18723E259AE00872273 /* SDL_hidapi_xbox360w.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A7C823E2513E00DCD162 /* SDL_hidapi_xbox360w.c */; };
 		A769B18823E259AE00872273 /* SDL_atomic.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A57423E2513D00DCD162 /* SDL_atomic.c */; };
 		A769B18923E259AE00872273 /* SDL_displayevents.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A92D23E2514000DCD162 /* SDL_displayevents.c */; };
-		A769B18A23E259AE00872273 /* SDL_cocoamousetap.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A69723E2513E00DCD162 /* SDL_cocoamousetap.m */; };
 		A769B18B23E259AE00872273 /* SDL_log.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A5DD23E2513D00DCD162 /* SDL_log.c */; };
 		A769B18C23E259AE00872273 /* SDL_cocoaopengl.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A67F23E2513E00DCD162 /* SDL_cocoaopengl.m */; };
 		A769B18D23E259AE00872273 /* SDL_offscreenframebuffer.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A5F223E2513D00DCD162 /* SDL_offscreenframebuffer.c */; };
@@ -1211,14 +1099,12 @@
 		A769B19623E259AE00872273 /* SDL_systimer.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A5E223E2513D00DCD162 /* SDL_systimer.c */; };
 		A769B19723E259AE00872273 /* SDL_uikitclipboard.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A62A23E2513D00DCD162 /* SDL_uikitclipboard.m */; };
 		A769B19823E259AE00872273 /* SDL_render_sw.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8F923E2514000DCD162 /* SDL_render_sw.c */; };
-		A769B19923E259AE00872273 /* SDL_x11video.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70823E2513E00DCD162 /* SDL_x11video.c */; };
 		A769B19A23E259AE00872273 /* SDL_syssem.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A78323E2513E00DCD162 /* SDL_syssem.c */; };
 		A769B19B23E259AE00872273 /* SDL_hidapi_xbox360.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A7C223E2513E00DCD162 /* SDL_hidapi_xbox360.c */; };
 		A769B19C23E259AE00872273 /* SDL_coreaudio.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8BB23E2513F00DCD162 /* SDL_coreaudio.m */; };
 		A769B19D23E259AE00872273 /* SDL_blendline.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8FB23E2514000DCD162 /* SDL_blendline.c */; };
 		A769B19E23E259AE00872273 /* SDL_blit_A.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A66423E2513E00DCD162 /* SDL_blit_A.c */; };
 		A769B19F23E259AE00872273 /* SDL_d3dmath.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8FF23E2514000DCD162 /* SDL_d3dmath.c */; };
-		A769B1A023E259AE00872273 /* SDL_x11mouse.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70423E2513E00DCD162 /* SDL_x11mouse.c */; };
 		A769B1A123E259AE00872273 /* SDL_nullvideo.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A60823E2513D00DCD162 /* SDL_nullvideo.c */; };
 		A769B1A223E259AE00872273 /* SDL_offscreenevents.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A5F023E2513D00DCD162 /* SDL_offscreenevents.c */; };
 		A769B1A323E259AE00872273 /* SDL_uikitview.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A62923E2513D00DCD162 /* SDL_uikitview.m */; };
@@ -1229,7 +1115,6 @@
 		A769B1A823E259AE00872273 /* s_copysign.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A91423E2514000DCD162 /* s_copysign.c */; };
 		A769B1A923E259AE00872273 /* SDL_haptic.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A5C523E2513D00DCD162 /* SDL_haptic.c */; };
 		A769B1AA23E259AE00872273 /* SDL_uikitvulkan.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A62523E2513D00DCD162 /* SDL_uikitvulkan.m */; };
-		A769B1AB23E259AE00872273 /* SDL_x11modes.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A6FE23E2513E00DCD162 /* SDL_x11modes.c */; };
 		A769B1AC23E259AE00872273 /* SDL_cocoametalview.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A69923E2513E00DCD162 /* SDL_cocoametalview.m */; };
 		A769B1AD23E259AE00872273 /* SDL_audiotypecvt.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8A023E2513F00DCD162 /* SDL_audiotypecvt.c */; };
 		A769B1AE23E259AE00872273 /* SDL_uikitevents.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A61C23E2513D00DCD162 /* SDL_uikitevents.m */; };
@@ -1260,15 +1145,10 @@
 		A769B1C723E259AE00872273 /* SDL_hints.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A5AB23E2513D00DCD162 /* SDL_hints.c */; };
 		A769B1C823E259AE00872273 /* SDL_hidapi_ps4.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A7C323E2513E00DCD162 /* SDL_hidapi_ps4.c */; };
 		A769B1C923E259AE00872273 /* SDL_pixels.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A64D23E2513D00DCD162 /* SDL_pixels.c */; };
-		A769B1CA23E259AE00872273 /* SDL_x11clipboard.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70B23E2513E00DCD162 /* SDL_x11clipboard.c */; };
 		A769B1CB23E259AE00872273 /* SDL_sysloadso.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A86323E2513F00DCD162 /* SDL_sysloadso.c */; };
-		A769B1CC23E259AE00872273 /* SDL_x11xinput2.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70223E2513E00DCD162 /* SDL_x11xinput2.c */; };
 		A769B1CD23E259AE00872273 /* SDL_syspower.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A7EB23E2513F00DCD162 /* SDL_syspower.c */; };
-		A769B1CE23E259AE00872273 /* SDL_x11touch.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71123E2513E00DCD162 /* SDL_x11touch.c */; };
 		A769B1CF23E259AE00872273 /* SDL_iconv.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8D323E2514000DCD162 /* SDL_iconv.c */; };
 		A769B1D023E259AE00872273 /* s_fabs.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A91523E2514000DCD162 /* s_fabs.c */; };
-		A769B1D123E259AE00872273 /* SDL_x11shape.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71623E2513E00DCD162 /* SDL_x11shape.c */; };
-		A769B1D223E259AE00872273 /* imKStoUCS.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70923E2513E00DCD162 /* imKStoUCS.c */; };
 		A769B1D323E259AE00872273 /* SDL_shaders_metal.metal in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8E023E2514000DCD162 /* SDL_shaders_metal.metal */; };
 		A769B1D423E259AE00872273 /* SDL_uikitwindow.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A61A23E2513D00DCD162 /* SDL_uikitwindow.m */; };
 		A769B1D523E259AE00872273 /* SDL_render.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8DB23E2514000DCD162 /* SDL_render.c */; };
@@ -1283,7 +1163,6 @@
 		A769B1DE23E259AE00872273 /* SDL_events.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A93523E2514000DCD162 /* SDL_events.c */; };
 		A769B1DF23E259AE00872273 /* SDL_blit_0.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A66223E2513E00DCD162 /* SDL_blit_0.c */; };
 		A769B1E023E259AE00872273 /* k_tan.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A92723E2514000DCD162 /* k_tan.c */; };
-		A769B1E123E259AE00872273 /* SDL_x11vulkan.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70023E2513E00DCD162 /* SDL_x11vulkan.c */; };
 		A769B1E223E259AE00872273 /* SDL_diskaudio.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8B123E2513F00DCD162 /* SDL_diskaudio.c */; };
 		A769B1E423E259AE00872273 /* SDL_egl.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A6B623E2513E00DCD162 /* SDL_egl.c */; };
 		A769B1E523E259AE00872273 /* SDL_RLEaccel.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A61523E2513D00DCD162 /* SDL_RLEaccel.c */; };
@@ -1298,7 +1177,6 @@
 		A769B1EF23E259AE00872273 /* SDL_string.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8D523E2514000DCD162 /* SDL_string.c */; };
 		A769B1F023E259AE00872273 /* SDL_render_gl.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A90F23E2514000DCD162 /* SDL_render_gl.c */; };
 		A769B1F123E259AE00872273 /* SDL_uikitopengles.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A62323E2513D00DCD162 /* SDL_uikitopengles.m */; };
-		A769B1F223E259AE00872273 /* SDL_x11opengles.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71B23E2513E00DCD162 /* SDL_x11opengles.c */; };
 		A769B1F323E259AE00872273 /* SDL_cocoamodes.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A68123E2513E00DCD162 /* SDL_cocoamodes.m */; };
 		A769B1F423E259AE00872273 /* k_rem_pio2.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A91623E2514000DCD162 /* k_rem_pio2.c */; };
 		A769B1F623E259AE00872273 /* SDL_gesture.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A94023E2514000DCD162 /* SDL_gesture.c */; };
@@ -1309,7 +1187,6 @@
 		A769B1FB23E259AE00872273 /* SDL_surface.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A61423E2513D00DCD162 /* SDL_surface.c */; };
 		A769B1FC23E259AE00872273 /* SDL_hidapi_xboxone.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A7C523E2513E00DCD162 /* SDL_hidapi_xboxone.c */; };
 		A769B1FD23E259AE00872273 /* SDL_blit_auto.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A63F23E2513D00DCD162 /* SDL_blit_auto.c */; };
-		A769B1FE23E259AE00872273 /* SDL_x11keyboard.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70C23E2513E00DCD162 /* SDL_x11keyboard.c */; };
 		A769B1FF23E259AE00872273 /* SDL_keyboard.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A93823E2514000DCD162 /* SDL_keyboard.c */; };
 		A769B20123E259AE00872273 /* SDL_rect.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A63423E2513D00DCD162 /* SDL_rect.c */; };
 		A769B20223E259AE00872273 /* SDL_cocoaopengles.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A68223E2513E00DCD162 /* SDL_cocoaopengles.m */; };
@@ -1317,7 +1194,6 @@
 		A769B20423E259AE00872273 /* SDL_hidapi_switch.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A7C623E2513E00DCD162 /* SDL_hidapi_switch.c */; };
 		A769B20523E259AE00872273 /* SDL_strtokr.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8D623E2514000DCD162 /* SDL_strtokr.c */; };
 		A769B20623E259AE00872273 /* SDL_clipboardevents.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A93A23E2514000DCD162 /* SDL_clipboardevents.c */; };
-		A769B20723E259AE00872273 /* SDL_x11framebuffer.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70623E2513E00DCD162 /* SDL_x11framebuffer.c */; };
 		A769B20823E259AE00872273 /* k_cos.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A91923E2514000DCD162 /* k_cos.c */; };
 		A769B20923E259AE00872273 /* SDL_hidapijoystick.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A7C423E2513E00DCD162 /* SDL_hidapijoystick.c */; };
 		A769B20A23E259AE00872273 /* SDL_malloc.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8D923E2514000DCD162 /* SDL_malloc.c */; };
@@ -1337,22 +1213,18 @@
 		A769B21823E259AE00872273 /* SDL_uikitmetalview.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A62E23E2513D00DCD162 /* SDL_uikitmetalview.m */; };
 		A769B21923E259AE00872273 /* SDL_shaders_gles2.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A90723E2514000DCD162 /* SDL_shaders_gles2.c */; };
 		A769B21A23E259AE00872273 /* SDL_blit_1.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A6FA23E2513E00DCD162 /* SDL_blit_1.c */; };
-		A769B21B23E259AE00872273 /* SDL_x11dyn.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70523E2513E00DCD162 /* SDL_x11dyn.c */; };
 		A769B21C23E259AE00872273 /* SDL_mouse.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A92A23E2514000DCD162 /* SDL_mouse.c */; };
 		A769B21D23E259AE00872273 /* e_rem_pio2.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A91F23E2514000DCD162 /* e_rem_pio2.c */; };
 		A769B21E23E259AE00872273 /* SDL_dataqueue.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A92823E2514000DCD162 /* SDL_dataqueue.c */; };
 		A769B21F23E259AE00872273 /* SDL_sysjoystick.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A7A023E2513E00DCD162 /* SDL_sysjoystick.c */; };
 		A769B22023E259AE00872273 /* SDL_cpuinfo.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A77523E2513E00DCD162 /* SDL_cpuinfo.c */; };
 		A769B22123E259AE00872273 /* SDL_sensor.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A58223E2513D00DCD162 /* SDL_sensor.c */; };
-		A769B22223E259AE00872273 /* SDL_x11window.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70723E2513E00DCD162 /* SDL_x11window.c */; };
 		A769B22323E259AE00872273 /* k_sin.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A91723E2514000DCD162 /* k_sin.c */; };
-		A769B22423E259AE00872273 /* edid-parse.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71223E2513E00DCD162 /* edid-parse.c */; };
 		A769B22523E259AE00872273 /* SDL_systimer.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A5E823E2513D00DCD162 /* SDL_systimer.c */; };
 		A769B22623E259AE00872273 /* SDL_drawpoint.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A8FC23E2514000DCD162 /* SDL_drawpoint.c */; };
 		A769B22723E259AE00872273 /* e_sqrt.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A92423E2514000DCD162 /* e_sqrt.c */; };
 		A769B22823E259AE00872273 /* SDL_cocoavideo.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A68523E2513E00DCD162 /* SDL_cocoavideo.m */; };
 		A769B22923E259AE00872273 /* SDL.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A57123E2513D00DCD162 /* SDL.c */; };
-		A769B22A23E259AE00872273 /* SDL_x11opengl.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A6FF23E2513E00DCD162 /* SDL_x11opengl.c */; };
 		A769B22B23E259AE00872273 /* SDL_cocoavulkan.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A68323E2513E00DCD162 /* SDL_cocoavulkan.m */; };
 		A769B22C23E259AE00872273 /* SDL_uikitappdelegate.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A61E23E2513D00DCD162 /* SDL_uikitappdelegate.m */; };
 		A769B22D23E259AE00872273 /* SDL_offscreenwindow.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A5EF23E2513D00DCD162 /* SDL_offscreenwindow.c */; };
@@ -2062,12 +1934,6 @@
 		A7D8AEBB23E2514100DCD162 /* SDL_cocoamouse.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A68723E2513E00DCD162 /* SDL_cocoamouse.m */; };
 		A7D8AEBC23E2514100DCD162 /* SDL_cocoamouse.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A68723E2513E00DCD162 /* SDL_cocoamouse.m */; };
 		A7D8AEBD23E2514100DCD162 /* SDL_cocoamouse.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A68723E2513E00DCD162 /* SDL_cocoamouse.m */; };
-		A7D8AEBE23E2514100DCD162 /* SDL_cocoamousetap.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A68823E2513E00DCD162 /* SDL_cocoamousetap.h */; };
-		A7D8AEBF23E2514100DCD162 /* SDL_cocoamousetap.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A68823E2513E00DCD162 /* SDL_cocoamousetap.h */; };
-		A7D8AEC023E2514100DCD162 /* SDL_cocoamousetap.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A68823E2513E00DCD162 /* SDL_cocoamousetap.h */; };
-		A7D8AEC123E2514100DCD162 /* SDL_cocoamousetap.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A68823E2513E00DCD162 /* SDL_cocoamousetap.h */; };
-		A7D8AEC223E2514100DCD162 /* SDL_cocoamousetap.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A68823E2513E00DCD162 /* SDL_cocoamousetap.h */; };
-		A7D8AEC323E2514100DCD162 /* SDL_cocoamousetap.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A68823E2513E00DCD162 /* SDL_cocoamousetap.h */; };
 		A7D8AEC423E2514100DCD162 /* SDL_cocoaevents.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A68923E2513E00DCD162 /* SDL_cocoaevents.m */; };
 		A7D8AEC523E2514100DCD162 /* SDL_cocoaevents.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A68923E2513E00DCD162 /* SDL_cocoaevents.m */; };
 		A7D8AEC623E2514100DCD162 /* SDL_cocoaevents.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A68923E2513E00DCD162 /* SDL_cocoaevents.m */; };
@@ -2152,12 +2018,6 @@
 		A7D8AF1523E2514100DCD162 /* SDL_cocoaevents.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A69623E2513E00DCD162 /* SDL_cocoaevents.h */; };
 		A7D8AF1623E2514100DCD162 /* SDL_cocoaevents.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A69623E2513E00DCD162 /* SDL_cocoaevents.h */; };
 		A7D8AF1723E2514100DCD162 /* SDL_cocoaevents.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A69623E2513E00DCD162 /* SDL_cocoaevents.h */; };
-		A7D8AF1823E2514100DCD162 /* SDL_cocoamousetap.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A69723E2513E00DCD162 /* SDL_cocoamousetap.m */; };
-		A7D8AF1923E2514100DCD162 /* SDL_cocoamousetap.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A69723E2513E00DCD162 /* SDL_cocoamousetap.m */; };
-		A7D8AF1A23E2514100DCD162 /* SDL_cocoamousetap.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A69723E2513E00DCD162 /* SDL_cocoamousetap.m */; };
-		A7D8AF1B23E2514100DCD162 /* SDL_cocoamousetap.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A69723E2513E00DCD162 /* SDL_cocoamousetap.m */; };
-		A7D8AF1C23E2514100DCD162 /* SDL_cocoamousetap.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A69723E2513E00DCD162 /* SDL_cocoamousetap.m */; };
-		A7D8AF1D23E2514100DCD162 /* SDL_cocoamousetap.m in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A69723E2513E00DCD162 /* SDL_cocoamousetap.m */; };
 		A7D8AF1E23E2514100DCD162 /* SDL_cocoamouse.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A69823E2513E00DCD162 /* SDL_cocoamouse.h */; };
 		A7D8AF1F23E2514100DCD162 /* SDL_cocoamouse.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A69823E2513E00DCD162 /* SDL_cocoamouse.h */; };
 		A7D8AF2023E2514100DCD162 /* SDL_cocoamouse.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A69823E2513E00DCD162 /* SDL_cocoamouse.h */; };
@@ -2182,228 +2042,6 @@
 		A7D8B14323E2514200DCD162 /* SDL_blit_1.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A6FA23E2513E00DCD162 /* SDL_blit_1.c */; };
 		A7D8B14423E2514200DCD162 /* SDL_blit_1.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A6FA23E2513E00DCD162 /* SDL_blit_1.c */; };
 		A7D8B14523E2514200DCD162 /* SDL_blit_1.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A6FA23E2513E00DCD162 /* SDL_blit_1.c */; };
-		A7D8B14623E2514200DCD162 /* SDL_x11touch.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A6FC23E2513E00DCD162 /* SDL_x11touch.h */; };
-		A7D8B14723E2514200DCD162 /* SDL_x11touch.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A6FC23E2513E00DCD162 /* SDL_x11touch.h */; };
-		A7D8B14823E2514200DCD162 /* SDL_x11touch.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A6FC23E2513E00DCD162 /* SDL_x11touch.h */; };
-		A7D8B14923E2514200DCD162 /* SDL_x11touch.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A6FC23E2513E00DCD162 /* SDL_x11touch.h */; };
-		A7D8B14A23E2514200DCD162 /* SDL_x11touch.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A6FC23E2513E00DCD162 /* SDL_x11touch.h */; };
-		A7D8B14B23E2514200DCD162 /* SDL_x11touch.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A6FC23E2513E00DCD162 /* SDL_x11touch.h */; };
-		A7D8B14C23E2514200DCD162 /* SDL_x11messagebox.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A6FD23E2513E00DCD162 /* SDL_x11messagebox.h */; };
-		A7D8B14D23E2514200DCD162 /* SDL_x11messagebox.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A6FD23E2513E00DCD162 /* SDL_x11messagebox.h */; };
-		A7D8B14E23E2514200DCD162 /* SDL_x11messagebox.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A6FD23E2513E00DCD162 /* SDL_x11messagebox.h */; };
-		A7D8B14F23E2514200DCD162 /* SDL_x11messagebox.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A6FD23E2513E00DCD162 /* SDL_x11messagebox.h */; };
-		A7D8B15023E2514200DCD162 /* SDL_x11messagebox.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A6FD23E2513E00DCD162 /* SDL_x11messagebox.h */; };
-		A7D8B15123E2514200DCD162 /* SDL_x11messagebox.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A6FD23E2513E00DCD162 /* SDL_x11messagebox.h */; };
-		A7D8B15223E2514200DCD162 /* SDL_x11modes.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A6FE23E2513E00DCD162 /* SDL_x11modes.c */; };
-		A7D8B15323E2514200DCD162 /* SDL_x11modes.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A6FE23E2513E00DCD162 /* SDL_x11modes.c */; };
-		A7D8B15423E2514200DCD162 /* SDL_x11modes.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A6FE23E2513E00DCD162 /* SDL_x11modes.c */; };
-		A7D8B15523E2514200DCD162 /* SDL_x11modes.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A6FE23E2513E00DCD162 /* SDL_x11modes.c */; };
-		A7D8B15623E2514200DCD162 /* SDL_x11modes.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A6FE23E2513E00DCD162 /* SDL_x11modes.c */; };
-		A7D8B15723E2514200DCD162 /* SDL_x11modes.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A6FE23E2513E00DCD162 /* SDL_x11modes.c */; };
-		A7D8B15823E2514200DCD162 /* SDL_x11opengl.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A6FF23E2513E00DCD162 /* SDL_x11opengl.c */; };
-		A7D8B15923E2514200DCD162 /* SDL_x11opengl.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A6FF23E2513E00DCD162 /* SDL_x11opengl.c */; };
-		A7D8B15A23E2514200DCD162 /* SDL_x11opengl.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A6FF23E2513E00DCD162 /* SDL_x11opengl.c */; };
-		A7D8B15B23E2514200DCD162 /* SDL_x11opengl.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A6FF23E2513E00DCD162 /* SDL_x11opengl.c */; };
-		A7D8B15C23E2514200DCD162 /* SDL_x11opengl.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A6FF23E2513E00DCD162 /* SDL_x11opengl.c */; };
-		A7D8B15D23E2514200DCD162 /* SDL_x11opengl.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A6FF23E2513E00DCD162 /* SDL_x11opengl.c */; };
-		A7D8B15E23E2514200DCD162 /* SDL_x11vulkan.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70023E2513E00DCD162 /* SDL_x11vulkan.c */; };
-		A7D8B15F23E2514200DCD162 /* SDL_x11vulkan.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70023E2513E00DCD162 /* SDL_x11vulkan.c */; };
-		A7D8B16023E2514200DCD162 /* SDL_x11vulkan.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70023E2513E00DCD162 /* SDL_x11vulkan.c */; };
-		A7D8B16123E2514200DCD162 /* SDL_x11vulkan.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70023E2513E00DCD162 /* SDL_x11vulkan.c */; };
-		A7D8B16223E2514200DCD162 /* SDL_x11vulkan.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70023E2513E00DCD162 /* SDL_x11vulkan.c */; };
-		A7D8B16323E2514200DCD162 /* SDL_x11vulkan.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70023E2513E00DCD162 /* SDL_x11vulkan.c */; };
-		A7D8B16423E2514200DCD162 /* SDL_x11shape.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70123E2513E00DCD162 /* SDL_x11shape.h */; };
-		A7D8B16523E2514200DCD162 /* SDL_x11shape.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70123E2513E00DCD162 /* SDL_x11shape.h */; };
-		A7D8B16623E2514200DCD162 /* SDL_x11shape.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70123E2513E00DCD162 /* SDL_x11shape.h */; };
-		A7D8B16723E2514200DCD162 /* SDL_x11shape.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70123E2513E00DCD162 /* SDL_x11shape.h */; };
-		A7D8B16823E2514200DCD162 /* SDL_x11shape.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70123E2513E00DCD162 /* SDL_x11shape.h */; };
-		A7D8B16923E2514200DCD162 /* SDL_x11shape.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70123E2513E00DCD162 /* SDL_x11shape.h */; };
-		A7D8B16A23E2514200DCD162 /* SDL_x11xinput2.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70223E2513E00DCD162 /* SDL_x11xinput2.c */; };
-		A7D8B16B23E2514200DCD162 /* SDL_x11xinput2.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70223E2513E00DCD162 /* SDL_x11xinput2.c */; };
-		A7D8B16C23E2514200DCD162 /* SDL_x11xinput2.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70223E2513E00DCD162 /* SDL_x11xinput2.c */; };
-		A7D8B16D23E2514200DCD162 /* SDL_x11xinput2.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70223E2513E00DCD162 /* SDL_x11xinput2.c */; };
-		A7D8B16E23E2514200DCD162 /* SDL_x11xinput2.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70223E2513E00DCD162 /* SDL_x11xinput2.c */; };
-		A7D8B16F23E2514200DCD162 /* SDL_x11xinput2.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70223E2513E00DCD162 /* SDL_x11xinput2.c */; };
-		A7D8B17023E2514200DCD162 /* SDL_x11opengles.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70323E2513E00DCD162 /* SDL_x11opengles.h */; };
-		A7D8B17123E2514200DCD162 /* SDL_x11opengles.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70323E2513E00DCD162 /* SDL_x11opengles.h */; };
-		A7D8B17223E2514200DCD162 /* SDL_x11opengles.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70323E2513E00DCD162 /* SDL_x11opengles.h */; };
-		A7D8B17323E2514200DCD162 /* SDL_x11opengles.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70323E2513E00DCD162 /* SDL_x11opengles.h */; };
-		A7D8B17423E2514200DCD162 /* SDL_x11opengles.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70323E2513E00DCD162 /* SDL_x11opengles.h */; };
-		A7D8B17523E2514200DCD162 /* SDL_x11opengles.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70323E2513E00DCD162 /* SDL_x11opengles.h */; };
-		A7D8B17623E2514200DCD162 /* SDL_x11mouse.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70423E2513E00DCD162 /* SDL_x11mouse.c */; };
-		A7D8B17723E2514200DCD162 /* SDL_x11mouse.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70423E2513E00DCD162 /* SDL_x11mouse.c */; };
-		A7D8B17823E2514200DCD162 /* SDL_x11mouse.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70423E2513E00DCD162 /* SDL_x11mouse.c */; };
-		A7D8B17923E2514200DCD162 /* SDL_x11mouse.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70423E2513E00DCD162 /* SDL_x11mouse.c */; };
-		A7D8B17A23E2514200DCD162 /* SDL_x11mouse.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70423E2513E00DCD162 /* SDL_x11mouse.c */; };
-		A7D8B17B23E2514200DCD162 /* SDL_x11mouse.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70423E2513E00DCD162 /* SDL_x11mouse.c */; };
-		A7D8B17C23E2514200DCD162 /* SDL_x11dyn.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70523E2513E00DCD162 /* SDL_x11dyn.c */; };
-		A7D8B17D23E2514200DCD162 /* SDL_x11dyn.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70523E2513E00DCD162 /* SDL_x11dyn.c */; };
-		A7D8B17E23E2514200DCD162 /* SDL_x11dyn.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70523E2513E00DCD162 /* SDL_x11dyn.c */; };
-		A7D8B17F23E2514200DCD162 /* SDL_x11dyn.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70523E2513E00DCD162 /* SDL_x11dyn.c */; };
-		A7D8B18023E2514200DCD162 /* SDL_x11dyn.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70523E2513E00DCD162 /* SDL_x11dyn.c */; };
-		A7D8B18123E2514200DCD162 /* SDL_x11dyn.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70523E2513E00DCD162 /* SDL_x11dyn.c */; };
-		A7D8B18223E2514200DCD162 /* SDL_x11framebuffer.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70623E2513E00DCD162 /* SDL_x11framebuffer.c */; };
-		A7D8B18323E2514200DCD162 /* SDL_x11framebuffer.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70623E2513E00DCD162 /* SDL_x11framebuffer.c */; };
-		A7D8B18423E2514200DCD162 /* SDL_x11framebuffer.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70623E2513E00DCD162 /* SDL_x11framebuffer.c */; };
-		A7D8B18523E2514200DCD162 /* SDL_x11framebuffer.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70623E2513E00DCD162 /* SDL_x11framebuffer.c */; };
-		A7D8B18623E2514200DCD162 /* SDL_x11framebuffer.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70623E2513E00DCD162 /* SDL_x11framebuffer.c */; };
-		A7D8B18723E2514200DCD162 /* SDL_x11framebuffer.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70623E2513E00DCD162 /* SDL_x11framebuffer.c */; };
-		A7D8B18823E2514200DCD162 /* SDL_x11window.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70723E2513E00DCD162 /* SDL_x11window.c */; };
-		A7D8B18923E2514200DCD162 /* SDL_x11window.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70723E2513E00DCD162 /* SDL_x11window.c */; };
-		A7D8B18A23E2514200DCD162 /* SDL_x11window.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70723E2513E00DCD162 /* SDL_x11window.c */; };
-		A7D8B18B23E2514200DCD162 /* SDL_x11window.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70723E2513E00DCD162 /* SDL_x11window.c */; };
-		A7D8B18C23E2514200DCD162 /* SDL_x11window.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70723E2513E00DCD162 /* SDL_x11window.c */; };
-		A7D8B18D23E2514200DCD162 /* SDL_x11window.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70723E2513E00DCD162 /* SDL_x11window.c */; };
-		A7D8B18E23E2514200DCD162 /* SDL_x11video.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70823E2513E00DCD162 /* SDL_x11video.c */; };
-		A7D8B18F23E2514200DCD162 /* SDL_x11video.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70823E2513E00DCD162 /* SDL_x11video.c */; };
-		A7D8B19023E2514200DCD162 /* SDL_x11video.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70823E2513E00DCD162 /* SDL_x11video.c */; };
-		A7D8B19123E2514200DCD162 /* SDL_x11video.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70823E2513E00DCD162 /* SDL_x11video.c */; };
-		A7D8B19223E2514200DCD162 /* SDL_x11video.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70823E2513E00DCD162 /* SDL_x11video.c */; };
-		A7D8B19323E2514200DCD162 /* SDL_x11video.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70823E2513E00DCD162 /* SDL_x11video.c */; };
-		A7D8B19423E2514200DCD162 /* imKStoUCS.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70923E2513E00DCD162 /* imKStoUCS.c */; };
-		A7D8B19523E2514200DCD162 /* imKStoUCS.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70923E2513E00DCD162 /* imKStoUCS.c */; };
-		A7D8B19623E2514200DCD162 /* imKStoUCS.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70923E2513E00DCD162 /* imKStoUCS.c */; };
-		A7D8B19723E2514200DCD162 /* imKStoUCS.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70923E2513E00DCD162 /* imKStoUCS.c */; };
-		A7D8B19823E2514200DCD162 /* imKStoUCS.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70923E2513E00DCD162 /* imKStoUCS.c */; };
-		A7D8B19923E2514200DCD162 /* imKStoUCS.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70923E2513E00DCD162 /* imKStoUCS.c */; };
-		A7D8B19A23E2514200DCD162 /* SDL_x11events.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70A23E2513E00DCD162 /* SDL_x11events.c */; };
-		A7D8B19B23E2514200DCD162 /* SDL_x11events.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70A23E2513E00DCD162 /* SDL_x11events.c */; };
-		A7D8B19C23E2514200DCD162 /* SDL_x11events.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70A23E2513E00DCD162 /* SDL_x11events.c */; };
-		A7D8B19D23E2514200DCD162 /* SDL_x11events.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70A23E2513E00DCD162 /* SDL_x11events.c */; };
-		A7D8B19E23E2514200DCD162 /* SDL_x11events.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70A23E2513E00DCD162 /* SDL_x11events.c */; };
-		A7D8B19F23E2514200DCD162 /* SDL_x11events.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70A23E2513E00DCD162 /* SDL_x11events.c */; };
-		A7D8B1A023E2514200DCD162 /* SDL_x11clipboard.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70B23E2513E00DCD162 /* SDL_x11clipboard.c */; };
-		A7D8B1A123E2514200DCD162 /* SDL_x11clipboard.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70B23E2513E00DCD162 /* SDL_x11clipboard.c */; };
-		A7D8B1A223E2514200DCD162 /* SDL_x11clipboard.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70B23E2513E00DCD162 /* SDL_x11clipboard.c */; };
-		A7D8B1A323E2514200DCD162 /* SDL_x11clipboard.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70B23E2513E00DCD162 /* SDL_x11clipboard.c */; };
-		A7D8B1A423E2514200DCD162 /* SDL_x11clipboard.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70B23E2513E00DCD162 /* SDL_x11clipboard.c */; };
-		A7D8B1A523E2514200DCD162 /* SDL_x11clipboard.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70B23E2513E00DCD162 /* SDL_x11clipboard.c */; };
-		A7D8B1A623E2514200DCD162 /* SDL_x11keyboard.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70C23E2513E00DCD162 /* SDL_x11keyboard.c */; };
-		A7D8B1A723E2514200DCD162 /* SDL_x11keyboard.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70C23E2513E00DCD162 /* SDL_x11keyboard.c */; };
-		A7D8B1A823E2514200DCD162 /* SDL_x11keyboard.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70C23E2513E00DCD162 /* SDL_x11keyboard.c */; };
-		A7D8B1A923E2514200DCD162 /* SDL_x11keyboard.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70C23E2513E00DCD162 /* SDL_x11keyboard.c */; };
-		A7D8B1AA23E2514200DCD162 /* SDL_x11keyboard.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70C23E2513E00DCD162 /* SDL_x11keyboard.c */; };
-		A7D8B1AB23E2514200DCD162 /* SDL_x11keyboard.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A70C23E2513E00DCD162 /* SDL_x11keyboard.c */; };
-		A7D8B1AC23E2514200DCD162 /* SDL_x11sym.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70D23E2513E00DCD162 /* SDL_x11sym.h */; };
-		A7D8B1AD23E2514200DCD162 /* SDL_x11sym.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70D23E2513E00DCD162 /* SDL_x11sym.h */; };
-		A7D8B1AE23E2514200DCD162 /* SDL_x11sym.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70D23E2513E00DCD162 /* SDL_x11sym.h */; };
-		A7D8B1AF23E2514200DCD162 /* SDL_x11sym.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70D23E2513E00DCD162 /* SDL_x11sym.h */; };
-		A7D8B1B023E2514200DCD162 /* SDL_x11sym.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70D23E2513E00DCD162 /* SDL_x11sym.h */; };
-		A7D8B1B123E2514200DCD162 /* SDL_x11sym.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70D23E2513E00DCD162 /* SDL_x11sym.h */; };
-		A7D8B1B223E2514200DCD162 /* SDL_x11opengl.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70E23E2513E00DCD162 /* SDL_x11opengl.h */; };
-		A7D8B1B323E2514200DCD162 /* SDL_x11opengl.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70E23E2513E00DCD162 /* SDL_x11opengl.h */; };
-		A7D8B1B423E2514200DCD162 /* SDL_x11opengl.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70E23E2513E00DCD162 /* SDL_x11opengl.h */; };
-		A7D8B1B523E2514200DCD162 /* SDL_x11opengl.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70E23E2513E00DCD162 /* SDL_x11opengl.h */; };
-		A7D8B1B623E2514200DCD162 /* SDL_x11opengl.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70E23E2513E00DCD162 /* SDL_x11opengl.h */; };
-		A7D8B1B723E2514200DCD162 /* SDL_x11opengl.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70E23E2513E00DCD162 /* SDL_x11opengl.h */; };
-		A7D8B1B823E2514200DCD162 /* SDL_x11modes.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70F23E2513E00DCD162 /* SDL_x11modes.h */; };
-		A7D8B1B923E2514200DCD162 /* SDL_x11modes.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70F23E2513E00DCD162 /* SDL_x11modes.h */; };
-		A7D8B1BA23E2514200DCD162 /* SDL_x11modes.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70F23E2513E00DCD162 /* SDL_x11modes.h */; };
-		A7D8B1BB23E2514200DCD162 /* SDL_x11modes.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70F23E2513E00DCD162 /* SDL_x11modes.h */; };
-		A7D8B1BC23E2514200DCD162 /* SDL_x11modes.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70F23E2513E00DCD162 /* SDL_x11modes.h */; };
-		A7D8B1BD23E2514200DCD162 /* SDL_x11modes.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A70F23E2513E00DCD162 /* SDL_x11modes.h */; };
-		A7D8B1BE23E2514200DCD162 /* SDL_x11messagebox.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71023E2513E00DCD162 /* SDL_x11messagebox.c */; };
-		A7D8B1BF23E2514200DCD162 /* SDL_x11messagebox.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71023E2513E00DCD162 /* SDL_x11messagebox.c */; };
-		A7D8B1C023E2514200DCD162 /* SDL_x11messagebox.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71023E2513E00DCD162 /* SDL_x11messagebox.c */; };
-		A7D8B1C123E2514200DCD162 /* SDL_x11messagebox.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71023E2513E00DCD162 /* SDL_x11messagebox.c */; };
-		A7D8B1C223E2514200DCD162 /* SDL_x11messagebox.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71023E2513E00DCD162 /* SDL_x11messagebox.c */; };
-		A7D8B1C323E2514200DCD162 /* SDL_x11messagebox.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71023E2513E00DCD162 /* SDL_x11messagebox.c */; };
-		A7D8B1C423E2514200DCD162 /* SDL_x11touch.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71123E2513E00DCD162 /* SDL_x11touch.c */; };
-		A7D8B1C523E2514200DCD162 /* SDL_x11touch.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71123E2513E00DCD162 /* SDL_x11touch.c */; };
-		A7D8B1C623E2514200DCD162 /* SDL_x11touch.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71123E2513E00DCD162 /* SDL_x11touch.c */; };
-		A7D8B1C723E2514200DCD162 /* SDL_x11touch.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71123E2513E00DCD162 /* SDL_x11touch.c */; };
-		A7D8B1C823E2514200DCD162 /* SDL_x11touch.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71123E2513E00DCD162 /* SDL_x11touch.c */; };
-		A7D8B1C923E2514200DCD162 /* SDL_x11touch.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71123E2513E00DCD162 /* SDL_x11touch.c */; };
-		A7D8B1CA23E2514200DCD162 /* edid-parse.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71223E2513E00DCD162 /* edid-parse.c */; };
-		A7D8B1CB23E2514200DCD162 /* edid-parse.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71223E2513E00DCD162 /* edid-parse.c */; };
-		A7D8B1CC23E2514200DCD162 /* edid-parse.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71223E2513E00DCD162 /* edid-parse.c */; };
-		A7D8B1CD23E2514200DCD162 /* edid-parse.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71223E2513E00DCD162 /* edid-parse.c */; };
-		A7D8B1CE23E2514200DCD162 /* edid-parse.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71223E2513E00DCD162 /* edid-parse.c */; };
-		A7D8B1CF23E2514200DCD162 /* edid-parse.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71223E2513E00DCD162 /* edid-parse.c */; };
-		A7D8B1D023E2514200DCD162 /* SDL_x11xinput2.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71323E2513E00DCD162 /* SDL_x11xinput2.h */; };
-		A7D8B1D123E2514200DCD162 /* SDL_x11xinput2.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71323E2513E00DCD162 /* SDL_x11xinput2.h */; };
-		A7D8B1D223E2514200DCD162 /* SDL_x11xinput2.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71323E2513E00DCD162 /* SDL_x11xinput2.h */; };
-		A7D8B1D323E2514200DCD162 /* SDL_x11xinput2.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71323E2513E00DCD162 /* SDL_x11xinput2.h */; };
-		A7D8B1D423E2514200DCD162 /* SDL_x11xinput2.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71323E2513E00DCD162 /* SDL_x11xinput2.h */; };
-		A7D8B1D523E2514200DCD162 /* SDL_x11xinput2.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71323E2513E00DCD162 /* SDL_x11xinput2.h */; };
-		A7D8B1D623E2514200DCD162 /* edid.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71423E2513E00DCD162 /* edid.h */; };
-		A7D8B1D723E2514200DCD162 /* edid.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71423E2513E00DCD162 /* edid.h */; };
-		A7D8B1D823E2514200DCD162 /* edid.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71423E2513E00DCD162 /* edid.h */; };
-		A7D8B1D923E2514200DCD162 /* edid.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71423E2513E00DCD162 /* edid.h */; };
-		A7D8B1DA23E2514200DCD162 /* edid.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71423E2513E00DCD162 /* edid.h */; };
-		A7D8B1DB23E2514200DCD162 /* edid.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71423E2513E00DCD162 /* edid.h */; };
-		A7D8B1DC23E2514200DCD162 /* SDL_x11vulkan.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71523E2513E00DCD162 /* SDL_x11vulkan.h */; };
-		A7D8B1DD23E2514200DCD162 /* SDL_x11vulkan.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71523E2513E00DCD162 /* SDL_x11vulkan.h */; };
-		A7D8B1DE23E2514200DCD162 /* SDL_x11vulkan.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71523E2513E00DCD162 /* SDL_x11vulkan.h */; };
-		A7D8B1DF23E2514200DCD162 /* SDL_x11vulkan.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71523E2513E00DCD162 /* SDL_x11vulkan.h */; };
-		A7D8B1E023E2514200DCD162 /* SDL_x11vulkan.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71523E2513E00DCD162 /* SDL_x11vulkan.h */; };
-		A7D8B1E123E2514200DCD162 /* SDL_x11vulkan.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71523E2513E00DCD162 /* SDL_x11vulkan.h */; };
-		A7D8B1E223E2514200DCD162 /* SDL_x11shape.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71623E2513E00DCD162 /* SDL_x11shape.c */; };
-		A7D8B1E323E2514200DCD162 /* SDL_x11shape.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71623E2513E00DCD162 /* SDL_x11shape.c */; };
-		A7D8B1E423E2514200DCD162 /* SDL_x11shape.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71623E2513E00DCD162 /* SDL_x11shape.c */; };
-		A7D8B1E523E2514200DCD162 /* SDL_x11shape.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71623E2513E00DCD162 /* SDL_x11shape.c */; };
-		A7D8B1E623E2514200DCD162 /* SDL_x11shape.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71623E2513E00DCD162 /* SDL_x11shape.c */; };
-		A7D8B1E723E2514200DCD162 /* SDL_x11shape.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71623E2513E00DCD162 /* SDL_x11shape.c */; };
-		A7D8B1E823E2514200DCD162 /* SDL_x11window.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71723E2513E00DCD162 /* SDL_x11window.h */; };
-		A7D8B1E923E2514200DCD162 /* SDL_x11window.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71723E2513E00DCD162 /* SDL_x11window.h */; };
-		A7D8B1EA23E2514200DCD162 /* SDL_x11window.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71723E2513E00DCD162 /* SDL_x11window.h */; };
-		A7D8B1EB23E2514200DCD162 /* SDL_x11window.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71723E2513E00DCD162 /* SDL_x11window.h */; };
-		A7D8B1EC23E2514200DCD162 /* SDL_x11window.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71723E2513E00DCD162 /* SDL_x11window.h */; };
-		A7D8B1ED23E2514200DCD162 /* SDL_x11window.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71723E2513E00DCD162 /* SDL_x11window.h */; };
-		A7D8B1EE23E2514200DCD162 /* SDL_x11framebuffer.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71823E2513E00DCD162 /* SDL_x11framebuffer.h */; };
-		A7D8B1EF23E2514200DCD162 /* SDL_x11framebuffer.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71823E2513E00DCD162 /* SDL_x11framebuffer.h */; };
-		A7D8B1F023E2514200DCD162 /* SDL_x11framebuffer.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71823E2513E00DCD162 /* SDL_x11framebuffer.h */; };
-		A7D8B1F123E2514200DCD162 /* SDL_x11framebuffer.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71823E2513E00DCD162 /* SDL_x11framebuffer.h */; };
-		A7D8B1F223E2514200DCD162 /* SDL_x11framebuffer.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71823E2513E00DCD162 /* SDL_x11framebuffer.h */; };
-		A7D8B1F323E2514200DCD162 /* SDL_x11framebuffer.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71823E2513E00DCD162 /* SDL_x11framebuffer.h */; };
-		A7D8B1F423E2514200DCD162 /* SDL_x11dyn.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71923E2513E00DCD162 /* SDL_x11dyn.h */; };
-		A7D8B1F523E2514200DCD162 /* SDL_x11dyn.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71923E2513E00DCD162 /* SDL_x11dyn.h */; };
-		A7D8B1F623E2514200DCD162 /* SDL_x11dyn.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71923E2513E00DCD162 /* SDL_x11dyn.h */; };
-		A7D8B1F723E2514200DCD162 /* SDL_x11dyn.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71923E2513E00DCD162 /* SDL_x11dyn.h */; };
-		A7D8B1F823E2514200DCD162 /* SDL_x11dyn.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71923E2513E00DCD162 /* SDL_x11dyn.h */; };
-		A7D8B1F923E2514200DCD162 /* SDL_x11dyn.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71923E2513E00DCD162 /* SDL_x11dyn.h */; };
-		A7D8B1FA23E2514200DCD162 /* SDL_x11mouse.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71A23E2513E00DCD162 /* SDL_x11mouse.h */; };
-		A7D8B1FB23E2514200DCD162 /* SDL_x11mouse.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71A23E2513E00DCD162 /* SDL_x11mouse.h */; };
-		A7D8B1FC23E2514200DCD162 /* SDL_x11mouse.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71A23E2513E00DCD162 /* SDL_x11mouse.h */; };
-		A7D8B1FD23E2514200DCD162 /* SDL_x11mouse.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71A23E2513E00DCD162 /* SDL_x11mouse.h */; };
-		A7D8B1FE23E2514200DCD162 /* SDL_x11mouse.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71A23E2513E00DCD162 /* SDL_x11mouse.h */; };
-		A7D8B1FF23E2514200DCD162 /* SDL_x11mouse.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71A23E2513E00DCD162 /* SDL_x11mouse.h */; };
-		A7D8B20023E2514200DCD162 /* SDL_x11opengles.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71B23E2513E00DCD162 /* SDL_x11opengles.c */; };
-		A7D8B20123E2514200DCD162 /* SDL_x11opengles.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71B23E2513E00DCD162 /* SDL_x11opengles.c */; };
-		A7D8B20223E2514200DCD162 /* SDL_x11opengles.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71B23E2513E00DCD162 /* SDL_x11opengles.c */; };
-		A7D8B20323E2514200DCD162 /* SDL_x11opengles.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71B23E2513E00DCD162 /* SDL_x11opengles.c */; };
-		A7D8B20423E2514200DCD162 /* SDL_x11opengles.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71B23E2513E00DCD162 /* SDL_x11opengles.c */; };
-		A7D8B20523E2514200DCD162 /* SDL_x11opengles.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A71B23E2513E00DCD162 /* SDL_x11opengles.c */; };
-		A7D8B20623E2514200DCD162 /* SDL_x11keyboard.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71C23E2513E00DCD162 /* SDL_x11keyboard.h */; };
-		A7D8B20723E2514200DCD162 /* SDL_x11keyboard.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71C23E2513E00DCD162 /* SDL_x11keyboard.h */; };
-		A7D8B20823E2514200DCD162 /* SDL_x11keyboard.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71C23E2513E00DCD162 /* SDL_x11keyboard.h */; };
-		A7D8B20923E2514200DCD162 /* SDL_x11keyboard.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71C23E2513E00DCD162 /* SDL_x11keyboard.h */; };
-		A7D8B20A23E2514200DCD162 /* SDL_x11keyboard.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71C23E2513E00DCD162 /* SDL_x11keyboard.h */; };
-		A7D8B20B23E2514200DCD162 /* SDL_x11keyboard.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71C23E2513E00DCD162 /* SDL_x11keyboard.h */; };
-		A7D8B20C23E2514200DCD162 /* SDL_x11clipboard.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71D23E2513E00DCD162 /* SDL_x11clipboard.h */; };
-		A7D8B20D23E2514200DCD162 /* SDL_x11clipboard.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71D23E2513E00DCD162 /* SDL_x11clipboard.h */; };
-		A7D8B20E23E2514200DCD162 /* SDL_x11clipboard.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71D23E2513E00DCD162 /* SDL_x11clipboard.h */; };
-		A7D8B20F23E2514200DCD162 /* SDL_x11clipboard.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71D23E2513E00DCD162 /* SDL_x11clipboard.h */; };
-		A7D8B21023E2514200DCD162 /* SDL_x11clipboard.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71D23E2513E00DCD162 /* SDL_x11clipboard.h */; };
-		A7D8B21123E2514200DCD162 /* SDL_x11clipboard.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71D23E2513E00DCD162 /* SDL_x11clipboard.h */; };
-		A7D8B21223E2514200DCD162 /* SDL_x11events.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71E23E2513E00DCD162 /* SDL_x11events.h */; };
-		A7D8B21323E2514200DCD162 /* SDL_x11events.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71E23E2513E00DCD162 /* SDL_x11events.h */; };
-		A7D8B21423E2514200DCD162 /* SDL_x11events.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71E23E2513E00DCD162 /* SDL_x11events.h */; };
-		A7D8B21523E2514200DCD162 /* SDL_x11events.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71E23E2513E00DCD162 /* SDL_x11events.h */; };
-		A7D8B21623E2514200DCD162 /* SDL_x11events.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71E23E2513E00DCD162 /* SDL_x11events.h */; };
-		A7D8B21723E2514200DCD162 /* SDL_x11events.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71E23E2513E00DCD162 /* SDL_x11events.h */; };
-		A7D8B21823E2514200DCD162 /* imKStoUCS.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71F23E2513E00DCD162 /* imKStoUCS.h */; };
-		A7D8B21923E2514200DCD162 /* imKStoUCS.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71F23E2513E00DCD162 /* imKStoUCS.h */; };
-		A7D8B21A23E2514200DCD162 /* imKStoUCS.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71F23E2513E00DCD162 /* imKStoUCS.h */; };
-		A7D8B21B23E2514200DCD162 /* imKStoUCS.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71F23E2513E00DCD162 /* imKStoUCS.h */; };
-		A7D8B21C23E2514200DCD162 /* imKStoUCS.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71F23E2513E00DCD162 /* imKStoUCS.h */; };
-		A7D8B21D23E2514200DCD162 /* imKStoUCS.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A71F23E2513E00DCD162 /* imKStoUCS.h */; };
-		A7D8B21E23E2514200DCD162 /* SDL_x11video.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72023E2513E00DCD162 /* SDL_x11video.h */; };
-		A7D8B21F23E2514200DCD162 /* SDL_x11video.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72023E2513E00DCD162 /* SDL_x11video.h */; };
-		A7D8B22023E2514200DCD162 /* SDL_x11video.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72023E2513E00DCD162 /* SDL_x11video.h */; };
-		A7D8B22123E2514200DCD162 /* SDL_x11video.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72023E2513E00DCD162 /* SDL_x11video.h */; };
-		A7D8B22223E2514200DCD162 /* SDL_x11video.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72023E2513E00DCD162 /* SDL_x11video.h */; };
-		A7D8B22323E2514200DCD162 /* SDL_x11video.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72023E2513E00DCD162 /* SDL_x11video.h */; };
 		A7D8B22423E2514200DCD162 /* gl2ext.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72323E2513E00DCD162 /* gl2ext.h */; };
 		A7D8B22523E2514200DCD162 /* gl2ext.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72323E2513E00DCD162 /* gl2ext.h */; };
 		A7D8B22623E2514200DCD162 /* gl2ext.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72323E2513E00DCD162 /* gl2ext.h */; };
@@ -3728,9 +3366,8 @@
 		DB31408D17554D3C006C0E22 /* ForceFeedback.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 00CFA89C106B4BA100758660 /* ForceFeedback.framework */; };
 		F3631C6424884ACF004F28EA /* SDL_locale.h in Headers */ = {isa = PBXBuildFile; fileRef = 566E26792462701100718109 /* SDL_locale.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		F3631C652488534E004F28EA /* SDL_locale.h in Headers */ = {isa = PBXBuildFile; fileRef = 566E26792462701100718109 /* SDL_locale.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		F376F6192559B29300CFC0BC /* OpenGLES.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F376F6182559B29300CFC0BC /* OpenGLES.framework */; };
+		F376F6192559B29300CFC0BC /* OpenGLES.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F376F6182559B29300CFC0BC /* OpenGLES.framework */; platformFilter = ios; };
 		F376F61B2559B2AF00CFC0BC /* UIKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F376F61A2559B2AF00CFC0BC /* UIKit.framework */; };
-		F376F6262559B30000CFC0BC /* UIKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F376F61A2559B2AF00CFC0BC /* UIKit.framework */; };
 		F376F6322559B31D00CFC0BC /* GameController.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F376F6312559B31D00CFC0BC /* GameController.framework */; };
 		F376F6332559B33D00CFC0BC /* AudioToolbox.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = A7381E931D8B69C300B177DD /* AudioToolbox.framework */; };
 		F376F63E2559B35200CFC0BC /* CoreMotion.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = A75FDABF23E28B8000529352 /* CoreMotion.framework */; };
@@ -3739,17 +3376,14 @@
 		F376F6552559B4E300CFC0BC /* SDL_hidapi.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A81423E2513F00DCD162 /* SDL_hidapi.c */; };
 		F376F6762559B4E500CFC0BC /* SDL_hidapi.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A81423E2513F00DCD162 /* SDL_hidapi.c */; };
 		F376F68D2559B4E900CFC0BC /* SDL_hidapi.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A81423E2513F00DCD162 /* SDL_hidapi.c */; };
-		F376F6CD2559B54500CFC0BC /* UIKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F376F6CC2559B54500CFC0BC /* UIKit.framework */; };
 		F376F6D92559B59600CFC0BC /* AudioToolbox.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F376F6D82559B59600CFC0BC /* AudioToolbox.framework */; };
 		F376F6DB2559B5A000CFC0BC /* AVFoundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F376F6DA2559B5A000CFC0BC /* AVFoundation.framework */; };
 		F376F6DD2559B5A900CFC0BC /* OpenGLES.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F376F6DC2559B5A900CFC0BC /* OpenGLES.framework */; };
 		F376F6DF2559B5BA00CFC0BC /* GameController.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F376F6DE2559B5BA00CFC0BC /* GameController.framework */; };
 		F376F6EC2559B5DA00CFC0BC /* UIKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F376F6CC2559B54500CFC0BC /* UIKit.framework */; };
 		F376F6F82559B5EC00CFC0BC /* CoreGraphics.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F376F6F72559B5EC00CFC0BC /* CoreGraphics.framework */; };
-		F376F70D2559B6A000CFC0BC /* hidapi.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = A75FDB4923E399AC00529352 /* hidapi.framework */; settings = {ATTRIBUTES = (Weak, ); }; };
 		F376F70E2559B6B800CFC0BC /* OpenGLES.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F376F6182559B29300CFC0BC /* OpenGLES.framework */; };
 		F376F70F2559B6BF00CFC0BC /* UIKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F376F61A2559B2AF00CFC0BC /* UIKit.framework */; };
-		F376F71A2559B70B00CFC0BC /* hidapi.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = A75FDB6E23E3A2C900529352 /* hidapi.framework */; settings = {ATTRIBUTES = (Weak, ); }; };
 		F376F71B2559B71C00CFC0BC /* AudioToolbox.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F376F6D82559B59600CFC0BC /* AudioToolbox.framework */; };
 		F376F71C2559B72900CFC0BC /* AVFoundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F376F6DA2559B5A000CFC0BC /* AVFoundation.framework */; };
 		F376F71D2559B73200CFC0BC /* UIKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F376F6CC2559B54500CFC0BC /* UIKit.framework */; };
@@ -3763,6 +3397,27 @@
 		F376F7332559B79B00CFC0BC /* GameController.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F376F6DE2559B5BA00CFC0BC /* GameController.framework */; };
 		F37DC5F325350EBC0002E6F7 /* CoreHaptics.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F37DC5F225350EBC0002E6F7 /* CoreHaptics.framework */; settings = {ATTRIBUTES = (Weak, ); }; };
 		F37DC5F525350ECC0002E6F7 /* CoreHaptics.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F37DC5F425350ECC0002E6F7 /* CoreHaptics.framework */; settings = {ATTRIBUTES = (Weak, ); }; };
+		F38233852738EB8600F7F527 /* SDL_hidapi.h in Headers */ = {isa = PBXBuildFile; fileRef = F38233842738EB8600F7F527 /* SDL_hidapi.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		F38233862738EB8600F7F527 /* SDL_hidapi.h in Headers */ = {isa = PBXBuildFile; fileRef = F38233842738EB8600F7F527 /* SDL_hidapi.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		F38233872738EB8600F7F527 /* SDL_hidapi.h in Headers */ = {isa = PBXBuildFile; fileRef = F38233842738EB8600F7F527 /* SDL_hidapi.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		F382338B2738EB8600F7F527 /* SDL_hidapi.h in Headers */ = {isa = PBXBuildFile; fileRef = F38233842738EB8600F7F527 /* SDL_hidapi.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		F382338C2738EB8600F7F527 /* SDL_hidapi.h in Headers */ = {isa = PBXBuildFile; fileRef = F38233842738EB8600F7F527 /* SDL_hidapi.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		F382338D2738EB8600F7F527 /* SDL_hidapi.h in Headers */ = {isa = PBXBuildFile; fileRef = F38233842738EB8600F7F527 /* SDL_hidapi.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		F382338E2738EBEC00F7F527 /* SDL_hidapi.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A81423E2513F00DCD162 /* SDL_hidapi.c */; };
+		F382338F2738EBEF00F7F527 /* SDL_hidapi.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A81423E2513F00DCD162 /* SDL_hidapi.c */; };
+		F38233902738EBF000F7F527 /* SDL_hidapi.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A81423E2513F00DCD162 /* SDL_hidapi.c */; };
+		F38233912738EBF100F7F527 /* SDL_hidapi.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A81423E2513F00DCD162 /* SDL_hidapi.c */; };
+		F38233922738EBF300F7F527 /* SDL_hidapi.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A81423E2513F00DCD162 /* SDL_hidapi.c */; };
+		F38233932738EBF300F7F527 /* SDL_hidapi.c in Sources */ = {isa = PBXBuildFile; fileRef = A7D8A81423E2513F00DCD162 /* SDL_hidapi.c */; };
+		F38233942738EC1400F7F527 /* hid.m in Sources */ = {isa = PBXBuildFile; fileRef = A75FDAA523E2792500529352 /* hid.m */; };
+		F38233952738EC1500F7F527 /* hid.m in Sources */ = {isa = PBXBuildFile; fileRef = A75FDAA523E2792500529352 /* hid.m */; };
+		F38233962738EC1600F7F527 /* hid.m in Sources */ = {isa = PBXBuildFile; fileRef = A75FDAA523E2792500529352 /* hid.m */; };
+		F38233972738EC1600F7F527 /* hid.m in Sources */ = {isa = PBXBuildFile; fileRef = A75FDAA523E2792500529352 /* hid.m */; };
+		F38233982738EC1800F7F527 /* hid.m in Sources */ = {isa = PBXBuildFile; fileRef = A75FDAA523E2792500529352 /* hid.m */; };
+		F38233992738EC1800F7F527 /* hid.m in Sources */ = {isa = PBXBuildFile; fileRef = A75FDAA523E2792500529352 /* hid.m */; };
+		F382339A2738ED5600F7F527 /* CoreBluetooth.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = A75FDAC323E28BA700529352 /* CoreBluetooth.framework */; };
+		F382339C2738ED6600F7F527 /* CoreBluetooth.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F382339B2738ED6600F7F527 /* CoreBluetooth.framework */; };
+		F382339D2738EE3F00F7F527 /* CoreBluetooth.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F382339B2738ED6600F7F527 /* CoreBluetooth.framework */; };
 		F3928194258603F1003191A7 /* SDL_misc.h in Headers */ = {isa = PBXBuildFile; fileRef = 5616CA4F252BB2BE005D5928 /* SDL_misc.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		F392819F25860422003191A7 /* SDL_misc.h in Headers */ = {isa = PBXBuildFile; fileRef = 5616CA4F252BB2BE005D5928 /* SDL_misc.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		F3942659253579B400B03694 /* CoreHaptics.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F37DC5F225350EBC0002E6F7 /* CoreHaptics.framework */; settings = {ATTRIBUTES = (Weak, ); }; };
@@ -3796,13 +3451,13 @@
 		F395C1A22569C68F00942BFF /* SDL_iokitjoystick.c in Sources */ = {isa = PBXBuildFile; fileRef = F395C1922569C68E00942BFF /* SDL_iokitjoystick.c */; };
 		F395C1A32569C68F00942BFF /* SDL_iokitjoystick.c in Sources */ = {isa = PBXBuildFile; fileRef = F395C1922569C68E00942BFF /* SDL_iokitjoystick.c */; };
 		F395C1A42569C68F00942BFF /* SDL_iokitjoystick.c in Sources */ = {isa = PBXBuildFile; fileRef = F395C1922569C68E00942BFF /* SDL_iokitjoystick.c */; };
-		F395C1B12569C6A000942BFF /* SDL_mfijoystick.m in Sources */ = {isa = PBXBuildFile; fileRef = F395C1AF2569C6A000942BFF /* SDL_mfijoystick.m */; };
+		F395C1B12569C6A000942BFF /* SDL_mfijoystick.m in Sources */ = {isa = PBXBuildFile; fileRef = F395C1AF2569C6A000942BFF /* SDL_mfijoystick.m */; settings = {COMPILER_FLAGS = "-fobjc-arc"; }; };
 		F395C1B22569C6A000942BFF /* SDL_mfijoystick.m in Sources */ = {isa = PBXBuildFile; fileRef = F395C1AF2569C6A000942BFF /* SDL_mfijoystick.m */; };
 		F395C1B32569C6A000942BFF /* SDL_mfijoystick.m in Sources */ = {isa = PBXBuildFile; fileRef = F395C1AF2569C6A000942BFF /* SDL_mfijoystick.m */; };
-		F395C1B42569C6A000942BFF /* SDL_mfijoystick.m in Sources */ = {isa = PBXBuildFile; fileRef = F395C1AF2569C6A000942BFF /* SDL_mfijoystick.m */; };
+		F395C1B42569C6A000942BFF /* SDL_mfijoystick.m in Sources */ = {isa = PBXBuildFile; fileRef = F395C1AF2569C6A000942BFF /* SDL_mfijoystick.m */; settings = {COMPILER_FLAGS = "-fobjc-arc"; }; };
 		F395C1B52569C6A000942BFF /* SDL_mfijoystick.m in Sources */ = {isa = PBXBuildFile; fileRef = F395C1AF2569C6A000942BFF /* SDL_mfijoystick.m */; };
 		F395C1B62569C6A000942BFF /* SDL_mfijoystick.m in Sources */ = {isa = PBXBuildFile; fileRef = F395C1AF2569C6A000942BFF /* SDL_mfijoystick.m */; };
-		F395C1B72569C6A000942BFF /* SDL_mfijoystick.m in Sources */ = {isa = PBXBuildFile; fileRef = F395C1AF2569C6A000942BFF /* SDL_mfijoystick.m */; };
+		F395C1B72569C6A000942BFF /* SDL_mfijoystick.m in Sources */ = {isa = PBXBuildFile; fileRef = F395C1AF2569C6A000942BFF /* SDL_mfijoystick.m */; settings = {COMPILER_FLAGS = "-fobjc-arc"; }; };
 		F395C1B82569C6A000942BFF /* SDL_mfijoystick.m in Sources */ = {isa = PBXBuildFile; fileRef = F395C1AF2569C6A000942BFF /* SDL_mfijoystick.m */; };
 		F395C1B92569C6A000942BFF /* SDL_mfijoystick.m in Sources */ = {isa = PBXBuildFile; fileRef = F395C1AF2569C6A000942BFF /* SDL_mfijoystick.m */; };
 		F395C1BA2569C6A000942BFF /* SDL_mfijoystick_c.h in Headers */ = {isa = PBXBuildFile; fileRef = F395C1B02569C6A000942BFF /* SDL_mfijoystick_c.h */; };
@@ -3814,6 +3469,15 @@
 		F395C1C02569C6A000942BFF /* SDL_mfijoystick_c.h in Headers */ = {isa = PBXBuildFile; fileRef = F395C1B02569C6A000942BFF /* SDL_mfijoystick_c.h */; };
 		F395C1C12569C6A000942BFF /* SDL_mfijoystick_c.h in Headers */ = {isa = PBXBuildFile; fileRef = F395C1B02569C6A000942BFF /* SDL_mfijoystick_c.h */; };
 		F395C1C22569C6A000942BFF /* SDL_mfijoystick_c.h in Headers */ = {isa = PBXBuildFile; fileRef = F395C1B02569C6A000942BFF /* SDL_mfijoystick_c.h */; };
+		F3984CD025BCC92900374F43 /* SDL_hidapi_stadia.c in Sources */ = {isa = PBXBuildFile; fileRef = F3984CCF25BCC92800374F43 /* SDL_hidapi_stadia.c */; };
+		F3984CD125BCC92900374F43 /* SDL_hidapi_stadia.c in Sources */ = {isa = PBXBuildFile; fileRef = F3984CCF25BCC92800374F43 /* SDL_hidapi_stadia.c */; };
+		F3984CD225BCC92900374F43 /* SDL_hidapi_stadia.c in Sources */ = {isa = PBXBuildFile; fileRef = F3984CCF25BCC92800374F43 /* SDL_hidapi_stadia.c */; };
+		F3984CD325BCC92900374F43 /* SDL_hidapi_stadia.c in Sources */ = {isa = PBXBuildFile; fileRef = F3984CCF25BCC92800374F43 /* SDL_hidapi_stadia.c */; };
+		F3984CD425BCC92900374F43 /* SDL_hidapi_stadia.c in Sources */ = {isa = PBXBuildFile; fileRef = F3984CCF25BCC92800374F43 /* SDL_hidapi_stadia.c */; };
+		F3984CD525BCC92900374F43 /* SDL_hidapi_stadia.c in Sources */ = {isa = PBXBuildFile; fileRef = F3984CCF25BCC92800374F43 /* SDL_hidapi_stadia.c */; };
+		F3984CD625BCC92900374F43 /* SDL_hidapi_stadia.c in Sources */ = {isa = PBXBuildFile; fileRef = F3984CCF25BCC92800374F43 /* SDL_hidapi_stadia.c */; };
+		F3984CD725BCC92900374F43 /* SDL_hidapi_stadia.c in Sources */ = {isa = PBXBuildFile; fileRef = F3984CCF25BCC92800374F43 /* SDL_hidapi_stadia.c */; };
+		F3984CD825BCC92900374F43 /* SDL_hidapi_stadia.c in Sources */ = {isa = PBXBuildFile; fileRef = F3984CCF25BCC92800374F43 /* SDL_hidapi_stadia.c */; };
 		F3A4909E2554D38600E92A8B /* SDL_hidapi_ps5.c in Sources */ = {isa = PBXBuildFile; fileRef = F3A4909D2554D38500E92A8B /* SDL_hidapi_ps5.c */; };
 		F3A4909F2554D38600E92A8B /* SDL_hidapi_ps5.c in Sources */ = {isa = PBXBuildFile; fileRef = F3A4909D2554D38500E92A8B /* SDL_hidapi_ps5.c */; };
 		F3A490A02554D38600E92A8B /* SDL_hidapi_ps5.c in Sources */ = {isa = PBXBuildFile; fileRef = F3A4909D2554D38500E92A8B /* SDL_hidapi_ps5.c */; };
@@ -3829,6 +3493,15 @@
 		F3ADAB912576F0B400A6B1D9 /* SDL_sysurl.m in Sources */ = {isa = PBXBuildFile; fileRef = F3ADAB8D2576F0B300A6B1D9 /* SDL_sysurl.m */; };
 		F3ADAB922576F0B400A6B1D9 /* SDL_sysurl.m in Sources */ = {isa = PBXBuildFile; fileRef = F3ADAB8D2576F0B300A6B1D9 /* SDL_sysurl.m */; };
 		F3ADAB932576F0B400A6B1D9 /* SDL_sysurl.m in Sources */ = {isa = PBXBuildFile; fileRef = F3ADAB8D2576F0B300A6B1D9 /* SDL_sysurl.m */; };
+		F3F07D5A269640160074468B /* SDL_hidapi_luna.c in Sources */ = {isa = PBXBuildFile; fileRef = F3F07D59269640160074468B /* SDL_hidapi_luna.c */; };
+		F3F07D5B269640160074468B /* SDL_hidapi_luna.c in Sources */ = {isa = PBXBuildFile; fileRef = F3F07D59269640160074468B /* SDL_hidapi_luna.c */; };
+		F3F07D5C269640160074468B /* SDL_hidapi_luna.c in Sources */ = {isa = PBXBuildFile; fileRef = F3F07D59269640160074468B /* SDL_hidapi_luna.c */; };
+		F3F07D5D269640160074468B /* SDL_hidapi_luna.c in Sources */ = {isa = PBXBuildFile; fileRef = F3F07D59269640160074468B /* SDL_hidapi_luna.c */; };
+		F3F07D5E269640160074468B /* SDL_hidapi_luna.c in Sources */ = {isa = PBXBuildFile; fileRef = F3F07D59269640160074468B /* SDL_hidapi_luna.c */; };
+		F3F07D5F269640160074468B /* SDL_hidapi_luna.c in Sources */ = {isa = PBXBuildFile; fileRef = F3F07D59269640160074468B /* SDL_hidapi_luna.c */; };
+		F3F07D60269640160074468B /* SDL_hidapi_luna.c in Sources */ = {isa = PBXBuildFile; fileRef = F3F07D59269640160074468B /* SDL_hidapi_luna.c */; };
+		F3F07D61269640160074468B /* SDL_hidapi_luna.c in Sources */ = {isa = PBXBuildFile; fileRef = F3F07D59269640160074468B /* SDL_hidapi_luna.c */; };
+		F3F07D62269640160074468B /* SDL_hidapi_luna.c in Sources */ = {isa = PBXBuildFile; fileRef = F3F07D59269640160074468B /* SDL_hidapi_luna.c */; };
 		FA24348B21D41FFB00B8918A /* SDL_metal.h in Headers */ = {isa = PBXBuildFile; fileRef = FA24348A21D41FFB00B8918A /* SDL_metal.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		FA73671D19A540EF004122E4 /* CoreVideo.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = FA73671C19A540EF004122E4 /* CoreVideo.framework */; };
 		FA73671F19A54144004122E4 /* CoreVideo.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = FA73671C19A540EF004122E4 /* CoreVideo.framework */; };
@@ -3842,13 +3515,6 @@
 			remoteGlobalIDString = BECDF5FE0761BA81005FE872;
 			remoteInfo = "Framework (Upgraded)";
 		};
-		F3190016240CA3BA00ED104F /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = A75FDB8023E4C74400529352;
-			remoteInfo = hidapi;
-		};
 /* End PBXContainerItemProxy section */
 
 /* Begin PBXCopyFilesBuildPhase section */
@@ -3858,7 +3524,6 @@
 			dstPath = "";
 			dstSubfolderSpec = 10;
 			files = (
-				A75FDB9B23E4CAEF00529352 /* hidapi.framework in Embed Frameworks */,
 			);
 			name = "Embed Frameworks";
 			runOnlyForDeploymentPostprocessing = 0;
@@ -3907,6 +3572,8 @@
 		5C2EF7001FC9EF0F003F5197 /* SDL_egl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_egl.h; sourceTree = "<group>"; };
 		75E09158241EA924004729E1 /* SDL_virtualjoystick.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_virtualjoystick.c; sourceTree = "<group>"; };
 		75E09159241EA924004729E1 /* SDL_virtualjoystick_c.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_virtualjoystick_c.h; sourceTree = "<group>"; };
+		A1626A3D2617006A003F1973 /* SDL_triangle.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_triangle.c; sourceTree = "<group>"; };
+		A1626A512617008C003F1973 /* SDL_triangle.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_triangle.h; sourceTree = "<group>"; };
 		A7381E931D8B69C300B177DD /* AudioToolbox.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = AudioToolbox.framework; path = System/Library/Frameworks/AudioToolbox.framework; sourceTree = SDKROOT; };
 		A7381E951D8B69D600B177DD /* CoreAudio.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreAudio.framework; path = System/Library/Frameworks/CoreAudio.framework; sourceTree = SDKROOT; };
 		A75FCEB323E25AB700529352 /* libSDL2.dylib */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.dylib"; includeInIndex = 0; path = libSDL2.dylib; sourceTree = BUILT_PRODUCTS_DIR; };
@@ -3919,11 +3586,7 @@
 		A75FDAC123E28B9600529352 /* CoreGraphics.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreGraphics.framework; path = System/Library/Frameworks/CoreGraphics.framework; sourceTree = SDKROOT; };
 		A75FDAC323E28BA700529352 /* CoreBluetooth.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreBluetooth.framework; path = System/Library/Frameworks/CoreBluetooth.framework; sourceTree = SDKROOT; };
 		A75FDAF523E35EC400529352 /* SDL_config_iphoneos.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_config_iphoneos.h; sourceTree = "<group>"; };
-		A75FDB4923E399AC00529352 /* hidapi.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = hidapi.framework; sourceTree = BUILT_PRODUCTS_DIR; };
-		A75FDB4C23E399AC00529352 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
 		A75FDB5723E39E6100529352 /* hidapi.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = hidapi.h; path = hidapi/hidapi.h; sourceTree = "<group>"; };
-		A75FDB6E23E3A2C900529352 /* hidapi.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = hidapi.framework; sourceTree = BUILT_PRODUCTS_DIR; };
-		A75FDB8C23E4C74400529352 /* hidapi.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = hidapi.framework; sourceTree = BUILT_PRODUCTS_DIR; };
 		A75FDB9223E4C8DB00529352 /* hid.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = hid.c; sourceTree = "<group>"; };
 		A75FDBA323E4CB6F00529352 /* LICENSE-bsd.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = "LICENSE-bsd.txt"; sourceTree = "<group>"; };
 		A75FDBA423E4CB6F00529352 /* AUTHORS.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = AUTHORS.txt; sourceTree = "<group>"; };
@@ -4042,7 +3705,6 @@
 		A7D8A68523E2513E00DCD162 /* SDL_cocoavideo.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = SDL_cocoavideo.m; sourceTree = "<group>"; };
 		A7D8A68623E2513E00DCD162 /* SDL_cocoametalview.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_cocoametalview.h; sourceTree = "<group>"; };
 		A7D8A68723E2513E00DCD162 /* SDL_cocoamouse.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = SDL_cocoamouse.m; sourceTree = "<group>"; };
-		A7D8A68823E2513E00DCD162 /* SDL_cocoamousetap.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_cocoamousetap.h; sourceTree = "<group>"; };
 		A7D8A68923E2513E00DCD162 /* SDL_cocoaevents.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = SDL_cocoaevents.m; sourceTree = "<group>"; };
 		A7D8A68A23E2513E00DCD162 /* SDL_cocoaclipboard.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_cocoaclipboard.h; sourceTree = "<group>"; };
 		A7D8A68B23E2513E00DCD162 /* SDL_cocoamessagebox.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = SDL_cocoamessagebox.m; sourceTree = "<group>"; };
@@ -4057,48 +3719,10 @@
 		A7D8A69423E2513E00DCD162 /* SDL_cocoamessagebox.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_cocoamessagebox.h; sourceTree = "<group>"; };
 		A7D8A69523E2513E00DCD162 /* SDL_cocoaclipboard.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = SDL_cocoaclipboard.m; sourceTree = "<group>"; };
 		A7D8A69623E2513E00DCD162 /* SDL_cocoaevents.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_cocoaevents.h; sourceTree = "<group>"; };
-		A7D8A69723E2513E00DCD162 /* SDL_cocoamousetap.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = SDL_cocoamousetap.m; sourceTree = "<group>"; };
 		A7D8A69823E2513E00DCD162 /* SDL_cocoamouse.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_cocoamouse.h; sourceTree = "<group>"; };
 		A7D8A69923E2513E00DCD162 /* SDL_cocoametalview.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = SDL_cocoametalview.m; sourceTree = "<group>"; };
 		A7D8A6B623E2513E00DCD162 /* SDL_egl.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_egl.c; sourceTree = "<group>"; };
 		A7D8A6FA23E2513E00DCD162 /* SDL_blit_1.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_blit_1.c; sourceTree = "<group>"; };
-		A7D8A6FC23E2513E00DCD162 /* SDL_x11touch.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_x11touch.h; sourceTree = "<group>"; };
-		A7D8A6FD23E2513E00DCD162 /* SDL_x11messagebox.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_x11messagebox.h; sourceTree = "<group>"; };
-		A7D8A6FE23E2513E00DCD162 /* SDL_x11modes.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_x11modes.c; sourceTree = "<group>"; };
-		A7D8A6FF23E2513E00DCD162 /* SDL_x11opengl.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_x11opengl.c; sourceTree = "<group>"; };
-		A7D8A70023E2513E00DCD162 /* SDL_x11vulkan.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_x11vulkan.c; sourceTree = "<group>"; };
-		A7D8A70123E2513E00DCD162 /* SDL_x11shape.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_x11shape.h; sourceTree = "<group>"; };
-		A7D8A70223E2513E00DCD162 /* SDL_x11xinput2.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_x11xinput2.c; sourceTree = "<group>"; };
-		A7D8A70323E2513E00DCD162 /* SDL_x11opengles.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_x11opengles.h; sourceTree = "<group>"; };
-		A7D8A70423E2513E00DCD162 /* SDL_x11mouse.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_x11mouse.c; sourceTree = "<group>"; };
-		A7D8A70523E2513E00DCD162 /* SDL_x11dyn.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_x11dyn.c; sourceTree = "<group>"; };
-		A7D8A70623E2513E00DCD162 /* SDL_x11framebuffer.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_x11framebuffer.c; sourceTree = "<group>"; };
-		A7D8A70723E2513E00DCD162 /* SDL_x11window.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_x11window.c; sourceTree = "<group>"; };
-		A7D8A70823E2513E00DCD162 /* SDL_x11video.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_x11video.c; sourceTree = "<group>"; };
-		A7D8A70923E2513E00DCD162 /* imKStoUCS.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = imKStoUCS.c; sourceTree = "<group>"; };
-		A7D8A70A23E2513E00DCD162 /* SDL_x11events.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_x11events.c; sourceTree = "<group>"; };
-		A7D8A70B23E2513E00DCD162 /* SDL_x11clipboard.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_x11clipboard.c; sourceTree = "<group>"; };
-		A7D8A70C23E2513E00DCD162 /* SDL_x11keyboard.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_x11keyboard.c; sourceTree = "<group>"; };
-		A7D8A70D23E2513E00DCD162 /* SDL_x11sym.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_x11sym.h; sourceTree = "<group>"; };
-		A7D8A70E23E2513E00DCD162 /* SDL_x11opengl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_x11opengl.h; sourceTree = "<group>"; };
-		A7D8A70F23E2513E00DCD162 /* SDL_x11modes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_x11modes.h; sourceTree = "<group>"; };
-		A7D8A71023E2513E00DCD162 /* SDL_x11messagebox.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_x11messagebox.c; sourceTree = "<group>"; };
-		A7D8A71123E2513E00DCD162 /* SDL_x11touch.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_x11touch.c; sourceTree = "<group>"; };
-		A7D8A71223E2513E00DCD162 /* edid-parse.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = "edid-parse.c"; sourceTree = "<group>"; };
-		A7D8A71323E2513E00DCD162 /* SDL_x11xinput2.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_x11xinput2.h; sourceTree = "<group>"; };
-		A7D8A71423E2513E00DCD162 /* edid.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = edid.h; sourceTree = "<group>"; };
-		A7D8A71523E2513E00DCD162 /* SDL_x11vulkan.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_x11vulkan.h; sourceTree = "<group>"; };
-		A7D8A71623E2513E00DCD162 /* SDL_x11shape.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_x11shape.c; sourceTree = "<group>"; };
-		A7D8A71723E2513E00DCD162 /* SDL_x11window.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_x11window.h; sourceTree = "<group>"; };
-		A7D8A71823E2513E00DCD162 /* SDL_x11framebuffer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_x11framebuffer.h; sourceTree = "<group>"; };
-		A7D8A71923E2513E00DCD162 /* SDL_x11dyn.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_x11dyn.h; sourceTree = "<group>"; };
-		A7D8A71A23E2513E00DCD162 /* SDL_x11mouse.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_x11mouse.h; sourceTree = "<group>"; };
-		A7D8A71B23E2513E00DCD162 /* SDL_x11opengles.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_x11opengles.c; sourceTree = "<group>"; };
-		A7D8A71C23E2513E00DCD162 /* SDL_x11keyboard.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_x11keyboard.h; sourceTree = "<group>"; };
-		A7D8A71D23E2513E00DCD162 /* SDL_x11clipboard.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_x11clipboard.h; sourceTree = "<group>"; };
-		A7D8A71E23E2513E00DCD162 /* SDL_x11events.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_x11events.h; sourceTree = "<group>"; };
-		A7D8A71F23E2513E00DCD162 /* imKStoUCS.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = imKStoUCS.h; sourceTree = "<group>"; };
-		A7D8A72023E2513E00DCD162 /* SDL_x11video.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_x11video.h; sourceTree = "<group>"; };
 		A7D8A72323E2513E00DCD162 /* gl2ext.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gl2ext.h; sourceTree = "<group>"; };
 		A7D8A72423E2513E00DCD162 /* gl2.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gl2.h; sourceTree = "<group>"; };
 		A7D8A72523E2513E00DCD162 /* gl2platform.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gl2platform.h; sourceTree = "<group>"; };
@@ -4369,14 +3993,18 @@
 		F376F7272559B77100CFC0BC /* CoreAudio.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreAudio.framework; path = Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS14.0.sdk/System/Library/Frameworks/CoreAudio.framework; sourceTree = DEVELOPER_DIR; };
 		F37DC5F225350EBC0002E6F7 /* CoreHaptics.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreHaptics.framework; path = System/Library/Frameworks/CoreHaptics.framework; sourceTree = SDKROOT; };
 		F37DC5F425350ECC0002E6F7 /* CoreHaptics.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreHaptics.framework; path = Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS14.0.sdk/System/Library/Frameworks/CoreHaptics.framework; sourceTree = DEVELOPER_DIR; };
+		F38233842738EB8600F7F527 /* SDL_hidapi.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_hidapi.h; sourceTree = "<group>"; };
+		F382339B2738ED6600F7F527 /* CoreBluetooth.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreBluetooth.framework; path = Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS15.0.sdk/System/Library/Frameworks/CoreBluetooth.framework; sourceTree = DEVELOPER_DIR; };
 		F3950CD7212BC88D00F51292 /* SDL_sensor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_sensor.h; sourceTree = "<group>"; };
 		F395BF6425633B2400942BFF /* SDL_crc32.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_crc32.c; sourceTree = "<group>"; };
 		F395C1912569C68E00942BFF /* SDL_iokitjoystick_c.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_iokitjoystick_c.h; sourceTree = "<group>"; };
 		F395C1922569C68E00942BFF /* SDL_iokitjoystick.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_iokitjoystick.c; sourceTree = "<group>"; };
 		F395C1AF2569C6A000942BFF /* SDL_mfijoystick.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = SDL_mfijoystick.m; sourceTree = "<group>"; };
 		F395C1B02569C6A000942BFF /* SDL_mfijoystick_c.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_mfijoystick_c.h; sourceTree = "<group>"; };
+		F3984CCF25BCC92800374F43 /* SDL_hidapi_stadia.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_hidapi_stadia.c; sourceTree = "<group>"; };
 		F3A4909D2554D38500E92A8B /* SDL_hidapi_ps5.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_hidapi_ps5.c; sourceTree = "<group>"; };
 		F3ADAB8D2576F0B300A6B1D9 /* SDL_sysurl.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = SDL_sysurl.m; sourceTree = "<group>"; };
+		F3F07D59269640160074468B /* SDL_hidapi_luna.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_hidapi_luna.c; sourceTree = "<group>"; };
 		F59C710300D5CB5801000001 /* ReadMe.txt */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = text; path = ReadMe.txt; sourceTree = "<group>"; };
 		F59C710600D5CB5801000001 /* SDL.info */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = text; path = SDL.info; sourceTree = "<group>"; };
 		F5A2EF3900C6A39A01000001 /* BUGS.txt */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = text; name = BUGS.txt; path = ../../BUGS.txt; sourceTree = SOURCE_ROOT; };
@@ -4389,7 +4017,6 @@
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				F376F70D2559B6A000CFC0BC /* hidapi.framework in Frameworks */,
 				A75FCEAE23E25AB700529352 /* AudioToolbox.framework in Frameworks */,
 				A75FDABA23E28A7A00529352 /* AVFoundation.framework in Frameworks */,
 				A75FCEA723E25AB700529352 /* CoreAudio.framework in Frameworks */,
@@ -4412,10 +4039,10 @@
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				F376F71A2559B70B00CFC0BC /* hidapi.framework in Frameworks */,
 				F376F71B2559B71C00CFC0BC /* AudioToolbox.framework in Frameworks */,
 				F376F71C2559B72900CFC0BC /* AVFoundation.framework in Frameworks */,
 				F376F7282559B77100CFC0BC /* CoreAudio.framework in Frameworks */,
+				F382339D2738EE3F00F7F527 /* CoreBluetooth.framework in Frameworks */,
 				F376F7262559B76800CFC0BC /* CoreFoundation.framework in Frameworks */,
 				F376F7242559B76100CFC0BC /* CoreGraphics.framework in Frameworks */,
 				F394265A253579D200B03694 /* CoreHaptics.framework in Frameworks */,
@@ -4428,33 +4055,6 @@
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
-		A75FDB4623E399AC00529352 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				A75FDB5523E39DAC00529352 /* CoreBluetooth.framework in Frameworks */,
-				F376F6262559B30000CFC0BC /* UIKit.framework in Frameworks */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		A75FDB6723E3A2C900529352 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				A75FDB6823E3A2C900529352 /* CoreBluetooth.framework in Frameworks */,
-				F376F6CD2559B54500CFC0BC /* UIKit.framework in Frameworks */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		A75FDB8523E4C74400529352 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				A75FDB9523E4C93600529352 /* CoreFoundation.framework in Frameworks */,
-				A75FDB9423E4C91300529352 /* IOKit.framework in Frameworks */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
 		A769B22E23E259AE00872273 /* Frameworks */ = {
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
@@ -4466,10 +4066,10 @@
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				A75FDB9D23E4CAFA00529352 /* hidapi.framework in Frameworks */,
 				F376F6332559B33D00CFC0BC /* AudioToolbox.framework in Frameworks */,
 				F376F6402559B38A00CFC0BC /* AVFoundation.framework in Frameworks */,
 				A7D88B4C23E2437C00DCD162 /* CoreAudio.framework in Frameworks */,
+				F382339A2738ED5600F7F527 /* CoreBluetooth.framework in Frameworks */,
 				A7D88B4D23E2437C00DCD162 /* CoreFoundation.framework in Frameworks */,
 				F376F63F2559B37300CFC0BC /* CoreGraphics.framework in Frameworks */,
 				F37DC5F325350EBC0002E6F7 /* CoreHaptics.framework in Frameworks */,
@@ -4488,10 +4088,10 @@
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				A75FDBA023E4CAFF00529352 /* hidapi.framework in Frameworks */,
 				F376F6DB2559B5A000CFC0BC /* AVFoundation.framework in Frameworks */,
 				F376F6D92559B59600CFC0BC /* AudioToolbox.framework in Frameworks */,
 				A7D88D0723E24BED00DCD162 /* CoreAudio.framework in Frameworks */,
+				F382339C2738ED6600F7F527 /* CoreBluetooth.framework in Frameworks */,
 				A7D88D0823E24BED00DCD162 /* CoreFoundation.framework in Frameworks */,
 				F376F6F82559B5EC00CFC0BC /* CoreGraphics.framework in Frameworks */,
 				F37DC5F525350ECC0002E6F7 /* CoreHaptics.framework in Frameworks */,
@@ -4520,7 +4120,6 @@
 				564624381FF821DA0074AC87 /* Metal.framework in Frameworks */,
 				564624361FF821C20074AC87 /* QuartzCore.framework in Frameworks */,
 				A7381E971D8B6A0300B177DD /* AudioToolbox.framework in Frameworks */,
-				A75FDB9A23E4CAEF00529352 /* hidapi.framework in Frameworks */,
 				00D0D0D810675E46004B05EF /* Carbon.framework in Frameworks */,
 				007317A40858DECD00B2BC32 /* Cocoa.framework in Frameworks */,
 				A7381E961D8B69D600B177DD /* CoreAudio.framework in Frameworks */,
@@ -4584,6 +4183,7 @@
 				A77E6EB3167AB0A90010E40B /* SDL_gamecontroller.h */,
 				AA7557D51595D4D800BBD41B /* SDL_gesture.h */,
 				AA7557D61595D4D800BBD41B /* SDL_haptic.h */,
+				F38233842738EB8600F7F527 /* SDL_hidapi.h */,
 				AA7557D71595D4D800BBD41B /* SDL_hints.h */,
 				AA7557D91595D4D800BBD41B /* SDL_joystick.h */,
 				AA7557DA1595D4D800BBD41B /* SDL_keyboard.h */,
@@ -4647,9 +4247,6 @@
 				A769B23D23E259AE00872273 /* libSDL2.a */,
 				A75FCEB323E25AB700529352 /* libSDL2.dylib */,
 				A75FD06C23E25AC700529352 /* libSDL2.dylib */,
-				A75FDB4923E399AC00529352 /* hidapi.framework */,
-				A75FDB6E23E3A2C900529352 /* hidapi.framework */,
-				A75FDB8C23E4C74400529352 /* hidapi.framework */,
 			);
 			name = Products;
 			sourceTree = "<group>";
@@ -4661,7 +4258,6 @@
 				F59C70FC00D5CB5801000001 /* pkg-support */,
 				0153844A006D81B07F000001 /* Public Headers */,
 				08FB77ACFE841707C02AAC07 /* Library Source */,
-				A75FDB4A23E399AC00529352 /* hidapi */,
 				034768DDFF38A45A11DB9C8B /* Products */,
 				BECDF66B0761BA81005FE872 /* Info-Framework.plist */,
 				564624341FF821B70074AC87 /* Frameworks */,
@@ -4736,6 +4332,7 @@
 		564624341FF821B70074AC87 /* Frameworks */ = {
 			isa = PBXGroup;
 			children = (
+				F382339B2738ED6600F7F527 /* CoreBluetooth.framework */,
 				F376F7272559B77100CFC0BC /* CoreAudio.framework */,
 				F376F7252559B76800CFC0BC /* CoreFoundation.framework */,
 				F376F7212559B74900CFC0BC /* Metal.framework */,
@@ -4806,14 +4403,6 @@
 			path = ios;
 			sourceTree = "<group>";
 		};
-		A75FDB4A23E399AC00529352 /* hidapi */ = {
-			isa = PBXGroup;
-			children = (
-				A75FDB4C23E399AC00529352 /* Info.plist */,
-			);
-			path = hidapi;
-			sourceTree = "<group>";
-		};
 		A75FDB9123E4C8B800529352 /* mac */ = {
 			isa = PBXGroup;
 			children = (
@@ -4952,7 +4541,6 @@
 				A7D8A72123E2513E00DCD162 /* khronos */,
 				A7D8A5EC23E2513D00DCD162 /* offscreen */,
 				A7D8A61823E2513D00DCD162 /* uikit */,
-				A7D8A6FB23E2513E00DCD162 /* x11 */,
 				A7D8A76C23E2513E00DCD162 /* yuv2rgb */,
 				A7D8A66223E2513E00DCD162 /* SDL_blit_0.c */,
 				A7D8A6FA23E2513E00DCD162 /* SDL_blit_1.c */,
@@ -5072,8 +4660,6 @@
 				A7D8A68123E2513E00DCD162 /* SDL_cocoamodes.m */,
 				A7D8A69823E2513E00DCD162 /* SDL_cocoamouse.h */,
 				A7D8A68723E2513E00DCD162 /* SDL_cocoamouse.m */,
-				A7D8A68823E2513E00DCD162 /* SDL_cocoamousetap.h */,
-				A7D8A69723E2513E00DCD162 /* SDL_cocoamousetap.m */,
 				A7D8A68D23E2513E00DCD162 /* SDL_cocoaopengl.h */,
 				A7D8A67F23E2513E00DCD162 /* SDL_cocoaopengl.m */,
 				A7D8A69023E2513E00DCD162 /* SDL_cocoaopengles.h */,
@@ -5090,50 +4676,6 @@
 			path = cocoa;
 			sourceTree = "<group>";
 		};
-		A7D8A6FB23E2513E00DCD162 /* x11 */ = {
-			isa = PBXGroup;
-			children = (
-				A7D8A71223E2513E00DCD162 /* edid-parse.c */,
-				A7D8A71423E2513E00DCD162 /* edid.h */,
-				A7D8A70923E2513E00DCD162 /* imKStoUCS.c */,
-				A7D8A71F23E2513E00DCD162 /* imKStoUCS.h */,
-				A7D8A70B23E2513E00DCD162 /* SDL_x11clipboard.c */,
-				A7D8A71D23E2513E00DCD162 /* SDL_x11clipboard.h */,
-				A7D8A70523E2513E00DCD162 /* SDL_x11dyn.c */,
-				A7D8A71923E2513E00DCD162 /* SDL_x11dyn.h */,
-				A7D8A70A23E2513E00DCD162 /* SDL_x11events.c */,
-				A7D8A71E23E2513E00DCD162 /* SDL_x11events.h */,
-				A7D8A70623E2513E00DCD162 /* SDL_x11framebuffer.c */,
-				A7D8A71823E2513E00DCD162 /* SDL_x11framebuffer.h */,
-				A7D8A70C23E2513E00DCD162 /* SDL_x11keyboard.c */,
-				A7D8A71C23E2513E00DCD162 /* SDL_x11keyboard.h */,
-				A7D8A71023E2513E00DCD162 /* SDL_x11messagebox.c */,
-				A7D8A6FD23E2513E00DCD162 /* SDL_x11messagebox.h */,
-				A7D8A6FE23E2513E00DCD162 /* SDL_x11modes.c */,
-				A7D8A70F23E2513E00DCD162 /* SDL_x11modes.h */,
-				A7D8A70423E2513E00DCD162 /* SDL_x11mouse.c */,
-				A7D8A71A23E2513E00DCD162 /* SDL_x11mouse.h */,
-				A7D8A6FF23E2513E00DCD162 /* SDL_x11opengl.c */,
-				A7D8A70E23E2513E00DCD162 /* SDL_x11opengl.h */,
-				A7D8A71B23E2513E00DCD162 /* SDL_x11opengles.c */,
-				A7D8A70323E2513E00DCD162 /* SDL_x11opengles.h */,
-				A7D8A71623E2513E00DCD162 /* SDL_x11shape.c */,
-				A7D8A70123E2513E00DCD162 /* SDL_x11shape.h */,
-				A7D8A70D23E2513E00DCD162 /* SDL_x11sym.h */,
-				A7D8A71123E2513E00DCD162 /* SDL_x11touch.c */,
-				A7D8A6FC23E2513E00DCD162 /* SDL_x11touch.h */,
-				A7D8A70823E2513E00DCD162 /* SDL_x11video.c */,
-				A7D8A72023E2513E00DCD162 /* SDL_x11video.h */,
-				A7D8A70023E2513E00DCD162 /* SDL_x11vulkan.c */,
-				A7D8A71523E2513E00DCD162 /* SDL_x11vulkan.h */,
-				A7D8A70723E2513E00DCD162 /* SDL_x11window.c */,
-				A7D8A71723E2513E00DCD162 /* SDL_x11window.h */,
-				A7D8A70223E2513E00DCD162 /* SDL_x11xinput2.c */,
-				A7D8A71323E2513E00DCD162 /* SDL_x11xinput2.h */,
-			);
-			path = x11;
-			sourceTree = "<group>";
-		};
 		A7D8A72123E2513E00DCD162 /* khronos */ = {
 			isa = PBXGroup;
 			children = (
@@ -5292,10 +4834,12 @@
 			isa = PBXGroup;
 			children = (
 				A7D8A7C923E2513E00DCD162 /* SDL_hidapi_gamecube.c */,
+				F3F07D59269640160074468B /* SDL_hidapi_luna.c */,
 				A7D8A7C323E2513E00DCD162 /* SDL_hidapi_ps4.c */,
 				F3A4909D2554D38500E92A8B /* SDL_hidapi_ps5.c */,
 				A75FDBC423EA380300529352 /* SDL_hidapi_rumble.c */,
 				A75FDBC323EA380300529352 /* SDL_hidapi_rumble.h */,
+				F3984CCF25BCC92800374F43 /* SDL_hidapi_stadia.c */,
 				A75FDAAC23E2795C00529352 /* SDL_hidapi_steam.c */,
 				A7D8A7C623E2513E00DCD162 /* SDL_hidapi_switch.c */,
 				A7D8A7C223E2513E00DCD162 /* SDL_hidapi_xbox360.c */,
@@ -5523,6 +5067,8 @@
 		A7D8A8EF23E2514000DCD162 /* software */ = {
 			isa = PBXGroup;
 			children = (
+				A1626A512617008C003F1973 /* SDL_triangle.h */,
+				A1626A3D2617006A003F1973 /* SDL_triangle.c */,
 				A7D8A8FD23E2514000DCD162 /* SDL_blendfillrect.c */,
 				A7D8A8F623E2514000DCD162 /* SDL_blendfillrect.h */,
 				A7D8A8FB23E2514000DCD162 /* SDL_blendline.c */,
@@ -5680,7 +5226,6 @@
 				A75FCD0723E25AB700529352 /* SDL_glfuncs.h in Headers */,
 				A75FCD0823E25AB700529352 /* SDL_atomic.h in Headers */,
 				A75FCD0923E25AB700529352 /* SDL_rect_c.h in Headers */,
-				A75FCD0A23E25AB700529352 /* SDL_x11xinput2.h in Headers */,
 				A75FCD0B23E25AB700529352 /* SDL_shaders_metal_osx.h in Headers */,
 				A75FCD0C23E25AB700529352 /* SDL_shaders_metal_ios.h in Headers */,
 				A75FCD0D23E25AB700529352 /* SDL_offscreenwindow.h in Headers */,
@@ -5696,19 +5241,16 @@
 				A75FCD1723E25AB700529352 /* SDL_clipboard.h in Headers */,
 				A75FCD1823E25AB700529352 /* SDL_dataqueue.h in Headers */,
 				A75FCD1923E25AB700529352 /* SDL_error_c.h in Headers */,
-				A75FCD1A23E25AB700529352 /* SDL_x11events.h in Headers */,
 				A75FCD1B23E25AB700529352 /* SDL_config.h in Headers */,
 				A75FCD1C23E25AB700529352 /* SDL_d3dmath.h in Headers */,
-				A75FCD1D23E25AB700529352 /* SDL_x11window.h in Headers */,
 				A75FCD1F23E25AB700529352 /* SDL_egl_c.h in Headers */,
 				A75FCD2023E25AB700529352 /* SDL_copying.h in Headers */,
 				A75FCD2123E25AB700529352 /* yuv_rgb.h in Headers */,
 				A75FCD2223E25AB700529352 /* SDL_dummyaudio.h in Headers */,
+				F382338C2738EB8600F7F527 /* SDL_hidapi.h in Headers */,
 				A75FCD2323E25AB700529352 /* SDL_uikitmessagebox.h in Headers */,
-				A75FCD2423E25AB700529352 /* SDL_x11messagebox.h in Headers */,
 				A75FCD2523E25AB700529352 /* SDL_thread_c.h in Headers */,
 				A75FCD2623E25AB700529352 /* SDL_cocoamessagebox.h in Headers */,
-				A75FCD2723E25AB700529352 /* SDL_x11shape.h in Headers */,
 				A75FCD2823E25AB700529352 /* SDL_cpuinfo.h in Headers */,
 				A75FCD2923E25AB700529352 /* SDL_endian.h in Headers */,
 				A75FCD2A23E25AB700529352 /* SDL_error.h in Headers */,
@@ -5717,7 +5259,6 @@
 				A75FCD2D23E25AB700529352 /* SDL_gamecontroller.h in Headers */,
 				A75FCD2E23E25AB700529352 /* SDL_hidapijoystick_c.h in Headers */,
 				A75FCD3023E25AB700529352 /* SDL_pixels_c.h in Headers */,
-				A75FCD3123E25AB700529352 /* SDL_x11modes.h in Headers */,
 				A75FCD3223E25AB700529352 /* SDL_joystick_c.h in Headers */,
 				F395C19A2569C68F00942BFF /* SDL_iokitjoystick_c.h in Headers */,
 				A75FCD3323E25AB700529352 /* vk_sdk_platform.h in Headers */,
@@ -5734,7 +5275,6 @@
 				A75FCD3C23E25AB700529352 /* SDL_hints.h in Headers */,
 				A75FCD3D23E25AB700529352 /* SDL_blit_slow.h in Headers */,
 				A75FCD3E23E25AB700529352 /* SDL_yuv_sw_c.h in Headers */,
-				A75FCD3F23E25AB700529352 /* SDL_x11opengl.h in Headers */,
 				A75FCD4023E25AB700529352 /* SDL_windowevents_c.h in Headers */,
 				A75FCD4123E25AB700529352 /* SDL_joystick.h in Headers */,
 				A75FCD4223E25AB700529352 /* SDL_cocoavideo.h in Headers */,
@@ -5745,17 +5285,13 @@
 				A75FCD4623E25AB700529352 /* SDL_shaders_gl.h in Headers */,
 				A75FCD4723E25AB700529352 /* SDL_systhread_c.h in Headers */,
 				A75FCD4823E25AB700529352 /* SDL_keycode.h in Headers */,
-				A75FCD4923E25AB700529352 /* SDL_x11keyboard.h in Headers */,
 				5616CA63252BB35F005D5928 /* SDL_sysurl.h in Headers */,
 				A75FCD4A23E25AB700529352 /* SDL_cocoakeyboard.h in Headers */,
 				A75FCD4B23E25AB700529352 /* SDL_uikitvulkan.h in Headers */,
-				A75FCD4C23E25AB700529352 /* SDL_x11framebuffer.h in Headers */,
-				A75FCD4D23E25AB700529352 /* SDL_x11video.h in Headers */,
 				A75FCD4E23E25AB700529352 /* vulkan.hpp in Headers */,
 				A75FCD4F23E25AB700529352 /* SDL_loadso.h in Headers */,
 				A75FCD5023E25AB700529352 /* gl2ext.h in Headers */,
 				A75FCD5123E25AB700529352 /* SDL_clipboardevents_c.h in Headers */,
-				A75FCD5223E25AB700529352 /* SDL_x11touch.h in Headers */,
 				A75FCD5323E25AB700529352 /* SDL_syshaptic_c.h in Headers */,
 				A75FCD5423E25AB700529352 /* SDL_hints_c.h in Headers */,
 				A75FCD5523E25AB700529352 /* SDL_audiodev_c.h in Headers */,
@@ -5779,9 +5315,8 @@
 				A75FCD6723E25AB700529352 /* SDL_wave.h in Headers */,
 				A75FCD6823E25AB700529352 /* SDL_cocoaopengl.h in Headers */,
 				A75FCD6923E25AB700529352 /* yuv_rgb_sse_func.h in Headers */,
-				A75FCD6A23E25AB700529352 /* imKStoUCS.h in Headers */,
 				A75FCD6B23E25AB700529352 /* SDL_offscreenevents_c.h in Headers */,
-				A75FCD6C23E25AB700529352 /* SDL_x11sym.h in Headers */,
+				A1626A592617008D003F1973 /* SDL_triangle.h in Headers */,
 				A75FCD6D23E25AB700529352 /* SDL_coreaudio.h in Headers */,
 				A75FCD6E23E25AB700529352 /* SDL_draw.h in Headers */,
 				A75FCD6F23E25AB700529352 /* SDL_drawline.h in Headers */,
@@ -5792,7 +5327,6 @@
 				A75FCD7423E25AB700529352 /* scancodes_xfree86.h in Headers */,
 				A75FCD7523E25AB700529352 /* SDL_syspower.h in Headers */,
 				A75FDAFA23E35ED600529352 /* SDL_config_iphoneos.h in Headers */,
-				A75FCD7623E25AB700529352 /* SDL_x11clipboard.h in Headers */,
 				A75FCD7723E25AB700529352 /* SDL_name.h in Headers */,
 				A75FCD7823E25AB700529352 /* eglext.h in Headers */,
 				A75FCD7923E25AB700529352 /* SDL_events_c.h in Headers */,
@@ -5810,14 +5344,12 @@
 				A75FCD8623E25AB700529352 /* SDL_sysjoystick.h in Headers */,
 				A75FCD8723E25AB700529352 /* SDL_steamcontroller.h in Headers */,
 				A75FCD8823E25AB700529352 /* scancodes_linux.h in Headers */,
-				A75FCD8923E25AB700529352 /* SDL_x11dyn.h in Headers */,
 				A75FCD8A23E25AB700529352 /* SDL_touch_c.h in Headers */,
 				A75FCD8B23E25AB700529352 /* SDL_gamecontrollerdb.h in Headers */,
 				A75FCD8C23E25AB700529352 /* SDL_cocoavulkan.h in Headers */,
 				A75FCD8D23E25AB700529352 /* gl2platform.h in Headers */,
 				A75FCD8E23E25AB700529352 /* SDL_pixels.h in Headers */,
 				A75FCD8F23E25AB700529352 /* vk_layer.h in Headers */,
-				A75FCD9023E25AB700529352 /* SDL_cocoamousetap.h in Headers */,
 				A75FCD9123E25AB700529352 /* vk_platform.h in Headers */,
 				A75FCD9223E25AB700529352 /* SDL_cocoametalview.h in Headers */,
 				A75FCD9323E25AB700529352 /* SDL_cocoaopengles.h in Headers */,
@@ -5831,7 +5363,6 @@
 				A75FCD9B23E25AB700529352 /* SDL_offscreenopengl.h in Headers */,
 				A75FCD9D23E25AB700529352 /* scancodes_darwin.h in Headers */,
 				A75FCD9E23E25AB700529352 /* controller_type.h in Headers */,
-				A75FCD9F23E25AB700529352 /* SDL_x11opengles.h in Headers */,
 				A75FCDA023E25AB700529352 /* SDL_uikitclipboard.h in Headers */,
 				A75FCDA123E25AB700529352 /* vulkan_xlib.h in Headers */,
 				A75FCDA223E25AB700529352 /* SDL_uikitwindow.h in Headers */,
@@ -5847,7 +5378,6 @@
 				75E0916A241EA924004729E1 /* SDL_virtualjoystick_c.h in Headers */,
 				A75FCDAC23E25AB700529352 /* SDL_RLEaccel_c.h in Headers */,
 				A75FCDAD23E25AB700529352 /* eglplatform.h in Headers */,
-				A75FCDAE23E25AB700529352 /* edid.h in Headers */,
 				A75FCDAF23E25AB700529352 /* SDL_revision.h in Headers */,
 				A75FCDB023E25AB700529352 /* SDL_systhread.h in Headers */,
 				A75FCDB123E25AB700529352 /* SDL_rwops.h in Headers */,
@@ -5900,10 +5430,8 @@
 				A75FCDE123E25AB700529352 /* SDL_sysvideo.h in Headers */,
 				A75FCDE223E25AB700529352 /* SDL_opengles2_gl2platform.h in Headers */,
 				A75FCDE323E25AB700529352 /* SDL_opengles2_gl2ext.h in Headers */,
-				A75FCDE423E25AB700529352 /* SDL_x11mouse.h in Headers */,
 				A75FCDE523E25AB700529352 /* SDL_dynapi_overrides.h in Headers */,
 				A75FCDE623E25AB700529352 /* SDL_cocoawindow.h in Headers */,
-				A75FCDE723E25AB700529352 /* SDL_x11vulkan.h in Headers */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -5923,7 +5451,6 @@
 				A75FCEC023E25AC700529352 /* SDL_glfuncs.h in Headers */,
 				A75FCEC123E25AC700529352 /* SDL_atomic.h in Headers */,
 				A75FCEC223E25AC700529352 /* SDL_rect_c.h in Headers */,
-				A75FCEC323E25AC700529352 /* SDL_x11xinput2.h in Headers */,
 				A75FCEC423E25AC700529352 /* SDL_shaders_metal_osx.h in Headers */,
 				A75FCEC523E25AC700529352 /* SDL_shaders_metal_ios.h in Headers */,
 				A75FCEC623E25AC700529352 /* SDL_offscreenwindow.h in Headers */,
@@ -5939,19 +5466,16 @@
 				A75FCED023E25AC700529352 /* SDL_clipboard.h in Headers */,
 				A75FCED123E25AC700529352 /* SDL_dataqueue.h in Headers */,
 				A75FCED223E25AC700529352 /* SDL_error_c.h in Headers */,
-				A75FCED323E25AC700529352 /* SDL_x11events.h in Headers */,
 				A75FCED423E25AC700529352 /* SDL_config.h in Headers */,
 				A75FCED523E25AC700529352 /* SDL_d3dmath.h in Headers */,
-				A75FCED623E25AC700529352 /* SDL_x11window.h in Headers */,
 				A75FCED823E25AC700529352 /* SDL_egl_c.h in Headers */,
 				A75FCED923E25AC700529352 /* SDL_copying.h in Headers */,
 				A75FCEDA23E25AC700529352 /* yuv_rgb.h in Headers */,
 				A75FCEDB23E25AC700529352 /* SDL_dummyaudio.h in Headers */,
+				F382338D2738EB8600F7F527 /* SDL_hidapi.h in Headers */,
 				A75FCEDC23E25AC700529352 /* SDL_uikitmessagebox.h in Headers */,
-				A75FCEDD23E25AC700529352 /* SDL_x11messagebox.h in Headers */,
 				A75FCEDE23E25AC700529352 /* SDL_thread_c.h in Headers */,
 				A75FCEDF23E25AC700529352 /* SDL_cocoamessagebox.h in Headers */,
-				A75FCEE023E25AC700529352 /* SDL_x11shape.h in Headers */,
 				A75FCEE123E25AC700529352 /* SDL_cpuinfo.h in Headers */,
 				A75FCEE223E25AC700529352 /* SDL_endian.h in Headers */,
 				A75FCEE323E25AC700529352 /* SDL_error.h in Headers */,
@@ -5960,7 +5484,6 @@
 				A75FCEE623E25AC700529352 /* SDL_gamecontroller.h in Headers */,
 				A75FCEE723E25AC700529352 /* SDL_hidapijoystick_c.h in Headers */,
 				A75FCEE923E25AC700529352 /* SDL_pixels_c.h in Headers */,
-				A75FCEEA23E25AC700529352 /* SDL_x11modes.h in Headers */,
 				A75FCEEB23E25AC700529352 /* SDL_joystick_c.h in Headers */,
 				F395C19B2569C68F00942BFF /* SDL_iokitjoystick_c.h in Headers */,
 				A75FCEEC23E25AC700529352 /* vk_sdk_platform.h in Headers */,
@@ -5977,7 +5500,6 @@
 				A75FCEF523E25AC700529352 /* SDL_hints.h in Headers */,
 				A75FCEF623E25AC700529352 /* SDL_blit_slow.h in Headers */,
 				A75FCEF723E25AC700529352 /* SDL_yuv_sw_c.h in Headers */,
-				A75FCEF823E25AC700529352 /* SDL_x11opengl.h in Headers */,
 				A75FCEF923E25AC700529352 /* SDL_windowevents_c.h in Headers */,
 				A75FCEFA23E25AC700529352 /* SDL_joystick.h in Headers */,
 				A75FCEFB23E25AC700529352 /* SDL_cocoavideo.h in Headers */,
@@ -5988,17 +5510,13 @@
 				A75FCEFF23E25AC700529352 /* SDL_shaders_gl.h in Headers */,
 				A75FCF0023E25AC700529352 /* SDL_systhread_c.h in Headers */,
 				A75FCF0123E25AC700529352 /* SDL_keycode.h in Headers */,
-				A75FCF0223E25AC700529352 /* SDL_x11keyboard.h in Headers */,
 				5616CA66252BB361005D5928 /* SDL_sysurl.h in Headers */,
 				A75FCF0323E25AC700529352 /* SDL_cocoakeyboard.h in Headers */,
 				A75FCF0423E25AC700529352 /* SDL_uikitvulkan.h in Headers */,
-				A75FCF0523E25AC700529352 /* SDL_x11framebuffer.h in Headers */,
-				A75FCF0623E25AC700529352 /* SDL_x11video.h in Headers */,
 				A75FCF0723E25AC700529352 /* vulkan.hpp in Headers */,
 				A75FCF0823E25AC700529352 /* SDL_loadso.h in Headers */,
 				A75FCF0923E25AC700529352 /* gl2ext.h in Headers */,
 				A75FCF0A23E25AC700529352 /* SDL_clipboardevents_c.h in Headers */,
-				A75FCF0B23E25AC700529352 /* SDL_x11touch.h in Headers */,
 				A75FCF0C23E25AC700529352 /* SDL_syshaptic_c.h in Headers */,
 				A75FCF0D23E25AC700529352 /* SDL_hints_c.h in Headers */,
 				A75FCF0E23E25AC700529352 /* SDL_audiodev_c.h in Headers */,
@@ -6022,9 +5540,8 @@
 				A75FCF2023E25AC700529352 /* SDL_wave.h in Headers */,
 				A75FCF2123E25AC700529352 /* SDL_cocoaopengl.h in Headers */,
 				A75FCF2223E25AC700529352 /* yuv_rgb_sse_func.h in Headers */,
-				A75FCF2323E25AC700529352 /* imKStoUCS.h in Headers */,
 				A75FCF2423E25AC700529352 /* SDL_offscreenevents_c.h in Headers */,
-				A75FCF2523E25AC700529352 /* SDL_x11sym.h in Headers */,
+				A1626A5A2617008D003F1973 /* SDL_triangle.h in Headers */,
 				A75FCF2623E25AC700529352 /* SDL_coreaudio.h in Headers */,
 				A75FCF2723E25AC700529352 /* SDL_draw.h in Headers */,
 				A75FCF2823E25AC700529352 /* SDL_drawline.h in Headers */,
@@ -6035,7 +5552,6 @@
 				A75FCF2D23E25AC700529352 /* scancodes_xfree86.h in Headers */,
 				A75FCF2E23E25AC700529352 /* SDL_syspower.h in Headers */,
 				A75FDAFB23E35ED700529352 /* SDL_config_iphoneos.h in Headers */,
-				A75FCF2F23E25AC700529352 /* SDL_x11clipboard.h in Headers */,
 				A75FCF3023E25AC700529352 /* SDL_name.h in Headers */,
 				A75FCF3123E25AC700529352 /* eglext.h in Headers */,
 				A75FCF3223E25AC700529352 /* SDL_events_c.h in Headers */,
@@ -6053,14 +5569,12 @@
 				A75FCF3F23E25AC700529352 /* SDL_sysjoystick.h in Headers */,
 				A75FCF4023E25AC700529352 /* SDL_steamcontroller.h in Headers */,
 				A75FCF4123E25AC700529352 /* scancodes_linux.h in Headers */,
-				A75FCF4223E25AC700529352 /* SDL_x11dyn.h in Headers */,
 				A75FCF4323E25AC700529352 /* SDL_touch_c.h in Headers */,
 				A75FCF4423E25AC700529352 /* SDL_gamecontrollerdb.h in Headers */,
 				A75FCF4523E25AC700529352 /* SDL_cocoavulkan.h in Headers */,
 				A75FCF4623E25AC700529352 /* gl2platform.h in Headers */,
 				A75FCF4723E25AC700529352 /* SDL_pixels.h in Headers */,
 				A75FCF4823E25AC700529352 /* vk_layer.h in Headers */,
-				A75FCF4923E25AC700529352 /* SDL_cocoamousetap.h in Headers */,
 				A75FCF4A23E25AC700529352 /* vk_platform.h in Headers */,
 				A75FCF4B23E25AC700529352 /* SDL_cocoametalview.h in Headers */,
 				A75FCF4C23E25AC700529352 /* SDL_cocoaopengles.h in Headers */,
@@ -6074,7 +5588,6 @@
 				A75FCF5423E25AC700529352 /* SDL_offscreenopengl.h in Headers */,
 				A75FCF5623E25AC700529352 /* scancodes_darwin.h in Headers */,
 				A75FCF5723E25AC700529352 /* controller_type.h in Headers */,
-				A75FCF5823E25AC700529352 /* SDL_x11opengles.h in Headers */,
 				A75FCF5923E25AC700529352 /* SDL_uikitclipboard.h in Headers */,
 				A75FCF5A23E25AC700529352 /* vulkan_xlib.h in Headers */,
 				A75FCF5B23E25AC700529352 /* SDL_uikitwindow.h in Headers */,
@@ -6090,7 +5603,6 @@
 				75E0916B241EA924004729E1 /* SDL_virtualjoystick_c.h in Headers */,
 				A75FCF6523E25AC700529352 /* SDL_RLEaccel_c.h in Headers */,
 				A75FCF6623E25AC700529352 /* eglplatform.h in Headers */,
-				A75FCF6723E25AC700529352 /* edid.h in Headers */,
 				A75FCF6823E25AC700529352 /* SDL_revision.h in Headers */,
 				A75FCF6923E25AC700529352 /* SDL_systhread.h in Headers */,
 				A75FCF6A23E25AC700529352 /* SDL_rwops.h in Headers */,
@@ -6143,34 +5655,8 @@
 				A75FCF9A23E25AC700529352 /* SDL_sysvideo.h in Headers */,
 				A75FCF9B23E25AC700529352 /* SDL_opengles2_gl2platform.h in Headers */,
 				A75FCF9C23E25AC700529352 /* SDL_opengles2_gl2ext.h in Headers */,
-				A75FCF9D23E25AC700529352 /* SDL_x11mouse.h in Headers */,
 				A75FCF9E23E25AC700529352 /* SDL_dynapi_overrides.h in Headers */,
 				A75FCF9F23E25AC700529352 /* SDL_cocoawindow.h in Headers */,
-				A75FCFA023E25AC700529352 /* SDL_x11vulkan.h in Headers */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		A75FDB4423E399AC00529352 /* Headers */ = {
-			isa = PBXHeadersBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				A75FDB6123E39E6100529352 /* hidapi.h in Headers */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		A75FDB6323E3A2C900529352 /* Headers */ = {
-			isa = PBXHeadersBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				A75FDB6423E3A2C900529352 /* hidapi.h in Headers */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		A75FDB8123E4C74400529352 /* Headers */ = {
-			isa = PBXHeadersBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				A75FDB8223E4C74400529352 /* hidapi.h in Headers */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -6184,7 +5670,6 @@
 				A769B08D23E259AE00872273 /* SDL_shape_internals.h in Headers */,
 				A769B08E23E259AE00872273 /* SDL_glfuncs.h in Headers */,
 				A769B09023E259AE00872273 /* SDL_rect_c.h in Headers */,
-				A769B09123E259AE00872273 /* SDL_x11xinput2.h in Headers */,
 				A769B09223E259AE00872273 /* SDL_shaders_metal_osx.h in Headers */,
 				A769B09323E259AE00872273 /* SDL_shaders_metal_ios.h in Headers */,
 				A769B09423E259AE00872273 /* SDL_offscreenwindow.h in Headers */,
@@ -6196,21 +5681,16 @@
 				A769B09D23E259AE00872273 /* SDL_haptic_c.h in Headers */,
 				A769B09F23E259AE00872273 /* SDL_dataqueue.h in Headers */,
 				A769B0A023E259AE00872273 /* SDL_error_c.h in Headers */,
-				A769B0A123E259AE00872273 /* SDL_x11events.h in Headers */,
 				A769B0A323E259AE00872273 /* SDL_d3dmath.h in Headers */,
-				A769B0A423E259AE00872273 /* SDL_x11window.h in Headers */,
 				A769B0A623E259AE00872273 /* SDL_egl_c.h in Headers */,
 				A769B0A823E259AE00872273 /* yuv_rgb.h in Headers */,
 				A769B0A923E259AE00872273 /* SDL_dummyaudio.h in Headers */,
 				A769B0AA23E259AE00872273 /* SDL_uikitmessagebox.h in Headers */,
-				A769B0AB23E259AE00872273 /* SDL_x11messagebox.h in Headers */,
 				A769B0AC23E259AE00872273 /* SDL_thread_c.h in Headers */,
 				A769B0AD23E259AE00872273 /* SDL_cocoamessagebox.h in Headers */,
-				A769B0AE23E259AE00872273 /* SDL_x11shape.h in Headers */,
 				A769B0B323E259AE00872273 /* SDL_blendfillrect.h in Headers */,
 				A769B0B523E259AE00872273 /* SDL_hidapijoystick_c.h in Headers */,
 				A769B0B623E259AE00872273 /* SDL_pixels_c.h in Headers */,
-				A769B0B723E259AE00872273 /* SDL_x11modes.h in Headers */,
 				A769B0B823E259AE00872273 /* SDL_joystick_c.h in Headers */,
 				F395C1982569C68F00942BFF /* SDL_iokitjoystick_c.h in Headers */,
 				A769B0B923E259AE00872273 /* vk_sdk_platform.h in Headers */,
@@ -6224,7 +5704,6 @@
 				A769B0C123E259AE00872273 /* SDL_cocoamouse.h in Headers */,
 				A769B0C323E259AE00872273 /* SDL_blit_slow.h in Headers */,
 				A769B0C423E259AE00872273 /* SDL_yuv_sw_c.h in Headers */,
-				A769B0C523E259AE00872273 /* SDL_x11opengl.h in Headers */,
 				A769B0C623E259AE00872273 /* SDL_windowevents_c.h in Headers */,
 				A769B0C823E259AE00872273 /* SDL_cocoavideo.h in Headers */,
 				5605721C2473688D00B46B66 /* SDL_syslocale.h in Headers */,
@@ -6232,16 +5711,12 @@
 				A769B0CB23E259AE00872273 /* SDL_gesture_c.h in Headers */,
 				A769B0CC23E259AE00872273 /* SDL_shaders_gl.h in Headers */,
 				A769B0CD23E259AE00872273 /* SDL_systhread_c.h in Headers */,
-				A769B0CF23E259AE00872273 /* SDL_x11keyboard.h in Headers */,
 				A769B0D023E259AE00872273 /* SDL_cocoakeyboard.h in Headers */,
 				5616CA5D252BB35E005D5928 /* SDL_sysurl.h in Headers */,
 				A769B0D123E259AE00872273 /* SDL_uikitvulkan.h in Headers */,
-				A769B0D223E259AE00872273 /* SDL_x11framebuffer.h in Headers */,
-				A769B0D323E259AE00872273 /* SDL_x11video.h in Headers */,
 				A769B0D423E259AE00872273 /* vulkan.hpp in Headers */,
 				A769B0D623E259AE00872273 /* gl2ext.h in Headers */,
 				A769B0D723E259AE00872273 /* SDL_clipboardevents_c.h in Headers */,
-				A769B0D823E259AE00872273 /* SDL_x11touch.h in Headers */,
 				A769B0D923E259AE00872273 /* SDL_syshaptic_c.h in Headers */,
 				A769B0DA23E259AE00872273 /* SDL_hints_c.h in Headers */,
 				A769B0DB23E259AE00872273 /* SDL_audiodev_c.h in Headers */,
@@ -6262,10 +5737,9 @@
 				A769B0ED23E259AE00872273 /* SDL_drawpoint.h in Headers */,
 				A769B0EF23E259AE00872273 /* SDL_wave.h in Headers */,
 				A769B0F023E259AE00872273 /* SDL_cocoaopengl.h in Headers */,
+				A1626A572617008D003F1973 /* SDL_triangle.h in Headers */,
 				A769B0F123E259AE00872273 /* yuv_rgb_sse_func.h in Headers */,
-				A769B0F223E259AE00872273 /* imKStoUCS.h in Headers */,
 				A769B0F323E259AE00872273 /* SDL_offscreenevents_c.h in Headers */,
-				A769B0F423E259AE00872273 /* SDL_x11sym.h in Headers */,
 				A769B0F523E259AE00872273 /* SDL_coreaudio.h in Headers */,
 				A769B0F623E259AE00872273 /* SDL_draw.h in Headers */,
 				A769B0F723E259AE00872273 /* SDL_drawline.h in Headers */,
@@ -6273,7 +5747,6 @@
 				A769B0FC23E259AE00872273 /* scancodes_xfree86.h in Headers */,
 				A769B0FD23E259AE00872273 /* SDL_syspower.h in Headers */,
 				A75FDAF923E35ED500529352 /* SDL_config_iphoneos.h in Headers */,
-				A769B0FE23E259AE00872273 /* SDL_x11clipboard.h in Headers */,
 				A769B10023E259AE00872273 /* eglext.h in Headers */,
 				A769B10123E259AE00872273 /* SDL_events_c.h in Headers */,
 				A769B10223E259AE00872273 /* math_private.h in Headers */,
@@ -6286,13 +5759,11 @@
 				A769B10C23E259AE00872273 /* SDL_nullevents_c.h in Headers */,
 				A769B10D23E259AE00872273 /* SDL_sysjoystick.h in Headers */,
 				A769B10E23E259AE00872273 /* scancodes_linux.h in Headers */,
-				A769B10F23E259AE00872273 /* SDL_x11dyn.h in Headers */,
 				A769B11023E259AE00872273 /* SDL_touch_c.h in Headers */,
 				A769B11123E259AE00872273 /* SDL_gamecontrollerdb.h in Headers */,
 				A769B11223E259AE00872273 /* SDL_cocoavulkan.h in Headers */,
 				A769B11323E259AE00872273 /* gl2platform.h in Headers */,
 				A769B11523E259AE00872273 /* vk_layer.h in Headers */,
-				A769B11723E259AE00872273 /* SDL_cocoamousetap.h in Headers */,
 				A769B11823E259AE00872273 /* vk_platform.h in Headers */,
 				A769B11A23E259AE00872273 /* SDL_cocoametalview.h in Headers */,
 				A769B11B23E259AE00872273 /* SDL_cocoaopengles.h in Headers */,
@@ -6304,7 +5775,6 @@
 				A769B12323E259AE00872273 /* SDL_offscreenopengl.h in Headers */,
 				A769B12523E259AE00872273 /* scancodes_darwin.h in Headers */,
 				A769B12623E259AE00872273 /* controller_type.h in Headers */,
-				A769B12723E259AE00872273 /* SDL_x11opengles.h in Headers */,
 				A769B12823E259AE00872273 /* SDL_uikitclipboard.h in Headers */,
 				A769B12923E259AE00872273 /* vulkan_xlib.h in Headers */,
 				A769B12A23E259AE00872273 /* SDL_uikitwindow.h in Headers */,
@@ -6317,7 +5787,6 @@
 				A769B13423E259AE00872273 /* SDL_RLEaccel_c.h in Headers */,
 				75E09168241EA924004729E1 /* SDL_virtualjoystick_c.h in Headers */,
 				A769B13523E259AE00872273 /* eglplatform.h in Headers */,
-				A769B13623E259AE00872273 /* edid.h in Headers */,
 				A769B13823E259AE00872273 /* SDL_systhread.h in Headers */,
 				A769B13B23E259AE00872273 /* SDL_cocoaclipboard.h in Headers */,
 				A769B13C23E259AE00872273 /* SDL_cocoamodes.h in Headers */,
@@ -6351,10 +5820,8 @@
 				A769B16123E259AE00872273 /* usb_ids.h in Headers */,
 				A769B16323E259AE00872273 /* SDL_gles2funcs.h in Headers */,
 				A769B16923E259AE00872273 /* SDL_sysvideo.h in Headers */,
-				A769B16C23E259AE00872273 /* SDL_x11mouse.h in Headers */,
 				A769B16D23E259AE00872273 /* SDL_dynapi_overrides.h in Headers */,
 				A769B16E23E259AE00872273 /* SDL_cocoawindow.h in Headers */,
-				A769B16F23E259AE00872273 /* SDL_x11vulkan.h in Headers */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -6388,7 +5855,6 @@
 				A7D8AEB323E2514100DCD162 /* SDL_cocoametalview.h in Headers */,
 				A7D8AEF523E2514100DCD162 /* SDL_cocoamodes.h in Headers */,
 				A7D8AF1F23E2514100DCD162 /* SDL_cocoamouse.h in Headers */,
-				A7D8AEBF23E2514100DCD162 /* SDL_cocoamousetap.h in Headers */,
 				A7D8AEDD23E2514100DCD162 /* SDL_cocoaopengl.h in Headers */,
 				A7D8AEEF23E2514100DCD162 /* SDL_cocoaopengles.h in Headers */,
 				A7D8AE8323E2514100DCD162 /* SDL_cocoashape.h in Headers */,
@@ -6452,6 +5918,7 @@
 				F3928194258603F1003191A7 /* SDL_misc.h in Headers */,
 				A7D88A3A23E2437C00DCD162 /* SDL_mouse.h in Headers */,
 				A7D8BB1C23E2514500DCD162 /* SDL_mouse_c.h in Headers */,
+				F38233862738EB8600F7F527 /* SDL_hidapi.h in Headers */,
 				A7D88A3B23E2437C00DCD162 /* SDL_mutex.h in Headers */,
 				A7D88A3C23E2437C00DCD162 /* SDL_name.h in Headers */,
 				A7D8ABFE23E2514100DCD162 /* SDL_nullevents_c.h in Headers */,
@@ -6540,23 +6007,6 @@
 				A7D8AD1E23E2514100DCD162 /* SDL_vulkan_internal.h in Headers */,
 				A7D8B86D23E2514400DCD162 /* SDL_wave.h in Headers */,
 				A7D8BBAC23E2514500DCD162 /* SDL_windowevents_c.h in Headers */,
-				A7D8B20D23E2514200DCD162 /* SDL_x11clipboard.h in Headers */,
-				A7D8B1F523E2514200DCD162 /* SDL_x11dyn.h in Headers */,
-				A7D8B21323E2514200DCD162 /* SDL_x11events.h in Headers */,
-				A7D8B1EF23E2514200DCD162 /* SDL_x11framebuffer.h in Headers */,
-				A7D8B20723E2514200DCD162 /* SDL_x11keyboard.h in Headers */,
-				A7D8B14D23E2514200DCD162 /* SDL_x11messagebox.h in Headers */,
-				A7D8B1B923E2514200DCD162 /* SDL_x11modes.h in Headers */,
-				A7D8B1FB23E2514200DCD162 /* SDL_x11mouse.h in Headers */,
-				A7D8B1B323E2514200DCD162 /* SDL_x11opengl.h in Headers */,
-				A7D8B17123E2514200DCD162 /* SDL_x11opengles.h in Headers */,
-				A7D8B16523E2514200DCD162 /* SDL_x11shape.h in Headers */,
-				A7D8B1AD23E2514200DCD162 /* SDL_x11sym.h in Headers */,
-				A7D8B14723E2514200DCD162 /* SDL_x11touch.h in Headers */,
-				A7D8B21F23E2514200DCD162 /* SDL_x11video.h in Headers */,
-				A7D8B1DD23E2514200DCD162 /* SDL_x11vulkan.h in Headers */,
-				A7D8B1E923E2514200DCD162 /* SDL_x11window.h in Headers */,
-				A7D8B1D123E2514200DCD162 /* SDL_x11xinput2.h in Headers */,
 				A7D8B3B123E2514200DCD162 /* SDL_yuv_c.h in Headers */,
 				A7D8B9CC23E2514400DCD162 /* SDL_yuv_sw_c.h in Headers */,
 				A7D88A1623E2437C00DCD162 /* begin_code.h in Headers */,
@@ -6564,7 +6014,6 @@
 				A7D88A1823E2437C00DCD162 /* close_code.h in Headers */,
 				A7D8B5B823E2514300DCD162 /* controller_type.h in Headers */,
 				A7D8BB4C23E2514500DCD162 /* default_cursor.h in Headers */,
-				A7D8B1D723E2514200DCD162 /* edid.h in Headers */,
 				A7D8B23D23E2514200DCD162 /* egl.h in Headers */,
 				A7D8B24323E2514200DCD162 /* eglext.h in Headers */,
 				A7D8B24923E2514200DCD162 /* eglplatform.h in Headers */,
@@ -6572,7 +6021,6 @@
 				A7D8B22523E2514200DCD162 /* gl2ext.h in Headers */,
 				A7D8B23123E2514200DCD162 /* gl2platform.h in Headers */,
 				A75FDB5923E39E6100529352 /* hidapi.h in Headers */,
-				A7D8B21923E2514200DCD162 /* imKStoUCS.h in Headers */,
 				A7D8ACA023E2514100DCD162 /* keyinfotable.h in Headers */,
 				A7D8B23723E2514200DCD162 /* khrplatform.h in Headers */,
 				A7D8BB0423E2514500DCD162 /* math_libm.h in Headers */,
@@ -6582,6 +6030,7 @@
 				A7D8BB2223E2514500DCD162 /* scancodes_windows.h in Headers */,
 				A7D8BBA023E2514500DCD162 /* scancodes_xfree86.h in Headers */,
 				A7D8B57023E2514300DCD162 /* usb_ids.h in Headers */,
+				A1626A532617008D003F1973 /* SDL_triangle.h in Headers */,
 				A7D8B25523E2514200DCD162 /* vk_icd.h in Headers */,
 				A7D8B24F23E2514200DCD162 /* vk_layer.h in Headers */,
 				A7D8B26723E2514200DCD162 /* vk_platform.h in Headers */,
@@ -6636,7 +6085,6 @@
 				A7D8AEB423E2514100DCD162 /* SDL_cocoametalview.h in Headers */,
 				A7D8AEF623E2514100DCD162 /* SDL_cocoamodes.h in Headers */,
 				A7D8AF2023E2514100DCD162 /* SDL_cocoamouse.h in Headers */,
-				A7D8AEC023E2514100DCD162 /* SDL_cocoamousetap.h in Headers */,
 				A7D8AEDE23E2514100DCD162 /* SDL_cocoaopengl.h in Headers */,
 				A7D8AEF023E2514100DCD162 /* SDL_cocoaopengles.h in Headers */,
 				A7D8AE8423E2514100DCD162 /* SDL_cocoashape.h in Headers */,
@@ -6700,6 +6148,7 @@
 				F392819F25860422003191A7 /* SDL_misc.h in Headers */,
 				A7D88BF323E24BED00DCD162 /* SDL_mouse.h in Headers */,
 				A7D8BB1D23E2514500DCD162 /* SDL_mouse_c.h in Headers */,
+				F38233872738EB8600F7F527 /* SDL_hidapi.h in Headers */,
 				A7D88BF423E24BED00DCD162 /* SDL_mutex.h in Headers */,
 				A7D88BF523E24BED00DCD162 /* SDL_name.h in Headers */,
 				A7D8ABFF23E2514100DCD162 /* SDL_nullevents_c.h in Headers */,
@@ -6788,23 +6237,6 @@
 				A7D8AD1F23E2514100DCD162 /* SDL_vulkan_internal.h in Headers */,
 				A7D8B86E23E2514400DCD162 /* SDL_wave.h in Headers */,
 				A7D8BBAD23E2514500DCD162 /* SDL_windowevents_c.h in Headers */,
-				A7D8B20E23E2514200DCD162 /* SDL_x11clipboard.h in Headers */,
-				A7D8B1F623E2514200DCD162 /* SDL_x11dyn.h in Headers */,
-				A7D8B21423E2514200DCD162 /* SDL_x11events.h in Headers */,
-				A7D8B1F023E2514200DCD162 /* SDL_x11framebuffer.h in Headers */,
-				A7D8B20823E2514200DCD162 /* SDL_x11keyboard.h in Headers */,
-				A7D8B14E23E2514200DCD162 /* SDL_x11messagebox.h in Headers */,
-				A7D8B1BA23E2514200DCD162 /* SDL_x11modes.h in Headers */,
-				A7D8B1FC23E2514200DCD162 /* SDL_x11mouse.h in Headers */,
-				A7D8B1B423E2514200DCD162 /* SDL_x11opengl.h in Headers */,
-				A7D8B17223E2514200DCD162 /* SDL_x11opengles.h in Headers */,
-				A7D8B16623E2514200DCD162 /* SDL_x11shape.h in Headers */,
-				A7D8B1AE23E2514200DCD162 /* SDL_x11sym.h in Headers */,
-				A7D8B14823E2514200DCD162 /* SDL_x11touch.h in Headers */,
-				A7D8B22023E2514200DCD162 /* SDL_x11video.h in Headers */,
-				A7D8B1DE23E2514200DCD162 /* SDL_x11vulkan.h in Headers */,
-				A7D8B1EA23E2514200DCD162 /* SDL_x11window.h in Headers */,
-				A7D8B1D223E2514200DCD162 /* SDL_x11xinput2.h in Headers */,
 				A7D8B3B223E2514200DCD162 /* SDL_yuv_c.h in Headers */,
 				A7D8B9CD23E2514400DCD162 /* SDL_yuv_sw_c.h in Headers */,
 				A7D88BCC23E24BED00DCD162 /* begin_code.h in Headers */,
@@ -6812,7 +6244,6 @@
 				A7D88BCE23E24BED00DCD162 /* close_code.h in Headers */,
 				A7D8B5B923E2514300DCD162 /* controller_type.h in Headers */,
 				A7D8BB4D23E2514500DCD162 /* default_cursor.h in Headers */,
-				A7D8B1D823E2514200DCD162 /* edid.h in Headers */,
 				A7D8B23E23E2514200DCD162 /* egl.h in Headers */,
 				A7D8B24423E2514200DCD162 /* eglext.h in Headers */,
 				A7D8B24A23E2514200DCD162 /* eglplatform.h in Headers */,
@@ -6820,7 +6251,6 @@
 				A7D8B22623E2514200DCD162 /* gl2ext.h in Headers */,
 				A7D8B23223E2514200DCD162 /* gl2platform.h in Headers */,
 				A75FDB5A23E39E6100529352 /* hidapi.h in Headers */,
-				A7D8B21A23E2514200DCD162 /* imKStoUCS.h in Headers */,
 				A7D8ACA123E2514100DCD162 /* keyinfotable.h in Headers */,
 				A7D8B23823E2514200DCD162 /* khrplatform.h in Headers */,
 				A7D8BB0523E2514500DCD162 /* math_libm.h in Headers */,
@@ -6830,6 +6260,7 @@
 				A7D8BB2323E2514500DCD162 /* scancodes_windows.h in Headers */,
 				A7D8BBA123E2514500DCD162 /* scancodes_xfree86.h in Headers */,
 				A7D8B57123E2514300DCD162 /* usb_ids.h in Headers */,
+				A1626A542617008D003F1973 /* SDL_triangle.h in Headers */,
 				A7D8B25623E2514200DCD162 /* vk_icd.h in Headers */,
 				A7D8B25023E2514200DCD162 /* vk_layer.h in Headers */,
 				A7D8B26823E2514200DCD162 /* vk_platform.h in Headers */,
@@ -6864,7 +6295,6 @@
 				A7D8AC0D23E2514100DCD162 /* SDL_shape_internals.h in Headers */,
 				A7D8BA7D23E2514400DCD162 /* SDL_glfuncs.h in Headers */,
 				A7D8AC0723E2514100DCD162 /* SDL_rect_c.h in Headers */,
-				A7D8B1D423E2514200DCD162 /* SDL_x11xinput2.h in Headers */,
 				A7D8B99F23E2514400DCD162 /* SDL_shaders_metal_osx.h in Headers */,
 				A7D8B99023E2514400DCD162 /* SDL_shaders_metal_ios.h in Headers */,
 				A7D8AB8923E2514100DCD162 /* SDL_offscreenwindow.h in Headers */,
@@ -6876,21 +6306,16 @@
 				A7D8AAC023E2514100DCD162 /* SDL_haptic_c.h in Headers */,
 				A7D8A94923E2514000DCD162 /* SDL_dataqueue.h in Headers */,
 				A7D8A96123E2514000DCD162 /* SDL_error_c.h in Headers */,
-				A7D8B21623E2514200DCD162 /* SDL_x11events.h in Headers */,
 				A7D8B98423E2514400DCD162 /* SDL_d3dmath.h in Headers */,
-				A7D8B1EC23E2514200DCD162 /* SDL_x11window.h in Headers */,
 				A7D8ABDD23E2514100DCD162 /* SDL_egl_c.h in Headers */,
 				A7D8B3D823E2514300DCD162 /* yuv_rgb.h in Headers */,
 				A7D8B79823E2514400DCD162 /* SDL_dummyaudio.h in Headers */,
 				A7D8AC9723E2514100DCD162 /* SDL_uikitmessagebox.h in Headers */,
-				A7D8B15023E2514200DCD162 /* SDL_x11messagebox.h in Headers */,
 				A7D8B3F023E2514300DCD162 /* SDL_thread_c.h in Headers */,
 				A7D8AF0A23E2514100DCD162 /* SDL_cocoamessagebox.h in Headers */,
-				A7D8B16823E2514200DCD162 /* SDL_x11shape.h in Headers */,
 				A7D8BA0523E2514400DCD162 /* SDL_blendfillrect.h in Headers */,
 				A7D8B55B23E2514300DCD162 /* SDL_hidapijoystick_c.h in Headers */,
 				A7D8B2C423E2514200DCD162 /* SDL_pixels_c.h in Headers */,
-				A7D8B1BC23E2514200DCD162 /* SDL_x11modes.h in Headers */,
 				A7D8B58B23E2514300DCD162 /* SDL_joystick_c.h in Headers */,
 				F395C1972569C68F00942BFF /* SDL_iokitjoystick_c.h in Headers */,
 				A7D8B2B223E2514200DCD162 /* vk_sdk_platform.h in Headers */,
@@ -6904,7 +6329,6 @@
 				A7D8AF2223E2514100DCD162 /* SDL_cocoamouse.h in Headers */,
 				A7D8ADF023E2514100DCD162 /* SDL_blit_slow.h in Headers */,
 				A7D8B9CF23E2514400DCD162 /* SDL_yuv_sw_c.h in Headers */,
-				A7D8B1B623E2514200DCD162 /* SDL_x11opengl.h in Headers */,
 				A7D8BBAF23E2514500DCD162 /* SDL_windowevents_c.h in Headers */,
 				A7D8AF0423E2514100DCD162 /* SDL_cocoavideo.h in Headers */,
 				5605721A2473688C00B46B66 /* SDL_syslocale.h in Headers */,
@@ -6912,16 +6336,12 @@
 				A7D8BB3D23E2514500DCD162 /* SDL_gesture_c.h in Headers */,
 				A7D8BA7723E2514400DCD162 /* SDL_shaders_gl.h in Headers */,
 				A7D8B42C23E2514300DCD162 /* SDL_systhread_c.h in Headers */,
-				A7D8B20A23E2514200DCD162 /* SDL_x11keyboard.h in Headers */,
 				A7D8AE9223E2514100DCD162 /* SDL_cocoakeyboard.h in Headers */,
 				5616CA5A252BB35D005D5928 /* SDL_sysurl.h in Headers */,
 				A7D8ACE523E2514100DCD162 /* SDL_uikitvulkan.h in Headers */,
-				A7D8B1F223E2514200DCD162 /* SDL_x11framebuffer.h in Headers */,
-				A7D8B22223E2514200DCD162 /* SDL_x11video.h in Headers */,
 				A7D8B27023E2514200DCD162 /* vulkan.hpp in Headers */,
 				A7D8B22823E2514200DCD162 /* gl2ext.h in Headers */,
 				A7D8BB7323E2514500DCD162 /* SDL_clipboardevents_c.h in Headers */,
-				A7D8B14A23E2514200DCD162 /* SDL_x11touch.h in Headers */,
 				A7D8AAE423E2514100DCD162 /* SDL_syshaptic_c.h in Headers */,
 				A7D8B94E23E2514400DCD162 /* SDL_hints_c.h in Headers */,
 				A7D8B7B623E2514400DCD162 /* SDL_audiodev_c.h in Headers */,
@@ -6942,10 +6362,9 @@
 				A7D8B9F323E2514400DCD162 /* SDL_drawpoint.h in Headers */,
 				A7D8B87023E2514400DCD162 /* SDL_wave.h in Headers */,
 				A7D8AEE023E2514100DCD162 /* SDL_cocoaopengl.h in Headers */,
+				A1626A562617008D003F1973 /* SDL_triangle.h in Headers */,
 				A7D8B3CC23E2514300DCD162 /* yuv_rgb_sse_func.h in Headers */,
-				A7D8B21C23E2514200DCD162 /* imKStoUCS.h in Headers */,
 				A7D8AB5F23E2514100DCD162 /* SDL_offscreenevents_c.h in Headers */,
-				A7D8B1B023E2514200DCD162 /* SDL_x11sym.h in Headers */,
 				A7D8B8D023E2514400DCD162 /* SDL_coreaudio.h in Headers */,
 				A7D8BA1D23E2514400DCD162 /* SDL_draw.h in Headers */,
 				A7D8BA0B23E2514400DCD162 /* SDL_drawline.h in Headers */,
@@ -6953,7 +6372,6 @@
 				A7D8BBA323E2514500DCD162 /* scancodes_xfree86.h in Headers */,
 				A7D8B5D923E2514300DCD162 /* SDL_syspower.h in Headers */,
 				A75FDAF823E35ED500529352 /* SDL_config_iphoneos.h in Headers */,
-				A7D8B21023E2514200DCD162 /* SDL_x11clipboard.h in Headers */,
 				A7D8B24623E2514200DCD162 /* eglext.h in Headers */,
 				A7D8BBA923E2514500DCD162 /* SDL_events_c.h in Headers */,
 				A7D8BAC523E2514500DCD162 /* math_private.h in Headers */,
@@ -6966,13 +6384,11 @@
 				A7D8AC0123E2514100DCD162 /* SDL_nullevents_c.h in Headers */,
 				A7D8B58523E2514300DCD162 /* SDL_sysjoystick.h in Headers */,
 				A7D8BB6123E2514500DCD162 /* scancodes_linux.h in Headers */,
-				A7D8B1F823E2514200DCD162 /* SDL_x11dyn.h in Headers */,
 				A7D8BB6723E2514500DCD162 /* SDL_touch_c.h in Headers */,
 				A7D8B4B023E2514300DCD162 /* SDL_gamecontrollerdb.h in Headers */,
 				A7D8AEEC23E2514100DCD162 /* SDL_cocoavulkan.h in Headers */,
 				A7D8B23423E2514200DCD162 /* gl2platform.h in Headers */,
 				A7D8B25223E2514200DCD162 /* vk_layer.h in Headers */,
-				A7D8AEC223E2514100DCD162 /* SDL_cocoamousetap.h in Headers */,
 				A7D8B26A23E2514200DCD162 /* vk_platform.h in Headers */,
 				A7D8AEB623E2514100DCD162 /* SDL_cocoametalview.h in Headers */,
 				A7D8AEF223E2514100DCD162 /* SDL_cocoaopengles.h in Headers */,
@@ -6984,7 +6400,6 @@
 				A7D8AB7D23E2514100DCD162 /* SDL_offscreenopengl.h in Headers */,
 				A7D8BB5523E2514500DCD162 /* scancodes_darwin.h in Headers */,
 				A7D8B5BB23E2514300DCD162 /* controller_type.h in Headers */,
-				A7D8B17423E2514200DCD162 /* SDL_x11opengles.h in Headers */,
 				A7D8AC7923E2514100DCD162 /* SDL_uikitclipboard.h in Headers */,
 				A7D8B2A023E2514200DCD162 /* vulkan_xlib.h in Headers */,
 				A7D8AC9D23E2514100DCD162 /* SDL_uikitwindow.h in Headers */,
@@ -6997,7 +6412,6 @@
 				A7D8B3A223E2514200DCD162 /* SDL_RLEaccel_c.h in Headers */,
 				75E09167241EA924004729E1 /* SDL_virtualjoystick_c.h in Headers */,
 				A7D8B24C23E2514200DCD162 /* eglplatform.h in Headers */,
-				A7D8B1DA23E2514200DCD162 /* edid.h in Headers */,
 				A7D8B3EA23E2514300DCD162 /* SDL_systhread.h in Headers */,
 				A7D8AECE23E2514100DCD162 /* SDL_cocoaclipboard.h in Headers */,
 				A7D8AEF823E2514100DCD162 /* SDL_cocoamodes.h in Headers */,
@@ -7031,10 +6445,8 @@
 				A7D8B57323E2514300DCD162 /* usb_ids.h in Headers */,
 				A7D8BA5923E2514400DCD162 /* SDL_gles2funcs.h in Headers */,
 				A7D8AC4323E2514100DCD162 /* SDL_sysvideo.h in Headers */,
-				A7D8B1FE23E2514200DCD162 /* SDL_x11mouse.h in Headers */,
 				A7D8AB1423E2514100DCD162 /* SDL_dynapi_overrides.h in Headers */,
 				A7D8AEFE23E2514100DCD162 /* SDL_cocoawindow.h in Headers */,
-				A7D8B1E023E2514200DCD162 /* SDL_x11vulkan.h in Headers */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -7068,7 +6480,6 @@
 				A7D8AEB223E2514100DCD162 /* SDL_cocoametalview.h in Headers */,
 				A7D8AEF423E2514100DCD162 /* SDL_cocoamodes.h in Headers */,
 				A7D8AF1E23E2514100DCD162 /* SDL_cocoamouse.h in Headers */,
-				A7D8AEBE23E2514100DCD162 /* SDL_cocoamousetap.h in Headers */,
 				A7D8AEDC23E2514100DCD162 /* SDL_cocoaopengl.h in Headers */,
 				A7D8AEEE23E2514100DCD162 /* SDL_cocoaopengles.h in Headers */,
 				A7D8AE8223E2514100DCD162 /* SDL_cocoashape.h in Headers */,
@@ -7132,6 +6543,7 @@
 				5616CA50252BB2BE005D5928 /* SDL_misc.h in Headers */,
 				AA75582A1595D4D800BBD41B /* SDL_mouse.h in Headers */,
 				A7D8BB1B23E2514500DCD162 /* SDL_mouse_c.h in Headers */,
+				F38233852738EB8600F7F527 /* SDL_hidapi.h in Headers */,
 				AA75582C1595D4D800BBD41B /* SDL_mutex.h in Headers */,
 				AA75582E1595D4D800BBD41B /* SDL_name.h in Headers */,
 				A7D8ABFD23E2514100DCD162 /* SDL_nullevents_c.h in Headers */,
@@ -7220,23 +6632,6 @@
 				A7D8AD1D23E2514100DCD162 /* SDL_vulkan_internal.h in Headers */,
 				A7D8B86C23E2514400DCD162 /* SDL_wave.h in Headers */,
 				A7D8BBAB23E2514500DCD162 /* SDL_windowevents_c.h in Headers */,
-				A7D8B20C23E2514200DCD162 /* SDL_x11clipboard.h in Headers */,
-				A7D8B1F423E2514200DCD162 /* SDL_x11dyn.h in Headers */,
-				A7D8B21223E2514200DCD162 /* SDL_x11events.h in Headers */,
-				A7D8B1EE23E2514200DCD162 /* SDL_x11framebuffer.h in Headers */,
-				A7D8B20623E2514200DCD162 /* SDL_x11keyboard.h in Headers */,
-				A7D8B14C23E2514200DCD162 /* SDL_x11messagebox.h in Headers */,
-				A7D8B1B823E2514200DCD162 /* SDL_x11modes.h in Headers */,
-				A7D8B1FA23E2514200DCD162 /* SDL_x11mouse.h in Headers */,
-				A7D8B1B223E2514200DCD162 /* SDL_x11opengl.h in Headers */,
-				A7D8B17023E2514200DCD162 /* SDL_x11opengles.h in Headers */,
-				A7D8B16423E2514200DCD162 /* SDL_x11shape.h in Headers */,
-				A7D8B1AC23E2514200DCD162 /* SDL_x11sym.h in Headers */,
-				A7D8B14623E2514200DCD162 /* SDL_x11touch.h in Headers */,
-				A7D8B21E23E2514200DCD162 /* SDL_x11video.h in Headers */,
-				A7D8B1DC23E2514200DCD162 /* SDL_x11vulkan.h in Headers */,
-				A7D8B1E823E2514200DCD162 /* SDL_x11window.h in Headers */,
-				A7D8B1D023E2514200DCD162 /* SDL_x11xinput2.h in Headers */,
 				A7D8B3B023E2514200DCD162 /* SDL_yuv_c.h in Headers */,
 				A7D8B9CB23E2514400DCD162 /* SDL_yuv_sw_c.h in Headers */,
 				AA7557FA1595D4D800BBD41B /* begin_code.h in Headers */,
@@ -7244,7 +6639,6 @@
 				AA7557FC1595D4D800BBD41B /* close_code.h in Headers */,
 				A7D8B5B723E2514300DCD162 /* controller_type.h in Headers */,
 				A7D8BB4B23E2514500DCD162 /* default_cursor.h in Headers */,
-				A7D8B1D623E2514200DCD162 /* edid.h in Headers */,
 				A7D8B23C23E2514200DCD162 /* egl.h in Headers */,
 				A7D8B24223E2514200DCD162 /* eglext.h in Headers */,
 				A7D8B24823E2514200DCD162 /* eglplatform.h in Headers */,
@@ -7252,7 +6646,6 @@
 				A7D8B22423E2514200DCD162 /* gl2ext.h in Headers */,
 				A7D8B23023E2514200DCD162 /* gl2platform.h in Headers */,
 				A75FDB5823E39E6100529352 /* hidapi.h in Headers */,
-				A7D8B21823E2514200DCD162 /* imKStoUCS.h in Headers */,
 				A7D8BBD123E2574800DCD162 /* keyinfotable.h in Headers */,
 				A7D8B23623E2514200DCD162 /* khrplatform.h in Headers */,
 				A7D8BB0323E2514500DCD162 /* math_libm.h in Headers */,
@@ -7262,6 +6655,7 @@
 				A7D8BB2123E2514500DCD162 /* scancodes_windows.h in Headers */,
 				A7D8BB9F23E2514500DCD162 /* scancodes_xfree86.h in Headers */,
 				A7D8B56F23E2514300DCD162 /* usb_ids.h in Headers */,
+				A1626A522617008D003F1973 /* SDL_triangle.h in Headers */,
 				A7D8B25423E2514200DCD162 /* vk_icd.h in Headers */,
 				A7D8B24E23E2514200DCD162 /* vk_layer.h in Headers */,
 				A7D8B26623E2514200DCD162 /* vk_platform.h in Headers */,
@@ -7294,7 +6688,6 @@
 				A7D8AC0C23E2514100DCD162 /* SDL_shape_internals.h in Headers */,
 				A7D8BA7C23E2514400DCD162 /* SDL_glfuncs.h in Headers */,
 				A7D8AC0623E2514100DCD162 /* SDL_rect_c.h in Headers */,
-				A7D8B1D323E2514200DCD162 /* SDL_x11xinput2.h in Headers */,
 				75E09166241EA924004729E1 /* SDL_virtualjoystick_c.h in Headers */,
 				A7D8B99E23E2514400DCD162 /* SDL_shaders_metal_osx.h in Headers */,
 				A7D8B98F23E2514400DCD162 /* SDL_shaders_metal_ios.h in Headers */,
@@ -7304,20 +6697,15 @@
 				A7D8AABF23E2514100DCD162 /* SDL_haptic_c.h in Headers */,
 				A7D8A94823E2514000DCD162 /* SDL_dataqueue.h in Headers */,
 				A7D8A96023E2514000DCD162 /* SDL_error_c.h in Headers */,
-				A7D8B21523E2514200DCD162 /* SDL_x11events.h in Headers */,
 				A7D8B98323E2514400DCD162 /* SDL_d3dmath.h in Headers */,
-				A7D8B1EB23E2514200DCD162 /* SDL_x11window.h in Headers */,
 				A7D8ABDC23E2514100DCD162 /* SDL_egl_c.h in Headers */,
 				A7D8B3D723E2514300DCD162 /* yuv_rgb.h in Headers */,
 				A7D8B79723E2514400DCD162 /* SDL_dummyaudio.h in Headers */,
-				A7D8B14F23E2514200DCD162 /* SDL_x11messagebox.h in Headers */,
 				A7D8B3EF23E2514300DCD162 /* SDL_thread_c.h in Headers */,
 				A7D8AF0923E2514100DCD162 /* SDL_cocoamessagebox.h in Headers */,
-				A7D8B16723E2514200DCD162 /* SDL_x11shape.h in Headers */,
 				A7D8BA0423E2514400DCD162 /* SDL_blendfillrect.h in Headers */,
 				A7D8B55A23E2514300DCD162 /* SDL_hidapijoystick_c.h in Headers */,
 				A7D8B2C323E2514200DCD162 /* SDL_pixels_c.h in Headers */,
-				A7D8B1BB23E2514200DCD162 /* SDL_x11modes.h in Headers */,
 				A7D8B58A23E2514300DCD162 /* SDL_joystick_c.h in Headers */,
 				A75FDB5B23E39E6100529352 /* hidapi.h in Headers */,
 				A7D8B2B123E2514200DCD162 /* vk_sdk_platform.h in Headers */,
@@ -7330,21 +6718,16 @@
 				A7D8ADEF23E2514100DCD162 /* SDL_blit_slow.h in Headers */,
 				A7D8B9CE23E2514400DCD162 /* SDL_yuv_sw_c.h in Headers */,
 				A7D8BBFD23E2574800DCD162 /* SDL_uikitvideo.h in Headers */,
-				A7D8B1B523E2514200DCD162 /* SDL_x11opengl.h in Headers */,
 				A7D8BBAE23E2514500DCD162 /* SDL_windowevents_c.h in Headers */,
 				A7D8AF0323E2514100DCD162 /* SDL_cocoavideo.h in Headers */,
 				A7D8BB3C23E2514500DCD162 /* SDL_gesture_c.h in Headers */,
 				A7D8BBEF23E2574800DCD162 /* SDL_uikitclipboard.h in Headers */,
 				A7D8BA7623E2514400DCD162 /* SDL_shaders_gl.h in Headers */,
 				A7D8B42B23E2514300DCD162 /* SDL_systhread_c.h in Headers */,
-				A7D8B20923E2514200DCD162 /* SDL_x11keyboard.h in Headers */,
 				A7D8AE9123E2514100DCD162 /* SDL_cocoakeyboard.h in Headers */,
-				A7D8B1F123E2514200DCD162 /* SDL_x11framebuffer.h in Headers */,
-				A7D8B22123E2514200DCD162 /* SDL_x11video.h in Headers */,
 				A7D8B26F23E2514200DCD162 /* vulkan.hpp in Headers */,
 				A7D8B22723E2514200DCD162 /* gl2ext.h in Headers */,
 				A7D8BB7223E2514500DCD162 /* SDL_clipboardevents_c.h in Headers */,
-				A7D8B14923E2514200DCD162 /* SDL_x11touch.h in Headers */,
 				A7D8AAE323E2514100DCD162 /* SDL_syshaptic_c.h in Headers */,
 				A7D8B94D23E2514400DCD162 /* SDL_hints_c.h in Headers */,
 				A7D8B7B523E2514400DCD162 /* SDL_audiodev_c.h in Headers */,
@@ -7364,9 +6747,7 @@
 				A7D8B86F23E2514400DCD162 /* SDL_wave.h in Headers */,
 				A7D8AEDF23E2514100DCD162 /* SDL_cocoaopengl.h in Headers */,
 				A7D8B3CB23E2514300DCD162 /* yuv_rgb_sse_func.h in Headers */,
-				A7D8B21B23E2514200DCD162 /* imKStoUCS.h in Headers */,
 				A7D8AB5E23E2514100DCD162 /* SDL_offscreenevents_c.h in Headers */,
-				A7D8B1AF23E2514200DCD162 /* SDL_x11sym.h in Headers */,
 				A7D8B8CF23E2514400DCD162 /* SDL_coreaudio.h in Headers */,
 				A7D8BA1C23E2514400DCD162 /* SDL_draw.h in Headers */,
 				A7D8BA0A23E2514400DCD162 /* SDL_drawline.h in Headers */,
@@ -7375,7 +6756,6 @@
 				A7D8B3B323E2514200DCD162 /* SDL_yuv_c.h in Headers */,
 				A7D8BBA223E2514500DCD162 /* scancodes_xfree86.h in Headers */,
 				A7D8B5D823E2514300DCD162 /* SDL_syspower.h in Headers */,
-				A7D8B20F23E2514200DCD162 /* SDL_x11clipboard.h in Headers */,
 				A7D8BC0523E2574800DCD162 /* SDL_uikitwindow.h in Headers */,
 				A7D8B24523E2514200DCD162 /* eglext.h in Headers */,
 				A7D8BBF123E2574800DCD162 /* SDL_uikitevents.h in Headers */,
@@ -7393,14 +6773,13 @@
 				A7D8AC0023E2514100DCD162 /* SDL_nullevents_c.h in Headers */,
 				A7D8B58423E2514300DCD162 /* SDL_sysjoystick.h in Headers */,
 				A7D8BB6023E2514500DCD162 /* scancodes_linux.h in Headers */,
-				A7D8B1F723E2514200DCD162 /* SDL_x11dyn.h in Headers */,
 				A7D8BB6623E2514500DCD162 /* SDL_touch_c.h in Headers */,
 				A7D8B4AF23E2514300DCD162 /* SDL_gamecontrollerdb.h in Headers */,
 				A7D8AEEB23E2514100DCD162 /* SDL_cocoavulkan.h in Headers */,
 				A7D8B23323E2514200DCD162 /* gl2platform.h in Headers */,
 				A7D8B25123E2514200DCD162 /* vk_layer.h in Headers */,
-				A7D8AEC123E2514100DCD162 /* SDL_cocoamousetap.h in Headers */,
 				A7D8B26923E2514200DCD162 /* vk_platform.h in Headers */,
+				A1626A552617008D003F1973 /* SDL_triangle.h in Headers */,
 				A7D8BBF323E2574800DCD162 /* SDL_uikitmessagebox.h in Headers */,
 				A7D8AEB523E2514100DCD162 /* SDL_cocoametalview.h in Headers */,
 				A7D8AEF123E2514100DCD162 /* SDL_cocoaopengles.h in Headers */,
@@ -7414,7 +6793,6 @@
 				A7D8BBCB23E2561600DCD162 /* SDL_steamcontroller.h in Headers */,
 				A7D8BB5423E2514500DCD162 /* scancodes_darwin.h in Headers */,
 				A7D8B5BA23E2514300DCD162 /* controller_type.h in Headers */,
-				A7D8B17323E2514200DCD162 /* SDL_x11opengles.h in Headers */,
 				A7D8B29F23E2514200DCD162 /* vulkan_xlib.h in Headers */,
 				A7D8B25D23E2514200DCD162 /* vulkan_vi.h in Headers */,
 				A7D8B29923E2514200DCD162 /* vulkan_mir.h in Headers */,
@@ -7426,7 +6804,6 @@
 				A7D8B39B23E2514200DCD162 /* SDL_blit_copy.h in Headers */,
 				A7D8B3A123E2514200DCD162 /* SDL_RLEaccel_c.h in Headers */,
 				A7D8B24B23E2514200DCD162 /* eglplatform.h in Headers */,
-				A7D8B1D923E2514200DCD162 /* edid.h in Headers */,
 				A7D8BC0123E2574800DCD162 /* SDL_uikitviewcontroller.h in Headers */,
 				A7D8B3E923E2514300DCD162 /* SDL_systhread.h in Headers */,
 				A7D8AECD23E2514100DCD162 /* SDL_cocoaclipboard.h in Headers */,
@@ -7462,10 +6839,8 @@
 				A7D8BA5823E2514400DCD162 /* SDL_gles2funcs.h in Headers */,
 				A75FDBC823EA380300529352 /* SDL_hidapi_rumble.h in Headers */,
 				A7D8AC4223E2514100DCD162 /* SDL_sysvideo.h in Headers */,
-				A7D8B1FD23E2514200DCD162 /* SDL_x11mouse.h in Headers */,
 				A7D8AB1323E2514100DCD162 /* SDL_dynapi_overrides.h in Headers */,
 				A7D8AEFD23E2514100DCD162 /* SDL_cocoawindow.h in Headers */,
-				A7D8B1DF23E2514200DCD162 /* SDL_x11vulkan.h in Headers */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -7486,7 +6861,6 @@
 				DB313FCB17554B71006C0E22 /* SDL_atomic.h in Headers */,
 				75E09169241EA924004729E1 /* SDL_virtualjoystick_c.h in Headers */,
 				A7D8AC0823E2514100DCD162 /* SDL_rect_c.h in Headers */,
-				A7D8B1D523E2514200DCD162 /* SDL_x11xinput2.h in Headers */,
 				A7D8B9A023E2514400DCD162 /* SDL_shaders_metal_osx.h in Headers */,
 				A7D8B99123E2514400DCD162 /* SDL_shaders_metal_ios.h in Headers */,
 				A7D8AB8A23E2514100DCD162 /* SDL_offscreenwindow.h in Headers */,
@@ -7502,20 +6876,17 @@
 				DB313FCE17554B71006C0E22 /* SDL_clipboard.h in Headers */,
 				A7D8A94A23E2514000DCD162 /* SDL_dataqueue.h in Headers */,
 				A7D8A96223E2514000DCD162 /* SDL_error_c.h in Headers */,
-				A7D8B21723E2514200DCD162 /* SDL_x11events.h in Headers */,
 				DB313FD017554B71006C0E22 /* SDL_config.h in Headers */,
 				A7D8B98523E2514400DCD162 /* SDL_d3dmath.h in Headers */,
-				A7D8B1ED23E2514200DCD162 /* SDL_x11window.h in Headers */,
 				DB313FCF17554B71006C0E22 /* SDL_config_macosx.h in Headers */,
 				A7D8ABDE23E2514100DCD162 /* SDL_egl_c.h in Headers */,
 				DB313FD117554B71006C0E22 /* SDL_copying.h in Headers */,
+				F382338B2738EB8600F7F527 /* SDL_hidapi.h in Headers */,
 				A7D8B3D923E2514300DCD162 /* yuv_rgb.h in Headers */,
 				A7D8B79923E2514400DCD162 /* SDL_dummyaudio.h in Headers */,
 				A7D8AC9823E2514100DCD162 /* SDL_uikitmessagebox.h in Headers */,
-				A7D8B15123E2514200DCD162 /* SDL_x11messagebox.h in Headers */,
 				A7D8B3F123E2514300DCD162 /* SDL_thread_c.h in Headers */,
 				A7D8AF0B23E2514100DCD162 /* SDL_cocoamessagebox.h in Headers */,
-				A7D8B16923E2514200DCD162 /* SDL_x11shape.h in Headers */,
 				DB313FD217554B71006C0E22 /* SDL_cpuinfo.h in Headers */,
 				DB313FD317554B71006C0E22 /* SDL_endian.h in Headers */,
 				DB313FD417554B71006C0E22 /* SDL_error.h in Headers */,
@@ -7526,7 +6897,6 @@
 				A7D8B55C23E2514300DCD162 /* SDL_hidapijoystick_c.h in Headers */,
 				F395C1992569C68F00942BFF /* SDL_iokitjoystick_c.h in Headers */,
 				A7D8B2C523E2514200DCD162 /* SDL_pixels_c.h in Headers */,
-				A7D8B1BD23E2514200DCD162 /* SDL_x11modes.h in Headers */,
 				A7D8B58C23E2514300DCD162 /* SDL_joystick_c.h in Headers */,
 				A7D8B2B323E2514200DCD162 /* vk_sdk_platform.h in Headers */,
 				A7D8BB4A23E2514500DCD162 /* blank_cursor.h in Headers */,
@@ -7540,7 +6910,6 @@
 				DB313FD817554B71006C0E22 /* SDL_hints.h in Headers */,
 				A7D8ADF123E2514100DCD162 /* SDL_blit_slow.h in Headers */,
 				A7D8B9D023E2514400DCD162 /* SDL_yuv_sw_c.h in Headers */,
-				A7D8B1B723E2514200DCD162 /* SDL_x11opengl.h in Headers */,
 				A7D8BBB023E2514500DCD162 /* SDL_windowevents_c.h in Headers */,
 				DB313FD917554B71006C0E22 /* SDL_joystick.h in Headers */,
 				A7D8AF0523E2514100DCD162 /* SDL_cocoavideo.h in Headers */,
@@ -7550,16 +6919,12 @@
 				A7D8BA7823E2514400DCD162 /* SDL_shaders_gl.h in Headers */,
 				A7D8B42D23E2514300DCD162 /* SDL_systhread_c.h in Headers */,
 				DB313FDB17554B71006C0E22 /* SDL_keycode.h in Headers */,
-				A7D8B20B23E2514200DCD162 /* SDL_x11keyboard.h in Headers */,
 				A7D8AE9323E2514100DCD162 /* SDL_cocoakeyboard.h in Headers */,
 				A7D8ACE623E2514100DCD162 /* SDL_uikitvulkan.h in Headers */,
-				A7D8B1F323E2514200DCD162 /* SDL_x11framebuffer.h in Headers */,
-				A7D8B22323E2514200DCD162 /* SDL_x11video.h in Headers */,
 				A7D8B27123E2514200DCD162 /* vulkan.hpp in Headers */,
 				DB313FDC17554B71006C0E22 /* SDL_loadso.h in Headers */,
 				A7D8B22923E2514200DCD162 /* gl2ext.h in Headers */,
 				A7D8BB7423E2514500DCD162 /* SDL_clipboardevents_c.h in Headers */,
-				A7D8B14B23E2514200DCD162 /* SDL_x11touch.h in Headers */,
 				A7D8AAE523E2514100DCD162 /* SDL_syshaptic_c.h in Headers */,
 				A7D8B94F23E2514400DCD162 /* SDL_hints_c.h in Headers */,
 				A7D8B7B723E2514400DCD162 /* SDL_audiodev_c.h in Headers */,
@@ -7583,10 +6948,9 @@
 				A7D8B87123E2514400DCD162 /* SDL_wave.h in Headers */,
 				A7D8AEE123E2514100DCD162 /* SDL_cocoaopengl.h in Headers */,
 				A7D8B3CD23E2514300DCD162 /* yuv_rgb_sse_func.h in Headers */,
-				A7D8B21D23E2514200DCD162 /* imKStoUCS.h in Headers */,
 				5605721B2473688D00B46B66 /* SDL_syslocale.h in Headers */,
 				A7D8AB6023E2514100DCD162 /* SDL_offscreenevents_c.h in Headers */,
-				A7D8B1B123E2514200DCD162 /* SDL_x11sym.h in Headers */,
+				A1626A582617008D003F1973 /* SDL_triangle.h in Headers */,
 				A7D8B8D123E2514400DCD162 /* SDL_coreaudio.h in Headers */,
 				A7D8BA1E23E2514400DCD162 /* SDL_draw.h in Headers */,
 				A7D8BA0C23E2514400DCD162 /* SDL_drawline.h in Headers */,
@@ -7596,7 +6960,6 @@
 				A7D8B3B523E2514200DCD162 /* SDL_yuv_c.h in Headers */,
 				A7D8BBA423E2514500DCD162 /* scancodes_xfree86.h in Headers */,
 				A7D8B5DA23E2514300DCD162 /* SDL_syspower.h in Headers */,
-				A7D8B21123E2514200DCD162 /* SDL_x11clipboard.h in Headers */,
 				DB313FE117554B71006C0E22 /* SDL_name.h in Headers */,
 				A7D8B24723E2514200DCD162 /* eglext.h in Headers */,
 				A7D8BBAA23E2514500DCD162 /* SDL_events_c.h in Headers */,
@@ -7614,14 +6977,12 @@
 				A7D8B58623E2514300DCD162 /* SDL_sysjoystick.h in Headers */,
 				A7D8BBCF23E2561600DCD162 /* SDL_steamcontroller.h in Headers */,
 				A7D8BB6223E2514500DCD162 /* scancodes_linux.h in Headers */,
-				A7D8B1F923E2514200DCD162 /* SDL_x11dyn.h in Headers */,
 				A7D8BB6823E2514500DCD162 /* SDL_touch_c.h in Headers */,
 				A7D8B4B123E2514300DCD162 /* SDL_gamecontrollerdb.h in Headers */,
 				A7D8AEED23E2514100DCD162 /* SDL_cocoavulkan.h in Headers */,
 				A7D8B23523E2514200DCD162 /* gl2platform.h in Headers */,
 				DB313FE517554B71006C0E22 /* SDL_pixels.h in Headers */,
 				A7D8B25323E2514200DCD162 /* vk_layer.h in Headers */,
-				A7D8AEC323E2514100DCD162 /* SDL_cocoamousetap.h in Headers */,
 				A7D8B26B23E2514200DCD162 /* vk_platform.h in Headers */,
 				A7D8AEB723E2514100DCD162 /* SDL_cocoametalview.h in Headers */,
 				A7D8AEF323E2514100DCD162 /* SDL_cocoaopengles.h in Headers */,
@@ -7635,7 +6996,6 @@
 				A7D8AB7E23E2514100DCD162 /* SDL_offscreenopengl.h in Headers */,
 				A7D8BB5623E2514500DCD162 /* scancodes_darwin.h in Headers */,
 				A7D8B5BC23E2514300DCD162 /* controller_type.h in Headers */,
-				A7D8B17523E2514200DCD162 /* SDL_x11opengles.h in Headers */,
 				A7D8AC7A23E2514100DCD162 /* SDL_uikitclipboard.h in Headers */,
 				A7D8B2A123E2514200DCD162 /* vulkan_xlib.h in Headers */,
 				A7D8AC9E23E2514100DCD162 /* SDL_uikitwindow.h in Headers */,
@@ -7650,7 +7010,6 @@
 				A7D8B39D23E2514200DCD162 /* SDL_blit_copy.h in Headers */,
 				A7D8B3A323E2514200DCD162 /* SDL_RLEaccel_c.h in Headers */,
 				A7D8B24D23E2514200DCD162 /* eglplatform.h in Headers */,
-				A7D8B1DB23E2514200DCD162 /* edid.h in Headers */,
 				DB313FEB17554B71006C0E22 /* SDL_revision.h in Headers */,
 				A7D8B3EB23E2514300DCD162 /* SDL_systhread.h in Headers */,
 				DB313FEC17554B71006C0E22 /* SDL_rwops.h in Headers */,
@@ -7705,10 +7064,8 @@
 				A7D8AC4423E2514100DCD162 /* SDL_sysvideo.h in Headers */,
 				AAC07104195606770073DCDF /* SDL_opengles2_gl2platform.h in Headers */,
 				AAC07101195606770073DCDF /* SDL_opengles2_gl2ext.h in Headers */,
-				A7D8B1FF23E2514200DCD162 /* SDL_x11mouse.h in Headers */,
 				A7D8AB1523E2514100DCD162 /* SDL_dynapi_overrides.h in Headers */,
 				A7D8AEFF23E2514100DCD162 /* SDL_cocoawindow.h in Headers */,
-				A7D8B1E123E2514200DCD162 /* SDL_x11vulkan.h in Headers */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -7755,60 +7112,6 @@
 			productReference = A75FD06C23E25AC700529352 /* libSDL2.dylib */;
 			productType = "com.apple.product-type.library.dynamic";
 		};
-		A75FDB4823E399AC00529352 /* hidapi-iOS */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = A75FDB5023E399AC00529352 /* Build configuration list for PBXNativeTarget "hidapi-iOS" */;
-			buildPhases = (
-				A75FDB4423E399AC00529352 /* Headers */,
-				A75FDB4523E399AC00529352 /* Sources */,
-				A75FDB4623E399AC00529352 /* Frameworks */,
-				A75FDB4723E399AC00529352 /* Resources */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = "hidapi-iOS";
-			productName = hidapi;
-			productReference = A75FDB4923E399AC00529352 /* hidapi.framework */;
-			productType = "com.apple.product-type.framework";
-		};
-		A75FDB6223E3A2C900529352 /* hidapi-tvOS */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = A75FDB6B23E3A2C900529352 /* Build configuration list for PBXNativeTarget "hidapi-tvOS" */;
-			buildPhases = (
-				A75FDB6323E3A2C900529352 /* Headers */,
-				A75FDB6523E3A2C900529352 /* Sources */,
-				A75FDB6723E3A2C900529352 /* Frameworks */,
-				A75FDB6A23E3A2C900529352 /* Resources */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = "hidapi-tvOS";
-			productName = hidapi;
-			productReference = A75FDB6E23E3A2C900529352 /* hidapi.framework */;
-			productType = "com.apple.product-type.framework";
-		};
-		A75FDB8023E4C74400529352 /* hidapi */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = A75FDB8923E4C74400529352 /* Build configuration list for PBXNativeTarget "hidapi" */;
-			buildPhases = (
-				A75FDB8123E4C74400529352 /* Headers */,
-				A75FDB8323E4C74400529352 /* Sources */,
-				A75FDB8523E4C74400529352 /* Frameworks */,
-				A75FDB8823E4C74400529352 /* Resources */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = hidapi;
-			productName = hidapi;
-			productReference = A75FDB8C23E4C74400529352 /* hidapi.framework */;
-			productType = "com.apple.product-type.framework";
-		};
 		A769B08223E259AE00872273 /* Static Library-tvOS */ = {
 			isa = PBXNativeTarget;
 			buildConfigurationList = A769B23A23E259AE00872273 /* Build configuration list for PBXNativeTarget "Static Library-tvOS" */;
@@ -7820,7 +7123,7 @@
 			);
 			buildRules = (
 			);
-			comments = "This produces libsdl.a, which is the static build of SDL. You will have to link to the Cocoa and OpenGL frameworks in your application.";
+			comments = "This produces libSDL.a, which is the static build of SDL. You will have to link to the Cocoa and OpenGL frameworks in your application.";
 			dependencies = (
 			);
 			name = "Static Library-tvOS";
@@ -7882,7 +7185,7 @@
 			);
 			buildRules = (
 			);
-			comments = "This produces libsdl.a, which is the static build of SDL. You will have to link to the Cocoa and OpenGL frameworks in your application.";
+			comments = "This produces libSDL.a, which is the static build of SDL. You will have to link to the Cocoa and OpenGL frameworks in your application.";
 			dependencies = (
 			);
 			name = "Static Library-iOS";
@@ -7923,7 +7226,7 @@
 			);
 			buildRules = (
 			);
-			comments = "This produces libsdl.a, which is the static build of SDL. You will have to link to the Cocoa and OpenGL frameworks in your application.";
+			comments = "This produces libSDL.a, which is the static build of SDL. You will have to link to the Cocoa and OpenGL frameworks in your application.";
 			dependencies = (
 			);
 			name = "Static Library";
@@ -7941,7 +7244,6 @@
 			buildRules = (
 			);
 			dependencies = (
-				F3190017240CA3BA00ED104F /* PBXTargetDependency */,
 				BECDF6C60761BA81005FE872 /* PBXTargetDependency */,
 			);
 			name = "Standard DMG";
@@ -7977,11 +7279,6 @@
 			isa = PBXProject;
 			attributes = {
 				LastUpgradeCheck = 1130;
-				TargetAttributes = {
-					A75FDB4823E399AC00529352 = {
-						CreatedOnToolsVersion = 11.3.1;
-					};
-				};
 			};
 			buildConfigurationList = 0073178E0858DB0500B2BC32 /* Build configuration list for PBXProject "SDL" */;
 			compatibilityVersion = "Xcode 3.2";
@@ -8007,50 +7304,11 @@
 				A75FCCFB23E25AB700529352 /* Shared Library-iOS */,
 				A75FCEB423E25AC700529352 /* Shared Library-tvOS */,
 				BECDF6BB0761BA81005FE872 /* Standard DMG */,
-				A75FDB8023E4C74400529352 /* hidapi */,
-				A75FDB4823E399AC00529352 /* hidapi-iOS */,
-				A75FDB6223E3A2C900529352 /* hidapi-tvOS */,
 			);
 		};
 /* End PBXProject section */
 
 /* Begin PBXResourcesBuildPhase section */
-		A75FDB4723E399AC00529352 /* Resources */ = {
-			isa = PBXResourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				A75FDBB223E4CB7000529352 /* LICENSE-gpl3.txt in Resources */,
-				A75FDBA923E4CB7000529352 /* LICENSE-bsd.txt in Resources */,
-				A75FDBAC23E4CB7000529352 /* AUTHORS.txt in Resources */,
-				A75FDBB523E4CB7000529352 /* LICENSE.txt in Resources */,
-				A75FDBAF23E4CB7000529352 /* LICENSE-orig.txt in Resources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		A75FDB6A23E3A2C900529352 /* Resources */ = {
-			isa = PBXResourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				A75FDBB323E4CB7000529352 /* LICENSE-gpl3.txt in Resources */,
-				A75FDBAA23E4CB7000529352 /* LICENSE-bsd.txt in Resources */,
-				A75FDBAD23E4CB7000529352 /* AUTHORS.txt in Resources */,
-				A75FDBB623E4CB7000529352 /* LICENSE.txt in Resources */,
-				A75FDBB023E4CB7000529352 /* LICENSE-orig.txt in Resources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		A75FDB8823E4C74400529352 /* Resources */ = {
-			isa = PBXResourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				A75FDBB123E4CB7000529352 /* LICENSE-gpl3.txt in Resources */,
-				A75FDBA823E4CB7000529352 /* LICENSE-bsd.txt in Resources */,
-				A75FDBAB23E4CB7000529352 /* AUTHORS.txt in Resources */,
-				A75FDBB423E4CB7000529352 /* LICENSE.txt in Resources */,
-				A75FDBAE23E4CB7000529352 /* LICENSE-orig.txt in Resources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
 		A7D88ABE23E2437C00DCD162 /* Resources */ = {
 			isa = PBXResourcesBuildPhase;
 			buildActionMask = 2147483647;
@@ -8157,20 +7415,18 @@
 				A75FCDF223E25AB700529352 /* SDL_render_metal.m in Sources */,
 				A75FCDF323E25AB700529352 /* SDL_clipboard.c in Sources */,
 				A75FCDF423E25AB700529352 /* SDL_cocoaevents.m in Sources */,
-				A75FCDF523E25AB700529352 /* SDL_x11messagebox.c in Sources */,
 				A75FCDF623E25AB700529352 /* SDL_audiocvt.c in Sources */,
 				A75FCDF723E25AB700529352 /* SDL_shape.c in Sources */,
 				A75FCDF823E25AB700529352 /* SDL_rotate.c in Sources */,
 				A75FCDF923E25AB700529352 /* SDL_coremotionsensor.m in Sources */,
 				A75FDAB123E2795C00529352 /* SDL_hidapi_steam.c in Sources */,
 				A75FCDFA23E25AB700529352 /* SDL_touch.c in Sources */,
-				A75FCDFB23E25AB700529352 /* SDL_x11events.c in Sources */,
+				A1626A452617006A003F1973 /* SDL_triangle.c in Sources */,
 				A75FCDFC23E25AB700529352 /* SDL_uikitmessagebox.m in Sources */,
 				A75FCDFD23E25AB700529352 /* SDL_thread.c in Sources */,
 				A75FCDFE23E25AB700529352 /* SDL_hidapi_xbox360w.c in Sources */,
 				A75FCDFF23E25AB700529352 /* SDL_atomic.c in Sources */,
 				A75FCE0023E25AB700529352 /* SDL_displayevents.c in Sources */,
-				A75FCE0123E25AB700529352 /* SDL_cocoamousetap.m in Sources */,
 				A75FCE0223E25AB700529352 /* SDL_log.c in Sources */,
 				A75FCE0323E25AB700529352 /* SDL_cocoaopengl.m in Sources */,
 				A75FCE0423E25AB700529352 /* SDL_offscreenframebuffer.c in Sources */,
@@ -8185,14 +7441,13 @@
 				A75FCE0D23E25AB700529352 /* SDL_systimer.c in Sources */,
 				A75FCE0E23E25AB700529352 /* SDL_uikitclipboard.m in Sources */,
 				A75FCE0F23E25AB700529352 /* SDL_render_sw.c in Sources */,
-				A75FCE1023E25AB700529352 /* SDL_x11video.c in Sources */,
 				A75FCE1123E25AB700529352 /* SDL_syssem.c in Sources */,
 				A75FCE1223E25AB700529352 /* SDL_hidapi_xbox360.c in Sources */,
 				A75FCE1323E25AB700529352 /* SDL_coreaudio.m in Sources */,
 				A75FCE1423E25AB700529352 /* SDL_blendline.c in Sources */,
+				F38233982738EC1800F7F527 /* hid.m in Sources */,
 				A75FCE1523E25AB700529352 /* SDL_blit_A.c in Sources */,
 				A75FCE1623E25AB700529352 /* SDL_d3dmath.c in Sources */,
-				A75FCE1723E25AB700529352 /* SDL_x11mouse.c in Sources */,
 				A75FCE1823E25AB700529352 /* SDL_nullvideo.c in Sources */,
 				A75FCE1923E25AB700529352 /* SDL_offscreenevents.c in Sources */,
 				A75FCE1A23E25AB700529352 /* SDL_uikitview.m in Sources */,
@@ -8203,7 +7458,7 @@
 				A75FCE1F23E25AB700529352 /* s_copysign.c in Sources */,
 				A75FCE2023E25AB700529352 /* SDL_haptic.c in Sources */,
 				A75FCE2123E25AB700529352 /* SDL_uikitvulkan.m in Sources */,
-				A75FCE2223E25AB700529352 /* SDL_x11modes.c in Sources */,
+				F3984CD725BCC92900374F43 /* SDL_hidapi_stadia.c in Sources */,
 				75E09161241EA924004729E1 /* SDL_virtualjoystick.c in Sources */,
 				A75FCE2323E25AB700529352 /* SDL_cocoametalview.m in Sources */,
 				A75FCE2423E25AB700529352 /* SDL_audiotypecvt.c in Sources */,
@@ -8227,6 +7482,7 @@
 				A75FCE3523E25AB700529352 /* SDL_error.c in Sources */,
 				A75FCE3623E25AB700529352 /* SDL_blit.c in Sources */,
 				A75FCE3723E25AB700529352 /* SDL_rwops.c in Sources */,
+				F38233922738EBF300F7F527 /* SDL_hidapi.c in Sources */,
 				A75FCE3823E25AB700529352 /* SDL_uikitviewcontroller.m in Sources */,
 				A75FCE3923E25AB700529352 /* s_cos.c in Sources */,
 				A75FCE3A23E25AB700529352 /* SDL_yuv_sw.c in Sources */,
@@ -8235,15 +7491,10 @@
 				A75FCE3D23E25AB700529352 /* SDL_hints.c in Sources */,
 				A75FCE3E23E25AB700529352 /* SDL_hidapi_ps4.c in Sources */,
 				A75FCE3F23E25AB700529352 /* SDL_pixels.c in Sources */,
-				A75FCE4023E25AB700529352 /* SDL_x11clipboard.c in Sources */,
 				A75FCE4123E25AB700529352 /* SDL_sysloadso.c in Sources */,
-				A75FCE4223E25AB700529352 /* SDL_x11xinput2.c in Sources */,
 				A75FCE4323E25AB700529352 /* SDL_syspower.c in Sources */,
-				A75FCE4423E25AB700529352 /* SDL_x11touch.c in Sources */,
 				A75FCE4523E25AB700529352 /* SDL_iconv.c in Sources */,
 				A75FCE4623E25AB700529352 /* s_fabs.c in Sources */,
-				A75FCE4723E25AB700529352 /* SDL_x11shape.c in Sources */,
-				A75FCE4823E25AB700529352 /* imKStoUCS.c in Sources */,
 				A75FCE4923E25AB700529352 /* SDL_shaders_metal.metal in Sources */,
 				F395C1B82569C6A000942BFF /* SDL_mfijoystick.m in Sources */,
 				A75FCE4A23E25AB700529352 /* SDL_uikitwindow.m in Sources */,
@@ -8260,7 +7511,6 @@
 				A75FCE5423E25AB700529352 /* SDL_events.c in Sources */,
 				A75FCE5523E25AB700529352 /* SDL_blit_0.c in Sources */,
 				A75FCE5623E25AB700529352 /* k_tan.c in Sources */,
-				A75FCE5723E25AB700529352 /* SDL_x11vulkan.c in Sources */,
 				A75FCE5823E25AB700529352 /* SDL_diskaudio.c in Sources */,
 				A75FCE5923E25AB700529352 /* SDL_egl.c in Sources */,
 				A75FCE5A23E25AB700529352 /* SDL_RLEaccel.c in Sources */,
@@ -8275,7 +7525,6 @@
 				A75FCE6323E25AB700529352 /* SDL_string.c in Sources */,
 				A75FCE6423E25AB700529352 /* SDL_render_gl.c in Sources */,
 				A75FCE6523E25AB700529352 /* SDL_uikitopengles.m in Sources */,
-				A75FCE6623E25AB700529352 /* SDL_x11opengles.c in Sources */,
 				A75FCE6723E25AB700529352 /* SDL_cocoamodes.m in Sources */,
 				A75FCE6823E25AB700529352 /* k_rem_pio2.c in Sources */,
 				A75FCE6A23E25AB700529352 /* SDL_gesture.c in Sources */,
@@ -8286,7 +7535,6 @@
 				A75FCE6F23E25AB700529352 /* SDL_surface.c in Sources */,
 				A75FCE7023E25AB700529352 /* SDL_hidapi_xboxone.c in Sources */,
 				A75FCE7123E25AB700529352 /* SDL_blit_auto.c in Sources */,
-				A75FCE7223E25AB700529352 /* SDL_x11keyboard.c in Sources */,
 				A75FCE7323E25AB700529352 /* SDL_keyboard.c in Sources */,
 				A75FCE7523E25AB700529352 /* SDL_rect.c in Sources */,
 				A75FCE7623E25AB700529352 /* SDL_cocoaopengles.m in Sources */,
@@ -8295,7 +7543,6 @@
 				A75FCE7823E25AB700529352 /* SDL_hidapi_switch.c in Sources */,
 				A75FCE7923E25AB700529352 /* SDL_strtokr.c in Sources */,
 				A75FCE7A23E25AB700529352 /* SDL_clipboardevents.c in Sources */,
-				A75FCE7B23E25AB700529352 /* SDL_x11framebuffer.c in Sources */,
 				A75FCE7C23E25AB700529352 /* k_cos.c in Sources */,
 				A75FCE7D23E25AB700529352 /* SDL_hidapijoystick.c in Sources */,
 				A75FCE7E23E25AB700529352 /* SDL_malloc.c in Sources */,
@@ -8309,6 +7556,7 @@
 				A75FCE8623E25AB700529352 /* SDL_cocoawindow.m in Sources */,
 				A75FCE8723E25AB700529352 /* SDL_sysmutex.c in Sources */,
 				A75FCE8823E25AB700529352 /* SDL_syshaptic.c in Sources */,
+				F3F07D61269640160074468B /* SDL_hidapi_luna.c in Sources */,
 				A75FCE8923E25AB700529352 /* SDL_rwopsbundlesupport.m in Sources */,
 				A75FCE8A23E25AB700529352 /* SDL_video.c in Sources */,
 				A75FCE8B23E25AB700529352 /* SDL_offscreenopengl.c in Sources */,
@@ -8316,7 +7564,6 @@
 				A75FCE8D23E25AB700529352 /* SDL_steamcontroller.c in Sources */,
 				A75FCE8E23E25AB700529352 /* SDL_shaders_gles2.c in Sources */,
 				A75FCE8F23E25AB700529352 /* SDL_blit_1.c in Sources */,
-				A75FCE9023E25AB700529352 /* SDL_x11dyn.c in Sources */,
 				A75FCE9123E25AB700529352 /* SDL_mouse.c in Sources */,
 				A75FCE9223E25AB700529352 /* e_rem_pio2.c in Sources */,
 				A75FCE9323E25AB700529352 /* SDL_dataqueue.c in Sources */,
@@ -8324,15 +7571,12 @@
 				A75FCE9423E25AB700529352 /* SDL_sysjoystick.c in Sources */,
 				A75FCE9523E25AB700529352 /* SDL_cpuinfo.c in Sources */,
 				A75FCE9623E25AB700529352 /* SDL_sensor.c in Sources */,
-				A75FCE9723E25AB700529352 /* SDL_x11window.c in Sources */,
 				A75FCE9823E25AB700529352 /* k_sin.c in Sources */,
-				A75FCE9923E25AB700529352 /* edid-parse.c in Sources */,
 				A75FCE9A23E25AB700529352 /* SDL_systimer.c in Sources */,
 				A75FCE9B23E25AB700529352 /* SDL_drawpoint.c in Sources */,
 				A75FCE9C23E25AB700529352 /* e_sqrt.c in Sources */,
 				A75FCE9D23E25AB700529352 /* SDL_cocoavideo.m in Sources */,
 				A75FCE9F23E25AB700529352 /* SDL.c in Sources */,
-				A75FCEA023E25AB700529352 /* SDL_x11opengl.c in Sources */,
 				A75FCEA123E25AB700529352 /* SDL_cocoavulkan.m in Sources */,
 				A75FCEA223E25AB700529352 /* SDL_uikitappdelegate.m in Sources */,
 				A75FCEA323E25AB700529352 /* SDL_offscreenwindow.c in Sources */,
@@ -8358,20 +7602,18 @@
 				A75FCFAB23E25AC700529352 /* SDL_render_metal.m in Sources */,
 				A75FCFAC23E25AC700529352 /* SDL_clipboard.c in Sources */,
 				A75FCFAD23E25AC700529352 /* SDL_cocoaevents.m in Sources */,
-				A75FCFAE23E25AC700529352 /* SDL_x11messagebox.c in Sources */,
 				A75FCFAF23E25AC700529352 /* SDL_audiocvt.c in Sources */,
 				A75FCFB023E25AC700529352 /* SDL_shape.c in Sources */,
 				A75FCFB123E25AC700529352 /* SDL_rotate.c in Sources */,
 				A75FCFB223E25AC700529352 /* SDL_coremotionsensor.m in Sources */,
 				A75FDAB223E2795C00529352 /* SDL_hidapi_steam.c in Sources */,
 				A75FCFB323E25AC700529352 /* SDL_touch.c in Sources */,
-				A75FCFB423E25AC700529352 /* SDL_x11events.c in Sources */,
+				A1626A462617006A003F1973 /* SDL_triangle.c in Sources */,
 				A75FCFB523E25AC700529352 /* SDL_uikitmessagebox.m in Sources */,
 				A75FCFB623E25AC700529352 /* SDL_thread.c in Sources */,
 				A75FCFB723E25AC700529352 /* SDL_hidapi_xbox360w.c in Sources */,
 				A75FCFB823E25AC700529352 /* SDL_atomic.c in Sources */,
 				A75FCFB923E25AC700529352 /* SDL_displayevents.c in Sources */,
-				A75FCFBA23E25AC700529352 /* SDL_cocoamousetap.m in Sources */,
 				A75FCFBB23E25AC700529352 /* SDL_log.c in Sources */,
 				A75FCFBC23E25AC700529352 /* SDL_cocoaopengl.m in Sources */,
 				A75FCFBD23E25AC700529352 /* SDL_offscreenframebuffer.c in Sources */,
@@ -8386,14 +7628,13 @@
 				A75FCFC623E25AC700529352 /* SDL_systimer.c in Sources */,
 				A75FCFC723E25AC700529352 /* SDL_uikitclipboard.m in Sources */,
 				A75FCFC823E25AC700529352 /* SDL_render_sw.c in Sources */,
-				A75FCFC923E25AC700529352 /* SDL_x11video.c in Sources */,
 				A75FCFCA23E25AC700529352 /* SDL_syssem.c in Sources */,
 				A75FCFCB23E25AC700529352 /* SDL_hidapi_xbox360.c in Sources */,
 				A75FCFCC23E25AC700529352 /* SDL_coreaudio.m in Sources */,
 				A75FCFCD23E25AC700529352 /* SDL_blendline.c in Sources */,
+				F38233992738EC1800F7F527 /* hid.m in Sources */,
 				A75FCFCE23E25AC700529352 /* SDL_blit_A.c in Sources */,
 				A75FCFCF23E25AC700529352 /* SDL_d3dmath.c in Sources */,
-				A75FCFD023E25AC700529352 /* SDL_x11mouse.c in Sources */,
 				A75FCFD123E25AC700529352 /* SDL_nullvideo.c in Sources */,
 				A75FCFD223E25AC700529352 /* SDL_offscreenevents.c in Sources */,
 				A75FCFD323E25AC700529352 /* SDL_uikitview.m in Sources */,
@@ -8404,7 +7645,7 @@
 				A75FCFD823E25AC700529352 /* s_copysign.c in Sources */,
 				A75FCFD923E25AC700529352 /* SDL_haptic.c in Sources */,
 				A75FCFDA23E25AC700529352 /* SDL_uikitvulkan.m in Sources */,
-				A75FCFDB23E25AC700529352 /* SDL_x11modes.c in Sources */,
+				F3984CD825BCC92900374F43 /* SDL_hidapi_stadia.c in Sources */,
 				75E09162241EA924004729E1 /* SDL_virtualjoystick.c in Sources */,
 				A75FCFDC23E25AC700529352 /* SDL_cocoametalview.m in Sources */,
 				A75FCFDD23E25AC700529352 /* SDL_audiotypecvt.c in Sources */,
@@ -8428,6 +7669,7 @@
 				A75FCFEE23E25AC700529352 /* SDL_error.c in Sources */,
 				A75FCFEF23E25AC700529352 /* SDL_blit.c in Sources */,
 				A75FCFF023E25AC700529352 /* SDL_rwops.c in Sources */,
+				F38233932738EBF300F7F527 /* SDL_hidapi.c in Sources */,
 				A75FCFF123E25AC700529352 /* SDL_uikitviewcontroller.m in Sources */,
 				A75FCFF223E25AC700529352 /* s_cos.c in Sources */,
 				A75FCFF323E25AC700529352 /* SDL_yuv_sw.c in Sources */,
@@ -8436,15 +7678,10 @@
 				A75FCFF623E25AC700529352 /* SDL_hints.c in Sources */,
 				A75FCFF723E25AC700529352 /* SDL_hidapi_ps4.c in Sources */,
 				A75FCFF823E25AC700529352 /* SDL_pixels.c in Sources */,
-				A75FCFF923E25AC700529352 /* SDL_x11clipboard.c in Sources */,
 				A75FCFFA23E25AC700529352 /* SDL_sysloadso.c in Sources */,
-				A75FCFFB23E25AC700529352 /* SDL_x11xinput2.c in Sources */,
 				A75FCFFC23E25AC700529352 /* SDL_syspower.c in Sources */,
-				A75FCFFD23E25AC700529352 /* SDL_x11touch.c in Sources */,
 				A75FCFFE23E25AC700529352 /* SDL_iconv.c in Sources */,
 				A75FCFFF23E25AC700529352 /* s_fabs.c in Sources */,
-				A75FD00023E25AC700529352 /* SDL_x11shape.c in Sources */,
-				A75FD00123E25AC700529352 /* imKStoUCS.c in Sources */,
 				A75FD00223E25AC700529352 /* SDL_shaders_metal.metal in Sources */,
 				F395C1B92569C6A000942BFF /* SDL_mfijoystick.m in Sources */,
 				A75FD00323E25AC700529352 /* SDL_uikitwindow.m in Sources */,
@@ -8461,7 +7698,6 @@
 				A75FD00D23E25AC700529352 /* SDL_events.c in Sources */,
 				A75FD00E23E25AC700529352 /* SDL_blit_0.c in Sources */,
 				A75FD00F23E25AC700529352 /* k_tan.c in Sources */,
-				A75FD01023E25AC700529352 /* SDL_x11vulkan.c in Sources */,
 				A75FD01123E25AC700529352 /* SDL_diskaudio.c in Sources */,
 				A75FD01223E25AC700529352 /* SDL_egl.c in Sources */,
 				A75FD01323E25AC700529352 /* SDL_RLEaccel.c in Sources */,
@@ -8476,7 +7712,6 @@
 				A75FD01C23E25AC700529352 /* SDL_string.c in Sources */,
 				A75FD01D23E25AC700529352 /* SDL_render_gl.c in Sources */,
 				A75FD01E23E25AC700529352 /* SDL_uikitopengles.m in Sources */,
-				A75FD01F23E25AC700529352 /* SDL_x11opengles.c in Sources */,
 				A75FD02023E25AC700529352 /* SDL_cocoamodes.m in Sources */,
 				A75FD02123E25AC700529352 /* k_rem_pio2.c in Sources */,
 				A75FD02323E25AC700529352 /* SDL_gesture.c in Sources */,
@@ -8487,7 +7722,6 @@
 				A75FD02823E25AC700529352 /* SDL_surface.c in Sources */,
 				A75FD02923E25AC700529352 /* SDL_hidapi_xboxone.c in Sources */,
 				A75FD02A23E25AC700529352 /* SDL_blit_auto.c in Sources */,
-				A75FD02B23E25AC700529352 /* SDL_x11keyboard.c in Sources */,
 				A75FD02C23E25AC700529352 /* SDL_keyboard.c in Sources */,
 				A75FD02E23E25AC700529352 /* SDL_rect.c in Sources */,
 				A75FD02F23E25AC700529352 /* SDL_cocoaopengles.m in Sources */,
@@ -8496,7 +7730,6 @@
 				A75FD03123E25AC700529352 /* SDL_hidapi_switch.c in Sources */,
 				A75FD03223E25AC700529352 /* SDL_strtokr.c in Sources */,
 				A75FD03323E25AC700529352 /* SDL_clipboardevents.c in Sources */,
-				A75FD03423E25AC700529352 /* SDL_x11framebuffer.c in Sources */,
 				A75FD03523E25AC700529352 /* k_cos.c in Sources */,
 				A75FD03623E25AC700529352 /* SDL_hidapijoystick.c in Sources */,
 				A75FD03723E25AC700529352 /* SDL_malloc.c in Sources */,
@@ -8510,6 +7743,7 @@
 				A75FD03F23E25AC700529352 /* SDL_cocoawindow.m in Sources */,
 				A75FD04023E25AC700529352 /* SDL_sysmutex.c in Sources */,
 				A75FD04123E25AC700529352 /* SDL_syshaptic.c in Sources */,
+				F3F07D62269640160074468B /* SDL_hidapi_luna.c in Sources */,
 				A75FD04223E25AC700529352 /* SDL_rwopsbundlesupport.m in Sources */,
 				A75FD04323E25AC700529352 /* SDL_video.c in Sources */,
 				A75FD04423E25AC700529352 /* SDL_offscreenopengl.c in Sources */,
@@ -8517,7 +7751,6 @@
 				A75FD04623E25AC700529352 /* SDL_steamcontroller.c in Sources */,
 				A75FD04723E25AC700529352 /* SDL_shaders_gles2.c in Sources */,
 				A75FD04823E25AC700529352 /* SDL_blit_1.c in Sources */,
-				A75FD04923E25AC700529352 /* SDL_x11dyn.c in Sources */,
 				A75FD04A23E25AC700529352 /* SDL_mouse.c in Sources */,
 				A75FD04B23E25AC700529352 /* e_rem_pio2.c in Sources */,
 				A75FD04C23E25AC700529352 /* SDL_dataqueue.c in Sources */,
@@ -8525,45 +7758,18 @@
 				A75FD04D23E25AC700529352 /* SDL_sysjoystick.c in Sources */,
 				A75FD04E23E25AC700529352 /* SDL_cpuinfo.c in Sources */,
 				A75FD04F23E25AC700529352 /* SDL_sensor.c in Sources */,
-				A75FD05023E25AC700529352 /* SDL_x11window.c in Sources */,
 				A75FD05123E25AC700529352 /* k_sin.c in Sources */,
-				A75FD05223E25AC700529352 /* edid-parse.c in Sources */,
 				A75FD05323E25AC700529352 /* SDL_systimer.c in Sources */,
 				A75FD05423E25AC700529352 /* SDL_drawpoint.c in Sources */,
 				A75FD05523E25AC700529352 /* e_sqrt.c in Sources */,
 				A75FD05623E25AC700529352 /* SDL_cocoavideo.m in Sources */,
 				A75FD05823E25AC700529352 /* SDL.c in Sources */,
-				A75FD05923E25AC700529352 /* SDL_x11opengl.c in Sources */,
 				A75FD05A23E25AC700529352 /* SDL_cocoavulkan.m in Sources */,
 				A75FD05B23E25AC700529352 /* SDL_uikitappdelegate.m in Sources */,
 				A75FD05C23E25AC700529352 /* SDL_offscreenwindow.c in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
-		A75FDB4523E399AC00529352 /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				A75FDB5323E39D1C00529352 /* hid.m in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		A75FDB6523E3A2C900529352 /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				A75FDB6623E3A2C900529352 /* hid.m in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		A75FDB8323E4C74400529352 /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				A75FDB9323E4C8DB00529352 /* hid.c in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
 		A769B17023E259AE00872273 /* Sources */ = {
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
@@ -8581,19 +7787,16 @@
 				A769B17A23E259AE00872273 /* SDL_render_metal.m in Sources */,
 				A769B17B23E259AE00872273 /* SDL_clipboard.c in Sources */,
 				A769B17C23E259AE00872273 /* SDL_cocoaevents.m in Sources */,
-				A769B17D23E259AE00872273 /* SDL_x11messagebox.c in Sources */,
 				A769B17E23E259AE00872273 /* SDL_audiocvt.c in Sources */,
 				A769B17F23E259AE00872273 /* SDL_shape.c in Sources */,
 				A769B18023E259AE00872273 /* SDL_rotate.c in Sources */,
 				A769B18123E259AE00872273 /* SDL_coremotionsensor.m in Sources */,
 				A769B18223E259AE00872273 /* SDL_touch.c in Sources */,
-				A769B18423E259AE00872273 /* SDL_x11events.c in Sources */,
 				A769B18523E259AE00872273 /* SDL_uikitmessagebox.m in Sources */,
 				A769B18623E259AE00872273 /* SDL_thread.c in Sources */,
 				A769B18723E259AE00872273 /* SDL_hidapi_xbox360w.c in Sources */,
 				A769B18823E259AE00872273 /* SDL_atomic.c in Sources */,
 				A769B18923E259AE00872273 /* SDL_displayevents.c in Sources */,
-				A769B18A23E259AE00872273 /* SDL_cocoamousetap.m in Sources */,
 				A769B18B23E259AE00872273 /* SDL_log.c in Sources */,
 				A769B18C23E259AE00872273 /* SDL_cocoaopengl.m in Sources */,
 				A769B18D23E259AE00872273 /* SDL_offscreenframebuffer.c in Sources */,
@@ -8608,14 +7811,12 @@
 				A769B19623E259AE00872273 /* SDL_systimer.c in Sources */,
 				A769B19723E259AE00872273 /* SDL_uikitclipboard.m in Sources */,
 				A769B19823E259AE00872273 /* SDL_render_sw.c in Sources */,
-				A769B19923E259AE00872273 /* SDL_x11video.c in Sources */,
 				A769B19A23E259AE00872273 /* SDL_syssem.c in Sources */,
 				A769B19B23E259AE00872273 /* SDL_hidapi_xbox360.c in Sources */,
 				A769B19C23E259AE00872273 /* SDL_coreaudio.m in Sources */,
 				A769B19D23E259AE00872273 /* SDL_blendline.c in Sources */,
 				A769B19E23E259AE00872273 /* SDL_blit_A.c in Sources */,
 				A769B19F23E259AE00872273 /* SDL_d3dmath.c in Sources */,
-				A769B1A023E259AE00872273 /* SDL_x11mouse.c in Sources */,
 				A769B1A123E259AE00872273 /* SDL_nullvideo.c in Sources */,
 				A769B1A223E259AE00872273 /* SDL_offscreenevents.c in Sources */,
 				A769B1A323E259AE00872273 /* SDL_uikitview.m in Sources */,
@@ -8626,7 +7827,6 @@
 				A769B1A823E259AE00872273 /* s_copysign.c in Sources */,
 				A769B1A923E259AE00872273 /* SDL_haptic.c in Sources */,
 				A769B1AA23E259AE00872273 /* SDL_uikitvulkan.m in Sources */,
-				A769B1AB23E259AE00872273 /* SDL_x11modes.c in Sources */,
 				A769B1AC23E259AE00872273 /* SDL_cocoametalview.m in Sources */,
 				A769B1AD23E259AE00872273 /* SDL_audiotypecvt.c in Sources */,
 				A769B1AE23E259AE00872273 /* SDL_uikitevents.m in Sources */,
@@ -8640,6 +7840,7 @@
 				A769B1B523E259AE00872273 /* SDL_cocoakeyboard.m in Sources */,
 				A769B1B623E259AE00872273 /* SDL_dynapi.c in Sources */,
 				A769B1B723E259AE00872273 /* SDL_shaders_gl.c in Sources */,
+				F38233912738EBF100F7F527 /* SDL_hidapi.c in Sources */,
 				A769B1B823E259AE00872273 /* e_log.c in Sources */,
 				A769B1B923E259AE00872273 /* SDL_cocoamessagebox.m in Sources */,
 				A769B1BA23E259AE00872273 /* SDL_blendfillrect.c in Sources */,
@@ -8659,15 +7860,10 @@
 				F3A490A32554D38600E92A8B /* SDL_hidapi_ps5.c in Sources */,
 				A769B1C823E259AE00872273 /* SDL_hidapi_ps4.c in Sources */,
 				A769B1C923E259AE00872273 /* SDL_pixels.c in Sources */,
-				A769B1CA23E259AE00872273 /* SDL_x11clipboard.c in Sources */,
 				A769B1CB23E259AE00872273 /* SDL_sysloadso.c in Sources */,
-				A769B1CC23E259AE00872273 /* SDL_x11xinput2.c in Sources */,
 				A769B1CD23E259AE00872273 /* SDL_syspower.c in Sources */,
-				A769B1CE23E259AE00872273 /* SDL_x11touch.c in Sources */,
 				A769B1CF23E259AE00872273 /* SDL_iconv.c in Sources */,
 				A769B1D023E259AE00872273 /* s_fabs.c in Sources */,
-				A769B1D123E259AE00872273 /* SDL_x11shape.c in Sources */,
-				A769B1D223E259AE00872273 /* imKStoUCS.c in Sources */,
 				A769B1D323E259AE00872273 /* SDL_shaders_metal.metal in Sources */,
 				5616CA5E252BB35E005D5928 /* SDL_url.c in Sources */,
 				A769B1D423E259AE00872273 /* SDL_uikitwindow.m in Sources */,
@@ -8683,7 +7879,6 @@
 				A769B1DE23E259AE00872273 /* SDL_events.c in Sources */,
 				A769B1DF23E259AE00872273 /* SDL_blit_0.c in Sources */,
 				A769B1E023E259AE00872273 /* k_tan.c in Sources */,
-				A769B1E123E259AE00872273 /* SDL_x11vulkan.c in Sources */,
 				A769B1E223E259AE00872273 /* SDL_diskaudio.c in Sources */,
 				A769B1E423E259AE00872273 /* SDL_egl.c in Sources */,
 				A769B1E523E259AE00872273 /* SDL_RLEaccel.c in Sources */,
@@ -8691,6 +7886,7 @@
 				A769B1E823E259AE00872273 /* SDL_bmp.c in Sources */,
 				75E0915F241EA924004729E1 /* SDL_virtualjoystick.c in Sources */,
 				A769B1E923E259AE00872273 /* SDL_uikit_main.c in Sources */,
+				F3F07D5F269640160074468B /* SDL_hidapi_luna.c in Sources */,
 				A769B1EA23E259AE00872273 /* SDL_stdlib.c in Sources */,
 				A769B1EB23E259AE00872273 /* SDL_dummyaudio.c in Sources */,
 				A769B1EC23E259AE00872273 /* SDL_fillrect.c in Sources */,
@@ -8699,7 +7895,6 @@
 				A769B1EF23E259AE00872273 /* SDL_string.c in Sources */,
 				A769B1F023E259AE00872273 /* SDL_render_gl.c in Sources */,
 				A769B1F123E259AE00872273 /* SDL_uikitopengles.m in Sources */,
-				A769B1F223E259AE00872273 /* SDL_x11opengles.c in Sources */,
 				A769B1F323E259AE00872273 /* SDL_cocoamodes.m in Sources */,
 				A769B1F423E259AE00872273 /* k_rem_pio2.c in Sources */,
 				A769B1F623E259AE00872273 /* SDL_gesture.c in Sources */,
@@ -8711,17 +7906,16 @@
 				F395BF6A25633B2400942BFF /* SDL_crc32.c in Sources */,
 				A769B1FC23E259AE00872273 /* SDL_hidapi_xboxone.c in Sources */,
 				A769B1FD23E259AE00872273 /* SDL_blit_auto.c in Sources */,
-				A769B1FE23E259AE00872273 /* SDL_x11keyboard.c in Sources */,
 				A769B1FF23E259AE00872273 /* SDL_keyboard.c in Sources */,
 				560572132473688200B46B66 /* SDL_locale.c in Sources */,
 				A769B20123E259AE00872273 /* SDL_rect.c in Sources */,
 				A769B20223E259AE00872273 /* SDL_cocoaopengles.m in Sources */,
 				A769B20323E259AE00872273 /* SDL_qsort.c in Sources */,
 				A769B20423E259AE00872273 /* SDL_hidapi_switch.c in Sources */,
+				F3984CD525BCC92900374F43 /* SDL_hidapi_stadia.c in Sources */,
 				A769B20523E259AE00872273 /* SDL_strtokr.c in Sources */,
 				5605720B2473687A00B46B66 /* SDL_syslocale.m in Sources */,
 				A769B20623E259AE00872273 /* SDL_clipboardevents.c in Sources */,
-				A769B20723E259AE00872273 /* SDL_x11framebuffer.c in Sources */,
 				A769B20823E259AE00872273 /* k_cos.c in Sources */,
 				A769B20923E259AE00872273 /* SDL_hidapijoystick.c in Sources */,
 				A769B20A23E259AE00872273 /* SDL_malloc.c in Sources */,
@@ -8740,28 +7934,26 @@
 				A769B21523E259AE00872273 /* SDL_rwopsbundlesupport.m in Sources */,
 				A769B21623E259AE00872273 /* SDL_video.c in Sources */,
 				A769B21723E259AE00872273 /* SDL_offscreenopengl.c in Sources */,
+				F38233972738EC1600F7F527 /* hid.m in Sources */,
 				A769B21823E259AE00872273 /* SDL_uikitmetalview.m in Sources */,
 				A769B21923E259AE00872273 /* SDL_shaders_gles2.c in Sources */,
 				A769B21A23E259AE00872273 /* SDL_blit_1.c in Sources */,
-				A769B21B23E259AE00872273 /* SDL_x11dyn.c in Sources */,
 				A769B21C23E259AE00872273 /* SDL_mouse.c in Sources */,
 				A769B21D23E259AE00872273 /* e_rem_pio2.c in Sources */,
 				A769B21E23E259AE00872273 /* SDL_dataqueue.c in Sources */,
 				A769B21F23E259AE00872273 /* SDL_sysjoystick.c in Sources */,
 				A769B22023E259AE00872273 /* SDL_cpuinfo.c in Sources */,
 				A769B22123E259AE00872273 /* SDL_sensor.c in Sources */,
-				A769B22223E259AE00872273 /* SDL_x11window.c in Sources */,
 				A769B22323E259AE00872273 /* k_sin.c in Sources */,
-				A769B22423E259AE00872273 /* edid-parse.c in Sources */,
 				A769B22523E259AE00872273 /* SDL_systimer.c in Sources */,
 				A769B22623E259AE00872273 /* SDL_drawpoint.c in Sources */,
 				F395C1B62569C6A000942BFF /* SDL_mfijoystick.m in Sources */,
 				A769B22723E259AE00872273 /* e_sqrt.c in Sources */,
 				A769B22823E259AE00872273 /* SDL_cocoavideo.m in Sources */,
 				A769B22923E259AE00872273 /* SDL.c in Sources */,
-				A769B22A23E259AE00872273 /* SDL_x11opengl.c in Sources */,
 				A769B22B23E259AE00872273 /* SDL_cocoavulkan.m in Sources */,
 				A769B22C23E259AE00872273 /* SDL_uikitappdelegate.m in Sources */,
+				A1626A432617006A003F1973 /* SDL_triangle.c in Sources */,
 				A769B22D23E259AE00872273 /* SDL_offscreenwindow.c in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
@@ -8784,19 +7976,17 @@
 				A7D8AE7723E2514100DCD162 /* SDL_clipboard.c in Sources */,
 				75E0915B241EA924004729E1 /* SDL_virtualjoystick.c in Sources */,
 				A7D8AEC523E2514100DCD162 /* SDL_cocoaevents.m in Sources */,
-				A7D8B1BF23E2514200DCD162 /* SDL_x11messagebox.c in Sources */,
 				A7D8B86723E2514400DCD162 /* SDL_audiocvt.c in Sources */,
 				A7D8B3AB23E2514200DCD162 /* SDL_shape.c in Sources */,
 				A7D8B9F623E2514400DCD162 /* SDL_rotate.c in Sources */,
 				A7D8A97623E2514000DCD162 /* SDL_coremotionsensor.m in Sources */,
 				A7D8BB8E23E2514500DCD162 /* SDL_touch.c in Sources */,
-				A7D8B19B23E2514200DCD162 /* SDL_x11events.c in Sources */,
 				A7D8AC5223E2514100DCD162 /* SDL_uikitmessagebox.m in Sources */,
 				A7D8B3F323E2514300DCD162 /* SDL_thread.c in Sources */,
+				A1626A3F2617006A003F1973 /* SDL_triangle.c in Sources */,
 				A7D8B55E23E2514300DCD162 /* SDL_hidapi_xbox360w.c in Sources */,
 				A7D8A95823E2514000DCD162 /* SDL_atomic.c in Sources */,
 				A7D8BB2823E2514500DCD162 /* SDL_displayevents.c in Sources */,
-				A7D8AF1923E2514100DCD162 /* SDL_cocoamousetap.m in Sources */,
 				A7D8AB2623E2514100DCD162 /* SDL_log.c in Sources */,
 				A7D8AE8923E2514100DCD162 /* SDL_cocoaopengl.m in Sources */,
 				A7D8AB7423E2514100DCD162 /* SDL_offscreenframebuffer.c in Sources */,
@@ -8811,14 +8001,13 @@
 				A7D8AB3823E2514100DCD162 /* SDL_systimer.c in Sources */,
 				A7D8ACAC23E2514100DCD162 /* SDL_uikitclipboard.m in Sources */,
 				A7D8BA1423E2514400DCD162 /* SDL_render_sw.c in Sources */,
-				A7D8B18F23E2514200DCD162 /* SDL_x11video.c in Sources */,
 				A7D8B42323E2514300DCD162 /* SDL_syssem.c in Sources */,
 				A7D8B53A23E2514300DCD162 /* SDL_hidapi_xbox360.c in Sources */,
 				A7D8B8D323E2514400DCD162 /* SDL_coreaudio.m in Sources */,
 				A7D8BA2023E2514400DCD162 /* SDL_blendline.c in Sources */,
 				A7D8ADF323E2514100DCD162 /* SDL_blit_A.c in Sources */,
 				A7D8BA3823E2514400DCD162 /* SDL_d3dmath.c in Sources */,
-				A7D8B17723E2514200DCD162 /* SDL_x11mouse.c in Sources */,
+				F38233942738EC1400F7F527 /* hid.m in Sources */,
 				A7D8ABEC23E2514100DCD162 /* SDL_nullvideo.c in Sources */,
 				A7D8AB6823E2514100DCD162 /* SDL_offscreenevents.c in Sources */,
 				A7D8ACA623E2514100DCD162 /* SDL_uikitview.m in Sources */,
@@ -8829,9 +8018,9 @@
 				A7D8BA9823E2514400DCD162 /* s_copysign.c in Sources */,
 				A7D8AAB723E2514100DCD162 /* SDL_haptic.c in Sources */,
 				A7D8AC8E23E2514100DCD162 /* SDL_uikitvulkan.m in Sources */,
-				A7D8B15323E2514200DCD162 /* SDL_x11modes.c in Sources */,
 				A7D8AF2523E2514100DCD162 /* SDL_cocoametalview.m in Sources */,
 				A7D8B86123E2514400DCD162 /* SDL_audiotypecvt.c in Sources */,
+				F3984CD125BCC92900374F43 /* SDL_hidapi_stadia.c in Sources */,
 				A7D8AC5823E2514100DCD162 /* SDL_uikitevents.m in Sources */,
 				A7D8ACB823E2514100DCD162 /* SDL_uikitmodes.m in Sources */,
 				A7D8AD3323E2514100DCD162 /* SDL_blit_N.c in Sources */,
@@ -8855,21 +8044,17 @@
 				A7D8BA9223E2514400DCD162 /* s_cos.c in Sources */,
 				A7D8B4D123E2514300DCD162 /* SDL_steamcontroller.c in Sources */,
 				A7D8B9D223E2514400DCD162 /* SDL_yuv_sw.c in Sources */,
+				F382338E2738EBEC00F7F527 /* SDL_hidapi.c in Sources */,
 				A7D8B76B23E2514300DCD162 /* SDL_wave.c in Sources */,
 				A7D8BAD423E2514500DCD162 /* s_tan.c in Sources */,
 				A7D8AA6623E2514000DCD162 /* SDL_hints.c in Sources */,
 				A7D8B54023E2514300DCD162 /* SDL_hidapi_ps4.c in Sources */,
 				A7D8AD6F23E2514100DCD162 /* SDL_pixels.c in Sources */,
 				5616CA52252BB35A005D5928 /* SDL_url.c in Sources */,
-				A7D8B1A123E2514200DCD162 /* SDL_x11clipboard.c in Sources */,
 				A7D8B75F23E2514300DCD162 /* SDL_sysloadso.c in Sources */,
-				A7D8B16B23E2514200DCD162 /* SDL_x11xinput2.c in Sources */,
 				A7D8B5F423E2514300DCD162 /* SDL_syspower.c in Sources */,
-				A7D8B1C523E2514200DCD162 /* SDL_x11touch.c in Sources */,
 				A7D8B95123E2514400DCD162 /* SDL_iconv.c in Sources */,
 				A7D8BA9E23E2514400DCD162 /* s_fabs.c in Sources */,
-				A7D8B1E323E2514200DCD162 /* SDL_x11shape.c in Sources */,
-				A7D8B19523E2514200DCD162 /* imKStoUCS.c in Sources */,
 				A7D8B99323E2514400DCD162 /* SDL_shaders_metal.metal in Sources */,
 				A7D8AC4C23E2514100DCD162 /* SDL_uikitwindow.m in Sources */,
 				A7D8B97B23E2514400DCD162 /* SDL_render.c in Sources */,
@@ -8886,7 +8071,6 @@
 				A7D8ADE723E2514100DCD162 /* SDL_blit_0.c in Sources */,
 				A7D8BB0A23E2514500DCD162 /* k_tan.c in Sources */,
 				A75FDBCF23EA380300529352 /* SDL_hidapi_rumble.c in Sources */,
-				A7D8B15F23E2514200DCD162 /* SDL_x11vulkan.c in Sources */,
 				A7D8B8A923E2514400DCD162 /* SDL_diskaudio.c in Sources */,
 				A7D8AFC123E2514200DCD162 /* SDL_egl.c in Sources */,
 				A7D8AC3423E2514100DCD162 /* SDL_RLEaccel.c in Sources */,
@@ -8901,7 +8085,6 @@
 				A7D8BA8023E2514400DCD162 /* SDL_render_gl.c in Sources */,
 				F3ADAB8E2576F0B400A6B1D9 /* SDL_sysurl.m in Sources */,
 				A7D8AC8223E2514100DCD162 /* SDL_uikitopengles.m in Sources */,
-				A7D8B20123E2514200DCD162 /* SDL_x11opengles.c in Sources */,
 				A7D8AE9523E2514100DCD162 /* SDL_cocoamodes.m in Sources */,
 				A7D8BAA423E2514400DCD162 /* k_rem_pio2.c in Sources */,
 				A7D8BB9A23E2514500DCD162 /* SDL_gesture.c in Sources */,
@@ -8912,7 +8095,6 @@
 				A7D8AC2E23E2514100DCD162 /* SDL_surface.c in Sources */,
 				A7D8B54C23E2514300DCD162 /* SDL_hidapi_xboxone.c in Sources */,
 				A7D8AD2423E2514100DCD162 /* SDL_blit_auto.c in Sources */,
-				A7D8B1A723E2514200DCD162 /* SDL_x11keyboard.c in Sources */,
 				A7D8BB6A23E2514500DCD162 /* SDL_keyboard.c in Sources */,
 				A7D8ACE823E2514100DCD162 /* SDL_rect.c in Sources */,
 				A7D8AE9B23E2514100DCD162 /* SDL_cocoaopengles.m in Sources */,
@@ -8920,7 +8102,6 @@
 				A7D8B55223E2514300DCD162 /* SDL_hidapi_switch.c in Sources */,
 				A7D8B96323E2514400DCD162 /* SDL_strtokr.c in Sources */,
 				A7D8BB7623E2514500DCD162 /* SDL_clipboardevents.c in Sources */,
-				A7D8B18323E2514200DCD162 /* SDL_x11framebuffer.c in Sources */,
 				A7D8BAB623E2514400DCD162 /* k_cos.c in Sources */,
 				A7D8B54623E2514300DCD162 /* SDL_hidapijoystick.c in Sources */,
 				A7D8B97523E2514400DCD162 /* SDL_malloc.c in Sources */,
@@ -8937,13 +8118,13 @@
 				A7D8B5CA23E2514300DCD162 /* SDL_rwopsbundlesupport.m in Sources */,
 				A7D8AC1023E2514100DCD162 /* SDL_video.c in Sources */,
 				560572062473687700B46B66 /* SDL_syslocale.m in Sources */,
+				F3F07D5B269640160074468B /* SDL_hidapi_luna.c in Sources */,
 				A7D8AB5623E2514100DCD162 /* SDL_offscreenopengl.c in Sources */,
 				A7D8ACC423E2514100DCD162 /* SDL_uikitmetalview.m in Sources */,
 				A7D8BA5C23E2514400DCD162 /* SDL_shaders_gles2.c in Sources */,
 				A7D8B14123E2514200DCD162 /* SDL_blit_1.c in Sources */,
 				5605720F2473688000B46B66 /* SDL_locale.c in Sources */,
 				F3A4909F2554D38600E92A8B /* SDL_hidapi_ps5.c in Sources */,
-				A7D8B17D23E2514200DCD162 /* SDL_x11dyn.c in Sources */,
 				A7D8BB1623E2514500DCD162 /* SDL_mouse.c in Sources */,
 				A7D8BADA23E2514500DCD162 /* e_rem_pio2.c in Sources */,
 				A7D8BB1023E2514500DCD162 /* SDL_dataqueue.c in Sources */,
@@ -8951,16 +8132,13 @@
 				F395C19D2569C68F00942BFF /* SDL_iokitjoystick.c in Sources */,
 				A7D8B3E123E2514300DCD162 /* SDL_cpuinfo.c in Sources */,
 				A7D8A99423E2514000DCD162 /* SDL_sensor.c in Sources */,
-				A7D8B18923E2514200DCD162 /* SDL_x11window.c in Sources */,
 				A75FDAAD23E2795C00529352 /* SDL_hidapi_steam.c in Sources */,
 				A7D8BAAA23E2514400DCD162 /* k_sin.c in Sources */,
-				A7D8B1CB23E2514200DCD162 /* edid-parse.c in Sources */,
 				A7D8AB4A23E2514100DCD162 /* SDL_systimer.c in Sources */,
 				A7D8BA2623E2514400DCD162 /* SDL_drawpoint.c in Sources */,
 				A7D8BAF823E2514500DCD162 /* e_sqrt.c in Sources */,
 				A7D8AEAD23E2514100DCD162 /* SDL_cocoavideo.m in Sources */,
 				A7D8A94C23E2514000DCD162 /* SDL.c in Sources */,
-				A7D8B15923E2514200DCD162 /* SDL_x11opengl.c in Sources */,
 				A7D8AEA123E2514100DCD162 /* SDL_cocoavulkan.m in Sources */,
 				A7D8AC6423E2514100DCD162 /* SDL_uikitappdelegate.m in Sources */,
 				A7D8AB6223E2514100DCD162 /* SDL_offscreenwindow.c in Sources */,
@@ -8985,19 +8163,17 @@
 				A7D8AE7823E2514100DCD162 /* SDL_clipboard.c in Sources */,
 				75E0915C241EA924004729E1 /* SDL_virtualjoystick.c in Sources */,
 				A7D8AEC623E2514100DCD162 /* SDL_cocoaevents.m in Sources */,
-				A7D8B1C023E2514200DCD162 /* SDL_x11messagebox.c in Sources */,
 				A7D8B86823E2514400DCD162 /* SDL_audiocvt.c in Sources */,
 				A7D8B3AC23E2514200DCD162 /* SDL_shape.c in Sources */,
 				A7D8B9F723E2514400DCD162 /* SDL_rotate.c in Sources */,
 				A7D8A97723E2514000DCD162 /* SDL_coremotionsensor.m in Sources */,
 				A7D8BB8F23E2514500DCD162 /* SDL_touch.c in Sources */,
-				A7D8B19C23E2514200DCD162 /* SDL_x11events.c in Sources */,
 				A7D8AC5323E2514100DCD162 /* SDL_uikitmessagebox.m in Sources */,
 				A7D8B3F423E2514300DCD162 /* SDL_thread.c in Sources */,
+				A1626A402617006A003F1973 /* SDL_triangle.c in Sources */,
 				A7D8B55F23E2514300DCD162 /* SDL_hidapi_xbox360w.c in Sources */,
 				A7D8A95923E2514000DCD162 /* SDL_atomic.c in Sources */,
 				A7D8BB2923E2514500DCD162 /* SDL_displayevents.c in Sources */,
-				A7D8AF1A23E2514100DCD162 /* SDL_cocoamousetap.m in Sources */,
 				A7D8AB2723E2514100DCD162 /* SDL_log.c in Sources */,
 				A7D8AE8A23E2514100DCD162 /* SDL_cocoaopengl.m in Sources */,
 				A7D8AB7523E2514100DCD162 /* SDL_offscreenframebuffer.c in Sources */,
@@ -9012,14 +8188,13 @@
 				A7D8AB3923E2514100DCD162 /* SDL_systimer.c in Sources */,
 				A7D8ACAD23E2514100DCD162 /* SDL_uikitclipboard.m in Sources */,
 				A7D8BA1523E2514400DCD162 /* SDL_render_sw.c in Sources */,
-				A7D8B19023E2514200DCD162 /* SDL_x11video.c in Sources */,
 				A7D8B42423E2514300DCD162 /* SDL_syssem.c in Sources */,
 				A7D8B53B23E2514300DCD162 /* SDL_hidapi_xbox360.c in Sources */,
 				A7D8B8D423E2514400DCD162 /* SDL_coreaudio.m in Sources */,
 				A7D8BA2123E2514400DCD162 /* SDL_blendline.c in Sources */,
 				A7D8ADF423E2514100DCD162 /* SDL_blit_A.c in Sources */,
 				A7D8BA3923E2514400DCD162 /* SDL_d3dmath.c in Sources */,
-				A7D8B17823E2514200DCD162 /* SDL_x11mouse.c in Sources */,
+				F38233952738EC1500F7F527 /* hid.m in Sources */,
 				A7D8ABED23E2514100DCD162 /* SDL_nullvideo.c in Sources */,
 				A7D8AB6923E2514100DCD162 /* SDL_offscreenevents.c in Sources */,
 				A7D8ACA723E2514100DCD162 /* SDL_uikitview.m in Sources */,
@@ -9030,9 +8205,9 @@
 				A7D8BA9923E2514400DCD162 /* s_copysign.c in Sources */,
 				A7D8AAB823E2514100DCD162 /* SDL_haptic.c in Sources */,
 				A7D8AC8F23E2514100DCD162 /* SDL_uikitvulkan.m in Sources */,
-				A7D8B15423E2514200DCD162 /* SDL_x11modes.c in Sources */,
 				A7D8AF2623E2514100DCD162 /* SDL_cocoametalview.m in Sources */,
 				A7D8B86223E2514400DCD162 /* SDL_audiotypecvt.c in Sources */,
+				F3984CD225BCC92900374F43 /* SDL_hidapi_stadia.c in Sources */,
 				A7D8AC5923E2514100DCD162 /* SDL_uikitevents.m in Sources */,
 				A7D8ACB923E2514100DCD162 /* SDL_uikitmodes.m in Sources */,
 				A7D8AD3423E2514100DCD162 /* SDL_blit_N.c in Sources */,
@@ -9056,21 +8231,17 @@
 				A7D8BA9323E2514400DCD162 /* s_cos.c in Sources */,
 				A7D8B4D223E2514300DCD162 /* SDL_steamcontroller.c in Sources */,
 				A7D8B9D323E2514400DCD162 /* SDL_yuv_sw.c in Sources */,
+				F382338F2738EBEF00F7F527 /* SDL_hidapi.c in Sources */,
 				A7D8B76C23E2514300DCD162 /* SDL_wave.c in Sources */,
 				A7D8BAD523E2514500DCD162 /* s_tan.c in Sources */,
 				A7D8AA6723E2514000DCD162 /* SDL_hints.c in Sources */,
 				A7D8B54123E2514300DCD162 /* SDL_hidapi_ps4.c in Sources */,
 				A7D8AD7023E2514100DCD162 /* SDL_pixels.c in Sources */,
-				A7D8B1A223E2514200DCD162 /* SDL_x11clipboard.c in Sources */,
 				5616CA55252BB35B005D5928 /* SDL_url.c in Sources */,
 				A7D8B76023E2514300DCD162 /* SDL_sysloadso.c in Sources */,
-				A7D8B16C23E2514200DCD162 /* SDL_x11xinput2.c in Sources */,
 				A7D8B5F523E2514300DCD162 /* SDL_syspower.c in Sources */,
-				A7D8B1C623E2514200DCD162 /* SDL_x11touch.c in Sources */,
 				A7D8B95223E2514400DCD162 /* SDL_iconv.c in Sources */,
 				A7D8BA9F23E2514400DCD162 /* s_fabs.c in Sources */,
-				A7D8B1E423E2514200DCD162 /* SDL_x11shape.c in Sources */,
-				A7D8B19623E2514200DCD162 /* imKStoUCS.c in Sources */,
 				A7D8B99423E2514400DCD162 /* SDL_shaders_metal.metal in Sources */,
 				A7D8AC4D23E2514100DCD162 /* SDL_uikitwindow.m in Sources */,
 				A7D8B97C23E2514400DCD162 /* SDL_render.c in Sources */,
@@ -9086,7 +8257,6 @@
 				A7D8BB5923E2514500DCD162 /* SDL_events.c in Sources */,
 				A7D8ADE823E2514100DCD162 /* SDL_blit_0.c in Sources */,
 				A7D8BB0B23E2514500DCD162 /* k_tan.c in Sources */,
-				A7D8B16023E2514200DCD162 /* SDL_x11vulkan.c in Sources */,
 				A75FDBD023EA380300529352 /* SDL_hidapi_rumble.c in Sources */,
 				A7D8B8AA23E2514400DCD162 /* SDL_diskaudio.c in Sources */,
 				A7D8AFC223E2514200DCD162 /* SDL_egl.c in Sources */,
@@ -9102,7 +8272,6 @@
 				A7D8BA8123E2514400DCD162 /* SDL_render_gl.c in Sources */,
 				F3ADAB8F2576F0B400A6B1D9 /* SDL_sysurl.m in Sources */,
 				A7D8AC8323E2514100DCD162 /* SDL_uikitopengles.m in Sources */,
-				A7D8B20223E2514200DCD162 /* SDL_x11opengles.c in Sources */,
 				A7D8AE9623E2514100DCD162 /* SDL_cocoamodes.m in Sources */,
 				A7D8BAA523E2514400DCD162 /* k_rem_pio2.c in Sources */,
 				A7D8BB9B23E2514500DCD162 /* SDL_gesture.c in Sources */,
@@ -9113,7 +8282,6 @@
 				A7D8AC2F23E2514100DCD162 /* SDL_surface.c in Sources */,
 				A7D8B54D23E2514300DCD162 /* SDL_hidapi_xboxone.c in Sources */,
 				A7D8AD2523E2514100DCD162 /* SDL_blit_auto.c in Sources */,
-				A7D8B1A823E2514200DCD162 /* SDL_x11keyboard.c in Sources */,
 				A7D8BB6B23E2514500DCD162 /* SDL_keyboard.c in Sources */,
 				A7D8ACE923E2514100DCD162 /* SDL_rect.c in Sources */,
 				A7D8AE9C23E2514100DCD162 /* SDL_cocoaopengles.m in Sources */,
@@ -9121,7 +8289,6 @@
 				A7D8B55323E2514300DCD162 /* SDL_hidapi_switch.c in Sources */,
 				A7D8B96423E2514400DCD162 /* SDL_strtokr.c in Sources */,
 				A7D8BB7723E2514500DCD162 /* SDL_clipboardevents.c in Sources */,
-				A7D8B18423E2514200DCD162 /* SDL_x11framebuffer.c in Sources */,
 				A7D8BAB723E2514400DCD162 /* k_cos.c in Sources */,
 				A7D8B54723E2514300DCD162 /* SDL_hidapijoystick.c in Sources */,
 				A7D8B97623E2514400DCD162 /* SDL_malloc.c in Sources */,
@@ -9138,13 +8305,13 @@
 				A7D8B5CB23E2514300DCD162 /* SDL_rwopsbundlesupport.m in Sources */,
 				A7D8AC1123E2514100DCD162 /* SDL_video.c in Sources */,
 				560572072473687800B46B66 /* SDL_syslocale.m in Sources */,
+				F3F07D5C269640160074468B /* SDL_hidapi_luna.c in Sources */,
 				A7D8AB5723E2514100DCD162 /* SDL_offscreenopengl.c in Sources */,
 				A7D8ACC523E2514100DCD162 /* SDL_uikitmetalview.m in Sources */,
 				A7D8BA5D23E2514400DCD162 /* SDL_shaders_gles2.c in Sources */,
 				A7D8B14223E2514200DCD162 /* SDL_blit_1.c in Sources */,
 				560572102473688000B46B66 /* SDL_locale.c in Sources */,
 				F3A490A02554D38600E92A8B /* SDL_hidapi_ps5.c in Sources */,
-				A7D8B17E23E2514200DCD162 /* SDL_x11dyn.c in Sources */,
 				A7D8BB1723E2514500DCD162 /* SDL_mouse.c in Sources */,
 				A7D8BADB23E2514500DCD162 /* e_rem_pio2.c in Sources */,
 				A7D8BB1123E2514500DCD162 /* SDL_dataqueue.c in Sources */,
@@ -9152,16 +8319,13 @@
 				F395C19E2569C68F00942BFF /* SDL_iokitjoystick.c in Sources */,
 				A7D8B3E223E2514300DCD162 /* SDL_cpuinfo.c in Sources */,
 				A7D8A99523E2514000DCD162 /* SDL_sensor.c in Sources */,
-				A7D8B18A23E2514200DCD162 /* SDL_x11window.c in Sources */,
 				A75FDAAE23E2795C00529352 /* SDL_hidapi_steam.c in Sources */,
 				A7D8BAAB23E2514400DCD162 /* k_sin.c in Sources */,
-				A7D8B1CC23E2514200DCD162 /* edid-parse.c in Sources */,
 				A7D8AB4B23E2514100DCD162 /* SDL_systimer.c in Sources */,
 				A7D8BA2723E2514400DCD162 /* SDL_drawpoint.c in Sources */,
 				A7D8BAF923E2514500DCD162 /* e_sqrt.c in Sources */,
 				A7D8AEAE23E2514100DCD162 /* SDL_cocoavideo.m in Sources */,
 				A7D8A94D23E2514000DCD162 /* SDL.c in Sources */,
-				A7D8B15A23E2514200DCD162 /* SDL_x11opengl.c in Sources */,
 				A7D8AEA223E2514100DCD162 /* SDL_cocoavulkan.m in Sources */,
 				A7D8AC6523E2514100DCD162 /* SDL_uikitappdelegate.m in Sources */,
 				A7D8AB6323E2514100DCD162 /* SDL_offscreenwindow.c in Sources */,
@@ -9185,19 +8349,16 @@
 				A7D8B98A23E2514400DCD162 /* SDL_render_metal.m in Sources */,
 				A7D8AE7A23E2514100DCD162 /* SDL_clipboard.c in Sources */,
 				A7D8AEC823E2514100DCD162 /* SDL_cocoaevents.m in Sources */,
-				A7D8B1C223E2514200DCD162 /* SDL_x11messagebox.c in Sources */,
 				A7D8B86A23E2514400DCD162 /* SDL_audiocvt.c in Sources */,
 				A7D8B3AE23E2514200DCD162 /* SDL_shape.c in Sources */,
 				A7D8B9F923E2514400DCD162 /* SDL_rotate.c in Sources */,
 				A7D8A97923E2514000DCD162 /* SDL_coremotionsensor.m in Sources */,
 				A7D8BB9123E2514500DCD162 /* SDL_touch.c in Sources */,
-				A7D8B19E23E2514200DCD162 /* SDL_x11events.c in Sources */,
 				A7D8AC5523E2514100DCD162 /* SDL_uikitmessagebox.m in Sources */,
 				A7D8B3F623E2514300DCD162 /* SDL_thread.c in Sources */,
 				A7D8B56123E2514300DCD162 /* SDL_hidapi_xbox360w.c in Sources */,
 				A7D8A95B23E2514000DCD162 /* SDL_atomic.c in Sources */,
 				A7D8BB2B23E2514500DCD162 /* SDL_displayevents.c in Sources */,
-				A7D8AF1C23E2514100DCD162 /* SDL_cocoamousetap.m in Sources */,
 				A7D8AB2923E2514100DCD162 /* SDL_log.c in Sources */,
 				A7D8AE8C23E2514100DCD162 /* SDL_cocoaopengl.m in Sources */,
 				A7D8AB7723E2514100DCD162 /* SDL_offscreenframebuffer.c in Sources */,
@@ -9212,14 +8373,12 @@
 				A7D8AB3B23E2514100DCD162 /* SDL_systimer.c in Sources */,
 				A7D8ACAF23E2514100DCD162 /* SDL_uikitclipboard.m in Sources */,
 				A7D8BA1723E2514400DCD162 /* SDL_render_sw.c in Sources */,
-				A7D8B19223E2514200DCD162 /* SDL_x11video.c in Sources */,
 				A7D8B42623E2514300DCD162 /* SDL_syssem.c in Sources */,
 				A7D8B53D23E2514300DCD162 /* SDL_hidapi_xbox360.c in Sources */,
 				A7D8B8D623E2514400DCD162 /* SDL_coreaudio.m in Sources */,
 				A7D8BA2323E2514400DCD162 /* SDL_blendline.c in Sources */,
 				A7D8ADF623E2514100DCD162 /* SDL_blit_A.c in Sources */,
 				A7D8BA3B23E2514400DCD162 /* SDL_d3dmath.c in Sources */,
-				A7D8B17A23E2514200DCD162 /* SDL_x11mouse.c in Sources */,
 				A7D8ABEF23E2514100DCD162 /* SDL_nullvideo.c in Sources */,
 				A7D8AB6B23E2514100DCD162 /* SDL_offscreenevents.c in Sources */,
 				A7D8ACA923E2514100DCD162 /* SDL_uikitview.m in Sources */,
@@ -9230,7 +8389,6 @@
 				A7D8BA9B23E2514400DCD162 /* s_copysign.c in Sources */,
 				A7D8AABA23E2514100DCD162 /* SDL_haptic.c in Sources */,
 				A7D8AC9123E2514100DCD162 /* SDL_uikitvulkan.m in Sources */,
-				A7D8B15623E2514200DCD162 /* SDL_x11modes.c in Sources */,
 				A7D8AF2823E2514100DCD162 /* SDL_cocoametalview.m in Sources */,
 				A7D8B86423E2514400DCD162 /* SDL_audiotypecvt.c in Sources */,
 				A7D8AC5B23E2514100DCD162 /* SDL_uikitevents.m in Sources */,
@@ -9244,6 +8402,7 @@
 				A7D8AEDA23E2514100DCD162 /* SDL_cocoakeyboard.m in Sources */,
 				A7D8AB1A23E2514100DCD162 /* SDL_dynapi.c in Sources */,
 				A7D8BA8923E2514400DCD162 /* SDL_shaders_gl.c in Sources */,
+				F38233902738EBF000F7F527 /* SDL_hidapi.c in Sources */,
 				A7D8BAF523E2514500DCD162 /* e_log.c in Sources */,
 				A7D8AED423E2514100DCD162 /* SDL_cocoamessagebox.m in Sources */,
 				A7D8BA2F23E2514400DCD162 /* SDL_blendfillrect.c in Sources */,
@@ -9263,15 +8422,10 @@
 				F3A490A22554D38600E92A8B /* SDL_hidapi_ps5.c in Sources */,
 				A7D8B54323E2514300DCD162 /* SDL_hidapi_ps4.c in Sources */,
 				A7D8AD7223E2514100DCD162 /* SDL_pixels.c in Sources */,
-				A7D8B1A423E2514200DCD162 /* SDL_x11clipboard.c in Sources */,
 				A7D8B76223E2514300DCD162 /* SDL_sysloadso.c in Sources */,
-				A7D8B16E23E2514200DCD162 /* SDL_x11xinput2.c in Sources */,
 				A7D8B5F723E2514300DCD162 /* SDL_syspower.c in Sources */,
-				A7D8B1C823E2514200DCD162 /* SDL_x11touch.c in Sources */,
 				A7D8B95423E2514400DCD162 /* SDL_iconv.c in Sources */,
 				A7D8BAA123E2514400DCD162 /* s_fabs.c in Sources */,
-				A7D8B1E623E2514200DCD162 /* SDL_x11shape.c in Sources */,
-				A7D8B19823E2514200DCD162 /* imKStoUCS.c in Sources */,
 				A7D8B99623E2514400DCD162 /* SDL_shaders_metal.metal in Sources */,
 				5616CA5B252BB35D005D5928 /* SDL_url.c in Sources */,
 				A7D8AC4F23E2514100DCD162 /* SDL_uikitwindow.m in Sources */,
@@ -9287,7 +8441,6 @@
 				A7D8BB5B23E2514500DCD162 /* SDL_events.c in Sources */,
 				A7D8ADEA23E2514100DCD162 /* SDL_blit_0.c in Sources */,
 				A7D8BB0D23E2514500DCD162 /* k_tan.c in Sources */,
-				A7D8B16223E2514200DCD162 /* SDL_x11vulkan.c in Sources */,
 				A7D8B8AC23E2514400DCD162 /* SDL_diskaudio.c in Sources */,
 				A7D8AFC423E2514200DCD162 /* SDL_egl.c in Sources */,
 				A7D8AC3723E2514100DCD162 /* SDL_RLEaccel.c in Sources */,
@@ -9295,6 +8448,7 @@
 				A7D8B3DE23E2514300DCD162 /* SDL_bmp.c in Sources */,
 				75E0915E241EA924004729E1 /* SDL_virtualjoystick.c in Sources */,
 				A7D8BC0723E2590800DCD162 /* SDL_uikit_main.c in Sources */,
+				F3F07D5E269640160074468B /* SDL_hidapi_luna.c in Sources */,
 				A7D8B97223E2514400DCD162 /* SDL_stdlib.c in Sources */,
 				A7D8B79E23E2514400DCD162 /* SDL_dummyaudio.c in Sources */,
 				A7D8B3A823E2514200DCD162 /* SDL_fillrect.c in Sources */,
@@ -9303,7 +8457,6 @@
 				A7D8B96023E2514400DCD162 /* SDL_string.c in Sources */,
 				A7D8BA8323E2514400DCD162 /* SDL_render_gl.c in Sources */,
 				A7D8AC8523E2514100DCD162 /* SDL_uikitopengles.m in Sources */,
-				A7D8B20423E2514200DCD162 /* SDL_x11opengles.c in Sources */,
 				A7D8AE9823E2514100DCD162 /* SDL_cocoamodes.m in Sources */,
 				A7D8BAA723E2514400DCD162 /* k_rem_pio2.c in Sources */,
 				A7D8BB9D23E2514500DCD162 /* SDL_gesture.c in Sources */,
@@ -9315,17 +8468,16 @@
 				F395BF6925633B2400942BFF /* SDL_crc32.c in Sources */,
 				A7D8B54F23E2514300DCD162 /* SDL_hidapi_xboxone.c in Sources */,
 				A7D8AD2723E2514100DCD162 /* SDL_blit_auto.c in Sources */,
-				A7D8B1AA23E2514200DCD162 /* SDL_x11keyboard.c in Sources */,
 				A7D8BB6D23E2514500DCD162 /* SDL_keyboard.c in Sources */,
 				560572122473688200B46B66 /* SDL_locale.c in Sources */,
 				A7D8ACEB23E2514100DCD162 /* SDL_rect.c in Sources */,
 				A7D8AE9E23E2514100DCD162 /* SDL_cocoaopengles.m in Sources */,
 				A7D8B96C23E2514400DCD162 /* SDL_qsort.c in Sources */,
 				A7D8B55523E2514300DCD162 /* SDL_hidapi_switch.c in Sources */,
+				F3984CD425BCC92900374F43 /* SDL_hidapi_stadia.c in Sources */,
 				A7D8B96623E2514400DCD162 /* SDL_strtokr.c in Sources */,
 				560572092473687900B46B66 /* SDL_syslocale.m in Sources */,
 				A7D8BB7923E2514500DCD162 /* SDL_clipboardevents.c in Sources */,
-				A7D8B18623E2514200DCD162 /* SDL_x11framebuffer.c in Sources */,
 				A7D8BAB923E2514400DCD162 /* k_cos.c in Sources */,
 				A7D8B54923E2514300DCD162 /* SDL_hidapijoystick.c in Sources */,
 				A7D8B97823E2514400DCD162 /* SDL_malloc.c in Sources */,
@@ -9344,28 +8496,26 @@
 				A7D8B5CD23E2514300DCD162 /* SDL_rwopsbundlesupport.m in Sources */,
 				A7D8AC1323E2514100DCD162 /* SDL_video.c in Sources */,
 				A7D8AB5923E2514100DCD162 /* SDL_offscreenopengl.c in Sources */,
+				F38233962738EC1600F7F527 /* hid.m in Sources */,
 				A7D8ACC723E2514100DCD162 /* SDL_uikitmetalview.m in Sources */,
 				A7D8BA5F23E2514400DCD162 /* SDL_shaders_gles2.c in Sources */,
 				A7D8B14423E2514200DCD162 /* SDL_blit_1.c in Sources */,
-				A7D8B18023E2514200DCD162 /* SDL_x11dyn.c in Sources */,
 				A7D8BB1923E2514500DCD162 /* SDL_mouse.c in Sources */,
 				A7D8BADD23E2514500DCD162 /* e_rem_pio2.c in Sources */,
 				A7D8BB1323E2514500DCD162 /* SDL_dataqueue.c in Sources */,
 				A7D8B4B623E2514300DCD162 /* SDL_sysjoystick.c in Sources */,
 				A7D8B3E423E2514300DCD162 /* SDL_cpuinfo.c in Sources */,
 				A7D8A99723E2514000DCD162 /* SDL_sensor.c in Sources */,
-				A7D8B18C23E2514200DCD162 /* SDL_x11window.c in Sources */,
 				A7D8BAAD23E2514400DCD162 /* k_sin.c in Sources */,
-				A7D8B1CE23E2514200DCD162 /* edid-parse.c in Sources */,
 				A7D8AB4D23E2514100DCD162 /* SDL_systimer.c in Sources */,
 				A7D8BA2923E2514400DCD162 /* SDL_drawpoint.c in Sources */,
 				F395C1B52569C6A000942BFF /* SDL_mfijoystick.m in Sources */,
 				A7D8BAFB23E2514500DCD162 /* e_sqrt.c in Sources */,
 				A7D8AEB023E2514100DCD162 /* SDL_cocoavideo.m in Sources */,
 				A7D8A94F23E2514000DCD162 /* SDL.c in Sources */,
-				A7D8B15C23E2514200DCD162 /* SDL_x11opengl.c in Sources */,
 				A7D8AEA423E2514100DCD162 /* SDL_cocoavulkan.m in Sources */,
 				A7D8AC6723E2514100DCD162 /* SDL_uikitappdelegate.m in Sources */,
+				A1626A422617006A003F1973 /* SDL_triangle.c in Sources */,
 				A7D8AB6523E2514100DCD162 /* SDL_offscreenwindow.c in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
@@ -9388,7 +8538,6 @@
 				A7D8B98623E2514400DCD162 /* SDL_render_metal.m in Sources */,
 				A7D8AE7623E2514100DCD162 /* SDL_clipboard.c in Sources */,
 				A7D8AEC423E2514100DCD162 /* SDL_cocoaevents.m in Sources */,
-				A7D8B1BE23E2514200DCD162 /* SDL_x11messagebox.c in Sources */,
 				A7D8B86623E2514400DCD162 /* SDL_audiocvt.c in Sources */,
 				A7D8B3AA23E2514200DCD162 /* SDL_shape.c in Sources */,
 				A7D8B9F523E2514400DCD162 /* SDL_rotate.c in Sources */,
@@ -9396,13 +8545,12 @@
 				5616CA4E252BB2A6005D5928 /* SDL_sysurl.m in Sources */,
 				A7D8A97523E2514000DCD162 /* SDL_coremotionsensor.m in Sources */,
 				A7D8BB8D23E2514500DCD162 /* SDL_touch.c in Sources */,
-				A7D8B19A23E2514200DCD162 /* SDL_x11events.c in Sources */,
+				A1626A3E2617006A003F1973 /* SDL_triangle.c in Sources */,
 				A7D8B3F223E2514300DCD162 /* SDL_thread.c in Sources */,
 				A7D8B55D23E2514300DCD162 /* SDL_hidapi_xbox360w.c in Sources */,
 				A7D8A95723E2514000DCD162 /* SDL_atomic.c in Sources */,
 				A75FDBCE23EA380300529352 /* SDL_hidapi_rumble.c in Sources */,
 				A7D8BB2723E2514500DCD162 /* SDL_displayevents.c in Sources */,
-				A7D8AF1823E2514100DCD162 /* SDL_cocoamousetap.m in Sources */,
 				A7D8AB2523E2514100DCD162 /* SDL_log.c in Sources */,
 				A7D8AE8823E2514100DCD162 /* SDL_cocoaopengl.m in Sources */,
 				A7D8AB7323E2514100DCD162 /* SDL_offscreenframebuffer.c in Sources */,
@@ -9416,7 +8564,6 @@
 				A7D8B4EE23E2514300DCD162 /* SDL_gamecontroller.c in Sources */,
 				A7D8AB3723E2514100DCD162 /* SDL_systimer.c in Sources */,
 				A7D8BA1323E2514400DCD162 /* SDL_render_sw.c in Sources */,
-				A7D8B18E23E2514200DCD162 /* SDL_x11video.c in Sources */,
 				A7D8B42223E2514300DCD162 /* SDL_syssem.c in Sources */,
 				A7D8B53923E2514300DCD162 /* SDL_hidapi_xbox360.c in Sources */,
 				A7D8B8D223E2514400DCD162 /* SDL_coreaudio.m in Sources */,
@@ -9425,7 +8572,6 @@
 				A7D8ADF223E2514100DCD162 /* SDL_blit_A.c in Sources */,
 				A7D8BBDD23E2574800DCD162 /* SDL_uikitmodes.m in Sources */,
 				A7D8BA3723E2514400DCD162 /* SDL_d3dmath.c in Sources */,
-				A7D8B17623E2514200DCD162 /* SDL_x11mouse.c in Sources */,
 				75E0915A241EA924004729E1 /* SDL_virtualjoystick.c in Sources */,
 				A7D8ABEB23E2514100DCD162 /* SDL_nullvideo.c in Sources */,
 				A7D8AB6723E2514100DCD162 /* SDL_offscreenevents.c in Sources */,
@@ -9436,8 +8582,8 @@
 				A7D8BBE923E2574800DCD162 /* SDL_uikitvulkan.m in Sources */,
 				A7D8ABCD23E2514100DCD162 /* SDL_blit_slow.c in Sources */,
 				A7D8BA9723E2514400DCD162 /* s_copysign.c in Sources */,
+				F3984CD025BCC92900374F43 /* SDL_hidapi_stadia.c in Sources */,
 				A7D8AAB623E2514100DCD162 /* SDL_haptic.c in Sources */,
-				A7D8B15223E2514200DCD162 /* SDL_x11modes.c in Sources */,
 				A7D8AF2423E2514100DCD162 /* SDL_cocoametalview.m in Sources */,
 				A7D8B86023E2514400DCD162 /* SDL_audiotypecvt.c in Sources */,
 				A7D8BBC523E2561500DCD162 /* SDL_steamcontroller.c in Sources */,
@@ -9469,17 +8615,12 @@
 				A7D8AA6523E2514000DCD162 /* SDL_hints.c in Sources */,
 				A7D8B53F23E2514300DCD162 /* SDL_hidapi_ps4.c in Sources */,
 				A7D8AD6E23E2514100DCD162 /* SDL_pixels.c in Sources */,
-				A7D8B1A023E2514200DCD162 /* SDL_x11clipboard.c in Sources */,
 				A7D8B75E23E2514300DCD162 /* SDL_sysloadso.c in Sources */,
 				A7D8BBD723E2574800DCD162 /* SDL_uikitevents.m in Sources */,
-				A7D8B16A23E2514200DCD162 /* SDL_x11xinput2.c in Sources */,
 				A7D8B5F323E2514300DCD162 /* SDL_syspower.c in Sources */,
-				A7D8B1C423E2514200DCD162 /* SDL_x11touch.c in Sources */,
 				A7D8B95023E2514400DCD162 /* SDL_iconv.c in Sources */,
 				A7D8BA9D23E2514400DCD162 /* s_fabs.c in Sources */,
-				A7D8B1E223E2514200DCD162 /* SDL_x11shape.c in Sources */,
 				F395C1B12569C6A000942BFF /* SDL_mfijoystick.m in Sources */,
-				A7D8B19423E2514200DCD162 /* imKStoUCS.c in Sources */,
 				A7D8B99223E2514400DCD162 /* SDL_shaders_metal.metal in Sources */,
 				A7D8B97A23E2514400DCD162 /* SDL_render.c in Sources */,
 				A7D8ABD323E2514100DCD162 /* SDL_stretch.c in Sources */,
@@ -9492,7 +8633,6 @@
 				A7D8BB5723E2514500DCD162 /* SDL_events.c in Sources */,
 				A7D8ADE623E2514100DCD162 /* SDL_blit_0.c in Sources */,
 				A7D8BB0923E2514500DCD162 /* k_tan.c in Sources */,
-				A7D8B15E23E2514200DCD162 /* SDL_x11vulkan.c in Sources */,
 				A7D8B8A823E2514400DCD162 /* SDL_diskaudio.c in Sources */,
 				566E26CF246274CC00718109 /* SDL_syslocale.m in Sources */,
 				A7D8AFC023E2514200DCD162 /* SDL_egl.c in Sources */,
@@ -9507,7 +8647,6 @@
 				A7D8A96923E2514000DCD162 /* SDL_dummysensor.c in Sources */,
 				A7D8B95C23E2514400DCD162 /* SDL_string.c in Sources */,
 				A7D8BA7F23E2514400DCD162 /* SDL_render_gl.c in Sources */,
-				A7D8B20023E2514200DCD162 /* SDL_x11opengles.c in Sources */,
 				A7D8AE9423E2514100DCD162 /* SDL_cocoamodes.m in Sources */,
 				A7D8BAA323E2514400DCD162 /* k_rem_pio2.c in Sources */,
 				A7D8BB9923E2514500DCD162 /* SDL_gesture.c in Sources */,
@@ -9518,7 +8657,6 @@
 				A7D8AC2D23E2514100DCD162 /* SDL_surface.c in Sources */,
 				A7D8B54B23E2514300DCD162 /* SDL_hidapi_xboxone.c in Sources */,
 				A7D8AD2323E2514100DCD162 /* SDL_blit_auto.c in Sources */,
-				A7D8B1A623E2514200DCD162 /* SDL_x11keyboard.c in Sources */,
 				F3A4909E2554D38600E92A8B /* SDL_hidapi_ps5.c in Sources */,
 				A7D8BB6923E2514500DCD162 /* SDL_keyboard.c in Sources */,
 				A7D8ACE723E2514100DCD162 /* SDL_rect.c in Sources */,
@@ -9527,7 +8665,6 @@
 				A7D8B55123E2514300DCD162 /* SDL_hidapi_switch.c in Sources */,
 				A7D8B96223E2514400DCD162 /* SDL_strtokr.c in Sources */,
 				A7D8BB7523E2514500DCD162 /* SDL_clipboardevents.c in Sources */,
-				A7D8B18223E2514200DCD162 /* SDL_x11framebuffer.c in Sources */,
 				A7D8BAB523E2514400DCD162 /* k_cos.c in Sources */,
 				A7D8B54523E2514300DCD162 /* SDL_hidapijoystick.c in Sources */,
 				A7D8B97423E2514400DCD162 /* SDL_malloc.c in Sources */,
@@ -9541,6 +8678,7 @@
 				A7D8AEA623E2514100DCD162 /* SDL_cocoawindow.m in Sources */,
 				A7D8B43A23E2514300DCD162 /* SDL_sysmutex.c in Sources */,
 				A7D8AAB023E2514100DCD162 /* SDL_syshaptic.c in Sources */,
+				F3F07D5A269640160074468B /* SDL_hidapi_luna.c in Sources */,
 				A7D8BBD523E2574800DCD162 /* SDL_uikitclipboard.m in Sources */,
 				A7D8B5C923E2514300DCD162 /* SDL_rwopsbundlesupport.m in Sources */,
 				A7D8AC0F23E2514100DCD162 /* SDL_video.c in Sources */,
@@ -9548,7 +8686,6 @@
 				A7D8BA5B23E2514400DCD162 /* SDL_shaders_gles2.c in Sources */,
 				A7D8B14023E2514200DCD162 /* SDL_blit_1.c in Sources */,
 				A7D8BBDB23E2574800DCD162 /* SDL_uikitmetalview.m in Sources */,
-				A7D8B17C23E2514200DCD162 /* SDL_x11dyn.c in Sources */,
 				A7D8BB1523E2514500DCD162 /* SDL_mouse.c in Sources */,
 				A7D8BAD923E2514500DCD162 /* e_rem_pio2.c in Sources */,
 				A7D8BB0F23E2514500DCD162 /* SDL_dataqueue.c in Sources */,
@@ -9556,15 +8693,12 @@
 				A7D8B4B223E2514300DCD162 /* SDL_sysjoystick.c in Sources */,
 				A7D8B3E023E2514300DCD162 /* SDL_cpuinfo.c in Sources */,
 				A7D8A99323E2514000DCD162 /* SDL_sensor.c in Sources */,
-				A7D8B18823E2514200DCD162 /* SDL_x11window.c in Sources */,
 				A7D8BAA923E2514400DCD162 /* k_sin.c in Sources */,
-				A7D8B1CA23E2514200DCD162 /* edid-parse.c in Sources */,
 				A7D8AB4923E2514100DCD162 /* SDL_systimer.c in Sources */,
 				A7D8BA2523E2514400DCD162 /* SDL_drawpoint.c in Sources */,
 				A7D8BAF723E2514500DCD162 /* e_sqrt.c in Sources */,
 				A7D8AEAC23E2514100DCD162 /* SDL_cocoavideo.m in Sources */,
 				A7D8A94B23E2514000DCD162 /* SDL.c in Sources */,
-				A7D8B15823E2514200DCD162 /* SDL_x11opengl.c in Sources */,
 				A7D8AEA023E2514100DCD162 /* SDL_cocoavulkan.m in Sources */,
 				A7D8AB6123E2514100DCD162 /* SDL_offscreenwindow.c in Sources */,
 				566E26D8246274CC00718109 /* SDL_locale.c in Sources */,
@@ -9589,21 +8723,19 @@
 				A7D8B98923E2514400DCD162 /* SDL_render_metal.m in Sources */,
 				A7D8AE7923E2514100DCD162 /* SDL_clipboard.c in Sources */,
 				A7D8AEC723E2514100DCD162 /* SDL_cocoaevents.m in Sources */,
-				A7D8B1C123E2514200DCD162 /* SDL_x11messagebox.c in Sources */,
 				A7D8B86923E2514400DCD162 /* SDL_audiocvt.c in Sources */,
 				A7D8B3AD23E2514200DCD162 /* SDL_shape.c in Sources */,
 				A7D8B9F823E2514400DCD162 /* SDL_rotate.c in Sources */,
 				A7D8A97823E2514000DCD162 /* SDL_coremotionsensor.m in Sources */,
 				A7D8BB9023E2514500DCD162 /* SDL_touch.c in Sources */,
-				A7D8B19D23E2514200DCD162 /* SDL_x11events.c in Sources */,
 				A7D8B3F523E2514300DCD162 /* SDL_thread.c in Sources */,
 				A7D8B56023E2514300DCD162 /* SDL_hidapi_xbox360w.c in Sources */,
+				A1626A412617006A003F1973 /* SDL_triangle.c in Sources */,
 				5616CA59252BB35C005D5928 /* SDL_sysurl.m in Sources */,
 				A7D8A95A23E2514000DCD162 /* SDL_atomic.c in Sources */,
 				A75FDBD123EA380300529352 /* SDL_hidapi_rumble.c in Sources */,
 				A7D8BB2A23E2514500DCD162 /* SDL_displayevents.c in Sources */,
 				A7D8BBFC23E2574800DCD162 /* SDL_uikitopenglview.m in Sources */,
-				A7D8AF1B23E2514100DCD162 /* SDL_cocoamousetap.m in Sources */,
 				A7D8AB2823E2514100DCD162 /* SDL_log.c in Sources */,
 				A7D8BC0223E2574800DCD162 /* SDL_uikitviewcontroller.m in Sources */,
 				A7D8AE8B23E2514100DCD162 /* SDL_cocoaopengl.m in Sources */,
@@ -9619,7 +8751,6 @@
 				A7D8B4F123E2514300DCD162 /* SDL_gamecontroller.c in Sources */,
 				A7D8AB3A23E2514100DCD162 /* SDL_systimer.c in Sources */,
 				A7D8BA1623E2514400DCD162 /* SDL_render_sw.c in Sources */,
-				A7D8B19123E2514200DCD162 /* SDL_x11video.c in Sources */,
 				A7D8B42523E2514300DCD162 /* SDL_syssem.c in Sources */,
 				A7D8B53C23E2514300DCD162 /* SDL_hidapi_xbox360.c in Sources */,
 				A7D8B8D523E2514400DCD162 /* SDL_coreaudio.m in Sources */,
@@ -9627,7 +8758,6 @@
 				A7D8BC0623E2574800DCD162 /* SDL_uikitwindow.m in Sources */,
 				A7D8ADF523E2514100DCD162 /* SDL_blit_A.c in Sources */,
 				A7D8BA3A23E2514400DCD162 /* SDL_d3dmath.c in Sources */,
-				A7D8B17923E2514200DCD162 /* SDL_x11mouse.c in Sources */,
 				A7D8ABEE23E2514100DCD162 /* SDL_nullvideo.c in Sources */,
 				A7D8AB6A23E2514100DCD162 /* SDL_offscreenevents.c in Sources */,
 				A7D8ABF423E2514100DCD162 /* SDL_nullevents.c in Sources */,
@@ -9636,7 +8766,7 @@
 				A7D8ABD023E2514100DCD162 /* SDL_blit_slow.c in Sources */,
 				A7D8BA9A23E2514400DCD162 /* s_copysign.c in Sources */,
 				A7D8AAB923E2514100DCD162 /* SDL_haptic.c in Sources */,
-				A7D8B15523E2514200DCD162 /* SDL_x11modes.c in Sources */,
+				F3984CD325BCC92900374F43 /* SDL_hidapi_stadia.c in Sources */,
 				A7D8AF2723E2514100DCD162 /* SDL_cocoametalview.m in Sources */,
 				A7D8B86323E2514400DCD162 /* SDL_audiotypecvt.c in Sources */,
 				A7D8AD3523E2514100DCD162 /* SDL_blit_N.c in Sources */,
@@ -9666,17 +8796,12 @@
 				A7D8AA6823E2514000DCD162 /* SDL_hints.c in Sources */,
 				A7D8B54223E2514300DCD162 /* SDL_hidapi_ps4.c in Sources */,
 				A7D8AD7123E2514100DCD162 /* SDL_pixels.c in Sources */,
-				A7D8B1A323E2514200DCD162 /* SDL_x11clipboard.c in Sources */,
 				A7D8B76123E2514300DCD162 /* SDL_sysloadso.c in Sources */,
-				A7D8B16D23E2514200DCD162 /* SDL_x11xinput2.c in Sources */,
 				A7D8B5F623E2514300DCD162 /* SDL_syspower.c in Sources */,
-				A7D8B1C723E2514200DCD162 /* SDL_x11touch.c in Sources */,
 				A7D8B95323E2514400DCD162 /* SDL_iconv.c in Sources */,
 				560572112473688100B46B66 /* SDL_locale.c in Sources */,
 				A7D8BAA023E2514400DCD162 /* s_fabs.c in Sources */,
-				A7D8B1E523E2514200DCD162 /* SDL_x11shape.c in Sources */,
 				A7D8BC0423E2574800DCD162 /* SDL_uikitvulkan.m in Sources */,
-				A7D8B19723E2514200DCD162 /* imKStoUCS.c in Sources */,
 				A7D8B99523E2514400DCD162 /* SDL_shaders_metal.metal in Sources */,
 				A7D8B97D23E2514400DCD162 /* SDL_render.c in Sources */,
 				F395C1B42569C6A000942BFF /* SDL_mfijoystick.m in Sources */,
@@ -9692,7 +8817,6 @@
 				A7D8ADE923E2514100DCD162 /* SDL_blit_0.c in Sources */,
 				A7D8BB0C23E2514500DCD162 /* k_tan.c in Sources */,
 				A7D8BBF223E2574800DCD162 /* SDL_uikitevents.m in Sources */,
-				A7D8B16123E2514200DCD162 /* SDL_x11vulkan.c in Sources */,
 				A7D8BBB923E2560500DCD162 /* SDL_steamcontroller.c in Sources */,
 				A7D8B8AB23E2514400DCD162 /* SDL_diskaudio.c in Sources */,
 				A7D8AFC323E2514200DCD162 /* SDL_egl.c in Sources */,
@@ -9707,7 +8831,6 @@
 				A7D8A96C23E2514000DCD162 /* SDL_dummysensor.c in Sources */,
 				A7D8B95F23E2514400DCD162 /* SDL_string.c in Sources */,
 				A7D8BA8223E2514400DCD162 /* SDL_render_gl.c in Sources */,
-				A7D8B20323E2514200DCD162 /* SDL_x11opengles.c in Sources */,
 				A7D8AE9723E2514100DCD162 /* SDL_cocoamodes.m in Sources */,
 				A7D8BAA623E2514400DCD162 /* k_rem_pio2.c in Sources */,
 				A7D8BB9C23E2514500DCD162 /* SDL_gesture.c in Sources */,
@@ -9718,7 +8841,6 @@
 				A7D8AC3023E2514100DCD162 /* SDL_surface.c in Sources */,
 				A7D8B54E23E2514300DCD162 /* SDL_hidapi_xboxone.c in Sources */,
 				A7D8AD2623E2514100DCD162 /* SDL_blit_auto.c in Sources */,
-				A7D8B1A923E2514200DCD162 /* SDL_x11keyboard.c in Sources */,
 				A7D8BB6C23E2514500DCD162 /* SDL_keyboard.c in Sources */,
 				A7D8ACEA23E2514100DCD162 /* SDL_rect.c in Sources */,
 				A7D8BC0023E2574800DCD162 /* SDL_uikitview.m in Sources */,
@@ -9727,7 +8849,6 @@
 				A7D8B55423E2514300DCD162 /* SDL_hidapi_switch.c in Sources */,
 				A7D8B96523E2514400DCD162 /* SDL_strtokr.c in Sources */,
 				A7D8BB7823E2514500DCD162 /* SDL_clipboardevents.c in Sources */,
-				A7D8B18523E2514200DCD162 /* SDL_x11framebuffer.c in Sources */,
 				A7D8BAB823E2514400DCD162 /* k_cos.c in Sources */,
 				A7D8B54823E2514300DCD162 /* SDL_hidapijoystick.c in Sources */,
 				A7D8B97723E2514400DCD162 /* SDL_malloc.c in Sources */,
@@ -9742,6 +8863,7 @@
 				A7D8BB8423E2514500DCD162 /* SDL_quit.c in Sources */,
 				A7D8AEA923E2514100DCD162 /* SDL_cocoawindow.m in Sources */,
 				A7D8B43D23E2514300DCD162 /* SDL_sysmutex.c in Sources */,
+				F3F07D5D269640160074468B /* SDL_hidapi_luna.c in Sources */,
 				A7D8AAB323E2514100DCD162 /* SDL_syshaptic.c in Sources */,
 				A7D8B5CC23E2514300DCD162 /* SDL_rwopsbundlesupport.m in Sources */,
 				A7D8AC1223E2514100DCD162 /* SDL_video.c in Sources */,
@@ -9749,7 +8871,6 @@
 				A7D8BA5E23E2514400DCD162 /* SDL_shaders_gles2.c in Sources */,
 				5605720A2473687900B46B66 /* SDL_syslocale.m in Sources */,
 				A7D8B14323E2514200DCD162 /* SDL_blit_1.c in Sources */,
-				A7D8B17F23E2514200DCD162 /* SDL_x11dyn.c in Sources */,
 				A7D8BB1823E2514500DCD162 /* SDL_mouse.c in Sources */,
 				A7D8BADC23E2514500DCD162 /* e_rem_pio2.c in Sources */,
 				A7D8BB1223E2514500DCD162 /* SDL_dataqueue.c in Sources */,
@@ -9757,15 +8878,12 @@
 				F395C19F2569C68F00942BFF /* SDL_iokitjoystick.c in Sources */,
 				A7D8B3E323E2514300DCD162 /* SDL_cpuinfo.c in Sources */,
 				A7D8A99623E2514000DCD162 /* SDL_sensor.c in Sources */,
-				A7D8B18B23E2514200DCD162 /* SDL_x11window.c in Sources */,
 				A7D8BAAC23E2514400DCD162 /* k_sin.c in Sources */,
-				A7D8B1CD23E2514200DCD162 /* edid-parse.c in Sources */,
 				A7D8AB4C23E2514100DCD162 /* SDL_systimer.c in Sources */,
 				A7D8BA2823E2514400DCD162 /* SDL_drawpoint.c in Sources */,
 				A7D8BAFA23E2514500DCD162 /* e_sqrt.c in Sources */,
 				A7D8AEAF23E2514100DCD162 /* SDL_cocoavideo.m in Sources */,
 				A7D8A94E23E2514000DCD162 /* SDL.c in Sources */,
-				A7D8B15B23E2514200DCD162 /* SDL_x11opengl.c in Sources */,
 				A7D8BBF823E2574800DCD162 /* SDL_uikitmodes.m in Sources */,
 				A7D8AEA323E2514100DCD162 /* SDL_cocoavulkan.m in Sources */,
 				A7D8AB6423E2514100DCD162 /* SDL_offscreenwindow.c in Sources */,
@@ -9789,21 +8907,19 @@
 				A7D8B98B23E2514400DCD162 /* SDL_render_metal.m in Sources */,
 				A7D8AE7B23E2514100DCD162 /* SDL_clipboard.c in Sources */,
 				A7D8AEC923E2514100DCD162 /* SDL_cocoaevents.m in Sources */,
-				A7D8B1C323E2514200DCD162 /* SDL_x11messagebox.c in Sources */,
 				A7D8B86B23E2514400DCD162 /* SDL_audiocvt.c in Sources */,
 				A7D8B3AF23E2514200DCD162 /* SDL_shape.c in Sources */,
 				A7D8B9FA23E2514400DCD162 /* SDL_rotate.c in Sources */,
 				A7D8A97A23E2514000DCD162 /* SDL_coremotionsensor.m in Sources */,
 				A7D8BB9223E2514500DCD162 /* SDL_touch.c in Sources */,
-				A7D8B19F23E2514200DCD162 /* SDL_x11events.c in Sources */,
 				A7D8AC5623E2514100DCD162 /* SDL_uikitmessagebox.m in Sources */,
 				A7D8B3F723E2514300DCD162 /* SDL_thread.c in Sources */,
 				A7D8B56223E2514300DCD162 /* SDL_hidapi_xbox360w.c in Sources */,
+				A1626A442617006A003F1973 /* SDL_triangle.c in Sources */,
 				5616CA62252BB35E005D5928 /* SDL_sysurl.m in Sources */,
 				A7D8A95C23E2514000DCD162 /* SDL_atomic.c in Sources */,
 				A75FDBD423EA380300529352 /* SDL_hidapi_rumble.c in Sources */,
 				A7D8BB2C23E2514500DCD162 /* SDL_displayevents.c in Sources */,
-				A7D8AF1D23E2514100DCD162 /* SDL_cocoamousetap.m in Sources */,
 				A7D8AB2A23E2514100DCD162 /* SDL_log.c in Sources */,
 				A7D8AE8D23E2514100DCD162 /* SDL_cocoaopengl.m in Sources */,
 				A7D8AB7823E2514100DCD162 /* SDL_offscreenframebuffer.c in Sources */,
@@ -9819,14 +8935,12 @@
 				A7D8AB3C23E2514100DCD162 /* SDL_systimer.c in Sources */,
 				A7D8ACB023E2514100DCD162 /* SDL_uikitclipboard.m in Sources */,
 				A7D8BA1823E2514400DCD162 /* SDL_render_sw.c in Sources */,
-				A7D8B19323E2514200DCD162 /* SDL_x11video.c in Sources */,
 				A7D8B42723E2514300DCD162 /* SDL_syssem.c in Sources */,
 				A7D8B53E23E2514300DCD162 /* SDL_hidapi_xbox360.c in Sources */,
 				A7D8B8D723E2514400DCD162 /* SDL_coreaudio.m in Sources */,
 				A7D8BA2423E2514400DCD162 /* SDL_blendline.c in Sources */,
 				A7D8ADF723E2514100DCD162 /* SDL_blit_A.c in Sources */,
 				A7D8BA3C23E2514400DCD162 /* SDL_d3dmath.c in Sources */,
-				A7D8B17B23E2514200DCD162 /* SDL_x11mouse.c in Sources */,
 				A7D8ABF023E2514100DCD162 /* SDL_nullvideo.c in Sources */,
 				A7D8AB6C23E2514100DCD162 /* SDL_offscreenevents.c in Sources */,
 				A7D8ACAA23E2514100DCD162 /* SDL_uikitview.m in Sources */,
@@ -9837,7 +8951,7 @@
 				A7D8BA9C23E2514400DCD162 /* s_copysign.c in Sources */,
 				A7D8AABB23E2514100DCD162 /* SDL_haptic.c in Sources */,
 				A7D8AC9223E2514100DCD162 /* SDL_uikitvulkan.m in Sources */,
-				A7D8B15723E2514200DCD162 /* SDL_x11modes.c in Sources */,
+				F3984CD625BCC92900374F43 /* SDL_hidapi_stadia.c in Sources */,
 				A7D8AF2923E2514100DCD162 /* SDL_cocoametalview.m in Sources */,
 				A7D8B86523E2514400DCD162 /* SDL_audiotypecvt.c in Sources */,
 				A7D8AC5C23E2514100DCD162 /* SDL_uikitevents.m in Sources */,
@@ -9869,16 +8983,11 @@
 				A7D8AA6A23E2514000DCD162 /* SDL_hints.c in Sources */,
 				A7D8B54423E2514300DCD162 /* SDL_hidapi_ps4.c in Sources */,
 				A7D8AD7323E2514100DCD162 /* SDL_pixels.c in Sources */,
-				A7D8B1A523E2514200DCD162 /* SDL_x11clipboard.c in Sources */,
 				A7D8B76323E2514300DCD162 /* SDL_sysloadso.c in Sources */,
-				A7D8B16F23E2514200DCD162 /* SDL_x11xinput2.c in Sources */,
 				A7D8B5F823E2514300DCD162 /* SDL_syspower.c in Sources */,
 				560572142473688300B46B66 /* SDL_locale.c in Sources */,
-				A7D8B1C923E2514200DCD162 /* SDL_x11touch.c in Sources */,
 				A7D8B95523E2514400DCD162 /* SDL_iconv.c in Sources */,
 				A7D8BAA223E2514400DCD162 /* s_fabs.c in Sources */,
-				A7D8B1E723E2514200DCD162 /* SDL_x11shape.c in Sources */,
-				A7D8B19923E2514200DCD162 /* imKStoUCS.c in Sources */,
 				A7D8B99723E2514400DCD162 /* SDL_shaders_metal.metal in Sources */,
 				F395C1B72569C6A000942BFF /* SDL_mfijoystick.m in Sources */,
 				A7D8AC5023E2514100DCD162 /* SDL_uikitwindow.m in Sources */,
@@ -9894,7 +9003,6 @@
 				A7D8BB5C23E2514500DCD162 /* SDL_events.c in Sources */,
 				A7D8ADEB23E2514100DCD162 /* SDL_blit_0.c in Sources */,
 				A7D8BB0E23E2514500DCD162 /* k_tan.c in Sources */,
-				A7D8B16323E2514200DCD162 /* SDL_x11vulkan.c in Sources */,
 				A7D8B8AD23E2514400DCD162 /* SDL_diskaudio.c in Sources */,
 				A7D8AFC523E2514200DCD162 /* SDL_egl.c in Sources */,
 				A7D8AC3823E2514100DCD162 /* SDL_RLEaccel.c in Sources */,
@@ -9909,7 +9017,6 @@
 				A7D8B96123E2514400DCD162 /* SDL_string.c in Sources */,
 				A7D8BA8423E2514400DCD162 /* SDL_render_gl.c in Sources */,
 				A7D8AC8623E2514100DCD162 /* SDL_uikitopengles.m in Sources */,
-				A7D8B20523E2514200DCD162 /* SDL_x11opengles.c in Sources */,
 				A7D8AE9923E2514100DCD162 /* SDL_cocoamodes.m in Sources */,
 				A7D8BAA823E2514400DCD162 /* k_rem_pio2.c in Sources */,
 				A7D8BB9E23E2514500DCD162 /* SDL_gesture.c in Sources */,
@@ -9920,7 +9027,6 @@
 				A7D8AC3223E2514100DCD162 /* SDL_surface.c in Sources */,
 				A7D8B55023E2514300DCD162 /* SDL_hidapi_xboxone.c in Sources */,
 				A7D8AD2823E2514100DCD162 /* SDL_blit_auto.c in Sources */,
-				A7D8B1AB23E2514200DCD162 /* SDL_x11keyboard.c in Sources */,
 				A7D8BB6E23E2514500DCD162 /* SDL_keyboard.c in Sources */,
 				A7D8ACEC23E2514100DCD162 /* SDL_rect.c in Sources */,
 				A7D8AE9F23E2514100DCD162 /* SDL_cocoaopengles.m in Sources */,
@@ -9928,7 +9034,6 @@
 				A7D8B55623E2514300DCD162 /* SDL_hidapi_switch.c in Sources */,
 				A7D8B96723E2514400DCD162 /* SDL_strtokr.c in Sources */,
 				A7D8BB7A23E2514500DCD162 /* SDL_clipboardevents.c in Sources */,
-				A7D8B18723E2514200DCD162 /* SDL_x11framebuffer.c in Sources */,
 				A7D8BABA23E2514400DCD162 /* k_cos.c in Sources */,
 				A7D8B54A23E2514300DCD162 /* SDL_hidapijoystick.c in Sources */,
 				A7D8B97923E2514400DCD162 /* SDL_malloc.c in Sources */,
@@ -9943,6 +9048,7 @@
 				A7D8B43F23E2514300DCD162 /* SDL_sysmutex.c in Sources */,
 				A7D8AAB523E2514100DCD162 /* SDL_syshaptic.c in Sources */,
 				A7D8B5CE23E2514300DCD162 /* SDL_rwopsbundlesupport.m in Sources */,
+				F3F07D60269640160074468B /* SDL_hidapi_luna.c in Sources */,
 				A7D8AC1423E2514100DCD162 /* SDL_video.c in Sources */,
 				A7D8AB5A23E2514100DCD162 /* SDL_offscreenopengl.c in Sources */,
 				A7D8ACC823E2514100DCD162 /* SDL_uikitmetalview.m in Sources */,
@@ -9950,7 +9056,6 @@
 				A7D8BA6023E2514400DCD162 /* SDL_shaders_gles2.c in Sources */,
 				5605720C2473687B00B46B66 /* SDL_syslocale.m in Sources */,
 				A7D8B14523E2514200DCD162 /* SDL_blit_1.c in Sources */,
-				A7D8B18123E2514200DCD162 /* SDL_x11dyn.c in Sources */,
 				A7D8BB1A23E2514500DCD162 /* SDL_mouse.c in Sources */,
 				A7D8BADE23E2514500DCD162 /* e_rem_pio2.c in Sources */,
 				A7D8BB1423E2514500DCD162 /* SDL_dataqueue.c in Sources */,
@@ -9958,15 +9063,12 @@
 				F395C1A22569C68F00942BFF /* SDL_iokitjoystick.c in Sources */,
 				A7D8B3E523E2514300DCD162 /* SDL_cpuinfo.c in Sources */,
 				A7D8A99823E2514000DCD162 /* SDL_sensor.c in Sources */,
-				A7D8B18D23E2514200DCD162 /* SDL_x11window.c in Sources */,
 				A7D8BAAE23E2514400DCD162 /* k_sin.c in Sources */,
-				A7D8B1CF23E2514200DCD162 /* edid-parse.c in Sources */,
 				A7D8AB4E23E2514100DCD162 /* SDL_systimer.c in Sources */,
 				A7D8BA2A23E2514400DCD162 /* SDL_drawpoint.c in Sources */,
 				A7D8BAFC23E2514500DCD162 /* e_sqrt.c in Sources */,
 				A7D8AEB123E2514100DCD162 /* SDL_cocoavideo.m in Sources */,
 				A7D8A95023E2514000DCD162 /* SDL.c in Sources */,
-				A7D8B15D23E2514200DCD162 /* SDL_x11opengl.c in Sources */,
 				A7D8AEA523E2514100DCD162 /* SDL_cocoavulkan.m in Sources */,
 				A7D8AC6823E2514100DCD162 /* SDL_uikitappdelegate.m in Sources */,
 				A7D8AB6623E2514100DCD162 /* SDL_offscreenwindow.c in Sources */,
@@ -9981,11 +9083,6 @@
 			target = BECDF5FE0761BA81005FE872 /* Framework */;
 			targetProxy = BECDF6C50761BA81005FE872 /* PBXContainerItemProxy */;
 		};
-		F3190017240CA3BA00ED104F /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = A75FDB8023E4C74400529352 /* hidapi */;
-			targetProxy = F3190016240CA3BA00ED104F /* PBXContainerItemProxy */;
-		};
 /* End PBXTargetDependency section */
 
 /* Begin XCBuildConfiguration section */
@@ -10014,7 +9111,7 @@
 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
 				DEPLOYMENT_POSTPROCESSING = YES;
 				DYLIB_COMPATIBILITY_VERSION = 1.0.0;
-				DYLIB_CURRENT_VERSION = 15.0.0;
+				DYLIB_CURRENT_VERSION = 19.3.0;
 				DYLIB_INSTALL_NAME_BASE = "@rpath";
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
 				GCC_ALTIVEC_EXTENSIONS = YES;
@@ -10038,7 +9135,11 @@
 				);
 				INFOPLIST_FILE = "Info-Framework.plist";
 				IPHONEOS_DEPLOYMENT_TARGET = 8.0;
-				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks";
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+					"@loader_path/Frameworks",
+				);
 				MACOSX_DEPLOYMENT_TARGET = 10.6;
 				PRODUCT_BUNDLE_IDENTIFIER = org.libsdl.SDL2;
 				PRODUCT_NAME = SDL2;
@@ -10051,6 +9152,7 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				CLANG_LINK_OBJC_RUNTIME = NO;
+				MARKETING_VERSION = 2.0.17;
 				OTHER_LDFLAGS = "-liconv";
 			};
 			name = Release;
@@ -10093,7 +9195,7 @@
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
 				DEBUG_INFORMATION_FORMAT = dwarf;
 				DYLIB_COMPATIBILITY_VERSION = 1.0.0;
-				DYLIB_CURRENT_VERSION = 15.0.0;
+				DYLIB_CURRENT_VERSION = 19.3.0;
 				DYLIB_INSTALL_NAME_BASE = "@rpath";
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
 				ENABLE_TESTABILITY = YES;
@@ -10117,7 +9219,11 @@
 				);
 				INFOPLIST_FILE = "Info-Framework.plist";
 				IPHONEOS_DEPLOYMENT_TARGET = 8.0;
-				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks";
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+					"@loader_path/Frameworks",
+				);
 				MACOSX_DEPLOYMENT_TARGET = 10.6;
 				ONLY_ACTIVE_ARCH = YES;
 				PRODUCT_BUNDLE_IDENTIFIER = org.libsdl.SDL2;
@@ -10131,6 +9237,7 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				CLANG_LINK_OBJC_RUNTIME = NO;
+				MARKETING_VERSION = 2.0.17;
 				OTHER_LDFLAGS = "-liconv";
 			};
 			name = Debug;
@@ -10158,10 +9265,10 @@
 					"$(inherited)",
 					"$(SDKROOT)/System/iOSSupport/System/Library/Frameworks",
 				);
-				GCC_PREPROCESSOR_DEFINITIONS = "IOS_DYLIB=1";
 				GCC_SYMBOLS_PRIVATE_EXTERN = YES;
 				INSTALL_PATH = "@rpath";
 				SDKROOT = iphoneos;
+				TARGETED_DEVICE_FAMILY = "1,2,6";
 			};
 			name = Debug;
 		};
@@ -10174,10 +9281,10 @@
 					"$(inherited)",
 					"$(SDKROOT)/System/iOSSupport/System/Library/Frameworks",
 				);
-				GCC_PREPROCESSOR_DEFINITIONS = "IOS_DYLIB=1";
 				GCC_SYMBOLS_PRIVATE_EXTERN = YES;
 				INSTALL_PATH = "@rpath";
 				SDKROOT = iphoneos;
+				TARGETED_DEVICE_FAMILY = "1,2,6";
 			};
 			name = Release;
 		};
@@ -10186,7 +9293,6 @@
 			buildSettings = {
 				CLANG_ENABLE_OBJC_ARC = YES;
 				EXECUTABLE_PREFIX = lib;
-				GCC_PREPROCESSOR_DEFINITIONS = "IOS_DYLIB=1";
 				GCC_SYMBOLS_PRIVATE_EXTERN = YES;
 				INSTALL_PATH = "@rpath";
 				SDKROOT = appletvos;
@@ -10198,115 +9304,12 @@
 			buildSettings = {
 				CLANG_ENABLE_OBJC_ARC = YES;
 				EXECUTABLE_PREFIX = lib;
-				GCC_PREPROCESSOR_DEFINITIONS = "IOS_DYLIB=1";
 				GCC_SYMBOLS_PRIVATE_EXTERN = YES;
 				INSTALL_PATH = "@rpath";
 				SDKROOT = appletvos;
 			};
 			name = Release;
 		};
-		A75FDB4E23E399AC00529352 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				CLANG_ENABLE_OBJC_ARC = YES;
-				CLANG_ENABLE_OBJC_WEAK = YES;
-				CURRENT_PROJECT_VERSION = 1.0;
-				DYLIB_COMPATIBILITY_VERSION = 1;
-				DYLIB_CURRENT_VERSION = 1;
-				FRAMEWORK_SEARCH_PATHS = (
-					"$(inherited)",
-					"$(SDKROOT)/System/iOSSupport/System/Library/Frameworks",
-				);
-				GCC_PREPROCESSOR_DEFINITIONS = "HID_API_EXPORT=\"__attribute__ ((visibility(\\\"default\\\")))\"";
-				INFOPLIST_FILE = hidapi/Info.plist;
-				PRODUCT_BUNDLE_IDENTIFIER = org.libsdl.hidapi;
-				PRODUCT_NAME = hidapi;
-				SDKROOT = iphoneos;
-				TARGETED_DEVICE_FAMILY = "1,2";
-			};
-			name = Debug;
-		};
-		A75FDB4F23E399AC00529352 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				CLANG_ENABLE_OBJC_ARC = YES;
-				CLANG_ENABLE_OBJC_WEAK = YES;
-				CURRENT_PROJECT_VERSION = 1.0;
-				DYLIB_COMPATIBILITY_VERSION = 1;
-				DYLIB_CURRENT_VERSION = 1;
-				FRAMEWORK_SEARCH_PATHS = (
-					"$(inherited)",
-					"$(SDKROOT)/System/iOSSupport/System/Library/Frameworks",
-				);
-				GCC_PREPROCESSOR_DEFINITIONS = "HID_API_EXPORT=\"__attribute__ ((visibility(\\\"default\\\")))\"";
-				INFOPLIST_FILE = hidapi/Info.plist;
-				PRODUCT_BUNDLE_IDENTIFIER = org.libsdl.hidapi;
-				PRODUCT_NAME = hidapi;
-				SDKROOT = iphoneos;
-				TARGETED_DEVICE_FAMILY = "1,2";
-			};
-			name = Release;
-		};
-		A75FDB6C23E3A2C900529352 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				CLANG_ENABLE_OBJC_ARC = YES;
-				CLANG_ENABLE_OBJC_WEAK = YES;
-				CURRENT_PROJECT_VERSION = 1.0;
-				DYLIB_COMPATIBILITY_VERSION = 1;
-				DYLIB_CURRENT_VERSION = 1;
-				GCC_PREPROCESSOR_DEFINITIONS = "HID_API_EXPORT=\"__attribute__ ((visibility(\\\"default\\\")))\"";
-				INFOPLIST_FILE = hidapi/Info.plist;
-				PRODUCT_BUNDLE_IDENTIFIER = org.libsdl.hidapi;
-				PRODUCT_NAME = hidapi;
-				SDKROOT = appletvos;
-			};
-			name = Debug;
-		};
-		A75FDB6D23E3A2C900529352 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				CLANG_ENABLE_OBJC_ARC = YES;
-				CLANG_ENABLE_OBJC_WEAK = YES;
-				CURRENT_PROJECT_VERSION = 1.0;
-				DYLIB_COMPATIBILITY_VERSION = 1;
-				DYLIB_CURRENT_VERSION = 1;
-				GCC_PREPROCESSOR_DEFINITIONS = "HID_API_EXPORT=\"__attribute__ ((visibility(\\\"default\\\")))\"";
-				INFOPLIST_FILE = hidapi/Info.plist;
-				PRODUCT_BUNDLE_IDENTIFIER = org.libsdl.hidapi;
-				PRODUCT_NAME = hidapi;
-				SDKROOT = appletvos;
-			};
-			name = Release;
-		};
-		A75FDB8A23E4C74400529352 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				CLANG_ENABLE_OBJC_ARC = YES;
-				CURRENT_PROJECT_VERSION = 1.0;
-				DYLIB_COMPATIBILITY_VERSION = 1;
-				DYLIB_CURRENT_VERSION = 1;
-				GCC_PREPROCESSOR_DEFINITIONS = "HID_API_EXPORT=\"__attribute__ ((visibility(\\\"default\\\")))\"";
-				INFOPLIST_FILE = hidapi/Info.plist;
-				PRODUCT_BUNDLE_IDENTIFIER = org.libsdl.hidapi;
-				PRODUCT_NAME = "$(TARGET_NAME)";
-			};
-			name = Debug;
-		};
-		A75FDB8B23E4C74400529352 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				CLANG_ENABLE_OBJC_ARC = YES;
-				CURRENT_PROJECT_VERSION = 1.0;
-				DYLIB_COMPATIBILITY_VERSION = 1;
-				DYLIB_CURRENT_VERSION = 1;
-				GCC_PREPROCESSOR_DEFINITIONS = "HID_API_EXPORT=\"__attribute__ ((visibility(\\\"default\\\")))\"";
-				INFOPLIST_FILE = hidapi/Info.plist;
-				PRODUCT_BUNDLE_IDENTIFIER = org.libsdl.hidapi;
-				PRODUCT_NAME = "$(TARGET_NAME)";
-			};
-			name = Release;
-		};
 		A769B23B23E259AE00872273 /* Debug */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
@@ -10338,10 +9341,9 @@
 					"$(inherited)",
 					"$(SDKROOT)/System/iOSSupport/System/Library/Frameworks",
 				);
-				GCC_PREPROCESSOR_DEFINITIONS = "IOS_DYLIB=1";
 				OTHER_LDFLAGS = "-liconv";
 				SDKROOT = iphoneos;
-				TARGETED_DEVICE_FAMILY = "1,2";
+				TARGETED_DEVICE_FAMILY = "1,2,6";
 			};
 			name = Debug;
 		};
@@ -10354,10 +9356,9 @@
 					"$(inherited)",
 					"$(SDKROOT)/System/iOSSupport/System/Library/Frameworks",
 				);
-				GCC_PREPROCESSOR_DEFINITIONS = "IOS_DYLIB=1";
 				OTHER_LDFLAGS = "-liconv";
 				SDKROOT = iphoneos;
-				TARGETED_DEVICE_FAMILY = "1,2";
+				TARGETED_DEVICE_FAMILY = "1,2,6";
 			};
 			name = Release;
 		};
@@ -10366,7 +9367,6 @@
 			buildSettings = {
 				CLANG_ENABLE_OBJC_ARC = YES;
 				CLANG_LINK_OBJC_RUNTIME = NO;
-				GCC_PREPROCESSOR_DEFINITIONS = "IOS_DYLIB=1";
 				OTHER_LDFLAGS = "-liconv";
 				SDKROOT = appletvos;
 			};
@@ -10377,7 +9377,6 @@
 			buildSettings = {
 				CLANG_ENABLE_OBJC_ARC = YES;
 				CLANG_LINK_OBJC_RUNTIME = NO;
-				GCC_PREPROCESSOR_DEFINITIONS = "IOS_DYLIB=1";
 				OTHER_LDFLAGS = "-liconv";
 				SDKROOT = appletvos;
 			};
@@ -10480,33 +9479,6 @@
 			defaultConfigurationIsVisible = 0;
 			defaultConfigurationName = Debug;
 		};
-		A75FDB5023E399AC00529352 /* Build configuration list for PBXNativeTarget "hidapi-iOS" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				A75FDB4E23E399AC00529352 /* Debug */,
-				A75FDB4F23E399AC00529352 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Debug;
-		};
-		A75FDB6B23E3A2C900529352 /* Build configuration list for PBXNativeTarget "hidapi-tvOS" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				A75FDB6C23E3A2C900529352 /* Debug */,
-				A75FDB6D23E3A2C900529352 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Debug;
-		};
-		A75FDB8923E4C74400529352 /* Build configuration list for PBXNativeTarget "hidapi" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				A75FDB8A23E4C74400529352 /* Debug */,
-				A75FDB8B23E4C74400529352 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Debug;
-		};
 		A769B23A23E259AE00872273 /* Build configuration list for PBXNativeTarget "Static Library-tvOS" */ = {
 			isa = XCConfigurationList;
 			buildConfigurations = (
diff --git a/Engine/lib/sdl/Xcode/SDL/hidapi/Info.plist b/Engine/lib/sdl/Xcode/SDL/hidapi/Info.plist
deleted file mode 100644
index 145b17a93..000000000
--- a/Engine/lib/sdl/Xcode/SDL/hidapi/Info.plist
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>CFBundleDevelopmentRegion</key>
-	<string>$(DEVELOPMENT_LANGUAGE)</string>
-	<key>CFBundleExecutable</key>
-	<string>$(EXECUTABLE_NAME)</string>
-	<key>CFBundleIdentifier</key>
-	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
-	<key>CFBundleInfoDictionaryVersion</key>
-	<string>6.0</string>
-	<key>CFBundleName</key>
-	<string>$(PRODUCT_NAME)</string>
-	<key>CFBundlePackageType</key>
-	<string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
-	<key>CFBundleShortVersionString</key>
-	<string>$(CURRENT_PROJECT_VERSION)</string>
-	<key>CFBundleVersion</key>
-	<string>$(CURRENT_PROJECT_VERSION)</string>
-</dict>
-</plist>
diff --git a/Engine/lib/sdl/Xcode/SDL/pkg-support/resources/License.txt b/Engine/lib/sdl/Xcode/SDL/pkg-support/resources/License.txt
index 9bbafca5e..d2785a681 100644
--- a/Engine/lib/sdl/Xcode/SDL/pkg-support/resources/License.txt
+++ b/Engine/lib/sdl/Xcode/SDL/pkg-support/resources/License.txt
@@ -1,6 +1,6 @@
 
 Simple DirectMedia Layer
-Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
   
 This software is provided 'as-is', without any express or implied
 warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/acinclude/alsa.m4 b/Engine/lib/sdl/acinclude/alsa.m4
index e21fd46fb..1a276a23d 100644
--- a/Engine/lib/sdl/acinclude/alsa.m4
+++ b/Engine/lib/sdl/acinclude/alsa.m4
@@ -72,11 +72,10 @@ no_alsa=""
     alsa_min_micro_version=`echo $min_alsa_version | \
            sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\3/'`
 
-AC_LANG_SAVE
-AC_LANG_C
-AC_TRY_COMPILE([
+AC_LANG_PUSH([C])
+AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 #include <alsa/asoundlib.h>
-], [
+]], [[
 /* ensure backward compatibility */
 #if !defined(SND_LIB_MAJOR) && defined(SOUNDLIB_VERSION_MAJOR)
 #define SND_LIB_MAJOR SOUNDLIB_VERSION_MAJOR
@@ -108,13 +107,13 @@ AC_TRY_COMPILE([
 #    endif
 #  endif
 exit(0);
-],
+]])],
   [AC_MSG_RESULT(found.)],
   [AC_MSG_RESULT(not present.)
    ifelse([$3], , [AC_MSG_ERROR(Sufficiently new version of libasound not found.)])
    alsa_found=no]
 )
-AC_LANG_RESTORE
+AC_LANG_POP([C])
 
 dnl Now that we know that we have the right version, let's see if we have the library and not just the headers.
 if test "x$enable_alsatest" = "xyes"; then
diff --git a/Engine/lib/sdl/acinclude/esd.m4 b/Engine/lib/sdl/acinclude/esd.m4
index 979d1b865..2e50ddb68 100644
--- a/Engine/lib/sdl/acinclude/esd.m4
+++ b/Engine/lib/sdl/acinclude/esd.m4
@@ -8,7 +8,7 @@ dnl AM_PATH_ESD([MINIMUM-VERSION, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]]])
 dnl Test for ESD, and define ESD_CFLAGS and ESD_LIBS
 dnl
 AC_DEFUN([AM_PATH_ESD],
-[dnl 
+[dnl
 dnl Get the cflags and libraries from the esd-config script
 dnl
 AC_ARG_WITH(esd-prefix,[  --with-esd-prefix=PFX   Prefix where ESD is installed (optional)],
@@ -48,6 +48,7 @@ AC_ARG_ENABLE(esdtest, [  --disable-esdtest       Do not try to compile and run
     esd_micro_version=`$ESD_CONFIG $esd_config_args --version | \
            sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\3/'`
     if test "x$enable_esdtest" = "xyes" ; then
+      AC_LANG_PUSH([C])
       ac_save_CFLAGS="$CFLAGS"
       ac_save_LIBS="$LIBS"
       CFLAGS="$CFLAGS $ESD_CFLAGS"
@@ -57,38 +58,19 @@ dnl Now check if the installed ESD is sufficiently new. (Also sanity
 dnl checks the results of esd-config to some extent
 dnl
       rm -f conf.esdtest
-      AC_TRY_RUN([
+      AC_RUN_IFELSE([AC_LANG_SOURCE([[
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
 #include <esd.h>
 
-char*
-my_strdup (char *str)
-{
-  char *new_str;
-  
-  if (str)
-    {
-      new_str = malloc ((strlen (str) + 1) * sizeof(char));
-      strcpy (new_str, str);
-    }
-  else
-    new_str = NULL;
-  
-  return new_str;
-}
-
-int main ()
+int main (void)
 {
   int major, minor, micro;
-  char *tmp_version;
+  FILE *fp = fopen("conf.esdtest", "w");
 
-  system ("touch conf.esdtest");
+  if (fp) fclose(fp);
 
-  /* HP/UX 9 (%@#!) writes to sscanf strings */
-  tmp_version = my_strdup("$min_esd_version");
-  if (sscanf(tmp_version, "%d.%d.%d", &major, &minor, &micro) != 3) {
+  if (sscanf("$min_esd_version", "%d.%d.%d", &major, &minor, &micro) != 3) {
      printf("%s, bad version string\n", "$min_esd_version");
      exit(1);
    }
@@ -110,15 +92,15 @@ int main ()
       return 1;
     }
 }
-
-],, no_esd=yes,[echo $ac_n "cross compiling; assumed OK... $ac_c"])
+]])], [], [no_esd=yes], [echo $ac_n "cross compiling; assumed OK... $ac_c"])
        CFLAGS="$ac_save_CFLAGS"
        LIBS="$ac_save_LIBS"
+       AC_LANG_POP([C])
      fi
   fi
   if test "x$no_esd" = x ; then
      AC_MSG_RESULT(yes)
-     ifelse([$2], , :, [$2])     
+     ifelse([$2], , :, [$2])
   else
      AC_MSG_RESULT(no)
      if test "$ESD_CONFIG" = "no" ; then
@@ -133,10 +115,11 @@ int main ()
           echo "*** Could not run ESD test program, checking why..."
           CFLAGS="$CFLAGS $ESD_CFLAGS"
           LIBS="$LIBS $ESD_LIBS"
-          AC_TRY_LINK([
+          AC_LANG_PUSH([C])
+          AC_LINK_IFELSE([AC_LANG_PROGRAM([[
 #include <stdio.h>
 #include <esd.h>
-],      [ return 0; ],
+]], [[ return 0; ]])],
         [ echo "*** The test program compiled, but did not run. This usually means"
           echo "*** that the run-time linker is not finding ESD or finding the wrong"
           echo "*** version of ESD. If it is not finding ESD, you'll need to set your"
@@ -152,6 +135,7 @@ int main ()
           echo "*** may want to edit the esd-config script: $ESD_CONFIG" ])
           CFLAGS="$ac_save_CFLAGS"
           LIBS="$ac_save_LIBS"
+          AC_LANG_POP([C])
        fi
      fi
      ESD_CFLAGS=""
@@ -162,3 +146,27 @@ int main ()
   AC_SUBST(ESD_LIBS)
   rm -f conf.esdtest
 ])
+
+dnl AM_ESD_SUPPORTS_MULTIPLE_RECORD([ACTION-IF-SUPPORTS [, ACTION-IF-NOT-SUPPORTS]])
+dnl Test, whether esd supports multiple recording clients (version >=0.2.21)
+dnl
+AC_DEFUN([AM_ESD_SUPPORTS_MULTIPLE_RECORD],
+[dnl
+  AC_MSG_NOTICE([whether installed esd version supports multiple recording clients])
+  ac_save_ESD_CFLAGS="$ESD_CFLAGS"
+  ac_save_ESD_LIBS="$ESD_LIBS"
+  AM_PATH_ESD(0.2.21,
+    ifelse([$1], , [
+      AM_CONDITIONAL(ESD_SUPPORTS_MULTIPLE_RECORD, true)
+      AC_DEFINE(ESD_SUPPORTS_MULTIPLE_RECORD, 1,
+	[Define if you have esound with support of multiple recording clients.])],
+    [$1]),
+    ifelse([$2], , [AM_CONDITIONAL(ESD_SUPPORTS_MULTIPLE_RECORD, false)], [$2])
+    if test "x$ac_save_ESD_CFLAGS" != x ; then
+       ESD_CFLAGS="$ac_save_ESD_CFLAGS"
+    fi
+    if test "x$ac_save_ESD_LIBS" != x ; then
+       ESD_LIBS="$ac_save_ESD_LIBS"
+    fi
+  )
+])
diff --git a/Engine/lib/sdl/acinclude/libtool.m4 b/Engine/lib/sdl/acinclude/libtool.m4
index b8ba0324f..3236ddab0 100644
--- a/Engine/lib/sdl/acinclude/libtool.m4
+++ b/Engine/lib/sdl/acinclude/libtool.m4
@@ -1,10 +1,6 @@
-##############################################################################
-# Based on libtool-2.4.2
 # libtool.m4 - Configure libtool for the host system. -*-Autoconf-*-
 #
-#   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005,
-#                 2006, 2007, 2008, 2009, 2010, 2011 Free Software
-#                 Foundation, Inc.
+#   Copyright (C) 1996-2001, 2003-2015 Free Software Foundation, Inc.
 #   Written by Gordon Matzigkeit, 1996
 #
 # This file is free software; the Free Software Foundation gives
@@ -12,36 +8,30 @@
 # modifications, as long as this notice is preserved.
 
 m4_define([_LT_COPYING], [dnl
-#   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005,
-#                 2006, 2007, 2008, 2009, 2010, 2011 Free Software
-#                 Foundation, Inc.
-#   Written by Gordon Matzigkeit, 1996
+# Copyright (C) 2014 Free Software Foundation, Inc.
+# This is free software; see the source for copying conditions.  There is NO
+# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+# GNU Libtool is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of of the License, or
+# (at your option) any later version.
 #
-#   This file is part of GNU Libtool.
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program or library that is built
+# using GNU Libtool, you may include this file under the  same
+# distribution terms that you use for the rest of that program.
 #
-# GNU Libtool is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License as
-# published by the Free Software Foundation; either version 2 of
-# the License, or (at your option) any later version.
-#
-# As a special exception to the GNU General Public License,
-# if you distribute this file as part of a program or library that
-# is built using GNU Libtool, you may include this file under the
-# same distribution terms that you use for the rest of that program.
-#
-# GNU Libtool is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# GNU Libtool is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
-# along with GNU Libtool; see the file COPYING.  If not, a copy
-# can be downloaded from http://www.gnu.org/licenses/gpl.html, or
-# obtained by writing to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 ])
 
-# serial 57 LT_INIT
+# serial 58 LT_INIT
 
 
 # LT_PREREQ(VERSION)
@@ -69,7 +59,7 @@ esac
 # LT_INIT([OPTIONS])
 # ------------------
 AC_DEFUN([LT_INIT],
-[AC_PREREQ([2.58])dnl We use AC_INCLUDES_DEFAULT
+[AC_PREREQ([2.62])dnl We use AC_PATH_PROGS_FEATURE_CHECK
 AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
 AC_BEFORE([$0], [LT_LANG])dnl
 AC_BEFORE([$0], [LT_OUTPUT])dnl
@@ -93,7 +83,7 @@ dnl Parse OPTIONS
 _LT_SET_OPTIONS([$0], [$1])
 
 # This can be used to rebuild libtool when needed
-LIBTOOL_DEPS="$ltmain"
+LIBTOOL_DEPS=$ltmain
 
 # Always use our own libtool.
 LIBTOOL='$(SHELL) $(top_builddir)/libtool'
@@ -113,26 +103,43 @@ dnl AC_DEFUN([AC_PROG_LIBTOOL], [])
 dnl AC_DEFUN([AM_PROG_LIBTOOL], [])
 
 
+# _LT_PREPARE_CC_BASENAME
+# -----------------------
+m4_defun([_LT_PREPARE_CC_BASENAME], [
+# Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
+func_cc_basename ()
+{
+    for cc_temp in @S|@*""; do
+      case $cc_temp in
+        compile | *[[\\/]]compile | ccache | *[[\\/]]ccache ) ;;
+        distcc | *[[\\/]]distcc | purify | *[[\\/]]purify ) ;;
+        \-*) ;;
+        *) break;;
+      esac
+    done
+    func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
+}
+])# _LT_PREPARE_CC_BASENAME
+
+
 # _LT_CC_BASENAME(CC)
 # -------------------
-# Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
+# It would be clearer to call AC_REQUIREs from _LT_PREPARE_CC_BASENAME,
+# but that macro is also expanded into generated libtool script, which
+# arranges for $SED and $ECHO to be set by different means.
 m4_defun([_LT_CC_BASENAME],
-[for cc_temp in $1""; do
-  case $cc_temp in
-    compile | *[[\\/]]compile | ccache | *[[\\/]]ccache ) ;;
-    distcc | *[[\\/]]distcc | purify | *[[\\/]]purify ) ;;
-    \-*) ;;
-    *) break;;
-  esac
-done
-cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
+[m4_require([_LT_PREPARE_CC_BASENAME])dnl
+AC_REQUIRE([_LT_DECL_SED])dnl
+AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH])dnl
+func_cc_basename $1
+cc_basename=$func_cc_basename_result
 ])
 
 
 # _LT_FILEUTILS_DEFAULTS
 # ----------------------
 # It is okay to use these file commands and assume they have been set
-# sensibly after `m4_require([_LT_FILEUTILS_DEFAULTS])'.
+# sensibly after 'm4_require([_LT_FILEUTILS_DEFAULTS])'.
 m4_defun([_LT_FILEUTILS_DEFAULTS],
 [: ${CP="cp -f"}
 : ${MV="mv -f"}
@@ -179,15 +186,16 @@ m4_require([_LT_CHECK_SHAREDLIB_FROM_LINKLIB])dnl
 m4_require([_LT_CMD_OLD_ARCHIVE])dnl
 m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl
 m4_require([_LT_WITH_SYSROOT])dnl
+m4_require([_LT_CMD_TRUNCATE])dnl
 
 _LT_CONFIG_LIBTOOL_INIT([
-# See if we are running on zsh, and set the options which allow our
+# See if we are running on zsh, and set the options that allow our
 # commands through without removal of \ escapes INIT.
-if test -n "\${ZSH_VERSION+set}" ; then
+if test -n "\${ZSH_VERSION+set}"; then
    setopt NO_GLOB_SUBST
 fi
 ])
-if test -n "${ZSH_VERSION+set}" ; then
+if test -n "${ZSH_VERSION+set}"; then
    setopt NO_GLOB_SUBST
 fi
 
@@ -200,7 +208,7 @@ aix3*)
   # AIX sometimes has problems with the GCC collect2 program.  For some
   # reason, if we set the COLLECT_NAMES environment variable, the problems
   # vanish in a puff of smoke.
-  if test "X${COLLECT_NAMES+set}" != Xset; then
+  if test set != "${COLLECT_NAMES+set}"; then
     COLLECT_NAMES=
     export COLLECT_NAMES
   fi
@@ -211,14 +219,14 @@ esac
 ofile=libtool
 can_build_shared=yes
 
-# All known linkers require a `.a' archive for static linking (except MSVC,
+# All known linkers require a '.a' archive for static linking (except MSVC,
 # which needs '.lib').
 libext=a
 
-with_gnu_ld="$lt_cv_prog_gnu_ld"
+with_gnu_ld=$lt_cv_prog_gnu_ld
 
-old_CC="$CC"
-old_CFLAGS="$CFLAGS"
+old_CC=$CC
+old_CFLAGS=$CFLAGS
 
 # Set sane defaults for various variables
 test -z "$CC" && CC=cc
@@ -271,14 +279,14 @@ no_glob_subst='s/\*/\\\*/g'
 
 # _LT_PROG_LTMAIN
 # ---------------
-# Note that this code is called both from `configure', and `config.status'
+# Note that this code is called both from 'configure', and 'config.status'
 # now that we use AC_CONFIG_COMMANDS to generate libtool.  Notably,
-# `config.status' has no value for ac_aux_dir unless we are using Automake,
+# 'config.status' has no value for ac_aux_dir unless we are using Automake,
 # so we pass a copy along to make sure it has a sensible value anyway.
 m4_defun([_LT_PROG_LTMAIN],
 [m4_ifdef([AC_REQUIRE_AUX_FILE], [AC_REQUIRE_AUX_FILE([ltmain.sh])])dnl
 _LT_CONFIG_LIBTOOL_INIT([ac_aux_dir='$ac_aux_dir'])
-ltmain="$ac_aux_dir/ltmain.sh"
+ltmain=$ac_aux_dir/ltmain.sh
 ])# _LT_PROG_LTMAIN
 
 
@@ -288,7 +296,7 @@ ltmain="$ac_aux_dir/ltmain.sh"
 
 # So that we can recreate a full libtool script including additional
 # tags, we accumulate the chunks of code to send to AC_CONFIG_COMMANDS
-# in macros and then make a single call at the end using the `libtool'
+# in macros and then make a single call at the end using the 'libtool'
 # label.
 
 
@@ -423,8 +431,8 @@ m4_define([_lt_decl_all_varnames],
 
 # _LT_CONFIG_STATUS_DECLARE([VARNAME])
 # ------------------------------------
-# Quote a variable value, and forward it to `config.status' so that its
-# declaration there will have the same value as in `configure'.  VARNAME
+# Quote a variable value, and forward it to 'config.status' so that its
+# declaration there will have the same value as in 'configure'.  VARNAME
 # must have a single quote delimited value for this to work.
 m4_define([_LT_CONFIG_STATUS_DECLARE],
 [$1='`$ECHO "$][$1" | $SED "$delay_single_quote_subst"`'])
@@ -448,7 +456,7 @@ m4_defun([_LT_CONFIG_STATUS_DECLARATIONS],
 # Output comment and list of tags supported by the script
 m4_defun([_LT_LIBTOOL_TAGS],
 [_LT_FORMAT_COMMENT([The names of the tagged configurations supported by this script])dnl
-available_tags="_LT_TAGS"dnl
+available_tags='_LT_TAGS'dnl
 ])
 
 
@@ -476,7 +484,7 @@ m4_ifval([$2], [_$2])[]m4_popdef([_libtool_name])[]dnl
 # _LT_LIBTOOL_CONFIG_VARS
 # -----------------------
 # Produce commented declarations of non-tagged libtool config variables
-# suitable for insertion in the LIBTOOL CONFIG section of the `libtool'
+# suitable for insertion in the LIBTOOL CONFIG section of the 'libtool'
 # script.  Tagged libtool config variables (even for the LIBTOOL CONFIG
 # section) are produced by _LT_LIBTOOL_TAG_VARS.
 m4_defun([_LT_LIBTOOL_CONFIG_VARS],
@@ -502,8 +510,8 @@ m4_define([_LT_TAGVAR], [m4_ifval([$2], [$1_$2], [$1])])
 # Send accumulated output to $CONFIG_STATUS.  Thanks to the lists of
 # variables for single and double quote escaping we saved from calls
 # to _LT_DECL, we can put quote escaped variables declarations
-# into `config.status', and then the shell code to quote escape them in
-# for loops in `config.status'.  Finally, any additional code accumulated
+# into 'config.status', and then the shell code to quote escape them in
+# for loops in 'config.status'.  Finally, any additional code accumulated
 # from calls to _LT_CONFIG_LIBTOOL_INIT is expanded.
 m4_defun([_LT_CONFIG_COMMANDS],
 [AC_PROVIDE_IFELSE([LT_OUTPUT],
@@ -549,7 +557,7 @@ for var in lt_decl_all_varnames([[ \
 ]], lt_decl_quote_varnames); do
     case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
     *[[\\\\\\\`\\"\\\$]]*)
-      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\""
+      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes
       ;;
     *)
       eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
@@ -562,7 +570,7 @@ for var in lt_decl_all_varnames([[ \
 ]], lt_decl_dquote_varnames); do
     case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
     *[[\\\\\\\`\\"\\\$]]*)
-      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\""
+      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes
       ;;
     *)
       eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
@@ -578,7 +586,7 @@ _LT_OUTPUT_LIBTOOL_INIT
 # Generate a child script FILE with all initialization necessary to
 # reuse the environment learned by the parent script, and make the
 # file executable.  If COMMENT is supplied, it is inserted after the
-# `#!' sequence but before initialization text begins.  After this
+# '#!' sequence but before initialization text begins.  After this
 # macro, additional text can be appended to FILE to form the body of
 # the child script.  The macro ends with non-zero status if the
 # file could not be fully written (such as if the disk is full).
@@ -600,7 +608,7 @@ AS_SHELL_SANITIZE
 _AS_PREPARE
 exec AS_MESSAGE_FD>&1
 _ASEOF
-test $lt_write_fail = 0 && chmod +x $1[]dnl
+test 0 = "$lt_write_fail" && chmod +x $1[]dnl
 m4_popdef([AS_MESSAGE_LOG_FD])])])# _LT_GENERATED_FILE_INIT
 
 # LT_OUTPUT
@@ -623,7 +631,7 @@ exec AS_MESSAGE_LOG_FD>>config.log
 } >&AS_MESSAGE_LOG_FD
 
 lt_cl_help="\
-\`$as_me' creates a local libtool stub from the current configuration,
+'$as_me' creates a local libtool stub from the current configuration,
 for use in further configure time tests before the real libtool is
 generated.
 
@@ -645,7 +653,7 @@ Copyright (C) 2011 Free Software Foundation, Inc.
 This config.lt script is free software; the Free Software Foundation
 gives unlimited permision to copy, distribute and modify it."
 
-while test $[#] != 0
+while test 0 != $[#]
 do
   case $[1] in
     --version | --v* | -V )
@@ -658,10 +666,10 @@ do
       lt_cl_silent=: ;;
 
     -*) AC_MSG_ERROR([unrecognized option: $[1]
-Try \`$[0] --help' for more information.]) ;;
+Try '$[0] --help' for more information.]) ;;
 
     *) AC_MSG_ERROR([unrecognized argument: $[1]
-Try \`$[0] --help' for more information.]) ;;
+Try '$[0] --help' for more information.]) ;;
   esac
   shift
 done
@@ -687,7 +695,7 @@ chmod +x "$CONFIG_LT"
 # open by configure.  Here we exec the FD to /dev/null, effectively closing
 # config.log, so it can be properly (re)opened and appended to by config.lt.
 lt_cl_success=:
-test "$silent" = yes &&
+test yes = "$silent" &&
   lt_config_lt_args="$lt_config_lt_args --quiet"
 exec AS_MESSAGE_LOG_FD>/dev/null
 $SHELL "$CONFIG_LT" $lt_config_lt_args || lt_cl_success=false
@@ -707,32 +715,47 @@ m4_defun([_LT_CONFIG],
 _LT_CONFIG_SAVE_COMMANDS([
   m4_define([_LT_TAG], m4_if([$1], [], [C], [$1]))dnl
   m4_if(_LT_TAG, [C], [
-    # See if we are running on zsh, and set the options which allow our
+    # See if we are running on zsh, and set the options that allow our
     # commands through without removal of \ escapes.
-    if test -n "${ZSH_VERSION+set}" ; then
+    if test -n "${ZSH_VERSION+set}"; then
       setopt NO_GLOB_SUBST
     fi
 
-    cfgfile="${ofile}T"
+    cfgfile=${ofile}T
     trap "$RM \"$cfgfile\"; exit 1" 1 2 15
     $RM "$cfgfile"
 
     cat <<_LT_EOF >> "$cfgfile"
 #! $SHELL
-
-# `$ECHO "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services.
-# Generated automatically by $as_me ($PACKAGE$TIMESTAMP) $VERSION
+# Generated automatically by $as_me ($PACKAGE) $VERSION
 # Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
 # NOTE: Changes made to this file will be lost: look at ltmain.sh.
-#
+
+# Provide generalized library-building support services.
+# Written by Gordon Matzigkeit, 1996
+
 _LT_COPYING
 _LT_LIBTOOL_TAGS
 
+# Configured defaults for sys_lib_dlsearch_path munging.
+: \${LT_SYS_LIBRARY_PATH="$configure_time_lt_sys_library_path"}
+
 # ### BEGIN LIBTOOL CONFIG
 _LT_LIBTOOL_CONFIG_VARS
 _LT_LIBTOOL_TAG_VARS
 # ### END LIBTOOL CONFIG
 
+_LT_EOF
+
+    cat <<'_LT_EOF' >> "$cfgfile"
+
+# ### BEGIN FUNCTIONS SHARED WITH CONFIGURE
+
+_LT_PREPARE_MUNGE_PATH_LIST
+_LT_PREPARE_CC_BASENAME
+
+# ### END FUNCTIONS SHARED WITH CONFIGURE
+
 _LT_EOF
 
   case $host_os in
@@ -741,7 +764,7 @@ _LT_EOF
 # AIX sometimes has problems with the GCC collect2 program.  For some
 # reason, if we set the COLLECT_NAMES environment variable, the problems
 # vanish in a puff of smoke.
-if test "X${COLLECT_NAMES+set}" != Xset; then
+if test set != "${COLLECT_NAMES+set}"; then
   COLLECT_NAMES=
   export COLLECT_NAMES
 fi
@@ -758,8 +781,6 @@ _LT_EOF
   sed '$q' "$ltmain" >> "$cfgfile" \
      || (rm -f "$cfgfile"; exit 1)
 
-  _LT_PROG_REPLACE_SHELLFNS
-
    mv -f "$cfgfile" "$ofile" ||
     (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile")
   chmod +x "$ofile"
@@ -777,7 +798,6 @@ _LT_EOF
 [m4_if([$1], [], [
     PACKAGE='$PACKAGE'
     VERSION='$VERSION'
-    TIMESTAMP='$TIMESTAMP'
     RM='$RM'
     ofile='$ofile'], [])
 ])dnl /_LT_CONFIG_SAVE_COMMANDS
@@ -976,7 +996,7 @@ m4_defun_once([_LT_REQUIRED_DARWIN_CHECKS],[
 
     AC_CACHE_CHECK([for -single_module linker flag],[lt_cv_apple_cc_single_mod],
       [lt_cv_apple_cc_single_mod=no
-      if test -z "${LT_MULTI_MODULE}"; then
+      if test -z "$LT_MULTI_MODULE"; then
 	# By default we will add the -single_module flag. You can override
 	# by either setting the environment variable LT_MULTI_MODULE
 	# non-empty at configure time, or by adding -multi_module to the
@@ -994,7 +1014,7 @@ m4_defun_once([_LT_REQUIRED_DARWIN_CHECKS],[
 	  cat conftest.err >&AS_MESSAGE_LOG_FD
 	# Otherwise, if the output was created with a 0 exit code from
 	# the compiler, it worked.
-	elif test -f libconftest.dylib && test $_lt_result -eq 0; then
+	elif test -f libconftest.dylib && test 0 = "$_lt_result"; then
 	  lt_cv_apple_cc_single_mod=yes
 	else
 	  cat conftest.err >&AS_MESSAGE_LOG_FD
@@ -1012,7 +1032,7 @@ m4_defun_once([_LT_REQUIRED_DARWIN_CHECKS],[
       AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])],
 	[lt_cv_ld_exported_symbols_list=yes],
 	[lt_cv_ld_exported_symbols_list=no])
-	LDFLAGS="$save_LDFLAGS"
+	LDFLAGS=$save_LDFLAGS
     ])
 
     AC_CACHE_CHECK([for -force_load linker flag],[lt_cv_ld_force_load],
@@ -1034,7 +1054,7 @@ _LT_EOF
       _lt_result=$?
       if test -s conftest.err && $GREP force_load conftest.err; then
 	cat conftest.err >&AS_MESSAGE_LOG_FD
-      elif test -f conftest && test $_lt_result -eq 0 && $GREP forced_load conftest >/dev/null 2>&1 ; then
+      elif test -f conftest && test 0 = "$_lt_result" && $GREP forced_load conftest >/dev/null 2>&1; then
 	lt_cv_ld_force_load=yes
       else
 	cat conftest.err >&AS_MESSAGE_LOG_FD
@@ -1044,32 +1064,27 @@ _LT_EOF
     ])
     case $host_os in
     rhapsody* | darwin1.[[012]])
-      _lt_dar_allow_undefined='${wl}-undefined ${wl}suppress' ;;
+      _lt_dar_allow_undefined='$wl-undefined ${wl}suppress' ;;
     darwin1.*)
-      _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;
-    darwin*) # darwin 5.x on
-      # if running on 10.5 or later, the deployment target defaults
-      # to the OS version, if on x86, and 10.4, the deployment
-      # target defaults to 10.4. Don't you love it?
-      case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in
-	10.0,*86*-darwin8*|10.0,*-darwin[[91]]*)
-	  _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;
-	10.[[012]]*)
-	  _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;
-	10.*)
-	  _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;
+      _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;;
+    darwin*)
+      case $MACOSX_DEPLOYMENT_TARGET,$host in
+        10.[[012]],*|,*powerpc*-darwin[[5-8]]*)
+          _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;;
+        *)
+          _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;;
       esac
     ;;
   esac
-    if test "$lt_cv_apple_cc_single_mod" = "yes"; then
+    if test yes = "$lt_cv_apple_cc_single_mod"; then
       _lt_dar_single_mod='$single_module'
     fi
-    if test "$lt_cv_ld_exported_symbols_list" = "yes"; then
-      _lt_dar_export_syms=' ${wl}-exported_symbols_list,$output_objdir/${libname}-symbols.expsym'
+    if test yes = "$lt_cv_ld_exported_symbols_list"; then
+      _lt_dar_export_syms=' $wl-exported_symbols_list,$output_objdir/$libname-symbols.expsym'
     else
-      _lt_dar_export_syms='~$NMEDIT -s $output_objdir/${libname}-symbols.expsym ${lib}'
+      _lt_dar_export_syms='~$NMEDIT -s $output_objdir/$libname-symbols.expsym $lib'
     fi
-    if test "$DSYMUTIL" != ":" && test "$lt_cv_ld_force_load" = "no"; then
+    if test : != "$DSYMUTIL" && test no = "$lt_cv_ld_force_load"; then
       _lt_dsymutil='~$DSYMUTIL $lib || :'
     else
       _lt_dsymutil=
@@ -1089,29 +1104,29 @@ m4_defun([_LT_DARWIN_LINKER_FEATURES],
   _LT_TAGVAR(hardcode_direct, $1)=no
   _LT_TAGVAR(hardcode_automatic, $1)=yes
   _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
-  if test "$lt_cv_ld_force_load" = "yes"; then
-    _LT_TAGVAR(whole_archive_flag_spec, $1)='`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience ${wl}-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`'
+  if test yes = "$lt_cv_ld_force_load"; then
+    _LT_TAGVAR(whole_archive_flag_spec, $1)='`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience $wl-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`'
     m4_case([$1], [F77], [_LT_TAGVAR(compiler_needs_object, $1)=yes],
                   [FC],  [_LT_TAGVAR(compiler_needs_object, $1)=yes])
   else
     _LT_TAGVAR(whole_archive_flag_spec, $1)=''
   fi
   _LT_TAGVAR(link_all_deplibs, $1)=yes
-  _LT_TAGVAR(allow_undefined_flag, $1)="$_lt_dar_allow_undefined"
+  _LT_TAGVAR(allow_undefined_flag, $1)=$_lt_dar_allow_undefined
   case $cc_basename in
-     ifort*) _lt_dar_can_shared=yes ;;
+     ifort*|nagfor*) _lt_dar_can_shared=yes ;;
      *) _lt_dar_can_shared=$GCC ;;
   esac
-  if test "$_lt_dar_can_shared" = "yes"; then
+  if test yes = "$_lt_dar_can_shared"; then
     output_verbose_link_cmd=func_echo_all
-    _LT_TAGVAR(archive_cmds, $1)="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}"
-    _LT_TAGVAR(module_cmds, $1)="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}"
-    _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}"
-    _LT_TAGVAR(module_expsym_cmds, $1)="sed -e 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dar_export_syms}${_lt_dsymutil}"
+    _LT_TAGVAR(archive_cmds, $1)="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dsymutil"
+    _LT_TAGVAR(module_cmds, $1)="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dsymutil"
+    _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dar_export_syms$_lt_dsymutil"
+    _LT_TAGVAR(module_expsym_cmds, $1)="sed -e 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dar_export_syms$_lt_dsymutil"
     m4_if([$1], [CXX],
-[   if test "$lt_cv_apple_cc_single_mod" != "yes"; then
-      _LT_TAGVAR(archive_cmds, $1)="\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dsymutil}"
-      _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dar_export_syms}${_lt_dsymutil}"
+[   if test yes != "$lt_cv_apple_cc_single_mod"; then
+      _LT_TAGVAR(archive_cmds, $1)="\$CC -r -keep_private_externs -nostdlib -o \$lib-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$lib-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring$_lt_dsymutil"
+      _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \$lib-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$lib-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring$_lt_dar_export_syms$_lt_dsymutil"
     fi
 ],[])
   else
@@ -1131,7 +1146,7 @@ m4_defun([_LT_DARWIN_LINKER_FEATURES],
 # Allow to override them for all tags through lt_cv_aix_libpath.
 m4_defun([_LT_SYS_MODULE_PATH_AIX],
 [m4_require([_LT_DECL_SED])dnl
-if test "${lt_cv_aix_libpath+set}" = set; then
+if test set = "${lt_cv_aix_libpath+set}"; then
   aix_libpath=$lt_cv_aix_libpath
 else
   AC_CACHE_VAL([_LT_TAGVAR([lt_cv_aix_libpath_], [$1])],
@@ -1149,7 +1164,7 @@ else
     _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
   fi],[])
   if test -z "$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])"; then
-    _LT_TAGVAR([lt_cv_aix_libpath_], [$1])="/usr/lib:/lib"
+    _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=/usr/lib:/lib
   fi
   ])
   aix_libpath=$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])
@@ -1169,8 +1184,8 @@ m4_define([_LT_SHELL_INIT],
 # -----------------------
 # Find how we can fake an echo command that does not interpret backslash.
 # In particular, with Autoconf 2.60 or later we add some code to the start
-# of the generated configure script which will find a shell with a builtin
-# printf (which we can use as an echo command).
+# of the generated configure script that will find a shell with a builtin
+# printf (that we can use as an echo command).
 m4_defun([_LT_PROG_ECHO_BACKSLASH],
 [ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
 ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO
@@ -1198,10 +1213,10 @@ fi
 # Invoke $ECHO with all args, space-separated.
 func_echo_all ()
 {
-    $ECHO "$*" 
+    $ECHO "$*"
 }
 
-case "$ECHO" in
+case $ECHO in
   printf*) AC_MSG_RESULT([printf]) ;;
   print*) AC_MSG_RESULT([print -r]) ;;
   *) AC_MSG_RESULT([cat]) ;;
@@ -1227,16 +1242,17 @@ _LT_DECL([], [ECHO], [1], [An echo program that protects backslashes])
 AC_DEFUN([_LT_WITH_SYSROOT],
 [AC_MSG_CHECKING([for sysroot])
 AC_ARG_WITH([sysroot],
-[  --with-sysroot[=DIR] Search for dependent libraries within DIR
-                        (or the compiler's sysroot if not specified).],
+[AS_HELP_STRING([--with-sysroot@<:@=DIR@:>@],
+  [Search for dependent libraries within DIR (or the compiler's sysroot
+   if not specified).])],
 [], [with_sysroot=no])
 
 dnl lt_sysroot will always be passed unquoted.  We quote it here
 dnl in case the user passed a directory name.
 lt_sysroot=
-case ${with_sysroot} in #(
+case $with_sysroot in #(
  yes)
-   if test "$GCC" = yes; then
+   if test yes = "$GCC"; then
      lt_sysroot=`$CC --print-sysroot 2>/dev/null`
    fi
    ;; #(
@@ -1246,14 +1262,14 @@ case ${with_sysroot} in #(
  no|'')
    ;; #(
  *)
-   AC_MSG_RESULT([${with_sysroot}])
+   AC_MSG_RESULT([$with_sysroot])
    AC_MSG_ERROR([The sysroot must be an absolute path.])
    ;;
 esac
 
  AC_MSG_RESULT([${lt_sysroot:-no}])
 _LT_DECL([], [lt_sysroot], [0], [The root where to search for ]dnl
-[dependent libraries, and in which our libraries should be installed.])])
+[dependent libraries, and where our libraries should be installed.])])
 
 # _LT_ENABLE_LOCK
 # ---------------
@@ -1261,31 +1277,33 @@ m4_defun([_LT_ENABLE_LOCK],
 [AC_ARG_ENABLE([libtool-lock],
   [AS_HELP_STRING([--disable-libtool-lock],
     [avoid locking (might break parallel builds)])])
-test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes
+test no = "$enable_libtool_lock" || enable_libtool_lock=yes
 
 # Some flags need to be propagated to the compiler or linker for good
 # libtool support.
 case $host in
 ia64-*-hpux*)
-  # Find out which ABI we are using.
+  # Find out what ABI is being produced by ac_compile, and set mode
+  # options accordingly.
   echo 'int i;' > conftest.$ac_ext
   if AC_TRY_EVAL(ac_compile); then
     case `/usr/bin/file conftest.$ac_objext` in
       *ELF-32*)
-	HPUX_IA64_MODE="32"
+	HPUX_IA64_MODE=32
 	;;
       *ELF-64*)
-	HPUX_IA64_MODE="64"
+	HPUX_IA64_MODE=64
 	;;
     esac
   fi
   rm -rf conftest*
   ;;
 *-*-irix6*)
-  # Find out which ABI we are using.
+  # Find out what ABI is being produced by ac_compile, and set linker
+  # options accordingly.
   echo '[#]line '$LINENO' "configure"' > conftest.$ac_ext
   if AC_TRY_EVAL(ac_compile); then
-    if test "$lt_cv_prog_gnu_ld" = yes; then
+    if test yes = "$lt_cv_prog_gnu_ld"; then
       case `/usr/bin/file conftest.$ac_objext` in
 	*32-bit*)
 	  LD="${LD-ld} -melf32bsmip"
@@ -1314,9 +1332,46 @@ ia64-*-hpux*)
   rm -rf conftest*
   ;;
 
-x86_64-*kfreebsd*-gnu|x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*| \
+mips64*-*linux*)
+  # Find out what ABI is being produced by ac_compile, and set linker
+  # options accordingly.
+  echo '[#]line '$LINENO' "configure"' > conftest.$ac_ext
+  if AC_TRY_EVAL(ac_compile); then
+    emul=elf
+    case `/usr/bin/file conftest.$ac_objext` in
+      *32-bit*)
+	emul="${emul}32"
+	;;
+      *64-bit*)
+	emul="${emul}64"
+	;;
+    esac
+    case `/usr/bin/file conftest.$ac_objext` in
+      *MSB*)
+	emul="${emul}btsmip"
+	;;
+      *LSB*)
+	emul="${emul}ltsmip"
+	;;
+    esac
+    case `/usr/bin/file conftest.$ac_objext` in
+      *N32*)
+	emul="${emul}n32"
+	;;
+    esac
+    LD="${LD-ld} -m $emul"
+  fi
+  rm -rf conftest*
+  ;;
+
+x86_64-*kfreebsd*-gnu|x86_64-*linux*|powerpc*-*linux*| \
 s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
-  # Find out which ABI we are using.
+  # Find out what ABI is being produced by ac_compile, and set linker
+  # options accordingly.  Note that the listed cases only cover the
+  # situations where additional linker options are needed (such as when
+  # doing 32-bit compilation for a host where ld defaults to 64-bit, or
+  # vice versa); the common cases where no linker options are needed do
+  # not appear in the list.
   echo 'int i;' > conftest.$ac_ext
   if AC_TRY_EVAL(ac_compile); then
     case `/usr/bin/file conftest.o` in
@@ -1326,9 +1381,19 @@ s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
 	    LD="${LD-ld} -m elf_i386_fbsd"
 	    ;;
 	  x86_64-*linux*)
-	    LD="${LD-ld} -m elf_i386"
+	    case `/usr/bin/file conftest.o` in
+	      *x86-64*)
+		LD="${LD-ld} -m elf32_x86_64"
+		;;
+	      *)
+		LD="${LD-ld} -m elf_i386"
+		;;
+	    esac
 	    ;;
-	  ppc64-*linux*|powerpc64-*linux*)
+	  powerpc64le-*linux*)
+	    LD="${LD-ld} -m elf32lppclinux"
+	    ;;
+	  powerpc64-*linux*)
 	    LD="${LD-ld} -m elf32ppclinux"
 	    ;;
 	  s390x-*linux*)
@@ -1347,10 +1412,10 @@ s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
 	  x86_64-*linux*)
 	    LD="${LD-ld} -m elf_x86_64"
 	    ;;
-	  powerpc64le-*linux*)
+	  powerpcle-*linux*|powerpc64le-*linux*)
 	    LD="${LD-ld} -m elf64lppc"
 	    ;;
-	  powerpc64-*linux*)
+	  powerpc-*linux*|powerpc64-*linux*)
 	    LD="${LD-ld} -m elf64ppc"
 	    ;;
 	  s390*-*linux*|s390*-*tpf*)
@@ -1368,19 +1433,20 @@ s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
 
 *-*-sco3.2v5*)
   # On SCO OpenServer 5, we need -belf to get full-featured binaries.
-  SAVE_CFLAGS="$CFLAGS"
+  SAVE_CFLAGS=$CFLAGS
   CFLAGS="$CFLAGS -belf"
   AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf,
     [AC_LANG_PUSH(C)
      AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],[[]])],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no])
      AC_LANG_POP])
-  if test x"$lt_cv_cc_needs_belf" != x"yes"; then
+  if test yes != "$lt_cv_cc_needs_belf"; then
     # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
-    CFLAGS="$SAVE_CFLAGS"
+    CFLAGS=$SAVE_CFLAGS
   fi
   ;;
 *-*solaris*)
-  # Find out which ABI we are using.
+  # Find out what ABI is being produced by ac_compile, and set linker
+  # options accordingly.
   echo 'int i;' > conftest.$ac_ext
   if AC_TRY_EVAL(ac_compile); then
     case `/usr/bin/file conftest.o` in
@@ -1388,7 +1454,7 @@ s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
       case $lt_cv_prog_gnu_ld in
       yes*)
         case $host in
-        i?86-*-solaris*)
+        i?86-*-solaris*|x86_64-*-solaris*)
           LD="${LD-ld} -m elf_x86_64"
           ;;
         sparc*-*-solaris*)
@@ -1397,7 +1463,7 @@ s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
         esac
         # GNU ld 2.21 introduced _sol2 emulations.  Use them if available.
         if ${LD-ld} -V | grep _sol2 >/dev/null 2>&1; then
-          LD="${LD-ld}_sol2"
+          LD=${LD-ld}_sol2
         fi
         ;;
       *)
@@ -1413,7 +1479,7 @@ s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
   ;;
 esac
 
-need_locks="$enable_libtool_lock"
+need_locks=$enable_libtool_lock
 ])# _LT_ENABLE_LOCK
 
 
@@ -1432,11 +1498,11 @@ AC_CACHE_CHECK([for archiver @FILE support], [lt_cv_ar_at_file],
      [echo conftest.$ac_objext > conftest.lst
       lt_ar_try='$AR $AR_FLAGS libconftest.a @conftest.lst >&AS_MESSAGE_LOG_FD'
       AC_TRY_EVAL([lt_ar_try])
-      if test "$ac_status" -eq 0; then
+      if test 0 -eq "$ac_status"; then
 	# Ensure the archiver fails upon bogus file names.
 	rm -f conftest.$ac_objext libconftest.a
 	AC_TRY_EVAL([lt_ar_try])
-	if test "$ac_status" -ne 0; then
+	if test 0 -ne "$ac_status"; then
           lt_cv_ar_at_file=@
         fi
       fi
@@ -1444,7 +1510,7 @@ AC_CACHE_CHECK([for archiver @FILE support], [lt_cv_ar_at_file],
      ])
   ])
 
-if test "x$lt_cv_ar_at_file" = xno; then
+if test no = "$lt_cv_ar_at_file"; then
   archiver_list_spec=
 else
   archiver_list_spec=$lt_cv_ar_at_file
@@ -1475,7 +1541,7 @@ old_postuninstall_cmds=
 
 if test -n "$RANLIB"; then
   case $host_os in
-  openbsd*)
+  bitrig* | openbsd*)
     old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$tool_oldlib"
     ;;
   *)
@@ -1511,7 +1577,7 @@ AC_CACHE_CHECK([$1], [$2],
   [$2=no
    m4_if([$4], , [ac_outfile=conftest.$ac_objext], [ac_outfile=$4])
    echo "$lt_simple_compile_test_code" > conftest.$ac_ext
-   lt_compiler_flag="$3"
+   lt_compiler_flag="$3"  ## exclude from sc_useless_quotes_in_assignment
    # Insert the option either (1) after the last *FLAGS variable, or
    # (2) before a word containing "conftest.", or (3) at the end.
    # Note that $ac_compile itself does not contain backslashes and begins
@@ -1538,7 +1604,7 @@ AC_CACHE_CHECK([$1], [$2],
    $RM conftest*
 ])
 
-if test x"[$]$2" = xyes; then
+if test yes = "[$]$2"; then
     m4_if([$5], , :, [$5])
 else
     m4_if([$6], , :, [$6])
@@ -1560,7 +1626,7 @@ AC_DEFUN([_LT_LINKER_OPTION],
 m4_require([_LT_DECL_SED])dnl
 AC_CACHE_CHECK([$1], [$2],
   [$2=no
-   save_LDFLAGS="$LDFLAGS"
+   save_LDFLAGS=$LDFLAGS
    LDFLAGS="$LDFLAGS $3"
    echo "$lt_simple_link_test_code" > conftest.$ac_ext
    if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
@@ -1579,10 +1645,10 @@ AC_CACHE_CHECK([$1], [$2],
      fi
    fi
    $RM -r conftest*
-   LDFLAGS="$save_LDFLAGS"
+   LDFLAGS=$save_LDFLAGS
 ])
 
-if test x"[$]$2" = xyes; then
+if test yes = "[$]$2"; then
     m4_if([$4], , :, [$4])
 else
     m4_if([$5], , :, [$5])
@@ -1603,7 +1669,7 @@ AC_DEFUN([LT_CMD_MAX_LEN],
 AC_MSG_CHECKING([the maximum length of command line arguments])
 AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl
   i=0
-  teststring="ABCD"
+  teststring=ABCD
 
   case $build_os in
   msdosdjgpp*)
@@ -1643,7 +1709,7 @@ AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl
     lt_cv_sys_max_cmd_len=8192;
     ;;
 
-  netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)
+  bitrig* | darwin* | dragonfly* | freebsd* | midnightbsd* | netbsd* | openbsd*)
     # This has been around since 386BSD, at least.  Likely further.
     if test -x /sbin/sysctl; then
       lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
@@ -1693,22 +1759,23 @@ AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl
     ;;
   *)
     lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null`
-    if test -n "$lt_cv_sys_max_cmd_len"; then
+    if test -n "$lt_cv_sys_max_cmd_len" && \
+       test undefined != "$lt_cv_sys_max_cmd_len"; then
       lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
       lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
     else
       # Make teststring a little bigger before we do anything with it.
       # a 1K string should be a reasonable start.
-      for i in 1 2 3 4 5 6 7 8 ; do
+      for i in 1 2 3 4 5 6 7 8; do
         teststring=$teststring$teststring
       done
       SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}
       # If test is not a shell built-in, we'll probably end up computing a
       # maximum length that is only half of the actual maximum length, but
       # we can't tell.
-      while { test "X"`env echo "$teststring$teststring" 2>/dev/null` \
+      while { test X`env echo "$teststring$teststring" 2>/dev/null` \
 	         = "X$teststring$teststring"; } >/dev/null 2>&1 &&
-	      test $i != 17 # 1/2 MB should be enough
+	      test 17 != "$i" # 1/2 MB should be enough
       do
         i=`expr $i + 1`
         teststring=$teststring$teststring
@@ -1724,7 +1791,7 @@ AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl
     ;;
   esac
 ])
-if test -n $lt_cv_sys_max_cmd_len ; then
+if test -n "$lt_cv_sys_max_cmd_len"; then
   AC_MSG_RESULT($lt_cv_sys_max_cmd_len)
 else
   AC_MSG_RESULT(none)
@@ -1752,7 +1819,7 @@ m4_defun([_LT_HEADER_DLFCN],
 # ----------------------------------------------------------------
 m4_defun([_LT_TRY_DLOPEN_SELF],
 [m4_require([_LT_HEADER_DLFCN])dnl
-if test "$cross_compiling" = yes; then :
+if test yes = "$cross_compiling"; then :
   [$4]
 else
   lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
@@ -1799,9 +1866,9 @@ else
 #  endif
 #endif
 
-/* When -fvisbility=hidden is used, assume the code has been annotated
+/* When -fvisibility=hidden is used, assume the code has been annotated
    correspondingly for the symbols needed.  */
-#if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3))
+#if defined __GNUC__ && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3))
 int fnord () __attribute__((visibility("default")));
 #endif
 
@@ -1827,7 +1894,7 @@ int main ()
   return status;
 }]
 _LT_EOF
-  if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext} 2>/dev/null; then
+  if AC_TRY_EVAL(ac_link) && test -s "conftest$ac_exeext" 2>/dev/null; then
     (./conftest; exit; ) >&AS_MESSAGE_LOG_FD 2>/dev/null
     lt_status=$?
     case x$lt_status in
@@ -1848,7 +1915,7 @@ rm -fr conftest*
 # ------------------
 AC_DEFUN([LT_SYS_DLOPEN_SELF],
 [m4_require([_LT_HEADER_DLFCN])dnl
-if test "x$enable_dlopen" != xyes; then
+if test yes != "$enable_dlopen"; then
   enable_dlopen=unknown
   enable_dlopen_self=unknown
   enable_dlopen_self_static=unknown
@@ -1858,44 +1925,52 @@ else
 
   case $host_os in
   beos*)
-    lt_cv_dlopen="load_add_on"
+    lt_cv_dlopen=load_add_on
     lt_cv_dlopen_libs=
     lt_cv_dlopen_self=yes
     ;;
 
   mingw* | pw32* | cegcc*)
-    lt_cv_dlopen="LoadLibrary"
+    lt_cv_dlopen=LoadLibrary
     lt_cv_dlopen_libs=
     ;;
 
   cygwin*)
-    lt_cv_dlopen="dlopen"
+    lt_cv_dlopen=dlopen
     lt_cv_dlopen_libs=
     ;;
 
   darwin*)
-  # if libdl is installed we need to link against it
+    # if libdl is installed we need to link against it
     AC_CHECK_LIB([dl], [dlopen],
-		[lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],[
-    lt_cv_dlopen="dyld"
+		[lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl],[
+    lt_cv_dlopen=dyld
     lt_cv_dlopen_libs=
     lt_cv_dlopen_self=yes
     ])
     ;;
 
+  tpf*)
+    # Don't try to run any link tests for TPF.  We know it's impossible
+    # because TPF is a cross-compiler, and we know how we open DSOs.
+    lt_cv_dlopen=dlopen
+    lt_cv_dlopen_libs=
+    lt_cv_dlopen_self=no
+    ;;
+
   *)
     AC_CHECK_FUNC([shl_load],
-	  [lt_cv_dlopen="shl_load"],
+	  [lt_cv_dlopen=shl_load],
       [AC_CHECK_LIB([dld], [shl_load],
-	    [lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-ldld"],
+	    [lt_cv_dlopen=shl_load lt_cv_dlopen_libs=-ldld],
 	[AC_CHECK_FUNC([dlopen],
-	      [lt_cv_dlopen="dlopen"],
+	      [lt_cv_dlopen=dlopen],
 	  [AC_CHECK_LIB([dl], [dlopen],
-		[lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],
+		[lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl],
 	    [AC_CHECK_LIB([svld], [dlopen],
-		  [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"],
+		  [lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-lsvld],
 	      [AC_CHECK_LIB([dld], [dld_link],
-		    [lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-ldld"])
+		    [lt_cv_dlopen=dld_link lt_cv_dlopen_libs=-ldld])
 	      ])
 	    ])
 	  ])
@@ -1904,21 +1979,21 @@ else
     ;;
   esac
 
-  if test "x$lt_cv_dlopen" != xno; then
-    enable_dlopen=yes
-  else
+  if test no = "$lt_cv_dlopen"; then
     enable_dlopen=no
+  else
+    enable_dlopen=yes
   fi
 
   case $lt_cv_dlopen in
   dlopen)
-    save_CPPFLAGS="$CPPFLAGS"
-    test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"
+    save_CPPFLAGS=$CPPFLAGS
+    test yes = "$ac_cv_header_dlfcn_h" && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"
 
-    save_LDFLAGS="$LDFLAGS"
+    save_LDFLAGS=$LDFLAGS
     wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\"
 
-    save_LIBS="$LIBS"
+    save_LIBS=$LIBS
     LIBS="$lt_cv_dlopen_libs $LIBS"
 
     AC_CACHE_CHECK([whether a program can dlopen itself],
@@ -1928,7 +2003,7 @@ else
 	    lt_cv_dlopen_self=no, lt_cv_dlopen_self=cross)
     ])
 
-    if test "x$lt_cv_dlopen_self" = xyes; then
+    if test yes = "$lt_cv_dlopen_self"; then
       wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\"
       AC_CACHE_CHECK([whether a statically linked program can dlopen itself],
 	  lt_cv_dlopen_self_static, [dnl
@@ -1938,9 +2013,9 @@ else
       ])
     fi
 
-    CPPFLAGS="$save_CPPFLAGS"
-    LDFLAGS="$save_LDFLAGS"
-    LIBS="$save_LIBS"
+    CPPFLAGS=$save_CPPFLAGS
+    LDFLAGS=$save_LDFLAGS
+    LIBS=$save_LIBS
     ;;
   esac
 
@@ -2032,8 +2107,8 @@ m4_defun([_LT_COMPILER_FILE_LOCKS],
 m4_require([_LT_FILEUTILS_DEFAULTS])dnl
 _LT_COMPILER_C_O([$1])
 
-hard_links="nottested"
-if test "$_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)" = no && test "$need_locks" != no; then
+hard_links=nottested
+if test no = "$_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)" && test no != "$need_locks"; then
   # do not overwrite the value of need_locks provided by the user
   AC_MSG_CHECKING([if we can lock with hard links])
   hard_links=yes
@@ -2043,8 +2118,8 @@ if test "$_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)" = no && test "$need_locks" !=
   ln conftest.a conftest.b 2>&5 || hard_links=no
   ln conftest.a conftest.b 2>/dev/null && hard_links=no
   AC_MSG_RESULT([$hard_links])
-  if test "$hard_links" = no; then
-    AC_MSG_WARN([`$CC' does not support `-c -o', so `make -j' may be unsafe])
+  if test no = "$hard_links"; then
+    AC_MSG_WARN(['$CC' does not support '-c -o', so 'make -j' may be unsafe])
     need_locks=warn
   fi
 else
@@ -2071,8 +2146,8 @@ objdir=$lt_cv_objdir
 _LT_DECL([], [objdir], [0],
          [The name of the directory that contains temporary libtool files])dnl
 m4_pattern_allow([LT_OBJDIR])dnl
-AC_DEFINE_UNQUOTED(LT_OBJDIR, "$lt_cv_objdir/",
-  [Define to the sub-directory in which libtool stores uninstalled libraries.])
+AC_DEFINE_UNQUOTED([LT_OBJDIR], "$lt_cv_objdir/",
+  [Define to the sub-directory where libtool stores uninstalled libraries.])
 ])# _LT_CHECK_OBJDIR
 
 
@@ -2084,15 +2159,15 @@ m4_defun([_LT_LINKER_HARDCODE_LIBPATH],
 _LT_TAGVAR(hardcode_action, $1)=
 if test -n "$_LT_TAGVAR(hardcode_libdir_flag_spec, $1)" ||
    test -n "$_LT_TAGVAR(runpath_var, $1)" ||
-   test "X$_LT_TAGVAR(hardcode_automatic, $1)" = "Xyes" ; then
+   test yes = "$_LT_TAGVAR(hardcode_automatic, $1)"; then
 
   # We can hardcode non-existent directories.
-  if test "$_LT_TAGVAR(hardcode_direct, $1)" != no &&
+  if test no != "$_LT_TAGVAR(hardcode_direct, $1)" &&
      # If the only mechanism to avoid hardcoding is shlibpath_var, we
      # have to relink, otherwise we might link with an installed library
      # when we should be linking with a yet-to-be-installed one
-     ## test "$_LT_TAGVAR(hardcode_shlibpath_var, $1)" != no &&
-     test "$_LT_TAGVAR(hardcode_minus_L, $1)" != no; then
+     ## test no != "$_LT_TAGVAR(hardcode_shlibpath_var, $1)" &&
+     test no != "$_LT_TAGVAR(hardcode_minus_L, $1)"; then
     # Linking always hardcodes the temporary library directory.
     _LT_TAGVAR(hardcode_action, $1)=relink
   else
@@ -2106,12 +2181,12 @@ else
 fi
 AC_MSG_RESULT([$_LT_TAGVAR(hardcode_action, $1)])
 
-if test "$_LT_TAGVAR(hardcode_action, $1)" = relink ||
-   test "$_LT_TAGVAR(inherit_rpath, $1)" = yes; then
+if test relink = "$_LT_TAGVAR(hardcode_action, $1)" ||
+   test yes = "$_LT_TAGVAR(inherit_rpath, $1)"; then
   # Fast installation is not supported
   enable_fast_install=no
-elif test "$shlibpath_overrides_runpath" = yes ||
-     test "$enable_shared" = no; then
+elif test yes = "$shlibpath_overrides_runpath" ||
+     test no = "$enable_shared"; then
   # Fast installation is not necessary
   enable_fast_install=needless
 fi
@@ -2127,32 +2202,82 @@ m4_defun([_LT_CMD_STRIPLIB],
 striplib=
 old_striplib=
 AC_MSG_CHECKING([whether stripping libraries is possible])
-if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then
-  test -z "$old_striplib" && old_striplib="$STRIP --strip-debug"
-  test -z "$striplib" && striplib="$STRIP --strip-unneeded"
-  AC_MSG_RESULT([yes])
+if test -z "$STRIP"; then
+  AC_MSG_RESULT([no])
 else
-# FIXME - insert some real tests, host_os isn't really good enough
-  case $host_os in
-  darwin*)
-    if test -n "$STRIP" ; then
+  if $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then
+    old_striplib="$STRIP --strip-debug"
+    striplib="$STRIP --strip-unneeded"
+    AC_MSG_RESULT([yes])
+  else
+    case $host_os in
+    darwin*)
+      # FIXME - insert some real tests, host_os isn't really good enough
       striplib="$STRIP -x"
       old_striplib="$STRIP -S"
       AC_MSG_RESULT([yes])
-    else
+      ;;
+    freebsd*)
+      if $STRIP -V 2>&1 | $GREP "elftoolchain" >/dev/null; then
+        old_striplib="$STRIP --strip-debug"
+        striplib="$STRIP --strip-unneeded"
+        AC_MSG_RESULT([yes])
+      else
+        AC_MSG_RESULT([no])
+      fi
+      ;;
+    *)
       AC_MSG_RESULT([no])
-    fi
-    ;;
-  *)
-    AC_MSG_RESULT([no])
-    ;;
-  esac
+      ;;
+    esac
+  fi
 fi
 _LT_DECL([], [old_striplib], [1], [Commands to strip libraries])
 _LT_DECL([], [striplib], [1])
 ])# _LT_CMD_STRIPLIB
 
 
+# _LT_PREPARE_MUNGE_PATH_LIST
+# ---------------------------
+# Make sure func_munge_path_list() is defined correctly.
+m4_defun([_LT_PREPARE_MUNGE_PATH_LIST],
+[[# func_munge_path_list VARIABLE PATH
+# -----------------------------------
+# VARIABLE is name of variable containing _space_ separated list of
+# directories to be munged by the contents of PATH, which is string
+# having a format:
+# "DIR[:DIR]:"
+#       string "DIR[ DIR]" will be prepended to VARIABLE
+# ":DIR[:DIR]"
+#       string "DIR[ DIR]" will be appended to VARIABLE
+# "DIRP[:DIRP]::[DIRA:]DIRA"
+#       string "DIRP[ DIRP]" will be prepended to VARIABLE and string
+#       "DIRA[ DIRA]" will be appended to VARIABLE
+# "DIR[:DIR]"
+#       VARIABLE will be replaced by "DIR[ DIR]"
+func_munge_path_list ()
+{
+    case x@S|@2 in
+    x)
+        ;;
+    *:)
+        eval @S|@1=\"`$ECHO @S|@2 | $SED 's/:/ /g'` \@S|@@S|@1\"
+        ;;
+    x:*)
+        eval @S|@1=\"\@S|@@S|@1 `$ECHO @S|@2 | $SED 's/:/ /g'`\"
+        ;;
+    *::*)
+        eval @S|@1=\"\@S|@@S|@1\ `$ECHO @S|@2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
+        eval @S|@1=\"`$ECHO @S|@2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \@S|@@S|@1\"
+        ;;
+    *)
+        eval @S|@1=\"`$ECHO @S|@2 | $SED 's/:/ /g'`\"
+        ;;
+    esac
+}
+]])# _LT_PREPARE_PATH_LIST
+
+
 # _LT_SYS_DYNAMIC_LINKER([TAG])
 # -----------------------------
 # PORTME Fill in your ld.so characteristics
@@ -2163,17 +2288,18 @@ m4_require([_LT_FILEUTILS_DEFAULTS])dnl
 m4_require([_LT_DECL_OBJDUMP])dnl
 m4_require([_LT_DECL_SED])dnl
 m4_require([_LT_CHECK_SHELL_FEATURES])dnl
+m4_require([_LT_PREPARE_MUNGE_PATH_LIST])dnl
 AC_MSG_CHECKING([dynamic linker characteristics])
 m4_if([$1],
 	[], [
-if test "$GCC" = yes; then
+if test yes = "$GCC"; then
   case $host_os in
-    darwin*) lt_awk_arg="/^libraries:/,/LR/" ;;
-    *) lt_awk_arg="/^libraries:/" ;;
+    darwin*) lt_awk_arg='/^libraries:/,/LR/' ;;
+    *) lt_awk_arg='/^libraries:/' ;;
   esac
   case $host_os in
-    mingw* | cegcc*) lt_sed_strip_eq="s,=\([[A-Za-z]]:\),\1,g" ;;
-    *) lt_sed_strip_eq="s,=/,/,g" ;;
+    mingw* | cegcc*) lt_sed_strip_eq='s|=\([[A-Za-z]]:\)|\1|g' ;;
+    *) lt_sed_strip_eq='s|=/|/|g' ;;
   esac
   lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e $lt_sed_strip_eq`
   case $lt_search_path_spec in
@@ -2192,8 +2318,8 @@ if test "$GCC" = yes; then
   # and add multilib dir if necessary...
   lt_tmp_lt_search_path_spec=
   lt_multi_os_dir=/`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null`
-  # ...but if some path already ends with the multilib dir we assume
-  # that all is fine and trust -print-search-dirs as is (GCC 4.2 or newer).
+  # ...but if some path component already ends with the multilib dir we assume
+  # that all is fine and trust -print-search-dirs as is (GCC 4.2? or newer).
   case "$lt_multi_os_dir; $lt_search_path_spec " in
   "/; "* | "/.; "* | "/./; "* | *"$lt_multi_os_dir "* | *"$lt_multi_os_dir/ "*)
     lt_multi_os_dir=
@@ -2208,16 +2334,16 @@ if test "$GCC" = yes; then
     fi
   done
   lt_search_path_spec=`$ECHO "$lt_tmp_lt_search_path_spec" | awk '
-BEGIN {RS=" "; FS="/|\n";} {
-  lt_foo="";
-  lt_count=0;
+BEGIN {RS = " "; FS = "/|\n";} {
+  lt_foo = "";
+  lt_count = 0;
   for (lt_i = NF; lt_i > 0; lt_i--) {
     if ($lt_i != "" && $lt_i != ".") {
       if ($lt_i == "..") {
         lt_count++;
       } else {
         if (lt_count == 0) {
-          lt_foo="/" $lt_i lt_foo;
+          lt_foo = "/" $lt_i lt_foo;
         } else {
           lt_count--;
         }
@@ -2231,7 +2357,7 @@ BEGIN {RS=" "; FS="/|\n";} {
   # for these hosts.
   case $host_os in
     mingw* | cegcc*) lt_search_path_spec=`$ECHO "$lt_search_path_spec" |\
-      $SED 's,/\([[A-Za-z]]:\),\1,g'` ;;
+      $SED 's|/\([[A-Za-z]]:\)|\1|g'` ;;
   esac
   sys_lib_search_path_spec=`$ECHO "$lt_search_path_spec" | $lt_NL2SP`
 else
@@ -2240,7 +2366,7 @@ fi])
 library_names_spec=
 libname_spec='lib$name'
 soname_spec=
-shrext_cmds=".so"
+shrext_cmds=.so
 postinstall_cmds=
 postuninstall_cmds=
 finish_cmds=
@@ -2257,14 +2383,17 @@ hardcode_into_libs=no
 # flags to be left without arguments
 need_version=unknown
 
+AC_ARG_VAR([LT_SYS_LIBRARY_PATH],
+[User-defined run-time library search path.])
+
 case $host_os in
 aix3*)
   version_type=linux # correct to gnu/linux during the next big refactor
-  library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname.a'
   shlibpath_var=LIBPATH
 
   # AIX 3 has no versioning support, so we append a major version to the name.
-  soname_spec='${libname}${release}${shared_ext}$major'
+  soname_spec='$libname$release$shared_ext$major'
   ;;
 
 aix[[4-9]]*)
@@ -2272,41 +2401,91 @@ aix[[4-9]]*)
   need_lib_prefix=no
   need_version=no
   hardcode_into_libs=yes
-  if test "$host_cpu" = ia64; then
+  if test ia64 = "$host_cpu"; then
     # AIX 5 supports IA64
-    library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}'
+    library_names_spec='$libname$release$shared_ext$major $libname$release$shared_ext$versuffix $libname$shared_ext'
     shlibpath_var=LD_LIBRARY_PATH
   else
     # With GCC up to 2.95.x, collect2 would create an import file
     # for dependence libraries.  The import file would start with
-    # the line `#! .'.  This would cause the generated library to
-    # depend on `.', always an invalid library.  This was fixed in
+    # the line '#! .'.  This would cause the generated library to
+    # depend on '.', always an invalid library.  This was fixed in
     # development snapshots of GCC prior to 3.0.
     case $host_os in
       aix4 | aix4.[[01]] | aix4.[[01]].*)
       if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
 	   echo ' yes '
-	   echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then
+	   echo '#endif'; } | $CC -E - | $GREP yes > /dev/null; then
 	:
       else
 	can_build_shared=no
       fi
       ;;
     esac
-    # AIX (on Power*) has no versioning support, so currently we can not hardcode correct
+    # Using Import Files as archive members, it is possible to support
+    # filename-based versioning of shared library archives on AIX. While
+    # this would work for both with and without runtime linking, it will
+    # prevent static linking of such archives. So we do filename-based
+    # shared library versioning with .so extension only, which is used
+    # when both runtime linking and shared linking is enabled.
+    # Unfortunately, runtime linking may impact performance, so we do
+    # not want this to be the default eventually. Also, we use the
+    # versioned .so libs for executables only if there is the -brtl
+    # linker flag in LDFLAGS as well, or --with-aix-soname=svr4 only.
+    # To allow for filename-based versioning support, we need to create
+    # libNAME.so.V as an archive file, containing:
+    # *) an Import File, referring to the versioned filename of the
+    #    archive as well as the shared archive member, telling the
+    #    bitwidth (32 or 64) of that shared object, and providing the
+    #    list of exported symbols of that shared object, eventually
+    #    decorated with the 'weak' keyword
+    # *) the shared object with the F_LOADONLY flag set, to really avoid
+    #    it being seen by the linker.
+    # At run time we better use the real file rather than another symlink,
+    # but for link time we create the symlink libNAME.so -> libNAME.so.V
+
+    case $with_aix_soname,$aix_use_runtimelinking in
+    # AIX (on Power*) has no versioning support, so currently we cannot hardcode correct
     # soname into executable. Probably we can add versioning support to
     # collect2, so additional links can be useful in future.
-    if test "$aix_use_runtimelinking" = yes; then
+    aix,yes) # traditional libtool
+      dynamic_linker='AIX unversionable lib.so'
       # If using run time linking (on AIX 4.2 or later) use lib<name>.so
       # instead of lib<name>.a to let people know that these are not
       # typical AIX shared libraries.
-      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-    else
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+      ;;
+    aix,no) # traditional AIX only
+      dynamic_linker='AIX lib.a[(]lib.so.V[)]'
       # We preserve .a as extension for shared libraries through AIX4.2
       # and later when we are not doing run time linking.
-      library_names_spec='${libname}${release}.a $libname.a'
-      soname_spec='${libname}${release}${shared_ext}$major'
-    fi
+      library_names_spec='$libname$release.a $libname.a'
+      soname_spec='$libname$release$shared_ext$major'
+      ;;
+    svr4,*) # full svr4 only
+      dynamic_linker="AIX lib.so.V[(]$shared_archive_member_spec.o[)]"
+      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
+      # We do not specify a path in Import Files, so LIBPATH fires.
+      shlibpath_overrides_runpath=yes
+      ;;
+    *,yes) # both, prefer svr4
+      dynamic_linker="AIX lib.so.V[(]$shared_archive_member_spec.o[)], lib.a[(]lib.so.V[)]"
+      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
+      # unpreferred sharedlib libNAME.a needs extra handling
+      postinstall_cmds='test -n "$linkname" || linkname="$realname"~func_stripname "" ".so" "$linkname"~$install_shared_prog "$dir/$func_stripname_result.$libext" "$destdir/$func_stripname_result.$libext"~test -z "$tstripme" || test -z "$striplib" || $striplib "$destdir/$func_stripname_result.$libext"'
+      postuninstall_cmds='for n in $library_names $old_library; do :; done~func_stripname "" ".so" "$n"~test "$func_stripname_result" = "$n" || func_append rmfiles " $odir/$func_stripname_result.$libext"'
+      # We do not specify a path in Import Files, so LIBPATH fires.
+      shlibpath_overrides_runpath=yes
+      ;;
+    *,no) # both, prefer aix
+      dynamic_linker="AIX lib.a[(]lib.so.V[)], lib.so.V[(]$shared_archive_member_spec.o[)]"
+      library_names_spec='$libname$release.a $libname.a'
+      soname_spec='$libname$release$shared_ext$major'
+      # unpreferred sharedlib libNAME.so.V and symlink libNAME.so need extra handling
+      postinstall_cmds='test -z "$dlname" || $install_shared_prog $dir/$dlname $destdir/$dlname~test -z "$tstripme" || test -z "$striplib" || $striplib $destdir/$dlname~test -n "$linkname" || linkname=$realname~func_stripname "" ".a" "$linkname"~(cd "$destdir" && $LN_S -f $dlname $func_stripname_result.so)'
+      postuninstall_cmds='test -z "$dlname" || func_append rmfiles " $odir/$dlname"~for n in $old_library $library_names; do :; done~func_stripname "" ".a" "$n"~func_append rmfiles " $odir/$func_stripname_result.so"'
+      ;;
+    esac
     shlibpath_var=LIBPATH
   fi
   ;;
@@ -2316,18 +2495,18 @@ amigaos*)
   powerpc)
     # Since July 2007 AmigaOS4 officially supports .so libraries.
     # When compiling the executable, add -use-dynld -Lsobjs: to the compileline.
-    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
     ;;
   m68k)
     library_names_spec='$libname.ixlibrary $libname.a'
     # Create ${libname}_ixlibrary.a entries in /sys/libs.
-    finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([[^/]]*\)\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
+    finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([[^/]]*\)\.ixlibrary$%\1%'\''`; $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
     ;;
   esac
   ;;
 
 beos*)
-  library_names_spec='${libname}${shared_ext}'
+  library_names_spec='$libname$shared_ext'
   dynamic_linker="$host_os ld.so"
   shlibpath_var=LIBRARY_PATH
   ;;
@@ -2335,8 +2514,8 @@ beos*)
 bsdi[[45]]*)
   version_type=linux # correct to gnu/linux during the next big refactor
   need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
   shlibpath_var=LD_LIBRARY_PATH
   sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
@@ -2348,7 +2527,7 @@ bsdi[[45]]*)
 
 cygwin* | mingw* | pw32* | cegcc*)
   version_type=windows
-  shrext_cmds=".dll"
+  shrext_cmds=.dll
   need_version=no
   need_lib_prefix=no
 
@@ -2357,8 +2536,8 @@ cygwin* | mingw* | pw32* | cegcc*)
     # gcc
     library_names_spec='$libname.dll.a'
     # DLL is installed to $(libdir)/../bin by postinstall_cmds
-    postinstall_cmds='base_file=`basename \${file}`~
-      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~
+    postinstall_cmds='base_file=`basename \$file`~
+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~
       dldir=$destdir/`dirname \$dlpath`~
       test -d \$dldir || mkdir -p \$dldir~
       $install_prog $dir/$dlname \$dldir/$dlname~
@@ -2374,19 +2553,19 @@ cygwin* | mingw* | pw32* | cegcc*)
     case $host_os in
     cygwin*)
       # Cygwin DLLs use 'cyg' prefix rather than 'lib'
-      #soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
-      soname_spec='`echo ${libname} | sed -e 's/^lib//'`${shared_ext}'
+      #soname_spec='`echo $libname | sed -e 's/^lib/cyg/'``echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext'
+      soname_spec='`echo $libname | sed -e 's/^lib//'`$shared_ext' # SDL customization
 m4_if([$1], [],[
       sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/lib/w32api"])
       ;;
     mingw* | cegcc*)
       # MinGW DLLs use traditional 'lib' prefix
-      #soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
-      soname_spec='`echo ${libname} | $SED -e 's/^lib//'`${shared_ext}'
+      #soname_spec='$libname`echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext'
+      soname_spec='`echo $libname | $SED -e 's/^lib//'`$shared_ext' # SDL customization
       ;;
     pw32*)
       # pw32 DLLs use 'pw' prefix rather than 'lib'
-      library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
+      library_names_spec='`echo $libname | sed -e 's/^lib/pw/'``echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext'
       ;;
     esac
     dynamic_linker='Win32 ld.exe'
@@ -2395,8 +2574,8 @@ m4_if([$1], [],[
   *,cl*)
     # Native MSVC
     libname_spec='$name'
-    soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
-    library_names_spec='${libname}.dll.lib'
+    soname_spec='$libname`echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext'
+    library_names_spec='$libname.dll.lib'
 
     case $build_os in
     mingw*)
@@ -2423,7 +2602,7 @@ m4_if([$1], [],[
       sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
       ;;
     *)
-      sys_lib_search_path_spec="$LIB"
+      sys_lib_search_path_spec=$LIB
       if $ECHO "$sys_lib_search_path_spec" | [$GREP ';[c-zC-Z]:/' >/dev/null]; then
         # It is most probably a Windows format PATH.
         sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
@@ -2436,8 +2615,8 @@ m4_if([$1], [],[
     esac
 
     # DLL is installed to $(libdir)/../bin by postinstall_cmds
-    postinstall_cmds='base_file=`basename \${file}`~
-      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~
+    postinstall_cmds='base_file=`basename \$file`~
+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~
       dldir=$destdir/`dirname \$dlpath`~
       test -d \$dldir || mkdir -p \$dldir~
       $install_prog $dir/$dlname \$dldir/$dlname'
@@ -2450,7 +2629,7 @@ m4_if([$1], [],[
 
   *)
     # Assume MSVC wrapper
-    library_names_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext} $libname.lib'
+    library_names_spec='$libname`echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext $libname.lib'
     dynamic_linker='Win32 ld.exe'
     ;;
   esac
@@ -2463,8 +2642,8 @@ darwin* | rhapsody*)
   version_type=darwin
   need_lib_prefix=no
   need_version=no
-  library_names_spec='${libname}${release}${major}$shared_ext ${libname}$shared_ext'
-  soname_spec='${libname}${release}${major}$shared_ext'
+  library_names_spec='$libname$release$major$shared_ext $libname$shared_ext'
+  soname_spec='$libname$release$major$shared_ext'
   shlibpath_overrides_runpath=yes
   shlibpath_var=DYLD_LIBRARY_PATH
   shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'
@@ -2477,12 +2656,12 @@ dgux*)
   version_type=linux # correct to gnu/linux during the next big refactor
   need_lib_prefix=no
   need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   shlibpath_var=LD_LIBRARY_PATH
   ;;
 
-freebsd* | dragonfly*)
+freebsd* | dragonfly* | midnightbsd*)
   # DragonFly does not have aout.  When/if they implement a new
   # versioning mechanism, adjust this.
   if test -x /usr/bin/objformat; then
@@ -2496,12 +2675,13 @@ freebsd* | dragonfly*)
   version_type=freebsd-$objformat
   case $version_type in
     freebsd-elf*)
-      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+      soname_spec='$libname$release$shared_ext$major'
       need_version=no
       need_lib_prefix=no
       ;;
     freebsd-*)
-      library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix'
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
       need_version=yes
       ;;
   esac
@@ -2526,26 +2706,15 @@ freebsd* | dragonfly*)
   esac
   ;;
 
-gnu*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=no
-  hardcode_into_libs=yes
-  ;;
-
 haiku*)
   version_type=linux # correct to gnu/linux during the next big refactor
   need_lib_prefix=no
   need_version=no
   dynamic_linker="$host_os runtime_loader"
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   shlibpath_var=LIBRARY_PATH
-  shlibpath_overrides_runpath=yes
+  shlibpath_overrides_runpath=no
   sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib'
   hardcode_into_libs=yes
   ;;
@@ -2563,14 +2732,15 @@ hpux9* | hpux10* | hpux11*)
     dynamic_linker="$host_os dld.so"
     shlibpath_var=LD_LIBRARY_PATH
     shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
-    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-    soname_spec='${libname}${release}${shared_ext}$major'
-    if test "X$HPUX_IA64_MODE" = X32; then
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
+    if test 32 = "$HPUX_IA64_MODE"; then
       sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
+      sys_lib_dlsearch_path_spec=/usr/lib/hpux32
     else
       sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
+      sys_lib_dlsearch_path_spec=/usr/lib/hpux64
     fi
-    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
     ;;
   hppa*64*)
     shrext_cmds='.sl'
@@ -2578,8 +2748,8 @@ hpux9* | hpux10* | hpux11*)
     dynamic_linker="$host_os dld.sl"
     shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
     shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
-    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-    soname_spec='${libname}${release}${shared_ext}$major'
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
     sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"
     sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
     ;;
@@ -2588,8 +2758,8 @@ hpux9* | hpux10* | hpux11*)
     dynamic_linker="$host_os dld.sl"
     shlibpath_var=SHLIB_PATH
     shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
-    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-    soname_spec='${libname}${release}${shared_ext}$major'
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
     ;;
   esac
   # HP-UX runs *really* slowly unless shared libraries are mode 555, ...
@@ -2602,8 +2772,8 @@ interix[[3-9]]*)
   version_type=linux # correct to gnu/linux during the next big refactor
   need_lib_prefix=no
   need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'
   shlibpath_var=LD_LIBRARY_PATH
   shlibpath_overrides_runpath=no
@@ -2614,7 +2784,7 @@ irix5* | irix6* | nonstopux*)
   case $host_os in
     nonstopux*) version_type=nonstopux ;;
     *)
-	if test "$lt_cv_prog_gnu_ld" = yes; then
+	if test yes = "$lt_cv_prog_gnu_ld"; then
 		version_type=linux # correct to gnu/linux during the next big refactor
 	else
 		version_type=irix
@@ -2622,8 +2792,8 @@ irix5* | irix6* | nonstopux*)
   esac
   need_lib_prefix=no
   need_version=no
-  soname_spec='${libname}${release}${shared_ext}$major'
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}'
+  soname_spec='$libname$release$shared_ext$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$release$shared_ext $libname$shared_ext'
   case $host_os in
   irix5* | nonstopux*)
     libsuff= shlibsuff=
@@ -2642,8 +2812,8 @@ irix5* | irix6* | nonstopux*)
   esac
   shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
   shlibpath_overrides_runpath=no
-  sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"
-  sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}"
+  sys_lib_search_path_spec="/usr/lib$libsuff /lib$libsuff /usr/local/lib$libsuff"
+  sys_lib_dlsearch_path_spec="/usr/lib$libsuff /lib$libsuff"
   hardcode_into_libs=yes
   ;;
 
@@ -2652,13 +2822,33 @@ linux*oldld* | linux*aout* | linux*coff*)
   dynamic_linker=no
   ;;
 
+linux*android*)
+  version_type=none # Android doesn't support versioned libraries.
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext'
+  soname_spec='$libname$release$shared_ext'
+  finish_cmds=
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+
+  # This implies no fast_install, which is unacceptable.
+  # Some rework will be needed to allow for fast_install
+  # before this can be enabled.
+  hardcode_into_libs=yes
+
+  dynamic_linker='Android linker'
+  # Don't embed -rpath directories since the linker doesn't support them.
+  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+  ;;
+
 # This must be glibc/ELF.
-linux* | k*bsd*-gnu | kopensolaris*-gnu)
+linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
   version_type=linux # correct to gnu/linux during the next big refactor
   need_lib_prefix=no
   need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
   shlibpath_var=LD_LIBRARY_PATH
   shlibpath_overrides_runpath=no
@@ -2683,10 +2873,18 @@ linux* | k*bsd*-gnu | kopensolaris*-gnu)
   # before this can be enabled.
   hardcode_into_libs=yes
 
-  # Append ld.so.conf contents to the search path
+  # Add ABI-specific directories to the system library path.
+  sys_lib_dlsearch_path_spec="/lib64 /usr/lib64 /lib /usr/lib"
+
+  # Ideally, we could use ldconfig to report *all* directores which are
+  # searched for libraries, however this is still not possible.  Aside from not
+  # being certain /sbin/ldconfig is available, command
+  # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64,
+  # even though it is searched at run-time.  Try to do the best guess by
+  # appending ld.so.conf contents (and includes) to the search path.
   if test -f /etc/ld.so.conf; then
     lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \[$]2)); skip = 1; } { if (!skip) print \[$]0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[	 ]*hwcap[	 ]/d;s/[:,	]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '`
-    sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
+    sys_lib_dlsearch_path_spec="$sys_lib_dlsearch_path_spec $lt_ld_extra"
   fi
 
   # We used to test for /lib/ld.so.1 and disable shared libraries on
@@ -2703,12 +2901,12 @@ netbsd*)
   need_lib_prefix=no
   need_version=no
   if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
-    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
     finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
     dynamic_linker='NetBSD (a.out) ld.so'
   else
-    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
-    soname_spec='${libname}${release}${shared_ext}$major'
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
     dynamic_linker='NetBSD ld.elf_so'
   fi
   shlibpath_var=LD_LIBRARY_PATH
@@ -2718,7 +2916,7 @@ netbsd*)
 
 newsos6)
   version_type=linux # correct to gnu/linux during the next big refactor
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
   shlibpath_var=LD_LIBRARY_PATH
   shlibpath_overrides_runpath=yes
   ;;
@@ -2727,58 +2925,70 @@ newsos6)
   version_type=qnx
   need_lib_prefix=no
   need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   shlibpath_var=LD_LIBRARY_PATH
   shlibpath_overrides_runpath=no
   hardcode_into_libs=yes
   dynamic_linker='ldqnx.so'
   ;;
 
-openbsd*)
+openbsd* | bitrig*)
   version_type=sunos
-  sys_lib_dlsearch_path_spec="/usr/lib"
+  sys_lib_dlsearch_path_spec=/usr/lib
   need_lib_prefix=no
-  # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs.
-  case $host_os in
-    openbsd3.3 | openbsd3.3.*)	need_version=yes ;;
-    *)				need_version=no  ;;
-  esac
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then
+    need_version=no
+  else
+    need_version=yes
+  fi
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
   finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
   shlibpath_var=LD_LIBRARY_PATH
-  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
-    case $host_os in
-      openbsd2.[[89]] | openbsd2.[[89]].*)
-	shlibpath_overrides_runpath=no
-	;;
-      *)
-	shlibpath_overrides_runpath=yes
-	;;
-      esac
-  else
-    shlibpath_overrides_runpath=yes
-  fi
+  shlibpath_overrides_runpath=yes
   ;;
 
 os2*)
   libname_spec='$name'
-  shrext_cmds=".dll"
+  shrext_cmds=.dll
   need_lib_prefix=no
-  library_names_spec='$libname${shared_ext} $libname.a'
+  # OS/2 can only load a DLL with a base name of 8 characters or less.
+# SDL customization: removed versioning support.
+# version_type=windows
+# need_version=no
+# soname_spec='`test -n "$os2dllname" && libname="$os2dllname";
+#   v=$($ECHO $release$versuffix | tr -d .-);
+#   n=$($ECHO $libname | cut -b -$((8 - ${#v})) | tr . _);
+#   $ECHO $n$v`$shared_ext'
+  soname_spec='`test -n "$os2dllname" && libname=$os2dllname; $ECHO $libname | cut -b -8 | tr . _`$shared_ext'
+  library_names_spec='${libname}_dll.$libext'
   dynamic_linker='OS/2 ld.exe'
-  shlibpath_var=LIBPATH
+  shlibpath_var=BEGINLIBPATH
+  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
+  sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+  postinstall_cmds='base_file=`basename \$file`~
+    dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; $ECHO \$dlname'\''`~
+    dldir=$destdir/`dirname \$dlpath`~
+    test -d \$dldir || mkdir -p \$dldir~
+    $install_prog $dir/$dlname \$dldir/$dlname~
+    chmod a+x \$dldir/$dlname~
+    if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
+      eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
+    fi'
+  postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; $ECHO \$dlname'\''`~
+    dlpath=$dir/\$dldll~
+    $RM \$dlpath'
   ;;
 
 osf3* | osf4* | osf5*)
   version_type=osf
   need_lib_prefix=no
   need_version=no
-  soname_spec='${libname}${release}${shared_ext}$major'
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='$libname$release$shared_ext$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
   shlibpath_var=LD_LIBRARY_PATH
   sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
-  sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec"
+  sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
   ;;
 
 rdos*)
@@ -2789,8 +2999,8 @@ solaris*)
   version_type=linux # correct to gnu/linux during the next big refactor
   need_lib_prefix=no
   need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   shlibpath_var=LD_LIBRARY_PATH
   shlibpath_overrides_runpath=yes
   hardcode_into_libs=yes
@@ -2800,11 +3010,11 @@ solaris*)
 
 sunos4*)
   version_type=sunos
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
   finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
   shlibpath_var=LD_LIBRARY_PATH
   shlibpath_overrides_runpath=yes
-  if test "$with_gnu_ld" = yes; then
+  if test yes = "$with_gnu_ld"; then
     need_lib_prefix=no
   fi
   need_version=yes
@@ -2812,8 +3022,8 @@ sunos4*)
 
 sysv4 | sysv4.3*)
   version_type=linux # correct to gnu/linux during the next big refactor
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   shlibpath_var=LD_LIBRARY_PATH
   case $host_vendor in
     sni)
@@ -2834,24 +3044,24 @@ sysv4 | sysv4.3*)
   ;;
 
 sysv4*MP*)
-  if test -d /usr/nec ;then
+  if test -d /usr/nec; then
     version_type=linux # correct to gnu/linux during the next big refactor
-    library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}'
-    soname_spec='$libname${shared_ext}.$major'
+    library_names_spec='$libname$shared_ext.$versuffix $libname$shared_ext.$major $libname$shared_ext'
+    soname_spec='$libname$shared_ext.$major'
     shlibpath_var=LD_LIBRARY_PATH
   fi
   ;;
 
 sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
-  version_type=freebsd-elf
+  version_type=sco
   need_lib_prefix=no
   need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   shlibpath_var=LD_LIBRARY_PATH
   shlibpath_overrides_runpath=yes
   hardcode_into_libs=yes
-  if test "$with_gnu_ld" = yes; then
+  if test yes = "$with_gnu_ld"; then
     sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'
   else
     sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'
@@ -2869,7 +3079,7 @@ tpf*)
   version_type=linux # correct to gnu/linux during the next big refactor
   need_lib_prefix=no
   need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
   shlibpath_var=LD_LIBRARY_PATH
   shlibpath_overrides_runpath=no
   hardcode_into_libs=yes
@@ -2877,8 +3087,8 @@ tpf*)
 
 uts4*)
   version_type=linux # correct to gnu/linux during the next big refactor
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   shlibpath_var=LD_LIBRARY_PATH
   ;;
 
@@ -2887,20 +3097,30 @@ uts4*)
   ;;
 esac
 AC_MSG_RESULT([$dynamic_linker])
-test "$dynamic_linker" = no && can_build_shared=no
+test no = "$dynamic_linker" && can_build_shared=no
 
 variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
-if test "$GCC" = yes; then
+if test yes = "$GCC"; then
   variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
 fi
 
-if test "${lt_cv_sys_lib_search_path_spec+set}" = set; then
-  sys_lib_search_path_spec="$lt_cv_sys_lib_search_path_spec"
+if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then
+  sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec
 fi
-if test "${lt_cv_sys_lib_dlsearch_path_spec+set}" = set; then
-  sys_lib_dlsearch_path_spec="$lt_cv_sys_lib_dlsearch_path_spec"
+
+if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then
+  sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec
 fi
 
+# remember unaugmented sys_lib_dlsearch_path content for libtool script decls...
+configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec
+
+# ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code
+func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH"
+
+# to be used as default LT_SYS_LIBRARY_PATH value in generated libtool
+configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH
+
 _LT_DECL([], [variables_saved_for_relink], [1],
     [Variables whose values should be saved in libtool wrapper scripts and
     restored at link time])
@@ -2933,39 +3153,41 @@ _LT_DECL([], [hardcode_into_libs], [0],
     [Whether we should hardcode library paths into libraries])
 _LT_DECL([], [sys_lib_search_path_spec], [2],
     [Compile-time system search path for libraries])
-_LT_DECL([], [sys_lib_dlsearch_path_spec], [2],
-    [Run-time system search path for libraries])
+_LT_DECL([sys_lib_dlsearch_path_spec], [configure_time_dlsearch_path], [2],
+    [Detected run-time system search path for libraries])
+_LT_DECL([], [configure_time_lt_sys_library_path], [2],
+    [Explicit LT_SYS_LIBRARY_PATH set during ./configure time])
 ])# _LT_SYS_DYNAMIC_LINKER
 
 
 # _LT_PATH_TOOL_PREFIX(TOOL)
 # --------------------------
-# find a file program which can recognize shared library
+# find a file program that can recognize shared library
 AC_DEFUN([_LT_PATH_TOOL_PREFIX],
 [m4_require([_LT_DECL_EGREP])dnl
 AC_MSG_CHECKING([for $1])
 AC_CACHE_VAL(lt_cv_path_MAGIC_CMD,
 [case $MAGIC_CMD in
 [[\\/*] |  ?:[\\/]*])
-  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
+  lt_cv_path_MAGIC_CMD=$MAGIC_CMD # Let the user override the test with a path.
   ;;
 *)
-  lt_save_MAGIC_CMD="$MAGIC_CMD"
-  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+  lt_save_MAGIC_CMD=$MAGIC_CMD
+  lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
 dnl $ac_dummy forces splitting on constant user-supplied paths.
 dnl POSIX.2 word splitting is done only on the output of word expansions,
 dnl not every word.  This closes a longstanding sh security hole.
   ac_dummy="m4_if([$2], , $PATH, [$2])"
   for ac_dir in $ac_dummy; do
-    IFS="$lt_save_ifs"
+    IFS=$lt_save_ifs
     test -z "$ac_dir" && ac_dir=.
-    if test -f $ac_dir/$1; then
-      lt_cv_path_MAGIC_CMD="$ac_dir/$1"
+    if test -f "$ac_dir/$1"; then
+      lt_cv_path_MAGIC_CMD=$ac_dir/"$1"
       if test -n "$file_magic_test_file"; then
 	case $deplibs_check_method in
 	"file_magic "*)
 	  file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
-	  MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+	  MAGIC_CMD=$lt_cv_path_MAGIC_CMD
 	  if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
 	    $EGREP "$file_magic_regex" > /dev/null; then
 	    :
@@ -2988,11 +3210,11 @@ _LT_EOF
       break
     fi
   done
-  IFS="$lt_save_ifs"
-  MAGIC_CMD="$lt_save_MAGIC_CMD"
+  IFS=$lt_save_ifs
+  MAGIC_CMD=$lt_save_MAGIC_CMD
   ;;
 esac])
-MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+MAGIC_CMD=$lt_cv_path_MAGIC_CMD
 if test -n "$MAGIC_CMD"; then
   AC_MSG_RESULT($MAGIC_CMD)
 else
@@ -3010,7 +3232,7 @@ dnl AC_DEFUN([AC_PATH_TOOL_PREFIX], [])
 
 # _LT_PATH_MAGIC
 # --------------
-# find a file program which can recognize a shared library
+# find a file program that can recognize a shared library
 m4_defun([_LT_PATH_MAGIC],
 [_LT_PATH_TOOL_PREFIX(${ac_tool_prefix}file, /usr/bin$PATH_SEPARATOR$PATH)
 if test -z "$lt_cv_path_MAGIC_CMD"; then
@@ -3037,16 +3259,16 @@ m4_require([_LT_PROG_ECHO_BACKSLASH])dnl
 AC_ARG_WITH([gnu-ld],
     [AS_HELP_STRING([--with-gnu-ld],
 	[assume the C compiler uses GNU ld @<:@default=no@:>@])],
-    [test "$withval" = no || with_gnu_ld=yes],
+    [test no = "$withval" || with_gnu_ld=yes],
     [with_gnu_ld=no])dnl
 
 ac_prog=ld
-if test "$GCC" = yes; then
+if test yes = "$GCC"; then
   # Check if gcc -print-prog-name=ld gives a path.
   AC_MSG_CHECKING([for ld used by $CC])
   case $host in
   *-*-mingw*)
-    # gcc leaves a trailing carriage return which upsets mingw
+    # gcc leaves a trailing carriage return, which upsets mingw
     ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
   *)
     ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
@@ -3060,7 +3282,7 @@ if test "$GCC" = yes; then
       while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do
 	ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"`
       done
-      test -z "$LD" && LD="$ac_prog"
+      test -z "$LD" && LD=$ac_prog
       ;;
   "")
     # If it fails, then pretend we aren't using GCC.
@@ -3071,37 +3293,37 @@ if test "$GCC" = yes; then
     with_gnu_ld=unknown
     ;;
   esac
-elif test "$with_gnu_ld" = yes; then
+elif test yes = "$with_gnu_ld"; then
   AC_MSG_CHECKING([for GNU ld])
 else
   AC_MSG_CHECKING([for non-GNU ld])
 fi
 AC_CACHE_VAL(lt_cv_path_LD,
 [if test -z "$LD"; then
-  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+  lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
   for ac_dir in $PATH; do
-    IFS="$lt_save_ifs"
+    IFS=$lt_save_ifs
     test -z "$ac_dir" && ac_dir=.
     if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
-      lt_cv_path_LD="$ac_dir/$ac_prog"
+      lt_cv_path_LD=$ac_dir/$ac_prog
       # Check to see if the program is GNU ld.  I'd rather use --version,
       # but apparently some variants of GNU ld only accept -v.
       # Break only if it was the GNU/non-GNU ld that we prefer.
       case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
       *GNU* | *'with BFD'*)
-	test "$with_gnu_ld" != no && break
+	test no != "$with_gnu_ld" && break
 	;;
       *)
-	test "$with_gnu_ld" != yes && break
+	test yes != "$with_gnu_ld" && break
 	;;
       esac
     fi
   done
-  IFS="$lt_save_ifs"
+  IFS=$lt_save_ifs
 else
-  lt_cv_path_LD="$LD" # Let the user override the test with a path.
+  lt_cv_path_LD=$LD # Let the user override the test with a path.
 fi])
-LD="$lt_cv_path_LD"
+LD=$lt_cv_path_LD
 if test -n "$LD"; then
   AC_MSG_RESULT($LD)
 else
@@ -3155,13 +3377,13 @@ esac
 reload_cmds='$LD$reload_flag -o $output$reload_objs'
 case $host_os in
   cygwin* | mingw* | pw32* | cegcc*)
-    if test "$GCC" != yes; then
+    if test yes != "$GCC"; then
       reload_cmds=false
     fi
     ;;
   darwin*)
-    if test "$GCC" = yes; then
-      reload_cmds='$LTCC $LTCFLAGS -nostdlib ${wl}-r -o $output$reload_objs'
+    if test yes = "$GCC"; then
+      reload_cmds='$LTCC $LTCFLAGS -nostdlib $wl-r -o $output$reload_objs'
     else
       reload_cmds='$LD$reload_flag -o $output$reload_objs'
     fi
@@ -3172,6 +3394,43 @@ _LT_TAGDECL([], [reload_cmds], [2])dnl
 ])# _LT_CMD_RELOAD
 
 
+# _LT_PATH_DD
+# -----------
+# find a working dd
+m4_defun([_LT_PATH_DD],
+[AC_CACHE_CHECK([for a working dd], [ac_cv_path_lt_DD],
+[printf 0123456789abcdef0123456789abcdef >conftest.i
+cat conftest.i conftest.i >conftest2.i
+: ${lt_DD:=$DD}
+AC_PATH_PROGS_FEATURE_CHECK([lt_DD], [dd],
+[if "$ac_path_lt_DD" bs=32 count=1 <conftest2.i >conftest.out 2>/dev/null; then
+  cmp -s conftest.i conftest.out \
+  && ac_cv_path_lt_DD="$ac_path_lt_DD" ac_path_lt_DD_found=:
+fi])
+rm -f conftest.i conftest2.i conftest.out])
+])# _LT_PATH_DD
+
+
+# _LT_CMD_TRUNCATE
+# ----------------
+# find command to truncate a binary pipe
+m4_defun([_LT_CMD_TRUNCATE],
+[m4_require([_LT_PATH_DD])
+AC_CACHE_CHECK([how to truncate binary pipes], [lt_cv_truncate_bin],
+[printf 0123456789abcdef0123456789abcdef >conftest.i
+cat conftest.i conftest.i >conftest2.i
+lt_cv_truncate_bin=
+if "$ac_cv_path_lt_DD" bs=32 count=1 <conftest2.i >conftest.out 2>/dev/null; then
+  cmp -s conftest.i conftest.out \
+  && lt_cv_truncate_bin="$ac_cv_path_lt_DD bs=4096 count=1"
+fi
+rm -f conftest.i conftest2.i conftest.out
+test -z "$lt_cv_truncate_bin" && lt_cv_truncate_bin="$SED -e 4q"])
+_LT_DECL([lt_truncate_bin], [lt_cv_truncate_bin], [1],
+  [Command to truncate a binary pipe])
+])# _LT_CMD_TRUNCATE
+
+
 # _LT_CHECK_MAGIC_METHOD
 # ----------------------
 # how to check for library dependencies
@@ -3187,13 +3446,13 @@ lt_cv_deplibs_check_method='unknown'
 # Need to set the preceding variable on all platforms that support
 # interlibrary dependencies.
 # 'none' -- dependencies not supported.
-# `unknown' -- same as none, but documents that we really don't know.
+# 'unknown' -- same as none, but documents that we really don't know.
 # 'pass_all' -- all dependencies passed with no checks.
 # 'test_compile' -- check by making test program.
 # 'file_magic [[regex]]' -- check by looking for files in library path
-# which responds to the $file_magic_cmd with a given extended regex.
-# If you have `file' or equivalent on your system and you're not sure
-# whether `pass_all' will *always* work, you probably want this one.
+# that responds to the $file_magic_cmd with a given extended regex.
+# If you have 'file' or equivalent on your system and you're not sure
+# whether 'pass_all' will *always* work, you probably want this one.
 
 case $host_os in
 aix[[4-9]]*)
@@ -3214,15 +3473,14 @@ cygwin*)
   # func_win32_libid is a shell function defined in ltmain.sh
   lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
   lt_cv_file_magic_cmd='func_win32_libid'
-  lt_cv_deplibs_check_method=pass_all
+  lt_cv_deplibs_check_method=pass_all # SDL customization
   ;;
 
 mingw* | pw32*)
   # Base MSYS/MinGW do not provide the 'file' command needed by
   # func_win32_libid shell function, so use a weaker test based on 'objdump',
   # unless we find 'file', for example because we are cross-compiling.
-  # func_win32_libid assumes BSD nm, so disallow it if using MS dumpbin.
-  if ( test "$lt_cv_nm_interface" = "BSD nm" && file / ) >/dev/null 2>&1; then
+  if ( file / ) >/dev/null 2>&1; then
     lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
     lt_cv_file_magic_cmd='func_win32_libid'
   else
@@ -3230,7 +3488,7 @@ mingw* | pw32*)
     lt_cv_deplibs_check_method='file_magic file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)'
     lt_cv_file_magic_cmd='$OBJDUMP -f'
   fi
-  lt_cv_deplibs_check_method=pass_all
+  lt_cv_deplibs_check_method=pass_all # SDL customization
   ;;
 
 cegcc*)
@@ -3243,7 +3501,7 @@ darwin* | rhapsody*)
   lt_cv_deplibs_check_method=pass_all
   ;;
 
-freebsd* | dragonfly*)
+freebsd* | dragonfly* | midnightbsd*)
   if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
     case $host_cpu in
     i*86 )
@@ -3259,10 +3517,6 @@ freebsd* | dragonfly*)
   fi
   ;;
 
-gnu*)
-  lt_cv_deplibs_check_method=pass_all
-  ;;
-
 haiku*)
   lt_cv_deplibs_check_method=pass_all
   ;;
@@ -3301,7 +3555,7 @@ irix5* | irix6* | nonstopux*)
   ;;
 
 # This must be glibc/ELF.
-linux* | k*bsd*-gnu | kopensolaris*-gnu)
+linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
   lt_cv_deplibs_check_method=pass_all
   ;;
 
@@ -3323,8 +3577,8 @@ newos6*)
   lt_cv_deplibs_check_method=pass_all
   ;;
 
-openbsd*)
-  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+openbsd* | bitrig*)
+  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then
     lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|\.so|_pic\.a)$'
   else
     lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$'
@@ -3377,6 +3631,9 @@ sysv4 | sysv4.3*)
 tpf*)
   lt_cv_deplibs_check_method=pass_all
   ;;
+os2*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
 esac
 ])
 
@@ -3417,33 +3674,38 @@ AC_DEFUN([LT_PATH_NM],
 AC_CACHE_CHECK([for BSD- or MS-compatible name lister (nm)], lt_cv_path_NM,
 [if test -n "$NM"; then
   # Let the user override the test.
-  lt_cv_path_NM="$NM"
+  lt_cv_path_NM=$NM
 else
-  lt_nm_to_check="${ac_tool_prefix}nm"
+  lt_nm_to_check=${ac_tool_prefix}nm
   if test -n "$ac_tool_prefix" && test "$build" = "$host"; then
     lt_nm_to_check="$lt_nm_to_check nm"
   fi
   for lt_tmp_nm in $lt_nm_to_check; do
-    lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+    lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
     for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do
-      IFS="$lt_save_ifs"
+      IFS=$lt_save_ifs
       test -z "$ac_dir" && ac_dir=.
-      tmp_nm="$ac_dir/$lt_tmp_nm"
-      if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then
+      tmp_nm=$ac_dir/$lt_tmp_nm
+      if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext"; then
 	# Check to see if the nm accepts a BSD-compat flag.
-	# Adding the `sed 1q' prevents false positives on HP-UX, which says:
+	# Adding the 'sed 1q' prevents false positives on HP-UX, which says:
 	#   nm: unknown option "B" ignored
 	# Tru64's nm complains that /dev/null is an invalid object file
-	case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in
-	*/dev/null* | *'Invalid file or object type'*)
+	# MSYS converts /dev/null to NUL, MinGW nm treats NUL as empty
+	case $build_os in
+	mingw*) lt_bad_file=conftest.nm/nofile ;;
+	*) lt_bad_file=/dev/null ;;
+	esac
+	case `"$tmp_nm" -B $lt_bad_file 2>&1 | sed '1q'` in
+	*$lt_bad_file* | *'Invalid file or object type'*)
 	  lt_cv_path_NM="$tmp_nm -B"
-	  break
+	  break 2
 	  ;;
 	*)
 	  case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in
 	  */dev/null*)
 	    lt_cv_path_NM="$tmp_nm -p"
-	    break
+	    break 2
 	    ;;
 	  *)
 	    lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
@@ -3454,21 +3716,21 @@ else
 	esac
       fi
     done
-    IFS="$lt_save_ifs"
+    IFS=$lt_save_ifs
   done
   : ${lt_cv_path_NM=no}
 fi])
-if test "$lt_cv_path_NM" != "no"; then
-  NM="$lt_cv_path_NM"
+if test no != "$lt_cv_path_NM"; then
+  NM=$lt_cv_path_NM
 else
   # Didn't find any BSD compatible name lister, look for dumpbin.
   if test -n "$DUMPBIN"; then :
     # Let the user override the test.
   else
     AC_CHECK_TOOLS(DUMPBIN, [dumpbin "link -dump"], :)
-    case `$DUMPBIN -symbols /dev/null 2>&1 | sed '1q'` in
+    case `$DUMPBIN -symbols -headers /dev/null 2>&1 | sed '1q'` in
     *COFF*)
-      DUMPBIN="$DUMPBIN -symbols"
+      DUMPBIN="$DUMPBIN -symbols -headers"
       ;;
     *)
       DUMPBIN=:
@@ -3476,8 +3738,8 @@ else
     esac
   fi
   AC_SUBST([DUMPBIN])
-  if test "$DUMPBIN" != ":"; then
-    NM="$DUMPBIN"
+  if test : != "$DUMPBIN"; then
+    NM=$DUMPBIN
   fi
 fi
 test -z "$NM" && NM=nm
@@ -3523,8 +3785,8 @@ lt_cv_sharedlib_from_linklib_cmd,
 
 case $host_os in
 cygwin* | mingw* | pw32* | cegcc*)
-  # two different shell functions defined in ltmain.sh
-  # decide which to use based on capabilities of $DLLTOOL
+  # two different shell functions defined in ltmain.sh;
+  # decide which one to use based on capabilities of $DLLTOOL
   case `$DLLTOOL --help 2>&1` in
   *--identify-strict*)
     lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib
@@ -3536,7 +3798,7 @@ cygwin* | mingw* | pw32* | cegcc*)
   ;;
 *)
   # fallback: assume linklib IS sharedlib
-  lt_cv_sharedlib_from_linklib_cmd="$ECHO"
+  lt_cv_sharedlib_from_linklib_cmd=$ECHO
   ;;
 esac
 ])
@@ -3563,13 +3825,28 @@ AC_CACHE_CHECK([if $MANIFEST_TOOL is a manifest tool], [lt_cv_path_mainfest_tool
     lt_cv_path_mainfest_tool=yes
   fi
   rm -f conftest*])
-if test "x$lt_cv_path_mainfest_tool" != xyes; then
+if test yes != "$lt_cv_path_mainfest_tool"; then
   MANIFEST_TOOL=:
 fi
 _LT_DECL([], [MANIFEST_TOOL], [1], [Manifest tool])dnl
 ])# _LT_PATH_MANIFEST_TOOL
 
 
+# _LT_DLL_DEF_P([FILE])
+# ---------------------
+# True iff FILE is a Windows DLL '.def' file.
+# Keep in sync with func_dll_def_p in the libtool script
+AC_DEFUN([_LT_DLL_DEF_P],
+[dnl
+  test DEF = "`$SED -n dnl
+    -e '\''s/^[[	 ]]*//'\'' dnl Strip leading whitespace
+    -e '\''/^\(;.*\)*$/d'\'' dnl      Delete empty lines and comments
+    -e '\''s/^\(EXPORTS\|LIBRARY\)\([[	 ]].*\)*$/DEF/p'\'' dnl
+    -e q dnl                          Only consider the first "real" line
+    $1`" dnl
+])# _LT_DLL_DEF_P
+
+
 # LT_LIB_M
 # --------
 # check for math library
@@ -3577,15 +3854,15 @@ AC_DEFUN([LT_LIB_M],
 [AC_REQUIRE([AC_CANONICAL_HOST])dnl
 LIBM=
 case $host in
-*-*-beos* | *-*-cegcc* | *-*-cygwin* | *-*-haiku* | *-*-pw32* | *-*-darwin*)
+*-*-beos* | *-*-cegcc* | *-*-cygwin* | *-*-haiku* | *-*-mingw* | *-*-pw32* | *-*-darwin*)
   # These system don't have libm, or don't need it
   ;;
 *-ncr-sysv4.3*)
-  AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM="-lmw")
+  AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM=-lmw)
   AC_CHECK_LIB(m, cos, LIBM="$LIBM -lm")
   ;;
 *)
-  AC_CHECK_LIB(m, cos, LIBM="-lm")
+  AC_CHECK_LIB(m, cos, LIBM=-lm)
   ;;
 esac
 AC_SUBST([LIBM])
@@ -3604,7 +3881,7 @@ m4_defun([_LT_COMPILER_NO_RTTI],
 
 _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=
 
-if test "$GCC" = yes; then
+if test yes = "$GCC"; then
   case $cc_basename in
   nvcc*)
     _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -Xcompiler -fno-builtin' ;;
@@ -3656,7 +3933,7 @@ cygwin* | mingw* | pw32* | cegcc*)
   symcode='[[ABCDGISTW]]'
   ;;
 hpux*)
-  if test "$host_cpu" = ia64; then
+  if test ia64 = "$host_cpu"; then
     symcode='[[ABCDEGRST]]'
   fi
   ;;
@@ -3667,7 +3944,7 @@ osf*)
   symcode='[[BCDEGQRST]]'
   ;;
 solaris*)
-  symcode='[[BDRT]]'
+  symcode='[[BCDRT]]'
   ;;
 sco3.2v5*)
   symcode='[[DT]]'
@@ -3689,14 +3966,44 @@ case `$NM -V 2>&1` in
   symcode='[[ABCDGIRSTW]]' ;;
 esac
 
+if test "$lt_cv_nm_interface" = "MS dumpbin"; then
+  # Gets list of data symbols to import.
+  lt_cv_sys_global_symbol_to_import="sed -n -e 's/^I .* \(.*\)$/\1/p'"
+  # Adjust the below global symbol transforms to fixup imported variables.
+  lt_cdecl_hook=" -e 's/^I .* \(.*\)$/extern __declspec(dllimport) char \1;/p'"
+  lt_c_name_hook=" -e 's/^I .* \(.*\)$/  {\"\1\", (void *) 0},/p'"
+  lt_c_name_lib_hook="\
+  -e 's/^I .* \(lib.*\)$/  {\"\1\", (void *) 0},/p'\
+  -e 's/^I .* \(.*\)$/  {\"lib\1\", (void *) 0},/p'"
+else
+  # Disable hooks by default.
+  lt_cv_sys_global_symbol_to_import=
+  lt_cdecl_hook=
+  lt_c_name_hook=
+  lt_c_name_lib_hook=
+fi
+
 # Transform an extracted symbol line into a proper C declaration.
 # Some systems (esp. on ia64) link data and code symbols differently,
 # so use this general approach.
-lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"
+lt_cv_sys_global_symbol_to_cdecl="sed -n"\
+$lt_cdecl_hook\
+" -e 's/^T .* \(.*\)$/extern int \1();/p'"\
+" -e 's/^$symcode$symcode* .* \(.*\)$/extern char \1;/p'"
 
 # Transform an extracted symbol line into symbol name and symbol address
-lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([[^ ]]*\)[[ ]]*$/  {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/  {\"\2\", (void *) \&\2},/p'"
-lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: \([[^ ]]*\)[[ ]]*$/  {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \(lib[[^ ]]*\)$/  {\"\2\", (void *) \&\2},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/  {\"lib\2\", (void *) \&\2},/p'"
+lt_cv_sys_global_symbol_to_c_name_address="sed -n"\
+$lt_c_name_hook\
+" -e 's/^: \(.*\) .*$/  {\"\1\", (void *) 0},/p'"\
+" -e 's/^$symcode$symcode* .* \(.*\)$/  {\"\1\", (void *) \&\1},/p'"
+
+# Transform an extracted symbol line into symbol name with lib prefix and
+# symbol address.
+lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n"\
+$lt_c_name_lib_hook\
+" -e 's/^: \(.*\) .*$/  {\"\1\", (void *) 0},/p'"\
+" -e 's/^$symcode$symcode* .* \(lib.*\)$/  {\"\1\", (void *) \&\1},/p'"\
+" -e 's/^$symcode$symcode* .* \(.*\)$/  {\"lib\1\", (void *) \&\1},/p'"
 
 # Handle CRLF in mingw tool chain
 opt_cr=
@@ -3714,21 +4021,24 @@ for ac_symprfx in "" "_"; do
 
   # Write the raw and C identifiers.
   if test "$lt_cv_nm_interface" = "MS dumpbin"; then
-    # Fake it for dumpbin and say T for any non-static function
-    # and D for any global variable.
+    # Fake it for dumpbin and say T for any non-static function,
+    # D for any global variable and I for any imported variable.
     # Also find C++ and __fastcall symbols from MSVC++,
     # which start with @ or ?.
     lt_cv_sys_global_symbol_pipe="$AWK ['"\
 "     {last_section=section; section=\$ 3};"\
 "     /^COFF SYMBOL TABLE/{for(i in hide) delete hide[i]};"\
 "     /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\
+"     /^ *Symbol name *: /{split(\$ 0,sn,\":\"); si=substr(sn[2],2)};"\
+"     /^ *Type *: code/{print \"T\",si,substr(si,length(prfx))};"\
+"     /^ *Type *: data/{print \"I\",si,substr(si,length(prfx))};"\
 "     \$ 0!~/External *\|/{next};"\
 "     / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\
 "     {if(hide[section]) next};"\
-"     {f=0}; \$ 0~/\(\).*\|/{f=1}; {printf f ? \"T \" : \"D \"};"\
-"     {split(\$ 0, a, /\||\r/); split(a[2], s)};"\
-"     s[1]~/^[@?]/{print s[1], s[1]; next};"\
-"     s[1]~prfx {split(s[1],t,\"@\"); print t[1], substr(t[1],length(prfx))}"\
+"     {f=\"D\"}; \$ 0~/\(\).*\|/{f=\"T\"};"\
+"     {split(\$ 0,a,/\||\r/); split(a[2],s)};"\
+"     s[1]~/^[@?]/{print f,s[1],s[1]; next};"\
+"     s[1]~prfx {split(s[1],t,\"@\"); print f,t[1],substr(t[1],length(prfx))}"\
 "     ' prfx=^$ac_symprfx]"
   else
     lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[[	 ]]\($symcode$symcode*\)[[	 ]][[	 ]]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"
@@ -3768,11 +4078,11 @@ _LT_EOF
 	if $GREP ' nm_test_func$' "$nlist" >/dev/null; then
 	  cat <<_LT_EOF > conftest.$ac_ext
 /* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
-#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
-/* DATA imports from DLLs on WIN32 con't be const, because runtime
+#if defined _WIN32 || defined __CYGWIN__ || defined _WIN32_WCE
+/* DATA imports from DLLs on WIN32 can't be const, because runtime
    relocations are performed -- see ld's documentation on pseudo-relocs.  */
 # define LT@&t@_DLSYM_CONST
-#elif defined(__osf__)
+#elif defined __osf__
 /* This system does not cope well with relocations in const data.  */
 # define LT@&t@_DLSYM_CONST
 #else
@@ -3798,7 +4108,7 @@ lt__PROGRAM__LTX_preloaded_symbols[[]] =
 {
   { "@PROGRAM@", (void *) 0 },
 _LT_EOF
-	  $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/  {\"\2\", (void *) \&\2},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext
+	  $SED "s/^$symcode$symcode* .* \(.*\)$/  {\"\1\", (void *) \&\1},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext
 	  cat <<\_LT_EOF >> conftest.$ac_ext
   {0, (void *) 0}
 };
@@ -3818,9 +4128,9 @@ _LT_EOF
 	  mv conftest.$ac_objext conftstm.$ac_objext
 	  lt_globsym_save_LIBS=$LIBS
 	  lt_globsym_save_CFLAGS=$CFLAGS
-	  LIBS="conftstm.$ac_objext"
+	  LIBS=conftstm.$ac_objext
 	  CFLAGS="$CFLAGS$_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)"
-	  if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext}; then
+	  if AC_TRY_EVAL(ac_link) && test -s conftest$ac_exeext; then
 	    pipe_works=yes
 	  fi
 	  LIBS=$lt_globsym_save_LIBS
@@ -3841,7 +4151,7 @@ _LT_EOF
   rm -rf conftest* conftst*
 
   # Do not use the global_symbol_pipe unless it works.
-  if test "$pipe_works" = yes; then
+  if test yes = "$pipe_works"; then
     break
   else
     lt_cv_sys_global_symbol_pipe=
@@ -3868,12 +4178,16 @@ _LT_DECL([global_symbol_pipe], [lt_cv_sys_global_symbol_pipe], [1],
     [Take the output of nm and produce a listing of raw symbols and C names])
 _LT_DECL([global_symbol_to_cdecl], [lt_cv_sys_global_symbol_to_cdecl], [1],
     [Transform the output of nm in a proper C declaration])
+_LT_DECL([global_symbol_to_import], [lt_cv_sys_global_symbol_to_import], [1],
+    [Transform the output of nm into a list of symbols to manually relocate])
 _LT_DECL([global_symbol_to_c_name_address],
     [lt_cv_sys_global_symbol_to_c_name_address], [1],
     [Transform the output of nm in a C name address pair])
 _LT_DECL([global_symbol_to_c_name_address_lib_prefix],
     [lt_cv_sys_global_symbol_to_c_name_address_lib_prefix], [1],
     [Transform the output of nm in a C name address pair when lib prefix is needed])
+_LT_DECL([nm_interface], [lt_cv_nm_interface], [1],
+    [The name lister interface])
 _LT_DECL([], [nm_file_list_spec], [1],
     [Specify filename containing input files for $NM])
 ]) # _LT_CMD_GLOBAL_SYMBOLS
@@ -3889,17 +4203,18 @@ _LT_TAGVAR(lt_prog_compiler_static, $1)=
 
 m4_if([$1], [CXX], [
   # C++ specific cases for pic, static, wl, etc.
-  if test "$GXX" = yes; then
+  if test yes = "$GXX"; then
     _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
     _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
 
     case $host_os in
     aix*)
       # All AIX code is PIC.
-      if test "$host_cpu" = ia64; then
+      if test ia64 = "$host_cpu"; then
 	# AIX 5 now supports IA64 processor
 	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
       fi
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
       ;;
 
     amigaos*)
@@ -3910,8 +4225,8 @@ m4_if([$1], [CXX], [
         ;;
       m68k)
             # FIXME: we need at least 68020 code to build shared libraries, but
-            # adding the `-m68020' flag to GCC prevents building anything better,
-            # like `-m68040'.
+            # adding the '-m68020' flag to GCC prevents building anything better,
+            # like '-m68040'.
             _LT_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4'
         ;;
       esac
@@ -3927,6 +4242,11 @@ m4_if([$1], [CXX], [
       # (--disable-auto-import) libraries
       m4_if([$1], [GCJ], [],
 	[_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'])
+      case $host_os in
+      os2*)
+	_LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-static'
+	;;
+      esac
       ;;
     darwin* | rhapsody*)
       # PIC is the default on this platform
@@ -3976,7 +4296,7 @@ m4_if([$1], [CXX], [
     case $host_os in
       aix[[4-9]]*)
 	# All AIX code is PIC.
-	if test "$host_cpu" = ia64; then
+	if test ia64 = "$host_cpu"; then
 	  # AIX 5 now supports IA64 processor
 	  _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
 	else
@@ -4010,21 +4330,21 @@ m4_if([$1], [CXX], [
 	    ;;
 	esac
 	;;
-      freebsd* | dragonfly*)
+      freebsd* | dragonfly* | midnightbsd*)
 	# FreeBSD uses GNU C++
 	;;
       hpux9* | hpux10* | hpux11*)
 	case $cc_basename in
 	  CC*)
 	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-	    _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive'
-	    if test "$host_cpu" != ia64; then
+	    _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-a ${wl}archive'
+	    if test ia64 != "$host_cpu"; then
 	      _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z'
 	    fi
 	    ;;
 	  aCC*)
 	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-	    _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive'
+	    _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-a ${wl}archive'
 	    case $host_cpu in
 	    hppa*64*|ia64*)
 	      # +Z the default
@@ -4053,7 +4373,7 @@ m4_if([$1], [CXX], [
 	    ;;
 	esac
 	;;
-      linux* | k*bsd*-gnu | kopensolaris*-gnu)
+      linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
 	case $cc_basename in
 	  KCC*)
 	    # KAI C++ Compiler
@@ -4061,7 +4381,7 @@ m4_if([$1], [CXX], [
 	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
 	    ;;
 	  ecpc* )
-	    # old Intel C++ for x86_64 which still supported -KPIC.
+	    # old Intel C++ for x86_64, which still supported -KPIC.
 	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
 	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
 	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
@@ -4206,17 +4526,18 @@ m4_if([$1], [CXX], [
   fi
 ],
 [
-  if test "$GCC" = yes; then
+  if test yes = "$GCC"; then
     _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
     _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
 
     case $host_os in
       aix*)
       # All AIX code is PIC.
-      if test "$host_cpu" = ia64; then
+      if test ia64 = "$host_cpu"; then
 	# AIX 5 now supports IA64 processor
 	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
       fi
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
       ;;
 
     amigaos*)
@@ -4227,8 +4548,8 @@ m4_if([$1], [CXX], [
         ;;
       m68k)
             # FIXME: we need at least 68020 code to build shared libraries, but
-            # adding the `-m68020' flag to GCC prevents building anything better,
-            # like `-m68040'.
+            # adding the '-m68020' flag to GCC prevents building anything better,
+            # like '-m68040'.
             _LT_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4'
         ;;
       esac
@@ -4245,6 +4566,11 @@ m4_if([$1], [CXX], [
       # (--disable-auto-import) libraries
       m4_if([$1], [GCJ], [],
 	[_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'])
+      case $host_os in
+      os2*)
+	_LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-static'
+	;;
+      esac
       ;;
 
     darwin* | rhapsody*)
@@ -4315,7 +4641,7 @@ m4_if([$1], [CXX], [
     case $host_os in
     aix*)
       _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-      if test "$host_cpu" = ia64; then
+      if test ia64 = "$host_cpu"; then
 	# AIX 5 now supports IA64 processor
 	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
       else
@@ -4323,11 +4649,30 @@ m4_if([$1], [CXX], [
       fi
       ;;
 
+    darwin* | rhapsody*)
+      # PIC is the default on this platform
+      # Common symbols not allowed in MH_DYLIB files
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common'
+      case $cc_basename in
+      nagfor*)
+        # NAG Fortran compiler
+        _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,-Wl,,'
+        _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'
+        _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+        ;;
+      esac
+      ;;
+
     mingw* | cygwin* | pw32* | os2* | cegcc*)
       # This hack is so that the source file can tell whether it is being
       # built for inclusion in a dll (and should export symbols for example).
       m4_if([$1], [GCJ], [],
 	[_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'])
+      case $host_os in
+      os2*)
+	_LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-static'
+	;;
+      esac
       ;;
 
     hpux9* | hpux10* | hpux11*)
@@ -4343,7 +4688,7 @@ m4_if([$1], [CXX], [
 	;;
       esac
       # Is there a better lt_prog_compiler_static that works with the bundled CC?
-      _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive'
+      _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-a ${wl}archive'
       ;;
 
     irix5* | irix6* | nonstopux*)
@@ -4352,9 +4697,9 @@ m4_if([$1], [CXX], [
       _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
       ;;
 
-    linux* | k*bsd*-gnu | kopensolaris*-gnu)
+    linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
       case $cc_basename in
-      # old Intel for x86_64 which still supported -KPIC.
+      # old Intel for x86_64, which still supported -KPIC.
       ecc*)
 	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
 	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
@@ -4379,6 +4724,12 @@ m4_if([$1], [CXX], [
 	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'
 	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
 	;;
+      tcc*)
+	# Fabrice Bellard et al's Tiny C Compiler
+	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+	_LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
+	;;
       pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*)
         # Portland Group compilers (*not* the Pentium gcc compiler,
 	# which looks to be a dead project)
@@ -4476,7 +4827,7 @@ m4_if([$1], [CXX], [
       ;;
 
     sysv4*MP*)
-      if test -d /usr/nec ;then
+      if test -d /usr/nec; then
 	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-Kconform_pic'
 	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
       fi
@@ -4505,7 +4856,7 @@ m4_if([$1], [CXX], [
   fi
 ])
 case $host_os in
-  # For platforms which do not support PIC, -DPIC is meaningless:
+  # For platforms that do not support PIC, -DPIC is meaningless:
   *djgpp*)
     _LT_TAGVAR(lt_prog_compiler_pic, $1)=
     ;;
@@ -4571,17 +4922,21 @@ m4_if([$1], [CXX], [
   case $host_os in
   aix[[4-9]]*)
     # If we're using GNU nm, then we don't want the "-C" option.
-    # -C means demangle to AIX nm, but means don't demangle with GNU nm
-    # Also, AIX nm treats weak defined symbols like other global defined
-    # symbols, whereas GNU nm marks them as "W".
+    # -C means demangle to GNU nm, but means don't demangle to AIX nm.
+    # Without the "-l" option, or with the "-B" option, AIX nm treats
+    # weak defined symbols like other global defined symbols, whereas
+    # GNU nm marks them as "W".
+    # While the 'weak' keyword is ignored in the Export File, we need
+    # it in the Import File for the 'aix-soname' feature, so we have
+    # to replace the "-B" option with "-P" for AIX nm.
     if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
-      _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+      _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols'
     else
-      _LT_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+      _LT_TAGVAR(export_symbols_cmds, $1)='`func_echo_all $NM | $SED -e '\''s/B\([[^B]]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "L") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && ([substr](\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols'
     fi
     ;;
   pw32*)
-    _LT_TAGVAR(export_symbols_cmds, $1)="$ltdll_cmds"
+    _LT_TAGVAR(export_symbols_cmds, $1)=$ltdll_cmds
     ;;
   cygwin* | mingw* | cegcc*)
     case $cc_basename in
@@ -4627,9 +4982,9 @@ m4_if([$1], [CXX], [
   # included in the symbol list
   _LT_TAGVAR(include_expsyms, $1)=
   # exclude_expsyms can be an extended regexp of symbols to exclude
-  # it will be wrapped by ` (' and `)$', so one must not match beginning or
-  # end of line.  Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc',
-  # as well as any symbol that contains `d'.
+  # it will be wrapped by ' (' and ')$', so one must not match beginning or
+  # end of line.  Example: 'a|bc|.*d.*' will exclude the symbols 'a' and 'bc',
+  # as well as any symbol that contains 'd'.
   _LT_TAGVAR(exclude_expsyms, $1)=['_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*']
   # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out
   # platforms (ab)use it in PIC code, but their linkers get confused if
@@ -4645,7 +5000,7 @@ dnl Note also adjust exclude_expsyms for C++ above.
     # FIXME: the MSVC++ port hasn't been tested in a loooong time
     # When not using gcc, we currently assume that we are using
     # Microsoft Visual C++.
-    if test "$GCC" != yes; then
+    if test yes != "$GCC"; then
       with_gnu_ld=no
     fi
     ;;
@@ -4653,7 +5008,7 @@ dnl Note also adjust exclude_expsyms for C++ above.
     # we just hope/assume this is gcc and not c89 (= MSVC++)
     with_gnu_ld=yes
     ;;
-  openbsd*)
+  openbsd* | bitrig*)
     with_gnu_ld=no
     ;;
   esac
@@ -4663,7 +5018,7 @@ dnl Note also adjust exclude_expsyms for C++ above.
   # On some targets, GNU ld is compatible enough with the native linker
   # that we're better off using the native interface for both.
   lt_use_gnu_ld_interface=no
-  if test "$with_gnu_ld" = yes; then
+  if test yes = "$with_gnu_ld"; then
     case $host_os in
       aix*)
 	# The AIX port of GNU ld has always aspired to compatibility
@@ -4685,24 +5040,24 @@ dnl Note also adjust exclude_expsyms for C++ above.
     esac
   fi
 
-  if test "$lt_use_gnu_ld_interface" = yes; then
+  if test yes = "$lt_use_gnu_ld_interface"; then
     # If archive_cmds runs LD, not CC, wlarc should be empty
-    wlarc='${wl}'
+    wlarc='$wl'
 
     # Set some defaults for GNU ld with shared library support. These
     # are reset later if shared libraries are not supported. Putting them
     # here allows them to be overridden if necessary.
     runpath_var=LD_RUN_PATH
-    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
-    _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
+    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
+    _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic'
     # ancient GNU ld didn't support --whole-archive et. al.
     if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then
-      _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
+      _LT_TAGVAR(whole_archive_flag_spec, $1)=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive'
     else
       _LT_TAGVAR(whole_archive_flag_spec, $1)=
     fi
     supports_anon_versioning=no
-    case `$LD -v 2>&1` in
+    case `$LD -v | $SED -e 's/([[^)]]\+)\s\+//' 2>&1` in
       *GNU\ gold*) supports_anon_versioning=yes ;;
       *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.10.*) ;; # catch versions < 2.11
       *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
@@ -4715,7 +5070,7 @@ dnl Note also adjust exclude_expsyms for C++ above.
     case $host_os in
     aix[[3-9]]*)
       # On AIX/PPC, the GNU linker is very broken
-      if test "$host_cpu" != ia64; then
+      if test ia64 != "$host_cpu"; then
 	_LT_TAGVAR(ld_shlibs, $1)=no
 	cat <<_LT_EOF 1>&2
 
@@ -4734,7 +5089,7 @@ _LT_EOF
       case $host_cpu in
       powerpc)
             # see comment about AmigaOS4 .so support
-            _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+            _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
             _LT_TAGVAR(archive_expsym_cmds, $1)=''
         ;;
       m68k)
@@ -4750,7 +5105,7 @@ _LT_EOF
 	_LT_TAGVAR(allow_undefined_flag, $1)=unsupported
 	# Joseph Beckenbach <jrb3@best.com> says some releases of gcc
 	# support --undefined.  This deserves some investigation.  FIXME
-	_LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+	_LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
       else
 	_LT_TAGVAR(ld_shlibs, $1)=no
       fi
@@ -4760,7 +5115,7 @@ _LT_EOF
       # _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless,
       # as there is no search path for DLLs.
       _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
-      _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-all-symbols'
+      _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-all-symbols'
       _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
       _LT_TAGVAR(always_export_symbols, $1)=no
       _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
@@ -4768,61 +5123,90 @@ _LT_EOF
       _LT_TAGVAR(exclude_expsyms, $1)=['[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname']
 
       if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
-        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
-	# If the export-symbols file already is a .def file (1st line
-	# is EXPORTS), use it as is; otherwise, prepend...
-	_LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
-	  cp $export_symbols $output_objdir/$soname.def;
-	else
-	  echo EXPORTS > $output_objdir/$soname.def;
-	  cat $export_symbols >> $output_objdir/$soname.def;
-	fi~
-	$CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+	# If the export-symbols file already is a .def file, use it as
+	# is; otherwise, prepend EXPORTS...
+	_LT_TAGVAR(archive_expsym_cmds, $1)='if _LT_DLL_DEF_P([$export_symbols]); then
+          cp $export_symbols $output_objdir/$soname.def;
+        else
+          echo EXPORTS > $output_objdir/$soname.def;
+          cat $export_symbols >> $output_objdir/$soname.def;
+        fi~
+        $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
       else
 	_LT_TAGVAR(ld_shlibs, $1)=no
       fi
       ;;
 
     haiku*)
-      _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+      _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
       _LT_TAGVAR(link_all_deplibs, $1)=yes
       ;;
 
+    os2*)
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+      _LT_TAGVAR(hardcode_minus_L, $1)=yes
+      _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+      shrext_cmds=.dll
+      _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      _LT_TAGVAR(archive_expsym_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	prefix_cmds="$SED"~
+	if test EXPORTS = "`$SED 1q $export_symbols`"; then
+	  prefix_cmds="$prefix_cmds -e 1d";
+	fi~
+	prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~
+	cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      _LT_TAGVAR(old_archive_from_new_cmds, $1)='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
+      _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+      _LT_TAGVAR(file_list_spec, $1)='@'
+      ;;
+
     interix[[3-9]]*)
       _LT_TAGVAR(hardcode_direct, $1)=no
       _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
-      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
-      _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir'
+      _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E'
       # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
       # Instead, shared libraries are loaded at an image base (0x10000000 by
       # default) and relocated if they conflict, which is a slow very memory
       # consuming and fragmenting process.  To avoid this, we pick a random,
       # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
       # time.  Moving up from 0x10000000 also allows more sbrk(2) space.
-      _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
-      _LT_TAGVAR(archive_expsym_cmds, $1)='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+      _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+      _LT_TAGVAR(archive_expsym_cmds, $1)='sed "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--retain-symbols-file,$output_objdir/$soname.expsym $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
       ;;
 
     gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu)
       tmp_diet=no
-      if test "$host_os" = linux-dietlibc; then
+      if test linux-dietlibc = "$host_os"; then
 	case $cc_basename in
 	  diet\ *) tmp_diet=yes;;	# linux-dietlibc with static linking (!diet-dyn)
 	esac
       fi
       if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \
-	 && test "$tmp_diet" = no
+	 && test no = "$tmp_diet"
       then
 	tmp_addflag=' $pic_flag'
 	tmp_sharedflag='-shared'
 	case $cc_basename,$host_cpu in
         pgcc*)				# Portland Group C compiler
-	  _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
+	  _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
 	  tmp_addflag=' $pic_flag'
 	  ;;
 	pgf77* | pgf90* | pgf95* | pgfortran*)
 					# Portland Group f77 and f90 compilers
-	  _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
+	  _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
 	  tmp_addflag=' $pic_flag -Mnomain' ;;
 	ecc*,ia64* | icc*,ia64*)	# Intel C compiler on ia64
 	  tmp_addflag=' -i_dynamic' ;;
@@ -4833,42 +5217,47 @@ _LT_EOF
 	lf95*)				# Lahey Fortran 8.1
 	  _LT_TAGVAR(whole_archive_flag_spec, $1)=
 	  tmp_sharedflag='--shared' ;;
+        nagfor*)                        # NAGFOR 5.3
+          tmp_sharedflag='-Wl,-shared' ;;
 	xl[[cC]]* | bgxl[[cC]]* | mpixl[[cC]]*) # IBM XL C 8.0 on PPC (deal with xlf below)
 	  tmp_sharedflag='-qmkshrobj'
 	  tmp_addflag= ;;
 	nvcc*)	# Cuda Compiler Driver 2.2
-	  _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
+	  _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
 	  _LT_TAGVAR(compiler_needs_object, $1)=yes
 	  ;;
 	esac
 	case `$CC -V 2>&1 | sed 5q` in
 	*Sun\ C*)			# Sun C 5.9
-	  _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
+	  _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
 	  _LT_TAGVAR(compiler_needs_object, $1)=yes
 	  tmp_sharedflag='-G' ;;
 	*Sun\ F*)			# Sun Fortran 8.3
 	  tmp_sharedflag='-G' ;;
 	esac
-	_LT_TAGVAR(archive_cmds, $1)='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+	_LT_TAGVAR(archive_cmds, $1)='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
 
-        if test "x$supports_anon_versioning" = xyes; then
+        if test yes = "$supports_anon_versioning"; then
           _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~
-	    cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
-	    echo "local: *; };" >> $output_objdir/$libname.ver~
-	    $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
+            cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+            echo "local: *; };" >> $output_objdir/$libname.ver~
+            $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-version-script $wl$output_objdir/$libname.ver -o $lib'
         fi
 
 	case $cc_basename in
+	tcc*)
+	  _LT_TAGVAR(export_dynamic_flag_spec, $1)='-rdynamic'
+	  ;;
 	xlf* | bgf* | bgxlf* | mpixlf*)
 	  # IBM XL Fortran 10.1 on PPC cannot create shared libs itself
 	  _LT_TAGVAR(whole_archive_flag_spec, $1)='--whole-archive$convenience --no-whole-archive'
-	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
 	  _LT_TAGVAR(archive_cmds, $1)='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib'
-	  if test "x$supports_anon_versioning" = xyes; then
+	  if test yes = "$supports_anon_versioning"; then
 	    _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~
-	      cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
-	      echo "local: *; };" >> $output_objdir/$libname.ver~
-	      $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib'
+              cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+              echo "local: *; };" >> $output_objdir/$libname.ver~
+              $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib'
 	  fi
 	  ;;
 	esac
@@ -4882,8 +5271,8 @@ _LT_EOF
 	_LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
 	wlarc=
       else
-	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
-	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
       fi
       ;;
 
@@ -4901,8 +5290,8 @@ _LT_EOF
 
 _LT_EOF
       elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
-	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
-	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
       else
 	_LT_TAGVAR(ld_shlibs, $1)=no
       fi
@@ -4914,7 +5303,7 @@ _LT_EOF
 	_LT_TAGVAR(ld_shlibs, $1)=no
 	cat <<_LT_EOF 1>&2
 
-*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not
+*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 cannot
 *** reliably create shared libraries on SCO systems.  Therefore, libtool
 *** is disabling shared libraries support.  We urge you to upgrade GNU
 *** binutils to release 2.16.91.0.3 or newer.  Another option is to modify
@@ -4929,9 +5318,9 @@ _LT_EOF
 	  # DT_RUNPATH tag from executables and libraries.  But doing so
 	  # requires that you compile everything twice, which is a pain.
 	  if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
-	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
-	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
-	    _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
+	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	    _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
 	  else
 	    _LT_TAGVAR(ld_shlibs, $1)=no
 	  fi
@@ -4948,15 +5337,15 @@ _LT_EOF
 
     *)
       if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
-	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
-	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
       else
 	_LT_TAGVAR(ld_shlibs, $1)=no
       fi
       ;;
     esac
 
-    if test "$_LT_TAGVAR(ld_shlibs, $1)" = no; then
+    if test no = "$_LT_TAGVAR(ld_shlibs, $1)"; then
       runpath_var=
       _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
       _LT_TAGVAR(export_dynamic_flag_spec, $1)=
@@ -4972,7 +5361,7 @@ _LT_EOF
       # Note: this linker hardcodes the directories in LIBPATH if there
       # are no directories specified by -L.
       _LT_TAGVAR(hardcode_minus_L, $1)=yes
-      if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then
+      if test yes = "$GCC" && test -z "$lt_prog_compiler_static"; then
 	# Neither direct hardcoding nor static linking is supported with a
 	# broken collect2.
 	_LT_TAGVAR(hardcode_direct, $1)=unsupported
@@ -4980,34 +5369,57 @@ _LT_EOF
       ;;
 
     aix[[4-9]]*)
-      if test "$host_cpu" = ia64; then
+      if test ia64 = "$host_cpu"; then
 	# On IA64, the linker does run time linking by default, so we don't
 	# have to do anything special.
 	aix_use_runtimelinking=no
 	exp_sym_flag='-Bexport'
-	no_entry_flag=""
+	no_entry_flag=
       else
 	# If we're using GNU nm, then we don't want the "-C" option.
-	# -C means demangle to AIX nm, but means don't demangle with GNU nm
-	# Also, AIX nm treats weak defined symbols like other global
-	# defined symbols, whereas GNU nm marks them as "W".
+	# -C means demangle to GNU nm, but means don't demangle to AIX nm.
+	# Without the "-l" option, or with the "-B" option, AIX nm treats
+	# weak defined symbols like other global defined symbols, whereas
+	# GNU nm marks them as "W".
+	# While the 'weak' keyword is ignored in the Export File, we need
+	# it in the Import File for the 'aix-soname' feature, so we have
+	# to replace the "-B" option with "-P" for AIX nm.
 	if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
-	  _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+	  _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols'
 	else
-	  _LT_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+	  _LT_TAGVAR(export_symbols_cmds, $1)='`func_echo_all $NM | $SED -e '\''s/B\([[^B]]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "L") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && ([substr](\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols'
 	fi
 	aix_use_runtimelinking=no
 
 	# Test if we are trying to use run time linking or normal
 	# AIX style linking. If -brtl is somewhere in LDFLAGS, we
-	# need to do runtime linking.
+	# have runtime linking enabled, and use it for executables.
+	# For shared libraries, we enable/disable runtime linking
+	# depending on the kind of the shared library created -
+	# when "with_aix_soname,aix_use_runtimelinking" is:
+	# "aix,no"   lib.a(lib.so.V) shared, rtl:no,  for executables
+	# "aix,yes"  lib.so          shared, rtl:yes, for executables
+	#            lib.a           static archive
+	# "both,no"  lib.so.V(shr.o) shared, rtl:yes
+	#            lib.a(lib.so.V) shared, rtl:no,  for executables
+	# "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables
+	#            lib.a(lib.so.V) shared, rtl:no
+	# "svr4,*"   lib.so.V(shr.o) shared, rtl:yes, for executables
+	#            lib.a           static archive
 	case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*)
 	  for ld_flag in $LDFLAGS; do
-	  if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then
+	  if (test x-brtl = "x$ld_flag" || test x-Wl,-brtl = "x$ld_flag"); then
 	    aix_use_runtimelinking=yes
 	    break
 	  fi
 	  done
+	  if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then
+	    # With aix-soname=svr4, we create the lib.so.V shared archives only,
+	    # so we don't have lib.a shared libs to link our executables.
+	    # We have to force runtime linking in this case.
+	    aix_use_runtimelinking=yes
+	    LDFLAGS="$LDFLAGS -Wl,-brtl"
+	  fi
 	  ;;
 	esac
 
@@ -5026,13 +5438,21 @@ _LT_EOF
       _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
       _LT_TAGVAR(hardcode_libdir_separator, $1)=':'
       _LT_TAGVAR(link_all_deplibs, $1)=yes
-      _LT_TAGVAR(file_list_spec, $1)='${wl}-f,'
+      _LT_TAGVAR(file_list_spec, $1)='$wl-f,'
+      case $with_aix_soname,$aix_use_runtimelinking in
+      aix,*) ;; # traditional, no import file
+      svr4,* | *,yes) # use import file
+	# The Import File defines what to hardcode.
+	_LT_TAGVAR(hardcode_direct, $1)=no
+	_LT_TAGVAR(hardcode_direct_absolute, $1)=no
+	;;
+      esac
 
-      if test "$GCC" = yes; then
+      if test yes = "$GCC"; then
 	case $host_os in aix4.[[012]]|aix4.[[012]].*)
 	# We only want to do this on AIX 4.2 and lower, the check
 	# below for broken collect2 doesn't work under 4.3+
-	  collect2name=`${CC} -print-prog-name=collect2`
+	  collect2name=`$CC -print-prog-name=collect2`
 	  if test -f "$collect2name" &&
 	   strings "$collect2name" | $GREP resolve_lib_name >/dev/null
 	  then
@@ -5051,61 +5471,80 @@ _LT_EOF
 	  ;;
 	esac
 	shared_flag='-shared'
-	if test "$aix_use_runtimelinking" = yes; then
-	  shared_flag="$shared_flag "'${wl}-G'
+	if test yes = "$aix_use_runtimelinking"; then
+	  shared_flag="$shared_flag "'$wl-G'
 	fi
+	# Need to ensure runtime linking is disabled for the traditional
+	# shared library, or the linker may eventually find shared libraries
+	# /with/ Import File - we do not want to mix them.
+	shared_flag_aix='-shared'
+	shared_flag_svr4='-shared $wl-G'
       else
 	# not using gcc
-	if test "$host_cpu" = ia64; then
+	if test ia64 = "$host_cpu"; then
 	# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
 	# chokes on -Wl,-G. The following line is correct:
 	  shared_flag='-G'
 	else
-	  if test "$aix_use_runtimelinking" = yes; then
-	    shared_flag='${wl}-G'
+	  if test yes = "$aix_use_runtimelinking"; then
+	    shared_flag='$wl-G'
 	  else
-	    shared_flag='${wl}-bM:SRE'
+	    shared_flag='$wl-bM:SRE'
 	  fi
+	  shared_flag_aix='$wl-bM:SRE'
+	  shared_flag_svr4='$wl-G'
 	fi
       fi
 
-      _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-bexpall'
+      _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-bexpall'
       # It seems that -bexpall does not export symbols beginning with
       # underscore (_), so it is better to generate a list of symbols to export.
       _LT_TAGVAR(always_export_symbols, $1)=yes
-      if test "$aix_use_runtimelinking" = yes; then
+      if test aix,yes = "$with_aix_soname,$aix_use_runtimelinking"; then
 	# Warning - without using the other runtime loading flags (-brtl),
 	# -berok will link without error, but may produce a broken library.
 	_LT_TAGVAR(allow_undefined_flag, $1)='-berok'
         # Determine the default libpath from the value encoded in an
         # empty executable.
         _LT_SYS_MODULE_PATH_AIX([$1])
-        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
-        _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"
+        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-blibpath:$libdir:'"$aix_libpath"
+        _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs $wl'$no_entry_flag' $compiler_flags `if test -n "$allow_undefined_flag"; then func_echo_all "$wl$allow_undefined_flag"; else :; fi` $wl'$exp_sym_flag:\$export_symbols' '$shared_flag
       else
-	if test "$host_cpu" = ia64; then
-	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib'
+	if test ia64 = "$host_cpu"; then
+	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R $libdir:/usr/lib:/lib'
 	  _LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs"
-	  _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"
+	  _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\$wl$no_entry_flag"' $compiler_flags $wl$allow_undefined_flag '"\$wl$exp_sym_flag:\$export_symbols"
 	else
 	 # Determine the default libpath from the value encoded in an
 	 # empty executable.
 	 _LT_SYS_MODULE_PATH_AIX([$1])
-	 _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
+	 _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-blibpath:$libdir:'"$aix_libpath"
 	  # Warning - without using the other run time loading flags,
 	  # -berok will link without error, but may produce a broken library.
-	  _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok'
-	  _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok'
-	  if test "$with_gnu_ld" = yes; then
+	  _LT_TAGVAR(no_undefined_flag, $1)=' $wl-bernotok'
+	  _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-berok'
+	  if test yes = "$with_gnu_ld"; then
 	    # We only use this code for GNU lds that support --whole-archive.
-	    _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive'
+	    _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive$convenience $wl--no-whole-archive'
 	  else
 	    # Exported symbols can be pulled into shared objects from archives
 	    _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience'
 	  fi
 	  _LT_TAGVAR(archive_cmds_need_lc, $1)=yes
-	  # This is similar to how AIX traditionally builds its shared libraries.
-	  _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
+	  _LT_TAGVAR(archive_expsym_cmds, $1)='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d'
+	  # -brtl affects multiple linker settings, -berok does not and is overridden later
+	  compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\\([[, ]]\\)%-berok\\1%g"`'
+	  if test svr4 != "$with_aix_soname"; then
+	    # This is similar to how AIX traditionally builds its shared libraries.
+	    _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname'
+	  fi
+	  if test aix != "$with_aix_soname"; then
+	    _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp'
+	  else
+	    # used by -dlpreopen to get the symbols
+	    _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$MV  $output_objdir/$realname.d/$soname $output_objdir'
+	  fi
+	  _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$RM -r $output_objdir/$realname.d'
 	fi
       fi
       ;;
@@ -5114,7 +5553,7 @@ _LT_EOF
       case $host_cpu in
       powerpc)
             # see comment about AmigaOS4 .so support
-            _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+            _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
             _LT_TAGVAR(archive_expsym_cmds, $1)=''
         ;;
       m68k)
@@ -5144,16 +5583,17 @@ _LT_EOF
 	# Tell ltmain to make .lib files, not .a files.
 	libext=lib
 	# Tell ltmain to make .dll files, not .so files.
-	shrext_cmds=".dll"
+	shrext_cmds=.dll
 	# FIXME: Setting linknames here is a bad hack.
-	_LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames='
-	_LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
-	    sed -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp;
-	  else
-	    sed -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp;
-	  fi~
-	  $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
-	  linknames='
+	_LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames='
+	_LT_TAGVAR(archive_expsym_cmds, $1)='if _LT_DLL_DEF_P([$export_symbols]); then
+            cp "$export_symbols" "$output_objdir/$soname.def";
+            echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp";
+          else
+            $SED -e '\''s/^/-link -EXPORT:/'\'' < $export_symbols > $output_objdir/$soname.exp;
+          fi~
+          $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
+          linknames='
 	# The linker will not automatically build a static lib if we build a DLL.
 	# _LT_TAGVAR(old_archive_from_new_cmds, $1)='true'
 	_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
@@ -5162,18 +5602,18 @@ _LT_EOF
 	# Don't use ranlib
 	_LT_TAGVAR(old_postinstall_cmds, $1)='chmod 644 $oldlib'
 	_LT_TAGVAR(postlink_cmds, $1)='lt_outputfile="@OUTPUT@"~
-	  lt_tool_outputfile="@TOOL_OUTPUT@"~
-	  case $lt_outputfile in
-	    *.exe|*.EXE) ;;
-	    *)
-	      lt_outputfile="$lt_outputfile.exe"
-	      lt_tool_outputfile="$lt_tool_outputfile.exe"
-	      ;;
-	  esac~
-	  if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then
-	    $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;
-	    $RM "$lt_outputfile.manifest";
-	  fi'
+          lt_tool_outputfile="@TOOL_OUTPUT@"~
+          case $lt_outputfile in
+            *.exe|*.EXE) ;;
+            *)
+              lt_outputfile=$lt_outputfile.exe
+              lt_tool_outputfile=$lt_tool_outputfile.exe
+              ;;
+          esac~
+          if test : != "$MANIFEST_TOOL" && test -f "$lt_outputfile.manifest"; then
+            $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;
+            $RM "$lt_outputfile.manifest";
+          fi'
 	;;
       *)
 	# Assume MSVC wrapper
@@ -5182,7 +5622,7 @@ _LT_EOF
 	# Tell ltmain to make .lib files, not .a files.
 	libext=lib
 	# Tell ltmain to make .dll files, not .so files.
-	shrext_cmds=".dll"
+	shrext_cmds=.dll
 	# FIXME: Setting linknames here is a bad hack.
 	_LT_TAGVAR(archive_cmds, $1)='$CC -o $lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames='
 	# The linker will automatically build a .lib file if we build a DLL.
@@ -5224,7 +5664,7 @@ _LT_EOF
       ;;
 
     # FreeBSD 3 and greater uses gcc -shared to do shared libraries.
-    freebsd* | dragonfly*)
+    freebsd* | dragonfly* | midnightbsd*)
       _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
       _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
       _LT_TAGVAR(hardcode_direct, $1)=yes
@@ -5232,33 +5672,33 @@ _LT_EOF
       ;;
 
     hpux9*)
-      if test "$GCC" = yes; then
-	_LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+      if test yes = "$GCC"; then
+	_LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared $pic_flag $wl+b $wl$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
       else
-	_LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+	_LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
       fi
-      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir'
       _LT_TAGVAR(hardcode_libdir_separator, $1)=:
       _LT_TAGVAR(hardcode_direct, $1)=yes
 
       # hardcode_minus_L: Not really in the search PATH,
       # but as the default location of the library.
       _LT_TAGVAR(hardcode_minus_L, $1)=yes
-      _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+      _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E'
       ;;
 
     hpux10*)
-      if test "$GCC" = yes && test "$with_gnu_ld" = no; then
-	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+      if test yes,no = "$GCC,$with_gnu_ld"; then
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
       else
 	_LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
       fi
-      if test "$with_gnu_ld" = no; then
-	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
+      if test no = "$with_gnu_ld"; then
+	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir'
 	_LT_TAGVAR(hardcode_libdir_separator, $1)=:
 	_LT_TAGVAR(hardcode_direct, $1)=yes
 	_LT_TAGVAR(hardcode_direct_absolute, $1)=yes
-	_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+	_LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E'
 	# hardcode_minus_L: Not really in the search PATH,
 	# but as the default location of the library.
 	_LT_TAGVAR(hardcode_minus_L, $1)=yes
@@ -5266,25 +5706,25 @@ _LT_EOF
       ;;
 
     hpux11*)
-      if test "$GCC" = yes && test "$with_gnu_ld" = no; then
+      if test yes,no = "$GCC,$with_gnu_ld"; then
 	case $host_cpu in
 	hppa*64*)
-	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl+h $wl$soname -o $lib $libobjs $deplibs $compiler_flags'
 	  ;;
 	ia64*)
-	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
+	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $wl+h $wl$soname $wl+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
 	  ;;
 	*)
-	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
 	  ;;
 	esac
       else
 	case $host_cpu in
 	hppa*64*)
-	  _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  _LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname -o $lib $libobjs $deplibs $compiler_flags'
 	  ;;
 	ia64*)
-	  _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
+	  _LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname $wl+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
 	  ;;
 	*)
 	m4_if($1, [], [
@@ -5292,14 +5732,14 @@ _LT_EOF
 	  # (HP92453-01 A.11.01.20 doesn't, HP92453-01 B.11.X.35175-35176.GP does)
 	  _LT_LINKER_OPTION([if $CC understands -b],
 	    _LT_TAGVAR(lt_cv_prog_compiler__b, $1), [-b],
-	    [_LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'],
+	    [_LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'],
 	    [_LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'])],
-	  [_LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'])
+	  [_LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'])
 	  ;;
 	esac
       fi
-      if test "$with_gnu_ld" = no; then
-	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
+      if test no = "$with_gnu_ld"; then
+	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir'
 	_LT_TAGVAR(hardcode_libdir_separator, $1)=:
 
 	case $host_cpu in
@@ -5310,7 +5750,7 @@ _LT_EOF
 	*)
 	  _LT_TAGVAR(hardcode_direct, $1)=yes
 	  _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
-	  _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+	  _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E'
 
 	  # hardcode_minus_L: Not really in the search PATH,
 	  # but as the default location of the library.
@@ -5321,16 +5761,16 @@ _LT_EOF
       ;;
 
     irix5* | irix6* | nonstopux*)
-      if test "$GCC" = yes; then
-	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+      if test yes = "$GCC"; then
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
 	# Try to use the -exported_symbol ld option, if it does not
 	# work, assume that -exports_file does not work either and
 	# implicitly export all symbols.
 	# This should be the same for all languages, so no per-tag cache variable.
 	AC_CACHE_CHECK([whether the $host_os linker accepts -exported_symbol],
 	  [lt_cv_irix_exported_symbol],
-	  [save_LDFLAGS="$LDFLAGS"
-	   LDFLAGS="$LDFLAGS -shared ${wl}-exported_symbol ${wl}foo ${wl}-update_registry ${wl}/dev/null"
+	  [save_LDFLAGS=$LDFLAGS
+	   LDFLAGS="$LDFLAGS -shared $wl-exported_symbol ${wl}foo $wl-update_registry $wl/dev/null"
 	   AC_LINK_IFELSE(
 	     [AC_LANG_SOURCE(
 	        [AC_LANG_CASE([C], [[int foo (void) { return 0; }]],
@@ -5343,21 +5783,31 @@ _LT_EOF
       end]])])],
 	      [lt_cv_irix_exported_symbol=yes],
 	      [lt_cv_irix_exported_symbol=no])
-           LDFLAGS="$save_LDFLAGS"])
-	if test "$lt_cv_irix_exported_symbol" = yes; then
-          _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations ${wl}-exports_file ${wl}$export_symbols -o $lib'
+           LDFLAGS=$save_LDFLAGS])
+	if test yes = "$lt_cv_irix_exported_symbol"; then
+          _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations $wl-exports_file $wl$export_symbols -o $lib'
 	fi
       else
-	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
-	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -exports_file $export_symbols -o $lib'
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
+	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -exports_file $export_symbols -o $lib'
       fi
       _LT_TAGVAR(archive_cmds_need_lc, $1)='no'
-      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
       _LT_TAGVAR(hardcode_libdir_separator, $1)=:
       _LT_TAGVAR(inherit_rpath, $1)=yes
       _LT_TAGVAR(link_all_deplibs, $1)=yes
       ;;
 
+    linux*)
+      case $cc_basename in
+      tcc*)
+	# Fabrice Bellard et al's Tiny C Compiler
+	_LT_TAGVAR(ld_shlibs, $1)=yes
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	;;
+      esac
+      ;;
+
     netbsd*)
       if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
 	_LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out
@@ -5372,7 +5822,7 @@ _LT_EOF
     newsos6)
       _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
       _LT_TAGVAR(hardcode_direct, $1)=yes
-      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
       _LT_TAGVAR(hardcode_libdir_separator, $1)=:
       _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
       ;;
@@ -5380,27 +5830,19 @@ _LT_EOF
     *nto* | *qnx*)
       ;;
 
-    openbsd*)
+    openbsd* | bitrig*)
       if test -f /usr/libexec/ld.so; then
 	_LT_TAGVAR(hardcode_direct, $1)=yes
 	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
 	_LT_TAGVAR(hardcode_direct_absolute, $1)=yes
-	if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+	if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then
 	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
-	  _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols'
-	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
-	  _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+	  _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags $wl-retain-symbols-file,$export_symbols'
+	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir'
+	  _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E'
 	else
-	  case $host_os in
-	   openbsd[[01]].* | openbsd2.[[0-7]] | openbsd2.[[0-7]].*)
-	     _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
-	     _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
-	     ;;
-	   *)
-	     _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
-	     _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
-	     ;;
-	  esac
+	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir'
 	fi
       else
 	_LT_TAGVAR(ld_shlibs, $1)=no
@@ -5411,33 +5853,54 @@ _LT_EOF
       _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
       _LT_TAGVAR(hardcode_minus_L, $1)=yes
       _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
-      _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~echo DATA >> $output_objdir/$libname.def~echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def'
-      _LT_TAGVAR(old_archive_from_new_cmds, $1)='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def'
+      shrext_cmds=.dll
+      _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      _LT_TAGVAR(archive_expsym_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	prefix_cmds="$SED"~
+	if test EXPORTS = "`$SED 1q $export_symbols`"; then
+	  prefix_cmds="$prefix_cmds -e 1d";
+	fi~
+	prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~
+	cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      _LT_TAGVAR(old_archive_from_new_cmds, $1)='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
+      _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+      _LT_TAGVAR(file_list_spec, $1)='@'
       ;;
 
     osf3*)
-      if test "$GCC" = yes; then
-	_LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
-	_LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+      if test yes = "$GCC"; then
+	_LT_TAGVAR(allow_undefined_flag, $1)=' $wl-expect_unresolved $wl\*'
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
       else
 	_LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
-	_LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
       fi
       _LT_TAGVAR(archive_cmds_need_lc, $1)='no'
-      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
       _LT_TAGVAR(hardcode_libdir_separator, $1)=:
       ;;
 
     osf4* | osf5*)	# as osf3* with the addition of -msym flag
-      if test "$GCC" = yes; then
-	_LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
-	_LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $pic_flag $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
-	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+      if test yes = "$GCC"; then
+	_LT_TAGVAR(allow_undefined_flag, $1)=' $wl-expect_unresolved $wl\*'
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_flag $pic_flag $libobjs $deplibs $compiler_flags $wl-msym $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
+	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
       else
 	_LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
-	_LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
 	_LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~
-	$CC -shared${allow_undefined_flag} ${wl}-input ${wl}$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~$RM $lib.exp'
+          $CC -shared$allow_undefined_flag $wl-input $wl$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib~$RM $lib.exp'
 
 	# Both c and cxx compiler support -rpath directly
 	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
@@ -5448,24 +5911,24 @@ _LT_EOF
 
     solaris*)
       _LT_TAGVAR(no_undefined_flag, $1)=' -z defs'
-      if test "$GCC" = yes; then
-	wlarc='${wl}'
-	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+      if test yes = "$GCC"; then
+	wlarc='$wl'
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $wl-z ${wl}text $wl-h $wl$soname -o $lib $libobjs $deplibs $compiler_flags'
 	_LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
-	  $CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
+          $CC -shared $pic_flag $wl-z ${wl}text $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
       else
 	case `$CC -V 2>&1` in
 	*"Compilers 5.0"*)
 	  wlarc=''
-	  _LT_TAGVAR(archive_cmds, $1)='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	  _LT_TAGVAR(archive_cmds, $1)='$LD -G$allow_undefined_flag -h $soname -o $lib $libobjs $deplibs $linker_flags'
 	  _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
-	  $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp'
+            $LD -G$allow_undefined_flag -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp'
 	  ;;
 	*)
-	  wlarc='${wl}'
-	  _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $compiler_flags'
+	  wlarc='$wl'
+	  _LT_TAGVAR(archive_cmds, $1)='$CC -G$allow_undefined_flag -h $soname -o $lib $libobjs $deplibs $compiler_flags'
 	  _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
-	  $CC -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
+            $CC -G$allow_undefined_flag -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
 	  ;;
 	esac
       fi
@@ -5475,11 +5938,11 @@ _LT_EOF
       solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;
       *)
 	# The compiler driver will combine and reorder linker options,
-	# but understands `-z linker_flag'.  GCC discards it without `$wl',
+	# but understands '-z linker_flag'.  GCC discards it without '$wl',
 	# but is careful enough not to reorder.
 	# Supported since Solaris 2.6 (maybe 2.5.1?)
-	if test "$GCC" = yes; then
-	  _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract'
+	if test yes = "$GCC"; then
+	  _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl-z ${wl}allextract$convenience $wl-z ${wl}defaultextract'
 	else
 	  _LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract'
 	fi
@@ -5489,10 +5952,10 @@ _LT_EOF
       ;;
 
     sunos4*)
-      if test "x$host_vendor" = xsequent; then
+      if test sequent = "$host_vendor"; then
 	# Use $CC to link under sequent, because it throws in some extra .o
 	# files that make .init and .fini sections work.
-	_LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags'
+	_LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h $soname -o $lib $libobjs $deplibs $compiler_flags'
       else
 	_LT_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'
       fi
@@ -5541,43 +6004,43 @@ _LT_EOF
       ;;
 
     sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*)
-      _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'
+      _LT_TAGVAR(no_undefined_flag, $1)='$wl-z,text'
       _LT_TAGVAR(archive_cmds_need_lc, $1)=no
       _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
       runpath_var='LD_RUN_PATH'
 
-      if test "$GCC" = yes; then
-	_LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      if test yes = "$GCC"; then
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
       else
-	_LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	_LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
       fi
       ;;
 
     sysv5* | sco3.2v5* | sco5v6*)
-      # Note: We can NOT use -z defs as we might desire, because we do not
+      # Note: We CANNOT use -z defs as we might desire, because we do not
       # link with -lc, and that would cause any symbols used from libc to
       # always be unresolved, which means just about no library would
       # ever link correctly.  If we're not using GNU ld we use -z text
       # though, which does catch some bad symbols but isn't as heavy-handed
       # as -z defs.
-      _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'
-      _LT_TAGVAR(allow_undefined_flag, $1)='${wl}-z,nodefs'
+      _LT_TAGVAR(no_undefined_flag, $1)='$wl-z,text'
+      _LT_TAGVAR(allow_undefined_flag, $1)='$wl-z,nodefs'
       _LT_TAGVAR(archive_cmds_need_lc, $1)=no
       _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
-      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R,$libdir'
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R,$libdir'
       _LT_TAGVAR(hardcode_libdir_separator, $1)=':'
       _LT_TAGVAR(link_all_deplibs, $1)=yes
-      _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport'
+      _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-Bexport'
       runpath_var='LD_RUN_PATH'
 
-      if test "$GCC" = yes; then
-	_LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      if test yes = "$GCC"; then
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
       else
-	_LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	_LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
       fi
       ;;
 
@@ -5592,17 +6055,17 @@ _LT_EOF
       ;;
     esac
 
-    if test x$host_vendor = xsni; then
+    if test sni = "$host_vendor"; then
       case $host in
       sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
-	_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Blargedynsym'
+	_LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-Blargedynsym'
 	;;
       esac
     fi
   fi
 ])
 AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)])
-test "$_LT_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no
+test no = "$_LT_TAGVAR(ld_shlibs, $1)" && can_build_shared=no
 
 _LT_TAGVAR(with_gnu_ld, $1)=$with_gnu_ld
 
@@ -5619,7 +6082,7 @@ x|xyes)
   # Assume -lc should be added
   _LT_TAGVAR(archive_cmds_need_lc, $1)=yes
 
-  if test "$enable_shared" = yes && test "$GCC" = yes; then
+  if test yes,yes = "$GCC,$enable_shared"; then
     case $_LT_TAGVAR(archive_cmds, $1) in
     *'~'*)
       # FIXME: we may have to deal with multi-command sequences.
@@ -5699,12 +6162,12 @@ _LT_TAGDECL([], [hardcode_libdir_flag_spec], [1],
 _LT_TAGDECL([], [hardcode_libdir_separator], [1],
     [Whether we need a single "-rpath" flag with a separated argument])
 _LT_TAGDECL([], [hardcode_direct], [0],
-    [Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes
+    [Set to "yes" if using DIR/libNAME$shared_ext during linking hardcodes
     DIR into the resulting binary])
 _LT_TAGDECL([], [hardcode_direct_absolute], [0],
-    [Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes
+    [Set to "yes" if using DIR/libNAME$shared_ext during linking hardcodes
     DIR into the resulting binary and the resulting library dependency is
-    "absolute", i.e impossible to change by setting ${shlibpath_var} if the
+    "absolute", i.e impossible to change by setting $shlibpath_var if the
     library is relocated])
 _LT_TAGDECL([], [hardcode_minus_L], [0],
     [Set to "yes" if using the -LDIR flag during linking hardcodes DIR
@@ -5745,10 +6208,10 @@ dnl    [Compiler flag to generate thread safe objects])
 # ------------------------
 # Ensure that the configuration variables for a C compiler are suitably
 # defined.  These variables are subsequently used by _LT_CONFIG to write
-# the compiler configuration to `libtool'.
+# the compiler configuration to 'libtool'.
 m4_defun([_LT_LANG_C_CONFIG],
 [m4_require([_LT_DECL_EGREP])dnl
-lt_save_CC="$CC"
+lt_save_CC=$CC
 AC_LANG_PUSH(C)
 
 # Source file extension for C test sources.
@@ -5788,18 +6251,18 @@ if test -n "$compiler"; then
   LT_SYS_DLOPEN_SELF
   _LT_CMD_STRIPLIB
 
-  # Report which library types will actually be built
+  # Report what library types will actually be built
   AC_MSG_CHECKING([if libtool supports shared libraries])
   AC_MSG_RESULT([$can_build_shared])
 
   AC_MSG_CHECKING([whether to build shared libraries])
-  test "$can_build_shared" = "no" && enable_shared=no
+  test no = "$can_build_shared" && enable_shared=no
 
   # On AIX, shared libraries and static libraries use the same namespace, and
   # are all built from PIC.
   case $host_os in
   aix3*)
-    test "$enable_shared" = yes && enable_static=no
+    test yes = "$enable_shared" && enable_static=no
     if test -n "$RANLIB"; then
       archive_cmds="$archive_cmds~\$RANLIB \$lib"
       postinstall_cmds='$RANLIB $lib'
@@ -5807,8 +6270,12 @@ if test -n "$compiler"; then
     ;;
 
   aix[[4-9]]*)
-    if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
-      test "$enable_shared" = yes && enable_static=no
+    if test ia64 != "$host_cpu"; then
+      case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in
+      yes,aix,yes) ;;			# shared object as lib.so file only
+      yes,svr4,*) ;;			# shared object as lib.so archive member only
+      yes,*) enable_static=no ;;	# shared object in lib.a archive as well
+      esac
     fi
     ;;
   esac
@@ -5816,13 +6283,13 @@ if test -n "$compiler"; then
 
   AC_MSG_CHECKING([whether to build static libraries])
   # Make sure either enable_shared or enable_static is yes.
-  test "$enable_shared" = yes || enable_static=yes
+  test yes = "$enable_shared" || enable_static=yes
   AC_MSG_RESULT([$enable_static])
 
   _LT_CONFIG($1)
 fi
 AC_LANG_POP
-CC="$lt_save_CC"
+CC=$lt_save_CC
 ])# _LT_LANG_C_CONFIG
 
 
@@ -5830,14 +6297,14 @@ CC="$lt_save_CC"
 # --------------------------
 # Ensure that the configuration variables for a C++ compiler are suitably
 # defined.  These variables are subsequently used by _LT_CONFIG to write
-# the compiler configuration to `libtool'.
+# the compiler configuration to 'libtool'.
 m4_defun([_LT_LANG_CXX_CONFIG],
 [m4_require([_LT_FILEUTILS_DEFAULTS])dnl
 m4_require([_LT_DECL_EGREP])dnl
 m4_require([_LT_PATH_MANIFEST_TOOL])dnl
-if test -n "$CXX" && ( test "X$CXX" != "Xno" &&
-    ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) ||
-    (test "X$CXX" != "Xg++"))) ; then
+if test -n "$CXX" && ( test no != "$CXX" &&
+    ( (test g++ = "$CXX" && `g++ -v >/dev/null 2>&1` ) ||
+    (test g++ != "$CXX"))); then
   AC_PROG_CXXCPP
 else
   _lt_caught_CXX_error=yes
@@ -5879,7 +6346,7 @@ _LT_TAGVAR(objext, $1)=$objext
 # the CXX compiler isn't working.  Some variables (like enable_shared)
 # are currently assumed to apply to all compilers on this platform,
 # and will be corrupted by setting them based on a non-working compiler.
-if test "$_lt_caught_CXX_error" != yes; then
+if test yes != "$_lt_caught_CXX_error"; then
   # Code to be used in simple compile tests
   lt_simple_compile_test_code="int some_variable = 0;"
 
@@ -5921,35 +6388,35 @@ if test "$_lt_caught_CXX_error" != yes; then
   if test -n "$compiler"; then
     # We don't want -fno-exception when compiling C++ code, so set the
     # no_builtin_flag separately
-    if test "$GXX" = yes; then
+    if test yes = "$GXX"; then
       _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin'
     else
       _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=
     fi
 
-    if test "$GXX" = yes; then
+    if test yes = "$GXX"; then
       # Set up default GNU C++ configuration
 
       LT_PATH_LD
 
       # Check if GNU C++ uses GNU ld as the underlying linker, since the
       # archiving commands below assume that GNU ld is being used.
-      if test "$with_gnu_ld" = yes; then
-        _LT_TAGVAR(archive_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
-        _LT_TAGVAR(archive_expsym_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+      if test yes = "$with_gnu_ld"; then
+        _LT_TAGVAR(archive_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
+        _LT_TAGVAR(archive_expsym_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
 
-        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
-        _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
+        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
+        _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic'
 
         # If archive_cmds runs LD, not CC, wlarc should be empty
         # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to
         #     investigate it a little bit more. (MM)
-        wlarc='${wl}'
+        wlarc='$wl'
 
         # ancient GNU ld didn't support --whole-archive et. al.
         if eval "`$CC -print-prog-name=ld` --help 2>&1" |
 	  $GREP 'no-whole-archive' > /dev/null; then
-          _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
+          _LT_TAGVAR(whole_archive_flag_spec, $1)=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive'
         else
           _LT_TAGVAR(whole_archive_flag_spec, $1)=
         fi
@@ -5985,18 +6452,30 @@ if test "$_lt_caught_CXX_error" != yes; then
         _LT_TAGVAR(ld_shlibs, $1)=no
         ;;
       aix[[4-9]]*)
-        if test "$host_cpu" = ia64; then
+        if test ia64 = "$host_cpu"; then
           # On IA64, the linker does run time linking by default, so we don't
           # have to do anything special.
           aix_use_runtimelinking=no
           exp_sym_flag='-Bexport'
-          no_entry_flag=""
+          no_entry_flag=
         else
           aix_use_runtimelinking=no
 
           # Test if we are trying to use run time linking or normal
           # AIX style linking. If -brtl is somewhere in LDFLAGS, we
-          # need to do runtime linking.
+          # have runtime linking enabled, and use it for executables.
+          # For shared libraries, we enable/disable runtime linking
+          # depending on the kind of the shared library created -
+          # when "with_aix_soname,aix_use_runtimelinking" is:
+          # "aix,no"   lib.a(lib.so.V) shared, rtl:no,  for executables
+          # "aix,yes"  lib.so          shared, rtl:yes, for executables
+          #            lib.a           static archive
+          # "both,no"  lib.so.V(shr.o) shared, rtl:yes
+          #            lib.a(lib.so.V) shared, rtl:no,  for executables
+          # "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables
+          #            lib.a(lib.so.V) shared, rtl:no
+          # "svr4,*"   lib.so.V(shr.o) shared, rtl:yes, for executables
+          #            lib.a           static archive
           case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*)
 	    for ld_flag in $LDFLAGS; do
 	      case $ld_flag in
@@ -6006,6 +6485,13 @@ if test "$_lt_caught_CXX_error" != yes; then
 	        ;;
 	      esac
 	    done
+	    if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then
+	      # With aix-soname=svr4, we create the lib.so.V shared archives only,
+	      # so we don't have lib.a shared libs to link our executables.
+	      # We have to force runtime linking in this case.
+	      aix_use_runtimelinking=yes
+	      LDFLAGS="$LDFLAGS -Wl,-brtl"
+	    fi
 	    ;;
           esac
 
@@ -6024,13 +6510,21 @@ if test "$_lt_caught_CXX_error" != yes; then
         _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
         _LT_TAGVAR(hardcode_libdir_separator, $1)=':'
         _LT_TAGVAR(link_all_deplibs, $1)=yes
-        _LT_TAGVAR(file_list_spec, $1)='${wl}-f,'
+        _LT_TAGVAR(file_list_spec, $1)='$wl-f,'
+        case $with_aix_soname,$aix_use_runtimelinking in
+        aix,*) ;;	# no import file
+        svr4,* | *,yes) # use import file
+          # The Import File defines what to hardcode.
+          _LT_TAGVAR(hardcode_direct, $1)=no
+          _LT_TAGVAR(hardcode_direct_absolute, $1)=no
+          ;;
+        esac
 
-        if test "$GXX" = yes; then
+        if test yes = "$GXX"; then
           case $host_os in aix4.[[012]]|aix4.[[012]].*)
           # We only want to do this on AIX 4.2 and lower, the check
           # below for broken collect2 doesn't work under 4.3+
-	  collect2name=`${CC} -print-prog-name=collect2`
+	  collect2name=`$CC -print-prog-name=collect2`
 	  if test -f "$collect2name" &&
 	     strings "$collect2name" | $GREP resolve_lib_name >/dev/null
 	  then
@@ -6048,64 +6542,84 @@ if test "$_lt_caught_CXX_error" != yes; then
 	  fi
           esac
           shared_flag='-shared'
-	  if test "$aix_use_runtimelinking" = yes; then
-	    shared_flag="$shared_flag "'${wl}-G'
+	  if test yes = "$aix_use_runtimelinking"; then
+	    shared_flag=$shared_flag' $wl-G'
 	  fi
+	  # Need to ensure runtime linking is disabled for the traditional
+	  # shared library, or the linker may eventually find shared libraries
+	  # /with/ Import File - we do not want to mix them.
+	  shared_flag_aix='-shared'
+	  shared_flag_svr4='-shared $wl-G'
         else
           # not using gcc
-          if test "$host_cpu" = ia64; then
+          if test ia64 = "$host_cpu"; then
 	  # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
 	  # chokes on -Wl,-G. The following line is correct:
 	  shared_flag='-G'
           else
-	    if test "$aix_use_runtimelinking" = yes; then
-	      shared_flag='${wl}-G'
+	    if test yes = "$aix_use_runtimelinking"; then
+	      shared_flag='$wl-G'
 	    else
-	      shared_flag='${wl}-bM:SRE'
+	      shared_flag='$wl-bM:SRE'
 	    fi
+	    shared_flag_aix='$wl-bM:SRE'
+	    shared_flag_svr4='$wl-G'
           fi
         fi
 
-        _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-bexpall'
+        _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-bexpall'
         # It seems that -bexpall does not export symbols beginning with
         # underscore (_), so it is better to generate a list of symbols to
 	# export.
         _LT_TAGVAR(always_export_symbols, $1)=yes
-        if test "$aix_use_runtimelinking" = yes; then
+	if test aix,yes = "$with_aix_soname,$aix_use_runtimelinking"; then
           # Warning - without using the other runtime loading flags (-brtl),
           # -berok will link without error, but may produce a broken library.
-          _LT_TAGVAR(allow_undefined_flag, $1)='-berok'
+          # The "-G" linker flag allows undefined symbols.
+          _LT_TAGVAR(no_undefined_flag, $1)='-bernotok'
           # Determine the default libpath from the value encoded in an empty
           # executable.
           _LT_SYS_MODULE_PATH_AIX([$1])
-          _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
+          _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-blibpath:$libdir:'"$aix_libpath"
 
-          _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"
+          _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs $wl'$no_entry_flag' $compiler_flags `if test -n "$allow_undefined_flag"; then func_echo_all "$wl$allow_undefined_flag"; else :; fi` $wl'$exp_sym_flag:\$export_symbols' '$shared_flag
         else
-          if test "$host_cpu" = ia64; then
-	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib'
+          if test ia64 = "$host_cpu"; then
+	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R $libdir:/usr/lib:/lib'
 	    _LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs"
-	    _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"
+	    _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\$wl$no_entry_flag"' $compiler_flags $wl$allow_undefined_flag '"\$wl$exp_sym_flag:\$export_symbols"
           else
 	    # Determine the default libpath from the value encoded in an
 	    # empty executable.
 	    _LT_SYS_MODULE_PATH_AIX([$1])
-	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
+	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-blibpath:$libdir:'"$aix_libpath"
 	    # Warning - without using the other run time loading flags,
 	    # -berok will link without error, but may produce a broken library.
-	    _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok'
-	    _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok'
-	    if test "$with_gnu_ld" = yes; then
+	    _LT_TAGVAR(no_undefined_flag, $1)=' $wl-bernotok'
+	    _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-berok'
+	    if test yes = "$with_gnu_ld"; then
 	      # We only use this code for GNU lds that support --whole-archive.
-	      _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive'
+	      _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive$convenience $wl--no-whole-archive'
 	    else
 	      # Exported symbols can be pulled into shared objects from archives
 	      _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience'
 	    fi
 	    _LT_TAGVAR(archive_cmds_need_lc, $1)=yes
-	    # This is similar to how AIX traditionally builds its shared
-	    # libraries.
-	    _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
+	    _LT_TAGVAR(archive_expsym_cmds, $1)='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d'
+	    # -brtl affects multiple linker settings, -berok does not and is overridden later
+	    compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\\([[, ]]\\)%-berok\\1%g"`'
+	    if test svr4 != "$with_aix_soname"; then
+	      # This is similar to how AIX traditionally builds its shared
+	      # libraries. Need -bnortl late, we may have -brtl in LDFLAGS.
+	      _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname'
+	    fi
+	    if test aix != "$with_aix_soname"; then
+	      _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp'
+	    else
+	      # used by -dlpreopen to get the symbols
+	      _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$MV  $output_objdir/$realname.d/$soname $output_objdir'
+	    fi
+	    _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$RM -r $output_objdir/$realname.d'
           fi
         fi
         ;;
@@ -6115,7 +6629,7 @@ if test "$_lt_caught_CXX_error" != yes; then
 	  _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
 	  # Joseph Beckenbach <jrb3@best.com> says some releases of gcc
 	  # support --undefined.  This deserves some investigation.  FIXME
-	  _LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+	  _LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
 	else
 	  _LT_TAGVAR(ld_shlibs, $1)=no
 	fi
@@ -6143,57 +6657,58 @@ if test "$_lt_caught_CXX_error" != yes; then
 	  # Tell ltmain to make .lib files, not .a files.
 	  libext=lib
 	  # Tell ltmain to make .dll files, not .so files.
-	  shrext_cmds=".dll"
+	  shrext_cmds=.dll
 	  # FIXME: Setting linknames here is a bad hack.
-	  _LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames='
-	  _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
-	      $SED -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp;
-	    else
-	      $SED -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp;
-	    fi~
-	    $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
-	    linknames='
+	  _LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames='
+	  _LT_TAGVAR(archive_expsym_cmds, $1)='if _LT_DLL_DEF_P([$export_symbols]); then
+              cp "$export_symbols" "$output_objdir/$soname.def";
+              echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp";
+            else
+              $SED -e '\''s/^/-link -EXPORT:/'\'' < $export_symbols > $output_objdir/$soname.exp;
+            fi~
+            $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
+            linknames='
 	  # The linker will not automatically build a static lib if we build a DLL.
 	  # _LT_TAGVAR(old_archive_from_new_cmds, $1)='true'
 	  _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
 	  # Don't use ranlib
 	  _LT_TAGVAR(old_postinstall_cmds, $1)='chmod 644 $oldlib'
 	  _LT_TAGVAR(postlink_cmds, $1)='lt_outputfile="@OUTPUT@"~
-	    lt_tool_outputfile="@TOOL_OUTPUT@"~
-	    case $lt_outputfile in
-	      *.exe|*.EXE) ;;
-	      *)
-		lt_outputfile="$lt_outputfile.exe"
-		lt_tool_outputfile="$lt_tool_outputfile.exe"
-		;;
-	    esac~
-	    func_to_tool_file "$lt_outputfile"~
-	    if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then
-	      $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;
-	      $RM "$lt_outputfile.manifest";
-	    fi'
+            lt_tool_outputfile="@TOOL_OUTPUT@"~
+            case $lt_outputfile in
+              *.exe|*.EXE) ;;
+              *)
+                lt_outputfile=$lt_outputfile.exe
+                lt_tool_outputfile=$lt_tool_outputfile.exe
+                ;;
+            esac~
+            func_to_tool_file "$lt_outputfile"~
+            if test : != "$MANIFEST_TOOL" && test -f "$lt_outputfile.manifest"; then
+              $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;
+              $RM "$lt_outputfile.manifest";
+            fi'
 	  ;;
 	*)
 	  # g++
 	  # _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless,
 	  # as there is no search path for DLLs.
 	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
-	  _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-all-symbols'
+	  _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-all-symbols'
 	  _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
 	  _LT_TAGVAR(always_export_symbols, $1)=no
 	  _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
 
 	  if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
-	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
-	    # If the export-symbols file already is a .def file (1st line
-	    # is EXPORTS), use it as is; otherwise, prepend...
-	    _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
-	      cp $export_symbols $output_objdir/$soname.def;
-	    else
-	      echo EXPORTS > $output_objdir/$soname.def;
-	      cat $export_symbols >> $output_objdir/$soname.def;
-	    fi~
-	    $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+	    # If the export-symbols file already is a .def file, use it as
+	    # is; otherwise, prepend EXPORTS...
+	    _LT_TAGVAR(archive_expsym_cmds, $1)='if _LT_DLL_DEF_P([$export_symbols]); then
+              cp $export_symbols $output_objdir/$soname.def;
+            else
+              echo EXPORTS > $output_objdir/$soname.def;
+              cat $export_symbols >> $output_objdir/$soname.def;
+            fi~
+            $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
 	  else
 	    _LT_TAGVAR(ld_shlibs, $1)=no
 	  fi
@@ -6204,6 +6719,35 @@ if test "$_lt_caught_CXX_error" != yes; then
         _LT_DARWIN_LINKER_FEATURES($1)
 	;;
 
+      os2*)
+	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+	_LT_TAGVAR(hardcode_minus_L, $1)=yes
+	_LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+	shrext_cmds=.dll
+	_LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	  $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	  $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	  $ECHO EXPORTS >> $output_objdir/$libname.def~
+	  emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
+	  $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	  emximp -o $lib $output_objdir/$libname.def'
+	_LT_TAGVAR(archive_expsym_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	  $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	  $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	  $ECHO EXPORTS >> $output_objdir/$libname.def~
+	  prefix_cmds="$SED"~
+	  if test EXPORTS = "`$SED 1q $export_symbols`"; then
+	    prefix_cmds="$prefix_cmds -e 1d";
+	  fi~
+	  prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~
+	  cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
+	  $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	  emximp -o $lib $output_objdir/$libname.def'
+	_LT_TAGVAR(old_archive_from_new_cmds, $1)='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
+	_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+	_LT_TAGVAR(file_list_spec, $1)='@'
+	;;
+
       dgux*)
         case $cc_basename in
           ec++*)
@@ -6232,24 +6776,21 @@ if test "$_lt_caught_CXX_error" != yes; then
         _LT_TAGVAR(archive_cmds_need_lc, $1)=no
         ;;
 
-      freebsd* | dragonfly*)
+      freebsd* | dragonfly* | midnightbsd*)
         # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF
         # conventions
         _LT_TAGVAR(ld_shlibs, $1)=yes
         ;;
 
-      gnu*)
-        ;;
-
       haiku*)
-        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
         _LT_TAGVAR(link_all_deplibs, $1)=yes
         ;;
 
       hpux9*)
-        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
+        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir'
         _LT_TAGVAR(hardcode_libdir_separator, $1)=:
-        _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+        _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E'
         _LT_TAGVAR(hardcode_direct, $1)=yes
         _LT_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH,
 				             # but as the default
@@ -6261,7 +6802,7 @@ if test "$_lt_caught_CXX_error" != yes; then
             _LT_TAGVAR(ld_shlibs, $1)=no
             ;;
           aCC*)
-            _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -b ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+            _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -b $wl+b $wl$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
             # Commands to make compiler produce verbose output that lists
             # what "hidden" libraries, object files and flags are used when
             # linking a shared library.
@@ -6270,11 +6811,11 @@ if test "$_lt_caught_CXX_error" != yes; then
             # explicitly linking system object files so we need to strip them
             # from the output so that they don't get included in the library
             # dependencies.
-            output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+            output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "\-L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
             ;;
           *)
-            if test "$GXX" = yes; then
-              _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared -nostdlib $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+            if test yes = "$GXX"; then
+              _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared -nostdlib $pic_flag $wl+b $wl$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
             else
               # FIXME: insert proper C++ library support
               _LT_TAGVAR(ld_shlibs, $1)=no
@@ -6284,15 +6825,15 @@ if test "$_lt_caught_CXX_error" != yes; then
         ;;
 
       hpux10*|hpux11*)
-        if test $with_gnu_ld = no; then
-	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
+        if test no = "$with_gnu_ld"; then
+	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir'
 	  _LT_TAGVAR(hardcode_libdir_separator, $1)=:
 
           case $host_cpu in
             hppa*64*|ia64*)
               ;;
             *)
-	      _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+	      _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E'
               ;;
           esac
         fi
@@ -6318,13 +6859,13 @@ if test "$_lt_caught_CXX_error" != yes; then
           aCC*)
 	    case $host_cpu in
 	      hppa*64*)
-	        _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	        _LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
 	        ;;
 	      ia64*)
-	        _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	        _LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname $wl+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
 	        ;;
 	      *)
-	        _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	        _LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
 	        ;;
 	    esac
 	    # Commands to make compiler produce verbose output that lists
@@ -6335,20 +6876,20 @@ if test "$_lt_caught_CXX_error" != yes; then
 	    # explicitly linking system object files so we need to strip them
 	    # from the output so that they don't get included in the library
 	    # dependencies.
-	    output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+	    output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP "\-L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
 	    ;;
           *)
-	    if test "$GXX" = yes; then
-	      if test $with_gnu_ld = no; then
+	    if test yes = "$GXX"; then
+	      if test no = "$with_gnu_ld"; then
 	        case $host_cpu in
 	          hppa*64*)
-	            _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	            _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC $wl+h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
 	            ;;
 	          ia64*)
-	            _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	            _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag $wl+h $wl$soname $wl+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
 	            ;;
 	          *)
-	            _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	            _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
 	            ;;
 	        esac
 	      fi
@@ -6363,22 +6904,22 @@ if test "$_lt_caught_CXX_error" != yes; then
       interix[[3-9]]*)
 	_LT_TAGVAR(hardcode_direct, $1)=no
 	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
-	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
-	_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir'
+	_LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E'
 	# Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
 	# Instead, shared libraries are loaded at an image base (0x10000000 by
 	# default) and relocated if they conflict, which is a slow very memory
 	# consuming and fragmenting process.  To avoid this, we pick a random,
 	# 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
 	# time.  Moving up from 0x10000000 also allows more sbrk(2) space.
-	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
-	_LT_TAGVAR(archive_expsym_cmds, $1)='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+	_LT_TAGVAR(archive_expsym_cmds, $1)='sed "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--retain-symbols-file,$output_objdir/$soname.expsym $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
 	;;
       irix5* | irix6*)
         case $cc_basename in
           CC*)
 	    # SGI C++
-	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
+	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
 
 	    # Archives containing C++ object files must be created using
 	    # "CC -ar", where "CC" is the IRIX C++ compiler.  This is
@@ -6387,22 +6928,22 @@ if test "$_lt_caught_CXX_error" != yes; then
 	    _LT_TAGVAR(old_archive_cmds, $1)='$CC -ar -WR,-u -o $oldlib $oldobjs'
 	    ;;
           *)
-	    if test "$GXX" = yes; then
-	      if test "$with_gnu_ld" = no; then
-	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+	    if test yes = "$GXX"; then
+	      if test no = "$with_gnu_ld"; then
+	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
 	      else
-	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` -o $lib'
+	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` -o $lib'
 	      fi
 	    fi
 	    _LT_TAGVAR(link_all_deplibs, $1)=yes
 	    ;;
         esac
-        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
         _LT_TAGVAR(hardcode_libdir_separator, $1)=:
         _LT_TAGVAR(inherit_rpath, $1)=yes
         ;;
 
-      linux* | k*bsd*-gnu | kopensolaris*-gnu)
+      linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
         case $cc_basename in
           KCC*)
 	    # Kuck and Associates, Inc. (KAI) C++ Compiler
@@ -6410,8 +6951,8 @@ if test "$_lt_caught_CXX_error" != yes; then
 	    # KCC will only create a shared library if the output file
 	    # ends with ".so" (or ".sl" for HP-UX), so rename the library
 	    # to its proper name (with version) after linking.
-	    _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
-	    _LT_TAGVAR(archive_expsym_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib ${wl}-retain-symbols-file,$export_symbols; mv \$templib $lib'
+	    _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\$tempext\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
+	    _LT_TAGVAR(archive_expsym_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\$tempext\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib $wl-retain-symbols-file,$export_symbols; mv \$templib $lib'
 	    # Commands to make compiler produce verbose output that lists
 	    # what "hidden" libraries, object files and flags are used when
 	    # linking a shared library.
@@ -6420,10 +6961,10 @@ if test "$_lt_caught_CXX_error" != yes; then
 	    # explicitly linking system object files so we need to strip them
 	    # from the output so that they don't get included in the library
 	    # dependencies.
-	    output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+	    output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
 
-	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
-	    _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
+	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir'
+	    _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic'
 
 	    # Archives containing C++ object files must be created using
 	    # "CC -Bstatic", where "CC" is the KAI C++ compiler.
@@ -6437,59 +6978,59 @@ if test "$_lt_caught_CXX_error" != yes; then
 	    # earlier do not add the objects themselves.
 	    case `$CC -V 2>&1` in
 	      *"Version 7."*)
-	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
-		_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
+		_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
 		;;
 	      *)  # Version 8.0 or newer
 	        tmp_idyn=
 	        case $host_cpu in
 		  ia64*) tmp_idyn=' -i_dynamic';;
 		esac
-	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
-		_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+		_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
 		;;
 	    esac
 	    _LT_TAGVAR(archive_cmds_need_lc, $1)=no
-	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
-	    _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
-	    _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive'
+	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir'
+	    _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic'
+	    _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive$convenience $wl--no-whole-archive'
 	    ;;
           pgCC* | pgcpp*)
             # Portland Group C++ compiler
 	    case `$CC -V` in
 	    *pgCC\ [[1-5]].* | *pgcpp\ [[1-5]].*)
 	      _LT_TAGVAR(prelink_cmds, $1)='tpldir=Template.dir~
-		rm -rf $tpldir~
-		$CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~
-		compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"'
+               rm -rf $tpldir~
+               $CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~
+               compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"'
 	      _LT_TAGVAR(old_archive_cmds, $1)='tpldir=Template.dir~
-		rm -rf $tpldir~
-		$CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~
-		$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~
-		$RANLIB $oldlib'
+                rm -rf $tpldir~
+                $CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~
+                $AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~
+                $RANLIB $oldlib'
 	      _LT_TAGVAR(archive_cmds, $1)='tpldir=Template.dir~
-		rm -rf $tpldir~
-		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
-		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+                rm -rf $tpldir~
+                $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+                $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
 	      _LT_TAGVAR(archive_expsym_cmds, $1)='tpldir=Template.dir~
-		rm -rf $tpldir~
-		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
-		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
+                rm -rf $tpldir~
+                $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+                $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
 	      ;;
 	    *) # Version 6 and above use weak symbols
-	      _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
-	      _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
+	      _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
+	      _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
 	      ;;
 	    esac
 
-	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir'
-	    _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
-	    _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
+	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl--rpath $wl$libdir'
+	    _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic'
+	    _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
             ;;
 	  cxx*)
 	    # Compaq C++
-	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
-	    _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname  -o $lib ${wl}-retain-symbols-file $wl$export_symbols'
+	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
+	    _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname  -o $lib $wl-retain-symbols-file $wl$export_symbols'
 
 	    runpath_var=LD_RUN_PATH
 	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
@@ -6503,18 +7044,18 @@ if test "$_lt_caught_CXX_error" != yes; then
 	    # explicitly linking system object files so we need to strip them
 	    # from the output so that they don't get included in the library
 	    # dependencies.
-	    output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "X$list" | $Xsed'
+	    output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "X$list" | $Xsed'
 	    ;;
 	  xl* | mpixl* | bgxl*)
 	    # IBM XL 8.0 on PPC, with GNU ld
-	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
-	    _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
-	    _LT_TAGVAR(archive_cmds, $1)='$CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
-	    if test "x$supports_anon_versioning" = xyes; then
+	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
+	    _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic'
+	    _LT_TAGVAR(archive_cmds, $1)='$CC -qmkshrobj $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	    if test yes = "$supports_anon_versioning"; then
 	      _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~
-		cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
-		echo "local: *; };" >> $output_objdir/$libname.ver~
-		$CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
+                cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+                echo "local: *; };" >> $output_objdir/$libname.ver~
+                $CC -qmkshrobj $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-version-script $wl$output_objdir/$libname.ver -o $lib'
 	    fi
 	    ;;
 	  *)
@@ -6522,10 +7063,10 @@ if test "$_lt_caught_CXX_error" != yes; then
 	    *Sun\ C*)
 	      # Sun C++ 5.9
 	      _LT_TAGVAR(no_undefined_flag, $1)=' -zdefs'
-	      _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
-	      _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file ${wl}$export_symbols'
+	      _LT_TAGVAR(archive_cmds, $1)='$CC -G$allow_undefined_flag -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	      _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G$allow_undefined_flag -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-retain-symbols-file $wl$export_symbols'
 	      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
-	      _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
+	      _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
 	      _LT_TAGVAR(compiler_needs_object, $1)=yes
 
 	      # Not sure whether something based on
@@ -6583,22 +7124,17 @@ if test "$_lt_caught_CXX_error" != yes; then
         _LT_TAGVAR(ld_shlibs, $1)=yes
 	;;
 
-      openbsd2*)
-        # C++ shared libraries are fairly broken
-	_LT_TAGVAR(ld_shlibs, $1)=no
-	;;
-
-      openbsd*)
+      openbsd* | bitrig*)
 	if test -f /usr/libexec/ld.so; then
 	  _LT_TAGVAR(hardcode_direct, $1)=yes
 	  _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
 	  _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
 	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
-	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
-	  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
-	    _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file,$export_symbols -o $lib'
-	    _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
-	    _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
+	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir'
+	  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`"; then
+	    _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-retain-symbols-file,$export_symbols -o $lib'
+	    _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E'
+	    _LT_TAGVAR(whole_archive_flag_spec, $1)=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive'
 	  fi
 	  output_verbose_link_cmd=func_echo_all
 	else
@@ -6614,9 +7150,9 @@ if test "$_lt_caught_CXX_error" != yes; then
 	    # KCC will only create a shared library if the output file
 	    # ends with ".so" (or ".sl" for HP-UX), so rename the library
 	    # to its proper name (with version) after linking.
-	    _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo "$lib" | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
+	    _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo "$lib" | $SED -e "s/\$tempext\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
 
-	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir'
 	    _LT_TAGVAR(hardcode_libdir_separator, $1)=:
 
 	    # Archives containing C++ object files must be created using
@@ -6634,17 +7170,17 @@ if test "$_lt_caught_CXX_error" != yes; then
           cxx*)
 	    case $host in
 	      osf3*)
-	        _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
-	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && func_echo_all "${wl}-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
-	        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+	        _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-expect_unresolved $wl\*'
+	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $soname `test -n "$verstring" && func_echo_all "$wl-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
+	        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
 		;;
 	      *)
 	        _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
-	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
+	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
 	        _LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~
-	          echo "-hidden">> $lib.exp~
-	          $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname ${wl}-input ${wl}$lib.exp  `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~
-	          $RM $lib.exp'
+                  echo "-hidden">> $lib.exp~
+                  $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname $wl-input $wl$lib.exp  `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib~
+                  $RM $lib.exp'
 	        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
 		;;
 	    esac
@@ -6659,21 +7195,21 @@ if test "$_lt_caught_CXX_error" != yes; then
 	    # explicitly linking system object files so we need to strip them
 	    # from the output so that they don't get included in the library
 	    # dependencies.
-	    output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+	    output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
 	    ;;
 	  *)
-	    if test "$GXX" = yes && test "$with_gnu_ld" = no; then
-	      _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
+	    if test yes,no = "$GXX,$with_gnu_ld"; then
+	      _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-expect_unresolved $wl\*'
 	      case $host in
 	        osf3*)
-	          _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+	          _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
 		  ;;
 	        *)
-	          _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+	          _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-msym $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
 		  ;;
 	      esac
 
-	      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+	      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
 	      _LT_TAGVAR(hardcode_libdir_separator, $1)=:
 
 	      # Commands to make compiler produce verbose output that lists
@@ -6719,9 +7255,9 @@ if test "$_lt_caught_CXX_error" != yes; then
 	    # Sun C++ 4.2, 5.x and Centerline C++
             _LT_TAGVAR(archive_cmds_need_lc,$1)=yes
 	    _LT_TAGVAR(no_undefined_flag, $1)=' -zdefs'
-	    _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag}  -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	    _LT_TAGVAR(archive_cmds, $1)='$CC -G$allow_undefined_flag -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
 	    _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
-	      $CC -G${allow_undefined_flag} ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
+              $CC -G$allow_undefined_flag $wl-M $wl$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
 
 	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
 	    _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
@@ -6729,7 +7265,7 @@ if test "$_lt_caught_CXX_error" != yes; then
 	      solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;
 	      *)
 		# The compiler driver will combine and reorder linker options,
-		# but understands `-z linker_flag'.
+		# but understands '-z linker_flag'.
 	        # Supported since Solaris 2.6 (maybe 2.5.1?)
 		_LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract'
 	        ;;
@@ -6746,30 +7282,30 @@ if test "$_lt_caught_CXX_error" != yes; then
 	    ;;
           gcx*)
 	    # Green Hills C++ Compiler
-	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
+	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib'
 
 	    # The C++ compiler must be used to create the archive.
 	    _LT_TAGVAR(old_archive_cmds, $1)='$CC $LDFLAGS -archive -o $oldlib $oldobjs'
 	    ;;
           *)
 	    # GNU C++ compiler with Solaris linker
-	    if test "$GXX" = yes && test "$with_gnu_ld" = no; then
-	      _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-z ${wl}defs'
+	    if test yes,no = "$GXX,$with_gnu_ld"; then
+	      _LT_TAGVAR(no_undefined_flag, $1)=' $wl-z ${wl}defs'
 	      if $CC --version | $GREP -v '^2\.7' > /dev/null; then
-	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
+	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib'
 	        _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
-		  $CC -shared $pic_flag -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
+                  $CC -shared $pic_flag -nostdlib $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
 
 	        # Commands to make compiler produce verbose output that lists
 	        # what "hidden" libraries, object files and flags are used when
 	        # linking a shared library.
 	        output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
 	      else
-	        # g++ 2.7 appears to require `-G' NOT `-shared' on this
+	        # g++ 2.7 appears to require '-G' NOT '-shared' on this
 	        # platform.
-	        _LT_TAGVAR(archive_cmds, $1)='$CC -G -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
+	        _LT_TAGVAR(archive_cmds, $1)='$CC -G -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib'
 	        _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
-		  $CC -G -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
+                  $CC -G -nostdlib $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
 
 	        # Commands to make compiler produce verbose output that lists
 	        # what "hidden" libraries, object files and flags are used when
@@ -6777,11 +7313,11 @@ if test "$_lt_caught_CXX_error" != yes; then
 	        output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
 	      fi
 
-	      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $wl$libdir'
+	      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R $wl$libdir'
 	      case $host_os in
 		solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;
 		*)
-		  _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract'
+		  _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl-z ${wl}allextract$convenience $wl-z ${wl}defaultextract'
 		  ;;
 	      esac
 	    fi
@@ -6790,52 +7326,52 @@ if test "$_lt_caught_CXX_error" != yes; then
         ;;
 
     sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*)
-      _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'
+      _LT_TAGVAR(no_undefined_flag, $1)='$wl-z,text'
       _LT_TAGVAR(archive_cmds_need_lc, $1)=no
       _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
       runpath_var='LD_RUN_PATH'
 
       case $cc_basename in
         CC*)
-	  _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	  _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  _LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
 	  ;;
 	*)
-	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	  _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
 	  ;;
       esac
       ;;
 
       sysv5* | sco3.2v5* | sco5v6*)
-	# Note: We can NOT use -z defs as we might desire, because we do not
+	# Note: We CANNOT use -z defs as we might desire, because we do not
 	# link with -lc, and that would cause any symbols used from libc to
 	# always be unresolved, which means just about no library would
 	# ever link correctly.  If we're not using GNU ld we use -z text
 	# though, which does catch some bad symbols but isn't as heavy-handed
 	# as -z defs.
-	_LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'
-	_LT_TAGVAR(allow_undefined_flag, $1)='${wl}-z,nodefs'
+	_LT_TAGVAR(no_undefined_flag, $1)='$wl-z,text'
+	_LT_TAGVAR(allow_undefined_flag, $1)='$wl-z,nodefs'
 	_LT_TAGVAR(archive_cmds_need_lc, $1)=no
 	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
-	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R,$libdir'
+	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R,$libdir'
 	_LT_TAGVAR(hardcode_libdir_separator, $1)=':'
 	_LT_TAGVAR(link_all_deplibs, $1)=yes
-	_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport'
+	_LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-Bexport'
 	runpath_var='LD_RUN_PATH'
 
 	case $cc_basename in
           CC*)
-	    _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	    _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	    _LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	    _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
 	    _LT_TAGVAR(old_archive_cmds, $1)='$CC -Tprelink_objects $oldobjs~
-	      '"$_LT_TAGVAR(old_archive_cmds, $1)"
+              '"$_LT_TAGVAR(old_archive_cmds, $1)"
 	    _LT_TAGVAR(reload_cmds, $1)='$CC -Tprelink_objects $reload_objs~
-	      '"$_LT_TAGVAR(reload_cmds, $1)"
+              '"$_LT_TAGVAR(reload_cmds, $1)"
 	    ;;
 	  *)
-	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	    _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	    _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
 	    ;;
 	esac
       ;;
@@ -6866,10 +7402,10 @@ if test "$_lt_caught_CXX_error" != yes; then
     esac
 
     AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)])
-    test "$_LT_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no
+    test no = "$_LT_TAGVAR(ld_shlibs, $1)" && can_build_shared=no
 
-    _LT_TAGVAR(GCC, $1)="$GXX"
-    _LT_TAGVAR(LD, $1)="$LD"
+    _LT_TAGVAR(GCC, $1)=$GXX
+    _LT_TAGVAR(LD, $1)=$LD
 
     ## CAVEAT EMPTOR:
     ## There is no encapsulation within the following macros, do not change
@@ -6896,7 +7432,7 @@ if test "$_lt_caught_CXX_error" != yes; then
   lt_cv_path_LD=$lt_save_path_LD
   lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld
   lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld
-fi # test "$_lt_caught_CXX_error" != yes
+fi # test yes != "$_lt_caught_CXX_error"
 
 AC_LANG_POP
 ])# _LT_LANG_CXX_CONFIG
@@ -6918,13 +7454,14 @@ AC_REQUIRE([_LT_DECL_SED])
 AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH])
 func_stripname_cnf ()
 {
-  case ${2} in
-  .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
-  *)  func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
+  case @S|@2 in
+  .*) func_stripname_result=`$ECHO "@S|@3" | $SED "s%^@S|@1%%; s%\\\\@S|@2\$%%"`;;
+  *)  func_stripname_result=`$ECHO "@S|@3" | $SED "s%^@S|@1%%; s%@S|@2\$%%"`;;
   esac
 } # func_stripname_cnf
 ])# _LT_FUNC_STRIPNAME_CNF
 
+
 # _LT_SYS_HIDDEN_LIBDEPS([TAGNAME])
 # ---------------------------------
 # Figure out "hidden" library dependencies from verbose
@@ -7008,13 +7545,14 @@ if AC_TRY_EVAL(ac_compile); then
   pre_test_object_deps_done=no
 
   for p in `eval "$output_verbose_link_cmd"`; do
-    case ${prev}${p} in
+    case $prev$p in
 
     -L* | -R* | -l*)
        # Some compilers place space between "-{L,R}" and the path.
        # Remove the space.
-       if test $p = "-L" ||
-          test $p = "-R"; then
+       if test x-L = "x$p" ||
+          test x-R = "x$p" ||
+          test x-l = "x$p"; then
 	 prev=$p
 	 continue
        fi
@@ -7030,16 +7568,16 @@ if AC_TRY_EVAL(ac_compile); then
        case $p in
        =*) func_stripname_cnf '=' '' "$p"; p=$lt_sysroot$func_stripname_result ;;
        esac
-       if test "$pre_test_object_deps_done" = no; then
-	 case ${prev} in
+       if test no = "$pre_test_object_deps_done"; then
+	 case $prev in
 	 -L | -R)
 	   # Internal compiler library paths should come after those
 	   # provided the user.  The postdeps already come after the
 	   # user supplied libs so there is no need to process them.
 	   if test -z "$_LT_TAGVAR(compiler_lib_search_path, $1)"; then
-	     _LT_TAGVAR(compiler_lib_search_path, $1)="${prev}${p}"
+	     _LT_TAGVAR(compiler_lib_search_path, $1)=$prev$p
 	   else
-	     _LT_TAGVAR(compiler_lib_search_path, $1)="${_LT_TAGVAR(compiler_lib_search_path, $1)} ${prev}${p}"
+	     _LT_TAGVAR(compiler_lib_search_path, $1)="${_LT_TAGVAR(compiler_lib_search_path, $1)} $prev$p"
 	   fi
 	   ;;
 	 # The "-l" case would never come before the object being
@@ -7047,9 +7585,9 @@ if AC_TRY_EVAL(ac_compile); then
 	 esac
        else
 	 if test -z "$_LT_TAGVAR(postdeps, $1)"; then
-	   _LT_TAGVAR(postdeps, $1)="${prev}${p}"
+	   _LT_TAGVAR(postdeps, $1)=$prev$p
 	 else
-	   _LT_TAGVAR(postdeps, $1)="${_LT_TAGVAR(postdeps, $1)} ${prev}${p}"
+	   _LT_TAGVAR(postdeps, $1)="${_LT_TAGVAR(postdeps, $1)} $prev$p"
 	 fi
        fi
        prev=
@@ -7064,15 +7602,15 @@ if AC_TRY_EVAL(ac_compile); then
 	 continue
        fi
 
-       if test "$pre_test_object_deps_done" = no; then
+       if test no = "$pre_test_object_deps_done"; then
 	 if test -z "$_LT_TAGVAR(predep_objects, $1)"; then
-	   _LT_TAGVAR(predep_objects, $1)="$p"
+	   _LT_TAGVAR(predep_objects, $1)=$p
 	 else
 	   _LT_TAGVAR(predep_objects, $1)="$_LT_TAGVAR(predep_objects, $1) $p"
 	 fi
        else
 	 if test -z "$_LT_TAGVAR(postdep_objects, $1)"; then
-	   _LT_TAGVAR(postdep_objects, $1)="$p"
+	   _LT_TAGVAR(postdep_objects, $1)=$p
 	 else
 	   _LT_TAGVAR(postdep_objects, $1)="$_LT_TAGVAR(postdep_objects, $1) $p"
 	 fi
@@ -7103,51 +7641,6 @@ interix[[3-9]]*)
   _LT_TAGVAR(postdep_objects,$1)=
   _LT_TAGVAR(postdeps,$1)=
   ;;
-
-linux*)
-  case `$CC -V 2>&1 | sed 5q` in
-  *Sun\ C*)
-    # Sun C++ 5.9
-
-    # The more standards-conforming stlport4 library is
-    # incompatible with the Cstd library. Avoid specifying
-    # it if it's in CXXFLAGS. Ignore libCrun as
-    # -library=stlport4 depends on it.
-    case " $CXX $CXXFLAGS " in
-    *" -library=stlport4 "*)
-      solaris_use_stlport4=yes
-      ;;
-    esac
-
-    if test "$solaris_use_stlport4" != yes; then
-      _LT_TAGVAR(postdeps,$1)='-library=Cstd -library=Crun'
-    fi
-    ;;
-  esac
-  ;;
-
-solaris*)
-  case $cc_basename in
-  CC* | sunCC*)
-    # The more standards-conforming stlport4 library is
-    # incompatible with the Cstd library. Avoid specifying
-    # it if it's in CXXFLAGS. Ignore libCrun as
-    # -library=stlport4 depends on it.
-    case " $CXX $CXXFLAGS " in
-    *" -library=stlport4 "*)
-      solaris_use_stlport4=yes
-      ;;
-    esac
-
-    # Adding this requires a known-good setup of shared libraries for
-    # Sun compiler versions before 5.6, else PIC objects from an old
-    # archive will be linked into the output, leading to subtle bugs.
-    if test "$solaris_use_stlport4" != yes; then
-      _LT_TAGVAR(postdeps,$1)='-library=Cstd -library=Crun'
-    fi
-    ;;
-  esac
-  ;;
 esac
 ])
 
@@ -7156,7 +7649,7 @@ case " $_LT_TAGVAR(postdeps, $1) " in
 esac
  _LT_TAGVAR(compiler_lib_search_dirs, $1)=
 if test -n "${_LT_TAGVAR(compiler_lib_search_path, $1)}"; then
- _LT_TAGVAR(compiler_lib_search_dirs, $1)=`echo " ${_LT_TAGVAR(compiler_lib_search_path, $1)}" | ${SED} -e 's! -L! !g' -e 's!^ !!'`
+ _LT_TAGVAR(compiler_lib_search_dirs, $1)=`echo " ${_LT_TAGVAR(compiler_lib_search_path, $1)}" | $SED -e 's! -L! !g' -e 's!^ !!'`
 fi
 _LT_TAGDECL([], [compiler_lib_search_dirs], [1],
     [The directories searched by this compiler when creating a shared library])
@@ -7176,10 +7669,10 @@ _LT_TAGDECL([], [compiler_lib_search_path], [1],
 # --------------------------
 # Ensure that the configuration variables for a Fortran 77 compiler are
 # suitably defined.  These variables are subsequently used by _LT_CONFIG
-# to write the compiler configuration to `libtool'.
+# to write the compiler configuration to 'libtool'.
 m4_defun([_LT_LANG_F77_CONFIG],
 [AC_LANG_PUSH(Fortran 77)
-if test -z "$F77" || test "X$F77" = "Xno"; then
+if test -z "$F77" || test no = "$F77"; then
   _lt_disable_F77=yes
 fi
 
@@ -7216,7 +7709,7 @@ _LT_TAGVAR(objext, $1)=$objext
 # the F77 compiler isn't working.  Some variables (like enable_shared)
 # are currently assumed to apply to all compilers on this platform,
 # and will be corrupted by setting them based on a non-working compiler.
-if test "$_lt_disable_F77" != yes; then
+if test yes != "$_lt_disable_F77"; then
   # Code to be used in simple compile tests
   lt_simple_compile_test_code="\
       subroutine t
@@ -7238,7 +7731,7 @@ if test "$_lt_disable_F77" != yes; then
   _LT_LINKER_BOILERPLATE
 
   # Allow CC to be a program name with arguments.
-  lt_save_CC="$CC"
+  lt_save_CC=$CC
   lt_save_GCC=$GCC
   lt_save_CFLAGS=$CFLAGS
   CC=${F77-"f77"}
@@ -7252,21 +7745,25 @@ if test "$_lt_disable_F77" != yes; then
     AC_MSG_RESULT([$can_build_shared])
 
     AC_MSG_CHECKING([whether to build shared libraries])
-    test "$can_build_shared" = "no" && enable_shared=no
+    test no = "$can_build_shared" && enable_shared=no
 
     # On AIX, shared libraries and static libraries use the same namespace, and
     # are all built from PIC.
     case $host_os in
       aix3*)
-        test "$enable_shared" = yes && enable_static=no
+        test yes = "$enable_shared" && enable_static=no
         if test -n "$RANLIB"; then
           archive_cmds="$archive_cmds~\$RANLIB \$lib"
           postinstall_cmds='$RANLIB $lib'
         fi
         ;;
       aix[[4-9]]*)
-	if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
-	  test "$enable_shared" = yes && enable_static=no
+	if test ia64 != "$host_cpu"; then
+	  case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in
+	  yes,aix,yes) ;;		# shared object as lib.so file only
+	  yes,svr4,*) ;;		# shared object as lib.so archive member only
+	  yes,*) enable_static=no ;;	# shared object in lib.a archive as well
+	  esac
 	fi
         ;;
     esac
@@ -7274,11 +7771,11 @@ if test "$_lt_disable_F77" != yes; then
 
     AC_MSG_CHECKING([whether to build static libraries])
     # Make sure either enable_shared or enable_static is yes.
-    test "$enable_shared" = yes || enable_static=yes
+    test yes = "$enable_shared" || enable_static=yes
     AC_MSG_RESULT([$enable_static])
 
-    _LT_TAGVAR(GCC, $1)="$G77"
-    _LT_TAGVAR(LD, $1)="$LD"
+    _LT_TAGVAR(GCC, $1)=$G77
+    _LT_TAGVAR(LD, $1)=$LD
 
     ## CAVEAT EMPTOR:
     ## There is no encapsulation within the following macros, do not change
@@ -7295,9 +7792,9 @@ if test "$_lt_disable_F77" != yes; then
   fi # test -n "$compiler"
 
   GCC=$lt_save_GCC
-  CC="$lt_save_CC"
-  CFLAGS="$lt_save_CFLAGS"
-fi # test "$_lt_disable_F77" != yes
+  CC=$lt_save_CC
+  CFLAGS=$lt_save_CFLAGS
+fi # test yes != "$_lt_disable_F77"
 
 AC_LANG_POP
 ])# _LT_LANG_F77_CONFIG
@@ -7307,11 +7804,11 @@ AC_LANG_POP
 # -------------------------
 # Ensure that the configuration variables for a Fortran compiler are
 # suitably defined.  These variables are subsequently used by _LT_CONFIG
-# to write the compiler configuration to `libtool'.
+# to write the compiler configuration to 'libtool'.
 m4_defun([_LT_LANG_FC_CONFIG],
 [AC_LANG_PUSH(Fortran)
 
-if test -z "$FC" || test "X$FC" = "Xno"; then
+if test -z "$FC" || test no = "$FC"; then
   _lt_disable_FC=yes
 fi
 
@@ -7348,7 +7845,7 @@ _LT_TAGVAR(objext, $1)=$objext
 # the FC compiler isn't working.  Some variables (like enable_shared)
 # are currently assumed to apply to all compilers on this platform,
 # and will be corrupted by setting them based on a non-working compiler.
-if test "$_lt_disable_FC" != yes; then
+if test yes != "$_lt_disable_FC"; then
   # Code to be used in simple compile tests
   lt_simple_compile_test_code="\
       subroutine t
@@ -7370,7 +7867,7 @@ if test "$_lt_disable_FC" != yes; then
   _LT_LINKER_BOILERPLATE
 
   # Allow CC to be a program name with arguments.
-  lt_save_CC="$CC"
+  lt_save_CC=$CC
   lt_save_GCC=$GCC
   lt_save_CFLAGS=$CFLAGS
   CC=${FC-"f95"}
@@ -7386,21 +7883,25 @@ if test "$_lt_disable_FC" != yes; then
     AC_MSG_RESULT([$can_build_shared])
 
     AC_MSG_CHECKING([whether to build shared libraries])
-    test "$can_build_shared" = "no" && enable_shared=no
+    test no = "$can_build_shared" && enable_shared=no
 
     # On AIX, shared libraries and static libraries use the same namespace, and
     # are all built from PIC.
     case $host_os in
       aix3*)
-        test "$enable_shared" = yes && enable_static=no
+        test yes = "$enable_shared" && enable_static=no
         if test -n "$RANLIB"; then
           archive_cmds="$archive_cmds~\$RANLIB \$lib"
           postinstall_cmds='$RANLIB $lib'
         fi
         ;;
       aix[[4-9]]*)
-	if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
-	  test "$enable_shared" = yes && enable_static=no
+	if test ia64 != "$host_cpu"; then
+	  case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in
+	  yes,aix,yes) ;;		# shared object as lib.so file only
+	  yes,svr4,*) ;;		# shared object as lib.so archive member only
+	  yes,*) enable_static=no ;;	# shared object in lib.a archive as well
+	  esac
 	fi
         ;;
     esac
@@ -7408,11 +7909,11 @@ if test "$_lt_disable_FC" != yes; then
 
     AC_MSG_CHECKING([whether to build static libraries])
     # Make sure either enable_shared or enable_static is yes.
-    test "$enable_shared" = yes || enable_static=yes
+    test yes = "$enable_shared" || enable_static=yes
     AC_MSG_RESULT([$enable_static])
 
-    _LT_TAGVAR(GCC, $1)="$ac_cv_fc_compiler_gnu"
-    _LT_TAGVAR(LD, $1)="$LD"
+    _LT_TAGVAR(GCC, $1)=$ac_cv_fc_compiler_gnu
+    _LT_TAGVAR(LD, $1)=$LD
 
     ## CAVEAT EMPTOR:
     ## There is no encapsulation within the following macros, do not change
@@ -7432,7 +7933,7 @@ if test "$_lt_disable_FC" != yes; then
   GCC=$lt_save_GCC
   CC=$lt_save_CC
   CFLAGS=$lt_save_CFLAGS
-fi # test "$_lt_disable_FC" != yes
+fi # test yes != "$_lt_disable_FC"
 
 AC_LANG_POP
 ])# _LT_LANG_FC_CONFIG
@@ -7442,7 +7943,7 @@ AC_LANG_POP
 # --------------------------
 # Ensure that the configuration variables for the GNU Java Compiler compiler
 # are suitably defined.  These variables are subsequently used by _LT_CONFIG
-# to write the compiler configuration to `libtool'.
+# to write the compiler configuration to 'libtool'.
 m4_defun([_LT_LANG_GCJ_CONFIG],
 [AC_REQUIRE([LT_PROG_GCJ])dnl
 AC_LANG_SAVE
@@ -7476,7 +7977,7 @@ CC=${GCJ-"gcj"}
 CFLAGS=$GCJFLAGS
 compiler=$CC
 _LT_TAGVAR(compiler, $1)=$CC
-_LT_TAGVAR(LD, $1)="$LD"
+_LT_TAGVAR(LD, $1)=$LD
 _LT_CC_BASENAME([$compiler])
 
 # GCJ did not exist at the time GCC didn't implicitly link libc in.
@@ -7513,7 +8014,7 @@ CFLAGS=$lt_save_CFLAGS
 # --------------------------
 # Ensure that the configuration variables for the GNU Go compiler
 # are suitably defined.  These variables are subsequently used by _LT_CONFIG
-# to write the compiler configuration to `libtool'.
+# to write the compiler configuration to 'libtool'.
 m4_defun([_LT_LANG_GO_CONFIG],
 [AC_REQUIRE([LT_PROG_GO])dnl
 AC_LANG_SAVE
@@ -7547,7 +8048,7 @@ CC=${GOC-"gccgo"}
 CFLAGS=$GOFLAGS
 compiler=$CC
 _LT_TAGVAR(compiler, $1)=$CC
-_LT_TAGVAR(LD, $1)="$LD"
+_LT_TAGVAR(LD, $1)=$LD
 _LT_CC_BASENAME([$compiler])
 
 # Go did not exist at the time GCC didn't implicitly link libc in.
@@ -7584,7 +8085,7 @@ CFLAGS=$lt_save_CFLAGS
 # -------------------------
 # Ensure that the configuration variables for the Windows resource compiler
 # are suitably defined.  These variables are subsequently used by _LT_CONFIG
-# to write the compiler configuration to `libtool'.
+# to write the compiler configuration to 'libtool'.
 m4_defun([_LT_LANG_RC_CONFIG],
 [AC_REQUIRE([LT_PROG_RC])dnl
 AC_LANG_SAVE
@@ -7600,7 +8101,7 @@ _LT_TAGVAR(objext, $1)=$objext
 lt_simple_compile_test_code='sample MENU { MENUITEM "&Soup", 100, CHECKED }'
 
 # Code to be used in simple link tests
-lt_simple_link_test_code="$lt_simple_compile_test_code"
+lt_simple_link_test_code=$lt_simple_compile_test_code
 
 # ltmain only uses $CC for tagged configurations so make sure $CC is set.
 _LT_TAG_COMPILER
@@ -7610,7 +8111,7 @@ _LT_COMPILER_BOILERPLATE
 _LT_LINKER_BOILERPLATE
 
 # Allow CC to be a program name with arguments.
-lt_save_CC="$CC"
+lt_save_CC=$CC
 lt_save_CFLAGS=$CFLAGS
 lt_save_GCC=$GCC
 GCC=
@@ -7639,7 +8140,7 @@ AC_DEFUN([LT_PROG_GCJ],
 [m4_ifdef([AC_PROG_GCJ], [AC_PROG_GCJ],
   [m4_ifdef([A][M_PROG_GCJ], [A][M_PROG_GCJ],
     [AC_CHECK_TOOL(GCJ, gcj,)
-      test "x${GCJFLAGS+set}" = xset || GCJFLAGS="-g -O2"
+      test set = "${GCJFLAGS+set}" || GCJFLAGS="-g -O2"
       AC_SUBST(GCJFLAGS)])])[]dnl
 ])
 
@@ -7750,7 +8251,7 @@ lt_ac_count=0
 # Add /usr/xpg4/bin/sed as it is typically found on Solaris
 # along with /bin/sed that truncates output.
 for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do
-  test ! -f $lt_ac_sed && continue
+  test ! -f "$lt_ac_sed" && continue
   cat /dev/null > conftest.in
   lt_ac_count=0
   echo $ECHO_N "0123456789$ECHO_C" >conftest.in
@@ -7767,9 +8268,9 @@ for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do
     $lt_ac_sed -e 's/a$//' < conftest.nl >conftest.out || break
     cmp -s conftest.out conftest.nl || break
     # 10000 chars as input seems more than enough
-    test $lt_ac_count -gt 10 && break
+    test 10 -lt "$lt_ac_count" && break
     lt_ac_count=`expr $lt_ac_count + 1`
-    if test $lt_ac_count -gt $lt_ac_max; then
+    if test "$lt_ac_count" -gt "$lt_ac_max"; then
       lt_ac_max=$lt_ac_count
       lt_cv_path_SED=$lt_ac_sed
     fi
@@ -7793,27 +8294,7 @@ dnl AC_DEFUN([LT_AC_PROG_SED], [])
 # Find out whether the shell is Bourne or XSI compatible,
 # or has some other useful features.
 m4_defun([_LT_CHECK_SHELL_FEATURES],
-[AC_MSG_CHECKING([whether the shell understands some XSI constructs])
-# Try some XSI features
-xsi_shell=no
-( _lt_dummy="a/b/c"
-  test "${_lt_dummy##*/},${_lt_dummy%/*},${_lt_dummy#??}"${_lt_dummy%"$_lt_dummy"}, \
-      = c,a/b,b/c, \
-    && eval 'test $(( 1 + 1 )) -eq 2 \
-    && test "${#_lt_dummy}" -eq 5' ) >/dev/null 2>&1 \
-  && xsi_shell=yes
-AC_MSG_RESULT([$xsi_shell])
-_LT_CONFIG_LIBTOOL_INIT([xsi_shell='$xsi_shell'])
-
-AC_MSG_CHECKING([whether the shell understands "+="])
-lt_shell_append=no
-( foo=bar; set foo baz; eval "$[1]+=\$[2]" && test "$foo" = barbaz ) \
-    >/dev/null 2>&1 \
-  && lt_shell_append=yes
-AC_MSG_RESULT([$lt_shell_append])
-_LT_CONFIG_LIBTOOL_INIT([lt_shell_append='$lt_shell_append'])
-
-if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
+[if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
   lt_unset=unset
 else
   lt_unset=false
@@ -7837,102 +8318,9 @@ _LT_DECL([NL2SP], [lt_NL2SP], [1], [turn newlines into spaces])dnl
 ])# _LT_CHECK_SHELL_FEATURES
 
 
-# _LT_PROG_FUNCTION_REPLACE (FUNCNAME, REPLACEMENT-BODY)
-# ------------------------------------------------------
-# In `$cfgfile', look for function FUNCNAME delimited by `^FUNCNAME ()$' and
-# '^} FUNCNAME ', and replace its body with REPLACEMENT-BODY.
-m4_defun([_LT_PROG_FUNCTION_REPLACE],
-[dnl {
-sed -e '/^$1 ()$/,/^} # $1 /c\
-$1 ()\
-{\
-m4_bpatsubsts([$2], [$], [\\], [^\([	 ]\)], [\\\1])
-} # Extended-shell $1 implementation' "$cfgfile" > $cfgfile.tmp \
-  && mv -f "$cfgfile.tmp" "$cfgfile" \
-    || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
-test 0 -eq $? || _lt_function_replace_fail=:
-])
-
-
-# _LT_PROG_REPLACE_SHELLFNS
-# -------------------------
-# Replace existing portable implementations of several shell functions with
-# equivalent extended shell implementations where those features are available..
-m4_defun([_LT_PROG_REPLACE_SHELLFNS],
-[if test x"$xsi_shell" = xyes; then
-  _LT_PROG_FUNCTION_REPLACE([func_dirname], [dnl
-    case ${1} in
-      */*) func_dirname_result="${1%/*}${2}" ;;
-      *  ) func_dirname_result="${3}" ;;
-    esac])
-
-  _LT_PROG_FUNCTION_REPLACE([func_basename], [dnl
-    func_basename_result="${1##*/}"])
-
-  _LT_PROG_FUNCTION_REPLACE([func_dirname_and_basename], [dnl
-    case ${1} in
-      */*) func_dirname_result="${1%/*}${2}" ;;
-      *  ) func_dirname_result="${3}" ;;
-    esac
-    func_basename_result="${1##*/}"])
-
-  _LT_PROG_FUNCTION_REPLACE([func_stripname], [dnl
-    # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are
-    # positional parameters, so assign one to ordinary parameter first.
-    func_stripname_result=${3}
-    func_stripname_result=${func_stripname_result#"${1}"}
-    func_stripname_result=${func_stripname_result%"${2}"}])
-
-  _LT_PROG_FUNCTION_REPLACE([func_split_long_opt], [dnl
-    func_split_long_opt_name=${1%%=*}
-    func_split_long_opt_arg=${1#*=}])
-
-  _LT_PROG_FUNCTION_REPLACE([func_split_short_opt], [dnl
-    func_split_short_opt_arg=${1#??}
-    func_split_short_opt_name=${1%"$func_split_short_opt_arg"}])
-
-  _LT_PROG_FUNCTION_REPLACE([func_lo2o], [dnl
-    case ${1} in
-      *.lo) func_lo2o_result=${1%.lo}.${objext} ;;
-      *)    func_lo2o_result=${1} ;;
-    esac])
-
-  _LT_PROG_FUNCTION_REPLACE([func_xform], [    func_xform_result=${1%.*}.lo])
-
-  _LT_PROG_FUNCTION_REPLACE([func_arith], [    func_arith_result=$(( $[*] ))])
-
-  _LT_PROG_FUNCTION_REPLACE([func_len], [    func_len_result=${#1}])
-fi
-
-if test x"$lt_shell_append" = xyes; then
-  _LT_PROG_FUNCTION_REPLACE([func_append], [    eval "${1}+=\\${2}"])
-
-  _LT_PROG_FUNCTION_REPLACE([func_append_quoted], [dnl
-    func_quote_for_eval "${2}"
-dnl m4 expansion turns \\\\ into \\, and then the shell eval turns that into \
-    eval "${1}+=\\\\ \\$func_quote_for_eval_result"])
-
-  # Save a `func_append' function call where possible by direct use of '+='
-  sed -e 's%func_append \([[a-zA-Z_]]\{1,\}\) "%\1+="%g' $cfgfile > $cfgfile.tmp \
-    && mv -f "$cfgfile.tmp" "$cfgfile" \
-      || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
-  test 0 -eq $? || _lt_function_replace_fail=:
-else
-  # Save a `func_append' function call even when '+=' is not available
-  sed -e 's%func_append \([[a-zA-Z_]]\{1,\}\) "%\1="$\1%g' $cfgfile > $cfgfile.tmp \
-    && mv -f "$cfgfile.tmp" "$cfgfile" \
-      || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
-  test 0 -eq $? || _lt_function_replace_fail=:
-fi
-
-if test x"$_lt_function_replace_fail" = x":"; then
-  AC_MSG_WARN([Unable to substitute extended shell functions in $ofile])
-fi
-])
-
 # _LT_PATH_CONVERSION_FUNCTIONS
 # -----------------------------
-# Determine which file name conversion functions should be used by
+# Determine what file name conversion functions should be used by
 # func_to_host_file (and, implicitly, by func_to_host_path).  These are needed
 # for certain cross-compile configurations and native mingw.
 m4_defun([_LT_PATH_CONVERSION_FUNCTIONS],
diff --git a/Engine/lib/sdl/acinclude/ltoptions.m4 b/Engine/lib/sdl/acinclude/ltoptions.m4
index 5d9acd8e2..94b082976 100644
--- a/Engine/lib/sdl/acinclude/ltoptions.m4
+++ b/Engine/lib/sdl/acinclude/ltoptions.m4
@@ -1,14 +1,14 @@
 # Helper functions for option handling.                    -*- Autoconf -*-
 #
-#   Copyright (C) 2004, 2005, 2007, 2008, 2009 Free Software Foundation,
-#   Inc.
+#   Copyright (C) 2004-2005, 2007-2009, 2011-2015 Free Software
+#   Foundation, Inc.
 #   Written by Gary V. Vaughan, 2004
 #
 # This file is free software; the Free Software Foundation gives
 # unlimited permission to copy and/or distribute it, with or without
 # modifications, as long as this notice is preserved.
 
-# serial 7 ltoptions.m4
+# serial 8 ltoptions.m4
 
 # This is to help aclocal find these macros, as it can't see m4_define.
 AC_DEFUN([LTOPTIONS_VERSION], [m4_if([1])])
@@ -29,7 +29,7 @@ m4_define([_LT_SET_OPTION],
 [m4_define(_LT_MANGLE_OPTION([$1], [$2]))dnl
 m4_ifdef(_LT_MANGLE_DEFUN([$1], [$2]),
         _LT_MANGLE_DEFUN([$1], [$2]),
-    [m4_warning([Unknown $1 option `$2'])])[]dnl
+    [m4_warning([Unknown $1 option '$2'])])[]dnl
 ])
 
 
@@ -75,13 +75,15 @@ m4_if([$1],[LT_INIT],[
   dnl
   dnl If no reference was made to various pairs of opposing options, then
   dnl we run the default mode handler for the pair.  For example, if neither
-  dnl `shared' nor `disable-shared' was passed, we enable building of shared
+  dnl 'shared' nor 'disable-shared' was passed, we enable building of shared
   dnl archives by default:
   _LT_UNLESS_OPTIONS([LT_INIT], [shared disable-shared], [_LT_ENABLE_SHARED])
   _LT_UNLESS_OPTIONS([LT_INIT], [static disable-static], [_LT_ENABLE_STATIC])
   _LT_UNLESS_OPTIONS([LT_INIT], [pic-only no-pic], [_LT_WITH_PIC])
   _LT_UNLESS_OPTIONS([LT_INIT], [fast-install disable-fast-install],
-  		   [_LT_ENABLE_FAST_INSTALL])
+		   [_LT_ENABLE_FAST_INSTALL])
+  _LT_UNLESS_OPTIONS([LT_INIT], [aix-soname=aix aix-soname=both aix-soname=svr4],
+		   [_LT_WITH_AIX_SONAME([aix])])
   ])
 ])# _LT_SET_OPTIONS
 
@@ -112,7 +114,7 @@ AU_DEFUN([AC_LIBTOOL_DLOPEN],
 [_LT_SET_OPTION([LT_INIT], [dlopen])
 AC_DIAGNOSE([obsolete],
 [$0: Remove this warning and the call to _LT_SET_OPTION when you
-put the `dlopen' option into LT_INIT's first parameter.])
+put the 'dlopen' option into LT_INIT's first parameter.])
 ])
 
 dnl aclocal-1.4 backwards compatibility:
@@ -148,7 +150,7 @@ AU_DEFUN([AC_LIBTOOL_WIN32_DLL],
 _LT_SET_OPTION([LT_INIT], [win32-dll])
 AC_DIAGNOSE([obsolete],
 [$0: Remove this warning and the call to _LT_SET_OPTION when you
-put the `win32-dll' option into LT_INIT's first parameter.])
+put the 'win32-dll' option into LT_INIT's first parameter.])
 ])
 
 dnl aclocal-1.4 backwards compatibility:
@@ -157,9 +159,9 @@ dnl AC_DEFUN([AC_LIBTOOL_WIN32_DLL], [])
 
 # _LT_ENABLE_SHARED([DEFAULT])
 # ----------------------------
-# implement the --enable-shared flag, and supports the `shared' and
-# `disable-shared' LT_INIT options.
-# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.
+# implement the --enable-shared flag, and supports the 'shared' and
+# 'disable-shared' LT_INIT options.
+# DEFAULT is either 'yes' or 'no'.  If omitted, it defaults to 'yes'.
 m4_define([_LT_ENABLE_SHARED],
 [m4_define([_LT_ENABLE_SHARED_DEFAULT], [m4_if($1, no, no, yes)])dnl
 AC_ARG_ENABLE([shared],
@@ -172,14 +174,14 @@ AC_ARG_ENABLE([shared],
     *)
       enable_shared=no
       # Look at the argument we got.  We use all the common list separators.
-      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
       for pkg in $enableval; do
-	IFS="$lt_save_ifs"
+	IFS=$lt_save_ifs
 	if test "X$pkg" = "X$p"; then
 	  enable_shared=yes
 	fi
       done
-      IFS="$lt_save_ifs"
+      IFS=$lt_save_ifs
       ;;
     esac],
     [enable_shared=]_LT_ENABLE_SHARED_DEFAULT)
@@ -211,9 +213,9 @@ dnl AC_DEFUN([AM_DISABLE_SHARED], [])
 
 # _LT_ENABLE_STATIC([DEFAULT])
 # ----------------------------
-# implement the --enable-static flag, and support the `static' and
-# `disable-static' LT_INIT options.
-# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.
+# implement the --enable-static flag, and support the 'static' and
+# 'disable-static' LT_INIT options.
+# DEFAULT is either 'yes' or 'no'.  If omitted, it defaults to 'yes'.
 m4_define([_LT_ENABLE_STATIC],
 [m4_define([_LT_ENABLE_STATIC_DEFAULT], [m4_if($1, no, no, yes)])dnl
 AC_ARG_ENABLE([static],
@@ -226,14 +228,14 @@ AC_ARG_ENABLE([static],
     *)
      enable_static=no
       # Look at the argument we got.  We use all the common list separators.
-      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
       for pkg in $enableval; do
-	IFS="$lt_save_ifs"
+	IFS=$lt_save_ifs
 	if test "X$pkg" = "X$p"; then
 	  enable_static=yes
 	fi
       done
-      IFS="$lt_save_ifs"
+      IFS=$lt_save_ifs
       ;;
     esac],
     [enable_static=]_LT_ENABLE_STATIC_DEFAULT)
@@ -265,9 +267,9 @@ dnl AC_DEFUN([AM_DISABLE_STATIC], [])
 
 # _LT_ENABLE_FAST_INSTALL([DEFAULT])
 # ----------------------------------
-# implement the --enable-fast-install flag, and support the `fast-install'
-# and `disable-fast-install' LT_INIT options.
-# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.
+# implement the --enable-fast-install flag, and support the 'fast-install'
+# and 'disable-fast-install' LT_INIT options.
+# DEFAULT is either 'yes' or 'no'.  If omitted, it defaults to 'yes'.
 m4_define([_LT_ENABLE_FAST_INSTALL],
 [m4_define([_LT_ENABLE_FAST_INSTALL_DEFAULT], [m4_if($1, no, no, yes)])dnl
 AC_ARG_ENABLE([fast-install],
@@ -280,14 +282,14 @@ AC_ARG_ENABLE([fast-install],
     *)
       enable_fast_install=no
       # Look at the argument we got.  We use all the common list separators.
-      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
       for pkg in $enableval; do
-	IFS="$lt_save_ifs"
+	IFS=$lt_save_ifs
 	if test "X$pkg" = "X$p"; then
 	  enable_fast_install=yes
 	fi
       done
-      IFS="$lt_save_ifs"
+      IFS=$lt_save_ifs
       ;;
     esac],
     [enable_fast_install=]_LT_ENABLE_FAST_INSTALL_DEFAULT)
@@ -304,14 +306,14 @@ AU_DEFUN([AC_ENABLE_FAST_INSTALL],
 [_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[fast-install])
 AC_DIAGNOSE([obsolete],
 [$0: Remove this warning and the call to _LT_SET_OPTION when you put
-the `fast-install' option into LT_INIT's first parameter.])
+the 'fast-install' option into LT_INIT's first parameter.])
 ])
 
 AU_DEFUN([AC_DISABLE_FAST_INSTALL],
 [_LT_SET_OPTION([LT_INIT], [disable-fast-install])
 AC_DIAGNOSE([obsolete],
 [$0: Remove this warning and the call to _LT_SET_OPTION when you put
-the `disable-fast-install' option into LT_INIT's first parameter.])
+the 'disable-fast-install' option into LT_INIT's first parameter.])
 ])
 
 dnl aclocal-1.4 backwards compatibility:
@@ -319,11 +321,64 @@ dnl AC_DEFUN([AC_ENABLE_FAST_INSTALL], [])
 dnl AC_DEFUN([AM_DISABLE_FAST_INSTALL], [])
 
 
+# _LT_WITH_AIX_SONAME([DEFAULT])
+# ----------------------------------
+# implement the --with-aix-soname flag, and support the `aix-soname=aix'
+# and `aix-soname=both' and `aix-soname=svr4' LT_INIT options. DEFAULT
+# is either `aix', `both' or `svr4'.  If omitted, it defaults to `aix'.
+m4_define([_LT_WITH_AIX_SONAME],
+[m4_define([_LT_WITH_AIX_SONAME_DEFAULT], [m4_if($1, svr4, svr4, m4_if($1, both, both, aix))])dnl
+shared_archive_member_spec=
+case $host,$enable_shared in
+power*-*-aix[[5-9]]*,yes)
+  AC_MSG_CHECKING([which variant of shared library versioning to provide])
+  AC_ARG_WITH([aix-soname],
+    [AS_HELP_STRING([--with-aix-soname=aix|svr4|both],
+      [shared library versioning (aka "SONAME") variant to provide on AIX, @<:@default=]_LT_WITH_AIX_SONAME_DEFAULT[@:>@.])],
+    [case $withval in
+    aix|svr4|both)
+      ;;
+    *)
+      AC_MSG_ERROR([Unknown argument to --with-aix-soname])
+      ;;
+    esac
+    lt_cv_with_aix_soname=$with_aix_soname],
+    [AC_CACHE_VAL([lt_cv_with_aix_soname],
+      [lt_cv_with_aix_soname=]_LT_WITH_AIX_SONAME_DEFAULT)
+    with_aix_soname=$lt_cv_with_aix_soname])
+  AC_MSG_RESULT([$with_aix_soname])
+  if test aix != "$with_aix_soname"; then
+    # For the AIX way of multilib, we name the shared archive member
+    # based on the bitwidth used, traditionally 'shr.o' or 'shr_64.o',
+    # and 'shr.imp' or 'shr_64.imp', respectively, for the Import File.
+    # Even when GNU compilers ignore OBJECT_MODE but need '-maix64' flag,
+    # the AIX toolchain works better with OBJECT_MODE set (default 32).
+    if test 64 = "${OBJECT_MODE-32}"; then
+      shared_archive_member_spec=shr_64
+    else
+      shared_archive_member_spec=shr
+    fi
+  fi
+  ;;
+*)
+  with_aix_soname=aix
+  ;;
+esac
+
+_LT_DECL([], [shared_archive_member_spec], [0],
+    [Shared archive member basename, for filename based shared library versioning on AIX])dnl
+])# _LT_WITH_AIX_SONAME
+
+LT_OPTION_DEFINE([LT_INIT], [aix-soname=aix], [_LT_WITH_AIX_SONAME([aix])])
+LT_OPTION_DEFINE([LT_INIT], [aix-soname=both], [_LT_WITH_AIX_SONAME([both])])
+LT_OPTION_DEFINE([LT_INIT], [aix-soname=svr4], [_LT_WITH_AIX_SONAME([svr4])])
+
+
 # _LT_WITH_PIC([MODE])
 # --------------------
-# implement the --with-pic flag, and support the `pic-only' and `no-pic'
+# implement the --with-pic flag, and support the 'pic-only' and 'no-pic'
 # LT_INIT options.
-# MODE is either `yes' or `no'.  If omitted, it defaults to `both'.
+# MODE is either 'yes' or 'no'.  If omitted, it defaults to 'both'.
 m4_define([_LT_WITH_PIC],
 [AC_ARG_WITH([pic],
     [AS_HELP_STRING([--with-pic@<:@=PKGS@:>@],
@@ -334,19 +389,17 @@ m4_define([_LT_WITH_PIC],
     *)
       pic_mode=default
       # Look at the argument we got.  We use all the common list separators.
-      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
       for lt_pkg in $withval; do
-	IFS="$lt_save_ifs"
+	IFS=$lt_save_ifs
 	if test "X$lt_pkg" = "X$lt_p"; then
 	  pic_mode=yes
 	fi
       done
-      IFS="$lt_save_ifs"
+      IFS=$lt_save_ifs
       ;;
     esac],
-    [pic_mode=default])
-
-test -z "$pic_mode" && pic_mode=m4_default([$1], [default])
+    [pic_mode=m4_default([$1], [default])])
 
 _LT_DECL([], [pic_mode], [0], [What type of objects to build])dnl
 ])# _LT_WITH_PIC
@@ -359,7 +412,7 @@ AU_DEFUN([AC_LIBTOOL_PICMODE],
 [_LT_SET_OPTION([LT_INIT], [pic-only])
 AC_DIAGNOSE([obsolete],
 [$0: Remove this warning and the call to _LT_SET_OPTION when you
-put the `pic-only' option into LT_INIT's first parameter.])
+put the 'pic-only' option into LT_INIT's first parameter.])
 ])
 
 dnl aclocal-1.4 backwards compatibility:
diff --git a/Engine/lib/sdl/acinclude/ltsugar.m4 b/Engine/lib/sdl/acinclude/ltsugar.m4
index 9000a057d..48bc9344a 100644
--- a/Engine/lib/sdl/acinclude/ltsugar.m4
+++ b/Engine/lib/sdl/acinclude/ltsugar.m4
@@ -1,6 +1,7 @@
 # ltsugar.m4 -- libtool m4 base layer.                         -*-Autoconf-*-
 #
-# Copyright (C) 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
+# Copyright (C) 2004-2005, 2007-2008, 2011-2015 Free Software
+# Foundation, Inc.
 # Written by Gary V. Vaughan, 2004
 #
 # This file is free software; the Free Software Foundation gives
@@ -33,7 +34,7 @@ m4_define([_lt_join],
 # ------------
 # Manipulate m4 lists.
 # These macros are necessary as long as will still need to support
-# Autoconf-2.59 which quotes differently.
+# Autoconf-2.59, which quotes differently.
 m4_define([lt_car], [[$1]])
 m4_define([lt_cdr],
 [m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])],
@@ -44,7 +45,7 @@ m4_define([lt_unquote], $1)
 
 # lt_append(MACRO-NAME, STRING, [SEPARATOR])
 # ------------------------------------------
-# Redefine MACRO-NAME to hold its former content plus `SEPARATOR'`STRING'.
+# Redefine MACRO-NAME to hold its former content plus 'SEPARATOR''STRING'.
 # Note that neither SEPARATOR nor STRING are expanded; they are appended
 # to MACRO-NAME as is (leaving the expansion for when MACRO-NAME is invoked).
 # No SEPARATOR is output if MACRO-NAME was previously undefined (different
diff --git a/Engine/lib/sdl/acinclude/ltversion.m4 b/Engine/lib/sdl/acinclude/ltversion.m4
index 07a8602d4..fa04b52a3 100644
--- a/Engine/lib/sdl/acinclude/ltversion.m4
+++ b/Engine/lib/sdl/acinclude/ltversion.m4
@@ -1,6 +1,6 @@
 # ltversion.m4 -- version numbers			-*- Autoconf -*-
 #
-#   Copyright (C) 2004 Free Software Foundation, Inc.
+#   Copyright (C) 2004, 2011-2015 Free Software Foundation, Inc.
 #   Written by Scott James Remnant, 2004
 #
 # This file is free software; the Free Software Foundation gives
@@ -9,15 +9,15 @@
 
 # @configure_input@
 
-# serial 3337 ltversion.m4
+# serial 4179 ltversion.m4
 # This file is part of GNU Libtool
 
-m4_define([LT_PACKAGE_VERSION], [2.4.2])
-m4_define([LT_PACKAGE_REVISION], [1.3337])
+m4_define([LT_PACKAGE_VERSION], [2.4.6])
+m4_define([LT_PACKAGE_REVISION], [2.4.6])
 
 AC_DEFUN([LTVERSION_VERSION],
-[macro_version='2.4.2'
-macro_revision='1.3337'
+[macro_version='2.4.6'
+macro_revision='2.4.6'
 _LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?])
 _LT_DECL(, macro_revision, 0)
 ])
diff --git a/Engine/lib/sdl/acinclude/lt~obsolete.m4 b/Engine/lib/sdl/acinclude/lt~obsolete.m4
index c573da90c..c6b26f88f 100644
--- a/Engine/lib/sdl/acinclude/lt~obsolete.m4
+++ b/Engine/lib/sdl/acinclude/lt~obsolete.m4
@@ -1,6 +1,7 @@
 # lt~obsolete.m4 -- aclocal satisfying obsolete definitions.    -*-Autoconf-*-
 #
-#   Copyright (C) 2004, 2005, 2007, 2009 Free Software Foundation, Inc.
+#   Copyright (C) 2004-2005, 2007, 2009, 2011-2015 Free Software
+#   Foundation, Inc.
 #   Written by Scott James Remnant, 2004.
 #
 # This file is free software; the Free Software Foundation gives
@@ -11,7 +12,7 @@
 
 # These exist entirely to fool aclocal when bootstrapping libtool.
 #
-# In the past libtool.m4 has provided macros via AC_DEFUN (or AU_DEFUN)
+# In the past libtool.m4 has provided macros via AC_DEFUN (or AU_DEFUN),
 # which have later been changed to m4_define as they aren't part of the
 # exported API, or moved to Autoconf or Automake where they belong.
 #
@@ -25,7 +26,7 @@
 # included after everything else.  This provides aclocal with the
 # AC_DEFUNs it wants, but when m4 processes it, it doesn't do anything
 # because those macros already exist, or will be overwritten later.
-# We use AC_DEFUN over AU_DEFUN for compatibility with aclocal-1.6. 
+# We use AC_DEFUN over AU_DEFUN for compatibility with aclocal-1.6.
 #
 # Anytime we withdraw an AC_DEFUN or AU_DEFUN, remember to add it here.
 # Yes, that means every name once taken will need to remain here until
diff --git a/Engine/lib/sdl/acinclude/pkg.m4 b/Engine/lib/sdl/acinclude/pkg.m4
new file mode 100644
index 000000000..13a889017
--- /dev/null
+++ b/Engine/lib/sdl/acinclude/pkg.m4
@@ -0,0 +1,275 @@
+# pkg.m4 - Macros to locate and utilise pkg-config.   -*- Autoconf -*-
+# serial 12 (pkg-config-0.29.2)
+
+dnl Copyright © 2004 Scott James Remnant <scott@netsplit.com>.
+dnl Copyright © 2012-2015 Dan Nicholson <dbn.lists@gmail.com>
+dnl
+dnl This program is free software; you can redistribute it and/or modify
+dnl it under the terms of the GNU General Public License as published by
+dnl the Free Software Foundation; either version 2 of the License, or
+dnl (at your option) any later version.
+dnl
+dnl This program is distributed in the hope that it will be useful, but
+dnl WITHOUT ANY WARRANTY; without even the implied warranty of
+dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+dnl General Public License for more details.
+dnl
+dnl You should have received a copy of the GNU General Public License
+dnl along with this program; if not, write to the Free Software
+dnl Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+dnl 02111-1307, USA.
+dnl
+dnl As a special exception to the GNU General Public License, if you
+dnl distribute this file as part of a program that contains a
+dnl configuration script generated by Autoconf, you may include it under
+dnl the same distribution terms that you use for the rest of that
+dnl program.
+
+dnl PKG_PREREQ(MIN-VERSION)
+dnl -----------------------
+dnl Since: 0.29
+dnl
+dnl Verify that the version of the pkg-config macros are at least
+dnl MIN-VERSION. Unlike PKG_PROG_PKG_CONFIG, which checks the user's
+dnl installed version of pkg-config, this checks the developer's version
+dnl of pkg.m4 when generating configure.
+dnl
+dnl To ensure that this macro is defined, also add:
+dnl m4_ifndef([PKG_PREREQ],
+dnl     [m4_fatal([must install pkg-config 0.29 or later before running autoconf/autogen])])
+dnl
+dnl See the "Since" comment for each macro you use to see what version
+dnl of the macros you require.
+m4_defun([PKG_PREREQ],
+[m4_define([PKG_MACROS_VERSION], [0.29.2])
+m4_if(m4_version_compare(PKG_MACROS_VERSION, [$1]), -1,
+    [m4_fatal([pkg.m4 version $1 or higher is required but ]PKG_MACROS_VERSION[ found])])
+])dnl PKG_PREREQ
+
+dnl PKG_PROG_PKG_CONFIG([MIN-VERSION])
+dnl ----------------------------------
+dnl Since: 0.16
+dnl
+dnl Search for the pkg-config tool and set the PKG_CONFIG variable to
+dnl first found in the path. Checks that the version of pkg-config found
+dnl is at least MIN-VERSION. If MIN-VERSION is not specified, 0.9.0 is
+dnl used since that's the first version where most current features of
+dnl pkg-config existed.
+AC_DEFUN([PKG_PROG_PKG_CONFIG],
+[m4_pattern_forbid([^_?PKG_[A-Z_]+$])
+m4_pattern_allow([^PKG_CONFIG(_(PATH|LIBDIR|SYSROOT_DIR|ALLOW_SYSTEM_(CFLAGS|LIBS)))?$])
+m4_pattern_allow([^PKG_CONFIG_(DISABLE_UNINSTALLED|TOP_BUILD_DIR|DEBUG_SPEW)$])
+AC_ARG_VAR([PKG_CONFIG], [path to pkg-config utility])
+AC_ARG_VAR([PKG_CONFIG_PATH], [directories to add to pkg-config's search path])
+AC_ARG_VAR([PKG_CONFIG_LIBDIR], [path overriding pkg-config's built-in search path])
+
+if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
+	AC_PATH_TOOL([PKG_CONFIG], [pkg-config])
+fi
+if test -n "$PKG_CONFIG"; then
+	_pkg_min_version=m4_default([$1], [0.9.0])
+	AC_MSG_CHECKING([pkg-config is at least version $_pkg_min_version])
+	if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
+		AC_MSG_RESULT([yes])
+	else
+		AC_MSG_RESULT([no])
+		PKG_CONFIG=""
+	fi
+fi[]dnl
+])dnl PKG_PROG_PKG_CONFIG
+
+dnl PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
+dnl -------------------------------------------------------------------
+dnl Since: 0.18
+dnl
+dnl Check to see whether a particular set of modules exists. Similar to
+dnl PKG_CHECK_MODULES(), but does not set variables or print errors.
+dnl
+dnl Please remember that m4 expands AC_REQUIRE([PKG_PROG_PKG_CONFIG])
+dnl only at the first occurence in configure.ac, so if the first place
+dnl it's called might be skipped (such as if it is within an "if", you
+dnl have to call PKG_CHECK_EXISTS manually
+AC_DEFUN([PKG_CHECK_EXISTS],
+[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
+if test -n "$PKG_CONFIG" && \
+    AC_RUN_LOG([$PKG_CONFIG --exists --print-errors "$1"]); then
+  m4_default([$2], [:])
+m4_ifvaln([$3], [else
+  $3])dnl
+fi])
+
+dnl _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
+dnl ---------------------------------------------
+dnl Internal wrapper calling pkg-config via PKG_CONFIG and setting
+dnl pkg_failed based on the result.
+m4_define([_PKG_CONFIG],
+[if test -n "$$1"; then
+    pkg_cv_[]$1="$$1"
+ elif test -n "$PKG_CONFIG"; then
+    PKG_CHECK_EXISTS([$3],
+                     [pkg_cv_[]$1=`$PKG_CONFIG --[]$2 "$3" 2>/dev/null`
+		      test "x$?" != "x0" && pkg_failed=yes ],
+		     [pkg_failed=yes])
+ else
+    pkg_failed=untried
+fi[]dnl
+])dnl _PKG_CONFIG
+
+dnl _PKG_SHORT_ERRORS_SUPPORTED
+dnl ---------------------------
+dnl Internal check to see if pkg-config supports short errors.
+AC_DEFUN([_PKG_SHORT_ERRORS_SUPPORTED],
+[AC_REQUIRE([PKG_PROG_PKG_CONFIG])
+if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
+        _pkg_short_errors_supported=yes
+else
+        _pkg_short_errors_supported=no
+fi[]dnl
+])dnl _PKG_SHORT_ERRORS_SUPPORTED
+
+
+dnl PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
+dnl   [ACTION-IF-NOT-FOUND])
+dnl --------------------------------------------------------------
+dnl Since: 0.4.0
+dnl
+dnl Note that if there is a possibility the first call to
+dnl PKG_CHECK_MODULES might not happen, you should be sure to include an
+dnl explicit call to PKG_PROG_PKG_CONFIG in your configure.ac
+AC_DEFUN([PKG_CHECK_MODULES],
+[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
+AC_ARG_VAR([$1][_CFLAGS], [C compiler flags for $1, overriding pkg-config])dnl
+AC_ARG_VAR([$1][_LIBS], [linker flags for $1, overriding pkg-config])dnl
+
+pkg_failed=no
+AC_MSG_CHECKING([for $2])
+
+_PKG_CONFIG([$1][_CFLAGS], [cflags], [$2])
+_PKG_CONFIG([$1][_LIBS], [libs], [$2])
+
+m4_define([_PKG_TEXT], [Alternatively, you may set the environment variables $1[]_CFLAGS
+and $1[]_LIBS to avoid the need to call pkg-config.
+See the pkg-config man page for more details.])
+
+if test $pkg_failed = yes; then
+        AC_MSG_RESULT([no])
+        _PKG_SHORT_ERRORS_SUPPORTED
+        if test $_pkg_short_errors_supported = yes; then
+	        $1[]_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "$2" 2>&1`
+        else
+	        $1[]_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "$2" 2>&1`
+        fi
+	# Put the nasty error message in config.log where it belongs
+	echo "$$1[]_PKG_ERRORS" >&AS_MESSAGE_LOG_FD
+
+	m4_default([$4], [AC_MSG_ERROR(
+[Package requirements ($2) were not met:
+
+$$1_PKG_ERRORS
+
+Consider adjusting the PKG_CONFIG_PATH environment variable if you
+installed software in a non-standard prefix.
+
+_PKG_TEXT])[]dnl
+        ])
+elif test $pkg_failed = untried; then
+        AC_MSG_RESULT([no])
+	m4_default([$4], [AC_MSG_FAILURE(
+[The pkg-config script could not be found or is too old.  Make sure it
+is in your PATH or set the PKG_CONFIG environment variable to the full
+path to pkg-config.
+
+_PKG_TEXT
+
+To get pkg-config, see <http://pkg-config.freedesktop.org/>.])[]dnl
+        ])
+else
+	$1[]_CFLAGS=$pkg_cv_[]$1[]_CFLAGS
+	$1[]_LIBS=$pkg_cv_[]$1[]_LIBS
+        AC_MSG_RESULT([yes])
+	$3
+fi[]dnl
+])dnl PKG_CHECK_MODULES
+
+
+dnl PKG_CHECK_MODULES_STATIC(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
+dnl   [ACTION-IF-NOT-FOUND])
+dnl ---------------------------------------------------------------------
+dnl Since: 0.29
+dnl
+dnl Checks for existence of MODULES and gathers its build flags with
+dnl static libraries enabled. Sets VARIABLE-PREFIX_CFLAGS from --cflags
+dnl and VARIABLE-PREFIX_LIBS from --libs.
+dnl
+dnl Note that if there is a possibility the first call to
+dnl PKG_CHECK_MODULES_STATIC might not happen, you should be sure to
+dnl include an explicit call to PKG_PROG_PKG_CONFIG in your
+dnl configure.ac.
+AC_DEFUN([PKG_CHECK_MODULES_STATIC],
+[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
+_save_PKG_CONFIG=$PKG_CONFIG
+PKG_CONFIG="$PKG_CONFIG --static"
+PKG_CHECK_MODULES($@)
+PKG_CONFIG=$_save_PKG_CONFIG[]dnl
+])dnl PKG_CHECK_MODULES_STATIC
+
+
+dnl PKG_INSTALLDIR([DIRECTORY])
+dnl -------------------------
+dnl Since: 0.27
+dnl
+dnl Substitutes the variable pkgconfigdir as the location where a module
+dnl should install pkg-config .pc files. By default the directory is
+dnl $libdir/pkgconfig, but the default can be changed by passing
+dnl DIRECTORY. The user can override through the --with-pkgconfigdir
+dnl parameter.
+AC_DEFUN([PKG_INSTALLDIR],
+[m4_pushdef([pkg_default], [m4_default([$1], ['${libdir}/pkgconfig'])])
+m4_pushdef([pkg_description],
+    [pkg-config installation directory @<:@]pkg_default[@:>@])
+AC_ARG_WITH([pkgconfigdir],
+    [AS_HELP_STRING([--with-pkgconfigdir], pkg_description)],,
+    [with_pkgconfigdir=]pkg_default)
+AC_SUBST([pkgconfigdir], [$with_pkgconfigdir])
+m4_popdef([pkg_default])
+m4_popdef([pkg_description])
+])dnl PKG_INSTALLDIR
+
+
+dnl PKG_NOARCH_INSTALLDIR([DIRECTORY])
+dnl --------------------------------
+dnl Since: 0.27
+dnl
+dnl Substitutes the variable noarch_pkgconfigdir as the location where a
+dnl module should install arch-independent pkg-config .pc files. By
+dnl default the directory is $datadir/pkgconfig, but the default can be
+dnl changed by passing DIRECTORY. The user can override through the
+dnl --with-noarch-pkgconfigdir parameter.
+AC_DEFUN([PKG_NOARCH_INSTALLDIR],
+[m4_pushdef([pkg_default], [m4_default([$1], ['${datadir}/pkgconfig'])])
+m4_pushdef([pkg_description],
+    [pkg-config arch-independent installation directory @<:@]pkg_default[@:>@])
+AC_ARG_WITH([noarch-pkgconfigdir],
+    [AS_HELP_STRING([--with-noarch-pkgconfigdir], pkg_description)],,
+    [with_noarch_pkgconfigdir=]pkg_default)
+AC_SUBST([noarch_pkgconfigdir], [$with_noarch_pkgconfigdir])
+m4_popdef([pkg_default])
+m4_popdef([pkg_description])
+])dnl PKG_NOARCH_INSTALLDIR
+
+
+dnl PKG_CHECK_VAR(VARIABLE, MODULE, CONFIG-VARIABLE,
+dnl [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
+dnl -------------------------------------------
+dnl Since: 0.28
+dnl
+dnl Retrieves the value of the pkg-config variable for the given module.
+AC_DEFUN([PKG_CHECK_VAR],
+[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
+AC_ARG_VAR([$1], [value of $3 for $2, overriding pkg-config])dnl
+
+_PKG_CONFIG([$1], [variable="][$3]["], [$2])
+AS_VAR_COPY([$1], [pkg_cv_][$1])
+
+AS_VAR_IF([$1], [""], [$5], [$4])dnl
+])dnl PKG_CHECK_VAR
diff --git a/Engine/lib/sdl/acinclude/pkg_config.m4 b/Engine/lib/sdl/acinclude/pkg_config.m4
deleted file mode 100644
index 596b10f58..000000000
--- a/Engine/lib/sdl/acinclude/pkg_config.m4
+++ /dev/null
@@ -1,133 +0,0 @@
-# PKG_PROG_PKG_CONFIG([MIN-VERSION])
-# ----------------------------------
-AC_DEFUN([PKG_PROG_PKG_CONFIG],
-[m4_pattern_forbid([^_?PKG_[A-Z_]+$])
-m4_pattern_allow([^PKG_CONFIG(_PATH)?$])
-AC_ARG_VAR([PKG_CONFIG], [path to pkg-config utility])
-AC_ARG_VAR([PKG_CONFIG_PATH], [directories to add to pkg-config's search path])
-AC_ARG_VAR([PKG_CONFIG_LIBDIR], [path overriding pkg-config's built-in search path])
-
-if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
-	AC_PATH_TOOL([PKG_CONFIG], [pkg-config])
-fi
-if test -n "$PKG_CONFIG"; then
-	_pkg_min_version=m4_default([$1], [0.9.0])
-	AC_MSG_CHECKING([pkg-config is at least version $_pkg_min_version])
-	if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
-		AC_MSG_RESULT([yes])
-	else
-		AC_MSG_RESULT([no])
-		PKG_CONFIG=""
-	fi
-fi[]dnl
-])# PKG_PROG_PKG_CONFIG
-
-# PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
-#
-# Check to see whether a particular set of modules exists.  Similar
-# to PKG_CHECK_MODULES(), but does not set variables or print errors.
-#
-# Please remember that m4 expands AC_REQUIRE([PKG_PROG_PKG_CONFIG])
-# only at the first occurence in configure.ac, so if the first place
-# it's called might be skipped (such as if it is within an "if", you
-# have to call PKG_CHECK_EXISTS manually
-# --------------------------------------------------------------
-AC_DEFUN([PKG_CHECK_EXISTS],
-[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
-if test -n "$PKG_CONFIG" && \
-    AC_RUN_LOG([$PKG_CONFIG --exists --print-errors "$1"]); then
-  m4_default([$2], [:])
-m4_ifvaln([$3], [else
-  $3])dnl
-fi])
-
-# _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
-# ---------------------------------------------
-m4_define([_PKG_CONFIG],
-[if test -n "$$1"; then
-    pkg_cv_[]$1="$$1"
- elif test -n "$PKG_CONFIG"; then
-    PKG_CHECK_EXISTS([$3],
-                     [pkg_cv_[]$1=`$PKG_CONFIG --[]$2 "$3" 2>/dev/null`],
-		     [pkg_failed=yes])
- else
-    pkg_failed=untried
-fi[]dnl
-])# _PKG_CONFIG
-
-# _PKG_SHORT_ERRORS_SUPPORTED
-# -----------------------------
-AC_DEFUN([_PKG_SHORT_ERRORS_SUPPORTED],
-[AC_REQUIRE([PKG_PROG_PKG_CONFIG])
-if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
-        _pkg_short_errors_supported=yes
-else
-        _pkg_short_errors_supported=no
-fi[]dnl
-])# _PKG_SHORT_ERRORS_SUPPORTED
-
-
-# PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
-# [ACTION-IF-NOT-FOUND])
-#
-#
-# Note that if there is a possibility the first call to
-# PKG_CHECK_MODULES might not happen, you should be sure to include an
-# explicit call to PKG_PROG_PKG_CONFIG in your configure.ac
-#
-#
-# --------------------------------------------------------------
-AC_DEFUN([PKG_CHECK_MODULES],
-[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
-AC_ARG_VAR([$1][_CFLAGS], [C compiler flags for $1, overriding pkg-config])dnl
-AC_ARG_VAR([$1][_LIBS], [linker flags for $1, overriding pkg-config])dnl
-
-pkg_failed=no
-AC_MSG_CHECKING([for $1])
-
-_PKG_CONFIG([$1][_CFLAGS], [cflags], [$2])
-_PKG_CONFIG([$1][_LIBS], [libs], [$2])
-
-m4_define([_PKG_TEXT], [Alternatively, you may set the environment variables $1[]_CFLAGS
-and $1[]_LIBS to avoid the need to call pkg-config.
-See the pkg-config man page for more details.])
-
-if test $pkg_failed = yes; then
-   	AC_MSG_RESULT([no])
-        _PKG_SHORT_ERRORS_SUPPORTED
-        if test $_pkg_short_errors_supported = yes; then
-	        $1[]_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "$2" 2>&1`
-        else 
-	        $1[]_PKG_ERRORS=`$PKG_CONFIG --print-errors "$2" 2>&1`
-        fi
-	# Put the nasty error message in config.log where it belongs
-	echo "$$1[]_PKG_ERRORS" >&AS_MESSAGE_LOG_FD
-
-	m4_default([$4], [AC_MSG_ERROR(
-[Package requirements ($2) were not met:
-
-$$1_PKG_ERRORS
-
-Consider adjusting the PKG_CONFIG_PATH environment variable if you
-installed software in a non-standard prefix.
-
-_PKG_TEXT])dnl
-        ])
-elif test $pkg_failed = untried; then
-     	AC_MSG_RESULT([no])
-	m4_default([$4], [AC_MSG_FAILURE(
-[The pkg-config script could not be found or is too old.  Make sure it
-is in your PATH or set the PKG_CONFIG environment variable to the full
-path to pkg-config.
-
-_PKG_TEXT
-
-To get pkg-config, see <http://pkg-config.freedesktop.org/>.])dnl
-        ])
-else
-	$1[]_CFLAGS=$pkg_cv_[]$1[]_CFLAGS
-	$1[]_LIBS=$pkg_cv_[]$1[]_LIBS
-        AC_MSG_RESULT([yes])
-	$3
-fi[]dnl
-])# PKG_CHECK_MODULES
diff --git a/Engine/lib/sdl/android-project/app/build.gradle b/Engine/lib/sdl/android-project/app/build.gradle
index bf3c35d6b..baa0edc8d 100644
--- a/Engine/lib/sdl/android-project/app/build.gradle
+++ b/Engine/lib/sdl/android-project/app/build.gradle
@@ -8,13 +8,13 @@ else {
 }
 
 android {
-    compileSdkVersion 26
+    compileSdkVersion 31
     defaultConfig {
         if (buildAsApplication) {
             applicationId "org.libsdl.app"
         }
         minSdkVersion 16
-        targetSdkVersion 26
+        targetSdkVersion 31
         versionCode 1
         versionName "1.0"
         externalNativeBuild {
@@ -35,6 +35,10 @@ android {
             proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
         }
     }
+    applicationVariants.all { variant ->
+        tasks["merge${variant.name.capitalize()}Assets"]
+            .dependsOn("externalNativeBuild${variant.name.capitalize()}")
+    }
     if (!project.hasProperty('EXCLUDE_NATIVE_LIBS')) {
         sourceSets.main {
             jniLibs.srcDir 'libs'
diff --git a/Engine/lib/sdl/android-project/app/jni/src/Android.mk b/Engine/lib/sdl/android-project/app/jni/src/Android.mk
index 1adcb6e9a..04e006ae9 100644
--- a/Engine/lib/sdl/android-project/app/jni/src/Android.mk
+++ b/Engine/lib/sdl/android-project/app/jni/src/Android.mk
@@ -13,6 +13,6 @@ LOCAL_SRC_FILES := YourSourceHere.c
 
 LOCAL_SHARED_LIBRARIES := SDL2
 
-LOCAL_LDLIBS := -lGLESv1_CM -lGLESv2 -llog
+LOCAL_LDLIBS := -lGLESv1_CM -lGLESv2 -lOpenSLES -llog -landroid
 
 include $(BUILD_SHARED_LIBRARY)
diff --git a/Engine/lib/sdl/android-project/app/src/main/AndroidManifest.xml b/Engine/lib/sdl/android-project/app/src/main/AndroidManifest.xml
index 36c5378b1..d997afe4a 100644
--- a/Engine/lib/sdl/android-project/app/src/main/AndroidManifest.xml
+++ b/Engine/lib/sdl/android-project/app/src/main/AndroidManifest.xml
@@ -38,10 +38,14 @@
         android:name="android.hardware.microphone"
         android:required="false" /> -->
 
-    <!-- Allow writing to external storage -->
-    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+    <!-- Allow downloading to the external storage on Android 5.1 and older -->
+    <!-- <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" android:maxSdkVersion="22" /> -->
+
     <!-- Allow access to Bluetooth devices -->
-    <uses-permission android:name="android.permission.BLUETOOTH" />
+    <!-- Currently this is just for Steam Controller support and requires setting SDL_HINT_JOYSTICK_HIDAPI_STEAM -->
+    <!-- <uses-permission android:name="android.permission.BLUETOOTH" android:maxSdkVersion="30" /> -->
+    <!-- <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" /> -->
+
     <!-- Allow access to the vibrator -->
     <uses-permission android:name="android.permission.VIBRATE" />
 
@@ -71,11 +75,17 @@
             android:alwaysRetainTaskState="true"
             android:launchMode="singleInstance"
             android:configChanges="layoutDirection|locale|orientation|uiMode|screenLayout|screenSize|smallestScreenSize|keyboard|keyboardHidden|navigation"
+            android:preferMinimalPostProcessing="true"
+            android:exported="true"
             >
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
+            <!-- Let Android know that we can handle some USB devices and should receive this event -->
+            <intent-filter>
+                <action android:name="android.hardware.usb.action.USB_DEVICE_ATTACHED" />
+            </intent-filter>
             <!-- Drop file event -->
             <!--
             <intent-filter>
diff --git a/Engine/lib/sdl/android-project/app/src/main/java/org/libsdl/app/HIDDeviceBLESteamController.java b/Engine/lib/sdl/android-project/app/src/main/java/org/libsdl/app/HIDDeviceBLESteamController.java
index 94a28189b..65c5a4237 100644
--- a/Engine/lib/sdl/android-project/app/src/main/java/org/libsdl/app/HIDDeviceBLESteamController.java
+++ b/Engine/lib/sdl/android-project/app/src/main/java/org/libsdl/app/HIDDeviceBLESteamController.java
@@ -564,10 +564,10 @@ class HIDDeviceBLESteamController extends BluetoothGattCallback implements HIDDe
         return "Steam Controller";
     }
 
-	@Override
+    @Override
     public UsbDevice getDevice() {
-		return null;
-	}
+        return null;
+    }
 
     @Override
     public boolean open() {
diff --git a/Engine/lib/sdl/android-project/app/src/main/java/org/libsdl/app/HIDDeviceManager.java b/Engine/lib/sdl/android-project/app/src/main/java/org/libsdl/app/HIDDeviceManager.java
index 5899817f6..802c7254e 100644
--- a/Engine/lib/sdl/android-project/app/src/main/java/org/libsdl/app/HIDDeviceManager.java
+++ b/Engine/lib/sdl/android-project/app/src/main/java/org/libsdl/app/HIDDeviceManager.java
@@ -7,6 +7,7 @@ import android.bluetooth.BluetoothAdapter;
 import android.bluetooth.BluetoothDevice;
 import android.bluetooth.BluetoothManager;
 import android.bluetooth.BluetoothProfile;
+import android.os.Build;
 import android.util.Log;
 import android.content.BroadcastReceiver;
 import android.content.Context;
@@ -104,36 +105,6 @@ public class HIDDeviceManager {
     private HIDDeviceManager(final Context context) {
         mContext = context;
 
-        // Make sure we have the HIDAPI library loaded with the native functions
-        try {
-            SDL.loadLibrary("hidapi");
-        } catch (Throwable e) {
-            Log.w(TAG, "Couldn't load hidapi: " + e.toString());
-
-            AlertDialog.Builder builder = new AlertDialog.Builder(context);
-            builder.setCancelable(false);
-            builder.setTitle("SDL HIDAPI Error");
-            builder.setMessage("Please report the following error to the SDL maintainers: " + e.getMessage());
-            builder.setNegativeButton("Quit", new DialogInterface.OnClickListener() {
-                @Override
-                public void onClick(DialogInterface dialog, int which) {
-                    try {
-                        // If our context is an activity, exit rather than crashing when we can't
-                        // call our native functions.
-                        Activity activity = (Activity)context;
-        
-                        activity.finish();
-                    }
-                    catch (ClassCastException cce) {
-                        // Context wasn't an activity, there's nothing we can do.  Give up and return.
-                    }
-                }
-            });
-            builder.show();
-
-            return;
-        }
-        
         HIDDeviceRegisterCallback();
 
         mSharedPreferences = mContext.getSharedPreferences("hidapi", Context.MODE_PRIVATE);
@@ -148,9 +119,6 @@ public class HIDDeviceManager {
         {
             mNextDeviceId = mSharedPreferences.getInt("next_device_id", 0);
         }
-
-        initializeUSB();
-        initializeBluetooth();
     }
 
     public Context getContext() {
@@ -173,6 +141,9 @@ public class HIDDeviceManager {
 
     private void initializeUSB() {
         mUsbManager = (UsbManager)mContext.getSystemService(Context.USB_SERVICE);
+        if (mUsbManager == null) {
+            return;
+        }
 
         /*
         // Logging
@@ -275,6 +246,7 @@ public class HIDDeviceManager {
             0x15e4, // Numark
             0x162e, // Joytech
             0x1689, // Razer Onza
+            0x1949, // Lab126, Inc.
             0x1bad, // Harmonix
             0x24c6, // PowerA
         };
@@ -377,11 +349,17 @@ public class HIDDeviceManager {
     private void initializeBluetooth() {
         Log.d(TAG, "Initializing Bluetooth");
 
-        if (mContext.getPackageManager().checkPermission(android.Manifest.permission.BLUETOOTH, mContext.getPackageName()) != PackageManager.PERMISSION_GRANTED) {
+        if (Build.VERSION.SDK_INT <= 30 &&
+            mContext.getPackageManager().checkPermission(android.Manifest.permission.BLUETOOTH, mContext.getPackageName()) != PackageManager.PERMISSION_GRANTED) {
             Log.d(TAG, "Couldn't initialize Bluetooth, missing android.permission.BLUETOOTH");
             return;
         }
 
+        if (!mContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE) || (Build.VERSION.SDK_INT < 18)) {
+            Log.d(TAG, "Couldn't initialize Bluetooth, this version of Android does not support Bluetooth LE");
+            return;
+        }
+
         // Find bonded bluetooth controllers and create SteamControllers for them
         mBluetoothManager = (BluetoothManager)mContext.getSystemService(Context.BLUETOOTH_SERVICE);
         if (mBluetoothManager == null) {
@@ -564,6 +542,18 @@ public class HIDDeviceManager {
     ////////// JNI interface functions
     //////////////////////////////////////////////////////////////////////////////////////////////////////
 
+    public boolean initialize(boolean usb, boolean bluetooth) {
+        Log.v(TAG, "initialize(" + usb + ", " + bluetooth + ")");
+
+        if (usb) {
+            initializeUSB();
+        }
+        if (bluetooth) {
+            initializeBluetooth();
+        }
+        return true;
+    }
+
     public boolean openDevice(int deviceID) {
         Log.v(TAG, "openDevice deviceID=" + deviceID);
         HIDDevice device = getDevice(deviceID);
@@ -577,7 +567,14 @@ public class HIDDeviceManager {
         if (usbDevice != null && !mUsbManager.hasPermission(usbDevice)) {
             HIDDeviceOpenPending(deviceID);
             try {
-                mUsbManager.requestPermission(usbDevice, PendingIntent.getBroadcast(mContext, 0, new Intent(HIDDeviceManager.ACTION_USB_PERMISSION), 0));
+                final int FLAG_MUTABLE = 0x02000000; // PendingIntent.FLAG_MUTABLE, but don't require SDK 31
+                int flags;
+                if (Build.VERSION.SDK_INT >= 31) {
+                    flags = FLAG_MUTABLE;
+                } else {
+                    flags = 0;
+                }
+                mUsbManager.requestPermission(usbDevice, PendingIntent.getBroadcast(mContext, 0, new Intent(HIDDeviceManager.ACTION_USB_PERMISSION), flags));
             } catch (Exception e) {
                 Log.v(TAG, "Couldn't request permission for USB device " + usbDevice);
                 HIDDeviceOpenResult(deviceID, false);
diff --git a/Engine/lib/sdl/android-project/app/src/main/java/org/libsdl/app/SDLActivity.java b/Engine/lib/sdl/android-project/app/src/main/java/org/libsdl/app/SDLActivity.java
index e7e5a2ac7..28f3c6776 100644
--- a/Engine/lib/sdl/android-project/app/src/main/java/org/libsdl/app/SDLActivity.java
+++ b/Engine/lib/sdl/android-project/app/src/main/java/org/libsdl/app/SDLActivity.java
@@ -52,6 +52,7 @@ import android.widget.Button;
 import android.widget.LinearLayout;
 import android.widget.RelativeLayout;
 import android.widget.TextView;
+import android.widget.Toast;
 
 import java.util.Hashtable;
 import java.util.Locale;
@@ -62,6 +63,106 @@ import java.util.Locale;
 */
 public class SDLActivity extends Activity implements View.OnSystemUiVisibilityChangeListener {
     private static final String TAG = "SDL";
+/*
+    // Display InputType.SOURCE/CLASS of events and devices
+    //
+    // SDLActivity.debugSource(device.getSources(), "device[" + device.getName() + "]");
+    // SDLActivity.debugSource(event.getSource(), "event");
+    public static void debugSource(int sources, String prefix) {
+        int s = sources;
+        int s_copy = sources;
+        String cls = "";
+        String src = "";
+        int tst = 0;
+        int FLAG_TAINTED = 0x80000000;
+
+        if ((s & InputDevice.SOURCE_CLASS_BUTTON) != 0)     cls += " BUTTON";
+        if ((s & InputDevice.SOURCE_CLASS_JOYSTICK) != 0)   cls += " JOYSTICK";
+        if ((s & InputDevice.SOURCE_CLASS_POINTER) != 0)    cls += " POINTER";
+        if ((s & InputDevice.SOURCE_CLASS_POSITION) != 0)   cls += " POSITION";
+        if ((s & InputDevice.SOURCE_CLASS_TRACKBALL) != 0)  cls += " TRACKBALL";
+
+
+        int s2 = s_copy & ~InputDevice.SOURCE_ANY; // keep class bits
+        s2 &= ~(  InputDevice.SOURCE_CLASS_BUTTON 
+                | InputDevice.SOURCE_CLASS_JOYSTICK
+                | InputDevice.SOURCE_CLASS_POINTER
+                | InputDevice.SOURCE_CLASS_POSITION
+                | InputDevice.SOURCE_CLASS_TRACKBALL);
+
+        if (s2 != 0) cls += "Some_Unkown";
+
+        s2 = s_copy & InputDevice.SOURCE_ANY; // keep source only, no class;
+
+        tst = InputDevice.SOURCE_BLUETOOTH_STYLUS;
+        if ((s & tst) == tst) src += " BLUETOOTH_STYLUS";
+        s2 &= ~tst;
+
+        tst = InputDevice.SOURCE_DPAD;
+        if ((s & tst) == tst) src += " DPAD";
+        s2 &= ~tst;
+
+        tst = InputDevice.SOURCE_GAMEPAD;
+        if ((s & tst) == tst) src += " GAMEPAD";
+        s2 &= ~tst;
+
+        tst = InputDevice.SOURCE_HDMI;
+        if ((s & tst) == tst) src += " HDMI";
+        s2 &= ~tst;
+
+        tst = InputDevice.SOURCE_JOYSTICK;
+        if ((s & tst) == tst) src += " JOYSTICK";
+        s2 &= ~tst;
+
+        tst = InputDevice.SOURCE_KEYBOARD;
+        if ((s & tst) == tst) src += " KEYBOARD";
+        s2 &= ~tst;
+
+        tst = InputDevice.SOURCE_MOUSE;
+        if ((s & tst) == tst) src += " MOUSE";
+        s2 &= ~tst;
+
+        if (Build.VERSION.SDK_INT >= 26) {
+            tst = InputDevice.SOURCE_MOUSE_RELATIVE;
+            if ((s & tst) == tst) src += " MOUSE_RELATIVE";
+            s2 &= ~tst;
+
+            tst = InputDevice.SOURCE_ROTARY_ENCODER;
+            if ((s & tst) == tst) src += " ROTARY_ENCODER";
+            s2 &= ~tst;
+        }
+        tst = InputDevice.SOURCE_STYLUS;
+        if ((s & tst) == tst) src += " STYLUS";
+        s2 &= ~tst;
+
+        tst = InputDevice.SOURCE_TOUCHPAD;
+        if ((s & tst) == tst) src += " TOUCHPAD";
+        s2 &= ~tst;
+
+        tst = InputDevice.SOURCE_TOUCHSCREEN;
+        if ((s & tst) == tst) src += " TOUCHSCREEN";
+        s2 &= ~tst;
+
+        tst = InputDevice.SOURCE_TOUCH_NAVIGATION;
+        if ((s & tst) == tst) src += " TOUCH_NAVIGATION";
+        s2 &= ~tst;
+
+        tst = InputDevice.SOURCE_TRACKBALL;
+        if ((s & tst) == tst) src += " TRACKBALL";
+        s2 &= ~tst;
+
+        tst = InputDevice.SOURCE_ANY;
+        if ((s & tst) == tst) src += " ANY";
+        s2 &= ~tst;
+
+        if (s == FLAG_TAINTED) src += " FLAG_TAINTED";
+        s2 &= ~FLAG_TAINTED;
+
+        if (s2 != 0) src += " Some_Unkown";
+
+        Log.v(TAG, prefix + "int=" + s_copy + " CLASS={" + cls + " } source(s):" + src);
+    }
+*/
 
     public static boolean mIsResumedCalled, mHasFocus;
     public static final boolean mHasMultiWindow = (Build.VERSION.SDK_INT >= 24);
@@ -163,7 +264,6 @@ public class SDLActivity extends Activity implements View.OnSystemUiVisibilityCh
      */
     protected String[] getLibraries() {
         return new String[] {
-            "hidapi",
             "SDL2",
             // "SDL2_image",
             // "SDL2_mixer",
@@ -378,11 +478,14 @@ public class SDLActivity extends Activity implements View.OnSystemUiVisibilityCh
     }
 
     public static int getCurrentOrientation() {
-        final Context context = SDLActivity.getContext();
-        final Display display = ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
-
         int result = SDL_ORIENTATION_UNKNOWN;
 
+        Activity activity = (Activity)getContext();
+        if (activity == null) {
+            return result;
+        }
+        Display display = activity.getWindowManager().getDefaultDisplay();
+
         switch (display.getRotation()) {
             case Surface.ROTATION_0:
                 result = SDL_ORIENTATION_PORTRAIT;
@@ -496,8 +599,8 @@ public class SDLActivity extends Activity implements View.OnSystemUiVisibilityCh
         // If we do, the normal hardware back button will no longer work and people have to use home,
         // but the mouse right click will work.
         //
-        String trapBack = SDLActivity.nativeGetHint("SDL_ANDROID_TRAP_BACK_BUTTON");
-        if ((trapBack != null) && trapBack.equals("1")) {
+        boolean trapBack = SDLActivity.nativeGetHintBoolean("SDL_ANDROID_TRAP_BACK_BUTTON", false);
+        if (trapBack) {
             // Exit and let the mouse handler handle this button (if appropriate)
             return;
         }
@@ -604,7 +707,6 @@ public class SDLActivity extends Activity implements View.OnSystemUiVisibilityCh
     static final int COMMAND_CHANGE_TITLE = 1;
     static final int COMMAND_CHANGE_WINDOW_STYLE = 2;
     static final int COMMAND_TEXTEDIT_HIDE = 3;
-    static final int COMMAND_CHANGE_SURFACEVIEW_FORMAT = 4;
     static final int COMMAND_SET_KEEP_SCREEN_ON = 5;
 
     protected static final int COMMAND_USER = 0x8000;
@@ -702,32 +804,6 @@ public class SDLActivity extends Activity implements View.OnSystemUiVisibilityCh
                 }
                 break;
             }
-            case COMMAND_CHANGE_SURFACEVIEW_FORMAT:
-            {
-                int format = (Integer) msg.obj;
-                int pf;
-
-                if (SDLActivity.mSurface == null) {
-                    return;
-                }
-
-                SurfaceHolder holder = SDLActivity.mSurface.getHolder();
-                if (holder == null) {
-                    return;
-                }
-
-                if (format == 1) {
-                    pf = PixelFormat.RGBA_8888;
-                } else if (format == 2) {
-                    pf = PixelFormat.RGBX_8888;
-                } else {
-                    pf = PixelFormat.RGB_565;
-                }
-
-                holder.setFormat(pf);
-
-                break;
-            }
             default:
                 if ((context instanceof SDLActivity) && !((SDLActivity) context).onUnhandledMessage(msg.arg1, msg.obj)) {
                     Log.e(TAG, "error handling message, command is " + msg.arg1);
@@ -811,7 +887,7 @@ public class SDLActivity extends Activity implements View.OnSystemUiVisibilityCh
     public static native void nativeResume();
     public static native void nativeFocusChanged(boolean hasFocus);
     public static native void onNativeDropFile(String filename);
-    public static native void nativeSetScreenResolution(int surfaceWidth, int surfaceHeight, int deviceWidth, int deviceHeight, int format, float rate);
+    public static native void nativeSetScreenResolution(int surfaceWidth, int surfaceHeight, int deviceWidth, int deviceHeight, float rate);
     public static native void onNativeResize();
     public static native void onNativeKeyDown(int keycode);
     public static native void onNativeKeyUp(int keycode);
@@ -827,6 +903,7 @@ public class SDLActivity extends Activity implements View.OnSystemUiVisibilityCh
     public static native void onNativeSurfaceChanged();
     public static native void onNativeSurfaceDestroyed();
     public static native String nativeGetHint(String name);
+    public static native boolean nativeGetHintBoolean(String name, boolean default_value);
     public static native void nativeSetenv(String name, String value);
     public static native void onNativeOrientationChanged(int orientation);
     public static native void nativeAddTouch(int touchId, String name);
@@ -986,11 +1063,6 @@ public class SDLActivity extends Activity implements View.OnSystemUiVisibilityCh
      */
     public static boolean supportsRelativeMouse()
     {
-        // ChromeOS doesn't provide relative mouse motion via the Android 7 APIs
-        if (isChromebook()) {
-            return false;
-        }
-
         // DeX mode in Samsung Experience 9.0 and earlier doesn't support relative mice properly under
         // Android 7 APIs, and simply returns no data under Android 8 APIs.
         //
@@ -1222,13 +1294,6 @@ public class SDLActivity extends Activity implements View.OnSystemUiVisibilityCh
         return SDLActivity.mSurface.getNativeSurface();
     }
 
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static void setSurfaceViewFormat(int format) {
-        mSingleton.sendCommand(COMMAND_CHANGE_SURFACEVIEW_FORMAT, format);
-    }
-
     // Input
 
     /**
@@ -1239,8 +1304,21 @@ public class SDLActivity extends Activity implements View.OnSystemUiVisibilityCh
 
         for (int id : ids) {
             InputDevice device = InputDevice.getDevice(id);
-            if (device != null && (device.getSources() & InputDevice.SOURCE_TOUCHSCREEN) != 0) {
-                nativeAddTouch(device.getId(), device.getName());
+            /* Allow SOURCE_TOUCHSCREEN and also Virtual InputDevices because they can send TOUCHSCREEN events */
+            if (device != null && ((device.getSources() & InputDevice.SOURCE_TOUCHSCREEN) == InputDevice.SOURCE_TOUCHSCREEN
+                    || device.isVirtual())) {
+
+                int touchDevId = device.getId();
+                /*
+                 * Prevent id to be -1, since it's used in SDL internal for synthetic events
+                 * Appears when using Android emulator, eg:
+                 *  adb shell input mouse tap 100 100
+                 *  adb shell input touchscreen tap 100 100
+                 */
+                if (touchDevId < 0) {
+                    touchDevId -= 1;
+                }
+                nativeAddTouch(touchDevId, device.getName());
             }
         }
     }
@@ -1514,6 +1592,19 @@ public class SDLActivity extends Activity implements View.OnSystemUiVisibilityCh
         return mLastCursorID;
     }
 
+    /**
+     * This method is called by SDL using JNI.
+     */
+    public static void destroyCustomCursor(int cursorID) {
+        if (Build.VERSION.SDK_INT >= 24) {
+            try {
+                mCursors.remove(cursorID);
+            } catch (Exception e) {
+            }
+        }
+        return;
+    }
+
     /**
      * This method is called by SDL using JNI.
      */
@@ -1630,6 +1721,52 @@ public class SDLActivity extends Activity implements View.OnSystemUiVisibilityCh
         }
         return 0;
     }
+
+    /**
+     * This method is called by SDL using JNI.
+     */
+    public static int showToast(String message, int duration, int gravity, int xOffset, int yOffset)
+    {
+        if(null == mSingleton) {
+            return - 1;
+        }
+
+        try
+        {
+            class OneShotTask implements Runnable {
+                String mMessage;
+                int mDuration;
+                int mGravity;
+                int mXOffset;
+                int mYOffset;
+
+                OneShotTask(String message, int duration, int gravity, int xOffset, int yOffset) {
+                    mMessage  = message;
+                    mDuration = duration;
+                    mGravity  = gravity;
+                    mXOffset  = xOffset;
+                    mYOffset  = yOffset;
+                }
+
+                public void run() {
+                    try
+                    {
+                        Toast toast = Toast.makeText(mSingleton, mMessage, mDuration);
+                        if (mGravity >= 0) {
+                            toast.setGravity(mGravity, mXOffset, mYOffset);
+                        }
+                        toast.show();
+                    } catch(Exception ex) {
+                        Log.e(TAG, ex.getMessage());
+                    }
+                }
+            }
+            mSingleton.runOnUiThread(new OneShotTask(message, duration, gravity, xOffset, yOffset));
+        } catch(Exception ex) {
+            return -1;
+        }
+        return 0;
+    }
 }
 
 /**
@@ -1754,30 +1891,6 @@ class SDLSurface extends SurfaceView implements SurfaceHolder.Callback,
             return;
         }
 
-        int sdlFormat = 0x15151002; // SDL_PIXELFORMAT_RGB565 by default
-        switch (format) {
-        case PixelFormat.RGBA_8888:
-            Log.v("SDL", "pixel format RGBA_8888");
-            sdlFormat = 0x16462004; // SDL_PIXELFORMAT_RGBA8888
-            break;
-        case PixelFormat.RGBX_8888:
-            Log.v("SDL", "pixel format RGBX_8888");
-            sdlFormat = 0x16261804; // SDL_PIXELFORMAT_RGBX8888
-            break;
-        case PixelFormat.RGB_565:
-            Log.v("SDL", "pixel format RGB_565");
-            sdlFormat = 0x15151002; // SDL_PIXELFORMAT_RGB565
-            break;
-        case PixelFormat.RGB_888:
-            Log.v("SDL", "pixel format RGB_888");
-            // Not sure this is right, maybe SDL_PIXELFORMAT_RGB24 instead?
-            sdlFormat = 0x16161804; // SDL_PIXELFORMAT_RGB888
-            break;
-        default:
-            Log.v("SDL", "pixel format unknown " + format);
-            break;
-        }
-
         mWidth = width;
         mHeight = height;
         int nDeviceWidth = width;
@@ -1800,7 +1913,7 @@ class SDLSurface extends SurfaceView implements SurfaceHolder.Callback,
 
         Log.v("SDL", "Window size: " + width + "x" + height);
         Log.v("SDL", "Device size: " + nDeviceWidth + "x" + nDeviceHeight);
-        SDLActivity.nativeSetScreenResolution(width, height, nDeviceWidth, nDeviceHeight, sdlFormat, mDisplay.getRefreshRate());
+        SDLActivity.nativeSetScreenResolution(width, height, nDeviceWidth, nDeviceHeight, mDisplay.getRefreshRate());
         SDLActivity.onNativeResize();
 
         // Prevent a screen distortion glitch,
@@ -1895,7 +2008,7 @@ class SDLSurface extends SurfaceView implements SurfaceHolder.Callback,
             }
         }
 
-        if ((source & InputDevice.SOURCE_KEYBOARD) != 0) {
+        if ((source & InputDevice.SOURCE_KEYBOARD) == InputDevice.SOURCE_KEYBOARD) {
             if (event.getAction() == KeyEvent.ACTION_DOWN) {
                 if (SDLActivity.isTextInputEvent(event)) {
                     SDLInputConnection.nativeCommitText(String.valueOf((char) event.getUnicodeChar()), 1);
@@ -1908,7 +2021,7 @@ class SDLSurface extends SurfaceView implements SurfaceHolder.Callback,
             }
         }
 
-        if ((source & InputDevice.SOURCE_MOUSE) != 0) {
+        if ((source & InputDevice.SOURCE_MOUSE) == InputDevice.SOURCE_MOUSE) {
             // on some devices key events are sent for mouse BUTTON_BACK/FORWARD presses
             // they are ignored here because sending them as mouse input to SDL is messy
             if ((keyCode == KeyEvent.KEYCODE_BACK) || (keyCode == KeyEvent.KEYCODE_FORWARD)) {
diff --git a/Engine/lib/sdl/android-project/app/src/main/java/org/libsdl/app/SDLAudioManager.java b/Engine/lib/sdl/android-project/app/src/main/java/org/libsdl/app/SDLAudioManager.java
index 09e44285b..2bfc71860 100644
--- a/Engine/lib/sdl/android-project/app/src/main/java/org/libsdl/app/SDLAudioManager.java
+++ b/Engine/lib/sdl/android-project/app/src/main/java/org/libsdl/app/SDLAudioManager.java
@@ -47,6 +47,10 @@ public class SDLAudioManager
             if (desiredChannels > 2) {
                 desiredChannels = 2;
             }
+        }
+
+        /* AudioTrack has sample rate limitation of 48000 (fixed in 5.0.2) */
+        if (Build.VERSION.SDK_INT < 22) {
             if (sampleRate < 8000) {
                 sampleRate = 8000;
             } else if (sampleRate > 48000) {
diff --git a/Engine/lib/sdl/android-project/app/src/main/java/org/libsdl/app/SDLControllerManager.java b/Engine/lib/sdl/android-project/app/src/main/java/org/libsdl/app/SDLControllerManager.java
index 05e0f0cac..82373d9d6 100644
--- a/Engine/lib/sdl/android-project/app/src/main/java/org/libsdl/app/SDLControllerManager.java
+++ b/Engine/lib/sdl/android-project/app/src/main/java/org/libsdl/app/SDLControllerManager.java
@@ -255,23 +255,21 @@ class SDLJoystickHandler_API16 extends SDLJoystickHandler {
 
     @Override
     public boolean handleMotionEvent(MotionEvent event) {
-        if ((event.getSource() & InputDevice.SOURCE_JOYSTICK) != 0) {
-            int actionPointerIndex = event.getActionIndex();
-            int action = event.getActionMasked();
-            if (action == MotionEvent.ACTION_MOVE) {
-                SDLJoystick joystick = getJoystick(event.getDeviceId());
-                if (joystick != null) {
-                    for (int i = 0; i < joystick.axes.size(); i++) {
-                        InputDevice.MotionRange range = joystick.axes.get(i);
-                        /* Normalize the value to -1...1 */
-                        float value = (event.getAxisValue(range.getAxis(), actionPointerIndex) - range.getMin()) / range.getRange() * 2.0f - 1.0f;
-                        SDLControllerManager.onNativeJoy(joystick.device_id, i, value);
-                    }
-                    for (int i = 0; i < joystick.hats.size() / 2; i++) {
-                        int hatX = Math.round(event.getAxisValue(joystick.hats.get(2 * i).getAxis(), actionPointerIndex));
-                        int hatY = Math.round(event.getAxisValue(joystick.hats.get(2 * i + 1).getAxis(), actionPointerIndex));
-                        SDLControllerManager.onNativeHat(joystick.device_id, i, hatX, hatY);
-                    }
+        int actionPointerIndex = event.getActionIndex();
+        int action = event.getActionMasked();
+        if (action == MotionEvent.ACTION_MOVE) {
+            SDLJoystick joystick = getJoystick(event.getDeviceId());
+            if (joystick != null) {
+                for (int i = 0; i < joystick.axes.size(); i++) {
+                    InputDevice.MotionRange range = joystick.axes.get(i);
+                    /* Normalize the value to -1...1 */
+                    float value = (event.getAxisValue(range.getAxis(), actionPointerIndex) - range.getMin()) / range.getRange() * 2.0f - 1.0f;
+                    SDLControllerManager.onNativeJoy(joystick.device_id, i, value);
+                }
+                for (int i = 0; i < joystick.hats.size() / 2; i++) {
+                    int hatX = Math.round(event.getAxisValue(joystick.hats.get(2 * i).getAxis(), actionPointerIndex));
+                    int hatY = Math.round(event.getAxisValue(joystick.hats.get(2 * i + 1).getAxis(), actionPointerIndex));
+                    SDLControllerManager.onNativeHat(joystick.device_id, i, hatX, hatY);
                 }
             }
         }
@@ -319,6 +317,7 @@ class SDLJoystickHandler_API19 extends SDLJoystickHandler_API16 {
             KeyEvent.KEYCODE_BUTTON_X,
             KeyEvent.KEYCODE_BUTTON_Y,
             KeyEvent.KEYCODE_BACK,
+            KeyEvent.KEYCODE_MENU,
             KeyEvent.KEYCODE_BUTTON_MODE,
             KeyEvent.KEYCODE_BUTTON_START,
             KeyEvent.KEYCODE_BUTTON_THUMBL,
@@ -360,6 +359,7 @@ class SDLJoystickHandler_API19 extends SDLJoystickHandler_API16 {
             (1 << 2),   // X -> X
             (1 << 3),   // Y -> Y
             (1 << 4),   // BACK -> BACK
+            (1 << 6),   // MENU -> START
             (1 << 5),   // MODE -> GUIDE
             (1 << 6),   // START -> START
             (1 << 7),   // THUMBL -> LEFTSTICK
@@ -560,8 +560,6 @@ class SDLGenericMotionListener_API12 implements View.OnGenericMotionListener {
 
         switch ( event.getSource() ) {
             case InputDevice.SOURCE_JOYSTICK:
-            case InputDevice.SOURCE_GAMEPAD:
-            case InputDevice.SOURCE_DPAD:
                 return SDLControllerManager.handleJoystickMotionEvent(event);
 
             case InputDevice.SOURCE_MOUSE:
@@ -691,8 +689,6 @@ class SDLGenericMotionListener_API26 extends SDLGenericMotionListener_API24 {
 
         switch ( event.getSource() ) {
             case InputDevice.SOURCE_JOYSTICK:
-            case InputDevice.SOURCE_GAMEPAD:
-            case InputDevice.SOURCE_DPAD:
                 return SDLControllerManager.handleJoystickMotionEvent(event);
 
             case InputDevice.SOURCE_MOUSE:
diff --git a/Engine/lib/sdl/android-project/build.gradle b/Engine/lib/sdl/android-project/build.gradle
index f6f90b25b..6f629c8aa 100644
--- a/Engine/lib/sdl/android-project/build.gradle
+++ b/Engine/lib/sdl/android-project/build.gradle
@@ -2,11 +2,11 @@
 
 buildscript {
     repositories {
-        jcenter()
+        mavenCentral()
         google()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:3.2.0'
+        classpath 'com.android.tools.build:gradle:7.0.3'
 
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files
@@ -15,7 +15,7 @@ buildscript {
 
 allprojects {
     repositories {
-        jcenter()
+        mavenCentral()
         google()
     }
 }
diff --git a/Engine/lib/sdl/android-project/gradle/wrapper/gradle-wrapper.jar b/Engine/lib/sdl/android-project/gradle/wrapper/gradle-wrapper.jar
index 13372aef5e24af05341d49695ee84e5f9b594659..2b338a935b508eb6286ed4b84a91176ee5fb93c5 100644
GIT binary patch
delta 24989
zcmZ6yW02<1xAxtfwr$%srfu7{?R(m`ZQFL=-P4}7ZEM<k=A8Fbo%4TFS*hAdR=y;)
z_jUc&N=Pv{upAswNfsOe9Rvg#8pOIvLM9QB2<?AIqr`=hLLeX@YKg)syce0bE_W`V
zApe`7`!C_&RS>ZMI{e!p{)MB9B@_7n@1Ddd64?Lmq5qYU_)LTKzoYf9aL_Sm5Reo!
z5D@C*L<r1e1w^RiTp%JKRWs5TZ3X4KHj&<28~!(T14|?bxJVL<XGan`p6ceC5(A#i
z!l<^at#4!vMm5GRyS0c<$(jCo3rVk{&sdAmTnCImq5RFe;CDhmu6K8hhDqVyhm+^+
zp3LX$gXt;V-urwk!ygR<--vsS$b?7-)2!#WV$g~c(EB;?Fp7788C?-CTWm+Ty(`wd
zQ9d*FT^yWfXT}iE39Tqs1oBr#!tLo{-<MrqZ!aR(9imYvFTq(pqQj-|A+NL(q=(x?
z=DdSfu;%=eCCT9z>{+6dJv3v#q!Y!v+cRWAv{B2oU$c!bC+3$USgRw^J#VD-edwd<
zYajIu1Dc{QxU+@;%O^IH9%56Z;|zc4QLbD0AHDPku*c>p&Kxn0(pEg1*@T4WSGYLW
z1o+rQIOlkZ2nc09VPTRKVs8pn<x4X;S^4L3x@CF!yu`-R?TJh}Hru>q$1+(V%e24h
zM9&D3L^#;otzIg^JG-JX1%0gi#;yep&JqJ)sz-fP56<=ggN1oIVo2pb6c{rkezGy>
z)5&OAXB#yA)w7(~qI$riQ<40OzqVr~doDq>K(3t6a-aN`62jmg#<Rp@UbU99>^-Um
z=T`U7A>av@nN+FMl~^t+pByIbqhNz`(cmy|mC=mq0jwIl30Za3m`pjv4utHArPpq2
zQJl2}FU^DjOyg@%tu9ODCn~#+si|77ubK4|^rEXa4TH)paq9q-W-pe(Q8`z%j)<xl
z#>l1IYSxk=1T5Kf2Jg6y<S)=qpSoSG%?B4@t11bWqf?~ND1P9uxWi1E=-NSgPoLxC
zoFBna<5IAxc4om!dLU4T-I5*^RaR<)TE}GY@FuVU7VRdIe;5lWMpjp{)e#-KIrb?v
zU0#8c&?^;`vrpP$Ym4)#YtoaTyaVn@N?>-zBhebs+S3w=RG8A$8BZoJSmC2DRpCBq
zeM_>^ETZsWD~{1$*A9z=WB%An!PtAMP#Xh7kiP6;2UgI#aCI*$SVRSx%5Hg9gw-2p
zJgS`mx*wP7IqNwDN;u~Avz^`I6E?{<G@i|pSKV|aEQS>gmASOa(w3F@qvQ~Z8wt}X
zvtibc7eLZ+^_<iNQtzuIU1e2hT^z%qw{Lyc!=QEviV>Sb`=()%c8#vAAof1_s?Vq_
zZ>Brunq70f;x9dCuZooRzc|yi%rMepWmb>?eqQNOF)l}Xhd2ua(uXjNr5TkoyV9&m
zBLoE}QP@2`*uLnS#-SV4jn2t)<y+hyjX{(iok8Wlv|bt01i*|SqTTQkstcMW#?}g&
zjyOD6SmN)1k*q3ml`4+f-7)$*ShnomslP2UjtX7u#k*9T64HZ;+H&4%OeJTe?7G8%
z*^KuG+AxF<IE#-Y9C<<iq@Y#%6c=q2Y6pcmHbEASSR9mvTKq~w8f;5L!1O@>pd-dd
zoMt~1#m>B)`ukMlU^)8K{^GQsvrnnfAJemG62%Qu0f5r2<OfZN5ZwzLl{ls;$%p#j
z&h0buSK)5{OL~YXxP%(H-`^Mqc}XI`oW<276J|?{V5RL^Mc%XfnMIb8LCqa*THdto
zxwfKT)@B|5>Dt!ryO?^a07t(#3*m)07$zi-Mrv3awe+82?qZ!U|A7sjtDZ+kn&|-j
zm_;UrWkJG8)1@0sS&k)smK=4pe=ky9UR-ET2YRMo*ZgX0iKEFO53SluH%$&uKKeJP
zR)Nt6CfhWa4?jC%r?VANF?$r}O94gMia5i~Lg(PRFJuS$jr6y!N3g391g)XTbe-4w
zOglV5fi1kw4`3^*)$>CXkyst;J?ruNW_0zfF|q}vWkY#wJAiup0UkzopG<;$VJiS>
zb3fCN>94QWcwG^NpTqNKOocOm=;HJO!16g^EeuCE5G>XkRl#dV_LdNCAnukPZXoK`
z9^MyzI!x#zFegChLq@t;U`?<`$Y624&dx-#<$p>w4qDWutVma24my7db}n&{C~gjc
ziHy%s+!ymF=NDed9Oh;SdTf+GbUoT11Z)>jA`z+Eq&x4B{IPRL_81Ak;ef0be;0LL
zA8ct1#fp~prlKSn<{UOv48;1My}4AkO%S2DHpVmJaY!pmMgs}5JqC&%bIk_+yq+K_
zerHH|7}kBT8LA}BM$&*xZgcio(^4%7jXU=ECG(c4;-zg})0@`F-qxpWfv4?W^o&#f
z<+bdKt7!z0hOO-ls~dX&s&6(^k-M;0Kk!L#aN9ElrQaj+GJap1KRn~W6Dw`5BerKv
zSO~P;6w*V<%`<7yp=&~5q%*$Gm&qXBKVvW;XBd?C8-xUZ1adPT>vUa})CIIi(*$Bn
zjQqqYXGXY&J0MBR*<^8!NMMcqzSjIqk6`)=y+DjeoWVO-HE15N$C`CK_mfYThT(XQ
zC%s}*LrkncJD`v72LP#tiogyigEu)xFw)B%$dz!-g^E$|O0pl{-L+tXMB0$}yUp9K
zAC!l1O=C3f0B)6sHm!SNRX>~Zv&0QVzN9IM@&dmUL!A|n$6b|I;A(fj4ta?~p?Pzm
zNPg0o{`IUM!ao3Th1yaeFn1%%l5WWKv-VhOQ$hGOfJ@yKTS6&<VprA~>t~EsG*r{-
zP*#VLSXL+VTxk-d<dBtG2=JNB&071(hDX%)U<t6F7Pxd~zT~F<Ib7n}x4=Vm_|O_&
z&L19py+<R*$1<Kc_p@)Rr1o>*OIWffwC-)UG|Nj!q;U#h%tJv;cHN}d34<9Jmn<S1
zLhecmNlKnw-prb5ucQR#0K$ED2KU=}w;(xS&r1YWDRt>h>9$0DbqPC+hL?~GgP?>g
zq~*7S%o~YzUUU~mq$XzVIfTXdAituT5;_zGwffN0XJFcZ`(iu9ancHk+)QonuQ0Em
zdv}GZQ(Z-X)`0fCf11pjaum??aPUA&UVAl+D)KvpD(<R|;lK7ch92HnHqyA-ke7mp
z<r=(R^wytgHfUSNUj+;H65x70T)GbO_<2uaEz?U|$ERt(4blJ$0MP%`PbZgJu2uhZ
z)5gCb{U7~g>0)eVmz)bR_J4Ge$%{4J=?@SPTtpBM%Kz3$x7e5fL%e?iiBU>NyT+d0
zl+Q@YTn>!{v}$YAUVcA~t_>9;g$}47g4u$35s})|-BhUQ(<y&LCotdj?4P`xxcNu%
z!S}nOZD&niwjhG?_2<pBZx+`>?#)zo`}f!E#W$D};&;p*e~f5K-I&sVL`)LRFal1V
zrgF-aytWpt49f_>=(mD)306^qxrd3;-h_vEST?N#&<S6c#cmRCa@$BPNH|P&JB}?F
ziY5Nm5;gn#V+~v3z?Id{0BDb47_lGCLVl})ZisrsG<l1`@>e~v4->dz{w0CF6SJ?&
z;)l0`a>68ew?*AYMP;aQ=Z_(z<Yd>?Qinw)Kh`?k8f6PeqleU4Zi4qMs^E*;qvm$^
z4zP3av2nLHwh4Hguye3+H+B}}bJhOo_ZAkQI*aaJouFL+TFqRwdn-2XqPOLe{%8VJ
zax!xWc#5oy1in?0LF&$8#Zrtl)TeNY4|AEOvBqbM2UC*9XQiDPsQk&p*V91GqCTqh
za9eMQ$(#TjXBjh{+lq^Rz`dAnahem@g>51vSG<?YdXOA+Pi!_lx~w&@xpsB4j8<?~
zS})8s9tN!JUs(-0JwG&N*_mI^04!QorbU3u;+}4|484dwkxqMd{`DA;4AU)c6~tX-
ze4{apViFJR7tsVBl_Sh{fYJ#fJ;-_W<{Bf;*JHqCZ!ov6nL+I;kgluwXC(gHyeLCY
z3%{S&f)jqPkz5w!urtQrSDCm*gGPBzzT}N}uE$~9jXE{UjaFw!SX2JSvGc{{E@i}*
zNbWp1%4JSYS+3YhhLr~V_~V45#^MA73fY;UsrQ^msNW33)AZApNYL7+dQH)fq<!`B
z2j+k>{hu)sW0@rJpI^aiR%!q#)QMoY(x_gC-;{Lzh6u60VGxSF)P|v)m4S4)l((V?
zE4M9S<;>M2(bfisy=fdD(4Or4P`R32I6yBT{V{^>aJ={l)e8;IxYbK$jl`WRLO=3Z
zdPni@2VcEY;~gDF|1xv1_V)SaAsKBz@gAW4B{yov_67W_Vo&j<IfxNym2%pAbXsKD
zB{rzwEt)!Jzdp!Ha_|l_Q{&IVYHqz&U8nWsYqMvO8qG19#<;v)12bBgdR+%hKfA=p
zQ*}(n(9W$Vg6CaUSe2Nc=B7I*moNgyrs;j~%xJWxF&o}^c3Tv{%1a-WIZA&y&kXQo
z5>%SXoGS+O*{0nh%^1;DmdcMcvRHAzzUV<g>Ytt*A08h(w&CAiTpI1gy^v|EIk!0C
zsZS!?pO~P-4$$@FrKUMka<C@p2)4||b$}C{{K_?szi0UYM>MQ8snOG4+kW5BK4|M(
zsqFOj{THX7%B=U<E>~-Y0RJ^GwhGYv3IUUtx7%K?<f4SDRiZL;!6*=tyfO-DMot70
zLEii|6KU3F-lS6d=4EQ>Jj}S2ls*^T8ywGjFpj6&yaF_fc9I$=DR1)Vx6PBY(0xxO
zBtj3n6A@?Pm4EtZA|UAL$`7(1<KXl+IJrb^K5-xdF~hNZQFqHTG`cz+B?EMTK;E2G
zAxPH=HCX2E$NML^r1;uJ;}ad6_vT>C?5QD4ROg*j#Iei>6Nz{s6BU)b%Dga-az_W=
z4GbJCqHkqjOO+am>JCq!41o!iiiCJWf991Y_jwpelLt}|Q!?YMelQ7C<~WwmtGBEm
zPn3q)K+l$hEpUi2hItg${RSA$;UZp<wyB6hY3g8vA4qb$g>$Ppw}j0^@4a`8J)Mm{
zpZUxy9VnS$jcKZE?OjVD=<_`~`5^CQm{A9F%Sb4a$o~;t9csW@#~^YOXxYdh6{x`o
z$TzTHT=zPsY-LPHQ*C$w(I@6WE4hbJK`zT3_DWI-$@0qqW1Y|o<pv;?L^Sk9p>gEo
zSc~lk6Fm*yuv6UPqj_!*r`_8xHX?X&qbp|JCspi$9`f7S-~WKzzPZiG!H>-E3WsuW
zTNPjva}?<2?nNan+Qxn3g{ty$qH2#Gk@<jUTlx;Oe1%v2s`KBBb;g&3GQBoydOv%m
z_lN6yX8D5lVF{1F6$3!MW{!b1=9KnCP%vdB^1h+a`<`wbQXnM=%G%Sk*SUSzVSvX!
zZvW)&O?J4c-QPkm*f(HTWK~^g$ss#v&if7lv|Sg%5k2x(ENTs^*Z+P!Lw;$hWbp9$
zJto>oB0V@zD#(k!j&lwtpa~pCh^NBA!IsT%wu&i9UOi~p{tb{(+_FW=Gsd@b<_=V^
zH(@s*y<^he^OWBGrpQB+pj@~!!w9Y?&gzP8%XQ;Fs^u*`Jvj3<Vhr;nXZYDWBB@1X
zFlTnH`R==ICGy68@rdK&pT?tQ?tbc9cV$L!M!p;bU*mi7Fjb&NU?`zM&^__}pJV|}
z#&q>M%lY53hzy@h1kDG~b;Yy92@uqtU%z-HaoE@3sY@27plVCPluDGZC?5S8nbXl|
za^A+SFKc)itJ!VRDq}*74r|SmrYgIEoUs>Xz&!N_r;6Mw%n6cBZ}=9j;}U^u%IT+9
zpZ?k%&GjPNSKQ5>_s;X{_R`MR^Oz7Qca-6o7k(+CA1c-&bL}1=ns?tzVK^p^T*l_1
zN2m8s9M;kYh5LOHE@Rc6IfoXm#fGxRWK^7iRBjogb%yO&PaJ`aACw(IdSihDK7o42
z)on_z4qx9U43RqlC@yc^t_|3E{mIBeZbz6ng5lh)I)WkEDMQ|5ekZp9bzTp*yRl!-
zZH}<vU6VU-f;SDom!1pjw~>p7aysGbAkeUBwC;kdQb5*FJ#Pzv<_@Zid|Kxnr|JZL
zX4r`Do`K)0&&SP}AcX~+X&vabU9HquZq<EnSIkTInZ$7+bu>$-JJWKsVY9;<1NFdJ
zYZjd+l%D%g8%5Tv>0hmp9Po75+O$xyp?TPG^}EqUd-(!@mS#IGoiCiM;YG}x7PsHf
zTa$zr=@C2N(PTc$z~yJy^^?<)C+?m*NgLy_b8WH-pW5_ZXZi^XXWv@HrRP3q;9BZW
z>DGPEQP+HBI3hMMNG3%uHZD>-T14Dp$=YH^au>x)^NW;hBQ1S)RWQ*TR;Avt6Qdp%
zNECUccjpcW*dmy=W@w?S;}T1V=S;aW)J+1eyJ#ai#QL<T;qoZ>=TaoK4p3T3rPBD$
zv<8JKen!rzIG7g218P*n6<F~zuXu1$eviOxIHMb`&*Ny==q~Bxq<W84Pg>%&!Q+=z
ze+S0jlG5^eXOi<O8gDehuEGYqol-MR!tpmnqJ#nXjyOJCs(0TB6=sb~?ToNj5b%eL
z!9}_0jcVey23GE(28u88cO%2D)Jhz8@m|UTHSZWutygK7uwUAEu}2ZW>-XHjca(=c
z?|9d42S#7Rs<$s>)W9U~4TdW->aa4*4Rr$9ZPO;2w6!fVyvHBpfqW0B&Y3^@uz243
z0v7<>WVfrs9hArq^|&vf0Tp`);6g+32<R+@dsIIHqVi$f(u%f?ebVJHCbRucD1WA$
zm;-xk)<6#sdh7Wq*nAc(c0-L^%EH>=KkyxGy~YN*JL>kz0u6U#!gPNGL|)V^QUcMj
z-?Xkm;_U=9MWf^;N3!ABFhe)9XKDbaxZ;2r9d!c-MN7_$O6jAWT4Z&fgGY&2Oh`3L
z=$=!l-GMSi%UBZN-8t9=Zg2d_aGS*nxC7tSTUFe==zwXn`>ZvD%RKDyD>)~)gfB0}
z!{n8j5l<Hb?nE8~WJdLXA${1D`;BOAEAC}gQp)i-?lF_HXGzVSc!?sNTlYd}Z4;o~
za`IY)&dz`4t*F)y)k6>;fB3ePthP%p*u|!i@HcJsu})oi#q5vP!f57*hH0Z;h7V(}
zwGN`N)@H=azxCmH-_&MzyA)dyW}LSX$R_WgJ=s#MRd-$nH;{w71%>ULo}sLKh13Lb
ztAIR+PMh(F_`+O>`!IPKiMV+q<wXD@m_j_1x|Cw<mHbglYH_YcSkzOn5mniUS$rGP
z#*o7)dn>&*uDQ8#SF552&X{J=o@t=!9c7opennRIj(B;NuY-vZOfMV5R-e6Ek=stw
zHQBQmBZ-T2Sd;%PQp8q6oHgl6;`s~R=%RN2(=h|S?oeE2Vc*w=7kj!CMHaw|K3$F?
zTPif@`8!c&dvHcA2wc8pt0P$dX6w6|m8E6<(cw*vF>7_9J^ez|)(F2Z+8>NZ00_>;
zE~Qo|59YT^T>34z(%C6@(woyL^QU9%;~S1BitxBW(oU6)mXwlp?<*lI(^|cLMT;&0
z_FWoWJfvJZJzWbWTD)GVXcTb1q}{Bkoy(<_-|ht8eyja~%k%Mr?1e#Mu4EZ?^z@Eg
zaD?Uq5Aq}Y>b;*k_?<cmdj<v}S<G4HZ!xjQUd!s_alkK6oNa<Zv)_qW;~BWu^TVot
zPFtmgc=8gVCVTd5LI}k>-tgm+x!$cG9{6oVb^fA`SG?&*15jsSnkoQ6{bcc$FTRiD
zOR*T!&Ng{AbMI&`BENUQzF+68l|LhI5v}@z1Fu#MKeu4VlJ{Oik(*J*TW-(J(H7?c
zfv)s^w1A&0yZZR(UPyQQ@BDG94bcu{uAfpNOmqqux#Kq`q+NF|R(<)bTRF4)dKZmy
z``W2cIY@hQpG5y<>;4brE)G-&`#<*W*{5az=^rN-{>RAK|J%ORX+ndNCo>LV15#D5
z98iCv3xKBp&8?l)8<u74Z9}W*Uoa3xLyY9)BCJ*HP2Ox_(X^VkNQQ}zwB`JMe466P
z`+*QmctKU5%2Zs(cY0p)Ja4;NS^&P@p1_51;_b;3oA-z<jTr*7IhPv~2Q0uQM|;gp
z;o9xR65AW>_Yg%tGKt>actqI^0js7FOJ=If^h=*gJ=X+;(2rq65a`YqO@qM#b$-o6
zP^Mj1o-iBA_f|?*XKm1}JG(lxKTg!KVb$Th+UX)xt7Mn%b)vYy_Z~5B+(PaReg|Mn
zZEy1H77R6PqWXl-zpHRiF&l=#<GqS}3VaXrDp@&lR+{WFf@3c~xca8k0W5BRD@T%e
zA|?)QrwS|~Gx@UxoTJm?(jcm6mEfNIHqo-P-J<cB`t8^)qTO*)03APb$K;e{n~)UR
z6#VXG#LM4u8&UWI2p>;)Ew+Kx%H?Ab^~u1#Z8*9@?9#z!C7<r4mX;GRTAf&-qSkpe
zu2$j3Gx1^#eu=L<JHw9r187=4uBt+(LTU6f?jKFaoipjTsPi<R$<Qk99}RphipbC{
zk!%*@i>L1;rne&^yAREQo^KfqAB^vis%9e{0Ae(;m?aQUY0}s<TzZP_bT*>VcQ~)`
z{@kZy#2^0RSHE5m>%6SM52Vq<OZS!GWL+MzupN(qHf0#q9egxir#nvofTxdl9a1O{
zP^@;yV4jUQ{wE_a^O@R7`uE`oz$Bxfa07Hzb=A?oIHkEs@F#lNrF2VLLv&S`q$pZw
z(aABuD4<IX&Pj48!^2$n$E86XAK!Eg@h#7T9T8`^XBN|$f5-SgOIGeEkRC2im^D4E
z+xq)nwf48JD15!W#|we>L^%4N0!xBuh|ZbMhTY}pGVTV+VjW)#j5HKTRk{mz?E#Rk
zu*d#ZLnT<sJd9F})IfP6HF{~U8k9+|auhnP)cv&0!!j&e!OhWbl^!bKJL=m{vg=(@
z$gCjuz_wK#J8z$_nf>`8Qs7^?L(Ev$>~(*Jl=&$!>f_b0OlUZEd2Nf)IXO#lS#$Tm
zH<)4e99yuufq|%Bz7y*Ot===tj{qwVTmAO**2fgaU~OlH)}pnr9IRLeDr+-{uoHSd
z6q(g^2^l2&4ISRvjlxxj(Yba^`)IVWKWxoe((Tje>u6o7XBgZ>)FrlBg*arT;ZU#(
zHKrvZ4?0;FJz?Xfr|W6I`r+|d7PQNEN#&RuXUG6%#y(Va<pjg5XRccdo&X%FX0$bi
zEw>3C9j%?k14L!_QSrdIq))Oq2irJ`WT8~S32g^?QSWuISn(0Y<}^7C!r^pAp2suP
zXBIr;GwK6hu1}(q;v-P1s%Sm?&e2~8EM&$u3d<HTXO^!1`x$*1sjUY-ff0G-YW&pc
zRUHvn5IXVCnM<tF*QLaDCIE1~9pz}4z`AlZ9f_W5(!df}(NTwbWtYI~gOT*6GE=)V
zikZ3zRe6ip#V`jry^J>d$?GkJa|_3bdCt=dfjZqA{bLt(Amz1mqDmvADy3Pa)Bzb}
zTNFG#q&CKLVfE@LB9p{%L_tB2J_gYN8b<y;8%F*?U=-7BX;8hIA0XBd;)mk43K&Cb
zx|T3QX{@~idOh972j_*7H>lagq$_L=k4NfLs+iY44INqVxSO1bB-qlkNx_5~Ifq^#
zQ`<)Kt-%;=h8G{$k}&BHTQemSZH4vaw##h4ugA-;jO*VA>Dyjehr?PH3H9=gXKT^s
zw@G6Kwd=G6<gIdQI{;(o_DrG)RUsd99a=O?p*!=o+^MQP^4G8>()8A9#WM>LFs%vb
zciv?ES@adpAEX@GE)<86jGsvFl9?Q-y+8D3Y>AypNAJ-fM;^FmiCBN7NBa<s!R0Is
z&ekU&fge%mh~Ps?&h841+;~d~nfq^_O8!z|0Ac?1GY$cJh#8=)N8cBmEw$S&x>$QP
z%)ylr{4VJgMo2UyD*E|BlENYJBoQv@Vzs-{4&}bdfYJXxPUuq{uC#(UC-%3p?HFGN
zyNDyaEz!S42xq4703;V|E)hHj(<|gctqWpwE5H-ca{YtHO=#$L?ywWzXH*~nsWtx(
z&*Af-zU7&~01p65<N1pR+Xo)&^;9w;63UrJ=#3@JnSGuNiAbF9NZZR9ar&?^75;79
zkVyOD#4@4<f+tQHkBY$<wK)o9wMCG)7zyVQ>dW{QvVK=H=2%+Kq(#sT72}Z6_%E_&
z=DMgG+M1+~eNR;SEi28EQ!t(68AWSLob%s(OT9r``cM|49oH3RS!QK=g+b5M^;SPn
z!}2Ey1K$V3|D3gQtFd1e|5-Cmq~tgV+~n(#AIXynuz+`8bWNN9#V6KDi(kk(PP$fe
z607tGaD_@Rfv_<4qUpkTA`qtTO?-AgDA_J9>C>wo!`j<ysx?Y&dex#mE0ZYD?JsKA
z-=e>N^}lJpRNQbiXK&f1K_7cR<?!tIr9b=a@a^z;zwgxd{V>A&YJ=Ck?SLmr*%M{O
zW|bRHPy~=h2mN4+gix@drc4z3iMeoZM&TrLyg=G$o{>11I4Ey|T1qYm&lK1s<(H_2
z%1uUTnamyjK<ZtDMl>iXzGvFx*MvqiM#Xz4?I#naNagf%Bwu>J`9%*kKiw$#MFdQd
z;<klfkZc$W_$4bX^3@b($-!T~M+d8K3Ew^D@c;<(AEFhoS}Plh+N3#%No?J$sqv(9
zi&7Y*eIHIMZ|Lf~uc?f3?40SaoW<iQ%O?QXg-BG3G2HM{)tUg=#1sp;PJDoNb8N6}
znF1F$rAcSzR72hs+Nn>K%gm+=65nyTrl~lg*UTCA+`vn0j2u#g{jV1F>$R$eI{g%s
za=;~C8-q`9n(3=A24hLOie5&DNA;V5qmOE|@-v}o1Y#$og}?cX%hcS&RLU6vM_CEt
z77xuN%W$)qKAMDiI;_$kN&IjWyJ9^~noiru>A!XdeZ_90BJQQWx)<4hEoB~-;?YZf
z6KKQ_*%y*FJ6cNmC3ias{HqW5ER<nYF#$Z~nw1DWW_jCe(a{%SSWE13*u!;kiryV)
zEc00Gn<BirvvN)<=%58w9x;~bH=kcs{BQ7d<bGf|nAIEcIWan>ky~gFYj%ddIRw`b
z<?)&yQ_MH9RG(r80E<`rqcO7f69!+SPBP>22~55qq`DhS9e|VB#xj3(mfIt6;Q+n^
z;~Nf{M}lT=3yiwJ6*vC)`U~s<huqIn!!Zw>>tRF!KIi_pXQTAEpMJr8S)ykzl!R(p
z8#2Y87?X?{d2!KRKgZf{?KPaEeRak>%>*K_-2Je27Vi9U0*IT^{~=DH`8!rdnvu2?
z_}P^^Q}0i-j}+yL$C3wx{X0wC06^UV)=O!e;a*dirrQT@|C}>qGjCN#m9fGYM^DvW
zSKLli{!ZYcfq>n58Iyt(E#>m#%)*wfm;NvwZ$P||)k|@l(BACSZpTB2I&CClWW%6m
z<qPFk(LueJ?AXTs{V%(KEfspIY8~6khJbMsRI_2TJbqZuO>V@&V}XTRa6lB@rOk%K
zI_EEOLj!UK0weFazwy{$bmR%6j}<JYZS(DO=OgXI^|ee}W##m!OD{i%LvF%ILw)D3
zd~|GG&s!#jALk*RUcJX^T_Rj5oUgNKyFGwh@z`JNXr_k`7Mc29bni~rY45h#_Utb1
zmUx!2eZ|tVIM4K)Lw|>!HUS$xtU$OSndU%`>;ikkQQq}7D$N-N%-|MAYSG$odiAhH
zgj|-fw#oC&?Yf3B+=O??``ubm!b(fKX9U4g2??~&*RgJ0m97T%AiAGVNsW^FgdYqe
zs1u9Ej^8^Cx-nS!sC1Yz*c(;3^8CE>y;rj}*FY5)i*@SwtdmpHa{z=Y!LdJB^Nog)
zOMJFN6I{rS{KMU<8#R|!6<0mp9}nmjNk=dpHdlvZ*?Oo|8c>h#9nE43&F38#+)|vd
zUiU?QI#Rn`e~!tG8I6(duEPchZpZp*e%9d3atr2%U3iPUnw~Dn7rYTdotvWt6gT06
z9+qZrOj_3)dR|ulW<Z3Q%AB?sTjeUfNv4_~=G~OKRlQO(IFeJ$0%6RzL7dNR56U|;
zd}r{TR1s#cCx2*$mnM^;<i6K2EN_*T2f_G(<{VDlU)nU!`dua9M0L-n5^kl*l6cLI
zp7^tPO`&ikvtOeRV!J*fL$~2C%-#?yGo+O{o=w57Yf=R!9DwDtUrwMEtqyP<=1wr&
zb5X5ZRqeETACXqw+499Dw?k39-q;_a((3f8E|Rx~XHx*V=jfFmSr%Bgmm7r@Cvg9l
zF_bF-JE9$;GyJED^EHK-DqKp`Y@y};JiwsdJ5K%Xnznk#>*MaI43o<`E8J>C+0(Hj
zrsb`chxm^i0f5c3Bhec_0@B&kb#+Q_hc7WoA90mr$sgaA=ZQ>S;fgfh#cZD3Ta7rp
zY`o~?kWd0q-#B%r1h~^k^gV$56>8i{2(?IQAj9gVg|JspwTt2o8ou~|t<JRH-~$u?
zqb75N_01auiA5nLE&Gl+fB%I_n>{Gl4AEQlKut#=5+M1aVXQ(xo+Wyy`SWUwI+M`&
zu-z#`E{=7S*5{`D%9O((>}C{ukD5YRX0-b$v2aWz?1y1u16NvQ(ak;T-?*iMsqQ^)
zl+%8svEWyTZK9s+5vUB<TYx%nmi^_O=|9)N8y}tYn}5oE2?hj&;lHbU$!QQM$$UUu
zK&*zg=Yj_E7y4uxnHZ)eD3laD$;ga}s*JU?6>J9#M2@g2G)Eyiu+IacDP@9{d<(1V
z8R>RCy)O+bJ5AN+Z5=QtB*LfJgzD&&mE)Se)}P5o_Wk+sYzbm8sK_efr8{aoC99R-
z^mCM$aYAc^0w+Cje=-T4D9v1NP`$4QfHneKUJ~3vxz`m!gR`ZT>Lfba{adP|6Y5hd
z*@-UVxubK#&pV&VGf2t2hK!B`3*um`Cq|T7Y84royBH@+fNB6MwiXsS*&+_+RKfa(
zE+f`Trn|iUN+haGrnb7FIz#M^t=Qc59~m$cngv>N*tDz#?ft+~2M1O<=WX^YK$3hq
zg*w}Oo6Xu(7RD~qUGcBtxz<Jf$G)sT>ct6C8)+8k7Wz>Zl$h+f)4X>T8iD+OTTw8H
zyBV3X#G^{9m9>S-CwohD(EXR$?b^(#+*{RTGHv2eST1d_rxf%IrI#8zToQ{sq`-VG
z{P@VPvmVkjdX0}E;Fn;u=<Azn0J%=y<UFex9ar*9-k;MJvvO0;lMlMuZPvDB%1H&v
zH1}DFvX$m!-GlT{Q%)^3iqpS=J;!R2tu@7FMzx{!Y{A$=MZXYZ5na~l|7Go3g>GOl
z&M;7O2Ps3c5u?2uB=CaD2uKd<ZzdPeQ4b{;(XNg_!P58PgMzkTq&OP_2Epx6n0+Li
z+ijeC!?*(mJ0G;r?G8kv^2+m!ILs9XC113JXBl57-t?<NLKM;cqGl`N3~-aWv`u=T
zVFkx3uv{2~7Gb*DW`^HI2Gd_;21Whke{FS?^>&mUptV!erG+@6`$gZJVqE$d(BQRc
znDM2eGv~8U`Y@Vgc!-q)o{gF#dIw1v+afI4T+TLS#Mt;<6pC4`F3cTBSOqn3<LO=q
zg>L@@pfi67`Nm~gay4{Ce6)G{hZ+bgvTN)>MK{M%=+#J<>5!|E^ZZeRxIy`gm65y6
zxK^{e>YNv9fl#iW>95|J@pG8u7y)W_0j}jGq=N3H6(PEEG2XWsU>=QkfBlKzpihg`
zH*#r~-N}sZAK9&tJJUMIjA@@M!vJFYr$^hlEp|pHTH(?h&HOvsi+!5opwByg`}WL-
z%Ylr&qcYK?mb}U{?K%9{Tp7>8kD6p;pR$};Ds%Q_Ry%UA{+fH3Ev>Lzn(YNSvfLsY
zRnY`spa)H#wD3b2KwLy#c;m1c;Sa&AeQf=_<twv){%bxGSiW})VX1DAN1(^I7{-t(
zubWZK@-NZNc+(czI*?J6(p*ATN~tJ1Au688r;iae41!6;y~zlG@YG8g-K{3Flu)4B
z&xWWOoI9Aq2Cc!o25c4DRlWnHcTs)vt=zlELMr{AH*&=I0OSbNi5JSVZBH`#uh1_^
zy&EogXs=6%*<!vh1)cEU@1S5V$jN_?gd&ag2B0-i2JOKnBZiCnPbIXX^YSTKj)*5r
zah*j_2MA<DbL`?tBM<)SN|4)9oqnr}Oxx#;*pj<frNN~?^WJR}M@gkDn1%Kcx29-}
zoBn#5RAkA>1i)Wan*bp9N-Hg0`&9RTd7WCu$RR{fdHtZph9#)j-6ew<`Z6Sn8e;nX
zdO#0nEi`6AQe;*UKb*}Sf=|-T`vnb}MJY9Q<`+fmT;Y1i8AO;v!W`g+@+@EEUXaed
zGo%f+s+cMyNtGDho}4tPK>EVRee)vy1@%7@B-Fo#)BoxQO{N81|3BEQnHMwi|8ldf
zw;dX61Q3vI91swa|KVncfLtvYKlBy<ue_FSHryX1n8@_24XdNj1at?h`1=is2}X^K
zEmCHKt1%j6)^|3R0&H-<9p=007Vz!2D6R3j?dLhI2~Mo+R}2!7#~dya-uvn~<@b-R
zT>lErQ@(C*ED_F!9cvox^c(<sZvaz(mp}14p9Ua&z?4AlJewhHz(**4UfM9*kMN*4
zNbvMqMuZ#Af`g{O=Ur{^8=$L;m%;o;DgM`lFx8jNFdXi-r4dIRw$<P}!arn}GDeg%
z9PaKnG9Y=!!sE9&Ky@n(o<CH6bel<O^I8)(i}S+YSFjh&+h;}`#ROIO1uyCD2OQA6
z<NEQ1X}FM>6y2W;5b0y|?5o?un-6iE*c0dZ=*91&2zQ*^<8yhbV?Q8r`zQ`1@lzao
zcK;9_Mnbp*s`7qG3w~=SeMIMcRzn=^z~hhhU%ViJe@A}L-|gTAkhgzHj(wlMG=^zf
zy+o1_hcMz&tFzmX7DN^>igf*9FT5xkA8<B4H3?;uo4}w0SVvkd18MbJPEA@Fhq|<i
zqg%VQs32QxOnNCftw>2hK-u!9*BuN;@A)^-pyRt{fUlz7faRIDvy>ygI^l=Y)!&JY
zUt;^$eZ>dEo`14B1||flE?za3^BY*byOl+#8;U&rj0ymk*J2-PLhWts&>^fdQ!(;1
z**^$8%X~)xt!1np&yXt<M|SPLN(9$ve>w=;j_tCTy=HhF-7RY_<vfQx7uIkH@%Zx^
z^qH>AXj}li*-uEYf7|rMk6l<MJw4>0A>MLms`NQBX4Z#aJEb=SjO8s-NE9X}<g^@g
z>SVJ)0i5zVb+zR$4Xz~F&NVdazVZ{}3gwpfb-m~SCHLS_&PwfkS{7(KYdYNY*3av^
zMz8V3mIZ-?nbiro>8val`}nSGTj|KRl&jY>J82JB2ByY~{){Hq`-CZmXx;<u9gk*>
zu+hV<Db&hfGus*8HeahzM(>OU#pCkwQYt)!=lMLl0Eelxw)%<AnHcuk*>Tyzn0V8a
z^Fx0?;BpfSnYU2-b7Z&uw6f1HkhxU^4jmj7Z9WPH3USe_lZ%OuJ3Ef<W9@~fj%>`;
z9*9l?*}1*P`K(nb-3X)lqf%Ab-o|3amr4612WFKc4gzYDD9dt!<GGTfwQh&A*)lcu
zt<`_+x95-^lQCCVnVTdV`R)-XqqMv$c{54?UC+Cizh$)%Sk|rk^R@EXiQ}$jNrEZ9
z?QtESY1z`URqpC)M-5u!oBHC|Ni3vP7uDQqnb>MjhuYJZQb%lQj`8Wn9d&(NHa9g!
zlT~Ibt|?xF&fcj`vD_G5V743QGR%kDA-TCpN7mxb%Cv~pbdsq-dtSix`9rUz?C?#%
zB7G=DPEU4|d0Rsb1EsUv1dB7%vAh|xB`MsPm;xdei{gldzYx~s_+{FYjY%?1-5?oQ
zW3^fsURt_l74nLWNi$7bL<MDA);_OuFO388h8+K|cli&>fJt<&s4IHf=*~aYsB?K$
zGc?C4?%SF~(irwGtA&vss%{YqX!T<N$80Y;!js3+SAAGVdACeb$}V~5<kiZ^Z23D>
z=V(d?4j^OW2D)#Fd_ATwjJFPDSN81dQwpVzT%+P8mX_+wQlg6;j2I>pQSU$dMLU|o
z9%)Bf771R)P3^ESa#hAn?jt`(^_0EeFtSz?N2U7rz*!ak_g)0IO;kq?LGmzw0H50N
z&xr0V71+-+!dY}t6Rq9C<nYn3gJH>{1HuC;pT8rKa}`w(bL%R|?lT(>ixcxQvkHw~
zl5}f?kGZENSN~eMe8f7rc~hUTQ<J@=(W2ul?3O{tk4rNt=KQpcNk?~+&hfeY4J&VJ
z3~|?cU)?0k^((CM#LP!V@NOdjG!jP)@zE@*<RdVch~s$0>vA=ksf6+|*(M@6C6aU;
zp-bM<Z&~}Lq}s4)HcxmH_|w2Fmm!*UH5GMzZFc7g^m1Tsi1){c@Cu=74vOc}ABLv7
zN>vAlB9~{A%Y8jc&deDFAfj&H(d>!cvJS6suZYG8^#D`W@}y_>q|z!t3x#u(OWtRu
zF3H=1Wr}>)-S0r0spNC5`bF?cyg82O@xC)h6tApkGuzTUf-oCfrO=1VR*j|Jw6rHJ
zbNE^2>e#BXNO~uiBb35bF12FyRb`M>wpxWmM_q45-GhBB8snmPP<y(qRA#x%-r$*&
zX}xWFqx|ctA}h;8r9=wglFB-wqH@A+z|;3+!(m4is!3&TB6y*TRjsE?0QHdP*vwgL
zB-Qk!94A!2jjE|$u-#H?P9VFkJly;_{M3><dkfiEc^;}NT5guHM3MMPRokF9kG{eX
z?U*jpjGonPNqgl}CC&$Yc_MfMQBO(zvU1<Jr(~Gd=-;VaRoMqvrlG{x8LG22I!8uj
zSyZ%s!H^{x#jHIauYqdZZW)xnSL}Rnq9s<%L{U`2CatI0%IDfYIoF+o2HThWdXCuY
z0ZiJwT9QK5MEW}F{7bPsX#&jGqcyh?mU4G0Y9J=3E7r>b)ER%P*WV<?y=LyfxOM7T
zRNj}_9QSEY%1Z%^nrXVrVtGm`j#fZwwRLB=*iVA8pKy$DjU&fOL1RDQ_XB7Tyqb_m
zE+ZFf7*zERJ}M4gfos&Z@vwbf*7mPcp1I8j-ny7SGo``nIM~YHiZ^GE&W`x*zKODX
zq$3Kna2#QlOVd=3<yK~w-qQ@+n+X0+I^udOKBg7r+YSN5?62uYZPl@8*&J}RJAdkH
zKL0wMq*YaEzWQeNP;UIYYO>((OOUrP=~Y!qZ+pP?QNy;MJ(K5oZESQ|8+>!do3LX0
zL6Ok=(DzZ|SnDbJ3b_*SxN2;{i=~z!TW`3q?8!kiQBmUu8B#{zIdh+`SBR+MUZ+$v
zq>&?z4~7W{T8*%tauS3q0JW~0Rj<AIspWB+6K<Ydm&fyHM>^f>#N(s)T7q!fS?CX1
z)O&!#-r^}3Jo;2;iM*?ED@`$d(t$z}mo42J%35Sq#$oG3uzcWi=sj<c68z9n@bzpJ
zJkPW!r}L-4Vm?e_=CxC)$>^7@bSo!*7sM587LzDIF$$7hKS+6QTaI>D;&fG^mM=x3
z`M2ggwG+`bRci{5f{k>4Rr4<l$PB6tK3=Q_m&y)>sEd96vJvrU`XjiSA*Nk(86a&B
ze!tX=;XeOBuJH_!mKtS%m}Sl3c=TnJZxBKHAH9L9yg%kG<V>dSNm0XaT5R|*7!7Sy
zf3{HoF!V+QjrLb_q=C0@5gG$wQU$-H6rCQQ(w<KRd=?zYP-9LZ?c}a)Y`oAU7>!jy
zSNMb675CO}kHOmXB-nAbyMA5d*>Ws%2$)@Q>cqBo1k{~9I+k3P&mnJX48&3`mGy3%
zMxDl9WWla}ttt{~mfJ&KMnKdH$3wtb-E<8B3_%Iv_udGbzd9*r$&OtW@8^Gh&=~B7
z8V+DQ(u=&gj6yoGX|^YrU>R>sTdf7#ugVtqdNsuZo{O=du!q}?k=qZ@5lMi#zJDaK
z{-Rxj_Ml4M>fi&5xg`WdUtEVi*(Gin@yD96i$_WPa(wgmwy`>&)vx`N3DX&;j3FNZ
zeW3j@P&l<*3w4IZJ=Tk!Kaln?+@2vM?y9GfDbIz(_3ML3^ff)+qRq?uwOo9_`vNr&
zIN;;#y$Jim3@xD{?l?Yv5FR(9qIP{yGXQr8XeWQwrq5;CF%`%<Mcl1S@5p~#9o`&6
z_8dmC`jG&gG}Vn9Dd3q7T$O<rQsYd3#iS@Ml}@>i;41>S4)czSPiTIezSiI_*wshs
zD2GjXE|0Khz0vJMFrT4!*wvlw)?eU$m`(}Kn&T1EAut&w1T-S7;>6{d>ugg|>;xWl
zv_Pb^L0+vN7sLVK1MCUDNCBFqFGWkr*Y~Qm8JGJYt-o3CnQs8PpzTQRVMrK&KX})+
zewg8Kr$pEANWUKwK~}~`Ik>ZS9TW>>6Nn848uN_EkzwxH^Xx96ca#T+Vd4bh3#oqd
zl4?t)H%NdL5qc}`vc^#jo3i4e&CW^XHnK|yQChu$(*ph7&2fmZynTqOS3XaVQ+>V8
zSR}$r_$Ak&)OrN|HN+<8?FdH!B=3A73bR}9o_XM$EWy8od9Lt{8LkDSB>Q0izqNzB
z?<8}^!TvhoY=>i{_&Kted}BLmH2%JMQQ7iSuXMSA&o|n_hmCi|zwQZQm|B*nh;RP5
zay+9kDylxcqrxVlqGMT!DnLay`IQZS*9w25@WTVR!Z$g3sW$g}1)Dbmkk*uwEf+B+
zbM#T`)nm4tPNOO@pLr{5{l|#AGKP;L7B2sI6%BfahG_5>=M_5i#%3<n7rP-g((G5f
zFsU>XRZ^i8bK)Xtp_s~z6uGWQE`Ceh2*u{-NK%78!?X{<Az(KolNjZPY09d-<?eVj
zJ_D{=mkc!39cO5@bbP<QxIV>HjDL8S3`F>y!VFl769`~bJHf@H5tirBPFVRNSq}MC
z!ro{o2U5rF?UddQTL|($vD6QHqAY@BI${O@jGx+3s}L1iCSRr=F@y;AGD@Tw5+5!y
zf^@<vazX<(@*SmXvR)>|cBd%ng$9v^&XvTLJ&?f08Y2}VHp+ghwN0bCwzaiw`Kk4(
zx3Bc(U-W!;dRnkbGlEg}`#o<v@?3o9-1r$9yuK&TBF}++F$;fQCQBraGRfz$2Lkxn
zU*{|Cc^HMw`3?492>09b5R`twnb{Swhl1vfB$v{_-l8)i{;B0x&ng&N0AtTApZvgq
zo&Ebz12TJ@FjNj{g*yv#d&aNnBU8d7y5|j=HGKfCH(?H1b>Q+^lTfCTRpnQAj2n9L
z?j1M;XFgg4GJOD??;n|!J?fMj5df%;&cG_Mth{-5@@pR6t@W@DoZNPT_AJr#&<alu
zz?nYIvr8>dqiev0K78~@_++6A8t%=$bgs?XmKIY8pWO3WFGIb6Z5KG%{#w5E5^_vA
zp|q|7>&a}V_A4B+XSM!!`mPP6^;R6#5lN}~)_yPgvqw~rF|ka>m_gWn6Hw<Q`K!&j
zJAXJ}`E!%z-s8xb3$JLYG+>)%HUb(=og1@2K?_x$Ki~I-)mknT4Rn1xc3z8>rSg_B
z)E9h_%=KWC3hqsOZW8=MyH7;0KB1isNTo^bhk?dYDc_jkuq@dkCZfm;iHEDXVsEqE
zQCwK*eh^lsp3TWwYrEFi2XHvREgL$PZPnM27mIdZYSAe}xzL$muM;Gc)zX<-uMtoB
zb7VtlNWQ&Pnk~1GePE#}pI#YC<|AKU`S|zLLcUobBK6CuhYK^(*0@aD0WBL><zT2(
zvbpPm*rY{(H07j&K`UPXD!S~<pCHj}XtlJSlhj9FGCWVJX2~Rr0iYX;7dm>t2*R@i
zOJ<=(m&wTZ3DGO4os1T(-<CP9ON4YGhn5wav7Hptc5y6$5WFAg6^^-9lNsh$&fBZe
z4mvySbVT15DMsvHFucei>&T3Xxu9K#Yv-KjWK}+w%FZzvF_xCjqrkP#VS?r?F8Rc*
zx+a|*Bw^gZ75h};2XJI1lRF@|XW6P+Ybk_LjcO`y@vwzUr?;1v$fT4Idkm}j8Cw6-
z^WoH?3`o^-zsXWPpp7zv5SEEzqh+~d(YJJ(=(vi?J?CqtEwVQ|$bfw*C1JEpA9#`y
zSE6!^DUj#T8y|`A!7-Se%lVo^En-r}CQ#@}E<b!;uMI~J28ckANY869GcV`vr5-M(
zSx#;d)?6vVHqRJb$-BHnuQ;*O4Yjhp34i90HJt!gl>{rRG%e9FuLq08(eF~nf^%G!
zFK!mv(7@YwHnRGn{v561`oRla>$CrZMo>0)&@qL_DOaJoTQlHQQnuFcn8S*C|0!U-
z8ZI%d&yutu1JLfCOccQIf86pJn+bWbkUrD0R;)k(Q;p;`_=V7lNLMLtr+7lKFWoHK
zewS1K{CG-`M%X6#fdZwX#BhihZl~UxWj!OFV25YV<tP?!Ogtu>ykg@9WT&$}H`Qm(
zDvOpbqjaloL@H<+iMnuSvmr+XGYgrwvdIoLCk;mV3*cM*GmPiPaCtZqf)Phm3y*BS
zTzz1n)=cjk#1(}9gID0{_n5YXzT+rGcbyC_N;v8hdltJ#P|PWrQy(Lm-y|DxgC;w0
zU|#NN;AKq}Oo3DjEk0<5`=nTqFxG}eEHetj+0}luTEZk6Ww;NbR-n{ex6p`xu4sIs
zr-5*e0szQjOdArTNNjnA`yI^$kmN#Va~JlV=Uf>;f-BrKyL17Mn)Qe+wUazNXPLa5
zeHm(FOIs$U;+Tjar{N||1}Ar#7h5)egtN^q<*J!fD1g=%_4wMSpNMTVQ=2ujKe~6@
zrz4ycfSiLNxXb&h!5>l6KhMhEEOlx4Ve4(j4)7*5>HKA(>vsL|`jDBW-(K_g%VVOF
zy4<mk9j-*1d&(xT!DWYFp+@hyTTVHdvPB8HmfKxqO<XZ+xd?56*VsXNL5IGjN+EQ4
zc@HRSb_Yq-_@ee;qp(wC%qSZ=d9Ui>>CsXm&A?}FZ|+>3J3}y1UFp5VDqnhX>Ych>
z4lt}{7Y?TVj0vclSN-=d=E}TKg&TsuLTUIJO6t>XtC61!Mj1U=?CioL?N!+Y`gZNT
z`-gXG{fPi9;HO|;#XW*w@r2<%UZVh!VPz*=$ZER!7c2mS*334-%0XXMGn7<(ufDP;
zy+5vECNBY_npk9(&M$d_>w$rGXQI8*55V`Y*12!MM(tNVv9s$~<%e~n`s&apndPhA
zr^w!6cm#E7e+f1m%|&jShO)%AmUWi&U>7Q~7Aj(8AZ=nmjlY6csI>`O_|d{nhB<HY
znPFkl94iY}jmS~vv7LZ{<W3qL{#Vd$KJn{M&{WTt%_8>j$4aYVltU`f;ipLhIDi%q
z{mf!7REJEn4bu=2UX-r@mP)kmSltqTt?^0>kUY8>qTRGl*Omy+brrpvNyvuJ#l=S#
ztR>e#wFQ^ZKM`yFQfhCLMQXk9p*ORhBV20`?G0Pf*GFxJb78}6>f(TlCCoa}ahQdB
z%y6b}c@u4L>%VnL&`1^0aks&@0fd)WA>hDZkD(LnWi-&kSW}A0nzI>=SfuL^p0gj!
zC15s9nTcE;p(`yFX;F92!xxrSA*7Pan4Gm>C%Gtv<y^-A`BYl<Yp<viV3yV(*E2v<
zi7?p(i|$DR)b_^I0`%|!8Bh)CNafSK3yW_Qo>lx(j@5o4`AV<S-grT?fYb7zL*Z@|
zS@D8_6PnAJF*+xS0Y-h_6Aw4Z18Nce$uxT9SL<yuwLIllYN6`eXSJ`sUyWXNHKo*H
zI__}LvMVlyd3z>|i#S}iqNx5tN-sRA`6u9K6$Glly{VffMLtv7{sE>aH74nYduTZG
zD*jZ%JppR!5h7IC`m*v^K+UpRfPC5X+hI^_WshK9OvsgzVvg`nyQK@Vt~BJF&_i^3
z7MOCf{TKzj;9i}nBr7?SxLqa;mh7wq=oGIa-mrCrBcl5Y*l(#Lq6a+M?~t7lt$NiT
zRUeq&YDev_1d9cAt?@GbC;2oVuBkg1ZXZEAvbsKUv1Rv6d!}Eh03*v$E6W-@<sSKI
zh5uK_RX|16y!|B>5DDq-?i5K$=~O_JE@`Ai1Q$_3LRMG->F!Pe32BL?LApU26r|(3
z@cRB?U(Yw^+;i@n`};k0=eaXycjjpym7NRNZ{Zs8JCmc~IC<4kKWnFR#x?Cf;dLT`
zRQ|MDL53PU-S|L~DO1Ak3s0w2Rz$iymxFEij~ZCbEvcb*3`>ef;B?E>r>GgBF(2Jq
z6AV_pa&Y1m1v02IT~K~y7Z6}71Ue*A@~>h)OhM}EoZy74pAA~}DCWkOxorOaq@faT
zxoUvREL2iV;=vg9(_B{#IL(7W<=i%FU!du9#A0AE^A+p2!>JinFXUBcL(Mws9Xgmn
zKS@6xwQ0jbg^s0KFY745Fee+NclPTbiF)7+7Z;2oJdi;E=A-iIY0Gyk<4D2?p{hA}
zz`SzQkV6~f)i%CZ=ZcG$&FRQt^l?PT{MxF}<kOY`mk^pqQ?hIfeWV-3PIq_R$81LL
zHisnFIpn=C_|4`5Q{7}DXkFw@M(3t54+;6=b7ZO55U8cyzrLWj5tkOfTxh4!%%G$a
z<w;(pw3o{7OCvEtU($2FMhD-1<PolNr>l>_7_aIfr2iOeyeYKpr)6fHcvTdh)cAL5
zOLK06U+?8)t4&^GJSOcHKW*MOG|>XZua@hH``_oDW4)a|xQO<(J4&k7MxTHDLlX%N
zL7Q7gYZ@7Gh0(E|>-}vd<04e(3;T#24+9g+05e@IA}h<>u>If%leqgSLus?ggSW$W
zkC-T9Hy~e<h%(=F@!e4l=Mf+g3YQqpRMyE5Q14*u91wOzR=odtLes$(eiFc7XHpf9
z5;I?`7{@B;|J<U-c`-T3ulIP^oth;sX8lX?oB5aDIZ{k)DsIRdwG&q1(56+FH;+|j
z-;v*C<re_KXa<h+27fGL3lNlIb}bvY9;S%J=Z-*TiYVG91_v$1O`5p|e{S=SzK_)Y
z8dgbq`!h+jVdg+qV#hnyC_gu_p_1yuS&o2$3>gvq`C3h!u{{C>i{ro@{sb8BGh82}
z4U(Vk*sPvE<Mi(;K3|k2wC3naROG=9_xjWt@sN@^z2+D1VMi{`z=5n#07b7l1I?I-
z9$88|#7)%VlS*k8>Qk%U_oQsktox&uJLUFbzcug0Dn^*s2O3cCzI<C3L>;z-0ak2q
zwQK>Y=>=ybrJp#HL!$!Ar;?ueV%oVb@?{SPoH<KR-%@krz&-M-iXhT?tt}|^AR&ED
zLB9PF8daxs6@H0spIeUq!j6N;ci{<smx8pyK8TUxM-{8S?<>rjH+s#g$@YGmIEYNj
ze3mU;>D|GpCMaF%#X3Tp^4?X;+cR4<)O)>?lZtyMna4M54KtHEd1j0*W>}X`aX?>O
zrIz64G8@FfG3<^N4Ll2T38yzCeTsg|u<h(VS=Vnu>GtSjsE?kARH<$9;(CQN<`8>A
z`Wb{C(!1YPD+r;dx_K0I5?mlElR2~m-a)et-FNK3We4w|FYj_m->Y779NqYF+Gd2y
zj-t(PA2}q5xAFGYm-o!Qx>Dv82A+8Ej1563w|}xnZ}cFJ>zftvej60`ex|{DXzl}+
zZfr@JDArozZ{jt#@$>4?<vUV$Y;H`d?1w>&KX!lmEm}<@FVk!?gtAMU_DSlCwIr4A
zqnm8f(~X!s)^f{qM?ziI_y)K@(*96B!to(->=4>++Ev8l)i9My8orP7WvN12LfVSg
zThRU8QaMqiS7JtqkcQ<N9&$BDs970)wuP~6rR{Ffj~hAN$%MY*k3jr=%(SK8-c4kP
zw^uf`5Gk6Miu?dE1*v^KmES#=A{T54W$3G^`DGmk4#ghRU5hnfk-!$8;17OdXFhaO
z+t^4%@pkzXyY%Uam^B`#*hFPkriHjRr5qj{dN1FhN+;i;F6p6mHr(eU@y&!tPiSxd
z?5B8hu|;LxnwVdBP#9jAwA_63tuq72yJ^t+v~`;=t`ED}Pi2g7sG?`15%?9qtx!MA
zqdV+Q10?iR$f8ZD;=YD7nL_rR?T>o76e*Tpe?{X@SWT)2Z)Z7Vdp*hiUMlz*qtA)w
zZBCF2$?%b19n#~MV%ZVW(*$Mo0Tt`r;PB}}$~`z|?2MY`+LMDNV)k@>yy4H%kQx1D
z%6Abs+xL@BUy3QRJOE3`DiptDcRI^^U%j%uvcDb4(P&ASr*hbbYdcpP7qTCh(6oG5
z=P*VyvnAp+rIdL>UAd5a&Op0rzYruVt39EsRq67f`%x#Ctea!(mQ9Y`4q<`c8s^%p
z@Ihg+`v>y)lM3=f>;kbZ98szp>JYM&+q}9DW)D$z$(#kLQ3l1O?Dhv%>1=H%QrsQ*
zA*Zy4yowZz56a9MS|8u*`kb9Ve2z?n9?=NL8GL;<j5JmPetr+X@h#V}O;D2uhtW>_
z_u$8%FD3R%;|c;%4UNG+T`;Oi=u&WLq2G4+7VyyRNgnWxeK9?KVN!ftv@!vKlHvB#
z%lU9E70PsdW@vnY_v1Tl-BT&mE!k#qUshp|C~m_Pbmo*#?}*pT9K%T*leP|h<`kz0
ze|irTSNpD&Wci-nDY?BQPhaOuWx$hu4&M}-301EMqt{V(HY}$fi~^!)8YgJ_pncCq
zUcPAZ-%}v#fyhY~OGpMzHE+d3D*T`J>I;>*F7R`dJ3F>SeSP_OHk84wJv9wm^M&g@
z(>Bms*Ue0WE$N;H)n%eF@la&Ro_@k42X;*ca#d&6G|ybYgsI{tb_K`I2j0}aAN}B#
zL>}VW^T~z3^Wq)_s?C(SP#8rBkRThsUWmY6!0Gr+Ik6F@*Dwffk`exS4in%bgwPR^
zBon_jyz!(~rQUaB9*;V_S3=Jft?OJxf5DQ>l`GYFbg3gO_iV7>8J)1wt#zst_0g?r
zN(*-tFCj(=3eT#KrXle-6AYgp6kFeCqtROCm*Pv>h0_J0%t<&fw4$w)Nb_rfP;2`m
zFpkjL@he&O2ZYfN+LK(|&WmH;tU$O|cE_JepZCf3T8jzs4ydn2o?_9`C>y#-*ru#0
zID~DP>>9HBPDxweB@xw?=`3AAvFO5;USa4xLTOo{kzT>gYC6MsOp{u0D8T9y;(eqM
z%_vARzJb0=G2$UsF*<Elo_0`6CbkLAi+^v<lZCmC`5_j9n?wDr2%Yi_V-zw_RgOIm
zK}Ki!Jmq`$m14Ubk8Mz75c?p$gG%kQ{(}zoFX79Rko6vrEKQ2ANcFp8lCpCg%k!Z7
zOZA%Fr`RcH&(JVvWAKVmZK;axalSI68GA8q|DtUV#N4vm<8c@MPH!f&-nW{;jA6-h
zTf2j!DETlz1us#}sT$6^pqdPUsPSnpPu~~PqD`^Sh^_@UpDUk-VTO^5Tj~}tGC%9j
z5on-$-*SG#u#I~!eqye^L8^OhOdEfDbTQ!AmgSodS-y9uZqknAZoQ*h4Z22H_j%v+
zgC|C~Yl=BPo4T?BBmxZBMD7Jk%C_SwcROwd#K%ugXtc?1E`eW;1R74tMbCFH!6u(u
zMT)&5>NbVO@{PprIfqD#aONyJar+E+e-Tl1?e57J2bUwAOCtV|_BqgGEd>(<VuuyU
z3PQXIzLT9xe(?EqDE<Lk{tX?*3|N;`>7AM))wpj1O3gdE8zKu$#9?moqI@w!VQ!2L
zWBt)(YR?AT!pkBig>S5=#%{W8)%Mr!AJl&-<x~myStvQPGPPfK>a%rR*9JR(e!vHc
zZ6+oXbNU<v_Y5>JVvmYq6HZN0^b6j00T)8H=ObR$C~q3&&)u$UgT6TR%=i1Ao%KPF
z$g@_wMx%vdTOR!MzSf5Cbe<W@6#er$9qy;F&T*Xy=rdMNsRprA&nVPd{T9p`g@zY8
zd9BCVoNbT5xH)<pRTIzv!kTF)ZdO(cx{d`eT|M*SFS;u6^|p^R(5&rwttyCWg9s4>
zI^V>8*AJR=Kzg@ej=)o<frZFhxkX4kdv4$$geEaUFmY#o2eXb=vYr(;F+9LHJS5@Q
zd}nyy!;^y?zd|Mb&B)I0r<Jm2FPorGa}J2>@@K?edOyU6XteDAM5#K_Y=Lf@6G=8`
z5S^&DfL?NImgW|g*XGV|n?Mw%XD4eRlT-mO_Oade_ApSZLswXKom4eK{Ezc31o_73
zHHV)t-;Ycv^54}PyM;mY;qx=BG7k^;GOI)FD%N9kF)_4~-o?@+uw2V{YG78mtcj`N
z=?C9JIAwBKP=R&hvQitAv>oYGvFn3!44#Bg8cV9n7P8N<o*+|EU8icOzXI$CqS%Fz
zsJc2oFVA1oIYsT{G3g~Jo$Bp;hRK;NrfprqWvCGvZXD58?7QkRmC6F{pbE(%n<9Hp
zCeB5p5hGrfBCjli`Z3Ms@rKqMF?6l{V*~Vdm6yC(pHnOubS)6iX8kTjK!`H^lQ~o}
zB|nv&8%G+MoD6k59P9zo<AP+*A*@T4M3yJwa$_#?F3azXqC3o0NJRG1^Q}3>QKCFV
zYtXXS9R<|Ig3Xtfv$Xf<3t8Pp1JZJx=%_M76vy}j>xXZif3@da*$aJuXFe9k?qk6?
zjgFkV`b5EePaRFyy;+#NuuHbE2f9fAFxG%9!X0ewSEDQZ^^NIU^kdOu4G0V8skW}^
z+=02O{$act8HrAHKaqe1;{zf2-(?{+xt@*EPMat?O5|(;@gb!7Y;&Yu1}4tBpSznq
z$6UTL4uz(r7KhzsFq3P`=Zt~heb@<iCsBtX?-a(6^cjdG?~OkZ-nUe0c<T_3eA^&+
zO)z9m7yI+f6YMr8f!w~g+~E*^;~AT3_UZT#@^c;0G>U=d3E|eX-ffi=<%UAwAD4Qj
zZs%7i^D9}>i4KR71xfzXv-{*{zLM+*Fn`H;9@U)ao8|f%@7>qt$<Ko7Z4SiFlIh-x
z-HvM&xUE;I(ja;J<mNfC-qLKH`lBdwJ|kghlgEw){gYLOJf!Y+CF~wZ%SM0jdGtnw
zO^{FZ?co?@GH2bvwB}<Tl4?*n^|yzm8R?vk7T!l(lR~-}#lG2*vDAX!lkH>Jg2Ojt
z?i~nfF$UdE=1pnT7?Qi;Xhl{PIjdek#0qD^%VCXhBkyeSwymM>5Y*ykC)COgyhoq(
zj$KVVxFtw0C6K)Mqk8N-q^^Hj;IKbRU9Yb)OyZ+0Dp9d20f~~2kAh7Gb7U|Pve?+J
zTw|FG1KK2>75y7}K8XnOOe<LhxWzY}JI&pAqA`N=$r!N{coLRxY`>@5#y&~6*$Ok4
zZ|-kaE>>2?vN0<sB*7ZL^W40@s-x7qOx~cYckdG&1=B*xn~Ypk9f%@}JZt(`ZknB0
zzFubF?-bn`{$EaZYOJOtv6{9M@8qEJ@53|&ovF{%g0cqWBnr%*@3HcP7{o?1Puk<E
z9XCgOXMFFVDVNGD^zMC4sGogPOeN}P4l`H{&FB6bKe(8~y-MwIi$6Vg;dM6m`=0cy
z+9oeQH&J7rOUTfNXP**+yJXTQW~lIkRi&1Dr=L$^D27t4?fn~fx}g&9MO7z3(HQk#
zX89bfU*5KUi+pIILA6uf>dN_zt~8ihzc0&l(W51OfGXEXQ*%N@erEN#U=SsDUI^Fk
z=PyL$((`p6{YG{_tQ7Qszg4)w-ucCow!Tzs$kwhwk+*OZD6;YV6q4V&HYNKb#e4LP
zp(KlWVFs_^frN(Dkf*+{*@$lMuB_4FEL-D>Sb~+2PeY_@@ek|BEk88e$U`5GI}ezc
z+Y;HAX5LzTZNw^ZeW>wkN`#N6ebcg3Fpt_0C*W~EDRjk!RVl->DBsb@beDYG_J@M<
z4#$%uhZ1LDp?=Zed|wDr(xlrImtDqF{h(qM`TT)dZ^|G;kvsnL=!YFH{ycYkF)O>{
z!l(Op;)^509z67@gR6g2cipg!PPj24p%QLcvO;Xq@yOGrpcJh&d`aoBv9uP}nKp1k
zA7ar}G)>+5vy3{mp7=+&7*|>P87-dY;=Jg*=UW9{oaeosV3%SDdcIG<I%-L4oYQY2
zti|6(Za>HdeY$%q%DQ(9lsV$rYBLWPBqX;+J03pYHfN;gdmt3xU*+oNLHp~AzBG}Q
z)5v6oSbXL<DQqJl$N1f|3X+0E8s<bJw@=53Bu1(01&_8yxCd(ZB)WwMsq$zVZS7le
zKzC93-k?zW7tT5&L6j?Lx<_*-Xu3wDoFS}M#_E`KG`t3dER0wpdMNj>32xzzu?AET
zkAID*e3iRIE7gW~7D?-eXBMUxmt1+jkvg&2ub@?lbA4%UEn22;8#O4_N7@*z<5g1O
zverQW37YazfDcl+<m-N{GBT%V)F_qhS8UoJN=m9&^%!kPzz`p7GSrx07OkN?R3e$+
zOii_qEo7YSNzC71>F~28$ULK;OKDz}MH3^pt?p~vCc;Qubd`)EKRc5}MqM>p!M8(A
z(&wndsxxzJc}$t^WO<3jFL03!zW2e`Y;3qDb)e*eCSdYnB8nmkwGoX>!`EuNaAMLo
z35}MO*yB#<F_541_HASafv(o&K6f?`0z4HqW+WP|=1ET<`Q4B^WJ39Mi{^v5o}viu
zjC}LEavJ72#oixxwxLSgEelQ<ZDDU@9_3TsZJWs~%lD2;Z{NWBE&2);(#EDADs`v+
z(95-nlCBVZlAq3!sVO#bD=Sv&lyP~AoMiA5N{q9j2oVZoOzSO9wMC}GAbtRmV+wvz
zedwrs_AjP&%$h-X?)?%wx3dIzXF+$|I(zvka!DmqXUb4ZZZT1}3Cg(xmLRy1%z*!u
z+TnV&>&TGB=+B7Fk}uE#nAcWz;}TYdMbYioDgu@ETc@mRF^v_otv3vuL-}J+xXA45
zNmQ74ozk};TI-}nBfXM=xy;)kt_A%01eHg5T)E+ORTD!NOqQV2H`sWhzP4EW?l`=G
z1+yCxpMD$Nmi3@WxOb$?3@`mj*?9U(XMOcZP*$&bnr@Zcx--e=X%hi!>F*V%k0b4a
zlS4y_Y97G<D*__}wWj3eh0Va97pVpBtzs9kS22&eAsgjAUY_t5Jz>Y}WxWmk?GAf9
zPDHT!*y$JR#%&4kU6uo2Z*Hd^$o7+B?x!HT=<fHs4xfzb{Is5$j%}JYZd#ToQ&6xb
zheb|Fk6XUCZQ0rOZhVM$gv?w_`-DwmTSiQtZDM7twnyFYsF+SOyrJ%e<_06jonwJz
z*xf|Aa~aiz`1LYYy7!i<=h0YtHpUd~lZ}Sl`wrauzu2%o*pM-)n(#_O9Xn?4Z@S>s
z*y69XoTDJFXG<Ny@yOS=<8t8iBmXG~d$C)0{%x-@HE@oB61Hy4&dI^r(W9)!%~qkt
zqpaGlG^EzuzQE27=V<RzD+gbz)N=n~pRcDW(;vYX-O}x}(SH?P_D_;mkqQ4P3wzP0
z_iBF}4hDguv0+HBiC|99o2BY6Qow&s)L$U@?H^Vs11IWH0hBzf&y5k**2PqM7^42~
z_TfvAu_ZJEuy+}_ST8~57RA@iIP%>=y58>z>OknfEzw2j4`depd&>XP?4@UdDA)N~
z&}95;MoN-cpSPidKmkB?TZv2kgdLQnTlSsk*GX)Z?MT;1@)a2S5-1>02XJUa?2-h9
zgJD>GM5PHe(g@l@@=g$fxbN4EAeh?n0O9#!sVIW=Csk?)&uOjau1BxpYmw_GAjCPq
zDb5S)*<s{8#HG`PaR?+VyAXsBHM@}_7@2AM3Yqlk&ElRnJp_6neBh!1!PNTbuEx>g
ze@71nuuI%dNBgqMFn|Xd?4=2{Foy~kdv{mQ4hLLKnXBaXus|P|^6+hBV923k46!G2
zkODwr;L=n<LM8<Lqx+(|G0gERvDk%_i>7u@TbfHrT^=~HgNXWH)nfp3Vd+(a)qkae
z{E>H&4i`^=_*}M&;>TAl2DrT_g?wH1e;GHg;J{toAI4?zKg<80co8>XG+k>e7yIHl
z|Eme1u<|uDki1B+S1mj&*ZlZz5yC4t8zz7yf(0}ZUdJO8BfJ6wcLX;t@!O;Xe;IUD
zstE)VKp;utUy_6|X#XPF(%OC~Ljr+xfqW1~AR&?c(S!|4Zl$_z9YU=Q1kO#0OU}Qg
zHxO7?MHWCHUIdms)g^1QiT=8ltK-f86mGntsM25JH=5C5Dy`VpIsZKlcEvGayX1(q
z&|Jq``&m3m1wcc<#c%}%?qazA^#s<{fS@D&Id8S@#h?Vfi!=zFmpqpoLt?DI!i;dt
z0)d3b|3?uH(SJwSKf8z;nhAiRZ!LKV+i1qWZvX#&9sv@P9YJi<{Y(6M3*~h@YPQ#;
z0bsipAo1e3+*Qjryu^QRM2Jrpwvl`ofIkF2P>6VK697*Mi)kXgF8_bi7a$lhp1kI;
zpT<nLuDf{geTNmc5wl!a0X6?8pZ{d1xxEcShF)Te;iQ1wb%3O9Hkf8R8tepq^X8u{
zy98)n0+OG=Olw$SAL0KC)y2cB2@k06dF3~77hwY{4xxmpzd(F#7bJu^5P@X(6d)-g
zyyr{8_4yEiK;{Av7+^u)u>K9$1wPK+peGYZzYLWBrXSe#(#_mXVgwgyyDnmY><*g@
z68}4zQau+>hdnMGDlEbM%RW!$Ic*aFLJoWz|M#K3v{T3vHk&E&7h%C{h-DTS0gk{V
zdr_(Ws%?408am_=j63Nf1^nQGz3OCuiNbGQcNAfwz7hi5jfBH~w#y;NLF&D5<0uA3
z)hl&f2*SjTAOs!<yz{@UhsD<r)d1Gh0=deGKrl~&#pH4S9l@^73)MEMz*Bk{W*6f4
zO8$27P&)VWP0oCyy>6RqAMw&E;Jr5xS#bnavIUp;;T{A$7m>9eI$+utKq5Z^KA_|h
z&sB{F<Lv-n*HM$F#($BHuK{-?5I9q1f0BaYIv!ztfq?J$4B+LiW0x7Qe<=VXQ3a6C
zhk&iEz8p>k?UV>FNvh)_7!PVL6(76Z`a72EZ5IgldSGCY!MaV!{~BC~OBDpAjljZ%
z;qgD~hJP0+*H<1FE0C+E)d&Kax!c%VaJg8TTiQ6eaXYy@b+UAEv$1s5Q~?8DuM4LD
Nx9~uqLI4W_{U7tGVAB8q

delta 24396
zcmZ5{bC4%MlV#hsZQHhO+qQpg+qP|E+P1A}+uhTco4vh=-R~-*Dx#t)^RE|~ukvM$
zR)B_<fFdZ#f`Y*S0YO0l(KM$?CLs`_{?BebEmK7h2na|$Nl1m~0vqJz(FGXje+)4G
z8T>m10{O4y-vIkJ9bGILLI1xyNi)PS|Lyd@ERx=+|JN?1l3@$$e-20Y!q(9K`E&Z`
zOAIJwaFhT^)!Wt0++NAW(aGG!&Dz{GWq%Y4P^N0{h$4&>fI$^8zIaq+RF}53=A(8J
z?YL-!105Fy%`9InFDGbk3~E{LY37*p*zg=<&-MWMUJ~0Pltu)MdN(|G&G$6J$J_IE
ze71fEH05PO5*G{&3l3^ay~EKIABV=Fs<n2DkE+{gOM)=|t3AjUZW7brph`cyQ<cvQ
zAhj}7ZlqQ18|1aj&yDd&FZfDrvOWy)hS>G|9DpWQ*^bFvOZZGmuJCHUfvn<9LUPw?
zcvIaDmAZaFlM1(XMTFFR`b32?;;oHnK5Z|(_Z+sJ(krUw$#@MOFp-n<1gn9St}Ak*
z+GRkMW15Kx0f(#5^b-X5?Ld^u%U@*zI1m7p>StAz?J9;u<=r)=nvphRLL92Mi`2{~
zP&@^pv8Kjg(JIApHDji0PrFRz`7?1xLJZH>s1z*gc@NonU}H8ev^gZow}elC>owH)
z2^cn?_}1VCuAR#T67>*z_Fiy_@W)#ElOMkO2ToVPpH5tw(MmlU5P_91Fa0G6u<>A#
zAW_q@b=6KwPKgXv<*R1?UD3)_eQ{-w<t$gbXlNk}a2|QCTO!pd&XY|yK*MOCNBWdg
zfYa7V2_YIc*QqlGvC|{X5kmMt?vhcCI~gGU*;B|h9aPvF<5n?rx_~>ah;lKh)eF#y
z{{`m|JH=0li)(GX-1a*hnv{NvLU(W$*xo%60INB<^}9@Y1U<7;0b_H8@jt<t!U=Qm
zzp&QQqn`)zzrcofq`y514g~b)AO2YX3vB2qPADV*StnF;yubF@6xQAL#6rYMc0ggR
zO2JeZ%faazCRRFy@MYlW9g`gT-Meu)^0NL!0+*le_vd*fETr^WkYm`AlH(yf$3YK6
zqu7l3Sd0WC`yDyy{rCtU1b@%&{{G<*{P|pk2SPkfA!;vb0YNSuSvryQL^8m8I~GF{
zaEqP>NIPFb7iwNx3v-jF_Y*0U>?Z^P&4DSCMzV9^j<9-hNU6?)J0r}07J)HQp|Jv+
zg=OQ2(TCF{4Lc#>%xRi{brY5ZU<G8Ntd+)7^31!FsotFVD7w3meUgW&oTV|7m(xlx
ztl8>jC)p+`r7^_?*I{`S6l1DGqqlQZXN&g$YKVkoWGd%!y7SrWR&i9_grD1N!Yv5X
zl?dc1aQ~2bp<1Lzvs2G1^~98fRHtb`xU0XjvPSP!Xk~Y1L>l;Nm85A+wYoIrmYKP;
zb2w0c^xBMWF`7M_2;-{qvgzATo2`fx$ug(r+8|ddIzyps6+7T%W23sz-_}{#`p}sI
zaI%WctHSYRsk#~X+Sz7e{=6S}vzsnw77*)t<ji6vAg4H3NRX{`B}2elhNBNFy#yZz
z8OKJ-RXrUtv%(rjE~J9YuKYzLf(AaEXKx-;iLK?ngt$uPnBTn79zp#jJ8`;0C!FKN
zm|CZw`8Vpz4xT^{-`JLC*Cq3h@S5l>U>gTF)PJ$&1a6c;XXVaDemukC<=%gF)P3of
z`p}lLxrvhexrH#l_KKQr0nxkf8eX`rY<o@umt2s^Fdvkwlyw~mD=nk(E{g<~R)cmc
zOBu^r!;ZUeSaU4ZBMZTh0(MWMYA~Om3^wDh<VNQQGkj_rAB{FMG^1%Mlh~UkfaZMc
z1Quo}6~jd4ub6;dvSagJ660kV@r;9}F>}3<ngG4z2ONWpq+hB5y~M}za?OUfAGg#v
zCVpql#6>JO@vb9y(NK7f&d((2)n?(Vc4m5ub|!IfSsG^bU8J|U;&!YoVsFmXeK#Tj
z;|ZSTy%BHU??Ph{6Q2)Bu?b0*fcy;Vu+Z|)Y-fbwqx@tg40QH}sj63K@n=PAn_~Ew
zh<U{%2lLdKm&NcC0-l0<N3$rJ?$kcD5;Y;_y7r4?vTLpOQA{ipd>)?U)!JatpPArF
zA4-^Zo~dv~`4B3FjPk2&+L;Qf2_}>l(tdl6Wc6^rt7?#$7<>8B+_Re?0D4^-L8rIS
z^6)kCX?1U54b9b6906+5s(4C`d3E@~HUw<BLF+1NH2(~?KEt|yOQog{?s)=YMt^6j
zYs1@V+OW~D^y(U!Ac-}GEPsgKd<b7!lJB5XNMjz?K>K2Qd{8806nSTfSRRrhCRdzJ
z_P^}|S<H8AaVm(}9lBr?0j9g^srt^Tp1d{&_1m2elHl-~%l8B-B=tDijhIdfLvg=z
zLrD?mnXgOGcD*j&i!y*GSwZi9-BPE{|KenV7fcAERtpW*D_7!%@9K%#p;pUFKQf>;
z2!LOm6`&@7g6x-sWNhmnV?4}K6ZnRkWv#@vf~m_I+v?=J&J&?B01%X4@<{%<oj0aw
zK=kcWDzkgU;n3^nCB0^wE%Yb^BWg{`51XX6g9-DdD4uOGYTwy$#dk+JLN_knxx^x)
z7^gVgbw#RwCn3-?pzvZf;8tvWq+tEvE_aT}>JHn_^Ct`#!aw`zXvyHt8i@3%@5y|l
za^3hP$Enf`4Vn260^loq=d2_A{BXQPhD+iJ9#52H-5&|*4Aqc3LgH^*)C4gs!QU?g
z-9MrV__h4J9%X2Ch~eEa`5DqHIQbdV%lrFVG{4dX5v0{GB>%M~7?N4kFd=zNW=<o&
z0`!@VyTW41EApL#fU+)@Wq>#yW2_f(0A-mt^_VH`H}?l6mCau=Y6F$aD2?Y`<aYW2
zs4@)x>D}YjbI(ef-grndy>L$VFf&H*n#$958~Qj<O6eQ&zJy%1?Y4dB(sY*9oo(#O
z?NUi>8fK!4PQF*d|I7$8@CFh||M<lR1P~DYe}{a=Nt~7fqqP5>7?l0-txx_j5bS@6
zf$6_*<>3<ou3S;o(f-=!m<@YOmng}|gh7E=|A`Dlw}YWskSRkXQ=$v*mUm1EGvl=5
zXhlaac$fGdf{P#46yOdS#`-lk;rW;9#gnsWHfGDh=eF<6ef}fQb^dz)@7D)r;P<=s
zFhgvmm#8SJ1Y7P%Wi%)IJNZ*81iI-X6N4uz4TX9xK;t1jTq73DS)v|VdQQegAtb(v
zXwKFPcX{br1a@z56hm*QC%KoBk(aXU&X$RZR9a=2E>tbwRv5+_y*zpv21K;nyjv2T
zO|rWJ?LB_GMPx9Xc^L&Y>^jzI4u=)nWozuZG%1S(Pc?s9t{{iw3C3sKjuKs#d(2K^
z<P@J2kb$Z|*Ocig{@QB#bdXH~SZbv5ID+A*2-T%kZ)9ch*zB|zk>lksu@LL+aii<B
zpx|)$ZH38J7kULnT0^8(#%pr|;~*`@9v0NbI4wyTftgHlmfbF{{e<2`<@!*HJuEY7
zWuZeIy;6Hfu{@;hal3mRnW}a0oi8<J#8o8%(9m*d%b3iXCb>}AGwUxjk_`({*5nGe
zmEC^nI&m{!F;lawEi9{Tng}&Vwn1KSK@YUALuvq`W}U=laBRadcj+dJmVK%YW;o5q
za4-C`Rpirn$t`)|q(3C59j@ziZtC@7QomV|-UzFpl6r9IBO&`DtBT(ve9l?7<GM5f
zsPN8+rsZKVTDG$e%?OUSY)yW)x@b&Vc2@thw^LYw=2j0DP;S&^p`ixFYtzD`!Nl6q
zJn4bR8-Ejewmbx5X=j?=d@tiZ>>7I#i2&&>t%nb;mjXOXyOC)aerN(H72K*b5gsQI
zSa8NCtbUgoAMY$WLd7o#*7ggZcgOn$z@+J4aaMKdA6lpBUwokNUw+^ZP;!<XPk5IW
zcDq5$3R-y`0O>=KMZj#?xxiz<)XLqePXv{uXfWE2u6$&dg$J;ho|Um;$BXawOZm6B
ztv5|cjoUs?GrF^X7usfM*=0%fk+2uTlT;q$%JaVV`pFr5;m>=8_*F{t<~-d4w8_iD
z6F7fyrz6#ewyMO@!RXdtxj3X-A`$wh`Hb4x)SR*Ow<Z-J!MYu`^p@eopA>mEviv!=
z9+r-*0XHTW55d!ru*PRNR)lPHoJ)0ot-$N~#l1m*ZLbv;*T#30jI1#w?+ec<lb!r=
z_g(OZ@k|*wmoqSDGZF@YlgTgzAj&tt&oD7SLFFQlbbClWrha&tAQ1Z4L%Ao5bDz20
zl%U2)O%&`<e}yED*k)DB7l<hQ_@gDV{4C0rARcr74FZ_|CV!uVie(heD?d9Bb2LQ0
zdT-bb5jaoDNxYln52Z{mRAekl+q&B3Kx;~3;6Ptodqc`8XtnnaeT~`!khBX(L<9>P
zPP}1lqwNercflr|+`)dtoYR?n8WEvU6<;B|hJy5y<m0M|+931Z7WYw>zRJ|)srkh^
zvCi#(zA4Z9v!N#WpId@_doAjUa)k=FDv=0hitt__ly{=yB8^d8Mnvu~$h;xP6M!tu
zzaaToql@R}KK<4ssb0STJWvR>J2>y`jtTFK%62NwLULUP@j!kUuP96l>|sb^-k9v{
zN>I|jJuP2R@Dmi82lhi)@&7_8b%tSFj!_I&P;795KjPdYuuKwpM;GN9I?_9OTT||p
z0W_q+YAyNX^_UtYCAfMHZNvYC{Lipi=FQZt(UQa%`oE*(oXb@-IwTN~0|F2b#s8zv
zqwoL*Q#)f<*EEd}Q(R5tpS3k~?-Z_R*NwIi6UsQcO$=#ODrwaFRk6B;KQszkowl~5
zjx=}OJvAfYE~r#*{$L=fpAeWj)FZ9H0lyPK`Zx7;+i8|xA^SM*toLR(S@&}~{{GB=
za{}j%4IFVr4-w>!s^CF5j8OLxi7JPmP{{!{+s&F#Mq`{uloRoF$tWQ-PgU@gcT#V3
zS!yMkFvf-b$l?>G0G1CbaD*{O$IgBr1+j;!&VD!rNu!qH-T0$tW<P#-<M+*QhLJ}x
z%6`=0jN^-84I}sJ%0Jm~hL}0~NEbQGezK>I<M(-3{kY?A_x^*<l;MOU_oCe1l+l15
z7=&1@7#-&cC%tVgs;+Qz8YS2As_hW*S!XxN!6ey~Z&A|WCsx(rl&6ew$%wOxa!Oaz
z3^Xzc2P@7tJ7rebO==t_*faEN{8qW~RXI-$+H^PYPYR0h0z87;J)X7(BioN+f#dU6
zb6agTKi2Rx{~@YNHe~M|Ciu7F;4y&OTW#<{VOqu35AyKJxXd(cH-8;Hn)?IefhGHP
zqI)B@O9ou=End^L$eL$bpSdk9ZFgSY!cJL$M4Oy^PCP=XM>mG!Cv0~QE8$a>Pka7@
zrG)P;RjQr5+q~yM-8!nHbmwn7=N@!$_t_QqN}~2c?mw9nQL!i1YnVB9(<T6{_JQar
zLOt*$bW`y`ugkhsUrgt<D!*1UOh(%|6!O!B41)UOvfIPH>F#4IaQ_La^Z1&=VNI9k
z(PaBh+s(xrfU00`<0%X;Zao5(64r5%y+(v4=1UrpAo95D;Lz5eW_MLW19$i3hb26g
zzH6$P@MP1u;HgjUE4aj*?i@f~*31n`bE)eXgF}*+YR;IZmIt^q4!%)X@3rS`ejLrG
zsEQInZnMm5F++~o9|VM#NoaITC*@IZK7!E%HMrw(n*3pQbXPB(QB|yC@jVCaQN{b{
zXmGkmne}2UD(ul-hnn}Q^Dj6-ONnNh0OA_h_p)fisAt>W;)9tU%TB<?yFA)}I&)Bk
zc6W-xE1B%No;Y*Alc=Fv$$MV({xM?jdx>a*#DgR{V5mU7_E;SqFldP0>Lr<e!N6;T
z=2BjR3HD-J>;&8Zd(<2p;+|PpSl7*~&7yCrz5i<YS*T8Pno@p3ks-BHYFwYXQ>vIJ
z(4=oHLA5iyueLKD9t{|fmAH-RIo*P&I)d+&b^*&vz-$?@SkK_RrXr|(k3c&I`H^;j
zVVxtF?khbclRbqkcaJejcFZsVuh=`3C+}ACq-RH5YwZM1aH6m3Mr%;dzqi6i*0eAX
zzT@pa03ImS?^;uHBJQ#2cElHL`2jZ>eq@G#B@_kh_V>1ouLGVM`?hPgRa-)mbErty
z>2pF=?}K=f4DhQ?oW2Df7XDgW1RPI#C!CU)^7Z*jc;19FU$6v-!j*NGkxR(Xde4@1
zIbB``is4K`?vYgG4!BaK)xdJ--<en5$}w)P(R<tWfpI*r1|2;8xqNqL)`sML>K>=2
zw|hMtuF~@#cm&vhT`w8ZS&LVU?O6mjT-PpVA74%fpitVypgFC30JFp#f9>&1Ird1j
z9({Yk)zWCfPdNEIY<Fh}dT2~B-!?6}d=Y6TIB9T2ETdC3_*4@fVV%Lb5slon1jtl3
zgaX64V1SAS1yNQ~cRMpD&h^HJSEu=hf|FUFaJ?2Tw*cHW))DBU$Qr>$nCw3|{>myU
z&vh(kvEa}`#g+TgKqZv<vZ9O4g>fL|r3{#$UvCQe)dy45uduvQygFOKJ5!kgz-P~f
za=IZs&M7?3eN+@*l*~XO&z9;A*QCJduXGPviHDd+mAab<t?`W0As0i`Ei^@Xu0!@<
zZa5g6699UHvJ*`h@O<v5iYhk0wNn(gOyy>YUL-SvnQpE}smh?(KX$+;I|l(Gxd~-a
zjZLwl=y(LOc+dkuC9ZK<Rb5JVEBvkX>#4VFvL0iiX|IZoMLeg(N_^7y>`JUb&WP$E
zy_P}yJ$#gupD6Zk_X|`hYXWP_x)S3M@v~u(CjfqQvK+-!XFq>8P<_`Z)Y`>K$o!LI
zI*+sX+80+mAyj6z6rMaf56o%$_c@k+s4eCw>U=8`i*jaBI{j43hgeMceT+W>ejB3u
zM26tNOSUT*#cgINh#Ah8BA@!9tXElMuPiF7y=1*s`6h7^R^F*y1aDuI-z~ZXI!>cc
zNPx02b-t^`oC4w?#+)sainxz+f*a)1-0ltG2>vU6{GzjIDNTL?3o|1%V~J9ha*MGP
zq8}Uet@hq_V}ki*Nvw!MZ#`vi|B(T;uzjwezZu>NEG((gNW$~@BTEfM#{4PgFB-EV
zZ({rWX0%>+-KpdUen)H<dC2tzo4-Fu5&3Kq1!T(wBpcSXLcDW{;xEJSw?ueC{gi-r
zc>(x$Pg>&<X>ERJQ-A-zA}QBi`z~&ZuOK}D)(`EZO^~u@bCYhE7HMe8R*b|uf)fV`
zUOI6DDe<0(=+ewHIrf_Lb}m`0PA5iYwO>hhQKL4&gkD`)dVy-g#=rfwsI9GSRm0Zt
z>ZY&n?R9ValjaRz;lY_>hIGU@@NIGGn|t;*_s-AI;QMn~GRle=fK(_jmoY{eM-m4x
z%nk-&1GXNUtiUN`A!xV<Lwv}Y2dDalYHpXzmIA6bp<0@Sb3l@hQOMh=m3;vN3Cfmc
zIq{VRGynK>4K!~of4B_lhBFU;kIkp(BU8$)diVjHJ$wwRH)Rf7eeCj4n^>-rUG1zl
z%MQbM|0EKIIT<?&oINjF3aBc`m~;hnMf#@4=HVBb)W1Bzc-PY%xO%Av&YwJic-5$S
zxd*0)V2)juStph&Q`I8FoPB!NJ+o2!1q~HEy0#RoOH0ZI&K<uj*+Jch^(r5(0o9#6
z1niN`&n~Hfd%-%YzmtS*n=Q2i)t%h{+Z@KA?;#gz9BvO~ynm>CbjoGZguMWO+MIia
zih%6TJOm@Y?cTdYf8Wp@FmQ<1On>*P<|89hR6EfL;Wv_HzjNK5(w0h7<-#o}IHZmx
zM^T4)QtzM^I%MIV8E7w1MjK!s)V$k#^y=&h&<k|w9NK0E!^hcPa&S6!w-!~oFOQY4
z=5VstId-{;?v}U7h0SJM^*jTzBMGi*t=mv6YF)vX-~V{gSzj>Q#t=vgKiX#bC3#s^
zBpGEd;wieVxluejjZ|JppYQHU6qj!jjK~1E_E2L+UYM5cI-=y^FPsmT>U8zpCrgp-
z6QEAI9AG(q&kYtY$L=YSrLlQp+s;HPW5Qrh{^sE?-)>&*RJP(f1W5!u)v=kDw?$th
zFC{Eq9kX+HZJ6t3_P#tc4ze|E#$wY~S@k4sl$t8>At7EQ(fbUg-nmt*U$UggvFdZj
zIFcYs5kir}?Xuv^l#aT!*FfmzQQ~bGdz7Pen~#~&PT^JLJm54%b&{m=&Z&7!l@=;v
zU87p~%Jg$mlE|UrJu(A^t2cX_pjD$?Dq1}*V$vCG<;AloB*k9BbA`hiL_MD-94OkT
zF+lGk5lV)bWEE_ly-Om6ki@~PnNYQ{BjgIVn(bJ7PH@Y??P49Y)79Qt?@=H`tDtK0
zNdN9E9jZ<31WzuTKeIGN8KUBC8>h_2kce1tFQ-UQr7_j@XS)LeDV#QqJaD9CH9Vjo
zqMP}$O?Iha-QfA7mBZEjZmQxDgah_oSE2e}1p<XT+{!_i+{uix1!SsMUuhOHH?6hY
zo9;14jXj=EwrouK5Txj_iuSEuB#5iH)>q*rSW=mK@DY86EkG{iTr`aMRF>_wd=zjA
zfc<x~s1_t<^tl1K+cere(@FgJu`l`(R+cJ$Ev;^?t(2<}&edZ0jK9KtCS)#<x0k^u
zy=ahG?7R|KeR|>&%|maH0V6?ZYRfx^i8a-lie#t67VQbGIh-aVOo^7o)K=`grrl{W
zSS9*Q$>lN9<&^L>O_+tvBhk3AVk>eK;1iLxNh|G8(`En+(sR#7<4{f<pAG3GX<9r*
zZEd2h+Vv4s<=y6M=shSEoO8DhQvNe6cTp0CNe}m_SgzE@qQ%rjRI?GR@TZr}1KlL>
zpuS>ii1a8m&e#H8@&mHqwg;;7SWkh=<Hbq>(bOs}WX0NPpH(>rcGHdW!nTT5J6yC_
zN?kW?Z6p8(NqFgUXiOQCvUK_N4d~<1G~s2i2{h<Je)BH-{jdm?AbQVI=#i_QDfK$?
zhs2D`v$?<VHnyy7VhWDASTY)3(kw6v7dFY2>z}Z;*(F>KGgGC|dTQ+!t_T-XI&}7C
zX}vC%l=o;!S4B}b6RN%4jFgbfYFT~PlpZyNH6s9hLL7yn7#-$<eaxJ0qY<!b%N0WU
z=IvN+^rH`^REtu!xM(c~4DH)2%kY%@=kyvEwn$9q!c-ILR9z5DD@H-?nzXBI_!>%)
zIy;8Wb~pxO+9+oJ&{5OrYVY2ts9rjB2D+(-r$eim6g^=}dvoWi!WqKR>T|D6R{7G?
zb1*<=pvY65NA8>EJ2#+ciHN^s$^98St-i=s-6xbl{X(LjAa-2MX{va>x;4i^>B8qv
z?NE<;e~_cv2gP2={n_thi!{eWUG*Qn{pg#I5t&)gTIq9t;S<Kkj6(7HWT^ACHh1+(
zRkWYxDc=tcFpt~NTqkg3AK}Ao_5P57;zxkyheF!hgZ>1=t$E0hXU!M;PxsW@eL&jX
ziKCQj!PHv}3S#9K(Kj6K;KET{Ri?Q_oZXN`_qCrcC4Gm+!f6KCneAa`(u#?*tf;Wf
zg@xR*sefkruK?T(JdHZ`a!$k9Xj^=#-`R^X{ya++^fPl;H4<6OBLM%;lXH!a96x{%
z+-u_0{?WG_uL6}=wkHbRk<N39bm8OhmwnnTappM@K=MS=2>rI1mY&tDLZ5!GsB3be
zXju4gS=NNSiR0IbyMo%?a`&@-_?iP2^XyW|ZnLE=fBCAqK1z%1vzS^-w;OC+(X1!^
zuQS`-C@u^ge;m49%3i!i^|C>YJOV((R`yC=c2=k}N--%OYC3s#exTJwC`9bW_0n`(
zycl2gMRuAL`KW;cygGffb=PQlcyqM|t#tYbOO|p<v{HEPZSAP&#bf=N2ik;{yGI;{
zjnIiCcw9o2UnHUCJ9JtB+Bo59!1bDFRtrPY!Y7%3HJ^~6>Ialy+2isf2Na-SF(>%9
zP!F~&WYMoPY`X=@YUl7l2GxMGi0)$N72^C8*^KHhx;tbVNp*p-dFn6yv;j&ZIs$xK
z>u8-CV_@Sf7lkW=>a*5(uVRgqb6<l)Otl{Y!PKZN<uE+e1@jt@F|~jsLzF6m^wTtB
zj42Esnt>@_CDlklvUG!KIb482W7QXE7RTqYEl2s|A1@k|c2RzB6!0cp$4D$66{qsa
zE-e!j1<8>td=3cT=S=d&%ptr%Lmm?jPGV%L2QzoLle{Ux-|Of<NmGKS1(jc_0idS*
z3gnfKIdBC7qk@vympVU{&%}R44m;F;$_kG)zZAxnN~YM-0PuuQj$i;@R!JVy@5Vp&
zJ`OT-_$Y$Cv<}{iWrB;6Fn={p_8(qo2If6UI`X}Ag+6jFk`g6nJFKoDPhu_Y-%j4)
zPMTAz%H-uAa{<wsU{rX{Q+Nsh73<9j-rx&TiW9t+iu7)R+O`zyF}Dk?TQPyfIFUoB
zrki0=jlLoiwm|RA=`g@<LFXg3Lz}9`Tp!uf#l^8)-qq%a1jp-;5)8JW#p;SESJZ;>
zI^NtV47jD=j6THNjMDxZBS!EKtp41oIb|1I)=_eQV*EW6EJa5HgKe-x)or7L^hXE+
zWO=`n4w$2LmR_<PL4MY?@36Cm-_3%*w6b*y?VcZ3lbepd2Oa>5v8e@*$ue~<A-|x{
zq>8Vp-eLJ$gO7AP^blPjl_e!^(E(Oc%rGJ^{l;~M>T+AMXI#C2gmdzDIg7OcG^)=*
zv+~$P_qL^85LzytF!`{8!s?vyR@6`Ts~KN%Gh9@~VU8Ig4e0w~2tCOgj1g!lHqV@b
z^F=s!_X#bDrYu0B!P<A@fvf*|MUzOA6~yZEw8U;DZ<>pBGm(0OD3~Ceb)M@Z4O2@l
zSmDKojzE+e(>XO;<I)A%=uEayz*v`MJyFz?Fh$aRYOFK|qut=s%vI)oa;FJQ(aR-`
z)KkyMJi<f)4*krm=1?<sd3XM;cr~@C=vhAL`42f>&JEzIFwIotv{IIQGGmh$cai{i
zsf=bhtHLZ99XppBn5;^dp^Br!;_q1!Yva%y@azKtnF1P)D4)w&=cAI6Fjn6cuL6>S
z{OgO>lJme7y>cVlI@qwId9)rRl8U~Mi$0$*n?x)X3o8&SgT=GX#e5R31&0NC=3>{y
zqqrweM-yO>m@~e+wra9%ura0*_0YT;m%b{H)S1~P0Fk9fxI&dM4Ov+L{6eNXI<tOE
zlfXY4=EN)RO@!NaTQN8JhBAJ}OJQ&a_kyC;_ud_!%IhIlQ$Ps(Bm~Wh7LPN_fPm<Q
zDUPv$OHRi7#P~5y6Tcif!VaN8)EDPtVQy3=t{kw0ooGxjTaMD3C(UVEx>F?Gu}~-W
znlmx-nj@8FIS{2s@EnleA4rgN3I#4T=&CL*D6bb`p(6W{!UoKkV%sO|D2TpxI&CUb
zhxmOQ(l4C7r9tov{zOY#4N+NHP|hzonh=-R0>_gc;zDj#SB$L&KZ&{FQt#erexfIC
zSPEbiF81Te>6h~rCKr-D=h#>eX*+S_-G!dD5SsUQ!?c(!%W~t~^Lu8meKk2*Z-O{e
zmn3u$F$5yzL{ktH8FUYE)6pFTnzeeMds4_3n}4@`is|+Kw6;)Z8Yr+}c*5|$<NnE*
zGU~5@l9}Ui`U;r}$kvCYKWl|g)Tr@F{{X~%3GXj{S`C`<5Im!QU>drHDm2hTVLUJE
z-Sx3CRLbcrC|cUV(=4$&UO5O7a{c%yT~s6!x6~F*T6KtA$5@fH0pn~R4BfCrFqD6^
zf`)g8&XM4sLM?uvmB*Pan6C&^xG$kweJ*&?i`$`k2n|j*{xQI+3S=lOdxq~$_yQEW
zt<`cad^4etK-3TvLK2UPZHe!ff->0>lV1?m-UmyB_KPD9*Vg=c+4g!m?21NM@;oTl
z0~HiWC<lImlK``!KWVfLkX==EqZsB~hO`dQHLiNorm=leYbPKs>^Z`cpiPo_t%#_R
zK=92kzT}euok#&Kq+OsOaz!bW2L=fAROb7*2JR)VwvIwTY&#|ll6Y%%r6VjJ7ruc_
znxj_u=8GxTD@0TY)-AU*20Gc-`XpUW(?V93uj!Ik8aiRpLl9v&(Cd|M6l=D&doMP1
zw$Tq%x6NWcN7J-@BrKy0F00%j>u{j8xY}3f!H2IeaB-Q?kT6GT@xc}sL;$etfF2#&
zO@BoQq(Kk`2w3FDRrXG4v@q9Lkn)?K;d!HeoozZQZaXK}tPtV-rg}l;BVW6Ou;y;`
zO9y+~{Ip^wXrot`%<$%)evCnae@oI(PaUXS!+d^Oj`lCrfbdsboZ{Q+<|UL0=x~|f
zY_SjS5U$%k%;Bv}?GJAJp#gyPhs=d(WdSjQZ{2l-xY4Np>XvK@;Bg9=k=TWMf9CEz
ziE+{fzgh}-4$1anWW3_9IFo+%Tj#iWyZ6mEa9W}s0A&C_|BDpKV@c?Z2(RL-D}GoF
z%;SmQ0k`CB-)~t}Kdah_Q%_qPaeOckz6NaL_PCAno3r!wtLGe!j0<3%xHhCEABOq7
zTrslf^{nbDSjQ`53sF^OpSadB`2`Q^b_isjDz_L7o@0Z~ynouR^EXBfPYtGnO9}Ch
z?x*#Y#&2|KD9kpzLTiL=doTR6UV|NwjkFV%edgpYI1Gc}4AF%?sE02kmq@+>Aq3}N
z9?<9|yNFl&ura$4@@Iem-!T(0fBK^U_O({hAz!4kb>e<UVYxfW5xz(&FR0f5tX6{I
zPt?X|<1cuS_;H{SPoUoYV_Cm#c&Aq)oB>6~q04pSPwyxLh;e?l7z1Fm?}PM0%?oy~
zu5^zj#Pf*zX0x>Q3(0d{yMgbG@Ye|Kc>q*p^jXCM?z1ZHmN?+tdpO)9U(ce9bI$%9
zWurjD>jJs^+Ii`-s;{e<X+`m{7m{k<cfpkj*C&i4q2$**b2db)Jfw|Sh&4hOn`0Wq
zg06?w$z+&!_Iya9N@G{=P<(_9U#xq+dJ9bxbgqHJaE;3v$$@QPZ*!25?jzpLO_J8&
zN|>k!*TY{DxMu*0R$r`<7dVA4I`uU>*;j@&@(Nl}dZ0eEMW6gY=mshhLGl8>mMg_K
z3<6S8hUIKqZh(Cbt)j!{a?hUl0hw^4XCjZ;z?EC#D*44`>a*R^iAy-K2ai+2b&1Jh
zsfs}HLRo={&;@P?8stdNc6c280y=1_5HQlSj3&!DE)hWXAfHF*82_Lmc&Z6>+!3?9
zr*zqI0Q`F#LAV6pjoV20UHg?aP|piBpL0-#Gj4-qf9QOh4cZ5?=!5TE3z~ku=q-_X
zAF^yeWQ~wY;V+O3K*-^n)XG1U=ZaAHf>aF&Fh^13y<xLovOm<$+c^7!P(wa?H@oG`
z=%2X9^$G~C{^fvjS%N6M3X1(2I7~?FOVQD8{H1ts@Ow>nff9*2>snlXQAIgSr`SI0
z%^_P!+guZcA2R+gw$ZsbT7?9LGeG#$QR%gT%KQiQWM`k~5?~$#RIH6GTet?SJAy*>
z+TYhP+vI77Xrv<d*X(S$HZtYwdA{&AawC$PfDe%N2xDjUQ=~FtiJEK7x{^!%%xE1B
z^KH9D0V9?=%huBo_-=Tyzf7zWQZX}?G4fkM$DM+!wCP>2@alZDUsd;u6Kg_SFGm4H
zpy$iU@CK}lu_kSP5ytH&=Vv@F{_Ozk;*0UyaBBwF2w$2#AQStg@hp*+yu#|ilKMk<
za#MHqyRoGu=kwxj*wgi%d+zt;9G@o#;oV%1%MNrclWTqs^G4n)bgZy99pBSN43E&G
z1HtZ~cqOb;ZS&dUU(o+lu6BRPMUDKE^3$OIui(Ep#t4Yh(AM47K;j>22Cqi>WycKW
z1cH_`s-P-^TgV0-)`*pCl+IHc)5s_xmR?DRdY;Z;{fYZ$E2E!-F}%S~e*cs4&kA7C
zquwlp^Kli?Gb@YNb#A85^!sDpkrB8zh|v7qSyO`1f~=R(SVMyL)NE(CH};=;U@RRD
z$&5X%bqE;#_Tf87j(E{ZL&{(xD?zqJSu?jYQXPVPk#gcpcyAny7=L+J8k2n28lrqr
z`f$;ez)VI_0r6AKF4|lM;VZfi2XY>hV+M|6o;9NFn&D_!Td~h0`^n5wdx2kFdhaJf
zyV0koCBkE^b7QlwqRta9(7F5(XesuTU!L1))dpy=lRDI-&(=x<@6j2;oFm$gzOI0>
zSJz1J;B?T>N-1`u%*M`H^W?bQS88OFw5~8=5cLqB&B7UX{p-dP3aQaoqZcV)gU`X=
zV(reJ9g|}pmBMmT#F~k(Zy1wN`*I3b;w1r|C2zt<Mx1?_p4nrkj>sd2z}Q~YUW)JL
zX$IIaD()->FniafIaGv~cb#nxlWljfFHguElx-}=s>#h_PwHE6oB4>Kdsmw=+*&EP
zt4&{0Lh7pf<YAX0VSuezw<aE2%*ix!pQ-&T-jVEt1QXR$dqH-9x#=bH0LxTK3?eL{
zc%WNtq}+=I#m9n#APQ%qyrTQT$O>b)Q38C<am073#h*crC-^Pro2VuZ0~elFQ0t<v
zslB2_f#uJRKDT|<prIvU1cuMV&BE9g!q(gD<Bwp$4UcHS=kM7cT!s@ch7%;h2~fRd
zhd5#SM?KZ9pMYw(hu2uHYmGoGEN61_VQ|XvSE{Z#V7Gec&Q+i={2?&!Y9ZK5r~nGq
zsrL4~<NRQdkj){;;PVgs5w9VEgMU9-&*O4IX@!5c&AzD9xT#X<`Rrm+Ow+b0HO8uI
zk4-e!k*tsEbd+b|3r=m(ss1!Z6VNDfH6(8$s>NWd-8nTuqLJ!5MRNuxch}$O$dy@o
zQfIYvmK^oB(bdwP9JI{jS3P|3iUJy-)(e-r?|&dgR%a`sje>NV$am_UEov_1-qqud
zr^I<|wz8d#1d4e5YS?0Z_os)@#13te0{f#mR6<Hqpt|$*=5dXw^j2lbNcxH&A@uTp
zS}1nas7qL}SIZ-W2)1p?UXhV^nCV%niL^))*rD>p>o5F3*U$g1A^toG9RTR##;#gp
zmgp9)@p;1UgE8FCOBT<dco!5)j&O{C8kXe}P>Gw5BK}hFMxD+UC7G_&<qoAF0U|Q*
zV^0rfhcN|%QYF8caVSPmCxDp~)<KF5Cy$pxIS*b8DXzvsE5PL+__8VefD43B07I;D
zpXsxh2s#KA<It#uPI;|&Ljb0F6S&>y*#%KTpgx2dZ%i3r3d1nw-$MIjpUA=2!=kZE
z(Vuvtp`9^oZ-)^6X<n0>s18T+%{a7)9`24w4!L9`(t8w)&x%SDyUgOxi@k2qYa@*V
zH&{2`ZgdH~xv#M?_9k!h=lIsBjxN>SdJm9~=U>qMfp6<)#rM+#0PDPB+QR`IGQZ$k
z)8{W|jUW#gSQymOT`J^W;Vb7U{t6y>;}9^<;0Z71tjmAm2+z9Q?|t&R2!X)*V}6||
zyghB1^jxv~;C+vyoe#wSjCN9M9c0V@nwChhfPkp}Tass-giOI3K>(y_dK=-XWB-+J
zo^;??4s}Rwr>3SOw_lnSpWaO;l~%=>ShZWqE?%3wWz*ic4&B@&fP$f-qAA8BK@$_N
z>kz(xhzu;o7{$H&6nGc{b-aI@mE&mHwuc8?=e+g3_1(SukNbZ9c109~G3rBkJf;uW
zLH?y1LN%Bdu!Am!jR1fsI&jeL8c*l|cWNMXL_EUxvP44fWQ>%-dp_0|Ry#HV=ia9u
z_BG=o8}>bU{xtI%X!IirM4WmPZGJS)@+S+#{@7z2mIQsz^dn5X8D^P=V4~fJH20zk
zj5y(?93KDnA`6rpjUEsEMitJDSB%a}n7&qJ`E&y+KqicTe*lEu<0a*Nn!RcZ3Sf?G
za$)^SdHnVRGK4ya0rsN~WQ4p=1L~)lR{VHqBkB&lxqAE#hf`EP%6U(h`e-NIhc3q4
zM<?HhJ^FkP%6uIr3J4{Hd_etT3oM|n++V`Q$G*M6!N0)A+u-Nf>F~Aka;miSGLsXo
zykoI%SW8+_K?UF|Ps^23a8PS4*_SS*r#E|8O~%$6ndb-A&sil%iu{}^olS7epGNo2
zp105K;?D8edb+h54nFGliT0F`h79wEq44v99|bR$GuP#4h$zx(oo41Yp-jdX?eNSt
z=p1ZiOD+A-M6epWLD3`JF3+I(<IiX<W7ASjNff#I=l~Q)+njTn_$*3a$tcijuUKcI
z;-OVzC|~0J%OxmUOe>yl+P(j&VdSxBh^yDkayV{T1TF1ka`EBbLW85T9~x+y-hBN0
zpD$YBLzP48_9GWs?uH~~h-T$u?yh3-vV3uw={rSP&_%oAL9=b)#6|A)zluO|r#LB9
zps)PE&j9FcZAcfUUX7wbBF66dH~HVp{#)YXmhu!>ePg5C-F90m73`|}$x^Jm<E$iR
zD{@p^Mc#QOL}j}8CBuCvwXI3armznN8_=h4QlAg5WBV&@o%Bms>?t#cd_FM>W&i4Y
z$Gq$i^}&Ji*6C$A+!c0Y?Q@K(!s33yTIx#+M*z`$F?$`f>|kA@BopMzEj0zy`RDS?
zlDS6;!GOU^#q)Gb#NffSUOKgfr7sbcwTA6P)E?O!M*ePcw3HQEdXg-<?sao4jGN{1
zPxc2XR&a9Xg^DaxvC{HL1e_!%F&Znbd=c=rWAWdFB@!{&L$OX9?bxc%UCH-dNk+Zv
z8~{T5oo<uYYKH=DroyOH*XUf`+S1N`$!W5)&zr88<kp(X%D^haB;)m{78p-zs_m=D
zT2pN7^3?*Viph=xJ0_d;Sk=F6;4kY8kLa~Of74_zd#URSy8`!#xAmI+i$rTOM;NQR
zwd5!E8qB0B-`N9(dGwvUxKf%?RDJ3j(E+X99ATKD5pN5bPRrSDs$33<a@ZPL`}0fI
zma}vdICvSi=i`p*d~y3xL;Ec@nA-d_9>?Z1V~w(-WnN9u83$!F2nRCg)L1k>fr2X9
zJE{%(Iy#yUlzb&e?w!)31>*Vy<B1mX)$cJ*U+NrJy*Z20aT!)@tYt@z@v%ATd;nUz
z%e1Hqs*)mJoF9gszZ2U|V1HFPe#mjz#eLY4t~ppHJLA%yoA3Kcer1oP!rS%ydT~Tg
zfB!>>{AI{japXOR_RFXv`mF7?6zl8Hho7@<YjkWQ1LMqDy&MU4#?q_h%x@-IZFRJ=
z(5zi$piI>u8C?EHhP#E?)|*9^I~#zfiYfZFbfl3XZ;^7E3Lh(?M1Z5_{k!vW^c`qS
z965gc8ADuSeld*;dzS=fTX+sk9KD_^y*-R=mDkT)aGU(iVUjd|UBnxC^5lId0mloq
zDI<D0Jn1R{fy^bGFIS3(e2T-AZJj^7>a+FendTH&p9^{i%+GY+%Vn1dmI7e3fd;s2
zr~yp9Oa<m1o#`vOnnpI2W<aHmhLTDa-3<ZDxTk9Y&z8lnE8v%MPX3yyi9;>~+H9`(
zwN?nFPYRJwpwjJIsj>Vm1m1IPzR$JiieJo$xat<2X_x-Bb<R$j<|6_vckXnb*Zj+#
zib4X_UjJ3}E|!{M9z$<s1_$6wP(HM#{D3Fp$XwKpp}LwvKekILH1%V#ckVJ8WKWOx
zP~%Ugu5kWVTBgSe__D#!rgLZyF9I_64?72oHO{At;uuVH)EI?()iJpX;nQM9bM7?R
z+nTP|;QGl%i9-LVSD-On3*6CEr_F1On(%h9gKNj)#J4r}Q&-amco|?s*>PygWZo3K
z!n@2v(Z(Vbvpqlh!rS8H8&+E<@$pqwhKE&jP479+>P$Te9t2Gm2c<o2JiwSamYGHO
zwPd?Kc2s~Y0Y<e+wsj*W)}xG`H!x0ozX1I9813h?4h%_*zuh!bEmaMAErsA=fmSNP
z=Nw{*m+yJ9)YIo&RT?lbA=)4=<=`<V>e97sxOexOu`V#6UKtqfoFAElBgCx;OnX)s
zJ6mK%heDGV=7?Z!+Ct@+6$Thf$34@UV-;d`i=WO_-7vjM%(608HzJ|r1s<4P#h4^<
z!qk{4GND6z=KuFzT#|Ygu58hI%sh`nQ`ZbriLXOjlEC8OvjJ@Dt(%=zhV^#gwM}{C
zQyov)nPI4->B}!t;*BjyT^Wax&_^hvTJy$kVc@t^I@ntKBe^F*cJjxVYtwa96rn#(
z76)L^ws0+K+d8djY}!(C+fwq{8k=~?VASM|s^*PK<T%H*w6AH~Hm_$R78#e!hm#)t
zS|o8=`LtMk+yH#LnZn-=@oSxdH2rJobqGwjTIIrT;|ft0M5R2WtIrLAnj>#R?%NRK
z;us$B?gTzlm7pxs3-om+Za!}Z<_lTai8<+n%TOf{7C}+vNNwS$jOI^)qiM1Pail);
z!*)rn9P?Iq#evqcB~-Ta1$pr}<qOQF+v-{xgqu2Q%>tx{8HL-~>sEb}RJOXYGdzH`
zF18iNe(=Z9T7^kZjXP$4YAC#U_`)M?h!(wQ+i?Y#xpL)c_XJ>A&K%8P>$qzeBfu-4
zc$A+<)~UFQb<*@jvv7;gvuvLHhL_pLo3jAPLxs+hh1a%&vp+(Dw)d!dvb+4^y9CMT
zP87w+Ljx>|Bkz9K715h3yrNd0XEL@5WQ)%$sI=8-+xbIbrWu_PtG#aD+HF(kw?(S9
zHiV{IxKKBxhe2QjK!dIhBfYeA9@9Cdn1-M9Wf<tmJC5!{eP3A?Uylkr-kG~g-Gjg4
z>cPp}+gx|#On~4Be@Gq_KggI6AL_D4>@kD*IRgN&H+`W4{i09^6CH8hx*{djN|Iwd
zV{HtWp=n^M-NN9j8p_6zn`+~ZpobWs!yGF$F5-PtbAlJ-ZC>2<&HA1*-PwZuH#<Mg
zL59%gzpCnfh7{5sLU|9ms~56tcb@QXKUla8z20f&51V%mZJqOCq?09NGoagewjeqF
zYyosGvtC2qFwOSaM;>+3@7=pVQe83`dyovopV56i_(@ev<_$vDAMFw?_NA2kxPi!i
zzBrF~8aL@jg-XSZ@3_hqBChz!F($0x4&Xg%#h2vkOY2hAE~RYfDJ~=w3**ztS~y)a
zOs0D`)4XA;SbCHjwKmZ??4DOY;|qKDI04H(VCHqKHMe5op&xzr650zL+08;d!KqsE
z+QhwC1Uo}94;&OTH#-BvA*QBt>0`O{arN{pzNm_@@wC*&8xmJ*cs`=HFDpizM@1|h
z$O#|Umu?LeAb7X0L|ci=y9bvVRweiQKZ5^Bh(mEoYnuNNViE9vjF{%X8S$PzM9Lo(
zG=LY{IQkEy!q&2lIu~^5a4IP5O5$8#T+=TkZ4{zJq(X}z``%oPi~9?Wog3w&bd!pW
zsAZ|96fS;+BeYyD%FSr`Ycxs)PoKNli$2~DOHX&6U3wA2e#F_EUhnTd?>l%!fv5Wt
zptYDdn)X8mbliKEu3kNc2Bmu$bZ`{CK!7GS*YSAGw^!UwpT_8wQwQPO`-2a-qmnX3
z)6~6$w^u_n=iw~OUUBgf@PPU#La+RzUyt4%afWAgC*qyTy#x5&!*Kw#Peb&HS3&Sw
zjaC?9rB-+g41tm|Y1d8!BF%duA!2pqXoPwxGw}e$$z!4(!K>+1LPF*JF>)6`4KT=!
zPB>~xLohzB=7(3H^dQYwbf5|&P-nuLul9iLx0Wz3ojw2g01j@LT40zQp*T6rC@b-g
zAfr#7*97><53ZNddrqF<2JA2Z1}?@s)ckPwmGAWh`zfOa8jc{}i}V6YkH+7lq6>~J
zVFK!l5eJYex4aA6`f84y0FL89fZ-mWZeE19>#M8lO<JULp7Mf)VP<{-l-o9x#rFw}
zpkxl#{MP4A_QG+Ma3QLM-oBECww9U_{^5!t@y-4H&Bcr$h8*x&Qkor{ILSJD5ZJ3r
zNH9P9Q>L;sck$z~y_F4Q(!~nGC~OsJ*5Yx9f6DKze&IY$90mBAM^;o4;9g3EFdq9b
z1=`<lM=I2FYg^cIy-xC&ZHjZuFo@he;!(c6>?#WRvF4r&LrH(G=Ot9ADg>E*n75cY
zq@wH?IweA5MM@?zFquidhF@l9$eBNh?Y)UdcV3DP$ANWx?D@Ts&7&YrR6-n?H6S>a
zY|y+5tgj*^ow=QnlqN<Pu+4_;O?BFdZvMq5w&fDuavo`rKVvM5$^BYZYemNgn&H9I
z`={!f!8O(cV{9e~x$0WnK>55GQCjm<ghv58Db*ZhU<?-E#F6giJ6;vZY_AX|z?XXk
z8kFYVQo`&@30lKrf)}UxyKwz%%q6KtzCHG_n~zP{U>e_Or*Y^T0LkO4I8OhqCSiQ^
zZYrnyktdCfsouSW&T2%K%pq~o8k<|=H6-kG3#u-SCC!=^iB%_kg!L!$*HNrP-or!c
zNuYE!zO=aMFl1~bGJXe(700I?J?Dx(m;B?*z5ru!my5_v+pN>=baF53HXXQ4C&ao9
z)*wBO!<aly{2_$~pafQ*41Qo_*-gEk7n}Vjjki>u+JqyHg_`XPW<cW}7k*&$F49%6
z@W6}4X2BBoZvt)Q;oEyixZsf@%unqh<2!AN&8f)EQcB70pU&`s!#kXRKV)sBju7B0
z9_-*TZq@D?;s1^Sz|ws>8&ua$v|=&mjvIIRuoJTWFxdvW0$fyvpPX}^k62rFIpmuZ
zJ0x^dq)lVd*@+*1ro$M7>L4H0YptbYaIp&vWIN)}Md*yG%_|^h-Klacr;5#bl#m7F
z(IQ3UsbVYdRoRt8x3whdjXP1<K}I*pM9@c*6->J_72`C;q9|m<vq+}co20<dl#8Nd
znzWE**_6qv0T->@x3u5<DU6UR&a^xhW(Z|C!s2wRBjPHC`^wo>QRXIHzuGzY2{`K(
z8ihS$nUO`3GV|r)ms^TTEJ%J=<C>g7;mc>57D46gAoE*?+N_h==2(_l&nKBmj4X}7
zG^xnIS(~JxVZv>5c2OVdooEZ_&@)(Ay=4>QlK(Ca1(er-sY{JUP?s&$l-d?c)Gm(b
zDAP7Z@$KlKMsJT&q~dXsES4yna-qfj6NOqxF4>e5Y_;?Gr(j9fEy|@hw?&r)oKM(g
zO>xl{E2G?tqt=xZ?X^%d4miYXGv1Cdcn*6<#Z(*<Z-_Bi6<^04BcE`d<v8QAyZ?N!
z?TIX}0^VHaAB+$%_?O+?;+t2FSr`dcQ|h9URx*)07)o`*8*-uJB_vg#4QkoF%{lk6
zHXmWGt4#aXyyC&N%{&%OX>piquj{q=cbgs|!AJ8<!RoUmOD2wnraH?6EEyvzQ&(wf
z3<?=AGsf!s@2P~%y)hwOd3#jrJbV?9+Ar!x011fG-pf5XCyI0}H?tQ$A5HfJ;+Q80
z)S>#El%@?D%)1DDik9jDx`8Ge8Vke`z0G5)q04c6^S#|+^k+v;J-pN4@C0<OJ$DQg
zN^%I|=rc30is2vL=9aDb2lj3(MN};r^ec_8mo8>2C}Uo786`3#lOeP2PcS9xOq#rc
z0F`V*4p94)n~|oZHElbjTG*TNr)+J0f5?<reG;2IgtH^1>*y|KJi&>M4A$g_&Gd2i
z)6}o(dCxHzNd^6^Do$2TUiuE(>F3geTkT4^lsYa%RfUPw&ACfl`Ao_@UoNH`=?c{L
zy@^WW0jbzyYJLd-{TziS&Q<!K5HTZS0M;`0I4xhW^F+uPZDI_+)eWy1Wg`1!=#|i3
zrNN!JXa2+PS***dd;Xb<&V!t=z-+|*hxfcj|4;}aDRNX+vpL&LUP%jR()QD%4R6SB
zKIiUVzTL4*yBD=@kzQ7Omzyu952BLcoxe->I8L5(KD!=Sr|?zIV@0<{-#{A10MK^e
zd*aA{{nTRp**)M?M*&o}4K4sCTf?F6qFR4y>QKKmr@r_^rr(|LXl!yqd`2aBr#e=k
zng>4h*&#sqlJB~qP~lPHCeGnU(a^qrD6ri)lueB}F^+d=FyRzR8%MBzmXshu`hz78
z2z9WiF7Y41SN7PVmlrI4k)!C*00u);sYuPeWrZ7smKb3E;4DG4qA3&?i$njPM!o_n
zs_lK7Zlq-B76b(84ljZ<NViBhbT<f$AfN~cGJ+r>4N8Y}#|+I-(jYBJDhhf*{%5$}
z>x_QCwZ5~~EM~9$K5y<l`>@a14{roWJ3Em(X51uE*)ZYiB>#`BHb+W@2Gd!+n(HQ_
z(J^KdS+jzXV8xCc9==U_6QSrNDgrI*Ngc$Eut}==03xxqw_I^=MUwZGAAF>j4&rw$
z&F|XQjl|<q;ke!-y>nCK>$s~i#8$4QngTDou!6A8M#N2p*fP9S^5L~ZS~J)EI2mU4
zMO~TT_)k(&>hYjuHl=Tzil10nl5<T|rH)tex*xw~feS@RwuH*HxFu?^Nm*z(U=e}e
zdU7*Gz8Vuh98G4g6Pfskqb<x{=pu!+aJo@EOzIQS3_7SwZcV?rtD~6Z2EqCQ&3agD
zp<@ejfU)HpkT|H|N`FXXs@2tCG^&55-u^?{jv>FFrs~>(utfEfzOvD8{^D2Lq^my_
zPk$xuUD+UsF`_B&H<FC=J#{7$#qV^q5Dxp&u+vyQZ3vz|{IXZo^r8$Jv|rX9B`RLv
z=}7+~ztV9egnR2{=SDV+&;sK5RM-s5d~7<1><y=&NB%yA3xnA-LMD2bD&U=zaq2rl
z3*UFihT2OOdrnp1!VfGv@d$PmIlre$Kh(@A4up`|H5>OOEIipvXiZo9Y#|%((H6|#
z)F?kh4m$9E(1<rX=CCw=fTQjbBF)I@C+O?%C#DCz6Bjlt>gQjc2AhU(2))}~*EJrW
z0R=v43~%+mzf;}P{6TKBH-xhm(J|KN`c<GJqi<<wf8lGn?Fim?s#D&a4Ng8xL(RM-
z%^vy!Z;lX#f*0jh6Lo^F{vy`Lf~NU#q|Xtm8t#R=RqAh7a0A$uuMvh&KuyT2Q<wuP
znR2h}dF(FQ7hXS`Cg)bSuw7ax@<~ieJ9A`AkbkALuep}7Q^U;`nXh@CN@8Mtm!WT=
zGvoU4(Dmano}*`ugq)gLHzeZS23Pd9y(pTUC_m=^{;+Fim?9txIN4fr393Lu4;ARe
zgJ!@8AQ{Ha{tT1U3sdx_Ph`~?F)?)?;Rv!`n^q?wyrO-RO6Gxr5S#W2Ov@ZL#u_h@
zsjI?qHJdD}xswBdm7n6zLhhi!U{)fTM;h-}S~eNFqY{b>$pW*)-5aP{;re1Gf4nHN
znOVIr^|$=d$a%0AbG!0s2wkJ6Nw>dJuyOaX5=54@^Kmx5EyX?C$Lus=bc!Ul!T~x#
z-?(A<Z<R#YRvr_Wci$t)^~mu6>m+m>=N@!7(msq&bSRkhxD4-pUr)l~)J1mCC4Ne9
z19a$dIsWnYQQFXOxJ`h?O6*EBcV_Gg&sHY+Va*_fOSxu5`M?6_Do222c1VAPjH`t6
zbS}hbS$ja7+UOovEDwikgCpHBPffJeFz<Kl<U$Wq*ELgH&Lyu5>`Xa{KB2Rtu#ku8
zHR^*^WuLQ>1OlU`d3?YY0<VVeD-Vm0tH|Z*2(}!lBEC+gd4=W(4Ib2wHaULwaMWXC
z#;GQ~`ii+A47wR%1exdcbJO|Y00JX;zDGe^V-~~*Do>e+;;+6Cwn&Mv%bhh72-1zw
z^=C3bd|zO!ZWXqb+R$<I8a(>SV5|2iK)K%wall7sob<9p50mJ7)~aB*>*W|Ou_@sA
z?Qon$ow7Zj!TqY@%2pvrm7wvNj`ovz8(&@vW?JFD{eln@4MbB^pVhi#Y=XkRdBH^?
z-aVMdMYc`K+6r-$srw+|jpvR~0i}1An_OMtM4%DhkjP15<A7!z^Yz9ko;lFXMK*3f
zmVuYJea=GRGz7J^W$K~(3~7SZl#VkMN&X~lYoi~Bd+>ZcfhPuipEcpPk45yc@=T|#
z>(;<SR);}iZE`j+%00iTTJw9>$0<J`^#k7T3#CJ&Xnb8djF=cIbXCe9n|l;L)tW9@
z6`wE5B@-Am4&i1Ju&wJ%ii?;rtlCN6+B%W496cm%?hpD>ui~RQP)}CA6~N^FAwa*|
zJm)^cK6k`@qNvS}C;3H?$h#tDr8Yi|+OlU{;r_nOkMyM%;rJA%M)3WE`%Ek=5Hjf>
zkH;y3^Hy)4c;m2qOrf{|-r2Mkw3;mt&{k#On)vc`e1UFI*~18aRg$LTuFom;W@-cW
zu%b~mYweYG>81ST!V^vS=E+U?Quq1;zD8RfW~f%2n1M<4Jqkjv(0)e8%Vn(|jNwB;
z1<PsJYnh$N1^Bnd`CA>_BNMCOFCd#*kaD&PtQ93mW?`-&<=J5tyOp`+&~0sTDKXIN
zH_h+6i}vw&BR@iiv`b;Dg+siTCe)3?21w_fsIk+pMSE|WjK0-qZJ0WMr_yqyiN(m;
zOC014S$ra#y$9^BISmn}4t`^0;8gv*GZik{q9^Pof42`7zGGN-syCxyfq>BI+cs%#
zQx9!>dN6yH|F!71m4NTeP_>UGWA)>4+{Q+uGnCYLG(485j9X15XV*WFL*hVz_s+wR
zf%B*Z!N9}pR-5do%F^xp4ygRh<f(A9z&o$|u?#(IpK0$nXy?D~Xg0L+yGx{5c32QI
z-;B9{zn#hGTep7NrCiQ3qBsY+g4k;#aQHIVkV0xkTw#iJbhhN49AsQ~$BTZQg!pMU
z+vlR9il=0K%<_t34zBJmnn<nY%v}S!49zUPl9G=t^4D+mZu&ev51EF|%+1WjfRv^e
zQ_OB)Cp8A*@xR`qi_jx<#WUlj$W)L_a>!6{-X>vZ8Lh&V;Wn3Ii4Dew<XdhnJ$BDw
z`6Ribb@N(~`yoXE=Y;ttx!m*bwESQ`nMc#vA`ZmLL39JF*SPyl0;A%oofN?(FJUjg
zfV&GTUlMWlzwZK9*Pr?biu|BwpXG7L-enq3F&R6j_Wtpxalk~5UEbakJSiATeM3J#
z=~<Q`oiYAW8(ZUE^#_7%8Hh)%U0#$OXo}=;+$^%x?4}H{<(u*8>n+aI@`^sr^=vTT
z*k=UZn3&I<5|jc!Q}OBF_X`c%L_hGY;zh&G-<cYLv(wVBiul8F1B7X#=+BIp$nA{p
z{HSkdNNFoI<E#;nx$NB>dL=uftm5Vy=_ixVTT~Mj&3ki58oX0l@OvTYRQHC|K5Zx(
zeU&Xe56d`_@LRriR4j>SfWJiM?D?XR>7f(WanWjT5p+7&vLhiVLzb#wXSF<wYG*;M
zAWG6(ZqG&_R-iAnNr*tJUT<AjPivVu)KId-Z`snu(YhI8O%_F-vuRi#e^)H%5-n|T
z)2q;9-CSLf`BrG?F}{V&nx!svW|Tg7J~)Vw{ZTQ-#=H)5(KJi9YW^AMl3{Dy%A6*~
ziT5)Z`lPmUO!WPmTrxV;Bgcuh>I`%Q7#JF47#M8G-5jQ$$BiS6qal~==|b(Qn?z(t
zq(GD=+zADwE_>`mi8T{f68z>wJNO9i=y+Di%<wG?y4c$h8o0K+`QrAL*)Y$N+B`nF
z)`c6fVrU?1R%&E^N^?pxv6;58Lt!*1@a^gG-;1mFUv1vs97uw^g5b9Mo$7;aBP+0_
zM&||SA?Dy!ZV$sXPfb`35iZ;?y&aoZK7uS}gTrRzAun^M3OHC31~(L4rQ&^gphiu$
zs&DgcoQPQ$*kCadeWiaG7_87kbI3U=OP{j~zZ`7ZV|-8_Th4p(^2yLi5XRz&Qd78l
zQ2^GG!6ARTL503%D}QV{WuiV&rojOd?vmjFL=Jb!_y8OCcHc?%lkt;hv4vn+j#W4%
zt3pg_fpxr{FI<R`km-=>sWabBU1_>?6J6Kxhm+{#W*PSsH?G%B$^6-#=M!s8`hTw+
za^(7J-=61Jc%o(^=al-iIBhRBbBKYIU7fI4xd0CPs>KuyzqFg{U|t<z^-jHz)NDr5
z4KlM8R#RG71#8bK-TdHbHE+(Ci0BS9k{mSIh-kG^C5UI4jNigGUC<=!z9VB>(7<o;
z))iL4<mcn*3>&P!e<fC_e09~#drH00?#hWu>E#89ID1W7_BKK1Y5b#^5}JghiE5F?
z42sW*i2Y&v6u8zG#{IXTp_2SU+GA3+0Z95l-sjp%;f_T@`kc<{L|z`%X-a-Pd-}ch
zBZHF5PB41ffqSF^nx?n&UAnUOVY8)5Y+y+@7~hOr$z)R2o=m2wm(A$2Ln^|d0XN$M
z=jnn>uxy}AQ|E!C7{lkM)?|folph99T|(WoAAFRN?MxUv?R?JG>E1tMWTqtHv<`{X
z)!Vpk_V!a*M6H)BG*IG&e`=88-7Mc5-rWIHQvsX<njAdg>zD3EeJll^rI?m7b4m6E
z8~Mj=t#fmh#Q9C;K2v|tf27+JMc1WCSXR!ft**hJlutCrSE!0eST`Vkw7Vu7*HhY@
zA*%EyP$iiTA+X~x9pgz_w<<>;C6oiPHW2l<O^?p-U$B5^>nP#~tQOLTM%i=jG+Zim
z`*H4XTpz3rqaz(z#ibK)l8gzD;!GbGj3cBIaFmQEUfcB2R+0TH&Ol7OJMZPqNsZ2q
zTcgc<tJI_~4!lWu4nDk*RC)C%Joc``31?{j@>GB!3{2YA;SN64?xH@m>|#-Z2(q-Z
zr2ZZI{z=A2gR(m8m1uL+6lV!fmz*hASwycFXqLveutmM{u9BkI>$|X5VyC$7y(h)M
zc8wM(1pbl!2OH&H$2_D2r_tzTQo9SUHVrT3jMsN9GM}Ve`pUhI*2;0Z4?eTG8N&(3
zbB1DTq{TWOUSGMl_*VHz-B)?3A?4VD)~~DSi}~CenPqAP3Wq<NCpErtctT<$Jr-rY
zGD=8jp6knN+u}T-TeoP$en4bs{!P04q@?KS@}AhnQE)PiudQK6@yzB7;>|bsea_BF
z*FB!$v={Dy`MtO_dm3OD__fkU$)wNK^CBKNSJoQv7&%#J9L<_BM87LHO@biQzc=@3
z=9u!BQHqy%=;|Y8x63P1ge3G~XMvzkMAzrG-|L+-yz9j=G*lt{_(s^kTzqPRq8c=3
z$wa0^7Vp#J#O-a>T3;ibT8E1@@Of6<{Q21Fb}Ut~#qjoa%d63Mgt_XP=TbtsMsmtT
zRzEg3GfBwxq1WAC8!=~0?bbt7OHxIhRONPdK`g$?)wRs?B=)1j^=oN^HQhGs5Aa&u
zxNqC>!;4x>EfZpGhO20Nn63RYI2f7ln$m7Bh|KpMulltvEJkC9TS?$aF|RZs9+^wE
zl{&TJTOWojOY+GJS>D+Gg1I*n6XF7w^lq3M2@N@>%-hSXKJY!xyrl^7Uot)6Axb|i
zS?KV?4tJ68JhqFdz>RZ&(<|3pVycH;Tev0jc=`H%Y2)H&fj|z5un~r6T6)P1c-iF+
z+D)6OS&sw8wE>4_3{EzFHlIsQJ@+~MF*Aa_-1Dc3Hg&IUC&{YU<5SJ^yJ&mYO)pKD
zx4*%vdAK0gqG8f9W<fRt`QkOdnd&U?<~bQ6LT%^RLUg$$CC4t^_68@uWTvGb*I5kD
zouQ=Su?SJx4?J0(f&rLX(Zmkg2<HLHPO4{Cn9g{&l&3EBQ$Xs)*l7@;Lz)UVK}1#Q
zw;bW32*20Q{!-$x3bC>8J-)&<!lu_AbrtblRy@j`+iD!wMLVL750ZVRmo`fuWU`cB
z``X!a_2!2|eTUspiq-=y-1%Sx6@Al0>*Fy5J#W_MBS_{~qdHIpKV>}$CnY!QtUujC
z2(C{COzWZ9nXhSyN{xnnzyyZ&r$~$+caFZ>u(Pl-bVD@dg+(6tTT}blaQHo=+UHVl
zY7p)nC2#Oxc(&9Pu?TsJ6POL9I(|laso{im=7d218@IKjnw{(|H(5o|SDY9EI;*na
zay`GuswwXK53A}3qcHeY;)@Sx?K~1rV-rV?$Ko{w_6uJr;sm5Ok%>GZUw?EU-*1R%
zM7L24PAN~e`nt?7ulO|K5>o&n%e|7&%w4TP_P*AaIKl6qoA9YZvMQ!hRnG(J(+pa#
z&Ug8-&ky(^SoWyyu+9rKS_S;&<8_j3w+?o>Evi$@mU(d8O%<lfnn|D>ei*^{Y?Uxy
zBGcj0*Ge|mmCb{voBgl%4;Y6Lhb@{4Sp2e!LCn6yWDQC1omDoaCk0Q!k}fg6-)7YB
zxGm>9zS!epjkVDdqs&w09>sB^H1<9BIaZCBQjv1XqC6<G<b@>*s993;Cck=2JYpZ?
zCH41Nh4#sFEcDxpb~<^O4!~Ne4OOw_h3F3t-R2omGgMX68W<el>l++d)%!X$qVJ)m
zWh5wUAShfVELtrrr0d~Fsw*fgD7wze-9MtPb)BbHOF&(-Pi<0bxNnV@cj#K*pw`=U
zER+M@L;&yQm6>GlFkp)j69WTy7=>Zu>*#Wi-wSLDcJ%PM?&0MQeb9*y5sPne>k=f1
z@NZS8P<Rdzap*J3>K)5*R?w))ZBHao6aRklHZ5W<WbLrm+PAu;EcAVzA_++sW^4MU
zMX!LFnu`vP!Q;4+r8P^doa3@)^U_AY3Ru-Huar2ot~>doMwwTCCp+X7*c*tw^@wS}
z`BcL1&RwA7XGbxPa~*<bcIOj6NNy~hZm(ukqHxCs!7a@O$qP>@fAp;@@{2!Bc_?QE
z<)?`^<K1CUk&3(kd;KF0%*4P@Jm-xg$X`M=WHb@Gm1{Rs-%@hleZM7%Kw;lPrU05@
z%Si(~jRVL=k<EnOqhwitj7uNjU=)Jt2GCc(X*0w6N!WNHf7NRRrCEKu_yo1PdZ%Uu
ztv%2fi-{_~kw{B`+O}?{#YSzP1&d-|{^bvQP@h>M;7ckgG%Oe3f-EDh9&*gVMe#V@
z#bTros9ym#28JZ`(2oh4HAV_08KkH-_bx^=?Vmf0k7|nCw;!!P&^-^$b(sg*l&JFM
zcH3zEgSInhZKZ&698`JFtW&i9>AEen_L`p&ntk0eX*4`RS|3_}Qk51Oel9&0`zJFj
zvNDc~AsEWQAXb9XbaEN}|4kfWoj)heI@)x>#JY_APdRvzqou7ABtwp|s{q)+(7I)y
zz^|sQ3^076OZ~@D3kY3CO8&g^!l2|`Opu@Y{$EtJ{|J&}oGH8nz9NZhQFZ^0ApTb|
z1`^Tw6JhUVea{8_zkyVM9P;zeg+y*$JcK6y-4v7@PK#3$#)ygJyoIX6Nv@)Jj?Rkv
zuQp(xFAM|ge{tk8p(@ziG4Xx_;O2l2`!778zz+u+1_MD|x~Wj*ab5>4SO7Cq7kG1?
zA5Gp0_kt&N@eV!T?;)Vmss2LMgy9ohfIKK!p#nX)#3+$LfAk{5X1a7CAkfEx>IFIt
zAF9G{<QMW8OiX_!()uEie4q=7asiS*{6y!iLRH&F`;VVJq{9EOSp6R21xW``&mA5N
z4Ax&rAdj@HKpq*PSvT<hu!nvG;TNhV%u@t93KK;Q8T|!bRM`iTKU0K!ofoZG|GndI
z@rnZ~CROnQ^Un(p6n{AOYrFXOQ32HkqTxX+)Quiwp}Y-$W{4NnYxIB1Q9TGT2IQIk
zM>hXkeE|f=FBFi?$-7WZTTV2Gk-s{>FQNZpYQpTSpst<tTB!9x0+0g0Fuu5eErXvI
zavC~W|1;%(PGDOXN3=<d1Ve|$kRhj9L!Y&YppCPOUe5t!@0EK{Hg67S#Q@2_*}CXF
zA3=7KgD*NC6f^u0N^^;pFp`M!A+X-a{p%R;w<e6z0RZtp14bGCO)*mA2M*FtD!|I4
z0bqpC<bOCpD;*i3Um9utFmi*&;T#Syv^@fbEV_~BE*GBBKpFo4F*<`PhX5;cz=H${
zG)uKU7oL@lQKNdcW;1zp8IX4a3?a$F|GjF$rv0IwL&~VKzgAcbfHLmaRTBof4@ANJ
zhcjpk?k{;DO*;<&XQclCm<PC}JO@01Q~YjWD;x^RVux;x5TjL!e-K%zjweuNU)ev4
zeAbWbO^Ut9mh8ZPqaIn3$ov`_drAxp81L_<6ypJT_QYXg)Y$Km$&cj%dEx=Q6G01Q
zFZ)9MdppWM!ciHu+erjK>A)~S2d(4*ARZ`RKLuJiI~U>f6ar(G4(c3m<<F3GFNS7l
z36PEJfA(gMA_I;nzfewA5BkHSt2nA8bihEgM}~qHhJO{ba!?R8WW`a?#x`)P6bvk$
zvS_kX)fXWbAz0D84;w~WXQ+o}4F83yh@aXa93L>)1guBGXo~h4E)>D4(0|^L^--=R
zIF<vf_X9`2WY9pjnlC`_?Qo%dBlM_-{=2UM<XO-#b8S$@PBxH^1}-o!kaJK7gB%!R
JmhH&a{{efo0KEVJ

diff --git a/Engine/lib/sdl/android-project/gradle/wrapper/gradle-wrapper.properties b/Engine/lib/sdl/android-project/gradle/wrapper/gradle-wrapper.properties
index f9b3be2f9..ada5af48a 100644
--- a/Engine/lib/sdl/android-project/gradle/wrapper/gradle-wrapper.properties
+++ b/Engine/lib/sdl/android-project/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
-#Mon Oct 23 13:51:26 PDT 2017
+#Thu Nov 11 18:20:34 PST 2021
 distributionBase=GRADLE_USER_HOME
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.3-bin.zip
 distributionPath=wrapper/dists
-zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.10.2-all.zip
+zipStoreBase=GRADLE_USER_HOME
diff --git a/Engine/lib/sdl/autogen.sh b/Engine/lib/sdl/autogen.sh
index 9edfb8a7d..daf160de5 100755
--- a/Engine/lib/sdl/autogen.sh
+++ b/Engine/lib/sdl/autogen.sh
@@ -1,5 +1,5 @@
 #!/bin/sh
-#
+
 echo "Generating build information using autoconf"
 echo "This may take a while ..."
 
@@ -9,15 +9,15 @@ cd "$srcdir"
 
 # Regenerate configuration files
 cat acinclude/* >aclocal.m4
-found=false
-for autoconf in autoconf autoconf259 autoconf-2.59
-do if which $autoconf >/dev/null 2>&1; then $autoconf && found=true; break; fi
-done
-if test x$found = xfalse; then
-    echo "Couldn't find autoconf, aborting"
-    exit 1
+
+if test "$AUTOCONF"x = x; then
+  AUTOCONF=autoconf
 fi
+
+$AUTOCONF || exit 1
+rm aclocal.m4
+rm -rf autom4te.cache
+
 (cd test; sh autogen.sh)
 
-# Run configure for this platform
 echo "Now you are ready to run ./configure"
diff --git a/Engine/lib/sdl/build-scripts/checker-buildbot.sh b/Engine/lib/sdl/build-scripts/checker-buildbot.sh
index e8f2f2246..be89fd7ec 100755
--- a/Engine/lib/sdl/build-scripts/checker-buildbot.sh
+++ b/Engine/lib/sdl/build-scripts/checker-buildbot.sh
@@ -27,7 +27,7 @@ cd checker-buildbot
 # The -Wno-liblto is new since our checker-279 upgrade, I think; checker otherwise warns "libLTO.dylib relative to clang installed dir not found"
 
 # You might want to do this for CMake-backed builds instead...
-scan-build -o analysis cmake -G Ninja -Wno-dev -DSDL_STATIC=OFF -DCMAKE_BUILD_TYPE=Debug -DASSERTIONS=enabled -DCMAKE_C_FLAGS="-Wno-deprecated-declarations" -DCMAKE_SHARED_LINKER_FLAGS="-Wno-liblto" ..
+scan-build -o analysis cmake -G Ninja -Wno-dev -DSDL_STATIC=OFF -DCMAKE_BUILD_TYPE=Debug -DSDL_ASSERTIONS=enabled -DCMAKE_C_FLAGS="-Wno-deprecated-declarations" -DCMAKE_SHARED_LINKER_FLAGS="-Wno-liblto" ..
 
 # ...or run configure without the scan-build wrapper...
 #CC="$CHECKERDIR/libexec/ccc-analyzer" CFLAGS="-O0 -Wno-deprecated-declarations" LDFLAGS="-Wno-liblto" ../configure --enable-assertions=enabled
diff --git a/Engine/lib/sdl/build-scripts/g++-fat.sh b/Engine/lib/sdl/build-scripts/clang++-fat.sh
old mode 100755
new mode 100644
similarity index 52%
rename from Engine/lib/sdl/build-scripts/g++-fat.sh
rename to Engine/lib/sdl/build-scripts/clang++-fat.sh
index 0dbe99039..d337109f9
--- a/Engine/lib/sdl/build-scripts/g++-fat.sh
+++ b/Engine/lib/sdl/build-scripts/clang++-fat.sh
@@ -2,35 +2,36 @@
 #
 # Build Universal binaries on Mac OS X, thanks Ryan!
 #
-# Usage: ./configure CXX="sh g++-fat.sh" && make && rm -rf x86 x64
+# Usage: ./configure CXX="sh clang++-fat.sh" && make && rm -rf arm64 x64
 
 DEVELOPER="`xcode-select -print-path`/Platforms/MacOSX.platform/Developer"
 
-# Intel 32-bit compiler flags (10.6 runtime compatibility)
-GCC_COMPILE_X86="g++ -arch i386 -mmacosx-version-min=10.6 \
--I/usr/local/include"
-
-GCC_LINK_X86="-mmacosx-version-min=10.6"
-
 # Intel 64-bit compiler flags (10.6 runtime compatibility)
-GCC_COMPILE_X64="g++ -arch x86_64 -mmacosx-version-min=10.6 \
+CLANG_COMPILE_X64="clang++ -arch x86_64 -mmacosx-version-min=10.6 \
 -I/usr/local/include"
 
-GCC_LINK_X64="-mmacosx-version-min=10.6"
+CLANG_LINK_X64="-mmacosx-version-min=10.6"
 
-# Output both PowerPC and Intel object files
+# ARM 64-bit compiler flags (11.0 runtime compatibility)
+CLANG_COMPILE_ARM64="clang++ -arch arm64 -mmacosx-version-min=11.0 \
+-I/usr/local/include"
+
+CLANG_LINK_ARM64="-mmacosx-version-min=11.0"
+
+
+# Output both Intel and ARM object files
 args="$*"
 compile=yes
 link=yes
 while test x$1 != x; do
     case $1 in
-        --version) exec g++ $1;;
-        -v) exec g++ $1;;
-        -V) exec g++ $1;;
-        -print-prog-name=*) exec g++ $1;;
-        -print-search-dirs) exec g++ $1;;
-        -E) GCC_COMPILE_X86="$GCC_COMPILE_X86 -E"
-            GCC_COMPILE_X64="$GCC_COMPILE_X64 -E"
+        --version) exec clang++ $1;;
+        -v) exec clang++ $1;;
+        -V) exec clang++ $1;;
+        -print-prog-name=*) exec clang++ $1;;
+        -print-search-dirs) exec clang++ $1;;
+        -E) CLANG_COMPILE_ARM64="$CLANG_COMPILE_ARM64 -E"
+            CLANG_COMPILE_X64="$CLANG_COMPILE_X64 -E"
             compile=no; link=no;;
         -c) link=no;;
         -o) output=$2;;
@@ -39,8 +40,8 @@ while test x$1 != x; do
     shift
 done
 if test x$link = xyes; then
-    GCC_COMPILE_X86="$GCC_COMPILE_X86 $GCC_LINK_X86"
-    GCC_COMPILE_X64="$GCC_COMPILE_X64 $GCC_LINK_X64"
+    CLANG_COMPILE_ARM64="$CLANG_COMPILE_ARM64 $CLANG_LINK_ARM64"
+    CLANG_COMPILE_X64="$CLANG_COMPILE_X64 $CLANG_LINK_X64"
 fi
 if test x"$output" = x; then
     if test x$link = xyes; then
@@ -50,9 +51,9 @@ if test x"$output" = x; then
     fi
 fi
 
-# Compile X86 32-bit
+# Compile ARM 64-bit
 if test x"$output" != x; then
-    dir=x86/`dirname $output`
+    dir=arm64/`dirname $output`
     if test -d $dir; then
         :
     else
@@ -61,19 +62,19 @@ if test x"$output" != x; then
 fi
 set -- $args
 while test x$1 != x; do
-    if test -f "x86/$1" && test "$1" != "$output"; then
-        x86_args="$x86_args x86/$1"
+    if test -f "arm64/$1" && test "$1" != "$output"; then
+        arm64_args="$arm64_args arm64/$1"
     else
-        x86_args="$x86_args $1"
+        arm64_args="$arm64_args $1"
     fi
     shift
 done
-$GCC_COMPILE_X86 $x86_args || exit $?
+$CLANG_COMPILE_ARM64 $arm64_args || exit $?
 if test x"$output" != x; then
-    cp $output x86/$output
+    cp $output arm64/$output
 fi
 
-# Compile X86 32-bit
+# Compile Intel 64-bit
 if test x"$output" != x; then
     dir=x64/`dirname $output`
     if test -d $dir; then
@@ -91,11 +92,11 @@ while test x$1 != x; do
     fi
     shift
 done
-$GCC_COMPILE_X64 $x64_args || exit $?
+$CLANG_COMPILE_X64 $x64_args || exit $?
 if test x"$output" != x; then
     cp $output x64/$output
 fi
 
 if test x"$output" != x; then
-    lipo -create -o $output x86/$output x64/$output
+    lipo -create -o $output arm64/$output x64/$output
 fi
diff --git a/Engine/lib/sdl/build-scripts/gcc-fat.sh b/Engine/lib/sdl/build-scripts/clang-fat.sh
old mode 100755
new mode 100644
similarity index 53%
rename from Engine/lib/sdl/build-scripts/gcc-fat.sh
rename to Engine/lib/sdl/build-scripts/clang-fat.sh
index 65f759d4a..38c07275d
--- a/Engine/lib/sdl/build-scripts/gcc-fat.sh
+++ b/Engine/lib/sdl/build-scripts/clang-fat.sh
@@ -2,36 +2,37 @@
 #
 # Build Universal binaries on Mac OS X, thanks Ryan!
 #
-# Usage: ./configure CC="sh gcc-fat.sh" && make && rm -rf x86 x64
+# Usage: ./configure CC="sh clang-fat.sh" && make && rm -rf arm64 x64
 
 DEVELOPER="`xcode-select -print-path`/Platforms/MacOSX.platform/Developer"
 
-# Intel 32-bit compiler flags (10.6 runtime compatibility)
-GCC_COMPILE_X86="gcc -arch i386 -mmacosx-version-min=10.6 \
--I/usr/local/include"
-
-GCC_LINK_X86="-mmacosx-version-min=10.6"
-
 # Intel 64-bit compiler flags (10.6 runtime compatibility)
-GCC_COMPILE_X64="gcc -arch x86_64 -mmacosx-version-min=10.6 \
+CLANG_COMPILE_X64="clang -arch x86_64 -mmacosx-version-min=10.6 \
 -DMAC_OS_X_VERSION_MIN_REQUIRED=1060 \
 -I/usr/local/include"
 
-GCC_LINK_X64="-mmacosx-version-min=10.6"
+CLANG_LINK_X64="-mmacosx-version-min=10.6"
 
-# Output both PowerPC and Intel object files
+# ARM 64-bit compiler flags (11.0 runtime compatibility)
+CLANG_COMPILE_ARM64="clang -arch arm64 -mmacosx-version-min=11.0 \
+-I/usr/local/include"
+
+CLANG_LINK_ARM64="-mmacosx-version-min=11.0"
+
+
+# Output both Intel and ARM object files
 args="$*"
 compile=yes
 link=yes
 while test x$1 != x; do
     case $1 in
-        --version) exec gcc $1;;
-        -v) exec gcc $1;;
-        -V) exec gcc $1;;
-        -print-prog-name=*) exec gcc $1;;
-        -print-search-dirs) exec gcc $1;;
-        -E) GCC_COMPILE_X86="$GCC_COMPILE_X86 -E"
-            GCC_COMPILE_X64="$GCC_COMPILE_X64 -E"
+        --version) exec clang $1;;
+        -v) exec clang $1;;
+        -V) exec clang $1;;
+        -print-prog-name=*) exec clang $1;;
+        -print-search-dirs) exec clang $1;;
+        -E) CLANG_COMPILE_X64="$CLANG_COMPILE_X64 -E"
+            CLANG_COMPILE_ARM64="$CLANG_COMPILE_ARM64 -E"
             compile=no; link=no;;
         -c) link=no;;
         -o) output=$2;;
@@ -40,8 +41,8 @@ while test x$1 != x; do
     shift
 done
 if test x$link = xyes; then
-    GCC_COMPILE_X86="$GCC_COMPILE_X86 $GCC_LINK_X86"
-    GCC_COMPILE_X64="$GCC_COMPILE_X64 $GCC_LINK_X64"
+    CLANG_COMPILE_X64="$CLANG_COMPILE_X64 $CLANG_LINK_X64"
+    CLANG_COMPILE_ARM64="$CLANG_COMPILE_ARM64 $CLANG_LINK_ARM64"
 fi
 if test x"$output" = x; then
     if test x$link = xyes; then
@@ -51,30 +52,7 @@ if test x"$output" = x; then
     fi
 fi
 
-# Compile X86 32-bit
-if test x"$output" != x; then
-    dir=x86/`dirname $output`
-    if test -d $dir; then
-        :
-    else
-        mkdir -p $dir
-    fi
-fi
-set -- $args
-while test x$1 != x; do
-    if test -f "x86/$1" && test "$1" != "$output"; then
-        x86_args="$x86_args x86/$1"
-    else
-        x86_args="$x86_args $1"
-    fi
-    shift
-done
-$GCC_COMPILE_X86 $x86_args || exit $?
-if test x"$output" != x; then
-    cp $output x86/$output
-fi
-
-# Compile X86 32-bit
+# Compile Intel 64-bit
 if test x"$output" != x; then
     dir=x64/`dirname $output`
     if test -d $dir; then
@@ -92,11 +70,36 @@ while test x$1 != x; do
     fi
     shift
 done
-$GCC_COMPILE_X64 $x64_args || exit $?
+$CLANG_COMPILE_X64 $x64_args || exit $?
 if test x"$output" != x; then
     cp $output x64/$output
 fi
 
+# Compile ARM 64-bit
 if test x"$output" != x; then
-    lipo -create -o $output x86/$output x64/$output
+    dir=arm64/`dirname $output`
+    if test -d $dir; then
+        :
+    else
+        mkdir -p $dir
+    fi
 fi
+set -- $args
+while test x$1 != x; do
+    if test -f "arm64/$1" && test "$1" != "$output"; then
+        arm64_args="$arm64_args arm64/$1"
+    else
+        arm64_args="$arm64_args $1"
+    fi
+    shift
+done
+$CLANG_COMPILE_ARM64 $arm64_args || exit $?
+if test x"$output" != x; then
+    cp $output arm64/$output
+fi
+
+
+if test x"$output" != x; then
+    lipo -create -o $output arm64/$output x64/$output
+fi
+
diff --git a/Engine/lib/sdl/build-scripts/codechecker-buildbot.sh b/Engine/lib/sdl/build-scripts/codechecker-buildbot.sh
new file mode 100644
index 000000000..76b7853b3
--- /dev/null
+++ b/Engine/lib/sdl/build-scripts/codechecker-buildbot.sh
@@ -0,0 +1,59 @@
+#!/bin/bash
+
+# This is a script used by some Buildbot build workers to push the project
+#  through Clang's static analyzer and prepare the output to be uploaded
+#  back to the buildmaster. You might find it useful too.
+
+# Install Clang (you already have it on macOS, apt-get install clang
+#  on Ubuntu, etc), install CMake, and pip3 install codechecker.
+
+FINALDIR="$1"
+
+set -x
+set -e
+
+cd `dirname "$0"`
+cd ..
+
+rm -rf codechecker-buildbot
+if [ ! -z "$FINALDIR" ]; then
+    rm -rf "$FINALDIR"
+fi
+
+mkdir codechecker-buildbot
+cd codechecker-buildbot
+
+# We turn off deprecated declarations, because we don't care about these warnings during static analysis.
+cmake -Wno-dev -DSDL_STATIC=OFF -DCMAKE_BUILD_TYPE=Debug -DSDL_ASSERTIONS=enabled -DCMAKE_C_FLAGS="-Wno-deprecated-declarations" -DCMAKE_EXPORT_COMPILE_COMMANDS=1 ..
+
+# CMake on macOS adds "-arch arm64" or whatever is appropriate, but this confuses CodeChecker, so strip it out.
+perl -w -pi -e 's/\-arch\s+.*?\s+//g;' compile_commands.json
+
+rm -rf ../analysis
+CodeChecker analyze compile_commands.json -o ./reports
+
+# "parse" returns 2 if there was a static analysis issue to report, but this
+#  does not signify an error in the parsing (that would be error code 1). Turn
+#  off the abort-on-error flag.
+set +e
+CodeChecker parse ./reports -e html -o ../analysis
+set -e
+
+cd ..
+chmod -R a+r analysis
+chmod -R go-w analysis
+find analysis -type d -exec chmod a+x {} \;
+if [ -x /usr/bin/xattr ]; then find analysis -exec /usr/bin/xattr -d com.apple.quarantine {} \; 2>/dev/null ; fi
+
+if [ ! -z "$FINALDIR" ]; then
+    mv analysis "$FINALDIR"
+else
+    FINALDIR=analysis
+fi
+
+rm -rf codechecker-buildbot
+
+echo "Done. Final output is in '$FINALDIR' ..."
+
+# end of codechecker-buildbot.sh ...
+
diff --git a/Engine/lib/sdl/build-scripts/config.guess b/Engine/lib/sdl/build-scripts/config.guess
index a74484427..b7806a8cb 100644
--- a/Engine/lib/sdl/build-scripts/config.guess
+++ b/Engine/lib/sdl/build-scripts/config.guess
@@ -1,12 +1,14 @@
 #! /bin/sh
 # Attempt to guess a canonical system name.
-#   Copyright 1992-2017 Free Software Foundation, Inc.
+#   Copyright 1992-2022 Free Software Foundation, Inc.
 
-timestamp='2017-08-08'
+# shellcheck disable=SC2006,SC2268 # see below for rationale
+
+timestamp='2022-01-03'
 
 # This file is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
+# the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful, but
@@ -15,7 +17,7 @@ timestamp='2017-08-08'
 # General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
-# along with this program; if not, see <http://www.gnu.org/licenses/>.
+# along with this program; if not, see <https://www.gnu.org/licenses/>.
 #
 # As a special exception to the GNU General Public License, if you
 # distribute this file as part of a program that contains a
@@ -27,11 +29,19 @@ timestamp='2017-08-08'
 # Originally written by Per Bothner; maintained since 2000 by Ben Elliston.
 #
 # You can get the latest version of this script from:
-# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess
+# https://git.savannah.gnu.org/cgit/config.git/plain/config.guess
 #
 # Please send patches to <config-patches@gnu.org>.
 
 
+# The "shellcheck disable" line above the timestamp inhibits complaints
+# about features and limitations of the classic Bourne shell that were
+# superseded or lifted in POSIX.  However, this script identifies a wide
+# variety of pre-POSIX systems that do not have POSIX shells at all, and
+# even some reasonably current systems (Solaris 10 as case-in-point) still
+# have a pre-POSIX /bin/sh.
+
+
 me=`echo "$0" | sed -e 's,.*/,,'`
 
 usage="\
@@ -39,7 +49,7 @@ Usage: $0 [OPTION]
 
 Output the configuration name of the system \`$me' is run on.
 
-Operation modes:
+Options:
   -h, --help         print this help, then exit
   -t, --time-stamp   print date of last modification, then exit
   -v, --version      print version number, then exit
@@ -50,7 +60,7 @@ version="\
 GNU config.guess ($timestamp)
 
 Originally written by Per Bothner.
-Copyright 1992-2017 Free Software Foundation, Inc.
+Copyright 1992-2022 Free Software Foundation, Inc.
 
 This is free software; see the source for copying conditions.  There is NO
 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
@@ -84,7 +94,8 @@ if test $# != 0; then
   exit 1
 fi
 
-trap 'exit 1' 1 2 15
+# Just in case it came from the environment.
+GUESS=
 
 # CC_FOR_BUILD -- compiler used by this script. Note that the use of a
 # compiler to aid in system detection is discouraged as it requires
@@ -96,66 +107,90 @@ trap 'exit 1' 1 2 15
 
 # Portable tmp directory creation inspired by the Autoconf team.
 
-set_cc_for_build='
-trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ;
-trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ;
-: ${TMPDIR=/tmp} ;
- { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } ||
- { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } ||
- { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } ||
- { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ;
-dummy=$tmp/dummy ;
-tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ;
-case $CC_FOR_BUILD,$HOST_CC,$CC in
- ,,)    echo "int x;" > $dummy.c ;
-	for c in cc gcc c89 c99 ; do
-	  if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then
-	     CC_FOR_BUILD="$c"; break ;
-	  fi ;
-	done ;
-	if test x"$CC_FOR_BUILD" = x ; then
-	  CC_FOR_BUILD=no_compiler_found ;
-	fi
-	;;
- ,,*)   CC_FOR_BUILD=$CC ;;
- ,*,*)  CC_FOR_BUILD=$HOST_CC ;;
-esac ; set_cc_for_build= ;'
+tmp=
+# shellcheck disable=SC2172
+trap 'test -z "$tmp" || rm -fr "$tmp"' 0 1 2 13 15
+
+set_cc_for_build() {
+    # prevent multiple calls if $tmp is already set
+    test "$tmp" && return 0
+    : "${TMPDIR=/tmp}"
+    # shellcheck disable=SC2039,SC3028
+    { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } ||
+	{ test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir "$tmp" 2>/dev/null) ; } ||
+	{ tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir "$tmp" 2>/dev/null) && echo "Warning: creating insecure temp directory" >&2 ; } ||
+	{ echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; }
+    dummy=$tmp/dummy
+    case ${CC_FOR_BUILD-},${HOST_CC-},${CC-} in
+	,,)    echo "int x;" > "$dummy.c"
+	       for driver in cc gcc c89 c99 ; do
+		   if ($driver -c -o "$dummy.o" "$dummy.c") >/dev/null 2>&1 ; then
+		       CC_FOR_BUILD=$driver
+		       break
+		   fi
+	       done
+	       if test x"$CC_FOR_BUILD" = x ; then
+		   CC_FOR_BUILD=no_compiler_found
+	       fi
+	       ;;
+	,,*)   CC_FOR_BUILD=$CC ;;
+	,*,*)  CC_FOR_BUILD=$HOST_CC ;;
+    esac
+}
 
 # This is needed to find uname on a Pyramid OSx when run in the BSD universe.
 # (ghazi@noc.rutgers.edu 1994-08-24)
-if (test -f /.attbin/uname) >/dev/null 2>&1 ; then
+if test -f /.attbin/uname ; then
 	PATH=$PATH:/.attbin ; export PATH
 fi
 
 UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
 UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
-UNAME_SYSTEM=`(uname -s) 2>/dev/null`  || UNAME_SYSTEM=unknown
+UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown
 UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
 
-case "${UNAME_SYSTEM}" in
+case $UNAME_SYSTEM in
 Linux|GNU|GNU/*)
-	# If the system lacks a compiler, then just pick glibc.
-	# We could probably try harder.
-	LIBC=gnu
+	LIBC=unknown
 
-	eval $set_cc_for_build
-	cat <<-EOF > $dummy.c
+	set_cc_for_build
+	cat <<-EOF > "$dummy.c"
 	#include <features.h>
 	#if defined(__UCLIBC__)
 	LIBC=uclibc
 	#elif defined(__dietlibc__)
 	LIBC=dietlibc
-	#else
+	#elif defined(__GLIBC__)
 	LIBC=gnu
+	#else
+	#include <stdarg.h>
+	/* First heuristic to detect musl libc.  */
+	#ifdef __DEFINED_va_list
+	LIBC=musl
+	#endif
 	#endif
 	EOF
-	eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^LIBC' | sed 's, ,,g'`
+	cc_set_libc=`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^LIBC' | sed 's, ,,g'`
+	eval "$cc_set_libc"
+
+	# Second heuristic to detect musl libc.
+	if [ "$LIBC" = unknown ] &&
+	   command -v ldd >/dev/null &&
+	   ldd --version 2>&1 | grep -q ^musl; then
+		LIBC=musl
+	fi
+
+	# If the system lacks a compiler, then just pick glibc.
+	# We could probably try harder.
+	if [ "$LIBC" = unknown ]; then
+		LIBC=gnu
+	fi
 	;;
 esac
 
 # Note: order is significant - the case branches are not exclusive.
 
-case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
+case $UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION in
     *:NetBSD:*:*)
 	# NetBSD (nbsd) targets should (where applicable) match one or
 	# more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*,
@@ -167,32 +202,32 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
 	#
 	# Note: NetBSD doesn't particularly care about the vendor
 	# portion of the name.  We always set it to "unknown".
-	sysctl="sysctl -n hw.machine_arch"
 	UNAME_MACHINE_ARCH=`(uname -p 2>/dev/null || \
-	    /sbin/$sysctl 2>/dev/null || \
-	    /usr/sbin/$sysctl 2>/dev/null || \
+	    /sbin/sysctl -n hw.machine_arch 2>/dev/null || \
+	    /usr/sbin/sysctl -n hw.machine_arch 2>/dev/null || \
 	    echo unknown)`
-	case "${UNAME_MACHINE_ARCH}" in
+	case $UNAME_MACHINE_ARCH in
+	    aarch64eb) machine=aarch64_be-unknown ;;
 	    armeb) machine=armeb-unknown ;;
 	    arm*) machine=arm-unknown ;;
 	    sh3el) machine=shl-unknown ;;
 	    sh3eb) machine=sh-unknown ;;
 	    sh5el) machine=sh5le-unknown ;;
 	    earmv*)
-		arch=`echo ${UNAME_MACHINE_ARCH} | sed -e 's,^e\(armv[0-9]\).*$,\1,'`
-		endian=`echo ${UNAME_MACHINE_ARCH} | sed -ne 's,^.*\(eb\)$,\1,p'`
+		arch=`echo "$UNAME_MACHINE_ARCH" | sed -e 's,^e\(armv[0-9]\).*$,\1,'`
+		endian=`echo "$UNAME_MACHINE_ARCH" | sed -ne 's,^.*\(eb\)$,\1,p'`
 		machine=${arch}${endian}-unknown
 		;;
-	    *) machine=${UNAME_MACHINE_ARCH}-unknown ;;
+	    *) machine=$UNAME_MACHINE_ARCH-unknown ;;
 	esac
 	# The Operating System including object format, if it has switched
 	# to ELF recently (or will in the future) and ABI.
-	case "${UNAME_MACHINE_ARCH}" in
+	case $UNAME_MACHINE_ARCH in
 	    earm*)
 		os=netbsdelf
 		;;
 	    arm*|i386|m68k|ns32k|sh3*|sparc|vax)
-		eval $set_cc_for_build
+		set_cc_for_build
 		if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
 			| grep -q __ELF__
 		then
@@ -208,10 +243,10 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
 		;;
 	esac
 	# Determine ABI tags.
-	case "${UNAME_MACHINE_ARCH}" in
+	case $UNAME_MACHINE_ARCH in
 	    earm*)
 		expr='s/^earmv[0-9]/-eabi/;s/eb$//'
-		abi=`echo ${UNAME_MACHINE_ARCH} | sed -e "$expr"`
+		abi=`echo "$UNAME_MACHINE_ARCH" | sed -e "$expr"`
 		;;
 	esac
 	# The OS release
@@ -219,50 +254,68 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
 	# thus, need a distinct triplet. However, they do not need
 	# kernel version information, so it can be replaced with a
 	# suitable tag, in the style of linux-gnu.
-	case "${UNAME_VERSION}" in
+	case $UNAME_VERSION in
 	    Debian*)
 		release='-gnu'
 		;;
 	    *)
-		release=`echo ${UNAME_RELEASE} | sed -e 's/[-_].*//' | cut -d. -f1,2`
+		release=`echo "$UNAME_RELEASE" | sed -e 's/[-_].*//' | cut -d. -f1,2`
 		;;
 	esac
 	# Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:
 	# contains redundant information, the shorter form:
 	# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
-	echo "${machine}-${os}${release}${abi}"
-	exit ;;
+	GUESS=$machine-${os}${release}${abi-}
+	;;
     *:Bitrig:*:*)
 	UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'`
-	echo ${UNAME_MACHINE_ARCH}-unknown-bitrig${UNAME_RELEASE}
-	exit ;;
+	GUESS=$UNAME_MACHINE_ARCH-unknown-bitrig$UNAME_RELEASE
+	;;
     *:OpenBSD:*:*)
 	UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'`
-	echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE}
-	exit ;;
+	GUESS=$UNAME_MACHINE_ARCH-unknown-openbsd$UNAME_RELEASE
+	;;
+    *:SecBSD:*:*)
+	UNAME_MACHINE_ARCH=`arch | sed 's/SecBSD.//'`
+	GUESS=$UNAME_MACHINE_ARCH-unknown-secbsd$UNAME_RELEASE
+	;;
     *:LibertyBSD:*:*)
 	UNAME_MACHINE_ARCH=`arch | sed 's/^.*BSD\.//'`
-	echo ${UNAME_MACHINE_ARCH}-unknown-libertybsd${UNAME_RELEASE}
-	exit ;;
+	GUESS=$UNAME_MACHINE_ARCH-unknown-libertybsd$UNAME_RELEASE
+	;;
+    *:MidnightBSD:*:*)
+	GUESS=$UNAME_MACHINE-unknown-midnightbsd$UNAME_RELEASE
+	;;
     *:ekkoBSD:*:*)
-	echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE}
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-ekkobsd$UNAME_RELEASE
+	;;
     *:SolidBSD:*:*)
-	echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE}
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-solidbsd$UNAME_RELEASE
+	;;
+    *:OS108:*:*)
+	GUESS=$UNAME_MACHINE-unknown-os108_$UNAME_RELEASE
+	;;
     macppc:MirBSD:*:*)
-	echo powerpc-unknown-mirbsd${UNAME_RELEASE}
-	exit ;;
+	GUESS=powerpc-unknown-mirbsd$UNAME_RELEASE
+	;;
     *:MirBSD:*:*)
-	echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE}
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-mirbsd$UNAME_RELEASE
+	;;
     *:Sortix:*:*)
-	echo ${UNAME_MACHINE}-unknown-sortix
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-sortix
+	;;
+    *:Twizzler:*:*)
+	GUESS=$UNAME_MACHINE-unknown-twizzler
+	;;
     *:Redox:*:*)
-	echo ${UNAME_MACHINE}-unknown-redox
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-redox
+	;;
+    mips:OSF1:*.*)
+	GUESS=mips-dec-osf1
+	;;
     alpha:OSF1:*:*)
+	# Reset EXIT trap before exiting to avoid spurious non-zero exit code.
+	trap '' 0
 	case $UNAME_RELEASE in
 	*4.0)
 		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
@@ -276,7 +329,7 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
 	# covers most systems running today.  This code pipes the CPU
 	# types through head -n 1, so we only detect the type of CPU 0.
 	ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^  The alpha \(.*\) processor.*$/\1/p' | head -n 1`
-	case "$ALPHA_CPU_TYPE" in
+	case $ALPHA_CPU_TYPE in
 	    "EV4 (21064)")
 		UNAME_MACHINE=alpha ;;
 	    "EV4.5 (21064)")
@@ -313,126 +366,121 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
 	# A Tn.n version is a released field test version.
 	# A Xn.n version is an unreleased experimental baselevel.
 	# 1.2 uses "1.2" for uname -r.
-	echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`
-	# Reset EXIT trap before exiting to avoid spurious non-zero exit code.
-	exitcode=$?
-	trap '' 0
-	exit $exitcode ;;
-    Alpha\ *:Windows_NT*:*)
-	# How do we know it's Interix rather than the generic POSIX subsystem?
-	# Should we change UNAME_MACHINE based on the output of uname instead
-	# of the specific Alpha model?
-	echo alpha-pc-interix
-	exit ;;
-    21064:Windows_NT:50:3)
-	echo alpha-dec-winnt3.5
-	exit ;;
+	OSF_REL=`echo "$UNAME_RELEASE" | sed -e 's/^[PVTX]//' | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`
+	GUESS=$UNAME_MACHINE-dec-osf$OSF_REL
+	;;
     Amiga*:UNIX_System_V:4.0:*)
-	echo m68k-unknown-sysv4
-	exit ;;
+	GUESS=m68k-unknown-sysv4
+	;;
     *:[Aa]miga[Oo][Ss]:*:*)
-	echo ${UNAME_MACHINE}-unknown-amigaos
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-amigaos
+	;;
     *:[Mm]orph[Oo][Ss]:*:*)
-	echo ${UNAME_MACHINE}-unknown-morphos
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-morphos
+	;;
     *:OS/390:*:*)
-	echo i370-ibm-openedition
-	exit ;;
+	GUESS=i370-ibm-openedition
+	;;
     *:z/VM:*:*)
-	echo s390-ibm-zvmoe
-	exit ;;
+	GUESS=s390-ibm-zvmoe
+	;;
     *:OS400:*:*)
-	echo powerpc-ibm-os400
-	exit ;;
+	GUESS=powerpc-ibm-os400
+	;;
     arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
-	echo arm-acorn-riscix${UNAME_RELEASE}
-	exit ;;
+	GUESS=arm-acorn-riscix$UNAME_RELEASE
+	;;
     arm*:riscos:*:*|arm*:RISCOS:*:*)
-	echo arm-unknown-riscos
-	exit ;;
+	GUESS=arm-unknown-riscos
+	;;
     SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)
-	echo hppa1.1-hitachi-hiuxmpp
-	exit ;;
+	GUESS=hppa1.1-hitachi-hiuxmpp
+	;;
     Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)
 	# akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE.
-	if test "`(/bin/universe) 2>/dev/null`" = att ; then
-		echo pyramid-pyramid-sysv3
-	else
-		echo pyramid-pyramid-bsd
-	fi
-	exit ;;
+	case `(/bin/universe) 2>/dev/null` in
+	    att) GUESS=pyramid-pyramid-sysv3 ;;
+	    *)   GUESS=pyramid-pyramid-bsd   ;;
+	esac
+	;;
     NILE*:*:*:dcosx)
-	echo pyramid-pyramid-svr4
-	exit ;;
+	GUESS=pyramid-pyramid-svr4
+	;;
     DRS?6000:unix:4.0:6*)
-	echo sparc-icl-nx6
-	exit ;;
+	GUESS=sparc-icl-nx6
+	;;
     DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*)
 	case `/usr/bin/uname -p` in
-	    sparc) echo sparc-icl-nx7; exit ;;
-	esac ;;
+	    sparc) GUESS=sparc-icl-nx7 ;;
+	esac
+	;;
     s390x:SunOS:*:*)
-	echo ${UNAME_MACHINE}-ibm-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
-	exit ;;
+	SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`
+	GUESS=$UNAME_MACHINE-ibm-solaris2$SUN_REL
+	;;
     sun4H:SunOS:5.*:*)
-	echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
-	exit ;;
+	SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`
+	GUESS=sparc-hal-solaris2$SUN_REL
+	;;
     sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)
-	echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
-	exit ;;
+	SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`
+	GUESS=sparc-sun-solaris2$SUN_REL
+	;;
     i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*)
-	echo i386-pc-auroraux${UNAME_RELEASE}
-	exit ;;
+	GUESS=i386-pc-auroraux$UNAME_RELEASE
+	;;
     i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*)
-	eval $set_cc_for_build
+	set_cc_for_build
 	SUN_ARCH=i386
 	# If there is a compiler, see if it is configured for 64-bit objects.
 	# Note that the Sun cc does not turn __LP64__ into 1 like gcc does.
 	# This test works for both compilers.
-	if [ "$CC_FOR_BUILD" != no_compiler_found ]; then
+	if test "$CC_FOR_BUILD" != no_compiler_found; then
 	    if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \
-		(CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
+		(CCOPTS="" $CC_FOR_BUILD -m64 -E - 2>/dev/null) | \
 		grep IS_64BIT_ARCH >/dev/null
 	    then
 		SUN_ARCH=x86_64
 	    fi
 	fi
-	echo ${SUN_ARCH}-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
-	exit ;;
+	SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`
+	GUESS=$SUN_ARCH-pc-solaris2$SUN_REL
+	;;
     sun4*:SunOS:6*:*)
 	# According to config.sub, this is the proper way to canonicalize
 	# SunOS6.  Hard to guess exactly what SunOS6 will be like, but
 	# it's likely to be more like Solaris than SunOS4.
-	echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
-	exit ;;
+	SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`
+	GUESS=sparc-sun-solaris3$SUN_REL
+	;;
     sun4*:SunOS:*:*)
-	case "`/usr/bin/arch -k`" in
+	case `/usr/bin/arch -k` in
 	    Series*|S4*)
 		UNAME_RELEASE=`uname -v`
 		;;
 	esac
 	# Japanese Language versions have a version number like `4.1.3-JL'.
-	echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'`
-	exit ;;
+	SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/-/_/'`
+	GUESS=sparc-sun-sunos$SUN_REL
+	;;
     sun3*:SunOS:*:*)
-	echo m68k-sun-sunos${UNAME_RELEASE}
-	exit ;;
+	GUESS=m68k-sun-sunos$UNAME_RELEASE
+	;;
     sun*:*:4.2BSD:*)
 	UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null`
-	test "x${UNAME_RELEASE}" = x && UNAME_RELEASE=3
-	case "`/bin/arch`" in
+	test "x$UNAME_RELEASE" = x && UNAME_RELEASE=3
+	case `/bin/arch` in
 	    sun3)
-		echo m68k-sun-sunos${UNAME_RELEASE}
+		GUESS=m68k-sun-sunos$UNAME_RELEASE
 		;;
 	    sun4)
-		echo sparc-sun-sunos${UNAME_RELEASE}
+		GUESS=sparc-sun-sunos$UNAME_RELEASE
 		;;
 	esac
-	exit ;;
+	;;
     aushp:SunOS:*:*)
-	echo sparc-auspex-sunos${UNAME_RELEASE}
-	exit ;;
+	GUESS=sparc-auspex-sunos$UNAME_RELEASE
+	;;
     # The situation for MiNT is a little confusing.  The machine name
     # can be virtually everything (everything which is not
     # "atarist" or "atariste" at least should have a processor
@@ -442,44 +490,44 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
     # MiNT.  But MiNT is downward compatible to TOS, so this should
     # be no problem.
     atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)
-	echo m68k-atari-mint${UNAME_RELEASE}
-	exit ;;
+	GUESS=m68k-atari-mint$UNAME_RELEASE
+	;;
     atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)
-	echo m68k-atari-mint${UNAME_RELEASE}
-	exit ;;
+	GUESS=m68k-atari-mint$UNAME_RELEASE
+	;;
     *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)
-	echo m68k-atari-mint${UNAME_RELEASE}
-	exit ;;
+	GUESS=m68k-atari-mint$UNAME_RELEASE
+	;;
     milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)
-	echo m68k-milan-mint${UNAME_RELEASE}
-	exit ;;
+	GUESS=m68k-milan-mint$UNAME_RELEASE
+	;;
     hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)
-	echo m68k-hades-mint${UNAME_RELEASE}
-	exit ;;
+	GUESS=m68k-hades-mint$UNAME_RELEASE
+	;;
     *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
-	echo m68k-unknown-mint${UNAME_RELEASE}
-	exit ;;
+	GUESS=m68k-unknown-mint$UNAME_RELEASE
+	;;
     m68k:machten:*:*)
-	echo m68k-apple-machten${UNAME_RELEASE}
-	exit ;;
+	GUESS=m68k-apple-machten$UNAME_RELEASE
+	;;
     powerpc:machten:*:*)
-	echo powerpc-apple-machten${UNAME_RELEASE}
-	exit ;;
+	GUESS=powerpc-apple-machten$UNAME_RELEASE
+	;;
     RISC*:Mach:*:*)
-	echo mips-dec-mach_bsd4.3
-	exit ;;
+	GUESS=mips-dec-mach_bsd4.3
+	;;
     RISC*:ULTRIX:*:*)
-	echo mips-dec-ultrix${UNAME_RELEASE}
-	exit ;;
+	GUESS=mips-dec-ultrix$UNAME_RELEASE
+	;;
     VAX*:ULTRIX*:*:*)
-	echo vax-dec-ultrix${UNAME_RELEASE}
-	exit ;;
+	GUESS=vax-dec-ultrix$UNAME_RELEASE
+	;;
     2020:CLIX:*:* | 2430:CLIX:*:*)
-	echo clipper-intergraph-clix${UNAME_RELEASE}
-	exit ;;
+	GUESS=clipper-intergraph-clix$UNAME_RELEASE
+	;;
     mips:*:*:UMIPS | mips:*:*:RISCos)
-	eval $set_cc_for_build
-	sed 's/^	//' << EOF >$dummy.c
+	set_cc_for_build
+	sed 's/^	//' << EOF > "$dummy.c"
 #ifdef __cplusplus
 #include <stdio.h>  /* for printf() prototype */
 	int main (int argc, char *argv[]) {
@@ -488,95 +536,96 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
 #endif
 	#if defined (host_mips) && defined (MIPSEB)
 	#if defined (SYSTYPE_SYSV)
-	  printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0);
+	  printf ("mips-mips-riscos%ssysv\\n", argv[1]); exit (0);
 	#endif
 	#if defined (SYSTYPE_SVR4)
-	  printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0);
+	  printf ("mips-mips-riscos%ssvr4\\n", argv[1]); exit (0);
 	#endif
 	#if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD)
-	  printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0);
+	  printf ("mips-mips-riscos%sbsd\\n", argv[1]); exit (0);
 	#endif
 	#endif
 	  exit (-1);
 	}
 EOF
-	$CC_FOR_BUILD -o $dummy $dummy.c &&
-	  dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` &&
-	  SYSTEM_NAME=`$dummy $dummyarg` &&
+	$CC_FOR_BUILD -o "$dummy" "$dummy.c" &&
+	  dummyarg=`echo "$UNAME_RELEASE" | sed -n 's/\([0-9]*\).*/\1/p'` &&
+	  SYSTEM_NAME=`"$dummy" "$dummyarg"` &&
 	    { echo "$SYSTEM_NAME"; exit; }
-	echo mips-mips-riscos${UNAME_RELEASE}
-	exit ;;
+	GUESS=mips-mips-riscos$UNAME_RELEASE
+	;;
     Motorola:PowerMAX_OS:*:*)
-	echo powerpc-motorola-powermax
-	exit ;;
+	GUESS=powerpc-motorola-powermax
+	;;
     Motorola:*:4.3:PL8-*)
-	echo powerpc-harris-powermax
-	exit ;;
+	GUESS=powerpc-harris-powermax
+	;;
     Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*)
-	echo powerpc-harris-powermax
-	exit ;;
+	GUESS=powerpc-harris-powermax
+	;;
     Night_Hawk:Power_UNIX:*:*)
-	echo powerpc-harris-powerunix
-	exit ;;
+	GUESS=powerpc-harris-powerunix
+	;;
     m88k:CX/UX:7*:*)
-	echo m88k-harris-cxux7
-	exit ;;
+	GUESS=m88k-harris-cxux7
+	;;
     m88k:*:4*:R4*)
-	echo m88k-motorola-sysv4
-	exit ;;
+	GUESS=m88k-motorola-sysv4
+	;;
     m88k:*:3*:R3*)
-	echo m88k-motorola-sysv3
-	exit ;;
+	GUESS=m88k-motorola-sysv3
+	;;
     AViiON:dgux:*:*)
 	# DG/UX returns AViiON for all architectures
 	UNAME_PROCESSOR=`/usr/bin/uname -p`
-	if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ]
+	if test "$UNAME_PROCESSOR" = mc88100 || test "$UNAME_PROCESSOR" = mc88110
 	then
-	    if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \
-	       [ ${TARGET_BINARY_INTERFACE}x = x ]
+	    if test "$TARGET_BINARY_INTERFACE"x = m88kdguxelfx || \
+	       test "$TARGET_BINARY_INTERFACE"x = x
 	    then
-		echo m88k-dg-dgux${UNAME_RELEASE}
+		GUESS=m88k-dg-dgux$UNAME_RELEASE
 	    else
-		echo m88k-dg-dguxbcs${UNAME_RELEASE}
+		GUESS=m88k-dg-dguxbcs$UNAME_RELEASE
 	    fi
 	else
-	    echo i586-dg-dgux${UNAME_RELEASE}
+	    GUESS=i586-dg-dgux$UNAME_RELEASE
 	fi
-	exit ;;
+	;;
     M88*:DolphinOS:*:*)	# DolphinOS (SVR3)
-	echo m88k-dolphin-sysv3
-	exit ;;
+	GUESS=m88k-dolphin-sysv3
+	;;
     M88*:*:R3*:*)
 	# Delta 88k system running SVR3
-	echo m88k-motorola-sysv3
-	exit ;;
+	GUESS=m88k-motorola-sysv3
+	;;
     XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3)
-	echo m88k-tektronix-sysv3
-	exit ;;
+	GUESS=m88k-tektronix-sysv3
+	;;
     Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD)
-	echo m68k-tektronix-bsd
-	exit ;;
+	GUESS=m68k-tektronix-bsd
+	;;
     *:IRIX*:*:*)
-	echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'`
-	exit ;;
+	IRIX_REL=`echo "$UNAME_RELEASE" | sed -e 's/-/_/g'`
+	GUESS=mips-sgi-irix$IRIX_REL
+	;;
     ????????:AIX?:[12].1:2)   # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
-	echo romp-ibm-aix     # uname -m gives an 8 hex-code CPU id
-	exit ;;               # Note that: echo "'`uname -s`'" gives 'AIX '
+	GUESS=romp-ibm-aix    # uname -m gives an 8 hex-code CPU id
+	;;                    # Note that: echo "'`uname -s`'" gives 'AIX '
     i*86:AIX:*:*)
-	echo i386-ibm-aix
-	exit ;;
+	GUESS=i386-ibm-aix
+	;;
     ia64:AIX:*:*)
-	if [ -x /usr/bin/oslevel ] ; then
+	if test -x /usr/bin/oslevel ; then
 		IBM_REV=`/usr/bin/oslevel`
 	else
-		IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
+		IBM_REV=$UNAME_VERSION.$UNAME_RELEASE
 	fi
-	echo ${UNAME_MACHINE}-ibm-aix${IBM_REV}
-	exit ;;
+	GUESS=$UNAME_MACHINE-ibm-aix$IBM_REV
+	;;
     *:AIX:2:3)
 	if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
-		eval $set_cc_for_build
-		sed 's/^		//' << EOF >$dummy.c
+		set_cc_for_build
+		sed 's/^		//' << EOF > "$dummy.c"
 		#include <sys/systemcfg.h>
 
 		main()
@@ -587,77 +636,77 @@ EOF
 			exit(0);
 			}
 EOF
-		if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy`
+		if $CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"`
 		then
-			echo "$SYSTEM_NAME"
+			GUESS=$SYSTEM_NAME
 		else
-			echo rs6000-ibm-aix3.2.5
+			GUESS=rs6000-ibm-aix3.2.5
 		fi
 	elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
-		echo rs6000-ibm-aix3.2.4
+		GUESS=rs6000-ibm-aix3.2.4
 	else
-		echo rs6000-ibm-aix3.2
+		GUESS=rs6000-ibm-aix3.2
 	fi
-	exit ;;
+	;;
     *:AIX:*:[4567])
 	IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'`
-	if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then
+	if /usr/sbin/lsattr -El "$IBM_CPU_ID" | grep ' POWER' >/dev/null 2>&1; then
 		IBM_ARCH=rs6000
 	else
 		IBM_ARCH=powerpc
 	fi
-	if [ -x /usr/bin/lslpp ] ; then
-		IBM_REV=`/usr/bin/lslpp -Lqc bos.rte.libc |
+	if test -x /usr/bin/lslpp ; then
+		IBM_REV=`/usr/bin/lslpp -Lqc bos.rte.libc | \
 			   awk -F: '{ print $3 }' | sed s/[0-9]*$/0/`
 	else
-		IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
+		IBM_REV=$UNAME_VERSION.$UNAME_RELEASE
 	fi
-	echo ${IBM_ARCH}-ibm-aix${IBM_REV}
-	exit ;;
+	GUESS=$IBM_ARCH-ibm-aix$IBM_REV
+	;;
     *:AIX:*:*)
-	echo rs6000-ibm-aix
-	exit ;;
-    ibmrt:4.4BSD:*|romp-ibm:BSD:*)
-	echo romp-ibm-bsd4.4
-	exit ;;
+	GUESS=rs6000-ibm-aix
+	;;
+    ibmrt:4.4BSD:*|romp-ibm:4.4BSD:*)
+	GUESS=romp-ibm-bsd4.4
+	;;
     ibmrt:*BSD:*|romp-ibm:BSD:*)            # covers RT/PC BSD and
-	echo romp-ibm-bsd${UNAME_RELEASE}   # 4.3 with uname added to
-	exit ;;                             # report: romp-ibm BSD 4.3
+	GUESS=romp-ibm-bsd$UNAME_RELEASE    # 4.3 with uname added to
+	;;                                  # report: romp-ibm BSD 4.3
     *:BOSX:*:*)
-	echo rs6000-bull-bosx
-	exit ;;
+	GUESS=rs6000-bull-bosx
+	;;
     DPX/2?00:B.O.S.:*:*)
-	echo m68k-bull-sysv3
-	exit ;;
+	GUESS=m68k-bull-sysv3
+	;;
     9000/[34]??:4.3bsd:1.*:*)
-	echo m68k-hp-bsd
-	exit ;;
+	GUESS=m68k-hp-bsd
+	;;
     hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*)
-	echo m68k-hp-bsd4.4
-	exit ;;
+	GUESS=m68k-hp-bsd4.4
+	;;
     9000/[34678]??:HP-UX:*:*)
-	HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
-	case "${UNAME_MACHINE}" in
-	    9000/31? )            HP_ARCH=m68000 ;;
-	    9000/[34]?? )         HP_ARCH=m68k ;;
+	HPUX_REV=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*.[0B]*//'`
+	case $UNAME_MACHINE in
+	    9000/31?)            HP_ARCH=m68000 ;;
+	    9000/[34]??)         HP_ARCH=m68k ;;
 	    9000/[678][0-9][0-9])
-		if [ -x /usr/bin/getconf ]; then
+		if test -x /usr/bin/getconf; then
 		    sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
 		    sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
-		    case "${sc_cpu_version}" in
+		    case $sc_cpu_version in
 		      523) HP_ARCH=hppa1.0 ;; # CPU_PA_RISC1_0
 		      528) HP_ARCH=hppa1.1 ;; # CPU_PA_RISC1_1
 		      532)                      # CPU_PA_RISC2_0
-			case "${sc_kernel_bits}" in
+			case $sc_kernel_bits in
 			  32) HP_ARCH=hppa2.0n ;;
 			  64) HP_ARCH=hppa2.0w ;;
 			  '') HP_ARCH=hppa2.0 ;;   # HP-UX 10.20
 			esac ;;
 		    esac
 		fi
-		if [ "${HP_ARCH}" = "" ]; then
-		    eval $set_cc_for_build
-		    sed 's/^		//' << EOF >$dummy.c
+		if test "$HP_ARCH" = ""; then
+		    set_cc_for_build
+		    sed 's/^		//' << EOF > "$dummy.c"
 
 		#define _HPUX_SOURCE
 		#include <stdlib.h>
@@ -690,13 +739,13 @@ EOF
 		    exit (0);
 		}
 EOF
-		    (CCOPTS="" $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy`
+		    (CCOPTS="" $CC_FOR_BUILD -o "$dummy" "$dummy.c" 2>/dev/null) && HP_ARCH=`"$dummy"`
 		    test -z "$HP_ARCH" && HP_ARCH=hppa
 		fi ;;
 	esac
-	if [ ${HP_ARCH} = hppa2.0w ]
+	if test "$HP_ARCH" = hppa2.0w
 	then
-	    eval $set_cc_for_build
+	    set_cc_for_build
 
 	    # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating
 	    # 32-bit code.  hppa64-hp-hpux* has the same kernel and a compiler
@@ -715,15 +764,15 @@ EOF
 		HP_ARCH=hppa64
 	    fi
 	fi
-	echo ${HP_ARCH}-hp-hpux${HPUX_REV}
-	exit ;;
+	GUESS=$HP_ARCH-hp-hpux$HPUX_REV
+	;;
     ia64:HP-UX:*:*)
-	HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
-	echo ia64-hp-hpux${HPUX_REV}
-	exit ;;
+	HPUX_REV=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*.[0B]*//'`
+	GUESS=ia64-hp-hpux$HPUX_REV
+	;;
     3050*:HI-UX:*:*)
-	eval $set_cc_for_build
-	sed 's/^	//' << EOF >$dummy.c
+	set_cc_for_build
+	sed 's/^	//' << EOF > "$dummy.c"
 	#include <unistd.h>
 	int
 	main ()
@@ -748,38 +797,38 @@ EOF
 	  exit (0);
 	}
 EOF
-	$CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` &&
+	$CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"` &&
 		{ echo "$SYSTEM_NAME"; exit; }
-	echo unknown-hitachi-hiuxwe2
-	exit ;;
-    9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* )
-	echo hppa1.1-hp-bsd
-	exit ;;
+	GUESS=unknown-hitachi-hiuxwe2
+	;;
+    9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:*)
+	GUESS=hppa1.1-hp-bsd
+	;;
     9000/8??:4.3bsd:*:*)
-	echo hppa1.0-hp-bsd
-	exit ;;
+	GUESS=hppa1.0-hp-bsd
+	;;
     *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*)
-	echo hppa1.0-hp-mpeix
-	exit ;;
-    hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* )
-	echo hppa1.1-hp-osf
-	exit ;;
+	GUESS=hppa1.0-hp-mpeix
+	;;
+    hp7??:OSF1:*:* | hp8?[79]:OSF1:*:*)
+	GUESS=hppa1.1-hp-osf
+	;;
     hp8??:OSF1:*:*)
-	echo hppa1.0-hp-osf
-	exit ;;
+	GUESS=hppa1.0-hp-osf
+	;;
     i*86:OSF1:*:*)
-	if [ -x /usr/sbin/sysversion ] ; then
-	    echo ${UNAME_MACHINE}-unknown-osf1mk
+	if test -x /usr/sbin/sysversion ; then
+	    GUESS=$UNAME_MACHINE-unknown-osf1mk
 	else
-	    echo ${UNAME_MACHINE}-unknown-osf1
+	    GUESS=$UNAME_MACHINE-unknown-osf1
 	fi
-	exit ;;
+	;;
     parisc*:Lites*:*:*)
-	echo hppa1.1-hp-lites
-	exit ;;
+	GUESS=hppa1.1-hp-lites
+	;;
     C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
-	echo c1-convex-bsd
-	exit ;;
+	GUESS=c1-convex-bsd
+	;;
     C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)
 	if getsysinfo -f scalar_acc
 	then echo c32-convex-bsd
@@ -787,140 +836,145 @@ EOF
 	fi
 	exit ;;
     C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)
-	echo c34-convex-bsd
-	exit ;;
+	GUESS=c34-convex-bsd
+	;;
     C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)
-	echo c38-convex-bsd
-	exit ;;
+	GUESS=c38-convex-bsd
+	;;
     C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)
-	echo c4-convex-bsd
-	exit ;;
+	GUESS=c4-convex-bsd
+	;;
     CRAY*Y-MP:*:*:*)
-	echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
+	CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'`
+	GUESS=ymp-cray-unicos$CRAY_REL
+	;;
     CRAY*[A-Z]90:*:*:*)
-	echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \
+	echo "$UNAME_MACHINE"-cray-unicos"$UNAME_RELEASE" \
 	| sed -e 's/CRAY.*\([A-Z]90\)/\1/' \
 	      -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \
 	      -e 's/\.[^.]*$/.X/'
 	exit ;;
     CRAY*TS:*:*:*)
-	echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
+	CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'`
+	GUESS=t90-cray-unicos$CRAY_REL
+	;;
     CRAY*T3E:*:*:*)
-	echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
+	CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'`
+	GUESS=alphaev5-cray-unicosmk$CRAY_REL
+	;;
     CRAY*SV1:*:*:*)
-	echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
+	CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'`
+	GUESS=sv1-cray-unicos$CRAY_REL
+	;;
     *:UNICOS/mp:*:*)
-	echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
+	CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'`
+	GUESS=craynv-cray-unicosmp$CRAY_REL
+	;;
     F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)
 	FUJITSU_PROC=`uname -m | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`
 	FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'`
-	FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'`
-	echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
-	exit ;;
+	FUJITSU_REL=`echo "$UNAME_RELEASE" | sed -e 's/ /_/'`
+	GUESS=${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}
+	;;
     5000:UNIX_System_V:4.*:*)
 	FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'`
-	FUJITSU_REL=`echo ${UNAME_RELEASE} | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/ /_/'`
-	echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
-	exit ;;
+	FUJITSU_REL=`echo "$UNAME_RELEASE" | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/ /_/'`
+	GUESS=sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}
+	;;
     i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
-	echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE}
-	exit ;;
+	GUESS=$UNAME_MACHINE-pc-bsdi$UNAME_RELEASE
+	;;
     sparc*:BSD/OS:*:*)
-	echo sparc-unknown-bsdi${UNAME_RELEASE}
-	exit ;;
+	GUESS=sparc-unknown-bsdi$UNAME_RELEASE
+	;;
     *:BSD/OS:*:*)
-	echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE}
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-bsdi$UNAME_RELEASE
+	;;
+    arm:FreeBSD:*:*)
+	UNAME_PROCESSOR=`uname -p`
+	set_cc_for_build
+	if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \
+	    | grep -q __ARM_PCS_VFP
+	then
+	    FREEBSD_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'`
+	    GUESS=$UNAME_PROCESSOR-unknown-freebsd$FREEBSD_REL-gnueabi
+	else
+	    FREEBSD_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'`
+	    GUESS=$UNAME_PROCESSOR-unknown-freebsd$FREEBSD_REL-gnueabihf
+	fi
+	;;
     *:FreeBSD:*:*)
 	UNAME_PROCESSOR=`/usr/bin/uname -p`
-	case ${UNAME_PROCESSOR} in
+	case $UNAME_PROCESSOR in
 	    amd64)
 		UNAME_PROCESSOR=x86_64 ;;
 	    i386)
 		UNAME_PROCESSOR=i586 ;;
 	esac
-	echo ${UNAME_PROCESSOR}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`
-	exit ;;
+	FREEBSD_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'`
+	GUESS=$UNAME_PROCESSOR-unknown-freebsd$FREEBSD_REL
+	;;
     i*:CYGWIN*:*)
-	echo ${UNAME_MACHINE}-pc-cygwin
-	exit ;;
+	GUESS=$UNAME_MACHINE-pc-cygwin
+	;;
     *:MINGW64*:*)
-	echo ${UNAME_MACHINE}-pc-mingw64
-	exit ;;
+	GUESS=$UNAME_MACHINE-pc-mingw64
+	;;
     *:MINGW*:*)
-	echo ${UNAME_MACHINE}-pc-mingw32
-	exit ;;
+	GUESS=$UNAME_MACHINE-pc-mingw32
+	;;
     *:MSYS*:*)
-	echo ${UNAME_MACHINE}-pc-msys
-	exit ;;
-    i*:windows32*:*)
-	# uname -m includes "-pc" on this system.
-	echo ${UNAME_MACHINE}-mingw32
-	exit ;;
+	GUESS=$UNAME_MACHINE-pc-msys
+	;;
     i*:PW*:*)
-	echo ${UNAME_MACHINE}-pc-pw32
-	exit ;;
+	GUESS=$UNAME_MACHINE-pc-pw32
+	;;
     *:Interix*:*)
-	case ${UNAME_MACHINE} in
+	case $UNAME_MACHINE in
 	    x86)
-		echo i586-pc-interix${UNAME_RELEASE}
-		exit ;;
+		GUESS=i586-pc-interix$UNAME_RELEASE
+		;;
 	    authenticamd | genuineintel | EM64T)
-		echo x86_64-unknown-interix${UNAME_RELEASE}
-		exit ;;
+		GUESS=x86_64-unknown-interix$UNAME_RELEASE
+		;;
 	    IA64)
-		echo ia64-unknown-interix${UNAME_RELEASE}
-		exit ;;
+		GUESS=ia64-unknown-interix$UNAME_RELEASE
+		;;
 	esac ;;
-    [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*)
-	echo i${UNAME_MACHINE}-pc-mks
-	exit ;;
-    8664:Windows_NT:*)
-	echo x86_64-pc-mks
-	exit ;;
-    i*:Windows_NT*:* | Pentium*:Windows_NT*:*)
-	# How do we know it's Interix rather than the generic POSIX subsystem?
-	# It also conflicts with pre-2.0 versions of AT&T UWIN. Should we
-	# UNAME_MACHINE based on the output of uname instead of i386?
-	echo i586-pc-interix
-	exit ;;
     i*:UWIN*:*)
-	echo ${UNAME_MACHINE}-pc-uwin
-	exit ;;
+	GUESS=$UNAME_MACHINE-pc-uwin
+	;;
     amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*)
-	echo x86_64-unknown-cygwin
-	exit ;;
-    p*:CYGWIN*:*)
-	echo powerpcle-unknown-cygwin
-	exit ;;
+	GUESS=x86_64-pc-cygwin
+	;;
     prep*:SunOS:5.*:*)
-	echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
-	exit ;;
+	SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`
+	GUESS=powerpcle-unknown-solaris2$SUN_REL
+	;;
     *:GNU:*:*)
 	# the GNU system
-	echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-${LIBC}`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'`
-	exit ;;
+	GNU_ARCH=`echo "$UNAME_MACHINE" | sed -e 's,[-/].*$,,'`
+	GNU_REL=`echo "$UNAME_RELEASE" | sed -e 's,/.*$,,'`
+	GUESS=$GNU_ARCH-unknown-$LIBC$GNU_REL
+	;;
     *:GNU/*:*:*)
 	# other systems with GNU libc and userland
-	echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr "[:upper:]" "[:lower:]"``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-${LIBC}
-	exit ;;
-    i*86:Minix:*:*)
-	echo ${UNAME_MACHINE}-pc-minix
-	exit ;;
+	GNU_SYS=`echo "$UNAME_SYSTEM" | sed 's,^[^/]*/,,' | tr "[:upper:]" "[:lower:]"`
+	GNU_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'`
+	GUESS=$UNAME_MACHINE-unknown-$GNU_SYS$GNU_REL-$LIBC
+	;;
+    *:Minix:*:*)
+	GUESS=$UNAME_MACHINE-unknown-minix
+	;;
     aarch64:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     aarch64_be:Linux:*:*)
 	UNAME_MACHINE=aarch64_be
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     alpha:Linux:*:*)
-	case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in
+	case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' /proc/cpuinfo 2>/dev/null` in
 	  EV5)   UNAME_MACHINE=alphaev5 ;;
 	  EV56)  UNAME_MACHINE=alphaev56 ;;
 	  PCA56) UNAME_MACHINE=alphapca56 ;;
@@ -931,183 +985,225 @@ EOF
 	esac
 	objdump --private-headers /bin/sh | grep -q ld.so.1
 	if test "$?" = 0 ; then LIBC=gnulibc1 ; fi
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
-	exit ;;
-    arc:Linux:*:* | arceb:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
+    arc:Linux:*:* | arceb:Linux:*:* | arc32:Linux:*:* | arc64:Linux:*:*)
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     arm*:Linux:*:*)
-	eval $set_cc_for_build
+	set_cc_for_build
 	if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \
 	    | grep -q __ARM_EABI__
 	then
-	    echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	    GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
 	else
 	    if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \
 		| grep -q __ARM_PCS_VFP
 	    then
-		echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabi
+		GUESS=$UNAME_MACHINE-unknown-linux-${LIBC}eabi
 	    else
-		echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabihf
+		GUESS=$UNAME_MACHINE-unknown-linux-${LIBC}eabihf
 	    fi
 	fi
-	exit ;;
+	;;
     avr32*:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     cris:Linux:*:*)
-	echo ${UNAME_MACHINE}-axis-linux-${LIBC}
-	exit ;;
+	GUESS=$UNAME_MACHINE-axis-linux-$LIBC
+	;;
     crisv32:Linux:*:*)
-	echo ${UNAME_MACHINE}-axis-linux-${LIBC}
-	exit ;;
+	GUESS=$UNAME_MACHINE-axis-linux-$LIBC
+	;;
     e2k:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     frv:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     hexagon:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     i*86:Linux:*:*)
-	echo ${UNAME_MACHINE}-pc-linux-${LIBC}
-	exit ;;
+	GUESS=$UNAME_MACHINE-pc-linux-$LIBC
+	;;
     ia64:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     k1om:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
+    loongarch32:Linux:*:* | loongarch64:Linux:*:* | loongarchx32:Linux:*:*)
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     m32r*:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     m68*:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     mips:Linux:*:* | mips64:Linux:*:*)
-	eval $set_cc_for_build
-	sed 's/^	//' << EOF >$dummy.c
+	set_cc_for_build
+	IS_GLIBC=0
+	test x"${LIBC}" = xgnu && IS_GLIBC=1
+	sed 's/^	//' << EOF > "$dummy.c"
 	#undef CPU
-	#undef ${UNAME_MACHINE}
-	#undef ${UNAME_MACHINE}el
+	#undef mips
+	#undef mipsel
+	#undef mips64
+	#undef mips64el
+	#if ${IS_GLIBC} && defined(_ABI64)
+	LIBCABI=gnuabi64
+	#else
+	#if ${IS_GLIBC} && defined(_ABIN32)
+	LIBCABI=gnuabin32
+	#else
+	LIBCABI=${LIBC}
+	#endif
+	#endif
+
+	#if ${IS_GLIBC} && defined(__mips64) && defined(__mips_isa_rev) && __mips_isa_rev>=6
+	CPU=mipsisa64r6
+	#else
+	#if ${IS_GLIBC} && !defined(__mips64) && defined(__mips_isa_rev) && __mips_isa_rev>=6
+	CPU=mipsisa32r6
+	#else
+	#if defined(__mips64)
+	CPU=mips64
+	#else
+	CPU=mips
+	#endif
+	#endif
+	#endif
+
 	#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
-	CPU=${UNAME_MACHINE}el
+	MIPS_ENDIAN=el
 	#else
 	#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
-	CPU=${UNAME_MACHINE}
+	MIPS_ENDIAN=
 	#else
-	CPU=
+	MIPS_ENDIAN=
 	#endif
 	#endif
 EOF
-	eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^CPU'`
-	test x"${CPU}" != x && { echo "${CPU}-unknown-linux-${LIBC}"; exit; }
+	cc_set_vars=`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^CPU\|^MIPS_ENDIAN\|^LIBCABI'`
+	eval "$cc_set_vars"
+	test "x$CPU" != x && { echo "$CPU${MIPS_ENDIAN}-unknown-linux-$LIBCABI"; exit; }
 	;;
     mips64el:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     openrisc*:Linux:*:*)
-	echo or1k-unknown-linux-${LIBC}
-	exit ;;
+	GUESS=or1k-unknown-linux-$LIBC
+	;;
     or32:Linux:*:* | or1k*:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     padre:Linux:*:*)
-	echo sparc-unknown-linux-${LIBC}
-	exit ;;
+	GUESS=sparc-unknown-linux-$LIBC
+	;;
     parisc64:Linux:*:* | hppa64:Linux:*:*)
-	echo hppa64-unknown-linux-${LIBC}
-	exit ;;
+	GUESS=hppa64-unknown-linux-$LIBC
+	;;
     parisc:Linux:*:* | hppa:Linux:*:*)
 	# Look for CPU level
 	case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in
-	  PA7*) echo hppa1.1-unknown-linux-${LIBC} ;;
-	  PA8*) echo hppa2.0-unknown-linux-${LIBC} ;;
-	  *)    echo hppa-unknown-linux-${LIBC} ;;
+	  PA7*) GUESS=hppa1.1-unknown-linux-$LIBC ;;
+	  PA8*) GUESS=hppa2.0-unknown-linux-$LIBC ;;
+	  *)    GUESS=hppa-unknown-linux-$LIBC ;;
 	esac
-	exit ;;
+	;;
     ppc64:Linux:*:*)
-	echo powerpc64-unknown-linux-${LIBC}
-	exit ;;
+	GUESS=powerpc64-unknown-linux-$LIBC
+	;;
     ppc:Linux:*:*)
-	echo powerpc-unknown-linux-${LIBC}
-	exit ;;
+	GUESS=powerpc-unknown-linux-$LIBC
+	;;
     ppc64le:Linux:*:*)
-	echo powerpc64le-unknown-linux-${LIBC}
-	exit ;;
+	GUESS=powerpc64le-unknown-linux-$LIBC
+	;;
     ppcle:Linux:*:*)
-	echo powerpcle-unknown-linux-${LIBC}
-	exit ;;
-    riscv32:Linux:*:* | riscv64:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
-	exit ;;
+	GUESS=powerpcle-unknown-linux-$LIBC
+	;;
+    riscv32:Linux:*:* | riscv32be:Linux:*:* | riscv64:Linux:*:* | riscv64be:Linux:*:*)
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     s390:Linux:*:* | s390x:Linux:*:*)
-	echo ${UNAME_MACHINE}-ibm-linux-${LIBC}
-	exit ;;
+	GUESS=$UNAME_MACHINE-ibm-linux-$LIBC
+	;;
     sh64*:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     sh*:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     sparc:Linux:*:* | sparc64:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     tile*:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     vax:Linux:*:*)
-	echo ${UNAME_MACHINE}-dec-linux-${LIBC}
-	exit ;;
+	GUESS=$UNAME_MACHINE-dec-linux-$LIBC
+	;;
     x86_64:Linux:*:*)
-	echo ${UNAME_MACHINE}-pc-linux-${LIBC}
-	exit ;;
+	set_cc_for_build
+	LIBCABI=$LIBC
+	if test "$CC_FOR_BUILD" != no_compiler_found; then
+	    if (echo '#ifdef __ILP32__'; echo IS_X32; echo '#endif') | \
+		(CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
+		grep IS_X32 >/dev/null
+	    then
+		LIBCABI=${LIBC}x32
+	    fi
+	fi
+	GUESS=$UNAME_MACHINE-pc-linux-$LIBCABI
+	;;
     xtensa*:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     i*86:DYNIX/ptx:4*:*)
 	# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.
 	# earlier versions are messed up and put the nodename in both
 	# sysname and nodename.
-	echo i386-sequent-sysv4
-	exit ;;
+	GUESS=i386-sequent-sysv4
+	;;
     i*86:UNIX_SV:4.2MP:2.*)
 	# Unixware is an offshoot of SVR4, but it has its own version
 	# number series starting with 2...
 	# I am not positive that other SVR4 systems won't match this,
 	# I just have to hope.  -- rms.
 	# Use sysv4.2uw... so that sysv4* matches it.
-	echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION}
-	exit ;;
+	GUESS=$UNAME_MACHINE-pc-sysv4.2uw$UNAME_VERSION
+	;;
     i*86:OS/2:*:*)
 	# If we were able to find `uname', then EMX Unix compatibility
 	# is probably installed.
-	echo ${UNAME_MACHINE}-pc-os2-emx
-	exit ;;
+	GUESS=$UNAME_MACHINE-pc-os2-emx
+	;;
     i*86:XTS-300:*:STOP)
-	echo ${UNAME_MACHINE}-unknown-stop
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-stop
+	;;
     i*86:atheos:*:*)
-	echo ${UNAME_MACHINE}-unknown-atheos
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-atheos
+	;;
     i*86:syllable:*:*)
-	echo ${UNAME_MACHINE}-pc-syllable
-	exit ;;
+	GUESS=$UNAME_MACHINE-pc-syllable
+	;;
     i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*)
-	echo i386-unknown-lynxos${UNAME_RELEASE}
-	exit ;;
+	GUESS=i386-unknown-lynxos$UNAME_RELEASE
+	;;
     i*86:*DOS:*:*)
-	echo ${UNAME_MACHINE}-pc-msdosdjgpp
-	exit ;;
-    i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*)
-	UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'`
+	GUESS=$UNAME_MACHINE-pc-msdosdjgpp
+	;;
+    i*86:*:4.*:*)
+	UNAME_REL=`echo "$UNAME_RELEASE" | sed 's/\/MP$//'`
 	if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
-		echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL}
+		GUESS=$UNAME_MACHINE-univel-sysv$UNAME_REL
 	else
-		echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL}
+		GUESS=$UNAME_MACHINE-pc-sysv$UNAME_REL
 	fi
-	exit ;;
+	;;
     i*86:*:5:[678]*)
 	# UnixWare 7.x, OpenUNIX and OpenServer 6.
 	case `/bin/uname -X | grep "^Machine"` in
@@ -1115,12 +1211,12 @@ EOF
 	    *Pentium)	     UNAME_MACHINE=i586 ;;
 	    *Pent*|*Celeron) UNAME_MACHINE=i686 ;;
 	esac
-	echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION}
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION}
+	;;
     i*86:*:3.2:*)
 	if test -f /usr/options/cb.name; then
 		UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`
-		echo ${UNAME_MACHINE}-pc-isc$UNAME_REL
+		GUESS=$UNAME_MACHINE-pc-isc$UNAME_REL
 	elif /bin/uname -X 2>/dev/null >/dev/null ; then
 		UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')`
 		(/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486
@@ -1130,11 +1226,11 @@ EOF
 			&& UNAME_MACHINE=i686
 		(/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \
 			&& UNAME_MACHINE=i686
-		echo ${UNAME_MACHINE}-pc-sco$UNAME_REL
+		GUESS=$UNAME_MACHINE-pc-sco$UNAME_REL
 	else
-		echo ${UNAME_MACHINE}-pc-sysv32
+		GUESS=$UNAME_MACHINE-pc-sysv32
 	fi
-	exit ;;
+	;;
     pc:*:*:*)
 	# Left here for compatibility:
 	# uname -m prints for DJGPP always 'pc', but it prints nothing about
@@ -1142,31 +1238,31 @@ EOF
 	# Note: whatever this is, it MUST be the same as what config.sub
 	# prints for the "djgpp" host, or else GDB configure will decide that
 	# this is a cross-build.
-	echo i586-pc-msdosdjgpp
-	exit ;;
+	GUESS=i586-pc-msdosdjgpp
+	;;
     Intel:Mach:3*:*)
-	echo i386-pc-mach3
-	exit ;;
+	GUESS=i386-pc-mach3
+	;;
     paragon:*:*:*)
-	echo i860-intel-osf1
-	exit ;;
+	GUESS=i860-intel-osf1
+	;;
     i860:*:4.*:*) # i860-SVR4
 	if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then
-	  echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4
+	  GUESS=i860-stardent-sysv$UNAME_RELEASE    # Stardent Vistra i860-SVR4
 	else # Add other i860-SVR4 vendors below as they are discovered.
-	  echo i860-unknown-sysv${UNAME_RELEASE}  # Unknown i860-SVR4
+	  GUESS=i860-unknown-sysv$UNAME_RELEASE     # Unknown i860-SVR4
 	fi
-	exit ;;
+	;;
     mini*:CTIX:SYS*5:*)
 	# "miniframe"
-	echo m68010-convergent-sysv
-	exit ;;
+	GUESS=m68010-convergent-sysv
+	;;
     mc68k:UNIX:SYSTEM5:3.51m)
-	echo m68k-convergent-sysv
-	exit ;;
+	GUESS=m68k-convergent-sysv
+	;;
     M680?0:D-NIX:5.3:*)
-	echo m68k-diab-dnix
-	exit ;;
+	GUESS=m68k-diab-dnix
+	;;
     M68*:*:R3V[5678]*:*)
 	test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;;
     3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0)
@@ -1174,9 +1270,9 @@ EOF
 	test -r /etc/.relid \
 	&& OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
 	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
-	  && { echo i486-ncr-sysv4.3${OS_REL}; exit; }
+	  && { echo i486-ncr-sysv4.3"$OS_REL"; exit; }
 	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
-	  && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
+	  && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;;
     3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
 	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
 	  && { echo i486-ncr-sysv4; exit; } ;;
@@ -1185,259 +1281,437 @@ EOF
 	test -r /etc/.relid \
 	    && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
 	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
-	    && { echo i486-ncr-sysv4.3${OS_REL}; exit; }
+	    && { echo i486-ncr-sysv4.3"$OS_REL"; exit; }
 	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
-	    && { echo i586-ncr-sysv4.3${OS_REL}; exit; }
+	    && { echo i586-ncr-sysv4.3"$OS_REL"; exit; }
 	/bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \
-	    && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
+	    && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;;
     m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
-	echo m68k-unknown-lynxos${UNAME_RELEASE}
-	exit ;;
+	GUESS=m68k-unknown-lynxos$UNAME_RELEASE
+	;;
     mc68030:UNIX_System_V:4.*:*)
-	echo m68k-atari-sysv4
-	exit ;;
+	GUESS=m68k-atari-sysv4
+	;;
     TSUNAMI:LynxOS:2.*:*)
-	echo sparc-unknown-lynxos${UNAME_RELEASE}
-	exit ;;
+	GUESS=sparc-unknown-lynxos$UNAME_RELEASE
+	;;
     rs6000:LynxOS:2.*:*)
-	echo rs6000-unknown-lynxos${UNAME_RELEASE}
-	exit ;;
+	GUESS=rs6000-unknown-lynxos$UNAME_RELEASE
+	;;
     PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*)
-	echo powerpc-unknown-lynxos${UNAME_RELEASE}
-	exit ;;
+	GUESS=powerpc-unknown-lynxos$UNAME_RELEASE
+	;;
     SM[BE]S:UNIX_SV:*:*)
-	echo mips-dde-sysv${UNAME_RELEASE}
-	exit ;;
+	GUESS=mips-dde-sysv$UNAME_RELEASE
+	;;
     RM*:ReliantUNIX-*:*:*)
-	echo mips-sni-sysv4
-	exit ;;
+	GUESS=mips-sni-sysv4
+	;;
     RM*:SINIX-*:*:*)
-	echo mips-sni-sysv4
-	exit ;;
+	GUESS=mips-sni-sysv4
+	;;
     *:SINIX-*:*:*)
 	if uname -p 2>/dev/null >/dev/null ; then
 		UNAME_MACHINE=`(uname -p) 2>/dev/null`
-		echo ${UNAME_MACHINE}-sni-sysv4
+		GUESS=$UNAME_MACHINE-sni-sysv4
 	else
-		echo ns32k-sni-sysv
+		GUESS=ns32k-sni-sysv
 	fi
-	exit ;;
+	;;
     PENTIUM:*:4.0*:*)	# Unisys `ClearPath HMP IX 4000' SVR4/MP effort
 			# says <Richard.M.Bartel@ccMail.Census.GOV>
-	echo i586-unisys-sysv4
-	exit ;;
+	GUESS=i586-unisys-sysv4
+	;;
     *:UNIX_System_V:4*:FTX*)
 	# From Gerald Hewes <hewes@openmarket.com>.
 	# How about differentiating between stratus architectures? -djm
-	echo hppa1.1-stratus-sysv4
-	exit ;;
+	GUESS=hppa1.1-stratus-sysv4
+	;;
     *:*:*:FTX*)
 	# From seanf@swdc.stratus.com.
-	echo i860-stratus-sysv4
-	exit ;;
+	GUESS=i860-stratus-sysv4
+	;;
     i*86:VOS:*:*)
 	# From Paul.Green@stratus.com.
-	echo ${UNAME_MACHINE}-stratus-vos
-	exit ;;
+	GUESS=$UNAME_MACHINE-stratus-vos
+	;;
     *:VOS:*:*)
 	# From Paul.Green@stratus.com.
-	echo hppa1.1-stratus-vos
-	exit ;;
+	GUESS=hppa1.1-stratus-vos
+	;;
     mc68*:A/UX:*:*)
-	echo m68k-apple-aux${UNAME_RELEASE}
-	exit ;;
+	GUESS=m68k-apple-aux$UNAME_RELEASE
+	;;
     news*:NEWS-OS:6*:*)
-	echo mips-sony-newsos6
-	exit ;;
+	GUESS=mips-sony-newsos6
+	;;
     R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
-	if [ -d /usr/nec ]; then
-		echo mips-nec-sysv${UNAME_RELEASE}
+	if test -d /usr/nec; then
+		GUESS=mips-nec-sysv$UNAME_RELEASE
 	else
-		echo mips-unknown-sysv${UNAME_RELEASE}
+		GUESS=mips-unknown-sysv$UNAME_RELEASE
 	fi
-	exit ;;
+	;;
     BeBox:BeOS:*:*)	# BeOS running on hardware made by Be, PPC only.
-	echo powerpc-be-beos
-	exit ;;
+	GUESS=powerpc-be-beos
+	;;
     BeMac:BeOS:*:*)	# BeOS running on Mac or Mac clone, PPC only.
-	echo powerpc-apple-beos
-	exit ;;
+	GUESS=powerpc-apple-beos
+	;;
     BePC:BeOS:*:*)	# BeOS running on Intel PC compatible.
-	echo i586-pc-beos
-	exit ;;
+	GUESS=i586-pc-beos
+	;;
     BePC:Haiku:*:*)	# Haiku running on Intel PC compatible.
-	echo i586-pc-haiku
-	exit ;;
+	GUESS=i586-pc-haiku
+	;;
     x86_64:Haiku:*:*)
-	echo x86_64-unknown-haiku
-	exit ;;
+	GUESS=x86_64-unknown-haiku
+	;;
     SX-4:SUPER-UX:*:*)
-	echo sx4-nec-superux${UNAME_RELEASE}
-	exit ;;
+	GUESS=sx4-nec-superux$UNAME_RELEASE
+	;;
     SX-5:SUPER-UX:*:*)
-	echo sx5-nec-superux${UNAME_RELEASE}
-	exit ;;
+	GUESS=sx5-nec-superux$UNAME_RELEASE
+	;;
     SX-6:SUPER-UX:*:*)
-	echo sx6-nec-superux${UNAME_RELEASE}
-	exit ;;
+	GUESS=sx6-nec-superux$UNAME_RELEASE
+	;;
     SX-7:SUPER-UX:*:*)
-	echo sx7-nec-superux${UNAME_RELEASE}
-	exit ;;
+	GUESS=sx7-nec-superux$UNAME_RELEASE
+	;;
     SX-8:SUPER-UX:*:*)
-	echo sx8-nec-superux${UNAME_RELEASE}
-	exit ;;
+	GUESS=sx8-nec-superux$UNAME_RELEASE
+	;;
     SX-8R:SUPER-UX:*:*)
-	echo sx8r-nec-superux${UNAME_RELEASE}
-	exit ;;
+	GUESS=sx8r-nec-superux$UNAME_RELEASE
+	;;
     SX-ACE:SUPER-UX:*:*)
-	echo sxace-nec-superux${UNAME_RELEASE}
-	exit ;;
+	GUESS=sxace-nec-superux$UNAME_RELEASE
+	;;
     Power*:Rhapsody:*:*)
-	echo powerpc-apple-rhapsody${UNAME_RELEASE}
-	exit ;;
+	GUESS=powerpc-apple-rhapsody$UNAME_RELEASE
+	;;
     *:Rhapsody:*:*)
-	echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE}
-	exit ;;
+	GUESS=$UNAME_MACHINE-apple-rhapsody$UNAME_RELEASE
+	;;
+    arm64:Darwin:*:*)
+	GUESS=aarch64-apple-darwin$UNAME_RELEASE
+	;;
     *:Darwin:*:*)
-	UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown
-	eval $set_cc_for_build
-	if test "$UNAME_PROCESSOR" = unknown ; then
-	    UNAME_PROCESSOR=powerpc
+	UNAME_PROCESSOR=`uname -p`
+	case $UNAME_PROCESSOR in
+	    unknown) UNAME_PROCESSOR=powerpc ;;
+	esac
+	if command -v xcode-select > /dev/null 2> /dev/null && \
+		! xcode-select --print-path > /dev/null 2> /dev/null ; then
+	    # Avoid executing cc if there is no toolchain installed as
+	    # cc will be a stub that puts up a graphical alert
+	    # prompting the user to install developer tools.
+	    CC_FOR_BUILD=no_compiler_found
+	else
+	    set_cc_for_build
 	fi
-	if test `echo "$UNAME_RELEASE" | sed -e 's/\..*//'` -le 10 ; then
-	    if [ "$CC_FOR_BUILD" != no_compiler_found ]; then
-		if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \
-		       (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
-		       grep IS_64BIT_ARCH >/dev/null
-		then
-		    case $UNAME_PROCESSOR in
-			i386) UNAME_PROCESSOR=x86_64 ;;
-			powerpc) UNAME_PROCESSOR=powerpc64 ;;
-		    esac
-		fi
-		# On 10.4-10.6 one might compile for PowerPC via gcc -arch ppc
-		if (echo '#ifdef __POWERPC__'; echo IS_PPC; echo '#endif') | \
-		       (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
-		       grep IS_PPC >/dev/null
-		then
-		    UNAME_PROCESSOR=powerpc
-		fi
+	if test "$CC_FOR_BUILD" != no_compiler_found; then
+	    if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \
+		   (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
+		   grep IS_64BIT_ARCH >/dev/null
+	    then
+		case $UNAME_PROCESSOR in
+		    i386) UNAME_PROCESSOR=x86_64 ;;
+		    powerpc) UNAME_PROCESSOR=powerpc64 ;;
+		esac
+	    fi
+	    # On 10.4-10.6 one might compile for PowerPC via gcc -arch ppc
+	    if (echo '#ifdef __POWERPC__'; echo IS_PPC; echo '#endif') | \
+		   (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
+		   grep IS_PPC >/dev/null
+	    then
+		UNAME_PROCESSOR=powerpc
 	    fi
 	elif test "$UNAME_PROCESSOR" = i386 ; then
-	    # Avoid executing cc on OS X 10.9, as it ships with a stub
-	    # that puts up a graphical alert prompting to install
-	    # developer tools.  Any system running Mac OS X 10.7 or
-	    # later (Darwin 11 and later) is required to have a 64-bit
-	    # processor. This is not true of the ARM version of Darwin
-	    # that Apple uses in portable devices.
-	    UNAME_PROCESSOR=x86_64
+	    # uname -m returns i386 or x86_64
+	    UNAME_PROCESSOR=$UNAME_MACHINE
 	fi
-	echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE}
-	exit ;;
+	GUESS=$UNAME_PROCESSOR-apple-darwin$UNAME_RELEASE
+	;;
     *:procnto*:*:* | *:QNX:[0123456789]*:*)
 	UNAME_PROCESSOR=`uname -p`
 	if test "$UNAME_PROCESSOR" = x86; then
 		UNAME_PROCESSOR=i386
 		UNAME_MACHINE=pc
 	fi
-	echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE}
-	exit ;;
+	GUESS=$UNAME_PROCESSOR-$UNAME_MACHINE-nto-qnx$UNAME_RELEASE
+	;;
     *:QNX:*:4*)
-	echo i386-pc-qnx
-	exit ;;
+	GUESS=i386-pc-qnx
+	;;
     NEO-*:NONSTOP_KERNEL:*:*)
-	echo neo-tandem-nsk${UNAME_RELEASE}
-	exit ;;
+	GUESS=neo-tandem-nsk$UNAME_RELEASE
+	;;
     NSE-*:NONSTOP_KERNEL:*:*)
-	echo nse-tandem-nsk${UNAME_RELEASE}
-	exit ;;
+	GUESS=nse-tandem-nsk$UNAME_RELEASE
+	;;
     NSR-*:NONSTOP_KERNEL:*:*)
-	echo nsr-tandem-nsk${UNAME_RELEASE}
-	exit ;;
+	GUESS=nsr-tandem-nsk$UNAME_RELEASE
+	;;
+    NSV-*:NONSTOP_KERNEL:*:*)
+	GUESS=nsv-tandem-nsk$UNAME_RELEASE
+	;;
     NSX-*:NONSTOP_KERNEL:*:*)
-	echo nsx-tandem-nsk${UNAME_RELEASE}
-	exit ;;
+	GUESS=nsx-tandem-nsk$UNAME_RELEASE
+	;;
     *:NonStop-UX:*:*)
-	echo mips-compaq-nonstopux
-	exit ;;
+	GUESS=mips-compaq-nonstopux
+	;;
     BS2000:POSIX*:*:*)
-	echo bs2000-siemens-sysv
-	exit ;;
+	GUESS=bs2000-siemens-sysv
+	;;
     DS/*:UNIX_System_V:*:*)
-	echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE}
-	exit ;;
+	GUESS=$UNAME_MACHINE-$UNAME_SYSTEM-$UNAME_RELEASE
+	;;
     *:Plan9:*:*)
 	# "uname -m" is not consistent, so use $cputype instead. 386
 	# is converted to i386 for consistency with other x86
 	# operating systems.
-	if test "$cputype" = 386; then
+	if test "${cputype-}" = 386; then
 	    UNAME_MACHINE=i386
-	else
-	    UNAME_MACHINE="$cputype"
+	elif test "x${cputype-}" != x; then
+	    UNAME_MACHINE=$cputype
 	fi
-	echo ${UNAME_MACHINE}-unknown-plan9
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-plan9
+	;;
     *:TOPS-10:*:*)
-	echo pdp10-unknown-tops10
-	exit ;;
+	GUESS=pdp10-unknown-tops10
+	;;
     *:TENEX:*:*)
-	echo pdp10-unknown-tenex
-	exit ;;
+	GUESS=pdp10-unknown-tenex
+	;;
     KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)
-	echo pdp10-dec-tops20
-	exit ;;
+	GUESS=pdp10-dec-tops20
+	;;
     XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*)
-	echo pdp10-xkl-tops20
-	exit ;;
+	GUESS=pdp10-xkl-tops20
+	;;
     *:TOPS-20:*:*)
-	echo pdp10-unknown-tops20
-	exit ;;
+	GUESS=pdp10-unknown-tops20
+	;;
     *:ITS:*:*)
-	echo pdp10-unknown-its
-	exit ;;
+	GUESS=pdp10-unknown-its
+	;;
     SEI:*:*:SEIUX)
-	echo mips-sei-seiux${UNAME_RELEASE}
-	exit ;;
+	GUESS=mips-sei-seiux$UNAME_RELEASE
+	;;
     *:DragonFly:*:*)
-	echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`
-	exit ;;
+	DRAGONFLY_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'`
+	GUESS=$UNAME_MACHINE-unknown-dragonfly$DRAGONFLY_REL
+	;;
     *:*VMS:*:*)
 	UNAME_MACHINE=`(uname -p) 2>/dev/null`
-	case "${UNAME_MACHINE}" in
-	    A*) echo alpha-dec-vms ; exit ;;
-	    I*) echo ia64-dec-vms ; exit ;;
-	    V*) echo vax-dec-vms ; exit ;;
+	case $UNAME_MACHINE in
+	    A*) GUESS=alpha-dec-vms ;;
+	    I*) GUESS=ia64-dec-vms ;;
+	    V*) GUESS=vax-dec-vms ;;
 	esac ;;
     *:XENIX:*:SysV)
-	echo i386-pc-xenix
-	exit ;;
+	GUESS=i386-pc-xenix
+	;;
     i*86:skyos:*:*)
-	echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE} | sed -e 's/ .*$//'`
-	exit ;;
+	SKYOS_REL=`echo "$UNAME_RELEASE" | sed -e 's/ .*$//'`
+	GUESS=$UNAME_MACHINE-pc-skyos$SKYOS_REL
+	;;
     i*86:rdos:*:*)
-	echo ${UNAME_MACHINE}-pc-rdos
-	exit ;;
-    i*86:AROS:*:*)
-	echo ${UNAME_MACHINE}-pc-aros
-	exit ;;
+	GUESS=$UNAME_MACHINE-pc-rdos
+	;;
+    i*86:Fiwix:*:*)
+	GUESS=$UNAME_MACHINE-pc-fiwix
+	;;
+    *:AROS:*:*)
+	GUESS=$UNAME_MACHINE-unknown-aros
+	;;
     x86_64:VMkernel:*:*)
-	echo ${UNAME_MACHINE}-unknown-esx
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-esx
+	;;
     amd64:Isilon\ OneFS:*:*)
-	echo x86_64-unknown-onefs
-	exit ;;
+	GUESS=x86_64-unknown-onefs
+	;;
+    *:Unleashed:*:*)
+	GUESS=$UNAME_MACHINE-unknown-unleashed$UNAME_RELEASE
+	;;
+esac
+
+# Do we have a guess based on uname results?
+if test "x$GUESS" != x; then
+    echo "$GUESS"
+    exit
+fi
+
+# No uname command or uname output not recognized.
+set_cc_for_build
+cat > "$dummy.c" <<EOF
+#ifdef _SEQUENT_
+#include <sys/types.h>
+#include <sys/utsname.h>
+#endif
+#if defined(ultrix) || defined(_ultrix) || defined(__ultrix) || defined(__ultrix__)
+#if defined (vax) || defined (__vax) || defined (__vax__) || defined(mips) || defined(__mips) || defined(__mips__) || defined(MIPS) || defined(__MIPS__)
+#include <signal.h>
+#if defined(_SIZE_T_) || defined(SIGLOST)
+#include <sys/utsname.h>
+#endif
+#endif
+#endif
+main ()
+{
+#if defined (sony)
+#if defined (MIPSEB)
+  /* BFD wants "bsd" instead of "newsos".  Perhaps BFD should be changed,
+     I don't know....  */
+  printf ("mips-sony-bsd\n"); exit (0);
+#else
+#include <sys/param.h>
+  printf ("m68k-sony-newsos%s\n",
+#ifdef NEWSOS4
+  "4"
+#else
+  ""
+#endif
+  ); exit (0);
+#endif
+#endif
+
+#if defined (NeXT)
+#if !defined (__ARCHITECTURE__)
+#define __ARCHITECTURE__ "m68k"
+#endif
+  int version;
+  version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`;
+  if (version < 4)
+    printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version);
+  else
+    printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version);
+  exit (0);
+#endif
+
+#if defined (MULTIMAX) || defined (n16)
+#if defined (UMAXV)
+  printf ("ns32k-encore-sysv\n"); exit (0);
+#else
+#if defined (CMU)
+  printf ("ns32k-encore-mach\n"); exit (0);
+#else
+  printf ("ns32k-encore-bsd\n"); exit (0);
+#endif
+#endif
+#endif
+
+#if defined (__386BSD__)
+  printf ("i386-pc-bsd\n"); exit (0);
+#endif
+
+#if defined (sequent)
+#if defined (i386)
+  printf ("i386-sequent-dynix\n"); exit (0);
+#endif
+#if defined (ns32000)
+  printf ("ns32k-sequent-dynix\n"); exit (0);
+#endif
+#endif
+
+#if defined (_SEQUENT_)
+  struct utsname un;
+
+  uname(&un);
+  if (strncmp(un.version, "V2", 2) == 0) {
+    printf ("i386-sequent-ptx2\n"); exit (0);
+  }
+  if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */
+    printf ("i386-sequent-ptx1\n"); exit (0);
+  }
+  printf ("i386-sequent-ptx\n"); exit (0);
+#endif
+
+#if defined (vax)
+#if !defined (ultrix)
+#include <sys/param.h>
+#if defined (BSD)
+#if BSD == 43
+  printf ("vax-dec-bsd4.3\n"); exit (0);
+#else
+#if BSD == 199006
+  printf ("vax-dec-bsd4.3reno\n"); exit (0);
+#else
+  printf ("vax-dec-bsd\n"); exit (0);
+#endif
+#endif
+#else
+  printf ("vax-dec-bsd\n"); exit (0);
+#endif
+#else
+#if defined(_SIZE_T_) || defined(SIGLOST)
+  struct utsname un;
+  uname (&un);
+  printf ("vax-dec-ultrix%s\n", un.release); exit (0);
+#else
+  printf ("vax-dec-ultrix\n"); exit (0);
+#endif
+#endif
+#endif
+#if defined(ultrix) || defined(_ultrix) || defined(__ultrix) || defined(__ultrix__)
+#if defined(mips) || defined(__mips) || defined(__mips__) || defined(MIPS) || defined(__MIPS__)
+#if defined(_SIZE_T_) || defined(SIGLOST)
+  struct utsname *un;
+  uname (&un);
+  printf ("mips-dec-ultrix%s\n", un.release); exit (0);
+#else
+  printf ("mips-dec-ultrix\n"); exit (0);
+#endif
+#endif
+#endif
+
+#if defined (alliant) && defined (i860)
+  printf ("i860-alliant-bsd\n"); exit (0);
+#endif
+
+  exit (1);
+}
+EOF
+
+$CC_FOR_BUILD -o "$dummy" "$dummy.c" 2>/dev/null && SYSTEM_NAME=`"$dummy"` &&
+	{ echo "$SYSTEM_NAME"; exit; }
+
+# Apollos put the system type in the environment.
+test -d /usr/apollo && { echo "$ISP-apollo-$SYSTYPE"; exit; }
+
+echo "$0: unable to guess system type" >&2
+
+case $UNAME_MACHINE:$UNAME_SYSTEM in
+    mips:Linux | mips64:Linux)
+	# If we got here on MIPS GNU/Linux, output extra information.
+	cat >&2 <<EOF
+
+NOTE: MIPS GNU/Linux systems require a C compiler to fully recognize
+the system type. Please install a C compiler and try again.
+EOF
+	;;
 esac
 
 cat >&2 <<EOF
-$0: unable to guess system type
 
 This script (version $timestamp), has failed to recognize the
 operating system you are using. If your script is old, overwrite *all*
 copies of config.guess and config.sub with the latest versions from:
 
-  http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess
+  https://git.savannah.gnu.org/cgit/config.git/plain/config.guess
 and
-  http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub
+  https://git.savannah.gnu.org/cgit/config.git/plain/config.sub
+EOF
+
+our_year=`echo $timestamp | sed 's,-.*,,'`
+thisyear=`date +%Y`
+# shellcheck disable=SC2003
+script_age=`expr "$thisyear" - "$our_year"`
+if test "$script_age" -lt 3 ; then
+   cat >&2 <<EOF
 
 If $0 has already been updated, send the following data and any
 information you think might be pertinent to config-patches@gnu.org to
@@ -1460,16 +1734,17 @@ hostinfo               = `(hostinfo) 2>/dev/null`
 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null`
 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null`
 
-UNAME_MACHINE = ${UNAME_MACHINE}
-UNAME_RELEASE = ${UNAME_RELEASE}
-UNAME_SYSTEM  = ${UNAME_SYSTEM}
-UNAME_VERSION = ${UNAME_VERSION}
+UNAME_MACHINE = "$UNAME_MACHINE"
+UNAME_RELEASE = "$UNAME_RELEASE"
+UNAME_SYSTEM  = "$UNAME_SYSTEM"
+UNAME_VERSION = "$UNAME_VERSION"
 EOF
+fi
 
 exit 1
 
 # Local variables:
-# eval: (add-hook 'write-file-hooks 'time-stamp)
+# eval: (add-hook 'before-save-hook 'time-stamp)
 # time-stamp-start: "timestamp='"
 # time-stamp-format: "%:y-%02m-%02d"
 # time-stamp-end: "'"
diff --git a/Engine/lib/sdl/build-scripts/config.sub b/Engine/lib/sdl/build-scripts/config.sub
index dcf41330c..dba16e84c 100644
--- a/Engine/lib/sdl/build-scripts/config.sub
+++ b/Engine/lib/sdl/build-scripts/config.sub
@@ -1,12 +1,14 @@
 #! /bin/sh
 # Configuration validation subroutine script.
-#   Copyright 1992-2017 Free Software Foundation, Inc.
+#   Copyright 1992-2022 Free Software Foundation, Inc.
 
-timestamp='2017-04-02'
+# shellcheck disable=SC2006,SC2268 # see below for rationale
+
+timestamp='2022-01-03'
 
 # This file is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
+# the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful, but
@@ -15,7 +17,7 @@ timestamp='2017-04-02'
 # General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
-# along with this program; if not, see <http://www.gnu.org/licenses/>.
+# along with this program; if not, see <https://www.gnu.org/licenses/>.
 #
 # As a special exception to the GNU General Public License, if you
 # distribute this file as part of a program that contains a
@@ -33,7 +35,7 @@ timestamp='2017-04-02'
 # Otherwise, we print the canonical config type on stdout and succeed.
 
 # You can get the latest version of this script from:
-# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub
+# https://git.savannah.gnu.org/cgit/config.git/plain/config.sub
 
 # This file is supposed to be the same for all GNU packages
 # and recognize all the CPU types, system types and aliases
@@ -50,6 +52,13 @@ timestamp='2017-04-02'
 #	CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
 # It is wrong to echo any other type of specification.
 
+# The "shellcheck disable" line above the timestamp inhibits complaints
+# about features and limitations of the classic Bourne shell that were
+# superseded or lifted in POSIX.  However, this script identifies a wide
+# variety of pre-POSIX systems that do not have POSIX shells at all, and
+# even some reasonably current systems (Solaris 10 as case-in-point) still
+# have a pre-POSIX /bin/sh.
+
 me=`echo "$0" | sed -e 's,.*/,,'`
 
 usage="\
@@ -57,7 +66,7 @@ Usage: $0 [OPTION] CPU-MFR-OPSYS or ALIAS
 
 Canonicalize a configuration name.
 
-Operation modes:
+Options:
   -h, --help         print this help, then exit
   -t, --time-stamp   print date of last modification, then exit
   -v, --version      print version number, then exit
@@ -67,7 +76,7 @@ Report bugs and patches to <config-patches@gnu.org>."
 version="\
 GNU config.sub ($timestamp)
 
-Copyright 1992-2017 Free Software Foundation, Inc.
+Copyright 1992-2022 Free Software Foundation, Inc.
 
 This is free software; see the source for copying conditions.  There is NO
 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
@@ -89,12 +98,12 @@ while test $# -gt 0 ; do
     - )	# Use stdin as input.
        break ;;
     -* )
-       echo "$me: invalid option $1$help"
+       echo "$me: invalid option $1$help" >&2
        exit 1 ;;
 
     *local*)
        # First pass through any local machine types.
-       echo $1
+       echo "$1"
        exit ;;
 
     * )
@@ -110,1269 +119,1186 @@ case $# in
     exit 1;;
 esac
 
-# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any).
-# Here we must recognize all the valid KERNEL-OS combinations.
-maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`
-case $maybe_os in
-  nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \
-  linux-musl* | linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \
-  knetbsd*-gnu* | netbsd*-gnu* | netbsd*-eabi* | \
-  kopensolaris*-gnu* | cloudabi*-eabi* | \
-  storm-chaos* | os2-emx* | rtmk-nova*)
-    os=-$maybe_os
-    basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`
-    ;;
-  android-linux)
-    os=-linux-android
-    basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`-unknown
-    ;;
-  *)
-    basic_machine=`echo $1 | sed 's/-[^-]*$//'`
-    if [ $basic_machine != $1 ]
-    then os=`echo $1 | sed 's/.*-/-/'`
-    else os=; fi
-    ;;
-esac
+# Split fields of configuration type
+# shellcheck disable=SC2162
+saved_IFS=$IFS
+IFS="-" read field1 field2 field3 field4 <<EOF
+$1
+EOF
+IFS=$saved_IFS
 
-### Let's recognize common machines as not being operating systems so
-### that things like config.sub decstation-3100 work.  We also
-### recognize some manufacturers as not being operating systems, so we
-### can provide default operating systems below.
-case $os in
-	-sun*os*)
-		# Prevent following clause from handling this invalid input.
+# Separate into logical components for further validation
+case $1 in
+	*-*-*-*-*)
+		echo Invalid configuration \`"$1"\': more than four components >&2
+		exit 1
 		;;
-	-dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \
-	-att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \
-	-unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \
-	-convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\
-	-c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \
-	-harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \
-	-apple | -axis | -knuth | -cray | -microblaze*)
-		os=
-		basic_machine=$1
+	*-*-*-*)
+		basic_machine=$field1-$field2
+		basic_os=$field3-$field4
 		;;
-	-bluegene*)
-		os=-cnk
+	*-*-*)
+		# Ambiguous whether COMPANY is present, or skipped and KERNEL-OS is two
+		# parts
+		maybe_os=$field2-$field3
+		case $maybe_os in
+			nto-qnx* | linux-* | uclinux-uclibc* \
+			| uclinux-gnu* | kfreebsd*-gnu* | knetbsd*-gnu* | netbsd*-gnu* \
+			| netbsd*-eabi* | kopensolaris*-gnu* | cloudabi*-eabi* \
+			| storm-chaos* | os2-emx* | rtmk-nova*)
+				basic_machine=$field1
+				basic_os=$maybe_os
+				;;
+			android-linux)
+				basic_machine=$field1-unknown
+				basic_os=linux-android
+				;;
+			*)
+				basic_machine=$field1-$field2
+				basic_os=$field3
+				;;
+		esac
 		;;
-	-sim | -cisco | -oki | -wec | -winbond)
-		os=
-		basic_machine=$1
+	*-*)
+		# A lone config we happen to match not fitting any pattern
+		case $field1-$field2 in
+			decstation-3100)
+				basic_machine=mips-dec
+				basic_os=
+				;;
+			*-*)
+				# Second component is usually, but not always the OS
+				case $field2 in
+					# Prevent following clause from handling this valid os
+					sun*os*)
+						basic_machine=$field1
+						basic_os=$field2
+						;;
+					zephyr*)
+						basic_machine=$field1-unknown
+						basic_os=$field2
+						;;
+					# Manufacturers
+					dec* | mips* | sequent* | encore* | pc533* | sgi* | sony* \
+					| att* | 7300* | 3300* | delta* | motorola* | sun[234]* \
+					| unicom* | ibm* | next | hp | isi* | apollo | altos* \
+					| convergent* | ncr* | news | 32* | 3600* | 3100* \
+					| hitachi* | c[123]* | convex* | sun | crds | omron* | dg \
+					| ultra | tti* | harris | dolphin | highlevel | gould \
+					| cbm | ns | masscomp | apple | axis | knuth | cray \
+					| microblaze* | sim | cisco \
+					| oki | wec | wrs | winbond)
+						basic_machine=$field1-$field2
+						basic_os=
+						;;
+					*)
+						basic_machine=$field1
+						basic_os=$field2
+						;;
+				esac
+			;;
+		esac
 		;;
-	-scout)
-		;;
-	-wrs)
-		os=-vxworks
-		basic_machine=$1
-		;;
-	-chorusos*)
-		os=-chorusos
-		basic_machine=$1
-		;;
-	-chorusrdb)
-		os=-chorusrdb
-		basic_machine=$1
-		;;
-	-hiux*)
-		os=-hiuxwe2
-		;;
-	-sco6)
-		os=-sco5v6
-		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco5)
-		os=-sco3.2v5
-		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco4)
-		os=-sco3.2v4
-		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco3.2.[4-9]*)
-		os=`echo $os | sed -e 's/sco3.2./sco3.2v/'`
-		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco3.2v[4-9]*)
-		# Don't forget version if it is 3.2v4 or newer.
-		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco5v6*)
-		# Don't forget version if it is 3.2v4 or newer.
-		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco*)
-		os=-sco3.2v2
-		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
-		;;
-	-udk*)
-		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
-		;;
-	-isc)
-		os=-isc2.2
-		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
-		;;
-	-clix*)
-		basic_machine=clipper-intergraph
-		;;
-	-isc*)
-		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
-		;;
-	-lynx*178)
-		os=-lynxos178
-		;;
-	-lynx*5)
-		os=-lynxos5
-		;;
-	-lynx*)
-		os=-lynxos
-		;;
-	-ptx*)
-		basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'`
-		;;
-	-windowsnt*)
-		os=`echo $os | sed -e 's/windowsnt/winnt/'`
-		;;
-	-psos*)
-		os=-psos
-		;;
-	-mint | -mint[0-9]*)
-		basic_machine=m68k-atari
-		os=-mint
+	*)
+		# Convert single-component short-hands not valid as part of
+		# multi-component configurations.
+		case $field1 in
+			386bsd)
+				basic_machine=i386-pc
+				basic_os=bsd
+				;;
+			a29khif)
+				basic_machine=a29k-amd
+				basic_os=udi
+				;;
+			adobe68k)
+				basic_machine=m68010-adobe
+				basic_os=scout
+				;;
+			alliant)
+				basic_machine=fx80-alliant
+				basic_os=
+				;;
+			altos | altos3068)
+				basic_machine=m68k-altos
+				basic_os=
+				;;
+			am29k)
+				basic_machine=a29k-none
+				basic_os=bsd
+				;;
+			amdahl)
+				basic_machine=580-amdahl
+				basic_os=sysv
+				;;
+			amiga)
+				basic_machine=m68k-unknown
+				basic_os=
+				;;
+			amigaos | amigados)
+				basic_machine=m68k-unknown
+				basic_os=amigaos
+				;;
+			amigaunix | amix)
+				basic_machine=m68k-unknown
+				basic_os=sysv4
+				;;
+			apollo68)
+				basic_machine=m68k-apollo
+				basic_os=sysv
+				;;
+			apollo68bsd)
+				basic_machine=m68k-apollo
+				basic_os=bsd
+				;;
+			aros)
+				basic_machine=i386-pc
+				basic_os=aros
+				;;
+			aux)
+				basic_machine=m68k-apple
+				basic_os=aux
+				;;
+			balance)
+				basic_machine=ns32k-sequent
+				basic_os=dynix
+				;;
+			blackfin)
+				basic_machine=bfin-unknown
+				basic_os=linux
+				;;
+			cegcc)
+				basic_machine=arm-unknown
+				basic_os=cegcc
+				;;
+			convex-c1)
+				basic_machine=c1-convex
+				basic_os=bsd
+				;;
+			convex-c2)
+				basic_machine=c2-convex
+				basic_os=bsd
+				;;
+			convex-c32)
+				basic_machine=c32-convex
+				basic_os=bsd
+				;;
+			convex-c34)
+				basic_machine=c34-convex
+				basic_os=bsd
+				;;
+			convex-c38)
+				basic_machine=c38-convex
+				basic_os=bsd
+				;;
+			cray)
+				basic_machine=j90-cray
+				basic_os=unicos
+				;;
+			crds | unos)
+				basic_machine=m68k-crds
+				basic_os=
+				;;
+			da30)
+				basic_machine=m68k-da30
+				basic_os=
+				;;
+			decstation | pmax | pmin | dec3100 | decstatn)
+				basic_machine=mips-dec
+				basic_os=
+				;;
+			delta88)
+				basic_machine=m88k-motorola
+				basic_os=sysv3
+				;;
+			dicos)
+				basic_machine=i686-pc
+				basic_os=dicos
+				;;
+			djgpp)
+				basic_machine=i586-pc
+				basic_os=msdosdjgpp
+				;;
+			ebmon29k)
+				basic_machine=a29k-amd
+				basic_os=ebmon
+				;;
+			es1800 | OSE68k | ose68k | ose | OSE)
+				basic_machine=m68k-ericsson
+				basic_os=ose
+				;;
+			gmicro)
+				basic_machine=tron-gmicro
+				basic_os=sysv
+				;;
+			go32)
+				basic_machine=i386-pc
+				basic_os=go32
+				;;
+			h8300hms)
+				basic_machine=h8300-hitachi
+				basic_os=hms
+				;;
+			h8300xray)
+				basic_machine=h8300-hitachi
+				basic_os=xray
+				;;
+			h8500hms)
+				basic_machine=h8500-hitachi
+				basic_os=hms
+				;;
+			harris)
+				basic_machine=m88k-harris
+				basic_os=sysv3
+				;;
+			hp300 | hp300hpux)
+				basic_machine=m68k-hp
+				basic_os=hpux
+				;;
+			hp300bsd)
+				basic_machine=m68k-hp
+				basic_os=bsd
+				;;
+			hppaosf)
+				basic_machine=hppa1.1-hp
+				basic_os=osf
+				;;
+			hppro)
+				basic_machine=hppa1.1-hp
+				basic_os=proelf
+				;;
+			i386mach)
+				basic_machine=i386-mach
+				basic_os=mach
+				;;
+			isi68 | isi)
+				basic_machine=m68k-isi
+				basic_os=sysv
+				;;
+			m68knommu)
+				basic_machine=m68k-unknown
+				basic_os=linux
+				;;
+			magnum | m3230)
+				basic_machine=mips-mips
+				basic_os=sysv
+				;;
+			merlin)
+				basic_machine=ns32k-utek
+				basic_os=sysv
+				;;
+			mingw64)
+				basic_machine=x86_64-pc
+				basic_os=mingw64
+				;;
+			mingw32)
+				basic_machine=i686-pc
+				basic_os=mingw32
+				;;
+			mingw32ce)
+				basic_machine=arm-unknown
+				basic_os=mingw32ce
+				;;
+			monitor)
+				basic_machine=m68k-rom68k
+				basic_os=coff
+				;;
+			morphos)
+				basic_machine=powerpc-unknown
+				basic_os=morphos
+				;;
+			moxiebox)
+				basic_machine=moxie-unknown
+				basic_os=moxiebox
+				;;
+			msdos)
+				basic_machine=i386-pc
+				basic_os=msdos
+				;;
+			msys)
+				basic_machine=i686-pc
+				basic_os=msys
+				;;
+			mvs)
+				basic_machine=i370-ibm
+				basic_os=mvs
+				;;
+			nacl)
+				basic_machine=le32-unknown
+				basic_os=nacl
+				;;
+			ncr3000)
+				basic_machine=i486-ncr
+				basic_os=sysv4
+				;;
+			netbsd386)
+				basic_machine=i386-pc
+				basic_os=netbsd
+				;;
+			netwinder)
+				basic_machine=armv4l-rebel
+				basic_os=linux
+				;;
+			news | news700 | news800 | news900)
+				basic_machine=m68k-sony
+				basic_os=newsos
+				;;
+			news1000)
+				basic_machine=m68030-sony
+				basic_os=newsos
+				;;
+			necv70)
+				basic_machine=v70-nec
+				basic_os=sysv
+				;;
+			nh3000)
+				basic_machine=m68k-harris
+				basic_os=cxux
+				;;
+			nh[45]000)
+				basic_machine=m88k-harris
+				basic_os=cxux
+				;;
+			nindy960)
+				basic_machine=i960-intel
+				basic_os=nindy
+				;;
+			mon960)
+				basic_machine=i960-intel
+				basic_os=mon960
+				;;
+			nonstopux)
+				basic_machine=mips-compaq
+				basic_os=nonstopux
+				;;
+			os400)
+				basic_machine=powerpc-ibm
+				basic_os=os400
+				;;
+			OSE68000 | ose68000)
+				basic_machine=m68000-ericsson
+				basic_os=ose
+				;;
+			os68k)
+				basic_machine=m68k-none
+				basic_os=os68k
+				;;
+			paragon)
+				basic_machine=i860-intel
+				basic_os=osf
+				;;
+			parisc)
+				basic_machine=hppa-unknown
+				basic_os=linux
+				;;
+			psp)
+				basic_machine=mipsallegrexel-sony
+				basic_os=psp
+				;;
+			pw32)
+				basic_machine=i586-unknown
+				basic_os=pw32
+				;;
+			rdos | rdos64)
+				basic_machine=x86_64-pc
+				basic_os=rdos
+				;;
+			rdos32)
+				basic_machine=i386-pc
+				basic_os=rdos
+				;;
+			rom68k)
+				basic_machine=m68k-rom68k
+				basic_os=coff
+				;;
+			sa29200)
+				basic_machine=a29k-amd
+				basic_os=udi
+				;;
+			sei)
+				basic_machine=mips-sei
+				basic_os=seiux
+				;;
+			sequent)
+				basic_machine=i386-sequent
+				basic_os=
+				;;
+			sps7)
+				basic_machine=m68k-bull
+				basic_os=sysv2
+				;;
+			st2000)
+				basic_machine=m68k-tandem
+				basic_os=
+				;;
+			stratus)
+				basic_machine=i860-stratus
+				basic_os=sysv4
+				;;
+			sun2)
+				basic_machine=m68000-sun
+				basic_os=
+				;;
+			sun2os3)
+				basic_machine=m68000-sun
+				basic_os=sunos3
+				;;
+			sun2os4)
+				basic_machine=m68000-sun
+				basic_os=sunos4
+				;;
+			sun3)
+				basic_machine=m68k-sun
+				basic_os=
+				;;
+			sun3os3)
+				basic_machine=m68k-sun
+				basic_os=sunos3
+				;;
+			sun3os4)
+				basic_machine=m68k-sun
+				basic_os=sunos4
+				;;
+			sun4)
+				basic_machine=sparc-sun
+				basic_os=
+				;;
+			sun4os3)
+				basic_machine=sparc-sun
+				basic_os=sunos3
+				;;
+			sun4os4)
+				basic_machine=sparc-sun
+				basic_os=sunos4
+				;;
+			sun4sol2)
+				basic_machine=sparc-sun
+				basic_os=solaris2
+				;;
+			sun386 | sun386i | roadrunner)
+				basic_machine=i386-sun
+				basic_os=
+				;;
+			sv1)
+				basic_machine=sv1-cray
+				basic_os=unicos
+				;;
+			symmetry)
+				basic_machine=i386-sequent
+				basic_os=dynix
+				;;
+			t3e)
+				basic_machine=alphaev5-cray
+				basic_os=unicos
+				;;
+			t90)
+				basic_machine=t90-cray
+				basic_os=unicos
+				;;
+			toad1)
+				basic_machine=pdp10-xkl
+				basic_os=tops20
+				;;
+			tpf)
+				basic_machine=s390x-ibm
+				basic_os=tpf
+				;;
+			udi29k)
+				basic_machine=a29k-amd
+				basic_os=udi
+				;;
+			ultra3)
+				basic_machine=a29k-nyu
+				basic_os=sym1
+				;;
+			v810 | necv810)
+				basic_machine=v810-nec
+				basic_os=none
+				;;
+			vaxv)
+				basic_machine=vax-dec
+				basic_os=sysv
+				;;
+			vms)
+				basic_machine=vax-dec
+				basic_os=vms
+				;;
+			vsta)
+				basic_machine=i386-pc
+				basic_os=vsta
+				;;
+			vxworks960)
+				basic_machine=i960-wrs
+				basic_os=vxworks
+				;;
+			vxworks68)
+				basic_machine=m68k-wrs
+				basic_os=vxworks
+				;;
+			vxworks29k)
+				basic_machine=a29k-wrs
+				basic_os=vxworks
+				;;
+			xbox)
+				basic_machine=i686-pc
+				basic_os=mingw32
+				;;
+			ymp)
+				basic_machine=ymp-cray
+				basic_os=unicos
+				;;
+			*)
+				basic_machine=$1
+				basic_os=
+				;;
+		esac
 		;;
 esac
 
-# Decode aliases for certain CPU-COMPANY combinations.
+# Decode 1-component or ad-hoc basic machines
 case $basic_machine in
-	# Recognize the basic CPU types without company name.
-	# Some are omitted here because they have special meanings below.
-	1750a | 580 \
-	| a29k \
-	| aarch64 | aarch64_be \
-	| alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \
-	| alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \
-	| am33_2.0 \
-	| arc | arceb \
-	| arm | arm[bl]e | arme[lb] | armv[2-8] | armv[3-8][lb] | armv7[arm] \
-	| avr | avr32 \
-	| ba \
-	| be32 | be64 \
-	| bfin \
-	| c4x | c8051 | clipper \
-	| d10v | d30v | dlx | dsp16xx \
-	| e2k | epiphany \
-	| fido | fr30 | frv | ft32 \
-	| h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
-	| hexagon \
-	| i370 | i860 | i960 | ia16 | ia64 \
-	| ip2k | iq2000 \
-	| k1om \
-	| le32 | le64 \
-	| lm32 \
-	| m32c | m32r | m32rle | m68000 | m68k | m88k \
-	| maxq | mb | microblaze | microblazeel | mcore | mep | metag \
-	| mips | mipsbe | mipseb | mipsel | mipsle \
-	| mips16 \
-	| mips64 | mips64el \
-	| mips64octeon | mips64octeonel \
-	| mips64orion | mips64orionel \
-	| mips64r5900 | mips64r5900el \
-	| mips64vr | mips64vrel \
-	| mips64vr4100 | mips64vr4100el \
-	| mips64vr4300 | mips64vr4300el \
-	| mips64vr5000 | mips64vr5000el \
-	| mips64vr5900 | mips64vr5900el \
-	| mipsisa32 | mipsisa32el \
-	| mipsisa32r2 | mipsisa32r2el \
-	| mipsisa32r6 | mipsisa32r6el \
-	| mipsisa64 | mipsisa64el \
-	| mipsisa64r2 | mipsisa64r2el \
-	| mipsisa64r6 | mipsisa64r6el \
-	| mipsisa64sb1 | mipsisa64sb1el \
-	| mipsisa64sr71k | mipsisa64sr71kel \
-	| mipsr5900 | mipsr5900el \
-	| mipstx39 | mipstx39el \
-	| mn10200 | mn10300 \
-	| moxie \
-	| mt \
-	| msp430 \
-	| nds32 | nds32le | nds32be \
-	| nios | nios2 | nios2eb | nios2el \
-	| ns16k | ns32k \
-	| open8 | or1k | or1knd | or32 \
-	| pdp10 | pdp11 | pj | pjl \
-	| powerpc | powerpc64 | powerpc64le | powerpcle \
-	| pru \
-	| pyramid \
-	| riscv32 | riscv64 \
-	| rl78 | rx \
-	| score \
-	| sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[234]eb | sheb | shbe | shle | sh[1234]le | sh3ele \
-	| sh64 | sh64le \
-	| sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \
-	| sparcv8 | sparcv9 | sparcv9b | sparcv9v \
-	| spu \
-	| tahoe | tic4x | tic54x | tic55x | tic6x | tic80 | tron \
-	| ubicom32 \
-	| v850 | v850e | v850e1 | v850e2 | v850es | v850e2v3 \
-	| visium \
-	| wasm32 \
-	| we32k \
-	| x86 | xc16x | xstormy16 | xtensa \
-	| z8k | z80)
-		basic_machine=$basic_machine-unknown
+	# Here we handle the default manufacturer of certain CPU types.  It is in
+	# some cases the only manufacturer, in others, it is the most popular.
+	w89k)
+		cpu=hppa1.1
+		vendor=winbond
 		;;
-	c54x)
-		basic_machine=tic54x-unknown
+	op50n)
+		cpu=hppa1.1
+		vendor=oki
 		;;
-	c55x)
-		basic_machine=tic55x-unknown
+	op60c)
+		cpu=hppa1.1
+		vendor=oki
 		;;
-	c6x)
-		basic_machine=tic6x-unknown
+	ibm*)
+		cpu=i370
+		vendor=ibm
+		;;
+	orion105)
+		cpu=clipper
+		vendor=highlevel
+		;;
+	mac | mpw | mac-mpw)
+		cpu=m68k
+		vendor=apple
+		;;
+	pmac | pmac-mpw)
+		cpu=powerpc
+		vendor=apple
+		;;
+
+	# Recognize the various machine names and aliases which stand
+	# for a CPU type and a company and sometimes even an OS.
+	3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc)
+		cpu=m68000
+		vendor=att
+		;;
+	3b*)
+		cpu=we32k
+		vendor=att
+		;;
+	bluegene*)
+		cpu=powerpc
+		vendor=ibm
+		basic_os=cnk
+		;;
+	decsystem10* | dec10*)
+		cpu=pdp10
+		vendor=dec
+		basic_os=tops10
+		;;
+	decsystem20* | dec20*)
+		cpu=pdp10
+		vendor=dec
+		basic_os=tops20
+		;;
+	delta | 3300 | motorola-3300 | motorola-delta \
+	      | 3300-motorola | delta-motorola)
+		cpu=m68k
+		vendor=motorola
+		;;
+	dpx2*)
+		cpu=m68k
+		vendor=bull
+		basic_os=sysv3
+		;;
+	encore | umax | mmax)
+		cpu=ns32k
+		vendor=encore
+		;;
+	elxsi)
+		cpu=elxsi
+		vendor=elxsi
+		basic_os=${basic_os:-bsd}
+		;;
+	fx2800)
+		cpu=i860
+		vendor=alliant
+		;;
+	genix)
+		cpu=ns32k
+		vendor=ns
+		;;
+	h3050r* | hiux*)
+		cpu=hppa1.1
+		vendor=hitachi
+		basic_os=hiuxwe2
+		;;
+	hp3k9[0-9][0-9] | hp9[0-9][0-9])
+		cpu=hppa1.0
+		vendor=hp
+		;;
+	hp9k2[0-9][0-9] | hp9k31[0-9])
+		cpu=m68000
+		vendor=hp
+		;;
+	hp9k3[2-9][0-9])
+		cpu=m68k
+		vendor=hp
+		;;
+	hp9k6[0-9][0-9] | hp6[0-9][0-9])
+		cpu=hppa1.0
+		vendor=hp
+		;;
+	hp9k7[0-79][0-9] | hp7[0-79][0-9])
+		cpu=hppa1.1
+		vendor=hp
+		;;
+	hp9k78[0-9] | hp78[0-9])
+		# FIXME: really hppa2.0-hp
+		cpu=hppa1.1
+		vendor=hp
+		;;
+	hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893)
+		# FIXME: really hppa2.0-hp
+		cpu=hppa1.1
+		vendor=hp
+		;;
+	hp9k8[0-9][13679] | hp8[0-9][13679])
+		cpu=hppa1.1
+		vendor=hp
+		;;
+	hp9k8[0-9][0-9] | hp8[0-9][0-9])
+		cpu=hppa1.0
+		vendor=hp
+		;;
+	i*86v32)
+		cpu=`echo "$1" | sed -e 's/86.*/86/'`
+		vendor=pc
+		basic_os=sysv32
+		;;
+	i*86v4*)
+		cpu=`echo "$1" | sed -e 's/86.*/86/'`
+		vendor=pc
+		basic_os=sysv4
+		;;
+	i*86v)
+		cpu=`echo "$1" | sed -e 's/86.*/86/'`
+		vendor=pc
+		basic_os=sysv
+		;;
+	i*86sol2)
+		cpu=`echo "$1" | sed -e 's/86.*/86/'`
+		vendor=pc
+		basic_os=solaris2
+		;;
+	j90 | j90-cray)
+		cpu=j90
+		vendor=cray
+		basic_os=${basic_os:-unicos}
+		;;
+	iris | iris4d)
+		cpu=mips
+		vendor=sgi
+		case $basic_os in
+		    irix*)
+			;;
+		    *)
+			basic_os=irix4
+			;;
+		esac
+		;;
+	miniframe)
+		cpu=m68000
+		vendor=convergent
+		;;
+	*mint | mint[0-9]* | *MiNT | *MiNT[0-9]*)
+		cpu=m68k
+		vendor=atari
+		basic_os=mint
+		;;
+	news-3600 | risc-news)
+		cpu=mips
+		vendor=sony
+		basic_os=newsos
+		;;
+	next | m*-next)
+		cpu=m68k
+		vendor=next
+		case $basic_os in
+		    openstep*)
+		        ;;
+		    nextstep*)
+			;;
+		    ns2*)
+		      basic_os=nextstep2
+			;;
+		    *)
+		      basic_os=nextstep3
+			;;
+		esac
+		;;
+	np1)
+		cpu=np1
+		vendor=gould
+		;;
+	op50n-* | op60c-*)
+		cpu=hppa1.1
+		vendor=oki
+		basic_os=proelf
+		;;
+	pa-hitachi)
+		cpu=hppa1.1
+		vendor=hitachi
+		basic_os=hiuxwe2
+		;;
+	pbd)
+		cpu=sparc
+		vendor=tti
+		;;
+	pbb)
+		cpu=m68k
+		vendor=tti
+		;;
+	pc532)
+		cpu=ns32k
+		vendor=pc532
+		;;
+	pn)
+		cpu=pn
+		vendor=gould
+		;;
+	power)
+		cpu=power
+		vendor=ibm
+		;;
+	ps2)
+		cpu=i386
+		vendor=ibm
+		;;
+	rm[46]00)
+		cpu=mips
+		vendor=siemens
+		;;
+	rtpc | rtpc-*)
+		cpu=romp
+		vendor=ibm
+		;;
+	sde)
+		cpu=mipsisa32
+		vendor=sde
+		basic_os=${basic_os:-elf}
+		;;
+	simso-wrs)
+		cpu=sparclite
+		vendor=wrs
+		basic_os=vxworks
+		;;
+	tower | tower-32)
+		cpu=m68k
+		vendor=ncr
+		;;
+	vpp*|vx|vx-*)
+		cpu=f301
+		vendor=fujitsu
+		;;
+	w65)
+		cpu=w65
+		vendor=wdc
+		;;
+	w89k-*)
+		cpu=hppa1.1
+		vendor=winbond
+		basic_os=proelf
+		;;
+	none)
+		cpu=none
+		vendor=none
 		;;
 	leon|leon[3-9])
-		basic_machine=sparc-$basic_machine
+		cpu=sparc
+		vendor=$basic_machine
 		;;
-	m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x | nvptx | picochip)
-		basic_machine=$basic_machine-unknown
-		os=-none
-		;;
-	m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k)
-		;;
-	ms1)
-		basic_machine=mt-unknown
+	leon-*|leon[3-9]-*)
+		cpu=sparc
+		vendor=`echo "$basic_machine" | sed 's/-.*//'`
 		;;
 
-	strongarm | thumb | xscale)
-		basic_machine=arm-unknown
+	*-*)
+		# shellcheck disable=SC2162
+		saved_IFS=$IFS
+		IFS="-" read cpu vendor <<EOF
+$basic_machine
+EOF
+		IFS=$saved_IFS
 		;;
-	xgate)
-		basic_machine=$basic_machine-unknown
-		os=-none
-		;;
-	xscaleeb)
-		basic_machine=armeb-unknown
-		;;
-
-	xscaleel)
-		basic_machine=armel-unknown
-		;;
-
 	# We use `pc' rather than `unknown'
 	# because (1) that's what they normally are, and
 	# (2) the word "unknown" tends to confuse beginning users.
 	i*86 | x86_64)
-	  basic_machine=$basic_machine-pc
-	  ;;
-	nacl64*)
-		basic_machine=x86_64-pc
-		os=-nacl
-		;;
-	nacl*)
-		basic_machine=i686-pc
-		os=-nacl
-		;;
-	pnacl*)
-		# le32-unknown-pnacl comes from http://www.chromium.org/nativeclient/pnacl/stability-of-the-pnacl-bitcode-abi
-		basic_machine=le32-unknown
-		os=-pnacl
-		;;
-	# Object if more than one company name word.
-	*-*-*)
-		echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
-		exit 1
-		;;
-	# Recognize the basic CPU types with company name.
-	580-* \
-	| a29k-* \
-	| aarch64-* | aarch64_be-* \
-	| alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \
-	| alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \
-	| alphapca5[67]-* | alpha64pca5[67]-* | arc-* | arceb-* \
-	| arm-*  | armbe-* | armle-* | armeb-* | armv*-* \
-	| avr-* | avr32-* \
-	| ba-* \
-	| be32-* | be64-* \
-	| bfin-* | bs2000-* \
-	| c[123]* | c30-* | [cjt]90-* | c4x-* \
-	| c8051-* | clipper-* | craynv-* | cydra-* \
-	| d10v-* | d30v-* | dlx-* \
-	| e2k-* | elxsi-* \
-	| f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \
-	| h8300-* | h8500-* \
-	| hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \
-	| hexagon-* \
-	| i*86-* | i860-* | i960-* | ia16-* | ia64-* \
-	| ip2k-* | iq2000-* \
-	| k1om-* \
-	| le32-* | le64-* \
-	| lm32-* \
-	| m32c-* | m32r-* | m32rle-* \
-	| m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \
-	| m88110-* | m88k-* | maxq-* | mcore-* | metag-* \
-	| microblaze-* | microblazeel-* \
-	| mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \
-	| mips16-* \
-	| mips64-* | mips64el-* \
-	| mips64octeon-* | mips64octeonel-* \
-	| mips64orion-* | mips64orionel-* \
-	| mips64r5900-* | mips64r5900el-* \
-	| mips64vr-* | mips64vrel-* \
-	| mips64vr4100-* | mips64vr4100el-* \
-	| mips64vr4300-* | mips64vr4300el-* \
-	| mips64vr5000-* | mips64vr5000el-* \
-	| mips64vr5900-* | mips64vr5900el-* \
-	| mipsisa32-* | mipsisa32el-* \
-	| mipsisa32r2-* | mipsisa32r2el-* \
-	| mipsisa32r6-* | mipsisa32r6el-* \
-	| mipsisa64-* | mipsisa64el-* \
-	| mipsisa64r2-* | mipsisa64r2el-* \
-	| mipsisa64r6-* | mipsisa64r6el-* \
-	| mipsisa64sb1-* | mipsisa64sb1el-* \
-	| mipsisa64sr71k-* | mipsisa64sr71kel-* \
-	| mipsr5900-* | mipsr5900el-* \
-	| mipstx39-* | mipstx39el-* \
-	| mmix-* \
-	| mt-* \
-	| msp430-* \
-	| nds32-* | nds32le-* | nds32be-* \
-	| nios-* | nios2-* | nios2eb-* | nios2el-* \
-	| none-* | np1-* | ns16k-* | ns32k-* \
-	| open8-* \
-	| or1k*-* \
-	| orion-* \
-	| pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \
-	| powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \
-	| pru-* \
-	| pyramid-* \
-	| riscv32-* | riscv64-* \
-	| rl78-* | romp-* | rs6000-* | rx-* \
-	| sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \
-	| shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \
-	| sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \
-	| sparclite-* \
-	| sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | sv1-* | sx*-* \
-	| tahoe-* \
-	| tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \
-	| tile*-* \
-	| tron-* \
-	| ubicom32-* \
-	| v850-* | v850e-* | v850e1-* | v850es-* | v850e2-* | v850e2v3-* \
-	| vax-* \
-	| visium-* \
-	| wasm32-* \
-	| we32k-* \
-	| x86-* | x86_64-* | xc16x-* | xps100-* \
-	| xstormy16-* | xtensa*-* \
-	| ymp-* \
-	| z8k-* | z80-*)
-		;;
-	# Recognize the basic CPU types without company name, with glob match.
-	xtensa*)
-		basic_machine=$basic_machine-unknown
-		;;
-	# Recognize the various machine names and aliases which stand
-	# for a CPU type and a company and sometimes even an OS.
-	386bsd)
-		basic_machine=i386-unknown
-		os=-bsd
-		;;
-	3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc)
-		basic_machine=m68000-att
-		;;
-	3b*)
-		basic_machine=we32k-att
-		;;
-	a29khif)
-		basic_machine=a29k-amd
-		os=-udi
-		;;
-	abacus)
-		basic_machine=abacus-unknown
-		;;
-	adobe68k)
-		basic_machine=m68010-adobe
-		os=-scout
-		;;
-	alliant | fx80)
-		basic_machine=fx80-alliant
-		;;
-	altos | altos3068)
-		basic_machine=m68k-altos
-		;;
-	am29k)
-		basic_machine=a29k-none
-		os=-bsd
-		;;
-	amd64)
-		basic_machine=x86_64-pc
-		;;
-	amd64-*)
-		basic_machine=x86_64-`echo $basic_machine | sed 's/^[^-]*-//'`
-		;;
-	amdahl)
-		basic_machine=580-amdahl
-		os=-sysv
-		;;
-	amiga | amiga-*)
-		basic_machine=m68k-unknown
-		;;
-	amigaos | amigados)
-		basic_machine=m68k-unknown
-		os=-amigaos
-		;;
-	amigaunix | amix)
-		basic_machine=m68k-unknown
-		os=-sysv4
-		;;
-	apollo68)
-		basic_machine=m68k-apollo
-		os=-sysv
-		;;
-	apollo68bsd)
-		basic_machine=m68k-apollo
-		os=-bsd
-		;;
-	aros)
-		basic_machine=i386-pc
-		os=-aros
-		;;
-	asmjs)
-		basic_machine=asmjs-unknown
-		;;
-	aux)
-		basic_machine=m68k-apple
-		os=-aux
-		;;
-	balance)
-		basic_machine=ns32k-sequent
-		os=-dynix
-		;;
-	blackfin)
-		basic_machine=bfin-unknown
-		os=-linux
-		;;
-	blackfin-*)
-		basic_machine=bfin-`echo $basic_machine | sed 's/^[^-]*-//'`
-		os=-linux
-		;;
-	bluegene*)
-		basic_machine=powerpc-ibm
-		os=-cnk
-		;;
-	c54x-*)
-		basic_machine=tic54x-`echo $basic_machine | sed 's/^[^-]*-//'`
-		;;
-	c55x-*)
-		basic_machine=tic55x-`echo $basic_machine | sed 's/^[^-]*-//'`
-		;;
-	c6x-*)
-		basic_machine=tic6x-`echo $basic_machine | sed 's/^[^-]*-//'`
-		;;
-	c90)
-		basic_machine=c90-cray
-		os=-unicos
-		;;
-	cegcc)
-		basic_machine=arm-unknown
-		os=-cegcc
-		;;
-	convex-c1)
-		basic_machine=c1-convex
-		os=-bsd
-		;;
-	convex-c2)
-		basic_machine=c2-convex
-		os=-bsd
-		;;
-	convex-c32)
-		basic_machine=c32-convex
-		os=-bsd
-		;;
-	convex-c34)
-		basic_machine=c34-convex
-		os=-bsd
-		;;
-	convex-c38)
-		basic_machine=c38-convex
-		os=-bsd
-		;;
-	cray | j90)
-		basic_machine=j90-cray
-		os=-unicos
-		;;
-	craynv)
-		basic_machine=craynv-cray
-		os=-unicosmp
-		;;
-	cr16 | cr16-*)
-		basic_machine=cr16-unknown
-		os=-elf
-		;;
-	crds | unos)
-		basic_machine=m68k-crds
-		;;
-	crisv32 | crisv32-* | etraxfs*)
-		basic_machine=crisv32-axis
-		;;
-	cris | cris-* | etrax*)
-		basic_machine=cris-axis
-		;;
-	crx)
-		basic_machine=crx-unknown
-		os=-elf
-		;;
-	da30 | da30-*)
-		basic_machine=m68k-da30
-		;;
-	decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn)
-		basic_machine=mips-dec
-		;;
-	decsystem10* | dec10*)
-		basic_machine=pdp10-dec
-		os=-tops10
-		;;
-	decsystem20* | dec20*)
-		basic_machine=pdp10-dec
-		os=-tops20
-		;;
-	delta | 3300 | motorola-3300 | motorola-delta \
-	      | 3300-motorola | delta-motorola)
-		basic_machine=m68k-motorola
-		;;
-	delta88)
-		basic_machine=m88k-motorola
-		os=-sysv3
-		;;
-	dicos)
-		basic_machine=i686-pc
-		os=-dicos
-		;;
-	djgpp)
-		basic_machine=i586-pc
-		os=-msdosdjgpp
-		;;
-	dpx20 | dpx20-*)
-		basic_machine=rs6000-bull
-		os=-bosx
-		;;
-	dpx2* | dpx2*-bull)
-		basic_machine=m68k-bull
-		os=-sysv3
-		;;
-	e500v[12])
-		basic_machine=powerpc-unknown
-		os=$os"spe"
-		;;
-	e500v[12]-*)
-		basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'`
-		os=$os"spe"
-		;;
-	ebmon29k)
-		basic_machine=a29k-amd
-		os=-ebmon
-		;;
-	elxsi)
-		basic_machine=elxsi-elxsi
-		os=-bsd
-		;;
-	encore | umax | mmax)
-		basic_machine=ns32k-encore
-		;;
-	es1800 | OSE68k | ose68k | ose | OSE)
-		basic_machine=m68k-ericsson
-		os=-ose
-		;;
-	fx2800)
-		basic_machine=i860-alliant
-		;;
-	genix)
-		basic_machine=ns32k-ns
-		;;
-	gmicro)
-		basic_machine=tron-gmicro
-		os=-sysv
-		;;
-	go32)
-		basic_machine=i386-pc
-		os=-go32
-		;;
-	h3050r* | hiux*)
-		basic_machine=hppa1.1-hitachi
-		os=-hiuxwe2
-		;;
-	h8300hms)
-		basic_machine=h8300-hitachi
-		os=-hms
-		;;
-	h8300xray)
-		basic_machine=h8300-hitachi
-		os=-xray
-		;;
-	h8500hms)
-		basic_machine=h8500-hitachi
-		os=-hms
-		;;
-	harris)
-		basic_machine=m88k-harris
-		os=-sysv3
-		;;
-	hp300-*)
-		basic_machine=m68k-hp
-		;;
-	hp300bsd)
-		basic_machine=m68k-hp
-		os=-bsd
-		;;
-	hp300hpux)
-		basic_machine=m68k-hp
-		os=-hpux
-		;;
-	hp3k9[0-9][0-9] | hp9[0-9][0-9])
-		basic_machine=hppa1.0-hp
-		;;
-	hp9k2[0-9][0-9] | hp9k31[0-9])
-		basic_machine=m68000-hp
-		;;
-	hp9k3[2-9][0-9])
-		basic_machine=m68k-hp
-		;;
-	hp9k6[0-9][0-9] | hp6[0-9][0-9])
-		basic_machine=hppa1.0-hp
-		;;
-	hp9k7[0-79][0-9] | hp7[0-79][0-9])
-		basic_machine=hppa1.1-hp
-		;;
-	hp9k78[0-9] | hp78[0-9])
-		# FIXME: really hppa2.0-hp
-		basic_machine=hppa1.1-hp
-		;;
-	hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893)
-		# FIXME: really hppa2.0-hp
-		basic_machine=hppa1.1-hp
-		;;
-	hp9k8[0-9][13679] | hp8[0-9][13679])
-		basic_machine=hppa1.1-hp
-		;;
-	hp9k8[0-9][0-9] | hp8[0-9][0-9])
-		basic_machine=hppa1.0-hp
-		;;
-	hppa-next)
-		os=-nextstep3
-		;;
-	hppaosf)
-		basic_machine=hppa1.1-hp
-		os=-osf
-		;;
-	hppro)
-		basic_machine=hppa1.1-hp
-		os=-proelf
-		;;
-	i370-ibm* | ibm*)
-		basic_machine=i370-ibm
-		;;
-	i*86v32)
-		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
-		os=-sysv32
-		;;
-	i*86v4*)
-		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
-		os=-sysv4
-		;;
-	i*86v)
-		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
-		os=-sysv
-		;;
-	i*86sol2)
-		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
-		os=-solaris2
-		;;
-	i386mach)
-		basic_machine=i386-mach
-		os=-mach
-		;;
-	i386-vsta | vsta)
-		basic_machine=i386-unknown
-		os=-vsta
-		;;
-	iris | iris4d)
-		basic_machine=mips-sgi
-		case $os in
-		    -irix*)
-			;;
-		    *)
-			os=-irix4
-			;;
-		esac
-		;;
-	isi68 | isi)
-		basic_machine=m68k-isi
-		os=-sysv
-		;;
-	leon-*|leon[3-9]-*)
-		basic_machine=sparc-`echo $basic_machine | sed 's/-.*//'`
-		;;
-	m68knommu)
-		basic_machine=m68k-unknown
-		os=-linux
-		;;
-	m68knommu-*)
-		basic_machine=m68k-`echo $basic_machine | sed 's/^[^-]*-//'`
-		os=-linux
-		;;
-	m88k-omron*)
-		basic_machine=m88k-omron
-		;;
-	magnum | m3230)
-		basic_machine=mips-mips
-		os=-sysv
-		;;
-	merlin)
-		basic_machine=ns32k-utek
-		os=-sysv
-		;;
-	microblaze*)
-		basic_machine=microblaze-xilinx
-		;;
-	mingw64)
-		basic_machine=x86_64-pc
-		os=-mingw64
-		;;
-	mingw32)
-		basic_machine=i686-pc
-		os=-mingw32
-		;;
-	mingw32ce)
-		basic_machine=arm-unknown
-		os=-mingw32ce
-		;;
-	miniframe)
-		basic_machine=m68000-convergent
-		;;
-	*mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*)
-		basic_machine=m68k-atari
-		os=-mint
-		;;
-	mips3*-*)
-		basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`
-		;;
-	mips3*)
-		basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown
-		;;
-	monitor)
-		basic_machine=m68k-rom68k
-		os=-coff
-		;;
-	morphos)
-		basic_machine=powerpc-unknown
-		os=-morphos
-		;;
-	moxiebox)
-		basic_machine=moxie-unknown
-		os=-moxiebox
-		;;
-	msdos)
-		basic_machine=i386-pc
-		os=-msdos
-		;;
-	ms1-*)
-		basic_machine=`echo $basic_machine | sed -e 's/ms1-/mt-/'`
-		;;
-	msys)
-		basic_machine=i686-pc
-		os=-msys
-		;;
-	mvs)
-		basic_machine=i370-ibm
-		os=-mvs
-		;;
-	nacl)
-		basic_machine=le32-unknown
-		os=-nacl
-		;;
-	pnacl)
-		basic_machine=le32-unknown
-		os=-pnacl
-		;;
-	ncr3000)
-		basic_machine=i486-ncr
-		os=-sysv4
-		;;
-	netbsd386)
-		basic_machine=i386-unknown
-		os=-netbsd
-		;;
-	netwinder)
-		basic_machine=armv4l-rebel
-		os=-linux
-		;;
-	news | news700 | news800 | news900)
-		basic_machine=m68k-sony
-		os=-newsos
-		;;
-	news1000)
-		basic_machine=m68030-sony
-		os=-newsos
-		;;
-	news-3600 | risc-news)
-		basic_machine=mips-sony
-		os=-newsos
-		;;
-	necv70)
-		basic_machine=v70-nec
-		os=-sysv
-		;;
-	next | m*-next )
-		basic_machine=m68k-next
-		case $os in
-		    -nextstep* )
-			;;
-		    -ns2*)
-		      os=-nextstep2
-			;;
-		    *)
-		      os=-nextstep3
-			;;
-		esac
-		;;
-	nh3000)
-		basic_machine=m68k-harris
-		os=-cxux
-		;;
-	nh[45]000)
-		basic_machine=m88k-harris
-		os=-cxux
-		;;
-	nindy960)
-		basic_machine=i960-intel
-		os=-nindy
-		;;
-	mon960)
-		basic_machine=i960-intel
-		os=-mon960
-		;;
-	nonstopux)
-		basic_machine=mips-compaq
-		os=-nonstopux
-		;;
-	np1)
-		basic_machine=np1-gould
-		;;
-	neo-tandem)
-		basic_machine=neo-tandem
-		;;
-	nse-tandem)
-		basic_machine=nse-tandem
-		;;
-	nsr-tandem)
-		basic_machine=nsr-tandem
-		;;
-	nsx-tandem)
-		basic_machine=nsx-tandem
-		;;
-	op50n-* | op60c-*)
-		basic_machine=hppa1.1-oki
-		os=-proelf
-		;;
-	openrisc | openrisc-*)
-		basic_machine=or32-unknown
-		;;
-	os400)
-		basic_machine=powerpc-ibm
-		os=-os400
-		;;
-	OSE68000 | ose68000)
-		basic_machine=m68000-ericsson
-		os=-ose
-		;;
-	os68k)
-		basic_machine=m68k-none
-		os=-os68k
-		;;
-	pa-hitachi)
-		basic_machine=hppa1.1-hitachi
-		os=-hiuxwe2
-		;;
-	paragon)
-		basic_machine=i860-intel
-		os=-osf
-		;;
-	parisc)
-		basic_machine=hppa-unknown
-		os=-linux
-		;;
-	parisc-*)
-		basic_machine=hppa-`echo $basic_machine | sed 's/^[^-]*-//'`
-		os=-linux
-		;;
-	pbd)
-		basic_machine=sparc-tti
-		;;
-	pbb)
-		basic_machine=m68k-tti
-		;;
-	pc532 | pc532-*)
-		basic_machine=ns32k-pc532
+		cpu=$basic_machine
+		vendor=pc
 		;;
+	# These rules are duplicated from below for sake of the special case above;
+	# i.e. things that normalized to x86 arches should also default to "pc"
 	pc98)
-		basic_machine=i386-pc
+		cpu=i386
+		vendor=pc
 		;;
-	pc98-*)
-		basic_machine=i386-`echo $basic_machine | sed 's/^[^-]*-//'`
+	x64 | amd64)
+		cpu=x86_64
+		vendor=pc
 		;;
-	pentium | p5 | k5 | k6 | nexgen | viac3)
-		basic_machine=i586-pc
+	# Recognize the basic CPU types without company name.
+	*)
+		cpu=$basic_machine
+		vendor=unknown
 		;;
-	pentiumpro | p6 | 6x86 | athlon | athlon_*)
-		basic_machine=i686-pc
+esac
+
+unset -v basic_machine
+
+# Decode basic machines in the full and proper CPU-Company form.
+case $cpu-$vendor in
+	# Here we handle the default manufacturer of certain CPU types in canonical form. It is in
+	# some cases the only manufacturer, in others, it is the most popular.
+	craynv-unknown)
+		vendor=cray
+		basic_os=${basic_os:-unicosmp}
 		;;
-	pentiumii | pentium2 | pentiumiii | pentium3)
-		basic_machine=i686-pc
+	c90-unknown | c90-cray)
+		vendor=cray
+		basic_os=${Basic_os:-unicos}
 		;;
-	pentium4)
-		basic_machine=i786-pc
+	fx80-unknown)
+		vendor=alliant
 		;;
-	pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*)
-		basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'`
+	romp-unknown)
+		vendor=ibm
 		;;
-	pentiumpro-* | p6-* | 6x86-* | athlon-*)
-		basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
+	mmix-unknown)
+		vendor=knuth
 		;;
-	pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*)
-		basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
+	microblaze-unknown | microblazeel-unknown)
+		vendor=xilinx
 		;;
-	pentium4-*)
-		basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'`
+	rs6000-unknown)
+		vendor=ibm
 		;;
-	pn)
-		basic_machine=pn-gould
+	vax-unknown)
+		vendor=dec
 		;;
-	power)	basic_machine=power-ibm
+	pdp11-unknown)
+		vendor=dec
 		;;
-	ppc | ppcbe)	basic_machine=powerpc-unknown
+	we32k-unknown)
+		vendor=att
 		;;
-	ppc-* | ppcbe-*)
-		basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'`
+	cydra-unknown)
+		vendor=cydrome
 		;;
-	ppcle | powerpclittle)
-		basic_machine=powerpcle-unknown
+	i370-ibm*)
+		vendor=ibm
 		;;
-	ppcle-* | powerpclittle-*)
-		basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'`
+	orion-unknown)
+		vendor=highlevel
 		;;
-	ppc64)	basic_machine=powerpc64-unknown
-		;;
-	ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'`
-		;;
-	ppc64le | powerpc64little)
-		basic_machine=powerpc64le-unknown
-		;;
-	ppc64le-* | powerpc64little-*)
-		basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'`
-		;;
-	ps2)
-		basic_machine=i386-ibm
-		;;
-	pw32)
-		basic_machine=i586-unknown
-		os=-pw32
-		;;
-	rdos | rdos64)
-		basic_machine=x86_64-pc
-		os=-rdos
-		;;
-	rdos32)
-		basic_machine=i386-pc
-		os=-rdos
-		;;
-	rom68k)
-		basic_machine=m68k-rom68k
-		os=-coff
-		;;
-	rm[46]00)
-		basic_machine=mips-siemens
-		;;
-	rtpc | rtpc-*)
-		basic_machine=romp-ibm
-		;;
-	s390 | s390-*)
-		basic_machine=s390-ibm
-		;;
-	s390x | s390x-*)
-		basic_machine=s390x-ibm
-		;;
-	sa29200)
-		basic_machine=a29k-amd
-		os=-udi
-		;;
-	sb1)
-		basic_machine=mipsisa64sb1-unknown
-		;;
-	sb1el)
-		basic_machine=mipsisa64sb1el-unknown
-		;;
-	sde)
-		basic_machine=mipsisa32-sde
-		os=-elf
-		;;
-	sei)
-		basic_machine=mips-sei
-		os=-seiux
-		;;
-	sequent)
-		basic_machine=i386-sequent
-		;;
-	sh)
-		basic_machine=sh-hitachi
-		os=-hms
-		;;
-	sh5el)
-		basic_machine=sh5le-unknown
-		;;
-	sh64)
-		basic_machine=sh64-unknown
-		;;
-	sparclite-wrs | simso-wrs)
-		basic_machine=sparclite-wrs
-		os=-vxworks
-		;;
-	sps7)
-		basic_machine=m68k-bull
-		os=-sysv2
-		;;
-	spur)
-		basic_machine=spur-unknown
-		;;
-	st2000)
-		basic_machine=m68k-tandem
-		;;
-	stratus)
-		basic_machine=i860-stratus
-		os=-sysv4
-		;;
-	strongarm-* | thumb-*)
-		basic_machine=arm-`echo $basic_machine | sed 's/^[^-]*-//'`
-		;;
-	sun2)
-		basic_machine=m68000-sun
-		;;
-	sun2os3)
-		basic_machine=m68000-sun
-		os=-sunos3
-		;;
-	sun2os4)
-		basic_machine=m68000-sun
-		os=-sunos4
-		;;
-	sun3os3)
-		basic_machine=m68k-sun
-		os=-sunos3
-		;;
-	sun3os4)
-		basic_machine=m68k-sun
-		os=-sunos4
-		;;
-	sun4os3)
-		basic_machine=sparc-sun
-		os=-sunos3
-		;;
-	sun4os4)
-		basic_machine=sparc-sun
-		os=-sunos4
-		;;
-	sun4sol2)
-		basic_machine=sparc-sun
-		os=-solaris2
-		;;
-	sun3 | sun3-*)
-		basic_machine=m68k-sun
-		;;
-	sun4)
-		basic_machine=sparc-sun
-		;;
-	sun386 | sun386i | roadrunner)
-		basic_machine=i386-sun
-		;;
-	sv1)
-		basic_machine=sv1-cray
-		os=-unicos
-		;;
-	symmetry)
-		basic_machine=i386-sequent
-		os=-dynix
-		;;
-	t3e)
-		basic_machine=alphaev5-cray
-		os=-unicos
-		;;
-	t90)
-		basic_machine=t90-cray
-		os=-unicos
-		;;
-	tile*)
-		basic_machine=$basic_machine-unknown
-		os=-linux-gnu
-		;;
-	tx39)
-		basic_machine=mipstx39-unknown
-		;;
-	tx39el)
-		basic_machine=mipstx39el-unknown
-		;;
-	toad1)
-		basic_machine=pdp10-xkl
-		os=-tops20
-		;;
-	tower | tower-32)
-		basic_machine=m68k-ncr
-		;;
-	tpf)
-		basic_machine=s390x-ibm
-		os=-tpf
-		;;
-	udi29k)
-		basic_machine=a29k-amd
-		os=-udi
-		;;
-	ultra3)
-		basic_machine=a29k-nyu
-		os=-sym1
-		;;
-	v810 | necv810)
-		basic_machine=v810-nec
-		os=-none
-		;;
-	vaxv)
-		basic_machine=vax-dec
-		os=-sysv
-		;;
-	vms)
-		basic_machine=vax-dec
-		os=-vms
-		;;
-	vpp*|vx|vx-*)
-		basic_machine=f301-fujitsu
-		;;
-	vxworks960)
-		basic_machine=i960-wrs
-		os=-vxworks
-		;;
-	vxworks68)
-		basic_machine=m68k-wrs
-		os=-vxworks
-		;;
-	vxworks29k)
-		basic_machine=a29k-wrs
-		os=-vxworks
-		;;
-	wasm32)
-		basic_machine=wasm32-unknown
-		;;
-	w65*)
-		basic_machine=w65-wdc
-		os=-none
-		;;
-	w89k-*)
-		basic_machine=hppa1.1-winbond
-		os=-proelf
-		;;
-	xbox)
-		basic_machine=i686-pc
-		os=-mingw32
-		;;
-	xps | xps100)
-		basic_machine=xps100-honeywell
-		;;
-	xscale-* | xscalee[bl]-*)
-		basic_machine=`echo $basic_machine | sed 's/^xscale/arm/'`
-		;;
-	ymp)
-		basic_machine=ymp-cray
-		os=-unicos
-		;;
-	z8k-*-coff)
-		basic_machine=z8k-unknown
-		os=-sim
-		;;
-	z80-*-coff)
-		basic_machine=z80-unknown
-		os=-sim
-		;;
-	none)
-		basic_machine=none-none
-		os=-none
+	xps-unknown | xps100-unknown)
+		cpu=xps100
+		vendor=honeywell
 		;;
 
-# Here we handle the default manufacturer of certain CPU types.  It is in
-# some cases the only manufacturer, in others, it is the most popular.
-	w89k)
-		basic_machine=hppa1.1-winbond
+	# Here we normalize CPU types with a missing or matching vendor
+	armh-unknown | armh-alt)
+		cpu=armv7l
+		vendor=alt
+		basic_os=${basic_os:-linux-gnueabihf}
 		;;
-	op50n)
-		basic_machine=hppa1.1-oki
+	dpx20-unknown | dpx20-bull)
+		cpu=rs6000
+		vendor=bull
+		basic_os=${basic_os:-bosx}
 		;;
-	op60c)
-		basic_machine=hppa1.1-oki
+
+	# Here we normalize CPU types irrespective of the vendor
+	amd64-*)
+		cpu=x86_64
 		;;
-	romp)
-		basic_machine=romp-ibm
+	blackfin-*)
+		cpu=bfin
+		basic_os=linux
 		;;
-	mmix)
-		basic_machine=mmix-knuth
+	c54x-*)
+		cpu=tic54x
 		;;
-	rs6000)
-		basic_machine=rs6000-ibm
+	c55x-*)
+		cpu=tic55x
 		;;
-	vax)
-		basic_machine=vax-dec
+	c6x-*)
+		cpu=tic6x
 		;;
-	pdp10)
-		# there are many clones, so DEC is not a safe bet
-		basic_machine=pdp10-unknown
+	e500v[12]-*)
+		cpu=powerpc
+		basic_os=${basic_os}"spe"
 		;;
-	pdp11)
-		basic_machine=pdp11-dec
+	mips3*-*)
+		cpu=mips64
 		;;
-	we32k)
-		basic_machine=we32k-att
+	ms1-*)
+		cpu=mt
 		;;
-	sh[1234] | sh[24]a | sh[24]aeb | sh[34]eb | sh[1234]le | sh[23]ele)
-		basic_machine=sh-unknown
+	m68knommu-*)
+		cpu=m68k
+		basic_os=linux
 		;;
-	sparc | sparcv8 | sparcv9 | sparcv9b | sparcv9v)
-		basic_machine=sparc-sun
+	m9s12z-* | m68hcs12z-* | hcs12z-* | s12z-*)
+		cpu=s12z
 		;;
-	cydra)
-		basic_machine=cydra-cydrome
+	openrisc-*)
+		cpu=or32
 		;;
-	orion)
-		basic_machine=orion-highlevel
+	parisc-*)
+		cpu=hppa
+		basic_os=linux
 		;;
-	orion105)
-		basic_machine=clipper-highlevel
+	pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*)
+		cpu=i586
 		;;
-	mac | mpw | mac-mpw)
-		basic_machine=m68k-apple
+	pentiumpro-* | p6-* | 6x86-* | athlon-* | athalon_*-*)
+		cpu=i686
 		;;
-	pmac | pmac-mpw)
-		basic_machine=powerpc-apple
+	pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*)
+		cpu=i686
 		;;
-	*-unknown)
-		# Make sure to match an already-canonicalized machine name.
+	pentium4-*)
+		cpu=i786
 		;;
+	pc98-*)
+		cpu=i386
+		;;
+	ppc-* | ppcbe-*)
+		cpu=powerpc
+		;;
+	ppcle-* | powerpclittle-*)
+		cpu=powerpcle
+		;;
+	ppc64-*)
+		cpu=powerpc64
+		;;
+	ppc64le-* | powerpc64little-*)
+		cpu=powerpc64le
+		;;
+	sb1-*)
+		cpu=mipsisa64sb1
+		;;
+	sb1el-*)
+		cpu=mipsisa64sb1el
+		;;
+	sh5e[lb]-*)
+		cpu=`echo "$cpu" | sed 's/^\(sh.\)e\(.\)$/\1\2e/'`
+		;;
+	spur-*)
+		cpu=spur
+		;;
+	strongarm-* | thumb-*)
+		cpu=arm
+		;;
+	tx39-*)
+		cpu=mipstx39
+		;;
+	tx39el-*)
+		cpu=mipstx39el
+		;;
+	x64-*)
+		cpu=x86_64
+		;;
+	xscale-* | xscalee[bl]-*)
+		cpu=`echo "$cpu" | sed 's/^xscale/arm/'`
+		;;
+	arm64-* | aarch64le-*)
+		cpu=aarch64
+		;;
+
+	# Recognize the canonical CPU Types that limit and/or modify the
+	# company names they are paired with.
+	cr16-*)
+		basic_os=${basic_os:-elf}
+		;;
+	crisv32-* | etraxfs*-*)
+		cpu=crisv32
+		vendor=axis
+		;;
+	cris-* | etrax*-*)
+		cpu=cris
+		vendor=axis
+		;;
+	crx-*)
+		basic_os=${basic_os:-elf}
+		;;
+	neo-tandem)
+		cpu=neo
+		vendor=tandem
+		;;
+	nse-tandem)
+		cpu=nse
+		vendor=tandem
+		;;
+	nsr-tandem)
+		cpu=nsr
+		vendor=tandem
+		;;
+	nsv-tandem)
+		cpu=nsv
+		vendor=tandem
+		;;
+	nsx-tandem)
+		cpu=nsx
+		vendor=tandem
+		;;
+	mipsallegrexel-sony)
+		cpu=mipsallegrexel
+		vendor=sony
+		;;
+	tile*-*)
+		basic_os=${basic_os:-linux-gnu}
+		;;
+
 	*)
-		echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
-		exit 1
+		# Recognize the canonical CPU types that are allowed with any
+		# company name.
+		case $cpu in
+			1750a | 580 \
+			| a29k \
+			| aarch64 | aarch64_be \
+			| abacus \
+			| alpha | alphaev[4-8] | alphaev56 | alphaev6[78] \
+			| alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] \
+			| alphapca5[67] | alpha64pca5[67] \
+			| am33_2.0 \
+			| amdgcn \
+			| arc | arceb | arc32 | arc64 \
+			| arm | arm[lb]e | arme[lb] | armv* \
+			| avr | avr32 \
+			| asmjs \
+			| ba \
+			| be32 | be64 \
+			| bfin | bpf | bs2000 \
+			| c[123]* | c30 | [cjt]90 | c4x \
+			| c8051 | clipper | craynv | csky | cydra \
+			| d10v | d30v | dlx | dsp16xx \
+			| e2k | elxsi | epiphany \
+			| f30[01] | f700 | fido | fr30 | frv | ft32 | fx80 \
+			| h8300 | h8500 \
+			| hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
+			| hexagon \
+			| i370 | i*86 | i860 | i960 | ia16 | ia64 \
+			| ip2k | iq2000 \
+			| k1om \
+			| le32 | le64 \
+			| lm32 \
+			| loongarch32 | loongarch64 | loongarchx32 \
+			| m32c | m32r | m32rle \
+			| m5200 | m68000 | m680[012346]0 | m68360 | m683?2 | m68k \
+			| m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x \
+			| m88110 | m88k | maxq | mb | mcore | mep | metag \
+			| microblaze | microblazeel \
+			| mips | mipsbe | mipseb | mipsel | mipsle \
+			| mips16 \
+			| mips64 | mips64eb | mips64el \
+			| mips64octeon | mips64octeonel \
+			| mips64orion | mips64orionel \
+			| mips64r5900 | mips64r5900el \
+			| mips64vr | mips64vrel \
+			| mips64vr4100 | mips64vr4100el \
+			| mips64vr4300 | mips64vr4300el \
+			| mips64vr5000 | mips64vr5000el \
+			| mips64vr5900 | mips64vr5900el \
+			| mipsisa32 | mipsisa32el \
+			| mipsisa32r2 | mipsisa32r2el \
+			| mipsisa32r3 | mipsisa32r3el \
+			| mipsisa32r5 | mipsisa32r5el \
+			| mipsisa32r6 | mipsisa32r6el \
+			| mipsisa64 | mipsisa64el \
+			| mipsisa64r2 | mipsisa64r2el \
+			| mipsisa64r3 | mipsisa64r3el \
+			| mipsisa64r5 | mipsisa64r5el \
+			| mipsisa64r6 | mipsisa64r6el \
+			| mipsisa64sb1 | mipsisa64sb1el \
+			| mipsisa64sr71k | mipsisa64sr71kel \
+			| mipsr5900 | mipsr5900el \
+			| mipstx39 | mipstx39el \
+			| mmix \
+			| mn10200 | mn10300 \
+			| moxie \
+			| mt \
+			| msp430 \
+			| nds32 | nds32le | nds32be \
+			| nfp \
+			| nios | nios2 | nios2eb | nios2el \
+			| none | np1 | ns16k | ns32k | nvptx \
+			| open8 \
+			| or1k* \
+			| or32 \
+			| orion \
+			| picochip \
+			| pdp10 | pdp11 | pj | pjl | pn | power \
+			| powerpc | powerpc64 | powerpc64le | powerpcle | powerpcspe \
+			| pru \
+			| pyramid \
+			| riscv | riscv32 | riscv32be | riscv64 | riscv64be \
+			| rl78 | romp | rs6000 | rx \
+			| s390 | s390x \
+			| score \
+			| sh | shl \
+			| sh[1234] | sh[24]a | sh[24]ae[lb] | sh[23]e | she[lb] | sh[lb]e \
+			| sh[1234]e[lb] |  sh[12345][lb]e | sh[23]ele | sh64 | sh64le \
+			| sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet \
+			| sparclite \
+			| sparcv8 | sparcv9 | sparcv9b | sparcv9v | sv1 | sx* \
+			| spu \
+			| tahoe \
+			| thumbv7* \
+			| tic30 | tic4x | tic54x | tic55x | tic6x | tic80 \
+			| tron \
+			| ubicom32 \
+			| v70 | v850 | v850e | v850e1 | v850es | v850e2 | v850e2v3 \
+			| vax \
+			| visium \
+			| w65 \
+			| wasm32 | wasm64 \
+			| we32k \
+			| x86 | x86_64 | xc16x | xgate | xps100 \
+			| xstormy16 | xtensa* \
+			| ymp \
+			| z8k | z80)
+				;;
+
+			*)
+				echo Invalid configuration \`"$1"\': machine \`"$cpu-$vendor"\' not recognized 1>&2
+				exit 1
+				;;
+		esac
 		;;
 esac
 
 # Here we canonicalize certain aliases for manufacturers.
-case $basic_machine in
-	*-digital*)
-		basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'`
+case $vendor in
+	digital*)
+		vendor=dec
 		;;
-	*-commodore*)
-		basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'`
+	commodore*)
+		vendor=cbm
 		;;
 	*)
 		;;
@@ -1380,218 +1306,215 @@ esac
 
 # Decode manufacturer-specific aliases for certain operating systems.
 
-if [ x"$os" != x"" ]
+if test x$basic_os != x
 then
+
+# First recognize some ad-hoc cases, or perhaps split kernel-os, or else just
+# set os.
+case $basic_os in
+	gnu/linux*)
+		kernel=linux
+		os=`echo "$basic_os" | sed -e 's|gnu/linux|gnu|'`
+		;;
+	os2-emx)
+		kernel=os2
+		os=`echo "$basic_os" | sed -e 's|os2-emx|emx|'`
+		;;
+	nto-qnx*)
+		kernel=nto
+		os=`echo "$basic_os" | sed -e 's|nto-qnx|qnx|'`
+		;;
+	*-*)
+		# shellcheck disable=SC2162
+		saved_IFS=$IFS
+		IFS="-" read kernel os <<EOF
+$basic_os
+EOF
+		IFS=$saved_IFS
+		;;
+	# Default OS when just kernel was specified
+	nto*)
+		kernel=nto
+		os=`echo "$basic_os" | sed -e 's|nto|qnx|'`
+		;;
+	linux*)
+		kernel=linux
+		os=`echo "$basic_os" | sed -e 's|linux|gnu|'`
+		;;
+	*)
+		kernel=
+		os=$basic_os
+		;;
+esac
+
+# Now, normalize the OS (knowing we just have one component, it's not a kernel,
+# etc.)
 case $os in
-	# First match some system type aliases
-	# that might get confused with valid system types.
-	# -solaris* is a basic system type, with this one exception.
-	-auroraux)
-		os=-auroraux
+	# First match some system type aliases that might get confused
+	# with valid system types.
+	# solaris* is a basic system type, with this one exception.
+	auroraux)
+		os=auroraux
 		;;
-	-solaris1 | -solaris1.*)
-		os=`echo $os | sed -e 's|solaris1|sunos4|'`
+	bluegene*)
+		os=cnk
 		;;
-	-solaris)
-		os=-solaris2
+	solaris1 | solaris1.*)
+		os=`echo "$os" | sed -e 's|solaris1|sunos4|'`
 		;;
-	-svr4*)
-		os=-sysv4
+	solaris)
+		os=solaris2
 		;;
-	-unixware*)
-		os=-sysv4.2uw
+	unixware*)
+		os=sysv4.2uw
 		;;
-	-gnu/linux*)
-		os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'`
+	# es1800 is here to avoid being matched by es* (a different OS)
+	es1800*)
+		os=ose
 		;;
-	# First accept the basic system types.
-	# The portable systems comes first.
-	# Each alternative MUST END IN A *, to match a version number.
-	# -sysv* is not here because it comes later, after sysvr4.
-	-gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \
-	      | -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\
-	      | -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \
-	      | -sym* | -kopensolaris* | -plan9* \
-	      | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \
-	      | -aos* | -aros* | -cloudabi* | -sortix* \
-	      | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \
-	      | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \
-	      | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \
-	      | -bitrig* | -openbsd* | -solidbsd* | -libertybsd* \
-	      | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \
-	      | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \
-	      | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
-	      | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \
-	      | -chorusos* | -chorusrdb* | -cegcc* | -glidix* \
-	      | -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
-	      | -midipix* | -mingw32* | -mingw64* | -linux-gnu* | -linux-android* \
-	      | -linux-newlib* | -linux-musl* | -linux-uclibc* \
-	      | -uxpv* | -beos* | -mpeix* | -udk* | -moxiebox* \
-	      | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \
-	      | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
-	      | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \
-	      | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \
-	      | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \
-	      | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \
-	      | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es* \
-	      | -onefs* | -tirtos* | -phoenix* | -fuchsia* | -redox*)
-	# Remember, each alternative MUST END IN *, to match a version number.
+	# Some version numbers need modification
+	chorusos*)
+		os=chorusos
 		;;
-	-qnx*)
-		case $basic_machine in
-		    x86-* | i*86-*)
+	isc)
+		os=isc2.2
+		;;
+	sco6)
+		os=sco5v6
+		;;
+	sco5)
+		os=sco3.2v5
+		;;
+	sco4)
+		os=sco3.2v4
+		;;
+	sco3.2.[4-9]*)
+		os=`echo "$os" | sed -e 's/sco3.2./sco3.2v/'`
+		;;
+	sco*v* | scout)
+		# Don't match below
+		;;
+	sco*)
+		os=sco3.2v2
+		;;
+	psos*)
+		os=psos
+		;;
+	qnx*)
+		os=qnx
+		;;
+	hiux*)
+		os=hiuxwe2
+		;;
+	lynx*178)
+		os=lynxos178
+		;;
+	lynx*5)
+		os=lynxos5
+		;;
+	lynxos*)
+		# don't get caught up in next wildcard
+		;;
+	lynx*)
+		os=lynxos
+		;;
+	mac[0-9]*)
+		os=`echo "$os" | sed -e 's|mac|macos|'`
+		;;
+	opened*)
+		os=openedition
+		;;
+	os400*)
+		os=os400
+		;;
+	sunos5*)
+		os=`echo "$os" | sed -e 's|sunos5|solaris2|'`
+		;;
+	sunos6*)
+		os=`echo "$os" | sed -e 's|sunos6|solaris3|'`
+		;;
+	wince*)
+		os=wince
+		;;
+	utek*)
+		os=bsd
+		;;
+	dynix*)
+		os=bsd
+		;;
+	acis*)
+		os=aos
+		;;
+	atheos*)
+		os=atheos
+		;;
+	syllable*)
+		os=syllable
+		;;
+	386bsd)
+		os=bsd
+		;;
+	ctix* | uts*)
+		os=sysv
+		;;
+	nova*)
+		os=rtmk-nova
+		;;
+	ns2)
+		os=nextstep2
+		;;
+	# Preserve the version number of sinix5.
+	sinix5.*)
+		os=`echo "$os" | sed -e 's|sinix|sysv|'`
+		;;
+	sinix*)
+		os=sysv4
+		;;
+	tpf*)
+		os=tpf
+		;;
+	triton*)
+		os=sysv3
+		;;
+	oss*)
+		os=sysv3
+		;;
+	svr4*)
+		os=sysv4
+		;;
+	svr3)
+		os=sysv3
+		;;
+	sysvr4)
+		os=sysv4
+		;;
+	ose*)
+		os=ose
+		;;
+	*mint | mint[0-9]* | *MiNT | MiNT[0-9]*)
+		os=mint
+		;;
+	dicos*)
+		os=dicos
+		;;
+	pikeos*)
+		# Until real need of OS specific support for
+		# particular features comes up, bare metal
+		# configurations are quite functional.
+		case $cpu in
+		    arm*)
+			os=eabi
 			;;
 		    *)
-			os=-nto$os
+			os=elf
 			;;
 		esac
 		;;
-	-nacl*)
-		os=-nacl
-		;;
-	-pnacl*)
-		os=-pnacl
-		;;
-	-nto-qnx*)
-		;;
-	-nto*)
-		os=`echo $os | sed -e 's|nto|nto-qnx|'`
-		;;
-	-sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \
-	      | -windows* | -osx | -abug | -netware* | -os9* | -beos* | -haiku* \
-	      | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*)
-		;;
-	-mac*)
-		os=`echo $os | sed -e 's|mac|macos|'`
-		;;
-	-linux-dietlibc)
-		os=-linux-dietlibc
-		;;
-	-linux*)
-		os=`echo $os | sed -e 's|linux|linux-gnu|'`
-		;;
-	-sunos5*)
-		os=`echo $os | sed -e 's|sunos5|solaris2|'`
-		;;
-	-sunos6*)
-		os=`echo $os | sed -e 's|sunos6|solaris3|'`
-		;;
-	-opened*)
-		os=-openedition
-		;;
-	-os400*)
-		os=-os400
-		;;
-	-cegcc*)
-		os=-cegcc
-		;;
-	-wince*)
-		os=-wince
-		;;
-	-osfrose*)
-		os=-osfrose
-		;;
-	-osf*)
-		os=-osf
-		;;
-	-utek*)
-		os=-bsd
-		;;
-	-dynix*)
-		os=-bsd
-		;;
-	-acis*)
-		os=-aos
-		;;
-	-atheos*)
-		os=-atheos
-		;;
-	-syllable*)
-		os=-syllable
-		;;
-	-386bsd)
-		os=-bsd
-		;;
-	-ctix* | -uts*)
-		os=-sysv
-		;;
-	-nova*)
-		os=-rtmk-nova
-		;;
-	-ns2 )
-		os=-nextstep2
-		;;
-	-nsk*)
-		os=-nsk
-		;;
-	# Preserve the version number of sinix5.
-	-sinix5.*)
-		os=`echo $os | sed -e 's|sinix|sysv|'`
-		;;
-	-sinix*)
-		os=-sysv4
-		;;
-	-tpf*)
-		os=-tpf
-		;;
-	-triton*)
-		os=-sysv3
-		;;
-	-oss*)
-		os=-sysv3
-		;;
-	-svr4)
-		os=-sysv4
-		;;
-	-svr3)
-		os=-sysv3
-		;;
-	-sysvr4)
-		os=-sysv4
-		;;
-	# This must come after -sysvr4.
-	-sysv*)
-		;;
-	-ose*)
-		os=-ose
-		;;
-	-es1800*)
-		os=-ose
-		;;
-	-xenix)
-		os=-xenix
-		;;
-	-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
-		os=-mint
-		;;
-	-aros*)
-		os=-aros
-		;;
-	-zvmoe)
-		os=-zvmoe
-		;;
-	-dicos*)
-		os=-dicos
-		;;
-	-nacl*)
-        os=-nacl
-        ;;
-	-pnacl*)
-		os=-pnacl
-		;;
-	-ios)
-		;;
-	-emscripten*)
-		;;
-	-none)
-		;;
 	*)
-		# Get rid of the `-' at the beginning of $os.
-		os=`echo $os | sed 's/[^-]*-//'`
-		echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2
-		exit 1
+		# No normalization, but not necessarily accepted, that comes below.
 		;;
 esac
+
 else
 
 # Here we handle the default operating systems that come with various machines.
@@ -1604,264 +1527,363 @@ else
 # will signal an error saying that MANUFACTURER isn't an operating
 # system, and we'll never get to this point.
 
-case $basic_machine in
+kernel=
+case $cpu-$vendor in
 	score-*)
-		os=-elf
+		os=elf
 		;;
 	spu-*)
-		os=-elf
+		os=elf
 		;;
 	*-acorn)
-		os=-riscix1.2
+		os=riscix1.2
 		;;
 	arm*-rebel)
-		os=-linux
+		kernel=linux
+		os=gnu
 		;;
 	arm*-semi)
-		os=-aout
+		os=aout
 		;;
 	c4x-* | tic4x-*)
-		os=-coff
+		os=coff
 		;;
 	c8051-*)
-		os=-elf
+		os=elf
+		;;
+	clipper-intergraph)
+		os=clix
 		;;
 	hexagon-*)
-		os=-elf
+		os=elf
 		;;
 	tic54x-*)
-		os=-coff
+		os=coff
 		;;
 	tic55x-*)
-		os=-coff
+		os=coff
 		;;
 	tic6x-*)
-		os=-coff
+		os=coff
 		;;
 	# This must come before the *-dec entry.
 	pdp10-*)
-		os=-tops20
+		os=tops20
 		;;
 	pdp11-*)
-		os=-none
+		os=none
 		;;
 	*-dec | vax-*)
-		os=-ultrix4.2
+		os=ultrix4.2
 		;;
 	m68*-apollo)
-		os=-domain
+		os=domain
 		;;
 	i386-sun)
-		os=-sunos4.0.2
+		os=sunos4.0.2
 		;;
 	m68000-sun)
-		os=-sunos3
+		os=sunos3
 		;;
 	m68*-cisco)
-		os=-aout
+		os=aout
 		;;
 	mep-*)
-		os=-elf
+		os=elf
 		;;
 	mips*-cisco)
-		os=-elf
+		os=elf
 		;;
 	mips*-*)
-		os=-elf
+		os=elf
 		;;
 	or32-*)
-		os=-coff
+		os=coff
 		;;
 	*-tti)	# must be before sparc entry or we get the wrong os.
-		os=-sysv3
+		os=sysv3
 		;;
 	sparc-* | *-sun)
-		os=-sunos4.1.1
+		os=sunos4.1.1
 		;;
 	pru-*)
-		os=-elf
+		os=elf
 		;;
 	*-be)
-		os=-beos
-		;;
-	*-haiku)
-		os=-haiku
+		os=beos
 		;;
 	*-ibm)
-		os=-aix
+		os=aix
 		;;
 	*-knuth)
-		os=-mmixware
+		os=mmixware
 		;;
 	*-wec)
-		os=-proelf
+		os=proelf
 		;;
 	*-winbond)
-		os=-proelf
+		os=proelf
 		;;
 	*-oki)
-		os=-proelf
+		os=proelf
 		;;
 	*-hp)
-		os=-hpux
+		os=hpux
 		;;
 	*-hitachi)
-		os=-hiux
+		os=hiux
 		;;
 	i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent)
-		os=-sysv
+		os=sysv
 		;;
 	*-cbm)
-		os=-amigaos
+		os=amigaos
 		;;
 	*-dg)
-		os=-dgux
+		os=dgux
 		;;
 	*-dolphin)
-		os=-sysv3
+		os=sysv3
 		;;
 	m68k-ccur)
-		os=-rtu
+		os=rtu
 		;;
 	m88k-omron*)
-		os=-luna
-		;;
-	*-next )
-		os=-nextstep
-		;;
-	*-sequent)
-		os=-ptx
-		;;
-	*-crds)
-		os=-unos
-		;;
-	*-ns)
-		os=-genix
-		;;
-	i370-*)
-		os=-mvs
+		os=luna
 		;;
 	*-next)
-		os=-nextstep3
+		os=nextstep
+		;;
+	*-sequent)
+		os=ptx
+		;;
+	*-crds)
+		os=unos
+		;;
+	*-ns)
+		os=genix
+		;;
+	i370-*)
+		os=mvs
 		;;
 	*-gould)
-		os=-sysv
+		os=sysv
 		;;
 	*-highlevel)
-		os=-bsd
+		os=bsd
 		;;
 	*-encore)
-		os=-bsd
+		os=bsd
 		;;
 	*-sgi)
-		os=-irix
+		os=irix
 		;;
 	*-siemens)
-		os=-sysv4
+		os=sysv4
 		;;
 	*-masscomp)
-		os=-rtu
+		os=rtu
 		;;
 	f30[01]-fujitsu | f700-fujitsu)
-		os=-uxpv
+		os=uxpv
 		;;
 	*-rom68k)
-		os=-coff
+		os=coff
 		;;
 	*-*bug)
-		os=-coff
+		os=coff
 		;;
 	*-apple)
-		os=-macos
+		os=macos
 		;;
 	*-atari*)
-		os=-mint
+		os=mint
+		;;
+	*-wrs)
+		os=vxworks
 		;;
 	*)
-		os=-none
+		os=none
 		;;
 esac
+
 fi
 
+# Now, validate our (potentially fixed-up) OS.
+case $os in
+	# Sometimes we do "kernel-libc", so those need to count as OSes.
+	musl* | newlib* | relibc* | uclibc*)
+		;;
+	# Likewise for "kernel-abi"
+	eabi* | gnueabi*)
+		;;
+	# VxWorks passes extra cpu info in the 4th filed.
+	simlinux | simwindows | spe)
+		;;
+	# Now accept the basic system types.
+	# The portable systems comes first.
+	# Each alternative MUST end in a * to match a version number.
+	gnu* | android* | bsd* | mach* | minix* | genix* | ultrix* | irix* \
+	     | *vms* | esix* | aix* | cnk* | sunos | sunos[34]* \
+	     | hpux* | unos* | osf* | luna* | dgux* | auroraux* | solaris* \
+	     | sym* |  plan9* | psp* | sim* | xray* | os68k* | v88r* \
+	     | hiux* | abug | nacl* | netware* | windows* \
+	     | os9* | macos* | osx* | ios* \
+	     | mpw* | magic* | mmixware* | mon960* | lnews* \
+	     | amigaos* | amigados* | msdos* | newsos* | unicos* | aof* \
+	     | aos* | aros* | cloudabi* | sortix* | twizzler* \
+	     | nindy* | vxsim* | vxworks* | ebmon* | hms* | mvs* \
+	     | clix* | riscos* | uniplus* | iris* | isc* | rtu* | xenix* \
+	     | mirbsd* | netbsd* | dicos* | openedition* | ose* \
+	     | bitrig* | openbsd* | secbsd* | solidbsd* | libertybsd* | os108* \
+	     | ekkobsd* | freebsd* | riscix* | lynxos* | os400* \
+	     | bosx* | nextstep* | cxux* | aout* | elf* | oabi* \
+	     | ptx* | coff* | ecoff* | winnt* | domain* | vsta* \
+	     | udi* | lites* | ieee* | go32* | aux* | hcos* \
+	     | chorusrdb* | cegcc* | glidix* | serenity* \
+	     | cygwin* | msys* | pe* | moss* | proelf* | rtems* \
+	     | midipix* | mingw32* | mingw64* | mint* \
+	     | uxpv* | beos* | mpeix* | udk* | moxiebox* \
+	     | interix* | uwin* | mks* | rhapsody* | darwin* \
+	     | openstep* | oskit* | conix* | pw32* | nonstopux* \
+	     | storm-chaos* | tops10* | tenex* | tops20* | its* \
+	     | os2* | vos* | palmos* | uclinux* | nucleus* | morphos* \
+	     | scout* | superux* | sysv* | rtmk* | tpf* | windiss* \
+	     | powermax* | dnix* | nx6 | nx7 | sei* | dragonfly* \
+	     | skyos* | haiku* | rdos* | toppers* | drops* | es* \
+	     | onefs* | tirtos* | phoenix* | fuchsia* | redox* | bme* \
+	     | midnightbsd* | amdhsa* | unleashed* | emscripten* | wasi* \
+	     | nsk* | powerunix* | genode* | zvmoe* | qnx* | emx* | zephyr* \
+	     | fiwix* )
+		;;
+	# This one is extra strict with allowed versions
+	sco3.2v2 | sco3.2v[4-9]* | sco5v6*)
+		# Don't forget version if it is 3.2v4 or newer.
+		;;
+	none)
+		;;
+	*)
+		echo Invalid configuration \`"$1"\': OS \`"$os"\' not recognized 1>&2
+		exit 1
+		;;
+esac
+
+# As a final step for OS-related things, validate the OS-kernel combination
+# (given a valid OS), if there is a kernel.
+case $kernel-$os in
+	linux-gnu* | linux-dietlibc* | linux-android* | linux-newlib* \
+		   | linux-musl* | linux-relibc* | linux-uclibc* )
+		;;
+	uclinux-uclibc* )
+		;;
+	-dietlibc* | -newlib* | -musl* | -relibc* | -uclibc* )
+		# These are just libc implementations, not actual OSes, and thus
+		# require a kernel.
+		echo "Invalid configuration \`$1': libc \`$os' needs explicit kernel." 1>&2
+		exit 1
+		;;
+	kfreebsd*-gnu* | kopensolaris*-gnu*)
+		;;
+	vxworks-simlinux | vxworks-simwindows | vxworks-spe)
+		;;
+	nto-qnx*)
+		;;
+	os2-emx)
+		;;
+	*-eabi* | *-gnueabi*)
+		;;
+	-*)
+		# Blank kernel with real OS is always fine.
+		;;
+	*-*)
+		echo "Invalid configuration \`$1': Kernel \`$kernel' not known to work with OS \`$os'." 1>&2
+		exit 1
+		;;
+esac
+
 # Here we handle the case where we know the os, and the CPU type, but not the
 # manufacturer.  We pick the logical manufacturer.
-vendor=unknown
-case $basic_machine in
-	*-unknown)
-		case $os in
-			-riscix*)
+case $vendor in
+	unknown)
+		case $cpu-$os in
+			*-riscix*)
 				vendor=acorn
 				;;
-			-sunos*)
+			*-sunos*)
 				vendor=sun
 				;;
-			-cnk*|-aix*)
+			*-cnk* | *-aix*)
 				vendor=ibm
 				;;
-			-beos*)
+			*-beos*)
 				vendor=be
 				;;
-			-hpux*)
+			*-hpux*)
 				vendor=hp
 				;;
-			-mpeix*)
+			*-mpeix*)
 				vendor=hp
 				;;
-			-hiux*)
+			*-hiux*)
 				vendor=hitachi
 				;;
-			-unos*)
+			*-unos*)
 				vendor=crds
 				;;
-			-dgux*)
+			*-dgux*)
 				vendor=dg
 				;;
-			-luna*)
+			*-luna*)
 				vendor=omron
 				;;
-			-genix*)
+			*-genix*)
 				vendor=ns
 				;;
-			-mvs* | -opened*)
+			*-clix*)
+				vendor=intergraph
+				;;
+			*-mvs* | *-opened*)
 				vendor=ibm
 				;;
-			-os400*)
+			*-os400*)
 				vendor=ibm
 				;;
-			-ptx*)
+			s390-* | s390x-*)
+				vendor=ibm
+				;;
+			*-ptx*)
 				vendor=sequent
 				;;
-			-tpf*)
+			*-tpf*)
 				vendor=ibm
 				;;
-			-vxsim* | -vxworks* | -windiss*)
+			*-vxsim* | *-vxworks* | *-windiss*)
 				vendor=wrs
 				;;
-			-aux*)
+			*-aux*)
 				vendor=apple
 				;;
-			-hms*)
+			*-hms*)
 				vendor=hitachi
 				;;
-			-mpw* | -macos*)
+			*-mpw* | *-macos*)
 				vendor=apple
 				;;
-			-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
+			*-*mint | *-mint[0-9]* | *-*MiNT | *-MiNT[0-9]*)
 				vendor=atari
 				;;
-			-vos*)
+			*-vos*)
 				vendor=stratus
 				;;
 		esac
-		basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"`
 		;;
 esac
 
-echo $basic_machine$os
+echo "$cpu-$vendor-${kernel:+$kernel-}$os"
 exit
 
 # Local variables:
-# eval: (add-hook 'write-file-hooks 'time-stamp)
+# eval: (add-hook 'before-save-hook 'time-stamp)
 # time-stamp-start: "timestamp='"
 # time-stamp-format: "%:y-%02m-%02d"
 # time-stamp-end: "'"
diff --git a/Engine/lib/sdl/build-scripts/config.sub.patch b/Engine/lib/sdl/build-scripts/config.sub.patch
deleted file mode 100644
index 8c09e0046..000000000
--- a/Engine/lib/sdl/build-scripts/config.sub.patch
+++ /dev/null
@@ -1,72 +0,0 @@
---- config.sub.orig	2017-09-09 08:01:02.139023205 -0700
-+++ config.sub	2017-09-09 07:59:35.798264474 -0700
-@@ -364,6 +364,19 @@
- 	i*86 | x86_64)
- 	  basic_machine=$basic_machine-pc
- 	  ;;
-+	nacl64*)
-+		basic_machine=x86_64-pc
-+		os=-nacl
-+		;;
-+	nacl*)
-+		basic_machine=i686-pc
-+		os=-nacl
-+		;;
-+	pnacl*)
-+		# le32-unknown-pnacl comes from http://www.chromium.org/nativeclient/pnacl/stability-of-the-pnacl-bitcode-abi
-+		basic_machine=le32-unknown
-+		os=-pnacl
-+		;;
- 	# Object if more than one company name word.
- 	*-*-*)
- 		echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
-@@ -877,6 +890,10 @@
- 		basic_machine=le32-unknown
- 		os=-nacl
- 		;;
-+	pnacl)
-+		basic_machine=le32-unknown
-+		os=-pnacl
-+		;;
- 	ncr3000)
- 		basic_machine=i486-ncr
- 		os=-sysv4
-@@ -1429,6 +1446,12 @@
- 			;;
- 		esac
- 		;;
-+	-nacl*)
-+		os=-nacl
-+		;;
-+	-pnacl*)
-+		os=-pnacl
-+		;;
- 	-nto-qnx*)
- 		;;
- 	-nto*)
-@@ -1459,6 +1482,9 @@
- 	-os400*)
- 		os=-os400
- 		;;
-+	-cegcc*)
-+		os=-cegcc
-+		;;
- 	-wince*)
- 		os=-wince
- 		;;
-@@ -1548,9 +1574,15 @@
- 		os=-dicos
- 		;;
- 	-nacl*)
-+        os=-nacl
-+        ;;
-+	-pnacl*)
-+		os=-pnacl
- 		;;
- 	-ios)
- 		;;
-+	-emscripten*)
-+		;;
- 	-none)
- 		;;
- 	*)
diff --git a/Engine/lib/sdl/build-scripts/emscripten-buildbot.sh b/Engine/lib/sdl/build-scripts/emscripten-buildbot.sh
index 7fa25918a..0898d747d 100755
--- a/Engine/lib/sdl/build-scripts/emscripten-buildbot.sh
+++ b/Engine/lib/sdl/build-scripts/emscripten-buildbot.sh
@@ -55,7 +55,7 @@ mkdir buildbot
 pushd buildbot
 
 echo "Configuring..."
-emconfigure ../configure --host=wasm-unknown-emscripten --disable-assembly --disable-threads --disable-cpuinfo CFLAGS="-O2 -Wno-warn-absolute-paths -Wdeclaration-after-statement -Werror=declaration-after-statement" --prefix="$PWD/emscripten-sdl2-installed" || exit $?
+emconfigure ../configure --host=wasm32-unknown-emscripten --disable-assembly --disable-threads --disable-cpuinfo CFLAGS="-O2 -Wno-warn-absolute-paths -Wdeclaration-after-statement -Werror=declaration-after-statement" --prefix="$PWD/emscripten-sdl2-installed" || exit $?
 
 echo "Building..."
 emmake $MAKE || exit $?
diff --git a/Engine/lib/sdl/build-scripts/fnsince.pl b/Engine/lib/sdl/build-scripts/fnsince.pl
new file mode 100644
index 000000000..6c69c5473
--- /dev/null
+++ b/Engine/lib/sdl/build-scripts/fnsince.pl
@@ -0,0 +1,174 @@
+#!/usr/bin/perl -w
+
+use warnings;
+use strict;
+use File::Basename;
+use Cwd qw(abs_path);
+
+my $wikipath = undef;
+foreach (@ARGV) {
+    $wikipath = abs_path($_), next if not defined $wikipath;
+}
+
+chdir(dirname(__FILE__));
+chdir('..');
+
+my @unsorted_releases = ();
+open(PIPEFH, '-|', 'git tag -l') or die "Failed to read git release tags: $!\n";
+
+while (<PIPEFH>) {
+    chomp;
+    if (/\Arelease\-(.*?)\Z/) {
+        push @unsorted_releases, $1;
+    }
+
+}
+close(PIPEFH);
+
+#print("\n\nUNSORTED\n");
+#foreach (@unsorted_releases) {
+#    print "$_\n";
+#}
+
+my @releases = sort {
+    my @asplit = split /\./, $a;
+    my @bsplit = split /\./, $b;
+    my $rc;
+    for (my $i = 0; $i < scalar(@asplit); $i++) {
+        return 1 if (scalar(@bsplit) <= $i);  # a is "2.0.1" and b is "2.0", or whatever.
+        my $aseg = $asplit[$i];
+        my $bseg = $bsplit[$i];
+        $rc = int($aseg) <=> int($bseg);
+        return $rc if ($rc != 0);  # found the difference.
+    }
+    return 0;  # still here? They matched completely?!
+} @unsorted_releases;
+
+# this happens to work for how SDL versions things at the moment.
+my $current_release = $releases[-1];
+my @current_release_segments = split /\./, $current_release;
+@current_release_segments[2] = '' . ($current_release_segments[2] + 2);
+my $next_release = join('.', @current_release_segments);
+
+#print("\n\nSORTED\n");
+#foreach (@releases) {
+#    print "$_\n";
+#}
+#print("\nCURRENT RELEASE: $current_release\n");
+#print("NEXT RELEASE: $next_release\n\n");
+
+push @releases, 'HEAD';
+
+my %funcs = ();
+foreach my $release (@releases) {
+    #print("Checking $release...\n");
+    next if ($release eq '2.0.0') || ($release eq '2.0.1');  # no dynapi before 2.0.2
+    my $assigned_release = ($release eq '2.0.2') ? '2.0.0' : $release;  # assume everything in 2.0.2--first with dynapi--was there since 2.0.0. We'll fix it up later.
+    my $tag = ($release eq 'HEAD') ? $release : "release-$release";
+    my $blobname = "$tag:src/dynapi/SDL_dynapi_overrides.h";
+    open(PIPEFH, '-|', "git show '$blobname'") or die "Failed to read git blob '$blobname': $!\n";
+    while (<PIPEFH>) {
+        chomp;
+        if (/\A\#define\s+(SDL_.*?)\s+SDL_.*?_REAL\Z/) {
+            my $fn = $1;
+            $funcs{$fn} = $assigned_release if not defined $funcs{$fn};
+        }
+    }
+    close(PIPEFH);
+}
+
+# Fixup the handful of functions that were added in 2.0.1 and 2.0.2 that we
+#  didn't have dynapi revision data about...
+$funcs{'SDL_GetSystemRAM'} = '2.0.1';
+$funcs{'SDL_GetBasePath'} = '2.0.1';
+$funcs{'SDL_GetPrefPath'} = '2.0.1';
+$funcs{'SDL_UpdateYUVTexture'} = '2.0.1';
+$funcs{'SDL_GL_GetDrawableSize'} = '2.0.1';
+$funcs{'SDL_Direct3D9GetAdapterIndex'} = '2.0.1';
+$funcs{'SDL_RenderGetD3D9Device'} = '2.0.1';
+
+$funcs{'SDL_RegisterApp'} = '2.0.2';
+$funcs{'SDL_UnregisterApp'} = '2.0.2';
+$funcs{'SDL_GetAssertionHandler'} = '2.0.2';
+$funcs{'SDL_GetDefaultAssertionHandler'} = '2.0.2';
+$funcs{'SDL_AtomicAdd'} = '2.0.2';
+$funcs{'SDL_AtomicGet'} = '2.0.2';
+$funcs{'SDL_AtomicGetPtr'} = '2.0.2';
+$funcs{'SDL_AtomicSet'} = '2.0.2';
+$funcs{'SDL_AtomicSetPtr'} = '2.0.2';
+$funcs{'SDL_HasAVX'} = '2.0.2';
+$funcs{'SDL_GameControllerAddMappingsFromRW'} = '2.0.2';
+$funcs{'SDL_acos'} = '2.0.2';
+$funcs{'SDL_asin'} = '2.0.2';
+$funcs{'SDL_vsscanf'} = '2.0.2';
+$funcs{'SDL_DetachThread'} = '2.0.2';
+$funcs{'SDL_GL_ResetAttributes'} = '2.0.2';
+$funcs{'SDL_DXGIGetOutputInfo'} = '2.0.2';
+
+# these are incorrect in the dynapi header, because we forgot to add them
+#  until a later release, but are available in the older release.
+$funcs{'SDL_WinRTGetFSPathUNICODE'} = '2.0.3';
+$funcs{'SDL_WinRTGetFSPathUTF8'} = '2.0.3';
+$funcs{'SDL_WinRTRunApp'} = '2.0.3';
+
+if (not defined $wikipath) {
+    foreach my $release (@releases) {
+        foreach my $fn (sort keys %funcs) {
+            print("$fn: $funcs{$fn}\n") if $funcs{$fn} eq $release;
+        }
+    }
+} else {
+    if (defined $wikipath) {
+        chdir($wikipath);
+        foreach my $fn (keys %funcs) {
+            my $revision = $funcs{$fn};
+            $revision = $next_release if $revision eq 'HEAD';
+            my $fname = "$fn.mediawiki";
+            if ( ! -f $fname ) {
+                #print STDERR "No such file: $fname\n";
+                next;
+            }
+
+            my @lines = ();
+            open(FH, '<', $fname) or die("Can't open $fname for read: $!\n");
+            my $added = 0;
+            while (<FH>) {
+                chomp;
+                if ((/\A\-\-\-\-/) && (!$added)) {
+                    push @lines, "== Version ==";
+                    push @lines, "";
+                    push @lines, "This function is available since SDL $revision.";
+                    push @lines, "";
+                    $added = 1;
+                }
+                push @lines, $_;
+                next if not /\A\=\=\s+Version\s+\=\=/;
+                $added = 1;
+                push @lines, "";
+                push @lines, "This function is available since SDL $revision.";
+                push @lines, "";
+                while (<FH>) {
+                    chomp;
+                    next if not (/\A\=\=\s+/ || /\A\-\-\-\-/);
+                    push @lines, $_;
+                    last;
+                }
+            }
+            close(FH);
+
+            if (!$added) {
+                push @lines, "== Version ==";
+                push @lines, "";
+                push @lines, "This function is available since SDL $revision.";
+                push @lines, "";
+            }
+
+            open(FH, '>', $fname) or die("Can't open $fname for write: $!\n");
+            foreach (@lines) {
+                print FH "$_\n";
+            }
+            close(FH);
+        }
+    }
+}
+
diff --git a/Engine/lib/sdl/build-scripts/git-pre-push-hook.pl b/Engine/lib/sdl/build-scripts/git-pre-push-hook.pl
new file mode 100644
index 000000000..ff84dff41
--- /dev/null
+++ b/Engine/lib/sdl/build-scripts/git-pre-push-hook.pl
@@ -0,0 +1,80 @@
+#!/usr/bin/perl -w
+
+# To use this script: symlink it to .git/hooks/pre-push, then "git push"
+#
+# This script is called by "git push" after it has checked the remote status,
+# but before anything has been pushed.  If this script exits with a non-zero
+# status nothing will be pushed.
+#
+# This hook is called with the following parameters:
+#
+# $1 -- Name of the remote to which the push is being done
+# $2 -- URL to which the push is being done
+#
+# If pushing without using a named remote those arguments will be equal.
+#
+# Information about the commits which are being pushed is supplied as lines to
+# the standard input in the form:
+#
+#   <local ref> <local sha1> <remote ref> <remote sha1>
+
+use warnings;
+use strict;
+
+my $remote = $ARGV[0];
+my $url = $ARGV[1];
+
+#print("remote: $remote\n");
+#print("url: $url\n");
+
+$url =~ s/\.git$//;  # change myorg/myproject.git to myorg/myproject
+$url =~ s#^git\@github\.com\:#https://github.com/#i;
+my $commiturl = $url =~ /\Ahttps?:\/\/github.com\// ? "$url/commit/" : '';
+
+my $z40 = '0000000000000000000000000000000000000000';
+my $reported = 0;
+
+while (<STDIN>) {
+    chomp;
+    my ($local_ref, $local_sha, $remote_ref, $remote_sha) = split / /;
+    #print("local_ref: $local_ref\n");
+    #print("local_sha: $local_sha\n");
+    #print("remote_ref: $remote_ref\n");
+    #print("remote_sha: $remote_sha\n");
+
+    my $range = '';
+    if ($remote_sha eq $z40) {  # New branch, examine all commits
+        $range = $local_sha;
+    } else { # Update to existing branch, examine new commits
+        $range = "$remote_sha..$local_sha";
+    }
+
+    my $gitcmd = "git log --reverse --oneline --no-abbrev-commit '$range'";
+    open(GITPIPE, '-|', $gitcmd) or die("\n\n$0: Failed to run '$gitcmd': $!\n\nAbort push!\n\n");
+    while (<GITPIPE>) {
+        chomp;
+        if (/\A([a-fA-F0-9]+)\s+(.*?)\Z/) {
+            my $hash = $1;
+            my $msg = $2;
+
+            if (!$reported) {
+                print("\nCommits expected to be pushed:\n");
+                $reported = 1;
+            }
+
+            #print("hash: $hash\n");
+            #print("msg: $msg\n");
+
+            print("$commiturl$hash -- $msg\n");
+        } else {
+            die("$0: Unexpected output from '$gitcmd'!\n\nAbort push!\n\n");
+        }
+    }
+    die("\n\n$0: Failing exit code from running '$gitcmd'!\n\nAbort push!\n\n") if !close(GITPIPE);
+}
+
+print("\n") if $reported;
+
+exit(0);  # Let the push go forward.
+
+# vi: set ts=4 sw=4 expandtab:
diff --git a/Engine/lib/sdl/build-scripts/install-sh b/Engine/lib/sdl/build-scripts/install-sh
index 377bb8687..ec298b537 100755
--- a/Engine/lib/sdl/build-scripts/install-sh
+++ b/Engine/lib/sdl/build-scripts/install-sh
@@ -1,7 +1,7 @@
 #!/bin/sh
 # install - install a program, script, or datafile
 
-scriptversion=2011-11-20.07; # UTC
+scriptversion=2020-11-14.01; # UTC
 
 # This originates from X11R5 (mit/util/scripts/install.sh), which was
 # later released in X11R6 (xc/config/util/install.sh) with the
@@ -41,19 +41,15 @@ scriptversion=2011-11-20.07; # UTC
 # This script is compatible with the BSD install script, but was written
 # from scratch.
 
+tab='	'
 nl='
 '
-IFS=" ""	$nl"
+IFS=" $tab$nl"
 
-# set DOITPROG to echo to test this script
+# Set DOITPROG to "echo" to test this script.
 
-# Don't use :- since 4.3BSD and earlier shells don't like it.
 doit=${DOITPROG-}
-if test -z "$doit"; then
-  doit_exec=exec
-else
-  doit_exec=$doit
-fi
+doit_exec=${doit:-exec}
 
 # Put in absolute file names if you don't have them in your path;
 # or use environment vars.
@@ -68,22 +64,16 @@ mvprog=${MVPROG-mv}
 rmprog=${RMPROG-rm}
 stripprog=${STRIPPROG-strip}
 
-posix_glob='?'
-initialize_posix_glob='
-  test "$posix_glob" != "?" || {
-    if (set -f) 2>/dev/null; then
-      posix_glob=
-    else
-      posix_glob=:
-    fi
-  }
-'
-
 posix_mkdir=
 
 # Desired mode of installed file.
 mode=0755
 
+# Create dirs (including intermediate dirs) using mode 755.
+# This is like GNU 'install' as of coreutils 8.32 (2020).
+mkdir_umask=22
+
+backupsuffix=
 chgrpcmd=
 chmodcmd=$chmodprog
 chowncmd=
@@ -97,7 +87,7 @@ dir_arg=
 dst_arg=
 
 copy_on_change=false
-no_target_directory=
+is_target_a_directory=possibly
 
 usage="\
 Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE
@@ -114,18 +104,28 @@ Options:
      --version  display version info and exit.
 
   -c            (ignored)
-  -C            install only if different (preserve the last data modification time)
+  -C            install only if different (preserve data modification time)
   -d            create directories instead of installing files.
   -g GROUP      $chgrpprog installed files to GROUP.
   -m MODE       $chmodprog installed files to MODE.
   -o USER       $chownprog installed files to USER.
+  -p            pass -p to $cpprog.
   -s            $stripprog installed files.
+  -S SUFFIX     attempt to back up existing files, with suffix SUFFIX.
   -t DIRECTORY  install into DIRECTORY.
   -T            report an error if DSTFILE is a directory.
 
 Environment variables override the default commands:
   CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG
   RMPROG STRIPPROG
+
+By default, rm is invoked with -f; when overridden with RMPROG,
+it's up to you to specify -f if you want it.
+
+If -S is not specified, no backups are attempted.
+
+Email bug reports to bug-automake@gnu.org.
+Automake home page: https://www.gnu.org/software/automake/
 "
 
 while test $# -ne 0; do
@@ -137,46 +137,62 @@ while test $# -ne 0; do
     -d) dir_arg=true;;
 
     -g) chgrpcmd="$chgrpprog $2"
-	shift;;
+        shift;;
 
     --help) echo "$usage"; exit $?;;
 
     -m) mode=$2
-	case $mode in
-	  *' '* | *'	'* | *'
-'*	  | *'*'* | *'?'* | *'['*)
-	    echo "$0: invalid mode: $mode" >&2
-	    exit 1;;
-	esac
-	shift;;
+        case $mode in
+          *' '* | *"$tab"* | *"$nl"* | *'*'* | *'?'* | *'['*)
+            echo "$0: invalid mode: $mode" >&2
+            exit 1;;
+        esac
+        shift;;
 
     -o) chowncmd="$chownprog $2"
-	shift;;
+        shift;;
+
+    -p) cpprog="$cpprog -p";;
 
     -s) stripcmd=$stripprog;;
 
-    -t) dst_arg=$2
-	# Protect names problematic for 'test' and other utilities.
-	case $dst_arg in
-	  -* | [=\(\)!]) dst_arg=./$dst_arg;;
-	esac
-	shift;;
+    -S) backupsuffix="$2"
+        shift;;
 
-    -T) no_target_directory=true;;
+    -t)
+        is_target_a_directory=always
+        dst_arg=$2
+        # Protect names problematic for 'test' and other utilities.
+        case $dst_arg in
+          -* | [=\(\)!]) dst_arg=./$dst_arg;;
+        esac
+        shift;;
+
+    -T) is_target_a_directory=never;;
 
     --version) echo "$0 $scriptversion"; exit $?;;
 
-    --)	shift
-	break;;
+    --) shift
+        break;;
 
-    -*)	echo "$0: invalid option: $1" >&2
-	exit 1;;
+    -*) echo "$0: invalid option: $1" >&2
+        exit 1;;
 
     *)  break;;
   esac
   shift
 done
 
+# We allow the use of options -d and -T together, by making -d
+# take the precedence; this is for compatibility with GNU install.
+
+if test -n "$dir_arg"; then
+  if test -n "$dst_arg"; then
+    echo "$0: target directory not allowed when installing a directory." >&2
+    exit 1
+  fi
+fi
+
 if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then
   # When -d is used, all remaining arguments are directories to create.
   # When -t is used, the destination is already specified.
@@ -207,6 +223,15 @@ if test $# -eq 0; then
   exit 0
 fi
 
+if test -z "$dir_arg"; then
+  if test $# -gt 1 || test "$is_target_a_directory" = always; then
+    if test ! -d "$dst_arg"; then
+      echo "$0: $dst_arg: Is not a directory." >&2
+      exit 1
+    fi
+  fi
+fi
+
 if test -z "$dir_arg"; then
   do_exit='(exit $ret); exit $ret'
   trap "ret=129; $do_exit" 1
@@ -223,16 +248,16 @@ if test -z "$dir_arg"; then
 
     *[0-7])
       if test -z "$stripcmd"; then
-	u_plus_rw=
+        u_plus_rw=
       else
-	u_plus_rw='% 200'
+        u_plus_rw='% 200'
       fi
       cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
     *)
       if test -z "$stripcmd"; then
-	u_plus_rw=
+        u_plus_rw=
       else
-	u_plus_rw=,u+rw
+        u_plus_rw=,u+rw
       fi
       cp_umask=$mode$u_plus_rw;;
   esac
@@ -250,6 +275,10 @@ do
     dstdir=$dst
     test -d "$dstdir"
     dstdir_status=$?
+    # Don't chown directories that already exist.
+    if test $dstdir_status = 0; then
+      chowncmd=""
+    fi
   else
 
     # Waiting for this to be detected by the "$cpprog $src $dsttmp" command
@@ -266,178 +295,148 @@ do
     fi
     dst=$dst_arg
 
-    # If destination is a directory, append the input filename; won't work
-    # if double slashes aren't ignored.
+    # If destination is a directory, append the input filename.
     if test -d "$dst"; then
-      if test -n "$no_target_directory"; then
-	echo "$0: $dst_arg: Is a directory" >&2
-	exit 1
+      if test "$is_target_a_directory" = never; then
+        echo "$0: $dst_arg: Is a directory" >&2
+        exit 1
       fi
       dstdir=$dst
-      dst=$dstdir/`basename "$src"`
+      dstbase=`basename "$src"`
+      case $dst in
+	*/) dst=$dst$dstbase;;
+	*)  dst=$dst/$dstbase;;
+      esac
       dstdir_status=0
     else
-      # Prefer dirname, but fall back on a substitute if dirname fails.
-      dstdir=`
-	(dirname "$dst") 2>/dev/null ||
-	expr X"$dst" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	     X"$dst" : 'X\(//\)[^/]' \| \
-	     X"$dst" : 'X\(//\)$' \| \
-	     X"$dst" : 'X\(/\)' \| . 2>/dev/null ||
-	echo X"$dst" |
-	    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
-		   s//\1/
-		   q
-		 }
-		 /^X\(\/\/\)[^/].*/{
-		   s//\1/
-		   q
-		 }
-		 /^X\(\/\/\)$/{
-		   s//\1/
-		   q
-		 }
-		 /^X\(\/\).*/{
-		   s//\1/
-		   q
-		 }
-		 s/.*/./; q'
-      `
-
+      dstdir=`dirname "$dst"`
       test -d "$dstdir"
       dstdir_status=$?
     fi
   fi
 
+  case $dstdir in
+    */) dstdirslash=$dstdir;;
+    *)  dstdirslash=$dstdir/;;
+  esac
+
   obsolete_mkdir_used=false
 
   if test $dstdir_status != 0; then
     case $posix_mkdir in
       '')
-	# Create intermediate dirs using mode 755 as modified by the umask.
-	# This is like FreeBSD 'install' as of 1997-10-28.
-	umask=`umask`
-	case $stripcmd.$umask in
-	  # Optimize common cases.
-	  *[2367][2367]) mkdir_umask=$umask;;
-	  .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;;
+        # With -d, create the new directory with the user-specified mode.
+        # Otherwise, rely on $mkdir_umask.
+        if test -n "$dir_arg"; then
+          mkdir_mode=-m$mode
+        else
+          mkdir_mode=
+        fi
 
-	  *[0-7])
-	    mkdir_umask=`expr $umask + 22 \
-	      - $umask % 100 % 40 + $umask % 20 \
-	      - $umask % 10 % 4 + $umask % 2
-	    `;;
-	  *) mkdir_umask=$umask,go-w;;
-	esac
+        posix_mkdir=false
+	# The $RANDOM variable is not portable (e.g., dash).  Use it
+	# here however when possible just to lower collision chance.
+	tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
 
-	# With -d, create the new directory with the user-specified mode.
-	# Otherwise, rely on $mkdir_umask.
-	if test -n "$dir_arg"; then
-	  mkdir_mode=-m$mode
+	trap '
+	  ret=$?
+	  rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" 2>/dev/null
+	  exit $ret
+	' 0
+
+	# Because "mkdir -p" follows existing symlinks and we likely work
+	# directly in world-writeable /tmp, make sure that the '$tmpdir'
+	# directory is successfully created first before we actually test
+	# 'mkdir -p'.
+	if (umask $mkdir_umask &&
+	    $mkdirprog $mkdir_mode "$tmpdir" &&
+	    exec $mkdirprog $mkdir_mode -p -- "$tmpdir/a/b") >/dev/null 2>&1
+	then
+	  if test -z "$dir_arg" || {
+	       # Check for POSIX incompatibilities with -m.
+	       # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
+	       # other-writable bit of parent directory when it shouldn't.
+	       # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
+	       test_tmpdir="$tmpdir/a"
+	       ls_ld_tmpdir=`ls -ld "$test_tmpdir"`
+	       case $ls_ld_tmpdir in
+		 d????-?r-*) different_mode=700;;
+		 d????-?--*) different_mode=755;;
+		 *) false;;
+	       esac &&
+	       $mkdirprog -m$different_mode -p -- "$test_tmpdir" && {
+		 ls_ld_tmpdir_1=`ls -ld "$test_tmpdir"`
+		 test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
+	       }
+	     }
+	  then posix_mkdir=:
+	  fi
+	  rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir"
 	else
-	  mkdir_mode=
+	  # Remove any dirs left behind by ancient mkdir implementations.
+	  rmdir ./$mkdir_mode ./-p ./-- "$tmpdir" 2>/dev/null
 	fi
-
-	posix_mkdir=false
-	case $umask in
-	  *[123567][0-7][0-7])
-	    # POSIX mkdir -p sets u+wx bits regardless of umask, which
-	    # is incompatible with FreeBSD 'install' when (umask & 300) != 0.
-	    ;;
-	  *)
-	    tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
-	    trap 'ret=$?; rmdir "$tmpdir/d" "$tmpdir" 2>/dev/null; exit $ret' 0
-
-	    if (umask $mkdir_umask &&
-		exec $mkdirprog $mkdir_mode -p -- "$tmpdir/d") >/dev/null 2>&1
-	    then
-	      if test -z "$dir_arg" || {
-		   # Check for POSIX incompatibilities with -m.
-		   # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
-		   # other-writable bit of parent directory when it shouldn't.
-		   # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
-		   ls_ld_tmpdir=`ls -ld "$tmpdir"`
-		   case $ls_ld_tmpdir in
-		     d????-?r-*) different_mode=700;;
-		     d????-?--*) different_mode=755;;
-		     *) false;;
-		   esac &&
-		   $mkdirprog -m$different_mode -p -- "$tmpdir" && {
-		     ls_ld_tmpdir_1=`ls -ld "$tmpdir"`
-		     test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
-		   }
-		 }
-	      then posix_mkdir=:
-	      fi
-	      rmdir "$tmpdir/d" "$tmpdir"
-	    else
-	      # Remove any dirs left behind by ancient mkdir implementations.
-	      rmdir ./$mkdir_mode ./-p ./-- 2>/dev/null
-	    fi
-	    trap '' 0;;
-	esac;;
+	trap '' 0;;
     esac
 
     if
       $posix_mkdir && (
-	umask $mkdir_umask &&
-	$doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
+        umask $mkdir_umask &&
+        $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
       )
     then :
     else
 
-      # The umask is ridiculous, or mkdir does not conform to POSIX,
+      # mkdir does not conform to POSIX,
       # or it failed possibly due to a race condition.  Create the
       # directory the slow way, step by step, checking for races as we go.
 
       case $dstdir in
-	/*) prefix='/';;
-	[-=\(\)!]*) prefix='./';;
-	*)  prefix='';;
+        /*) prefix='/';;
+        [-=\(\)!]*) prefix='./';;
+        *)  prefix='';;
       esac
 
-      eval "$initialize_posix_glob"
-
       oIFS=$IFS
       IFS=/
-      $posix_glob set -f
+      set -f
       set fnord $dstdir
       shift
-      $posix_glob set +f
+      set +f
       IFS=$oIFS
 
       prefixes=
 
       for d
       do
-	test X"$d" = X && continue
+        test X"$d" = X && continue
 
-	prefix=$prefix$d
-	if test -d "$prefix"; then
-	  prefixes=
-	else
-	  if $posix_mkdir; then
-	    (umask=$mkdir_umask &&
-	     $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
-	    # Don't fail if two instances are running concurrently.
-	    test -d "$prefix" || exit 1
-	  else
-	    case $prefix in
-	      *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
-	      *) qprefix=$prefix;;
-	    esac
-	    prefixes="$prefixes '$qprefix'"
-	  fi
-	fi
-	prefix=$prefix/
+        prefix=$prefix$d
+        if test -d "$prefix"; then
+          prefixes=
+        else
+          if $posix_mkdir; then
+            (umask $mkdir_umask &&
+             $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
+            # Don't fail if two instances are running concurrently.
+            test -d "$prefix" || exit 1
+          else
+            case $prefix in
+              *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
+              *) qprefix=$prefix;;
+            esac
+            prefixes="$prefixes '$qprefix'"
+          fi
+        fi
+        prefix=$prefix/
       done
 
       if test -n "$prefixes"; then
-	# Don't fail if two instances are running concurrently.
-	(umask $mkdir_umask &&
-	 eval "\$doit_exec \$mkdirprog $prefixes") ||
-	  test -d "$dstdir" || exit 1
-	obsolete_mkdir_used=true
+        # Don't fail if two instances are running concurrently.
+        (umask $mkdir_umask &&
+         eval "\$doit_exec \$mkdirprog $prefixes") ||
+          test -d "$dstdir" || exit 1
+        obsolete_mkdir_used=true
       fi
     fi
   fi
@@ -450,14 +449,25 @@ do
   else
 
     # Make a couple of temp file names in the proper directory.
-    dsttmp=$dstdir/_inst.$$_
-    rmtmp=$dstdir/_rm.$$_
+    dsttmp=${dstdirslash}_inst.$$_
+    rmtmp=${dstdirslash}_rm.$$_
 
     # Trap to clean up those temp files at exit.
     trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0
 
     # Copy the file name to the temp name.
-    (umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") &&
+    (umask $cp_umask &&
+     { test -z "$stripcmd" || {
+	 # Create $dsttmp read-write so that cp doesn't create it read-only,
+	 # which would cause strip to fail.
+	 if test -z "$doit"; then
+	   : >"$dsttmp" # No need to fork-exec 'touch'.
+	 else
+	   $doit touch "$dsttmp"
+	 fi
+       }
+     } &&
+     $doit_exec $cpprog "$src" "$dsttmp") &&
 
     # and set any options; do chmod last to preserve setuid bits.
     #
@@ -472,20 +482,24 @@ do
 
     # If -C, don't bother to copy if it wouldn't change the file.
     if $copy_on_change &&
-       old=`LC_ALL=C ls -dlL "$dst"	2>/dev/null` &&
-       new=`LC_ALL=C ls -dlL "$dsttmp"	2>/dev/null` &&
-
-       eval "$initialize_posix_glob" &&
-       $posix_glob set -f &&
+       old=`LC_ALL=C ls -dlL "$dst"     2>/dev/null` &&
+       new=`LC_ALL=C ls -dlL "$dsttmp"  2>/dev/null` &&
+       set -f &&
        set X $old && old=:$2:$4:$5:$6 &&
        set X $new && new=:$2:$4:$5:$6 &&
-       $posix_glob set +f &&
-
+       set +f &&
        test "$old" = "$new" &&
        $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
     then
       rm -f "$dsttmp"
     else
+      # If $backupsuffix is set, and the file being installed
+      # already exists, attempt a backup.  Don't worry if it fails,
+      # e.g., if mv doesn't support -f.
+      if test -n "$backupsuffix" && test -f "$dst"; then
+        $doit $mvcmd -f "$dst" "$dst$backupsuffix" 2>/dev/null
+      fi
+
       # Rename the file to the real destination.
       $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null ||
 
@@ -493,24 +507,24 @@ do
       # to itself, or perhaps because mv is so ancient that it does not
       # support -f.
       {
-	# Now remove or move aside any old file at destination location.
-	# We try this two ways since rm can't unlink itself on some
-	# systems and the destination file might be busy for other
-	# reasons.  In this case, the final cleanup might fail but the new
-	# file should still install successfully.
-	{
-	  test ! -f "$dst" ||
-	  $doit $rmcmd -f "$dst" 2>/dev/null ||
-	  { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
-	    { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; }
-	  } ||
-	  { echo "$0: cannot unlink or rename $dst" >&2
-	    (exit 1); exit 1
-	  }
-	} &&
+        # Now remove or move aside any old file at destination location.
+        # We try this two ways since rm can't unlink itself on some
+        # systems and the destination file might be busy for other
+        # reasons.  In this case, the final cleanup might fail but the new
+        # file should still install successfully.
+        {
+          test ! -f "$dst" ||
+          $doit $rmcmd "$dst" 2>/dev/null ||
+          { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
+            { $doit $rmcmd "$rmtmp" 2>/dev/null; :; }
+          } ||
+          { echo "$0: cannot unlink or rename $dst" >&2
+            (exit 1); exit 1
+          }
+        } &&
 
-	# Now rename the file to the real destination.
-	$doit $mvcmd "$dsttmp" "$dst"
+        # Now rename the file to the real destination.
+        $doit $mvcmd "$dsttmp" "$dst"
       }
     fi || exit 1
 
@@ -519,9 +533,9 @@ do
 done
 
 # Local variables:
-# eval: (add-hook 'write-file-hooks 'time-stamp)
+# eval: (add-hook 'before-save-hook 'time-stamp)
 # time-stamp-start: "scriptversion="
 # time-stamp-format: "%:y-%02m-%02d.%02H"
-# time-stamp-time-zone: "UTC"
+# time-stamp-time-zone: "UTC0"
 # time-stamp-end: "; # UTC"
 # End:
diff --git a/Engine/lib/sdl/build-scripts/iosbuild.sh b/Engine/lib/sdl/build-scripts/iosbuild.sh
deleted file mode 100755
index 143de7dad..000000000
--- a/Engine/lib/sdl/build-scripts/iosbuild.sh
+++ /dev/null
@@ -1,190 +0,0 @@
-#!/bin/sh
-#
-# Build a fat binary for iOS
-
-# Number of CPUs (for make -j)
-NCPU=`sysctl -n hw.ncpu`
-if test x$NJOB = x; then
-    NJOB=$NCPU
-fi
-
-SRC_DIR=$(cd `dirname $0`/..; pwd)
-if [ "$PWD" = "$SRC_DIR" ]; then
-    PREFIX=$SRC_DIR/ios-build
-    if [ ! -d "$PREFIX" ]; then
-        mkdir $PREFIX
-    fi
-else
-    PREFIX=$PWD
-fi
-
-BUILD_I386_IOSSIM=YES
-BUILD_X86_64_IOSSIM=YES
-
-BUILD_IOS_ARMV7=YES
-BUILD_IOS_ARMV7S=YES
-BUILD_IOS_ARM64=YES
-
-# 13.4.0 - Mavericks
-# 14.0.0 - Yosemite
-# 15.0.0 - El Capitan
-DARWIN=darwin15.0.0
-
-XCODEDIR=`xcode-select --print-path`
-IOS_SDK_VERSION=`xcrun --sdk iphoneos --show-sdk-version`
-MIN_SDK_VERSION=6.0
-
-IPHONEOS_PLATFORM=`xcrun --sdk iphoneos --show-sdk-platform-path`
-IPHONEOS_SYSROOT=`xcrun --sdk iphoneos --show-sdk-path`
-
-IPHONESIMULATOR_PLATFORM=`xcrun --sdk iphonesimulator --show-sdk-platform-path`
-IPHONESIMULATOR_SYSROOT=`xcrun --sdk iphonesimulator --show-sdk-path`
-
-# Uncomment if you want to see more information about each invocation
-# of clang as the builds proceed.
-# CLANG_VERBOSE="--verbose"
-
-CC=clang
-CXX=clang
-
-SILENCED_WARNINGS="-Wno-unused-local-typedef -Wno-unused-function"
-
-CFLAGS="${CLANG_VERBOSE} ${SILENCED_WARNINGS} -DNDEBUG -g -O0 -pipe -fPIC -fobjc-arc"
-
-echo "PREFIX ..................... ${PREFIX}"
-echo "BUILD_MACOSX_X86_64 ........ ${BUILD_MACOSX_X86_64}"
-echo "BUILD_I386_IOSSIM .......... ${BUILD_I386_IOSSIM}"
-echo "BUILD_X86_64_IOSSIM ........ ${BUILD_X86_64_IOSSIM}"
-echo "BUILD_IOS_ARMV7 ............ ${BUILD_IOS_ARMV7}"
-echo "BUILD_IOS_ARMV7S ........... ${BUILD_IOS_ARMV7S}"
-echo "BUILD_IOS_ARM64 ............ ${BUILD_IOS_ARM64}"
-echo "DARWIN ..................... ${DARWIN}"
-echo "XCODEDIR ................... ${XCODEDIR}"
-echo "IOS_SDK_VERSION ............ ${IOS_SDK_VERSION}"
-echo "MIN_SDK_VERSION ............ ${MIN_SDK_VERSION}"
-echo "IPHONEOS_PLATFORM .......... ${IPHONEOS_PLATFORM}"
-echo "IPHONEOS_SYSROOT ........... ${IPHONEOS_SYSROOT}"
-echo "IPHONESIMULATOR_PLATFORM ... ${IPHONESIMULATOR_PLATFORM}"
-echo "IPHONESIMULATOR_SYSROOT .... ${IPHONESIMULATOR_SYSROOT}"
-echo "CC ......................... ${CC}"
-echo "CFLAGS ..................... ${CFLAGS}"
-echo "CXX ........................ ${CXX}"
-echo "CXXFLAGS ................... ${CXXFLAGS}"
-echo "LDFLAGS .................... ${LDFLAGS}"
-
-###################################################################
-# This section contains the build commands for each of the 
-# architectures that will be included in the universal binaries.
-###################################################################
-
-echo "$(tput setaf 2)"
-echo "###########################"
-echo "# i386 for iPhone Simulator"
-echo "###########################"
-echo "$(tput sgr0)"
-
-if [ "${BUILD_I386_IOSSIM}" == "YES" ]
-then
-    (
-        cd ${PREFIX}
-        make clean
-        ../configure --build=x86_64-apple-${DARWIN} --host=i386-ios-${DARWIN} --disable-shared --prefix=${PREFIX}/platform/i386-sim "CC=${CC}" "CFLAGS=${CFLAGS} -mios-simulator-version-min=${MIN_SDK_VERSION} -arch i386 -isysroot ${IPHONESIMULATOR_SYSROOT}" "CXX=${CXX}" "CXXFLAGS=${CXXFLAGS} -mios-simulator-version-min=${MIN_SDK_VERSION} -arch i386 -isysroot ${IPHONESIMULATOR_SYSROOT}" LDFLAGS="-arch i386 -mios-simulator-version-min=${MIN_SDK_VERSION} ${LDFLAGS} -L${IPHONESIMULATOR_SYSROOT}/usr/lib/ -L${IPHONESIMULATOR_SYSROOT}/usr/lib/system" || exit 2
-        cp $SRC_DIR/include/SDL_config_iphoneos.h include/SDL_config.h
-        make -j10 || exit 3
-        make install
-    ) || exit $?
-fi
-
-echo "$(tput setaf 2)"
-echo "#############################"
-echo "# x86_64 for iPhone Simulator"
-echo "#############################"
-echo "$(tput sgr0)"
-
-if [ "${BUILD_X86_64_IOSSIM}" == "YES" ]
-then
-    (
-        cd ${PREFIX}
-        make clean
-        ../configure --build=x86_64-apple-${DARWIN} --host=x86_64-ios-${DARWIN} --disable-shared --prefix=${PREFIX}/platform/x86_64-sim "CC=${CC}" "CFLAGS=${CFLAGS} -mios-simulator-version-min=${MIN_SDK_VERSION} -arch x86_64 -isysroot ${IPHONESIMULATOR_SYSROOT}" "CXX=${CXX}" "CXXFLAGS=${CXXFLAGS} -mios-simulator-version-min=${MIN_SDK_VERSION} -arch x86_64 -isysroot ${IPHONESIMULATOR_SYSROOT}" LDFLAGS="-arch x86_64 -mios-simulator-version-min=${MIN_SDK_VERSION} ${LDFLAGS} -L${IPHONESIMULATOR_SYSROOT}/usr/lib/ -L${IPHONESIMULATOR_SYSROOT}/usr/lib/system" || exit 2
-        cp $SRC_DIR/include/SDL_config_iphoneos.h include/SDL_config.h
-        make -j$NJOB || exit 3
-        make install
-    ) || exit $?
-fi
-
-echo "$(tput setaf 2)"
-echo "##################"
-echo "# armv7 for iPhone"
-echo "##################"
-echo "$(tput sgr0)"
-
-if [ "${BUILD_IOS_ARMV7}" == "YES" ]
-then
-    (
-        cd ${PREFIX}
-        make clean
-        ../configure --build=x86_64-apple-${DARWIN} --host=armv7-ios-${DARWIN} --disable-shared --prefix=${PREFIX}/platform/armv7-ios "CC=${CC}" "CFLAGS=${CFLAGS} -miphoneos-version-min=${MIN_SDK_VERSION} -arch armv7 -isysroot ${IPHONEOS_SYSROOT}" "CXX=${CXX}" "CXXFLAGS=${CXXFLAGS} -arch armv7 -isysroot ${IPHONEOS_SYSROOT}" LDFLAGS="-arch armv7 -miphoneos-version-min=${MIN_SDK_VERSION} ${LDFLAGS}" || exit 2
-        cp $SRC_DIR/include/SDL_config_iphoneos.h include/SDL_config.h
-        make -j$NJOB || exit 3
-        make install
-    ) || exit $?
-fi
-
-echo "$(tput setaf 2)"
-echo "###################"
-echo "# armv7s for iPhone"
-echo "###################"
-echo "$(tput sgr0)"
-
-if [ "${BUILD_IOS_ARMV7S}" == "YES" ]
-then
-    (
-        cd ${PREFIX}
-        make clean
-        ../configure --build=x86_64-apple-${DARWIN} --host=armv7s-ios-${DARWIN} --disable-shared --prefix=${PREFIX}/platform/armv7s-ios "CC=${CC}" "CFLAGS=${CFLAGS} -miphoneos-version-min=${MIN_SDK_VERSION} -arch armv7s -isysroot ${IPHONEOS_SYSROOT}" "CXX=${CXX}" "CXXFLAGS=${CXXFLAGS} -miphoneos-version-min=${MIN_SDK_VERSION} -arch armv7s -isysroot ${IPHONEOS_SYSROOT}" LDFLAGS="-arch armv7s -miphoneos-version-min=${MIN_SDK_VERSION} ${LDFLAGS}" || exit 2
-        cp $SRC_DIR/include/SDL_config_iphoneos.h include/SDL_config.h
-        make -j$NJOB || exit 3
-        make install
-    ) || exit $?
-fi
-
-echo "$(tput setaf 2)"
-echo "##################"
-echo "# arm64 for iPhone"
-echo "##################"
-echo "$(tput sgr0)"
-
-if [ "${BUILD_IOS_ARM64}" == "YES" ]
-then
-    (
-        cd ${PREFIX}
-        make clean
-        ../configure --build=x86_64-apple-${DARWIN} --host=arm-ios-${DARWIN} --disable-shared --prefix=${PREFIX}/platform/arm64-ios "CC=${CC}" "CFLAGS=${CFLAGS} -miphoneos-version-min=${MIN_SDK_VERSION} -arch arm64 -isysroot ${IPHONEOS_SYSROOT}" "CXX=${CXX}" "CXXFLAGS=${CXXFLAGS} -miphoneos-version-min=${MIN_SDK_VERSION} -arch arm64 -isysroot ${IPHONEOS_SYSROOT}" LDFLAGS="-arch arm64 -miphoneos-version-min=${MIN_SDK_VERSION} ${LDFLAGS}" || exit 2
-        cp $SRC_DIR/include/SDL_config_iphoneos.h include/SDL_config.h
-        make -j$NJOB || exit 3
-        make install
-    ) || exit $?
-fi
-
-echo "$(tput setaf 2)"
-echo "###################################################################"
-echo "# Create Universal Libraries and Finalize the packaging"
-echo "###################################################################"
-echo "$(tput sgr0)"
-
-(
-    cd ${PREFIX}/platform
-    mkdir -p universal
-    lipo x86_64-sim/lib/libSDL2.a i386-sim/lib/libSDL2.a arm64-ios/lib/libSDL2.a armv7s-ios/lib/libSDL2.a armv7-ios/lib/libSDL2.a -create -output universal/libSDL2.a
-)
-
-(
-    cd ${PREFIX}
-    mkdir -p lib
-    cp -r platform/universal/* lib
-    #rm -rf platform
-    lipo -info lib/libSDL2.a
-)
-
-echo Done!
diff --git a/Engine/lib/sdl/build-scripts/ltmain.sh b/Engine/lib/sdl/build-scripts/ltmain.sh
index eca1501e4..70a3e8253 100755
--- a/Engine/lib/sdl/build-scripts/ltmain.sh
+++ b/Engine/lib/sdl/build-scripts/ltmain.sh
@@ -1,9 +1,12 @@
+#! /bin/sh
+## DO NOT EDIT - This file generated from ./build-aux/ltmain.in
+##               by inline-source v2014-01-03.01
 
-# libtool (GNU libtool) 2.4.2
+# libtool (GNU libtool) 2.4.6
+# Provide generalized library-building support services.
 # Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
 
-# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
-# 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
+# Copyright (C) 1996-2015 Free Software Foundation, Inc.
 # This is free software; see the source for copying conditions.  There is NO
 # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
@@ -23,430 +26,998 @@
 # General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
-# along with GNU Libtool; see the file COPYING.  If not, a copy
-# can be downloaded from http://www.gnu.org/licenses/gpl.html,
-# or obtained by writing to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-# Usage: $progname [OPTION]... [MODE-ARG]...
-#
-# Provide generalized library-building support services.
-#
-#       --config             show all configuration variables
-#       --debug              enable verbose shell tracing
-#   -n, --dry-run            display commands without modifying any files
-#       --features           display basic configuration information and exit
-#       --mode=MODE          use operation mode MODE
-#       --preserve-dup-deps  don't remove duplicate dependency libraries
-#       --quiet, --silent    don't print informational messages
-#       --no-quiet, --no-silent
-#                            print informational messages (default)
-#       --no-warn            don't display warning messages
-#       --tag=TAG            use configuration variables from tag TAG
-#   -v, --verbose            print more informational messages than default
-#       --no-verbose         don't print the extra informational messages
-#       --version            print version information
-#   -h, --help, --help-all   print short, long, or detailed help message
-#
-# MODE must be one of the following:
-#
-#         clean              remove files from the build directory
-#         compile            compile a source file into a libtool object
-#         execute            automatically set library path, then run a program
-#         finish             complete the installation of libtool libraries
-#         install            install libraries or executables
-#         link               create a library or an executable
-#         uninstall          remove libraries from an installed directory
-#
-# MODE-ARGS vary depending on the MODE.  When passed as first option,
-# `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
-# Try `$progname --help --mode=MODE' for a more detailed description of MODE.
-#
-# When reporting a bug, please describe a test case to reproduce it and
-# include the following information:
-#
-#         host-triplet:	$host
-#         shell:		$SHELL
-#         compiler:		$LTCC
-#         compiler flags:		$LTCFLAGS
-#         linker:		$LD (gnu? $with_gnu_ld)
-#         $progname:	(GNU libtool) 2.4.2
-#         automake:	$automake_version
-#         autoconf:	$autoconf_version
-#
-# Report bugs to <bug-libtool@gnu.org>.
-# GNU libtool home page: <http://www.gnu.org/software/libtool/>.
-# General help using GNU software: <http://www.gnu.org/gethelp/>.
 
 PROGRAM=libtool
 PACKAGE=libtool
-VERSION=2.4.2
-TIMESTAMP=""
-package_revision=1.3337
+VERSION=2.4.6
+package_revision=2.4.6
 
-# Be Bourne compatible
-if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
+
+## ------ ##
+## Usage. ##
+## ------ ##
+
+# Run './libtool --help' for help with using this script from the
+# command line.
+
+
+## ------------------------------- ##
+## User overridable command paths. ##
+## ------------------------------- ##
+
+# After configure completes, it has a better idea of some of the
+# shell tools we need than the defaults used by the functions shared
+# with bootstrap, so set those here where they can still be over-
+# ridden by the user, but otherwise take precedence.
+
+: ${AUTOCONF="autoconf"}
+: ${AUTOMAKE="automake"}
+
+
+## -------------------------- ##
+## Source external libraries. ##
+## -------------------------- ##
+
+# Much of our low-level functionality needs to be sourced from external
+# libraries, which are installed to $pkgauxdir.
+
+# Set a version string for this script.
+scriptversion=2015-01-20.17; # UTC
+
+# General shell script boiler plate, and helper functions.
+# Written by Gary V. Vaughan, 2004
+
+# Copyright (C) 2004-2015 Free Software Foundation, Inc.
+# This is free software; see the source for copying conditions.  There is NO
+# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+
+# As a special exception to the GNU General Public License, if you distribute
+# this file as part of a program or library that is built using GNU Libtool,
+# you may include this file under the same distribution terms that you use
+# for the rest of that program.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNES FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+# Please report bugs or propose patches to gary@gnu.org.
+
+
+## ------ ##
+## Usage. ##
+## ------ ##
+
+# Evaluate this file near the top of your script to gain access to
+# the functions and variables defined here:
+#
+#   . `echo "$0" | ${SED-sed} 's|[^/]*$||'`/build-aux/funclib.sh
+#
+# If you need to override any of the default environment variable
+# settings, do that before evaluating this file.
+
+
+## -------------------- ##
+## Shell normalisation. ##
+## -------------------- ##
+
+# Some shells need a little help to be as Bourne compatible as possible.
+# Before doing anything else, make sure all that help has been provided!
+
+DUALCASE=1; export DUALCASE # for MKS sh
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
   emulate sh
   NULLCMD=:
-  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
+  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
   # is contrary to our usage.  Disable this feature.
   alias -g '${1+"$@"}'='"$@"'
   setopt NO_GLOB_SUBST
 else
-  case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
+  case `(set -o) 2>/dev/null` in *posix*) set -o posix ;; esac
 fi
-BIN_SH=xpg4; export BIN_SH # for Tru64
-DUALCASE=1; export DUALCASE # for MKS sh
 
-# A function that is used when there is no print builtin or printf.
-func_fallback_echo ()
-{
-  eval 'cat <<_LTECHO_EOF
-$1
-_LTECHO_EOF'
-}
-
-# NLS nuisances: We save the old values to restore during execute mode.
-lt_user_locale=
-lt_safe_locale=
-for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
+# NLS nuisances: We save the old values in case they are required later.
+_G_user_locale=
+_G_safe_locale=
+for _G_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
 do
-  eval "if test \"\${$lt_var+set}\" = set; then
-          save_$lt_var=\$$lt_var
-          $lt_var=C
-	  export $lt_var
-	  lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
-	  lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
+  eval "if test set = \"\${$_G_var+set}\"; then
+          save_$_G_var=\$$_G_var
+          $_G_var=C
+	  export $_G_var
+	  _G_user_locale=\"$_G_var=\\\$save_\$_G_var; \$_G_user_locale\"
+	  _G_safe_locale=\"$_G_var=C; \$_G_safe_locale\"
 	fi"
 done
-LC_ALL=C
-LANGUAGE=C
-export LANGUAGE LC_ALL
 
-$lt_unset CDPATH
+# CDPATH.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
 
+# Make sure IFS has a sensible default
+sp=' '
+nl='
+'
+IFS="$sp	$nl"
+
+# There are apparently some retarded systems that use ';' as a PATH separator!
+if test "${PATH_SEPARATOR+set}" != set; then
+  PATH_SEPARATOR=:
+  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
+    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
+      PATH_SEPARATOR=';'
+  }
+fi
+
+
+
+## ------------------------- ##
+## Locate command utilities. ##
+## ------------------------- ##
+
+
+# func_executable_p FILE
+# ----------------------
+# Check that FILE is an executable regular file.
+func_executable_p ()
+{
+    test -f "$1" && test -x "$1"
+}
+
+
+# func_path_progs PROGS_LIST CHECK_FUNC [PATH]
+# --------------------------------------------
+# Search for either a program that responds to --version with output
+# containing "GNU", or else returned by CHECK_FUNC otherwise, by
+# trying all the directories in PATH with each of the elements of
+# PROGS_LIST.
+#
+# CHECK_FUNC should accept the path to a candidate program, and
+# set $func_check_prog_result if it truncates its output less than
+# $_G_path_prog_max characters.
+func_path_progs ()
+{
+    _G_progs_list=$1
+    _G_check_func=$2
+    _G_PATH=${3-"$PATH"}
+
+    _G_path_prog_max=0
+    _G_path_prog_found=false
+    _G_save_IFS=$IFS; IFS=${PATH_SEPARATOR-:}
+    for _G_dir in $_G_PATH; do
+      IFS=$_G_save_IFS
+      test -z "$_G_dir" && _G_dir=.
+      for _G_prog_name in $_G_progs_list; do
+        for _exeext in '' .EXE; do
+          _G_path_prog=$_G_dir/$_G_prog_name$_exeext
+          func_executable_p "$_G_path_prog" || continue
+          case `"$_G_path_prog" --version 2>&1` in
+            *GNU*) func_path_progs_result=$_G_path_prog _G_path_prog_found=: ;;
+            *)     $_G_check_func $_G_path_prog
+		   func_path_progs_result=$func_check_prog_result
+		   ;;
+          esac
+          $_G_path_prog_found && break 3
+        done
+      done
+    done
+    IFS=$_G_save_IFS
+    test -z "$func_path_progs_result" && {
+      echo "no acceptable sed could be found in \$PATH" >&2
+      exit 1
+    }
+}
+
+
+# We want to be able to use the functions in this file before configure
+# has figured out where the best binaries are kept, which means we have
+# to search for them ourselves - except when the results are already set
+# where we skip the searches.
+
+# Unless the user overrides by setting SED, search the path for either GNU
+# sed, or the sed that truncates its output the least.
+test -z "$SED" && {
+  _G_sed_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
+  for _G_i in 1 2 3 4 5 6 7; do
+    _G_sed_script=$_G_sed_script$nl$_G_sed_script
+  done
+  echo "$_G_sed_script" 2>/dev/null | sed 99q >conftest.sed
+  _G_sed_script=
+
+  func_check_prog_sed ()
+  {
+    _G_path_prog=$1
+
+    _G_count=0
+    printf 0123456789 >conftest.in
+    while :
+    do
+      cat conftest.in conftest.in >conftest.tmp
+      mv conftest.tmp conftest.in
+      cp conftest.in conftest.nl
+      echo '' >> conftest.nl
+      "$_G_path_prog" -f conftest.sed <conftest.nl >conftest.out 2>/dev/null || break
+      diff conftest.out conftest.nl >/dev/null 2>&1 || break
+      _G_count=`expr $_G_count + 1`
+      if test "$_G_count" -gt "$_G_path_prog_max"; then
+        # Best one so far, save it but keep looking for a better one
+        func_check_prog_result=$_G_path_prog
+        _G_path_prog_max=$_G_count
+      fi
+      # 10*(2^10) chars as input seems more than enough
+      test 10 -lt "$_G_count" && break
+    done
+    rm -f conftest.in conftest.tmp conftest.nl conftest.out
+  }
+
+  func_path_progs "sed gsed" func_check_prog_sed $PATH:/usr/xpg4/bin
+  rm -f conftest.sed
+  SED=$func_path_progs_result
+}
+
+
+# Unless the user overrides by setting GREP, search the path for either GNU
+# grep, or the grep that truncates its output the least.
+test -z "$GREP" && {
+  func_check_prog_grep ()
+  {
+    _G_path_prog=$1
+
+    _G_count=0
+    _G_path_prog_max=0
+    printf 0123456789 >conftest.in
+    while :
+    do
+      cat conftest.in conftest.in >conftest.tmp
+      mv conftest.tmp conftest.in
+      cp conftest.in conftest.nl
+      echo 'GREP' >> conftest.nl
+      "$_G_path_prog" -e 'GREP$' -e '-(cannot match)-' <conftest.nl >conftest.out 2>/dev/null || break
+      diff conftest.out conftest.nl >/dev/null 2>&1 || break
+      _G_count=`expr $_G_count + 1`
+      if test "$_G_count" -gt "$_G_path_prog_max"; then
+        # Best one so far, save it but keep looking for a better one
+        func_check_prog_result=$_G_path_prog
+        _G_path_prog_max=$_G_count
+      fi
+      # 10*(2^10) chars as input seems more than enough
+      test 10 -lt "$_G_count" && break
+    done
+    rm -f conftest.in conftest.tmp conftest.nl conftest.out
+  }
+
+  func_path_progs "grep ggrep" func_check_prog_grep $PATH:/usr/xpg4/bin
+  GREP=$func_path_progs_result
+}
+
+
+## ------------------------------- ##
+## User overridable command paths. ##
+## ------------------------------- ##
+
+# All uppercase variable names are used for environment variables.  These
+# variables can be overridden by the user before calling a script that
+# uses them if a suitable command of that name is not already available
+# in the command search PATH.
+
+: ${CP="cp -f"}
+: ${ECHO="printf %s\n"}
+: ${EGREP="$GREP -E"}
+: ${FGREP="$GREP -F"}
+: ${LN_S="ln -s"}
+: ${MAKE="make"}
+: ${MKDIR="mkdir"}
+: ${MV="mv -f"}
+: ${RM="rm -f"}
+: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
+
+
+## -------------------- ##
+## Useful sed snippets. ##
+## -------------------- ##
+
+sed_dirname='s|/[^/]*$||'
+sed_basename='s|^.*/||'
+
+# Sed substitution that helps us do robust quoting.  It backslashifies
+# metacharacters that are still active within double-quoted strings.
+sed_quote_subst='s|\([`"$\\]\)|\\\1|g'
+
+# Same as above, but do not quote variable references.
+sed_double_quote_subst='s/\(["`\\]\)/\\\1/g'
+
+# Sed substitution that turns a string into a regex matching for the
+# string literally.
+sed_make_literal_regex='s|[].[^$\\*\/]|\\&|g'
+
+# Sed substitution that converts a w32 file name or path
+# that contains forward slashes, into one that contains
+# (escaped) backslashes.  A very naive implementation.
+sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
+
+# Re-'\' parameter expansions in output of sed_double_quote_subst that
+# were '\'-ed in input to the same.  If an odd number of '\' preceded a
+# '$' in input to sed_double_quote_subst, that '$' was protected from
+# expansion.  Since each input '\' is now two '\'s, look for any number
+# of runs of four '\'s followed by two '\'s and then a '$'.  '\' that '$'.
+_G_bs='\\'
+_G_bs2='\\\\'
+_G_bs4='\\\\\\\\'
+_G_dollar='\$'
+sed_double_backslash="\
+  s/$_G_bs4/&\\
+/g
+  s/^$_G_bs2$_G_dollar/$_G_bs&/
+  s/\\([^$_G_bs]\\)$_G_bs2$_G_dollar/\\1$_G_bs2$_G_bs$_G_dollar/g
+  s/\n//g"
+
+
+## ----------------- ##
+## Global variables. ##
+## ----------------- ##
+
+# Except for the global variables explicitly listed below, the following
+# functions in the '^func_' namespace, and the '^require_' namespace
+# variables initialised in the 'Resource management' section, sourcing
+# this file will not pollute your global namespace with anything
+# else. There's no portable way to scope variables in Bourne shell
+# though, so actually running these functions will sometimes place
+# results into a variable named after the function, and often use
+# temporary variables in the '^_G_' namespace. If you are careful to
+# avoid using those namespaces casually in your sourcing script, things
+# should continue to work as you expect. And, of course, you can freely
+# overwrite any of the functions or variables defined here before
+# calling anything to customize them.
+
+EXIT_SUCCESS=0
+EXIT_FAILURE=1
+EXIT_MISMATCH=63  # $? = 63 is used to indicate version mismatch to missing.
+EXIT_SKIP=77	  # $? = 77 is used to indicate a skipped test to automake.
+
+# Allow overriding, eg assuming that you follow the convention of
+# putting '$debug_cmd' at the start of all your functions, you can get
+# bash to show function call trace with:
+#
+#    debug_cmd='eval echo "${FUNCNAME[0]} $*" >&2' bash your-script-name
+debug_cmd=${debug_cmd-":"}
+exit_cmd=:
+
+# By convention, finish your script with:
+#
+#    exit $exit_status
+#
+# so that you can set exit_status to non-zero if you want to indicate
+# something went wrong during execution without actually bailing out at
+# the point of failure.
+exit_status=$EXIT_SUCCESS
 
 # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
 # is ksh but when the shell is invoked as "sh" and the current value of
 # the _XPG environment variable is not equal to 1 (one), the special
 # positional parameter $0, within a function call, is the name of the
 # function.
-progpath="$0"
+progpath=$0
+
+# The name of this program.
+progname=`$ECHO "$progpath" |$SED "$sed_basename"`
+
+# Make sure we have an absolute progpath for reexecution:
+case $progpath in
+  [\\/]*|[A-Za-z]:\\*) ;;
+  *[\\/]*)
+     progdir=`$ECHO "$progpath" |$SED "$sed_dirname"`
+     progdir=`cd "$progdir" && pwd`
+     progpath=$progdir/$progname
+     ;;
+  *)
+     _G_IFS=$IFS
+     IFS=${PATH_SEPARATOR-:}
+     for progdir in $PATH; do
+       IFS=$_G_IFS
+       test -x "$progdir/$progname" && break
+     done
+     IFS=$_G_IFS
+     test -n "$progdir" || progdir=`pwd`
+     progpath=$progdir/$progname
+     ;;
+esac
 
 
+## ----------------- ##
+## Standard options. ##
+## ----------------- ##
 
-: ${CP="cp -f"}
-test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}
-: ${MAKE="make"}
-: ${MKDIR="mkdir"}
-: ${MV="mv -f"}
-: ${RM="rm -f"}
-: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
-: ${Xsed="$SED -e 1s/^X//"}
+# The following options affect the operation of the functions defined
+# below, and should be set appropriately depending on run-time para-
+# meters passed on the command line.
 
-# Global variables:
-EXIT_SUCCESS=0
-EXIT_FAILURE=1
-EXIT_MISMATCH=63  # $? = 63 is used to indicate version mismatch to missing.
-EXIT_SKIP=77	  # $? = 77 is used to indicate a skipped test to automake.
+opt_dry_run=false
+opt_quiet=false
+opt_verbose=false
 
-exit_status=$EXIT_SUCCESS
+# Categories 'all' and 'none' are always available.  Append any others
+# you will pass as the first argument to func_warning from your own
+# code.
+warning_categories=
 
-# Make sure IFS has a sensible default
-lt_nl='
-'
-IFS=" 	$lt_nl"
+# By default, display warnings according to 'opt_warning_types'.  Set
+# 'warning_func'  to ':' to elide all warnings, or func_fatal_error to
+# treat the next displayed warning as a fatal error.
+warning_func=func_warn_and_continue
 
-dirname="s,/[^/]*$,,"
-basename="s,^.*/,,"
+# Set to 'all' to display all warnings, 'none' to suppress all
+# warnings, or a space delimited list of some subset of
+# 'warning_categories' to display only the listed warnings.
+opt_warning_types=all
 
-# func_dirname file append nondir_replacement
+
+## -------------------- ##
+## Resource management. ##
+## -------------------- ##
+
+# This section contains definitions for functions that each ensure a
+# particular resource (a file, or a non-empty configuration variable for
+# example) is available, and if appropriate to extract default values
+# from pertinent package files. Call them using their associated
+# 'require_*' variable to ensure that they are executed, at most, once.
+#
+# It's entirely deliberate that calling these functions can set
+# variables that don't obey the namespace limitations obeyed by the rest
+# of this file, in order that that they be as useful as possible to
+# callers.
+
+
+# require_term_colors
+# -------------------
+# Allow display of bold text on terminals that support it.
+require_term_colors=func_require_term_colors
+func_require_term_colors ()
+{
+    $debug_cmd
+
+    test -t 1 && {
+      # COLORTERM and USE_ANSI_COLORS environment variables take
+      # precedence, because most terminfo databases neglect to describe
+      # whether color sequences are supported.
+      test -n "${COLORTERM+set}" && : ${USE_ANSI_COLORS="1"}
+
+      if test 1 = "$USE_ANSI_COLORS"; then
+        # Standard ANSI escape sequences
+        tc_reset=''
+        tc_bold='';   tc_standout=''
+        tc_red='';   tc_green=''
+        tc_blue='';  tc_cyan=''
+      else
+        # Otherwise trust the terminfo database after all.
+        test -n "`tput sgr0 2>/dev/null`" && {
+          tc_reset=`tput sgr0`
+          test -n "`tput bold 2>/dev/null`" && tc_bold=`tput bold`
+          tc_standout=$tc_bold
+          test -n "`tput smso 2>/dev/null`" && tc_standout=`tput smso`
+          test -n "`tput setaf 1 2>/dev/null`" && tc_red=`tput setaf 1`
+          test -n "`tput setaf 2 2>/dev/null`" && tc_green=`tput setaf 2`
+          test -n "`tput setaf 4 2>/dev/null`" && tc_blue=`tput setaf 4`
+          test -n "`tput setaf 5 2>/dev/null`" && tc_cyan=`tput setaf 5`
+        }
+      fi
+    }
+
+    require_term_colors=:
+}
+
+
+## ----------------- ##
+## Function library. ##
+## ----------------- ##
+
+# This section contains a variety of useful functions to call in your
+# scripts. Take note of the portable wrappers for features provided by
+# some modern shells, which will fall back to slower equivalents on
+# less featureful shells.
+
+
+# func_append VAR VALUE
+# ---------------------
+# Append VALUE onto the existing contents of VAR.
+
+  # We should try to minimise forks, especially on Windows where they are
+  # unreasonably slow, so skip the feature probes when bash or zsh are
+  # being used:
+  if test set = "${BASH_VERSION+set}${ZSH_VERSION+set}"; then
+    : ${_G_HAVE_ARITH_OP="yes"}
+    : ${_G_HAVE_XSI_OPS="yes"}
+    # The += operator was introduced in bash 3.1
+    case $BASH_VERSION in
+      [12].* | 3.0 | 3.0*) ;;
+      *)
+        : ${_G_HAVE_PLUSEQ_OP="yes"}
+        ;;
+    esac
+  fi
+
+  # _G_HAVE_PLUSEQ_OP
+  # Can be empty, in which case the shell is probed, "yes" if += is
+  # useable or anything else if it does not work.
+  test -z "$_G_HAVE_PLUSEQ_OP" \
+    && (eval 'x=a; x+=" b"; test "a b" = "$x"') 2>/dev/null \
+    && _G_HAVE_PLUSEQ_OP=yes
+
+if test yes = "$_G_HAVE_PLUSEQ_OP"
+then
+  # This is an XSI compatible shell, allowing a faster implementation...
+  eval 'func_append ()
+  {
+    $debug_cmd
+
+    eval "$1+=\$2"
+  }'
+else
+  # ...otherwise fall back to using expr, which is often a shell builtin.
+  func_append ()
+  {
+    $debug_cmd
+
+    eval "$1=\$$1\$2"
+  }
+fi
+
+
+# func_append_quoted VAR VALUE
+# ----------------------------
+# Quote VALUE and append to the end of shell variable VAR, separated
+# by a space.
+if test yes = "$_G_HAVE_PLUSEQ_OP"; then
+  eval 'func_append_quoted ()
+  {
+    $debug_cmd
+
+    func_quote_for_eval "$2"
+    eval "$1+=\\ \$func_quote_for_eval_result"
+  }'
+else
+  func_append_quoted ()
+  {
+    $debug_cmd
+
+    func_quote_for_eval "$2"
+    eval "$1=\$$1\\ \$func_quote_for_eval_result"
+  }
+fi
+
+
+# func_append_uniq VAR VALUE
+# --------------------------
+# Append unique VALUE onto the existing contents of VAR, assuming
+# entries are delimited by the first character of VALUE.  For example:
+#
+#   func_append_uniq options " --another-option option-argument"
+#
+# will only append to $options if " --another-option option-argument "
+# is not already present somewhere in $options already (note spaces at
+# each end implied by leading space in second argument).
+func_append_uniq ()
+{
+    $debug_cmd
+
+    eval _G_current_value='`$ECHO $'$1'`'
+    _G_delim=`expr "$2" : '\(.\)'`
+
+    case $_G_delim$_G_current_value$_G_delim in
+      *"$2$_G_delim"*) ;;
+      *) func_append "$@" ;;
+    esac
+}
+
+
+# func_arith TERM...
+# ------------------
+# Set func_arith_result to the result of evaluating TERMs.
+  test -z "$_G_HAVE_ARITH_OP" \
+    && (eval 'test 2 = $(( 1 + 1 ))') 2>/dev/null \
+    && _G_HAVE_ARITH_OP=yes
+
+if test yes = "$_G_HAVE_ARITH_OP"; then
+  eval 'func_arith ()
+  {
+    $debug_cmd
+
+    func_arith_result=$(( $* ))
+  }'
+else
+  func_arith ()
+  {
+    $debug_cmd
+
+    func_arith_result=`expr "$@"`
+  }
+fi
+
+
+# func_basename FILE
+# ------------------
+# Set func_basename_result to FILE with everything up to and including
+# the last / stripped.
+if test yes = "$_G_HAVE_XSI_OPS"; then
+  # If this shell supports suffix pattern removal, then use it to avoid
+  # forking. Hide the definitions single quotes in case the shell chokes
+  # on unsupported syntax...
+  _b='func_basename_result=${1##*/}'
+  _d='case $1 in
+        */*) func_dirname_result=${1%/*}$2 ;;
+        *  ) func_dirname_result=$3        ;;
+      esac'
+
+else
+  # ...otherwise fall back to using sed.
+  _b='func_basename_result=`$ECHO "$1" |$SED "$sed_basename"`'
+  _d='func_dirname_result=`$ECHO "$1"  |$SED "$sed_dirname"`
+      if test "X$func_dirname_result" = "X$1"; then
+        func_dirname_result=$3
+      else
+        func_append func_dirname_result "$2"
+      fi'
+fi
+
+eval 'func_basename ()
+{
+    $debug_cmd
+
+    '"$_b"'
+}'
+
+
+# func_dirname FILE APPEND NONDIR_REPLACEMENT
+# -------------------------------------------
 # Compute the dirname of FILE.  If nonempty, add APPEND to the result,
 # otherwise set result to NONDIR_REPLACEMENT.
-func_dirname ()
+eval 'func_dirname ()
 {
-    func_dirname_result=`$ECHO "${1}" | $SED "$dirname"`
-    if test "X$func_dirname_result" = "X${1}"; then
-      func_dirname_result="${3}"
-    else
-      func_dirname_result="$func_dirname_result${2}"
-    fi
-} # func_dirname may be replaced by extended shell implementation
+    $debug_cmd
+
+    '"$_d"'
+}'
 
 
-# func_basename file
-func_basename ()
-{
-    func_basename_result=`$ECHO "${1}" | $SED "$basename"`
-} # func_basename may be replaced by extended shell implementation
-
-
-# func_dirname_and_basename file append nondir_replacement
-# perform func_basename and func_dirname in a single function
+# func_dirname_and_basename FILE APPEND NONDIR_REPLACEMENT
+# --------------------------------------------------------
+# Perform func_basename and func_dirname in a single function
 # call:
 #   dirname:  Compute the dirname of FILE.  If nonempty,
 #             add APPEND to the result, otherwise set result
 #             to NONDIR_REPLACEMENT.
 #             value returned in "$func_dirname_result"
 #   basename: Compute filename of FILE.
-#             value returned in "$func_basename_result"
-# Implementation must be kept synchronized with func_dirname
-# and func_basename. For efficiency, we do not delegate to
-# those functions but instead duplicate the functionality here.
-func_dirname_and_basename ()
+#             value retuned in "$func_basename_result"
+# For efficiency, we do not delegate to the functions above but instead
+# duplicate the functionality here.
+eval 'func_dirname_and_basename ()
 {
-    # Extract subdirectory from the argument.
-    func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
-    if test "X$func_dirname_result" = "X${1}"; then
-      func_dirname_result="${3}"
-    else
-      func_dirname_result="$func_dirname_result${2}"
+    $debug_cmd
+
+    '"$_b"'
+    '"$_d"'
+}'
+
+
+# func_echo ARG...
+# ----------------
+# Echo program name prefixed message.
+func_echo ()
+{
+    $debug_cmd
+
+    _G_message=$*
+
+    func_echo_IFS=$IFS
+    IFS=$nl
+    for _G_line in $_G_message; do
+      IFS=$func_echo_IFS
+      $ECHO "$progname: $_G_line"
+    done
+    IFS=$func_echo_IFS
+}
+
+
+# func_echo_all ARG...
+# --------------------
+# Invoke $ECHO with all args, space-separated.
+func_echo_all ()
+{
+    $ECHO "$*"
+}
+
+
+# func_echo_infix_1 INFIX ARG...
+# ------------------------------
+# Echo program name, followed by INFIX on the first line, with any
+# additional lines not showing INFIX.
+func_echo_infix_1 ()
+{
+    $debug_cmd
+
+    $require_term_colors
+
+    _G_infix=$1; shift
+    _G_indent=$_G_infix
+    _G_prefix="$progname: $_G_infix: "
+    _G_message=$*
+
+    # Strip color escape sequences before counting printable length
+    for _G_tc in "$tc_reset" "$tc_bold" "$tc_standout" "$tc_red" "$tc_green" "$tc_blue" "$tc_cyan"
+    do
+      test -n "$_G_tc" && {
+        _G_esc_tc=`$ECHO "$_G_tc" | $SED "$sed_make_literal_regex"`
+        _G_indent=`$ECHO "$_G_indent" | $SED "s|$_G_esc_tc||g"`
+      }
+    done
+    _G_indent="$progname: "`echo "$_G_indent" | $SED 's|.| |g'`"  " ## exclude from sc_prohibit_nested_quotes
+
+    func_echo_infix_1_IFS=$IFS
+    IFS=$nl
+    for _G_line in $_G_message; do
+      IFS=$func_echo_infix_1_IFS
+      $ECHO "$_G_prefix$tc_bold$_G_line$tc_reset" >&2
+      _G_prefix=$_G_indent
+    done
+    IFS=$func_echo_infix_1_IFS
+}
+
+
+# func_error ARG...
+# -----------------
+# Echo program name prefixed message to standard error.
+func_error ()
+{
+    $debug_cmd
+
+    $require_term_colors
+
+    func_echo_infix_1 "  $tc_standout${tc_red}error$tc_reset" "$*" >&2
+}
+
+
+# func_fatal_error ARG...
+# -----------------------
+# Echo program name prefixed message to standard error, and exit.
+func_fatal_error ()
+{
+    $debug_cmd
+
+    func_error "$*"
+    exit $EXIT_FAILURE
+}
+
+
+# func_grep EXPRESSION FILENAME
+# -----------------------------
+# Check whether EXPRESSION matches any line of FILENAME, without output.
+func_grep ()
+{
+    $debug_cmd
+
+    $GREP "$1" "$2" >/dev/null 2>&1
+}
+
+
+# func_len STRING
+# ---------------
+# Set func_len_result to the length of STRING. STRING may not
+# start with a hyphen.
+  test -z "$_G_HAVE_XSI_OPS" \
+    && (eval 'x=a/b/c;
+      test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \
+    && _G_HAVE_XSI_OPS=yes
+
+if test yes = "$_G_HAVE_XSI_OPS"; then
+  eval 'func_len ()
+  {
+    $debug_cmd
+
+    func_len_result=${#1}
+  }'
+else
+  func_len ()
+  {
+    $debug_cmd
+
+    func_len_result=`expr "$1" : ".*" 2>/dev/null || echo $max_cmd_len`
+  }
+fi
+
+
+# func_mkdir_p DIRECTORY-PATH
+# ---------------------------
+# Make sure the entire path to DIRECTORY-PATH is available.
+func_mkdir_p ()
+{
+    $debug_cmd
+
+    _G_directory_path=$1
+    _G_dir_list=
+
+    if test -n "$_G_directory_path" && test : != "$opt_dry_run"; then
+
+      # Protect directory names starting with '-'
+      case $_G_directory_path in
+        -*) _G_directory_path=./$_G_directory_path ;;
+      esac
+
+      # While some portion of DIR does not yet exist...
+      while test ! -d "$_G_directory_path"; do
+        # ...make a list in topmost first order.  Use a colon delimited
+	# list incase some portion of path contains whitespace.
+        _G_dir_list=$_G_directory_path:$_G_dir_list
+
+        # If the last portion added has no slash in it, the list is done
+        case $_G_directory_path in */*) ;; *) break ;; esac
+
+        # ...otherwise throw away the child directory and loop
+        _G_directory_path=`$ECHO "$_G_directory_path" | $SED -e "$sed_dirname"`
+      done
+      _G_dir_list=`$ECHO "$_G_dir_list" | $SED 's|:*$||'`
+
+      func_mkdir_p_IFS=$IFS; IFS=:
+      for _G_dir in $_G_dir_list; do
+	IFS=$func_mkdir_p_IFS
+        # mkdir can fail with a 'File exist' error if two processes
+        # try to create one of the directories concurrently.  Don't
+        # stop in that case!
+        $MKDIR "$_G_dir" 2>/dev/null || :
+      done
+      IFS=$func_mkdir_p_IFS
+
+      # Bail out if we (or some other process) failed to create a directory.
+      test -d "$_G_directory_path" || \
+        func_fatal_error "Failed to create '$1'"
     fi
-    func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
-} # func_dirname_and_basename may be replaced by extended shell implementation
+}
 
 
-# func_stripname prefix suffix name
-# strip PREFIX and SUFFIX off of NAME.
-# PREFIX and SUFFIX must not contain globbing or regex special
-# characters, hashes, percent signs, but SUFFIX may contain a leading
-# dot (in which case that matches only a dot).
-# func_strip_suffix prefix name
-func_stripname ()
+# func_mktempdir [BASENAME]
+# -------------------------
+# Make a temporary directory that won't clash with other running
+# libtool processes, and avoids race conditions if possible.  If
+# given, BASENAME is the basename for that directory.
+func_mktempdir ()
 {
-    case ${2} in
-      .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
-      *)  func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
-    esac
-} # func_stripname may be replaced by extended shell implementation
+    $debug_cmd
 
+    _G_template=${TMPDIR-/tmp}/${1-$progname}
+
+    if test : = "$opt_dry_run"; then
+      # Return a directory name, but don't create it in dry-run mode
+      _G_tmpdir=$_G_template-$$
+    else
+
+      # If mktemp works, use that first and foremost
+      _G_tmpdir=`mktemp -d "$_G_template-XXXXXXXX" 2>/dev/null`
+
+      if test ! -d "$_G_tmpdir"; then
+        # Failing that, at least try and use $RANDOM to avoid a race
+        _G_tmpdir=$_G_template-${RANDOM-0}$$
+
+        func_mktempdir_umask=`umask`
+        umask 0077
+        $MKDIR "$_G_tmpdir"
+        umask $func_mktempdir_umask
+      fi
+
+      # If we're not in dry-run mode, bomb out on failure
+      test -d "$_G_tmpdir" || \
+        func_fatal_error "cannot create temporary directory '$_G_tmpdir'"
+    fi
+
+    $ECHO "$_G_tmpdir"
+}
 
-# These SED scripts presuppose an absolute path with a trailing slash.
-pathcar='s,^/\([^/]*\).*$,\1,'
-pathcdr='s,^/[^/]*,,'
-removedotparts=':dotsl
-		s@/\./@/@g
-		t dotsl
-		s,/\.$,/,'
-collapseslashes='s@/\{1,\}@/@g'
-finalslash='s,/*$,/,'
 
 # func_normal_abspath PATH
+# ------------------------
 # Remove doubled-up and trailing slashes, "." path components,
 # and cancel out any ".." path components in PATH after making
 # it an absolute path.
-#             value returned in "$func_normal_abspath_result"
 func_normal_abspath ()
 {
-  # Start from root dir and reassemble the path.
-  func_normal_abspath_result=
-  func_normal_abspath_tpath=$1
-  func_normal_abspath_altnamespace=
-  case $func_normal_abspath_tpath in
-    "")
-      # Empty path, that just means $cwd.
-      func_stripname '' '/' "`pwd`"
-      func_normal_abspath_result=$func_stripname_result
-      return
-    ;;
-    # The next three entries are used to spot a run of precisely
-    # two leading slashes without using negated character classes;
-    # we take advantage of case's first-match behaviour.
-    ///*)
-      # Unusual form of absolute path, do nothing.
-    ;;
-    //*)
-      # Not necessarily an ordinary path; POSIX reserves leading '//'
-      # and for example Cygwin uses it to access remote file shares
-      # over CIFS/SMB, so we conserve a leading double slash if found.
-      func_normal_abspath_altnamespace=/
-    ;;
-    /*)
-      # Absolute path, do nothing.
-    ;;
-    *)
-      # Relative path, prepend $cwd.
-      func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
-    ;;
-  esac
-  # Cancel out all the simple stuff to save iterations.  We also want
-  # the path to end with a slash for ease of parsing, so make sure
-  # there is one (and only one) here.
-  func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
-        -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
-  while :; do
-    # Processed it all yet?
-    if test "$func_normal_abspath_tpath" = / ; then
-      # If we ascended to the root using ".." the result may be empty now.
-      if test -z "$func_normal_abspath_result" ; then
-        func_normal_abspath_result=/
-      fi
-      break
-    fi
-    func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
-        -e "$pathcar"`
-    func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
-        -e "$pathcdr"`
-    # Figure out what to do with it
-    case $func_normal_abspath_tcomponent in
+    $debug_cmd
+
+    # These SED scripts presuppose an absolute path with a trailing slash.
+    _G_pathcar='s|^/\([^/]*\).*$|\1|'
+    _G_pathcdr='s|^/[^/]*||'
+    _G_removedotparts=':dotsl
+		s|/\./|/|g
+		t dotsl
+		s|/\.$|/|'
+    _G_collapseslashes='s|/\{1,\}|/|g'
+    _G_finalslash='s|/*$|/|'
+
+    # Start from root dir and reassemble the path.
+    func_normal_abspath_result=
+    func_normal_abspath_tpath=$1
+    func_normal_abspath_altnamespace=
+    case $func_normal_abspath_tpath in
       "")
-        # Trailing empty path component, ignore it.
-      ;;
-      ..)
-        # Parent dir; strip last assembled component from result.
-        func_dirname "$func_normal_abspath_result"
-        func_normal_abspath_result=$func_dirname_result
-      ;;
-      *)
-        # Actual path component, append it.
-        func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
-      ;;
-    esac
-  done
-  # Restore leading double-slash if one was found on entry.
-  func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
-}
-
-# func_relative_path SRCDIR DSTDIR
-# generates a relative path from SRCDIR to DSTDIR, with a trailing
-# slash if non-empty, suitable for immediately appending a filename
-# without needing to append a separator.
-#             value returned in "$func_relative_path_result"
-func_relative_path ()
-{
-  func_relative_path_result=
-  func_normal_abspath "$1"
-  func_relative_path_tlibdir=$func_normal_abspath_result
-  func_normal_abspath "$2"
-  func_relative_path_tbindir=$func_normal_abspath_result
-
-  # Ascend the tree starting from libdir
-  while :; do
-    # check if we have found a prefix of bindir
-    case $func_relative_path_tbindir in
-      $func_relative_path_tlibdir)
-        # found an exact match
-        func_relative_path_tcancelled=
-        break
+        # Empty path, that just means $cwd.
+        func_stripname '' '/' "`pwd`"
+        func_normal_abspath_result=$func_stripname_result
+        return
         ;;
-      $func_relative_path_tlibdir*)
-        # found a matching prefix
-        func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
-        func_relative_path_tcancelled=$func_stripname_result
-        if test -z "$func_relative_path_result"; then
-          func_relative_path_result=.
-        fi
-        break
+      # The next three entries are used to spot a run of precisely
+      # two leading slashes without using negated character classes;
+      # we take advantage of case's first-match behaviour.
+      ///*)
+        # Unusual form of absolute path, do nothing.
+        ;;
+      //*)
+        # Not necessarily an ordinary path; POSIX reserves leading '//'
+        # and for example Cygwin uses it to access remote file shares
+        # over CIFS/SMB, so we conserve a leading double slash if found.
+        func_normal_abspath_altnamespace=/
+        ;;
+      /*)
+        # Absolute path, do nothing.
         ;;
       *)
-        func_dirname $func_relative_path_tlibdir
-        func_relative_path_tlibdir=${func_dirname_result}
-        if test "x$func_relative_path_tlibdir" = x ; then
-          # Have to descend all the way to the root!
-          func_relative_path_result=../$func_relative_path_result
-          func_relative_path_tcancelled=$func_relative_path_tbindir
-          break
-        fi
-        func_relative_path_result=../$func_relative_path_result
+        # Relative path, prepend $cwd.
+        func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
         ;;
     esac
-  done
 
-  # Now calculate path; take care to avoid doubling-up slashes.
-  func_stripname '' '/' "$func_relative_path_result"
-  func_relative_path_result=$func_stripname_result
-  func_stripname '/' '/' "$func_relative_path_tcancelled"
-  if test "x$func_stripname_result" != x ; then
-    func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
-  fi
-
-  # Normalisation. If bindir is libdir, return empty string,
-  # else relative path ending with a slash; either way, target
-  # file name can be directly appended.
-  if test ! -z "$func_relative_path_result"; then
-    func_stripname './' '' "$func_relative_path_result/"
-    func_relative_path_result=$func_stripname_result
-  fi
+    # Cancel out all the simple stuff to save iterations.  We also want
+    # the path to end with a slash for ease of parsing, so make sure
+    # there is one (and only one) here.
+    func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
+          -e "$_G_removedotparts" -e "$_G_collapseslashes" -e "$_G_finalslash"`
+    while :; do
+      # Processed it all yet?
+      if test / = "$func_normal_abspath_tpath"; then
+        # If we ascended to the root using ".." the result may be empty now.
+        if test -z "$func_normal_abspath_result"; then
+          func_normal_abspath_result=/
+        fi
+        break
+      fi
+      func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
+          -e "$_G_pathcar"`
+      func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
+          -e "$_G_pathcdr"`
+      # Figure out what to do with it
+      case $func_normal_abspath_tcomponent in
+        "")
+          # Trailing empty path component, ignore it.
+          ;;
+        ..)
+          # Parent dir; strip last assembled component from result.
+          func_dirname "$func_normal_abspath_result"
+          func_normal_abspath_result=$func_dirname_result
+          ;;
+        *)
+          # Actual path component, append it.
+          func_append func_normal_abspath_result "/$func_normal_abspath_tcomponent"
+          ;;
+      esac
+    done
+    # Restore leading double-slash if one was found on entry.
+    func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
 }
 
-# The name of this program:
-func_dirname_and_basename "$progpath"
-progname=$func_basename_result
 
-# Make sure we have an absolute path for reexecution:
-case $progpath in
-  [\\/]*|[A-Za-z]:\\*) ;;
-  *[\\/]*)
-     progdir=$func_dirname_result
-     progdir=`cd "$progdir" && pwd`
-     progpath="$progdir/$progname"
-     ;;
-  *)
-     save_IFS="$IFS"
-     IFS=${PATH_SEPARATOR-:}
-     for progdir in $PATH; do
-       IFS="$save_IFS"
-       test -x "$progdir/$progname" && break
-     done
-     IFS="$save_IFS"
-     test -n "$progdir" || progdir=`pwd`
-     progpath="$progdir/$progname"
-     ;;
-esac
-
-# Sed substitution that helps us do robust quoting.  It backslashifies
-# metacharacters that are still active within double-quoted strings.
-Xsed="${SED}"' -e 1s/^X//'
-sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
-
-# Same as above, but do not quote variable references.
-double_quote_subst='s/\(["`\\]\)/\\\1/g'
-
-# Sed substitution that turns a string into a regex matching for the
-# string literally.
-sed_make_literal_regex='s,[].[^$\\*\/],\\&,g'
-
-# Sed substitution that converts a w32 file name or path
-# which contains forward slashes, into one that contains
-# (escaped) backslashes.  A very naive implementation.
-lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
-
-# Re-`\' parameter expansions in output of double_quote_subst that were
-# `\'-ed in input to the same.  If an odd number of `\' preceded a '$'
-# in input to double_quote_subst, that '$' was protected from expansion.
-# Since each input `\' is now two `\'s, look for any number of runs of
-# four `\'s followed by two `\'s and then a '$'.  `\' that '$'.
-bs='\\'
-bs2='\\\\'
-bs4='\\\\\\\\'
-dollar='\$'
-sed_double_backslash="\
-  s/$bs4/&\\
-/g
-  s/^$bs2$dollar/$bs&/
-  s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
-  s/\n//g"
-
-# Standard options:
-opt_dry_run=false
-opt_help=false
-opt_quiet=false
-opt_verbose=false
-opt_warning=:
-
-# func_echo arg...
-# Echo program name prefixed message, along with the current mode
-# name if it has been set yet.
-func_echo ()
+# func_notquiet ARG...
+# --------------------
+# Echo program name prefixed message only when not in quiet mode.
+func_notquiet ()
 {
-    $ECHO "$progname: ${opt_mode+$opt_mode: }$*"
-}
+    $debug_cmd
 
-# func_verbose arg...
-# Echo program name prefixed message in verbose mode only.
-func_verbose ()
-{
-    $opt_verbose && func_echo ${1+"$@"}
+    $opt_quiet || func_echo ${1+"$@"}
 
     # A bug in bash halts the script if the last line of a function
     # fails when set -e is in force, so we need another command to
@@ -454,450 +1025,1113 @@ func_verbose ()
     :
 }
 
-# func_echo_all arg...
-# Invoke $ECHO with all args, space-separated.
-func_echo_all ()
-{
-    $ECHO "$*"
-}
 
-# func_error arg...
-# Echo program name prefixed message to standard error.
-func_error ()
+# func_relative_path SRCDIR DSTDIR
+# --------------------------------
+# Set func_relative_path_result to the relative path from SRCDIR to DSTDIR.
+func_relative_path ()
 {
-    $ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2
-}
+    $debug_cmd
 
-# func_warning arg...
-# Echo program name prefixed warning message to standard error.
-func_warning ()
-{
-    $opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2
+    func_relative_path_result=
+    func_normal_abspath "$1"
+    func_relative_path_tlibdir=$func_normal_abspath_result
+    func_normal_abspath "$2"
+    func_relative_path_tbindir=$func_normal_abspath_result
+
+    # Ascend the tree starting from libdir
+    while :; do
+      # check if we have found a prefix of bindir
+      case $func_relative_path_tbindir in
+        $func_relative_path_tlibdir)
+          # found an exact match
+          func_relative_path_tcancelled=
+          break
+          ;;
+        $func_relative_path_tlibdir*)
+          # found a matching prefix
+          func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
+          func_relative_path_tcancelled=$func_stripname_result
+          if test -z "$func_relative_path_result"; then
+            func_relative_path_result=.
+          fi
+          break
+          ;;
+        *)
+          func_dirname $func_relative_path_tlibdir
+          func_relative_path_tlibdir=$func_dirname_result
+          if test -z "$func_relative_path_tlibdir"; then
+            # Have to descend all the way to the root!
+            func_relative_path_result=../$func_relative_path_result
+            func_relative_path_tcancelled=$func_relative_path_tbindir
+            break
+          fi
+          func_relative_path_result=../$func_relative_path_result
+          ;;
+      esac
+    done
+
+    # Now calculate path; take care to avoid doubling-up slashes.
+    func_stripname '' '/' "$func_relative_path_result"
+    func_relative_path_result=$func_stripname_result
+    func_stripname '/' '/' "$func_relative_path_tcancelled"
+    if test -n "$func_stripname_result"; then
+      func_append func_relative_path_result "/$func_stripname_result"
+    fi
+
+    # Normalisation. If bindir is libdir, return '.' else relative path.
+    if test -n "$func_relative_path_result"; then
+      func_stripname './' '' "$func_relative_path_result"
+      func_relative_path_result=$func_stripname_result
+    fi
+
+    test -n "$func_relative_path_result" || func_relative_path_result=.
 
-    # bash bug again:
     :
 }
 
-# func_fatal_error arg...
-# Echo program name prefixed message to standard error, and exit.
-func_fatal_error ()
-{
-    func_error ${1+"$@"}
-    exit $EXIT_FAILURE
-}
 
-# func_fatal_help arg...
-# Echo program name prefixed message to standard error, followed by
-# a help hint, and exit.
-func_fatal_help ()
-{
-    func_error ${1+"$@"}
-    func_fatal_error "$help"
-}
-help="Try \`$progname --help' for more information."  ## default
-
-
-# func_grep expression filename
-# Check whether EXPRESSION matches any line of FILENAME, without output.
-func_grep ()
-{
-    $GREP "$1" "$2" >/dev/null 2>&1
-}
-
-
-# func_mkdir_p directory-path
-# Make sure the entire path to DIRECTORY-PATH is available.
-func_mkdir_p ()
-{
-    my_directory_path="$1"
-    my_dir_list=
-
-    if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
-
-      # Protect directory names starting with `-'
-      case $my_directory_path in
-        -*) my_directory_path="./$my_directory_path" ;;
-      esac
-
-      # While some portion of DIR does not yet exist...
-      while test ! -d "$my_directory_path"; do
-        # ...make a list in topmost first order.  Use a colon delimited
-	# list incase some portion of path contains whitespace.
-        my_dir_list="$my_directory_path:$my_dir_list"
-
-        # If the last portion added has no slash in it, the list is done
-        case $my_directory_path in */*) ;; *) break ;; esac
-
-        # ...otherwise throw away the child directory and loop
-        my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
-      done
-      my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
-
-      save_mkdir_p_IFS="$IFS"; IFS=':'
-      for my_dir in $my_dir_list; do
-	IFS="$save_mkdir_p_IFS"
-        # mkdir can fail with a `File exist' error if two processes
-        # try to create one of the directories concurrently.  Don't
-        # stop in that case!
-        $MKDIR "$my_dir" 2>/dev/null || :
-      done
-      IFS="$save_mkdir_p_IFS"
-
-      # Bail out if we (or some other process) failed to create a directory.
-      test -d "$my_directory_path" || \
-        func_fatal_error "Failed to create \`$1'"
-    fi
-}
-
-
-# func_mktempdir [string]
-# Make a temporary directory that won't clash with other running
-# libtool processes, and avoids race conditions if possible.  If
-# given, STRING is the basename for that directory.
-func_mktempdir ()
-{
-    my_template="${TMPDIR-/tmp}/${1-$progname}"
-
-    if test "$opt_dry_run" = ":"; then
-      # Return a directory name, but don't create it in dry-run mode
-      my_tmpdir="${my_template}-$$"
-    else
-
-      # If mktemp works, use that first and foremost
-      my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
-
-      if test ! -d "$my_tmpdir"; then
-        # Failing that, at least try and use $RANDOM to avoid a race
-        my_tmpdir="${my_template}-${RANDOM-0}$$"
-
-        save_mktempdir_umask=`umask`
-        umask 0077
-        $MKDIR "$my_tmpdir"
-        umask $save_mktempdir_umask
-      fi
-
-      # If we're not in dry-run mode, bomb out on failure
-      test -d "$my_tmpdir" || \
-        func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
-    fi
-
-    $ECHO "$my_tmpdir"
-}
-
-
-# func_quote_for_eval arg
-# Aesthetically quote ARG to be evaled later.
-# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
-# is double-quoted, suitable for a subsequent eval, whereas
-# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
-# which are still active within double quotes backslashified.
+# func_quote_for_eval ARG...
+# --------------------------
+# Aesthetically quote ARGs to be evaled later.
+# This function returns two values:
+#   i) func_quote_for_eval_result
+#      double-quoted, suitable for a subsequent eval
+#  ii) func_quote_for_eval_unquoted_result
+#      has all characters that are still active within double
+#      quotes backslashified.
 func_quote_for_eval ()
 {
-    case $1 in
-      *[\\\`\"\$]*)
-	func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
-      *)
-        func_quote_for_eval_unquoted_result="$1" ;;
-    esac
+    $debug_cmd
 
-    case $func_quote_for_eval_unquoted_result in
-      # Double-quote args containing shell metacharacters to delay
-      # word splitting, command substitution and and variable
-      # expansion for a subsequent eval.
-      # Many Bourne shells cannot handle close brackets correctly
-      # in scan sets, so we specify it separately.
-      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
-        func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
-        ;;
-      *)
-        func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
-    esac
+    func_quote_for_eval_unquoted_result=
+    func_quote_for_eval_result=
+    while test 0 -lt $#; do
+      case $1 in
+        *[\\\`\"\$]*)
+	  _G_unquoted_arg=`printf '%s\n' "$1" |$SED "$sed_quote_subst"` ;;
+        *)
+          _G_unquoted_arg=$1 ;;
+      esac
+      if test -n "$func_quote_for_eval_unquoted_result"; then
+	func_append func_quote_for_eval_unquoted_result " $_G_unquoted_arg"
+      else
+        func_append func_quote_for_eval_unquoted_result "$_G_unquoted_arg"
+      fi
+
+      case $_G_unquoted_arg in
+        # Double-quote args containing shell metacharacters to delay
+        # word splitting, command substitution and variable expansion
+        # for a subsequent eval.
+        # Many Bourne shells cannot handle close brackets correctly
+        # in scan sets, so we specify it separately.
+        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+          _G_quoted_arg=\"$_G_unquoted_arg\"
+          ;;
+        *)
+          _G_quoted_arg=$_G_unquoted_arg
+	  ;;
+      esac
+
+      if test -n "$func_quote_for_eval_result"; then
+	func_append func_quote_for_eval_result " $_G_quoted_arg"
+      else
+        func_append func_quote_for_eval_result "$_G_quoted_arg"
+      fi
+      shift
+    done
 }
 
 
-# func_quote_for_expand arg
+# func_quote_for_expand ARG
+# -------------------------
 # Aesthetically quote ARG to be evaled later; same as above,
 # but do not quote variable references.
 func_quote_for_expand ()
 {
+    $debug_cmd
+
     case $1 in
       *[\\\`\"]*)
-	my_arg=`$ECHO "$1" | $SED \
-	    -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
+	_G_arg=`$ECHO "$1" | $SED \
+	    -e "$sed_double_quote_subst" -e "$sed_double_backslash"` ;;
       *)
-        my_arg="$1" ;;
+        _G_arg=$1 ;;
     esac
 
-    case $my_arg in
+    case $_G_arg in
       # Double-quote args containing shell metacharacters to delay
       # word splitting and command substitution for a subsequent eval.
       # Many Bourne shells cannot handle close brackets correctly
       # in scan sets, so we specify it separately.
       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
-        my_arg="\"$my_arg\""
+        _G_arg=\"$_G_arg\"
         ;;
     esac
 
-    func_quote_for_expand_result="$my_arg"
+    func_quote_for_expand_result=$_G_arg
 }
 
 
-# func_show_eval cmd [fail_exp]
-# Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
+# func_stripname PREFIX SUFFIX NAME
+# ---------------------------------
+# strip PREFIX and SUFFIX from NAME, and store in func_stripname_result.
+# PREFIX and SUFFIX must not contain globbing or regex special
+# characters, hashes, percent signs, but SUFFIX may contain a leading
+# dot (in which case that matches only a dot).
+if test yes = "$_G_HAVE_XSI_OPS"; then
+  eval 'func_stripname ()
+  {
+    $debug_cmd
+
+    # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are
+    # positional parameters, so assign one to ordinary variable first.
+    func_stripname_result=$3
+    func_stripname_result=${func_stripname_result#"$1"}
+    func_stripname_result=${func_stripname_result%"$2"}
+  }'
+else
+  func_stripname ()
+  {
+    $debug_cmd
+
+    case $2 in
+      .*) func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%\\\\$2\$%%"`;;
+      *)  func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%$2\$%%"`;;
+    esac
+  }
+fi
+
+
+# func_show_eval CMD [FAIL_EXP]
+# -----------------------------
+# Unless opt_quiet is true, then output CMD.  Then, if opt_dryrun is
 # not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
 # is given, then evaluate it.
 func_show_eval ()
 {
-    my_cmd="$1"
-    my_fail_exp="${2-:}"
+    $debug_cmd
 
-    ${opt_silent-false} || {
-      func_quote_for_expand "$my_cmd"
-      eval "func_echo $func_quote_for_expand_result"
-    }
+    _G_cmd=$1
+    _G_fail_exp=${2-':'}
 
-    if ${opt_dry_run-false}; then :; else
-      eval "$my_cmd"
-      my_status=$?
-      if test "$my_status" -eq 0; then :; else
-	eval "(exit $my_status); $my_fail_exp"
+    func_quote_for_expand "$_G_cmd"
+    eval "func_notquiet $func_quote_for_expand_result"
+
+    $opt_dry_run || {
+      eval "$_G_cmd"
+      _G_status=$?
+      if test 0 -ne "$_G_status"; then
+	eval "(exit $_G_status); $_G_fail_exp"
       fi
-    fi
+    }
 }
 
 
-# func_show_eval_locale cmd [fail_exp]
-# Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
+# func_show_eval_locale CMD [FAIL_EXP]
+# ------------------------------------
+# Unless opt_quiet is true, then output CMD.  Then, if opt_dryrun is
 # not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
 # is given, then evaluate it.  Use the saved locale for evaluation.
 func_show_eval_locale ()
 {
-    my_cmd="$1"
-    my_fail_exp="${2-:}"
+    $debug_cmd
 
-    ${opt_silent-false} || {
-      func_quote_for_expand "$my_cmd"
+    _G_cmd=$1
+    _G_fail_exp=${2-':'}
+
+    $opt_quiet || {
+      func_quote_for_expand "$_G_cmd"
       eval "func_echo $func_quote_for_expand_result"
     }
 
-    if ${opt_dry_run-false}; then :; else
-      eval "$lt_user_locale
-	    $my_cmd"
-      my_status=$?
-      eval "$lt_safe_locale"
-      if test "$my_status" -eq 0; then :; else
-	eval "(exit $my_status); $my_fail_exp"
+    $opt_dry_run || {
+      eval "$_G_user_locale
+	    $_G_cmd"
+      _G_status=$?
+      eval "$_G_safe_locale"
+      if test 0 -ne "$_G_status"; then
+	eval "(exit $_G_status); $_G_fail_exp"
       fi
-    fi
+    }
 }
 
+
 # func_tr_sh
+# ----------
 # Turn $1 into a string suitable for a shell variable name.
 # Result is stored in $func_tr_sh_result.  All characters
 # not in the set a-zA-Z0-9_ are replaced with '_'. Further,
 # if $1 begins with a digit, a '_' is prepended as well.
 func_tr_sh ()
 {
-  case $1 in
-  [0-9]* | *[!a-zA-Z0-9_]*)
-    func_tr_sh_result=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'`
-    ;;
-  * )
-    func_tr_sh_result=$1
-    ;;
-  esac
+    $debug_cmd
+
+    case $1 in
+    [0-9]* | *[!a-zA-Z0-9_]*)
+      func_tr_sh_result=`$ECHO "$1" | $SED -e 's/^\([0-9]\)/_\1/' -e 's/[^a-zA-Z0-9_]/_/g'`
+      ;;
+    * )
+      func_tr_sh_result=$1
+      ;;
+    esac
 }
 
 
-# func_version
-# Echo version message to standard output and exit.
-func_version ()
+# func_verbose ARG...
+# -------------------
+# Echo program name prefixed message in verbose mode only.
+func_verbose ()
 {
-    $opt_debug
+    $debug_cmd
 
-    $SED -n '/(C)/!b go
-	:more
-	/\./!{
-	  N
-	  s/\n# / /
-	  b more
-	}
-	:go
-	/^# '$PROGRAM' (GNU /,/# warranty; / {
-        s/^# //
-	s/^# *$//
-        s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
-        p
-     }' < "$progpath"
-     exit $?
+    $opt_verbose && func_echo "$*"
+
+    :
 }
 
-# func_usage
-# Echo short help message to standard output and exit.
-func_usage ()
+
+# func_warn_and_continue ARG...
+# -----------------------------
+# Echo program name prefixed warning message to standard error.
+func_warn_and_continue ()
 {
-    $opt_debug
+    $debug_cmd
 
-    $SED -n '/^# Usage:/,/^#  *.*--help/ {
-        s/^# //
-	s/^# *$//
-	s/\$progname/'$progname'/
-	p
-    }' < "$progpath"
-    echo
-    $ECHO "run \`$progname --help | more' for full usage"
-    exit $?
+    $require_term_colors
+
+    func_echo_infix_1 "${tc_red}warning$tc_reset" "$*" >&2
 }
 
-# func_help [NOEXIT]
-# Echo long help message to standard output and exit,
-# unless 'noexit' is passed as argument.
+
+# func_warning CATEGORY ARG...
+# ----------------------------
+# Echo program name prefixed warning message to standard error. Warning
+# messages can be filtered according to CATEGORY, where this function
+# elides messages where CATEGORY is not listed in the global variable
+# 'opt_warning_types'.
+func_warning ()
+{
+    $debug_cmd
+
+    # CATEGORY must be in the warning_categories list!
+    case " $warning_categories " in
+      *" $1 "*) ;;
+      *) func_internal_error "invalid warning category '$1'" ;;
+    esac
+
+    _G_category=$1
+    shift
+
+    case " $opt_warning_types " in
+      *" $_G_category "*) $warning_func ${1+"$@"} ;;
+    esac
+}
+
+
+# func_sort_ver VER1 VER2
+# -----------------------
+# 'sort -V' is not generally available.
+# Note this deviates from the version comparison in automake
+# in that it treats 1.5 < 1.5.0, and treats 1.4.4a < 1.4-p3a
+# but this should suffice as we won't be specifying old
+# version formats or redundant trailing .0 in bootstrap.conf.
+# If we did want full compatibility then we should probably
+# use m4_version_compare from autoconf.
+func_sort_ver ()
+{
+    $debug_cmd
+
+    printf '%s\n%s\n' "$1" "$2" \
+      | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n -k 5,5n -k 6,6n -k 7,7n -k 8,8n -k 9,9n
+}
+
+# func_lt_ver PREV CURR
+# ---------------------
+# Return true if PREV and CURR are in the correct order according to
+# func_sort_ver, otherwise false.  Use it like this:
+#
+#  func_lt_ver "$prev_ver" "$proposed_ver" || func_fatal_error "..."
+func_lt_ver ()
+{
+    $debug_cmd
+
+    test "x$1" = x`func_sort_ver "$1" "$2" | $SED 1q`
+}
+
+
+# Local variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'before-save-hook 'time-stamp)
+# time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC"
+# time-stamp-time-zone: "UTC"
+# End:
+#! /bin/sh
+
+# Set a version string for this script.
+scriptversion=2014-01-07.03; # UTC
+
+# A portable, pluggable option parser for Bourne shell.
+# Written by Gary V. Vaughan, 2010
+
+# Copyright (C) 2010-2015 Free Software Foundation, Inc.
+# This is free software; see the source for copying conditions.  There is NO
+# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# Please report bugs or propose patches to gary@gnu.org.
+
+
+## ------ ##
+## Usage. ##
+## ------ ##
+
+# This file is a library for parsing options in your shell scripts along
+# with assorted other useful supporting features that you can make use
+# of too.
+#
+# For the simplest scripts you might need only:
+#
+#   #!/bin/sh
+#   . relative/path/to/funclib.sh
+#   . relative/path/to/options-parser
+#   scriptversion=1.0
+#   func_options ${1+"$@"}
+#   eval set dummy "$func_options_result"; shift
+#   ...rest of your script...
+#
+# In order for the '--version' option to work, you will need to have a
+# suitably formatted comment like the one at the top of this file
+# starting with '# Written by ' and ending with '# warranty; '.
+#
+# For '-h' and '--help' to work, you will also need a one line
+# description of your script's purpose in a comment directly above the
+# '# Written by ' line, like the one at the top of this file.
+#
+# The default options also support '--debug', which will turn on shell
+# execution tracing (see the comment above debug_cmd below for another
+# use), and '--verbose' and the func_verbose function to allow your script
+# to display verbose messages only when your user has specified
+# '--verbose'.
+#
+# After sourcing this file, you can plug processing for additional
+# options by amending the variables from the 'Configuration' section
+# below, and following the instructions in the 'Option parsing'
+# section further down.
+
+## -------------- ##
+## Configuration. ##
+## -------------- ##
+
+# You should override these variables in your script after sourcing this
+# file so that they reflect the customisations you have added to the
+# option parser.
+
+# The usage line for option parsing errors and the start of '-h' and
+# '--help' output messages. You can embed shell variables for delayed
+# expansion at the time the message is displayed, but you will need to
+# quote other shell meta-characters carefully to prevent them being
+# expanded when the contents are evaled.
+usage='$progpath [OPTION]...'
+
+# Short help message in response to '-h' and '--help'.  Add to this or
+# override it after sourcing this library to reflect the full set of
+# options your script accepts.
+usage_message="\
+       --debug        enable verbose shell tracing
+   -W, --warnings=CATEGORY
+                      report the warnings falling in CATEGORY [all]
+   -v, --verbose      verbosely report processing
+       --version      print version information and exit
+   -h, --help         print short or long help message and exit
+"
+
+# Additional text appended to 'usage_message' in response to '--help'.
+long_help_message="
+Warning categories include:
+       'all'          show all warnings
+       'none'         turn off all the warnings
+       'error'        warnings are treated as fatal errors"
+
+# Help message printed before fatal option parsing errors.
+fatal_help="Try '\$progname --help' for more information."
+
+
+
+## ------------------------- ##
+## Hook function management. ##
+## ------------------------- ##
+
+# This section contains functions for adding, removing, and running hooks
+# to the main code.  A hook is just a named list of of function, that can
+# be run in order later on.
+
+# func_hookable FUNC_NAME
+# -----------------------
+# Declare that FUNC_NAME will run hooks added with
+# 'func_add_hook FUNC_NAME ...'.
+func_hookable ()
+{
+    $debug_cmd
+
+    func_append hookable_fns " $1"
+}
+
+
+# func_add_hook FUNC_NAME HOOK_FUNC
+# ---------------------------------
+# Request that FUNC_NAME call HOOK_FUNC before it returns.  FUNC_NAME must
+# first have been declared "hookable" by a call to 'func_hookable'.
+func_add_hook ()
+{
+    $debug_cmd
+
+    case " $hookable_fns " in
+      *" $1 "*) ;;
+      *) func_fatal_error "'$1' does not accept hook functions." ;;
+    esac
+
+    eval func_append ${1}_hooks '" $2"'
+}
+
+
+# func_remove_hook FUNC_NAME HOOK_FUNC
+# ------------------------------------
+# Remove HOOK_FUNC from the list of functions called by FUNC_NAME.
+func_remove_hook ()
+{
+    $debug_cmd
+
+    eval ${1}_hooks='`$ECHO "\$'$1'_hooks" |$SED "s| '$2'||"`'
+}
+
+
+# func_run_hooks FUNC_NAME [ARG]...
+# ---------------------------------
+# Run all hook functions registered to FUNC_NAME.
+# It is assumed that the list of hook functions contains nothing more
+# than a whitespace-delimited list of legal shell function names, and
+# no effort is wasted trying to catch shell meta-characters or preserve
+# whitespace.
+func_run_hooks ()
+{
+    $debug_cmd
+
+    case " $hookable_fns " in
+      *" $1 "*) ;;
+      *) func_fatal_error "'$1' does not support hook funcions.n" ;;
+    esac
+
+    eval _G_hook_fns=\$$1_hooks; shift
+
+    for _G_hook in $_G_hook_fns; do
+      eval $_G_hook '"$@"'
+
+      # store returned options list back into positional
+      # parameters for next 'cmd' execution.
+      eval _G_hook_result=\$${_G_hook}_result
+      eval set dummy "$_G_hook_result"; shift
+    done
+
+    func_quote_for_eval ${1+"$@"}
+    func_run_hooks_result=$func_quote_for_eval_result
+}
+
+
+
+## --------------- ##
+## Option parsing. ##
+## --------------- ##
+
+# In order to add your own option parsing hooks, you must accept the
+# full positional parameter list in your hook function, remove any
+# options that you action, and then pass back the remaining unprocessed
+# options in '<hooked_function_name>_result', escaped suitably for
+# 'eval'.  Like this:
+#
+#    my_options_prep ()
+#    {
+#        $debug_cmd
+#
+#        # Extend the existing usage message.
+#        usage_message=$usage_message'
+#      -s, --silent       don'\''t print informational messages
+#    '
+#
+#        func_quote_for_eval ${1+"$@"}
+#        my_options_prep_result=$func_quote_for_eval_result
+#    }
+#    func_add_hook func_options_prep my_options_prep
+#
+#
+#    my_silent_option ()
+#    {
+#        $debug_cmd
+#
+#        # Note that for efficiency, we parse as many options as we can
+#        # recognise in a loop before passing the remainder back to the
+#        # caller on the first unrecognised argument we encounter.
+#        while test $# -gt 0; do
+#          opt=$1; shift
+#          case $opt in
+#            --silent|-s) opt_silent=: ;;
+#            # Separate non-argument short options:
+#            -s*)         func_split_short_opt "$_G_opt"
+#                         set dummy "$func_split_short_opt_name" \
+#                             "-$func_split_short_opt_arg" ${1+"$@"}
+#                         shift
+#                         ;;
+#            *)            set dummy "$_G_opt" "$*"; shift; break ;;
+#          esac
+#        done
+#
+#        func_quote_for_eval ${1+"$@"}
+#        my_silent_option_result=$func_quote_for_eval_result
+#    }
+#    func_add_hook func_parse_options my_silent_option
+#
+#
+#    my_option_validation ()
+#    {
+#        $debug_cmd
+#
+#        $opt_silent && $opt_verbose && func_fatal_help "\
+#    '--silent' and '--verbose' options are mutually exclusive."
+#
+#        func_quote_for_eval ${1+"$@"}
+#        my_option_validation_result=$func_quote_for_eval_result
+#    }
+#    func_add_hook func_validate_options my_option_validation
+#
+# You'll alse need to manually amend $usage_message to reflect the extra
+# options you parse.  It's preferable to append if you can, so that
+# multiple option parsing hooks can be added safely.
+
+
+# func_options [ARG]...
+# ---------------------
+# All the functions called inside func_options are hookable. See the
+# individual implementations for details.
+func_hookable func_options
+func_options ()
+{
+    $debug_cmd
+
+    func_options_prep ${1+"$@"}
+    eval func_parse_options \
+        ${func_options_prep_result+"$func_options_prep_result"}
+    eval func_validate_options \
+        ${func_parse_options_result+"$func_parse_options_result"}
+
+    eval func_run_hooks func_options \
+        ${func_validate_options_result+"$func_validate_options_result"}
+
+    # save modified positional parameters for caller
+    func_options_result=$func_run_hooks_result
+}
+
+
+# func_options_prep [ARG]...
+# --------------------------
+# All initialisations required before starting the option parse loop.
+# Note that when calling hook functions, we pass through the list of
+# positional parameters.  If a hook function modifies that list, and
+# needs to propogate that back to rest of this script, then the complete
+# modified list must be put in 'func_run_hooks_result' before
+# returning.
+func_hookable func_options_prep
+func_options_prep ()
+{
+    $debug_cmd
+
+    # Option defaults:
+    opt_verbose=false
+    opt_warning_types=
+
+    func_run_hooks func_options_prep ${1+"$@"}
+
+    # save modified positional parameters for caller
+    func_options_prep_result=$func_run_hooks_result
+}
+
+
+# func_parse_options [ARG]...
+# ---------------------------
+# The main option parsing loop.
+func_hookable func_parse_options
+func_parse_options ()
+{
+    $debug_cmd
+
+    func_parse_options_result=
+
+    # this just eases exit handling
+    while test $# -gt 0; do
+      # Defer to hook functions for initial option parsing, so they
+      # get priority in the event of reusing an option name.
+      func_run_hooks func_parse_options ${1+"$@"}
+
+      # Adjust func_parse_options positional parameters to match
+      eval set dummy "$func_run_hooks_result"; shift
+
+      # Break out of the loop if we already parsed every option.
+      test $# -gt 0 || break
+
+      _G_opt=$1
+      shift
+      case $_G_opt in
+        --debug|-x)   debug_cmd='set -x'
+                      func_echo "enabling shell trace mode"
+                      $debug_cmd
+                      ;;
+
+        --no-warnings|--no-warning|--no-warn)
+                      set dummy --warnings none ${1+"$@"}
+                      shift
+		      ;;
+
+        --warnings|--warning|-W)
+                      test $# = 0 && func_missing_arg $_G_opt && break
+                      case " $warning_categories $1" in
+                        *" $1 "*)
+                          # trailing space prevents matching last $1 above
+                          func_append_uniq opt_warning_types " $1"
+                          ;;
+                        *all)
+                          opt_warning_types=$warning_categories
+                          ;;
+                        *none)
+                          opt_warning_types=none
+                          warning_func=:
+                          ;;
+                        *error)
+                          opt_warning_types=$warning_categories
+                          warning_func=func_fatal_error
+                          ;;
+                        *)
+                          func_fatal_error \
+                             "unsupported warning category: '$1'"
+                          ;;
+                      esac
+                      shift
+                      ;;
+
+        --verbose|-v) opt_verbose=: ;;
+        --version)    func_version ;;
+        -\?|-h)       func_usage ;;
+        --help)       func_help ;;
+
+	# Separate optargs to long options (plugins may need this):
+	--*=*)        func_split_equals "$_G_opt"
+	              set dummy "$func_split_equals_lhs" \
+                          "$func_split_equals_rhs" ${1+"$@"}
+                      shift
+                      ;;
+
+       # Separate optargs to short options:
+        -W*)
+                      func_split_short_opt "$_G_opt"
+                      set dummy "$func_split_short_opt_name" \
+                          "$func_split_short_opt_arg" ${1+"$@"}
+                      shift
+                      ;;
+
+        # Separate non-argument short options:
+        -\?*|-h*|-v*|-x*)
+                      func_split_short_opt "$_G_opt"
+                      set dummy "$func_split_short_opt_name" \
+                          "-$func_split_short_opt_arg" ${1+"$@"}
+                      shift
+                      ;;
+
+        --)           break ;;
+        -*)           func_fatal_help "unrecognised option: '$_G_opt'" ;;
+        *)            set dummy "$_G_opt" ${1+"$@"}; shift; break ;;
+      esac
+    done
+
+    # save modified positional parameters for caller
+    func_quote_for_eval ${1+"$@"}
+    func_parse_options_result=$func_quote_for_eval_result
+}
+
+
+# func_validate_options [ARG]...
+# ------------------------------
+# Perform any sanity checks on option settings and/or unconsumed
+# arguments.
+func_hookable func_validate_options
+func_validate_options ()
+{
+    $debug_cmd
+
+    # Display all warnings if -W was not given.
+    test -n "$opt_warning_types" || opt_warning_types=" $warning_categories"
+
+    func_run_hooks func_validate_options ${1+"$@"}
+
+    # Bail if the options were screwed!
+    $exit_cmd $EXIT_FAILURE
+
+    # save modified positional parameters for caller
+    func_validate_options_result=$func_run_hooks_result
+}
+
+
+
+## ----------------- ##
+## Helper functions. ##
+## ----------------- ##
+
+# This section contains the helper functions used by the rest of the
+# hookable option parser framework in ascii-betical order.
+
+
+# func_fatal_help ARG...
+# ----------------------
+# Echo program name prefixed message to standard error, followed by
+# a help hint, and exit.
+func_fatal_help ()
+{
+    $debug_cmd
+
+    eval \$ECHO \""Usage: $usage"\"
+    eval \$ECHO \""$fatal_help"\"
+    func_error ${1+"$@"}
+    exit $EXIT_FAILURE
+}
+
+
+# func_help
+# ---------
+# Echo long help message to standard output and exit.
 func_help ()
 {
-    $opt_debug
+    $debug_cmd
 
-    $SED -n '/^# Usage:/,/# Report bugs to/ {
-	:print
-        s/^# //
-	s/^# *$//
-	s*\$progname*'$progname'*
-	s*\$host*'"$host"'*
-	s*\$SHELL*'"$SHELL"'*
-	s*\$LTCC*'"$LTCC"'*
-	s*\$LTCFLAGS*'"$LTCFLAGS"'*
-	s*\$LD*'"$LD"'*
-	s/\$with_gnu_ld/'"$with_gnu_ld"'/
-	s/\$automake_version/'"`(${AUTOMAKE-automake} --version) 2>/dev/null |$SED 1q`"'/
-	s/\$autoconf_version/'"`(${AUTOCONF-autoconf} --version) 2>/dev/null |$SED 1q`"'/
-	p
-	d
-     }
-     /^# .* home page:/b print
-     /^# General help using/b print
-     ' < "$progpath"
-    ret=$?
-    if test -z "$1"; then
-      exit $ret
-    fi
+    func_usage_message
+    $ECHO "$long_help_message"
+    exit 0
 }
 
-# func_missing_arg argname
+
+# func_missing_arg ARGNAME
+# ------------------------
 # Echo program name prefixed message to standard error and set global
 # exit_cmd.
 func_missing_arg ()
 {
-    $opt_debug
+    $debug_cmd
 
-    func_error "missing argument for $1."
+    func_error "Missing argument for '$1'."
     exit_cmd=exit
 }
 
 
-# func_split_short_opt shortopt
+# func_split_equals STRING
+# ------------------------
+# Set func_split_equals_lhs and func_split_equals_rhs shell variables after
+# splitting STRING at the '=' sign.
+test -z "$_G_HAVE_XSI_OPS" \
+    && (eval 'x=a/b/c;
+      test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \
+    && _G_HAVE_XSI_OPS=yes
+
+if test yes = "$_G_HAVE_XSI_OPS"
+then
+  # This is an XSI compatible shell, allowing a faster implementation...
+  eval 'func_split_equals ()
+  {
+      $debug_cmd
+
+      func_split_equals_lhs=${1%%=*}
+      func_split_equals_rhs=${1#*=}
+      test "x$func_split_equals_lhs" = "x$1" \
+        && func_split_equals_rhs=
+  }'
+else
+  # ...otherwise fall back to using expr, which is often a shell builtin.
+  func_split_equals ()
+  {
+      $debug_cmd
+
+      func_split_equals_lhs=`expr "x$1" : 'x\([^=]*\)'`
+      func_split_equals_rhs=
+      test "x$func_split_equals_lhs" = "x$1" \
+        || func_split_equals_rhs=`expr "x$1" : 'x[^=]*=\(.*\)$'`
+  }
+fi #func_split_equals
+
+
+# func_split_short_opt SHORTOPT
+# -----------------------------
 # Set func_split_short_opt_name and func_split_short_opt_arg shell
 # variables after splitting SHORTOPT after the 2nd character.
-func_split_short_opt ()
+if test yes = "$_G_HAVE_XSI_OPS"
+then
+  # This is an XSI compatible shell, allowing a faster implementation...
+  eval 'func_split_short_opt ()
+  {
+      $debug_cmd
+
+      func_split_short_opt_arg=${1#??}
+      func_split_short_opt_name=${1%"$func_split_short_opt_arg"}
+  }'
+else
+  # ...otherwise fall back to using expr, which is often a shell builtin.
+  func_split_short_opt ()
+  {
+      $debug_cmd
+
+      func_split_short_opt_name=`expr "x$1" : 'x-\(.\)'`
+      func_split_short_opt_arg=`expr "x$1" : 'x-.\(.*\)$'`
+  }
+fi #func_split_short_opt
+
+
+# func_usage
+# ----------
+# Echo short help message to standard output and exit.
+func_usage ()
 {
-    my_sed_short_opt='1s/^\(..\).*$/\1/;q'
-    my_sed_short_rest='1s/^..\(.*\)$/\1/;q'
+    $debug_cmd
 
-    func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"`
-    func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"`
-} # func_split_short_opt may be replaced by extended shell implementation
+    func_usage_message
+    $ECHO "Run '$progname --help |${PAGER-more}' for full usage"
+    exit 0
+}
 
 
-# func_split_long_opt longopt
-# Set func_split_long_opt_name and func_split_long_opt_arg shell
-# variables after splitting LONGOPT at the `=' sign.
-func_split_long_opt ()
+# func_usage_message
+# ------------------
+# Echo short help message to standard output.
+func_usage_message ()
 {
-    my_sed_long_opt='1s/^\(--[^=]*\)=.*/\1/;q'
-    my_sed_long_arg='1s/^--[^=]*=//'
+    $debug_cmd
 
-    func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"`
-    func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"`
-} # func_split_long_opt may be replaced by extended shell implementation
-
-exit_cmd=:
+    eval \$ECHO \""Usage: $usage"\"
+    echo
+    $SED -n 's|^# ||
+        /^Written by/{
+          x;p;x
+        }
+	h
+	/^Written by/q' < "$progpath"
+    echo
+    eval \$ECHO \""$usage_message"\"
+}
 
 
-
-
-
-magic="%%%MAGIC variable%%%"
-magic_exe="%%%MAGIC EXE variable%%%"
-
-# Global variables.
-nonopt=
-preserve_args=
-lo2o="s/\\.lo\$/.${objext}/"
-o2lo="s/\\.${objext}\$/.lo/"
-extracted_archives=
-extracted_serial=0
-
-# If this variable is set in any of the actions, the command in it
-# will be execed at the end.  This prevents here-documents from being
-# left over by shells.
-exec_cmd=
-
-# func_append var value
-# Append VALUE to the end of shell variable VAR.
-func_append ()
+# func_version
+# ------------
+# Echo version message to standard output and exit.
+func_version ()
 {
-    eval "${1}=\$${1}\${2}"
-} # func_append may be replaced by extended shell implementation
+    $debug_cmd
 
-# func_append_quoted var value
-# Quote VALUE and append to the end of shell variable VAR, separated
-# by a space.
-func_append_quoted ()
+    printf '%s\n' "$progname $scriptversion"
+    $SED -n '
+        /(C)/!b go
+        :more
+        /\./!{
+          N
+          s|\n# | |
+          b more
+        }
+        :go
+        /^# Written by /,/# warranty; / {
+          s|^# ||
+          s|^# *$||
+          s|\((C)\)[ 0-9,-]*[ ,-]\([1-9][0-9]* \)|\1 \2|
+          p
+        }
+        /^# Written by / {
+          s|^# ||
+          p
+        }
+        /^warranty; /q' < "$progpath"
+
+    exit $?
+}
+
+
+# Local variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'before-save-hook 'time-stamp)
+# time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC"
+# time-stamp-time-zone: "UTC"
+# End:
+
+# Set a version string.
+scriptversion='(GNU libtool) 2.4.6'
+
+
+# func_echo ARG...
+# ----------------
+# Libtool also displays the current mode in messages, so override
+# funclib.sh func_echo with this custom definition.
+func_echo ()
 {
-    func_quote_for_eval "${2}"
-    eval "${1}=\$${1}\\ \$func_quote_for_eval_result"
-} # func_append_quoted may be replaced by extended shell implementation
+    $debug_cmd
+
+    _G_message=$*
+
+    func_echo_IFS=$IFS
+    IFS=$nl
+    for _G_line in $_G_message; do
+      IFS=$func_echo_IFS
+      $ECHO "$progname${opt_mode+: $opt_mode}: $_G_line"
+    done
+    IFS=$func_echo_IFS
+}
 
 
-# func_arith arithmetic-term...
-func_arith ()
+# func_warning ARG...
+# -------------------
+# Libtool warnings are not categorized, so override funclib.sh
+# func_warning with this simpler definition.
+func_warning ()
 {
-    func_arith_result=`expr "${@}"`
-} # func_arith may be replaced by extended shell implementation
+    $debug_cmd
+
+    $warning_func ${1+"$@"}
+}
 
 
-# func_len string
-# STRING may not start with a hyphen.
-func_len ()
+## ---------------- ##
+## Options parsing. ##
+## ---------------- ##
+
+# Hook in the functions to make sure our own options are parsed during
+# the option parsing loop.
+
+usage='$progpath [OPTION]... [MODE-ARG]...'
+
+# Short help message in response to '-h'.
+usage_message="Options:
+       --config             show all configuration variables
+       --debug              enable verbose shell tracing
+   -n, --dry-run            display commands without modifying any files
+       --features           display basic configuration information and exit
+       --mode=MODE          use operation mode MODE
+       --no-warnings        equivalent to '-Wnone'
+       --preserve-dup-deps  don't remove duplicate dependency libraries
+       --quiet, --silent    don't print informational messages
+       --tag=TAG            use configuration variables from tag TAG
+   -v, --verbose            print more informational messages than default
+       --version            print version information
+   -W, --warnings=CATEGORY  report the warnings falling in CATEGORY [all]
+   -h, --help, --help-all   print short, long, or detailed help message
+"
+
+# Additional text appended to 'usage_message' in response to '--help'.
+func_help ()
 {
-    func_len_result=`expr "${1}" : ".*" 2>/dev/null || echo $max_cmd_len`
-} # func_len may be replaced by extended shell implementation
+    $debug_cmd
+
+    func_usage_message
+    $ECHO "$long_help_message
+
+MODE must be one of the following:
+
+       clean           remove files from the build directory
+       compile         compile a source file into a libtool object
+       execute         automatically set library path, then run a program
+       finish          complete the installation of libtool libraries
+       install         install libraries or executables
+       link            create a library or an executable
+       uninstall       remove libraries from an installed directory
+
+MODE-ARGS vary depending on the MODE.  When passed as first option,
+'--mode=MODE' may be abbreviated as 'MODE' or a unique abbreviation of that.
+Try '$progname --help --mode=MODE' for a more detailed description of MODE.
+
+When reporting a bug, please describe a test case to reproduce it and
+include the following information:
+
+       host-triplet:   $host
+       shell:          $SHELL
+       compiler:       $LTCC
+       compiler flags: $LTCFLAGS
+       linker:         $LD (gnu? $with_gnu_ld)
+       version:        $progname (GNU libtool) 2.4.6
+       automake:       `($AUTOMAKE --version) 2>/dev/null |$SED 1q`
+       autoconf:       `($AUTOCONF --version) 2>/dev/null |$SED 1q`
+
+Report bugs to <bug-libtool@gnu.org>.
+GNU libtool home page: <http://www.gnu.org/software/libtool/>.
+General help using GNU software: <http://www.gnu.org/gethelp/>."
+    exit 0
+}
 
 
-# func_lo2o object
-func_lo2o ()
-{
-    func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"`
-} # func_lo2o may be replaced by extended shell implementation
+# func_lo2o OBJECT-NAME
+# ---------------------
+# Transform OBJECT-NAME from a '.lo' suffix to the platform specific
+# object suffix.
+
+lo2o=s/\\.lo\$/.$objext/
+o2lo=s/\\.$objext\$/.lo/
+
+if test yes = "$_G_HAVE_XSI_OPS"; then
+  eval 'func_lo2o ()
+  {
+    case $1 in
+      *.lo) func_lo2o_result=${1%.lo}.$objext ;;
+      *   ) func_lo2o_result=$1               ;;
+    esac
+  }'
+
+  # func_xform LIBOBJ-OR-SOURCE
+  # ---------------------------
+  # Transform LIBOBJ-OR-SOURCE from a '.o' or '.c' (or otherwise)
+  # suffix to a '.lo' libtool-object suffix.
+  eval 'func_xform ()
+  {
+    func_xform_result=${1%.*}.lo
+  }'
+else
+  # ...otherwise fall back to using sed.
+  func_lo2o ()
+  {
+    func_lo2o_result=`$ECHO "$1" | $SED "$lo2o"`
+  }
+
+  func_xform ()
+  {
+    func_xform_result=`$ECHO "$1" | $SED 's|\.[^.]*$|.lo|'`
+  }
+fi
 
 
-# func_xform libobj-or-source
-func_xform ()
-{
-    func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'`
-} # func_xform may be replaced by extended shell implementation
-
-
-# func_fatal_configuration arg...
+# func_fatal_configuration ARG...
+# -------------------------------
 # Echo program name prefixed message to standard error, followed by
 # a configuration failure hint, and exit.
 func_fatal_configuration ()
 {
-    func_error ${1+"$@"}
-    func_error "See the $PACKAGE documentation for more information."
-    func_fatal_error "Fatal configuration error."
+    func_fatal_error ${1+"$@"} \
+      "See the $PACKAGE documentation for more information." \
+      "Fatal configuration error."
 }
 
 
 # func_config
+# -----------
 # Display the configuration for all the tags in this script.
 func_config ()
 {
@@ -915,17 +2149,19 @@ func_config ()
     exit $?
 }
 
+
 # func_features
+# -------------
 # Display the features supported by this script.
 func_features ()
 {
     echo "host: $host"
-    if test "$build_libtool_libs" = yes; then
+    if test yes = "$build_libtool_libs"; then
       echo "enable shared libraries"
     else
       echo "disable shared libraries"
     fi
-    if test "$build_old_libs" = yes; then
+    if test yes = "$build_old_libs"; then
       echo "enable static libraries"
     else
       echo "disable static libraries"
@@ -934,314 +2170,350 @@ func_features ()
     exit $?
 }
 
-# func_enable_tag tagname
+
+# func_enable_tag TAGNAME
+# -----------------------
 # Verify that TAGNAME is valid, and either flag an error and exit, or
 # enable the TAGNAME tag.  We also add TAGNAME to the global $taglist
 # variable here.
 func_enable_tag ()
 {
-  # Global variable:
-  tagname="$1"
+    # Global variable:
+    tagname=$1
 
-  re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
-  re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
-  sed_extractcf="/$re_begincf/,/$re_endcf/p"
+    re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
+    re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
+    sed_extractcf=/$re_begincf/,/$re_endcf/p
 
-  # Validate tagname.
-  case $tagname in
-    *[!-_A-Za-z0-9,/]*)
-      func_fatal_error "invalid tag name: $tagname"
-      ;;
-  esac
+    # Validate tagname.
+    case $tagname in
+      *[!-_A-Za-z0-9,/]*)
+        func_fatal_error "invalid tag name: $tagname"
+        ;;
+    esac
 
-  # Don't test for the "default" C tag, as we know it's
-  # there but not specially marked.
-  case $tagname in
-    CC) ;;
+    # Don't test for the "default" C tag, as we know it's
+    # there but not specially marked.
+    case $tagname in
+        CC) ;;
     *)
-      if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
-	taglist="$taglist $tagname"
+        if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
+	  taglist="$taglist $tagname"
 
-	# Evaluate the configuration.  Be careful to quote the path
-	# and the sed script, to avoid splitting on whitespace, but
-	# also don't use non-portable quotes within backquotes within
-	# quotes we have to do it in 2 steps:
-	extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
-	eval "$extractedcf"
-      else
-	func_error "ignoring unknown tag $tagname"
-      fi
-      ;;
-  esac
+	  # Evaluate the configuration.  Be careful to quote the path
+	  # and the sed script, to avoid splitting on whitespace, but
+	  # also don't use non-portable quotes within backquotes within
+	  # quotes we have to do it in 2 steps:
+	  extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
+	  eval "$extractedcf"
+        else
+	  func_error "ignoring unknown tag $tagname"
+        fi
+        ;;
+    esac
 }
 
+
 # func_check_version_match
+# ------------------------
 # Ensure that we are using m4 macros, and libtool script from the same
 # release of libtool.
 func_check_version_match ()
 {
-  if test "$package_revision" != "$macro_revision"; then
-    if test "$VERSION" != "$macro_version"; then
-      if test -z "$macro_version"; then
-        cat >&2 <<_LT_EOF
+    if test "$package_revision" != "$macro_revision"; then
+      if test "$VERSION" != "$macro_version"; then
+        if test -z "$macro_version"; then
+          cat >&2 <<_LT_EOF
 $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
 $progname: definition of this LT_INIT comes from an older release.
 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
 $progname: and run autoconf again.
 _LT_EOF
-      else
-        cat >&2 <<_LT_EOF
+        else
+          cat >&2 <<_LT_EOF
 $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
 $progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
 $progname: and run autoconf again.
 _LT_EOF
-      fi
-    else
-      cat >&2 <<_LT_EOF
+        fi
+      else
+        cat >&2 <<_LT_EOF
 $progname: Version mismatch error.  This is $PACKAGE $VERSION, revision $package_revision,
 $progname: but the definition of this LT_INIT comes from revision $macro_revision.
 $progname: You should recreate aclocal.m4 with macros from revision $package_revision
 $progname: of $PACKAGE $VERSION and run autoconf again.
 _LT_EOF
-    fi
+      fi
 
-    exit $EXIT_MISMATCH
-  fi
+      exit $EXIT_MISMATCH
+    fi
 }
 
 
-# Shorthand for --mode=foo, only valid as the first argument
-case $1 in
-clean|clea|cle|cl)
-  shift; set dummy --mode clean ${1+"$@"}; shift
-  ;;
-compile|compil|compi|comp|com|co|c)
-  shift; set dummy --mode compile ${1+"$@"}; shift
-  ;;
-execute|execut|execu|exec|exe|ex|e)
-  shift; set dummy --mode execute ${1+"$@"}; shift
-  ;;
-finish|finis|fini|fin|fi|f)
-  shift; set dummy --mode finish ${1+"$@"}; shift
-  ;;
-install|instal|insta|inst|ins|in|i)
-  shift; set dummy --mode install ${1+"$@"}; shift
-  ;;
-link|lin|li|l)
-  shift; set dummy --mode link ${1+"$@"}; shift
-  ;;
-uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
-  shift; set dummy --mode uninstall ${1+"$@"}; shift
-  ;;
-esac
-
-
-
-# Option defaults:
-opt_debug=:
-opt_dry_run=false
-opt_config=false
-opt_preserve_dup_deps=false
-opt_features=false
-opt_finish=false
-opt_help=false
-opt_help_all=false
-opt_silent=:
-opt_warning=:
-opt_verbose=:
-opt_silent=false
-opt_verbose=false
-
-
-# Parse options once, thoroughly.  This comes as soon as possible in the
-# script to make things like `--version' happen as quickly as we can.
+# libtool_options_prep [ARG]...
+# -----------------------------
+# Preparation for options parsed by libtool.
+libtool_options_prep ()
 {
-  # this just eases exit handling
-  while test $# -gt 0; do
-    opt="$1"
-    shift
-    case $opt in
-      --debug|-x)	opt_debug='set -x'
-			func_echo "enabling shell trace mode"
-			$opt_debug
-			;;
-      --dry-run|--dryrun|-n)
-			opt_dry_run=:
-			;;
-      --config)
-			opt_config=:
-func_config
-			;;
-      --dlopen|-dlopen)
-			optarg="$1"
-			opt_dlopen="${opt_dlopen+$opt_dlopen
-}$optarg"
-			shift
-			;;
-      --preserve-dup-deps)
-			opt_preserve_dup_deps=:
-			;;
-      --features)
-			opt_features=:
-func_features
-			;;
-      --finish)
-			opt_finish=:
-set dummy --mode finish ${1+"$@"}; shift
-			;;
-      --help)
-			opt_help=:
-			;;
-      --help-all)
-			opt_help_all=:
-opt_help=': help-all'
-			;;
-      --mode)
-			test $# = 0 && func_missing_arg $opt && break
-			optarg="$1"
-			opt_mode="$optarg"
-case $optarg in
-  # Valid mode arguments:
-  clean|compile|execute|finish|install|link|relink|uninstall) ;;
+    $debug_mode
 
-  # Catch anything else as an error
-  *) func_error "invalid argument for $opt"
-     exit_cmd=exit
-     break
-     ;;
-esac
-			shift
-			;;
-      --no-silent|--no-quiet)
-			opt_silent=false
-func_append preserve_args " $opt"
-			;;
-      --no-warning|--no-warn)
-			opt_warning=false
-func_append preserve_args " $opt"
-			;;
-      --no-verbose)
-			opt_verbose=false
-func_append preserve_args " $opt"
-			;;
-      --silent|--quiet)
-			opt_silent=:
-func_append preserve_args " $opt"
-        opt_verbose=false
-			;;
-      --verbose|-v)
-			opt_verbose=:
-func_append preserve_args " $opt"
-opt_silent=false
-			;;
-      --tag)
-			test $# = 0 && func_missing_arg $opt && break
-			optarg="$1"
-			opt_tag="$optarg"
-func_append preserve_args " $opt $optarg"
-func_enable_tag "$optarg"
-			shift
-			;;
+    # Option defaults:
+    opt_config=false
+    opt_dlopen=
+    opt_dry_run=false
+    opt_help=false
+    opt_mode=
+    opt_preserve_dup_deps=false
+    opt_quiet=false
 
-      -\?|-h)		func_usage				;;
-      --help)		func_help				;;
-      --version)	func_version				;;
+    nonopt=
+    preserve_args=
 
-      # Separate optargs to long options:
-      --*=*)
-			func_split_long_opt "$opt"
-			set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"}
-			shift
-			;;
-
-      # Separate non-argument short options:
-      -\?*|-h*|-n*|-v*)
-			func_split_short_opt "$opt"
-			set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"}
-			shift
-			;;
-
-      --)		break					;;
-      -*)		func_fatal_help "unrecognized option \`$opt'" ;;
-      *)		set dummy "$opt" ${1+"$@"};	shift; break  ;;
+    # Shorthand for --mode=foo, only valid as the first argument
+    case $1 in
+    clean|clea|cle|cl)
+      shift; set dummy --mode clean ${1+"$@"}; shift
+      ;;
+    compile|compil|compi|comp|com|co|c)
+      shift; set dummy --mode compile ${1+"$@"}; shift
+      ;;
+    execute|execut|execu|exec|exe|ex|e)
+      shift; set dummy --mode execute ${1+"$@"}; shift
+      ;;
+    finish|finis|fini|fin|fi|f)
+      shift; set dummy --mode finish ${1+"$@"}; shift
+      ;;
+    install|instal|insta|inst|ins|in|i)
+      shift; set dummy --mode install ${1+"$@"}; shift
+      ;;
+    link|lin|li|l)
+      shift; set dummy --mode link ${1+"$@"}; shift
+      ;;
+    uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
+      shift; set dummy --mode uninstall ${1+"$@"}; shift
+      ;;
     esac
-  done
 
-  # Validate options:
-
-  # save first non-option argument
-  if test "$#" -gt 0; then
-    nonopt="$opt"
-    shift
-  fi
-
-  # preserve --debug
-  test "$opt_debug" = : || func_append preserve_args " --debug"
-
-  case $host in
-    *cygwin* | *mingw* | *pw32* | *cegcc*)
-      # don't eliminate duplications in $postdeps and $predeps
-      opt_duplicate_compiler_generated_deps=:
-      ;;
-    *)
-      opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
-      ;;
-  esac
-
-  $opt_help || {
-    # Sanity checks first:
-    func_check_version_match
-
-    if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
-      func_fatal_configuration "not configured to build any kind of library"
-    fi
-
-    # Darwin sucks
-    eval std_shrext=\"$shrext_cmds\"
-
-    # Only execute mode is allowed to have -dlopen flags.
-    if test -n "$opt_dlopen" && test "$opt_mode" != execute; then
-      func_error "unrecognized option \`-dlopen'"
-      $ECHO "$help" 1>&2
-      exit $EXIT_FAILURE
-    fi
-
-    # Change the help message to a mode-specific one.
-    generic_help="$help"
-    help="Try \`$progname --help --mode=$opt_mode' for more information."
-  }
-
-
-  # Bail if the options were screwed
-  $exit_cmd $EXIT_FAILURE
+    # Pass back the list of options.
+    func_quote_for_eval ${1+"$@"}
+    libtool_options_prep_result=$func_quote_for_eval_result
 }
+func_add_hook func_options_prep libtool_options_prep
 
 
+# libtool_parse_options [ARG]...
+# ---------------------------------
+# Provide handling for libtool specific options.
+libtool_parse_options ()
+{
+    $debug_cmd
+
+    # Perform our own loop to consume as many options as possible in
+    # each iteration.
+    while test $# -gt 0; do
+      _G_opt=$1
+      shift
+      case $_G_opt in
+        --dry-run|--dryrun|-n)
+                        opt_dry_run=:
+                        ;;
+
+        --config)       func_config ;;
+
+        --dlopen|-dlopen)
+                        opt_dlopen="${opt_dlopen+$opt_dlopen
+}$1"
+                        shift
+                        ;;
+
+        --preserve-dup-deps)
+                        opt_preserve_dup_deps=: ;;
+
+        --features)     func_features ;;
+
+        --finish)       set dummy --mode finish ${1+"$@"}; shift ;;
+
+        --help)         opt_help=: ;;
+
+        --help-all)     opt_help=': help-all' ;;
+
+        --mode)         test $# = 0 && func_missing_arg $_G_opt && break
+                        opt_mode=$1
+                        case $1 in
+                          # Valid mode arguments:
+                          clean|compile|execute|finish|install|link|relink|uninstall) ;;
+
+                          # Catch anything else as an error
+                          *) func_error "invalid argument for $_G_opt"
+                             exit_cmd=exit
+                             break
+                             ;;
+                        esac
+                        shift
+                        ;;
+
+        --no-silent|--no-quiet)
+                        opt_quiet=false
+                        func_append preserve_args " $_G_opt"
+                        ;;
+
+        --no-warnings|--no-warning|--no-warn)
+                        opt_warning=false
+                        func_append preserve_args " $_G_opt"
+                        ;;
+
+        --no-verbose)
+                        opt_verbose=false
+                        func_append preserve_args " $_G_opt"
+                        ;;
+
+        --silent|--quiet)
+                        opt_quiet=:
+                        opt_verbose=false
+                        func_append preserve_args " $_G_opt"
+                        ;;
+
+        --tag)          test $# = 0 && func_missing_arg $_G_opt && break
+                        opt_tag=$1
+                        func_append preserve_args " $_G_opt $1"
+                        func_enable_tag "$1"
+                        shift
+                        ;;
+
+        --verbose|-v)   opt_quiet=false
+                        opt_verbose=:
+                        func_append preserve_args " $_G_opt"
+                        ;;
+
+	# An option not handled by this hook function:
+        *)		set dummy "$_G_opt" ${1+"$@"};	shift; break  ;;
+      esac
+    done
+
+
+    # save modified positional parameters for caller
+    func_quote_for_eval ${1+"$@"}
+    libtool_parse_options_result=$func_quote_for_eval_result
+}
+func_add_hook func_parse_options libtool_parse_options
+
+
+
+# libtool_validate_options [ARG]...
+# ---------------------------------
+# Perform any sanity checks on option settings and/or unconsumed
+# arguments.
+libtool_validate_options ()
+{
+    # save first non-option argument
+    if test 0 -lt $#; then
+      nonopt=$1
+      shift
+    fi
+
+    # preserve --debug
+    test : = "$debug_cmd" || func_append preserve_args " --debug"
+
+    case $host in
+      # Solaris2 added to fix http://debbugs.gnu.org/cgi/bugreport.cgi?bug=16452
+      # see also: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=59788
+      *cygwin* | *mingw* | *pw32* | *cegcc* | *solaris2* | *os2*)
+        # don't eliminate duplications in $postdeps and $predeps
+        opt_duplicate_compiler_generated_deps=:
+        ;;
+      *)
+        opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
+        ;;
+    esac
+
+    $opt_help || {
+      # Sanity checks first:
+      func_check_version_match
+
+      test yes != "$build_libtool_libs" \
+        && test yes != "$build_old_libs" \
+        && func_fatal_configuration "not configured to build any kind of library"
+
+      # Darwin sucks
+      eval std_shrext=\"$shrext_cmds\"
+
+      # Only execute mode is allowed to have -dlopen flags.
+      if test -n "$opt_dlopen" && test execute != "$opt_mode"; then
+        func_error "unrecognized option '-dlopen'"
+        $ECHO "$help" 1>&2
+        exit $EXIT_FAILURE
+      fi
+
+      # Change the help message to a mode-specific one.
+      generic_help=$help
+      help="Try '$progname --help --mode=$opt_mode' for more information."
+    }
+
+    # Pass back the unparsed argument list
+    func_quote_for_eval ${1+"$@"}
+    libtool_validate_options_result=$func_quote_for_eval_result
+}
+func_add_hook func_validate_options libtool_validate_options
+
+
+# Process options as early as possible so that --help and --version
+# can return quickly.
+func_options ${1+"$@"}
+eval set dummy "$func_options_result"; shift
+
 
 
 ## ----------- ##
 ##    Main.    ##
 ## ----------- ##
 
+magic='%%%MAGIC variable%%%'
+magic_exe='%%%MAGIC EXE variable%%%'
+
+# Global variables.
+extracted_archives=
+extracted_serial=0
+
+# If this variable is set in any of the actions, the command in it
+# will be execed at the end.  This prevents here-documents from being
+# left over by shells.
+exec_cmd=
+
+
+# A function that is used when there is no print builtin or printf.
+func_fallback_echo ()
+{
+  eval 'cat <<_LTECHO_EOF
+$1
+_LTECHO_EOF'
+}
+
+# func_generated_by_libtool
+# True iff stdin has been generated by Libtool. This function is only
+# a basic sanity check; it will hardly flush out determined imposters.
+func_generated_by_libtool_p ()
+{
+  $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
+}
+
 # func_lalib_p file
-# True iff FILE is a libtool `.la' library or `.lo' object file.
+# True iff FILE is a libtool '.la' library or '.lo' object file.
 # This function is only a basic sanity check; it will hardly flush out
 # determined imposters.
 func_lalib_p ()
 {
     test -f "$1" &&
-      $SED -e 4q "$1" 2>/dev/null \
-        | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
+      $SED -e 4q "$1" 2>/dev/null | func_generated_by_libtool_p
 }
 
 # func_lalib_unsafe_p file
-# True iff FILE is a libtool `.la' library or `.lo' object file.
+# True iff FILE is a libtool '.la' library or '.lo' object file.
 # This function implements the same check as func_lalib_p without
 # resorting to external programs.  To this end, it redirects stdin and
 # closes it afterwards, without saving the original file descriptor.
 # As a safety measure, use it only where a negative result would be
-# fatal anyway.  Works if `file' does not exist.
+# fatal anyway.  Works if 'file' does not exist.
 func_lalib_unsafe_p ()
 {
     lalib_p=no
@@ -1249,13 +2521,13 @@ func_lalib_unsafe_p ()
 	for lalib_p_l in 1 2 3 4
 	do
 	    read lalib_p_line
-	    case "$lalib_p_line" in
+	    case $lalib_p_line in
 		\#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
 	    esac
 	done
 	exec 0<&5 5<&-
     fi
-    test "$lalib_p" = yes
+    test yes = "$lalib_p"
 }
 
 # func_ltwrapper_script_p file
@@ -1264,7 +2536,8 @@ func_lalib_unsafe_p ()
 # determined imposters.
 func_ltwrapper_script_p ()
 {
-    func_lalib_p "$1"
+    test -f "$1" &&
+      $lt_truncate_bin < "$1" 2>/dev/null | func_generated_by_libtool_p
 }
 
 # func_ltwrapper_executable_p file
@@ -1289,7 +2562,7 @@ func_ltwrapper_scriptname ()
 {
     func_dirname_and_basename "$1" "" "."
     func_stripname '' '.exe' "$func_basename_result"
-    func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
+    func_ltwrapper_scriptname_result=$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper
 }
 
 # func_ltwrapper_p file
@@ -1308,11 +2581,13 @@ func_ltwrapper_p ()
 # FAIL_CMD may read-access the current command in variable CMD!
 func_execute_cmds ()
 {
-    $opt_debug
+    $debug_cmd
+
     save_ifs=$IFS; IFS='~'
     for cmd in $1; do
-      IFS=$save_ifs
+      IFS=$sp$nl
       eval cmd=\"$cmd\"
+      IFS=$save_ifs
       func_show_eval "$cmd" "${2-:}"
     done
     IFS=$save_ifs
@@ -1324,10 +2599,11 @@ func_execute_cmds ()
 # Note that it is not necessary on cygwin/mingw to append a dot to
 # FILE even if both FILE and FILE.exe exist: automatic-append-.exe
 # behavior happens only for exec(3), not for open(2)!  Also, sourcing
-# `FILE.' does not work on cygwin managed mounts.
+# 'FILE.' does not work on cygwin managed mounts.
 func_source ()
 {
-    $opt_debug
+    $debug_cmd
+
     case $1 in
     */* | *\\*)	. "$1" ;;
     *)		. "./$1" ;;
@@ -1354,10 +2630,10 @@ func_resolve_sysroot ()
 # store the result into func_replace_sysroot_result.
 func_replace_sysroot ()
 {
-  case "$lt_sysroot:$1" in
+  case $lt_sysroot:$1 in
   ?*:"$lt_sysroot"*)
     func_stripname "$lt_sysroot" '' "$1"
-    func_replace_sysroot_result="=$func_stripname_result"
+    func_replace_sysroot_result='='$func_stripname_result
     ;;
   *)
     # Including no sysroot.
@@ -1374,7 +2650,8 @@ func_replace_sysroot ()
 # arg is usually of the form 'gcc ...'
 func_infer_tag ()
 {
-    $opt_debug
+    $debug_cmd
+
     if test -n "$available_tags" && test -z "$tagname"; then
       CC_quoted=
       for arg in $CC; do
@@ -1393,7 +2670,7 @@ func_infer_tag ()
 	for z in $available_tags; do
 	  if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
 	    # Evaluate the configuration.
-	    eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
+	    eval "`$SED -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
 	    CC_quoted=
 	    for arg in $CC; do
 	      # Double-quote args containing other shell metacharacters.
@@ -1418,7 +2695,7 @@ func_infer_tag ()
 	# line option must be used.
 	if test -z "$tagname"; then
 	  func_echo "unable to infer tagged configuration"
-	  func_fatal_error "specify a tag with \`--tag'"
+	  func_fatal_error "specify a tag with '--tag'"
 #	else
 #	  func_verbose "using $tagname tagged configuration"
 	fi
@@ -1434,15 +2711,15 @@ func_infer_tag ()
 # but don't create it if we're doing a dry run.
 func_write_libtool_object ()
 {
-    write_libobj=${1}
-    if test "$build_libtool_libs" = yes; then
-      write_lobj=\'${2}\'
+    write_libobj=$1
+    if test yes = "$build_libtool_libs"; then
+      write_lobj=\'$2\'
     else
       write_lobj=none
     fi
 
-    if test "$build_old_libs" = yes; then
-      write_oldobj=\'${3}\'
+    if test yes = "$build_old_libs"; then
+      write_oldobj=\'$3\'
     else
       write_oldobj=none
     fi
@@ -1450,7 +2727,7 @@ func_write_libtool_object ()
     $opt_dry_run || {
       cat >${write_libobj}T <<EOF
 # $write_libobj - a libtool object file
-# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
+# Generated by $PROGRAM (GNU $PACKAGE) $VERSION
 #
 # Please DO NOT delete this file!
 # It is necessary for linking the library.
@@ -1462,7 +2739,7 @@ pic_object=$write_lobj
 non_pic_object=$write_oldobj
 
 EOF
-      $MV "${write_libobj}T" "${write_libobj}"
+      $MV "${write_libobj}T" "$write_libobj"
     }
 }
 
@@ -1482,8 +2759,9 @@ EOF
 # be empty on error (or when ARG is empty)
 func_convert_core_file_wine_to_w32 ()
 {
-  $opt_debug
-  func_convert_core_file_wine_to_w32_result="$1"
+  $debug_cmd
+
+  func_convert_core_file_wine_to_w32_result=$1
   if test -n "$1"; then
     # Unfortunately, winepath does not exit with a non-zero error code, so we
     # are forced to check the contents of stdout. On the other hand, if the
@@ -1491,9 +2769,9 @@ func_convert_core_file_wine_to_w32 ()
     # *an error message* to stdout. So we must check for both error code of
     # zero AND non-empty stdout, which explains the odd construction:
     func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
-    if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then
+    if test "$?" -eq 0 && test -n "$func_convert_core_file_wine_to_w32_tmp"; then
       func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
-        $SED -e "$lt_sed_naive_backslashify"`
+        $SED -e "$sed_naive_backslashify"`
     else
       func_convert_core_file_wine_to_w32_result=
     fi
@@ -1514,18 +2792,19 @@ func_convert_core_file_wine_to_w32 ()
 # are convertible, then the result may be empty.
 func_convert_core_path_wine_to_w32 ()
 {
-  $opt_debug
+  $debug_cmd
+
   # unfortunately, winepath doesn't convert paths, only file names
-  func_convert_core_path_wine_to_w32_result=""
+  func_convert_core_path_wine_to_w32_result=
   if test -n "$1"; then
     oldIFS=$IFS
     IFS=:
     for func_convert_core_path_wine_to_w32_f in $1; do
       IFS=$oldIFS
       func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
-      if test -n "$func_convert_core_file_wine_to_w32_result" ; then
+      if test -n "$func_convert_core_file_wine_to_w32_result"; then
         if test -z "$func_convert_core_path_wine_to_w32_result"; then
-          func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"
+          func_convert_core_path_wine_to_w32_result=$func_convert_core_file_wine_to_w32_result
         else
           func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
         fi
@@ -1554,7 +2833,8 @@ func_convert_core_path_wine_to_w32 ()
 # environment variable; do not put it in $PATH.
 func_cygpath ()
 {
-  $opt_debug
+  $debug_cmd
+
   if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
     func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
     if test "$?" -ne 0; then
@@ -1563,7 +2843,7 @@ func_cygpath ()
     fi
   else
     func_cygpath_result=
-    func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'"
+    func_error "LT_CYGPATH is empty or specifies non-existent file: '$LT_CYGPATH'"
   fi
 }
 #end: func_cygpath
@@ -1574,10 +2854,11 @@ func_cygpath ()
 # result in func_convert_core_msys_to_w32_result.
 func_convert_core_msys_to_w32 ()
 {
-  $opt_debug
+  $debug_cmd
+
   # awkward: cmd appends spaces to result
   func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
-    $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
+    $SED -e 's/[ ]*$//' -e "$sed_naive_backslashify"`
 }
 #end: func_convert_core_msys_to_w32
 
@@ -1588,13 +2869,14 @@ func_convert_core_msys_to_w32 ()
 # func_to_host_file_result to ARG1).
 func_convert_file_check ()
 {
-  $opt_debug
-  if test -z "$2" && test -n "$1" ; then
+  $debug_cmd
+
+  if test -z "$2" && test -n "$1"; then
     func_error "Could not determine host file name corresponding to"
-    func_error "  \`$1'"
+    func_error "  '$1'"
     func_error "Continuing, but uninstalled executables may not work."
     # Fallback:
-    func_to_host_file_result="$1"
+    func_to_host_file_result=$1
   fi
 }
 # end func_convert_file_check
@@ -1606,10 +2888,11 @@ func_convert_file_check ()
 # func_to_host_file_result to a simplistic fallback value (see below).
 func_convert_path_check ()
 {
-  $opt_debug
+  $debug_cmd
+
   if test -z "$4" && test -n "$3"; then
     func_error "Could not determine the host path corresponding to"
-    func_error "  \`$3'"
+    func_error "  '$3'"
     func_error "Continuing, but uninstalled executables may not work."
     # Fallback.  This is a deliberately simplistic "conversion" and
     # should not be "improved".  See libtool.info.
@@ -1618,7 +2901,7 @@ func_convert_path_check ()
       func_to_host_path_result=`echo "$3" |
         $SED -e "$lt_replace_pathsep_chars"`
     else
-      func_to_host_path_result="$3"
+      func_to_host_path_result=$3
     fi
   fi
 }
@@ -1630,9 +2913,10 @@ func_convert_path_check ()
 # and appending REPL if ORIG matches BACKPAT.
 func_convert_path_front_back_pathsep ()
 {
-  $opt_debug
+  $debug_cmd
+
   case $4 in
-  $1 ) func_to_host_path_result="$3$func_to_host_path_result"
+  $1 ) func_to_host_path_result=$3$func_to_host_path_result
     ;;
   esac
   case $4 in
@@ -1646,7 +2930,7 @@ func_convert_path_front_back_pathsep ()
 ##################################################
 # $build to $host FILE NAME CONVERSION FUNCTIONS #
 ##################################################
-# invoked via `$to_host_file_cmd ARG'
+# invoked via '$to_host_file_cmd ARG'
 #
 # In each case, ARG is the path to be converted from $build to $host format.
 # Result will be available in $func_to_host_file_result.
@@ -1657,7 +2941,8 @@ func_convert_path_front_back_pathsep ()
 # in func_to_host_file_result.
 func_to_host_file ()
 {
-  $opt_debug
+  $debug_cmd
+
   $to_host_file_cmd "$1"
 }
 # end func_to_host_file
@@ -1669,7 +2954,8 @@ func_to_host_file ()
 # in (the comma separated) LAZY, no conversion takes place.
 func_to_tool_file ()
 {
-  $opt_debug
+  $debug_cmd
+
   case ,$2, in
     *,"$to_tool_file_cmd",*)
       func_to_tool_file_result=$1
@@ -1687,7 +2973,7 @@ func_to_tool_file ()
 # Copy ARG to func_to_host_file_result.
 func_convert_file_noop ()
 {
-  func_to_host_file_result="$1"
+  func_to_host_file_result=$1
 }
 # end func_convert_file_noop
 
@@ -1698,11 +2984,12 @@ func_convert_file_noop ()
 # func_to_host_file_result.
 func_convert_file_msys_to_w32 ()
 {
-  $opt_debug
-  func_to_host_file_result="$1"
+  $debug_cmd
+
+  func_to_host_file_result=$1
   if test -n "$1"; then
     func_convert_core_msys_to_w32 "$1"
-    func_to_host_file_result="$func_convert_core_msys_to_w32_result"
+    func_to_host_file_result=$func_convert_core_msys_to_w32_result
   fi
   func_convert_file_check "$1" "$func_to_host_file_result"
 }
@@ -1714,8 +3001,9 @@ func_convert_file_msys_to_w32 ()
 # func_to_host_file_result.
 func_convert_file_cygwin_to_w32 ()
 {
-  $opt_debug
-  func_to_host_file_result="$1"
+  $debug_cmd
+
+  func_to_host_file_result=$1
   if test -n "$1"; then
     # because $build is cygwin, we call "the" cygpath in $PATH; no need to use
     # LT_CYGPATH in this case.
@@ -1731,11 +3019,12 @@ func_convert_file_cygwin_to_w32 ()
 # and a working winepath. Returns result in func_to_host_file_result.
 func_convert_file_nix_to_w32 ()
 {
-  $opt_debug
-  func_to_host_file_result="$1"
+  $debug_cmd
+
+  func_to_host_file_result=$1
   if test -n "$1"; then
     func_convert_core_file_wine_to_w32 "$1"
-    func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"
+    func_to_host_file_result=$func_convert_core_file_wine_to_w32_result
   fi
   func_convert_file_check "$1" "$func_to_host_file_result"
 }
@@ -1747,12 +3036,13 @@ func_convert_file_nix_to_w32 ()
 # Returns result in func_to_host_file_result.
 func_convert_file_msys_to_cygwin ()
 {
-  $opt_debug
-  func_to_host_file_result="$1"
+  $debug_cmd
+
+  func_to_host_file_result=$1
   if test -n "$1"; then
     func_convert_core_msys_to_w32 "$1"
     func_cygpath -u "$func_convert_core_msys_to_w32_result"
-    func_to_host_file_result="$func_cygpath_result"
+    func_to_host_file_result=$func_cygpath_result
   fi
   func_convert_file_check "$1" "$func_to_host_file_result"
 }
@@ -1765,13 +3055,14 @@ func_convert_file_msys_to_cygwin ()
 # in func_to_host_file_result.
 func_convert_file_nix_to_cygwin ()
 {
-  $opt_debug
-  func_to_host_file_result="$1"
+  $debug_cmd
+
+  func_to_host_file_result=$1
   if test -n "$1"; then
     # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
     func_convert_core_file_wine_to_w32 "$1"
     func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
-    func_to_host_file_result="$func_cygpath_result"
+    func_to_host_file_result=$func_cygpath_result
   fi
   func_convert_file_check "$1" "$func_to_host_file_result"
 }
@@ -1781,7 +3072,7 @@ func_convert_file_nix_to_cygwin ()
 #############################################
 # $build to $host PATH CONVERSION FUNCTIONS #
 #############################################
-# invoked via `$to_host_path_cmd ARG'
+# invoked via '$to_host_path_cmd ARG'
 #
 # In each case, ARG is the path to be converted from $build to $host format.
 # The result will be available in $func_to_host_path_result.
@@ -1805,10 +3096,11 @@ func_convert_file_nix_to_cygwin ()
 to_host_path_cmd=
 func_init_to_host_path_cmd ()
 {
-  $opt_debug
+  $debug_cmd
+
   if test -z "$to_host_path_cmd"; then
     func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
-    to_host_path_cmd="func_convert_path_${func_stripname_result}"
+    to_host_path_cmd=func_convert_path_$func_stripname_result
   fi
 }
 
@@ -1818,7 +3110,8 @@ func_init_to_host_path_cmd ()
 # in func_to_host_path_result.
 func_to_host_path ()
 {
-  $opt_debug
+  $debug_cmd
+
   func_init_to_host_path_cmd
   $to_host_path_cmd "$1"
 }
@@ -1829,7 +3122,7 @@ func_to_host_path ()
 # Copy ARG to func_to_host_path_result.
 func_convert_path_noop ()
 {
-  func_to_host_path_result="$1"
+  func_to_host_path_result=$1
 }
 # end func_convert_path_noop
 
@@ -1840,8 +3133,9 @@ func_convert_path_noop ()
 # func_to_host_path_result.
 func_convert_path_msys_to_w32 ()
 {
-  $opt_debug
-  func_to_host_path_result="$1"
+  $debug_cmd
+
+  func_to_host_path_result=$1
   if test -n "$1"; then
     # Remove leading and trailing path separator characters from ARG.  MSYS
     # behavior is inconsistent here; cygpath turns them into '.;' and ';.';
@@ -1849,7 +3143,7 @@ func_convert_path_msys_to_w32 ()
     func_stripname : : "$1"
     func_to_host_path_tmp1=$func_stripname_result
     func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
-    func_to_host_path_result="$func_convert_core_msys_to_w32_result"
+    func_to_host_path_result=$func_convert_core_msys_to_w32_result
     func_convert_path_check : ";" \
       "$func_to_host_path_tmp1" "$func_to_host_path_result"
     func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
@@ -1863,8 +3157,9 @@ func_convert_path_msys_to_w32 ()
 # func_to_host_file_result.
 func_convert_path_cygwin_to_w32 ()
 {
-  $opt_debug
-  func_to_host_path_result="$1"
+  $debug_cmd
+
+  func_to_host_path_result=$1
   if test -n "$1"; then
     # See func_convert_path_msys_to_w32:
     func_stripname : : "$1"
@@ -1883,14 +3178,15 @@ func_convert_path_cygwin_to_w32 ()
 # a working winepath.  Returns result in func_to_host_file_result.
 func_convert_path_nix_to_w32 ()
 {
-  $opt_debug
-  func_to_host_path_result="$1"
+  $debug_cmd
+
+  func_to_host_path_result=$1
   if test -n "$1"; then
     # See func_convert_path_msys_to_w32:
     func_stripname : : "$1"
     func_to_host_path_tmp1=$func_stripname_result
     func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
-    func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"
+    func_to_host_path_result=$func_convert_core_path_wine_to_w32_result
     func_convert_path_check : ";" \
       "$func_to_host_path_tmp1" "$func_to_host_path_result"
     func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
@@ -1904,15 +3200,16 @@ func_convert_path_nix_to_w32 ()
 # Returns result in func_to_host_file_result.
 func_convert_path_msys_to_cygwin ()
 {
-  $opt_debug
-  func_to_host_path_result="$1"
+  $debug_cmd
+
+  func_to_host_path_result=$1
   if test -n "$1"; then
     # See func_convert_path_msys_to_w32:
     func_stripname : : "$1"
     func_to_host_path_tmp1=$func_stripname_result
     func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
     func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
-    func_to_host_path_result="$func_cygpath_result"
+    func_to_host_path_result=$func_cygpath_result
     func_convert_path_check : : \
       "$func_to_host_path_tmp1" "$func_to_host_path_result"
     func_convert_path_front_back_pathsep ":*" "*:" : "$1"
@@ -1927,8 +3224,9 @@ func_convert_path_msys_to_cygwin ()
 # func_to_host_file_result.
 func_convert_path_nix_to_cygwin ()
 {
-  $opt_debug
-  func_to_host_path_result="$1"
+  $debug_cmd
+
+  func_to_host_path_result=$1
   if test -n "$1"; then
     # Remove leading and trailing path separator characters from
     # ARG. msys behavior is inconsistent here, cygpath turns them
@@ -1937,7 +3235,7 @@ func_convert_path_nix_to_cygwin ()
     func_to_host_path_tmp1=$func_stripname_result
     func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
     func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
-    func_to_host_path_result="$func_cygpath_result"
+    func_to_host_path_result=$func_cygpath_result
     func_convert_path_check : : \
       "$func_to_host_path_tmp1" "$func_to_host_path_result"
     func_convert_path_front_back_pathsep ":*" "*:" : "$1"
@@ -1946,13 +3244,31 @@ func_convert_path_nix_to_cygwin ()
 # end func_convert_path_nix_to_cygwin
 
 
+# func_dll_def_p FILE
+# True iff FILE is a Windows DLL '.def' file.
+# Keep in sync with _LT_DLL_DEF_P in libtool.m4
+func_dll_def_p ()
+{
+  $debug_cmd
+
+  func_dll_def_p_tmp=`$SED -n \
+    -e 's/^[	 ]*//' \
+    -e '/^\(;.*\)*$/d' \
+    -e 's/^\(EXPORTS\|LIBRARY\)\([	 ].*\)*$/DEF/p' \
+    -e q \
+    "$1"`
+  test DEF = "$func_dll_def_p_tmp"
+}
+
+
 # func_mode_compile arg...
 func_mode_compile ()
 {
-    $opt_debug
+    $debug_cmd
+
     # Get the compilation command and the source file.
     base_compile=
-    srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
+    srcfile=$nonopt  #  always keep a non-empty value in "srcfile"
     suppress_opt=yes
     suppress_output=
     arg_mode=normal
@@ -1965,12 +3281,12 @@ func_mode_compile ()
       case $arg_mode in
       arg  )
 	# do not "continue".  Instead, add this to base_compile
-	lastarg="$arg"
+	lastarg=$arg
 	arg_mode=normal
 	;;
 
       target )
-	libobj="$arg"
+	libobj=$arg
 	arg_mode=normal
 	continue
 	;;
@@ -1980,7 +3296,7 @@ func_mode_compile ()
 	case $arg in
 	-o)
 	  test -n "$libobj" && \
-	    func_fatal_error "you cannot specify \`-o' more than once"
+	    func_fatal_error "you cannot specify '-o' more than once"
 	  arg_mode=target
 	  continue
 	  ;;
@@ -2009,12 +3325,12 @@ func_mode_compile ()
 	  func_stripname '-Wc,' '' "$arg"
 	  args=$func_stripname_result
 	  lastarg=
-	  save_ifs="$IFS"; IFS=','
+	  save_ifs=$IFS; IFS=,
 	  for arg in $args; do
-	    IFS="$save_ifs"
+	    IFS=$save_ifs
 	    func_append_quoted lastarg "$arg"
 	  done
-	  IFS="$save_ifs"
+	  IFS=$save_ifs
 	  func_stripname ' ' '' "$lastarg"
 	  lastarg=$func_stripname_result
 
@@ -2027,8 +3343,8 @@ func_mode_compile ()
 	  # Accept the current argument as the source file.
 	  # The previous "srcfile" becomes the current argument.
 	  #
-	  lastarg="$srcfile"
-	  srcfile="$arg"
+	  lastarg=$srcfile
+	  srcfile=$arg
 	  ;;
 	esac  #  case $arg
 	;;
@@ -2043,13 +3359,13 @@ func_mode_compile ()
       func_fatal_error "you must specify an argument for -Xcompile"
       ;;
     target)
-      func_fatal_error "you must specify a target with \`-o'"
+      func_fatal_error "you must specify a target with '-o'"
       ;;
     *)
       # Get the name of the library object.
       test -z "$libobj" && {
 	func_basename "$srcfile"
-	libobj="$func_basename_result"
+	libobj=$func_basename_result
       }
       ;;
     esac
@@ -2069,7 +3385,7 @@ func_mode_compile ()
     case $libobj in
     *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
     *)
-      func_fatal_error "cannot determine name of library object from \`$libobj'"
+      func_fatal_error "cannot determine name of library object from '$libobj'"
       ;;
     esac
 
@@ -2078,8 +3394,8 @@ func_mode_compile ()
     for arg in $later; do
       case $arg in
       -shared)
-	test "$build_libtool_libs" != yes && \
-	  func_fatal_configuration "can not build a shared library"
+	test yes = "$build_libtool_libs" \
+	  || func_fatal_configuration "cannot build a shared library"
 	build_old_libs=no
 	continue
 	;;
@@ -2105,17 +3421,17 @@ func_mode_compile ()
     func_quote_for_eval "$libobj"
     test "X$libobj" != "X$func_quote_for_eval_result" \
       && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"'	 &()|`$[]' \
-      && func_warning "libobj name \`$libobj' may not contain shell special characters."
+      && func_warning "libobj name '$libobj' may not contain shell special characters."
     func_dirname_and_basename "$obj" "/" ""
-    objname="$func_basename_result"
-    xdir="$func_dirname_result"
-    lobj=${xdir}$objdir/$objname
+    objname=$func_basename_result
+    xdir=$func_dirname_result
+    lobj=$xdir$objdir/$objname
 
     test -z "$base_compile" && \
       func_fatal_help "you must specify a compilation command"
 
     # Delete any leftover library objects.
-    if test "$build_old_libs" = yes; then
+    if test yes = "$build_old_libs"; then
       removelist="$obj $lobj $libobj ${libobj}T"
     else
       removelist="$lobj $libobj ${libobj}T"
@@ -2127,16 +3443,16 @@ func_mode_compile ()
       pic_mode=default
       ;;
     esac
-    if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
+    if test no = "$pic_mode" && test pass_all != "$deplibs_check_method"; then
       # non-PIC code in shared libraries is not supported
       pic_mode=default
     fi
 
     # Calculate the filename of the output object if compiler does
     # not support -o with -c
-    if test "$compiler_c_o" = no; then
-      output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
-      lockfile="$output_obj.lock"
+    if test no = "$compiler_c_o"; then
+      output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.$objext
+      lockfile=$output_obj.lock
     else
       output_obj=
       need_locks=no
@@ -2145,12 +3461,12 @@ func_mode_compile ()
 
     # Lock this critical section if it is needed
     # We use this script file to make the link, it avoids creating a new file
-    if test "$need_locks" = yes; then
+    if test yes = "$need_locks"; then
       until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
 	func_echo "Waiting for $lockfile to be removed"
 	sleep 2
       done
-    elif test "$need_locks" = warn; then
+    elif test warn = "$need_locks"; then
       if test -f "$lockfile"; then
 	$ECHO "\
 *** ERROR, $lockfile exists and contains:
@@ -2158,7 +3474,7 @@ func_mode_compile ()
 
 This indicates that another process is trying to use the same
 temporary object file, and libtool could not work around it because
-your compiler does not support \`-c' and \`-o' together.  If you
+your compiler does not support '-c' and '-o' together.  If you
 repeat this compilation, it may succeed, by chance, but you had better
 avoid parallel builds (make -j) in this platform, or get a better
 compiler."
@@ -2180,11 +3496,11 @@ compiler."
     qsrcfile=$func_quote_for_eval_result
 
     # Only build a PIC object if we are building libtool libraries.
-    if test "$build_libtool_libs" = yes; then
+    if test yes = "$build_libtool_libs"; then
       # Without this assignment, base_compile gets emptied.
       fbsd_hideous_sh_bug=$base_compile
 
-      if test "$pic_mode" != no; then
+      if test no != "$pic_mode"; then
 	command="$base_compile $qsrcfile $pic_flag"
       else
 	# Don't build PIC code
@@ -2201,7 +3517,7 @@ compiler."
       func_show_eval_locale "$command"	\
           'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
 
-      if test "$need_locks" = warn &&
+      if test warn = "$need_locks" &&
 	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
 	$ECHO "\
 *** ERROR, $lockfile contains:
@@ -2212,7 +3528,7 @@ $srcfile
 
 This indicates that another process is trying to use the same
 temporary object file, and libtool could not work around it because
-your compiler does not support \`-c' and \`-o' together.  If you
+your compiler does not support '-c' and '-o' together.  If you
 repeat this compilation, it may succeed, by chance, but you had better
 avoid parallel builds (make -j) in this platform, or get a better
 compiler."
@@ -2228,20 +3544,20 @@ compiler."
       fi
 
       # Allow error messages only from the first compilation.
-      if test "$suppress_opt" = yes; then
+      if test yes = "$suppress_opt"; then
 	suppress_output=' >/dev/null 2>&1'
       fi
     fi
 
     # Only build a position-dependent object if we build old libraries.
-    if test "$build_old_libs" = yes; then
-      if test "$pic_mode" != yes; then
+    if test yes = "$build_old_libs"; then
+      if test yes != "$pic_mode"; then
 	# Don't build PIC code
 	command="$base_compile $qsrcfile$pie_flag"
       else
 	command="$base_compile $qsrcfile $pic_flag"
       fi
-      if test "$compiler_c_o" = yes; then
+      if test yes = "$compiler_c_o"; then
 	func_append command " -o $obj"
       fi
 
@@ -2250,7 +3566,7 @@ compiler."
       func_show_eval_locale "$command" \
         '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
 
-      if test "$need_locks" = warn &&
+      if test warn = "$need_locks" &&
 	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
 	$ECHO "\
 *** ERROR, $lockfile contains:
@@ -2261,7 +3577,7 @@ $srcfile
 
 This indicates that another process is trying to use the same
 temporary object file, and libtool could not work around it because
-your compiler does not support \`-c' and \`-o' together.  If you
+your compiler does not support '-c' and '-o' together.  If you
 repeat this compilation, it may succeed, by chance, but you had better
 avoid parallel builds (make -j) in this platform, or get a better
 compiler."
@@ -2281,7 +3597,7 @@ compiler."
       func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
 
       # Unlock the critical section if it was locked
-      if test "$need_locks" != no; then
+      if test no != "$need_locks"; then
 	removelist=$lockfile
         $RM "$lockfile"
       fi
@@ -2291,7 +3607,7 @@ compiler."
 }
 
 $opt_help || {
-  test "$opt_mode" = compile && func_mode_compile ${1+"$@"}
+  test compile = "$opt_mode" && func_mode_compile ${1+"$@"}
 }
 
 func_mode_help ()
@@ -2311,7 +3627,7 @@ func_mode_help ()
 Remove files from the build directory.
 
 RM is the name of the program to use to delete files associated with each FILE
-(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
+(typically '/bin/rm').  RM-OPTIONS are options (such as '-f') to be passed
 to RM.
 
 If FILE is a libtool library, object or program, all the files associated
@@ -2330,16 +3646,17 @@ This mode accepts the following additional options:
   -no-suppress      do not suppress compiler output for multiple passes
   -prefer-pic       try to build PIC objects only
   -prefer-non-pic   try to build non-PIC objects only
-  -shared           do not build a \`.o' file suitable for static linking
-  -static           only build a \`.o' file suitable for static linking
-  -Wc,FLAG          pass FLAG directly to the compiler
+  -shared           do not build a '.o' file suitable for static linking
+  -static           only build a '.o' file suitable for static linking
+  -Wc,FLAG
+  -Xcompiler FLAG   pass FLAG directly to the compiler
 
-COMPILE-COMMAND is a command to be used in creating a \`standard' object file
+COMPILE-COMMAND is a command to be used in creating a 'standard' object file
 from the given SOURCEFILE.
 
 The output file name is determined by removing the directory component from
-SOURCEFILE, then substituting the C source code suffix \`.c' with the
-library object suffix, \`.lo'."
+SOURCEFILE, then substituting the C source code suffix '.c' with the
+library object suffix, '.lo'."
         ;;
 
       execute)
@@ -2352,7 +3669,7 @@ This mode accepts the following additional options:
 
   -dlopen FILE      add the directory containing FILE to the library path
 
-This mode sets the library path environment variable according to \`-dlopen'
+This mode sets the library path environment variable according to '-dlopen'
 flags.
 
 If any of the ARGS are libtool executable wrappers, then they are translated
@@ -2371,7 +3688,7 @@ Complete the installation of libtool libraries.
 Each LIBDIR is a directory that contains libtool libraries.
 
 The commands that this mode executes may require superuser privileges.  Use
-the \`--dry-run' option if you just want to see what would be executed."
+the '--dry-run' option if you just want to see what would be executed."
         ;;
 
       install)
@@ -2381,7 +3698,7 @@ the \`--dry-run' option if you just want to see what would be executed."
 Install executables or libraries.
 
 INSTALL-COMMAND is the installation command.  The first component should be
-either the \`install' or \`cp' program.
+either the 'install' or 'cp' program.
 
 The following components of INSTALL-COMMAND are treated specially:
 
@@ -2407,7 +3724,7 @@ The following components of LINK-COMMAND are treated specially:
   -avoid-version    do not add a version suffix if possible
   -bindir BINDIR    specify path to binaries directory (for systems where
                     libraries must be found in the PATH setting at runtime)
-  -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
+  -dlopen FILE      '-dlpreopen' FILE if it cannot be dlopened at runtime
   -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
   -export-symbols SYMFILE
@@ -2421,7 +3738,8 @@ The following components of LINK-COMMAND are treated specially:
   -no-install       link a not-installable executable
   -no-undefined     declare that a library does not refer to external symbols
   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
-  -objectlist FILE  Use a list of object files found in FILE to specify objects
+  -objectlist FILE  use a list of object files found in FILE to specify objects
+  -os2dllname NAME  force a short DLL name on OS/2 (no effect on other OSes)
   -precious-files-regex REGEX
                     don't remove output files matching REGEX
   -release RELEASE  specify package release information
@@ -2437,24 +3755,26 @@ The following components of LINK-COMMAND are treated specially:
   -weak LIBNAME     declare that the target provides the LIBNAME interface
   -Wc,FLAG
   -Xcompiler FLAG   pass linker-specific FLAG directly to the compiler
+  -Wa,FLAG
+  -Xassembler FLAG  pass linker-specific FLAG directly to the assembler
   -Wl,FLAG
   -Xlinker FLAG     pass linker-specific FLAG directly to the linker
   -XCClinker FLAG   pass link-specific FLAG to the compiler driver (CC)
 
-All other options (arguments beginning with \`-') are ignored.
+All other options (arguments beginning with '-') are ignored.
 
-Every other argument is treated as a filename.  Files ending in \`.la' are
+Every other argument is treated as a filename.  Files ending in '.la' are
 treated as uninstalled libtool libraries, other files are standard or library
 object files.
 
-If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
-only library objects (\`.lo' files) may be specified, and \`-rpath' is
+If the OUTPUT-FILE ends in '.la', then a libtool library is created,
+only library objects ('.lo' files) may be specified, and '-rpath' is
 required, except when creating a convenience library.
 
-If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
-using \`ar' and \`ranlib', or on Windows using \`lib'.
+If OUTPUT-FILE ends in '.a' or '.lib', then a standard library is created
+using 'ar' and 'ranlib', or on Windows using 'lib'.
 
-If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
+If OUTPUT-FILE ends in '.lo' or '.$objext', then a reloadable object file
 is created, otherwise an executable program is created."
         ;;
 
@@ -2465,7 +3785,7 @@ is created, otherwise an executable program is created."
 Remove libraries from an installation directory.
 
 RM is the name of the program to use to delete files associated with each FILE
-(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
+(typically '/bin/rm').  RM-OPTIONS are options (such as '-f') to be passed
 to RM.
 
 If FILE is a libtool library, all the files associated with it are deleted.
@@ -2473,17 +3793,17 @@ Otherwise, only FILE itself is deleted using RM."
         ;;
 
       *)
-        func_fatal_help "invalid operation mode \`$opt_mode'"
+        func_fatal_help "invalid operation mode '$opt_mode'"
         ;;
     esac
 
     echo
-    $ECHO "Try \`$progname --help' for more information about other modes."
+    $ECHO "Try '$progname --help' for more information about other modes."
 }
 
 # Now that we've collected a possible --mode arg, show help if necessary
 if $opt_help; then
-  if test "$opt_help" = :; then
+  if test : = "$opt_help"; then
     func_mode_help
   else
     {
@@ -2491,7 +3811,7 @@ if $opt_help; then
       for opt_mode in compile link execute install finish uninstall clean; do
 	func_mode_help
       done
-    } | sed -n '1p; 2,$s/^Usage:/  or: /p'
+    } | $SED -n '1p; 2,$s/^Usage:/  or: /p'
     {
       func_help noexit
       for opt_mode in compile link execute install finish uninstall clean; do
@@ -2499,7 +3819,7 @@ if $opt_help; then
 	func_mode_help
       done
     } |
-    sed '1d
+    $SED '1d
       /^When reporting/,/^Report/{
 	H
 	d
@@ -2516,16 +3836,17 @@ fi
 # func_mode_execute arg...
 func_mode_execute ()
 {
-    $opt_debug
+    $debug_cmd
+
     # The first argument is the command name.
-    cmd="$nonopt"
+    cmd=$nonopt
     test -z "$cmd" && \
       func_fatal_help "you must specify a COMMAND"
 
     # Handle -dlopen flags immediately.
     for file in $opt_dlopen; do
       test -f "$file" \
-	|| func_fatal_help "\`$file' is not a file"
+	|| func_fatal_help "'$file' is not a file"
 
       dir=
       case $file in
@@ -2535,7 +3856,7 @@ func_mode_execute ()
 
 	# Check to see that this really is a libtool archive.
 	func_lalib_unsafe_p "$file" \
-	  || func_fatal_help "\`$lib' is not a valid libtool archive"
+	  || func_fatal_help "'$lib' is not a valid libtool archive"
 
 	# Read the libtool library.
 	dlname=
@@ -2546,18 +3867,18 @@ func_mode_execute ()
 	if test -z "$dlname"; then
 	  # Warn if it was a shared library.
 	  test -n "$library_names" && \
-	    func_warning "\`$file' was not linked with \`-export-dynamic'"
+	    func_warning "'$file' was not linked with '-export-dynamic'"
 	  continue
 	fi
 
 	func_dirname "$file" "" "."
-	dir="$func_dirname_result"
+	dir=$func_dirname_result
 
 	if test -f "$dir/$objdir/$dlname"; then
 	  func_append dir "/$objdir"
 	else
 	  if test ! -f "$dir/$dlname"; then
-	    func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
+	    func_fatal_error "cannot find '$dlname' in '$dir' or '$dir/$objdir'"
 	  fi
 	fi
 	;;
@@ -2565,18 +3886,18 @@ func_mode_execute ()
       *.lo)
 	# Just add the directory containing the .lo file.
 	func_dirname "$file" "" "."
-	dir="$func_dirname_result"
+	dir=$func_dirname_result
 	;;
 
       *)
-	func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
+	func_warning "'-dlopen' is ignored for non-libtool libraries and objects"
 	continue
 	;;
       esac
 
       # Get the absolute pathname.
       absdir=`cd "$dir" && pwd`
-      test -n "$absdir" && dir="$absdir"
+      test -n "$absdir" && dir=$absdir
 
       # Now add the directory to shlibpath_var.
       if eval "test -z \"\$$shlibpath_var\""; then
@@ -2588,7 +3909,7 @@ func_mode_execute ()
 
     # This variable tells wrapper scripts just to set shlibpath_var
     # rather than running their programs.
-    libtool_execute_magic="$magic"
+    libtool_execute_magic=$magic
 
     # Check if any of the arguments is a wrapper script.
     args=
@@ -2601,12 +3922,12 @@ func_mode_execute ()
 	if func_ltwrapper_script_p "$file"; then
 	  func_source "$file"
 	  # Transform arg to wrapped name.
-	  file="$progdir/$program"
+	  file=$progdir/$program
 	elif func_ltwrapper_executable_p "$file"; then
 	  func_ltwrapper_scriptname "$file"
 	  func_source "$func_ltwrapper_scriptname_result"
 	  # Transform arg to wrapped name.
-	  file="$progdir/$program"
+	  file=$progdir/$program
 	fi
 	;;
       esac
@@ -2614,7 +3935,15 @@ func_mode_execute ()
       func_append_quoted args "$file"
     done
 
-    if test "X$opt_dry_run" = Xfalse; then
+    if $opt_dry_run; then
+      # Display what would be done.
+      if test -n "$shlibpath_var"; then
+	eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
+	echo "export $shlibpath_var"
+      fi
+      $ECHO "$cmd$args"
+      exit $EXIT_SUCCESS
+    else
       if test -n "$shlibpath_var"; then
 	# Export the shlibpath_var.
 	eval "export $shlibpath_var"
@@ -2631,25 +3960,18 @@ func_mode_execute ()
       done
 
       # Now prepare to actually exec the command.
-      exec_cmd="\$cmd$args"
-    else
-      # Display what would be done.
-      if test -n "$shlibpath_var"; then
-	eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
-	echo "export $shlibpath_var"
-      fi
-      $ECHO "$cmd$args"
-      exit $EXIT_SUCCESS
+      exec_cmd=\$cmd$args
     fi
 }
 
-test "$opt_mode" = execute && func_mode_execute ${1+"$@"}
+test execute = "$opt_mode" && func_mode_execute ${1+"$@"}
 
 
 # func_mode_finish arg...
 func_mode_finish ()
 {
-    $opt_debug
+    $debug_cmd
+
     libs=
     libdirs=
     admincmds=
@@ -2663,11 +3985,11 @@ func_mode_finish ()
 	if func_lalib_unsafe_p "$opt"; then
 	  func_append libs " $opt"
 	else
-	  func_warning "\`$opt' is not a valid libtool archive"
+	  func_warning "'$opt' is not a valid libtool archive"
 	fi
 
       else
-	func_fatal_error "invalid argument \`$opt'"
+	func_fatal_error "invalid argument '$opt'"
       fi
     done
 
@@ -2682,12 +4004,12 @@ func_mode_finish ()
       # Remove sysroot references
       if $opt_dry_run; then
         for lib in $libs; do
-          echo "removing references to $lt_sysroot and \`=' prefixes from $lib"
+          echo "removing references to $lt_sysroot and '=' prefixes from $lib"
         done
       else
         tmpdir=`func_mktempdir`
         for lib in $libs; do
-	  sed -e "${sysroot_cmd} s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
+	  $SED -e "$sysroot_cmd s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
 	    > $tmpdir/tmp-la
 	  mv -f $tmpdir/tmp-la $lib
 	done
@@ -2712,7 +4034,7 @@ func_mode_finish ()
     fi
 
     # Exit here if they wanted silent mode.
-    $opt_silent && exit $EXIT_SUCCESS
+    $opt_quiet && exit $EXIT_SUCCESS
 
     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
       echo "----------------------------------------------------------------------"
@@ -2723,27 +4045,27 @@ func_mode_finish ()
       echo
       echo "If you ever happen to want to link against installed libraries"
       echo "in a given directory, LIBDIR, you must either use libtool, and"
-      echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
+      echo "specify the full pathname of the library, or use the '-LLIBDIR'"
       echo "flag during linking and do at least one of the following:"
       if test -n "$shlibpath_var"; then
-	echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
+	echo "   - add LIBDIR to the '$shlibpath_var' environment variable"
 	echo "     during execution"
       fi
       if test -n "$runpath_var"; then
-	echo "   - add LIBDIR to the \`$runpath_var' environment variable"
+	echo "   - add LIBDIR to the '$runpath_var' environment variable"
 	echo "     during linking"
       fi
       if test -n "$hardcode_libdir_flag_spec"; then
 	libdir=LIBDIR
 	eval flag=\"$hardcode_libdir_flag_spec\"
 
-	$ECHO "   - use the \`$flag' linker flag"
+	$ECHO "   - use the '$flag' linker flag"
       fi
       if test -n "$admincmds"; then
 	$ECHO "   - have your system administrator run these commands:$admincmds"
       fi
       if test -f /etc/ld.so.conf; then
-	echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
+	echo "   - have your system administrator add LIBDIR to '/etc/ld.so.conf'"
       fi
       echo
 
@@ -2762,18 +4084,20 @@ func_mode_finish ()
     exit $EXIT_SUCCESS
 }
 
-test "$opt_mode" = finish && func_mode_finish ${1+"$@"}
+test finish = "$opt_mode" && func_mode_finish ${1+"$@"}
 
 
 # func_mode_install arg...
 func_mode_install ()
 {
-    $opt_debug
+    $debug_cmd
+
     # There may be an optional sh(1) argument at the beginning of
     # install_prog (especially on Windows NT).
-    if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
+    if test "$SHELL" = "$nonopt" || test /bin/sh = "$nonopt" ||
        # Allow the use of GNU shtool's install command.
-       case $nonopt in *shtool*) :;; *) false;; esac; then
+       case $nonopt in *shtool*) :;; *) false;; esac
+    then
       # Aesthetically quote it.
       func_quote_for_eval "$nonopt"
       install_prog="$func_quote_for_eval_result "
@@ -2800,7 +4124,7 @@ func_mode_install ()
     opts=
     prev=
     install_type=
-    isdir=no
+    isdir=false
     stripme=
     no_mode=:
     for arg
@@ -2813,7 +4137,7 @@ func_mode_install ()
       fi
 
       case $arg in
-      -d) isdir=yes ;;
+      -d) isdir=: ;;
       -f)
 	if $install_cp; then :; else
 	  prev=$arg
@@ -2831,7 +4155,7 @@ func_mode_install ()
       *)
 	# If the previous option needed an argument, then skip it.
 	if test -n "$prev"; then
-	  if test "x$prev" = x-m && test -n "$install_override_mode"; then
+	  if test X-m = "X$prev" && test -n "$install_override_mode"; then
 	    arg2=$install_override_mode
 	    no_mode=false
 	  fi
@@ -2856,7 +4180,7 @@ func_mode_install ()
       func_fatal_help "you must specify an install program"
 
     test -n "$prev" && \
-      func_fatal_help "the \`$prev' option requires an argument"
+      func_fatal_help "the '$prev' option requires an argument"
 
     if test -n "$install_override_mode" && $no_mode; then
       if $install_cp; then :; else
@@ -2878,19 +4202,19 @@ func_mode_install ()
     dest=$func_stripname_result
 
     # Check to see that the destination is a directory.
-    test -d "$dest" && isdir=yes
-    if test "$isdir" = yes; then
-      destdir="$dest"
+    test -d "$dest" && isdir=:
+    if $isdir; then
+      destdir=$dest
       destname=
     else
       func_dirname_and_basename "$dest" "" "."
-      destdir="$func_dirname_result"
-      destname="$func_basename_result"
+      destdir=$func_dirname_result
+      destname=$func_basename_result
 
       # Not a directory, so check to see that there is only one file specified.
       set dummy $files; shift
       test "$#" -gt 1 && \
-	func_fatal_help "\`$dest' is not a directory"
+	func_fatal_help "'$dest' is not a directory"
     fi
     case $destdir in
     [\\/]* | [A-Za-z]:[\\/]*) ;;
@@ -2899,7 +4223,7 @@ func_mode_install ()
 	case $file in
 	*.lo) ;;
 	*)
-	  func_fatal_help "\`$destdir' must be an absolute directory name"
+	  func_fatal_help "'$destdir' must be an absolute directory name"
 	  ;;
 	esac
       done
@@ -2908,7 +4232,7 @@ func_mode_install ()
 
     # This variable tells wrapper scripts just to set variables rather
     # than running their programs.
-    libtool_install_magic="$magic"
+    libtool_install_magic=$magic
 
     staticlibs=
     future_libdirs=
@@ -2928,7 +4252,7 @@ func_mode_install ()
 
 	# Check to see that this really is a libtool archive.
 	func_lalib_unsafe_p "$file" \
-	  || func_fatal_help "\`$file' is not a valid libtool archive"
+	  || func_fatal_help "'$file' is not a valid libtool archive"
 
 	library_names=
 	old_library=
@@ -2950,7 +4274,7 @@ func_mode_install ()
 	fi
 
 	func_dirname "$file" "/" ""
-	dir="$func_dirname_result"
+	dir=$func_dirname_result
 	func_append dir "$objdir"
 
 	if test -n "$relink_command"; then
@@ -2964,7 +4288,7 @@ func_mode_install ()
 	  # are installed into $libdir/../bin (currently, that works fine)
 	  # but it's something to keep an eye on.
 	  test "$inst_prefix_dir" = "$destdir" && \
-	    func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
+	    func_fatal_error "error: cannot install '$file' to a directory not ending in $libdir"
 
 	  if test -n "$inst_prefix_dir"; then
 	    # Stick the inst_prefix_dir data into the link command.
@@ -2973,29 +4297,36 @@ func_mode_install ()
 	    relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
 	  fi
 
-	  func_warning "relinking \`$file'"
+	  func_warning "relinking '$file'"
 	  func_show_eval "$relink_command" \
-	    'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
+	    'func_fatal_error "error: relink '\''$file'\'' with the above command before installing it"'
 	fi
 
 	# See the names of the shared library.
 	set dummy $library_names; shift
 	if test -n "$1"; then
-	  realname="$1"
+	  realname=$1
 	  shift
 
-	  srcname="$realname"
-	  test -n "$relink_command" && srcname="$realname"T
+	  srcname=$realname
+	  test -n "$relink_command" && srcname=${realname}T
 
 	  # Install the shared library and build the symlinks.
 	  func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
 	      'exit $?'
-	  tstripme="$stripme"
+	  tstripme=$stripme
 	  case $host_os in
 	  cygwin* | mingw* | pw32* | cegcc*)
 	    case $realname in
 	    *.dll.a)
-	      tstripme=""
+	      tstripme=
+	      ;;
+	    esac
+	    ;;
+	  os2*)
+	    case $realname in
+	    *_dll.a)
+	      tstripme=
 	      ;;
 	    esac
 	    ;;
@@ -3006,7 +4337,7 @@ func_mode_install ()
 
 	  if test "$#" -gt 0; then
 	    # Delete the old symlinks, and create new ones.
-	    # Try `ln -sf' first, because the `ln' binary might depend on
+	    # Try 'ln -sf' first, because the 'ln' binary might depend on
 	    # the symlink we replace!  Solaris /bin/ln does not understand -f,
 	    # so we also need to try rm && ln -s.
 	    for linkname
@@ -3017,14 +4348,14 @@ func_mode_install ()
 	  fi
 
 	  # Do each command in the postinstall commands.
-	  lib="$destdir/$realname"
+	  lib=$destdir/$realname
 	  func_execute_cmds "$postinstall_cmds" 'exit $?'
 	fi
 
 	# Install the pseudo-library for information purposes.
 	func_basename "$file"
-	name="$func_basename_result"
-	instname="$dir/$name"i
+	name=$func_basename_result
+	instname=$dir/${name}i
 	func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
 
 	# Maybe install the static library, too.
@@ -3036,11 +4367,11 @@ func_mode_install ()
 
 	# Figure out destination file name, if it wasn't already specified.
 	if test -n "$destname"; then
-	  destfile="$destdir/$destname"
+	  destfile=$destdir/$destname
 	else
 	  func_basename "$file"
-	  destfile="$func_basename_result"
-	  destfile="$destdir/$destfile"
+	  destfile=$func_basename_result
+	  destfile=$destdir/$destfile
 	fi
 
 	# Deduce the name of the destination old-style object file.
@@ -3050,11 +4381,11 @@ func_mode_install ()
 	  staticdest=$func_lo2o_result
 	  ;;
 	*.$objext)
-	  staticdest="$destfile"
+	  staticdest=$destfile
 	  destfile=
 	  ;;
 	*)
-	  func_fatal_help "cannot copy a libtool object to \`$destfile'"
+	  func_fatal_help "cannot copy a libtool object to '$destfile'"
 	  ;;
 	esac
 
@@ -3063,7 +4394,7 @@ func_mode_install ()
 	  func_show_eval "$install_prog $file $destfile" 'exit $?'
 
 	# Install the old object if enabled.
-	if test "$build_old_libs" = yes; then
+	if test yes = "$build_old_libs"; then
 	  # Deduce the name of the old-style object file.
 	  func_lo2o "$file"
 	  staticobj=$func_lo2o_result
@@ -3075,23 +4406,23 @@ func_mode_install ()
       *)
 	# Figure out destination file name, if it wasn't already specified.
 	if test -n "$destname"; then
-	  destfile="$destdir/$destname"
+	  destfile=$destdir/$destname
 	else
 	  func_basename "$file"
-	  destfile="$func_basename_result"
-	  destfile="$destdir/$destfile"
+	  destfile=$func_basename_result
+	  destfile=$destdir/$destfile
 	fi
 
 	# If the file is missing, and there is a .exe on the end, strip it
 	# because it is most likely a libtool script we actually want to
 	# install
-	stripped_ext=""
+	stripped_ext=
 	case $file in
 	  *.exe)
 	    if test ! -f "$file"; then
 	      func_stripname '' '.exe' "$file"
 	      file=$func_stripname_result
-	      stripped_ext=".exe"
+	      stripped_ext=.exe
 	    fi
 	    ;;
 	esac
@@ -3119,19 +4450,19 @@ func_mode_install ()
 
 	  # Check the variables that should have been set.
 	  test -z "$generated_by_libtool_version" && \
-	    func_fatal_error "invalid libtool wrapper script \`$wrapper'"
+	    func_fatal_error "invalid libtool wrapper script '$wrapper'"
 
-	  finalize=yes
+	  finalize=:
 	  for lib in $notinst_deplibs; do
 	    # Check to see that each library is installed.
 	    libdir=
 	    if test -f "$lib"; then
 	      func_source "$lib"
 	    fi
-	    libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
+	    libfile=$libdir/`$ECHO "$lib" | $SED 's%^.*/%%g'`
 	    if test -n "$libdir" && test ! -f "$libfile"; then
-	      func_warning "\`$lib' has not been installed in \`$libdir'"
-	      finalize=no
+	      func_warning "'$lib' has not been installed in '$libdir'"
+	      finalize=false
 	    fi
 	  done
 
@@ -3139,29 +4470,29 @@ func_mode_install ()
 	  func_source "$wrapper"
 
 	  outputname=
-	  if test "$fast_install" = no && test -n "$relink_command"; then
+	  if test no = "$fast_install" && test -n "$relink_command"; then
 	    $opt_dry_run || {
-	      if test "$finalize" = yes; then
+	      if $finalize; then
 	        tmpdir=`func_mktempdir`
 		func_basename "$file$stripped_ext"
-		file="$func_basename_result"
-	        outputname="$tmpdir/$file"
+		file=$func_basename_result
+	        outputname=$tmpdir/$file
 	        # Replace the output file specification.
 	        relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
 
-	        $opt_silent || {
+	        $opt_quiet || {
 	          func_quote_for_expand "$relink_command"
 		  eval "func_echo $func_quote_for_expand_result"
 	        }
 	        if eval "$relink_command"; then :
 	          else
-		  func_error "error: relink \`$file' with the above command before installing it"
+		  func_error "error: relink '$file' with the above command before installing it"
 		  $opt_dry_run || ${RM}r "$tmpdir"
 		  continue
 	        fi
-	        file="$outputname"
+	        file=$outputname
 	      else
-	        func_warning "cannot relink \`$file'"
+	        func_warning "cannot relink '$file'"
 	      fi
 	    }
 	  else
@@ -3198,10 +4529,10 @@ func_mode_install ()
 
     for file in $staticlibs; do
       func_basename "$file"
-      name="$func_basename_result"
+      name=$func_basename_result
 
       # Set up the ranlib parameters.
-      oldlib="$destdir/$name"
+      oldlib=$destdir/$name
       func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
       tool_oldlib=$func_to_tool_file_result
 
@@ -3216,18 +4547,18 @@ func_mode_install ()
     done
 
     test -n "$future_libdirs" && \
-      func_warning "remember to run \`$progname --finish$future_libdirs'"
+      func_warning "remember to run '$progname --finish$future_libdirs'"
 
     if test -n "$current_libdirs"; then
       # Maybe just do a dry run.
       $opt_dry_run && current_libdirs=" -n$current_libdirs"
-      exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
+      exec_cmd='$SHELL "$progpath" $preserve_args --finish$current_libdirs'
     else
       exit $EXIT_SUCCESS
     fi
 }
 
-test "$opt_mode" = install && func_mode_install ${1+"$@"}
+test install = "$opt_mode" && func_mode_install ${1+"$@"}
 
 
 # func_generate_dlsyms outputname originator pic_p
@@ -3235,16 +4566,17 @@ test "$opt_mode" = install && func_mode_install ${1+"$@"}
 # a dlpreopen symbol table.
 func_generate_dlsyms ()
 {
-    $opt_debug
-    my_outputname="$1"
-    my_originator="$2"
-    my_pic_p="${3-no}"
-    my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
+    $debug_cmd
+
+    my_outputname=$1
+    my_originator=$2
+    my_pic_p=${3-false}
+    my_prefix=`$ECHO "$my_originator" | $SED 's%[^a-zA-Z0-9]%_%g'`
     my_dlsyms=
 
-    if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
+    if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
       if test -n "$NM" && test -n "$global_symbol_pipe"; then
-	my_dlsyms="${my_outputname}S.c"
+	my_dlsyms=${my_outputname}S.c
       else
 	func_error "not configured to extract global symbols from dlpreopened files"
       fi
@@ -3255,7 +4587,7 @@ func_generate_dlsyms ()
       "") ;;
       *.c)
 	# Discover the nlist of each of the dlfiles.
-	nlist="$output_objdir/${my_outputname}.nm"
+	nlist=$output_objdir/$my_outputname.nm
 
 	func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
 
@@ -3263,34 +4595,36 @@ func_generate_dlsyms ()
 	func_verbose "creating $output_objdir/$my_dlsyms"
 
 	$opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
-/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
-/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
+/* $my_dlsyms - symbol resolution table for '$my_outputname' dlsym emulation. */
+/* Generated by $PROGRAM (GNU $PACKAGE) $VERSION */
 
 #ifdef __cplusplus
 extern \"C\" {
 #endif
 
-#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
+#if defined __GNUC__ && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
 #pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
 #endif
 
 /* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
-#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
+#if defined _WIN32 || defined __CYGWIN__ || defined _WIN32_WCE
 /* DATA imports from DLLs on WIN32 can't be const, because runtime
    relocations are performed -- see ld's documentation on pseudo-relocs.  */
 # define LT_DLSYM_CONST
-#elif defined(__osf__)
+#elif defined __osf__
 /* This system does not cope well with relocations in const data.  */
 # define LT_DLSYM_CONST
 #else
 # define LT_DLSYM_CONST const
 #endif
 
+#define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0)
+
 /* External symbol declarations for the compiler. */\
 "
 
-	if test "$dlself" = yes; then
-	  func_verbose "generating symbol list for \`$output'"
+	if test yes = "$dlself"; then
+	  func_verbose "generating symbol list for '$output'"
 
 	  $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
 
@@ -3298,7 +4632,7 @@ extern \"C\" {
 	  progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
 	  for progfile in $progfiles; do
 	    func_to_tool_file "$progfile" func_convert_file_msys_to_w32
-	    func_verbose "extracting global C symbols from \`$func_to_tool_file_result'"
+	    func_verbose "extracting global C symbols from '$func_to_tool_file_result'"
 	    $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
 	  done
 
@@ -3318,10 +4652,10 @@ extern \"C\" {
 
 	  # Prepare the list of exported symbols
 	  if test -z "$export_symbols"; then
-	    export_symbols="$output_objdir/$outputname.exp"
+	    export_symbols=$output_objdir/$outputname.exp
 	    $opt_dry_run || {
 	      $RM $export_symbols
-	      eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
+	      eval "$SED -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
 	      case $host in
 	      *cygwin* | *mingw* | *cegcc* )
                 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
@@ -3331,7 +4665,7 @@ extern \"C\" {
 	    }
 	  else
 	    $opt_dry_run || {
-	      eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
+	      eval "$SED -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
 	      eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
 	      eval '$MV "$nlist"T "$nlist"'
 	      case $host in
@@ -3345,22 +4679,22 @@ extern \"C\" {
 	fi
 
 	for dlprefile in $dlprefiles; do
-	  func_verbose "extracting global C symbols from \`$dlprefile'"
+	  func_verbose "extracting global C symbols from '$dlprefile'"
 	  func_basename "$dlprefile"
-	  name="$func_basename_result"
+	  name=$func_basename_result
           case $host in
 	    *cygwin* | *mingw* | *cegcc* )
 	      # if an import library, we need to obtain dlname
 	      if func_win32_import_lib_p "$dlprefile"; then
 	        func_tr_sh "$dlprefile"
 	        eval "curr_lafile=\$libfile_$func_tr_sh_result"
-	        dlprefile_dlbasename=""
+	        dlprefile_dlbasename=
 	        if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
 	          # Use subshell, to avoid clobbering current variable values
 	          dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
-	          if test -n "$dlprefile_dlname" ; then
+	          if test -n "$dlprefile_dlname"; then
 	            func_basename "$dlprefile_dlname"
-	            dlprefile_dlbasename="$func_basename_result"
+	            dlprefile_dlbasename=$func_basename_result
 	          else
 	            # no lafile. user explicitly requested -dlpreopen <import library>.
 	            $sharedlib_from_linklib_cmd "$dlprefile"
@@ -3368,7 +4702,7 @@ extern \"C\" {
 	          fi
 	        fi
 	        $opt_dry_run || {
-	          if test -n "$dlprefile_dlbasename" ; then
+	          if test -n "$dlprefile_dlbasename"; then
 	            eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
 	          else
 	            func_warning "Could not compute DLL name from $name"
@@ -3424,6 +4758,11 @@ extern \"C\" {
 	    echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
 	  fi
 
+	  func_show_eval '$RM "${nlist}I"'
+	  if test -n "$global_symbol_to_import"; then
+	    eval "$global_symbol_to_import"' < "$nlist"S > "$nlist"I'
+	  fi
+
 	  echo >> "$output_objdir/$my_dlsyms" "\
 
 /* The mapping between symbol names and symbols.  */
@@ -3432,11 +4771,30 @@ typedef struct {
   void *address;
 } lt_dlsymlist;
 extern LT_DLSYM_CONST lt_dlsymlist
-lt_${my_prefix}_LTX_preloaded_symbols[];
+lt_${my_prefix}_LTX_preloaded_symbols[];\
+"
+
+	  if test -s "$nlist"I; then
+	    echo >> "$output_objdir/$my_dlsyms" "\
+static void lt_syminit(void)
+{
+  LT_DLSYM_CONST lt_dlsymlist *symbol = lt_${my_prefix}_LTX_preloaded_symbols;
+  for (; symbol->name; ++symbol)
+    {"
+	    $SED 's/.*/      if (STREQ (symbol->name, \"&\")) symbol->address = (void *) \&&;/' < "$nlist"I >> "$output_objdir/$my_dlsyms"
+	    echo >> "$output_objdir/$my_dlsyms" "\
+    }
+}"
+	  fi
+	  echo >> "$output_objdir/$my_dlsyms" "\
 LT_DLSYM_CONST lt_dlsymlist
 lt_${my_prefix}_LTX_preloaded_symbols[] =
-{\
-  { \"$my_originator\", (void *) 0 },"
+{ {\"$my_originator\", (void *) 0},"
+
+	  if test -s "$nlist"I; then
+	    echo >> "$output_objdir/$my_dlsyms" "\
+  {\"@INIT@\", (void *) &lt_syminit},"
+	  fi
 
 	  case $need_lib_prefix in
 	  no)
@@ -3478,9 +4836,7 @@ static const void *lt_preloaded_setup() {
 	  *-*-hpux*)
 	    pic_flag_for_symtable=" $pic_flag"  ;;
 	  *)
-	    if test "X$my_pic_p" != Xno; then
-	      pic_flag_for_symtable=" $pic_flag"
-	    fi
+	    $my_pic_p && pic_flag_for_symtable=" $pic_flag"
 	    ;;
 	  esac
 	  ;;
@@ -3497,10 +4853,10 @@ static const void *lt_preloaded_setup() {
 	func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
 
 	# Clean up the generated files.
-	func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
+	func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T" "${nlist}I"'
 
 	# Transform the symbol file into the correct name.
-	symfileobj="$output_objdir/${my_outputname}S.$objext"
+	symfileobj=$output_objdir/${my_outputname}S.$objext
 	case $host in
 	*cygwin* | *mingw* | *cegcc* )
 	  if test -f "$output_objdir/$my_outputname.def"; then
@@ -3518,7 +4874,7 @@ static const void *lt_preloaded_setup() {
 	esac
 	;;
       *)
-	func_fatal_error "unknown suffix for \`$my_dlsyms'"
+	func_fatal_error "unknown suffix for '$my_dlsyms'"
 	;;
       esac
     else
@@ -3532,6 +4888,32 @@ static const void *lt_preloaded_setup() {
     fi
 }
 
+# func_cygming_gnu_implib_p ARG
+# This predicate returns with zero status (TRUE) if
+# ARG is a GNU/binutils-style import library. Returns
+# with nonzero status (FALSE) otherwise.
+func_cygming_gnu_implib_p ()
+{
+  $debug_cmd
+
+  func_to_tool_file "$1" func_convert_file_msys_to_w32
+  func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'`
+  test -n "$func_cygming_gnu_implib_tmp"
+}
+
+# func_cygming_ms_implib_p ARG
+# This predicate returns with zero status (TRUE) if
+# ARG is an MS-style import library. Returns
+# with nonzero status (FALSE) otherwise.
+func_cygming_ms_implib_p ()
+{
+  $debug_cmd
+
+  func_to_tool_file "$1" func_convert_file_msys_to_w32
+  func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
+  test -n "$func_cygming_ms_implib_tmp"
+}
+
 # func_win32_libid arg
 # return the library type of file 'arg'
 #
@@ -3541,8 +4923,9 @@ static const void *lt_preloaded_setup() {
 # Despite the name, also deal with 64 bit binaries.
 func_win32_libid ()
 {
-  $opt_debug
-  win32_libid_type="unknown"
+  $debug_cmd
+
+  win32_libid_type=unknown
   win32_fileres=`file -L $1 2>/dev/null`
   case $win32_fileres in
   *ar\ archive\ import\ library*) # definitely import
@@ -3552,16 +4935,29 @@ func_win32_libid ()
     # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
     if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
        $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
-      func_to_tool_file "$1" func_convert_file_msys_to_w32
-      win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
-	$SED -n -e '
+      case $nm_interface in
+      "MS dumpbin")
+	if func_cygming_ms_implib_p "$1" ||
+	   func_cygming_gnu_implib_p "$1"
+	then
+	  win32_nmres=import
+	else
+	  win32_nmres=
+	fi
+	;;
+      *)
+	func_to_tool_file "$1" func_convert_file_msys_to_w32
+	win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
+	  $SED -n -e '
 	    1,100{
 		/ I /{
-		    s,.*,import,
+		    s|.*|import|
 		    p
 		    q
 		}
 	    }'`
+	;;
+      esac
       case $win32_nmres in
       import*)  win32_libid_type="x86 archive import";;
       *)        win32_libid_type="x86 archive static";;
@@ -3593,7 +4989,8 @@ func_win32_libid ()
 #    $sharedlib_from_linklib_result
 func_cygming_dll_for_implib ()
 {
-  $opt_debug
+  $debug_cmd
+
   sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
 }
 
@@ -3610,7 +5007,8 @@ func_cygming_dll_for_implib ()
 # specified import library.
 func_cygming_dll_for_implib_fallback_core ()
 {
-  $opt_debug
+  $debug_cmd
+
   match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
   $OBJDUMP -s --section "$1" "$2" 2>/dev/null |
     $SED '/^Contents of section '"$match_literal"':/{
@@ -3646,8 +5044,8 @@ func_cygming_dll_for_implib_fallback_core ()
       /./p' |
     # we now have a list, one entry per line, of the stringified
     # contents of the appropriate section of all members of the
-    # archive which possess that section. Heuristic: eliminate
-    # all those which have a first or second character that is
+    # archive that possess that section. Heuristic: eliminate
+    # all those that have a first or second character that is
     # a '.' (that is, objdump's representation of an unprintable
     # character.) This should work for all archives with less than
     # 0x302f exports -- but will fail for DLLs whose name actually
@@ -3658,30 +5056,6 @@ func_cygming_dll_for_implib_fallback_core ()
     $SED -e '/^\./d;/^.\./d;q'
 }
 
-# func_cygming_gnu_implib_p ARG
-# This predicate returns with zero status (TRUE) if
-# ARG is a GNU/binutils-style import library. Returns
-# with nonzero status (FALSE) otherwise.
-func_cygming_gnu_implib_p ()
-{
-  $opt_debug
-  func_to_tool_file "$1" func_convert_file_msys_to_w32
-  func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'`
-  test -n "$func_cygming_gnu_implib_tmp"
-}
-
-# func_cygming_ms_implib_p ARG
-# This predicate returns with zero status (TRUE) if
-# ARG is an MS-style import library. Returns
-# with nonzero status (FALSE) otherwise.
-func_cygming_ms_implib_p ()
-{
-  $opt_debug
-  func_to_tool_file "$1" func_convert_file_msys_to_w32
-  func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
-  test -n "$func_cygming_ms_implib_tmp"
-}
-
 # func_cygming_dll_for_implib_fallback ARG
 # Platform-specific function to extract the
 # name of the DLL associated with the specified
@@ -3695,16 +5069,17 @@ func_cygming_ms_implib_p ()
 #    $sharedlib_from_linklib_result
 func_cygming_dll_for_implib_fallback ()
 {
-  $opt_debug
-  if func_cygming_gnu_implib_p "$1" ; then
+  $debug_cmd
+
+  if func_cygming_gnu_implib_p "$1"; then
     # binutils import library
     sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
-  elif func_cygming_ms_implib_p "$1" ; then
+  elif func_cygming_ms_implib_p "$1"; then
     # ms-generated import library
     sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
   else
     # unknown
-    sharedlib_from_linklib_result=""
+    sharedlib_from_linklib_result=
   fi
 }
 
@@ -3712,10 +5087,11 @@ func_cygming_dll_for_implib_fallback ()
 # func_extract_an_archive dir oldlib
 func_extract_an_archive ()
 {
-    $opt_debug
-    f_ex_an_ar_dir="$1"; shift
-    f_ex_an_ar_oldlib="$1"
-    if test "$lock_old_archive_extraction" = yes; then
+    $debug_cmd
+
+    f_ex_an_ar_dir=$1; shift
+    f_ex_an_ar_oldlib=$1
+    if test yes = "$lock_old_archive_extraction"; then
       lockfile=$f_ex_an_ar_oldlib.lock
       until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
 	func_echo "Waiting for $lockfile to be removed"
@@ -3724,7 +5100,7 @@ func_extract_an_archive ()
     fi
     func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
 		   'stat=$?; rm -f "$lockfile"; exit $stat'
-    if test "$lock_old_archive_extraction" = yes; then
+    if test yes = "$lock_old_archive_extraction"; then
       $opt_dry_run || rm -f "$lockfile"
     fi
     if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
@@ -3738,22 +5114,23 @@ func_extract_an_archive ()
 # func_extract_archives gentop oldlib ...
 func_extract_archives ()
 {
-    $opt_debug
-    my_gentop="$1"; shift
+    $debug_cmd
+
+    my_gentop=$1; shift
     my_oldlibs=${1+"$@"}
-    my_oldobjs=""
-    my_xlib=""
-    my_xabs=""
-    my_xdir=""
+    my_oldobjs=
+    my_xlib=
+    my_xabs=
+    my_xdir=
 
     for my_xlib in $my_oldlibs; do
       # Extract the objects.
       case $my_xlib in
-	[\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
+	[\\/]* | [A-Za-z]:[\\/]*) my_xabs=$my_xlib ;;
 	*) my_xabs=`pwd`"/$my_xlib" ;;
       esac
       func_basename "$my_xlib"
-      my_xlib="$func_basename_result"
+      my_xlib=$func_basename_result
       my_xlib_u=$my_xlib
       while :; do
         case " $extracted_archives " in
@@ -3765,7 +5142,7 @@ func_extract_archives ()
 	esac
       done
       extracted_archives="$extracted_archives $my_xlib_u"
-      my_xdir="$my_gentop/$my_xlib_u"
+      my_xdir=$my_gentop/$my_xlib_u
 
       func_mkdir_p "$my_xdir"
 
@@ -3778,22 +5155,23 @@ func_extract_archives ()
 	  cd $my_xdir || exit $?
 	  darwin_archive=$my_xabs
 	  darwin_curdir=`pwd`
-	  darwin_base_archive=`basename "$darwin_archive"`
+	  func_basename "$darwin_archive"
+	  darwin_base_archive=$func_basename_result
 	  darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
 	  if test -n "$darwin_arches"; then
 	    darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
 	    darwin_arch=
 	    func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
-	    for darwin_arch in  $darwin_arches ; do
-	      func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
-	      $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
-	      cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
-	      func_extract_an_archive "`pwd`" "${darwin_base_archive}"
+	    for darwin_arch in  $darwin_arches; do
+	      func_mkdir_p "unfat-$$/$darwin_base_archive-$darwin_arch"
+	      $LIPO -thin $darwin_arch -output "unfat-$$/$darwin_base_archive-$darwin_arch/$darwin_base_archive" "$darwin_archive"
+	      cd "unfat-$$/$darwin_base_archive-$darwin_arch"
+	      func_extract_an_archive "`pwd`" "$darwin_base_archive"
 	      cd "$darwin_curdir"
-	      $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
+	      $RM "unfat-$$/$darwin_base_archive-$darwin_arch/$darwin_base_archive"
 	    done # $darwin_arches
             ## Okay now we've a bunch of thin objects, gotta fatten them up :)
-	    darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
+	    darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$sed_basename" | sort -u`
 	    darwin_file=
 	    darwin_files=
 	    for darwin_file in $darwin_filelist; do
@@ -3815,7 +5193,7 @@ func_extract_archives ()
       my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
     done
 
-    func_extract_archives_result="$my_oldobjs"
+    func_extract_archives_result=$my_oldobjs
 }
 
 
@@ -3830,7 +5208,7 @@ func_extract_archives ()
 #
 # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
 # variable will take.  If 'yes', then the emitted script
-# will assume that the directory in which it is stored is
+# will assume that the directory where it is stored is
 # the $objdir directory.  This is a cygwin/mingw-specific
 # behavior.
 func_emit_wrapper ()
@@ -3841,7 +5219,7 @@ func_emit_wrapper ()
 #! $SHELL
 
 # $output - temporary wrapper script for $objdir/$outputname
-# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
+# Generated by $PROGRAM (GNU $PACKAGE) $VERSION
 #
 # The $output program cannot be directly executed until all the libtool
 # libraries that it depends on are installed.
@@ -3898,9 +5276,9 @@ _LTECHO_EOF'
 
 # Very basic option parsing. These options are (a) specific to
 # the libtool wrapper, (b) are identical between the wrapper
-# /script/ and the wrapper /executable/ which is used only on
+# /script/ and the wrapper /executable/ that is used only on
 # windows platforms, and (c) all begin with the string "--lt-"
-# (application programs are unlikely to have options which match
+# (application programs are unlikely to have options that match
 # this pattern).
 #
 # There are only two supported options: --lt-debug and
@@ -3933,7 +5311,7 @@ func_parse_lt_options ()
 
   # Print the debug banner immediately:
   if test -n \"\$lt_option_debug\"; then
-    echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2
+    echo \"$outputname:$output:\$LINENO: libtool wrapper (GNU $PACKAGE) $VERSION\" 1>&2
   fi
 }
 
@@ -3944,7 +5322,7 @@ func_lt_dump_args ()
   lt_dump_args_N=1;
   for lt_arg
   do
-    \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"
+    \$ECHO \"$outputname:$output:\$LINENO: newargv[\$lt_dump_args_N]: \$lt_arg\"
     lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
   done
 }
@@ -3958,7 +5336,7 @@ func_exec_program_core ()
   *-*-mingw | *-*-os2* | *-cegcc*)
     $ECHO "\
       if test -n \"\$lt_option_debug\"; then
-        \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2
+        \$ECHO \"$outputname:$output:\$LINENO: newargv[0]: \$progdir\\\\\$program\" 1>&2
         func_lt_dump_args \${1+\"\$@\"} 1>&2
       fi
       exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
@@ -3968,7 +5346,7 @@ func_exec_program_core ()
   *)
     $ECHO "\
       if test -n \"\$lt_option_debug\"; then
-        \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2
+        \$ECHO \"$outputname:$output:\$LINENO: newargv[0]: \$progdir/\$program\" 1>&2
         func_lt_dump_args \${1+\"\$@\"} 1>&2
       fi
       exec \"\$progdir/\$program\" \${1+\"\$@\"}
@@ -4043,13 +5421,13 @@ func_exec_program ()
   test -n \"\$absdir\" && thisdir=\"\$absdir\"
 "
 
-	if test "$fast_install" = yes; then
+	if test yes = "$fast_install"; then
 	  $ECHO "\
   program=lt-'$outputname'$exeext
   progdir=\"\$thisdir/$objdir\"
 
   if test ! -f \"\$progdir/\$program\" ||
-     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
+     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | $SED 1q\`; \\
        test \"X\$file\" != \"X\$progdir/\$program\"; }; then
 
     file=\"\$\$-\$program\"
@@ -4066,7 +5444,7 @@ func_exec_program ()
     if test -n \"\$relink_command\"; then
       if relink_command_output=\`eval \$relink_command 2>&1\`; then :
       else
-	$ECHO \"\$relink_command_output\" >&2
+	\$ECHO \"\$relink_command_output\" >&2
 	$RM \"\$progdir/\$file\"
 	exit 1
       fi
@@ -4101,7 +5479,7 @@ func_exec_program ()
 	fi
 
 	# Export our shlibpath_var if we have one.
-	if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
+	if test yes = "$shlibpath_overrides_runpath" && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
 	  $ECHO "\
     # Add our own library path to $shlibpath_var
     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
@@ -4121,7 +5499,7 @@ func_exec_program ()
     fi
   else
     # The program doesn't exist.
-    \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
+    \$ECHO \"\$0: error: '\$progdir/\$program' does not exist\" 1>&2
     \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
     \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
     exit 1
@@ -4140,7 +5518,7 @@ func_emit_cwrapperexe_src ()
 	cat <<EOF
 
 /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
-   Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
+   Generated by $PROGRAM (GNU $PACKAGE) $VERSION
 
    The $output program cannot be directly executed until all the libtool
    libraries that it depends on are installed.
@@ -4175,47 +5553,45 @@ EOF
 #include <fcntl.h>
 #include <sys/stat.h>
 
+#define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0)
+
 /* declarations of non-ANSI functions */
-#if defined(__MINGW32__)
+#if defined __MINGW32__
 # ifdef __STRICT_ANSI__
 int _putenv (const char *);
 # endif
-#elif defined(__CYGWIN__)
+#elif defined __CYGWIN__
 # ifdef __STRICT_ANSI__
 char *realpath (const char *, char *);
 int putenv (char *);
 int setenv (const char *, const char *, int);
 # endif
-/* #elif defined (other platforms) ... */
+/* #elif defined other_platform || defined ... */
 #endif
 
 /* portability defines, excluding path handling macros */
-#if defined(_MSC_VER)
+#if defined _MSC_VER
 # define setmode _setmode
 # define stat    _stat
 # define chmod   _chmod
 # define getcwd  _getcwd
 # define putenv  _putenv
 # define S_IXUSR _S_IEXEC
-# ifndef _INTPTR_T_DEFINED
-#  define _INTPTR_T_DEFINED
-#  define intptr_t int
-# endif
-#elif defined(__MINGW32__)
+#elif defined __MINGW32__
 # define setmode _setmode
 # define stat    _stat
 # define chmod   _chmod
 # define getcwd  _getcwd
 # define putenv  _putenv
-#elif defined(__CYGWIN__)
+#elif defined __CYGWIN__
 # define HAVE_SETENV
 # define FOPEN_WB "wb"
-/* #elif defined (other platforms) ... */
+/* #elif defined other platforms ... */
 #endif
 
-#if defined(PATH_MAX)
+#if defined PATH_MAX
 # define LT_PATHMAX PATH_MAX
-#elif defined(MAXPATHLEN)
+#elif defined MAXPATHLEN
 # define LT_PATHMAX MAXPATHLEN
 #else
 # define LT_PATHMAX 1024
@@ -4234,8 +5610,8 @@ int setenv (const char *, const char *, int);
 # define PATH_SEPARATOR ':'
 #endif
 
-#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
-  defined (__OS2__)
+#if defined _WIN32 || defined __MSDOS__ || defined __DJGPP__ || \
+  defined __OS2__
 # define HAVE_DOS_BASED_FILE_SYSTEM
 # define FOPEN_WB "wb"
 # ifndef DIR_SEPARATOR_2
@@ -4268,10 +5644,10 @@ int setenv (const char *, const char *, int);
 
 #define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
 #define XFREE(stale) do { \
-  if (stale) { free ((void *) stale); stale = 0; } \
+  if (stale) { free (stale); stale = 0; } \
 } while (0)
 
-#if defined(LT_DEBUGWRAPPER)
+#if defined LT_DEBUGWRAPPER
 static int lt_debug = 1;
 #else
 static int lt_debug = 0;
@@ -4300,11 +5676,16 @@ void lt_dump_script (FILE *f);
 EOF
 
 	    cat <<EOF
-volatile const char * MAGIC_EXE = "$magic_exe";
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5)
+# define externally_visible volatile
+#else
+# define externally_visible __attribute__((externally_visible)) volatile
+#endif
+externally_visible const char * MAGIC_EXE = "$magic_exe";
 const char * LIB_PATH_VARNAME = "$shlibpath_var";
 EOF
 
-	    if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
+	    if test yes = "$shlibpath_overrides_runpath" && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
               func_to_host_path "$temp_rpath"
 	      cat <<EOF
 const char * LIB_PATH_VALUE   = "$func_to_host_path_result";
@@ -4328,7 +5709,7 @@ const char * EXE_PATH_VALUE   = "";
 EOF
 	    fi
 
-	    if test "$fast_install" = yes; then
+	    if test yes = "$fast_install"; then
 	      cat <<EOF
 const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
 EOF
@@ -4357,12 +5738,12 @@ main (int argc, char *argv[])
   char *actual_cwrapper_name;
   char *target_name;
   char *lt_argv_zero;
-  intptr_t rval = 127;
+  int rval = 127;
 
   int i;
 
   program_name = (char *) xstrdup (base_name (argv[0]));
-  newargz = XMALLOC (char *, argc + 1);
+  newargz = XMALLOC (char *, (size_t) argc + 1);
 
   /* very simple arg parsing; don't want to rely on getopt
    * also, copy all non cwrapper options to newargz, except
@@ -4371,10 +5752,10 @@ main (int argc, char *argv[])
   newargc=0;
   for (i = 1; i < argc; i++)
     {
-      if (strcmp (argv[i], dumpscript_opt) == 0)
+      if (STREQ (argv[i], dumpscript_opt))
 	{
 EOF
-	    case "$host" in
+	    case $host in
 	      *mingw* | *cygwin* )
 		# make stdout use "unix" line endings
 		echo "          setmode(1,_O_BINARY);"
@@ -4385,16 +5766,16 @@ EOF
 	  lt_dump_script (stdout);
 	  return 0;
 	}
-      if (strcmp (argv[i], debug_opt) == 0)
+      if (STREQ (argv[i], debug_opt))
 	{
           lt_debug = 1;
           continue;
 	}
-      if (strcmp (argv[i], ltwrapper_option_prefix) == 0)
+      if (STREQ (argv[i], ltwrapper_option_prefix))
         {
           /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
              namespace, but it is not one of the ones we know about and
-             have already dealt with, above (including dump-script), then
+             have already dealt with, above (inluding dump-script), then
              report an error. Otherwise, targets might begin to believe
              they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
              namespace. The first time any user complains about this, we'll
@@ -4413,7 +5794,7 @@ EOF
 EOF
 	    cat <<EOF
   /* The GNU banner must be the first non-error debug message */
-  lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");
+  lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE) $VERSION\n");
 EOF
 	    cat <<"EOF"
   lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
@@ -4524,7 +5905,7 @@ EOF
 		cat <<"EOF"
   /* execv doesn't actually work on mingw as expected on unix */
   newargz = prepare_spawn (newargz);
-  rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
+  rval = (int) _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
   if (rval == -1)
     {
       /* failed to start process */
@@ -4569,7 +5950,7 @@ base_name (const char *name)
 {
   const char *base;
 
-#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
+#if defined HAVE_DOS_BASED_FILE_SYSTEM
   /* Skip over the disk name in MSDOS pathnames. */
   if (isalpha ((unsigned char) name[0]) && name[1] == ':')
     name += 2;
@@ -4628,7 +6009,7 @@ find_executable (const char *wrapper)
   const char *p_next;
   /* static buffer for getcwd */
   char tmp[LT_PATHMAX + 1];
-  int tmp_len;
+  size_t tmp_len;
   char *concat_name;
 
   lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
@@ -4638,7 +6019,7 @@ find_executable (const char *wrapper)
     return NULL;
 
   /* Absolute path? */
-#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
+#if defined HAVE_DOS_BASED_FILE_SYSTEM
   if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
     {
       concat_name = xstrdup (wrapper);
@@ -4656,7 +6037,7 @@ find_executable (const char *wrapper)
 	    return concat_name;
 	  XFREE (concat_name);
 	}
-#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
+#if defined HAVE_DOS_BASED_FILE_SYSTEM
     }
 #endif
 
@@ -4679,7 +6060,7 @@ find_executable (const char *wrapper)
 	      for (q = p; *q; q++)
 		if (IS_PATH_SEPARATOR (*q))
 		  break;
-	      p_len = q - p;
+	      p_len = (size_t) (q - p);
 	      p_next = (*q == '\0' ? q : q + 1);
 	      if (p_len == 0)
 		{
@@ -4798,7 +6179,7 @@ strendzap (char *str, const char *pat)
   if (patlen <= len)
     {
       str += len - patlen;
-      if (strcmp (str, pat) == 0)
+      if (STREQ (str, pat))
 	*str = '\0';
     }
   return str;
@@ -4863,7 +6244,7 @@ lt_setenv (const char *name, const char *value)
     char *str = xstrdup (value);
     setenv (name, str, 1);
 #else
-    int len = strlen (name) + 1 + strlen (value) + 1;
+    size_t len = strlen (name) + 1 + strlen (value) + 1;
     char *str = XMALLOC (char, len);
     sprintf (str, "%s=%s", name, value);
     if (putenv (str) != EXIT_SUCCESS)
@@ -4880,8 +6261,8 @@ lt_extend_str (const char *orig_value, const char *add, int to_end)
   char *new_value;
   if (orig_value && *orig_value)
     {
-      int orig_value_len = strlen (orig_value);
-      int add_len = strlen (add);
+      size_t orig_value_len = strlen (orig_value);
+      size_t add_len = strlen (add);
       new_value = XMALLOC (char, add_len + orig_value_len + 1);
       if (to_end)
         {
@@ -4912,10 +6293,10 @@ lt_update_exe_path (const char *name, const char *value)
     {
       char *new_value = lt_extend_str (getenv (name), value, 0);
       /* some systems can't cope with a ':'-terminated path #' */
-      int len = strlen (new_value);
-      while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
+      size_t len = strlen (new_value);
+      while ((len > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
         {
-          new_value[len-1] = '\0';
+          new_value[--len] = '\0';
         }
       lt_setenv (name, new_value);
       XFREE (new_value);
@@ -5082,24 +6463,53 @@ EOF
 # True if ARG is an import lib, as indicated by $file_magic_cmd
 func_win32_import_lib_p ()
 {
-    $opt_debug
+    $debug_cmd
+
     case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
     *import*) : ;;
     *) false ;;
     esac
 }
 
+# func_suncc_cstd_abi
+# !!ONLY CALL THIS FOR SUN CC AFTER $compile_command IS FULLY EXPANDED!!
+# Several compiler flags select an ABI that is incompatible with the
+# Cstd library. Avoid specifying it if any are in CXXFLAGS.
+func_suncc_cstd_abi ()
+{
+    $debug_cmd
+
+    case " $compile_command " in
+    *" -compat=g "*|*\ -std=c++[0-9][0-9]\ *|*" -library=stdcxx4 "*|*" -library=stlport4 "*)
+      suncc_use_cstd_abi=no
+      ;;
+    *)
+      suncc_use_cstd_abi=yes
+      ;;
+    esac
+}
+
 # func_mode_link arg...
 func_mode_link ()
 {
-    $opt_debug
+    $debug_cmd
+
     case $host in
     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
       # It is impossible to link a dll without this setting, and
       # we shouldn't force the makefile maintainer to figure out
-      # which system we are compiling for in order to pass an extra
+      # what system we are compiling for in order to pass an extra
       # flag for every libtool invocation.
+      # SDL customization: SDL code doesn't have any undefined symbols
       allow_undefined=no
+
+      # FIXME: Unfortunately, there are problems with the above when trying
+      # to make a dll that has undefined symbols, in which case not
+      # even a static library is built.  For now, we need to specify
+      # -no-undefined on the libtool link line when we can be certain
+      # that all symbols are satisfied, otherwise we get a static library.
+      # SDL customization: SDL code doesn't have any undefined symbols
+      # allow_undefined=yes
       ;;
     *)
       allow_undefined=yes
@@ -5139,10 +6549,11 @@ func_mode_link ()
     module=no
     no_install=no
     objs=
+    os2dllname=
     non_pic_objects=
     precious_files_regex=
     prefer_static_libs=no
-    preload=no
+    preload=false
     prev=
     prevarg=
     release=
@@ -5154,7 +6565,7 @@ func_mode_link ()
     vinfo=
     vinfo_number=no
     weak_libs=
-    single_module="${wl}-single_module"
+    single_module=$wl-single_module
     func_infer_tag $base_compile
 
     # We need to know -static, to get the right output filenames.
@@ -5162,15 +6573,15 @@ func_mode_link ()
     do
       case $arg in
       -shared)
-	test "$build_libtool_libs" != yes && \
-	  func_fatal_configuration "can not build a shared library"
+	test yes != "$build_libtool_libs" \
+	  && func_fatal_configuration "cannot build a shared library"
 	build_old_libs=no
 	break
 	;;
       -all-static | -static | -static-libtool-libs)
 	case $arg in
 	-all-static)
-	  if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
+	  if test yes = "$build_libtool_libs" && test -z "$link_static_flag"; then
 	    func_warning "complete static linking is impossible in this configuration"
 	  fi
 	  if test -n "$link_static_flag"; then
@@ -5203,7 +6614,7 @@ func_mode_link ()
 
     # Go through the arguments, transforming them on the way.
     while test "$#" -gt 0; do
-      arg="$1"
+      arg=$1
       shift
       func_quote_for_eval "$arg"
       qarg=$func_quote_for_eval_unquoted_result
@@ -5220,21 +6631,21 @@ func_mode_link ()
 
 	case $prev in
 	bindir)
-	  bindir="$arg"
+	  bindir=$arg
 	  prev=
 	  continue
 	  ;;
 	dlfiles|dlprefiles)
-	  if test "$preload" = no; then
+	  $preload || {
 	    # Add the symbol object into the linking commands.
 	    func_append compile_command " @SYMFILE@"
 	    func_append finalize_command " @SYMFILE@"
-	    preload=yes
-	  fi
+	    preload=:
+	  }
 	  case $arg in
 	  *.la | *.lo) ;;  # We handle these cases below.
 	  force)
-	    if test "$dlself" = no; then
+	    if test no = "$dlself"; then
 	      dlself=needless
 	      export_dynamic=yes
 	    fi
@@ -5242,9 +6653,9 @@ func_mode_link ()
 	    continue
 	    ;;
 	  self)
-	    if test "$prev" = dlprefiles; then
+	    if test dlprefiles = "$prev"; then
 	      dlself=yes
-	    elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
+	    elif test dlfiles = "$prev" && test yes != "$dlopen_self"; then
 	      dlself=yes
 	    else
 	      dlself=needless
@@ -5254,7 +6665,7 @@ func_mode_link ()
 	    continue
 	    ;;
 	  *)
-	    if test "$prev" = dlfiles; then
+	    if test dlfiles = "$prev"; then
 	      func_append dlfiles " $arg"
 	    else
 	      func_append dlprefiles " $arg"
@@ -5265,14 +6676,14 @@ func_mode_link ()
 	  esac
 	  ;;
 	expsyms)
-	  export_symbols="$arg"
+	  export_symbols=$arg
 	  test -f "$arg" \
-	    || func_fatal_error "symbol file \`$arg' does not exist"
+	    || func_fatal_error "symbol file '$arg' does not exist"
 	  prev=
 	  continue
 	  ;;
 	expsyms_regex)
-	  export_symbols_regex="$arg"
+	  export_symbols_regex=$arg
 	  prev=
 	  continue
 	  ;;
@@ -5290,7 +6701,13 @@ func_mode_link ()
 	  continue
 	  ;;
 	inst_prefix)
-	  inst_prefix_dir="$arg"
+	  inst_prefix_dir=$arg
+	  prev=
+	  continue
+	  ;;
+	mllvm)
+	  # Clang does not use LLVM to link, so we can simply discard any
+	  # '-mllvm $arg' options when doing the link step.
 	  prev=
 	  continue
 	  ;;
@@ -5314,21 +6731,21 @@ func_mode_link ()
 
 		if test -z "$pic_object" ||
 		   test -z "$non_pic_object" ||
-		   test "$pic_object" = none &&
-		   test "$non_pic_object" = none; then
-		  func_fatal_error "cannot find name of object for \`$arg'"
+		   test none = "$pic_object" &&
+		   test none = "$non_pic_object"; then
+		  func_fatal_error "cannot find name of object for '$arg'"
 		fi
 
 		# Extract subdirectory from the argument.
 		func_dirname "$arg" "/" ""
-		xdir="$func_dirname_result"
+		xdir=$func_dirname_result
 
-		if test "$pic_object" != none; then
+		if test none != "$pic_object"; then
 		  # Prepend the subdirectory the object is found in.
-		  pic_object="$xdir$pic_object"
+		  pic_object=$xdir$pic_object
 
-		  if test "$prev" = dlfiles; then
-		    if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
+		  if test dlfiles = "$prev"; then
+		    if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; then
 		      func_append dlfiles " $pic_object"
 		      prev=
 		      continue
@@ -5339,7 +6756,7 @@ func_mode_link ()
 		  fi
 
 		  # CHECK ME:  I think I busted this.  -Ossama
-		  if test "$prev" = dlprefiles; then
+		  if test dlprefiles = "$prev"; then
 		    # Preload the old-style object.
 		    func_append dlprefiles " $pic_object"
 		    prev=
@@ -5347,23 +6764,23 @@ func_mode_link ()
 
 		  # A PIC object.
 		  func_append libobjs " $pic_object"
-		  arg="$pic_object"
+		  arg=$pic_object
 		fi
 
 		# Non-PIC object.
-		if test "$non_pic_object" != none; then
+		if test none != "$non_pic_object"; then
 		  # Prepend the subdirectory the object is found in.
-		  non_pic_object="$xdir$non_pic_object"
+		  non_pic_object=$xdir$non_pic_object
 
 		  # A standard non-PIC object
 		  func_append non_pic_objects " $non_pic_object"
-		  if test -z "$pic_object" || test "$pic_object" = none ; then
-		    arg="$non_pic_object"
+		  if test -z "$pic_object" || test none = "$pic_object"; then
+		    arg=$non_pic_object
 		  fi
 		else
 		  # If the PIC object exists, use it instead.
 		  # $xdir was prepended to $pic_object above.
-		  non_pic_object="$pic_object"
+		  non_pic_object=$pic_object
 		  func_append non_pic_objects " $non_pic_object"
 		fi
 	      else
@@ -5371,7 +6788,7 @@ func_mode_link ()
 		if $opt_dry_run; then
 		  # Extract subdirectory from the argument.
 		  func_dirname "$arg" "/" ""
-		  xdir="$func_dirname_result"
+		  xdir=$func_dirname_result
 
 		  func_lo2o "$arg"
 		  pic_object=$xdir$objdir/$func_lo2o_result
@@ -5379,24 +6796,29 @@ func_mode_link ()
 		  func_append libobjs " $pic_object"
 		  func_append non_pic_objects " $non_pic_object"
 	        else
-		  func_fatal_error "\`$arg' is not a valid libtool object"
+		  func_fatal_error "'$arg' is not a valid libtool object"
 		fi
 	      fi
 	    done
 	  else
-	    func_fatal_error "link input file \`$arg' does not exist"
+	    func_fatal_error "link input file '$arg' does not exist"
 	  fi
 	  arg=$save_arg
 	  prev=
 	  continue
 	  ;;
+	os2dllname)
+	  os2dllname=$arg
+	  prev=
+	  continue
+	  ;;
 	precious_regex)
-	  precious_files_regex="$arg"
+	  precious_files_regex=$arg
 	  prev=
 	  continue
 	  ;;
 	release)
-	  release="-$arg"
+	  release=-$arg
 	  prev=
 	  continue
 	  ;;
@@ -5408,7 +6830,7 @@ func_mode_link ()
 	    func_fatal_error "only absolute run-paths are allowed"
 	    ;;
 	  esac
-	  if test "$prev" = rpath; then
+	  if test rpath = "$prev"; then
 	    case "$rpath " in
 	    *" $arg "*) ;;
 	    *) func_append rpath " $arg" ;;
@@ -5423,7 +6845,7 @@ func_mode_link ()
 	  continue
 	  ;;
 	shrext)
-	  shrext_cmds="$arg"
+	  shrext_cmds=$arg
 	  prev=
 	  continue
 	  ;;
@@ -5432,6 +6854,13 @@ func_mode_link ()
 	  prev=
 	  continue
 	  ;;
+	xassembler)
+	  func_append compiler_flags " -Xassembler $qarg"
+	  prev=
+	  func_append compile_command " -Xassembler $qarg"
+	  func_append finalize_command " -Xassembler $qarg"
+	  continue
+	  ;;
 	xcclinker)
 	  func_append linker_flags " $qarg"
 	  func_append compiler_flags " $qarg"
@@ -5463,7 +6892,7 @@ func_mode_link ()
 	esac
       fi # test -n "$prev"
 
-      prevarg="$arg"
+      prevarg=$arg
 
       case $arg in
       -all-static)
@@ -5477,7 +6906,7 @@ func_mode_link ()
 
       -allow-undefined)
 	# FIXME: remove this flag sometime in the future.
-	func_fatal_error "\`-allow-undefined' must not be used because it is the default"
+	func_fatal_error "'-allow-undefined' must not be used because it is the default"
 	;;
 
       -avoid-version)
@@ -5509,7 +6938,7 @@ func_mode_link ()
 	if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
 	  func_fatal_error "more than one -exported-symbols argument is not allowed"
 	fi
-	if test "X$arg" = "X-export-symbols"; then
+	if test X-export-symbols = "X$arg"; then
 	  prev=expsyms
 	else
 	  prev=expsyms_regex
@@ -5543,9 +6972,9 @@ func_mode_link ()
 	func_stripname "-L" '' "$arg"
 	if test -z "$func_stripname_result"; then
 	  if test "$#" -gt 0; then
-	    func_fatal_error "require no space between \`-L' and \`$1'"
+	    func_fatal_error "require no space between '-L' and '$1'"
 	  else
-	    func_fatal_error "need path for \`-L' option"
+	    func_fatal_error "need path for '-L' option"
 	  fi
 	fi
 	func_resolve_sysroot "$func_stripname_result"
@@ -5556,8 +6985,8 @@ func_mode_link ()
 	*)
 	  absdir=`cd "$dir" && pwd`
 	  test -z "$absdir" && \
-	    func_fatal_error "cannot determine absolute directory name of \`$dir'"
-	  dir="$absdir"
+	    func_fatal_error "cannot determine absolute directory name of '$dir'"
+	  dir=$absdir
 	  ;;
 	esac
 	case "$deplibs " in
@@ -5592,7 +7021,7 @@ func_mode_link ()
 	;;
 
       -l*)
-	if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
+	if test X-lc = "X$arg" || test X-lm = "X$arg"; then
 	  case $host in
 	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
 	    # These systems don't actually have a C or math library (as such)
@@ -5600,11 +7029,11 @@ func_mode_link ()
 	    ;;
 	  *-*-os2*)
 	    # These systems don't actually have a C library (as such)
-	    test "X$arg" = "X-lc" && continue
+	    test X-lc = "X$arg" && continue
 	    ;;
-	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
+	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig* | *-*-midnightbsd*)
 	    # Do not include libc due to us having libc/libc_r.
-	    test "X$arg" = "X-lc" && continue
+	    test X-lc = "X$arg" && continue
 	    ;;
 	  *-*-rhapsody* | *-*-darwin1.[012])
 	    # Rhapsody C and math libraries are in the System framework
@@ -5613,16 +7042,16 @@ func_mode_link ()
 	    ;;
 	  *-*-sco3.2v5* | *-*-sco5v6*)
 	    # Causes problems with __ctype
-	    test "X$arg" = "X-lc" && continue
+	    test X-lc = "X$arg" && continue
 	    ;;
 	  *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
 	    # Compiler inserts libc in the correct place for threads to work
-	    test "X$arg" = "X-lc" && continue
+	    test X-lc = "X$arg" && continue
 	    ;;
 	  esac
-	elif test "X$arg" = "X-lc_r"; then
+	elif test X-lc_r = "X$arg"; then
 	 case $host in
-	 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
+	 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig* | *-*-midnightbsd*)
 	   # Do not include libc_r directly, use -pthread flag.
 	   continue
 	   ;;
@@ -5632,6 +7061,11 @@ func_mode_link ()
 	continue
 	;;
 
+      -mllvm)
+	prev=mllvm
+	continue
+	;;
+
       -module)
 	module=yes
 	continue
@@ -5647,8 +7081,20 @@ func_mode_link ()
 	prev=xcompiler
 	continue
 	;;
-
-      -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
+     # Solaris ld rejects as of 11.4. Refer to Oracle bug 22985199.
+     -pthread)
+	case $host in
+	  *solaris2*) ;;
+	  *)
+	    case "$new_inherited_linker_flags " in
+	        *" $arg "*) ;;
+	        * ) func_append new_inherited_linker_flags " $arg" ;;
+	    esac
+	  ;;
+	esac
+	continue
+	;;
+      -mt|-mthreads|-kthread|-Kthread|-pthreads|--thread-safe \
       |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
 	func_append compiler_flags " $arg"
 	func_append compile_command " $arg"
@@ -5661,7 +7107,7 @@ func_mode_link ()
 	;;
 
       -multi_module)
-	single_module="${wl}-multi_module"
+	single_module=$wl-multi_module
 	continue
 	;;
 
@@ -5675,8 +7121,8 @@ func_mode_link ()
 	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
 	  # The PATH hackery in wrapper scripts is required on Windows
 	  # and Darwin in order for the loader to find any dlls it needs.
-	  func_warning "\`-no-install' is ignored for $host"
-	  func_warning "assuming \`-no-fast-install' instead"
+	  func_warning "'-no-install' is ignored for $host"
+	  func_warning "assuming '-no-fast-install' instead"
 	  fast_install=no
 	  ;;
 	*) no_install=yes ;;
@@ -5694,6 +7140,11 @@ func_mode_link ()
 	continue
 	;;
 
+      -os2dllname)
+	prev=os2dllname
+	continue
+	;;
+
       -o) prev=output ;;
 
       -precious-files-regex)
@@ -5781,14 +7232,14 @@ func_mode_link ()
 	func_stripname '-Wc,' '' "$arg"
 	args=$func_stripname_result
 	arg=
-	save_ifs="$IFS"; IFS=','
+	save_ifs=$IFS; IFS=,
 	for flag in $args; do
-	  IFS="$save_ifs"
+	  IFS=$save_ifs
           func_quote_for_eval "$flag"
 	  func_append arg " $func_quote_for_eval_result"
 	  func_append compiler_flags " $func_quote_for_eval_result"
 	done
-	IFS="$save_ifs"
+	IFS=$save_ifs
 	func_stripname ' ' '' "$arg"
 	arg=$func_stripname_result
 	;;
@@ -5797,19 +7248,24 @@ func_mode_link ()
 	func_stripname '-Wl,' '' "$arg"
 	args=$func_stripname_result
 	arg=
-	save_ifs="$IFS"; IFS=','
+	save_ifs=$IFS; IFS=,
 	for flag in $args; do
-	  IFS="$save_ifs"
+	  IFS=$save_ifs
           func_quote_for_eval "$flag"
 	  func_append arg " $wl$func_quote_for_eval_result"
 	  func_append compiler_flags " $wl$func_quote_for_eval_result"
 	  func_append linker_flags " $func_quote_for_eval_result"
 	done
-	IFS="$save_ifs"
+	IFS=$save_ifs
 	func_stripname ' ' '' "$arg"
 	arg=$func_stripname_result
 	;;
 
+      -Xassembler)
+        prev=xassembler
+        continue
+        ;;
+
       -Xcompiler)
 	prev=xcompiler
 	continue
@@ -5828,7 +7284,7 @@ func_mode_link ()
       # -msg_* for osf cc
       -msg_*)
 	func_quote_for_eval "$arg"
-	arg="$func_quote_for_eval_result"
+	arg=$func_quote_for_eval_result
 	;;
 
       # Flags to be passed through unchanged, with rationale:
@@ -5840,25 +7296,51 @@ func_mode_link ()
       # -m*, -t[45]*, -txscale* architecture-specific flags for GCC
       # -F/path              path to uninstalled frameworks, gcc on darwin
       # -p, -pg, --coverage, -fprofile-*  profiling flags for GCC
+      # -fstack-protector*   stack protector flags for GCC
       # @file                GCC response files
       # -tp=*                Portland pgcc target processor selection
       # --sysroot=*          for sysroot support
-      # -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
+      # -O*, -g*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
+      # -specs=*             GCC specs files
+      # -stdlib=*            select c++ std lib with clang
+      # -fsanitize=*         Clang/GCC memory and address sanitizer
+      # -fuse-ld=*           Linker select flags for GCC
+      # -Wa,*                Pass flags directly to the assembler
       -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
       -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
-      -O*|-flto*|-fwhopr*|-fuse-linker-plugin)
+      -O*|-g*|-flto*|-fwhopr*|-fuse-linker-plugin|-fstack-protector*|-stdlib=*| \
+      -specs=*|-fsanitize=*|-fuse-ld=*|-Wa,*)
         func_quote_for_eval "$arg"
-	arg="$func_quote_for_eval_result"
+	arg=$func_quote_for_eval_result
         func_append compile_command " $arg"
         func_append finalize_command " $arg"
         func_append compiler_flags " $arg"
         continue
         ;;
 
+      -Z*)
+        if test os2 = "`expr $host : '.*\(os2\)'`"; then
+          # OS/2 uses -Zxxx to specify OS/2-specific options
+	  compiler_flags="$compiler_flags $arg"
+	  func_append compile_command " $arg"
+	  func_append finalize_command " $arg"
+	  case $arg in
+	  -Zlinker | -Zstack)
+	    prev=xcompiler
+	    ;;
+	  esac
+	  continue
+        else
+	  # Otherwise treat like 'Some other compiler flag' below
+	  func_quote_for_eval "$arg"
+	  arg=$func_quote_for_eval_result
+        fi
+	;;
+
       # Some other compiler flag.
       -* | +*)
         func_quote_for_eval "$arg"
-	arg="$func_quote_for_eval_result"
+	arg=$func_quote_for_eval_result
 	;;
 
       *.$objext)
@@ -5879,21 +7361,21 @@ func_mode_link ()
 
 	  if test -z "$pic_object" ||
 	     test -z "$non_pic_object" ||
-	     test "$pic_object" = none &&
-	     test "$non_pic_object" = none; then
-	    func_fatal_error "cannot find name of object for \`$arg'"
+	     test none = "$pic_object" &&
+	     test none = "$non_pic_object"; then
+	    func_fatal_error "cannot find name of object for '$arg'"
 	  fi
 
 	  # Extract subdirectory from the argument.
 	  func_dirname "$arg" "/" ""
-	  xdir="$func_dirname_result"
+	  xdir=$func_dirname_result
 
-	  if test "$pic_object" != none; then
+	  test none = "$pic_object" || {
 	    # Prepend the subdirectory the object is found in.
-	    pic_object="$xdir$pic_object"
+	    pic_object=$xdir$pic_object
 
-	    if test "$prev" = dlfiles; then
-	      if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
+	    if test dlfiles = "$prev"; then
+	      if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; then
 		func_append dlfiles " $pic_object"
 		prev=
 		continue
@@ -5904,7 +7386,7 @@ func_mode_link ()
 	    fi
 
 	    # CHECK ME:  I think I busted this.  -Ossama
-	    if test "$prev" = dlprefiles; then
+	    if test dlprefiles = "$prev"; then
 	      # Preload the old-style object.
 	      func_append dlprefiles " $pic_object"
 	      prev=
@@ -5912,23 +7394,23 @@ func_mode_link ()
 
 	    # A PIC object.
 	    func_append libobjs " $pic_object"
-	    arg="$pic_object"
-	  fi
+	    arg=$pic_object
+	  }
 
 	  # Non-PIC object.
-	  if test "$non_pic_object" != none; then
+	  if test none != "$non_pic_object"; then
 	    # Prepend the subdirectory the object is found in.
-	    non_pic_object="$xdir$non_pic_object"
+	    non_pic_object=$xdir$non_pic_object
 
 	    # A standard non-PIC object
 	    func_append non_pic_objects " $non_pic_object"
-	    if test -z "$pic_object" || test "$pic_object" = none ; then
-	      arg="$non_pic_object"
+	    if test -z "$pic_object" || test none = "$pic_object"; then
+	      arg=$non_pic_object
 	    fi
 	  else
 	    # If the PIC object exists, use it instead.
 	    # $xdir was prepended to $pic_object above.
-	    non_pic_object="$pic_object"
+	    non_pic_object=$pic_object
 	    func_append non_pic_objects " $non_pic_object"
 	  fi
 	else
@@ -5936,7 +7418,7 @@ func_mode_link ()
 	  if $opt_dry_run; then
 	    # Extract subdirectory from the argument.
 	    func_dirname "$arg" "/" ""
-	    xdir="$func_dirname_result"
+	    xdir=$func_dirname_result
 
 	    func_lo2o "$arg"
 	    pic_object=$xdir$objdir/$func_lo2o_result
@@ -5944,7 +7426,7 @@ func_mode_link ()
 	    func_append libobjs " $pic_object"
 	    func_append non_pic_objects " $non_pic_object"
 	  else
-	    func_fatal_error "\`$arg' is not a valid libtool object"
+	    func_fatal_error "'$arg' is not a valid libtool object"
 	  fi
 	fi
 	;;
@@ -5960,11 +7442,11 @@ func_mode_link ()
 	# A libtool-controlled library.
 
 	func_resolve_sysroot "$arg"
-	if test "$prev" = dlfiles; then
+	if test dlfiles = "$prev"; then
 	  # This library was specified with -dlopen.
 	  func_append dlfiles " $func_resolve_sysroot_result"
 	  prev=
-	elif test "$prev" = dlprefiles; then
+	elif test dlprefiles = "$prev"; then
 	  # The library was specified with -dlpreopen.
 	  func_append dlprefiles " $func_resolve_sysroot_result"
 	  prev=
@@ -5979,7 +7461,7 @@ func_mode_link ()
 	# Unknown arguments in both finalize_command and compile_command need
 	# to be aesthetically quoted because they are evaled later.
 	func_quote_for_eval "$arg"
-	arg="$func_quote_for_eval_result"
+	arg=$func_quote_for_eval_result
 	;;
       esac # arg
 
@@ -5991,9 +7473,9 @@ func_mode_link ()
     done # argument parsing loop
 
     test -n "$prev" && \
-      func_fatal_help "the \`$prevarg' option requires an argument"
+      func_fatal_help "the '$prevarg' option requires an argument"
 
-    if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
+    if test yes = "$export_dynamic" && test -n "$export_dynamic_flag_spec"; then
       eval arg=\"$export_dynamic_flag_spec\"
       func_append compile_command " $arg"
       func_append finalize_command " $arg"
@@ -6002,20 +7484,23 @@ func_mode_link ()
     oldlibs=
     # calculate the name of the file, without its directory
     func_basename "$output"
-    outputname="$func_basename_result"
-    libobjs_save="$libobjs"
+    outputname=$func_basename_result
+    libobjs_save=$libobjs
 
     if test -n "$shlibpath_var"; then
       # get the directories listed in $shlibpath_var
-      eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
+      eval shlib_search_path=\`\$ECHO \"\$$shlibpath_var\" \| \$SED \'s/:/ /g\'\`
     else
       shlib_search_path=
     fi
     eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
 
+    # Definition is injected by LT_CONFIG during libtool generation.
+    func_munge_path_list sys_lib_dlsearch_path "$LT_SYS_LIBRARY_PATH"
+
     func_dirname "$output" "/" ""
-    output_objdir="$func_dirname_result$objdir"
+    output_objdir=$func_dirname_result$objdir
     func_to_tool_file "$output_objdir/"
     tool_output_objdir=$func_to_tool_file_result
     # Create the object directory.
@@ -6038,7 +7523,7 @@ func_mode_link ()
     # Find all interdependent deplibs by searching for libraries
     # that are linked more than once (e.g. -la -lb -la)
     for deplib in $deplibs; do
-      if $opt_preserve_dup_deps ; then
+      if $opt_preserve_dup_deps; then
 	case "$libs " in
 	*" $deplib "*) func_append specialdeplibs " $deplib" ;;
 	esac
@@ -6046,7 +7531,7 @@ func_mode_link ()
       func_append libs " $deplib"
     done
 
-    if test "$linkmode" = lib; then
+    if test lib = "$linkmode"; then
       libs="$predeps $libs $compiler_lib_search_path $postdeps"
 
       # Compute libraries that are listed more than once in $predeps
@@ -6078,7 +7563,7 @@ func_mode_link ()
 	  case $file in
 	  *.la) ;;
 	  *)
-	    func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
+	    func_fatal_help "libraries can '-dlopen' only libtool libraries: $file"
 	    ;;
 	  esac
 	done
@@ -6086,7 +7571,7 @@ func_mode_link ()
     prog)
 	compile_deplibs=
 	finalize_deplibs=
-	alldeplibs=no
+	alldeplibs=false
 	newdlfiles=
 	newdlprefiles=
 	passes="conv scan dlopen dlpreopen link"
@@ -6098,29 +7583,29 @@ func_mode_link ()
     for pass in $passes; do
       # The preopen pass in lib mode reverses $deplibs; put it back here
       # so that -L comes before libs that need it for instance...
-      if test "$linkmode,$pass" = "lib,link"; then
+      if test lib,link = "$linkmode,$pass"; then
 	## FIXME: Find the place where the list is rebuilt in the wrong
 	##        order, and fix it there properly
         tmp_deplibs=
 	for deplib in $deplibs; do
 	  tmp_deplibs="$deplib $tmp_deplibs"
 	done
-	deplibs="$tmp_deplibs"
+	deplibs=$tmp_deplibs
       fi
 
-      if test "$linkmode,$pass" = "lib,link" ||
-	 test "$linkmode,$pass" = "prog,scan"; then
-	libs="$deplibs"
+      if test lib,link = "$linkmode,$pass" ||
+	 test prog,scan = "$linkmode,$pass"; then
+	libs=$deplibs
 	deplibs=
       fi
-      if test "$linkmode" = prog; then
+      if test prog = "$linkmode"; then
 	case $pass in
-	dlopen) libs="$dlfiles" ;;
-	dlpreopen) libs="$dlprefiles" ;;
+	dlopen) libs=$dlfiles ;;
+	dlpreopen) libs=$dlprefiles ;;
 	link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
 	esac
       fi
-      if test "$linkmode,$pass" = "lib,dlpreopen"; then
+      if test lib,dlpreopen = "$linkmode,$pass"; then
 	# Collect and forward deplibs of preopened libtool libs
 	for lib in $dlprefiles; do
 	  # Ignore non-libtool-libs
@@ -6141,26 +7626,26 @@ func_mode_link ()
 	    esac
 	  done
 	done
-	libs="$dlprefiles"
+	libs=$dlprefiles
       fi
-      if test "$pass" = dlopen; then
+      if test dlopen = "$pass"; then
 	# Collect dlpreopened libraries
-	save_deplibs="$deplibs"
+	save_deplibs=$deplibs
 	deplibs=
       fi
 
       for deplib in $libs; do
 	lib=
-	found=no
+	found=false
 	case $deplib in
 	-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
         |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
-	  if test "$linkmode,$pass" = "prog,link"; then
+	  if test prog,link = "$linkmode,$pass"; then
 	    compile_deplibs="$deplib $compile_deplibs"
 	    finalize_deplibs="$deplib $finalize_deplibs"
 	  else
 	    func_append compiler_flags " $deplib"
-	    if test "$linkmode" = lib ; then
+	    if test lib = "$linkmode"; then
 		case "$new_inherited_linker_flags " in
 		    *" $deplib "*) ;;
 		    * ) func_append new_inherited_linker_flags " $deplib" ;;
@@ -6170,13 +7655,13 @@ func_mode_link ()
 	  continue
 	  ;;
 	-l*)
-	  if test "$linkmode" != lib && test "$linkmode" != prog; then
-	    func_warning "\`-l' is ignored for archives/objects"
+	  if test lib != "$linkmode" && test prog != "$linkmode"; then
+	    func_warning "'-l' is ignored for archives/objects"
 	    continue
 	  fi
 	  func_stripname '-l' '' "$deplib"
 	  name=$func_stripname_result
-	  if test "$linkmode" = lib; then
+	  if test lib = "$linkmode"; then
 	    searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
 	  else
 	    searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
@@ -6184,31 +7669,22 @@ func_mode_link ()
 	  for searchdir in $searchdirs; do
 	    for search_ext in .la $std_shrext .so .a; do
 	      # Search the libtool library
-	      lib="$searchdir/lib${name}${search_ext}"
+	      lib=$searchdir/lib$name$search_ext
 	      if test -f "$lib"; then
-		if test "$search_ext" = ".la"; then
-		  found=yes
+		if test .la = "$search_ext"; then
+		  found=:
 		else
-		  found=no
+		  found=false
 		fi
 		break 2
 	      fi
 	    done
 	  done
-	  if test "$found" != yes; then
-	    # deplib doesn't seem to be a libtool library
-	    if test "$linkmode,$pass" = "prog,link"; then
-	      compile_deplibs="$deplib $compile_deplibs"
-	      finalize_deplibs="$deplib $finalize_deplibs"
-	    else
-	      deplibs="$deplib $deplibs"
-	      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
-	    fi
-	    continue
-	  else # deplib is a libtool library
+	  if $found; then
+	    # deplib is a libtool library
 	    # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
 	    # We need to do some special things here, and not later.
-	    if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
+	    if test yes = "$allow_libtool_libs_with_static_runtimes"; then
 	      case " $predeps $postdeps " in
 	      *" $deplib "*)
 		if func_lalib_p "$lib"; then
@@ -6216,19 +7692,19 @@ func_mode_link ()
 		  old_library=
 		  func_source "$lib"
 		  for l in $old_library $library_names; do
-		    ll="$l"
+		    ll=$l
 		  done
-		  if test "X$ll" = "X$old_library" ; then # only static version available
-		    found=no
+		  if test "X$ll" = "X$old_library"; then # only static version available
+		    found=false
 		    func_dirname "$lib" "" "."
-		    ladir="$func_dirname_result"
+		    ladir=$func_dirname_result
 		    lib=$ladir/$old_library
-		    if test "$linkmode,$pass" = "prog,link"; then
+		    if test prog,link = "$linkmode,$pass"; then
 		      compile_deplibs="$deplib $compile_deplibs"
 		      finalize_deplibs="$deplib $finalize_deplibs"
 		    else
 		      deplibs="$deplib $deplibs"
-		      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
+		      test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs"
 		    fi
 		    continue
 		  fi
@@ -6237,15 +7713,25 @@ func_mode_link ()
 	      *) ;;
 	      esac
 	    fi
+	  else
+	    # deplib doesn't seem to be a libtool library
+	    if test prog,link = "$linkmode,$pass"; then
+	      compile_deplibs="$deplib $compile_deplibs"
+	      finalize_deplibs="$deplib $finalize_deplibs"
+	    else
+	      deplibs="$deplib $deplibs"
+	      test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs"
+	    fi
+	    continue
 	  fi
 	  ;; # -l
 	*.ltframework)
-	  if test "$linkmode,$pass" = "prog,link"; then
+	  if test prog,link = "$linkmode,$pass"; then
 	    compile_deplibs="$deplib $compile_deplibs"
 	    finalize_deplibs="$deplib $finalize_deplibs"
 	  else
 	    deplibs="$deplib $deplibs"
-	    if test "$linkmode" = lib ; then
+	    if test lib = "$linkmode"; then
 		case "$new_inherited_linker_flags " in
 		    *" $deplib "*) ;;
 		    * ) func_append new_inherited_linker_flags " $deplib" ;;
@@ -6258,18 +7744,18 @@ func_mode_link ()
 	  case $linkmode in
 	  lib)
 	    deplibs="$deplib $deplibs"
-	    test "$pass" = conv && continue
+	    test conv = "$pass" && continue
 	    newdependency_libs="$deplib $newdependency_libs"
 	    func_stripname '-L' '' "$deplib"
 	    func_resolve_sysroot "$func_stripname_result"
 	    func_append newlib_search_path " $func_resolve_sysroot_result"
 	    ;;
 	  prog)
-	    if test "$pass" = conv; then
+	    if test conv = "$pass"; then
 	      deplibs="$deplib $deplibs"
 	      continue
 	    fi
-	    if test "$pass" = scan; then
+	    if test scan = "$pass"; then
 	      deplibs="$deplib $deplibs"
 	    else
 	      compile_deplibs="$deplib $compile_deplibs"
@@ -6280,13 +7766,13 @@ func_mode_link ()
 	    func_append newlib_search_path " $func_resolve_sysroot_result"
 	    ;;
 	  *)
-	    func_warning "\`-L' is ignored for archives/objects"
+	    func_warning "'-L' is ignored for archives/objects"
 	    ;;
 	  esac # linkmode
 	  continue
 	  ;; # -L
 	-R*)
-	  if test "$pass" = link; then
+	  if test link = "$pass"; then
 	    func_stripname '-R' '' "$deplib"
 	    func_resolve_sysroot "$func_stripname_result"
 	    dir=$func_resolve_sysroot_result
@@ -6304,7 +7790,7 @@ func_mode_link ()
 	  lib=$func_resolve_sysroot_result
 	  ;;
 	*.$libext)
-	  if test "$pass" = conv; then
+	  if test conv = "$pass"; then
 	    deplibs="$deplib $deplibs"
 	    continue
 	  fi
@@ -6315,21 +7801,26 @@ func_mode_link ()
 	    case " $dlpreconveniencelibs " in
 	    *" $deplib "*) ;;
 	    *)
-	      valid_a_lib=no
+	      valid_a_lib=false
 	      case $deplibs_check_method in
 		match_pattern*)
 		  set dummy $deplibs_check_method; shift
 		  match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
 		  if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
 		    | $EGREP "$match_pattern_regex" > /dev/null; then
-		    valid_a_lib=yes
+		    valid_a_lib=:
 		  fi
 		;;
 		pass_all)
-		  valid_a_lib=yes
+		  valid_a_lib=:
 		;;
 	      esac
-	      if test "$valid_a_lib" != yes; then
+	      if $valid_a_lib; then
+		echo
+		$ECHO "*** Warning: Linking the shared library $output against the"
+		$ECHO "*** static library $deplib is not portable!"
+		deplibs="$deplib $deplibs"
+	      else
 		echo
 		$ECHO "*** Warning: Trying to link with static lib archive $deplib."
 		echo "*** I have the capability to make that library automatically link in when"
@@ -6337,18 +7828,13 @@ func_mode_link ()
 		echo "*** shared version of the library, which you do not appear to have"
 		echo "*** because the file extensions .$libext of this argument makes me believe"
 		echo "*** that it is just a static archive that I should not use here."
-	      else
-		echo
-		$ECHO "*** Warning: Linking the shared library $output against the"
-		$ECHO "*** static library $deplib is not portable!"
-		deplibs="$deplib $deplibs"
 	      fi
 	      ;;
 	    esac
 	    continue
 	    ;;
 	  prog)
-	    if test "$pass" != link; then
+	    if test link != "$pass"; then
 	      deplibs="$deplib $deplibs"
 	    else
 	      compile_deplibs="$deplib $compile_deplibs"
@@ -6359,10 +7845,10 @@ func_mode_link ()
 	  esac # linkmode
 	  ;; # *.$libext
 	*.lo | *.$objext)
-	  if test "$pass" = conv; then
+	  if test conv = "$pass"; then
 	    deplibs="$deplib $deplibs"
-	  elif test "$linkmode" = prog; then
-	    if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
+	  elif test prog = "$linkmode"; then
+	    if test dlpreopen = "$pass" || test yes != "$dlopen_support" || test no = "$build_libtool_libs"; then
 	      # If there is no dlopen support or we're linking statically,
 	      # we need to preload.
 	      func_append newdlprefiles " $deplib"
@@ -6375,22 +7861,20 @@ func_mode_link ()
 	  continue
 	  ;;
 	%DEPLIBS%)
-	  alldeplibs=yes
+	  alldeplibs=:
 	  continue
 	  ;;
 	esac # case $deplib
 
-	if test "$found" = yes || test -f "$lib"; then :
-	else
-	  func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
-	fi
+	$found || test -f "$lib" \
+	  || func_fatal_error "cannot find the library '$lib' or unhandled argument '$deplib'"
 
 	# Check to see that this really is a libtool archive.
 	func_lalib_unsafe_p "$lib" \
-	  || func_fatal_error "\`$lib' is not a valid libtool archive"
+	  || func_fatal_error "'$lib' is not a valid libtool archive"
 
 	func_dirname "$lib" "" "."
-	ladir="$func_dirname_result"
+	ladir=$func_dirname_result
 
 	dlname=
 	dlopen=
@@ -6420,30 +7904,30 @@ func_mode_link ()
 	  done
 	fi
 	dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
-	if test "$linkmode,$pass" = "lib,link" ||
-	   test "$linkmode,$pass" = "prog,scan" ||
-	   { test "$linkmode" != prog && test "$linkmode" != lib; }; then
+	if test lib,link = "$linkmode,$pass" ||
+	   test prog,scan = "$linkmode,$pass" ||
+	   { test prog != "$linkmode" && test lib != "$linkmode"; }; then
 	  test -n "$dlopen" && func_append dlfiles " $dlopen"
 	  test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
 	fi
 
-	if test "$pass" = conv; then
+	if test conv = "$pass"; then
 	  # Only check for convenience libraries
 	  deplibs="$lib $deplibs"
 	  if test -z "$libdir"; then
 	    if test -z "$old_library"; then
-	      func_fatal_error "cannot find name of link library for \`$lib'"
+	      func_fatal_error "cannot find name of link library for '$lib'"
 	    fi
 	    # It is a libtool convenience library, so add in its objects.
 	    func_append convenience " $ladir/$objdir/$old_library"
 	    func_append old_convenience " $ladir/$objdir/$old_library"
-	  elif test "$linkmode" != prog && test "$linkmode" != lib; then
-	    func_fatal_error "\`$lib' is not a convenience library"
+	  elif test prog != "$linkmode" && test lib != "$linkmode"; then
+	    func_fatal_error "'$lib' is not a convenience library"
 	  fi
 	  tmp_libs=
 	  for deplib in $dependency_libs; do
 	    deplibs="$deplib $deplibs"
-	    if $opt_preserve_dup_deps ; then
+	    if $opt_preserve_dup_deps; then
 	      case "$tmp_libs " in
 	      *" $deplib "*) func_append specialdeplibs " $deplib" ;;
 	      esac
@@ -6457,26 +7941,26 @@ func_mode_link ()
 	# Get the name of the library we link against.
 	linklib=
 	if test -n "$old_library" &&
-	   { test "$prefer_static_libs" = yes ||
-	     test "$prefer_static_libs,$installed" = "built,no"; }; then
+	   { test yes = "$prefer_static_libs" ||
+	     test built,no = "$prefer_static_libs,$installed"; }; then
 	  linklib=$old_library
 	else
 	  for l in $old_library $library_names; do
-	    linklib="$l"
+	    linklib=$l
 	  done
 	fi
 	if test -z "$linklib"; then
-	  func_fatal_error "cannot find name of link library for \`$lib'"
+	  func_fatal_error "cannot find name of link library for '$lib'"
 	fi
 
 	# This library was specified with -dlopen.
-	if test "$pass" = dlopen; then
-	  if test -z "$libdir"; then
-	    func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
-	  fi
+	if test dlopen = "$pass"; then
+	  test -z "$libdir" \
+	    && func_fatal_error "cannot -dlopen a convenience library: '$lib'"
 	  if test -z "$dlname" ||
-	     test "$dlopen_support" != yes ||
-	     test "$build_libtool_libs" = no; then
+	     test yes != "$dlopen_support" ||
+	     test no = "$build_libtool_libs"
+	  then
 	    # If there is no dlname, no dlopen support or we're linking
 	    # statically, we need to preload.  We also need to preload any
 	    # dependent libraries so libltdl's deplib preloader doesn't
@@ -6490,40 +7974,40 @@ func_mode_link ()
 
 	# We need an absolute path.
 	case $ladir in
-	[\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
+	[\\/]* | [A-Za-z]:[\\/]*) abs_ladir=$ladir ;;
 	*)
 	  abs_ladir=`cd "$ladir" && pwd`
 	  if test -z "$abs_ladir"; then
-	    func_warning "cannot determine absolute directory name of \`$ladir'"
+	    func_warning "cannot determine absolute directory name of '$ladir'"
 	    func_warning "passing it literally to the linker, although it might fail"
-	    abs_ladir="$ladir"
+	    abs_ladir=$ladir
 	  fi
 	  ;;
 	esac
 	func_basename "$lib"
-	laname="$func_basename_result"
+	laname=$func_basename_result
 
 	# Find the relevant object directory and library name.
-	if test "X$installed" = Xyes; then
+	if test yes = "$installed"; then
 	  if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
-	    func_warning "library \`$lib' was moved."
-	    dir="$ladir"
-	    absdir="$abs_ladir"
-	    libdir="$abs_ladir"
+	    func_warning "library '$lib' was moved."
+	    dir=$ladir
+	    absdir=$abs_ladir
+	    libdir=$abs_ladir
 	  else
-	    dir="$lt_sysroot$libdir"
-	    absdir="$lt_sysroot$libdir"
+	    dir=$lt_sysroot$libdir
+	    absdir=$lt_sysroot$libdir
 	  fi
-	  test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
+	  test yes = "$hardcode_automatic" && avoidtemprpath=yes
 	else
 	  if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
-	    dir="$ladir"
-	    absdir="$abs_ladir"
+	    dir=$ladir
+	    absdir=$abs_ladir
 	    # Remove this search path later
 	    func_append notinst_path " $abs_ladir"
 	  else
-	    dir="$ladir/$objdir"
-	    absdir="$abs_ladir/$objdir"
+	    dir=$ladir/$objdir
+	    absdir=$abs_ladir/$objdir
 	    # Remove this search path later
 	    func_append notinst_path " $abs_ladir"
 	  fi
@@ -6532,11 +8016,11 @@ func_mode_link ()
 	name=$func_stripname_result
 
 	# This library was specified with -dlpreopen.
-	if test "$pass" = dlpreopen; then
-	  if test -z "$libdir" && test "$linkmode" = prog; then
-	    func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
+	if test dlpreopen = "$pass"; then
+	  if test -z "$libdir" && test prog = "$linkmode"; then
+	    func_fatal_error "only libraries may -dlpreopen a convenience library: '$lib'"
 	  fi
-	  case "$host" in
+	  case $host in
 	    # special handling for platforms with PE-DLLs.
 	    *cygwin* | *mingw* | *cegcc* )
 	      # Linker will automatically link against shared library if both
@@ -6580,9 +8064,9 @@ func_mode_link ()
 
 	if test -z "$libdir"; then
 	  # Link the convenience library
-	  if test "$linkmode" = lib; then
+	  if test lib = "$linkmode"; then
 	    deplibs="$dir/$old_library $deplibs"
-	  elif test "$linkmode,$pass" = "prog,link"; then
+	  elif test prog,link = "$linkmode,$pass"; then
 	    compile_deplibs="$dir/$old_library $compile_deplibs"
 	    finalize_deplibs="$dir/$old_library $finalize_deplibs"
 	  else
@@ -6592,14 +8076,14 @@ func_mode_link ()
 	fi
 
 
-	if test "$linkmode" = prog && test "$pass" != link; then
+	if test prog = "$linkmode" && test link != "$pass"; then
 	  func_append newlib_search_path " $ladir"
 	  deplibs="$lib $deplibs"
 
-	  linkalldeplibs=no
-	  if test "$link_all_deplibs" != no || test -z "$library_names" ||
-	     test "$build_libtool_libs" = no; then
-	    linkalldeplibs=yes
+	  linkalldeplibs=false
+	  if test no != "$link_all_deplibs" || test -z "$library_names" ||
+	     test no = "$build_libtool_libs"; then
+	    linkalldeplibs=:
 	  fi
 
 	  tmp_libs=
@@ -6611,14 +8095,14 @@ func_mode_link ()
 		 ;;
 	    esac
 	    # Need to link against all dependency_libs?
-	    if test "$linkalldeplibs" = yes; then
+	    if $linkalldeplibs; then
 	      deplibs="$deplib $deplibs"
 	    else
 	      # Need to hardcode shared library paths
 	      # or/and link against static libraries
 	      newdependency_libs="$deplib $newdependency_libs"
 	    fi
-	    if $opt_preserve_dup_deps ; then
+	    if $opt_preserve_dup_deps; then
 	      case "$tmp_libs " in
 	      *" $deplib "*) func_append specialdeplibs " $deplib" ;;
 	      esac
@@ -6628,15 +8112,15 @@ func_mode_link ()
 	  continue
 	fi # $linkmode = prog...
 
-	if test "$linkmode,$pass" = "prog,link"; then
+	if test prog,link = "$linkmode,$pass"; then
 	  if test -n "$library_names" &&
-	     { { test "$prefer_static_libs" = no ||
-	         test "$prefer_static_libs,$installed" = "built,yes"; } ||
+	     { { test no = "$prefer_static_libs" ||
+	         test built,yes = "$prefer_static_libs,$installed"; } ||
 	       test -z "$old_library"; }; then
 	    # We need to hardcode the library path
-	    if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
+	    if test -n "$shlibpath_var" && test -z "$avoidtemprpath"; then
 	      # Make sure the rpath contains only unique directories.
-	      case "$temp_rpath:" in
+	      case $temp_rpath: in
 	      *"$absdir:"*) ;;
 	      *) func_append temp_rpath "$absdir:" ;;
 	      esac
@@ -6665,9 +8149,9 @@ func_mode_link ()
 	    esac
 	  fi # $linkmode,$pass = prog,link...
 
-	  if test "$alldeplibs" = yes &&
-	     { test "$deplibs_check_method" = pass_all ||
-	       { test "$build_libtool_libs" = yes &&
+	  if $alldeplibs &&
+	     { test pass_all = "$deplibs_check_method" ||
+	       { test yes = "$build_libtool_libs" &&
 		 test -n "$library_names"; }; }; then
 	    # We only need to search for static libraries
 	    continue
@@ -6676,19 +8160,19 @@ func_mode_link ()
 
 	link_static=no # Whether the deplib will be linked statically
 	use_static_libs=$prefer_static_libs
-	if test "$use_static_libs" = built && test "$installed" = yes; then
+	if test built = "$use_static_libs" && test yes = "$installed"; then
 	  use_static_libs=no
 	fi
 	if test -n "$library_names" &&
-	   { test "$use_static_libs" = no || test -z "$old_library"; }; then
+	   { test no = "$use_static_libs" || test -z "$old_library"; }; then
 	  case $host in
-	  *cygwin* | *mingw* | *cegcc*)
+	  *cygwin* | *mingw* | *cegcc* | *os2*)
 	      # No point in relinking DLLs because paths are not encoded
 	      func_append notinst_deplibs " $lib"
 	      need_relink=no
 	    ;;
 	  *)
-	    if test "$installed" = no; then
+	    if test no = "$installed"; then
 	      func_append notinst_deplibs " $lib"
 	      need_relink=yes
 	    fi
@@ -6698,24 +8182,24 @@ func_mode_link ()
 
 	  # Warn about portability, can't link against -module's on some
 	  # systems (darwin).  Don't bleat about dlopened modules though!
-	  dlopenmodule=""
+	  dlopenmodule=
 	  for dlpremoduletest in $dlprefiles; do
 	    if test "X$dlpremoduletest" = "X$lib"; then
-	      dlopenmodule="$dlpremoduletest"
+	      dlopenmodule=$dlpremoduletest
 	      break
 	    fi
 	  done
-	  if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
+	  if test -z "$dlopenmodule" && test yes = "$shouldnotlink" && test link = "$pass"; then
 	    echo
-	    if test "$linkmode" = prog; then
+	    if test prog = "$linkmode"; then
 	      $ECHO "*** Warning: Linking the executable $output against the loadable module"
 	    else
 	      $ECHO "*** Warning: Linking the shared library $output against the loadable module"
 	    fi
 	    $ECHO "*** $linklib is not portable!"
 	  fi
-	  if test "$linkmode" = lib &&
-	     test "$hardcode_into_libs" = yes; then
+	  if test lib = "$linkmode" &&
+	     test yes = "$hardcode_into_libs"; then
 	    # Hardcode the library path.
 	    # Skip directories that are in the system default run-time
 	    # search path.
@@ -6743,43 +8227,43 @@ func_mode_link ()
 	    # figure out the soname
 	    set dummy $library_names
 	    shift
-	    realname="$1"
+	    realname=$1
 	    shift
 	    libname=`eval "\\$ECHO \"$libname_spec\""`
 	    # use dlname if we got it. it's perfectly good, no?
 	    if test -n "$dlname"; then
-	      soname="$dlname"
+	      soname=$dlname
 	    elif test -n "$soname_spec"; then
 	      # bleh windows
 	      case $host in
-	      *cygwin* | mingw* | *cegcc*)
+	      *cygwin* | mingw* | *cegcc*)  # | *os2* # SDL customization: removed OS/2 versioning support.
 	        func_arith $current - $age
 		major=$func_arith_result
-		versuffix="-$major"
+		versuffix=-$major
 		;;
 	      esac
 	      eval soname=\"$soname_spec\"
 	    else
-	      soname="$realname"
+	      soname=$realname
 	    fi
 
 	    # Make a new name for the extract_expsyms_cmds to use
-	    soroot="$soname"
+	    soroot=$soname
 	    func_basename "$soroot"
-	    soname="$func_basename_result"
+	    soname=$func_basename_result
 	    func_stripname 'lib' '.dll' "$soname"
 	    newlib=libimp-$func_stripname_result.a
 
 	    # If the library has no export list, then create one now
 	    if test -f "$output_objdir/$soname-def"; then :
 	    else
-	      func_verbose "extracting exported symbol list from \`$soname'"
+	      func_verbose "extracting exported symbol list from '$soname'"
 	      func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
 	    fi
 
 	    # Create $newlib
 	    if test -f "$output_objdir/$newlib"; then :; else
-	      func_verbose "generating import library for \`$soname'"
+	      func_verbose "generating import library for '$soname'"
 	      func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
 	    fi
 	    # make sure the library variables are pointing to the new library
@@ -6787,58 +8271,58 @@ func_mode_link ()
 	    linklib=$newlib
 	  fi # test -n "$old_archive_from_expsyms_cmds"
 
-	  if test "$linkmode" = prog || test "$opt_mode" != relink; then
+	  if test prog = "$linkmode" || test relink != "$opt_mode"; then
 	    add_shlibpath=
 	    add_dir=
 	    add=
 	    lib_linked=yes
 	    case $hardcode_action in
 	    immediate | unsupported)
-	      if test "$hardcode_direct" = no; then
-		add="$dir/$linklib"
+	      if test no = "$hardcode_direct"; then
+		add=$dir/$linklib
 		case $host in
-		  *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
-		  *-*-sysv4*uw2*) add_dir="-L$dir" ;;
+		  *-*-sco3.2v5.0.[024]*) add_dir=-L$dir ;;
+		  *-*-sysv4*uw2*) add_dir=-L$dir ;;
 		  *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
-		    *-*-unixware7*) add_dir="-L$dir" ;;
+		    *-*-unixware7*) add_dir=-L$dir ;;
 		  *-*-darwin* )
-		    # if the lib is a (non-dlopened) module then we can not
+		    # if the lib is a (non-dlopened) module then we cannot
 		    # link against it, someone is ignoring the earlier warnings
 		    if /usr/bin/file -L $add 2> /dev/null |
-			 $GREP ": [^:]* bundle" >/dev/null ; then
+			 $GREP ": [^:]* bundle" >/dev/null; then
 		      if test "X$dlopenmodule" != "X$lib"; then
 			$ECHO "*** Warning: lib $linklib is a module, not a shared library"
-			if test -z "$old_library" ; then
+			if test -z "$old_library"; then
 			  echo
 			  echo "*** And there doesn't seem to be a static archive available"
 			  echo "*** The link will probably fail, sorry"
 			else
-			  add="$dir/$old_library"
+			  add=$dir/$old_library
 			fi
 		      elif test -n "$old_library"; then
-			add="$dir/$old_library"
+			add=$dir/$old_library
 		      fi
 		    fi
 		esac
-	      elif test "$hardcode_minus_L" = no; then
+	      elif test no = "$hardcode_minus_L"; then
 		case $host in
-		*-*-sunos*) add_shlibpath="$dir" ;;
+		*-*-sunos*) add_shlibpath=$dir ;;
 		esac
-		add_dir="-L$dir"
-		add="-l$name"
-	      elif test "$hardcode_shlibpath_var" = no; then
-		add_shlibpath="$dir"
-		add="-l$name"
+		add_dir=-L$dir
+		add=-l$name
+	      elif test no = "$hardcode_shlibpath_var"; then
+		add_shlibpath=$dir
+		add=-l$name
 	      else
 		lib_linked=no
 	      fi
 	      ;;
 	    relink)
-	      if test "$hardcode_direct" = yes &&
-	         test "$hardcode_direct_absolute" = no; then
-		add="$dir/$linklib"
-	      elif test "$hardcode_minus_L" = yes; then
-		add_dir="-L$absdir"
+	      if test yes = "$hardcode_direct" &&
+	         test no = "$hardcode_direct_absolute"; then
+		add=$dir/$linklib
+	      elif test yes = "$hardcode_minus_L"; then
+		add_dir=-L$absdir
 		# Try looking first in the location we're being installed to.
 		if test -n "$inst_prefix_dir"; then
 		  case $libdir in
@@ -6847,10 +8331,10 @@ func_mode_link ()
 		      ;;
 		  esac
 		fi
-		add="-l$name"
-	      elif test "$hardcode_shlibpath_var" = yes; then
-		add_shlibpath="$dir"
-		add="-l$name"
+		add=-l$name
+	      elif test yes = "$hardcode_shlibpath_var"; then
+		add_shlibpath=$dir
+		add=-l$name
 	      else
 		lib_linked=no
 	      fi
@@ -6858,7 +8342,7 @@ func_mode_link ()
 	    *) lib_linked=no ;;
 	    esac
 
-	    if test "$lib_linked" != yes; then
+	    if test yes != "$lib_linked"; then
 	      func_fatal_configuration "unsupported hardcode properties"
 	    fi
 
@@ -6868,15 +8352,15 @@ func_mode_link ()
 	      *) func_append compile_shlibpath "$add_shlibpath:" ;;
 	      esac
 	    fi
-	    if test "$linkmode" = prog; then
+	    if test prog = "$linkmode"; then
 	      test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
 	      test -n "$add" && compile_deplibs="$add $compile_deplibs"
 	    else
 	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
 	      test -n "$add" && deplibs="$add $deplibs"
-	      if test "$hardcode_direct" != yes &&
-		 test "$hardcode_minus_L" != yes &&
-		 test "$hardcode_shlibpath_var" = yes; then
+	      if test yes != "$hardcode_direct" &&
+		 test yes != "$hardcode_minus_L" &&
+		 test yes = "$hardcode_shlibpath_var"; then
 		case :$finalize_shlibpath: in
 		*":$libdir:"*) ;;
 		*) func_append finalize_shlibpath "$libdir:" ;;
@@ -6885,33 +8369,33 @@ func_mode_link ()
 	    fi
 	  fi
 
-	  if test "$linkmode" = prog || test "$opt_mode" = relink; then
+	  if test prog = "$linkmode" || test relink = "$opt_mode"; then
 	    add_shlibpath=
 	    add_dir=
 	    add=
 	    # Finalize command for both is simple: just hardcode it.
-	    if test "$hardcode_direct" = yes &&
-	       test "$hardcode_direct_absolute" = no; then
-	      add="$libdir/$linklib"
-	    elif test "$hardcode_minus_L" = yes; then
-	      add_dir="-L$libdir"
-	      add="-l$name"
-	    elif test "$hardcode_shlibpath_var" = yes; then
+	    if test yes = "$hardcode_direct" &&
+	       test no = "$hardcode_direct_absolute"; then
+	      add=$libdir/$linklib
+	    elif test yes = "$hardcode_minus_L"; then
+	      add_dir=-L$libdir
+	      add=-l$name
+	    elif test yes = "$hardcode_shlibpath_var"; then
 	      case :$finalize_shlibpath: in
 	      *":$libdir:"*) ;;
 	      *) func_append finalize_shlibpath "$libdir:" ;;
 	      esac
-	      add="-l$name"
-	    elif test "$hardcode_automatic" = yes; then
+	      add=-l$name
+	    elif test yes = "$hardcode_automatic"; then
 	      if test -n "$inst_prefix_dir" &&
-		 test -f "$inst_prefix_dir$libdir/$linklib" ; then
-		add="$inst_prefix_dir$libdir/$linklib"
+		 test -f "$inst_prefix_dir$libdir/$linklib"; then
+		add=$inst_prefix_dir$libdir/$linklib
 	      else
-		add="$libdir/$linklib"
+		add=$libdir/$linklib
 	      fi
 	    else
 	      # We cannot seem to hardcode it, guess we'll fake it.
-	      add_dir="-L$libdir"
+	      add_dir=-L$libdir
 	      # Try looking first in the location we're being installed to.
 	      if test -n "$inst_prefix_dir"; then
 		case $libdir in
@@ -6920,10 +8404,10 @@ func_mode_link ()
 		    ;;
 		esac
 	      fi
-	      add="-l$name"
+	      add=-l$name
 	    fi
 
-	    if test "$linkmode" = prog; then
+	    if test prog = "$linkmode"; then
 	      test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
 	      test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
 	    else
@@ -6931,43 +8415,43 @@ func_mode_link ()
 	      test -n "$add" && deplibs="$add $deplibs"
 	    fi
 	  fi
-	elif test "$linkmode" = prog; then
+	elif test prog = "$linkmode"; then
 	  # Here we assume that one of hardcode_direct or hardcode_minus_L
 	  # is not unsupported.  This is valid on all known static and
 	  # shared platforms.
-	  if test "$hardcode_direct" != unsupported; then
-	    test -n "$old_library" && linklib="$old_library"
+	  if test unsupported != "$hardcode_direct"; then
+	    test -n "$old_library" && linklib=$old_library
 	    compile_deplibs="$dir/$linklib $compile_deplibs"
 	    finalize_deplibs="$dir/$linklib $finalize_deplibs"
 	  else
 	    compile_deplibs="-l$name -L$dir $compile_deplibs"
 	    finalize_deplibs="-l$name -L$dir $finalize_deplibs"
 	  fi
-	elif test "$build_libtool_libs" = yes; then
+	elif test yes = "$build_libtool_libs"; then
 	  # Not a shared library
-	  if test "$deplibs_check_method" != pass_all; then
+	  if test pass_all != "$deplibs_check_method"; then
 	    # We're trying link a shared library against a static one
 	    # but the system doesn't support it.
 
 	    # Just print a warning and add the library to dependency_libs so
 	    # that the program can be linked against the static library.
 	    echo
-	    $ECHO "*** Warning: This system can not link to static lib archive $lib."
+	    $ECHO "*** Warning: This system cannot link to static lib archive $lib."
 	    echo "*** I have the capability to make that library automatically link in when"
 	    echo "*** you link to this library.  But I can only do this if you have a"
 	    echo "*** shared version of the library, which you do not appear to have."
-	    if test "$module" = yes; then
+	    if test yes = "$module"; then
 	      echo "*** But as you try to build a module library, libtool will still create "
 	      echo "*** a static module, that should work as long as the dlopening application"
 	      echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
 	      if test -z "$global_symbol_pipe"; then
 		echo
 		echo "*** However, this would only work if libtool was able to extract symbol"
-		echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
+		echo "*** lists from a program, using 'nm' or equivalent, but libtool could"
 		echo "*** not find such a program.  So, this module is probably useless."
-		echo "*** \`nm' from GNU binutils and a full rebuild may help."
+		echo "*** 'nm' from GNU binutils and a full rebuild may help."
 	      fi
-	      if test "$build_old_libs" = no; then
+	      if test no = "$build_old_libs"; then
 		build_libtool_libs=module
 		build_old_libs=yes
 	      else
@@ -6980,11 +8464,11 @@ func_mode_link ()
 	  fi
 	fi # link shared/static library?
 
-	if test "$linkmode" = lib; then
+	if test lib = "$linkmode"; then
 	  if test -n "$dependency_libs" &&
-	     { test "$hardcode_into_libs" != yes ||
-	       test "$build_old_libs" = yes ||
-	       test "$link_static" = yes; }; then
+	     { test yes != "$hardcode_into_libs" ||
+	       test yes = "$build_old_libs" ||
+	       test yes = "$link_static"; }; then
 	    # Extract -R from dependency_libs
 	    temp_deplibs=
 	    for libdir in $dependency_libs; do
@@ -6998,12 +8482,12 @@ func_mode_link ()
 	      *) func_append temp_deplibs " $libdir";;
 	      esac
 	    done
-	    dependency_libs="$temp_deplibs"
+	    dependency_libs=$temp_deplibs
 	  fi
 
 	  func_append newlib_search_path " $absdir"
 	  # Link against this library
-	  test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
+	  test no = "$link_static" && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
 	  # ... and its dependency_libs
 	  tmp_libs=
 	  for deplib in $dependency_libs; do
@@ -7013,7 +8497,7 @@ func_mode_link ()
                    func_resolve_sysroot "$func_stripname_result";;
               *) func_resolve_sysroot "$deplib" ;;
             esac
-	    if $opt_preserve_dup_deps ; then
+	    if $opt_preserve_dup_deps; then
 	      case "$tmp_libs " in
 	      *" $func_resolve_sysroot_result "*)
                 func_append specialdeplibs " $func_resolve_sysroot_result" ;;
@@ -7022,12 +8506,12 @@ func_mode_link ()
 	    func_append tmp_libs " $func_resolve_sysroot_result"
 	  done
 
-	  if test "$link_all_deplibs" != no; then
+	  if test no != "$link_all_deplibs"; then
 	    # Add the search paths of all dependency libraries
 	    for deplib in $dependency_libs; do
 	      path=
 	      case $deplib in
-	      -L*) path="$deplib" ;;
+	      -L*) path=$deplib ;;
 	      *.la)
 	        func_resolve_sysroot "$deplib"
 	        deplib=$func_resolve_sysroot_result
@@ -7035,12 +8519,12 @@ func_mode_link ()
 		dir=$func_dirname_result
 		# We need an absolute path.
 		case $dir in
-		[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
+		[\\/]* | [A-Za-z]:[\\/]*) absdir=$dir ;;
 		*)
 		  absdir=`cd "$dir" && pwd`
 		  if test -z "$absdir"; then
-		    func_warning "cannot determine absolute directory name of \`$dir'"
-		    absdir="$dir"
+		    func_warning "cannot determine absolute directory name of '$dir'"
+		    absdir=$dir
 		  fi
 		  ;;
 		esac
@@ -7048,35 +8532,35 @@ func_mode_link ()
 		case $host in
 		*-*-darwin*)
 		  depdepl=
-		  eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
-		  if test -n "$deplibrary_names" ; then
-		    for tmp in $deplibrary_names ; do
+		  eval deplibrary_names=`$SED -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
+		  if test -n "$deplibrary_names"; then
+		    for tmp in $deplibrary_names; do
 		      depdepl=$tmp
 		    done
-		    if test -f "$absdir/$objdir/$depdepl" ; then
-		      depdepl="$absdir/$objdir/$depdepl"
-		      darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
+		    if test -f "$absdir/$objdir/$depdepl"; then
+		      depdepl=$absdir/$objdir/$depdepl
+		      darwin_install_name=`$OTOOL -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
                       if test -z "$darwin_install_name"; then
-                          darwin_install_name=`${OTOOL64} -L $depdepl  | awk '{if (NR == 2) {print $1;exit}}'`
+                          darwin_install_name=`$OTOOL64 -L $depdepl  | awk '{if (NR == 2) {print $1;exit}}'`
                       fi
-		      func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
-		      func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"
+		      func_append compiler_flags " $wl-dylib_file $wl$darwin_install_name:$depdepl"
+		      func_append linker_flags " -dylib_file $darwin_install_name:$depdepl"
 		      path=
 		    fi
 		  fi
 		  ;;
 		*)
-		  path="-L$absdir/$objdir"
+		  path=-L$absdir/$objdir
 		  ;;
 		esac
 		else
-		  eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
+		  eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
 		  test -z "$libdir" && \
-		    func_fatal_error "\`$deplib' is not a valid libtool archive"
+		    func_fatal_error "'$deplib' is not a valid libtool archive"
 		  test "$absdir" != "$libdir" && \
-		    func_warning "\`$deplib' seems to be moved"
+		    func_warning "'$deplib' seems to be moved"
 
-		  path="-L$absdir"
+		  path=-L$absdir
 		fi
 		;;
 	      esac
@@ -7088,23 +8572,23 @@ func_mode_link ()
 	  fi # link_all_deplibs != no
 	fi # linkmode = lib
       done # for deplib in $libs
-      if test "$pass" = link; then
-	if test "$linkmode" = "prog"; then
+      if test link = "$pass"; then
+	if test prog = "$linkmode"; then
 	  compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
 	  finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
 	else
 	  compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
 	fi
       fi
-      dependency_libs="$newdependency_libs"
-      if test "$pass" = dlpreopen; then
+      dependency_libs=$newdependency_libs
+      if test dlpreopen = "$pass"; then
 	# Link the dlpreopened libraries before other libraries
 	for deplib in $save_deplibs; do
 	  deplibs="$deplib $deplibs"
 	done
       fi
-      if test "$pass" != dlopen; then
-	if test "$pass" != conv; then
+      if test dlopen != "$pass"; then
+	test conv = "$pass" || {
 	  # Make sure lib_search_path contains only unique directories.
 	  lib_search_path=
 	  for dir in $newlib_search_path; do
@@ -7114,12 +8598,12 @@ func_mode_link ()
 	    esac
 	  done
 	  newlib_search_path=
-	fi
+	}
 
-	if test "$linkmode,$pass" != "prog,link"; then
-	  vars="deplibs"
-	else
+	if test prog,link = "$linkmode,$pass"; then
 	  vars="compile_deplibs finalize_deplibs"
+	else
+	  vars=deplibs
 	fi
 	for var in $vars dependency_libs; do
 	  # Add libraries to $var in reverse order
@@ -7177,62 +8661,93 @@ func_mode_link ()
 	  eval $var=\"$tmp_libs\"
 	done # for var
       fi
+
+      # Add Sun CC postdeps if required:
+      test CXX = "$tagname" && {
+        case $host_os in
+        linux*)
+          case `$CC -V 2>&1 | sed 5q` in
+          *Sun\ C*) # Sun C++ 5.9
+            func_suncc_cstd_abi
+
+            if test no != "$suncc_use_cstd_abi"; then
+              func_append postdeps ' -library=Cstd -library=Crun'
+            fi
+            ;;
+          esac
+          ;;
+
+        solaris*)
+          func_cc_basename "$CC"
+          case $func_cc_basename_result in
+          CC* | sunCC*)
+            func_suncc_cstd_abi
+
+            if test no != "$suncc_use_cstd_abi"; then
+              func_append postdeps ' -library=Cstd -library=Crun'
+            fi
+            ;;
+          esac
+          ;;
+        esac
+      }
+
       # Last step: remove runtime libs from dependency_libs
       # (they stay in deplibs)
       tmp_libs=
-      for i in $dependency_libs ; do
+      for i in $dependency_libs; do
 	case " $predeps $postdeps $compiler_lib_search_path " in
 	*" $i "*)
-	  i=""
+	  i=
 	  ;;
 	esac
-	if test -n "$i" ; then
+	if test -n "$i"; then
 	  func_append tmp_libs " $i"
 	fi
       done
       dependency_libs=$tmp_libs
     done # for pass
-    if test "$linkmode" = prog; then
-      dlfiles="$newdlfiles"
+    if test prog = "$linkmode"; then
+      dlfiles=$newdlfiles
     fi
-    if test "$linkmode" = prog || test "$linkmode" = lib; then
-      dlprefiles="$newdlprefiles"
+    if test prog = "$linkmode" || test lib = "$linkmode"; then
+      dlprefiles=$newdlprefiles
     fi
 
     case $linkmode in
     oldlib)
-      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
-	func_warning "\`-dlopen' is ignored for archives"
+      if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
+	func_warning "'-dlopen' is ignored for archives"
       fi
 
       case " $deplibs" in
       *\ -l* | *\ -L*)
-	func_warning "\`-l' and \`-L' are ignored for archives" ;;
+	func_warning "'-l' and '-L' are ignored for archives" ;;
       esac
 
       test -n "$rpath" && \
-	func_warning "\`-rpath' is ignored for archives"
+	func_warning "'-rpath' is ignored for archives"
 
       test -n "$xrpath" && \
-	func_warning "\`-R' is ignored for archives"
+	func_warning "'-R' is ignored for archives"
 
       test -n "$vinfo" && \
-	func_warning "\`-version-info/-version-number' is ignored for archives"
+	func_warning "'-version-info/-version-number' is ignored for archives"
 
       test -n "$release" && \
-	func_warning "\`-release' is ignored for archives"
+	func_warning "'-release' is ignored for archives"
 
       test -n "$export_symbols$export_symbols_regex" && \
-	func_warning "\`-export-symbols' is ignored for archives"
+	func_warning "'-export-symbols' is ignored for archives"
 
       # Now set the variables for building old libraries.
       build_libtool_libs=no
-      oldlibs="$output"
+      oldlibs=$output
       func_append objs "$old_deplibs"
       ;;
 
     lib)
-      # Make sure we only generate libraries of the form `libNAME.la'.
+      # Make sure we only generate libraries of the form 'libNAME.la'.
       case $outputname in
       lib*)
 	func_stripname 'lib' '.la' "$outputname"
@@ -7241,10 +8756,10 @@ func_mode_link ()
 	eval libname=\"$libname_spec\"
 	;;
       *)
-	test "$module" = no && \
-	  func_fatal_help "libtool library \`$output' must begin with \`lib'"
+	test no = "$module" \
+	  && func_fatal_help "libtool library '$output' must begin with 'lib'"
 
-	if test "$need_lib_prefix" != no; then
+	if test no != "$need_lib_prefix"; then
 	  # Add the "lib" prefix for modules if required
 	  func_stripname '' '.la' "$outputname"
 	  name=$func_stripname_result
@@ -7258,8 +8773,8 @@ func_mode_link ()
       esac
 
       if test -n "$objs"; then
-	if test "$deplibs_check_method" != pass_all; then
-	  func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
+	if test pass_all != "$deplibs_check_method"; then
+	  func_fatal_error "cannot build libtool library '$output' from non-libtool objects on this host:$objs"
 	else
 	  echo
 	  $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
@@ -7268,21 +8783,21 @@ func_mode_link ()
 	fi
       fi
 
-      test "$dlself" != no && \
-	func_warning "\`-dlopen self' is ignored for libtool libraries"
+      test no = "$dlself" \
+	|| func_warning "'-dlopen self' is ignored for libtool libraries"
 
       set dummy $rpath
       shift
-      test "$#" -gt 1 && \
-	func_warning "ignoring multiple \`-rpath's for a libtool library"
+      test 1 -lt "$#" \
+	&& func_warning "ignoring multiple '-rpath's for a libtool library"
 
-      install_libdir="$1"
+      install_libdir=$1
 
       oldlibs=
       if test -z "$rpath"; then
-	if test "$build_libtool_libs" = yes; then
+	if test yes = "$build_libtool_libs"; then
 	  # Building a libtool convenience library.
-	  # Some compilers have problems with a `.al' extension so
+	  # Some compilers have problems with a '.al' extension so
 	  # convenience libraries should have the same extension an
 	  # archive normally would.
 	  oldlibs="$output_objdir/$libname.$libext $oldlibs"
@@ -7291,20 +8806,20 @@ func_mode_link ()
 	fi
 
 	test -n "$vinfo" && \
-	  func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
+	  func_warning "'-version-info/-version-number' is ignored for convenience libraries"
 
 	test -n "$release" && \
-	  func_warning "\`-release' is ignored for convenience libraries"
+	  func_warning "'-release' is ignored for convenience libraries"
       else
 
 	# Parse the version information argument.
-	save_ifs="$IFS"; IFS=':'
+	save_ifs=$IFS; IFS=:
 	set dummy $vinfo 0 0 0
 	shift
-	IFS="$save_ifs"
+	IFS=$save_ifs
 
 	test -n "$7" && \
-	  func_fatal_help "too many parameters to \`-version-info'"
+	  func_fatal_help "too many parameters to '-version-info'"
 
 	# convert absolute version numbers to libtool ages
 	# this retains compatibility with .la files and attempts
@@ -7312,42 +8827,42 @@ func_mode_link ()
 
 	case $vinfo_number in
 	yes)
-	  number_major="$1"
-	  number_minor="$2"
-	  number_revision="$3"
+	  number_major=$1
+	  number_minor=$2
+	  number_revision=$3
 	  #
 	  # There are really only two kinds -- those that
 	  # use the current revision as the major version
 	  # and those that subtract age and use age as
 	  # a minor version.  But, then there is irix
-	  # which has an extra 1 added just for fun
+	  # that has an extra 1 added just for fun
 	  #
 	  case $version_type in
 	  # correct linux to gnu/linux during the next big refactor
-	  darwin|linux|osf|windows|none)
+	  darwin|freebsd-elf|linux|midnightbsd-elf|osf|windows|none)
 	    func_arith $number_major + $number_minor
 	    current=$func_arith_result
-	    age="$number_minor"
-	    revision="$number_revision"
+	    age=$number_minor
+	    revision=$number_revision
 	    ;;
-	  freebsd-aout|freebsd-elf|qnx|sunos)
-	    current="$number_major"
-	    revision="$number_minor"
-	    age="0"
+	  freebsd-aout|qnx|sunos)
+	    current=$number_major
+	    revision=$number_minor
+	    age=0
 	    ;;
 	  irix|nonstopux)
 	    func_arith $number_major + $number_minor
 	    current=$func_arith_result
-	    age="$number_minor"
-	    revision="$number_minor"
+	    age=$number_minor
+	    revision=$number_minor
 	    lt_irix_increment=no
 	    ;;
 	  esac
 	  ;;
 	no)
-	  current="$1"
-	  revision="$2"
-	  age="$3"
+	  current=$1
+	  revision=$2
+	  age=$3
 	  ;;
 	esac
 
@@ -7355,30 +8870,30 @@ func_mode_link ()
 	case $current in
 	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
 	*)
-	  func_error "CURRENT \`$current' must be a nonnegative integer"
-	  func_fatal_error "\`$vinfo' is not valid version information"
+	  func_error "CURRENT '$current' must be a nonnegative integer"
+	  func_fatal_error "'$vinfo' is not valid version information"
 	  ;;
 	esac
 
 	case $revision in
 	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
 	*)
-	  func_error "REVISION \`$revision' must be a nonnegative integer"
-	  func_fatal_error "\`$vinfo' is not valid version information"
+	  func_error "REVISION '$revision' must be a nonnegative integer"
+	  func_fatal_error "'$vinfo' is not valid version information"
 	  ;;
 	esac
 
 	case $age in
 	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
 	*)
-	  func_error "AGE \`$age' must be a nonnegative integer"
-	  func_fatal_error "\`$vinfo' is not valid version information"
+	  func_error "AGE '$age' must be a nonnegative integer"
+	  func_fatal_error "'$vinfo' is not valid version information"
 	  ;;
 	esac
 
 	if test "$age" -gt "$current"; then
-	  func_error "AGE \`$age' is greater than the current interface number \`$current'"
-	  func_fatal_error "\`$vinfo' is not valid version information"
+	  func_error "AGE '$age' is greater than the current interface number '$current'"
+	  func_fatal_error "'$vinfo' is not valid version information"
 	fi
 
 	# Calculate the version variables.
@@ -7393,26 +8908,36 @@ func_mode_link ()
 	  # verstring for coding it into the library header
 	  func_arith $current - $age
 	  major=.$func_arith_result
-	  versuffix="$major.$age.$revision"
+	  versuffix=$major.$age.$revision
 	  # Darwin ld doesn't like 0 for these options...
 	  func_arith $current + 1
 	  minor_current=$func_arith_result
-	  xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
+	  xlcverstring="$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision"
 	  verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
+          # On Darwin other compilers
+          case $CC in
+              nagfor*)
+                  verstring="$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision"
+                  ;;
+              *)
+                  verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
+                  ;;
+          esac
 	  ;;
 
 	freebsd-aout)
-	  major=".$current"
-	  versuffix=".$current.$revision";
+	  major=.$current
+	  versuffix=.$current.$revision
 	  ;;
 
-	freebsd-elf)
-	  major=".$current"
-	  versuffix=".$current"
+	freebsd-elf | midnightbsd-elf)
+	  func_arith $current - $age
+	  major=.$func_arith_result
+	  versuffix=$major.$age.$revision
 	  ;;
 
 	irix | nonstopux)
-	  if test "X$lt_irix_increment" = "Xno"; then
+	  if test no = "$lt_irix_increment"; then
 	    func_arith $current - $age
 	  else
 	    func_arith $current - $age + 1
@@ -7423,69 +8948,74 @@ func_mode_link ()
 	    nonstopux) verstring_prefix=nonstopux ;;
 	    *)         verstring_prefix=sgi ;;
 	  esac
-	  verstring="$verstring_prefix$major.$revision"
+	  verstring=$verstring_prefix$major.$revision
 
 	  # Add in all the interfaces that we are compatible with.
 	  loop=$revision
-	  while test "$loop" -ne 0; do
+	  while test 0 -ne "$loop"; do
 	    func_arith $revision - $loop
 	    iface=$func_arith_result
 	    func_arith $loop - 1
 	    loop=$func_arith_result
-	    verstring="$verstring_prefix$major.$iface:$verstring"
+	    verstring=$verstring_prefix$major.$iface:$verstring
 	  done
 
-	  # Before this point, $major must not contain `.'.
+	  # Before this point, $major must not contain '.'.
 	  major=.$major
-	  versuffix="$major.$revision"
+	  versuffix=$major.$revision
 	  ;;
 
 	linux) # correct to gnu/linux during the next big refactor
 	  func_arith $current - $age
 	  major=.$func_arith_result
-	  versuffix="$major.$age.$revision"
+	  versuffix=$major.$age.$revision
 	  ;;
 
 	osf)
 	  func_arith $current - $age
 	  major=.$func_arith_result
-	  versuffix=".$current.$age.$revision"
-	  verstring="$current.$age.$revision"
+	  versuffix=.$current.$age.$revision
+	  verstring=$current.$age.$revision
 
 	  # Add in all the interfaces that we are compatible with.
 	  loop=$age
-	  while test "$loop" -ne 0; do
+	  while test 0 -ne "$loop"; do
 	    func_arith $current - $loop
 	    iface=$func_arith_result
 	    func_arith $loop - 1
 	    loop=$func_arith_result
-	    verstring="$verstring:${iface}.0"
+	    verstring=$verstring:$iface.0
 	  done
 
 	  # Make executables depend on our current version.
-	  func_append verstring ":${current}.0"
+	  func_append verstring ":$current.0"
 	  ;;
 
 	qnx)
-	  major=".$current"
-	  versuffix=".$current"
+	  major=.$current
+	  versuffix=.$current
+	  ;;
+
+	sco)
+	  major=.$current
+	  versuffix=.$current
 	  ;;
 
 	sunos)
-	  major=".$current"
-	  versuffix=".$current.$revision"
+	  major=.$current
+	  versuffix=.$current.$revision
 	  ;;
 
 	windows)
 	  # Use '-' rather than '.', since we only want one
-	  # extension on DOS 8.3 filesystems.
+	  # extension on DOS 8.3 file systems.
 	  func_arith $current - $age
 	  major=$func_arith_result
-	  versuffix="-$major"
+	  versuffix=-$major
 	  ;;
 
 	*)
-	  func_fatal_configuration "unknown library version type \`$version_type'"
+	  func_fatal_configuration "unknown library version type '$version_type'"
 	  ;;
 	esac
 
@@ -7499,42 +9029,45 @@ func_mode_link ()
 	    verstring=
 	    ;;
 	  *)
-	    verstring="0.0"
+	    verstring=0.0
 	    ;;
 	  esac
-	  if test "$need_version" = no; then
+	  if test no = "$need_version"; then
 	    versuffix=
 	  else
-	    versuffix=".0.0"
+	    versuffix=.0.0
 	  fi
 	fi
 
 	# Remove version info from name if versioning should be avoided
-	if test "$avoid_version" = yes && test "$need_version" = no; then
+	if test yes,no = "$avoid_version,$need_version"; then
 	  major=
 	  versuffix=
-	  verstring=""
+	  verstring=
 	fi
 
 	# Check to see if the archive will have undefined symbols.
-	if test "$allow_undefined" = yes; then
-	  if test "$allow_undefined_flag" = unsupported; then
-	    func_warning "undefined symbols not allowed in $host shared libraries"
-	    build_libtool_libs=no
-	    build_old_libs=yes
+	if test yes = "$allow_undefined"; then
+	  if test unsupported = "$allow_undefined_flag"; then
+	    if test yes = "$build_old_libs"; then
+	      func_warning "undefined symbols not allowed in $host shared libraries; building static only"
+	      build_libtool_libs=no
+	    else
+	      func_fatal_error "can't build $host shared library unless -no-undefined is specified"
+	    fi
 	  fi
 	else
 	  # Don't allow undefined symbols.
-	  allow_undefined_flag="$no_undefined_flag"
+	  allow_undefined_flag=$no_undefined_flag
 	fi
 
       fi
 
-      func_generate_dlsyms "$libname" "$libname" "yes"
+      func_generate_dlsyms "$libname" "$libname" :
       func_append libobjs " $symfileobj"
-      test "X$libobjs" = "X " && libobjs=
+      test " " = "$libobjs" && libobjs=
 
-      if test "$opt_mode" != relink; then
+      if test relink != "$opt_mode"; then
 	# Remove our outputs, but don't remove object files since they
 	# may have been created when compiling PIC objects.
 	removelist=
@@ -7543,8 +9076,8 @@ func_mode_link ()
 	  case $p in
 	    *.$objext | *.gcno)
 	       ;;
-	    $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
-	       if test "X$precious_files_regex" != "X"; then
+	    $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/$libname$release.*)
+	       if test -n "$precious_files_regex"; then
 		 if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
 		 then
 		   continue
@@ -7560,11 +9093,11 @@ func_mode_link ()
       fi
 
       # Now set the variables for building old libraries.
-      if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
+      if test yes = "$build_old_libs" && test convenience != "$build_libtool_libs"; then
 	func_append oldlibs " $output_objdir/$libname.$libext"
 
 	# Transform .lo files to .o files.
-	oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
+	oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.$libext$/d; $lo2o" | $NL2SP`
       fi
 
       # Eliminate all temporary directories.
@@ -7585,13 +9118,13 @@ func_mode_link ()
 	  *) func_append finalize_rpath " $libdir" ;;
 	  esac
 	done
-	if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
+	if test yes != "$hardcode_into_libs" || test yes = "$build_old_libs"; then
 	  dependency_libs="$temp_xrpath $dependency_libs"
 	fi
       fi
 
       # Make sure dlfiles contains only unique files that won't be dlpreopened
-      old_dlfiles="$dlfiles"
+      old_dlfiles=$dlfiles
       dlfiles=
       for lib in $old_dlfiles; do
 	case " $dlprefiles $dlfiles " in
@@ -7601,7 +9134,7 @@ func_mode_link ()
       done
 
       # Make sure dlprefiles contains only unique files
-      old_dlprefiles="$dlprefiles"
+      old_dlprefiles=$dlprefiles
       dlprefiles=
       for lib in $old_dlprefiles; do
 	case "$dlprefiles " in
@@ -7610,7 +9143,7 @@ func_mode_link ()
 	esac
       done
 
-      if test "$build_libtool_libs" = yes; then
+      if test yes = "$build_libtool_libs"; then
 	if test -n "$rpath"; then
 	  case $host in
 	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
@@ -7623,7 +9156,7 @@ func_mode_link ()
 	  *-*-netbsd*)
 	    # Don't link with libc until the a.out ld.so is fixed.
 	    ;;
-	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
+	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-midnightbsd*)
 	    # Do not include libc due to us having libc/libc_r.
 	    ;;
 	  *-*-sco3.2v5* | *-*-sco5v6*)
@@ -7634,7 +9167,7 @@ func_mode_link ()
 	    ;;
 	  *)
 	    # Add libc to deplibs on all other systems if necessary.
-	    if test "$build_libtool_need_lc" = "yes"; then
+	    if test yes = "$build_libtool_need_lc"; then
 	      func_append deplibs " -lc"
 	    fi
 	    ;;
@@ -7650,9 +9183,9 @@ func_mode_link ()
 	# I'm not sure if I'm treating the release correctly.  I think
 	# release should show up in the -l (ie -lgmp5) so we don't want to
 	# add it in twice.  Is that correct?
-	release=""
-	versuffix=""
-	major=""
+	release=
+	versuffix=
+	major=
 	newdeplibs=
 	droppeddeps=no
 	case $deplibs_check_method in
@@ -7681,20 +9214,20 @@ EOF
 	      -l*)
 		func_stripname -l '' "$i"
 		name=$func_stripname_result
-		if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
+		if test yes = "$allow_libtool_libs_with_static_runtimes"; then
 		  case " $predeps $postdeps " in
 		  *" $i "*)
 		    func_append newdeplibs " $i"
-		    i=""
+		    i=
 		    ;;
 		  esac
 		fi
-		if test -n "$i" ; then
+		if test -n "$i"; then
 		  libname=`eval "\\$ECHO \"$libname_spec\""`
 		  deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
 		  set dummy $deplib_matches; shift
 		  deplib_match=$1
-		  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
+		  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0; then
 		    func_append newdeplibs " $i"
 		  else
 		    droppeddeps=yes
@@ -7724,20 +9257,20 @@ EOF
 		$opt_dry_run || $RM conftest
 		if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
 		  ldd_output=`ldd conftest`
-		  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
+		  if test yes = "$allow_libtool_libs_with_static_runtimes"; then
 		    case " $predeps $postdeps " in
 		    *" $i "*)
 		      func_append newdeplibs " $i"
-		      i=""
+		      i=
 		      ;;
 		    esac
 		  fi
-		  if test -n "$i" ; then
+		  if test -n "$i"; then
 		    libname=`eval "\\$ECHO \"$libname_spec\""`
 		    deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
 		    set dummy $deplib_matches; shift
 		    deplib_match=$1
-		    if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
+		    if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0; then
 		      func_append newdeplibs " $i"
 		    else
 		      droppeddeps=yes
@@ -7774,24 +9307,24 @@ EOF
 	    -l*)
 	      func_stripname -l '' "$a_deplib"
 	      name=$func_stripname_result
-	      if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
+	      if test yes = "$allow_libtool_libs_with_static_runtimes"; then
 		case " $predeps $postdeps " in
 		*" $a_deplib "*)
 		  func_append newdeplibs " $a_deplib"
-		  a_deplib=""
+		  a_deplib=
 		  ;;
 		esac
 	      fi
-	      if test -n "$a_deplib" ; then
+	      if test -n "$a_deplib"; then
 		libname=`eval "\\$ECHO \"$libname_spec\""`
 		if test -n "$file_magic_glob"; then
 		  libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
 		else
 		  libnameglob=$libname
 		fi
-		test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob`
+		test yes = "$want_nocaseglob" && nocaseglob=`shopt -p nocaseglob`
 		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
-		  if test "$want_nocaseglob" = yes; then
+		  if test yes = "$want_nocaseglob"; then
 		    shopt -s nocaseglob
 		    potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
 		    $nocaseglob
@@ -7809,25 +9342,25 @@ EOF
 		      # We might still enter an endless loop, since a link
 		      # loop can be closed while we follow links,
 		      # but so what?
-		      potlib="$potent_lib"
+		      potlib=$potent_lib
 		      while test -h "$potlib" 2>/dev/null; do
-			potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
+			potliblink=`ls -ld $potlib | $SED 's/.* -> //'`
 			case $potliblink in
-			[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
-			*) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;
+			[\\/]* | [A-Za-z]:[\\/]*) potlib=$potliblink;;
+			*) potlib=`$ECHO "$potlib" | $SED 's|[^/]*$||'`"$potliblink";;
 			esac
 		      done
 		      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
 			 $SED -e 10q |
 			 $EGREP "$file_magic_regex" > /dev/null; then
 			func_append newdeplibs " $a_deplib"
-			a_deplib=""
+			a_deplib=
 			break 2
 		      fi
 		  done
 		done
 	      fi
-	      if test -n "$a_deplib" ; then
+	      if test -n "$a_deplib"; then
 		droppeddeps=yes
 		echo
 		$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
@@ -7835,7 +9368,7 @@ EOF
 		echo "*** you link to this library.  But I can only do this if you have a"
 		echo "*** shared version of the library, which you do not appear to have"
 		echo "*** because I did check the linker path looking for a file starting"
-		if test -z "$potlib" ; then
+		if test -z "$potlib"; then
 		  $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
 		else
 		  $ECHO "*** with $libname and none of the candidates passed a file format test"
@@ -7858,30 +9391,30 @@ EOF
 	    -l*)
 	      func_stripname -l '' "$a_deplib"
 	      name=$func_stripname_result
-	      if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
+	      if test yes = "$allow_libtool_libs_with_static_runtimes"; then
 		case " $predeps $postdeps " in
 		*" $a_deplib "*)
 		  func_append newdeplibs " $a_deplib"
-		  a_deplib=""
+		  a_deplib=
 		  ;;
 		esac
 	      fi
-	      if test -n "$a_deplib" ; then
+	      if test -n "$a_deplib"; then
 		libname=`eval "\\$ECHO \"$libname_spec\""`
 		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
 		  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
 		  for potent_lib in $potential_libs; do
-		    potlib="$potent_lib" # see symlink-check above in file_magic test
+		    potlib=$potent_lib # see symlink-check above in file_magic test
 		    if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
 		       $EGREP "$match_pattern_regex" > /dev/null; then
 		      func_append newdeplibs " $a_deplib"
-		      a_deplib=""
+		      a_deplib=
 		      break 2
 		    fi
 		  done
 		done
 	      fi
-	      if test -n "$a_deplib" ; then
+	      if test -n "$a_deplib"; then
 		droppeddeps=yes
 		echo
 		$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
@@ -7889,7 +9422,7 @@ EOF
 		echo "*** you link to this library.  But I can only do this if you have a"
 		echo "*** shared version of the library, which you do not appear to have"
 		echo "*** because I did check the linker path looking for a file starting"
-		if test -z "$potlib" ; then
+		if test -z "$potlib"; then
 		  $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
 		else
 		  $ECHO "*** with $libname and none of the candidates passed a file format test"
@@ -7905,18 +9438,18 @@ EOF
 	  done # Gone through all deplibs.
 	  ;;
 	none | unknown | *)
-	  newdeplibs=""
+	  newdeplibs=
 	  tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
-	  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
-	    for i in $predeps $postdeps ; do
+	  if test yes = "$allow_libtool_libs_with_static_runtimes"; then
+	    for i in $predeps $postdeps; do
 	      # can't use Xsed below, because $i might contain '/'
-	      tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`
+	      tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s|$i||"`
 	    done
 	  fi
 	  case $tmp_deplibs in
 	  *[!\	\ ]*)
 	    echo
-	    if test "X$deplibs_check_method" = "Xnone"; then
+	    if test none = "$deplibs_check_method"; then
 	      echo "*** Warning: inter-library dependencies are not supported in this platform."
 	    else
 	      echo "*** Warning: inter-library dependencies are not known to be supported."
@@ -7940,8 +9473,8 @@ EOF
 	  ;;
 	esac
 
-	if test "$droppeddeps" = yes; then
-	  if test "$module" = yes; then
+	if test yes = "$droppeddeps"; then
+	  if test yes = "$module"; then
 	    echo
 	    echo "*** Warning: libtool could not satisfy all declared inter-library"
 	    $ECHO "*** dependencies of module $libname.  Therefore, libtool will create"
@@ -7950,12 +9483,12 @@ EOF
 	    if test -z "$global_symbol_pipe"; then
 	      echo
 	      echo "*** However, this would only work if libtool was able to extract symbol"
-	      echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
+	      echo "*** lists from a program, using 'nm' or equivalent, but libtool could"
 	      echo "*** not find such a program.  So, this module is probably useless."
-	      echo "*** \`nm' from GNU binutils and a full rebuild may help."
+	      echo "*** 'nm' from GNU binutils and a full rebuild may help."
 	    fi
-	    if test "$build_old_libs" = no; then
-	      oldlibs="$output_objdir/$libname.$libext"
+	    if test no = "$build_old_libs"; then
+	      oldlibs=$output_objdir/$libname.$libext
 	      build_libtool_libs=module
 	      build_old_libs=yes
 	    else
@@ -7966,14 +9499,14 @@ EOF
 	    echo "*** automatically added whenever a program is linked with this library"
 	    echo "*** or is declared to -dlopen it."
 
-	    if test "$allow_undefined" = no; then
+	    if test no = "$allow_undefined"; then
 	      echo
 	      echo "*** Since this library must not contain undefined symbols,"
 	      echo "*** because either the platform does not support them or"
 	      echo "*** it was explicitly requested with -no-undefined,"
 	      echo "*** libtool will only create a static version of it."
-	      if test "$build_old_libs" = no; then
-		oldlibs="$output_objdir/$libname.$libext"
+	      if test no = "$build_old_libs"; then
+		oldlibs=$output_objdir/$libname.$libext
 		build_libtool_libs=module
 		build_old_libs=yes
 	      else
@@ -8019,7 +9552,7 @@ EOF
 	*) func_append new_libs " $deplib" ;;
 	esac
       done
-      deplibs="$new_libs"
+      deplibs=$new_libs
 
       # All the library-specific variables (install_libdir is set above).
       library_names=
@@ -8027,25 +9560,25 @@ EOF
       dlname=
 
       # Test again, we may have decided not to build it any more
-      if test "$build_libtool_libs" = yes; then
-	# Remove ${wl} instances when linking with ld.
+      if test yes = "$build_libtool_libs"; then
+	# Remove $wl instances when linking with ld.
 	# FIXME: should test the right _cmds variable.
 	case $archive_cmds in
 	  *\$LD\ *) wl= ;;
         esac
-	if test "$hardcode_into_libs" = yes; then
+	if test yes = "$hardcode_into_libs"; then
 	  # Hardcode the library paths
 	  hardcode_libdirs=
 	  dep_rpath=
-	  rpath="$finalize_rpath"
-	  test "$opt_mode" != relink && rpath="$compile_rpath$rpath"
+	  rpath=$finalize_rpath
+	  test relink = "$opt_mode" || rpath=$compile_rpath$rpath
 	  for libdir in $rpath; do
 	    if test -n "$hardcode_libdir_flag_spec"; then
 	      if test -n "$hardcode_libdir_separator"; then
 		func_replace_sysroot "$libdir"
 		libdir=$func_replace_sysroot_result
 		if test -z "$hardcode_libdirs"; then
-		  hardcode_libdirs="$libdir"
+		  hardcode_libdirs=$libdir
 		else
 		  # Just accumulate the unique libdirs.
 		  case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
@@ -8070,7 +9603,7 @@ EOF
 	  # Substitute the hardcoded libdirs into the rpath.
 	  if test -n "$hardcode_libdir_separator" &&
 	     test -n "$hardcode_libdirs"; then
-	    libdir="$hardcode_libdirs"
+	    libdir=$hardcode_libdirs
 	    eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
 	  fi
 	  if test -n "$runpath_var" && test -n "$perm_rpath"; then
@@ -8084,8 +9617,8 @@ EOF
 	  test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
 	fi
 
-	shlibpath="$finalize_shlibpath"
-	test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
+	shlibpath=$finalize_shlibpath
+	test relink = "$opt_mode" || shlibpath=$compile_shlibpath$shlibpath
 	if test -n "$shlibpath"; then
 	  eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
 	fi
@@ -8095,19 +9628,19 @@ EOF
 	eval library_names=\"$library_names_spec\"
 	set dummy $library_names
 	shift
-	realname="$1"
+	realname=$1
 	shift
 
 	if test -n "$soname_spec"; then
 	  eval soname=\"$soname_spec\"
 	else
-	  soname="$realname"
+	  soname=$realname
 	fi
 	if test -z "$dlname"; then
 	  dlname=$soname
 	fi
 
-	lib="$output_objdir/$realname"
+	lib=$output_objdir/$realname
 	linknames=
 	for link
 	do
@@ -8121,7 +9654,7 @@ EOF
 	delfiles=
 	if test -n "$export_symbols" && test -n "$include_expsyms"; then
 	  $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
-	  export_symbols="$output_objdir/$libname.uexp"
+	  export_symbols=$output_objdir/$libname.uexp
 	  func_append delfiles " $export_symbols"
 	fi
 
@@ -8130,31 +9663,31 @@ EOF
 	cygwin* | mingw* | cegcc*)
 	  if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
 	    # exporting using user supplied symfile
-	    if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
+	    func_dll_def_p "$export_symbols" || {
 	      # and it's NOT already a .def file. Must figure out
 	      # which of the given symbols are data symbols and tag
 	      # them as such. So, trigger use of export_symbols_cmds.
 	      # export_symbols gets reassigned inside the "prepare
 	      # the list of exported symbols" if statement, so the
 	      # include_expsyms logic still works.
-	      orig_export_symbols="$export_symbols"
+	      orig_export_symbols=$export_symbols
 	      export_symbols=
 	      always_export_symbols=yes
-	    fi
+	    }
 	  fi
 	  ;;
 	esac
 
 	# Prepare the list of exported symbols
 	if test -z "$export_symbols"; then
-	  if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
-	    func_verbose "generating symbol list for \`$libname.la'"
-	    export_symbols="$output_objdir/$libname.exp"
+	  if test yes = "$always_export_symbols" || test -n "$export_symbols_regex"; then
+	    func_verbose "generating symbol list for '$libname.la'"
+	    export_symbols=$output_objdir/$libname.exp
 	    $opt_dry_run || $RM $export_symbols
 	    cmds=$export_symbols_cmds
-	    save_ifs="$IFS"; IFS='~'
+	    save_ifs=$IFS; IFS='~'
 	    for cmd1 in $cmds; do
-	      IFS="$save_ifs"
+	      IFS=$save_ifs
 	      # Take the normal branch if the nm_file_list_spec branch
 	      # doesn't work or if tool conversion is not needed.
 	      case $nm_file_list_spec~$to_tool_file_cmd in
@@ -8168,7 +9701,7 @@ EOF
 		  try_normal_branch=no
 		  ;;
 	      esac
-	      if test "$try_normal_branch" = yes \
+	      if test yes = "$try_normal_branch" \
 		 && { test "$len" -lt "$max_cmd_len" \
 		      || test "$max_cmd_len" -le -1; }
 	      then
@@ -8179,7 +9712,7 @@ EOF
 		output_la=$func_basename_result
 		save_libobjs=$libobjs
 		save_output=$output
-		output=${output_objdir}/${output_la}.nm
+		output=$output_objdir/$output_la.nm
 		func_to_tool_file "$output"
 		libobjs=$nm_file_list_spec$func_to_tool_file_result
 		func_append delfiles " $output"
@@ -8202,8 +9735,8 @@ EOF
 		break
 	      fi
 	    done
-	    IFS="$save_ifs"
-	    if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
+	    IFS=$save_ifs
+	    if test -n "$export_symbols_regex" && test : != "$skipped_export"; then
 	      func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
 	      func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
 	    fi
@@ -8211,16 +9744,16 @@ EOF
 	fi
 
 	if test -n "$export_symbols" && test -n "$include_expsyms"; then
-	  tmp_export_symbols="$export_symbols"
-	  test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
+	  tmp_export_symbols=$export_symbols
+	  test -n "$orig_export_symbols" && tmp_export_symbols=$orig_export_symbols
 	  $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
 	fi
 
-	if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
+	if test : != "$skipped_export" && test -n "$orig_export_symbols"; then
 	  # The given exports_symbols file has to be filtered, so filter it.
-	  func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
+	  func_verbose "filter symbol list for '$libname.la' to tag DATA exports"
 	  # FIXME: $output_objdir/$libname.filter potentially contains lots of
-	  # 's' commands which not all seds can handle. GNU sed should be fine
+	  # 's' commands, which not all seds can handle. GNU sed should be fine
 	  # though. Also, the filter scales superlinearly with the number of
 	  # global variables. join(1) would be nice here, but unfortunately
 	  # isn't a blessed tool.
@@ -8239,11 +9772,11 @@ EOF
 	    ;;
 	  esac
 	done
-	deplibs="$tmp_deplibs"
+	deplibs=$tmp_deplibs
 
 	if test -n "$convenience"; then
 	  if test -n "$whole_archive_flag_spec" &&
-	    test "$compiler_needs_object" = yes &&
+	    test yes = "$compiler_needs_object" &&
 	    test -z "$libobjs"; then
 	    # extract the archives, so we have objects to list.
 	    # TODO: could optimize this to just extract one archive.
@@ -8254,7 +9787,7 @@ EOF
 	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
 	    test "X$libobjs" = "X " && libobjs=
 	  else
-	    gentop="$output_objdir/${outputname}x"
+	    gentop=$output_objdir/${outputname}x
 	    func_append generated " $gentop"
 
 	    func_extract_archives $gentop $convenience
@@ -8263,18 +9796,18 @@ EOF
 	  fi
 	fi
 
-	if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
+	if test yes = "$thread_safe" && test -n "$thread_safe_flag_spec"; then
 	  eval flag=\"$thread_safe_flag_spec\"
 	  func_append linker_flags " $flag"
 	fi
 
 	# Make a backup of the uninstalled library when relinking
-	if test "$opt_mode" = relink; then
+	if test relink = "$opt_mode"; then
 	  $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
 	fi
 
 	# Do each of the archive commands.
-	if test "$module" = yes && test -n "$module_cmds" ; then
+	if test yes = "$module" && test -n "$module_cmds"; then
 	  if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
 	    eval test_cmds=\"$module_expsym_cmds\"
 	    cmds=$module_expsym_cmds
@@ -8292,7 +9825,7 @@ EOF
 	  fi
 	fi
 
-	if test "X$skipped_export" != "X:" &&
+	if test : != "$skipped_export" &&
 	   func_len " $test_cmds" &&
 	   len=$func_len_result &&
 	   test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
@@ -8325,8 +9858,8 @@ EOF
 	  last_robj=
 	  k=1
 
-	  if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
-	    output=${output_objdir}/${output_la}.lnkscript
+	  if test -n "$save_libobjs" && test : != "$skipped_export" && test yes = "$with_gnu_ld"; then
+	    output=$output_objdir/$output_la.lnkscript
 	    func_verbose "creating GNU ld script: $output"
 	    echo 'INPUT (' > $output
 	    for obj in $save_libobjs
@@ -8338,14 +9871,14 @@ EOF
 	    func_append delfiles " $output"
 	    func_to_tool_file "$output"
 	    output=$func_to_tool_file_result
-	  elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
-	    output=${output_objdir}/${output_la}.lnk
+	  elif test -n "$save_libobjs" && test : != "$skipped_export" && test -n "$file_list_spec"; then
+	    output=$output_objdir/$output_la.lnk
 	    func_verbose "creating linker input file list: $output"
 	    : > $output
 	    set x $save_libobjs
 	    shift
 	    firstobj=
-	    if test "$compiler_needs_object" = yes; then
+	    if test yes = "$compiler_needs_object"; then
 	      firstobj="$1 "
 	      shift
 	    fi
@@ -8360,7 +9893,7 @@ EOF
 	  else
 	    if test -n "$save_libobjs"; then
 	      func_verbose "creating reloadable object files..."
-	      output=$output_objdir/$output_la-${k}.$objext
+	      output=$output_objdir/$output_la-$k.$objext
 	      eval test_cmds=\"$reload_cmds\"
 	      func_len " $test_cmds"
 	      len0=$func_len_result
@@ -8372,13 +9905,13 @@ EOF
 		func_len " $obj"
 		func_arith $len + $func_len_result
 		len=$func_arith_result
-		if test "X$objlist" = X ||
+		if test -z "$objlist" ||
 		   test "$len" -lt "$max_cmd_len"; then
 		  func_append objlist " $obj"
 		else
 		  # The command $test_cmds is almost too long, add a
 		  # command to the queue.
-		  if test "$k" -eq 1 ; then
+		  if test 1 -eq "$k"; then
 		    # The first file doesn't have a previous command to add.
 		    reload_objs=$objlist
 		    eval concat_cmds=\"$reload_cmds\"
@@ -8388,10 +9921,10 @@ EOF
 		    reload_objs="$objlist $last_robj"
 		    eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
 		  fi
-		  last_robj=$output_objdir/$output_la-${k}.$objext
+		  last_robj=$output_objdir/$output_la-$k.$objext
 		  func_arith $k + 1
 		  k=$func_arith_result
-		  output=$output_objdir/$output_la-${k}.$objext
+		  output=$output_objdir/$output_la-$k.$objext
 		  objlist=" $obj"
 		  func_len " $last_robj"
 		  func_arith $len0 + $func_len_result
@@ -8403,9 +9936,9 @@ EOF
 	      # files will link in the last one created.
 	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
 	      reload_objs="$objlist $last_robj"
-	      eval concat_cmds=\"\${concat_cmds}$reload_cmds\"
+	      eval concat_cmds=\"\$concat_cmds$reload_cmds\"
 	      if test -n "$last_robj"; then
-	        eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
+	        eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
 	      fi
 	      func_append delfiles " $output"
 
@@ -8413,9 +9946,9 @@ EOF
 	      output=
 	    fi
 
-	    if ${skipped_export-false}; then
-	      func_verbose "generating symbol list for \`$libname.la'"
-	      export_symbols="$output_objdir/$libname.exp"
+	    ${skipped_export-false} && {
+	      func_verbose "generating symbol list for '$libname.la'"
+	      export_symbols=$output_objdir/$libname.exp
 	      $opt_dry_run || $RM $export_symbols
 	      libobjs=$output
 	      # Append the command to create the export file.
@@ -8424,16 +9957,16 @@ EOF
 	      if test -n "$last_robj"; then
 		eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
 	      fi
-	    fi
+	    }
 
 	    test -n "$save_libobjs" &&
 	      func_verbose "creating a temporary reloadable object file: $output"
 
 	    # Loop through the commands generated above and execute them.
-	    save_ifs="$IFS"; IFS='~'
+	    save_ifs=$IFS; IFS='~'
 	    for cmd in $concat_cmds; do
-	      IFS="$save_ifs"
-	      $opt_silent || {
+	      IFS=$save_ifs
+	      $opt_quiet || {
 		  func_quote_for_expand "$cmd"
 		  eval "func_echo $func_quote_for_expand_result"
 	      }
@@ -8441,7 +9974,7 @@ EOF
 		lt_exit=$?
 
 		# Restore the uninstalled library and exit
-		if test "$opt_mode" = relink; then
+		if test relink = "$opt_mode"; then
 		  ( cd "$output_objdir" && \
 		    $RM "${realname}T" && \
 		    $MV "${realname}U" "$realname" )
@@ -8450,7 +9983,7 @@ EOF
 		exit $lt_exit
 	      }
 	    done
-	    IFS="$save_ifs"
+	    IFS=$save_ifs
 
 	    if test -n "$export_symbols_regex" && ${skipped_export-false}; then
 	      func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
@@ -8458,18 +9991,18 @@ EOF
 	    fi
 	  fi
 
-          if ${skipped_export-false}; then
+          ${skipped_export-false} && {
 	    if test -n "$export_symbols" && test -n "$include_expsyms"; then
-	      tmp_export_symbols="$export_symbols"
-	      test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
+	      tmp_export_symbols=$export_symbols
+	      test -n "$orig_export_symbols" && tmp_export_symbols=$orig_export_symbols
 	      $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
 	    fi
 
 	    if test -n "$orig_export_symbols"; then
 	      # The given exports_symbols file has to be filtered, so filter it.
-	      func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
+	      func_verbose "filter symbol list for '$libname.la' to tag DATA exports"
 	      # FIXME: $output_objdir/$libname.filter potentially contains lots of
-	      # 's' commands which not all seds can handle. GNU sed should be fine
+	      # 's' commands, which not all seds can handle. GNU sed should be fine
 	      # though. Also, the filter scales superlinearly with the number of
 	      # global variables. join(1) would be nice here, but unfortunately
 	      # isn't a blessed tool.
@@ -8478,7 +10011,7 @@ EOF
 	      export_symbols=$output_objdir/$libname.def
 	      $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
 	    fi
-	  fi
+	  }
 
 	  libobjs=$output
 	  # Restore the value of output.
@@ -8492,7 +10025,7 @@ EOF
 	  # value of $libobjs for piecewise linking.
 
 	  # Do each of the archive commands.
-	  if test "$module" = yes && test -n "$module_cmds" ; then
+	  if test yes = "$module" && test -n "$module_cmds"; then
 	    if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
 	      cmds=$module_expsym_cmds
 	    else
@@ -8514,7 +10047,7 @@ EOF
 
 	# Add any objects from preloaded convenience libraries
 	if test -n "$dlprefiles"; then
-	  gentop="$output_objdir/${outputname}x"
+	  gentop=$output_objdir/${outputname}x
 	  func_append generated " $gentop"
 
 	  func_extract_archives $gentop $dlprefiles
@@ -8522,11 +10055,12 @@ EOF
 	  test "X$libobjs" = "X " && libobjs=
 	fi
 
-	save_ifs="$IFS"; IFS='~'
+	save_ifs=$IFS; IFS='~'
 	for cmd in $cmds; do
-	  IFS="$save_ifs"
+	  IFS=$sp$nl
 	  eval cmd=\"$cmd\"
-	  $opt_silent || {
+	  IFS=$save_ifs
+	  $opt_quiet || {
 	    func_quote_for_expand "$cmd"
 	    eval "func_echo $func_quote_for_expand_result"
 	  }
@@ -8534,7 +10068,7 @@ EOF
 	    lt_exit=$?
 
 	    # Restore the uninstalled library and exit
-	    if test "$opt_mode" = relink; then
+	    if test relink = "$opt_mode"; then
 	      ( cd "$output_objdir" && \
 	        $RM "${realname}T" && \
 		$MV "${realname}U" "$realname" )
@@ -8543,10 +10077,10 @@ EOF
 	    exit $lt_exit
 	  }
 	done
-	IFS="$save_ifs"
+	IFS=$save_ifs
 
 	# Restore the uninstalled library and exit
-	if test "$opt_mode" = relink; then
+	if test relink = "$opt_mode"; then
 	  $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
 
 	  if test -n "$convenience"; then
@@ -8566,39 +10100,39 @@ EOF
 	done
 
 	# If -module or -export-dynamic was specified, set the dlname.
-	if test "$module" = yes || test "$export_dynamic" = yes; then
+	if test yes = "$module" || test yes = "$export_dynamic"; then
 	  # On all known operating systems, these are identical.
-	  dlname="$soname"
+	  dlname=$soname
 	fi
       fi
       ;;
 
     obj)
-      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
-	func_warning "\`-dlopen' is ignored for objects"
+      if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
+	func_warning "'-dlopen' is ignored for objects"
       fi
 
       case " $deplibs" in
       *\ -l* | *\ -L*)
-	func_warning "\`-l' and \`-L' are ignored for objects" ;;
+	func_warning "'-l' and '-L' are ignored for objects" ;;
       esac
 
       test -n "$rpath" && \
-	func_warning "\`-rpath' is ignored for objects"
+	func_warning "'-rpath' is ignored for objects"
 
       test -n "$xrpath" && \
-	func_warning "\`-R' is ignored for objects"
+	func_warning "'-R' is ignored for objects"
 
       test -n "$vinfo" && \
-	func_warning "\`-version-info' is ignored for objects"
+	func_warning "'-version-info' is ignored for objects"
 
       test -n "$release" && \
-	func_warning "\`-release' is ignored for objects"
+	func_warning "'-release' is ignored for objects"
 
       case $output in
       *.lo)
 	test -n "$objs$old_deplibs" && \
-	  func_fatal_error "cannot build library object \`$output' from non-libtool objects"
+	  func_fatal_error "cannot build library object '$output' from non-libtool objects"
 
 	libobj=$output
 	func_lo2o "$libobj"
@@ -8606,7 +10140,7 @@ EOF
 	;;
       *)
 	libobj=
-	obj="$output"
+	obj=$output
 	;;
       esac
 
@@ -8619,17 +10153,19 @@ EOF
       # the extraction.
       reload_conv_objs=
       gentop=
-      # reload_cmds runs $LD directly, so let us get rid of
-      # -Wl from whole_archive_flag_spec and hope we can get by with
-      # turning comma into space..
-      wl=
-
+      # if reload_cmds runs $LD directly, get rid of -Wl from
+      # whole_archive_flag_spec and hope we can get by with turning comma
+      # into space.
+      case $reload_cmds in
+        *\$LD[\ \$]*) wl= ;;
+      esac
       if test -n "$convenience"; then
 	if test -n "$whole_archive_flag_spec"; then
 	  eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
-	  reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
+	  test -n "$wl" || tmp_whole_archive_flags=`$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
+	  reload_conv_objs=$reload_objs\ $tmp_whole_archive_flags
 	else
-	  gentop="$output_objdir/${obj}x"
+	  gentop=$output_objdir/${obj}x
 	  func_append generated " $gentop"
 
 	  func_extract_archives $gentop $convenience
@@ -8638,12 +10174,12 @@ EOF
       fi
 
       # If we're not building shared, we need to use non_pic_objs
-      test "$build_libtool_libs" != yes && libobjs="$non_pic_objects"
+      test yes = "$build_libtool_libs" || libobjs=$non_pic_objects
 
       # Create the old-style object.
-      reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
+      reload_objs=$objs$old_deplibs' '`$ECHO "$libobjs" | $SP2NL | $SED "/\.$libext$/d; /\.lib$/d; $lo2o" | $NL2SP`' '$reload_conv_objs
 
-      output="$obj"
+      output=$obj
       func_execute_cmds "$reload_cmds" 'exit $?'
 
       # Exit if we aren't doing a library object file.
@@ -8655,7 +10191,7 @@ EOF
 	exit $EXIT_SUCCESS
       fi
 
-      if test "$build_libtool_libs" != yes; then
+      test yes = "$build_libtool_libs" || {
 	if test -n "$gentop"; then
 	  func_show_eval '${RM}r "$gentop"'
 	fi
@@ -8665,12 +10201,12 @@ EOF
 	# $show "echo timestamp > $libobj"
 	# $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
 	exit $EXIT_SUCCESS
-      fi
+      }
 
-      if test -n "$pic_flag" || test "$pic_mode" != default; then
+      if test -n "$pic_flag" || test default != "$pic_mode"; then
 	# Only do commands if we really have different PIC objects.
 	reload_objs="$libobjs $reload_conv_objs"
-	output="$libobj"
+	output=$libobj
 	func_execute_cmds "$reload_cmds" 'exit $?'
       fi
 
@@ -8687,16 +10223,14 @@ EOF
 	          output=$func_stripname_result.exe;;
       esac
       test -n "$vinfo" && \
-	func_warning "\`-version-info' is ignored for programs"
+	func_warning "'-version-info' is ignored for programs"
 
       test -n "$release" && \
-	func_warning "\`-release' is ignored for programs"
+	func_warning "'-release' is ignored for programs"
 
-      test "$preload" = yes \
-        && test "$dlopen_support" = unknown \
-	&& test "$dlopen_self" = unknown \
-	&& test "$dlopen_self_static" = unknown && \
-	  func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
+      $preload \
+	&& test unknown,unknown,unknown = "$dlopen_support,$dlopen_self,$dlopen_self_static" \
+	&& func_warning "'LT_INIT([dlopen])' not used. Assuming no dlopen support."
 
       case $host in
       *-*-rhapsody* | *-*-darwin1.[012])
@@ -8710,11 +10244,11 @@ EOF
       *-*-darwin*)
 	# Don't allow lazy linking, it breaks C++ global constructors
 	# But is supposedly fixed on 10.4 or later (yay!).
-	if test "$tagname" = CXX ; then
+	if test CXX = "$tagname"; then
 	  case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
 	    10.[0123])
-	      func_append compile_command " ${wl}-bind_at_load"
-	      func_append finalize_command " ${wl}-bind_at_load"
+	      func_append compile_command " $wl-bind_at_load"
+	      func_append finalize_command " $wl-bind_at_load"
 	    ;;
 	  esac
 	fi
@@ -8750,7 +10284,7 @@ EOF
 	*) func_append new_libs " $deplib" ;;
 	esac
       done
-      compile_deplibs="$new_libs"
+      compile_deplibs=$new_libs
 
 
       func_append compile_command " $compile_deplibs"
@@ -8774,7 +10308,7 @@ EOF
 	if test -n "$hardcode_libdir_flag_spec"; then
 	  if test -n "$hardcode_libdir_separator"; then
 	    if test -z "$hardcode_libdirs"; then
-	      hardcode_libdirs="$libdir"
+	      hardcode_libdirs=$libdir
 	    else
 	      # Just accumulate the unique libdirs.
 	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
@@ -8797,7 +10331,7 @@ EOF
 	fi
 	case $host in
 	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
-	  testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
+	  testbindir=`$ECHO "$libdir" | $SED -e 's*/lib$*/bin*'`
 	  case :$dllsearchpath: in
 	  *":$libdir:"*) ;;
 	  ::) dllsearchpath=$libdir;;
@@ -8814,10 +10348,10 @@ EOF
       # Substitute the hardcoded libdirs into the rpath.
       if test -n "$hardcode_libdir_separator" &&
 	 test -n "$hardcode_libdirs"; then
-	libdir="$hardcode_libdirs"
+	libdir=$hardcode_libdirs
 	eval rpath=\" $hardcode_libdir_flag_spec\"
       fi
-      compile_rpath="$rpath"
+      compile_rpath=$rpath
 
       rpath=
       hardcode_libdirs=
@@ -8825,7 +10359,7 @@ EOF
 	if test -n "$hardcode_libdir_flag_spec"; then
 	  if test -n "$hardcode_libdir_separator"; then
 	    if test -z "$hardcode_libdirs"; then
-	      hardcode_libdirs="$libdir"
+	      hardcode_libdirs=$libdir
 	    else
 	      # Just accumulate the unique libdirs.
 	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
@@ -8850,45 +10384,43 @@ EOF
       # Substitute the hardcoded libdirs into the rpath.
       if test -n "$hardcode_libdir_separator" &&
 	 test -n "$hardcode_libdirs"; then
-	libdir="$hardcode_libdirs"
+	libdir=$hardcode_libdirs
 	eval rpath=\" $hardcode_libdir_flag_spec\"
       fi
-      finalize_rpath="$rpath"
+      finalize_rpath=$rpath
 
-      if test -n "$libobjs" && test "$build_old_libs" = yes; then
+      if test -n "$libobjs" && test yes = "$build_old_libs"; then
 	# Transform all the library objects into standard objects.
 	compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
 	finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
       fi
 
-      func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
+      func_generate_dlsyms "$outputname" "@PROGRAM@" false
 
       # template prelinking step
       if test -n "$prelink_cmds"; then
 	func_execute_cmds "$prelink_cmds" 'exit $?'
       fi
 
-      wrappers_required=yes
+      wrappers_required=:
       case $host in
       *cegcc* | *mingw32ce*)
         # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
-        wrappers_required=no
+        wrappers_required=false
         ;;
       *cygwin* | *mingw* )
-        if test "$build_libtool_libs" != yes; then
-          wrappers_required=no
-        fi
+        test yes = "$build_libtool_libs" || wrappers_required=false
         ;;
       *)
-        if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
-          wrappers_required=no
+        if test no = "$need_relink" || test yes != "$build_libtool_libs"; then
+          wrappers_required=false
         fi
         ;;
       esac
-      if test "$wrappers_required" = no; then
+      $wrappers_required || {
 	# Replace the output file specification.
 	compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
-	link_command="$compile_command$compile_rpath"
+	link_command=$compile_command$compile_rpath
 
 	# We have no uninstalled library dependencies, so finalize right now.
 	exit_status=0
@@ -8901,12 +10433,12 @@ EOF
 	fi
 
 	# Delete the generated files.
-	if test -f "$output_objdir/${outputname}S.${objext}"; then
-	  func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
+	if test -f "$output_objdir/${outputname}S.$objext"; then
+	  func_show_eval '$RM "$output_objdir/${outputname}S.$objext"'
 	fi
 
 	exit $exit_status
-      fi
+      }
 
       if test -n "$compile_shlibpath$finalize_shlibpath"; then
 	compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
@@ -8936,9 +10468,9 @@ EOF
 	fi
       fi
 
-      if test "$no_install" = yes; then
+      if test yes = "$no_install"; then
 	# We don't need to create a wrapper script.
-	link_command="$compile_var$compile_command$compile_rpath"
+	link_command=$compile_var$compile_command$compile_rpath
 	# Replace the output file specification.
 	link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
 	# Delete the old output file.
@@ -8955,27 +10487,28 @@ EOF
 	exit $EXIT_SUCCESS
       fi
 
-      if test "$hardcode_action" = relink; then
-	# Fast installation is not supported
-	link_command="$compile_var$compile_command$compile_rpath"
-	relink_command="$finalize_var$finalize_command$finalize_rpath"
+      case $hardcode_action,$fast_install in
+        relink,*)
+	  # Fast installation is not supported
+	  link_command=$compile_var$compile_command$compile_rpath
+	  relink_command=$finalize_var$finalize_command$finalize_rpath
 
-	func_warning "this platform does not like uninstalled shared libraries"
-	func_warning "\`$output' will be relinked during installation"
-      else
-	if test "$fast_install" != no; then
-	  link_command="$finalize_var$compile_command$finalize_rpath"
-	  if test "$fast_install" = yes; then
-	    relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
-	  else
-	    # fast_install is set to needless
-	    relink_command=
-	  fi
-	else
-	  link_command="$compile_var$compile_command$compile_rpath"
-	  relink_command="$finalize_var$finalize_command$finalize_rpath"
-	fi
-      fi
+	  func_warning "this platform does not like uninstalled shared libraries"
+	  func_warning "'$output' will be relinked during installation"
+	  ;;
+        *,yes)
+	  link_command=$finalize_var$compile_command$finalize_rpath
+	  relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
+          ;;
+	*,no)
+	  link_command=$compile_var$compile_command$compile_rpath
+	  relink_command=$finalize_var$finalize_command$finalize_rpath
+          ;;
+	*,needless)
+	  link_command=$finalize_var$compile_command$finalize_rpath
+	  relink_command=
+          ;;
+      esac
 
       # Replace the output file specification.
       link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
@@ -9032,8 +10565,8 @@ EOF
 	    func_dirname_and_basename "$output" "" "."
 	    output_name=$func_basename_result
 	    output_path=$func_dirname_result
-	    cwrappersource="$output_path/$objdir/lt-$output_name.c"
-	    cwrapper="$output_path/$output_name.exe"
+	    cwrappersource=$output_path/$objdir/lt-$output_name.c
+	    cwrapper=$output_path/$output_name.exe
 	    $RM $cwrappersource $cwrapper
 	    trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
 
@@ -9054,7 +10587,7 @@ EOF
 	    trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
 	    $opt_dry_run || {
 	      # note: this script will not be executed, so do not chmod.
-	      if test "x$build" = "x$host" ; then
+	      if test "x$build" = "x$host"; then
 		$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
 	      else
 		func_emit_wrapper no > $func_ltwrapper_scriptname_result
@@ -9077,25 +10610,27 @@ EOF
     # See if we need to build an old-fashioned archive.
     for oldlib in $oldlibs; do
 
-      if test "$build_libtool_libs" = convenience; then
-	oldobjs="$libobjs_save $symfileobj"
-	addlibs="$convenience"
-	build_libtool_libs=no
-      else
-	if test "$build_libtool_libs" = module; then
-	  oldobjs="$libobjs_save"
+      case $build_libtool_libs in
+        convenience)
+	  oldobjs="$libobjs_save $symfileobj"
+	  addlibs=$convenience
 	  build_libtool_libs=no
-	else
+	  ;;
+	module)
+	  oldobjs=$libobjs_save
+	  addlibs=$old_convenience
+	  build_libtool_libs=no
+          ;;
+	*)
 	  oldobjs="$old_deplibs $non_pic_objects"
-	  if test "$preload" = yes && test -f "$symfileobj"; then
-	    func_append oldobjs " $symfileobj"
-	  fi
-	fi
-	addlibs="$old_convenience"
-      fi
+	  $preload && test -f "$symfileobj" \
+	    && func_append oldobjs " $symfileobj"
+	  addlibs=$old_convenience
+	  ;;
+      esac
 
       if test -n "$addlibs"; then
-	gentop="$output_objdir/${outputname}x"
+	gentop=$output_objdir/${outputname}x
 	func_append generated " $gentop"
 
 	func_extract_archives $gentop $addlibs
@@ -9103,13 +10638,13 @@ EOF
       fi
 
       # Do each command in the archive commands.
-      if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
+      if test -n "$old_archive_from_new_cmds" && test yes = "$build_libtool_libs"; then
 	cmds=$old_archive_from_new_cmds
       else
 
 	# Add any objects from preloaded convenience libraries
 	if test -n "$dlprefiles"; then
-	  gentop="$output_objdir/${outputname}x"
+	  gentop=$output_objdir/${outputname}x
 	  func_append generated " $gentop"
 
 	  func_extract_archives $gentop $dlprefiles
@@ -9130,7 +10665,7 @@ EOF
 	  :
 	else
 	  echo "copying selected object files to avoid basename conflicts..."
-	  gentop="$output_objdir/${outputname}x"
+	  gentop=$output_objdir/${outputname}x
 	  func_append generated " $gentop"
 	  func_mkdir_p "$gentop"
 	  save_oldobjs=$oldobjs
@@ -9139,7 +10674,7 @@ EOF
 	  for obj in $save_oldobjs
 	  do
 	    func_basename "$obj"
-	    objbase="$func_basename_result"
+	    objbase=$func_basename_result
 	    case " $oldobjs " in
 	    " ") oldobjs=$obj ;;
 	    *[\ /]"$objbase "*)
@@ -9208,18 +10743,18 @@ EOF
 	    else
 	      # the above command should be used before it gets too long
 	      oldobjs=$objlist
-	      if test "$obj" = "$last_oldobj" ; then
+	      if test "$obj" = "$last_oldobj"; then
 		RANLIB=$save_RANLIB
 	      fi
 	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
-	      eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
+	      eval concat_cmds=\"\$concat_cmds$old_archive_cmds\"
 	      objlist=
 	      len=$len0
 	    fi
 	  done
 	  RANLIB=$save_RANLIB
 	  oldobjs=$objlist
-	  if test "X$oldobjs" = "X" ; then
+	  if test -z "$oldobjs"; then
 	    eval cmds=\"\$concat_cmds\"
 	  else
 	    eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
@@ -9236,7 +10771,7 @@ EOF
     case $output in
     *.la)
       old_library=
-      test "$build_old_libs" = yes && old_library="$libname.$libext"
+      test yes = "$build_old_libs" && old_library=$libname.$libext
       func_verbose "creating $output"
 
       # Preserve any variables that may affect compiler behavior
@@ -9251,31 +10786,31 @@ EOF
 	fi
       done
       # Quote the link command for shipping.
-      relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
+      relink_command="(cd `pwd`; $SHELL \"$progpath\" $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
       relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
-      if test "$hardcode_automatic" = yes ; then
+      if test yes = "$hardcode_automatic"; then
 	relink_command=
       fi
 
       # Only create the output if not a dry run.
       $opt_dry_run || {
 	for installed in no yes; do
-	  if test "$installed" = yes; then
+	  if test yes = "$installed"; then
 	    if test -z "$install_libdir"; then
 	      break
 	    fi
-	    output="$output_objdir/$outputname"i
+	    output=$output_objdir/${outputname}i
 	    # Replace all uninstalled libtool libraries with the installed ones
 	    newdependency_libs=
 	    for deplib in $dependency_libs; do
 	      case $deplib in
 	      *.la)
 		func_basename "$deplib"
-		name="$func_basename_result"
+		name=$func_basename_result
 		func_resolve_sysroot "$deplib"
-		eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result`
+		eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result`
 		test -z "$libdir" && \
-		  func_fatal_error "\`$deplib' is not a valid libtool archive"
+		  func_fatal_error "'$deplib' is not a valid libtool archive"
 		func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
 		;;
 	      -L*)
@@ -9291,23 +10826,23 @@ EOF
 	      *) func_append newdependency_libs " $deplib" ;;
 	      esac
 	    done
-	    dependency_libs="$newdependency_libs"
+	    dependency_libs=$newdependency_libs
 	    newdlfiles=
 
 	    for lib in $dlfiles; do
 	      case $lib in
 	      *.la)
 	        func_basename "$lib"
-		name="$func_basename_result"
-		eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
+		name=$func_basename_result
+		eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
 		test -z "$libdir" && \
-		  func_fatal_error "\`$lib' is not a valid libtool archive"
+		  func_fatal_error "'$lib' is not a valid libtool archive"
 		func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
 		;;
 	      *) func_append newdlfiles " $lib" ;;
 	      esac
 	    done
-	    dlfiles="$newdlfiles"
+	    dlfiles=$newdlfiles
 	    newdlprefiles=
 	    for lib in $dlprefiles; do
 	      case $lib in
@@ -9317,34 +10852,34 @@ EOF
 		# didn't already link the preopened objects directly into
 		# the library:
 		func_basename "$lib"
-		name="$func_basename_result"
-		eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
+		name=$func_basename_result
+		eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
 		test -z "$libdir" && \
-		  func_fatal_error "\`$lib' is not a valid libtool archive"
+		  func_fatal_error "'$lib' is not a valid libtool archive"
 		func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
 		;;
 	      esac
 	    done
-	    dlprefiles="$newdlprefiles"
+	    dlprefiles=$newdlprefiles
 	  else
 	    newdlfiles=
 	    for lib in $dlfiles; do
 	      case $lib in
-		[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
+		[\\/]* | [A-Za-z]:[\\/]*) abs=$lib ;;
 		*) abs=`pwd`"/$lib" ;;
 	      esac
 	      func_append newdlfiles " $abs"
 	    done
-	    dlfiles="$newdlfiles"
+	    dlfiles=$newdlfiles
 	    newdlprefiles=
 	    for lib in $dlprefiles; do
 	      case $lib in
-		[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
+		[\\/]* | [A-Za-z]:[\\/]*) abs=$lib ;;
 		*) abs=`pwd`"/$lib" ;;
 	      esac
 	      func_append newdlprefiles " $abs"
 	    done
-	    dlprefiles="$newdlprefiles"
+	    dlprefiles=$newdlprefiles
 	  fi
 	  $RM $output
 	  # place dlname in correct position for cygwin
@@ -9360,10 +10895,9 @@ EOF
 	  case $host,$output,$installed,$module,$dlname in
 	    *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
 	      # If a -bindir argument was supplied, place the dll there.
-	      if test "x$bindir" != x ;
-	      then
+	      if test -n "$bindir"; then
 		func_relative_path "$install_libdir" "$bindir"
-		tdlname=$func_relative_path_result$dlname
+		tdlname=$func_relative_path_result/$dlname
 	      else
 		# Otherwise fall back on heuristic.
 		tdlname=../bin/$dlname
@@ -9372,7 +10906,7 @@ EOF
 	  esac
 	  $ECHO > $output "\
 # $outputname - a libtool library file
-# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
+# Generated by $PROGRAM (GNU $PACKAGE) $VERSION
 #
 # Please DO NOT delete this file!
 # It is necessary for linking the library.
@@ -9386,7 +10920,7 @@ library_names='$library_names'
 # The name of the static archive.
 old_library='$old_library'
 
-# Linker flags that can not go in dependency_libs.
+# Linker flags that cannot go in dependency_libs.
 inherited_linker_flags='$new_inherited_linker_flags'
 
 # Libraries that this one depends upon.
@@ -9412,7 +10946,7 @@ dlpreopen='$dlprefiles'
 
 # Directory that this library needs to be installed in:
 libdir='$install_libdir'"
-	  if test "$installed" = no && test "$need_relink" = yes; then
+	  if test no,yes = "$installed,$need_relink"; then
 	    $ECHO >> $output "\
 relink_command=\"$relink_command\""
 	  fi
@@ -9427,27 +10961,29 @@ relink_command=\"$relink_command\""
     exit $EXIT_SUCCESS
 }
 
-{ test "$opt_mode" = link || test "$opt_mode" = relink; } &&
-    func_mode_link ${1+"$@"}
+if test link = "$opt_mode" || test relink = "$opt_mode"; then
+  func_mode_link ${1+"$@"}
+fi
 
 
 # func_mode_uninstall arg...
 func_mode_uninstall ()
 {
-    $opt_debug
-    RM="$nonopt"
+    $debug_cmd
+
+    RM=$nonopt
     files=
-    rmforce=
+    rmforce=false
     exit_status=0
 
     # This variable tells wrapper scripts just to set variables rather
     # than running their programs.
-    libtool_install_magic="$magic"
+    libtool_install_magic=$magic
 
     for arg
     do
       case $arg in
-      -f) func_append RM " $arg"; rmforce=yes ;;
+      -f) func_append RM " $arg"; rmforce=: ;;
       -*) func_append RM " $arg" ;;
       *) func_append files " $arg" ;;
       esac
@@ -9460,18 +10996,18 @@ func_mode_uninstall ()
 
     for file in $files; do
       func_dirname "$file" "" "."
-      dir="$func_dirname_result"
-      if test "X$dir" = X.; then
-	odir="$objdir"
+      dir=$func_dirname_result
+      if test . = "$dir"; then
+	odir=$objdir
       else
-	odir="$dir/$objdir"
+	odir=$dir/$objdir
       fi
       func_basename "$file"
-      name="$func_basename_result"
-      test "$opt_mode" = uninstall && odir="$dir"
+      name=$func_basename_result
+      test uninstall = "$opt_mode" && odir=$dir
 
       # Remember odir for removal later, being careful to avoid duplicates
-      if test "$opt_mode" = clean; then
+      if test clean = "$opt_mode"; then
 	case " $rmdirs " in
 	  *" $odir "*) ;;
 	  *) func_append rmdirs " $odir" ;;
@@ -9486,11 +11022,11 @@ func_mode_uninstall ()
       elif test -d "$file"; then
 	exit_status=1
 	continue
-      elif test "$rmforce" = yes; then
+      elif $rmforce; then
 	continue
       fi
 
-      rmfiles="$file"
+      rmfiles=$file
 
       case $name in
       *.la)
@@ -9504,7 +11040,7 @@ func_mode_uninstall ()
 	  done
 	  test -n "$old_library" && func_append rmfiles " $odir/$old_library"
 
-	  case "$opt_mode" in
+	  case $opt_mode in
 	  clean)
 	    case " $library_names " in
 	    *" $dlname "*) ;;
@@ -9515,12 +11051,12 @@ func_mode_uninstall ()
 	  uninstall)
 	    if test -n "$library_names"; then
 	      # Do each command in the postuninstall commands.
-	      func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
+	      func_execute_cmds "$postuninstall_cmds" '$rmforce || exit_status=1'
 	    fi
 
 	    if test -n "$old_library"; then
 	      # Do each command in the old_postuninstall commands.
-	      func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
+	      func_execute_cmds "$old_postuninstall_cmds" '$rmforce || exit_status=1'
 	    fi
 	    # FIXME: should reinstall the best remaining shared library.
 	    ;;
@@ -9536,21 +11072,19 @@ func_mode_uninstall ()
 	  func_source $dir/$name
 
 	  # Add PIC object to the list of files to remove.
-	  if test -n "$pic_object" &&
-	     test "$pic_object" != none; then
+	  if test -n "$pic_object" && test none != "$pic_object"; then
 	    func_append rmfiles " $dir/$pic_object"
 	  fi
 
 	  # Add non-PIC object to the list of files to remove.
-	  if test -n "$non_pic_object" &&
-	     test "$non_pic_object" != none; then
+	  if test -n "$non_pic_object" && test none != "$non_pic_object"; then
 	    func_append rmfiles " $dir/$non_pic_object"
 	  fi
 	fi
 	;;
 
       *)
-	if test "$opt_mode" = clean ; then
+	if test clean = "$opt_mode"; then
 	  noexename=$name
 	  case $file in
 	  *.exe)
@@ -9577,12 +11111,12 @@ func_mode_uninstall ()
 
 	    # note $name still contains .exe if it was in $file originally
 	    # as does the version of $file that was added into $rmfiles
-	    func_append rmfiles " $odir/$name $odir/${name}S.${objext}"
-	    if test "$fast_install" = yes && test -n "$relink_command"; then
+	    func_append rmfiles " $odir/$name $odir/${name}S.$objext"
+	    if test yes = "$fast_install" && test -n "$relink_command"; then
 	      func_append rmfiles " $odir/lt-$name"
 	    fi
-	    if test "X$noexename" != "X$name" ; then
-	      func_append rmfiles " $odir/lt-${noexename}.c"
+	    if test "X$noexename" != "X$name"; then
+	      func_append rmfiles " $odir/lt-$noexename.c"
 	    fi
 	  fi
 	fi
@@ -9591,7 +11125,7 @@ func_mode_uninstall ()
       func_show_eval "$RM $rmfiles" 'exit_status=1'
     done
 
-    # Try to remove the ${objdir}s in the directories where we deleted files
+    # Try to remove the $objdir's in the directories where we deleted files
     for dir in $rmdirs; do
       if test -d "$dir"; then
 	func_show_eval "rmdir $dir >/dev/null 2>&1"
@@ -9601,16 +11135,17 @@ func_mode_uninstall ()
     exit $exit_status
 }
 
-{ test "$opt_mode" = uninstall || test "$opt_mode" = clean; } &&
-    func_mode_uninstall ${1+"$@"}
+if test uninstall = "$opt_mode" || test clean = "$opt_mode"; then
+  func_mode_uninstall ${1+"$@"}
+fi
 
 test -z "$opt_mode" && {
-  help="$generic_help"
+  help=$generic_help
   func_fatal_help "you must specify a MODE"
 }
 
 test -z "$exec_cmd" && \
-  func_fatal_help "invalid operation mode \`$opt_mode'"
+  func_fatal_help "invalid operation mode '$opt_mode'"
 
 if test -n "$exec_cmd"; then
   eval exec "$exec_cmd"
@@ -9621,7 +11156,7 @@ exit $exit_status
 
 
 # The TAGs below are defined such that we never get into a situation
-# in which we disable both kinds of libraries.  Given conflicting
+# where we disable both kinds of libraries.  Given conflicting
 # choices, we go for a static library, that is the most portable,
 # since we can't tell whether shared libraries were disabled because
 # the user asked for that or because the platform doesn't support
@@ -9644,5 +11179,3 @@ build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
 # mode:shell-script
 # sh-indentation:2
 # End:
-# vi:sw=2
-
diff --git a/Engine/lib/sdl/build-scripts/mkinstalldirs b/Engine/lib/sdl/build-scripts/mkinstalldirs
index 55d537f87..c364f3d5e 100755
--- a/Engine/lib/sdl/build-scripts/mkinstalldirs
+++ b/Engine/lib/sdl/build-scripts/mkinstalldirs
@@ -1,7 +1,7 @@
 #! /bin/sh
 # mkinstalldirs --- make directory hierarchy
 
-scriptversion=2009-04-28.21; # UTC
+scriptversion=2020-07-26.22; # UTC
 
 # Original author: Noah Friedman <friedman@prep.ai.mit.edu>
 # Created: 1993-05-16
@@ -92,6 +92,8 @@ case $dirmode in
   *)
     if mkdir -m "$dirmode" -p --version . >/dev/null 2>&1 &&
        test ! -d ./--version; then
+      echo "umask 22"
+      umask 22
       echo "mkdir -m $dirmode -p -- $*"
       exec mkdir -m "$dirmode" -p -- "$@"
     else
@@ -104,6 +106,9 @@ case $dirmode in
     ;;
 esac
 
+echo "umask 22"
+umask 22
+
 for file
 do
   case $file in
@@ -132,21 +137,16 @@ do
 
       if test ! -d "$pathcomp"; then
 	errstatus=$lasterr
-      else
-	if test ! -z "$dirmode"; then
-	  echo "chmod $dirmode $pathcomp"
-	  lasterr=
-	  chmod "$dirmode" "$pathcomp" || lasterr=$?
-
-	  if test ! -z "$lasterr"; then
-	    errstatus=$lasterr
-	  fi
-	fi
       fi
     fi
 
     pathcomp=$pathcomp/
   done
+
+  if test ! -z "$dirmode"; then
+    echo "chmod $dirmode $file"
+    chmod "$dirmode" "$file" || errstatus=$?
+  fi
 done
 
 exit $errstatus
@@ -154,9 +154,9 @@ exit $errstatus
 # Local Variables:
 # mode: shell-script
 # sh-indentation: 2
-# eval: (add-hook 'write-file-hooks 'time-stamp)
+# eval: (add-hook 'before-save-hook 'time-stamp)
 # time-stamp-start: "scriptversion="
 # time-stamp-format: "%:y-%02m-%02d.%02H"
-# time-stamp-time-zone: "UTC"
+# time-stamp-time-zone: "UTC0"
 # time-stamp-end: "; # UTC"
 # End:
diff --git a/Engine/lib/sdl/build-scripts/os2-buildbot.sh b/Engine/lib/sdl/build-scripts/os2-buildbot.sh
index e0a53c8d0..abe0350d0 100644
--- a/Engine/lib/sdl/build-scripts/os2-buildbot.sh
+++ b/Engine/lib/sdl/build-scripts/os2-buildbot.sh
@@ -12,8 +12,7 @@ if [ -z "$WATCOM" ]; then
     echo "This is often something like '/usr/local/share/watcom'" 1>&2
     exit 1
 fi
-
-export PATH="$WATCOM/binl:$PATH"
+export PATH="$WATCOM/binl64:$PATH"
 
 ZIPFILE="$1"
 if [ -z $1 ]; then
@@ -31,8 +30,8 @@ rm -f $ZIPFILE
 wmake -f Makefile.os2
 rm -rf $ZIPDIR
 mkdir -p $ZIPDIR
-chmod a+r SDL2.lib SDL2.dll
-mv SDL2.lib SDL2.dll $ZIPDIR/
+chmod 644 SDL2.dll SDL2.lib SDL2test.lib
+mv SDL2.dll SDL2.lib SDL2test.lib $ZIPDIR/
 cp -R include $ZIPDIR/
 zip -9r "buildbot/$ZIPFILE" $ZIPDIR
 
diff --git a/Engine/lib/sdl/build-scripts/showrev.sh b/Engine/lib/sdl/build-scripts/showrev.sh
index d3b131a14..71be3fea9 100755
--- a/Engine/lib/sdl/build-scripts/showrev.sh
+++ b/Engine/lib/sdl/build-scripts/showrev.sh
@@ -5,9 +5,9 @@
 SDL_ROOT=$(dirname $0)/..
 cd $SDL_ROOT
 
-if [ -x "$(command -v hg)" ]; then
-    rev="$(hg parents --template 'hg-{rev}:{node|short}' 2>/dev/null)"
-    if [ $? = 0 ]; then
+if [ -x "$(command -v git)" ]; then
+    rev=$(echo "$(git remote get-url origin 2>/dev/null)@$(git rev-list HEAD~.. 2>/dev/null)")
+    if [ "$rev" != "@" ]; then
         echo $rev
         exit 0
     fi
@@ -21,5 +21,5 @@ if [ -x "$(command -v p4)" ]; then
     fi
 fi
 
-echo "hg-0:baadf00d"
+echo ""
 exit 1
diff --git a/Engine/lib/sdl/build-scripts/update-copyright.sh b/Engine/lib/sdl/build-scripts/update-copyright.sh
index 5955b09fa..ea1f79875 100755
--- a/Engine/lib/sdl/build-scripts/update-copyright.sh
+++ b/Engine/lib/sdl/build-scripts/update-copyright.sh
@@ -1,7 +1,7 @@
 #!/bin/sh
 
 find . -type f -exec grep -Il "Copyright" {} \;     \
-| grep -v \.hg                             \
+| grep -v \.git                             \
 | while read file;                            \
 do \
   LC_ALL=C sed -b -i "s/\(.*Copyright.*\)[0-9]\{4\}\( *Sam Lantinga\)/\1`date +%Y`\2/" "$file"; \
diff --git a/Engine/lib/sdl/build-scripts/updaterev.sh b/Engine/lib/sdl/build-scripts/updaterev.sh
index 485d04580..eb20e8069 100755
--- a/Engine/lib/sdl/build-scripts/updaterev.sh
+++ b/Engine/lib/sdl/build-scripts/updaterev.sh
@@ -8,10 +8,9 @@ srcdir=..
 header=$outdir/include/SDL_revision.h
 
 rev=`sh showrev.sh 2>/dev/null`
-if [ "$rev" != "" -a "$rev" != "hg-0:baadf00d" ]; then
-    revnum=`echo $rev | sed 's,hg-\([0-9]*\).*,\1,'`
+if [ "$rev" != "" ]; then
     echo "#define SDL_REVISION \"$rev\"" >"$header.new"
-    echo "#define SDL_REVISION_NUMBER $revnum" >>"$header.new"
+    echo "#define SDL_REVISION_NUMBER 0" >>"$header.new"
     if diff $header $header.new >/dev/null 2>&1; then
         rm "$header.new"
     else
diff --git a/Engine/lib/sdl/build-scripts/wikiheaders.pl b/Engine/lib/sdl/build-scripts/wikiheaders.pl
new file mode 100644
index 000000000..2be760cac
--- /dev/null
+++ b/Engine/lib/sdl/build-scripts/wikiheaders.pl
@@ -0,0 +1,1258 @@
+#!/usr/bin/perl -w
+
+use warnings;
+use strict;
+use Text::Wrap;
+
+my $srcpath = undef;
+my $wikipath = undef;
+my $warn_about_missing = 0;
+my $copy_direction = 0;
+
+foreach (@ARGV) {
+    $warn_about_missing = 1, next if $_ eq '--warn-about-missing';
+    $copy_direction = 1, next if $_ eq '--copy-to-headers';
+    $copy_direction = 1, next if $_ eq '--copy-to-header';
+    $copy_direction = -1, next if $_ eq '--copy-to-wiki';
+    $copy_direction = -2, next if $_ eq '--copy-to-manpages';
+    $srcpath = $_, next if not defined $srcpath;
+    $wikipath = $_, next if not defined $wikipath;
+}
+
+my $wordwrap_mode = 'mediawiki';
+sub wordwrap_atom {   # don't call this directly.
+    my $str = shift;
+    return fill('', '', $str);
+}
+
+sub wordwrap_with_bullet_indent {  # don't call this directly.
+    my $bullet = shift;
+    my $str = shift;
+    my $retval = '';
+
+    #print("WORDWRAP BULLET ('$bullet'):\n\n$str\n\n");
+
+    # You _can't_ (at least with Pandoc) have a bullet item with a newline in
+    #  MediaWiki, so _remove_ wrapping!
+    if ($wordwrap_mode eq 'mediawiki') {
+        $retval = "$bullet$str";
+        $retval =~ s/\n/ /gms;
+        $retval =~ s/\s+$//gms;
+        #print("WORDWRAP BULLET DONE:\n\n$retval\n\n");
+        return "$retval\n";
+    }
+
+    my $bulletlen = length($bullet);
+
+    # wrap it and then indent each line to be under the bullet.
+    $Text::Wrap::columns -= $bulletlen;
+    my @wrappedlines = split /\n/, wordwrap_atom($str);
+    $Text::Wrap::columns += $bulletlen;
+
+    my $prefix = $bullet;
+    my $usual_prefix = ' ' x $bulletlen;
+
+    foreach (@wrappedlines) {
+        $retval .= "$prefix$_\n";
+        $prefix = $usual_prefix;
+    }
+
+    return $retval;
+}
+
+sub wordwrap_one_paragraph {  # don't call this directly.
+    my $retval = '';
+    my $p = shift;
+    #print "\n\n\nPARAGRAPH: [$p]\n\n\n";
+    if ($p =~ s/\A([\*\-] )//) {  # bullet list, starts with "* " or "- ".
+        my $bullet = $1;
+        my $item = '';
+        my @items = split /\n/, $p;
+        foreach (@items) {
+            if (s/\A([\*\-] )//) {
+                $retval .= wordwrap_with_bullet_indent($bullet, $item);
+                $item = '';
+            }
+            s/\A\s*//;
+            $item .= "$_\n";   # accumulate lines until we hit the end or another bullet.
+        }
+        if ($item ne '') {
+            $retval .= wordwrap_with_bullet_indent($bullet, $item);
+        }
+    } else {
+        $retval = wordwrap_atom($p) . "\n";
+    }
+
+    return $retval;
+}
+
+sub wordwrap_paragraphs {  # don't call this directly.
+    my $str = shift;
+    my $retval = '';
+    my @paragraphs = split /\n\n/, $str;
+    foreach (@paragraphs) {
+        next if $_ eq '';
+        $retval .= wordwrap_one_paragraph($_);
+        $retval .= "\n";
+    }
+    return $retval;
+}
+
+my $wordwrap_default_columns = 76;
+sub wordwrap {
+    my $str = shift;
+    my $columns = shift;
+
+    $columns = $wordwrap_default_columns if not defined $columns;
+    $columns += $wordwrap_default_columns if $columns < 0;
+    $Text::Wrap::columns = $columns;
+
+    my $retval = '';
+
+    #print("\n\nWORDWRAP:\n\n$str\n\n\n");
+
+    $str =~ s/\A\n+//ms;
+
+    while ($str =~ s/(.*?)(\`\`\`.*?\`\`\`|\<syntaxhighlight.*?\<\/syntaxhighlight\>)//ms) {
+        #print("\n\nWORDWRAP BLOCK:\n\n$1\n\n ===\n\n$2\n\n\n");
+        $retval .= wordwrap_paragraphs($1); # wrap it.
+        $retval .= "$2\n\n";  # don't wrap it.
+    }
+
+    $retval .= wordwrap_paragraphs($str);  # wrap what's left.
+    $retval =~ s/\n+\Z//ms;
+
+    #print("\n\nWORDWRAP DONE:\n\n$retval\n\n\n");
+    return $retval;
+}
+
+# This assumes you're moving from Markdown (in the Doxygen data) to Wiki, which
+#  is why the 'md' section is so sparse.
+sub wikify_chunk {
+    my $wikitype = shift;
+    my $str = shift;
+    my $codelang = shift;
+    my $code = shift;
+
+    #print("\n\nWIKIFY CHUNK:\n\n$str\n\n\n");
+
+    if ($wikitype eq 'mediawiki') {
+        # convert `code` things first, so they aren't mistaken for other markdown items.
+        my $codedstr = '';
+        while ($str =~ s/\A(.*?)\`(.*?)\`//ms) {
+            my $codeblock = $2;
+            $codedstr .= wikify_chunk($wikitype, $1, undef, undef);
+            # Convert obvious SDL things to wikilinks, even inside `code` blocks.
+            $codeblock =~ s/\b(SDL_[a-zA-Z0-9_]+)/[[$1]]/gms;
+            $codedstr .= "<code>$codeblock</code>";
+        }
+
+        # Convert obvious SDL things to wikilinks.
+        $str =~ s/\b(SDL_[a-zA-Z0-9_]+)/[[$1]]/gms;
+
+        # Make some Markdown things into MediaWiki...
+
+        # bold+italic
+        $str =~ s/\*\*\*(.*?)\*\*\*/'''''$1'''''/gms;
+
+        # bold
+        $str =~ s/\*\*(.*?)\*\*/'''$1'''/gms;
+
+        # italic
+        $str =~ s/\*(.*?)\*/''$1''/gms;
+
+        # bullets
+        $str =~ s/^\- /* /gm;
+
+        $str = $codedstr . $str;
+
+        if (defined $code) {
+            $str .= "<syntaxhighlight lang='$codelang'>$code<\/syntaxhighlight>";
+        }
+    } elsif ($wikitype eq 'md') {
+        # Convert obvious SDL things to wikilinks.
+        $str =~ s/\b(SDL_[a-zA-Z0-9_]+)/[$1]($1)/gms;
+        if (defined $code) {
+            $str .= "```$codelang$code```";
+        }
+    }
+
+    #print("\n\nWIKIFY CHUNK DONE:\n\n$str\n\n\n");
+
+    return $str;
+}
+
+sub wikify {
+    my $wikitype = shift;
+    my $str = shift;
+    my $retval = '';
+
+    #print("WIKIFY WHOLE:\n\n$str\n\n\n");
+
+    while ($str =~ s/\A(.*?)\`\`\`(c\+\+|c)(.*?)\`\`\`//ms) {
+        $retval .= wikify_chunk($wikitype, $1, $2, $3);
+    }
+    $retval .= wikify_chunk($wikitype, $str, undef, undef);
+
+    #print("WIKIFY WHOLE DONE:\n\n$retval\n\n\n");
+
+    return $retval;
+}
+
+
+my $dewikify_mode = 'md';
+my $dewikify_manpage_code_indent = 1;
+
+sub dewikify_chunk {
+    my $wikitype = shift;
+    my $str = shift;
+    my $codelang = shift;
+    my $code = shift;
+
+    #print("\n\nDEWIKIFY CHUNK:\n\n$str\n\n\n");
+
+    if ($dewikify_mode eq 'md') {
+        if ($wikitype eq 'mediawiki') {
+            # Doxygen supports Markdown (and it just simply looks better than MediaWiki
+            # when looking at the raw headers), so do some conversions here as necessary.
+
+            $str =~ s/\[\[(SDL_[a-zA-Z0-9_]+)\]\]/$1/gms;  # Dump obvious wikilinks.
+
+            # <code></code> is also popular.  :/
+            $str =~ s/\<code>(.*?)<\/code>/`$1`/gms;
+
+            # bold+italic
+            $str =~ s/'''''(.*?)'''''/***$1***/gms;
+
+            # bold
+            $str =~ s/'''(.*?)'''/**$1**/gms;
+
+            # italic
+            $str =~ s/''(.*?)''/*$1*/gms;
+
+            # bullets
+            $str =~ s/^\* /- /gm;
+        }
+
+        if (defined $code) {
+            $str .= "```$codelang$code```";
+        }
+    } elsif ($dewikify_mode eq 'manpage') {
+        $str =~ s/\./\\[char46]/gms;  # make sure these can't become control codes.
+        if ($wikitype eq 'mediawiki') {
+            $str =~ s/\s*\[\[(SDL_[a-zA-Z0-9_]+)\]\]\s*/\n.BR $1\n/gms;  # Dump obvious wikilinks.
+
+            # <code></code> is also popular.  :/
+            $str =~ s/\s*\<code>(.*?)<\/code>\s*/\n.BR $1\n/gms;
+
+            # bold+italic
+            $str =~ s/\s*'''''(.*?)'''''\s*/\n.BI $1\n/gms;
+
+            # bold
+            $str =~ s/\s*'''(.*?)'''\s*/\n.B $1\n/gms;
+
+            # italic
+            $str =~ s/\s*''(.*?)''\s*/\n.I $1\n/gms;
+
+            # bullets
+            $str =~ s/^\* /\n\\\(bu /gm;
+        } else {
+            die("Unexpected wikitype when converting to manpages\n");   # !!! FIXME: need to handle Markdown wiki pages.
+        }
+
+        if (defined $code) {
+            $code =~ s/\A\n+//gms;
+            $code =~ s/\n+\Z//gms;
+            if ($dewikify_manpage_code_indent) {
+                $str .= "\n.IP\n"
+            } else {
+                $str .= "\n.PP\n"
+            }
+            $str .= ".EX\n$code\n.EE\n.PP\n";
+        }
+    } else {
+        die("Unexpected dewikify_mode\n");
+    }
+
+    #print("\n\nDEWIKIFY CHUNK DONE:\n\n$str\n\n\n");
+
+    return $str;
+}
+
+sub dewikify {
+    my $wikitype = shift;
+    my $str = shift;
+    return '' if not defined $str;
+
+    #print("DEWIKIFY WHOLE:\n\n$str\n\n\n");
+
+    $str =~ s/\A[\s\n]*\= .*? \=\s*?\n+//ms;
+    $str =~ s/\A[\s\n]*\=\= .*? \=\=\s*?\n+//ms;
+
+    my $retval = '';
+    while ($str =~ s/\A(.*?)<syntaxhighlight lang='?(.*?)'?>(.*?)<\/syntaxhighlight\>//ms) {
+        $retval .= dewikify_chunk($wikitype, $1, $2, $3);
+    }
+    $retval .= dewikify_chunk($wikitype, $str, undef, undef);
+
+    #print("DEWIKIFY WHOLE DONE:\n\n$retval\n\n\n");
+
+    return $retval;
+}
+
+sub usage {
+    die("USAGE: $0 <source code git clone path> <wiki git clone path> [--copy-to-headers|--copy-to-wiki|--copy-to-manpages] [--warn-about-missing]\n\n");
+}
+
+usage() if not defined $srcpath;
+usage() if not defined $wikipath;
+#usage() if $copy_direction == 0;
+
+my @standard_wiki_sections = (
+    'Draft',
+    '[Brief]',
+    'Deprecated',
+    'Syntax',
+    'Function Parameters',
+    'Return Value',
+    'Remarks',
+    'Version',
+    'Code Examples',
+    'Related Functions'
+);
+
+# Sections that only ever exist in the wiki and shouldn't be deleted when
+#  not found in the headers.
+my %only_wiki_sections = (  # The ones don't mean anything, I just need to check for key existence.
+    'Draft', 1,
+    'Code Examples', 1
+);
+
+
+my %headers = ();       # $headers{"SDL_audio.h"} -> reference to an array of all lines of text in SDL_audio.h.
+my %headerfuncs = ();   # $headerfuncs{"SDL_OpenAudio"} -> string of header documentation for SDL_OpenAudio, with comment '*' bits stripped from the start. Newlines embedded!
+my %headerdecls = ();
+my %headerfuncslocation = ();   # $headerfuncslocation{"SDL_OpenAudio"} -> name of header holding SDL_OpenAudio define ("SDL_audio.h" in this case).
+my %headerfuncschunk = ();   # $headerfuncschunk{"SDL_OpenAudio"} -> offset in array in %headers that should be replaced for this function.
+my %headerfuncshasdoxygen = ();   # $headerfuncschunk{"SDL_OpenAudio"} -> 1 if there was no existing doxygen for this function.
+
+my $incpath = "$srcpath/include";
+opendir(DH, $incpath) or die("Can't opendir '$incpath': $!\n");
+while (readdir(DH)) {
+    my $dent = $_;
+    next if not $dent =~ /\ASDL.*?\.h\Z/;  # just SDL*.h headers.
+    open(FH, '<', "$incpath/$dent") or die("Can't open '$incpath/$dent': $!\n");
+
+    my @contents = ();
+
+    while (<FH>) {
+        chomp;
+        my $decl;
+        my @templines;
+        my $str;
+        my $has_doxygen = 1;
+        if (/\A\s*extern\s+(SDL_DEPRECATED\s+|)DECLSPEC/) {  # a function declaration without a doxygen comment?
+            @templines = ();
+            $decl = $_;
+            $str = '';
+            $has_doxygen = 0;
+        } elsif (not /\A\/\*\*\s*\Z/) {  # not doxygen comment start?
+            push @contents, $_;
+            next;
+        } else {   # Start of a doxygen comment, parse it out.
+            @templines = ( $_ );
+            while (<FH>) {
+                chomp;
+                push @templines, $_;
+                last if /\A\s*\*\/\Z/;
+                if (s/\A\s*\*\s*\`\`\`/```/) {  # this is a hack, but a lot of other code relies on the whitespace being trimmed, but we can't trim it in code blocks...
+                    $str .= "$_\n";
+                    while (<FH>) {
+                        chomp;
+                        push @templines, $_;
+                        s/\A\s*\*\s?//;
+                        if (s/\A\s*\`\`\`/```/) {
+                            $str .= "$_\n";
+                            last;
+                        } else {
+                            $str .= "$_\n";
+                        }
+                    }
+                } else {
+                    s/\A\s*\*\s*//;
+                    $str .= "$_\n";
+                }
+            }
+
+            $decl = <FH>;
+            $decl = '' if not defined $decl;
+            chomp($decl);
+            if (not $decl =~ /\A\s*extern\s+(SDL_DEPRECATED\s+|)DECLSPEC/) {
+                #print "Found doxygen but no function sig:\n$str\n\n";
+                foreach (@templines) {
+                    push @contents, $_;
+                }
+                push @contents, $decl;
+                next;
+            }
+        }
+
+        my @decllines = ( $decl );
+
+        if (not $decl =~ /\)\s*;/) {
+            while (<FH>) {
+                chomp;
+                push @decllines, $_;
+                s/\A\s+//;
+                s/\s+\Z//;
+                $decl .= " $_";
+                last if /\)\s*;/;
+            }
+        }
+
+        $decl =~ s/\s+\);\Z/);/;
+        $decl =~ s/\s+\Z//;
+        #print("DECL: [$decl]\n");
+
+        my $fn = '';
+        if ($decl =~ /\A\s*extern\s+(SDL_DEPRECATED\s+|)DECLSPEC\s+(const\s+|)(unsigned\s+|)(.*?)\s*(\*?)\s*SDLCALL\s+(.*?)\s*\((.*?)\);/) {
+            $fn = $6;
+            #$decl =~ s/\A\s*extern\s+DECLSPEC\s+(.*?)\s+SDLCALL/$1/;
+        } else {
+            #print "Found doxygen but no function sig:\n$str\n\n";
+            foreach (@templines) {
+                push @contents, $_;
+            }
+            foreach (@decllines) {
+                push @contents, $_;
+            }
+            next;
+        }
+
+        $decl = '';  # build this with the line breaks, since it looks better for syntax highlighting.
+        foreach (@decllines) {
+            if ($decl eq '') {
+                $decl = $_;
+                $decl =~ s/\Aextern\s+(SDL_DEPRECATED\s+|)DECLSPEC\s+(.*?)\s+(\*?)SDLCALL\s+/$2$3 /;
+            } else {
+                my $trimmed = $_;
+                # !!! FIXME: trim space for SDL_DEPRECATED if it was used, too.
+                $trimmed =~ s/\A\s{24}//;  # 24 for shrinking to match the removed "extern DECLSPEC SDLCALL "
+                $decl .= $trimmed;
+            }
+            $decl .= "\n";
+        }
+
+        #print("$fn:\n$str\n\n");
+
+        # There might be multiple declarations of a function due to #ifdefs,
+        #  and only one of them will have documentation. If we hit an
+        #  undocumented one before, delete the placeholder line we left for
+        #  it so it doesn't accumulate a new blank line on each run.
+        my $skipfn = 0;
+        if (defined $headerfuncshasdoxygen{$fn}) {
+            if ($headerfuncshasdoxygen{$fn} == 0) {  # An undocumented declaration already exists, nuke its placeholder line.
+                delete $contents[$headerfuncschunk{$fn}];  # delete DOES NOT RENUMBER existing elements!
+            } else {  # documented function already existed?
+                $skipfn = 1;  # don't add this copy to the list of functions.
+                if ($has_doxygen) {
+                    print STDERR "WARNING: Function '$fn' appears to be documented in multiple locations. Only keeping the first one we saw!\n";
+                }
+                push @contents, join("\n", @decllines);  # just put the existing declation in as-is.
+            }
+        }
+
+        if (!$skipfn) {
+            $headerfuncs{$fn} = $str;
+            $headerdecls{$fn} = $decl;
+            $headerfuncslocation{$fn} = $dent;
+            $headerfuncschunk{$fn} = scalar(@contents);
+            $headerfuncshasdoxygen{$fn} = $has_doxygen;
+            push @contents, join("\n", @templines);
+            push @contents, join("\n", @decllines);
+        }
+
+    }
+    close(FH);
+
+    $headers{$dent} = \@contents;
+}
+closedir(DH);
+
+
+# !!! FIXME: we need to parse enums and typedefs and structs and defines and and and and and...
+# !!! FIXME:  (but functions are good enough for now.)
+
+my %wikitypes = ();  # contains string of wiki page extension, like $wikitypes{"SDL_OpenAudio"} == 'mediawiki'
+my %wikifuncs = ();  # contains references to hash of strings, each string being the full contents of a section of a wiki page, like $wikifuncs{"SDL_OpenAudio"}{"Remarks"}.
+my %wikisectionorder = ();   # contains references to array, each array item being a key to a wikipage section in the correct order, like $wikisectionorder{"SDL_OpenAudio"}[2] == 'Remarks'
+opendir(DH, $wikipath) or die("Can't opendir '$wikipath': $!\n");
+while (readdir(DH)) {
+    my $dent = $_;
+    my $type = '';
+    if ($dent =~ /\ASDL.*?\.(md|mediawiki)\Z/) {
+        $type = $1;
+    } else {
+        next;  # only dealing with wiki pages.
+    }
+
+    open(FH, '<', "$wikipath/$dent") or die("Can't open '$wikipath/$dent': $!\n");
+
+    my $current_section = '[start]';
+    my @section_order = ( $current_section );
+    my $fn = $dent;
+    $fn =~ s/\..*\Z//;
+    my %sections = ();
+    $sections{$current_section} = '';
+
+    while (<FH>) {
+        chomp;
+        my $orig = $_;
+        s/\A\s*//;
+        s/\s*\Z//;
+
+        if ($type eq 'mediawiki') {
+            if (/\A\= (.*?) \=\Z/) {
+                $current_section = ($1 eq $fn) ? '[Brief]' : $1;
+                die("Doubly-defined section '$current_section' in '$dent'!\n") if defined $sections{$current_section};
+                push @section_order, $current_section;
+                $sections{$current_section} = '';
+            } elsif (/\A\=\= (.*?) \=\=\Z/) {
+                $current_section = ($1 eq $fn) ? '[Brief]' : $1;
+                die("Doubly-defined section '$current_section' in '$dent'!\n") if defined $sections{$current_section};
+                push @section_order, $current_section;
+                $sections{$current_section} = '';
+                next;
+            } elsif (/\A\-\-\-\-\Z/) {
+                $current_section = '[footer]';
+                die("Doubly-defined section '$current_section' in '$dent'!\n") if defined $sections{$current_section};
+                push @section_order, $current_section;
+                $sections{$current_section} = '';
+                next;
+            }
+        } elsif ($type eq 'md') {
+            if (/\A\#+ (.*?)\Z/) {
+                $current_section = ($1 eq $fn) ? '[Brief]' : $1;
+                die("Doubly-defined section '$current_section' in '$dent'!\n") if defined $sections{$current_section};
+                push @section_order, $current_section;
+                $sections{$current_section} = '';
+                next;
+            } elsif (/\A\-\-\-\-\Z/) {
+                $current_section = '[footer]';
+                die("Doubly-defined section '$current_section' in '$dent'!\n") if defined $sections{$current_section};
+                push @section_order, $current_section;
+                $sections{$current_section} = '';
+                next;
+            }
+        } else {
+            die("Unexpected wiki file type. Fixme!\n");
+        }
+
+        $sections{$current_section} .= "$orig\n";
+    }
+    close(FH);
+
+    foreach (keys %sections) {
+        $sections{$_} =~ s/\A\n+//;
+        $sections{$_} =~ s/\n+\Z//;
+        $sections{$_} .= "\n";
+    }
+
+    if (0) {
+        foreach (@section_order) {
+            print("$fn SECTION '$_':\n");
+            print($sections{$_});
+            print("\n\n");
+        }
+    }
+
+    $wikitypes{$fn} = $type;
+    $wikifuncs{$fn} = \%sections;
+    $wikisectionorder{$fn} = \@section_order;
+}
+closedir(DH);
+
+
+if ($warn_about_missing) {
+    foreach (keys %wikifuncs) {
+        my $fn = $_;
+        if (not defined $headerfuncs{$fn}) {
+            print("WARNING: $fn defined in the wiki but not the headers!\n");
+        }
+    }
+
+    foreach (keys %headerfuncs) {
+        my $fn = $_;
+        if (not defined $wikifuncs{$fn}) {
+            print("WARNING: $fn defined in the headers but not the wiki!\n");
+        }
+    }
+}
+
+if ($copy_direction == 1) {  # --copy-to-headers
+    my %changed_headers = ();
+
+    $dewikify_mode = 'md';
+    $wordwrap_mode = 'md';   # the headers use Markdown format.
+
+    foreach (keys %headerfuncs) {
+        my $fn = $_;
+        next if not defined $wikifuncs{$fn};  # don't have a page for that function, skip it.
+        my $wikitype = $wikitypes{$fn};
+        my $sectionsref = $wikifuncs{$fn};
+        my $remarks = %$sectionsref{'Remarks'};
+        my $params = %$sectionsref{'Function Parameters'};
+        my $returns = %$sectionsref{'Return Value'};
+        my $version = %$sectionsref{'Version'};
+        my $related = %$sectionsref{'Related Functions'};
+        my $deprecated = %$sectionsref{'Deprecated'};
+        my $brief = %$sectionsref{'[Brief]'};
+        my $addblank = 0;
+        my $str = '';
+
+        $headerfuncshasdoxygen{$fn} = 1;  # Added/changed doxygen for this header.
+
+        $brief = dewikify($wikitype, $brief);
+        $brief =~ s/\A(.*?\.) /$1\n/;  # \brief should only be one sentence, delimited by a period+space. Split if necessary.
+        my @briefsplit = split /\n/, $brief;
+        $brief = shift @briefsplit;
+
+        if (defined $remarks) {
+            $remarks = join("\n", @briefsplit) . dewikify($wikitype, $remarks);
+        }
+
+        if (defined $brief) {
+            $str .= "\n" if $addblank; $addblank = 1;
+            $str .= wordwrap($brief) . "\n";
+        }
+
+        if (defined $remarks) {
+            $str .= "\n" if $addblank; $addblank = 1;
+            $str .= wordwrap($remarks) . "\n";
+        }
+
+        if (defined $deprecated) {
+            # !!! FIXME: lots of code duplication in all of these.
+            $str .= "\n" if $addblank; $addblank = 1;
+            my $v = dewikify($wikitype, $deprecated);
+            my $whitespacelen = length("\\deprecated") + 1;
+            my $whitespace = ' ' x $whitespacelen;
+            $v = wordwrap($v, -$whitespacelen);
+            my @desclines = split /\n/, $v;
+            my $firstline = shift @desclines;
+            $str .= "\\deprecated $firstline\n";
+            foreach (@desclines) {
+                $str .= "${whitespace}$_\n";
+            }
+        }
+
+        if (defined $params) {
+            $str .= "\n" if $addblank; $addblank = (defined $returns) ? 0 : 1;
+            my @lines = split /\n/, dewikify($wikitype, $params);
+            if ($wikitype eq 'mediawiki') {
+                die("Unexpected data parsing MediaWiki table") if (shift @lines ne '{|');  # Dump the '{|' start
+                while (scalar(@lines) >= 3) {
+                    my $name = shift @lines;
+                    my $desc = shift @lines;
+                    my $terminator = shift @lines;  # the '|-' or '|}' line.
+                    last if ($terminator ne '|-') and ($terminator ne '|}');  # we seem to have run out of table.
+                    $name =~ s/\A\|\s*//;
+                    $name =~ s/\A\*\*(.*?)\*\*/$1/;
+                    $name =~ s/\A\'\'\'(.*?)\'\'\'/$1/;
+                    $desc =~ s/\A\|\s*//;
+                    #print STDERR "FN: $fn   NAME: $name   DESC: $desc TERM: $terminator\n";
+                    my $whitespacelen = length($name) + 8;
+                    my $whitespace = ' ' x $whitespacelen;
+                    $desc = wordwrap($desc, -$whitespacelen);
+                    my @desclines = split /\n/, $desc;
+                    my $firstline = shift @desclines;
+                    $str .= "\\param $name $firstline\n";
+                    foreach (@desclines) {
+                        $str .= "${whitespace}$_\n";
+                    }
+                }
+            } else {
+                die("write me");
+            }
+        }
+
+        if (defined $returns) {
+            $str .= "\n" if $addblank; $addblank = 1;
+            my $r = dewikify($wikitype, $returns);
+            my $retstr = "\\returns";
+            if ($r =~ s/\AReturn(s?) //) {
+                $retstr = "\\return$1";
+            }
+
+            my $whitespacelen = length($retstr) + 1;
+            my $whitespace = ' ' x $whitespacelen;
+            $r = wordwrap($r, -$whitespacelen);
+            my @desclines = split /\n/, $r;
+            my $firstline = shift @desclines;
+            $str .= "$retstr $firstline\n";
+            foreach (@desclines) {
+                $str .= "${whitespace}$_\n";
+            }
+        }
+
+        if (defined $version) {
+            # !!! FIXME: lots of code duplication in all of these.
+            $str .= "\n" if $addblank; $addblank = 1;
+            my $v = dewikify($wikitype, $version);
+            my $whitespacelen = length("\\since") + 1;
+            my $whitespace = ' ' x $whitespacelen;
+            $v = wordwrap($v, -$whitespacelen);
+            my @desclines = split /\n/, $v;
+            my $firstline = shift @desclines;
+            $str .= "\\since $firstline\n";
+            foreach (@desclines) {
+                $str .= "${whitespace}$_\n";
+            }
+        }
+
+        if (defined $related) {
+            # !!! FIXME: lots of code duplication in all of these.
+            $str .= "\n" if $addblank; $addblank = 1;
+            my $v = dewikify($wikitype, $related);
+            my @desclines = split /\n/, $v;
+            foreach (@desclines) {
+                s/\A(\:|\* )//;
+                s/\(\)\Z//;  # Convert "SDL_Func()" to "SDL_Func"
+                $str .= "\\sa $_\n";
+            }
+        }
+
+        my $header = $headerfuncslocation{$fn};
+        my $contentsref = $headers{$header};
+        my $chunk = $headerfuncschunk{$fn};
+
+        my @lines = split /\n/, $str;
+
+        my $addnewline = (($chunk > 0) && ($$contentsref[$chunk-1] ne '')) ? "\n" : '';
+
+        my $output = "$addnewline/**\n";
+        foreach (@lines) {
+            chomp;
+            s/\s*\Z//;
+            if ($_ eq '') {
+                $output .= " *\n";
+            } else {
+                $output .= " * $_\n";
+            }
+        }
+        $output .= " */";
+
+        #print("$fn:\n$output\n\n");
+
+        $$contentsref[$chunk] = $output;
+        #$$contentsref[$chunk+1] = $headerdecls{$fn};
+
+        $changed_headers{$header} = 1;
+    }
+
+    foreach (keys %changed_headers) {
+        my $header = $_;
+
+        # this is kinda inefficient, but oh well.
+        my @removelines = ();
+        foreach (keys %headerfuncslocation) {
+            my $fn = $_;
+            next if $headerfuncshasdoxygen{$fn};
+            next if $headerfuncslocation{$fn} ne $header;
+            # the index of the blank line we put before the function declaration in case we needed to replace it with new content from the wiki.
+            push @removelines, $headerfuncschunk{$fn};
+        }
+
+        my $contentsref = $headers{$header};
+        foreach (@removelines) {
+            delete $$contentsref[$_];  # delete DOES NOT RENUMBER existing elements!
+        }
+
+        my $path = "$incpath/$header.tmp";
+        open(FH, '>', $path) or die("Can't open '$path': $!\n");
+        foreach (@$contentsref) {
+            print FH "$_\n" if defined $_;
+        }
+        close(FH);
+        rename($path, "$incpath/$header") or die("Can't rename '$path' to '$incpath/$header': $!\n");
+    }
+
+} elsif ($copy_direction == -1) { # --copy-to-wiki
+    foreach (keys %headerfuncs) {
+        my $fn = $_;
+        next if not $headerfuncshasdoxygen{$fn};
+        my $wikitype = defined $wikitypes{$fn} ? $wikitypes{$fn} : 'mediawiki';  # default to MediaWiki for new stuff FOR NOW.
+        die("Unexpected wikitype '$wikitype'\n") if (($wikitype ne 'mediawiki') and ($wikitype ne 'md') and ($wikitype ne 'manpage'));
+
+        #print("$fn\n"); next;
+
+        $wordwrap_mode = $wikitype;
+
+        my $raw = $headerfuncs{$fn};  # raw doxygen text with comment characters stripped from start/end and start of each line.
+        next if not defined $raw;
+        $raw =~ s/\A\s*\\brief\s+//;  # Technically we don't need \brief (please turn on JAVADOC_AUTOBRIEF if you use Doxygen), so just in case one is present, strip it.
+
+        my @doxygenlines = split /\n/, $raw;
+        my $brief = '';
+        while (@doxygenlines) {
+            last if $doxygenlines[0] =~ /\A\\/;  # some sort of doxygen command, assume we're past the general remarks.
+            last if $doxygenlines[0] =~ /\A\s*\Z/;  # blank line? End of paragraph, done.
+            my $l = shift @doxygenlines;
+            chomp($l);
+            $l =~ s/\A\s*//;
+            $l =~ s/\s*\Z//;
+            $brief .= "$l ";
+        }
+
+        $brief =~ s/\A(.*?\.) /$1\n\n/;  # \brief should only be one sentence, delimited by a period+space. Split if necessary.
+        my @briefsplit = split /\n/, $brief;
+        $brief = wikify($wikitype, shift @briefsplit) . "\n";
+        @doxygenlines = (@briefsplit, @doxygenlines);
+
+        my $remarks = '';
+        # !!! FIXME: wordwrap and wikify might handle this, now.
+        while (@doxygenlines) {
+            last if $doxygenlines[0] =~ /\A\\/;  # some sort of doxygen command, assume we're past the general remarks.
+            my $l = shift @doxygenlines;
+            if ($l =~ /\A\`\`\`/) {  # syntax highlighting, don't reformat.
+                $remarks .= "$l\n";
+                while ((@doxygenlines) && (not $l =~ /\`\`\`\Z/)) {
+                    $l = shift @doxygenlines;
+                    $remarks .= "$l\n";
+                }
+            } else {
+                $l =~ s/\A\s*//;
+                $l =~ s/\s*\Z//;
+                $remarks .= "$l\n";
+            }
+        }
+
+        #print("REMARKS:\n\n $remarks\n\n");
+
+        $remarks = wordwrap(wikify($wikitype, $remarks));
+        $remarks =~ s/\A\s*//;
+        $remarks =~ s/\s*\Z//;
+
+        my $decl = $headerdecls{$fn};
+        #$decl =~ s/\*\s+SDLCALL/ *SDLCALL/;  # Try to make "void * Function" become "void *Function"
+        #$decl =~ s/\A\s*extern\s+(SDL_DEPRECATED\s+|)DECLSPEC\s+(.*?)\s+(\*?)SDLCALL/$2$3/;
+
+        my $syntax = '';
+        if ($wikitype eq 'mediawiki') {
+            $syntax = "<syntaxhighlight lang='c'>\n$decl</syntaxhighlight>\n";
+        } elsif ($wikitype eq 'md') {
+            $syntax = "```c\n$decl\n```\n";
+        } else { die("Expected wikitype '$wikitype'\n"); }
+
+        my %sections = ();
+        $sections{'[Brief]'} = $brief;  # include this section even if blank so we get a title line.
+        $sections{'Remarks'} = "$remarks\n" if $remarks ne '';
+        $sections{'Syntax'} = $syntax;
+
+        my @params = ();  # have to parse these and build up the wiki tables after, since Markdown needs to know the length of the largest string.  :/
+
+        while (@doxygenlines) {
+            my $l = shift @doxygenlines;
+            if ($l =~ /\A\\param\s+(.*?)\s+(.*)\Z/) {
+                my $arg = $1;
+                my $desc = $2;
+                while (@doxygenlines) {
+                    my $subline = $doxygenlines[0];
+                    $subline =~ s/\A\s*//;
+                    last if $subline =~ /\A\\/;  # some sort of doxygen command, assume we're past this thing.
+                    shift @doxygenlines;  # dump this line from the array; we're using it.
+                    if ($subline eq '') {  # empty line, make sure it keeps the newline char.
+                        $desc .= "\n";
+                    } else {
+                        $desc .= " $subline";
+                    }
+                }
+
+                $desc =~ s/[\s\n]+\Z//ms;
+
+                # We need to know the length of the longest string to make Markdown tables, so we just store these off until everything is parsed.
+                push @params, $arg;
+                push @params, $desc;
+            } elsif ($l =~ /\A\\r(eturns?)\s+(.*)\Z/) {
+                my $retstr = "R$1";  # "Return" or "Returns"
+                my $desc = $2;
+                while (@doxygenlines) {
+                    my $subline = $doxygenlines[0];
+                    $subline =~ s/\A\s*//;
+                    last if $subline =~ /\A\\/;  # some sort of doxygen command, assume we're past this thing.
+                    shift @doxygenlines;  # dump this line from the array; we're using it.
+                    if ($subline eq '') {  # empty line, make sure it keeps the newline char.
+                        $desc .= "\n";
+                    } else {
+                        $desc .= " $subline";
+                    }
+                }
+                $desc =~ s/[\s\n]+\Z//ms;
+                $sections{'Return Value'} = wordwrap("$retstr " . wikify($wikitype, $desc)) . "\n";
+            } elsif ($l =~ /\A\\deprecated\s+(.*)\Z/) {
+                my $desc = $1;
+                while (@doxygenlines) {
+                    my $subline = $doxygenlines[0];
+                    $subline =~ s/\A\s*//;
+                    last if $subline =~ /\A\\/;  # some sort of doxygen command, assume we're past this thing.
+                    shift @doxygenlines;  # dump this line from the array; we're using it.
+                    if ($subline eq '') {  # empty line, make sure it keeps the newline char.
+                        $desc .= "\n";
+                    } else {
+                        $desc .= " $subline";
+                    }
+                }
+                $desc =~ s/[\s\n]+\Z//ms;
+                $sections{'Deprecated'} = wordwrap(wikify($wikitype, $desc)) . "\n";
+            } elsif ($l =~ /\A\\since\s+(.*)\Z/) {
+                my $desc = $1;
+                while (@doxygenlines) {
+                    my $subline = $doxygenlines[0];
+                    $subline =~ s/\A\s*//;
+                    last if $subline =~ /\A\\/;  # some sort of doxygen command, assume we're past this thing.
+                    shift @doxygenlines;  # dump this line from the array; we're using it.
+                    if ($subline eq '') {  # empty line, make sure it keeps the newline char.
+                        $desc .= "\n";
+                    } else {
+                        $desc .= " $subline";
+                    }
+                }
+                $desc =~ s/[\s\n]+\Z//ms;
+                $sections{'Version'} = wordwrap(wikify($wikitype, $desc)) . "\n";
+            } elsif ($l =~ /\A\\sa\s+(.*)\Z/) {
+                my $sa = $1;
+                $sa =~ s/\(\)\Z//;  # Convert "SDL_Func()" to "SDL_Func"
+                $sections{'Related Functions'} = '' if not defined $sections{'Related Functions'};
+                if ($wikitype eq 'mediawiki') {
+                    $sections{'Related Functions'} .= ":[[$sa]]\n";
+                } elsif ($wikitype eq 'md') {
+                    $sections{'Related Functions'} .= "* [$sa](/$sa)\n";
+                } else { die("Expected wikitype '$wikitype'\n"); }
+            }
+        }
+
+        # Make sure this ends with a double-newline.
+        $sections{'Related Functions'} .= "\n" if defined $sections{'Related Functions'};
+
+        # We can build the wiki table now that we have all the data.
+        if (scalar(@params) > 0) {
+            my $str = '';
+            if ($wikitype eq 'mediawiki') {
+                while (scalar(@params) > 0) {
+                    my $arg = shift @params;
+                    my $desc = wikify($wikitype, shift @params);
+                    $str .= ($str eq '') ? "{|\n" : "|-\n";
+                    $str .= "|'''$arg'''\n";
+                    $str .= "|$desc\n";
+                }
+                $str .= "|}\n";
+            } elsif ($wikitype eq 'md') {
+                my $longest_arg = 0;
+                my $longest_desc = 0;
+                my $which = 0;
+                foreach (@params) {
+                    if ($which == 0) {
+                        my $len = length($_) + 4;
+                        $longest_arg = $len if ($len > $longest_arg);
+                        $which = 1;
+                    } else {
+                        my $len = length(wikify($wikitype, $_));
+                        $longest_desc = $len if ($len > $longest_desc);
+                        $which = 0;
+                    }
+                }
+
+                # Markdown tables are sort of obnoxious.
+                $str .= '| ' . (' ' x ($longest_arg+4)) . ' | ' . (' ' x $longest_desc) . " |\n";
+                $str .= '| ' . ('-' x ($longest_arg+4)) . ' | ' . ('-' x $longest_desc) . " |\n";
+
+                while (@params) {
+                    my $arg = shift @params;
+                    my $desc = wikify($wikitype, shift @params);
+                    $str .= "| **$arg** " . (' ' x ($longest_arg - length($arg))) . "| $desc" . (' ' x ($longest_desc - length($desc))) . " |\n";
+                }
+            } else {
+                die("Unexpected wikitype!\n");  # should have checked this elsewhere.
+            }
+            $sections{'Function Parameters'} = $str;
+        }
+
+        my $path = "$wikipath/$_.${wikitype}.tmp";
+        open(FH, '>', $path) or die("Can't open '$path': $!\n");
+
+        my $sectionsref = $wikifuncs{$fn};
+
+        foreach (@standard_wiki_sections) {
+            # drop sections we either replaced or removed from the original wiki's contents.
+            if (not defined $only_wiki_sections{$_}) {
+                delete($$sectionsref{$_});
+            }
+        }
+
+        my $wikisectionorderref = $wikisectionorder{$fn};
+
+        # Make sure there's a footer in the wiki that puts this function in CategoryAPI...
+        if (not $$sectionsref{'[footer]'}) {
+            $$sectionsref{'[footer]'} = '';
+            push @$wikisectionorderref, '[footer]';
+        }
+
+        # !!! FIXME: This won't be CategoryAPI if we eventually handle things other than functions.
+        my $footer = $$sectionsref{'[footer]'};
+        if ($wikitype eq 'mediawiki') {
+            $footer =~ s/\[\[CategoryAPI\]\],?\s*//g;
+            $footer = '[[CategoryAPI]]' . (($footer eq '') ? "\n" : ", $footer");
+        } elsif ($wikitype eq 'md') {
+            $footer =~ s/\[CategoryAPI\]\(CategoryAPI\),?\s*//g;
+            $footer = '[CategoryAPI](CategoryAPI)' . (($footer eq '') ? '' : ', ') . $footer;
+        } else { die("Unexpected wikitype '$wikitype'\n"); }
+        $$sectionsref{'[footer]'} = $footer;
+
+        my $prevsectstr = '';
+        my @ordered_sections = (@standard_wiki_sections, defined $wikisectionorderref ? @$wikisectionorderref : ());  # this copies the arrays into one.
+        foreach (@ordered_sections) {
+            my $sect = $_;
+            next if $sect eq '[start]';
+            next if (not defined $sections{$sect} and not defined $$sectionsref{$sect});
+            my $section = defined $sections{$sect} ? $sections{$sect} : $$sectionsref{$sect};
+            if ($sect eq '[footer]') {
+                # Make sure previous section ends with two newlines.
+                if (substr($prevsectstr, -1) ne "\n") {
+                    print FH "\n\n";
+                } elsif (substr($prevsectstr, -2) ne "\n\n") {
+                    print FH "\n";
+                }
+                print FH "----\n";   # It's the same in Markdown and MediaWiki.
+            } elsif ($sect eq '[Brief]') {
+                if ($wikitype eq 'mediawiki') {
+                    print FH  "= $fn =\n\n";
+                } elsif ($wikitype eq 'md') {
+                    print FH "# $fn\n\n";
+                } else { die("Unexpected wikitype '$wikitype'\n"); }
+            } else {
+                if ($wikitype eq 'mediawiki') {
+                    print FH  "\n== $sect ==\n\n";
+                } elsif ($wikitype eq 'md') {
+                    print FH "\n## $sect\n\n";
+                } else { die("Unexpected wikitype '$wikitype'\n"); }
+            }
+
+            my $sectstr = defined $sections{$sect} ? $sections{$sect} : $$sectionsref{$sect};
+            print FH $sectstr;
+
+            $prevsectstr = $sectstr;
+
+            # make sure these don't show up twice.
+            delete($sections{$sect});
+            delete($$sectionsref{$sect});
+        }
+
+        print FH "\n\n";
+        close(FH);
+        rename($path, "$wikipath/$_.${wikitype}") or die("Can't rename '$path' to '$wikipath/$_.${wikitype}': $!\n");
+    }
+
+} elsif ($copy_direction == -2) { # --copy-to-manpages
+    # This only takes from the wiki data, since it has sections we omit from the headers, like code examples.
+
+    my $manpath = "$srcpath/man";
+    mkdir($manpath);
+    $manpath .= "/man3";
+    mkdir($manpath);
+
+    $dewikify_mode = 'manpage';
+    $wordwrap_mode = 'manpage';
+
+    my $introtxt = '';
+    if (0) {
+    open(FH, '<', "$srcpath/LICENSE.txt") or die("Can't open '$srcpath/LICENSE.txt': $!\n");
+    while (<FH>) {
+        chomp;
+        $introtxt .= ".\\\" $_\n";
+    }
+    close(FH);
+    }
+
+    my $gitrev = `cd "$srcpath" ; git rev-list HEAD~..`;
+    chomp($gitrev);
+
+    open(FH, '<', "$srcpath/include/SDL_version.h") or die("Can't open '$srcpath/include/SDL_version.h': $!\n");
+    my $majorver = 0;
+    my $minorver = 0;
+    my $patchver = 0;
+    while (<FH>) {
+        chomp;
+        if (/\A\#define SDL_MAJOR_VERSION\s+(\d+)\Z/) {
+            $majorver = int($1);
+        } elsif (/\A\#define SDL_MINOR_VERSION\s+(\d+)\Z/) {
+            $minorver = int($1);
+        } elsif (/\A\#define SDL_PATCHLEVEL\s+(\d+)\Z/) {
+            $patchver = int($1);
+        }
+    }
+    close(FH);
+    my $sdlversion = "$majorver.$minorver.$patchver";
+
+    foreach (keys %headerfuncs) {
+        my $fn = $_;
+        next if not defined $wikifuncs{$fn};  # don't have a page for that function, skip it.
+        my $wikitype = $wikitypes{$fn};
+        my $sectionsref = $wikifuncs{$fn};
+        my $remarks = %$sectionsref{'Remarks'};
+        my $params = %$sectionsref{'Function Parameters'};
+        my $returns = %$sectionsref{'Return Value'};
+        my $version = %$sectionsref{'Version'};
+        my $related = %$sectionsref{'Related Functions'};
+        my $examples = %$sectionsref{'Code Examples'};
+        my $deprecated = %$sectionsref{'Deprecated'};
+        my $brief = %$sectionsref{'[Brief]'};
+        my $decl = $headerdecls{$fn};
+        my $str = '';
+
+        $brief = "$brief";
+        $brief =~ s/\A[\s\n]*\= .*? \=\s*?\n+//ms;
+        $brief =~ s/\A[\s\n]*\=\= .*? \=\=\s*?\n+//ms;
+        $brief =~ s/\A(.*?\.) /$1\n/;  # \brief should only be one sentence, delimited by a period+space. Split if necessary.
+        my @briefsplit = split /\n/, $brief;
+        $brief = shift @briefsplit;
+        $brief = dewikify($wikitype, $brief);
+
+        if (defined $remarks) {
+            $remarks = dewikify($wikitype, join("\n", @briefsplit) . $remarks);
+        }
+
+        $str .= $introtxt;
+
+        $str .= ".\\\" This manpage content is licensed under Creative Commons\n";
+        $str .= ".\\\"  Attribution 4.0 International (CC BY 4.0)\n";
+        $str .= ".\\\"   https://creativecommons.org/licenses/by/4.0/\n";
+        $str .= ".\\\" This manpage was generated from SDL's wiki page for $fn:\n";
+        $str .= ".\\\"   https://wiki.libsdl.org/$fn\n";
+        $str .= ".\\\" Generated with SDL/build-scripts/wikiheaders.pl\n";
+        $str .= ".\\\"  revision $gitrev\n" if $gitrev ne '';
+        $str .= ".\\\" Please report issues in this manpage's content at:\n";
+        $str .= ".\\\"   https://github.com/libsdl-org/sdlwiki/issues/new?title=Feedback%20on%20page%20$fn\n";
+        $str .= ".\\\" Please report issues in the generation of this manpage from the wiki at:\n";
+        $str .= ".\\\"   https://github.com/libsdl-org/SDL/issues/new?title=Misgenerated%20manpage%20for%20$fn\n";
+        $str .= ".\\\" SDL can be found at https://libsdl.org/\n";
+
+        $str .= ".TH $fn 3 \"SDL $sdlversion\" \"Simple Directmedia Layer\" \"SDL$majorver FUNCTIONS\"\n";
+        $str .= ".SH NAME\n";
+
+        $str .= "$fn";
+        $str .= " \\- $brief" if (defined $brief);
+        $str .= "\n";
+
+        $str .= ".SH SYNOPSIS\n";
+        $str .= ".nf\n";
+        $str .= ".B #include \\(dqSDL.h\\(dq\n";
+        $str .= ".PP\n";
+
+        my @decllines = split /\n/, $decl;
+        foreach (@decllines) {
+            $str .= ".BI \"$_\n";
+        }
+        $str .= ".fi\n";
+
+        if (defined $remarks) {
+            $str .= ".SH DESCRIPTION\n";
+            $str .= $remarks . "\n";
+        }
+
+        if (defined $deprecated) {
+            $str .= ".SH DEPRECATED\n";
+            $str .= dewikify($wikitype, $deprecated) . "\n";
+        }
+
+        if (defined $params) {
+            $str .= ".SH FUNCTION PARAMETERS\n";
+            my @lines = split /\n/, $params;
+            if ($wikitype eq 'mediawiki') {
+                die("Unexpected data parsing MediaWiki table") if (shift @lines ne '{|');  # Dump the '{|' start
+                while (scalar(@lines) >= 3) {
+                    my $name = shift @lines;
+                    my $desc = shift @lines;
+                    my $terminator = shift @lines;  # the '|-' or '|}' line.
+                    last if ($terminator ne '|-') and ($terminator ne '|}');  # we seem to have run out of table.
+                    $name =~ s/\A\|\s*//;
+                    $name =~ s/\A\*\*(.*?)\*\*/$1/;
+                    $name =~ s/\A\'\'\'(.*?)\'\'\'/$1/;
+                    $desc =~ s/\A\|\s*//;
+                    $desc = dewikify($wikitype, $desc);
+                    #print STDERR "FN: $fn   NAME: $name   DESC: $desc TERM: $terminator\n";
+
+                    $str .= ".TP\n";
+                    $str .= ".I $name\n";
+                    $str .= "$desc\n";
+                }
+            } else {
+                die("write me");
+            }
+        }
+
+        if (defined $returns) {
+            $str .= ".SH RETURN VALUE\n";
+            $str .= dewikify($wikitype, $returns) . "\n";
+        }
+
+        if (defined $examples) {
+            $str .= ".SH CODE EXAMPLES\n";
+            $dewikify_manpage_code_indent = 0;
+            $str .= dewikify($wikitype, $examples) . "\n";
+            $dewikify_manpage_code_indent = 1;
+        }
+
+        if (defined $version) {
+            $str .= ".SH AVAILABILITY\n";
+            $str .= dewikify($wikitype, $version) . "\n";
+        }
+
+        if (defined $related) {
+            $str .= ".SH SEE ALSO\n";
+            # !!! FIXME: lots of code duplication in all of these.
+            my $v = dewikify($wikitype, $related);
+            my @desclines = split /\n/, $v;
+            my $nextstr = '';
+            foreach (@desclines) {
+                s/\A(\:|\* )//;
+                s/\(\)\Z//;  # Convert "SDL_Func()" to "SDL_Func"
+                s/\A\.BR\s+//;  # dewikify added this, but we want to handle it.
+                s/\A\s+//;
+                s/\s+\Z//;
+                next if $_ eq '';
+                $str .= "$nextstr.BR $_ (3)";
+                $nextstr = ",\n";
+            }
+            $str .= "\n";
+        }
+
+        if (0) {
+        $str .= ".SH COPYRIGHT\n";
+        $str .= "This manpage is licensed under\n";
+        $str .= ".UR https://creativecommons.org/licenses/by/4.0/\n";
+        $str .= "Creative Commons Attribution 4.0 International (CC BY 4.0)\n";
+        $str .= ".UE\n";
+        $str .= ".PP\n";
+        $str .= "This manpage was generated from\n";
+        $str .= ".UR https://wiki.libsdl.org/$fn\n";
+        $str .= "SDL's wiki\n";
+        $str .= ".UE\n";
+        $str .= "using SDL/build-scripts/wikiheaders.pl";
+        $str .= " revision $gitrev" if $gitrev ne '';
+        $str .= ".\n";
+        $str .= "Please report issues in this manpage at\n";
+        $str .= ".UR https://github.com/libsdl-org/sdlwiki/issues/new\n";
+        $str .= "our bugtracker!\n";
+        $str .= ".UE\n";
+        }
+
+        my $path = "$manpath/$_.3.tmp";
+        open(FH, '>', $path) or die("Can't open '$path': $!\n");
+        print FH $str;
+        close(FH);
+        rename($path, "$manpath/$_.3") or die("Can't rename '$path' to '$manpath/$_.3': $!\n");
+    }
+}
+
+# end of wikiheaders.pl ...
+
diff --git a/Engine/lib/sdl/build-scripts/winrtbuild.ps1 b/Engine/lib/sdl/build-scripts/winrtbuild.ps1
index f22a5d22c..1da76abb1 100644
--- a/Engine/lib/sdl/build-scripts/winrtbuild.ps1
+++ b/Engine/lib/sdl/build-scripts/winrtbuild.ps1
@@ -39,7 +39,7 @@
 #
 
 # Base version of SDL, used for packaging purposes
-$SDLVersion = "2.0.14"
+$SDLVersion = "2.0.21"
 
 # Gets the .bat file that sets up an MSBuild environment, given one of
 # Visual Studio's, "PlatformToolset"s.
diff --git a/Engine/lib/sdl/cmake/macros.cmake b/Engine/lib/sdl/cmake/macros.cmake
index 96a7ce8b1..62621ddfa 100644
--- a/Engine/lib/sdl/cmake/macros.cmake
+++ b/Engine/lib/sdl/cmake/macros.cmake
@@ -1,5 +1,13 @@
+macro(ADD_TO_ALLOPTIONS _NEWNAME)
+  list(APPEND ALLOPTIONS ${_NEWNAME})
+  string(LENGTH ${_NEWNAME} _SLEN)
+  if(${LONGESTOPTIONNAME} LESS ${_SLEN})
+    set(LONGESTOPTIONNAME ${_SLEN})
+  endif()
+endmacro()
+
 macro(SET_OPTION _NAME _DESC)
-  list(APPEND ALLOPTIONS ${_NAME})
+  add_to_alloptions(${_NAME})
   if(${ARGC} EQUAL 3)
     set(_DEFLT ${ARGV2})
   else()
@@ -9,12 +17,12 @@ macro(SET_OPTION _NAME _DESC)
 endmacro()
 
 macro(DEP_OPTION _NAME _DESC _DEFLT _DEPTEST _FAILDFLT)
-  list(APPEND ALLOPTIONS ${_NAME})
+  add_to_alloptions(${_NAME})
   cmake_dependent_option(${_NAME} ${_DESC} ${_DEFLT} ${_DEPTEST} ${_FAILDFLT})
 endmacro()
 
 macro(OPTION_STRING _NAME _DESC _VALUE)
-  list(APPEND ALLOPTIONS ${_NAME})
+  add_to_alloptions(${_NAME})
   set(${_NAME} ${_VALUE} CACHE STRING "${_DESC}")
   set(HAVE_${_NAME} ${_VALUE})
 ENDMACRO()
@@ -42,12 +50,18 @@ macro(MESSAGE_TESTED_OPTION _NAME)
   if(${ARGC} EQUAL 2)
     set(_PAD ${ARGV1})
   endif()
-  if(NOT HAVE_${_NAME})
-    set(HAVE_${_NAME} OFF)
-  elseif("${HAVE_${_NAME}}" MATCHES "1|TRUE|YES|Y")
-    set(HAVE_${_NAME} ON)
+  string(SUBSTRING "${_NAME}" 0 4 _NAMESTART)
+  if(_NAMESTART STREQUAL "SDL_")
+    string(SUBSTRING "${_NAME}" 4 -1 _STRIPPEDNAME)
+  else()
+    set(_STRIPPEDNAME "${_NAME}")
   endif()
-  message(STATUS "  ${_NAME}${_PAD}(Wanted: ${_REQVALUE}): ${HAVE_${_NAME}}")
+  if(NOT HAVE_${_STRIPPEDNAME})
+    set(HAVE_${_STRIPPEDNAME} OFF)
+  elseif("${HAVE_${_STRIPPEDNAME}}" MATCHES "1|TRUE|YES|Y")
+    set(HAVE_${_STRIPPEDNAME} ON)
+  endif()
+  message(STATUS "  ${_NAME}${_PAD}(Wanted: ${_REQVALUE}): ${HAVE_${_STRIPPEDNAME}}")
 endmacro()
 
 macro(LISTTOSTR _LIST _OUTPUT)
@@ -64,10 +78,36 @@ macro(LISTTOSTR _LIST _OUTPUT)
   endforeach()
 endmacro()
 
-macro(CHECK_OBJC_SOURCE_COMPILES SOURCE VAR)
-  set(PREV_REQUIRED_DEFS "${CMAKE_REQUIRED_DEFINITIONS}")
-  set(CMAKE_REQUIRED_DEFINITIONS "-x objective-c ${PREV_REQUIRED_DEFS}")
-  CHECK_C_SOURCE_COMPILES(${SOURCE} ${VAR})
-  set(CMAKE_REQUIRED_DEFINITIONS "${PREV_REQUIRED_DEFS}")
+macro(LISTTOSTRREV _LIST _OUTPUT)
+  if(${ARGC} EQUAL 3)
+    # prefix for each element
+    set(_LPREFIX ${ARGV2})
+  else()
+    set(_LPREFIX "")
+  endif()
+  # Do not use string(REPLACE ";" " ") here to avoid messing up list
+  # entries
+  foreach(_ITEM ${${_LIST}})
+    set(${_OUTPUT} "${${_OUTPUT}} ${_LPREFIX}${_ITEM}")
+  endforeach()
 endmacro()
 
+if(${CMAKE_VERSION} VERSION_LESS "3.16.0")
+  macro(CHECK_OBJC_SOURCE_COMPILES SOURCE VAR)
+    set(PREV_REQUIRED_DEFS "${CMAKE_REQUIRED_DEFINITIONS}")
+    set(CMAKE_REQUIRED_DEFINITIONS "-x objective-c ${PREV_REQUIRED_DEFS}")
+    CHECK_C_SOURCE_COMPILES(${SOURCE} ${VAR})
+    set(CMAKE_REQUIRED_DEFINITIONS "${PREV_REQUIRED_DEFS}")
+  endmacro()
+else()
+  include(CheckOBJCSourceCompiles)
+  if (APPLE)
+      enable_language(OBJC)
+  endif()
+endif()
+
+if(CMAKE_VERSION VERSION_LESS 3.13.0)
+  macro(target_link_directories _TARGET _SCOPE)
+    link_directories(${ARGN})
+  endmacro()
+endif()
diff --git a/Engine/lib/sdl/cmake/sdlchecks.cmake b/Engine/lib/sdl/cmake/sdlchecks.cmake
index a9434c85a..c9feffb69 100644
--- a/Engine/lib/sdl/cmake/sdlchecks.cmake
+++ b/Engine/lib/sdl/cmake/sdlchecks.cmake
@@ -32,17 +32,13 @@ endmacro()
 macro(CheckDLOPEN)
   check_symbol_exists(dlopen "dlfcn.h" HAVE_DLOPEN)
   if(NOT HAVE_DLOPEN)
-    foreach(_LIBNAME dl tdl)
-      check_library_exists("${_LIBNAME}" "dlopen" "" DLOPEN_LIB)
-      if(DLOPEN_LIB)
-        list(APPEND EXTRA_LIBS ${_LIBNAME})
-        set(_DLLIB ${_LIBNAME})
-        set(HAVE_DLOPEN TRUE)
-        break()
-      endif()
-    endforeach()
+    check_library_exists(dl dlopen "" DLOPEN_LIB)
+    if(DLOPEN_LIB)
+      list(APPEND EXTRA_LIBS dl)
+      set(_DLLIB dl)
+      set(HAVE_DLOPEN TRUE)
+    endif()
   endif()
-
   if(HAVE_DLOPEN)
     if(_DLLIB)
       set(CMAKE_REQUIRED_LIBRARIES ${_DLLIB})
@@ -52,32 +48,32 @@ macro(CheckDLOPEN)
        int main(int argc, char **argv) {
          void *handle = dlopen(\"\", RTLD_NOW);
          const char *loaderror = (char *) dlerror();
+         return 0;
        }" HAVE_DLOPEN)
     set(CMAKE_REQUIRED_LIBRARIES)
   endif()
+endmacro()
 
-  if (HAVE_DLOPEN)
-    set(SDL_LOADSO_DLOPEN 1)
-    set(HAVE_SDL_DLOPEN TRUE)
-    file(GLOB DLOPEN_SOURCES ${SDL2_SOURCE_DIR}/src/loadso/dlopen/*.c)
-    set(SOURCE_FILES ${SOURCE_FILES} ${DLOPEN_SOURCES})
-    set(HAVE_SDL_LOADSO TRUE)
-  endif()
+macro(CheckO_CLOEXEC)
+  check_c_source_compiles("
+    #include <fcntl.h>
+    int flag = O_CLOEXEC;
+    int main(int argc, char **argv) { return 0; }" HAVE_O_CLOEXEC)
 endmacro()
 
 # Requires:
 # - n/a
 macro(CheckOSS)
-  if(OSS)
+  if(SDL_OSS)
     set(OSS_HEADER_FILE "sys/soundcard.h")
     check_c_source_compiles("
         #include <sys/soundcard.h>
-        int main() { int arg = SNDCTL_DSP_SETFRAGMENT; }" OSS_FOUND)
+        int main(int argc, char **argv) { int arg = SNDCTL_DSP_SETFRAGMENT; return 0; }" OSS_FOUND)
     if(NOT OSS_FOUND)
       set(OSS_HEADER_FILE "soundcard.h")
       check_c_source_compiles("
           #include <soundcard.h>
-          int main() { int arg = SNDCTL_DSP_SETFRAGMENT; }" OSS_FOUND)
+          int main(int argc, char **argv) { int arg = SNDCTL_DSP_SETFRAGMENT; return 0; }" OSS_FOUND)
     endif()
 
     if(OSS_FOUND)
@@ -99,10 +95,10 @@ endmacro()
 # Requires:
 # - n/a
 # Optional:
-# - ALSA_SHARED opt
-# - HAVE_DLOPEN opt
+# - SDL_ALSA_SHARED opt
+# - HAVE_SDL_LOADSO opt
 macro(CheckALSA)
-  if(ALSA)
+  if(SDL_ALSA)
     CHECK_INCLUDE_FILE(alsa/asoundlib.h HAVE_ASOUNDLIB_H)
     if(HAVE_ASOUNDLIB_H)
       CHECK_LIBRARY_EXISTS(asound snd_pcm_recover "" HAVE_LIBASOUND)
@@ -112,14 +108,13 @@ macro(CheckALSA)
       file(GLOB ALSA_SOURCES ${SDL2_SOURCE_DIR}/src/audio/alsa/*.c)
       set(SOURCE_FILES ${SOURCE_FILES} ${ALSA_SOURCES})
       set(SDL_AUDIO_DRIVER_ALSA 1)
-      if(ALSA_SHARED)
-        if(NOT HAVE_DLOPEN)
-          message_warn("You must have SDL_LoadObject() support for dynamic ALSA loading")
-        else()
-          FindLibraryAndSONAME("asound")
-          set(SDL_AUDIO_DRIVER_ALSA_DYNAMIC "\"${ASOUND_LIB_SONAME}\"")
-          set(HAVE_ALSA_SHARED TRUE)
-        endif()
+      if(SDL_ALSA_SHARED AND NOT HAVE_SDL_LOADSO)
+        message_warn("You must have SDL_LoadObject() support for dynamic ALSA loading")
+      endif()
+      if(SDL_ALSA_SHARED AND HAVE_SDL_LOADSO)
+        FindLibraryAndSONAME("asound")
+        set(SDL_AUDIO_DRIVER_ALSA_DYNAMIC "\"${ASOUND_LIB_SONAME}\"")
+        set(HAVE_ALSA_SHARED TRUE)
       else()
         list(APPEND EXTRA_LIBS asound)
       endif()
@@ -131,10 +126,39 @@ endmacro()
 # Requires:
 # - PkgCheckModules
 # Optional:
-# - PULSEAUDIO_SHARED opt
-# - HAVE_DLOPEN opt
+# - SDL_PIPEWIRE_SHARED opt
+# - HAVE_SDL_LOADSO opt
+macro(CheckPipewire)
+    if(SDL_PIPEWIRE)
+        pkg_check_modules(PKG_PIPEWIRE libpipewire-0.3>=0.3.20)
+        if(PKG_PIPEWIRE_FOUND)
+            set(HAVE_PIPEWIRE TRUE)
+            file(GLOB PIPEWIRE_SOURCES ${SDL2_SOURCE_DIR}/src/audio/pipewire/*.c)
+            set(SOURCE_FILES ${SOURCE_FILES} ${PIPEWIRE_SOURCES})
+            set(SDL_AUDIO_DRIVER_PIPEWIRE 1)
+            list(APPEND EXTRA_CFLAGS ${PKG_PIPEWIRE_CFLAGS})
+            if(SDL_PIPEWIRE_SHARED AND NOT HAVE_SDL_LOADSO)
+                message_warn("You must have SDL_LoadObject() support for dynamic Pipewire loading")
+            endif()
+            if(SDL_PIPEWIRE_SHARED AND HAVE_SDL_LOADSO)
+                FindLibraryAndSONAME("pipewire-0.3")
+                set(SDL_AUDIO_DRIVER_PIPEWIRE_DYNAMIC "\"${PIPEWIRE_0.3_LIB_SONAME}\"")
+                set(HAVE_PIPEWIRE_SHARED TRUE)
+            else()
+                list(APPEND EXTRA_LDFLAGS ${PKG_PIPEWIRE_LDFLAGS})
+            endif()
+            set(HAVE_SDL_AUDIO TRUE)
+        endif()
+    endif()
+endmacro()
+
+# Requires:
+# - PkgCheckModules
+# Optional:
+# - SDL_PULSEAUDIO_SHARED opt
+# - HAVE_SDL_LOADSO opt
 macro(CheckPulseAudio)
-  if(PULSEAUDIO)
+  if(SDL_PULSEAUDIO)
     pkg_check_modules(PKG_PULSEAUDIO libpulse-simple)
     if(PKG_PULSEAUDIO_FOUND)
       set(HAVE_PULSEAUDIO TRUE)
@@ -142,14 +166,13 @@ macro(CheckPulseAudio)
       set(SOURCE_FILES ${SOURCE_FILES} ${PULSEAUDIO_SOURCES})
       set(SDL_AUDIO_DRIVER_PULSEAUDIO 1)
       list(APPEND EXTRA_CFLAGS ${PKG_PULSEAUDIO_CFLAGS})
-      if(PULSEAUDIO_SHARED)
-        if(NOT HAVE_DLOPEN)
-          message_warn("You must have SDL_LoadObject() support for dynamic PulseAudio loading")
-        else()
-          FindLibraryAndSONAME("pulse-simple")
-          set(SDL_AUDIO_DRIVER_PULSEAUDIO_DYNAMIC "\"${PULSE_SIMPLE_LIB_SONAME}\"")
-          set(HAVE_PULSEAUDIO_SHARED TRUE)
-        endif()
+      if(SDL_PULSEAUDIO_SHARED AND NOT HAVE_SDL_LOADSO)
+        message_warn("You must have SDL_LoadObject() support for dynamic PulseAudio loading")
+      endif()
+      if(SDL_PULSEAUDIO_SHARED AND HAVE_SDL_LOADSO)
+        FindLibraryAndSONAME("pulse-simple")
+        set(SDL_AUDIO_DRIVER_PULSEAUDIO_DYNAMIC "\"${PULSE_SIMPLE_LIB_SONAME}\"")
+        set(HAVE_PULSEAUDIO_SHARED TRUE)
       else()
         list(APPEND EXTRA_LDFLAGS ${PKG_PULSEAUDIO_LDFLAGS})
       endif()
@@ -161,10 +184,10 @@ endmacro()
 # Requires:
 # - PkgCheckModules
 # Optional:
-# - JACK_SHARED opt
-# - HAVE_DLOPEN opt
+# - SDL_JACK_SHARED opt
+# - HAVE_SDL_LOADSO opt
 macro(CheckJACK)
-  if(JACK)
+  if(SDL_JACK)
     pkg_check_modules(PKG_JACK jack)
     if(PKG_JACK_FOUND)
       set(HAVE_JACK TRUE)
@@ -172,14 +195,13 @@ macro(CheckJACK)
       set(SOURCE_FILES ${SOURCE_FILES} ${JACK_SOURCES})
       set(SDL_AUDIO_DRIVER_JACK 1)
       list(APPEND EXTRA_CFLAGS ${PKG_JACK_CFLAGS})
-      if(JACK_SHARED)
-        if(NOT HAVE_DLOPEN)
-          message_warn("You must have SDL_LoadObject() support for dynamic JACK audio loading")
-        else()
-          FindLibraryAndSONAME("jack")
-          set(SDL_AUDIO_DRIVER_JACK_DYNAMIC "\"${JACK_LIB_SONAME}\"")
-          set(HAVE_JACK_SHARED TRUE)
-        endif()
+      if(SDL_JACK_SHARED AND NOT HAVE_SDL_LOADSO)
+        message_warn("You must have SDL_LoadObject() support for dynamic JACK audio loading")
+      endif()
+      if(SDL_JACK_SHARED AND HAVE_SDL_LOADSO)
+        FindLibraryAndSONAME("jack")
+        set(SDL_AUDIO_DRIVER_JACK_DYNAMIC "\"${JACK_LIB_SONAME}\"")
+        set(HAVE_JACK_SHARED TRUE)
       else()
         list(APPEND EXTRA_LDFLAGS ${PKG_JACK_LDFLAGS})
       endif()
@@ -191,10 +213,10 @@ endmacro()
 # Requires:
 # - PkgCheckModules
 # Optional:
-# - ESD_SHARED opt
-# - HAVE_DLOPEN opt
+# - SDL_ESD_SHARED opt
+# - HAVE_SDL_LOADSO opt
 macro(CheckESD)
-  if(ESD)
+  if(SDL_ESD)
     pkg_check_modules(PKG_ESD esound)
     if(PKG_ESD_FOUND)
       set(HAVE_ESD TRUE)
@@ -202,16 +224,15 @@ macro(CheckESD)
       set(SOURCE_FILES ${SOURCE_FILES} ${ESD_SOURCES})
       set(SDL_AUDIO_DRIVER_ESD 1)
       list(APPEND EXTRA_CFLAGS ${PKG_ESD_CFLAGS})
-      if(ESD_SHARED)
-        if(NOT HAVE_DLOPEN)
+      if(SDL_ESD_SHARED AND NOT HAVE_SDL_LOADSO)
           message_warn("You must have SDL_LoadObject() support for dynamic ESD loading")
-        else()
+      endif()
+      if(SDL_ESD_SHARED AND HAVE_SDL_LOADSO)
           FindLibraryAndSONAME(esd)
           set(SDL_AUDIO_DRIVER_ESD_DYNAMIC "\"${ESD_LIB_SONAME}\"")
           set(HAVE_ESD_SHARED TRUE)
-        endif()
       else()
-        list(APPEND EXTRA_LDFLAGS ${PKG_ESD_LDFLAGS})
+          list(APPEND EXTRA_LDFLAGS ${PKG_ESD_LDFLAGS})
       endif()
       set(HAVE_SDL_AUDIO TRUE)
     endif()
@@ -221,10 +242,10 @@ endmacro()
 # Requires:
 # - n/a
 # Optional:
-# - ARTS_SHARED opt
-# - HAVE_DLOPEN opt
+# - SDL_ARTS_SHARED opt
+# - HAVE_SDL_LOADSO opt
 macro(CheckARTS)
-  if(ARTS)
+  if(SDL_ARTS)
     find_program(ARTS_CONFIG arts-config)
     if(ARTS_CONFIG)
       execute_process(CMD_ARTSCFLAGS ${ARTS_CONFIG} --cflags
@@ -236,15 +257,14 @@ macro(CheckARTS)
       set(SOURCE_FILES ${SOURCE_FILES} ${ARTS_SOURCES})
       set(SDL_AUDIO_DRIVER_ARTS 1)
       set(HAVE_ARTS TRUE)
-      if(ARTS_SHARED)
-        if(NOT HAVE_DLOPEN)
-          message_warn("You must have SDL_LoadObject() support for dynamic ARTS loading")
-        else()
-          # TODO
-          FindLibraryAndSONAME(artsc)
-          set(SDL_AUDIO_DRIVER_ARTS_DYNAMIC "\"${ARTSC_LIB_SONAME}\"")
-          set(HAVE_ARTS_SHARED TRUE)
-        endif()
+      if(SDL_ARTS_SHARED AND NOT HAVE_SDL_LOADSO)
+        message_warn("You must have SDL_LoadObject() support for dynamic ARTS loading")
+      endif()
+      if(SDL_ARTS_SHARED AND HAVE_SDL_LOADSO)
+        # TODO
+        FindLibraryAndSONAME(artsc)
+        set(SDL_AUDIO_DRIVER_ARTS_DYNAMIC "\"${ARTSC_LIB_SONAME}\"")
+        set(HAVE_ARTS_SHARED TRUE)
       else()
         list(APPEND EXTRA_LDFLAGS ${ARTS_LIBS})
       endif()
@@ -256,10 +276,10 @@ endmacro()
 # Requires:
 # - n/a
 # Optional:
-# - NAS_SHARED opt
-# - HAVE_DLOPEN opt
+# - SDL_NAS_SHARED opt
+# - HAVE_SDL_LOADSO opt
 macro(CheckNAS)
-  if(NAS)
+  if(SDL_NAS)
     # TODO: set include paths properly, so the NAS headers are found
     check_include_file(audio/audiolib.h HAVE_NAS_H)
     find_library(D_NAS_LIB audio)
@@ -268,14 +288,13 @@ macro(CheckNAS)
       file(GLOB NAS_SOURCES ${SDL2_SOURCE_DIR}/src/audio/nas/*.c)
       set(SOURCE_FILES ${SOURCE_FILES} ${NAS_SOURCES})
       set(SDL_AUDIO_DRIVER_NAS 1)
-      if(NAS_SHARED)
-        if(NOT HAVE_DLOPEN)
-          message_warn("You must have SDL_LoadObject() support for dynamic NAS loading")
-        else()
-          FindLibraryAndSONAME("audio")
-          set(SDL_AUDIO_DRIVER_NAS_DYNAMIC "\"${AUDIO_LIB_SONAME}\"")
-          set(HAVE_NAS_SHARED TRUE)
-        endif()
+      if(SDL_NAS_SHARED AND NOT HAVE_SDL_LOADSO)
+        message_warn("You must have SDL_LoadObject() support for dynamic NAS loading")
+      endif()
+      if(SDL_NAS_SHARED AND HAVE_SDL_LOADSO)
+        FindLibraryAndSONAME("audio")
+        set(SDL_AUDIO_DRIVER_NAS_DYNAMIC "\"${AUDIO_LIB_SONAME}\"")
+        set(HAVE_NAS_SHARED TRUE)
       else()
         list(APPEND EXTRA_LIBS ${D_NAS_LIB})
       endif()
@@ -287,10 +306,10 @@ endmacro()
 # Requires:
 # - n/a
 # Optional:
-# - SNDIO_SHARED opt
-# - HAVE_DLOPEN opt
+# - SDL_SNDIO_SHARED opt
+# - HAVE_SDL_LOADSO opt
 macro(CheckSNDIO)
-  if(SNDIO)
+  if(SDL_SNDIO)
     # TODO: set include paths properly, so the sndio headers are found
     check_include_file(sndio.h HAVE_SNDIO_H)
     find_library(D_SNDIO_LIB sndio)
@@ -299,14 +318,13 @@ macro(CheckSNDIO)
       file(GLOB SNDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/sndio/*.c)
       set(SOURCE_FILES ${SOURCE_FILES} ${SNDIO_SOURCES})
       set(SDL_AUDIO_DRIVER_SNDIO 1)
-      if(SNDIO_SHARED)
-        if(NOT HAVE_DLOPEN)
-          message_warn("You must have SDL_LoadObject() support for dynamic sndio loading")
-        else()
-          FindLibraryAndSONAME("sndio")
-          set(SDL_AUDIO_DRIVER_SNDIO_DYNAMIC "\"${SNDIO_LIB_SONAME}\"")
-          set(HAVE_SNDIO_SHARED TRUE)
-        endif()
+      if(SDL_SNDIO_SHARED AND NOT HAVE_SDL_LOADSO)
+        message_warn("You must have SDL_LoadObject() support for dynamic sndio loading")
+      endif()
+      if(SDL_SNDIO_SHARED AND HAVE_SDL_LOADSO)
+        FindLibraryAndSONAME("sndio")
+        set(SDL_AUDIO_DRIVER_SNDIO_DYNAMIC "\"${SNDIO_LIB_SONAME}\"")
+        set(HAVE_SNDIO_SHARED TRUE)
       else()
         list(APPEND EXTRA_LIBS ${D_SNDIO_LIB})
       endif()
@@ -319,7 +337,7 @@ endmacro()
 # - PkgCheckModules
 # Optional:
 # - FUSIONSOUND_SHARED opt
-# - HAVE_DLOPEN opt
+# - HAVE_SDL_LOADSO opt
 macro(CheckFusionSound)
   if(FUSIONSOUND)
     pkg_check_modules(PKG_FUSIONSOUND fusionsound>=1.0.0)
@@ -329,14 +347,13 @@ macro(CheckFusionSound)
       set(SOURCE_FILES ${SOURCE_FILES} ${FUSIONSOUND_SOURCES})
       set(SDL_AUDIO_DRIVER_FUSIONSOUND 1)
       list(APPEND EXTRA_CFLAGS ${PKG_FUSIONSOUND_CFLAGS})
-      if(FUSIONSOUND_SHARED)
-        if(NOT HAVE_DLOPEN)
-          message_warn("You must have SDL_LoadObject() support for dynamic FusionSound loading")
-        else()
-          FindLibraryAndSONAME("fusionsound")
-          set(SDL_AUDIO_DRIVER_FUSIONSOUND_DYNAMIC "\"${FUSIONSOUND_LIB_SONAME}\"")
-          set(HAVE_FUSIONSOUND_SHARED TRUE)
-        endif()
+      if(FUSIONSOUND_SHARED AND NOT HAVE_SDL_LOADSO)
+        message_warn("You must have SDL_LoadObject() support for dynamic FusionSound loading")
+      endif()
+      if(FUSIONSOUND_SHARED AND HAVE_SDL_LOADSO)
+        FindLibraryAndSONAME("fusionsound")
+        set(SDL_AUDIO_DRIVER_FUSIONSOUND_DYNAMIC "\"${FUSIONSOUND_LIB_SONAME}\"")
+        set(HAVE_FUSIONSOUND_SHARED TRUE)
       else()
         list(APPEND EXTRA_LDFLAGS ${PKG_FUSIONSOUND_LDFLAGS})
       endif()
@@ -346,23 +363,22 @@ macro(CheckFusionSound)
 endmacro()
 
 # Requires:
-# - LIBSAMPLERATE
+# - SDL_LIBSAMPLERATE
 # Optional:
-# - LIBSAMPLERATE_SHARED opt
-# - HAVE_DLOPEN opt
+# - SDL_LIBSAMPLERATE_SHARED opt
+# - HAVE_SDL_LOADSO opt
 macro(CheckLibSampleRate)
-  if(LIBSAMPLERATE)
+  if(SDL_LIBSAMPLERATE)
     check_include_file(samplerate.h HAVE_LIBSAMPLERATE_H)
     if(HAVE_LIBSAMPLERATE_H)
       set(HAVE_LIBSAMPLERATE TRUE)
-      if(LIBSAMPLERATE_SHARED)
-        if(NOT HAVE_DLOPEN)
-          message_warn("You must have SDL_LoadObject() support for dynamic libsamplerate loading")
-        else()
-          FindLibraryAndSONAME("samplerate")
-          set(SDL_LIBSAMPLERATE_DYNAMIC "\"${SAMPLERATE_LIB_SONAME}\"")
-          set(HAVE_LIBSAMPLERATE_SHARED TRUE)
-        endif()
+      if(SDL_LIBSAMPLERATE_SHARED AND NOT HAVE_SDL_LOADSO)
+        message_warn("You must have SDL_LoadObject() support for dynamic libsamplerate loading")
+      endif()
+      if(SDL_LIBSAMPLERATE_SHARED AND HAVE_SDL_LOADSO)
+        FindLibraryAndSONAME("samplerate")
+        set(SDL_LIBSAMPLERATE_DYNAMIC "\"${SAMPLERATE_LIB_SONAME}\"")
+        set(HAVE_LIBSAMPLERATE_SHARED TRUE)
       else()
         list(APPEND EXTRA_LDFLAGS -lsamplerate)
       endif()
@@ -373,11 +389,11 @@ endmacro()
 # Requires:
 # - n/a
 # Optional:
-# - X11_SHARED opt
-# - HAVE_DLOPEN opt
+# - SDL_X11_SHARED opt
+# - HAVE_SDL_LOADSO opt
 macro(CheckX11)
-  if(VIDEO_X11)
-    foreach(_LIB X11 Xext Xcursor Xinerama Xi Xrandr Xrender Xss Xxf86vm)
+  if(SDL_X11)
+    foreach(_LIB X11 Xext Xcursor Xinerama Xi Xfixes Xrandr Xrender Xss Xxf86vm)
         FindLibraryAndSONAME("${_LIB}")
     endforeach()
 
@@ -400,11 +416,13 @@ macro(CheckX11)
 
     check_include_file(X11/Xcursor/Xcursor.h HAVE_XCURSOR_H)
     check_include_file(X11/extensions/Xinerama.h HAVE_XINERAMA_H)
-    check_include_file(X11/extensions/XInput2.h HAVE_XINPUT_H)
+    check_include_file(X11/extensions/XInput2.h HAVE_XINPUT2_H)
     check_include_file(X11/extensions/Xrandr.h HAVE_XRANDR_H)
+    check_include_file(X11/extensions/Xfixes.h HAVE_XFIXES_H_)
     check_include_file(X11/extensions/Xrender.h HAVE_XRENDER_H)
     check_include_file(X11/extensions/scrnsaver.h HAVE_XSS_H)
     check_include_file(X11/extensions/shape.h HAVE_XSHAPE_H)
+    check_include_files("X11/Xlib.h;X11/extensions/Xdbe.h" HAVE_XDBE_H)
     check_include_files("X11/Xlib.h;X11/extensions/xf86vmode.h" HAVE_XF86VM_H)
     check_include_files("X11/Xlib.h;X11/Xproto.h;X11/extensions/Xext.h" HAVE_XEXT_H)
 
@@ -413,15 +431,16 @@ macro(CheckX11)
         message_error("Missing Xext.h, maybe you need to install the libxext-dev package?")
       endif()
 
-      set(HAVE_VIDEO_X11 TRUE)
+      set(HAVE_X11 TRUE)
       set(HAVE_SDL_VIDEO TRUE)
 
       file(GLOB X11_SOURCES ${SDL2_SOURCE_DIR}/src/video/x11/*.c)
       set(SOURCE_FILES ${SOURCE_FILES} ${X11_SOURCES})
       set(SDL_VIDEO_DRIVER_X11 1)
 
+      # !!! FIXME: why is this disabled for Apple?
       if(APPLE)
-        set(X11_SHARED OFF)
+        set(SDL_X11_SHARED OFF)
       endif()
 
       check_symbol_exists(shmat "sys/shm.h" HAVE_SHMAT)
@@ -431,13 +450,12 @@ macro(CheckX11)
           list(APPEND EXTRA_LIBS ipc)
         endif()
         if(NOT HAVE_SHMAT)
-          add_definitions(-DNO_SHARED_MEMORY)
           list(APPEND EXTRA_CFLAGS "-DNO_SHARED_MEMORY")
         endif()
       endif()
 
-      if(X11_SHARED)
-        if(NOT HAVE_DLOPEN)
+      if(SDL_X11_SHARED)
+        if(NOT HAVE_SDL_LOADSO)
           message_warn("You must have SDL_LoadObject() support for dynamic X11 loading")
           set(HAVE_X11_SHARED FALSE)
         else()
@@ -449,19 +467,11 @@ macro(CheckX11)
         else()
           list(APPEND EXTRA_LIBS ${X11_LIB} ${XEXT_LIB})
         endif()
+      else()
+          list(APPEND EXTRA_LIBS ${X11_LIB} ${XEXT_LIB})
       endif()
 
       set(CMAKE_REQUIRED_LIBRARIES ${X11_LIB} ${X11_LIB})
-      check_c_source_compiles("
-          #include <X11/Xlib.h>
-          #include <X11/Xproto.h>
-          #include <X11/extensions/Xext.h>
-          #include <X11/extensions/extutil.h>
-          extern XExtDisplayInfo* XextAddDisplay(XExtensionInfo* a,Display* b,_Xconst char* c,XExtensionHooks* d,int e,XPointer f);
-          int main(int argc, char **argv) {}" HAVE_CONST_XEXT_ADDDISPLAY)
-      if(HAVE_CONST_XEXT_ADDDISPLAY)
-        set(SDL_VIDEO_DRIVER_X11_CONST_PARAM_XEXTADDDISPLAY 1)
-      endif()
 
       check_c_source_compiles("
           #include <X11/Xlib.h>
@@ -471,15 +481,16 @@ macro(CheckX11)
             XGenericEventCookie *cookie = &event.xcookie;
             XNextEvent(display, &event);
             XGetEventData(display, cookie);
-            XFreeEventData(display, cookie); }" HAVE_XGENERICEVENT)
+            XFreeEventData(display, cookie);
+            return 0; }" HAVE_XGENERICEVENT)
       if(HAVE_XGENERICEVENT)
         set(SDL_VIDEO_DRIVER_X11_SUPPORTS_GENERIC_EVENTS 1)
       endif()
 
       check_symbol_exists(XkbKeycodeToKeysym "X11/Xlib.h;X11/XKBlib.h" SDL_VIDEO_DRIVER_X11_HAS_XKBKEYCODETOKEYSYM)
 
-      if(VIDEO_X11_XCURSOR AND HAVE_XCURSOR_H)
-        set(HAVE_VIDEO_X11_XCURSOR TRUE)
+      if(SDL_X11_XCURSOR AND HAVE_XCURSOR_H)
+        set(HAVE_X11_XCURSOR TRUE)
         if(HAVE_X11_SHARED AND XCURSOR_LIB)
           set(SDL_VIDEO_DRIVER_X11_DYNAMIC_XCURSOR "\"${XCURSOR_LIB_SONAME}\"")
         else()
@@ -488,8 +499,13 @@ macro(CheckX11)
         set(SDL_VIDEO_DRIVER_X11_XCURSOR 1)
       endif()
 
-      if(VIDEO_X11_XINERAMA AND HAVE_XINERAMA_H)
-        set(HAVE_VIDEO_X11_XINERAMA TRUE)
+      if(SDL_X11_XDBE AND HAVE_XDBE_H)
+        set(HAVE_X11_XDBE TRUE)
+        set(SDL_VIDEO_DRIVER_X11_XDBE 1)
+      endif()
+
+      if(SDL_X11_XINERAMA AND HAVE_XINERAMA_H)
+        set(HAVE_X11_XINERAMA TRUE)
         if(HAVE_X11_SHARED AND XINERAMA_LIB)
           set(SDL_VIDEO_DRIVER_X11_DYNAMIC_XINERAMA "\"${XINERAMA_LIB_SONAME}\"")
         else()
@@ -498,8 +514,8 @@ macro(CheckX11)
         set(SDL_VIDEO_DRIVER_X11_XINERAMA 1)
       endif()
 
-      if(VIDEO_X11_XINPUT AND HAVE_XINPUT_H)
-        set(HAVE_VIDEO_X11_XINPUT TRUE)
+      if(SDL_X11_XINPUT AND HAVE_XINPUT2_H)
+        set(HAVE_X11_XINPUT TRUE)
         if(HAVE_X11_SHARED AND XI_LIB)
           set(SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT2 "\"${XI_LIB_SONAME}\"")
         else()
@@ -514,57 +530,80 @@ macro(CheckX11)
             #include <X11/extensions/XInput2.h>
             int event_type = XI_TouchBegin;
             XITouchClassInfo *t;
-            Status XIAllowTouchEvents(Display *a,int b,unsigned int c,Window d,int f)
-            {
+            Status XIAllowTouchEvents(Display *a,int b,unsigned int c,Window d,int f) {
               return (Status)0;
             }
-            int main(int argc, char **argv) {}" HAVE_XINPUT2_MULTITOUCH)
+            int main(int argc, char **argv) { return 0; }" HAVE_XINPUT2_MULTITOUCH)
         if(HAVE_XINPUT2_MULTITOUCH)
           set(SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH 1)
         endif()
       endif()
 
-      if(VIDEO_X11_XRANDR AND HAVE_XRANDR_H)
+      # check along with XInput2.h because we use Xfixes with XIBarrierReleasePointer
+      if(SDL_X11_XFIXES AND HAVE_XFIXES_H_ AND HAVE_XINPUT2_H)
+        check_c_source_compiles("
+            #include <X11/Xlib.h>
+            #include <X11/Xproto.h>
+            #include <X11/extensions/XInput2.h>
+            #include <X11/extensions/Xfixes.h>
+            BarrierEventID b;
+            int main(int argc, char **argv) { return 0; }" HAVE_XFIXES_H)
+      endif()
+      if(SDL_X11_XFIXES AND HAVE_XFIXES_H AND HAVE_XINPUT2_H)
+        if(HAVE_X11_SHARED AND XFIXES_LIB)
+          set(SDL_VIDEO_DRIVER_X11_DYNAMIC_XFIXES "\"${XFIXES_LIB_SONAME}\"")
+        else()
+          list(APPEND EXTRA_LIBS ${XFIXES_LIB})
+        endif()
+        set(SDL_VIDEO_DRIVER_X11_XFIXES 1)
+        set(HAVE_X11_XFIXES TRUE)
+      endif()
+
+      if(SDL_X11_XRANDR AND HAVE_XRANDR_H)
         if(HAVE_X11_SHARED AND XRANDR_LIB)
           set(SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR "\"${XRANDR_LIB_SONAME}\"")
         else()
           list(APPEND EXTRA_LIBS ${XRANDR_LIB})
         endif()
         set(SDL_VIDEO_DRIVER_X11_XRANDR 1)
-        set(HAVE_VIDEO_X11_XRANDR TRUE)
+        set(HAVE_X11_XRANDR TRUE)
       endif()
 
-      if(VIDEO_X11_XSCRNSAVER AND HAVE_XSS_H)
+      if(SDL_X11_XSCRNSAVER AND HAVE_XSS_H)
         if(HAVE_X11_SHARED AND XSS_LIB)
           set(SDL_VIDEO_DRIVER_X11_DYNAMIC_XSS "\"${XSS_LIB_SONAME}\"")
         else()
           list(APPEND EXTRA_LIBS ${XSS_LIB})
         endif()
         set(SDL_VIDEO_DRIVER_X11_XSCRNSAVER 1)
-        set(HAVE_VIDEO_X11_XSCRNSAVER TRUE)
+        set(HAVE_X11_XSCRNSAVER TRUE)
       endif()
 
-      if(VIDEO_X11_XSHAPE AND HAVE_XSHAPE_H)
+      if(SDL_X11_XSHAPE AND HAVE_XSHAPE_H)
         set(SDL_VIDEO_DRIVER_X11_XSHAPE 1)
-        set(HAVE_VIDEO_X11_XSHAPE TRUE)
+        set(HAVE_X11_XSHAPE TRUE)
       endif()
 
-      if(VIDEO_X11_XVM AND HAVE_XF86VM_H)
+      if(SDL_X11_XVM AND HAVE_XF86VM_H)
         if(HAVE_X11_SHARED AND XXF86VM_LIB)
           set(SDL_VIDEO_DRIVER_X11_DYNAMIC_XVIDMODE "\"${XXF86VM_LIB_SONAME}\"")
         else()
           list(APPEND EXTRA_LIBS ${XXF86VM_LIB})
         endif()
         set(SDL_VIDEO_DRIVER_X11_XVIDMODE 1)
-        set(HAVE_VIDEO_X11_XVM TRUE)
+        set(HAVE_X11_XVM TRUE)
       endif()
 
       set(CMAKE_REQUIRED_LIBRARIES)
     endif()
   endif()
+  if(NOT HAVE_X11)
+    # Prevent Mesa from including X11 headers
+    list(APPEND EXTRA_CFLAGS "-DMESA_EGL_NO_X11_HEADERS -DEGL_NO_X11")
+  endif()
 endmacro()
 
-macro(WaylandProtocolGen _SCANNER _XML _PROTL)
+macro(WaylandProtocolGen _SCANNER _CODE_MODE _XML _PROTL)
     set(_WAYLAND_PROT_C_CODE "${CMAKE_CURRENT_BINARY_DIR}/wayland-generated-protocols/${_PROTL}-protocol.c")
     set(_WAYLAND_PROT_H_CODE "${CMAKE_CURRENT_BINARY_DIR}/wayland-generated-protocols/${_PROTL}-client-protocol.h")
 
@@ -579,7 +618,7 @@ macro(WaylandProtocolGen _SCANNER _XML _PROTL)
         OUTPUT "${_WAYLAND_PROT_C_CODE}"
         DEPENDS "${_WAYLAND_PROT_H_CODE}"
         COMMAND "${_SCANNER}"
-        ARGS code "${_XML}" "${_WAYLAND_PROT_C_CODE}"
+        ARGS "${_CODE_MODE}" "${_XML}" "${_WAYLAND_PROT_C_CODE}"
     )
 
     set(SOURCE_FILES ${SOURCE_FILES} "${_WAYLAND_PROT_C_CODE}")
@@ -589,34 +628,39 @@ endmacro()
 # - EGL
 # - PkgCheckModules
 # Optional:
-# - WAYLAND_SHARED opt
-# - HAVE_DLOPEN opt
+# - SDL_WAYLAND_SHARED opt
+# - HAVE_SDL_LOADSO opt
 macro(CheckWayland)
-  if(VIDEO_WAYLAND)
-    pkg_check_modules(WAYLAND wayland-client wayland-scanner wayland-egl wayland-cursor egl xkbcommon)
+  if(SDL_WAYLAND)
+    pkg_check_modules(WAYLAND wayland-client wayland-egl wayland-cursor egl "xkbcommon>=0.5.0")
 
     if(WAYLAND_FOUND)
+      find_program(WAYLAND_SCANNER NAMES wayland-scanner REQUIRED)
       execute_process(
-        COMMAND ${PKG_CONFIG_EXECUTABLE} --variable=wayland_scanner wayland-scanner
-        WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
-        RESULT_VARIABLE WAYLAND_SCANNER_RC
-        OUTPUT_VARIABLE WAYLAND_SCANNER
-        ERROR_QUIET
-        OUTPUT_STRIP_TRAILING_WHITESPACE
+        COMMAND ${WAYLAND_SCANNER} --version
+        RESULT_VARIABLE WAYLAND_SCANNER_VERSION_RC
+        ERROR_VARIABLE WAYLAND_SCANNER_VERSION
+        ERROR_STRIP_TRAILING_WHITESPACE
       )
-      if(NOT WAYLAND_SCANNER_RC EQUAL 0)
+      if(NOT WAYLAND_SCANNER_VERSION_RC EQUAL 0)
+        message(FATAL "Failed to get wayland-scanner version")
         set(WAYLAND_FOUND FALSE)
       endif()
+      string(REPLACE "wayland-scanner " "" WAYLAND_SCANNER_VERSION ${WAYLAND_SCANNER_VERSION})
+
+      string(COMPARE LESS ${WAYLAND_SCANNER_VERSION} "1.15.0" WAYLAND_SCANNER_PRE_1_15)
+      if(WAYLAND_SCANNER_PRE_1_15)
+        set(WAYLAND_SCANNER_CODE_MODE "code")
+      else()
+        set(WAYLAND_SCANNER_CODE_MODE "private-code")
+      endif()
     endif()
 
     if(WAYLAND_FOUND)
-      link_directories(
-          ${WAYLAND_LIBRARY_DIRS}
-      )
-      include_directories(
-          ${WAYLAND_INCLUDE_DIRS}
-      )
-      set(HAVE_VIDEO_WAYLAND TRUE)
+      target_link_directories(sdl-build-options INTERFACE "${WAYLAND_LIBRARY_DIRS}")
+      target_include_directories(sdl-build-options INTERFACE "${WAYLAND_INCLUDE_DIRS}")
+
+      set(HAVE_WAYLAND TRUE)
       set(HAVE_SDL_VIDEO TRUE)
 
       file(GLOB WAYLAND_SOURCES ${SDL2_SOURCE_DIR}/src/video/wayland/*.c)
@@ -624,37 +668,56 @@ macro(CheckWayland)
 
       # We have to generate some protocol interface code for some unstable Wayland features.
       file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/wayland-generated-protocols")
-      include_directories("${CMAKE_CURRENT_BINARY_DIR}/wayland-generated-protocols")
+      target_include_directories(sdl-build-options INTERFACE "${CMAKE_CURRENT_BINARY_DIR}/wayland-generated-protocols")
 
       file(GLOB WAYLAND_PROTOCOLS_XML RELATIVE "${SDL2_SOURCE_DIR}/wayland-protocols/" "${SDL2_SOURCE_DIR}/wayland-protocols/*.xml")
       foreach(_XML ${WAYLAND_PROTOCOLS_XML})
         string(REGEX REPLACE "\\.xml$" "" _PROTL "${_XML}")
-        WaylandProtocolGen("${WAYLAND_SCANNER}" "${SDL2_SOURCE_DIR}/wayland-protocols/${_XML}" "${_PROTL}")
+        WaylandProtocolGen("${WAYLAND_SCANNER}" "${WAYLAND_SCANNER_CODE_MODE}" "${SDL2_SOURCE_DIR}/wayland-protocols/${_XML}" "${_PROTL}")
       endforeach()
 
-      if(VIDEO_WAYLAND_QT_TOUCH)
-          set(HAVE_VIDEO_WAYLAND_QT_TOUCH TRUE)
+      if(SDL_WAYLAND_QT_TOUCH)
+          set(HAVE_WAYLAND_QT_TOUCH TRUE)
           set(SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH 1)
       endif()
 
-      if(WAYLAND_SHARED)
-        if(NOT HAVE_DLOPEN)
-          message_warn("You must have SDL_LoadObject() support for dynamic Wayland loading")
-        else()
-          FindLibraryAndSONAME(wayland-client)
-          FindLibraryAndSONAME(wayland-egl)
-          FindLibraryAndSONAME(wayland-cursor)
-          FindLibraryAndSONAME(xkbcommon)
-          set(SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC "\"${WAYLAND_CLIENT_LIB_SONAME}\"")
-          set(SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_EGL "\"${WAYLAND_EGL_LIB_SONAME}\"")
-          set(SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_CURSOR "\"${WAYLAND_CURSOR_LIB_SONAME}\"")
-          set(SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_XKBCOMMON "\"${XKBCOMMON_LIB_SONAME}\"")
-          set(HAVE_WAYLAND_SHARED TRUE)
-        endif()
+      if(SDL_WAYLAND_SHARED AND NOT HAVE_SDL_LOADSO)
+        message_warn("You must have SDL_LoadObject() support for dynamic Wayland loading")
+      endif()
+      if(SDL_WAYLAND_SHARED AND HAVE_SDL_LOADSO)
+        FindLibraryAndSONAME(wayland-client)
+        FindLibraryAndSONAME(wayland-egl)
+        FindLibraryAndSONAME(wayland-cursor)
+        FindLibraryAndSONAME(xkbcommon)
+        set(SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC "\"${WAYLAND_CLIENT_LIB_SONAME}\"")
+        set(SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_EGL "\"${WAYLAND_EGL_LIB_SONAME}\"")
+        set(SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_CURSOR "\"${WAYLAND_CURSOR_LIB_SONAME}\"")
+        set(SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_XKBCOMMON "\"${XKBCOMMON_LIB_SONAME}\"")
+        set(HAVE_WAYLAND_SHARED TRUE)
       else()
         set(EXTRA_LIBS ${WAYLAND_LIBRARIES} ${EXTRA_LIBS})
       endif()
 
+      if(SDL_WAYLAND_LIBDECOR)
+        pkg_check_modules(LIBDECOR libdecor-0)
+        if(LIBDECOR_FOUND)
+            set(HAVE_WAYLAND_LIBDECOR TRUE)
+            set(HAVE_LIBDECOR_H 1)
+            target_link_directories(sdl-build-options INTERFACE "${LIBDECOR_LIBRARY_DIRS}")
+            target_include_directories(sdl-build-options INTERFACE "${LIBDECOR_INCLUDE_DIRS}")
+            if(SDL_WAYLAND_LIBDECOR_SHARED AND NOT HAVE_SDL_LOADSO)
+                message_warn("You must have SDL_LoadObject() support for dynamic libdecor loading")
+            endif()
+            if(SDL_WAYLAND_LIBDECOR_SHARED AND HAVE_SDL_LOADSO)
+                set(HAVE_LIBDECOR_SHARED TRUE)
+                FindLibraryAndSONAME(decor-0)
+                set(SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_LIBDECOR "\"${DECOR_0_LIB_SONAME}\"")
+            else()
+              set(EXTRA_LIBS ${LIBDECOR_LIBRARIES} ${EXTRA_LIBS})
+            endif()
+        endif()
+      endif()
+
       set(SDL_VIDEO_DRIVER_WAYLAND 1)
     endif()
   endif()
@@ -664,11 +727,11 @@ endmacro()
 # - n/a
 #
 macro(CheckCOCOA)
-  if(VIDEO_COCOA)
+  if(SDL_COCOA)
     if(APPLE) # Apple always has Cocoa.
-      set(HAVE_VIDEO_COCOA TRUE)
+      set(HAVE_COCOA TRUE)
     endif()
-    if(HAVE_VIDEO_COCOA)
+    if(HAVE_COCOA)
       file(GLOB COCOA_SOURCES ${SDL2_SOURCE_DIR}/src/video/cocoa/*.m)
       set_source_files_properties(${COCOA_SOURCES} PROPERTIES LANGUAGE C)
       set(SOURCE_FILES ${SOURCE_FILES} ${COCOA_SOURCES})
@@ -682,25 +745,24 @@ endmacro()
 # - PkgCheckModules
 # Optional:
 # - DIRECTFB_SHARED opt
-# - HAVE_DLOPEN opt
+# - HAVE_SDL_LOADSO opt
 macro(CheckDirectFB)
-  if(VIDEO_DIRECTFB)
+  if(SDL_DIRECTFB)
     pkg_check_modules(PKG_DIRECTFB directfb>=1.0.0)
     if(PKG_DIRECTFB_FOUND)
-      set(HAVE_VIDEO_DIRECTFB TRUE)
+      set(HAVE_DIRECTFB TRUE)
       file(GLOB DIRECTFB_SOURCES ${SDL2_SOURCE_DIR}/src/video/directfb/*.c)
       set(SOURCE_FILES ${SOURCE_FILES} ${DIRECTFB_SOURCES})
       set(SDL_VIDEO_DRIVER_DIRECTFB 1)
       set(SDL_VIDEO_RENDER_DIRECTFB 1)
       list(APPEND EXTRA_CFLAGS ${PKG_DIRECTFB_CFLAGS})
-      if(DIRECTFB_SHARED)
-        if(NOT HAVE_DLOPEN)
-          message_warn("You must have SDL_LoadObject() support for dynamic DirectFB loading")
-        else()
-          FindLibraryAndSONAME("directfb")
-          set(SDL_VIDEO_DRIVER_DIRECTFB_DYNAMIC "\"${DIRECTFB_LIB_SONAME}\"")
-          set(HAVE_DIRECTFB_SHARED TRUE)
-        endif()
+      if(SDL_DIRECTFB_SHARED AND NOT HAVE_SDL_LOADSO)
+        message_warn("You must have SDL_LoadObject() support for dynamic DirectFB loading")
+      endif()
+      if(SDL_DIRECTFB_SHARED AND HAVE_SDL_LOADSO)
+        FindLibraryAndSONAME("directfb")
+        set(SDL_VIDEO_DRIVER_DIRECTFB_DYNAMIC "\"${DIRECTFB_LIB_SONAME}\"")
+        set(HAVE_DIRECTFB_SHARED TRUE)
       else()
         list(APPEND EXTRA_LDFLAGS ${PKG_DIRECTFB_LDFLAGS})
       endif()
@@ -712,83 +774,102 @@ endmacro()
 # Requires:
 # - n/a
 macro(CheckVivante)
-  if(VIDEO_VIVANTE)
+  if(SDL_VIVANTE)
     check_c_source_compiles("
         #include <gc_vdk.h>
-        int main(int argc, char** argv) {}" HAVE_VIDEO_VIVANTE_VDK)
+        int main(int argc, char** argv) { return 0; }" HAVE_VIVANTE_VDK)
     check_c_source_compiles("
         #define LINUX
         #define EGL_API_FB
         #include <EGL/eglvivante.h>
-        int main(int argc, char** argv) {}" HAVE_VIDEO_VIVANTE_EGL_FB)
-    if(HAVE_VIDEO_VIVANTE_VDK OR HAVE_VIDEO_VIVANTE_EGL_FB)
-      set(HAVE_VIDEO_VIVANTE TRUE)
+        int main(int argc, char** argv) { return 0; }" HAVE_VIVANTE_EGL_FB)
+    if(HAVE_VIVANTE_VDK OR HAVE_VIVANTE_EGL_FB)
+      set(HAVE_VIVANTE TRUE)
       set(HAVE_SDL_VIDEO TRUE)
 
       file(GLOB VIVANTE_SOURCES ${SDL2_SOURCE_DIR}/src/video/vivante/*.c)
       set(SOURCE_FILES ${SOURCE_FILES} ${VIVANTE_SOURCES})
       set(SDL_VIDEO_DRIVER_VIVANTE 1)
-      if(HAVE_VIDEO_VIVANTE_VDK)
+      if(HAVE_VIVANTE_VDK)
         set(SDL_VIDEO_DRIVER_VIVANTE_VDK 1)
         list(APPEND EXTRA_LIBS VDK VIVANTE)
       else()
         set(SDL_CFLAGS "${SDL_CFLAGS} -DLINUX -DEGL_API_FB")
         list(APPEND EXTRA_LIBS EGL)
-      endif(HAVE_VIDEO_VIVANTE_VDK)
-    endif(HAVE_VIDEO_VIVANTE_VDK OR HAVE_VIDEO_VIVANTE_EGL_FB)
-  endif(VIDEO_VIVANTE)
-endmacro(CheckVivante)
+      endif(HAVE_VIVANTE_VDK)
+    endif()
+  endif()
+endmacro()
 
 # Requires:
 # - nada
-macro(CheckOpenGLX11)
-  if(VIDEO_OPENGL)
+macro(CheckGLX)
+  if(SDL_OPENGL)
     check_c_source_compiles("
-        #include <GL/gl.h>
         #include <GL/glx.h>
-        int main(int argc, char** argv) {}" HAVE_VIDEO_OPENGL)
-
-    if(HAVE_VIDEO_OPENGL)
-      set(HAVE_VIDEO_OPENGL TRUE)
-      set(SDL_VIDEO_OPENGL 1)
+        int main(int argc, char** argv) { return 0; }" HAVE_OPENGL_GLX)
+    if(HAVE_OPENGL_GLX)
       set(SDL_VIDEO_OPENGL_GLX 1)
-      set(SDL_VIDEO_RENDER_OGL 1)
     endif()
   endif()
 endmacro()
 
 # Requires:
 # - PkgCheckModules
-macro(CheckOpenGLESX11)
-  pkg_check_modules(EGL egl)
-  set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${EGL_CFLAGS}")
-  if(VIDEO_OPENGLES)
+macro(CheckEGL)
+  if (SDL_OPENGL OR SDL_OPENGLES)
+    pkg_check_modules(EGL egl)
+    set(CMAKE_REQUIRED_DEFINITIONS "${CMAKE_REQUIRED_DEFINITIONS} ${EGL_CFLAGS}")
     check_c_source_compiles("
         #define EGL_API_FB
+        #define MESA_EGL_NO_X11_HEADERS
+        #define EGL_NO_X11
         #include <EGL/egl.h>
-        int main (int argc, char** argv) {}" HAVE_VIDEO_OPENGL_EGL)
-    if(HAVE_VIDEO_OPENGL_EGL)
-        set(SDL_VIDEO_OPENGL_EGL 1)
+        #include <EGL/eglext.h>
+        int main (int argc, char** argv) { return 0; }" HAVE_OPENGL_EGL)
+    if(HAVE_OPENGL_EGL)
+      set(SDL_VIDEO_OPENGL_EGL 1)
     endif()
+  endif()
+endmacro()
+
+# Requires:
+# - nada
+macro(CheckOpenGL)
+  if(SDL_OPENGL)
     check_c_source_compiles("
-      #include <GLES/gl.h>
-      #include <GLES/glext.h>
-      int main (int argc, char** argv) {}" HAVE_VIDEO_OPENGLES_V1)
-    if(HAVE_VIDEO_OPENGLES_V1)
-        set(HAVE_VIDEO_OPENGLES TRUE)
+        #include <GL/gl.h>
+        #include <GL/glext.h>
+        int main(int argc, char** argv) { return 0; }" HAVE_OPENGL)
+    if(HAVE_OPENGL)
+      set(SDL_VIDEO_OPENGL 1)
+      set(SDL_VIDEO_RENDER_OGL 1)
+    endif()
+  endif()
+endmacro()
+
+# Requires:
+# - nada
+macro(CheckOpenGLES)
+  if(SDL_OPENGLES)
+    check_c_source_compiles("
+        #include <GLES/gl.h>
+        #include <GLES/glext.h>
+        int main (int argc, char** argv) { return 0; }" HAVE_OPENGLES_V1)
+    if(HAVE_OPENGLES_V1)
+        set(HAVE_OPENGLES TRUE)
         set(SDL_VIDEO_OPENGL_ES 1)
         set(SDL_VIDEO_RENDER_OGL_ES 1)
     endif()
     check_c_source_compiles("
-      #include <GLES2/gl2.h>
-      #include <GLES2/gl2ext.h>
-      int main (int argc, char** argv) {}" HAVE_VIDEO_OPENGLES_V2)
-    if(HAVE_VIDEO_OPENGLES_V2)
-        set(HAVE_VIDEO_OPENGLES TRUE)
+        #include <GLES2/gl2.h>
+        #include <GLES2/gl2ext.h>
+        int main (int argc, char** argv) { return 0; }" HAVE_OPENGLES_V2)
+    if(HAVE_OPENGLES_V2)
+        set(HAVE_OPENGLES TRUE)
         set(SDL_VIDEO_OPENGL_ES2 1)
         set(SDL_VIDEO_RENDER_OGL_ES2 1)
     endif()
-
   endif()
 endmacro()
 
@@ -800,7 +881,7 @@ endmacro()
 # PTHREAD_CFLAGS
 # PTHREAD_LIBS
 macro(CheckPTHREAD)
-  if(PTHREADS)
+  if(SDL_THREADS AND SDL_PTHREADS)
     if(ANDROID)
       # the android libc provides built-in support for pthreads, so no
       # additional linking or compile flags are necessary
@@ -839,6 +920,9 @@ macro(CheckPTHREAD)
     elseif(HAIKU)
       set(PTHREAD_CFLAGS "-D_REENTRANT")
       set(PTHREAD_LDFLAGS "")
+    elseif(EMSCRIPTEN)
+      set(PTHREAD_CFLAGS "-D_REENTRANT -pthread")
+      set(PTHREAD_LDFLAGS "-pthread")
     else()
       set(PTHREAD_CFLAGS "-D_REENTRANT")
       set(PTHREAD_LDFLAGS "-lpthread")
@@ -847,17 +931,13 @@ macro(CheckPTHREAD)
     # Run some tests
     set(ORIG_CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
     set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${PTHREAD_CFLAGS} ${PTHREAD_LDFLAGS}")
-    if(CMAKE_CROSSCOMPILING)
-      set(HAVE_PTHREADS 1)
-    else()
-      check_c_source_runs("
-        #include <pthread.h>
-        int main(int argc, char** argv) {
-          pthread_attr_t type;
-          pthread_attr_init(&type);
-          return 0;
-        }" HAVE_PTHREADS)
-    endif()
+    check_c_source_compiles("
+      #include <pthread.h>
+      int main(int argc, char** argv) {
+        pthread_attr_t type;
+        pthread_attr_init(&type);
+        return 0;
+      }" HAVE_PTHREADS)
     if(HAVE_PTHREADS)
       set(SDL_THREAD_PTHREAD 1)
       list(APPEND EXTRA_CFLAGS ${PTHREAD_CFLAGS})
@@ -866,6 +946,7 @@ macro(CheckPTHREAD)
       list(APPEND SDL_LIBS ${PTHREAD_LDFLAGS})
 
       check_c_source_compiles("
+        #define _GNU_SOURCE 1
         #include <pthread.h>
         int main(int argc, char **argv) {
           pthread_mutexattr_t attr;
@@ -876,6 +957,7 @@ macro(CheckPTHREAD)
         set(SDL_THREAD_PTHREAD_RECURSIVE_MUTEX 1)
       else()
         check_c_source_compiles("
+            #define _GNU_SOURCE 1
             #include <pthread.h>
             int main(int argc, char **argv) {
               pthread_mutexattr_t attr;
@@ -887,7 +969,7 @@ macro(CheckPTHREAD)
         endif()
       endif()
 
-      if(PTHREADS_SEM)
+      if(SDL_PTHREADS_SEM)
         check_c_source_compiles("#include <pthread.h>
                                  #include <semaphore.h>
                                  int main(int argc, char **argv) { return 0; }" HAVE_PTHREADS_SEM)
@@ -905,7 +987,13 @@ macro(CheckPTHREAD)
       check_include_files("pthread.h" HAVE_PTHREAD_H)
       check_include_files("pthread_np.h" HAVE_PTHREAD_NP_H)
       if (HAVE_PTHREAD_H)
-        check_symbol_exists(pthread_setname_np "pthread.h" HAVE_PTHREAD_SETNAME_NP)
+        check_c_source_compiles("
+            #define _GNU_SOURCE 1
+            #include <pthread.h>
+            int main(int argc, char **argv) {
+              pthread_setname_np(pthread_self(), \"\");
+              return 0;
+            }" HAVE_PTHREAD_SETNAME_NP)
         if (HAVE_PTHREAD_NP_H)
           check_symbol_exists(pthread_set_name_np "pthread.h;pthread_np.h" HAVE_PTHREAD_SET_NAME_NP)
         endif()
@@ -1056,7 +1144,7 @@ macro(CheckUSBHID)
             return 0;
         }" HAVE_MACHINE_JOYSTICK)
     if(HAVE_MACHINE_JOYSTICK)
-      set(SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H 1)
+      set(SDL_HAVE_MACHINE_JOYSTICK_H 1)
     endif()
     set(SDL_JOYSTICK_USBHID 1)
     file(GLOB BSD_JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/bsd/*.c)
@@ -1070,48 +1158,57 @@ macro(CheckUSBHID)
   endif()
 endmacro()
 
-# Check for HIDAPI joystick drivers. This is currently a Unix thing, not Windows or macOS!
+# Check for HIDAPI support
 macro(CheckHIDAPI)
-  if(HIDAPI)
-    if(HIDAPI_SKIP_LIBUSB)
-      set(HAVE_HIDAPI TRUE)
-    else()
-      set(HAVE_HIDAPI FALSE)
-      pkg_check_modules(LIBUSB libusb-1.0)
-      if (LIBUSB_FOUND)
-        check_include_file(libusb.h HAVE_LIBUSB_H ${LIBUSB_CFLAGS})
-        if (HAVE_LIBUSB_H)
-          set(HAVE_HIDAPI TRUE)
+  set(HAVE_HIDAPI TRUE)
+  if(NOT HIDAPI_SKIP_LIBUSB)
+    set(HAVE_LIBUSB FALSE)
+    pkg_check_modules(LIBUSB libusb-1.0)
+    if (LIBUSB_FOUND)
+      check_include_file(libusb.h HAVE_LIBUSB_H ${LIBUSB_CFLAGS})
+      if(HAVE_LIBUSB_H)
+        set(HAVE_LIBUSB TRUE)
+        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${LIBUSB_CFLAGS}")
+        if(HIDAPI_ONLY_LIBUSB)
+          list(APPEND EXTRA_LIBS ${LIBUSB_LIBS})
+        elseif(OS2)
+          set(SDL_LIBUSB_DYNAMIC "\"usb100.dll\"")
+        else()
+          # libusb is loaded dynamically, so don't add it to EXTRA_LIBS
+          FindLibraryAndSONAME("usb-1.0")
+          set(SDL_LIBUSB_DYNAMIC "\"${USB_1.0_LIB_SONAME}\"")
         endif()
       endif()
     endif()
+    if(HIDAPI_ONLY_LIBUSB AND NOT HAVE_LIBUSB)
+      set(HAVE_HIDAPI FALSE)
+    endif()
+  endif()
 
-    if(HAVE_HIDAPI)
+  if(HAVE_HIDAPI)
+    if(ANDROID)
+      set(SOURCE_FILES ${SOURCE_FILES} ${SDL2_SOURCE_DIR}/src/hidapi/android/hid.cpp)
+    endif()
+    if(IOS OR TVOS)
+      set(SOURCE_FILES ${SOURCE_FILES} ${SDL2_SOURCE_DIR}/src/hidapi/ios/hid.m)
+      set(SDL_FRAMEWORK_COREBLUETOOTH 1)
+    endif()
+    set(HAVE_SDL_HIDAPI TRUE)
+
+    if(SDL_JOYSTICK AND SDL_HIDAPI_JOYSTICK)
       set(SDL_JOYSTICK_HIDAPI 1)
       set(HAVE_SDL_JOYSTICK TRUE)
-      file(GLOB HIDAPI_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/hidapi/*.c)
-      set(SOURCE_FILES ${SOURCE_FILES} ${HIDAPI_SOURCES})
-      set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${LIBUSB_CFLAGS} \"-I${SDL2_SOURCE_DIR}/src/hidapi/hidapi\"")
-      if(NOT HIDAPI_SKIP_LIBUSB)
-        if(HIDAPI_ONLY_LIBUSB)
-          set(SOURCE_FILES ${SOURCE_FILES} ${SDL2_SOURCE_DIR}/src/hidapi/libusb/hid.c)
-          list(APPEND EXTRA_LIBS ${LIBUSB_LIBS})
-        else()
-          set(SOURCE_FILES ${SOURCE_FILES} ${SDL2_SOURCE_DIR}/src/hidapi/SDL_hidapi.c)
-          # libusb is loaded dynamically, so don't add it to EXTRA_LIBS
-          FindLibraryAndSONAME("usb-1.0")
-          set(SDL_LIBUSB_DYNAMIC "\"${USB_LIB_SONAME}\"")
-        endif()
-      endif()
+      set(HAVE_HIDAPI_JOYSTICK TRUE)
+      file(GLOB HIDAPI_JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/hidapi/*.c)
+      set(SOURCE_FILES ${SOURCE_FILES} ${HIDAPI_JOYSTICK_SOURCES})
     endif()
   endif()
 endmacro()
 
-
 # Requires:
 # - n/a
 macro(CheckRPI)
-  if(VIDEO_RPI)
+  if(SDL_RPI)
     pkg_check_modules(VIDEO_RPI bcm_host brcmegl)
     if (NOT VIDEO_RPI_FOUND)
       set(VIDEO_RPI_INCLUDE_DIRS "/opt/vc/include" "/opt/vc/include/interface/vcos/pthreads" "/opt/vc/include/interface/vmcs_host/linux/" )
@@ -1127,59 +1224,60 @@ macro(CheckRPI)
     set(CMAKE_REQUIRED_LIBRARIES "${VIDEO_RPI_LIBRARIES}")
     check_c_source_compiles("
         #include <bcm_host.h>
-        int main(int argc, char **argv) {}" HAVE_VIDEO_RPI)
+        #include <EGL/eglplatform.h>
+        int main(int argc, char **argv) {
+          EGL_DISPMANX_WINDOW_T window;
+          bcm_host_init();
+        }" HAVE_RPI)
     set(CMAKE_REQUIRED_FLAGS "${ORIG_CMAKE_REQUIRED_FLAGS}")
     set(CMAKE_REQUIRED_LIBRARIES)
 
-    if(SDL_VIDEO AND HAVE_VIDEO_RPI)
+    if(SDL_VIDEO AND HAVE_RPI)
       set(HAVE_SDL_VIDEO TRUE)
       set(SDL_VIDEO_DRIVER_RPI 1)
       file(GLOB VIDEO_RPI_SOURCES ${SDL2_SOURCE_DIR}/src/video/raspberry/*.c)
       set(SOURCE_FILES ${SOURCE_FILES} ${VIDEO_RPI_SOURCES})
       list(APPEND EXTRA_LIBS ${VIDEO_RPI_LIBRARIES})
+      # !!! FIXME: shouldn't be using CMAKE_C_FLAGS, right?
       set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${VIDEO_RPI_INCLUDE_FLAGS} ${VIDEO_RPI_LIBRARY_FLAGS}")
       list(APPEND EXTRA_LDFLAGS ${VIDEO_RPI_LDFLAGS})
-    endif(SDL_VIDEO AND HAVE_VIDEO_RPI)
-  endif(VIDEO_RPI)
-endmacro(CheckRPI)
+    endif()
+  endif()
+endmacro()
 
 # Requires:
 # - EGL
 # - PkgCheckModules
 # Optional:
-# - KMSDRM_SHARED opt
-# - HAVE_DLOPEN opt
+# - SDL_KMSDRM_SHARED opt
+# - HAVE_SDL_LOADSO opt
 macro(CheckKMSDRM)
-  if(VIDEO_KMSDRM)
+  if(SDL_KMSDRM)
     pkg_check_modules(KMSDRM libdrm gbm egl)
-    if(KMSDRM_FOUND)
+    if(KMSDRM_FOUND AND HAVE_OPENGL_EGL)
       link_directories(
         ${KMSDRM_LIBRARY_DIRS}
       )
-      include_directories(
-        ${KMSDRM_INCLUDE_DIRS}
-      )
-      set(HAVE_VIDEO_KMSDRM TRUE)
+      target_include_directories(sdl-build-options INTERFACE "${KMSDRM_INCLUDE_DIRS}")
+      set(HAVE_KMSDRM TRUE)
       set(HAVE_SDL_VIDEO TRUE)
 
       file(GLOB KMSDRM_SOURCES ${SDL2_SOURCE_DIR}/src/video/kmsdrm/*.c)
-      file(GLOB KMSDRM_LEGACY_SOURCES ${SDL2_SOURCE_DIR}/src/video/kmsdrm_legacy/*.c)
-      set(SOURCE_FILES ${SOURCE_FILES} ${KMSDRM_SOURCES} ${KMSDRM_LEGACY_SOURCES})
+      set(SOURCE_FILES ${SOURCE_FILES} ${KMSDRM_SOURCES})
 
       list(APPEND EXTRA_CFLAGS ${KMSDRM_CFLAGS})
 
       set(SDL_VIDEO_DRIVER_KMSDRM 1)
 
-      if(KMSDRM_SHARED)
-        if(NOT HAVE_DLOPEN)
-          message_warn("You must have SDL_LoadObject() support for dynamic KMS/DRM loading")
-        else()
-          FindLibraryAndSONAME(drm)
-          FindLibraryAndSONAME(gbm)
-          set(SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC "\"${DRM_LIB_SONAME}\"")
-          set(SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC_GBM "\"${GBM_LIB_SONAME}\"")
-          set(HAVE_KMSDRM_SHARED TRUE)
-        endif()
+      if(SDL_KMSDRM_SHARED AND NOT HAVE_SDL_LOADSO)
+        message_warn("You must have SDL_LoadObject() support for dynamic KMS/DRM loading")
+      endif()
+      if(SDL_KMSDRM_SHARED AND HAVE_SDL_LOADSO)
+        FindLibraryAndSONAME(drm)
+        FindLibraryAndSONAME(gbm)
+        set(SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC "\"${DRM_LIB_SONAME}\"")
+        set(SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC_GBM "\"${GBM_LIB_SONAME}\"")
+        set(HAVE_KMSDRM_SHARED TRUE)
       else()
         set(EXTRA_LIBS ${KMSDRM_LIBRARIES} ${EXTRA_LIBS})
       endif()
diff --git a/Engine/lib/sdl/configure b/Engine/lib/sdl/configure
index cdb12bd02..df73ab0cb 100755
--- a/Engine/lib/sdl/configure
+++ b/Engine/lib/sdl/configure
@@ -592,7 +592,7 @@ PACKAGE_STRING=
 PACKAGE_BUGREPORT=
 PACKAGE_URL=
 
-ac_unique_file="README.txt"
+ac_unique_file="src/SDL.c"
 # Factoring default headers for most tests.
 ac_includes_default="\
 #include <stdio.h>
@@ -630,6 +630,7 @@ ac_includes_default="\
 #endif"
 
 ac_subst_vars='LTLIBOBJS
+WAYLAND_SCANNER_CODE_MODE
 WAYLAND_SCANNER
 EXTRA_LDFLAGS
 BUILD_LDFLAGS
@@ -647,7 +648,7 @@ ENABLE_STATIC_FALSE
 ENABLE_STATIC_TRUE
 ENABLE_SHARED_FALSE
 ENABLE_SHARED_TRUE
-PKG_CONFIG_LIBS_PRIV
+PKGCONFIG_LIBS_PRIV
 SDL_RLD_FLAGS
 SDL_STATIC_LIBS
 SDL_LIBS
@@ -677,6 +678,8 @@ FUSIONSOUND_CFLAGS
 ARTSCONFIG
 PULSEAUDIO_LIBS
 PULSEAUDIO_CFLAGS
+PIPEWIRE_LIBS
+PIPEWIRE_CFLAGS
 ESD_LIBS
 ESD_CFLAGS
 ESD_CONFIG
@@ -687,6 +690,8 @@ ALSA_CFLAGS
 POW_LIB
 LIBOBJS
 ALLOCA
+LIBTOOLLINKERTAG
+LINKER
 PKG_CONFIG_LIBDIR
 PKG_CONFIG_PATH
 PKG_CONFIG
@@ -704,6 +709,7 @@ LT_CURRENT
 LT_RELEASE
 RC
 CPP
+LT_SYS_LIBRARY_PATH
 OTOOL64
 OTOOL
 LIPO
@@ -794,6 +800,7 @@ enable_shared
 enable_static
 with_pic
 enable_fast_install
+with_aix_soname
 with_gnu_ld
 with_sysroot
 enable_libtool_lock
@@ -808,12 +815,15 @@ enable_render
 enable_events
 enable_joystick
 enable_haptic
+enable_hidapi
 enable_sensor
 enable_power
 enable_filesystem
 enable_threads
 enable_timers
 enable_file
+enable_misc
+enable_locale
 enable_loadso
 enable_cpuinfo
 enable_assembly
@@ -837,6 +847,8 @@ with_esd_prefix
 with_esd_exec_prefix
 enable_esdtest
 enable_esd_shared
+enable_pipewire
+enable_pipewire_shared
 enable_pulseaudio
 enable_pulseaudio_shared
 enable_arts
@@ -856,6 +868,8 @@ enable_arm_neon
 enable_video_wayland
 enable_video_wayland_qt_touch
 enable_wayland_shared
+enable_libdecor
+enable_libdecor_shared
 enable_video_rpi
 enable_video_x11
 with_x
@@ -864,6 +878,7 @@ enable_video_x11_xcursor
 enable_video_x11_xdbe
 enable_video_x11_xinerama
 enable_video_x11_xinput
+enable_video_x11_xfixes
 enable_video_x11_xrandr
 enable_video_x11_scrnsaver
 enable_video_x11_xshape
@@ -877,6 +892,7 @@ enable_directfb_shared
 enable_video_kmsdrm
 enable_kmsdrm_shared
 enable_video_dummy
+enable_video_offscreen
 enable_video_opengl
 enable_video_opengles
 enable_video_opengles1
@@ -891,9 +907,9 @@ enable_joystick_mfi
 enable_pthreads
 enable_pthread_sem
 enable_directx
+enable_xinput
 enable_wasapi
-enable_sdl_dlopen
-enable_hidapi
+enable_hidapi_joystick
 enable_hidapi_libusb
 enable_clock_gettime
 enable_rpath
@@ -911,6 +927,7 @@ CFLAGS
 LDFLAGS
 LIBS
 CPPFLAGS
+LT_SYS_LIBRARY_PATH
 CPP
 CXX
 CXXFLAGS
@@ -921,6 +938,8 @@ PKG_CONFIG_PATH
 PKG_CONFIG_LIBDIR
 JACK_CFLAGS
 JACK_LIBS
+PIPEWIRE_CFLAGS
+PIPEWIRE_LIBS
 PULSEAUDIO_CFLAGS
 PULSEAUDIO_LIBS
 FUSIONSOUND_CFLAGS
@@ -1562,138 +1581,152 @@ Optional Features:
   --disable-libtool-lock  avoid locking (might break parallel builds)
   --enable-assertions     Enable internal sanity checks
                           (auto/disabled/release/enabled/paranoid)
-                          [[default=auto]]
+                          [default=auto]
   --enable-dependency-tracking
-                          Use gcc -MMD -MT dependency tracking [[default=yes]]
-  --enable-libc           Use the system C library [[default=yes]]
-  --enable-gcc-atomics    Use gcc builtin atomics [[default=yes]]
-  --enable-atomic         Enable the atomic operations subsystem
-                          [[default=yes]]
-  --enable-audio          Enable the audio subsystem [[default=yes]]
-  --enable-video          Enable the video subsystem [[default=yes]]
-  --enable-render         Enable the render subsystem [[default=yes]]
-  --enable-events         Enable the events subsystem [[default=yes]]
-  --enable-joystick       Enable the joystick subsystem [[default=yes]]
+                          Use gcc -MMD -MT dependency tracking [default=yes]
+  --enable-libc           Use the system C library [default=yes]
+  --enable-gcc-atomics    Use gcc builtin atomics [default=yes]
+  --enable-atomic         Enable the atomic operations subsystem [default=yes]
+  --enable-audio          Enable the audio subsystem [default=yes]
+  --enable-video          Enable the video subsystem [default=yes]
+  --enable-render         Enable the render subsystem [default=yes]
+  --enable-events         Enable the events subsystem [default=yes]
+  --enable-joystick       Enable the joystick subsystem [default=yes]
   --enable-haptic         Enable the haptic (force feedback) subsystem
-                          [[default=yes]]
-  --enable-sensor         Enable the sensor subsystem [[default=yes]]
-  --enable-power          Enable the power subsystem [[default=yes]]
-  --enable-filesystem     Enable the filesystem subsystem [[default=yes]]
-  --enable-threads        Enable the threading subsystem [[default=yes]]
-  --enable-timers         Enable the timer subsystem [[default=yes]]
-  --enable-file           Enable the file subsystem [[default=yes]]
+                          [default=yes]
+  --enable-hidapi         Enable the HIDAPI subsystem [default=yes]
+  --enable-sensor         Enable the sensor subsystem [default=yes]
+  --enable-power          Enable the power subsystem [default=yes]
+  --enable-filesystem     Enable the filesystem subsystem [default=yes]
+  --enable-threads        Enable the threading subsystem [default=yes]
+  --enable-timers         Enable the timer subsystem [default=yes]
+  --enable-file           Enable the file subsystem [default=yes]
+  --enable-misc           Enable the misc subsystem [default=yes]
+  --enable-locale         Enable the locale subsystem [default=yes]
   --enable-loadso         Enable the shared object loading subsystem
-                          [[default=yes]]
-  --enable-cpuinfo        Enable the cpuinfo subsystem [[default=yes]]
-  --enable-assembly       Enable assembly routines [[default=yes]]
+                          [default=yes]
+  --enable-cpuinfo        Enable the cpuinfo subsystem [default=yes]
+  --enable-assembly       Enable assembly routines [default=yes]
   --enable-ssemath        Allow GCC to use SSE floating point math
-                          [[default=maybe]]
-  --enable-mmx            use MMX assembly routines [[default=yes]]
-  --enable-3dnow          use 3DNow! assembly routines [[default=yes]]
-  --enable-sse            use SSE assembly routines [[default=yes]]
-  --enable-sse2           use SSE2 assembly routines [[default=maybe]]
-  --enable-sse3           use SSE3 assembly routines [[default=maybe]]
-  --enable-altivec        use Altivec assembly routines [[default=yes]]
-  --enable-oss            support the OSS audio API [[default=maybe]]
-  --enable-alsa           support the ALSA audio API [[default=yes]]
+                          [default=maybe]
+  --enable-mmx            use MMX assembly routines [default=yes]
+  --enable-3dnow          use 3DNow! assembly routines [default=yes]
+  --enable-sse            use SSE assembly routines [default=yes]
+  --enable-sse2           use SSE2 assembly routines [default=maybe]
+  --enable-sse3           use SSE3 assembly routines [default=maybe]
+  --enable-altivec        use Altivec assembly routines [default=yes]
+  --enable-oss            support the OSS audio API [default=maybe]
+  --enable-alsa           support the ALSA audio API [default=yes]
   --disable-alsatest      Do not try to compile and run a test Alsa program
-  --enable-alsa-shared    dynamically load ALSA audio support [[default=yes]]
-  --enable-jack           use JACK audio [[default=yes]]
-  --enable-jack-shared    dynamically load JACK audio support [[default=yes]]
-  --enable-esd            support the Enlightened Sound Daemon [[default=yes]]
+  --enable-alsa-shared    dynamically load ALSA audio support [default=yes]
+  --enable-jack           use JACK audio [default=yes]
+  --enable-jack-shared    dynamically load JACK audio support [default=yes]
+  --enable-esd            support the Enlightened Sound Daemon [default=yes]
   --disable-esdtest       Do not try to compile and run a test ESD program
-  --enable-esd-shared     dynamically load ESD audio support [[default=yes]]
-  --enable-pulseaudio     use PulseAudio [[default=yes]]
+  --enable-esd-shared     dynamically load ESD audio support [default=yes]
+  --enable-pipewire       use Pipewire audio [default=yes]
+  --enable-pipewire-shared
+                          dynamically load Pipewire support [default=yes]
+  --enable-pulseaudio     use PulseAudio [default=yes]
   --enable-pulseaudio-shared
-                          dynamically load PulseAudio support [[default=yes]]
+                          dynamically load PulseAudio support [default=yes]
   --enable-arts           support the Analog Real Time Synthesizer
-                          [[default=yes]]
-  --enable-arts-shared    dynamically load aRts audio support [[default=yes]]
-  --enable-nas            support the NAS audio API [[default=yes]]
-  --enable-nas-shared     dynamically load NAS audio support [[default=yes]]
-  --enable-sndio          support the sndio audio API [[default=yes]]
-  --enable-sndio-shared   dynamically load sndio audio support [[default=yes]]
-  --enable-fusionsound    use FusionSound audio driver [[default=no]]
+                          [default=yes]
+  --enable-arts-shared    dynamically load aRts audio support [default=yes]
+  --enable-nas            support the NAS audio API [default=yes]
+  --enable-nas-shared     dynamically load NAS audio support [default=yes]
+  --enable-sndio          support the sndio audio API [default=yes]
+  --enable-sndio-shared   dynamically load sndio audio support [default=yes]
+  --enable-fusionsound    use FusionSound audio driver [default=no]
   --enable-fusionsound-shared
                           dynamically load fusionsound audio support
-                          [[default=yes]]
-  --enable-diskaudio      support the disk writer audio driver [[default=yes]]
-  --enable-dummyaudio     support the dummy audio driver [[default=yes]]
+                          [default=yes]
+  --enable-diskaudio      support the disk writer audio driver [default=yes]
+  --enable-dummyaudio     support the dummy audio driver [default=yes]
   --enable-libsamplerate  use libsamplerate for audio rate conversion
-                          [[default=yes]]
+                          [default=yes]
   --enable-libsamplerate-shared
-                          dynamically load libsamplerate [[default=yes]]
-  --enable-arm-simd       use SIMD assembly blitters on ARM [[default=no]]
-  --enable-arm-neon       use NEON assembly blitters on ARM [[default=no]]
-  --enable-video-wayland  use Wayland video driver [[default=yes]]
+                          dynamically load libsamplerate [default=yes]
+  --enable-arm-simd       use SIMD assembly blitters on ARM [default=no]
+  --enable-arm-neon       use NEON assembly blitters on ARM [default=no]
+  --enable-video-wayland  use Wayland video driver [default=yes]
   --enable-video-wayland-qt-touch
                           QtWayland server support for Wayland video driver
-                          [[default=yes]]
-  --enable-wayland-shared dynamically load Wayland support [[default=maybe]]
-  --enable-video-rpi      use Raspberry Pi video driver [[default=yes]]
-  --enable-video-x11      use X11 video driver [[default=yes]]
-  --enable-x11-shared     dynamically load X11 support [[default=maybe]]
+                          [default=yes]
+  --enable-wayland-shared dynamically load Wayland support [default=maybe]
+  --enable-libdecor       use libdecor for Wayland client-side decorations
+                          [default=yes]
+  --enable-libdecor-shared
+                          dynamically load libdecor [default=yes]
+  --enable-video-rpi      use Raspberry Pi 2/3 video driver [default=yes]
+  --enable-video-x11      use X11 video driver [default=yes]
+  --enable-x11-shared     dynamically load X11 support [default=maybe]
   --enable-video-x11-xcursor
-                          enable X11 Xcursor support [[default=yes]]
-  --enable-video-x11-xdbe enable X11 Xdbe support [[default=yes]]
+                          enable X11 Xcursor support [default=yes]
+  --enable-video-x11-xdbe enable X11 Xdbe support [default=yes]
   --enable-video-x11-xinerama
-                          enable X11 Xinerama support [[default=yes]]
+                          enable X11 Xinerama support [default=yes]
   --enable-video-x11-xinput
                           enable X11 XInput extension for manymouse, tablets,
-                          etc [[default=yes]]
+                          etc [default=yes]
+  --enable-video-x11-xfixes
+                          enable X11 Xfixes support [default=yes]
   --enable-video-x11-xrandr
                           enable X11 Xrandr extension for fullscreen
-                          [[default=yes]]
+                          [default=yes]
   --enable-video-x11-scrnsaver
-                          enable X11 screensaver extension [[default=yes]]
+                          enable X11 screensaver extension [default=yes]
   --enable-video-x11-xshape
-                          enable X11 XShape support [[default=yes]]
-  --enable-video-x11-vm   use X11 VM extension for fullscreen [[default=yes]]
-  --enable-video-vivante  use Vivante EGL video driver [[default=yes]]
-  --enable-video-cocoa    use Cocoa video driver [[default=yes]]
-  --enable-video-metal    include Metal support [[default=yes]]
-  --enable-render-metal   enable the Metal render driver [[default=yes]]
-  --enable-video-directfb use DirectFB video driver [[default=no]]
+                          enable X11 XShape support [default=yes]
+  --enable-video-x11-vm   use X11 VM extension for fullscreen [default=yes]
+  --enable-video-vivante  use Vivante EGL video driver [default=yes]
+  --enable-video-cocoa    use Cocoa video driver [default=yes]
+  --enable-video-metal    include Metal support [default=yes]
+  --enable-render-metal   enable the Metal render driver [default=yes]
+  --enable-video-directfb use DirectFB video driver [default=no]
   --enable-directfb-shared
-                          dynamically load directfb support [[default=yes]]
-  --enable-video-kmsdrm   use KMSDRM video driver [[default=no]]
-  --enable-kmsdrm-shared  dynamically load kmsdrm support [[default=yes]]
-  --enable-video-dummy    use dummy video driver [[default=yes]]
-  --enable-video-opengl   include OpenGL support [[default=yes]]
-  --enable-video-opengles include OpenGL ES support [[default=yes]]
+                          dynamically load directfb support [default=yes]
+  --enable-video-kmsdrm   use KMSDRM video driver [default=yes]
+  --enable-kmsdrm-shared  dynamically load kmsdrm support [default=yes]
+  --enable-video-dummy    use dummy video driver [default=yes]
+  --enable-video-offscreen
+                          use offscreen video driver [default=no]
+  --enable-video-opengl   include OpenGL support [default=yes]
+  --enable-video-opengles include OpenGL ES support [default=yes]
   --enable-video-opengles1
-                          include OpenGL ES 1.1 support [[default=yes]]
+                          include OpenGL ES 1.1 support [default=yes]
   --enable-video-opengles2
-                          include OpenGL ES 2.0 support [[default=yes]]
-  --enable-video-vulkan   include Vulkan support [[default=yes]]
-  --enable-libudev        enable libudev support [[default=yes]]
-  --enable-dbus           enable D-Bus support [[default=yes]]
-  --enable-ime            enable IME support [[default=yes]]
-  --enable-ibus           enable IBus support [[default=yes]]
-  --enable-fcitx          enable fcitx support [[default=yes]]
-  --enable-joystick-mfi   include macOS MFI joystick support [[default=yes]]
+                          include OpenGL ES 2.0 support [default=yes]
+  --enable-video-vulkan   include Vulkan support [default=yes]
+  --enable-libudev        enable libudev support [default=yes]
+  --enable-dbus           enable D-Bus support [default=yes]
+  --enable-ime            enable IME support [default=yes]
+  --enable-ibus           enable IBus support [default=yes]
+  --enable-fcitx          enable fcitx support [default=yes]
+  --enable-joystick-mfi   include macOS MFI joystick support [default=yes]
   --enable-pthreads       use POSIX threads for multi-threading
-                          [[default=yes]]
-  --enable-pthread-sem    use pthread semaphores [[default=yes]]
-  --enable-directx        use DirectX for Windows audio/video [[default=yes]]
-  --enable-wasapi         use the Windows WASAPI audio driver [[default=yes]]
-  --enable-sdl-dlopen     use dlopen for shared object loading [[default=yes]]
-  --enable-hidapi         use HIDAPI for low level joystick drivers
-                          [[default=yes]]
+                          [default=maybe]
+  --enable-pthread-sem    use pthread semaphores [default=maybe]
+  --enable-directx        use DirectX for Windows audio/video [default=yes]
+  --enable-xinput         use Xinput for Windows [default=yes]
+  --enable-wasapi         use the Windows WASAPI audio driver [default=yes]
+  --enable-hidapi-joystick
+                          use HIDAPI for low level joystick drivers
+                          [default=yes]
   --enable-hidapi-libusb  use libusb for low level joystick drivers
-                          [[default=maybe]]
+                          [default=maybe]
   --enable-clock_gettime  use clock_gettime() instead of gettimeofday() on
-                          UNIX [[default=yes]]
-  --enable-rpath          use an rpath when linking SDL [[default=yes]]
+                          UNIX [default=yes]
+  --enable-rpath          use an rpath when linking SDL [default=yes]
   --enable-backgrounding-signal
                           number to use for magic backgrounding signal or 'no'
-                          [[default=no]]
+                          [default=no]
   --enable-foregrounding-signal
                           number to use for magic foregrounding signal or 'no'
-                          [[default=no]]
+                          [default=no]
   --enable-joystick-virtual
-                          enable virtual joystick APIs [[default=yes]]
-  --enable-render-d3d     enable the Direct3D render driver [[default=yes]]
+                          enable virtual joystick APIs [default=yes]
+  --enable-render-d3d     enable the Direct3D render driver [default=yes]
   --enable-sdl2-config    Install sdl2-config [default=yes]
 
 Optional Packages:
@@ -1701,9 +1734,12 @@ Optional Packages:
   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
   --with-pic[=PKGS]       try to use only PIC/non-PIC objects [default=use
                           both]
+  --with-aix-soname=aix|svr4|both
+                          shared library versioning (aka "SONAME") variant to
+                          provide on AIX, [default=aix].
   --with-gnu-ld           assume the C compiler uses GNU ld [default=no]
-  --with-sysroot=DIR Search for dependent libraries within DIR
-                        (or the compiler's sysroot if not specified).
+  --with-sysroot[=DIR]    Search for dependent libraries within DIR (or the
+                          compiler's sysroot if not specified).
   --with-alsa-prefix=PFX  Prefix where Alsa library is installed(optional)
   --with-alsa-inc-prefix=PFX  Prefix where include libraries are (optional)
   --with-esd-prefix=PFX   Prefix where ESD is installed (optional)
@@ -1718,6 +1754,8 @@ Some influential environment variables:
   LIBS        libraries to pass to the linker, e.g. -l<library>
   CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
               you have headers in a nonstandard directory <include dir>
+  LT_SYS_LIBRARY_PATH
+              User-defined run-time library search path.
   CPP         C preprocessor
   CXX         C++ compiler command
   CXXFLAGS    C++ compiler flags
@@ -1729,6 +1767,10 @@ Some influential environment variables:
               path overriding pkg-config's built-in search path
   JACK_CFLAGS C compiler flags for JACK, overriding pkg-config
   JACK_LIBS   linker flags for JACK, overriding pkg-config
+  PIPEWIRE_CFLAGS
+              C compiler flags for PIPEWIRE, overriding pkg-config
+  PIPEWIRE_LIBS
+              linker flags for PIPEWIRE, overriding pkg-config
   PULSEAUDIO_CFLAGS
               C compiler flags for PULSEAUDIO, overriding pkg-config
   PULSEAUDIO_LIBS
@@ -2817,9 +2859,9 @@ orig_CFLAGS="$CFLAGS"
 #
 SDL_MAJOR_VERSION=2
 SDL_MINOR_VERSION=0
-SDL_MICRO_VERSION=14
-SDL_INTERFACE_AGE=0
-SDL_BINARY_AGE=14
+SDL_MICRO_VERSION=21
+SDL_INTERFACE_AGE=3
+SDL_BINARY_AGE=21
 SDL_VERSION=$SDL_MAJOR_VERSION.$SDL_MINOR_VERSION.$SDL_MICRO_VERSION
 
 
@@ -2838,8 +2880,8 @@ esac
 
 
 
-macro_version='2.4.2'
-macro_revision='1.3337'
+macro_version='2.4.6'
+macro_revision='2.4.6'
 
 
 
@@ -2853,7 +2895,7 @@ macro_revision='1.3337'
 
 
 
-ltmain="$ac_aux_dir/ltmain.sh"
+ltmain=$ac_aux_dir/ltmain.sh
 
 # Make sure we can run config.sub.
 $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
@@ -2973,7 +3015,7 @@ func_echo_all ()
     $ECHO ""
 }
 
-case "$ECHO" in
+case $ECHO in
   printf*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: printf" >&5
 $as_echo "printf" >&6; } ;;
   print*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: print -r" >&5
@@ -4085,19 +4127,19 @@ test -z "$GREP" && GREP=grep
 
 # Check whether --with-gnu-ld was given.
 if test "${with_gnu_ld+set}" = set; then :
-  withval=$with_gnu_ld; test "$withval" = no || with_gnu_ld=yes
+  withval=$with_gnu_ld; test no = "$withval" || with_gnu_ld=yes
 else
   with_gnu_ld=no
 fi
 
 ac_prog=ld
-if test "$GCC" = yes; then
+if test yes = "$GCC"; then
   # Check if gcc -print-prog-name=ld gives a path.
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5
 $as_echo_n "checking for ld used by $CC... " >&6; }
   case $host in
   *-*-mingw*)
-    # gcc leaves a trailing carriage return which upsets mingw
+    # gcc leaves a trailing carriage return, which upsets mingw
     ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
   *)
     ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
@@ -4111,7 +4153,7 @@ $as_echo_n "checking for ld used by $CC... " >&6; }
       while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do
 	ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"`
       done
-      test -z "$LD" && LD="$ac_prog"
+      test -z "$LD" && LD=$ac_prog
       ;;
   "")
     # If it fails, then pretend we aren't using GCC.
@@ -4122,7 +4164,7 @@ $as_echo_n "checking for ld used by $CC... " >&6; }
     with_gnu_ld=unknown
     ;;
   esac
-elif test "$with_gnu_ld" = yes; then
+elif test yes = "$with_gnu_ld"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5
 $as_echo_n "checking for GNU ld... " >&6; }
 else
@@ -4133,32 +4175,32 @@ if ${lt_cv_path_LD+:} false; then :
   $as_echo_n "(cached) " >&6
 else
   if test -z "$LD"; then
-  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+  lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
   for ac_dir in $PATH; do
-    IFS="$lt_save_ifs"
+    IFS=$lt_save_ifs
     test -z "$ac_dir" && ac_dir=.
     if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
-      lt_cv_path_LD="$ac_dir/$ac_prog"
+      lt_cv_path_LD=$ac_dir/$ac_prog
       # Check to see if the program is GNU ld.  I'd rather use --version,
       # but apparently some variants of GNU ld only accept -v.
       # Break only if it was the GNU/non-GNU ld that we prefer.
       case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
       *GNU* | *'with BFD'*)
-	test "$with_gnu_ld" != no && break
+	test no != "$with_gnu_ld" && break
 	;;
       *)
-	test "$with_gnu_ld" != yes && break
+	test yes != "$with_gnu_ld" && break
 	;;
       esac
     fi
   done
-  IFS="$lt_save_ifs"
+  IFS=$lt_save_ifs
 else
-  lt_cv_path_LD="$LD" # Let the user override the test with a path.
+  lt_cv_path_LD=$LD # Let the user override the test with a path.
 fi
 fi
 
-LD="$lt_cv_path_LD"
+LD=$lt_cv_path_LD
 if test -n "$LD"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LD" >&5
 $as_echo "$LD" >&6; }
@@ -4201,33 +4243,38 @@ if ${lt_cv_path_NM+:} false; then :
 else
   if test -n "$NM"; then
   # Let the user override the test.
-  lt_cv_path_NM="$NM"
+  lt_cv_path_NM=$NM
 else
-  lt_nm_to_check="${ac_tool_prefix}nm"
+  lt_nm_to_check=${ac_tool_prefix}nm
   if test -n "$ac_tool_prefix" && test "$build" = "$host"; then
     lt_nm_to_check="$lt_nm_to_check nm"
   fi
   for lt_tmp_nm in $lt_nm_to_check; do
-    lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+    lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
     for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do
-      IFS="$lt_save_ifs"
+      IFS=$lt_save_ifs
       test -z "$ac_dir" && ac_dir=.
-      tmp_nm="$ac_dir/$lt_tmp_nm"
-      if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then
+      tmp_nm=$ac_dir/$lt_tmp_nm
+      if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext"; then
 	# Check to see if the nm accepts a BSD-compat flag.
-	# Adding the `sed 1q' prevents false positives on HP-UX, which says:
+	# Adding the 'sed 1q' prevents false positives on HP-UX, which says:
 	#   nm: unknown option "B" ignored
 	# Tru64's nm complains that /dev/null is an invalid object file
-	case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in
-	*/dev/null* | *'Invalid file or object type'*)
+	# MSYS converts /dev/null to NUL, MinGW nm treats NUL as empty
+	case $build_os in
+	mingw*) lt_bad_file=conftest.nm/nofile ;;
+	*) lt_bad_file=/dev/null ;;
+	esac
+	case `"$tmp_nm" -B $lt_bad_file 2>&1 | sed '1q'` in
+	*$lt_bad_file* | *'Invalid file or object type'*)
 	  lt_cv_path_NM="$tmp_nm -B"
-	  break
+	  break 2
 	  ;;
 	*)
 	  case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in
 	  */dev/null*)
 	    lt_cv_path_NM="$tmp_nm -p"
-	    break
+	    break 2
 	    ;;
 	  *)
 	    lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
@@ -4238,15 +4285,15 @@ else
 	esac
       fi
     done
-    IFS="$lt_save_ifs"
+    IFS=$lt_save_ifs
   done
   : ${lt_cv_path_NM=no}
 fi
 fi
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5
 $as_echo "$lt_cv_path_NM" >&6; }
-if test "$lt_cv_path_NM" != "no"; then
-  NM="$lt_cv_path_NM"
+if test no != "$lt_cv_path_NM"; then
+  NM=$lt_cv_path_NM
 else
   # Didn't find any BSD compatible name lister, look for dumpbin.
   if test -n "$DUMPBIN"; then :
@@ -4352,9 +4399,9 @@ esac
   fi
 fi
 
-    case `$DUMPBIN -symbols /dev/null 2>&1 | sed '1q'` in
+    case `$DUMPBIN -symbols -headers /dev/null 2>&1 | sed '1q'` in
     *COFF*)
-      DUMPBIN="$DUMPBIN -symbols"
+      DUMPBIN="$DUMPBIN -symbols -headers"
       ;;
     *)
       DUMPBIN=:
@@ -4362,8 +4409,8 @@ fi
     esac
   fi
 
-  if test "$DUMPBIN" != ":"; then
-    NM="$DUMPBIN"
+  if test : != "$DUMPBIN"; then
+    NM=$DUMPBIN
   fi
 fi
 test -z "$NM" && NM=nm
@@ -4414,7 +4461,7 @@ if ${lt_cv_sys_max_cmd_len+:} false; then :
   $as_echo_n "(cached) " >&6
 else
     i=0
-  teststring="ABCD"
+  teststring=ABCD
 
   case $build_os in
   msdosdjgpp*)
@@ -4454,7 +4501,7 @@ else
     lt_cv_sys_max_cmd_len=8192;
     ;;
 
-  netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)
+  bitrig* | darwin* | dragonfly* | freebsd* | midnightbsd* | netbsd* | openbsd*)
     # This has been around since 386BSD, at least.  Likely further.
     if test -x /sbin/sysctl; then
       lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
@@ -4504,22 +4551,23 @@ else
     ;;
   *)
     lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null`
-    if test -n "$lt_cv_sys_max_cmd_len"; then
+    if test -n "$lt_cv_sys_max_cmd_len" && \
+       test undefined != "$lt_cv_sys_max_cmd_len"; then
       lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
       lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
     else
       # Make teststring a little bigger before we do anything with it.
       # a 1K string should be a reasonable start.
-      for i in 1 2 3 4 5 6 7 8 ; do
+      for i in 1 2 3 4 5 6 7 8; do
         teststring=$teststring$teststring
       done
       SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}
       # If test is not a shell built-in, we'll probably end up computing a
       # maximum length that is only half of the actual maximum length, but
       # we can't tell.
-      while { test "X"`env echo "$teststring$teststring" 2>/dev/null` \
+      while { test X`env echo "$teststring$teststring" 2>/dev/null` \
 	         = "X$teststring$teststring"; } >/dev/null 2>&1 &&
-	      test $i != 17 # 1/2 MB should be enough
+	      test 17 != "$i" # 1/2 MB should be enough
       do
         i=`expr $i + 1`
         teststring=$teststring$teststring
@@ -4537,7 +4585,7 @@ else
 
 fi
 
-if test -n $lt_cv_sys_max_cmd_len ; then
+if test -n "$lt_cv_sys_max_cmd_len"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sys_max_cmd_len" >&5
 $as_echo "$lt_cv_sys_max_cmd_len" >&6; }
 else
@@ -4555,30 +4603,6 @@ max_cmd_len=$lt_cv_sys_max_cmd_len
 : ${MV="mv -f"}
 : ${RM="rm -f"}
 
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the shell understands some XSI constructs" >&5
-$as_echo_n "checking whether the shell understands some XSI constructs... " >&6; }
-# Try some XSI features
-xsi_shell=no
-( _lt_dummy="a/b/c"
-  test "${_lt_dummy##*/},${_lt_dummy%/*},${_lt_dummy#??}"${_lt_dummy%"$_lt_dummy"}, \
-      = c,a/b,b/c, \
-    && eval 'test $(( 1 + 1 )) -eq 2 \
-    && test "${#_lt_dummy}" -eq 5' ) >/dev/null 2>&1 \
-  && xsi_shell=yes
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $xsi_shell" >&5
-$as_echo "$xsi_shell" >&6; }
-
-
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the shell understands \"+=\"" >&5
-$as_echo_n "checking whether the shell understands \"+=\"... " >&6; }
-lt_shell_append=no
-( foo=bar; set foo baz; eval "$1+=\$2" && test "$foo" = barbaz ) \
-    >/dev/null 2>&1 \
-  && lt_shell_append=yes
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_shell_append" >&5
-$as_echo "$lt_shell_append" >&6; }
-
-
 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
   lt_unset=unset
 else
@@ -4701,13 +4725,13 @@ esac
 reload_cmds='$LD$reload_flag -o $output$reload_objs'
 case $host_os in
   cygwin* | mingw* | pw32* | cegcc*)
-    if test "$GCC" != yes; then
+    if test yes != "$GCC"; then
       reload_cmds=false
     fi
     ;;
   darwin*)
-    if test "$GCC" = yes; then
-      reload_cmds='$LTCC $LTCFLAGS -nostdlib ${wl}-r -o $output$reload_objs'
+    if test yes = "$GCC"; then
+      reload_cmds='$LTCC $LTCFLAGS -nostdlib $wl-r -o $output$reload_objs'
     else
       reload_cmds='$LD$reload_flag -o $output$reload_objs'
     fi
@@ -4832,13 +4856,13 @@ lt_cv_deplibs_check_method='unknown'
 # Need to set the preceding variable on all platforms that support
 # interlibrary dependencies.
 # 'none' -- dependencies not supported.
-# `unknown' -- same as none, but documents that we really don't know.
+# 'unknown' -- same as none, but documents that we really don't know.
 # 'pass_all' -- all dependencies passed with no checks.
 # 'test_compile' -- check by making test program.
 # 'file_magic [[regex]]' -- check by looking for files in library path
-# which responds to the $file_magic_cmd with a given extended regex.
-# If you have `file' or equivalent on your system and you're not sure
-# whether `pass_all' will *always* work, you probably want this one.
+# that responds to the $file_magic_cmd with a given extended regex.
+# If you have 'file' or equivalent on your system and you're not sure
+# whether 'pass_all' will *always* work, you probably want this one.
 
 case $host_os in
 aix[4-9]*)
@@ -4859,15 +4883,14 @@ cygwin*)
   # func_win32_libid is a shell function defined in ltmain.sh
   lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
   lt_cv_file_magic_cmd='func_win32_libid'
-  lt_cv_deplibs_check_method=pass_all
+  lt_cv_deplibs_check_method=pass_all # SDL customization
   ;;
 
 mingw* | pw32*)
   # Base MSYS/MinGW do not provide the 'file' command needed by
   # func_win32_libid shell function, so use a weaker test based on 'objdump',
   # unless we find 'file', for example because we are cross-compiling.
-  # func_win32_libid assumes BSD nm, so disallow it if using MS dumpbin.
-  if ( test "$lt_cv_nm_interface" = "BSD nm" && file / ) >/dev/null 2>&1; then
+  if ( file / ) >/dev/null 2>&1; then
     lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
     lt_cv_file_magic_cmd='func_win32_libid'
   else
@@ -4875,7 +4898,7 @@ mingw* | pw32*)
     lt_cv_deplibs_check_method='file_magic file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)'
     lt_cv_file_magic_cmd='$OBJDUMP -f'
   fi
-  lt_cv_deplibs_check_method=pass_all
+  lt_cv_deplibs_check_method=pass_all # SDL customization
   ;;
 
 cegcc*)
@@ -4888,7 +4911,7 @@ darwin* | rhapsody*)
   lt_cv_deplibs_check_method=pass_all
   ;;
 
-freebsd* | dragonfly*)
+freebsd* | dragonfly* | midnightbsd*)
   if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
     case $host_cpu in
     i*86 )
@@ -4904,10 +4927,6 @@ freebsd* | dragonfly*)
   fi
   ;;
 
-gnu*)
-  lt_cv_deplibs_check_method=pass_all
-  ;;
-
 haiku*)
   lt_cv_deplibs_check_method=pass_all
   ;;
@@ -4946,7 +4965,7 @@ irix5* | irix6* | nonstopux*)
   ;;
 
 # This must be glibc/ELF.
-linux* | k*bsd*-gnu | kopensolaris*-gnu)
+linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
   lt_cv_deplibs_check_method=pass_all
   ;;
 
@@ -4968,8 +4987,8 @@ newos6*)
   lt_cv_deplibs_check_method=pass_all
   ;;
 
-openbsd*)
-  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+openbsd* | bitrig*)
+  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then
     lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|\.so|_pic\.a)$'
   else
     lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$'
@@ -5022,6 +5041,9 @@ sysv4 | sysv4.3*)
 tpf*)
   lt_cv_deplibs_check_method=pass_all
   ;;
+os2*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
 esac
 
 fi
@@ -5176,8 +5198,8 @@ else
 
 case $host_os in
 cygwin* | mingw* | pw32* | cegcc*)
-  # two different shell functions defined in ltmain.sh
-  # decide which to use based on capabilities of $DLLTOOL
+  # two different shell functions defined in ltmain.sh;
+  # decide which one to use based on capabilities of $DLLTOOL
   case `$DLLTOOL --help 2>&1` in
   *--identify-strict*)
     lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib
@@ -5189,7 +5211,7 @@ cygwin* | mingw* | pw32* | cegcc*)
   ;;
 *)
   # fallback: assume linklib IS sharedlib
-  lt_cv_sharedlib_from_linklib_cmd="$ECHO"
+  lt_cv_sharedlib_from_linklib_cmd=$ECHO
   ;;
 esac
 
@@ -5344,7 +5366,7 @@ if ac_fn_c_try_compile "$LINENO"; then :
   ac_status=$?
   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }
-      if test "$ac_status" -eq 0; then
+      if test 0 -eq "$ac_status"; then
 	# Ensure the archiver fails upon bogus file names.
 	rm -f conftest.$ac_objext libconftest.a
 	{ { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5
@@ -5352,7 +5374,7 @@ if ac_fn_c_try_compile "$LINENO"; then :
   ac_status=$?
   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }
-	if test "$ac_status" -ne 0; then
+	if test 0 -ne "$ac_status"; then
           lt_cv_ar_at_file=@
         fi
       fi
@@ -5365,7 +5387,7 @@ fi
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ar_at_file" >&5
 $as_echo "$lt_cv_ar_at_file" >&6; }
 
-if test "x$lt_cv_ar_at_file" = xno; then
+if test no = "$lt_cv_ar_at_file"; then
   archiver_list_spec=
 else
   archiver_list_spec=$lt_cv_ar_at_file
@@ -5582,7 +5604,7 @@ old_postuninstall_cmds=
 
 if test -n "$RANLIB"; then
   case $host_os in
-  openbsd*)
+  bitrig* | openbsd*)
     old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$tool_oldlib"
     ;;
   *)
@@ -5714,7 +5736,7 @@ cygwin* | mingw* | pw32* | cegcc*)
   symcode='[ABCDGISTW]'
   ;;
 hpux*)
-  if test "$host_cpu" = ia64; then
+  if test ia64 = "$host_cpu"; then
     symcode='[ABCDEGRST]'
   fi
   ;;
@@ -5725,7 +5747,7 @@ osf*)
   symcode='[BCDEGQRST]'
   ;;
 solaris*)
-  symcode='[BDRT]'
+  symcode='[BCDRT]'
   ;;
 sco3.2v5*)
   symcode='[DT]'
@@ -5747,14 +5769,44 @@ case `$NM -V 2>&1` in
   symcode='[ABCDGIRSTW]' ;;
 esac
 
+if test "$lt_cv_nm_interface" = "MS dumpbin"; then
+  # Gets list of data symbols to import.
+  lt_cv_sys_global_symbol_to_import="sed -n -e 's/^I .* \(.*\)$/\1/p'"
+  # Adjust the below global symbol transforms to fixup imported variables.
+  lt_cdecl_hook=" -e 's/^I .* \(.*\)$/extern __declspec(dllimport) char \1;/p'"
+  lt_c_name_hook=" -e 's/^I .* \(.*\)$/  {\"\1\", (void *) 0},/p'"
+  lt_c_name_lib_hook="\
+  -e 's/^I .* \(lib.*\)$/  {\"\1\", (void *) 0},/p'\
+  -e 's/^I .* \(.*\)$/  {\"lib\1\", (void *) 0},/p'"
+else
+  # Disable hooks by default.
+  lt_cv_sys_global_symbol_to_import=
+  lt_cdecl_hook=
+  lt_c_name_hook=
+  lt_c_name_lib_hook=
+fi
+
 # Transform an extracted symbol line into a proper C declaration.
 # Some systems (esp. on ia64) link data and code symbols differently,
 # so use this general approach.
-lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"
+lt_cv_sys_global_symbol_to_cdecl="sed -n"\
+$lt_cdecl_hook\
+" -e 's/^T .* \(.*\)$/extern int \1();/p'"\
+" -e 's/^$symcode$symcode* .* \(.*\)$/extern char \1;/p'"
 
 # Transform an extracted symbol line into symbol name and symbol address
-lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([^ ]*\)[ ]*$/  {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/  {\"\2\", (void *) \&\2},/p'"
-lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: \([^ ]*\)[ ]*$/  {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([^ ]*\) \(lib[^ ]*\)$/  {\"\2\", (void *) \&\2},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/  {\"lib\2\", (void *) \&\2},/p'"
+lt_cv_sys_global_symbol_to_c_name_address="sed -n"\
+$lt_c_name_hook\
+" -e 's/^: \(.*\) .*$/  {\"\1\", (void *) 0},/p'"\
+" -e 's/^$symcode$symcode* .* \(.*\)$/  {\"\1\", (void *) \&\1},/p'"
+
+# Transform an extracted symbol line into symbol name with lib prefix and
+# symbol address.
+lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n"\
+$lt_c_name_lib_hook\
+" -e 's/^: \(.*\) .*$/  {\"\1\", (void *) 0},/p'"\
+" -e 's/^$symcode$symcode* .* \(lib.*\)$/  {\"\1\", (void *) \&\1},/p'"\
+" -e 's/^$symcode$symcode* .* \(.*\)$/  {\"lib\1\", (void *) \&\1},/p'"
 
 # Handle CRLF in mingw tool chain
 opt_cr=
@@ -5772,21 +5824,24 @@ for ac_symprfx in "" "_"; do
 
   # Write the raw and C identifiers.
   if test "$lt_cv_nm_interface" = "MS dumpbin"; then
-    # Fake it for dumpbin and say T for any non-static function
-    # and D for any global variable.
+    # Fake it for dumpbin and say T for any non-static function,
+    # D for any global variable and I for any imported variable.
     # Also find C++ and __fastcall symbols from MSVC++,
     # which start with @ or ?.
     lt_cv_sys_global_symbol_pipe="$AWK '"\
 "     {last_section=section; section=\$ 3};"\
 "     /^COFF SYMBOL TABLE/{for(i in hide) delete hide[i]};"\
 "     /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\
+"     /^ *Symbol name *: /{split(\$ 0,sn,\":\"); si=substr(sn[2],2)};"\
+"     /^ *Type *: code/{print \"T\",si,substr(si,length(prfx))};"\
+"     /^ *Type *: data/{print \"I\",si,substr(si,length(prfx))};"\
 "     \$ 0!~/External *\|/{next};"\
 "     / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\
 "     {if(hide[section]) next};"\
-"     {f=0}; \$ 0~/\(\).*\|/{f=1}; {printf f ? \"T \" : \"D \"};"\
-"     {split(\$ 0, a, /\||\r/); split(a[2], s)};"\
-"     s[1]~/^[@?]/{print s[1], s[1]; next};"\
-"     s[1]~prfx {split(s[1],t,\"@\"); print t[1], substr(t[1],length(prfx))}"\
+"     {f=\"D\"}; \$ 0~/\(\).*\|/{f=\"T\"};"\
+"     {split(\$ 0,a,/\||\r/); split(a[2],s)};"\
+"     s[1]~/^[@?]/{print f,s[1],s[1]; next};"\
+"     s[1]~prfx {split(s[1],t,\"@\"); print f,t[1],substr(t[1],length(prfx))}"\
 "     ' prfx=^$ac_symprfx"
   else
     lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[	 ]\($symcode$symcode*\)[	 ][	 ]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"
@@ -5834,11 +5889,11 @@ _LT_EOF
 	if $GREP ' nm_test_func$' "$nlist" >/dev/null; then
 	  cat <<_LT_EOF > conftest.$ac_ext
 /* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
-#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
-/* DATA imports from DLLs on WIN32 con't be const, because runtime
+#if defined _WIN32 || defined __CYGWIN__ || defined _WIN32_WCE
+/* DATA imports from DLLs on WIN32 can't be const, because runtime
    relocations are performed -- see ld's documentation on pseudo-relocs.  */
 # define LT_DLSYM_CONST
-#elif defined(__osf__)
+#elif defined __osf__
 /* This system does not cope well with relocations in const data.  */
 # define LT_DLSYM_CONST
 #else
@@ -5864,7 +5919,7 @@ lt__PROGRAM__LTX_preloaded_symbols[] =
 {
   { "@PROGRAM@", (void *) 0 },
 _LT_EOF
-	  $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/  {\"\2\", (void *) \&\2},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext
+	  $SED "s/^$symcode$symcode* .* \(.*\)$/  {\"\1\", (void *) \&\1},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext
 	  cat <<\_LT_EOF >> conftest.$ac_ext
   {0, (void *) 0}
 };
@@ -5884,13 +5939,13 @@ _LT_EOF
 	  mv conftest.$ac_objext conftstm.$ac_objext
 	  lt_globsym_save_LIBS=$LIBS
 	  lt_globsym_save_CFLAGS=$CFLAGS
-	  LIBS="conftstm.$ac_objext"
+	  LIBS=conftstm.$ac_objext
 	  CFLAGS="$CFLAGS$lt_prog_compiler_no_builtin_flag"
 	  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
   (eval $ac_link) 2>&5
   ac_status=$?
   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } && test -s conftest${ac_exeext}; then
+  test $ac_status = 0; } && test -s conftest$ac_exeext; then
 	    pipe_works=yes
 	  fi
 	  LIBS=$lt_globsym_save_LIBS
@@ -5911,7 +5966,7 @@ _LT_EOF
   rm -rf conftest* conftst*
 
   # Do not use the global_symbol_pipe unless it works.
-  if test "$pipe_works" = yes; then
+  if test yes = "$pipe_works"; then
     break
   else
     lt_cv_sys_global_symbol_pipe=
@@ -5953,6 +6008,16 @@ fi
 
 
 
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -5976,9 +6041,9 @@ fi
 
 
 lt_sysroot=
-case ${with_sysroot} in #(
+case $with_sysroot in #(
  yes)
-   if test "$GCC" = yes; then
+   if test yes = "$GCC"; then
      lt_sysroot=`$CC --print-sysroot 2>/dev/null`
    fi
    ;; #(
@@ -5988,8 +6053,8 @@ case ${with_sysroot} in #(
  no|'')
    ;; #(
  *)
-   { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${with_sysroot}" >&5
-$as_echo "${with_sysroot}" >&6; }
+   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_sysroot" >&5
+$as_echo "$with_sysroot" >&6; }
    as_fn_error $? "The sysroot must be an absolute path." "$LINENO" 5
    ;;
 esac
@@ -6001,18 +6066,99 @@ $as_echo "${lt_sysroot:-no}" >&6; }
 
 
 
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a working dd" >&5
+$as_echo_n "checking for a working dd... " >&6; }
+if ${ac_cv_path_lt_DD+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  printf 0123456789abcdef0123456789abcdef >conftest.i
+cat conftest.i conftest.i >conftest2.i
+: ${lt_DD:=$DD}
+if test -z "$lt_DD"; then
+  ac_path_lt_DD_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in dd; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_lt_DD="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_lt_DD" || continue
+if "$ac_path_lt_DD" bs=32 count=1 <conftest2.i >conftest.out 2>/dev/null; then
+  cmp -s conftest.i conftest.out \
+  && ac_cv_path_lt_DD="$ac_path_lt_DD" ac_path_lt_DD_found=:
+fi
+      $ac_path_lt_DD_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_lt_DD"; then
+    :
+  fi
+else
+  ac_cv_path_lt_DD=$lt_DD
+fi
+
+rm -f conftest.i conftest2.i conftest.out
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_lt_DD" >&5
+$as_echo "$ac_cv_path_lt_DD" >&6; }
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to truncate binary pipes" >&5
+$as_echo_n "checking how to truncate binary pipes... " >&6; }
+if ${lt_cv_truncate_bin+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  printf 0123456789abcdef0123456789abcdef >conftest.i
+cat conftest.i conftest.i >conftest2.i
+lt_cv_truncate_bin=
+if "$ac_cv_path_lt_DD" bs=32 count=1 <conftest2.i >conftest.out 2>/dev/null; then
+  cmp -s conftest.i conftest.out \
+  && lt_cv_truncate_bin="$ac_cv_path_lt_DD bs=4096 count=1"
+fi
+rm -f conftest.i conftest2.i conftest.out
+test -z "$lt_cv_truncate_bin" && lt_cv_truncate_bin="$SED -e 4q"
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_truncate_bin" >&5
+$as_echo "$lt_cv_truncate_bin" >&6; }
+
+
+
+
+
+
+
+# Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
+func_cc_basename ()
+{
+    for cc_temp in $*""; do
+      case $cc_temp in
+        compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
+        distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
+        \-*) ;;
+        *) break;;
+      esac
+    done
+    func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
+}
+
 # Check whether --enable-libtool-lock was given.
 if test "${enable_libtool_lock+set}" = set; then :
   enableval=$enable_libtool_lock;
 fi
 
-test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes
+test no = "$enable_libtool_lock" || enable_libtool_lock=yes
 
 # Some flags need to be propagated to the compiler or linker for good
 # libtool support.
 case $host in
 ia64-*-hpux*)
-  # Find out which ABI we are using.
+  # Find out what ABI is being produced by ac_compile, and set mode
+  # options accordingly.
   echo 'int i;' > conftest.$ac_ext
   if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
   (eval $ac_compile) 2>&5
@@ -6021,24 +6167,25 @@ ia64-*-hpux*)
   test $ac_status = 0; }; then
     case `/usr/bin/file conftest.$ac_objext` in
       *ELF-32*)
-	HPUX_IA64_MODE="32"
+	HPUX_IA64_MODE=32
 	;;
       *ELF-64*)
-	HPUX_IA64_MODE="64"
+	HPUX_IA64_MODE=64
 	;;
     esac
   fi
   rm -rf conftest*
   ;;
 *-*-irix6*)
-  # Find out which ABI we are using.
+  # Find out what ABI is being produced by ac_compile, and set linker
+  # options accordingly.
   echo '#line '$LINENO' "configure"' > conftest.$ac_ext
   if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }; then
-    if test "$lt_cv_prog_gnu_ld" = yes; then
+    if test yes = "$lt_cv_prog_gnu_ld"; then
       case `/usr/bin/file conftest.$ac_objext` in
 	*32-bit*)
 	  LD="${LD-ld} -melf32bsmip"
@@ -6067,9 +6214,50 @@ ia64-*-hpux*)
   rm -rf conftest*
   ;;
 
-x86_64-*kfreebsd*-gnu|x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*| \
+mips64*-*linux*)
+  # Find out what ABI is being produced by ac_compile, and set linker
+  # options accordingly.
+  echo '#line '$LINENO' "configure"' > conftest.$ac_ext
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+    emul=elf
+    case `/usr/bin/file conftest.$ac_objext` in
+      *32-bit*)
+	emul="${emul}32"
+	;;
+      *64-bit*)
+	emul="${emul}64"
+	;;
+    esac
+    case `/usr/bin/file conftest.$ac_objext` in
+      *MSB*)
+	emul="${emul}btsmip"
+	;;
+      *LSB*)
+	emul="${emul}ltsmip"
+	;;
+    esac
+    case `/usr/bin/file conftest.$ac_objext` in
+      *N32*)
+	emul="${emul}n32"
+	;;
+    esac
+    LD="${LD-ld} -m $emul"
+  fi
+  rm -rf conftest*
+  ;;
+
+x86_64-*kfreebsd*-gnu|x86_64-*linux*|powerpc*-*linux*| \
 s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
-  # Find out which ABI we are using.
+  # Find out what ABI is being produced by ac_compile, and set linker
+  # options accordingly.  Note that the listed cases only cover the
+  # situations where additional linker options are needed (such as when
+  # doing 32-bit compilation for a host where ld defaults to 64-bit, or
+  # vice versa); the common cases where no linker options are needed do
+  # not appear in the list.
   echo 'int i;' > conftest.$ac_ext
   if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
   (eval $ac_compile) 2>&5
@@ -6083,9 +6271,19 @@ s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
 	    LD="${LD-ld} -m elf_i386_fbsd"
 	    ;;
 	  x86_64-*linux*)
-	    LD="${LD-ld} -m elf_i386"
+	    case `/usr/bin/file conftest.o` in
+	      *x86-64*)
+		LD="${LD-ld} -m elf32_x86_64"
+		;;
+	      *)
+		LD="${LD-ld} -m elf_i386"
+		;;
+	    esac
 	    ;;
-	  ppc64-*linux*|powerpc64-*linux*)
+	  powerpc64le-*linux*)
+	    LD="${LD-ld} -m elf32lppclinux"
+	    ;;
+	  powerpc64-*linux*)
 	    LD="${LD-ld} -m elf32ppclinux"
 	    ;;
 	  s390x-*linux*)
@@ -6104,10 +6302,10 @@ s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
 	  x86_64-*linux*)
 	    LD="${LD-ld} -m elf_x86_64"
 	    ;;
-	  powerpc64le-*linux*)
+	  powerpcle-*linux*|powerpc64le-*linux*)
 	    LD="${LD-ld} -m elf64lppc"
 	    ;;
-	  powerpc64-*linux*)
+	  powerpc-*linux*|powerpc64-*linux*)
 	    LD="${LD-ld} -m elf64ppc"
 	    ;;
 	  s390*-*linux*|s390*-*tpf*)
@@ -6125,7 +6323,7 @@ s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
 
 *-*-sco3.2v5*)
   # On SCO OpenServer 5, we need -belf to get full-featured binaries.
-  SAVE_CFLAGS="$CFLAGS"
+  SAVE_CFLAGS=$CFLAGS
   CFLAGS="$CFLAGS -belf"
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler needs -belf" >&5
 $as_echo_n "checking whether the C compiler needs -belf... " >&6; }
@@ -6165,13 +6363,14 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
 fi
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_cc_needs_belf" >&5
 $as_echo "$lt_cv_cc_needs_belf" >&6; }
-  if test x"$lt_cv_cc_needs_belf" != x"yes"; then
+  if test yes != "$lt_cv_cc_needs_belf"; then
     # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
-    CFLAGS="$SAVE_CFLAGS"
+    CFLAGS=$SAVE_CFLAGS
   fi
   ;;
 *-*solaris*)
-  # Find out which ABI we are using.
+  # Find out what ABI is being produced by ac_compile, and set linker
+  # options accordingly.
   echo 'int i;' > conftest.$ac_ext
   if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
   (eval $ac_compile) 2>&5
@@ -6183,7 +6382,7 @@ $as_echo "$lt_cv_cc_needs_belf" >&6; }
       case $lt_cv_prog_gnu_ld in
       yes*)
         case $host in
-        i?86-*-solaris*)
+        i?86-*-solaris*|x86_64-*-solaris*)
           LD="${LD-ld} -m elf_x86_64"
           ;;
         sparc*-*-solaris*)
@@ -6192,7 +6391,7 @@ $as_echo "$lt_cv_cc_needs_belf" >&6; }
         esac
         # GNU ld 2.21 introduced _sol2 emulations.  Use them if available.
         if ${LD-ld} -V | grep _sol2 >/dev/null 2>&1; then
-          LD="${LD-ld}_sol2"
+          LD=${LD-ld}_sol2
         fi
         ;;
       *)
@@ -6208,7 +6407,7 @@ $as_echo "$lt_cv_cc_needs_belf" >&6; }
   ;;
 esac
 
-need_locks="$enable_libtool_lock"
+need_locks=$enable_libtool_lock
 
 if test -n "$ac_tool_prefix"; then
   # Extract the first word of "${ac_tool_prefix}mt", so it can be a program name with args.
@@ -6319,7 +6518,7 @@ else
 fi
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_mainfest_tool" >&5
 $as_echo "$lt_cv_path_mainfest_tool" >&6; }
-if test "x$lt_cv_path_mainfest_tool" != xyes; then
+if test yes != "$lt_cv_path_mainfest_tool"; then
   MANIFEST_TOOL=:
 fi
 
@@ -6822,7 +7021,7 @@ if ${lt_cv_apple_cc_single_mod+:} false; then :
   $as_echo_n "(cached) " >&6
 else
   lt_cv_apple_cc_single_mod=no
-      if test -z "${LT_MULTI_MODULE}"; then
+      if test -z "$LT_MULTI_MODULE"; then
 	# By default we will add the -single_module flag. You can override
 	# by either setting the environment variable LT_MULTI_MODULE
 	# non-empty at configure time, or by adding -multi_module to the
@@ -6840,7 +7039,7 @@ else
 	  cat conftest.err >&5
 	# Otherwise, if the output was created with a 0 exit code from
 	# the compiler, it worked.
-	elif test -f libconftest.dylib && test $_lt_result -eq 0; then
+	elif test -f libconftest.dylib && test 0 = "$_lt_result"; then
 	  lt_cv_apple_cc_single_mod=yes
 	else
 	  cat conftest.err >&5
@@ -6879,7 +7078,7 @@ else
 fi
 rm -f core conftest.err conftest.$ac_objext \
     conftest$ac_exeext conftest.$ac_ext
-	LDFLAGS="$save_LDFLAGS"
+	LDFLAGS=$save_LDFLAGS
 
 fi
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_exported_symbols_list" >&5
@@ -6908,7 +7107,7 @@ _LT_EOF
       _lt_result=$?
       if test -s conftest.err && $GREP force_load conftest.err; then
 	cat conftest.err >&5
-      elif test -f conftest && test $_lt_result -eq 0 && $GREP forced_load conftest >/dev/null 2>&1 ; then
+      elif test -f conftest && test 0 = "$_lt_result" && $GREP forced_load conftest >/dev/null 2>&1; then
 	lt_cv_ld_force_load=yes
       else
 	cat conftest.err >&5
@@ -6921,32 +7120,27 @@ fi
 $as_echo "$lt_cv_ld_force_load" >&6; }
     case $host_os in
     rhapsody* | darwin1.[012])
-      _lt_dar_allow_undefined='${wl}-undefined ${wl}suppress' ;;
+      _lt_dar_allow_undefined='$wl-undefined ${wl}suppress' ;;
     darwin1.*)
-      _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;
-    darwin*) # darwin 5.x on
-      # if running on 10.5 or later, the deployment target defaults
-      # to the OS version, if on x86, and 10.4, the deployment
-      # target defaults to 10.4. Don't you love it?
-      case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in
-	10.0,*86*-darwin8*|10.0,*-darwin[91]*)
-	  _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;
-	10.[012]*)
-	  _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;
-	10.*)
-	  _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;
+      _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;;
+    darwin*)
+      case $MACOSX_DEPLOYMENT_TARGET,$host in
+        10.[012],*|,*powerpc*-darwin[5-8]*)
+          _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;;
+        *)
+          _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;;
       esac
     ;;
   esac
-    if test "$lt_cv_apple_cc_single_mod" = "yes"; then
+    if test yes = "$lt_cv_apple_cc_single_mod"; then
       _lt_dar_single_mod='$single_module'
     fi
-    if test "$lt_cv_ld_exported_symbols_list" = "yes"; then
-      _lt_dar_export_syms=' ${wl}-exported_symbols_list,$output_objdir/${libname}-symbols.expsym'
+    if test yes = "$lt_cv_ld_exported_symbols_list"; then
+      _lt_dar_export_syms=' $wl-exported_symbols_list,$output_objdir/$libname-symbols.expsym'
     else
-      _lt_dar_export_syms='~$NMEDIT -s $output_objdir/${libname}-symbols.expsym ${lib}'
+      _lt_dar_export_syms='~$NMEDIT -s $output_objdir/$libname-symbols.expsym $lib'
     fi
-    if test "$DSYMUTIL" != ":" && test "$lt_cv_ld_force_load" = "no"; then
+    if test : != "$DSYMUTIL" && test no = "$lt_cv_ld_force_load"; then
       _lt_dsymutil='~$DSYMUTIL $lib || :'
     else
       _lt_dsymutil=
@@ -6954,6 +7148,41 @@ $as_echo "$lt_cv_ld_force_load" >&6; }
     ;;
   esac
 
+# func_munge_path_list VARIABLE PATH
+# -----------------------------------
+# VARIABLE is name of variable containing _space_ separated list of
+# directories to be munged by the contents of PATH, which is string
+# having a format:
+# "DIR[:DIR]:"
+#       string "DIR[ DIR]" will be prepended to VARIABLE
+# ":DIR[:DIR]"
+#       string "DIR[ DIR]" will be appended to VARIABLE
+# "DIRP[:DIRP]::[DIRA:]DIRA"
+#       string "DIRP[ DIRP]" will be prepended to VARIABLE and string
+#       "DIRA[ DIRA]" will be appended to VARIABLE
+# "DIR[:DIR]"
+#       VARIABLE will be replaced by "DIR[ DIR]"
+func_munge_path_list ()
+{
+    case x$2 in
+    x)
+        ;;
+    *:)
+        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\"
+        ;;
+    x:*)
+        eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\"
+        ;;
+    *::*)
+        eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
+        eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
+        ;;
+    *)
+        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\"
+        ;;
+    esac
+}
+
 ac_ext=c
 ac_cpp='$CPP $CPPFLAGS'
 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
@@ -7555,14 +7784,14 @@ if test "${enable_shared+set}" = set; then :
     *)
       enable_shared=no
       # Look at the argument we got.  We use all the common list separators.
-      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
       for pkg in $enableval; do
-	IFS="$lt_save_ifs"
+	IFS=$lt_save_ifs
 	if test "X$pkg" = "X$p"; then
 	  enable_shared=yes
 	fi
       done
-      IFS="$lt_save_ifs"
+      IFS=$lt_save_ifs
       ;;
     esac
 else
@@ -7586,14 +7815,14 @@ if test "${enable_static+set}" = set; then :
     *)
      enable_static=no
       # Look at the argument we got.  We use all the common list separators.
-      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
       for pkg in $enableval; do
-	IFS="$lt_save_ifs"
+	IFS=$lt_save_ifs
 	if test "X$pkg" = "X$p"; then
 	  enable_static=yes
 	fi
       done
-      IFS="$lt_save_ifs"
+      IFS=$lt_save_ifs
       ;;
     esac
 else
@@ -7617,14 +7846,14 @@ if test "${with_pic+set}" = set; then :
     *)
       pic_mode=default
       # Look at the argument we got.  We use all the common list separators.
-      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
       for lt_pkg in $withval; do
-	IFS="$lt_save_ifs"
+	IFS=$lt_save_ifs
 	if test "X$lt_pkg" = "X$lt_p"; then
 	  pic_mode=yes
 	fi
       done
-      IFS="$lt_save_ifs"
+      IFS=$lt_save_ifs
       ;;
     esac
 else
@@ -7632,8 +7861,6 @@ else
 fi
 
 
-test -z "$pic_mode" && pic_mode=default
-
 
 
 
@@ -7649,14 +7876,14 @@ if test "${enable_fast_install+set}" = set; then :
     *)
       enable_fast_install=no
       # Look at the argument we got.  We use all the common list separators.
-      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
       for pkg in $enableval; do
-	IFS="$lt_save_ifs"
+	IFS=$lt_save_ifs
 	if test "X$pkg" = "X$p"; then
 	  enable_fast_install=yes
 	fi
       done
-      IFS="$lt_save_ifs"
+      IFS=$lt_save_ifs
       ;;
     esac
 else
@@ -7670,11 +7897,63 @@ fi
 
 
 
+  shared_archive_member_spec=
+case $host,$enable_shared in
+power*-*-aix[5-9]*,yes)
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of shared library versioning to provide" >&5
+$as_echo_n "checking which variant of shared library versioning to provide... " >&6; }
+
+# Check whether --with-aix-soname was given.
+if test "${with_aix_soname+set}" = set; then :
+  withval=$with_aix_soname; case $withval in
+    aix|svr4|both)
+      ;;
+    *)
+      as_fn_error $? "Unknown argument to --with-aix-soname" "$LINENO" 5
+      ;;
+    esac
+    lt_cv_with_aix_soname=$with_aix_soname
+else
+  if ${lt_cv_with_aix_soname+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_with_aix_soname=aix
+fi
+
+    with_aix_soname=$lt_cv_with_aix_soname
+fi
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_aix_soname" >&5
+$as_echo "$with_aix_soname" >&6; }
+  if test aix != "$with_aix_soname"; then
+    # For the AIX way of multilib, we name the shared archive member
+    # based on the bitwidth used, traditionally 'shr.o' or 'shr_64.o',
+    # and 'shr.imp' or 'shr_64.imp', respectively, for the Import File.
+    # Even when GNU compilers ignore OBJECT_MODE but need '-maix64' flag,
+    # the AIX toolchain works better with OBJECT_MODE set (default 32).
+    if test 64 = "${OBJECT_MODE-32}"; then
+      shared_archive_member_spec=shr_64
+    else
+      shared_archive_member_spec=shr
+    fi
+  fi
+  ;;
+*)
+  with_aix_soname=aix
+  ;;
+esac
+
+
+
+
+
+
+
 
 
 
 # This can be used to rebuild libtool when needed
-LIBTOOL_DEPS="$ltmain"
+LIBTOOL_DEPS=$ltmain
 
 # Always use our own libtool.
 LIBTOOL='$(SHELL) $(top_builddir)/libtool'
@@ -7723,7 +8002,7 @@ test -z "$LN_S" && LN_S="ln -s"
 
 
 
-if test -n "${ZSH_VERSION+set}" ; then
+if test -n "${ZSH_VERSION+set}"; then
    setopt NO_GLOB_SUBST
 fi
 
@@ -7762,7 +8041,7 @@ aix3*)
   # AIX sometimes has problems with the GCC collect2 program.  For some
   # reason, if we set the COLLECT_NAMES environment variable, the problems
   # vanish in a puff of smoke.
-  if test "X${COLLECT_NAMES+set}" != Xset; then
+  if test set != "${COLLECT_NAMES+set}"; then
     COLLECT_NAMES=
     export COLLECT_NAMES
   fi
@@ -7773,14 +8052,14 @@ esac
 ofile=libtool
 can_build_shared=yes
 
-# All known linkers require a `.a' archive for static linking (except MSVC,
+# All known linkers require a '.a' archive for static linking (except MSVC,
 # which needs '.lib').
 libext=a
 
-with_gnu_ld="$lt_cv_prog_gnu_ld"
+with_gnu_ld=$lt_cv_prog_gnu_ld
 
-old_CC="$CC"
-old_CFLAGS="$CFLAGS"
+old_CC=$CC
+old_CFLAGS=$CFLAGS
 
 # Set sane defaults for various variables
 test -z "$CC" && CC=cc
@@ -7789,15 +8068,8 @@ test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS
 test -z "$LD" && LD=ld
 test -z "$ac_objext" && ac_objext=o
 
-for cc_temp in $compiler""; do
-  case $cc_temp in
-    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
-    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
-    \-*) ;;
-    *) break;;
-  esac
-done
-cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
+func_cc_basename $compiler
+cc_basename=$func_cc_basename_result
 
 
 # Only perform the check for file, if the check method requires it
@@ -7812,22 +8084,22 @@ if ${lt_cv_path_MAGIC_CMD+:} false; then :
 else
   case $MAGIC_CMD in
 [\\/*] |  ?:[\\/]*)
-  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
+  lt_cv_path_MAGIC_CMD=$MAGIC_CMD # Let the user override the test with a path.
   ;;
 *)
-  lt_save_MAGIC_CMD="$MAGIC_CMD"
-  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+  lt_save_MAGIC_CMD=$MAGIC_CMD
+  lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
   ac_dummy="/usr/bin$PATH_SEPARATOR$PATH"
   for ac_dir in $ac_dummy; do
-    IFS="$lt_save_ifs"
+    IFS=$lt_save_ifs
     test -z "$ac_dir" && ac_dir=.
-    if test -f $ac_dir/${ac_tool_prefix}file; then
-      lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file"
+    if test -f "$ac_dir/${ac_tool_prefix}file"; then
+      lt_cv_path_MAGIC_CMD=$ac_dir/"${ac_tool_prefix}file"
       if test -n "$file_magic_test_file"; then
 	case $deplibs_check_method in
 	"file_magic "*)
 	  file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
-	  MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+	  MAGIC_CMD=$lt_cv_path_MAGIC_CMD
 	  if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
 	    $EGREP "$file_magic_regex" > /dev/null; then
 	    :
@@ -7850,13 +8122,13 @@ _LT_EOF
       break
     fi
   done
-  IFS="$lt_save_ifs"
-  MAGIC_CMD="$lt_save_MAGIC_CMD"
+  IFS=$lt_save_ifs
+  MAGIC_CMD=$lt_save_MAGIC_CMD
   ;;
 esac
 fi
 
-MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+MAGIC_CMD=$lt_cv_path_MAGIC_CMD
 if test -n "$MAGIC_CMD"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5
 $as_echo "$MAGIC_CMD" >&6; }
@@ -7878,22 +8150,22 @@ if ${lt_cv_path_MAGIC_CMD+:} false; then :
 else
   case $MAGIC_CMD in
 [\\/*] |  ?:[\\/]*)
-  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
+  lt_cv_path_MAGIC_CMD=$MAGIC_CMD # Let the user override the test with a path.
   ;;
 *)
-  lt_save_MAGIC_CMD="$MAGIC_CMD"
-  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+  lt_save_MAGIC_CMD=$MAGIC_CMD
+  lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
   ac_dummy="/usr/bin$PATH_SEPARATOR$PATH"
   for ac_dir in $ac_dummy; do
-    IFS="$lt_save_ifs"
+    IFS=$lt_save_ifs
     test -z "$ac_dir" && ac_dir=.
-    if test -f $ac_dir/file; then
-      lt_cv_path_MAGIC_CMD="$ac_dir/file"
+    if test -f "$ac_dir/file"; then
+      lt_cv_path_MAGIC_CMD=$ac_dir/"file"
       if test -n "$file_magic_test_file"; then
 	case $deplibs_check_method in
 	"file_magic "*)
 	  file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
-	  MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+	  MAGIC_CMD=$lt_cv_path_MAGIC_CMD
 	  if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
 	    $EGREP "$file_magic_regex" > /dev/null; then
 	    :
@@ -7916,13 +8188,13 @@ _LT_EOF
       break
     fi
   done
-  IFS="$lt_save_ifs"
-  MAGIC_CMD="$lt_save_MAGIC_CMD"
+  IFS=$lt_save_ifs
+  MAGIC_CMD=$lt_save_MAGIC_CMD
   ;;
 esac
 fi
 
-MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+MAGIC_CMD=$lt_cv_path_MAGIC_CMD
 if test -n "$MAGIC_CMD"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5
 $as_echo "$MAGIC_CMD" >&6; }
@@ -7943,7 +8215,7 @@ esac
 
 # Use C for the default configuration in the libtool script
 
-lt_save_CC="$CC"
+lt_save_CC=$CC
 ac_ext=c
 ac_cpp='$CPP $CPPFLAGS'
 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
@@ -8005,7 +8277,7 @@ if test -n "$compiler"; then
 
 lt_prog_compiler_no_builtin_flag=
 
-if test "$GCC" = yes; then
+if test yes = "$GCC"; then
   case $cc_basename in
   nvcc*)
     lt_prog_compiler_no_builtin_flag=' -Xcompiler -fno-builtin' ;;
@@ -8021,7 +8293,7 @@ else
   lt_cv_prog_compiler_rtti_exceptions=no
    ac_outfile=conftest.$ac_objext
    echo "$lt_simple_compile_test_code" > conftest.$ac_ext
-   lt_compiler_flag="-fno-rtti -fno-exceptions"
+   lt_compiler_flag="-fno-rtti -fno-exceptions"  ## exclude from sc_useless_quotes_in_assignment
    # Insert the option either (1) after the last *FLAGS variable, or
    # (2) before a word containing "conftest.", or (3) at the end.
    # Note that $ac_compile itself does not contain backslashes and begins
@@ -8051,7 +8323,7 @@ fi
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_rtti_exceptions" >&5
 $as_echo "$lt_cv_prog_compiler_rtti_exceptions" >&6; }
 
-if test x"$lt_cv_prog_compiler_rtti_exceptions" = xyes; then
+if test yes = "$lt_cv_prog_compiler_rtti_exceptions"; then
     lt_prog_compiler_no_builtin_flag="$lt_prog_compiler_no_builtin_flag -fno-rtti -fno-exceptions"
 else
     :
@@ -8069,17 +8341,18 @@ lt_prog_compiler_pic=
 lt_prog_compiler_static=
 
 
-  if test "$GCC" = yes; then
+  if test yes = "$GCC"; then
     lt_prog_compiler_wl='-Wl,'
     lt_prog_compiler_static='-static'
 
     case $host_os in
       aix*)
       # All AIX code is PIC.
-      if test "$host_cpu" = ia64; then
+      if test ia64 = "$host_cpu"; then
 	# AIX 5 now supports IA64 processor
 	lt_prog_compiler_static='-Bstatic'
       fi
+      lt_prog_compiler_pic='-fPIC'
       ;;
 
     amigaos*)
@@ -8090,8 +8363,8 @@ lt_prog_compiler_static=
         ;;
       m68k)
             # FIXME: we need at least 68020 code to build shared libraries, but
-            # adding the `-m68020' flag to GCC prevents building anything better,
-            # like `-m68040'.
+            # adding the '-m68020' flag to GCC prevents building anything better,
+            # like '-m68040'.
             lt_prog_compiler_pic='-m68020 -resident32 -malways-restore-a4'
         ;;
       esac
@@ -8107,6 +8380,11 @@ lt_prog_compiler_static=
       # Although the cygwin gcc ignores -fPIC, still need this for old-style
       # (--disable-auto-import) libraries
       lt_prog_compiler_pic='-DDLL_EXPORT'
+      case $host_os in
+      os2*)
+	lt_prog_compiler_static='$wl-static'
+	;;
+      esac
       ;;
 
     darwin* | rhapsody*)
@@ -8177,7 +8455,7 @@ lt_prog_compiler_static=
     case $host_os in
     aix*)
       lt_prog_compiler_wl='-Wl,'
-      if test "$host_cpu" = ia64; then
+      if test ia64 = "$host_cpu"; then
 	# AIX 5 now supports IA64 processor
 	lt_prog_compiler_static='-Bstatic'
       else
@@ -8185,10 +8463,29 @@ lt_prog_compiler_static=
       fi
       ;;
 
+    darwin* | rhapsody*)
+      # PIC is the default on this platform
+      # Common symbols not allowed in MH_DYLIB files
+      lt_prog_compiler_pic='-fno-common'
+      case $cc_basename in
+      nagfor*)
+        # NAG Fortran compiler
+        lt_prog_compiler_wl='-Wl,-Wl,,'
+        lt_prog_compiler_pic='-PIC'
+        lt_prog_compiler_static='-Bstatic'
+        ;;
+      esac
+      ;;
+
     mingw* | cygwin* | pw32* | os2* | cegcc*)
       # This hack is so that the source file can tell whether it is being
       # built for inclusion in a dll (and should export symbols for example).
       lt_prog_compiler_pic='-DDLL_EXPORT'
+      case $host_os in
+      os2*)
+	lt_prog_compiler_static='$wl-static'
+	;;
+      esac
       ;;
 
     hpux9* | hpux10* | hpux11*)
@@ -8204,7 +8501,7 @@ lt_prog_compiler_static=
 	;;
       esac
       # Is there a better lt_prog_compiler_static that works with the bundled CC?
-      lt_prog_compiler_static='${wl}-a ${wl}archive'
+      lt_prog_compiler_static='$wl-a ${wl}archive'
       ;;
 
     irix5* | irix6* | nonstopux*)
@@ -8213,9 +8510,9 @@ lt_prog_compiler_static=
       lt_prog_compiler_static='-non_shared'
       ;;
 
-    linux* | k*bsd*-gnu | kopensolaris*-gnu)
+    linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
       case $cc_basename in
-      # old Intel for x86_64 which still supported -KPIC.
+      # old Intel for x86_64, which still supported -KPIC.
       ecc*)
 	lt_prog_compiler_wl='-Wl,'
 	lt_prog_compiler_pic='-KPIC'
@@ -8240,6 +8537,12 @@ lt_prog_compiler_static=
 	lt_prog_compiler_pic='-PIC'
 	lt_prog_compiler_static='-Bstatic'
 	;;
+      tcc*)
+	# Fabrice Bellard et al's Tiny C Compiler
+	lt_prog_compiler_wl='-Wl,'
+	lt_prog_compiler_pic='-fPIC'
+	lt_prog_compiler_static='-static'
+	;;
       pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*)
         # Portland Group compilers (*not* the Pentium gcc compiler,
 	# which looks to be a dead project)
@@ -8337,7 +8640,7 @@ lt_prog_compiler_static=
       ;;
 
     sysv4*MP*)
-      if test -d /usr/nec ;then
+      if test -d /usr/nec; then
 	lt_prog_compiler_pic='-Kconform_pic'
 	lt_prog_compiler_static='-Bstatic'
       fi
@@ -8366,7 +8669,7 @@ lt_prog_compiler_static=
   fi
 
 case $host_os in
-  # For platforms which do not support PIC, -DPIC is meaningless:
+  # For platforms that do not support PIC, -DPIC is meaningless:
   *djgpp*)
     lt_prog_compiler_pic=
     ;;
@@ -8398,7 +8701,7 @@ else
   lt_cv_prog_compiler_pic_works=no
    ac_outfile=conftest.$ac_objext
    echo "$lt_simple_compile_test_code" > conftest.$ac_ext
-   lt_compiler_flag="$lt_prog_compiler_pic -DPIC"
+   lt_compiler_flag="$lt_prog_compiler_pic -DPIC"  ## exclude from sc_useless_quotes_in_assignment
    # Insert the option either (1) after the last *FLAGS variable, or
    # (2) before a word containing "conftest.", or (3) at the end.
    # Note that $ac_compile itself does not contain backslashes and begins
@@ -8428,7 +8731,7 @@ fi
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works" >&5
 $as_echo "$lt_cv_prog_compiler_pic_works" >&6; }
 
-if test x"$lt_cv_prog_compiler_pic_works" = xyes; then
+if test yes = "$lt_cv_prog_compiler_pic_works"; then
     case $lt_prog_compiler_pic in
      "" | " "*) ;;
      *) lt_prog_compiler_pic=" $lt_prog_compiler_pic" ;;
@@ -8460,7 +8763,7 @@ if ${lt_cv_prog_compiler_static_works+:} false; then :
   $as_echo_n "(cached) " >&6
 else
   lt_cv_prog_compiler_static_works=no
-   save_LDFLAGS="$LDFLAGS"
+   save_LDFLAGS=$LDFLAGS
    LDFLAGS="$LDFLAGS $lt_tmp_static_flag"
    echo "$lt_simple_link_test_code" > conftest.$ac_ext
    if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
@@ -8479,13 +8782,13 @@ else
      fi
    fi
    $RM -r conftest*
-   LDFLAGS="$save_LDFLAGS"
+   LDFLAGS=$save_LDFLAGS
 
 fi
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works" >&5
 $as_echo "$lt_cv_prog_compiler_static_works" >&6; }
 
-if test x"$lt_cv_prog_compiler_static_works" = xyes; then
+if test yes = "$lt_cv_prog_compiler_static_works"; then
     :
 else
     lt_prog_compiler_static=
@@ -8605,8 +8908,8 @@ $as_echo "$lt_cv_prog_compiler_c_o" >&6; }
 
 
 
-hard_links="nottested"
-if test "$lt_cv_prog_compiler_c_o" = no && test "$need_locks" != no; then
+hard_links=nottested
+if test no = "$lt_cv_prog_compiler_c_o" && test no != "$need_locks"; then
   # do not overwrite the value of need_locks provided by the user
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5
 $as_echo_n "checking if we can lock with hard links... " >&6; }
@@ -8618,9 +8921,9 @@ $as_echo_n "checking if we can lock with hard links... " >&6; }
   ln conftest.a conftest.b 2>/dev/null && hard_links=no
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5
 $as_echo "$hard_links" >&6; }
-  if test "$hard_links" = no; then
-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5
-$as_echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;}
+  if test no = "$hard_links"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&5
+$as_echo "$as_me: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&2;}
     need_locks=warn
   fi
 else
@@ -8663,9 +8966,9 @@ $as_echo_n "checking whether the $compiler linker ($LD) supports shared librarie
   # included in the symbol list
   include_expsyms=
   # exclude_expsyms can be an extended regexp of symbols to exclude
-  # it will be wrapped by ` (' and `)$', so one must not match beginning or
-  # end of line.  Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc',
-  # as well as any symbol that contains `d'.
+  # it will be wrapped by ' (' and ')$', so one must not match beginning or
+  # end of line.  Example: 'a|bc|.*d.*' will exclude the symbols 'a' and 'bc',
+  # as well as any symbol that contains 'd'.
   exclude_expsyms='_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*'
   # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out
   # platforms (ab)use it in PIC code, but their linkers get confused if
@@ -8680,7 +8983,7 @@ $as_echo_n "checking whether the $compiler linker ($LD) supports shared librarie
     # FIXME: the MSVC++ port hasn't been tested in a loooong time
     # When not using gcc, we currently assume that we are using
     # Microsoft Visual C++.
-    if test "$GCC" != yes; then
+    if test yes != "$GCC"; then
       with_gnu_ld=no
     fi
     ;;
@@ -8688,7 +8991,7 @@ $as_echo_n "checking whether the $compiler linker ($LD) supports shared librarie
     # we just hope/assume this is gcc and not c89 (= MSVC++)
     with_gnu_ld=yes
     ;;
-  openbsd*)
+  openbsd* | bitrig*)
     with_gnu_ld=no
     ;;
   esac
@@ -8698,7 +9001,7 @@ $as_echo_n "checking whether the $compiler linker ($LD) supports shared librarie
   # On some targets, GNU ld is compatible enough with the native linker
   # that we're better off using the native interface for both.
   lt_use_gnu_ld_interface=no
-  if test "$with_gnu_ld" = yes; then
+  if test yes = "$with_gnu_ld"; then
     case $host_os in
       aix*)
 	# The AIX port of GNU ld has always aspired to compatibility
@@ -8720,24 +9023,24 @@ $as_echo_n "checking whether the $compiler linker ($LD) supports shared librarie
     esac
   fi
 
-  if test "$lt_use_gnu_ld_interface" = yes; then
+  if test yes = "$lt_use_gnu_ld_interface"; then
     # If archive_cmds runs LD, not CC, wlarc should be empty
-    wlarc='${wl}'
+    wlarc='$wl'
 
     # Set some defaults for GNU ld with shared library support. These
     # are reset later if shared libraries are not supported. Putting them
     # here allows them to be overridden if necessary.
     runpath_var=LD_RUN_PATH
-    hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
-    export_dynamic_flag_spec='${wl}--export-dynamic'
+    hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
+    export_dynamic_flag_spec='$wl--export-dynamic'
     # ancient GNU ld didn't support --whole-archive et. al.
     if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then
-      whole_archive_flag_spec="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
+      whole_archive_flag_spec=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive'
     else
       whole_archive_flag_spec=
     fi
     supports_anon_versioning=no
-    case `$LD -v 2>&1` in
+    case `$LD -v | $SED -e 's/([^)]\+)\s\+//' 2>&1` in
       *GNU\ gold*) supports_anon_versioning=yes ;;
       *\ [01].* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11
       *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
@@ -8750,7 +9053,7 @@ $as_echo_n "checking whether the $compiler linker ($LD) supports shared librarie
     case $host_os in
     aix[3-9]*)
       # On AIX/PPC, the GNU linker is very broken
-      if test "$host_cpu" != ia64; then
+      if test ia64 != "$host_cpu"; then
 	ld_shlibs=no
 	cat <<_LT_EOF 1>&2
 
@@ -8769,7 +9072,7 @@ _LT_EOF
       case $host_cpu in
       powerpc)
             # see comment about AmigaOS4 .so support
-            archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+            archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
             archive_expsym_cmds=''
         ;;
       m68k)
@@ -8785,7 +9088,7 @@ _LT_EOF
 	allow_undefined_flag=unsupported
 	# Joseph Beckenbach <jrb3@best.com> says some releases of gcc
 	# support --undefined.  This deserves some investigation.  FIXME
-	archive_cmds='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+	archive_cmds='$CC -nostart $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
       else
 	ld_shlibs=no
       fi
@@ -8795,7 +9098,7 @@ _LT_EOF
       # _LT_TAGVAR(hardcode_libdir_flag_spec, ) is actually meaningless,
       # as there is no search path for DLLs.
       hardcode_libdir_flag_spec='-L$libdir'
-      export_dynamic_flag_spec='${wl}--export-all-symbols'
+      export_dynamic_flag_spec='$wl--export-all-symbols'
       allow_undefined_flag=unsupported
       always_export_symbols=no
       enable_shared_with_static_runtimes=yes
@@ -8803,61 +9106,90 @@ _LT_EOF
       exclude_expsyms='[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname'
 
       if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
-        archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
-	# If the export-symbols file already is a .def file (1st line
-	# is EXPORTS), use it as is; otherwise, prepend...
-	archive_expsym_cmds='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
-	  cp $export_symbols $output_objdir/$soname.def;
-	else
-	  echo EXPORTS > $output_objdir/$soname.def;
-	  cat $export_symbols >> $output_objdir/$soname.def;
-	fi~
-	$CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+        archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+	# If the export-symbols file already is a .def file, use it as
+	# is; otherwise, prepend EXPORTS...
+	archive_expsym_cmds='if   test DEF = "`$SED -n     -e '\''s/^[	 ]*//'\''     -e '\''/^\(;.*\)*$/d'\''     -e '\''s/^\(EXPORTS\|LIBRARY\)\([	 ].*\)*$/DEF/p'\''     -e q     $export_symbols`" ; then
+          cp $export_symbols $output_objdir/$soname.def;
+        else
+          echo EXPORTS > $output_objdir/$soname.def;
+          cat $export_symbols >> $output_objdir/$soname.def;
+        fi~
+        $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
       else
 	ld_shlibs=no
       fi
       ;;
 
     haiku*)
-      archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+      archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
       link_all_deplibs=yes
       ;;
 
+    os2*)
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_minus_L=yes
+      allow_undefined_flag=unsupported
+      shrext_cmds=.dll
+      archive_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      archive_expsym_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	prefix_cmds="$SED"~
+	if test EXPORTS = "`$SED 1q $export_symbols`"; then
+	  prefix_cmds="$prefix_cmds -e 1d";
+	fi~
+	prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~
+	cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      old_archive_from_new_cmds='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
+      enable_shared_with_static_runtimes=yes
+      file_list_spec='@'
+      ;;
+
     interix[3-9]*)
       hardcode_direct=no
       hardcode_shlibpath_var=no
-      hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
-      export_dynamic_flag_spec='${wl}-E'
+      hardcode_libdir_flag_spec='$wl-rpath,$libdir'
+      export_dynamic_flag_spec='$wl-E'
       # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
       # Instead, shared libraries are loaded at an image base (0x10000000 by
       # default) and relocated if they conflict, which is a slow very memory
       # consuming and fragmenting process.  To avoid this, we pick a random,
       # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
       # time.  Moving up from 0x10000000 also allows more sbrk(2) space.
-      archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
-      archive_expsym_cmds='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+      archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+      archive_expsym_cmds='sed "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--retain-symbols-file,$output_objdir/$soname.expsym $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
       ;;
 
     gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu)
       tmp_diet=no
-      if test "$host_os" = linux-dietlibc; then
+      if test linux-dietlibc = "$host_os"; then
 	case $cc_basename in
 	  diet\ *) tmp_diet=yes;;	# linux-dietlibc with static linking (!diet-dyn)
 	esac
       fi
       if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \
-	 && test "$tmp_diet" = no
+	 && test no = "$tmp_diet"
       then
 	tmp_addflag=' $pic_flag'
 	tmp_sharedflag='-shared'
 	case $cc_basename,$host_cpu in
         pgcc*)				# Portland Group C compiler
-	  whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
+	  whole_archive_flag_spec='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
 	  tmp_addflag=' $pic_flag'
 	  ;;
 	pgf77* | pgf90* | pgf95* | pgfortran*)
 					# Portland Group f77 and f90 compilers
-	  whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
+	  whole_archive_flag_spec='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
 	  tmp_addflag=' $pic_flag -Mnomain' ;;
 	ecc*,ia64* | icc*,ia64*)	# Intel C compiler on ia64
 	  tmp_addflag=' -i_dynamic' ;;
@@ -8868,42 +9200,47 @@ _LT_EOF
 	lf95*)				# Lahey Fortran 8.1
 	  whole_archive_flag_spec=
 	  tmp_sharedflag='--shared' ;;
+        nagfor*)                        # NAGFOR 5.3
+          tmp_sharedflag='-Wl,-shared' ;;
 	xl[cC]* | bgxl[cC]* | mpixl[cC]*) # IBM XL C 8.0 on PPC (deal with xlf below)
 	  tmp_sharedflag='-qmkshrobj'
 	  tmp_addflag= ;;
 	nvcc*)	# Cuda Compiler Driver 2.2
-	  whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
+	  whole_archive_flag_spec='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
 	  compiler_needs_object=yes
 	  ;;
 	esac
 	case `$CC -V 2>&1 | sed 5q` in
 	*Sun\ C*)			# Sun C 5.9
-	  whole_archive_flag_spec='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
+	  whole_archive_flag_spec='$wl--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
 	  compiler_needs_object=yes
 	  tmp_sharedflag='-G' ;;
 	*Sun\ F*)			# Sun Fortran 8.3
 	  tmp_sharedflag='-G' ;;
 	esac
-	archive_cmds='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+	archive_cmds='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
 
-        if test "x$supports_anon_versioning" = xyes; then
+        if test yes = "$supports_anon_versioning"; then
           archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~
-	    cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
-	    echo "local: *; };" >> $output_objdir/$libname.ver~
-	    $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
+            cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+            echo "local: *; };" >> $output_objdir/$libname.ver~
+            $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-version-script $wl$output_objdir/$libname.ver -o $lib'
         fi
 
 	case $cc_basename in
+	tcc*)
+	  export_dynamic_flag_spec='-rdynamic'
+	  ;;
 	xlf* | bgf* | bgxlf* | mpixlf*)
 	  # IBM XL Fortran 10.1 on PPC cannot create shared libs itself
 	  whole_archive_flag_spec='--whole-archive$convenience --no-whole-archive'
-	  hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+	  hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
 	  archive_cmds='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib'
-	  if test "x$supports_anon_versioning" = xyes; then
+	  if test yes = "$supports_anon_versioning"; then
 	    archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~
-	      cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
-	      echo "local: *; };" >> $output_objdir/$libname.ver~
-	      $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib'
+              cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+              echo "local: *; };" >> $output_objdir/$libname.ver~
+              $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib'
 	  fi
 	  ;;
 	esac
@@ -8917,8 +9254,8 @@ _LT_EOF
 	archive_cmds='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
 	wlarc=
       else
-	archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
-	archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+	archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
       fi
       ;;
 
@@ -8936,8 +9273,8 @@ _LT_EOF
 
 _LT_EOF
       elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
-	archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
-	archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+	archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
       else
 	ld_shlibs=no
       fi
@@ -8949,7 +9286,7 @@ _LT_EOF
 	ld_shlibs=no
 	cat <<_LT_EOF 1>&2
 
-*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not
+*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 cannot
 *** reliably create shared libraries on SCO systems.  Therefore, libtool
 *** is disabling shared libraries support.  We urge you to upgrade GNU
 *** binutils to release 2.16.91.0.3 or newer.  Another option is to modify
@@ -8964,9 +9301,9 @@ _LT_EOF
 	  # DT_RUNPATH tag from executables and libraries.  But doing so
 	  # requires that you compile everything twice, which is a pain.
 	  if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
-	    hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
-	    archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
-	    archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+	    hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
+	    archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	    archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
 	  else
 	    ld_shlibs=no
 	  fi
@@ -8983,15 +9320,15 @@ _LT_EOF
 
     *)
       if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
-	archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
-	archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+	archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
       else
 	ld_shlibs=no
       fi
       ;;
     esac
 
-    if test "$ld_shlibs" = no; then
+    if test no = "$ld_shlibs"; then
       runpath_var=
       hardcode_libdir_flag_spec=
       export_dynamic_flag_spec=
@@ -9007,7 +9344,7 @@ _LT_EOF
       # Note: this linker hardcodes the directories in LIBPATH if there
       # are no directories specified by -L.
       hardcode_minus_L=yes
-      if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then
+      if test yes = "$GCC" && test -z "$lt_prog_compiler_static"; then
 	# Neither direct hardcoding nor static linking is supported with a
 	# broken collect2.
 	hardcode_direct=unsupported
@@ -9015,34 +9352,57 @@ _LT_EOF
       ;;
 
     aix[4-9]*)
-      if test "$host_cpu" = ia64; then
+      if test ia64 = "$host_cpu"; then
 	# On IA64, the linker does run time linking by default, so we don't
 	# have to do anything special.
 	aix_use_runtimelinking=no
 	exp_sym_flag='-Bexport'
-	no_entry_flag=""
+	no_entry_flag=
       else
 	# If we're using GNU nm, then we don't want the "-C" option.
-	# -C means demangle to AIX nm, but means don't demangle with GNU nm
-	# Also, AIX nm treats weak defined symbols like other global
-	# defined symbols, whereas GNU nm marks them as "W".
+	# -C means demangle to GNU nm, but means don't demangle to AIX nm.
+	# Without the "-l" option, or with the "-B" option, AIX nm treats
+	# weak defined symbols like other global defined symbols, whereas
+	# GNU nm marks them as "W".
+	# While the 'weak' keyword is ignored in the Export File, we need
+	# it in the Import File for the 'aix-soname' feature, so we have
+	# to replace the "-B" option with "-P" for AIX nm.
 	if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
-	  export_symbols_cmds='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+	  export_symbols_cmds='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols'
 	else
-	  export_symbols_cmds='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+	  export_symbols_cmds='`func_echo_all $NM | $SED -e '\''s/B\([^B]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "L") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && (substr(\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols'
 	fi
 	aix_use_runtimelinking=no
 
 	# Test if we are trying to use run time linking or normal
 	# AIX style linking. If -brtl is somewhere in LDFLAGS, we
-	# need to do runtime linking.
+	# have runtime linking enabled, and use it for executables.
+	# For shared libraries, we enable/disable runtime linking
+	# depending on the kind of the shared library created -
+	# when "with_aix_soname,aix_use_runtimelinking" is:
+	# "aix,no"   lib.a(lib.so.V) shared, rtl:no,  for executables
+	# "aix,yes"  lib.so          shared, rtl:yes, for executables
+	#            lib.a           static archive
+	# "both,no"  lib.so.V(shr.o) shared, rtl:yes
+	#            lib.a(lib.so.V) shared, rtl:no,  for executables
+	# "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables
+	#            lib.a(lib.so.V) shared, rtl:no
+	# "svr4,*"   lib.so.V(shr.o) shared, rtl:yes, for executables
+	#            lib.a           static archive
 	case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*)
 	  for ld_flag in $LDFLAGS; do
-	  if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then
+	  if (test x-brtl = "x$ld_flag" || test x-Wl,-brtl = "x$ld_flag"); then
 	    aix_use_runtimelinking=yes
 	    break
 	  fi
 	  done
+	  if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then
+	    # With aix-soname=svr4, we create the lib.so.V shared archives only,
+	    # so we don't have lib.a shared libs to link our executables.
+	    # We have to force runtime linking in this case.
+	    aix_use_runtimelinking=yes
+	    LDFLAGS="$LDFLAGS -Wl,-brtl"
+	  fi
 	  ;;
 	esac
 
@@ -9061,13 +9421,21 @@ _LT_EOF
       hardcode_direct_absolute=yes
       hardcode_libdir_separator=':'
       link_all_deplibs=yes
-      file_list_spec='${wl}-f,'
+      file_list_spec='$wl-f,'
+      case $with_aix_soname,$aix_use_runtimelinking in
+      aix,*) ;; # traditional, no import file
+      svr4,* | *,yes) # use import file
+	# The Import File defines what to hardcode.
+	hardcode_direct=no
+	hardcode_direct_absolute=no
+	;;
+      esac
 
-      if test "$GCC" = yes; then
+      if test yes = "$GCC"; then
 	case $host_os in aix4.[012]|aix4.[012].*)
 	# We only want to do this on AIX 4.2 and lower, the check
 	# below for broken collect2 doesn't work under 4.3+
-	  collect2name=`${CC} -print-prog-name=collect2`
+	  collect2name=`$CC -print-prog-name=collect2`
 	  if test -f "$collect2name" &&
 	   strings "$collect2name" | $GREP resolve_lib_name >/dev/null
 	  then
@@ -9086,35 +9454,42 @@ _LT_EOF
 	  ;;
 	esac
 	shared_flag='-shared'
-	if test "$aix_use_runtimelinking" = yes; then
-	  shared_flag="$shared_flag "'${wl}-G'
+	if test yes = "$aix_use_runtimelinking"; then
+	  shared_flag="$shared_flag "'$wl-G'
 	fi
+	# Need to ensure runtime linking is disabled for the traditional
+	# shared library, or the linker may eventually find shared libraries
+	# /with/ Import File - we do not want to mix them.
+	shared_flag_aix='-shared'
+	shared_flag_svr4='-shared $wl-G'
       else
 	# not using gcc
-	if test "$host_cpu" = ia64; then
+	if test ia64 = "$host_cpu"; then
 	# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
 	# chokes on -Wl,-G. The following line is correct:
 	  shared_flag='-G'
 	else
-	  if test "$aix_use_runtimelinking" = yes; then
-	    shared_flag='${wl}-G'
+	  if test yes = "$aix_use_runtimelinking"; then
+	    shared_flag='$wl-G'
 	  else
-	    shared_flag='${wl}-bM:SRE'
+	    shared_flag='$wl-bM:SRE'
 	  fi
+	  shared_flag_aix='$wl-bM:SRE'
+	  shared_flag_svr4='$wl-G'
 	fi
       fi
 
-      export_dynamic_flag_spec='${wl}-bexpall'
+      export_dynamic_flag_spec='$wl-bexpall'
       # It seems that -bexpall does not export symbols beginning with
       # underscore (_), so it is better to generate a list of symbols to export.
       always_export_symbols=yes
-      if test "$aix_use_runtimelinking" = yes; then
+      if test aix,yes = "$with_aix_soname,$aix_use_runtimelinking"; then
 	# Warning - without using the other runtime loading flags (-brtl),
 	# -berok will link without error, but may produce a broken library.
 	allow_undefined_flag='-berok'
         # Determine the default libpath from the value encoded in an
         # empty executable.
-        if test "${lt_cv_aix_libpath+set}" = set; then
+        if test set = "${lt_cv_aix_libpath+set}"; then
   aix_libpath=$lt_cv_aix_libpath
 else
   if ${lt_cv_aix_libpath_+:} false; then :
@@ -9149,7 +9524,7 @@ fi
 rm -f core conftest.err conftest.$ac_objext \
     conftest$ac_exeext conftest.$ac_ext
   if test -z "$lt_cv_aix_libpath_"; then
-    lt_cv_aix_libpath_="/usr/lib:/lib"
+    lt_cv_aix_libpath_=/usr/lib:/lib
   fi
 
 fi
@@ -9157,17 +9532,17 @@ fi
   aix_libpath=$lt_cv_aix_libpath_
 fi
 
-        hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath"
-        archive_expsym_cmds='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"
+        hardcode_libdir_flag_spec='$wl-blibpath:$libdir:'"$aix_libpath"
+        archive_expsym_cmds='$CC -o $output_objdir/$soname $libobjs $deplibs $wl'$no_entry_flag' $compiler_flags `if test -n "$allow_undefined_flag"; then func_echo_all "$wl$allow_undefined_flag"; else :; fi` $wl'$exp_sym_flag:\$export_symbols' '$shared_flag
       else
-	if test "$host_cpu" = ia64; then
-	  hardcode_libdir_flag_spec='${wl}-R $libdir:/usr/lib:/lib'
+	if test ia64 = "$host_cpu"; then
+	  hardcode_libdir_flag_spec='$wl-R $libdir:/usr/lib:/lib'
 	  allow_undefined_flag="-z nodefs"
-	  archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"
+	  archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\$wl$no_entry_flag"' $compiler_flags $wl$allow_undefined_flag '"\$wl$exp_sym_flag:\$export_symbols"
 	else
 	 # Determine the default libpath from the value encoded in an
 	 # empty executable.
-	 if test "${lt_cv_aix_libpath+set}" = set; then
+	 if test set = "${lt_cv_aix_libpath+set}"; then
   aix_libpath=$lt_cv_aix_libpath
 else
   if ${lt_cv_aix_libpath_+:} false; then :
@@ -9202,7 +9577,7 @@ fi
 rm -f core conftest.err conftest.$ac_objext \
     conftest$ac_exeext conftest.$ac_ext
   if test -z "$lt_cv_aix_libpath_"; then
-    lt_cv_aix_libpath_="/usr/lib:/lib"
+    lt_cv_aix_libpath_=/usr/lib:/lib
   fi
 
 fi
@@ -9210,21 +9585,33 @@ fi
   aix_libpath=$lt_cv_aix_libpath_
 fi
 
-	 hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath"
+	 hardcode_libdir_flag_spec='$wl-blibpath:$libdir:'"$aix_libpath"
 	  # Warning - without using the other run time loading flags,
 	  # -berok will link without error, but may produce a broken library.
-	  no_undefined_flag=' ${wl}-bernotok'
-	  allow_undefined_flag=' ${wl}-berok'
-	  if test "$with_gnu_ld" = yes; then
+	  no_undefined_flag=' $wl-bernotok'
+	  allow_undefined_flag=' $wl-berok'
+	  if test yes = "$with_gnu_ld"; then
 	    # We only use this code for GNU lds that support --whole-archive.
-	    whole_archive_flag_spec='${wl}--whole-archive$convenience ${wl}--no-whole-archive'
+	    whole_archive_flag_spec='$wl--whole-archive$convenience $wl--no-whole-archive'
 	  else
 	    # Exported symbols can be pulled into shared objects from archives
 	    whole_archive_flag_spec='$convenience'
 	  fi
 	  archive_cmds_need_lc=yes
-	  # This is similar to how AIX traditionally builds its shared libraries.
-	  archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
+	  archive_expsym_cmds='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d'
+	  # -brtl affects multiple linker settings, -berok does not and is overridden later
+	  compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\\([, ]\\)%-berok\\1%g"`'
+	  if test svr4 != "$with_aix_soname"; then
+	    # This is similar to how AIX traditionally builds its shared libraries.
+	    archive_expsym_cmds="$archive_expsym_cmds"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname'
+	  fi
+	  if test aix != "$with_aix_soname"; then
+	    archive_expsym_cmds="$archive_expsym_cmds"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp'
+	  else
+	    # used by -dlpreopen to get the symbols
+	    archive_expsym_cmds="$archive_expsym_cmds"'~$MV  $output_objdir/$realname.d/$soname $output_objdir'
+	  fi
+	  archive_expsym_cmds="$archive_expsym_cmds"'~$RM -r $output_objdir/$realname.d'
 	fi
       fi
       ;;
@@ -9233,7 +9620,7 @@ fi
       case $host_cpu in
       powerpc)
             # see comment about AmigaOS4 .so support
-            archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+            archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
             archive_expsym_cmds=''
         ;;
       m68k)
@@ -9263,16 +9650,17 @@ fi
 	# Tell ltmain to make .lib files, not .a files.
 	libext=lib
 	# Tell ltmain to make .dll files, not .so files.
-	shrext_cmds=".dll"
+	shrext_cmds=.dll
 	# FIXME: Setting linknames here is a bad hack.
-	archive_cmds='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames='
-	archive_expsym_cmds='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
-	    sed -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp;
-	  else
-	    sed -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp;
-	  fi~
-	  $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
-	  linknames='
+	archive_cmds='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames='
+	archive_expsym_cmds='if   test DEF = "`$SED -n     -e '\''s/^[	 ]*//'\''     -e '\''/^\(;.*\)*$/d'\''     -e '\''s/^\(EXPORTS\|LIBRARY\)\([	 ].*\)*$/DEF/p'\''     -e q     $export_symbols`" ; then
+            cp "$export_symbols" "$output_objdir/$soname.def";
+            echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp";
+          else
+            $SED -e '\''s/^/-link -EXPORT:/'\'' < $export_symbols > $output_objdir/$soname.exp;
+          fi~
+          $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
+          linknames='
 	# The linker will not automatically build a static lib if we build a DLL.
 	# _LT_TAGVAR(old_archive_from_new_cmds, )='true'
 	enable_shared_with_static_runtimes=yes
@@ -9281,18 +9669,18 @@ fi
 	# Don't use ranlib
 	old_postinstall_cmds='chmod 644 $oldlib'
 	postlink_cmds='lt_outputfile="@OUTPUT@"~
-	  lt_tool_outputfile="@TOOL_OUTPUT@"~
-	  case $lt_outputfile in
-	    *.exe|*.EXE) ;;
-	    *)
-	      lt_outputfile="$lt_outputfile.exe"
-	      lt_tool_outputfile="$lt_tool_outputfile.exe"
-	      ;;
-	  esac~
-	  if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then
-	    $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;
-	    $RM "$lt_outputfile.manifest";
-	  fi'
+          lt_tool_outputfile="@TOOL_OUTPUT@"~
+          case $lt_outputfile in
+            *.exe|*.EXE) ;;
+            *)
+              lt_outputfile=$lt_outputfile.exe
+              lt_tool_outputfile=$lt_tool_outputfile.exe
+              ;;
+          esac~
+          if test : != "$MANIFEST_TOOL" && test -f "$lt_outputfile.manifest"; then
+            $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;
+            $RM "$lt_outputfile.manifest";
+          fi'
 	;;
       *)
 	# Assume MSVC wrapper
@@ -9301,7 +9689,7 @@ fi
 	# Tell ltmain to make .lib files, not .a files.
 	libext=lib
 	# Tell ltmain to make .dll files, not .so files.
-	shrext_cmds=".dll"
+	shrext_cmds=.dll
 	# FIXME: Setting linknames here is a bad hack.
 	archive_cmds='$CC -o $lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames='
 	# The linker will automatically build a .lib file if we build a DLL.
@@ -9320,24 +9708,24 @@ fi
   hardcode_direct=no
   hardcode_automatic=yes
   hardcode_shlibpath_var=unsupported
-  if test "$lt_cv_ld_force_load" = "yes"; then
-    whole_archive_flag_spec='`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience ${wl}-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`'
+  if test yes = "$lt_cv_ld_force_load"; then
+    whole_archive_flag_spec='`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience $wl-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`'
 
   else
     whole_archive_flag_spec=''
   fi
   link_all_deplibs=yes
-  allow_undefined_flag="$_lt_dar_allow_undefined"
+  allow_undefined_flag=$_lt_dar_allow_undefined
   case $cc_basename in
-     ifort*) _lt_dar_can_shared=yes ;;
+     ifort*|nagfor*) _lt_dar_can_shared=yes ;;
      *) _lt_dar_can_shared=$GCC ;;
   esac
-  if test "$_lt_dar_can_shared" = "yes"; then
+  if test yes = "$_lt_dar_can_shared"; then
     output_verbose_link_cmd=func_echo_all
-    archive_cmds="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}"
-    module_cmds="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}"
-    archive_expsym_cmds="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}"
-    module_expsym_cmds="sed -e 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dar_export_syms}${_lt_dsymutil}"
+    archive_cmds="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dsymutil"
+    module_cmds="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dsymutil"
+    archive_expsym_cmds="sed 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dar_export_syms$_lt_dsymutil"
+    module_expsym_cmds="sed -e 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dar_export_syms$_lt_dsymutil"
 
   else
   ld_shlibs=no
@@ -9371,7 +9759,7 @@ fi
       ;;
 
     # FreeBSD 3 and greater uses gcc -shared to do shared libraries.
-    freebsd* | dragonfly*)
+    freebsd* | dragonfly* | midnightbsd*)
       archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
       hardcode_libdir_flag_spec='-R$libdir'
       hardcode_direct=yes
@@ -9379,33 +9767,33 @@ fi
       ;;
 
     hpux9*)
-      if test "$GCC" = yes; then
-	archive_cmds='$RM $output_objdir/$soname~$CC -shared $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+      if test yes = "$GCC"; then
+	archive_cmds='$RM $output_objdir/$soname~$CC -shared $pic_flag $wl+b $wl$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
       else
-	archive_cmds='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+	archive_cmds='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
       fi
-      hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
+      hardcode_libdir_flag_spec='$wl+b $wl$libdir'
       hardcode_libdir_separator=:
       hardcode_direct=yes
 
       # hardcode_minus_L: Not really in the search PATH,
       # but as the default location of the library.
       hardcode_minus_L=yes
-      export_dynamic_flag_spec='${wl}-E'
+      export_dynamic_flag_spec='$wl-E'
       ;;
 
     hpux10*)
-      if test "$GCC" = yes && test "$with_gnu_ld" = no; then
-	archive_cmds='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+      if test yes,no = "$GCC,$with_gnu_ld"; then
+	archive_cmds='$CC -shared $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
       else
 	archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
       fi
-      if test "$with_gnu_ld" = no; then
-	hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
+      if test no = "$with_gnu_ld"; then
+	hardcode_libdir_flag_spec='$wl+b $wl$libdir'
 	hardcode_libdir_separator=:
 	hardcode_direct=yes
 	hardcode_direct_absolute=yes
-	export_dynamic_flag_spec='${wl}-E'
+	export_dynamic_flag_spec='$wl-E'
 	# hardcode_minus_L: Not really in the search PATH,
 	# but as the default location of the library.
 	hardcode_minus_L=yes
@@ -9413,25 +9801,25 @@ fi
       ;;
 
     hpux11*)
-      if test "$GCC" = yes && test "$with_gnu_ld" = no; then
+      if test yes,no = "$GCC,$with_gnu_ld"; then
 	case $host_cpu in
 	hppa*64*)
-	  archive_cmds='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  archive_cmds='$CC -shared $wl+h $wl$soname -o $lib $libobjs $deplibs $compiler_flags'
 	  ;;
 	ia64*)
-	  archive_cmds='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
+	  archive_cmds='$CC -shared $pic_flag $wl+h $wl$soname $wl+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
 	  ;;
 	*)
-	  archive_cmds='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+	  archive_cmds='$CC -shared $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
 	  ;;
 	esac
       else
 	case $host_cpu in
 	hppa*64*)
-	  archive_cmds='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  archive_cmds='$CC -b $wl+h $wl$soname -o $lib $libobjs $deplibs $compiler_flags'
 	  ;;
 	ia64*)
-	  archive_cmds='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
+	  archive_cmds='$CC -b $wl+h $wl$soname $wl+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
 	  ;;
 	*)
 
@@ -9443,7 +9831,7 @@ if ${lt_cv_prog_compiler__b+:} false; then :
   $as_echo_n "(cached) " >&6
 else
   lt_cv_prog_compiler__b=no
-   save_LDFLAGS="$LDFLAGS"
+   save_LDFLAGS=$LDFLAGS
    LDFLAGS="$LDFLAGS -b"
    echo "$lt_simple_link_test_code" > conftest.$ac_ext
    if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
@@ -9462,14 +9850,14 @@ else
      fi
    fi
    $RM -r conftest*
-   LDFLAGS="$save_LDFLAGS"
+   LDFLAGS=$save_LDFLAGS
 
 fi
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler__b" >&5
 $as_echo "$lt_cv_prog_compiler__b" >&6; }
 
-if test x"$lt_cv_prog_compiler__b" = xyes; then
-    archive_cmds='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+if test yes = "$lt_cv_prog_compiler__b"; then
+    archive_cmds='$CC -b $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
 else
     archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
 fi
@@ -9477,8 +9865,8 @@ fi
 	  ;;
 	esac
       fi
-      if test "$with_gnu_ld" = no; then
-	hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
+      if test no = "$with_gnu_ld"; then
+	hardcode_libdir_flag_spec='$wl+b $wl$libdir'
 	hardcode_libdir_separator=:
 
 	case $host_cpu in
@@ -9489,7 +9877,7 @@ fi
 	*)
 	  hardcode_direct=yes
 	  hardcode_direct_absolute=yes
-	  export_dynamic_flag_spec='${wl}-E'
+	  export_dynamic_flag_spec='$wl-E'
 
 	  # hardcode_minus_L: Not really in the search PATH,
 	  # but as the default location of the library.
@@ -9500,8 +9888,8 @@ fi
       ;;
 
     irix5* | irix6* | nonstopux*)
-      if test "$GCC" = yes; then
-	archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+      if test yes = "$GCC"; then
+	archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
 	# Try to use the -exported_symbol ld option, if it does not
 	# work, assume that -exports_file does not work either and
 	# implicitly export all symbols.
@@ -9511,8 +9899,8 @@ $as_echo_n "checking whether the $host_os linker accepts -exported_symbol... " >
 if ${lt_cv_irix_exported_symbol+:} false; then :
   $as_echo_n "(cached) " >&6
 else
-  save_LDFLAGS="$LDFLAGS"
-	   LDFLAGS="$LDFLAGS -shared ${wl}-exported_symbol ${wl}foo ${wl}-update_registry ${wl}/dev/null"
+  save_LDFLAGS=$LDFLAGS
+	   LDFLAGS="$LDFLAGS -shared $wl-exported_symbol ${wl}foo $wl-update_registry $wl/dev/null"
 	   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 int foo (void) { return 0; }
@@ -9524,24 +9912,34 @@ else
 fi
 rm -f core conftest.err conftest.$ac_objext \
     conftest$ac_exeext conftest.$ac_ext
-           LDFLAGS="$save_LDFLAGS"
+           LDFLAGS=$save_LDFLAGS
 fi
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_irix_exported_symbol" >&5
 $as_echo "$lt_cv_irix_exported_symbol" >&6; }
-	if test "$lt_cv_irix_exported_symbol" = yes; then
-          archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations ${wl}-exports_file ${wl}$export_symbols -o $lib'
+	if test yes = "$lt_cv_irix_exported_symbol"; then
+          archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations $wl-exports_file $wl$export_symbols -o $lib'
 	fi
       else
-	archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
-	archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -exports_file $export_symbols -o $lib'
+	archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
+	archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -exports_file $export_symbols -o $lib'
       fi
       archive_cmds_need_lc='no'
-      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+      hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
       hardcode_libdir_separator=:
       inherit_rpath=yes
       link_all_deplibs=yes
       ;;
 
+    linux*)
+      case $cc_basename in
+      tcc*)
+	# Fabrice Bellard et al's Tiny C Compiler
+	ld_shlibs=yes
+	archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	;;
+      esac
+      ;;
+
     netbsd*)
       if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
 	archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out
@@ -9556,7 +9954,7 @@ $as_echo "$lt_cv_irix_exported_symbol" >&6; }
     newsos6)
       archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
       hardcode_direct=yes
-      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+      hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
       hardcode_libdir_separator=:
       hardcode_shlibpath_var=no
       ;;
@@ -9564,27 +9962,19 @@ $as_echo "$lt_cv_irix_exported_symbol" >&6; }
     *nto* | *qnx*)
       ;;
 
-    openbsd*)
+    openbsd* | bitrig*)
       if test -f /usr/libexec/ld.so; then
 	hardcode_direct=yes
 	hardcode_shlibpath_var=no
 	hardcode_direct_absolute=yes
-	if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+	if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then
 	  archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
-	  archive_expsym_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols'
-	  hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
-	  export_dynamic_flag_spec='${wl}-E'
+	  archive_expsym_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags $wl-retain-symbols-file,$export_symbols'
+	  hardcode_libdir_flag_spec='$wl-rpath,$libdir'
+	  export_dynamic_flag_spec='$wl-E'
 	else
-	  case $host_os in
-	   openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*)
-	     archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
-	     hardcode_libdir_flag_spec='-R$libdir'
-	     ;;
-	   *)
-	     archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
-	     hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
-	     ;;
-	  esac
+	  archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	  hardcode_libdir_flag_spec='$wl-rpath,$libdir'
 	fi
       else
 	ld_shlibs=no
@@ -9595,33 +9985,54 @@ $as_echo "$lt_cv_irix_exported_symbol" >&6; }
       hardcode_libdir_flag_spec='-L$libdir'
       hardcode_minus_L=yes
       allow_undefined_flag=unsupported
-      archive_cmds='$ECHO "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~echo DATA >> $output_objdir/$libname.def~echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def'
-      old_archive_from_new_cmds='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def'
+      shrext_cmds=.dll
+      archive_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      archive_expsym_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	prefix_cmds="$SED"~
+	if test EXPORTS = "`$SED 1q $export_symbols`"; then
+	  prefix_cmds="$prefix_cmds -e 1d";
+	fi~
+	prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~
+	cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      old_archive_from_new_cmds='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
+      enable_shared_with_static_runtimes=yes
+      file_list_spec='@'
       ;;
 
     osf3*)
-      if test "$GCC" = yes; then
-	allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*'
-	archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+      if test yes = "$GCC"; then
+	allow_undefined_flag=' $wl-expect_unresolved $wl\*'
+	archive_cmds='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
       else
 	allow_undefined_flag=' -expect_unresolved \*'
-	archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
+	archive_cmds='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
       fi
       archive_cmds_need_lc='no'
-      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+      hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
       hardcode_libdir_separator=:
       ;;
 
     osf4* | osf5*)	# as osf3* with the addition of -msym flag
-      if test "$GCC" = yes; then
-	allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*'
-	archive_cmds='$CC -shared${allow_undefined_flag} $pic_flag $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
-	hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+      if test yes = "$GCC"; then
+	allow_undefined_flag=' $wl-expect_unresolved $wl\*'
+	archive_cmds='$CC -shared$allow_undefined_flag $pic_flag $libobjs $deplibs $compiler_flags $wl-msym $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
+	hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
       else
 	allow_undefined_flag=' -expect_unresolved \*'
-	archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
+	archive_cmds='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
 	archive_expsym_cmds='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~
-	$CC -shared${allow_undefined_flag} ${wl}-input ${wl}$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~$RM $lib.exp'
+          $CC -shared$allow_undefined_flag $wl-input $wl$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib~$RM $lib.exp'
 
 	# Both c and cxx compiler support -rpath directly
 	hardcode_libdir_flag_spec='-rpath $libdir'
@@ -9632,24 +10043,24 @@ $as_echo "$lt_cv_irix_exported_symbol" >&6; }
 
     solaris*)
       no_undefined_flag=' -z defs'
-      if test "$GCC" = yes; then
-	wlarc='${wl}'
-	archive_cmds='$CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+      if test yes = "$GCC"; then
+	wlarc='$wl'
+	archive_cmds='$CC -shared $pic_flag $wl-z ${wl}text $wl-h $wl$soname -o $lib $libobjs $deplibs $compiler_flags'
 	archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
-	  $CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
+          $CC -shared $pic_flag $wl-z ${wl}text $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
       else
 	case `$CC -V 2>&1` in
 	*"Compilers 5.0"*)
 	  wlarc=''
-	  archive_cmds='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	  archive_cmds='$LD -G$allow_undefined_flag -h $soname -o $lib $libobjs $deplibs $linker_flags'
 	  archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
-	  $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp'
+            $LD -G$allow_undefined_flag -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp'
 	  ;;
 	*)
-	  wlarc='${wl}'
-	  archive_cmds='$CC -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $compiler_flags'
+	  wlarc='$wl'
+	  archive_cmds='$CC -G$allow_undefined_flag -h $soname -o $lib $libobjs $deplibs $compiler_flags'
 	  archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
-	  $CC -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
+            $CC -G$allow_undefined_flag -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
 	  ;;
 	esac
       fi
@@ -9659,11 +10070,11 @@ $as_echo "$lt_cv_irix_exported_symbol" >&6; }
       solaris2.[0-5] | solaris2.[0-5].*) ;;
       *)
 	# The compiler driver will combine and reorder linker options,
-	# but understands `-z linker_flag'.  GCC discards it without `$wl',
+	# but understands '-z linker_flag'.  GCC discards it without '$wl',
 	# but is careful enough not to reorder.
 	# Supported since Solaris 2.6 (maybe 2.5.1?)
-	if test "$GCC" = yes; then
-	  whole_archive_flag_spec='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract'
+	if test yes = "$GCC"; then
+	  whole_archive_flag_spec='$wl-z ${wl}allextract$convenience $wl-z ${wl}defaultextract'
 	else
 	  whole_archive_flag_spec='-z allextract$convenience -z defaultextract'
 	fi
@@ -9673,10 +10084,10 @@ $as_echo "$lt_cv_irix_exported_symbol" >&6; }
       ;;
 
     sunos4*)
-      if test "x$host_vendor" = xsequent; then
+      if test sequent = "$host_vendor"; then
 	# Use $CC to link under sequent, because it throws in some extra .o
 	# files that make .init and .fini sections work.
-	archive_cmds='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_cmds='$CC -G $wl-h $soname -o $lib $libobjs $deplibs $compiler_flags'
       else
 	archive_cmds='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'
       fi
@@ -9725,43 +10136,43 @@ $as_echo "$lt_cv_irix_exported_symbol" >&6; }
       ;;
 
     sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*)
-      no_undefined_flag='${wl}-z,text'
+      no_undefined_flag='$wl-z,text'
       archive_cmds_need_lc=no
       hardcode_shlibpath_var=no
       runpath_var='LD_RUN_PATH'
 
-      if test "$GCC" = yes; then
-	archive_cmds='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	archive_expsym_cmds='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      if test yes = "$GCC"; then
+	archive_cmds='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
       else
-	archive_cmds='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	archive_expsym_cmds='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_cmds='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
       fi
       ;;
 
     sysv5* | sco3.2v5* | sco5v6*)
-      # Note: We can NOT use -z defs as we might desire, because we do not
+      # Note: We CANNOT use -z defs as we might desire, because we do not
       # link with -lc, and that would cause any symbols used from libc to
       # always be unresolved, which means just about no library would
       # ever link correctly.  If we're not using GNU ld we use -z text
       # though, which does catch some bad symbols but isn't as heavy-handed
       # as -z defs.
-      no_undefined_flag='${wl}-z,text'
-      allow_undefined_flag='${wl}-z,nodefs'
+      no_undefined_flag='$wl-z,text'
+      allow_undefined_flag='$wl-z,nodefs'
       archive_cmds_need_lc=no
       hardcode_shlibpath_var=no
-      hardcode_libdir_flag_spec='${wl}-R,$libdir'
+      hardcode_libdir_flag_spec='$wl-R,$libdir'
       hardcode_libdir_separator=':'
       link_all_deplibs=yes
-      export_dynamic_flag_spec='${wl}-Bexport'
+      export_dynamic_flag_spec='$wl-Bexport'
       runpath_var='LD_RUN_PATH'
 
-      if test "$GCC" = yes; then
-	archive_cmds='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	archive_expsym_cmds='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      if test yes = "$GCC"; then
+	archive_cmds='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
       else
-	archive_cmds='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	archive_expsym_cmds='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_cmds='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
       fi
       ;;
 
@@ -9776,10 +10187,10 @@ $as_echo "$lt_cv_irix_exported_symbol" >&6; }
       ;;
     esac
 
-    if test x$host_vendor = xsni; then
+    if test sni = "$host_vendor"; then
       case $host in
       sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
-	export_dynamic_flag_spec='${wl}-Blargedynsym'
+	export_dynamic_flag_spec='$wl-Blargedynsym'
 	;;
       esac
     fi
@@ -9787,7 +10198,7 @@ $as_echo "$lt_cv_irix_exported_symbol" >&6; }
 
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs" >&5
 $as_echo "$ld_shlibs" >&6; }
-test "$ld_shlibs" = no && can_build_shared=no
+test no = "$ld_shlibs" && can_build_shared=no
 
 with_gnu_ld=$with_gnu_ld
 
@@ -9813,7 +10224,7 @@ x|xyes)
   # Assume -lc should be added
   archive_cmds_need_lc=yes
 
-  if test "$enable_shared" = yes && test "$GCC" = yes; then
+  if test yes,yes = "$GCC,$enable_shared"; then
     case $archive_cmds in
     *'~'*)
       # FIXME: we may have to deal with multi-command sequences.
@@ -10028,14 +10439,14 @@ esac
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5
 $as_echo_n "checking dynamic linker characteristics... " >&6; }
 
-if test "$GCC" = yes; then
+if test yes = "$GCC"; then
   case $host_os in
-    darwin*) lt_awk_arg="/^libraries:/,/LR/" ;;
-    *) lt_awk_arg="/^libraries:/" ;;
+    darwin*) lt_awk_arg='/^libraries:/,/LR/' ;;
+    *) lt_awk_arg='/^libraries:/' ;;
   esac
   case $host_os in
-    mingw* | cegcc*) lt_sed_strip_eq="s,=\([A-Za-z]:\),\1,g" ;;
-    *) lt_sed_strip_eq="s,=/,/,g" ;;
+    mingw* | cegcc*) lt_sed_strip_eq='s|=\([A-Za-z]:\)|\1|g' ;;
+    *) lt_sed_strip_eq='s|=/|/|g' ;;
   esac
   lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e $lt_sed_strip_eq`
   case $lt_search_path_spec in
@@ -10054,8 +10465,8 @@ if test "$GCC" = yes; then
   # and add multilib dir if necessary...
   lt_tmp_lt_search_path_spec=
   lt_multi_os_dir=/`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null`
-  # ...but if some path already ends with the multilib dir we assume
-  # that all is fine and trust -print-search-dirs as is (GCC 4.2 or newer).
+  # ...but if some path component already ends with the multilib dir we assume
+  # that all is fine and trust -print-search-dirs as is (GCC 4.2? or newer).
   case "$lt_multi_os_dir; $lt_search_path_spec " in
   "/; "* | "/.; "* | "/./; "* | *"$lt_multi_os_dir "* | *"$lt_multi_os_dir/ "*)
     lt_multi_os_dir=
@@ -10070,16 +10481,16 @@ if test "$GCC" = yes; then
     fi
   done
   lt_search_path_spec=`$ECHO "$lt_tmp_lt_search_path_spec" | awk '
-BEGIN {RS=" "; FS="/|\n";} {
-  lt_foo="";
-  lt_count=0;
+BEGIN {RS = " "; FS = "/|\n";} {
+  lt_foo = "";
+  lt_count = 0;
   for (lt_i = NF; lt_i > 0; lt_i--) {
     if ($lt_i != "" && $lt_i != ".") {
       if ($lt_i == "..") {
         lt_count++;
       } else {
         if (lt_count == 0) {
-          lt_foo="/" $lt_i lt_foo;
+          lt_foo = "/" $lt_i lt_foo;
         } else {
           lt_count--;
         }
@@ -10093,7 +10504,7 @@ BEGIN {RS=" "; FS="/|\n";} {
   # for these hosts.
   case $host_os in
     mingw* | cegcc*) lt_search_path_spec=`$ECHO "$lt_search_path_spec" |\
-      $SED 's,/\([A-Za-z]:\),\1,g'` ;;
+      $SED 's|/\([A-Za-z]:\)|\1|g'` ;;
   esac
   sys_lib_search_path_spec=`$ECHO "$lt_search_path_spec" | $lt_NL2SP`
 else
@@ -10102,7 +10513,7 @@ fi
 library_names_spec=
 libname_spec='lib$name'
 soname_spec=
-shrext_cmds=".so"
+shrext_cmds=.so
 postinstall_cmds=
 postuninstall_cmds=
 finish_cmds=
@@ -10119,14 +10530,16 @@ hardcode_into_libs=no
 # flags to be left without arguments
 need_version=unknown
 
+
+
 case $host_os in
 aix3*)
   version_type=linux # correct to gnu/linux during the next big refactor
-  library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname.a'
   shlibpath_var=LIBPATH
 
   # AIX 3 has no versioning support, so we append a major version to the name.
-  soname_spec='${libname}${release}${shared_ext}$major'
+  soname_spec='$libname$release$shared_ext$major'
   ;;
 
 aix[4-9]*)
@@ -10134,41 +10547,91 @@ aix[4-9]*)
   need_lib_prefix=no
   need_version=no
   hardcode_into_libs=yes
-  if test "$host_cpu" = ia64; then
+  if test ia64 = "$host_cpu"; then
     # AIX 5 supports IA64
-    library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}'
+    library_names_spec='$libname$release$shared_ext$major $libname$release$shared_ext$versuffix $libname$shared_ext'
     shlibpath_var=LD_LIBRARY_PATH
   else
     # With GCC up to 2.95.x, collect2 would create an import file
     # for dependence libraries.  The import file would start with
-    # the line `#! .'.  This would cause the generated library to
-    # depend on `.', always an invalid library.  This was fixed in
+    # the line '#! .'.  This would cause the generated library to
+    # depend on '.', always an invalid library.  This was fixed in
     # development snapshots of GCC prior to 3.0.
     case $host_os in
       aix4 | aix4.[01] | aix4.[01].*)
       if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
 	   echo ' yes '
-	   echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then
+	   echo '#endif'; } | $CC -E - | $GREP yes > /dev/null; then
 	:
       else
 	can_build_shared=no
       fi
       ;;
     esac
-    # AIX (on Power*) has no versioning support, so currently we can not hardcode correct
+    # Using Import Files as archive members, it is possible to support
+    # filename-based versioning of shared library archives on AIX. While
+    # this would work for both with and without runtime linking, it will
+    # prevent static linking of such archives. So we do filename-based
+    # shared library versioning with .so extension only, which is used
+    # when both runtime linking and shared linking is enabled.
+    # Unfortunately, runtime linking may impact performance, so we do
+    # not want this to be the default eventually. Also, we use the
+    # versioned .so libs for executables only if there is the -brtl
+    # linker flag in LDFLAGS as well, or --with-aix-soname=svr4 only.
+    # To allow for filename-based versioning support, we need to create
+    # libNAME.so.V as an archive file, containing:
+    # *) an Import File, referring to the versioned filename of the
+    #    archive as well as the shared archive member, telling the
+    #    bitwidth (32 or 64) of that shared object, and providing the
+    #    list of exported symbols of that shared object, eventually
+    #    decorated with the 'weak' keyword
+    # *) the shared object with the F_LOADONLY flag set, to really avoid
+    #    it being seen by the linker.
+    # At run time we better use the real file rather than another symlink,
+    # but for link time we create the symlink libNAME.so -> libNAME.so.V
+
+    case $with_aix_soname,$aix_use_runtimelinking in
+    # AIX (on Power*) has no versioning support, so currently we cannot hardcode correct
     # soname into executable. Probably we can add versioning support to
     # collect2, so additional links can be useful in future.
-    if test "$aix_use_runtimelinking" = yes; then
+    aix,yes) # traditional libtool
+      dynamic_linker='AIX unversionable lib.so'
       # If using run time linking (on AIX 4.2 or later) use lib<name>.so
       # instead of lib<name>.a to let people know that these are not
       # typical AIX shared libraries.
-      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-    else
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+      ;;
+    aix,no) # traditional AIX only
+      dynamic_linker='AIX lib.a(lib.so.V)'
       # We preserve .a as extension for shared libraries through AIX4.2
       # and later when we are not doing run time linking.
-      library_names_spec='${libname}${release}.a $libname.a'
-      soname_spec='${libname}${release}${shared_ext}$major'
-    fi
+      library_names_spec='$libname$release.a $libname.a'
+      soname_spec='$libname$release$shared_ext$major'
+      ;;
+    svr4,*) # full svr4 only
+      dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o)"
+      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
+      # We do not specify a path in Import Files, so LIBPATH fires.
+      shlibpath_overrides_runpath=yes
+      ;;
+    *,yes) # both, prefer svr4
+      dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o), lib.a(lib.so.V)"
+      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
+      # unpreferred sharedlib libNAME.a needs extra handling
+      postinstall_cmds='test -n "$linkname" || linkname="$realname"~func_stripname "" ".so" "$linkname"~$install_shared_prog "$dir/$func_stripname_result.$libext" "$destdir/$func_stripname_result.$libext"~test -z "$tstripme" || test -z "$striplib" || $striplib "$destdir/$func_stripname_result.$libext"'
+      postuninstall_cmds='for n in $library_names $old_library; do :; done~func_stripname "" ".so" "$n"~test "$func_stripname_result" = "$n" || func_append rmfiles " $odir/$func_stripname_result.$libext"'
+      # We do not specify a path in Import Files, so LIBPATH fires.
+      shlibpath_overrides_runpath=yes
+      ;;
+    *,no) # both, prefer aix
+      dynamic_linker="AIX lib.a(lib.so.V), lib.so.V($shared_archive_member_spec.o)"
+      library_names_spec='$libname$release.a $libname.a'
+      soname_spec='$libname$release$shared_ext$major'
+      # unpreferred sharedlib libNAME.so.V and symlink libNAME.so need extra handling
+      postinstall_cmds='test -z "$dlname" || $install_shared_prog $dir/$dlname $destdir/$dlname~test -z "$tstripme" || test -z "$striplib" || $striplib $destdir/$dlname~test -n "$linkname" || linkname=$realname~func_stripname "" ".a" "$linkname"~(cd "$destdir" && $LN_S -f $dlname $func_stripname_result.so)'
+      postuninstall_cmds='test -z "$dlname" || func_append rmfiles " $odir/$dlname"~for n in $old_library $library_names; do :; done~func_stripname "" ".a" "$n"~func_append rmfiles " $odir/$func_stripname_result.so"'
+      ;;
+    esac
     shlibpath_var=LIBPATH
   fi
   ;;
@@ -10178,18 +10641,18 @@ amigaos*)
   powerpc)
     # Since July 2007 AmigaOS4 officially supports .so libraries.
     # When compiling the executable, add -use-dynld -Lsobjs: to the compileline.
-    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
     ;;
   m68k)
     library_names_spec='$libname.ixlibrary $libname.a'
     # Create ${libname}_ixlibrary.a entries in /sys/libs.
-    finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
+    finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
     ;;
   esac
   ;;
 
 beos*)
-  library_names_spec='${libname}${shared_ext}'
+  library_names_spec='$libname$shared_ext'
   dynamic_linker="$host_os ld.so"
   shlibpath_var=LIBRARY_PATH
   ;;
@@ -10197,8 +10660,8 @@ beos*)
 bsdi[45]*)
   version_type=linux # correct to gnu/linux during the next big refactor
   need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
   shlibpath_var=LD_LIBRARY_PATH
   sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
@@ -10210,7 +10673,7 @@ bsdi[45]*)
 
 cygwin* | mingw* | pw32* | cegcc*)
   version_type=windows
-  shrext_cmds=".dll"
+  shrext_cmds=.dll
   need_version=no
   need_lib_prefix=no
 
@@ -10219,8 +10682,8 @@ cygwin* | mingw* | pw32* | cegcc*)
     # gcc
     library_names_spec='$libname.dll.a'
     # DLL is installed to $(libdir)/../bin by postinstall_cmds
-    postinstall_cmds='base_file=`basename \${file}`~
-      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~
+    postinstall_cmds='base_file=`basename \$file`~
+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~
       dldir=$destdir/`dirname \$dlpath`~
       test -d \$dldir || mkdir -p \$dldir~
       $install_prog $dir/$dlname \$dldir/$dlname~
@@ -10236,19 +10699,19 @@ cygwin* | mingw* | pw32* | cegcc*)
     case $host_os in
     cygwin*)
       # Cygwin DLLs use 'cyg' prefix rather than 'lib'
-      #soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
-      soname_spec='`echo ${libname} | sed -e 's/^lib//'`${shared_ext}'
+      #soname_spec='`echo $libname | sed -e 's/^lib/cyg/'``echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext'
+      soname_spec='`echo $libname | sed -e 's/^lib//'`$shared_ext' # SDL customization
 
       sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/lib/w32api"
       ;;
     mingw* | cegcc*)
       # MinGW DLLs use traditional 'lib' prefix
-      #soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
-      soname_spec='`echo ${libname} | $SED -e 's/^lib//'`${shared_ext}'
+      #soname_spec='$libname`echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext'
+      soname_spec='`echo $libname | $SED -e 's/^lib//'`$shared_ext' # SDL customization
       ;;
     pw32*)
       # pw32 DLLs use 'pw' prefix rather than 'lib'
-      library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
+      library_names_spec='`echo $libname | sed -e 's/^lib/pw/'``echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
       ;;
     esac
     dynamic_linker='Win32 ld.exe'
@@ -10257,8 +10720,8 @@ cygwin* | mingw* | pw32* | cegcc*)
   *,cl*)
     # Native MSVC
     libname_spec='$name'
-    soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
-    library_names_spec='${libname}.dll.lib'
+    soname_spec='$libname`echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
+    library_names_spec='$libname.dll.lib'
 
     case $build_os in
     mingw*)
@@ -10285,7 +10748,7 @@ cygwin* | mingw* | pw32* | cegcc*)
       sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
       ;;
     *)
-      sys_lib_search_path_spec="$LIB"
+      sys_lib_search_path_spec=$LIB
       if $ECHO "$sys_lib_search_path_spec" | $GREP ';[c-zC-Z]:/' >/dev/null; then
         # It is most probably a Windows format PATH.
         sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
@@ -10298,8 +10761,8 @@ cygwin* | mingw* | pw32* | cegcc*)
     esac
 
     # DLL is installed to $(libdir)/../bin by postinstall_cmds
-    postinstall_cmds='base_file=`basename \${file}`~
-      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~
+    postinstall_cmds='base_file=`basename \$file`~
+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~
       dldir=$destdir/`dirname \$dlpath`~
       test -d \$dldir || mkdir -p \$dldir~
       $install_prog $dir/$dlname \$dldir/$dlname'
@@ -10312,7 +10775,7 @@ cygwin* | mingw* | pw32* | cegcc*)
 
   *)
     # Assume MSVC wrapper
-    library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib'
+    library_names_spec='$libname`echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext $libname.lib'
     dynamic_linker='Win32 ld.exe'
     ;;
   esac
@@ -10325,8 +10788,8 @@ darwin* | rhapsody*)
   version_type=darwin
   need_lib_prefix=no
   need_version=no
-  library_names_spec='${libname}${release}${major}$shared_ext ${libname}$shared_ext'
-  soname_spec='${libname}${release}${major}$shared_ext'
+  library_names_spec='$libname$release$major$shared_ext $libname$shared_ext'
+  soname_spec='$libname$release$major$shared_ext'
   shlibpath_overrides_runpath=yes
   shlibpath_var=DYLD_LIBRARY_PATH
   shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'
@@ -10339,12 +10802,12 @@ dgux*)
   version_type=linux # correct to gnu/linux during the next big refactor
   need_lib_prefix=no
   need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   shlibpath_var=LD_LIBRARY_PATH
   ;;
 
-freebsd* | dragonfly*)
+freebsd* | dragonfly* | midnightbsd*)
   # DragonFly does not have aout.  When/if they implement a new
   # versioning mechanism, adjust this.
   if test -x /usr/bin/objformat; then
@@ -10358,12 +10821,13 @@ freebsd* | dragonfly*)
   version_type=freebsd-$objformat
   case $version_type in
     freebsd-elf*)
-      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+      soname_spec='$libname$release$shared_ext$major'
       need_version=no
       need_lib_prefix=no
       ;;
     freebsd-*)
-      library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix'
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
       need_version=yes
       ;;
   esac
@@ -10388,26 +10852,15 @@ freebsd* | dragonfly*)
   esac
   ;;
 
-gnu*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=no
-  hardcode_into_libs=yes
-  ;;
-
 haiku*)
   version_type=linux # correct to gnu/linux during the next big refactor
   need_lib_prefix=no
   need_version=no
   dynamic_linker="$host_os runtime_loader"
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   shlibpath_var=LIBRARY_PATH
-  shlibpath_overrides_runpath=yes
+  shlibpath_overrides_runpath=no
   sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib'
   hardcode_into_libs=yes
   ;;
@@ -10425,14 +10878,15 @@ hpux9* | hpux10* | hpux11*)
     dynamic_linker="$host_os dld.so"
     shlibpath_var=LD_LIBRARY_PATH
     shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
-    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-    soname_spec='${libname}${release}${shared_ext}$major'
-    if test "X$HPUX_IA64_MODE" = X32; then
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
+    if test 32 = "$HPUX_IA64_MODE"; then
       sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
+      sys_lib_dlsearch_path_spec=/usr/lib/hpux32
     else
       sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
+      sys_lib_dlsearch_path_spec=/usr/lib/hpux64
     fi
-    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
     ;;
   hppa*64*)
     shrext_cmds='.sl'
@@ -10440,8 +10894,8 @@ hpux9* | hpux10* | hpux11*)
     dynamic_linker="$host_os dld.sl"
     shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
     shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
-    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-    soname_spec='${libname}${release}${shared_ext}$major'
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
     sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"
     sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
     ;;
@@ -10450,8 +10904,8 @@ hpux9* | hpux10* | hpux11*)
     dynamic_linker="$host_os dld.sl"
     shlibpath_var=SHLIB_PATH
     shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
-    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-    soname_spec='${libname}${release}${shared_ext}$major'
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
     ;;
   esac
   # HP-UX runs *really* slowly unless shared libraries are mode 555, ...
@@ -10464,8 +10918,8 @@ interix[3-9]*)
   version_type=linux # correct to gnu/linux during the next big refactor
   need_lib_prefix=no
   need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'
   shlibpath_var=LD_LIBRARY_PATH
   shlibpath_overrides_runpath=no
@@ -10476,7 +10930,7 @@ irix5* | irix6* | nonstopux*)
   case $host_os in
     nonstopux*) version_type=nonstopux ;;
     *)
-	if test "$lt_cv_prog_gnu_ld" = yes; then
+	if test yes = "$lt_cv_prog_gnu_ld"; then
 		version_type=linux # correct to gnu/linux during the next big refactor
 	else
 		version_type=irix
@@ -10484,8 +10938,8 @@ irix5* | irix6* | nonstopux*)
   esac
   need_lib_prefix=no
   need_version=no
-  soname_spec='${libname}${release}${shared_ext}$major'
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}'
+  soname_spec='$libname$release$shared_ext$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$release$shared_ext $libname$shared_ext'
   case $host_os in
   irix5* | nonstopux*)
     libsuff= shlibsuff=
@@ -10504,8 +10958,8 @@ irix5* | irix6* | nonstopux*)
   esac
   shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
   shlibpath_overrides_runpath=no
-  sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"
-  sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}"
+  sys_lib_search_path_spec="/usr/lib$libsuff /lib$libsuff /usr/local/lib$libsuff"
+  sys_lib_dlsearch_path_spec="/usr/lib$libsuff /lib$libsuff"
   hardcode_into_libs=yes
   ;;
 
@@ -10514,13 +10968,33 @@ linux*oldld* | linux*aout* | linux*coff*)
   dynamic_linker=no
   ;;
 
+linux*android*)
+  version_type=none # Android doesn't support versioned libraries.
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext'
+  soname_spec='$libname$release$shared_ext'
+  finish_cmds=
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+
+  # This implies no fast_install, which is unacceptable.
+  # Some rework will be needed to allow for fast_install
+  # before this can be enabled.
+  hardcode_into_libs=yes
+
+  dynamic_linker='Android linker'
+  # Don't embed -rpath directories since the linker doesn't support them.
+  hardcode_libdir_flag_spec='-L$libdir'
+  ;;
+
 # This must be glibc/ELF.
-linux* | k*bsd*-gnu | kopensolaris*-gnu)
+linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
   version_type=linux # correct to gnu/linux during the next big refactor
   need_lib_prefix=no
   need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
   shlibpath_var=LD_LIBRARY_PATH
   shlibpath_overrides_runpath=no
@@ -10564,10 +11038,18 @@ fi
   # before this can be enabled.
   hardcode_into_libs=yes
 
-  # Append ld.so.conf contents to the search path
+  # Add ABI-specific directories to the system library path.
+  sys_lib_dlsearch_path_spec="/lib64 /usr/lib64 /lib /usr/lib"
+
+  # Ideally, we could use ldconfig to report *all* directores which are
+  # searched for libraries, however this is still not possible.  Aside from not
+  # being certain /sbin/ldconfig is available, command
+  # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64,
+  # even though it is searched at run-time.  Try to do the best guess by
+  # appending ld.so.conf contents (and includes) to the search path.
   if test -f /etc/ld.so.conf; then
     lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[	 ]*hwcap[	 ]/d;s/[:,	]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '`
-    sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
+    sys_lib_dlsearch_path_spec="$sys_lib_dlsearch_path_spec $lt_ld_extra"
   fi
 
   # We used to test for /lib/ld.so.1 and disable shared libraries on
@@ -10584,12 +11066,12 @@ netbsd*)
   need_lib_prefix=no
   need_version=no
   if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
-    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
     finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
     dynamic_linker='NetBSD (a.out) ld.so'
   else
-    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
-    soname_spec='${libname}${release}${shared_ext}$major'
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
     dynamic_linker='NetBSD ld.elf_so'
   fi
   shlibpath_var=LD_LIBRARY_PATH
@@ -10599,7 +11081,7 @@ netbsd*)
 
 newsos6)
   version_type=linux # correct to gnu/linux during the next big refactor
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
   shlibpath_var=LD_LIBRARY_PATH
   shlibpath_overrides_runpath=yes
   ;;
@@ -10608,58 +11090,70 @@ newsos6)
   version_type=qnx
   need_lib_prefix=no
   need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   shlibpath_var=LD_LIBRARY_PATH
   shlibpath_overrides_runpath=no
   hardcode_into_libs=yes
   dynamic_linker='ldqnx.so'
   ;;
 
-openbsd*)
+openbsd* | bitrig*)
   version_type=sunos
-  sys_lib_dlsearch_path_spec="/usr/lib"
+  sys_lib_dlsearch_path_spec=/usr/lib
   need_lib_prefix=no
-  # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs.
-  case $host_os in
-    openbsd3.3 | openbsd3.3.*)	need_version=yes ;;
-    *)				need_version=no  ;;
-  esac
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then
+    need_version=no
+  else
+    need_version=yes
+  fi
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
   finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
   shlibpath_var=LD_LIBRARY_PATH
-  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
-    case $host_os in
-      openbsd2.[89] | openbsd2.[89].*)
-	shlibpath_overrides_runpath=no
-	;;
-      *)
-	shlibpath_overrides_runpath=yes
-	;;
-      esac
-  else
-    shlibpath_overrides_runpath=yes
-  fi
+  shlibpath_overrides_runpath=yes
   ;;
 
 os2*)
   libname_spec='$name'
-  shrext_cmds=".dll"
+  shrext_cmds=.dll
   need_lib_prefix=no
-  library_names_spec='$libname${shared_ext} $libname.a'
+  # OS/2 can only load a DLL with a base name of 8 characters or less.
+# SDL customization: removed versioning support.
+# version_type=windows
+# need_version=no
+# soname_spec='`test -n "$os2dllname" && libname="$os2dllname";
+#   v=$($ECHO $release$versuffix | tr -d .-);
+#   n=$($ECHO $libname | cut -b -$((8 - ${#v})) | tr . _);
+#   $ECHO $n$v`$shared_ext'
+  soname_spec='`test -n "$os2dllname" && libname=$os2dllname; $ECHO $libname | cut -b -8 | tr . _`$shared_ext'
+  library_names_spec='${libname}_dll.$libext'
   dynamic_linker='OS/2 ld.exe'
-  shlibpath_var=LIBPATH
+  shlibpath_var=BEGINLIBPATH
+  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
+  sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+  postinstall_cmds='base_file=`basename \$file`~
+    dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; $ECHO \$dlname'\''`~
+    dldir=$destdir/`dirname \$dlpath`~
+    test -d \$dldir || mkdir -p \$dldir~
+    $install_prog $dir/$dlname \$dldir/$dlname~
+    chmod a+x \$dldir/$dlname~
+    if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
+      eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
+    fi'
+  postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; $ECHO \$dlname'\''`~
+    dlpath=$dir/\$dldll~
+    $RM \$dlpath'
   ;;
 
 osf3* | osf4* | osf5*)
   version_type=osf
   need_lib_prefix=no
   need_version=no
-  soname_spec='${libname}${release}${shared_ext}$major'
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='$libname$release$shared_ext$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
   shlibpath_var=LD_LIBRARY_PATH
   sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
-  sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec"
+  sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
   ;;
 
 rdos*)
@@ -10670,8 +11164,8 @@ solaris*)
   version_type=linux # correct to gnu/linux during the next big refactor
   need_lib_prefix=no
   need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   shlibpath_var=LD_LIBRARY_PATH
   shlibpath_overrides_runpath=yes
   hardcode_into_libs=yes
@@ -10681,11 +11175,11 @@ solaris*)
 
 sunos4*)
   version_type=sunos
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
   finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
   shlibpath_var=LD_LIBRARY_PATH
   shlibpath_overrides_runpath=yes
-  if test "$with_gnu_ld" = yes; then
+  if test yes = "$with_gnu_ld"; then
     need_lib_prefix=no
   fi
   need_version=yes
@@ -10693,8 +11187,8 @@ sunos4*)
 
 sysv4 | sysv4.3*)
   version_type=linux # correct to gnu/linux during the next big refactor
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   shlibpath_var=LD_LIBRARY_PATH
   case $host_vendor in
     sni)
@@ -10715,24 +11209,24 @@ sysv4 | sysv4.3*)
   ;;
 
 sysv4*MP*)
-  if test -d /usr/nec ;then
+  if test -d /usr/nec; then
     version_type=linux # correct to gnu/linux during the next big refactor
-    library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}'
-    soname_spec='$libname${shared_ext}.$major'
+    library_names_spec='$libname$shared_ext.$versuffix $libname$shared_ext.$major $libname$shared_ext'
+    soname_spec='$libname$shared_ext.$major'
     shlibpath_var=LD_LIBRARY_PATH
   fi
   ;;
 
 sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
-  version_type=freebsd-elf
+  version_type=sco
   need_lib_prefix=no
   need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   shlibpath_var=LD_LIBRARY_PATH
   shlibpath_overrides_runpath=yes
   hardcode_into_libs=yes
-  if test "$with_gnu_ld" = yes; then
+  if test yes = "$with_gnu_ld"; then
     sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'
   else
     sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'
@@ -10750,7 +11244,7 @@ tpf*)
   version_type=linux # correct to gnu/linux during the next big refactor
   need_lib_prefix=no
   need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
   shlibpath_var=LD_LIBRARY_PATH
   shlibpath_overrides_runpath=no
   hardcode_into_libs=yes
@@ -10758,8 +11252,8 @@ tpf*)
 
 uts4*)
   version_type=linux # correct to gnu/linux during the next big refactor
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   shlibpath_var=LD_LIBRARY_PATH
   ;;
 
@@ -10769,20 +11263,35 @@ uts4*)
 esac
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5
 $as_echo "$dynamic_linker" >&6; }
-test "$dynamic_linker" = no && can_build_shared=no
+test no = "$dynamic_linker" && can_build_shared=no
 
 variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
-if test "$GCC" = yes; then
+if test yes = "$GCC"; then
   variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
 fi
 
-if test "${lt_cv_sys_lib_search_path_spec+set}" = set; then
-  sys_lib_search_path_spec="$lt_cv_sys_lib_search_path_spec"
+if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then
+  sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec
 fi
-if test "${lt_cv_sys_lib_dlsearch_path_spec+set}" = set; then
-  sys_lib_dlsearch_path_spec="$lt_cv_sys_lib_dlsearch_path_spec"
+
+if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then
+  sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec
 fi
 
+# remember unaugmented sys_lib_dlsearch_path content for libtool script decls...
+configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec
+
+# ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code
+func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH"
+
+# to be used as default LT_SYS_LIBRARY_PATH value in generated libtool
+configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH
+
+
+
+
+
+
 
 
 
@@ -10879,15 +11388,15 @@ $as_echo_n "checking how to hardcode library paths into programs... " >&6; }
 hardcode_action=
 if test -n "$hardcode_libdir_flag_spec" ||
    test -n "$runpath_var" ||
-   test "X$hardcode_automatic" = "Xyes" ; then
+   test yes = "$hardcode_automatic"; then
 
   # We can hardcode non-existent directories.
-  if test "$hardcode_direct" != no &&
+  if test no != "$hardcode_direct" &&
      # If the only mechanism to avoid hardcoding is shlibpath_var, we
      # have to relink, otherwise we might link with an installed library
      # when we should be linking with a yet-to-be-installed one
-     ## test "$_LT_TAGVAR(hardcode_shlibpath_var, )" != no &&
-     test "$hardcode_minus_L" != no; then
+     ## test no != "$_LT_TAGVAR(hardcode_shlibpath_var, )" &&
+     test no != "$hardcode_minus_L"; then
     # Linking always hardcodes the temporary library directory.
     hardcode_action=relink
   else
@@ -10902,12 +11411,12 @@ fi
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hardcode_action" >&5
 $as_echo "$hardcode_action" >&6; }
 
-if test "$hardcode_action" = relink ||
-   test "$inherit_rpath" = yes; then
+if test relink = "$hardcode_action" ||
+   test yes = "$inherit_rpath"; then
   # Fast installation is not supported
   enable_fast_install=no
-elif test "$shlibpath_overrides_runpath" = yes ||
-     test "$enable_shared" = no; then
+elif test yes = "$shlibpath_overrides_runpath" ||
+     test no = "$enable_shared"; then
   # Fast installation is not necessary
   enable_fast_install=needless
 fi
@@ -10917,7 +11426,7 @@ fi
 
 
 
-  if test "x$enable_dlopen" != xyes; then
+  if test yes != "$enable_dlopen"; then
   enable_dlopen=unknown
   enable_dlopen_self=unknown
   enable_dlopen_self_static=unknown
@@ -10927,23 +11436,23 @@ else
 
   case $host_os in
   beos*)
-    lt_cv_dlopen="load_add_on"
+    lt_cv_dlopen=load_add_on
     lt_cv_dlopen_libs=
     lt_cv_dlopen_self=yes
     ;;
 
   mingw* | pw32* | cegcc*)
-    lt_cv_dlopen="LoadLibrary"
+    lt_cv_dlopen=LoadLibrary
     lt_cv_dlopen_libs=
     ;;
 
   cygwin*)
-    lt_cv_dlopen="dlopen"
+    lt_cv_dlopen=dlopen
     lt_cv_dlopen_libs=
     ;;
 
   darwin*)
-  # if libdl is installed we need to link against it
+    # if libdl is installed we need to link against it
     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
 $as_echo_n "checking for dlopen in -ldl... " >&6; }
 if ${ac_cv_lib_dl_dlopen+:} false; then :
@@ -10981,10 +11490,10 @@ fi
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
 $as_echo "$ac_cv_lib_dl_dlopen" >&6; }
 if test "x$ac_cv_lib_dl_dlopen" = xyes; then :
-  lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"
+  lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl
 else
 
-    lt_cv_dlopen="dyld"
+    lt_cv_dlopen=dyld
     lt_cv_dlopen_libs=
     lt_cv_dlopen_self=yes
 
@@ -10992,10 +11501,18 @@ fi
 
     ;;
 
+  tpf*)
+    # Don't try to run any link tests for TPF.  We know it's impossible
+    # because TPF is a cross-compiler, and we know how we open DSOs.
+    lt_cv_dlopen=dlopen
+    lt_cv_dlopen_libs=
+    lt_cv_dlopen_self=no
+    ;;
+
   *)
     ac_fn_c_check_func "$LINENO" "shl_load" "ac_cv_func_shl_load"
 if test "x$ac_cv_func_shl_load" = xyes; then :
-  lt_cv_dlopen="shl_load"
+  lt_cv_dlopen=shl_load
 else
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5
 $as_echo_n "checking for shl_load in -ldld... " >&6; }
@@ -11034,11 +11551,11 @@ fi
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5
 $as_echo "$ac_cv_lib_dld_shl_load" >&6; }
 if test "x$ac_cv_lib_dld_shl_load" = xyes; then :
-  lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-ldld"
+  lt_cv_dlopen=shl_load lt_cv_dlopen_libs=-ldld
 else
   ac_fn_c_check_func "$LINENO" "dlopen" "ac_cv_func_dlopen"
 if test "x$ac_cv_func_dlopen" = xyes; then :
-  lt_cv_dlopen="dlopen"
+  lt_cv_dlopen=dlopen
 else
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
 $as_echo_n "checking for dlopen in -ldl... " >&6; }
@@ -11077,7 +11594,7 @@ fi
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
 $as_echo "$ac_cv_lib_dl_dlopen" >&6; }
 if test "x$ac_cv_lib_dl_dlopen" = xyes; then :
-  lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"
+  lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl
 else
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5
 $as_echo_n "checking for dlopen in -lsvld... " >&6; }
@@ -11116,7 +11633,7 @@ fi
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_svld_dlopen" >&5
 $as_echo "$ac_cv_lib_svld_dlopen" >&6; }
 if test "x$ac_cv_lib_svld_dlopen" = xyes; then :
-  lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"
+  lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-lsvld
 else
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5
 $as_echo_n "checking for dld_link in -ldld... " >&6; }
@@ -11155,7 +11672,7 @@ fi
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_dld_link" >&5
 $as_echo "$ac_cv_lib_dld_dld_link" >&6; }
 if test "x$ac_cv_lib_dld_dld_link" = xyes; then :
-  lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-ldld"
+  lt_cv_dlopen=dld_link lt_cv_dlopen_libs=-ldld
 fi
 
 
@@ -11176,21 +11693,21 @@ fi
     ;;
   esac
 
-  if test "x$lt_cv_dlopen" != xno; then
-    enable_dlopen=yes
-  else
+  if test no = "$lt_cv_dlopen"; then
     enable_dlopen=no
+  else
+    enable_dlopen=yes
   fi
 
   case $lt_cv_dlopen in
   dlopen)
-    save_CPPFLAGS="$CPPFLAGS"
-    test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"
+    save_CPPFLAGS=$CPPFLAGS
+    test yes = "$ac_cv_header_dlfcn_h" && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"
 
-    save_LDFLAGS="$LDFLAGS"
+    save_LDFLAGS=$LDFLAGS
     wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\"
 
-    save_LIBS="$LIBS"
+    save_LIBS=$LIBS
     LIBS="$lt_cv_dlopen_libs $LIBS"
 
     { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a program can dlopen itself" >&5
@@ -11198,7 +11715,7 @@ $as_echo_n "checking whether a program can dlopen itself... " >&6; }
 if ${lt_cv_dlopen_self+:} false; then :
   $as_echo_n "(cached) " >&6
 else
-  	  if test "$cross_compiling" = yes; then :
+  	  if test yes = "$cross_compiling"; then :
   lt_cv_dlopen_self=cross
 else
   lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
@@ -11245,9 +11762,9 @@ else
 #  endif
 #endif
 
-/* When -fvisbility=hidden is used, assume the code has been annotated
+/* When -fvisibility=hidden is used, assume the code has been annotated
    correspondingly for the symbols needed.  */
-#if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3))
+#if defined __GNUC__ && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3))
 int fnord () __attribute__((visibility("default")));
 #endif
 
@@ -11277,7 +11794,7 @@ _LT_EOF
   (eval $ac_link) 2>&5
   ac_status=$?
   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then
+  test $ac_status = 0; } && test -s "conftest$ac_exeext" 2>/dev/null; then
     (./conftest; exit; ) >&5 2>/dev/null
     lt_status=$?
     case x$lt_status in
@@ -11297,14 +11814,14 @@ fi
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self" >&5
 $as_echo "$lt_cv_dlopen_self" >&6; }
 
-    if test "x$lt_cv_dlopen_self" = xyes; then
+    if test yes = "$lt_cv_dlopen_self"; then
       wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\"
       { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a statically linked program can dlopen itself" >&5
 $as_echo_n "checking whether a statically linked program can dlopen itself... " >&6; }
 if ${lt_cv_dlopen_self_static+:} false; then :
   $as_echo_n "(cached) " >&6
 else
-  	  if test "$cross_compiling" = yes; then :
+  	  if test yes = "$cross_compiling"; then :
   lt_cv_dlopen_self_static=cross
 else
   lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
@@ -11351,9 +11868,9 @@ else
 #  endif
 #endif
 
-/* When -fvisbility=hidden is used, assume the code has been annotated
+/* When -fvisibility=hidden is used, assume the code has been annotated
    correspondingly for the symbols needed.  */
-#if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3))
+#if defined __GNUC__ && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3))
 int fnord () __attribute__((visibility("default")));
 #endif
 
@@ -11383,7 +11900,7 @@ _LT_EOF
   (eval $ac_link) 2>&5
   ac_status=$?
   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then
+  test $ac_status = 0; } && test -s "conftest$ac_exeext" 2>/dev/null; then
     (./conftest; exit; ) >&5 2>/dev/null
     lt_status=$?
     case x$lt_status in
@@ -11404,9 +11921,9 @@ fi
 $as_echo "$lt_cv_dlopen_self_static" >&6; }
     fi
 
-    CPPFLAGS="$save_CPPFLAGS"
-    LDFLAGS="$save_LDFLAGS"
-    LIBS="$save_LIBS"
+    CPPFLAGS=$save_CPPFLAGS
+    LDFLAGS=$save_LDFLAGS
+    LIBS=$save_LIBS
     ;;
   esac
 
@@ -11441,30 +11958,41 @@ striplib=
 old_striplib=
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether stripping libraries is possible" >&5
 $as_echo_n "checking whether stripping libraries is possible... " >&6; }
-if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then
-  test -z "$old_striplib" && old_striplib="$STRIP --strip-debug"
-  test -z "$striplib" && striplib="$STRIP --strip-unneeded"
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-$as_echo "yes" >&6; }
+if test -z "$STRIP"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
 else
-# FIXME - insert some real tests, host_os isn't really good enough
-  case $host_os in
-  darwin*)
-    if test -n "$STRIP" ; then
+  if $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then
+    old_striplib="$STRIP --strip-debug"
+    striplib="$STRIP --strip-unneeded"
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+  else
+    case $host_os in
+    darwin*)
+      # FIXME - insert some real tests, host_os isn't really good enough
       striplib="$STRIP -x"
       old_striplib="$STRIP -S"
       { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 $as_echo "yes" >&6; }
-    else
+      ;;
+    freebsd*)
+      if $STRIP -V 2>&1 | $GREP "elftoolchain" >/dev/null; then
+        old_striplib="$STRIP --strip-debug"
+        striplib="$STRIP --strip-unneeded"
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+      else
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+      fi
+      ;;
+    *)
       { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
-    fi
-    ;;
-  *)
-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-    ;;
-  esac
+      ;;
+    esac
+  fi
 fi
 
 
@@ -11478,7 +12006,7 @@ fi
 
 
 
-  # Report which library types will actually be built
+  # Report what library types will actually be built
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if libtool supports shared libraries" >&5
 $as_echo_n "checking if libtool supports shared libraries... " >&6; }
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $can_build_shared" >&5
@@ -11486,13 +12014,13 @@ $as_echo "$can_build_shared" >&6; }
 
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries" >&5
 $as_echo_n "checking whether to build shared libraries... " >&6; }
-  test "$can_build_shared" = "no" && enable_shared=no
+  test no = "$can_build_shared" && enable_shared=no
 
   # On AIX, shared libraries and static libraries use the same namespace, and
   # are all built from PIC.
   case $host_os in
   aix3*)
-    test "$enable_shared" = yes && enable_static=no
+    test yes = "$enable_shared" && enable_static=no
     if test -n "$RANLIB"; then
       archive_cmds="$archive_cmds~\$RANLIB \$lib"
       postinstall_cmds='$RANLIB $lib'
@@ -11500,8 +12028,12 @@ $as_echo_n "checking whether to build shared libraries... " >&6; }
     ;;
 
   aix[4-9]*)
-    if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
-      test "$enable_shared" = yes && enable_static=no
+    if test ia64 != "$host_cpu"; then
+      case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in
+      yes,aix,yes) ;;			# shared object as lib.so file only
+      yes,svr4,*) ;;			# shared object as lib.so archive member only
+      yes,*) enable_static=no ;;	# shared object in lib.a archive as well
+      esac
     fi
     ;;
   esac
@@ -11511,7 +12043,7 @@ $as_echo "$enable_shared" >&6; }
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build static libraries" >&5
 $as_echo_n "checking whether to build static libraries... " >&6; }
   # Make sure either enable_shared or enable_static is yes.
-  test "$enable_shared" = yes || enable_static=yes
+  test yes = "$enable_shared" || enable_static=yes
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_static" >&5
 $as_echo "$enable_static" >&6; }
 
@@ -11525,7 +12057,7 @@ ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
-CC="$lt_save_CC"
+CC=$lt_save_CC
 
 
 
@@ -11655,7 +12187,7 @@ objext_RC=$objext
 lt_simple_compile_test_code='sample MENU { MENUITEM "&Soup", 100, CHECKED }'
 
 # Code to be used in simple link tests
-lt_simple_link_test_code="$lt_simple_compile_test_code"
+lt_simple_link_test_code=$lt_simple_compile_test_code
 
 # ltmain only uses $CC for tagged configurations so make sure $CC is set.
 
@@ -11689,7 +12221,7 @@ $RM -r conftest*
 
 
 # Allow CC to be a program name with arguments.
-lt_save_CC="$CC"
+lt_save_CC=$CC
 lt_save_CFLAGS=$CFLAGS
 lt_save_GCC=$GCC
 GCC=
@@ -11697,15 +12229,8 @@ CC=${RC-"windres"}
 CFLAGS=
 compiler=$CC
 compiler_RC=$CC
-for cc_temp in $compiler""; do
-  case $cc_temp in
-    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
-    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
-    \-*) ;;
-    *) break;;
-  esac
-done
-cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
+func_cc_basename $compiler
+cc_basename=$func_cc_basename_result
 
 lt_cv_prog_compiler_c_o_RC=yes
 
@@ -12539,15 +13064,15 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
 func_stripname_cnf ()
 {
-  case ${2} in
-  .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
-  *)  func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
+  case $2 in
+  .*) func_stripname_result=`$ECHO "$3" | $SED "s%^$1%%; s%\\\\$2\$%%"`;;
+  *)  func_stripname_result=`$ECHO "$3" | $SED "s%^$1%%; s%$2\$%%"`;;
   esac
 } # func_stripname_cnf
 
-      if test -n "$CXX" && ( test "X$CXX" != "Xno" &&
-    ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) ||
-    (test "X$CXX" != "Xg++"))) ; then
+      if test -n "$CXX" && ( test no != "$CXX" &&
+    ( (test g++ = "$CXX" && `g++ -v >/dev/null 2>&1` ) ||
+    (test g++ != "$CXX"))); then
   ac_ext=cpp
 ac_cpp='$CXXCPP $CPPFLAGS'
 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
@@ -12726,7 +13251,7 @@ objext_CXX=$objext
 # the CXX compiler isn't working.  Some variables (like enable_shared)
 # are currently assumed to apply to all compilers on this platform,
 # and will be corrupted by setting them based on a non-working compiler.
-if test "$_lt_caught_CXX_error" != yes; then
+if test yes != "$_lt_caught_CXX_error"; then
   # Code to be used in simple compile tests
   lt_simple_compile_test_code="int some_variable = 0;"
 
@@ -12787,46 +13312,39 @@ $RM -r conftest*
   CFLAGS=$CXXFLAGS
   compiler=$CC
   compiler_CXX=$CC
-  for cc_temp in $compiler""; do
-  case $cc_temp in
-    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
-    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
-    \-*) ;;
-    *) break;;
-  esac
-done
-cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
+  func_cc_basename $compiler
+cc_basename=$func_cc_basename_result
 
 
   if test -n "$compiler"; then
     # We don't want -fno-exception when compiling C++ code, so set the
     # no_builtin_flag separately
-    if test "$GXX" = yes; then
+    if test yes = "$GXX"; then
       lt_prog_compiler_no_builtin_flag_CXX=' -fno-builtin'
     else
       lt_prog_compiler_no_builtin_flag_CXX=
     fi
 
-    if test "$GXX" = yes; then
+    if test yes = "$GXX"; then
       # Set up default GNU C++ configuration
 
 
 
 # Check whether --with-gnu-ld was given.
 if test "${with_gnu_ld+set}" = set; then :
-  withval=$with_gnu_ld; test "$withval" = no || with_gnu_ld=yes
+  withval=$with_gnu_ld; test no = "$withval" || with_gnu_ld=yes
 else
   with_gnu_ld=no
 fi
 
 ac_prog=ld
-if test "$GCC" = yes; then
+if test yes = "$GCC"; then
   # Check if gcc -print-prog-name=ld gives a path.
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5
 $as_echo_n "checking for ld used by $CC... " >&6; }
   case $host in
   *-*-mingw*)
-    # gcc leaves a trailing carriage return which upsets mingw
+    # gcc leaves a trailing carriage return, which upsets mingw
     ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
   *)
     ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
@@ -12840,7 +13358,7 @@ $as_echo_n "checking for ld used by $CC... " >&6; }
       while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do
 	ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"`
       done
-      test -z "$LD" && LD="$ac_prog"
+      test -z "$LD" && LD=$ac_prog
       ;;
   "")
     # If it fails, then pretend we aren't using GCC.
@@ -12851,7 +13369,7 @@ $as_echo_n "checking for ld used by $CC... " >&6; }
     with_gnu_ld=unknown
     ;;
   esac
-elif test "$with_gnu_ld" = yes; then
+elif test yes = "$with_gnu_ld"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5
 $as_echo_n "checking for GNU ld... " >&6; }
 else
@@ -12862,32 +13380,32 @@ if ${lt_cv_path_LD+:} false; then :
   $as_echo_n "(cached) " >&6
 else
   if test -z "$LD"; then
-  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+  lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
   for ac_dir in $PATH; do
-    IFS="$lt_save_ifs"
+    IFS=$lt_save_ifs
     test -z "$ac_dir" && ac_dir=.
     if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
-      lt_cv_path_LD="$ac_dir/$ac_prog"
+      lt_cv_path_LD=$ac_dir/$ac_prog
       # Check to see if the program is GNU ld.  I'd rather use --version,
       # but apparently some variants of GNU ld only accept -v.
       # Break only if it was the GNU/non-GNU ld that we prefer.
       case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
       *GNU* | *'with BFD'*)
-	test "$with_gnu_ld" != no && break
+	test no != "$with_gnu_ld" && break
 	;;
       *)
-	test "$with_gnu_ld" != yes && break
+	test yes != "$with_gnu_ld" && break
 	;;
       esac
     fi
   done
-  IFS="$lt_save_ifs"
+  IFS=$lt_save_ifs
 else
-  lt_cv_path_LD="$LD" # Let the user override the test with a path.
+  lt_cv_path_LD=$LD # Let the user override the test with a path.
 fi
 fi
 
-LD="$lt_cv_path_LD"
+LD=$lt_cv_path_LD
 if test -n "$LD"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LD" >&5
 $as_echo "$LD" >&6; }
@@ -12923,22 +13441,22 @@ with_gnu_ld=$lt_cv_prog_gnu_ld
 
       # Check if GNU C++ uses GNU ld as the underlying linker, since the
       # archiving commands below assume that GNU ld is being used.
-      if test "$with_gnu_ld" = yes; then
-        archive_cmds_CXX='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
-        archive_expsym_cmds_CXX='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+      if test yes = "$with_gnu_ld"; then
+        archive_cmds_CXX='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
+        archive_expsym_cmds_CXX='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
 
-        hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir'
-        export_dynamic_flag_spec_CXX='${wl}--export-dynamic'
+        hardcode_libdir_flag_spec_CXX='$wl-rpath $wl$libdir'
+        export_dynamic_flag_spec_CXX='$wl--export-dynamic'
 
         # If archive_cmds runs LD, not CC, wlarc should be empty
         # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to
         #     investigate it a little bit more. (MM)
-        wlarc='${wl}'
+        wlarc='$wl'
 
         # ancient GNU ld didn't support --whole-archive et. al.
         if eval "`$CC -print-prog-name=ld` --help 2>&1" |
 	  $GREP 'no-whole-archive' > /dev/null; then
-          whole_archive_flag_spec_CXX="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
+          whole_archive_flag_spec_CXX=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive'
         else
           whole_archive_flag_spec_CXX=
         fi
@@ -12975,18 +13493,30 @@ $as_echo_n "checking whether the $compiler linker ($LD) supports shared librarie
         ld_shlibs_CXX=no
         ;;
       aix[4-9]*)
-        if test "$host_cpu" = ia64; then
+        if test ia64 = "$host_cpu"; then
           # On IA64, the linker does run time linking by default, so we don't
           # have to do anything special.
           aix_use_runtimelinking=no
           exp_sym_flag='-Bexport'
-          no_entry_flag=""
+          no_entry_flag=
         else
           aix_use_runtimelinking=no
 
           # Test if we are trying to use run time linking or normal
           # AIX style linking. If -brtl is somewhere in LDFLAGS, we
-          # need to do runtime linking.
+          # have runtime linking enabled, and use it for executables.
+          # For shared libraries, we enable/disable runtime linking
+          # depending on the kind of the shared library created -
+          # when "with_aix_soname,aix_use_runtimelinking" is:
+          # "aix,no"   lib.a(lib.so.V) shared, rtl:no,  for executables
+          # "aix,yes"  lib.so          shared, rtl:yes, for executables
+          #            lib.a           static archive
+          # "both,no"  lib.so.V(shr.o) shared, rtl:yes
+          #            lib.a(lib.so.V) shared, rtl:no,  for executables
+          # "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables
+          #            lib.a(lib.so.V) shared, rtl:no
+          # "svr4,*"   lib.so.V(shr.o) shared, rtl:yes, for executables
+          #            lib.a           static archive
           case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*)
 	    for ld_flag in $LDFLAGS; do
 	      case $ld_flag in
@@ -12996,6 +13526,13 @@ $as_echo_n "checking whether the $compiler linker ($LD) supports shared librarie
 	        ;;
 	      esac
 	    done
+	    if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then
+	      # With aix-soname=svr4, we create the lib.so.V shared archives only,
+	      # so we don't have lib.a shared libs to link our executables.
+	      # We have to force runtime linking in this case.
+	      aix_use_runtimelinking=yes
+	      LDFLAGS="$LDFLAGS -Wl,-brtl"
+	    fi
 	    ;;
           esac
 
@@ -13014,13 +13551,21 @@ $as_echo_n "checking whether the $compiler linker ($LD) supports shared librarie
         hardcode_direct_absolute_CXX=yes
         hardcode_libdir_separator_CXX=':'
         link_all_deplibs_CXX=yes
-        file_list_spec_CXX='${wl}-f,'
+        file_list_spec_CXX='$wl-f,'
+        case $with_aix_soname,$aix_use_runtimelinking in
+        aix,*) ;;	# no import file
+        svr4,* | *,yes) # use import file
+          # The Import File defines what to hardcode.
+          hardcode_direct_CXX=no
+          hardcode_direct_absolute_CXX=no
+          ;;
+        esac
 
-        if test "$GXX" = yes; then
+        if test yes = "$GXX"; then
           case $host_os in aix4.[012]|aix4.[012].*)
           # We only want to do this on AIX 4.2 and lower, the check
           # below for broken collect2 doesn't work under 4.3+
-	  collect2name=`${CC} -print-prog-name=collect2`
+	  collect2name=`$CC -print-prog-name=collect2`
 	  if test -f "$collect2name" &&
 	     strings "$collect2name" | $GREP resolve_lib_name >/dev/null
 	  then
@@ -13038,36 +13583,44 @@ $as_echo_n "checking whether the $compiler linker ($LD) supports shared librarie
 	  fi
           esac
           shared_flag='-shared'
-	  if test "$aix_use_runtimelinking" = yes; then
-	    shared_flag="$shared_flag "'${wl}-G'
+	  if test yes = "$aix_use_runtimelinking"; then
+	    shared_flag=$shared_flag' $wl-G'
 	  fi
+	  # Need to ensure runtime linking is disabled for the traditional
+	  # shared library, or the linker may eventually find shared libraries
+	  # /with/ Import File - we do not want to mix them.
+	  shared_flag_aix='-shared'
+	  shared_flag_svr4='-shared $wl-G'
         else
           # not using gcc
-          if test "$host_cpu" = ia64; then
+          if test ia64 = "$host_cpu"; then
 	  # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
 	  # chokes on -Wl,-G. The following line is correct:
 	  shared_flag='-G'
           else
-	    if test "$aix_use_runtimelinking" = yes; then
-	      shared_flag='${wl}-G'
+	    if test yes = "$aix_use_runtimelinking"; then
+	      shared_flag='$wl-G'
 	    else
-	      shared_flag='${wl}-bM:SRE'
+	      shared_flag='$wl-bM:SRE'
 	    fi
+	    shared_flag_aix='$wl-bM:SRE'
+	    shared_flag_svr4='$wl-G'
           fi
         fi
 
-        export_dynamic_flag_spec_CXX='${wl}-bexpall'
+        export_dynamic_flag_spec_CXX='$wl-bexpall'
         # It seems that -bexpall does not export symbols beginning with
         # underscore (_), so it is better to generate a list of symbols to
 	# export.
         always_export_symbols_CXX=yes
-        if test "$aix_use_runtimelinking" = yes; then
+	if test aix,yes = "$with_aix_soname,$aix_use_runtimelinking"; then
           # Warning - without using the other runtime loading flags (-brtl),
           # -berok will link without error, but may produce a broken library.
-          allow_undefined_flag_CXX='-berok'
+          # The "-G" linker flag allows undefined symbols.
+          no_undefined_flag_CXX='-bernotok'
           # Determine the default libpath from the value encoded in an empty
           # executable.
-          if test "${lt_cv_aix_libpath+set}" = set; then
+          if test set = "${lt_cv_aix_libpath+set}"; then
   aix_libpath=$lt_cv_aix_libpath
 else
   if ${lt_cv_aix_libpath__CXX+:} false; then :
@@ -13102,7 +13655,7 @@ fi
 rm -f core conftest.err conftest.$ac_objext \
     conftest$ac_exeext conftest.$ac_ext
   if test -z "$lt_cv_aix_libpath__CXX"; then
-    lt_cv_aix_libpath__CXX="/usr/lib:/lib"
+    lt_cv_aix_libpath__CXX=/usr/lib:/lib
   fi
 
 fi
@@ -13110,18 +13663,18 @@ fi
   aix_libpath=$lt_cv_aix_libpath__CXX
 fi
 
-          hardcode_libdir_flag_spec_CXX='${wl}-blibpath:$libdir:'"$aix_libpath"
+          hardcode_libdir_flag_spec_CXX='$wl-blibpath:$libdir:'"$aix_libpath"
 
-          archive_expsym_cmds_CXX='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"
+          archive_expsym_cmds_CXX='$CC -o $output_objdir/$soname $libobjs $deplibs $wl'$no_entry_flag' $compiler_flags `if test -n "$allow_undefined_flag"; then func_echo_all "$wl$allow_undefined_flag"; else :; fi` $wl'$exp_sym_flag:\$export_symbols' '$shared_flag
         else
-          if test "$host_cpu" = ia64; then
-	    hardcode_libdir_flag_spec_CXX='${wl}-R $libdir:/usr/lib:/lib'
+          if test ia64 = "$host_cpu"; then
+	    hardcode_libdir_flag_spec_CXX='$wl-R $libdir:/usr/lib:/lib'
 	    allow_undefined_flag_CXX="-z nodefs"
-	    archive_expsym_cmds_CXX="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"
+	    archive_expsym_cmds_CXX="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\$wl$no_entry_flag"' $compiler_flags $wl$allow_undefined_flag '"\$wl$exp_sym_flag:\$export_symbols"
           else
 	    # Determine the default libpath from the value encoded in an
 	    # empty executable.
-	    if test "${lt_cv_aix_libpath+set}" = set; then
+	    if test set = "${lt_cv_aix_libpath+set}"; then
   aix_libpath=$lt_cv_aix_libpath
 else
   if ${lt_cv_aix_libpath__CXX+:} false; then :
@@ -13156,7 +13709,7 @@ fi
 rm -f core conftest.err conftest.$ac_objext \
     conftest$ac_exeext conftest.$ac_ext
   if test -z "$lt_cv_aix_libpath__CXX"; then
-    lt_cv_aix_libpath__CXX="/usr/lib:/lib"
+    lt_cv_aix_libpath__CXX=/usr/lib:/lib
   fi
 
 fi
@@ -13164,22 +13717,34 @@ fi
   aix_libpath=$lt_cv_aix_libpath__CXX
 fi
 
-	    hardcode_libdir_flag_spec_CXX='${wl}-blibpath:$libdir:'"$aix_libpath"
+	    hardcode_libdir_flag_spec_CXX='$wl-blibpath:$libdir:'"$aix_libpath"
 	    # Warning - without using the other run time loading flags,
 	    # -berok will link without error, but may produce a broken library.
-	    no_undefined_flag_CXX=' ${wl}-bernotok'
-	    allow_undefined_flag_CXX=' ${wl}-berok'
-	    if test "$with_gnu_ld" = yes; then
+	    no_undefined_flag_CXX=' $wl-bernotok'
+	    allow_undefined_flag_CXX=' $wl-berok'
+	    if test yes = "$with_gnu_ld"; then
 	      # We only use this code for GNU lds that support --whole-archive.
-	      whole_archive_flag_spec_CXX='${wl}--whole-archive$convenience ${wl}--no-whole-archive'
+	      whole_archive_flag_spec_CXX='$wl--whole-archive$convenience $wl--no-whole-archive'
 	    else
 	      # Exported symbols can be pulled into shared objects from archives
 	      whole_archive_flag_spec_CXX='$convenience'
 	    fi
 	    archive_cmds_need_lc_CXX=yes
-	    # This is similar to how AIX traditionally builds its shared
-	    # libraries.
-	    archive_expsym_cmds_CXX="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
+	    archive_expsym_cmds_CXX='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d'
+	    # -brtl affects multiple linker settings, -berok does not and is overridden later
+	    compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\\([, ]\\)%-berok\\1%g"`'
+	    if test svr4 != "$with_aix_soname"; then
+	      # This is similar to how AIX traditionally builds its shared
+	      # libraries. Need -bnortl late, we may have -brtl in LDFLAGS.
+	      archive_expsym_cmds_CXX="$archive_expsym_cmds_CXX"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname'
+	    fi
+	    if test aix != "$with_aix_soname"; then
+	      archive_expsym_cmds_CXX="$archive_expsym_cmds_CXX"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp'
+	    else
+	      # used by -dlpreopen to get the symbols
+	      archive_expsym_cmds_CXX="$archive_expsym_cmds_CXX"'~$MV  $output_objdir/$realname.d/$soname $output_objdir'
+	    fi
+	    archive_expsym_cmds_CXX="$archive_expsym_cmds_CXX"'~$RM -r $output_objdir/$realname.d'
           fi
         fi
         ;;
@@ -13189,7 +13754,7 @@ fi
 	  allow_undefined_flag_CXX=unsupported
 	  # Joseph Beckenbach <jrb3@best.com> says some releases of gcc
 	  # support --undefined.  This deserves some investigation.  FIXME
-	  archive_cmds_CXX='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+	  archive_cmds_CXX='$CC -nostart $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
 	else
 	  ld_shlibs_CXX=no
 	fi
@@ -13217,57 +13782,58 @@ fi
 	  # Tell ltmain to make .lib files, not .a files.
 	  libext=lib
 	  # Tell ltmain to make .dll files, not .so files.
-	  shrext_cmds=".dll"
+	  shrext_cmds=.dll
 	  # FIXME: Setting linknames here is a bad hack.
-	  archive_cmds_CXX='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames='
-	  archive_expsym_cmds_CXX='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
-	      $SED -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp;
-	    else
-	      $SED -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp;
-	    fi~
-	    $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
-	    linknames='
+	  archive_cmds_CXX='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames='
+	  archive_expsym_cmds_CXX='if   test DEF = "`$SED -n     -e '\''s/^[	 ]*//'\''     -e '\''/^\(;.*\)*$/d'\''     -e '\''s/^\(EXPORTS\|LIBRARY\)\([	 ].*\)*$/DEF/p'\''     -e q     $export_symbols`" ; then
+              cp "$export_symbols" "$output_objdir/$soname.def";
+              echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp";
+            else
+              $SED -e '\''s/^/-link -EXPORT:/'\'' < $export_symbols > $output_objdir/$soname.exp;
+            fi~
+            $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
+            linknames='
 	  # The linker will not automatically build a static lib if we build a DLL.
 	  # _LT_TAGVAR(old_archive_from_new_cmds, CXX)='true'
 	  enable_shared_with_static_runtimes_CXX=yes
 	  # Don't use ranlib
 	  old_postinstall_cmds_CXX='chmod 644 $oldlib'
 	  postlink_cmds_CXX='lt_outputfile="@OUTPUT@"~
-	    lt_tool_outputfile="@TOOL_OUTPUT@"~
-	    case $lt_outputfile in
-	      *.exe|*.EXE) ;;
-	      *)
-		lt_outputfile="$lt_outputfile.exe"
-		lt_tool_outputfile="$lt_tool_outputfile.exe"
-		;;
-	    esac~
-	    func_to_tool_file "$lt_outputfile"~
-	    if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then
-	      $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;
-	      $RM "$lt_outputfile.manifest";
-	    fi'
+            lt_tool_outputfile="@TOOL_OUTPUT@"~
+            case $lt_outputfile in
+              *.exe|*.EXE) ;;
+              *)
+                lt_outputfile=$lt_outputfile.exe
+                lt_tool_outputfile=$lt_tool_outputfile.exe
+                ;;
+            esac~
+            func_to_tool_file "$lt_outputfile"~
+            if test : != "$MANIFEST_TOOL" && test -f "$lt_outputfile.manifest"; then
+              $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;
+              $RM "$lt_outputfile.manifest";
+            fi'
 	  ;;
 	*)
 	  # g++
 	  # _LT_TAGVAR(hardcode_libdir_flag_spec, CXX) is actually meaningless,
 	  # as there is no search path for DLLs.
 	  hardcode_libdir_flag_spec_CXX='-L$libdir'
-	  export_dynamic_flag_spec_CXX='${wl}--export-all-symbols'
+	  export_dynamic_flag_spec_CXX='$wl--export-all-symbols'
 	  allow_undefined_flag_CXX=unsupported
 	  always_export_symbols_CXX=no
 	  enable_shared_with_static_runtimes_CXX=yes
 
 	  if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
-	    archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
-	    # If the export-symbols file already is a .def file (1st line
-	    # is EXPORTS), use it as is; otherwise, prepend...
-	    archive_expsym_cmds_CXX='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
-	      cp $export_symbols $output_objdir/$soname.def;
-	    else
-	      echo EXPORTS > $output_objdir/$soname.def;
-	      cat $export_symbols >> $output_objdir/$soname.def;
-	    fi~
-	    $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+	    archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+	    # If the export-symbols file already is a .def file, use it as
+	    # is; otherwise, prepend EXPORTS...
+	    archive_expsym_cmds_CXX='if   test DEF = "`$SED -n     -e '\''s/^[	 ]*//'\''     -e '\''/^\(;.*\)*$/d'\''     -e '\''s/^\(EXPORTS\|LIBRARY\)\([	 ].*\)*$/DEF/p'\''     -e q     $export_symbols`" ; then
+              cp $export_symbols $output_objdir/$soname.def;
+            else
+              echo EXPORTS > $output_objdir/$soname.def;
+              cat $export_symbols >> $output_objdir/$soname.def;
+            fi~
+            $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
 	  else
 	    ld_shlibs_CXX=no
 	  fi
@@ -13281,27 +13847,27 @@ fi
   hardcode_direct_CXX=no
   hardcode_automatic_CXX=yes
   hardcode_shlibpath_var_CXX=unsupported
-  if test "$lt_cv_ld_force_load" = "yes"; then
-    whole_archive_flag_spec_CXX='`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience ${wl}-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`'
+  if test yes = "$lt_cv_ld_force_load"; then
+    whole_archive_flag_spec_CXX='`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience $wl-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`'
 
   else
     whole_archive_flag_spec_CXX=''
   fi
   link_all_deplibs_CXX=yes
-  allow_undefined_flag_CXX="$_lt_dar_allow_undefined"
+  allow_undefined_flag_CXX=$_lt_dar_allow_undefined
   case $cc_basename in
-     ifort*) _lt_dar_can_shared=yes ;;
+     ifort*|nagfor*) _lt_dar_can_shared=yes ;;
      *) _lt_dar_can_shared=$GCC ;;
   esac
-  if test "$_lt_dar_can_shared" = "yes"; then
+  if test yes = "$_lt_dar_can_shared"; then
     output_verbose_link_cmd=func_echo_all
-    archive_cmds_CXX="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}"
-    module_cmds_CXX="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}"
-    archive_expsym_cmds_CXX="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}"
-    module_expsym_cmds_CXX="sed -e 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dar_export_syms}${_lt_dsymutil}"
-       if test "$lt_cv_apple_cc_single_mod" != "yes"; then
-      archive_cmds_CXX="\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dsymutil}"
-      archive_expsym_cmds_CXX="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dar_export_syms}${_lt_dsymutil}"
+    archive_cmds_CXX="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dsymutil"
+    module_cmds_CXX="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dsymutil"
+    archive_expsym_cmds_CXX="sed 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dar_export_syms$_lt_dsymutil"
+    module_expsym_cmds_CXX="sed -e 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dar_export_syms$_lt_dsymutil"
+       if test yes != "$lt_cv_apple_cc_single_mod"; then
+      archive_cmds_CXX="\$CC -r -keep_private_externs -nostdlib -o \$lib-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$lib-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring$_lt_dsymutil"
+      archive_expsym_cmds_CXX="sed 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \$lib-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$lib-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring$_lt_dar_export_syms$_lt_dsymutil"
     fi
 
   else
@@ -13310,6 +13876,35 @@ fi
 
 	;;
 
+      os2*)
+	hardcode_libdir_flag_spec_CXX='-L$libdir'
+	hardcode_minus_L_CXX=yes
+	allow_undefined_flag_CXX=unsupported
+	shrext_cmds=.dll
+	archive_cmds_CXX='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	  $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	  $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	  $ECHO EXPORTS >> $output_objdir/$libname.def~
+	  emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
+	  $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	  emximp -o $lib $output_objdir/$libname.def'
+	archive_expsym_cmds_CXX='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	  $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	  $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	  $ECHO EXPORTS >> $output_objdir/$libname.def~
+	  prefix_cmds="$SED"~
+	  if test EXPORTS = "`$SED 1q $export_symbols`"; then
+	    prefix_cmds="$prefix_cmds -e 1d";
+	  fi~
+	  prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~
+	  cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
+	  $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	  emximp -o $lib $output_objdir/$libname.def'
+	old_archive_from_new_cmds_CXX='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
+	enable_shared_with_static_runtimes_CXX=yes
+	file_list_spec_CXX='@'
+	;;
+
       dgux*)
         case $cc_basename in
           ec++*)
@@ -13338,24 +13933,21 @@ fi
         archive_cmds_need_lc_CXX=no
         ;;
 
-      freebsd* | dragonfly*)
+      freebsd* | dragonfly* | midnightbsd*)
         # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF
         # conventions
         ld_shlibs_CXX=yes
         ;;
 
-      gnu*)
-        ;;
-
       haiku*)
-        archive_cmds_CXX='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+        archive_cmds_CXX='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
         link_all_deplibs_CXX=yes
         ;;
 
       hpux9*)
-        hardcode_libdir_flag_spec_CXX='${wl}+b ${wl}$libdir'
+        hardcode_libdir_flag_spec_CXX='$wl+b $wl$libdir'
         hardcode_libdir_separator_CXX=:
-        export_dynamic_flag_spec_CXX='${wl}-E'
+        export_dynamic_flag_spec_CXX='$wl-E'
         hardcode_direct_CXX=yes
         hardcode_minus_L_CXX=yes # Not in the search PATH,
 				             # but as the default
@@ -13367,7 +13959,7 @@ fi
             ld_shlibs_CXX=no
             ;;
           aCC*)
-            archive_cmds_CXX='$RM $output_objdir/$soname~$CC -b ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+            archive_cmds_CXX='$RM $output_objdir/$soname~$CC -b $wl+b $wl$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
             # Commands to make compiler produce verbose output that lists
             # what "hidden" libraries, object files and flags are used when
             # linking a shared library.
@@ -13376,11 +13968,11 @@ fi
             # explicitly linking system object files so we need to strip them
             # from the output so that they don't get included in the library
             # dependencies.
-            output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+            output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "\-L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
             ;;
           *)
-            if test "$GXX" = yes; then
-              archive_cmds_CXX='$RM $output_objdir/$soname~$CC -shared -nostdlib $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+            if test yes = "$GXX"; then
+              archive_cmds_CXX='$RM $output_objdir/$soname~$CC -shared -nostdlib $pic_flag $wl+b $wl$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
             else
               # FIXME: insert proper C++ library support
               ld_shlibs_CXX=no
@@ -13390,15 +13982,15 @@ fi
         ;;
 
       hpux10*|hpux11*)
-        if test $with_gnu_ld = no; then
-	  hardcode_libdir_flag_spec_CXX='${wl}+b ${wl}$libdir'
+        if test no = "$with_gnu_ld"; then
+	  hardcode_libdir_flag_spec_CXX='$wl+b $wl$libdir'
 	  hardcode_libdir_separator_CXX=:
 
           case $host_cpu in
             hppa*64*|ia64*)
               ;;
             *)
-	      export_dynamic_flag_spec_CXX='${wl}-E'
+	      export_dynamic_flag_spec_CXX='$wl-E'
               ;;
           esac
         fi
@@ -13424,13 +14016,13 @@ fi
           aCC*)
 	    case $host_cpu in
 	      hppa*64*)
-	        archive_cmds_CXX='$CC -b ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	        archive_cmds_CXX='$CC -b $wl+h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
 	        ;;
 	      ia64*)
-	        archive_cmds_CXX='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	        archive_cmds_CXX='$CC -b $wl+h $wl$soname $wl+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
 	        ;;
 	      *)
-	        archive_cmds_CXX='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	        archive_cmds_CXX='$CC -b $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
 	        ;;
 	    esac
 	    # Commands to make compiler produce verbose output that lists
@@ -13441,20 +14033,20 @@ fi
 	    # explicitly linking system object files so we need to strip them
 	    # from the output so that they don't get included in the library
 	    # dependencies.
-	    output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+	    output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP "\-L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
 	    ;;
           *)
-	    if test "$GXX" = yes; then
-	      if test $with_gnu_ld = no; then
+	    if test yes = "$GXX"; then
+	      if test no = "$with_gnu_ld"; then
 	        case $host_cpu in
 	          hppa*64*)
-	            archive_cmds_CXX='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	            archive_cmds_CXX='$CC -shared -nostdlib -fPIC $wl+h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
 	            ;;
 	          ia64*)
-	            archive_cmds_CXX='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	            archive_cmds_CXX='$CC -shared -nostdlib $pic_flag $wl+h $wl$soname $wl+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
 	            ;;
 	          *)
-	            archive_cmds_CXX='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	            archive_cmds_CXX='$CC -shared -nostdlib $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
 	            ;;
 	        esac
 	      fi
@@ -13469,22 +14061,22 @@ fi
       interix[3-9]*)
 	hardcode_direct_CXX=no
 	hardcode_shlibpath_var_CXX=no
-	hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir'
-	export_dynamic_flag_spec_CXX='${wl}-E'
+	hardcode_libdir_flag_spec_CXX='$wl-rpath,$libdir'
+	export_dynamic_flag_spec_CXX='$wl-E'
 	# Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
 	# Instead, shared libraries are loaded at an image base (0x10000000 by
 	# default) and relocated if they conflict, which is a slow very memory
 	# consuming and fragmenting process.  To avoid this, we pick a random,
 	# 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
 	# time.  Moving up from 0x10000000 also allows more sbrk(2) space.
-	archive_cmds_CXX='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
-	archive_expsym_cmds_CXX='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+	archive_cmds_CXX='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+	archive_expsym_cmds_CXX='sed "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--retain-symbols-file,$output_objdir/$soname.expsym $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
 	;;
       irix5* | irix6*)
         case $cc_basename in
           CC*)
 	    # SGI C++
-	    archive_cmds_CXX='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
+	    archive_cmds_CXX='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
 
 	    # Archives containing C++ object files must be created using
 	    # "CC -ar", where "CC" is the IRIX C++ compiler.  This is
@@ -13493,22 +14085,22 @@ fi
 	    old_archive_cmds_CXX='$CC -ar -WR,-u -o $oldlib $oldobjs'
 	    ;;
           *)
-	    if test "$GXX" = yes; then
-	      if test "$with_gnu_ld" = no; then
-	        archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+	    if test yes = "$GXX"; then
+	      if test no = "$with_gnu_ld"; then
+	        archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
 	      else
-	        archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` -o $lib'
+	        archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` -o $lib'
 	      fi
 	    fi
 	    link_all_deplibs_CXX=yes
 	    ;;
         esac
-        hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir'
+        hardcode_libdir_flag_spec_CXX='$wl-rpath $wl$libdir'
         hardcode_libdir_separator_CXX=:
         inherit_rpath_CXX=yes
         ;;
 
-      linux* | k*bsd*-gnu | kopensolaris*-gnu)
+      linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
         case $cc_basename in
           KCC*)
 	    # Kuck and Associates, Inc. (KAI) C++ Compiler
@@ -13516,8 +14108,8 @@ fi
 	    # KCC will only create a shared library if the output file
 	    # ends with ".so" (or ".sl" for HP-UX), so rename the library
 	    # to its proper name (with version) after linking.
-	    archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
-	    archive_expsym_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib ${wl}-retain-symbols-file,$export_symbols; mv \$templib $lib'
+	    archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\$tempext\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
+	    archive_expsym_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\$tempext\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib $wl-retain-symbols-file,$export_symbols; mv \$templib $lib'
 	    # Commands to make compiler produce verbose output that lists
 	    # what "hidden" libraries, object files and flags are used when
 	    # linking a shared library.
@@ -13526,10 +14118,10 @@ fi
 	    # explicitly linking system object files so we need to strip them
 	    # from the output so that they don't get included in the library
 	    # dependencies.
-	    output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+	    output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
 
-	    hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir'
-	    export_dynamic_flag_spec_CXX='${wl}--export-dynamic'
+	    hardcode_libdir_flag_spec_CXX='$wl-rpath,$libdir'
+	    export_dynamic_flag_spec_CXX='$wl--export-dynamic'
 
 	    # Archives containing C++ object files must be created using
 	    # "CC -Bstatic", where "CC" is the KAI C++ compiler.
@@ -13543,59 +14135,59 @@ fi
 	    # earlier do not add the objects themselves.
 	    case `$CC -V 2>&1` in
 	      *"Version 7."*)
-	        archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
-		archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+	        archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
+		archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
 		;;
 	      *)  # Version 8.0 or newer
 	        tmp_idyn=
 	        case $host_cpu in
 		  ia64*) tmp_idyn=' -i_dynamic';;
 		esac
-	        archive_cmds_CXX='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
-		archive_expsym_cmds_CXX='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+	        archive_cmds_CXX='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+		archive_expsym_cmds_CXX='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
 		;;
 	    esac
 	    archive_cmds_need_lc_CXX=no
-	    hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir'
-	    export_dynamic_flag_spec_CXX='${wl}--export-dynamic'
-	    whole_archive_flag_spec_CXX='${wl}--whole-archive$convenience ${wl}--no-whole-archive'
+	    hardcode_libdir_flag_spec_CXX='$wl-rpath,$libdir'
+	    export_dynamic_flag_spec_CXX='$wl--export-dynamic'
+	    whole_archive_flag_spec_CXX='$wl--whole-archive$convenience $wl--no-whole-archive'
 	    ;;
           pgCC* | pgcpp*)
             # Portland Group C++ compiler
 	    case `$CC -V` in
 	    *pgCC\ [1-5].* | *pgcpp\ [1-5].*)
 	      prelink_cmds_CXX='tpldir=Template.dir~
-		rm -rf $tpldir~
-		$CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~
-		compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"'
+               rm -rf $tpldir~
+               $CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~
+               compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"'
 	      old_archive_cmds_CXX='tpldir=Template.dir~
-		rm -rf $tpldir~
-		$CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~
-		$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~
-		$RANLIB $oldlib'
+                rm -rf $tpldir~
+                $CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~
+                $AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~
+                $RANLIB $oldlib'
 	      archive_cmds_CXX='tpldir=Template.dir~
-		rm -rf $tpldir~
-		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
-		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+                rm -rf $tpldir~
+                $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+                $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
 	      archive_expsym_cmds_CXX='tpldir=Template.dir~
-		rm -rf $tpldir~
-		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
-		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
+                rm -rf $tpldir~
+                $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+                $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
 	      ;;
 	    *) # Version 6 and above use weak symbols
-	      archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
-	      archive_expsym_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
+	      archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
+	      archive_expsym_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
 	      ;;
 	    esac
 
-	    hardcode_libdir_flag_spec_CXX='${wl}--rpath ${wl}$libdir'
-	    export_dynamic_flag_spec_CXX='${wl}--export-dynamic'
-	    whole_archive_flag_spec_CXX='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
+	    hardcode_libdir_flag_spec_CXX='$wl--rpath $wl$libdir'
+	    export_dynamic_flag_spec_CXX='$wl--export-dynamic'
+	    whole_archive_flag_spec_CXX='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
             ;;
 	  cxx*)
 	    # Compaq C++
-	    archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
-	    archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname  -o $lib ${wl}-retain-symbols-file $wl$export_symbols'
+	    archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
+	    archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname  -o $lib $wl-retain-symbols-file $wl$export_symbols'
 
 	    runpath_var=LD_RUN_PATH
 	    hardcode_libdir_flag_spec_CXX='-rpath $libdir'
@@ -13609,18 +14201,18 @@ fi
 	    # explicitly linking system object files so we need to strip them
 	    # from the output so that they don't get included in the library
 	    # dependencies.
-	    output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "X$list" | $Xsed'
+	    output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "X$list" | $Xsed'
 	    ;;
 	  xl* | mpixl* | bgxl*)
 	    # IBM XL 8.0 on PPC, with GNU ld
-	    hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir'
-	    export_dynamic_flag_spec_CXX='${wl}--export-dynamic'
-	    archive_cmds_CXX='$CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
-	    if test "x$supports_anon_versioning" = xyes; then
+	    hardcode_libdir_flag_spec_CXX='$wl-rpath $wl$libdir'
+	    export_dynamic_flag_spec_CXX='$wl--export-dynamic'
+	    archive_cmds_CXX='$CC -qmkshrobj $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	    if test yes = "$supports_anon_versioning"; then
 	      archive_expsym_cmds_CXX='echo "{ global:" > $output_objdir/$libname.ver~
-		cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
-		echo "local: *; };" >> $output_objdir/$libname.ver~
-		$CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
+                cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+                echo "local: *; };" >> $output_objdir/$libname.ver~
+                $CC -qmkshrobj $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-version-script $wl$output_objdir/$libname.ver -o $lib'
 	    fi
 	    ;;
 	  *)
@@ -13628,10 +14220,10 @@ fi
 	    *Sun\ C*)
 	      # Sun C++ 5.9
 	      no_undefined_flag_CXX=' -zdefs'
-	      archive_cmds_CXX='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
-	      archive_expsym_cmds_CXX='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file ${wl}$export_symbols'
+	      archive_cmds_CXX='$CC -G$allow_undefined_flag -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	      archive_expsym_cmds_CXX='$CC -G$allow_undefined_flag -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-retain-symbols-file $wl$export_symbols'
 	      hardcode_libdir_flag_spec_CXX='-R$libdir'
-	      whole_archive_flag_spec_CXX='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
+	      whole_archive_flag_spec_CXX='$wl--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
 	      compiler_needs_object_CXX=yes
 
 	      # Not sure whether something based on
@@ -13689,22 +14281,17 @@ fi
         ld_shlibs_CXX=yes
 	;;
 
-      openbsd2*)
-        # C++ shared libraries are fairly broken
-	ld_shlibs_CXX=no
-	;;
-
-      openbsd*)
+      openbsd* | bitrig*)
 	if test -f /usr/libexec/ld.so; then
 	  hardcode_direct_CXX=yes
 	  hardcode_shlibpath_var_CXX=no
 	  hardcode_direct_absolute_CXX=yes
 	  archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
-	  hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir'
-	  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
-	    archive_expsym_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file,$export_symbols -o $lib'
-	    export_dynamic_flag_spec_CXX='${wl}-E'
-	    whole_archive_flag_spec_CXX="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
+	  hardcode_libdir_flag_spec_CXX='$wl-rpath,$libdir'
+	  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`"; then
+	    archive_expsym_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-retain-symbols-file,$export_symbols -o $lib'
+	    export_dynamic_flag_spec_CXX='$wl-E'
+	    whole_archive_flag_spec_CXX=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive'
 	  fi
 	  output_verbose_link_cmd=func_echo_all
 	else
@@ -13720,9 +14307,9 @@ fi
 	    # KCC will only create a shared library if the output file
 	    # ends with ".so" (or ".sl" for HP-UX), so rename the library
 	    # to its proper name (with version) after linking.
-	    archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo "$lib" | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
+	    archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo "$lib" | $SED -e "s/\$tempext\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
 
-	    hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir'
+	    hardcode_libdir_flag_spec_CXX='$wl-rpath,$libdir'
 	    hardcode_libdir_separator_CXX=:
 
 	    # Archives containing C++ object files must be created using
@@ -13740,17 +14327,17 @@ fi
           cxx*)
 	    case $host in
 	      osf3*)
-	        allow_undefined_flag_CXX=' ${wl}-expect_unresolved ${wl}\*'
-	        archive_cmds_CXX='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && func_echo_all "${wl}-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
-	        hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir'
+	        allow_undefined_flag_CXX=' $wl-expect_unresolved $wl\*'
+	        archive_cmds_CXX='$CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $soname `test -n "$verstring" && func_echo_all "$wl-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
+	        hardcode_libdir_flag_spec_CXX='$wl-rpath $wl$libdir'
 		;;
 	      *)
 	        allow_undefined_flag_CXX=' -expect_unresolved \*'
-	        archive_cmds_CXX='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
+	        archive_cmds_CXX='$CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
 	        archive_expsym_cmds_CXX='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~
-	          echo "-hidden">> $lib.exp~
-	          $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname ${wl}-input ${wl}$lib.exp  `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~
-	          $RM $lib.exp'
+                  echo "-hidden">> $lib.exp~
+                  $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname $wl-input $wl$lib.exp  `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib~
+                  $RM $lib.exp'
 	        hardcode_libdir_flag_spec_CXX='-rpath $libdir'
 		;;
 	    esac
@@ -13765,21 +14352,21 @@ fi
 	    # explicitly linking system object files so we need to strip them
 	    # from the output so that they don't get included in the library
 	    # dependencies.
-	    output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+	    output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
 	    ;;
 	  *)
-	    if test "$GXX" = yes && test "$with_gnu_ld" = no; then
-	      allow_undefined_flag_CXX=' ${wl}-expect_unresolved ${wl}\*'
+	    if test yes,no = "$GXX,$with_gnu_ld"; then
+	      allow_undefined_flag_CXX=' $wl-expect_unresolved $wl\*'
 	      case $host in
 	        osf3*)
-	          archive_cmds_CXX='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+	          archive_cmds_CXX='$CC -shared -nostdlib $allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
 		  ;;
 	        *)
-	          archive_cmds_CXX='$CC -shared $pic_flag -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+	          archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-msym $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
 		  ;;
 	      esac
 
-	      hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir'
+	      hardcode_libdir_flag_spec_CXX='$wl-rpath $wl$libdir'
 	      hardcode_libdir_separator_CXX=:
 
 	      # Commands to make compiler produce verbose output that lists
@@ -13825,9 +14412,9 @@ fi
 	    # Sun C++ 4.2, 5.x and Centerline C++
             archive_cmds_need_lc_CXX=yes
 	    no_undefined_flag_CXX=' -zdefs'
-	    archive_cmds_CXX='$CC -G${allow_undefined_flag}  -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	    archive_cmds_CXX='$CC -G$allow_undefined_flag -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
 	    archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
-	      $CC -G${allow_undefined_flag} ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
+              $CC -G$allow_undefined_flag $wl-M $wl$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
 
 	    hardcode_libdir_flag_spec_CXX='-R$libdir'
 	    hardcode_shlibpath_var_CXX=no
@@ -13835,7 +14422,7 @@ fi
 	      solaris2.[0-5] | solaris2.[0-5].*) ;;
 	      *)
 		# The compiler driver will combine and reorder linker options,
-		# but understands `-z linker_flag'.
+		# but understands '-z linker_flag'.
 	        # Supported since Solaris 2.6 (maybe 2.5.1?)
 		whole_archive_flag_spec_CXX='-z allextract$convenience -z defaultextract'
 	        ;;
@@ -13852,30 +14439,30 @@ fi
 	    ;;
           gcx*)
 	    # Green Hills C++ Compiler
-	    archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
+	    archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib'
 
 	    # The C++ compiler must be used to create the archive.
 	    old_archive_cmds_CXX='$CC $LDFLAGS -archive -o $oldlib $oldobjs'
 	    ;;
           *)
 	    # GNU C++ compiler with Solaris linker
-	    if test "$GXX" = yes && test "$with_gnu_ld" = no; then
-	      no_undefined_flag_CXX=' ${wl}-z ${wl}defs'
+	    if test yes,no = "$GXX,$with_gnu_ld"; then
+	      no_undefined_flag_CXX=' $wl-z ${wl}defs'
 	      if $CC --version | $GREP -v '^2\.7' > /dev/null; then
-	        archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
+	        archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib'
 	        archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
-		  $CC -shared $pic_flag -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
+                  $CC -shared $pic_flag -nostdlib $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
 
 	        # Commands to make compiler produce verbose output that lists
 	        # what "hidden" libraries, object files and flags are used when
 	        # linking a shared library.
 	        output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
 	      else
-	        # g++ 2.7 appears to require `-G' NOT `-shared' on this
+	        # g++ 2.7 appears to require '-G' NOT '-shared' on this
 	        # platform.
-	        archive_cmds_CXX='$CC -G -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
+	        archive_cmds_CXX='$CC -G -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib'
 	        archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
-		  $CC -G -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
+                  $CC -G -nostdlib $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
 
 	        # Commands to make compiler produce verbose output that lists
 	        # what "hidden" libraries, object files and flags are used when
@@ -13883,11 +14470,11 @@ fi
 	        output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
 	      fi
 
-	      hardcode_libdir_flag_spec_CXX='${wl}-R $wl$libdir'
+	      hardcode_libdir_flag_spec_CXX='$wl-R $wl$libdir'
 	      case $host_os in
 		solaris2.[0-5] | solaris2.[0-5].*) ;;
 		*)
-		  whole_archive_flag_spec_CXX='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract'
+		  whole_archive_flag_spec_CXX='$wl-z ${wl}allextract$convenience $wl-z ${wl}defaultextract'
 		  ;;
 	      esac
 	    fi
@@ -13896,52 +14483,52 @@ fi
         ;;
 
     sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*)
-      no_undefined_flag_CXX='${wl}-z,text'
+      no_undefined_flag_CXX='$wl-z,text'
       archive_cmds_need_lc_CXX=no
       hardcode_shlibpath_var_CXX=no
       runpath_var='LD_RUN_PATH'
 
       case $cc_basename in
         CC*)
-	  archive_cmds_CXX='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	  archive_expsym_cmds_CXX='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  archive_cmds_CXX='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  archive_expsym_cmds_CXX='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
 	  ;;
 	*)
-	  archive_cmds_CXX='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	  archive_expsym_cmds_CXX='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  archive_cmds_CXX='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  archive_expsym_cmds_CXX='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
 	  ;;
       esac
       ;;
 
       sysv5* | sco3.2v5* | sco5v6*)
-	# Note: We can NOT use -z defs as we might desire, because we do not
+	# Note: We CANNOT use -z defs as we might desire, because we do not
 	# link with -lc, and that would cause any symbols used from libc to
 	# always be unresolved, which means just about no library would
 	# ever link correctly.  If we're not using GNU ld we use -z text
 	# though, which does catch some bad symbols but isn't as heavy-handed
 	# as -z defs.
-	no_undefined_flag_CXX='${wl}-z,text'
-	allow_undefined_flag_CXX='${wl}-z,nodefs'
+	no_undefined_flag_CXX='$wl-z,text'
+	allow_undefined_flag_CXX='$wl-z,nodefs'
 	archive_cmds_need_lc_CXX=no
 	hardcode_shlibpath_var_CXX=no
-	hardcode_libdir_flag_spec_CXX='${wl}-R,$libdir'
+	hardcode_libdir_flag_spec_CXX='$wl-R,$libdir'
 	hardcode_libdir_separator_CXX=':'
 	link_all_deplibs_CXX=yes
-	export_dynamic_flag_spec_CXX='${wl}-Bexport'
+	export_dynamic_flag_spec_CXX='$wl-Bexport'
 	runpath_var='LD_RUN_PATH'
 
 	case $cc_basename in
           CC*)
-	    archive_cmds_CXX='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	    archive_expsym_cmds_CXX='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	    archive_cmds_CXX='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	    archive_expsym_cmds_CXX='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
 	    old_archive_cmds_CXX='$CC -Tprelink_objects $oldobjs~
-	      '"$old_archive_cmds_CXX"
+              '"$old_archive_cmds_CXX"
 	    reload_cmds_CXX='$CC -Tprelink_objects $reload_objs~
-	      '"$reload_cmds_CXX"
+              '"$reload_cmds_CXX"
 	    ;;
 	  *)
-	    archive_cmds_CXX='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	    archive_expsym_cmds_CXX='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	    archive_cmds_CXX='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	    archive_expsym_cmds_CXX='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
 	    ;;
 	esac
       ;;
@@ -13973,10 +14560,10 @@ fi
 
     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5
 $as_echo "$ld_shlibs_CXX" >&6; }
-    test "$ld_shlibs_CXX" = no && can_build_shared=no
+    test no = "$ld_shlibs_CXX" && can_build_shared=no
 
-    GCC_CXX="$GXX"
-    LD_CXX="$LD"
+    GCC_CXX=$GXX
+    LD_CXX=$LD
 
     ## CAVEAT EMPTOR:
     ## There is no encapsulation within the following macros, do not change
@@ -14020,13 +14607,14 @@ if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
   pre_test_object_deps_done=no
 
   for p in `eval "$output_verbose_link_cmd"`; do
-    case ${prev}${p} in
+    case $prev$p in
 
     -L* | -R* | -l*)
        # Some compilers place space between "-{L,R}" and the path.
        # Remove the space.
-       if test $p = "-L" ||
-          test $p = "-R"; then
+       if test x-L = "x$p" ||
+          test x-R = "x$p" ||
+          test x-l = "x$p"; then
 	 prev=$p
 	 continue
        fi
@@ -14042,16 +14630,16 @@ if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
        case $p in
        =*) func_stripname_cnf '=' '' "$p"; p=$lt_sysroot$func_stripname_result ;;
        esac
-       if test "$pre_test_object_deps_done" = no; then
-	 case ${prev} in
+       if test no = "$pre_test_object_deps_done"; then
+	 case $prev in
 	 -L | -R)
 	   # Internal compiler library paths should come after those
 	   # provided the user.  The postdeps already come after the
 	   # user supplied libs so there is no need to process them.
 	   if test -z "$compiler_lib_search_path_CXX"; then
-	     compiler_lib_search_path_CXX="${prev}${p}"
+	     compiler_lib_search_path_CXX=$prev$p
 	   else
-	     compiler_lib_search_path_CXX="${compiler_lib_search_path_CXX} ${prev}${p}"
+	     compiler_lib_search_path_CXX="${compiler_lib_search_path_CXX} $prev$p"
 	   fi
 	   ;;
 	 # The "-l" case would never come before the object being
@@ -14059,9 +14647,9 @@ if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
 	 esac
        else
 	 if test -z "$postdeps_CXX"; then
-	   postdeps_CXX="${prev}${p}"
+	   postdeps_CXX=$prev$p
 	 else
-	   postdeps_CXX="${postdeps_CXX} ${prev}${p}"
+	   postdeps_CXX="${postdeps_CXX} $prev$p"
 	 fi
        fi
        prev=
@@ -14076,15 +14664,15 @@ if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
 	 continue
        fi
 
-       if test "$pre_test_object_deps_done" = no; then
+       if test no = "$pre_test_object_deps_done"; then
 	 if test -z "$predep_objects_CXX"; then
-	   predep_objects_CXX="$p"
+	   predep_objects_CXX=$p
 	 else
 	   predep_objects_CXX="$predep_objects_CXX $p"
 	 fi
        else
 	 if test -z "$postdep_objects_CXX"; then
-	   postdep_objects_CXX="$p"
+	   postdep_objects_CXX=$p
 	 else
 	   postdep_objects_CXX="$postdep_objects_CXX $p"
 	 fi
@@ -14114,51 +14702,6 @@ interix[3-9]*)
   postdep_objects_CXX=
   postdeps_CXX=
   ;;
-
-linux*)
-  case `$CC -V 2>&1 | sed 5q` in
-  *Sun\ C*)
-    # Sun C++ 5.9
-
-    # The more standards-conforming stlport4 library is
-    # incompatible with the Cstd library. Avoid specifying
-    # it if it's in CXXFLAGS. Ignore libCrun as
-    # -library=stlport4 depends on it.
-    case " $CXX $CXXFLAGS " in
-    *" -library=stlport4 "*)
-      solaris_use_stlport4=yes
-      ;;
-    esac
-
-    if test "$solaris_use_stlport4" != yes; then
-      postdeps_CXX='-library=Cstd -library=Crun'
-    fi
-    ;;
-  esac
-  ;;
-
-solaris*)
-  case $cc_basename in
-  CC* | sunCC*)
-    # The more standards-conforming stlport4 library is
-    # incompatible with the Cstd library. Avoid specifying
-    # it if it's in CXXFLAGS. Ignore libCrun as
-    # -library=stlport4 depends on it.
-    case " $CXX $CXXFLAGS " in
-    *" -library=stlport4 "*)
-      solaris_use_stlport4=yes
-      ;;
-    esac
-
-    # Adding this requires a known-good setup of shared libraries for
-    # Sun compiler versions before 5.6, else PIC objects from an old
-    # archive will be linked into the output, leading to subtle bugs.
-    if test "$solaris_use_stlport4" != yes; then
-      postdeps_CXX='-library=Cstd -library=Crun'
-    fi
-    ;;
-  esac
-  ;;
 esac
 
 
@@ -14167,7 +14710,7 @@ case " $postdeps_CXX " in
 esac
  compiler_lib_search_dirs_CXX=
 if test -n "${compiler_lib_search_path_CXX}"; then
- compiler_lib_search_dirs_CXX=`echo " ${compiler_lib_search_path_CXX}" | ${SED} -e 's! -L! !g' -e 's!^ !!'`
+ compiler_lib_search_dirs_CXX=`echo " ${compiler_lib_search_path_CXX}" | $SED -e 's! -L! !g' -e 's!^ !!'`
 fi
 
 
@@ -14206,17 +14749,18 @@ lt_prog_compiler_static_CXX=
 
 
   # C++ specific cases for pic, static, wl, etc.
-  if test "$GXX" = yes; then
+  if test yes = "$GXX"; then
     lt_prog_compiler_wl_CXX='-Wl,'
     lt_prog_compiler_static_CXX='-static'
 
     case $host_os in
     aix*)
       # All AIX code is PIC.
-      if test "$host_cpu" = ia64; then
+      if test ia64 = "$host_cpu"; then
 	# AIX 5 now supports IA64 processor
 	lt_prog_compiler_static_CXX='-Bstatic'
       fi
+      lt_prog_compiler_pic_CXX='-fPIC'
       ;;
 
     amigaos*)
@@ -14227,8 +14771,8 @@ lt_prog_compiler_static_CXX=
         ;;
       m68k)
             # FIXME: we need at least 68020 code to build shared libraries, but
-            # adding the `-m68020' flag to GCC prevents building anything better,
-            # like `-m68040'.
+            # adding the '-m68020' flag to GCC prevents building anything better,
+            # like '-m68040'.
             lt_prog_compiler_pic_CXX='-m68020 -resident32 -malways-restore-a4'
         ;;
       esac
@@ -14243,6 +14787,11 @@ lt_prog_compiler_static_CXX=
       # Although the cygwin gcc ignores -fPIC, still need this for old-style
       # (--disable-auto-import) libraries
       lt_prog_compiler_pic_CXX='-DDLL_EXPORT'
+      case $host_os in
+      os2*)
+	lt_prog_compiler_static_CXX='$wl-static'
+	;;
+      esac
       ;;
     darwin* | rhapsody*)
       # PIC is the default on this platform
@@ -14292,7 +14841,7 @@ lt_prog_compiler_static_CXX=
     case $host_os in
       aix[4-9]*)
 	# All AIX code is PIC.
-	if test "$host_cpu" = ia64; then
+	if test ia64 = "$host_cpu"; then
 	  # AIX 5 now supports IA64 processor
 	  lt_prog_compiler_static_CXX='-Bstatic'
 	else
@@ -14325,21 +14874,21 @@ lt_prog_compiler_static_CXX=
 	    ;;
 	esac
 	;;
-      freebsd* | dragonfly*)
+      freebsd* | dragonfly* | midnightbsd*)
 	# FreeBSD uses GNU C++
 	;;
       hpux9* | hpux10* | hpux11*)
 	case $cc_basename in
 	  CC*)
 	    lt_prog_compiler_wl_CXX='-Wl,'
-	    lt_prog_compiler_static_CXX='${wl}-a ${wl}archive'
-	    if test "$host_cpu" != ia64; then
+	    lt_prog_compiler_static_CXX='$wl-a ${wl}archive'
+	    if test ia64 != "$host_cpu"; then
 	      lt_prog_compiler_pic_CXX='+Z'
 	    fi
 	    ;;
 	  aCC*)
 	    lt_prog_compiler_wl_CXX='-Wl,'
-	    lt_prog_compiler_static_CXX='${wl}-a ${wl}archive'
+	    lt_prog_compiler_static_CXX='$wl-a ${wl}archive'
 	    case $host_cpu in
 	    hppa*64*|ia64*)
 	      # +Z the default
@@ -14368,7 +14917,7 @@ lt_prog_compiler_static_CXX=
 	    ;;
 	esac
 	;;
-      linux* | k*bsd*-gnu | kopensolaris*-gnu)
+      linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
 	case $cc_basename in
 	  KCC*)
 	    # KAI C++ Compiler
@@ -14376,7 +14925,7 @@ lt_prog_compiler_static_CXX=
 	    lt_prog_compiler_pic_CXX='-fPIC'
 	    ;;
 	  ecpc* )
-	    # old Intel C++ for x86_64 which still supported -KPIC.
+	    # old Intel C++ for x86_64, which still supported -KPIC.
 	    lt_prog_compiler_wl_CXX='-Wl,'
 	    lt_prog_compiler_pic_CXX='-KPIC'
 	    lt_prog_compiler_static_CXX='-static'
@@ -14521,7 +15070,7 @@ lt_prog_compiler_static_CXX=
   fi
 
 case $host_os in
-  # For platforms which do not support PIC, -DPIC is meaningless:
+  # For platforms that do not support PIC, -DPIC is meaningless:
   *djgpp*)
     lt_prog_compiler_pic_CXX=
     ;;
@@ -14553,7 +15102,7 @@ else
   lt_cv_prog_compiler_pic_works_CXX=no
    ac_outfile=conftest.$ac_objext
    echo "$lt_simple_compile_test_code" > conftest.$ac_ext
-   lt_compiler_flag="$lt_prog_compiler_pic_CXX -DPIC"
+   lt_compiler_flag="$lt_prog_compiler_pic_CXX -DPIC"  ## exclude from sc_useless_quotes_in_assignment
    # Insert the option either (1) after the last *FLAGS variable, or
    # (2) before a word containing "conftest.", or (3) at the end.
    # Note that $ac_compile itself does not contain backslashes and begins
@@ -14583,7 +15132,7 @@ fi
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works_CXX" >&5
 $as_echo "$lt_cv_prog_compiler_pic_works_CXX" >&6; }
 
-if test x"$lt_cv_prog_compiler_pic_works_CXX" = xyes; then
+if test yes = "$lt_cv_prog_compiler_pic_works_CXX"; then
     case $lt_prog_compiler_pic_CXX in
      "" | " "*) ;;
      *) lt_prog_compiler_pic_CXX=" $lt_prog_compiler_pic_CXX" ;;
@@ -14609,7 +15158,7 @@ if ${lt_cv_prog_compiler_static_works_CXX+:} false; then :
   $as_echo_n "(cached) " >&6
 else
   lt_cv_prog_compiler_static_works_CXX=no
-   save_LDFLAGS="$LDFLAGS"
+   save_LDFLAGS=$LDFLAGS
    LDFLAGS="$LDFLAGS $lt_tmp_static_flag"
    echo "$lt_simple_link_test_code" > conftest.$ac_ext
    if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
@@ -14628,13 +15177,13 @@ else
      fi
    fi
    $RM -r conftest*
-   LDFLAGS="$save_LDFLAGS"
+   LDFLAGS=$save_LDFLAGS
 
 fi
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works_CXX" >&5
 $as_echo "$lt_cv_prog_compiler_static_works_CXX" >&6; }
 
-if test x"$lt_cv_prog_compiler_static_works_CXX" = xyes; then
+if test yes = "$lt_cv_prog_compiler_static_works_CXX"; then
     :
 else
     lt_prog_compiler_static_CXX=
@@ -14748,8 +15297,8 @@ $as_echo "$lt_cv_prog_compiler_c_o_CXX" >&6; }
 
 
 
-hard_links="nottested"
-if test "$lt_cv_prog_compiler_c_o_CXX" = no && test "$need_locks" != no; then
+hard_links=nottested
+if test no = "$lt_cv_prog_compiler_c_o_CXX" && test no != "$need_locks"; then
   # do not overwrite the value of need_locks provided by the user
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5
 $as_echo_n "checking if we can lock with hard links... " >&6; }
@@ -14761,9 +15310,9 @@ $as_echo_n "checking if we can lock with hard links... " >&6; }
   ln conftest.a conftest.b 2>/dev/null && hard_links=no
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5
 $as_echo "$hard_links" >&6; }
-  if test "$hard_links" = no; then
-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5
-$as_echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;}
+  if test no = "$hard_links"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&5
+$as_echo "$as_me: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&2;}
     need_locks=warn
   fi
 else
@@ -14780,17 +15329,21 @@ $as_echo_n "checking whether the $compiler linker ($LD) supports shared librarie
   case $host_os in
   aix[4-9]*)
     # If we're using GNU nm, then we don't want the "-C" option.
-    # -C means demangle to AIX nm, but means don't demangle with GNU nm
-    # Also, AIX nm treats weak defined symbols like other global defined
-    # symbols, whereas GNU nm marks them as "W".
+    # -C means demangle to GNU nm, but means don't demangle to AIX nm.
+    # Without the "-l" option, or with the "-B" option, AIX nm treats
+    # weak defined symbols like other global defined symbols, whereas
+    # GNU nm marks them as "W".
+    # While the 'weak' keyword is ignored in the Export File, we need
+    # it in the Import File for the 'aix-soname' feature, so we have
+    # to replace the "-B" option with "-P" for AIX nm.
     if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
-      export_symbols_cmds_CXX='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+      export_symbols_cmds_CXX='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols'
     else
-      export_symbols_cmds_CXX='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+      export_symbols_cmds_CXX='`func_echo_all $NM | $SED -e '\''s/B\([^B]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "L") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && (substr(\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols'
     fi
     ;;
   pw32*)
-    export_symbols_cmds_CXX="$ltdll_cmds"
+    export_symbols_cmds_CXX=$ltdll_cmds
     ;;
   cygwin* | mingw* | cegcc*)
     case $cc_basename in
@@ -14810,7 +15363,7 @@ $as_echo_n "checking whether the $compiler linker ($LD) supports shared librarie
 
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5
 $as_echo "$ld_shlibs_CXX" >&6; }
-test "$ld_shlibs_CXX" = no && can_build_shared=no
+test no = "$ld_shlibs_CXX" && can_build_shared=no
 
 with_gnu_ld_CXX=$with_gnu_ld
 
@@ -14827,7 +15380,7 @@ x|xyes)
   # Assume -lc should be added
   archive_cmds_need_lc_CXX=yes
 
-  if test "$enable_shared" = yes && test "$GCC" = yes; then
+  if test yes,yes = "$GCC,$enable_shared"; then
     case $archive_cmds_CXX in
     *'~'*)
       # FIXME: we may have to deal with multi-command sequences.
@@ -14955,7 +15508,7 @@ $as_echo_n "checking dynamic linker characteristics... " >&6; }
 library_names_spec=
 libname_spec='lib$name'
 soname_spec=
-shrext_cmds=".so"
+shrext_cmds=.so
 postinstall_cmds=
 postuninstall_cmds=
 finish_cmds=
@@ -14972,14 +15525,16 @@ hardcode_into_libs=no
 # flags to be left without arguments
 need_version=unknown
 
+
+
 case $host_os in
 aix3*)
   version_type=linux # correct to gnu/linux during the next big refactor
-  library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname.a'
   shlibpath_var=LIBPATH
 
   # AIX 3 has no versioning support, so we append a major version to the name.
-  soname_spec='${libname}${release}${shared_ext}$major'
+  soname_spec='$libname$release$shared_ext$major'
   ;;
 
 aix[4-9]*)
@@ -14987,41 +15542,91 @@ aix[4-9]*)
   need_lib_prefix=no
   need_version=no
   hardcode_into_libs=yes
-  if test "$host_cpu" = ia64; then
+  if test ia64 = "$host_cpu"; then
     # AIX 5 supports IA64
-    library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}'
+    library_names_spec='$libname$release$shared_ext$major $libname$release$shared_ext$versuffix $libname$shared_ext'
     shlibpath_var=LD_LIBRARY_PATH
   else
     # With GCC up to 2.95.x, collect2 would create an import file
     # for dependence libraries.  The import file would start with
-    # the line `#! .'.  This would cause the generated library to
-    # depend on `.', always an invalid library.  This was fixed in
+    # the line '#! .'.  This would cause the generated library to
+    # depend on '.', always an invalid library.  This was fixed in
     # development snapshots of GCC prior to 3.0.
     case $host_os in
       aix4 | aix4.[01] | aix4.[01].*)
       if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
 	   echo ' yes '
-	   echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then
+	   echo '#endif'; } | $CC -E - | $GREP yes > /dev/null; then
 	:
       else
 	can_build_shared=no
       fi
       ;;
     esac
-    # AIX (on Power*) has no versioning support, so currently we can not hardcode correct
+    # Using Import Files as archive members, it is possible to support
+    # filename-based versioning of shared library archives on AIX. While
+    # this would work for both with and without runtime linking, it will
+    # prevent static linking of such archives. So we do filename-based
+    # shared library versioning with .so extension only, which is used
+    # when both runtime linking and shared linking is enabled.
+    # Unfortunately, runtime linking may impact performance, so we do
+    # not want this to be the default eventually. Also, we use the
+    # versioned .so libs for executables only if there is the -brtl
+    # linker flag in LDFLAGS as well, or --with-aix-soname=svr4 only.
+    # To allow for filename-based versioning support, we need to create
+    # libNAME.so.V as an archive file, containing:
+    # *) an Import File, referring to the versioned filename of the
+    #    archive as well as the shared archive member, telling the
+    #    bitwidth (32 or 64) of that shared object, and providing the
+    #    list of exported symbols of that shared object, eventually
+    #    decorated with the 'weak' keyword
+    # *) the shared object with the F_LOADONLY flag set, to really avoid
+    #    it being seen by the linker.
+    # At run time we better use the real file rather than another symlink,
+    # but for link time we create the symlink libNAME.so -> libNAME.so.V
+
+    case $with_aix_soname,$aix_use_runtimelinking in
+    # AIX (on Power*) has no versioning support, so currently we cannot hardcode correct
     # soname into executable. Probably we can add versioning support to
     # collect2, so additional links can be useful in future.
-    if test "$aix_use_runtimelinking" = yes; then
+    aix,yes) # traditional libtool
+      dynamic_linker='AIX unversionable lib.so'
       # If using run time linking (on AIX 4.2 or later) use lib<name>.so
       # instead of lib<name>.a to let people know that these are not
       # typical AIX shared libraries.
-      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-    else
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+      ;;
+    aix,no) # traditional AIX only
+      dynamic_linker='AIX lib.a(lib.so.V)'
       # We preserve .a as extension for shared libraries through AIX4.2
       # and later when we are not doing run time linking.
-      library_names_spec='${libname}${release}.a $libname.a'
-      soname_spec='${libname}${release}${shared_ext}$major'
-    fi
+      library_names_spec='$libname$release.a $libname.a'
+      soname_spec='$libname$release$shared_ext$major'
+      ;;
+    svr4,*) # full svr4 only
+      dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o)"
+      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
+      # We do not specify a path in Import Files, so LIBPATH fires.
+      shlibpath_overrides_runpath=yes
+      ;;
+    *,yes) # both, prefer svr4
+      dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o), lib.a(lib.so.V)"
+      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
+      # unpreferred sharedlib libNAME.a needs extra handling
+      postinstall_cmds='test -n "$linkname" || linkname="$realname"~func_stripname "" ".so" "$linkname"~$install_shared_prog "$dir/$func_stripname_result.$libext" "$destdir/$func_stripname_result.$libext"~test -z "$tstripme" || test -z "$striplib" || $striplib "$destdir/$func_stripname_result.$libext"'
+      postuninstall_cmds='for n in $library_names $old_library; do :; done~func_stripname "" ".so" "$n"~test "$func_stripname_result" = "$n" || func_append rmfiles " $odir/$func_stripname_result.$libext"'
+      # We do not specify a path in Import Files, so LIBPATH fires.
+      shlibpath_overrides_runpath=yes
+      ;;
+    *,no) # both, prefer aix
+      dynamic_linker="AIX lib.a(lib.so.V), lib.so.V($shared_archive_member_spec.o)"
+      library_names_spec='$libname$release.a $libname.a'
+      soname_spec='$libname$release$shared_ext$major'
+      # unpreferred sharedlib libNAME.so.V and symlink libNAME.so need extra handling
+      postinstall_cmds='test -z "$dlname" || $install_shared_prog $dir/$dlname $destdir/$dlname~test -z "$tstripme" || test -z "$striplib" || $striplib $destdir/$dlname~test -n "$linkname" || linkname=$realname~func_stripname "" ".a" "$linkname"~(cd "$destdir" && $LN_S -f $dlname $func_stripname_result.so)'
+      postuninstall_cmds='test -z "$dlname" || func_append rmfiles " $odir/$dlname"~for n in $old_library $library_names; do :; done~func_stripname "" ".a" "$n"~func_append rmfiles " $odir/$func_stripname_result.so"'
+      ;;
+    esac
     shlibpath_var=LIBPATH
   fi
   ;;
@@ -15031,18 +15636,18 @@ amigaos*)
   powerpc)
     # Since July 2007 AmigaOS4 officially supports .so libraries.
     # When compiling the executable, add -use-dynld -Lsobjs: to the compileline.
-    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
     ;;
   m68k)
     library_names_spec='$libname.ixlibrary $libname.a'
     # Create ${libname}_ixlibrary.a entries in /sys/libs.
-    finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
+    finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
     ;;
   esac
   ;;
 
 beos*)
-  library_names_spec='${libname}${shared_ext}'
+  library_names_spec='$libname$shared_ext'
   dynamic_linker="$host_os ld.so"
   shlibpath_var=LIBRARY_PATH
   ;;
@@ -15050,8 +15655,8 @@ beos*)
 bsdi[45]*)
   version_type=linux # correct to gnu/linux during the next big refactor
   need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
   shlibpath_var=LD_LIBRARY_PATH
   sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
@@ -15063,7 +15668,7 @@ bsdi[45]*)
 
 cygwin* | mingw* | pw32* | cegcc*)
   version_type=windows
-  shrext_cmds=".dll"
+  shrext_cmds=.dll
   need_version=no
   need_lib_prefix=no
 
@@ -15072,8 +15677,8 @@ cygwin* | mingw* | pw32* | cegcc*)
     # gcc
     library_names_spec='$libname.dll.a'
     # DLL is installed to $(libdir)/../bin by postinstall_cmds
-    postinstall_cmds='base_file=`basename \${file}`~
-      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~
+    postinstall_cmds='base_file=`basename \$file`~
+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~
       dldir=$destdir/`dirname \$dlpath`~
       test -d \$dldir || mkdir -p \$dldir~
       $install_prog $dir/$dlname \$dldir/$dlname~
@@ -15089,18 +15694,18 @@ cygwin* | mingw* | pw32* | cegcc*)
     case $host_os in
     cygwin*)
       # Cygwin DLLs use 'cyg' prefix rather than 'lib'
-      #soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
-      soname_spec='`echo ${libname} | sed -e 's/^lib//'`${shared_ext}'
+      #soname_spec='`echo $libname | sed -e 's/^lib/cyg/'``echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext'
+      soname_spec='`echo $libname | sed -e 's/^lib//'`$shared_ext' # SDL customization
 
       ;;
     mingw* | cegcc*)
       # MinGW DLLs use traditional 'lib' prefix
-      #soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
-      soname_spec='`echo ${libname} | $SED -e 's/^lib//'`${shared_ext}'
+      #soname_spec='$libname`echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext'
+      soname_spec='`echo $libname | $SED -e 's/^lib//'`$shared_ext' # SDL customization
       ;;
     pw32*)
       # pw32 DLLs use 'pw' prefix rather than 'lib'
-      library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
+      library_names_spec='`echo $libname | sed -e 's/^lib/pw/'``echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
       ;;
     esac
     dynamic_linker='Win32 ld.exe'
@@ -15109,8 +15714,8 @@ cygwin* | mingw* | pw32* | cegcc*)
   *,cl*)
     # Native MSVC
     libname_spec='$name'
-    soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
-    library_names_spec='${libname}.dll.lib'
+    soname_spec='$libname`echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
+    library_names_spec='$libname.dll.lib'
 
     case $build_os in
     mingw*)
@@ -15137,7 +15742,7 @@ cygwin* | mingw* | pw32* | cegcc*)
       sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
       ;;
     *)
-      sys_lib_search_path_spec="$LIB"
+      sys_lib_search_path_spec=$LIB
       if $ECHO "$sys_lib_search_path_spec" | $GREP ';[c-zC-Z]:/' >/dev/null; then
         # It is most probably a Windows format PATH.
         sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
@@ -15150,8 +15755,8 @@ cygwin* | mingw* | pw32* | cegcc*)
     esac
 
     # DLL is installed to $(libdir)/../bin by postinstall_cmds
-    postinstall_cmds='base_file=`basename \${file}`~
-      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~
+    postinstall_cmds='base_file=`basename \$file`~
+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~
       dldir=$destdir/`dirname \$dlpath`~
       test -d \$dldir || mkdir -p \$dldir~
       $install_prog $dir/$dlname \$dldir/$dlname'
@@ -15164,7 +15769,7 @@ cygwin* | mingw* | pw32* | cegcc*)
 
   *)
     # Assume MSVC wrapper
-    library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib'
+    library_names_spec='$libname`echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext $libname.lib'
     dynamic_linker='Win32 ld.exe'
     ;;
   esac
@@ -15177,8 +15782,8 @@ darwin* | rhapsody*)
   version_type=darwin
   need_lib_prefix=no
   need_version=no
-  library_names_spec='${libname}${release}${major}$shared_ext ${libname}$shared_ext'
-  soname_spec='${libname}${release}${major}$shared_ext'
+  library_names_spec='$libname$release$major$shared_ext $libname$shared_ext'
+  soname_spec='$libname$release$major$shared_ext'
   shlibpath_overrides_runpath=yes
   shlibpath_var=DYLD_LIBRARY_PATH
   shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'
@@ -15190,12 +15795,12 @@ dgux*)
   version_type=linux # correct to gnu/linux during the next big refactor
   need_lib_prefix=no
   need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   shlibpath_var=LD_LIBRARY_PATH
   ;;
 
-freebsd* | dragonfly*)
+freebsd* | dragonfly* | midnightbsd*)
   # DragonFly does not have aout.  When/if they implement a new
   # versioning mechanism, adjust this.
   if test -x /usr/bin/objformat; then
@@ -15209,12 +15814,13 @@ freebsd* | dragonfly*)
   version_type=freebsd-$objformat
   case $version_type in
     freebsd-elf*)
-      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+      soname_spec='$libname$release$shared_ext$major'
       need_version=no
       need_lib_prefix=no
       ;;
     freebsd-*)
-      library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix'
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
       need_version=yes
       ;;
   esac
@@ -15239,26 +15845,15 @@ freebsd* | dragonfly*)
   esac
   ;;
 
-gnu*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=no
-  hardcode_into_libs=yes
-  ;;
-
 haiku*)
   version_type=linux # correct to gnu/linux during the next big refactor
   need_lib_prefix=no
   need_version=no
   dynamic_linker="$host_os runtime_loader"
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   shlibpath_var=LIBRARY_PATH
-  shlibpath_overrides_runpath=yes
+  shlibpath_overrides_runpath=no
   sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib'
   hardcode_into_libs=yes
   ;;
@@ -15276,14 +15871,15 @@ hpux9* | hpux10* | hpux11*)
     dynamic_linker="$host_os dld.so"
     shlibpath_var=LD_LIBRARY_PATH
     shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
-    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-    soname_spec='${libname}${release}${shared_ext}$major'
-    if test "X$HPUX_IA64_MODE" = X32; then
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
+    if test 32 = "$HPUX_IA64_MODE"; then
       sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
+      sys_lib_dlsearch_path_spec=/usr/lib/hpux32
     else
       sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
+      sys_lib_dlsearch_path_spec=/usr/lib/hpux64
     fi
-    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
     ;;
   hppa*64*)
     shrext_cmds='.sl'
@@ -15291,8 +15887,8 @@ hpux9* | hpux10* | hpux11*)
     dynamic_linker="$host_os dld.sl"
     shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
     shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
-    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-    soname_spec='${libname}${release}${shared_ext}$major'
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
     sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"
     sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
     ;;
@@ -15301,8 +15897,8 @@ hpux9* | hpux10* | hpux11*)
     dynamic_linker="$host_os dld.sl"
     shlibpath_var=SHLIB_PATH
     shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
-    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-    soname_spec='${libname}${release}${shared_ext}$major'
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
     ;;
   esac
   # HP-UX runs *really* slowly unless shared libraries are mode 555, ...
@@ -15315,8 +15911,8 @@ interix[3-9]*)
   version_type=linux # correct to gnu/linux during the next big refactor
   need_lib_prefix=no
   need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'
   shlibpath_var=LD_LIBRARY_PATH
   shlibpath_overrides_runpath=no
@@ -15327,7 +15923,7 @@ irix5* | irix6* | nonstopux*)
   case $host_os in
     nonstopux*) version_type=nonstopux ;;
     *)
-	if test "$lt_cv_prog_gnu_ld" = yes; then
+	if test yes = "$lt_cv_prog_gnu_ld"; then
 		version_type=linux # correct to gnu/linux during the next big refactor
 	else
 		version_type=irix
@@ -15335,8 +15931,8 @@ irix5* | irix6* | nonstopux*)
   esac
   need_lib_prefix=no
   need_version=no
-  soname_spec='${libname}${release}${shared_ext}$major'
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}'
+  soname_spec='$libname$release$shared_ext$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$release$shared_ext $libname$shared_ext'
   case $host_os in
   irix5* | nonstopux*)
     libsuff= shlibsuff=
@@ -15355,8 +15951,8 @@ irix5* | irix6* | nonstopux*)
   esac
   shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
   shlibpath_overrides_runpath=no
-  sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"
-  sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}"
+  sys_lib_search_path_spec="/usr/lib$libsuff /lib$libsuff /usr/local/lib$libsuff"
+  sys_lib_dlsearch_path_spec="/usr/lib$libsuff /lib$libsuff"
   hardcode_into_libs=yes
   ;;
 
@@ -15365,13 +15961,33 @@ linux*oldld* | linux*aout* | linux*coff*)
   dynamic_linker=no
   ;;
 
+linux*android*)
+  version_type=none # Android doesn't support versioned libraries.
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext'
+  soname_spec='$libname$release$shared_ext'
+  finish_cmds=
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+
+  # This implies no fast_install, which is unacceptable.
+  # Some rework will be needed to allow for fast_install
+  # before this can be enabled.
+  hardcode_into_libs=yes
+
+  dynamic_linker='Android linker'
+  # Don't embed -rpath directories since the linker doesn't support them.
+  hardcode_libdir_flag_spec_CXX='-L$libdir'
+  ;;
+
 # This must be glibc/ELF.
-linux* | k*bsd*-gnu | kopensolaris*-gnu)
+linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
   version_type=linux # correct to gnu/linux during the next big refactor
   need_lib_prefix=no
   need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
   shlibpath_var=LD_LIBRARY_PATH
   shlibpath_overrides_runpath=no
@@ -15415,10 +16031,18 @@ fi
   # before this can be enabled.
   hardcode_into_libs=yes
 
-  # Append ld.so.conf contents to the search path
+  # Add ABI-specific directories to the system library path.
+  sys_lib_dlsearch_path_spec="/lib64 /usr/lib64 /lib /usr/lib"
+
+  # Ideally, we could use ldconfig to report *all* directores which are
+  # searched for libraries, however this is still not possible.  Aside from not
+  # being certain /sbin/ldconfig is available, command
+  # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64,
+  # even though it is searched at run-time.  Try to do the best guess by
+  # appending ld.so.conf contents (and includes) to the search path.
   if test -f /etc/ld.so.conf; then
     lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[	 ]*hwcap[	 ]/d;s/[:,	]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '`
-    sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
+    sys_lib_dlsearch_path_spec="$sys_lib_dlsearch_path_spec $lt_ld_extra"
   fi
 
   # We used to test for /lib/ld.so.1 and disable shared libraries on
@@ -15435,12 +16059,12 @@ netbsd*)
   need_lib_prefix=no
   need_version=no
   if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
-    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
     finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
     dynamic_linker='NetBSD (a.out) ld.so'
   else
-    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
-    soname_spec='${libname}${release}${shared_ext}$major'
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
     dynamic_linker='NetBSD ld.elf_so'
   fi
   shlibpath_var=LD_LIBRARY_PATH
@@ -15450,7 +16074,7 @@ netbsd*)
 
 newsos6)
   version_type=linux # correct to gnu/linux during the next big refactor
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
   shlibpath_var=LD_LIBRARY_PATH
   shlibpath_overrides_runpath=yes
   ;;
@@ -15459,58 +16083,70 @@ newsos6)
   version_type=qnx
   need_lib_prefix=no
   need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   shlibpath_var=LD_LIBRARY_PATH
   shlibpath_overrides_runpath=no
   hardcode_into_libs=yes
   dynamic_linker='ldqnx.so'
   ;;
 
-openbsd*)
+openbsd* | bitrig*)
   version_type=sunos
-  sys_lib_dlsearch_path_spec="/usr/lib"
+  sys_lib_dlsearch_path_spec=/usr/lib
   need_lib_prefix=no
-  # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs.
-  case $host_os in
-    openbsd3.3 | openbsd3.3.*)	need_version=yes ;;
-    *)				need_version=no  ;;
-  esac
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then
+    need_version=no
+  else
+    need_version=yes
+  fi
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
   finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
   shlibpath_var=LD_LIBRARY_PATH
-  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
-    case $host_os in
-      openbsd2.[89] | openbsd2.[89].*)
-	shlibpath_overrides_runpath=no
-	;;
-      *)
-	shlibpath_overrides_runpath=yes
-	;;
-      esac
-  else
-    shlibpath_overrides_runpath=yes
-  fi
+  shlibpath_overrides_runpath=yes
   ;;
 
 os2*)
   libname_spec='$name'
-  shrext_cmds=".dll"
+  shrext_cmds=.dll
   need_lib_prefix=no
-  library_names_spec='$libname${shared_ext} $libname.a'
+  # OS/2 can only load a DLL with a base name of 8 characters or less.
+# SDL customization: removed versioning support.
+# version_type=windows
+# need_version=no
+# soname_spec='`test -n "$os2dllname" && libname="$os2dllname";
+#   v=$($ECHO $release$versuffix | tr -d .-);
+#   n=$($ECHO $libname | cut -b -$((8 - ${#v})) | tr . _);
+#   $ECHO $n$v`$shared_ext'
+  soname_spec='`test -n "$os2dllname" && libname=$os2dllname; $ECHO $libname | cut -b -8 | tr . _`$shared_ext'
+  library_names_spec='${libname}_dll.$libext'
   dynamic_linker='OS/2 ld.exe'
-  shlibpath_var=LIBPATH
+  shlibpath_var=BEGINLIBPATH
+  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
+  sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+  postinstall_cmds='base_file=`basename \$file`~
+    dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; $ECHO \$dlname'\''`~
+    dldir=$destdir/`dirname \$dlpath`~
+    test -d \$dldir || mkdir -p \$dldir~
+    $install_prog $dir/$dlname \$dldir/$dlname~
+    chmod a+x \$dldir/$dlname~
+    if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
+      eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
+    fi'
+  postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; $ECHO \$dlname'\''`~
+    dlpath=$dir/\$dldll~
+    $RM \$dlpath'
   ;;
 
 osf3* | osf4* | osf5*)
   version_type=osf
   need_lib_prefix=no
   need_version=no
-  soname_spec='${libname}${release}${shared_ext}$major'
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='$libname$release$shared_ext$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
   shlibpath_var=LD_LIBRARY_PATH
   sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
-  sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec"
+  sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
   ;;
 
 rdos*)
@@ -15521,8 +16157,8 @@ solaris*)
   version_type=linux # correct to gnu/linux during the next big refactor
   need_lib_prefix=no
   need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   shlibpath_var=LD_LIBRARY_PATH
   shlibpath_overrides_runpath=yes
   hardcode_into_libs=yes
@@ -15532,11 +16168,11 @@ solaris*)
 
 sunos4*)
   version_type=sunos
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
   finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
   shlibpath_var=LD_LIBRARY_PATH
   shlibpath_overrides_runpath=yes
-  if test "$with_gnu_ld" = yes; then
+  if test yes = "$with_gnu_ld"; then
     need_lib_prefix=no
   fi
   need_version=yes
@@ -15544,8 +16180,8 @@ sunos4*)
 
 sysv4 | sysv4.3*)
   version_type=linux # correct to gnu/linux during the next big refactor
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   shlibpath_var=LD_LIBRARY_PATH
   case $host_vendor in
     sni)
@@ -15566,24 +16202,24 @@ sysv4 | sysv4.3*)
   ;;
 
 sysv4*MP*)
-  if test -d /usr/nec ;then
+  if test -d /usr/nec; then
     version_type=linux # correct to gnu/linux during the next big refactor
-    library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}'
-    soname_spec='$libname${shared_ext}.$major'
+    library_names_spec='$libname$shared_ext.$versuffix $libname$shared_ext.$major $libname$shared_ext'
+    soname_spec='$libname$shared_ext.$major'
     shlibpath_var=LD_LIBRARY_PATH
   fi
   ;;
 
 sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
-  version_type=freebsd-elf
+  version_type=sco
   need_lib_prefix=no
   need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   shlibpath_var=LD_LIBRARY_PATH
   shlibpath_overrides_runpath=yes
   hardcode_into_libs=yes
-  if test "$with_gnu_ld" = yes; then
+  if test yes = "$with_gnu_ld"; then
     sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'
   else
     sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'
@@ -15601,7 +16237,7 @@ tpf*)
   version_type=linux # correct to gnu/linux during the next big refactor
   need_lib_prefix=no
   need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
   shlibpath_var=LD_LIBRARY_PATH
   shlibpath_overrides_runpath=no
   hardcode_into_libs=yes
@@ -15609,8 +16245,8 @@ tpf*)
 
 uts4*)
   version_type=linux # correct to gnu/linux during the next big refactor
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
   shlibpath_var=LD_LIBRARY_PATH
   ;;
 
@@ -15620,20 +16256,32 @@ uts4*)
 esac
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5
 $as_echo "$dynamic_linker" >&6; }
-test "$dynamic_linker" = no && can_build_shared=no
+test no = "$dynamic_linker" && can_build_shared=no
 
 variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
-if test "$GCC" = yes; then
+if test yes = "$GCC"; then
   variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
 fi
 
-if test "${lt_cv_sys_lib_search_path_spec+set}" = set; then
-  sys_lib_search_path_spec="$lt_cv_sys_lib_search_path_spec"
+if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then
+  sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec
 fi
-if test "${lt_cv_sys_lib_dlsearch_path_spec+set}" = set; then
-  sys_lib_dlsearch_path_spec="$lt_cv_sys_lib_dlsearch_path_spec"
+
+if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then
+  sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec
 fi
 
+# remember unaugmented sys_lib_dlsearch_path content for libtool script decls...
+configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec
+
+# ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code
+func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH"
+
+# to be used as default LT_SYS_LIBRARY_PATH value in generated libtool
+configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH
+
+
+
 
 
 
@@ -15676,15 +16324,15 @@ $as_echo_n "checking how to hardcode library paths into programs... " >&6; }
 hardcode_action_CXX=
 if test -n "$hardcode_libdir_flag_spec_CXX" ||
    test -n "$runpath_var_CXX" ||
-   test "X$hardcode_automatic_CXX" = "Xyes" ; then
+   test yes = "$hardcode_automatic_CXX"; then
 
   # We can hardcode non-existent directories.
-  if test "$hardcode_direct_CXX" != no &&
+  if test no != "$hardcode_direct_CXX" &&
      # If the only mechanism to avoid hardcoding is shlibpath_var, we
      # have to relink, otherwise we might link with an installed library
      # when we should be linking with a yet-to-be-installed one
-     ## test "$_LT_TAGVAR(hardcode_shlibpath_var, CXX)" != no &&
-     test "$hardcode_minus_L_CXX" != no; then
+     ## test no != "$_LT_TAGVAR(hardcode_shlibpath_var, CXX)" &&
+     test no != "$hardcode_minus_L_CXX"; then
     # Linking always hardcodes the temporary library directory.
     hardcode_action_CXX=relink
   else
@@ -15699,12 +16347,12 @@ fi
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hardcode_action_CXX" >&5
 $as_echo "$hardcode_action_CXX" >&6; }
 
-if test "$hardcode_action_CXX" = relink ||
-   test "$inherit_rpath_CXX" = yes; then
+if test relink = "$hardcode_action_CXX" ||
+   test yes = "$inherit_rpath_CXX"; then
   # Fast installation is not supported
   enable_fast_install=no
-elif test "$shlibpath_overrides_runpath" = yes ||
-     test "$enable_shared" = no; then
+elif test yes = "$shlibpath_overrides_runpath" ||
+     test no = "$enable_shared"; then
   # Fast installation is not necessary
   enable_fast_install=needless
 fi
@@ -15727,7 +16375,7 @@ fi
   lt_cv_path_LD=$lt_save_path_LD
   lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld
   lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld
-fi # test "$_lt_caught_CXX_error" != yes
+fi # test yes != "$_lt_caught_CXX_error"
 
 ac_ext=c
 ac_cpp='$CPP $CPPFLAGS'
@@ -15866,6 +16514,7 @@ fi
 
 
 
+
 if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
 	if test -n "$ac_tool_prefix"; then
   # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
@@ -15981,7 +16630,7 @@ $as_echo "no" >&6; }
 fi
 
 case "$host" in
-    *-*-mingw32*)
+    *-*-mingw*)
         # Except on msys, where make can't handle full pathnames (bug 1972)
         ;;
     *)
@@ -15999,11 +16648,24 @@ case "$host" in
         ;;
 esac
 
+case "$host" in
+    *-*-haiku*)
+        LINKER='$(CXX)'
+        LIBTOOLLINKERTAG='CXX'
+        ;;
+    *)
+        LINKER='$(CC)'
+        LIBTOOLLINKERTAG='CC'
+        ;;
+esac
+
+
+
 if test x$srcdir != x.; then
     INCLUDE="-Iinclude $INCLUDE"
-elif test -d .hg; then
+elif test -d .git; then
     as_fn_error $? "
-*** When building from Mercurial you should configure and build in a
+*** When building from a git clone you should configure and build in a
     separate directory so you don't clobber SDL_config.h, SDL_revision.h
 " "$LINENO" 5
 fi
@@ -16021,20 +16683,16 @@ $as_echo_n "checking for GCC -mno-cygwin option... " >&6; }
         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-
 int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-        have_no_cygwin=yes
-
+  have_no_cygwin=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_no_cygwin" >&5
@@ -16325,15 +16983,12 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-    have_gcc_mmd_mt=yes
-
+  have_gcc_mmd_mt=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_gcc_mmd_mt" >&5
@@ -16348,21 +17003,18 @@ fi
 $as_echo_n "checking for linker option --no-undefined... " >&6; }
 have_no_undefined=no
 case "$host" in
-        *-*-openbsd*)
+    *-*-openbsd*)
         ;;
-
     *)
         save_LDFLAGS="$LDFLAGS"
         LDFLAGS="$LDFLAGS -Wl,--no-undefined"
         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-
 int
 main ()
 {
 
-
   ;
   return 0;
 }
@@ -16370,7 +17022,7 @@ _ACEOF
 if ac_fn_c_try_link "$LINENO"; then :
 
         have_no_undefined=yes
-        EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,--no-undefined"
+        BUILD_LDFLAGS="$BUILD_LDFLAGS -Wl,--no-undefined"
 
 fi
 rm -f core conftest.err conftest.$ac_objext \
@@ -16391,12 +17043,10 @@ case "$host" in
         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-
 int
 main ()
 {
 
-
   ;
   return 0;
 }
@@ -16425,12 +17075,10 @@ case "$host" in
         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-
 int
 main ()
 {
 
-
   ;
   return 0;
 }
@@ -16459,12 +17107,10 @@ case "$host" in
         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-
 int
 main ()
 {
 
-
   ;
   return 0;
 }
@@ -16495,7 +17141,7 @@ if test x$enable_libc = xyes; then
 $as_echo "#define HAVE_LIBC 1" >>confdefs.h
 
 
-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
 $as_echo_n "checking for ANSI C header files... " >&6; }
 if ${ac_cv_header_stdc+:} false; then :
   $as_echo_n "(cached) " >&6
@@ -16621,7 +17267,7 @@ fi
 done
 
 
-        ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default"
+    ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default"
 if test "x$ac_cv_type_size_t" = xyes; then :
 
 else
@@ -16633,7 +17279,7 @@ _ACEOF
 fi
 
 
-          { $as_echo "$as_me:${as_lineno-$LINENO}: checking for M_PI in math.h" >&5
+      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for M_PI in math.h" >&5
 $as_echo_n "checking for M_PI in math.h... " >&6; }
 if ${ac_cv_define_M_PI+:} false; then :
   $as_echo_n "(cached) " >&6
@@ -16666,11 +17312,7 @@ $as_echo "#define HAVE_M_PI /**/" >>confdefs.h
   fi
 
 
-        case "$host" in
-    *-*-cygwin* | *-*-mingw32*)
-        ;;
-    *)
-        # The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
+    # The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
 # for constant arguments.  Useless!
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for working alloca.h" >&5
 $as_echo_n "checking for working alloca.h... " >&6; }
@@ -16856,8 +17498,6 @@ _ACEOF
 
 fi
 
-        ;;
-    esac
 
     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for working memcmp" >&5
 $as_echo_n "checking for working memcmp... " >&6; }
@@ -17056,7 +17696,6 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
@@ -17071,7 +17710,7 @@ fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
 
-    for ac_func in malloc calloc realloc free getenv setenv putenv unsetenv qsort abs bcopy memset memcpy memmove wcslen wcslcpy wcslcat wcsdup wcsstr wcscmp wcsncmp wcscasecmp _wcsicmp wcsncasecmp _wcsnicmp strlen strlcpy strlcat _strrev _strupr _strlwr strchr strrchr strstr strtok_r itoa _ltoa _uitoa _ultoa strtol strtoul _i64toa _ui64toa strtoll strtoull atoi atof strcmp strncmp _stricmp strcasecmp _strnicmp strncasecmp vsscanf vsnprintf fopen64 fseeko fseeko64 sigaction setjmp nanosleep sysconf sysctlbyname getauxval elf_aux_info poll _Exit
+    for ac_func in malloc calloc realloc free getenv setenv putenv unsetenv qsort abs bcopy memset memcpy memmove wcslen wcslcpy wcslcat _wcsdup wcsdup wcsstr wcscmp wcsncmp wcscasecmp _wcsicmp wcsncasecmp _wcsnicmp strlen strlcpy strlcat _strrev _strupr _strlwr index rindex strchr strrchr strstr strtok_r itoa _ltoa _uitoa _ultoa strtol strtoul _i64toa _ui64toa strtoll strtoull atoi atof strcmp strncmp _stricmp strcasecmp _strnicmp strncasecmp vsscanf vsnprintf fopen64 fseeko fseeko64 sigaction setjmp nanosleep sysconf sysctlbyname getauxval elf_aux_info poll _Exit
 do :
   as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
 ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
@@ -17124,7 +17763,7 @@ if test "x$ac_cv_lib_m_pow" = xyes; then :
   LIBS="$LIBS -lm"; EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lm"
 fi
 
-    for ac_func in acos acosf asin asinf atan atanf atan2 atan2f ceil ceilf copysign copysignf cos cosf exp expf fabs fabsf floor floorf trunc truncf fmod fmodf log logf log10 log10f pow powf scalbn scalbnf sin sinf sqrt sqrtf tan tanf
+    for ac_func in acos acosf asin asinf atan atanf atan2 atan2f ceil ceilf copysign copysignf cos cosf exp expf fabs fabsf floor floorf trunc truncf fmod fmodf log logf log10 log10f lround lroundf pow powf round roundf scalbn scalbnf sin sinf sqrt sqrtf tan tanf
 do :
   as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
 ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
@@ -17198,7 +17837,7 @@ $as_echo "#define HAVE_SA_SIGACTION 1" >>confdefs.h
 fi
 
 
-        for ac_header in libunwind.h
+    for ac_header in libunwind.h
 do :
   ac_fn_c_check_header_mongrel "$LINENO" "libunwind.h" "ac_cv_header_libunwind_h" "$ac_includes_default"
 if test "x$ac_cv_header_libunwind_h" = xyes; then :
@@ -17227,7 +17866,6 @@ $as_echo_n "checking for GCC builtin atomic operations... " >&6; }
     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-
 int
 main ()
 {
@@ -17245,9 +17883,7 @@ main ()
 }
 _ACEOF
 if ac_fn_c_try_link "$LINENO"; then :
-
-    have_gcc_atomics=yes
-
+  have_gcc_atomics=yes
 fi
 rm -f core conftest.err conftest.$ac_objext \
     conftest$ac_exeext conftest.$ac_ext
@@ -17263,7 +17899,6 @@ $as_echo "#define HAVE_GCC_ATOMICS 1" >>confdefs.h
         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-
 int
 main ()
 {
@@ -17277,9 +17912,7 @@ main ()
 }
 _ACEOF
 if ac_fn_c_try_link "$LINENO"; then :
-
-        have_gcc_sync_lock_test_and_set=yes
-
+  have_gcc_sync_lock_test_and_set=yes
 fi
 rm -f core conftest.err conftest.$ac_objext \
     conftest$ac_exeext conftest.$ac_ext
@@ -17300,6 +17933,7 @@ SOURCES="$SOURCES $srcdir/src/dynapi/*.c"
 SOURCES="$SOURCES $srcdir/src/events/*.c"
 SOURCES="$SOURCES $srcdir/src/file/*.c"
 SOURCES="$SOURCES $srcdir/src/haptic/*.c"
+SOURCES="$SOURCES $srcdir/src/hidapi/*.c"
 SOURCES="$SOURCES $srcdir/src/joystick/*.c"
 SOURCES="$SOURCES $srcdir/src/libm/*.c"
 SOURCES="$SOURCES $srcdir/src/misc/*.c"
@@ -17316,11 +17950,20 @@ SOURCES="$SOURCES $srcdir/src/video/yuv2rgb/*.c"
 SOURCES="$SOURCES $srcdir/src/locale/*.c"
 
 
+case "$host" in
+    *-*-emscripten*)
+        default_atomic=no
+        ;;
+    *)
+        default_atomic=yes
+        ;;
+esac
+
 # Check whether --enable-atomic was given.
 if test "${enable_atomic+set}" = set; then :
   enableval=$enable_atomic;
 else
-  enable_atomic=yes
+  enable_atomic=$default_atomic
 fi
 
 if test x$enable_atomic != xyes; then
@@ -17414,6 +18057,20 @@ $as_echo "#define SDL_HAPTIC_DISABLED 1" >>confdefs.h
 else
     SUMMARY_modules="${SUMMARY_modules} haptic"
 fi
+# Check whether --enable-hidapi was given.
+if test "${enable_hidapi+set}" = set; then :
+  enableval=$enable_hidapi;
+else
+  enable_hidapi=yes
+fi
+
+if test x$enable_hidapi != xyes; then
+
+$as_echo "#define SDL_HIDAPI_DISABLED 1" >>confdefs.h
+
+else
+    SUMMARY_modules="${SUMMARY_modules} hidapi"
+fi
 # Check whether --enable-sensor was given.
 if test "${enable_sensor+set}" = set; then :
   enableval=$enable_sensor;
@@ -17498,6 +18155,34 @@ $as_echo "#define SDL_FILE_DISABLED 1" >>confdefs.h
 else
     SUMMARY_modules="${SUMMARY_modules} file"
 fi
+# Check whether --enable-misc was given.
+if test "${enable_misc+set}" = set; then :
+  enableval=$enable_misc;
+else
+  enable_misc=yes
+fi
+
+if test x$enable_misc != xyes; then
+
+$as_echo "#define SDL_MISC_DISABLED 1" >>confdefs.h
+
+else
+    SUMMARY_modules="${SUMMARY_modules} misc"
+fi
+# Check whether --enable-locale was given.
+if test "${enable_locale+set}" = set; then :
+  enableval=$enable_locale;
+else
+  enable_locale=yes
+fi
+
+if test x$enable_locale != xyes; then
+
+$as_echo "#define SDL_LOCALE_DISABLED 1" >>confdefs.h
+
+else
+    SUMMARY_modules="${SUMMARY_modules} locale"
+fi
 # Check whether --enable-loadso was given.
 if test "${enable_loadso+set}" = set; then :
   enableval=$enable_loadso;
@@ -17568,7 +18253,7 @@ fi
         fi
     fi
 
-        # Check whether --enable-mmx was given.
+    # Check whether --enable-mmx was given.
 if test "${enable_mmx+set}" = set; then :
   enableval=$enable_mmx;
 else
@@ -17604,15 +18289,12 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-        have_gcc_mmx=yes
-
+  have_gcc_mmx=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_gcc_mmx" >&5
@@ -17660,9 +18342,7 @@ main ()
 }
 _ACEOF
 if ac_fn_c_try_link "$LINENO"; then :
-
-        have_gcc_3dnow=yes
-
+  have_gcc_3dnow=yes
 fi
 rm -f core conftest.err conftest.$ac_objext \
     conftest$ac_exeext conftest.$ac_ext
@@ -17712,15 +18392,12 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-        have_gcc_sse=yes
-
+  have_gcc_sse=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_gcc_sse" >&5
@@ -17769,15 +18446,12 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-        have_gcc_sse2=yes
-
+  have_gcc_sse2=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_gcc_sse2" >&5
@@ -17826,15 +18500,12 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-        have_gcc_sse3=yes
-
+  have_gcc_sse3=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_gcc_sse3" >&5
@@ -17847,14 +18518,27 @@ $as_echo "$have_gcc_sse3" >&6; }
         fi
     fi
 
-    ac_fn_c_check_header_mongrel "$LINENO" "immintrin.h" "ac_cv_header_immintrin_h" "$ac_includes_default"
-if test "x$ac_cv_header_immintrin_h" = xyes; then :
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for immintrin.h" >&5
+$as_echo_n "checking for immintrin.h... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <immintrin.h>
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
   have_immintrin_h_hdr=yes
 else
   have_immintrin_h_hdr=no
 fi
-
-
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_immintrin_h_hdr" >&5
+$as_echo "$have_immintrin_h_hdr" >&6; }
     if test x$have_immintrin_h_hdr = xyes; then
 
 $as_echo "#define HAVE_IMMINTRIN_H 1" >>confdefs.h
@@ -17889,7 +18573,6 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
@@ -17918,15 +18601,12 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-            have_gcc_altivec=yes
-
+  have_gcc_altivec=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_gcc_altivec" >&5
@@ -17950,7 +18630,6 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
@@ -17980,15 +18659,12 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-            have_gcc_altivec=yes
-
+  have_gcc_altivec=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_gcc_altivec" >&5
@@ -18053,9 +18729,7 @@ main ()
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-            have_oss=yes
-
+  have_oss=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         fi
@@ -18181,7 +18855,6 @@ no_alsa=""
     alsa_min_micro_version=`echo $min_alsa_version | \
            sed 's/\([0-9]*\).\([0-9]*\).\([0-9]*\)/\3/'`
 
-
 ac_ext=c
 ac_cpp='$CPP $CPPFLAGS'
 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
@@ -18375,8 +19048,8 @@ fi
     if test x$enable_audio = xyes -a x$enable_jack = xyes; then
 
 pkg_failed=no
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for JACK" >&5
-$as_echo_n "checking for JACK... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for jack >= 0.125" >&5
+$as_echo_n "checking for jack >= 0.125... " >&6; }
 
 if test -n "$JACK_CFLAGS"; then
     pkg_cv_JACK_CFLAGS="$JACK_CFLAGS"
@@ -18388,6 +19061,7 @@ if test -n "$JACK_CFLAGS"; then
   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }; then
   pkg_cv_JACK_CFLAGS=`$PKG_CONFIG --cflags "jack >= 0.125" 2>/dev/null`
+		      test "x$?" != "x0" && pkg_failed=yes
 else
   pkg_failed=yes
 fi
@@ -18404,6 +19078,7 @@ if test -n "$JACK_LIBS"; then
   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }; then
   pkg_cv_JACK_LIBS=`$PKG_CONFIG --libs "jack >= 0.125" 2>/dev/null`
+		      test "x$?" != "x0" && pkg_failed=yes
 else
   pkg_failed=yes
 fi
@@ -18414,7 +19089,7 @@ fi
 
 
 if test $pkg_failed = yes; then
-   	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
 
 if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
@@ -18423,16 +19098,16 @@ else
         _pkg_short_errors_supported=no
 fi
         if test $_pkg_short_errors_supported = yes; then
-	        JACK_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "jack >= 0.125" 2>&1`
+	        JACK_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "jack >= 0.125" 2>&1`
         else
-	        JACK_PKG_ERRORS=`$PKG_CONFIG --print-errors "jack >= 0.125" 2>&1`
+	        JACK_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "jack >= 0.125" 2>&1`
         fi
 	# Put the nasty error message in config.log where it belongs
 	echo "$JACK_PKG_ERRORS" >&5
 
 	audio_jack=no
 elif test $pkg_failed = untried; then
-     	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
 	audio_jack=no
 else
@@ -18594,6 +19269,12 @@ $as_echo_n "checking for ESD - version >= $min_esd_version... " >&6; }
     esd_micro_version=`$ESD_CONFIG $esd_config_args --version | \
            sed 's/\([0-9]*\).\([0-9]*\).\([0-9]*\)/\3/'`
     if test "x$enable_esdtest" = "xyes" ; then
+      ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
       ac_save_CFLAGS="$CFLAGS"
       ac_save_LIBS="$LIBS"
       CFLAGS="$CFLAGS $ESD_CFLAGS"
@@ -18607,35 +19288,16 @@ else
 
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
 #include <esd.h>
 
-char*
-my_strdup (char *str)
-{
-  char *new_str;
-
-  if (str)
-    {
-      new_str = malloc ((strlen (str) + 1) * sizeof(char));
-      strcpy (new_str, str);
-    }
-  else
-    new_str = NULL;
-
-  return new_str;
-}
-
-int main ()
+int main (void)
 {
   int major, minor, micro;
-  char *tmp_version;
+  FILE *fp = fopen("conf.esdtest", "w");
 
-  system ("touch conf.esdtest");
+  if (fp) fclose(fp);
 
-  /* HP/UX 9 (%@#!) writes to sscanf strings */
-  tmp_version = my_strdup("$min_esd_version");
-  if (sscanf(tmp_version, "%d.%d.%d", &major, &minor, &micro) != 3) {
+  if (sscanf("$min_esd_version", "%d.%d.%d", &major, &minor, &micro) != 3) {
      printf("%s, bad version string\n", "$min_esd_version");
      exit(1);
    }
@@ -18658,7 +19320,6 @@ int main ()
     }
 }
 
-
 _ACEOF
 if ac_fn_c_try_run "$LINENO"; then :
 
@@ -18671,6 +19332,12 @@ fi
 
        CFLAGS="$ac_save_CFLAGS"
        LIBS="$ac_save_LIBS"
+       ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
      fi
   fi
   if test "x$no_esd" = x ; then
@@ -18692,6 +19359,12 @@ $as_echo "no" >&6; }
           echo "*** Could not run ESD test program, checking why..."
           CFLAGS="$CFLAGS $ESD_CFLAGS"
           LIBS="$LIBS $ESD_LIBS"
+          ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
           cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
@@ -18726,6 +19399,12 @@ rm -f core conftest.err conftest.$ac_objext \
     conftest$ac_exeext conftest.$ac_ext
           CFLAGS="$ac_save_CFLAGS"
           LIBS="$ac_save_LIBS"
+          ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
        fi
      fi
      ESD_CFLAGS=""
@@ -18774,6 +19453,126 @@ _ACEOF
     fi
 }
 
+CheckPipewire()
+{
+    # Check whether --enable-pipewire was given.
+if test "${enable_pipewire+set}" = set; then :
+  enableval=$enable_pipewire;
+else
+  enable_pipewire=yes
+fi
+
+    if test x$enable_audio = xyes -a x$enable_pipewire = xyes; then
+
+pkg_failed=no
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for libpipewire-0.3 >= 0.3.20" >&5
+$as_echo_n "checking for libpipewire-0.3 >= 0.3.20... " >&6; }
+
+if test -n "$PIPEWIRE_CFLAGS"; then
+    pkg_cv_PIPEWIRE_CFLAGS="$PIPEWIRE_CFLAGS"
+ elif test -n "$PKG_CONFIG"; then
+    if test -n "$PKG_CONFIG" && \
+    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libpipewire-0.3 >= 0.3.20\""; } >&5
+  ($PKG_CONFIG --exists --print-errors "libpipewire-0.3 >= 0.3.20") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+  pkg_cv_PIPEWIRE_CFLAGS=`$PKG_CONFIG --cflags "libpipewire-0.3 >= 0.3.20" 2>/dev/null`
+		      test "x$?" != "x0" && pkg_failed=yes
+else
+  pkg_failed=yes
+fi
+ else
+    pkg_failed=untried
+fi
+if test -n "$PIPEWIRE_LIBS"; then
+    pkg_cv_PIPEWIRE_LIBS="$PIPEWIRE_LIBS"
+ elif test -n "$PKG_CONFIG"; then
+    if test -n "$PKG_CONFIG" && \
+    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libpipewire-0.3 >= 0.3.20\""; } >&5
+  ($PKG_CONFIG --exists --print-errors "libpipewire-0.3 >= 0.3.20") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+  pkg_cv_PIPEWIRE_LIBS=`$PKG_CONFIG --libs "libpipewire-0.3 >= 0.3.20" 2>/dev/null`
+		      test "x$?" != "x0" && pkg_failed=yes
+else
+  pkg_failed=yes
+fi
+ else
+    pkg_failed=untried
+fi
+
+
+
+if test $pkg_failed = yes; then
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+
+if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
+        _pkg_short_errors_supported=yes
+else
+        _pkg_short_errors_supported=no
+fi
+        if test $_pkg_short_errors_supported = yes; then
+	        PIPEWIRE_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "libpipewire-0.3 >= 0.3.20" 2>&1`
+        else
+	        PIPEWIRE_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "libpipewire-0.3 >= 0.3.20" 2>&1`
+        fi
+	# Put the nasty error message in config.log where it belongs
+	echo "$PIPEWIRE_PKG_ERRORS" >&5
+
+	audio_pipewire=no
+elif test $pkg_failed = untried; then
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+	audio_pipewire=no
+else
+	PIPEWIRE_CFLAGS=$pkg_cv_PIPEWIRE_CFLAGS
+	PIPEWIRE_LIBS=$pkg_cv_PIPEWIRE_LIBS
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+	audio_pipewire=yes
+fi
+
+        if test x$audio_pipewire = xyes; then
+            # Check whether --enable-pipewire-shared was given.
+if test "${enable_pipewire_shared+set}" = set; then :
+  enableval=$enable_pipewire_shared;
+else
+  enable_pipewire_shared=yes
+fi
+
+            pipewire_lib=`find_lib "libpipewire-0.3.so.*" "$PIPEWIRE_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`
+
+
+$as_echo "#define SDL_AUDIO_DRIVER_PIPEWIRE 1" >>confdefs.h
+
+            SOURCES="$SOURCES $srcdir/src/audio/pipewire/*.c"
+            EXTRA_CFLAGS="$EXTRA_CFLAGS $PIPEWIRE_CFLAGS"
+            if test x$have_loadso != xyes && \
+               test x$enable_pipewire_shared = xyes; then
+                { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: You must have SDL_LoadObject() support for dynamic Pipewire loading" >&5
+$as_echo "$as_me: WARNING: You must have SDL_LoadObject() support for dynamic Pipewire loading" >&2;}
+            fi
+            if test x$have_loadso = xyes && \
+               test x$enable_pipewire_shared = xyes && test x$pipewire_lib != x; then
+                echo "-- dynamic libpipewire-0.3 -> $pipewire_lib"
+
+cat >>confdefs.h <<_ACEOF
+#define SDL_AUDIO_DRIVER_PIPEWIRE_DYNAMIC "$pipewire_lib"
+_ACEOF
+
+                SUMMARY_audio="${SUMMARY_audio} pipewire(dynamic)"
+            else
+                EXTRA_LDFLAGS="$EXTRA_LDFLAGS $PIPEWIRE_LIBS"
+                SUMMARY_audio="${SUMMARY_audio} pipewire"
+            fi
+            have_audio=yes
+        fi
+    fi
+}
+
 CheckPulseAudio()
 {
     # Check whether --enable-pulseaudio was given.
@@ -18786,8 +19585,8 @@ fi
     if test x$enable_audio = xyes -a x$enable_pulseaudio = xyes; then
 
 pkg_failed=no
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for PULSEAUDIO" >&5
-$as_echo_n "checking for PULSEAUDIO... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for libpulse-simple >= 0.9" >&5
+$as_echo_n "checking for libpulse-simple >= 0.9... " >&6; }
 
 if test -n "$PULSEAUDIO_CFLAGS"; then
     pkg_cv_PULSEAUDIO_CFLAGS="$PULSEAUDIO_CFLAGS"
@@ -18799,6 +19598,7 @@ if test -n "$PULSEAUDIO_CFLAGS"; then
   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }; then
   pkg_cv_PULSEAUDIO_CFLAGS=`$PKG_CONFIG --cflags "libpulse-simple >= 0.9" 2>/dev/null`
+		      test "x$?" != "x0" && pkg_failed=yes
 else
   pkg_failed=yes
 fi
@@ -18815,6 +19615,7 @@ if test -n "$PULSEAUDIO_LIBS"; then
   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }; then
   pkg_cv_PULSEAUDIO_LIBS=`$PKG_CONFIG --libs "libpulse-simple >= 0.9" 2>/dev/null`
+		      test "x$?" != "x0" && pkg_failed=yes
 else
   pkg_failed=yes
 fi
@@ -18825,7 +19626,7 @@ fi
 
 
 if test $pkg_failed = yes; then
-   	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
 
 if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
@@ -18834,16 +19635,16 @@ else
         _pkg_short_errors_supported=no
 fi
         if test $_pkg_short_errors_supported = yes; then
-	        PULSEAUDIO_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "libpulse-simple >= 0.9" 2>&1`
+	        PULSEAUDIO_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "libpulse-simple >= 0.9" 2>&1`
         else
-	        PULSEAUDIO_PKG_ERRORS=`$PKG_CONFIG --print-errors "libpulse-simple >= 0.9" 2>&1`
+	        PULSEAUDIO_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "libpulse-simple >= 0.9" 2>&1`
         fi
 	# Put the nasty error message in config.log where it belongs
 	echo "$PULSEAUDIO_PKG_ERRORS" >&5
 
 	audio_pulseaudio=no
 elif test $pkg_failed = untried; then
-     	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
 	audio_pulseaudio=no
 else
@@ -18976,9 +19777,7 @@ main ()
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-            audio_arts=yes
-
+  audio_arts=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
             CFLAGS="$save_CFLAGS"
@@ -19257,8 +20056,8 @@ fi
     if test x$enable_audio = xyes -a x$enable_fusionsound = xyes; then
 
 pkg_failed=no
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for FUSIONSOUND" >&5
-$as_echo_n "checking for FUSIONSOUND... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for fusionsound >= 1.1.1" >&5
+$as_echo_n "checking for fusionsound >= 1.1.1... " >&6; }
 
 if test -n "$FUSIONSOUND_CFLAGS"; then
     pkg_cv_FUSIONSOUND_CFLAGS="$FUSIONSOUND_CFLAGS"
@@ -19270,6 +20069,7 @@ if test -n "$FUSIONSOUND_CFLAGS"; then
   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }; then
   pkg_cv_FUSIONSOUND_CFLAGS=`$PKG_CONFIG --cflags "fusionsound >= 1.1.1" 2>/dev/null`
+		      test "x$?" != "x0" && pkg_failed=yes
 else
   pkg_failed=yes
 fi
@@ -19286,6 +20086,7 @@ if test -n "$FUSIONSOUND_LIBS"; then
   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }; then
   pkg_cv_FUSIONSOUND_LIBS=`$PKG_CONFIG --libs "fusionsound >= 1.1.1" 2>/dev/null`
+		      test "x$?" != "x0" && pkg_failed=yes
 else
   pkg_failed=yes
 fi
@@ -19296,7 +20097,7 @@ fi
 
 
 if test $pkg_failed = yes; then
-   	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
 
 if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
@@ -19305,16 +20106,16 @@ else
         _pkg_short_errors_supported=no
 fi
         if test $_pkg_short_errors_supported = yes; then
-	        FUSIONSOUND_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "fusionsound >= 1.1.1" 2>&1`
+	        FUSIONSOUND_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "fusionsound >= 1.1.1" 2>&1`
         else
-	        FUSIONSOUND_PKG_ERRORS=`$PKG_CONFIG --print-errors "fusionsound >= 1.1.1" 2>&1`
+	        FUSIONSOUND_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "fusionsound >= 1.1.1" 2>&1`
         fi
 	# Put the nasty error message in config.log where it belongs
 	echo "$FUSIONSOUND_PKG_ERRORS" >&5
 
 	fusionsound=no
 elif test $pkg_failed = untried; then
-     	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
 	fusionsound=no
 else
@@ -19383,6 +20184,7 @@ $as_echo "#define SDL_AUDIO_DRIVER_DISK 1" >>confdefs.h
 
         SOURCES="$SOURCES $srcdir/src/audio/disk/*.c"
         SUMMARY_audio="${SUMMARY_audio} disk"
+        have_audio=yes
     fi
 }
 
@@ -19401,6 +20203,7 @@ $as_echo "#define SDL_AUDIO_DRIVER_DUMMY 1" >>confdefs.h
 
         SOURCES="$SOURCES $srcdir/src/audio/dummy/*.c"
         SUMMARY_audio="${SUMMARY_audio} dummy"
+        have_audio=yes
     fi
 }
 
@@ -19578,15 +20381,12 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-    have_gcc_fvisibility=yes
-
+  have_gcc_fvisibility=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_gcc_fvisibility" >&5
@@ -19615,15 +20415,12 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-    have_gcc_no_strict_aliasing=yes
-
+  have_gcc_no_strict_aliasing=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_gcc_no_strict_aliasing" >&5
@@ -19652,15 +20449,12 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-    have_gcc_preferred_stack_boundary=yes
-
+  have_gcc_preferred_stack_boundary=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_gcc_preferred_stack_boundary" >&5
@@ -19689,15 +20483,12 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-    have_gcc_declaration_after_statement=yes
-
+  have_gcc_declaration_after_statement=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_gcc_declaration_after_statement" >&5
@@ -19726,15 +20517,12 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-    have_gcc_Wall=yes
-
+  have_gcc_Wall=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_gcc_Wall" >&5
@@ -19744,7 +20532,7 @@ $as_echo "$have_gcc_Wall" >&6; }
     if test x$have_gcc_Wall = xyes; then
         EXTRA_CFLAGS="$EXTRA_CFLAGS -Wall"
 
-                { $as_echo "$as_me:${as_lineno-$LINENO}: checking for necessary GCC -Wno-multichar option" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for necessary GCC -Wno-multichar option" >&5
 $as_echo_n "checking for necessary GCC -Wno-multichar option... " >&6; }
         need_gcc_Wno_multichar=no
         case "$host" in
@@ -19784,10 +20572,15 @@ $as_echo_n "checking for Wayland support... " >&6; }
         video_wayland=no
         if  test x$video_opengl_egl = xyes && \
             test x$video_opengles_v2 = xyes; then
-            if $PKG_CONFIG --exists wayland-client wayland-scanner wayland-egl wayland-cursor egl xkbcommon ; then
+            if $PKG_CONFIG --exists wayland-client wayland-scanner wayland-egl wayland-cursor egl 'xkbcommon >= 0.5.0'; then
                 WAYLAND_CFLAGS=`$PKG_CONFIG --cflags wayland-client wayland-egl wayland-cursor xkbcommon`
                 WAYLAND_LIBS=`$PKG_CONFIG --libs wayland-client wayland-egl wayland-cursor xkbcommon`
                 WAYLAND_SCANNER=`$PKG_CONFIG --variable=wayland_scanner wayland-scanner`
+                if $PKG_CONFIG --exists 'wayland-scanner >= 1.15'; then :
+  WAYLAND_SCANNER_CODE_MODE=private-code
+else
+  WAYLAND_SCANNER_CODE_MODE=code
+fi
                 video_wayland=yes
             fi
         fi
@@ -19815,12 +20608,13 @@ else
 fi
 
 
-                        case "$host" in
+            case "$host" in
                 *)
                     wayland_client_lib=`find_lib "libwayland-client.so.*" "$WAYLAND_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`
                     wayland_egl_lib=`find_lib "libwayland-egl.so.*" "$WAYLAND_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`
                     if test x$wayland_egl_lib = x; then
-                                                wayland_egl_lib=`find_lib "mesa-egl/libwayland-egl.so.*" "$WAYLAND_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`
+                        # This works in Ubuntu 13.10, maybe others
+                        wayland_egl_lib=`find_lib "mesa-egl/libwayland-egl.so.*" "$WAYLAND_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`
                     fi
                     wayland_cursor_lib=`find_lib "libwayland-cursor.so.*" "$WAYLAND_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`
                     xkbcommon_lib=`find_lib "libxkbcommon.so.*" "$WAYLAND_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`
@@ -19873,6 +20667,63 @@ _ACEOF
                 SUMMARY_video="${SUMMARY_video} wayland"
             fi
             have_video=yes
+
+            # Check whether --enable-libdecor was given.
+if test "${enable_libdecor+set}" = set; then :
+  enableval=$enable_libdecor;
+else
+  enable_libdecor=yes
+fi
+
+            if test x$enable_libdecor = xyes; then
+                { $as_echo "$as_me:${as_lineno-$LINENO}: checking for libdecor support" >&5
+$as_echo_n "checking for libdecor support... " >&6; }
+                if $PKG_CONFIG --exists libdecor-0; then :
+  video_libdecor=yes
+else
+  video_libdecor=no
+fi
+                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $video_libdecor" >&5
+$as_echo "$video_libdecor" >&6; }
+                if test x$video_libdecor = xyes; then
+                    EXTRA_CFLAGS="$EXTRA_CFLAGS `$PKG_CONFIG --cflags libdecor-0`"
+
+$as_echo "#define HAVE_LIBDECOR_H 1" >>confdefs.h
+
+
+                    # Check whether --enable-libdecor-shared was given.
+if test "${enable_libdecor_shared+set}" = set; then :
+  enableval=$enable_libdecor_shared;
+else
+  enable_libdecor_shared=yes
+fi
+
+
+                    if test x$enable_wayland_shared != xyes; then
+                       enable_libdecor_shared=no
+                    fi
+
+                    decor_lib=`find_lib "libdecor-0.so.*" "" | sed 's/.*\/\(.*\)/\1/; q'`
+
+                    if test x$have_loadso != xyes && \
+                       test x$enable_libdecor_shared = xyes; then
+                        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: You must have SDL_LoadObject() support for dynamic libdecor loading" >&5
+$as_echo "$as_me: WARNING: You must have SDL_LoadObject() support for dynamic libdecor loading" >&2;}
+                    fi
+
+                    if test x$have_loadso = xyes && \
+                       test x$enable_libdecor_shared = xyes && test x$decor_lib != x; then
+                        echo "-- dynamic libdecor -> $decor_lib"
+
+cat >>confdefs.h <<_ACEOF
+#define SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_LIBDECOR "$decor_lib"
+_ACEOF
+
+                    else
+                        EXTRA_LDFLAGS="$EXTRA_LDFLAGS `$PKG_CONFIG --libs libdecor-0`"
+                    fi
+                fi
+            fi
         fi
     fi
 }
@@ -19890,7 +20741,6 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
@@ -19921,8 +20771,10 @@ $as_echo "#define SDL_VIDEO_RENDER_OGL_ES2 1" >>confdefs.h
         SDLMAIN_SOURCES="$srcdir/src/main/nacl/*.c"
         SOURCES="$SOURCES $srcdir/src/audio/nacl/*.c"
         SUMMARY_audio="${SUMMARY_audio} nacl"
+        have_audio=yes
         SOURCES="$SOURCES $srcdir/src/video/nacl/*.c"
         SUMMARY_video="${SUMMARY_video} nacl opengles2"
+        have_video=yes
 
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
@@ -19940,8 +20792,8 @@ fi
     if test x$enable_video = xyes -a x$enable_video_rpi = xyes; then
 
 pkg_failed=no
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for RPI" >&5
-$as_echo_n "checking for RPI... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for bcm_host brcmegl" >&5
+$as_echo_n "checking for bcm_host brcmegl... " >&6; }
 
 if test -n "$RPI_CFLAGS"; then
     pkg_cv_RPI_CFLAGS="$RPI_CFLAGS"
@@ -19953,6 +20805,7 @@ if test -n "$RPI_CFLAGS"; then
   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }; then
   pkg_cv_RPI_CFLAGS=`$PKG_CONFIG --cflags "bcm_host brcmegl" 2>/dev/null`
+		      test "x$?" != "x0" && pkg_failed=yes
 else
   pkg_failed=yes
 fi
@@ -19969,6 +20822,7 @@ if test -n "$RPI_LIBS"; then
   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }; then
   pkg_cv_RPI_LIBS=`$PKG_CONFIG --libs "bcm_host brcmegl" 2>/dev/null`
+		      test "x$?" != "x0" && pkg_failed=yes
 else
   pkg_failed=yes
 fi
@@ -19979,7 +20833,7 @@ fi
 
 
 if test $pkg_failed = yes; then
-   	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
 
 if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
@@ -19988,16 +20842,16 @@ else
         _pkg_short_errors_supported=no
 fi
         if test $_pkg_short_errors_supported = yes; then
-	        RPI_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "bcm_host brcmegl" 2>&1`
+	        RPI_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "bcm_host brcmegl" 2>&1`
         else
-	        RPI_PKG_ERRORS=`$PKG_CONFIG --print-errors "bcm_host brcmegl" 2>&1`
+	        RPI_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "bcm_host brcmegl" 2>&1`
         fi
 	# Put the nasty error message in config.log where it belongs
 	echo "$RPI_PKG_ERRORS" >&5
 
 	video_rpi=no
 elif test $pkg_failed = untried; then
-     	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
 	video_rpi=no
 else
@@ -20024,18 +20878,20 @@ fi
         # Add the Raspberry Pi compiler flags and libraries
         CFLAGS="$CFLAGS $RPI_CFLAGS"; LIBS="$LIBS $RPI_LIBS"
 
-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Raspberry Pi" >&5
-$as_echo_n "checking for Raspberry Pi... " >&6; }
+        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Raspberry Pi 2/3" >&5
+$as_echo_n "checking for Raspberry Pi 2/3... " >&6; }
         have_video_rpi=no
         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
           #include <bcm_host.h>
+          #include <EGL/eglplatform.h>
 
 int
 main ()
 {
 
+          EGL_DISPMANX_WINDOW_T window;
           bcm_host_init();
 
   ;
@@ -20043,9 +20899,7 @@ main ()
 }
 _ACEOF
 if ac_fn_c_try_link "$LINENO"; then :
-
-        have_video_rpi=yes
-
+  have_video_rpi=yes
 fi
 rm -f core conftest.err conftest.$ac_objext \
     conftest$ac_exeext conftest.$ac_ext
@@ -20065,6 +20919,7 @@ $as_echo "$have_video_rpi" >&6; }
 $as_echo "#define SDL_VIDEO_DRIVER_RPI 1" >>confdefs.h
 
             SUMMARY_video="${SUMMARY_video} rpi"
+            have_video=yes
         fi
     fi
 }
@@ -20111,8 +20966,34 @@ else
   $as_echo_n "(cached) " >&6
 else
   # One or both of the vars are not set, and there is no cached value.
-ac_x_includes=no ac_x_libraries=no
-rm -f -r conftest.dir
+ac_x_includes=no
+ac_x_libraries=no
+# Do we need to do anything special at all?
+ac_save_LIBS=$LIBS
+LIBS="-lX11 $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <X11/Xlib.h>
+int
+main ()
+{
+XrmInitialize ()
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  # We can compile and link X programs with no special options.
+  ac_x_includes=
+  ac_x_libraries=
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS="$ac_save_LIBS"
+# If that didn't work, only try xmkmf and filesystem searches
+# for native compilation.
+if test x"$ac_x_includes" = xno && test "$cross_compiling" = no; then :
+  rm -f -r conftest.dir
 if mkdir conftest.dir; then
   cd conftest.dir
   cat >Imakefile <<'_ACEOF'
@@ -20151,7 +21032,7 @@ _ACEOF
   rm -f -r conftest.dir
 fi
 
-# Standard set of common directories for X headers.
+  # Standard set of common directories for X headers.
 # Check X11 before X11Rn because it is often a symlink to the current release.
 ac_x_header_dirs='
 /usr/X11/include
@@ -20253,15 +21134,17 @@ rm -f core conftest.err conftest.$ac_objext \
     conftest$ac_exeext conftest.$ac_ext
 fi # $ac_x_libraries = no
 
+fi
+# Record the results.
 case $ac_x_includes,$ac_x_libraries in #(
-  no,* | *,no | *\'*)
+  no,* | *,no | *\'*) :
     # Didn't find X, or a directory has "'" in its name.
-    ac_cv_have_x="have_x=no";; #(
-  *)
+    ac_cv_have_x="have_x=no" ;; #(
+  *) :
     # Record where we found X for the cache.
     ac_cv_have_x="have_x=yes\
 	ac_x_includes='$ac_x_includes'\
-	ac_x_libraries='$ac_x_libraries'"
+	ac_x_libraries='$ac_x_libraries'" ;;
 esac
 fi
 ;; #(
@@ -20793,6 +21676,7 @@ fi
                     xcursor_lib='/opt/X11/lib/libXcursor.1.dylib'
                     xinerama_lib='/opt/X11/lib/libXinerama.1.dylib'
                     xinput_lib='/opt/X11/lib/libXi.6.dylib'
+                    xfixes_lib='/opt/X11/lib/libXfixes.3.dylib'
                     xrandr_lib='/opt/X11/lib/libXrandr.2.dylib'
                     xrender_lib='/opt/X11/lib/libXrender.1.dylib'
                     xss_lib='/opt/X11/lib/libXss.1.dylib'
@@ -20804,6 +21688,7 @@ fi
                     xcursor_lib='libXcursor.so'
                     xinerama_lib='libXinerama.so'
                     xinput_lib='libXi.so'
+                    xfixes_lib='libXfixes.so'
                     xrandr_lib='libXrandr.so'
                     xrender_lib='libXrender.so'
                     xss_lib='libXss.so'
@@ -20815,6 +21700,7 @@ fi
                     xcursor_lib=`find_lib "libXcursor.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`
                     xinerama_lib=`find_lib "libXinerama.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`
                     xinput_lib=`find_lib "libXi.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`
+                    xfixes_lib=`find_lib "libXfixes.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`
                     xrandr_lib=`find_lib "libXrandr.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`
                     xrender_lib=`find_lib "libXrender.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`
                     xss_lib=`find_lib "libXss.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`
@@ -20885,40 +21771,7 @@ _ACEOF
             fi
             have_video=yes
 
-            { $as_echo "$as_me:${as_lineno-$LINENO}: checking for const parameter to XextAddDisplay" >&5
-$as_echo_n "checking for const parameter to XextAddDisplay... " >&6; }
-            have_const_param_XextAddDisplay=no
-            cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-              #include <X11/Xlib.h>
-              #include <X11/Xproto.h>
-              #include <X11/extensions/Xext.h>
-              #include <X11/extensions/extutil.h>
-              extern XExtDisplayInfo* XextAddDisplay(XExtensionInfo* a,Display* b,_Xconst char* c,XExtensionHooks* d,int e,XPointer f);
-
-int
-main ()
-{
-
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"; then :
-
-            have_const_param_XextAddDisplay=yes
-
-$as_echo "#define SDL_VIDEO_DRIVER_X11_CONST_PARAM_XEXTADDDISPLAY 1" >>confdefs.h
-
-
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_const_param_XextAddDisplay" >&5
-$as_echo "$have_const_param_XextAddDisplay" >&6; }
-
-                        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XGenericEvent" >&5
+            { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XGenericEvent" >&5
 $as_echo_n "checking for XGenericEvent... " >&6; }
             have_XGenericEvent=no
             cat confdefs.h - <<_ACEOF >conftest.$ac_ext
@@ -21300,6 +22153,104 @@ rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_xinput2_multitouch" >&5
 $as_echo "$have_xinput2_multitouch" >&6; }
             fi
+            # Check whether --enable-video-x11-xfixes was given.
+if test "${enable_video_x11_xfixes+set}" = set; then :
+  enableval=$enable_video_x11_xfixes;
+else
+  enable_video_x11_xfixes=yes
+fi
+
+            if test x$enable_video_x11_xfixes = xyes; then
+                definitely_enable_video_x11_xfixes=no
+                # check along with XInput2.h because we use Xfixes with XIBarrierReleasePointer
+                { $as_echo "$as_me:${as_lineno-$LINENO}: checking for X11/extensions/Xfixes.h" >&5
+$as_echo_n "checking for X11/extensions/Xfixes.h... " >&6; }
+                cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+                    #include <X11/Xlib.h>
+                    #include <X11/Xproto.h>
+                    #include <X11/extensions/XInput2.h>
+                    #include <X11/extensions/Xfixes.h>
+int
+main ()
+{
+BarrierEventID b;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  have_xfixes_h_hdr=yes
+else
+  have_xfixes_h_hdr=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_xfixes_h_hdr" >&5
+$as_echo "$have_xfixes_h_hdr" >&6; }
+                if test x$have_xfixes_h_hdr = xyes; then
+                    if test x$enable_x11_shared = xyes && test x$xfixes_lib != x ; then
+                        echo "-- dynamic libXfixes -> $xfixes_lib"
+
+cat >>confdefs.h <<_ACEOF
+#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XFIXES "$xfixes_lib"
+_ACEOF
+
+                        definitely_enable_video_x11_xfixes=yes
+                    else
+                        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XFixesCreatePointerBarrier in -lXfixes" >&5
+$as_echo_n "checking for XFixesCreatePointerBarrier in -lXfixes... " >&6; }
+if ${ac_cv_lib_Xfixes_XFixesCreatePointerBarrier+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lXfixes  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char XFixesCreatePointerBarrier ();
+int
+main ()
+{
+return XFixesCreatePointerBarrier ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_Xfixes_XFixesCreatePointerBarrier=yes
+else
+  ac_cv_lib_Xfixes_XFixesCreatePointerBarrier=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_Xfixes_XFixesCreatePointerBarrier" >&5
+$as_echo "$ac_cv_lib_Xfixes_XFixesCreatePointerBarrier" >&6; }
+if test "x$ac_cv_lib_Xfixes_XFixesCreatePointerBarrier" = xyes; then :
+  have_xfixes_lib=yes
+fi
+
+                        if test x$have_xfixes_lib = xyes ; then
+                            EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lXfixes"
+                            definitely_enable_video_x11_xfixes=yes
+                        fi
+                    fi
+                fi
+            fi
+            if test x$definitely_enable_video_x11_xfixes = xyes; then
+
+$as_echo "#define SDL_VIDEO_DRIVER_X11_XFIXES 1" >>confdefs.h
+
+                SUMMARY_video_x11="${SUMMARY_video_x11} xfixes"
+            fi
             # Check whether --enable-video-x11-xrandr was given.
 if test "${enable_video_x11_xrandr+set}" = set; then :
   enableval=$enable_video_x11_xrandr;
@@ -21308,7 +22259,7 @@ else
 fi
 
             if test x$enable_video_x11_xrandr = xyes; then
-                                definitely_enable_video_x11_xrandr=no
+                definitely_enable_video_x11_xrandr=no
                 have_xrandr_h_hdr=no
                 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
@@ -21327,9 +22278,7 @@ main ()
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-                have_xrandr_h_hdr=yes
-
+  have_xrandr_h_hdr=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
                 if test x$have_xrandr_h_hdr = xyes; then
@@ -21584,7 +22533,8 @@ $as_echo "#define SDL_VIDEO_DRIVER_X11_XVIDMODE 1" >>confdefs.h
                 SUMMARY_video_x11="${SUMMARY_video_x11} xvidmode"
             fi
         fi
-    else
+    fi
+    if test x$have_x != xyes; then
         # Prevent Mesa from including X11 headers
         EXTRA_CFLAGS="$EXTRA_CFLAGS -DMESA_EGL_NO_X11_HEADERS -DEGL_NO_X11"
     fi
@@ -21614,15 +22564,12 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-        have_vivante_vdk=yes
-
+  have_vivante_vdk=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_vivante_vdk" >&5
@@ -21642,15 +22589,12 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-        have_vivante_egl=yes
-
+  have_vivante_egl=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_vivante_egl" >&5
@@ -21697,7 +22641,7 @@ fi
 
     if test x$enable_video = xyes -a x$enable_video_cocoa = xyes; then
         save_CFLAGS="$CFLAGS"
-                CFLAGS="$CFLAGS -x objective-c"
+        CFLAGS="$CFLAGS -x objective-c"
         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Cocoa framework" >&5
 $as_echo_n "checking for Cocoa framework... " >&6; }
         have_cocoa=no
@@ -21710,15 +22654,12 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-        have_cocoa=yes
-
+  have_cocoa=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_cocoa" >&5
@@ -21753,7 +22694,7 @@ fi
 
     if test x$enable_video = xyes -a x$enable_video_metal = xyes; then
         save_CFLAGS="$CFLAGS"
-                CFLAGS="$CFLAGS -x objective-c"
+        CFLAGS="$CFLAGS -x objective-c"
         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Metal framework" >&5
 $as_echo_n "checking for Metal framework... " >&6; }
         have_metal=no
@@ -21772,15 +22713,12 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-        have_metal=yes
-
+  have_metal=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         CFLAGS="$save_CFLAGS"
@@ -21816,8 +22754,8 @@ fi
     if test x$enable_video = xyes -a x$enable_video_directfb = xyes; then
 
 pkg_failed=no
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIRECTFB" >&5
-$as_echo_n "checking for DIRECTFB... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for directfb >= 1.0.0" >&5
+$as_echo_n "checking for directfb >= 1.0.0... " >&6; }
 
 if test -n "$DIRECTFB_CFLAGS"; then
     pkg_cv_DIRECTFB_CFLAGS="$DIRECTFB_CFLAGS"
@@ -21829,6 +22767,7 @@ if test -n "$DIRECTFB_CFLAGS"; then
   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }; then
   pkg_cv_DIRECTFB_CFLAGS=`$PKG_CONFIG --cflags "directfb >= 1.0.0" 2>/dev/null`
+		      test "x$?" != "x0" && pkg_failed=yes
 else
   pkg_failed=yes
 fi
@@ -21845,6 +22784,7 @@ if test -n "$DIRECTFB_LIBS"; then
   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }; then
   pkg_cv_DIRECTFB_LIBS=`$PKG_CONFIG --libs "directfb >= 1.0.0" 2>/dev/null`
+		      test "x$?" != "x0" && pkg_failed=yes
 else
   pkg_failed=yes
 fi
@@ -21855,7 +22795,7 @@ fi
 
 
 if test $pkg_failed = yes; then
-   	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
 
 if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
@@ -21864,16 +22804,16 @@ else
         _pkg_short_errors_supported=no
 fi
         if test $_pkg_short_errors_supported = yes; then
-	        DIRECTFB_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "directfb >= 1.0.0" 2>&1`
+	        DIRECTFB_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "directfb >= 1.0.0" 2>&1`
         else
-	        DIRECTFB_PKG_ERRORS=`$PKG_CONFIG --print-errors "directfb >= 1.0.0" 2>&1`
+	        DIRECTFB_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "directfb >= 1.0.0" 2>&1`
         fi
 	# Put the nasty error message in config.log where it belongs
 	echo "$DIRECTFB_PKG_ERRORS" >&5
 
 	video_directfb=no
 elif test $pkg_failed = untried; then
-     	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
 	video_directfb=no
 else
@@ -21918,13 +22858,8 @@ $as_echo "#define SDL_VIDEO_RENDER_DIRECTFB 1" >>confdefs.h
             SOURCES="$SOURCES $srcdir/src/video/directfb/*.c"
             EXTRA_CFLAGS="$EXTRA_CFLAGS $DIRECTFB_CFLAGS"
 
-            { $as_echo "$as_me:${as_lineno-$LINENO}: checking for directfb dynamic loading support" >&5
-$as_echo_n "checking for directfb dynamic loading support... " >&6; }
             directfb_shared=no
-            directfb_lib=`find_lib "libdirectfb*.so.*" "$DIRECTFB_LIBS"`
-            # | sed 's/.*\/\(.*\)/\1/; q'`]
-{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"directfb $directfb_lib\"" >&5
-$as_echo "$as_me: WARNING: \"directfb $directfb_lib\"" >&2;}
+            directfb_lib=`find_lib "libdirectfb*.so.*" "$DIRECTFB_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`
             if test x$have_loadso != xyes && \
                test x$enable_directfb_shared = xyes; then
                 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: You must have SDL_LoadObject() support for dynamic directfb loading" >&5
@@ -21933,7 +22868,7 @@ $as_echo "$as_me: WARNING: You must have SDL_LoadObject() support for dynamic di
             if test x$have_loadso = xyes && \
                test x$enable_directfb_shared = xyes && test x$directfb_lib != x; then
                 directfb_shared=yes
-                echo "-- $directfb_lib_spec -> $directfb_lib"
+                echo "-- dynamic libdirectfb -> $directfb_lib"
 
 cat >>confdefs.h <<_ACEOF
 #define SDL_VIDEO_DRIVER_DIRECTFB_DYNAMIC "$directfb_lib"
@@ -21944,8 +22879,6 @@ _ACEOF
                 EXTRA_LDFLAGS="$EXTRA_LDFLAGS $DIRECTFB_LIBS"
                 SUMMARY_video="${SUMMARY_video} directfb"
             fi
-            { $as_echo "$as_me:${as_lineno-$LINENO}: result: $directfb_shared" >&5
-$as_echo "$directfb_shared" >&6; }
             SDL_CFLAGS="$SDL_CFLAGS $DIRECTFB_CFLAGS"
             have_video=yes
         fi
@@ -21958,17 +22891,20 @@ CheckKMSDRM()
 if test "${enable_video_kmsdrm+set}" = set; then :
   enableval=$enable_video_kmsdrm;
 else
-  enable_video_kmsdrm=no
+  enable_video_kmsdrm=yes
 fi
 
 
-    if test x$enable_video = xyes -a x$enable_video_kmsdrm = xyes; then
+    if  test x$enable_video = xyes && \
+        test x$enable_video_kmsdrm = xyes && \
+        test x$video_opengl_egl = xyes; then
+
         video_kmsdrm=no
 
 
 pkg_failed=no
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for LIBDRM" >&5
-$as_echo_n "checking for LIBDRM... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for libdrm >= 1.4.82" >&5
+$as_echo_n "checking for libdrm >= 1.4.82... " >&6; }
 
 if test -n "$LIBDRM_CFLAGS"; then
     pkg_cv_LIBDRM_CFLAGS="$LIBDRM_CFLAGS"
@@ -21980,6 +22916,7 @@ if test -n "$LIBDRM_CFLAGS"; then
   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }; then
   pkg_cv_LIBDRM_CFLAGS=`$PKG_CONFIG --cflags "libdrm >= 1.4.82" 2>/dev/null`
+		      test "x$?" != "x0" && pkg_failed=yes
 else
   pkg_failed=yes
 fi
@@ -21996,6 +22933,7 @@ if test -n "$LIBDRM_LIBS"; then
   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }; then
   pkg_cv_LIBDRM_LIBS=`$PKG_CONFIG --libs "libdrm >= 1.4.82" 2>/dev/null`
+		      test "x$?" != "x0" && pkg_failed=yes
 else
   pkg_failed=yes
 fi
@@ -22006,7 +22944,7 @@ fi
 
 
 if test $pkg_failed = yes; then
-   	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
 
 if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
@@ -22015,16 +22953,16 @@ else
         _pkg_short_errors_supported=no
 fi
         if test $_pkg_short_errors_supported = yes; then
-	        LIBDRM_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "libdrm >= 1.4.82" 2>&1`
+	        LIBDRM_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "libdrm >= 1.4.82" 2>&1`
         else
-	        LIBDRM_PKG_ERRORS=`$PKG_CONFIG --print-errors "libdrm >= 1.4.82" 2>&1`
+	        LIBDRM_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "libdrm >= 1.4.82" 2>&1`
         fi
 	# Put the nasty error message in config.log where it belongs
 	echo "$LIBDRM_PKG_ERRORS" >&5
 
 	libdrm_avail=no
 elif test $pkg_failed = untried; then
-     	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
 	libdrm_avail=no
 else
@@ -22036,8 +22974,8 @@ $as_echo "yes" >&6; }
 fi
 
 pkg_failed=no
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for LIBGBM" >&5
-$as_echo_n "checking for LIBGBM... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for gbm >= 11.1.0" >&5
+$as_echo_n "checking for gbm >= 11.1.0... " >&6; }
 
 if test -n "$LIBGBM_CFLAGS"; then
     pkg_cv_LIBGBM_CFLAGS="$LIBGBM_CFLAGS"
@@ -22049,6 +22987,7 @@ if test -n "$LIBGBM_CFLAGS"; then
   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }; then
   pkg_cv_LIBGBM_CFLAGS=`$PKG_CONFIG --cflags "gbm >= 11.1.0" 2>/dev/null`
+		      test "x$?" != "x0" && pkg_failed=yes
 else
   pkg_failed=yes
 fi
@@ -22065,6 +23004,7 @@ if test -n "$LIBGBM_LIBS"; then
   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }; then
   pkg_cv_LIBGBM_LIBS=`$PKG_CONFIG --libs "gbm >= 11.1.0" 2>/dev/null`
+		      test "x$?" != "x0" && pkg_failed=yes
 else
   pkg_failed=yes
 fi
@@ -22075,7 +23015,7 @@ fi
 
 
 if test $pkg_failed = yes; then
-   	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
 
 if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
@@ -22084,16 +23024,16 @@ else
         _pkg_short_errors_supported=no
 fi
         if test $_pkg_short_errors_supported = yes; then
-	        LIBGBM_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "gbm >= 11.1.0" 2>&1`
+	        LIBGBM_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "gbm >= 11.1.0" 2>&1`
         else
-	        LIBGBM_PKG_ERRORS=`$PKG_CONFIG --print-errors "gbm >= 11.1.0" 2>&1`
+	        LIBGBM_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "gbm >= 11.1.0" 2>&1`
         fi
 	# Put the nasty error message in config.log where it belongs
 	echo "$LIBGBM_PKG_ERRORS" >&5
 
 	libgbm_avail=no
 elif test $pkg_failed = untried; then
-     	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
 	libgbm_avail=no
 else
@@ -22121,14 +23061,13 @@ fi
 $as_echo "#define SDL_VIDEO_DRIVER_KMSDRM 1" >>confdefs.h
 
             SOURCES="$SOURCES $srcdir/src/video/kmsdrm/*.c"
-            SOURCES="$SOURCES $srcdir/src/video/kmsdrm_legacy/*.c"
             EXTRA_CFLAGS="$EXTRA_CFLAGS $LIBDRM_CFLAGS $LIBGBM_CFLAGS"
 
             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for kmsdrm dynamic loading support" >&5
 $as_echo_n "checking for kmsdrm dynamic loading support... " >&6; }
             kmsdrm_shared=no
-            drm_lib=`find_lib "libdrm.so.*" "$DRM_LIBS"`
-            gbm_lib=`find_lib "libgbm.so.*" "$DRM_LIBS"`
+            drm_lib=`find_lib "libdrm.so.*" "$LIBDRM_LIBS"`
+            gbm_lib=`find_lib "libgbm.so.*" "$LIBGBM_LIBS"`
             if test x$have_loadso != xyes && \
                test x$enable_kmsdrm_shared = xyes; then
                 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: You must have SDL_LoadObject() support for dynamic kmsdrm loading" >&5
@@ -22159,6 +23098,10 @@ _ACEOF
             fi
             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $kmsdrm_shared" >&5
 $as_echo "$kmsdrm_shared" >&6; }
+            if test x$kmsdrm_shared = xyes; then
+                echo "-- dynamic libdrm -> $drm_lib"
+                echo "-- dynamic libgbm -> $gbm_lib"
+            fi
             have_video=yes
         fi
     fi
@@ -22183,6 +23126,25 @@ $as_echo "#define SDL_VIDEO_DRIVER_DUMMY 1" >>confdefs.h
     fi
 }
 
+CheckOffscreenVideo()
+{
+    # Check whether --enable-video-offscreen was given.
+if test "${enable_video_offscreen+set}" = set; then :
+  enableval=$enable_video_offscreen;
+else
+  enable_video_offscreen=no
+fi
+
+    if test x$enable_video_offscreen = xyes; then
+
+$as_echo "#define SDL_VIDEO_DRIVER_OFFSCREEN 1" >>confdefs.h
+
+        SOURCES="$SOURCES $srcdir/src/video/offscreen/*.c"
+        have_video=yes
+        SUMMARY_video="${SUMMARY_video} offscreen"
+    fi
+}
+
 CheckQNXVideo()
 {
     if test x$enable_video = xyes; then
@@ -22217,46 +23179,38 @@ else
 fi
 
 
-CheckOpenGLX11()
+CheckGLX()
 {
     if test x$enable_video = xyes -a x$enable_video_opengl = xyes; then
-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OpenGL (GLX) support" >&5
-$as_echo_n "checking for OpenGL (GLX) support... " >&6; }
-        video_opengl=no
+        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GLX support" >&5
+$as_echo_n "checking for GLX support... " >&6; }
+        video_opengl_glx=no
         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-         #include <GL/gl.h>
          #include <GL/glx.h>
 
 int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-        video_opengl=yes
-
+  video_opengl_glx=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $video_opengl" >&5
-$as_echo "$video_opengl" >&6; }
-        if test x$video_opengl = xyes; then
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $video_opengl_glx" >&5
+$as_echo "$video_opengl_glx" >&6; }
+        if test x$video_opengl_glx = xyes; then
 
 $as_echo "#define SDL_VIDEO_OPENGL 1" >>confdefs.h
 
 
 $as_echo "#define SDL_VIDEO_OPENGL_GLX 1" >>confdefs.h
 
-
-$as_echo "#define SDL_VIDEO_RENDER_OGL 1" >>confdefs.h
-
-            SUMMARY_video="${SUMMARY_video} opengl"
         fi
     fi
 }
@@ -22283,9 +23237,9 @@ else
 fi
 
 
-CheckOpenGLESX11()
+CheckEGL()
 {
-    if test x$enable_video = xyes -a x$enable_video_opengles = xyes; then
+    if test x$enable_video = xyes -a x$enable_video_opengl = xyes || test x$enable_video = xyes -a x$enable_video_opengles = xyes; then
         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EGL support" >&5
 $as_echo_n "checking for EGL support... " >&6; }
         video_opengl_egl=no
@@ -22303,15 +23257,12 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-        video_opengl_egl=yes
-
+  video_opengl_egl=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $video_opengl_egl" >&5
@@ -22321,7 +23272,50 @@ $as_echo "$video_opengl_egl" >&6; }
 $as_echo "#define SDL_VIDEO_OPENGL_EGL 1" >>confdefs.h
 
         fi
+    fi
+}
 
+CheckOpenGL()
+{
+    if test x$enable_video = xyes -a x$enable_video_opengl = xyes; then
+        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OpenGL headers" >&5
+$as_echo_n "checking for OpenGL headers... " >&6; }
+        video_opengl=no
+        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+         #include <GL/gl.h>
+         #include <GL/glext.h>
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  video_opengl=yes
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $video_opengl" >&5
+$as_echo "$video_opengl" >&6; }
+        if test x$video_opengl = xyes; then
+
+$as_echo "#define SDL_VIDEO_OPENGL 1" >>confdefs.h
+
+
+$as_echo "#define SDL_VIDEO_RENDER_OGL 1" >>confdefs.h
+
+            SUMMARY_video="${SUMMARY_video} opengl"
+        fi
+    fi
+}
+
+CheckOpenGLES()
+{
+    if test x$enable_video = xyes -a x$enable_video_opengles = xyes; then
         if test x$enable_video_opengles1 = xyes; then
             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OpenGL ES v1 headers" >&5
 $as_echo_n "checking for OpenGL ES v1 headers... " >&6; }
@@ -22336,15 +23330,12 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-            video_opengles_v1=yes
-
+  video_opengles_v1=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $video_opengles_v1" >&5
@@ -22374,15 +23365,12 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-            video_opengles_v2=yes
-
+  video_opengles_v2=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $video_opengles_v2" >&5
@@ -22432,15 +23420,12 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-        video_opengl_egl=yes
-
+  video_opengl_egl=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $video_opengl_egl" >&5
@@ -22468,15 +23453,12 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-        video_opengles_v2=yes
-
+  video_opengles_v2=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $video_opengles_v2" >&5
@@ -22562,15 +23544,12 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-        video_opengl_egl=yes
-
+  video_opengl_egl=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $video_opengl_egl" >&5
@@ -22594,15 +23573,12 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-        video_opengles_v2=yes
-
+  video_opengles_v2=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $video_opengles_v2" >&5
@@ -22643,24 +23619,20 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
 
-
 else
-
-                    enable_video_vulkan=no
-
+  enable_video_vulkan=no
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
                 ;;
             *-*-darwin*)
                 save_CFLAGS="$CFLAGS"
-                                CFLAGS="$CFLAGS -x objective-c"
+                CFLAGS="$CFLAGS -x objective-c"
                 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
@@ -22676,18 +23648,14 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
 
-
 else
-
-                    enable_video_vulkan=no
-
+  enable_video_vulkan=no
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
                 CFLAGS="$save_CFLAGS"
@@ -22702,6 +23670,11 @@ rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 $as_echo "$as_me: WARNING: Vulkan does not work on this configuration." >&2;}
         fi
     fi
+    if test x$have_loadso != xyes; then
+        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Vulkan support is available, but disabled because there's no loadso." >&5
+$as_echo "$as_me: WARNING: Vulkan support is available, but disabled because there's no loadso." >&2;}
+        enable_video_vulkan=no
+    fi
     if test x$enable_video_vulkan = xyes; then
 
 $as_echo "#define SDL_VIDEO_VULKAN 1" >>confdefs.h
@@ -22712,7 +23685,7 @@ $as_echo "#define SDL_VIDEO_VULKAN 1" >>confdefs.h
 
 CheckInputEvents()
 {
-            { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Linux 2.4 unified input interface" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Linux 2.4 unified input interface" >&5
 $as_echo_n "checking for Linux 2.4 unified input interface... " >&6; }
         use_input_events=no
         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
@@ -22733,9 +23706,7 @@ main ()
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-        use_input_events=yes
-
+  use_input_events=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $use_input_events" >&5
@@ -22750,7 +23721,6 @@ $as_echo "#define SDL_INPUT_LINUXEV 1" >>confdefs.h
 
 CheckInputKD()
 {
-
     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Linux kd.h" >&5
 $as_echo_n "checking for Linux kd.h... " >&6; }
     use_input_kd=no
@@ -22773,9 +23743,7 @@ main ()
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-    use_input_kd=yes
-
+  use_input_kd=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $use_input_kd" >&5
@@ -22803,7 +23771,7 @@ int
 main ()
 {
 
-    	accentmap_t accTable;
+        accentmap_t accTable;
         ioctl(0, KDENABIO, 1);
 
   ;
@@ -22811,9 +23779,7 @@ main ()
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-    use_input_kbio=yes
-
+  use_input_kbio=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $use_input_kbio" >&5
@@ -22826,6 +23792,45 @@ $as_echo "#define SDL_INPUT_FBSDKBIO 1" >>confdefs.h
     fi
 }
 
+CheckInputWSCONS()
+{
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OpenBSD wscons" >&5
+$as_echo_n "checking for OpenBSD wscons... " >&6; }
+    use_input_wscons=no
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+     #include <sys/time.h>
+     #include <dev/wscons/wsconsio.h>
+     #include <dev/wscons/wsksymdef.h>
+     #include <dev/wscons/wsksymvar.h>
+     #include <sys/ioctl.h>
+
+int
+main ()
+{
+
+     struct wskbd_map_data data;
+     ioctl(0, WSKBDIO_GETMAP, &data);
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  use_input_wscons=yes
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $use_input_wscons" >&5
+$as_echo "$use_input_wscons" >&6; }
+    if test x$use_input_wscons = xyes; then
+
+$as_echo "#define SDL_INPUT_WSCONS 1" >>confdefs.h
+
+        SUMMARY_input="${SUMMARY_input} wscons"
+    fi
+}
+
 CheckLibUDev()
 {
     # Check whether --enable-libudev was given.
@@ -22874,8 +23879,8 @@ fi
     if test x$enable_dbus = xyes; then
 
 pkg_failed=no
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for DBUS" >&5
-$as_echo_n "checking for DBUS... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for dbus-1" >&5
+$as_echo_n "checking for dbus-1... " >&6; }
 
 if test -n "$DBUS_CFLAGS"; then
     pkg_cv_DBUS_CFLAGS="$DBUS_CFLAGS"
@@ -22887,6 +23892,7 @@ if test -n "$DBUS_CFLAGS"; then
   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }; then
   pkg_cv_DBUS_CFLAGS=`$PKG_CONFIG --cflags "dbus-1" 2>/dev/null`
+		      test "x$?" != "x0" && pkg_failed=yes
 else
   pkg_failed=yes
 fi
@@ -22903,6 +23909,7 @@ if test -n "$DBUS_LIBS"; then
   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }; then
   pkg_cv_DBUS_LIBS=`$PKG_CONFIG --libs "dbus-1" 2>/dev/null`
+		      test "x$?" != "x0" && pkg_failed=yes
 else
   pkg_failed=yes
 fi
@@ -22913,7 +23920,7 @@ fi
 
 
 if test $pkg_failed = yes; then
-   	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
 
 if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
@@ -22922,16 +23929,16 @@ else
         _pkg_short_errors_supported=no
 fi
         if test $_pkg_short_errors_supported = yes; then
-	        DBUS_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "dbus-1" 2>&1`
+	        DBUS_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "dbus-1" 2>&1`
         else
-	        DBUS_PKG_ERRORS=`$PKG_CONFIG --print-errors "dbus-1" 2>&1`
+	        DBUS_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "dbus-1" 2>&1`
         fi
 	# Put the nasty error message in config.log where it belongs
 	echo "$DBUS_PKG_ERRORS" >&5
 
 	have_dbus=no
 elif test $pkg_failed = untried; then
-     	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
 	have_dbus=no
 else
@@ -22941,8 +23948,8 @@ else
 $as_echo "yes" >&6; }
 	have_dbus=yes
 fi
-        save_CFLAGS="$CFLAGS"
-        CFLAGS="$save_CFLAGS $DBUS_CFLAGS"
+        save_CPPFLAGS="$CPPFLAGS"
+        CPPFLAGS="$save_CPPFLAGS $DBUS_CFLAGS"
         ac_fn_c_check_header_mongrel "$LINENO" "dbus/dbus.h" "ac_cv_header_dbus_dbus_h" "$ac_includes_default"
 if test "x$ac_cv_header_dbus_dbus_h" = xyes; then :
   have_dbus_dbus_h_hdr=yes
@@ -22951,7 +23958,7 @@ else
 fi
 
 
-        CFLAGS="$save_CFLAGS"
+        CPPFLAGS="$save_CPPFLAGS"
         if test x$have_dbus_dbus_h_hdr = xyes; then
 
 $as_echo "#define HAVE_DBUS_DBUS_H 1" >>confdefs.h
@@ -23045,8 +24052,8 @@ fi
     if test x$enable_ibus = xyes; then
 
 pkg_failed=no
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for IBUS" >&5
-$as_echo_n "checking for IBUS... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ibus-1.0" >&5
+$as_echo_n "checking for ibus-1.0... " >&6; }
 
 if test -n "$IBUS_CFLAGS"; then
     pkg_cv_IBUS_CFLAGS="$IBUS_CFLAGS"
@@ -23058,6 +24065,7 @@ if test -n "$IBUS_CFLAGS"; then
   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }; then
   pkg_cv_IBUS_CFLAGS=`$PKG_CONFIG --cflags "ibus-1.0" 2>/dev/null`
+		      test "x$?" != "x0" && pkg_failed=yes
 else
   pkg_failed=yes
 fi
@@ -23074,6 +24082,7 @@ if test -n "$IBUS_LIBS"; then
   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }; then
   pkg_cv_IBUS_LIBS=`$PKG_CONFIG --libs "ibus-1.0" 2>/dev/null`
+		      test "x$?" != "x0" && pkg_failed=yes
 else
   pkg_failed=yes
 fi
@@ -23084,7 +24093,7 @@ fi
 
 
 if test $pkg_failed = yes; then
-   	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
 
 if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
@@ -23093,16 +24102,16 @@ else
         _pkg_short_errors_supported=no
 fi
         if test $_pkg_short_errors_supported = yes; then
-	        IBUS_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "ibus-1.0" 2>&1`
+	        IBUS_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "ibus-1.0" 2>&1`
         else
-	        IBUS_PKG_ERRORS=`$PKG_CONFIG --print-errors "ibus-1.0" 2>&1`
+	        IBUS_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "ibus-1.0" 2>&1`
         fi
 	# Put the nasty error message in config.log where it belongs
 	echo "$IBUS_PKG_ERRORS" >&5
 
 	have_ibus=no
 elif test $pkg_failed = untried; then
-     	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
 	have_ibus=no
 else
@@ -23112,8 +24121,8 @@ else
 $as_echo "yes" >&6; }
 	have_ibus=yes
 fi
-        save_CFLAGS="$CFLAGS"
-        CFLAGS="$save_CFLAGS $IBUS_CFLAGS"
+        save_CPPFLAGS="$CPPFLAGS"
+        CPPFLAGS="$save_CPPFLAGS $IBUS_CFLAGS"
         ac_fn_c_check_header_mongrel "$LINENO" "ibus-1.0/ibus.h" "ac_cv_header_ibus_1_0_ibus_h" "$ac_includes_default"
 if test "x$ac_cv_header_ibus_1_0_ibus_h" = xyes; then :
   have_ibus_ibus_h_hdr=yes
@@ -23122,7 +24131,7 @@ else
 fi
 
 
-        CFLAGS="$save_CFLAGS"
+        CPPFLAGS="$save_CPPFLAGS"
         if test x$have_ibus_ibus_h_hdr = xyes; then
             if test x$enable_ime != xyes; then
                 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: IME support is required for IBus." >&5
@@ -23191,7 +24200,7 @@ fi
     if test x$enable_joystick_mfi = xyes; then
         save_CFLAGS="$CFLAGS"
         save_LDFLAGS="$LDFLAGS"
-                CFLAGS="$CFLAGS -x objective-c -fobjc-weak"
+        CFLAGS="$CFLAGS -x objective-c -fobjc-weak"
         LDFLAGS="$LDFLAGS -Wl,-weak_framework,CoreHaptics -Wl,-weak_framework,GameController"
         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GameController framework" >&5
 $as_echo_n "checking for GameController framework... " >&6; }
@@ -23219,9 +24228,7 @@ main ()
 }
 _ACEOF
 if ac_fn_c_try_link "$LINENO"; then :
-
-        enable_joystick_mfi=yes
-
+  enable_joystick_mfi=yes
 fi
 rm -f core conftest.err conftest.$ac_objext \
     conftest$ac_exeext conftest.$ac_ext
@@ -23242,20 +24249,39 @@ $as_echo "#define SDL_JOYSTICK_MFI 1" >>confdefs.h
 
 CheckPTHREAD()
 {
-        # Check whether --enable-pthreads was given.
+
+
+    case "$host" in
+        *-*-emscripten*)
+            enable_pthreads_default=no
+            ;;
+        *)
+            enable_pthreads_default=yes
+            ;;
+    esac
+
+    # Check whether --enable-pthreads was given.
 if test "${enable_pthreads+set}" = set; then :
   enableval=$enable_pthreads;
 else
-  enable_pthreads=yes
+  enable_pthreads=maybe
 fi
 
-        # Check whether --enable-pthread-sem was given.
+    # Check whether --enable-pthread-sem was given.
 if test "${enable_pthread_sem+set}" = set; then :
   enableval=$enable_pthread_sem;
 else
-  enable_pthread_sem=yes
+  enable_pthread_sem=maybe
 fi
 
+
+    if test x$enable_pthreads = xmaybe; then
+        enable_pthreads=$enable_pthreads_default
+    fi
+    if test x$enable_pthread_sem = xmaybe; then
+        enable_pthread_sem=$enable_pthreads
+    fi
+
     case "$host" in
          *-*-android*)
             pthread_cflags="-D_REENTRANT -D_THREAD_SAFE"
@@ -23321,6 +24347,10 @@ fi
             pthread_cflags="-D_REENTRANT"
             pthread_lib=""
             ;;
+        *-*-emscripten*)
+            pthread_cflags="-D_REENTRANT -pthread"
+            pthread_lib="-pthread"
+            ;;
         *)
             pthread_cflags="-D_REENTRANT"
             pthread_lib="-lpthread"
@@ -23352,9 +24382,7 @@ main ()
 }
 _ACEOF
 if ac_fn_c_try_link "$LINENO"; then :
-
-        use_pthreads=yes
-
+  use_pthreads=yes
 fi
 rm -f core conftest.err conftest.$ac_objext \
     conftest$ac_exeext conftest.$ac_ext
@@ -23457,15 +24485,12 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-                have_pthread_sem=yes
-
+  have_pthread_sem=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_pthread_sem" >&5
@@ -23639,15 +24664,12 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-    have_win32_gcc=yes
-
+  have_win32_gcc=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_win32_gcc" >&5
@@ -23672,7 +24694,6 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
@@ -23693,6 +24714,35 @@ $as_echo "$have_wince" >&6; }
     CheckStackBoundary
 }
 
+CheckOS2()
+{
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking OS/2 compiler" >&5
+$as_echo_n "checking OS/2 compiler... " >&6; }
+    have_os2_gcc=no
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <os2.h>
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  have_os2_gcc=yes
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_os2_gcc" >&5
+$as_echo "$have_os2_gcc" >&6; }
+    if test x$have_os2_gcc != xyes; then
+       as_fn_error $? "
+*** Your compiler ($CC) does not produce OS/2 executables!
+       " "$LINENO" 5
+    fi
+}
+
 CheckDIRECTX()
 {
     # Check whether --enable-directx was given.
@@ -23739,50 +24789,6 @@ if test "x$ac_cv_header_dxgi_h" = xyes; then :
 fi
 
 
-        ac_fn_c_check_header_mongrel "$LINENO" "xinput.h" "ac_cv_header_xinput_h" "$ac_includes_default"
-if test "x$ac_cv_header_xinput_h" = xyes; then :
-  have_xinput=yes
-fi
-
-
-        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-#include <windows.h>
-#include <xinput.h>
-XINPUT_GAMEPAD_EX x1;
-
-int
-main ()
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"; then :
-  have_xinput_gamepadex=yes
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-#include <windows.h>
-#include <xinput.h>
-XINPUT_STATE_EX s1;
-
-int
-main ()
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"; then :
-  have_xinput_stateex=yes
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
         if test x$have_ddraw = xyes; then
 
@@ -23804,6 +24810,79 @@ $as_echo "#define HAVE_DSOUND_H 1" >>confdefs.h
 $as_echo "#define HAVE_DXGI_H 1" >>confdefs.h
 
         fi
+
+        # FIXME: latest Cygwin finds dinput headers, but we die on other win32 headers.
+        # FIXME:  ...so force it off for now.
+        case "$host" in
+            *-*-cygwin*)
+            have_dinput=false
+            ;;
+        esac
+    fi
+
+    # Check whether --enable-xinput was given.
+if test "${enable_xinput+set}" = set; then :
+  enableval=$enable_xinput;
+else
+  enable_xinput=yes
+fi
+
+    if test x$enable_xinput = xyes; then
+        have_xinput_gamepadex=no
+        have_xinput_stateex=no
+        ac_fn_c_check_header_mongrel "$LINENO" "xinput.h" "ac_cv_header_xinput_h" "$ac_includes_default"
+if test "x$ac_cv_header_xinput_h" = xyes; then :
+  have_xinput=yes
+fi
+
+
+        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for struct XINPUT_GAMEPAD_EX" >&5
+$as_echo_n "checking for struct XINPUT_GAMEPAD_EX... " >&6; }
+        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+#include <windows.h>
+#include <xinput.h>
+XINPUT_GAMEPAD_EX x1;
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  have_xinput_gamepadex=yes
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_xinput_gamepadex" >&5
+$as_echo "$have_xinput_gamepadex" >&6; }
+        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for struct XINPUT_STATE_EX" >&5
+$as_echo_n "checking for struct XINPUT_STATE_EX... " >&6; }
+        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+#include <windows.h>
+#include <xinput.h>
+XINPUT_STATE_EX s1;
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  have_xinput_stateex=yes
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_xinput_stateex" >&5
+$as_echo "$have_xinput_stateex" >&6; }
+
         if test x$have_xinput = xyes; then
 
 $as_echo "#define HAVE_XINPUT_H 1" >>confdefs.h
@@ -23819,14 +24898,38 @@ $as_echo "#define HAVE_XINPUT_GAMEPAD_EX 1" >>confdefs.h
 $as_echo "#define HAVE_XINPUT_STATE_EX 1" >>confdefs.h
 
         fi
+    fi
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for windows.gaming.input.h" >&5
+$as_echo_n "checking for windows.gaming.input.h... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+#define COBJMACROS
+#include <windows.gaming.input.h>
+__x_ABI_CWindows_CGaming_CInput_CIGamepadStatics2 *s2;
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  have_wgi=yes
+else
+  have_wgi=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_wgi" >&5
+$as_echo "$have_wgi" >&6; }
+
+    if test x$have_wgi = xyes; then
+
+$as_echo "#define HAVE_WINDOWS_GAMING_INPUT_H 1" >>confdefs.h
 
-        # FIXME: latest Cygwin finds dinput headers, but we die on other win32 headers.
-        # FIXME:  ...so force it off for now.
-        case "$host" in
-            *-*-cygwin*)
-            have_dinput=false
-            ;;
-        esac
     fi
 
     ac_fn_c_check_header_mongrel "$LINENO" "mmdeviceapi.h" "ac_cv_header_mmdeviceapi_h" "$ac_includes_default"
@@ -23865,44 +24968,21 @@ fi
 
 CheckDLOPEN()
 {
-    # Check whether --enable-sdl-dlopen was given.
-if test "${enable_sdl_dlopen+set}" = set; then :
-  enableval=$enable_sdl_dlopen;
+
+$as_echo "#define DYNAPI_NEEDS_DLOPEN 1" >>confdefs.h
+
+
+    ac_fn_c_check_header_mongrel "$LINENO" "dlfcn.h" "ac_cv_header_dlfcn_h" "$ac_includes_default"
+if test "x$ac_cv_header_dlfcn_h" = xyes; then :
+  have_dlfcn_h=yes
 else
-  enable_sdl_dlopen=yes
+  have_dlfcn_h=no
 fi
 
-    if test x$enable_sdl_dlopen = xyes; then
-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen" >&5
-$as_echo_n "checking for dlopen... " >&6; }
-        have_dlopen=no
-        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
 
-         #include <dlfcn.h>
 
-int
-main ()
-{
-
-         void *handle = dlopen("", RTLD_NOW);
-         const char *loaderror = (char *) dlerror();
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"; then :
-
-        have_dlopen=yes
-
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_dlopen" >&5
-$as_echo "$have_dlopen" >&6; }
-
-        if test x$have_dlopen = xyes; then
-            { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lc" >&5
+    have_dlopen=no
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lc" >&5
 $as_echo_n "checking for dlopen in -lc... " >&6; }
 if ${ac_cv_lib_c_dlopen+:} false; then :
   $as_echo_n "(cached) " >&6
@@ -23939,7 +25019,7 @@ fi
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_c_dlopen" >&5
 $as_echo "$ac_cv_lib_c_dlopen" >&6; }
 if test "x$ac_cv_lib_c_dlopen" = xyes; then :
-  EXTRA_LDFLAGS="$EXTRA_LDFLAGS"
+  have_dlopen=yes
 else
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
 $as_echo_n "checking for dlopen in -ldl... " >&6; }
@@ -23978,58 +25058,60 @@ fi
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
 $as_echo "$ac_cv_lib_dl_dlopen" >&6; }
 if test "x$ac_cv_lib_dl_dlopen" = xyes; then :
-  EXTRA_LDFLAGS="$EXTRA_LDFLAGS -ldl"
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lltdl" >&5
-$as_echo_n "checking for dlopen in -lltdl... " >&6; }
-if ${ac_cv_lib_ltdl_dlopen+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  ac_check_lib_save_LIBS=$LIBS
-LIBS="-lltdl  $LIBS"
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+  have_dlopen=yes; EXTRA_LDFLAGS="$EXTRA_LDFLAGS -ldl"
+fi
+
+fi
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen" >&5
+$as_echo_n "checking for dlopen... " >&6; }
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_dlopen" >&5
+$as_echo "$have_dlopen" >&6; }
+
+    if test x$have_dlfcn_h = xyes -a x$have_dlopen = xyes; then
+
+$as_echo "#define HAVE_DLOPEN 1" >>confdefs.h
+
+       if test x$enable_loadso = xyes; then
+
+$as_echo "#define SDL_LOADSO_DLOPEN 1" >>confdefs.h
+
+          SOURCES="$SOURCES $srcdir/src/loadso/dlopen/*.c"
+          have_loadso=yes
+       fi
+    fi
+}
+
+CheckO_CLOEXEC()
+{
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for O_CLOEXEC" >&5
+$as_echo_n "checking for O_CLOEXEC... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-/* Override any GCC internal prototype to avoid an error.
-   Use char because int might match the return type of a GCC
-   builtin and then its argument prototype would still apply.  */
-#ifdef __cplusplus
-extern "C"
-#endif
-char dlopen ();
+#include <fcntl.h>
+int flag = O_CLOEXEC;
+
 int
 main ()
 {
-return dlopen ();
+
   ;
   return 0;
 }
 _ACEOF
-if ac_fn_c_try_link "$LINENO"; then :
-  ac_cv_lib_ltdl_dlopen=yes
+if ac_fn_c_try_compile "$LINENO"; then :
+  have_o_cloexec=yes
 else
-  ac_cv_lib_ltdl_dlopen=no
-fi
-rm -f core conftest.err conftest.$ac_objext \
-    conftest$ac_exeext conftest.$ac_ext
-LIBS=$ac_check_lib_save_LIBS
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ltdl_dlopen" >&5
-$as_echo "$ac_cv_lib_ltdl_dlopen" >&6; }
-if test "x$ac_cv_lib_ltdl_dlopen" = xyes; then :
-  EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lltdl"
+  have_o_cloexec=no
 fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_o_cloexec" >&5
+$as_echo "$have_o_cloexec" >&6; }
+    if test $have_o_cloexec = yes; then
 
-fi
+$as_echo "#define HAVE_O_CLOEXEC 1" >>confdefs.h
 
-fi
-
-
-$as_echo "#define SDL_LOADSO_DLOPEN 1" >>confdefs.h
-
-            SOURCES="$SOURCES $srcdir/src/loadso/dlopen/*.c"
-            have_loadso=yes
-        fi
     fi
 }
 
@@ -24188,9 +25270,7 @@ main ()
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-                have_usbhid=yes
-
+  have_usbhid=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_usbhid" >&5
@@ -24234,9 +25314,7 @@ main ()
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-                    have_usbhid_ucr_data=yes
-
+  have_usbhid_ucr_data=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
                     if test x$have_usbhid_ucr_data = xyes; then
@@ -24282,9 +25360,7 @@ main ()
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-                    have_usbhid_new=yes
-
+  have_usbhid_new=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
                     if test x$have_usbhid_new = xyes; then
@@ -24312,14 +25388,12 @@ main ()
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-                    have_machine_joystick=yes
-
+  have_machine_joystick=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
                     if test x$have_machine_joystick = xyes; then
 
-$as_echo "#define SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H 1" >>confdefs.h
+$as_echo "#define SDL_HAVE_MACHINE_JOYSTICK_H 1" >>confdefs.h
 
                     fi
                     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_machine_joystick" >&5
@@ -24333,6 +25407,7 @@ $as_echo "#define SDL_JOYSTICK_USBHID 1" >>confdefs.h
                     EXTRA_LDFLAGS="$EXTRA_LDFLAGS $USB_LIBS"
                     have_joystick=yes
                 fi
+
                 CFLAGS="$save_CFLAGS"
             fi
         ;;
@@ -24341,11 +25416,11 @@ $as_echo "#define SDL_JOYSTICK_USBHID 1" >>confdefs.h
 
 CheckHIDAPI()
 {
-    # Check whether --enable-hidapi was given.
-if test "${enable_hidapi+set}" = set; then :
-  enableval=$enable_hidapi;
+    # Check whether --enable-hidapi-joystick was given.
+if test "${enable_hidapi_joystick+set}" = set; then :
+  enableval=$enable_hidapi_joystick;
 else
-  enable_hidapi=yes
+  enable_hidapi_joystick=yes
 fi
 
     # Check whether --enable-hidapi-libusb was given.
@@ -24356,7 +25431,7 @@ else
 fi
 
 
-    if test x$enable_joystick = xyes -a x$enable_hidapi = xyes; then
+    if test x$enable_hidapi = xyes; then
         case "$host" in
             # libusb does not support iOS
             *-ios-* )
@@ -24367,9 +25442,8 @@ fi
                 enable_hidapi_libusb=yes
                 require_hidapi_libusb=yes
                 ;;
-            # RAWINPUT is only available on Win32, but can be enabled if HIDAPI is
-            *-*-cygwin* | *-*-mingw32*)
-                enable_joystick_rawinput=yes
+           *-*-os2* )
+                enable_hidapi_libusb=yes
                 ;;
         esac
 
@@ -24377,8 +25451,8 @@ fi
         if test x$enable_hidapi_libusb = xyes; then
 
 pkg_failed=no
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for LIBUSB" >&5
-$as_echo_n "checking for LIBUSB... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for libusb-1.0" >&5
+$as_echo_n "checking for libusb-1.0... " >&6; }
 
 if test -n "$LIBUSB_CFLAGS"; then
     pkg_cv_LIBUSB_CFLAGS="$LIBUSB_CFLAGS"
@@ -24390,6 +25464,7 @@ if test -n "$LIBUSB_CFLAGS"; then
   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }; then
   pkg_cv_LIBUSB_CFLAGS=`$PKG_CONFIG --cflags "libusb-1.0" 2>/dev/null`
+		      test "x$?" != "x0" && pkg_failed=yes
 else
   pkg_failed=yes
 fi
@@ -24406,6 +25481,7 @@ if test -n "$LIBUSB_LIBS"; then
   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }; then
   pkg_cv_LIBUSB_LIBS=`$PKG_CONFIG --libs "libusb-1.0" 2>/dev/null`
+		      test "x$?" != "x0" && pkg_failed=yes
 else
   pkg_failed=yes
 fi
@@ -24416,7 +25492,7 @@ fi
 
 
 if test $pkg_failed = yes; then
-   	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
 
 if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
@@ -24425,16 +25501,16 @@ else
         _pkg_short_errors_supported=no
 fi
         if test $_pkg_short_errors_supported = yes; then
-	        LIBUSB_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "libusb-1.0" 2>&1`
+	        LIBUSB_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "libusb-1.0" 2>&1`
         else
-	        LIBUSB_PKG_ERRORS=`$PKG_CONFIG --print-errors "libusb-1.0" 2>&1`
+	        LIBUSB_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "libusb-1.0" 2>&1`
         fi
 	# Put the nasty error message in config.log where it belongs
 	echo "$LIBUSB_PKG_ERRORS" >&5
 
 	have_libusb=no
 elif test $pkg_failed = untried; then
-     	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
 	have_libusb=no
 else
@@ -24444,33 +25520,23 @@ else
 $as_echo "yes" >&6; }
 	have_libusb=yes
 fi
-            save_CFLAGS="$CFLAGS"
-            CFLAGS="$save_CFLAGS $LIBUSB_CFLAGS"
+            save_CPPFLAGS="$CPPFLAGS"
+            CPPFLAGS="$save_CPPFLAGS $LIBUSB_CFLAGS"
             ac_fn_c_check_header_mongrel "$LINENO" "libusb.h" "ac_cv_header_libusb_h" "$ac_includes_default"
 if test "x$ac_cv_header_libusb_h" = xyes; then :
   have_libusb_h=yes
+else
+  have_libusb_h=no
 fi
 
 
-            CFLAGS="$save_CFLAGS"
+            CPPFLAGS="$save_CPPFLAGS"
             if test x$have_libusb_h = xno && test x$require_hidapi_libusb = xyes; then
                 hidapi_support=no
             fi
         fi
 
         if test x$hidapi_support = xyes; then
-
-$as_echo "#define SDL_JOYSTICK_HIDAPI 1" >>confdefs.h
-
-            if test x$enable_joystick_rawinput = xyes; then
-
-$as_echo "#define SDL_JOYSTICK_RAWINPUT 1" >>confdefs.h
-
-            fi
-            EXTRA_CFLAGS="$EXTRA_CFLAGS -I$srcdir/src/hidapi/hidapi"
-            SOURCES="$SOURCES $srcdir/src/joystick/hidapi/*.c"
-            SOURCES="$SOURCES $srcdir/src/hidapi/SDL_hidapi.c"
-
             if test x$have_libusb_h = xyes; then
                 EXTRA_CFLAGS="$EXTRA_CFLAGS $LIBUSB_CFLAGS"
                 if test x$require_hidapi_libusb = xyes; then
@@ -24486,9 +25552,12 @@ $as_echo "$as_me: WARNING: You must have SDL_LoadObject() support for dynamic li
                         *-*-darwin* )
                             libusb_lib="libusb-1.0.0.dylib"
                             ;;
-                        *-*-cygwin* | *-*-mingw32* )
+                        *-*-cygwin* | *-*-mingw* )
                             libusb_lib="libusb-1.0.dll"
                             ;;
+                        *-*-os2* )
+                            libusb_lib="usb100.dll"
+                            ;;
                     esac
                     if test x$libusb_lib = x; then
                         libusb_lib=`find_lib "libusb-1.0.so.*" "" | sed 's/.*\/\(.*\)/\1/; q'`
@@ -24502,11 +25571,18 @@ _ACEOF
             fi
         fi
 
-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for hidapi support" >&5
-$as_echo_n "checking for hidapi support... " >&6; }
+        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for hidapi joystick support" >&5
+$as_echo_n "checking for hidapi joystick support... " >&6; }
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hidapi_support" >&5
 $as_echo "$hidapi_support" >&6; }
     fi
+
+    if test x$enable_joystick = xyes -a x$hidapi_support = xyes -a x$enable_hidapi_joystick = xyes; then
+
+$as_echo "#define SDL_JOYSTICK_HIDAPI 1" >>confdefs.h
+
+        SOURCES="$SOURCES $srcdir/src/joystick/hidapi/*.c"
+    fi
 }
 
 CheckClockGettime()
@@ -24707,6 +25783,7 @@ case "$host" in
 $as_echo "#define SDL_VIDEO_DRIVER_ANDROID 1" >>confdefs.h
 
                     SUMMARY_video="${SUMMARY_video} android"
+                    have_video=yes
                 fi
                 ;;
             *-*-linux*)         ARCH=linux ;;
@@ -24732,13 +25809,16 @@ $as_echo "#define SDL_VIDEO_DRIVER_ANDROID 1" >>confdefs.h
         CheckVisibilityHidden
         CheckDeclarationAfterStatement
         CheckDummyVideo
+        CheckOffscreenVideo
         CheckDiskAudio
         CheckDummyAudio
         CheckDLOPEN
         CheckARM
         CheckNEON
+        CheckO_CLOEXEC
         CheckOSS
         CheckALSA
+        CheckPipewire
         CheckPulseAudio
         CheckJACK
         CheckARTSC
@@ -24751,9 +25831,12 @@ $as_echo "#define SDL_VIDEO_DRIVER_ANDROID 1" >>confdefs.h
         CheckRPI
         CheckX11
         CheckDirectFB
+        # Need to check for EGL first because KMSDRM and Wayland depends on it.
+        CheckEGL
         CheckKMSDRM
-        CheckOpenGLX11
-        CheckOpenGLESX11
+        CheckGLX
+        CheckOpenGL
+        CheckOpenGLES
         CheckVulkan
         CheckWayland
         CheckInputEvents
@@ -24770,6 +25853,9 @@ $as_echo "#define SDL_VIDEO_DRIVER_ANDROID 1" >>confdefs.h
           freebsd)
               CheckInputKBIO
           ;;
+          openbsd|netbsd)
+              CheckInputWSCONS
+          ;;
         esac
         CheckUSBHID
         CheckHIDAPI
@@ -24779,12 +25865,16 @@ $as_echo "#define SDL_VIDEO_DRIVER_ANDROID 1" >>confdefs.h
         CheckRPATH
         CheckVivanteVideo
 
-        SOURCES="$SOURCES $srcdir/src/misc/unix/*.c"
-        have_misc=yes
-
-        SOURCES="$SOURCES $srcdir/src/locale/unix/*.c"
-        have_locale=yes
-
+        # Set up files for the misc library
+        if test x$enable_misc = xyes; then
+            SOURCES="$SOURCES $srcdir/src/misc/unix/*.c"
+            have_misc=yes
+        fi
+        # Set up files for the locale library
+        if test x$enable_locale = xyes; then
+            SOURCES="$SOURCES $srcdir/src/locale/unix/*.c"
+            have_locale=yes
+        fi
         # Set up files for the audio library
         if test x$enable_audio = xyes; then
           case $ARCH in
@@ -24818,6 +25908,19 @@ $as_echo "#define SDL_AUDIO_DRIVER_ANDROID 1" >>confdefs.h
 
                 SOURCES="$SOURCES $srcdir/src/audio/android/*.c"
                 SUMMARY_audio="${SUMMARY_audio} android"
+
+
+$as_echo "#define SDL_AUDIO_DRIVER_OPENSLES 1" >>confdefs.h
+
+                SOURCES="$SOURCES $srcdir/src/audio/openslES/*.c"
+                SUMMARY_audio="${SUMMARY_audio} openslES"
+
+
+$as_echo "#define SDL_AUDIO_DRIVER_AAUDIO 1" >>confdefs.h
+
+                SOURCES="$SOURCES $srcdir/src/audio/aaudio/*.c"
+                SUMMARY_audio="${SUMMARY_audio} aaudio"
+
                 have_audio=yes
             ;;
             nto)
@@ -24945,12 +26048,17 @@ $as_echo "#define SDL_TIMER_UNIX 1" >>confdefs.h
             SOURCES="$SOURCES $srcdir/src/core/linux/SDL_evdev_kbd.c"
             SOURCES="$SOURCES $srcdir/src/core/freebsd/SDL_evdev_kbd_freebsd.c"
         fi
+        # Set up files for wscons input
+        if test x$use_input_wscons = xyes; then
+            SOURCES="$SOURCES $srcdir/src/core/openbsd/SDL_wscons_kbd.c"
+            SOURCES="$SOURCES $srcdir/src/core/openbsd/SDL_wscons_mouse.c"
+        fi
         # Set up other core UNIX files
         SOURCES="$SOURCES $srcdir/src/core/linux/SDL_evdev_capabilities.c"
         SOURCES="$SOURCES $srcdir/src/core/linux/SDL_threadprio.c"
         SOURCES="$SOURCES $srcdir/src/core/unix/*.c"
         ;;
-    *-*-cygwin* | *-*-mingw32*)
+    *-*-cygwin* | *-*-mingw*)
         ARCH=win32
         if test "$build" != "$host"; then # cross-compiling
             # Default cross-compile location
@@ -24961,8 +26069,12 @@ $as_echo "#define SDL_TIMER_UNIX 1" >>confdefs.h
                 ac_default_prefix=$BUILD_PREFIX
             fi
         fi
+        if test x$enable_loadso = xyes; then
+            have_loadso=yes
+        fi
         CheckDeclarationAfterStatement
         CheckDummyVideo
+        CheckOffscreenVideo
         CheckDiskAudio
         CheckDummyAudio
         CheckWINDOWS
@@ -24974,14 +26086,16 @@ $as_echo "#define SDL_TIMER_UNIX 1" >>confdefs.h
 
         # Set up the core platform files
         SOURCES="$SOURCES $srcdir/src/core/windows/*.c"
-
-        SOURCES="$SOURCES $srcdir/src/misc/windows/*.c"
-        have_misc=yes
-
+        # Set up files for the misc library
+        if test x$enable_misc = xyes; then
+            SOURCES="$SOURCES $srcdir/src/misc/windows/*.c"
+            have_misc=yes
+        fi
         # Use the Windows locale APIs.
-        SOURCES="$SOURCES $srcdir/src/locale/windows/*.c"
-        have_locale=yes
-
+        if test x$enable_locale = xyes; then
+            SOURCES="$SOURCES $srcdir/src/locale/windows/*.c"
+            have_locale=yes
+        fi
         # Set up files for the video library
         if test x$enable_video = xyes; then
 
@@ -25034,11 +26148,19 @@ $as_echo "#define SDL_AUDIO_DRIVER_WASAPI 1" >>confdefs.h
         fi
         # Set up files for the joystick library
         if test x$enable_joystick = xyes; then
-            if test x$have_dinput = xyes -o x$have_xinput = xyes; then
+
+$as_echo "#define SDL_JOYSTICK_RAWINPUT 1" >>confdefs.h
+
+            if test x$have_dinput = xyes -o x$have_xinput = xyes -o x$have_wgi = xyes; then
                 if test x$have_xinput = xyes; then
 
 $as_echo "#define SDL_JOYSTICK_XINPUT 1" >>confdefs.h
 
+                fi
+                if test x$have_wgi = xyes; then
+
+$as_echo "#define SDL_JOYSTICK_WGI 1" >>confdefs.h
+
                 fi
                 if test x$have_dinput = xyes; then
 
@@ -25046,10 +26168,6 @@ $as_echo "#define SDL_JOYSTICK_DINPUT 1" >>confdefs.h
 
                     EXTRA_LDFLAGS="$EXTRA_LDFLAGS -ldinput8 -ldxguid -ldxerr8"
                 fi
-            else
-
-$as_echo "#define SDL_JOYSTICK_WINMM 1" >>confdefs.h
-
             fi
             SOURCES="$SOURCES $srcdir/src/joystick/windows/*.c"
             have_joystick=yes
@@ -25070,6 +26188,17 @@ $as_echo "#define SDL_HAPTIC_DINPUT 1" >>confdefs.h
                 have_haptic=yes
             fi
         fi
+        ac_fn_c_check_header_mongrel "$LINENO" "tpcshrd.h" "ac_cv_header_tpcshrd_h" "$ac_includes_default"
+if test "x$ac_cv_header_tpcshrd_h" = xyes; then :
+  have_tpcshrd_h=yes
+fi
+
+
+        if test x$have_tpcshrd_h = xyes; then
+
+$as_echo "#define HAVE_TPCSHRD_H 1" >>confdefs.h
+
+        fi
         # Set up files for the sensor library
         ac_fn_c_check_header_mongrel "$LINENO" "sensorsapi.h" "ac_cv_header_sensorsapi_h" "$ac_includes_default"
 if test "x$ac_cv_header_sensorsapi_h" = xyes; then :
@@ -25110,6 +26239,9 @@ $as_echo "#define SDL_FILESYSTEM_WINDOWS 1" >>confdefs.h
         # Set up files for the thread library
         if test x$enable_threads = xyes; then
 
+$as_echo "#define SDL_THREAD_GENERIC_COND_SUFFIX 1" >>confdefs.h
+
+
 $as_echo "#define SDL_THREAD_WINDOWS 1" >>confdefs.h
 
             SOURCES="$SOURCES $srcdir/src/thread/windows/*.c"
@@ -25130,7 +26262,6 @@ $as_echo "#define SDL_TIMER_WINDOWS 1" >>confdefs.h
 $as_echo "#define SDL_LOADSO_WINDOWS 1" >>confdefs.h
 
             SOURCES="$SOURCES $srcdir/src/loadso/windows/*.c"
-            have_loadso=yes
         fi
         # Set up the system libraries we need
         if test -f /lib/w32api/libuuid.a; then
@@ -25138,7 +26269,8 @@ $as_echo "#define SDL_LOADSO_WINDOWS 1" >>confdefs.h
         else
             LIBUUID=-luuid
         fi
-        EXTRA_LDFLAGS="$EXTRA_LDFLAGS -luser32 -lgdi32 -lwinmm -limm32 -lole32 -loleaut32 -lshell32 -lsetupapi -lversion $LIBUUID -static-libgcc"
+        EXTRA_LDFLAGS="$EXTRA_LDFLAGS -luser32 -lgdi32 -lwinmm -limm32 -lole32 -loleaut32 -lshell32 -lsetupapi -lversion $LIBUUID"
+        BUILD_LDFLAGS="$BUILD_LDFLAGS -Wc,-static-libgcc"
         # The Windows platform requires special setup
         VERSION_SOURCES="$srcdir/src/main/windows/*.rc"
         SDLMAIN_SOURCES="$srcdir/src/main/windows/*.c"
@@ -25187,20 +26319,20 @@ fi
             SDL_LIBS="-lcygwin $SDL_LIBS"
         fi
         ;;
-
-        *-*-beos*)
+    *-*-beos*)
         as_fn_error $? "
 *** BeOS support has been removed as of SDL 2.0.2.
         " "$LINENO" 5
         ;;
-
     *-*-haiku*)
         ARCH=haiku
         ac_default_prefix=/boot/system
         CheckDummyVideo
+        CheckOffscreenVideo
         CheckDiskAudio
         CheckDummyAudio
         CheckDLOPEN
+        CheckO_CLOEXEC
         CheckHaikuVideo
         CheckHaikuGL
         CheckPTHREAD
@@ -25246,42 +26378,19 @@ $as_echo "#define SDL_FILESYSTEM_HAIKU 1" >>confdefs.h
             SOURCES="$SOURCES $srcdir/src/filesystem/haiku/*.cc"
             have_filesystem=yes
         fi
-
-        SOURCES="$SOURCES $srcdir/src/misc/haiku/*.cc"
-        have_misc=yes
-
+        # Set up files for the misc library
+        if test x$enable_misc = xyes; then
+            SOURCES="$SOURCES $srcdir/src/misc/haiku/*.cc"
+            have_misc=yes
+        fi
         # Set up files for the locale library
-        SOURCES="$SOURCES $srcdir/src/locale/haiku/*.cc"
-        have_locale=yes
-
+        if test x$enable_locale = xyes; then
+            SOURCES="$SOURCES $srcdir/src/locale/haiku/*.cc"
+            have_locale=yes
+        fi
         # The Haiku platform requires special setup.
         SOURCES="$srcdir/src/main/haiku/*.cc $SOURCES"
         EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lroot -lbe -lmedia -lgame -ldevice -ltextencoding"
-        # Haiku's x86 spins use libstdc++.r4.so (for binary compat?), but
-        #  other spins, like x86-64, use a more standard "libstdc++.so.*"
-        as_ac_File=`$as_echo "ac_cv_file_"/boot/system/lib/libstdc++.r4.so"" | $as_tr_sh`
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for \"/boot/system/lib/libstdc++.r4.so\"" >&5
-$as_echo_n "checking for \"/boot/system/lib/libstdc++.r4.so\"... " >&6; }
-if eval \${$as_ac_File+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  test "$cross_compiling" = yes &&
-  as_fn_error $? "cannot check for file existence when cross compiling" "$LINENO" 5
-if test -r ""/boot/system/lib/libstdc++.r4.so""; then
-  eval "$as_ac_File=yes"
-else
-  eval "$as_ac_File=no"
-fi
-fi
-eval ac_res=\$$as_ac_File
-	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
-$as_echo "$ac_res" >&6; }
-if eval test \"x\$"$as_ac_File"\" = x"yes"; then :
-  EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lstdc++.r4"
-else
-  EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lstdc++"
-fi
-
         ;;
     *-ios-*)
         ARCH=ios
@@ -25289,20 +26398,25 @@ fi
         CheckVisibilityHidden
         CheckDeclarationAfterStatement
         CheckDummyVideo
+        CheckOffscreenVideo
         CheckDiskAudio
         CheckDummyAudio
         CheckDLOPEN
+        CheckO_CLOEXEC
         CheckMETAL
         CheckVulkan
         CheckPTHREAD
 
-        SOURCES="$SOURCES $srcdir/src/misc/ios/*.m"
-        have_misc=yes
-
+        # Set up files for the misc library
+        if test x$enable_misc = xyes; then
+            SOURCES="$SOURCES $srcdir/src/misc/ios/*.m"
+            have_misc=yes
+        fi
         # Set up files for the locale library
-        SOURCES="$SOURCES $srcdir/src/locale/macosx/*.m"
-        have_locale=yes
-
+        if test x$enable_locale = xyes; then
+            SOURCES="$SOURCES $srcdir/src/locale/macosx/*.m"
+            have_locale=yes
+        fi
         # Set up files for the audio library
         if test x$enable_audio = xyes; then
 
@@ -25385,6 +26499,8 @@ $as_echo "#define SDL_VIDEO_RENDER_OGL_ES 1" >>confdefs.h
 $as_echo "#define SDL_VIDEO_RENDER_OGL_ES2 1" >>confdefs.h
 
         SOURCES="$SOURCES $srcdir/src/video/uikit/*.m"
+        SUMMARY_video="${SUMMARY_video} uikit"
+        have_video=yes
         EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lm -liconv -lobjc"
         EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,AVFoundation"
         EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,AudioToolbox"
@@ -25414,26 +26530,32 @@ $as_echo "#define SDL_VIDEO_RENDER_OGL_ES2 1" >>confdefs.h
         CheckVisibilityHidden
         CheckDeclarationAfterStatement
         CheckDummyVideo
+        CheckOffscreenVideo
         CheckDiskAudio
         CheckDummyAudio
         CheckDLOPEN
+        CheckO_CLOEXEC
         CheckCOCOA
         CheckMETAL
         CheckX11
         CheckMacGL
         CheckMacGLES
-        CheckOpenGLX11
+        CheckGLX
+        CheckOpenGL
         CheckVulkan
         CheckPTHREAD
         CheckHIDAPI
 
-        SOURCES="$SOURCES $srcdir/src/misc/macosx/*.m"
-        have_misc=yes
-
+        # Set up files for the misc library
+        if test x$enable_misc = xyes; then
+            SOURCES="$SOURCES $srcdir/src/misc/macosx/*.m"
+            have_misc=yes
+        fi
         # Set up files for the locale library
-        SOURCES="$SOURCES $srcdir/src/locale/macosx/*.m"
-        have_locale=yes
-
+        if test x$enable_locale = xyes; then
+            SOURCES="$SOURCES $srcdir/src/locale/macosx/*.m"
+            have_locale=yes
+        fi
         # Set up files for the audio library
         if test x$enable_audio = xyes; then
 
@@ -25509,8 +26631,10 @@ $as_echo "#define SDL_TIMER_UNIX 1" >>confdefs.h
         CheckNativeClient
         CheckDummyAudio
         CheckDummyVideo
+        CheckOffscreenVideo
         CheckInputEvents
         CheckPTHREAD
+        CheckO_CLOEXEC
 
         # Set up files for the timer library
         if test x$enable_timers = xyes; then
@@ -25551,12 +26675,20 @@ $as_echo "#define SDL_AUDIO_DRIVER_EMSCRIPTEN 1" >>confdefs.h
         CheckVisibilityHidden
         CheckDeclarationAfterStatement
         CheckDummyVideo
+        CheckOffscreenVideo
         CheckDiskAudio
         CheckDummyAudio
+        CheckPTHREAD
         CheckDLOPEN
         CheckClockGettime
         CheckEmscriptenGLES
 
+        # Set up files for the misc library
+        if test x$enable_misc = xyes; then
+            SOURCES="$SOURCES $srcdir/src/misc/emscripten/*.c"
+            have_misc=yes
+        fi
+
          # Set up files for the power library
         if test x$enable_power = xyes; then
 
@@ -25566,7 +26698,7 @@ $as_echo "#define SDL_POWER_EMSCRIPTEN 1" >>confdefs.h
             have_power=yes
         fi
 
-        # Set up files for the power library
+        # Set up files for the joystick library
         if test x$enable_joystick = xyes; then
 
 $as_echo "#define SDL_JOYSTICK_EMSCRIPTEN 1" >>confdefs.h
@@ -25592,24 +26724,47 @@ $as_echo "#define SDL_TIMER_UNIX 1" >>confdefs.h
             have_timers=yes
         fi
         # Set up files for the locale library
-        SOURCES="$SOURCES $srcdir/src/locale/emscripten/*.c"
-        have_locale=yes
+        if test x$enable_locale = xyes; then
+            SOURCES="$SOURCES $srcdir/src/locale/emscripten/*.c"
+            have_locale=yes
+        fi
         ;;
     *-*-riscos*)
         ARCH=riscos
         CheckVisibilityHidden
         CheckDeclarationAfterStatement
         CheckDummyVideo
+        CheckOffscreenVideo
         CheckDiskAudio
         CheckDummyAudio
         CheckDLOPEN
+        CheckO_CLOEXEC
         CheckOSS
         CheckPTHREAD
         CheckClockGettime
 
-        SOURCES="$SOURCES $srcdir/src/misc/riscos/*.c"
-        have_misc=yes
+        # Set up files for the misc library
+        if test x$enable_misc = xyes; then
+            SOURCES="$SOURCES $srcdir/src/misc/riscos/*.c"
+            have_misc=yes
+        fi
+        # Set up files for the video library
+        if test x$enable_video = xyes; then
 
+$as_echo "#define SDL_VIDEO_DRIVER_RISCOS 1" >>confdefs.h
+
+            SOURCES="$SOURCES $srcdir/src/video/riscos/*.c"
+            have_video=yes
+            SUMMARY_video="${SUMMARY_video} riscos"
+        fi
+        # Set up files for the filesystem library
+        if test x$enable_filesystem = xyes; then
+
+$as_echo "#define SDL_FILESYSTEM_RISCOS 1" >>confdefs.h
+
+            SOURCES="$SOURCES $srcdir/src/filesystem/riscos/*.c"
+            have_filesystem=yes
+        fi
         # Set up files for the timer library
         if test x$enable_timers = xyes; then
 
@@ -25619,6 +26774,97 @@ $as_echo "#define SDL_TIMER_UNIX 1" >>confdefs.h
             have_timers=yes
         fi
         ;;
+    *-*-os2*)
+        ARCH=os2
+        if test "$build" != "$host"; then # cross-compiling
+            # Default cross-compile location
+            ac_default_prefix=/@unixroot/usr/local/cross-tools/$host
+        else
+            # Look for the location of the tools and install there
+            if test "$BUILD_PREFIX" != ""; then
+                ac_default_prefix=$BUILD_PREFIX
+            fi
+        fi
+        enable_static=no # disable static builds
+        EXTRA_CFLAGS="$EXTRA_CFLAGS -DBUILD_SDL -DOS2EMX_PLAIN_CHAR"
+        CheckOS2
+        CheckDeclarationAfterStatement
+        CheckDummyVideo
+        CheckDiskAudio
+        CheckDummyAudio
+        CheckHIDAPI
+
+        # Set up the core platform files
+        SOURCES="$SOURCES $srcdir/src/core/os2/*.c"
+        if test x$ac_cv_func_iconv != xyes -o x$ac_cv_header_iconv_h != xyes; then
+            SOURCES="$SOURCES $srcdir/src/core/os2/geniconv/*.c"
+        fi
+        # Use the Unix locale APIs.
+        if test x$enable_locale = xyes; then
+            SOURCES="$SOURCES $srcdir/src/locale/unix/*.c"
+            have_locale=yes
+        fi
+        # Set up files for the video library
+        if test x$enable_video = xyes; then
+
+$as_echo "#define SDL_VIDEO_DRIVER_OS2 1" >>confdefs.h
+
+            SOURCES="$SOURCES $srcdir/src/video/os2/*.c"
+            have_video=yes
+            SUMMARY_video="${SUMMARY_video} os/2"
+        fi
+        # Set up files for the audio library
+        if test x$enable_audio = xyes; then
+
+$as_echo "#define SDL_AUDIO_DRIVER_OS2 1" >>confdefs.h
+
+            SOURCES="$SOURCES $srcdir/src/audio/os2/*.c"
+            have_audio=yes
+            SUMMARY_audio="${SUMMARY_audio} os/2"
+            EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lmmpm2"
+        fi
+        # Set up files for the thread library
+        if test x$enable_threads = xyes; then
+
+$as_echo "#define SDL_THREAD_OS2 1" >>confdefs.h
+
+            SOURCES="$SOURCES $srcdir/src/thread/os2/*.c"
+            SOURCES="$SOURCES $srcdir/src/thread/generic/SDL_syscond.c"
+            have_threads=yes
+        fi
+        # Set up files for the timer library
+        if test x$enable_timers = xyes; then
+
+$as_echo "#define SDL_TIMER_OS2 1" >>confdefs.h
+
+            SOURCES="$SOURCES $srcdir/src/timer/os2/*.c"
+            have_timers=yes
+        fi
+        # Set up files for the shared object loading library
+        if test x$enable_loadso = xyes; then
+
+$as_echo "#define SDL_LOADSO_OS2 1" >>confdefs.h
+
+            SOURCES="$SOURCES $srcdir/src/loadso/os2/*.c"
+            have_loadso=yes
+        fi
+        # Set up files for the filesystem library
+        if test x$enable_filesystem = xyes; then
+
+$as_echo "#define SDL_FILESYSTEM_OS2 1" >>confdefs.h
+
+            SOURCES="$SOURCES $srcdir/src/filesystem/os2/*.c"
+            have_filesystem=yes
+        fi
+        # Set up files for the joystick library
+        if test x$enable_joystick = xyes; then
+
+$as_echo "#define SDL_JOYSTICK_OS2 1" >>confdefs.h
+
+            SOURCES="$SOURCES $srcdir/src/joystick/os2/*.c"
+            have_joystick=yes
+        fi
+        ;;
     *)
         as_fn_error $? "
 *** Unsupported host:  Please add to configure.ac
@@ -25654,10 +26900,36 @@ INSTALL_SDL2_CONFIG=$enable_sdl2_config
 
 # Verify that we have all the platform specific files we need
 
+if test x$have_audio != xyes; then
+    if test x$enable_audio = xyes; then
+
+$as_echo "#define SDL_AUDIO_DRIVER_DUMMY 1" >>confdefs.h
+
+    fi
+    SOURCES="$SOURCES $srcdir/src/audio/dummy/*.c"
+fi
+if test x$have_video != xyes; then
+    if test x$enable_video = xyes; then
+
+$as_echo "#define SDL_VIDEO_DRIVER_DUMMY 1" >>confdefs.h
+
+    fi
+    SOURCES="$SOURCES $srcdir/src/video/dummy/*.c"
+fi
 if test x$have_misc != xyes; then
+    if test x$enable_misc = xyes; then
+
+$as_echo "#define SDL_MISC_DUMMY 1" >>confdefs.h
+
+    fi
     SOURCES="$SOURCES $srcdir/src/misc/dummy/*.c"
 fi
 if test x$have_locale != xyes; then
+    if test x$enable_locale = xyes; then
+
+$as_echo "#define SDL_LOCALE_DUMMY 1" >>confdefs.h
+
+    fi
     SOURCES="$SOURCES $srcdir/src/locale/dummy/*.c"
 fi
 if test x$have_joystick != xyes; then
@@ -25695,7 +26967,7 @@ fi
 if test x$have_timers != xyes; then
     if test x$enable_timers = xyes; then
 
-$as_echo "#define SDL_TIMERS_DISABLED 1" >>confdefs.h
+$as_echo "#define SDL_TIMER_DUMMY 1" >>confdefs.h
 
     fi
     SOURCES="$SOURCES $srcdir/src/timer/dummy/*.c"
@@ -25703,7 +26975,7 @@ fi
 if test x$have_filesystem != xyes; then
     if test x$enable_filesystem = xyes; then
 
-$as_echo "#define SDL_FILESYSTEM_DISABLED 1" >>confdefs.h
+$as_echo "#define SDL_FILESYSTEM_DUMMY 1" >>confdefs.h
 
     fi
     SOURCES="$SOURCES $srcdir/src/filesystem/dummy/*.c"
@@ -25711,7 +26983,7 @@ fi
 if test x$have_loadso != xyes; then
     if test x$enable_loadso = xyes; then
 
-$as_echo "#define SDL_LOADSO_DISABLED 1" >>confdefs.h
+$as_echo "#define SDL_LOADSO_DUMMY 1" >>confdefs.h
 
     fi
     SOURCES="$SOURCES $srcdir/src/loadso/dummy/*.c"
@@ -25722,27 +26994,28 @@ fi
 SDLTEST_SOURCES="$srcdir/src/test/*.c"
 
 if test x$video_wayland = xyes; then
-    WAYLAND_PROTOCOLS=`cd $srcdir/wayland-protocols ; for p in *.xml ; do echo -n "\$p" |sed 's,\\.xml\$, ,g' ; done`
-    WAYLAND_PROTOCOLS_SOURCES=`for p in $WAYLAND_PROTOCOLS ; do echo -n "\\$(gen)/\$p-protocol.c " ; done`
-    WAYLAND_PROTOCOLS_HEADERS=`for p in $WAYLAND_PROTOCOLS ; do echo -n "\\$(gen)/\$p-client-protocol.h " ; done`
+    WAYLAND_PROTOCOLS=`cd $srcdir/wayland-protocols ; for p in *.xml ; do printf '%s' "\$p" |sed 's,\\.xml\$, ,g' ; done`
+    WAYLAND_PROTOCOLS_SOURCES=`for p in $WAYLAND_PROTOCOLS ; do printf '%s' "\\$(gen)/\$p-protocol.c " ; done`
+    WAYLAND_PROTOCOLS_HEADERS=`for p in $WAYLAND_PROTOCOLS ; do printf '%s' "\\$(gen)/\$p-client-protocol.h " ; done`
     GEN_SOURCES="$GEN_SOURCES $WAYLAND_PROTOCOLS_SOURCES"
     GEN_HEADERS="$GEN_HEADERS $WAYLAND_PROTOCOLS_HEADERS"
 
     WAYLAND_PROTOCOLS_DEPENDS=`for p in $WAYLAND_PROTOCOLS ; do\
         echo ;\
-        echo "\\$(gen)/\$p-client-protocol.h: \\$(srcdir)/wayland-protocols/\$p.xml" ;\
-        echo "	@\\$(SHELL) \\$(auxdir)/mkinstalldirs \\$(gen)" ;\
-        echo "	\\$(RUN_CMD_GEN)\\$(WAYLAND_SCANNER) client-header \\$< \\$@" ;\
+        printf '%s\n' "\\$(gen)/\$p-client-protocol.h: \\$(srcdir)/wayland-protocols/\$p.xml" ;\
+        printf '%s\n' "	@\\$(SHELL) \\$(auxdir)/mkinstalldirs \\$(gen)" ;\
+        printf '%s\n' "	\\$(RUN_CMD_GEN)\\$(WAYLAND_SCANNER) client-header \\$< \\$@" ;\
         echo ;\
-        echo "\\$(gen)/\$p-protocol.c: \\$(srcdir)/wayland-protocols/\$p.xml" ;\
-        echo "	@\\$(SHELL) \\$(auxdir)/mkinstalldirs \\$(gen)" ;\
-        echo "	\\$(RUN_CMD_GEN)\\$(WAYLAND_SCANNER) code \\$< \\$@" ;\
+        printf '%s\n' "\\$(gen)/\$p-protocol.c: \\$(srcdir)/wayland-protocols/\$p.xml" ;\
+        printf '%s\n' "	@\\$(SHELL) \\$(auxdir)/mkinstalldirs \\$(gen)" ;\
+        printf '%s\n' "	\\$(RUN_CMD_GEN)\\$(WAYLAND_SCANNER) \\$(WAYLAND_SCANNER_CODE_MODE) \\$< \\$@" ;\
         echo ;\
-        echo "\\$(objects)/\$p-protocol.lo: \\$(gen)/\$p-protocol.c \\$(gen)/\$p-client-protocol.h" ;\
-        echo "	\\$(RUN_CMD_CC)\\$(LIBTOOL) --tag=CC --mode=compile \\$(CC) \\$(CFLAGS) \\$(EXTRA_CFLAGS) $DEPENDENCY_TRACKING_OPTIONS -c \\$< -o \\$@" ;\
+        printf '%s\n' "\\$(objects)/\$p-protocol.lo: \\$(gen)/\$p-protocol.c \\$(gen)/\$p-client-protocol.h" ;\
+        printf '%s\n' "	@\\$(SHELL) \\$(auxdir)/mkinstalldirs \\$(objects)" ;\
+        printf '%s\n' "	\\$(RUN_CMD_CC)\\$(LIBTOOL) --tag=CC --mode=compile \\$(CC) \\$(CFLAGS) \\$(EXTRA_CFLAGS) $DEPENDENCY_TRACKING_OPTIONS -c \\$< -o \\$@" ;\
         done ;\
         echo ;\
-        for s in $WAYLAND_SOURCES ; do echo -n "\$s:" ; for p in $WAYLAND_PROTOCOLS ; do echo -n " \\$(gen)/\$p-client-protocol.h" ; done ; echo ; done ; echo`
+        for s in $WAYLAND_SOURCES ; do printf '%s' "\$s:" ; printf ' \$(gen)/%s-client-protocol.h' $WAYLAND_PROTOCOLS ; echo ; done ; echo`
 fi
 
 OBJECTS=`echo $SOURCES`
@@ -25791,12 +27064,10 @@ $as_echo_n "checking for linker option --enable-new-dtags... " >&6; }
     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-
 int
 main ()
 {
 
-
   ;
   return 0;
 }
@@ -25827,12 +27098,12 @@ SDL_STATIC_LIBS="$EXTRA_LDFLAGS"
 
 
 if test x$enable_shared = xyes; then
-    PKG_CONFIG_LIBS_PRIV="
+    PKGCONFIG_LIBS_PRIV="
 Libs.private:"
     ENABLE_SHARED_TRUE=
     ENABLE_SHARED_FALSE="#"
 else
-    PKG_CONFIG_LIBS_PRIV=
+    PKGCONFIG_LIBS_PRIV=
     ENABLE_SHARED_TRUE="#"
     ENABLE_SHARED_FALSE=
 fi
@@ -25862,6 +27133,7 @@ fi
 
 
 
+
 
 cat >Makefile.rules <<__EOF__
 
@@ -25940,7 +27212,6 @@ if test x$WARN_ABOUT_ARM_SIMD_ASM_MIT = xyes; then
     SUMMARY="${SUMMARY}configure script with:\n"
     SUMMARY="${SUMMARY}\n    --disable-arm-simd\n"
 fi
-
 if test x$WARN_ABOUT_ARM_NEON_ASM_MIT = xyes; then
     SUMMARY="${SUMMARY}\nSDL is being built with ARM NEON optimizations, which\n"
     SUMMARY="${SUMMARY}uses code licensed under the MIT license. If this is a\n"
@@ -26660,6 +27931,7 @@ enable_shared='`$ECHO "$enable_shared" | $SED "$delay_single_quote_subst"`'
 enable_static='`$ECHO "$enable_static" | $SED "$delay_single_quote_subst"`'
 pic_mode='`$ECHO "$pic_mode" | $SED "$delay_single_quote_subst"`'
 enable_fast_install='`$ECHO "$enable_fast_install" | $SED "$delay_single_quote_subst"`'
+shared_archive_member_spec='`$ECHO "$shared_archive_member_spec" | $SED "$delay_single_quote_subst"`'
 SHELL='`$ECHO "$SHELL" | $SED "$delay_single_quote_subst"`'
 ECHO='`$ECHO "$ECHO" | $SED "$delay_single_quote_subst"`'
 PATH_SEPARATOR='`$ECHO "$PATH_SEPARATOR" | $SED "$delay_single_quote_subst"`'
@@ -26707,10 +27979,13 @@ compiler='`$ECHO "$compiler" | $SED "$delay_single_quote_subst"`'
 GCC='`$ECHO "$GCC" | $SED "$delay_single_quote_subst"`'
 lt_cv_sys_global_symbol_pipe='`$ECHO "$lt_cv_sys_global_symbol_pipe" | $SED "$delay_single_quote_subst"`'
 lt_cv_sys_global_symbol_to_cdecl='`$ECHO "$lt_cv_sys_global_symbol_to_cdecl" | $SED "$delay_single_quote_subst"`'
+lt_cv_sys_global_symbol_to_import='`$ECHO "$lt_cv_sys_global_symbol_to_import" | $SED "$delay_single_quote_subst"`'
 lt_cv_sys_global_symbol_to_c_name_address='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address" | $SED "$delay_single_quote_subst"`'
 lt_cv_sys_global_symbol_to_c_name_address_lib_prefix='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address_lib_prefix" | $SED "$delay_single_quote_subst"`'
+lt_cv_nm_interface='`$ECHO "$lt_cv_nm_interface" | $SED "$delay_single_quote_subst"`'
 nm_file_list_spec='`$ECHO "$nm_file_list_spec" | $SED "$delay_single_quote_subst"`'
 lt_sysroot='`$ECHO "$lt_sysroot" | $SED "$delay_single_quote_subst"`'
+lt_cv_truncate_bin='`$ECHO "$lt_cv_truncate_bin" | $SED "$delay_single_quote_subst"`'
 objdir='`$ECHO "$objdir" | $SED "$delay_single_quote_subst"`'
 MAGIC_CMD='`$ECHO "$MAGIC_CMD" | $SED "$delay_single_quote_subst"`'
 lt_prog_compiler_no_builtin_flag='`$ECHO "$lt_prog_compiler_no_builtin_flag" | $SED "$delay_single_quote_subst"`'
@@ -26775,7 +28050,8 @@ finish_cmds='`$ECHO "$finish_cmds" | $SED "$delay_single_quote_subst"`'
 finish_eval='`$ECHO "$finish_eval" | $SED "$delay_single_quote_subst"`'
 hardcode_into_libs='`$ECHO "$hardcode_into_libs" | $SED "$delay_single_quote_subst"`'
 sys_lib_search_path_spec='`$ECHO "$sys_lib_search_path_spec" | $SED "$delay_single_quote_subst"`'
-sys_lib_dlsearch_path_spec='`$ECHO "$sys_lib_dlsearch_path_spec" | $SED "$delay_single_quote_subst"`'
+configure_time_dlsearch_path='`$ECHO "$configure_time_dlsearch_path" | $SED "$delay_single_quote_subst"`'
+configure_time_lt_sys_library_path='`$ECHO "$configure_time_lt_sys_library_path" | $SED "$delay_single_quote_subst"`'
 hardcode_action='`$ECHO "$hardcode_action" | $SED "$delay_single_quote_subst"`'
 enable_dlopen='`$ECHO "$enable_dlopen" | $SED "$delay_single_quote_subst"`'
 enable_dlopen_self='`$ECHO "$enable_dlopen_self" | $SED "$delay_single_quote_subst"`'
@@ -26929,9 +28205,12 @@ CFLAGS \
 compiler \
 lt_cv_sys_global_symbol_pipe \
 lt_cv_sys_global_symbol_to_cdecl \
+lt_cv_sys_global_symbol_to_import \
 lt_cv_sys_global_symbol_to_c_name_address \
 lt_cv_sys_global_symbol_to_c_name_address_lib_prefix \
+lt_cv_nm_interface \
 nm_file_list_spec \
+lt_cv_truncate_bin \
 lt_prog_compiler_no_builtin_flag \
 lt_prog_compiler_pic \
 lt_prog_compiler_wl \
@@ -27022,7 +28301,7 @@ compiler_lib_search_path_RC \
 compiler_lib_search_path_CXX; do
     case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
     *[\\\\\\\`\\"\\\$]*)
-      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\""
+      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes
       ;;
     *)
       eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
@@ -27049,7 +28328,8 @@ postinstall_cmds \
 postuninstall_cmds \
 finish_cmds \
 sys_lib_search_path_spec \
-sys_lib_dlsearch_path_spec \
+configure_time_dlsearch_path \
+configure_time_lt_sys_library_path \
 reload_cmds_RC \
 reload_cmds_CXX \
 old_archive_cmds_RC \
@@ -27074,7 +28354,7 @@ postlink_cmds_RC \
 postlink_cmds_CXX; do
     case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
     *[\\\\\\\`\\"\\\$]*)
-      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\""
+      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes
       ;;
     *)
       eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
@@ -27083,19 +28363,16 @@ postlink_cmds_CXX; do
 done
 
 ac_aux_dir='$ac_aux_dir'
-xsi_shell='$xsi_shell'
-lt_shell_append='$lt_shell_append'
 
-# See if we are running on zsh, and set the options which allow our
+# See if we are running on zsh, and set the options that allow our
 # commands through without removal of \ escapes INIT.
-if test -n "\${ZSH_VERSION+set}" ; then
+if test -n "\${ZSH_VERSION+set}"; then
    setopt NO_GLOB_SUBST
 fi
 
 
     PACKAGE='$PACKAGE'
     VERSION='$VERSION'
-    TIMESTAMP='$TIMESTAMP'
     RM='$RM'
     ofile='$ofile'
 
@@ -27682,55 +28959,53 @@ $as_echo "$as_me: executing $ac_file commands" >&6;}
   case $ac_file$ac_mode in
     "libtool":C)
 
-    # See if we are running on zsh, and set the options which allow our
+    # See if we are running on zsh, and set the options that allow our
     # commands through without removal of \ escapes.
-    if test -n "${ZSH_VERSION+set}" ; then
+    if test -n "${ZSH_VERSION+set}"; then
       setopt NO_GLOB_SUBST
     fi
 
-    cfgfile="${ofile}T"
+    cfgfile=${ofile}T
     trap "$RM \"$cfgfile\"; exit 1" 1 2 15
     $RM "$cfgfile"
 
     cat <<_LT_EOF >> "$cfgfile"
 #! $SHELL
-
-# `$ECHO "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services.
-# Generated automatically by $as_me ($PACKAGE$TIMESTAMP) $VERSION
+# Generated automatically by $as_me ($PACKAGE) $VERSION
 # Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
 # NOTE: Changes made to this file will be lost: look at ltmain.sh.
+
+# Provide generalized library-building support services.
+# Written by Gordon Matzigkeit, 1996
+
+# Copyright (C) 2014 Free Software Foundation, Inc.
+# This is free software; see the source for copying conditions.  There is NO
+# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+# GNU Libtool is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of of the License, or
+# (at your option) any later version.
 #
-#   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005,
-#                 2006, 2007, 2008, 2009, 2010, 2011 Free Software
-#                 Foundation, Inc.
-#   Written by Gordon Matzigkeit, 1996
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program or library that is built
+# using GNU Libtool, you may include this file under the  same
+# distribution terms that you use for the rest of that program.
 #
-#   This file is part of GNU Libtool.
-#
-# GNU Libtool is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License as
-# published by the Free Software Foundation; either version 2 of
-# the License, or (at your option) any later version.
-#
-# As a special exception to the GNU General Public License,
-# if you distribute this file as part of a program or library that
-# is built using GNU Libtool, you may include this file under the
-# same distribution terms that you use for the rest of that program.
-#
-# GNU Libtool is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# GNU Libtool is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
-# along with GNU Libtool; see the file COPYING.  If not, a copy
-# can be downloaded from http://www.gnu.org/licenses/gpl.html, or
-# obtained by writing to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
 # The names of the tagged configurations supported by this script.
-available_tags="RC CXX "
+available_tags='RC CXX '
+
+# Configured defaults for sys_lib_dlsearch_path munging.
+: \${LT_SYS_LIBRARY_PATH="$configure_time_lt_sys_library_path"}
 
 # ### BEGIN LIBTOOL CONFIG
 
@@ -27759,6 +29034,9 @@ pic_mode=$pic_mode
 # Whether or not to optimize for fast installation.
 fast_install=$enable_fast_install
 
+# Shared archive member basename,for filename based shared library versioning on AIX.
+shared_archive_member_spec=$shared_archive_member_spec
+
 # Shell to use when invoking shell scripts.
 SHELL=$lt_SHELL
 
@@ -27870,18 +29148,27 @@ global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe
 # Transform the output of nm in a proper C declaration.
 global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl
 
+# Transform the output of nm into a list of symbols to manually relocate.
+global_symbol_to_import=$lt_lt_cv_sys_global_symbol_to_import
+
 # Transform the output of nm in a C name address pair.
 global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address
 
 # Transform the output of nm in a C name address pair when lib prefix is needed.
 global_symbol_to_c_name_address_lib_prefix=$lt_lt_cv_sys_global_symbol_to_c_name_address_lib_prefix
 
+# The name lister interface.
+nm_interface=$lt_lt_cv_nm_interface
+
 # Specify filename containing input files for \$NM.
 nm_file_list_spec=$lt_nm_file_list_spec
 
-# The root where to search for dependent libraries,and in which our libraries should be installed.
+# The root where to search for dependent libraries,and where our libraries should be installed.
 lt_sysroot=$lt_sysroot
 
+# Command to truncate a binary pipe.
+lt_truncate_bin=$lt_lt_cv_truncate_bin
+
 # The name of the directory that contains temporary libtool files.
 objdir=$objdir
 
@@ -27972,8 +29259,11 @@ hardcode_into_libs=$hardcode_into_libs
 # Compile-time system search path for libraries.
 sys_lib_search_path_spec=$lt_sys_lib_search_path_spec
 
-# Run-time system search path for libraries.
-sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec
+# Detected run-time system search path for libraries.
+sys_lib_dlsearch_path_spec=$lt_configure_time_dlsearch_path
+
+# Explicit LT_SYS_LIBRARY_PATH set during ./configure time.
+configure_time_lt_sys_library_path=$lt_configure_time_lt_sys_library_path
 
 # Whether dlopen is supported.
 dlopen_support=$enable_dlopen
@@ -28066,13 +29356,13 @@ hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec
 # Whether we need a single "-rpath" flag with a separated argument.
 hardcode_libdir_separator=$lt_hardcode_libdir_separator
 
-# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes
+# Set to "yes" if using DIR/libNAME\$shared_ext during linking hardcodes
 # DIR into the resulting binary.
 hardcode_direct=$hardcode_direct
 
-# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes
+# Set to "yes" if using DIR/libNAME\$shared_ext during linking hardcodes
 # DIR into the resulting binary and the resulting library dependency is
-# "absolute",i.e impossible to change by setting \${shlibpath_var} if the
+# "absolute",i.e impossible to change by setting \$shlibpath_var if the
 # library is relocated.
 hardcode_direct_absolute=$hardcode_direct_absolute
 
@@ -28136,6 +29426,65 @@ compiler_lib_search_path=$lt_compiler_lib_search_path
 
 # ### END LIBTOOL CONFIG
 
+_LT_EOF
+
+    cat <<'_LT_EOF' >> "$cfgfile"
+
+# ### BEGIN FUNCTIONS SHARED WITH CONFIGURE
+
+# func_munge_path_list VARIABLE PATH
+# -----------------------------------
+# VARIABLE is name of variable containing _space_ separated list of
+# directories to be munged by the contents of PATH, which is string
+# having a format:
+# "DIR[:DIR]:"
+#       string "DIR[ DIR]" will be prepended to VARIABLE
+# ":DIR[:DIR]"
+#       string "DIR[ DIR]" will be appended to VARIABLE
+# "DIRP[:DIRP]::[DIRA:]DIRA"
+#       string "DIRP[ DIRP]" will be prepended to VARIABLE and string
+#       "DIRA[ DIRA]" will be appended to VARIABLE
+# "DIR[:DIR]"
+#       VARIABLE will be replaced by "DIR[ DIR]"
+func_munge_path_list ()
+{
+    case x$2 in
+    x)
+        ;;
+    *:)
+        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\"
+        ;;
+    x:*)
+        eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\"
+        ;;
+    *::*)
+        eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
+        eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
+        ;;
+    *)
+        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\"
+        ;;
+    esac
+}
+
+
+# Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
+func_cc_basename ()
+{
+    for cc_temp in $*""; do
+      case $cc_temp in
+        compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
+        distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
+        \-*) ;;
+        *) break;;
+      esac
+    done
+    func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
+}
+
+
+# ### END FUNCTIONS SHARED WITH CONFIGURE
+
 _LT_EOF
 
   case $host_os in
@@ -28144,7 +29493,7 @@ _LT_EOF
 # AIX sometimes has problems with the GCC collect2 program.  For some
 # reason, if we set the COLLECT_NAMES environment variable, the problems
 # vanish in a puff of smoke.
-if test "X${COLLECT_NAMES+set}" != Xset; then
+if test set != "${COLLECT_NAMES+set}"; then
   COLLECT_NAMES=
   export COLLECT_NAMES
 fi
@@ -28153,7 +29502,7 @@ _LT_EOF
   esac
 
 
-ltmain="$ac_aux_dir/ltmain.sh"
+ltmain=$ac_aux_dir/ltmain.sh
 
 
   # We use sed instead of cat because bash on DJGPP gets confused if
@@ -28163,165 +29512,6 @@ ltmain="$ac_aux_dir/ltmain.sh"
   sed '$q' "$ltmain" >> "$cfgfile" \
      || (rm -f "$cfgfile"; exit 1)
 
-  if test x"$xsi_shell" = xyes; then
-  sed -e '/^func_dirname ()$/,/^} # func_dirname /c\
-func_dirname ()\
-{\
-\    case ${1} in\
-\      */*) func_dirname_result="${1%/*}${2}" ;;\
-\      *  ) func_dirname_result="${3}" ;;\
-\    esac\
-} # Extended-shell func_dirname implementation' "$cfgfile" > $cfgfile.tmp \
-  && mv -f "$cfgfile.tmp" "$cfgfile" \
-    || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
-test 0 -eq $? || _lt_function_replace_fail=:
-
-
-  sed -e '/^func_basename ()$/,/^} # func_basename /c\
-func_basename ()\
-{\
-\    func_basename_result="${1##*/}"\
-} # Extended-shell func_basename implementation' "$cfgfile" > $cfgfile.tmp \
-  && mv -f "$cfgfile.tmp" "$cfgfile" \
-    || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
-test 0 -eq $? || _lt_function_replace_fail=:
-
-
-  sed -e '/^func_dirname_and_basename ()$/,/^} # func_dirname_and_basename /c\
-func_dirname_and_basename ()\
-{\
-\    case ${1} in\
-\      */*) func_dirname_result="${1%/*}${2}" ;;\
-\      *  ) func_dirname_result="${3}" ;;\
-\    esac\
-\    func_basename_result="${1##*/}"\
-} # Extended-shell func_dirname_and_basename implementation' "$cfgfile" > $cfgfile.tmp \
-  && mv -f "$cfgfile.tmp" "$cfgfile" \
-    || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
-test 0 -eq $? || _lt_function_replace_fail=:
-
-
-  sed -e '/^func_stripname ()$/,/^} # func_stripname /c\
-func_stripname ()\
-{\
-\    # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are\
-\    # positional parameters, so assign one to ordinary parameter first.\
-\    func_stripname_result=${3}\
-\    func_stripname_result=${func_stripname_result#"${1}"}\
-\    func_stripname_result=${func_stripname_result%"${2}"}\
-} # Extended-shell func_stripname implementation' "$cfgfile" > $cfgfile.tmp \
-  && mv -f "$cfgfile.tmp" "$cfgfile" \
-    || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
-test 0 -eq $? || _lt_function_replace_fail=:
-
-
-  sed -e '/^func_split_long_opt ()$/,/^} # func_split_long_opt /c\
-func_split_long_opt ()\
-{\
-\    func_split_long_opt_name=${1%%=*}\
-\    func_split_long_opt_arg=${1#*=}\
-} # Extended-shell func_split_long_opt implementation' "$cfgfile" > $cfgfile.tmp \
-  && mv -f "$cfgfile.tmp" "$cfgfile" \
-    || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
-test 0 -eq $? || _lt_function_replace_fail=:
-
-
-  sed -e '/^func_split_short_opt ()$/,/^} # func_split_short_opt /c\
-func_split_short_opt ()\
-{\
-\    func_split_short_opt_arg=${1#??}\
-\    func_split_short_opt_name=${1%"$func_split_short_opt_arg"}\
-} # Extended-shell func_split_short_opt implementation' "$cfgfile" > $cfgfile.tmp \
-  && mv -f "$cfgfile.tmp" "$cfgfile" \
-    || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
-test 0 -eq $? || _lt_function_replace_fail=:
-
-
-  sed -e '/^func_lo2o ()$/,/^} # func_lo2o /c\
-func_lo2o ()\
-{\
-\    case ${1} in\
-\      *.lo) func_lo2o_result=${1%.lo}.${objext} ;;\
-\      *)    func_lo2o_result=${1} ;;\
-\    esac\
-} # Extended-shell func_lo2o implementation' "$cfgfile" > $cfgfile.tmp \
-  && mv -f "$cfgfile.tmp" "$cfgfile" \
-    || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
-test 0 -eq $? || _lt_function_replace_fail=:
-
-
-  sed -e '/^func_xform ()$/,/^} # func_xform /c\
-func_xform ()\
-{\
-    func_xform_result=${1%.*}.lo\
-} # Extended-shell func_xform implementation' "$cfgfile" > $cfgfile.tmp \
-  && mv -f "$cfgfile.tmp" "$cfgfile" \
-    || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
-test 0 -eq $? || _lt_function_replace_fail=:
-
-
-  sed -e '/^func_arith ()$/,/^} # func_arith /c\
-func_arith ()\
-{\
-    func_arith_result=$(( $* ))\
-} # Extended-shell func_arith implementation' "$cfgfile" > $cfgfile.tmp \
-  && mv -f "$cfgfile.tmp" "$cfgfile" \
-    || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
-test 0 -eq $? || _lt_function_replace_fail=:
-
-
-  sed -e '/^func_len ()$/,/^} # func_len /c\
-func_len ()\
-{\
-    func_len_result=${#1}\
-} # Extended-shell func_len implementation' "$cfgfile" > $cfgfile.tmp \
-  && mv -f "$cfgfile.tmp" "$cfgfile" \
-    || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
-test 0 -eq $? || _lt_function_replace_fail=:
-
-fi
-
-if test x"$lt_shell_append" = xyes; then
-  sed -e '/^func_append ()$/,/^} # func_append /c\
-func_append ()\
-{\
-    eval "${1}+=\\${2}"\
-} # Extended-shell func_append implementation' "$cfgfile" > $cfgfile.tmp \
-  && mv -f "$cfgfile.tmp" "$cfgfile" \
-    || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
-test 0 -eq $? || _lt_function_replace_fail=:
-
-
-  sed -e '/^func_append_quoted ()$/,/^} # func_append_quoted /c\
-func_append_quoted ()\
-{\
-\    func_quote_for_eval "${2}"\
-\    eval "${1}+=\\\\ \\$func_quote_for_eval_result"\
-} # Extended-shell func_append_quoted implementation' "$cfgfile" > $cfgfile.tmp \
-  && mv -f "$cfgfile.tmp" "$cfgfile" \
-    || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
-test 0 -eq $? || _lt_function_replace_fail=:
-
-
-  # Save a `func_append' function call where possible by direct use of '+='
-  sed -e 's%func_append \([a-zA-Z_]\{1,\}\) "%\1+="%g' $cfgfile > $cfgfile.tmp \
-    && mv -f "$cfgfile.tmp" "$cfgfile" \
-      || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
-  test 0 -eq $? || _lt_function_replace_fail=:
-else
-  # Save a `func_append' function call even when '+=' is not available
-  sed -e 's%func_append \([a-zA-Z_]\{1,\}\) "%\1="$\1%g' $cfgfile > $cfgfile.tmp \
-    && mv -f "$cfgfile.tmp" "$cfgfile" \
-      || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
-  test 0 -eq $? || _lt_function_replace_fail=:
-fi
-
-if test x"$_lt_function_replace_fail" = x":"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Unable to substitute extended shell functions in $ofile" >&5
-$as_echo "$as_me: WARNING: Unable to substitute extended shell functions in $ofile" >&2;}
-fi
-
-
    mv -f "$cfgfile" "$ofile" ||
     (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile")
   chmod +x "$ofile"
@@ -28408,13 +29598,13 @@ hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_RC
 # Whether we need a single "-rpath" flag with a separated argument.
 hardcode_libdir_separator=$lt_hardcode_libdir_separator_RC
 
-# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes
+# Set to "yes" if using DIR/libNAME\$shared_ext during linking hardcodes
 # DIR into the resulting binary.
 hardcode_direct=$hardcode_direct_RC
 
-# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes
+# Set to "yes" if using DIR/libNAME\$shared_ext during linking hardcodes
 # DIR into the resulting binary and the resulting library dependency is
-# "absolute",i.e impossible to change by setting \${shlibpath_var} if the
+# "absolute",i.e impossible to change by setting \$shlibpath_var if the
 # library is relocated.
 hardcode_direct_absolute=$hardcode_direct_absolute_RC
 
@@ -28561,13 +29751,13 @@ hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_CXX
 # Whether we need a single "-rpath" flag with a separated argument.
 hardcode_libdir_separator=$lt_hardcode_libdir_separator_CXX
 
-# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes
+# Set to "yes" if using DIR/libNAME\$shared_ext during linking hardcodes
 # DIR into the resulting binary.
 hardcode_direct=$hardcode_direct_CXX
 
-# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes
+# Set to "yes" if using DIR/libNAME\$shared_ext during linking hardcodes
 # DIR into the resulting binary and the resulting library dependency is
-# "absolute",i.e impossible to change by setting \${shlibpath_var} if the
+# "absolute",i.e impossible to change by setting \$shlibpath_var if the
 # library is relocated.
 hardcode_direct_absolute=$hardcode_direct_absolute_CXX
 
@@ -28634,7 +29824,7 @@ _LT_EOF
 
  ;;
     "sdl2_config":C) chmod a+x sdl2-config ;;
-    "summary":C) echo -en "$SUMMARY" ;;
+    "summary":C) printf "$SUMMARY" ;;
 
   esac
 done # for ac_tag
diff --git a/Engine/lib/sdl/configure.ac b/Engine/lib/sdl/configure.ac
index b7e519b8f..28d620d94 100644
--- a/Engine/lib/sdl/configure.ac
+++ b/Engine/lib/sdl/configure.ac
@@ -1,8 +1,9 @@
 dnl Process this file with autoconf to produce a configure script.
+AC_PREREQ([2.63])
 AC_INIT
-AC_CONFIG_SRCDIR(README.txt)
-AC_CONFIG_HEADERS(include/SDL_config.h)
-AC_CONFIG_AUX_DIR(build-scripts)
+AC_CONFIG_SRCDIR([src/SDL.c])
+AC_CONFIG_HEADERS([include/SDL_config.h])
+AC_CONFIG_AUX_DIR([build-scripts])
 AC_CONFIG_MACRO_DIR([acinclude])
 
 dnl Save the CFLAGS to see whether they were passed in or generated
@@ -21,9 +22,9 @@ dnl Set various version strings - taken gratefully from the GTk sources
 #
 SDL_MAJOR_VERSION=2
 SDL_MINOR_VERSION=0
-SDL_MICRO_VERSION=14
-SDL_INTERFACE_AGE=0
-SDL_BINARY_AGE=14
+SDL_MICRO_VERSION=21
+SDL_INTERFACE_AGE=3
+SDL_BINARY_AGE=21
 SDL_VERSION=$SDL_MAJOR_VERSION.$SDL_MINOR_VERSION.$SDL_MICRO_VERSION
 
 AC_SUBST(SDL_MAJOR_VERSION)
@@ -60,7 +61,7 @@ PKG_PROG_PKG_CONFIG
 
 dnl Make sure that srcdir is a full pathname
 case "$host" in
-    *-*-mingw32*)
+    *-*-mingw*)
         # Except on msys, where make can't handle full pathnames (bug 1972)
         ;;
     *)
@@ -80,11 +81,25 @@ case "$host" in
         ;;
 esac
 
+dnl use CXX for linker on Haiku
+case "$host" in
+    *-*-haiku*)
+        LINKER='$(CXX)'
+        LIBTOOLLINKERTAG='CXX'
+        ;;
+    *)
+        LINKER='$(CC)'
+        LIBTOOLLINKERTAG='CC'
+        ;;
+esac
+AC_SUBST(LINKER)
+AC_SUBST(LIBTOOLLINKERTAG)
+
 if test x$srcdir != x.; then
     INCLUDE="-Iinclude $INCLUDE"
-elif test -d .hg; then
+elif test -d .git; then
     AC_MSG_ERROR([
-*** When building from Mercurial you should configure and build in a
+*** When building from a git clone you should configure and build in a
     separate directory so you don't clobber SDL_config.h, SDL_revision.h
 ])
 fi
@@ -98,11 +113,7 @@ case "$host" in
         AC_MSG_CHECKING(for GCC -mno-cygwin option)
         CFLAGS="$save_CFLAGS -mno-cygwin"
 
-        AC_TRY_COMPILE([
-        ],[
-        ],[
-        have_no_cygwin=yes
-        ])
+        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],[])], [have_no_cygwin=yes],[])
         AC_MSG_RESULT($have_no_cygwin)
         CFLAGS="$save_CFLAGS"
 
@@ -184,8 +195,8 @@ AC_C_VOLATILE
 
 dnl See whether we want assertions for debugging/sanity checking SDL itself.
 AC_ARG_ENABLE(assertions,
-AS_HELP_STRING([--enable-assertions],
-               [Enable internal sanity checks (auto/disabled/release/enabled/paranoid) [[default=auto]]]),
+[AS_HELP_STRING([--enable-assertions],
+               [Enable internal sanity checks (auto/disabled/release/enabled/paranoid) [default=auto]])],
               , enable_assertions=auto)
 case "$enable_assertions" in
     auto) # Use optimization settings to determine assertion level
@@ -209,20 +220,17 @@ esac
 
 dnl See whether we can use gcc style dependency tracking
 AC_ARG_ENABLE(dependency-tracking,
-AS_HELP_STRING([--enable-dependency-tracking],
-               [Use gcc -MMD -MT dependency tracking [[default=yes]]]),
+[AS_HELP_STRING([--enable-dependency-tracking],
+               [Use gcc -MMD -MT dependency tracking [default=yes]])],
               , enable_dependency_tracking=yes)
 if test x$enable_dependency_tracking = xyes; then
     have_gcc_mmd_mt=no
     AC_MSG_CHECKING(for GCC -MMD -MT option)
-    AC_TRY_COMPILE([
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
     #if !defined(__GNUC__) || __GNUC__ < 3
     #error Dependency tracking requires GCC 3.0 or newer
     #endif
-    ],[
-    ],[
-    have_gcc_mmd_mt=yes
-    ])
+    ]],[])], [have_gcc_mmd_mt=yes],[])
     AC_MSG_RESULT($have_gcc_mmd_mt)
 
     if test x$have_gcc_mmd_mt = xyes; then
@@ -233,19 +241,16 @@ fi
 AC_MSG_CHECKING(for linker option --no-undefined)
 have_no_undefined=no
 case "$host" in
-    dnl Skip this on platforms where it is just simply busted.
+dnl Skip this on platforms where it is just simply busted.
     *-*-openbsd*)
         ;;
-
     *)
         save_LDFLAGS="$LDFLAGS"
         LDFLAGS="$LDFLAGS -Wl,--no-undefined"
-        AC_TRY_LINK([
-        ],[
-        ],[
+        AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])], [
         have_no_undefined=yes
-        EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,--no-undefined"
-        ])
+        BUILD_LDFLAGS="$BUILD_LDFLAGS -Wl,--no-undefined"
+        ],[])
         LDFLAGS="$save_LDFLAGS"
         ;;
 esac
@@ -257,12 +262,10 @@ case "$host" in
     *)
         save_LDFLAGS="$LDFLAGS"
         LDFLAGS="$LDFLAGS -Wl,--dynamicbase"
-        AC_TRY_LINK([
-        ],[
-        ],[
+        AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])], [
         have_dynamicbase=yes
         EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,--dynamicbase"
-        ])
+        ],[])
         LDFLAGS="$save_LDFLAGS"
         ;;
 esac
@@ -274,12 +277,10 @@ case "$host" in
     *)
         save_LDFLAGS="$LDFLAGS"
         LDFLAGS="$LDFLAGS -Wl,--nxcompat"
-        AC_TRY_LINK([
-        ],[
-        ],[
+        AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])], [
         have_nxcompat=yes
         EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,--nxcompat"
-        ])
+        ],[])
         LDFLAGS="$save_LDFLAGS"
         ;;
 esac
@@ -291,12 +292,10 @@ case "$host" in
     *)
         save_LDFLAGS="$LDFLAGS"
         LDFLAGS="$LDFLAGS -Wl,--high-entropy-va"
-        AC_TRY_LINK([
-        ],[
-        ],[
+        AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])], [
         have_high_entropy_va=yes
         EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,--high-entropy-va"
-        ])
+        ],[])
         LDFLAGS="$save_LDFLAGS"
         ;;
 esac
@@ -304,30 +303,24 @@ AC_MSG_RESULT($have_high_entropy_va)
 
 dnl See whether we are allowed to use the system C library
 AC_ARG_ENABLE(libc,
-AS_HELP_STRING([--enable-libc], [Use the system C library [[default=yes]]]),
+[AS_HELP_STRING([--enable-libc], [Use the system C library [default=yes]])],
               , enable_libc=yes)
 if test x$enable_libc = xyes; then
     AC_DEFINE(HAVE_LIBC, 1, [ ])
 
-    dnl Check for C library headers
+dnl Check for C library headers
     AC_HEADER_STDC
     AC_CHECK_HEADERS(sys/types.h stdio.h stdlib.h stddef.h stdarg.h malloc.h memory.h string.h strings.h wchar.h inttypes.h stdint.h limits.h ctype.h math.h float.h iconv.h signal.h)
 
-    dnl Check for typedefs, structures, etc.
+dnl Check for typedefs, structures, etc.
     AC_TYPE_SIZE_T
 
-    dnl Check for defines
+dnl Check for defines
     AC_CHECK_DEFINE(M_PI, math.h)
 
-    dnl Checks for library functions.
-    case "$host" in
-    *-*-cygwin* | *-*-mingw32*)
-        ;;
-    *)
-        AC_FUNC_ALLOCA
-        ;;
-    esac
+    AC_FUNC_ALLOCA
 
+dnl Checks for library functions.
     AC_FUNC_MEMCMP
     if test x$ac_cv_func_memcmp_working = xyes; then
         AC_DEFINE(HAVE_MEMCMP, 1, [ ])
@@ -337,25 +330,24 @@ if test x$enable_libc = xyes; then
         AC_DEFINE(HAVE_STRTOD, 1, [ ])
     fi
     AC_CHECK_FUNC(mprotect,
-        AC_TRY_COMPILE([
+        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
           #include <sys/types.h>
           #include <sys/mman.h>
-        ],[
-        ],[
+        ]],[])], [
         AC_DEFINE(HAVE_MPROTECT, 1, [ ])
-        ]),
+        ],[]),
     )
-    AC_CHECK_FUNCS(malloc calloc realloc free getenv setenv putenv unsetenv qsort abs bcopy memset memcpy memmove wcslen wcslcpy wcslcat wcsdup wcsstr wcscmp wcsncmp wcscasecmp _wcsicmp wcsncasecmp _wcsnicmp strlen strlcpy strlcat _strrev _strupr _strlwr strchr strrchr strstr strtok_r itoa _ltoa _uitoa _ultoa strtol strtoul _i64toa _ui64toa strtoll strtoull atoi atof strcmp strncmp _stricmp strcasecmp _strnicmp strncasecmp vsscanf vsnprintf fopen64 fseeko fseeko64 sigaction setjmp nanosleep sysconf sysctlbyname getauxval elf_aux_info poll _Exit)
+    AC_CHECK_FUNCS(malloc calloc realloc free getenv setenv putenv unsetenv qsort abs bcopy memset memcpy memmove wcslen wcslcpy wcslcat _wcsdup wcsdup wcsstr wcscmp wcsncmp wcscasecmp _wcsicmp wcsncasecmp _wcsnicmp strlen strlcpy strlcat _strrev _strupr _strlwr index rindex strchr strrchr strstr strtok_r itoa _ltoa _uitoa _ultoa strtol strtoul _i64toa _ui64toa strtoll strtoull atoi atof strcmp strncmp _stricmp strcasecmp _strnicmp strncasecmp vsscanf vsnprintf fopen64 fseeko fseeko64 sigaction setjmp nanosleep sysconf sysctlbyname getauxval elf_aux_info poll _Exit)
 
     AC_CHECK_LIB(m, pow, [LIBS="$LIBS -lm"; EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lm"])
-    AC_CHECK_FUNCS(acos acosf asin asinf atan atanf atan2 atan2f ceil ceilf copysign copysignf cos cosf exp expf fabs fabsf floor floorf trunc truncf fmod fmodf log logf log10 log10f pow powf scalbn scalbnf sin sinf sqrt sqrtf tan tanf)
+    AC_CHECK_FUNCS(acos acosf asin asinf atan atanf atan2 atan2f ceil ceilf copysign copysignf cos cosf exp expf fabs fabsf floor floorf trunc truncf fmod fmodf log logf log10 log10f lround lroundf pow powf round roundf scalbn scalbnf sin sinf sqrt sqrtf tan tanf)
 
     AC_CHECK_LIB(iconv, iconv_open, [LIBS="$LIBS -liconv"; EXTRA_LDFLAGS="$EXTRA_LDFLAGS -liconv"])
     AC_CHECK_FUNCS(iconv)
 
     AC_CHECK_MEMBER(struct sigaction.sa_sigaction,[AC_DEFINE([HAVE_SA_SIGACTION], 1, [ ])], ,[#include <signal.h>])
 
-    dnl Check for additional non-standard headers
+dnl Check for additional non-standard headers
     AC_CHECK_HEADERS(libunwind.h)
 fi
 
@@ -363,14 +355,13 @@ dnl AC_CHECK_SIZEOF(void*)
 
 dnl See whether we can use gcc atomic operations on this architecture
 AC_ARG_ENABLE(gcc-atomics,
-AS_HELP_STRING([--enable-gcc-atomics],
-               [Use gcc builtin atomics [[default=yes]]]),
+[AS_HELP_STRING([--enable-gcc-atomics],
+               [Use gcc builtin atomics [default=yes]])],
               , enable_gcc_atomics=yes)
 if test x$enable_gcc_atomics = xyes; then
     have_gcc_atomics=no
     AC_MSG_CHECKING(for GCC builtin atomic operations)
-    AC_TRY_LINK([
-    ],[
+    AC_LINK_IFELSE([AC_LANG_PROGRAM([],[[
     int a;
     void *x, *y, *z;
     __sync_lock_test_and_set(&a, 4);
@@ -378,23 +369,19 @@ if test x$enable_gcc_atomics = xyes; then
     __sync_fetch_and_add(&a, 1);
     __sync_bool_compare_and_swap(&a, 5, 10);
     __sync_bool_compare_and_swap(&x, y, z);
-    ],[
-    have_gcc_atomics=yes
-    ])
+    ]])],
+     [have_gcc_atomics=yes],[])
     AC_MSG_RESULT($have_gcc_atomics)
 
     if test x$have_gcc_atomics = xyes; then
         AC_DEFINE(HAVE_GCC_ATOMICS, 1, [ ])
     else
         # See if we have the minimum operation needed for GCC atomics
-        AC_TRY_LINK([
-        ],[
+        AC_LINK_IFELSE([AC_LANG_PROGRAM([],[[
         int a;
         __sync_lock_test_and_set(&a, 1);
         __sync_lock_release(&a);
-        ],[
-        have_gcc_sync_lock_test_and_set=yes
-        ])
+        ]])], [have_gcc_sync_lock_test_and_set=yes],[])
         if test x$have_gcc_sync_lock_test_and_set = xyes; then
             AC_DEFINE(HAVE_GCC_SYNC_LOCK_TEST_AND_SET, 1, [ ])
         fi
@@ -410,6 +397,7 @@ SOURCES="$SOURCES $srcdir/src/dynapi/*.c"
 SOURCES="$SOURCES $srcdir/src/events/*.c"
 SOURCES="$SOURCES $srcdir/src/file/*.c"
 SOURCES="$SOURCES $srcdir/src/haptic/*.c"
+SOURCES="$SOURCES $srcdir/src/hidapi/*.c"
 SOURCES="$SOURCES $srcdir/src/joystick/*.c"
 SOURCES="$SOURCES $srcdir/src/libm/*.c"
 SOURCES="$SOURCES $srcdir/src/misc/*.c"
@@ -427,16 +415,25 @@ SOURCES="$SOURCES $srcdir/src/locale/*.c"
 
 dnl Enable/disable various subsystems of the SDL library
 
+case "$host" in
+    *-*-emscripten*)
+        default_atomic=no
+        ;;
+    *)
+        default_atomic=yes
+        ;;
+esac
+
 AC_ARG_ENABLE(atomic,
-AS_HELP_STRING([--enable-atomic], [Enable the atomic operations subsystem [[default=yes]]]),
-              , enable_atomic=yes)
+[AS_HELP_STRING([--enable-atomic], [Enable the atomic operations subsystem [default=yes]])],
+              , enable_atomic=$default_atomic)
 if test x$enable_atomic != xyes; then
     AC_DEFINE(SDL_ATOMIC_DISABLED, 1, [ ])
 else
     SUMMARY_modules="${SUMMARY_modules} atomic"
 fi
 AC_ARG_ENABLE(audio,
-AS_HELP_STRING([--enable-audio], [Enable the audio subsystem [[default=yes]]]),
+[AS_HELP_STRING([--enable-audio], [Enable the audio subsystem [default=yes]])],
               , enable_audio=yes)
 if test x$enable_audio != xyes; then
     AC_DEFINE(SDL_AUDIO_DISABLED, 1, [ ])
@@ -444,7 +441,7 @@ else
     SUMMARY_modules="${SUMMARY_modules} audio"
 fi
 AC_ARG_ENABLE(video,
-AS_HELP_STRING([--enable-video], [Enable the video subsystem [[default=yes]]]),
+[AS_HELP_STRING([--enable-video], [Enable the video subsystem [default=yes]])],
               , enable_video=yes)
 if test x$enable_video != xyes; then
     AC_DEFINE(SDL_VIDEO_DISABLED, 1, [ ])
@@ -452,7 +449,7 @@ else
     SUMMARY_modules="${SUMMARY_modules} video"
 fi
 AC_ARG_ENABLE(render,
-AS_HELP_STRING([--enable-render], [Enable the render subsystem [[default=yes]]]),
+[AS_HELP_STRING([--enable-render], [Enable the render subsystem [default=yes]])],
               , enable_render=yes)
 if test x$enable_render != xyes; then
     AC_DEFINE(SDL_RENDER_DISABLED, 1, [ ])
@@ -460,7 +457,7 @@ else
     SUMMARY_modules="${SUMMARY_modules} render"
 fi
 AC_ARG_ENABLE(events,
-AS_HELP_STRING([--enable-events], [Enable the events subsystem [[default=yes]]]),
+[AS_HELP_STRING([--enable-events], [Enable the events subsystem [default=yes]])],
               , enable_events=yes)
 if test x$enable_events != xyes; then
     AC_DEFINE(SDL_EVENTS_DISABLED, 1, [ ])
@@ -468,7 +465,7 @@ else
     SUMMARY_modules="${SUMMARY_modules} events"
 fi
 AC_ARG_ENABLE(joystick,
-AS_HELP_STRING([--enable-joystick], [Enable the joystick subsystem [[default=yes]]]),
+[AS_HELP_STRING([--enable-joystick], [Enable the joystick subsystem [default=yes]])],
               , enable_joystick=yes)
 if test x$enable_joystick != xyes; then
     AC_DEFINE(SDL_JOYSTICK_DISABLED, 1, [ ])
@@ -476,15 +473,23 @@ else
     SUMMARY_modules="${SUMMARY_modules} joystick"
 fi
 AC_ARG_ENABLE(haptic,
-AS_HELP_STRING([--enable-haptic], [Enable the haptic (force feedback) subsystem [[default=yes]]]),
+[AS_HELP_STRING([--enable-haptic], [Enable the haptic (force feedback) subsystem [default=yes]])],
               , enable_haptic=yes)
 if test x$enable_haptic != xyes; then
     AC_DEFINE(SDL_HAPTIC_DISABLED, 1, [ ])
 else
     SUMMARY_modules="${SUMMARY_modules} haptic"
 fi
+AC_ARG_ENABLE(hidapi,
+[AS_HELP_STRING([--enable-hidapi], [Enable the HIDAPI subsystem [default=yes]])],
+              , enable_hidapi=yes)
+if test x$enable_hidapi != xyes; then
+    AC_DEFINE(SDL_HIDAPI_DISABLED, 1, [ ])
+else
+    SUMMARY_modules="${SUMMARY_modules} hidapi"
+fi
 AC_ARG_ENABLE(sensor,
-AS_HELP_STRING([--enable-sensor], [Enable the sensor subsystem [[default=yes]]]),
+[AS_HELP_STRING([--enable-sensor], [Enable the sensor subsystem [default=yes]])],
               , enable_sensor=yes)
 if test x$enable_sensor != xyes; then
     AC_DEFINE(SDL_SENSOR_DISABLED, 1, [ ])
@@ -492,7 +497,7 @@ else
     SUMMARY_modules="${SUMMARY_modules} sensor"
 fi
 AC_ARG_ENABLE(power,
-AS_HELP_STRING([--enable-power], [Enable the power subsystem [[default=yes]]]),
+[AS_HELP_STRING([--enable-power], [Enable the power subsystem [default=yes]])],
               , enable_power=yes)
 if test x$enable_power != xyes; then
     AC_DEFINE(SDL_POWER_DISABLED, 1, [ ])
@@ -500,7 +505,7 @@ else
     SUMMARY_modules="${SUMMARY_modules} power"
 fi
 AC_ARG_ENABLE(filesystem,
-AS_HELP_STRING([--enable-filesystem], [Enable the filesystem subsystem [[default=yes]]]),
+[AS_HELP_STRING([--enable-filesystem], [Enable the filesystem subsystem [default=yes]])],
               , enable_filesystem=yes)
 if test x$enable_filesystem != xyes; then
     AC_DEFINE(SDL_FILESYSTEM_DISABLED, 1, [ ])
@@ -508,7 +513,7 @@ else
     SUMMARY_modules="${SUMMARY_modules} filesystem"
 fi
 AC_ARG_ENABLE(threads,
-AS_HELP_STRING([--enable-threads], [Enable the threading subsystem [[default=yes]]]),
+[AS_HELP_STRING([--enable-threads], [Enable the threading subsystem [default=yes]])],
               , enable_threads=yes)
 if test x$enable_threads != xyes; then
     AC_DEFINE(SDL_THREADS_DISABLED, 1, [ ])
@@ -516,7 +521,7 @@ else
     SUMMARY_modules="${SUMMARY_modules} threads"
 fi
 AC_ARG_ENABLE(timers,
-AS_HELP_STRING([--enable-timers], [Enable the timer subsystem [[default=yes]]]),
+[AS_HELP_STRING([--enable-timers], [Enable the timer subsystem [default=yes]])],
               , enable_timers=yes)
 if test x$enable_timers != xyes; then
     AC_DEFINE(SDL_TIMERS_DISABLED, 1, [ ])
@@ -524,15 +529,31 @@ else
     SUMMARY_modules="${SUMMARY_modules} timers"
 fi
 AC_ARG_ENABLE(file,
-AS_HELP_STRING([--enable-file], [Enable the file subsystem [[default=yes]]]),
+[AS_HELP_STRING([--enable-file], [Enable the file subsystem [default=yes]])],
               , enable_file=yes)
 if test x$enable_file != xyes; then
     AC_DEFINE(SDL_FILE_DISABLED, 1, [ ])
 else
     SUMMARY_modules="${SUMMARY_modules} file"
 fi
+AC_ARG_ENABLE(misc,
+[AS_HELP_STRING([--enable-misc], [Enable the misc subsystem [default=yes]])],
+              , enable_misc=yes)
+if test x$enable_misc != xyes; then
+    AC_DEFINE(SDL_MISC_DISABLED, 1, [ ])
+else
+    SUMMARY_modules="${SUMMARY_modules} misc"
+fi
+AC_ARG_ENABLE(locale,
+[AS_HELP_STRING([--enable-locale], [Enable the locale subsystem [default=yes]])],
+              , enable_locale=yes)
+if test x$enable_locale != xyes; then
+    AC_DEFINE(SDL_LOCALE_DISABLED, 1, [ ])
+else
+    SUMMARY_modules="${SUMMARY_modules} locale"
+fi
 AC_ARG_ENABLE(loadso,
-AS_HELP_STRING([--enable-loadso], [Enable the shared object loading subsystem [[default=yes]]]),
+[AS_HELP_STRING([--enable-loadso], [Enable the shared object loading subsystem [default=yes]])],
               , enable_loadso=yes)
 if test x$enable_loadso != xyes; then
     AC_DEFINE(SDL_LOADSO_DISABLED, 1, [ ])
@@ -540,7 +561,7 @@ else
     SUMMARY_modules="${SUMMARY_modules} loadso"
 fi
 AC_ARG_ENABLE(cpuinfo,
-AS_HELP_STRING([--enable-cpuinfo], [Enable the cpuinfo subsystem [[default=yes]]]),
+[AS_HELP_STRING([--enable-cpuinfo], [Enable the cpuinfo subsystem [default=yes]])],
               , enable_cpuinfo=yes)
 if test x$enable_cpuinfo != xyes; then
     AC_DEFINE(SDL_CPUINFO_DISABLED, 1, [ ])
@@ -548,7 +569,7 @@ else
     SUMMARY_modules="${SUMMARY_modules} cpuinfo"
 fi
 AC_ARG_ENABLE(assembly,
-AS_HELP_STRING([--enable-assembly], [Enable assembly routines [[default=yes]]]),
+[AS_HELP_STRING([--enable-assembly], [Enable assembly routines [default=yes]])],
               , enable_assembly=yes)
 if test x$enable_assembly = xyes; then
     SUMMARY_modules="${SUMMARY_modules} assembly"
@@ -571,7 +592,7 @@ if test x$enable_assembly = xyes; then
             ;;
     esac
     AC_ARG_ENABLE(ssemath,
-AS_HELP_STRING([--enable-ssemath], [Allow GCC to use SSE floating point math [[default=maybe]]]),
+[AS_HELP_STRING([--enable-ssemath], [Allow GCC to use SSE floating point math [default=maybe]])],
                   , enable_ssemath=$default_ssemath)
     if test x$enable_ssemath = xno; then
         if test x$have_gcc_sse = xyes -o x$have_gcc_sse2 = xyes -o x$have_gcc_sse3 = xyes; then
@@ -579,9 +600,9 @@ AS_HELP_STRING([--enable-ssemath], [Allow GCC to use SSE floating point math [[d
         fi
     fi
 
-    dnl Check for various instruction support
+dnl Check for various instruction support
     AC_ARG_ENABLE(mmx,
-AS_HELP_STRING([--enable-mmx], [use MMX assembly routines [[default=yes]]]),
+[AS_HELP_STRING([--enable-mmx], [use MMX assembly routines [default=yes]])],
                   , enable_mmx=yes)
     if test x$enable_mmx = xyes; then
         save_CFLAGS="$CFLAGS"
@@ -590,7 +611,7 @@ AS_HELP_STRING([--enable-mmx], [use MMX assembly routines [[default=yes]]]),
         mmx_CFLAGS="-mmmx"
         CFLAGS="$save_CFLAGS $mmx_CFLAGS"
 
-        AC_TRY_COMPILE([
+        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
         #ifdef __MINGW32__
         #include <_mingw.h>
         #ifdef __MINGW64_VERSION_MAJOR
@@ -604,10 +625,7 @@ AS_HELP_STRING([--enable-mmx], [use MMX assembly routines [[default=yes]]]),
         #ifndef __MMX__
         #error Assembler CPP flag not enabled
         #endif
-        ],[
-        ],[
-        have_gcc_mmx=yes
-        ])
+        ]],[])], [have_gcc_mmx=yes],[])
         AC_MSG_RESULT($have_gcc_mmx)
         CFLAGS="$save_CFLAGS"
 
@@ -618,7 +636,7 @@ AS_HELP_STRING([--enable-mmx], [use MMX assembly routines [[default=yes]]]),
     fi
 
     AC_ARG_ENABLE(3dnow,
-AS_HELP_STRING([--enable-3dnow], [use 3DNow! assembly routines [[default=yes]]]),
+[AS_HELP_STRING([--enable-3dnow], [use 3DNow! assembly routines [default=yes]])],
                   , enable_3dnow=yes)
     if test x$enable_3dnow = xyes; then
         save_CFLAGS="$CFLAGS"
@@ -627,17 +645,16 @@ AS_HELP_STRING([--enable-3dnow], [use 3DNow! assembly routines [[default=yes]]])
         amd3dnow_CFLAGS="-m3dnow"
         CFLAGS="$save_CFLAGS $amd3dnow_CFLAGS"
 
-        AC_TRY_LINK([
+        AC_LINK_IFELSE([AC_LANG_PROGRAM([[
         #include <mm3dnow.h>
         #ifndef __3dNOW__
         #error Assembler CPP flag not enabled
         #endif
-        ],[
+        ]], [[
         void *p = 0;
         _m_prefetch(p);
-        ],[
-        have_gcc_3dnow=yes
-        ])
+        ]])],
+         [have_gcc_3dnow=yes],[])
         AC_MSG_RESULT($have_gcc_3dnow)
         CFLAGS="$save_CFLAGS"
 
@@ -648,7 +665,7 @@ AS_HELP_STRING([--enable-3dnow], [use 3DNow! assembly routines [[default=yes]]])
     fi
 
     AC_ARG_ENABLE(sse,
-AS_HELP_STRING([--enable-sse], [use SSE assembly routines [[default=yes]]]),
+[AS_HELP_STRING([--enable-sse], [use SSE assembly routines [default=yes]])],
                   , enable_sse=yes)
     if test x$enable_sse = xyes; then
         save_CFLAGS="$CFLAGS"
@@ -657,7 +674,7 @@ AS_HELP_STRING([--enable-sse], [use SSE assembly routines [[default=yes]]]),
         sse_CFLAGS="-msse"
         CFLAGS="$save_CFLAGS $sse_CFLAGS"
 
-        AC_TRY_COMPILE([
+        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
         #ifdef __MINGW32__
         #include <_mingw.h>
         #ifdef __MINGW64_VERSION_MAJOR
@@ -671,10 +688,7 @@ AS_HELP_STRING([--enable-sse], [use SSE assembly routines [[default=yes]]]),
         #ifndef __SSE__
         #error Assembler CPP flag not enabled
         #endif
-        ],[
-        ],[
-        have_gcc_sse=yes
-        ])
+        ]],[])], [have_gcc_sse=yes],[])
         AC_MSG_RESULT($have_gcc_sse)
         CFLAGS="$save_CFLAGS"
 
@@ -685,7 +699,7 @@ AS_HELP_STRING([--enable-sse], [use SSE assembly routines [[default=yes]]]),
     fi
 
     AC_ARG_ENABLE(sse2,
-AS_HELP_STRING([--enable-sse2], [use SSE2 assembly routines [[default=maybe]]]),
+[AS_HELP_STRING([--enable-sse2], [use SSE2 assembly routines [default=maybe]])],
                   , enable_sse2=$default_ssemath)
     if test x$enable_sse2 = xyes; then
         save_CFLAGS="$CFLAGS"
@@ -694,7 +708,7 @@ AS_HELP_STRING([--enable-sse2], [use SSE2 assembly routines [[default=maybe]]]),
         sse2_CFLAGS="-msse2"
         CFLAGS="$save_CFLAGS $sse2_CFLAGS"
 
-        AC_TRY_COMPILE([
+        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
         #ifdef __MINGW32__
         #include <_mingw.h>
         #ifdef __MINGW64_VERSION_MAJOR
@@ -708,10 +722,7 @@ AS_HELP_STRING([--enable-sse2], [use SSE2 assembly routines [[default=maybe]]]),
         #ifndef __SSE2__
         #error Assembler CPP flag not enabled
         #endif
-        ],[
-        ],[
-        have_gcc_sse2=yes
-        ])
+        ]],[])], [have_gcc_sse2=yes],[])
         AC_MSG_RESULT($have_gcc_sse2)
         CFLAGS="$save_CFLAGS"
 
@@ -722,7 +733,7 @@ AS_HELP_STRING([--enable-sse2], [use SSE2 assembly routines [[default=maybe]]]),
     fi
 
     AC_ARG_ENABLE(sse3,
-AS_HELP_STRING([--enable-sse3], [use SSE3 assembly routines [[default=maybe]]]),
+[AS_HELP_STRING([--enable-sse3], [use SSE3 assembly routines [default=maybe]])],
                   , enable_sse3=$default_ssemath)
     if test x$enable_sse3 = xyes; then
         save_CFLAGS="$CFLAGS"
@@ -731,7 +742,7 @@ AS_HELP_STRING([--enable-sse3], [use SSE3 assembly routines [[default=maybe]]]),
         sse3_CFLAGS="-msse3"
         CFLAGS="$save_CFLAGS $sse3_CFLAGS"
 
-        AC_TRY_COMPILE([
+        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
         #ifdef __MINGW32__
         #include <_mingw.h>
         #ifdef __MINGW64_VERSION_MAJOR
@@ -745,10 +756,7 @@ AS_HELP_STRING([--enable-sse3], [use SSE3 assembly routines [[default=maybe]]]),
         #ifndef __SSE2__
         #error Assembler CPP flag not enabled
         #endif
-        ],[
-        ],[
-        have_gcc_sse3=yes
-        ])
+        ]],[])], [have_gcc_sse3=yes],[])
         AC_MSG_RESULT($have_gcc_sse3)
         CFLAGS="$save_CFLAGS"
 
@@ -758,15 +766,16 @@ AS_HELP_STRING([--enable-sse3], [use SSE3 assembly routines [[default=maybe]]]),
         fi
     fi
 
-    AC_CHECK_HEADER(immintrin.h,
-                    have_immintrin_h_hdr=yes,
-                    have_immintrin_h_hdr=no)
+    AC_MSG_CHECKING(for immintrin.h)
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <immintrin.h>]])],
+       [have_immintrin_h_hdr=yes],[have_immintrin_h_hdr=no])
+    AC_MSG_RESULT($have_immintrin_h_hdr)
     if test x$have_immintrin_h_hdr = xyes; then
         AC_DEFINE(HAVE_IMMINTRIN_H, 1, [ ])
     fi
 
     AC_ARG_ENABLE(altivec,
-AS_HELP_STRING([--enable-altivec], [use Altivec assembly routines [[default=yes]]]),
+[AS_HELP_STRING([--enable-altivec], [use Altivec assembly routines [default=yes]])],
                   , enable_altivec=yes)
     if test x$enable_altivec = xyes; then
         save_CFLAGS="$CFLAGS"
@@ -776,28 +785,24 @@ AS_HELP_STRING([--enable-altivec], [use Altivec assembly routines [[default=yes]
         CFLAGS="$save_CFLAGS $altivec_CFLAGS"
 
         AC_MSG_CHECKING(for Altivec with GCC altivec.h and -maltivec option)
-        AC_TRY_COMPILE([
+        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
         #include <altivec.h>
         vector unsigned int vzero() {
             return vec_splat_u32(0);
         }
-        ],[
-        ],[
+        ]],[])], [
         have_gcc_altivec=yes
         have_altivec_h_hdr=yes
-        ])
+        ],[])
         AC_MSG_RESULT($have_gcc_altivec)
 
         if test x$have_gcc_altivec = xno; then
             AC_MSG_CHECKING(for Altivec with GCC -maltivec option)
-            AC_TRY_COMPILE([
+            AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
             vector unsigned int vzero() {
                 return vec_splat_u32(0);
             }
-            ],[
-            ],[
-            have_gcc_altivec=yes
-            ])
+            ]],[])], [have_gcc_altivec=yes],[])
             AC_MSG_RESULT($have_gcc_altivec)
         fi
 
@@ -805,29 +810,25 @@ AS_HELP_STRING([--enable-altivec], [use Altivec assembly routines [[default=yes]
             AC_MSG_CHECKING(for Altivec with GCC altivec.h and -faltivec option)
             altivec_CFLAGS="-faltivec"
             CFLAGS="$save_CFLAGS $altivec_CFLAGS"
-            AC_TRY_COMPILE([
+            AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
             #include <altivec.h>
             vector unsigned int vzero() {
                 return vec_splat_u32(0);
             }
-            ],[
-            ],[
+            ]],[])], [
             have_gcc_altivec=yes
             have_altivec_h_hdr=yes
-            ])
+            ],[])
             AC_MSG_RESULT($have_gcc_altivec)
         fi
 
         if test x$have_gcc_altivec = xno; then
             AC_MSG_CHECKING(for Altivec with GCC -faltivec option)
-            AC_TRY_COMPILE([
+            AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
             vector unsigned int vzero() {
                 return vec_splat_u32(0);
             }
-            ],[
-            ],[
-            have_gcc_altivec=yes
-            ])
+            ]],[])], [have_gcc_altivec=yes],[])
             AC_MSG_RESULT($have_gcc_altivec)
         fi
         CFLAGS="$save_CFLAGS"
@@ -847,7 +848,7 @@ dnl See if the OSS audio interface is supported
 CheckOSS()
 {
     AC_ARG_ENABLE(oss,
-AS_HELP_STRING([--enable-oss], [support the OSS audio API [[default=maybe]]]),
+[AS_HELP_STRING([--enable-oss], [support the OSS audio API [default=maybe]])],
                   , enable_oss=maybe)
 
     # OpenBSD "has" OSS, but it's not really for app use. They want you to
@@ -865,23 +866,21 @@ AS_HELP_STRING([--enable-oss], [support the OSS audio API [[default=maybe]]]),
         AC_MSG_CHECKING(for OSS audio support)
         have_oss=no
         if test x$have_oss != xyes; then
-            AC_TRY_COMPILE([
+            AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
               #include <sys/soundcard.h>
-            ],[
+            ]], [[
               int arg = SNDCTL_DSP_SETFRAGMENT;
-            ],[
-            have_oss=yes
-            ])
+            ]])], [have_oss=yes],[])
         fi
         if test x$have_oss != xyes; then
-            AC_TRY_COMPILE([
+            AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
               #include <soundcard.h>
-            ],[
+            ]], [[
               int arg = SNDCTL_DSP_SETFRAGMENT;
-            ],[
+            ]])], [
             have_oss=yes
             AC_DEFINE(SDL_AUDIO_DRIVER_OSS_SOUNDCARD_H, 1, [ ])
-            ])
+            ],[])
         fi
         AC_MSG_RESULT($have_oss)
         if test x$have_oss = xyes; then
@@ -903,7 +902,7 @@ dnl See if the ALSA audio interface is supported
 CheckALSA()
 {
     AC_ARG_ENABLE(alsa,
-AS_HELP_STRING([--enable-alsa], [support the ALSA audio API [[default=yes]]]),
+[AS_HELP_STRING([--enable-alsa], [support the ALSA audio API [default=yes]])],
                   , enable_alsa=yes)
     if test x$enable_audio = xyes -a x$enable_alsa = xyes; then
         AM_PATH_ALSA(1.0.11, have_alsa=yes, have_alsa=no)
@@ -913,7 +912,7 @@ AS_HELP_STRING([--enable-alsa], [support the ALSA audio API [[default=yes]]]),
         LIBS="$alsa_save_LIBS"
         if test x$have_alsa = xyes; then
             AC_ARG_ENABLE(alsa-shared,
-AS_HELP_STRING([--enable-alsa-shared], [dynamically load ALSA audio support [[default=yes]]]),
+[AS_HELP_STRING([--enable-alsa-shared], [dynamically load ALSA audio support [default=yes]])],
                           , enable_alsa_shared=yes)
             alsa_lib=[`find_lib "libasound.so.*" "$ALSA_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`]
 
@@ -942,14 +941,14 @@ dnl Find JACK Audio
 CheckJACK()
 {
     AC_ARG_ENABLE(jack,
-AS_HELP_STRING([--enable-jack], [use JACK audio [[default=yes]]]),
+[AS_HELP_STRING([--enable-jack], [use JACK audio [default=yes]])],
                   , enable_jack=yes)
     if test x$enable_audio = xyes -a x$enable_jack = xyes; then
         PKG_CHECK_MODULES([JACK], [jack >= 0.125], audio_jack=yes, audio_jack=no)
 
         if test x$audio_jack = xyes; then
             AC_ARG_ENABLE(jack-shared,
-AS_HELP_STRING([--enable-jack-shared], [dynamically load JACK audio support [[default=yes]]]),
+[AS_HELP_STRING([--enable-jack-shared], [dynamically load JACK audio support [default=yes]])],
                           , enable_jack_shared=yes)
             jack_lib=[`find_lib "libjack.so.*" "$JACK_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`]
 
@@ -986,13 +985,13 @@ dnl Find the ESD includes and libraries
 CheckESD()
 {
     AC_ARG_ENABLE(esd,
-AS_HELP_STRING([--enable-esd], [support the Enlightened Sound Daemon [[default=yes]]]),
+[AS_HELP_STRING([--enable-esd], [support the Enlightened Sound Daemon [default=yes]])],
                   , enable_esd=yes)
     if test x$enable_audio = xyes -a x$enable_esd = xyes; then
         AM_PATH_ESD(0.2.8, have_esd=yes, have_esd=no)
         if test x$have_esd = xyes; then
             AC_ARG_ENABLE(esd-shared,
-AS_HELP_STRING([--enable-esd-shared], [dynamically load ESD audio support [[default=yes]]]),
+[AS_HELP_STRING([--enable-esd-shared], [dynamically load ESD audio support [default=yes]])],
                           , enable_esd_shared=yes)
             esd_lib=[`find_lib "libesd.so.*" "$ESD_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`]
 
@@ -1017,18 +1016,54 @@ AS_HELP_STRING([--enable-esd-shared], [dynamically load ESD audio support [[defa
     fi
 }
 
+dnl Find Pipewire
+CheckPipewire()
+{
+    AC_ARG_ENABLE(pipewire,
+[AS_HELP_STRING([--enable-pipewire], [use Pipewire audio [default=yes]])],
+                  , enable_pipewire=yes)
+    if test x$enable_audio = xyes -a x$enable_pipewire = xyes; then
+        PKG_CHECK_MODULES([PIPEWIRE], [libpipewire-0.3 >= 0.3.20], audio_pipewire=yes, audio_pipewire=no)
+
+        if test x$audio_pipewire = xyes; then
+            AC_ARG_ENABLE(pipewire-shared,
+[AS_HELP_STRING([--enable-pipewire-shared], [dynamically load Pipewire support [default=yes]])],
+                          , enable_pipewire_shared=yes)
+            pipewire_lib=[`find_lib "libpipewire-0.3.so.*" "$PIPEWIRE_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`]
+
+            AC_DEFINE(SDL_AUDIO_DRIVER_PIPEWIRE, 1, [ ])
+            SOURCES="$SOURCES $srcdir/src/audio/pipewire/*.c"
+            EXTRA_CFLAGS="$EXTRA_CFLAGS $PIPEWIRE_CFLAGS"
+            if test x$have_loadso != xyes && \
+               test x$enable_pipewire_shared = xyes; then
+                AC_MSG_WARN([You must have SDL_LoadObject() support for dynamic Pipewire loading])
+            fi
+            if test x$have_loadso = xyes && \
+               test x$enable_pipewire_shared = xyes && test x$pipewire_lib != x; then
+                echo "-- dynamic libpipewire-0.3 -> $pipewire_lib"
+                AC_DEFINE_UNQUOTED(SDL_AUDIO_DRIVER_PIPEWIRE_DYNAMIC, "$pipewire_lib", [ ])
+                SUMMARY_audio="${SUMMARY_audio} pipewire(dynamic)"
+            else
+                EXTRA_LDFLAGS="$EXTRA_LDFLAGS $PIPEWIRE_LIBS"
+                SUMMARY_audio="${SUMMARY_audio} pipewire"
+            fi
+            have_audio=yes
+        fi
+    fi
+}
+
 dnl Find PulseAudio
 CheckPulseAudio()
 {
     AC_ARG_ENABLE(pulseaudio,
-AS_HELP_STRING([--enable-pulseaudio], [use PulseAudio [[default=yes]]]),
+[AS_HELP_STRING([--enable-pulseaudio], [use PulseAudio [default=yes]])],
                   , enable_pulseaudio=yes)
     if test x$enable_audio = xyes -a x$enable_pulseaudio = xyes; then
         PKG_CHECK_MODULES([PULSEAUDIO], [libpulse-simple >= 0.9], audio_pulseaudio=yes, audio_pulseaudio=no)
 
         if test x$audio_pulseaudio = xyes; then
             AC_ARG_ENABLE(pulseaudio-shared,
-AS_HELP_STRING([--enable-pulseaudio-shared], [dynamically load PulseAudio support [[default=yes]]]),
+[AS_HELP_STRING([--enable-pulseaudio-shared], [dynamically load PulseAudio support [default=yes]])],
                           , enable_pulseaudio_shared=yes)
             pulseaudio_lib=[`find_lib "libpulse-simple.so.*" "$PULSEAUDIO_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`]
 
@@ -1064,7 +1099,7 @@ AS_HELP_STRING([--enable-pulseaudio-shared], [dynamically load PulseAudio suppor
 CheckARTSC()
 {
     AC_ARG_ENABLE(arts,
-AS_HELP_STRING([--enable-arts], [support the Analog Real Time Synthesizer [[default=yes]]]),
+[AS_HELP_STRING([--enable-arts], [support the Analog Real Time Synthesizer [default=yes]])],
                   , enable_arts=yes)
     if test x$enable_audio = xyes -a x$enable_arts = xyes; then
         AC_PATH_PROG(ARTSCONFIG, artsc-config)
@@ -1077,18 +1112,16 @@ AS_HELP_STRING([--enable-arts], [support the Analog Real Time Synthesizer [[defa
             audio_arts=no
             save_CFLAGS="$CFLAGS"
             CFLAGS="$CFLAGS $ARTS_CFLAGS"
-            AC_TRY_COMPILE([
+            AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
              #include <artsc.h>
-            ],[
+            ]], [[
              arts_stream_t stream;
-            ],[
-            audio_arts=yes
-            ])
+            ]])], [audio_arts=yes],[])
             CFLAGS="$save_CFLAGS"
             AC_MSG_RESULT($audio_arts)
             if test x$audio_arts = xyes; then
                 AC_ARG_ENABLE(arts-shared,
-AS_HELP_STRING([--enable-arts-shared], [dynamically load aRts audio support [[default=yes]]]),
+[AS_HELP_STRING([--enable-arts-shared], [dynamically load aRts audio support [default=yes]])],
                               , enable_arts_shared=yes)
                 arts_lib=[`find_lib "libartsc.so.*" "$ARTS_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`]
 
@@ -1118,7 +1151,7 @@ dnl See if the NAS audio interface is supported
 CheckNAS()
 {
     AC_ARG_ENABLE(nas,
-AS_HELP_STRING([--enable-nas], [support the NAS audio API [[default=yes]]]),
+[AS_HELP_STRING([--enable-nas], [support the NAS audio API [default=yes]])],
                   , enable_nas=yes)
     if test x$enable_audio = xyes -a x$enable_nas = xyes; then
         AC_CHECK_HEADER(audio/audiolib.h, have_nas_hdr=yes)
@@ -1142,7 +1175,7 @@ AS_HELP_STRING([--enable-nas], [support the NAS audio API [[default=yes]]]),
 
         if test x$have_nas = xyes; then
             AC_ARG_ENABLE(nas-shared,
-AS_HELP_STRING([--enable-nas-shared], [dynamically load NAS audio support [[default=yes]]]),
+[AS_HELP_STRING([--enable-nas-shared], [dynamically load NAS audio support [default=yes]])],
                           , enable_nas_shared=yes)
             nas_lib=[`find_lib "libaudio.so.*" "$NAS_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`]
 
@@ -1172,7 +1205,7 @@ dnl See if the sndio audio interface is supported
 CheckSNDIO()
 {
     AC_ARG_ENABLE(sndio,
-AS_HELP_STRING([--enable-sndio], [support the sndio audio API [[default=yes]]]),
+[AS_HELP_STRING([--enable-sndio], [support the sndio audio API [default=yes]])],
                   , enable_sndio=yes)
     if test x$enable_audio = xyes -a x$enable_sndio = xyes; then
         AC_CHECK_HEADER(sndio.h, have_sndio_hdr=yes)
@@ -1190,7 +1223,7 @@ AS_HELP_STRING([--enable-sndio], [support the sndio audio API [[default=yes]]]),
 
         if test x$have_sndio = xyes; then
             AC_ARG_ENABLE(sndio-shared,
-AS_HELP_STRING([--enable-sndio-shared], [dynamically load sndio audio support [[default=yes]]]),
+[AS_HELP_STRING([--enable-sndio-shared], [dynamically load sndio audio support [default=yes]])],
                           , enable_sndio_shared=yes)
             sndio_lib=[`find_lib "libsndio.so.*" "$SNDIO_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`]
 
@@ -1220,7 +1253,7 @@ dnl Find FusionSound
 CheckFusionSound()
 {
     AC_ARG_ENABLE(fusionsound,
-AS_HELP_STRING([--enable-fusionsound], [use FusionSound audio driver [[default=no]]]),
+[AS_HELP_STRING([--enable-fusionsound], [use FusionSound audio driver [default=no]])],
                   , enable_fusionsound=no)
     if test x$enable_audio = xyes -a x$enable_fusionsound = xyes; then
         PKG_CHECK_MODULES([FUSIONSOUND], [fusionsound >= 1.1.1], fusionsound=yes, fusionsound=no)
@@ -1231,7 +1264,7 @@ AS_HELP_STRING([--enable-fusionsound], [use FusionSound audio driver [[default=n
             EXTRA_CFLAGS="$EXTRA_CFLAGS $FUSIONSOUND_CFLAGS"
 
             AC_ARG_ENABLE(fusionsound-shared,
-AS_HELP_STRING([--enable-fusionsound-shared], [dynamically load fusionsound audio support [[default=yes]]]),
+[AS_HELP_STRING([--enable-fusionsound-shared], [dynamically load fusionsound audio support [default=yes]])],
                           , enable_fusionsound_shared=yes)
             fusionsound_shared=no
             AC_MSG_CHECKING(for FusionSound dynamic loading support)
@@ -1259,12 +1292,13 @@ dnl rcg07142001 See if the user wants the disk writer audio driver...
 CheckDiskAudio()
 {
     AC_ARG_ENABLE(diskaudio,
-AS_HELP_STRING([--enable-diskaudio], [support the disk writer audio driver [[default=yes]]]),
+[AS_HELP_STRING([--enable-diskaudio], [support the disk writer audio driver [default=yes]])],
                   , enable_diskaudio=yes)
     if test x$enable_audio = xyes -a x$enable_diskaudio = xyes; then
         AC_DEFINE(SDL_AUDIO_DRIVER_DISK, 1, [ ])
         SOURCES="$SOURCES $srcdir/src/audio/disk/*.c"
         SUMMARY_audio="${SUMMARY_audio} disk"
+        have_audio=yes
     fi
 }
 
@@ -1272,12 +1306,13 @@ dnl rcg03142006 See if the user wants the dummy audio driver...
 CheckDummyAudio()
 {
     AC_ARG_ENABLE(dummyaudio,
-AS_HELP_STRING([--enable-dummyaudio], [support the dummy audio driver [[default=yes]]]),
+[AS_HELP_STRING([--enable-dummyaudio], [support the dummy audio driver [default=yes]])],
                   , enable_dummyaudio=yes)
     if test x$enable_audio = xyes -a x$enable_dummyaudio = xyes; then
         AC_DEFINE(SDL_AUDIO_DRIVER_DUMMY, 1, [ ])
         SOURCES="$SOURCES $srcdir/src/audio/dummy/*.c"
         SUMMARY_audio="${SUMMARY_audio} dummy"
+        have_audio=yes
     fi
 }
 
@@ -1285,7 +1320,7 @@ dnl See if libsamplerate is available
 CheckLibSampleRate()
 {
     AC_ARG_ENABLE(libsamplerate,
-AS_HELP_STRING([--enable-libsamplerate], [use libsamplerate for audio rate conversion [[default=yes]]]),
+[AS_HELP_STRING([--enable-libsamplerate], [use libsamplerate for audio rate conversion [default=yes]])],
                   , enable_libsamplerate=yes)
     if test x$enable_libsamplerate = xyes; then
         AC_CHECK_HEADER(samplerate.h,
@@ -1295,7 +1330,7 @@ AS_HELP_STRING([--enable-libsamplerate], [use libsamplerate for audio rate conve
             AC_DEFINE(HAVE_LIBSAMPLERATE_H, 1, [ ])
 
             AC_ARG_ENABLE(libsamplerate-shared,
-AS_HELP_STRING([--enable-libsamplerate-shared], [dynamically load libsamplerate [[default=yes]]]),
+[AS_HELP_STRING([--enable-libsamplerate-shared], [dynamically load libsamplerate [default=yes]])],
                           , enable_libsamplerate_shared=yes)
 
             samplerate_lib=[`find_lib "libsamplerate.so.*" "" | sed 's/.*\/\(.*\)/\1/; q'`]
@@ -1319,7 +1354,7 @@ dnl Check for ARM instruction support using gas syntax
 CheckARM()
 {
     AC_ARG_ENABLE(arm-simd,
-AS_HELP_STRING([--enable-arm-simd], [use SIMD assembly blitters on ARM [[default=no]]]),
+[AS_HELP_STRING([--enable-arm-simd], [use SIMD assembly blitters on ARM [default=no]])],
                   enable_arm_simd=$enableval, enable_arm_simd=no)
     if test x$enable_video = xyes -a x$enable_assembly = xyes -a x$enable_arm_simd = xyes; then
         save_CFLAGS="$CFLAGS"
@@ -1355,7 +1390,7 @@ dnl Check for ARM NEON instruction support using gas syntax
 CheckNEON()
 {
     AC_ARG_ENABLE(arm-neon,
-AS_HELP_STRING([--enable-arm-neon], [use NEON assembly blitters on ARM [[default=no]]]),
+[AS_HELP_STRING([--enable-arm-neon], [use NEON assembly blitters on ARM [default=no]])],
                   enable_arm_neon=$enableval, enable_arm_neon=no)
     if test x$enable_video = xyes -a x$enable_assembly = xyes -a x$enable_arm_neon = xyes; then
         save_CFLAGS="$CFLAGS"
@@ -1398,14 +1433,11 @@ CheckVisibilityHidden()
     visibility_CFLAGS="-fvisibility=hidden"
     save_CFLAGS="$CFLAGS"
     CFLAGS="$save_CFLAGS $visibility_CFLAGS -Werror"
-    AC_TRY_COMPILE([
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
     #if !defined(__GNUC__) || __GNUC__ < 4
     #error SDL only uses visibility attributes in GCC 4 or newer
     #endif
-    ],[
-    ],[
-    have_gcc_fvisibility=yes
-    ])
+    ]],[])], [have_gcc_fvisibility=yes],[])
     AC_MSG_RESULT($have_gcc_fvisibility)
     CFLAGS="$save_CFLAGS"
 
@@ -1423,12 +1455,9 @@ CheckNoStrictAliasing()
 
     save_CFLAGS="$CFLAGS"
     CFLAGS="$save_CFLAGS -fno-strict-aliasing"
-    AC_TRY_COMPILE([
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
     int x = 0;
-    ],[
-    ],[
-    have_gcc_no_strict_aliasing=yes
-    ])
+    ]],[])], [have_gcc_no_strict_aliasing=yes],[])
     AC_MSG_RESULT($have_gcc_no_strict_aliasing)
     CFLAGS="$save_CFLAGS"
 
@@ -1446,12 +1475,9 @@ CheckStackBoundary()
 
     save_CFLAGS="$CFLAGS"
     CFLAGS="$save_CFLAGS -mpreferred-stack-boundary=2"
-    AC_TRY_COMPILE([
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
     int x = 0;
-    ],[
-    ],[
-    have_gcc_preferred_stack_boundary=yes
-    ])
+    ]],[])], [have_gcc_preferred_stack_boundary=yes],[])
     AC_MSG_RESULT($have_gcc_preferred_stack_boundary)
     CFLAGS="$save_CFLAGS"
 
@@ -1470,12 +1496,9 @@ CheckDeclarationAfterStatement()
 
     save_CFLAGS="$CFLAGS"
     CFLAGS="$save_CFLAGS -Wdeclaration-after-statement -Werror=declaration-after-statement"
-    AC_TRY_COMPILE([
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
     int x = 0;
-    ],[
-    ],[
-    have_gcc_declaration_after_statement=yes
-    ])
+    ]],[])], [have_gcc_declaration_after_statement=yes],[])
     AC_MSG_RESULT($have_gcc_declaration_after_statement)
     CFLAGS="$save_CFLAGS"
 
@@ -1492,19 +1515,16 @@ CheckWarnAll()
 
     save_CFLAGS="$CFLAGS"
     CFLAGS="$save_CFLAGS -Wall"
-    AC_TRY_COMPILE([
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
     int x = 0;
-    ],[
-    ],[
-    have_gcc_Wall=yes
-    ])
+    ]],[])], [have_gcc_Wall=yes],[])
     AC_MSG_RESULT($have_gcc_Wall)
     CFLAGS="$save_CFLAGS"
 
     if test x$have_gcc_Wall = xyes; then
         EXTRA_CFLAGS="$EXTRA_CFLAGS -Wall"
 
-        dnl Haiku headers use multicharacter constants all over the place. Ignore these warnings when using -Wall.
+dnl Haiku headers use multicharacter constants all over the place. Ignore these warnings when using -Wall.
         AC_MSG_CHECKING(for necessary GCC -Wno-multichar option)
         need_gcc_Wno_multichar=no
         case "$host" in
@@ -1523,11 +1543,11 @@ dnl Check for Wayland
 CheckWayland()
 {
     AC_ARG_ENABLE(video-wayland,
-AS_HELP_STRING([--enable-video-wayland], [use Wayland video driver [[default=yes]]]),
+[AS_HELP_STRING([--enable-video-wayland], [use Wayland video driver [default=yes]])],
                   ,enable_video_wayland=yes)
 
     AC_ARG_ENABLE(video-wayland-qt-touch,
-AS_HELP_STRING([--enable-video-wayland-qt-touch], [QtWayland server support for Wayland video driver [[default=yes]]]),
+[AS_HELP_STRING([--enable-video-wayland-qt-touch], [QtWayland server support for Wayland video driver [default=yes]])],
                   ,enable_video_wayland_qt_touch=yes)
 
     if test x$enable_video = xyes -a x$enable_video_wayland = xyes; then
@@ -1535,10 +1555,13 @@ AS_HELP_STRING([--enable-video-wayland-qt-touch], [QtWayland server support for
         video_wayland=no
         if  test x$video_opengl_egl = xyes && \
             test x$video_opengles_v2 = xyes; then
-            if $PKG_CONFIG --exists wayland-client wayland-scanner wayland-egl wayland-cursor egl xkbcommon ; then
+            if $PKG_CONFIG --exists wayland-client wayland-scanner wayland-egl wayland-cursor egl 'xkbcommon >= 0.5.0'; then
                 WAYLAND_CFLAGS=`$PKG_CONFIG --cflags wayland-client wayland-egl wayland-cursor xkbcommon`
                 WAYLAND_LIBS=`$PKG_CONFIG --libs wayland-client wayland-egl wayland-cursor xkbcommon`
                 WAYLAND_SCANNER=`$PKG_CONFIG --variable=wayland_scanner wayland-scanner`
+                AS_IF([$PKG_CONFIG --exists 'wayland-scanner >= 1.15'],
+                      [WAYLAND_SCANNER_CODE_MODE=private-code],
+                      [WAYLAND_SCANNER_CODE_MODE=code])
                 video_wayland=yes
             fi
         fi
@@ -1554,16 +1577,16 @@ AS_HELP_STRING([--enable-video-wayland-qt-touch], [QtWayland server support for
             SOURCES="$SOURCES $WAYLAND_SOURCES"
             EXTRA_CFLAGS="$EXTRA_CFLAGS $WAYLAND_CFLAGS -I\$(gen)"
             AC_ARG_ENABLE(wayland-shared,
-AS_HELP_STRING([--enable-wayland-shared], [dynamically load Wayland support [[default=maybe]]]),
+[AS_HELP_STRING([--enable-wayland-shared], [dynamically load Wayland support [default=maybe]])],
                           , enable_wayland_shared=maybe)
 
-            dnl FIXME: Do BSD and OS X need special cases?
+dnl FIXME: Do BSD and OS X need special cases?
             case "$host" in
                 *)
                     wayland_client_lib=[`find_lib "libwayland-client.so.*" "$WAYLAND_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`]
                     wayland_egl_lib=[`find_lib "libwayland-egl.so.*" "$WAYLAND_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`]
                     if test x$wayland_egl_lib = x; then
-                        dnl This works in Ubuntu 13.10, maybe others
+                        # This works in Ubuntu 13.10, maybe others
                         wayland_egl_lib=[`find_lib "mesa-egl/libwayland-egl.so.*" "$WAYLAND_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`]
                     fi
                     wayland_cursor_lib=[`find_lib "libwayland-cursor.so.*" "$WAYLAND_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`]
@@ -1600,6 +1623,45 @@ AS_HELP_STRING([--enable-wayland-shared], [dynamically load Wayland support [[de
                 SUMMARY_video="${SUMMARY_video} wayland"
             fi
             have_video=yes
+
+dnl See if libdecor is available
+            AC_ARG_ENABLE(libdecor,
+[AS_HELP_STRING([--enable-libdecor], [use libdecor for Wayland client-side decorations [default=yes]])],
+                          , enable_libdecor=yes)
+            if test x$enable_libdecor = xyes; then
+                AC_MSG_CHECKING(for libdecor support)
+                AS_IF([$PKG_CONFIG --exists libdecor-0],
+                      [video_libdecor=yes],
+                      [video_libdecor=no])
+                AC_MSG_RESULT($video_libdecor)
+                if test x$video_libdecor = xyes; then
+                    EXTRA_CFLAGS="$EXTRA_CFLAGS `$PKG_CONFIG --cflags libdecor-0`"
+                    AC_DEFINE(HAVE_LIBDECOR_H, 1, [ ])
+
+                    AC_ARG_ENABLE(libdecor-shared,
+[AS_HELP_STRING([--enable-libdecor-shared], [dynamically load libdecor [default=yes]])],
+                         , enable_libdecor_shared=yes)
+
+                    if test x$enable_wayland_shared != xyes; then
+                       enable_libdecor_shared=no
+                    fi
+
+                    decor_lib=[`find_lib "libdecor-0.so.*" "" | sed 's/.*\/\(.*\)/\1/; q'`]
+
+                    if test x$have_loadso != xyes && \
+                       test x$enable_libdecor_shared = xyes; then
+                        AC_MSG_WARN([You must have SDL_LoadObject() support for dynamic libdecor loading])
+                    fi
+
+                    if test x$have_loadso = xyes && \
+                       test x$enable_libdecor_shared = xyes && test x$decor_lib != x; then
+                        echo "-- dynamic libdecor -> $decor_lib"
+                        AC_DEFINE_UNQUOTED(SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_LIBDECOR, "$decor_lib", [ ])
+                    else
+                        EXTRA_LDFLAGS="$EXTRA_LDFLAGS `$PKG_CONFIG --libs libdecor-0`"
+                    fi
+                fi
+            fi
         fi
     fi
 }
@@ -1607,12 +1669,11 @@ AS_HELP_STRING([--enable-wayland-shared], [dynamically load Wayland support [[de
 dnl Check for Native Client stuff
 CheckNativeClient()
 {
-        AC_TRY_COMPILE([
+        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
           #if !defined(__native_client__)
           #error "NO NACL"
           #endif
-        ],[
-        ],[
+        ]],[])], [
         AC_DEFINE(SDL_VIDEO_DRIVER_NACL, 1, [ ])
         AC_DEFINE(SDL_AUDIO_DRIVER_NACL, 1, [ ])
         AC_DEFINE(HAVE_POW, 1, [ ])
@@ -1625,15 +1686,17 @@ CheckNativeClient()
         SDLMAIN_SOURCES="$srcdir/src/main/nacl/*.c"
         SOURCES="$SOURCES $srcdir/src/audio/nacl/*.c"
         SUMMARY_audio="${SUMMARY_audio} nacl"
+        have_audio=yes
         SOURCES="$SOURCES $srcdir/src/video/nacl/*.c"
         SUMMARY_video="${SUMMARY_video} nacl opengles2"
-        ])
+        have_video=yes
+        ],[])
 }
 
 CheckRPI()
 {
     AC_ARG_ENABLE(video-rpi,
-AS_HELP_STRING([--enable-video-rpi], [use Raspberry Pi video driver [[default=yes]]]),
+[AS_HELP_STRING([--enable-video-rpi], [use Raspberry Pi 2/3 video driver [default=yes]])],
                   , enable_video_rpi=yes)
     if test x$enable_video = xyes -a x$enable_video_rpi = xyes; then
         PKG_CHECK_MODULES([RPI], [bcm_host brcmegl], video_rpi=yes, video_rpi=no)
@@ -1654,16 +1717,15 @@ AS_HELP_STRING([--enable-video-rpi], [use Raspberry Pi video driver [[default=ye
         # Add the Raspberry Pi compiler flags and libraries
         CFLAGS="$CFLAGS $RPI_CFLAGS"; LIBS="$LIBS $RPI_LIBS"
 
-        AC_MSG_CHECKING(for Raspberry Pi)
+        AC_MSG_CHECKING(for Raspberry Pi 2/3)
         have_video_rpi=no
-        AC_TRY_LINK([
+        AC_LINK_IFELSE([AC_LANG_PROGRAM([[
           #include <bcm_host.h>
-        ],[
+          #include <EGL/eglplatform.h>
+        ]], [[
+          EGL_DISPMANX_WINDOW_T window;
           bcm_host_init();
-        ],[
-        have_video_rpi=yes
-        ],[
-        ])
+        ]])], [have_video_rpi=yes],[])
         AC_MSG_RESULT($have_video_rpi)
 
         # Restore the compiler flags and libraries
@@ -1677,6 +1739,7 @@ AS_HELP_STRING([--enable-video-rpi], [use Raspberry Pi video driver [[default=ye
             SOURCES="$SOURCES $srcdir/src/video/raspberry/*.c"
             AC_DEFINE(SDL_VIDEO_DRIVER_RPI, 1, [ ])
             SUMMARY_video="${SUMMARY_video} rpi"
+            have_video=yes
         fi
     fi
 }
@@ -1685,7 +1748,7 @@ dnl Find the X11 include and library directories
 CheckX11()
 {
     AC_ARG_ENABLE(video-x11,
-AS_HELP_STRING([--enable-video-x11], [use X11 video driver [[default=yes]]]),
+[AS_HELP_STRING([--enable-video-x11], [use X11 video driver [default=yes]])],
                   , enable_video_x11=yes)
     if test x$enable_video = xyes -a x$enable_video_x11 = xyes; then
         case "$host" in
@@ -1704,7 +1767,7 @@ AS_HELP_STRING([--enable-video-x11], [use X11 video driver [[default=yes]]]),
         AC_PATH_XTRA
         if test x$have_x = xyes; then
             AC_ARG_ENABLE(x11-shared,
-AS_HELP_STRING([--enable-x11-shared], [dynamically load X11 support [[default=maybe]]]),
+[AS_HELP_STRING([--enable-x11-shared], [dynamically load X11 support [default=maybe]])],
                           , enable_x11_shared=maybe)
 
             case "$host" in
@@ -1715,6 +1778,7 @@ AS_HELP_STRING([--enable-x11-shared], [dynamically load X11 support [[default=ma
                     xcursor_lib='/opt/X11/lib/libXcursor.1.dylib'
                     xinerama_lib='/opt/X11/lib/libXinerama.1.dylib'
                     xinput_lib='/opt/X11/lib/libXi.6.dylib'
+                    xfixes_lib='/opt/X11/lib/libXfixes.3.dylib'
                     xrandr_lib='/opt/X11/lib/libXrandr.2.dylib'
                     xrender_lib='/opt/X11/lib/libXrender.1.dylib'
                     xss_lib='/opt/X11/lib/libXss.1.dylib'
@@ -1726,6 +1790,7 @@ AS_HELP_STRING([--enable-x11-shared], [dynamically load X11 support [[default=ma
                     xcursor_lib='libXcursor.so'
                     xinerama_lib='libXinerama.so'
                     xinput_lib='libXi.so'
+                    xfixes_lib='libXfixes.so'
                     xrandr_lib='libXrandr.so'
                     xrender_lib='libXrender.so'
                     xss_lib='libXss.so'
@@ -1737,6 +1802,7 @@ AS_HELP_STRING([--enable-x11-shared], [dynamically load X11 support [[default=ma
                     xcursor_lib=[`find_lib "libXcursor.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`]
                     xinerama_lib=[`find_lib "libXinerama.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`]
                     xinput_lib=[`find_lib "libXi.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`]
+                    xfixes_lib=[`find_lib "libXfixes.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`]
                     xrandr_lib=[`find_lib "libXrandr.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`]
                     xrender_lib=[`find_lib "libXrender.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`]
                     xss_lib=[`find_lib "libXss.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`]
@@ -1791,43 +1857,27 @@ AS_HELP_STRING([--enable-x11-shared], [dynamically load X11 support [[default=ma
             fi
             have_video=yes
 
-            AC_MSG_CHECKING(for const parameter to XextAddDisplay)
-            have_const_param_XextAddDisplay=no
-            AC_TRY_COMPILE([
-              #include <X11/Xlib.h>
-              #include <X11/Xproto.h>
-              #include <X11/extensions/Xext.h>
-              #include <X11/extensions/extutil.h>
-              extern XExtDisplayInfo* XextAddDisplay(XExtensionInfo* a,Display* b,_Xconst char* c,XExtensionHooks* d,int e,XPointer f);
-            ],[
-            ],[
-            have_const_param_XextAddDisplay=yes
-            AC_DEFINE([SDL_VIDEO_DRIVER_X11_CONST_PARAM_XEXTADDDISPLAY], 1, [ ])
-            ])
-            AC_MSG_RESULT($have_const_param_XextAddDisplay)
-
-            dnl AC_CHECK_LIB(X11, XGetEventData, AC_DEFINE(SDL_VIDEO_DRIVER_X11_SUPPORTS_GENERIC_EVENTS, 1, [Have XGenericEvent]))
             AC_MSG_CHECKING([for XGenericEvent])
             have_XGenericEvent=no
-            AC_TRY_COMPILE([
+            AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
                 #include <X11/Xlib.h>
-            ],[
+            ]], [[
 Display *display;
 XEvent event;
 XGenericEventCookie *cookie = &event.xcookie;
 XNextEvent(display, &event);
 XGetEventData(display, cookie);
 XFreeEventData(display, cookie);
-            ],[
+            ]])], [
                 have_XGenericEvent=yes
                 AC_DEFINE([SDL_VIDEO_DRIVER_X11_SUPPORTS_GENERIC_EVENTS], 1, [ ])
-            ])
+            ],[])
             AC_MSG_RESULT($have_XGenericEvent)
 
             AC_CHECK_LIB(X11, XkbKeycodeToKeysym, AC_DEFINE(SDL_VIDEO_DRIVER_X11_HAS_XKBKEYCODETOKEYSYM, 1, [Have XkbKeycodeToKeysym]))
 
             AC_ARG_ENABLE(video-x11-xcursor,
-AS_HELP_STRING([--enable-video-x11-xcursor], [enable X11 Xcursor support [[default=yes]]]),
+[AS_HELP_STRING([--enable-video-x11-xcursor], [enable X11 Xcursor support [default=yes]])],
                             , enable_video_x11_xcursor=yes)
             if test x$enable_video_x11_xcursor = xyes; then
                 definitely_enable_video_x11_xcursor=no
@@ -1855,7 +1905,7 @@ AS_HELP_STRING([--enable-video-x11-xcursor], [enable X11 Xcursor support [[defau
                 SUMMARY_video_x11="${SUMMARY_video_x11} xcursor"
             fi
             AC_ARG_ENABLE(video-x11-xdbe,
-AS_HELP_STRING([--enable-video-x11-xdbe], [enable X11 Xdbe support [[default=yes]]]),
+[AS_HELP_STRING([--enable-video-x11-xdbe], [enable X11 Xdbe support [default=yes]])],
                             , enable_video_x11_xdbe=yes)
             if test x$enable_video_x11_xdbe = xyes; then
                 AC_CHECK_HEADER(X11/extensions/Xdbe.h,
@@ -1869,7 +1919,7 @@ AS_HELP_STRING([--enable-video-x11-xdbe], [enable X11 Xdbe support [[default=yes
                 fi
             fi
             AC_ARG_ENABLE(video-x11-xinerama,
-AS_HELP_STRING([--enable-video-x11-xinerama], [enable X11 Xinerama support [[default=yes]]]),
+[AS_HELP_STRING([--enable-video-x11-xinerama], [enable X11 Xinerama support [default=yes]])],
                             , enable_video_x11_xinerama=yes)
             if test x$enable_video_x11_xinerama = xyes; then
                 definitely_enable_video_x11_xinerama=no
@@ -1897,7 +1947,7 @@ AS_HELP_STRING([--enable-video-x11-xinerama], [enable X11 Xinerama support [[def
                 SUMMARY_video_x11="${SUMMARY_video_x11} xinerama"
             fi
             AC_ARG_ENABLE(video-x11-xinput,
-AS_HELP_STRING([--enable-video-x11-xinput], [enable X11 XInput extension for manymouse, tablets, etc [[default=yes]]]),
+[AS_HELP_STRING([--enable-video-x11-xinput], [enable X11 XInput extension for manymouse, tablets, etc [default=yes]])],
                             , enable_video_x11_xinput=yes)
             if test x$enable_video_x11_xinput = xyes; then
                 definitely_enable_video_x11_xinput=no
@@ -1925,35 +1975,67 @@ AS_HELP_STRING([--enable-video-x11-xinput], [enable X11 XInput extension for man
                 AC_DEFINE(SDL_VIDEO_DRIVER_X11_XINPUT2, 1, [ ])
                 AC_MSG_CHECKING(for xinput2 multitouch)
                 have_xinput2_multitouch=no
-                AC_TRY_COMPILE([
+                AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
                     #include <X11/Xlib.h>
                     #include <X11/Xproto.h>
                     #include <X11/extensions/XInput2.h>
-                    ],[
+                    ]], [[
 int event_type = XI_TouchBegin;
 XITouchClassInfo *t;
-                    ],[
+                    ]])], [
                     have_xinput2_multitouch=yes
                     AC_DEFINE([SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH], 1, [ ])
                     SUMMARY_video_x11="${SUMMARY_video_x11} xinput2_multitouch"
-                    ])
+                    ],[])
                 AC_MSG_RESULT($have_xinput2_multitouch)
             fi
+            AC_ARG_ENABLE(video-x11-xfixes,
+[AS_HELP_STRING([--enable-video-x11-xfixes], [enable X11 Xfixes support [default=yes]])],
+                            , enable_video_x11_xfixes=yes)
+            if test x$enable_video_x11_xfixes = xyes; then
+                definitely_enable_video_x11_xfixes=no
+                # check along with XInput2.h because we use Xfixes with XIBarrierReleasePointer
+                AC_MSG_CHECKING(for X11/extensions/Xfixes.h)
+                AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+                    #include <X11/Xlib.h>
+                    #include <X11/Xproto.h>
+                    #include <X11/extensions/XInput2.h>
+                    #include <X11/extensions/Xfixes.h>]],
+                    [BarrierEventID b;])],
+                    [have_xfixes_h_hdr=yes],
+                    [have_xfixes_h_hdr=no])
+                AC_MSG_RESULT($have_xfixes_h_hdr)
+                if test x$have_xfixes_h_hdr = xyes; then
+                    if test x$enable_x11_shared = xyes && test x$xfixes_lib != x ; then
+                        echo "-- dynamic libXfixes -> $xfixes_lib"
+                        AC_DEFINE_UNQUOTED(SDL_VIDEO_DRIVER_X11_DYNAMIC_XFIXES, "$xfixes_lib", [ ])
+                        definitely_enable_video_x11_xfixes=yes
+                    else
+                        AC_CHECK_LIB(Xfixes, XFixesCreatePointerBarrier, have_xfixes_lib=yes)
+                        if test x$have_xfixes_lib = xyes ; then
+                            EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lXfixes"
+                            definitely_enable_video_x11_xfixes=yes
+                        fi
+                    fi
+                fi
+            fi
+            if test x$definitely_enable_video_x11_xfixes = xyes; then
+                AC_DEFINE(SDL_VIDEO_DRIVER_X11_XFIXES, 1, [ ])
+                SUMMARY_video_x11="${SUMMARY_video_x11} xfixes"
+            fi
             AC_ARG_ENABLE(video-x11-xrandr,
-AS_HELP_STRING([--enable-video-x11-xrandr], [enable X11 Xrandr extension for fullscreen [[default=yes]]]),
+[AS_HELP_STRING([--enable-video-x11-xrandr], [enable X11 Xrandr extension for fullscreen [default=yes]])],
                             , enable_video_x11_xrandr=yes)
             if test x$enable_video_x11_xrandr = xyes; then
-                dnl XRRScreenResources is only present in Xrandr >= 1.2, we use that as a test.
+dnl             XRRScreenResources is only present in Xrandr >= 1.2, we use that as a test.
                 definitely_enable_video_x11_xrandr=no
                 have_xrandr_h_hdr=no
-                AC_TRY_COMPILE([
+                AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
                 #include <X11/Xlib.h>
                 #include <X11/extensions/Xrandr.h>
-                ],[
+                ]], [[
                 XRRScreenResources *res = NULL;
-                ],[
-                have_xrandr_h_hdr=yes
-                ])
+                ]])], [have_xrandr_h_hdr=yes],[])
                 if test x$have_xrandr_h_hdr = xyes; then
                     if test x$enable_x11_shared = xyes && test x$xrandr_lib != x ; then
                         echo "-- dynamic libXrandr -> $xrandr_lib"
@@ -1973,7 +2055,7 @@ AS_HELP_STRING([--enable-video-x11-xrandr], [enable X11 Xrandr extension for ful
                 SUMMARY_video_x11="${SUMMARY_video_x11} xrandr"
             fi
             AC_ARG_ENABLE(video-x11-scrnsaver,
-AS_HELP_STRING([--enable-video-x11-scrnsaver], [enable X11 screensaver extension [[default=yes]]]),
+[AS_HELP_STRING([--enable-video-x11-scrnsaver], [enable X11 screensaver extension [default=yes]])],
                             , enable_video_x11_scrnsaver=yes)
             if test x$enable_video_x11_scrnsaver = xyes; then
                 AC_CHECK_HEADER(X11/extensions/scrnsaver.h,
@@ -2000,7 +2082,7 @@ AS_HELP_STRING([--enable-video-x11-scrnsaver], [enable X11 screensaver extension
                 SUMMARY_video_x11="${SUMMARY_video_x11} xscrnsaver"
             fi
             AC_ARG_ENABLE(video-x11-xshape,
-AS_HELP_STRING([--enable-video-x11-xshape], [enable X11 XShape support [[default=yes]]]),
+[AS_HELP_STRING([--enable-video-x11-xshape], [enable X11 XShape support [default=yes]])],
                             , enable_video_x11_xshape=yes)
             if test x$enable_video_x11_xshape = xyes; then
                 AC_CHECK_HEADER(X11/extensions/shape.h,
@@ -2014,7 +2096,7 @@ AS_HELP_STRING([--enable-video-x11-xshape], [enable X11 XShape support [[default
                 fi
             fi
             AC_ARG_ENABLE(video-x11-vm,
-AS_HELP_STRING([--enable-video-x11-vm], [use X11 VM extension for fullscreen [[default=yes]]]),
+[AS_HELP_STRING([--enable-video-x11-vm], [use X11 VM extension for fullscreen [default=yes]])],
                             , enable_video_x11_vm=yes)
             if test x$enable_video_x11_vm = xyes; then
                 definitely_enable_video_x11_vm=no
@@ -2042,7 +2124,8 @@ AS_HELP_STRING([--enable-video-x11-vm], [use X11 VM extension for fullscreen [[d
                 SUMMARY_video_x11="${SUMMARY_video_x11} xvidmode"
             fi
         fi
-    else
+    fi
+    if test x$have_x != xyes; then
         # Prevent Mesa from including X11 headers
         EXTRA_CFLAGS="$EXTRA_CFLAGS -DMESA_EGL_NO_X11_HEADERS -DEGL_NO_X11"
     fi
@@ -2052,31 +2135,25 @@ dnl Set up the Vivante video driver if enabled
 CheckVivanteVideo()
 {
     AC_ARG_ENABLE(video-vivante,
-AS_HELP_STRING([--enable-video-vivante], [use Vivante EGL video driver [[default=yes]]]),
+[AS_HELP_STRING([--enable-video-vivante], [use Vivante EGL video driver [default=yes]])],
                   , enable_video_vivante=yes)
     if test x$enable_video = xyes -a x$enable_video_vivante = xyes; then
         AC_MSG_CHECKING(for Vivante VDK API)
         have_vivante_vdk=no
-        AC_TRY_COMPILE([
+        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
           #define LINUX
           #define EGL_API_FB
           #include <gc_vdk.h>
-        ],[
-        ],[
-        have_vivante_vdk=yes
-        ])
+        ]],[])], [have_vivante_vdk=yes],[])
         AC_MSG_RESULT($have_vivante_vdk)
 
         AC_MSG_CHECKING(for Vivante FB API)
         have_vivante_egl=no
-        AC_TRY_COMPILE([
+        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
           #define LINUX
           #define EGL_API_FB
           #include <EGL/eglvivante.h>
-        ],[
-        ],[
-        have_vivante_egl=yes
-        ])
+        ]],[])], [have_vivante_egl=yes],[])
         AC_MSG_RESULT($have_vivante_egl)
 
         if test x$have_vivante_vdk = xyes -o x$have_vivante_egl = xyes; then
@@ -2108,20 +2185,17 @@ dnl Set up the Cocoa video driver for Mac OS X (but not Darwin)
 CheckCOCOA()
 {
     AC_ARG_ENABLE(video-cocoa,
-AS_HELP_STRING([--enable-video-cocoa], [use Cocoa video driver [[default=yes]]]),
+[AS_HELP_STRING([--enable-video-cocoa], [use Cocoa video driver [default=yes]])],
                   , enable_video_cocoa=yes)
     if test x$enable_video = xyes -a x$enable_video_cocoa = xyes; then
         save_CFLAGS="$CFLAGS"
-        dnl Work around that we don't have Objective-C support in autoconf
+dnl     Work around that we don't have Objective-C support in autoconf
         CFLAGS="$CFLAGS -x objective-c"
         AC_MSG_CHECKING(for Cocoa framework)
         have_cocoa=no
-        AC_TRY_COMPILE([
+        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
           #import <Cocoa/Cocoa.h>
-        ],[
-        ],[
-        have_cocoa=yes
-        ])
+        ]],[])], [have_cocoa=yes],[])
         AC_MSG_RESULT($have_cocoa)
         CFLAGS="$save_CFLAGS"
         if test x$have_cocoa = xyes; then
@@ -2136,18 +2210,18 @@ AS_HELP_STRING([--enable-video-cocoa], [use Cocoa video driver [[default=yes]]])
 CheckMETAL()
 {
     AC_ARG_ENABLE(video-metal,
-AS_HELP_STRING([--enable-video-metal], [include Metal support [[default=yes]]]),
+[AS_HELP_STRING([--enable-video-metal], [include Metal support [default=yes]])],
               , enable_video_metal=yes)
     AC_ARG_ENABLE(render-metal,
-AS_HELP_STRING([--enable-render-metal], [enable the Metal render driver [[default=yes]]]),
+[AS_HELP_STRING([--enable-render-metal], [enable the Metal render driver [default=yes]])],
                                 , enable_render_metal=yes)
     if test x$enable_video = xyes -a x$enable_video_metal = xyes; then
         save_CFLAGS="$CFLAGS"
-        dnl Work around that we don't have Objective-C support in autoconf
+dnl     Work around that we don't have Objective-C support in autoconf
         CFLAGS="$CFLAGS -x objective-c"
         AC_MSG_CHECKING(for Metal framework)
         have_metal=no
-        AC_TRY_COMPILE([
+        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
           #import <Cocoa/Cocoa.h>
           #import <Metal/Metal.h>
           #import <QuartzCore/CAMetalLayer.h>
@@ -2155,10 +2229,7 @@ AS_HELP_STRING([--enable-render-metal], [enable the Metal render driver [[defaul
           #if TARGET_CPU_X86
           #error Metal doesn't work on this configuration
           #endif
-        ],[
-        ],[
-        have_metal=yes
-        ])
+        ]],[])], [have_metal=yes],[])
         CFLAGS="$save_CFLAGS"
         AC_MSG_RESULT($have_metal)
         if test x$have_metal = xyes; then
@@ -2179,7 +2250,7 @@ dnl Find DirectFB
 CheckDirectFB()
 {
     AC_ARG_ENABLE(video-directfb,
-AS_HELP_STRING([--enable-video-directfb], [use DirectFB video driver [[default=no]]]),
+[AS_HELP_STRING([--enable-video-directfb], [use DirectFB video driver [default=no]])],
                   , enable_video_directfb=no)
     if test x$enable_video = xyes -a x$enable_video_directfb = xyes; then
         PKG_CHECK_MODULES([DIRECTFB], [directfb >= 1.0.0], video_directfb=yes, video_directfb=no)
@@ -2195,7 +2266,7 @@ AS_HELP_STRING([--enable-video-directfb], [use DirectFB video driver [[default=n
 
         if test x$video_directfb = xyes; then
             AC_ARG_ENABLE(directfb-shared,
-AS_HELP_STRING([--enable-directfb-shared], [dynamically load directfb support [[default=yes]]]),
+[AS_HELP_STRING([--enable-directfb-shared], [dynamically load directfb support [default=yes]])],
                               , enable_directfb_shared=yes)
 
             AC_DEFINE(SDL_VIDEO_DRIVER_DIRECTFB, 1, [ ])
@@ -2203,11 +2274,8 @@ AS_HELP_STRING([--enable-directfb-shared], [dynamically load directfb support [[
             SOURCES="$SOURCES $srcdir/src/video/directfb/*.c"
             EXTRA_CFLAGS="$EXTRA_CFLAGS $DIRECTFB_CFLAGS"
 
-            AC_MSG_CHECKING(for directfb dynamic loading support)
             directfb_shared=no
-            directfb_lib=[`find_lib "libdirectfb*.so.*" "$DIRECTFB_LIBS"`]
-            # | sed 's/.*\/\(.*\)/\1/; q'`]
-AC_MSG_WARN("directfb $directfb_lib")
+            directfb_lib=[`find_lib "libdirectfb*.so.*" "$DIRECTFB_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`]
             if test x$have_loadso != xyes && \
                test x$enable_directfb_shared = xyes; then
                 AC_MSG_WARN([You must have SDL_LoadObject() support for dynamic directfb loading])
@@ -2215,14 +2283,13 @@ AC_MSG_WARN("directfb $directfb_lib")
             if test x$have_loadso = xyes && \
                test x$enable_directfb_shared = xyes && test x$directfb_lib != x; then
                 directfb_shared=yes
-                echo "-- $directfb_lib_spec -> $directfb_lib"
+                echo "-- dynamic libdirectfb -> $directfb_lib"
                 AC_DEFINE_UNQUOTED(SDL_VIDEO_DRIVER_DIRECTFB_DYNAMIC, "$directfb_lib", [ ])
                 SUMMARY_video="${SUMMARY_video} directfb(dynamic)"
             else
                 EXTRA_LDFLAGS="$EXTRA_LDFLAGS $DIRECTFB_LIBS"
                 SUMMARY_video="${SUMMARY_video} directfb"
             fi
-            AC_MSG_RESULT($directfb_shared)
             SDL_CFLAGS="$SDL_CFLAGS $DIRECTFB_CFLAGS"
             have_video=yes
         fi
@@ -2233,10 +2300,13 @@ dnl Find KMSDRM
 CheckKMSDRM()
 {
     AC_ARG_ENABLE(video-kmsdrm,
-AS_HELP_STRING([--enable-video-kmsdrm], [use KMSDRM video driver [[default=no]]]),
-                  , enable_video_kmsdrm=no)
+[AS_HELP_STRING([--enable-video-kmsdrm], [use KMSDRM video driver [default=yes]])],
+                  , enable_video_kmsdrm=yes)
+
+    if  test x$enable_video = xyes && \
+        test x$enable_video_kmsdrm = xyes && \
+        test x$video_opengl_egl = xyes; then
 
-    if test x$enable_video = xyes -a x$enable_video_kmsdrm = xyes; then
         video_kmsdrm=no
 
         PKG_CHECK_MODULES([LIBDRM], [libdrm >= 1.4.82], libdrm_avail=yes, libdrm_avail=no)
@@ -2248,18 +2318,17 @@ AS_HELP_STRING([--enable-video-kmsdrm], [use KMSDRM video driver [[default=no]]]
 
         if test x$video_kmsdrm = xyes; then
             AC_ARG_ENABLE(kmsdrm-shared,
-AS_HELP_STRING([--enable-kmsdrm-shared], [dynamically load kmsdrm support [[default=yes]]]),
+[AS_HELP_STRING([--enable-kmsdrm-shared], [dynamically load kmsdrm support [default=yes]])],
                 , enable_kmsdrm_shared=yes)
 
             AC_DEFINE(SDL_VIDEO_DRIVER_KMSDRM, 1, [ ])
             SOURCES="$SOURCES $srcdir/src/video/kmsdrm/*.c"
-            SOURCES="$SOURCES $srcdir/src/video/kmsdrm_legacy/*.c"
             EXTRA_CFLAGS="$EXTRA_CFLAGS $LIBDRM_CFLAGS $LIBGBM_CFLAGS"
 
             AC_MSG_CHECKING(for kmsdrm dynamic loading support)
             kmsdrm_shared=no
-            drm_lib=[`find_lib "libdrm.so.*" "$DRM_LIBS"`]
-            gbm_lib=[`find_lib "libgbm.so.*" "$DRM_LIBS"`]
+            drm_lib=[`find_lib "libdrm.so.*" "$LIBDRM_LIBS"`]
+            gbm_lib=[`find_lib "libgbm.so.*" "$LIBGBM_LIBS"`]
             if test x$have_loadso != xyes && \
                test x$enable_kmsdrm_shared = xyes; then
                 AC_MSG_WARN([You must have SDL_LoadObject() support for dynamic kmsdrm loading])
@@ -2276,6 +2345,10 @@ AS_HELP_STRING([--enable-kmsdrm-shared], [dynamically load kmsdrm support [[defa
                 SUMMARY_video="${SUMMARY_video} kmsdrm"
             fi
             AC_MSG_RESULT($kmsdrm_shared)
+            if test x$kmsdrm_shared = xyes; then
+                echo "-- dynamic libdrm -> $drm_lib"
+                echo "-- dynamic libgbm -> $gbm_lib"
+            fi
             have_video=yes
         fi
     fi
@@ -2285,7 +2358,7 @@ dnl rcg04172001 Set up the Null video driver.
 CheckDummyVideo()
 {
     AC_ARG_ENABLE(video-dummy,
-AS_HELP_STRING([--enable-video-dummy], [use dummy video driver [[default=yes]]]),
+[AS_HELP_STRING([--enable-video-dummy], [use dummy video driver [default=yes]])],
                   , enable_video_dummy=yes)
     if test x$enable_video_dummy = xyes; then
         AC_DEFINE(SDL_VIDEO_DRIVER_DUMMY, 1, [ ])
@@ -2295,6 +2368,19 @@ AS_HELP_STRING([--enable-video-dummy], [use dummy video driver [[default=yes]]])
     fi
 }
 
+CheckOffscreenVideo()
+{
+    AC_ARG_ENABLE(video-offscreen,
+[AS_HELP_STRING([--enable-video-offscreen], [use offscreen video driver [default=no]])],
+                  , enable_video_offscreen=no)
+    if test x$enable_video_offscreen = xyes; then
+        AC_DEFINE(SDL_VIDEO_DRIVER_OFFSCREEN, 1, [ ])
+        SOURCES="$SOURCES $srcdir/src/video/offscreen/*.c"
+        have_video=yes
+        SUMMARY_video="${SUMMARY_video} offscreen"
+    fi
+}
+
 dnl Set up the QNX video driver if enabled
 CheckQNXVideo()
 {
@@ -2321,75 +2407,88 @@ CheckQNXAudio()
 
 dnl Check to see if OpenGL support is desired
 AC_ARG_ENABLE(video-opengl,
-AS_HELP_STRING([--enable-video-opengl], [include OpenGL support [[default=yes]]]),
+[AS_HELP_STRING([--enable-video-opengl], [include OpenGL support [default=yes]])],
               , enable_video_opengl=yes)
 
-dnl Find OpenGL
-CheckOpenGLX11()
+dnl Find GLX
+CheckGLX()
 {
     if test x$enable_video = xyes -a x$enable_video_opengl = xyes; then
-        AC_MSG_CHECKING(for OpenGL (GLX) support)
-        video_opengl=no
-        AC_TRY_COMPILE([
-         #include <GL/gl.h>
+        AC_MSG_CHECKING(for GLX support)
+        video_opengl_glx=no
+        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
          #include <GL/glx.h>
-        ],[
-        ],[
-        video_opengl=yes
-        ])
-        AC_MSG_RESULT($video_opengl)
-        if test x$video_opengl = xyes; then
+        ]],[])], [video_opengl_glx=yes],[])
+        AC_MSG_RESULT($video_opengl_glx)
+        if test x$video_opengl_glx = xyes; then
             AC_DEFINE(SDL_VIDEO_OPENGL, 1, [ ])
             AC_DEFINE(SDL_VIDEO_OPENGL_GLX, 1, [ ])
-            AC_DEFINE(SDL_VIDEO_RENDER_OGL, 1, [ ])
-            SUMMARY_video="${SUMMARY_video} opengl"
         fi
     fi
 }
 
 dnl Check to see if OpenGL ES support is desired
 AC_ARG_ENABLE(video-opengles,
-AS_HELP_STRING([--enable-video-opengles], [include OpenGL ES support [[default=yes]]]),
+[AS_HELP_STRING([--enable-video-opengles], [include OpenGL ES support [default=yes]])],
               , enable_video_opengles=yes)
 AC_ARG_ENABLE(video-opengles1,
-AS_HELP_STRING([--enable-video-opengles1], [include OpenGL ES 1.1 support [[default=yes]]]),
+[AS_HELP_STRING([--enable-video-opengles1], [include OpenGL ES 1.1 support [default=yes]])],
               , enable_video_opengles1=yes)
 AC_ARG_ENABLE(video-opengles2,
-AS_HELP_STRING([--enable-video-opengles2], [include OpenGL ES 2.0 support [[default=yes]]]),
+[AS_HELP_STRING([--enable-video-opengles2], [include OpenGL ES 2.0 support [default=yes]])],
               , enable_video_opengles2=yes)
 
-dnl Find OpenGL ES
-CheckOpenGLESX11()
+dnl Find EGL
+CheckEGL()
 {
-    if test x$enable_video = xyes -a x$enable_video_opengles = xyes; then
+    if test x$enable_video = xyes -a x$enable_video_opengl = xyes || test x$enable_video = xyes -a x$enable_video_opengles = xyes; then
         AC_MSG_CHECKING(for EGL support)
         video_opengl_egl=no
-        AC_TRY_COMPILE([
+        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
           #define LINUX
           #define EGL_API_FB
           #define MESA_EGL_NO_X11_HEADERS
           #define EGL_NO_X11
           #include <EGL/egl.h>
           #include <EGL/eglext.h>
-        ],[
-        ],[
-        video_opengl_egl=yes
-        ])
+        ]],[])], [video_opengl_egl=yes],[])
         AC_MSG_RESULT($video_opengl_egl)
         if test x$video_opengl_egl = xyes; then
             AC_DEFINE(SDL_VIDEO_OPENGL_EGL, 1, [ ])
         fi
+    fi
+}
 
+dnl Find OpenGL
+CheckOpenGL()
+{
+    if test x$enable_video = xyes -a x$enable_video_opengl = xyes; then
+        AC_MSG_CHECKING(for OpenGL headers)
+        video_opengl=no
+        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+         #include <GL/gl.h>
+         #include <GL/glext.h>
+        ]],[])], [video_opengl=yes],[])
+        AC_MSG_RESULT($video_opengl)
+        if test x$video_opengl = xyes; then 
+            AC_DEFINE(SDL_VIDEO_OPENGL, 1, [ ])
+            AC_DEFINE(SDL_VIDEO_RENDER_OGL, 1, [ ])
+            SUMMARY_video="${SUMMARY_video} opengl"
+        fi
+    fi
+}
+
+dnl Find OpenGL ES
+CheckOpenGLES()
+{
+    if test x$enable_video = xyes -a x$enable_video_opengles = xyes; then
         if test x$enable_video_opengles1 = xyes; then
             AC_MSG_CHECKING(for OpenGL ES v1 headers)
             video_opengles_v1=no
-            AC_TRY_COMPILE([
+            AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
              #include <GLES/gl.h>
              #include <GLES/glext.h>
-            ],[
-            ],[
-            video_opengles_v1=yes
-            ])
+            ]],[])], [video_opengles_v1=yes],[])
             AC_MSG_RESULT($video_opengles_v1)
             if test x$video_opengles_v1 = xyes; then
                 AC_DEFINE(SDL_VIDEO_OPENGL_ES, 1, [ ])
@@ -2401,13 +2500,10 @@ CheckOpenGLESX11()
         if test x$enable_video_opengles2 = xyes; then
             AC_MSG_CHECKING(for OpenGL ES v2 headers)
             video_opengles_v2=no
-            AC_TRY_COMPILE([
+            AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
              #include <GLES2/gl2.h>
              #include <GLES2/gl2ext.h>
-            ],[
-            ],[
-            video_opengles_v2=yes
-            ])
+            ]],[])], [video_opengles_v2=yes],[])
             AC_MSG_RESULT($video_opengles_v2)
             if test x$video_opengles_v2 = xyes; then
                 AC_DEFINE(SDL_VIDEO_OPENGL_ES2, 1, [ ])
@@ -2436,12 +2532,9 @@ CheckWINDOWSGLES()
 
         AC_MSG_CHECKING(for EGL support)
         video_opengl_egl=no
-        AC_TRY_COMPILE([
+        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
          #include <EGL/egl.h>
-        ],[
-        ],[
-        video_opengl_egl=yes
-        ])
+        ]],[])], [video_opengl_egl=yes],[])
         AC_MSG_RESULT($video_opengl_egl)
         if test x$video_opengl_egl = xyes; then
             AC_DEFINE(SDL_VIDEO_OPENGL, 1, [ ])
@@ -2451,13 +2544,10 @@ CheckWINDOWSGLES()
 
         AC_MSG_CHECKING(for OpenGL ES v2 headers)
         video_opengles_v2=no
-        AC_TRY_COMPILE([
+        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
          #include <GLES2/gl2.h>
          #include <GLES2/gl2ext.h>
-        ],[
-        ],[
-        video_opengles_v2=yes
-        ])
+        ]],[])], [video_opengles_v2=yes],[])
         AC_MSG_RESULT($video_opengles_v2)
         if test x$video_opengles_v2 = xyes; then
             AC_DEFINE(SDL_VIDEO_OPENGL, 1, [ ])
@@ -2509,12 +2599,9 @@ CheckEmscriptenGLES()
     if test x$enable_video = xyes -a x$enable_video_opengles = xyes; then
         AC_MSG_CHECKING(for EGL support)
         video_opengl_egl=no
-        AC_TRY_COMPILE([
+        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
          #include <EGL/egl.h>
-        ],[
-        ],[
-        video_opengl_egl=yes
-        ])
+        ]],[])], [video_opengl_egl=yes],[])
         AC_MSG_RESULT($video_opengl_egl)
         if test x$video_opengl_egl = xyes; then
             AC_DEFINE(SDL_VIDEO_OPENGL_EGL, 1, [ ])
@@ -2522,13 +2609,10 @@ CheckEmscriptenGLES()
 
         AC_MSG_CHECKING(for OpenGL ES v2 headers)
         video_opengles_v2=no
-        AC_TRY_COMPILE([
+        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
          #include <GLES2/gl2.h>
          #include <GLES2/gl2ext.h>
-        ],[
-        ],[
-        video_opengles_v2=yes
-        ])
+        ]],[])], [video_opengles_v2=yes],[])
         AC_MSG_RESULT($video_opengles_v2)
         if test x$video_opengles_v2 = xyes; then
             AC_DEFINE(SDL_VIDEO_OPENGL_ES2, 1, [ ])
@@ -2540,7 +2624,7 @@ CheckEmscriptenGLES()
 
 dnl Check to see if Vulkan support is desired
 AC_ARG_ENABLE(video-vulkan,
-AS_HELP_STRING([--enable-video-vulkan], [include Vulkan support [[default=yes]]]),
+[AS_HELP_STRING([--enable-video-vulkan], [include Vulkan support [default=yes]])],
               , enable_video_vulkan=yes)
 
 dnl Find Vulkan Header
@@ -2549,21 +2633,17 @@ CheckVulkan()
     if test x$enable_video = xyes -a x$enable_video_vulkan = xyes; then
         case "$host" in
             *-*-android*)
-                AC_TRY_COMPILE([
+                AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
                   #if defined(__ARM_ARCH) && __ARM_ARCH < 7
                   #error Vulkan doesn't work on this configuration
                   #endif
-                ],[
-                ],[
-                ],[
-                    enable_video_vulkan=no
-                ])
+                ]],[])], [],[enable_video_vulkan=no])
                 ;;
             *-*-darwin*)
                 save_CFLAGS="$CFLAGS"
-                dnl Work around that we don't have Objective-C support in autoconf
+dnl             Work around that we don't have Objective-C support in autoconf
                 CFLAGS="$CFLAGS -x objective-c"
-                AC_TRY_COMPILE([
+                AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
                   #include <Cocoa/Cocoa.h>
                   #include <Metal/Metal.h>
                   #include <QuartzCore/CAMetalLayer.h>
@@ -2571,11 +2651,7 @@ CheckVulkan()
                   #if TARGET_CPU_X86
                   #error Vulkan doesn't work on this configuration
                   #endif
-                ],[
-                ],[
-                ],[
-                    enable_video_vulkan=no
-                ])
+                ]],[])], [],[enable_video_vulkan=no])
                 CFLAGS="$save_CFLAGS"
                 ;;
             *)
@@ -2587,6 +2663,10 @@ CheckVulkan()
             AC_MSG_WARN([Vulkan does not work on this configuration.])
         fi
     fi
+    if test x$have_loadso != xyes; then
+        AC_MSG_WARN([Vulkan support is available, but disabled because there's no loadso.])
+        enable_video_vulkan=no
+    fi
     if test x$enable_video_vulkan = xyes; then
         AC_DEFINE(SDL_VIDEO_VULKAN, 1, [ ])
         SUMMARY_video="${SUMMARY_video} vulkan"
@@ -2596,18 +2676,16 @@ CheckVulkan()
 dnl See if we can use the new unified event interface in Linux 2.4
 CheckInputEvents()
 {
-    dnl Check for Linux 2.4 unified input event interface support
+dnl Check for Linux 2.4 unified input event interface support
         AC_MSG_CHECKING(for Linux 2.4 unified input interface)
         use_input_events=no
-        AC_TRY_COMPILE([
+        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
           #include <linux/input.h>
-        ],[
+        ]], [[
           #ifndef EVIOCGNAME
           #error EVIOCGNAME() ioctl not available
           #endif
-        ],[
-        use_input_events=yes
-        ])
+        ]])], [use_input_events=yes],[])
         AC_MSG_RESULT($use_input_events)
         if test x$use_input_events = xyes; then
             AC_DEFINE(SDL_INPUT_LINUXEV, 1, [ ])
@@ -2618,19 +2696,16 @@ CheckInputEvents()
 dnl See if we can use the kernel kd.h header
 CheckInputKD()
 {
-
     AC_MSG_CHECKING(for Linux kd.h)
     use_input_kd=no
-    AC_TRY_COMPILE([
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
       #include <linux/kd.h>
       #include <linux/keyboard.h>
-    ],[
+    ]], [[
         struct kbentry kbe;
         kbe.kb_table = KG_CTRL;
         ioctl(0, KDGKBENT, &kbe);
-    ],[
-    use_input_kd=yes
-    ])
+    ]])], [use_input_kd=yes],[])
     AC_MSG_RESULT($use_input_kd)
     if test x$use_input_kd = xyes; then
         AC_DEFINE(SDL_INPUT_LINUXKD, 1, [ ])
@@ -2643,15 +2718,13 @@ CheckInputKBIO()
 {
     AC_MSG_CHECKING(for FreeBSD kbio.h)
     use_input_kbio=no
-    AC_TRY_COMPILE([
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
       #include <sys/kbio.h>
       #include <sys/ioctl.h>
-    ],[
-    	accentmap_t accTable;
+    ]], [[
+        accentmap_t accTable;
         ioctl(0, KDENABIO, 1);
-    ],[
-    use_input_kbio=yes
-    ])
+    ]])], [use_input_kbio=yes],[])
     AC_MSG_RESULT($use_input_kbio)
     if test x$use_input_kbio = xyes; then
         AC_DEFINE(SDL_INPUT_FBSDKBIO, 1, [ ])
@@ -2659,11 +2732,33 @@ CheckInputKBIO()
     fi
 }
 
+dnl See if we can use the wscons input driver
+CheckInputWSCONS()
+{
+    AC_MSG_CHECKING(for OpenBSD wscons)
+    use_input_wscons=no
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+     #include <sys/time.h>
+     #include <dev/wscons/wsconsio.h>
+     #include <dev/wscons/wsksymdef.h>
+     #include <dev/wscons/wsksymvar.h>
+     #include <sys/ioctl.h>
+    ]], [[
+     struct wskbd_map_data data;
+     ioctl(0, WSKBDIO_GETMAP, &data);
+    ]])], [use_input_wscons=yes],[])
+    AC_MSG_RESULT($use_input_wscons)
+    if test x$use_input_wscons = xyes; then
+        AC_DEFINE(SDL_INPUT_WSCONS, 1, [ ])
+        SUMMARY_input="${SUMMARY_input} wscons"
+    fi
+}
+
 dnl See if the platform offers libudev for device enumeration and hotplugging.
 CheckLibUDev()
 {
     AC_ARG_ENABLE(libudev,
-AS_HELP_STRING([--enable-libudev], [enable libudev support [[default=yes]]]),
+[AS_HELP_STRING([--enable-libudev], [enable libudev support [default=yes]])],
                         , enable_libudev=yes)
     if test x$enable_libudev = xyes; then
         AC_CHECK_HEADER(libudev.h,
@@ -2685,16 +2780,16 @@ dnl See if the platform offers libdbus for various IPC techniques.
 CheckDBus()
 {
     AC_ARG_ENABLE(dbus,
-AS_HELP_STRING([--enable-dbus], [enable D-Bus support [[default=yes]]]),
+[AS_HELP_STRING([--enable-dbus], [enable D-Bus support [default=yes]])],
                         , enable_dbus=yes)
     if test x$enable_dbus = xyes; then
         PKG_CHECK_MODULES([DBUS], [dbus-1], have_dbus=yes, have_dbus=no)
-        save_CFLAGS="$CFLAGS"
-        CFLAGS="$save_CFLAGS $DBUS_CFLAGS"
+        save_CPPFLAGS="$CPPFLAGS"
+        CPPFLAGS="$save_CPPFLAGS $DBUS_CFLAGS"
         AC_CHECK_HEADER(dbus/dbus.h,
                         have_dbus_dbus_h_hdr=yes,
                         have_dbus_dbus_h_hdr=no)
-        CFLAGS="$save_CFLAGS"
+        CPPFLAGS="$save_CPPFLAGS"
         if test x$have_dbus_dbus_h_hdr = xyes; then
             AC_DEFINE(HAVE_DBUS_DBUS_H, 1, [ ])
             EXTRA_CFLAGS="$EXTRA_CFLAGS $DBUS_CFLAGS"
@@ -2707,7 +2802,7 @@ dnl See if the platform wanna IME support.
 CheckIME()
 {
     AC_ARG_ENABLE(ime,
-AS_HELP_STRING([--enable-ime], [enable IME support [[default=yes]]]),
+[AS_HELP_STRING([--enable-ime], [enable IME support [default=yes]])],
                   , enable_ime=yes)
     if test x$enable_ime = xyes; then
         AC_DEFINE(SDL_USE_IME, 1, [ ])
@@ -2741,16 +2836,16 @@ dnl See if the platform has libibus IME support.
 CheckIBus()
 {
     AC_ARG_ENABLE(ibus,
-AS_HELP_STRING([--enable-ibus], [enable IBus support [[default=yes]]]),
+[AS_HELP_STRING([--enable-ibus], [enable IBus support [default=yes]])],
                   , enable_ibus=yes)
     if test x$enable_ibus = xyes; then
         PKG_CHECK_MODULES([IBUS], [ibus-1.0], have_ibus=yes, have_ibus=no)
-        save_CFLAGS="$CFLAGS"
-        CFLAGS="$save_CFLAGS $IBUS_CFLAGS"
+        save_CPPFLAGS="$CPPFLAGS"
+        CPPFLAGS="$save_CPPFLAGS $IBUS_CFLAGS"
         AC_CHECK_HEADER(ibus-1.0/ibus.h,
                         have_ibus_ibus_h_hdr=yes,
                         have_ibus_ibus_h_hdr=no)
-        CFLAGS="$save_CFLAGS"
+        CPPFLAGS="$save_CPPFLAGS"
         if test x$have_ibus_ibus_h_hdr = xyes; then
             if test x$enable_ime != xyes; then
                 AC_MSG_WARN([IME support is required for IBus.])
@@ -2774,7 +2869,7 @@ dnl See if the platform has fcitx IME support.
 CheckFcitx()
 {
     AC_ARG_ENABLE(fcitx,
-AS_HELP_STRING([--enable-fcitx], [enable fcitx support [[default=yes]]]),
+[AS_HELP_STRING([--enable-fcitx], [enable fcitx support [default=yes]])],
                   , enable_fcitx=yes)
     if test x$enable_fcitx = xyes; then
         AC_MSG_CHECKING(for fcitx support)
@@ -2796,31 +2891,29 @@ dnl Check to see if GameController framework support is desired
 CheckJoystickMFI()
 {
     AC_ARG_ENABLE(joystick-mfi,
-AS_HELP_STRING([--enable-joystick-mfi], [include macOS MFI joystick support [[default=yes]]]),
+[AS_HELP_STRING([--enable-joystick-mfi], [include macOS MFI joystick support [default=yes]])],
               , enable_joystick_mfi=yes)
 
     if test x$enable_joystick_mfi = xyes; then
         save_CFLAGS="$CFLAGS"
         save_LDFLAGS="$LDFLAGS"
-        dnl Work around that we don't have Objective-C support in autoconf
+dnl     Work around that we don't have Objective-C support in autoconf
         CFLAGS="$CFLAGS -x objective-c -fobjc-weak"
         LDFLAGS="$LDFLAGS -Wl,-weak_framework,CoreHaptics -Wl,-weak_framework,GameController"
         AC_MSG_CHECKING(for GameController framework)
         enable_joystick_mfi=no
-        AC_TRY_LINK([
+        AC_LINK_IFELSE([AC_LANG_PROGRAM([[
           #include <AvailabilityMacros.h>
           #include <TargetConditionals.h>
           #import <GameController/GameController.h>
-        ],[
+        ]], [[
           #if MAC_OS_X_VERSION_MIN_REQUIRED < 1080
           #error GameController framework doesn't work on this configuration
           #endif
           #if TARGET_CPU_X86
           #error GameController framework doesn't work on this configuration
           #endif
-        ],[
-        enable_joystick_mfi=yes
-        ])
+        ]])], [enable_joystick_mfi=yes],[])
         CFLAGS="$save_CFLAGS"
         LDFLAGS="$save_LDFLAGS"
 
@@ -2836,14 +2929,40 @@ AS_HELP_STRING([--enable-joystick-mfi], [include macOS MFI joystick support [[de
 dnl See what type of thread model to use on Linux and Solaris
 CheckPTHREAD()
 {
-    dnl Check for pthread support
+dnl Check for pthread support
+
+dnl Emscripten pthreads work, but you need to have a non-pthread fallback build
+dnl  for systems without support. It's not currently enough to not use
+dnl  pthread functions in a pthread-build; it won't start up on unsupported
+dnl  browsers. As such, you have to explicitly enable it on Emscripten builds
+dnl  for the time being. This default with change to ON once this becomes
+dnl  commonly supported in browsers or the Emscripten teams makes a single
+dnl  binary work everywhere.
+
+    case "$host" in
+        *-*-emscripten*)
+            enable_pthreads_default=no
+            ;;
+        *)
+            enable_pthreads_default=yes
+            ;;
+    esac
+
     AC_ARG_ENABLE(pthreads,
-AS_HELP_STRING([--enable-pthreads], [use POSIX threads for multi-threading [[default=yes]]]),
-                  , enable_pthreads=yes)
-    dnl This is used on Linux for glibc binary compatibility (Doh!)
+[AS_HELP_STRING([--enable-pthreads], [use POSIX threads for multi-threading [default=maybe]])],
+                  , enable_pthreads=maybe)
+dnl This is used on Linux for glibc binary compatibility (Doh!)
     AC_ARG_ENABLE(pthread-sem,
-AS_HELP_STRING([--enable-pthread-sem], [use pthread semaphores [[default=yes]]]),
-                  , enable_pthread_sem=yes)
+[AS_HELP_STRING([--enable-pthread-sem], [use pthread semaphores [default=maybe]])],
+                  , enable_pthread_sem=maybe)
+
+    if test x$enable_pthreads = xmaybe; then
+        enable_pthreads=$enable_pthreads_default
+    fi
+    if test x$enable_pthread_sem = xmaybe; then
+        enable_pthread_sem=$enable_pthreads
+    fi
+
     case "$host" in
          *-*-android*)
             pthread_cflags="-D_REENTRANT -D_THREAD_SAFE"
@@ -2909,6 +3028,10 @@ AS_HELP_STRING([--enable-pthread-sem], [use pthread semaphores [[default=yes]]])
             pthread_cflags="-D_REENTRANT"
             pthread_lib=""
             ;;
+        *-*-emscripten*)
+            pthread_cflags="-D_REENTRANT -pthread"
+            pthread_lib="-pthread"
+            ;;
         *)
             pthread_cflags="-D_REENTRANT"
             pthread_lib="-lpthread"
@@ -2922,14 +3045,12 @@ AS_HELP_STRING([--enable-pthread-sem], [use pthread semaphores [[default=yes]]])
         # Check to see if we have pthread support on this system
         AC_MSG_CHECKING(for pthreads)
         use_pthreads=no
-        AC_TRY_LINK([
+        AC_LINK_IFELSE([AC_LANG_PROGRAM([[
          #include <pthread.h>
-        ],[
+        ]], [[
          pthread_attr_t type;
          pthread_attr_init(&type);
-        ],[
-        use_pthreads=yes
-        ])
+        ]])], [use_pthreads=yes],[])
         AC_MSG_RESULT($use_pthreads)
         # Restore the compiler flags and libraries
         CFLAGS="$ac_save_cflags"; LIBS="$ac_save_libs"
@@ -2950,28 +3071,28 @@ AS_HELP_STRING([--enable-pthread-sem], [use pthread semaphores [[default=yes]]])
             AC_MSG_CHECKING(for recursive mutexes)
             has_recursive_mutexes=no
             if test x$has_recursive_mutexes = xno; then
-                AC_TRY_LINK([
+                AC_LINK_IFELSE([AC_LANG_PROGRAM([[
                   #define _GNU_SOURCE 1
                   #include <pthread.h>
-                ],[
+                ]], [[
                   pthread_mutexattr_t attr;
                   pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
-                ],[
+                ]])], [
                 has_recursive_mutexes=yes
                 AC_DEFINE(SDL_THREAD_PTHREAD_RECURSIVE_MUTEX, 1, [ ])
-                ])
+                ],[])
             fi
             if test x$has_recursive_mutexes = xno; then
-                AC_TRY_LINK([
+                AC_LINK_IFELSE([AC_LANG_PROGRAM([[
                   #define _GNU_SOURCE 1
                   #include <pthread.h>
-                ],[
+                ]], [[
                   pthread_mutexattr_t attr;
                   pthread_mutexattr_setkind_np(&attr, PTHREAD_MUTEX_RECURSIVE_NP);
-                ],[
+                ]])],[
                 has_recursive_mutexes=yes
                 AC_DEFINE(SDL_THREAD_PTHREAD_RECURSIVE_MUTEX_NP, 1, [ ])
-                ])
+                ],[])
             fi
             AC_MSG_RESULT($has_recursive_mutexes)
 
@@ -2979,27 +3100,24 @@ AS_HELP_STRING([--enable-pthread-sem], [use pthread semaphores [[default=yes]]])
             if test x$enable_pthread_sem = xyes; then
                 AC_MSG_CHECKING(for pthread semaphores)
                 have_pthread_sem=no
-                AC_TRY_COMPILE([
+                AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
                   #include <pthread.h>
                   #include <semaphore.h>
-                ],[
-                ],[
-                have_pthread_sem=yes
-                ])
+                ]],[])], [have_pthread_sem=yes],[])
                 AC_MSG_RESULT($have_pthread_sem)
             fi
             if test x$have_pthread_sem = xyes; then
                 AC_MSG_CHECKING(for sem_timedwait)
                 have_sem_timedwait=no
-                AC_TRY_LINK([
+                AC_LINK_IFELSE([AC_LANG_PROGRAM([[
                   #include <pthread.h>
                   #include <semaphore.h>
-                ],[
+                ]], [[
                   sem_timedwait(NULL, NULL);
-                ],[
+                ]])], [
                 have_sem_timedwait=yes
                 AC_DEFINE([HAVE_SEM_TIMEDWAIT], 1, [ ])
-                ])
+                ],[])
                 AC_MSG_RESULT($have_sem_timedwait)
             fi
 
@@ -3062,12 +3180,9 @@ CheckWINDOWS()
 {
     AC_MSG_CHECKING(Windows compiler)
     have_win32_gcc=no
-    AC_TRY_COMPILE([
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
      #include <windows.h>
-    ],[
-    ],[
-    have_win32_gcc=yes
-    ])
+    ]],[])], [have_win32_gcc=yes],[])
     AC_MSG_RESULT($have_win32_gcc)
     if test x$have_win32_gcc != xyes; then
        AC_MSG_ERROR([
@@ -3077,29 +3192,43 @@ CheckWINDOWS()
 
     AC_MSG_CHECKING(Windows CE)
     have_wince=no
-    AC_TRY_COMPILE([
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 #if !defined(_WIN32_WCE) && !defined(__MINGW32CE__)
 #error This is not Windows CE
 #endif
-    ],[
-    ],[
+    ]],[])], [
     have_wince=yes
        AC_MSG_ERROR([
 *** Sorry, Windows CE is no longer supported.
        ])
-    ])
+    ],[])
     AC_MSG_RESULT($have_wince)
 
     # This fixes Windows stack alignment with newer GCC
     CheckStackBoundary
 }
 
+dnl Determine whether the compiler can produce OS/2 executables
+CheckOS2()
+{
+    AC_MSG_CHECKING(OS/2 compiler)
+    have_os2_gcc=no
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <os2.h>]],
+     [])],[have_os2_gcc=yes],[])
+    AC_MSG_RESULT($have_os2_gcc)
+    if test x$have_os2_gcc != xyes; then
+       AC_MSG_ERROR([
+*** Your compiler ($CC) does not produce OS/2 executables!
+       ])
+    fi
+}
+
 dnl Find the DirectX includes and libraries
 CheckDIRECTX()
 {
     AC_ARG_ENABLE(directx,
-AS_HELP_STRING([--enable-directx], [use DirectX for Windows audio/video [[default=yes]]]),
-                  , enable_directx=yes)
+[AS_HELP_STRING([--enable-directx], [use DirectX for Windows audio/video [default=yes]])],
+                                 , enable_directx=yes)
     if test x$enable_directx = xyes; then
         AC_CHECK_HEADER(d3d9.h, have_d3d=yes)
         AC_CHECK_HEADER(d3d11_1.h, have_d3d11=yes)
@@ -3107,17 +3236,6 @@ AS_HELP_STRING([--enable-directx], [use DirectX for Windows audio/video [[defaul
         AC_CHECK_HEADER(dsound.h, have_dsound=yes)
         AC_CHECK_HEADER(dinput.h, have_dinput=yes)
         AC_CHECK_HEADER(dxgi.h, have_dxgi=yes)
-        AC_CHECK_HEADER(xinput.h, have_xinput=yes)
-        AC_TRY_COMPILE([
-#include <windows.h>
-#include <xinput.h>
-XINPUT_GAMEPAD_EX x1;
-        ],[],[have_xinput_gamepadex=yes])
-        AC_TRY_COMPILE([
-#include <windows.h>
-#include <xinput.h>
-XINPUT_STATE_EX s1;
-        ],[],[have_xinput_stateex=yes])
 
         if test x$have_ddraw = xyes; then
             AC_DEFINE(HAVE_DDRAW_H, 1, [ ])
@@ -3131,6 +3249,38 @@ XINPUT_STATE_EX s1;
         if test x$have_dxgi = xyes; then
             AC_DEFINE(HAVE_DXGI_H, 1, [ ])
         fi
+
+        # FIXME: latest Cygwin finds dinput headers, but we die on other win32 headers.
+        # FIXME:  ...so force it off for now.
+        case "$host" in
+            *-*-cygwin*)
+            have_dinput=false
+            ;;
+        esac
+    fi
+
+    AC_ARG_ENABLE(xinput,
+[AS_HELP_STRING([--enable-xinput], [use Xinput for Windows [default=yes]])],
+                                , enable_xinput=yes)
+    if test x$enable_xinput = xyes; then
+        have_xinput_gamepadex=no
+        have_xinput_stateex=no
+        AC_CHECK_HEADER(xinput.h, have_xinput=yes)
+        AC_MSG_CHECKING(for struct XINPUT_GAMEPAD_EX)
+        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+#include <windows.h>
+#include <xinput.h>
+XINPUT_GAMEPAD_EX x1;
+            ]],[])], [have_xinput_gamepadex=yes],[])
+        AC_MSG_RESULT($have_xinput_gamepadex)
+        AC_MSG_CHECKING(for struct XINPUT_STATE_EX)
+        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+#include <windows.h>
+#include <xinput.h>
+XINPUT_STATE_EX s1;
+            ]],[])], [have_xinput_stateex=yes],[])
+        AC_MSG_RESULT($have_xinput_stateex)
+
         if test x$have_xinput = xyes; then
             AC_DEFINE(HAVE_XINPUT_H, 1, [ ])
         fi
@@ -3140,14 +3290,18 @@ XINPUT_STATE_EX s1;
         if test x$have_xinput_stateex = xyes; then
             AC_DEFINE(HAVE_XINPUT_STATE_EX, 1, [ ])
         fi
+    fi
 
-        # FIXME: latest Cygwin finds dinput headers, but we die on other win32 headers.
-        # FIXME:  ...so force it off for now.
-        case "$host" in
-            *-*-cygwin*)
-            have_dinput=false
-            ;;
-        esac
+    AC_MSG_CHECKING(for windows.gaming.input.h)
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+#define COBJMACROS
+#include <windows.gaming.input.h>
+__x_ABI_CWindows_CGaming_CInput_CIGamepadStatics2 *s2;
+        ]],[])], [have_wgi=yes],[have_wgi=no])
+    AC_MSG_RESULT($have_wgi)
+
+    if test x$have_wgi = xyes; then
+        AC_DEFINE(HAVE_WINDOWS_GAMING_INPUT_H, 1, [ ])
     fi
 
     AC_CHECK_HEADER(mmdeviceapi.h, have_wasapi=yes)
@@ -3160,37 +3314,44 @@ XINPUT_STATE_EX s1;
     fi
 
     AC_ARG_ENABLE(wasapi,
-AS_HELP_STRING([--enable-wasapi], [use the Windows WASAPI audio driver [[default=yes]]]),
+[AS_HELP_STRING([--enable-wasapi], [use the Windows WASAPI audio driver [default=yes]])],
                                 , enable_wasapi=yes)
 }
 
 dnl Check for the dlfcn.h interface for dynamically loading objects
+dnl NOTE: CheckDLOPEN is called only for relevant platforms
 CheckDLOPEN()
 {
-    AC_ARG_ENABLE(sdl-dlopen,
-AS_HELP_STRING([--enable-sdl-dlopen], [use dlopen for shared object loading [[default=yes]]]),
-                  , enable_sdl_dlopen=yes)
-    if test x$enable_sdl_dlopen = xyes; then
-        AC_MSG_CHECKING(for dlopen)
-        have_dlopen=no
-        AC_TRY_COMPILE([
-         #include <dlfcn.h>
-        ],[
-         void *handle = dlopen("", RTLD_NOW);
-         const char *loaderror = (char *) dlerror();
-        ],[
-        have_dlopen=yes
-        ])
-        AC_MSG_RESULT($have_dlopen)
+    AC_DEFINE(DYNAPI_NEEDS_DLOPEN, 1, [ ])
 
-        if test x$have_dlopen = xyes; then
-            AC_CHECK_LIB(c, dlopen, EXTRA_LDFLAGS="$EXTRA_LDFLAGS",
-               AC_CHECK_LIB(dl, dlopen, EXTRA_LDFLAGS="$EXTRA_LDFLAGS -ldl",
-                  AC_CHECK_LIB(ltdl, dlopen, EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lltdl")))
-            AC_DEFINE(SDL_LOADSO_DLOPEN, 1, [ ])
-            SOURCES="$SOURCES $srcdir/src/loadso/dlopen/*.c"
-            have_loadso=yes
-        fi
+    AC_CHECK_HEADER(dlfcn.h,have_dlfcn_h=yes,have_dlfcn_h=no)
+
+    have_dlopen=no
+    AC_CHECK_LIB(c, dlopen, have_dlopen=yes,
+       AC_CHECK_LIB(dl, dlopen, [have_dlopen=yes; EXTRA_LDFLAGS="$EXTRA_LDFLAGS -ldl"]))
+    AC_MSG_CHECKING(for dlopen)
+    AC_MSG_RESULT($have_dlopen)
+
+    if test x$have_dlfcn_h = xyes -a x$have_dlopen = xyes; then
+       AC_DEFINE(HAVE_DLOPEN, 1, [ ])
+       if test x$enable_loadso = xyes; then
+          AC_DEFINE(SDL_LOADSO_DLOPEN, 1, [ ])
+          SOURCES="$SOURCES $srcdir/src/loadso/dlopen/*.c"
+          have_loadso=yes
+       fi
+    fi
+}
+
+CheckO_CLOEXEC()
+{
+    AC_MSG_CHECKING(for O_CLOEXEC)
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+#include <fcntl.h>
+int flag = O_CLOEXEC;
+        ]],[])], [have_o_cloexec=yes],[have_o_cloexec=no])
+    AC_MSG_RESULT($have_o_cloexec)
+    if test $have_o_cloexec = yes; then
+       AC_DEFINE(HAVE_O_CLOEXEC, 1, [ ])
     fi
 }
 
@@ -3216,7 +3377,7 @@ CheckUSBHID()
 
                 AC_MSG_CHECKING(for usbhid)
                 have_usbhid=no
-                AC_TRY_COMPILE([
+                AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
                   #include <sys/types.h>
                   #if defined(HAVE_USB_H)
                   #include <usb.h>
@@ -3235,19 +3396,17 @@ CheckUSBHID()
                   #elif defined(HAVE_LIBUSBHID_H)
                   #include <libusbhid.h>
                   #endif
-                ],[
+                ]], [[
                   struct report_desc *repdesc;
                   struct usb_ctl_report *repbuf;
                   hid_kind_t hidkind;
-                ],[
-                have_usbhid=yes
-                ])
+                ]])], [have_usbhid=yes],[])
                 AC_MSG_RESULT($have_usbhid)
 
                 if test x$have_usbhid = xyes; then
                     AC_MSG_CHECKING(for ucr_data member of usb_ctl_report)
                     have_usbhid_ucr_data=no
-                    AC_TRY_COMPILE([
+                    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
                       #include <sys/types.h>
                       #if defined(HAVE_USB_H)
                       #include <usb.h>
@@ -3266,12 +3425,10 @@ CheckUSBHID()
                       #elif defined(HAVE_LIBUSBHID_H)
                       #include <libusbhid.h>
                       #endif
-                    ],[
+                    ]], [[
                       struct usb_ctl_report buf;
                       if (buf.ucr_data) { }
-                    ],[
-                    have_usbhid_ucr_data=yes
-                    ])
+                    ]])], [have_usbhid_ucr_data=yes],[])
                     if test x$have_usbhid_ucr_data = xyes; then
                         USB_CFLAGS="$USB_CFLAGS -DUSBHID_UCR_DATA"
                     fi
@@ -3279,7 +3436,7 @@ CheckUSBHID()
 
                     AC_MSG_CHECKING(for new usbhid API)
                     have_usbhid_new=no
-                    AC_TRY_COMPILE([
+                    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
                       #include <sys/types.h>
                       #if defined(HAVE_USB_H)
                       #include <usb.h>
@@ -3298,12 +3455,10 @@ CheckUSBHID()
                       #elif defined(HAVE_LIBUSBHID_H)
                       #include <libusbhid.h>
                       #endif
-                    ],[
+                    ]], [[
                       report_desc_t d;
                       hid_start_parse(d, 1, 1);
-                    ],[
-                    have_usbhid_new=yes
-                    ])
+                    ]])], [have_usbhid_new=yes],[])
                     if test x$have_usbhid_new = xyes; then
                         USB_CFLAGS="$USB_CFLAGS -DUSBHID_NEW"
                     fi
@@ -3311,15 +3466,13 @@ CheckUSBHID()
 
                     AC_MSG_CHECKING(for struct joystick in machine/joystick.h)
                     have_machine_joystick=no
-                    AC_TRY_COMPILE([
+                    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
                       #include <machine/joystick.h>
-                    ],[
+                    ]], [[
                       struct joystick t;
-                    ],[
-                    have_machine_joystick=yes
-                    ])
+                    ]])], [have_machine_joystick=yes],[])
                     if test x$have_machine_joystick = xyes; then
-                        AC_DEFINE(SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H, 1, [ ])
+                        AC_DEFINE(SDL_HAVE_MACHINE_JOYSTICK_H, 1, [ ])
                     fi
                     AC_MSG_RESULT($have_machine_joystick)
 
@@ -3329,6 +3482,7 @@ CheckUSBHID()
                     EXTRA_LDFLAGS="$EXTRA_LDFLAGS $USB_LIBS"
                     have_joystick=yes
                 fi
+
                 CFLAGS="$save_CFLAGS"
             fi
         ;;
@@ -3338,14 +3492,14 @@ CheckUSBHID()
 dnl Check for HIDAPI joystick drivers
 CheckHIDAPI()
 {
-    AC_ARG_ENABLE(hidapi,
-AS_HELP_STRING([--enable-hidapi], [use HIDAPI for low level joystick drivers [[default=yes]]]),
-                  , enable_hidapi=yes)
+    AC_ARG_ENABLE(hidapi-joystick,
+[AS_HELP_STRING([--enable-hidapi-joystick], [use HIDAPI for low level joystick drivers [default=yes]])],
+                  , enable_hidapi_joystick=yes)
     AC_ARG_ENABLE(hidapi-libusb,
-AS_HELP_STRING([--enable-hidapi-libusb], [use libusb for low level joystick drivers [[default=maybe]]]),
+[AS_HELP_STRING([--enable-hidapi-libusb], [use libusb for low level joystick drivers [default=maybe]])],
                   , enable_hidapi_libusb=maybe)
 
-    if test x$enable_joystick = xyes -a x$enable_hidapi = xyes; then
+    if test x$enable_hidapi = xyes; then
         case "$host" in
             # libusb does not support iOS
             *-ios-* )
@@ -3356,33 +3510,24 @@ AS_HELP_STRING([--enable-hidapi-libusb], [use libusb for low level joystick driv
                 enable_hidapi_libusb=yes
                 require_hidapi_libusb=yes
                 ;;
-            # RAWINPUT is only available on Win32, but can be enabled if HIDAPI is
-            *-*-cygwin* | *-*-mingw32*)
-                enable_joystick_rawinput=yes
+           *-*-os2* )
+                enable_hidapi_libusb=yes
                 ;;
         esac
 
         hidapi_support=yes
         if test x$enable_hidapi_libusb = xyes; then
             PKG_CHECK_MODULES([LIBUSB], [libusb-1.0], have_libusb=yes, have_libusb=no)
-            save_CFLAGS="$CFLAGS"
-            CFLAGS="$save_CFLAGS $LIBUSB_CFLAGS"
-            AC_CHECK_HEADER(libusb.h, have_libusb_h=yes)
-            CFLAGS="$save_CFLAGS"
+            save_CPPFLAGS="$CPPFLAGS"
+            CPPFLAGS="$save_CPPFLAGS $LIBUSB_CFLAGS"
+            AC_CHECK_HEADER(libusb.h, have_libusb_h=yes, have_libusb_h=no)
+            CPPFLAGS="$save_CPPFLAGS"
             if test x$have_libusb_h = xno && test x$require_hidapi_libusb = xyes; then
                 hidapi_support=no
             fi
         fi
 
         if test x$hidapi_support = xyes; then
-            AC_DEFINE(SDL_JOYSTICK_HIDAPI, 1, [ ])
-            if test x$enable_joystick_rawinput = xyes; then
-                AC_DEFINE(SDL_JOYSTICK_RAWINPUT, 1, [ ])
-            fi
-            EXTRA_CFLAGS="$EXTRA_CFLAGS -I$srcdir/src/hidapi/hidapi"
-            SOURCES="$SOURCES $srcdir/src/joystick/hidapi/*.c"
-            SOURCES="$SOURCES $srcdir/src/hidapi/SDL_hidapi.c"
-
             if test x$have_libusb_h = xyes; then
                 EXTRA_CFLAGS="$EXTRA_CFLAGS $LIBUSB_CFLAGS"
                 if test x$require_hidapi_libusb = xyes; then
@@ -3397,9 +3542,12 @@ AS_HELP_STRING([--enable-hidapi-libusb], [use libusb for low level joystick driv
                         *-*-darwin* )
                             libusb_lib="libusb-1.0.0.dylib"
                             ;;
-                        *-*-cygwin* | *-*-mingw32* )
+                        *-*-cygwin* | *-*-mingw* )
                             libusb_lib="libusb-1.0.dll"
                             ;;
+                        *-*-os2* )
+                            libusb_lib="usb100.dll"
+                            ;;
                     esac
                     if test x$libusb_lib = x; then
                         libusb_lib=[`find_lib "libusb-1.0.so.*" "" | sed 's/.*\/\(.*\)/\1/; q'`]
@@ -3409,16 +3557,21 @@ AS_HELP_STRING([--enable-hidapi-libusb], [use libusb for low level joystick driv
             fi
         fi
 
-        AC_MSG_CHECKING(for hidapi support)
+        AC_MSG_CHECKING(for hidapi joystick support)
         AC_MSG_RESULT($hidapi_support)
     fi
+
+    if test x$enable_joystick = xyes -a x$hidapi_support = xyes -a x$enable_hidapi_joystick = xyes; then
+        AC_DEFINE(SDL_JOYSTICK_HIDAPI, 1, [ ])
+        SOURCES="$SOURCES $srcdir/src/joystick/hidapi/*.c"
+    fi
 }
 
 dnl Check for clock_gettime()
 CheckClockGettime()
 {
     AC_ARG_ENABLE(clock_gettime,
-AS_HELP_STRING([--enable-clock_gettime], [use clock_gettime() instead of gettimeofday() on UNIX [[default=yes]]]),
+[AS_HELP_STRING([--enable-clock_gettime], [use clock_gettime() instead of gettimeofday() on UNIX [default=yes]])],
                   , enable_clock_gettime=yes)
     if test x$enable_clock_gettime = xyes; then
         AC_CHECK_LIB(rt, clock_gettime, have_clock_gettime=yes)
@@ -3448,7 +3601,7 @@ dnl Check if we want to use RPATH
 CheckRPATH()
 {
     AC_ARG_ENABLE(rpath,
-AS_HELP_STRING([--enable-rpath], [use an rpath when linking SDL [[default=yes]]]),
+[AS_HELP_STRING([--enable-rpath], [use an rpath when linking SDL [default=yes]])],
                   , enable_rpath=yes)
 }
 
@@ -3458,14 +3611,14 @@ dnl  environment, etc, but most people don't need this.
 CheckEventSignals()
 {
     AC_ARG_ENABLE(backgrounding-signal,
-AS_HELP_STRING([--enable-backgrounding-signal], [number to use for magic backgrounding signal or 'no' [[default=no]]]),
+[AS_HELP_STRING([--enable-backgrounding-signal], [number to use for magic backgrounding signal or 'no' [default=no]])],
                   , enable_backgrounding_signal=no)
     if test x$enable_backgrounding_signal != xno; then
         EXTRA_CFLAGS="$EXTRA_CFLAGS -DSDL_BACKGROUNDING_SIGNAL=$enable_backgrounding_signal"
     fi
 
     AC_ARG_ENABLE(foregrounding-signal,
-AS_HELP_STRING([--enable-foregrounding-signal], [number to use for magic foregrounding signal or 'no' [[default=no]]]),
+[AS_HELP_STRING([--enable-foregrounding-signal], [number to use for magic foregrounding signal or 'no' [default=no]])],
                   , enable_foregrounding_signal=no)
     if test x$enable_foregrounding_signal != xno; then
         EXTRA_CFLAGS="$EXTRA_CFLAGS -DSDL_FOREGROUNDING_SIGNAL=$enable_foregrounding_signal"
@@ -3476,7 +3629,7 @@ dnl Set up the Virtual joystick driver.
 CheckVirtualJoystick()
 {
     AC_ARG_ENABLE(joystick-virtual,
-AS_HELP_STRING([--enable-joystick-virtual], [enable virtual joystick APIs [[default=yes]]]),
+[AS_HELP_STRING([--enable-joystick-virtual], [enable virtual joystick APIs [default=yes]])],
                   , enable_joystick_virtual=yes)
     if test x$enable_joystick = xyes -a x$enable_joystick_virtual = xyes; then
         AC_DEFINE(SDL_JOYSTICK_VIRTUAL, 1, [ ])
@@ -3511,6 +3664,7 @@ case "$host" in
                     SOURCES="$SOURCES $srcdir/src/core/android/*.c $srcdir/src/video/android/*.c"
                     AC_DEFINE(SDL_VIDEO_DRIVER_ANDROID, 1, [ ])
                     SUMMARY_video="${SUMMARY_video} android"
+                    have_video=yes
                 fi
                 ;;
             *-*-linux*)         ARCH=linux ;;
@@ -3536,13 +3690,16 @@ case "$host" in
         CheckVisibilityHidden
         CheckDeclarationAfterStatement
         CheckDummyVideo
+        CheckOffscreenVideo
         CheckDiskAudio
         CheckDummyAudio
         CheckDLOPEN
         CheckARM
         CheckNEON
+        CheckO_CLOEXEC
         CheckOSS
         CheckALSA
+        CheckPipewire
         CheckPulseAudio
         CheckJACK
         CheckARTSC
@@ -3555,9 +3712,12 @@ case "$host" in
         CheckRPI
         CheckX11
         CheckDirectFB
+        # Need to check for EGL first because KMSDRM and Wayland depends on it.
+        CheckEGL
         CheckKMSDRM
-        CheckOpenGLX11
-        CheckOpenGLESX11
+        CheckGLX
+        CheckOpenGL
+        CheckOpenGLES
         CheckVulkan
         CheckWayland
         CheckInputEvents
@@ -3574,6 +3734,9 @@ case "$host" in
           freebsd)
               CheckInputKBIO
           ;;
+          openbsd|netbsd)
+              CheckInputWSCONS
+          ;;
         esac
         CheckUSBHID
         CheckHIDAPI
@@ -3583,12 +3746,16 @@ case "$host" in
         CheckRPATH
         CheckVivanteVideo
 
-        SOURCES="$SOURCES $srcdir/src/misc/unix/*.c"
-        have_misc=yes
-
-        SOURCES="$SOURCES $srcdir/src/locale/unix/*.c"
-        have_locale=yes
-
+        # Set up files for the misc library
+        if test x$enable_misc = xyes; then
+            SOURCES="$SOURCES $srcdir/src/misc/unix/*.c"
+            have_misc=yes
+        fi
+        # Set up files for the locale library
+        if test x$enable_locale = xyes; then
+            SOURCES="$SOURCES $srcdir/src/locale/unix/*.c"
+            have_locale=yes
+        fi
         # Set up files for the audio library
         if test x$enable_audio = xyes; then
           case $ARCH in
@@ -3614,6 +3781,15 @@ case "$host" in
                 AC_DEFINE(SDL_AUDIO_DRIVER_ANDROID, 1, [ ])
                 SOURCES="$SOURCES $srcdir/src/audio/android/*.c"
                 SUMMARY_audio="${SUMMARY_audio} android"
+
+                AC_DEFINE(SDL_AUDIO_DRIVER_OPENSLES, 1, [ ])
+                SOURCES="$SOURCES $srcdir/src/audio/openslES/*.c"
+                SUMMARY_audio="${SUMMARY_audio} openslES"
+
+                AC_DEFINE(SDL_AUDIO_DRIVER_AAUDIO, 1, [ ])
+                SOURCES="$SOURCES $srcdir/src/audio/aaudio/*.c"
+                SUMMARY_audio="${SUMMARY_audio} aaudio"
+
                 have_audio=yes
             ;;
             nto)
@@ -3711,7 +3887,7 @@ case "$host" in
         fi
         # Set up files for udev hotplugging support
         if test x$enable_libudev = xyes && test x$have_libudev_h_hdr = xyes; then
-            SOURCES="$SOURCES $srcdir/src/core/linux/SDL_udev.c"               
+            SOURCES="$SOURCES $srcdir/src/core/linux/SDL_udev.c"
         fi
         # Set up files for evdev input
         if test x$use_input_events = xyes; then
@@ -3719,12 +3895,17 @@ case "$host" in
             SOURCES="$SOURCES $srcdir/src/core/linux/SDL_evdev_kbd.c"
             SOURCES="$SOURCES $srcdir/src/core/freebsd/SDL_evdev_kbd_freebsd.c"
         fi
+        # Set up files for wscons input
+        if test x$use_input_wscons = xyes; then
+            SOURCES="$SOURCES $srcdir/src/core/openbsd/SDL_wscons_kbd.c"
+            SOURCES="$SOURCES $srcdir/src/core/openbsd/SDL_wscons_mouse.c"
+        fi
         # Set up other core UNIX files
         SOURCES="$SOURCES $srcdir/src/core/linux/SDL_evdev_capabilities.c"
         SOURCES="$SOURCES $srcdir/src/core/linux/SDL_threadprio.c"
         SOURCES="$SOURCES $srcdir/src/core/unix/*.c"
         ;;
-    *-*-cygwin* | *-*-mingw32*)
+    *-*-cygwin* | *-*-mingw*)
         ARCH=win32
         if test "$build" != "$host"; then # cross-compiling
             # Default cross-compile location
@@ -3735,8 +3916,12 @@ case "$host" in
                 ac_default_prefix=$BUILD_PREFIX
             fi
         fi
+        if test x$enable_loadso = xyes; then
+            have_loadso=yes
+        fi
         CheckDeclarationAfterStatement
         CheckDummyVideo
+        CheckOffscreenVideo
         CheckDiskAudio
         CheckDummyAudio
         CheckWINDOWS
@@ -3748,21 +3933,23 @@ case "$host" in
 
         # Set up the core platform files
         SOURCES="$SOURCES $srcdir/src/core/windows/*.c"
-
-        SOURCES="$SOURCES $srcdir/src/misc/windows/*.c"
-        have_misc=yes
-
+        # Set up files for the misc library
+        if test x$enable_misc = xyes; then
+            SOURCES="$SOURCES $srcdir/src/misc/windows/*.c"
+            have_misc=yes
+        fi
         # Use the Windows locale APIs.
-        SOURCES="$SOURCES $srcdir/src/locale/windows/*.c"
-        have_locale=yes
-
+        if test x$enable_locale = xyes; then
+            SOURCES="$SOURCES $srcdir/src/locale/windows/*.c"
+            have_locale=yes
+        fi
         # Set up files for the video library
         if test x$enable_video = xyes; then
             AC_DEFINE(SDL_VIDEO_DRIVER_WINDOWS, 1, [ ])
             SOURCES="$SOURCES $srcdir/src/video/windows/*.c"
             have_video=yes
             AC_ARG_ENABLE(render-d3d,
-AS_HELP_STRING([--enable-render-d3d], [enable the Direct3D render driver [[default=yes]]]),
+[AS_HELP_STRING([--enable-render-d3d], [enable the Direct3D render driver [default=yes]])],
                                 , enable_render_d3d=yes)
             if test x$enable_render_d3d = xyes -a x$have_d3d = xyes; then
                 AC_DEFINE(SDL_VIDEO_RENDER_D3D, 1, [ ])
@@ -3792,16 +3979,18 @@ AS_HELP_STRING([--enable-render-d3d], [enable the Direct3D render driver [[defau
         fi
         # Set up files for the joystick library
         if test x$enable_joystick = xyes; then
-            if test x$have_dinput = xyes -o x$have_xinput = xyes; then
+            AC_DEFINE(SDL_JOYSTICK_RAWINPUT, 1, [ ])
+            if test x$have_dinput = xyes -o x$have_xinput = xyes -o x$have_wgi = xyes; then
                 if test x$have_xinput = xyes; then
                     AC_DEFINE(SDL_JOYSTICK_XINPUT, 1, [ ])
                 fi
+                if test x$have_wgi = xyes; then
+                    AC_DEFINE(SDL_JOYSTICK_WGI, 1, [ ])
+                fi
                 if test x$have_dinput = xyes; then
                     AC_DEFINE(SDL_JOYSTICK_DINPUT, 1, [ ])
                     EXTRA_LDFLAGS="$EXTRA_LDFLAGS -ldinput8 -ldxguid -ldxerr8"
                 fi
-            else
-                AC_DEFINE(SDL_JOYSTICK_WINMM, 1, [ ])
             fi
             SOURCES="$SOURCES $srcdir/src/joystick/windows/*.c"
             have_joystick=yes
@@ -3818,6 +4007,10 @@ AS_HELP_STRING([--enable-render-d3d], [enable the Direct3D render driver [[defau
                 have_haptic=yes
             fi
         fi
+        AC_CHECK_HEADER(tpcshrd.h,have_tpcshrd_h=yes)
+        if test x$have_tpcshrd_h = xyes; then
+            AC_DEFINE(HAVE_TPCSHRD_H, 1, [ ])
+        fi
         # Set up files for the sensor library
         AC_CHECK_HEADER(sensorsapi.h,have_winsensors=yes,have_winsensors=no)
         if test x$have_winsensors = xyes; then
@@ -3842,6 +4035,7 @@ AS_HELP_STRING([--enable-render-d3d], [enable the Direct3D render driver [[defau
         fi
         # Set up files for the thread library
         if test x$enable_threads = xyes; then
+            AC_DEFINE(SDL_THREAD_GENERIC_COND_SUFFIX, 1, [ ])
             AC_DEFINE(SDL_THREAD_WINDOWS, 1, [ ])
             SOURCES="$SOURCES $srcdir/src/thread/windows/*.c"
             SOURCES="$SOURCES $srcdir/src/thread/generic/SDL_syscond.c"
@@ -3857,7 +4051,6 @@ AS_HELP_STRING([--enable-render-d3d], [enable the Direct3D render driver [[defau
         if test x$enable_loadso = xyes; then
             AC_DEFINE(SDL_LOADSO_WINDOWS, 1, [ ])
             SOURCES="$SOURCES $srcdir/src/loadso/windows/*.c"
-            have_loadso=yes
         fi
         # Set up the system libraries we need
         if test -f /lib/w32api/libuuid.a; then
@@ -3865,7 +4058,8 @@ AS_HELP_STRING([--enable-render-d3d], [enable the Direct3D render driver [[defau
         else
             LIBUUID=-luuid
         fi
-        EXTRA_LDFLAGS="$EXTRA_LDFLAGS -luser32 -lgdi32 -lwinmm -limm32 -lole32 -loleaut32 -lshell32 -lsetupapi -lversion $LIBUUID -static-libgcc"
+        EXTRA_LDFLAGS="$EXTRA_LDFLAGS -luser32 -lgdi32 -lwinmm -limm32 -lole32 -loleaut32 -lshell32 -lsetupapi -lversion $LIBUUID"
+        BUILD_LDFLAGS="$BUILD_LDFLAGS -Wc,-static-libgcc"
         # The Windows platform requires special setup
         VERSION_SOURCES="$srcdir/src/main/windows/*.rc"
         SDLMAIN_SOURCES="$srcdir/src/main/windows/*.c"
@@ -3881,21 +4075,21 @@ AS_HELP_STRING([--enable-render-d3d], [enable the Direct3D render driver [[defau
             SDL_LIBS="-lcygwin $SDL_LIBS"
         fi
         ;;
-
-    dnl BeOS support removed after SDL 2.0.1. Haiku still works.  --ryan.
+dnl BeOS support removed after SDL 2.0.1. Haiku still works.  --ryan.
     *-*-beos*)
         AC_MSG_ERROR([
 *** BeOS support has been removed as of SDL 2.0.2.
         ])
         ;;
-
     *-*-haiku*)
         ARCH=haiku
         ac_default_prefix=/boot/system
         CheckDummyVideo
+        CheckOffscreenVideo
         CheckDiskAudio
         CheckDummyAudio
         CheckDLOPEN
+        CheckO_CLOEXEC
         CheckHaikuVideo
         CheckHaikuGL
         CheckPTHREAD
@@ -3931,20 +4125,19 @@ AS_HELP_STRING([--enable-render-d3d], [enable the Direct3D render driver [[defau
             SOURCES="$SOURCES $srcdir/src/filesystem/haiku/*.cc"
             have_filesystem=yes
         fi
-
-        SOURCES="$SOURCES $srcdir/src/misc/haiku/*.cc"
-        have_misc=yes
-
+        # Set up files for the misc library
+        if test x$enable_misc = xyes; then
+            SOURCES="$SOURCES $srcdir/src/misc/haiku/*.cc"
+            have_misc=yes
+        fi
         # Set up files for the locale library
-        SOURCES="$SOURCES $srcdir/src/locale/haiku/*.cc"
-        have_locale=yes
-
+        if test x$enable_locale = xyes; then
+            SOURCES="$SOURCES $srcdir/src/locale/haiku/*.cc"
+            have_locale=yes
+        fi
         # The Haiku platform requires special setup.
         SOURCES="$srcdir/src/main/haiku/*.cc $SOURCES"
         EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lroot -lbe -lmedia -lgame -ldevice -ltextencoding"
-        # Haiku's x86 spins use libstdc++.r4.so (for binary compat?), but
-        #  other spins, like x86-64, use a more standard "libstdc++.so.*"
-        AC_CHECK_FILE("/boot/system/lib/libstdc++.r4.so", EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lstdc++.r4", EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lstdc++")
         ;;
     *-ios-*)
         ARCH=ios
@@ -3952,20 +4145,25 @@ AS_HELP_STRING([--enable-render-d3d], [enable the Direct3D render driver [[defau
         CheckVisibilityHidden
         CheckDeclarationAfterStatement
         CheckDummyVideo
+        CheckOffscreenVideo
         CheckDiskAudio
         CheckDummyAudio
         CheckDLOPEN
+        CheckO_CLOEXEC
         CheckMETAL
         CheckVulkan
         CheckPTHREAD
 
-        SOURCES="$SOURCES $srcdir/src/misc/ios/*.m"
-        have_misc=yes
-
+        # Set up files for the misc library
+        if test x$enable_misc = xyes; then
+            SOURCES="$SOURCES $srcdir/src/misc/ios/*.m"
+            have_misc=yes
+        fi
         # Set up files for the locale library
-        SOURCES="$SOURCES $srcdir/src/locale/macosx/*.m"
-        have_locale=yes
-
+        if test x$enable_locale = xyes; then
+            SOURCES="$SOURCES $srcdir/src/locale/macosx/*.m"
+            have_locale=yes
+        fi
         # Set up files for the audio library
         if test x$enable_audio = xyes; then
             AC_DEFINE(SDL_AUDIO_DRIVER_COREAUDIO, 1, [ ])
@@ -4026,6 +4224,8 @@ AS_HELP_STRING([--enable-render-d3d], [enable the Direct3D render driver [[defau
         AC_DEFINE(SDL_VIDEO_RENDER_OGL_ES, 1, [ ])
         AC_DEFINE(SDL_VIDEO_RENDER_OGL_ES2, 1, [ ])
         SOURCES="$SOURCES $srcdir/src/video/uikit/*.m"
+        SUMMARY_video="${SUMMARY_video} uikit"
+        have_video=yes
         EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lm -liconv -lobjc"
         EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,AVFoundation"
         EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,AudioToolbox"
@@ -4055,26 +4255,32 @@ AS_HELP_STRING([--enable-render-d3d], [enable the Direct3D render driver [[defau
         CheckVisibilityHidden
         CheckDeclarationAfterStatement
         CheckDummyVideo
+        CheckOffscreenVideo
         CheckDiskAudio
         CheckDummyAudio
         CheckDLOPEN
+        CheckO_CLOEXEC
         CheckCOCOA
         CheckMETAL
         CheckX11
         CheckMacGL
         CheckMacGLES
-        CheckOpenGLX11
+        CheckGLX
+        CheckOpenGL
         CheckVulkan
         CheckPTHREAD
         CheckHIDAPI
 
-        SOURCES="$SOURCES $srcdir/src/misc/macosx/*.m"
-        have_misc=yes
-
+        # Set up files for the misc library
+        if test x$enable_misc = xyes; then
+            SOURCES="$SOURCES $srcdir/src/misc/macosx/*.m"
+            have_misc=yes
+        fi
         # Set up files for the locale library
-        SOURCES="$SOURCES $srcdir/src/locale/macosx/*.m"
-        have_locale=yes
-
+        if test x$enable_locale = xyes; then
+            SOURCES="$SOURCES $srcdir/src/locale/macosx/*.m"
+            have_locale=yes
+        fi
         # Set up files for the audio library
         if test x$enable_audio = xyes; then
             AC_DEFINE(SDL_AUDIO_DRIVER_COREAUDIO, 1, [ ])
@@ -4138,8 +4344,10 @@ AS_HELP_STRING([--enable-render-d3d], [enable the Direct3D render driver [[defau
         CheckNativeClient
         CheckDummyAudio
         CheckDummyVideo
+        CheckOffscreenVideo
         CheckInputEvents
         CheckPTHREAD
+        CheckO_CLOEXEC
 
         # Set up files for the timer library
         if test x$enable_timers = xyes; then
@@ -4172,12 +4380,20 @@ AS_HELP_STRING([--enable-render-d3d], [enable the Direct3D render driver [[defau
         CheckVisibilityHidden
         CheckDeclarationAfterStatement
         CheckDummyVideo
+        CheckOffscreenVideo
         CheckDiskAudio
         CheckDummyAudio
+        CheckPTHREAD
         CheckDLOPEN
         CheckClockGettime
         CheckEmscriptenGLES
 
+        # Set up files for the misc library
+        if test x$enable_misc = xyes; then
+            SOURCES="$SOURCES $srcdir/src/misc/emscripten/*.c"
+            have_misc=yes
+        fi
+
          # Set up files for the power library
         if test x$enable_power = xyes; then
             AC_DEFINE(SDL_POWER_EMSCRIPTEN, 1, [ ])
@@ -4185,7 +4401,7 @@ AS_HELP_STRING([--enable-render-d3d], [enable the Direct3D render driver [[defau
             have_power=yes
         fi
 
-        # Set up files for the power library
+        # Set up files for the joystick library
         if test x$enable_joystick = xyes; then
             AC_DEFINE(SDL_JOYSTICK_EMSCRIPTEN, 1, [ ])
             SOURCES="$SOURCES $srcdir/src/joystick/emscripten/*.c"
@@ -4205,24 +4421,43 @@ AS_HELP_STRING([--enable-render-d3d], [enable the Direct3D render driver [[defau
             have_timers=yes
         fi
         # Set up files for the locale library
-        SOURCES="$SOURCES $srcdir/src/locale/emscripten/*.c"
-        have_locale=yes
+        if test x$enable_locale = xyes; then
+            SOURCES="$SOURCES $srcdir/src/locale/emscripten/*.c"
+            have_locale=yes
+        fi
         ;;
     *-*-riscos*)
         ARCH=riscos
         CheckVisibilityHidden
         CheckDeclarationAfterStatement
         CheckDummyVideo
+        CheckOffscreenVideo
         CheckDiskAudio
         CheckDummyAudio
         CheckDLOPEN
+        CheckO_CLOEXEC
         CheckOSS
         CheckPTHREAD
         CheckClockGettime
 
-        SOURCES="$SOURCES $srcdir/src/misc/riscos/*.c"
-        have_misc=yes
-
+        # Set up files for the misc library
+        if test x$enable_misc = xyes; then
+            SOURCES="$SOURCES $srcdir/src/misc/riscos/*.c"
+            have_misc=yes
+        fi
+        # Set up files for the video library
+        if test x$enable_video = xyes; then
+            AC_DEFINE(SDL_VIDEO_DRIVER_RISCOS, 1, [ ])
+            SOURCES="$SOURCES $srcdir/src/video/riscos/*.c"
+            have_video=yes
+            SUMMARY_video="${SUMMARY_video} riscos"
+        fi
+        # Set up files for the filesystem library
+        if test x$enable_filesystem = xyes; then
+            AC_DEFINE(SDL_FILESYSTEM_RISCOS, 1, [ ])
+            SOURCES="$SOURCES $srcdir/src/filesystem/riscos/*.c"
+            have_filesystem=yes
+        fi
         # Set up files for the timer library
         if test x$enable_timers = xyes; then
             AC_DEFINE(SDL_TIMER_UNIX, 1, [ ])
@@ -4230,6 +4465,83 @@ AS_HELP_STRING([--enable-render-d3d], [enable the Direct3D render driver [[defau
             have_timers=yes
         fi
         ;;
+    *-*-os2*)
+        ARCH=os2
+        if test "$build" != "$host"; then # cross-compiling
+            # Default cross-compile location
+            ac_default_prefix=/@unixroot/usr/local/cross-tools/$host
+        else
+            # Look for the location of the tools and install there
+            if test "$BUILD_PREFIX" != ""; then
+                ac_default_prefix=$BUILD_PREFIX
+            fi
+        fi
+        enable_static=no # disable static builds
+        EXTRA_CFLAGS="$EXTRA_CFLAGS -DBUILD_SDL -DOS2EMX_PLAIN_CHAR"
+        CheckOS2
+        CheckDeclarationAfterStatement
+        CheckDummyVideo
+        CheckDiskAudio
+        CheckDummyAudio
+        CheckHIDAPI
+
+        # Set up the core platform files
+        SOURCES="$SOURCES $srcdir/src/core/os2/*.c"
+        if test x$ac_cv_func_iconv != xyes -o x$ac_cv_header_iconv_h != xyes; then
+            SOURCES="$SOURCES $srcdir/src/core/os2/geniconv/*.c"
+        fi
+        # Use the Unix locale APIs.
+        if test x$enable_locale = xyes; then
+            SOURCES="$SOURCES $srcdir/src/locale/unix/*.c"
+            have_locale=yes
+        fi
+        # Set up files for the video library
+        if test x$enable_video = xyes; then
+            AC_DEFINE(SDL_VIDEO_DRIVER_OS2, 1, [ ])
+            SOURCES="$SOURCES $srcdir/src/video/os2/*.c"
+            have_video=yes
+            SUMMARY_video="${SUMMARY_video} os/2"
+        fi
+        # Set up files for the audio library
+        if test x$enable_audio = xyes; then
+            AC_DEFINE(SDL_AUDIO_DRIVER_OS2, 1, [ ])
+            SOURCES="$SOURCES $srcdir/src/audio/os2/*.c"
+            have_audio=yes
+            SUMMARY_audio="${SUMMARY_audio} os/2"
+            EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lmmpm2"
+        fi
+        # Set up files for the thread library
+        if test x$enable_threads = xyes; then
+            AC_DEFINE(SDL_THREAD_OS2, 1, [ ])
+            SOURCES="$SOURCES $srcdir/src/thread/os2/*.c"
+            SOURCES="$SOURCES $srcdir/src/thread/generic/SDL_syscond.c"
+            have_threads=yes
+        fi
+        # Set up files for the timer library
+        if test x$enable_timers = xyes; then
+            AC_DEFINE(SDL_TIMER_OS2, 1, [ ])
+            SOURCES="$SOURCES $srcdir/src/timer/os2/*.c"
+            have_timers=yes
+        fi
+        # Set up files for the shared object loading library
+        if test x$enable_loadso = xyes; then
+            AC_DEFINE(SDL_LOADSO_OS2, 1, [ ])
+            SOURCES="$SOURCES $srcdir/src/loadso/os2/*.c"
+            have_loadso=yes
+        fi
+        # Set up files for the filesystem library
+        if test x$enable_filesystem = xyes; then
+            AC_DEFINE(SDL_FILESYSTEM_OS2, 1, [ ])
+            SOURCES="$SOURCES $srcdir/src/filesystem/os2/*.c"
+            have_filesystem=yes
+        fi
+        # Set up files for the joystick library
+        if test x$enable_joystick = xyes; then
+            AC_DEFINE(SDL_JOYSTICK_OS2, 1, [ ])
+            SOURCES="$SOURCES $srcdir/src/joystick/os2/*.c"
+            have_joystick=yes
+        fi
+        ;;
     *)
         AC_MSG_ERROR([
 *** Unsupported host:  Please add to configure.ac
@@ -4243,7 +4555,7 @@ CheckVirtualJoystick
 # Check whether to install sdl2-config
 AC_MSG_CHECKING(whether to install sdl2-config)
 AC_ARG_ENABLE([sdl2-config],
-    AS_HELP_STRING([--enable-sdl2-config], [Install sdl2-config [default=yes]]),
+    [AS_HELP_STRING([--enable-sdl2-config],[Install sdl2-config [default=yes]])],
     [case "${enableval}" in
         yes) enable_sdl2_config="TRUE" ;;
         no) enable_sdl2_config="FALSE" ;;
@@ -4258,10 +4570,28 @@ AC_SUBST([INSTALL_SDL2_CONFIG], [$enable_sdl2_config])
 
 # Verify that we have all the platform specific files we need
 
+if test x$have_audio != xyes; then
+    if test x$enable_audio = xyes; then
+        AC_DEFINE(SDL_AUDIO_DRIVER_DUMMY, 1, [ ])
+    fi
+    SOURCES="$SOURCES $srcdir/src/audio/dummy/*.c"
+fi
+if test x$have_video != xyes; then
+    if test x$enable_video = xyes; then
+        AC_DEFINE(SDL_VIDEO_DRIVER_DUMMY, 1, [ ])
+    fi
+    SOURCES="$SOURCES $srcdir/src/video/dummy/*.c"
+fi
 if test x$have_misc != xyes; then
+    if test x$enable_misc = xyes; then
+        AC_DEFINE(SDL_MISC_DUMMY, 1, [ ])
+    fi
     SOURCES="$SOURCES $srcdir/src/misc/dummy/*.c"
 fi
 if test x$have_locale != xyes; then
+    if test x$enable_locale = xyes; then
+        AC_DEFINE(SDL_LOCALE_DUMMY, 1, [ ])
+    fi
     SOURCES="$SOURCES $srcdir/src/locale/dummy/*.c"
 fi
 if test x$have_joystick != xyes; then
@@ -4290,19 +4620,19 @@ if test x$have_threads != xyes; then
 fi
 if test x$have_timers != xyes; then
     if test x$enable_timers = xyes; then
-        AC_DEFINE(SDL_TIMERS_DISABLED, 1, [ ])
+        AC_DEFINE(SDL_TIMER_DUMMY, 1, [ ])
     fi
     SOURCES="$SOURCES $srcdir/src/timer/dummy/*.c"
 fi
 if test x$have_filesystem != xyes; then
     if test x$enable_filesystem = xyes; then
-        AC_DEFINE(SDL_FILESYSTEM_DISABLED, 1, [ ])
+        AC_DEFINE(SDL_FILESYSTEM_DUMMY, 1, [ ])
     fi
     SOURCES="$SOURCES $srcdir/src/filesystem/dummy/*.c"
 fi
 if test x$have_loadso != xyes; then
     if test x$enable_loadso = xyes; then
-        AC_DEFINE(SDL_LOADSO_DISABLED, 1, [ ])
+        AC_DEFINE(SDL_LOADSO_DUMMY, 1, [ ])
     fi
     SOURCES="$SOURCES $srcdir/src/loadso/dummy/*.c"
 fi
@@ -4312,27 +4642,28 @@ fi
 SDLTEST_SOURCES="$srcdir/src/test/*.c"
 
 if test x$video_wayland = xyes; then
-    WAYLAND_PROTOCOLS=`cd $srcdir/wayland-protocols ; for p in *.xml ; do echo -n "\$p" |sed 's,\\.xml\$, ,g' ; done`
-    WAYLAND_PROTOCOLS_SOURCES=`for p in $WAYLAND_PROTOCOLS ; do echo -n "\\$(gen)/\$p-protocol.c " ; done`
-    WAYLAND_PROTOCOLS_HEADERS=`for p in $WAYLAND_PROTOCOLS ; do echo -n "\\$(gen)/\$p-client-protocol.h " ; done`
+    WAYLAND_PROTOCOLS=`cd $srcdir/wayland-protocols ; for p in *.xml ; do printf '%s' "\$p" |sed 's,\\.xml\$, ,g' ; done`
+    WAYLAND_PROTOCOLS_SOURCES=`for p in $WAYLAND_PROTOCOLS ; do printf '%s' "\\$(gen)/\$p-protocol.c " ; done`
+    WAYLAND_PROTOCOLS_HEADERS=`for p in $WAYLAND_PROTOCOLS ; do printf '%s' "\\$(gen)/\$p-client-protocol.h " ; done`
     GEN_SOURCES="$GEN_SOURCES $WAYLAND_PROTOCOLS_SOURCES"
     GEN_HEADERS="$GEN_HEADERS $WAYLAND_PROTOCOLS_HEADERS"
 
     WAYLAND_PROTOCOLS_DEPENDS=`for p in $WAYLAND_PROTOCOLS ; do\
         echo ;\
-        echo "\\$(gen)/\$p-client-protocol.h: \\$(srcdir)/wayland-protocols/\$p.xml" ;\
-        echo "	@\\$(SHELL) \\$(auxdir)/mkinstalldirs \\$(gen)" ;\
-        echo "	\\$(RUN_CMD_GEN)\\$(WAYLAND_SCANNER) client-header \\$< \\$@" ;\
+        printf '%s\n' "\\$(gen)/\$p-client-protocol.h: \\$(srcdir)/wayland-protocols/\$p.xml" ;\
+        printf '%s\n' "	@\\$(SHELL) \\$(auxdir)/mkinstalldirs \\$(gen)" ;\
+        printf '%s\n' "	\\$(RUN_CMD_GEN)\\$(WAYLAND_SCANNER) client-header \\$< \\$@" ;\
         echo ;\
-        echo "\\$(gen)/\$p-protocol.c: \\$(srcdir)/wayland-protocols/\$p.xml" ;\
-        echo "	@\\$(SHELL) \\$(auxdir)/mkinstalldirs \\$(gen)" ;\
-        echo "	\\$(RUN_CMD_GEN)\\$(WAYLAND_SCANNER) code \\$< \\$@" ;\
+        printf '%s\n' "\\$(gen)/\$p-protocol.c: \\$(srcdir)/wayland-protocols/\$p.xml" ;\
+        printf '%s\n' "	@\\$(SHELL) \\$(auxdir)/mkinstalldirs \\$(gen)" ;\
+        printf '%s\n' "	\\$(RUN_CMD_GEN)\\$(WAYLAND_SCANNER) \\$(WAYLAND_SCANNER_CODE_MODE) \\$< \\$@" ;\
         echo ;\
-        echo "\\$(objects)/\$p-protocol.lo: \\$(gen)/\$p-protocol.c \\$(gen)/\$p-client-protocol.h" ;\
-        echo "	\\$(RUN_CMD_CC)\\$(LIBTOOL) --tag=CC --mode=compile \\$(CC) \\$(CFLAGS) \\$(EXTRA_CFLAGS) $DEPENDENCY_TRACKING_OPTIONS -c \\$< -o \\$@" ;\
+        printf '%s\n' "\\$(objects)/\$p-protocol.lo: \\$(gen)/\$p-protocol.c \\$(gen)/\$p-client-protocol.h" ;\
+        printf '%s\n' "	@\\$(SHELL) \\$(auxdir)/mkinstalldirs \\$(objects)" ;\
+        printf '%s\n' "	\\$(RUN_CMD_CC)\\$(LIBTOOL) --tag=CC --mode=compile \\$(CC) \\$(CFLAGS) \\$(EXTRA_CFLAGS) $DEPENDENCY_TRACKING_OPTIONS -c \\$< -o \\$@" ;\
         done ;\
         echo ;\
-        for s in $WAYLAND_SOURCES ; do echo -n "\$s:" ; for p in $WAYLAND_PROTOCOLS ; do echo -n " \\$(gen)/\$p-client-protocol.h" ; done ; echo ; done ; echo`
+        for s in $WAYLAND_SOURCES ; do printf '%s' "\$s:" ; printf ' \$(gen)/%s-client-protocol.h' $WAYLAND_PROTOCOLS ; echo ; done ; echo`
 fi
 
 OBJECTS=`echo $SOURCES`
@@ -4377,12 +4708,10 @@ if test "x$enable_rpath" = "xyes" -a "x$enable_shared" = "xyes"; then
     have_enable_new_dtags=no
     save_LDFLAGS="$LDFLAGS"
     LDFLAGS="$LDFLAGS -Wl,--enable-new-dtags"
-    AC_TRY_LINK([
-    ],[
-    ],[
+    AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])], [
     have_enable_new_dtags=yes
     SDL_RLD_FLAGS="$SDL_RLD_FLAGS -Wl,--enable-new-dtags"
-    ])
+    ],[])
     LDFLAGS="$save_LDFLAGS"
     AC_MSG_RESULT($have_enable_new_dtags)
   fi
@@ -4401,12 +4730,12 @@ AC_SUBST(SDL_LIBS)
 AC_SUBST(SDL_STATIC_LIBS)
 AC_SUBST(SDL_RLD_FLAGS)
 if test x$enable_shared = xyes; then
-    PKG_CONFIG_LIBS_PRIV="
+    PKGCONFIG_LIBS_PRIV="
 Libs.private:"
     ENABLE_SHARED_TRUE=
     ENABLE_SHARED_FALSE="#"
 else
-    PKG_CONFIG_LIBS_PRIV=
+    PKGCONFIG_LIBS_PRIV=
     ENABLE_SHARED_TRUE="#"
     ENABLE_SHARED_FALSE=
 fi
@@ -4417,7 +4746,7 @@ else
     ENABLE_STATIC_TRUE="#"
     ENABLE_STATIC_FALSE=
 fi
-AC_SUBST(PKG_CONFIG_LIBS_PRIV)
+AC_SUBST(PKGCONFIG_LIBS_PRIV)
 AC_SUBST(ENABLE_SHARED_TRUE)
 AC_SUBST(ENABLE_SHARED_FALSE)
 AC_SUBST(ENABLE_STATIC_TRUE)
@@ -4437,6 +4766,7 @@ AC_SUBST(EXTRA_CFLAGS)
 AC_SUBST(BUILD_LDFLAGS)
 AC_SUBST(EXTRA_LDFLAGS)
 AC_SUBST(WAYLAND_SCANNER)
+AC_SUBST(WAYLAND_SCANNER_CODE_MODE)
 
 cat >Makefile.rules <<__EOF__
 
@@ -4515,7 +4845,6 @@ if test x$WARN_ABOUT_ARM_SIMD_ASM_MIT = xyes; then
     SUMMARY="${SUMMARY}configure script with:\n"
     SUMMARY="${SUMMARY}\n    --disable-arm-simd\n"
 fi
-
 if test x$WARN_ABOUT_ARM_NEON_ASM_MIT = xyes; then
     SUMMARY="${SUMMARY}\nSDL is being built with ARM NEON optimizations, which\n"
     SUMMARY="${SUMMARY}uses code licensed under the MIT license. If this is a\n"
@@ -4524,6 +4853,6 @@ if test x$WARN_ABOUT_ARM_NEON_ASM_MIT = xyes; then
     SUMMARY="${SUMMARY}\n    --disable-arm-neon\n"
 fi
 
-AC_CONFIG_COMMANDS([summary], [echo -en "$SUMMARY"], [SUMMARY="$SUMMARY"])
+AC_CONFIG_COMMANDS([summary], [printf "$SUMMARY"], [SUMMARY="$SUMMARY"])
 
 AC_OUTPUT
diff --git a/Engine/lib/sdl/debian/changelog b/Engine/lib/sdl/debian/changelog
deleted file mode 100644
index 2a8c1688e..000000000
--- a/Engine/lib/sdl/debian/changelog
+++ /dev/null
@@ -1,150 +0,0 @@
-libsdl2 (2.0.14) UNRELEASED; urgency=low
-
-  * Updated SDL to version 2.0.14
-
- -- Sam Lantinga <slouken@libsdl.org>  Tue, 8 Dec 2020 17:54:33 -0800
-
-libsdl2 (2.0.13) UNRELEASED; urgency=low
-
-  * Updated SDL to version 2.0.13 for development builds
-
- -- Sam Lantinga <slouken@libsdl.org>  Tue, 10 Mar 2020 18:24:22 -0800
-
-libsdl2 (2.0.12) UNRELEASED; urgency=low
-
-  * Updated SDL to version 2.0.12
-
- -- Sam Lantinga <slouken@libsdl.org>  Sun, 1 Mar 2020 14:57:07 -0800
-
-libsdl2 (2.0.11) UNRELEASED; urgency=low
-
-  * Updated SDL to version 2.0.11 for development builds
-
- -- Sam Lantinga <slouken@libsdl.org>  Sun, 22 Sep 2019 10:33:03 -0800
-
-libsdl2 (2.0.10) UNRELEASED; urgency=low
-
-  * Updated SDL to version 2.0.10
-
- -- Sam Lantinga <slouken@libsdl.org>  Mon, 17 Jun 2019 08:48:47 -0800
-
-libsdl2 (2.0.9) UNRELEASED; urgency=low
-
-  * Updated SDL to version 2.0.9
-
- -- Sam Lantinga <slouken@libsdl.org>  Wed, 26 Sep 2018 10:02:21 -0800
-
-libsdl2 (2.0.8) UNRELEASED; urgency=low
-
-  * Updated SDL to version 2.0.8
-
- -- Sam Lantinga <slouken@libsdl.org>  Sat, 4 Nov 2017 21:21:53 -0800
-
-libsdl2 (2.0.7) UNRELEASED; urgency=low
-
-  * Updated SDL to version 2.0.7
-
- -- Sam Lantinga <slouken@libsdl.org>  Thu, 12 Oct 2017 08:01:16 -0800
-
-libsdl2 (2.0.6) UNRELEASED; urgency=low
-
-  * Updated SDL to version 2.0.6
-
- -- Sam Lantinga <slouken@libsdl.org>  Sat, 9 Sep 2017 07:29:36 -0800
-
-libsdl2 (2.0.5) UNRELEASED; urgency=low
-
-  * Updated SDL to version 2.0.5
-
- -- Sam Lantinga <slouken@libsdl.org>  Mon, 28 Nov 2016 07:32:52 -0800
-
-libsdl2 (2.0.4) UNRELEASED; urgency=low
-
-  * Updated SDL to version 2.0.4
-
- -- Sam Lantinga <slouken@libsdl.org>  Thu, 07 Jan 2016 11:02:39 -0800
-
-libsdl2 (2.0.3) UNRELEASED; urgency=low
-
-  * Updated SDL to version 2.0.3
-
- -- Sam Lantinga <slouken@libsdl.org>  Sun, 9 Mar 2014 10:35:54 -0800
-
-libsdl2 (2.0.2) UNRELEASED; urgency=low
-
-  * Updated SDL to version 2.0.2
-
- -- Sam Lantinga <slouken@libsdl.org>  Sun, 9 Feb 2014 2:55:59 -0800
-
-libsdl2 (2.0.1) UNRELEASED; urgency=low
-
-  * Updated SDL to version 2.0.1
-
- -- Sam Lantinga <slouken@libsdl.org>  Wed, 23 Oct 2013 16:31:38 -0800
-
-libsdl2 (2.0.0) UNRELEASED; urgency=low
-
-  * SDL is now a native debian package.
-  * Removed udeb package
-  * Disabled DirectFB support by default, to avoid runtime dependencies
-
- -- Sam Lantinga <slouken@libsdl.org>  Fri, 15 Feb 2013 08:55:04 -0800
-
-libsdl2 (2.0.0~20130127-1) UNRELEASED; urgency=low
-
-  * New upstream snapshot.
-
- -- Sam Hocevar <sho@debian.org>  Wed, 30 Jan 2013 23:01:12 +0100
-
-libsdl2 (2.0.0~20130103-1) unstable; urgency=low
-
-  [ Manuel A. Fernandez Montecelo ]
-  * debian/control:
-    - Updating maintainers/permissions:
-      - Add myself and Felix Geyer
-    - Update Build-Depends:
-      - Remove a few obsolete items
-      - Add items added lately to libsdl1.2, such as libts (touch screen)
-        support
-    - Add "libsdl2-dbg", analog to libsdl1.2-dbg
-    - Change "XC-Package-Type: udeb" to "Package-Type"
-  * debian/compat: set level 9
-  * debian/source/format: Set to "3.0 (quilt)"
-    - Remove README.source, not needed with new format
-  * debian/sdl2-config.1: Fix typo, "progams"->"programs"
-  * debian/libsdl2-dev.install:
-    - Remove "usr/lib/*/*.la", discouraged
-    - Add man pages: "usr/share/man/man3/*"
-  * debian/libsdl2-dev.manpages: add file to install local "sdl2-config.1"
-  * debian/sources: Removed, possible obsolete file from long ago?
-  * debian/copyright:
-    - Upstream updated to zlib/libpng
-    - Copyright-file format conversion to 1.0
-    - Complete revamp and detailed research about copyright and licenses used,
-      it's very messy but hopefully complete
-
-  [ Felix Geyer ]
-  * Simplify debian/rules by using dh(1).
-
- -- Manuel A. Fernandez Montecelo <manuel.montezelo@gmail.com>  Sun, 27 Jan 2013 16:40:49 +0100
-
-libsdl2 (2.0~20120220c-1) experimental; urgency=low
-
-  * Upstream version was renamed to 2.0 (Closes: #669367).
-  * New upstream snapshot (Closes: #671506).
-  * This package no longer conflicts with libsdl-1.2.
-  * debian/rules: add multiarch support (Closes: #669364).
-
-  * debian/patches/fix_joystick_misc_axes.diff: fix a joystick remapping
-    bug causing some axes to malfunction.
-  * debian/patches/external_header_paths.diff: provide additional CFLAGS
-    so that headers such as SDL_syswm.h can be included (Closes: #669363).
-
- -- Sam Hocevar <sho@debian.org>  Thu, 17 May 2012 19:03:59 +0200
-
-libsdl-1.3 (1.3.0~20111204-1) experimental; urgency=low
-
-  * Initial upload from upstream snapshot.
-
- -- Sam Hocevar <sho@debian.org>  Sun, 04 Dec 2011 14:35:05 +0100
-
diff --git a/Engine/lib/sdl/debian/compat b/Engine/lib/sdl/debian/compat
deleted file mode 100644
index ec635144f..000000000
--- a/Engine/lib/sdl/debian/compat
+++ /dev/null
@@ -1 +0,0 @@
-9
diff --git a/Engine/lib/sdl/debian/control b/Engine/lib/sdl/debian/control
deleted file mode 100644
index a3411335a..000000000
--- a/Engine/lib/sdl/debian/control
+++ /dev/null
@@ -1,76 +0,0 @@
-Source: libsdl2
-Priority: optional
-Section: libs
-Maintainer: Debian SDL packages maintainers <pkg-sdl-maintainers@lists.alioth.debian.org>
-Uploaders: Barry deFreese <bdefreese@debian.org>,
-           Sam Hocevar <sho@debian.org>,
-           Manuel A. Fernandez Montecelo <manuel.montezelo@gmail.com>,
-           Felix Geyer <fgeyer@debian.org>,
-           Sam Lantinga <slouken@libsdl.org>
-Standards-Version: 3.9.3
-Build-Depends: debhelper (>= 9),
-               dh-autoreconf,
-               dpkg-dev (>= 1.16.1~),
-               fcitx-libs-dev [linux-any],
-               libasound2-dev [linux-any],
-               libgl1-mesa-dev,
-               libpulse-dev,
-               libudev-dev [linux-any],
-               libdbus-1-dev [linux-any],
-               libibus-1.0-dev[linux-any],
-               libusb2-dev [kfreebsd-any],
-               libusbhid-dev [kfreebsd-any],
-               libx11-dev,
-               libxcursor-dev,
-               libxext-dev,
-               libxi-dev,
-               libxinerama-dev,
-               libxrandr-dev,
-               libxss-dev,
-               libxxf86vm-dev
-Homepage: http://www.libsdl.org/
-
-Package: libsdl2
-Architecture: any
-Multi-Arch: same
-Pre-Depends: ${misc:Pre-Depends}
-Depends: ${misc:Depends},
-         ${shlibs:Depends},
-         libudev0 [linux-any],
-         libdbus-1-3 [linux-any]
-Conflicts: libsdl-1.3-0
-Replaces: libsdl-1.3-0
-Description: Simple DirectMedia Layer
- SDL is a library that allows programs portable low level access to
- a video framebuffer, audio output, mouse, and keyboard.
- .
- This package contains the shared library, compiled with X11 graphics drivers and OSS, ALSA and PulseAudio sound drivers.
-
-Package: libsdl2-dev
-Section: libdevel
-Architecture: any
-Multi-Arch: same
-Depends: ${misc:Depends},
-         libsdl2 (= ${binary:Version}),
-         libc6-dev,
-         libgl1-mesa-dev
-Conflicts: libsdl-1.3-dev
-Replaces: libsdl-1.3-dev
-Description: Simple DirectMedia Layer development files
- SDL is a library that allows programs portable low level access to a video
- framebuffer, audio output, mouse, and keyboard.
- .
- This package contains files needed if you wish to use the SDL library in your own programs.
-
-Package: libsdl2-dbg
-Priority: extra
-Section: debug
-Architecture: any
-Multi-Arch: same
-Depends: ${misc:Depends},
-         libsdl2 (= ${binary:Version}),
-Description: Simple DirectMedia Layer debug files
- SDL is a library that allows programs portable low level access to a video
- framebuffer, audio output, mouse, and keyboard.
- .
- This package contains the debug symbols for the SDL library.
diff --git a/Engine/lib/sdl/debian/copyright b/Engine/lib/sdl/debian/copyright
deleted file mode 100644
index d46c5e81b..000000000
--- a/Engine/lib/sdl/debian/copyright
+++ /dev/null
@@ -1,351 +0,0 @@
-Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
-Upstream-Name: SDL
-Upstream-Contact: Sam Lantinga <slouken@libsdl.org>
-Source: http://www.libsdl.org/
-
-Files: *
-Copyright: 1997-2020 Sam Lantinga <slouken@libsdl.org>
-License: zlib/libpng
-
-Files: src/libm/*
-Copyright: 1993 by Sun Microsystems, Inc. All rights reserved.
-License: SunPro
-
-Files: src/main/windows/SDL_windows_main.c
-Copyright: 2020 Sam Lantinga
-License: PublicDomain_Sam_Lantinga
-Comment: SDL_main.c, placed in the public domain by Sam Lantinga  4/13/98
-
-Files: src/render/mmx.h
-Copyright: 1997-99 by H. Dietz and R. Fisher
-License: zlib/libpng
-Comment:
-  Copyright but no mention to license.
-  .
-  Included since long ago with SDL (and its Debian package) under directory
-  src/video/mmx.h
-
-Files: src/render/SDL_yuv_sw.c
-Copyright: 1995 Erik Corry
-           1995 The Regents of the University of California
-           1995 Brown University
-License: BrownUn_UnCalifornia_ErikCorry
-
-Files: src/test/SDL_test_md5.c
-Copyright: 1997-2020 Sam Lantinga <slouken@libsdl.org>
-           1990 RSA Data Security, Inc.
-License: zlib/libpng and RSA_Data_Security
-
-Files: src/thread/windows/win_ce_semaphore.c
-Copyright: 1998, Johnson M. Hart (with corrections 2001 by Rainer Loritz)
-License: Johnson_M._Hart
-
-Files: src/video/x11/imKStoUCS.c
-       src/video/x11/imKStoUCS.h
-Copyright: 1994-2003 The XFree86 Project, Inc.
-License: MIT/X11
-
-Files: test/testhaptic.c
-Copyright: 1997-2020 Sam Lantinga <slouken@libsdl.org>
-           2008 Edgar Simo Serra
-License: BSD_3_clause
-
-Files: test/testrumble.c
-Copyright: 1997-2020 Sam Lantinga <slouken@libsdl.org>
-           2011 Edgar Simo Serra
-License: BSD_3_clause
-
-Files: test/shapes/*
-Copyright: none
-License: zlib/libpng
-Comment: No specific information about the images
-
-Files: Xcode/TemplatesForXcode*/*/main.c
-Copyright: none
-License: zlib/libpng
-Comment: SDL files, no copyright or license notice
-
-Files: Xcode/TemplatesForXcode*/*/atlantis/*
-Copyright: 1993, 1994, Silicon Graphics, Inc.
-License: SGI_atlantis
-
-Files: Xcode/TemplatesForXcode*/*/atlantis/atlantis.c
-Copyright: 1994 Mark J. Kilgard
-           1993, 1994, Silicon Graphics, Inc.
-License: SGI_atlantis
-Comment: See license for full copyright notice, this one is the same except for
- the additional copyright holder
-
-Files: Xcode/SDLTest/sdlcommon_prefix.h
-Copyright: 2003 Darrell Walisser
-License: zlib/libpng
-Comment:
- Created by Darrell Walisser on Wed Aug 06 2003.
- Copyright (c) 2003 __MyCompanyName__. All rights reserved.
-
-Files: debian/*
-Copyright: 2011-2012, Manuel A. Fernandez Montecelo <manuel.montezelo@gmail.com>
-           2011-2012, Felix Geyer <debfx-pkg@fobos.de>
-           2011, Roman Vasiyarov <rvasiyarov@gmail.com>
-           2010, Jon Dowland <jmtd@debian.org>
-           2009, Barry deFreese <bdefreese@debian.org>
-           2007-2008, Aurelien Jarno <aurel32@debian.org>
-           2007-2008, Sam Hocevar (Debian packages) <sam+deb@zoy.org>
-           2002-2007, Josselin Mouette <joss@debian.org>
-           2001, Christian T. Steigies <cts@debian.org>
-           2001, Branden Robinson <branden@debian.org>
-License: LGPL-2.1+
-
-
-License: zlib/libpng
- This software is provided 'as-is', without any express or implied
- warranty.  In no event will the authors be held liable for any damages
- arising from the use of this software.
- .
- Permission is granted to anyone to use this software for any purpose,
- including commercial applications, and to alter it and redistribute it
- freely, subject to the following restrictions:
- .
- 1. The origin of this software must not be misrepresented; you must not
-    claim that you wrote the original software. If you use this software
-    in a product, an acknowledgment in the product documentation would be
-    appreciated but is not required.
- 2. Altered source versions must be plainly marked as such, and must not be
-    misrepresented as being the original software.
- 3. This notice may not be removed or altered from any source distribution.
-
-License: LGPL-2.1+
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU Lesser General Public License as published by
- the Free Software Foundation; either version 2.1 of the License, or (at
- your option) any later version.
- .
- On Debian systems, the complete text of version 2.1 of the GNU Lesser
- Public License can be found in '/usr/share/common-licenses/LGPL-2.1'.
-
-License: MIT/X11
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is fur-
- nished to do so, subject to the following conditions:
- .
- The above copyright notice and this permission notice shall be included in
- all copies or substantial portions of the Software.
- .
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FIT-
- NESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
- XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
- IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CON-
- NECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- .
- Except as contained in this notice, the name of the XFree86 Project shall not
- be used in advertising or otherwise to promote the sale, use or other deal-
- ings in this Software without prior written authorization from the XFree86
- Project.
-
-License: BSD_3_clause
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-     * Redistributions of source code must retain the above copyright
-       notice, this list of conditions and the following disclaimer.
-     * Redistributions in binary form must reproduce the above copyright
-       notice, this list of conditions and the following disclaimer in the
-       documentation and/or other materials provided with the distribution.
-     * Neither the name of the LibQxt project nor the
-       names of its contributors may be used to endorse or promote products
-       derived from this software without specific prior written permission.
- .
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
- DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-Comment:
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
-  .
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-  .
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely.
-  .
-  .
-  Copyright (c) 2011, Edgar Simo Serra
-  All rights reserved.
-  .
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
-  .
-    * Redistributions of source code must retain the above copyright notice,
-      this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright notice,
-      this list of conditions and the following disclaimer in the documentation
-      and/or other materials provided with the distribution.
-    * Neither the name of the Simple Directmedia Layer (SDL) nor the names of
-      its contributors may be used to endorse or promote products derived from
-      this software without specific prior written permission.
-  .
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
-  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-License: BrownUn_UnCalifornia_ErikCorry
- /* This code was derived from code carrying the following copyright notices:
-  * Copyright (c) 1995 The Regents of the University of California.
-  * All rights reserved.
-  *
-  * Permission to use, copy, modify, and distribute this software and its
-  * documentation for any purpose, without fee, and without written agreement is
-  * hereby granted, provided that the above copyright notice and the following
-  * two paragraphs appear in all copies of this software.
-  *
-  * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
-  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
-  * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
-  * CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
-  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
-  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
-  * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
-  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
-  *
-  * Copyright (c) 1995 Erik Corry
-  * All rights reserved.
-  *
-  * Permission to use, copy, modify, and distribute this software and its
-  * documentation for any purpose, without fee, and without written agreement is
-  * hereby granted, provided that the above copyright notice and the following
-  * two paragraphs appear in all copies of this software.
-  *
-  * IN NO EVENT SHALL ERIK CORRY BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
-  * SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF
-  * THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF ERIK CORRY HAS BEEN ADVISED
-  * OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  * ERIK CORRY SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT
-  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
-  * PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS"
-  * BASIS, AND ERIK CORRY HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT,
-  * UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
-  *
-  * Portions of this software Copyright (c) 1995 Brown University.
-  * All rights reserved.
-  *
-  * Permission to use, copy, modify, and distribute this software and its
-  * documentation for any purpose, without fee, and without written agreement
-  * is hereby granted, provided that the above copyright notice and the
-  * following two paragraphs appear in all copies of this software.
-  *
-  * IN NO EVENT SHALL BROWN UNIVERSITY BE LIABLE TO ANY PARTY FOR
-  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
-  * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF BROWN
-  * UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  * BROWN UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT
-  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
-  * PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS"
-  * BASIS, AND BROWN UNIVERSITY HAS NO OBLIGATION TO PROVIDE MAINTENANCE,
-  * SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
-  */
-
-License: Johnson_M._Hart
-  Permission is granted for any and all use providing that this
-  copyright is properly acknowledged.
-  There are no assurances of suitability for any use whatsoever.
-
-License: SunPro
-  Developed at SunPro, a Sun Microsystems, Inc. business.
-  Permission to use, copy, modify, and distribute this
-  software is freely granted, provided that this notice
-  is preserved.
-
-License: PublicDomain_Sam_Lantinga
- Placed in the public domain by Sam Lantinga  4/13/98
-
-License: PublicDomain_Edgar_Simo
- Written by Edgar Simo "bobbens"
- .
- Released under Public Domain.
-
-License: RSA_Data_Security
- ***********************************************************************
- ** utl_md5.c -- the source code for MD5 routines                      **
- ** RSA Data Security, Inc. MD5 Message-Digest Algorithm              **
- ** Created: 2/17/90 RLR                                              **
- ** Revised: 1/91 SRD,AJ,BSK,JT Reference C ver., 7/10 constant corr. **
- ***********************************************************************
- ***********************************************************************
- ** Copyright (C) 1990, RSA Data Security, Inc. All rights reserved.  **
- **                                                                   **
- ** License to copy and use this software is granted provided that    **
- ** it is identified as the "RSA Data Security, Inc. MD5 Message-     **
- ** Digest Algorithm" in all material mentioning or referencing this  **
- ** software or this function.                                        **
- **                                                                   **
- ** License is also granted to make and use derivative works          **
- ** provided that such works are identified as "derived from the RSA  **
- ** Data Security, Inc. MD5 Message-Digest Algorithm" in all          **
- ** material mentioning or referencing the derived work.              **
- **                                                                   **
- ** RSA Data Security, Inc. makes no representations concerning       **
- ** either the merchantability of this software or the suitability    **
- ** of this software for any particular purpose.  It is provided "as  **
- ** is" without express or implied warranty of any kind.              **
- **                                                                   **
- ** These notices must be retained in any copies of any part of this  **
- ** documentation and/or software.                                    **
- ***********************************************************************
-
-License: SGI_atlantis
- (c) Copyright 1993, 1994, Silicon Graphics, Inc.
- ALL RIGHTS RESERVED
- Permission to use, copy, modify, and distribute this software for
- any purpose and without fee is hereby granted, provided that the above
- copyright notice appear in all copies and that both the copyright notice
- and this permission notice appear in supporting documentation, and that
- the name of Silicon Graphics, Inc. not be used in advertising
- or publicity pertaining to distribution of the software without specific,
- written prior permission.
- .
- THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS"
- AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE,
- INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR
- FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL SILICON
- GRAPHICS, INC.  BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT,
- SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY
- KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION,
- LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF
- THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC.  HAS BEEN
- ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON
- ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE
- POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE.
- .
- US Government Users Restricted Rights
- Use, duplication, or disclosure by the Government is subject to
- restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
- (c)(1)(ii) of the Rights in Technical Data and Computer Software
- clause at DFARS 252.227-7013 and/or in similar or successor
- clauses in the FAR or the DOD or NASA FAR Supplement.
- Unpublished-- rights reserved under the copyright laws of the
- United States.  Contractor/manufacturer is Silicon Graphics,
- Inc., 2011 N.  Shoreline Blvd., Mountain View, CA 94039-7311.
- .
- OpenGL(TM) is a trademark of Silicon Graphics, Inc.
diff --git a/Engine/lib/sdl/debian/docs b/Engine/lib/sdl/debian/docs
deleted file mode 100644
index 2e2e9c4ee..000000000
--- a/Engine/lib/sdl/debian/docs
+++ /dev/null
@@ -1,4 +0,0 @@
-BUGS.txt
-CREDITS.txt
-README.txt
-README-SDL.txt
diff --git a/Engine/lib/sdl/debian/libsdl2-dev.install b/Engine/lib/sdl/debian/libsdl2-dev.install
deleted file mode 100644
index 40a9754c7..000000000
--- a/Engine/lib/sdl/debian/libsdl2-dev.install
+++ /dev/null
@@ -1,9 +0,0 @@
-usr/bin/sdl2-config
-usr/include/SDL2
-usr/lib/*/*.a
-usr/lib/*/*.la
-usr/lib/*/*.so
-usr/lib/*/pkgconfig/sdl2.pc
-usr/lib/*/cmake/SDL2/sdl2-config.cmake
-usr/lib/*/cmake/SDL2/sdl2-config-version.cmake
-usr/share/aclocal/sdl2.m4
diff --git a/Engine/lib/sdl/debian/libsdl2-dev.manpages b/Engine/lib/sdl/debian/libsdl2-dev.manpages
deleted file mode 100644
index 150752ce9..000000000
--- a/Engine/lib/sdl/debian/libsdl2-dev.manpages
+++ /dev/null
@@ -1 +0,0 @@
-debian/sdl2-config.1
diff --git a/Engine/lib/sdl/debian/libsdl2.install b/Engine/lib/sdl/debian/libsdl2.install
deleted file mode 100644
index e4193c74c..000000000
--- a/Engine/lib/sdl/debian/libsdl2.install
+++ /dev/null
@@ -1 +0,0 @@
-usr/lib/*/libSDL2-2.0.so.0*
diff --git a/Engine/lib/sdl/debian/rules b/Engine/lib/sdl/debian/rules
deleted file mode 100755
index b065aca0f..000000000
--- a/Engine/lib/sdl/debian/rules
+++ /dev/null
@@ -1,54 +0,0 @@
-#!/usr/bin/make -f
-
-DEB_HOST_ARCH_CPU ?= $(shell dpkg-architecture -qDEB_HOST_ARCH_CPU)
-DEB_HOST_MULTIARCH ?= $(shell dpkg-architecture -qDEB_HOST_MULTIARCH)
-
-confflags = --disable-rpath --disable-video-directfb \
-            --disable-nas --disable-esd --disable-arts
-
-# These flags can be used to create a package directly linking with external libraries and having the appropriate package dependencies
-#confflags += --disable-alsa-shared
-#confflags += --disable-arts-shared
-#confflags += --disable-directfb-shared
-#confflags += --disable-esd-shared
-#confflags += --disable-fusionsound-shared
-#confflags += --disable-jack-shared
-#confflags += --disable-kmsdrm-shared
-#confflags += --disable-libsamplerate-shared
-#confflags += --disable-nas-shared
-#confflags += --disable-pulseaudio-shared
-#confflags += --disable-sndio-shared
-#confflags += --disable-wayland-shared
-#confflags += --disable-x11-shared
-
-%:
-	dh $@ --parallel
-
-override_dh_auto_configure:
-	dh_auto_configure -Bbuilddir/all -- $(confflags)
-
-override_dh_auto_build:
-	dh_auto_build -Bbuilddir/all
-	tar czf debian/examples.tar.gz test
-
-override_dh_auto_install:
-	dh_auto_install -Bbuilddir/all
-
-override_dh_auto_clean:
-	dh_auto_clean -Bbuilddir/all
-	rm -f debian/examples.tar.gz
-
-override_dh_install:
-	dh_install --remaining-packages --fail-missing -XlibSDL2.la
-
-override_dh_installexamples:
-	dh_installexamples -plibsdl2-dev debian/examples.tar.gz
-	dh_installexamples --remaining-packages
-
-override_dh_link:
-	# to address lintian warning
-	# W: libsdl2-2.0-0: dev-pkg-without-shlib-symlink usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.0.0 usr/lib/x86_64-linux-gnu/libSDL2-2.0.so
-	dh_link -plibsdl2-dev usr/lib/$(DEB_HOST_MULTIARCH)/libSDL2-2.0.so.0.0.0 usr/lib/$(DEB_HOST_MULTIARCH)/libSDL2-2.0.so
-
-override_dh_strip:
-	dh_strip --dbg-package=libsdl2-dbg
diff --git a/Engine/lib/sdl/debian/sdl2-config.1 b/Engine/lib/sdl/debian/sdl2-config.1
deleted file mode 100644
index c4f4106fa..000000000
--- a/Engine/lib/sdl/debian/sdl2-config.1
+++ /dev/null
@@ -1,86 +0,0 @@
-.TH sdl2-config 1 "2012-02-20" "SDL 2.0"
-.SH NAME
-sdl2-config \- script to get information about the installed version of SDL
-.SH SYNOPSIS
-.B sdl2-config
-[ --prefix=
-.IR DIR ]
-[ --exec-prefix=
-.IR DIR ]
-[ --version ] [ --libs | --library-libs | --plugin-libs ] [ --cflags ]
-.SH DESCRIPTION
-.B sdl2-config
-is a tool that is used to configure and determine the compiler and linker
-flags that should be used to compile and link programs, libraries, and
-plugins that use SDL.  It is also used internally by the m4 macros that are
-included with SDL.
-.SH OPTIONS
-.TP
-.B --cflags
-Print the compiler flags that are necessary to compile a program or library
-that uses SDL.
-.TP
-.BI --exec-prefix= DIR
-If specified, use
-.I DIR
-instead of the installation exec prefix that SDL was build with when
-computing the output for the --cflags, --libs, --library-libs, and
---plugin-libs options.  This option must be specified before any of the
---cflags, --libs, --library-libs, and --plugin-libs options.
-.TP
-.B --libs
-Print the linker flags that are necessary to link a program that uses SDL.
-.TP
-.B --static-libs
-Print the linker flags that are necessary to statically link a program that uses SDL.
-.TP
-.B --library-libs
-Print the linker flags that are necessary to link a library that uses SDL.
-(This excludes any static objects required for linking, since these must be
-linked only by executable programs.)
-.TP
-.B --plugin-libs
-Print the linker flags that are necessary to link an SDL-using object that
-is to be accessed via
-.IR dlopen (3).
-This may include static objects with PIC symbol information.  This option
-should
-.B not
-be used for ordinary shared libraries or standalone applications.
-.TP
-.BI --prefix= DIR
-If specified, use PREFIX instead of the installation prefix that SDL was
-built with when computing the output for the --cflags, --libs,
---library-libs, and --plugin-libs options.  This option is also used for
-the exec prefix if --exec-prefix was not specified.  This option must be
-specified before any of the --cflags, --libs, --library-libs, and
---plugin-libs options.
-.TP
-.B --version
-Prints the currently installed version of SDL on standard output.
-.SH EXAMPLES
-.TP
-gcc -o main.o $(sdl2-config --cflags) main.c
-is how you might use
-.B sdl2-config
-to compile a C source file for an executable program.
-.TP
-gcc -o my_app $(sdl2-config --libs) main.o util.o
-is how you might use
-.B sdl2-config
-to link compiled objects into an executable program.
-.TP
-gcc -o libSDL_nifty-2.0.so.0.0.1 $(sdl --library-libs) read.o write.o munge.o
-is how you might use
-.B sdl2-config
-to link compiled objects into a shared library.
-.TP
-gcc -o libnifty_xmms.so $(sdl --plugin-libs) stream.o blit.o deinterlace.o
-is how you might use
-.B sdl2-config
-to link compiled objects into a plugin for use by another program.
-.SH AUTHOR
-The Simple DirectMedia Layer (SDL) library was written by Sam Lantinga.
-.PP
-This manual page was written by Branden Robinson, originally for Progeny
-Linux Systems, Inc., and the Debian Project.
diff --git a/Engine/lib/sdl/debian/source/format b/Engine/lib/sdl/debian/source/format
deleted file mode 100644
index 89ae9db8f..000000000
--- a/Engine/lib/sdl/debian/source/format
+++ /dev/null
@@ -1 +0,0 @@
-3.0 (native)
diff --git a/Engine/lib/sdl/debian/watch b/Engine/lib/sdl/debian/watch
deleted file mode 100644
index 07dc20117..000000000
--- a/Engine/lib/sdl/debian/watch
+++ /dev/null
@@ -1,2 +0,0 @@
-version=3
-http://www.libsdl.org/release/SDL-([\d.]+)\.tar\.gz
diff --git a/Engine/lib/sdl/docs/README-android.md b/Engine/lib/sdl/docs/README-android.md
index de0f0c4bf..0b112f04e 100644
--- a/Engine/lib/sdl/docs/README-android.md
+++ b/Engine/lib/sdl/docs/README-android.md
@@ -10,8 +10,7 @@ If you are using the older ant build process, it is no longer officially
 supported, but you can use the "android-project-ant" directory as a template.
 
 
-================================================================================
- Requirements
+Requirements
 ================================================================================
 
 Android SDK (version 26 or later)
@@ -23,8 +22,7 @@ https://developer.android.com/tools/sdk/ndk/index.html
 Minimum API level supported by SDL: 16 (Android 4.1)
 
 
-================================================================================
- How the port works
+How the port works
 ================================================================================
 
 - Android applications are Java-based, optionally with parts written in C
@@ -42,8 +40,7 @@ dispatches to native functions implemented in the SDL library:
 src/core/android/SDL_android.c
 
 
-================================================================================
- Building an app
+Building an app
 ================================================================================
 
 For simple projects you can use the script located at build-scripts/androidbuild.sh
@@ -120,8 +117,7 @@ Here's an explanation of the files in the Android project, so you can customize
         src/main/java/org/libsdl/app/SDLActivity.java - the Java class handling the initialization and binding to SDL. Be very careful changing this, as the SDL library relies on this implementation. You should instead subclass this for your application.
 
 
-================================================================================
- Customizing your application name
+Customizing your application name
 ================================================================================
 
 To customize your application name, edit AndroidManifest.xml and replace
@@ -151,8 +147,7 @@ Then replace "SDLActivity" in AndroidManifest.xml with the name of your
 class, .e.g. "MyGame"
 
 
-================================================================================
- Customizing your application icon
+Customizing your application icon
 ================================================================================
 
 Conceptually changing your icon is just replacing the "ic_launcher.png" files in
@@ -160,8 +155,7 @@ the drawable directories under the res directory. There are several directories
 for different screen sizes.
 
 
-================================================================================
- Loading assets
+Loading assets
 ================================================================================
 
 Any files you put in the "app/src/main/assets" directory of your project
@@ -189,8 +183,7 @@ disable this behaviour, see for example:
 http://ponystyle.com/blog/2010/03/26/dealing-with-asset-compression-in-android-apps/
 
 
-================================================================================
- Pause / Resume behaviour
+Pause / Resume behaviour
 ================================================================================
 
 If SDL_HINT_ANDROID_BLOCK_ON_PAUSE hint is set (the default),
@@ -205,13 +198,40 @@ app can continue to operate as it was.
 
 However, there's a chance (on older hardware, or on systems under heavy load),
 where the GL context can not be restored. In that case you have to listen for
-a specific message, (which is not yet implemented!) and restore your textures
-manually or quit the app (which is actually the kind of behaviour you'll see
-under iOS, if the OS can not restore your GL context it will just kill your app)
+a specific message (SDL_RENDER_DEVICE_RESET) and restore your textures
+manually or quit the app.
 
+You should not use the SDL renderer API while the app going in background:
+- SDL_APP_WILLENTERBACKGROUND:
+    after you read this message, GL context gets backed-up and you should not
+    use the SDL renderer API.
 
+    When this event is received, you have to set the render target to NULL, if you're using it.
+    (eg call SDL_SetRenderTarget(renderer, NULL))
+
+- SDL_APP_DIDENTERFOREGROUND:
+   GL context is restored, and the SDL renderer API is available (unless you
+   receive SDL_RENDER_DEVICE_RESET).
+
+Mouse / Touch events
 ================================================================================
- Threads and the Java VM
+
+In some case, SDL generates synthetic mouse (resp. touch) events for touch
+(resp. mouse) devices.
+To enable/disable this behavior, see SDL_hints.h:
+- SDL_HINT_TOUCH_MOUSE_EVENTS
+- SDL_HINT_MOUSE_TOUCH_EVENTS
+
+Misc
+================================================================================
+
+For some device, it appears to works better setting explicitly GL attributes
+before creating a window:
+  SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
+  SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 6);
+  SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
+
+Threads and the Java VM
 ================================================================================
 
 For a quick tour on how Linux native threads interoperate with the Java VM, take
@@ -226,8 +246,17 @@ your thread automatically anyway (when you make an SDL call), but it'll never
 detach it.
 
 
-================================================================================
- Using STL
+If you ever want to use JNI in a native thread (created by "SDL_CreateThread()"),
+it won't be able to find your java class and method because of the java class loader
+which is different for native threads, than for java threads (eg your "main()").
+
+the work-around is to find class/method, in you "main()" thread, and to use them
+in your native thread.
+
+see:
+https://developer.android.com/training/articles/perf-jni#faq:-why-didnt-findclass-find-my-class
+
+Using STL
 ================================================================================
 
 You can use STL in your project by creating an Application.mk file in the jni
@@ -239,8 +268,7 @@ For more information go here:
 	https://developer.android.com/ndk/guides/cpp-support
 
 
-================================================================================
- Using the emulator
+Using the emulator
 ================================================================================
 
 There are some good tips and tricks for getting the most out of the
@@ -252,8 +280,7 @@ Notice that this software emulator is incredibly slow and needs a lot of disk sp
 Using a real device works better.
 
 
-================================================================================
- Troubleshooting
+Troubleshooting
 ================================================================================
 
 You can see if adb can see any devices with the following command:
@@ -332,8 +359,7 @@ If you need to build without optimization turned on, you can create a file calle
     APP_OPTIM := debug
 
 
-================================================================================
- Memory debugging
+Memory debugging
 ================================================================================
 
 The best (and slowest) way to debug memory issues on Android is valgrind.
@@ -384,8 +410,7 @@ When you're done instrumenting with valgrind, you can disable the wrapper:
     adb shell setprop wrap.org.libsdl.app ""
 
 
-================================================================================
- Graphics debugging
+Graphics debugging
 ================================================================================
 
 If you are developing on a compatible Tegra-based tablet, NVidia provides
@@ -398,8 +423,7 @@ The Tegra Graphics Debugger is available from NVidia here:
 https://developer.nvidia.com/tegra-graphics-debugger
 
 
-================================================================================
- Why is API level 16 the minimum required?
+Why is API level 16 the minimum required?
 ================================================================================
 
 The latest NDK toolchain doesn't support targeting earlier than API level 16.
@@ -408,8 +432,7 @@ about 99% of the Android devices accessing Google Play support API level 16 or
 higher (January 2018).
 
 
-================================================================================
- A note regarding the use of the "dirty rectangles" rendering technique
+A note regarding the use of the "dirty rectangles" rendering technique
 ================================================================================
 
 If your app uses a variation of the "dirty rectangles" rendering technique,
@@ -427,8 +450,7 @@ screen each frame.
 Reference: http://www.khronos.org/registry/egl/specs/EGLTechNote0001.html
 
 
-================================================================================
- Ending your application
+Ending your application
 ================================================================================
 
 Two legitimate ways:
@@ -445,8 +467,7 @@ Don't call exit() as it stops the activity badly.
 NB: "Back button" can be handled as a SDL_KEYDOWN/UP events, with Keycode
 SDLK_AC_BACK, for any purpose.
 
-================================================================================
- Known issues
+Known issues
 ================================================================================
 
 - The number of buttons reported for each joystick is hardcoded to be 36, which
diff --git a/Engine/lib/sdl/docs/README-dynapi.md b/Engine/lib/sdl/docs/README-dynapi.md
index b9a58bce1..782745886 100644
--- a/Engine/lib/sdl/docs/README-dynapi.md
+++ b/Engine/lib/sdl/docs/README-dynapi.md
@@ -1,7 +1,6 @@
-Dynamic API
-================================================================================
-Originally posted by Ryan at:
-  https://plus.google.com/103391075724026391227/posts/TB8UfnDYu4U
+# Dynamic API
+
+Originally posted on Ryan's Google+ account.
 
 Background:
 
@@ -35,10 +34,12 @@ So here's what we did:
 SDL now has, internally, a table of function pointers. So, this is what SDL_Init
 now looks like:
 
-    UInt32 SDL_Init(Uint32 flags)
-    {
-        return jump_table.SDL_Init(flags);
-    }
+```c
+UInt32 SDL_Init(Uint32 flags)
+{
+    return jump_table.SDL_Init(flags);
+}
+```
 
 Except that is all done with a bunch of macro magic so we don't have to maintain
 every one of these.
@@ -47,22 +48,26 @@ What is jump_table.SDL_init()? Eventually, that's a function pointer of the real
 SDL_Init() that you've been calling all this time. But at startup, it looks more 
 like this:
 
-    Uint32 SDL_Init_DEFAULT(Uint32 flags)
-    {
-        SDL_InitDynamicAPI();
-        return jump_table.SDL_Init(flags);
-    }
+```c
+Uint32 SDL_Init_DEFAULT(Uint32 flags)
+{
+    SDL_InitDynamicAPI();
+    return jump_table.SDL_Init(flags);
+}
+```
 
 SDL_InitDynamicAPI() fills in jump_table with all the actual SDL function 
-pointers, which means that this _DEFAULT function never gets called again. 
+pointers, which means that this `_DEFAULT` function never gets called again. 
 First call to any SDL function sets the whole thing up.
 
 So you might be asking, what was the value in that? Isn't this what the operating
 system's dynamic loader was supposed to do for us? Yes, but now we've got this 
 level of indirection, we can do things like this:
 
-    export SDL_DYNAMIC_API=/my/actual/libSDL-2.0.so.0
-    ./MyGameThatIsStaticallyLinkedToSDL2
+```bash
+export SDL_DYNAMIC_API=/my/actual/libSDL-2.0.so.0
+./MyGameThatIsStaticallyLinkedToSDL2
+```
 
 And now, this game that is statically linked to SDL, can still be overridden 
 with a newer, or better, SDL. The statically linked one will only be used as 
@@ -94,7 +99,9 @@ SDL's function pointers (which might be statically linked into a program, or in
 a shared library of its own). If so, it loads that library and looks for and 
 calls a single function:
 
-    SInt32 SDL_DYNAPI_entry(Uint32 version, void *table, Uint32 tablesize);
+```c
+SInt32 SDL_DYNAPI_entry(Uint32 version, void *table, Uint32 tablesize);
+```
 
 That function takes a version number (more on that in a moment), the address of
 the jump table, and the size, in bytes, of the table. 
@@ -116,6 +123,7 @@ Steam Client, this isn't a bad option.
 
 Finally, I'm sure some people are reading this and thinking,
 "I don't want that overhead in my project!"  
+
 To which I would point out that the extra function call through the jump table 
 probably wouldn't even show up in a profile, but lucky you: this can all be 
 disabled. You can build SDL without this if you absolutely must, but we would 
diff --git a/Engine/lib/sdl/docs/README-git.md b/Engine/lib/sdl/docs/README-git.md
new file mode 100644
index 000000000..3f03488ae
--- /dev/null
+++ b/Engine/lib/sdl/docs/README-git.md
@@ -0,0 +1,19 @@
+git
+=========
+
+The latest development version of SDL is available via git.
+Git allows you to get up-to-the-minute fixes and enhancements;
+as a developer works on a source tree, you can use "git" to mirror that
+source tree instead of waiting for an official release. Please look
+at the Git website ( https://git-scm.com/ ) for more
+information on using git, where you can also download software for
+macOS, Windows, and Unix systems.
+
+    git clone https://github.com/libsdl-org/SDL
+
+If you are building SDL via configure, you will need to run autogen.sh
+before running configure.
+
+There is a web interface to the Git repository at:
+	http://github.com/libsdl-org/SDL/
+
diff --git a/Engine/lib/sdl/docs/README-hg.md b/Engine/lib/sdl/docs/README-hg.md
index 2449d555d..4e35683bd 100644
--- a/Engine/lib/sdl/docs/README-hg.md
+++ b/Engine/lib/sdl/docs/README-hg.md
@@ -1,22 +1,4 @@
-Mercurial
-=========
+We are no longer hosted in Mercurial. Please see README-git.md for details.
 
-The latest development version of SDL is available via Mercurial.
-Mercurial allows you to get up-to-the-minute fixes and enhancements;
-as a developer works on a source tree, you can use "hg" to mirror that
-source tree instead of waiting for an official release. Please look
-at the Mercurial website ( https://www.mercurial-scm.org/ ) for more
-information on using hg, where you can also download software for
-Mac OS X, Windows, and Unix systems.
-
-    hg clone http://hg.libsdl.org/SDL
-
-If you are building SDL via configure, you will need to run autogen.sh
-before running configure.
-
-There is a web interface to the subversion repository at:
-	http://hg.libsdl.org/SDL/
-
-There is an RSS feed available at that URL, for those that want to
-track commits in real time.
+Thanks!
 
diff --git a/Engine/lib/sdl/docs/README-ios.md b/Engine/lib/sdl/docs/README-ios.md
index f6f570d44..2bcb19681 100644
--- a/Engine/lib/sdl/docs/README-ios.md
+++ b/Engine/lib/sdl/docs/README-ios.md
@@ -1,7 +1,6 @@
 iOS
 ======
 
-==============================================================================
 Building the Simple DirectMedia Layer for iOS 5.1+
 ==============================================================================
 
@@ -9,57 +8,29 @@ Requirements: Mac OS X 10.8 or later and the iOS 7+ SDK.
 
 Instructions:
 
-1.  Open SDL.xcodeproj (located in Xcode-iOS/SDL) in Xcode.
-2.  Select your desired target, and hit build.
-
-There are three build targets:
-- libSDL.a:
-	Build SDL as a statically linked library
-- testsdl:
-	Build a test program (there are known test failures which are fine)
-- Template:
-	Package a project template together with the SDL for iPhone static libraries and copies of the SDL headers.  The template includes proper references to the SDL library and headers, skeleton code for a basic SDL program, and placeholder graphics for the application icon and startup screen.
+1. Open SDL.xcodeproj (located in Xcode/SDL) in Xcode.
+2. Select your desired target, and hit build.
 
 
-==============================================================================
-Build SDL for iOS from the command line
-==============================================================================
-
-1. cd (PATH WHERE THE SDL CODE IS)/build-scripts
-2. ./iosbuild.sh
-
-If everything goes fine, you should see a build/ios directory, inside there's
-two directories "lib" and "include". 
-"include" contains a copy of the SDL headers that you'll need for your project,
-make sure to configure XCode to look for headers there.
-"lib" contains find two files, libSDL2.a and libSDL2main.a, you have to add both 
-to your XCode project. These libraries contain three architectures in them,
-armv6 for legacy devices, armv7, and i386 (for the simulator).
-By default, iosbuild.sh will autodetect the SDK version you have installed using 
-xcodebuild -showsdks, and build for iOS >= 3.0, you can override this behaviour 
-by setting the MIN_OS_VERSION variable, ie:
-
-MIN_OS_VERSION=4.2 ./iosbuild.sh
-
-==============================================================================
 Using the Simple DirectMedia Layer for iOS
 ==============================================================================
 
-FIXME: This needs to be updated for the latest methods
+1. Run Xcode and create a new project using the iOS Game template, selecting the Objective C language and Metal game technology.
+2. In the main view, delete all files except for Assets and LaunchScreen
+3. Right click the project in the main view, select "Add Files...", and add the SDL project, Xcode/SDL/SDL.xcodeproj
+4. Select the project in the main view, go to the "Info" tab and under "Custom iOS Target Properties" remove the line "Main storyboard file base name"
+5. Select the project in the main view, go to the "Build Settings" tab, select "All", and edit "Header Search Path" and drag over the SDL "Public Headers" folder from the left
+6. Select the project in the main view, go to the "Build Phases" tab, select "Link Binary With Libraries", and add SDL2.framework from "Framework-iOS"
+7. Select the project in the main view, go to the "General" tab, scroll down to "Frameworks, Libraries, and Embedded Content", and select "Embed & Sign" for the SDL library.
+8. In the main view, expand SDL -> Library Source -> main -> uikit and drag SDL_uikit_main.c into your game files
+9. Add the source files that you would normally have for an SDL program, making sure to have #include "SDL.h" at the top of the file containing your main() function.
+10. Add any assets that your application needs.
+11. Enjoy!
 
-Here is the easiest method:
-1.  Build the SDL library (libSDL2.a) and the iPhone SDL Application template.
-2.  Install the iPhone SDL Application template by copying it to one of Xcode's template directories.  I recommend creating a directory called "SDL" in "/Developer/Platforms/iOS.platform/Developer/Library/Xcode/Project Templates/" and placing it there.
-3.  Start a new project using the template.  The project should be immediately ready for use with SDL.
 
-Here is a more manual method:
-1.  Create a new iOS view based application.
-2.  Build the SDL static library (libSDL2.a) for iOS and include them in your project.  Xcode will ignore the library that is not currently of the correct architecture, hence your app will work both on iOS and in the iOS Simulator.
-3.  Include the SDL header files in your project.
-4.  Remove the ApplicationDelegate.h and ApplicationDelegate.m files -- SDL for iOS provides its own UIApplicationDelegate.  Remove MainWindow.xib -- SDL for iOS produces its user interface programmatically.
-5.  Delete the contents of main.m and program your app as a regular SDL program instead.  You may replace main.m with your own main.c, but you must tell Xcode not to use the project prefix file, as it includes Objective-C code.
+TODO: Add information regarding App Store requirements such as icons, etc.
+
 
-==============================================================================
 Notes -- Retina / High-DPI and window sizes
 ==============================================================================
 
@@ -88,7 +59,7 @@ orthographic projection matrix using the size in screen coordinates
 (SDL_GetWindowSize()) can be used in order to display content at the same scale
 no matter whether a Retina device is used or not.
 
-==============================================================================
+
 Notes -- Application events
 ==============================================================================
 
@@ -151,7 +122,6 @@ e.g.
     }
 
     
-==============================================================================
 Notes -- Accelerometer as Joystick
 ==============================================================================
 
@@ -159,7 +129,7 @@ SDL for iPhone supports polling the built in accelerometer as a joystick device.
 
 The main thing to note when using the accelerometer with SDL is that while the iPhone natively reports accelerometer as floating point values in units of g-force, SDL_JoystickGetAxis() reports joystick values as signed integers.  Hence, in order to convert between the two, some clamping and scaling is necessary on the part of the iPhone SDL joystick driver.  To convert SDL_JoystickGetAxis() reported values BACK to units of g-force, simply multiply the values by SDL_IPHONE_MAX_GFORCE / 0x7FFF.
 
-==============================================================================
+
 Notes -- OpenGL ES
 ==============================================================================
 
@@ -179,7 +149,7 @@ OpenGL ES on iOS doesn't use the traditional system-framebuffer setup provided i
 
 The above objects can be obtained via SDL_GetWindowWMInfo() (in SDL_syswm.h).
 
-==============================================================================
+
 Notes -- Keyboard
 ==============================================================================
 
@@ -195,7 +165,12 @@ SDL_bool SDL_IsTextInputActive()
 	-- returns whether or not text events are enabled (and the onscreen keyboard is visible)
 
 
+Notes -- Mouse
 ==============================================================================
+
+iOS now supports Bluetooth mice on iPad, but by default will provide the mouse input as touch. In order for SDL to see the real mouse events, you should set the key UIApplicationSupportsIndirectInputEvents to true in your Info.plist
+
+
 Notes -- Reading and Writing files
 ==============================================================================
 
@@ -215,7 +190,7 @@ When your SDL based iPhone application starts up, it sets the working directory
 More information on this subject is available here:
 http://developer.apple.com/library/ios/#documentation/iPhone/Conceptual/iPhoneOSProgrammingGuide/Introduction/Introduction.html
 
-==============================================================================
+
 Notes -- iPhone SDL limitations
 ==============================================================================
 
@@ -228,7 +203,7 @@ Textures:
 Loading Shared Objects:
 	This is disabled by default since it seems to break the terms of the iOS SDK agreement for iOS versions prior to iOS 8. It can be re-enabled in SDL_config_iphoneos.h.
 
-==============================================================================
+
 Notes -- CoreBluetooth.framework
 ==============================================================================
 
@@ -244,7 +219,7 @@ to your Info.plist:
 <key>NSBluetoothPeripheralUsageDescription</key>
 <string>MyApp would like to remain connected to nearby bluetooth Game Controllers and Game Pads even when you're not using the app.</string>
 
-==============================================================================
+
 Game Center 
 ==============================================================================
 
@@ -282,7 +257,7 @@ e.g.
         return 0;
     }
 
-==============================================================================
+
 Deploying to older versions of iOS
 ==============================================================================
 
diff --git a/Engine/lib/sdl/docs/README-kmsbsd.md b/Engine/lib/sdl/docs/README-kmsbsd.md
new file mode 100644
index 000000000..01db5e8aa
--- /dev/null
+++ b/Engine/lib/sdl/docs/README-kmsbsd.md
@@ -0,0 +1,27 @@
+KMSDRM on *BSD
+==================================================
+
+KMSDRM is supported on FreeBSD and OpenBSD. DragonFlyBSD works but requires being a root user. NetBSD isn't supported yet because the application will crash when creating the KMSDRM screen.
+
+WSCONS support has been brought back, but only as an input backend. It will not be brought back as a video backend to ease maintenance.
+
+OpenBSD note: Note that the video backend assumes that the user has read/write permissions to the /dev/drm* devices.
+
+
+SDL2 WSCONS input backend features
+===================================================
+1. It is keymap-aware; it will work properly with different keymaps.
+2. It has mouse support.
+3. Accent input is supported.
+4. Compose keys are supported.
+5. AltGr and Meta Shift keys work as intended.
+
+Partially working or no input on OpenBSD/NetBSD.
+==================================================
+
+The WSCONS input backend needs read/write access to the /dev/wskbd* devices, without which it will not work properly. /dev/wsmouse must also be read/write accessible, otherwise mouse input will not work.
+
+Partially working or no input on FreeBSD.
+==================================================
+
+The evdev devices are only accessible to the root user by default. Edit devfs rules to allow access to such devices. The /dev/kbd* devices are also only accessible to the root user by default. Edit devfs rules to allow access to such devices.
diff --git a/Engine/lib/sdl/docs/README-linux.md b/Engine/lib/sdl/docs/README-linux.md
index 7bbe63f12..230bad963 100644
--- a/Engine/lib/sdl/docs/README-linux.md
+++ b/Engine/lib/sdl/docs/README-linux.md
@@ -9,22 +9,35 @@ at runtime, and you won't get a missing library error, at least with the
 default configuration parameters.
 
 
-================================================================================
 Build Dependencies
-================================================================================
-    
+--------------------------------------------------------------------------------
+
 Ubuntu 20.04, all available features enabled:
 
-sudo apt-get install build-essential mercurial make cmake autoconf automake \
-libtool libasound2-dev libpulse-dev libaudio-dev libx11-dev libxext-dev \
-libxrandr-dev libxcursor-dev libxi-dev libxinerama-dev libxxf86vm-dev \
-libxss-dev libgl1-mesa-dev libdbus-1-dev libudev-dev libgles2-mesa-dev \
-libegl1-mesa-dev libibus-1.0-dev fcitx-libs-dev libsamplerate0-dev \
-libsndio-dev libwayland-dev libxkbcommon-dev
+    sudo apt-get install build-essential git make cmake autoconf automake \
+    libtool pkg-config libasound2-dev libpulse-dev libaudio-dev libjack-dev \
+    libx11-dev libxext-dev libxrandr-dev libxcursor-dev libxfixes-dev libxi-dev \
+    libxinerama-dev libxxf86vm-dev libxss-dev libgl1-mesa-dev libdbus-1-dev \
+    libudev-dev libgles2-mesa-dev libegl1-mesa-dev libibus-1.0-dev \
+    fcitx-libs-dev libsamplerate0-dev libsndio-dev libwayland-dev \
+    libxkbcommon-dev libdrm-dev libgbm-dev
+
+Fedora 35, all available features enabled:
+
+    sudo yum install gcc git-core make cmake autoconf automake libtool \
+    alsa-lib-devel pulseaudio-libs-devel nas-devel pipewire-devel \
+    libX11-devel libXext-devel libXrandr-devel libXcursor-devel libXfixes-devel \
+    libXi-devel libXinerama-devel libXxf86vm-devel libXScrnSaver-devel \
+    dbus-devel ibus-devel fcitx-devel systemd-devel mesa-libGL-devel \
+    libxkbcommon-devel mesa-libGLES-devel mesa-libEGL-devel vulkan-devel \
+    wayland-devel wayland-protocols-devel libdrm-devel mesa-libgbm-devel \
+    libusb-devel pipewire-jack-audio-connection-kit-devel libdecor-devel \
+    libsamplerate-devel
 
 NOTES:
 - This includes all the audio targets except arts and esd, because Ubuntu
   (and/or Debian) pulled their packages, but in theory SDL still supports them.
+  The sndio audio target is also unavailable on Fedora.
 - libsamplerate0-dev lets SDL optionally link to libresamplerate at runtime
   for higher-quality audio resampling. SDL will work without it if the library
   is missing, so it's safe to build in support even if the end user doesn't
@@ -34,9 +47,8 @@ NOTES:
   configure script to include DirectFB support. Send patches.  :)
 
 
-================================================================================
 Joystick does not work
-================================================================================
+--------------------------------------------------------------------------------
 
 If you compiled or are using a version of SDL with udev support (and you should!)
 there's a few issues that may cause SDL to fail to detect your joystick. To
@@ -66,8 +78,8 @@ you need to set up an udev rule to force this variable.
 A combined rule for the Saitek Pro Flight Rudder Pedals to fix both issues looks 
 like:
     
-   SUBSYSTEM=="input", ATTRS{idProduct}=="0763", ATTRS{idVendor}=="06a3", MODE="0666", ENV{ID_INPUT_JOYSTICK}="1"
-   SUBSYSTEM=="input", ATTRS{idProduct}=="0764", ATTRS{idVendor}=="06a3", MODE="0666", ENV{ID_INPUT_JOYSTICK}="1"
+    SUBSYSTEM=="input", ATTRS{idProduct}=="0763", ATTRS{idVendor}=="06a3", MODE="0666", ENV{ID_INPUT_JOYSTICK}="1"
+    SUBSYSTEM=="input", ATTRS{idProduct}=="0764", ATTRS{idVendor}=="06a3", MODE="0666", ENV{ID_INPUT_JOYSTICK}="1"
    
 You can set up similar rules for your device by changing the values listed in
 idProduct and idVendor. To obtain these values, try:
diff --git a/Engine/lib/sdl/docs/README-macos.md b/Engine/lib/sdl/docs/README-macos.md
new file mode 100644
index 000000000..d7bc98afd
--- /dev/null
+++ b/Engine/lib/sdl/docs/README-macos.md
@@ -0,0 +1,286 @@
+# Mac OS X (aka macOS).
+
+These instructions are for people using Apple's Mac OS X (pronounced
+"ten"), which in newer versions is just referred to as "macOS".
+
+From the developer's point of view, macOS is a sort of hybrid Mac and
+Unix system, and you have the option of using either traditional
+command line tools or Apple's IDE Xcode.
+
+# Command Line Build
+
+To build SDL using the command line, use the standard configure and make
+process:
+
+```bash
+mkdir build
+cd build
+../configure
+make
+sudo make install
+```
+
+CMake is also known to work, although it continues to be a work in progress:
+
+```bash
+mkdir build
+cd build
+cmake -DCMAKE_BUILD_TYPE=Release ..
+make
+sudo make install
+```
+
+
+You can also build SDL as a Universal library (a single binary for both
+64-bit Intel and ARM architectures), by using the build-scripts/clang-fat.sh
+script.
+
+```bash
+mkdir build
+cd build
+CC=$PWD/../build-scripts/clang-fat.sh ../configure
+make
+sudo make install
+```
+
+This script builds SDL with 10.6 ABI compatibility on 64-bit Intel and 11.0
+ABI compatibility on ARM64 architectures.  For best compatibility you
+should compile your application the same way.
+
+Please note that building SDL requires at least Xcode 4.6 and the 10.7 SDK
+(even if you target back to 10.6 systems). PowerPC support for Mac OS X has
+been officially dropped as of SDL 2.0.2. 32-bit Intel, using an older Xcode
+release, is still supported at the time of this writing, but current Xcode
+releases no longer support it, and eventually neither will SDL.
+
+To use the library once it's built, you essential have two possibilities:
+use the traditional autoconf/automake/make method, or use Xcode.
+
+
+# Caveats for using SDL with Mac OS X
+
+If you register your own NSApplicationDelegate (using [NSApp setDelegate:]),
+SDL will not register its own. This means that SDL will not terminate using
+SDL_Quit if it receives a termination request, it will terminate like a
+normal app, and it will not send a SDL_DROPFILE when you request to open a
+file with the app. To solve these issues, put the following code in your
+NSApplicationDelegate implementation:
+
+
+```objc
+- (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)sender
+{
+    if (SDL_GetEventState(SDL_QUIT) == SDL_ENABLE) {
+        SDL_Event event;
+        event.type = SDL_QUIT;
+        SDL_PushEvent(&event);
+    }
+    
+    return NSTerminateCancel;
+}
+    
+- (BOOL)application:(NSApplication *)theApplication openFile:(NSString *)filename
+{
+    if (SDL_GetEventState(SDL_DROPFILE) == SDL_ENABLE) {
+        SDL_Event event;
+        event.type = SDL_DROPFILE;
+        event.drop.file = SDL_strdup([filename UTF8String]);
+        return (SDL_PushEvent(&event) > 0);
+    }
+    
+    return NO;
+}
+```
+
+# Using the Simple DirectMedia Layer with a traditional Makefile
+
+An existing autoconf/automake build system for your SDL app has good chances
+to work almost unchanged on macOS. However, to produce a "real" Mac binary
+that you can distribute to users, you need to put the generated binary into a
+so called "bundle", which is basically a fancy folder with a name like
+"MyCoolGame.app".
+
+To get this build automatically, add something like the following rule to
+your Makefile.am:
+
+```make
+bundle_contents = APP_NAME.app/Contents
+APP_NAME_bundle: EXE_NAME
+	mkdir -p $(bundle_contents)/MacOS
+	mkdir -p $(bundle_contents)/Resources
+	echo "APPL????" > $(bundle_contents)/PkgInfo
+	$(INSTALL_PROGRAM) $< $(bundle_contents)/MacOS/
+```
+
+You should replace `EXE_NAME` with the name of the executable. `APP_NAME` is
+what will be visible to the user in the Finder. Usually it will be the same
+as `EXE_NAME` but capitalized. E.g. if `EXE_NAME` is "testgame" then `APP_NAME`
+usually is "TestGame". You might also want to use `@PACKAGE@` to use the
+package name as specified in your configure.ac file.
+
+If your project builds more than one application, you will have to do a bit
+more. For each of your target applications, you need a separate rule.
+
+If you want the created bundles to be installed, you may want to add this
+rule to your Makefile.am:
+
+```make
+install-exec-hook: APP_NAME_bundle
+	rm -rf $(DESTDIR)$(prefix)/Applications/APP_NAME.app
+	mkdir -p $(DESTDIR)$(prefix)/Applications/
+	cp -r $< /$(DESTDIR)$(prefix)Applications/
+```
+
+This rule takes the Bundle created by the rule from step 3 and installs them
+into "$(DESTDIR)$(prefix)/Applications/".
+
+Again, if you want to install multiple applications, you will have to augment
+the make rule accordingly.
+
+But beware! That is only part of the story! With the above, you end up with
+a barebones .app bundle, which is double-clickable from the Finder. But
+there are some more things you should do before shipping your product...
+
+1. The bundle right now probably is dynamically linked against SDL. That
+   means that when you copy it to another computer, *it will not run*,
+   unless you also install SDL on that other computer. A good solution
+   for this dilemma is to static link against SDL. On OS X, you can
+   achieve that by linking against the libraries listed by
+
+   ```bash
+   sdl-config --static-libs
+   ```
+
+   instead of those listed by
+
+   ```bash
+   sdl-config --libs
+   ```
+
+   Depending on how exactly SDL is integrated into your build systems, the
+   way to achieve that varies, so I won't describe it here in detail
+
+2. Add an 'Info.plist' to your application. That is a special XML file which
+   contains some meta-information about your application (like some copyright
+   information, the version of your app, the name of an optional icon file,
+   and other things). Part of that information is displayed by the Finder
+   when you click on the .app, or if you look at the "Get Info" window.
+   More information about Info.plist files can be found on Apple's homepage.
+
+
+As a final remark, let me add that I use some of the techniques (and some
+variations of them) in [Exult](https://github.com/exult/exult) and
+[ScummVM](https://github.com/scummvm/scummvm); both are available in source on
+the net, so feel free to take a peek at them for inspiration!
+
+
+# Using the Simple DirectMedia Layer with Xcode
+
+These instructions are for using Apple's Xcode IDE to build SDL applications.
+
+## First steps
+
+The first thing to do is to unpack the Xcode.tar.gz archive in the
+top level SDL directory (where the Xcode.tar.gz archive resides).
+Because Stuffit Expander will unpack the archive into a subdirectory,
+you should unpack the archive manually from the command line:
+
+```bash
+cd [path_to_SDL_source]
+tar zxf Xcode.tar.gz
+```
+
+This will create a new folder called Xcode, which you can browse
+normally from the Finder.
+
+## Building the Framework
+
+The SDL Library is packaged as a framework bundle, an organized
+relocatable folder hierarchy of executable code, interface headers,
+and additional resources. For practical purposes, you can think of a 
+framework as a more user and system-friendly shared library, whose library
+file behaves more or less like a standard UNIX shared library.
+
+To build the framework, simply open the framework project and build it. 
+By default, the framework bundle "SDL.framework" is installed in 
+/Library/Frameworks. Therefore, the testers and project stationary expect
+it to be located there. However, it will function the same in any of the
+following locations:
+
+* ~/Library/Frameworks
+* /Local/Library/Frameworks
+* /System/Library/Frameworks
+
+## Build Options
+
+There are two "Build Styles" (See the "Targets" tab) for SDL.
+"Deployment" should be used if you aren't tweaking the SDL library.
+"Development" should be used to debug SDL apps or the library itself.
+
+## Building the Testers
+
+Open the SDLTest project and build away!
+
+## Using the Project Stationary
+
+Copy the stationary to the indicated folders to access it from
+the "New Project" and "Add target" menus. What could be easier?
+
+## Setting up a new project by hand
+
+Some of you won't want to use the Stationary so I'll give some tips:
+
+(this is accurate as of Xcode 12.5.)
+
+* Click "File" -> "New" -> "Project...
+* Choose "macOS" and then "App" from the "Application" section.
+* Fill out the options in the next window. User interface is "XIB" and
+  Language is "Objective-C".
+* Remove "main.m" from your project
+* Remove "MainMenu.xib" from your project
+* Remove "AppDelegates.*" from your project
+* Add "\$(HOME)/Library/Frameworks/SDL.framework/Headers" to include path
+* Add "\$(HOME)/Library/Frameworks" to the frameworks search path
+* Add "-framework SDL -framework Foundation -framework AppKit" to "OTHER_LDFLAGS"
+* Add your files
+* Clean and build
+
+## Building from command line
+
+Use `xcode-build` in the same directory as your .pbxproj file
+
+## Running your app
+
+You can send command line args to your app by either invoking it from
+the command line (in *.app/Contents/MacOS) or by entering them in the
+Executables" panel of the target settings.
+    
+# Implementation Notes
+
+Some things that may be of interest about how it all works...
+
+## Working directory
+
+In SDL 1.2, the working directory of your SDL app is by default set to its
+parent, but this is no longer the case in SDL 2.0. SDL2 does change the
+working directory, which means it'll be whatever the command line prompt
+that launched the program was using, or if launched by double-clicking in
+the finger, it will be "/", the _root of the filesystem_. Plan accordingly!
+You can use SDL_GetBasePath() to find where the program is running from and
+chdir() there directly.
+
+
+## You have a Cocoa App!
+
+Your SDL app is essentially a Cocoa application. When your app
+starts up and the libraries finish loading, a Cocoa procedure is called,
+which sets up the working directory and calls your main() method.
+You are free to modify your Cocoa app with generally no consequence
+to SDL. You cannot, however, easily change the SDL window itself.
+Functionality may be added in the future to help this.
+
+# Bug reports
+
+Bugs are tracked at [the GitHub issue tracker](https://github.com/libsdl-org/SDL/issues/).
+Please feel free to report bugs there!
+
diff --git a/Engine/lib/sdl/docs/README-macosx.md b/Engine/lib/sdl/docs/README-macosx.md
deleted file mode 100644
index 2cb80013f..000000000
--- a/Engine/lib/sdl/docs/README-macosx.md
+++ /dev/null
@@ -1,240 +0,0 @@
-Mac OS X
-==============================================================================
-
-These instructions are for people using Apple's Mac OS X (pronounced
-"ten").
-
-From the developer's point of view, OS X is a sort of hybrid Mac and
-Unix system, and you have the option of using either traditional
-command line tools or Apple's IDE Xcode.
-
-Command Line Build
-==================
-
-To build SDL using the command line, use the standard configure and make
-process:
-
-    ./configure
-    make
-    sudo make install
-
-You can also build SDL as a Universal library (a single binary for both
-32-bit and 64-bit Intel architectures), on Mac OS X 10.7 and newer, by using
-the gcc-fat.sh script in build-scripts:
-
-    mkdir mybuild
-    cd mybuild
-    CC=$PWD/../build-scripts/gcc-fat.sh CXX=$PWD/../build-scripts/g++-fat.sh ../configure
-    make
-    sudo make install
-
-This script builds SDL with 10.5 ABI compatibility on i386 and 10.6
-ABI compatibility on x86_64 architectures.  For best compatibility you
-should compile your application the same way.
-
-Please note that building SDL requires at least Xcode 4.6 and the 10.7 SDK
-(even if you target back to 10.5 systems). PowerPC support for Mac OS X has
-been officially dropped as of SDL 2.0.2.
-
-To use the library once it's built, you essential have two possibilities:
-use the traditional autoconf/automake/make method, or use Xcode.
-
-==============================================================================
-Caveats for using SDL with Mac OS X
-==============================================================================
-
-Some things you have to be aware of when using SDL on Mac OS X:
-
-- If you register your own NSApplicationDelegate (using [NSApp setDelegate:]),
-  SDL will not register its own. This means that SDL will not terminate using
-  SDL_Quit if it receives a termination request, it will terminate like a 
-  normal app, and it will not send a SDL_DROPFILE when you request to open a
-  file with the app. To solve these issues, put the following code in your 
-  NSApplicationDelegate implementation:
-
-
-    - (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)sender
-    {
-        if (SDL_GetEventState(SDL_QUIT) == SDL_ENABLE) {
-            SDL_Event event;
-            event.type = SDL_QUIT;
-            SDL_PushEvent(&event);
-        }
-    
-        return NSTerminateCancel;
-    }
-    
-    - (BOOL)application:(NSApplication *)theApplication openFile:(NSString *)filename
-    {
-        if (SDL_GetEventState(SDL_DROPFILE) == SDL_ENABLE) {
-            SDL_Event event;
-            event.type = SDL_DROPFILE;
-            event.drop.file = SDL_strdup([filename UTF8String]);
-            return (SDL_PushEvent(&event) > 0);
-        }
-    
-        return NO;
-    }
-
-==============================================================================
-Using the Simple DirectMedia Layer with a traditional Makefile
-==============================================================================
-
-An existing autoconf/automake build system for your SDL app has good chances
-to work almost unchanged on OS X. However, to produce a "real" Mac OS X binary
-that you can distribute to users, you need to put the generated binary into a
-so called "bundle", which basically is a fancy folder with a name like
-"MyCoolGame.app".
-
-To get this build automatically, add something like the following rule to
-your Makefile.am:
-
-    bundle_contents = APP_NAME.app/Contents
-    APP_NAME_bundle: EXE_NAME
-    	mkdir -p $(bundle_contents)/MacOS
-    	mkdir -p $(bundle_contents)/Resources
-    	echo "APPL????" > $(bundle_contents)/PkgInfo
-    	$(INSTALL_PROGRAM) $< $(bundle_contents)/MacOS/
-
-You should replace EXE_NAME with the name of the executable. APP_NAME is what
-will be visible to the user in the Finder. Usually it will be the same
-as EXE_NAME but capitalized. E.g. if EXE_NAME is "testgame" then APP_NAME 
-usually is "TestGame". You might also want to use `@PACKAGE@` to use the package
-name as specified in your configure.ac file.
-
-If your project builds more than one application, you will have to do a bit
-more. For each of your target applications, you need a separate rule.
-
-If you want the created bundles to be installed, you may want to add this
-rule to your Makefile.am:
-
-    install-exec-hook: APP_NAME_bundle
-    	rm -rf $(DESTDIR)$(prefix)/Applications/APP_NAME.app
-    	mkdir -p $(DESTDIR)$(prefix)/Applications/
-    	cp -r $< /$(DESTDIR)$(prefix)Applications/
-
-This rule takes the Bundle created by the rule from step 3 and installs them
-into "$(DESTDIR)$(prefix)/Applications/".
-
-Again, if you want to install multiple applications, you will have to augment
-the make rule accordingly.
-
-
-But beware! That is only part of the story! With the above, you end up with
-a bare bone .app bundle, which is double clickable from the Finder. But
-there are some more things you should do before shipping your product...
-
-1) The bundle right now probably is dynamically linked against SDL. That 
-   means that when you copy it to another computer, *it will not run*,
-   unless you also install SDL on that other computer. A good solution
-   for this dilemma is to static link against SDL. On OS X, you can
-   achieve that by linking against the libraries listed by
-
-       sdl-config --static-libs
-
-   instead of those listed by
-
-       sdl-config --libs
-
-   Depending on how exactly SDL is integrated into your build systems, the
-   way to achieve that varies, so I won't describe it here in detail
-
-2) Add an 'Info.plist' to your application. That is a special XML file which
-   contains some meta-information about your application (like some copyright
-   information, the version of your app, the name of an optional icon file,
-   and other things). Part of that information is displayed by the Finder
-   when you click on the .app, or if you look at the "Get Info" window.
-   More information about Info.plist files can be found on Apple's homepage.
-
-
-As a final remark, let me add that I use some of the techniques (and some
-variations of them) in Exult and ScummVM; both are available in source on
-the net, so feel free to take a peek at them for inspiration!
-
-
-==============================================================================
-Using the Simple DirectMedia Layer with Xcode
-==============================================================================
-
-These instructions are for using Apple's Xcode IDE to build SDL applications.
-
-- First steps
-
-The first thing to do is to unpack the Xcode.tar.gz archive in the
-top level SDL directory (where the Xcode.tar.gz archive resides).
-Because Stuffit Expander will unpack the archive into a subdirectory,
-you should unpack the archive manually from the command line:
-
-    cd [path_to_SDL_source]
-    tar zxf Xcode.tar.gz
-
-This will create a new folder called Xcode, which you can browse
-normally from the Finder.
-
-- Building the Framework
-
-The SDL Library is packaged as a framework bundle, an organized
-relocatable folder hierarchy of executable code, interface headers,
-and additional resources. For practical purposes, you can think of a 
-framework as a more user and system-friendly shared library, whose library
-file behaves more or less like a standard UNIX shared library.
-
-To build the framework, simply open the framework project and build it. 
-By default, the framework bundle "SDL.framework" is installed in 
-/Library/Frameworks. Therefore, the testers and project stationary expect
-it to be located there. However, it will function the same in any of the
-following locations:
-
-    ~/Library/Frameworks
-    /Local/Library/Frameworks
-    /System/Library/Frameworks
-
-- Build Options
-    There are two "Build Styles" (See the "Targets" tab) for SDL.
-    "Deployment" should be used if you aren't tweaking the SDL library.
-    "Development" should be used to debug SDL apps or the library itself.
-
-- Building the Testers
-    Open the SDLTest project and build away!
-
-- Using the Project Stationary
-    Copy the stationary to the indicated folders to access it from
-    the "New Project" and "Add target" menus. What could be easier?
-
-- Setting up a new project by hand
-    Some of you won't want to use the Stationary so I'll give some tips:
-    * Create a new "Cocoa Application"
-    * Add src/main/macosx/SDLMain.m , .h and .nib to your project
-    * Remove "main.c" from your project
-    * Remove "MainMenu.nib" from your project
-    * Add "$(HOME)/Library/Frameworks/SDL.framework/Headers" to include path
-    * Add "$(HOME)/Library/Frameworks" to the frameworks search path
-    * Add "-framework SDL -framework Foundation -framework AppKit" to "OTHER_LDFLAGS"
-    * Set the "Main Nib File" under "Application Settings" to "SDLMain.nib"
-    * Add your files
-    * Clean and build
-
-- Building from command line
-    Use pbxbuild in the same directory as your .pbproj file
-
-- Running your app
-    You can send command line args to your app by either invoking it from
-    the command line (in *.app/Contents/MacOS) or by entering them in the
-    "Executables" panel of the target settings.
-    
-- Implementation Notes
-    Some things that may be of interest about how it all works...
-    * Working directory
-        As defined in the SDL_main.m file, the working directory of your SDL app
-        is by default set to its parent. You may wish to change this to better
-        suit your needs.
-    * You have a Cocoa App!
-        Your SDL app is essentially a Cocoa application. When your app
-        starts up and the libraries finish loading, a Cocoa procedure is called,
-        which sets up the working directory and calls your main() method.
-        You are free to modify your Cocoa app with generally no consequence 
-        to SDL. You cannot, however, easily change the SDL window itself.
-        Functionality may be added in the future to help this.
-
-
-Known bugs are listed in the file "BUGS.txt".
diff --git a/Engine/lib/sdl/docs/README-os2.md b/Engine/lib/sdl/docs/README-os2.md
index 2b7bb2bf0..1815b944d 100644
--- a/Engine/lib/sdl/docs/README-os2.md
+++ b/Engine/lib/sdl/docs/README-os2.md
@@ -3,9 +3,9 @@ Simple DirectMedia Layer 2 for OS/2 & eComStation
 SDL port for OS/2, authored by Andrey Vasilkin <digi@os2.snc.ru>, 2016
 
 
-OpenGL, joystick and audio capture not supported by this port.
+OpenGL and audio capture not supported by this port.
 
-Additional environment variables (optional) for OS/2 version:
+Additional optional environment variables:
 
 SDL_AUDIO_SHARE
   Values: 0 or 1, default is 0
@@ -33,7 +33,7 @@ Compiling:
 
 Open Watcom 1.9 or newer is tested. For the new Open Watcom V2 fork, see:
 https://github.com/open-watcom/ and https://open-watcom.github.io
-WATCOM ervironment variable must to be set to the Open Watcom install
+WATCOM environment variable must to be set to the Open Watcom install
 directory. To compile, run: wmake -f Makefile.os2
 
 
@@ -52,3 +52,41 @@ Installing:
   version installed, close all SDL2 applications before replacing the old
   copy.  Also make sure that any other older versions of DLLs are removed
   from your system.
+
+
+Joysticks in SDL2:
+------------------
+
+The joystick code in SDL2 is a direct forward-port from the SDL-1.2 version.
+Here is the original documentation from SDL-1.2:
+
+The Joystick detection only works for standard joysticks (2 buttons, 2 axes
+and the like). Therefore, if you use a non-standard joystick, you should
+specify its features in the SDL_OS2_JOYSTICK environment variable in a batch
+file or CONFIG.SYS, so SDL applications can provide full capability to your
+device. The syntax is:
+
+SET SDL_OS2_JOYSTICK=[JOYSTICK_NAME] [AXES] [BUTTONS] [HATS] [BALLS]
+
+So, it you have a Gravis GamePad with 4 axes, 2 buttons, 2 hats and 0 balls,
+the line should be:
+
+SET SDL_OS2_JOYSTICK=Gravis_GamePad 4 2 2 0
+
+If you want to add spaces in your joystick name, just surround it with
+quotes or double-quotes:
+
+SET SDL_OS2_JOYSTICK='Gravis GamePad' 4 2 2 0
+
+or
+
+SET SDL_OS2_JOYSTICK="Gravis GamePad" 4 2 2 0
+
+   Note however that Balls and Hats are not supported under OS/2, and the
+value will be ignored... but it is wise to define these correctly because
+in the future those can be supported.
+
+   Also the number of buttons is limited to 2 when using two joysticks,
+4 when using one joystick with 4 axes, 6 when using a joystick with 3 axes
+and 8 when using a joystick with 2 axes. Notice however these are limitations
+of the Joystick Port hardware, not OS/2.
diff --git a/Engine/lib/sdl/docs/README-psp.md b/Engine/lib/sdl/docs/README-psp.md
index 0acc93d4c..798a37b65 100644
--- a/Engine/lib/sdl/docs/README-psp.md
+++ b/Engine/lib/sdl/docs/README-psp.md
@@ -1,19 +1,36 @@
 PSP
 ======
-SDL port for the Sony PSP contributed by 
-   Captian Lex 
+SDL2 port for the Sony PSP contributed by:
+- Captian Lex 
+- Francisco Javier Trujillo Mata
+- Wouter Wijsman
+
 
 Credit to
    Marcus R.Brown,Jim Paris,Matthew H for the original SDL 1.2 for PSP
    Geecko for his PSP GU lib "Glib2d"
 
-Building
---------
-To build for the PSP, make sure psp-config is in the path and run:
-   make -f Makefile.psp
+## Building
+To build SDL2 library for the PSP, make sure you have the latest PSPDev status and run:
+```bash
+cmake -S. -Bbuild -DCMAKE_BUILD_TYPE=Release -DCMAKE_TOOLCHAIN_FILE=$PSPDEV/psp/share/pspdev.cmake
+cmake --build build
+cmake --install build
+```
 
 
+## Getting PSP Dev
+[Installing PSP Dev](https://github.com/pspdev/pspdev)
 
-To Do
-------
-PSP Screen Keyboard
+## Running on PPSSPP Emulator
+[PPSSPP](https://github.com/hrydgard/ppsspp)
+
+[Build Instructions](https://github.com/hrydgard/ppsspp/wiki/Build-instructions)
+
+
+## Compiling a HelloWorld
+[PSP Hello World](https://psp-dev.org/doku.php?id=tutorial:hello_world)
+
+## To Do
+- PSP Screen Keyboard
+- Dialogs
\ No newline at end of file
diff --git a/Engine/lib/sdl/docs/README-raspberrypi.md b/Engine/lib/sdl/docs/README-raspberrypi.md
index 2c95e0649..6a85c3cf4 100644
--- a/Engine/lib/sdl/docs/README-raspberrypi.md
+++ b/Engine/lib/sdl/docs/README-raspberrypi.md
@@ -1,13 +1,12 @@
 Raspberry Pi
-================================================================================
+============
 
 Requirements:
 
 Raspbian (other Linux distros may work as well).
 
-================================================================================
- Features
-================================================================================
+Features
+--------
 
 * Works without X11
 * Hardware accelerated OpenGL ES 2.x
@@ -16,9 +15,8 @@ Raspbian (other Linux distros may work as well).
 * Hotplugging of input devices via UDEV
 
 
-================================================================================
- Raspbian Build Dependencies
-================================================================================
+Raspbian Build Dependencies
+---------------------------
 
 sudo apt-get install libudev-dev libasound2-dev libdbus-1-dev
 
@@ -28,18 +26,17 @@ OpenGL ES 2.x, it usually comes pre-installed, but in any case:
 sudo apt-get install libraspberrypi0 libraspberrypi-bin libraspberrypi-dev
 
 
-================================================================================
- NEON
-================================================================================
+NEON
+----
 
 If your Pi has NEON support, make sure you add -mfpu=neon to your CFLAGS so
 that SDL will select some otherwise-disabled highly-optimized code. The
 original Pi units don't have NEON, the Pi2 probably does, and the Pi3
 definitely does.
 
-================================================================================
- Cross compiling from x86 Linux
-================================================================================
+
+Cross compiling from x86 Linux
+------------------------------
 
 To cross compile SDL for Raspbian from your desktop machine, you'll need a
 Raspbian system root and the cross compilation tools. We'll assume these tools
@@ -92,9 +89,8 @@ To be able to deploy this to /usr/local in the Raspbian system you need to fix u
     
     perl -w -pi -e "s#$PWD/rpi-sdl2-installed#/usr/local#g;" ./rpi-sdl2-installed/lib/libSDL2.la ./rpi-sdl2-installed/lib/pkgconfig/sdl2.pc ./rpi-sdl2-installed/bin/sdl2-config
     
-================================================================================
- Apps don't work or poor video/audio performance
-================================================================================
+Apps don't work or poor video/audio performance
+-----------------------------------------------
 
 If you get sound problems, buffer underruns, etc, run "sudo rpi-update" to 
 update the RPi's firmware. Note that doing so will fix these problems, but it
@@ -108,17 +104,15 @@ See here how to configure this setting: http://elinux.org/RPiconfig
 Using a fixed gpu_mem=128 is the best option (specially if you updated the 
 firmware, using CMA probably won't work, at least it's the current case).
 
-================================================================================
- No input
-================================================================================
+No input
+--------
 
 Make sure you belong to the "input" group.
 
     sudo usermod -aG input `whoami`
 
-================================================================================
- No HDMI Audio
-================================================================================
+No HDMI Audio
+-------------
 
 If you notice that ALSA works but there's no audio over HDMI, try adding:
     
@@ -128,9 +122,8 @@ to your config.txt file and reboot.
 
 Reference: http://www.raspberrypi.org/phpBB3/viewtopic.php?t=5062
 
-================================================================================
- Text Input API support
-================================================================================
+Text Input API support
+----------------------
 
 The Text Input API is supported, with translation of scan codes done via the
 kernel symbol tables. For this to work, SDL needs access to a valid console.
@@ -160,9 +153,9 @@ this determining the CAPS LOCK behavior:
 
     sudo dpkg-reconfigure locales
 
-================================================================================
- OpenGL problems
-================================================================================
+
+OpenGL problems
+---------------
 
 If you have desktop OpenGL headers installed at build time in your RPi or cross 
 compilation environment, support for it will be built in. However, the chipset 
@@ -177,9 +170,8 @@ environment variable:
 
     export SDL_RENDER_DRIVER=opengles2
 
-================================================================================
- Notes
-================================================================================
+Notes
+-----
 
 * When launching apps remotely (via SSH), SDL can prevent local keystrokes from
   leaking into the console only if it has root privileges. Launching apps locally
diff --git a/Engine/lib/sdl/docs/README-riscos.md b/Engine/lib/sdl/docs/README-riscos.md
new file mode 100644
index 000000000..76b27e0aa
--- /dev/null
+++ b/Engine/lib/sdl/docs/README-riscos.md
@@ -0,0 +1,41 @@
+RISC OS
+=======
+
+Requirements:
+
+* RISC OS 3.5 or later.
+* [SharedUnixLibrary](http://www.riscos.info/packages/LibraryDetails.html#SharedUnixLibraryarm).
+* [DigitalRenderer](http://www.riscos.info/packages/LibraryDetails.html#DRendererarm), for audio support.
+* [Iconv](http://www.netsurf-browser.org/projects/iconv/), for `SDL_iconv` and related functions.
+
+
+Compiling:
+----------
+
+Currently, SDL2 for RISC OS only supports compiling with GCCSDK under Linux. Both the autoconf and CMake build systems are supported.
+
+The following commands can be used to build SDL2 for RISC OS using autoconf:
+
+    ./configure --host=arm-unknown-riscos --prefix=$GCCSDK_INSTALL_ENV --disable-gcc-atomics
+    make
+    make install
+
+The following commands can be used to build SDL2 for RISC OS using CMake:
+
+    cmake -Bbuild-riscos -DCMAKE_TOOLCHAIN_FILE=$GCCSDK_INSTALL_ENV/toolchain-riscos.cmake -DRISCOS=ON -DCMAKE_INSTALL_PREFIX=$GCCSDK_INSTALL_ENV -DCMAKE_BUILD_TYPE=Release -DSDL_GCC_ATOMICS=OFF
+    cmake --build build-riscos
+    cmake --build build-riscos --target install
+
+
+Current level of implementation
+-------------------------------
+
+The video driver currently provides full screen video support with keyboard and mouse input. Windowed mode is not yet supported, but is planned in the future. Only software rendering is supported.
+
+The filesystem APIs return either Unix-style paths or RISC OS-style paths based on the value of the `__riscosify_control` symbol, as is standard for UnixLib functions.
+
+The audio, loadso, thread and timer APIs are currently provided by UnixLib.
+
+GCC atomics are currently broken on some platforms, meaning it's currently necessary to compile with `--disable-gcc-atomics` using autotools or `-DSDL_GCC_ATOMICS=OFF` using CMake.
+
+The joystick, locale and power APIs are not yet implemented.
diff --git a/Engine/lib/sdl/docs/README-visualc.md b/Engine/lib/sdl/docs/README-visualc.md
new file mode 100644
index 000000000..ea2bc1852
--- /dev/null
+++ b/Engine/lib/sdl/docs/README-visualc.md
@@ -0,0 +1,114 @@
+Using SDL with Microsoft Visual C++
+===================================
+
+### by [Lion Kimbro](mailto:snowlion@sprynet.com) with additions by [James Turk](mailto:james@conceptofzero.net)
+
+You can either use the precompiled libraries from the [SDL](https://www.libsdl.org/download.php) web site, or you can build SDL
+yourself.
+
+### Building SDL
+
+0. To build SDL, your machine must, at a minimum, have the DirectX9.0c SDK installed. It may or may not be retrievable from
+the [Microsoft](https://www.microsoft.com) website, so you might need to locate it [online](https://duckduckgo.com/?q=directx9.0c+sdk+download&t=h_&ia=web).
+_Editor's note: I've been able to successfully build SDL using Visual Studio 2019 **without** the DX9.0c SDK_
+
+1. Open the Visual Studio solution file at `./VisualC/SDL.sln`.
+
+2. Your IDE will likely prompt you to upgrade this solution file to whatever later version of the IDE you're using. In the `Retarget Projects` dialog,
+all of the affected project files should be checked allowing you to use the latest `Windows SDK Version` you have installed, along with
+the `Platform Toolset`.
+   
+If you choose *NOT* to upgrade to use the latest `Windows SDK Version` or `Platform Toolset`, then you'll need the `Visual Studio 2010 Platform Toolset`.
+
+3. Build the `.dll` and `.lib` files by right clicking on each project in turn (Projects are listed in the _Workspace_ 
+panel in the _FileView_ tab), and selecting `Build`.
+
+You may get a few warnings, but you should not get any errors.
+
+Later, we will refer to the following `.lib` and `.dll` files that have just been generated:
+
+-   `./VisualC/Win32/Debug/SDL2.dll` or `./VisualC/Win32/Release/SDL2.dll`
+-   `./VisualC/Win32/Debug/SDL2.lib` or `./VisualC/Win32/Release/SDL2.lib`
+-   `./VisualC/Win32/Debug/SDL2main.lib` or `./VisualC/Win32/Release/SDL2main.lib`
+
+_Note for the `x64` versions, just replace `Win32` in the path with `x64`_
+
+### Creating a Project with SDL
+
+- Create a project as a `Win32 Application`.
+
+- Create a C++ file for your project.
+
+- Set the C runtime to `Multi-threaded DLL` in the menu:
+`Project|Settings|C/C++                  tab|Code Generation|Runtime Library `.
+
+- Add the SDL `include` directory to your list of includes in the menu:
+`Project|Settings|C/C++ tab|Preprocessor|Additional include directories `
+
+*VC7 Specific: Instead of doing this, I find it easier to add the
+include and library directories to the list that VC7 keeps. Do this by
+selecting Tools|Options|Projects|VC++ Directories and under the "Show
+Directories For:" dropbox select "Include Files", and click the "New
+Directory Icon" and add the [SDLROOT]\\include directory (e.g. If you
+installed to c:\\SDL\\ add c:\\SDL\\include). Proceed to change the
+dropbox selection to "Library Files" and add [SDLROOT]\\lib.*
+
+The "include directory" I am referring to is the `./include` folder.
+
+Now we're going to use the files that we had created earlier in the *Build SDL* step.
+
+Copy the following file into your Project directory:
+
+-   `SDL2.dll`
+
+Add the following files to your project (It is not necessary to copy them to your project directory):
+
+-   `SDL2.lib`
+-   `SDL2main.lib`
+
+To add them to your project, right click on your project, and select
+`Add files to project`.
+
+**Instead of adding the files to your project, it is more desirable to add them to the linker options: Project|Properties|Linker|Command Line
+and type the names of the libraries to link with in the "Additional Options:" box. Note: This must be done for each build configuration
+(e.g. Release,Debug).**
+
+### Hello SDL2
+
+Here's a sample SDL snippet to verify everything is setup in your IDE:
+
+```
+    #include "SDL.h"
+
+    int main( int argc, char* argv[] )
+    {
+        const int WIDTH = 640;
+        const int HEIGHT = 480;
+        SDL_Window* window = NULL;
+        SDL_Renderer* renderer = NULL;
+
+        SDL_Init(SDL_INIT_VIDEO);
+        window = SDL_CreateWindow("SDL2 Test", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, WIDTH, HEIGHT, SDL_WINDOW_SHOWN);
+        renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
+ 
+        SDL_DestroyRenderer(renderer);
+        SDL_DestroyWindow(window);
+        SDL_Quit();
+        return 0;
+    }
+ ```               
+
+### That's it!
+
+I hope that this document has helped you get through the most difficult part of using the SDL: installing it. 
+Suggestions for improvements should be posted to the [Github Issues](https://github.com/libsdl-org/SDL/issues).
+
+### Credits
+
+Thanks to [Paulus Esterhazy](mailto:pesterhazy@gmx.net), for the work on VC++ port.
+
+This document was originally called "VisualC.txt", and was written by [Sam Lantinga](mailto:slouken@libsdl.org).
+
+Later, it was converted to HTML and expanded into the document that you see today by [Lion Kimbro](mailto:snowlion@sprynet.com).
+
+Minor Fixes and Visual C++ 7 Information (In Green) was added by [James Turk](mailto:james@conceptofzero.net)
diff --git a/Engine/lib/sdl/docs/README-vita.md b/Engine/lib/sdl/docs/README-vita.md
new file mode 100644
index 000000000..535b4034c
--- /dev/null
+++ b/Engine/lib/sdl/docs/README-vita.md
@@ -0,0 +1,30 @@
+PS Vita
+=======
+SDL port for the Sony Playstation Vita and Sony Playstation TV
+
+Credit to
+* xerpi, cpasjuste and rsn8887 for initial (vita2d) port
+* vitasdk/dolcesdk devs
+* CBPS discord (Namely Graphene and SonicMastr)
+
+Building
+--------
+To build for the PSVita, make sure you have vitasdk and cmake installed and run:
+```
+   cmake -S. -Bbuild -DCMAKE_TOOLCHAIN_FILE=${VITASDK}/share/vita.toolchain.cmake -DCMAKE_BUILD_TYPE=Release
+   cmake --build build
+   cmake --install build
+```
+
+
+Notes
+-----
+* gles1/gles2 support and renderers are disabled by default and can be enabled by configuring with `-DVIDEO_VITA_PVR=ON`
+  These renderers support 720p and 1080i resolutions. These can be specified with: 
+  `SDL_setenv("VITA_RESOLUTION", "720", 1);` and `SDL_setenv("VITA_RESOLUTION", "1080", 1);`
+* gles2 support via PIB is disabled by default and can be enabled by configuring with `-DVIDEO_VITA_PIB=ON`
+* By default SDL emits mouse events for touch events on every touchscreen.  
+  Vita has two touchscreens, so it's recommended to use `SDL_SetHint(SDL_HINT_TOUCH_MOUSE_EVENTS, "0");` and handle touch events instead.
+  Individual touchscreens can be disabled with:
+  `SDL_setenv("VITA_DISABLE_TOUCH_FRONT", "1", 1);` and `SDL_setenv("VITA_DISABLE_TOUCH_BACK", "1", 1);`
+* Support for L2/R2/R3/R3 buttons, haptic feedback and gamepad led only available on PSTV, or when using external ds4 gamepad on vita.
diff --git a/Engine/lib/sdl/docs/README-winrt.md b/Engine/lib/sdl/docs/README-winrt.md
index fe539d83b..87052ff1d 100644
--- a/Engine/lib/sdl/docs/README-winrt.md
+++ b/Engine/lib/sdl/docs/README-winrt.md
@@ -352,38 +352,41 @@ source file, such as, "main.cpp".
 your project, and open the file in Visual C++'s text editor.
 7. Copy and paste the following code into the new file, then save it.
 
-
-    #include <SDL.h>
+```c
+#include <SDL.h>
     
-    int main(int argc, char **argv)
-    {
-        SDL_DisplayMode mode;
-        SDL_Window * window = NULL;
-        SDL_Renderer * renderer = NULL;
-        SDL_Event evt;
+int main(int argc, char **argv)
+{
+    SDL_DisplayMode mode;
+    SDL_Window * window = NULL;
+    SDL_Renderer * renderer = NULL;
+    SDL_Event evt;
+    SDL_bool keep_going = SDL_TRUE;
+  
+    if (SDL_Init(SDL_INIT_VIDEO) != 0) {
+        return 1;
+    } else if (SDL_GetCurrentDisplayMode(0, &mode) != 0) {
+        return 1;
+    } else if (SDL_CreateWindowAndRenderer(mode.w, mode.h, SDL_WINDOW_FULLSCREEN, &window, &renderer) != 0) {
+        return 1;
+    }
     
-        if (SDL_Init(SDL_INIT_VIDEO) != 0) {
-            return 1;
+    while (keep_going) {
+        while (SDL_PollEvent(&evt)) {
+            if ((evt.type == SDL_KEYDOWN) && (evt.key.keysym.sym == SDLK_ESCAPE)) {
+                keep_going = SDL_FALSE;
+            } 
         }
     
-        if (SDL_GetCurrentDisplayMode(0, &mode) != 0) {
-            return 1;
-        }
-    
-        if (SDL_CreateWindowAndRenderer(mode.w, mode.h, SDL_WINDOW_FULLSCREEN, &window, &renderer) != 0) {
-            return 1;
-        }
-    
-        while (1) {
-            while (SDL_PollEvent(&evt)) {
-            }
-    
-            SDL_SetRenderDrawColor(renderer, 0, 255, 0, 255);
-            SDL_RenderClear(renderer);
-            SDL_RenderPresent(renderer);
-        }
+        SDL_SetRenderDrawColor(renderer, 0, 255, 0, 255);
+        SDL_RenderClear(renderer);
+        SDL_RenderPresent(renderer);
     }
 
+    SDL_Quit();
+    return 0;
+}
+```
 
 #### 6.B. Adding code and assets ####
 
diff --git a/Engine/lib/sdl/docs/README.md b/Engine/lib/sdl/docs/README.md
index f34811335..b1b969a79 100644
--- a/Engine/lib/sdl/docs/README.md
+++ b/Engine/lib/sdl/docs/README.md
@@ -14,14 +14,14 @@ hardware via OpenGL and Direct3D. It is used by video playback software,
 emulators, and popular games including Valve's award winning catalog
 and many Humble Bundle games.
 
-SDL officially supports Windows, Mac OS X, Linux, iOS, and Android.
+SDL officially supports Windows, macOS, Linux, iOS, and Android.
 Support for other platforms may be found in the source code.
 
 SDL is written in C, works natively with C++, and there are bindings 
 available for several other languages, including C# and Python.
 
 This library is distributed under the zlib license, which can be found
-in the file "COPYING.txt".
+in the file "LICENSE.txt".
 
 The best way to learn how to use SDL is to check out the header files in
 the "include" subdirectory and the programs in the "test" subdirectory.
@@ -35,10 +35,11 @@ More documentation and FAQs are available online at [the wiki](http://wiki.libsd
 - [DynAPI](README-dynapi.md)
 - [Emscripten](README-emscripten.md)
 - [Gesture](README-gesture.md)
-- [Mercurial](README-hg.md)
+- [Git](README-git.md)
 - [iOS](README-ios.md)
 - [Linux](README-linux.md)
-- [OS X](README-macosx.md)
+- [macOS](README-macos.md)
+- [OS/2](README-os2.md)
 - [Native Client](README-nacl.md)
 - [Pandora](README-pandora.md)
 - [Supported Platforms](README-platforms.md)
@@ -49,15 +50,16 @@ More documentation and FAQs are available online at [the wiki](http://wiki.libsd
 - [WinCE](README-wince.md)
 - [Windows](README-windows.md)
 - [WinRT](README-winrt.md)
+- [PSVita](README-vita.md)
 
 If you need help with the library, or just want to discuss SDL related
-issues, you can join the [developers mailing list](http://www.libsdl.org/mailing-list.php)
+issues, you can join the [SDL Discourse](https://discourse.libsdl.org/),
+which can be used as a web forum or a mailing list, at your preference.
 
 If you want to report bugs or contribute patches, please submit them to
-[bugzilla](https://bugzilla.libsdl.org/)
+[our bug tracker](https://github.com/libsdl-org/SDL/issues)
 
 Enjoy!
 
 
 Sam Lantinga <mailto:slouken@libsdl.org>
-
diff --git a/Engine/lib/sdl/include/SDL.h b/Engine/lib/sdl/include/SDL.h
index e2656caf7..7cdd3243d 100644
--- a/Engine/lib/sdl/include/SDL.h
+++ b/Engine/lib/sdl/include/SDL.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -42,6 +42,7 @@
 #include "SDL_filesystem.h"
 #include "SDL_gamecontroller.h"
 #include "SDL_haptic.h"
+#include "SDL_hidapi.h"
 #include "SDL_hints.h"
 #include "SDL_joystick.h"
 #include "SDL_loadso.h"
@@ -93,37 +94,130 @@ extern "C" {
 /* @} */
 
 /**
- *  This function initializes  the subsystems specified by \c flags
+ * Initialize the SDL library.
+ *
+ * SDL_Init() simply forwards to calling SDL_InitSubSystem(). Therefore, the
+ * two may be used interchangeably. Though for readability of your code
+ * SDL_InitSubSystem() might be preferred.
+ *
+ * The file I/O (for example: SDL_RWFromFile) and threading (SDL_CreateThread)
+ * subsystems are initialized by default. Message boxes
+ * (SDL_ShowSimpleMessageBox) also attempt to work without initializing the
+ * video subsystem, in hopes of being useful in showing an error dialog when
+ * SDL_Init fails. You must specifically initialize other subsystems if you
+ * use them in your application.
+ *
+ * Logging (such as SDL_Log) works without initialization, too.
+ *
+ * `flags` may be any of the following OR'd together:
+ *
+ * - `SDL_INIT_TIMER`: timer subsystem
+ * - `SDL_INIT_AUDIO`: audio subsystem
+ * - `SDL_INIT_VIDEO`: video subsystem; automatically initializes the events
+ *   subsystem
+ * - `SDL_INIT_JOYSTICK`: joystick subsystem; automatically initializes the
+ *   events subsystem
+ * - `SDL_INIT_HAPTIC`: haptic (force feedback) subsystem
+ * - `SDL_INIT_GAMECONTROLLER`: controller subsystem; automatically
+ *   initializes the joystick subsystem
+ * - `SDL_INIT_EVENTS`: events subsystem
+ * - `SDL_INIT_EVERYTHING`: all of the above subsystems
+ * - `SDL_INIT_NOPARACHUTE`: compatibility; this flag is ignored
+ *
+ * Subsystem initialization is ref-counted, you must call SDL_QuitSubSystem()
+ * for each SDL_InitSubSystem() to correctly shutdown a subsystem manually (or
+ * call SDL_Quit() to force shutdown). If a subsystem is already loaded then
+ * this call will increase the ref-count and return.
+ *
+ * \param flags subsystem initialization flags
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_InitSubSystem
+ * \sa SDL_Quit
+ * \sa SDL_SetMainReady
+ * \sa SDL_WasInit
  */
 extern DECLSPEC int SDLCALL SDL_Init(Uint32 flags);
 
 /**
- *  This function initializes specific SDL subsystems
+ * Compatibility function to initialize the SDL library.
  *
- *  Subsystem initialization is ref-counted, you must call
- *  SDL_QuitSubSystem() for each SDL_InitSubSystem() to correctly
- *  shutdown a subsystem manually (or call SDL_Quit() to force shutdown).
- *  If a subsystem is already loaded then this call will
- *  increase the ref-count and return.
+ * In SDL2, this function and SDL_Init() are interchangeable.
+ *
+ * \param flags any of the flags used by SDL_Init(); see SDL_Init for details.
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_Init
+ * \sa SDL_Quit
+ * \sa SDL_QuitSubSystem
  */
 extern DECLSPEC int SDLCALL SDL_InitSubSystem(Uint32 flags);
 
 /**
- *  This function cleans up specific SDL subsystems
+ * Shut down specific SDL subsystems.
+ *
+ * If you start a subsystem using a call to that subsystem's init function
+ * (for example SDL_VideoInit()) instead of SDL_Init() or SDL_InitSubSystem(),
+ * SDL_QuitSubSystem() and SDL_WasInit() will not work. You will need to use
+ * that subsystem's quit function (SDL_VideoQuit()) directly instead. But
+ * generally, you should not be using those functions directly anyhow; use
+ * SDL_Init() instead.
+ *
+ * You still need to call SDL_Quit() even if you close all open subsystems
+ * with SDL_QuitSubSystem().
+ *
+ * \param flags any of the flags used by SDL_Init(); see SDL_Init for details.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_InitSubSystem
+ * \sa SDL_Quit
  */
 extern DECLSPEC void SDLCALL SDL_QuitSubSystem(Uint32 flags);
 
 /**
- *  This function returns a mask of the specified subsystems which have
- *  previously been initialized.
+ * Get a mask of the specified subsystems which are currently initialized.
  *
- *  If \c flags is 0, it returns a mask of all initialized subsystems.
+ * \param flags any of the flags used by SDL_Init(); see SDL_Init for details.
+ * \returns a mask of all initialized subsystems if `flags` is 0, otherwise it
+ *          returns the initialization status of the specified subsystems.
+ *
+ *          The return value does not include SDL_INIT_NOPARACHUTE.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_Init
+ * \sa SDL_InitSubSystem
  */
 extern DECLSPEC Uint32 SDLCALL SDL_WasInit(Uint32 flags);
 
 /**
- *  This function cleans up all initialized subsystems. You should
- *  call it upon all exit conditions.
+ * Clean up all initialized subsystems.
+ *
+ * You should call this function even if you have already shutdown each
+ * initialized subsystem with SDL_QuitSubSystem(). It is safe to call this
+ * function even in the case of errors in initialization.
+ *
+ * If you start a subsystem using a call to that subsystem's init function
+ * (for example SDL_VideoInit()) instead of SDL_Init() or SDL_InitSubSystem(),
+ * then you must use that subsystem's quit function (SDL_VideoQuit()) to shut
+ * it down before calling SDL_Quit(). But generally, you should not be using
+ * those functions directly anyhow; use SDL_Init() instead.
+ *
+ * You can use this function with atexit() to ensure that it is run when your
+ * application is shutdown, but it is not wise to do this from a library or
+ * other dynamically loaded code.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_Init
+ * \sa SDL_QuitSubSystem
  */
 extern DECLSPEC void SDLCALL SDL_Quit(void);
 
diff --git a/Engine/lib/sdl/include/SDL_assert.h b/Engine/lib/sdl/include/SDL_assert.h
index f8a368ec1..defadf137 100644
--- a/Engine/lib/sdl/include/SDL_assert.h
+++ b/Engine/lib/sdl/include/SDL_assert.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -53,8 +53,10 @@ assert can have unique static variables associated with it.
     #define SDL_TriggerBreakpoint() __debugbreak()
 #elif ( (!defined(__NACL__)) && ((defined(__GNUC__) || defined(__clang__)) && (defined(__i386__) || defined(__x86_64__))) )
     #define SDL_TriggerBreakpoint() __asm__ __volatile__ ( "int $3\n\t" )
-#elif ( defined(__APPLE__) && defined(__arm64__) )  /* this might work on other ARM targets, but this is a known quantity... */
+#elif ( defined(__APPLE__) && (defined(__arm64__) || defined(__aarch64__)) )  /* this might work on other ARM targets, but this is a known quantity... */
     #define SDL_TriggerBreakpoint() __asm__ __volatile__ ( "brk #22\n\t" )
+#elif defined(__APPLE__) && defined(__arm__)
+    #define SDL_TriggerBreakpoint() __asm__ __volatile__ ( "bkpt #22\n\t" )
 #elif defined(__386__) && defined(__WATCOMC__)
     #define SDL_TriggerBreakpoint() { _asm { int 0x03 } }
 #elif defined(HAVE_SIGNAL_H) && !defined(__WATCOMC__)
@@ -187,92 +189,121 @@ extern DECLSPEC SDL_AssertState SDLCALL SDL_ReportAssertion(SDL_AssertData *,
 #define SDL_assert_always(condition) SDL_enabled_assert(condition)
 
 
+/**
+ * A callback that fires when an SDL assertion fails.
+ *
+ * \param data a pointer to the SDL_AssertData structure corresponding to the
+ *             current assertion
+ * \param userdata what was passed as `userdata` to SDL_SetAssertionHandler()
+ * \returns an SDL_AssertState value indicating how to handle the failure.
+ */
 typedef SDL_AssertState (SDLCALL *SDL_AssertionHandler)(
                                  const SDL_AssertData* data, void* userdata);
 
 /**
- *  \brief Set an application-defined assertion handler.
+ * Set an application-defined assertion handler.
  *
- *  This allows an app to show its own assertion UI and/or force the
- *  response to an assertion failure. If the app doesn't provide this, SDL
- *  will try to do the right thing, popping up a system-specific GUI dialog,
- *  and probably minimizing any fullscreen windows.
+ * This function allows an application to show its own assertion UI and/or
+ * force the response to an assertion failure. If the application doesn't
+ * provide this, SDL will try to do the right thing, popping up a
+ * system-specific GUI dialog, and probably minimizing any fullscreen windows.
  *
- *  This callback may fire from any thread, but it runs wrapped in a mutex, so
- *  it will only fire from one thread at a time.
+ * This callback may fire from any thread, but it runs wrapped in a mutex, so
+ * it will only fire from one thread at a time.
  *
- *  Setting the callback to NULL restores SDL's original internal handler.
+ * This callback is NOT reset to SDL's internal handler upon SDL_Quit()!
  *
- *  This callback is NOT reset to SDL's internal handler upon SDL_Quit()!
+ * \param handler the SDL_AssertionHandler function to call when an assertion
+ *                fails or NULL for the default handler
+ * \param userdata a pointer that is passed to `handler`
  *
- *  Return SDL_AssertState value of how to handle the assertion failure.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \param handler Callback function, called when an assertion fails.
- *  \param userdata A pointer passed to the callback as-is.
+ * \sa SDL_GetAssertionHandler
  */
 extern DECLSPEC void SDLCALL SDL_SetAssertionHandler(
                                             SDL_AssertionHandler handler,
                                             void *userdata);
 
 /**
- *  \brief Get the default assertion handler.
+ * Get the default assertion handler.
  *
- *  This returns the function pointer that is called by default when an
- *   assertion is triggered. This is an internal function provided by SDL,
- *   that is used for assertions when SDL_SetAssertionHandler() hasn't been
- *   used to provide a different function.
+ * This returns the function pointer that is called by default when an
+ * assertion is triggered. This is an internal function provided by SDL, that
+ * is used for assertions when SDL_SetAssertionHandler() hasn't been used to
+ * provide a different function.
  *
- *  \return The default SDL_AssertionHandler that is called when an assert triggers.
+ * \returns the default SDL_AssertionHandler that is called when an assert
+ *          triggers.
+ *
+ * \since This function is available since SDL 2.0.2.
+ *
+ * \sa SDL_GetAssertionHandler
  */
 extern DECLSPEC SDL_AssertionHandler SDLCALL SDL_GetDefaultAssertionHandler(void);
 
 /**
- *  \brief Get the current assertion handler.
+ * Get the current assertion handler.
  *
- *  This returns the function pointer that is called when an assertion is
- *   triggered. This is either the value last passed to
- *   SDL_SetAssertionHandler(), or if no application-specified function is
- *   set, is equivalent to calling SDL_GetDefaultAssertionHandler().
+ * This returns the function pointer that is called when an assertion is
+ * triggered. This is either the value last passed to
+ * SDL_SetAssertionHandler(), or if no application-specified function is set,
+ * is equivalent to calling SDL_GetDefaultAssertionHandler().
  *
- *   \param puserdata Pointer to a void*, which will store the "userdata"
- *                    pointer that was passed to SDL_SetAssertionHandler().
- *                    This value will always be NULL for the default handler.
- *                    If you don't care about this data, it is safe to pass
- *                    a NULL pointer to this function to ignore it.
- *  \return The SDL_AssertionHandler that is called when an assert triggers.
+ * The parameter `puserdata` is a pointer to a void*, which will store the
+ * "userdata" pointer that was passed to SDL_SetAssertionHandler(). This value
+ * will always be NULL for the default handler. If you don't care about this
+ * data, it is safe to pass a NULL pointer to this function to ignore it.
+ *
+ * \param puserdata pointer which is filled with the "userdata" pointer that
+ *                  was passed to SDL_SetAssertionHandler()
+ * \returns the SDL_AssertionHandler that is called when an assert triggers.
+ *
+ * \since This function is available since SDL 2.0.2.
+ *
+ * \sa SDL_SetAssertionHandler
  */
 extern DECLSPEC SDL_AssertionHandler SDLCALL SDL_GetAssertionHandler(void **puserdata);
 
 /**
- *  \brief Get a list of all assertion failures.
+ * Get a list of all assertion failures.
  *
- *  Get all assertions triggered since last call to SDL_ResetAssertionReport(),
- *  or the start of the program.
+ * This function gets all assertions triggered since the last call to
+ * SDL_ResetAssertionReport(), or the start of the program.
  *
- *  The proper way to examine this data looks something like this:
+ * The proper way to examine this data looks something like this:
  *
- *  <code>
- *  const SDL_AssertData *item = SDL_GetAssertionReport();
- *  while (item) {
- *      printf("'%s', %s (%s:%d), triggered %u times, always ignore: %s.\\n",
- *             item->condition, item->function, item->filename,
- *             item->linenum, item->trigger_count,
- *             item->always_ignore ? "yes" : "no");
- *      item = item->next;
- *  }
- *  </code>
+ * ```c
+ * const SDL_AssertData *item = SDL_GetAssertionReport();
+ * while (item) {
+ *    printf("'%s', %s (%s:%d), triggered %u times, always ignore: %s.\\n",
+ *           item->condition, item->function, item->filename,
+ *           item->linenum, item->trigger_count,
+ *           item->always_ignore ? "yes" : "no");
+ *    item = item->next;
+ * }
+ * ```
  *
- *  \return List of all assertions.
- *  \sa SDL_ResetAssertionReport
+ * \returns a list of all failed assertions or NULL if the list is empty. This
+ *          memory should not be modified or freed by the application.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_ResetAssertionReport
  */
 extern DECLSPEC const SDL_AssertData * SDLCALL SDL_GetAssertionReport(void);
 
 /**
- *  \brief Reset the list of all assertion failures.
+ * Clear the list of all assertion failures.
  *
- *  Reset list of all assertions triggered.
+ * This function will clear the list of all assertions triggered up to that
+ * point. Immediately following this call, SDL_GetAssertionReport will return
+ * no items. In addition, any previously-triggered assertions will be reset to
+ * a trigger_count of zero, and their always_ignore state will be false.
  *
- *  \sa SDL_GetAssertionReport
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetAssertionReport
  */
 extern DECLSPEC void SDLCALL SDL_ResetAssertionReport(void);
 
diff --git a/Engine/lib/sdl/include/SDL_atomic.h b/Engine/lib/sdl/include/SDL_atomic.h
index e99f1bcc6..b29ceeac2 100644
--- a/Engine/lib/sdl/include/SDL_atomic.h
+++ b/Engine/lib/sdl/include/SDL_atomic.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -89,25 +89,51 @@ extern "C" {
 typedef int SDL_SpinLock;
 
 /**
- * \brief Try to lock a spin lock by setting it to a non-zero value.
+ * Try to lock a spin lock by setting it to a non-zero value.
  *
- * \param lock Points to the lock.
+ * ***Please note that spinlocks are dangerous if you don't know what you're
+ * doing. Please be careful using any sort of spinlock!***
  *
- * \return SDL_TRUE if the lock succeeded, SDL_FALSE if the lock is already held.
+ * \param lock a pointer to a lock variable
+ * \returns SDL_TRUE if the lock succeeded, SDL_FALSE if the lock is already
+ *          held.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_AtomicLock
+ * \sa SDL_AtomicUnlock
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_AtomicTryLock(SDL_SpinLock *lock);
 
 /**
- * \brief Lock a spin lock by setting it to a non-zero value.
+ * Lock a spin lock by setting it to a non-zero value.
  *
- * \param lock Points to the lock.
+ * ***Please note that spinlocks are dangerous if you don't know what you're
+ * doing. Please be careful using any sort of spinlock!***
+ *
+ * \param lock a pointer to a lock variable
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_AtomicTryLock
+ * \sa SDL_AtomicUnlock
  */
 extern DECLSPEC void SDLCALL SDL_AtomicLock(SDL_SpinLock *lock);
 
 /**
- * \brief Unlock a spin lock by setting it to 0. Always returns immediately
+ * Unlock a spin lock by setting it to 0.
  *
- * \param lock Points to the lock.
+ * Always returns immediately.
+ *
+ * ***Please note that spinlocks are dangerous if you don't know what you're
+ * doing. Please be careful using any sort of spinlock!***
+ *
+ * \param lock a pointer to a lock variable
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_AtomicLock
+ * \sa SDL_AtomicTryLock
  */
 extern DECLSPEC void SDLCALL SDL_AtomicUnlock(SDL_SpinLock *lock);
 
@@ -126,7 +152,7 @@ void _ReadWriteBarrier(void);
 /* This is correct for all CPUs when using GCC or Solaris Studio 12.1+. */
 #define SDL_CompilerBarrier()   __asm__ __volatile__ ("" : : : "memory")
 #elif defined(__WATCOMC__)
-extern _inline void SDL_CompilerBarrier (void);
+extern __inline void SDL_CompilerBarrier(void);
 #pragma aux SDL_CompilerBarrier = "" parm [] modify exact [];
 #else
 #define SDL_CompilerBarrier()   \
@@ -137,20 +163,22 @@ extern _inline void SDL_CompilerBarrier (void);
  * Memory barriers are designed to prevent reads and writes from being
  * reordered by the compiler and being seen out of order on multi-core CPUs.
  *
- * A typical pattern would be for thread A to write some data and a flag,
- * and for thread B to read the flag and get the data. In this case you
- * would insert a release barrier between writing the data and the flag,
+ * A typical pattern would be for thread A to write some data and a flag, and
+ * for thread B to read the flag and get the data. In this case you would
+ * insert a release barrier between writing the data and the flag,
  * guaranteeing that the data write completes no later than the flag is
- * written, and you would insert an acquire barrier between reading the
- * flag and reading the data, to ensure that all the reads associated
- * with the flag have completed.
+ * written, and you would insert an acquire barrier between reading the flag
+ * and reading the data, to ensure that all the reads associated with the flag
+ * have completed.
  *
- * In this pattern you should always see a release barrier paired with
- * an acquire barrier and you should gate the data reads/writes with a
- * single flag variable.
+ * In this pattern you should always see a release barrier paired with an
+ * acquire barrier and you should gate the data reads/writes with a single
+ * flag variable.
  *
  * For more information on these semantics, take a look at the blog post:
  * http://preshing.com/20120913/acquire-and-release-semantics
+ *
+ * \since This function is available since SDL 2.0.6.
  */
 extern DECLSPEC void SDLCALL SDL_MemoryBarrierReleaseFunction(void);
 extern DECLSPEC void SDLCALL SDL_MemoryBarrierAcquireFunction(void);
@@ -216,32 +244,73 @@ typedef void (*SDL_KernelMemoryBarrierFunc)();
 typedef struct { int value; } SDL_atomic_t;
 
 /**
- * \brief Set an atomic variable to a new value if it is currently an old value.
+ * Set an atomic variable to a new value if it is currently an old value.
  *
- * \return SDL_TRUE if the atomic variable was set, SDL_FALSE otherwise.
+ * ***Note: If you don't know what this function is for, you shouldn't use
+ * it!***
  *
- * \note If you don't know what this function is for, you shouldn't use it!
-*/
+ * \param a a pointer to an SDL_atomic_t variable to be modified
+ * \param oldval the old value
+ * \param newval the new value
+ * \returns SDL_TRUE if the atomic variable was set, SDL_FALSE otherwise.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_AtomicCASPtr
+ * \sa SDL_AtomicGet
+ * \sa SDL_AtomicSet
+ */
 extern DECLSPEC SDL_bool SDLCALL SDL_AtomicCAS(SDL_atomic_t *a, int oldval, int newval);
 
 /**
- * \brief Set an atomic variable to a value.
+ * Set an atomic variable to a value.
  *
- * \return The previous value of the atomic variable.
+ * This function also acts as a full memory barrier.
+ *
+ * ***Note: If you don't know what this function is for, you shouldn't use
+ * it!***
+ *
+ * \param a a pointer to an SDL_atomic_t variable to be modified
+ * \param v the desired value
+ * \returns the previous value of the atomic variable.
+ *
+ * \since This function is available since SDL 2.0.2.
+ *
+ * \sa SDL_AtomicGet
  */
 extern DECLSPEC int SDLCALL SDL_AtomicSet(SDL_atomic_t *a, int v);
 
 /**
- * \brief Get the value of an atomic variable
+ * Get the value of an atomic variable.
+ *
+ * ***Note: If you don't know what this function is for, you shouldn't use
+ * it!***
+ *
+ * \param a a pointer to an SDL_atomic_t variable
+ * \returns the current value of an atomic variable.
+ *
+ * \since This function is available since SDL 2.0.2.
+ *
+ * \sa SDL_AtomicSet
  */
 extern DECLSPEC int SDLCALL SDL_AtomicGet(SDL_atomic_t *a);
 
 /**
- * \brief Add to an atomic variable.
+ * Add to an atomic variable.
  *
- * \return The previous value of the atomic variable.
+ * This function also acts as a full memory barrier.
  *
- * \note This same style can be used for any number operation
+ * ***Note: If you don't know what this function is for, you shouldn't use
+ * it!***
+ *
+ * \param a a pointer to an SDL_atomic_t variable to be modified
+ * \param v the desired value to add
+ * \returns the previous value of the atomic variable.
+ *
+ * \since This function is available since SDL 2.0.2.
+ *
+ * \sa SDL_AtomicDecRef
+ * \sa SDL_AtomicIncRef
  */
 extern DECLSPEC int SDLCALL SDL_AtomicAdd(SDL_atomic_t *a, int v);
 
@@ -263,23 +332,54 @@ extern DECLSPEC int SDLCALL SDL_AtomicAdd(SDL_atomic_t *a, int v);
 #endif
 
 /**
- * \brief Set a pointer to a new value if it is currently an old value.
+ * Set a pointer to a new value if it is currently an old value.
  *
- * \return SDL_TRUE if the pointer was set, SDL_FALSE otherwise.
+ * ***Note: If you don't know what this function is for, you shouldn't use
+ * it!***
  *
- * \note If you don't know what this function is for, you shouldn't use it!
-*/
+ * \param a a pointer to a pointer
+ * \param oldval the old pointer value
+ * \param newval the new pointer value
+ * \returns SDL_TRUE if the pointer was set, SDL_FALSE otherwise.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_AtomicCAS
+ * \sa SDL_AtomicGetPtr
+ * \sa SDL_AtomicSetPtr
+ */
 extern DECLSPEC SDL_bool SDLCALL SDL_AtomicCASPtr(void **a, void *oldval, void *newval);
 
 /**
- * \brief Set a pointer to a value atomically.
+ * Set a pointer to a value atomically.
  *
- * \return The previous value of the pointer.
+ * ***Note: If you don't know what this function is for, you shouldn't use
+ * it!***
+ *
+ * \param a a pointer to a pointer
+ * \param v the desired pointer value
+ * \returns the previous value of the pointer.
+ *
+ * \since This function is available since SDL 2.0.2.
+ *
+ * \sa SDL_AtomicCASPtr
+ * \sa SDL_AtomicGetPtr
  */
 extern DECLSPEC void* SDLCALL SDL_AtomicSetPtr(void **a, void* v);
 
 /**
- * \brief Get the value of a pointer atomically.
+ * Get the value of a pointer atomically.
+ *
+ * ***Note: If you don't know what this function is for, you shouldn't use
+ * it!***
+ *
+ * \param a a pointer to a pointer
+ * \returns the current value of a pointer.
+ *
+ * \since This function is available since SDL 2.0.2.
+ *
+ * \sa SDL_AtomicCASPtr
+ * \sa SDL_AtomicSetPtr
  */
 extern DECLSPEC void* SDLCALL SDL_AtomicGetPtr(void **a);
 
diff --git a/Engine/lib/sdl/include/SDL_audio.h b/Engine/lib/sdl/include/SDL_audio.h
index 4ba349147..ab25ec93d 100644
--- a/Engine/lib/sdl/include/SDL_audio.h
+++ b/Engine/lib/sdl/include/SDL_audio.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -19,6 +19,8 @@
   3. This notice may not be removed or altered from any source distribution.
 */
 
+/* !!! FIXME: several functions in here need Doxygen comments. */
+
 /**
  *  \file SDL_audio.h
  *
@@ -212,9 +214,12 @@ typedef void (SDLCALL * SDL_AudioFilter) (struct SDL_AudioCVT * cvt,
  *  set both its (buf) field to a pointer that is aligned to 16 bytes, and its
  *  (len) field to something that's a multiple of 16, if possible.
  */
-#ifdef __GNUC__
+#if defined(__GNUC__) && !defined(__CHERI_PURE_CAPABILITY__)
 /* This structure is 84 bytes on 32-bit architectures, make sure GCC doesn't
    pad it out to 88 bytes to guarantee ABI compatibility between compilers.
+   This is not a concern on CHERI architectures, where pointers must be stored
+   at aligned locations otherwise they will become invalid, and thus structs
+   containing pointers cannot be packed without giving a warning or error.
    vvv
    The next time we rev the ABI, make sure to size the ints and add padding.
 */
@@ -248,7 +253,48 @@ typedef struct SDL_AudioCVT
  *  order that they are normally initialized by default.
  */
 /* @{ */
+
+/**
+ * Use this function to get the number of built-in audio drivers.
+ *
+ * This function returns a hardcoded number. This never returns a negative
+ * value; if there are no drivers compiled into this build of SDL, this
+ * function returns zero. The presence of a driver in this list does not mean
+ * it will function, it just means SDL is capable of interacting with that
+ * interface. For example, a build of SDL might have esound support, but if
+ * there's no esound server available, SDL's esound driver would fail if used.
+ *
+ * By default, SDL tries all drivers, in its preferred order, until one is
+ * found to be usable.
+ *
+ * \returns the number of built-in audio drivers.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetAudioDriver
+ */
 extern DECLSPEC int SDLCALL SDL_GetNumAudioDrivers(void);
+
+/**
+ * Use this function to get the name of a built in audio driver.
+ *
+ * The list of audio drivers is given in the order that they are normally
+ * initialized by default; the drivers that seem more reasonable to choose
+ * first (as far as the SDL developers believe) are earlier in the list.
+ *
+ * The names of drivers are all simple, low-ASCII identifiers, like "alsa",
+ * "coreaudio" or "xaudio2". These never have Unicode characters, and are not
+ * meant to be proper names.
+ *
+ * \param index the index of the audio driver; the value ranges from 0 to
+ *              SDL_GetNumAudioDrivers() - 1
+ * \returns the name of the audio driver at the requested index, or NULL if an
+ *          invalid index was specified.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetNumAudioDrivers
+ */
 extern DECLSPEC const char *SDLCALL SDL_GetAudioDriver(int index);
 /* @} */
 
@@ -260,60 +306,103 @@ extern DECLSPEC const char *SDLCALL SDL_GetAudioDriver(int index);
  *            use.  You should normally use SDL_Init() or SDL_InitSubSystem().
  */
 /* @{ */
+
+/**
+ * Use this function to initialize a particular audio driver.
+ *
+ * This function is used internally, and should not be used unless you have a
+ * specific need to designate the audio driver you want to use. You should
+ * normally use SDL_Init() or SDL_InitSubSystem().
+ *
+ * \param driver_name the name of the desired audio driver
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_AudioQuit
+ */
 extern DECLSPEC int SDLCALL SDL_AudioInit(const char *driver_name);
+
+/**
+ * Use this function to shut down audio if you initialized it with
+ * SDL_AudioInit().
+ *
+ * This function is used internally, and should not be used unless you have a
+ * specific need to specify the audio driver you want to use. You should
+ * normally use SDL_Quit() or SDL_QuitSubSystem().
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_AudioInit
+ */
 extern DECLSPEC void SDLCALL SDL_AudioQuit(void);
 /* @} */
 
 /**
- *  This function returns the name of the current audio driver, or NULL
- *  if no driver has been initialized.
+ * Get the name of the current audio driver.
+ *
+ * The returned string points to internal static memory and thus never becomes
+ * invalid, even if you quit the audio subsystem and initialize a new driver
+ * (although such a case would return a different static string from another
+ * call to this function, of course). As such, you should not modify or free
+ * the returned string.
+ *
+ * \returns the name of the current audio driver or NULL if no driver has been
+ *          initialized.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_AudioInit
  */
 extern DECLSPEC const char *SDLCALL SDL_GetCurrentAudioDriver(void);
 
 /**
- *  This function opens the audio device with the desired parameters, and
- *  returns 0 if successful, placing the actual hardware parameters in the
- *  structure pointed to by \c obtained.  If \c obtained is NULL, the audio
- *  data passed to the callback function will be guaranteed to be in the
- *  requested format, and will be automatically converted to the hardware
- *  audio format if necessary.  This function returns -1 if it failed
- *  to open the audio device, or couldn't set up the audio thread.
+ * This function is a legacy means of opening the audio device.
  *
- *  When filling in the desired audio spec structure,
- *    - \c desired->freq should be the desired audio frequency in samples-per-
- *      second.
- *    - \c desired->format should be the desired audio format.
- *    - \c desired->samples is the desired size of the audio buffer, in
- *      samples.  This number should be a power of two, and may be adjusted by
- *      the audio driver to a value more suitable for the hardware.  Good values
- *      seem to range between 512 and 8096 inclusive, depending on the
- *      application and CPU speed.  Smaller values yield faster response time,
- *      but can lead to underflow if the application is doing heavy processing
- *      and cannot fill the audio buffer in time.  A stereo sample consists of
- *      both right and left channels in LR ordering.
- *      Note that the number of samples is directly related to time by the
- *      following formula:  \code ms = (samples*1000)/freq \endcode
- *    - \c desired->size is the size in bytes of the audio buffer, and is
- *      calculated by SDL_OpenAudio().
- *    - \c desired->silence is the value used to set the buffer to silence,
- *      and is calculated by SDL_OpenAudio().
- *    - \c desired->callback should be set to a function that will be called
- *      when the audio device is ready for more data.  It is passed a pointer
- *      to the audio buffer, and the length in bytes of the audio buffer.
- *      This function usually runs in a separate thread, and so you should
- *      protect data structures that it accesses by calling SDL_LockAudio()
- *      and SDL_UnlockAudio() in your code. Alternately, you may pass a NULL
- *      pointer here, and call SDL_QueueAudio() with some frequency, to queue
- *      more audio samples to be played (or for capture devices, call
- *      SDL_DequeueAudio() with some frequency, to obtain audio samples).
- *    - \c desired->userdata is passed as the first parameter to your callback
- *      function. If you passed a NULL callback, this value is ignored.
+ * This function remains for compatibility with SDL 1.2, but also because it's
+ * slightly easier to use than the new functions in SDL 2.0. The new, more
+ * powerful, and preferred way to do this is SDL_OpenAudioDevice().
  *
- *  The audio device starts out playing silence when it's opened, and should
- *  be enabled for playing by calling \c SDL_PauseAudio(0) when you are ready
- *  for your audio callback function to be called.  Since the audio driver
- *  may modify the requested size of the audio buffer, you should allocate
- *  any local mixing buffers after you open the audio device.
+ * This function is roughly equivalent to:
+ *
+ * ```c
+ * SDL_OpenAudioDevice(NULL, 0, desired, obtained, SDL_AUDIO_ALLOW_ANY_CHANGE);
+ * ```
+ *
+ * With two notable exceptions:
+ *
+ * - If `obtained` is NULL, we use `desired` (and allow no changes), which
+ *   means desired will be modified to have the correct values for silence,
+ *   etc, and SDL will convert any differences between your app's specific
+ *   request and the hardware behind the scenes.
+ * - The return value is always success or failure, and not a device ID, which
+ *   means you can only have one device open at a time with this function.
+ *
+ * \param desired an SDL_AudioSpec structure representing the desired output
+ *                format. Please refer to the SDL_OpenAudioDevice
+ *                documentation for details on how to prepare this structure.
+ * \param obtained an SDL_AudioSpec structure filled in with the actual
+ *                 parameters, or NULL.
+ * \returns 0 if successful, placing the actual hardware parameters in the
+ *          structure pointed to by `obtained`.
+ *
+ *          If `obtained` is NULL, the audio data passed to the callback
+ *          function will be guaranteed to be in the requested format, and
+ *          will be automatically converted to the actual hardware audio
+ *          format if necessary. If `obtained` is NULL, `desired` will have
+ *          fields modified.
+ *
+ *          This function returns a negative error code on failure to open the
+ *          audio device or failure to set up the audio thread; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CloseAudio
+ * \sa SDL_LockAudio
+ * \sa SDL_PauseAudio
+ * \sa SDL_UnlockAudio
  */
 extern DECLSPEC int SDLCALL SDL_OpenAudio(SDL_AudioSpec * desired,
                                           SDL_AudioSpec * obtained);
@@ -330,59 +419,221 @@ extern DECLSPEC int SDLCALL SDL_OpenAudio(SDL_AudioSpec * desired,
 typedef Uint32 SDL_AudioDeviceID;
 
 /**
- *  Get the number of available devices exposed by the current driver.
- *  Only valid after a successfully initializing the audio subsystem.
- *  Returns -1 if an explicit list of devices can't be determined; this is
- *  not an error. For example, if SDL is set up to talk to a remote audio
- *  server, it can't list every one available on the Internet, but it will
- *  still allow a specific host to be specified to SDL_OpenAudioDevice().
+ * Get the number of built-in audio devices.
  *
- *  In many common cases, when this function returns a value <= 0, it can still
- *  successfully open the default device (NULL for first argument of
- *  SDL_OpenAudioDevice()).
+ * This function is only valid after successfully initializing the audio
+ * subsystem.
+ *
+ * Note that audio capture support is not implemented as of SDL 2.0.4, so the
+ * `iscapture` parameter is for future expansion and should always be zero for
+ * now.
+ *
+ * This function will return -1 if an explicit list of devices can't be
+ * determined. Returning -1 is not an error. For example, if SDL is set up to
+ * talk to a remote audio server, it can't list every one available on the
+ * Internet, but it will still allow a specific host to be specified in
+ * SDL_OpenAudioDevice().
+ *
+ * In many common cases, when this function returns a value <= 0, it can still
+ * successfully open the default device (NULL for first argument of
+ * SDL_OpenAudioDevice()).
+ *
+ * This function may trigger a complete redetect of available hardware. It
+ * should not be called for each iteration of a loop, but rather once at the
+ * start of a loop:
+ *
+ * ```c
+ * // Don't do this:
+ * for (int i = 0; i < SDL_GetNumAudioDevices(0); i++)
+ *
+ * // do this instead:
+ * const int count = SDL_GetNumAudioDevices(0);
+ * for (int i = 0; i < count; ++i) { do_something_here(); }
+ * ```
+ *
+ * \param iscapture zero to request playback devices, non-zero to request
+ *                  recording devices
+ * \returns the number of available devices exposed by the current driver or
+ *          -1 if an explicit list of devices can't be determined. A return
+ *          value of -1 does not necessarily mean an error condition.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetAudioDeviceName
+ * \sa SDL_OpenAudioDevice
  */
 extern DECLSPEC int SDLCALL SDL_GetNumAudioDevices(int iscapture);
 
 /**
- *  Get the human-readable name of a specific audio device.
- *  Must be a value between 0 and (number of audio devices-1).
- *  Only valid after a successfully initializing the audio subsystem.
- *  The values returned by this function reflect the latest call to
- *  SDL_GetNumAudioDevices(); recall that function to redetect available
- *  hardware.
+ * Get the human-readable name of a specific audio device.
  *
- *  The string returned by this function is UTF-8 encoded, read-only, and
- *  managed internally. You are not to free it. If you need to keep the
- *  string for any length of time, you should make your own copy of it, as it
- *  will be invalid next time any of several other SDL functions is called.
+ * This function is only valid after successfully initializing the audio
+ * subsystem. The values returned by this function reflect the latest call to
+ * SDL_GetNumAudioDevices(); re-call that function to redetect available
+ * hardware.
+ *
+ * The string returned by this function is UTF-8 encoded, read-only, and
+ * managed internally. You are not to free it. If you need to keep the string
+ * for any length of time, you should make your own copy of it, as it will be
+ * invalid next time any of several other SDL functions are called.
+ *
+ * \param index the index of the audio device; valid values range from 0 to
+ *              SDL_GetNumAudioDevices() - 1
+ * \param iscapture non-zero to query the list of recording devices, zero to
+ *                  query the list of output devices.
+ * \returns the name of the audio device at the requested index, or NULL on
+ *          error.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetNumAudioDevices
  */
 extern DECLSPEC const char *SDLCALL SDL_GetAudioDeviceName(int index,
                                                            int iscapture);
 
+/**
+ * Get the preferred audio format of a specific audio device.
+ *
+ * This function is only valid after a successfully initializing the audio
+ * subsystem. The values returned by this function reflect the latest call to
+ * SDL_GetNumAudioDevices(); re-call that function to redetect available
+ * hardware.
+ *
+ * `spec` will be filled with the sample rate, sample format, and channel
+ * count.
+ *
+ * \param index the index of the audio device; valid values range from 0 to
+ *              SDL_GetNumAudioDevices() - 1
+ * \param iscapture non-zero to query the list of recording devices, zero to
+ *                  query the list of output devices.
+ * \param spec The SDL_AudioSpec to be initialized by this function.
+ * \returns 0 on success, nonzero on error
+ *
+ * \since This function is available since SDL 2.0.16.
+ *
+ * \sa SDL_GetNumAudioDevices
+ */
+extern DECLSPEC int SDLCALL SDL_GetAudioDeviceSpec(int index,
+                                                   int iscapture,
+                                                   SDL_AudioSpec *spec);
+
 
 /**
- *  Open a specific audio device. Passing in a device name of NULL requests
- *  the most reasonable default (and is equivalent to calling SDL_OpenAudio()).
+ * Open a specific audio device.
  *
- *  The device name is a UTF-8 string reported by SDL_GetAudioDeviceName(), but
- *  some drivers allow arbitrary and driver-specific strings, such as a
- *  hostname/IP address for a remote audio server, or a filename in the
- *  diskaudio driver.
+ * SDL_OpenAudio(), unlike this function, always acts on device ID 1. As such,
+ * this function will never return a 1 so as not to conflict with the legacy
+ * function.
  *
- *  \return 0 on error, a valid device ID that is >= 2 on success.
+ * Please note that SDL 2.0 before 2.0.5 did not support recording; as such,
+ * this function would fail if `iscapture` was not zero. Starting with SDL
+ * 2.0.5, recording is implemented and this value can be non-zero.
  *
- *  SDL_OpenAudio(), unlike this function, always acts on device ID 1.
+ * Passing in a `device` name of NULL requests the most reasonable default
+ * (and is equivalent to what SDL_OpenAudio() does to choose a device). The
+ * `device` name is a UTF-8 string reported by SDL_GetAudioDeviceName(), but
+ * some drivers allow arbitrary and driver-specific strings, such as a
+ * hostname/IP address for a remote audio server, or a filename in the
+ * diskaudio driver.
+ *
+ * An opened audio device starts out paused, and should be enabled for playing
+ * by calling SDL_PauseAudioDevice(devid, 0) when you are ready for your audio
+ * callback function to be called. Since the audio driver may modify the
+ * requested size of the audio buffer, you should allocate any local mixing
+ * buffers after you open the audio device.
+ *
+ * The audio callback runs in a separate thread in most cases; you can prevent
+ * race conditions between your callback and other threads without fully
+ * pausing playback with SDL_LockAudioDevice(). For more information about the
+ * callback, see SDL_AudioSpec.
+ *
+ * Managing the audio spec via 'desired' and 'obtained':
+ *
+ * When filling in the desired audio spec structure:
+ *
+ * - `desired->freq` should be the frequency in sample-frames-per-second (Hz).
+ * - `desired->format` should be the audio format (`AUDIO_S16SYS`, etc).
+ * - `desired->samples` is the desired size of the audio buffer, in _sample
+ *   frames_ (with stereo output, two samples--left and right--would make a
+ *   single sample frame). This number should be a power of two, and may be
+ *   adjusted by the audio driver to a value more suitable for the hardware.
+ *   Good values seem to range between 512 and 8096 inclusive, depending on
+ *   the application and CPU speed. Smaller values reduce latency, but can
+ *   lead to underflow if the application is doing heavy processing and cannot
+ *   fill the audio buffer in time. Note that the number of sample frames is
+ *   directly related to time by the following formula: `ms =
+ *   (sampleframes*1000)/freq`
+ * - `desired->size` is the size in _bytes_ of the audio buffer, and is
+ *   calculated by SDL_OpenAudioDevice(). You don't initialize this.
+ * - `desired->silence` is the value used to set the buffer to silence, and is
+ *   calculated by SDL_OpenAudioDevice(). You don't initialize this.
+ * - `desired->callback` should be set to a function that will be called when
+ *   the audio device is ready for more data. It is passed a pointer to the
+ *   audio buffer, and the length in bytes of the audio buffer. This function
+ *   usually runs in a separate thread, and so you should protect data
+ *   structures that it accesses by calling SDL_LockAudioDevice() and
+ *   SDL_UnlockAudioDevice() in your code. Alternately, you may pass a NULL
+ *   pointer here, and call SDL_QueueAudio() with some frequency, to queue
+ *   more audio samples to be played (or for capture devices, call
+ *   SDL_DequeueAudio() with some frequency, to obtain audio samples).
+ * - `desired->userdata` is passed as the first parameter to your callback
+ *   function. If you passed a NULL callback, this value is ignored.
+ *
+ * `allowed_changes` can have the following flags OR'd together:
+ *
+ * - `SDL_AUDIO_ALLOW_FREQUENCY_CHANGE`
+ * - `SDL_AUDIO_ALLOW_FORMAT_CHANGE`
+ * - `SDL_AUDIO_ALLOW_CHANNELS_CHANGE`
+ * - `SDL_AUDIO_ALLOW_ANY_CHANGE`
+ *
+ * These flags specify how SDL should behave when a device cannot offer a
+ * specific feature. If the application requests a feature that the hardware
+ * doesn't offer, SDL will always try to get the closest equivalent.
+ *
+ * For example, if you ask for float32 audio format, but the sound card only
+ * supports int16, SDL will set the hardware to int16. If you had set
+ * SDL_AUDIO_ALLOW_FORMAT_CHANGE, SDL will change the format in the `obtained`
+ * structure. If that flag was *not* set, SDL will prepare to convert your
+ * callback's float32 audio to int16 before feeding it to the hardware and
+ * will keep the originally requested format in the `obtained` structure.
+ *
+ * The resulting audio specs, varying depending on hardware and on what
+ * changes were allowed, will then be written back to `obtained`.
+ *
+ * If your application can only handle one specific data format, pass a zero
+ * for `allowed_changes` and let SDL transparently handle any differences.
+ *
+ * \param device a UTF-8 string reported by SDL_GetAudioDeviceName() or a
+ *               driver-specific name as appropriate. NULL requests the most
+ *               reasonable default device.
+ * \param iscapture non-zero to specify a device should be opened for
+ *                  recording, not playback
+ * \param desired an SDL_AudioSpec structure representing the desired output
+ *                format; see SDL_OpenAudio() for more information
+ * \param obtained an SDL_AudioSpec structure filled in with the actual output
+ *                 format; see SDL_OpenAudio() for more information
+ * \param allowed_changes 0, or one or more flags OR'd together
+ * \returns a valid device ID that is > 0 on success or 0 on failure; call
+ *          SDL_GetError() for more information.
+ *
+ *          For compatibility with SDL 1.2, this will never return 1, since
+ *          SDL reserves that ID for the legacy SDL_OpenAudio() function.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CloseAudioDevice
+ * \sa SDL_GetAudioDeviceName
+ * \sa SDL_LockAudioDevice
+ * \sa SDL_OpenAudio
+ * \sa SDL_PauseAudioDevice
+ * \sa SDL_UnlockAudioDevice
  */
-extern DECLSPEC SDL_AudioDeviceID SDLCALL SDL_OpenAudioDevice(const char
-                                                              *device,
-                                                              int iscapture,
-                                                              const
-                                                              SDL_AudioSpec *
-                                                              desired,
-                                                              SDL_AudioSpec *
-                                                              obtained,
-                                                              int
-                                                              allowed_changes);
+extern DECLSPEC SDL_AudioDeviceID SDLCALL SDL_OpenAudioDevice(
+                                                  const char *device,
+                                                  int iscapture,
+                                                  const SDL_AudioSpec *desired,
+                                                  SDL_AudioSpec *obtained,
+                                                  int allowed_changes);
 
 
 
@@ -398,10 +649,39 @@ typedef enum
     SDL_AUDIO_PLAYING,
     SDL_AUDIO_PAUSED
 } SDL_AudioStatus;
+
+/**
+ * This function is a legacy means of querying the audio device.
+ *
+ * New programs might want to use SDL_GetAudioDeviceStatus() instead. This
+ * function is equivalent to calling...
+ *
+ * ```c
+ * SDL_GetAudioDeviceStatus(1);
+ * ```
+ *
+ * ...and is only useful if you used the legacy SDL_OpenAudio() function.
+ *
+ * \returns the SDL_AudioStatus of the audio device opened by SDL_OpenAudio().
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetAudioDeviceStatus
+ */
 extern DECLSPEC SDL_AudioStatus SDLCALL SDL_GetAudioStatus(void);
 
-extern DECLSPEC SDL_AudioStatus SDLCALL
-SDL_GetAudioDeviceStatus(SDL_AudioDeviceID dev);
+/**
+ * Use this function to get the current audio state of an audio device.
+ *
+ * \param dev the ID of an audio device previously opened with
+ *            SDL_OpenAudioDevice()
+ * \returns the SDL_AudioStatus of the specified audio device.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_PauseAudioDevice
+ */
+extern DECLSPEC SDL_AudioStatus SDLCALL SDL_GetAudioDeviceStatus(SDL_AudioDeviceID dev);
 /* @} *//* Audio State */
 
 /**
@@ -414,62 +694,140 @@ SDL_GetAudioDeviceStatus(SDL_AudioDeviceID dev);
  *  Silence will be written to the audio device during the pause.
  */
 /* @{ */
+
+/**
+ * This function is a legacy means of pausing the audio device.
+ *
+ * New programs might want to use SDL_PauseAudioDevice() instead. This
+ * function is equivalent to calling...
+ *
+ * ```c
+ * SDL_PauseAudioDevice(1, pause_on);
+ * ```
+ *
+ * ...and is only useful if you used the legacy SDL_OpenAudio() function.
+ *
+ * \param pause_on non-zero to pause, 0 to unpause
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetAudioStatus
+ * \sa SDL_PauseAudioDevice
+ */
 extern DECLSPEC void SDLCALL SDL_PauseAudio(int pause_on);
+
+/**
+ * Use this function to pause and unpause audio playback on a specified
+ * device.
+ *
+ * This function pauses and unpauses the audio callback processing for a given
+ * device. Newly-opened audio devices start in the paused state, so you must
+ * call this function with **pause_on**=0 after opening the specified audio
+ * device to start playing sound. This allows you to safely initialize data
+ * for your callback function after opening the audio device. Silence will be
+ * written to the audio device while paused, and the audio callback is
+ * guaranteed to not be called. Pausing one device does not prevent other
+ * unpaused devices from running their callbacks.
+ *
+ * Pausing state does not stack; even if you pause a device several times, a
+ * single unpause will start the device playing again, and vice versa. This is
+ * different from how SDL_LockAudioDevice() works.
+ *
+ * If you just need to protect a few variables from race conditions vs your
+ * callback, you shouldn't pause the audio device, as it will lead to dropouts
+ * in the audio playback. Instead, you should use SDL_LockAudioDevice().
+ *
+ * \param dev a device opened by SDL_OpenAudioDevice()
+ * \param pause_on non-zero to pause, 0 to unpause
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_LockAudioDevice
+ */
 extern DECLSPEC void SDLCALL SDL_PauseAudioDevice(SDL_AudioDeviceID dev,
                                                   int pause_on);
 /* @} *//* Pause audio functions */
 
 /**
- *  \brief Load the audio data of a WAVE file into memory
+ * Load the audio data of a WAVE file into memory.
  *
- *  Loading a WAVE file requires \c src, \c spec, \c audio_buf and \c audio_len
- *  to be valid pointers. The entire data portion of the file is then loaded
- *  into memory and decoded if necessary.
+ * Loading a WAVE file requires `src`, `spec`, `audio_buf` and `audio_len` to
+ * be valid pointers. The entire data portion of the file is then loaded into
+ * memory and decoded if necessary.
  *
- *  If \c freesrc is non-zero, the data source gets automatically closed and
- *  freed before the function returns.
+ * If `freesrc` is non-zero, the data source gets automatically closed and
+ * freed before the function returns.
  *
- *  Supported are RIFF WAVE files with the formats PCM (8, 16, 24, and 32 bits),
- *  IEEE Float (32 bits), Microsoft ADPCM and IMA ADPCM (4 bits), and A-law and
- *  µ-law (8 bits). Other formats are currently unsupported and cause an error.
+ * Supported formats are RIFF WAVE files with the formats PCM (8, 16, 24, and
+ * 32 bits), IEEE Float (32 bits), Microsoft ADPCM and IMA ADPCM (4 bits), and
+ * A-law and mu-law (8 bits). Other formats are currently unsupported and
+ * cause an error.
  *
- *  If this function succeeds, the pointer returned by it is equal to \c spec
- *  and the pointer to the audio data allocated by the function is written to
- *  \c audio_buf and its length in bytes to \c audio_len. The \ref SDL_AudioSpec
- *  members \c freq, \c channels, and \c format are set to the values of the
- *  audio data in the buffer. The \c samples member is set to a sane default and
- *  all others are set to zero.
+ * If this function succeeds, the pointer returned by it is equal to `spec`
+ * and the pointer to the audio data allocated by the function is written to
+ * `audio_buf` and its length in bytes to `audio_len`. The SDL_AudioSpec
+ * members `freq`, `channels`, and `format` are set to the values of the audio
+ * data in the buffer. The `samples` member is set to a sane default and all
+ * others are set to zero.
  *
- *  It's necessary to use SDL_FreeWAV() to free the audio data returned in
- *  \c audio_buf when it is no longer used.
+ * It's necessary to use SDL_FreeWAV() to free the audio data returned in
+ * `audio_buf` when it is no longer used.
  *
- *  Because of the underspecification of the Waveform format, there are many
- *  problematic files in the wild that cause issues with strict decoders. To
- *  provide compatibility with these files, this decoder is lenient in regards
- *  to the truncation of the file, the fact chunk, and the size of the RIFF
- *  chunk. The hints SDL_HINT_WAVE_RIFF_CHUNK_SIZE, SDL_HINT_WAVE_TRUNCATION,
- *  and SDL_HINT_WAVE_FACT_CHUNK can be used to tune the behavior of the
- *  loading process.
+ * Because of the underspecification of the .WAV format, there are many
+ * problematic files in the wild that cause issues with strict decoders. To
+ * provide compatibility with these files, this decoder is lenient in regards
+ * to the truncation of the file, the fact chunk, and the size of the RIFF
+ * chunk. The hints `SDL_HINT_WAVE_RIFF_CHUNK_SIZE`,
+ * `SDL_HINT_WAVE_TRUNCATION`, and `SDL_HINT_WAVE_FACT_CHUNK` can be used to
+ * tune the behavior of the loading process.
  *
- *  Any file that is invalid (due to truncation, corruption, or wrong values in
- *  the headers), too big, or unsupported causes an error. Additionally, any
- *  critical I/O error from the data source will terminate the loading process
- *  with an error. The function returns NULL on error and in all cases (with the
- *  exception of \c src being NULL), an appropriate error message will be set.
+ * Any file that is invalid (due to truncation, corruption, or wrong values in
+ * the headers), too big, or unsupported causes an error. Additionally, any
+ * critical I/O error from the data source will terminate the loading process
+ * with an error. The function returns NULL on error and in all cases (with
+ * the exception of `src` being NULL), an appropriate error message will be
+ * set.
  *
- *  It is required that the data source supports seeking.
+ * It is required that the data source supports seeking.
  *
- *  Example:
- *  \code
- *      SDL_LoadWAV_RW(SDL_RWFromFile("sample.wav", "rb"), 1, ...);
- *  \endcode
+ * Example:
  *
- *  \param src The data source with the WAVE data
- *  \param freesrc A integer value that makes the function close the data source if non-zero
- *  \param spec A pointer filled with the audio format of the audio data
- *  \param audio_buf A pointer filled with the audio data allocated by the function
- *  \param audio_len A pointer filled with the length of the audio data buffer in bytes
- *  \return NULL on error, or non-NULL on success.
+ * ```c
+ * SDL_LoadWAV_RW(SDL_RWFromFile("sample.wav", "rb"), 1, &spec, &buf, &len);
+ * ```
+ *
+ * Note that the SDL_LoadWAV macro does this same thing for you, but in a less
+ * messy way:
+ *
+ * ```c
+ * SDL_LoadWAV("sample.wav", &spec, &buf, &len);
+ * ```
+ *
+ * \param src The data source for the WAVE data
+ * \param freesrc If non-zero, SDL will _always_ free the data source
+ * \param spec An SDL_AudioSpec that will be filled in with the wave file's
+ *             format details
+ * \param audio_buf A pointer filled with the audio data, allocated by the
+ *                  function.
+ * \param audio_len A pointer filled with the length of the audio data buffer
+ *                  in bytes
+ * \returns This function, if successfully called, returns `spec`, which will
+ *          be filled with the audio data format of the wave source data.
+ *          `audio_buf` will be filled with a pointer to an allocated buffer
+ *          containing the audio data, and `audio_len` is filled with the
+ *          length of that audio buffer in bytes.
+ *
+ *          This function returns NULL if the .WAV file cannot be opened, uses
+ *          an unknown data format, or is corrupt; call SDL_GetError() for
+ *          more information.
+ *
+ *          When the application is done with the data returned in
+ *          `audio_buf`, it should call SDL_FreeWAV() to dispose of it.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_FreeWAV
+ * \sa SDL_LoadWAV
  */
 extern DECLSPEC SDL_AudioSpec *SDLCALL SDL_LoadWAV_RW(SDL_RWops * src,
                                                       int freesrc,
@@ -485,18 +843,53 @@ extern DECLSPEC SDL_AudioSpec *SDLCALL SDL_LoadWAV_RW(SDL_RWops * src,
     SDL_LoadWAV_RW(SDL_RWFromFile(file, "rb"),1, spec,audio_buf,audio_len)
 
 /**
- *  This function frees data previously allocated with SDL_LoadWAV_RW()
+ * Free data previously allocated with SDL_LoadWAV() or SDL_LoadWAV_RW().
+ *
+ * After a WAVE file has been opened with SDL_LoadWAV() or SDL_LoadWAV_RW()
+ * its data can eventually be freed with SDL_FreeWAV(). It is safe to call
+ * this function with a NULL pointer.
+ *
+ * \param audio_buf a pointer to the buffer created by SDL_LoadWAV() or
+ *                  SDL_LoadWAV_RW()
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_LoadWAV
+ * \sa SDL_LoadWAV_RW
  */
 extern DECLSPEC void SDLCALL SDL_FreeWAV(Uint8 * audio_buf);
 
 /**
- *  This function takes a source format and rate and a destination format
- *  and rate, and initializes the \c cvt structure with information needed
- *  by SDL_ConvertAudio() to convert a buffer of audio data from one format
- *  to the other. An unsupported format causes an error and -1 will be returned.
+ * Initialize an SDL_AudioCVT structure for conversion.
  *
- *  \return 0 if no conversion is needed, 1 if the audio filter is set up,
- *  or -1 on error.
+ * Before an SDL_AudioCVT structure can be used to convert audio data it must
+ * be initialized with source and destination information.
+ *
+ * This function will zero out every field of the SDL_AudioCVT, so it must be
+ * called before the application fills in the final buffer information.
+ *
+ * Once this function has returned successfully, and reported that a
+ * conversion is necessary, the application fills in the rest of the fields in
+ * SDL_AudioCVT, now that it knows how large a buffer it needs to allocate,
+ * and then can call SDL_ConvertAudio() to complete the conversion.
+ *
+ * \param cvt an SDL_AudioCVT structure filled in with audio conversion
+ *            information
+ * \param src_format the source format of the audio data; for more info see
+ *                   SDL_AudioFormat
+ * \param src_channels the number of channels in the source
+ * \param src_rate the frequency (sample-frames-per-second) of the source
+ * \param dst_format the destination format of the audio data; for more info
+ *                   see SDL_AudioFormat
+ * \param dst_channels the number of channels in the destination
+ * \param dst_rate the frequency (sample-frames-per-second) of the destination
+ * \returns 1 if the audio filter is prepared, 0 if no conversion is needed,
+ *          or a negative error code on failure; call SDL_GetError() for more
+ *          information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_ConvertAudio
  */
 extern DECLSPEC int SDLCALL SDL_BuildAudioCVT(SDL_AudioCVT * cvt,
                                               SDL_AudioFormat src_format,
@@ -507,16 +900,42 @@ extern DECLSPEC int SDLCALL SDL_BuildAudioCVT(SDL_AudioCVT * cvt,
                                               int dst_rate);
 
 /**
- *  Once you have initialized the \c cvt structure using SDL_BuildAudioCVT(),
- *  created an audio buffer \c cvt->buf, and filled it with \c cvt->len bytes of
- *  audio data in the source format, this function will convert it in-place
- *  to the desired format.
+ * Convert audio data to a desired audio format.
  *
- *  The data conversion may expand the size of the audio data, so the buffer
- *  \c cvt->buf should be allocated after the \c cvt structure is initialized by
- *  SDL_BuildAudioCVT(), and should be \c cvt->len*cvt->len_mult bytes long.
+ * This function does the actual audio data conversion, after the application
+ * has called SDL_BuildAudioCVT() to prepare the conversion information and
+ * then filled in the buffer details.
  *
- *  \return 0 on success or -1 if \c cvt->buf is NULL.
+ * Once the application has initialized the `cvt` structure using
+ * SDL_BuildAudioCVT(), allocated an audio buffer and filled it with audio
+ * data in the source format, this function will convert the buffer, in-place,
+ * to the desired format.
+ *
+ * The data conversion may go through several passes; any given pass may
+ * possibly temporarily increase the size of the data. For example, SDL might
+ * expand 16-bit data to 32 bits before resampling to a lower frequency,
+ * shrinking the data size after having grown it briefly. Since the supplied
+ * buffer will be both the source and destination, converting as necessary
+ * in-place, the application must allocate a buffer that will fully contain
+ * the data during its largest conversion pass. After SDL_BuildAudioCVT()
+ * returns, the application should set the `cvt->len` field to the size, in
+ * bytes, of the source data, and allocate a buffer that is `cvt->len *
+ * cvt->len_mult` bytes long for the `buf` field.
+ *
+ * The source data should be copied into this buffer before the call to
+ * SDL_ConvertAudio(). Upon successful return, this buffer will contain the
+ * converted audio, and `cvt->len_cvt` will be the size of the converted data,
+ * in bytes. Any bytes in the buffer past `cvt->len_cvt` are undefined once
+ * this function returns.
+ *
+ * \param cvt an SDL_AudioCVT structure that was previously set up by
+ *            SDL_BuildAudioCVT().
+ * \returns 0 if the conversion was completed successfully or a negative error
+ *          code on failure; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_BuildAudioCVT
  */
 extern DECLSPEC int SDLCALL SDL_ConvertAudio(SDL_AudioCVT * cvt);
 
@@ -532,22 +951,24 @@ struct _SDL_AudioStream;
 typedef struct _SDL_AudioStream SDL_AudioStream;
 
 /**
- *  Create a new audio stream
+ * Create a new audio stream.
  *
- *  \param src_format The format of the source audio
- *  \param src_channels The number of channels of the source audio
- *  \param src_rate The sampling rate of the source audio
- *  \param dst_format The format of the desired audio output
- *  \param dst_channels The number of channels of the desired audio output
- *  \param dst_rate The sampling rate of the desired audio output
- *  \return 0 on success, or -1 on error.
+ * \param src_format The format of the source audio
+ * \param src_channels The number of channels of the source audio
+ * \param src_rate The sampling rate of the source audio
+ * \param dst_format The format of the desired audio output
+ * \param dst_channels The number of channels of the desired audio output
+ * \param dst_rate The sampling rate of the desired audio output
+ * \returns 0 on success, or -1 on error.
  *
- *  \sa SDL_AudioStreamPut
- *  \sa SDL_AudioStreamGet
- *  \sa SDL_AudioStreamAvailable
- *  \sa SDL_AudioStreamFlush
- *  \sa SDL_AudioStreamClear
- *  \sa SDL_FreeAudioStream
+ * \since This function is available since SDL 2.0.7.
+ *
+ * \sa SDL_AudioStreamPut
+ * \sa SDL_AudioStreamGet
+ * \sa SDL_AudioStreamAvailable
+ * \sa SDL_AudioStreamFlush
+ * \sa SDL_AudioStreamClear
+ * \sa SDL_FreeAudioStream
  */
 extern DECLSPEC SDL_AudioStream * SDLCALL SDL_NewAudioStream(const SDL_AudioFormat src_format,
                                            const Uint8 src_channels,
@@ -557,110 +978,164 @@ extern DECLSPEC SDL_AudioStream * SDLCALL SDL_NewAudioStream(const SDL_AudioForm
                                            const int dst_rate);
 
 /**
- *  Add data to be converted/resampled to the stream
+ * Add data to be converted/resampled to the stream.
  *
- *  \param stream The stream the audio data is being added to
- *  \param buf A pointer to the audio data to add
- *  \param len The number of bytes to write to the stream
- *  \return 0 on success, or -1 on error.
+ * \param stream The stream the audio data is being added to
+ * \param buf A pointer to the audio data to add
+ * \param len The number of bytes to write to the stream
+ * \returns 0 on success, or -1 on error.
  *
- *  \sa SDL_NewAudioStream
- *  \sa SDL_AudioStreamGet
- *  \sa SDL_AudioStreamAvailable
- *  \sa SDL_AudioStreamFlush
- *  \sa SDL_AudioStreamClear
- *  \sa SDL_FreeAudioStream
+ * \since This function is available since SDL 2.0.7.
+ *
+ * \sa SDL_NewAudioStream
+ * \sa SDL_AudioStreamGet
+ * \sa SDL_AudioStreamAvailable
+ * \sa SDL_AudioStreamFlush
+ * \sa SDL_AudioStreamClear
+ * \sa SDL_FreeAudioStream
  */
 extern DECLSPEC int SDLCALL SDL_AudioStreamPut(SDL_AudioStream *stream, const void *buf, int len);
 
 /**
- *  Get converted/resampled data from the stream
+ * Get converted/resampled data from the stream
  *
- *  \param stream The stream the audio is being requested from
- *  \param buf A buffer to fill with audio data
- *  \param len The maximum number of bytes to fill
- *  \return The number of bytes read from the stream, or -1 on error
+ * \param stream The stream the audio is being requested from
+ * \param buf A buffer to fill with audio data
+ * \param len The maximum number of bytes to fill
+ * \returns the number of bytes read from the stream, or -1 on error
  *
- *  \sa SDL_NewAudioStream
- *  \sa SDL_AudioStreamPut
- *  \sa SDL_AudioStreamAvailable
- *  \sa SDL_AudioStreamFlush
- *  \sa SDL_AudioStreamClear
- *  \sa SDL_FreeAudioStream
+ * \since This function is available since SDL 2.0.7.
+ *
+ * \sa SDL_NewAudioStream
+ * \sa SDL_AudioStreamPut
+ * \sa SDL_AudioStreamAvailable
+ * \sa SDL_AudioStreamFlush
+ * \sa SDL_AudioStreamClear
+ * \sa SDL_FreeAudioStream
  */
 extern DECLSPEC int SDLCALL SDL_AudioStreamGet(SDL_AudioStream *stream, void *buf, int len);
 
 /**
- * Get the number of converted/resampled bytes available. The stream may be
- *  buffering data behind the scenes until it has enough to resample
- *  correctly, so this number might be lower than what you expect, or even
- *  be zero. Add more data or flush the stream if you need the data now.
+ * Get the number of converted/resampled bytes available.
  *
- *  \sa SDL_NewAudioStream
- *  \sa SDL_AudioStreamPut
- *  \sa SDL_AudioStreamGet
- *  \sa SDL_AudioStreamFlush
- *  \sa SDL_AudioStreamClear
- *  \sa SDL_FreeAudioStream
+ * The stream may be buffering data behind the scenes until it has enough to
+ * resample correctly, so this number might be lower than what you expect, or
+ * even be zero. Add more data or flush the stream if you need the data now.
+ *
+ * \since This function is available since SDL 2.0.7.
+ *
+ * \sa SDL_NewAudioStream
+ * \sa SDL_AudioStreamPut
+ * \sa SDL_AudioStreamGet
+ * \sa SDL_AudioStreamFlush
+ * \sa SDL_AudioStreamClear
+ * \sa SDL_FreeAudioStream
  */
 extern DECLSPEC int SDLCALL SDL_AudioStreamAvailable(SDL_AudioStream *stream);
 
 /**
  * Tell the stream that you're done sending data, and anything being buffered
- *  should be converted/resampled and made available immediately.
+ * should be converted/resampled and made available immediately.
  *
- * It is legal to add more data to a stream after flushing, but there will
- *  be audio gaps in the output. Generally this is intended to signal the
- *  end of input, so the complete output becomes available.
+ * It is legal to add more data to a stream after flushing, but there will be
+ * audio gaps in the output. Generally this is intended to signal the end of
+ * input, so the complete output becomes available.
  *
- *  \sa SDL_NewAudioStream
- *  \sa SDL_AudioStreamPut
- *  \sa SDL_AudioStreamGet
- *  \sa SDL_AudioStreamAvailable
- *  \sa SDL_AudioStreamClear
- *  \sa SDL_FreeAudioStream
+ * \since This function is available since SDL 2.0.7.
+ *
+ * \sa SDL_NewAudioStream
+ * \sa SDL_AudioStreamPut
+ * \sa SDL_AudioStreamGet
+ * \sa SDL_AudioStreamAvailable
+ * \sa SDL_AudioStreamClear
+ * \sa SDL_FreeAudioStream
  */
 extern DECLSPEC int SDLCALL SDL_AudioStreamFlush(SDL_AudioStream *stream);
 
 /**
- *  Clear any pending data in the stream without converting it
+ * Clear any pending data in the stream without converting it
  *
- *  \sa SDL_NewAudioStream
- *  \sa SDL_AudioStreamPut
- *  \sa SDL_AudioStreamGet
- *  \sa SDL_AudioStreamAvailable
- *  \sa SDL_AudioStreamFlush
- *  \sa SDL_FreeAudioStream
+ * \since This function is available since SDL 2.0.7.
+ *
+ * \sa SDL_NewAudioStream
+ * \sa SDL_AudioStreamPut
+ * \sa SDL_AudioStreamGet
+ * \sa SDL_AudioStreamAvailable
+ * \sa SDL_AudioStreamFlush
+ * \sa SDL_FreeAudioStream
  */
 extern DECLSPEC void SDLCALL SDL_AudioStreamClear(SDL_AudioStream *stream);
 
 /**
  * Free an audio stream
  *
- *  \sa SDL_NewAudioStream
- *  \sa SDL_AudioStreamPut
- *  \sa SDL_AudioStreamGet
- *  \sa SDL_AudioStreamAvailable
- *  \sa SDL_AudioStreamFlush
- *  \sa SDL_AudioStreamClear
+ * \since This function is available since SDL 2.0.7.
+ *
+ * \sa SDL_NewAudioStream
+ * \sa SDL_AudioStreamPut
+ * \sa SDL_AudioStreamGet
+ * \sa SDL_AudioStreamAvailable
+ * \sa SDL_AudioStreamFlush
+ * \sa SDL_AudioStreamClear
  */
 extern DECLSPEC void SDLCALL SDL_FreeAudioStream(SDL_AudioStream *stream);
 
 #define SDL_MIX_MAXVOLUME 128
+
 /**
- *  This takes two audio buffers of the playing audio format and mixes
- *  them, performing addition, volume adjustment, and overflow clipping.
- *  The volume ranges from 0 - 128, and should be set to ::SDL_MIX_MAXVOLUME
- *  for full audio volume.  Note this does not change hardware volume.
- *  This is provided for convenience -- you can mix your own audio data.
+ * This function is a legacy means of mixing audio.
+ *
+ * This function is equivalent to calling...
+ *
+ * ```c
+ * SDL_MixAudioFormat(dst, src, format, len, volume);
+ * ```
+ *
+ * ...where `format` is the obtained format of the audio device from the
+ * legacy SDL_OpenAudio() function.
+ *
+ * \param dst the destination for the mixed audio
+ * \param src the source audio buffer to be mixed
+ * \param len the length of the audio buffer in bytes
+ * \param volume ranges from 0 - 128, and should be set to SDL_MIX_MAXVOLUME
+ *               for full audio volume
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_MixAudioFormat
  */
 extern DECLSPEC void SDLCALL SDL_MixAudio(Uint8 * dst, const Uint8 * src,
                                           Uint32 len, int volume);
 
 /**
- *  This works like SDL_MixAudio(), but you specify the audio format instead of
- *  using the format of audio device 1. Thus it can be used when no audio
- *  device is open at all.
+ * Mix audio data in a specified format.
+ *
+ * This takes an audio buffer `src` of `len` bytes of `format` data and mixes
+ * it into `dst`, performing addition, volume adjustment, and overflow
+ * clipping. The buffer pointed to by `dst` must also be `len` bytes of
+ * `format` data.
+ *
+ * This is provided for convenience -- you can mix your own audio data.
+ *
+ * Do not use this function for mixing together more than two streams of
+ * sample data. The output from repeated application of this function may be
+ * distorted by clipping, because there is no accumulator with greater range
+ * than the input (not to mention this being an inefficient way of doing it).
+ *
+ * It is a common misconception that this function is required to write audio
+ * data to an output stream in an audio callback. While you can do that,
+ * SDL_MixAudioFormat() is really only needed when you're mixing a single
+ * audio stream with a volume adjustment.
+ *
+ * \param dst the destination for the mixed audio
+ * \param src the source audio buffer to be mixed
+ * \param format the SDL_AudioFormat structure representing the desired audio
+ *               format
+ * \param len the length of the audio buffer in bytes
+ * \param volume ranges from 0 - 128, and should be set to SDL_MIX_MAXVOLUME
+ *               for full audio volume
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC void SDLCALL SDL_MixAudioFormat(Uint8 * dst,
                                                 const Uint8 * src,
@@ -668,161 +1143,166 @@ extern DECLSPEC void SDLCALL SDL_MixAudioFormat(Uint8 * dst,
                                                 Uint32 len, int volume);
 
 /**
- *  Queue more audio on non-callback devices.
+ * Queue more audio on non-callback devices.
  *
- *  (If you are looking to retrieve queued audio from a non-callback capture
- *  device, you want SDL_DequeueAudio() instead. This will return -1 to
- *  signify an error if you use it with capture devices.)
+ * If you are looking to retrieve queued audio from a non-callback capture
+ * device, you want SDL_DequeueAudio() instead. SDL_QueueAudio() will return
+ * -1 to signify an error if you use it with capture devices.
  *
- *  SDL offers two ways to feed audio to the device: you can either supply a
- *  callback that SDL triggers with some frequency to obtain more audio
- *  (pull method), or you can supply no callback, and then SDL will expect
- *  you to supply data at regular intervals (push method) with this function.
+ * SDL offers two ways to feed audio to the device: you can either supply a
+ * callback that SDL triggers with some frequency to obtain more audio (pull
+ * method), or you can supply no callback, and then SDL will expect you to
+ * supply data at regular intervals (push method) with this function.
  *
- *  There are no limits on the amount of data you can queue, short of
- *  exhaustion of address space. Queued data will drain to the device as
- *  necessary without further intervention from you. If the device needs
- *  audio but there is not enough queued, it will play silence to make up
- *  the difference. This means you will have skips in your audio playback
- *  if you aren't routinely queueing sufficient data.
+ * There are no limits on the amount of data you can queue, short of
+ * exhaustion of address space. Queued data will drain to the device as
+ * necessary without further intervention from you. If the device needs audio
+ * but there is not enough queued, it will play silence to make up the
+ * difference. This means you will have skips in your audio playback if you
+ * aren't routinely queueing sufficient data.
  *
- *  This function copies the supplied data, so you are safe to free it when
- *  the function returns. This function is thread-safe, but queueing to the
- *  same device from two threads at once does not promise which buffer will
- *  be queued first.
+ * This function copies the supplied data, so you are safe to free it when the
+ * function returns. This function is thread-safe, but queueing to the same
+ * device from two threads at once does not promise which buffer will be
+ * queued first.
  *
- *  You may not queue audio on a device that is using an application-supplied
- *  callback; doing so returns an error. You have to use the audio callback
- *  or queue audio with this function, but not both.
+ * You may not queue audio on a device that is using an application-supplied
+ * callback; doing so returns an error. You have to use the audio callback or
+ * queue audio with this function, but not both.
  *
- *  You should not call SDL_LockAudio() on the device before queueing; SDL
- *  handles locking internally for this function.
+ * You should not call SDL_LockAudio() on the device before queueing; SDL
+ * handles locking internally for this function.
  *
- *  \param dev The device ID to which we will queue audio.
- *  \param data The data to queue to the device for later playback.
- *  \param len The number of bytes (not samples!) to which (data) points.
- *  \return 0 on success, or -1 on error.
+ * Note that SDL2 does not support planar audio. You will need to resample
+ * from planar audio formats into a non-planar one (see SDL_AudioFormat)
+ * before queuing audio.
  *
- *  \sa SDL_GetQueuedAudioSize
- *  \sa SDL_ClearQueuedAudio
+ * \param dev the device ID to which we will queue audio
+ * \param data the data to queue to the device for later playback
+ * \param len the number of bytes (not samples!) to which `data` points
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.4.
+ *
+ * \sa SDL_ClearQueuedAudio
+ * \sa SDL_GetQueuedAudioSize
  */
 extern DECLSPEC int SDLCALL SDL_QueueAudio(SDL_AudioDeviceID dev, const void *data, Uint32 len);
 
 /**
- *  Dequeue more audio on non-callback devices.
+ * Dequeue more audio on non-callback devices.
  *
- *  (If you are looking to queue audio for output on a non-callback playback
- *  device, you want SDL_QueueAudio() instead. This will always return 0
- *  if you use it with playback devices.)
+ * If you are looking to queue audio for output on a non-callback playback
+ * device, you want SDL_QueueAudio() instead. SDL_DequeueAudio() will always
+ * return 0 if you use it with playback devices.
  *
- *  SDL offers two ways to retrieve audio from a capture device: you can
- *  either supply a callback that SDL triggers with some frequency as the
- *  device records more audio data, (push method), or you can supply no
- *  callback, and then SDL will expect you to retrieve data at regular
- *  intervals (pull method) with this function.
+ * SDL offers two ways to retrieve audio from a capture device: you can either
+ * supply a callback that SDL triggers with some frequency as the device
+ * records more audio data, (push method), or you can supply no callback, and
+ * then SDL will expect you to retrieve data at regular intervals (pull
+ * method) with this function.
  *
- *  There are no limits on the amount of data you can queue, short of
- *  exhaustion of address space. Data from the device will keep queuing as
- *  necessary without further intervention from you. This means you will
- *  eventually run out of memory if you aren't routinely dequeueing data.
+ * There are no limits on the amount of data you can queue, short of
+ * exhaustion of address space. Data from the device will keep queuing as
+ * necessary without further intervention from you. This means you will
+ * eventually run out of memory if you aren't routinely dequeueing data.
  *
- *  Capture devices will not queue data when paused; if you are expecting
- *  to not need captured audio for some length of time, use
- *  SDL_PauseAudioDevice() to stop the capture device from queueing more
- *  data. This can be useful during, say, level loading times. When
- *  unpaused, capture devices will start queueing data from that point,
- *  having flushed any capturable data available while paused.
+ * Capture devices will not queue data when paused; if you are expecting to
+ * not need captured audio for some length of time, use SDL_PauseAudioDevice()
+ * to stop the capture device from queueing more data. This can be useful
+ * during, say, level loading times. When unpaused, capture devices will start
+ * queueing data from that point, having flushed any capturable data available
+ * while paused.
  *
- *  This function is thread-safe, but dequeueing from the same device from
- *  two threads at once does not promise which thread will dequeued data
- *  first.
+ * This function is thread-safe, but dequeueing from the same device from two
+ * threads at once does not promise which thread will dequeue data first.
  *
- *  You may not dequeue audio from a device that is using an
- *  application-supplied callback; doing so returns an error. You have to use
- *  the audio callback, or dequeue audio with this function, but not both.
+ * You may not dequeue audio from a device that is using an
+ * application-supplied callback; doing so returns an error. You have to use
+ * the audio callback, or dequeue audio with this function, but not both.
  *
- *  You should not call SDL_LockAudio() on the device before queueing; SDL
- *  handles locking internally for this function.
+ * You should not call SDL_LockAudio() on the device before dequeueing; SDL
+ * handles locking internally for this function.
  *
- *  \param dev The device ID from which we will dequeue audio.
- *  \param data A pointer into where audio data should be copied.
- *  \param len The number of bytes (not samples!) to which (data) points.
- *  \return number of bytes dequeued, which could be less than requested.
+ * \param dev the device ID from which we will dequeue audio
+ * \param data a pointer into where audio data should be copied
+ * \param len the number of bytes (not samples!) to which (data) points
+ * \returns the number of bytes dequeued, which could be less than requested;
+ *          call SDL_GetError() for more information.
  *
- *  \sa SDL_GetQueuedAudioSize
- *  \sa SDL_ClearQueuedAudio
+ * \since This function is available since SDL 2.0.5.
+ *
+ * \sa SDL_ClearQueuedAudio
+ * \sa SDL_GetQueuedAudioSize
  */
 extern DECLSPEC Uint32 SDLCALL SDL_DequeueAudio(SDL_AudioDeviceID dev, void *data, Uint32 len);
 
 /**
- *  Get the number of bytes of still-queued audio.
+ * Get the number of bytes of still-queued audio.
  *
- *  For playback device:
+ * For playback devices: this is the number of bytes that have been queued for
+ * playback with SDL_QueueAudio(), but have not yet been sent to the hardware.
  *
- *    This is the number of bytes that have been queued for playback with
- *    SDL_QueueAudio(), but have not yet been sent to the hardware. This
- *    number may shrink at any time, so this only informs of pending data.
+ * Once we've sent it to the hardware, this function can not decide the exact
+ * byte boundary of what has been played. It's possible that we just gave the
+ * hardware several kilobytes right before you called this function, but it
+ * hasn't played any of it yet, or maybe half of it, etc.
  *
- *    Once we've sent it to the hardware, this function can not decide the
- *    exact byte boundary of what has been played. It's possible that we just
- *    gave the hardware several kilobytes right before you called this
- *    function, but it hasn't played any of it yet, or maybe half of it, etc.
+ * For capture devices, this is the number of bytes that have been captured by
+ * the device and are waiting for you to dequeue. This number may grow at any
+ * time, so this only informs of the lower-bound of available data.
  *
- *  For capture devices:
+ * You may not queue or dequeue audio on a device that is using an
+ * application-supplied callback; calling this function on such a device
+ * always returns 0. You have to use the audio callback or queue audio, but
+ * not both.
  *
- *    This is the number of bytes that have been captured by the device and
- *    are waiting for you to dequeue. This number may grow at any time, so
- *    this only informs of the lower-bound of available data.
+ * You should not call SDL_LockAudio() on the device before querying; SDL
+ * handles locking internally for this function.
  *
- *  You may not queue audio on a device that is using an application-supplied
- *  callback; calling this function on such a device always returns 0.
- *  You have to queue audio with SDL_QueueAudio()/SDL_DequeueAudio(), or use
- *  the audio callback, but not both.
+ * \param dev the device ID of which we will query queued audio size
+ * \returns the number of bytes (not samples!) of queued audio.
  *
- *  You should not call SDL_LockAudio() on the device before querying; SDL
- *  handles locking internally for this function.
+ * \since This function is available since SDL 2.0.4.
  *
- *  \param dev The device ID of which we will query queued audio size.
- *  \return Number of bytes (not samples!) of queued audio.
- *
- *  \sa SDL_QueueAudio
- *  \sa SDL_ClearQueuedAudio
+ * \sa SDL_ClearQueuedAudio
+ * \sa SDL_QueueAudio
+ * \sa SDL_DequeueAudio
  */
 extern DECLSPEC Uint32 SDLCALL SDL_GetQueuedAudioSize(SDL_AudioDeviceID dev);
 
 /**
- *  Drop any queued audio data. For playback devices, this is any queued data
- *  still waiting to be submitted to the hardware. For capture devices, this
- *  is any data that was queued by the device that hasn't yet been dequeued by
- *  the application.
+ * Drop any queued audio data waiting to be sent to the hardware.
  *
- *  Immediately after this call, SDL_GetQueuedAudioSize() will return 0. For
- *  playback devices, the hardware will start playing silence if more audio
- *  isn't queued. Unpaused capture devices will start filling the queue again
- *  as soon as they have more data available (which, depending on the state
- *  of the hardware and the thread, could be before this function call
- *  returns!).
+ * Immediately after this call, SDL_GetQueuedAudioSize() will return 0. For
+ * output devices, the hardware will start playing silence if more audio isn't
+ * queued. For capture devices, the hardware will start filling the empty
+ * queue with new data if the capture device isn't paused.
  *
- *  This will not prevent playback of queued audio that's already been sent
- *  to the hardware, as we can not undo that, so expect there to be some
- *  fraction of a second of audio that might still be heard. This can be
- *  useful if you want to, say, drop any pending music during a level change
- *  in your game.
+ * This will not prevent playback of queued audio that's already been sent to
+ * the hardware, as we can not undo that, so expect there to be some fraction
+ * of a second of audio that might still be heard. This can be useful if you
+ * want to, say, drop any pending music or any unprocessed microphone input
+ * during a level change in your game.
  *
- *  You may not queue audio on a device that is using an application-supplied
- *  callback; calling this function on such a device is always a no-op.
- *  You have to queue audio with SDL_QueueAudio()/SDL_DequeueAudio(), or use
- *  the audio callback, but not both.
+ * You may not queue or dequeue audio on a device that is using an
+ * application-supplied callback; calling this function on such a device
+ * always returns 0. You have to use the audio callback or queue audio, but
+ * not both.
  *
- *  You should not call SDL_LockAudio() on the device before clearing the
- *  queue; SDL handles locking internally for this function.
+ * You should not call SDL_LockAudio() on the device before clearing the
+ * queue; SDL handles locking internally for this function.
  *
- *  This function always succeeds and thus returns void.
+ * This function always succeeds and thus returns void.
  *
- *  \param dev The device ID of which to clear the audio queue.
+ * \param dev the device ID of which to clear the audio queue
  *
- *  \sa SDL_QueueAudio
- *  \sa SDL_GetQueuedAudioSize
+ * \since This function is available since SDL 2.0.4.
+ *
+ * \sa SDL_GetQueuedAudioSize
+ * \sa SDL_QueueAudio
+ * \sa SDL_DequeueAudio
  */
 extern DECLSPEC void SDLCALL SDL_ClearQueuedAudio(SDL_AudioDeviceID dev);
 
@@ -836,16 +1316,139 @@ extern DECLSPEC void SDLCALL SDL_ClearQueuedAudio(SDL_AudioDeviceID dev);
  *  function or you will cause deadlock.
  */
 /* @{ */
+
+/**
+ * This function is a legacy means of locking the audio device.
+ *
+ * New programs might want to use SDL_LockAudioDevice() instead. This function
+ * is equivalent to calling...
+ *
+ * ```c
+ * SDL_LockAudioDevice(1);
+ * ```
+ *
+ * ...and is only useful if you used the legacy SDL_OpenAudio() function.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_LockAudioDevice
+ * \sa SDL_UnlockAudio
+ * \sa SDL_UnlockAudioDevice
+ */
 extern DECLSPEC void SDLCALL SDL_LockAudio(void);
+
+/**
+ * Use this function to lock out the audio callback function for a specified
+ * device.
+ *
+ * The lock manipulated by these functions protects the audio callback
+ * function specified in SDL_OpenAudioDevice(). During a
+ * SDL_LockAudioDevice()/SDL_UnlockAudioDevice() pair, you can be guaranteed
+ * that the callback function for that device is not running, even if the
+ * device is not paused. While a device is locked, any other unpaused,
+ * unlocked devices may still run their callbacks.
+ *
+ * Calling this function from inside your audio callback is unnecessary. SDL
+ * obtains this lock before calling your function, and releases it when the
+ * function returns.
+ *
+ * You should not hold the lock longer than absolutely necessary. If you hold
+ * it too long, you'll experience dropouts in your audio playback. Ideally,
+ * your application locks the device, sets a few variables and unlocks again.
+ * Do not do heavy work while holding the lock for a device.
+ *
+ * It is safe to lock the audio device multiple times, as long as you unlock
+ * it an equivalent number of times. The callback will not run until the
+ * device has been unlocked completely in this way. If your application fails
+ * to unlock the device appropriately, your callback will never run, you might
+ * hear repeating bursts of audio, and SDL_CloseAudioDevice() will probably
+ * deadlock.
+ *
+ * Internally, the audio device lock is a mutex; if you lock from two threads
+ * at once, not only will you block the audio callback, you'll block the other
+ * thread.
+ *
+ * \param dev the ID of the device to be locked
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_UnlockAudioDevice
+ */
 extern DECLSPEC void SDLCALL SDL_LockAudioDevice(SDL_AudioDeviceID dev);
+
+/**
+ * This function is a legacy means of unlocking the audio device.
+ *
+ * New programs might want to use SDL_UnlockAudioDevice() instead. This
+ * function is equivalent to calling...
+ *
+ * ```c
+ * SDL_UnlockAudioDevice(1);
+ * ```
+ *
+ * ...and is only useful if you used the legacy SDL_OpenAudio() function.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_LockAudio
+ * \sa SDL_UnlockAudioDevice
+ */
 extern DECLSPEC void SDLCALL SDL_UnlockAudio(void);
+
+/**
+ * Use this function to unlock the audio callback function for a specified
+ * device.
+ *
+ * This function should be paired with a previous SDL_LockAudioDevice() call.
+ *
+ * \param dev the ID of the device to be unlocked
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_LockAudioDevice
+ */
 extern DECLSPEC void SDLCALL SDL_UnlockAudioDevice(SDL_AudioDeviceID dev);
 /* @} *//* Audio lock functions */
 
 /**
- *  This function shuts down audio processing and closes the audio device.
+ * This function is a legacy means of closing the audio device.
+ *
+ * This function is equivalent to calling...
+ *
+ * ```c
+ * SDL_CloseAudioDevice(1);
+ * ```
+ *
+ * ...and is only useful if you used the legacy SDL_OpenAudio() function.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_OpenAudio
  */
 extern DECLSPEC void SDLCALL SDL_CloseAudio(void);
+
+/**
+ * Use this function to shut down audio processing and close the audio device.
+ *
+ * The application should close open audio devices once they are no longer
+ * needed. Calling this function will wait until the device's audio callback
+ * is not running, release the audio hardware and then clean up internal
+ * state. No further audio will play from this device once this function
+ * returns.
+ *
+ * This function may block briefly while pending audio data is played by the
+ * hardware, so that applications don't drop the last buffer of data they
+ * supplied.
+ *
+ * The device ID is invalid as soon as the device is closed, and is eligible
+ * for reuse in a new SDL_OpenAudioDevice() call immediately.
+ *
+ * \param dev an audio device previously opened with SDL_OpenAudioDevice()
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_OpenAudioDevice
+ */
 extern DECLSPEC void SDLCALL SDL_CloseAudioDevice(SDL_AudioDeviceID dev);
 
 /* Ends C function definitions when using C++ */
diff --git a/Engine/lib/sdl/include/SDL_bits.h b/Engine/lib/sdl/include/SDL_bits.h
index db150ed08..22cb85314 100644
--- a/Engine/lib/sdl/include/SDL_bits.h
+++ b/Engine/lib/sdl/include/SDL_bits.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -45,13 +45,12 @@ extern "C" {
  *  with 0. This operation can also be stated as "count leading zeroes" and
  *  "log base 2".
  *
- *  \return Index of the most significant bit, or -1 if the value is 0.
+ *  \return the index of the most significant bit, or -1 if the value is 0.
  */
 #if defined(__WATCOMC__) && defined(__386__)
-extern _inline int _SDL_clz_watcom (Uint32);
-#pragma aux _SDL_clz_watcom = \
+extern __inline int _SDL_bsr_watcom(Uint32);
+#pragma aux _SDL_bsr_watcom = \
     "bsr eax, eax" \
-    "xor eax, 31" \
     parm [eax] nomemory \
     value [eax] \
     modify exact [eax] nomemory;
@@ -72,7 +71,13 @@ SDL_MostSignificantBitIndex32(Uint32 x)
     if (x == 0) {
         return -1;
     }
-    return 31 - _SDL_clz_watcom(x);
+    return _SDL_bsr_watcom(x);
+#elif defined(_MSC_VER)
+    unsigned long index;
+    if (_BitScanReverse(&index, x)) {
+        return index;
+    }
+    return -1;
 #else
     /* Based off of Bit Twiddling Hacks by Sean Eron Anderson
      * <seander@cs.stanford.edu>, released in the public domain.
diff --git a/Engine/lib/sdl/include/SDL_blendmode.h b/Engine/lib/sdl/include/SDL_blendmode.h
index 5e21a79e6..b6d140dbb 100644
--- a/Engine/lib/sdl/include/SDL_blendmode.h
+++ b/Engine/lib/sdl/include/SDL_blendmode.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -91,19 +91,96 @@ typedef enum
 } SDL_BlendFactor;
 
 /**
- *  \brief Create a custom blend mode, which may or may not be supported by a given renderer
+ * Compose a custom blend mode for renderers.
  *
- *  \param srcColorFactor source color factor
- *  \param dstColorFactor destination color factor
- *  \param colorOperation color operation
- *  \param srcAlphaFactor source alpha factor
- *  \param dstAlphaFactor destination alpha factor
- *  \param alphaOperation alpha operation
+ * The functions SDL_SetRenderDrawBlendMode and SDL_SetTextureBlendMode accept
+ * the SDL_BlendMode returned by this function if the renderer supports it.
  *
- *  The result of the blend mode operation will be:
- *      dstRGB = dstRGB * dstColorFactor colorOperation srcRGB * srcColorFactor
- *  and
- *      dstA = dstA * dstAlphaFactor alphaOperation srcA * srcAlphaFactor
+ * A blend mode controls how the pixels from a drawing operation (source) get
+ * combined with the pixels from the render target (destination). First, the
+ * components of the source and destination pixels get multiplied with their
+ * blend factors. Then, the blend operation takes the two products and
+ * calculates the result that will get stored in the render target.
+ *
+ * Expressed in pseudocode, it would look like this:
+ *
+ * ```c
+ * dstRGB = colorOperation(srcRGB * srcColorFactor, dstRGB * dstColorFactor);
+ * dstA = alphaOperation(srcA * srcAlphaFactor, dstA * dstAlphaFactor);
+ * ```
+ *
+ * Where the functions `colorOperation(src, dst)` and `alphaOperation(src,
+ * dst)` can return one of the following:
+ *
+ * - `src + dst`
+ * - `src - dst`
+ * - `dst - src`
+ * - `min(src, dst)`
+ * - `max(src, dst)`
+ *
+ * The red, green, and blue components are always multiplied with the first,
+ * second, and third components of the SDL_BlendFactor, respectively. The
+ * fourth component is not used.
+ *
+ * The alpha component is always multiplied with the fourth component of the
+ * SDL_BlendFactor. The other components are not used in the alpha
+ * calculation.
+ *
+ * Support for these blend modes varies for each renderer. To check if a
+ * specific SDL_BlendMode is supported, create a renderer and pass it to
+ * either SDL_SetRenderDrawBlendMode or SDL_SetTextureBlendMode. They will
+ * return with an error if the blend mode is not supported.
+ *
+ * This list describes the support of custom blend modes for each renderer in
+ * SDL 2.0.6. All renderers support the four blend modes listed in the
+ * SDL_BlendMode enumeration.
+ *
+ * - **direct3d**: Supports `SDL_BLENDOPERATION_ADD` with all factors.
+ * - **direct3d11**: Supports all operations with all factors. However, some
+ *   factors produce unexpected results with `SDL_BLENDOPERATION_MINIMUM` and
+ *   `SDL_BLENDOPERATION_MAXIMUM`.
+ * - **opengl**: Supports the `SDL_BLENDOPERATION_ADD` operation with all
+ *   factors. OpenGL versions 1.1, 1.2, and 1.3 do not work correctly with SDL
+ *   2.0.6.
+ * - **opengles**: Supports the `SDL_BLENDOPERATION_ADD` operation with all
+ *   factors. Color and alpha factors need to be the same. OpenGL ES 1
+ *   implementation specific: May also support `SDL_BLENDOPERATION_SUBTRACT`
+ *   and `SDL_BLENDOPERATION_REV_SUBTRACT`. May support color and alpha
+ *   operations being different from each other. May support color and alpha
+ *   factors being different from each other.
+ * - **opengles2**: Supports the `SDL_BLENDOPERATION_ADD`,
+ *   `SDL_BLENDOPERATION_SUBTRACT`, `SDL_BLENDOPERATION_REV_SUBTRACT`
+ *   operations with all factors.
+ * - **psp**: No custom blend mode support.
+ * - **software**: No custom blend mode support.
+ *
+ * Some renderers do not provide an alpha component for the default render
+ * target. The `SDL_BLENDFACTOR_DST_ALPHA` and
+ * `SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA` factors do not have an effect in this
+ * case.
+ *
+ * \param srcColorFactor the SDL_BlendFactor applied to the red, green, and
+ *                       blue components of the source pixels
+ * \param dstColorFactor the SDL_BlendFactor applied to the red, green, and
+ *                       blue components of the destination pixels
+ * \param colorOperation the SDL_BlendOperation used to combine the red,
+ *                       green, and blue components of the source and
+ *                       destination pixels
+ * \param srcAlphaFactor the SDL_BlendFactor applied to the alpha component of
+ *                       the source pixels
+ * \param dstAlphaFactor the SDL_BlendFactor applied to the alpha component of
+ *                       the destination pixels
+ * \param alphaOperation the SDL_BlendOperation used to combine the alpha
+ *                       component of the source and destination pixels
+ * \returns an SDL_BlendMode that represents the chosen factors and
+ *          operations.
+ *
+ * \since This function is available since SDL 2.0.6.
+ *
+ * \sa SDL_SetRenderDrawBlendMode
+ * \sa SDL_GetRenderDrawBlendMode
+ * \sa SDL_SetTextureBlendMode
+ * \sa SDL_GetTextureBlendMode
  */
 extern DECLSPEC SDL_BlendMode SDLCALL SDL_ComposeCustomBlendMode(SDL_BlendFactor srcColorFactor,
                                                                  SDL_BlendFactor dstColorFactor,
diff --git a/Engine/lib/sdl/include/SDL_clipboard.h b/Engine/lib/sdl/include/SDL_clipboard.h
index dbf69fcea..935136305 100644
--- a/Engine/lib/sdl/include/SDL_clipboard.h
+++ b/Engine/lib/sdl/include/SDL_clipboard.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -39,23 +39,46 @@ extern "C" {
 /* Function prototypes */
 
 /**
- * \brief Put UTF-8 text into the clipboard
+ * Put UTF-8 text into the clipboard.
  *
- * \sa SDL_GetClipboardText()
+ * \param text the text to store in the clipboard
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetClipboardText
+ * \sa SDL_HasClipboardText
  */
 extern DECLSPEC int SDLCALL SDL_SetClipboardText(const char *text);
 
 /**
- * \brief Get UTF-8 text from the clipboard, which must be freed with SDL_free()
+ * Get UTF-8 text from the clipboard, which must be freed with SDL_free().
  *
- * \sa SDL_SetClipboardText()
+ * This functions returns empty string if there was not enough memory left for
+ * a copy of the clipboard's content.
+ *
+ * \returns the clipboard text on success or an empty string on failure; call
+ *          SDL_GetError() for more information. Caller must call SDL_free()
+ *          on the returned pointer when done with it (even if there was an
+ *          error).
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HasClipboardText
+ * \sa SDL_SetClipboardText
  */
 extern DECLSPEC char * SDLCALL SDL_GetClipboardText(void);
 
 /**
- * \brief Returns a flag indicating whether the clipboard exists and contains a text string that is non-empty
+ * Query whether the clipboard exists and contains a non-empty text string.
  *
- * \sa SDL_GetClipboardText()
+ * \returns SDL_TRUE if the clipboard has text, or SDL_FALSE if it does not.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetClipboardText
+ * \sa SDL_SetClipboardText
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_HasClipboardText(void);
 
diff --git a/Engine/lib/sdl/include/SDL_config.h b/Engine/lib/sdl/include/SDL_config.h
index 3937dbc38..7afefabe2 100644
--- a/Engine/lib/sdl/include/SDL_config.h
+++ b/Engine/lib/sdl/include/SDL_config.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -39,10 +39,10 @@
 #include "SDL_config_iphoneos.h"
 #elif defined(__ANDROID__)
 #include "SDL_config_android.h"
-#elif defined(__PSP__)
-#include "SDL_config_psp.h"
 #elif defined(__OS2__)
 #include "SDL_config_os2.h"
+#elif defined(__EMSCRIPTEN__)
+#include "SDL_config_emscripten.h"
 #else
 /* This is a minimal configuration just to get SDL running on new platforms. */
 #include "SDL_config_minimal.h"
diff --git a/Engine/lib/sdl/include/SDL_config.h.cmake b/Engine/lib/sdl/include/SDL_config.h.cmake
index 754b57013..9a1bf6758 100644
--- a/Engine/lib/sdl/include/SDL_config.h.cmake
+++ b/Engine/lib/sdl/include/SDL_config.h.cmake
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -38,7 +38,7 @@
 
 /* C datatypes */
 /* Define SIZEOF_VOIDP for 64/32 architectures */
-#ifdef __LP64__
+#if defined(__LP64__) || defined(_LP64) || defined(_WIN64)
 #define SIZEOF_VOIDP 8
 #else
 #define SIZEOF_VOIDP 4
@@ -75,6 +75,7 @@
 #cmakedefine HAVE_LIBUNWIND_H 1
 
 /* C library functions */
+#cmakedefine HAVE_DLOPEN 1
 #cmakedefine HAVE_MALLOC 1
 #cmakedefine HAVE_CALLOC 1
 #cmakedefine HAVE_REALLOC 1
@@ -96,6 +97,7 @@
 #cmakedefine HAVE_WCSLEN 1
 #cmakedefine HAVE_WCSLCPY 1
 #cmakedefine HAVE_WCSLCAT 1
+#cmakedefine HAVE__WCSDUP 1
 #cmakedefine HAVE_WCSDUP 1
 #cmakedefine HAVE_WCSSTR 1
 #cmakedefine HAVE_WCSCMP 1
@@ -116,7 +118,6 @@
 #cmakedefine HAVE_STRRCHR 1
 #cmakedefine HAVE_STRSTR 1
 #cmakedefine HAVE_STRTOK_R 1
-#cmakedefine HAVE_STRTOK_S 1
 #cmakedefine HAVE_ITOA 1
 #cmakedefine HAVE__LTOA 1
 #cmakedefine HAVE__UITOA 1
@@ -166,8 +167,12 @@
 #cmakedefine HAVE_LOGF 1
 #cmakedefine HAVE_LOG10 1
 #cmakedefine HAVE_LOG10F 1
+#cmakedefine HAVE_LROUND 1
+#cmakedefine HAVE_LROUNDF 1
 #cmakedefine HAVE_POW 1
 #cmakedefine HAVE_POWF 1
+#cmakedefine HAVE_ROUND 1
+#cmakedefine HAVE_ROUNDF 1
 #cmakedefine HAVE_SCALBN 1
 #cmakedefine HAVE_SCALBNF 1
 #cmakedefine HAVE_SIN 1
@@ -199,10 +204,11 @@
 #cmakedefine HAVE_POLL 1
 #cmakedefine HAVE__EXIT 1
 
-#elif __WIN32__
+#elif defined(__WIN32__)
 #cmakedefine HAVE_STDARG_H 1
 #cmakedefine HAVE_STDDEF_H 1
 #cmakedefine HAVE_FLOAT_H 1
+
 #else
 /* We may need some replacement for stdarg.h here */
 #include <stdarg.h>
@@ -216,9 +222,23 @@
 #cmakedefine HAVE_INOTIFY_INIT 1
 #cmakedefine HAVE_INOTIFY_INIT1 1
 #cmakedefine HAVE_INOTIFY 1
+#cmakedefine HAVE_O_CLOEXEC 1
+
+/* Apple platforms might be building universal binaries, where Intel builds
+   can use immintrin.h but other architectures can't. */
+#ifdef __APPLE__
+#  if defined(__has_include) && (defined(__i386__) || defined(__x86_64))
+#    if __has_include(<immintrin.h>)
+#       define HAVE_IMMINTRIN_H 1
+#    endif
+#  endif
+#else  /* non-Apple platforms can use the normal CMake check for this. */
 #cmakedefine HAVE_IMMINTRIN_H 1
+#endif
+
 #cmakedefine HAVE_LIBUDEV_H 1
 #cmakedefine HAVE_LIBSAMPLERATE_H 1
+#cmakedefine HAVE_LIBDECOR_H  1
 
 #cmakedefine HAVE_D3D_H @HAVE_D3D_H@
 #cmakedefine HAVE_D3D11_H @HAVE_D3D11_H@
@@ -226,10 +246,12 @@
 #cmakedefine HAVE_DSOUND_H @HAVE_DSOUND_H@
 #cmakedefine HAVE_DINPUT_H @HAVE_DINPUT_H@
 #cmakedefine HAVE_XINPUT_H @HAVE_XINPUT_H@
+#cmakedefine HAVE_WINDOWS_GAMING_INPUT_H @HAVE_WINDOWS_GAMING_INPUT_H@
 #cmakedefine HAVE_DXGI_H @HAVE_DXGI_H@
 
 #cmakedefine HAVE_MMDEVICEAPI_H @HAVE_MMDEVICEAPI_H@
 #cmakedefine HAVE_AUDIOCLIENT_H @HAVE_AUDIOCLIENT_H@
+#cmakedefine HAVE_TPCSHRD_H @HAVE_TPCSHRD_H@
 #cmakedefine HAVE_SENSORSAPI_H @HAVE_SENSORSAPI_H@
 
 #cmakedefine HAVE_XINPUT_GAMEPAD_EX @HAVE_XINPUT_GAMEPAD_EX@
@@ -246,6 +268,7 @@
 #cmakedefine SDL_FILE_DISABLED @SDL_FILE_DISABLED@
 #cmakedefine SDL_JOYSTICK_DISABLED @SDL_JOYSTICK_DISABLED@
 #cmakedefine SDL_HAPTIC_DISABLED @SDL_HAPTIC_DISABLED@
+#cmakedefine SDL_HIDAPI_DISABLED @SDL_HIDAPI_DISABLED@
 #cmakedefine SDL_SENSOR_DISABLED @SDL_SENSOR_DISABLED@
 #cmakedefine SDL_LOADSO_DISABLED @SDL_LOADSO_DISABLED@
 #cmakedefine SDL_RENDER_DISABLED @SDL_RENDER_DISABLED@
@@ -254,11 +277,15 @@
 #cmakedefine SDL_VIDEO_DISABLED @SDL_VIDEO_DISABLED@
 #cmakedefine SDL_POWER_DISABLED @SDL_POWER_DISABLED@
 #cmakedefine SDL_FILESYSTEM_DISABLED @SDL_FILESYSTEM_DISABLED@
+#cmakedefine SDL_LOCALE_DISABLED @SDL_LOCALE_DISABLED@
+#cmakedefine SDL_MISC_DISABLED @SDL_MISC_DISABLED@
 
 /* Enable various audio drivers */
 #cmakedefine SDL_AUDIO_DRIVER_ALSA @SDL_AUDIO_DRIVER_ALSA@
 #cmakedefine SDL_AUDIO_DRIVER_ALSA_DYNAMIC @SDL_AUDIO_DRIVER_ALSA_DYNAMIC@
 #cmakedefine SDL_AUDIO_DRIVER_ANDROID @SDL_AUDIO_DRIVER_ANDROID@
+#cmakedefine SDL_AUDIO_DRIVER_OPENSLES @SDL_AUDIO_DRIVER_OPENSLES@
+#cmakedefine SDL_AUDIO_DRIVER_AAUDIO @SDL_AUDIO_DRIVER_AAUDIO@
 #cmakedefine SDL_AUDIO_DRIVER_ARTS @SDL_AUDIO_DRIVER_ARTS@
 #cmakedefine SDL_AUDIO_DRIVER_ARTS_DYNAMIC @SDL_AUDIO_DRIVER_ARTS_DYNAMIC@
 #cmakedefine SDL_AUDIO_DRIVER_COREAUDIO @SDL_AUDIO_DRIVER_COREAUDIO@
@@ -279,6 +306,8 @@
 #cmakedefine SDL_AUDIO_DRIVER_OSS @SDL_AUDIO_DRIVER_OSS@
 #cmakedefine SDL_AUDIO_DRIVER_OSS_SOUNDCARD_H @SDL_AUDIO_DRIVER_OSS_SOUNDCARD_H@
 #cmakedefine SDL_AUDIO_DRIVER_PAUDIO @SDL_AUDIO_DRIVER_PAUDIO@
+#cmakedefine SDL_AUDIO_DRIVER_PIPEWIRE @SDL_AUDIO_DRIVER_PIPEWIRE@
+#cmakedefine SDL_AUDIO_DRIVER_PIPEWIRE_DYNAMIC @SDL_AUDIO_DRIVER_PIPEWIRE_DYNAMIC@
 #cmakedefine SDL_AUDIO_DRIVER_PULSEAUDIO @SDL_AUDIO_DRIVER_PULSEAUDIO@
 #cmakedefine SDL_AUDIO_DRIVER_PULSEAUDIO_DYNAMIC @SDL_AUDIO_DRIVER_PULSEAUDIO_DYNAMIC@
 #cmakedefine SDL_AUDIO_DRIVER_QSA @SDL_AUDIO_DRIVER_QSA@
@@ -287,24 +316,32 @@
 #cmakedefine SDL_AUDIO_DRIVER_SUNAUDIO @SDL_AUDIO_DRIVER_SUNAUDIO@
 #cmakedefine SDL_AUDIO_DRIVER_WASAPI @SDL_AUDIO_DRIVER_WASAPI@
 #cmakedefine SDL_AUDIO_DRIVER_WINMM @SDL_AUDIO_DRIVER_WINMM@
+#cmakedefine SDL_AUDIO_DRIVER_OS2 @SDL_AUDIO_DRIVER_OS2@
+#cmakedefine SDL_AUDIO_DRIVER_VITA @SDL_AUDIO_DRIVER_VITA@
+#cmakedefine SDL_AUDIO_DRIVER_PSP @SDL_AUDIO_DRIVER_PSP@
 
 /* Enable various input drivers */
 #cmakedefine SDL_INPUT_LINUXEV @SDL_INPUT_LINUXEV@
 #cmakedefine SDL_INPUT_LINUXKD @SDL_INPUT_LINUXKD@
+#cmakedefine SDL_INPUT_FBSDKBIO @SDL_INPUT_FBSDKBIO@
 #cmakedefine SDL_JOYSTICK_ANDROID @SDL_JOYSTICK_ANDROID@
 #cmakedefine SDL_JOYSTICK_HAIKU @SDL_JOYSTICK_HAIKU@
+#cmakedefine SDL_JOYSTICK_WGI @SDL_JOYSTICK_WGI@
 #cmakedefine SDL_JOYSTICK_DINPUT @SDL_JOYSTICK_DINPUT@
 #cmakedefine SDL_JOYSTICK_XINPUT @SDL_JOYSTICK_XINPUT@
 #cmakedefine SDL_JOYSTICK_DUMMY @SDL_JOYSTICK_DUMMY@
 #cmakedefine SDL_JOYSTICK_IOKIT @SDL_JOYSTICK_IOKIT@
 #cmakedefine SDL_JOYSTICK_MFI @SDL_JOYSTICK_MFI@
 #cmakedefine SDL_JOYSTICK_LINUX @SDL_JOYSTICK_LINUX@
-#cmakedefine SDL_JOYSTICK_WINMM @SDL_JOYSTICK_WINMM@
+#cmakedefine SDL_JOYSTICK_OS2 @SDL_JOYSTICK_OS2@
 #cmakedefine SDL_JOYSTICK_USBHID @SDL_JOYSTICK_USBHID@
-#cmakedefine SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H @SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H@
+#cmakedefine SDL_HAVE_MACHINE_JOYSTICK_H @SDL_HAVE_MACHINE_JOYSTICK_H@
 #cmakedefine SDL_JOYSTICK_HIDAPI @SDL_JOYSTICK_HIDAPI@
+#cmakedefine SDL_JOYSTICK_RAWINPUT @SDL_JOYSTICK_RAWINPUT@
 #cmakedefine SDL_JOYSTICK_EMSCRIPTEN @SDL_JOYSTICK_EMSCRIPTEN@
 #cmakedefine SDL_JOYSTICK_VIRTUAL @SDL_JOYSTICK_VIRTUAL@
+#cmakedefine SDL_JOYSTICK_VITA @SDL_JOYSTICK_VITA@
+#cmakedefine SDL_JOYSTICK_PSP @SDL_JOYSTICK_PSP@
 #cmakedefine SDL_HAPTIC_DUMMY @SDL_HAPTIC_DUMMY@
 #cmakedefine SDL_HAPTIC_LINUX @SDL_HAPTIC_LINUX@
 #cmakedefine SDL_HAPTIC_IOKIT @SDL_HAPTIC_IOKIT@
@@ -318,28 +355,37 @@
 #cmakedefine SDL_SENSOR_COREMOTION @SDL_SENSOR_COREMOTION@
 #cmakedefine SDL_SENSOR_WINDOWS @SDL_SENSOR_WINDOWS@
 #cmakedefine SDL_SENSOR_DUMMY @SDL_SENSOR_DUMMY@
+#cmakedefine SDL_SENSOR_VITA @SDL_SENSOR_VITA@
 
 /* Enable various shared object loading systems */
 #cmakedefine SDL_LOADSO_DLOPEN @SDL_LOADSO_DLOPEN@
 #cmakedefine SDL_LOADSO_DUMMY @SDL_LOADSO_DUMMY@
 #cmakedefine SDL_LOADSO_LDG @SDL_LOADSO_LDG@
 #cmakedefine SDL_LOADSO_WINDOWS @SDL_LOADSO_WINDOWS@
+#cmakedefine SDL_LOADSO_OS2 @SDL_LOADSO_OS2@
 
 /* Enable various threading systems */
+#cmakedefine SDL_THREAD_GENERIC_COND_SUFFIX @SDL_THREAD_GENERIC_COND_SUFFIX@
 #cmakedefine SDL_THREAD_PTHREAD @SDL_THREAD_PTHREAD@
 #cmakedefine SDL_THREAD_PTHREAD_RECURSIVE_MUTEX @SDL_THREAD_PTHREAD_RECURSIVE_MUTEX@
 #cmakedefine SDL_THREAD_PTHREAD_RECURSIVE_MUTEX_NP @SDL_THREAD_PTHREAD_RECURSIVE_MUTEX_NP@
 #cmakedefine SDL_THREAD_WINDOWS @SDL_THREAD_WINDOWS@
+#cmakedefine SDL_THREAD_OS2 @SDL_THREAD_OS2@
+#cmakedefine SDL_THREAD_VITA @SDL_THREAD_VITA@
+#cmakedefine SDL_THREAD_PSP @SDL_THREAD_PSP@
 
 /* Enable various timer systems */
 #cmakedefine SDL_TIMER_HAIKU @SDL_TIMER_HAIKU@
 #cmakedefine SDL_TIMER_DUMMY @SDL_TIMER_DUMMY@
 #cmakedefine SDL_TIMER_UNIX @SDL_TIMER_UNIX@
 #cmakedefine SDL_TIMER_WINDOWS @SDL_TIMER_WINDOWS@
-#cmakedefine SDL_TIMER_WINCE @SDL_TIMER_WINCE@
+#cmakedefine SDL_TIMER_OS2 @SDL_TIMER_OS2@
+#cmakedefine SDL_TIMER_VITA @SDL_TIMER_VITA@
+#cmakedefine SDL_TIMER_PSP @SDL_TIMER_PSP@
 
 /* Enable various video drivers */
 #cmakedefine SDL_VIDEO_DRIVER_ANDROID @SDL_VIDEO_DRIVER_ANDROID@
+#cmakedefine SDL_VIDEO_DRIVER_EMSCRIPTEN @SDL_VIDEO_DRIVER_EMSCRIPTEN@
 #cmakedefine SDL_VIDEO_DRIVER_HAIKU @SDL_VIDEO_DRIVER_HAIKU@
 #cmakedefine SDL_VIDEO_DRIVER_COCOA @SDL_VIDEO_DRIVER_COCOA@
 #cmakedefine SDL_VIDEO_DRIVER_UIKIT @SDL_VIDEO_DRIVER_UIKIT@
@@ -353,6 +399,10 @@
 #cmakedefine SDL_VIDEO_DRIVER_RPI @SDL_VIDEO_DRIVER_RPI@
 #cmakedefine SDL_VIDEO_DRIVER_VIVANTE @SDL_VIDEO_DRIVER_VIVANTE@
 #cmakedefine SDL_VIDEO_DRIVER_VIVANTE_VDK @SDL_VIDEO_DRIVER_VIVANTE_VDK@
+#cmakedefine SDL_VIDEO_DRIVER_OS2 @SDL_VIDEO_DRIVER_OS2@
+#cmakedefine SDL_VIDEO_DRIVER_QNX @SDL_VIDEO_DRIVER_QNX@
+#cmakedefine SDL_VIDEO_DRIVER_RISCOS @SDL_VIDEO_DRIVER_RISCOS@
+#cmakedefine SDL_VIDEO_DRIVER_PSP @SDL_VIDEO_DRIVER_PSP@
 
 #cmakedefine SDL_VIDEO_DRIVER_KMSDRM @SDL_VIDEO_DRIVER_KMSDRM@
 #cmakedefine SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC @SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC@
@@ -363,14 +413,15 @@
 #cmakedefine SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_EGL @SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_EGL@
 #cmakedefine SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_CURSOR @SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_CURSOR@
 #cmakedefine SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_XKBCOMMON @SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_XKBCOMMON@
+#cmakedefine SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_LIBDECOR @SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_LIBDECOR@
 
-#cmakedefine SDL_VIDEO_DRIVER_EMSCRIPTEN @SDL_VIDEO_DRIVER_EMSCRIPTEN@
 #cmakedefine SDL_VIDEO_DRIVER_X11 @SDL_VIDEO_DRIVER_X11@
 #cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC @SDL_VIDEO_DRIVER_X11_DYNAMIC@
 #cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT @SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT@
 #cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XCURSOR @SDL_VIDEO_DRIVER_X11_DYNAMIC_XCURSOR@
 #cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XINERAMA @SDL_VIDEO_DRIVER_X11_DYNAMIC_XINERAMA@
 #cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT2 @SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT2@
+#cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XFIXES @SDL_VIDEO_DRIVER_X11_DYNAMIC_XFIXES@
 #cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR @SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR@
 #cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XSS @SDL_VIDEO_DRIVER_X11_DYNAMIC_XSS@
 #cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XVIDMODE @SDL_VIDEO_DRIVER_X11_DYNAMIC_XVIDMODE@
@@ -379,13 +430,14 @@
 #cmakedefine SDL_VIDEO_DRIVER_X11_XINERAMA @SDL_VIDEO_DRIVER_X11_XINERAMA@
 #cmakedefine SDL_VIDEO_DRIVER_X11_XINPUT2 @SDL_VIDEO_DRIVER_X11_XINPUT2@
 #cmakedefine SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH @SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH@
+#cmakedefine SDL_VIDEO_DRIVER_X11_XFIXES @SDL_VIDEO_DRIVER_X11_XFIXES@
 #cmakedefine SDL_VIDEO_DRIVER_X11_XRANDR @SDL_VIDEO_DRIVER_X11_XRANDR@
 #cmakedefine SDL_VIDEO_DRIVER_X11_XSCRNSAVER @SDL_VIDEO_DRIVER_X11_XSCRNSAVER@
 #cmakedefine SDL_VIDEO_DRIVER_X11_XSHAPE @SDL_VIDEO_DRIVER_X11_XSHAPE@
 #cmakedefine SDL_VIDEO_DRIVER_X11_XVIDMODE @SDL_VIDEO_DRIVER_X11_XVIDMODE@
 #cmakedefine SDL_VIDEO_DRIVER_X11_SUPPORTS_GENERIC_EVENTS @SDL_VIDEO_DRIVER_X11_SUPPORTS_GENERIC_EVENTS@
-#cmakedefine SDL_VIDEO_DRIVER_X11_CONST_PARAM_XEXTADDDISPLAY @SDL_VIDEO_DRIVER_X11_CONST_PARAM_XEXTADDDISPLAY@
 #cmakedefine SDL_VIDEO_DRIVER_X11_HAS_XKBKEYCODETOKEYSYM @SDL_VIDEO_DRIVER_X11_HAS_XKBKEYCODETOKEYSYM@
+#cmakedefine SDL_VIDEO_DRIVER_VITA @SDL_VIDEO_DRIVER_VITA@
 
 #cmakedefine SDL_VIDEO_RENDER_D3D @SDL_VIDEO_RENDER_D3D@
 #cmakedefine SDL_VIDEO_RENDER_D3D11 @SDL_VIDEO_RENDER_D3D11@
@@ -394,6 +446,8 @@
 #cmakedefine SDL_VIDEO_RENDER_OGL_ES2 @SDL_VIDEO_RENDER_OGL_ES2@
 #cmakedefine SDL_VIDEO_RENDER_DIRECTFB @SDL_VIDEO_RENDER_DIRECTFB@
 #cmakedefine SDL_VIDEO_RENDER_METAL @SDL_VIDEO_RENDER_METAL@
+#cmakedefine SDL_VIDEO_RENDER_VITA_GXM @SDL_VIDEO_RENDER_VITA_GXM@
+#cmakedefine SDL_VIDEO_RENDER_PSP @SDL_VIDEO_RENDER_PSP@
 
 /* Enable OpenGL support */
 #cmakedefine SDL_VIDEO_OPENGL @SDL_VIDEO_OPENGL@
@@ -423,15 +477,27 @@
 #cmakedefine SDL_POWER_HAIKU @SDL_POWER_HAIKU@
 #cmakedefine SDL_POWER_EMSCRIPTEN @SDL_POWER_EMSCRIPTEN@
 #cmakedefine SDL_POWER_HARDWIRED @SDL_POWER_HARDWIRED@
+#cmakedefine SDL_POWER_VITA @SDL_POWER_VITA@
+#cmakedefine SDL_POWER_PSP @SDL_POWER_PSP@
 
 /* Enable system filesystem support */
 #cmakedefine SDL_FILESYSTEM_ANDROID @SDL_FILESYSTEM_ANDROID@
 #cmakedefine SDL_FILESYSTEM_HAIKU @SDL_FILESYSTEM_HAIKU@
 #cmakedefine SDL_FILESYSTEM_COCOA @SDL_FILESYSTEM_COCOA@
 #cmakedefine SDL_FILESYSTEM_DUMMY @SDL_FILESYSTEM_DUMMY@
+#cmakedefine SDL_FILESYSTEM_RISCOS @SDL_FILESYSTEM_RISCOS@
 #cmakedefine SDL_FILESYSTEM_UNIX @SDL_FILESYSTEM_UNIX@
 #cmakedefine SDL_FILESYSTEM_WINDOWS @SDL_FILESYSTEM_WINDOWS@
 #cmakedefine SDL_FILESYSTEM_EMSCRIPTEN @SDL_FILESYSTEM_EMSCRIPTEN@
+#cmakedefine SDL_FILESYSTEM_OS2 @SDL_FILESYSTEM_OS2@
+#cmakedefine SDL_FILESYSTEM_VITA @SDL_FILESYSTEM_VITA@
+#cmakedefine SDL_FILESYSTEM_PSP @SDL_FILESYSTEM_PSP@
+
+/* Enable misc subsystem */
+#cmakedefine SDL_MISC_DUMMY @SDL_MISC_DUMMY@
+
+/* Enable locale subsystem */
+#cmakedefine SDL_LOCALE_DUMMY @SDL_LOCALE_DUMMY@
 
 /* Enable assembly routines */
 #cmakedefine SDL_ASSEMBLY_ROUTINES @SDL_ASSEMBLY_ROUTINES@
@@ -439,13 +505,22 @@
 #cmakedefine SDL_ARM_SIMD_BLITTERS @SDL_ARM_SIMD_BLITTERS@
 #cmakedefine SDL_ARM_NEON_BLITTERS @SDL_ARM_NEON_BLITTERS@
 
+/* Whether SDL_DYNAMIC_API needs dlopen */
+#cmakedefine DYNAPI_NEEDS_DLOPEN  @DYNAPI_NEEDS_DLOPEN@
+
 /* Enable dynamic libsamplerate support */
 #cmakedefine SDL_LIBSAMPLERATE_DYNAMIC @SDL_LIBSAMPLERATE_DYNAMIC@
 
+/* Enable ime support */
+#cmakedefine SDL_USE_IME @SDL_USE_IME@
+
 /* Platform specific definitions */
 #cmakedefine SDL_IPHONE_KEYBOARD @SDL_IPHONE_KEYBOARD@
 #cmakedefine SDL_IPHONE_LAUNCHSCREEN @SDL_IPHONE_LAUNCHSCREEN@
 
+#cmakedefine SDL_VIDEO_VITA_PIB @SDL_VIDEO_VITA_PIB@
+#cmakedefine SDL_VIDEO_VITA_PVR @SDL_VIDEO_VITA_PVR@
+
 #if !defined(__WIN32__) && !defined(__WINRT__)
 #  if !defined(_STDINT_H_) && !defined(_STDINT_H) && !defined(HAVE_STDINT_H) && !defined(_HAVE_STDINT_H)
 typedef unsigned int size_t;
@@ -461,7 +536,7 @@ typedef unsigned long uintptr_t;
 #  endif /* if (stdint.h isn't available) */
 #else /* __WIN32__ */
 #  if !defined(_STDINT_H_) && !defined(HAVE_STDINT_H) && !defined(_HAVE_STDINT_H)
-#    if defined(__GNUC__) || defined(__DMC__) || defined(__WATCOMC__)
+#    if defined(__GNUC__) || defined(__DMC__) || defined(__WATCOMC__) || defined(__BORLANDC__) || defined(__CODEGEARC__)
 #define HAVE_STDINT_H	1
 #    elif defined(_MSC_VER)
 typedef signed __int8 int8_t;
diff --git a/Engine/lib/sdl/include/SDL_config.h.in b/Engine/lib/sdl/include/SDL_config.h.in
index 3a2a7149d..195b9887e 100644
--- a/Engine/lib/sdl/include/SDL_config.h.in
+++ b/Engine/lib/sdl/include/SDL_config.h.in
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -33,7 +33,7 @@
 
 /* Make sure that this isn't included by Visual C++ */
 #ifdef _MSC_VER
-#error You should run hg revert SDL_config.h
+#error You should run git checkout -f include/SDL_config.h
 #endif
 
 /* C language features */
@@ -42,11 +42,12 @@
 #undef volatile
 
 /* C datatypes */
-#ifdef __LP64__
+#if defined(__LP64__) || defined(_LP64) || defined(_WIN64)
 #define SIZEOF_VOIDP 8
 #else
 #define SIZEOF_VOIDP 4
 #endif
+
 #undef HAVE_GCC_ATOMICS
 #undef HAVE_GCC_SYNC_LOCK_TEST_AND_SET
 
@@ -78,6 +79,7 @@
 #undef HAVE_LIBUNWIND_H
 
 /* C library functions */
+#undef HAVE_DLOPEN
 #undef HAVE_MALLOC
 #undef HAVE_CALLOC
 #undef HAVE_REALLOC
@@ -99,6 +101,7 @@
 #undef HAVE_WCSLEN
 #undef HAVE_WCSLCPY
 #undef HAVE_WCSLCAT
+#undef HAVE__WCSDUP
 #undef HAVE_WCSDUP
 #undef HAVE_WCSSTR
 #undef HAVE_WCSCMP
@@ -119,7 +122,6 @@
 #undef HAVE_STRRCHR
 #undef HAVE_STRSTR
 #undef HAVE_STRTOK_R
-#undef HAVE_STRTOK_S
 #undef HAVE_ITOA
 #undef HAVE__LTOA
 #undef HAVE__UITOA
@@ -170,8 +172,12 @@
 #undef HAVE_LOGF
 #undef HAVE_LOG10
 #undef HAVE_LOG10F
+#undef HAVE_LROUND
+#undef HAVE_LROUNDF
 #undef HAVE_POW
 #undef HAVE_POWF
+#undef HAVE_ROUND
+#undef HAVE_ROUNDF
 #undef HAVE_SCALBN
 #undef HAVE_SCALBNF
 #undef HAVE_SIN
@@ -209,6 +215,7 @@
 #define HAVE_STDINT_H 1
 #endif /* HAVE_LIBC */
 
+#undef HAVE_O_CLOEXEC
 #undef HAVE_ALTIVEC_H
 #undef HAVE_DBUS_DBUS_H
 #undef HAVE_FCITX
@@ -220,20 +227,22 @@
 #undef HAVE_IMMINTRIN_H
 #undef HAVE_LIBUDEV_H
 #undef HAVE_LIBSAMPLERATE_H
+#undef HAVE_LIBDECOR_H
 
 #undef HAVE_DDRAW_H
 #undef HAVE_DINPUT_H
 #undef HAVE_DSOUND_H
 #undef HAVE_DXGI_H
+#undef HAVE_WINDOWS_GAMING_INPUT_H
 #undef HAVE_XINPUT_H
+#undef HAVE_XINPUT_GAMEPAD_EX
+#undef HAVE_XINPUT_STATE_EX
 
 #undef HAVE_MMDEVICEAPI_H
 #undef HAVE_AUDIOCLIENT_H
+#undef HAVE_TPCSHRD_H
 #undef HAVE_SENSORSAPI_H
 
-#undef HAVE_XINPUT_GAMEPAD_EX
-#undef HAVE_XINPUT_STATE_EX
-
 /* SDL internal assertion support */
 #undef SDL_DEFAULT_ASSERT_LEVEL
 
@@ -245,6 +254,7 @@
 #undef SDL_FILE_DISABLED
 #undef SDL_JOYSTICK_DISABLED
 #undef SDL_HAPTIC_DISABLED
+#undef SDL_HIDAPI_DISABLED
 #undef SDL_SENSOR_DISABLED
 #undef SDL_LOADSO_DISABLED
 #undef SDL_RENDER_DISABLED
@@ -253,8 +263,11 @@
 #undef SDL_VIDEO_DISABLED
 #undef SDL_POWER_DISABLED
 #undef SDL_FILESYSTEM_DISABLED
+#undef SDL_LOCALE_DISABLED
+#undef SDL_MISC_DISABLED
 
 /* Enable various audio drivers */
+#undef SDL_AUDIO_DRIVER_AAUDIO
 #undef SDL_AUDIO_DRIVER_ALSA
 #undef SDL_AUDIO_DRIVER_ALSA_DYNAMIC
 #undef SDL_AUDIO_DRIVER_ANDROID
@@ -276,9 +289,12 @@
 #undef SDL_AUDIO_DRIVER_NAS
 #undef SDL_AUDIO_DRIVER_NAS_DYNAMIC
 #undef SDL_AUDIO_DRIVER_NETBSD
+#undef SDL_AUDIO_DRIVER_OPENSLES
 #undef SDL_AUDIO_DRIVER_OSS
 #undef SDL_AUDIO_DRIVER_OSS_SOUNDCARD_H
 #undef SDL_AUDIO_DRIVER_PAUDIO
+#undef SDL_AUDIO_DRIVER_PIPEWIRE
+#undef SDL_AUDIO_DRIVER_PIPEWIRE_DYNAMIC
 #undef SDL_AUDIO_DRIVER_PULSEAUDIO
 #undef SDL_AUDIO_DRIVER_PULSEAUDIO_DYNAMIC
 #undef SDL_AUDIO_DRIVER_QSA
@@ -287,22 +303,25 @@
 #undef SDL_AUDIO_DRIVER_SUNAUDIO
 #undef SDL_AUDIO_DRIVER_WASAPI
 #undef SDL_AUDIO_DRIVER_WINMM
+#undef SDL_AUDIO_DRIVER_OS2
 
 /* Enable various input drivers */
 #undef SDL_INPUT_LINUXEV
 #undef SDL_INPUT_FBSDKBIO
 #undef SDL_INPUT_LINUXKD
+#undef SDL_INPUT_WSCONS
 #undef SDL_JOYSTICK_HAIKU
 #undef SDL_JOYSTICK_DINPUT
+#undef SDL_JOYSTICK_WGI
 #undef SDL_JOYSTICK_XINPUT
 #undef SDL_JOYSTICK_DUMMY
 #undef SDL_JOYSTICK_IOKIT
 #undef SDL_JOYSTICK_MFI
 #undef SDL_JOYSTICK_LINUX
 #undef SDL_JOYSTICK_ANDROID
-#undef SDL_JOYSTICK_WINMM
+#undef SDL_JOYSTICK_OS2
 #undef SDL_JOYSTICK_USBHID
-#undef SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H
+#undef SDL_HAVE_MACHINE_JOYSTICK_H
 #undef SDL_JOYSTICK_HIDAPI
 #undef SDL_JOYSTICK_RAWINPUT
 #undef SDL_JOYSTICK_EMSCRIPTEN
@@ -325,18 +344,22 @@
 #undef SDL_LOADSO_DUMMY
 #undef SDL_LOADSO_LDG
 #undef SDL_LOADSO_WINDOWS
+#undef SDL_LOADSO_OS2
 
 /* Enable various threading systems */
+#undef SDL_THREAD_GENERIC_COND_SUFFIX
 #undef SDL_THREAD_PTHREAD
 #undef SDL_THREAD_PTHREAD_RECURSIVE_MUTEX
 #undef SDL_THREAD_PTHREAD_RECURSIVE_MUTEX_NP
 #undef SDL_THREAD_WINDOWS
+#undef SDL_THREAD_OS2
 
 /* Enable various timer systems */
 #undef SDL_TIMER_HAIKU
 #undef SDL_TIMER_DUMMY
 #undef SDL_TIMER_UNIX
 #undef SDL_TIMER_WINDOWS
+#undef SDL_TIMER_OS2
 
 /* Enable various video drivers */
 #undef SDL_VIDEO_DRIVER_HAIKU
@@ -351,6 +374,7 @@
 #undef SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_EGL
 #undef SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_CURSOR
 #undef SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_XKBCOMMON
+#undef SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_LIBDECOR
 #undef SDL_VIDEO_DRIVER_X11
 #undef SDL_VIDEO_DRIVER_RPI
 #undef SDL_VIDEO_DRIVER_KMSDRM
@@ -358,11 +382,13 @@
 #undef SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC_GBM
 #undef SDL_VIDEO_DRIVER_ANDROID
 #undef SDL_VIDEO_DRIVER_EMSCRIPTEN
+#undef SDL_VIDEO_DRIVER_OFFSCREEN
 #undef SDL_VIDEO_DRIVER_X11_DYNAMIC
 #undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT
 #undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XCURSOR
 #undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XINERAMA
 #undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT2
+#undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XFIXES
 #undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR
 #undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XSS
 #undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XVIDMODE
@@ -371,17 +397,19 @@
 #undef SDL_VIDEO_DRIVER_X11_XINERAMA
 #undef SDL_VIDEO_DRIVER_X11_XINPUT2
 #undef SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH
+#undef SDL_VIDEO_DRIVER_X11_XFIXES
 #undef SDL_VIDEO_DRIVER_X11_XRANDR
 #undef SDL_VIDEO_DRIVER_X11_XSCRNSAVER
 #undef SDL_VIDEO_DRIVER_X11_XSHAPE
 #undef SDL_VIDEO_DRIVER_X11_XVIDMODE
 #undef SDL_VIDEO_DRIVER_X11_SUPPORTS_GENERIC_EVENTS
-#undef SDL_VIDEO_DRIVER_X11_CONST_PARAM_XEXTADDDISPLAY
 #undef SDL_VIDEO_DRIVER_X11_HAS_XKBKEYCODETOKEYSYM
 #undef SDL_VIDEO_DRIVER_NACL
 #undef SDL_VIDEO_DRIVER_VIVANTE
 #undef SDL_VIDEO_DRIVER_VIVANTE_VDK
+#undef SDL_VIDEO_DRIVER_OS2
 #undef SDL_VIDEO_DRIVER_QNX
+#undef SDL_VIDEO_DRIVER_RISCOS
 
 #undef SDL_VIDEO_RENDER_D3D
 #undef SDL_VIDEO_RENDER_D3D11
@@ -419,14 +447,24 @@
 #undef SDL_POWER_HARDWIRED
 
 /* Enable system filesystem support */
+#undef SDL_FILESYSTEM_ANDROID
 #undef SDL_FILESYSTEM_HAIKU
 #undef SDL_FILESYSTEM_COCOA
 #undef SDL_FILESYSTEM_DUMMY
+#undef SDL_FILESYSTEM_RISCOS
 #undef SDL_FILESYSTEM_UNIX
 #undef SDL_FILESYSTEM_WINDOWS
 #undef SDL_FILESYSTEM_NACL
-#undef SDL_FILESYSTEM_ANDROID
 #undef SDL_FILESYSTEM_EMSCRIPTEN
+#undef SDL_FILESYSTEM_OS2
+#undef SDL_FILESYSTEM_VITA
+#undef SDL_FILESYSTEM_PSP
+
+/* Enable misc subsystem */
+#undef SDL_MISC_DUMMY
+
+/* Enable locale subsystem */
+#undef SDL_LOCALE_DUMMY
 
 /* Enable assembly routines */
 #undef SDL_ASSEMBLY_ROUTINES
@@ -434,6 +472,9 @@
 #undef SDL_ARM_SIMD_BLITTERS
 #undef SDL_ARM_NEON_BLITTERS
 
+/* Whether SDL_DYNAMIC_API needs dlopen() */
+#undef DYNAPI_NEEDS_DLOPEN
+
 /* Enable ime support */
 #undef SDL_USE_IME
 
diff --git a/Engine/lib/sdl/include/SDL_config_android.h b/Engine/lib/sdl/include/SDL_config_android.h
index d1148cf2f..4a13a3a53 100644
--- a/Engine/lib/sdl/include/SDL_config_android.h
+++ b/Engine/lib/sdl/include/SDL_config_android.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -48,6 +48,7 @@
 #define HAVE_SYS_TYPES_H    1
 
 /* C library functions */
+#define HAVE_DLOPEN 1
 #define HAVE_MALLOC 1
 #define HAVE_CALLOC 1
 #define HAVE_REALLOC    1
@@ -111,8 +112,12 @@
 #define HAVE_LOGF   1
 #define HAVE_LOG10  1
 #define HAVE_LOG10F 1
+#define HAVE_LROUND 1
+#define HAVE_LROUNDF 1
 #define HAVE_POW    1
 #define HAVE_POWF   1
+#define HAVE_ROUND  1
+#define HAVE_ROUNDF 1
 #define HAVE_SCALBN 1
 #define HAVE_SCALBNF    1
 #define HAVE_SIN    1
@@ -129,11 +134,16 @@
 #define HAVE_SYSCONF    1
 #define HAVE_CLOCK_GETTIME  1
 
+#ifdef __LP64__
+#define SIZEOF_VOIDP 8
+#else
 #define SIZEOF_VOIDP 4
+#endif
 
 /* Enable various audio drivers */
 #define SDL_AUDIO_DRIVER_ANDROID    1
 #define SDL_AUDIO_DRIVER_OPENSLES   1
+#define SDL_AUDIO_DRIVER_AAUDIO     1
 #define SDL_AUDIO_DRIVER_DUMMY  1
 
 /* Enable various input drivers */
diff --git a/Engine/lib/sdl/include/SDL_config_emscripten.h b/Engine/lib/sdl/include/SDL_config_emscripten.h
new file mode 100644
index 000000000..7efe32373
--- /dev/null
+++ b/Engine/lib/sdl/include/SDL_config_emscripten.h
@@ -0,0 +1,216 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef _SDL_config_emscripten_h_
+#define _SDL_config_emscripten_h_
+
+#include "SDL_platform.h"
+
+/**
+ *  \file SDL_config_emscripten.h
+ *
+ *  This is a configuration that can be used to build SDL for Emscripten.
+ */
+
+#ifdef __LP64__
+#define SIZEOF_VOIDP 8
+#else
+#define SIZEOF_VOIDP 4
+#endif
+#define HAVE_GCC_ATOMICS 1
+
+/* Useful headers */
+#define STDC_HEADERS 1
+#define HAVE_ALLOCA_H 1
+#define HAVE_CTYPE_H 1
+#define HAVE_ICONV_H 1
+#define HAVE_INTTYPES_H 1
+#define HAVE_LIMITS_H 1
+#define HAVE_MALLOC_H 1
+#define HAVE_MATH_H 1
+#define HAVE_MEMORY_H 1
+#define HAVE_SIGNAL_H 1
+#define HAVE_STDARG_H 1
+#define HAVE_STDINT_H 1
+#define HAVE_STDIO_H 1
+#define HAVE_STDLIB_H 1
+#define HAVE_STRINGS_H 1
+#define HAVE_STRING_H 1
+#define HAVE_SYS_TYPES_H 1
+#define HAVE_WCHAR_H 1
+
+/* C library functions */
+#define HAVE_DLOPEN 1
+#define HAVE_MALLOC 1
+#define HAVE_CALLOC 1
+#define HAVE_REALLOC 1
+#define HAVE_FREE 1
+#define HAVE_ALLOCA 1
+#define HAVE_GETENV 1
+#define HAVE_SETENV 1
+#define HAVE_PUTENV 1
+#define HAVE_UNSETENV 1
+#define HAVE_QSORT 1
+#define HAVE_ABS 1
+#define HAVE_BCOPY 1
+#define HAVE_MEMSET 1
+#define HAVE_MEMCPY 1
+#define HAVE_MEMMOVE 1
+#define HAVE_MEMCMP 1
+#define HAVE_WCSLEN 1
+#define HAVE_WCSDUP 1
+#define HAVE_WCSSTR 1
+#define HAVE_WCSCMP 1
+#define HAVE_WCSNCMP 1
+#define HAVE_WCSCASECMP 1
+#define HAVE_WCSNCASECMP 1
+#define HAVE_STRLEN 1
+#define HAVE_STRLCPY 1
+#define HAVE_STRLCAT 1
+#define HAVE_STRCHR 1
+#define HAVE_STRRCHR 1
+#define HAVE_STRSTR 1
+#define HAVE_STRTOK_R 1
+#define HAVE_STRTOL 1
+#define HAVE_STRTOUL 1
+#define HAVE_STRTOLL 1
+#define HAVE_STRTOULL 1
+#define HAVE_STRTOD 1
+#define HAVE_ATOI 1
+#define HAVE_ATOF 1
+#define HAVE_STRCMP 1
+#define HAVE_STRNCMP 1
+#define HAVE_STRCASECMP 1
+#define HAVE_STRNCASECMP 1
+#define HAVE_SSCANF 1
+#define HAVE_VSSCANF 1
+#define HAVE_VSNPRINTF 1
+#define HAVE_M_PI 1
+#define HAVE_ACOS 1
+#define HAVE_ACOSF 1
+#define HAVE_ASIN 1
+#define HAVE_ASINF 1
+#define HAVE_ATAN 1
+#define HAVE_ATANF 1
+#define HAVE_ATAN2 1
+#define HAVE_ATAN2F 1
+#define HAVE_CEIL 1
+#define HAVE_CEILF 1
+#define HAVE_COPYSIGN 1
+#define HAVE_COPYSIGNF 1
+#define HAVE_COS 1
+#define HAVE_COSF 1
+#define HAVE_EXP 1
+#define HAVE_EXPF 1
+#define HAVE_FABS 1
+#define HAVE_FABSF 1
+#define HAVE_FLOOR 1
+#define HAVE_FLOORF 1
+#define HAVE_FMOD 1
+#define HAVE_FMODF 1
+#define HAVE_LOG 1
+#define HAVE_LOGF 1
+#define HAVE_LOG10 1
+#define HAVE_LOG10F 1
+#define HAVE_LROUND 1
+#define HAVE_LROUNDF 1
+#define HAVE_POW 1
+#define HAVE_POWF 1
+#define HAVE_ROUND  1
+#define HAVE_ROUNDF 1
+#define HAVE_SCALBN 1
+#define HAVE_SCALBNF 1
+#define HAVE_SIN 1
+#define HAVE_SINF 1
+#define HAVE_SQRT 1
+#define HAVE_SQRTF 1
+#define HAVE_TAN 1
+#define HAVE_TANF 1
+#define HAVE_TRUNC 1
+#define HAVE_TRUNCF 1
+#define HAVE_FSEEKO 1
+#define HAVE_FSEEKO64 1
+#define HAVE_SIGACTION 1
+#define HAVE_SA_SIGACTION 1
+#define HAVE_SETJMP 1
+#define HAVE_NANOSLEEP 1
+#define HAVE_SYSCONF 1
+#define HAVE_CLOCK_GETTIME 1
+/* #undef HAVE_GETPAGESIZE */
+#define HAVE_MPROTECT 1
+#define HAVE_ICONV 1
+
+/* SDL internal assertion support */
+/* #undef SDL_DEFAULT_ASSERT_LEVEL */
+
+#define SDL_CPUINFO_DISABLED 1
+#define SDL_HAPTIC_DISABLED 1
+#define SDL_HIDAPI_DISABLED 1
+#ifndef __EMSCRIPTEN_PTHREADS__
+#define SDL_THREADS_DISABLED 1
+#endif
+
+/* Enable various audio drivers */
+#define SDL_AUDIO_DRIVER_DISK 1
+#define SDL_AUDIO_DRIVER_DUMMY 1
+#define SDL_AUDIO_DRIVER_EMSCRIPTEN 1
+
+/* Enable various input drivers */
+#define SDL_JOYSTICK_EMSCRIPTEN 1
+
+/* Enable various sensor drivers */
+#define SDL_SENSOR_DUMMY 1
+
+/* Enable various shared object loading systems */
+#define SDL_LOADSO_DLOPEN 1
+
+/* Enable various threading systems */
+#ifdef __EMSCRIPTEN_PTHREADS__
+#define SDL_THREAD_PTHREAD 1
+#endif
+
+/* Enable various timer systems */
+#define SDL_TIMER_UNIX 1
+
+/* Enable various video drivers */
+#define SDL_VIDEO_DRIVER_EMSCRIPTEN 1
+
+#define SDL_VIDEO_RENDER_OGL_ES2 1
+
+/* Enable OpenGL support */
+/* #undef SDL_VIDEO_OPENGL */
+/* #undef SDL_VIDEO_OPENGL_ES */
+#define SDL_VIDEO_OPENGL_ES2 1
+/* #undef SDL_VIDEO_OPENGL_BGL */
+/* #undef SDL_VIDEO_OPENGL_CGL */
+/* #undef SDL_VIDEO_OPENGL_GLX */
+/* #undef SDL_VIDEO_OPENGL_WGL */
+#define SDL_VIDEO_OPENGL_EGL 1
+/* #undef SDL_VIDEO_OPENGL_OSMESA */
+/* #undef SDL_VIDEO_OPENGL_OSMESA_DYNAMIC */
+
+/* Enable system power support */
+#define SDL_POWER_EMSCRIPTEN 1
+
+/* Enable system filesystem support */
+#define SDL_FILESYSTEM_EMSCRIPTEN 1
+
+#endif /* _SDL_config_emscripten_h_ */
diff --git a/Engine/lib/sdl/include/SDL_config_iphoneos.h b/Engine/lib/sdl/include/SDL_config_iphoneos.h
index f06ad3354..0aa242563 100644
--- a/Engine/lib/sdl/include/SDL_config_iphoneos.h
+++ b/Engine/lib/sdl/include/SDL_config_iphoneos.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -48,6 +48,7 @@
 /* #undef HAVE_LIBUNWIND_H */
 
 /* C library functions */
+#define HAVE_DLOPEN 1
 #define HAVE_MALLOC 1
 #define HAVE_CALLOC 1
 #define HAVE_REALLOC    1
@@ -112,8 +113,12 @@
 #define HAVE_LOGF   1
 #define HAVE_LOG10  1
 #define HAVE_LOG10F 1
+#define HAVE_LROUND 1
+#define HAVE_LROUNDF 1
 #define HAVE_POW    1
 #define HAVE_POWF   1
+#define HAVE_ROUND 1
+#define HAVE_ROUNDF 1
 #define HAVE_SCALBN 1
 #define HAVE_SCALBNF    1
 #define HAVE_SIN    1
@@ -129,6 +134,7 @@
 #define HAVE_NANOSLEEP  1
 #define HAVE_SYSCONF    1
 #define HAVE_SYSCTLBYNAME 1
+#define HAVE_O_CLOEXEC 1
 
 /* enable iPhone version of Core Audio driver */
 #define SDL_AUDIO_DRIVER_COREAUDIO 1
@@ -166,10 +172,12 @@
 #define SDL_VIDEO_DRIVER_DUMMY  1
 
 /* Enable OpenGL ES */
+#if !TARGET_OS_MACCATALYST
 #define SDL_VIDEO_OPENGL_ES2 1
 #define SDL_VIDEO_OPENGL_ES 1
 #define SDL_VIDEO_RENDER_OGL_ES 1
 #define SDL_VIDEO_RENDER_OGL_ES2    1
+#endif
 
 /* Metal supported on 64-bit devices running iOS 8.0 and tvOS 9.0 and newer
    Also supported in simulator from iOS 13.0 and tvOS 13.0
diff --git a/Engine/lib/sdl/include/SDL_config_macosx.h b/Engine/lib/sdl/include/SDL_config_macosx.h
index 4b45f1658..ff42e3d5f 100644
--- a/Engine/lib/sdl/include/SDL_config_macosx.h
+++ b/Engine/lib/sdl/include/SDL_config_macosx.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -52,6 +52,7 @@
 #define HAVE_LIBUNWIND_H    1
 
 /* C library functions */
+#define HAVE_DLOPEN 1
 #define HAVE_MALLOC 1
 #define HAVE_CALLOC 1
 #define HAVE_REALLOC    1
@@ -115,8 +116,12 @@
 #define HAVE_LOGF   1
 #define HAVE_LOG10  1
 #define HAVE_LOG10F 1
+#define HAVE_LROUND 1
+#define HAVE_LROUNDF 1
 #define HAVE_POW    1
 #define HAVE_POWF   1
+#define HAVE_ROUND 1
+#define HAVE_ROUNDF 1
 #define HAVE_SCALBN 1
 #define HAVE_SCALBNF    1
 #define HAVE_SIN    1
@@ -133,6 +138,16 @@
 #define HAVE_SYSCONF    1
 #define HAVE_SYSCTLBYNAME 1
 
+#if defined(__has_include) && (defined(__i386__) || defined(__x86_64))
+# if __has_include(<immintrin.h>)
+#   define HAVE_IMMINTRIN_H 1
+# endif
+#endif
+
+#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1070)
+#define HAVE_O_CLOEXEC 1
+#endif
+
 #define HAVE_GCC_ATOMICS 1
 
 /* Enable various audio drivers */
@@ -191,7 +206,6 @@
  */
 #define SDL_VIDEO_DRIVER_X11_XINPUT2 1
 #define SDL_VIDEO_DRIVER_X11_SUPPORTS_GENERIC_EVENTS 1
-#define SDL_VIDEO_DRIVER_X11_CONST_PARAM_XEXTADDDISPLAY 1
 #endif
 
 #ifndef SDL_VIDEO_RENDER_OGL
diff --git a/Engine/lib/sdl/include/SDL_config_minimal.h b/Engine/lib/sdl/include/SDL_config_minimal.h
index b9c39584f..4df92f748 100644
--- a/Engine/lib/sdl/include/SDL_config_minimal.h
+++ b/Engine/lib/sdl/include/SDL_config_minimal.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -64,6 +64,9 @@ typedef unsigned long uintptr_t;
 /* Enable the stub haptic driver (src/haptic/dummy/\*.c) */
 #define SDL_HAPTIC_DISABLED 1
 
+/* Enable the stub HIDAPI */
+#define SDL_HIDAPI_DISABLED 1
+
 /* Enable the stub sensor driver (src/sensor/dummy/\*.c) */
 #define SDL_SENSOR_DISABLED 1
 
diff --git a/Engine/lib/sdl/include/SDL_config_os2.h b/Engine/lib/sdl/include/SDL_config_os2.h
index 1922217d0..1728bd772 100644
--- a/Engine/lib/sdl/include/SDL_config_os2.h
+++ b/Engine/lib/sdl/include/SDL_config_os2.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -25,26 +25,32 @@
 
 #include "SDL_platform.h"
 
+#define SIZEOF_VOIDP 4
+
 #define SDL_AUDIO_DRIVER_DUMMY 1
 #define SDL_AUDIO_DRIVER_DISK 1
 #define SDL_AUDIO_DRIVER_OS2 1
 
 #define SDL_POWER_DISABLED  1
-#define SDL_JOYSTICK_DISABLED 1
 #define SDL_HAPTIC_DISABLED 1
-/*#undef SDL_JOYSTICK_HIDAPI */
-/*#undef SDL_JOYSTICK_VIRTUAL */
 
 #define SDL_SENSOR_DUMMY 1
 #define SDL_VIDEO_DRIVER_DUMMY 1
 #define SDL_VIDEO_DRIVER_OS2 1
+#define SDL_JOYSTICK_OS2 1
+#ifndef HAVE_LIBUSB_H  /* see Makefile */
+#define SDL_HIDAPI_DISABLED 1
+/*#undef SDL_JOYSTICK_HIDAPI */
+#else
+#define SDL_JOYSTICK_HIDAPI 1
+/* dynamically loaded libusb-1.0 dll: */
+#define SDL_LIBUSB_DYNAMIC "usb100.dll"
+#endif
+/*#undef SDL_JOYSTICK_VIRTUAL */
 
 /* Enable OpenGL support */
 /* #undef SDL_VIDEO_OPENGL */
 
-/* Enable Vulkan support */
-/* #undef SDL_VIDEO_VULKAN */
-
 #define SDL_THREAD_OS2 1
 #define SDL_LOADSO_OS2 1
 #define SDL_TIMER_OS2 1
@@ -61,25 +67,32 @@
 
 #define HAVE_LIBC 1
 
+#define HAVE_STDARG_H 1
+#define HAVE_STDDEF_H 1
+#define HAVE_STDINT_H 1
+
 #define HAVE_SYS_TYPES_H 1
 #define HAVE_STDIO_H 1
 #define STDC_HEADERS 1
 #define HAVE_STDLIB_H 1
-#define HAVE_STDARG_H 1
-#define HAVE_STDDEF_H 1
 #define HAVE_MALLOC_H 1
 #define HAVE_MEMORY_H 1
 #define HAVE_STRING_H 1
 #define HAVE_STRINGS_H 1
 #define HAVE_WCHAR_H 1
 #define HAVE_INTTYPES_H 1
-#define HAVE_STDINT_H 1
 #define HAVE_LIMITS_H 1
 #define HAVE_CTYPE_H 1
 #define HAVE_MATH_H 1
 #define HAVE_FLOAT_H 1
 #define HAVE_SIGNAL_H 1
 
+#if 0 /* see Makefile */
+#define HAVE_ICONV 1
+#define HAVE_ICONV_H 1
+#endif
+
+/* #undef HAVE_DLOPEN */
 #define HAVE_MALLOC 1
 #define HAVE_CALLOC 1
 #define HAVE_REALLOC 1
@@ -105,14 +118,22 @@
 #define HAVE_WCSCMP 1
 #define HAVE__WCSICMP 1
 #define HAVE__WCSNICMP 1
+#define HAVE_WCSLEN 1
+#define HAVE_WCSLCPY 1
+#define HAVE_WCSLCAT 1
+/* #undef HAVE_WCSDUP */
+#define HAVE__WCSDUP 1
+#define HAVE_WCSSTR 1
+#define HAVE_WCSCMP 1
+#define HAVE_WCSNCMP 1
 #define HAVE_STRLEN 1
 #define HAVE_STRLCPY 1
 #define HAVE_STRLCAT 1
 #define HAVE__STRREV 1
 #define HAVE__STRUPR 1
 #define HAVE__STRLWR 1
-#define HAVE_INDEX 1
-#define HAVE_RINDEX 1
+/* #undef HAVE_INDEX */
+/* #undef HAVE_RINDEX */
 #define HAVE_STRCHR 1
 #define HAVE_STRRCHR 1
 #define HAVE_STRSTR 1
@@ -129,14 +150,6 @@
 #define HAVE_STRTOD 1
 #define HAVE_ATOI 1
 #define HAVE_ATOF 1
-#define HAVE_WCSLEN 1
-#define HAVE_WCSLCPY 1
-#define HAVE_WCSLCAT 1
-/* #define HAVE_WCSDUP 1 */
-/* #define wcsdup _wcsdup */
-#define HAVE_WCSSTR 1
-#define HAVE_WCSCMP 1
-#define HAVE_WCSNCMP 1
 #define HAVE_STRCMP 1
 #define HAVE_STRNCMP 1
 #define HAVE_STRICMP 1
@@ -184,5 +197,9 @@
 /* #undef HAVE_TANF */
 /* #undef HAVE_TRUNC */
 /* #undef HAVE_TRUNCF */
+/* #undef HAVE_LROUND */
+/* #undef HAVE_LROUNDF */
+/* #undef HAVE_ROUND */
+/* #undef HAVE_ROUNDF */
 
 #endif /* SDL_config_os2_h_ */
diff --git a/Engine/lib/sdl/include/SDL_config_pandora.h b/Engine/lib/sdl/include/SDL_config_pandora.h
index 8728a6388..e0be390bc 100644
--- a/Engine/lib/sdl/include/SDL_config_pandora.h
+++ b/Engine/lib/sdl/include/SDL_config_pandora.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -54,6 +54,7 @@
 #define HAVE_STRING_H 1
 #define HAVE_SYS_TYPES_H 1
 
+#define HAVE_DLOPEN 1
 #define HAVE_MALLOC 1
 #define HAVE_CALLOC 1
 #define HAVE_REALLOC 1
@@ -95,6 +96,10 @@
 #define HAVE_FLOOR 1
 #define HAVE_LOG 1
 #define HAVE_LOG10 1
+#define HAVE_LROUND 1
+#define HAVE_LROUNDF 1
+#define HAVE_ROUND 1
+#define HAVE_ROUNDF 1
 #define HAVE_SCALBN 1
 #define HAVE_SIN 1
 #define HAVE_SINF 1
diff --git a/Engine/lib/sdl/include/SDL_config_psp.h b/Engine/lib/sdl/include/SDL_config_psp.h
deleted file mode 100644
index 235fe08e9..000000000
--- a/Engine/lib/sdl/include/SDL_config_psp.h
+++ /dev/null
@@ -1,165 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_config_psp_h_
-#define SDL_config_psp_h_
-#define SDL_config_h_
-
-#include "SDL_platform.h"
-
-
-
-#ifdef __GNUC__
-#define HAVE_GCC_SYNC_LOCK_TEST_AND_SET 1
-#endif
-
-#define HAVE_GCC_ATOMICS    1
-
-#define STDC_HEADERS    1
-#define HAVE_ALLOCA_H       1
-#define HAVE_CTYPE_H    1
-#define HAVE_INTTYPES_H 1
-#define HAVE_LIMITS_H   1
-#define HAVE_MATH_H 1
-#define HAVE_SIGNAL_H   1
-#define HAVE_STDINT_H   1
-#define HAVE_STDIO_H    1
-#define HAVE_STRING_H   1
-#define HAVE_SYS_TYPES_H    1
-
-/* C library functions */
-#define HAVE_MALLOC 1
-#define HAVE_CALLOC 1
-#define HAVE_REALLOC    1
-#define HAVE_FREE   1
-#define HAVE_ALLOCA 1
-#define HAVE_GETENV 1
-#define HAVE_SETENV 1
-#define HAVE_PUTENV 1
-#define HAVE_SETENV 1
-#define HAVE_UNSETENV   1
-#define HAVE_QSORT  1
-#define HAVE_ABS    1
-#define HAVE_BCOPY  1
-#define HAVE_MEMSET 1
-#define HAVE_MEMCPY 1
-#define HAVE_MEMMOVE    1
-#define HAVE_MEMCMP 1
-#define HAVE_STRLEN 1
-#define HAVE_STRLCPY    1
-#define HAVE_STRLCAT    1
-#define HAVE_STRCHR 1
-#define HAVE_STRRCHR    1
-#define HAVE_STRSTR 1
-#define HAVE_STRTOL 1
-#define HAVE_STRTOUL    1
-#define HAVE_STRTOLL    1
-#define HAVE_STRTOULL   1
-#define HAVE_STRTOD 1
-#define HAVE_ATOI   1
-#define HAVE_ATOF   1
-#define HAVE_STRCMP 1
-#define HAVE_STRNCMP    1
-#define HAVE_STRCASECMP 1
-#define HAVE_STRNCASECMP 1
-#define HAVE_VSSCANF 1
-#define HAVE_VSNPRINTF  1
-#define HAVE_M_PI   1
-#define HAVE_ACOS   1
-#define HAVE_ACOSF  1
-#define HAVE_ASIN   1
-#define HAVE_ASINF  1
-#define HAVE_ATAN   1
-#define HAVE_ATANF  1
-#define HAVE_ATAN2  1
-#define HAVE_ATAN2F 1
-#define HAVE_CEIL   1
-#define HAVE_CEILF  1
-#define HAVE_COPYSIGN   1
-#define HAVE_COPYSIGNF  1
-#define HAVE_COS    1
-#define HAVE_COSF   1
-#define HAVE_EXP    1
-#define HAVE_EXPF   1
-#define HAVE_FABS   1
-#define HAVE_FABSF  1
-#define HAVE_FLOOR  1
-#define HAVE_FLOORF 1
-#define HAVE_FMOD   1
-#define HAVE_FMODF  1
-#define HAVE_LOG    1
-#define HAVE_LOGF   1
-#define HAVE_LOG10  1
-#define HAVE_LOG10F 1
-#define HAVE_POW    1
-#define HAVE_POWF   1
-#define HAVE_SCALBN 1
-#define HAVE_SCALBNF    1
-#define HAVE_SIN    1
-#define HAVE_SINF   1
-#define HAVE_SQRT   1
-#define HAVE_SQRTF  1
-#define HAVE_TAN    1
-#define HAVE_TANF   1
-#define HAVE_SETJMP 1
-#define HAVE_NANOSLEEP  1
-/* #define HAVE_SYSCONF  1 */
-/* #define HAVE_SIGACTION    1 */
-
-
-/* PSP isn't that sophisticated */
-#define LACKS_SYS_MMAN_H 1
-
-/* Enable the PSP thread support (src/thread/psp/\*.c) */
-#define SDL_THREAD_PSP  1
-
-/* Enable the PSP timer support (src/timer/psp/\*.c) */
-#define SDL_TIMERS_PSP  1
-
-/* Enable the PSP joystick driver (src/joystick/psp/\*.c) */
-#define SDL_JOYSTICK_PSP        1
-#define SDL_JOYSTICK_VIRTUAL    1
-
-/* Enable the dummy sensor driver */
-#define SDL_SENSOR_DUMMY  1
-
-/* Enable the PSP audio driver (src/audio/psp/\*.c) */
-#define SDL_AUDIO_DRIVER_PSP    1
-
-/* PSP video driver */
-#define SDL_VIDEO_DRIVER_PSP   1
-
-/* PSP render driver */
-#define SDL_VIDEO_RENDER_PSP   1
-
-#define SDL_POWER_PSP          1
-
-/* !!! FIXME: what does PSP do for filesystem stuff? */
-#define SDL_FILESYSTEM_DUMMY   1
-
-/* PSP doesn't have haptic device (src/haptic/dummy/\*.c) */
-#define SDL_HAPTIC_DISABLED    1
-
-/* PSP can't load shared object (src/loadso/dummy/\*.c) */
-#define SDL_LOADSO_DISABLED    1
-
-
-#endif /* SDL_config_psp_h_ */
diff --git a/Engine/lib/sdl/include/SDL_config_windows.h b/Engine/lib/sdl/include/SDL_config_windows.h
index 18a363829..efb246da9 100644
--- a/Engine/lib/sdl/include/SDL_config_windows.h
+++ b/Engine/lib/sdl/include/SDL_config_windows.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -25,10 +25,23 @@
 
 #include "SDL_platform.h"
 
+/* winsdkver.h defines _WIN32_MAXVER for SDK version detection. It is present since at least the Windows 7 SDK,
+ * but out of caution we'll only use it if the compiler supports __has_include() to confirm its presence.
+ * If your compiler doesn't support __has_include() but you have winsdkver.h, define HAVE_WINSDKVER_H.  */
+#if !defined(HAVE_WINSDKVER_H) && defined(__has_include)
+#if __has_include(<winsdkver.h>)
+#define HAVE_WINSDKVER_H 1
+#endif
+#endif
+
+#ifdef HAVE_WINSDKVER_H
+#include <winsdkver.h>
+#endif
+
 /* This is a set of defines to configure the SDL features */
 
 #if !defined(_STDINT_H_) && (!defined(HAVE_STDINT_H) || !_HAVE_STDINT_H)
-#if defined(__GNUC__) || defined(__DMC__) || defined(__WATCOMC__)
+#if defined(__GNUC__) || defined(__DMC__) || defined(__WATCOMC__) || defined(__clang__) || defined(__BORLANDC__) || defined(__CODEGEARC__)
 #define HAVE_STDINT_H   1
 #elif defined(_MSC_VER)
 typedef signed __int8 int8_t;
@@ -77,14 +90,32 @@ typedef unsigned int uintptr_t;
 # define SIZEOF_VOIDP 4
 #endif
 
+#ifdef __clang__
+# define HAVE_GCC_ATOMICS 1
+#endif
+
 #define HAVE_DDRAW_H 1
 #define HAVE_DINPUT_H 1
 #define HAVE_DSOUND_H 1
 #define HAVE_DXGI_H 1
 #define HAVE_XINPUT_H 1
+#if defined(_WIN32_MAXVER) && _WIN32_MAXVER >= 0x0A00  /* Windows 10 SDK */
+#define HAVE_WINDOWS_GAMING_INPUT_H 1
+#endif
+#if defined(_WIN32_MAXVER) && _WIN32_MAXVER >= 0x0602  /* Windows 8 SDK */
+#define HAVE_D3D11_H 1
+#endif
 #define HAVE_MMDEVICEAPI_H 1
 #define HAVE_AUDIOCLIENT_H 1
-#define HAVE_SENSORSAPI_H
+#define HAVE_TPCSHRD_H 1
+#define HAVE_SENSORSAPI_H 1
+#if (defined(_M_IX86) || defined(_M_X64) || defined(_M_AMD64)) && (defined(_MSC_VER) && _MSC_VER >= 1600)
+#define HAVE_IMMINTRIN_H 1
+#elif defined(__has_include) && (defined(__i386__) || defined(__x86_64))
+# if __has_include(<immintrin.h>)
+#   define HAVE_IMMINTRIN_H 1
+# endif
+#endif
 
 /* This is disabled by default to avoid C runtime dependencies and manifest requirements */
 #ifdef HAVE_LIBC
@@ -119,9 +150,6 @@ typedef unsigned int uintptr_t;
 #define HAVE_STRRCHR 1
 #define HAVE_STRSTR 1
 /* #undef HAVE_STRTOK_R */
-#if defined(_MSC_VER)
-#define HAVE_STRTOK_S 1
-#endif
 /* These functions have security warnings, so we won't use them */
 /* #undef HAVE__LTOA */
 /* #undef HAVE__ULTOA */
@@ -136,6 +164,7 @@ typedef unsigned int uintptr_t;
 #define HAVE__STRNICMP 1
 #define HAVE__WCSICMP 1
 #define HAVE__WCSNICMP 1
+#define HAVE__WCSDUP 1
 #define HAVE_ACOS   1
 #define HAVE_ACOSF  1
 #define HAVE_ASIN   1
@@ -172,7 +201,12 @@ typedef unsigned int uintptr_t;
 /* These functions were added with the VC++ 2013 C runtime library */
 #if _MSC_VER >= 1800
 #define HAVE_STRTOLL 1
+#define HAVE_STRTOULL 1
 #define HAVE_VSSCANF 1
+#define HAVE_LROUND 1
+#define HAVE_LROUNDF 1
+#define HAVE_ROUND 1
+#define HAVE_ROUNDF 1
 #define HAVE_SCALBN 1
 #define HAVE_SCALBNF 1
 #define HAVE_TRUNC  1
@@ -191,20 +225,6 @@ typedef unsigned int uintptr_t;
 #define HAVE_STDDEF_H   1
 #endif
 
-/* Check to see if we have Windows 10 build environment */
-#if _MSC_VER >= 1911        /* Visual Studio 15.3 */
-#include <sdkddkver.h>
-#if _WIN32_WINNT >= 0x0601  /* Windows 7 */
-#define SDL_WINDOWS7_SDK
-#endif
-#if _WIN32_WINNT >= 0x0602  /* Windows 8 */
-#define SDL_WINDOWS8_SDK
-#endif
-#if _WIN32_WINNT >= 0x0A00  /* Windows 10 */
-#define SDL_WINDOWS10_SDK
-#endif
-#endif /* _MSC_VER >= 1911 */
-
 /* Enable various audio drivers */
 #define SDL_AUDIO_DRIVER_WASAPI 1
 #define SDL_AUDIO_DRIVER_DSOUND 1
@@ -219,7 +239,7 @@ typedef unsigned int uintptr_t;
 #define SDL_JOYSTICK_RAWINPUT   1
 #endif
 #define SDL_JOYSTICK_VIRTUAL    1
-#ifdef SDL_WINDOWS10_SDK
+#ifdef HAVE_WINDOWS_GAMING_INPUT_H
 #define SDL_JOYSTICK_WGI    1
 #endif
 #define SDL_JOYSTICK_XINPUT 1
@@ -233,6 +253,7 @@ typedef unsigned int uintptr_t;
 #define SDL_LOADSO_WINDOWS  1
 
 /* Enable various threading systems */
+#define SDL_THREAD_GENERIC_COND_SUFFIX 1
 #define SDL_THREAD_WINDOWS  1
 
 /* Enable various timer systems */
@@ -245,7 +266,7 @@ typedef unsigned int uintptr_t;
 #ifndef SDL_VIDEO_RENDER_D3D
 #define SDL_VIDEO_RENDER_D3D    1
 #endif
-#ifdef SDL_WINDOWS7_SDK
+#if !defined(SDL_VIDEO_RENDER_D3D11) && defined(HAVE_D3D11_H)
 #define SDL_VIDEO_RENDER_D3D11  1
 #endif
 
diff --git a/Engine/lib/sdl/include/SDL_config_winrt.h b/Engine/lib/sdl/include/SDL_config_winrt.h
index 02079f53c..c548fd695 100644
--- a/Engine/lib/sdl/include/SDL_config_winrt.h
+++ b/Engine/lib/sdl/include/SDL_config_winrt.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -92,6 +92,10 @@ typedef unsigned int uintptr_t;
 # define SIZEOF_VOIDP 4
 #endif
 
+#ifdef __clang__
+# define HAVE_GCC_ATOMICS 1
+#endif
+
 /* Useful headers */
 #define HAVE_DXGI_H 1
 #if WINAPI_FAMILY != WINAPI_FAMILY_PHONE_APP
@@ -100,6 +104,7 @@ typedef unsigned int uintptr_t;
 
 #define HAVE_MMDEVICEAPI_H 1
 #define HAVE_AUDIOCLIENT_H 1
+#define HAVE_TPCSHRD_H 1
 
 #define HAVE_LIBC 1
 #define STDC_HEADERS 1
@@ -126,17 +131,13 @@ typedef unsigned int uintptr_t;
 #define HAVE_STRLEN 1
 #define HAVE__STRREV 1
 #define HAVE__STRUPR 1
-//#define HAVE__STRLWR 1    // TODO, WinRT: consider using _strlwr_s instead
 #define HAVE_STRCHR 1
 #define HAVE_STRRCHR 1
 #define HAVE_STRSTR 1
-#define HAVE_STRTOK_S 1
-//#define HAVE_ITOA 1   // TODO, WinRT: consider using _itoa_s instead
-//#define HAVE__LTOA 1  // TODO, WinRT: consider using _ltoa_s instead
-//#define HAVE__ULTOA 1 // TODO, WinRT: consider using _ultoa_s instead
 #define HAVE_STRTOL 1
 #define HAVE_STRTOUL 1
-//#define HAVE_STRTOLL 1
+/* #undef HAVE_STRTOLL */
+/* #undef HAVE_STRTOULL */
 #define HAVE_STRTOD 1
 #define HAVE_ATOI 1
 #define HAVE_ATOF 1
@@ -145,7 +146,12 @@ typedef unsigned int uintptr_t;
 #define HAVE__STRICMP 1
 #define HAVE__STRNICMP 1
 #define HAVE_VSNPRINTF 1
-//#define HAVE_SSCANF 1 // TODO, WinRT: consider using sscanf_s instead
+/* TODO, WinRT: consider using ??_s versions of the following */
+/* #undef HAVE__STRLWR */
+/* #undef HAVE_ITOA */
+/* #undef HAVE__LTOA */
+/* #undef HAVE__ULTOA */
+/* #undef HAVE_SSCANF */
 #define HAVE_M_PI 1
 #define HAVE_ACOS   1
 #define HAVE_ACOSF  1
@@ -172,8 +178,12 @@ typedef unsigned int uintptr_t;
 #define HAVE_LOGF   1
 #define HAVE_LOG10  1
 #define HAVE_LOG10F 1
+#define HAVE_LROUND 1
+#define HAVE_LROUNDF 1
 #define HAVE_POW    1
 #define HAVE_POWF   1
+#define HAVE_ROUND 1
+#define HAVE_ROUNDF 1
 #define HAVE__SCALB 1
 #define HAVE_SIN    1
 #define HAVE_SINF   1
@@ -196,10 +206,18 @@ typedef unsigned int uintptr_t;
 #define SDL_HAPTIC_DISABLED 1
 #else
 #define SDL_JOYSTICK_VIRTUAL    1
+#if (NTDDI_VERSION >= NTDDI_WIN10)
+#define SDL_JOYSTICK_WGI    1
+#define SDL_HAPTIC_DISABLED 1
+#else
 #define SDL_JOYSTICK_XINPUT 1
 #define SDL_HAPTIC_XINPUT   1
+#endif /* WIN10 */
 #endif
 
+/* WinRT doesn't have HIDAPI available */
+#define SDL_HIDAPI_DISABLED    1
+
 /* Enable the dummy sensor driver */
 #define SDL_SENSOR_DUMMY  1
 
@@ -208,6 +226,7 @@ typedef unsigned int uintptr_t;
 
 /* Enable various threading systems */
 #if (NTDDI_VERSION >= NTDDI_WINBLUE)
+#define SDL_THREAD_GENERIC_COND_SUFFIX 1
 #define SDL_THREAD_WINDOWS  1
 #else
 /* WinRT on Windows 8.0 and Windows Phone 8.0 don't support CreateThread() */
diff --git a/Engine/lib/sdl/include/SDL_config_wiz.h b/Engine/lib/sdl/include/SDL_config_wiz.h
deleted file mode 100644
index f65af8eb5..000000000
--- a/Engine/lib/sdl/include/SDL_config_wiz.h
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_config_wiz_h_
-#define SDL_config_wiz_h_
-#define SDL_config_h_
-
-/* This is a set of defines to configure the SDL features */
-
-/* General platform specific identifiers */
-#include "SDL_platform.h"
-
-#define SDL_BYTEORDER 1234
-
-#define STDC_HEADERS 1
-#define HAVE_ALLOCA_H 1
-#define HAVE_CTYPE_H 1
-#define HAVE_ICONV_H 1
-#define HAVE_INTTYPES_H 1
-#define HAVE_LIMITS_H 1
-#define HAVE_MALLOC_H 1
-#define HAVE_MATH_H 1
-#define HAVE_MEMORY_H 1
-#define HAVE_SIGNAL_H 1
-#define HAVE_STDARG_H 1
-#define HAVE_STDINT_H 1
-#define HAVE_STDIO_H 1
-#define HAVE_STDLIB_H 1
-#define HAVE_STRINGS_H 1
-#define HAVE_STRING_H 1
-#define HAVE_SYS_TYPES_H 1
-
-#define HAVE_MALLOC 1
-#define HAVE_CALLOC 1
-#define HAVE_REALLOC 1
-#define HAVE_FREE 1
-#define HAVE_ALLOCA 1
-#define HAVE_GETENV 1
-#define HAVE_SETENV 1
-#define HAVE_PUTENV 1
-#define HAVE_UNSETENV 1
-#define HAVE_QSORT 1
-#define HAVE_ABS 1
-#define HAVE_BCOPY 1
-#define HAVE_MEMSET 1
-#define HAVE_MEMCPY 1
-#define HAVE_MEMMOVE 1
-#define HAVE_STRLEN 1
-#define HAVE_STRCHR 1
-#define HAVE_STRRCHR 1
-#define HAVE_STRSTR 1
-#define HAVE_STRTOK_R 1
-#define HAVE_STRTOL 1
-#define HAVE_STRTOUL 1
-#define HAVE_STRTOLL 1
-#define HAVE_STRTOULL 1
-#define HAVE_ATOI 1
-#define HAVE_ATOF 1
-#define HAVE_STRCMP 1
-#define HAVE_STRNCMP 1
-#define HAVE_STRCASECMP 1
-#define HAVE_STRNCASECMP 1
-#define HAVE_VSSCANF 1
-#define HAVE_VSNPRINTF 1
-#define HAVE_M_PI 1
-#define HAVE_ACOS   1
-#define HAVE_ACOSF  1
-#define HAVE_ASIN   1
-#define HAVE_ASINF  1
-#define HAVE_ATAN   1
-#define HAVE_ATANF  1
-#define HAVE_ATAN2  1
-#define HAVE_ATAN2F 1
-#define HAVE_CEIL   1
-#define HAVE_CEILF  1
-#define HAVE_COPYSIGN   1
-#define HAVE_COPYSIGNF  1
-#define HAVE_COS    1
-#define HAVE_COSF   1
-#define HAVE_EXP    1
-#define HAVE_EXPF   1
-#define HAVE_FABS   1
-#define HAVE_FABSF  1
-#define HAVE_FLOOR  1
-#define HAVE_FLOORF 1
-#define HAVE_FMOD   1
-#define HAVE_FMODF  1
-#define HAVE_LOG    1
-#define HAVE_LOGF   1
-#define HAVE_LOG10  1
-#define HAVE_LOG10F 1
-#define HAVE_POW    1
-#define HAVE_POWF   1
-#define HAVE_SCALBN 1
-#define HAVE_SCALBNF    1
-#define HAVE_SIN    1
-#define HAVE_SINF   1
-#define HAVE_SQRT   1
-#define HAVE_SQRTF  1
-#define HAVE_TAN    1
-#define HAVE_TANF   1
-#define HAVE_TRUNC    1
-#define HAVE_TRUNCF   1
-#define HAVE_SIGACTION 1
-#define HAVE_SETJMP 1
-#define HAVE_NANOSLEEP 1
-#define HAVE_POW 1
-
-#define SDL_AUDIO_DRIVER_DUMMY 1
-#define SDL_AUDIO_DRIVER_OSS 1
-
-#define SDL_INPUT_LINUXEV 1
-#define SDL_JOYSTICK_LINUX 1
-#define SDL_JOYSTICK_VIRTUAL 1
-#define SDL_HAPTIC_LINUX 1
-
-#define SDL_SENSOR_DUMMY  1
-
-#define SDL_LOADSO_DLOPEN 1
-
-#define SDL_THREAD_PTHREAD 1
-#define SDL_THREAD_PTHREAD_RECURSIVE_MUTEX_NP 1
-
-#define SDL_TIMER_UNIX 1
-
-#define SDL_VIDEO_DRIVER_DUMMY 1
-#define SDL_VIDEO_DRIVER_PANDORA 1
-#define SDL_VIDEO_RENDER_OGL_ES 1
-#define SDL_VIDEO_OPENGL_ES 1
-
-#endif /* SDL_config_wiz_h_ */
diff --git a/Engine/lib/sdl/include/SDL_copying.h b/Engine/lib/sdl/include/SDL_copying.h
index 4f8a2bcd4..49e3f9da0 100644
--- a/Engine/lib/sdl/include/SDL_copying.h
+++ b/Engine/lib/sdl/include/SDL_copying.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/include/SDL_cpuinfo.h b/Engine/lib/sdl/include/SDL_cpuinfo.h
index df3123c00..1fc40991d 100644
--- a/Engine/lib/sdl/include/SDL_cpuinfo.h
+++ b/Engine/lib/sdl/include/SDL_cpuinfo.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -34,11 +34,20 @@
 /* Visual Studio 2005 has a bug where intrin.h conflicts with winnt.h */
 #if defined(_MSC_VER) && (_MSC_VER >= 1500) && (defined(_M_IX86) || defined(_M_X64))
 #ifdef __clang__
-/* Many of the intrinsics SDL uses are not implemented by clang with Visual Studio */
-#undef __MMX__
-#undef __SSE__
-#undef __SSE2__
-#else
+/* As of Clang 11, '_m_prefetchw' is conflicting with the winnt.h's version,
+   so we define the needed '_m_prefetch' here as a pseudo-header, until the issue is fixed. */
+
+#ifndef __PRFCHWINTRIN_H
+#define __PRFCHWINTRIN_H
+
+static __inline__ void __attribute__((__always_inline__, __nodebug__))
+_m_prefetch(void *__P)
+{
+  __builtin_prefetch (__P, 0, 3 /* _MM_HINT_T0 */);
+}
+
+#endif /* __PRFCHWINTRIN_H */
+#endif /* __clang__ */
 #include <intrin.h>
 #ifndef _WIN64
 #ifndef __MMX__
@@ -54,9 +63,14 @@
 #ifndef __SSE2__
 #define __SSE2__
 #endif
-#endif /* __clang__ */
+#ifndef __SSE3__
+#define __SSE3__
+#endif
 #elif defined(__MINGW64_VERSION_MAJOR)
 #include <intrin.h>
+#if !defined(SDL_DISABLE_ARM_NEON_H) && defined(__ARM_NEON)
+#  include <arm_neon.h>
+#endif
 #else
 /* altivec.h redefining bool causes a number of problems, see bugs 3993 and 4392, so you need to explicitly define SDL_ENABLE_ALTIVEC_H to have it included. */
 #if defined(HAVE_ALTIVEC_H) && defined(__ALTIVEC__) && !defined(__APPLE_ALTIVEC__) && defined(SDL_ENABLE_ALTIVEC_H)
@@ -79,6 +93,8 @@
 #    endif
 #  endif
 #endif
+#endif /* compiler version */
+
 #if defined(__3dNOW__) && !defined(SDL_DISABLE_MM3DNOW_H)
 #include <mm3dnow.h>
 #endif
@@ -98,7 +114,6 @@
 #include <pmmintrin.h>
 #endif
 #endif /* HAVE_IMMINTRIN_H */
-#endif /* compiler version */
 
 #include "begin_code.h"
 /* Set up for C function definitions, even when using C++ */
@@ -114,136 +129,370 @@ extern "C" {
 #define SDL_CACHELINE_SIZE  128
 
 /**
- *  This function returns the number of CPU cores available.
+ * Get the number of CPU cores available.
+ *
+ * \returns the total number of logical CPU cores. On CPUs that include
+ *          technologies such as hyperthreading, the number of logical cores
+ *          may be more than the number of physical cores.
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC int SDLCALL SDL_GetCPUCount(void);
 
 /**
- *  This function returns the L1 cache line size of the CPU
+ * Determine the L1 cache line size of the CPU.
  *
- *  This is useful for determining multi-threaded structure padding
- *  or SIMD prefetch sizes.
+ * This is useful for determining multi-threaded structure padding or SIMD
+ * prefetch sizes.
+ *
+ * \returns the L1 cache line size of the CPU, in bytes.
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC int SDLCALL SDL_GetCPUCacheLineSize(void);
 
 /**
- *  This function returns true if the CPU has the RDTSC instruction.
+ * Determine whether the CPU has the RDTSC instruction.
+ *
+ * This always returns false on CPUs that aren't using Intel instruction sets.
+ *
+ * \returns SDL_TRUE if the CPU has the RDTSC instruction or SDL_FALSE if not.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_Has3DNow
+ * \sa SDL_HasAltiVec
+ * \sa SDL_HasAVX
+ * \sa SDL_HasAVX2
+ * \sa SDL_HasMMX
+ * \sa SDL_HasSSE
+ * \sa SDL_HasSSE2
+ * \sa SDL_HasSSE3
+ * \sa SDL_HasSSE41
+ * \sa SDL_HasSSE42
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_HasRDTSC(void);
 
 /**
- *  This function returns true if the CPU has AltiVec features.
+ * Determine whether the CPU has AltiVec features.
+ *
+ * This always returns false on CPUs that aren't using PowerPC instruction
+ * sets.
+ *
+ * \returns SDL_TRUE if the CPU has AltiVec features or SDL_FALSE if not.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_Has3DNow
+ * \sa SDL_HasAVX
+ * \sa SDL_HasAVX2
+ * \sa SDL_HasMMX
+ * \sa SDL_HasRDTSC
+ * \sa SDL_HasSSE
+ * \sa SDL_HasSSE2
+ * \sa SDL_HasSSE3
+ * \sa SDL_HasSSE41
+ * \sa SDL_HasSSE42
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_HasAltiVec(void);
 
 /**
- *  This function returns true if the CPU has MMX features.
+ * Determine whether the CPU has MMX features.
+ *
+ * This always returns false on CPUs that aren't using Intel instruction sets.
+ *
+ * \returns SDL_TRUE if the CPU has MMX features or SDL_FALSE if not.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_Has3DNow
+ * \sa SDL_HasAltiVec
+ * \sa SDL_HasAVX
+ * \sa SDL_HasAVX2
+ * \sa SDL_HasRDTSC
+ * \sa SDL_HasSSE
+ * \sa SDL_HasSSE2
+ * \sa SDL_HasSSE3
+ * \sa SDL_HasSSE41
+ * \sa SDL_HasSSE42
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_HasMMX(void);
 
 /**
- *  This function returns true if the CPU has 3DNow! features.
+ * Determine whether the CPU has 3DNow! features.
+ *
+ * This always returns false on CPUs that aren't using AMD instruction sets.
+ *
+ * \returns SDL_TRUE if the CPU has 3DNow! features or SDL_FALSE if not.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HasAltiVec
+ * \sa SDL_HasAVX
+ * \sa SDL_HasAVX2
+ * \sa SDL_HasMMX
+ * \sa SDL_HasRDTSC
+ * \sa SDL_HasSSE
+ * \sa SDL_HasSSE2
+ * \sa SDL_HasSSE3
+ * \sa SDL_HasSSE41
+ * \sa SDL_HasSSE42
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_Has3DNow(void);
 
 /**
- *  This function returns true if the CPU has SSE features.
+ * Determine whether the CPU has SSE features.
+ *
+ * This always returns false on CPUs that aren't using Intel instruction sets.
+ *
+ * \returns SDL_TRUE if the CPU has SSE features or SDL_FALSE if not.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_Has3DNow
+ * \sa SDL_HasAltiVec
+ * \sa SDL_HasAVX
+ * \sa SDL_HasAVX2
+ * \sa SDL_HasMMX
+ * \sa SDL_HasRDTSC
+ * \sa SDL_HasSSE2
+ * \sa SDL_HasSSE3
+ * \sa SDL_HasSSE41
+ * \sa SDL_HasSSE42
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_HasSSE(void);
 
 /**
- *  This function returns true if the CPU has SSE2 features.
+ * Determine whether the CPU has SSE2 features.
+ *
+ * This always returns false on CPUs that aren't using Intel instruction sets.
+ *
+ * \returns SDL_TRUE if the CPU has SSE2 features or SDL_FALSE if not.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_Has3DNow
+ * \sa SDL_HasAltiVec
+ * \sa SDL_HasAVX
+ * \sa SDL_HasAVX2
+ * \sa SDL_HasMMX
+ * \sa SDL_HasRDTSC
+ * \sa SDL_HasSSE
+ * \sa SDL_HasSSE3
+ * \sa SDL_HasSSE41
+ * \sa SDL_HasSSE42
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_HasSSE2(void);
 
 /**
- *  This function returns true if the CPU has SSE3 features.
+ * Determine whether the CPU has SSE3 features.
+ *
+ * This always returns false on CPUs that aren't using Intel instruction sets.
+ *
+ * \returns SDL_TRUE if the CPU has SSE3 features or SDL_FALSE if not.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_Has3DNow
+ * \sa SDL_HasAltiVec
+ * \sa SDL_HasAVX
+ * \sa SDL_HasAVX2
+ * \sa SDL_HasMMX
+ * \sa SDL_HasRDTSC
+ * \sa SDL_HasSSE
+ * \sa SDL_HasSSE2
+ * \sa SDL_HasSSE41
+ * \sa SDL_HasSSE42
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_HasSSE3(void);
 
 /**
- *  This function returns true if the CPU has SSE4.1 features.
+ * Determine whether the CPU has SSE4.1 features.
+ *
+ * This always returns false on CPUs that aren't using Intel instruction sets.
+ *
+ * \returns SDL_TRUE if the CPU has SSE4.1 features or SDL_FALSE if not.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_Has3DNow
+ * \sa SDL_HasAltiVec
+ * \sa SDL_HasAVX
+ * \sa SDL_HasAVX2
+ * \sa SDL_HasMMX
+ * \sa SDL_HasRDTSC
+ * \sa SDL_HasSSE
+ * \sa SDL_HasSSE2
+ * \sa SDL_HasSSE3
+ * \sa SDL_HasSSE42
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_HasSSE41(void);
 
 /**
- *  This function returns true if the CPU has SSE4.2 features.
+ * Determine whether the CPU has SSE4.2 features.
+ *
+ * This always returns false on CPUs that aren't using Intel instruction sets.
+ *
+ * \returns SDL_TRUE if the CPU has SSE4.2 features or SDL_FALSE if not.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_Has3DNow
+ * \sa SDL_HasAltiVec
+ * \sa SDL_HasAVX
+ * \sa SDL_HasAVX2
+ * \sa SDL_HasMMX
+ * \sa SDL_HasRDTSC
+ * \sa SDL_HasSSE
+ * \sa SDL_HasSSE2
+ * \sa SDL_HasSSE3
+ * \sa SDL_HasSSE41
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_HasSSE42(void);
 
 /**
- *  This function returns true if the CPU has AVX features.
+ * Determine whether the CPU has AVX features.
+ *
+ * This always returns false on CPUs that aren't using Intel instruction sets.
+ *
+ * \returns SDL_TRUE if the CPU has AVX features or SDL_FALSE if not.
+ *
+ * \since This function is available since SDL 2.0.2.
+ *
+ * \sa SDL_Has3DNow
+ * \sa SDL_HasAltiVec
+ * \sa SDL_HasAVX2
+ * \sa SDL_HasMMX
+ * \sa SDL_HasRDTSC
+ * \sa SDL_HasSSE
+ * \sa SDL_HasSSE2
+ * \sa SDL_HasSSE3
+ * \sa SDL_HasSSE41
+ * \sa SDL_HasSSE42
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_HasAVX(void);
 
 /**
- *  This function returns true if the CPU has AVX2 features.
+ * Determine whether the CPU has AVX2 features.
+ *
+ * This always returns false on CPUs that aren't using Intel instruction sets.
+ *
+ * \returns SDL_TRUE if the CPU has AVX2 features or SDL_FALSE if not.
+ *
+ * \since This function is available since SDL 2.0.4.
+ *
+ * \sa SDL_Has3DNow
+ * \sa SDL_HasAltiVec
+ * \sa SDL_HasAVX
+ * \sa SDL_HasMMX
+ * \sa SDL_HasRDTSC
+ * \sa SDL_HasSSE
+ * \sa SDL_HasSSE2
+ * \sa SDL_HasSSE3
+ * \sa SDL_HasSSE41
+ * \sa SDL_HasSSE42
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_HasAVX2(void);
 
 /**
- *  This function returns true if the CPU has AVX-512F (foundation) features.
+ * Determine whether the CPU has AVX-512F (foundation) features.
+ *
+ * This always returns false on CPUs that aren't using Intel instruction sets.
+ *
+ * \returns SDL_TRUE if the CPU has AVX-512F features or SDL_FALSE if not.
+ *
+ * \since This function is available since SDL 2.0.9.
+ *
+ * \sa SDL_HasAVX
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_HasAVX512F(void);
 
 /**
- *  This function returns true if the CPU has ARM SIMD (ARMv6) features.
+ * Determine whether the CPU has ARM SIMD (ARMv6) features.
+ *
+ * This is different from ARM NEON, which is a different instruction set.
+ *
+ * This always returns false on CPUs that aren't using ARM instruction sets.
+ *
+ * \returns SDL_TRUE if the CPU has ARM SIMD features or SDL_FALSE if not.
+ *
+ * \since This function is available since SDL 2.0.12.
+ *
+ * \sa SDL_HasNEON
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_HasARMSIMD(void);
 
 /**
- *  This function returns true if the CPU has NEON (ARM SIMD) features.
+ * Determine whether the CPU has NEON (ARM SIMD) features.
+ *
+ * This always returns false on CPUs that aren't using ARM instruction sets.
+ *
+ * \returns SDL_TRUE if the CPU has ARM NEON features or SDL_FALSE if not.
+ *
+ * \since This function is available since SDL 2.0.6.
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_HasNEON(void);
 
 /**
- *  This function returns the amount of RAM configured in the system, in MB.
+ * Get the amount of RAM configured in the system.
+ *
+ * \returns the amount of RAM configured in the system in MB.
+ *
+ * \since This function is available since SDL 2.0.1.
  */
 extern DECLSPEC int SDLCALL SDL_GetSystemRAM(void);
 
 /**
- * \brief Report the alignment this system needs for SIMD allocations.
+ * Report the alignment this system needs for SIMD allocations.
  *
  * This will return the minimum number of bytes to which a pointer must be
- *  aligned to be compatible with SIMD instructions on the current machine.
- *  For example, if the machine supports SSE only, it will return 16, but if
- *  it supports AVX-512F, it'll return 64 (etc). This only reports values for
- *  instruction sets SDL knows about, so if your SDL build doesn't have
- *  SDL_HasAVX512F(), then it might return 16 for the SSE support it sees and
- *  not 64 for the AVX-512 instructions that exist but SDL doesn't know about.
- *  Plan accordingly.
+ * aligned to be compatible with SIMD instructions on the current machine. For
+ * example, if the machine supports SSE only, it will return 16, but if it
+ * supports AVX-512F, it'll return 64 (etc). This only reports values for
+ * instruction sets SDL knows about, so if your SDL build doesn't have
+ * SDL_HasAVX512F(), then it might return 16 for the SSE support it sees and
+ * not 64 for the AVX-512 instructions that exist but SDL doesn't know about.
+ * Plan accordingly.
+ *
+ * \returns the alignment in bytes needed for available, known SIMD
+ *          instructions.
+ *
+ * \since This function is available since SDL 2.0.10.
  */
 extern DECLSPEC size_t SDLCALL SDL_SIMDGetAlignment(void);
 
 /**
- * \brief Allocate memory in a SIMD-friendly way.
+ * Allocate memory in a SIMD-friendly way.
  *
  * This will allocate a block of memory that is suitable for use with SIMD
- *  instructions. Specifically, it will be properly aligned and padded for
- *  the system's supported vector instructions.
+ * instructions. Specifically, it will be properly aligned and padded for the
+ * system's supported vector instructions.
  *
- * The memory returned will be padded such that it is safe to read or write
- *  an incomplete vector at the end of the memory block. This can be useful
- *  so you don't have to drop back to a scalar fallback at the end of your
- *  SIMD processing loop to deal with the final elements without overflowing
- *  the allocated buffer.
+ * The memory returned will be padded such that it is safe to read or write an
+ * incomplete vector at the end of the memory block. This can be useful so you
+ * don't have to drop back to a scalar fallback at the end of your SIMD
+ * processing loop to deal with the final elements without overflowing the
+ * allocated buffer.
  *
- * You must free this memory with SDL_FreeSIMD(), not free() or SDL_free()
- *  or delete[], etc.
+ * You must free this memory with SDL_FreeSIMD(), not free() or SDL_free() or
+ * delete[], etc.
  *
- * Note that SDL will only deal with SIMD instruction sets it is aware of;
- *  for example, SDL 2.0.8 knows that SSE wants 16-byte vectors
- *  (SDL_HasSSE()), and AVX2 wants 32 bytes (SDL_HasAVX2()), but doesn't
- *  know that AVX-512 wants 64. To be clear: if you can't decide to use an
- *  instruction set with an SDL_Has*() function, don't use that instruction
- *  set with memory allocated through here.
+ * Note that SDL will only deal with SIMD instruction sets it is aware of; for
+ * example, SDL 2.0.8 knows that SSE wants 16-byte vectors (SDL_HasSSE()), and
+ * AVX2 wants 32 bytes (SDL_HasAVX2()), but doesn't know that AVX-512 wants
+ * 64. To be clear: if you can't decide to use an instruction set with an
+ * SDL_Has*() function, don't use that instruction set with memory allocated
+ * through here.
  *
  * SDL_AllocSIMD(0) will return a non-NULL pointer, assuming the system isn't
- *  out of memory.
+ * out of memory, but you are not allowed to dereference it (because you only
+ * own zero bytes of that buffer).
  *
- *  \param len The length, in bytes, of the block to allocated. The actual
- *             allocated block might be larger due to padding, etc.
- * \return Pointer to newly-allocated block, NULL if out of memory.
+ * \param len The length, in bytes, of the block to allocate. The actual
+ *            allocated block might be larger due to padding, etc.
+ * \returns a pointer to the newly-allocated block, NULL if out of memory.
+ *
+ * \since This function is available since SDL 2.0.10.
  *
  * \sa SDL_SIMDAlignment
  * \sa SDL_SIMDRealloc
@@ -252,20 +501,22 @@ extern DECLSPEC size_t SDLCALL SDL_SIMDGetAlignment(void);
 extern DECLSPEC void * SDLCALL SDL_SIMDAlloc(const size_t len);
 
 /**
- * \brief Reallocate memory obtained from SDL_SIMDAlloc
+ * Reallocate memory obtained from SDL_SIMDAlloc
  *
  * It is not valid to use this function on a pointer from anything but
- *  SDL_SIMDAlloc(). It can't be used on pointers from malloc, realloc,
- *  SDL_malloc, memalign, new[], etc.
+ * SDL_SIMDAlloc(). It can't be used on pointers from malloc, realloc,
+ * SDL_malloc, memalign, new[], etc.
  *
- *  \param mem The pointer obtained from SDL_SIMDAlloc. This function also
- *             accepts NULL, at which point this function is the same as
- *             calling SDL_realloc with a NULL pointer.
- *  \param len The length, in bytes, of the block to allocated. The actual
- *             allocated block might be larger due to padding, etc. Passing 0
- *             will return a non-NULL pointer, assuming the system isn't out of
- *             memory.
- * \return Pointer to newly-reallocated block, NULL if out of memory.
+ * \param mem The pointer obtained from SDL_SIMDAlloc. This function also
+ *            accepts NULL, at which point this function is the same as
+ *            calling SDL_SIMDAlloc with a NULL pointer.
+ * \param len The length, in bytes, of the block to allocated. The actual
+ *            allocated block might be larger due to padding, etc. Passing 0
+ *            will return a non-NULL pointer, assuming the system isn't out of
+ *            memory.
+ * \returns a pointer to the newly-reallocated block, NULL if out of memory.
+ *
+ * \since This function is available since SDL 2.0.14.
  *
  * \sa SDL_SIMDAlignment
  * \sa SDL_SIMDAlloc
@@ -274,20 +525,29 @@ extern DECLSPEC void * SDLCALL SDL_SIMDAlloc(const size_t len);
 extern DECLSPEC void * SDLCALL SDL_SIMDRealloc(void *mem, const size_t len);
 
 /**
- * \brief Deallocate memory obtained from SDL_SIMDAlloc
+ * Deallocate memory obtained from SDL_SIMDAlloc
  *
  * It is not valid to use this function on a pointer from anything but
- *  SDL_SIMDAlloc(). It can't be used on pointers from malloc, realloc,
- *  SDL_malloc, memalign, new[], etc.
+ * SDL_SIMDAlloc() or SDL_SIMDRealloc(). It can't be used on pointers from
+ * malloc, realloc, SDL_malloc, memalign, new[], etc.
  *
  * However, SDL_SIMDFree(NULL) is a legal no-op.
  *
+ * The memory pointed to by `ptr` is no longer valid for access upon return,
+ * and may be returned to the system or reused by a future allocation. The
+ * pointer passed to this function is no longer safe to dereference once this
+ * function returns, and should be discarded.
+ *
+ * \param ptr The pointer, returned from SDL_SIMDAlloc or SDL_SIMDRealloc, to
+ *            deallocate. NULL is a legal no-op.
+ *
+ * \since This function is available since SDL 2.0.10.
+ *
  * \sa SDL_SIMDAlloc
  * \sa SDL_SIMDRealloc
  */
 extern DECLSPEC void SDLCALL SDL_SIMDFree(void *ptr);
 
-/* vi: set ts=4 sw=4 expandtab: */
 /* Ends C function definitions when using C++ */
 #ifdef __cplusplus
 }
diff --git a/Engine/lib/sdl/include/SDL_egl.h b/Engine/lib/sdl/include/SDL_egl.h
index 531441e68..f90e27b26 100644
--- a/Engine/lib/sdl/include/SDL_egl.h
+++ b/Engine/lib/sdl/include/SDL_egl.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -24,7 +24,11 @@
  *
  *  This is a simple file to encapsulate the EGL API headers.
  */
-#if !defined(_MSC_VER) && !defined(__ANDROID__)
+#if !defined(_MSC_VER) && !defined(__ANDROID__) && !defined(SDL_USE_BUILTIN_OPENGL_DEFINITIONS)
+
+#if defined(__vita__) || defined(__psp2__)
+#include <psp2/types.h>
+#endif
 
 #include <EGL/egl.h>
 #include <EGL/eglext.h>
@@ -37,7 +41,7 @@
 #define __khrplatform_h_
 
 /*
-** Copyright (c) 2008-2009 The Khronos Group Inc.
+** Copyright (c) 2008-2018 The Khronos Group Inc.
 **
 ** Permission is hereby granted, free of charge, to any person obtaining a
 ** copy of this software and/or associated documentation files (the
@@ -60,104 +64,112 @@
 */
 
 /* Khronos platform-specific types and definitions.
-*
-* $Revision: 23298 $ on $Date: 2013-09-30 17:07:13 -0700 (Mon, 30 Sep 2013) $
-*
-* Adopters may modify this file to suit their platform. Adopters are
-* encouraged to submit platform specific modifications to the Khronos
-* group so that they can be included in future versions of this file.
-* Please submit changes by sending them to the public Khronos Bugzilla
-* (http://khronos.org/bugzilla) by filing a bug against product
-* "Khronos (general)" component "Registry".
-*
-* A predefined template which fills in some of the bug fields can be
-* reached using http://tinyurl.com/khrplatform-h-bugreport, but you
-* must create a Bugzilla login first.
-*
-*
-* See the Implementer's Guidelines for information about where this file
-* should be located on your system and for more details of its use:
-*    http://www.khronos.org/registry/implementers_guide.pdf
-*
-* This file should be included as
-*        #include <KHR/khrplatform.h>
-* by Khronos client API header files that use its types and defines.
-*
-* The types in khrplatform.h should only be used to define API-specific types.
-*
-* Types defined in khrplatform.h:
-*    khronos_int8_t              signed   8  bit
-*    khronos_uint8_t             unsigned 8  bit
-*    khronos_int16_t             signed   16 bit
-*    khronos_uint16_t            unsigned 16 bit
-*    khronos_int32_t             signed   32 bit
-*    khronos_uint32_t            unsigned 32 bit
-*    khronos_int64_t             signed   64 bit
-*    khronos_uint64_t            unsigned 64 bit
-*    khronos_intptr_t            signed   same number of bits as a pointer
-*    khronos_uintptr_t           unsigned same number of bits as a pointer
-*    khronos_ssize_t             signed   size
-*    khronos_usize_t             unsigned size
-*    khronos_float_t             signed   32 bit floating point
-*    khronos_time_ns_t           unsigned 64 bit time in nanoseconds
-*    khronos_utime_nanoseconds_t unsigned time interval or absolute time in
-*                                         nanoseconds
-*    khronos_stime_nanoseconds_t signed time interval in nanoseconds
-*    khronos_boolean_enum_t      enumerated boolean type. This should
-*      only be used as a base type when a client API's boolean type is
-*      an enum. Client APIs which use an integer or other type for
-*      booleans cannot use this as the base type for their boolean.
-*
-* Tokens defined in khrplatform.h:
-*
-*    KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
-*
-*    KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
-*    KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
-*
-* Calling convention macros defined in this file:
-*    KHRONOS_APICALL
-*    KHRONOS_APIENTRY
-*    KHRONOS_APIATTRIBUTES
-*
-* These may be used in function prototypes as:
-*
-*      KHRONOS_APICALL void KHRONOS_APIENTRY funcname(
-*                                  int arg1,
-*                                  int arg2) KHRONOS_APIATTRIBUTES;
-*/
+ *
+ * The master copy of khrplatform.h is maintained in the Khronos EGL
+ * Registry repository at https://github.com/KhronosGroup/EGL-Registry
+ * The last semantic modification to khrplatform.h was at commit ID:
+ *      67a3e0864c2d75ea5287b9f3d2eb74a745936692
+ *
+ * Adopters may modify this file to suit their platform. Adopters are
+ * encouraged to submit platform specific modifications to the Khronos
+ * group so that they can be included in future versions of this file.
+ * Please submit changes by filing pull requests or issues on
+ * the EGL Registry repository linked above.
+ *
+ *
+ * See the Implementer's Guidelines for information about where this file
+ * should be located on your system and for more details of its use:
+ *    http://www.khronos.org/registry/implementers_guide.pdf
+ *
+ * This file should be included as
+ *        #include <KHR/khrplatform.h>
+ * by Khronos client API header files that use its types and defines.
+ *
+ * The types in khrplatform.h should only be used to define API-specific types.
+ *
+ * Types defined in khrplatform.h:
+ *    khronos_int8_t              signed   8  bit
+ *    khronos_uint8_t             unsigned 8  bit
+ *    khronos_int16_t             signed   16 bit
+ *    khronos_uint16_t            unsigned 16 bit
+ *    khronos_int32_t             signed   32 bit
+ *    khronos_uint32_t            unsigned 32 bit
+ *    khronos_int64_t             signed   64 bit
+ *    khronos_uint64_t            unsigned 64 bit
+ *    khronos_intptr_t            signed   same number of bits as a pointer
+ *    khronos_uintptr_t           unsigned same number of bits as a pointer
+ *    khronos_ssize_t             signed   size
+ *    khronos_usize_t             unsigned size
+ *    khronos_float_t             signed   32 bit floating point
+ *    khronos_time_ns_t           unsigned 64 bit time in nanoseconds
+ *    khronos_utime_nanoseconds_t unsigned time interval or absolute time in
+ *                                         nanoseconds
+ *    khronos_stime_nanoseconds_t signed time interval in nanoseconds
+ *    khronos_boolean_enum_t      enumerated boolean type. This should
+ *      only be used as a base type when a client API's boolean type is
+ *      an enum. Client APIs which use an integer or other type for
+ *      booleans cannot use this as the base type for their boolean.
+ *
+ * Tokens defined in khrplatform.h:
+ *
+ *    KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
+ *
+ *    KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
+ *    KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
+ *
+ * Calling convention macros defined in this file:
+ *    KHRONOS_APICALL
+ *    KHRONOS_APIENTRY
+ *    KHRONOS_APIATTRIBUTES
+ *
+ * These may be used in function prototypes as:
+ *
+ *      KHRONOS_APICALL void KHRONOS_APIENTRY funcname(
+ *                                  int arg1,
+ *                                  int arg2) KHRONOS_APIATTRIBUTES;
+ */
+
+#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC)
+#   define KHRONOS_STATIC 1
+#endif
 
 /*-------------------------------------------------------------------------
-* Definition of KHRONOS_APICALL
-*-------------------------------------------------------------------------
-* This precedes the return type of the function in the function prototype.
-*/
-#if defined(_WIN32) && !defined(__SCITECH_SNAP__) && !defined(SDL_VIDEO_STATIC_ANGLE)
+ * Definition of KHRONOS_APICALL
+ *-------------------------------------------------------------------------
+ * This precedes the return type of the function in the function prototype.
+ */
+#if defined(KHRONOS_STATIC)
+    /* If the preprocessor constant KHRONOS_STATIC is defined, make the
+     * header compatible with static linking. */
+#   define KHRONOS_APICALL
+#elif defined(_WIN32)
 #   define KHRONOS_APICALL __declspec(dllimport)
 #elif defined (__SYMBIAN32__)
 #   define KHRONOS_APICALL IMPORT_C
+#elif defined(__ANDROID__)
+#   define KHRONOS_APICALL __attribute__((visibility("default")))
 #else
 #   define KHRONOS_APICALL
 #endif
 
 /*-------------------------------------------------------------------------
-* Definition of KHRONOS_APIENTRY
-*-------------------------------------------------------------------------
-* This follows the return type of the function  and precedes the function
-* name in the function prototype.
-*/
+ * Definition of KHRONOS_APIENTRY
+ *-------------------------------------------------------------------------
+ * This follows the return type of the function  and precedes the function
+ * name in the function prototype.
+ */
 #if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
-/* Win32 but not WinCE */
+    /* Win32 but not WinCE */
 #   define KHRONOS_APIENTRY __stdcall
 #else
 #   define KHRONOS_APIENTRY
 #endif
 
 /*-------------------------------------------------------------------------
-* Definition of KHRONOS_APIATTRIBUTES
-*-------------------------------------------------------------------------
-* This follows the closing parenthesis of the function prototype arguments.
-*/
+ * Definition of KHRONOS_APIATTRIBUTES
+ *-------------------------------------------------------------------------
+ * This follows the closing parenthesis of the function prototype arguments.
+ */
 #if defined (__ARMCC_2__)
 #define KHRONOS_APIATTRIBUTES __softfp
 #else
@@ -165,14 +177,14 @@
 #endif
 
 /*-------------------------------------------------------------------------
-* basic type definitions
-*-----------------------------------------------------------------------*/
+ * basic type definitions
+ *-----------------------------------------------------------------------*/
 #if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__)
 
 
 /*
-* Using <stdint.h>
-*/
+ * Using <stdint.h>
+ */
 #include <stdint.h>
 typedef int32_t                 khronos_int32_t;
 typedef uint32_t                khronos_uint32_t;
@@ -184,8 +196,8 @@ typedef uint64_t                khronos_uint64_t;
 #elif defined(__VMS ) || defined(__sgi)
 
 /*
-* Using <inttypes.h>
-*/
+ * Using <inttypes.h>
+ */
 #include <inttypes.h>
 typedef int32_t                 khronos_int32_t;
 typedef uint32_t                khronos_uint32_t;
@@ -197,8 +209,8 @@ typedef uint64_t                khronos_uint64_t;
 #elif defined(_WIN32) && !defined(__SCITECH_SNAP__)
 
 /*
-* Win32
-*/
+ * Win32
+ */
 typedef __int32                 khronos_int32_t;
 typedef unsigned __int32        khronos_uint32_t;
 typedef __int64                 khronos_int64_t;
@@ -209,8 +221,8 @@ typedef unsigned __int64        khronos_uint64_t;
 #elif defined(__sun__) || defined(__digital__)
 
 /*
-* Sun or Digital
-*/
+ * Sun or Digital
+ */
 typedef int                     khronos_int32_t;
 typedef unsigned int            khronos_uint32_t;
 #if defined(__arch64__) || defined(_LP64)
@@ -226,8 +238,8 @@ typedef unsigned long long int  khronos_uint64_t;
 #elif 0
 
 /*
-* Hypothetical platform with no float or int64 support
-*/
+ * Hypothetical platform with no float or int64 support
+ */
 typedef int                     khronos_int32_t;
 typedef unsigned int            khronos_uint32_t;
 #define KHRONOS_SUPPORT_INT64   0
@@ -236,8 +248,8 @@ typedef unsigned int            khronos_uint32_t;
 #else
 
 /*
-* Generic fallback
-*/
+ * Generic fallback
+ */
 #include <stdint.h>
 typedef int32_t                 khronos_int32_t;
 typedef uint32_t                khronos_uint32_t;
@@ -250,18 +262,18 @@ typedef uint64_t                khronos_uint64_t;
 
 
 /*
-* Types that are (so far) the same on all platforms
-*/
+ * Types that are (so far) the same on all platforms
+ */
 typedef signed   char          khronos_int8_t;
 typedef unsigned char          khronos_uint8_t;
 typedef signed   short int     khronos_int16_t;
 typedef unsigned short int     khronos_uint16_t;
 
 /*
-* Types that differ between LLP64 and LP64 architectures - in LLP64,
-* pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
-* to be the only LLP64 architecture in current use.
-*/
+ * Types that differ between LLP64 and LP64 architectures - in LLP64,
+ * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
+ * to be the only LLP64 architecture in current use.
+ */
 #ifdef _WIN64
 typedef signed   long long int khronos_intptr_t;
 typedef unsigned long long int khronos_uintptr_t;
@@ -276,41 +288,41 @@ typedef unsigned long  int     khronos_usize_t;
 
 #if KHRONOS_SUPPORT_FLOAT
 /*
-* Float type
-*/
+ * Float type
+ */
 typedef          float         khronos_float_t;
 #endif
 
 #if KHRONOS_SUPPORT_INT64
 /* Time types
-*
-* These types can be used to represent a time interval in nanoseconds or
-* an absolute Unadjusted System Time.  Unadjusted System Time is the number
-* of nanoseconds since some arbitrary system event (e.g. since the last
-* time the system booted).  The Unadjusted System Time is an unsigned
-* 64 bit value that wraps back to 0 every 584 years.  Time intervals
-* may be either signed or unsigned.
-*/
+ *
+ * These types can be used to represent a time interval in nanoseconds or
+ * an absolute Unadjusted System Time.  Unadjusted System Time is the number
+ * of nanoseconds since some arbitrary system event (e.g. since the last
+ * time the system booted).  The Unadjusted System Time is an unsigned
+ * 64 bit value that wraps back to 0 every 584 years.  Time intervals
+ * may be either signed or unsigned.
+ */
 typedef khronos_uint64_t       khronos_utime_nanoseconds_t;
 typedef khronos_int64_t        khronos_stime_nanoseconds_t;
 #endif
 
 /*
-* Dummy value used to pad enum types to 32 bits.
-*/
+ * Dummy value used to pad enum types to 32 bits.
+ */
 #ifndef KHRONOS_MAX_ENUM
 #define KHRONOS_MAX_ENUM 0x7FFFFFFF
 #endif
 
 /*
-* Enumerated boolean type
-*
-* Values other than zero should be considered to be true.  Therefore
-* comparisons should not be made against KHRONOS_TRUE.
-*/
+ * Enumerated boolean type
+ *
+ * Values other than zero should be considered to be true.  Therefore
+ * comparisons should not be made against KHRONOS_TRUE.
+ */
 typedef enum {
     KHRONOS_FALSE = 0,
-    KHRONOS_TRUE = 1,
+    KHRONOS_TRUE  = 1,
     KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM
 } khronos_boolean_enum_t;
 
@@ -321,49 +333,30 @@ typedef enum {
 #define __eglplatform_h_
 
 /*
-** Copyright (c) 2007-2009 The Khronos Group Inc.
-**
-** Permission is hereby granted, free of charge, to any person obtaining a
-** copy of this software and/or associated documentation files (the
-** "Materials"), to deal in the Materials without restriction, including
-** without limitation the rights to use, copy, modify, merge, publish,
-** distribute, sublicense, and/or sell copies of the Materials, and to
-** permit persons to whom the Materials are furnished to do so, subject to
-** the following conditions:
-**
-** The above copyright notice and this permission notice shall be included
-** in all copies or substantial portions of the Materials.
-**
-** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+** Copyright 2007-2020 The Khronos Group Inc.
+** SPDX-License-Identifier: Apache-2.0
 */
 
 /* Platform-specific types and definitions for egl.h
-* $Revision: 12306 $ on $Date: 2010-08-25 09:51:28 -0700 (Wed, 25 Aug 2010) $
-*
-* Adopters may modify khrplatform.h and this file to suit their platform.
-* You are encouraged to submit all modifications to the Khronos group so that
-* they can be included in future versions of this file.  Please submit changes
-* by sending them to the public Khronos Bugzilla (http://khronos.org/bugzilla)
-* by filing a bug against product "EGL" component "Registry".
-*/
+ *
+ * Adopters may modify khrplatform.h and this file to suit their platform.
+ * You are encouraged to submit all modifications to the Khronos group so that
+ * they can be included in future versions of this file.  Please submit changes
+ * by filing an issue or pull request on the public Khronos EGL Registry, at
+ * https://www.github.com/KhronosGroup/EGL-Registry/
+ */
 
 /*#include <KHR/khrplatform.h>*/
 
 /* Macros used in EGL function prototype declarations.
-*
-* EGL functions should be prototyped as:
-*
-* EGLAPI return-type EGLAPIENTRY eglFunction(arguments);
-* typedef return-type (EXPAPIENTRYP PFNEGLFUNCTIONPROC) (arguments);
-*
-* KHRONOS_APICALL and KHRONOS_APIENTRY are defined in KHR/khrplatform.h
-*/
+ *
+ * EGL functions should be prototyped as:
+ *
+ * EGLAPI return-type EGLAPIENTRY eglFunction(arguments);
+ * typedef return-type (EXPAPIENTRYP PFNEGLFUNCTIONPROC) (arguments);
+ *
+ * KHRONOS_APICALL and KHRONOS_APIENTRY are defined in KHR/khrplatform.h
+ */
 
 #ifndef EGLAPI
 #define EGLAPI KHRONOS_APICALL
@@ -375,42 +368,44 @@ typedef enum {
 #define EGLAPIENTRYP EGLAPIENTRY*
 
 /* The types NativeDisplayType, NativeWindowType, and NativePixmapType
-* are aliases of window-system-dependent types, such as X Display * or
-* Windows Device Context. They must be defined in platform-specific
-* code below. The EGL-prefixed versions of Native*Type are the same
-* types, renamed in EGL 1.3 so all types in the API start with "EGL".
-*
-* Khronos STRONGLY RECOMMENDS that you use the default definitions
-* provided below, since these changes affect both binary and source
-* portability of applications using EGL running on different EGL
-* implementations.
-*/
+ * are aliases of window-system-dependent types, such as X Display * or
+ * Windows Device Context. They must be defined in platform-specific
+ * code below. The EGL-prefixed versions of Native*Type are the same
+ * types, renamed in EGL 1.3 so all types in the API start with "EGL".
+ *
+ * Khronos STRONGLY RECOMMENDS that you use the default definitions
+ * provided below, since these changes affect both binary and source
+ * portability of applications using EGL running on different EGL
+ * implementations.
+ */
 
-#if defined(_WIN32) || defined(__VC32__) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) /* Win32 and WinCE */
+#if defined(EGL_NO_PLATFORM_SPECIFIC_TYPES)
+
+typedef void *EGLNativeDisplayType;
+typedef void *EGLNativePixmapType;
+typedef void *EGLNativeWindowType;
+
+#elif defined(_WIN32) || defined(__VC32__) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) /* Win32 and WinCE */
 #ifndef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN 1
 #endif
-#ifndef NOMINMAX   /* don't define min() and max(). */
-#define NOMINMAX
-#endif
 #include <windows.h>
 
-#if __WINRT__
-#include <Unknwn.h>
-typedef IUnknown * EGLNativeWindowType;
-typedef IUnknown * EGLNativePixmapType;
-typedef IUnknown * EGLNativeDisplayType;
-#else
 typedef HDC     EGLNativeDisplayType;
 typedef HBITMAP EGLNativePixmapType;
 typedef HWND    EGLNativeWindowType;
-#endif
+
+#elif defined(__EMSCRIPTEN__)
+
+typedef int EGLNativeDisplayType;
+typedef int EGLNativePixmapType;
+typedef int EGLNativeWindowType;
 
 #elif defined(__WINSCW__) || defined(__SYMBIAN32__)  /* Symbian */
 
 typedef int   EGLNativeDisplayType;
-typedef void *EGLNativeWindowType;
 typedef void *EGLNativePixmapType;
+typedef void *EGLNativeWindowType;
 
 #elif defined(WL_EGL_PLATFORM)
 
@@ -424,31 +419,22 @@ typedef struct gbm_device  *EGLNativeDisplayType;
 typedef struct gbm_bo      *EGLNativePixmapType;
 typedef void               *EGLNativeWindowType;
 
-#elif defined(__ANDROID__) /* Android */
+#elif defined(__ANDROID__) || defined(ANDROID)
 
 struct ANativeWindow;
 struct egl_native_pixmap_t;
 
-typedef struct ANativeWindow        *EGLNativeWindowType;
-typedef struct egl_native_pixmap_t  *EGLNativePixmapType;
-typedef void                        *EGLNativeDisplayType;
+typedef void*                           EGLNativeDisplayType;
+typedef struct egl_native_pixmap_t*     EGLNativePixmapType;
+typedef struct ANativeWindow*           EGLNativeWindowType;
 
-#elif defined(MIR_EGL_PLATFORM)
+#elif defined(USE_OZONE)
 
-#include <mir_toolkit/mir_client_library.h>
-typedef MirEGLNativeDisplayType EGLNativeDisplayType;
-typedef void                   *EGLNativePixmapType;
-typedef MirEGLNativeWindowType  EGLNativeWindowType;
+typedef intptr_t EGLNativeDisplayType;
+typedef intptr_t EGLNativePixmapType;
+typedef intptr_t EGLNativeWindowType;
 
-#elif defined(__unix__)
-
-#ifdef MESA_EGL_NO_X11_HEADERS
-
-typedef void            *EGLNativeDisplayType;
-typedef khronos_uintptr_t EGLNativePixmapType;
-typedef khronos_uintptr_t EGLNativeWindowType;
-
-#else
+#elif defined(USE_X11)
 
 /* X11 (tentative)  */
 #include <X11/Xlib.h>
@@ -458,7 +444,31 @@ typedef Display *EGLNativeDisplayType;
 typedef Pixmap   EGLNativePixmapType;
 typedef Window   EGLNativeWindowType;
 
-#endif /* MESA_EGL_NO_X11_HEADERS */
+#elif defined(__unix__)
+
+typedef void             *EGLNativeDisplayType;
+typedef khronos_uintptr_t EGLNativePixmapType;
+typedef khronos_uintptr_t EGLNativeWindowType;
+
+#elif defined(__APPLE__)
+
+typedef int   EGLNativeDisplayType;
+typedef void *EGLNativePixmapType;
+typedef void *EGLNativeWindowType;
+
+#elif defined(__HAIKU__)
+
+#include <kernel/image.h>
+
+typedef void              *EGLNativeDisplayType;
+typedef khronos_uintptr_t  EGLNativePixmapType;
+typedef khronos_uintptr_t  EGLNativeWindowType;
+
+#elif defined(__Fuchsia__)
+
+typedef void              *EGLNativeDisplayType;
+typedef khronos_uintptr_t  EGLNativePixmapType;
+typedef khronos_uintptr_t  EGLNativeWindowType;
 
 #else
 #error "Platform not recognized"
@@ -471,16 +481,25 @@ typedef EGLNativeWindowType  NativeWindowType;
 
 
 /* Define EGLint. This must be a signed integral type large enough to contain
-* all legal attribute names and values passed into and out of EGL, whether
-* their type is boolean, bitmask, enumerant (symbolic constant), integer,
-* handle, or other.  While in general a 32-bit integer will suffice, if
-* handles are 64 bit types, then EGLint should be defined as a signed 64-bit
-* integer type.
-*/
+ * all legal attribute names and values passed into and out of EGL, whether
+ * their type is boolean, bitmask, enumerant (symbolic constant), integer,
+ * handle, or other.  While in general a 32-bit integer will suffice, if
+ * handles are 64 bit types, then EGLint should be defined as a signed 64-bit
+ * integer type.
+ */
 typedef khronos_int32_t EGLint;
 
+
+/* C++ / C typecast macros for special EGL handle values */
+#if defined(__cplusplus)
+#define EGL_CAST(type, value) (static_cast<type>(value))
+#else
+#define EGL_CAST(type, value) ((type) (value))
+#endif
+
 #endif /* __eglplatform_h */
 
+
 #ifndef __egl_h_
 #define __egl_h_ 1
 
@@ -489,39 +508,24 @@ extern "C" {
 #endif
 
 /*
-** Copyright (c) 2013-2015 The Khronos Group Inc.
+** Copyright 2013-2020 The Khronos Group Inc.
+** SPDX-License-Identifier: Apache-2.0
 **
-** Permission is hereby granted, free of charge, to any person obtaining a
-** copy of this software and/or associated documentation files (the
-** "Materials"), to deal in the Materials without restriction, including
-** without limitation the rights to use, copy, modify, merge, publish,
-** distribute, sublicense, and/or sell copies of the Materials, and to
-** permit persons to whom the Materials are furnished to do so, subject to
-** the following conditions:
-**
-** The above copyright notice and this permission notice shall be included
-** in all copies or substantial portions of the Materials.
-**
-** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
-*/
-/*
-** This header is generated from the Khronos OpenGL / OpenGL ES XML
-** API Registry. The current version of the Registry, generator scripts
+** This header is generated from the Khronos EGL XML API Registry.
+** The current version of the Registry, generator scripts
 ** used to make the header, and the header can be found at
-**   http://www.opengl.org/registry/
+**   http://www.khronos.org/registry/egl
 **
-** Khronos $Revision: 31566 $ on $Date: 2015-06-23 08:48:48 -0700 (Tue, 23 Jun 2015) $
+** Khronos $Git commit SHA1: b35e89ca9a $ on $Git commit date: 2021-09-01 09:34:00 +0530 $
 */
 
 /*#include <EGL/eglplatform.h>*/
 
-/* Generated on date 20150623 */
+#ifndef EGL_EGL_PROTOTYPES
+#define EGL_EGL_PROTOTYPES 1
+#endif
+
+/* Generated on date 20210901 */
 
 /* Generated C header for:
  * API: egl
@@ -536,6 +540,8 @@ extern "C" {
 #define EGL_VERSION_1_0 1
 typedef unsigned int EGLBoolean;
 typedef void *EGLDisplay;
+/*#include <KHR/khrplatform.h>*/
+/*#include <EGL/eglplatform.h>*/
 typedef void *EGLConfig;
 typedef void *EGLSurface;
 typedef void *EGLContext;
@@ -559,7 +565,7 @@ typedef void (*__eglMustCastToProperFunctionPointerType)(void);
 #define EGL_CONFIG_ID                     0x3028
 #define EGL_CORE_NATIVE_ENGINE            0x305B
 #define EGL_DEPTH_SIZE                    0x3025
-#define EGL_DONT_CARE                     ((EGLint)-1)
+#define EGL_DONT_CARE                     EGL_CAST(EGLint,-1)
 #define EGL_DRAW                          0x3059
 #define EGL_EXTENSIONS                    0x3055
 #define EGL_FALSE                         0
@@ -576,9 +582,9 @@ typedef void (*__eglMustCastToProperFunctionPointerType)(void);
 #define EGL_NONE                          0x3038
 #define EGL_NON_CONFORMANT_CONFIG         0x3051
 #define EGL_NOT_INITIALIZED               0x3001
-#define EGL_NO_CONTEXT                    ((EGLContext)0)
-#define EGL_NO_DISPLAY                    ((EGLDisplay)0)
-#define EGL_NO_SURFACE                    ((EGLSurface)0)
+#define EGL_NO_CONTEXT                    EGL_CAST(EGLContext,0)
+#define EGL_NO_DISPLAY                    EGL_CAST(EGLDisplay,0)
+#define EGL_NO_SURFACE                    EGL_CAST(EGLSurface,0)
 #define EGL_PBUFFER_BIT                   0x0001
 #define EGL_PIXMAP_BIT                    0x0002
 #define EGL_READ                          0x305A
@@ -599,6 +605,31 @@ typedef void (*__eglMustCastToProperFunctionPointerType)(void);
 #define EGL_VERSION                       0x3054
 #define EGL_WIDTH                         0x3057
 #define EGL_WINDOW_BIT                    0x0004
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLCHOOSECONFIGPROC) (EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLCOPYBUFFERSPROC) (EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target);
+typedef EGLContext (EGLAPIENTRYP PFNEGLCREATECONTEXTPROC) (EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list);
+typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATEPBUFFERSURFACEPROC) (EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list);
+typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATEPIXMAPSURFACEPROC) (EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list);
+typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATEWINDOWSURFACEPROC) (EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYCONTEXTPROC) (EGLDisplay dpy, EGLContext ctx);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYSURFACEPROC) (EGLDisplay dpy, EGLSurface surface);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETCONFIGATTRIBPROC) (EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETCONFIGSPROC) (EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config);
+typedef EGLDisplay (EGLAPIENTRYP PFNEGLGETCURRENTDISPLAYPROC) (void);
+typedef EGLSurface (EGLAPIENTRYP PFNEGLGETCURRENTSURFACEPROC) (EGLint readdraw);
+typedef EGLDisplay (EGLAPIENTRYP PFNEGLGETDISPLAYPROC) (EGLNativeDisplayType display_id);
+typedef EGLint (EGLAPIENTRYP PFNEGLGETERRORPROC) (void);
+typedef __eglMustCastToProperFunctionPointerType (EGLAPIENTRYP PFNEGLGETPROCADDRESSPROC) (const char *procname);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLINITIALIZEPROC) (EGLDisplay dpy, EGLint *major, EGLint *minor);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLMAKECURRENTPROC) (EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYCONTEXTPROC) (EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value);
+typedef const char *(EGLAPIENTRYP PFNEGLQUERYSTRINGPROC) (EGLDisplay dpy, EGLint name);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSURFACEPROC) (EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSWAPBUFFERSPROC) (EGLDisplay dpy, EGLSurface surface);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLTERMINATEPROC) (EGLDisplay dpy);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLWAITGLPROC) (void);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLWAITNATIVEPROC) (EGLint engine);
+#if EGL_EGL_PROTOTYPES
 EGLAPI EGLBoolean EGLAPIENTRY eglChooseConfig (EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config);
 EGLAPI EGLBoolean EGLAPIENTRY eglCopyBuffers (EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target);
 EGLAPI EGLContext EGLAPIENTRY eglCreateContext (EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list);
@@ -623,6 +654,7 @@ EGLAPI EGLBoolean EGLAPIENTRY eglSwapBuffers (EGLDisplay dpy, EGLSurface surface
 EGLAPI EGLBoolean EGLAPIENTRY eglTerminate (EGLDisplay dpy);
 EGLAPI EGLBoolean EGLAPIENTRY eglWaitGL (void);
 EGLAPI EGLBoolean EGLAPIENTRY eglWaitNative (EGLint engine);
+#endif
 #endif /* EGL_VERSION_1_0 */
 
 #ifndef EGL_VERSION_1_1
@@ -641,10 +673,16 @@ EGLAPI EGLBoolean EGLAPIENTRY eglWaitNative (EGLint engine);
 #define EGL_TEXTURE_RGB                   0x305D
 #define EGL_TEXTURE_RGBA                  0x305E
 #define EGL_TEXTURE_TARGET                0x3081
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLBINDTEXIMAGEPROC) (EGLDisplay dpy, EGLSurface surface, EGLint buffer);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLRELEASETEXIMAGEPROC) (EGLDisplay dpy, EGLSurface surface, EGLint buffer);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSURFACEATTRIBPROC) (EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSWAPINTERVALPROC) (EGLDisplay dpy, EGLint interval);
+#if EGL_EGL_PROTOTYPES
 EGLAPI EGLBoolean EGLAPIENTRY eglBindTexImage (EGLDisplay dpy, EGLSurface surface, EGLint buffer);
 EGLAPI EGLBoolean EGLAPIENTRY eglReleaseTexImage (EGLDisplay dpy, EGLSurface surface, EGLint buffer);
 EGLAPI EGLBoolean EGLAPIENTRY eglSurfaceAttrib (EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value);
 EGLAPI EGLBoolean EGLAPIENTRY eglSwapInterval (EGLDisplay dpy, EGLint interval);
+#endif
 #endif /* EGL_VERSION_1_1 */
 
 #ifndef EGL_VERSION_1_2
@@ -678,13 +716,20 @@ typedef void *EGLClientBuffer;
 #define EGL_RGB_BUFFER                    0x308E
 #define EGL_SINGLE_BUFFER                 0x3085
 #define EGL_SWAP_BEHAVIOR                 0x3093
-#define EGL_UNKNOWN                       ((EGLint)-1)
+#define EGL_UNKNOWN                       EGL_CAST(EGLint,-1)
 #define EGL_VERTICAL_RESOLUTION           0x3091
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLBINDAPIPROC) (EGLenum api);
+typedef EGLenum (EGLAPIENTRYP PFNEGLQUERYAPIPROC) (void);
+typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC) (EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLRELEASETHREADPROC) (void);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLWAITCLIENTPROC) (void);
+#if EGL_EGL_PROTOTYPES
 EGLAPI EGLBoolean EGLAPIENTRY eglBindAPI (EGLenum api);
 EGLAPI EGLenum EGLAPIENTRY eglQueryAPI (void);
 EGLAPI EGLSurface EGLAPIENTRY eglCreatePbufferFromClientBuffer (EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list);
 EGLAPI EGLBoolean EGLAPIENTRY eglReleaseThread (void);
 EGLAPI EGLBoolean EGLAPIENTRY eglWaitClient (void);
+#endif
 #endif /* EGL_VERSION_1_2 */
 
 #ifndef EGL_VERSION_1_3
@@ -705,7 +750,7 @@ EGLAPI EGLBoolean EGLAPIENTRY eglWaitClient (void);
 
 #ifndef EGL_VERSION_1_4
 #define EGL_VERSION_1_4 1
-#define EGL_DEFAULT_DISPLAY               ((EGLNativeDisplayType)0)
+#define EGL_DEFAULT_DISPLAY               EGL_CAST(EGLNativeDisplayType,0)
 #define EGL_MULTISAMPLE_RESOLVE_BOX_BIT   0x0200
 #define EGL_MULTISAMPLE_RESOLVE           0x3099
 #define EGL_MULTISAMPLE_RESOLVE_DEFAULT   0x309A
@@ -713,7 +758,10 @@ EGLAPI EGLBoolean EGLAPIENTRY eglWaitClient (void);
 #define EGL_OPENGL_API                    0x30A2
 #define EGL_OPENGL_BIT                    0x0008
 #define EGL_SWAP_BEHAVIOR_PRESERVED_BIT   0x0400
+typedef EGLContext (EGLAPIENTRYP PFNEGLGETCURRENTCONTEXTPROC) (void);
+#if EGL_EGL_PROTOTYPES
 EGLAPI EGLContext EGLAPIENTRY eglGetCurrentContext (void);
+#endif
 #endif /* EGL_VERSION_1_4 */
 
 #ifndef EGL_VERSION_1_5
@@ -747,7 +795,7 @@ typedef void *EGLImage;
 #define EGL_FOREVER                       0xFFFFFFFFFFFFFFFFull
 #define EGL_TIMEOUT_EXPIRED               0x30F5
 #define EGL_CONDITION_SATISFIED           0x30F6
-#define EGL_NO_SYNC                       ((EGLSync)0)
+#define EGL_NO_SYNC                       EGL_CAST(EGLSync,0)
 #define EGL_SYNC_FENCE                    0x30F9
 #define EGL_GL_COLORSPACE                 0x309D
 #define EGL_GL_COLORSPACE_SRGB            0x3089
@@ -764,7 +812,18 @@ typedef void *EGLImage;
 #define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x30B7
 #define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x30B8
 #define EGL_IMAGE_PRESERVED               0x30D2
-#define EGL_NO_IMAGE                      ((EGLImage)0)
+#define EGL_NO_IMAGE                      EGL_CAST(EGLImage,0)
+typedef EGLSync (EGLAPIENTRYP PFNEGLCREATESYNCPROC) (EGLDisplay dpy, EGLenum type, const EGLAttrib *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYSYNCPROC) (EGLDisplay dpy, EGLSync sync);
+typedef EGLint (EGLAPIENTRYP PFNEGLCLIENTWAITSYNCPROC) (EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETSYNCATTRIBPROC) (EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib *value);
+typedef EGLImage (EGLAPIENTRYP PFNEGLCREATEIMAGEPROC) (EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLAttrib *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYIMAGEPROC) (EGLDisplay dpy, EGLImage image);
+typedef EGLDisplay (EGLAPIENTRYP PFNEGLGETPLATFORMDISPLAYPROC) (EGLenum platform, void *native_display, const EGLAttrib *attrib_list);
+typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATEPLATFORMWINDOWSURFACEPROC) (EGLDisplay dpy, EGLConfig config, void *native_window, const EGLAttrib *attrib_list);
+typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC) (EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLAttrib *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLWAITSYNCPROC) (EGLDisplay dpy, EGLSync sync, EGLint flags);
+#if EGL_EGL_PROTOTYPES
 EGLAPI EGLSync EGLAPIENTRY eglCreateSync (EGLDisplay dpy, EGLenum type, const EGLAttrib *attrib_list);
 EGLAPI EGLBoolean EGLAPIENTRY eglDestroySync (EGLDisplay dpy, EGLSync sync);
 EGLAPI EGLint EGLAPIENTRY eglClientWaitSync (EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout);
@@ -775,6 +834,7 @@ EGLAPI EGLDisplay EGLAPIENTRY eglGetPlatformDisplay (EGLenum platform, void *nat
 EGLAPI EGLSurface EGLAPIENTRY eglCreatePlatformWindowSurface (EGLDisplay dpy, EGLConfig config, void *native_window, const EGLAttrib *attrib_list);
 EGLAPI EGLSurface EGLAPIENTRY eglCreatePlatformPixmapSurface (EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLAttrib *attrib_list);
 EGLAPI EGLBoolean EGLAPIENTRY eglWaitSync (EGLDisplay dpy, EGLSync sync, EGLint flags);
+#endif
 #endif /* EGL_VERSION_1_5 */
 
 #ifdef __cplusplus
@@ -784,7 +844,6 @@ EGLAPI EGLBoolean EGLAPIENTRY eglWaitSync (EGLDisplay dpy, EGLSync sync, EGLint
 #endif /* __egl_h_ */
 
 
-
 #ifndef __eglext_h_
 #define __eglext_h_ 1
 
@@ -793,39 +852,20 @@ extern "C" {
 #endif
 
 /*
-** Copyright (c) 2013-2015 The Khronos Group Inc.
+** Copyright 2013-2020 The Khronos Group Inc.
+** SPDX-License-Identifier: Apache-2.0
 **
-** Permission is hereby granted, free of charge, to any person obtaining a
-** copy of this software and/or associated documentation files (the
-** "Materials"), to deal in the Materials without restriction, including
-** without limitation the rights to use, copy, modify, merge, publish,
-** distribute, sublicense, and/or sell copies of the Materials, and to
-** permit persons to whom the Materials are furnished to do so, subject to
-** the following conditions:
-**
-** The above copyright notice and this permission notice shall be included
-** in all copies or substantial portions of the Materials.
-**
-** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
-*/
-/*
-** This header is generated from the Khronos OpenGL / OpenGL ES XML
-** API Registry. The current version of the Registry, generator scripts
+** This header is generated from the Khronos EGL XML API Registry.
+** The current version of the Registry, generator scripts
 ** used to make the header, and the header can be found at
-**   http://www.opengl.org/registry/
+**   http://www.khronos.org/registry/egl
 **
-** Khronos $Revision: 31566 $ on $Date: 2015-06-23 08:48:48 -0700 (Tue, 23 Jun 2015) $
+** Khronos $Git commit SHA1: b35e89ca9a $ on $Git commit date: 2021-09-01 09:34:00 +0530 $
 */
 
 /*#include <EGL/eglplatform.h>*/
 
-#define EGL_EGLEXT_VERSION 20150623
+#define EGL_EGLEXT_VERSION 20210901
 
 /* Generated C header for:
  * API: egl
@@ -864,6 +904,13 @@ EGLAPI EGLSyncKHR EGLAPIENTRY eglCreateSync64KHR (EGLDisplay dpy, EGLenum type,
 #define EGL_VG_ALPHA_FORMAT_PRE_BIT_KHR   0x0040
 #endif /* EGL_KHR_config_attribs */
 
+#ifndef EGL_KHR_context_flush_control
+#define EGL_KHR_context_flush_control 1
+#define EGL_CONTEXT_RELEASE_BEHAVIOR_NONE_KHR 0
+#define EGL_CONTEXT_RELEASE_BEHAVIOR_KHR  0x2097
+#define EGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR 0x2098
+#endif /* EGL_KHR_context_flush_control */
+
 #ifndef EGL_KHR_create_context
 #define EGL_KHR_create_context 1
 #define EGL_CONTEXT_MAJOR_VERSION_KHR     0x3098
@@ -886,6 +933,42 @@ EGLAPI EGLSyncKHR EGLAPIENTRY eglCreateSync64KHR (EGLDisplay dpy, EGLenum type,
 #define EGL_CONTEXT_OPENGL_NO_ERROR_KHR   0x31B3
 #endif /* EGL_KHR_create_context_no_error */
 
+#ifndef EGL_KHR_debug
+#define EGL_KHR_debug 1
+typedef void *EGLLabelKHR;
+typedef void *EGLObjectKHR;
+typedef void (EGLAPIENTRY  *EGLDEBUGPROCKHR)(EGLenum error,const char *command,EGLint messageType,EGLLabelKHR threadLabel,EGLLabelKHR objectLabel,const char* message);
+#define EGL_OBJECT_THREAD_KHR             0x33B0
+#define EGL_OBJECT_DISPLAY_KHR            0x33B1
+#define EGL_OBJECT_CONTEXT_KHR            0x33B2
+#define EGL_OBJECT_SURFACE_KHR            0x33B3
+#define EGL_OBJECT_IMAGE_KHR              0x33B4
+#define EGL_OBJECT_SYNC_KHR               0x33B5
+#define EGL_OBJECT_STREAM_KHR             0x33B6
+#define EGL_DEBUG_MSG_CRITICAL_KHR        0x33B9
+#define EGL_DEBUG_MSG_ERROR_KHR           0x33BA
+#define EGL_DEBUG_MSG_WARN_KHR            0x33BB
+#define EGL_DEBUG_MSG_INFO_KHR            0x33BC
+#define EGL_DEBUG_CALLBACK_KHR            0x33B8
+typedef EGLint (EGLAPIENTRYP PFNEGLDEBUGMESSAGECONTROLKHRPROC) (EGLDEBUGPROCKHR callback, const EGLAttrib *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYDEBUGKHRPROC) (EGLint attribute, EGLAttrib *value);
+typedef EGLint (EGLAPIENTRYP PFNEGLLABELOBJECTKHRPROC) (EGLDisplay display, EGLenum objectType, EGLObjectKHR object, EGLLabelKHR label);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLint EGLAPIENTRY eglDebugMessageControlKHR (EGLDEBUGPROCKHR callback, const EGLAttrib *attrib_list);
+EGLAPI EGLBoolean EGLAPIENTRY eglQueryDebugKHR (EGLint attribute, EGLAttrib *value);
+EGLAPI EGLint EGLAPIENTRY eglLabelObjectKHR (EGLDisplay display, EGLenum objectType, EGLObjectKHR object, EGLLabelKHR label);
+#endif
+#endif /* EGL_KHR_debug */
+
+#ifndef EGL_KHR_display_reference
+#define EGL_KHR_display_reference 1
+#define EGL_TRACK_REFERENCES_KHR          0x3352
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYDISPLAYATTRIBKHRPROC) (EGLDisplay dpy, EGLint name, EGLAttrib *value);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglQueryDisplayAttribKHR (EGLDisplay dpy, EGLint name, EGLAttrib *value);
+#endif
+#endif /* EGL_KHR_display_reference */
+
 #ifndef EGL_KHR_fence_sync
 #define EGL_KHR_fence_sync 1
 typedef khronos_utime_nanoseconds_t EGLTimeKHR;
@@ -948,7 +1031,7 @@ EGLAPI EGLBoolean EGLAPIENTRY eglGetSyncAttribKHR (EGLDisplay dpy, EGLSyncKHR sy
 #define EGL_KHR_image 1
 typedef void *EGLImageKHR;
 #define EGL_NATIVE_PIXMAP_KHR             0x30B0
-#define EGL_NO_IMAGE_KHR                  ((EGLImageKHR)0)
+#define EGL_NO_IMAGE_KHR                  EGL_CAST(EGLImageKHR,0)
 typedef EGLImageKHR (EGLAPIENTRYP PFNEGLCREATEIMAGEKHRPROC) (EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list);
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYIMAGEKHRPROC) (EGLDisplay dpy, EGLImageKHR image);
 #ifdef EGL_EGLEXT_PROTOTYPES
@@ -1010,6 +1093,16 @@ EGLAPI EGLBoolean EGLAPIENTRY eglQuerySurface64KHR (EGLDisplay dpy, EGLSurface s
 #endif
 #endif /* EGL_KHR_lock_surface3 */
 
+#ifndef EGL_KHR_mutable_render_buffer
+#define EGL_KHR_mutable_render_buffer 1
+#define EGL_MUTABLE_RENDER_BUFFER_BIT_KHR 0x1000
+#endif /* EGL_KHR_mutable_render_buffer */
+
+#ifndef EGL_KHR_no_config_context
+#define EGL_KHR_no_config_context 1
+#define EGL_NO_CONFIG_KHR                 EGL_CAST(EGLConfig,0)
+#endif /* EGL_KHR_no_config_context */
+
 #ifndef EGL_KHR_partial_update
 #define EGL_KHR_partial_update 1
 #define EGL_BUFFER_AGE_KHR                0x313D
@@ -1052,7 +1145,7 @@ EGLAPI EGLBoolean EGLAPIENTRY eglSetDamageRegionKHR (EGLDisplay dpy, EGLSurface
 #define EGL_SYNC_REUSABLE_KHR             0x30FA
 #define EGL_SYNC_FLUSH_COMMANDS_BIT_KHR   0x0001
 #define EGL_FOREVER_KHR                   0xFFFFFFFFFFFFFFFFull
-#define EGL_NO_SYNC_KHR                   ((EGLSyncKHR)0)
+#define EGL_NO_SYNC_KHR                   EGL_CAST(EGLSyncKHR,0)
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLSIGNALSYNCKHRPROC) (EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode);
 #ifdef EGL_EGLEXT_PROTOTYPES
 EGLAPI EGLBoolean EGLAPIENTRY eglSignalSyncKHR (EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode);
@@ -1065,7 +1158,7 @@ EGLAPI EGLBoolean EGLAPIENTRY eglSignalSyncKHR (EGLDisplay dpy, EGLSyncKHR sync,
 typedef void *EGLStreamKHR;
 typedef khronos_uint64_t EGLuint64KHR;
 #ifdef KHRONOS_SUPPORT_INT64
-#define EGL_NO_STREAM_KHR                 ((EGLStreamKHR)0)
+#define EGL_NO_STREAM_KHR                 EGL_CAST(EGLStreamKHR,0)
 #define EGL_CONSUMER_LATENCY_USEC_KHR     0x3210
 #define EGL_PRODUCER_FRAME_KHR            0x3212
 #define EGL_CONSUMER_FRAME_KHR            0x3213
@@ -1093,6 +1186,24 @@ EGLAPI EGLBoolean EGLAPIENTRY eglQueryStreamu64KHR (EGLDisplay dpy, EGLStreamKHR
 #endif /* KHRONOS_SUPPORT_INT64 */
 #endif /* EGL_KHR_stream */
 
+#ifndef EGL_KHR_stream_attrib
+#define EGL_KHR_stream_attrib 1
+#ifdef KHRONOS_SUPPORT_INT64
+typedef EGLStreamKHR (EGLAPIENTRYP PFNEGLCREATESTREAMATTRIBKHRPROC) (EGLDisplay dpy, const EGLAttrib *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSETSTREAMATTRIBKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLAttrib value);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSTREAMATTRIBKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLAttrib *value);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMERACQUIREATTRIBKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMERRELEASEATTRIBKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib *attrib_list);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLStreamKHR EGLAPIENTRY eglCreateStreamAttribKHR (EGLDisplay dpy, const EGLAttrib *attrib_list);
+EGLAPI EGLBoolean EGLAPIENTRY eglSetStreamAttribKHR (EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLAttrib value);
+EGLAPI EGLBoolean EGLAPIENTRY eglQueryStreamAttribKHR (EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLAttrib *value);
+EGLAPI EGLBoolean EGLAPIENTRY eglStreamConsumerAcquireAttribKHR (EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib *attrib_list);
+EGLAPI EGLBoolean EGLAPIENTRY eglStreamConsumerReleaseAttribKHR (EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib *attrib_list);
+#endif
+#endif /* KHRONOS_SUPPORT_INT64 */
+#endif /* EGL_KHR_stream_attrib */
+
 #ifndef EGL_KHR_stream_consumer_gltexture
 #define EGL_KHR_stream_consumer_gltexture 1
 #ifdef EGL_KHR_stream
@@ -1112,7 +1223,7 @@ EGLAPI EGLBoolean EGLAPIENTRY eglStreamConsumerReleaseKHR (EGLDisplay dpy, EGLSt
 #define EGL_KHR_stream_cross_process_fd 1
 typedef int EGLNativeFileDescriptorKHR;
 #ifdef EGL_KHR_stream
-#define EGL_NO_FILE_DESCRIPTOR_KHR        ((EGLNativeFileDescriptorKHR)(-1))
+#define EGL_NO_FILE_DESCRIPTOR_KHR        EGL_CAST(EGLNativeFileDescriptorKHR,-1)
 typedef EGLNativeFileDescriptorKHR (EGLAPIENTRYP PFNEGLGETSTREAMFILEDESCRIPTORKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream);
 typedef EGLStreamKHR (EGLAPIENTRYP PFNEGLCREATESTREAMFROMFILEDESCRIPTORKHRPROC) (EGLDisplay dpy, EGLNativeFileDescriptorKHR file_descriptor);
 #ifdef EGL_EGLEXT_PROTOTYPES
@@ -1159,9 +1270,9 @@ EGLAPI EGLSurface EGLAPIENTRY eglCreateStreamProducerSurfaceKHR (EGLDisplay dpy,
 
 #ifndef EGL_KHR_swap_buffers_with_damage
 #define EGL_KHR_swap_buffers_with_damage 1
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLSWAPBUFFERSWITHDAMAGEKHRPROC) (EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSWAPBUFFERSWITHDAMAGEKHRPROC) (EGLDisplay dpy, EGLSurface surface, const EGLint *rects, EGLint n_rects);
 #ifdef EGL_EGLEXT_PROTOTYPES
-EGLAPI EGLBoolean EGLAPIENTRY eglSwapBuffersWithDamageKHR (EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects);
+EGLAPI EGLBoolean EGLAPIENTRY eglSwapBuffersWithDamageKHR (EGLDisplay dpy, EGLSurface surface, const EGLint *rects, EGLint n_rects);
 #endif
 #endif /* EGL_KHR_swap_buffers_with_damage */
 
@@ -1178,6 +1289,10 @@ EGLAPI EGLint EGLAPIENTRY eglWaitSyncKHR (EGLDisplay dpy, EGLSyncKHR sync, EGLin
 #endif
 #endif /* EGL_KHR_wait_sync */
 
+#ifndef EGL_ANDROID_GLES_layers
+#define EGL_ANDROID_GLES_layers 1
+#endif /* EGL_ANDROID_GLES_layers */
+
 #ifndef EGL_ANDROID_blob_cache
 #define EGL_ANDROID_blob_cache 1
 typedef khronos_ssize_t EGLsizeiANDROID;
@@ -1189,11 +1304,69 @@ EGLAPI void EGLAPIENTRY eglSetBlobCacheFuncsANDROID (EGLDisplay dpy, EGLSetBlobF
 #endif
 #endif /* EGL_ANDROID_blob_cache */
 
+#ifndef EGL_ANDROID_create_native_client_buffer
+#define EGL_ANDROID_create_native_client_buffer 1
+#define EGL_NATIVE_BUFFER_USAGE_ANDROID   0x3143
+#define EGL_NATIVE_BUFFER_USAGE_PROTECTED_BIT_ANDROID 0x00000001
+#define EGL_NATIVE_BUFFER_USAGE_RENDERBUFFER_BIT_ANDROID 0x00000002
+#define EGL_NATIVE_BUFFER_USAGE_TEXTURE_BIT_ANDROID 0x00000004
+typedef EGLClientBuffer (EGLAPIENTRYP PFNEGLCREATENATIVECLIENTBUFFERANDROIDPROC) (const EGLint *attrib_list);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLClientBuffer EGLAPIENTRY eglCreateNativeClientBufferANDROID (const EGLint *attrib_list);
+#endif
+#endif /* EGL_ANDROID_create_native_client_buffer */
+
 #ifndef EGL_ANDROID_framebuffer_target
 #define EGL_ANDROID_framebuffer_target 1
 #define EGL_FRAMEBUFFER_TARGET_ANDROID    0x3147
 #endif /* EGL_ANDROID_framebuffer_target */
 
+#ifndef EGL_ANDROID_front_buffer_auto_refresh
+#define EGL_ANDROID_front_buffer_auto_refresh 1
+#define EGL_FRONT_BUFFER_AUTO_REFRESH_ANDROID 0x314C
+#endif /* EGL_ANDROID_front_buffer_auto_refresh */
+
+#ifndef EGL_ANDROID_get_frame_timestamps
+#define EGL_ANDROID_get_frame_timestamps 1
+typedef khronos_stime_nanoseconds_t EGLnsecsANDROID;
+#define EGL_TIMESTAMP_PENDING_ANDROID     EGL_CAST(EGLnsecsANDROID,-2)
+#define EGL_TIMESTAMP_INVALID_ANDROID     EGL_CAST(EGLnsecsANDROID,-1)
+#define EGL_TIMESTAMPS_ANDROID            0x3430
+#define EGL_COMPOSITE_DEADLINE_ANDROID    0x3431
+#define EGL_COMPOSITE_INTERVAL_ANDROID    0x3432
+#define EGL_COMPOSITE_TO_PRESENT_LATENCY_ANDROID 0x3433
+#define EGL_REQUESTED_PRESENT_TIME_ANDROID 0x3434
+#define EGL_RENDERING_COMPLETE_TIME_ANDROID 0x3435
+#define EGL_COMPOSITION_LATCH_TIME_ANDROID 0x3436
+#define EGL_FIRST_COMPOSITION_START_TIME_ANDROID 0x3437
+#define EGL_LAST_COMPOSITION_START_TIME_ANDROID 0x3438
+#define EGL_FIRST_COMPOSITION_GPU_FINISHED_TIME_ANDROID 0x3439
+#define EGL_DISPLAY_PRESENT_TIME_ANDROID  0x343A
+#define EGL_DEQUEUE_READY_TIME_ANDROID    0x343B
+#define EGL_READS_DONE_TIME_ANDROID       0x343C
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETCOMPOSITORTIMINGSUPPORTEDANDROIDPROC) (EGLDisplay dpy, EGLSurface surface, EGLint name);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETCOMPOSITORTIMINGANDROIDPROC) (EGLDisplay dpy, EGLSurface surface, EGLint numTimestamps,  const EGLint *names, EGLnsecsANDROID *values);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETNEXTFRAMEIDANDROIDPROC) (EGLDisplay dpy, EGLSurface surface, EGLuint64KHR *frameId);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETFRAMETIMESTAMPSUPPORTEDANDROIDPROC) (EGLDisplay dpy, EGLSurface surface, EGLint timestamp);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETFRAMETIMESTAMPSANDROIDPROC) (EGLDisplay dpy, EGLSurface surface, EGLuint64KHR frameId, EGLint numTimestamps,  const EGLint *timestamps, EGLnsecsANDROID *values);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglGetCompositorTimingSupportedANDROID (EGLDisplay dpy, EGLSurface surface, EGLint name);
+EGLAPI EGLBoolean EGLAPIENTRY eglGetCompositorTimingANDROID (EGLDisplay dpy, EGLSurface surface, EGLint numTimestamps,  const EGLint *names, EGLnsecsANDROID *values);
+EGLAPI EGLBoolean EGLAPIENTRY eglGetNextFrameIdANDROID (EGLDisplay dpy, EGLSurface surface, EGLuint64KHR *frameId);
+EGLAPI EGLBoolean EGLAPIENTRY eglGetFrameTimestampSupportedANDROID (EGLDisplay dpy, EGLSurface surface, EGLint timestamp);
+EGLAPI EGLBoolean EGLAPIENTRY eglGetFrameTimestampsANDROID (EGLDisplay dpy, EGLSurface surface, EGLuint64KHR frameId, EGLint numTimestamps,  const EGLint *timestamps, EGLnsecsANDROID *values);
+#endif
+#endif /* EGL_ANDROID_get_frame_timestamps */
+
+#ifndef EGL_ANDROID_get_native_client_buffer
+#define EGL_ANDROID_get_native_client_buffer 1
+struct AHardwareBuffer;
+typedef EGLClientBuffer (EGLAPIENTRYP PFNEGLGETNATIVECLIENTBUFFERANDROIDPROC) (const struct AHardwareBuffer *buffer);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLClientBuffer EGLAPIENTRY eglGetNativeClientBufferANDROID (const struct AHardwareBuffer *buffer);
+#endif
+#endif /* EGL_ANDROID_get_native_client_buffer */
+
 #ifndef EGL_ANDROID_image_native_buffer
 #define EGL_ANDROID_image_native_buffer 1
 #define EGL_NATIVE_BUFFER_ANDROID         0x3140
@@ -1211,6 +1384,14 @@ EGLAPI EGLint EGLAPIENTRY eglDupNativeFenceFDANDROID (EGLDisplay dpy, EGLSyncKHR
 #endif
 #endif /* EGL_ANDROID_native_fence_sync */
 
+#ifndef EGL_ANDROID_presentation_time
+#define EGL_ANDROID_presentation_time 1
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLPRESENTATIONTIMEANDROIDPROC) (EGLDisplay dpy, EGLSurface surface, EGLnsecsANDROID time);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglPresentationTimeANDROID (EGLDisplay dpy, EGLSurface surface, EGLnsecsANDROID time);
+#endif
+#endif /* EGL_ANDROID_presentation_time */
+
 #ifndef EGL_ANDROID_recordable
 #define EGL_ANDROID_recordable 1
 #define EGL_RECORDABLE_ANDROID            0x3142
@@ -1239,16 +1420,40 @@ EGLAPI EGLBoolean EGLAPIENTRY eglQuerySurfacePointerANGLE (EGLDisplay dpy, EGLSu
 #define EGL_ANGLE_surface_d3d_texture_2d_share_handle 1
 #endif /* EGL_ANGLE_surface_d3d_texture_2d_share_handle */
 
+#ifndef EGL_ANGLE_sync_control_rate
+#define EGL_ANGLE_sync_control_rate 1
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETMSCRATEANGLEPROC) (EGLDisplay dpy, EGLSurface surface, EGLint *numerator, EGLint *denominator);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglGetMscRateANGLE (EGLDisplay dpy, EGLSurface surface, EGLint *numerator, EGLint *denominator);
+#endif
+#endif /* EGL_ANGLE_sync_control_rate */
+
 #ifndef EGL_ANGLE_window_fixed_size
 #define EGL_ANGLE_window_fixed_size 1
 #define EGL_FIXED_SIZE_ANGLE              0x3201
 #endif /* EGL_ANGLE_window_fixed_size */
 
+#ifndef EGL_ARM_image_format
+#define EGL_ARM_image_format 1
+#define EGL_COLOR_COMPONENT_TYPE_UNSIGNED_INTEGER_ARM 0x3287
+#define EGL_COLOR_COMPONENT_TYPE_INTEGER_ARM 0x3288
+#endif /* EGL_ARM_image_format */
+
+#ifndef EGL_ARM_implicit_external_sync
+#define EGL_ARM_implicit_external_sync 1
+#define EGL_SYNC_PRIOR_COMMANDS_IMPLICIT_EXTERNAL_ARM 0x328A
+#endif /* EGL_ARM_implicit_external_sync */
+
 #ifndef EGL_ARM_pixmap_multisample_discard
 #define EGL_ARM_pixmap_multisample_discard 1
 #define EGL_DISCARD_SAMPLES_ARM           0x3286
 #endif /* EGL_ARM_pixmap_multisample_discard */
 
+#ifndef EGL_EXT_bind_to_front
+#define EGL_EXT_bind_to_front 1
+#define EGL_FRONT_BUFFER_EXT              0x3464
+#endif /* EGL_EXT_bind_to_front */
+
 #ifndef EGL_EXT_buffer_age
 #define EGL_EXT_buffer_age 1
 #define EGL_BUFFER_AGE_EXT                0x313D
@@ -1258,6 +1463,45 @@ EGLAPI EGLBoolean EGLAPIENTRY eglQuerySurfacePointerANGLE (EGLDisplay dpy, EGLSu
 #define EGL_EXT_client_extensions 1
 #endif /* EGL_EXT_client_extensions */
 
+#ifndef EGL_EXT_client_sync
+#define EGL_EXT_client_sync 1
+#define EGL_SYNC_CLIENT_EXT               0x3364
+#define EGL_SYNC_CLIENT_SIGNAL_EXT        0x3365
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLCLIENTSIGNALSYNCEXTPROC) (EGLDisplay dpy, EGLSync sync, const EGLAttrib *attrib_list);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglClientSignalSyncEXT (EGLDisplay dpy, EGLSync sync, const EGLAttrib *attrib_list);
+#endif
+#endif /* EGL_EXT_client_sync */
+
+#ifndef EGL_EXT_compositor
+#define EGL_EXT_compositor 1
+#define EGL_PRIMARY_COMPOSITOR_CONTEXT_EXT 0x3460
+#define EGL_EXTERNAL_REF_ID_EXT           0x3461
+#define EGL_COMPOSITOR_DROP_NEWEST_FRAME_EXT 0x3462
+#define EGL_COMPOSITOR_KEEP_NEWEST_FRAME_EXT 0x3463
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLCOMPOSITORSETCONTEXTLISTEXTPROC) (const EGLint *external_ref_ids, EGLint num_entries);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLCOMPOSITORSETCONTEXTATTRIBUTESEXTPROC) (EGLint external_ref_id, const EGLint *context_attributes, EGLint num_entries);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLCOMPOSITORSETWINDOWLISTEXTPROC) (EGLint external_ref_id, const EGLint *external_win_ids, EGLint num_entries);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLCOMPOSITORSETWINDOWATTRIBUTESEXTPROC) (EGLint external_win_id, const EGLint *window_attributes, EGLint num_entries);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLCOMPOSITORBINDTEXWINDOWEXTPROC) (EGLint external_win_id);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLCOMPOSITORSETSIZEEXTPROC) (EGLint external_win_id, EGLint width, EGLint height);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLCOMPOSITORSWAPPOLICYEXTPROC) (EGLint external_win_id, EGLint policy);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglCompositorSetContextListEXT (const EGLint *external_ref_ids, EGLint num_entries);
+EGLAPI EGLBoolean EGLAPIENTRY eglCompositorSetContextAttributesEXT (EGLint external_ref_id, const EGLint *context_attributes, EGLint num_entries);
+EGLAPI EGLBoolean EGLAPIENTRY eglCompositorSetWindowListEXT (EGLint external_ref_id, const EGLint *external_win_ids, EGLint num_entries);
+EGLAPI EGLBoolean EGLAPIENTRY eglCompositorSetWindowAttributesEXT (EGLint external_win_id, const EGLint *window_attributes, EGLint num_entries);
+EGLAPI EGLBoolean EGLAPIENTRY eglCompositorBindTexWindowEXT (EGLint external_win_id);
+EGLAPI EGLBoolean EGLAPIENTRY eglCompositorSetSizeEXT (EGLint external_win_id, EGLint width, EGLint height);
+EGLAPI EGLBoolean EGLAPIENTRY eglCompositorSwapPolicyEXT (EGLint external_win_id, EGLint policy);
+#endif
+#endif /* EGL_EXT_compositor */
+
+#ifndef EGL_EXT_config_select_group
+#define EGL_EXT_config_select_group 1
+#define EGL_CONFIG_SELECT_GROUP_EXT       0x34C0
+#endif /* EGL_EXT_config_select_group */
+
 #ifndef EGL_EXT_create_context_robustness
 #define EGL_EXT_create_context_robustness 1
 #define EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT 0x30BF
@@ -1269,7 +1513,7 @@ EGLAPI EGLBoolean EGLAPIENTRY eglQuerySurfacePointerANGLE (EGLDisplay dpy, EGLSu
 #ifndef EGL_EXT_device_base
 #define EGL_EXT_device_base 1
 typedef void *EGLDeviceEXT;
-#define EGL_NO_DEVICE_EXT                 ((EGLDeviceEXT)(0))
+#define EGL_NO_DEVICE_EXT                 EGL_CAST(EGLDeviceEXT,0)
 #define EGL_BAD_DEVICE_EXT                0x322B
 #define EGL_DEVICE_EXT                    0x322C
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYDEVICEATTRIBEXTPROC) (EGLDeviceEXT device, EGLint attribute, EGLAttrib *value);
@@ -1287,8 +1531,14 @@ EGLAPI EGLBoolean EGLAPIENTRY eglQueryDisplayAttribEXT (EGLDisplay dpy, EGLint a
 #ifndef EGL_EXT_device_drm
 #define EGL_EXT_device_drm 1
 #define EGL_DRM_DEVICE_FILE_EXT           0x3233
+#define EGL_DRM_MASTER_FD_EXT             0x333C
 #endif /* EGL_EXT_device_drm */
 
+#ifndef EGL_EXT_device_drm_render_node
+#define EGL_EXT_device_drm_render_node 1
+#define EGL_DRM_RENDER_NODE_FILE_EXT      0x3377
+#endif /* EGL_EXT_device_drm_render_node */
+
 #ifndef EGL_EXT_device_enumeration
 #define EGL_EXT_device_enumeration 1
 #endif /* EGL_EXT_device_enumeration */
@@ -1296,12 +1546,64 @@ EGLAPI EGLBoolean EGLAPIENTRY eglQueryDisplayAttribEXT (EGLDisplay dpy, EGLint a
 #ifndef EGL_EXT_device_openwf
 #define EGL_EXT_device_openwf 1
 #define EGL_OPENWF_DEVICE_ID_EXT          0x3237
+#define EGL_OPENWF_DEVICE_EXT             0x333D
 #endif /* EGL_EXT_device_openwf */
 
+#ifndef EGL_EXT_device_persistent_id
+#define EGL_EXT_device_persistent_id 1
+#define EGL_DEVICE_UUID_EXT               0x335C
+#define EGL_DRIVER_UUID_EXT               0x335D
+#define EGL_DRIVER_NAME_EXT               0x335E
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYDEVICEBINARYEXTPROC) (EGLDeviceEXT device, EGLint name, EGLint max_size, void *value, EGLint *size);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglQueryDeviceBinaryEXT (EGLDeviceEXT device, EGLint name, EGLint max_size, void *value, EGLint *size);
+#endif
+#endif /* EGL_EXT_device_persistent_id */
+
 #ifndef EGL_EXT_device_query
 #define EGL_EXT_device_query 1
 #endif /* EGL_EXT_device_query */
 
+#ifndef EGL_EXT_device_query_name
+#define EGL_EXT_device_query_name 1
+#define EGL_RENDERER_EXT                  0x335F
+#endif /* EGL_EXT_device_query_name */
+
+#ifndef EGL_EXT_gl_colorspace_bt2020_linear
+#define EGL_EXT_gl_colorspace_bt2020_linear 1
+#define EGL_GL_COLORSPACE_BT2020_LINEAR_EXT 0x333F
+#endif /* EGL_EXT_gl_colorspace_bt2020_linear */
+
+#ifndef EGL_EXT_gl_colorspace_bt2020_pq
+#define EGL_EXT_gl_colorspace_bt2020_pq 1
+#define EGL_GL_COLORSPACE_BT2020_PQ_EXT   0x3340
+#endif /* EGL_EXT_gl_colorspace_bt2020_pq */
+
+#ifndef EGL_EXT_gl_colorspace_display_p3
+#define EGL_EXT_gl_colorspace_display_p3 1
+#define EGL_GL_COLORSPACE_DISPLAY_P3_EXT  0x3363
+#endif /* EGL_EXT_gl_colorspace_display_p3 */
+
+#ifndef EGL_EXT_gl_colorspace_display_p3_linear
+#define EGL_EXT_gl_colorspace_display_p3_linear 1
+#define EGL_GL_COLORSPACE_DISPLAY_P3_LINEAR_EXT 0x3362
+#endif /* EGL_EXT_gl_colorspace_display_p3_linear */
+
+#ifndef EGL_EXT_gl_colorspace_display_p3_passthrough
+#define EGL_EXT_gl_colorspace_display_p3_passthrough 1
+#define EGL_GL_COLORSPACE_DISPLAY_P3_PASSTHROUGH_EXT 0x3490
+#endif /* EGL_EXT_gl_colorspace_display_p3_passthrough */
+
+#ifndef EGL_EXT_gl_colorspace_scrgb
+#define EGL_EXT_gl_colorspace_scrgb 1
+#define EGL_GL_COLORSPACE_SCRGB_EXT       0x3351
+#endif /* EGL_EXT_gl_colorspace_scrgb */
+
+#ifndef EGL_EXT_gl_colorspace_scrgb_linear
+#define EGL_EXT_gl_colorspace_scrgb_linear 1
+#define EGL_GL_COLORSPACE_SCRGB_LINEAR_EXT 0x3350
+#endif /* EGL_EXT_gl_colorspace_scrgb_linear */
+
 #ifndef EGL_EXT_image_dma_buf_import
 #define EGL_EXT_image_dma_buf_import 1
 #define EGL_LINUX_DMA_BUF_EXT             0x3270
@@ -1328,6 +1630,39 @@ EGLAPI EGLBoolean EGLAPIENTRY eglQueryDisplayAttribEXT (EGLDisplay dpy, EGLint a
 #define EGL_YUV_CHROMA_SITING_0_5_EXT     0x3285
 #endif /* EGL_EXT_image_dma_buf_import */
 
+#ifndef EGL_EXT_image_dma_buf_import_modifiers
+#define EGL_EXT_image_dma_buf_import_modifiers 1
+#define EGL_DMA_BUF_PLANE3_FD_EXT         0x3440
+#define EGL_DMA_BUF_PLANE3_OFFSET_EXT     0x3441
+#define EGL_DMA_BUF_PLANE3_PITCH_EXT      0x3442
+#define EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT 0x3443
+#define EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT 0x3444
+#define EGL_DMA_BUF_PLANE1_MODIFIER_LO_EXT 0x3445
+#define EGL_DMA_BUF_PLANE1_MODIFIER_HI_EXT 0x3446
+#define EGL_DMA_BUF_PLANE2_MODIFIER_LO_EXT 0x3447
+#define EGL_DMA_BUF_PLANE2_MODIFIER_HI_EXT 0x3448
+#define EGL_DMA_BUF_PLANE3_MODIFIER_LO_EXT 0x3449
+#define EGL_DMA_BUF_PLANE3_MODIFIER_HI_EXT 0x344A
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYDMABUFFORMATSEXTPROC) (EGLDisplay dpy, EGLint max_formats, EGLint *formats, EGLint *num_formats);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYDMABUFMODIFIERSEXTPROC) (EGLDisplay dpy, EGLint format, EGLint max_modifiers, EGLuint64KHR *modifiers, EGLBoolean *external_only, EGLint *num_modifiers);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglQueryDmaBufFormatsEXT (EGLDisplay dpy, EGLint max_formats, EGLint *formats, EGLint *num_formats);
+EGLAPI EGLBoolean EGLAPIENTRY eglQueryDmaBufModifiersEXT (EGLDisplay dpy, EGLint format, EGLint max_modifiers, EGLuint64KHR *modifiers, EGLBoolean *external_only, EGLint *num_modifiers);
+#endif
+#endif /* EGL_EXT_image_dma_buf_import_modifiers */
+
+#ifndef EGL_EXT_image_gl_colorspace
+#define EGL_EXT_image_gl_colorspace 1
+#define EGL_GL_COLORSPACE_DEFAULT_EXT     0x314D
+#endif /* EGL_EXT_image_gl_colorspace */
+
+#ifndef EGL_EXT_image_implicit_sync_control
+#define EGL_EXT_image_implicit_sync_control 1
+#define EGL_IMPORT_SYNC_TYPE_EXT          0x3470
+#define EGL_IMPORT_IMPLICIT_SYNC_EXT      0x3471
+#define EGL_IMPORT_EXPLICIT_SYNC_EXT      0x3472
+#endif /* EGL_EXT_image_implicit_sync_control */
+
 #ifndef EGL_EXT_multiview_window
 #define EGL_EXT_multiview_window 1
 #define EGL_MULTIVIEW_VIEW_COUNT_EXT      0x3134
@@ -1337,8 +1672,8 @@ EGLAPI EGLBoolean EGLAPIENTRY eglQueryDisplayAttribEXT (EGLDisplay dpy, EGLint a
 #define EGL_EXT_output_base 1
 typedef void *EGLOutputLayerEXT;
 typedef void *EGLOutputPortEXT;
-#define EGL_NO_OUTPUT_LAYER_EXT           ((EGLOutputLayerEXT)0)
-#define EGL_NO_OUTPUT_PORT_EXT            ((EGLOutputPortEXT)0)
+#define EGL_NO_OUTPUT_LAYER_EXT           EGL_CAST(EGLOutputLayerEXT,0)
+#define EGL_NO_OUTPUT_PORT_EXT            EGL_CAST(EGLOutputPortEXT,0)
 #define EGL_BAD_OUTPUT_LAYER_EXT          0x322D
 #define EGL_BAD_OUTPUT_PORT_EXT           0x322E
 #define EGL_SWAP_INTERVAL_EXT             0x322F
@@ -1375,6 +1710,13 @@ EGLAPI const char *EGLAPIENTRY eglQueryOutputPortStringEXT (EGLDisplay dpy, EGLO
 #define EGL_OPENWF_PORT_ID_EXT            0x3239
 #endif /* EGL_EXT_output_openwf */
 
+#ifndef EGL_EXT_pixel_format_float
+#define EGL_EXT_pixel_format_float 1
+#define EGL_COLOR_COMPONENT_TYPE_EXT      0x3339
+#define EGL_COLOR_COMPONENT_TYPE_FIXED_EXT 0x333A
+#define EGL_COLOR_COMPONENT_TYPE_FLOAT_EXT 0x333B
+#endif /* EGL_EXT_pixel_format_float */
+
 #ifndef EGL_EXT_platform_base
 #define EGL_EXT_platform_base 1
 typedef EGLDisplay (EGLAPIENTRYP PFNEGLGETPLATFORMDISPLAYEXTPROC) (EGLenum platform, void *native_display, const EGLint *attrib_list);
@@ -1403,9 +1745,24 @@ EGLAPI EGLSurface EGLAPIENTRY eglCreatePlatformPixmapSurfaceEXT (EGLDisplay dpy,
 #define EGL_PLATFORM_X11_SCREEN_EXT       0x31D6
 #endif /* EGL_EXT_platform_x11 */
 
+#ifndef EGL_EXT_platform_xcb
+#define EGL_EXT_platform_xcb 1
+#define EGL_PLATFORM_XCB_EXT              0x31DC
+#define EGL_PLATFORM_XCB_SCREEN_EXT       0x31DE
+#endif /* EGL_EXT_platform_xcb */
+
+#ifndef EGL_EXT_present_opaque
+#define EGL_EXT_present_opaque 1
+#define EGL_PRESENT_OPAQUE_EXT            0x31DF
+#endif /* EGL_EXT_present_opaque */
+
+#ifndef EGL_EXT_protected_content
+#define EGL_EXT_protected_content 1
+#define EGL_PROTECTED_CONTENT_EXT         0x32C0
+#endif /* EGL_EXT_protected_content */
+
 #ifndef EGL_EXT_protected_surface
 #define EGL_EXT_protected_surface 1
-#define EGL_PROTECTED_CONTENT_EXT         0x32C0
 #endif /* EGL_EXT_protected_surface */
 
 #ifndef EGL_EXT_stream_consumer_egloutput
@@ -1416,14 +1773,43 @@ EGLAPI EGLBoolean EGLAPIENTRY eglStreamConsumerOutputEXT (EGLDisplay dpy, EGLStr
 #endif
 #endif /* EGL_EXT_stream_consumer_egloutput */
 
+#ifndef EGL_EXT_surface_CTA861_3_metadata
+#define EGL_EXT_surface_CTA861_3_metadata 1
+#define EGL_CTA861_3_MAX_CONTENT_LIGHT_LEVEL_EXT 0x3360
+#define EGL_CTA861_3_MAX_FRAME_AVERAGE_LEVEL_EXT 0x3361
+#endif /* EGL_EXT_surface_CTA861_3_metadata */
+
+#ifndef EGL_EXT_surface_SMPTE2086_metadata
+#define EGL_EXT_surface_SMPTE2086_metadata 1
+#define EGL_SMPTE2086_DISPLAY_PRIMARY_RX_EXT 0x3341
+#define EGL_SMPTE2086_DISPLAY_PRIMARY_RY_EXT 0x3342
+#define EGL_SMPTE2086_DISPLAY_PRIMARY_GX_EXT 0x3343
+#define EGL_SMPTE2086_DISPLAY_PRIMARY_GY_EXT 0x3344
+#define EGL_SMPTE2086_DISPLAY_PRIMARY_BX_EXT 0x3345
+#define EGL_SMPTE2086_DISPLAY_PRIMARY_BY_EXT 0x3346
+#define EGL_SMPTE2086_WHITE_POINT_X_EXT   0x3347
+#define EGL_SMPTE2086_WHITE_POINT_Y_EXT   0x3348
+#define EGL_SMPTE2086_MAX_LUMINANCE_EXT   0x3349
+#define EGL_SMPTE2086_MIN_LUMINANCE_EXT   0x334A
+#define EGL_METADATA_SCALING_EXT          50000
+#endif /* EGL_EXT_surface_SMPTE2086_metadata */
+
 #ifndef EGL_EXT_swap_buffers_with_damage
 #define EGL_EXT_swap_buffers_with_damage 1
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC) (EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC) (EGLDisplay dpy, EGLSurface surface, const EGLint *rects, EGLint n_rects);
 #ifdef EGL_EGLEXT_PROTOTYPES
-EGLAPI EGLBoolean EGLAPIENTRY eglSwapBuffersWithDamageEXT (EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects);
+EGLAPI EGLBoolean EGLAPIENTRY eglSwapBuffersWithDamageEXT (EGLDisplay dpy, EGLSurface surface, const EGLint *rects, EGLint n_rects);
 #endif
 #endif /* EGL_EXT_swap_buffers_with_damage */
 
+#ifndef EGL_EXT_sync_reuse
+#define EGL_EXT_sync_reuse 1
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLUNSIGNALSYNCEXTPROC) (EGLDisplay dpy, EGLSync sync, const EGLAttrib *attrib_list);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglUnsignalSyncEXT (EGLDisplay dpy, EGLSync sync, const EGLAttrib *attrib_list);
+#endif
+#endif /* EGL_EXT_sync_reuse */
+
 #ifndef EGL_EXT_yuv_surface
 #define EGL_EXT_yuv_surface 1
 #define EGL_YUV_ORDER_EXT                 0x3301
@@ -1484,6 +1870,12 @@ EGLAPI EGLSurface EGLAPIENTRY eglCreatePixmapSurfaceHI (EGLDisplay dpy, EGLConfi
 #define EGL_CONTEXT_PRIORITY_LOW_IMG      0x3103
 #endif /* EGL_IMG_context_priority */
 
+#ifndef EGL_IMG_image_plane_attribs
+#define EGL_IMG_image_plane_attribs 1
+#define EGL_NATIVE_BUFFER_MULTIPLANE_SEPARATE_IMG 0x3105
+#define EGL_NATIVE_BUFFER_PLANE_OFFSET_IMG 0x3106
+#endif /* EGL_IMG_image_plane_attribs */
+
 #ifndef EGL_MESA_drm_image
 #define EGL_MESA_drm_image 1
 #define EGL_DRM_BUFFER_FORMAT_MESA        0x31D0
@@ -1493,6 +1885,7 @@ EGLAPI EGLSurface EGLAPIENTRY eglCreatePixmapSurfaceHI (EGLDisplay dpy, EGLConfi
 #define EGL_DRM_BUFFER_STRIDE_MESA        0x31D4
 #define EGL_DRM_BUFFER_USE_SCANOUT_MESA   0x00000001
 #define EGL_DRM_BUFFER_USE_SHARE_MESA     0x00000002
+#define EGL_DRM_BUFFER_USE_CURSOR_MESA    0x00000004
 typedef EGLImageKHR (EGLAPIENTRYP PFNEGLCREATEDRMIMAGEMESAPROC) (EGLDisplay dpy, const EGLint *attrib_list);
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLEXPORTDRMIMAGEMESAPROC) (EGLDisplay dpy, EGLImageKHR image, EGLint *name, EGLint *handle, EGLint *stride);
 #ifdef EGL_EGLEXT_PROTOTYPES
@@ -1516,6 +1909,21 @@ EGLAPI EGLBoolean EGLAPIENTRY eglExportDMABUFImageMESA (EGLDisplay dpy, EGLImage
 #define EGL_PLATFORM_GBM_MESA             0x31D7
 #endif /* EGL_MESA_platform_gbm */
 
+#ifndef EGL_MESA_platform_surfaceless
+#define EGL_MESA_platform_surfaceless 1
+#define EGL_PLATFORM_SURFACELESS_MESA     0x31DD
+#endif /* EGL_MESA_platform_surfaceless */
+
+#ifndef EGL_MESA_query_driver
+#define EGL_MESA_query_driver 1
+typedef char *(EGLAPIENTRYP PFNEGLGETDISPLAYDRIVERCONFIGPROC) (EGLDisplay dpy);
+typedef const char *(EGLAPIENTRYP PFNEGLGETDISPLAYDRIVERNAMEPROC) (EGLDisplay dpy);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI char *EGLAPIENTRY eglGetDisplayDriverConfig (EGLDisplay dpy);
+EGLAPI const char *EGLAPIENTRY eglGetDisplayDriverName (EGLDisplay dpy);
+#endif
+#endif /* EGL_MESA_query_driver */
+
 #ifndef EGL_NOK_swap_region
 #define EGL_NOK_swap_region 1
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLSWAPBUFFERSREGIONNOKPROC) (EGLDisplay dpy, EGLSurface surface, EGLint numRects, const EGLint *rects);
@@ -1542,6 +1950,11 @@ EGLAPI EGLBoolean EGLAPIENTRY eglSwapBuffersRegion2NOK (EGLDisplay dpy, EGLSurfa
 #define EGL_AUTO_STEREO_NV                0x3136
 #endif /* EGL_NV_3dvision_surface */
 
+#ifndef EGL_NV_context_priority_realtime
+#define EGL_NV_context_priority_realtime 1
+#define EGL_CONTEXT_PRIORITY_REALTIME_NV  0x3357
+#endif /* EGL_NV_context_priority_realtime */
+
 #ifndef EGL_NV_coverage_sample
 #define EGL_NV_coverage_sample 1
 #define EGL_COVERAGE_BUFFERS_NV           0x30E0
@@ -1599,6 +2012,181 @@ EGLAPI EGLBoolean EGLAPIENTRY eglPostSubBufferNV (EGLDisplay dpy, EGLSurface sur
 #endif
 #endif /* EGL_NV_post_sub_buffer */
 
+#ifndef EGL_NV_quadruple_buffer
+#define EGL_NV_quadruple_buffer 1
+#define EGL_QUADRUPLE_BUFFER_NV           0x3231
+#endif /* EGL_NV_quadruple_buffer */
+
+#ifndef EGL_NV_robustness_video_memory_purge
+#define EGL_NV_robustness_video_memory_purge 1
+#define EGL_GENERATE_RESET_ON_VIDEO_MEMORY_PURGE_NV 0x334C
+#endif /* EGL_NV_robustness_video_memory_purge */
+
+#ifndef EGL_NV_stream_consumer_eglimage
+#define EGL_NV_stream_consumer_eglimage 1
+#define EGL_STREAM_CONSUMER_IMAGE_NV      0x3373
+#define EGL_STREAM_IMAGE_ADD_NV           0x3374
+#define EGL_STREAM_IMAGE_REMOVE_NV        0x3375
+#define EGL_STREAM_IMAGE_AVAILABLE_NV     0x3376
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMIMAGECONSUMERCONNECTNVPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLint num_modifiers, EGLuint64KHR *modifiers, EGLAttrib *attrib_list);
+typedef EGLint (EGLAPIENTRYP PFNEGLQUERYSTREAMCONSUMEREVENTNVPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLTime timeout, EGLenum *event, EGLAttrib *aux);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMACQUIREIMAGENVPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLImage *pImage, EGLSync sync);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMRELEASEIMAGENVPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLImage image, EGLSync sync);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglStreamImageConsumerConnectNV (EGLDisplay dpy, EGLStreamKHR stream, EGLint num_modifiers, EGLuint64KHR *modifiers, EGLAttrib *attrib_list);
+EGLAPI EGLint EGLAPIENTRY eglQueryStreamConsumerEventNV (EGLDisplay dpy, EGLStreamKHR stream, EGLTime timeout, EGLenum *event, EGLAttrib *aux);
+EGLAPI EGLBoolean EGLAPIENTRY eglStreamAcquireImageNV (EGLDisplay dpy, EGLStreamKHR stream, EGLImage *pImage, EGLSync sync);
+EGLAPI EGLBoolean EGLAPIENTRY eglStreamReleaseImageNV (EGLDisplay dpy, EGLStreamKHR stream, EGLImage image, EGLSync sync);
+#endif
+#endif /* EGL_NV_stream_consumer_eglimage */
+
+#ifndef EGL_NV_stream_consumer_gltexture_yuv
+#define EGL_NV_stream_consumer_gltexture_yuv 1
+#define EGL_YUV_PLANE0_TEXTURE_UNIT_NV    0x332C
+#define EGL_YUV_PLANE1_TEXTURE_UNIT_NV    0x332D
+#define EGL_YUV_PLANE2_TEXTURE_UNIT_NV    0x332E
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALATTRIBSNVPROC) (EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib *attrib_list);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglStreamConsumerGLTextureExternalAttribsNV (EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib *attrib_list);
+#endif
+#endif /* EGL_NV_stream_consumer_gltexture_yuv */
+
+#ifndef EGL_NV_stream_cross_display
+#define EGL_NV_stream_cross_display 1
+#define EGL_STREAM_CROSS_DISPLAY_NV       0x334E
+#endif /* EGL_NV_stream_cross_display */
+
+#ifndef EGL_NV_stream_cross_object
+#define EGL_NV_stream_cross_object 1
+#define EGL_STREAM_CROSS_OBJECT_NV        0x334D
+#endif /* EGL_NV_stream_cross_object */
+
+#ifndef EGL_NV_stream_cross_partition
+#define EGL_NV_stream_cross_partition 1
+#define EGL_STREAM_CROSS_PARTITION_NV     0x323F
+#endif /* EGL_NV_stream_cross_partition */
+
+#ifndef EGL_NV_stream_cross_process
+#define EGL_NV_stream_cross_process 1
+#define EGL_STREAM_CROSS_PROCESS_NV       0x3245
+#endif /* EGL_NV_stream_cross_process */
+
+#ifndef EGL_NV_stream_cross_system
+#define EGL_NV_stream_cross_system 1
+#define EGL_STREAM_CROSS_SYSTEM_NV        0x334F
+#endif /* EGL_NV_stream_cross_system */
+
+#ifndef EGL_NV_stream_dma
+#define EGL_NV_stream_dma 1
+#define EGL_STREAM_DMA_NV                 0x3371
+#define EGL_STREAM_DMA_SERVER_NV          0x3372
+#endif /* EGL_NV_stream_dma */
+
+#ifndef EGL_NV_stream_fifo_next
+#define EGL_NV_stream_fifo_next 1
+#define EGL_PENDING_FRAME_NV              0x3329
+#define EGL_STREAM_TIME_PENDING_NV        0x332A
+#endif /* EGL_NV_stream_fifo_next */
+
+#ifndef EGL_NV_stream_fifo_synchronous
+#define EGL_NV_stream_fifo_synchronous 1
+#define EGL_STREAM_FIFO_SYNCHRONOUS_NV    0x3336
+#endif /* EGL_NV_stream_fifo_synchronous */
+
+#ifndef EGL_NV_stream_flush
+#define EGL_NV_stream_flush 1
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMFLUSHNVPROC) (EGLDisplay dpy, EGLStreamKHR stream);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglStreamFlushNV (EGLDisplay dpy, EGLStreamKHR stream);
+#endif
+#endif /* EGL_NV_stream_flush */
+
+#ifndef EGL_NV_stream_frame_limits
+#define EGL_NV_stream_frame_limits 1
+#define EGL_PRODUCER_MAX_FRAME_HINT_NV    0x3337
+#define EGL_CONSUMER_MAX_FRAME_HINT_NV    0x3338
+#endif /* EGL_NV_stream_frame_limits */
+
+#ifndef EGL_NV_stream_metadata
+#define EGL_NV_stream_metadata 1
+#define EGL_MAX_STREAM_METADATA_BLOCKS_NV 0x3250
+#define EGL_MAX_STREAM_METADATA_BLOCK_SIZE_NV 0x3251
+#define EGL_MAX_STREAM_METADATA_TOTAL_SIZE_NV 0x3252
+#define EGL_PRODUCER_METADATA_NV          0x3253
+#define EGL_CONSUMER_METADATA_NV          0x3254
+#define EGL_PENDING_METADATA_NV           0x3328
+#define EGL_METADATA0_SIZE_NV             0x3255
+#define EGL_METADATA1_SIZE_NV             0x3256
+#define EGL_METADATA2_SIZE_NV             0x3257
+#define EGL_METADATA3_SIZE_NV             0x3258
+#define EGL_METADATA0_TYPE_NV             0x3259
+#define EGL_METADATA1_TYPE_NV             0x325A
+#define EGL_METADATA2_TYPE_NV             0x325B
+#define EGL_METADATA3_TYPE_NV             0x325C
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYDISPLAYATTRIBNVPROC) (EGLDisplay dpy, EGLint attribute, EGLAttrib *value);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSETSTREAMMETADATANVPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLint n, EGLint offset, EGLint size, const void *data);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSTREAMMETADATANVPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLenum name, EGLint n, EGLint offset, EGLint size, void *data);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglQueryDisplayAttribNV (EGLDisplay dpy, EGLint attribute, EGLAttrib *value);
+EGLAPI EGLBoolean EGLAPIENTRY eglSetStreamMetadataNV (EGLDisplay dpy, EGLStreamKHR stream, EGLint n, EGLint offset, EGLint size, const void *data);
+EGLAPI EGLBoolean EGLAPIENTRY eglQueryStreamMetadataNV (EGLDisplay dpy, EGLStreamKHR stream, EGLenum name, EGLint n, EGLint offset, EGLint size, void *data);
+#endif
+#endif /* EGL_NV_stream_metadata */
+
+#ifndef EGL_NV_stream_origin
+#define EGL_NV_stream_origin 1
+#define EGL_STREAM_FRAME_ORIGIN_X_NV      0x3366
+#define EGL_STREAM_FRAME_ORIGIN_Y_NV      0x3367
+#define EGL_STREAM_FRAME_MAJOR_AXIS_NV    0x3368
+#define EGL_CONSUMER_AUTO_ORIENTATION_NV  0x3369
+#define EGL_PRODUCER_AUTO_ORIENTATION_NV  0x336A
+#define EGL_LEFT_NV                       0x336B
+#define EGL_RIGHT_NV                      0x336C
+#define EGL_TOP_NV                        0x336D
+#define EGL_BOTTOM_NV                     0x336E
+#define EGL_X_AXIS_NV                     0x336F
+#define EGL_Y_AXIS_NV                     0x3370
+#endif /* EGL_NV_stream_origin */
+
+#ifndef EGL_NV_stream_remote
+#define EGL_NV_stream_remote 1
+#define EGL_STREAM_STATE_INITIALIZING_NV  0x3240
+#define EGL_STREAM_TYPE_NV                0x3241
+#define EGL_STREAM_PROTOCOL_NV            0x3242
+#define EGL_STREAM_ENDPOINT_NV            0x3243
+#define EGL_STREAM_LOCAL_NV               0x3244
+#define EGL_STREAM_PRODUCER_NV            0x3247
+#define EGL_STREAM_CONSUMER_NV            0x3248
+#define EGL_STREAM_PROTOCOL_FD_NV         0x3246
+#endif /* EGL_NV_stream_remote */
+
+#ifndef EGL_NV_stream_reset
+#define EGL_NV_stream_reset 1
+#define EGL_SUPPORT_RESET_NV              0x3334
+#define EGL_SUPPORT_REUSE_NV              0x3335
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLRESETSTREAMNVPROC) (EGLDisplay dpy, EGLStreamKHR stream);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglResetStreamNV (EGLDisplay dpy, EGLStreamKHR stream);
+#endif
+#endif /* EGL_NV_stream_reset */
+
+#ifndef EGL_NV_stream_socket
+#define EGL_NV_stream_socket 1
+#define EGL_STREAM_PROTOCOL_SOCKET_NV     0x324B
+#define EGL_SOCKET_HANDLE_NV              0x324C
+#define EGL_SOCKET_TYPE_NV                0x324D
+#endif /* EGL_NV_stream_socket */
+
+#ifndef EGL_NV_stream_socket_inet
+#define EGL_NV_stream_socket_inet 1
+#define EGL_SOCKET_TYPE_INET_NV           0x324F
+#endif /* EGL_NV_stream_socket_inet */
+
+#ifndef EGL_NV_stream_socket_unix
+#define EGL_NV_stream_socket_unix 1
+#define EGL_SOCKET_TYPE_UNIX_NV           0x324E
+#endif /* EGL_NV_stream_socket_unix */
+
 #ifndef EGL_NV_stream_sync
 #define EGL_NV_stream_sync 1
 #define EGL_SYNC_NEW_FRAME_NV             0x321F
@@ -1625,7 +2213,7 @@ typedef khronos_utime_nanoseconds_t EGLTimeNV;
 #define EGL_SYNC_TYPE_NV                  0x30ED
 #define EGL_SYNC_CONDITION_NV             0x30EE
 #define EGL_SYNC_FENCE_NV                 0x30EF
-#define EGL_NO_SYNC_NV                    ((EGLSyncNV)0)
+#define EGL_NO_SYNC_NV                    EGL_CAST(EGLSyncNV,0)
 typedef EGLSyncNV (EGLAPIENTRYP PFNEGLCREATEFENCESYNCNVPROC) (EGLDisplay dpy, EGLenum condition, const EGLint *attrib_list);
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYSYNCNVPROC) (EGLSyncNV sync);
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLFENCENVPROC) (EGLSyncNV sync);
@@ -1656,6 +2244,11 @@ EGLAPI EGLuint64NV EGLAPIENTRY eglGetSystemTimeNV (void);
 #endif /* KHRONOS_SUPPORT_INT64 */
 #endif /* EGL_NV_system_time */
 
+#ifndef EGL_NV_triple_buffer
+#define EGL_NV_triple_buffer 1
+#define EGL_TRIPLE_BUFFER_NV              0x3230
+#endif /* EGL_NV_triple_buffer */
+
 #ifndef EGL_TIZEN_image_native_buffer
 #define EGL_TIZEN_image_native_buffer 1
 #define EGL_NATIVE_BUFFER_TIZEN           0x32A0
@@ -1666,11 +2259,44 @@ EGLAPI EGLuint64NV EGLAPIENTRY eglGetSystemTimeNV (void);
 #define EGL_NATIVE_SURFACE_TIZEN          0x32A1
 #endif /* EGL_TIZEN_image_native_surface */
 
+#ifndef EGL_WL_bind_wayland_display
+#define EGL_WL_bind_wayland_display 1
+#define PFNEGLBINDWAYLANDDISPLAYWL PFNEGLBINDWAYLANDDISPLAYWLPROC
+#define PFNEGLUNBINDWAYLANDDISPLAYWL PFNEGLUNBINDWAYLANDDISPLAYWLPROC
+#define PFNEGLQUERYWAYLANDBUFFERWL PFNEGLQUERYWAYLANDBUFFERWLPROC
+struct wl_display;
+struct wl_resource;
+#define EGL_WAYLAND_BUFFER_WL             0x31D5
+#define EGL_WAYLAND_PLANE_WL              0x31D6
+#define EGL_TEXTURE_Y_U_V_WL              0x31D7
+#define EGL_TEXTURE_Y_UV_WL               0x31D8
+#define EGL_TEXTURE_Y_XUXV_WL             0x31D9
+#define EGL_TEXTURE_EXTERNAL_WL           0x31DA
+#define EGL_WAYLAND_Y_INVERTED_WL         0x31DB
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLBINDWAYLANDDISPLAYWLPROC) (EGLDisplay dpy, struct wl_display *display);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLUNBINDWAYLANDDISPLAYWLPROC) (EGLDisplay dpy, struct wl_display *display);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYWAYLANDBUFFERWLPROC) (EGLDisplay dpy, struct wl_resource *buffer, EGLint attribute, EGLint *value);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglBindWaylandDisplayWL (EGLDisplay dpy, struct wl_display *display);
+EGLAPI EGLBoolean EGLAPIENTRY eglUnbindWaylandDisplayWL (EGLDisplay dpy, struct wl_display *display);
+EGLAPI EGLBoolean EGLAPIENTRY eglQueryWaylandBufferWL (EGLDisplay dpy, struct wl_resource *buffer, EGLint attribute, EGLint *value);
+#endif
+#endif /* EGL_WL_bind_wayland_display */
+
+#ifndef EGL_WL_create_wayland_buffer_from_image
+#define EGL_WL_create_wayland_buffer_from_image 1
+#define PFNEGLCREATEWAYLANDBUFFERFROMIMAGEWL PFNEGLCREATEWAYLANDBUFFERFROMIMAGEWLPROC
+struct wl_buffer;
+typedef struct wl_buffer *(EGLAPIENTRYP PFNEGLCREATEWAYLANDBUFFERFROMIMAGEWLPROC) (EGLDisplay dpy, EGLImageKHR image);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI struct wl_buffer *EGLAPIENTRY eglCreateWaylandBufferFromImageWL (EGLDisplay dpy, EGLImageKHR image);
+#endif
+#endif /* EGL_WL_create_wayland_buffer_from_image */
+
 #ifdef __cplusplus
 }
 #endif
 
 #endif /* __eglext_h_ */
 
-
 #endif /* _MSC_VER */
diff --git a/Engine/lib/sdl/include/SDL_endian.h b/Engine/lib/sdl/include/SDL_endian.h
index 171c008a8..2866f4bea 100644
--- a/Engine/lib/sdl/include/SDL_endian.h
+++ b/Engine/lib/sdl/include/SDL_endian.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -30,6 +30,23 @@
 
 #include "SDL_stdinc.h"
 
+#if defined(_MSC_VER) && (_MSC_VER >= 1400)
+/* As of Clang 11, '_m_prefetchw' is conflicting with the winnt.h's version,
+   so we define the needed '_m_prefetch' here as a pseudo-header, until the issue is fixed. */
+#ifdef __clang__
+#ifndef __PRFCHWINTRIN_H
+#define __PRFCHWINTRIN_H
+static __inline__ void __attribute__((__always_inline__, __nodebug__))
+_m_prefetch(void *__P)
+{
+  __builtin_prefetch (__P, 0, 3 /* _MM_HINT_T0 */);
+}
+#endif /* __PRFCHWINTRIN_H */
+#endif /* __clang__ */
+
+#include <intrin.h>
+#endif
+
 /**
  *  \name The two types of endianness
  */
@@ -45,6 +62,18 @@
 #elif defined(__OpenBSD__)
 #include <endian.h>
 #define SDL_BYTEORDER  BYTE_ORDER
+#elif defined(__FreeBSD__) || defined(__NetBSD__)
+#include <sys/endian.h>
+#define SDL_BYTEORDER  BYTE_ORDER
+/* predefs from newer gcc and clang versions: */
+#elif defined(__ORDER_LITTLE_ENDIAN__) && defined(__ORDER_BIG_ENDIAN__) && defined(__BYTE_ORDER__)
+#if (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+#define SDL_BYTEORDER   SDL_LIL_ENDIAN
+#elif (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+#define SDL_BYTEORDER   SDL_BIG_ENDIAN
+#else
+#error Unsupported endianness
+#endif /**/
 #else
 #if defined(__hppa__) || \
     defined(__m68k__) || defined(mc68000) || defined(_M_M68K) || \
@@ -68,22 +97,45 @@ extern "C" {
 /**
  *  \file SDL_endian.h
  */
-#if defined(__GNUC__) && defined(__i386__) && \
-   !(__GNUC__ == 2 && __GNUC_MINOR__ == 95 /* broken gcc version */)
+
+/* various modern compilers may have builtin swap */
+#if defined(__GNUC__) || defined(__clang__)
+#   define HAS_BUILTIN_BSWAP16 (_SDL_HAS_BUILTIN(__builtin_bswap16)) || \
+        (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))
+#   define HAS_BUILTIN_BSWAP32 (_SDL_HAS_BUILTIN(__builtin_bswap32)) || \
+        (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
+#   define HAS_BUILTIN_BSWAP64 (_SDL_HAS_BUILTIN(__builtin_bswap64)) || \
+        (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
+
+    /* this one is broken */
+#   define HAS_BROKEN_BSWAP (__GNUC__ == 2 && __GNUC_MINOR__ <= 95)
+#else
+#   define HAS_BUILTIN_BSWAP16 0
+#   define HAS_BUILTIN_BSWAP32 0
+#   define HAS_BUILTIN_BSWAP64 0
+#   define HAS_BROKEN_BSWAP 0
+#endif
+
+#if HAS_BUILTIN_BSWAP16
+#define SDL_Swap16(x) __builtin_bswap16(x)
+#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
+#pragma intrinsic(_byteswap_ushort)
+#define SDL_Swap16(x) _byteswap_ushort(x)
+#elif defined(__i386__) && !HAS_BROKEN_BSWAP
 SDL_FORCE_INLINE Uint16
 SDL_Swap16(Uint16 x)
 {
   __asm__("xchgb %b0,%h0": "=q"(x):"0"(x));
     return x;
 }
-#elif defined(__GNUC__) && defined(__x86_64__)
+#elif defined(__x86_64__)
 SDL_FORCE_INLINE Uint16
 SDL_Swap16(Uint16 x)
 {
   __asm__("xchgb %b0,%h0": "=Q"(x):"0"(x));
     return x;
 }
-#elif defined(__GNUC__) && (defined(__powerpc__) || defined(__ppc__))
+#elif (defined(__powerpc__) || defined(__ppc__))
 SDL_FORCE_INLINE Uint16
 SDL_Swap16(Uint16 x)
 {
@@ -92,7 +144,7 @@ SDL_Swap16(Uint16 x)
   __asm__("rlwimi %0,%2,8,16,23": "=&r"(result):"0"(x >> 8), "r"(x));
     return (Uint16)result;
 }
-#elif defined(__GNUC__) && (defined(__M68000__) || defined(__M68020__)) && !defined(__mcoldfire__)
+#elif (defined(__m68k__) && !defined(__mcoldfire__))
 SDL_FORCE_INLINE Uint16
 SDL_Swap16(Uint16 x)
 {
@@ -100,7 +152,7 @@ SDL_Swap16(Uint16 x)
     return x;
 }
 #elif defined(__WATCOMC__) && defined(__386__)
-extern _inline Uint16 SDL_Swap16(Uint16);
+extern __inline Uint16 SDL_Swap16(Uint16);
 #pragma aux SDL_Swap16 = \
   "xchg al, ah" \
   parm   [ax]   \
@@ -113,32 +165,37 @@ SDL_Swap16(Uint16 x)
 }
 #endif
 
-#if defined(__GNUC__) && defined(__i386__)
+#if HAS_BUILTIN_BSWAP32
+#define SDL_Swap32(x) __builtin_bswap32(x)
+#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
+#pragma intrinsic(_byteswap_ulong)
+#define SDL_Swap32(x) _byteswap_ulong(x)
+#elif defined(__i386__) && !HAS_BROKEN_BSWAP
 SDL_FORCE_INLINE Uint32
 SDL_Swap32(Uint32 x)
 {
   __asm__("bswap %0": "=r"(x):"0"(x));
     return x;
 }
-#elif defined(__GNUC__) && defined(__x86_64__)
+#elif defined(__x86_64__)
 SDL_FORCE_INLINE Uint32
 SDL_Swap32(Uint32 x)
 {
   __asm__("bswapl %0": "=r"(x):"0"(x));
     return x;
 }
-#elif defined(__GNUC__) && (defined(__powerpc__) || defined(__ppc__))
+#elif (defined(__powerpc__) || defined(__ppc__))
 SDL_FORCE_INLINE Uint32
 SDL_Swap32(Uint32 x)
 {
     Uint32 result;
 
-  __asm__("rlwimi %0,%2,24,16,23": "=&r"(result):"0"(x >> 24), "r"(x));
-  __asm__("rlwimi %0,%2,8,8,15": "=&r"(result):"0"(result), "r"(x));
-  __asm__("rlwimi %0,%2,24,0,7": "=&r"(result):"0"(result), "r"(x));
+  __asm__("rlwimi %0,%2,24,16,23": "=&r"(result): "0" (x>>24),  "r"(x));
+  __asm__("rlwimi %0,%2,8,8,15"  : "=&r"(result): "0" (result), "r"(x));
+  __asm__("rlwimi %0,%2,24,0,7"  : "=&r"(result): "0" (result), "r"(x));
     return result;
 }
-#elif defined(__GNUC__) && (defined(__M68000__) || defined(__M68020__)) && !defined(__mcoldfire__)
+#elif (defined(__m68k__) && !defined(__mcoldfire__))
 SDL_FORCE_INLINE Uint32
 SDL_Swap32(Uint32 x)
 {
@@ -146,20 +203,11 @@ SDL_Swap32(Uint32 x)
     return x;
 }
 #elif defined(__WATCOMC__) && defined(__386__)
-extern _inline Uint32 SDL_Swap32(Uint32);
-#ifndef __SW_3 /* 486+ */
+extern __inline Uint32 SDL_Swap32(Uint32);
 #pragma aux SDL_Swap32 = \
   "bswap eax"  \
   parm   [eax] \
   modify [eax];
-#else  /* 386-only */
-#pragma aux SDL_Swap32 = \
-  "xchg al, ah"  \
-  "ror  eax, 16" \
-  "xchg al, ah"  \
-  parm   [eax]   \
-  modify [eax];
-#endif
 #else
 SDL_FORCE_INLINE Uint32
 SDL_Swap32(Uint32 x)
@@ -169,31 +217,42 @@ SDL_Swap32(Uint32 x)
 }
 #endif
 
-#if defined(__GNUC__) && defined(__i386__)
+#if HAS_BUILTIN_BSWAP64
+#define SDL_Swap64(x) __builtin_bswap64(x)
+#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
+#pragma intrinsic(_byteswap_uint64)
+#define SDL_Swap64(x) _byteswap_uint64(x)
+#elif defined(__i386__) && !HAS_BROKEN_BSWAP
 SDL_FORCE_INLINE Uint64
 SDL_Swap64(Uint64 x)
 {
-    union
-    {
-        struct
-        {
+    union {
+        struct {
             Uint32 a, b;
         } s;
         Uint64 u;
     } v;
     v.u = x;
-  __asm__("bswapl %0 ; bswapl %1 ; xchgl %0,%1": "=r"(v.s.a), "=r"(v.s.b):"0"(v.s.a),
-            "1"(v.s.
-                b));
+  __asm__("bswapl %0 ; bswapl %1 ; xchgl %0,%1"
+          : "=r"(v.s.a), "=r"(v.s.b)
+          : "0" (v.s.a),  "1"(v.s.b));
     return v.u;
 }
-#elif defined(__GNUC__) && defined(__x86_64__)
+#elif defined(__x86_64__)
 SDL_FORCE_INLINE Uint64
 SDL_Swap64(Uint64 x)
 {
   __asm__("bswapq %0": "=r"(x):"0"(x));
     return x;
 }
+#elif defined(__WATCOMC__) && defined(__386__)
+extern __inline Uint64 SDL_Swap64(Uint64);
+#pragma aux SDL_Swap64 = \
+  "bswap eax"     \
+  "bswap edx"     \
+  "xchg eax,edx"  \
+  parm [eax edx]  \
+  modify [eax edx];
 #else
 SDL_FORCE_INLINE Uint64
 SDL_Swap64(Uint64 x)
@@ -215,8 +274,7 @@ SDL_Swap64(Uint64 x)
 SDL_FORCE_INLINE float
 SDL_SwapFloat(float x)
 {
-    union
-    {
+    union {
         float f;
         Uint32 ui32;
     } swapper;
@@ -225,6 +283,11 @@ SDL_SwapFloat(float x)
     return swapper.f;
 }
 
+/* remove extra macros */
+#undef HAS_BROKEN_BSWAP
+#undef HAS_BUILTIN_BSWAP16
+#undef HAS_BUILTIN_BSWAP32
+#undef HAS_BUILTIN_BSWAP64
 
 /**
  *  \name Swap to native
@@ -232,22 +295,22 @@ SDL_SwapFloat(float x)
  */
 /* @{ */
 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
-#define SDL_SwapLE16(X) (X)
-#define SDL_SwapLE32(X) (X)
-#define SDL_SwapLE64(X) (X)
+#define SDL_SwapLE16(X)     (X)
+#define SDL_SwapLE32(X)     (X)
+#define SDL_SwapLE64(X)     (X)
 #define SDL_SwapFloatLE(X)  (X)
-#define SDL_SwapBE16(X) SDL_Swap16(X)
-#define SDL_SwapBE32(X) SDL_Swap32(X)
-#define SDL_SwapBE64(X) SDL_Swap64(X)
+#define SDL_SwapBE16(X)     SDL_Swap16(X)
+#define SDL_SwapBE32(X)     SDL_Swap32(X)
+#define SDL_SwapBE64(X)     SDL_Swap64(X)
 #define SDL_SwapFloatBE(X)  SDL_SwapFloat(X)
 #else
-#define SDL_SwapLE16(X) SDL_Swap16(X)
-#define SDL_SwapLE32(X) SDL_Swap32(X)
-#define SDL_SwapLE64(X) SDL_Swap64(X)
+#define SDL_SwapLE16(X)     SDL_Swap16(X)
+#define SDL_SwapLE32(X)     SDL_Swap32(X)
+#define SDL_SwapLE64(X)     SDL_Swap64(X)
 #define SDL_SwapFloatLE(X)  SDL_SwapFloat(X)
-#define SDL_SwapBE16(X) (X)
-#define SDL_SwapBE32(X) (X)
-#define SDL_SwapBE64(X) (X)
+#define SDL_SwapBE16(X)     (X)
+#define SDL_SwapBE32(X)     (X)
+#define SDL_SwapBE64(X)     (X)
 #define SDL_SwapFloatBE(X)  (X)
 #endif
 /* @} *//* Swap to native */
diff --git a/Engine/lib/sdl/include/SDL_error.h b/Engine/lib/sdl/include/SDL_error.h
index 962d62f6e..5c961e428 100644
--- a/Engine/lib/sdl/include/SDL_error.h
+++ b/Engine/lib/sdl/include/SDL_error.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -40,41 +40,92 @@ extern "C" {
 
 
 /**
- *  \brief Set the error message for the current thread
+ * Set the SDL error message for the current thread.
  *
- *  \return -1, there is no error handling for this function
+ * Calling this function will replace any previous error message that was set.
+ *
+ * This function always returns -1, since SDL frequently uses -1 to signify an
+ * failing result, leading to this idiom:
+ *
+ * ```c
+ * if (error_code) {
+ *     return SDL_SetError("This operation has failed: %d", error_code);
+ * }
+ * ```
+ *
+ * \param fmt a printf()-style message format string
+ * \param ... additional parameters matching % tokens in the `fmt` string, if
+ *            any
+ * \returns always -1.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_ClearError
+ * \sa SDL_GetError
  */
 extern DECLSPEC int SDLCALL SDL_SetError(SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(1);
 
 /**
- *  \brief Get the last error message that was set
+ * Retrieve a message about the last error that occurred on the current
+ * thread.
  *
- * SDL API functions may set error messages and then succeed, so you should
- * only use the error value if a function fails.
- * 
- * This returns a pointer to a static buffer for convenience and should not
- * be called by multiple threads simultaneously.
+ * It is possible for multiple errors to occur before calling SDL_GetError().
+ * Only the last error is returned.
  *
- *  \return a pointer to the last error message that was set
+ * The message is only applicable when an SDL function has signaled an error.
+ * You must check the return values of SDL function calls to determine when to
+ * appropriately call SDL_GetError(). You should *not* use the results of
+ * SDL_GetError() to decide if an error has occurred! Sometimes SDL will set
+ * an error string even when reporting success.
+ *
+ * SDL will *not* clear the error string for successful API calls. You *must*
+ * check return values for failure cases before you can assume the error
+ * string applies.
+ *
+ * Error strings are set per-thread, so an error set in a different thread
+ * will not interfere with the current thread's operation.
+ *
+ * The returned string is internally allocated and must not be freed by the
+ * application.
+ *
+ * \returns a message with information about the specific error that occurred,
+ *          or an empty string if there hasn't been an error message set since
+ *          the last call to SDL_ClearError(). The message is only applicable
+ *          when an SDL function has signaled an error. You must check the
+ *          return values of SDL function calls to determine when to
+ *          appropriately call SDL_GetError().
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_ClearError
+ * \sa SDL_SetError
  */
 extern DECLSPEC const char *SDLCALL SDL_GetError(void);
 
 /**
- *  \brief Get the last error message that was set for the current thread
+ * Get the last error message that was set for the current thread.
  *
- * SDL API functions may set error messages and then succeed, so you should
- * only use the error value if a function fails.
- * 
- *  \param errstr A buffer to fill with the last error message that was set
- *                for the current thread
- *  \param maxlen The size of the buffer pointed to by the errstr parameter
+ * This allows the caller to copy the error string into a provided buffer, but
+ * otherwise operates exactly the same as SDL_GetError().
  *
- *  \return errstr
+ * \param errstr A buffer to fill with the last error message that was set for
+ *               the current thread
+ * \param maxlen The size of the buffer pointed to by the errstr parameter
+ * \returns the pointer passed in as the `errstr` parameter.
+ *
+ * \since This function is available since SDL 2.0.14.
+ *
+ * \sa SDL_GetError
  */
 extern DECLSPEC char * SDLCALL SDL_GetErrorMsg(char *errstr, int maxlen);
 
 /**
- *  \brief Clear the error message for the current thread
+ * Clear any previous error message for this thread.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetError
+ * \sa SDL_SetError
  */
 extern DECLSPEC void SDLCALL SDL_ClearError(void);
 
diff --git a/Engine/lib/sdl/include/SDL_events.h b/Engine/lib/sdl/include/SDL_events.h
index ae560c085..7e469070e 100644
--- a/Engine/lib/sdl/include/SDL_events.h
+++ b/Engine/lib/sdl/include/SDL_events.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -50,7 +50,7 @@ extern "C" {
 #define SDL_PRESSED 1
 
 /**
- * \brief The types of events that can be delivered.
+ * The types of events that can be delivered.
  */
 typedef enum
 {
@@ -102,6 +102,7 @@ typedef enum
     SDL_KEYMAPCHANGED,          /**< Keymap changed due to a system event such as an
                                      input language or keyboard layout change.
                                 */
+    SDL_TEXTEDITING_EXT,       /**< Extended keyboard text editing (composition) */
 
     /* Mouse events */
     SDL_MOUSEMOTION    = 0x400, /**< Mouse moved */
@@ -160,6 +161,9 @@ typedef enum
     SDL_RENDER_TARGETS_RESET = 0x2000, /**< The render targets have been reset and their contents need to be updated */
     SDL_RENDER_DEVICE_RESET, /**< The device has been reset and all textures need to be recreated */
 
+    /* Internal events */
+    SDL_POLLSENTINEL = 0x7F00, /**< Signals the end of an event poll cycle */
+
     /** Events ::SDL_USEREVENT through ::SDL_LASTEVENT are for your use,
      *  and should be allocated with SDL_RegisterEvents()
      */
@@ -240,6 +244,19 @@ typedef struct SDL_TextEditingEvent
     Sint32 length;                              /**< The length of selected editing text */
 } SDL_TextEditingEvent;
 
+/**
+ *  \brief Extended keyboard text editing event structure (event.editExt.*) when text would be
+ *  truncated if stored in the text buffer SDL_TextEditingEvent
+ */
+typedef struct SDL_TextEditingExtEvent
+{
+    Uint32 type;                                /**< ::SDL_TEXTEDITING_EXT */
+    Uint32 timestamp;                           /**< In milliseconds, populated using SDL_GetTicks() */
+    Uint32 windowID;                            /**< The window with keyboard focus, if any */
+    char* text;                                 /**< The editing text, which should be freed with SDL_free(), and will not be NULL */
+    Sint32 start;                               /**< The start cursor of selected editing text */
+    Sint32 length;                              /**< The length of selected editing text */
+} SDL_TextEditingExtEvent;
 
 #define SDL_TEXTINPUTEVENT_TEXT_SIZE (32)
 /**
@@ -298,6 +315,8 @@ typedef struct SDL_MouseWheelEvent
     Sint32 x;           /**< The amount scrolled horizontally, positive to the right and negative to the left */
     Sint32 y;           /**< The amount scrolled vertically, positive away from the user and negative toward the user */
     Uint32 direction;   /**< Set to one of the SDL_MOUSEWHEEL_* defines. When FLIPPED the values in X and Y will be opposite. Multiply by -1 to change them back */
+    float preciseX;     /**< The amount scrolled horizontally, positive to the right and negative to the left, with float precision (added in 2.0.18) */
+    float preciseY;     /**< The amount scrolled vertically, positive away from the user and negative toward the user, with float precision (added in 2.0.18) */
 } SDL_MouseWheelEvent;
 
 /**
@@ -596,6 +615,7 @@ typedef union SDL_Event
     SDL_WindowEvent window;                 /**< Window event data */
     SDL_KeyboardEvent key;                  /**< Keyboard event data */
     SDL_TextEditingEvent edit;              /**< Text editing event data */
+    SDL_TextEditingExtEvent editExt;        /**< Extended text editing event data */
     SDL_TextInputEvent text;                /**< Text input event data */
     SDL_MouseMotionEvent motion;            /**< Mouse motion event data */
     SDL_MouseButtonEvent button;            /**< Mouse button event data */
@@ -620,28 +640,49 @@ typedef union SDL_Event
     SDL_DollarGestureEvent dgesture;        /**< Gesture event data */
     SDL_DropEvent drop;                     /**< Drag and drop event data */
 
-    /* This is necessary for ABI compatibility between Visual C++ and GCC
-       Visual C++ will respect the push pack pragma and use 52 bytes for
-       this structure, and GCC will use the alignment of the largest datatype
-       within the union, which is 8 bytes.
+    /* This is necessary for ABI compatibility between Visual C++ and GCC.
+       Visual C++ will respect the push pack pragma and use 52 bytes (size of
+       SDL_TextEditingEvent, the largest structure for 32-bit and 64-bit
+       architectures) for this union, and GCC will use the alignment of the
+       largest datatype within the union, which is 8 bytes on 64-bit
+       architectures.
 
        So... we'll add padding to force the size to be 56 bytes for both.
+
+       On architectures where pointers are 16 bytes, this needs rounding up to
+       the next multiple of 16, 64, and on architectures where pointers are
+       even larger the size of SDL_UserEvent will dominate as being 3 pointers.
     */
-    Uint8 padding[56];
+    Uint8 padding[sizeof(void *) <= 8 ? 56 : sizeof(void *) == 16 ? 64 : 3 * sizeof(void *)];
 } SDL_Event;
 
 /* Make sure we haven't broken binary compatibility */
-SDL_COMPILE_TIME_ASSERT(SDL_Event, sizeof(SDL_Event) == 56);
+SDL_COMPILE_TIME_ASSERT(SDL_Event, sizeof(SDL_Event) == sizeof(((SDL_Event *)NULL)->padding));
 
 
 /* Function prototypes */
 
 /**
- *  Pumps the event loop, gathering events from the input devices.
+ * Pump the event loop, gathering events from the input devices.
  *
- *  This function updates the event queue and internal input device state.
+ * This function updates the event queue and internal input device state.
  *
- *  This should only be run in the thread that sets the video mode.
+ * **WARNING**: This should only be run in the thread that initialized the
+ * video subsystem, and for extra safety, you should consider only doing those
+ * things on the main thread in any case.
+ *
+ * SDL_PumpEvents() gathers all the pending input information from devices and
+ * places it in the event queue. Without calls to SDL_PumpEvents() no events
+ * would ever be placed on the queue. Often the need for calls to
+ * SDL_PumpEvents() is hidden from the user since SDL_PollEvent() and
+ * SDL_WaitEvent() implicitly call SDL_PumpEvents(). However, if you are not
+ * polling or waiting for events (e.g. you are filtering them), then you must
+ * call SDL_PumpEvents() to force an event queue update.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_PollEvent
+ * \sa SDL_WaitEvent
  */
 extern DECLSPEC void SDLCALL SDL_PumpEvents(void);
 
@@ -654,22 +695,42 @@ typedef enum
 } SDL_eventaction;
 
 /**
- *  Checks the event queue for messages and optionally returns them.
+ * Check the event queue for messages and optionally return them.
  *
- *  If \c action is ::SDL_ADDEVENT, up to \c numevents events will be added to
- *  the back of the event queue.
+ * `action` may be any of the following:
  *
- *  If \c action is ::SDL_PEEKEVENT, up to \c numevents events at the front
- *  of the event queue, within the specified minimum and maximum type,
- *  will be returned and will not be removed from the queue.
+ * - `SDL_ADDEVENT`: up to `numevents` events will be added to the back of the
+ *   event queue.
+ * - `SDL_PEEKEVENT`: `numevents` events at the front of the event queue,
+ *   within the specified minimum and maximum type, will be returned to the
+ *   caller and will _not_ be removed from the queue.
+ * - `SDL_GETEVENT`: up to `numevents` events at the front of the event queue,
+ *   within the specified minimum and maximum type, will be returned to the
+ *   caller and will be removed from the queue.
  *
- *  If \c action is ::SDL_GETEVENT, up to \c numevents events at the front
- *  of the event queue, within the specified minimum and maximum type,
- *  will be returned and will be removed from the queue.
+ * You may have to call SDL_PumpEvents() before calling this function.
+ * Otherwise, the events may not be ready to be filtered when you call
+ * SDL_PeepEvents().
  *
- *  \return The number of events actually stored, or -1 if there was an error.
+ * This function is thread-safe.
  *
- *  This function is thread-safe.
+ * \param events destination buffer for the retrieved events
+ * \param numevents if action is SDL_ADDEVENT, the number of events to add
+ *                  back to the event queue; if action is SDL_PEEKEVENT or
+ *                  SDL_GETEVENT, the maximum number of events to retrieve
+ * \param action action to take; see [[#action|Remarks]] for details
+ * \param minType minimum value of the event type to be considered;
+ *                SDL_FIRSTEVENT is a safe choice
+ * \param maxType maximum value of the event type to be considered;
+ *                SDL_LASTEVENT is a safe choice
+ * \returns the number of events actually stored or a negative error code on
+ *          failure; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_PollEvent
+ * \sa SDL_PumpEvents
+ * \sa SDL_PushEvent
  */
 extern DECLSPEC int SDLCALL SDL_PeepEvents(SDL_Event * events, int numevents,
                                            SDL_eventaction action,
@@ -677,113 +738,354 @@ extern DECLSPEC int SDLCALL SDL_PeepEvents(SDL_Event * events, int numevents,
 /* @} */
 
 /**
- *  Checks to see if certain event types are in the event queue.
+ * Check for the existence of a certain event type in the event queue.
+ *
+ * If you need to check for a range of event types, use SDL_HasEvents()
+ * instead.
+ *
+ * \param type the type of event to be queried; see SDL_EventType for details
+ * \returns SDL_TRUE if events matching `type` are present, or SDL_FALSE if
+ *          events matching `type` are not present.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HasEvents
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_HasEvent(Uint32 type);
+
+
+/**
+ * Check for the existence of certain event types in the event queue.
+ *
+ * If you need to check for a single event type, use SDL_HasEvent() instead.
+ *
+ * \param minType the low end of event type to be queried, inclusive; see
+ *                SDL_EventType for details
+ * \param maxType the high end of event type to be queried, inclusive; see
+ *                SDL_EventType for details
+ * \returns SDL_TRUE if events with type >= `minType` and <= `maxType` are
+ *          present, or SDL_FALSE if not.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HasEvents
+ */
 extern DECLSPEC SDL_bool SDLCALL SDL_HasEvents(Uint32 minType, Uint32 maxType);
 
 /**
- *  This function clears events from the event queue
- *  This function only affects currently queued events. If you want to make
- *  sure that all pending OS events are flushed, you can call SDL_PumpEvents()
- *  on the main thread immediately before the flush call.
+ * Clear events of a specific type from the event queue.
+ *
+ * This will unconditionally remove any events from the queue that match
+ * `type`. If you need to remove a range of event types, use SDL_FlushEvents()
+ * instead.
+ *
+ * It's also normal to just ignore events you don't care about in your event
+ * loop without calling this function.
+ *
+ * This function only affects currently queued events. If you want to make
+ * sure that all pending OS events are flushed, you can call SDL_PumpEvents()
+ * on the main thread immediately before the flush call.
+ *
+ * \param type the type of event to be cleared; see SDL_EventType for details
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_FlushEvents
  */
 extern DECLSPEC void SDLCALL SDL_FlushEvent(Uint32 type);
+
+/**
+ * Clear events of a range of types from the event queue.
+ *
+ * This will unconditionally remove any events from the queue that are in the
+ * range of `minType` to `maxType`, inclusive. If you need to remove a single
+ * event type, use SDL_FlushEvent() instead.
+ *
+ * It's also normal to just ignore events you don't care about in your event
+ * loop without calling this function.
+ *
+ * This function only affects currently queued events. If you want to make
+ * sure that all pending OS events are flushed, you can call SDL_PumpEvents()
+ * on the main thread immediately before the flush call.
+ *
+ * \param minType the low end of event type to be cleared, inclusive; see
+ *                SDL_EventType for details
+ * \param maxType the high end of event type to be cleared, inclusive; see
+ *                SDL_EventType for details
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_FlushEvent
+ */
 extern DECLSPEC void SDLCALL SDL_FlushEvents(Uint32 minType, Uint32 maxType);
 
 /**
- *  \brief Polls for currently pending events.
+ * Poll for currently pending events.
  *
- *  \return 1 if there are any pending events, or 0 if there are none available.
+ * If `event` is not NULL, the next event is removed from the queue and stored
+ * in the SDL_Event structure pointed to by `event`. The 1 returned refers to
+ * this event, immediately stored in the SDL Event structure -- not an event
+ * to follow.
  *
- *  \param event If not NULL, the next event is removed from the queue and
- *               stored in that area.
+ * If `event` is NULL, it simply returns 1 if there is an event in the queue,
+ * but will not remove it from the queue.
+ *
+ * As this function may implicitly call SDL_PumpEvents(), you can only call
+ * this function in the thread that set the video mode.
+ *
+ * SDL_PollEvent() is the favored way of receiving system events since it can
+ * be done from the main loop and does not suspend the main loop while waiting
+ * on an event to be posted.
+ *
+ * The common practice is to fully process the event queue once every frame,
+ * usually as a first step before updating the game's state:
+ *
+ * ```c
+ * while (game_is_still_running) {
+ *     SDL_Event event;
+ *     while (SDL_PollEvent(&event)) {  // poll until all events are handled!
+ *         // decide what to do with this event.
+ *     }
+ *
+ *     // update game state, draw the current frame
+ * }
+ * ```
+ *
+ * \param event the SDL_Event structure to be filled with the next event from
+ *              the queue, or NULL
+ * \returns 1 if there is a pending event or 0 if there are none available.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetEventFilter
+ * \sa SDL_PeepEvents
+ * \sa SDL_PushEvent
+ * \sa SDL_SetEventFilter
+ * \sa SDL_WaitEvent
+ * \sa SDL_WaitEventTimeout
  */
 extern DECLSPEC int SDLCALL SDL_PollEvent(SDL_Event * event);
 
 /**
- *  \brief Waits indefinitely for the next available event.
+ * Wait indefinitely for the next available event.
  *
- *  \return 1, or 0 if there was an error while waiting for events.
+ * If `event` is not NULL, the next event is removed from the queue and stored
+ * in the SDL_Event structure pointed to by `event`.
  *
- *  \param event If not NULL, the next event is removed from the queue and
- *               stored in that area.
+ * As this function may implicitly call SDL_PumpEvents(), you can only call
+ * this function in the thread that initialized the video subsystem.
+ *
+ * \param event the SDL_Event structure to be filled in with the next event
+ *              from the queue, or NULL
+ * \returns 1 on success or 0 if there was an error while waiting for events;
+ *          call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_PollEvent
+ * \sa SDL_PumpEvents
+ * \sa SDL_WaitEventTimeout
  */
 extern DECLSPEC int SDLCALL SDL_WaitEvent(SDL_Event * event);
 
 /**
- *  \brief Waits until the specified timeout (in milliseconds) for the next
- *         available event.
+ * Wait until the specified timeout (in milliseconds) for the next available
+ * event.
  *
- *  \return 1, or 0 if there was an error while waiting for events.
+ * If `event` is not NULL, the next event is removed from the queue and stored
+ * in the SDL_Event structure pointed to by `event`.
  *
- *  \param event If not NULL, the next event is removed from the queue and
- *               stored in that area.
- *  \param timeout The timeout (in milliseconds) to wait for next event.
+ * As this function may implicitly call SDL_PumpEvents(), you can only call
+ * this function in the thread that initialized the video subsystem.
+ *
+ * \param event the SDL_Event structure to be filled in with the next event
+ *              from the queue, or NULL
+ * \param timeout the maximum number of milliseconds to wait for the next
+ *                available event
+ * \returns 1 on success or 0 if there was an error while waiting for events;
+ *          call SDL_GetError() for more information. This also returns 0 if
+ *          the timeout elapsed without an event arriving.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_PollEvent
+ * \sa SDL_PumpEvents
+ * \sa SDL_WaitEvent
  */
 extern DECLSPEC int SDLCALL SDL_WaitEventTimeout(SDL_Event * event,
                                                  int timeout);
 
 /**
- *  \brief Add an event to the event queue.
+ * Add an event to the event queue.
  *
- *  \return 1 on success, 0 if the event was filtered, or -1 if the event queue
- *          was full or there was some other error.
+ * The event queue can actually be used as a two way communication channel.
+ * Not only can events be read from the queue, but the user can also push
+ * their own events onto it. `event` is a pointer to the event structure you
+ * wish to push onto the queue. The event is copied into the queue, and the
+ * caller may dispose of the memory pointed to after SDL_PushEvent() returns.
+ *
+ * Note: Pushing device input events onto the queue doesn't modify the state
+ * of the device within SDL.
+ *
+ * This function is thread-safe, and can be called from other threads safely.
+ *
+ * Note: Events pushed onto the queue with SDL_PushEvent() get passed through
+ * the event filter but events added with SDL_PeepEvents() do not.
+ *
+ * For pushing application-specific events, please use SDL_RegisterEvents() to
+ * get an event type that does not conflict with other code that also wants
+ * its own custom event types.
+ *
+ * \param event the SDL_Event to be added to the queue
+ * \returns 1 on success, 0 if the event was filtered, or a negative error
+ *          code on failure; call SDL_GetError() for more information. A
+ *          common reason for error is the event queue being full.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_PeepEvents
+ * \sa SDL_PollEvent
+ * \sa SDL_RegisterEvents
  */
 extern DECLSPEC int SDLCALL SDL_PushEvent(SDL_Event * event);
 
+/**
+ * A function pointer used for callbacks that watch the event queue.
+ *
+ * \param userdata what was passed as `userdata` to SDL_SetEventFilter()
+ *        or SDL_AddEventWatch, etc
+ * \param event the event that triggered the callback
+ * \returns 1 to permit event to be added to the queue, and 0 to disallow
+ *          it. When used with SDL_AddEventWatch, the return value is ignored.
+ *
+ * \sa SDL_SetEventFilter
+ * \sa SDL_AddEventWatch
+ */
 typedef int (SDLCALL * SDL_EventFilter) (void *userdata, SDL_Event * event);
 
 /**
- *  Sets up a filter to process all events before they change internal state and
- *  are posted to the internal event queue.
+ * Set up a filter to process all events before they change internal state and
+ * are posted to the internal event queue.
  *
- *  The filter is prototyped as:
- *  \code
- *      int SDL_EventFilter(void *userdata, SDL_Event * event);
- *  \endcode
+ * If the filter function returns 1 when called, then the event will be added
+ * to the internal queue. If it returns 0, then the event will be dropped from
+ * the queue, but the internal state will still be updated. This allows
+ * selective filtering of dynamically arriving events.
  *
- *  If the filter returns 1, then the event will be added to the internal queue.
- *  If it returns 0, then the event will be dropped from the queue, but the
- *  internal state will still be updated.  This allows selective filtering of
- *  dynamically arriving events.
+ * **WARNING**: Be very careful of what you do in the event filter function,
+ * as it may run in a different thread!
  *
- *  \warning  Be very careful of what you do in the event filter function, as
- *            it may run in a different thread!
+ * On platforms that support it, if the quit event is generated by an
+ * interrupt signal (e.g. pressing Ctrl-C), it will be delivered to the
+ * application at the next event poll.
  *
- *  There is one caveat when dealing with the ::SDL_QuitEvent event type.  The
- *  event filter is only called when the window manager desires to close the
- *  application window.  If the event filter returns 1, then the window will
- *  be closed, otherwise the window will remain open if possible.
+ * There is one caveat when dealing with the ::SDL_QuitEvent event type. The
+ * event filter is only called when the window manager desires to close the
+ * application window. If the event filter returns 1, then the window will be
+ * closed, otherwise the window will remain open if possible.
  *
- *  If the quit event is generated by an interrupt signal, it will bypass the
- *  internal queue and be delivered to the application at the next event poll.
+ * Note: Disabled events never make it to the event filter function; see
+ * SDL_EventState().
+ *
+ * Note: If you just want to inspect events without filtering, you should use
+ * SDL_AddEventWatch() instead.
+ *
+ * Note: Events pushed onto the queue with SDL_PushEvent() get passed through
+ * the event filter, but events pushed onto the queue with SDL_PeepEvents() do
+ * not.
+ *
+ * \param filter An SDL_EventFilter function to call when an event happens
+ * \param userdata a pointer that is passed to `filter`
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_AddEventWatch
+ * \sa SDL_EventState
+ * \sa SDL_GetEventFilter
+ * \sa SDL_PeepEvents
+ * \sa SDL_PushEvent
  */
 extern DECLSPEC void SDLCALL SDL_SetEventFilter(SDL_EventFilter filter,
                                                 void *userdata);
 
 /**
- *  Return the current event filter - can be used to "chain" filters.
- *  If there is no event filter set, this function returns SDL_FALSE.
+ * Query the current event filter.
+ *
+ * This function can be used to "chain" filters, by saving the existing filter
+ * before replacing it with a function that will call that saved filter.
+ *
+ * \param filter the current callback function will be stored here
+ * \param userdata the pointer that is passed to the current event filter will
+ *                 be stored here
+ * \returns SDL_TRUE on success or SDL_FALSE if there is no event filter set.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_SetEventFilter
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_GetEventFilter(SDL_EventFilter * filter,
                                                     void **userdata);
 
 /**
- *  Add a function which is called when an event is added to the queue.
+ * Add a callback to be triggered when an event is added to the event queue.
+ *
+ * `filter` will be called when an event happens, and its return value is
+ * ignored.
+ *
+ * **WARNING**: Be very careful of what you do in the event filter function,
+ * as it may run in a different thread!
+ *
+ * If the quit event is generated by a signal (e.g. SIGINT), it will bypass
+ * the internal queue and be delivered to the watch callback immediately, and
+ * arrive at the next event poll.
+ *
+ * Note: the callback is called for events posted by the user through
+ * SDL_PushEvent(), but not for disabled events, nor for events by a filter
+ * callback set with SDL_SetEventFilter(), nor for events posted by the user
+ * through SDL_PeepEvents().
+ *
+ * \param filter an SDL_EventFilter function to call when an event happens.
+ * \param userdata a pointer that is passed to `filter`
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_DelEventWatch
+ * \sa SDL_SetEventFilter
  */
 extern DECLSPEC void SDLCALL SDL_AddEventWatch(SDL_EventFilter filter,
                                                void *userdata);
 
 /**
- *  Remove an event watch function added with SDL_AddEventWatch()
+ * Remove an event watch callback added with SDL_AddEventWatch().
+ *
+ * This function takes the same input as SDL_AddEventWatch() to identify and
+ * delete the corresponding callback.
+ *
+ * \param filter the function originally passed to SDL_AddEventWatch()
+ * \param userdata the pointer originally passed to SDL_AddEventWatch()
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_AddEventWatch
  */
 extern DECLSPEC void SDLCALL SDL_DelEventWatch(SDL_EventFilter filter,
                                                void *userdata);
 
 /**
- *  Run the filter function on the current event queue, removing any
- *  events for which the filter returns 0.
+ * Run a specific filter function on the current event queue, removing any
+ * events for which the filter returns 0.
+ *
+ * See SDL_SetEventFilter() for more information. Unlike SDL_SetEventFilter(),
+ * this function does not change the filter permanently, it only uses the
+ * supplied filter until this function returns.
+ *
+ * \param filter the SDL_EventFilter function to call when an event happens
+ * \param userdata a pointer that is passed to `filter`
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetEventFilter
+ * \sa SDL_SetEventFilter
  */
 extern DECLSPEC void SDLCALL SDL_FilterEvents(SDL_EventFilter filter,
                                               void *userdata);
@@ -795,24 +1097,45 @@ extern DECLSPEC void SDLCALL SDL_FilterEvents(SDL_EventFilter filter,
 #define SDL_ENABLE   1
 
 /**
- *  This function allows you to set the state of processing certain events.
- *   - If \c state is set to ::SDL_IGNORE, that event will be automatically
- *     dropped from the event queue and will not be filtered.
- *   - If \c state is set to ::SDL_ENABLE, that event will be processed
- *     normally.
- *   - If \c state is set to ::SDL_QUERY, SDL_EventState() will return the
- *     current processing state of the specified event.
+ * Set the state of processing events by type.
+ *
+ * `state` may be any of the following:
+ *
+ * - `SDL_QUERY`: returns the current processing state of the specified event
+ * - `SDL_IGNORE` (aka `SDL_DISABLE`): the event will automatically be dropped
+ *   from the event queue and will not be filtered
+ * - `SDL_ENABLE`: the event will be processed normally
+ *
+ * \param type the type of event; see SDL_EventType for details
+ * \param state how to process the event
+ * \returns `SDL_DISABLE` or `SDL_ENABLE`, representing the processing state
+ *          of the event before this function makes any changes to it.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetEventState
  */
 extern DECLSPEC Uint8 SDLCALL SDL_EventState(Uint32 type, int state);
 /* @} */
 #define SDL_GetEventState(type) SDL_EventState(type, SDL_QUERY)
 
 /**
- *  This function allocates a set of user-defined events, and returns
- *  the beginning event number for that set of events.
+ * Allocate a set of user-defined events, and return the beginning event
+ * number for that set of events.
  *
- *  If there aren't enough user-defined events left, this function
- *  returns (Uint32)-1
+ * Calling this function with `numevents` <= 0 is an error and will return
+ * (Uint32)-1.
+ *
+ * Note, (Uint32)-1 means the maximum unsigned 32-bit integer value (or
+ * 0xFFFFFFFF), but is clearer to write.
+ *
+ * \param numevents the number of events to be allocated
+ * \returns the beginning event number, or (Uint32)-1 if there are not enough
+ *          user-defined events left.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_PushEvent
  */
 extern DECLSPEC Uint32 SDLCALL SDL_RegisterEvents(int numevents);
 
diff --git a/Engine/lib/sdl/include/SDL_filesystem.h b/Engine/lib/sdl/include/SDL_filesystem.h
index 68042b60f..16f02e287 100644
--- a/Engine/lib/sdl/include/SDL_filesystem.h
+++ b/Engine/lib/sdl/include/SDL_filesystem.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -38,88 +38,97 @@ extern "C" {
 #endif
 
 /**
- * \brief Get the path where the application resides.
+ * Get the directory where the application was run from.
  *
- * Get the "base path". This is the directory where the application was run
- *  from, which is probably the installation directory, and may or may not
- *  be the process's current working directory.
+ * This is not necessarily a fast call, so you should call this once near
+ * startup and save the string if you need it.
  *
- * This returns an absolute path in UTF-8 encoding, and is guaranteed to
- *  end with a path separator ('\\' on Windows, '/' most other places).
+ * **Mac OS X and iOS Specific Functionality**: If the application is in a
+ * ".app" bundle, this function returns the Resource directory (e.g.
+ * MyApp.app/Contents/Resources/). This behaviour can be overridden by adding
+ * a property to the Info.plist file. Adding a string key with the name
+ * SDL_FILESYSTEM_BASE_DIR_TYPE with a supported value will change the
+ * behaviour.
  *
- * The pointer returned by this function is owned by you. Please call
- *  SDL_free() on the pointer when you are done with it, or it will be a
- *  memory leak. This is not necessarily a fast call, though, so you should
- *  call this once near startup and save the string if you need it.
+ * Supported values for the SDL_FILESYSTEM_BASE_DIR_TYPE property (Given an
+ * application in /Applications/SDLApp/MyApp.app):
  *
- * Some platforms can't determine the application's path, and on other
- *  platforms, this might be meaningless. In such cases, this function will
- *  return NULL.
+ * - `resource`: bundle resource directory (the default). For example:
+ *   `/Applications/SDLApp/MyApp.app/Contents/Resources`
+ * - `bundle`: the Bundle directory. For example:
+ *   `/Applications/SDLApp/MyApp.app/`
+ * - `parent`: the containing directory of the bundle. For example:
+ *   `/Applications/SDLApp/`
  *
- *  \return String of base dir in UTF-8 encoding, or NULL on error.
+ * The returned path is guaranteed to end with a path separator ('\' on
+ * Windows, '/' on most other platforms).
+ *
+ * The pointer returned is owned by the caller. Please call SDL_free() on the
+ * pointer when done with it.
+ *
+ * \returns an absolute path in UTF-8 encoding to the application data
+ *          directory. NULL will be returned on error or when the platform
+ *          doesn't implement this functionality, call SDL_GetError() for more
+ *          information.
+ *
+ * \since This function is available since SDL 2.0.1.
  *
  * \sa SDL_GetPrefPath
  */
 extern DECLSPEC char *SDLCALL SDL_GetBasePath(void);
 
 /**
- * \brief Get the user-and-app-specific path where files can be written.
+ * Get the user-and-app-specific path where files can be written.
  *
  * Get the "pref dir". This is meant to be where users can write personal
- *  files (preferences and save games, etc) that are specific to your
- *  application. This directory is unique per user, per application.
+ * files (preferences and save games, etc) that are specific to your
+ * application. This directory is unique per user, per application.
  *
- * This function will decide the appropriate location in the native filesystem,
- *  create the directory if necessary, and return a string of the absolute
- *  path to the directory in UTF-8 encoding.
+ * This function will decide the appropriate location in the native
+ * filesystem, create the directory if necessary, and return a string of the
+ * absolute path to the directory in UTF-8 encoding.
  *
  * On Windows, the string might look like:
- *  "C:\\Users\\bob\\AppData\\Roaming\\My Company\\My Program Name\\"
  *
- * On Linux, the string might look like:
- *  "/home/bob/.local/share/My Program Name/"
+ * `C:\\Users\\bob\\AppData\\Roaming\\My Company\\My Program Name\\`
+ *
+ * On Linux, the string might look like"
+ *
+ * `/home/bob/.local/share/My Program Name/`
  *
  * On Mac OS X, the string might look like:
- *  "/Users/bob/Library/Application Support/My Program Name/"
  *
- * (etc.)
+ * `/Users/bob/Library/Application Support/My Program Name/`
  *
- * You specify the name of your organization (if it's not a real organization,
- *  your name or an Internet domain you own might do) and the name of your
- *  application. These should be untranslated proper names.
+ * You should assume the path returned by this function is the only safe place
+ * to write files (and that SDL_GetBasePath(), while it might be writable, or
+ * even the parent of the returned path, isn't where you should be writing
+ * things).
  *
- * Both the org and app strings may become part of a directory name, so
- *  please follow these rules:
+ * Both the org and app strings may become part of a directory name, so please
+ * follow these rules:
  *
- *    - Try to use the same org string (including case-sensitivity) for
- *      all your applications that use this function.
- *    - Always use a unique app string for each one, and make sure it never
- *      changes for an app once you've decided on it.
- *    - Unicode characters are legal, as long as it's UTF-8 encoded, but...
- *    - ...only use letters, numbers, and spaces. Avoid punctuation like
- *      "Game Name 2: Bad Guy's Revenge!" ... "Game Name 2" is sufficient.
+ * - Try to use the same org string (_including case-sensitivity_) for all
+ *   your applications that use this function.
+ * - Always use a unique app string for each one, and make sure it never
+ *   changes for an app once you've decided on it.
+ * - Unicode characters are legal, as long as it's UTF-8 encoded, but...
+ * - ...only use letters, numbers, and spaces. Avoid punctuation like "Game
+ *   Name 2: Bad Guy's Revenge!" ... "Game Name 2" is sufficient.
  *
- * This returns an absolute path in UTF-8 encoding, and is guaranteed to
- *  end with a path separator ('\\' on Windows, '/' most other places).
+ * The returned path is guaranteed to end with a path separator ('\' on
+ * Windows, '/' on most other platforms).
  *
- * The pointer returned by this function is owned by you. Please call
- *  SDL_free() on the pointer when you are done with it, or it will be a
- *  memory leak. This is not necessarily a fast call, though, so you should
- *  call this once near startup and save the string if you need it.
+ * The pointer returned is owned by the caller. Please call SDL_free() on the
+ * pointer when done with it.
  *
- * You should assume the path returned by this function is the only safe
- *  place to write files (and that SDL_GetBasePath(), while it might be
- *  writable, or even the parent of the returned path, aren't where you
- *  should be writing things).
+ * \param org the name of your organization
+ * \param app the name of your application
+ * \returns a UTF-8 string of the user directory in platform-dependent
+ *          notation. NULL if there's a problem (creating directory failed,
+ *          etc.).
  *
- * Some platforms can't determine the pref path, and on other
- *  platforms, this might be meaningless. In such cases, this function will
- *  return NULL.
- *
- *   \param org The name of your organization.
- *   \param app The name of your application.
- *  \return UTF-8 string of user dir in platform-dependent notation. NULL
- *          if there's a problem (creating directory failed, etc).
+ * \since This function is available since SDL 2.0.1.
  *
  * \sa SDL_GetBasePath
  */
diff --git a/Engine/lib/sdl/include/SDL_gamecontroller.h b/Engine/lib/sdl/include/SDL_gamecontroller.h
index e42433c95..548861083 100644
--- a/Engine/lib/sdl/include/SDL_gamecontroller.h
+++ b/Engine/lib/sdl/include/SDL_gamecontroller.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -67,7 +67,9 @@ typedef enum
     SDL_CONTROLLER_TYPE_PS4,
     SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_PRO,
     SDL_CONTROLLER_TYPE_VIRTUAL,
-    SDL_CONTROLLER_TYPE_PS5
+    SDL_CONTROLLER_TYPE_PS5,
+    SDL_CONTROLLER_TYPE_AMAZON_LUNA,
+    SDL_CONTROLLER_TYPE_GOOGLE_STADIA
 } SDL_GameControllerType;
 
 typedef enum
@@ -99,6 +101,8 @@ typedef struct SDL_GameControllerButtonBind
 
 /**
  *  To count the number of game controllers in the system for the following:
+ *
+ *  ```c
  *  int nJoysticks = SDL_NumJoysticks();
  *  int nGameControllers = 0;
  *  for (int i = 0; i < nJoysticks; i++) {
@@ -106,6 +110,7 @@ typedef struct SDL_GameControllerButtonBind
  *          nGameControllers++;
  *      }
  *  }
+ *  ```
  *
  *  Using the SDL_HINT_GAMECONTROLLERCONFIG hint or the SDL_GameControllerAddMapping() you can add support for controllers SDL is unaware of or cause an existing controller to have a different binding. The format is:
  *  guid,name,mappings
@@ -119,17 +124,39 @@ typedef struct SDL_GameControllerButtonBind
  *  Buttons can be used as a controller axis and vice versa.
  *
  *  This string shows an example of a valid mapping for a controller
- *  "03000000341a00003608000000000000,PS3 Controller,a:b1,b:b2,y:b3,x:b0,start:b9,guide:b12,back:b8,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftshoulder:b4,rightshoulder:b5,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7",
  *
+ * ```c
+ * "03000000341a00003608000000000000,PS3 Controller,a:b1,b:b2,y:b3,x:b0,start:b9,guide:b12,back:b8,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftshoulder:b4,rightshoulder:b5,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7",
+ * ```
  */
 
 /**
- *  Load a set of mappings from a seekable SDL data stream (memory or file), filtered by the current SDL_GetPlatform()
- *  A community sourced database of controllers is available at https://raw.github.com/gabomdq/SDL_GameControllerDB/master/gamecontrollerdb.txt
+ * Load a set of Game Controller mappings from a seekable SDL data stream.
  *
- *  If \c freerw is non-zero, the stream will be closed after being read.
- * 
- * \return number of mappings added, -1 on error
+ * You can call this function several times, if needed, to load different
+ * database files.
+ *
+ * If a new mapping is loaded for an already known controller GUID, the later
+ * version will overwrite the one currently loaded.
+ *
+ * Mappings not belonging to the current platform or with no platform field
+ * specified will be ignored (i.e. mappings for Linux will be ignored in
+ * Windows, etc).
+ *
+ * This function will load the text database entirely in memory before
+ * processing it, so take this into consideration if you are in a memory
+ * constrained environment.
+ *
+ * \param rw the data stream for the mappings to be added
+ * \param freerw non-zero to close the stream after being read
+ * \returns the number of mappings added or -1 on error; call SDL_GetError()
+ *          for more information.
+ *
+ * \since This function is available since SDL 2.0.2.
+ *
+ * \sa SDL_GameControllerAddMapping
+ * \sa SDL_GameControllerAddMappingsFromFile
+ * \sa SDL_GameControllerMappingForGUID
  */
 extern DECLSPEC int SDLCALL SDL_GameControllerAddMappingsFromRW(SDL_RWops * rw, int freerw);
 
@@ -141,161 +168,372 @@ extern DECLSPEC int SDLCALL SDL_GameControllerAddMappingsFromRW(SDL_RWops * rw,
 #define SDL_GameControllerAddMappingsFromFile(file)   SDL_GameControllerAddMappingsFromRW(SDL_RWFromFile(file, "rb"), 1)
 
 /**
- *  Add or update an existing mapping configuration
+ * Add support for controllers that SDL is unaware of or to cause an existing
+ * controller to have a different binding.
  *
- * \return 1 if mapping is added, 0 if updated, -1 on error
+ * The mapping string has the format "GUID,name,mapping", where GUID is the
+ * string value from SDL_JoystickGetGUIDString(), name is the human readable
+ * string for the device and mappings are controller mappings to joystick
+ * ones. Under Windows there is a reserved GUID of "xinput" that covers all
+ * XInput devices. The mapping format for joystick is: {| |bX |a joystick
+ * button, index X |- |hX.Y |hat X with value Y |- |aX |axis X of the joystick
+ * |} Buttons can be used as a controller axes and vice versa.
+ *
+ * This string shows an example of a valid mapping for a controller:
+ *
+ * ```c
+ * "341a3608000000000000504944564944,Afterglow PS3 Controller,a:b1,b:b2,y:b3,x:b0,start:b9,guide:b12,back:b8,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftshoulder:b4,rightshoulder:b5,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7"
+ * ```
+ *
+ * \param mappingString the mapping string
+ * \returns 1 if a new mapping is added, 0 if an existing mapping is updated,
+ *          -1 on error; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GameControllerMapping
+ * \sa SDL_GameControllerMappingForGUID
  */
 extern DECLSPEC int SDLCALL SDL_GameControllerAddMapping(const char* mappingString);
 
 /**
- *  Get the number of mappings installed
+ * Get the number of mappings installed.
  *
- *  \return the number of mappings
+ * \returns the number of mappings.
+ *
+ * \since This function is available since SDL 2.0.6.
  */
 extern DECLSPEC int SDLCALL SDL_GameControllerNumMappings(void);
 
 /**
- *  Get the mapping at a particular index.
+ * Get the mapping at a particular index.
  *
- *  \return the mapping string.  Must be freed with SDL_free().  Returns NULL if the index is out of range.
+ * \returns the mapping string. Must be freed with SDL_free(). Returns NULL if
+ *          the index is out of range.
+ *
+ * \since This function is available since SDL 2.0.6.
  */
 extern DECLSPEC char * SDLCALL SDL_GameControllerMappingForIndex(int mapping_index);
 
 /**
- *  Get a mapping string for a GUID
+ * Get the game controller mapping string for a given GUID.
  *
- *  \return the mapping string.  Must be freed with SDL_free().  Returns NULL if no mapping is available
+ * The returned string must be freed with SDL_free().
+ *
+ * \param guid a structure containing the GUID for which a mapping is desired
+ * \returns a mapping string or NULL on error; call SDL_GetError() for more
+ *          information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_JoystickGetDeviceGUID
+ * \sa SDL_JoystickGetGUID
  */
 extern DECLSPEC char * SDLCALL SDL_GameControllerMappingForGUID(SDL_JoystickGUID guid);
 
 /**
- *  Get a mapping string for an open GameController
+ * Get the current mapping of a Game Controller.
  *
- *  \return the mapping string.  Must be freed with SDL_free().  Returns NULL if no mapping is available
+ * The returned string must be freed with SDL_free().
+ *
+ * Details about mappings are discussed with SDL_GameControllerAddMapping().
+ *
+ * \param gamecontroller the game controller you want to get the current
+ *                       mapping for
+ * \returns a string that has the controller's mapping or NULL if no mapping
+ *          is available; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GameControllerAddMapping
+ * \sa SDL_GameControllerMappingForGUID
  */
 extern DECLSPEC char * SDLCALL SDL_GameControllerMapping(SDL_GameController *gamecontroller);
 
 /**
- *  Is the joystick on this index supported by the game controller interface?
+ * Check if the given joystick is supported by the game controller interface.
+ *
+ * `joystick_index` is the same as the `device_index` passed to
+ * SDL_JoystickOpen().
+ *
+ * \param joystick_index the device_index of a device, up to
+ *                       SDL_NumJoysticks()
+ * \returns SDL_TRUE if the given joystick is supported by the game controller
+ *          interface, SDL_FALSE if it isn't or it's an invalid index.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GameControllerNameForIndex
+ * \sa SDL_GameControllerOpen
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_IsGameController(int joystick_index);
 
 /**
- *  Get the implementation dependent name of a game controller.
- *  This can be called before any controllers are opened.
- *  If no name can be found, this function returns NULL.
+ * Get the implementation dependent name for the game controller.
+ *
+ * This function can be called before any controllers are opened.
+ *
+ * `joystick_index` is the same as the `device_index` passed to
+ * SDL_JoystickOpen().
+ *
+ * \param joystick_index the device_index of a device, from zero to
+ *                       SDL_NumJoysticks()-1
+ * \returns the implementation-dependent name for the game controller, or NULL
+ *          if there is no name or the index is invalid.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GameControllerName
+ * \sa SDL_GameControllerOpen
+ * \sa SDL_IsGameController
  */
 extern DECLSPEC const char *SDLCALL SDL_GameControllerNameForIndex(int joystick_index);
 
 /**
- *  Get the type of a game controller.
- *  This can be called before any controllers are opened.
+ * Get the type of a game controller.
+ *
+ * This can be called before any controllers are opened.
+ *
+ * \param joystick_index the device_index of a device, from zero to
+ *                       SDL_NumJoysticks()-1
+ * \returns the controller type.
+ *
+ * \since This function is available since SDL 2.0.12.
  */
 extern DECLSPEC SDL_GameControllerType SDLCALL SDL_GameControllerTypeForIndex(int joystick_index);
 
 /**
- *  Get the mapping of a game controller.
- *  This can be called before any controllers are opened.
+ * Get the mapping of a game controller.
  *
- *  \return the mapping string.  Must be freed with SDL_free().  Returns NULL if no mapping is available
+ * This can be called before any controllers are opened.
+ *
+ * \param joystick_index the device_index of a device, from zero to
+ *                       SDL_NumJoysticks()-1
+ * \returns the mapping string. Must be freed with SDL_free(). Returns NULL if
+ *          no mapping is available.
+ *
+ * \since This function is available since SDL 2.0.9.
  */
 extern DECLSPEC char *SDLCALL SDL_GameControllerMappingForDeviceIndex(int joystick_index);
 
 /**
- *  Open a game controller for use.
- *  The index passed as an argument refers to the N'th game controller on the system.
- *  This index is not the value which will identify this controller in future
- *  controller events.  The joystick's instance id (::SDL_JoystickID) will be
- *  used there instead.
+ * Open a game controller for use.
  *
- *  \return A controller identifier, or NULL if an error occurred.
+ * `joystick_index` is the same as the `device_index` passed to
+ * SDL_JoystickOpen().
+ *
+ * The index passed as an argument refers to the N'th game controller on the
+ * system. This index is not the value which will identify this controller in
+ * future controller events. The joystick's instance id (SDL_JoystickID) will
+ * be used there instead.
+ *
+ * \param joystick_index the device_index of a device, up to
+ *                       SDL_NumJoysticks()
+ * \returns a gamecontroller identifier or NULL if an error occurred; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GameControllerClose
+ * \sa SDL_GameControllerNameForIndex
+ * \sa SDL_IsGameController
  */
 extern DECLSPEC SDL_GameController *SDLCALL SDL_GameControllerOpen(int joystick_index);
 
 /**
- * Return the SDL_GameController associated with an instance id.
+ * Get the SDL_GameController associated with an instance id.
+ *
+ * \param joyid the instance id to get the SDL_GameController for
+ * \returns an SDL_GameController on success or NULL on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.4.
  */
 extern DECLSPEC SDL_GameController *SDLCALL SDL_GameControllerFromInstanceID(SDL_JoystickID joyid);
 
 /**
- * Return the SDL_GameController associated with a player index.
+ * Get the SDL_GameController associated with a player index.
+ *
+ * Please note that the player index is _not_ the device index, nor is it the
+ * instance id!
+ *
+ * \param player_index the player index, which is not the device index or the
+ *                     instance id!
+ * \returns the SDL_GameController associated with a player index.
+ *
+ * \since This function is available since SDL 2.0.12.
+ *
+ * \sa SDL_GameControllerGetPlayerIndex
+ * \sa SDL_GameControllerSetPlayerIndex
  */
 extern DECLSPEC SDL_GameController *SDLCALL SDL_GameControllerFromPlayerIndex(int player_index);
 
 /**
- *  Return the name for this currently opened controller
+ * Get the implementation-dependent name for an opened game controller.
+ *
+ * This is the same name as returned by SDL_GameControllerNameForIndex(), but
+ * it takes a controller identifier instead of the (unstable) device index.
+ *
+ * \param gamecontroller a game controller identifier previously returned by
+ *                       SDL_GameControllerOpen()
+ * \returns the implementation dependent name for the game controller, or NULL
+ *          if there is no name or the identifier passed is invalid.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GameControllerNameForIndex
+ * \sa SDL_GameControllerOpen
  */
 extern DECLSPEC const char *SDLCALL SDL_GameControllerName(SDL_GameController *gamecontroller);
 
 /**
- *  Return the type of this currently opened controller
+ * Get the type of this currently opened controller
+ *
+ * This is the same name as returned by SDL_GameControllerTypeForIndex(), but
+ * it takes a controller identifier instead of the (unstable) device index.
+ *
+ * \param gamecontroller the game controller object to query.
+ * \returns the controller type.
+ *
+ * \since This function is available since SDL 2.0.12.
  */
 extern DECLSPEC SDL_GameControllerType SDLCALL SDL_GameControllerGetType(SDL_GameController *gamecontroller);
 
 /**
- *  Get the player index of an opened game controller, or -1 if it's not available
+ * Get the player index of an opened game controller.
  *
- *  For XInput controllers this returns the XInput user index.
+ * For XInput controllers this returns the XInput user index.
+ *
+ * \param gamecontroller the game controller object to query.
+ * \returns the player index for controller, or -1 if it's not available.
+ *
+ * \since This function is available since SDL 2.0.9.
  */
 extern DECLSPEC int SDLCALL SDL_GameControllerGetPlayerIndex(SDL_GameController *gamecontroller);
 
 /**
- *  Set the player index of an opened game controller
+ * Set the player index of an opened game controller.
+ *
+ * \param gamecontroller the game controller object to adjust.
+ * \param player_index Player index to assign to this controller.
+ *
+ * \since This function is available since SDL 2.0.12.
  */
 extern DECLSPEC void SDLCALL SDL_GameControllerSetPlayerIndex(SDL_GameController *gamecontroller, int player_index);
 
 /**
- *  Get the USB vendor ID of an opened controller, if available.
- *  If the vendor ID isn't available this function returns 0.
+ * Get the USB vendor ID of an opened controller, if available.
+ *
+ * If the vendor ID isn't available this function returns 0.
+ *
+ * \param gamecontroller the game controller object to query.
+ * \return the USB vendor ID, or zero if unavailable.
+ *
+ * \since This function is available since SDL 2.0.6.
  */
 extern DECLSPEC Uint16 SDLCALL SDL_GameControllerGetVendor(SDL_GameController *gamecontroller);
 
 /**
- *  Get the USB product ID of an opened controller, if available.
- *  If the product ID isn't available this function returns 0.
+ * Get the USB product ID of an opened controller, if available.
+ *
+ * If the product ID isn't available this function returns 0.
+ *
+ * \param gamecontroller the game controller object to query.
+ * \return the USB product ID, or zero if unavailable.
+ *
+ * \since This function is available since SDL 2.0.6.
  */
 extern DECLSPEC Uint16 SDLCALL SDL_GameControllerGetProduct(SDL_GameController *gamecontroller);
 
 /**
- *  Get the product version of an opened controller, if available.
- *  If the product version isn't available this function returns 0.
+ * Get the product version of an opened controller, if available.
+ *
+ * If the product version isn't available this function returns 0.
+ *
+ * \param gamecontroller the game controller object to query.
+ * \return the USB product version, or zero if unavailable.
+ *
+ * \since This function is available since SDL 2.0.6.
  */
 extern DECLSPEC Uint16 SDLCALL SDL_GameControllerGetProductVersion(SDL_GameController *gamecontroller);
 
 /**
- *  Get the serial number of an opened controller, if available.
- * 
- *  Returns the serial number of the controller, or NULL if it is not available.
+ * Get the serial number of an opened controller, if available.
+ *
+ * Returns the serial number of the controller, or NULL if it is not
+ * available.
+ *
+ * \param gamecontroller the game controller object to query.
+ * \return the serial number, or NULL if unavailable.
+ *
+ * \since This function is available since SDL 2.0.14.
  */
 extern DECLSPEC const char * SDLCALL SDL_GameControllerGetSerial(SDL_GameController *gamecontroller);
 
 /**
- *  Returns SDL_TRUE if the controller has been opened and currently connected,
- *  or SDL_FALSE if it has not.
+ * Check if a controller has been opened and is currently connected.
+ *
+ * \param gamecontroller a game controller identifier previously returned by
+ *                       SDL_GameControllerOpen()
+ * \returns SDL_TRUE if the controller has been opened and is currently
+ *          connected, or SDL_FALSE if not.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GameControllerClose
+ * \sa SDL_GameControllerOpen
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_GameControllerGetAttached(SDL_GameController *gamecontroller);
 
 /**
- *  Get the underlying joystick object used by a controller
+ * Get the Joystick ID from a Game Controller.
+ *
+ * This function will give you a SDL_Joystick object, which allows you to use
+ * the SDL_Joystick functions with a SDL_GameController object. This would be
+ * useful for getting a joystick's position at any given time, even if it
+ * hasn't moved (moving it would produce an event, which would have the axis'
+ * value).
+ *
+ * The pointer returned is owned by the SDL_GameController. You should not
+ * call SDL_JoystickClose() on it, for example, since doing so will likely
+ * cause SDL to crash.
+ *
+ * \param gamecontroller the game controller object that you want to get a
+ *                       joystick from
+ * \returns a SDL_Joystick object; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC SDL_Joystick *SDLCALL SDL_GameControllerGetJoystick(SDL_GameController *gamecontroller);
 
 /**
- *  Enable/disable controller event polling.
+ * Query or change current state of Game Controller events.
  *
- *  If controller events are disabled, you must call SDL_GameControllerUpdate()
- *  yourself and check the state of the controller when you want controller
- *  information.
+ * If controller events are disabled, you must call SDL_GameControllerUpdate()
+ * yourself and check the state of the controller when you want controller
+ * information.
  *
- *  The state can be one of ::SDL_QUERY, ::SDL_ENABLE or ::SDL_IGNORE.
+ * Any number can be passed to SDL_GameControllerEventState(), but only -1, 0,
+ * and 1 will have any effect. Other numbers will just be returned.
+ *
+ * \param state can be one of `SDL_QUERY`, `SDL_IGNORE`, or `SDL_ENABLE`
+ * \returns the same value passed to the function, with exception to -1
+ *          (SDL_QUERY), which will return the current state.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_JoystickEventState
  */
 extern DECLSPEC int SDLCALL SDL_GameControllerEventState(int state);
 
 /**
- *  Update the current state of the open game controllers.
+ * Manually pump game controller updates if not using the loop.
  *
- *  This is called automatically by the event loop if any game controller
- *  events are enabled.
+ * This function is called automatically by the event loop if events are
+ * enabled. Under such circumstances, it will not be necessary to call this
+ * function.
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC void SDLCALL SDL_GameControllerUpdate(void);
 
@@ -322,35 +560,91 @@ typedef enum
 } SDL_GameControllerAxis;
 
 /**
- *  turn this string into a axis mapping
+ * Convert a string into SDL_GameControllerAxis enum.
+ *
+ * This function is called internally to translate SDL_GameController mapping
+ * strings for the underlying joystick device into the consistent
+ * SDL_GameController mapping. You do not normally need to call this function
+ * unless you are parsing SDL_GameController mappings in your own code.
+ *
+ * Note specially that "righttrigger" and "lefttrigger" map to
+ * `SDL_CONTROLLER_AXIS_TRIGGERRIGHT` and `SDL_CONTROLLER_AXIS_TRIGGERLEFT`,
+ * respectively.
+ *
+ * \param str string representing a SDL_GameController axis
+ * \returns the SDL_GameControllerAxis enum corresponding to the input string,
+ *          or `SDL_CONTROLLER_AXIS_INVALID` if no match was found.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GameControllerGetStringForAxis
  */
-extern DECLSPEC SDL_GameControllerAxis SDLCALL SDL_GameControllerGetAxisFromString(const char *pchString);
+extern DECLSPEC SDL_GameControllerAxis SDLCALL SDL_GameControllerGetAxisFromString(const char *str);
 
 /**
- *  turn this axis enum into a string mapping
+ * Convert from an SDL_GameControllerAxis enum to a string.
+ *
+ * The caller should not SDL_free() the returned string.
+ *
+ * \param axis an enum value for a given SDL_GameControllerAxis
+ * \returns a string for the given axis, or NULL if an invalid axis is
+ *          specified. The string returned is of the format used by
+ *          SDL_GameController mapping strings.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GameControllerGetAxisFromString
  */
 extern DECLSPEC const char* SDLCALL SDL_GameControllerGetStringForAxis(SDL_GameControllerAxis axis);
 
 /**
- *  Get the SDL joystick layer binding for this controller button mapping
+ * Get the SDL joystick layer binding for a controller axis mapping.
+ *
+ * \param gamecontroller a game controller
+ * \param axis an axis enum value (one of the SDL_GameControllerAxis values)
+ * \returns a SDL_GameControllerButtonBind describing the bind. On failure
+ *          (like the given Controller axis doesn't exist on the device), its
+ *          `.bindType` will be `SDL_CONTROLLER_BINDTYPE_NONE`.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GameControllerGetBindForButton
  */
 extern DECLSPEC SDL_GameControllerButtonBind SDLCALL
 SDL_GameControllerGetBindForAxis(SDL_GameController *gamecontroller,
                                  SDL_GameControllerAxis axis);
 
 /**
- *  Return whether a game controller has a given axis
+ * Query whether a game controller has a given axis.
+ *
+ * This merely reports whether the controller's mapping defined this axis, as
+ * that is all the information SDL has about the physical device.
+ *
+ * \param gamecontroller a game controller
+ * \param axis an axis enum value (an SDL_GameControllerAxis value)
+ * \returns SDL_TRUE if the controller has this axis, SDL_FALSE otherwise.
+ *
+ * \since This function is available since SDL 2.0.14.
  */
 extern DECLSPEC SDL_bool SDLCALL
 SDL_GameControllerHasAxis(SDL_GameController *gamecontroller, SDL_GameControllerAxis axis);
 
 /**
- *  Get the current state of an axis control on a game controller.
+ * Get the current state of an axis control on a game controller.
  *
- *  The state is a value ranging from -32768 to 32767 (except for the triggers,
- *  which range from 0 to 32767).
+ * The axis indices start at index 0.
  *
- *  The axis indices start at index 0.
+ * The state is a value ranging from -32768 to 32767. Triggers, however, range
+ * from 0 to 32767 (they never return a negative value).
+ *
+ * \param gamecontroller a game controller
+ * \param axis an axis index (one of the SDL_GameControllerAxis values)
+ * \returns axis state (including 0) on success or 0 (also) on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GameControllerGetButton
  */
 extern DECLSPEC Sint16 SDLCALL
 SDL_GameControllerGetAxis(SDL_GameController *gamecontroller, SDL_GameControllerAxis axis);
@@ -376,7 +670,7 @@ typedef enum
     SDL_CONTROLLER_BUTTON_DPAD_DOWN,
     SDL_CONTROLLER_BUTTON_DPAD_LEFT,
     SDL_CONTROLLER_BUTTON_DPAD_RIGHT,
-    SDL_CONTROLLER_BUTTON_MISC1,    /* Xbox Series X share button, PS5 microphone button, Nintendo Switch Pro capture button */
+    SDL_CONTROLLER_BUTTON_MISC1,    /* Xbox Series X share button, PS5 microphone button, Nintendo Switch Pro capture button, Amazon Luna microphone button */
     SDL_CONTROLLER_BUTTON_PADDLE1,  /* Xbox Elite paddle P1 */
     SDL_CONTROLLER_BUTTON_PADDLE2,  /* Xbox Elite paddle P3 */
     SDL_CONTROLLER_BUTTON_PADDLE3,  /* Xbox Elite paddle P2 */
@@ -386,149 +680,316 @@ typedef enum
 } SDL_GameControllerButton;
 
 /**
- *  turn this string into a button mapping
+ * Convert a string into an SDL_GameControllerButton enum.
+ *
+ * This function is called internally to translate SDL_GameController mapping
+ * strings for the underlying joystick device into the consistent
+ * SDL_GameController mapping. You do not normally need to call this function
+ * unless you are parsing SDL_GameController mappings in your own code.
+ *
+ * \param str string representing a SDL_GameController axis
+ * \returns the SDL_GameControllerButton enum corresponding to the input
+ *          string, or `SDL_CONTROLLER_AXIS_INVALID` if no match was found.
+ *
+ * \since This function is available since SDL 2.0.0.
  */
-extern DECLSPEC SDL_GameControllerButton SDLCALL SDL_GameControllerGetButtonFromString(const char *pchString);
+extern DECLSPEC SDL_GameControllerButton SDLCALL SDL_GameControllerGetButtonFromString(const char *str);
 
 /**
- *  turn this button enum into a string mapping
+ * Convert from an SDL_GameControllerButton enum to a string.
+ *
+ * The caller should not SDL_free() the returned string.
+ *
+ * \param button an enum value for a given SDL_GameControllerButton
+ * \returns a string for the given button, or NULL if an invalid axis is
+ *          specified. The string returned is of the format used by
+ *          SDL_GameController mapping strings.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GameControllerGetButtonFromString
  */
 extern DECLSPEC const char* SDLCALL SDL_GameControllerGetStringForButton(SDL_GameControllerButton button);
 
 /**
- *  Get the SDL joystick layer binding for this controller button mapping
+ * Get the SDL joystick layer binding for a controller button mapping.
+ *
+ * \param gamecontroller a game controller
+ * \param button an button enum value (an SDL_GameControllerButton value)
+ * \returns a SDL_GameControllerButtonBind describing the bind. On failure
+ *          (like the given Controller button doesn't exist on the device),
+ *          its `.bindType` will be `SDL_CONTROLLER_BINDTYPE_NONE`.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GameControllerGetBindForAxis
  */
 extern DECLSPEC SDL_GameControllerButtonBind SDLCALL
 SDL_GameControllerGetBindForButton(SDL_GameController *gamecontroller,
                                    SDL_GameControllerButton button);
 
 /**
- *  Return whether a game controller has a given button
+ * Query whether a game controller has a given button.
+ *
+ * This merely reports whether the controller's mapping defined this button,
+ * as that is all the information SDL has about the physical device.
+ *
+ * \param gamecontroller a game controller
+ * \param button a button enum value (an SDL_GameControllerButton value)
+ * \returns SDL_TRUE if the controller has this button, SDL_FALSE otherwise.
+ *
+ * \since This function is available since SDL 2.0.14.
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_GameControllerHasButton(SDL_GameController *gamecontroller,
                                                              SDL_GameControllerButton button);
 
 /**
- *  Get the current state of a button on a game controller.
+ * Get the current state of a button on a game controller.
  *
- *  The button indices start at index 0.
+ * \param gamecontroller a game controller
+ * \param button a button index (one of the SDL_GameControllerButton values)
+ * \returns 1 for pressed state or 0 for not pressed state or error; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GameControllerGetAxis
  */
 extern DECLSPEC Uint8 SDLCALL SDL_GameControllerGetButton(SDL_GameController *gamecontroller,
                                                           SDL_GameControllerButton button);
 
 /**
- *  Get the number of touchpads on a game controller.
+ * Get the number of touchpads on a game controller.
+ *
+ * \since This function is available since SDL 2.0.14.
  */
 extern DECLSPEC int SDLCALL SDL_GameControllerGetNumTouchpads(SDL_GameController *gamecontroller);
 
 /**
- *  Get the number of supported simultaneous fingers on a touchpad on a game controller.
+ * Get the number of supported simultaneous fingers on a touchpad on a game
+ * controller.
+ *
+ * \since This function is available since SDL 2.0.14.
  */
 extern DECLSPEC int SDLCALL SDL_GameControllerGetNumTouchpadFingers(SDL_GameController *gamecontroller, int touchpad);
 
 /**
- *  Get the current state of a finger on a touchpad on a game controller.
+ * Get the current state of a finger on a touchpad on a game controller.
+ *
+ * \since This function is available since SDL 2.0.14.
  */
 extern DECLSPEC int SDLCALL SDL_GameControllerGetTouchpadFinger(SDL_GameController *gamecontroller, int touchpad, int finger, Uint8 *state, float *x, float *y, float *pressure);
 
 /**
- *  Return whether a game controller has a particular sensor.
+ * Return whether a game controller has a particular sensor.
  *
- *  \param gamecontroller The controller to query
- *  \param type The type of sensor to query
+ * \param gamecontroller The controller to query
+ * \param type The type of sensor to query
+ * \returns SDL_TRUE if the sensor exists, SDL_FALSE otherwise.
  *
- *  \return SDL_TRUE if the sensor exists, SDL_FALSE otherwise.
+ * \since This function is available since SDL 2.0.14.
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_GameControllerHasSensor(SDL_GameController *gamecontroller, SDL_SensorType type);
 
 /**
- *  Set whether data reporting for a game controller sensor is enabled
+ * Set whether data reporting for a game controller sensor is enabled.
  *
- *  \param gamecontroller The controller to update
- *  \param type The type of sensor to enable/disable
- *  \param enabled Whether data reporting should be enabled
+ * \param gamecontroller The controller to update
+ * \param type The type of sensor to enable/disable
+ * \param enabled Whether data reporting should be enabled
+ * \returns 0 or -1 if an error occurred.
  *
- *  \return 0 or -1 if an error occurred.
+ * \since This function is available since SDL 2.0.14.
  */
 extern DECLSPEC int SDLCALL SDL_GameControllerSetSensorEnabled(SDL_GameController *gamecontroller, SDL_SensorType type, SDL_bool enabled);
 
 /**
- *  Query whether sensor data reporting is enabled for a game controller
+ * Query whether sensor data reporting is enabled for a game controller.
  *
- *  \param gamecontroller The controller to query
- *  \param type The type of sensor to query
+ * \param gamecontroller The controller to query
+ * \param type The type of sensor to query
+ * \returns SDL_TRUE if the sensor is enabled, SDL_FALSE otherwise.
  *
- *  \return SDL_TRUE if the sensor is enabled, SDL_FALSE otherwise.
+ * \since This function is available since SDL 2.0.14.
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_GameControllerIsSensorEnabled(SDL_GameController *gamecontroller, SDL_SensorType type);
 
 /**
- *  Get the current state of a game controller sensor.
+ * Get the data rate (number of events per second) of a game controller
+ * sensor.
  *
- *  The number of values and interpretation of the data is sensor dependent.
- *  See SDL_sensor.h for the details for each type of sensor.
+ * \param gamecontroller The controller to query
+ * \param type The type of sensor to query
+ * \return the data rate, or 0.0f if the data rate is not available.
  *
- *  \param gamecontroller The controller to query
- *  \param type The type of sensor to query
- *  \param data A pointer filled with the current sensor state
- *  \param num_values The number of values to write to data
+ * \since This function is available since SDL 2.0.16.
+ */
+extern DECLSPEC float SDLCALL SDL_GameControllerGetSensorDataRate(SDL_GameController *gamecontroller, SDL_SensorType type);
+
+/**
+ * Get the current state of a game controller sensor.
  *
- *  \return 0 or -1 if an error occurred.
+ * The number of values and interpretation of the data is sensor dependent.
+ * See SDL_sensor.h for the details for each type of sensor.
+ *
+ * \param gamecontroller The controller to query
+ * \param type The type of sensor to query
+ * \param data A pointer filled with the current sensor state
+ * \param num_values The number of values to write to data
+ * \return 0 or -1 if an error occurred.
+ *
+ * \since This function is available since SDL 2.0.14.
  */
 extern DECLSPEC int SDLCALL SDL_GameControllerGetSensorData(SDL_GameController *gamecontroller, SDL_SensorType type, float *data, int num_values);
 
 /**
- *  Start a rumble effect
- *  Each call to this function cancels any previous rumble effect, and calling it with 0 intensity stops any rumbling.
+ * Start a rumble effect on a game controller.
  *
- *  \param gamecontroller The controller to vibrate
- *  \param low_frequency_rumble The intensity of the low frequency (left) rumble motor, from 0 to 0xFFFF
- *  \param high_frequency_rumble The intensity of the high frequency (right) rumble motor, from 0 to 0xFFFF
- *  \param duration_ms The duration of the rumble effect, in milliseconds
+ * Each call to this function cancels any previous rumble effect, and calling
+ * it with 0 intensity stops any rumbling.
  *
- *  \return 0, or -1 if rumble isn't supported on this controller
+ * \param gamecontroller The controller to vibrate
+ * \param low_frequency_rumble The intensity of the low frequency (left)
+ *                             rumble motor, from 0 to 0xFFFF
+ * \param high_frequency_rumble The intensity of the high frequency (right)
+ *                              rumble motor, from 0 to 0xFFFF
+ * \param duration_ms The duration of the rumble effect, in milliseconds
+ * \returns 0, or -1 if rumble isn't supported on this controller
+ *
+ * \since This function is available since SDL 2.0.9.
+ *
+ * \sa SDL_GameControllerHasRumble
  */
 extern DECLSPEC int SDLCALL SDL_GameControllerRumble(SDL_GameController *gamecontroller, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble, Uint32 duration_ms);
 
 /**
- *  Start a rumble effect in the game controller's triggers
- *  Each call to this function cancels any previous trigger rumble effect, and calling it with 0 intensity stops any rumbling.
+ * Start a rumble effect in the game controller's triggers.
  *
- *  \param gamecontroller The controller to vibrate
- *  \param left_rumble The intensity of the left trigger rumble motor, from 0 to 0xFFFF
- *  \param right_rumble The intensity of the right trigger rumble motor, from 0 to 0xFFFF
- *  \param duration_ms The duration of the rumble effect, in milliseconds
+ * Each call to this function cancels any previous trigger rumble effect, and
+ * calling it with 0 intensity stops any rumbling.
  *
- *  \return 0, or -1 if rumble isn't supported on this controller
+ * Note that this is rumbling of the _triggers_ and not the game controller as
+ * a whole. This is currently only supported on Xbox One controllers. If you
+ * want the (more common) whole-controller rumble, use
+ * SDL_GameControllerRumble() instead.
+ *
+ * \param gamecontroller The controller to vibrate
+ * \param left_rumble The intensity of the left trigger rumble motor, from 0
+ *                    to 0xFFFF
+ * \param right_rumble The intensity of the right trigger rumble motor, from 0
+ *                     to 0xFFFF
+ * \param duration_ms The duration of the rumble effect, in milliseconds
+ * \returns 0, or -1 if trigger rumble isn't supported on this controller
+ *
+ * \since This function is available since SDL 2.0.14.
+ *
+ * \sa SDL_GameControllerHasRumbleTriggers
  */
 extern DECLSPEC int SDLCALL SDL_GameControllerRumbleTriggers(SDL_GameController *gamecontroller, Uint16 left_rumble, Uint16 right_rumble, Uint32 duration_ms);
 
 /**
- *  Return whether a controller has an LED
+ * Query whether a game controller has an LED.
  *
- *  \param gamecontroller The controller to query
+ * \param gamecontroller The controller to query
+ * \returns SDL_TRUE, or SDL_FALSE if this controller does not have a
+ *          modifiable LED
  *
- *  \return SDL_TRUE, or SDL_FALSE if this controller does not have a modifiable LED
+ * \since This function is available since SDL 2.0.14.
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_GameControllerHasLED(SDL_GameController *gamecontroller);
 
 /**
- *  Update a controller's LED color.
+ * Query whether a game controller has rumble support.
  *
- *  \param gamecontroller The controller to update
- *  \param red The intensity of the red LED
- *  \param green The intensity of the green LED
- *  \param blue The intensity of the blue LED
+ * \param gamecontroller The controller to query
+ * \returns SDL_TRUE, or SDL_FALSE if this controller does not have rumble
+ *          support
  *
- *  \return 0, or -1 if this controller does not have a modifiable LED
+ * \since This function is available since SDL 2.0.18.
+ *
+ * \sa SDL_GameControllerRumble
+ */
+extern DECLSPEC SDL_bool SDLCALL SDL_GameControllerHasRumble(SDL_GameController *gamecontroller);
+
+/**
+ * Query whether a game controller has rumble support on triggers.
+ *
+ * \param gamecontroller The controller to query
+ * \returns SDL_TRUE, or SDL_FALSE if this controller does not have trigger
+ *          rumble support
+ *
+ * \since This function is available since SDL 2.0.18.
+ *
+ * \sa SDL_GameControllerRumbleTriggers
+ */
+extern DECLSPEC SDL_bool SDLCALL SDL_GameControllerHasRumbleTriggers(SDL_GameController *gamecontroller);
+
+/**
+ * Update a game controller's LED color.
+ *
+ * \param gamecontroller The controller to update
+ * \param red The intensity of the red LED
+ * \param green The intensity of the green LED
+ * \param blue The intensity of the blue LED
+ * \returns 0, or -1 if this controller does not have a modifiable LED
+ *
+ * \since This function is available since SDL 2.0.14.
  */
 extern DECLSPEC int SDLCALL SDL_GameControllerSetLED(SDL_GameController *gamecontroller, Uint8 red, Uint8 green, Uint8 blue);
 
 /**
- *  Close a controller previously opened with SDL_GameControllerOpen().
+ * Send a controller specific effect packet
+ *
+ * \param gamecontroller The controller to affect
+ * \param data The data to send to the controller
+ * \param size The size of the data to send to the controller
+ * \returns 0, or -1 if this controller or driver doesn't support effect
+ *          packets
+ *
+ * \since This function is available since SDL 2.0.16.
+ */
+extern DECLSPEC int SDLCALL SDL_GameControllerSendEffect(SDL_GameController *gamecontroller, const void *data, int size);
+
+/**
+ * Close a game controller previously opened with SDL_GameControllerOpen().
+ *
+ * \param gamecontroller a game controller identifier previously returned by
+ *                       SDL_GameControllerOpen()
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GameControllerOpen
  */
 extern DECLSPEC void SDLCALL SDL_GameControllerClose(SDL_GameController *gamecontroller);
 
+/**
+ * Return the sfSymbolsName for a given button on a game controller on Apple
+ * platforms.
+ *
+ * \param gamecontroller the controller to query
+ * \param button a button on the game controller
+ * \returns the sfSymbolsName or NULL if the name can't be found
+ *
+ * \since This function is available since SDL 2.0.18.
+ *
+ * \sa SDL_GameControllerGetAppleSFSymbolsNameForAxis
+ */
+extern DECLSPEC const char* SDLCALL SDL_GameControllerGetAppleSFSymbolsNameForButton(SDL_GameController *gamecontroller, SDL_GameControllerButton button);
+
+/**
+ * Return the sfSymbolsName for a given axis on a game controller on Apple
+ * platforms.
+ *
+ * \param gamecontroller the controller to query
+ * \param axis an axis on the game controller
+ * \returns the sfSymbolsName or NULL if the name can't be found
+ *
+ * \since This function is available since SDL 2.0.18.
+ *
+ * \sa SDL_GameControllerGetAppleSFSymbolsNameForButton
+ */
+extern DECLSPEC const char* SDLCALL SDL_GameControllerGetAppleSFSymbolsNameForAxis(SDL_GameController *gamecontroller, SDL_GameControllerAxis axis);
+
 
 /* Ends C function definitions when using C++ */
 #ifdef __cplusplus
diff --git a/Engine/lib/sdl/include/SDL_gesture.h b/Engine/lib/sdl/include/SDL_gesture.h
index 81ed43173..e2caea2a9 100644
--- a/Engine/lib/sdl/include/SDL_gesture.h
+++ b/Engine/lib/sdl/include/SDL_gesture.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -46,36 +46,66 @@ typedef Sint64 SDL_GestureID;
 /* Function prototypes */
 
 /**
- *  \brief Begin Recording a gesture on the specified touch, or all touches (-1)
+ * Begin recording a gesture on a specified touch device or all touch devices.
  *
+ * If the parameter `touchId` is -1 (i.e., all devices), this function will
+ * always return 1, regardless of whether there actually are any devices.
  *
+ * \param touchId the touch device id, or -1 for all touch devices
+ * \returns 1 on success or 0 if the specified device could not be found.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetTouchDevice
  */
 extern DECLSPEC int SDLCALL SDL_RecordGesture(SDL_TouchID touchId);
 
 
 /**
- *  \brief Save all currently loaded Dollar Gesture templates
+ * Save all currently loaded Dollar Gesture templates.
  *
+ * \param dst a SDL_RWops to save to
+ * \returns the number of saved templates on success or 0 on failure; call
+ *          SDL_GetError() for more information.
  *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_LoadDollarTemplates
+ * \sa SDL_SaveDollarTemplate
  */
 extern DECLSPEC int SDLCALL SDL_SaveAllDollarTemplates(SDL_RWops *dst);
 
 /**
- *  \brief Save a currently loaded Dollar Gesture template
+ * Save a currently loaded Dollar Gesture template.
  *
+ * \param gestureId a gesture id
+ * \param dst a SDL_RWops to save to
+ * \returns 1 on success or 0 on failure; call SDL_GetError() for more
+ *          information.
  *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_LoadDollarTemplates
+ * \sa SDL_SaveAllDollarTemplates
  */
 extern DECLSPEC int SDLCALL SDL_SaveDollarTemplate(SDL_GestureID gestureId,SDL_RWops *dst);
 
 
 /**
- *  \brief Load Dollar Gesture templates from a file
+ * Load Dollar Gesture templates from a file.
  *
+ * \param touchId a touch id
+ * \param src a SDL_RWops to load from
+ * \returns the number of loaded templates on success or a negative error code
+ *          (or 0) on failure; call SDL_GetError() for more information.
  *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_SaveAllDollarTemplates
+ * \sa SDL_SaveDollarTemplate
  */
 extern DECLSPEC int SDLCALL SDL_LoadDollarTemplates(SDL_TouchID touchId, SDL_RWops *src);
 
-
 /* Ends C function definitions when using C++ */
 #ifdef __cplusplus
 }
diff --git a/Engine/lib/sdl/include/SDL_haptic.h b/Engine/lib/sdl/include/SDL_haptic.h
index c27da1186..f240ae927 100644
--- a/Engine/lib/sdl/include/SDL_haptic.h
+++ b/Engine/lib/sdl/include/SDL_haptic.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -76,7 +76,7 @@
  *    }
  *
  *    // Create the effect
- *    memset( &effect, 0, sizeof(SDL_HapticEffect) ); // 0 is safe default
+ *    SDL_memset( &effect, 0, sizeof(SDL_HapticEffect) ); // 0 is safe default
  *    effect.type = SDL_HAPTIC_SINE;
  *    effect.periodic.direction.type = SDL_HAPTIC_POLAR; // Polar coordinates
  *    effect.periodic.direction.dir[0] = 18000; // Force comes from south
@@ -820,419 +820,513 @@ typedef union SDL_HapticEffect
 
 
 /* Function prototypes */
+
 /**
- *  \brief Count the number of haptic devices attached to the system.
+ * Count the number of haptic devices attached to the system.
  *
- *  \return Number of haptic devices detected on the system.
+ * \returns the number of haptic devices detected on the system or a negative
+ *          error code on failure; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HapticName
  */
 extern DECLSPEC int SDLCALL SDL_NumHaptics(void);
 
 /**
- *  \brief Get the implementation dependent name of a haptic device.
+ * Get the implementation dependent name of a haptic device.
  *
- *  This can be called before any joysticks are opened.
- *  If no name can be found, this function returns NULL.
+ * This can be called before any joysticks are opened. If no name can be
+ * found, this function returns NULL.
  *
- *  \param device_index Index of the device to get its name.
- *  \return Name of the device or NULL on error.
+ * \param device_index index of the device to query.
+ * \returns the name of the device or NULL on failure; call SDL_GetError() for
+ *          more information.
  *
- *  \sa SDL_NumHaptics
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_NumHaptics
  */
 extern DECLSPEC const char *SDLCALL SDL_HapticName(int device_index);
 
 /**
- *  \brief Opens a haptic device for use.
+ * Open a haptic device for use.
  *
- *  The index passed as an argument refers to the N'th haptic device on this
- *  system.
+ * The index passed as an argument refers to the N'th haptic device on this
+ * system.
  *
- *  When opening a haptic device, its gain will be set to maximum and
- *  autocenter will be disabled.  To modify these values use
- *  SDL_HapticSetGain() and SDL_HapticSetAutocenter().
+ * When opening a haptic device, its gain will be set to maximum and
+ * autocenter will be disabled. To modify these values use SDL_HapticSetGain()
+ * and SDL_HapticSetAutocenter().
  *
- *  \param device_index Index of the device to open.
- *  \return Device identifier or NULL on error.
+ * \param device_index index of the device to open
+ * \returns the device identifier or NULL on failure; call SDL_GetError() for
+ *          more information.
  *
- *  \sa SDL_HapticIndex
- *  \sa SDL_HapticOpenFromMouse
- *  \sa SDL_HapticOpenFromJoystick
- *  \sa SDL_HapticClose
- *  \sa SDL_HapticSetGain
- *  \sa SDL_HapticSetAutocenter
- *  \sa SDL_HapticPause
- *  \sa SDL_HapticStopAll
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HapticClose
+ * \sa SDL_HapticIndex
+ * \sa SDL_HapticOpenFromJoystick
+ * \sa SDL_HapticOpenFromMouse
+ * \sa SDL_HapticPause
+ * \sa SDL_HapticSetAutocenter
+ * \sa SDL_HapticSetGain
+ * \sa SDL_HapticStopAll
  */
 extern DECLSPEC SDL_Haptic *SDLCALL SDL_HapticOpen(int device_index);
 
 /**
- *  \brief Checks if the haptic device at index has been opened.
+ * Check if the haptic device at the designated index has been opened.
  *
- *  \param device_index Index to check to see if it has been opened.
- *  \return 1 if it has been opened or 0 if it hasn't.
+ * \param device_index the index of the device to query
+ * \returns 1 if it has been opened, 0 if it hasn't or on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \sa SDL_HapticOpen
- *  \sa SDL_HapticIndex
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HapticIndex
+ * \sa SDL_HapticOpen
  */
 extern DECLSPEC int SDLCALL SDL_HapticOpened(int device_index);
 
 /**
- *  \brief Gets the index of a haptic device.
+ * Get the index of a haptic device.
  *
- *  \param haptic Haptic device to get the index of.
- *  \return The index of the haptic device or -1 on error.
+ * \param haptic the SDL_Haptic device to query
+ * \returns the index of the specified haptic device or a negative error code
+ *          on failure; call SDL_GetError() for more information.
  *
- *  \sa SDL_HapticOpen
- *  \sa SDL_HapticOpened
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HapticOpen
+ * \sa SDL_HapticOpened
  */
 extern DECLSPEC int SDLCALL SDL_HapticIndex(SDL_Haptic * haptic);
 
 /**
- *  \brief Gets whether or not the current mouse has haptic capabilities.
+ * Query whether or not the current mouse has haptic capabilities.
  *
- *  \return SDL_TRUE if the mouse is haptic, SDL_FALSE if it isn't.
+ * \returns SDL_TRUE if the mouse is haptic or SDL_FALSE if it isn't.
  *
- *  \sa SDL_HapticOpenFromMouse
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HapticOpenFromMouse
  */
 extern DECLSPEC int SDLCALL SDL_MouseIsHaptic(void);
 
 /**
- *  \brief Tries to open a haptic device from the current mouse.
+ * Try to open a haptic device from the current mouse.
  *
- *  \return The haptic device identifier or NULL on error.
+ * \returns the haptic device identifier or NULL on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \sa SDL_MouseIsHaptic
- *  \sa SDL_HapticOpen
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HapticOpen
+ * \sa SDL_MouseIsHaptic
  */
 extern DECLSPEC SDL_Haptic *SDLCALL SDL_HapticOpenFromMouse(void);
 
 /**
- *  \brief Checks to see if a joystick has haptic features.
+ * Query if a joystick has haptic features.
  *
- *  \param joystick Joystick to test for haptic capabilities.
- *  \return SDL_TRUE if the joystick is haptic, SDL_FALSE if it isn't
- *          or -1 if an error occurred.
+ * \param joystick the SDL_Joystick to test for haptic capabilities
+ * \returns SDL_TRUE if the joystick is haptic, SDL_FALSE if it isn't, or a
+ *          negative error code on failure; call SDL_GetError() for more
+ *          information.
  *
- *  \sa SDL_HapticOpenFromJoystick
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HapticOpenFromJoystick
  */
 extern DECLSPEC int SDLCALL SDL_JoystickIsHaptic(SDL_Joystick * joystick);
 
 /**
- *  \brief Opens a haptic device for use from a joystick device.
+ * Open a haptic device for use from a joystick device.
  *
- *  You must still close the haptic device separately.  It will not be closed
- *  with the joystick.
+ * You must still close the haptic device separately. It will not be closed
+ * with the joystick.
  *
- *  When opening from a joystick you should first close the haptic device before
- *  closing the joystick device.  If not, on some implementations the haptic
- *  device will also get unallocated and you'll be unable to use force feedback
- *  on that device.
+ * When opened from a joystick you should first close the haptic device before
+ * closing the joystick device. If not, on some implementations the haptic
+ * device will also get unallocated and you'll be unable to use force feedback
+ * on that device.
  *
- *  \param joystick Joystick to create a haptic device from.
- *  \return A valid haptic device identifier on success or NULL on error.
+ * \param joystick the SDL_Joystick to create a haptic device from
+ * \returns a valid haptic device identifier on success or NULL on failure;
+ *          call SDL_GetError() for more information.
  *
- *  \sa SDL_HapticOpen
- *  \sa SDL_HapticClose
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HapticClose
+ * \sa SDL_HapticOpen
+ * \sa SDL_JoystickIsHaptic
  */
 extern DECLSPEC SDL_Haptic *SDLCALL SDL_HapticOpenFromJoystick(SDL_Joystick *
                                                                joystick);
 
 /**
- *  \brief Closes a haptic device previously opened with SDL_HapticOpen().
+ * Close a haptic device previously opened with SDL_HapticOpen().
  *
- *  \param haptic Haptic device to close.
+ * \param haptic the SDL_Haptic device to close
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HapticOpen
  */
 extern DECLSPEC void SDLCALL SDL_HapticClose(SDL_Haptic * haptic);
 
 /**
- *  \brief Returns the number of effects a haptic device can store.
+ * Get the number of effects a haptic device can store.
  *
- *  On some platforms this isn't fully supported, and therefore is an
- *  approximation.  Always check to see if your created effect was actually
- *  created and do not rely solely on SDL_HapticNumEffects().
+ * On some platforms this isn't fully supported, and therefore is an
+ * approximation. Always check to see if your created effect was actually
+ * created and do not rely solely on SDL_HapticNumEffects().
  *
- *  \param haptic The haptic device to query effect max.
- *  \return The number of effects the haptic device can store or
- *          -1 on error.
+ * \param haptic the SDL_Haptic device to query
+ * \returns the number of effects the haptic device can store or a negative
+ *          error code on failure; call SDL_GetError() for more information.
  *
- *  \sa SDL_HapticNumEffectsPlaying
- *  \sa SDL_HapticQuery
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HapticNumEffectsPlaying
+ * \sa SDL_HapticQuery
  */
 extern DECLSPEC int SDLCALL SDL_HapticNumEffects(SDL_Haptic * haptic);
 
 /**
- *  \brief Returns the number of effects a haptic device can play at the same
- *         time.
+ * Get the number of effects a haptic device can play at the same time.
  *
- *  This is not supported on all platforms, but will always return a value.
- *  Added here for the sake of completeness.
+ * This is not supported on all platforms, but will always return a value.
  *
- *  \param haptic The haptic device to query maximum playing effects.
- *  \return The number of effects the haptic device can play at the same time
- *          or -1 on error.
+ * \param haptic the SDL_Haptic device to query maximum playing effects
+ * \returns the number of effects the haptic device can play at the same time
+ *          or a negative error code on failure; call SDL_GetError() for more
+ *          information.
  *
- *  \sa SDL_HapticNumEffects
- *  \sa SDL_HapticQuery
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HapticNumEffects
+ * \sa SDL_HapticQuery
  */
 extern DECLSPEC int SDLCALL SDL_HapticNumEffectsPlaying(SDL_Haptic * haptic);
 
 /**
- *  \brief Gets the haptic device's supported features in bitwise manner.
+ * Get the haptic device's supported features in bitwise manner.
  *
- *  Example:
- *  \code
- *  if (SDL_HapticQuery(haptic) & SDL_HAPTIC_CONSTANT) {
- *      printf("We have constant haptic effect!\n");
- *  }
- *  \endcode
+ * \param haptic the SDL_Haptic device to query
+ * \returns a list of supported haptic features in bitwise manner (OR'd), or 0
+ *          on failure; call SDL_GetError() for more information.
  *
- *  \param haptic The haptic device to query.
- *  \return Haptic features in bitwise manner (OR'd).
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_HapticNumEffects
- *  \sa SDL_HapticEffectSupported
+ * \sa SDL_HapticEffectSupported
+ * \sa SDL_HapticNumEffects
  */
 extern DECLSPEC unsigned int SDLCALL SDL_HapticQuery(SDL_Haptic * haptic);
 
 
 /**
- *  \brief Gets the number of haptic axes the device has.
+ * Get the number of haptic axes the device has.
  *
- *  \sa SDL_HapticDirection
+ * The number of haptic axes might be useful if working with the
+ * SDL_HapticDirection effect.
+ *
+ * \param haptic the SDL_Haptic device to query
+ * \returns the number of axes on success or a negative error code on failure;
+ *          call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC int SDLCALL SDL_HapticNumAxes(SDL_Haptic * haptic);
 
 /**
- *  \brief Checks to see if effect is supported by haptic.
+ * Check to see if an effect is supported by a haptic device.
  *
- *  \param haptic Haptic device to check on.
- *  \param effect Effect to check to see if it is supported.
- *  \return SDL_TRUE if effect is supported, SDL_FALSE if it isn't or -1 on error.
+ * \param haptic the SDL_Haptic device to query
+ * \param effect the desired effect to query
+ * \returns SDL_TRUE if effect is supported, SDL_FALSE if it isn't, or a
+ *          negative error code on failure; call SDL_GetError() for more
+ *          information.
  *
- *  \sa SDL_HapticQuery
- *  \sa SDL_HapticNewEffect
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HapticNewEffect
+ * \sa SDL_HapticQuery
  */
 extern DECLSPEC int SDLCALL SDL_HapticEffectSupported(SDL_Haptic * haptic,
                                                       SDL_HapticEffect *
                                                       effect);
 
 /**
- *  \brief Creates a new haptic effect on the device.
+ * Create a new haptic effect on a specified device.
  *
- *  \param haptic Haptic device to create the effect on.
- *  \param effect Properties of the effect to create.
- *  \return The identifier of the effect on success or -1 on error.
+ * \param haptic an SDL_Haptic device to create the effect on
+ * \param effect an SDL_HapticEffect structure containing the properties of
+ *               the effect to create
+ * \returns the ID of the effect on success or a negative error code on
+ *          failure; call SDL_GetError() for more information.
  *
- *  \sa SDL_HapticUpdateEffect
- *  \sa SDL_HapticRunEffect
- *  \sa SDL_HapticDestroyEffect
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HapticDestroyEffect
+ * \sa SDL_HapticRunEffect
+ * \sa SDL_HapticUpdateEffect
  */
 extern DECLSPEC int SDLCALL SDL_HapticNewEffect(SDL_Haptic * haptic,
                                                 SDL_HapticEffect * effect);
 
 /**
- *  \brief Updates the properties of an effect.
+ * Update the properties of an effect.
  *
- *  Can be used dynamically, although behavior when dynamically changing
- *  direction may be strange.  Specifically the effect may reupload itself
- *  and start playing from the start.  You cannot change the type either when
- *  running SDL_HapticUpdateEffect().
+ * Can be used dynamically, although behavior when dynamically changing
+ * direction may be strange. Specifically the effect may re-upload itself and
+ * start playing from the start. You also cannot change the type either when
+ * running SDL_HapticUpdateEffect().
  *
- *  \param haptic Haptic device that has the effect.
- *  \param effect Identifier of the effect to update.
- *  \param data New effect properties to use.
- *  \return 0 on success or -1 on error.
+ * \param haptic the SDL_Haptic device that has the effect
+ * \param effect the identifier of the effect to update
+ * \param data an SDL_HapticEffect structure containing the new effect
+ *             properties to use
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \sa SDL_HapticNewEffect
- *  \sa SDL_HapticRunEffect
- *  \sa SDL_HapticDestroyEffect
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HapticDestroyEffect
+ * \sa SDL_HapticNewEffect
+ * \sa SDL_HapticRunEffect
  */
 extern DECLSPEC int SDLCALL SDL_HapticUpdateEffect(SDL_Haptic * haptic,
                                                    int effect,
                                                    SDL_HapticEffect * data);
 
 /**
- *  \brief Runs the haptic effect on its associated haptic device.
+ * Run the haptic effect on its associated haptic device.
  *
- *  If iterations are ::SDL_HAPTIC_INFINITY, it'll run the effect over and over
- *  repeating the envelope (attack and fade) every time.  If you only want the
- *  effect to last forever, set ::SDL_HAPTIC_INFINITY in the effect's length
- *  parameter.
+ * To repeat the effect over and over indefinitely, set `iterations` to
+ * `SDL_HAPTIC_INFINITY`. (Repeats the envelope - attack and fade.) To make
+ * one instance of the effect last indefinitely (so the effect does not fade),
+ * set the effect's `length` in its structure/union to `SDL_HAPTIC_INFINITY`
+ * instead.
  *
- *  \param haptic Haptic device to run the effect on.
- *  \param effect Identifier of the haptic effect to run.
- *  \param iterations Number of iterations to run the effect. Use
- *         ::SDL_HAPTIC_INFINITY for infinity.
- *  \return 0 on success or -1 on error.
+ * \param haptic the SDL_Haptic device to run the effect on
+ * \param effect the ID of the haptic effect to run
+ * \param iterations the number of iterations to run the effect; use
+ *                   `SDL_HAPTIC_INFINITY` to repeat forever
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \sa SDL_HapticStopEffect
- *  \sa SDL_HapticDestroyEffect
- *  \sa SDL_HapticGetEffectStatus
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HapticDestroyEffect
+ * \sa SDL_HapticGetEffectStatus
+ * \sa SDL_HapticStopEffect
  */
 extern DECLSPEC int SDLCALL SDL_HapticRunEffect(SDL_Haptic * haptic,
                                                 int effect,
                                                 Uint32 iterations);
 
 /**
- *  \brief Stops the haptic effect on its associated haptic device.
+ * Stop the haptic effect on its associated haptic device.
  *
- *  \param haptic Haptic device to stop the effect on.
- *  \param effect Identifier of the effect to stop.
- *  \return 0 on success or -1 on error.
+ * *
  *
- *  \sa SDL_HapticRunEffect
- *  \sa SDL_HapticDestroyEffect
+ * \param haptic the SDL_Haptic device to stop the effect on
+ * \param effect the ID of the haptic effect to stop
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HapticDestroyEffect
+ * \sa SDL_HapticRunEffect
  */
 extern DECLSPEC int SDLCALL SDL_HapticStopEffect(SDL_Haptic * haptic,
                                                  int effect);
 
 /**
- *  \brief Destroys a haptic effect on the device.
+ * Destroy a haptic effect on the device.
  *
- *  This will stop the effect if it's running.  Effects are automatically
- *  destroyed when the device is closed.
+ * This will stop the effect if it's running. Effects are automatically
+ * destroyed when the device is closed.
  *
- *  \param haptic Device to destroy the effect on.
- *  \param effect Identifier of the effect to destroy.
+ * \param haptic the SDL_Haptic device to destroy the effect on
+ * \param effect the ID of the haptic effect to destroy
  *
- *  \sa SDL_HapticNewEffect
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HapticNewEffect
  */
 extern DECLSPEC void SDLCALL SDL_HapticDestroyEffect(SDL_Haptic * haptic,
                                                      int effect);
 
 /**
- *  \brief Gets the status of the current effect on the haptic device.
+ * Get the status of the current effect on the specified haptic device.
  *
- *  Device must support the ::SDL_HAPTIC_STATUS feature.
+ * Device must support the SDL_HAPTIC_STATUS feature.
  *
- *  \param haptic Haptic device to query the effect status on.
- *  \param effect Identifier of the effect to query its status.
- *  \return 0 if it isn't playing, 1 if it is playing or -1 on error.
+ * \param haptic the SDL_Haptic device to query for the effect status on
+ * \param effect the ID of the haptic effect to query its status
+ * \returns 0 if it isn't playing, 1 if it is playing, or a negative error
+ *          code on failure; call SDL_GetError() for more information.
  *
- *  \sa SDL_HapticRunEffect
- *  \sa SDL_HapticStopEffect
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HapticRunEffect
+ * \sa SDL_HapticStopEffect
  */
 extern DECLSPEC int SDLCALL SDL_HapticGetEffectStatus(SDL_Haptic * haptic,
                                                       int effect);
 
 /**
- *  \brief Sets the global gain of the device.
+ * Set the global gain of the specified haptic device.
  *
- *  Device must support the ::SDL_HAPTIC_GAIN feature.
+ * Device must support the SDL_HAPTIC_GAIN feature.
  *
- *  The user may specify the maximum gain by setting the environment variable
- *  SDL_HAPTIC_GAIN_MAX which should be between 0 and 100.  All calls to
- *  SDL_HapticSetGain() will scale linearly using SDL_HAPTIC_GAIN_MAX as the
- *  maximum.
+ * The user may specify the maximum gain by setting the environment variable
+ * `SDL_HAPTIC_GAIN_MAX` which should be between 0 and 100. All calls to
+ * SDL_HapticSetGain() will scale linearly using `SDL_HAPTIC_GAIN_MAX` as the
+ * maximum.
  *
- *  \param haptic Haptic device to set the gain on.
- *  \param gain Value to set the gain to, should be between 0 and 100.
- *  \return 0 on success or -1 on error.
+ * \param haptic the SDL_Haptic device to set the gain on
+ * \param gain value to set the gain to, should be between 0 and 100 (0 - 100)
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \sa SDL_HapticQuery
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HapticQuery
  */
 extern DECLSPEC int SDLCALL SDL_HapticSetGain(SDL_Haptic * haptic, int gain);
 
 /**
- *  \brief Sets the global autocenter of the device.
+ * Set the global autocenter of the device.
  *
- *  Autocenter should be between 0 and 100.  Setting it to 0 will disable
- *  autocentering.
+ * Autocenter should be between 0 and 100. Setting it to 0 will disable
+ * autocentering.
  *
- *  Device must support the ::SDL_HAPTIC_AUTOCENTER feature.
+ * Device must support the SDL_HAPTIC_AUTOCENTER feature.
  *
- *  \param haptic Haptic device to set autocentering on.
- *  \param autocenter Value to set autocenter to, 0 disables autocentering.
- *  \return 0 on success or -1 on error.
+ * \param haptic the SDL_Haptic device to set autocentering on
+ * \param autocenter value to set autocenter to (0-100)
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \sa SDL_HapticQuery
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HapticQuery
  */
 extern DECLSPEC int SDLCALL SDL_HapticSetAutocenter(SDL_Haptic * haptic,
                                                     int autocenter);
 
 /**
- *  \brief Pauses a haptic device.
+ * Pause a haptic device.
  *
- *  Device must support the ::SDL_HAPTIC_PAUSE feature.  Call
- *  SDL_HapticUnpause() to resume playback.
+ * Device must support the `SDL_HAPTIC_PAUSE` feature. Call
+ * SDL_HapticUnpause() to resume playback.
  *
- *  Do not modify the effects nor add new ones while the device is paused.
- *  That can cause all sorts of weird errors.
+ * Do not modify the effects nor add new ones while the device is paused. That
+ * can cause all sorts of weird errors.
  *
- *  \param haptic Haptic device to pause.
- *  \return 0 on success or -1 on error.
+ * \param haptic the SDL_Haptic device to pause
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \sa SDL_HapticUnpause
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HapticUnpause
  */
 extern DECLSPEC int SDLCALL SDL_HapticPause(SDL_Haptic * haptic);
 
 /**
- *  \brief Unpauses a haptic device.
+ * Unpause a haptic device.
  *
- *  Call to unpause after SDL_HapticPause().
+ * Call to unpause after SDL_HapticPause().
  *
- *  \param haptic Haptic device to unpause.
- *  \return 0 on success or -1 on error.
+ * \param haptic the SDL_Haptic device to unpause
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \sa SDL_HapticPause
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HapticPause
  */
 extern DECLSPEC int SDLCALL SDL_HapticUnpause(SDL_Haptic * haptic);
 
 /**
- *  \brief Stops all the currently playing effects on a haptic device.
+ * Stop all the currently playing effects on a haptic device.
  *
- *  \param haptic Haptic device to stop.
- *  \return 0 on success or -1 on error.
+ * \param haptic the SDL_Haptic device to stop
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC int SDLCALL SDL_HapticStopAll(SDL_Haptic * haptic);
 
 /**
- *  \brief Checks to see if rumble is supported on a haptic device.
+ * Check whether rumble is supported on a haptic device.
  *
- *  \param haptic Haptic device to check to see if it supports rumble.
- *  \return SDL_TRUE if effect is supported, SDL_FALSE if it isn't or -1 on error.
+ * \param haptic haptic device to check for rumble support
+ * \returns SDL_TRUE if effect is supported, SDL_FALSE if it isn't, or a
+ *          negative error code on failure; call SDL_GetError() for more
+ *          information.
  *
- *  \sa SDL_HapticRumbleInit
- *  \sa SDL_HapticRumblePlay
- *  \sa SDL_HapticRumbleStop
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HapticRumbleInit
+ * \sa SDL_HapticRumblePlay
+ * \sa SDL_HapticRumbleStop
  */
 extern DECLSPEC int SDLCALL SDL_HapticRumbleSupported(SDL_Haptic * haptic);
 
 /**
- *  \brief Initializes the haptic device for simple rumble playback.
+ * Initialize a haptic device for simple rumble playback.
  *
- *  \param haptic Haptic device to initialize for simple rumble playback.
- *  \return 0 on success or -1 on error.
+ * \param haptic the haptic device to initialize for simple rumble playback
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \sa SDL_HapticOpen
- *  \sa SDL_HapticRumbleSupported
- *  \sa SDL_HapticRumblePlay
- *  \sa SDL_HapticRumbleStop
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HapticOpen
+ * \sa SDL_HapticRumblePlay
+ * \sa SDL_HapticRumbleStop
+ * \sa SDL_HapticRumbleSupported
  */
 extern DECLSPEC int SDLCALL SDL_HapticRumbleInit(SDL_Haptic * haptic);
 
 /**
- *  \brief Runs simple rumble on a haptic device
+ * Run a simple rumble effect on a haptic device.
  *
- *  \param haptic Haptic device to play rumble effect on.
- *  \param strength Strength of the rumble to play as a 0-1 float value.
- *  \param length Length of the rumble to play in milliseconds.
- *  \return 0 on success or -1 on error.
+ * \param haptic the haptic device to play the rumble effect on
+ * \param strength strength of the rumble to play as a 0-1 float value
+ * \param length length of the rumble to play in milliseconds
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \sa SDL_HapticRumbleSupported
- *  \sa SDL_HapticRumbleInit
- *  \sa SDL_HapticRumbleStop
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HapticRumbleInit
+ * \sa SDL_HapticRumbleStop
+ * \sa SDL_HapticRumbleSupported
  */
 extern DECLSPEC int SDLCALL SDL_HapticRumblePlay(SDL_Haptic * haptic, float strength, Uint32 length );
 
 /**
- *  \brief Stops the simple rumble on a haptic device.
+ * Stop the simple rumble on a haptic device.
  *
- *  \param haptic Haptic to stop the rumble on.
- *  \return 0 on success or -1 on error.
+ * \param haptic the haptic device to stop the rumble effect on
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \sa SDL_HapticRumbleSupported
- *  \sa SDL_HapticRumbleInit
- *  \sa SDL_HapticRumblePlay
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HapticRumbleInit
+ * \sa SDL_HapticRumblePlay
+ * \sa SDL_HapticRumbleSupported
  */
 extern DECLSPEC int SDLCALL SDL_HapticRumbleStop(SDL_Haptic * haptic);
 
diff --git a/Engine/lib/sdl/include/SDL_hidapi.h b/Engine/lib/sdl/include/SDL_hidapi.h
new file mode 100644
index 000000000..354af5c52
--- /dev/null
+++ b/Engine/lib/sdl/include/SDL_hidapi.h
@@ -0,0 +1,451 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+/**
+ *  \file SDL_hidapi.h
+ *
+ *  Header file for SDL HIDAPI functions.
+ *
+ *  This is an adaptation of the original HIDAPI interface by Alan Ott,
+ *  and includes source code licensed under the following BSD license:
+ *
+    Copyright (c) 2010, Alan Ott, Signal 11 Software
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Signal 11 Software nor the names of its
+      contributors may be used to endorse or promote products derived from
+      this software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+    ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+    POSSIBILITY OF SUCH DAMAGE.
+ *
+ * If you would like a version of SDL without this code, you can build SDL
+ * with SDL_HIDAPI_DISABLED defined to 1. You might want to do this for example
+ * on iOS or tvOS to avoid a dependency on the CoreBluetooth framework.
+ */
+
+#ifndef SDL_hidapi_h_
+#define SDL_hidapi_h_
+
+#include "SDL_stdinc.h"
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ *  \brief  A handle representing an open HID device
+ */
+struct SDL_hid_device_;
+typedef struct SDL_hid_device_ SDL_hid_device; /**< opaque hidapi structure */
+
+/** hidapi info structure */
+/**
+ *  \brief  Information about a connected HID device
+ */
+typedef struct SDL_hid_device_info
+{
+    /** Platform-specific device path */
+    char *path;
+    /** Device Vendor ID */
+    unsigned short vendor_id;
+    /** Device Product ID */
+    unsigned short product_id;
+    /** Serial Number */
+    wchar_t *serial_number;
+    /** Device Release Number in binary-coded decimal,
+        also known as Device Version Number */
+    unsigned short release_number;
+    /** Manufacturer String */
+    wchar_t *manufacturer_string;
+    /** Product string */
+    wchar_t *product_string;
+    /** Usage Page for this Device/Interface
+        (Windows/Mac only). */
+    unsigned short usage_page;
+    /** Usage for this Device/Interface
+        (Windows/Mac only).*/
+    unsigned short usage;
+    /** The USB interface which this logical device
+        represents.
+
+        * Valid on both Linux implementations in all cases.
+        * Valid on the Windows implementation only if the device
+          contains more than one interface. */
+    int interface_number;
+
+    /** Additional information about the USB interface.
+        Valid on libusb and Android implementations. */
+    int interface_class;
+    int interface_subclass;
+    int interface_protocol;
+
+    /** Pointer to the next device */
+    struct SDL_hid_device_info *next;
+} SDL_hid_device_info;
+
+
+/**
+ * Initialize the HIDAPI library.
+ *
+ * This function initializes the HIDAPI library. Calling it is not strictly
+ * necessary, as it will be called automatically by SDL_hid_enumerate() and
+ * any of the SDL_hid_open_*() functions if it is needed. This function should
+ * be called at the beginning of execution however, if there is a chance of
+ * HIDAPI handles being opened by different threads simultaneously.
+ *
+ * Each call to this function should have a matching call to SDL_hid_exit()
+ *
+ * \returns 0 on success and -1 on error.
+ *
+ * \since This function is available since SDL 2.0.18.
+ *
+ * \sa SDL_hid_exit
+ */
+extern DECLSPEC int SDLCALL SDL_hid_init(void);
+
+/**
+ * Finalize the HIDAPI library.
+ *
+ * This function frees all of the static data associated with HIDAPI. It
+ * should be called at the end of execution to avoid memory leaks.
+ *
+ * \returns 0 on success and -1 on error.
+ *
+ * \since This function is available since SDL 2.0.18.
+ *
+ * \sa SDL_hid_init
+ */
+extern DECLSPEC int SDLCALL SDL_hid_exit(void);
+
+/**
+ * Check to see if devices may have been added or removed.
+ *
+ * Enumerating the HID devices is an expensive operation, so you can call this
+ * to see if there have been any system device changes since the last call to
+ * this function. A change in the counter returned doesn't necessarily mean
+ * that anything has changed, but you can call SDL_hid_enumerate() to get an
+ * updated device list.
+ *
+ * Calling this function for the first time may cause a thread or other system
+ * resource to be allocated to track device change notifications.
+ *
+ * \returns a change counter that is incremented with each potential device
+ *          change, or 0 if device change detection isn't available.
+ *
+ * \since This function is available since SDL 2.0.18.
+ *
+ * \sa SDL_hid_enumerate
+ */
+extern DECLSPEC Uint32 SDLCALL SDL_hid_device_change_count(void);
+
+/**
+ * Enumerate the HID Devices.
+ *
+ * This function returns a linked list of all the HID devices attached to the
+ * system which match vendor_id and product_id. If `vendor_id` is set to 0
+ * then any vendor matches. If `product_id` is set to 0 then any product
+ * matches. If `vendor_id` and `product_id` are both set to 0, then all HID
+ * devices will be returned.
+ *
+ * \param vendor_id The Vendor ID (VID) of the types of device to open.
+ * \param product_id The Product ID (PID) of the types of device to open.
+ * \returns a pointer to a linked list of type SDL_hid_device_info, containing
+ *          information about the HID devices attached to the system, or NULL
+ *          in the case of failure. Free this linked list by calling
+ *          SDL_hid_free_enumeration().
+ *
+ * \since This function is available since SDL 2.0.18.
+ *
+ * \sa SDL_hid_device_change_count
+ */
+extern DECLSPEC SDL_hid_device_info * SDLCALL SDL_hid_enumerate(unsigned short vendor_id, unsigned short product_id);
+
+/**
+ * Free an enumeration Linked List
+ *
+ * This function frees a linked list created by SDL_hid_enumerate().
+ *
+ * \param devs Pointer to a list of struct_device returned from
+ *             SDL_hid_enumerate().
+ *
+ * \since This function is available since SDL 2.0.18.
+ */
+extern DECLSPEC void SDLCALL SDL_hid_free_enumeration(SDL_hid_device_info *devs);
+
+/**
+ * Open a HID device using a Vendor ID (VID), Product ID (PID) and optionally
+ * a serial number.
+ *
+ * If `serial_number` is NULL, the first device with the specified VID and PID
+ * is opened.
+ *
+ * \param vendor_id The Vendor ID (VID) of the device to open.
+ * \param product_id The Product ID (PID) of the device to open.
+ * \param serial_number The Serial Number of the device to open (Optionally
+ *                      NULL).
+ * \returns a pointer to a SDL_hid_device object on success or NULL on
+ *          failure.
+ *
+ * \since This function is available since SDL 2.0.18.
+ */
+extern DECLSPEC SDL_hid_device * SDLCALL SDL_hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number);
+
+/**
+ * Open a HID device by its path name.
+ *
+ * The path name be determined by calling SDL_hid_enumerate(), or a
+ * platform-specific path name can be used (eg: /dev/hidraw0 on Linux).
+ *
+ * \param path The path name of the device to open
+ * \returns a pointer to a SDL_hid_device object on success or NULL on
+ *          failure.
+ *
+ * \since This function is available since SDL 2.0.18.
+ */
+extern DECLSPEC SDL_hid_device * SDLCALL SDL_hid_open_path(const char *path, int bExclusive /* = false */);
+
+/**
+ * Write an Output report to a HID device.
+ *
+ * The first byte of `data` must contain the Report ID. For devices which only
+ * support a single report, this must be set to 0x0. The remaining bytes
+ * contain the report data. Since the Report ID is mandatory, calls to
+ * SDL_hid_write() will always contain one more byte than the report contains.
+ * For example, if a hid report is 16 bytes long, 17 bytes must be passed to
+ * SDL_hid_write(), the Report ID (or 0x0, for devices with a single report),
+ * followed by the report data (16 bytes). In this example, the length passed
+ * in would be 17.
+ *
+ * SDL_hid_write() will send the data on the first OUT endpoint, if one
+ * exists. If it does not, it will send the data through the Control Endpoint
+ * (Endpoint 0).
+ *
+ * \param dev A device handle returned from SDL_hid_open().
+ * \param data The data to send, including the report number as the first
+ *             byte.
+ * \param length The length in bytes of the data to send.
+ * \returns the actual number of bytes written and -1 on error.
+ *
+ * \since This function is available since SDL 2.0.18.
+ */
+extern DECLSPEC int SDLCALL SDL_hid_write(SDL_hid_device *dev, const unsigned char *data, size_t length);
+
+/**
+ * Read an Input report from a HID device with timeout.
+ *
+ * Input reports are returned to the host through the INTERRUPT IN endpoint.
+ * The first byte will contain the Report number if the device uses numbered
+ * reports.
+ *
+ * \param dev A device handle returned from SDL_hid_open().
+ * \param data A buffer to put the read data into.
+ * \param length The number of bytes to read. For devices with multiple
+ *               reports, make sure to read an extra byte for the report
+ *               number.
+ * \param milliseconds timeout in milliseconds or -1 for blocking wait.
+ * \returns the actual number of bytes read and -1 on error. If no packet was
+ *          available to be read within the timeout period, this function
+ *          returns 0.
+ *
+ * \since This function is available since SDL 2.0.18.
+ */
+extern DECLSPEC int SDLCALL SDL_hid_read_timeout(SDL_hid_device *dev, unsigned char *data, size_t length, int milliseconds);
+
+/**
+ * Read an Input report from a HID device.
+ *
+ * Input reports are returned to the host through the INTERRUPT IN endpoint.
+ * The first byte will contain the Report number if the device uses numbered
+ * reports.
+ *
+ * \param dev A device handle returned from SDL_hid_open().
+ * \param data A buffer to put the read data into.
+ * \param length The number of bytes to read. For devices with multiple
+ *               reports, make sure to read an extra byte for the report
+ *               number.
+ * \returns the actual number of bytes read and -1 on error. If no packet was
+ *          available to be read and the handle is in non-blocking mode, this
+ *          function returns 0.
+ *
+ * \since This function is available since SDL 2.0.18.
+ */
+extern DECLSPEC int SDLCALL SDL_hid_read(SDL_hid_device *dev, unsigned char *data, size_t length);
+
+/**
+ * Set the device handle to be non-blocking.
+ *
+ * In non-blocking mode calls to SDL_hid_read() will return immediately with a
+ * value of 0 if there is no data to be read. In blocking mode, SDL_hid_read()
+ * will wait (block) until there is data to read before returning.
+ *
+ * Nonblocking can be turned on and off at any time.
+ *
+ * \param dev A device handle returned from SDL_hid_open().
+ * \param nonblock enable or not the nonblocking reads - 1 to enable
+ *                 nonblocking - 0 to disable nonblocking.
+ * \returns 0 on success and -1 on error.
+ *
+ * \since This function is available since SDL 2.0.18.
+ */
+extern DECLSPEC int SDLCALL SDL_hid_set_nonblocking(SDL_hid_device *dev, int nonblock);
+
+/**
+ * Send a Feature report to the device.
+ *
+ * Feature reports are sent over the Control endpoint as a Set_Report
+ * transfer. The first byte of `data` must contain the Report ID. For devices
+ * which only support a single report, this must be set to 0x0. The remaining
+ * bytes contain the report data. Since the Report ID is mandatory, calls to
+ * SDL_hid_send_feature_report() will always contain one more byte than the
+ * report contains. For example, if a hid report is 16 bytes long, 17 bytes
+ * must be passed to SDL_hid_send_feature_report(): the Report ID (or 0x0, for
+ * devices which do not use numbered reports), followed by the report data (16
+ * bytes). In this example, the length passed in would be 17.
+ *
+ * \param dev A device handle returned from SDL_hid_open().
+ * \param data The data to send, including the report number as the first
+ *             byte.
+ * \param length The length in bytes of the data to send, including the report
+ *               number.
+ * \returns the actual number of bytes written and -1 on error.
+ *
+ * \since This function is available since SDL 2.0.18.
+ */
+extern DECLSPEC int SDLCALL SDL_hid_send_feature_report(SDL_hid_device *dev, const unsigned char *data, size_t length);
+
+/**
+ * Get a feature report from a HID device.
+ *
+ * Set the first byte of `data` to the Report ID of the report to be read.
+ * Make sure to allow space for this extra byte in `data`. Upon return, the
+ * first byte will still contain the Report ID, and the report data will start
+ * in data[1].
+ *
+ * \param dev A device handle returned from SDL_hid_open().
+ * \param data A buffer to put the read data into, including the Report ID.
+ *             Set the first byte of `data` to the Report ID of the report to
+ *             be read, or set it to zero if your device does not use numbered
+ *             reports.
+ * \param length The number of bytes to read, including an extra byte for the
+ *               report ID. The buffer can be longer than the actual report.
+ * \returns the number of bytes read plus one for the report ID (which is
+ *          still in the first byte), or -1 on error.
+ *
+ * \since This function is available since SDL 2.0.18.
+ */
+extern DECLSPEC int SDLCALL SDL_hid_get_feature_report(SDL_hid_device *dev, unsigned char *data, size_t length);
+
+/**
+ * Close a HID device.
+ *
+ * \param dev A device handle returned from SDL_hid_open().
+ *
+ * \since This function is available since SDL 2.0.18.
+ */
+extern DECLSPEC void SDLCALL SDL_hid_close(SDL_hid_device *dev);
+
+/**
+ * Get The Manufacturer String from a HID device.
+ *
+ * \param dev A device handle returned from SDL_hid_open().
+ * \param string A wide string buffer to put the data into.
+ * \param maxlen The length of the buffer in multiples of wchar_t.
+ * \returns 0 on success and -1 on error.
+ *
+ * \since This function is available since SDL 2.0.18.
+ */
+extern DECLSPEC int SDLCALL SDL_hid_get_manufacturer_string(SDL_hid_device *dev, wchar_t *string, size_t maxlen);
+
+/**
+ * Get The Product String from a HID device.
+ *
+ * \param dev A device handle returned from SDL_hid_open().
+ * \param string A wide string buffer to put the data into.
+ * \param maxlen The length of the buffer in multiples of wchar_t.
+ * \returns 0 on success and -1 on error.
+ *
+ * \since This function is available since SDL 2.0.18.
+ */
+extern DECLSPEC int SDLCALL SDL_hid_get_product_string(SDL_hid_device *dev, wchar_t *string, size_t maxlen);
+
+/**
+ * Get The Serial Number String from a HID device.
+ *
+ * \param dev A device handle returned from SDL_hid_open().
+ * \param string A wide string buffer to put the data into.
+ * \param maxlen The length of the buffer in multiples of wchar_t.
+ * \returns 0 on success and -1 on error.
+ *
+ * \since This function is available since SDL 2.0.18.
+ */
+extern DECLSPEC int SDLCALL SDL_hid_get_serial_number_string(SDL_hid_device *dev, wchar_t *string, size_t maxlen);
+
+/**
+ * Get a string from a HID device, based on its string index.
+ *
+ * \param dev A device handle returned from SDL_hid_open().
+ * \param string_index The index of the string to get.
+ * \param string A wide string buffer to put the data into.
+ * \param maxlen The length of the buffer in multiples of wchar_t.
+ * \returns 0 on success and -1 on error.
+ *
+ * \since This function is available since SDL 2.0.18.
+ */
+extern DECLSPEC int SDLCALL SDL_hid_get_indexed_string(SDL_hid_device *dev, int string_index, wchar_t *string, size_t maxlen);
+
+/**
+ * Start or stop a BLE scan on iOS and tvOS to pair Steam Controllers
+ *
+ * \param active SDL_TRUE to start the scan, SDL_FALSE to stop the scan
+ *
+ * \since This function is available since SDL 2.0.18.
+ */
+extern DECLSPEC void SDLCALL SDL_hid_ble_scan(SDL_bool active);
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+#include "close_code.h"
+
+#endif /* SDL_hidapi_h_ */
+
+/* vi: set sts=4 ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/include/SDL_hints.h b/Engine/lib/sdl/include/SDL_hints.h
index 50a5a0892..133f68769 100644
--- a/Engine/lib/sdl/include/SDL_hints.h
+++ b/Engine/lib/sdl/include/SDL_hints.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -48,361 +48,122 @@ extern "C" {
 #endif
 
 /**
- *  \brief  A variable controlling how 3D acceleration is used to accelerate the SDL screen surface.
- *
- *  SDL can try to accelerate the SDL screen surface by using streaming
- *  textures with a 3D rendering engine.  This variable controls whether and
- *  how this is done.
+ *  \brief  A variable controlling whether the Android / iOS built-in
+ *  accelerometer should be listed as a joystick device.
  *
  *  This variable can be set to the following values:
- *    "0"       - Disable 3D acceleration
- *    "1"       - Enable 3D acceleration, using the default renderer.
- *    "X"       - Enable 3D acceleration, using X where X is one of the valid rendering drivers.  (e.g. "direct3d", "opengl", etc.)
- *
- *  By default SDL tries to make a best guess for each platform whether
- *  to use acceleration or not.
+ *    "0"       - The accelerometer is not listed as a joystick
+ *    "1"       - The accelerometer is available as a 3 axis joystick (the default).
  */
-#define SDL_HINT_FRAMEBUFFER_ACCELERATION   "SDL_FRAMEBUFFER_ACCELERATION"
+#define SDL_HINT_ACCELEROMETER_AS_JOYSTICK "SDL_ACCELEROMETER_AS_JOYSTICK"
 
 /**
- *  \brief  A variable specifying which render driver to use.
+ *  \brief Specify the behavior of Alt+Tab while the keyboard is grabbed.
  *
- *  If the application doesn't pick a specific renderer to use, this variable
- *  specifies the name of the preferred renderer.  If the preferred renderer
- *  can't be initialized, the normal default renderer is used.
+ * By default, SDL emulates Alt+Tab functionality while the keyboard is grabbed
+ * and your window is full-screen. This prevents the user from getting stuck in
+ * your application if you've enabled keyboard grab.
  *
- *  This variable is case insensitive and can be set to the following values:
- *    "direct3d"
- *    "opengl"
- *    "opengles2"
- *    "opengles"
- *    "metal"
- *    "software"
- *
- *  The default varies by platform, but it's the first one in the list that
- *  is available on the current platform.
- */
-#define SDL_HINT_RENDER_DRIVER              "SDL_RENDER_DRIVER"
+ * The variable can be set to the following values:
+ *   "0"       - SDL will not handle Alt+Tab. Your application is responsible
+                 for handling Alt+Tab while the keyboard is grabbed.
+ *   "1"       - SDL will minimize your window when Alt+Tab is pressed (default)
+*/
+#define SDL_HINT_ALLOW_ALT_TAB_WHILE_GRABBED "SDL_ALLOW_ALT_TAB_WHILE_GRABBED"
 
 /**
- *  \brief  A variable controlling whether the OpenGL render driver uses shaders if they are available.
+ *  \brief If set to "0" then never set the top most bit on a SDL Window, even if the video mode expects it.
+ *      This is a debugging aid for developers and not expected to be used by end users. The default is "1"
  *
  *  This variable can be set to the following values:
- *    "0"       - Disable shaders
- *    "1"       - Enable shaders
- *
- *  By default shaders are used if OpenGL supports them.
+ *    "0"       - don't allow topmost
+ *    "1"       - allow topmost
  */
-#define SDL_HINT_RENDER_OPENGL_SHADERS      "SDL_RENDER_OPENGL_SHADERS"
+#define SDL_HINT_ALLOW_TOPMOST "SDL_ALLOW_TOPMOST"
 
 /**
- *  \brief  A variable controlling whether the Direct3D device is initialized for thread-safe operations.
+ * \brief Android APK expansion main file version. Should be a string number like "1", "2" etc.
  *
- *  This variable can be set to the following values:
- *    "0"       - Thread-safety is not enabled (faster)
- *    "1"       - Thread-safety is enabled
+ * Must be set together with SDL_HINT_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION.
  *
- *  By default the Direct3D device is created with thread-safety disabled.
+ * If both hints were set then SDL_RWFromFile() will look into expansion files
+ * after a given relative path was not found in the internal storage and assets.
+ *
+ * By default this hint is not set and the APK expansion files are not searched.
  */
-#define SDL_HINT_RENDER_DIRECT3D_THREADSAFE "SDL_RENDER_DIRECT3D_THREADSAFE"
+#define SDL_HINT_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION "SDL_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION"
+ 
+/**
+ * \brief Android APK expansion patch file version. Should be a string number like "1", "2" etc.
+ *
+ * Must be set together with SDL_HINT_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION.
+ *
+ * If both hints were set then SDL_RWFromFile() will look into expansion files
+ * after a given relative path was not found in the internal storage and assets.
+ *
+ * By default this hint is not set and the APK expansion files are not searched.
+ */
+#define SDL_HINT_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION "SDL_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION"
 
 /**
- *  \brief  A variable controlling whether to enable Direct3D 11+'s Debug Layer.
+ * \brief A variable to control whether the event loop will block itself when the app is paused.
  *
- *  This variable does not have any effect on the Direct3D 9 based renderer.
+ * The variable can be set to the following values:
+ *   "0"       - Non blocking.
+ *   "1"       - Blocking. (default)
  *
- *  This variable can be set to the following values:
- *    "0"       - Disable Debug Layer use
- *    "1"       - Enable Debug Layer use
- *
- *  By default, SDL does not use Direct3D Debug Layer.
+ * The value should be set before SDL is initialized.
  */
-#define SDL_HINT_RENDER_DIRECT3D11_DEBUG    "SDL_RENDER_DIRECT3D11_DEBUG"
+#define SDL_HINT_ANDROID_BLOCK_ON_PAUSE "SDL_ANDROID_BLOCK_ON_PAUSE"
 
 /**
- *  \brief  A variable controlling the scaling policy for SDL_RenderSetLogicalSize.
+ * \brief A variable to control whether SDL will pause audio in background
+ *        (Requires SDL_ANDROID_BLOCK_ON_PAUSE as "Non blocking")
  *
- *  This variable can be set to the following values:
- *    "0" or "letterbox" - Uses letterbox/sidebars to fit the entire rendering on screen
- *    "1" or "overscan"  - Will zoom the rendering so it fills the entire screen, allowing edges to be drawn offscreen
+ * The variable can be set to the following values:
+ *   "0"       - Non paused.
+ *   "1"       - Paused. (default)
  *
- *  By default letterbox is used
+ * The value should be set before SDL is initialized.
  */
-#define SDL_HINT_RENDER_LOGICAL_SIZE_MODE       "SDL_RENDER_LOGICAL_SIZE_MODE"
+#define SDL_HINT_ANDROID_BLOCK_ON_PAUSE_PAUSEAUDIO "SDL_ANDROID_BLOCK_ON_PAUSE_PAUSEAUDIO"
 
 /**
- *  \brief  A variable controlling the scaling quality
+ * \brief A variable to control whether we trap the Android back button to handle it manually.
+ *        This is necessary for the right mouse button to work on some Android devices, or
+ *        to be able to trap the back button for use in your code reliably.  If set to true,
+ *        the back button will show up as an SDL_KEYDOWN / SDL_KEYUP pair with a keycode of 
+ *        SDL_SCANCODE_AC_BACK.
  *
- *  This variable can be set to the following values:
- *    "0" or "nearest" - Nearest pixel sampling
- *    "1" or "linear"  - Linear filtering (supported by OpenGL and Direct3D)
- *    "2" or "best"    - Currently this is the same as "linear"
+ * The variable can be set to the following values:
+ *   "0"       - Back button will be handled as usual for system. (default)
+ *   "1"       - Back button will be trapped, allowing you to handle the key press
+ *               manually.  (This will also let right mouse click work on systems 
+ *               where the right mouse button functions as back.)
  *
- *  By default nearest pixel sampling is used
+ * The value of this hint is used at runtime, so it can be changed at any time.
  */
-#define SDL_HINT_RENDER_SCALE_QUALITY       "SDL_RENDER_SCALE_QUALITY"
+#define SDL_HINT_ANDROID_TRAP_BACK_BUTTON "SDL_ANDROID_TRAP_BACK_BUTTON"
 
 /**
- *  \brief  A variable controlling whether updates to the SDL screen surface should be synchronized with the vertical refresh, to avoid tearing.
- *
- *  This variable can be set to the following values:
- *    "0"       - Disable vsync
- *    "1"       - Enable vsync
- *
- *  By default SDL does not sync screen surface updates with vertical refresh.
- */
-#define SDL_HINT_RENDER_VSYNC               "SDL_RENDER_VSYNC"
-
-/**
- *  \brief  A variable controlling whether the screensaver is enabled. 
- *
- *  This variable can be set to the following values:
- *    "0"       - Disable screensaver
- *    "1"       - Enable screensaver
- *
- *  By default SDL will disable the screensaver.
- */
-#define SDL_HINT_VIDEO_ALLOW_SCREENSAVER    "SDL_VIDEO_ALLOW_SCREENSAVER"
-
-/**
- * \brief A variable controlling whether the graphics context is externally managed.
- *
- * This variable can be set to the following values:
- *  "0"         - SDL will manage graphics contexts that are attached to windows.
- *  "1"         - Disable graphics context management on windows.
- *
- * By default SDL will manage OpenGL contexts in certain situations. For example, on Android the
- * context will be automatically saved and restored when pausing the application. Additionally, some
- * platforms will assume usage of OpenGL if Vulkan isn't used. Setting this to "1" will prevent this
- * behavior, which is desireable when the application manages the graphics context, such as
- * an externally managed OpenGL context or attaching a Vulkan surface to the window.
- */
-#define SDL_HINT_VIDEO_EXTERNAL_CONTEXT    "SDL_VIDEO_EXTERNAL_CONTEXT"
-
-/**
- *  \brief  A variable controlling whether the X11 VidMode extension should be used.
- *
- *  This variable can be set to the following values:
- *    "0"       - Disable XVidMode
- *    "1"       - Enable XVidMode
- *
- *  By default SDL will use XVidMode if it is available.
- */
-#define SDL_HINT_VIDEO_X11_XVIDMODE         "SDL_VIDEO_X11_XVIDMODE"
-
-/**
- *  \brief  A variable controlling whether the X11 Xinerama extension should be used.
- *
- *  This variable can be set to the following values:
- *    "0"       - Disable Xinerama
- *    "1"       - Enable Xinerama
- *
- *  By default SDL will use Xinerama if it is available.
- */
-#define SDL_HINT_VIDEO_X11_XINERAMA         "SDL_VIDEO_X11_XINERAMA"
-
-/**
- *  \brief  A variable controlling whether the X11 XRandR extension should be used.
- *
- *  This variable can be set to the following values:
- *    "0"       - Disable XRandR
- *    "1"       - Enable XRandR
- *
- *  By default SDL will not use XRandR because of window manager issues.
- */
-#define SDL_HINT_VIDEO_X11_XRANDR           "SDL_VIDEO_X11_XRANDR"
-
-/**
- *  \brief  A variable forcing the visual ID chosen for new X11 windows
- *
- */
-#define SDL_HINT_VIDEO_X11_WINDOW_VISUALID      "SDL_VIDEO_X11_WINDOW_VISUALID"
-
-/**
- *  \brief  A variable controlling whether the X11 _NET_WM_PING protocol should be supported.
- *
- *  This variable can be set to the following values:
- *    "0"       - Disable _NET_WM_PING
- *    "1"       - Enable _NET_WM_PING
- *
- *  By default SDL will use _NET_WM_PING, but for applications that know they
- *  will not always be able to respond to ping requests in a timely manner they can
- *  turn it off to avoid the window manager thinking the app is hung.
- *  The hint is checked in CreateWindow.
- */
-#define SDL_HINT_VIDEO_X11_NET_WM_PING      "SDL_VIDEO_X11_NET_WM_PING"
-
-/**
- * \brief A variable controlling whether the X11 _NET_WM_BYPASS_COMPOSITOR hint should be used.
- * 
- * This variable can be set to the following values:
- * "0" - Disable _NET_WM_BYPASS_COMPOSITOR
- * "1" - Enable _NET_WM_BYPASS_COMPOSITOR
- * 
- * By default SDL will use _NET_WM_BYPASS_COMPOSITOR
+ *  \brief Specify an application name.
  * 
+ * This hint lets you specify the application name sent to the OS when
+ * required. For example, this will often appear in volume control applets for
+ * audio streams, and in lists of applications which are inhibiting the
+ * screensaver.  You should use a string that describes your program ("My Game
+ * 2: The Revenge")
+ *
+ * Setting this to "" or leaving it unset will have SDL use a reasonable
+ * default: probably the application's name or "SDL Application" if SDL
+ * doesn't have any better information.
+ *
+ * Note that, for audio streams, this can be overridden with
+ * SDL_HINT_AUDIO_DEVICE_APP_NAME.
+ *
+ * On targets where this is not supported, this hint does nothing.
  */
-#define SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR "SDL_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR"
-
-/**
- * \brief A variable controlling whether X11 should use GLX or EGL by default
- *
- * This variable can be set to the following values:
- * "0" - Use GLX
- * "1" - Use EGL
- *
- * By default SDL will use GLX when both are present.
- */
-#define SDL_HINT_VIDEO_X11_FORCE_EGL "SDL_VIDEO_X11_FORCE_EGL"
-
-/**
- *  \brief  A variable controlling whether the window frame and title bar are interactive when the cursor is hidden 
- *
- *  This variable can be set to the following values:
- *    "0"       - The window frame is not interactive when the cursor is hidden (no move, resize, etc)
- *    "1"       - The window frame is interactive when the cursor is hidden
- *
- *  By default SDL will allow interaction with the window frame when the cursor is hidden
- */
-#define SDL_HINT_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN    "SDL_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN"
-
-/**
- * \brief A variable to specify custom icon resource id from RC file on Windows platform 
- */
-#define SDL_HINT_WINDOWS_INTRESOURCE_ICON       "SDL_WINDOWS_INTRESOURCE_ICON"
-#define SDL_HINT_WINDOWS_INTRESOURCE_ICON_SMALL "SDL_WINDOWS_INTRESOURCE_ICON_SMALL"
-
-/**
- *  \brief  A variable controlling whether the windows message loop is processed by SDL 
- *
- *  This variable can be set to the following values:
- *    "0"       - The window message loop is not run
- *    "1"       - The window message loop is processed in SDL_PumpEvents()
- *
- *  By default SDL will process the windows message loop
- */
-#define SDL_HINT_WINDOWS_ENABLE_MESSAGELOOP "SDL_WINDOWS_ENABLE_MESSAGELOOP"
-
-/**
- *  \brief  A variable controlling whether grabbing input grabs the keyboard
- *
- *  This variable can be set to the following values:
- *    "0"       - Grab will affect only the mouse
- *    "1"       - Grab will affect mouse and keyboard
- *
- *  By default SDL will not grab the keyboard so system shortcuts still work.
- */
-#define SDL_HINT_GRAB_KEYBOARD              "SDL_GRAB_KEYBOARD"
-
-/**
- *  \brief  A variable setting the double click time, in milliseconds.
- */
-#define SDL_HINT_MOUSE_DOUBLE_CLICK_TIME    "SDL_MOUSE_DOUBLE_CLICK_TIME"
-
-/**
- *  \brief  A variable setting the double click radius, in pixels.
- */
-#define SDL_HINT_MOUSE_DOUBLE_CLICK_RADIUS    "SDL_MOUSE_DOUBLE_CLICK_RADIUS"
-
-/**
- *  \brief  A variable setting the speed scale for mouse motion, in floating point, when the mouse is not in relative mode
- */
-#define SDL_HINT_MOUSE_NORMAL_SPEED_SCALE    "SDL_MOUSE_NORMAL_SPEED_SCALE"
-
-/**
- *  \brief  A variable setting the scale for mouse motion, in floating point, when the mouse is in relative mode
- */
-#define SDL_HINT_MOUSE_RELATIVE_SPEED_SCALE    "SDL_MOUSE_RELATIVE_SPEED_SCALE"
-
-/**
- *  \brief  A variable controlling whether relative mouse motion is affected by renderer scaling
- *
- *  This variable can be set to the following values:
- *    "0"       - Relative motion is unaffected by DPI or renderer's logical size
- *    "1"       - Relative motion is scaled according to DPI scaling and logical size
- *
- *  By default relative mouse deltas are affected by DPI and renderer scaling
- */
-#define SDL_HINT_MOUSE_RELATIVE_SCALING "SDL_MOUSE_RELATIVE_SCALING"
-
-/**
- *  \brief  A variable controlling whether relative mouse mode is implemented using mouse warping
- *
- *  This variable can be set to the following values:
- *    "0"       - Relative mouse mode uses raw input
- *    "1"       - Relative mouse mode uses mouse warping
- *
- *  By default SDL will use raw input for relative mouse mode
- */
-#define SDL_HINT_MOUSE_RELATIVE_MODE_WARP    "SDL_MOUSE_RELATIVE_MODE_WARP"
-
-/**
- *  \brief Allow mouse click events when clicking to focus an SDL window
- *
- *  This variable can be set to the following values:
- *    "0"       - Ignore mouse clicks that activate a window
- *    "1"       - Generate events for mouse clicks that activate a window
- *
- *  By default SDL will ignore mouse clicks that activate a window
- */
-#define SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH "SDL_MOUSE_FOCUS_CLICKTHROUGH"
-
-/**
- *  \brief  A variable controlling whether touch events should generate synthetic mouse events
- *
- *  This variable can be set to the following values:
- *    "0"       - Touch events will not generate mouse events
- *    "1"       - Touch events will generate mouse events
- *
- *  By default SDL will generate mouse events for touch events
- */
-#define SDL_HINT_TOUCH_MOUSE_EVENTS    "SDL_TOUCH_MOUSE_EVENTS"
-
-/**
- *  \brief  A variable controlling whether mouse events should generate synthetic touch events
- *
- *  This variable can be set to the following values:
- *    "0"       - Mouse events will not generate touch events (default for desktop platforms)
- *    "1"       - Mouse events will generate touch events (default for mobile platforms, such as Android and iOS)
- */
-
-#define SDL_HINT_MOUSE_TOUCH_EVENTS    "SDL_MOUSE_TOUCH_EVENTS"
-
-/**
- *  \brief Minimize your SDL_Window if it loses key focus when in fullscreen mode. Defaults to false.
- *  \warning  Before SDL 2.0.14, this defaulted to true! In 2.0.14, we're
- *            seeing if "true" causes more problems than it solves in modern times.
- *
- */
-#define SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS   "SDL_VIDEO_MINIMIZE_ON_FOCUS_LOSS"
-
-/**
- *  \brief  A variable controlling whether the idle timer is disabled on iOS.
- *
- *  When an iOS app does not receive touches for some time, the screen is
- *  dimmed automatically. For games where the accelerometer is the only input
- *  this is problematic. This functionality can be disabled by setting this
- *  hint.
- *
- *  As of SDL 2.0.4, SDL_EnableScreenSaver() and SDL_DisableScreenSaver()
- *  accomplish the same thing on iOS. They should be preferred over this hint.
- *
- *  This variable can be set to the following values:
- *    "0"       - Enable idle timer
- *    "1"       - Disable idle timer
- */
-#define SDL_HINT_IDLE_TIMER_DISABLED "SDL_IOS_IDLE_TIMER_DISABLED"
-
-/**
- *  \brief  A variable controlling which orientations are allowed on iOS/Android.
- *
- *  In some circumstances it is necessary to be able to explicitly control
- *  which UI orientations are allowed.
- *
- *  This variable is a space delimited list of the following values:
- *    "LandscapeLeft", "LandscapeRight", "Portrait" "PortraitUpsideDown"
- */
-#define SDL_HINT_ORIENTATIONS "SDL_IOS_ORIENTATIONS"
+#define SDL_HINT_APP_NAME "SDL_APP_NAME"
 
 /**
  *  \brief  A variable controlling whether controllers used with the Apple TV
@@ -433,72 +194,253 @@ extern "C" {
 #define SDL_HINT_APPLE_TV_REMOTE_ALLOW_ROTATION "SDL_APPLE_TV_REMOTE_ALLOW_ROTATION"
 
 /**
- * \brief  A variable controlling whether the home indicator bar on iPhone X
- *         should be hidden.
+ *  \brief  A variable controlling the audio category on iOS and Mac OS X
  *
  *  This variable can be set to the following values:
- *    "0"       - The indicator bar is not hidden (default for windowed applications)
- *    "1"       - The indicator bar is hidden and is shown when the screen is touched (useful for movie playback applications)
- *    "2"       - The indicator bar is dim and the first swipe makes it visible and the second swipe performs the "home" action (default for fullscreen applications)
+ *
+ *    "ambient"     - Use the AVAudioSessionCategoryAmbient audio category, will be muted by the phone mute switch (default)
+ *    "playback"    - Use the AVAudioSessionCategoryPlayback category
+ *
+ *  For more information, see Apple's documentation:
+ *  https://developer.apple.com/library/content/documentation/Audio/Conceptual/AudioSessionProgrammingGuide/AudioSessionCategoriesandModes/AudioSessionCategoriesandModes.html
  */
-#define SDL_HINT_IOS_HIDE_HOME_INDICATOR "SDL_IOS_HIDE_HOME_INDICATOR"
+#define SDL_HINT_AUDIO_CATEGORY   "SDL_AUDIO_CATEGORY"
 
 /**
- *  \brief  A variable controlling whether the Android / iOS built-in
- *  accelerometer should be listed as a joystick device.
+ *  \brief Specify an application name for an audio device.
+ *
+ * Some audio backends (such as PulseAudio) allow you to describe your audio
+ * stream. Among other things, this description might show up in a system
+ * control panel that lets the user adjust the volume on specific audio
+ * streams instead of using one giant master volume slider.
+ *
+ * This hints lets you transmit that information to the OS. The contents of
+ * this hint are used while opening an audio device. You should use a string
+ * that describes your program ("My Game 2: The Revenge")
+ *
+ * Setting this to "" or leaving it unset will have SDL use a reasonable
+ * default: this will be the name set with SDL_HINT_APP_NAME, if that hint is
+ * set. Otherwise, it'll probably the application's name or "SDL Application"
+ * if SDL doesn't have any better information.
+ *
+ * On targets where this is not supported, this hint does nothing.
+ */
+#define SDL_HINT_AUDIO_DEVICE_APP_NAME "SDL_AUDIO_DEVICE_APP_NAME"
+
+/**
+ *  \brief Specify an application name for an audio device.
+ *
+ * Some audio backends (such as PulseAudio) allow you to describe your audio
+ * stream. Among other things, this description might show up in a system
+ * control panel that lets the user adjust the volume on specific audio
+ * streams instead of using one giant master volume slider.
+ *
+ * This hints lets you transmit that information to the OS. The contents of
+ * this hint are used while opening an audio device. You should use a string
+ * that describes your what your program is playing ("audio stream" is
+ * probably sufficient in many cases, but this could be useful for something
+ * like "team chat" if you have a headset playing VoIP audio separately).
+ *
+ * Setting this to "" or leaving it unset will have SDL use a reasonable
+ * default: "audio stream" or something similar.
+ *
+ * On targets where this is not supported, this hint does nothing.
+ */
+#define SDL_HINT_AUDIO_DEVICE_STREAM_NAME "SDL_AUDIO_DEVICE_STREAM_NAME"
+
+/**
+ *  \brief Specify an application role for an audio device.
+ *
+ * Some audio backends (such as Pipewire) allow you to describe the role of
+ * your audio stream. Among other things, this description might show up in
+ * a system control panel or software for displaying and manipulating media
+ * playback/capture graphs.
+ *
+ * This hints lets you transmit that information to the OS. The contents of
+ * this hint are used while opening an audio device. You should use a string
+ * that describes your what your program is playing (Game, Music, Movie,
+ * etc...).
+ *
+ * Setting this to "" or leaving it unset will have SDL use a reasonable
+ * default: "Game" or something similar.
+ *
+ * On targets where this is not supported, this hint does nothing.
+ */
+#define SDL_HINT_AUDIO_DEVICE_STREAM_ROLE "SDL_AUDIO_DEVICE_STREAM_ROLE"
+
+/**
+ *  \brief  A variable controlling speed/quality tradeoff of audio resampling.
+ *
+ *  If available, SDL can use libsamplerate ( http://www.mega-nerd.com/SRC/ )
+ *  to handle audio resampling. There are different resampling modes available
+ *  that produce different levels of quality, using more CPU.
+ *
+ *  If this hint isn't specified to a valid setting, or libsamplerate isn't
+ *  available, SDL will use the default, internal resampling algorithm.
+ *
+ *  Note that this is currently only applicable to resampling audio that is
+ *  being written to a device for playback or audio being read from a device
+ *  for capture. SDL_AudioCVT always uses the default resampler (although this
+ *  might change for SDL 2.1).
+ *
+ *  This hint is currently only checked at audio subsystem initialization.
  *
  *  This variable can be set to the following values:
- *    "0"       - The accelerometer is not listed as a joystick
- *    "1"       - The accelerometer is available as a 3 axis joystick (the default).
+ *
+ *    "0" or "default" - Use SDL's internal resampling (Default when not set - low quality, fast)
+ *    "1" or "fast"    - Use fast, slightly higher quality resampling, if available
+ *    "2" or "medium"  - Use medium quality resampling, if available
+ *    "3" or "best"    - Use high quality resampling, if available
  */
-#define SDL_HINT_ACCELEROMETER_AS_JOYSTICK "SDL_ACCELEROMETER_AS_JOYSTICK"
+#define SDL_HINT_AUDIO_RESAMPLING_MODE   "SDL_AUDIO_RESAMPLING_MODE"
 
 /**
- *  \brief  A variable controlling whether the Android / tvOS remotes
- *  should be listed as joystick devices, instead of sending keyboard events.
+ *  \brief  A variable controlling whether SDL updates joystick state when getting input events
  *
  *  This variable can be set to the following values:
- *    "0"       - Remotes send enter/escape/arrow key events
- *    "1"       - Remotes are available as 2 axis, 2 button joysticks (the default).
+ *
+ *    "0"     - You'll call SDL_JoystickUpdate() manually
+ *    "1"     - SDL will automatically call SDL_JoystickUpdate() (default)
+ *
+ *  This hint can be toggled on and off at runtime.
  */
-#define SDL_HINT_TV_REMOTE_AS_JOYSTICK "SDL_TV_REMOTE_AS_JOYSTICK"
+#define SDL_HINT_AUTO_UPDATE_JOYSTICKS  "SDL_AUTO_UPDATE_JOYSTICKS"
 
 /**
- *  \brief  A variable that lets you disable the detection and use of Xinput gamepad devices
+ *  \brief  A variable controlling whether SDL updates sensor state when getting input events
+ *
+ *  This variable can be set to the following values:
+ *
+ *    "0"     - You'll call SDL_SensorUpdate() manually
+ *    "1"     - SDL will automatically call SDL_SensorUpdate() (default)
+ *
+ *  This hint can be toggled on and off at runtime.
+ */
+#define SDL_HINT_AUTO_UPDATE_SENSORS    "SDL_AUTO_UPDATE_SENSORS"
+
+/**
+ *  \brief Prevent SDL from using version 4 of the bitmap header when saving BMPs.
+ *
+ * The bitmap header version 4 is required for proper alpha channel support and
+ * SDL will use it when required. Should this not be desired, this hint can
+ * force the use of the 40 byte header version which is supported everywhere.
+ *
+ * The variable can be set to the following values:
+ *   "0"       - Surfaces with a colorkey or an alpha channel are saved to a
+ *               32-bit BMP file with an alpha mask. SDL will use the bitmap
+ *               header version 4 and set the alpha mask accordingly.
+ *   "1"       - Surfaces with a colorkey or an alpha channel are saved to a
+ *               32-bit BMP file without an alpha mask. The alpha channel data
+ *               will be in the file, but applications are going to ignore it.
+ *
+ * The default value is "0".
+ */
+#define SDL_HINT_BMP_SAVE_LEGACY_FORMAT "SDL_BMP_SAVE_LEGACY_FORMAT"
+
+/**
+ *  \brief Override for SDL_GetDisplayUsableBounds()
+ *
+ *  If set, this hint will override the expected results for
+ *  SDL_GetDisplayUsableBounds() for display index 0. Generally you don't want
+ *  to do this, but this allows an embedded system to request that some of the
+ *  screen be reserved for other uses when paired with a well-behaved
+ *  application.
+ *
+ *  The contents of this hint must be 4 comma-separated integers, the first
+ *  is the bounds x, then y, width and height, in that order.
+ */
+#define SDL_HINT_DISPLAY_USABLE_BOUNDS "SDL_DISPLAY_USABLE_BOUNDS"
+
+/**
+ *  \brief Disable giving back control to the browser automatically
+ *  when running with asyncify
+ *
+ * With -s ASYNCIFY, SDL2 calls emscripten_sleep during operations
+ * such as refreshing the screen or polling events.
+ *
+ * This hint only applies to the emscripten platform
+ *
+ * The variable can be set to the following values:
+ *    "0"       - Disable emscripten_sleep calls (if you give back browser control manually or use asyncify for other purposes)
+ *    "1"       - Enable emscripten_sleep calls (the default)
+ */
+#define SDL_HINT_EMSCRIPTEN_ASYNCIFY   "SDL_EMSCRIPTEN_ASYNCIFY"
+
+/**
+ *  \brief override the binding element for keyboard inputs for Emscripten builds
+ *
+ * This hint only applies to the emscripten platform
+ *
+ * The variable can be one of
+ *    "#window"      - The javascript window object (this is the default)
+ *    "#document"    - The javascript document object
+ *    "#screen"      - the javascript window.screen object
+ *    "#canvas"      - the WebGL canvas element
+ *    any other string without a leading # sign applies to the element on the page with that ID.
+ */
+#define SDL_HINT_EMSCRIPTEN_KEYBOARD_ELEMENT   "SDL_EMSCRIPTEN_KEYBOARD_ELEMENT"
+
+/**
+ *  \brief  A variable that controls whether Steam Controllers should be exposed using the SDL joystick and game controller APIs
  *
  *  The variable can be set to the following values:
- *    "0"       - Disable XInput detection (only uses direct input)
- *    "1"       - Enable XInput detection (the default)
+ *    "0"       - Do not scan for Steam Controllers
+ *    "1"       - Scan for Steam Controllers (the default)
+ *
+ *  The default value is "1".  This hint must be set before initializing the joystick subsystem.
  */
-#define SDL_HINT_XINPUT_ENABLED "SDL_XINPUT_ENABLED"
+#define SDL_HINT_ENABLE_STEAM_CONTROLLERS "SDL_ENABLE_STEAM_CONTROLLERS"
 
 /**
- *  \brief  A variable that causes SDL to use the old axis and button mapping for XInput devices.
+ *  \brief  A variable controlling whether SDL logs all events pushed onto its internal queue.
  *
- *  This hint is for backwards compatibility only and will be removed in SDL 2.1
+ *  This variable can be set to the following values:
  *
- *  The default value is "0".  This hint must be set before SDL_Init()
+ *    "0"     - Don't log any events (default)
+ *    "1"     - Log all events except mouse and finger motion, which are pretty spammy.
+ *    "2"     - Log all events.
+ *
+ *  This is generally meant to be used to debug SDL itself, but can be useful
+ *  for application developers that need better visibility into what is going
+ *  on in the event queue. Logged events are sent through SDL_Log(), which
+ *  means by default they appear on stdout on most platforms or maybe
+ *  OutputDebugString() on Windows, and can be funneled by the app with
+ *  SDL_LogSetOutputFunction(), etc.
+ *
+ *  This hint can be toggled on and off at runtime, if you only need to log
+ *  events for a small subset of program execution.
  */
-#define SDL_HINT_XINPUT_USE_OLD_JOYSTICK_MAPPING "SDL_XINPUT_USE_OLD_JOYSTICK_MAPPING"
+#define SDL_HINT_EVENT_LOGGING   "SDL_EVENT_LOGGING"
 
 /**
- *  \brief  A variable that overrides the automatic controller type detection
+ *  \brief  A variable controlling whether raising the window should be done more forcefully
  *
- *  The variable should be comma separated entries, in the form: VID/PID=type
+ *  This variable can be set to the following values:
+ *    "0"       - No forcing (the default)
+ *    "1"       - Extra level of forcing
  *
- *  The VID and PID should be hexadecimal with exactly 4 digits, e.g. 0x00fd
- *
- *  The type should be one of:
- *      Xbox360
- *      XboxOne
- *      PS3
- *      PS4
- *      PS5
- *      SwitchPro
- *
- *  This hint affects what driver is used, and must be set before calling SDL_Init(SDL_INIT_GAMECONTROLLER)
+ *  At present, this is only an issue under MS Windows, which makes it nearly impossible to
+ *  programmatically move a window to the foreground, for "security" reasons. See
+ *  http://stackoverflow.com/a/34414846 for a discussion.
  */
-#define SDL_HINT_GAMECONTROLLERTYPE "SDL_GAMECONTROLLERTYPE"
+#define SDL_HINT_FORCE_RAISEWINDOW    "SDL_HINT_FORCE_RAISEWINDOW"
+
+/**
+ *  \brief  A variable controlling how 3D acceleration is used to accelerate the SDL screen surface.
+ *
+ *  SDL can try to accelerate the SDL screen surface by using streaming
+ *  textures with a 3D rendering engine.  This variable controls whether and
+ *  how this is done.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Disable 3D acceleration
+ *    "1"       - Enable 3D acceleration, using the default renderer.
+ *    "X"       - Enable 3D acceleration, using X where X is one of the valid rendering drivers.  (e.g. "direct3d", "opengl", etc.)
+ *
+ *  By default SDL tries to make a best guess for each platform whether
+ *  to use acceleration or not.
+ */
+#define SDL_HINT_FRAMEBUFFER_ACCELERATION   "SDL_FRAMEBUFFER_ACCELERATION"
 
 /**
  *  \brief  A variable that lets you manually hint extra gamecontroller db entries.
@@ -520,6 +462,25 @@ extern "C" {
  */
 #define SDL_HINT_GAMECONTROLLERCONFIG_FILE "SDL_GAMECONTROLLERCONFIG_FILE"
 
+/**
+ *  \brief  A variable that overrides the automatic controller type detection
+ *
+ *  The variable should be comma separated entries, in the form: VID/PID=type
+ *
+ *  The VID and PID should be hexadecimal with exactly 4 digits, e.g. 0x00fd
+ *
+ *  The type should be one of:
+ *      Xbox360
+ *      XboxOne
+ *      PS3
+ *      PS4
+ *      PS5
+ *      SwitchPro
+ *
+ *  This hint affects what driver is used, and must be set before calling SDL_Init(SDL_INIT_GAMECONTROLLER)
+ */
+#define SDL_HINT_GAMECONTROLLERTYPE "SDL_GAMECONTROLLERTYPE"
+
 /**
  *  \brief  A variable containing a list of devices to skip when scanning for game controllers.
  *
@@ -569,6 +530,77 @@ extern "C" {
  */
 #define SDL_HINT_GAMECONTROLLER_USE_BUTTON_LABELS "SDL_GAMECONTROLLER_USE_BUTTON_LABELS"
 
+/**
+ *  \brief  A variable controlling whether grabbing input grabs the keyboard
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Grab will affect only the mouse
+ *    "1"       - Grab will affect mouse and keyboard
+ *
+ *  By default SDL will not grab the keyboard so system shortcuts still work.
+ */
+#define SDL_HINT_GRAB_KEYBOARD              "SDL_GRAB_KEYBOARD"
+
+/**
+ *  \brief  A variable controlling whether the idle timer is disabled on iOS.
+ *
+ *  When an iOS app does not receive touches for some time, the screen is
+ *  dimmed automatically. For games where the accelerometer is the only input
+ *  this is problematic. This functionality can be disabled by setting this
+ *  hint.
+ *
+ *  As of SDL 2.0.4, SDL_EnableScreenSaver() and SDL_DisableScreenSaver()
+ *  accomplish the same thing on iOS. They should be preferred over this hint.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Enable idle timer
+ *    "1"       - Disable idle timer
+ */
+#define SDL_HINT_IDLE_TIMER_DISABLED "SDL_IOS_IDLE_TIMER_DISABLED"
+
+/**
+ * \brief A variable to control whether certain IMEs should handle text editing internally instead of sending SDL_TEXTEDITING events.
+ *
+ * The variable can be set to the following values:
+ *   "0"       - SDL_TEXTEDITING events are sent, and it is the application's
+ *               responsibility to render the text from these events and 
+ *               differentiate it somehow from committed text. (default)
+ *   "1"       - If supported by the IME then SDL_TEXTEDITING events are not sent, 
+ *               and text that is being composed will be rendered in its own UI.
+ */
+#define SDL_HINT_IME_INTERNAL_EDITING "SDL_IME_INTERNAL_EDITING"
+
+/**
+ * \brief A variable to control whether certain IMEs should show native UI components (such as the Candidate List) instead of suppressing them.
+ *
+ * The variable can be set to the following values:
+ *   "0"       - Native UI components are not display. (default)
+ *   "1"       - Native UI components are displayed.
+ */
+#define SDL_HINT_IME_SHOW_UI "SDL_IME_SHOW_UI"
+
+/**
+ * \brief A variable to control if extended IME text support is enabled.
+ * If enabled then SDL_TextEditingExtEvent will be issued if the text would be truncated otherwise.
+ * Additionally SDL_TextInputEvent will be dispatched multiple times so that it is not truncated.
+ *
+ * The variable can be set to the following values:
+ *   "0"       - Legacy behavior. Text can be truncated, no heap allocations. (default)
+ *   "1"       - Modern behavior.
+ */
+#define SDL_HINT_IME_SUPPORT_EXTENDED_TEXT "SDL_IME_SUPPORT_EXTENDED_TEXT"
+
+/**
+ * \brief  A variable controlling whether the home indicator bar on iPhone X
+ *         should be hidden.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - The indicator bar is not hidden (default for windowed applications)
+ *    "1"       - The indicator bar is hidden and is shown when the screen is touched (useful for movie playback applications)
+ *    "2"       - The indicator bar is dim and the first swipe makes it visible and the second swipe performs the "home" action (default for fullscreen applications)
+ */
+#define SDL_HINT_IOS_HIDE_HOME_INDICATOR "SDL_IOS_HIDE_HOME_INDICATOR"
+
 /**
  *  \brief  A variable that lets you enable joystick (and gamecontroller) events even when your app is in the background.
  *
@@ -593,6 +625,54 @@ extern "C" {
  */
 #define SDL_HINT_JOYSTICK_HIDAPI "SDL_JOYSTICK_HIDAPI"
 
+/**
+ *  \brief  A variable controlling whether the HIDAPI driver for Nintendo GameCube controllers should be used.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - HIDAPI driver is not used
+ *    "1"       - HIDAPI driver is used
+ *
+ *  The default is the value of SDL_HINT_JOYSTICK_HIDAPI
+ */
+#define SDL_HINT_JOYSTICK_HIDAPI_GAMECUBE "SDL_JOYSTICK_HIDAPI_GAMECUBE"
+
+/**
+ *  \brief  A variable controlling whether "low_frequency_rumble" and "high_frequency_rumble" is used to implement
+ *          the GameCube controller's 3 rumble modes, Stop(0), Rumble(1), and StopHard(2)
+ *          this is useful for applications that need full compatibility for things like ADSR envelopes.
+ *          Stop is implemented by setting "low_frequency_rumble" to "0" and "high_frequency_rumble" ">0"
+ *          Rumble is both at any arbitrary value,
+ *          StopHard is implemented by setting both "low_frequency_rumble" and "high_frequency_rumble" to "0"
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Normal rumble behavior is behavior is used (default)
+ *    "1"       - Proper GameCube controller rumble behavior is used
+ *
+ */
+#define SDL_HINT_JOYSTICK_GAMECUBE_RUMBLE_BRAKE "SDL_JOYSTICK_GAMECUBE_RUMBLE_BRAKE"
+
+ /**
+  *  \brief  A variable controlling whether Switch Joy-Cons should be treated the same as Switch Pro Controllers when using the HIDAPI driver.
+  *
+  *  This variable can be set to the following values:
+  *    "0"       - basic Joy-Con support with no analog input (the default)
+  *    "1"       - Joy-Cons treated as half full Pro Controllers with analog inputs and sensors
+  *
+  *  This does not combine Joy-Cons into a single controller. That's up to the user.
+  */
+#define SDL_HINT_JOYSTICK_HIDAPI_JOY_CONS "SDL_JOYSTICK_HIDAPI_JOY_CONS"
+
+ /**
+  *  \brief  A variable controlling whether the HIDAPI driver for Amazon Luna controllers connected via Bluetooth should be used.
+  *
+  *  This variable can be set to the following values:
+  *    "0"       - HIDAPI driver is not used
+  *    "1"       - HIDAPI driver is used
+  *
+  *  The default is the value of SDL_HINT_JOYSTICK_HIDAPI
+  */
+#define SDL_HINT_JOYSTICK_HIDAPI_LUNA "SDL_JOYSTICK_HIDAPI_LUNA"
+
 /**
  *  \brief  A variable controlling whether the HIDAPI driver for PS4 controllers should be used.
  *
@@ -604,17 +684,6 @@ extern "C" {
  */
 #define SDL_HINT_JOYSTICK_HIDAPI_PS4 "SDL_JOYSTICK_HIDAPI_PS4"
 
-/**
- *  \brief  A variable controlling whether the HIDAPI driver for PS5 controllers should be used.
- *
- *  This variable can be set to the following values:
- *    "0"       - HIDAPI driver is not used
- *    "1"       - HIDAPI driver is used
- *
- *  The default is the value of SDL_HINT_JOYSTICK_HIDAPI
- */
-#define SDL_HINT_JOYSTICK_HIDAPI_PS5 "SDL_JOYSTICK_HIDAPI_PS5"
-
 /**
  *  \brief  A variable controlling whether extended input reports should be used for PS4 controllers when using the HIDAPI driver.
  *
@@ -627,11 +696,16 @@ extern "C" {
  *
  *  Once extended reports are enabled, they can not be disabled without
  *  power cycling the controller.
+ *
+ *  For compatibility with applications written for versions of SDL prior
+ *  to the introduction of PS5 controller support, this value will also
+ *  control the state of extended reports on PS5 controllers when the
+ *  SDL_HINT_JOYSTICK_HIDAPI_PS5_RUMBLE hint is not explicitly set.
  */
 #define SDL_HINT_JOYSTICK_HIDAPI_PS4_RUMBLE "SDL_JOYSTICK_HIDAPI_PS4_RUMBLE"
 
 /**
- *  \brief  A variable controlling whether the HIDAPI driver for Steam Controllers should be used.
+ *  \brief  A variable controlling whether the HIDAPI driver for PS5 controllers should be used.
  *
  *  This variable can be set to the following values:
  *    "0"       - HIDAPI driver is not used
@@ -639,6 +713,57 @@ extern "C" {
  *
  *  The default is the value of SDL_HINT_JOYSTICK_HIDAPI
  */
+#define SDL_HINT_JOYSTICK_HIDAPI_PS5 "SDL_JOYSTICK_HIDAPI_PS5"
+
+/**
+ *  \brief  A variable controlling whether the player LEDs should be lit to indicate which player is associated with a PS5 controller.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - player LEDs are not enabled
+ *    "1"       - player LEDs are enabled (the default)
+ */
+#define SDL_HINT_JOYSTICK_HIDAPI_PS5_PLAYER_LED "SDL_JOYSTICK_HIDAPI_PS5_PLAYER_LED"
+
+/**
+ *  \brief  A variable controlling whether extended input reports should be used for PS5 controllers when using the HIDAPI driver.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - extended reports are not enabled (the default)
+ *    "1"       - extended reports
+ *
+ *  Extended input reports allow rumble on Bluetooth PS5 controllers, but
+ *  break DirectInput handling for applications that don't use SDL.
+ *
+ *  Once extended reports are enabled, they can not be disabled without
+ *  power cycling the controller.
+ *
+ *  For compatibility with applications written for versions of SDL prior
+ *  to the introduction of PS5 controller support, this value defaults to
+ *  the value of SDL_HINT_JOYSTICK_HIDAPI_PS4_RUMBLE.
+ */
+#define SDL_HINT_JOYSTICK_HIDAPI_PS5_RUMBLE "SDL_JOYSTICK_HIDAPI_PS5_RUMBLE"
+
+/**
+ *  \brief  A variable controlling whether the HIDAPI driver for Google Stadia controllers should be used.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - HIDAPI driver is not used
+ *    "1"       - HIDAPI driver is used
+ *
+ *  The default is the value of SDL_HINT_JOYSTICK_HIDAPI
+ */
+#define SDL_HINT_JOYSTICK_HIDAPI_STADIA "SDL_JOYSTICK_HIDAPI_STADIA"
+
+/**
+ *  \brief  A variable controlling whether the HIDAPI driver for Steam Controllers should be used.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - HIDAPI driver is not used
+ *    "1"       - HIDAPI driver is used for Steam Controllers, which requires Bluetooth access
+ *                and may prompt the user for permission on iOS and Android.
+ *
+ *  The default is "0"
+ */
 #define SDL_HINT_JOYSTICK_HIDAPI_STEAM "SDL_JOYSTICK_HIDAPI_STEAM"
 
 /**
@@ -652,6 +777,17 @@ extern "C" {
  */
 #define SDL_HINT_JOYSTICK_HIDAPI_SWITCH "SDL_JOYSTICK_HIDAPI_SWITCH"
 
+/**
+ *  \brief  A variable controlling whether the Home button LED should be turned on when a Nintendo Switch controller is opened
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - home button LED is turned off
+ *    "1"       - home button LED is turned on
+ *
+ *  By default the Home button LED state is not changed.
+ */
+#define SDL_HINT_JOYSTICK_HIDAPI_SWITCH_HOME_LED "SDL_JOYSTICK_HIDAPI_SWITCH_HOME_LED"
+
 /**
  *  \brief  A variable controlling whether the HIDAPI driver for XBox controllers should be used.
  *
@@ -663,51 +799,37 @@ extern "C" {
  */
 #define SDL_HINT_JOYSTICK_HIDAPI_XBOX   "SDL_JOYSTICK_HIDAPI_XBOX"
 
- /**
-  *  \brief  A variable controlling whether the HIDAPI driver for XBox controllers on Windows should pull correlated
-  *      data from XInput.
-  *
-  *  This variable can be set to the following values:
-  *    "0"       - HIDAPI Xbox driver will only use HIDAPI data
-  *    "1"       - HIDAPI Xbox driver will also pull data from XInput, providing better trigger axes, guide button
-  *                presses, and rumble support
-  *
-  *  The default is "1".  This hint applies to any joysticks opened after setting the hint.
-  */
-#define SDL_HINT_JOYSTICK_HIDAPI_CORRELATE_XINPUT   "SDL_JOYSTICK_HIDAPI_CORRELATE_XINPUT"
-
-/**
- *  \brief  A variable controlling whether the HIDAPI driver for Nintendo GameCube controllers should be used.
- *
- *  This variable can be set to the following values:
- *    "0"       - HIDAPI driver is not used
- *    "1"       - HIDAPI driver is used
- *
- *  The default is the value of SDL_HINT_JOYSTICK_HIDAPI
- */
-#define SDL_HINT_JOYSTICK_HIDAPI_GAMECUBE "SDL_JOYSTICK_HIDAPI_GAMECUBE"
-
-/**
- *  \brief  A variable that controls whether Steam Controllers should be exposed using the SDL joystick and game controller APIs
- *
- *  The variable can be set to the following values:
- *    "0"       - Do not scan for Steam Controllers
- *    "1"       - Scan for Steam Controllers (the default)
- *
- *  The default value is "1".  This hint must be set before initializing the joystick subsystem.
- */
-#define SDL_HINT_ENABLE_STEAM_CONTROLLERS "SDL_ENABLE_STEAM_CONTROLLERS"
-
  /**
   *  \brief  A variable controlling whether the RAWINPUT joystick drivers should be used for better handling XInput-capable devices.
   *
   *  This variable can be set to the following values:
   *    "0"       - RAWINPUT drivers are not used
   *    "1"       - RAWINPUT drivers are used (the default)
-  *
   */
 #define SDL_HINT_JOYSTICK_RAWINPUT "SDL_JOYSTICK_RAWINPUT"
 
+ /**
+  *  \brief  A variable controlling whether the RAWINPUT driver should pull correlated data from XInput.
+  *
+  *  This variable can be set to the following values:
+  *    "0"       - RAWINPUT driver will only use data from raw input APIs
+  *    "1"       - RAWINPUT driver will also pull data from XInput, providing
+  *                better trigger axes, guide button presses, and rumble support
+  *                for Xbox controllers
+  *
+  *  The default is "1".  This hint applies to any joysticks opened after setting the hint.
+  */
+#define SDL_HINT_JOYSTICK_RAWINPUT_CORRELATE_XINPUT   "SDL_JOYSTICK_RAWINPUT_CORRELATE_XINPUT"
+
+ /**
+  *  \brief  A variable controlling whether the ROG Chakram mice should show up as joysticks
+  *
+  *  This variable can be set to the following values:
+  *    "0"       - ROG Chakram mice do not show up as joysticks (the default)
+  *    "1"       - ROG Chakram mice show up as joysticks
+  */
+#define SDL_HINT_JOYSTICK_ROG_CHAKRAM "SDL_JOYSTICK_ROG_CHAKRAM"
+
  /**
   *  \brief  A variable controlling whether a separate thread should be used
   *          for handling joystick detection and raw input messages on Windows
@@ -719,6 +841,47 @@ extern "C" {
   */
 #define SDL_HINT_JOYSTICK_THREAD "SDL_JOYSTICK_THREAD"
 
+/**
+ * \brief Determines whether SDL enforces that DRM master is required in order
+ *        to initialize the KMSDRM video backend.
+ *
+ * The DRM subsystem has a concept of a "DRM master" which is a DRM client that
+ * has the ability to set planes, set cursor, etc. When SDL is DRM master, it
+ * can draw to the screen using the SDL rendering APIs. Without DRM master, SDL
+ * is still able to process input and query attributes of attached displays,
+ * but it cannot change display state or draw to the screen directly.
+ *
+ * In some cases, it can be useful to have the KMSDRM backend even if it cannot
+ * be used for rendering. An app may want to use SDL for input processing while
+ * using another rendering API (such as an MMAL overlay on Raspberry Pi) or
+ * using its own code to render to DRM overlays that SDL doesn't support.
+ *
+ * This hint must be set before initializing the video subsystem.
+ *
+ * This variable can be set to the following values:
+ *    "0"       - SDL will allow usage of the KMSDRM backend without DRM master
+ *    "1"       - SDL Will require DRM master to use the KMSDRM backend (default)
+ */
+#define SDL_HINT_KMSDRM_REQUIRE_DRM_MASTER      "SDL_KMSDRM_REQUIRE_DRM_MASTER"
+
+ /**
+  *  \brief  A comma separated list of devices to open as joysticks
+  *
+  *  This variable is currently only used by the Linux joystick driver.
+  */
+#define SDL_HINT_JOYSTICK_DEVICE "SDL_JOYSTICK_DEVICE"
+
+ /**
+  *  \brief  A variable controlling whether to use the classic /dev/input/js* joystick interface or the newer /dev/input/event* joystick interface on Linux
+  *
+  *  This variable can be set to the following values:
+  *    "0"       - Use /dev/input/event*
+  *    "1"       - Use /dev/input/js*
+  *
+  *  By default the /dev/input/event* interfaces are used
+  */
+#define SDL_HINT_LINUX_JOYSTICK_CLASSIC "SDL_LINUX_JOYSTICK_CLASSIC"
+
  /**
   *  \brief  A variable controlling whether joysticks on Linux adhere to their HID-defined deadzones or return unfiltered values.
   *
@@ -729,31 +892,196 @@ extern "C" {
 #define SDL_HINT_LINUX_JOYSTICK_DEADZONES "SDL_LINUX_JOYSTICK_DEADZONES"
 
 /**
- *  \brief If set to "0" then never set the top most bit on a SDL Window, even if the video mode expects it.
- *      This is a debugging aid for developers and not expected to be used by end users. The default is "1"
- *
- *  This variable can be set to the following values:
- *    "0"       - don't allow topmost
- *    "1"       - allow topmost
- */
-#define SDL_HINT_ALLOW_TOPMOST "SDL_ALLOW_TOPMOST"
+*  \brief  When set don't force the SDL app to become a foreground process
+*
+*  This hint only applies to Mac OS X.
+*
+*/
+#define SDL_HINT_MAC_BACKGROUND_APP    "SDL_MAC_BACKGROUND_APP"
 
 /**
- *  \brief A variable that controls the timer resolution, in milliseconds.
+ *  \brief A variable that determines whether ctrl+click should generate a right-click event on Mac
  *
- *  The higher resolution the timer, the more frequently the CPU services
- *  timer interrupts, and the more precise delays are, but this takes up
- *  power and CPU time.  This hint is only used on Windows 7 and earlier.
- *
- *  See this blog post for more information:
- *  http://randomascii.wordpress.com/2013/07/08/windows-timer-resolution-megawatts-wasted/
- *
- *  If this variable is set to "0", the system timer resolution is not set.
- *
- *  The default value is "1". This hint may be set at any time.
+ *  If present, holding ctrl while left clicking will generate a right click
+ *  event when on Mac.
  */
-#define SDL_HINT_TIMER_RESOLUTION "SDL_TIMER_RESOLUTION"
+#define SDL_HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK "SDL_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK"
 
+/**
+ *  \brief  A variable setting the double click radius, in pixels.
+ */
+#define SDL_HINT_MOUSE_DOUBLE_CLICK_RADIUS    "SDL_MOUSE_DOUBLE_CLICK_RADIUS"
+
+/**
+ *  \brief  A variable setting the double click time, in milliseconds.
+ */
+#define SDL_HINT_MOUSE_DOUBLE_CLICK_TIME    "SDL_MOUSE_DOUBLE_CLICK_TIME"
+
+/**
+ *  \brief Allow mouse click events when clicking to focus an SDL window
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Ignore mouse clicks that activate a window
+ *    "1"       - Generate events for mouse clicks that activate a window
+ *
+ *  By default SDL will ignore mouse clicks that activate a window
+ */
+#define SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH "SDL_MOUSE_FOCUS_CLICKTHROUGH"
+
+/**
+ *  \brief  A variable setting the speed scale for mouse motion, in floating point, when the mouse is not in relative mode
+ */
+#define SDL_HINT_MOUSE_NORMAL_SPEED_SCALE    "SDL_MOUSE_NORMAL_SPEED_SCALE"
+
+/**
+ *  \brief  A variable controlling whether relative mouse mode constrains the mouse to the center of the window
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Relative mouse mode constrains the mouse to the window
+ *    "1"       - Relative mouse mode constrains the mouse to the center of the window
+ *
+ *  Constraining to the center of the window works better for FPS games and when the
+ *  application is running over RDP. Constraining to the whole window works better
+ *  for 2D games and increases the chance that the mouse will be in the correct
+ *  position when using high DPI mice.
+ *
+ *  By default SDL will constrain the mouse to the center of the window
+ */
+#define SDL_HINT_MOUSE_RELATIVE_MODE_CENTER    "SDL_MOUSE_RELATIVE_MODE_CENTER"
+
+/**
+ *  \brief  A variable controlling whether relative mouse mode is implemented using mouse warping
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Relative mouse mode uses raw input
+ *    "1"       - Relative mouse mode uses mouse warping
+ *
+ *  By default SDL will use raw input for relative mouse mode
+ */
+#define SDL_HINT_MOUSE_RELATIVE_MODE_WARP    "SDL_MOUSE_RELATIVE_MODE_WARP"
+
+/**
+ *  \brief  A variable controlling whether relative mouse motion is affected by renderer scaling
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Relative motion is unaffected by DPI or renderer's logical size
+ *    "1"       - Relative motion is scaled according to DPI scaling and logical size
+ *
+ *  By default relative mouse deltas are affected by DPI and renderer scaling
+ */
+#define SDL_HINT_MOUSE_RELATIVE_SCALING "SDL_MOUSE_RELATIVE_SCALING"
+
+/**
+ *  \brief  A variable setting the scale for mouse motion, in floating point, when the mouse is in relative mode
+ */
+#define SDL_HINT_MOUSE_RELATIVE_SPEED_SCALE    "SDL_MOUSE_RELATIVE_SPEED_SCALE"
+
+/**
+ *  \brief  A variable controlling whether mouse events should generate synthetic touch events
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Mouse events will not generate touch events (default for desktop platforms)
+ *    "1"       - Mouse events will generate touch events (default for mobile platforms, such as Android and iOS)
+ */
+#define SDL_HINT_MOUSE_TOUCH_EVENTS    "SDL_MOUSE_TOUCH_EVENTS"
+
+/**
+ *  \brief  A variable controlling whether the mouse is captured while mouse buttons are pressed
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - The mouse is not captured while mouse buttons are pressed
+ *    "1"       - The mouse is captured while mouse buttons are pressed
+ *
+ *  By default the mouse is captured while mouse buttons are pressed so if the mouse is dragged
+ *  outside the window, the application continues to receive mouse events until the button is
+ *  released.
+ */
+#define SDL_HINT_MOUSE_AUTO_CAPTURE    "SDL_MOUSE_AUTO_CAPTURE"
+
+/**
+ *  \brief Tell SDL not to catch the SIGINT or SIGTERM signals.
+ *
+ * This hint only applies to Unix-like platforms, and should set before
+ * any calls to SDL_Init()
+ *
+ * The variable can be set to the following values:
+ *   "0"       - SDL will install a SIGINT and SIGTERM handler, and when it
+ *               catches a signal, convert it into an SDL_QUIT event.
+ *   "1"       - SDL will not install a signal handler at all.
+ */
+#define SDL_HINT_NO_SIGNAL_HANDLERS   "SDL_NO_SIGNAL_HANDLERS"
+
+/**
+ *  \brief  A variable controlling what driver to use for OpenGL ES contexts.
+ *
+ *  On some platforms, currently Windows and X11, OpenGL drivers may support
+ *  creating contexts with an OpenGL ES profile. By default SDL uses these
+ *  profiles, when available, otherwise it attempts to load an OpenGL ES
+ *  library, e.g. that provided by the ANGLE project. This variable controls
+ *  whether SDL follows this default behaviour or will always load an
+ *  OpenGL ES library.
+ *
+ *  Circumstances where this is useful include
+ *  - Testing an app with a particular OpenGL ES implementation, e.g ANGLE,
+ *    or emulator, e.g. those from ARM, Imagination or Qualcomm.
+ *  - Resolving OpenGL ES function addresses at link time by linking with
+ *    the OpenGL ES library instead of querying them at run time with
+ *    SDL_GL_GetProcAddress().
+ *
+ *  Caution: for an application to work with the default behaviour across
+ *  different OpenGL drivers it must query the OpenGL ES function
+ *  addresses at run time using SDL_GL_GetProcAddress().
+ *
+ *  This variable is ignored on most platforms because OpenGL ES is native
+ *  or not supported.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Use ES profile of OpenGL, if available. (Default when not set.)
+ *    "1"       - Load OpenGL ES library using the default library names.
+ *
+ */
+#define SDL_HINT_OPENGL_ES_DRIVER   "SDL_OPENGL_ES_DRIVER"
+
+/**
+ *  \brief  A variable controlling which orientations are allowed on iOS/Android.
+ *
+ *  In some circumstances it is necessary to be able to explicitly control
+ *  which UI orientations are allowed.
+ *
+ *  This variable is a space delimited list of the following values:
+ *    "LandscapeLeft", "LandscapeRight", "Portrait" "PortraitUpsideDown"
+ */
+#define SDL_HINT_ORIENTATIONS "SDL_IOS_ORIENTATIONS"
+
+/**
+ *  \brief  A variable controlling the use of a sentinel event when polling the event queue
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Disable poll sentinels
+ *    "1"       - Enable poll sentinels
+ *
+ *  When polling for events, SDL_PumpEvents is used to gather new events from devices.
+ *  If a device keeps producing new events between calls to SDL_PumpEvents, a poll loop will
+ *  become stuck until the new events stop.
+ *  This is most noticable when moving a high frequency mouse.
+ *
+ *  By default, poll sentinels are enabled.
+ */
+#define SDL_HINT_POLL_SENTINEL "SDL_POLL_SENTINEL"
+
+/**
+ *  \brief Override for SDL_GetPreferredLocales()
+ *
+ *  If set, this will be favored over anything the OS might report for the
+ *  user's preferred locales. Changing this hint at runtime will not generate
+ *  a SDL_LOCALECHANGED event (but if you can change the hint, you can push
+ *  your own event, if you want).
+ *
+ *  The format of this hint is a comma-separated list of language and locale,
+ *  combined with an underscore, as is a common format: "en_GB". Locale is
+ *  optional: "en". So you might have a list like this: "en_GB,jp,es_PT"
+ */
+#define SDL_HINT_PREFERRED_LOCALES "SDL_PREFERRED_LOCALES"
 
 /**
  *  \brief  A variable describing the content orientation on QtWayland-based platforms.
@@ -784,35 +1112,170 @@ extern "C" {
 #define SDL_HINT_QTWAYLAND_WINDOW_FLAGS "SDL_QTWAYLAND_WINDOW_FLAGS"
 
 /**
-*  \brief  A string specifying SDL's threads stack size in bytes or "0" for the backend's default size
-*
-*  Use this hint in case you need to set SDL's threads stack size to other than the default.
-*  This is specially useful if you build SDL against a non glibc libc library (such as musl) which
-*  provides a relatively small default thread stack size (a few kilobytes versus the default 8MB glibc uses).
-*  Support for this hint is currently available only in the pthread, Windows, and PSP backend.
-*
-*  Instead of this hint, in 2.0.9 and later, you can use
-*  SDL_CreateThreadWithStackSize(). This hint only works with the classic
-*  SDL_CreateThread().
-*/
-#define SDL_HINT_THREAD_STACK_SIZE              "SDL_THREAD_STACK_SIZE"
+ *  \brief  A variable controlling whether the 2D render API is compatible or efficient.
+ *
+ *  This variable can be set to the following values:
+ *
+ *    "0"     - Don't use batching to make rendering more efficient.
+ *    "1"     - Use batching, but might cause problems if app makes its own direct OpenGL calls.
+ *
+ *  Up to SDL 2.0.9, the render API would draw immediately when requested. Now
+ *  it batches up draw requests and sends them all to the GPU only when forced
+ *  to (during SDL_RenderPresent, when changing render targets, by updating a
+ *  texture that the batch needs, etc). This is significantly more efficient,
+ *  but it can cause problems for apps that expect to render on top of the
+ *  render API's output. As such, SDL will disable batching if a specific
+ *  render backend is requested (since this might indicate that the app is
+ *  planning to use the underlying graphics API directly). This hint can
+ *  be used to explicitly request batching in this instance. It is a contract
+ *  that you will either never use the underlying graphics API directly, or
+ *  if you do, you will call SDL_RenderFlush() before you do so any current
+ *  batch goes to the GPU before your work begins. Not following this contract
+ *  will result in undefined behavior.
+ */
+#define SDL_HINT_RENDER_BATCHING  "SDL_RENDER_BATCHING"
 
 /**
-*  \brief  A string specifying additional information to use with SDL_SetThreadPriority.
-*
-*  By default SDL_SetThreadPriority will make appropriate system changes in order to
-*  apply a thread priority.  For example on systems using pthreads the scheduler policy
-*  is changed automatically to a policy that works well with a given priority.
-*  Code which has specific requirements can override SDL's default behavior with this hint.
-*
-*  pthread hint values are "current", "other", "fifo" and "rr".
-*  Currently no other platform hint values are defined but may be in the future.
-*
-*  \note On Linux, the kernel may send SIGKILL to realtime tasks which exceed the distro
-*  configured execution budget for rtkit. This budget can be queried through RLIMIT_RTTIME
-*  after calling SDL_SetThreadPriority().
-*/
-#define SDL_HINT_THREAD_PRIORITY_POLICY         "SDL_THREAD_PRIORITY_POLICY"
+ *  \brief  A variable controlling how the 2D render API renders lines
+ *
+ *  This variable can be set to the following values:
+ *    "0"     - Use the default line drawing method (Bresenham's line algorithm as of SDL 2.0.20)
+ *    "1"     - Use the driver point API using Bresenham's line algorithm (correct, draws many points)
+ *    "2"     - Use the driver line API (occasionally misses line endpoints based on hardware driver quirks, was the default before 2.0.20)
+ *    "3"     - Use the driver geometry API (correct, draws thicker diagonal lines)
+ *
+ *  This variable should be set when the renderer is created.
+ */
+#define SDL_HINT_RENDER_LINE_METHOD "SDL_RENDER_LINE_METHOD"
+
+/**
+ *  \brief  A variable controlling whether to enable Direct3D 11+'s Debug Layer.
+ *
+ *  This variable does not have any effect on the Direct3D 9 based renderer.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Disable Debug Layer use
+ *    "1"       - Enable Debug Layer use
+ *
+ *  By default, SDL does not use Direct3D Debug Layer.
+ */
+#define SDL_HINT_RENDER_DIRECT3D11_DEBUG    "SDL_RENDER_DIRECT3D11_DEBUG"
+
+/**
+ *  \brief  A variable controlling whether the Direct3D device is initialized for thread-safe operations.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Thread-safety is not enabled (faster)
+ *    "1"       - Thread-safety is enabled
+ *
+ *  By default the Direct3D device is created with thread-safety disabled.
+ */
+#define SDL_HINT_RENDER_DIRECT3D_THREADSAFE "SDL_RENDER_DIRECT3D_THREADSAFE"
+
+/**
+ *  \brief  A variable specifying which render driver to use.
+ *
+ *  If the application doesn't pick a specific renderer to use, this variable
+ *  specifies the name of the preferred renderer.  If the preferred renderer
+ *  can't be initialized, the normal default renderer is used.
+ *
+ *  This variable is case insensitive and can be set to the following values:
+ *    "direct3d"
+ *    "opengl"
+ *    "opengles2"
+ *    "opengles"
+ *    "metal"
+ *    "software"
+ *
+ *  The default varies by platform, but it's the first one in the list that
+ *  is available on the current platform.
+ */
+#define SDL_HINT_RENDER_DRIVER              "SDL_RENDER_DRIVER"
+
+/**
+ *  \brief  A variable controlling the scaling policy for SDL_RenderSetLogicalSize.
+ *
+ *  This variable can be set to the following values:
+ *    "0" or "letterbox" - Uses letterbox/sidebars to fit the entire rendering on screen
+ *    "1" or "overscan"  - Will zoom the rendering so it fills the entire screen, allowing edges to be drawn offscreen
+ *
+ *  By default letterbox is used
+ */
+#define SDL_HINT_RENDER_LOGICAL_SIZE_MODE       "SDL_RENDER_LOGICAL_SIZE_MODE"
+
+/**
+ *  \brief  A variable controlling whether the OpenGL render driver uses shaders if they are available.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Disable shaders
+ *    "1"       - Enable shaders
+ *
+ *  By default shaders are used if OpenGL supports them.
+ */
+#define SDL_HINT_RENDER_OPENGL_SHADERS      "SDL_RENDER_OPENGL_SHADERS"
+
+/**
+ *  \brief  A variable controlling the scaling quality
+ *
+ *  This variable can be set to the following values:
+ *    "0" or "nearest" - Nearest pixel sampling
+ *    "1" or "linear"  - Linear filtering (supported by OpenGL and Direct3D)
+ *    "2" or "best"    - Currently this is the same as "linear"
+ *
+ *  By default nearest pixel sampling is used
+ */
+#define SDL_HINT_RENDER_SCALE_QUALITY       "SDL_RENDER_SCALE_QUALITY"
+
+/**
+ *  \brief  A variable controlling whether updates to the SDL screen surface should be synchronized with the vertical refresh, to avoid tearing.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Disable vsync
+ *    "1"       - Enable vsync
+ *
+ *  By default SDL does not sync screen surface updates with vertical refresh.
+ */
+#define SDL_HINT_RENDER_VSYNC               "SDL_RENDER_VSYNC"
+
+ /**
+ * \brief A variable to control whether the return key on the soft keyboard
+ *        should hide the soft keyboard on Android and iOS.
+ *
+ * The variable can be set to the following values:
+ *   "0"       - The return key will be handled as a key event. This is the behaviour of SDL <= 2.0.3. (default)
+ *   "1"       - The return key will hide the keyboard.
+ *
+ * The value of this hint is used at runtime, so it can be changed at any time.
+ */
+#define SDL_HINT_RETURN_KEY_HIDES_IME "SDL_RETURN_KEY_HIDES_IME"
+
+/**
+ * \brief Tell SDL which Dispmanx layer to use on a Raspberry PI
+ *
+ * Also known as Z-order. The variable can take a negative or positive value.
+ * The default is 10000.
+ */
+#define SDL_HINT_RPI_VIDEO_LAYER           "SDL_RPI_VIDEO_LAYER"
+
+/**
+ *  \brief Specify an "activity name" for screensaver inhibition.
+ *
+ * Some platforms, notably Linux desktops, list the applications which are
+ * inhibiting the screensaver or other power-saving features.
+ *
+ * This hint lets you specify the "activity name" sent to the OS when
+ * SDL_DisableScreenSaver() is used (or the screensaver is automatically
+ * disabled). The contents of this hint are used when the screensaver is
+ * disabled. You should use a string that describes what your program is doing
+ * (and, therefore, why the screensaver is disabled).  For example, "Playing a
+ * game" or "Watching a video".
+ * 
+ * Setting this to "" or leaving it unset will have SDL use a reasonable
+ * default: "Playing a game" or something similar.
+ *
+ * On targets where this is not supported, this hint does nothing.
+ */
+#define SDL_HINT_SCREENSAVER_INHIBIT_ACTIVITY_NAME "SDL_SCREENSAVER_INHIBIT_ACTIVITY_NAME"
 
 /**
  *  \brief Specifies whether SDL_THREAD_PRIORITY_TIME_CRITICAL should be treated as realtime.
@@ -833,34 +1296,172 @@ extern "C" {
  */
 #define SDL_HINT_THREAD_FORCE_REALTIME_TIME_CRITICAL "SDL_THREAD_FORCE_REALTIME_TIME_CRITICAL"
 
+/**
+*  \brief  A string specifying additional information to use with SDL_SetThreadPriority.
+*
+*  By default SDL_SetThreadPriority will make appropriate system changes in order to
+*  apply a thread priority.  For example on systems using pthreads the scheduler policy
+*  is changed automatically to a policy that works well with a given priority.
+*  Code which has specific requirements can override SDL's default behavior with this hint.
+*
+*  pthread hint values are "current", "other", "fifo" and "rr".
+*  Currently no other platform hint values are defined but may be in the future.
+*
+*  \note On Linux, the kernel may send SIGKILL to realtime tasks which exceed the distro
+*  configured execution budget for rtkit. This budget can be queried through RLIMIT_RTTIME
+*  after calling SDL_SetThreadPriority().
+*/
+#define SDL_HINT_THREAD_PRIORITY_POLICY         "SDL_THREAD_PRIORITY_POLICY"
+
+/**
+*  \brief  A string specifying SDL's threads stack size in bytes or "0" for the backend's default size
+*
+*  Use this hint in case you need to set SDL's threads stack size to other than the default.
+*  This is specially useful if you build SDL against a non glibc libc library (such as musl) which
+*  provides a relatively small default thread stack size (a few kilobytes versus the default 8MB glibc uses).
+*  Support for this hint is currently available only in the pthread, Windows, and PSP backend.
+*
+*  Instead of this hint, in 2.0.9 and later, you can use
+*  SDL_CreateThreadWithStackSize(). This hint only works with the classic
+*  SDL_CreateThread().
+*/
+#define SDL_HINT_THREAD_STACK_SIZE              "SDL_THREAD_STACK_SIZE"
+
+/**
+ *  \brief A variable that controls the timer resolution, in milliseconds.
+ *
+ *  The higher resolution the timer, the more frequently the CPU services
+ *  timer interrupts, and the more precise delays are, but this takes up
+ *  power and CPU time.  This hint is only used on Windows.
+ *
+ *  See this blog post for more information:
+ *  http://randomascii.wordpress.com/2013/07/08/windows-timer-resolution-megawatts-wasted/
+ *
+ *  If this variable is set to "0", the system timer resolution is not set.
+ *
+ *  The default value is "1". This hint may be set at any time.
+ */
+#define SDL_HINT_TIMER_RESOLUTION "SDL_TIMER_RESOLUTION"
+
+/**
+ *  \brief  A variable controlling whether touch events should generate synthetic mouse events
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Touch events will not generate mouse events
+ *    "1"       - Touch events will generate mouse events
+ *
+ *  By default SDL will generate mouse events for touch events
+ */
+#define SDL_HINT_TOUCH_MOUSE_EVENTS    "SDL_TOUCH_MOUSE_EVENTS"
+
+/**
+ *  \brief  A variable controlling whether the Android / tvOS remotes
+ *  should be listed as joystick devices, instead of sending keyboard events.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Remotes send enter/escape/arrow key events
+ *    "1"       - Remotes are available as 2 axis, 2 button joysticks (the default).
+ */
+#define SDL_HINT_TV_REMOTE_AS_JOYSTICK "SDL_TV_REMOTE_AS_JOYSTICK"
+
+/**
+ *  \brief  A variable controlling whether the screensaver is enabled. 
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Disable screensaver
+ *    "1"       - Enable screensaver
+ *
+ *  By default SDL will disable the screensaver.
+ */
+#define SDL_HINT_VIDEO_ALLOW_SCREENSAVER    "SDL_VIDEO_ALLOW_SCREENSAVER"
+
+/**
+ * \brief Tell the video driver that we only want a double buffer.
+ *
+ * By default, most lowlevel 2D APIs will use a triple buffer scheme that 
+ * wastes no CPU time on waiting for vsync after issuing a flip, but
+ * introduces a frame of latency. On the other hand, using a double buffer
+ * scheme instead is recommended for cases where low latency is an important
+ * factor because we save a whole frame of latency.
+ * We do so by waiting for vsync immediately after issuing a flip, usually just
+ * after eglSwapBuffers call in the backend's *_SwapWindow function.
+ *
+ * Since it's driver-specific, it's only supported where possible and
+ * implemented. Currently supported the following drivers:
+ *
+ * - KMSDRM (kmsdrm)
+ * - Raspberry Pi (raspberrypi)
+ */
+#define SDL_HINT_VIDEO_DOUBLE_BUFFER      "SDL_VIDEO_DOUBLE_BUFFER"
+
+/**
+ * \brief A variable controlling whether the EGL window is allowed to be
+ * composited as transparent, rather than opaque.
+ *
+ * Most window systems will always render windows opaque, even if the surface
+ * format has an alpha channel. This is not always true, however, so by default
+ * SDL will try to enforce opaque composition. To override this behavior, you
+ * can set this hint to "1".
+ */
+#define SDL_HINT_VIDEO_EGL_ALLOW_TRANSPARENCY "SDL_VIDEO_EGL_ALLOW_TRANSPARENCY"
+
+/**
+ * \brief A variable controlling whether the graphics context is externally managed.
+ *
+ * This variable can be set to the following values:
+ *  "0"         - SDL will manage graphics contexts that are attached to windows.
+ *  "1"         - Disable graphics context management on windows.
+ *
+ * By default SDL will manage OpenGL contexts in certain situations. For example, on Android the
+ * context will be automatically saved and restored when pausing the application. Additionally, some
+ * platforms will assume usage of OpenGL if Vulkan isn't used. Setting this to "1" will prevent this
+ * behavior, which is desireable when the application manages the graphics context, such as
+ * an externally managed OpenGL context or attaching a Vulkan surface to the window.
+ */
+#define SDL_HINT_VIDEO_EXTERNAL_CONTEXT    "SDL_VIDEO_EXTERNAL_CONTEXT"
+
 /**
  *  \brief If set to 1, then do not allow high-DPI windows. ("Retina" on Mac and iOS)
  */
 #define SDL_HINT_VIDEO_HIGHDPI_DISABLED "SDL_VIDEO_HIGHDPI_DISABLED"
 
 /**
- *  \brief A variable that determines whether ctrl+click should generate a right-click event on Mac
+ *  \brief  A variable that dictates policy for fullscreen Spaces on Mac OS X.
  *
- *  If present, holding ctrl while left clicking will generate a right click
- *  event when on Mac.
+ *  This hint only applies to Mac OS X.
+ *
+ *  The variable can be set to the following values:
+ *    "0"       - Disable Spaces support (FULLSCREEN_DESKTOP won't use them and
+ *                SDL_WINDOW_RESIZABLE windows won't offer the "fullscreen"
+ *                button on their titlebars).
+ *    "1"       - Enable Spaces support (FULLSCREEN_DESKTOP will use them and
+ *                SDL_WINDOW_RESIZABLE windows will offer the "fullscreen"
+ *                button on their titlebars).
+ *
+ *  The default value is "1". Spaces are disabled regardless of this hint if
+ *   the OS isn't at least Mac OS X Lion (10.7). This hint must be set before
+ *   any windows are created.
  */
-#define SDL_HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK "SDL_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK"
+#define SDL_HINT_VIDEO_MAC_FULLSCREEN_SPACES    "SDL_VIDEO_MAC_FULLSCREEN_SPACES"
 
 /**
-*  \brief  A variable specifying which shader compiler to preload when using the Chrome ANGLE binaries
-*
-*  SDL has EGL and OpenGL ES2 support on Windows via the ANGLE project. It
-*  can use two different sets of binaries, those compiled by the user from source
-*  or those provided by the Chrome browser. In the later case, these binaries require
-*  that SDL loads a DLL providing the shader compiler.
-*
-*  This variable can be set to the following values:
-*    "d3dcompiler_46.dll" - default, best for Vista or later.
-*    "d3dcompiler_43.dll" - for XP support.
-*    "none" - do not load any library, useful if you compiled ANGLE from source and included the compiler in your binaries.
-*
-*/
-#define SDL_HINT_VIDEO_WIN_D3DCOMPILER              "SDL_VIDEO_WIN_D3DCOMPILER"
+ *  \brief Minimize your SDL_Window if it loses key focus when in fullscreen mode. Defaults to false.
+ *  \warning  Before SDL 2.0.14, this defaulted to true! In 2.0.14, we're
+ *            seeing if "true" causes more problems than it solves in modern times.
+ *
+ */
+#define SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS   "SDL_VIDEO_MINIMIZE_ON_FOCUS_LOSS"
+
+/**
+ *  \brief  A variable controlling whether the libdecor Wayland backend is allowed to be used.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - libdecor use is disabled.
+ *    "1"       - libdecor use is enabled (default).
+ *
+ *  libdecor is used over xdg-shell when xdg-decoration protocol is unavailable.
+ */
+#define SDL_HINT_VIDEO_WAYLAND_ALLOW_LIBDECOR "SDL_VIDEO_WAYLAND_ALLOW_LIBDECOR"
 
 /**
 *  \brief  A variable that is the address of another SDL_Window* (as a hex string formatted with "%p").
@@ -882,51 +1483,296 @@ extern "C" {
 #define SDL_HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT    "SDL_VIDEO_WINDOW_SHARE_PIXEL_FORMAT"
 
 /**
- *  \brief A URL to a WinRT app's privacy policy
+ *  \brief  When calling SDL_CreateWindowFrom(), make the window compatible with OpenGL.
  *
- *  All network-enabled WinRT apps must make a privacy policy available to its
- *  users.  On Windows 8, 8.1, and RT, Microsoft mandates that this policy be
- *  be available in the Windows Settings charm, as accessed from within the app.
- *  SDL provides code to add a URL-based link there, which can point to the app's
- *  privacy policy.
+ * This variable can be set to the following values:
+ * "0" - Don't add any graphics flags to the SDL_WindowFlags
+ * "1" - Add SDL_WINDOW_OPENGL to the SDL_WindowFlags
  *
- *  To setup a URL to an app's privacy policy, set SDL_HINT_WINRT_PRIVACY_POLICY_URL
- *  before calling any SDL_Init() functions.  The contents of the hint should
- *  be a valid URL.  For example, "http://www.example.com".
- *
- *  The default value is "", which will prevent SDL from adding a privacy policy
- *  link to the Settings charm.  This hint should only be set during app init.
- *
- *  The label text of an app's "Privacy Policy" link may be customized via another
- *  hint, SDL_HINT_WINRT_PRIVACY_POLICY_LABEL.
- *
- *  Please note that on Windows Phone, Microsoft does not provide standard UI
- *  for displaying a privacy policy link, and as such, SDL_HINT_WINRT_PRIVACY_POLICY_URL
- *  will not get used on that platform.  Network-enabled phone apps should display
- *  their privacy policy through some other, in-app means.
+ * By default SDL will not make the foreign window compatible with OpenGL.
  */
-#define SDL_HINT_WINRT_PRIVACY_POLICY_URL "SDL_WINRT_PRIVACY_POLICY_URL"
+#define SDL_HINT_VIDEO_FOREIGN_WINDOW_OPENGL "SDL_VIDEO_FOREIGN_WINDOW_OPENGL"
 
-/** \brief Label text for a WinRT app's privacy policy link
+/**
+ *  \brief  When calling SDL_CreateWindowFrom(), make the window compatible with Vulkan.
  *
- *  Network-enabled WinRT apps must include a privacy policy.  On Windows 8, 8.1, and RT,
- *  Microsoft mandates that this policy be available via the Windows Settings charm.
- *  SDL provides code to add a link there, with its label text being set via the
- *  optional hint, SDL_HINT_WINRT_PRIVACY_POLICY_LABEL.
+ * This variable can be set to the following values:
+ * "0" - Don't add any graphics flags to the SDL_WindowFlags
+ * "1" - Add SDL_WINDOW_VULKAN to the SDL_WindowFlags
  *
- *  Please note that a privacy policy's contents are not set via this hint.  A separate
- *  hint, SDL_HINT_WINRT_PRIVACY_POLICY_URL, is used to link to the actual text of the
- *  policy.
- *
- *  The contents of this hint should be encoded as a UTF8 string.
- *
- *  The default value is "Privacy Policy".  This hint should only be set during app
- *  initialization, preferably before any calls to SDL_Init().
- *
- *  For additional information on linking to a privacy policy, see the documentation for
- *  SDL_HINT_WINRT_PRIVACY_POLICY_URL.
+ * By default SDL will not make the foreign window compatible with Vulkan.
  */
-#define SDL_HINT_WINRT_PRIVACY_POLICY_LABEL "SDL_WINRT_PRIVACY_POLICY_LABEL"
+#define SDL_HINT_VIDEO_FOREIGN_WINDOW_VULKAN "SDL_VIDEO_FOREIGN_WINDOW_VULKAN"
+
+/**
+*  \brief  A variable specifying which shader compiler to preload when using the Chrome ANGLE binaries
+*
+*  SDL has EGL and OpenGL ES2 support on Windows via the ANGLE project. It
+*  can use two different sets of binaries, those compiled by the user from source
+*  or those provided by the Chrome browser. In the later case, these binaries require
+*  that SDL loads a DLL providing the shader compiler.
+*
+*  This variable can be set to the following values:
+*    "d3dcompiler_46.dll" - default, best for Vista or later.
+*    "d3dcompiler_43.dll" - for XP support.
+*    "none" - do not load any library, useful if you compiled ANGLE from source and included the compiler in your binaries.
+*
+*/
+#define SDL_HINT_VIDEO_WIN_D3DCOMPILER              "SDL_VIDEO_WIN_D3DCOMPILER"
+
+/**
+ * \brief A variable controlling whether X11 should use GLX or EGL by default
+ *
+ * This variable can be set to the following values:
+ * "0" - Use GLX
+ * "1" - Use EGL
+ *
+ * By default SDL will use GLX when both are present.
+ */
+#define SDL_HINT_VIDEO_X11_FORCE_EGL "SDL_VIDEO_X11_FORCE_EGL"
+
+/**
+ * \brief A variable controlling whether the X11 _NET_WM_BYPASS_COMPOSITOR hint should be used.
+ * 
+ * This variable can be set to the following values:
+ * "0" - Disable _NET_WM_BYPASS_COMPOSITOR
+ * "1" - Enable _NET_WM_BYPASS_COMPOSITOR
+ * 
+ * By default SDL will use _NET_WM_BYPASS_COMPOSITOR
+ * 
+ */
+#define SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR "SDL_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR"
+
+/**
+ *  \brief  A variable controlling whether the X11 _NET_WM_PING protocol should be supported.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Disable _NET_WM_PING
+ *    "1"       - Enable _NET_WM_PING
+ *
+ *  By default SDL will use _NET_WM_PING, but for applications that know they
+ *  will not always be able to respond to ping requests in a timely manner they can
+ *  turn it off to avoid the window manager thinking the app is hung.
+ *  The hint is checked in CreateWindow.
+ */
+#define SDL_HINT_VIDEO_X11_NET_WM_PING      "SDL_VIDEO_X11_NET_WM_PING"
+
+/**
+ *  \brief  A variable forcing the visual ID chosen for new X11 windows
+ *
+ */
+#define SDL_HINT_VIDEO_X11_WINDOW_VISUALID      "SDL_VIDEO_X11_WINDOW_VISUALID"
+
+/**
+ *  \brief  A variable controlling whether the X11 Xinerama extension should be used.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Disable Xinerama
+ *    "1"       - Enable Xinerama
+ *
+ *  By default SDL will use Xinerama if it is available.
+ */
+#define SDL_HINT_VIDEO_X11_XINERAMA         "SDL_VIDEO_X11_XINERAMA"
+
+/**
+ *  \brief  A variable controlling whether the X11 XRandR extension should be used.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Disable XRandR
+ *    "1"       - Enable XRandR
+ *
+ *  By default SDL will not use XRandR because of window manager issues.
+ */
+#define SDL_HINT_VIDEO_X11_XRANDR           "SDL_VIDEO_X11_XRANDR"
+
+/**
+ *  \brief  A variable controlling whether the X11 VidMode extension should be used.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Disable XVidMode
+ *    "1"       - Enable XVidMode
+ *
+ *  By default SDL will use XVidMode if it is available.
+ */
+#define SDL_HINT_VIDEO_X11_XVIDMODE         "SDL_VIDEO_X11_XVIDMODE"
+
+/**
+ *  \brief  Controls how the fact chunk affects the loading of a WAVE file.
+ *
+ *  The fact chunk stores information about the number of samples of a WAVE
+ *  file. The Standards Update from Microsoft notes that this value can be used
+ *  to 'determine the length of the data in seconds'. This is especially useful
+ *  for compressed formats (for which this is a mandatory chunk) if they produce
+ *  multiple sample frames per block and truncating the block is not allowed.
+ *  The fact chunk can exactly specify how many sample frames there should be
+ *  in this case.
+ *
+ *  Unfortunately, most application seem to ignore the fact chunk and so SDL
+ *  ignores it by default as well.
+ *
+ *  This variable can be set to the following values:
+ *
+ *    "truncate"    - Use the number of samples to truncate the wave data if
+ *                    the fact chunk is present and valid
+ *    "strict"      - Like "truncate", but raise an error if the fact chunk
+ *                    is invalid, not present for non-PCM formats, or if the
+ *                    data chunk doesn't have that many samples
+ *    "ignorezero"  - Like "truncate", but ignore fact chunk if the number of
+ *                    samples is zero
+ *    "ignore"      - Ignore fact chunk entirely (default)
+ */
+#define SDL_HINT_WAVE_FACT_CHUNK   "SDL_WAVE_FACT_CHUNK"
+
+/**
+ *  \brief  Controls how the size of the RIFF chunk affects the loading of a WAVE file.
+ *
+ *  The size of the RIFF chunk (which includes all the sub-chunks of the WAVE
+ *  file) is not always reliable. In case the size is wrong, it's possible to
+ *  just ignore it and step through the chunks until a fixed limit is reached.
+ *
+ *  Note that files that have trailing data unrelated to the WAVE file or
+ *  corrupt files may slow down the loading process without a reliable boundary.
+ *  By default, SDL stops after 10000 chunks to prevent wasting time. Use the
+ *  environment variable SDL_WAVE_CHUNK_LIMIT to adjust this value.
+ *
+ *  This variable can be set to the following values:
+ *
+ *    "force"        - Always use the RIFF chunk size as a boundary for the chunk search
+ *    "ignorezero"   - Like "force", but a zero size searches up to 4 GiB (default)
+ *    "ignore"       - Ignore the RIFF chunk size and always search up to 4 GiB
+ *    "maximum"      - Search for chunks until the end of file (not recommended)
+ */
+#define SDL_HINT_WAVE_RIFF_CHUNK_SIZE   "SDL_WAVE_RIFF_CHUNK_SIZE"
+
+/**
+ *  \brief  Controls how a truncated WAVE file is handled.
+ *
+ *  A WAVE file is considered truncated if any of the chunks are incomplete or
+ *  the data chunk size is not a multiple of the block size. By default, SDL
+ *  decodes until the first incomplete block, as most applications seem to do.
+ *
+ *  This variable can be set to the following values:
+ *
+ *    "verystrict" - Raise an error if the file is truncated
+ *    "strict"     - Like "verystrict", but the size of the RIFF chunk is ignored
+ *    "dropframe"  - Decode until the first incomplete sample frame
+ *    "dropblock"  - Decode until the first incomplete block (default)
+ */
+#define SDL_HINT_WAVE_TRUNCATION   "SDL_WAVE_TRUNCATION"
+
+/**
+ * \brief Tell SDL not to name threads on Windows with the 0x406D1388 Exception.
+ *        The 0x406D1388 Exception is a trick used to inform Visual Studio of a
+ *        thread's name, but it tends to cause problems with other debuggers,
+ *        and the .NET runtime. Note that SDL 2.0.6 and later will still use
+ *        the (safer) SetThreadDescription API, introduced in the Windows 10
+ *        Creators Update, if available.
+ *
+ * The variable can be set to the following values:
+ *   "0"       - SDL will raise the 0x406D1388 Exception to name threads.
+ *               This is the default behavior of SDL <= 2.0.4.
+ *   "1"       - SDL will not raise this exception, and threads will be unnamed. (default)
+ *               This is necessary with .NET languages or debuggers that aren't Visual Studio.
+ */
+#define SDL_HINT_WINDOWS_DISABLE_THREAD_NAMING "SDL_WINDOWS_DISABLE_THREAD_NAMING"
+
+/**
+ *  \brief  A variable controlling whether the windows message loop is processed by SDL 
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - The window message loop is not run
+ *    "1"       - The window message loop is processed in SDL_PumpEvents()
+ *
+ *  By default SDL will process the windows message loop
+ */
+#define SDL_HINT_WINDOWS_ENABLE_MESSAGELOOP "SDL_WINDOWS_ENABLE_MESSAGELOOP"
+
+/**
+ * \brief Force SDL to use Critical Sections for mutexes on Windows.
+ *        On Windows 7 and newer, Slim Reader/Writer Locks are available.
+ *        They offer better performance, allocate no kernel ressources and
+ *        use less memory. SDL will fall back to Critical Sections on older
+ *        OS versions or if forced to by this hint.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Use SRW Locks when available. If not, fall back to Critical Sections. (default)
+ *    "1"       - Force the use of Critical Sections in all cases.
+ *
+ */
+#define SDL_HINT_WINDOWS_FORCE_MUTEX_CRITICAL_SECTIONS "SDL_WINDOWS_FORCE_MUTEX_CRITICAL_SECTIONS"
+
+/**
+ * \brief Force SDL to use Kernel Semaphores on Windows.
+ *        Kernel Semaphores are inter-process and require a context
+ *        switch on every interaction. On Windows 8 and newer, the
+ *        WaitOnAddress API is available. Using that and atomics to
+ *        implement semaphores increases performance.
+ *        SDL will fall back to Kernel Objects on older OS versions
+ *        or if forced to by this hint.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Use Atomics and WaitOnAddress API when available. If not, fall back to Kernel Objects. (default)
+ *    "1"       - Force the use of Kernel Objects in all cases.
+ *
+ */
+#define SDL_HINT_WINDOWS_FORCE_SEMAPHORE_KERNEL "SDL_WINDOWS_FORCE_SEMAPHORE_KERNEL"
+
+/**
+ * \brief A variable to specify custom icon resource id from RC file on Windows platform 
+ */
+#define SDL_HINT_WINDOWS_INTRESOURCE_ICON       "SDL_WINDOWS_INTRESOURCE_ICON"
+#define SDL_HINT_WINDOWS_INTRESOURCE_ICON_SMALL "SDL_WINDOWS_INTRESOURCE_ICON_SMALL"
+
+/**
+ *  \brief Tell SDL not to generate window-close events for Alt+F4 on Windows.
+ *
+ * The variable can be set to the following values:
+ *   "0"       - SDL will generate a window-close event when it sees Alt+F4.
+ *   "1"       - SDL will only do normal key handling for Alt+F4.
+ */
+#define SDL_HINT_WINDOWS_NO_CLOSE_ON_ALT_F4 "SDL_WINDOWS_NO_CLOSE_ON_ALT_F4"
+
+/**
+ * \brief Use the D3D9Ex API introduced in Windows Vista, instead of normal D3D9.
+ *        Direct3D 9Ex contains changes to state management that can eliminate device
+ *        loss errors during scenarios like Alt+Tab or UAC prompts. D3D9Ex may require
+ *        some changes to your application to cope with the new behavior, so this
+ *        is disabled by default.
+ *
+ *  This hint must be set before initializing the video subsystem.
+ *
+ *  For more information on Direct3D 9Ex, see:
+ *    - https://docs.microsoft.com/en-us/windows/win32/direct3darticles/graphics-apis-in-windows-vista#direct3d-9ex
+ *    - https://docs.microsoft.com/en-us/windows/win32/direct3darticles/direct3d-9ex-improvements
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Use the original Direct3D 9 API (default)
+ *    "1"       - Use the Direct3D 9Ex API on Vista and later (and fall back if D3D9Ex is unavailable)
+ *
+ */
+#define SDL_HINT_WINDOWS_USE_D3D9EX "SDL_WINDOWS_USE_D3D9EX"
+
+/**
+ *  \brief  A variable controlling whether the window frame and title bar are interactive when the cursor is hidden 
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - The window frame is not interactive when the cursor is hidden (no move, resize, etc)
+ *    "1"       - The window frame is interactive when the cursor is hidden
+ *
+ *  By default SDL will allow interaction with the window frame when the cursor is hidden
+ */
+#define SDL_HINT_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN    "SDL_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN"
+
+/**
+*  \brief  A variable controlling whether the window is activated when the SDL_ShowWindow function is called 
+*
+*  This variable can be set to the following values:
+*    "0"       - The window is activated when the SDL_ShowWindow function is called
+*    "1"       - The window is not activated when the SDL_ShowWindow function is called
+*
+*  By default SDL will activate the window when the SDL_ShowWindow function is called
+*/
+#define SDL_HINT_WINDOW_NO_ACTIVATION_WHEN_SHOWN    "SDL_WINDOW_NO_ACTIVATION_WHEN_SHOWN"
 
 /** \brief Allows back-button-press events on Windows Phone to be marked as handled
  *
@@ -980,510 +1826,146 @@ extern "C" {
  */
 #define SDL_HINT_WINRT_HANDLE_BACK_BUTTON "SDL_WINRT_HANDLE_BACK_BUTTON"
 
-/**
- *  \brief  A variable that dictates policy for fullscreen Spaces on Mac OS X.
+/** \brief Label text for a WinRT app's privacy policy link
  *
- *  This hint only applies to Mac OS X.
+ *  Network-enabled WinRT apps must include a privacy policy.  On Windows 8, 8.1, and RT,
+ *  Microsoft mandates that this policy be available via the Windows Settings charm.
+ *  SDL provides code to add a link there, with its label text being set via the
+ *  optional hint, SDL_HINT_WINRT_PRIVACY_POLICY_LABEL.
+ *
+ *  Please note that a privacy policy's contents are not set via this hint.  A separate
+ *  hint, SDL_HINT_WINRT_PRIVACY_POLICY_URL, is used to link to the actual text of the
+ *  policy.
+ *
+ *  The contents of this hint should be encoded as a UTF8 string.
+ *
+ *  The default value is "Privacy Policy".  This hint should only be set during app
+ *  initialization, preferably before any calls to SDL_Init().
+ *
+ *  For additional information on linking to a privacy policy, see the documentation for
+ *  SDL_HINT_WINRT_PRIVACY_POLICY_URL.
+ */
+#define SDL_HINT_WINRT_PRIVACY_POLICY_LABEL "SDL_WINRT_PRIVACY_POLICY_LABEL"
+
+/**
+ *  \brief A URL to a WinRT app's privacy policy
+ *
+ *  All network-enabled WinRT apps must make a privacy policy available to its
+ *  users.  On Windows 8, 8.1, and RT, Microsoft mandates that this policy be
+ *  be available in the Windows Settings charm, as accessed from within the app.
+ *  SDL provides code to add a URL-based link there, which can point to the app's
+ *  privacy policy.
+ *
+ *  To setup a URL to an app's privacy policy, set SDL_HINT_WINRT_PRIVACY_POLICY_URL
+ *  before calling any SDL_Init() functions.  The contents of the hint should
+ *  be a valid URL.  For example, "http://www.example.com".
+ *
+ *  The default value is "", which will prevent SDL from adding a privacy policy
+ *  link to the Settings charm.  This hint should only be set during app init.
+ *
+ *  The label text of an app's "Privacy Policy" link may be customized via another
+ *  hint, SDL_HINT_WINRT_PRIVACY_POLICY_LABEL.
+ *
+ *  Please note that on Windows Phone, Microsoft does not provide standard UI
+ *  for displaying a privacy policy link, and as such, SDL_HINT_WINRT_PRIVACY_POLICY_URL
+ *  will not get used on that platform.  Network-enabled phone apps should display
+ *  their privacy policy through some other, in-app means.
+ */
+#define SDL_HINT_WINRT_PRIVACY_POLICY_URL "SDL_WINRT_PRIVACY_POLICY_URL"
+
+/**
+ *  \brief Mark X11 windows as override-redirect.
+ *
+ *  If set, this _might_ increase framerate at the expense of the desktop
+ *  not working as expected. Override-redirect windows aren't noticed by the
+ *  window manager at all.
+ *
+ *  You should probably only use this for fullscreen windows, and you probably
+ *  shouldn't even use it for that. But it's here if you want to try!
+ */
+#define SDL_HINT_X11_FORCE_OVERRIDE_REDIRECT "SDL_X11_FORCE_OVERRIDE_REDIRECT"
+
+/**
+ *  \brief  A variable that lets you disable the detection and use of Xinput gamepad devices
  *
  *  The variable can be set to the following values:
- *    "0"       - Disable Spaces support (FULLSCREEN_DESKTOP won't use them and
- *                SDL_WINDOW_RESIZABLE windows won't offer the "fullscreen"
- *                button on their titlebars).
- *    "1"       - Enable Spaces support (FULLSCREEN_DESKTOP will use them and
- *                SDL_WINDOW_RESIZABLE windows will offer the "fullscreen"
- *                button on their titlebars).
- *
- *  The default value is "1". Spaces are disabled regardless of this hint if
- *   the OS isn't at least Mac OS X Lion (10.7). This hint must be set before
- *   any windows are created.
+ *    "0"       - Disable XInput detection (only uses direct input)
+ *    "1"       - Enable XInput detection (the default)
  */
-#define SDL_HINT_VIDEO_MAC_FULLSCREEN_SPACES    "SDL_VIDEO_MAC_FULLSCREEN_SPACES"
+#define SDL_HINT_XINPUT_ENABLED "SDL_XINPUT_ENABLED"
 
 /**
-*  \brief  When set don't force the SDL app to become a foreground process
-*
-*  This hint only applies to Mac OS X.
-*
-*/
-#define SDL_HINT_MAC_BACKGROUND_APP    "SDL_MAC_BACKGROUND_APP"
+ *  \brief  A variable that causes SDL to use the old axis and button mapping for XInput devices.
+ *
+ *  This hint is for backwards compatibility only and will be removed in SDL 2.1
+ *
+ *  The default value is "0".  This hint must be set before SDL_Init()
+ */
+#define SDL_HINT_XINPUT_USE_OLD_JOYSTICK_MAPPING "SDL_XINPUT_USE_OLD_JOYSTICK_MAPPING"
 
 /**
- * \brief Android APK expansion main file version. Should be a string number like "1", "2" etc.
+ *  \brief  A variable that causes SDL to not ignore audio "monitors"
  *
- * Must be set together with SDL_HINT_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION.
+ *  This is currently only used for PulseAudio and ignored elsewhere.
  *
- * If both hints were set then SDL_RWFromFile() will look into expansion files
- * after a given relative path was not found in the internal storage and assets.
+ *  By default, SDL ignores audio devices that aren't associated with physical
+ *  hardware. Changing this hint to "1" will expose anything SDL sees that
+ *  appears to be an audio source or sink. This will add "devices" to the list
+ *  that the user probably doesn't want or need, but it can be useful in
+ *  scenarios where you want to hook up SDL to some sort of virtual device,
+ *  etc.
  *
- * By default this hint is not set and the APK expansion files are not searched.
+ *  The default value is "0".  This hint must be set before SDL_Init().
+ *
+ *  This hint is available since SDL 2.0.16. Before then, virtual devices are
+ *  always ignored.
  */
-#define SDL_HINT_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION "SDL_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION"
- 
-/**
- * \brief Android APK expansion patch file version. Should be a string number like "1", "2" etc.
- *
- * Must be set together with SDL_HINT_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION.
- *
- * If both hints were set then SDL_RWFromFile() will look into expansion files
- * after a given relative path was not found in the internal storage and assets.
- *
- * By default this hint is not set and the APK expansion files are not searched.
- */
-#define SDL_HINT_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION "SDL_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION"
+#define SDL_HINT_AUDIO_INCLUDE_MONITORS "SDL_AUDIO_INCLUDE_MONITORS"
 
 /**
- * \brief A variable to control whether certain IMEs should handle text editing internally instead of sending SDL_TEXTEDITING events.
+ *  \brief  A variable that forces X11 windows to create as a custom type.
  *
- * The variable can be set to the following values:
- *   "0"       - SDL_TEXTEDITING events are sent, and it is the application's
- *               responsibility to render the text from these events and 
- *               differentiate it somehow from committed text. (default)
- *   "1"       - If supported by the IME then SDL_TEXTEDITING events are not sent, 
- *               and text that is being composed will be rendered in its own UI.
+ *  This is currently only used for X11 and ignored elsewhere.
+ *
+ *  During SDL_CreateWindow, SDL uses the _NET_WM_WINDOW_TYPE X11 property
+ *  to report to the window manager the type of window it wants to create.
+ *  This might be set to various things if SDL_WINDOW_TOOLTIP or
+ *  SDL_WINDOW_POPUP_MENU, etc, were specified. For "normal" windows that
+ *  haven't set a specific type, this hint can be used to specify a custom
+ *  type. For example, a dock window might set this to
+ *  "_NET_WM_WINDOW_TYPE_DOCK".
+ *
+ *  If not set or set to "", this hint is ignored. This hint must be set
+ *  before the SDL_CreateWindow() call that it is intended to affect.
+ *
+ *  This hint is available since SDL 2.0.22. Before then, virtual devices are
+ *  always ignored.
  */
-#define SDL_HINT_IME_INTERNAL_EDITING "SDL_IME_INTERNAL_EDITING"
+#define SDL_HINT_X11_WINDOW_TYPE "SDL_X11_WINDOW_TYPE"
 
 /**
- * \brief A variable to control whether we trap the Android back button to handle it manually.
- *        This is necessary for the right mouse button to work on some Android devices, or
- *        to be able to trap the back button for use in your code reliably.  If set to true,
- *        the back button will show up as an SDL_KEYDOWN / SDL_KEYUP pair with a keycode of 
- *        SDL_SCANCODE_AC_BACK.
+ *  \brief  A variable that decides whether to send SDL_QUIT when closing the final window.
  *
- * The variable can be set to the following values:
- *   "0"       - Back button will be handled as usual for system. (default)
- *   "1"       - Back button will be trapped, allowing you to handle the key press
- *               manually.  (This will also let right mouse click work on systems 
- *               where the right mouse button functions as back.)
+ *  By default, SDL sends an SDL_QUIT event when there is only one window
+ *  and it receives an SDL_WINDOWEVENT_CLOSE event, under the assumption most
+ *  apps would also take the loss of this window as a signal to terminate the
+ *  program.
  *
- * The value of this hint is used at runtime, so it can be changed at any time.
+ *  However, it's not unreasonable in some cases to have the program continue
+ *  to live on, perhaps to create new windows later.
+ *
+ *  Changing this hint to "0" will cause SDL to not send an SDL_QUIT event
+ *  when the final window is requesting to close. Note that in this case,
+ *  there are still other legitimate reasons one might get an SDL_QUIT
+ *  event: choosing "Quit" from the macOS menu bar, sending a SIGINT (ctrl-c)
+ *  on Unix, etc.
+ *
+ *  The default value is "1".  This hint can be changed at any time.
+ *
+ *  This hint is available since SDL 2.0.22. Before then, you always get
+ *  an SDL_QUIT event when closing the final window.
  */
-#define SDL_HINT_ANDROID_TRAP_BACK_BUTTON "SDL_ANDROID_TRAP_BACK_BUTTON"
-
-/**
- * \brief A variable to control whether the event loop will block itself when the app is paused.
- *
- * The variable can be set to the following values:
- *   "0"       - Non blocking.
- *   "1"       - Blocking. (default)
- *
- * The value should be set before SDL is initialized.
- */
-#define SDL_HINT_ANDROID_BLOCK_ON_PAUSE "SDL_ANDROID_BLOCK_ON_PAUSE"
-
-/**
- * \brief A variable to control whether SDL will pause audio in background
- *        (Requires SDL_ANDROID_BLOCK_ON_PAUSE as "Non blocking")
- *
- * The variable can be set to the following values:
- *   "0"       - Non paused.
- *   "1"       - Paused. (default)
- *
- * The value should be set before SDL is initialized.
- */
-#define SDL_HINT_ANDROID_BLOCK_ON_PAUSE_PAUSEAUDIO "SDL_ANDROID_BLOCK_ON_PAUSE_PAUSEAUDIO"
-
- /**
- * \brief A variable to control whether the return key on the soft keyboard
- *        should hide the soft keyboard on Android and iOS.
- *
- * The variable can be set to the following values:
- *   "0"       - The return key will be handled as a key event. This is the behaviour of SDL <= 2.0.3. (default)
- *   "1"       - The return key will hide the keyboard.
- *
- * The value of this hint is used at runtime, so it can be changed at any time.
- */
-#define SDL_HINT_RETURN_KEY_HIDES_IME "SDL_RETURN_KEY_HIDES_IME"
-
-/**
- *  \brief override the binding element for keyboard inputs for Emscripten builds
- *
- * This hint only applies to the emscripten platform
- *
- * The variable can be one of
- *    "#window"      - The javascript window object (this is the default)
- *    "#document"    - The javascript document object
- *    "#screen"      - the javascript window.screen object
- *    "#canvas"      - the WebGL canvas element
- *    any other string without a leading # sign applies to the element on the page with that ID.
- */
-#define SDL_HINT_EMSCRIPTEN_KEYBOARD_ELEMENT   "SDL_EMSCRIPTEN_KEYBOARD_ELEMENT"
-
-/**
- *  \brief Disable giving back control to the browser automatically
- *  when running with asyncify
- *
- * With -s ASYNCIFY, SDL2 calls emscripten_sleep during operations
- * such as refreshing the screen or polling events.
- *
- * This hint only applies to the emscripten platform
- *
- * The variable can be set to the following values:
- *    "0"       - Disable emscripten_sleep calls (if you give back browser control manually or use asyncify for other purposes)
- *    "1"       - Enable emscripten_sleep calls (the default)
- */
-#define SDL_HINT_EMSCRIPTEN_ASYNCIFY   "SDL_EMSCRIPTEN_ASYNCIFY"
-
-/**
- *  \brief Tell SDL not to catch the SIGINT or SIGTERM signals.
- *
- * This hint only applies to Unix-like platforms, and should set before
- * any calls to SDL_Init()
- *
- * The variable can be set to the following values:
- *   "0"       - SDL will install a SIGINT and SIGTERM handler, and when it
- *               catches a signal, convert it into an SDL_QUIT event.
- *   "1"       - SDL will not install a signal handler at all.
- */
-#define SDL_HINT_NO_SIGNAL_HANDLERS   "SDL_NO_SIGNAL_HANDLERS"
-
-/**
- *  \brief Tell SDL not to generate window-close events for Alt+F4 on Windows.
- *
- * The variable can be set to the following values:
- *   "0"       - SDL will generate a window-close event when it sees Alt+F4.
- *   "1"       - SDL will only do normal key handling for Alt+F4.
- */
-#define SDL_HINT_WINDOWS_NO_CLOSE_ON_ALT_F4 "SDL_WINDOWS_NO_CLOSE_ON_ALT_F4"
-
-/**
- *  \brief Prevent SDL from using version 4 of the bitmap header when saving BMPs.
- *
- * The bitmap header version 4 is required for proper alpha channel support and
- * SDL will use it when required. Should this not be desired, this hint can
- * force the use of the 40 byte header version which is supported everywhere.
- *
- * The variable can be set to the following values:
- *   "0"       - Surfaces with a colorkey or an alpha channel are saved to a
- *               32-bit BMP file with an alpha mask. SDL will use the bitmap
- *               header version 4 and set the alpha mask accordingly.
- *   "1"       - Surfaces with a colorkey or an alpha channel are saved to a
- *               32-bit BMP file without an alpha mask. The alpha channel data
- *               will be in the file, but applications are going to ignore it.
- *
- * The default value is "0".
- */
-#define SDL_HINT_BMP_SAVE_LEGACY_FORMAT "SDL_BMP_SAVE_LEGACY_FORMAT"
-
-/**
- * \brief Tell SDL not to name threads on Windows with the 0x406D1388 Exception.
- *        The 0x406D1388 Exception is a trick used to inform Visual Studio of a
- *        thread's name, but it tends to cause problems with other debuggers,
- *        and the .NET runtime. Note that SDL 2.0.6 and later will still use
- *        the (safer) SetThreadDescription API, introduced in the Windows 10
- *        Creators Update, if available.
- *
- * The variable can be set to the following values:
- *   "0"       - SDL will raise the 0x406D1388 Exception to name threads.
- *               This is the default behavior of SDL <= 2.0.4.
- *   "1"       - SDL will not raise this exception, and threads will be unnamed. (default)
- *               This is necessary with .NET languages or debuggers that aren't Visual Studio.
- */
-#define SDL_HINT_WINDOWS_DISABLE_THREAD_NAMING "SDL_WINDOWS_DISABLE_THREAD_NAMING"
-
-/**
- * \brief Tell SDL which Dispmanx layer to use on a Raspberry PI
- *
- * Also known as Z-order. The variable can take a negative or positive value.
- * The default is 10000.
- */
-#define SDL_HINT_RPI_VIDEO_LAYER           "SDL_RPI_VIDEO_LAYER"
-
-/**
- * \brief Tell the video driver that we only want a double buffer.
- *
- * By default, most lowlevel 2D APIs will use a triple buffer scheme that 
- * wastes no CPU time on waiting for vsync after issuing a flip, but
- * introduces a frame of latency. On the other hand, using a double buffer
- * scheme instead is recommended for cases where low latency is an important
- * factor because we save a whole frame of latency.
- * We do so by waiting for vsync immediately after issuing a flip, usually just
- * after eglSwapBuffers call in the backend's *_SwapWindow function.
- *
- * Since it's driver-specific, it's only supported where possible and
- * implemented. Currently supported the following drivers:
- * - KMSDRM (kmsdrm)
- * - Raspberry Pi (raspberrypi)
- */
-#define SDL_HINT_VIDEO_DOUBLE_BUFFER      "SDL_VIDEO_DOUBLE_BUFFER"
-
-/**
- *  \brief  A variable controlling what driver to use for OpenGL ES contexts.
- *
- *  On some platforms, currently Windows and X11, OpenGL drivers may support
- *  creating contexts with an OpenGL ES profile. By default SDL uses these
- *  profiles, when available, otherwise it attempts to load an OpenGL ES
- *  library, e.g. that provided by the ANGLE project. This variable controls
- *  whether SDL follows this default behaviour or will always load an
- *  OpenGL ES library.
- *
- *  Circumstances where this is useful include
- *  - Testing an app with a particular OpenGL ES implementation, e.g ANGLE,
- *    or emulator, e.g. those from ARM, Imagination or Qualcomm.
- *  - Resolving OpenGL ES function addresses at link time by linking with
- *    the OpenGL ES library instead of querying them at run time with
- *    SDL_GL_GetProcAddress().
- *
- *  Caution: for an application to work with the default behaviour across
- *  different OpenGL drivers it must query the OpenGL ES function
- *  addresses at run time using SDL_GL_GetProcAddress().
- *
- *  This variable is ignored on most platforms because OpenGL ES is native
- *  or not supported.
- *
- *  This variable can be set to the following values:
- *    "0"       - Use ES profile of OpenGL, if available. (Default when not set.)
- *    "1"       - Load OpenGL ES library using the default library names.
- *
- */
-#define SDL_HINT_OPENGL_ES_DRIVER   "SDL_OPENGL_ES_DRIVER"
-
-/**
- *  \brief  A variable controlling speed/quality tradeoff of audio resampling.
- *
- *  If available, SDL can use libsamplerate ( http://www.mega-nerd.com/SRC/ )
- *  to handle audio resampling. There are different resampling modes available
- *  that produce different levels of quality, using more CPU.
- *
- *  If this hint isn't specified to a valid setting, or libsamplerate isn't
- *  available, SDL will use the default, internal resampling algorithm.
- *
- *  Note that this is currently only applicable to resampling audio that is
- *  being written to a device for playback or audio being read from a device
- *  for capture. SDL_AudioCVT always uses the default resampler (although this
- *  might change for SDL 2.1).
- *
- *  This hint is currently only checked at audio subsystem initialization.
- *
- *  This variable can be set to the following values:
- *
- *    "0" or "default" - Use SDL's internal resampling (Default when not set - low quality, fast)
- *    "1" or "fast"    - Use fast, slightly higher quality resampling, if available
- *    "2" or "medium"  - Use medium quality resampling, if available
- *    "3" or "best"    - Use high quality resampling, if available
- */
-#define SDL_HINT_AUDIO_RESAMPLING_MODE   "SDL_AUDIO_RESAMPLING_MODE"
-
-/**
- *  \brief  A variable controlling the audio category on iOS and Mac OS X
- *
- *  This variable can be set to the following values:
- *
- *    "ambient"     - Use the AVAudioSessionCategoryAmbient audio category, will be muted by the phone mute switch (default)
- *    "playback"    - Use the AVAudioSessionCategoryPlayback category
- *
- *  For more information, see Apple's documentation:
- *  https://developer.apple.com/library/content/documentation/Audio/Conceptual/AudioSessionProgrammingGuide/AudioSessionCategoriesandModes/AudioSessionCategoriesandModes.html
- */
-#define SDL_HINT_AUDIO_CATEGORY   "SDL_AUDIO_CATEGORY"
-
-/**
- *  \brief  A variable controlling whether the 2D render API is compatible or efficient.
- *
- *  This variable can be set to the following values:
- *
- *    "0"     - Don't use batching to make rendering more efficient.
- *    "1"     - Use batching, but might cause problems if app makes its own direct OpenGL calls.
- *
- *  Up to SDL 2.0.9, the render API would draw immediately when requested. Now
- *  it batches up draw requests and sends them all to the GPU only when forced
- *  to (during SDL_RenderPresent, when changing render targets, by updating a
- *  texture that the batch needs, etc). This is significantly more efficient,
- *  but it can cause problems for apps that expect to render on top of the
- *  render API's output. As such, SDL will disable batching if a specific
- *  render backend is requested (since this might indicate that the app is
- *  planning to use the underlying graphics API directly). This hint can
- *  be used to explicitly request batching in this instance. It is a contract
- *  that you will either never use the underlying graphics API directly, or
- *  if you do, you will call SDL_RenderFlush() before you do so any current
- *  batch goes to the GPU before your work begins. Not following this contract
- *  will result in undefined behavior.
- */
-#define SDL_HINT_RENDER_BATCHING  "SDL_RENDER_BATCHING"
-
-
-/**
- *  \brief  A variable controlling whether SDL updates joystick state when getting input events
- *
- *  This variable can be set to the following values:
- *
- *    "0"     - You'll call SDL_JoystickUpdate() manually
- *    "1"     - SDL will automatically call SDL_JoystickUpdate() (default)
- *
- *  This hint can be toggled on and off at runtime.
- */
-#define SDL_HINT_AUTO_UPDATE_JOYSTICKS  "SDL_AUTO_UPDATE_JOYSTICKS"
-
-
-/**
- *  \brief  A variable controlling whether SDL updates sensor state when getting input events
- *
- *  This variable can be set to the following values:
- *
- *    "0"     - You'll call SDL_SensorUpdate() manually
- *    "1"     - SDL will automatically call SDL_SensorUpdate() (default)
- *
- *  This hint can be toggled on and off at runtime.
- */
-#define SDL_HINT_AUTO_UPDATE_SENSORS    "SDL_AUTO_UPDATE_SENSORS"
-
-
-/**
- *  \brief  A variable controlling whether SDL logs all events pushed onto its internal queue.
- *
- *  This variable can be set to the following values:
- *
- *    "0"     - Don't log any events (default)
- *    "1"     - Log all events except mouse and finger motion, which are pretty spammy.
- *    "2"     - Log all events.
- *
- *  This is generally meant to be used to debug SDL itself, but can be useful
- *  for application developers that need better visibility into what is going
- *  on in the event queue. Logged events are sent through SDL_Log(), which
- *  means by default they appear on stdout on most platforms or maybe
- *  OutputDebugString() on Windows, and can be funneled by the app with
- *  SDL_LogSetOutputFunction(), etc.
- *
- *  This hint can be toggled on and off at runtime, if you only need to log
- *  events for a small subset of program execution.
- */
-#define SDL_HINT_EVENT_LOGGING   "SDL_EVENT_LOGGING"
-
-
-
-/**
- *  \brief  Controls how the size of the RIFF chunk affects the loading of a WAVE file.
- *
- *  The size of the RIFF chunk (which includes all the sub-chunks of the WAVE
- *  file) is not always reliable. In case the size is wrong, it's possible to
- *  just ignore it and step through the chunks until a fixed limit is reached.
- *
- *  Note that files that have trailing data unrelated to the WAVE file or
- *  corrupt files may slow down the loading process without a reliable boundary.
- *  By default, SDL stops after 10000 chunks to prevent wasting time. Use the
- *  environment variable SDL_WAVE_CHUNK_LIMIT to adjust this value.
- *
- *  This variable can be set to the following values:
- *
- *    "force"        - Always use the RIFF chunk size as a boundary for the chunk search
- *    "ignorezero"   - Like "force", but a zero size searches up to 4 GiB (default)
- *    "ignore"       - Ignore the RIFF chunk size and always search up to 4 GiB
- *    "maximum"      - Search for chunks until the end of file (not recommended)
- */
-#define SDL_HINT_WAVE_RIFF_CHUNK_SIZE   "SDL_WAVE_RIFF_CHUNK_SIZE"
-
-/**
- *  \brief  Controls how a truncated WAVE file is handled.
- *
- *  A WAVE file is considered truncated if any of the chunks are incomplete or
- *  the data chunk size is not a multiple of the block size. By default, SDL
- *  decodes until the first incomplete block, as most applications seem to do.
- *
- *  This variable can be set to the following values:
- *
- *    "verystrict" - Raise an error if the file is truncated
- *    "strict"     - Like "verystrict", but the size of the RIFF chunk is ignored
- *    "dropframe"  - Decode until the first incomplete sample frame
- *    "dropblock"  - Decode until the first incomplete block (default)
- */
-#define SDL_HINT_WAVE_TRUNCATION   "SDL_WAVE_TRUNCATION"
-
-/**
- *  \brief  Controls how the fact chunk affects the loading of a WAVE file.
- *
- *  The fact chunk stores information about the number of samples of a WAVE
- *  file. The Standards Update from Microsoft notes that this value can be used
- *  to 'determine the length of the data in seconds'. This is especially useful
- *  for compressed formats (for which this is a mandatory chunk) if they produce
- *  multiple sample frames per block and truncating the block is not allowed.
- *  The fact chunk can exactly specify how many sample frames there should be
- *  in this case.
- *
- *  Unfortunately, most application seem to ignore the fact chunk and so SDL
- *  ignores it by default as well.
- *
- *  This variable can be set to the following values:
- *
- *    "truncate"    - Use the number of samples to truncate the wave data if
- *                    the fact chunk is present and valid
- *    "strict"      - Like "truncate", but raise an error if the fact chunk
- *                    is invalid, not present for non-PCM formats, or if the
- *                    data chunk doesn't have that many samples
- *    "ignorezero"  - Like "truncate", but ignore fact chunk if the number of
- *                    samples is zero
- *    "ignore"      - Ignore fact chunk entirely (default)
- */
-#define SDL_HINT_WAVE_FACT_CHUNK   "SDL_WAVE_FACT_CHUNK"
-
-/**
- *  \brief Override for SDL_GetDisplayUsableBounds()
- *
- *  If set, this hint will override the expected results for
- *  SDL_GetDisplayUsableBounds() for display index 0. Generally you don't want
- *  to do this, but this allows an embedded system to request that some of the
- *  screen be reserved for other uses when paired with a well-behaved
- *  application.
- *
- *  The contents of this hint must be 4 comma-separated integers, the first
- *  is the bounds x, then y, width and height, in that order.
- */
-#define SDL_HINT_DISPLAY_USABLE_BOUNDS "SDL_DISPLAY_USABLE_BOUNDS"
-
-/**
- *  \brief Specify an application name for an audio device.
- *
- * Some audio backends (such as PulseAudio) allow you to describe your audio
- * stream. Among other things, this description might show up in a system
- * control panel that lets the user adjust the volume on specific audio
- * streams instead of using one giant master volume slider.
- *
- * This hints lets you transmit that information to the OS. The contents of
- * this hint are used while opening an audio device. You should use a string
- * that describes your program ("My Game 2: The Revenge")
- *
- * Setting this to "" or leaving it unset will have SDL use a reasonable
- * default: probably the application's name or "SDL Application" if SDL
- * doesn't have any better information.
- *
- * On targets where this is not supported, this hint does nothing.
- */
-#define SDL_HINT_AUDIO_DEVICE_APP_NAME "SDL_AUDIO_DEVICE_APP_NAME"
-
-/**
- *  \brief Specify an application name for an audio device.
- *
- * Some audio backends (such as PulseAudio) allow you to describe your audio
- * stream. Among other things, this description might show up in a system
- * control panel that lets the user adjust the volume on specific audio
- * streams instead of using one giant master volume slider.
- *
- * This hints lets you transmit that information to the OS. The contents of
- * this hint are used while opening an audio device. You should use a string
- * that describes your what your program is playing ("audio stream" is
- * probably sufficient in many cases, but this could be useful for something
- * like "team chat" if you have a headset playing VoIP audio separately).
- *
- * Setting this to "" or leaving it unset will have SDL use a reasonable
- * default: "audio stream" or something similar.
- *
- * On targets where this is not supported, this hint does nothing.
- */
-#define SDL_HINT_AUDIO_DEVICE_STREAM_NAME "SDL_AUDIO_DEVICE_STREAM_NAME"
-
-
-/**
- *  \brief Override for SDL_GetPreferredLocales()
- *
- *  If set, this will be favored over anything the OS might report for the
- *  user's preferred locales. Changing this hint at runtime will not generate
- *  a SDL_LOCALECHANGED event (but if you can change the hint, you can push
- *  your own event, if you want).
- *
- *  The format of this hint is a comma-separated list of language and locale,
- *  combined with an underscore, as is a common format: "en_GB". Locale is
- *  optional: "en". So you might have a list like this: "en_GB,jp,es_PT"
- */
-#define SDL_HINT_PREFERRED_LOCALES "SDL_PREFERRED_LOCALES"
+#define SDL_HINT_QUIT_ON_LAST_WINDOW_CLOSE "SDL_QUIT_ON_LAST_WINDOW_CLOSE"
 
 
 /**
@@ -1498,71 +1980,121 @@ typedef enum
 
 
 /**
- *  \brief Set a hint with a specific priority
+ * Set a hint with a specific priority.
  *
- *  The priority controls the behavior when setting a hint that already
- *  has a value.  Hints will replace existing hints of their priority and
- *  lower.  Environment variables are considered to have override priority.
+ * The priority controls the behavior when setting a hint that already has a
+ * value. Hints will replace existing hints of their priority and lower.
+ * Environment variables are considered to have override priority.
  *
- *  \return SDL_TRUE if the hint was set, SDL_FALSE otherwise
+ * \param name the hint to set
+ * \param value the value of the hint variable
+ * \param priority the SDL_HintPriority level for the hint
+ * \returns SDL_TRUE if the hint was set, SDL_FALSE otherwise.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetHint
+ * \sa SDL_SetHint
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_SetHintWithPriority(const char *name,
                                                          const char *value,
                                                          SDL_HintPriority priority);
 
 /**
- *  \brief Set a hint with normal priority
+ * Set a hint with normal priority.
  *
- *  \return SDL_TRUE if the hint was set, SDL_FALSE otherwise
+ * Hints will not be set if there is an existing override hint or environment
+ * variable that takes precedence. You can use SDL_SetHintWithPriority() to
+ * set the hint with override priority instead.
+ *
+ * \param name the hint to set
+ * \param value the value of the hint variable
+ * \returns SDL_TRUE if the hint was set, SDL_FALSE otherwise.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetHint
+ * \sa SDL_SetHintWithPriority
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_SetHint(const char *name,
                                              const char *value);
 
 /**
- *  \brief Get a hint
+ * Get the value of a hint.
  *
- *  \return The string value of a hint variable.
+ * \param name the hint to query
+ * \returns the string value of a hint or NULL if the hint isn't set.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_SetHint
+ * \sa SDL_SetHintWithPriority
  */
 extern DECLSPEC const char * SDLCALL SDL_GetHint(const char *name);
 
 /**
- *  \brief Get a hint
+ * Get the boolean value of a hint variable.
  *
- *  \return The boolean value of a hint variable.
+ * \param name the name of the hint to get the boolean value from
+ * \param default_value the value to return if the hint does not exist
+ * \returns the boolean value of a hint or the provided default value if the
+ *          hint does not exist.
+ *
+ * \since This function is available since SDL 2.0.5.
+ *
+ * \sa SDL_GetHint
+ * \sa SDL_SetHint
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_GetHintBoolean(const char *name, SDL_bool default_value);
 
 /**
- * \brief type definition of the hint callback function.
+ * Type definition of the hint callback function.
+ *
+ * \param userdata what was passed as `userdata` to SDL_AddHintCallback()
+ * \param name what was passed as `name` to SDL_AddHintCallback()
+ * \param oldValue the previous hint value
+ * \param newValue the new value hint is to be set to
  */
 typedef void (SDLCALL *SDL_HintCallback)(void *userdata, const char *name, const char *oldValue, const char *newValue);
 
 /**
- *  \brief Add a function to watch a particular hint
+ * Add a function to watch a particular hint.
  *
- *  \param name The hint to watch
- *  \param callback The function to call when the hint value changes
- *  \param userdata A pointer to pass to the callback function
+ * \param name the hint to watch
+ * \param callback An SDL_HintCallback function that will be called when the
+ *                 hint value changes
+ * \param userdata a pointer to pass to the callback function
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_DelHintCallback
  */
 extern DECLSPEC void SDLCALL SDL_AddHintCallback(const char *name,
                                                  SDL_HintCallback callback,
                                                  void *userdata);
 
 /**
- *  \brief Remove a function watching a particular hint
+ * Remove a function watching a particular hint.
  *
- *  \param name The hint being watched
- *  \param callback The function being called when the hint value changes
- *  \param userdata A pointer being passed to the callback function
+ * \param name the hint being watched
+ * \param callback An SDL_HintCallback function that will be called when the
+ *                 hint value changes
+ * \param userdata a pointer being passed to the callback function
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_AddHintCallback
  */
 extern DECLSPEC void SDLCALL SDL_DelHintCallback(const char *name,
                                                  SDL_HintCallback callback,
                                                  void *userdata);
 
 /**
- *  \brief  Clear all hints
+ * Clear all hints.
  *
- *  This function is called during SDL_Quit() to free stored hints.
+ * This function is automatically called during SDL_Quit().
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC void SDLCALL SDL_ClearHints(void);
 
diff --git a/Engine/lib/sdl/include/SDL_joystick.h b/Engine/lib/sdl/include/SDL_joystick.h
index 0bbeafe0a..07e2b1561 100644
--- a/Engine/lib/sdl/include/SDL_joystick.h
+++ b/Engine/lib/sdl/include/SDL_joystick.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -30,10 +30,12 @@
  * The term "instance_id" is the current instantiation of a joystick device in the system, if the joystick is removed and then re-inserted
  *   then it will get a new instance_id, instance_id's are monotonically increasing identifiers of a joystick plugged in.
  *
+ * The term "player_index" is the number assigned to a player on a specific
+ *   controller. For XInput controllers this returns the XInput user index.
+ *   Many joysticks will not be able to supply this information.
+ *
  * The term JoystickGUID is a stable 128-bit identifier for a joystick device that does not change over time, it identifies class of
  *   the device (a X360 wired controller for example). This identifier is platform dependent.
- *
- *
  */
 
 #ifndef SDL_joystick_h_
@@ -122,92 +124,206 @@ typedef enum
  * In particular, you are guaranteed that the joystick list won't change, so
  * the API functions that take a joystick index will be valid, and joystick
  * and game controller events will not be delivered.
+ *
+ * \since This function is available since SDL 2.0.7.
  */
 extern DECLSPEC void SDLCALL SDL_LockJoysticks(void);
+
+
+/**
+ * Unlocking for multi-threaded access to the joystick API
+ *
+ * If you are using the joystick API or handling events from multiple threads
+ * you should use these locking functions to protect access to the joysticks.
+ *
+ * In particular, you are guaranteed that the joystick list won't change, so
+ * the API functions that take a joystick index will be valid, and joystick
+ * and game controller events will not be delivered.
+ *
+ * \since This function is available since SDL 2.0.7.
+ */
 extern DECLSPEC void SDLCALL SDL_UnlockJoysticks(void);
 
 /**
- *  Count the number of joysticks attached to the system right now
+ * Count the number of joysticks attached to the system.
+ *
+ * \returns the number of attached joysticks on success or a negative error
+ *          code on failure; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_JoystickName
+ * \sa SDL_JoystickOpen
  */
 extern DECLSPEC int SDLCALL SDL_NumJoysticks(void);
 
 /**
- *  Get the implementation dependent name of a joystick.
- *  This can be called before any joysticks are opened.
- *  If no name can be found, this function returns NULL.
+ * Get the implementation dependent name of a joystick.
+ *
+ * This can be called before any joysticks are opened.
+ *
+ * \param device_index the index of the joystick to query (the N'th joystick
+ *                     on the system)
+ * \returns the name of the selected joystick. If no name can be found, this
+ *          function returns NULL; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_JoystickName
+ * \sa SDL_JoystickOpen
  */
 extern DECLSPEC const char *SDLCALL SDL_JoystickNameForIndex(int device_index);
 
 /**
- *  Get the player index of a joystick, or -1 if it's not available
- *  This can be called before any joysticks are opened.
+ * Get the player index of a joystick, or -1 if it's not available This can be
+ * called before any joysticks are opened.
+ *
+ * \since This function is available since SDL 2.0.9.
  */
 extern DECLSPEC int SDLCALL SDL_JoystickGetDevicePlayerIndex(int device_index);
 
 /**
- *  Return the GUID for the joystick at this index
- *  This can be called before any joysticks are opened.
+ * Get the implementation-dependent GUID for the joystick at a given device
+ * index.
+ *
+ * This function can be called before any joysticks are opened.
+ *
+ * \param device_index the index of the joystick to query (the N'th joystick
+ *                     on the system
+ * \returns the GUID of the selected joystick. If called on an invalid index,
+ *          this function returns a zero GUID
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_JoystickGetGUID
+ * \sa SDL_JoystickGetGUIDString
  */
 extern DECLSPEC SDL_JoystickGUID SDLCALL SDL_JoystickGetDeviceGUID(int device_index);
 
 /**
- *  Get the USB vendor ID of a joystick, if available.
- *  This can be called before any joysticks are opened.
- *  If the vendor ID isn't available this function returns 0.
+ * Get the USB vendor ID of a joystick, if available.
+ *
+ * This can be called before any joysticks are opened. If the vendor ID isn't
+ * available this function returns 0.
+ *
+ * \param device_index the index of the joystick to query (the N'th joystick
+ *                     on the system
+ * \returns the USB vendor ID of the selected joystick. If called on an
+ *          invalid index, this function returns zero
+ *
+ * \since This function is available since SDL 2.0.6.
  */
 extern DECLSPEC Uint16 SDLCALL SDL_JoystickGetDeviceVendor(int device_index);
 
 /**
- *  Get the USB product ID of a joystick, if available.
- *  This can be called before any joysticks are opened.
- *  If the product ID isn't available this function returns 0.
+ * Get the USB product ID of a joystick, if available.
+ *
+ * This can be called before any joysticks are opened. If the product ID isn't
+ * available this function returns 0.
+ *
+ * \param device_index the index of the joystick to query (the N'th joystick
+ *                     on the system
+ * \returns the USB product ID of the selected joystick. If called on an
+ *          invalid index, this function returns zero
+ *
+ * \since This function is available since SDL 2.0.6.
  */
 extern DECLSPEC Uint16 SDLCALL SDL_JoystickGetDeviceProduct(int device_index);
 
 /**
- *  Get the product version of a joystick, if available.
- *  This can be called before any joysticks are opened.
- *  If the product version isn't available this function returns 0.
+ * Get the product version of a joystick, if available.
+ *
+ * This can be called before any joysticks are opened. If the product version
+ * isn't available this function returns 0.
+ *
+ * \param device_index the index of the joystick to query (the N'th joystick
+ *                     on the system
+ * \returns the product version of the selected joystick. If called on an
+ *          invalid index, this function returns zero
+ *
+ * \since This function is available since SDL 2.0.6.
  */
 extern DECLSPEC Uint16 SDLCALL SDL_JoystickGetDeviceProductVersion(int device_index);
 
 /**
- *  Get the type of a joystick, if available.
- *  This can be called before any joysticks are opened.
+ * Get the type of a joystick, if available.
+ *
+ * This can be called before any joysticks are opened.
+ *
+ * \param device_index the index of the joystick to query (the N'th joystick
+ *                     on the system
+ * \returns the SDL_JoystickType of the selected joystick. If called on an
+ *          invalid index, this function returns `SDL_JOYSTICK_TYPE_UNKNOWN`
+ *
+ * \since This function is available since SDL 2.0.6.
  */
 extern DECLSPEC SDL_JoystickType SDLCALL SDL_JoystickGetDeviceType(int device_index);
 
 /**
- *  Get the instance ID of a joystick.
- *  This can be called before any joysticks are opened.
- *  If the index is out of range, this function will return -1.
+ * Get the instance ID of a joystick.
+ *
+ * This can be called before any joysticks are opened. If the index is out of
+ * range, this function will return -1.
+ *
+ * \param device_index the index of the joystick to query (the N'th joystick
+ *                     on the system
+ * \returns the instance id of the selected joystick. If called on an invalid
+ *          index, this function returns zero
+ *
+ * \since This function is available since SDL 2.0.6.
  */
 extern DECLSPEC SDL_JoystickID SDLCALL SDL_JoystickGetDeviceInstanceID(int device_index);
 
 /**
- *  Open a joystick for use.
- *  The index passed as an argument refers to the N'th joystick on the system.
- *  This index is not the value which will identify this joystick in future
- *  joystick events.  The joystick's instance id (::SDL_JoystickID) will be used
- *  there instead.
+ * Open a joystick for use.
  *
- *  \return A joystick identifier, or NULL if an error occurred.
+ * The `device_index` argument refers to the N'th joystick presently
+ * recognized by SDL on the system. It is **NOT** the same as the instance ID
+ * used to identify the joystick in future events. See
+ * SDL_JoystickInstanceID() for more details about instance IDs.
+ *
+ * The joystick subsystem must be initialized before a joystick can be opened
+ * for use.
+ *
+ * \param device_index the index of the joystick to query
+ * \returns a joystick identifier or NULL if an error occurred; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_JoystickClose
+ * \sa SDL_JoystickInstanceID
  */
 extern DECLSPEC SDL_Joystick *SDLCALL SDL_JoystickOpen(int device_index);
 
 /**
- * Return the SDL_Joystick associated with an instance id.
+ * Get the SDL_Joystick associated with an instance id.
+ *
+ * \param instance_id the instance id to get the SDL_Joystick for
+ * \returns an SDL_Joystick on success or NULL on failure; call SDL_GetError()
+ *          for more information.
+ *
+ * \since This function is available since SDL 2.0.4.
  */
 extern DECLSPEC SDL_Joystick *SDLCALL SDL_JoystickFromInstanceID(SDL_JoystickID instance_id);
 
 /**
- * Return the SDL_Joystick associated with a player index.
+ * Get the SDL_Joystick associated with a player index.
+ *
+ * \param player_index the player index to get the SDL_Joystick for
+ * \returns an SDL_Joystick on success or NULL on failure; call SDL_GetError()
+ *          for more information.
+ *
+ * \since This function is available since SDL 2.0.12.
  */
 extern DECLSPEC SDL_Joystick *SDLCALL SDL_JoystickFromPlayerIndex(int player_index);
 
 /**
- * Attaches a new virtual joystick.
- * Returns the joystick's device index, or -1 if an error occurred.
+ * Attach a new virtual joystick.
+ *
+ * \returns the joystick's device index, or -1 if an error occurred.
+ *
+ * \since This function is available since SDL 2.0.14.
  */
 extern DECLSPEC int SDLCALL SDL_JoystickAttachVirtual(SDL_JoystickType type,
                                                       int naxes,
@@ -215,166 +331,396 @@ extern DECLSPEC int SDLCALL SDL_JoystickAttachVirtual(SDL_JoystickType type,
                                                       int nhats);
 
 /**
- * Detaches a virtual joystick
- * Returns 0 on success, or -1 if an error occurred.
+ * Detach a virtual joystick.
+ *
+ * \param device_index a value previously returned from
+ *                     SDL_JoystickAttachVirtual()
+ * \returns 0 on success, or -1 if an error occurred.
+ *
+ * \since This function is available since SDL 2.0.14.
  */
 extern DECLSPEC int SDLCALL SDL_JoystickDetachVirtual(int device_index);
 
 /**
- * Indicates whether or not a virtual-joystick is at a given device index.
+ * Query whether or not the joystick at a given device index is virtual.
+ *
+ * \param device_index a joystick device index.
+ * \returns SDL_TRUE if the joystick is virtual, SDL_FALSE otherwise.
+ *
+ * \since This function is available since SDL 2.0.14.
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_JoystickIsVirtual(int device_index);
 
 /**
- * Set values on an opened, virtual-joystick's controls.
- * Please note that values set here will not be applied until the next
- * call to SDL_JoystickUpdate, which can either be called directly,
- * or can be called indirectly through various other SDL APIS,
- * including, but not limited to the following: SDL_PollEvent,
- * SDL_PumpEvents, SDL_WaitEventTimeout, SDL_WaitEvent.
- * 
- * Returns 0 on success, -1 on error.
+ * Set values on an opened, virtual-joystick's axis.
+ *
+ * Please note that values set here will not be applied until the next call to
+ * SDL_JoystickUpdate, which can either be called directly, or can be called
+ * indirectly through various other SDL APIs, including, but not limited to
+ * the following: SDL_PollEvent, SDL_PumpEvents, SDL_WaitEventTimeout,
+ * SDL_WaitEvent.
+ *
+ * \param joystick the virtual joystick on which to set state.
+ * \param axis the specific axis on the virtual joystick to set.
+ * \param value the new value for the specified axis.
+ * \returns 0 on success, -1 on error.
+ *
+ * \since This function is available since SDL 2.0.14.
  */
 extern DECLSPEC int SDLCALL SDL_JoystickSetVirtualAxis(SDL_Joystick *joystick, int axis, Sint16 value);
+
+/**
+ * Set values on an opened, virtual-joystick's button.
+ *
+ * Please note that values set here will not be applied until the next call to
+ * SDL_JoystickUpdate, which can either be called directly, or can be called
+ * indirectly through various other SDL APIs, including, but not limited to
+ * the following: SDL_PollEvent, SDL_PumpEvents, SDL_WaitEventTimeout,
+ * SDL_WaitEvent.
+ *
+ * \param joystick the virtual joystick on which to set state.
+ * \param button the specific button on the virtual joystick to set.
+ * \param value the new value for the specified button.
+ * \returns 0 on success, -1 on error.
+ *
+ * \since This function is available since SDL 2.0.14.
+ */
 extern DECLSPEC int SDLCALL SDL_JoystickSetVirtualButton(SDL_Joystick *joystick, int button, Uint8 value);
+
+/**
+ * Set values on an opened, virtual-joystick's hat.
+ *
+ * Please note that values set here will not be applied until the next call to
+ * SDL_JoystickUpdate, which can either be called directly, or can be called
+ * indirectly through various other SDL APIs, including, but not limited to
+ * the following: SDL_PollEvent, SDL_PumpEvents, SDL_WaitEventTimeout,
+ * SDL_WaitEvent.
+ *
+ * \param joystick the virtual joystick on which to set state.
+ * \param hat the specific hat on the virtual joystick to set.
+ * \param value the new value for the specified hat.
+ * \returns 0 on success, -1 on error.
+ *
+ * \since This function is available since SDL 2.0.14.
+ */
 extern DECLSPEC int SDLCALL SDL_JoystickSetVirtualHat(SDL_Joystick *joystick, int hat, Uint8 value);
 
 /**
- *  Return the name for this currently opened joystick.
- *  If no name can be found, this function returns NULL.
+ * Get the implementation dependent name of a joystick.
+ *
+ * \param joystick the SDL_Joystick obtained from SDL_JoystickOpen()
+ * \returns the name of the selected joystick. If no name can be found, this
+ *          function returns NULL; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_JoystickNameForIndex
+ * \sa SDL_JoystickOpen
  */
 extern DECLSPEC const char *SDLCALL SDL_JoystickName(SDL_Joystick *joystick);
 
 /**
- *  Get the player index of an opened joystick, or -1 if it's not available
+ * Get the player index of an opened joystick.
  *
- *  For XInput controllers this returns the XInput user index.
+ * For XInput controllers this returns the XInput user index. Many joysticks
+ * will not be able to supply this information.
+ *
+ * \param joystick the SDL_Joystick obtained from SDL_JoystickOpen()
+ * \returns the player index, or -1 if it's not available.
+ *
+ * \since This function is available since SDL 2.0.9.
  */
 extern DECLSPEC int SDLCALL SDL_JoystickGetPlayerIndex(SDL_Joystick *joystick);
 
 /**
- *  Set the player index of an opened joystick
+ * Set the player index of an opened joystick.
+ *
+ * \param joystick the SDL_Joystick obtained from SDL_JoystickOpen()
+ * \param player_index the player index to set.
+ *
+ * \since This function is available since SDL 2.0.12.
  */
 extern DECLSPEC void SDLCALL SDL_JoystickSetPlayerIndex(SDL_Joystick *joystick, int player_index);
 
 /**
- *  Return the GUID for this opened joystick
+ * Get the implementation-dependent GUID for the joystick.
+ *
+ * This function requires an open joystick.
+ *
+ * \param joystick the SDL_Joystick obtained from SDL_JoystickOpen()
+ * \returns the GUID of the given joystick. If called on an invalid index,
+ *          this function returns a zero GUID; call SDL_GetError() for more
+ *          information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_JoystickGetDeviceGUID
+ * \sa SDL_JoystickGetGUIDString
  */
 extern DECLSPEC SDL_JoystickGUID SDLCALL SDL_JoystickGetGUID(SDL_Joystick *joystick);
 
 /**
- *  Get the USB vendor ID of an opened joystick, if available.
- *  If the vendor ID isn't available this function returns 0.
+ * Get the USB vendor ID of an opened joystick, if available.
+ *
+ * If the vendor ID isn't available this function returns 0.
+ *
+ * \param joystick the SDL_Joystick obtained from SDL_JoystickOpen()
+ * \returns the USB vendor ID of the selected joystick, or 0 if unavailable.
+ *
+ * \since This function is available since SDL 2.0.6.
  */
 extern DECLSPEC Uint16 SDLCALL SDL_JoystickGetVendor(SDL_Joystick *joystick);
 
 /**
- *  Get the USB product ID of an opened joystick, if available.
- *  If the product ID isn't available this function returns 0.
+ * Get the USB product ID of an opened joystick, if available.
+ *
+ * If the product ID isn't available this function returns 0.
+ *
+ * \param joystick the SDL_Joystick obtained from SDL_JoystickOpen()
+ * \returns the USB product ID of the selected joystick, or 0 if unavailable.
+ *
+ * \since This function is available since SDL 2.0.6.
  */
 extern DECLSPEC Uint16 SDLCALL SDL_JoystickGetProduct(SDL_Joystick *joystick);
 
 /**
- *  Get the product version of an opened joystick, if available.
- *  If the product version isn't available this function returns 0.
+ * Get the product version of an opened joystick, if available.
+ *
+ * If the product version isn't available this function returns 0.
+ *
+ * \param joystick the SDL_Joystick obtained from SDL_JoystickOpen()
+ * \returns the product version of the selected joystick, or 0 if unavailable.
+ *
+ * \since This function is available since SDL 2.0.6.
  */
 extern DECLSPEC Uint16 SDLCALL SDL_JoystickGetProductVersion(SDL_Joystick *joystick);
 
 /**
- *  Get the serial number of an opened joystick, if available.
- * 
- *  Returns the serial number of the joystick, or NULL if it is not available.
+ * Get the serial number of an opened joystick, if available.
+ *
+ * Returns the serial number of the joystick, or NULL if it is not available.
+ *
+ * \param joystick the SDL_Joystick obtained from SDL_JoystickOpen()
+ * \returns the serial number of the selected joystick, or NULL if
+ *          unavailable.
+ *
+ * \since This function is available since SDL 2.0.14.
  */
 extern DECLSPEC const char * SDLCALL SDL_JoystickGetSerial(SDL_Joystick *joystick);
 
 /**
- *  Get the type of an opened joystick.
+ * Get the type of an opened joystick.
+ *
+ * \param joystick the SDL_Joystick obtained from SDL_JoystickOpen()
+ * \returns the SDL_JoystickType of the selected joystick.
+ *
+ * \since This function is available since SDL 2.0.6.
  */
 extern DECLSPEC SDL_JoystickType SDLCALL SDL_JoystickGetType(SDL_Joystick *joystick);
 
 /**
- *  Return a string representation for this guid. pszGUID must point to at least 33 bytes
- *  (32 for the string plus a NULL terminator).
+ * Get an ASCII string representation for a given SDL_JoystickGUID.
+ *
+ * You should supply at least 33 bytes for pszGUID.
+ *
+ * \param guid the SDL_JoystickGUID you wish to convert to string
+ * \param pszGUID buffer in which to write the ASCII string
+ * \param cbGUID the size of pszGUID
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_JoystickGetDeviceGUID
+ * \sa SDL_JoystickGetGUID
+ * \sa SDL_JoystickGetGUIDFromString
  */
 extern DECLSPEC void SDLCALL SDL_JoystickGetGUIDString(SDL_JoystickGUID guid, char *pszGUID, int cbGUID);
 
 /**
- *  Convert a string into a joystick guid
+ * Convert a GUID string into a SDL_JoystickGUID structure.
+ *
+ * Performs no error checking. If this function is given a string containing
+ * an invalid GUID, the function will silently succeed, but the GUID generated
+ * will not be useful.
+ *
+ * \param pchGUID string containing an ASCII representation of a GUID
+ * \returns a SDL_JoystickGUID structure.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_JoystickGetGUIDString
  */
 extern DECLSPEC SDL_JoystickGUID SDLCALL SDL_JoystickGetGUIDFromString(const char *pchGUID);
 
 /**
- *  Returns SDL_TRUE if the joystick has been opened and currently connected, or SDL_FALSE if it has not.
+ * Get the status of a specified joystick.
+ *
+ * \param joystick the joystick to query
+ * \returns SDL_TRUE if the joystick has been opened, SDL_FALSE if it has not;
+ *          call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_JoystickClose
+ * \sa SDL_JoystickOpen
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_JoystickGetAttached(SDL_Joystick *joystick);
 
 /**
- *  Get the instance ID of an opened joystick or -1 if the joystick is invalid.
+ * Get the instance ID of an opened joystick.
+ *
+ * \param joystick an SDL_Joystick structure containing joystick information
+ * \returns the instance ID of the specified joystick on success or a negative
+ *          error code on failure; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_JoystickOpen
  */
 extern DECLSPEC SDL_JoystickID SDLCALL SDL_JoystickInstanceID(SDL_Joystick *joystick);
 
 /**
- *  Get the number of general axis controls on a joystick.
+ * Get the number of general axis controls on a joystick.
+ *
+ * Often, the directional pad on a game controller will either look like 4
+ * separate buttons or a POV hat, and not axes, but all of this is up to the
+ * device and platform.
+ *
+ * \param joystick an SDL_Joystick structure containing joystick information
+ * \returns the number of axis controls/number of axes on success or a
+ *          negative error code on failure; call SDL_GetError() for more
+ *          information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_JoystickGetAxis
+ * \sa SDL_JoystickOpen
  */
 extern DECLSPEC int SDLCALL SDL_JoystickNumAxes(SDL_Joystick *joystick);
 
 /**
- *  Get the number of trackballs on a joystick.
+ * Get the number of trackballs on a joystick.
  *
- *  Joystick trackballs have only relative motion events associated
- *  with them and their state cannot be polled.
+ * Joystick trackballs have only relative motion events associated with them
+ * and their state cannot be polled.
+ *
+ * Most joysticks do not have trackballs.
+ *
+ * \param joystick an SDL_Joystick structure containing joystick information
+ * \returns the number of trackballs on success or a negative error code on
+ *          failure; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_JoystickGetBall
  */
 extern DECLSPEC int SDLCALL SDL_JoystickNumBalls(SDL_Joystick *joystick);
 
 /**
- *  Get the number of POV hats on a joystick.
+ * Get the number of POV hats on a joystick.
+ *
+ * \param joystick an SDL_Joystick structure containing joystick information
+ * \returns the number of POV hats on success or a negative error code on
+ *          failure; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_JoystickGetHat
+ * \sa SDL_JoystickOpen
  */
 extern DECLSPEC int SDLCALL SDL_JoystickNumHats(SDL_Joystick *joystick);
 
 /**
- *  Get the number of buttons on a joystick.
+ * Get the number of buttons on a joystick.
+ *
+ * \param joystick an SDL_Joystick structure containing joystick information
+ * \returns the number of buttons on success or a negative error code on
+ *          failure; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_JoystickGetButton
+ * \sa SDL_JoystickOpen
  */
 extern DECLSPEC int SDLCALL SDL_JoystickNumButtons(SDL_Joystick *joystick);
 
 /**
- *  Update the current state of the open joysticks.
+ * Update the current state of the open joysticks.
  *
- *  This is called automatically by the event loop if any joystick
- *  events are enabled.
+ * This is called automatically by the event loop if any joystick events are
+ * enabled.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_JoystickEventState
  */
 extern DECLSPEC void SDLCALL SDL_JoystickUpdate(void);
 
 /**
- *  Enable/disable joystick event polling.
+ * Enable/disable joystick event polling.
  *
- *  If joystick events are disabled, you must call SDL_JoystickUpdate()
- *  yourself and check the state of the joystick when you want joystick
- *  information.
+ * If joystick events are disabled, you must call SDL_JoystickUpdate()
+ * yourself and manually check the state of the joystick when you want
+ * joystick information.
  *
- *  The state can be one of ::SDL_QUERY, ::SDL_ENABLE or ::SDL_IGNORE.
+ * It is recommended that you leave joystick event handling enabled.
+ *
+ * **WARNING**: Calling this function may delete all events currently in SDL's
+ * event queue.
+ *
+ * \param state can be one of `SDL_QUERY`, `SDL_IGNORE`, or `SDL_ENABLE`
+ * \returns 1 if enabled, 0 if disabled, or a negative error code on failure;
+ *          call SDL_GetError() for more information.
+ *
+ *          If `state` is `SDL_QUERY` then the current state is returned,
+ *          otherwise the new processing state is returned.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GameControllerEventState
  */
 extern DECLSPEC int SDLCALL SDL_JoystickEventState(int state);
 
 #define SDL_JOYSTICK_AXIS_MAX   32767
 #define SDL_JOYSTICK_AXIS_MIN   -32768
+
 /**
- *  Get the current state of an axis control on a joystick.
+ * Get the current state of an axis control on a joystick.
  *
- *  The state is a value ranging from -32768 to 32767.
+ * SDL makes no promises about what part of the joystick any given axis refers
+ * to. Your game should have some sort of configuration UI to let users
+ * specify what each axis should be bound to. Alternately, SDL's higher-level
+ * Game Controller API makes a great effort to apply order to this lower-level
+ * interface, so you know that a specific axis is the "left thumb stick," etc.
  *
- *  The axis indices start at index 0.
+ * The value returned by SDL_JoystickGetAxis() is a signed integer (-32768 to
+ * 32767) representing the current position of the axis. It may be necessary
+ * to impose certain tolerances on these values to account for jitter.
+ *
+ * \param joystick an SDL_Joystick structure containing joystick information
+ * \param axis the axis to query; the axis indices start at index 0
+ * \returns a 16-bit signed integer representing the current position of the
+ *          axis or 0 on failure; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_JoystickNumAxes
  */
 extern DECLSPEC Sint16 SDLCALL SDL_JoystickGetAxis(SDL_Joystick *joystick,
                                                    int axis);
 
 /**
- *  Get the initial state of an axis control on a joystick.
+ * Get the initial state of an axis control on a joystick.
  *
- *  The state is a value ranging from -32768 to 32767.
+ * The state is a value ranging from -32768 to 32767.
  *
- *  The axis indices start at index 0.
+ * The axis indices start at index 0.
  *
- *  \return SDL_TRUE if this axis has any initial value, or SDL_FALSE if not.
+ * \param joystick an SDL_Joystick structure containing joystick information
+ * \param axis the axis to query; the axis indices start at index 0
+ * \param state Upon return, the initial value is supplied here.
+ * \return SDL_TRUE if this axis has any initial value, or SDL_FALSE if not.
+ *
+ * \since This function is available since SDL 2.0.6.
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_JoystickGetAxisInitialState(SDL_Joystick *joystick,
                                                    int axis, Sint16 *state);
@@ -395,96 +741,197 @@ extern DECLSPEC SDL_bool SDLCALL SDL_JoystickGetAxisInitialState(SDL_Joystick *j
 /* @} */
 
 /**
- *  Get the current state of a POV hat on a joystick.
+ * Get the current state of a POV hat on a joystick.
  *
- *  The hat indices start at index 0.
+ * The returned value will be one of the following positions:
  *
- *  \return The return value is one of the following positions:
- *           - ::SDL_HAT_CENTERED
- *           - ::SDL_HAT_UP
- *           - ::SDL_HAT_RIGHT
- *           - ::SDL_HAT_DOWN
- *           - ::SDL_HAT_LEFT
- *           - ::SDL_HAT_RIGHTUP
- *           - ::SDL_HAT_RIGHTDOWN
- *           - ::SDL_HAT_LEFTUP
- *           - ::SDL_HAT_LEFTDOWN
+ * - `SDL_HAT_CENTERED`
+ * - `SDL_HAT_UP`
+ * - `SDL_HAT_RIGHT`
+ * - `SDL_HAT_DOWN`
+ * - `SDL_HAT_LEFT`
+ * - `SDL_HAT_RIGHTUP`
+ * - `SDL_HAT_RIGHTDOWN`
+ * - `SDL_HAT_LEFTUP`
+ * - `SDL_HAT_LEFTDOWN`
+ *
+ * \param joystick an SDL_Joystick structure containing joystick information
+ * \param hat the hat index to get the state from; indices start at index 0
+ * \returns the current hat position.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_JoystickNumHats
  */
 extern DECLSPEC Uint8 SDLCALL SDL_JoystickGetHat(SDL_Joystick *joystick,
                                                  int hat);
 
 /**
- *  Get the ball axis change since the last poll.
+ * Get the ball axis change since the last poll.
  *
- *  \return 0, or -1 if you passed it invalid parameters.
+ * Trackballs can only return relative motion since the last call to
+ * SDL_JoystickGetBall(), these motion deltas are placed into `dx` and `dy`.
  *
- *  The ball indices start at index 0.
+ * Most joysticks do not have trackballs.
+ *
+ * \param joystick the SDL_Joystick to query
+ * \param ball the ball index to query; ball indices start at index 0
+ * \param dx stores the difference in the x axis position since the last poll
+ * \param dy stores the difference in the y axis position since the last poll
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_JoystickNumBalls
  */
 extern DECLSPEC int SDLCALL SDL_JoystickGetBall(SDL_Joystick *joystick,
                                                 int ball, int *dx, int *dy);
 
 /**
- *  Get the current state of a button on a joystick.
+ * Get the current state of a button on a joystick.
  *
- *  The button indices start at index 0.
+ * \param joystick an SDL_Joystick structure containing joystick information
+ * \param button the button index to get the state from; indices start at
+ *               index 0
+ * \returns 1 if the specified button is pressed, 0 otherwise.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_JoystickNumButtons
  */
 extern DECLSPEC Uint8 SDLCALL SDL_JoystickGetButton(SDL_Joystick *joystick,
                                                     int button);
 
 /**
- *  Start a rumble effect
- *  Each call to this function cancels any previous rumble effect, and calling it with 0 intensity stops any rumbling.
+ * Start a rumble effect.
  *
- *  \param joystick The joystick to vibrate
- *  \param low_frequency_rumble The intensity of the low frequency (left) rumble motor, from 0 to 0xFFFF
- *  \param high_frequency_rumble The intensity of the high frequency (right) rumble motor, from 0 to 0xFFFF
- *  \param duration_ms The duration of the rumble effect, in milliseconds
+ * Each call to this function cancels any previous rumble effect, and calling
+ * it with 0 intensity stops any rumbling.
  *
- *  \return 0, or -1 if rumble isn't supported on this joystick
+ * \param joystick The joystick to vibrate
+ * \param low_frequency_rumble The intensity of the low frequency (left)
+ *                             rumble motor, from 0 to 0xFFFF
+ * \param high_frequency_rumble The intensity of the high frequency (right)
+ *                              rumble motor, from 0 to 0xFFFF
+ * \param duration_ms The duration of the rumble effect, in milliseconds
+ * \returns 0, or -1 if rumble isn't supported on this joystick
+ *
+ * \since This function is available since SDL 2.0.9.
+ *
+ * \sa SDL_JoystickHasRumble
  */
 extern DECLSPEC int SDLCALL SDL_JoystickRumble(SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble, Uint32 duration_ms);
 
 /**
- *  Start a rumble effect in the joystick's triggers
- *  Each call to this function cancels any previous trigger rumble effect, and calling it with 0 intensity stops any rumbling.
+ * Start a rumble effect in the joystick's triggers
  *
- *  \param joystick The joystick to vibrate
- *  \param left_rumble The intensity of the left trigger rumble motor, from 0 to 0xFFFF
- *  \param right_rumble The intensity of the right trigger rumble motor, from 0 to 0xFFFF
- *  \param duration_ms The duration of the rumble effect, in milliseconds
+ * Each call to this function cancels any previous trigger rumble effect, and
+ * calling it with 0 intensity stops any rumbling.
  *
- *  \return 0, or -1 if trigger rumble isn't supported on this joystick
+ * Note that this is rumbling of the _triggers_ and not the game controller as
+ * a whole. This is currently only supported on Xbox One controllers. If you
+ * want the (more common) whole-controller rumble, use SDL_JoystickRumble()
+ * instead.
+ *
+ * \param joystick The joystick to vibrate
+ * \param left_rumble The intensity of the left trigger rumble motor, from 0
+ *                    to 0xFFFF
+ * \param right_rumble The intensity of the right trigger rumble motor, from 0
+ *                     to 0xFFFF
+ * \param duration_ms The duration of the rumble effect, in milliseconds
+ * \returns 0, or -1 if trigger rumble isn't supported on this joystick
+ *
+ * \since This function is available since SDL 2.0.14.
+ *
+ * \sa SDL_JoystickHasRumbleTriggers
  */
 extern DECLSPEC int SDLCALL SDL_JoystickRumbleTriggers(SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble, Uint32 duration_ms);
 
 /**
- *  Return whether a joystick has an LED
+ * Query whether a joystick has an LED.
  *
- *  \param joystick The joystick to query
+ * An example of a joystick LED is the light on the back of a PlayStation 4's
+ * DualShock 4 controller.
  *
- *  \return SDL_TRUE, or SDL_FALSE if this joystick does not have a modifiable LED
+ * \param joystick The joystick to query
+ * \return SDL_TRUE if the joystick has a modifiable LED, SDL_FALSE otherwise.
+ *
+ * \since This function is available since SDL 2.0.14.
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_JoystickHasLED(SDL_Joystick *joystick);
 
 /**
- *  Update a joystick's LED color.
+ * Query whether a joystick has rumble support.
  *
- *  \param joystick The joystick to update
- *  \param red The intensity of the red LED
- *  \param green The intensity of the green LED
- *  \param blue The intensity of the blue LED
+ * \param joystick The joystick to query
+ * \return SDL_TRUE if the joystick has rumble, SDL_FALSE otherwise.
  *
- *  \return 0, or -1 if this joystick does not have a modifiable LED
+ * \since This function is available since SDL 2.0.18.
+ *
+ * \sa SDL_JoystickRumble
+ */
+extern DECLSPEC SDL_bool SDLCALL SDL_JoystickHasRumble(SDL_Joystick *joystick);
+
+/**
+ * Query whether a joystick has rumble support on triggers.
+ *
+ * \param joystick The joystick to query
+ * \return SDL_TRUE if the joystick has trigger rumble, SDL_FALSE otherwise.
+ *
+ * \since This function is available since SDL 2.0.18.
+ *
+ * \sa SDL_JoystickRumbleTriggers
+ */
+extern DECLSPEC SDL_bool SDLCALL SDL_JoystickHasRumbleTriggers(SDL_Joystick *joystick);
+
+/**
+ * Update a joystick's LED color.
+ *
+ * An example of a joystick LED is the light on the back of a PlayStation 4's
+ * DualShock 4 controller.
+ *
+ * \param joystick The joystick to update
+ * \param red The intensity of the red LED
+ * \param green The intensity of the green LED
+ * \param blue The intensity of the blue LED
+ * \returns 0 on success, -1 if this joystick does not have a modifiable LED
+ *
+ * \since This function is available since SDL 2.0.14.
  */
 extern DECLSPEC int SDLCALL SDL_JoystickSetLED(SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue);
 
 /**
- *  Close a joystick previously opened with SDL_JoystickOpen().
+ * Send a joystick specific effect packet
+ *
+ * \param joystick The joystick to affect
+ * \param data The data to send to the joystick
+ * \param size The size of the data to send to the joystick
+ * \returns 0, or -1 if this joystick or driver doesn't support effect packets
+ *
+ * \since This function is available since SDL 2.0.16.
+ */
+extern DECLSPEC int SDLCALL SDL_JoystickSendEffect(SDL_Joystick *joystick, const void *data, int size);
+
+/**
+ * Close a joystick previously opened with SDL_JoystickOpen().
+ *
+ * \param joystick The joystick device to close
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_JoystickOpen
  */
 extern DECLSPEC void SDLCALL SDL_JoystickClose(SDL_Joystick *joystick);
 
 /**
- *  Return the battery level of this joystick
+ * Get the battery level of a joystick as SDL_JoystickPowerLevel.
+ *
+ * \param joystick the SDL_Joystick to query
+ * \returns the current battery level as SDL_JoystickPowerLevel on success or
+ *          `SDL_JOYSTICK_POWER_UNKNOWN` if it is unknown
+ *
+ * \since This function is available since SDL 2.0.4.
  */
 extern DECLSPEC SDL_JoystickPowerLevel SDLCALL SDL_JoystickCurrentPowerLevel(SDL_Joystick *joystick);
 
diff --git a/Engine/lib/sdl/include/SDL_keyboard.h b/Engine/lib/sdl/include/SDL_keyboard.h
index f6853c647..0aa599076 100644
--- a/Engine/lib/sdl/include/SDL_keyboard.h
+++ b/Engine/lib/sdl/include/SDL_keyboard.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -55,154 +55,274 @@ typedef struct SDL_Keysym
 /* Function prototypes */
 
 /**
- *  \brief Get the window which currently has keyboard focus.
+ * Query the window which currently has keyboard focus.
+ *
+ * \returns the window with keyboard focus.
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC SDL_Window * SDLCALL SDL_GetKeyboardFocus(void);
 
 /**
- *  \brief Get a snapshot of the current state of the keyboard.
+ * Get a snapshot of the current state of the keyboard.
  *
- *  \param numkeys if non-NULL, receives the length of the returned array.
+ * The pointer returned is a pointer to an internal SDL array. It will be
+ * valid for the whole lifetime of the application and should not be freed by
+ * the caller.
  *
- *  \return An array of key states. Indexes into this array are obtained by using ::SDL_Scancode values.
+ * A array element with a value of 1 means that the key is pressed and a value
+ * of 0 means that it is not. Indexes into this array are obtained by using
+ * SDL_Scancode values.
  *
- *  \b Example:
- *  \code
- *  const Uint8 *state = SDL_GetKeyboardState(NULL);
- *  if ( state[SDL_SCANCODE_RETURN] )   {
- *      printf("<RETURN> is pressed.\n");
- *  }
- *  \endcode
+ * Use SDL_PumpEvents() to update the state array.
+ *
+ * This function gives you the current state after all events have been
+ * processed, so if a key or button has been pressed and released before you
+ * process events, then the pressed state will never show up in the
+ * SDL_GetKeyboardState() calls.
+ *
+ * Note: This function doesn't take into account whether shift has been
+ * pressed or not.
+ *
+ * \param numkeys if non-NULL, receives the length of the returned array
+ * \returns a pointer to an array of key states.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_PumpEvents
  */
 extern DECLSPEC const Uint8 *SDLCALL SDL_GetKeyboardState(int *numkeys);
 
 /**
- *  \brief Get the current key modifier state for the keyboard.
+ * Get the current key modifier state for the keyboard.
+ *
+ * \returns an OR'd combination of the modifier keys for the keyboard. See
+ *          SDL_Keymod for details.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetKeyboardState
+ * \sa SDL_SetModState
  */
 extern DECLSPEC SDL_Keymod SDLCALL SDL_GetModState(void);
 
 /**
- *  \brief Set the current key modifier state for the keyboard.
+ * Set the current key modifier state for the keyboard.
  *
- *  \note This does not change the keyboard state, only the key modifier flags.
+ * The inverse of SDL_GetModState(), SDL_SetModState() allows you to impose
+ * modifier key states on your application. Simply pass your desired modifier
+ * states into `modstate`. This value may be a bitwise, OR'd combination of
+ * SDL_Keymod values.
+ *
+ * This does not change the keyboard state, only the key modifier flags that
+ * SDL reports.
+ *
+ * \param modstate the desired SDL_Keymod for the keyboard
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetModState
  */
 extern DECLSPEC void SDLCALL SDL_SetModState(SDL_Keymod modstate);
 
 /**
- *  \brief Get the key code corresponding to the given scancode according
- *         to the current keyboard layout.
+ * Get the key code corresponding to the given scancode according to the
+ * current keyboard layout.
  *
- *  See ::SDL_Keycode for details.
+ * See SDL_Keycode for details.
  *
- *  \sa SDL_GetKeyName()
+ * \param scancode the desired SDL_Scancode to query
+ * \returns the SDL_Keycode that corresponds to the given SDL_Scancode.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetKeyName
+ * \sa SDL_GetScancodeFromKey
  */
 extern DECLSPEC SDL_Keycode SDLCALL SDL_GetKeyFromScancode(SDL_Scancode scancode);
 
 /**
- *  \brief Get the scancode corresponding to the given key code according to the
- *         current keyboard layout.
+ * Get the scancode corresponding to the given key code according to the
+ * current keyboard layout.
  *
- *  See ::SDL_Scancode for details.
+ * See SDL_Scancode for details.
  *
- *  \sa SDL_GetScancodeName()
+ * \param key the desired SDL_Keycode to query
+ * \returns the SDL_Scancode that corresponds to the given SDL_Keycode.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetKeyFromScancode
+ * \sa SDL_GetScancodeName
  */
 extern DECLSPEC SDL_Scancode SDLCALL SDL_GetScancodeFromKey(SDL_Keycode key);
 
 /**
- *  \brief Get a human-readable name for a scancode.
+ * Get a human-readable name for a scancode.
  *
- *  \return A pointer to the name for the scancode.
- *          If the scancode doesn't have a name, this function returns
- *          an empty string ("").
+ * See SDL_Scancode for details.
  *
- *  \sa SDL_Scancode
+ * **Warning**: The returned name is by design not stable across platforms,
+ * e.g. the name for `SDL_SCANCODE_LGUI` is "Left GUI" under Linux but "Left
+ * Windows" under Microsoft Windows, and some scancodes like
+ * `SDL_SCANCODE_NONUSBACKSLASH` don't have any name at all. There are even
+ * scancodes that share names, e.g. `SDL_SCANCODE_RETURN` and
+ * `SDL_SCANCODE_RETURN2` (both called "Return"). This function is therefore
+ * unsuitable for creating a stable cross-platform two-way mapping between
+ * strings and scancodes.
+ *
+ * \param scancode the desired SDL_Scancode to query
+ * \returns a pointer to the name for the scancode. If the scancode doesn't
+ *          have a name this function returns an empty string ("").
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetScancodeFromKey
+ * \sa SDL_GetScancodeFromName
  */
 extern DECLSPEC const char *SDLCALL SDL_GetScancodeName(SDL_Scancode scancode);
 
 /**
- *  \brief Get a scancode from a human-readable name
+ * Get a scancode from a human-readable name.
  *
- *  \return scancode, or SDL_SCANCODE_UNKNOWN if the name wasn't recognized
+ * \param name the human-readable scancode name
+ * \returns the SDL_Scancode, or `SDL_SCANCODE_UNKNOWN` if the name wasn't
+ *          recognized; call SDL_GetError() for more information.
  *
- *  \sa SDL_Scancode
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetKeyFromName
+ * \sa SDL_GetScancodeFromKey
+ * \sa SDL_GetScancodeName
  */
 extern DECLSPEC SDL_Scancode SDLCALL SDL_GetScancodeFromName(const char *name);
 
 /**
- *  \brief Get a human-readable name for a key.
+ * Get a human-readable name for a key.
  *
- *  \return A pointer to a UTF-8 string that stays valid at least until the next
- *          call to this function. If you need it around any longer, you must
- *          copy it.  If the key doesn't have a name, this function returns an
- *          empty string ("").
+ * See SDL_Scancode and SDL_Keycode for details.
  *
- *  \sa SDL_Keycode
+ * \param key the desired SDL_Keycode to query
+ * \returns a pointer to a UTF-8 string that stays valid at least until the
+ *          next call to this function. If you need it around any longer, you
+ *          must copy it. If the key doesn't have a name, this function
+ *          returns an empty string ("").
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetKeyFromName
+ * \sa SDL_GetKeyFromScancode
+ * \sa SDL_GetScancodeFromKey
  */
 extern DECLSPEC const char *SDLCALL SDL_GetKeyName(SDL_Keycode key);
 
 /**
- *  \brief Get a key code from a human-readable name
+ * Get a key code from a human-readable name.
  *
- *  \return key code, or SDLK_UNKNOWN if the name wasn't recognized
+ * \param name the human-readable key name
+ * \returns key code, or `SDLK_UNKNOWN` if the name wasn't recognized; call
+ *          SDL_GetError() for more information.
  *
- *  \sa SDL_Keycode
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetKeyFromScancode
+ * \sa SDL_GetKeyName
+ * \sa SDL_GetScancodeFromName
  */
 extern DECLSPEC SDL_Keycode SDLCALL SDL_GetKeyFromName(const char *name);
 
 /**
- *  \brief Start accepting Unicode text input events.
- *         This function will show the on-screen keyboard if supported.
+ * Start accepting Unicode text input events.
  *
- *  \sa SDL_StopTextInput()
- *  \sa SDL_SetTextInputRect()
- *  \sa SDL_HasScreenKeyboardSupport()
+ * This function will start accepting Unicode text input events in the focused
+ * SDL window, and start emitting SDL_TextInputEvent (SDL_TEXTINPUT) and
+ * SDL_TextEditingEvent (SDL_TEXTEDITING) events. Please use this function in
+ * pair with SDL_StopTextInput().
+ *
+ * On some platforms using this function activates the screen keyboard.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_SetTextInputRect
+ * \sa SDL_StopTextInput
  */
 extern DECLSPEC void SDLCALL SDL_StartTextInput(void);
 
 /**
- *  \brief Return whether or not Unicode text input events are enabled.
+ * Check whether or not Unicode text input events are enabled.
  *
- *  \sa SDL_StartTextInput()
- *  \sa SDL_StopTextInput()
+ * \returns SDL_TRUE if text input events are enabled else SDL_FALSE.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_StartTextInput
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_IsTextInputActive(void);
 
 /**
- *  \brief Stop receiving any text input events.
- *         This function will hide the on-screen keyboard if supported.
+ * Stop receiving any text input events.
  *
- *  \sa SDL_StartTextInput()
- *  \sa SDL_HasScreenKeyboardSupport()
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_StartTextInput
  */
 extern DECLSPEC void SDLCALL SDL_StopTextInput(void);
 
 /**
- *  \brief Set the rectangle used to type Unicode text inputs.
- *         This is used as a hint for IME and on-screen keyboard placement.
+ * Dismiss the composition window/IME without disabling the subsystem.
  *
- *  \sa SDL_StartTextInput()
+ * \since This function is available since SDL 2.0.22.
+ *
+ * \sa SDL_StartTextInput
+ * \sa SDL_StopTextInput
+ */
+extern DECLSPEC void SDLCALL SDL_ClearComposition(void);
+
+/**
+ * Returns if an IME Composite or Candidate window is currently shown.
+ *
+ * \since This function is available since SDL 2.0.22.
+ */
+extern DECLSPEC SDL_bool SDLCALL SDL_IsTextInputShown(void);
+
+/**
+ * Set the rectangle used to type Unicode text inputs.
+ *
+ * Note: If you want use system native IME window, try to set hint
+ * **SDL_HINT_IME_SHOW_UI** to **1**, otherwise this function won't give you
+ * any feedback.
+ *
+ * \param rect the SDL_Rect structure representing the rectangle to receive
+ *             text (ignored if NULL)
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_StartTextInput
  */
 extern DECLSPEC void SDLCALL SDL_SetTextInputRect(SDL_Rect *rect);
 
 /**
- *  \brief Returns whether the platform has some screen keyboard support.
+ * Check whether the platform has screen keyboard support.
  *
- *  \return SDL_TRUE if some keyboard support is available else SDL_FALSE.
+ * \returns SDL_TRUE if the platform has some screen keyboard support or
+ *          SDL_FALSE if not.
  *
- *  \note Not all screen keyboard functions are supported on all platforms.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_IsScreenKeyboardShown()
+ * \sa SDL_StartTextInput
+ * \sa SDL_IsScreenKeyboardShown
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_HasScreenKeyboardSupport(void);
 
 /**
- *  \brief Returns whether the screen keyboard is shown for given window.
+ * Check whether the screen keyboard is shown for given window.
  *
- *  \param window The window for which screen keyboard should be queried.
+ * \param window the window for which screen keyboard should be queried
+ * \returns SDL_TRUE if screen keyboard is shown or SDL_FALSE if not.
  *
- *  \return SDL_TRUE if screen keyboard is shown else SDL_FALSE.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_HasScreenKeyboardSupport()
+ * \sa SDL_HasScreenKeyboardSupport
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_IsScreenKeyboardShown(SDL_Window *window);
 
diff --git a/Engine/lib/sdl/include/SDL_keycode.h b/Engine/lib/sdl/include/SDL_keycode.h
index 6f6b65cb9..35602541a 100644
--- a/Engine/lib/sdl/include/SDL_keycode.h
+++ b/Engine/lib/sdl/include/SDL_keycode.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -52,7 +52,7 @@ typedef enum
     SDLK_UNKNOWN = 0,
 
     SDLK_RETURN = '\r',
-    SDLK_ESCAPE = '\033',
+    SDLK_ESCAPE = '\x1B',
     SDLK_BACKSPACE = '\b',
     SDLK_TAB = '\t',
     SDLK_SPACE = ' ',
@@ -147,7 +147,7 @@ typedef enum
     SDLK_INSERT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_INSERT),
     SDLK_HOME = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_HOME),
     SDLK_PAGEUP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_PAGEUP),
-    SDLK_DELETE = '\177',
+    SDLK_DELETE = '\x7F',
     SDLK_END = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_END),
     SDLK_PAGEDOWN = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_PAGEDOWN),
     SDLK_RIGHT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_RIGHT),
@@ -338,12 +338,14 @@ typedef enum
     KMOD_NUM = 0x1000,
     KMOD_CAPS = 0x2000,
     KMOD_MODE = 0x4000,
-    KMOD_RESERVED = 0x8000,
+    KMOD_SCROLL = 0x8000,
 
     KMOD_CTRL = KMOD_LCTRL | KMOD_RCTRL,
     KMOD_SHIFT = KMOD_LSHIFT | KMOD_RSHIFT,
     KMOD_ALT = KMOD_LALT | KMOD_RALT,
-    KMOD_GUI = KMOD_LGUI | KMOD_RGUI
+    KMOD_GUI = KMOD_LGUI | KMOD_RGUI,
+
+    KMOD_RESERVED = KMOD_SCROLL /* This is for source-level compatibility with SDL 2.0.0. */
 } SDL_Keymod;
 
 #endif /* SDL_keycode_h_ */
diff --git a/Engine/lib/sdl/include/SDL_loadso.h b/Engine/lib/sdl/include/SDL_loadso.h
index 89578a9f6..61857c813 100644
--- a/Engine/lib/sdl/include/SDL_loadso.h
+++ b/Engine/lib/sdl/include/SDL_loadso.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -51,22 +51,56 @@ extern "C" {
 #endif
 
 /**
- *  This function dynamically loads a shared object and returns a pointer
- *  to the object handle (or NULL if there was an error).
- *  The 'sofile' parameter is a system dependent name of the object file.
+ * Dynamically load a shared object.
+ *
+ * \param sofile a system-dependent name of the object file
+ * \returns an opaque pointer to the object handle or NULL if there was an
+ *          error; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_LoadFunction
+ * \sa SDL_UnloadObject
  */
 extern DECLSPEC void *SDLCALL SDL_LoadObject(const char *sofile);
 
 /**
- *  Given an object handle, this function looks up the address of the
- *  named function in the shared object and returns it.  This address
- *  is no longer valid after calling SDL_UnloadObject().
+ * Look up the address of the named function in a shared object.
+ *
+ * This function pointer is no longer valid after calling SDL_UnloadObject().
+ *
+ * This function can only look up C function names. Other languages may have
+ * name mangling and intrinsic language support that varies from compiler to
+ * compiler.
+ *
+ * Make sure you declare your function pointers with the same calling
+ * convention as the actual library function. Your code will crash
+ * mysteriously if you do not do this.
+ *
+ * If the requested function doesn't exist, NULL is returned.
+ *
+ * \param handle a valid shared object handle returned by SDL_LoadObject()
+ * \param name the name of the function to look up
+ * \returns a pointer to the function or NULL if there was an error; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_LoadObject
+ * \sa SDL_UnloadObject
  */
 extern DECLSPEC void *SDLCALL SDL_LoadFunction(void *handle,
                                                const char *name);
 
 /**
- *  Unload a shared object from memory.
+ * Unload a shared object from memory.
+ *
+ * \param handle a valid shared object handle returned by SDL_LoadObject()
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_LoadFunction
+ * \sa SDL_LoadObject
  */
 extern DECLSPEC void SDLCALL SDL_UnloadObject(void *handle);
 
diff --git a/Engine/lib/sdl/include/SDL_locale.h b/Engine/lib/sdl/include/SDL_locale.h
index 1f4b0c469..751577994 100644
--- a/Engine/lib/sdl/include/SDL_locale.h
+++ b/Engine/lib/sdl/include/SDL_locale.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -47,44 +47,46 @@ typedef struct SDL_Locale
 } SDL_Locale;
 
 /**
- *  \brief Report the user's preferred locale.
+ * Report the user's preferred locale.
  *
- *  This returns an array of SDL_Locale structs, the final item zeroed out.
- *  When the caller is done with this array, it should call SDL_free() on
- *  the returned value; all the memory involved is allocated in a single
- *  block, so a single SDL_free() will suffice.
+ * This returns an array of SDL_Locale structs, the final item zeroed out.
+ * When the caller is done with this array, it should call SDL_free() on the
+ * returned value; all the memory involved is allocated in a single block, so
+ * a single SDL_free() will suffice.
  *
- *  Returned language strings are in the format xx, where 'xx' is an ISO-639
- *  language specifier (such as "en" for English, "de" for German, etc).
- *  Country strings are in the format YY, where "YY" is an ISO-3166 country
- *  code (such as "US" for the United States, "CA" for Canada, etc). Country
- *  might be NULL if there's no specific guidance on them (so you might get
- *  { "en", "US" } for American English, but { "en", NULL } means "English
- *  language, generically"). Language strings are never NULL, except to
- *  terminate the array.
+ * Returned language strings are in the format xx, where 'xx' is an ISO-639
+ * language specifier (such as "en" for English, "de" for German, etc).
+ * Country strings are in the format YY, where "YY" is an ISO-3166 country
+ * code (such as "US" for the United States, "CA" for Canada, etc). Country
+ * might be NULL if there's no specific guidance on them (so you might get {
+ * "en", "US" } for American English, but { "en", NULL } means "English
+ * language, generically"). Language strings are never NULL, except to
+ * terminate the array.
  *
- *  Please note that not all of these strings are 2 characters; some are
- *  three or more.
+ * Please note that not all of these strings are 2 characters; some are three
+ * or more.
  *
- *  The returned list of locales are in the order of the user's preference.
- *  For example, a German citizen that is fluent in US English and knows
- *  enough Japanese to navigate around Tokyo might have a list like:
- *  { "de", "en_US", "jp", NULL }. Someone from England might prefer British
- *  English (where "color" is spelled "colour", etc), but will settle for
- *  anything like it: { "en_GB", "en", NULL }.
+ * The returned list of locales are in the order of the user's preference. For
+ * example, a German citizen that is fluent in US English and knows enough
+ * Japanese to navigate around Tokyo might have a list like: { "de", "en_US",
+ * "jp", NULL }. Someone from England might prefer British English (where
+ * "color" is spelled "colour", etc), but will settle for anything like it: {
+ * "en_GB", "en", NULL }.
  *
- *  This function returns NULL on error, including when the platform does not
- *  supply this information at all.
+ * This function returns NULL on error, including when the platform does not
+ * supply this information at all.
  *
- *  This might be a "slow" call that has to query the operating system. It's
- *  best to ask for this once and save the results. However, this list can
- *  change, usually because the user has changed a system preference outside
- *  of your program; SDL will send an SDL_LOCALECHANGED event in this case,
- *  if possible, and you can call this function again to get an updated copy
- *  of preferred locales.
+ * This might be a "slow" call that has to query the operating system. It's
+ * best to ask for this once and save the results. However, this list can
+ * change, usually because the user has changed a system preference outside of
+ * your program; SDL will send an SDL_LOCALECHANGED event in this case, if
+ * possible, and you can call this function again to get an updated copy of
+ * preferred locales.
  *
- *   \return array of locales, terminated with a locale with a NULL language
- *           field. Will return NULL on error.
+ * \return array of locales, terminated with a locale with a NULL language
+ *         field. Will return NULL on error.
+ *
+ * \since This function is available since SDL 2.0.14.
  */
 extern DECLSPEC SDL_Locale * SDLCALL SDL_GetPreferredLocales(void);
 
diff --git a/Engine/lib/sdl/include/SDL_log.h b/Engine/lib/sdl/include/SDL_log.h
index c1751fd77..dbbcb1e6f 100644
--- a/Engine/lib/sdl/include/SDL_log.h
+++ b/Engine/lib/sdl/include/SDL_log.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -112,90 +112,283 @@ typedef enum
 
 
 /**
- *  \brief Set the priority of all log categories
+ * Set the priority of all log categories.
+ *
+ * \param priority the SDL_LogPriority to assign
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_LogSetPriority
  */
 extern DECLSPEC void SDLCALL SDL_LogSetAllPriority(SDL_LogPriority priority);
 
 /**
- *  \brief Set the priority of a particular log category
+ * Set the priority of a particular log category.
+ *
+ * \param category the category to assign a priority to
+ * \param priority the SDL_LogPriority to assign
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_LogGetPriority
+ * \sa SDL_LogSetAllPriority
  */
 extern DECLSPEC void SDLCALL SDL_LogSetPriority(int category,
                                                 SDL_LogPriority priority);
 
 /**
- *  \brief Get the priority of a particular log category
+ * Get the priority of a particular log category.
+ *
+ * \param category the category to query
+ * \returns the SDL_LogPriority for the requested category
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_LogSetPriority
  */
 extern DECLSPEC SDL_LogPriority SDLCALL SDL_LogGetPriority(int category);
 
 /**
- *  \brief Reset all priorities to default.
+ * Reset all priorities to default.
  *
- *  \note This is called in SDL_Quit().
+ * This is called by SDL_Quit().
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_LogSetAllPriority
+ * \sa SDL_LogSetPriority
  */
 extern DECLSPEC void SDLCALL SDL_LogResetPriorities(void);
 
 /**
- *  \brief Log a message with SDL_LOG_CATEGORY_APPLICATION and SDL_LOG_PRIORITY_INFO
+ * Log a message with SDL_LOG_CATEGORY_APPLICATION and SDL_LOG_PRIORITY_INFO.
+ *
+ * = * \param fmt a printf() style message format string
+ *
+ * \param ... additional parameters matching % tokens in the `fmt` string, if
+ *            any
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_LogCritical
+ * \sa SDL_LogDebug
+ * \sa SDL_LogError
+ * \sa SDL_LogInfo
+ * \sa SDL_LogMessage
+ * \sa SDL_LogMessageV
+ * \sa SDL_LogVerbose
+ * \sa SDL_LogWarn
  */
 extern DECLSPEC void SDLCALL SDL_Log(SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(1);
 
 /**
- *  \brief Log a message with SDL_LOG_PRIORITY_VERBOSE
+ * Log a message with SDL_LOG_PRIORITY_VERBOSE.
+ *
+ * \param category the category of the message
+ * \param fmt a printf() style message format string
+ * \param ... additional parameters matching % tokens in the **fmt** string,
+ *            if any
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_Log
+ * \sa SDL_LogCritical
+ * \sa SDL_LogDebug
+ * \sa SDL_LogError
+ * \sa SDL_LogInfo
+ * \sa SDL_LogMessage
+ * \sa SDL_LogMessageV
+ * \sa SDL_LogWarn
  */
 extern DECLSPEC void SDLCALL SDL_LogVerbose(int category, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(2);
 
 /**
- *  \brief Log a message with SDL_LOG_PRIORITY_DEBUG
+ * Log a message with SDL_LOG_PRIORITY_DEBUG.
+ *
+ * \param category the category of the message
+ * \param fmt a printf() style message format string
+ * \param ... additional parameters matching % tokens in the **fmt** string,
+ *            if any
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_Log
+ * \sa SDL_LogCritical
+ * \sa SDL_LogError
+ * \sa SDL_LogInfo
+ * \sa SDL_LogMessage
+ * \sa SDL_LogMessageV
+ * \sa SDL_LogVerbose
+ * \sa SDL_LogWarn
  */
 extern DECLSPEC void SDLCALL SDL_LogDebug(int category, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(2);
 
 /**
- *  \brief Log a message with SDL_LOG_PRIORITY_INFO
+ * Log a message with SDL_LOG_PRIORITY_INFO.
+ *
+ * \param category the category of the message
+ * \param fmt a printf() style message format string
+ * \param ... additional parameters matching % tokens in the **fmt** string,
+ *            if any
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_Log
+ * \sa SDL_LogCritical
+ * \sa SDL_LogDebug
+ * \sa SDL_LogError
+ * \sa SDL_LogMessage
+ * \sa SDL_LogMessageV
+ * \sa SDL_LogVerbose
+ * \sa SDL_LogWarn
  */
 extern DECLSPEC void SDLCALL SDL_LogInfo(int category, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(2);
 
 /**
- *  \brief Log a message with SDL_LOG_PRIORITY_WARN
+ * Log a message with SDL_LOG_PRIORITY_WARN.
+ *
+ * \param category the category of the message
+ * \param fmt a printf() style message format string
+ * \param ... additional parameters matching % tokens in the **fmt** string,
+ *            if any
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_Log
+ * \sa SDL_LogCritical
+ * \sa SDL_LogDebug
+ * \sa SDL_LogError
+ * \sa SDL_LogInfo
+ * \sa SDL_LogMessage
+ * \sa SDL_LogMessageV
+ * \sa SDL_LogVerbose
  */
 extern DECLSPEC void SDLCALL SDL_LogWarn(int category, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(2);
 
 /**
- *  \brief Log a message with SDL_LOG_PRIORITY_ERROR
+ * Log a message with SDL_LOG_PRIORITY_ERROR.
+ *
+ * \param category the category of the message
+ * \param fmt a printf() style message format string
+ * \param ... additional parameters matching % tokens in the **fmt** string,
+ *            if any
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_Log
+ * \sa SDL_LogCritical
+ * \sa SDL_LogDebug
+ * \sa SDL_LogInfo
+ * \sa SDL_LogMessage
+ * \sa SDL_LogMessageV
+ * \sa SDL_LogVerbose
+ * \sa SDL_LogWarn
  */
 extern DECLSPEC void SDLCALL SDL_LogError(int category, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(2);
 
 /**
- *  \brief Log a message with SDL_LOG_PRIORITY_CRITICAL
+ * Log a message with SDL_LOG_PRIORITY_CRITICAL.
+ *
+ * \param category the category of the message
+ * \param fmt a printf() style message format string
+ * \param ... additional parameters matching % tokens in the **fmt** string,
+ *            if any
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_Log
+ * \sa SDL_LogDebug
+ * \sa SDL_LogError
+ * \sa SDL_LogInfo
+ * \sa SDL_LogMessage
+ * \sa SDL_LogMessageV
+ * \sa SDL_LogVerbose
+ * \sa SDL_LogWarn
  */
 extern DECLSPEC void SDLCALL SDL_LogCritical(int category, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(2);
 
 /**
- *  \brief Log a message with the specified category and priority.
+ * Log a message with the specified category and priority.
+ *
+ * \param category the category of the message
+ * \param priority the priority of the message
+ * \param fmt a printf() style message format string
+ * \param ... additional parameters matching % tokens in the **fmt** string,
+ *            if any
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_Log
+ * \sa SDL_LogCritical
+ * \sa SDL_LogDebug
+ * \sa SDL_LogError
+ * \sa SDL_LogInfo
+ * \sa SDL_LogMessageV
+ * \sa SDL_LogVerbose
+ * \sa SDL_LogWarn
  */
 extern DECLSPEC void SDLCALL SDL_LogMessage(int category,
                                             SDL_LogPriority priority,
                                             SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(3);
 
 /**
- *  \brief Log a message with the specified category and priority.
+ * Log a message with the specified category and priority.
+ *
+ * \param category the category of the message
+ * \param priority the priority of the message
+ * \param fmt a printf() style message format string
+ * \param ap a variable argument list
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_Log
+ * \sa SDL_LogCritical
+ * \sa SDL_LogDebug
+ * \sa SDL_LogError
+ * \sa SDL_LogInfo
+ * \sa SDL_LogMessage
+ * \sa SDL_LogVerbose
+ * \sa SDL_LogWarn
  */
 extern DECLSPEC void SDLCALL SDL_LogMessageV(int category,
                                              SDL_LogPriority priority,
                                              const char *fmt, va_list ap);
 
 /**
- *  \brief The prototype for the log output function
+ * The prototype for the log output callback function.
+ *
+ * This function is called by SDL when there is new text to be logged.
+ *
+ * \param userdata what was passed as `userdata` to SDL_LogSetOutputFunction()
+ * \param category the category of the message
+ * \param priority the priority of the message
+ * \param message the message being output
  */
 typedef void (SDLCALL *SDL_LogOutputFunction)(void *userdata, int category, SDL_LogPriority priority, const char *message);
 
 /**
- *  \brief Get the current log output function.
+ * Get the current log output function.
+ *
+ * \param callback an SDL_LogOutputFunction filled in with the current log
+ *                 callback
+ * \param userdata a pointer filled in with the pointer that is passed to
+ *                 `callback`
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_LogSetOutputFunction
  */
 extern DECLSPEC void SDLCALL SDL_LogGetOutputFunction(SDL_LogOutputFunction *callback, void **userdata);
 
 /**
- *  \brief This function allows you to replace the default log output
- *         function with one of your own.
+ * Replace the default log output function with one of your own.
+ *
+ * \param callback an SDL_LogOutputFunction to call instead of the default
+ * \param userdata a pointer that is passed to `callback`
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_LogGetOutputFunction
  */
 extern DECLSPEC void SDLCALL SDL_LogSetOutputFunction(SDL_LogOutputFunction callback, void *userdata);
 
diff --git a/Engine/lib/sdl/include/SDL_main.h b/Engine/lib/sdl/include/SDL_main.h
index fcb5c17db..b3fec15fe 100644
--- a/Engine/lib/sdl/include/SDL_main.h
+++ b/Engine/lib/sdl/include/SDL_main.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -83,6 +83,15 @@
 */
 #define SDL_MAIN_NEEDED
 
+#elif defined(__PSP__)
+/* On PSP SDL provides a main function that sets the module info,
+   activates the GPU and starts the thread required to be able to exit
+   the software.
+
+   If you provide this yourself, you may define SDL_MAIN_HANDLED
+ */
+#define SDL_MAIN_AVAILABLE
+
 #endif
 #endif /* SDL_MAIN_HANDLED */
 
@@ -122,20 +131,62 @@ extern SDLMAIN_DECLSPEC int SDL_main(int argc, char *argv[]);
 
 
 /**
- *  This is called by the real SDL main function to let the rest of the
- *  library know that initialization was done properly.
+ * Circumvent failure of SDL_Init() when not using SDL_main() as an entry
+ * point.
  *
- *  Calling this yourself without knowing what you're doing can cause
- *  crashes and hard to diagnose problems with your application.
+ * This function is defined in SDL_main.h, along with the preprocessor rule to
+ * redefine main() as SDL_main(). Thus to ensure that your main() function
+ * will not be changed it is necessary to define SDL_MAIN_HANDLED before
+ * including SDL.h.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_Init
  */
 extern DECLSPEC void SDLCALL SDL_SetMainReady(void);
 
 #ifdef __WIN32__
 
 /**
- *  This can be called to set the application class at startup
+ * Register a win32 window class for SDL's use.
+ *
+ * This can be called to set the application window class at startup. It is
+ * safe to call this multiple times, as long as every call is eventually
+ * paired with a call to SDL_UnregisterApp, but a second registration attempt
+ * while a previous registration is still active will be ignored, other than
+ * to increment a counter.
+ *
+ * Most applications do not need to, and should not, call this directly; SDL
+ * will call it when initializing the video subsystem.
+ *
+ * \param name the window class name, in UTF-8 encoding. If NULL, SDL
+ *             currently uses "SDL_app" but this isn't guaranteed.
+ * \param style the value to use in WNDCLASSEX::style. If `name` is NULL, SDL
+ *              currently uses `(CS_BYTEALIGNCLIENT | CS_OWNDC)` regardless of
+ *              what is specified here.
+ * \param hInst the HINSTANCE to use in WNDCLASSEX::hInstance. If zero, SDL
+ *              will use `GetModuleHandle(NULL)` instead.
+ * \returns 0 on success, -1 on error. SDL_GetError() may have details.
+ *
+ * \since This function is available since SDL 2.0.2.
+ */
+extern DECLSPEC int SDLCALL SDL_RegisterApp(const char *name, Uint32 style, void *hInst);
+
+/**
+ * Deregister the win32 window class from an SDL_RegisterApp call.
+ *
+ * This can be called to undo the effects of SDL_RegisterApp.
+ *
+ * Most applications do not need to, and should not, call this directly; SDL
+ * will call it when deinitializing the video subsystem.
+ *
+ * It is safe to call this multiple times, as long as every call is eventually
+ * paired with a prior call to SDL_RegisterApp. The window class will only be
+ * deregistered when the registration counter in SDL_RegisterApp decrements to
+ * zero through calls to this function.
+ *
+ * \since This function is available since SDL 2.0.2.
  */
-extern DECLSPEC int SDLCALL SDL_RegisterApp(char *name, Uint32 style, void *hInst);
 extern DECLSPEC void SDLCALL SDL_UnregisterApp(void);
 
 #endif /* __WIN32__ */
@@ -144,12 +195,14 @@ extern DECLSPEC void SDLCALL SDL_UnregisterApp(void);
 #ifdef __WINRT__
 
 /**
- *  \brief Initializes and launches an SDL/WinRT application.
+ * Initialize and launch an SDL/WinRT application.
  *
- *  \param mainFunction The SDL app's C-style main().
- *  \param reserved Reserved for future use; should be NULL
- *  \return 0 on success, -1 on failure.  On failure, use SDL_GetError to retrieve more
- *      information on the failure.
+ * \param mainFunction the SDL app's C-style main(), an SDL_main_func
+ * \param reserved reserved for future use; should be NULL
+ * \returns 0 on success or -1 on failure; call SDL_GetError() to retrieve
+ *          more information on the failure.
+ *
+ * \since This function is available since SDL 2.0.3.
  */
 extern DECLSPEC int SDLCALL SDL_WinRTRunApp(SDL_main_func mainFunction, void * reserved);
 
@@ -158,12 +211,14 @@ extern DECLSPEC int SDLCALL SDL_WinRTRunApp(SDL_main_func mainFunction, void * r
 #if defined(__IPHONEOS__)
 
 /**
- *  \brief Initializes and launches an SDL application.
+ * Initializes and launches an SDL application.
  *
- *  \param argc The argc parameter from the application's main() function
- *  \param argv The argv parameter from the application's main() function
- *  \param mainFunction The SDL app's C-style main().
- *  \return the return value from mainFunction
+ * \param argc The argc parameter from the application's main() function
+ * \param argv The argv parameter from the application's main() function
+ * \param mainFunction The SDL app's C-style main(), an SDL_main_func
+ * \return the return value from mainFunction
+ *
+ * \since This function is available since SDL 2.0.10.
  */
 extern DECLSPEC int SDLCALL SDL_UIKitRunApp(int argc, char *argv[], SDL_main_func mainFunction);
 
diff --git a/Engine/lib/sdl/include/SDL_messagebox.h b/Engine/lib/sdl/include/SDL_messagebox.h
index 03639ce4f..d763534d2 100644
--- a/Engine/lib/sdl/include/SDL_messagebox.h
+++ b/Engine/lib/sdl/include/SDL_messagebox.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -32,7 +32,7 @@ extern "C" {
 #endif
 
 /**
- * \brief SDL_MessageBox flags. If supported will display warning icon, etc.
+ * SDL_MessageBox flags. If supported will display warning icon, etc.
  */
 typedef enum
 {
@@ -44,7 +44,7 @@ typedef enum
 } SDL_MessageBoxFlags;
 
 /**
- * \brief Flags for SDL_MessageBoxButtonData.
+ * Flags for SDL_MessageBoxButtonData.
  */
 typedef enum
 {
@@ -53,7 +53,7 @@ typedef enum
 } SDL_MessageBoxButtonFlags;
 
 /**
- *  \brief Individual button data.
+ * Individual button data.
  */
 typedef struct
 {
@@ -63,7 +63,7 @@ typedef struct
 } SDL_MessageBoxButtonData;
 
 /**
- * \brief RGB value used in a message box color scheme
+ * RGB value used in a message box color scheme
  */
 typedef struct
 {
@@ -81,7 +81,7 @@ typedef enum
 } SDL_MessageBoxColorType;
 
 /**
- * \brief A set of colors to use for message box dialogs
+ * A set of colors to use for message box dialogs
  */
 typedef struct
 {
@@ -89,7 +89,7 @@ typedef struct
 } SDL_MessageBoxColorScheme;
 
 /**
- *  \brief MessageBox structure containing title, text, window, etc.
+ * MessageBox structure containing title, text, window, etc.
  */
 typedef struct
 {
@@ -105,32 +105,79 @@ typedef struct
 } SDL_MessageBoxData;
 
 /**
- *  \brief Create a modal message box.
+ * Create a modal message box.
  *
- *  \param messageboxdata The SDL_MessageBoxData structure with title, text, etc.
- *  \param buttonid The pointer to which user id of hit button should be copied.
+ * If your needs aren't complex, it might be easier to use
+ * SDL_ShowSimpleMessageBox.
  *
- *  \return -1 on error, otherwise 0 and buttonid contains user id of button
- *          hit or -1 if dialog was closed.
+ * This function should be called on the thread that created the parent
+ * window, or on the main thread if the messagebox has no parent. It will
+ * block execution of that thread until the user clicks a button or closes the
+ * messagebox.
  *
- *  \note This function should be called on the thread that created the parent
- *        window, or on the main thread if the messagebox has no parent.  It will
- *        block execution of that thread until the user clicks a button or
- *        closes the messagebox.
+ * This function may be called at any time, even before SDL_Init(). This makes
+ * it useful for reporting errors like a failure to create a renderer or
+ * OpenGL context.
+ *
+ * On X11, SDL rolls its own dialog box with X11 primitives instead of a
+ * formal toolkit like GTK+ or Qt.
+ *
+ * Note that if SDL_Init() would fail because there isn't any available video
+ * target, this function is likely to fail for the same reasons. If this is a
+ * concern, check the return value from this function and fall back to writing
+ * to stderr if you can.
+ *
+ * \param messageboxdata the SDL_MessageBoxData structure with title, text and
+ *                       other options
+ * \param buttonid the pointer to which user id of hit button should be copied
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_ShowSimpleMessageBox
  */
 extern DECLSPEC int SDLCALL SDL_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid);
 
 /**
- *  \brief Create a simple modal message box
+ * Display a simple modal message box.
  *
- *  \param flags    ::SDL_MessageBoxFlags
- *  \param title    UTF-8 title text
- *  \param message  UTF-8 message text
- *  \param window   The parent window, or NULL for no parent
+ * If your needs aren't complex, this function is preferred over
+ * SDL_ShowMessageBox.
  *
- *  \return 0 on success, -1 on error
+ * `flags` may be any of the following:
  *
- *  \sa SDL_ShowMessageBox
+ * - `SDL_MESSAGEBOX_ERROR`: error dialog
+ * - `SDL_MESSAGEBOX_WARNING`: warning dialog
+ * - `SDL_MESSAGEBOX_INFORMATION`: informational dialog
+ *
+ * This function should be called on the thread that created the parent
+ * window, or on the main thread if the messagebox has no parent. It will
+ * block execution of that thread until the user clicks a button or closes the
+ * messagebox.
+ *
+ * This function may be called at any time, even before SDL_Init(). This makes
+ * it useful for reporting errors like a failure to create a renderer or
+ * OpenGL context.
+ *
+ * On X11, SDL rolls its own dialog box with X11 primitives instead of a
+ * formal toolkit like GTK+ or Qt.
+ *
+ * Note that if SDL_Init() would fail because there isn't any available video
+ * target, this function is likely to fail for the same reasons. If this is a
+ * concern, check the return value from this function and fall back to writing
+ * to stderr if you can.
+ *
+ * \param flags an SDL_MessageBoxFlags value
+ * \param title UTF-8 title text
+ * \param message UTF-8 message text
+ * \param window the parent window, or NULL for no parent
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_ShowMessageBox
  */
 extern DECLSPEC int SDLCALL SDL_ShowSimpleMessageBox(Uint32 flags, const char *title, const char *message, SDL_Window *window);
 
diff --git a/Engine/lib/sdl/include/SDL_metal.h b/Engine/lib/sdl/include/SDL_metal.h
index f96735770..9ecaa8151 100644
--- a/Engine/lib/sdl/include/SDL_metal.h
+++ b/Engine/lib/sdl/include/SDL_metal.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -49,59 +49,54 @@ typedef void *SDL_MetalView;
 /* @{ */
 
 /**
- *  \brief Create a CAMetalLayer-backed NSView/UIView and attach it to the
- *        specified window.
+ * Create a CAMetalLayer-backed NSView/UIView and attach it to the specified
+ * window.
  *
- *  On macOS, this does *not* associate a MTLDevice with the CAMetalLayer on its
- *  own. It is up to user code to do that.
+ * On macOS, this does *not* associate a MTLDevice with the CAMetalLayer on
+ * its own. It is up to user code to do that.
  *
- *  The returned handle can be casted directly to a NSView or UIView.
- *  To access the backing CAMetalLayer, call SDL_Metal_GetLayer().
+ * The returned handle can be casted directly to a NSView or UIView. To access
+ * the backing CAMetalLayer, call SDL_Metal_GetLayer().
  *
- *  \note \a window must be created with the SDL_WINDOW_METAL flag.
+ * \since This function is available since SDL 2.0.12.
  *
- *  \sa SDL_Metal_DestroyView
- *  \sa SDL_Metal_GetLayer
+ * \sa SDL_Metal_DestroyView
+ * \sa SDL_Metal_GetLayer
  */
 extern DECLSPEC SDL_MetalView SDLCALL SDL_Metal_CreateView(SDL_Window * window);
 
 /**
- *  \brief Destroy an existing SDL_MetalView object.
+ * Destroy an existing SDL_MetalView object.
  *
- *  This should be called before SDL_DestroyWindow, if SDL_Metal_CreateView was
- *  called after SDL_CreateWindow.
+ * This should be called before SDL_DestroyWindow, if SDL_Metal_CreateView was
+ * called after SDL_CreateWindow.
  *
- *  \sa SDL_Metal_CreateView
+ * \since This function is available since SDL 2.0.12.
+ *
+ * \sa SDL_Metal_CreateView
  */
 extern DECLSPEC void SDLCALL SDL_Metal_DestroyView(SDL_MetalView view);
 
 /**
- *  \brief Get a pointer to the backing CAMetalLayer for the given view.
+ * Get a pointer to the backing CAMetalLayer for the given view.
  *
- *  \sa SDL_MetalCreateView
+ * \since This function is available since SDL 2.0.14.
+ *
+ * \sa SDL_MetalCreateView
  */
 extern DECLSPEC void *SDLCALL SDL_Metal_GetLayer(SDL_MetalView view);
 
 /**
- *  \brief Get the size of a window's underlying drawable in pixels (for use
- *         with setting viewport, scissor & etc).
+ * Get the size of a window's underlying drawable in pixels (for use with
+ * setting viewport, scissor & etc).
  *
- *  \param window   SDL_Window from which the drawable size should be queried
- *  \param w        Pointer to variable for storing the width in pixels,
- *                  may be NULL
- *  \param h        Pointer to variable for storing the height in pixels,
- *                  may be NULL
+ * \param window SDL_Window from which the drawable size should be queried
+ * \param w Pointer to variable for storing the width in pixels, may be NULL
  *
- * This may differ from SDL_GetWindowSize() if we're rendering to a high-DPI
- * drawable, i.e. the window was created with SDL_WINDOW_ALLOW_HIGHDPI on a
- * platform with high-DPI support (Apple calls this "Retina"), and not disabled
- * by the \c SDL_HINT_VIDEO_HIGHDPI_DISABLED hint.
+ * \since This function is available since SDL 2.0.14.
  *
- *  \note On macOS high-DPI support must be enabled for an application by
- *        setting NSHighResolutionCapable to true in its Info.plist.
- *
- *  \sa SDL_GetWindowSize()
- *  \sa SDL_CreateWindow()
+ * \sa SDL_GetWindowSize
+ * \sa SDL_CreateWindow
  */
 extern DECLSPEC void SDLCALL SDL_Metal_GetDrawableSize(SDL_Window* window, int *w,
                                                        int *h);
diff --git a/Engine/lib/sdl/include/SDL_misc.h b/Engine/lib/sdl/include/SDL_misc.h
index a04f19ba8..261b6b871 100644
--- a/Engine/lib/sdl/include/SDL_misc.h
+++ b/Engine/lib/sdl/include/SDL_misc.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -38,29 +38,33 @@ extern "C" {
 #endif
 
 /**
- * \brief Open an URL / URI in the browser or other
+ * Open a URL/URI in the browser or other appropriate external application.
  *
  * Open a URL in a separate, system-provided application. How this works will
- *  vary wildly depending on the platform. This will likely launch what
- *  makes sense to handle a specific URL's protocol (a web browser for http://,
- *  etc), but it might also be able to launch file managers for directories
- *  and other things.
+ * vary wildly depending on the platform. This will likely launch what makes
+ * sense to handle a specific URL's protocol (a web browser for `http://`,
+ * etc), but it might also be able to launch file managers for directories and
+ * other things.
  *
  * What happens when you open a URL varies wildly as well: your game window
- *  may lose focus (and may or may not lose focus if your game was fullscreen
- *  or grabbing input at the time). On mobile devices, your app will likely
- *  move to the background or your process might be paused. Any given platform
- *  may or may not handle a given URL.
+ * may lose focus (and may or may not lose focus if your game was fullscreen
+ * or grabbing input at the time). On mobile devices, your app will likely
+ * move to the background or your process might be paused. Any given platform
+ * may or may not handle a given URL.
  *
  * If this is unimplemented (or simply unavailable) for a platform, this will
- *  fail with an error. A successful result does not mean the URL loaded, just
- *  that we launched something to handle it (or at least believe we did).
+ * fail with an error. A successful result does not mean the URL loaded, just
+ * that we launched _something_ to handle it (or at least believe we did).
  *
  * All this to say: this function can be useful, but you should definitely
- *  test it on every platform you target.
+ * test it on every platform you target.
  *
- *   \param url A valid URL to open.
- *  \return 0 on success, or -1 on error.
+ * \param url A valid URL/URI to open. Use `file:///full/path/to/file` for
+ *            local files, if supported.
+ * \returns 0 on success, or -1 on error; call SDL_GetError() for more
+ *          information.
+ *
+ * \since This function is available since SDL 2.0.14.
  */
 extern DECLSPEC int SDLCALL SDL_OpenURL(const char *url);
 
diff --git a/Engine/lib/sdl/include/SDL_mouse.h b/Engine/lib/sdl/include/SDL_mouse.h
index 99b658e94..1d4a2db0d 100644
--- a/Engine/lib/sdl/include/SDL_mouse.h
+++ b/Engine/lib/sdl/include/SDL_mouse.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -72,150 +72,240 @@ typedef enum
 /* Function prototypes */
 
 /**
- *  \brief Get the window which currently has mouse focus.
+ * Get the window which currently has mouse focus.
+ *
+ * \returns the window with mouse focus.
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC SDL_Window * SDLCALL SDL_GetMouseFocus(void);
 
 /**
- *  \brief Retrieve the current state of the mouse.
+ * Retrieve the current state of the mouse.
  *
- *  The current button state is returned as a button bitmask, which can
- *  be tested using the SDL_BUTTON(X) macros, and x and y are set to the
- *  mouse cursor position relative to the focus window for the currently
- *  selected mouse.  You can pass NULL for either x or y.
+ * The current button state is returned as a button bitmask, which can be
+ * tested using the `SDL_BUTTON(X)` macros (where `X` is generally 1 for the
+ * left, 2 for middle, 3 for the right button), and `x` and `y` are set to the
+ * mouse cursor position relative to the focus window. You can pass NULL for
+ * either `x` or `y`.
+ *
+ * \param x the x coordinate of the mouse cursor position relative to the
+ *          focus window
+ * \param y the y coordinate of the mouse cursor position relative to the
+ *          focus window
+ * \returns a 32-bit button bitmask of the current button state.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetGlobalMouseState
+ * \sa SDL_GetRelativeMouseState
+ * \sa SDL_PumpEvents
  */
 extern DECLSPEC Uint32 SDLCALL SDL_GetMouseState(int *x, int *y);
 
 /**
- *  \brief Get the current state of the mouse, in relation to the desktop
+ * Get the current state of the mouse in relation to the desktop.
  *
- *  This works just like SDL_GetMouseState(), but the coordinates will be
- *  reported relative to the top-left of the desktop. This can be useful if
- *  you need to track the mouse outside of a specific window and
- *  SDL_CaptureMouse() doesn't fit your needs. For example, it could be
- *  useful if you need to track the mouse while dragging a window, where
- *  coordinates relative to a window might not be in sync at all times.
+ * This works similarly to SDL_GetMouseState(), but the coordinates will be
+ * reported relative to the top-left of the desktop. This can be useful if you
+ * need to track the mouse outside of a specific window and SDL_CaptureMouse()
+ * doesn't fit your needs. For example, it could be useful if you need to
+ * track the mouse while dragging a window, where coordinates relative to a
+ * window might not be in sync at all times.
  *
- *  \note SDL_GetMouseState() returns the mouse position as SDL understands
- *        it from the last pump of the event queue. This function, however,
- *        queries the OS for the current mouse position, and as such, might
- *        be a slightly less efficient function. Unless you know what you're
- *        doing and have a good reason to use this function, you probably want
- *        SDL_GetMouseState() instead.
+ * Note: SDL_GetMouseState() returns the mouse position as SDL understands it
+ * from the last pump of the event queue. This function, however, queries the
+ * OS for the current mouse position, and as such, might be a slightly less
+ * efficient function. Unless you know what you're doing and have a good
+ * reason to use this function, you probably want SDL_GetMouseState() instead.
  *
- *  \param x Returns the current X coord, relative to the desktop. Can be NULL.
- *  \param y Returns the current Y coord, relative to the desktop. Can be NULL.
- *  \return The current button state as a bitmask, which can be tested using the SDL_BUTTON(X) macros.
+ * \param x filled in with the current X coord relative to the desktop; can be
+ *          NULL
+ * \param y filled in with the current Y coord relative to the desktop; can be
+ *          NULL
+ * \returns the current button state as a bitmask which can be tested using
+ *          the SDL_BUTTON(X) macros.
  *
- *  \sa SDL_GetMouseState
+ * \since This function is available since SDL 2.0.4.
+ *
+ * \sa SDL_CaptureMouse
  */
 extern DECLSPEC Uint32 SDLCALL SDL_GetGlobalMouseState(int *x, int *y);
 
 /**
- *  \brief Retrieve the relative state of the mouse.
+ * Retrieve the relative state of the mouse.
  *
- *  The current button state is returned as a button bitmask, which can
- *  be tested using the SDL_BUTTON(X) macros, and x and y are set to the
- *  mouse deltas since the last call to SDL_GetRelativeMouseState().
+ * The current button state is returned as a button bitmask, which can be
+ * tested using the `SDL_BUTTON(X)` macros (where `X` is generally 1 for the
+ * left, 2 for middle, 3 for the right button), and `x` and `y` are set to the
+ * mouse deltas since the last call to SDL_GetRelativeMouseState() or since
+ * event initialization. You can pass NULL for either `x` or `y`.
+ *
+ * \param x a pointer filled with the last recorded x coordinate of the mouse
+ * \param y a pointer filled with the last recorded y coordinate of the mouse
+ * \returns a 32-bit button bitmask of the relative button state.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetMouseState
  */
 extern DECLSPEC Uint32 SDLCALL SDL_GetRelativeMouseState(int *x, int *y);
 
 /**
- *  \brief Moves the mouse to the given position within the window.
+ * Move the mouse cursor to the given position within the window.
  *
- *  \param window The window to move the mouse into, or NULL for the current mouse focus
- *  \param x The x coordinate within the window
- *  \param y The y coordinate within the window
+ * This function generates a mouse motion event.
  *
- *  \note This function generates a mouse motion event
+ * Note that this function will appear to succeed, but not actually move the
+ * mouse when used over Microsoft Remote Desktop.
+ *
+ * \param window the window to move the mouse into, or NULL for the current
+ *               mouse focus
+ * \param x the x coordinate within the window
+ * \param y the y coordinate within the window
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_WarpMouseGlobal
  */
 extern DECLSPEC void SDLCALL SDL_WarpMouseInWindow(SDL_Window * window,
                                                    int x, int y);
 
 /**
- *  \brief Moves the mouse to the given position in global screen space.
+ * Move the mouse to the given position in global screen space.
  *
- *  \param x The x coordinate
- *  \param y The y coordinate
- *  \return 0 on success, -1 on error (usually: unsupported by a platform).
+ * This function generates a mouse motion event.
  *
- *  \note This function generates a mouse motion event
+ * A failure of this function usually means that it is unsupported by a
+ * platform.
+ *
+ * Note that this function will appear to succeed, but not actually move the
+ * mouse when used over Microsoft Remote Desktop.
+ *
+ * \param x the x coordinate
+ * \param y the y coordinate
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.4.
+ *
+ * \sa SDL_WarpMouseInWindow
  */
 extern DECLSPEC int SDLCALL SDL_WarpMouseGlobal(int x, int y);
 
 /**
- *  \brief Set relative mouse mode.
+ * Set relative mouse mode.
  *
- *  \param enabled Whether or not to enable relative mode
+ * While the mouse is in relative mode, the cursor is hidden, and the driver
+ * will try to report continuous motion in the current window. Only relative
+ * motion events will be delivered, the mouse position will not change.
  *
- *  \return 0 on success, or -1 if relative mode is not supported.
+ * Note that this function will not be able to provide continuous relative
+ * motion when used over Microsoft Remote Desktop, instead motion is limited
+ * to the bounds of the screen.
  *
- *  While the mouse is in relative mode, the cursor is hidden, and the
- *  driver will try to report continuous motion in the current window.
- *  Only relative motion events will be delivered, the mouse position
- *  will not change.
+ * This function will flush any pending mouse motion.
  *
- *  \note This function will flush any pending mouse motion.
+ * \param enabled SDL_TRUE to enable relative mode, SDL_FALSE to disable.
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \sa SDL_GetRelativeMouseMode()
+ *          If relative mode is not supported, this returns -1.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetRelativeMouseMode
  */
 extern DECLSPEC int SDLCALL SDL_SetRelativeMouseMode(SDL_bool enabled);
 
 /**
- *  \brief Capture the mouse, to track input outside an SDL window.
+ * Capture the mouse and to track input outside an SDL window.
  *
- *  \param enabled Whether or not to enable capturing
+ * Capturing enables your app to obtain mouse events globally, instead of just
+ * within your window. Not all video targets support this function. When
+ * capturing is enabled, the current window will get all mouse events, but
+ * unlike relative mode, no change is made to the cursor and it is not
+ * restrained to your window.
  *
- *  Capturing enables your app to obtain mouse events globally, instead of
- *  just within your window. Not all video targets support this function.
- *  When capturing is enabled, the current window will get all mouse events,
- *  but unlike relative mode, no change is made to the cursor and it is
- *  not restrained to your window.
+ * This function may also deny mouse input to other windows--both those in
+ * your application and others on the system--so you should use this function
+ * sparingly, and in small bursts. For example, you might want to track the
+ * mouse while the user is dragging something, until the user releases a mouse
+ * button. It is not recommended that you capture the mouse for long periods
+ * of time, such as the entire time your app is running. For that, you should
+ * probably use SDL_SetRelativeMouseMode() or SDL_SetWindowGrab(), depending
+ * on your goals.
  *
- *  This function may also deny mouse input to other windows--both those in
- *  your application and others on the system--so you should use this
- *  function sparingly, and in small bursts. For example, you might want to
- *  track the mouse while the user is dragging something, until the user
- *  releases a mouse button. It is not recommended that you capture the mouse
- *  for long periods of time, such as the entire time your app is running.
+ * While captured, mouse events still report coordinates relative to the
+ * current (foreground) window, but those coordinates may be outside the
+ * bounds of the window (including negative values). Capturing is only allowed
+ * for the foreground window. If the window loses focus while capturing, the
+ * capture will be disabled automatically.
  *
- *  While captured, mouse events still report coordinates relative to the
- *  current (foreground) window, but those coordinates may be outside the
- *  bounds of the window (including negative values). Capturing is only
- *  allowed for the foreground window. If the window loses focus while
- *  capturing, the capture will be disabled automatically.
+ * While capturing is enabled, the current window will have the
+ * `SDL_WINDOW_MOUSE_CAPTURE` flag set.
  *
- *  While capturing is enabled, the current window will have the
- *  SDL_WINDOW_MOUSE_CAPTURE flag set.
+ * \param enabled SDL_TRUE to enable capturing, SDL_FALSE to disable.
+ * \returns 0 on success or -1 if not supported; call SDL_GetError() for more
+ *          information.
  *
- *  \return 0 on success, or -1 if not supported.
+ * \since This function is available since SDL 2.0.4.
+ *
+ * \sa SDL_GetGlobalMouseState
  */
 extern DECLSPEC int SDLCALL SDL_CaptureMouse(SDL_bool enabled);
 
 /**
- *  \brief Query whether relative mouse mode is enabled.
+ * Query whether relative mouse mode is enabled.
  *
- *  \sa SDL_SetRelativeMouseMode()
+ * \returns SDL_TRUE if relative mode is enabled or SDL_FALSE otherwise.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_SetRelativeMouseMode
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_GetRelativeMouseMode(void);
 
 /**
- *  \brief Create a cursor, using the specified bitmap data and
- *         mask (in MSB format).
+ * Create a cursor using the specified bitmap data and mask (in MSB format).
  *
- *  The cursor width must be a multiple of 8 bits.
+ * `mask` has to be in MSB (Most Significant Bit) format.
  *
- *  The cursor is created in black and white according to the following:
- *  <table>
- *  <tr><td> data </td><td> mask </td><td> resulting pixel on screen </td></tr>
- *  <tr><td>  0   </td><td>  1   </td><td> White </td></tr>
- *  <tr><td>  1   </td><td>  1   </td><td> Black </td></tr>
- *  <tr><td>  0   </td><td>  0   </td><td> Transparent </td></tr>
- *  <tr><td>  1   </td><td>  0   </td><td> Inverted color if possible, black
- *                                         if not. </td></tr>
- *  </table>
+ * The cursor width (`w`) must be a multiple of 8 bits.
  *
- *  \sa SDL_FreeCursor()
+ * The cursor is created in black and white according to the following:
+ *
+ * - data=0, mask=1: white
+ * - data=1, mask=1: black
+ * - data=0, mask=0: transparent
+ * - data=1, mask=0: inverted color if possible, black if not.
+ *
+ * Cursors created with this function must be freed with SDL_FreeCursor().
+ *
+ * If you want to have a color cursor, or create your cursor from an
+ * SDL_Surface, you should use SDL_CreateColorCursor(). Alternately, you can
+ * hide the cursor and draw your own as part of your game's rendering, but it
+ * will be bound to the framerate.
+ *
+ * Also, since SDL 2.0.0, SDL_CreateSystemCursor() is available, which
+ * provides twelve readily available system cursors to pick from.
+ *
+ * \param data the color value for each pixel of the cursor
+ * \param mask the mask value for each pixel of the cursor
+ * \param w the width of the cursor
+ * \param h the height of the cursor
+ * \param hot_x the X-axis location of the upper left corner of the cursor
+ *              relative to the actual mouse position
+ * \param hot_y the Y-axis location of the upper left corner of the cursor
+ *              relative to the actual mouse position
+ * \returns a new cursor with the specified parameters on success or NULL on
+ *          failure; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_FreeCursor
+ * \sa SDL_SetCursor
+ * \sa SDL_ShowCursor
  */
 extern DECLSPEC SDL_Cursor *SDLCALL SDL_CreateCursor(const Uint8 * data,
                                                      const Uint8 * mask,
@@ -223,60 +313,123 @@ extern DECLSPEC SDL_Cursor *SDLCALL SDL_CreateCursor(const Uint8 * data,
                                                      int hot_y);
 
 /**
- *  \brief Create a color cursor.
+ * Create a color cursor.
  *
- *  \sa SDL_FreeCursor()
+ * \param surface an SDL_Surface structure representing the cursor image
+ * \param hot_x the x position of the cursor hot spot
+ * \param hot_y the y position of the cursor hot spot
+ * \returns the new cursor on success or NULL on failure; call SDL_GetError()
+ *          for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateCursor
+ * \sa SDL_FreeCursor
  */
 extern DECLSPEC SDL_Cursor *SDLCALL SDL_CreateColorCursor(SDL_Surface *surface,
                                                           int hot_x,
                                                           int hot_y);
 
 /**
- *  \brief Create a system cursor.
+ * Create a system cursor.
  *
- *  \sa SDL_FreeCursor()
+ * \param id an SDL_SystemCursor enum value
+ * \returns a cursor on success or NULL on failure; call SDL_GetError() for
+ *          more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_FreeCursor
  */
 extern DECLSPEC SDL_Cursor *SDLCALL SDL_CreateSystemCursor(SDL_SystemCursor id);
 
 /**
- *  \brief Set the active cursor.
+ * Set the active cursor.
+ *
+ * This function sets the currently active cursor to the specified one. If the
+ * cursor is currently visible, the change will be immediately represented on
+ * the display. SDL_SetCursor(NULL) can be used to force cursor redraw, if
+ * this is desired for any reason.
+ *
+ * \param cursor a cursor to make active
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateCursor
+ * \sa SDL_GetCursor
+ * \sa SDL_ShowCursor
  */
 extern DECLSPEC void SDLCALL SDL_SetCursor(SDL_Cursor * cursor);
 
 /**
- *  \brief Return the active cursor.
+ * Get the active cursor.
+ *
+ * This function returns a pointer to the current cursor which is owned by the
+ * library. It is not necessary to free the cursor with SDL_FreeCursor().
+ *
+ * \returns the active cursor or NULL if there is no mouse.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_SetCursor
  */
 extern DECLSPEC SDL_Cursor *SDLCALL SDL_GetCursor(void);
 
 /**
- *  \brief Return the default cursor.
+ * Get the default cursor.
+ *
+ * \returns the default cursor on success or NULL on failure.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateSystemCursor
  */
 extern DECLSPEC SDL_Cursor *SDLCALL SDL_GetDefaultCursor(void);
 
 /**
- *  \brief Frees a cursor created with SDL_CreateCursor() or similar functions.
+ * Free a previously-created cursor.
  *
- *  \sa SDL_CreateCursor()
- *  \sa SDL_CreateColorCursor()
- *  \sa SDL_CreateSystemCursor()
+ * Use this function to free cursor resources created with SDL_CreateCursor(),
+ * SDL_CreateColorCursor() or SDL_CreateSystemCursor().
+ *
+ * \param cursor the cursor to free
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateColorCursor
+ * \sa SDL_CreateCursor
+ * \sa SDL_CreateSystemCursor
  */
 extern DECLSPEC void SDLCALL SDL_FreeCursor(SDL_Cursor * cursor);
 
 /**
- *  \brief Toggle whether or not the cursor is shown.
+ * Toggle whether or not the cursor is shown.
  *
- *  \param toggle 1 to show the cursor, 0 to hide it, -1 to query the current
- *                state.
+ * The cursor starts off displayed but can be turned off. Passing `SDL_ENABLE`
+ * displays the cursor and passing `SDL_DISABLE` hides it.
  *
- *  \return 1 if the cursor is shown, or 0 if the cursor is hidden.
+ * The current state of the mouse cursor can be queried by passing
+ * `SDL_QUERY`; either `SDL_DISABLE` or `SDL_ENABLE` will be returned.
+ *
+ * \param toggle `SDL_ENABLE` to show the cursor, `SDL_DISABLE` to hide it,
+ *               `SDL_QUERY` to query the current state without changing it.
+ * \returns `SDL_ENABLE` if the cursor is shown, or `SDL_DISABLE` if the
+ *          cursor is hidden, or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateCursor
+ * \sa SDL_SetCursor
  */
 extern DECLSPEC int SDLCALL SDL_ShowCursor(int toggle);
 
 /**
- *  Used as a mask when testing buttons in buttonstate.
- *   - Button 1:  Left mouse button
- *   - Button 2:  Middle mouse button
- *   - Button 3:  Right mouse button
+ * Used as a mask when testing buttons in buttonstate.
+ *
+ * - Button 1:  Left mouse button
+ * - Button 2:  Middle mouse button
+ * - Button 3:  Right mouse button
  */
 #define SDL_BUTTON(X)       (1 << ((X)-1))
 #define SDL_BUTTON_LEFT     1
@@ -290,7 +443,6 @@ extern DECLSPEC int SDLCALL SDL_ShowCursor(int toggle);
 #define SDL_BUTTON_X1MASK   SDL_BUTTON(SDL_BUTTON_X1)
 #define SDL_BUTTON_X2MASK   SDL_BUTTON(SDL_BUTTON_X2)
 
-
 /* Ends C function definitions when using C++ */
 #ifdef __cplusplus
 }
diff --git a/Engine/lib/sdl/include/SDL_mutex.h b/Engine/lib/sdl/include/SDL_mutex.h
index 3c5b95574..173468f6a 100644
--- a/Engine/lib/sdl/include/SDL_mutex.h
+++ b/Engine/lib/sdl/include/SDL_mutex.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -59,38 +59,105 @@ struct SDL_mutex;
 typedef struct SDL_mutex SDL_mutex;
 
 /**
- *  Create a mutex, initialized unlocked.
+ * Create a new mutex.
+ *
+ * All newly-created mutexes begin in the _unlocked_ state.
+ *
+ * Calls to SDL_LockMutex() will not return while the mutex is locked by
+ * another thread. See SDL_TryLockMutex() to attempt to lock without blocking.
+ *
+ * SDL mutexes are reentrant.
+ *
+ * \returns the initialized and unlocked mutex or NULL on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_DestroyMutex
+ * \sa SDL_LockMutex
+ * \sa SDL_TryLockMutex
+ * \sa SDL_UnlockMutex
  */
 extern DECLSPEC SDL_mutex *SDLCALL SDL_CreateMutex(void);
 
 /**
- *  Lock the mutex.
+ * Lock the mutex.
  *
- *  \return 0, or -1 on error.
+ * This will block until the mutex is available, which is to say it is in the
+ * unlocked state and the OS has chosen the caller as the next thread to lock
+ * it. Of all threads waiting to lock the mutex, only one may do so at a time.
+ *
+ * It is legal for the owning thread to lock an already-locked mutex. It must
+ * unlock it the same number of times before it is actually made available for
+ * other threads in the system (this is known as a "recursive mutex").
+ *
+ * \param mutex the mutex to lock
+ * \return 0, or -1 on error.
+ *
+ * \since This function is available since SDL 2.0.0.
  */
-#define SDL_mutexP(m)   SDL_LockMutex(m)
 extern DECLSPEC int SDLCALL SDL_LockMutex(SDL_mutex * mutex);
+#define SDL_mutexP(m)   SDL_LockMutex(m)
 
 /**
- *  Try to lock the mutex
+ * Try to lock a mutex without blocking.
  *
- *  \return 0, SDL_MUTEX_TIMEDOUT, or -1 on error
+ * This works just like SDL_LockMutex(), but if the mutex is not available,
+ * this function returns `SDL_MUTEX_TIMEOUT` immediately.
+ *
+ * This technique is useful if you need exclusive access to a resource but
+ * don't want to wait for it, and will return to it to try again later.
+ *
+ * \param mutex the mutex to try to lock
+ * \returns 0, `SDL_MUTEX_TIMEDOUT`, or -1 on error; call SDL_GetError() for
+ *          more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateMutex
+ * \sa SDL_DestroyMutex
+ * \sa SDL_LockMutex
+ * \sa SDL_UnlockMutex
  */
 extern DECLSPEC int SDLCALL SDL_TryLockMutex(SDL_mutex * mutex);
 
 /**
- *  Unlock the mutex.
+ * Unlock the mutex.
  *
- *  \return 0, or -1 on error.
+ * It is legal for the owning thread to lock an already-locked mutex. It must
+ * unlock it the same number of times before it is actually made available for
+ * other threads in the system (this is known as a "recursive mutex").
  *
- *  \warning It is an error to unlock a mutex that has not been locked by
- *           the current thread, and doing so results in undefined behavior.
+ * It is an error to unlock a mutex that has not been locked by the current
+ * thread, and doing so results in undefined behavior.
+ *
+ * It is also an error to unlock a mutex that isn't locked at all.
+ *
+ * \param mutex the mutex to unlock.
+ * \returns 0, or -1 on error.
+ *
+ * \since This function is available since SDL 2.0.0.
  */
-#define SDL_mutexV(m)   SDL_UnlockMutex(m)
 extern DECLSPEC int SDLCALL SDL_UnlockMutex(SDL_mutex * mutex);
+#define SDL_mutexV(m)   SDL_UnlockMutex(m)
 
 /**
- *  Destroy a mutex.
+ * Destroy a mutex created with SDL_CreateMutex().
+ *
+ * This function must be called on any mutex that is no longer needed. Failure
+ * to destroy a mutex will result in a system memory or resource leak. While
+ * it is safe to destroy a mutex that is _unlocked_, it is not safe to attempt
+ * to destroy a locked mutex, and may result in undefined behavior depending
+ * on the platform.
+ *
+ * \param mutex the mutex to destroy
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateMutex
+ * \sa SDL_LockMutex
+ * \sa SDL_TryLockMutex
+ * \sa SDL_UnlockMutex
  */
 extern DECLSPEC void SDLCALL SDL_DestroyMutex(SDL_mutex * mutex);
 
@@ -107,50 +174,151 @@ struct SDL_semaphore;
 typedef struct SDL_semaphore SDL_sem;
 
 /**
- *  Create a semaphore, initialized with value, returns NULL on failure.
+ * Create a semaphore.
+ *
+ * This function creates a new semaphore and initializes it with the value
+ * `initial_value`. Each wait operation on the semaphore will atomically
+ * decrement the semaphore value and potentially block if the semaphore value
+ * is 0. Each post operation will atomically increment the semaphore value and
+ * wake waiting threads and allow them to retry the wait operation.
+ *
+ * \param initial_value the starting value of the semaphore
+ * \returns a new semaphore or NULL on failure; call SDL_GetError() for more
+ *          information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_DestroySemaphore
+ * \sa SDL_SemPost
+ * \sa SDL_SemTryWait
+ * \sa SDL_SemValue
+ * \sa SDL_SemWait
+ * \sa SDL_SemWaitTimeout
  */
 extern DECLSPEC SDL_sem *SDLCALL SDL_CreateSemaphore(Uint32 initial_value);
 
 /**
- *  Destroy a semaphore.
+ * Destroy a semaphore.
+ *
+ * It is not safe to destroy a semaphore if there are threads currently
+ * waiting on it.
+ *
+ * \param sem the semaphore to destroy
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateSemaphore
+ * \sa SDL_SemPost
+ * \sa SDL_SemTryWait
+ * \sa SDL_SemValue
+ * \sa SDL_SemWait
+ * \sa SDL_SemWaitTimeout
  */
 extern DECLSPEC void SDLCALL SDL_DestroySemaphore(SDL_sem * sem);
 
 /**
- *  This function suspends the calling thread until the semaphore pointed
- *  to by \c sem has a positive count. It then atomically decreases the
- *  semaphore count.
+ * Wait until a semaphore has a positive value and then decrements it.
+ *
+ * This function suspends the calling thread until either the semaphore
+ * pointed to by `sem` has a positive value or the call is interrupted by a
+ * signal or error. If the call is successful it will atomically decrement the
+ * semaphore value.
+ *
+ * This function is the equivalent of calling SDL_SemWaitTimeout() with a time
+ * length of `SDL_MUTEX_MAXWAIT`.
+ *
+ * \param sem the semaphore wait on
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateSemaphore
+ * \sa SDL_DestroySemaphore
+ * \sa SDL_SemPost
+ * \sa SDL_SemTryWait
+ * \sa SDL_SemValue
+ * \sa SDL_SemWait
+ * \sa SDL_SemWaitTimeout
  */
 extern DECLSPEC int SDLCALL SDL_SemWait(SDL_sem * sem);
 
 /**
- *  Non-blocking variant of SDL_SemWait().
+ * See if a semaphore has a positive value and decrement it if it does.
  *
- *  \return 0 if the wait succeeds, ::SDL_MUTEX_TIMEDOUT if the wait would
- *          block, and -1 on error.
+ * This function checks to see if the semaphore pointed to by `sem` has a
+ * positive value and atomically decrements the semaphore value if it does. If
+ * the semaphore doesn't have a positive value, the function immediately
+ * returns SDL_MUTEX_TIMEDOUT.
+ *
+ * \param sem the semaphore to wait on
+ * \returns 0 if the wait succeeds, `SDL_MUTEX_TIMEDOUT` if the wait would
+ *          block, or a negative error code on failure; call SDL_GetError()
+ *          for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateSemaphore
+ * \sa SDL_DestroySemaphore
+ * \sa SDL_SemPost
+ * \sa SDL_SemValue
+ * \sa SDL_SemWait
+ * \sa SDL_SemWaitTimeout
  */
 extern DECLSPEC int SDLCALL SDL_SemTryWait(SDL_sem * sem);
 
 /**
- *  Variant of SDL_SemWait() with a timeout in milliseconds.
+ * Wait until a semaphore has a positive value and then decrements it.
  *
- *  \return 0 if the wait succeeds, ::SDL_MUTEX_TIMEDOUT if the wait does not
- *          succeed in the allotted time, and -1 on error.
+ * This function suspends the calling thread until either the semaphore
+ * pointed to by `sem` has a positive value, the call is interrupted by a
+ * signal or error, or the specified time has elapsed. If the call is
+ * successful it will atomically decrement the semaphore value.
  *
- *  \warning On some platforms this function is implemented by looping with a
- *           delay of 1 ms, and so should be avoided if possible.
+ * \param sem the semaphore to wait on
+ * \param ms the length of the timeout, in milliseconds
+ * \returns 0 if the wait succeeds, `SDL_MUTEX_TIMEDOUT` if the wait does not
+ *          succeed in the allotted time, or a negative error code on failure;
+ *          call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateSemaphore
+ * \sa SDL_DestroySemaphore
+ * \sa SDL_SemPost
+ * \sa SDL_SemTryWait
+ * \sa SDL_SemValue
+ * \sa SDL_SemWait
  */
 extern DECLSPEC int SDLCALL SDL_SemWaitTimeout(SDL_sem * sem, Uint32 ms);
 
 /**
- *  Atomically increases the semaphore's count (not blocking).
+ * Atomically increment a semaphore's value and wake waiting threads.
  *
- *  \return 0, or -1 on error.
+ * \param sem the semaphore to increment
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateSemaphore
+ * \sa SDL_DestroySemaphore
+ * \sa SDL_SemTryWait
+ * \sa SDL_SemValue
+ * \sa SDL_SemWait
+ * \sa SDL_SemWaitTimeout
  */
 extern DECLSPEC int SDLCALL SDL_SemPost(SDL_sem * sem);
 
 /**
- *  Returns the current count of the semaphore.
+ * Get the current value of a semaphore.
+ *
+ * \param sem the semaphore to query
+ * \returns the current value of the semaphore.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateSemaphore
  */
 extern DECLSPEC Uint32 SDLCALL SDL_SemValue(SDL_sem * sem);
 
@@ -167,72 +335,124 @@ struct SDL_cond;
 typedef struct SDL_cond SDL_cond;
 
 /**
- *  Create a condition variable.
+ * Create a condition variable.
  *
- *  Typical use of condition variables:
+ * \returns a new condition variable or NULL on failure; call SDL_GetError()
+ *          for more information.
  *
- *  Thread A:
- *    SDL_LockMutex(lock);
- *    while ( ! condition ) {
- *        SDL_CondWait(cond, lock);
- *    }
- *    SDL_UnlockMutex(lock);
+ * \since This function is available since SDL 2.0.0.
  *
- *  Thread B:
- *    SDL_LockMutex(lock);
- *    ...
- *    condition = true;
- *    ...
- *    SDL_CondSignal(cond);
- *    SDL_UnlockMutex(lock);
- *
- *  There is some discussion whether to signal the condition variable
- *  with the mutex locked or not.  There is some potential performance
- *  benefit to unlocking first on some platforms, but there are some
- *  potential race conditions depending on how your code is structured.
- *
- *  In general it's safer to signal the condition variable while the
- *  mutex is locked.
+ * \sa SDL_CondBroadcast
+ * \sa SDL_CondSignal
+ * \sa SDL_CondWait
+ * \sa SDL_CondWaitTimeout
+ * \sa SDL_DestroyCond
  */
 extern DECLSPEC SDL_cond *SDLCALL SDL_CreateCond(void);
 
 /**
- *  Destroy a condition variable.
+ * Destroy a condition variable.
+ *
+ * \param cond the condition variable to destroy
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CondBroadcast
+ * \sa SDL_CondSignal
+ * \sa SDL_CondWait
+ * \sa SDL_CondWaitTimeout
+ * \sa SDL_CreateCond
  */
 extern DECLSPEC void SDLCALL SDL_DestroyCond(SDL_cond * cond);
 
 /**
- *  Restart one of the threads that are waiting on the condition variable.
+ * Restart one of the threads that are waiting on the condition variable.
  *
- *  \return 0 or -1 on error.
+ * \param cond the condition variable to signal
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CondBroadcast
+ * \sa SDL_CondWait
+ * \sa SDL_CondWaitTimeout
+ * \sa SDL_CreateCond
+ * \sa SDL_DestroyCond
  */
 extern DECLSPEC int SDLCALL SDL_CondSignal(SDL_cond * cond);
 
 /**
- *  Restart all threads that are waiting on the condition variable.
+ * Restart all threads that are waiting on the condition variable.
  *
- *  \return 0 or -1 on error.
+ * \param cond the condition variable to signal
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CondSignal
+ * \sa SDL_CondWait
+ * \sa SDL_CondWaitTimeout
+ * \sa SDL_CreateCond
+ * \sa SDL_DestroyCond
  */
 extern DECLSPEC int SDLCALL SDL_CondBroadcast(SDL_cond * cond);
 
 /**
- *  Wait on the condition variable, unlocking the provided mutex.
+ * Wait until a condition variable is signaled.
  *
- *  \warning The mutex must be locked before entering this function!
+ * This function unlocks the specified `mutex` and waits for another thread to
+ * call SDL_CondSignal() or SDL_CondBroadcast() on the condition variable
+ * `cond`. Once the condition variable is signaled, the mutex is re-locked and
+ * the function returns.
  *
- *  The mutex is re-locked once the condition variable is signaled.
+ * The mutex must be locked before calling this function.
  *
- *  \return 0 when it is signaled, or -1 on error.
+ * This function is the equivalent of calling SDL_CondWaitTimeout() with a
+ * time length of `SDL_MUTEX_MAXWAIT`.
+ *
+ * \param cond the condition variable to wait on
+ * \param mutex the mutex used to coordinate thread access
+ * \returns 0 when it is signaled or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CondBroadcast
+ * \sa SDL_CondSignal
+ * \sa SDL_CondWaitTimeout
+ * \sa SDL_CreateCond
+ * \sa SDL_DestroyCond
  */
 extern DECLSPEC int SDLCALL SDL_CondWait(SDL_cond * cond, SDL_mutex * mutex);
 
 /**
- *  Waits for at most \c ms milliseconds, and returns 0 if the condition
- *  variable is signaled, ::SDL_MUTEX_TIMEDOUT if the condition is not
- *  signaled in the allotted time, and -1 on error.
+ * Wait until a condition variable is signaled or a certain time has passed.
  *
- *  \warning On some platforms this function is implemented by looping with a
- *           delay of 1 ms, and so should be avoided if possible.
+ * This function unlocks the specified `mutex` and waits for another thread to
+ * call SDL_CondSignal() or SDL_CondBroadcast() on the condition variable
+ * `cond`, or for the specified time to elapse. Once the condition variable is
+ * signaled or the time elapsed, the mutex is re-locked and the function
+ * returns.
+ *
+ * The mutex must be locked before calling this function.
+ *
+ * \param cond the condition variable to wait on
+ * \param mutex the mutex used to coordinate thread access
+ * \param ms the maximum time to wait, in milliseconds, or `SDL_MUTEX_MAXWAIT`
+ *           to wait indefinitely
+ * \returns 0 if the condition variable is signaled, `SDL_MUTEX_TIMEDOUT` if
+ *          the condition is not signaled in the allotted time, or a negative
+ *          error code on failure; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CondBroadcast
+ * \sa SDL_CondSignal
+ * \sa SDL_CondWait
+ * \sa SDL_CreateCond
+ * \sa SDL_DestroyCond
  */
 extern DECLSPEC int SDLCALL SDL_CondWaitTimeout(SDL_cond * cond,
                                                 SDL_mutex * mutex, Uint32 ms);
diff --git a/Engine/lib/sdl/include/SDL_name.h b/Engine/lib/sdl/include/SDL_name.h
index a49c4887b..6ff35b46e 100644
--- a/Engine/lib/sdl/include/SDL_name.h
+++ b/Engine/lib/sdl/include/SDL_name.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/include/SDL_opengl.h b/Engine/lib/sdl/include/SDL_opengl.h
index 5cd302cde..9aed5035a 100644
--- a/Engine/lib/sdl/include/SDL_opengl.h
+++ b/Engine/lib/sdl/include/SDL_opengl.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/include/SDL_opengles.h b/Engine/lib/sdl/include/SDL_opengles.h
index 5c2a3e63c..8511b9607 100644
--- a/Engine/lib/sdl/include/SDL_opengles.h
+++ b/Engine/lib/sdl/include/SDL_opengles.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/include/SDL_opengles2.h b/Engine/lib/sdl/include/SDL_opengles2.h
index 00bc180c2..172fcb3f4 100644
--- a/Engine/lib/sdl/include/SDL_opengles2.h
+++ b/Engine/lib/sdl/include/SDL_opengles2.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -26,7 +26,7 @@
  */
 #include "SDL_config.h"
 
-#ifndef _MSC_VER
+#if !defined(_MSC_VER) && !defined(SDL_USE_BUILTIN_OPENGL_DEFINITIONS)
 
 #ifdef __IPHONEOS__
 #include <OpenGLES/ES2/gl.h>
diff --git a/Engine/lib/sdl/include/SDL_pixels.h b/Engine/lib/sdl/include/SDL_pixels.h
index aa90cbc2a..5d2c0c898 100644
--- a/Engine/lib/sdl/include/SDL_pixels.h
+++ b/Engine/lib/sdl/include/SDL_pixels.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -301,6 +301,11 @@ typedef enum
         SDL_DEFINE_PIXELFOURCC('O', 'E', 'S', ' ')
 } SDL_PixelFormatEnum;
 
+/**
+ * The bits of this structure can be directly reinterpreted as an integer-packed
+ * color which uses the SDL_PIXELFORMAT_RGBA32 format (SDL_PIXELFORMAT_ABGR8888
+ * on little-endian systems and SDL_PIXELFORMAT_RGBA8888 on big-endian systems).
+ */
 typedef struct SDL_Color
 {
     Uint8 r;
@@ -345,16 +350,31 @@ typedef struct SDL_PixelFormat
 } SDL_PixelFormat;
 
 /**
- * \brief Get the human readable name of a pixel format
+ * Get the human readable name of a pixel format.
+ *
+ * \param format the pixel format to query
+ * \returns the human readable name of the specified pixel format or
+ *          `SDL_PIXELFORMAT_UNKNOWN` if the format isn't recognized.
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC const char* SDLCALL SDL_GetPixelFormatName(Uint32 format);
 
 /**
- *  \brief Convert one of the enumerated pixel formats to a bpp and RGBA masks.
+ * Convert one of the enumerated pixel formats to a bpp value and RGBA masks.
  *
- *  \return SDL_TRUE, or SDL_FALSE if the conversion wasn't possible.
+ * \param format one of the SDL_PixelFormatEnum values
+ * \param bpp a bits per pixel value; usually 15, 16, or 32
+ * \param Rmask a pointer filled in with the red mask for the format
+ * \param Gmask a pointer filled in with the green mask for the format
+ * \param Bmask a pointer filled in with the blue mask for the format
+ * \param Amask a pointer filled in with the alpha mask for the format
+ * \returns SDL_TRUE on success or SDL_FALSE if the conversion wasn't
+ *          possible; call SDL_GetError() for more information.
  *
- *  \sa SDL_MasksToPixelFormatEnum()
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_MasksToPixelFormatEnum
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_PixelFormatEnumToMasks(Uint32 format,
                                                             int *bpp,
@@ -364,12 +384,21 @@ extern DECLSPEC SDL_bool SDLCALL SDL_PixelFormatEnumToMasks(Uint32 format,
                                                             Uint32 * Amask);
 
 /**
- *  \brief Convert a bpp and RGBA masks to an enumerated pixel format.
+ * Convert a bpp value and RGBA masks to an enumerated pixel format.
  *
- *  \return The pixel format, or ::SDL_PIXELFORMAT_UNKNOWN if the conversion
- *          wasn't possible.
+ * This will return `SDL_PIXELFORMAT_UNKNOWN` if the conversion wasn't
+ * possible.
  *
- *  \sa SDL_PixelFormatEnumToMasks()
+ * \param bpp a bits per pixel value; usually 15, 16, or 32
+ * \param Rmask the red mask for the format
+ * \param Gmask the green mask for the format
+ * \param Bmask the blue mask for the format
+ * \param Amask the alpha mask for the format
+ * \returns one of the SDL_PixelFormatEnum values
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_PixelFormatEnumToMasks
  */
 extern DECLSPEC Uint32 SDLCALL SDL_MasksToPixelFormatEnum(int bpp,
                                                           Uint32 Rmask,
@@ -378,84 +407,213 @@ extern DECLSPEC Uint32 SDLCALL SDL_MasksToPixelFormatEnum(int bpp,
                                                           Uint32 Amask);
 
 /**
- *  \brief Create an SDL_PixelFormat structure from a pixel format enum.
+ * Create an SDL_PixelFormat structure corresponding to a pixel format.
+ *
+ * Returned structure may come from a shared global cache (i.e. not newly
+ * allocated), and hence should not be modified, especially the palette. Weird
+ * errors such as `Blit combination not supported` may occur.
+ *
+ * \param pixel_format one of the SDL_PixelFormatEnum values
+ * \returns the new SDL_PixelFormat structure or NULL on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_FreeFormat
  */
 extern DECLSPEC SDL_PixelFormat * SDLCALL SDL_AllocFormat(Uint32 pixel_format);
 
 /**
- *  \brief Free an SDL_PixelFormat structure.
+ * Free an SDL_PixelFormat structure allocated by SDL_AllocFormat().
+ *
+ * \param format the SDL_PixelFormat structure to free
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_AllocFormat
  */
 extern DECLSPEC void SDLCALL SDL_FreeFormat(SDL_PixelFormat *format);
 
 /**
- *  \brief Create a palette structure with the specified number of color
- *         entries.
+ * Create a palette structure with the specified number of color entries.
  *
- *  \return A new palette, or NULL if there wasn't enough memory.
+ * The palette entries are initialized to white.
  *
- *  \note The palette entries are initialized to white.
+ * \param ncolors represents the number of color entries in the color palette
+ * \returns a new SDL_Palette structure on success or NULL on failure (e.g. if
+ *          there wasn't enough memory); call SDL_GetError() for more
+ *          information.
  *
- *  \sa SDL_FreePalette()
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_FreePalette
  */
 extern DECLSPEC SDL_Palette *SDLCALL SDL_AllocPalette(int ncolors);
 
 /**
- *  \brief Set the palette for a pixel format structure.
+ * Set the palette for a pixel format structure.
+ *
+ * \param format the SDL_PixelFormat structure that will use the palette
+ * \param palette the SDL_Palette structure that will be used
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_AllocPalette
+ * \sa SDL_FreePalette
  */
 extern DECLSPEC int SDLCALL SDL_SetPixelFormatPalette(SDL_PixelFormat * format,
                                                       SDL_Palette *palette);
 
 /**
- *  \brief Set a range of colors in a palette.
+ * Set a range of colors in a palette.
  *
- *  \param palette    The palette to modify.
- *  \param colors     An array of colors to copy into the palette.
- *  \param firstcolor The index of the first palette entry to modify.
- *  \param ncolors    The number of entries to modify.
+ * \param palette the SDL_Palette structure to modify
+ * \param colors an array of SDL_Color structures to copy into the palette
+ * \param firstcolor the index of the first palette entry to modify
+ * \param ncolors the number of entries to modify
+ * \returns 0 on success or a negative error code if not all of the colors
+ *          could be set; call SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 if not all of the colors could be set.
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_AllocPalette
+ * \sa SDL_CreateRGBSurface
  */
 extern DECLSPEC int SDLCALL SDL_SetPaletteColors(SDL_Palette * palette,
                                                  const SDL_Color * colors,
                                                  int firstcolor, int ncolors);
 
 /**
- *  \brief Free a palette created with SDL_AllocPalette().
+ * Free a palette created with SDL_AllocPalette().
  *
- *  \sa SDL_AllocPalette()
+ * \param palette the SDL_Palette structure to be freed
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_AllocPalette
  */
 extern DECLSPEC void SDLCALL SDL_FreePalette(SDL_Palette * palette);
 
 /**
- *  \brief Maps an RGB triple to an opaque pixel value for a given pixel format.
+ * Map an RGB triple to an opaque pixel value for a given pixel format.
  *
- *  \sa SDL_MapRGBA
+ * This function maps the RGB color value to the specified pixel format and
+ * returns the pixel value best approximating the given RGB color value for
+ * the given pixel format.
+ *
+ * If the format has a palette (8-bit) the index of the closest matching color
+ * in the palette will be returned.
+ *
+ * If the specified pixel format has an alpha component it will be returned as
+ * all 1 bits (fully opaque).
+ *
+ * If the pixel format bpp (color depth) is less than 32-bpp then the unused
+ * upper bits of the return value can safely be ignored (e.g., with a 16-bpp
+ * format the return value can be assigned to a Uint16, and similarly a Uint8
+ * for an 8-bpp format).
+ *
+ * \param format an SDL_PixelFormat structure describing the pixel format
+ * \param r the red component of the pixel in the range 0-255
+ * \param g the green component of the pixel in the range 0-255
+ * \param b the blue component of the pixel in the range 0-255
+ * \returns a pixel value
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetRGB
+ * \sa SDL_GetRGBA
+ * \sa SDL_MapRGBA
  */
 extern DECLSPEC Uint32 SDLCALL SDL_MapRGB(const SDL_PixelFormat * format,
                                           Uint8 r, Uint8 g, Uint8 b);
 
 /**
- *  \brief Maps an RGBA quadruple to a pixel value for a given pixel format.
+ * Map an RGBA quadruple to a pixel value for a given pixel format.
  *
- *  \sa SDL_MapRGB
+ * This function maps the RGBA color value to the specified pixel format and
+ * returns the pixel value best approximating the given RGBA color value for
+ * the given pixel format.
+ *
+ * If the specified pixel format has no alpha component the alpha value will
+ * be ignored (as it will be in formats with a palette).
+ *
+ * If the format has a palette (8-bit) the index of the closest matching color
+ * in the palette will be returned.
+ *
+ * If the pixel format bpp (color depth) is less than 32-bpp then the unused
+ * upper bits of the return value can safely be ignored (e.g., with a 16-bpp
+ * format the return value can be assigned to a Uint16, and similarly a Uint8
+ * for an 8-bpp format).
+ *
+ * \param format an SDL_PixelFormat structure describing the format of the
+ *               pixel
+ * \param r the red component of the pixel in the range 0-255
+ * \param g the green component of the pixel in the range 0-255
+ * \param b the blue component of the pixel in the range 0-255
+ * \param a the alpha component of the pixel in the range 0-255
+ * \returns a pixel value
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetRGB
+ * \sa SDL_GetRGBA
+ * \sa SDL_MapRGB
  */
 extern DECLSPEC Uint32 SDLCALL SDL_MapRGBA(const SDL_PixelFormat * format,
                                            Uint8 r, Uint8 g, Uint8 b,
                                            Uint8 a);
 
 /**
- *  \brief Get the RGB components from a pixel of the specified format.
+ * Get RGB values from a pixel in the specified format.
  *
- *  \sa SDL_GetRGBA
+ * This function uses the entire 8-bit [0..255] range when converting color
+ * components from pixel formats with less than 8-bits per RGB component
+ * (e.g., a completely white pixel in 16-bit RGB565 format would return [0xff,
+ * 0xff, 0xff] not [0xf8, 0xfc, 0xf8]).
+ *
+ * \param pixel a pixel value
+ * \param format an SDL_PixelFormat structure describing the format of the
+ *               pixel
+ * \param r a pointer filled in with the red component
+ * \param g a pointer filled in with the green component
+ * \param b a pointer filled in with the blue component
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetRGBA
+ * \sa SDL_MapRGB
+ * \sa SDL_MapRGBA
  */
 extern DECLSPEC void SDLCALL SDL_GetRGB(Uint32 pixel,
                                         const SDL_PixelFormat * format,
                                         Uint8 * r, Uint8 * g, Uint8 * b);
 
 /**
- *  \brief Get the RGBA components from a pixel of the specified format.
+ * Get RGBA values from a pixel in the specified format.
  *
- *  \sa SDL_GetRGB
+ * This function uses the entire 8-bit [0..255] range when converting color
+ * components from pixel formats with less than 8-bits per RGB component
+ * (e.g., a completely white pixel in 16-bit RGB565 format would return [0xff,
+ * 0xff, 0xff] not [0xf8, 0xfc, 0xf8]).
+ *
+ * If the surface has no alpha component, the alpha will be returned as 0xff
+ * (100% opaque).
+ *
+ * \param pixel a pixel value
+ * \param format an SDL_PixelFormat structure describing the format of the
+ *               pixel
+ * \param r a pointer filled in with the red component
+ * \param g a pointer filled in with the green component
+ * \param b a pointer filled in with the blue component
+ * \param a a pointer filled in with the alpha component
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetRGB
+ * \sa SDL_MapRGB
+ * \sa SDL_MapRGBA
  */
 extern DECLSPEC void SDLCALL SDL_GetRGBA(Uint32 pixel,
                                          const SDL_PixelFormat * format,
@@ -463,7 +621,14 @@ extern DECLSPEC void SDLCALL SDL_GetRGBA(Uint32 pixel,
                                          Uint8 * a);
 
 /**
- *  \brief Calculate a 256 entry gamma ramp for a gamma value.
+ * Calculate a 256 entry gamma ramp for a gamma value.
+ *
+ * \param gamma a gamma value where 0.0 is black and 1.0 is identity
+ * \param ramp an array of 256 values filled in with the gamma ramp
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_SetWindowGammaRamp
  */
 extern DECLSPEC void SDLCALL SDL_CalculateGammaRamp(float gamma, Uint16 * ramp);
 
diff --git a/Engine/lib/sdl/include/SDL_platform.h b/Engine/lib/sdl/include/SDL_platform.h
index 716655792..79b8b6f45 100644
--- a/Engine/lib/sdl/include/SDL_platform.h
+++ b/Engine/lib/sdl/include/SDL_platform.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -70,6 +70,27 @@
 /* lets us know what version of Mac OS X we're compiling on */
 #include "AvailabilityMacros.h"
 #include "TargetConditionals.h"
+
+/* Fix building with older SDKs that don't define these
+   See this for more information:
+   https://stackoverflow.com/questions/12132933/preprocessor-macro-for-os-x-targets
+*/
+#ifndef TARGET_OS_MACCATALYST
+#define TARGET_OS_MACCATALYST 0
+#endif
+#ifndef TARGET_OS_IOS
+#define TARGET_OS_IOS 0
+#endif
+#ifndef TARGET_OS_IPHONE
+#define TARGET_OS_IPHONE 0
+#endif
+#ifndef TARGET_OS_TV
+#define TARGET_OS_TV 0
+#endif
+#ifndef TARGET_OS_SIMULATOR
+#define TARGET_OS_SIMULATOR 0
+#endif
+
 #if TARGET_OS_TV
 #undef __TVOS__
 #define __TVOS__ 1
@@ -175,6 +196,9 @@
 #define __SDL_NOGETPROCADDR__
 #endif
 
+#if defined(__vita__)
+#define __VITA__ 1
+#endif
 
 #include "begin_code.h"
 /* Set up for C function definitions, even when using C++ */
@@ -183,7 +207,20 @@ extern "C" {
 #endif
 
 /**
- *  \brief Gets the name of the platform.
+ * Get the name of the platform.
+ *
+ * Here are the names returned for some (but not all) supported platforms:
+ *
+ * - "Windows"
+ * - "Mac OS X"
+ * - "Linux"
+ * - "iOS"
+ * - "Android"
+ *
+ * \returns the name of the platform. If the correct platform name is not
+ *          available, returns a string beginning with the text "Unknown".
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC const char * SDLCALL SDL_GetPlatform (void);
 
diff --git a/Engine/lib/sdl/include/SDL_power.h b/Engine/lib/sdl/include/SDL_power.h
index 39884cc23..ecb3f4b02 100644
--- a/Engine/lib/sdl/include/SDL_power.h
+++ b/Engine/lib/sdl/include/SDL_power.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -37,7 +37,7 @@ extern "C" {
 #endif
 
 /**
- *  \brief The basic state for the system's power supply.
+ *  The basic state for the system's power supply.
  */
 typedef enum
 {
@@ -50,17 +50,30 @@ typedef enum
 
 
 /**
- *  \brief Get the current power supply details.
+ * Get the current power supply details.
  *
- *  \param secs Seconds of battery life left. You can pass a NULL here if
- *              you don't care. Will return -1 if we can't determine a
- *              value, or we're not running on a battery.
+ * You should never take a battery status as absolute truth. Batteries
+ * (especially failing batteries) are delicate hardware, and the values
+ * reported here are best estimates based on what that hardware reports. It's
+ * not uncommon for older batteries to lose stored power much faster than it
+ * reports, or completely drain when reporting it has 20 percent left, etc.
  *
- *  \param pct Percentage of battery life left, between 0 and 100. You can
- *             pass a NULL here if you don't care. Will return -1 if we
- *             can't determine a value, or we're not running on a battery.
+ * Battery status can change at any time; if you are concerned with power
+ * state, you should call this function frequently, and perhaps ignore changes
+ * until they seem to be stable for a few seconds.
  *
- *  \return The state of the battery (if any).
+ * It's possible a platform can only report battery percentage or time left
+ * but not both.
+ *
+ * \param secs seconds of battery life left, you can pass a NULL here if you
+ *             don't care, will return -1 if we can't determine a value, or
+ *             we're not running on a battery
+ * \param pct percentage of battery life left, between 0 and 100, you can pass
+ *            a NULL here if you don't care, will return -1 if we can't
+ *            determine a value, or we're not running on a battery
+ * \returns an SDL_PowerState enum representing the current battery state.
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC SDL_PowerState SDLCALL SDL_GetPowerInfo(int *secs, int *pct);
 
diff --git a/Engine/lib/sdl/include/SDL_quit.h b/Engine/lib/sdl/include/SDL_quit.h
index b2bd5da50..4090f7f19 100644
--- a/Engine/lib/sdl/include/SDL_quit.h
+++ b/Engine/lib/sdl/include/SDL_quit.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/include/SDL_rect.h b/Engine/lib/sdl/include/SDL_rect.h
index 47f0d2078..55a6473f2 100644
--- a/Engine/lib/sdl/include/SDL_rect.h
+++ b/Engine/lib/sdl/include/SDL_rect.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -40,10 +40,10 @@ extern "C" {
 #endif
 
 /**
- *  \brief  The structure that defines a point (integer)
+ * The structure that defines a point (integer)
  *
- *  \sa SDL_EnclosePoints
- *  \sa SDL_PointInRect
+ * \sa SDL_EnclosePoints
+ * \sa SDL_PointInRect
  */
 typedef struct SDL_Point
 {
@@ -52,10 +52,15 @@ typedef struct SDL_Point
 } SDL_Point;
 
 /**
- *  \brief  The structure that defines a point (floating point)
+ * The structure that defines a point (floating point)
  *
- *  \sa SDL_EnclosePoints
- *  \sa SDL_PointInRect
+ * \sa SDL_FRectEmpty
+ * \sa SDL_FRectEquals
+ * \sa SDL_HasIntersectionF
+ * \sa SDL_IntersectFRect
+ * \sa SDL_UnionFRect
+ * \sa SDL_EncloseFPoints
+ * \sa SDL_PointInFRect
  */
 typedef struct SDL_FPoint
 {
@@ -65,14 +70,14 @@ typedef struct SDL_FPoint
 
 
 /**
- *  \brief A rectangle, with the origin at the upper left (integer).
+ * A rectangle, with the origin at the upper left (integer).
  *
- *  \sa SDL_RectEmpty
- *  \sa SDL_RectEquals
- *  \sa SDL_HasIntersection
- *  \sa SDL_IntersectRect
- *  \sa SDL_UnionRect
- *  \sa SDL_EnclosePoints
+ * \sa SDL_RectEmpty
+ * \sa SDL_RectEquals
+ * \sa SDL_HasIntersection
+ * \sa SDL_IntersectRect
+ * \sa SDL_UnionRect
+ * \sa SDL_EnclosePoints
  */
 typedef struct SDL_Rect
 {
@@ -82,7 +87,7 @@ typedef struct SDL_Rect
 
 
 /**
- *  \brief A rectangle, with the origin at the upper left (floating point).
+ * A rectangle, with the origin at the upper left (floating point).
  */
 typedef struct SDL_FRect
 {
@@ -94,7 +99,7 @@ typedef struct SDL_FRect
 
 
 /**
- *  \brief Returns true if point resides inside a rectangle.
+ * Returns true if point resides inside a rectangle.
  */
 SDL_FORCE_INLINE SDL_bool SDL_PointInRect(const SDL_Point *p, const SDL_Rect *r)
 {
@@ -103,7 +108,7 @@ SDL_FORCE_INLINE SDL_bool SDL_PointInRect(const SDL_Point *p, const SDL_Rect *r)
 }
 
 /**
- *  \brief Returns true if the rectangle has no area.
+ * Returns true if the rectangle has no area.
  */
 SDL_FORCE_INLINE SDL_bool SDL_RectEmpty(const SDL_Rect *r)
 {
@@ -111,7 +116,7 @@ SDL_FORCE_INLINE SDL_bool SDL_RectEmpty(const SDL_Rect *r)
 }
 
 /**
- *  \brief Returns true if the two rectangles are equal.
+ * Returns true if the two rectangles are equal.
  */
 SDL_FORCE_INLINE SDL_bool SDL_RectEquals(const SDL_Rect *a, const SDL_Rect *b)
 {
@@ -120,33 +125,70 @@ SDL_FORCE_INLINE SDL_bool SDL_RectEquals(const SDL_Rect *a, const SDL_Rect *b)
 }
 
 /**
- *  \brief Determine whether two rectangles intersect.
+ * Determine whether two rectangles intersect.
  *
- *  \return SDL_TRUE if there is an intersection, SDL_FALSE otherwise.
+ * If either pointer is NULL the function will return SDL_FALSE.
+ *
+ * \param A an SDL_Rect structure representing the first rectangle
+ * \param B an SDL_Rect structure representing the second rectangle
+ * \returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_IntersectRect
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_HasIntersection(const SDL_Rect * A,
                                                      const SDL_Rect * B);
 
 /**
- *  \brief Calculate the intersection of two rectangles.
+ * Calculate the intersection of two rectangles.
  *
- *  \return SDL_TRUE if there is an intersection, SDL_FALSE otherwise.
+ * If `result` is NULL then this function will return SDL_FALSE.
+ *
+ * \param A an SDL_Rect structure representing the first rectangle
+ * \param B an SDL_Rect structure representing the second rectangle
+ * \param result an SDL_Rect structure filled in with the intersection of
+ *               rectangles `A` and `B`
+ * \returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HasIntersection
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_IntersectRect(const SDL_Rect * A,
                                                    const SDL_Rect * B,
                                                    SDL_Rect * result);
 
 /**
- *  \brief Calculate the union of two rectangles.
+ * Calculate the union of two rectangles.
+ *
+ * \param A an SDL_Rect structure representing the first rectangle
+ * \param B an SDL_Rect structure representing the second rectangle
+ * \param result an SDL_Rect structure filled in with the union of rectangles
+ *               `A` and `B`
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC void SDLCALL SDL_UnionRect(const SDL_Rect * A,
                                            const SDL_Rect * B,
                                            SDL_Rect * result);
 
 /**
- *  \brief Calculate a minimal rectangle enclosing a set of points
+ * Calculate a minimal rectangle enclosing a set of points.
  *
- *  \return SDL_TRUE if any points were within the clipping rect
+ * If `clip` is not NULL then only points inside of the clipping rectangle are
+ * considered.
+ *
+ * \param points an array of SDL_Point structures representing points to be
+ *               enclosed
+ * \param count the number of structures in the `points` array
+ * \param clip an SDL_Rect used for clipping or NULL to enclose all points
+ * \param result an SDL_Rect structure filled in with the minimal enclosing
+ *               rectangle
+ * \returns SDL_TRUE if any points were enclosed or SDL_FALSE if all the
+ *          points were outside of the clipping rectangle.
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_EnclosePoints(const SDL_Point * points,
                                                    int count,
@@ -154,15 +196,153 @@ extern DECLSPEC SDL_bool SDLCALL SDL_EnclosePoints(const SDL_Point * points,
                                                    SDL_Rect * result);
 
 /**
- *  \brief Calculate the intersection of a rectangle and line segment.
+ * Calculate the intersection of a rectangle and line segment.
  *
- *  \return SDL_TRUE if there is an intersection, SDL_FALSE otherwise.
+ * This function is used to clip a line segment to a rectangle. A line segment
+ * contained entirely within the rectangle or that does not intersect will
+ * remain unchanged. A line segment that crosses the rectangle at either or
+ * both ends will be clipped to the boundary of the rectangle and the new
+ * coordinates saved in `X1`, `Y1`, `X2`, and/or `Y2` as necessary.
+ *
+ * \param rect an SDL_Rect structure representing the rectangle to intersect
+ * \param X1 a pointer to the starting X-coordinate of the line
+ * \param Y1 a pointer to the starting Y-coordinate of the line
+ * \param X2 a pointer to the ending X-coordinate of the line
+ * \param Y2 a pointer to the ending Y-coordinate of the line
+ * \returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise.
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_IntersectRectAndLine(const SDL_Rect *
                                                           rect, int *X1,
                                                           int *Y1, int *X2,
                                                           int *Y2);
 
+
+/* SDL_FRect versions... */
+
+/**
+ * Returns true if point resides inside a rectangle.
+ */
+SDL_FORCE_INLINE SDL_bool SDL_PointInFRect(const SDL_FPoint *p, const SDL_FRect *r)
+{
+    return ( (p->x >= r->x) && (p->x < (r->x + r->w)) &&
+             (p->y >= r->y) && (p->y < (r->y + r->h)) ) ? SDL_TRUE : SDL_FALSE;
+}
+
+/**
+ * Returns true if the rectangle has no area.
+ */
+SDL_FORCE_INLINE SDL_bool SDL_FRectEmpty(const SDL_FRect *r)
+{
+    return ((!r) || (r->w <= 0.0f) || (r->h <= 0.0f)) ? SDL_TRUE : SDL_FALSE;
+}
+
+/**
+ * Returns true if the two rectangles are equal.
+ */
+SDL_FORCE_INLINE SDL_bool SDL_FRectEquals(const SDL_FRect *a, const SDL_FRect *b)
+{
+    return (a && b && (a->x == b->x) && (a->y == b->y) &&
+            (a->w == b->w) && (a->h == b->h)) ? SDL_TRUE : SDL_FALSE;
+}
+
+/**
+ * Determine whether two rectangles intersect with float precision.
+ *
+ * If either pointer is NULL the function will return SDL_FALSE.
+ *
+ * \param A an SDL_FRect structure representing the first rectangle
+ * \param B an SDL_FRect structure representing the second rectangle
+ * \returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise.
+ *
+ * \since This function is available since SDL 2.0.22.
+ *
+ * \sa SDL_IntersectRect
+ */
+extern DECLSPEC SDL_bool SDLCALL SDL_HasIntersectionF(const SDL_FRect * A,
+                                                      const SDL_FRect * B);
+
+/**
+ * Calculate the intersection of two rectangles with float precision.
+ *
+ * If `result` is NULL then this function will return SDL_FALSE.
+ *
+ * \param A an SDL_FRect structure representing the first rectangle
+ * \param B an SDL_FRect structure representing the second rectangle
+ * \param result an SDL_FRect structure filled in with the intersection of
+ *               rectangles `A` and `B`
+ * \returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise.
+ *
+ * \since This function is available since SDL 2.0.22.
+ *
+ * \sa SDL_HasIntersectionF
+ */
+extern DECLSPEC SDL_bool SDLCALL SDL_IntersectFRect(const SDL_FRect * A,
+                                                    const SDL_FRect * B,
+                                                    SDL_FRect * result);
+
+/**
+ * Calculate the union of two rectangles with float precision.
+ *
+ * \param A an SDL_FRect structure representing the first rectangle
+ * \param B an SDL_FRect structure representing the second rectangle
+ * \param result an SDL_FRect structure filled in with the union of rectangles
+ *               `A` and `B`
+ *
+ * \since This function is available since SDL 2.0.22.
+ */
+extern DECLSPEC void SDLCALL SDL_UnionFRect(const SDL_FRect * A,
+                                            const SDL_FRect * B,
+                                            SDL_FRect * result);
+
+/**
+ * Calculate a minimal rectangle enclosing a set of points with float
+ * precision.
+ *
+ * If `clip` is not NULL then only points inside of the clipping rectangle are
+ * considered.
+ *
+ * \param points an array of SDL_FPoint structures representing points to be
+ *               enclosed
+ * \param count the number of structures in the `points` array
+ * \param clip an SDL_FRect used for clipping or NULL to enclose all points
+ * \param result an SDL_FRect structure filled in with the minimal enclosing
+ *               rectangle
+ * \returns SDL_TRUE if any points were enclosed or SDL_FALSE if all the
+ *          points were outside of the clipping rectangle.
+ *
+ * \since This function is available since SDL 2.0.22.
+ */
+extern DECLSPEC SDL_bool SDLCALL SDL_EncloseFPoints(const SDL_FPoint * points,
+                                                    int count,
+                                                    const SDL_FRect * clip,
+                                                    SDL_FRect * result);
+
+/**
+ * Calculate the intersection of a rectangle and line segment with float
+ * precision.
+ *
+ * This function is used to clip a line segment to a rectangle. A line segment
+ * contained entirely within the rectangle or that does not intersect will
+ * remain unchanged. A line segment that crosses the rectangle at either or
+ * both ends will be clipped to the boundary of the rectangle and the new
+ * coordinates saved in `X1`, `Y1`, `X2`, and/or `Y2` as necessary.
+ *
+ * \param rect an SDL_FRect structure representing the rectangle to intersect
+ * \param X1 a pointer to the starting X-coordinate of the line
+ * \param Y1 a pointer to the starting Y-coordinate of the line
+ * \param X2 a pointer to the ending X-coordinate of the line
+ * \param Y2 a pointer to the ending Y-coordinate of the line
+ * \returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise.
+ *
+ * \since This function is available since SDL 2.0.22.
+ */
+extern DECLSPEC SDL_bool SDLCALL SDL_IntersectFRectAndLine(const SDL_FRect *
+                                                           rect, float *X1,
+                                                           float *Y1, float *X2,
+                                                           float *Y2);
+
 /* Ends C function definitions when using C++ */
 #ifdef __cplusplus
 }
diff --git a/Engine/lib/sdl/include/SDL_render.h b/Engine/lib/sdl/include/SDL_render.h
index f26fb7e5f..88620336b 100644
--- a/Engine/lib/sdl/include/SDL_render.h
+++ b/Engine/lib/sdl/include/SDL_render.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -59,7 +59,7 @@ extern "C" {
 #endif
 
 /**
- *  \brief Flags used when creating a rendering context
+ * Flags used when creating a rendering context
  */
 typedef enum
 {
@@ -73,7 +73,7 @@ typedef enum
 } SDL_RendererFlags;
 
 /**
- *  \brief Information on the capabilities of a render driver or context.
+ * Information on the capabilities of a render driver or context.
  */
 typedef struct SDL_RendererInfo
 {
@@ -86,7 +86,17 @@ typedef struct SDL_RendererInfo
 } SDL_RendererInfo;
 
 /**
- *  \brief The scaling mode for a texture.
+ *  Vertex structure
+ */
+typedef struct SDL_Vertex
+{
+    SDL_FPoint position;        /**< Vertex position, in SDL_Renderer coordinates  */
+    SDL_Color  color;           /**< Vertex color */
+    SDL_FPoint tex_coord;       /**< Normalized texture coordinates, if needed */
+} SDL_Vertex;
+
+/**
+ * The scaling mode for a texture.
  */
 typedef enum
 {
@@ -96,7 +106,7 @@ typedef enum
 } SDL_ScaleMode;
 
 /**
- *  \brief The access pattern allowed for a texture.
+ * The access pattern allowed for a texture.
  */
 typedef enum
 {
@@ -106,7 +116,7 @@ typedef enum
 } SDL_TextureAccess;
 
 /**
- *  \brief The texture channel modulation used in SDL_RenderCopy().
+ * The texture channel modulation used in SDL_RenderCopy().
  */
 typedef enum
 {
@@ -116,7 +126,7 @@ typedef enum
 } SDL_TextureModulate;
 
 /**
- *  \brief Flip constants for SDL_RenderCopyEx
+ * Flip constants for SDL_RenderCopyEx
  */
 typedef enum
 {
@@ -126,58 +136,71 @@ typedef enum
 } SDL_RendererFlip;
 
 /**
- *  \brief A structure representing rendering state
+ * A structure representing rendering state
  */
 struct SDL_Renderer;
 typedef struct SDL_Renderer SDL_Renderer;
 
 /**
- *  \brief An efficient driver-specific representation of pixel data
+ * An efficient driver-specific representation of pixel data
  */
 struct SDL_Texture;
 typedef struct SDL_Texture SDL_Texture;
 
-
 /* Function prototypes */
 
 /**
- *  \brief Get the number of 2D rendering drivers available for the current
- *         display.
+ * Get the number of 2D rendering drivers available for the current display.
  *
- *  A render driver is a set of code that handles rendering and texture
- *  management on a particular display.  Normally there is only one, but
- *  some drivers may have several available with different capabilities.
+ * A render driver is a set of code that handles rendering and texture
+ * management on a particular display. Normally there is only one, but some
+ * drivers may have several available with different capabilities.
  *
- *  \sa SDL_GetRenderDriverInfo()
- *  \sa SDL_CreateRenderer()
+ * There may be none if SDL was compiled without render support.
+ *
+ * \returns a number >= 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateRenderer
+ * \sa SDL_GetRenderDriverInfo
  */
 extern DECLSPEC int SDLCALL SDL_GetNumRenderDrivers(void);
 
 /**
- *  \brief Get information about a specific 2D rendering driver for the current
- *         display.
+ * Get info about a specific 2D rendering driver for the current display.
  *
- *  \param index The index of the driver to query information about.
- *  \param info  A pointer to an SDL_RendererInfo struct to be filled with
- *               information on the rendering driver.
+ * \param index the index of the driver to query information about
+ * \param info an SDL_RendererInfo structure to be filled with information on
+ *             the rendering driver
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, -1 if the index was out of range.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_CreateRenderer()
+ * \sa SDL_CreateRenderer
+ * \sa SDL_GetNumRenderDrivers
  */
 extern DECLSPEC int SDLCALL SDL_GetRenderDriverInfo(int index,
                                                     SDL_RendererInfo * info);
 
 /**
- *  \brief Create a window and default renderer
+ * Create a window and default renderer.
  *
- *  \param width    The width of the window
- *  \param height   The height of the window
- *  \param window_flags The flags used to create the window
- *  \param window   A pointer filled with the window, or NULL on error
- *  \param renderer A pointer filled with the renderer, or NULL on error
+ * \param width the width of the window
+ * \param height the height of the window
+ * \param window_flags the flags used to create the window (see
+ *                     SDL_CreateWindow())
+ * \param window a pointer filled with the window, or NULL on error
+ * \param renderer a pointer filled with the renderer, or NULL on error
+ * \returns 0 on success, or -1 on error; call SDL_GetError() for more
+ *          information.
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateRenderer
+ * \sa SDL_CreateWindow
  */
 extern DECLSPEC int SDLCALL SDL_CreateWindowAndRenderer(
                                 int width, int height, Uint32 window_flags,
@@ -185,69 +208,116 @@ extern DECLSPEC int SDLCALL SDL_CreateWindowAndRenderer(
 
 
 /**
- *  \brief Create a 2D rendering context for a window.
+ * Create a 2D rendering context for a window.
  *
- *  \param window The window where rendering is displayed.
- *  \param index    The index of the rendering driver to initialize, or -1 to
- *                  initialize the first one supporting the requested flags.
- *  \param flags    ::SDL_RendererFlags.
+ * \param window the window where rendering is displayed
+ * \param index the index of the rendering driver to initialize, or -1 to
+ *              initialize the first one supporting the requested flags
+ * \param flags 0, or one or more SDL_RendererFlags OR'd together
+ * \returns a valid rendering context or NULL if there was an error; call
+ *          SDL_GetError() for more information.
  *
- *  \return A valid rendering context or NULL if there was an error.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_CreateSoftwareRenderer()
- *  \sa SDL_GetRendererInfo()
- *  \sa SDL_DestroyRenderer()
+ * \sa SDL_CreateSoftwareRenderer
+ * \sa SDL_DestroyRenderer
+ * \sa SDL_GetNumRenderDrivers
+ * \sa SDL_GetRendererInfo
  */
 extern DECLSPEC SDL_Renderer * SDLCALL SDL_CreateRenderer(SDL_Window * window,
                                                int index, Uint32 flags);
 
 /**
- *  \brief Create a 2D software rendering context for a surface.
+ * Create a 2D software rendering context for a surface.
  *
- *  \param surface The surface where rendering is done.
+ * Two other API which can be used to create SDL_Renderer:
+ * SDL_CreateRenderer() and SDL_CreateWindowAndRenderer(). These can _also_
+ * create a software renderer, but they are intended to be used with an
+ * SDL_Window as the final destination and not an SDL_Surface.
  *
- *  \return A valid rendering context or NULL if there was an error.
+ * \param surface the SDL_Surface structure representing the surface where
+ *                rendering is done
+ * \returns a valid rendering context or NULL if there was an error; call
+ *          SDL_GetError() for more information.
  *
- *  \sa SDL_CreateRenderer()
- *  \sa SDL_DestroyRenderer()
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateRenderer
+ * \sa SDL_CreateWindowRenderer
+ * \sa SDL_DestroyRenderer
  */
 extern DECLSPEC SDL_Renderer * SDLCALL SDL_CreateSoftwareRenderer(SDL_Surface * surface);
 
 /**
- *  \brief Get the renderer associated with a window.
+ * Get the renderer associated with a window.
+ *
+ * \param window the window to query
+ * \returns the rendering context on success or NULL on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateRenderer
  */
 extern DECLSPEC SDL_Renderer * SDLCALL SDL_GetRenderer(SDL_Window * window);
 
 /**
- *  \brief Get information about a rendering context.
+ * Get information about a rendering context.
+ *
+ * \param renderer the rendering context
+ * \param info an SDL_RendererInfo structure filled with information about the
+ *             current renderer
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateRenderer
  */
 extern DECLSPEC int SDLCALL SDL_GetRendererInfo(SDL_Renderer * renderer,
                                                 SDL_RendererInfo * info);
 
 /**
- *  \brief Get the output size in pixels of a rendering context.
+ * Get the output size in pixels of a rendering context.
+ *
+ * Due to high-dpi displays, you might end up with a rendering context that
+ * has more pixels than the window that contains it, so use this instead of
+ * SDL_GetWindowSize() to decide how much drawing area you have.
+ *
+ * \param renderer the rendering context
+ * \param w an int filled with the width
+ * \param h an int filled with the height
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetRenderer
  */
 extern DECLSPEC int SDLCALL SDL_GetRendererOutputSize(SDL_Renderer * renderer,
                                                       int *w, int *h);
 
 /**
- *  \brief Create a texture for a rendering context.
+ * Create a texture for a rendering context.
  *
- *  \param renderer The renderer.
- *  \param format The format of the texture.
- *  \param access One of the enumerated values in ::SDL_TextureAccess.
- *  \param w      The width of the texture in pixels.
- *  \param h      The height of the texture in pixels.
+ * You can set the texture scaling method by setting
+ * `SDL_HINT_RENDER_SCALE_QUALITY` before creating the texture.
  *
- *  \return The created texture is returned, or NULL if no rendering context was
- *          active,  the format was unsupported, or the width or height were out
- *          of range.
+ * \param renderer the rendering context
+ * \param format one of the enumerated values in SDL_PixelFormatEnum
+ * \param access one of the enumerated values in SDL_TextureAccess
+ * \param w the width of the texture in pixels
+ * \param h the height of the texture in pixels
+ * \returns a pointer to the created texture or NULL if no rendering context
+ *          was active, the format was unsupported, or the width or height
+ *          were out of range; call SDL_GetError() for more information.
  *
- *  \note The contents of the texture are not defined at creation.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_QueryTexture()
- *  \sa SDL_UpdateTexture()
- *  \sa SDL_DestroyTexture()
+ * \sa SDL_CreateTextureFromSurface
+ * \sa SDL_DestroyTexture
+ * \sa SDL_QueryTexture
+ * \sa SDL_UpdateTexture
  */
 extern DECLSPEC SDL_Texture * SDLCALL SDL_CreateTexture(SDL_Renderer * renderer,
                                                         Uint32 format,
@@ -255,194 +325,294 @@ extern DECLSPEC SDL_Texture * SDLCALL SDL_CreateTexture(SDL_Renderer * renderer,
                                                         int h);
 
 /**
- *  \brief Create a texture from an existing surface.
+ * Create a texture from an existing surface.
  *
- *  \param renderer The renderer.
- *  \param surface The surface containing pixel data used to fill the texture.
+ * The surface is not modified or freed by this function.
  *
- *  \return The created texture is returned, or NULL on error.
+ * The SDL_TextureAccess hint for the created texture is
+ * `SDL_TEXTUREACCESS_STATIC`.
  *
- *  \note The surface is not modified or freed by this function.
+ * The pixel format of the created texture may be different from the pixel
+ * format of the surface. Use SDL_QueryTexture() to query the pixel format of
+ * the texture.
  *
- *  \sa SDL_QueryTexture()
- *  \sa SDL_DestroyTexture()
+ * \param renderer the rendering context
+ * \param surface the SDL_Surface structure containing pixel data used to fill
+ *                the texture
+ * \returns the created texture or NULL on failure; call SDL_GetError() for
+ *          more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateTexture
+ * \sa SDL_DestroyTexture
+ * \sa SDL_QueryTexture
  */
 extern DECLSPEC SDL_Texture * SDLCALL SDL_CreateTextureFromSurface(SDL_Renderer * renderer, SDL_Surface * surface);
 
 /**
- *  \brief Query the attributes of a texture
+ * Query the attributes of a texture.
  *
- *  \param texture A texture to be queried.
- *  \param format  A pointer filled in with the raw format of the texture.  The
- *                 actual format may differ, but pixel transfers will use this
- *                 format.
- *  \param access  A pointer filled in with the actual access to the texture.
- *  \param w       A pointer filled in with the width of the texture in pixels.
- *  \param h       A pointer filled in with the height of the texture in pixels.
+ * \param texture the texture to query
+ * \param format a pointer filled in with the raw format of the texture; the
+ *               actual format may differ, but pixel transfers will use this
+ *               format (one of the SDL_PixelFormatEnum values). This argument
+ *               can be NULL if you don't need this information.
+ * \param access a pointer filled in with the actual access to the texture
+ *               (one of the SDL_TextureAccess values). This argument can be
+ *               NULL if you don't need this information.
+ * \param w a pointer filled in with the width of the texture in pixels. This
+ *          argument can be NULL if you don't need this information.
+ * \param h a pointer filled in with the height of the texture in pixels. This
+ *          argument can be NULL if you don't need this information.
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 if the texture is not valid.
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateTexture
  */
 extern DECLSPEC int SDLCALL SDL_QueryTexture(SDL_Texture * texture,
                                              Uint32 * format, int *access,
                                              int *w, int *h);
 
 /**
- *  \brief Set an additional color value used in render copy operations.
+ * Set an additional color value multiplied into render copy operations.
  *
- *  \param texture The texture to update.
- *  \param r       The red color value multiplied into copy operations.
- *  \param g       The green color value multiplied into copy operations.
- *  \param b       The blue color value multiplied into copy operations.
+ * When this texture is rendered, during the copy operation each source color
+ * channel is modulated by the appropriate color value according to the
+ * following formula:
  *
- *  \return 0 on success, or -1 if the texture is not valid or color modulation
- *          is not supported.
+ * `srcC = srcC * (color / 255)`
  *
- *  \sa SDL_GetTextureColorMod()
+ * Color modulation is not always supported by the renderer; it will return -1
+ * if color modulation is not supported.
+ *
+ * \param texture the texture to update
+ * \param r the red color value multiplied into copy operations
+ * \param g the green color value multiplied into copy operations
+ * \param b the blue color value multiplied into copy operations
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetTextureColorMod
+ * \sa SDL_SetTextureAlphaMod
  */
 extern DECLSPEC int SDLCALL SDL_SetTextureColorMod(SDL_Texture * texture,
                                                    Uint8 r, Uint8 g, Uint8 b);
 
 
 /**
- *  \brief Get the additional color value used in render copy operations.
+ * Get the additional color value multiplied into render copy operations.
  *
- *  \param texture The texture to query.
- *  \param r         A pointer filled in with the current red color value.
- *  \param g         A pointer filled in with the current green color value.
- *  \param b         A pointer filled in with the current blue color value.
+ * \param texture the texture to query
+ * \param r a pointer filled in with the current red color value
+ * \param g a pointer filled in with the current green color value
+ * \param b a pointer filled in with the current blue color value
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 if the texture is not valid.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_SetTextureColorMod()
+ * \sa SDL_GetTextureAlphaMod
+ * \sa SDL_SetTextureColorMod
  */
 extern DECLSPEC int SDLCALL SDL_GetTextureColorMod(SDL_Texture * texture,
                                                    Uint8 * r, Uint8 * g,
                                                    Uint8 * b);
 
 /**
- *  \brief Set an additional alpha value used in render copy operations.
+ * Set an additional alpha value multiplied into render copy operations.
  *
- *  \param texture The texture to update.
- *  \param alpha     The alpha value multiplied into copy operations.
+ * When this texture is rendered, during the copy operation the source alpha
+ * value is modulated by this alpha value according to the following formula:
  *
- *  \return 0 on success, or -1 if the texture is not valid or alpha modulation
- *          is not supported.
+ * `srcA = srcA * (alpha / 255)`
  *
- *  \sa SDL_GetTextureAlphaMod()
+ * Alpha modulation is not always supported by the renderer; it will return -1
+ * if alpha modulation is not supported.
+ *
+ * \param texture the texture to update
+ * \param alpha the source alpha value multiplied into copy operations
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetTextureAlphaMod
+ * \sa SDL_SetTextureColorMod
  */
 extern DECLSPEC int SDLCALL SDL_SetTextureAlphaMod(SDL_Texture * texture,
                                                    Uint8 alpha);
 
 /**
- *  \brief Get the additional alpha value used in render copy operations.
+ * Get the additional alpha value multiplied into render copy operations.
  *
- *  \param texture The texture to query.
- *  \param alpha     A pointer filled in with the current alpha value.
+ * \param texture the texture to query
+ * \param alpha a pointer filled in with the current alpha value
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 if the texture is not valid.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_SetTextureAlphaMod()
+ * \sa SDL_GetTextureColorMod
+ * \sa SDL_SetTextureAlphaMod
  */
 extern DECLSPEC int SDLCALL SDL_GetTextureAlphaMod(SDL_Texture * texture,
                                                    Uint8 * alpha);
 
 /**
- *  \brief Set the blend mode used for texture copy operations.
+ * Set the blend mode for a texture, used by SDL_RenderCopy().
  *
- *  \param texture The texture to update.
- *  \param blendMode ::SDL_BlendMode to use for texture blending.
+ * If the blend mode is not supported, the closest supported mode is chosen
+ * and this function returns -1.
  *
- *  \return 0 on success, or -1 if the texture is not valid or the blend mode is
- *          not supported.
+ * \param texture the texture to update
+ * \param blendMode the SDL_BlendMode to use for texture blending
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \note If the blend mode is not supported, the closest supported mode is
- *        chosen.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_GetTextureBlendMode()
+ * \sa SDL_GetTextureBlendMode
+ * \sa SDL_RenderCopy
  */
 extern DECLSPEC int SDLCALL SDL_SetTextureBlendMode(SDL_Texture * texture,
                                                     SDL_BlendMode blendMode);
 
 /**
- *  \brief Get the blend mode used for texture copy operations.
+ * Get the blend mode used for texture copy operations.
  *
- *  \param texture   The texture to query.
- *  \param blendMode A pointer filled in with the current blend mode.
+ * \param texture the texture to query
+ * \param blendMode a pointer filled in with the current SDL_BlendMode
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 if the texture is not valid.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_SetTextureBlendMode()
+ * \sa SDL_SetTextureBlendMode
  */
 extern DECLSPEC int SDLCALL SDL_GetTextureBlendMode(SDL_Texture * texture,
                                                     SDL_BlendMode *blendMode);
 
 /**
- *  \brief Set the scale mode used for texture scale operations.
+ * Set the scale mode used for texture scale operations.
  *
- *  \param texture The texture to update.
- *  \param scaleMode ::SDL_ScaleMode to use for texture scaling.
+ * If the scale mode is not supported, the closest supported mode is chosen.
  *
- *  \return 0 on success, or -1 if the texture is not valid.
+ * \param texture The texture to update.
+ * \param scaleMode the SDL_ScaleMode to use for texture scaling.
+ * \returns 0 on success, or -1 if the texture is not valid.
  *
- *  \note If the scale mode is not supported, the closest supported mode is
- *        chosen.
+ * \since This function is available since SDL 2.0.12.
  *
- *  \sa SDL_GetTextureScaleMode()
+ * \sa SDL_GetTextureScaleMode
  */
 extern DECLSPEC int SDLCALL SDL_SetTextureScaleMode(SDL_Texture * texture,
                                                     SDL_ScaleMode scaleMode);
 
 /**
- *  \brief Get the scale mode used for texture scale operations.
+ * Get the scale mode used for texture scale operations.
  *
- *  \param texture   The texture to query.
- *  \param scaleMode A pointer filled in with the current scale mode.
+ * \param texture the texture to query.
+ * \param scaleMode a pointer filled in with the current scale mode.
+ * \return 0 on success, or -1 if the texture is not valid.
  *
- *  \return 0 on success, or -1 if the texture is not valid.
+ * \since This function is available since SDL 2.0.12.
  *
- *  \sa SDL_SetTextureScaleMode()
+ * \sa SDL_SetTextureScaleMode
  */
 extern DECLSPEC int SDLCALL SDL_GetTextureScaleMode(SDL_Texture * texture,
                                                     SDL_ScaleMode *scaleMode);
 
 /**
- *  \brief Update the given texture rectangle with new pixel data.
+ * Associate a user-specified pointer with a texture.
  *
- *  \param texture   The texture to update
- *  \param rect      A pointer to the rectangle of pixels to update, or NULL to
- *                   update the entire texture.
- *  \param pixels    The raw pixel data in the format of the texture.
- *  \param pitch     The number of bytes in a row of pixel data, including padding between lines.
+ * \param texture the texture to update.
+ * \param userdata the pointer to associate with the texture.
+ * \returns 0 on success, or -1 if the texture is not valid.
  *
- *  The pixel data must be in the format of the texture. The pixel format can be
- *  queried with SDL_QueryTexture.
+ * \since This function is available since SDL 2.0.18.
  *
- *  \return 0 on success, or -1 if the texture is not valid.
+ * \sa SDL_GetTextureUserData
+ */
+extern DECLSPEC int SDLCALL SDL_SetTextureUserData(SDL_Texture * texture,
+                                                   void *userdata);
+
+/**
+ * Get the user-specified pointer associated with a texture
  *
- *  \note This is a fairly slow function.
+ * \param texture the texture to query.
+ * \return the pointer associated with the texture, or NULL if the texture is
+ *         not valid.
+ *
+ * \since This function is available since SDL 2.0.18.
+ *
+ * \sa SDL_SetTextureUserData
+ */
+extern DECLSPEC void * SDLCALL SDL_GetTextureUserData(SDL_Texture * texture);
+
+/**
+ * Update the given texture rectangle with new pixel data.
+ *
+ * The pixel data must be in the pixel format of the texture. Use
+ * SDL_QueryTexture() to query the pixel format of the texture.
+ *
+ * This is a fairly slow function, intended for use with static textures that
+ * do not change often.
+ *
+ * If the texture is intended to be updated often, it is preferred to create
+ * the texture as streaming and use the locking functions referenced below.
+ * While this function will work with streaming textures, for optimization
+ * reasons you may not get the pixels back if you lock the texture afterward.
+ *
+ * \param texture the texture to update
+ * \param rect an SDL_Rect structure representing the area to update, or NULL
+ *             to update the entire texture
+ * \param pixels the raw pixel data in the format of the texture
+ * \param pitch the number of bytes in a row of pixel data, including padding
+ *              between lines
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateTexture
+ * \sa SDL_LockTexture
+ * \sa SDL_UnlockTexture
  */
 extern DECLSPEC int SDLCALL SDL_UpdateTexture(SDL_Texture * texture,
                                               const SDL_Rect * rect,
                                               const void *pixels, int pitch);
 
 /**
- *  \brief Update a rectangle within a planar YV12 or IYUV texture with new pixel data.
+ * Update a rectangle within a planar YV12 or IYUV texture with new pixel
+ * data.
  *
- *  \param texture   The texture to update
- *  \param rect      A pointer to the rectangle of pixels to update, or NULL to
- *                   update the entire texture.
- *  \param Yplane    The raw pixel data for the Y plane.
- *  \param Ypitch    The number of bytes between rows of pixel data for the Y plane.
- *  \param Uplane    The raw pixel data for the U plane.
- *  \param Upitch    The number of bytes between rows of pixel data for the U plane.
- *  \param Vplane    The raw pixel data for the V plane.
- *  \param Vpitch    The number of bytes between rows of pixel data for the V plane.
+ * You can use SDL_UpdateTexture() as long as your pixel data is a contiguous
+ * block of Y and U/V planes in the proper order, but this function is
+ * available if your pixel data is not contiguous.
  *
- *  \return 0 on success, or -1 if the texture is not valid.
+ * \param texture the texture to update
+ * \param rect a pointer to the rectangle of pixels to update, or NULL to
+ *             update the entire texture
+ * \param Yplane the raw pixel data for the Y plane
+ * \param Ypitch the number of bytes between rows of pixel data for the Y
+ *               plane
+ * \param Uplane the raw pixel data for the U plane
+ * \param Upitch the number of bytes between rows of pixel data for the U
+ *               plane
+ * \param Vplane the raw pixel data for the V plane
+ * \param Vpitch the number of bytes between rows of pixel data for the V
+ *               plane
+ * \returns 0 on success or -1 if the texture is not valid; call
+ *          SDL_GetError() for more information.
  *
- *  \note You can use SDL_UpdateTexture() as long as your pixel data is
- *        a contiguous block of Y and U/V planes in the proper order, but
- *        this function is available if your pixel data is not contiguous.
+ * \since This function is available since SDL 2.0.1.
+ *
+ * \sa SDL_UpdateTexture
  */
 extern DECLSPEC int SDLCALL SDL_UpdateYUVTexture(SDL_Texture * texture,
                                                  const SDL_Rect * rect,
@@ -451,421 +621,771 @@ extern DECLSPEC int SDLCALL SDL_UpdateYUVTexture(SDL_Texture * texture,
                                                  const Uint8 *Vplane, int Vpitch);
 
 /**
- *  \brief Lock a portion of the texture for write-only pixel access.
+ * Update a rectangle within a planar NV12 or NV21 texture with new pixels.
  *
- *  \param texture   The texture to lock for access, which was created with
- *                   ::SDL_TEXTUREACCESS_STREAMING.
- *  \param rect      A pointer to the rectangle to lock for access. If the rect
- *                   is NULL, the entire texture will be locked.
- *  \param pixels    This is filled in with a pointer to the locked pixels,
- *                   appropriately offset by the locked area.
- *  \param pitch     This is filled in with the pitch of the locked pixels.
+ * You can use SDL_UpdateTexture() as long as your pixel data is a contiguous
+ * block of NV12/21 planes in the proper order, but this function is available
+ * if your pixel data is not contiguous.
  *
- *  \return 0 on success, or -1 if the texture is not valid or was not created with ::SDL_TEXTUREACCESS_STREAMING.
+ * \param texture the texture to update
+ * \param rect a pointer to the rectangle of pixels to update, or NULL to
+ *             update the entire texture.
+ * \param Yplane the raw pixel data for the Y plane.
+ * \param Ypitch the number of bytes between rows of pixel data for the Y
+ *               plane.
+ * \param UVplane the raw pixel data for the UV plane.
+ * \param UVpitch the number of bytes between rows of pixel data for the UV
+ *                plane.
+ * \return 0 on success, or -1 if the texture is not valid.
  *
- *  \sa SDL_UnlockTexture()
+ * \since This function is available since SDL 2.0.16.
+ */
+extern DECLSPEC int SDLCALL SDL_UpdateNVTexture(SDL_Texture * texture,
+                                                 const SDL_Rect * rect,
+                                                 const Uint8 *Yplane, int Ypitch,
+                                                 const Uint8 *UVplane, int UVpitch);
+
+/**
+ * Lock a portion of the texture for **write-only** pixel access.
+ *
+ * As an optimization, the pixels made available for editing don't necessarily
+ * contain the old texture data. This is a write-only operation, and if you
+ * need to keep a copy of the texture data you should do that at the
+ * application level.
+ *
+ * You must use SDL_UnlockTexture() to unlock the pixels and apply any
+ * changes.
+ *
+ * \param texture the texture to lock for access, which was created with
+ *                `SDL_TEXTUREACCESS_STREAMING`
+ * \param rect an SDL_Rect structure representing the area to lock for access;
+ *             NULL to lock the entire texture
+ * \param pixels this is filled in with a pointer to the locked pixels,
+ *               appropriately offset by the locked area
+ * \param pitch this is filled in with the pitch of the locked pixels; the
+ *              pitch is the length of one row in bytes
+ * \returns 0 on success or a negative error code if the texture is not valid
+ *          or was not created with `SDL_TEXTUREACCESS_STREAMING`; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_UnlockTexture
  */
 extern DECLSPEC int SDLCALL SDL_LockTexture(SDL_Texture * texture,
                                             const SDL_Rect * rect,
                                             void **pixels, int *pitch);
 
 /**
- *  \brief Lock a portion of the texture for write-only pixel access.
- *         Expose it as a SDL surface.
+ * Lock a portion of the texture for **write-only** pixel access, and expose
+ * it as a SDL surface.
  *
- *  \param texture   The texture to lock for access, which was created with
- *                   ::SDL_TEXTUREACCESS_STREAMING.
- *  \param rect      A pointer to the rectangle to lock for access. If the rect
- *                   is NULL, the entire texture will be locked.
- *  \param surface   This is filled in with a SDL surface representing the locked area
- *                   Surface is freed internally after calling SDL_UnlockTexture or SDL_DestroyTexture.
+ * Besides providing an SDL_Surface instead of raw pixel data, this function
+ * operates like SDL_LockTexture.
  *
- *  \return 0 on success, or -1 if the texture is not valid or was not created with ::SDL_TEXTUREACCESS_STREAMING.
+ * As an optimization, the pixels made available for editing don't necessarily
+ * contain the old texture data. This is a write-only operation, and if you
+ * need to keep a copy of the texture data you should do that at the
+ * application level.
  *
- *  \sa SDL_UnlockTexture()
+ * You must use SDL_UnlockTexture() to unlock the pixels and apply any
+ * changes.
+ *
+ * The returned surface is freed internally after calling SDL_UnlockTexture()
+ * or SDL_DestroyTexture(). The caller should not free it.
+ *
+ * \param texture the texture to lock for access, which was created with
+ *                `SDL_TEXTUREACCESS_STREAMING`
+ * \param rect a pointer to the rectangle to lock for access. If the rect is
+ *             NULL, the entire texture will be locked
+ * \param surface this is filled in with an SDL surface representing the
+ *                locked area
+ * \returns 0 on success, or -1 if the texture is not valid or was not created
+ *          with `SDL_TEXTUREACCESS_STREAMING`
+ *
+ * \since This function is available since SDL 2.0.12.
+ *
+ * \sa SDL_LockTexture
+ * \sa SDL_UnlockTexture
  */
 extern DECLSPEC int SDLCALL SDL_LockTextureToSurface(SDL_Texture *texture,
                                             const SDL_Rect *rect,
                                             SDL_Surface **surface);
 
 /**
- *  \brief Unlock a texture, uploading the changes to video memory, if needed.
- *         If SDL_LockTextureToSurface() was called for locking, the SDL surface is freed.
+ * Unlock a texture, uploading the changes to video memory, if needed.
  *
- *  \sa SDL_LockTexture()
- *  \sa SDL_LockTextureToSurface()
+ * **Warning**: Please note that SDL_LockTexture() is intended to be
+ * write-only; it will not guarantee the previous contents of the texture will
+ * be provided. You must fully initialize any area of a texture that you lock
+ * before unlocking it, as the pixels might otherwise be uninitialized memory.
+ *
+ * Which is to say: locking and immediately unlocking a texture can result in
+ * corrupted textures, depending on the renderer in use.
+ *
+ * \param texture a texture locked by SDL_LockTexture()
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_LockTexture
  */
 extern DECLSPEC void SDLCALL SDL_UnlockTexture(SDL_Texture * texture);
 
 /**
- * \brief Determines whether a window supports the use of render targets
+ * Determine whether a renderer supports the use of render targets.
  *
- * \param renderer The renderer that will be checked
+ * \param renderer the renderer that will be checked
+ * \returns SDL_TRUE if supported or SDL_FALSE if not.
  *
- * \return SDL_TRUE if supported, SDL_FALSE if not.
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_SetRenderTarget
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_RenderTargetSupported(SDL_Renderer *renderer);
 
 /**
- * \brief Set a texture as the current rendering target.
+ * Set a texture as the current rendering target.
  *
- * \param renderer The renderer.
- * \param texture The targeted texture, which must be created with the SDL_TEXTUREACCESS_TARGET flag, or NULL for the default render target
+ * Before using this function, you should check the
+ * `SDL_RENDERER_TARGETTEXTURE` bit in the flags of SDL_RendererInfo to see if
+ * render targets are supported.
  *
- * \return 0 on success, or -1 on error
+ * The default render target is the window for which the renderer was created.
+ * To stop rendering to a texture and render to the window again, call this
+ * function with a NULL `texture`.
  *
- *  \sa SDL_GetRenderTarget()
+ * \param renderer the rendering context
+ * \param texture the targeted texture, which must be created with the
+ *                `SDL_TEXTUREACCESS_TARGET` flag, or NULL to render to the
+ *                window instead of a texture.
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetRenderTarget
  */
 extern DECLSPEC int SDLCALL SDL_SetRenderTarget(SDL_Renderer *renderer,
                                                 SDL_Texture *texture);
 
 /**
- * \brief Get the current render target or NULL for the default render target.
+ * Get the current render target.
  *
- * \return The current render target
+ * The default render target is the window for which the renderer was created,
+ * and is reported a NULL here.
  *
- *  \sa SDL_SetRenderTarget()
+ * \param renderer the rendering context
+ * \returns the current render target or NULL for the default render target.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_SetRenderTarget
  */
 extern DECLSPEC SDL_Texture * SDLCALL SDL_GetRenderTarget(SDL_Renderer *renderer);
 
 /**
- *  \brief Set device independent resolution for rendering
+ * Set a device independent resolution for rendering.
  *
- *  \param renderer The renderer for which resolution should be set.
- *  \param w      The width of the logical resolution
- *  \param h      The height of the logical resolution
+ * This function uses the viewport and scaling functionality to allow a fixed
+ * logical resolution for rendering, regardless of the actual output
+ * resolution. If the actual output resolution doesn't have the same aspect
+ * ratio the output rendering will be centered within the output display.
  *
- *  This function uses the viewport and scaling functionality to allow a fixed logical
- *  resolution for rendering, regardless of the actual output resolution.  If the actual
- *  output resolution doesn't have the same aspect ratio the output rendering will be
- *  centered within the output display.
+ * If the output display is a window, mouse and touch events in the window
+ * will be filtered and scaled so they seem to arrive within the logical
+ * resolution. The SDL_HINT_MOUSE_RELATIVE_SCALING hint controls whether
+ * relative motion events are also scaled.
  *
- *  If the output display is a window, mouse events in the window will be filtered
- *  and scaled so they seem to arrive within the logical resolution.
+ * If this function results in scaling or subpixel drawing by the rendering
+ * backend, it will be handled using the appropriate quality hints.
  *
- *  \note If this function results in scaling or subpixel drawing by the
- *        rendering backend, it will be handled using the appropriate
- *        quality hints.
+ * \param renderer the renderer for which resolution should be set
+ * \param w the width of the logical resolution
+ * \param h the height of the logical resolution
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \sa SDL_RenderGetLogicalSize()
- *  \sa SDL_RenderSetScale()
- *  \sa SDL_RenderSetViewport()
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RenderGetLogicalSize
  */
 extern DECLSPEC int SDLCALL SDL_RenderSetLogicalSize(SDL_Renderer * renderer, int w, int h);
 
 /**
- *  \brief Get device independent resolution for rendering
+ * Get device independent resolution for rendering.
  *
- *  \param renderer The renderer from which resolution should be queried.
- *  \param w      A pointer filled with the width of the logical resolution
- *  \param h      A pointer filled with the height of the logical resolution
+ * This may return 0 for `w` and `h` if the SDL_Renderer has never had its
+ * logical size set by SDL_RenderSetLogicalSize() and never had a render
+ * target set.
  *
- *  \sa SDL_RenderSetLogicalSize()
+ * \param renderer a rendering context
+ * \param w an int to be filled with the width
+ * \param h an int to be filled with the height
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RenderSetLogicalSize
  */
 extern DECLSPEC void SDLCALL SDL_RenderGetLogicalSize(SDL_Renderer * renderer, int *w, int *h);
 
 /**
- *  \brief Set whether to force integer scales for resolution-independent rendering
+ * Set whether to force integer scales for resolution-independent rendering.
  *
- *  \param renderer The renderer for which integer scaling should be set.
- *  \param enable   Enable or disable integer scaling
+ * This function restricts the logical viewport to integer values - that is,
+ * when a resolution is between two multiples of a logical size, the viewport
+ * size is rounded down to the lower multiple.
  *
- *  This function restricts the logical viewport to integer values - that is, when
- *  a resolution is between two multiples of a logical size, the viewport size is
- *  rounded down to the lower multiple.
+ * \param renderer the renderer for which integer scaling should be set
+ * \param enable enable or disable the integer scaling for rendering
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \sa SDL_RenderSetLogicalSize()
+ * \since This function is available since SDL 2.0.5.
+ *
+ * \sa SDL_RenderGetIntegerScale
+ * \sa SDL_RenderSetLogicalSize
  */
 extern DECLSPEC int SDLCALL SDL_RenderSetIntegerScale(SDL_Renderer * renderer,
                                                       SDL_bool enable);
 
 /**
- *  \brief Get whether integer scales are forced for resolution-independent rendering
+ * Get whether integer scales are forced for resolution-independent rendering.
  *
- *  \param renderer The renderer from which integer scaling should be queried.
+ * \param renderer the renderer from which integer scaling should be queried
+ * \returns SDL_TRUE if integer scales are forced or SDL_FALSE if not and on
+ *          failure; call SDL_GetError() for more information.
  *
- *  \sa SDL_RenderSetIntegerScale()
+ * \since This function is available since SDL 2.0.5.
+ *
+ * \sa SDL_RenderSetIntegerScale
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_RenderGetIntegerScale(SDL_Renderer * renderer);
 
 /**
- *  \brief Set the drawing area for rendering on the current target.
+ * Set the drawing area for rendering on the current target.
  *
- *  \param renderer The renderer for which the drawing area should be set.
- *  \param rect The rectangle representing the drawing area, or NULL to set the viewport to the entire target.
+ * When the window is resized, the viewport is reset to fill the entire new
+ * window size.
  *
- *  The x,y of the viewport rect represents the origin for rendering.
+ * \param renderer the rendering context
+ * \param rect the SDL_Rect structure representing the drawing area, or NULL
+ *             to set the viewport to the entire target
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.0.
  *
- *  \note If the window associated with the renderer is resized, the viewport is automatically reset.
- *
- *  \sa SDL_RenderGetViewport()
- *  \sa SDL_RenderSetLogicalSize()
+ * \sa SDL_RenderGetViewport
  */
 extern DECLSPEC int SDLCALL SDL_RenderSetViewport(SDL_Renderer * renderer,
                                                   const SDL_Rect * rect);
 
 /**
- *  \brief Get the drawing area for the current target.
+ * Get the drawing area for the current target.
  *
- *  \sa SDL_RenderSetViewport()
+ * \param renderer the rendering context
+ * \param rect an SDL_Rect structure filled in with the current drawing area
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RenderSetViewport
  */
 extern DECLSPEC void SDLCALL SDL_RenderGetViewport(SDL_Renderer * renderer,
                                                    SDL_Rect * rect);
 
 /**
- *  \brief Set the clip rectangle for the current target.
+ * Set the clip rectangle for rendering on the specified target.
  *
- *  \param renderer The renderer for which clip rectangle should be set.
- *  \param rect   A pointer to the rectangle to set as the clip rectangle,
- *                relative to the viewport, or NULL to disable clipping.
+ * \param renderer the rendering context for which clip rectangle should be
+ *                 set
+ * \param rect an SDL_Rect structure representing the clip area, relative to
+ *             the viewport, or NULL to disable clipping
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_RenderGetClipRect()
+ * \sa SDL_RenderGetClipRect
+ * \sa SDL_RenderIsClipEnabled
  */
 extern DECLSPEC int SDLCALL SDL_RenderSetClipRect(SDL_Renderer * renderer,
                                                   const SDL_Rect * rect);
 
 /**
- *  \brief Get the clip rectangle for the current target.
+ * Get the clip rectangle for the current target.
  *
- *  \param renderer The renderer from which clip rectangle should be queried.
- *  \param rect   A pointer filled in with the current clip rectangle, or
- *                an empty rectangle if clipping is disabled.
+ * \param renderer the rendering context from which clip rectangle should be
+ *                 queried
+ * \param rect an SDL_Rect structure filled in with the current clipping area
+ *             or an empty rectangle if clipping is disabled
  *
- *  \sa SDL_RenderSetClipRect()
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RenderIsClipEnabled
+ * \sa SDL_RenderSetClipRect
  */
 extern DECLSPEC void SDLCALL SDL_RenderGetClipRect(SDL_Renderer * renderer,
                                                    SDL_Rect * rect);
 
 /**
- *  \brief Get whether clipping is enabled on the given renderer.
+ * Get whether clipping is enabled on the given renderer.
  *
- *  \param renderer The renderer from which clip state should be queried.
+ * \param renderer the renderer from which clip state should be queried
+ * \returns SDL_TRUE if clipping is enabled or SDL_FALSE if not; call
+ *          SDL_GetError() for more information.
  *
- *  \sa SDL_RenderGetClipRect()
+ * \since This function is available since SDL 2.0.4.
+ *
+ * \sa SDL_RenderGetClipRect
+ * \sa SDL_RenderSetClipRect
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_RenderIsClipEnabled(SDL_Renderer * renderer);
 
 
 /**
- *  \brief Set the drawing scale for rendering on the current target.
+ * Set the drawing scale for rendering on the current target.
  *
- *  \param renderer The renderer for which the drawing scale should be set.
- *  \param scaleX The horizontal scaling factor
- *  \param scaleY The vertical scaling factor
+ * The drawing coordinates are scaled by the x/y scaling factors before they
+ * are used by the renderer. This allows resolution independent drawing with a
+ * single coordinate system.
  *
- *  The drawing coordinates are scaled by the x/y scaling factors
- *  before they are used by the renderer.  This allows resolution
- *  independent drawing with a single coordinate system.
+ * If this results in scaling or subpixel drawing by the rendering backend, it
+ * will be handled using the appropriate quality hints. For best results use
+ * integer scaling factors.
  *
- *  \note If this results in scaling or subpixel drawing by the
- *        rendering backend, it will be handled using the appropriate
- *        quality hints.  For best results use integer scaling factors.
+ * \param renderer a rendering context
+ * \param scaleX the horizontal scaling factor
+ * \param scaleY the vertical scaling factor
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \sa SDL_RenderGetScale()
- *  \sa SDL_RenderSetLogicalSize()
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RenderGetScale
+ * \sa SDL_RenderSetLogicalSize
  */
 extern DECLSPEC int SDLCALL SDL_RenderSetScale(SDL_Renderer * renderer,
                                                float scaleX, float scaleY);
 
 /**
- *  \brief Get the drawing scale for the current target.
+ * Get the drawing scale for the current target.
  *
- *  \param renderer The renderer from which drawing scale should be queried.
- *  \param scaleX A pointer filled in with the horizontal scaling factor
- *  \param scaleY A pointer filled in with the vertical scaling factor
+ * \param renderer the renderer from which drawing scale should be queried
+ * \param scaleX a pointer filled in with the horizontal scaling factor
+ * \param scaleY a pointer filled in with the vertical scaling factor
  *
- *  \sa SDL_RenderSetScale()
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RenderSetScale
  */
 extern DECLSPEC void SDLCALL SDL_RenderGetScale(SDL_Renderer * renderer,
                                                float *scaleX, float *scaleY);
 
 /**
- *  \brief Set the color used for drawing operations (Rect, Line and Clear).
+ * Get logical coordinates of point in renderer when given real coordinates of
+ * point in window.
  *
- *  \param renderer The renderer for which drawing color should be set.
- *  \param r The red value used to draw on the rendering target.
- *  \param g The green value used to draw on the rendering target.
- *  \param b The blue value used to draw on the rendering target.
- *  \param a The alpha value used to draw on the rendering target, usually
- *           ::SDL_ALPHA_OPAQUE (255).
+ * Logical coordinates will differ from real coordinates when render is scaled
+ * and logical renderer size set
  *
- *  \return 0 on success, or -1 on error
+ * \param renderer the renderer from which the logical coordinates should be
+ *                 calcualted
+ * \param windowX the real X coordinate in the window
+ * \param windowY the real Y coordinate in the window
+ * \param logicalX the pointer filled with the logical x coordinate
+ * \param logicalY the pointer filled with the logical y coordinate
+ *
+ * \since This function is available since SDL 2.0.18.
+ *
+ * \sa SDL_RenderGetScale
+ * \sa SDL_RenderSetScale
+ * \sa SDL_RenderGetLogicalSize
+ * \sa SDL_RenderSetLogicalSize
+ */
+extern DECLSPEC void SDLCALL SDL_RenderWindowToLogical(SDL_Renderer * renderer, 
+                                                            int windowX, int windowY, 
+                                                            float *logicalX, float *logicalY);
+                                                  
+                                                  /**
+ * Get real coordinates of point in window when given logical coordinates of point in renderer.
+ * Logical coordinates will differ from real coordinates when render is scaled and logical renderer size set
+ * 
+ * \param renderer the renderer from which the window coordinates should be calculated
+ * \param logicalX the logical x coordinate
+ * \param logicalY the logical y coordinate
+ * \param windowX the pointer filled with the real X coordinate in the window
+ * \param windowY the pointer filled with the real Y coordinate in the window
+ 
+ *  
+ * \since This function is available since SDL 2.0.18.
+ * 
+ * \sa SDL_RenderGetScale
+ * \sa SDL_RenderSetScale
+ * \sa SDL_RenderGetLogicalSize
+ * \sa SDL_RenderSetLogicalSize
+ */
+extern DECLSPEC void SDLCALL SDL_RenderLogicalToWindow(SDL_Renderer * renderer, 
+                                                            float logicalX, float logicalY,
+                                                            int *windowX, int *windowY);
+
+/**
+ * Set the color used for drawing operations (Rect, Line and Clear).
+ *
+ * Set the color for drawing or filling rectangles, lines, and points, and for
+ * SDL_RenderClear().
+ *
+ * \param renderer the rendering context
+ * \param r the red value used to draw on the rendering target
+ * \param g the green value used to draw on the rendering target
+ * \param b the blue value used to draw on the rendering target
+ * \param a the alpha value used to draw on the rendering target; usually
+ *          `SDL_ALPHA_OPAQUE` (255). Use SDL_SetRenderDrawBlendMode to
+ *          specify how the alpha channel is used
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetRenderDrawColor
+ * \sa SDL_RenderClear
+ * \sa SDL_RenderDrawLine
+ * \sa SDL_RenderDrawLines
+ * \sa SDL_RenderDrawPoint
+ * \sa SDL_RenderDrawPoints
+ * \sa SDL_RenderDrawRect
+ * \sa SDL_RenderDrawRects
+ * \sa SDL_RenderFillRect
+ * \sa SDL_RenderFillRects
  */
 extern DECLSPEC int SDLCALL SDL_SetRenderDrawColor(SDL_Renderer * renderer,
                                            Uint8 r, Uint8 g, Uint8 b,
                                            Uint8 a);
 
 /**
- *  \brief Get the color used for drawing operations (Rect, Line and Clear).
+ * Get the color used for drawing operations (Rect, Line and Clear).
  *
- *  \param renderer The renderer from which drawing color should be queried.
- *  \param r A pointer to the red value used to draw on the rendering target.
- *  \param g A pointer to the green value used to draw on the rendering target.
- *  \param b A pointer to the blue value used to draw on the rendering target.
- *  \param a A pointer to the alpha value used to draw on the rendering target,
- *           usually ::SDL_ALPHA_OPAQUE (255).
+ * \param renderer the rendering context
+ * \param r a pointer filled in with the red value used to draw on the
+ *          rendering target
+ * \param g a pointer filled in with the green value used to draw on the
+ *          rendering target
+ * \param b a pointer filled in with the blue value used to draw on the
+ *          rendering target
+ * \param a a pointer filled in with the alpha value used to draw on the
+ *          rendering target; usually `SDL_ALPHA_OPAQUE` (255)
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_SetRenderDrawColor
  */
 extern DECLSPEC int SDLCALL SDL_GetRenderDrawColor(SDL_Renderer * renderer,
                                            Uint8 * r, Uint8 * g, Uint8 * b,
                                            Uint8 * a);
 
 /**
- *  \brief Set the blend mode used for drawing operations (Fill and Line).
+ * Set the blend mode used for drawing operations (Fill and Line).
  *
- *  \param renderer The renderer for which blend mode should be set.
- *  \param blendMode ::SDL_BlendMode to use for blending.
+ * If the blend mode is not supported, the closest supported mode is chosen.
  *
- *  \return 0 on success, or -1 on error
+ * \param renderer the rendering context
+ * \param blendMode the SDL_BlendMode to use for blending
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \note If the blend mode is not supported, the closest supported mode is
- *        chosen.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_GetRenderDrawBlendMode()
+ * \sa SDL_GetRenderDrawBlendMode
+ * \sa SDL_RenderDrawLine
+ * \sa SDL_RenderDrawLines
+ * \sa SDL_RenderDrawPoint
+ * \sa SDL_RenderDrawPoints
+ * \sa SDL_RenderDrawRect
+ * \sa SDL_RenderDrawRects
+ * \sa SDL_RenderFillRect
+ * \sa SDL_RenderFillRects
  */
 extern DECLSPEC int SDLCALL SDL_SetRenderDrawBlendMode(SDL_Renderer * renderer,
                                                        SDL_BlendMode blendMode);
 
 /**
- *  \brief Get the blend mode used for drawing operations.
+ * Get the blend mode used for drawing operations.
  *
- *  \param renderer The renderer from which blend mode should be queried.
- *  \param blendMode A pointer filled in with the current blend mode.
+ * \param renderer the rendering context
+ * \param blendMode a pointer filled in with the current SDL_BlendMode
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_SetRenderDrawBlendMode()
+ * \sa SDL_SetRenderDrawBlendMode
  */
 extern DECLSPEC int SDLCALL SDL_GetRenderDrawBlendMode(SDL_Renderer * renderer,
                                                        SDL_BlendMode *blendMode);
 
 /**
- *  \brief Clear the current rendering target with the drawing color
+ * Clear the current rendering target with the drawing color.
  *
- *  This function clears the entire rendering target, ignoring the viewport and
- *  the clip rectangle.
+ * This function clears the entire rendering target, ignoring the viewport and
+ * the clip rectangle.
  *
- *  \return 0 on success, or -1 on error
+ * \param renderer the rendering context
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_SetRenderDrawColor
  */
 extern DECLSPEC int SDLCALL SDL_RenderClear(SDL_Renderer * renderer);
 
 /**
- *  \brief Draw a point on the current rendering target.
+ * Draw a point on the current rendering target.
  *
- *  \param renderer The renderer which should draw a point.
- *  \param x The x coordinate of the point.
- *  \param y The y coordinate of the point.
+ * SDL_RenderDrawPoint() draws a single point. If you want to draw multiple,
+ * use SDL_RenderDrawPoints() instead.
  *
- *  \return 0 on success, or -1 on error
+ * \param renderer the rendering context
+ * \param x the x coordinate of the point
+ * \param y the y coordinate of the point
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RenderDrawLine
+ * \sa SDL_RenderDrawLines
+ * \sa SDL_RenderDrawPoints
+ * \sa SDL_RenderDrawRect
+ * \sa SDL_RenderDrawRects
+ * \sa SDL_RenderFillRect
+ * \sa SDL_RenderFillRects
+ * \sa SDL_RenderPresent
+ * \sa SDL_SetRenderDrawBlendMode
+ * \sa SDL_SetRenderDrawColor
  */
 extern DECLSPEC int SDLCALL SDL_RenderDrawPoint(SDL_Renderer * renderer,
                                                 int x, int y);
 
 /**
- *  \brief Draw multiple points on the current rendering target.
+ * Draw multiple points on the current rendering target.
  *
- *  \param renderer The renderer which should draw multiple points.
- *  \param points The points to draw
- *  \param count The number of points to draw
+ * \param renderer the rendering context
+ * \param points an array of SDL_Point structures that represent the points to
+ *               draw
+ * \param count the number of points to draw
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RenderDrawLine
+ * \sa SDL_RenderDrawLines
+ * \sa SDL_RenderDrawPoint
+ * \sa SDL_RenderDrawRect
+ * \sa SDL_RenderDrawRects
+ * \sa SDL_RenderFillRect
+ * \sa SDL_RenderFillRects
+ * \sa SDL_RenderPresent
+ * \sa SDL_SetRenderDrawBlendMode
+ * \sa SDL_SetRenderDrawColor
  */
 extern DECLSPEC int SDLCALL SDL_RenderDrawPoints(SDL_Renderer * renderer,
                                                  const SDL_Point * points,
                                                  int count);
 
 /**
- *  \brief Draw a line on the current rendering target.
+ * Draw a line on the current rendering target.
  *
- *  \param renderer The renderer which should draw a line.
- *  \param x1 The x coordinate of the start point.
- *  \param y1 The y coordinate of the start point.
- *  \param x2 The x coordinate of the end point.
- *  \param y2 The y coordinate of the end point.
+ * SDL_RenderDrawLine() draws the line to include both end points. If you want
+ * to draw multiple, connecting lines use SDL_RenderDrawLines() instead.
  *
- *  \return 0 on success, or -1 on error
+ * \param renderer the rendering context
+ * \param x1 the x coordinate of the start point
+ * \param y1 the y coordinate of the start point
+ * \param x2 the x coordinate of the end point
+ * \param y2 the y coordinate of the end point
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RenderDrawLines
+ * \sa SDL_RenderDrawPoint
+ * \sa SDL_RenderDrawPoints
+ * \sa SDL_RenderDrawRect
+ * \sa SDL_RenderDrawRects
+ * \sa SDL_RenderFillRect
+ * \sa SDL_RenderFillRects
+ * \sa SDL_RenderPresent
+ * \sa SDL_SetRenderDrawBlendMode
+ * \sa SDL_SetRenderDrawColor
  */
 extern DECLSPEC int SDLCALL SDL_RenderDrawLine(SDL_Renderer * renderer,
                                                int x1, int y1, int x2, int y2);
 
 /**
- *  \brief Draw a series of connected lines on the current rendering target.
+ * Draw a series of connected lines on the current rendering target.
  *
- *  \param renderer The renderer which should draw multiple lines.
- *  \param points The points along the lines
- *  \param count The number of points, drawing count-1 lines
+ * \param renderer the rendering context
+ * \param points an array of SDL_Point structures representing points along
+ *               the lines
+ * \param count the number of points, drawing count-1 lines
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RenderDrawLine
+ * \sa SDL_RenderDrawPoint
+ * \sa SDL_RenderDrawPoints
+ * \sa SDL_RenderDrawRect
+ * \sa SDL_RenderDrawRects
+ * \sa SDL_RenderFillRect
+ * \sa SDL_RenderFillRects
+ * \sa SDL_RenderPresent
+ * \sa SDL_SetRenderDrawBlendMode
+ * \sa SDL_SetRenderDrawColor
  */
 extern DECLSPEC int SDLCALL SDL_RenderDrawLines(SDL_Renderer * renderer,
                                                 const SDL_Point * points,
                                                 int count);
 
 /**
- *  \brief Draw a rectangle on the current rendering target.
+ * Draw a rectangle on the current rendering target.
  *
- *  \param renderer The renderer which should draw a rectangle.
- *  \param rect A pointer to the destination rectangle, or NULL to outline the entire rendering target.
+ * \param renderer the rendering context
+ * \param rect an SDL_Rect structure representing the rectangle to draw, or
+ *             NULL to outline the entire rendering target
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RenderDrawLine
+ * \sa SDL_RenderDrawLines
+ * \sa SDL_RenderDrawPoint
+ * \sa SDL_RenderDrawPoints
+ * \sa SDL_RenderDrawRects
+ * \sa SDL_RenderFillRect
+ * \sa SDL_RenderFillRects
+ * \sa SDL_RenderPresent
+ * \sa SDL_SetRenderDrawBlendMode
+ * \sa SDL_SetRenderDrawColor
  */
 extern DECLSPEC int SDLCALL SDL_RenderDrawRect(SDL_Renderer * renderer,
                                                const SDL_Rect * rect);
 
 /**
- *  \brief Draw some number of rectangles on the current rendering target.
+ * Draw some number of rectangles on the current rendering target.
  *
- *  \param renderer The renderer which should draw multiple rectangles.
- *  \param rects A pointer to an array of destination rectangles.
- *  \param count The number of rectangles.
+ * \param renderer the rendering context
+ * \param rects an array of SDL_Rect structures representing the rectangles to
+ *              be drawn
+ * \param count the number of rectangles
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RenderDrawLine
+ * \sa SDL_RenderDrawLines
+ * \sa SDL_RenderDrawPoint
+ * \sa SDL_RenderDrawPoints
+ * \sa SDL_RenderDrawRect
+ * \sa SDL_RenderFillRect
+ * \sa SDL_RenderFillRects
+ * \sa SDL_RenderPresent
+ * \sa SDL_SetRenderDrawBlendMode
+ * \sa SDL_SetRenderDrawColor
  */
 extern DECLSPEC int SDLCALL SDL_RenderDrawRects(SDL_Renderer * renderer,
                                                 const SDL_Rect * rects,
                                                 int count);
 
 /**
- *  \brief Fill a rectangle on the current rendering target with the drawing color.
+ * Fill a rectangle on the current rendering target with the drawing color.
  *
- *  \param renderer The renderer which should fill a rectangle.
- *  \param rect A pointer to the destination rectangle, or NULL for the entire
- *              rendering target.
+ * The current drawing color is set by SDL_SetRenderDrawColor(), and the
+ * color's alpha value is ignored unless blending is enabled with the
+ * appropriate call to SDL_SetRenderDrawBlendMode().
  *
- *  \return 0 on success, or -1 on error
+ * \param renderer the rendering context
+ * \param rect the SDL_Rect structure representing the rectangle to fill, or
+ *             NULL for the entire rendering target
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RenderDrawLine
+ * \sa SDL_RenderDrawLines
+ * \sa SDL_RenderDrawPoint
+ * \sa SDL_RenderDrawPoints
+ * \sa SDL_RenderDrawRect
+ * \sa SDL_RenderDrawRects
+ * \sa SDL_RenderFillRects
+ * \sa SDL_RenderPresent
+ * \sa SDL_SetRenderDrawBlendMode
+ * \sa SDL_SetRenderDrawColor
  */
 extern DECLSPEC int SDLCALL SDL_RenderFillRect(SDL_Renderer * renderer,
                                                const SDL_Rect * rect);
 
 /**
- *  \brief Fill some number of rectangles on the current rendering target with the drawing color.
+ * Fill some number of rectangles on the current rendering target with the
+ * drawing color.
  *
- *  \param renderer The renderer which should fill multiple rectangles.
- *  \param rects A pointer to an array of destination rectangles.
- *  \param count The number of rectangles.
+ * \param renderer the rendering context
+ * \param rects an array of SDL_Rect structures representing the rectangles to
+ *              be filled
+ * \param count the number of rectangles
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RenderDrawLine
+ * \sa SDL_RenderDrawLines
+ * \sa SDL_RenderDrawPoint
+ * \sa SDL_RenderDrawPoints
+ * \sa SDL_RenderDrawRect
+ * \sa SDL_RenderDrawRects
+ * \sa SDL_RenderFillRect
+ * \sa SDL_RenderPresent
  */
 extern DECLSPEC int SDLCALL SDL_RenderFillRects(SDL_Renderer * renderer,
                                                 const SDL_Rect * rects,
                                                 int count);
 
 /**
- *  \brief Copy a portion of the texture to the current rendering target.
+ * Copy a portion of the texture to the current rendering target.
  *
- *  \param renderer The renderer which should copy parts of a texture.
- *  \param texture The source texture.
- *  \param srcrect   A pointer to the source rectangle, or NULL for the entire
- *                   texture.
- *  \param dstrect   A pointer to the destination rectangle, or NULL for the
- *                   entire rendering target.
+ * The texture is blended with the destination based on its blend mode set
+ * with SDL_SetTextureBlendMode().
  *
- *  \return 0 on success, or -1 on error
+ * The texture color is affected based on its color modulation set by
+ * SDL_SetTextureColorMod().
+ *
+ * The texture alpha is affected based on its alpha modulation set by
+ * SDL_SetTextureAlphaMod().
+ *
+ * \param renderer the rendering context
+ * \param texture the source texture
+ * \param srcrect the source SDL_Rect structure or NULL for the entire texture
+ * \param dstrect the destination SDL_Rect structure or NULL for the entire
+ *                rendering target; the texture will be stretched to fill the
+ *                given rectangle
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RenderCopyEx
+ * \sa SDL_SetTextureAlphaMod
+ * \sa SDL_SetTextureBlendMode
+ * \sa SDL_SetTextureColorMod
  */
 extern DECLSPEC int SDLCALL SDL_RenderCopy(SDL_Renderer * renderer,
                                            SDL_Texture * texture,
@@ -873,19 +1393,43 @@ extern DECLSPEC int SDLCALL SDL_RenderCopy(SDL_Renderer * renderer,
                                            const SDL_Rect * dstrect);
 
 /**
- *  \brief Copy a portion of the source texture to the current rendering target, rotating it by angle around the given center
+ * Copy a portion of the texture to the current rendering, with optional
+ * rotation and flipping.
  *
- *  \param renderer The renderer which should copy parts of a texture.
- *  \param texture The source texture.
- *  \param srcrect   A pointer to the source rectangle, or NULL for the entire
- *                   texture.
- *  \param dstrect   A pointer to the destination rectangle, or NULL for the
- *                   entire rendering target.
- *  \param angle    An angle in degrees that indicates the rotation that will be applied to dstrect, rotating it in a clockwise direction
- *  \param center   A pointer to a point indicating the point around which dstrect will be rotated (if NULL, rotation will be done around dstrect.w/2, dstrect.h/2).
- *  \param flip     An SDL_RendererFlip value stating which flipping actions should be performed on the texture
+ * Copy a portion of the texture to the current rendering target, optionally
+ * rotating it by angle around the given center and also flipping it
+ * top-bottom and/or left-right.
  *
- *  \return 0 on success, or -1 on error
+ * The texture is blended with the destination based on its blend mode set
+ * with SDL_SetTextureBlendMode().
+ *
+ * The texture color is affected based on its color modulation set by
+ * SDL_SetTextureColorMod().
+ *
+ * The texture alpha is affected based on its alpha modulation set by
+ * SDL_SetTextureAlphaMod().
+ *
+ * \param renderer the rendering context
+ * \param texture the source texture
+ * \param srcrect the source SDL_Rect structure or NULL for the entire texture
+ * \param dstrect the destination SDL_Rect structure or NULL for the entire
+ *                rendering target
+ * \param angle an angle in degrees that indicates the rotation that will be
+ *              applied to dstrect, rotating it in a clockwise direction
+ * \param center a pointer to a point indicating the point around which
+ *               dstrect will be rotated (if NULL, rotation will be done
+ *               around `dstrect.w / 2`, `dstrect.h / 2`)
+ * \param flip a SDL_RendererFlip value stating which flipping actions should
+ *             be performed on the texture
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RenderCopy
+ * \sa SDL_SetTextureAlphaMod
+ * \sa SDL_SetTextureBlendMode
+ * \sa SDL_SetTextureColorMod
  */
 extern DECLSPEC int SDLCALL SDL_RenderCopyEx(SDL_Renderer * renderer,
                                            SDL_Texture * texture,
@@ -897,117 +1441,132 @@ extern DECLSPEC int SDLCALL SDL_RenderCopyEx(SDL_Renderer * renderer,
 
 
 /**
- *  \brief Draw a point on the current rendering target.
+ * Draw a point on the current rendering target at subpixel precision.
  *
- *  \param renderer The renderer which should draw a point.
- *  \param x The x coordinate of the point.
- *  \param y The y coordinate of the point.
+ * \param renderer The renderer which should draw a point.
+ * \param x The x coordinate of the point.
+ * \param y The y coordinate of the point.
+ * \return 0 on success, or -1 on error
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.10.
  */
 extern DECLSPEC int SDLCALL SDL_RenderDrawPointF(SDL_Renderer * renderer,
                                                  float x, float y);
 
 /**
- *  \brief Draw multiple points on the current rendering target.
+ * Draw multiple points on the current rendering target at subpixel precision.
  *
- *  \param renderer The renderer which should draw multiple points.
- *  \param points The points to draw
- *  \param count The number of points to draw
+ * \param renderer The renderer which should draw multiple points.
+ * \param points The points to draw
+ * \param count The number of points to draw
+ * \return 0 on success, or -1 on error
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.10.
  */
 extern DECLSPEC int SDLCALL SDL_RenderDrawPointsF(SDL_Renderer * renderer,
                                                   const SDL_FPoint * points,
                                                   int count);
 
 /**
- *  \brief Draw a line on the current rendering target.
+ * Draw a line on the current rendering target at subpixel precision.
  *
- *  \param renderer The renderer which should draw a line.
- *  \param x1 The x coordinate of the start point.
- *  \param y1 The y coordinate of the start point.
- *  \param x2 The x coordinate of the end point.
- *  \param y2 The y coordinate of the end point.
+ * \param renderer The renderer which should draw a line.
+ * \param x1 The x coordinate of the start point.
+ * \param y1 The y coordinate of the start point.
+ * \param x2 The x coordinate of the end point.
+ * \param y2 The y coordinate of the end point.
+ * \return 0 on success, or -1 on error
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.10.
  */
 extern DECLSPEC int SDLCALL SDL_RenderDrawLineF(SDL_Renderer * renderer,
                                                 float x1, float y1, float x2, float y2);
 
 /**
- *  \brief Draw a series of connected lines on the current rendering target.
+ * Draw a series of connected lines on the current rendering target at
+ * subpixel precision.
  *
- *  \param renderer The renderer which should draw multiple lines.
- *  \param points The points along the lines
- *  \param count The number of points, drawing count-1 lines
+ * \param renderer The renderer which should draw multiple lines.
+ * \param points The points along the lines
+ * \param count The number of points, drawing count-1 lines
+ * \return 0 on success, or -1 on error
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.10.
  */
 extern DECLSPEC int SDLCALL SDL_RenderDrawLinesF(SDL_Renderer * renderer,
-                                                const SDL_FPoint * points,
-                                                int count);
+                                                 const SDL_FPoint * points,
+                                                 int count);
 
 /**
- *  \brief Draw a rectangle on the current rendering target.
+ * Draw a rectangle on the current rendering target at subpixel precision.
  *
- *  \param renderer The renderer which should draw a rectangle.
- *  \param rect A pointer to the destination rectangle, or NULL to outline the entire rendering target.
+ * \param renderer The renderer which should draw a rectangle.
+ * \param rect A pointer to the destination rectangle, or NULL to outline the
+ *             entire rendering target.
+ * \return 0 on success, or -1 on error
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.10.
  */
 extern DECLSPEC int SDLCALL SDL_RenderDrawRectF(SDL_Renderer * renderer,
-                                               const SDL_FRect * rect);
+                                                const SDL_FRect * rect);
 
 /**
- *  \brief Draw some number of rectangles on the current rendering target.
+ * Draw some number of rectangles on the current rendering target at subpixel
+ * precision.
  *
- *  \param renderer The renderer which should draw multiple rectangles.
- *  \param rects A pointer to an array of destination rectangles.
- *  \param count The number of rectangles.
+ * \param renderer The renderer which should draw multiple rectangles.
+ * \param rects A pointer to an array of destination rectangles.
+ * \param count The number of rectangles.
+ * \return 0 on success, or -1 on error
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.10.
  */
 extern DECLSPEC int SDLCALL SDL_RenderDrawRectsF(SDL_Renderer * renderer,
                                                  const SDL_FRect * rects,
                                                  int count);
 
 /**
- *  \brief Fill a rectangle on the current rendering target with the drawing color.
+ * Fill a rectangle on the current rendering target with the drawing color at
+ * subpixel precision.
  *
- *  \param renderer The renderer which should fill a rectangle.
- *  \param rect A pointer to the destination rectangle, or NULL for the entire
- *              rendering target.
+ * \param renderer The renderer which should fill a rectangle.
+ * \param rect A pointer to the destination rectangle, or NULL for the entire
+ *             rendering target.
+ * \return 0 on success, or -1 on error
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.10.
  */
 extern DECLSPEC int SDLCALL SDL_RenderFillRectF(SDL_Renderer * renderer,
                                                 const SDL_FRect * rect);
 
 /**
- *  \brief Fill some number of rectangles on the current rendering target with the drawing color.
+ * Fill some number of rectangles on the current rendering target with the
+ * drawing color at subpixel precision.
  *
- *  \param renderer The renderer which should fill multiple rectangles.
- *  \param rects A pointer to an array of destination rectangles.
- *  \param count The number of rectangles.
+ * \param renderer The renderer which should fill multiple rectangles.
+ * \param rects A pointer to an array of destination rectangles.
+ * \param count The number of rectangles.
+ * \return 0 on success, or -1 on error
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.10.
  */
 extern DECLSPEC int SDLCALL SDL_RenderFillRectsF(SDL_Renderer * renderer,
                                                  const SDL_FRect * rects,
                                                  int count);
 
 /**
- *  \brief Copy a portion of the texture to the current rendering target.
+ * Copy a portion of the texture to the current rendering target at subpixel
+ * precision.
  *
- *  \param renderer The renderer which should copy parts of a texture.
- *  \param texture The source texture.
- *  \param srcrect   A pointer to the source rectangle, or NULL for the entire
- *                   texture.
- *  \param dstrect   A pointer to the destination rectangle, or NULL for the
- *                   entire rendering target.
+ * \param renderer The renderer which should copy parts of a texture.
+ * \param texture The source texture.
+ * \param srcrect A pointer to the source rectangle, or NULL for the entire
+ *                texture.
+ * \param dstrect A pointer to the destination rectangle, or NULL for the
+ *                entire rendering target.
+ * \return 0 on success, or -1 on error
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.10.
  */
 extern DECLSPEC int SDLCALL SDL_RenderCopyF(SDL_Renderer * renderer,
                                             SDL_Texture * texture,
@@ -1015,19 +1574,25 @@ extern DECLSPEC int SDLCALL SDL_RenderCopyF(SDL_Renderer * renderer,
                                             const SDL_FRect * dstrect);
 
 /**
- *  \brief Copy a portion of the source texture to the current rendering target, rotating it by angle around the given center
+ * Copy a portion of the source texture to the current rendering target, with
+ * rotation and flipping, at subpixel precision.
  *
- *  \param renderer The renderer which should copy parts of a texture.
- *  \param texture The source texture.
- *  \param srcrect   A pointer to the source rectangle, or NULL for the entire
- *                   texture.
- *  \param dstrect   A pointer to the destination rectangle, or NULL for the
- *                   entire rendering target.
- *  \param angle    An angle in degrees that indicates the rotation that will be applied to dstrect, rotating it in a clockwise direction
- *  \param center   A pointer to a point indicating the point around which dstrect will be rotated (if NULL, rotation will be done around dstrect.w/2, dstrect.h/2).
- *  \param flip     An SDL_RendererFlip value stating which flipping actions should be performed on the texture
+ * \param renderer The renderer which should copy parts of a texture.
+ * \param texture The source texture.
+ * \param srcrect A pointer to the source rectangle, or NULL for the entire
+ *                texture.
+ * \param dstrect A pointer to the destination rectangle, or NULL for the
+ *                entire rendering target.
+ * \param angle An angle in degrees that indicates the rotation that will be
+ *              applied to dstrect, rotating it in a clockwise direction
+ * \param center A pointer to a point indicating the point around which
+ *               dstrect will be rotated (if NULL, rotation will be done
+ *               around dstrect.w/2, dstrect.h/2).
+ * \param flip An SDL_RendererFlip value stating which flipping actions should
+ *             be performed on the texture
+ * \return 0 on success, or -1 on error
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.10.
  */
 extern DECLSPEC int SDLCALL SDL_RenderCopyExF(SDL_Renderer * renderer,
                                             SDL_Texture * texture,
@@ -1038,19 +1603,86 @@ extern DECLSPEC int SDLCALL SDL_RenderCopyExF(SDL_Renderer * renderer,
                                             const SDL_RendererFlip flip);
 
 /**
- *  \brief Read pixels from the current rendering target.
+ * Render a list of triangles, optionally using a texture and indices into the
+ * vertex array Color and alpha modulation is done per vertex
+ * (SDL_SetTextureColorMod and SDL_SetTextureAlphaMod are ignored).
  *
- *  \param renderer The renderer from which pixels should be read.
- *  \param rect   A pointer to the rectangle to read, or NULL for the entire
- *                render target.
- *  \param format The desired format of the pixel data, or 0 to use the format
- *                of the rendering target
- *  \param pixels A pointer to be filled in with the pixel data
- *  \param pitch  The pitch of the pixels parameter.
+ * \param texture (optional) The SDL texture to use.
+ * \param vertices Vertices.
+ * \param num_vertices Number of vertices.
+ * \param indices (optional) An array of integer indices into the 'vertices'
+ *                array, if NULL all vertices will be rendered in sequential
+ *                order.
+ * \param num_indices Number of indices.
+ * \return 0 on success, or -1 if the operation is not supported
  *
- *  \return 0 on success, or -1 if pixel reading is not supported.
+ * \since This function is available since SDL 2.0.18.
  *
- *  \warning This is a very slow operation, and should not be used frequently.
+ * \sa SDL_RenderGeometryRaw
+ * \sa SDL_Vertex
+ */
+extern DECLSPEC int SDLCALL SDL_RenderGeometry(SDL_Renderer *renderer,
+                                               SDL_Texture *texture,
+                                               const SDL_Vertex *vertices, int num_vertices,
+                                               const int *indices, int num_indices);
+
+/**
+ * Render a list of triangles, optionally using a texture and indices into the
+ * vertex arrays Color and alpha modulation is done per vertex
+ * (SDL_SetTextureColorMod and SDL_SetTextureAlphaMod are ignored).
+ *
+ * \param texture (optional) The SDL texture to use.
+ * \param xy Vertex positions
+ * \param xy_stride Byte size to move from one element to the next element
+ * \param color Vertex colors (as SDL_Color)
+ * \param color_stride Byte size to move from one element to the next element
+ * \param uv Vertex normalized texture coordinates
+ * \param uv_stride Byte size to move from one element to the next element
+ * \param num_vertices Number of vertices.
+ * \param indices (optional) An array of indices into the 'vertices' arrays,
+ *                if NULL all vertices will be rendered in sequential order.
+ * \param num_indices Number of indices.
+ * \param size_indices Index size: 1 (byte), 2 (short), 4 (int)
+ * \return 0 on success, or -1 if the operation is not supported
+ *
+ * \since This function is available since SDL 2.0.18.
+ *
+ * \sa SDL_RenderGeometry
+ * \sa SDL_Vertex
+ */
+extern DECLSPEC int SDLCALL SDL_RenderGeometryRaw(SDL_Renderer *renderer,
+                                               SDL_Texture *texture,
+                                               const float *xy, int xy_stride,
+                                               const SDL_Color *color, int color_stride,
+                                               const float *uv, int uv_stride,
+                                               int num_vertices,
+                                               const void *indices, int num_indices, int size_indices);
+
+/**
+ * Read pixels from the current rendering target to an array of pixels.
+ *
+ * **WARNING**: This is a very slow operation, and should not be used
+ * frequently. If you're using this on the main rendering target, it should be
+ * called after rendering and before SDL_RenderPresent().
+ *
+ * `pitch` specifies the number of bytes between rows in the destination
+ * `pixels` data. This allows you to write to a subrectangle or have padded
+ * rows in the destination. Generally, `pitch` should equal the number of
+ * pixels per row in the `pixels` data times the number of bytes per pixel,
+ * but it might contain additional padding (for example, 24bit RGB Windows
+ * Bitmap data pads all rows to multiples of 4 bytes).
+ *
+ * \param renderer the rendering context
+ * \param rect an SDL_Rect structure representing the area to read, or NULL
+ *             for the entire render target
+ * \param format an SDL_PixelFormatEnum value of the desired format of the
+ *               pixel data, or 0 to use the format of the rendering target
+ * \param pixels a pointer to the pixel data to copy into
+ * \param pitch the pitch of the `pixels` parameter
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC int SDLCALL SDL_RenderReadPixels(SDL_Renderer * renderer,
                                                  const SDL_Rect * rect,
@@ -1058,95 +1690,200 @@ extern DECLSPEC int SDLCALL SDL_RenderReadPixels(SDL_Renderer * renderer,
                                                  void *pixels, int pitch);
 
 /**
- *  \brief Update the screen with rendering performed.
+ * Update the screen with any rendering performed since the previous call.
+ *
+ * SDL's rendering functions operate on a backbuffer; that is, calling a
+ * rendering function such as SDL_RenderDrawLine() does not directly put a
+ * line on the screen, but rather updates the backbuffer. As such, you compose
+ * your entire scene and *present* the composed backbuffer to the screen as a
+ * complete picture.
+ *
+ * Therefore, when using SDL's rendering API, one does all drawing intended
+ * for the frame, and then calls this function once per frame to present the
+ * final drawing to the user.
+ *
+ * The backbuffer should be considered invalidated after each present; do not
+ * assume that previous contents will exist between frames. You are strongly
+ * encouraged to call SDL_RenderClear() to initialize the backbuffer before
+ * starting each new frame's drawing, even if you plan to overwrite every
+ * pixel.
+ *
+ * \param renderer the rendering context
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RenderClear
+ * \sa SDL_RenderDrawLine
+ * \sa SDL_RenderDrawLines
+ * \sa SDL_RenderDrawPoint
+ * \sa SDL_RenderDrawPoints
+ * \sa SDL_RenderDrawRect
+ * \sa SDL_RenderDrawRects
+ * \sa SDL_RenderFillRect
+ * \sa SDL_RenderFillRects
+ * \sa SDL_SetRenderDrawBlendMode
+ * \sa SDL_SetRenderDrawColor
  */
 extern DECLSPEC void SDLCALL SDL_RenderPresent(SDL_Renderer * renderer);
 
 /**
- *  \brief Destroy the specified texture.
+ * Destroy the specified texture.
  *
- *  \sa SDL_CreateTexture()
- *  \sa SDL_CreateTextureFromSurface()
+ * Passing NULL or an otherwise invalid texture will set the SDL error message
+ * to "Invalid texture".
+ *
+ * \param texture the texture to destroy
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateTexture
+ * \sa SDL_CreateTextureFromSurface
  */
 extern DECLSPEC void SDLCALL SDL_DestroyTexture(SDL_Texture * texture);
 
 /**
- *  \brief Destroy the rendering context for a window and free associated
- *         textures.
+ * Destroy the rendering context for a window and free associated textures.
  *
- *  \sa SDL_CreateRenderer()
+ * \param renderer the rendering context
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateRenderer
  */
 extern DECLSPEC void SDLCALL SDL_DestroyRenderer(SDL_Renderer * renderer);
 
 /**
- *  \brief Force the rendering context to flush any pending commands to the
- *         underlying rendering API.
+ * Force the rendering context to flush any pending commands to the underlying
+ * rendering API.
  *
- *  You do not need to (and in fact, shouldn't) call this function unless
- *  you are planning to call into OpenGL/Direct3D/Metal/whatever directly
- *  in addition to using an SDL_Renderer.
+ * You do not need to (and in fact, shouldn't) call this function unless you
+ * are planning to call into OpenGL/Direct3D/Metal/whatever directly in
+ * addition to using an SDL_Renderer.
  *
- *  This is for a very-specific case: if you are using SDL's render API,
- *  you asked for a specific renderer backend (OpenGL, Direct3D, etc),
- *  you set SDL_HINT_RENDER_BATCHING to "1", and you plan to make
- *  OpenGL/D3D/whatever calls in addition to SDL render API calls. If all of
- *  this applies, you should call SDL_RenderFlush() between calls to SDL's
- *  render API and the low-level API you're using in cooperation.
+ * This is for a very-specific case: if you are using SDL's render API, you
+ * asked for a specific renderer backend (OpenGL, Direct3D, etc), you set
+ * SDL_HINT_RENDER_BATCHING to "1", and you plan to make OpenGL/D3D/whatever
+ * calls in addition to SDL render API calls. If all of this applies, you
+ * should call SDL_RenderFlush() between calls to SDL's render API and the
+ * low-level API you're using in cooperation.
  *
- *  In all other cases, you can ignore this function. This is only here to
- *  get maximum performance out of a specific situation. In all other cases,
- *  SDL will do the right thing, perhaps at a performance loss.
+ * In all other cases, you can ignore this function. This is only here to get
+ * maximum performance out of a specific situation. In all other cases, SDL
+ * will do the right thing, perhaps at a performance loss.
  *
- *  This function is first available in SDL 2.0.10, and is not needed in
- *  2.0.9 and earlier, as earlier versions did not queue rendering commands
- *  at all, instead flushing them to the OS immediately.
+ * This function is first available in SDL 2.0.10, and is not needed in 2.0.9
+ * and earlier, as earlier versions did not queue rendering commands at all,
+ * instead flushing them to the OS immediately.
+ *
+ * \param renderer the rendering context
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.10.
  */
 extern DECLSPEC int SDLCALL SDL_RenderFlush(SDL_Renderer * renderer);
 
 
 /**
- *  \brief Bind the texture to the current OpenGL/ES/ES2 context for use with
- *         OpenGL instructions.
+ * Bind an OpenGL/ES/ES2 texture to the current context.
  *
- *  \param texture  The SDL texture to bind
- *  \param texw     A pointer to a float that will be filled with the texture width
- *  \param texh     A pointer to a float that will be filled with the texture height
+ * This is for use with OpenGL instructions when rendering OpenGL primitives
+ * directly.
  *
- *  \return 0 on success, or -1 if the operation is not supported
+ * If not NULL, `texw` and `texh` will be filled with the width and height
+ * values suitable for the provided texture. In most cases, both will be 1.0,
+ * however, on systems that support the GL_ARB_texture_rectangle extension,
+ * these values will actually be the pixel width and height used to create the
+ * texture, so this factor needs to be taken into account when providing
+ * texture coordinates to OpenGL.
+ *
+ * You need a renderer to create an SDL_Texture, therefore you can only use
+ * this function with an implicit OpenGL context from SDL_CreateRenderer(),
+ * not with your own OpenGL context. If you need control over your OpenGL
+ * context, you need to write your own texture-loading methods.
+ *
+ * Also note that SDL may upload RGB textures as BGR (or vice-versa), and
+ * re-order the color channels in the shaders phase, so the uploaded texture
+ * may have swapped color channels.
+ *
+ * \param texture the texture to bind to the current OpenGL/ES/ES2 context
+ * \param texw a pointer to a float value which will be filled with the
+ *             texture width or NULL if you don't need that value
+ * \param texh a pointer to a float value which will be filled with the
+ *             texture height or NULL if you don't need that value
+ * \returns 0 on success, or -1 if the operation is not supported; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GL_MakeCurrent
+ * \sa SDL_GL_UnbindTexture
  */
 extern DECLSPEC int SDLCALL SDL_GL_BindTexture(SDL_Texture *texture, float *texw, float *texh);
 
 /**
- *  \brief Unbind a texture from the current OpenGL/ES/ES2 context.
+ * Unbind an OpenGL/ES/ES2 texture from the current context.
  *
- *  \param texture  The SDL texture to unbind
+ * See SDL_GL_BindTexture() for examples on how to use these functions
  *
- *  \return 0 on success, or -1 if the operation is not supported
+ * \param texture the texture to unbind from the current OpenGL/ES/ES2 context
+ * \returns 0 on success, or -1 if the operation is not supported
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GL_BindTexture
+ * \sa SDL_GL_MakeCurrent
  */
 extern DECLSPEC int SDLCALL SDL_GL_UnbindTexture(SDL_Texture *texture);
 
 /**
- *  \brief Get the CAMetalLayer associated with the given Metal renderer
+ * Get the CAMetalLayer associated with the given Metal renderer.
  *
- *  \param renderer The renderer to query
+ * This function returns `void *`, so SDL doesn't have to include Metal's
+ * headers, but it can be safely cast to a `CAMetalLayer *`.
  *
- *  \return CAMetalLayer* on success, or NULL if the renderer isn't a Metal renderer
+ * \param renderer The renderer to query
+ * \returns a `CAMetalLayer *` on success, or NULL if the renderer isn't a
+ *          Metal renderer
  *
- *  \sa SDL_RenderGetMetalCommandEncoder()
+ * \since This function is available since SDL 2.0.8.
+ *
+ * \sa SDL_RenderGetMetalCommandEncoder
  */
 extern DECLSPEC void *SDLCALL SDL_RenderGetMetalLayer(SDL_Renderer * renderer);
 
 /**
- *  \brief Get the Metal command encoder for the current frame
+ * Get the Metal command encoder for the current frame
  *
- *  \param renderer The renderer to query
+ * This function returns `void *`, so SDL doesn't have to include Metal's
+ * headers, but it can be safely cast to an `id<MTLRenderCommandEncoder>`.
  *
- *  \return id<MTLRenderCommandEncoder> on success, or NULL if the renderer isn't a Metal renderer
+ * Note that as of SDL 2.0.18, this will return NULL if Metal refuses to give
+ * SDL a drawable to render to, which might happen if the window is
+ * hidden/minimized/offscreen. This doesn't apply to command encoders for
+ * render targets, just the window's backbacker. Check your return values!
  *
- *  \sa SDL_RenderGetMetalLayer()
+ * \param renderer The renderer to query
+ * \returns an `id<MTLRenderCommandEncoder>` on success, or NULL if the
+ *          renderer isn't a Metal renderer or there was an error.
+ *
+ * \since This function is available since SDL 2.0.8.
+ *
+ * \sa SDL_RenderGetMetalLayer
  */
 extern DECLSPEC void *SDLCALL SDL_RenderGetMetalCommandEncoder(SDL_Renderer * renderer);
 
+/**
+ * Toggle VSync of the given renderer.
+ *
+ * \param renderer The renderer to toggle
+ * \param vsync 1 for on, 0 for off. All other values are reserved
+ * \returns a 0 int on success, or non-zero on failure
+ *
+ * \since This function is available since SDL 2.0.18.
+ */
+extern DECLSPEC int SDLCALL SDL_RenderSetVSync(SDL_Renderer* renderer, int vsync);
+
 /* Ends C function definitions when using C++ */
 #ifdef __cplusplus
 }
diff --git a/Engine/lib/sdl/include/SDL_revision.h b/Engine/lib/sdl/include/SDL_revision.h
index d70fd694e..3e9b63af9 100644
--- a/Engine/lib/sdl/include/SDL_revision.h
+++ b/Engine/lib/sdl/include/SDL_revision.h
@@ -1,2 +1,2 @@
-#define SDL_REVISION "hg-0:aaaaaaaaaaah"
+#define SDL_REVISION ""
 #define SDL_REVISION_NUMBER 0
diff --git a/Engine/lib/sdl/include/SDL_revision.h.cmake b/Engine/lib/sdl/include/SDL_revision.h.cmake
new file mode 100644
index 000000000..b27ec11bf
--- /dev/null
+++ b/Engine/lib/sdl/include/SDL_revision.h.cmake
@@ -0,0 +1,6 @@
+#cmakedefine SDL_REVISION "@SDL_REVISION@"
+#define SDL_REVISION_NUMBER 0
+
+#ifndef SDL_REVISION
+#define SDL_REVISION ""
+#endif
diff --git a/Engine/lib/sdl/include/SDL_rwops.h b/Engine/lib/sdl/include/SDL_rwops.h
index 2e6225fcb..71e5c8db8 100644
--- a/Engine/lib/sdl/include/SDL_rwops.h
+++ b/Engine/lib/sdl/include/SDL_rwops.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -45,6 +45,9 @@ extern "C" {
 #define SDL_RWOPS_JNIFILE   3U  /**< Android asset */
 #define SDL_RWOPS_MEMORY    4U  /**< Memory stream */
 #define SDL_RWOPS_MEMORY_RO 5U  /**< Read-Only memory stream */
+#if defined(__VITA__)
+#define SDL_RWOPS_VITAFILE  6U  /**< Vita file */
+#endif
 
 /**
  * This is the read/write operation structure -- very basic.
@@ -110,6 +113,17 @@ typedef struct SDL_RWops
                 size_t left;
             } buffer;
         } windowsio;
+#elif defined(__VITA__)
+        struct
+        {
+            int h;
+            struct
+            {
+                void *data;
+                size_t size;
+                size_t left;
+            } buffer;
+        } vitaio;
 #endif
 
 #ifdef HAVE_STDIO_H
@@ -142,25 +156,228 @@ typedef struct SDL_RWops
  */
 /* @{ */
 
+/**
+ * Use this function to create a new SDL_RWops structure for reading from
+ * and/or writing to a named file.
+ *
+ * The `mode` string is treated roughly the same as in a call to the C
+ * library's fopen(), even if SDL doesn't happen to use fopen() behind the
+ * scenes.
+ *
+ * Available `mode` strings:
+ *
+ * - "r": Open a file for reading. The file must exist.
+ * - "w": Create an empty file for writing. If a file with the same name
+ *   already exists its content is erased and the file is treated as a new
+ *   empty file.
+ * - "a": Append to a file. Writing operations append data at the end of the
+ *   file. The file is created if it does not exist.
+ * - "r+": Open a file for update both reading and writing. The file must
+ *   exist.
+ * - "w+": Create an empty file for both reading and writing. If a file with
+ *   the same name already exists its content is erased and the file is
+ *   treated as a new empty file.
+ * - "a+": Open a file for reading and appending. All writing operations are
+ *   performed at the end of the file, protecting the previous content to be
+ *   overwritten. You can reposition (fseek, rewind) the internal pointer to
+ *   anywhere in the file for reading, but writing operations will move it
+ *   back to the end of file. The file is created if it does not exist.
+ *
+ * **NOTE**: In order to open a file as a binary file, a "b" character has to
+ * be included in the `mode` string. This additional "b" character can either
+ * be appended at the end of the string (thus making the following compound
+ * modes: "rb", "wb", "ab", "r+b", "w+b", "a+b") or be inserted between the
+ * letter and the "+" sign for the mixed modes ("rb+", "wb+", "ab+").
+ * Additional characters may follow the sequence, although they should have no
+ * effect. For example, "t" is sometimes appended to make explicit the file is
+ * a text file.
+ *
+ * This function supports Unicode filenames, but they must be encoded in UTF-8
+ * format, regardless of the underlying operating system.
+ *
+ * As a fallback, SDL_RWFromFile() will transparently open a matching filename
+ * in an Android app's `assets`.
+ *
+ * Closing the SDL_RWops will close the file handle SDL is holding internally.
+ *
+ * \param file a UTF-8 string representing the filename to open
+ * \param mode an ASCII string representing the mode to be used for opening
+ *             the file.
+ * \returns a pointer to the SDL_RWops structure that is created, or NULL on
+ *          failure; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RWclose
+ * \sa SDL_RWFromConstMem
+ * \sa SDL_RWFromFP
+ * \sa SDL_RWFromMem
+ * \sa SDL_RWread
+ * \sa SDL_RWseek
+ * \sa SDL_RWtell
+ * \sa SDL_RWwrite
+ */
 extern DECLSPEC SDL_RWops *SDLCALL SDL_RWFromFile(const char *file,
                                                   const char *mode);
 
 #ifdef HAVE_STDIO_H
-extern DECLSPEC SDL_RWops *SDLCALL SDL_RWFromFP(FILE * fp,
-                                                SDL_bool autoclose);
+
+extern DECLSPEC SDL_RWops *SDLCALL SDL_RWFromFP(FILE * fp, SDL_bool autoclose);
+
 #else
+
+/**
+ * Use this function to create an SDL_RWops structure from a standard I/O file
+ * pointer (stdio.h's `FILE*`).
+ *
+ * This function is not available on Windows, since files opened in an
+ * application on that platform cannot be used by a dynamically linked
+ * library.
+ *
+ * On some platforms, the first parameter is a `void*`, on others, it's a
+ * `FILE*`, depending on what system headers are available to SDL. It is
+ * always intended to be the `FILE*` type from the C runtime's stdio.h.
+ *
+ * \param fp the `FILE*` that feeds the SDL_RWops stream
+ * \param autoclose SDL_TRUE to close the `FILE*` when closing the SDL_RWops,
+ *                  SDL_FALSE to leave the `FILE*` open when the RWops is
+ *                  closed
+ * \returns a pointer to the SDL_RWops structure that is created, or NULL on
+ *          failure; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RWclose
+ * \sa SDL_RWFromConstMem
+ * \sa SDL_RWFromFile
+ * \sa SDL_RWFromMem
+ * \sa SDL_RWread
+ * \sa SDL_RWseek
+ * \sa SDL_RWtell
+ * \sa SDL_RWwrite
+ */
 extern DECLSPEC SDL_RWops *SDLCALL SDL_RWFromFP(void * fp,
                                                 SDL_bool autoclose);
 #endif
 
+/**
+ * Use this function to prepare a read-write memory buffer for use with
+ * SDL_RWops.
+ *
+ * This function sets up an SDL_RWops struct based on a memory area of a
+ * certain size, for both read and write access.
+ *
+ * This memory buffer is not copied by the RWops; the pointer you provide must
+ * remain valid until you close the stream. Closing the stream will not free
+ * the original buffer.
+ *
+ * If you need to make sure the RWops never writes to the memory buffer, you
+ * should use SDL_RWFromConstMem() with a read-only buffer of memory instead.
+ *
+ * \param mem a pointer to a buffer to feed an SDL_RWops stream
+ * \param size the buffer size, in bytes
+ * \returns a pointer to a new SDL_RWops structure, or NULL if it fails; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RWclose
+ * \sa SDL_RWFromConstMem
+ * \sa SDL_RWFromFile
+ * \sa SDL_RWFromFP
+ * \sa SDL_RWFromMem
+ * \sa SDL_RWread
+ * \sa SDL_RWseek
+ * \sa SDL_RWtell
+ * \sa SDL_RWwrite
+ */
 extern DECLSPEC SDL_RWops *SDLCALL SDL_RWFromMem(void *mem, int size);
+
+/**
+ * Use this function to prepare a read-only memory buffer for use with RWops.
+ *
+ * This function sets up an SDL_RWops struct based on a memory area of a
+ * certain size. It assumes the memory area is not writable.
+ *
+ * Attempting to write to this RWops stream will report an error without
+ * writing to the memory buffer.
+ *
+ * This memory buffer is not copied by the RWops; the pointer you provide must
+ * remain valid until you close the stream. Closing the stream will not free
+ * the original buffer.
+ *
+ * If you need to write to a memory buffer, you should use SDL_RWFromMem()
+ * with a writable buffer of memory instead.
+ *
+ * \param mem a pointer to a read-only buffer to feed an SDL_RWops stream
+ * \param size the buffer size, in bytes
+ * \returns a pointer to a new SDL_RWops structure, or NULL if it fails; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RWclose
+ * \sa SDL_RWFromConstMem
+ * \sa SDL_RWFromFile
+ * \sa SDL_RWFromFP
+ * \sa SDL_RWFromMem
+ * \sa SDL_RWread
+ * \sa SDL_RWseek
+ * \sa SDL_RWtell
+ */
 extern DECLSPEC SDL_RWops *SDLCALL SDL_RWFromConstMem(const void *mem,
                                                       int size);
 
 /* @} *//* RWFrom functions */
 
 
+/**
+ * Use this function to allocate an empty, unpopulated SDL_RWops structure.
+ *
+ * Applications do not need to use this function unless they are providing
+ * their own SDL_RWops implementation. If you just need a SDL_RWops to
+ * read/write a common data source, you should use the built-in
+ * implementations in SDL, like SDL_RWFromFile() or SDL_RWFromMem(), etc.
+ *
+ * You must free the returned pointer with SDL_FreeRW(). Depending on your
+ * operating system and compiler, there may be a difference between the
+ * malloc() and free() your program uses and the versions SDL calls
+ * internally. Trying to mix the two can cause crashing such as segmentation
+ * faults. Since all SDL_RWops must free themselves when their **close**
+ * method is called, all SDL_RWops must be allocated through this function, so
+ * they can all be freed correctly with SDL_FreeRW().
+ *
+ * \returns a pointer to the allocated memory on success, or NULL on failure;
+ *          call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_FreeRW
+ */
 extern DECLSPEC SDL_RWops *SDLCALL SDL_AllocRW(void);
+
+/**
+ * Use this function to free an SDL_RWops structure allocated by
+ * SDL_AllocRW().
+ *
+ * Applications do not need to use this function unless they are providing
+ * their own SDL_RWops implementation. If you just need a SDL_RWops to
+ * read/write a common data source, you should use the built-in
+ * implementations in SDL, like SDL_RWFromFile() or SDL_RWFromMem(), etc, and
+ * call the **close** method on those SDL_RWops pointers when you are done
+ * with them.
+ *
+ * Only use SDL_FreeRW() on pointers returned by SDL_AllocRW(). The pointer is
+ * invalid as soon as this function returns. Any extra memory allocated during
+ * creation of the SDL_RWops is not freed by SDL_FreeRW(); the programmer must
+ * be responsible for managing that memory in their **close** method.
+ *
+ * \param area the SDL_RWops structure to be freed
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_AllocRW
+ */
 extern DECLSPEC void SDLCALL SDL_FreeRW(SDL_RWops * area);
 
 #define RW_SEEK_SET 0       /**< Seek from the beginning of data */
@@ -168,77 +385,218 @@ extern DECLSPEC void SDLCALL SDL_FreeRW(SDL_RWops * area);
 #define RW_SEEK_END 2       /**< Seek relative to the end of data */
 
 /**
- *  Return the size of the file in this rwops, or -1 if unknown
+ * Use this function to get the size of the data stream in an SDL_RWops.
+ *
+ * Prior to SDL 2.0.10, this function was a macro.
+ *
+ * \param context the SDL_RWops to get the size of the data stream from
+ * \returns the size of the data stream in the SDL_RWops on success, -1 if
+ *          unknown or a negative error code on failure; call SDL_GetError()
+ *          for more information.
+ *
+ * \since This function is available since SDL 2.0.10.
  */
 extern DECLSPEC Sint64 SDLCALL SDL_RWsize(SDL_RWops *context);
 
 /**
- *  Seek to \c offset relative to \c whence, one of stdio's whence values:
- *  RW_SEEK_SET, RW_SEEK_CUR, RW_SEEK_END
+ * Seek within an SDL_RWops data stream.
  *
- *  \return the final offset in the data stream, or -1 on error.
+ * This function seeks to byte `offset`, relative to `whence`.
+ *
+ * `whence` may be any of the following values:
+ *
+ * - `RW_SEEK_SET`: seek from the beginning of data
+ * - `RW_SEEK_CUR`: seek relative to current read point
+ * - `RW_SEEK_END`: seek relative to the end of data
+ *
+ * If this stream can not seek, it will return -1.
+ *
+ * SDL_RWseek() is actually a wrapper function that calls the SDL_RWops's
+ * `seek` method appropriately, to simplify application development.
+ *
+ * Prior to SDL 2.0.10, this function was a macro.
+ *
+ * \param context a pointer to an SDL_RWops structure
+ * \param offset an offset in bytes, relative to **whence** location; can be
+ *               negative
+ * \param whence any of `RW_SEEK_SET`, `RW_SEEK_CUR`, `RW_SEEK_END`
+ * \returns the final offset in the data stream after the seek or -1 on error.
+ *
+ * \since This function is available since SDL 2.0.10.
+ *
+ * \sa SDL_RWclose
+ * \sa SDL_RWFromConstMem
+ * \sa SDL_RWFromFile
+ * \sa SDL_RWFromFP
+ * \sa SDL_RWFromMem
+ * \sa SDL_RWread
+ * \sa SDL_RWtell
+ * \sa SDL_RWwrite
  */
 extern DECLSPEC Sint64 SDLCALL SDL_RWseek(SDL_RWops *context,
                                           Sint64 offset, int whence);
 
 /**
- *  Return the current offset in the data stream, or -1 on error.
+ * Determine the current read/write offset in an SDL_RWops data stream.
+ *
+ * SDL_RWtell is actually a wrapper function that calls the SDL_RWops's `seek`
+ * method, with an offset of 0 bytes from `RW_SEEK_CUR`, to simplify
+ * application development.
+ *
+ * Prior to SDL 2.0.10, this function was a macro.
+ *
+ * \param context a SDL_RWops data stream object from which to get the current
+ *                offset
+ * \returns the current offset in the stream, or -1 if the information can not
+ *          be determined.
+ *
+ * \since This function is available since SDL 2.0.10.
+ *
+ * \sa SDL_RWclose
+ * \sa SDL_RWFromConstMem
+ * \sa SDL_RWFromFile
+ * \sa SDL_RWFromFP
+ * \sa SDL_RWFromMem
+ * \sa SDL_RWread
+ * \sa SDL_RWseek
+ * \sa SDL_RWwrite
  */
 extern DECLSPEC Sint64 SDLCALL SDL_RWtell(SDL_RWops *context);
 
 /**
- *  Read up to \c maxnum objects each of size \c size from the data
- *  stream to the area pointed at by \c ptr.
+ * Read from a data source.
  *
- *  \return the number of objects read, or 0 at error or end of file.
+ * This function reads up to `maxnum` objects each of size `size` from the
+ * data source to the area pointed at by `ptr`. This function may read less
+ * objects than requested. It will return zero when there has been an error or
+ * the data stream is completely read.
+ *
+ * SDL_RWread() is actually a function wrapper that calls the SDL_RWops's
+ * `read` method appropriately, to simplify application development.
+ *
+ * Prior to SDL 2.0.10, this function was a macro.
+ *
+ * \param context a pointer to an SDL_RWops structure
+ * \param ptr a pointer to a buffer to read data into
+ * \param size the size of each object to read, in bytes
+ * \param maxnum the maximum number of objects to be read
+ * \returns the number of objects read, or 0 at error or end of file; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.10.
+ *
+ * \sa SDL_RWclose
+ * \sa SDL_RWFromConstMem
+ * \sa SDL_RWFromFile
+ * \sa SDL_RWFromFP
+ * \sa SDL_RWFromMem
+ * \sa SDL_RWseek
+ * \sa SDL_RWwrite
  */
 extern DECLSPEC size_t SDLCALL SDL_RWread(SDL_RWops *context,
-                                          void *ptr, size_t size, size_t maxnum);
+                                          void *ptr, size_t size,
+                                          size_t maxnum);
 
 /**
- *  Write exactly \c num objects each of size \c size from the area
- *  pointed at by \c ptr to data stream.
+ * Write to an SDL_RWops data stream.
  *
- *  \return the number of objects written, or 0 at error or end of file.
+ * This function writes exactly `num` objects each of size `size` from the
+ * area pointed at by `ptr` to the stream. If this fails for any reason, it'll
+ * return less than `num` to demonstrate how far the write progressed. On
+ * success, it returns `num`.
+ *
+ * SDL_RWwrite is actually a function wrapper that calls the SDL_RWops's
+ * `write` method appropriately, to simplify application development.
+ *
+ * Prior to SDL 2.0.10, this function was a macro.
+ *
+ * \param context a pointer to an SDL_RWops structure
+ * \param ptr a pointer to a buffer containing data to write
+ * \param size the size of an object to write, in bytes
+ * \param num the number of objects to write
+ * \returns the number of objects written, which will be less than **num** on
+ *          error; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.10.
+ *
+ * \sa SDL_RWclose
+ * \sa SDL_RWFromConstMem
+ * \sa SDL_RWFromFile
+ * \sa SDL_RWFromFP
+ * \sa SDL_RWFromMem
+ * \sa SDL_RWread
+ * \sa SDL_RWseek
  */
 extern DECLSPEC size_t SDLCALL SDL_RWwrite(SDL_RWops *context,
-                                           const void *ptr, size_t size, size_t num);
+                                           const void *ptr, size_t size,
+                                           size_t num);
 
 /**
- *  Close and free an allocated SDL_RWops structure.
+ * Close and free an allocated SDL_RWops structure.
  *
- *  \return 0 if successful or -1 on write error when flushing data.
+ * SDL_RWclose() closes and cleans up the SDL_RWops stream. It releases any
+ * resources used by the stream and frees the SDL_RWops itself with
+ * SDL_FreeRW(). This returns 0 on success, or -1 if the stream failed to
+ * flush to its output (e.g. to disk).
+ *
+ * Note that if this fails to flush the stream to disk, this function reports
+ * an error, but the SDL_RWops is still invalid once this function returns.
+ *
+ * Prior to SDL 2.0.10, this function was a macro.
+ *
+ * \param context SDL_RWops structure to close
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.10.
+ *
+ * \sa SDL_RWFromConstMem
+ * \sa SDL_RWFromFile
+ * \sa SDL_RWFromFP
+ * \sa SDL_RWFromMem
+ * \sa SDL_RWread
+ * \sa SDL_RWseek
+ * \sa SDL_RWwrite
  */
 extern DECLSPEC int SDLCALL SDL_RWclose(SDL_RWops *context);
 
 /**
- *  Load all the data from an SDL data stream.
+ * Load all the data from an SDL data stream.
  *
- *  The data is allocated with a zero byte at the end (null terminated)
+ * The data is allocated with a zero byte at the end (null terminated) for
+ * convenience. This extra byte is not included in the value reported via
+ * `datasize`.
  *
- *  If \c datasize is not NULL, it is filled with the size of the data read.
+ * The data should be freed with SDL_free().
  *
- *  If \c freesrc is non-zero, the stream will be closed after being read.
+ * \param src the SDL_RWops to read all available data from
+ * \param datasize if not NULL, will store the number of bytes read
+ * \param freesrc if non-zero, calls SDL_RWclose() on `src` before returning
+ * \returns the data, or NULL if there was an error.
  *
- *  The data should be freed with SDL_free().
- *
- *  \return the data, or NULL if there was an error.
+ * \since This function is available since SDL 2.0.6.
  */
-extern DECLSPEC void *SDLCALL SDL_LoadFile_RW(SDL_RWops * src, size_t *datasize,
-                                                    int freesrc);
+extern DECLSPEC void *SDLCALL SDL_LoadFile_RW(SDL_RWops *src,
+                                              size_t *datasize,
+                                              int freesrc);
 
 /**
- *  Load an entire file.
+ * Load all the data from a file path.
  *
- *  The data is allocated with a zero byte at the end (null terminated)
+ * The data is allocated with a zero byte at the end (null terminated) for
+ * convenience. This extra byte is not included in the value reported via
+ * `datasize`.
  *
- *  If \c datasize is not NULL, it is filled with the size of the data read.
+ * The data should be freed with SDL_free().
  *
- *  If \c freesrc is non-zero, the stream will be closed after being read.
+ * Prior to SDL 2.0.10, this function was a macro wrapping around
+ * SDL_LoadFile_RW.
  *
- *  The data should be freed with SDL_free().
+ * \param file the path to read all available data from
+ * \param datasize if not NULL, will store the number of bytes read
+ * \returns the data, or NULL if there was an error.
  *
- *  \return the data, or NULL if there was an error.
+ * \since This function is available since SDL 2.0.10.
  */
 extern DECLSPEC void *SDLCALL SDL_LoadFile(const char *file, size_t *datasize);
 
@@ -248,12 +606,114 @@ extern DECLSPEC void *SDLCALL SDL_LoadFile(const char *file, size_t *datasize);
  *  Read an item of the specified endianness and return in native format.
  */
 /* @{ */
+
+/**
+ * Use this function to read a byte from an SDL_RWops.
+ *
+ * \param src the SDL_RWops to read from
+ * \returns the read byte on success or 0 on failure; call SDL_GetError() for
+ *          more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_WriteU8
+ */
 extern DECLSPEC Uint8 SDLCALL SDL_ReadU8(SDL_RWops * src);
+
+/**
+ * Use this function to read 16 bits of little-endian data from an SDL_RWops
+ * and return in native format.
+ *
+ * SDL byteswaps the data only if necessary, so the data returned will be in
+ * the native byte order.
+ *
+ * \param src the stream from which to read data
+ * \returns 16 bits of data in the native byte order of the platform.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_ReadBE16
+ */
 extern DECLSPEC Uint16 SDLCALL SDL_ReadLE16(SDL_RWops * src);
+
+/**
+ * Use this function to read 16 bits of big-endian data from an SDL_RWops and
+ * return in native format.
+ *
+ * SDL byteswaps the data only if necessary, so the data returned will be in
+ * the native byte order.
+ *
+ * \param src the stream from which to read data
+ * \returns 16 bits of data in the native byte order of the platform.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_ReadLE16
+ */
 extern DECLSPEC Uint16 SDLCALL SDL_ReadBE16(SDL_RWops * src);
+
+/**
+ * Use this function to read 32 bits of little-endian data from an SDL_RWops
+ * and return in native format.
+ *
+ * SDL byteswaps the data only if necessary, so the data returned will be in
+ * the native byte order.
+ *
+ * \param src the stream from which to read data
+ * \returns 32 bits of data in the native byte order of the platform.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_ReadBE32
+ */
 extern DECLSPEC Uint32 SDLCALL SDL_ReadLE32(SDL_RWops * src);
+
+/**
+ * Use this function to read 32 bits of big-endian data from an SDL_RWops and
+ * return in native format.
+ *
+ * SDL byteswaps the data only if necessary, so the data returned will be in
+ * the native byte order.
+ *
+ * \param src the stream from which to read data
+ * \returns 32 bits of data in the native byte order of the platform.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_ReadLE32
+ */
 extern DECLSPEC Uint32 SDLCALL SDL_ReadBE32(SDL_RWops * src);
+
+/**
+ * Use this function to read 64 bits of little-endian data from an SDL_RWops
+ * and return in native format.
+ *
+ * SDL byteswaps the data only if necessary, so the data returned will be in
+ * the native byte order.
+ *
+ * \param src the stream from which to read data
+ * \returns 64 bits of data in the native byte order of the platform.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_ReadBE64
+ */
 extern DECLSPEC Uint64 SDLCALL SDL_ReadLE64(SDL_RWops * src);
+
+/**
+ * Use this function to read 64 bits of big-endian data from an SDL_RWops and
+ * return in native format.
+ *
+ * SDL byteswaps the data only if necessary, so the data returned will be in
+ * the native byte order.
+ *
+ * \param src the stream from which to read data
+ * \returns 64 bits of data in the native byte order of the platform.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_ReadLE64
+ */
 extern DECLSPEC Uint64 SDLCALL SDL_ReadBE64(SDL_RWops * src);
 /* @} *//* Read endian functions */
 
@@ -263,12 +723,124 @@ extern DECLSPEC Uint64 SDLCALL SDL_ReadBE64(SDL_RWops * src);
  *  Write an item of native format to the specified endianness.
  */
 /* @{ */
+
+/**
+ * Use this function to write a byte to an SDL_RWops.
+ *
+ * \param dst the SDL_RWops to write to
+ * \param value the byte value to write
+ * \returns 1 on success or 0 on failure; call SDL_GetError() for more
+ *          information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_ReadU8
+ */
 extern DECLSPEC size_t SDLCALL SDL_WriteU8(SDL_RWops * dst, Uint8 value);
+
+/**
+ * Use this function to write 16 bits in native format to a SDL_RWops as
+ * little-endian data.
+ *
+ * SDL byteswaps the data only if necessary, so the application always
+ * specifies native format, and the data written will be in little-endian
+ * format.
+ *
+ * \param dst the stream to which data will be written
+ * \param value the data to be written, in native format
+ * \returns 1 on successful write, 0 on error.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_WriteBE16
+ */
 extern DECLSPEC size_t SDLCALL SDL_WriteLE16(SDL_RWops * dst, Uint16 value);
+
+/**
+ * Use this function to write 16 bits in native format to a SDL_RWops as
+ * big-endian data.
+ *
+ * SDL byteswaps the data only if necessary, so the application always
+ * specifies native format, and the data written will be in big-endian format.
+ *
+ * \param dst the stream to which data will be written
+ * \param value the data to be written, in native format
+ * \returns 1 on successful write, 0 on error.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_WriteLE16
+ */
 extern DECLSPEC size_t SDLCALL SDL_WriteBE16(SDL_RWops * dst, Uint16 value);
+
+/**
+ * Use this function to write 32 bits in native format to a SDL_RWops as
+ * little-endian data.
+ *
+ * SDL byteswaps the data only if necessary, so the application always
+ * specifies native format, and the data written will be in little-endian
+ * format.
+ *
+ * \param dst the stream to which data will be written
+ * \param value the data to be written, in native format
+ * \returns 1 on successful write, 0 on error.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_WriteBE32
+ */
 extern DECLSPEC size_t SDLCALL SDL_WriteLE32(SDL_RWops * dst, Uint32 value);
+
+/**
+ * Use this function to write 32 bits in native format to a SDL_RWops as
+ * big-endian data.
+ *
+ * SDL byteswaps the data only if necessary, so the application always
+ * specifies native format, and the data written will be in big-endian format.
+ *
+ * \param dst the stream to which data will be written
+ * \param value the data to be written, in native format
+ * \returns 1 on successful write, 0 on error.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_WriteLE32
+ */
 extern DECLSPEC size_t SDLCALL SDL_WriteBE32(SDL_RWops * dst, Uint32 value);
+
+/**
+ * Use this function to write 64 bits in native format to a SDL_RWops as
+ * little-endian data.
+ *
+ * SDL byteswaps the data only if necessary, so the application always
+ * specifies native format, and the data written will be in little-endian
+ * format.
+ *
+ * \param dst the stream to which data will be written
+ * \param value the data to be written, in native format
+ * \returns 1 on successful write, 0 on error.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_WriteBE64
+ */
 extern DECLSPEC size_t SDLCALL SDL_WriteLE64(SDL_RWops * dst, Uint64 value);
+
+/**
+ * Use this function to write 64 bits in native format to a SDL_RWops as
+ * big-endian data.
+ *
+ * SDL byteswaps the data only if necessary, so the application always
+ * specifies native format, and the data written will be in big-endian format.
+ *
+ * \param dst the stream to which data will be written
+ * \param value the data to be written, in native format
+ * \returns 1 on successful write, 0 on error.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_WriteLE64
+ */
 extern DECLSPEC size_t SDLCALL SDL_WriteBE64(SDL_RWops * dst, Uint64 value);
 /* @} *//* Write endian functions */
 
diff --git a/Engine/lib/sdl/include/SDL_scancode.h b/Engine/lib/sdl/include/SDL_scancode.h
index b19197d2b..5b2c67c8f 100644
--- a/Engine/lib/sdl/include/SDL_scancode.h
+++ b/Engine/lib/sdl/include/SDL_scancode.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/include/SDL_sensor.h b/Engine/lib/sdl/include/SDL_sensor.h
index e6236341e..a2f30e0f8 100644
--- a/Engine/lib/sdl/include/SDL_sensor.h
+++ b/Engine/lib/sdl/include/SDL_sensor.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -130,126 +130,160 @@ typedef enum
  * If you are using the sensor API or handling events from multiple threads
  * you should use these locking functions to protect access to the sensors.
  *
- * In particular, you are guaranteed that the sensor list won't change, so
- * the API functions that take a sensor index will be valid, and sensor
- * events will not be delivered.
+ * In particular, you are guaranteed that the sensor list won't change, so the
+ * API functions that take a sensor index will be valid, and sensor events
+ * will not be delivered.
+ *
+ * \since This function is available since SDL 2.0.14.
  */
 extern DECLSPEC void SDLCALL SDL_LockSensors(void);
 extern DECLSPEC void SDLCALL SDL_UnlockSensors(void);
 
 /**
- *  \brief Count the number of sensors attached to the system right now
+ * Count the number of sensors attached to the system right now.
+ *
+ * \returns the number of sensors detected.
+ *
+ * \since This function is available since SDL 2.0.9.
  */
 extern DECLSPEC int SDLCALL SDL_NumSensors(void);
 
 /**
- *  \brief Get the implementation dependent name of a sensor.
+ * Get the implementation dependent name of a sensor.
  *
- *  This can be called before any sensors are opened.
- * 
- *  \return The sensor name, or NULL if device_index is out of range.
+ * \param device_index The sensor to obtain name from
+ * \returns the sensor name, or NULL if `device_index` is out of range.
+ *
+ * \since This function is available since SDL 2.0.9.
  */
 extern DECLSPEC const char *SDLCALL SDL_SensorGetDeviceName(int device_index);
 
 /**
- *  \brief Get the type of a sensor.
+ * Get the type of a sensor.
  *
- *  This can be called before any sensors are opened.
+ * \param device_index The sensor to get the type from
+ * \returns the SDL_SensorType, or `SDL_SENSOR_INVALID` if `device_index` is
+ *          out of range.
  *
- *  \return The sensor type, or SDL_SENSOR_INVALID if device_index is out of range.
+ * \since This function is available since SDL 2.0.9.
  */
 extern DECLSPEC SDL_SensorType SDLCALL SDL_SensorGetDeviceType(int device_index);
 
 /**
- *  \brief Get the platform dependent type of a sensor.
+ * Get the platform dependent type of a sensor.
  *
- *  This can be called before any sensors are opened.
+ * \param device_index The sensor to check
+ * \returns the sensor platform dependent type, or -1 if `device_index` is out
+ *          of range.
  *
- *  \return The sensor platform dependent type, or -1 if device_index is out of range.
+ * \since This function is available since SDL 2.0.9.
  */
 extern DECLSPEC int SDLCALL SDL_SensorGetDeviceNonPortableType(int device_index);
 
 /**
- *  \brief Get the instance ID of a sensor.
+ * Get the instance ID of a sensor.
  *
- *  This can be called before any sensors are opened.
+ * \param device_index The sensor to get instance id from
+ * \returns the sensor instance ID, or -1 if `device_index` is out of range.
  *
- *  \return The sensor instance ID, or -1 if device_index is out of range.
+ * \since This function is available since SDL 2.0.9.
  */
 extern DECLSPEC SDL_SensorID SDLCALL SDL_SensorGetDeviceInstanceID(int device_index);
 
 /**
- *  \brief Open a sensor for use.
+ * Open a sensor for use.
  *
- *  The index passed as an argument refers to the N'th sensor on the system.
+ * \param device_index The sensor to open
+ * \returns an SDL_Sensor sensor object, or NULL if an error occurred.
  *
- *  \return A sensor identifier, or NULL if an error occurred.
+ * \since This function is available since SDL 2.0.9.
  */
 extern DECLSPEC SDL_Sensor *SDLCALL SDL_SensorOpen(int device_index);
 
 /**
  * Return the SDL_Sensor associated with an instance id.
+ *
+ * \param instance_id The sensor from instance id
+ * \returns an SDL_Sensor object.
+ *
+ * \since This function is available since SDL 2.0.9.
  */
 extern DECLSPEC SDL_Sensor *SDLCALL SDL_SensorFromInstanceID(SDL_SensorID instance_id);
 
 /**
- *  \brief Get the implementation dependent name of a sensor.
+ * Get the implementation dependent name of a sensor
  *
- *  \return The sensor name, or NULL if the sensor is NULL.
+ * \param sensor The SDL_Sensor object
+ * \returns the sensor name, or NULL if `sensor` is NULL.
+ *
+ * \since This function is available since SDL 2.0.9.
  */
 extern DECLSPEC const char *SDLCALL SDL_SensorGetName(SDL_Sensor *sensor);
 
 /**
- *  \brief Get the type of a sensor.
+ * Get the type of a sensor.
  *
- *  This can be called before any sensors are opened.
+ * \param sensor The SDL_Sensor object to inspect
+ * \returns the SDL_SensorType type, or `SDL_SENSOR_INVALID` if `sensor` is
+ *          NULL.
  *
- *  \return The sensor type, or SDL_SENSOR_INVALID if the sensor is NULL.
+ * \since This function is available since SDL 2.0.9.
  */
 extern DECLSPEC SDL_SensorType SDLCALL SDL_SensorGetType(SDL_Sensor *sensor);
 
 /**
- *  \brief Get the platform dependent type of a sensor.
+ * Get the platform dependent type of a sensor.
  *
- *  This can be called before any sensors are opened.
+ * \param sensor The SDL_Sensor object to inspect
+ * \returns the sensor platform dependent type, or -1 if `sensor` is NULL.
  *
- *  \return The sensor platform dependent type, or -1 if the sensor is NULL.
+ * \since This function is available since SDL 2.0.9.
  */
 extern DECLSPEC int SDLCALL SDL_SensorGetNonPortableType(SDL_Sensor *sensor);
 
 /**
- *  \brief Get the instance ID of a sensor.
+ * Get the instance ID of a sensor.
  *
- *  This can be called before any sensors are opened.
+ * \param sensor The SDL_Sensor object to inspect
+ * \returns the sensor instance ID, or -1 if `sensor` is NULL.
  *
- *  \return The sensor instance ID, or -1 if the sensor is NULL.
+ * \since This function is available since SDL 2.0.9.
  */
 extern DECLSPEC SDL_SensorID SDLCALL SDL_SensorGetInstanceID(SDL_Sensor *sensor);
 
 /**
- *  Get the current state of an opened sensor.
+ * Get the current state of an opened sensor.
  *
- *  The number of values and interpretation of the data is sensor dependent.
+ * The number of values and interpretation of the data is sensor dependent.
  *
- *  \param sensor The sensor to query
- *  \param data A pointer filled with the current sensor state
- *  \param num_values The number of values to write to data
+ * \param sensor The SDL_Sensor object to query
+ * \param data A pointer filled with the current sensor state
+ * \param num_values The number of values to write to data
+ * \returns 0 or -1 if an error occurred.
  *
- *  \return 0 or -1 if an error occurred.
+ * \since This function is available since SDL 2.0.9.
  */
 extern DECLSPEC int SDLCALL SDL_SensorGetData(SDL_Sensor * sensor, float *data, int num_values);
 
 /**
- *  Close a sensor previously opened with SDL_SensorOpen()
+ * Close a sensor previously opened with SDL_SensorOpen().
+ *
+ * \param sensor The SDL_Sensor object to close
+ *
+ * \since This function is available since SDL 2.0.9.
  */
 extern DECLSPEC void SDLCALL SDL_SensorClose(SDL_Sensor * sensor);
 
 /**
- *  Update the current state of the open sensors.
+ * Update the current state of the open sensors.
  *
- *  This is called automatically by the event loop if sensor events are enabled.
+ * This is called automatically by the event loop if sensor events are
+ * enabled.
  *
- *  This needs to be called from the thread that initialized the sensor subsystem.
+ * This needs to be called from the thread that initialized the sensor
+ * subsystem.
+ *
+ * \since This function is available since SDL 2.0.9.
  */
 extern DECLSPEC void SDLCALL SDL_SensorUpdate(void);
 
diff --git a/Engine/lib/sdl/include/SDL_shape.h b/Engine/lib/sdl/include/SDL_shape.h
index cbd9debd6..1bca9270e 100644
--- a/Engine/lib/sdl/include/SDL_shape.h
+++ b/Engine/lib/sdl/include/SDL_shape.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -44,33 +44,38 @@ extern "C" {
 #define SDL_WINDOW_LACKS_SHAPE -3
 
 /**
- *  \brief Create a window that can be shaped with the specified position, dimensions, and flags.
+ * Create a window that can be shaped with the specified position, dimensions,
+ * and flags.
  *
- *  \param title The title of the window, in UTF-8 encoding.
- *  \param x     The x position of the window, ::SDL_WINDOWPOS_CENTERED, or
- *               ::SDL_WINDOWPOS_UNDEFINED.
- *  \param y     The y position of the window, ::SDL_WINDOWPOS_CENTERED, or
- *               ::SDL_WINDOWPOS_UNDEFINED.
- *  \param w     The width of the window.
- *  \param h     The height of the window.
- *  \param flags The flags for the window, a mask of SDL_WINDOW_BORDERLESS with any of the following:
- *               ::SDL_WINDOW_OPENGL,     ::SDL_WINDOW_INPUT_GRABBED,
- *               ::SDL_WINDOW_HIDDEN,     ::SDL_WINDOW_RESIZABLE,
- *               ::SDL_WINDOW_MAXIMIZED,  ::SDL_WINDOW_MINIMIZED,
- *       ::SDL_WINDOW_BORDERLESS is always set, and ::SDL_WINDOW_FULLSCREEN is always unset.
+ * \param title The title of the window, in UTF-8 encoding.
+ * \param x The x position of the window, ::SDL_WINDOWPOS_CENTERED, or
+ *          ::SDL_WINDOWPOS_UNDEFINED.
+ * \param y The y position of the window, ::SDL_WINDOWPOS_CENTERED, or
+ *          ::SDL_WINDOWPOS_UNDEFINED.
+ * \param w The width of the window.
+ * \param h The height of the window.
+ * \param flags The flags for the window, a mask of SDL_WINDOW_BORDERLESS with
+ *              any of the following: ::SDL_WINDOW_OPENGL,
+ *              ::SDL_WINDOW_INPUT_GRABBED, ::SDL_WINDOW_HIDDEN,
+ *              ::SDL_WINDOW_RESIZABLE, ::SDL_WINDOW_MAXIMIZED,
+ *              ::SDL_WINDOW_MINIMIZED, ::SDL_WINDOW_BORDERLESS is always set,
+ *              and ::SDL_WINDOW_FULLSCREEN is always unset.
+ * \return the window created, or NULL if window creation failed.
  *
- *  \return The window created, or NULL if window creation failed.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_DestroyWindow()
+ * \sa SDL_DestroyWindow
  */
 extern DECLSPEC SDL_Window * SDLCALL SDL_CreateShapedWindow(const char *title,unsigned int x,unsigned int y,unsigned int w,unsigned int h,Uint32 flags);
 
 /**
- * \brief Return whether the given window is a shaped window.
+ * Return whether the given window is a shaped window.
  *
  * \param window The window to query for being shaped.
+ * \return SDL_TRUE if the window is a window that can be shaped, SDL_FALSE if
+ *         the window is unshaped or NULL.
  *
- * \return SDL_TRUE if the window is a window that can be shaped, SDL_FALSE if the window is unshaped or NULL.
+ * \since This function is available since SDL 2.0.0.
  *
  * \sa SDL_CreateShapedWindow
  */
@@ -106,29 +111,35 @@ typedef struct SDL_WindowShapeMode {
 } SDL_WindowShapeMode;
 
 /**
- * \brief Set the shape and parameters of a shaped window.
+ * Set the shape and parameters of a shaped window.
  *
  * \param window The shaped window whose parameters should be set.
  * \param shape A surface encoding the desired shape for the window.
  * \param shape_mode The parameters to set for the shaped window.
+ * \return 0 on success, SDL_INVALID_SHAPE_ARGUMENT on an invalid shape
+ *         argument, or SDL_NONSHAPEABLE_WINDOW if the SDL_Window given does
+ *         not reference a valid shaped window.
  *
- * \return 0 on success, SDL_INVALID_SHAPE_ARGUMENT on an invalid shape argument, or SDL_NONSHAPEABLE_WINDOW
- *           if the SDL_Window given does not reference a valid shaped window.
+ * \since This function is available since SDL 2.0.0.
  *
  * \sa SDL_WindowShapeMode
- * \sa SDL_GetShapedWindowMode.
+ * \sa SDL_GetShapedWindowMode
  */
 extern DECLSPEC int SDLCALL SDL_SetWindowShape(SDL_Window *window,SDL_Surface *shape,SDL_WindowShapeMode *shape_mode);
 
 /**
- * \brief Get the shape parameters of a shaped window.
+ * Get the shape parameters of a shaped window.
  *
  * \param window The shaped window whose parameters should be retrieved.
- * \param shape_mode An empty shape-mode structure to fill, or NULL to check whether the window has a shape.
+ * \param shape_mode An empty shape-mode structure to fill, or NULL to check
+ *                   whether the window has a shape.
+ * \return 0 if the window has a shape and, provided shape_mode was not NULL,
+ *         shape_mode has been filled with the mode data,
+ *         SDL_NONSHAPEABLE_WINDOW if the SDL_Window given is not a shaped
+ *         window, or SDL_WINDOW_LACKS_SHAPE if the SDL_Window given is a
+ *         shapeable window currently lacking a shape.
  *
- * \return 0 if the window has a shape and, provided shape_mode was not NULL, shape_mode has been filled with the mode
- *           data, SDL_NONSHAPEABLE_WINDOW if the SDL_Window given is not a shaped window, or SDL_WINDOW_LACKS_SHAPE if
- *           the SDL_Window given is a shapeable window currently lacking a shape.
+ * \since This function is available since SDL 2.0.0.
  *
  * \sa SDL_WindowShapeMode
  * \sa SDL_SetWindowShape
diff --git a/Engine/lib/sdl/include/SDL_stdinc.h b/Engine/lib/sdl/include/SDL_stdinc.h
index 91ccaa451..4554f9e71 100644
--- a/Engine/lib/sdl/include/SDL_stdinc.h
+++ b/Engine/lib/sdl/include/SDL_stdinc.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -115,6 +115,17 @@ char *alloca();
 # endif
 #endif
 
+/**
+ * Check if the compiler supports a given builtin.
+ * Supported by virtually all clang versions and recent gcc. Use this
+ * instead of checking the clang version if possible.
+ */
+#ifdef __has_builtin
+#define _SDL_HAS_BUILTIN(x) __has_builtin(x)
+#else
+#define _SDL_HAS_BUILTIN(x) 0
+#endif
+
 /**
  *  The number of elements in an array.
  */
@@ -223,7 +234,7 @@ typedef uint64_t Uint64;
 
 /* @} *//* Basic data types */
 
-/* Make sure we have macros for printing 64 bit values.
+/* Make sure we have macros for printing width-based integers.
  * <stdint.h> should define these but this is not true all platforms.
  * (for example win32) */
 #ifndef SDL_PRIs64
@@ -270,6 +281,34 @@ typedef uint64_t Uint64;
 #define SDL_PRIX64 "llX"
 #endif
 #endif
+#ifndef SDL_PRIs32
+#ifdef PRId32
+#define SDL_PRIs32 PRId32
+#else
+#define SDL_PRIs32 "d"
+#endif
+#endif
+#ifndef SDL_PRIu32
+#ifdef PRIu32
+#define SDL_PRIu32 PRIu32
+#else
+#define SDL_PRIu32 "u"
+#endif
+#endif
+#ifndef SDL_PRIx32
+#ifdef PRIx32
+#define SDL_PRIx32 PRIx32
+#else
+#define SDL_PRIx32 "x"
+#endif
+#endif
+#ifndef SDL_PRIX32
+#ifdef PRIX32
+#define SDL_PRIX32 PRIX32
+#else
+#define SDL_PRIX32 "X"
+#endif
+#endif
 
 /* Annotations to help code analysis tools */
 #ifdef SDL_DISABLE_ANALYZE_MACROS
@@ -315,8 +354,14 @@ typedef uint64_t Uint64;
 #endif
 #endif /* SDL_DISABLE_ANALYZE_MACROS */
 
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
+#define SDL_COMPILE_TIME_ASSERT(name, x) _Static_assert(x, #x);
+#elif defined(__cplusplus) && (__cplusplus >= 201103L)
+#define SDL_COMPILE_TIME_ASSERT(name, x)  static_assert(x, #x);
+#else /* universal, but may trigger -Wunused-local-typedefs */
 #define SDL_COMPILE_TIME_ASSERT(name, x)               \
        typedef int SDL_compile_time_assert_ ## name[(x) * 2 - 1]
+#endif
 /** \cond */
 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
 SDL_COMPILE_TIME_ASSERT(uint8, sizeof(Uint8) == 1);
@@ -338,7 +383,7 @@ SDL_COMPILE_TIME_ASSERT(sint64, sizeof(Sint64) == 8);
 
 /** \cond */
 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
-#if !defined(__ANDROID__)
+#if !defined(__ANDROID__) && !defined(__VITA__)
    /* TODO: include/SDL_stdinc.h:174: error: size of array 'SDL_dummy_enum' is negative */
 typedef enum
 {
@@ -375,7 +420,9 @@ typedef void *(SDLCALL *SDL_realloc_func)(void *mem, size_t size);
 typedef void (SDLCALL *SDL_free_func)(void *mem);
 
 /**
- *  \brief Get the current set of SDL memory functions
+ * Get the current set of SDL memory functions
+ *
+ * \since This function is available since SDL 2.0.7.
  */
 extern DECLSPEC void SDLCALL SDL_GetMemoryFunctions(SDL_malloc_func *malloc_func,
                                                     SDL_calloc_func *calloc_func,
@@ -383,12 +430,9 @@ extern DECLSPEC void SDLCALL SDL_GetMemoryFunctions(SDL_malloc_func *malloc_func
                                                     SDL_free_func *free_func);
 
 /**
- *  \brief Replace SDL's memory allocation functions with a custom set
+ * Replace SDL's memory allocation functions with a custom set
  *
- *  \note If you are replacing SDL's memory functions, you should call
- *        SDL_GetNumAllocations() and be very careful if it returns non-zero.
- *        That means that your free function will be called with memory
- *        allocated by the previous memory allocation functions.
+ * \since This function is available since SDL 2.0.7.
  */
 extern DECLSPEC int SDLCALL SDL_SetMemoryFunctions(SDL_malloc_func malloc_func,
                                                    SDL_calloc_func calloc_func,
@@ -396,7 +440,9 @@ extern DECLSPEC int SDLCALL SDL_SetMemoryFunctions(SDL_malloc_func malloc_func,
                                                    SDL_free_func free_func);
 
 /**
- *  \brief Get the number of outstanding (unfreed) allocations
+ * Get the number of outstanding (unfreed) allocations
+ *
+ * \since This function is available since SDL 2.0.7.
  */
 extern DECLSPEC int SDLCALL SDL_GetNumAllocations(void);
 
@@ -407,15 +453,23 @@ extern DECLSPEC void SDLCALL SDL_qsort(void *base, size_t nmemb, size_t size, in
 
 extern DECLSPEC int SDLCALL SDL_abs(int x);
 
-/* !!! FIXME: these have side effects. You probably shouldn't use them. */
-/* !!! FIXME: Maybe we do forceinline functions of SDL_mini, SDL_minf, etc? */
+/* NOTE: these double-evaluate their arguments, so you should never have side effects in the parameters */
 #define SDL_min(x, y) (((x) < (y)) ? (x) : (y))
 #define SDL_max(x, y) (((x) > (y)) ? (x) : (y))
+#define SDL_clamp(x, a, b) (((x) < (a)) ? (a) : (((x) > (b)) ? (b) : (x)))
 
+extern DECLSPEC int SDLCALL SDL_isalpha(int x);
+extern DECLSPEC int SDLCALL SDL_isalnum(int x);
+extern DECLSPEC int SDLCALL SDL_isblank(int x);
+extern DECLSPEC int SDLCALL SDL_iscntrl(int x);
 extern DECLSPEC int SDLCALL SDL_isdigit(int x);
+extern DECLSPEC int SDLCALL SDL_isxdigit(int x);
+extern DECLSPEC int SDLCALL SDL_ispunct(int x);
 extern DECLSPEC int SDLCALL SDL_isspace(int x);
 extern DECLSPEC int SDLCALL SDL_isupper(int x);
 extern DECLSPEC int SDLCALL SDL_islower(int x);
+extern DECLSPEC int SDLCALL SDL_isprint(int x);
+extern DECLSPEC int SDLCALL SDL_isgraph(int x);
 extern DECLSPEC int SDLCALL SDL_toupper(int x);
 extern DECLSPEC int SDLCALL SDL_tolower(int x);
 
@@ -432,7 +486,7 @@ SDL_FORCE_INLINE void SDL_memset4(void *dst, Uint32 val, size_t dwords)
 {
 #ifdef __APPLE__
     memset_pattern4(dst, &val, dwords * 4);
-#elif defined(__GNUC__) && defined(i386)
+#elif defined(__GNUC__) && defined(__i386__)
     int u0, u1, u2;
     __asm__ __volatile__ (
         "cld \n\t"
@@ -445,14 +499,14 @@ SDL_FORCE_INLINE void SDL_memset4(void *dst, Uint32 val, size_t dwords)
     size_t _n = (dwords + 3) / 4;
     Uint32 *_p = SDL_static_cast(Uint32 *, dst);
     Uint32 _val = (val);
-    if (dwords == 0)
+    if (dwords == 0) {
         return;
-    switch (dwords % 4)
-    {
-        case 0: do {    *_p++ = _val;   /* fallthrough */
-        case 3:         *_p++ = _val;   /* fallthrough */
-        case 2:         *_p++ = _val;   /* fallthrough */
-        case 1:         *_p++ = _val;   /* fallthrough */
+    }
+    switch (dwords % 4) {
+        case 0: do {    *_p++ = _val;   SDL_FALLTHROUGH;
+        case 3:         *_p++ = _val;   SDL_FALLTHROUGH;
+        case 2:         *_p++ = _val;   SDL_FALLTHROUGH;
+        case 1:         *_p++ = _val;
         } while ( --_n );
     }
 #endif
@@ -512,6 +566,8 @@ extern DECLSPEC int SDLCALL SDL_sscanf(const char *text, SDL_SCANF_FORMAT_STRING
 extern DECLSPEC int SDLCALL SDL_vsscanf(const char *text, const char *fmt, va_list ap);
 extern DECLSPEC int SDLCALL SDL_snprintf(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, SDL_PRINTF_FORMAT_STRING const char *fmt, ... ) SDL_PRINTF_VARARG_FUNC(3);
 extern DECLSPEC int SDLCALL SDL_vsnprintf(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, const char *fmt, va_list ap);
+extern DECLSPEC int SDLCALL SDL_asprintf(char **strp, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(2);
+extern DECLSPEC int SDLCALL SDL_vasprintf(char **strp, const char *fmt, va_list ap);
 
 #ifndef HAVE_M_PI
 #ifndef M_PI
@@ -519,14 +575,28 @@ extern DECLSPEC int SDLCALL SDL_vsnprintf(SDL_OUT_Z_CAP(maxlen) char *text, size
 #endif
 #endif
 
+/**
+ * Use this function to compute arc cosine of `x`.
+ *
+ * The definition of `y = acos(x)` is `x = cos(y)`.
+ *
+ * Domain: `-1 <= x <= 1`
+ *
+ * Range: `0 <= y <= Pi`
+ *
+ * \param x floating point value, in radians.
+ * \returns arc cosine of `x`.
+ *
+ * \since This function is available since SDL 2.0.2.
+ */
 extern DECLSPEC double SDLCALL SDL_acos(double x);
 extern DECLSPEC float SDLCALL SDL_acosf(float x);
 extern DECLSPEC double SDLCALL SDL_asin(double x);
 extern DECLSPEC float SDLCALL SDL_asinf(float x);
 extern DECLSPEC double SDLCALL SDL_atan(double x);
 extern DECLSPEC float SDLCALL SDL_atanf(float x);
-extern DECLSPEC double SDLCALL SDL_atan2(double x, double y);
-extern DECLSPEC float SDLCALL SDL_atan2f(float x, float y);
+extern DECLSPEC double SDLCALL SDL_atan2(double y, double x);
+extern DECLSPEC float SDLCALL SDL_atan2f(float y, float x);
 extern DECLSPEC double SDLCALL SDL_ceil(double x);
 extern DECLSPEC float SDLCALL SDL_ceilf(float x);
 extern DECLSPEC double SDLCALL SDL_copysign(double x, double y);
@@ -549,6 +619,10 @@ extern DECLSPEC double SDLCALL SDL_log10(double x);
 extern DECLSPEC float SDLCALL SDL_log10f(float x);
 extern DECLSPEC double SDLCALL SDL_pow(double x, double y);
 extern DECLSPEC float SDLCALL SDL_powf(float x, float y);
+extern DECLSPEC double SDLCALL SDL_round(double x);
+extern DECLSPEC float SDLCALL SDL_roundf(float x);
+extern DECLSPEC long SDLCALL SDL_lround(double x);
+extern DECLSPEC long SDLCALL SDL_lroundf(float x);
 extern DECLSPEC double SDLCALL SDL_scalbn(double x, int n);
 extern DECLSPEC float SDLCALL SDL_scalbnf(float x, int n);
 extern DECLSPEC double SDLCALL SDL_sin(double x);
@@ -572,9 +646,12 @@ extern DECLSPEC int SDLCALL SDL_iconv_close(SDL_iconv_t cd);
 extern DECLSPEC size_t SDLCALL SDL_iconv(SDL_iconv_t cd, const char **inbuf,
                                          size_t * inbytesleft, char **outbuf,
                                          size_t * outbytesleft);
+
 /**
- *  This function converts a string between encodings in one pass, returning a
- *  string that must be freed with SDL_free() or NULL on error.
+ * This function converts a string between encodings in one pass, returning a
+ * string that must be freed with SDL_free() or NULL on error.
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC char *SDLCALL SDL_iconv_string(const char *tocode,
                                                const char *fromcode,
@@ -583,6 +660,7 @@ extern DECLSPEC char *SDLCALL SDL_iconv_string(const char *tocode,
 #define SDL_iconv_utf8_locale(S)    SDL_iconv_string("", "UTF-8", S, SDL_strlen(S)+1)
 #define SDL_iconv_utf8_ucs2(S)      (Uint16 *)SDL_iconv_string("UCS-2-INTERNAL", "UTF-8", S, SDL_strlen(S)+1)
 #define SDL_iconv_utf8_ucs4(S)      (Uint32 *)SDL_iconv_string("UCS-4-INTERNAL", "UTF-8", S, SDL_strlen(S)+1)
+#define SDL_iconv_wchar_utf8(S)     SDL_iconv_string("UTF-8", "WCHAR_T", (char *)S, (SDL_wcslen(S)+1)*sizeof(wchar_t))
 
 /* force builds using Clang's static analysis tools to use literal C runtime
    here, since there are possibly tests that are ineffective otherwise. */
diff --git a/Engine/lib/sdl/include/SDL_surface.h b/Engine/lib/sdl/include/SDL_surface.h
index d3f8c814e..441237617 100644
--- a/Engine/lib/sdl/include/SDL_surface.h
+++ b/Engine/lib/sdl/include/SDL_surface.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -112,31 +112,108 @@ typedef enum
 } SDL_YUV_CONVERSION_MODE;
 
 /**
- *  Allocate and free an RGB surface.
+ * Allocate a new RGB surface.
  *
- *  If the depth is 4 or 8 bits, an empty palette is allocated for the surface.
- *  If the depth is greater than 8 bits, the pixel format is set using the
- *  flags '[RGB]mask'.
+ * If `depth` is 4 or 8 bits, an empty palette is allocated for the surface.
+ * If `depth` is greater than 8 bits, the pixel format is set using the
+ * [RGBA]mask parameters.
  *
- *  If the function runs out of memory, it will return NULL.
+ * The [RGBA]mask parameters are the bitmasks used to extract that color from
+ * a pixel. For instance, `Rmask` being 0xFF000000 means the red data is
+ * stored in the most significant byte. Using zeros for the RGB masks sets a
+ * default value, based on the depth. For example:
  *
- *  \param flags The \c flags are obsolete and should be set to 0.
- *  \param width The width in pixels of the surface to create.
- *  \param height The height in pixels of the surface to create.
- *  \param depth The depth in bits of the surface to create.
- *  \param Rmask The red mask of the surface to create.
- *  \param Gmask The green mask of the surface to create.
- *  \param Bmask The blue mask of the surface to create.
- *  \param Amask The alpha mask of the surface to create.
+ * ```c++
+ * SDL_CreateRGBSurface(0,w,h,32,0,0,0,0);
+ * ```
+ *
+ * However, using zero for the Amask results in an Amask of 0.
+ *
+ * By default surfaces with an alpha mask are set up for blending as with:
+ *
+ * ```c++
+ * SDL_SetSurfaceBlendMode(surface, SDL_BLENDMODE_BLEND)
+ * ```
+ *
+ * You can change this by calling SDL_SetSurfaceBlendMode() and selecting a
+ * different `blendMode`.
+ *
+ * \param flags the flags are unused and should be set to 0
+ * \param width the width of the surface
+ * \param height the height of the surface
+ * \param depth the depth of the surface in bits
+ * \param Rmask the red mask for the pixels
+ * \param Gmask the green mask for the pixels
+ * \param Bmask the blue mask for the pixels
+ * \param Amask the alpha mask for the pixels
+ * \returns the new SDL_Surface structure that is created or NULL if it fails;
+ *          call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateRGBSurfaceFrom
+ * \sa SDL_CreateRGBSurfaceWithFormat
+ * \sa SDL_FreeSurface
  */
 extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurface
     (Uint32 flags, int width, int height, int depth,
      Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
 
+
 /* !!! FIXME for 2.1: why does this ask for depth? Format provides that. */
+
+/**
+ * Allocate a new RGB surface with a specific pixel format.
+ *
+ * This function operates mostly like SDL_CreateRGBSurface(), except instead
+ * of providing pixel color masks, you provide it with a predefined format
+ * from SDL_PixelFormatEnum.
+ *
+ * \param flags the flags are unused and should be set to 0
+ * \param width the width of the surface
+ * \param height the height of the surface
+ * \param depth the depth of the surface in bits
+ * \param format the SDL_PixelFormatEnum for the new surface's pixel format.
+ * \returns the new SDL_Surface structure that is created or NULL if it fails;
+ *          call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.5.
+ *
+ * \sa SDL_CreateRGBSurface
+ * \sa SDL_CreateRGBSurfaceFrom
+ * \sa SDL_FreeSurface
+ */
 extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurfaceWithFormat
     (Uint32 flags, int width, int height, int depth, Uint32 format);
 
+/**
+ * Allocate a new RGB surface with existing pixel data.
+ *
+ * This function operates mostly like SDL_CreateRGBSurface(), except it does
+ * not allocate memory for the pixel data, instead the caller provides an
+ * existing buffer of data for the surface to use.
+ *
+ * No copy is made of the pixel data. Pixel data is not managed automatically;
+ * you must free the surface before you free the pixel data.
+ *
+ * \param pixels a pointer to existing pixel data
+ * \param width the width of the surface
+ * \param height the height of the surface
+ * \param depth the depth of the surface in bits
+ * \param pitch the pitch of the surface in bytes
+ * \param Rmask the red mask for the pixels
+ * \param Gmask the green mask for the pixels
+ * \param Bmask the blue mask for the pixels
+ * \param Amask the alpha mask for the pixels
+ * \returns the new SDL_Surface structure that is created or NULL if it fails;
+ *          call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateRGBSurface
+ * \sa SDL_CreateRGBSurfaceWithFormat
+ * \sa SDL_FreeSurface
+ */
 extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurfaceFrom(void *pixels,
                                                               int width,
                                                               int height,
@@ -146,74 +223,154 @@ extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurfaceFrom(void *pixels,
                                                               Uint32 Gmask,
                                                               Uint32 Bmask,
                                                               Uint32 Amask);
+
+/* !!! FIXME for 2.1: why does this ask for depth? Format provides that. */
+
+/**
+ * Allocate a new RGB surface with with a specific pixel format and existing
+ * pixel data.
+ *
+ * This function operates mostly like SDL_CreateRGBSurfaceFrom(), except
+ * instead of providing pixel color masks, you provide it with a predefined
+ * format from SDL_PixelFormatEnum.
+ *
+ * No copy is made of the pixel data. Pixel data is not managed automatically;
+ * you must free the surface before you free the pixel data.
+ *
+ * \param pixels a pointer to existing pixel data
+ * \param width the width of the surface
+ * \param height the height of the surface
+ * \param depth the depth of the surface in bits
+ * \param pitch the pitch of the surface in bytes
+ * \param format the SDL_PixelFormatEnum for the new surface's pixel format.
+ * \returns the new SDL_Surface structure that is created or NULL if it fails;
+ *          call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.5.
+ *
+ * \sa SDL_CreateRGBSurfaceFrom
+ * \sa SDL_CreateRGBSurfaceWithFormat
+ * \sa SDL_FreeSurface
+ */
 extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurfaceWithFormatFrom
     (void *pixels, int width, int height, int depth, int pitch, Uint32 format);
+
+/**
+ * Free an RGB surface.
+ *
+ * It is safe to pass NULL to this function.
+ *
+ * \param surface the SDL_Surface to free.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateRGBSurface
+ * \sa SDL_CreateRGBSurfaceFrom
+ * \sa SDL_LoadBMP
+ * \sa SDL_LoadBMP_RW
+ */
 extern DECLSPEC void SDLCALL SDL_FreeSurface(SDL_Surface * surface);
 
 /**
- *  \brief Set the palette used by a surface.
+ * Set the palette used by a surface.
  *
- *  \return 0, or -1 if the surface format doesn't use a palette.
+ * A single palette can be shared with many surfaces.
  *
- *  \note A single palette can be shared with many surfaces.
+ * \param surface the SDL_Surface structure to update
+ * \param palette the SDL_Palette structure to use
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC int SDLCALL SDL_SetSurfacePalette(SDL_Surface * surface,
                                                   SDL_Palette * palette);
 
 /**
- *  \brief Sets up a surface for directly accessing the pixels.
+ * Set up a surface for directly accessing the pixels.
  *
- *  Between calls to SDL_LockSurface() / SDL_UnlockSurface(), you can write
- *  to and read from \c surface->pixels, using the pixel format stored in
- *  \c surface->format.  Once you are done accessing the surface, you should
- *  use SDL_UnlockSurface() to release it.
+ * Between calls to SDL_LockSurface() / SDL_UnlockSurface(), you can write to
+ * and read from `surface->pixels`, using the pixel format stored in
+ * `surface->format`. Once you are done accessing the surface, you should use
+ * SDL_UnlockSurface() to release it.
  *
- *  Not all surfaces require locking.  If SDL_MUSTLOCK(surface) evaluates
- *  to 0, then you can read and write to the surface at any time, and the
- *  pixel format of the surface will not change.
+ * Not all surfaces require locking. If `SDL_MUSTLOCK(surface)` evaluates to
+ * 0, then you can read and write to the surface at any time, and the pixel
+ * format of the surface will not change.
  *
- *  No operating system or library calls should be made between lock/unlock
- *  pairs, as critical system locks may be held during this time.
+ * \param surface the SDL_Surface structure to be locked
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  SDL_LockSurface() returns 0, or -1 if the surface couldn't be locked.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_UnlockSurface()
+ * \sa SDL_MUSTLOCK
+ * \sa SDL_UnlockSurface
  */
 extern DECLSPEC int SDLCALL SDL_LockSurface(SDL_Surface * surface);
-/** \sa SDL_LockSurface() */
+
+/**
+ * Release a surface after directly accessing the pixels.
+ *
+ * \param surface the SDL_Surface structure to be unlocked
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_LockSurface
+ */
 extern DECLSPEC void SDLCALL SDL_UnlockSurface(SDL_Surface * surface);
 
 /**
- *  Load a surface from a seekable SDL data stream (memory or file).
+ * Load a BMP image from a seekable SDL data stream.
  *
- *  If \c freesrc is non-zero, the stream will be closed after being read.
+ * The new surface should be freed with SDL_FreeSurface(). Not doing so will
+ * result in a memory leak.
  *
- *  The new surface should be freed with SDL_FreeSurface().
+ * src is an open SDL_RWops buffer, typically loaded with SDL_RWFromFile.
+ * Alternitavely, you might also use the macro SDL_LoadBMP to load a bitmap
+ * from a file, convert it to an SDL_Surface and then close the file.
  *
- *  \return the new surface, or NULL if there was an error.
+ * \param src the data stream for the surface
+ * \param freesrc non-zero to close the stream after being read
+ * \returns a pointer to a new SDL_Surface structure or NULL if there was an
+ *          error; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_FreeSurface
+ * \sa SDL_RWFromFile
+ * \sa SDL_LoadBMP
+ * \sa SDL_SaveBMP_RW
  */
 extern DECLSPEC SDL_Surface *SDLCALL SDL_LoadBMP_RW(SDL_RWops * src,
                                                     int freesrc);
 
 /**
- *  Load a surface from a file.
+ * Load a surface from a file.
  *
- *  Convenience macro.
+ * Convenience macro.
  */
 #define SDL_LoadBMP(file)   SDL_LoadBMP_RW(SDL_RWFromFile(file, "rb"), 1)
 
 /**
- *  Save a surface to a seekable SDL data stream (memory or file).
+ * Save a surface to a seekable SDL data stream in BMP format.
  *
- *  Surfaces with a 24-bit, 32-bit and paletted 8-bit format get saved in the
- *  BMP directly. Other RGB formats with 8-bit or higher get converted to a
- *  24-bit surface or, if they have an alpha mask or a colorkey, to a 32-bit
- *  surface before they are saved. YUV and paletted 1-bit and 4-bit formats are
- *  not supported.
+ * Surfaces with a 24-bit, 32-bit and paletted 8-bit format get saved in the
+ * BMP directly. Other RGB formats with 8-bit or higher get converted to a
+ * 24-bit surface or, if they have an alpha mask or a colorkey, to a 32-bit
+ * surface before they are saved. YUV and paletted 1-bit and 4-bit formats are
+ * not supported.
  *
- *  If \c freedst is non-zero, the stream will be closed after being written.
+ * \param surface the SDL_Surface structure containing the image to be saved
+ * \param dst a data stream to save to
+ * \param freedst non-zero to close the stream after being written
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 if successful or -1 if there was an error.
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_LoadBMP_RW
+ * \sa SDL_SaveBMP
  */
 extern DECLSPEC int SDLCALL SDL_SaveBMP_RW
     (SDL_Surface * surface, SDL_RWops * dst, int freedst);
@@ -227,190 +384,335 @@ extern DECLSPEC int SDLCALL SDL_SaveBMP_RW
         SDL_SaveBMP_RW(surface, SDL_RWFromFile(file, "wb"), 1)
 
 /**
- *  \brief Sets the RLE acceleration hint for a surface.
+ * Set the RLE acceleration hint for a surface.
  *
- *  \return 0 on success, or -1 if the surface is not valid
+ * If RLE is enabled, color key and alpha blending blits are much faster, but
+ * the surface must be locked before directly accessing the pixels.
  *
- *  \note If RLE is enabled, colorkey and alpha blending blits are much faster,
- *        but the surface must be locked before directly accessing the pixels.
+ * \param surface the SDL_Surface structure to optimize
+ * \param flag 0 to disable, non-zero to enable RLE acceleration
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_BlitSurface
+ * \sa SDL_LockSurface
+ * \sa SDL_UnlockSurface
  */
 extern DECLSPEC int SDLCALL SDL_SetSurfaceRLE(SDL_Surface * surface,
                                               int flag);
 
 /**
- *  \brief Returns whether the surface is RLE enabled
+ * Returns whether the surface is RLE enabled
  *
- *  \return SDL_TRUE if the surface is RLE enabled, or SDL_FALSE if the surface is NULL or not RLE enabled
+ * It is safe to pass a NULL `surface` here; it will return SDL_FALSE.
+ *
+ * \param surface the SDL_Surface structure to query
+ * \returns SDL_TRUE if the surface is RLE enabled, SDL_FALSE otherwise.
+ *
+ * \since This function is available since SDL 2.0.14.
+ *
+ * \sa SDL_SetSurfaceRLE
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_HasSurfaceRLE(SDL_Surface * surface);
 
 /**
- *  \brief Sets the color key (transparent pixel) in a blittable surface.
+ * Set the color key (transparent pixel) in a surface.
  *
- *  \param surface The surface to update
- *  \param flag Non-zero to enable colorkey and 0 to disable colorkey
- *  \param key The transparent pixel in the native surface format
+ * The color key defines a pixel value that will be treated as transparent in
+ * a blit. For example, one can use this to specify that cyan pixels should be
+ * considered transparent, and therefore not rendered.
  *
- *  \return 0 on success, or -1 if the surface is not valid
+ * It is a pixel of the format used by the surface, as generated by
+ * SDL_MapRGB().
  *
- *  You can pass SDL_RLEACCEL to enable RLE accelerated blits.
+ * RLE acceleration can substantially speed up blitting of images with large
+ * horizontal runs of transparent pixels. See SDL_SetSurfaceRLE() for details.
+ *
+ * \param surface the SDL_Surface structure to update
+ * \param flag SDL_TRUE to enable color key, SDL_FALSE to disable color key
+ * \param key the transparent pixel
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_BlitSurface
+ * \sa SDL_GetColorKey
  */
 extern DECLSPEC int SDLCALL SDL_SetColorKey(SDL_Surface * surface,
                                             int flag, Uint32 key);
 
 /**
- *  \brief Returns whether the surface has a color key
+ * Returns whether the surface has a color key
  *
- *  \return SDL_TRUE if the surface has a color key, or SDL_FALSE if the surface is NULL or has no color key
+ * It is safe to pass a NULL `surface` here; it will return SDL_FALSE.
+ *
+ * \param surface the SDL_Surface structure to query
+ * \return SDL_TRUE if the surface has a color key, SDL_FALSE otherwise.
+ *
+ * \since This function is available since SDL 2.0.9.
+ *
+ * \sa SDL_SetColorKey
+ * \sa SDL_GetColorKey
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_HasColorKey(SDL_Surface * surface);
 
 /**
- *  \brief Gets the color key (transparent pixel) in a blittable surface.
+ * Get the color key (transparent pixel) for a surface.
  *
- *  \param surface The surface to update
- *  \param key A pointer filled in with the transparent pixel in the native
- *             surface format
+ * The color key is a pixel of the format used by the surface, as generated by
+ * SDL_MapRGB().
  *
- *  \return 0 on success, or -1 if the surface is not valid or colorkey is not
- *          enabled.
+ * If the surface doesn't have color key enabled this function returns -1.
+ *
+ * \param surface the SDL_Surface structure to query
+ * \param key a pointer filled in with the transparent pixel
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_BlitSurface
+ * \sa SDL_SetColorKey
  */
 extern DECLSPEC int SDLCALL SDL_GetColorKey(SDL_Surface * surface,
                                             Uint32 * key);
 
 /**
- *  \brief Set an additional color value used in blit operations.
+ * Set an additional color value multiplied into blit operations.
  *
- *  \param surface The surface to update.
- *  \param r The red color value multiplied into blit operations.
- *  \param g The green color value multiplied into blit operations.
- *  \param b The blue color value multiplied into blit operations.
+ * When this surface is blitted, during the blit operation each source color
+ * channel is modulated by the appropriate color value according to the
+ * following formula:
  *
- *  \return 0 on success, or -1 if the surface is not valid.
+ * `srcC = srcC * (color / 255)`
  *
- *  \sa SDL_GetSurfaceColorMod()
+ * \param surface the SDL_Surface structure to update
+ * \param r the red color value multiplied into blit operations
+ * \param g the green color value multiplied into blit operations
+ * \param b the blue color value multiplied into blit operations
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetSurfaceColorMod
+ * \sa SDL_SetSurfaceAlphaMod
  */
 extern DECLSPEC int SDLCALL SDL_SetSurfaceColorMod(SDL_Surface * surface,
                                                    Uint8 r, Uint8 g, Uint8 b);
 
 
 /**
- *  \brief Get the additional color value used in blit operations.
+ * Get the additional color value multiplied into blit operations.
  *
- *  \param surface The surface to query.
- *  \param r A pointer filled in with the current red color value.
- *  \param g A pointer filled in with the current green color value.
- *  \param b A pointer filled in with the current blue color value.
+ * \param surface the SDL_Surface structure to query
+ * \param r a pointer filled in with the current red color value
+ * \param g a pointer filled in with the current green color value
+ * \param b a pointer filled in with the current blue color value
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 if the surface is not valid.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_SetSurfaceColorMod()
+ * \sa SDL_GetSurfaceAlphaMod
+ * \sa SDL_SetSurfaceColorMod
  */
 extern DECLSPEC int SDLCALL SDL_GetSurfaceColorMod(SDL_Surface * surface,
                                                    Uint8 * r, Uint8 * g,
                                                    Uint8 * b);
 
 /**
- *  \brief Set an additional alpha value used in blit operations.
+ * Set an additional alpha value used in blit operations.
  *
- *  \param surface The surface to update.
- *  \param alpha The alpha value multiplied into blit operations.
+ * When this surface is blitted, during the blit operation the source alpha
+ * value is modulated by this alpha value according to the following formula:
  *
- *  \return 0 on success, or -1 if the surface is not valid.
+ * `srcA = srcA * (alpha / 255)`
  *
- *  \sa SDL_GetSurfaceAlphaMod()
+ * \param surface the SDL_Surface structure to update
+ * \param alpha the alpha value multiplied into blit operations
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetSurfaceAlphaMod
+ * \sa SDL_SetSurfaceColorMod
  */
 extern DECLSPEC int SDLCALL SDL_SetSurfaceAlphaMod(SDL_Surface * surface,
                                                    Uint8 alpha);
 
 /**
- *  \brief Get the additional alpha value used in blit operations.
+ * Get the additional alpha value used in blit operations.
  *
- *  \param surface The surface to query.
- *  \param alpha A pointer filled in with the current alpha value.
+ * \param surface the SDL_Surface structure to query
+ * \param alpha a pointer filled in with the current alpha value
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 if the surface is not valid.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_SetSurfaceAlphaMod()
+ * \sa SDL_GetSurfaceColorMod
+ * \sa SDL_SetSurfaceAlphaMod
  */
 extern DECLSPEC int SDLCALL SDL_GetSurfaceAlphaMod(SDL_Surface * surface,
                                                    Uint8 * alpha);
 
 /**
- *  \brief Set the blend mode used for blit operations.
+ * Set the blend mode used for blit operations.
  *
- *  \param surface The surface to update.
- *  \param blendMode ::SDL_BlendMode to use for blit blending.
+ * To copy a surface to another surface (or texture) without blending with the
+ * existing data, the blendmode of the SOURCE surface should be set to
+ * `SDL_BLENDMODE_NONE`.
  *
- *  \return 0 on success, or -1 if the parameters are not valid.
+ * \param surface the SDL_Surface structure to update
+ * \param blendMode the SDL_BlendMode to use for blit blending
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \sa SDL_GetSurfaceBlendMode()
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetSurfaceBlendMode
  */
 extern DECLSPEC int SDLCALL SDL_SetSurfaceBlendMode(SDL_Surface * surface,
                                                     SDL_BlendMode blendMode);
 
 /**
- *  \brief Get the blend mode used for blit operations.
+ * Get the blend mode used for blit operations.
  *
- *  \param surface   The surface to query.
- *  \param blendMode A pointer filled in with the current blend mode.
+ * \param surface the SDL_Surface structure to query
+ * \param blendMode a pointer filled in with the current SDL_BlendMode
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 if the surface is not valid.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_SetSurfaceBlendMode()
+ * \sa SDL_SetSurfaceBlendMode
  */
 extern DECLSPEC int SDLCALL SDL_GetSurfaceBlendMode(SDL_Surface * surface,
                                                     SDL_BlendMode *blendMode);
 
 /**
- *  Sets the clipping rectangle for the destination surface in a blit.
+ * Set the clipping rectangle for a surface.
  *
- *  If the clip rectangle is NULL, clipping will be disabled.
+ * When `surface` is the destination of a blit, only the area within the clip
+ * rectangle is drawn into.
  *
- *  If the clip rectangle doesn't intersect the surface, the function will
- *  return SDL_FALSE and blits will be completely clipped.  Otherwise the
- *  function returns SDL_TRUE and blits to the surface will be clipped to
- *  the intersection of the surface area and the clipping rectangle.
+ * Note that blits are automatically clipped to the edges of the source and
+ * destination surfaces.
  *
- *  Note that blits are automatically clipped to the edges of the source
- *  and destination surfaces.
+ * \param surface the SDL_Surface structure to be clipped
+ * \param rect the SDL_Rect structure representing the clipping rectangle, or
+ *             NULL to disable clipping
+ * \returns SDL_TRUE if the rectangle intersects the surface, otherwise
+ *          SDL_FALSE and blits will be completely clipped.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_BlitSurface
+ * \sa SDL_GetClipRect
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_SetClipRect(SDL_Surface * surface,
                                                  const SDL_Rect * rect);
 
 /**
- *  Gets the clipping rectangle for the destination surface in a blit.
+ * Get the clipping rectangle for a surface.
  *
- *  \c rect must be a pointer to a valid rectangle which will be filled
- *  with the correct values.
+ * When `surface` is the destination of a blit, only the area within the clip
+ * rectangle is drawn into.
+ *
+ * \param surface the SDL_Surface structure representing the surface to be
+ *                clipped
+ * \param rect an SDL_Rect structure filled in with the clipping rectangle for
+ *             the surface
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_BlitSurface
+ * \sa SDL_SetClipRect
  */
 extern DECLSPEC void SDLCALL SDL_GetClipRect(SDL_Surface * surface,
                                              SDL_Rect * rect);
 
 /*
- * Creates a new surface identical to the existing surface
+ * Creates a new surface identical to the existing surface.
+ *
+ * The returned surface should be freed with SDL_FreeSurface().
+ *
+ * \param surface the surface to duplicate.
+ * \returns a copy of the surface, or NULL on failure; call SDL_GetError() for
+ *          more information.
  */
 extern DECLSPEC SDL_Surface *SDLCALL SDL_DuplicateSurface(SDL_Surface * surface);
 
 /**
- *  Creates a new surface of the specified format, and then copies and maps
- *  the given surface to it so the blit of the converted surface will be as
- *  fast as possible.  If this function fails, it returns NULL.
+ * Copy an existing surface to a new surface of the specified format.
  *
- *  The \c flags parameter is passed to SDL_CreateRGBSurface() and has those
- *  semantics.  You can also pass ::SDL_RLEACCEL in the flags parameter and
- *  SDL will try to RLE accelerate colorkey and alpha blits in the resulting
- *  surface.
+ * This function is used to optimize images for faster *repeat* blitting. This
+ * is accomplished by converting the original and storing the result as a new
+ * surface. The new, optimized surface can then be used as the source for
+ * future blits, making them faster.
+ *
+ * \param src the existing SDL_Surface structure to convert
+ * \param fmt the SDL_PixelFormat structure that the new surface is optimized
+ *            for
+ * \param flags the flags are unused and should be set to 0; this is a
+ *              leftover from SDL 1.2's API
+ * \returns the new SDL_Surface structure that is created or NULL if it fails;
+ *          call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_AllocFormat
+ * \sa SDL_ConvertSurfaceFormat
+ * \sa SDL_CreateRGBSurface
  */
 extern DECLSPEC SDL_Surface *SDLCALL SDL_ConvertSurface
     (SDL_Surface * src, const SDL_PixelFormat * fmt, Uint32 flags);
+
+/**
+ * Copy an existing surface to a new surface of the specified format enum.
+ *
+ * This function operates just like SDL_ConvertSurface(), but accepts an
+ * SDL_PixelFormatEnum value instead of an SDL_PixelFormat structure. As such,
+ * it might be easier to call but it doesn't have access to palette
+ * information for the destination surface, in case that would be important.
+ *
+ * \param src the existing SDL_Surface structure to convert
+ * \param pixel_format the SDL_PixelFormatEnum that the new surface is
+ *                     optimized for
+ * \param flags the flags are unused and should be set to 0; this is a
+ *              leftover from SDL 1.2's API
+ * \returns the new SDL_Surface structure that is created or NULL if it fails;
+ *          call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_AllocFormat
+ * \sa SDL_ConvertSurface
+ * \sa SDL_CreateRGBSurface
+ */
 extern DECLSPEC SDL_Surface *SDLCALL SDL_ConvertSurfaceFormat
     (SDL_Surface * src, Uint32 pixel_format, Uint32 flags);
 
 /**
- * \brief Copy a block of pixels of one format to another format
+ * Copy a block of pixels of one format to another format.
  *
- *  \return 0 on success, or -1 if there was an error
+ * \param width the width of the block to copy, in pixels
+ * \param height the height of the block to copy, in pixels
+ * \param src_format an SDL_PixelFormatEnum value of the `src` pixels format
+ * \param src a pointer to the source pixels
+ * \param src_pitch the pitch of the source pixels, in bytes
+ * \param dst_format an SDL_PixelFormatEnum value of the `dst` pixels format
+ * \param dst a pointer to be filled in with new pixel data
+ * \param dst_pitch the pitch of the destination pixels, in bytes
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC int SDLCALL SDL_ConvertPixels(int width, int height,
                                               Uint32 src_format,
@@ -419,20 +721,84 @@ extern DECLSPEC int SDLCALL SDL_ConvertPixels(int width, int height,
                                               void * dst, int dst_pitch);
 
 /**
- *  Performs a fast fill of the given rectangle with \c color.
+ * Premultiply the alpha on a block of pixels.
  *
- *  If \c rect is NULL, the whole surface will be filled with \c color.
+ * This is safe to use with src == dst, but not for other overlapping areas.
  *
- *  The color should be a pixel of the format used by the surface, and
- *  can be generated by the SDL_MapRGB() function.
+ * This function is currently only implemented for SDL_PIXELFORMAT_ARGB8888.
  *
- *  \return 0 on success, or -1 on error.
+ * \param width the width of the block to convert, in pixels
+ * \param height the height of the block to convert, in pixels
+ * \param src_format an SDL_PixelFormatEnum value of the `src` pixels format
+ * \param src a pointer to the source pixels
+ * \param src_pitch the pitch of the source pixels, in bytes
+ * \param dst_format an SDL_PixelFormatEnum value of the `dst` pixels format
+ * \param dst a pointer to be filled in with premultiplied pixel data
+ * \param dst_pitch the pitch of the destination pixels, in bytes
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.18.
+ */
+extern DECLSPEC int SDLCALL SDL_PremultiplyAlpha(int width, int height,
+                                                 Uint32 src_format,
+                                                 const void * src, int src_pitch,
+                                                 Uint32 dst_format,
+                                                 void * dst, int dst_pitch);
+
+/**
+ * Perform a fast fill of a rectangle with a specific color.
+ *
+ * `color` should be a pixel of the format used by the surface, and can be
+ * generated by SDL_MapRGB() or SDL_MapRGBA(). If the color value contains an
+ * alpha component then the destination is simply filled with that alpha
+ * information, no blending takes place.
+ *
+ * If there is a clip rectangle set on the destination (set via
+ * SDL_SetClipRect()), then this function will fill based on the intersection
+ * of the clip rectangle and `rect`.
+ *
+ * \param dst the SDL_Surface structure that is the drawing target
+ * \param rect the SDL_Rect structure representing the rectangle to fill, or
+ *             NULL to fill the entire surface
+ * \param color the color to fill with
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_FillRects
  */
 extern DECLSPEC int SDLCALL SDL_FillRect
     (SDL_Surface * dst, const SDL_Rect * rect, Uint32 color);
+
+/**
+ * Perform a fast fill of a set of rectangles with a specific color.
+ *
+ * `color` should be a pixel of the format used by the surface, and can be
+ * generated by SDL_MapRGB() or SDL_MapRGBA(). If the color value contains an
+ * alpha component then the destination is simply filled with that alpha
+ * information, no blending takes place.
+ *
+ * If there is a clip rectangle set on the destination (set via
+ * SDL_SetClipRect()), then this function will fill based on the intersection
+ * of the clip rectangle and `rect`.
+ *
+ * \param dst the SDL_Surface structure that is the drawing target
+ * \param rects an array of SDL_Rects representing the rectangles to fill.
+ * \param count the number of rectangles in the array
+ * \param color the color to fill with
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_FillRect
+ */
 extern DECLSPEC int SDLCALL SDL_FillRects
     (SDL_Surface * dst, const SDL_Rect * rects, int count, Uint32 color);
 
+/* !!! FIXME: merge this documentation with the wiki */
 /**
  *  Performs a fast blit from the source surface to the destination surface.
  *
@@ -441,7 +807,7 @@ extern DECLSPEC int SDLCALL SDL_FillRects
  *  surface (\c src or \c dst) is copied.  The final blit rectangles are saved
  *  in \c srcrect and \c dstrect after all clipping is performed.
  *
- *  \return If the blit is successful, it returns 0, otherwise it returns -1.
+ *  \returns 0 if the blit is successful, otherwise it returns -1.
  *
  *  The blit function should not be called on a locked surface.
  *
@@ -493,62 +859,128 @@ extern DECLSPEC int SDLCALL SDL_FillRects
 #define SDL_BlitSurface SDL_UpperBlit
 
 /**
- *  This is the public blit function, SDL_BlitSurface(), and it performs
- *  rectangle validation and clipping before passing it to SDL_LowerBlit()
+ * Perform a fast blit from the source surface to the destination surface.
+ *
+ * SDL_UpperBlit() has been replaced by SDL_BlitSurface(), which is merely a
+ * macro for this function with a less confusing name.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_BlitSurface
  */
 extern DECLSPEC int SDLCALL SDL_UpperBlit
     (SDL_Surface * src, const SDL_Rect * srcrect,
      SDL_Surface * dst, SDL_Rect * dstrect);
 
 /**
- *  This is a semi-private blit function and it performs low-level surface
- *  blitting only.
+ * Perform low-level surface blitting only.
+ *
+ * This is a semi-private blit function and it performs low-level surface
+ * blitting, assuming the input rectangles have already been clipped.
+ *
+ * Unless you know what you're doing, you should be using SDL_BlitSurface()
+ * instead.
+ *
+ * \param src the SDL_Surface structure to be copied from
+ * \param srcrect the SDL_Rect structure representing the rectangle to be
+ *                copied, or NULL to copy the entire surface
+ * \param dst the SDL_Surface structure that is the blit target
+ * \param dstrect the SDL_Rect structure representing the rectangle that is
+ *                copied into
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_BlitSurface
  */
 extern DECLSPEC int SDLCALL SDL_LowerBlit
     (SDL_Surface * src, SDL_Rect * srcrect,
      SDL_Surface * dst, SDL_Rect * dstrect);
 
+
 /**
- *  \brief Perform a fast, low quality, stretch blit between two surfaces of the
- *         same pixel format.
+ * Perform a fast, low quality, stretch blit between two surfaces of the same
+ * format.
  *
- *  \note This function uses a static buffer, and is not thread-safe.
+ * Please use SDL_BlitScaled() instead.
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC int SDLCALL SDL_SoftStretch(SDL_Surface * src,
                                             const SDL_Rect * srcrect,
                                             SDL_Surface * dst,
                                             const SDL_Rect * dstrect);
 
+/**
+ * Perform bilinear scaling between two surfaces of the same format, 32BPP.
+ *
+ * \since This function is available since SDL 2.0.16.
+ */
+extern DECLSPEC int SDLCALL SDL_SoftStretchLinear(SDL_Surface * src,
+                                            const SDL_Rect * srcrect,
+                                            SDL_Surface * dst,
+                                            const SDL_Rect * dstrect);
+
+
 #define SDL_BlitScaled SDL_UpperBlitScaled
 
 /**
- *  This is the public scaled blit function, SDL_BlitScaled(), and it performs
- *  rectangle validation and clipping before passing it to SDL_LowerBlitScaled()
+ * Perform a scaled surface copy to a destination surface.
+ *
+ * SDL_UpperBlitScaled() has been replaced by SDL_BlitScaled(), which is
+ * merely a macro for this function with a less confusing name.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_BlitScaled
  */
 extern DECLSPEC int SDLCALL SDL_UpperBlitScaled
     (SDL_Surface * src, const SDL_Rect * srcrect,
     SDL_Surface * dst, SDL_Rect * dstrect);
 
 /**
- *  This is a semi-private blit function and it performs low-level surface
- *  scaled blitting only.
+ * Perform low-level surface scaled blitting only.
+ *
+ * This is a semi-private function and it performs low-level surface blitting,
+ * assuming the input rectangles have already been clipped.
+ *
+ * \param src the SDL_Surface structure to be copied from
+ * \param srcrect the SDL_Rect structure representing the rectangle to be
+ *                copied
+ * \param dst the SDL_Surface structure that is the blit target
+ * \param dstrect the SDL_Rect structure representing the rectangle that is
+ *                copied into
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_BlitScaled
  */
 extern DECLSPEC int SDLCALL SDL_LowerBlitScaled
     (SDL_Surface * src, SDL_Rect * srcrect,
     SDL_Surface * dst, SDL_Rect * dstrect);
 
 /**
- *  \brief Set the YUV conversion mode
+ * Set the YUV conversion mode
+ *
+ * \since This function is available since SDL 2.0.8.
  */
 extern DECLSPEC void SDLCALL SDL_SetYUVConversionMode(SDL_YUV_CONVERSION_MODE mode);
 
 /**
- *  \brief Get the YUV conversion mode
+ * Get the YUV conversion mode
+ *
+ * \since This function is available since SDL 2.0.8.
  */
 extern DECLSPEC SDL_YUV_CONVERSION_MODE SDLCALL SDL_GetYUVConversionMode(void);
 
 /**
- *  \brief Get the YUV conversion mode, returning the correct mode for the resolution when the current conversion mode is SDL_YUV_CONVERSION_AUTOMATIC
+ * Get the YUV conversion mode, returning the correct mode for the resolution
+ * when the current conversion mode is SDL_YUV_CONVERSION_AUTOMATIC
+ *
+ * \since This function is available since SDL 2.0.8.
  */
 extern DECLSPEC SDL_YUV_CONVERSION_MODE SDLCALL SDL_GetYUVConversionModeForResolution(int width, int height);
 
diff --git a/Engine/lib/sdl/include/SDL_system.h b/Engine/lib/sdl/include/SDL_system.h
index d296ab1fc..41563add4 100644
--- a/Engine/lib/sdl/include/SDL_system.h
+++ b/Engine/lib/sdl/include/SDL_system.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -43,33 +43,82 @@ extern "C" {
 /* Platform specific functions for Windows */
 #ifdef __WIN32__
 	
-/**
-   \brief Set a function that is called for every windows message, before TranslateMessage()
-*/
 typedef void (SDLCALL * SDL_WindowsMessageHook)(void *userdata, void *hWnd, unsigned int message, Uint64 wParam, Sint64 lParam);
+
+/**
+ * Set a callback for every Windows message, run before TranslateMessage().
+ *
+ * \param callback The SDL_WindowsMessageHook function to call.
+ * \param userdata a pointer to pass to every iteration of `callback`
+ *
+ * \since This function is available since SDL 2.0.4.
+ */
 extern DECLSPEC void SDLCALL SDL_SetWindowsMessageHook(SDL_WindowsMessageHook callback, void *userdata);
 
 /**
-   \brief Returns the D3D9 adapter index that matches the specified display index.
-
-   This adapter index can be passed to IDirect3D9::CreateDevice and controls
-   on which monitor a full screen application will appear.
-*/
+ * Get the D3D9 adapter index that matches the specified display index.
+ *
+ * The returned adapter index can be passed to `IDirect3D9::CreateDevice` and
+ * controls on which monitor a full screen application will appear.
+ *
+ * \param displayIndex the display index for which to get the D3D9 adapter
+ *                     index
+ * \returns the D3D9 adapter index on success or a negative error code on
+ *          failure; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.1.
+ */
 extern DECLSPEC int SDLCALL SDL_Direct3D9GetAdapterIndex( int displayIndex );
 
 typedef struct IDirect3DDevice9 IDirect3DDevice9;
-/**
-   \brief Returns the D3D device associated with a renderer, or NULL if it's not a D3D renderer.
 
-   Once you are done using the device, you should release it to avoid a resource leak.
+/**
+ * Get the D3D9 device associated with a renderer.
+ *
+ * Once you are done using the device, you should release it to avoid a
+ * resource leak.
+ *
+ * \param renderer the renderer from which to get the associated D3D device
+ * \returns the D3D9 device associated with given renderer or NULL if it is
+ *          not a D3D9 renderer; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.1.
  */
 extern DECLSPEC IDirect3DDevice9* SDLCALL SDL_RenderGetD3D9Device(SDL_Renderer * renderer);
 
-/**
-   \brief Returns the DXGI Adapter and Output indices for the specified display index.
+typedef struct ID3D11Device ID3D11Device;
 
-   These can be passed to EnumAdapters and EnumOutputs respectively to get the objects
-   required to create a DX10 or DX11 device and swap chain.
+/**
+ * Get the D3D11 device associated with a renderer.
+ *
+ * Once you are done using the device, you should release it to avoid a
+ * resource leak.
+ *
+ * \param renderer the renderer from which to get the associated D3D11 device
+ * \returns the D3D11 device associated with given renderer or NULL if it is
+ *          not a D3D11 renderer; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.16.
+ */
+extern DECLSPEC ID3D11Device* SDLCALL SDL_RenderGetD3D11Device(SDL_Renderer * renderer);
+
+/**
+ * Get the DXGI Adapter and Output indices for the specified display index.
+ *
+ * The DXGI Adapter and Output indices can be passed to `EnumAdapters` and
+ * `EnumOutputs` respectively to get the objects required to create a DX10 or
+ * DX11 device and swap chain.
+ *
+ * Before SDL 2.0.4 this function did not return a value. Since SDL 2.0.4 it
+ * returns an SDL_bool.
+ *
+ * \param displayIndex the display index for which to get both indices
+ * \param adapterIndex a pointer to be filled in with the adapter index
+ * \param outputIndex a pointer to be filled in with the output index
+ * \returns SDL_TRUE on success or SDL_FALSE on failure; call SDL_GetError()
+ *          for more information.
+ *
+ * \since This function is available since SDL 2.0.2.
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_DXGIGetOutputInfo( int displayIndex, int *adapterIndex, int *outputIndex );
 
@@ -80,11 +129,32 @@ extern DECLSPEC SDL_bool SDLCALL SDL_DXGIGetOutputInfo( int displayIndex, int *a
 #ifdef __LINUX__
 
 /**
-   \brief Sets the UNIX nice value for a thread, using setpriority() if possible, and RealtimeKit if available.
-
-   \return 0 on success, or -1 on error.
+ * Sets the UNIX nice value for a thread.
+ *
+ * This uses setpriority() if possible, and RealtimeKit if available.
+ *
+ * \param threadID the Unix thread ID to change priority of.
+ * \param priority The new, Unix-specific, priority value.
+ * \returns 0 on success, or -1 on error.
+ *
+ * \since This function is available since SDL 2.0.9.
  */
 extern DECLSPEC int SDLCALL SDL_LinuxSetThreadPriority(Sint64 threadID, int priority);
+
+/**
+ * Sets the priority (not nice level) and scheduling policy for a thread.
+ *
+ * This uses setpriority() if possible, and RealtimeKit if available.
+ *
+ * \param threadID The Unix thread ID to change priority of.
+ * \param sdlPriority The new SDL_ThreadPriority value.
+ * \param schedPolicy The new scheduling policy (SCHED_FIFO, SCHED_RR,
+ *                    SCHED_OTHER, etc...)
+ * \returns 0 on success, or -1 on error.
+ *
+ * \since This function is available since SDL 2.0.18.
+ */
+extern DECLSPEC int SDLCALL SDL_LinuxSetThreadPriorityAndPolicy(Sint64 threadID, int sdlPriority, int schedPolicy);
  
 #endif /* __LINUX__ */
 	
@@ -92,9 +162,57 @@ extern DECLSPEC int SDLCALL SDL_LinuxSetThreadPriority(Sint64 threadID, int prio
 #ifdef __IPHONEOS__
 
 #define SDL_iOSSetAnimationCallback(window, interval, callback, callbackParam) SDL_iPhoneSetAnimationCallback(window, interval, callback, callbackParam)
+
+/**
+ * Use this function to set the animation callback on Apple iOS.
+ *
+ * The function prototype for `callback` is:
+ *
+ * ```c
+ * void callback(void* callbackParam);
+ * ```
+ *
+ * Where its parameter, `callbackParam`, is what was passed as `callbackParam`
+ * to SDL_iPhoneSetAnimationCallback().
+ *
+ * This function is only available on Apple iOS.
+ *
+ * For more information see:
+ * [README-ios.md](https://hg.libsdl.org/SDL/file/default/docs/README-ios.md)
+ *
+ * This functions is also accessible using the macro
+ * SDL_iOSSetAnimationCallback() since SDL 2.0.4.
+ *
+ * \param window the window for which the animation callback should be set
+ * \param interval the number of frames after which **callback** will be
+ *                 called
+ * \param callback the function to call for every frame.
+ * \param callbackParam a pointer that is passed to `callback`.
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_iPhoneSetEventPump
+ */
 extern DECLSPEC int SDLCALL SDL_iPhoneSetAnimationCallback(SDL_Window * window, int interval, void (*callback)(void*), void *callbackParam);
 
 #define SDL_iOSSetEventPump(enabled) SDL_iPhoneSetEventPump(enabled)
+
+/**
+ * Use this function to enable or disable the SDL event pump on Apple iOS.
+ *
+ * This function is only available on Apple iOS.
+ *
+ * This functions is also accessible using the macro SDL_iOSSetEventPump()
+ * since SDL 2.0.4.
+ *
+ * \param enabled SDL_TRUE to enable the event pump, SDL_FALSE to disable it
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_iPhoneSetAnimationCallback
+ */
 extern DECLSPEC void SDLCALL SDL_iPhoneSetEventPump(SDL_bool enabled);
 
 #endif /* __IPHONEOS__ */
@@ -104,66 +222,109 @@ extern DECLSPEC void SDLCALL SDL_iPhoneSetEventPump(SDL_bool enabled);
 #ifdef __ANDROID__
 
 /**
-   \brief Get the JNI environment for the current thread
-
-   This returns JNIEnv*, but the prototype is void* so we don't need jni.h
+ * Get the Android Java Native Interface Environment of the current thread.
+ *
+ * This is the JNIEnv one needs to access the Java virtual machine from native
+ * code, and is needed for many Android APIs to be usable from C.
+ *
+ * The prototype of the function in SDL's code actually declare a void* return
+ * type, even if the implementation returns a pointer to a JNIEnv. The
+ * rationale being that the SDL headers can avoid including jni.h.
+ *
+ * \returns a pointer to Java native interface object (JNIEnv) to which the
+ *          current thread is attached, or 0 on error.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_AndroidGetActivity
  */
 extern DECLSPEC void * SDLCALL SDL_AndroidGetJNIEnv(void);
 
 /**
-   \brief Get the SDL Activity object for the application
-
-   This returns jobject, but the prototype is void* so we don't need jni.h
-   The jobject returned by SDL_AndroidGetActivity is a local reference.
-   It is the caller's responsibility to properly release it
-   (using env->Push/PopLocalFrame or manually with env->DeleteLocalRef)
+ * Retrieve the Java instance of the Android activity class.
+ *
+ * The prototype of the function in SDL's code actually declares a void*
+ * return type, even if the implementation returns a jobject. The rationale
+ * being that the SDL headers can avoid including jni.h.
+ *
+ * The jobject returned by the function is a local reference and must be
+ * released by the caller. See the PushLocalFrame() and PopLocalFrame() or
+ * DeleteLocalRef() functions of the Java native interface:
+ *
+ * https://docs.oracle.com/javase/1.5.0/docs/guide/jni/spec/functions.html
+ *
+ * \returns the jobject representing the instance of the Activity class of the
+ *          Android application, or NULL on error.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_AndroidGetJNIEnv
  */
 extern DECLSPEC void * SDLCALL SDL_AndroidGetActivity(void);
 
 /**
-   \brief Return API level of the current device
-
-    API level 30: Android 11
-    API level 29: Android 10
-    API level 28: Android 9
-    API level 27: Android 8.1
-    API level 26: Android 8.0
-    API level 25: Android 7.1
-    API level 24: Android 7.0
-    API level 23: Android 6.0
-    API level 22: Android 5.1
-    API level 21: Android 5.0
-    API level 20: Android 4.4W
-    API level 19: Android 4.4
-    API level 18: Android 4.3
-    API level 17: Android 4.2
-    API level 16: Android 4.1
-    API level 15: Android 4.0.3
-    API level 14: Android 4.0
-    API level 13: Android 3.2
-    API level 12: Android 3.1
-    API level 11: Android 3.0
-    API level 10: Android 2.3.3
+ * Query Android API level of the current device.
+ *
+ * - API level 31: Android 12
+ * - API level 30: Android 11
+ * - API level 29: Android 10
+ * - API level 28: Android 9
+ * - API level 27: Android 8.1
+ * - API level 26: Android 8.0
+ * - API level 25: Android 7.1
+ * - API level 24: Android 7.0
+ * - API level 23: Android 6.0
+ * - API level 22: Android 5.1
+ * - API level 21: Android 5.0
+ * - API level 20: Android 4.4W
+ * - API level 19: Android 4.4
+ * - API level 18: Android 4.3
+ * - API level 17: Android 4.2
+ * - API level 16: Android 4.1
+ * - API level 15: Android 4.0.3
+ * - API level 14: Android 4.0
+ * - API level 13: Android 3.2
+ * - API level 12: Android 3.1
+ * - API level 11: Android 3.0
+ * - API level 10: Android 2.3.3
+ *
+ * \returns the Android API level.
+ *
+ * \since This function is available since SDL 2.0.12.
  */
 extern DECLSPEC int SDLCALL SDL_GetAndroidSDKVersion(void);
 
 /**
-   \brief Return true if the application is running on Android TV
+ * Query if the application is running on Android TV.
+ *
+ * \returns SDL_TRUE if this is Android TV, SDL_FALSE otherwise.
+ *
+ * \since This function is available since SDL 2.0.8.
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_IsAndroidTV(void);
 
 /**
-   \brief Return true if the application is running on a Chromebook
+ * Query if the application is running on a Chromebook.
+ *
+ * \returns SDL_TRUE if this is a Chromebook, SDL_FALSE otherwise.
+ *
+ * \since This function is available since SDL 2.0.9.
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_IsChromebook(void);
 
 /**
-  \brief Return true is the application is running on a Samsung DeX docking station
+ * Query if the application is running on a Samsung DeX docking station.
+ *
+ * \returns SDL_TRUE if this is a DeX docking station, SDL_FALSE otherwise.
+ *
+ * \since This function is available since SDL 2.0.9.
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_IsDeXMode(void);
 
 /**
- \brief Trigger the Android system back button behavior.
+ * Trigger the Android system back button behavior.
+ *
+ * \since This function is available since SDL 2.0.9.
  */
 extern DECLSPEC void SDLCALL SDL_AndroidBackButton(void);
 
@@ -175,38 +336,107 @@ extern DECLSPEC void SDLCALL SDL_AndroidBackButton(void);
 #define SDL_ANDROID_EXTERNAL_STORAGE_WRITE  0x02
 
 /**
-   \brief Get the path used for internal storage for this application.
-
-   This path is unique to your application and cannot be written to
-   by other applications.
+ * Get the path used for internal storage for this application.
+ *
+ * This path is unique to your application and cannot be written to by other
+ * applications.
+ *
+ * Your internal storage path is typically:
+ * `/data/data/your.app.package/files`.
+ *
+ * \returns the path used for internal storage or NULL on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_AndroidGetExternalStorageState
  */
 extern DECLSPEC const char * SDLCALL SDL_AndroidGetInternalStoragePath(void);
 
 /**
-   \brief Get the current state of external storage, a bitmask of these values:
-    SDL_ANDROID_EXTERNAL_STORAGE_READ
-    SDL_ANDROID_EXTERNAL_STORAGE_WRITE
-
-   If external storage is currently unavailable, this will return 0.
-*/
+ * Get the current state of external storage.
+ *
+ * The current state of external storage, a bitmask of these values:
+ * `SDL_ANDROID_EXTERNAL_STORAGE_READ`, `SDL_ANDROID_EXTERNAL_STORAGE_WRITE`.
+ *
+ * If external storage is currently unavailable, this will return 0.
+ *
+ * \returns the current state of external storage on success or 0 on failure;
+ *          call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_AndroidGetExternalStoragePath
+ */
 extern DECLSPEC int SDLCALL SDL_AndroidGetExternalStorageState(void);
 
 /**
-   \brief Get the path used for external storage for this application.
-
-   This path is unique to your application, but is public and can be
-   written to by other applications.
+ * Get the path used for external storage for this application.
+ *
+ * This path is unique to your application, but is public and can be written
+ * to by other applications.
+ *
+ * Your external storage path is typically:
+ * `/storage/sdcard0/Android/data/your.app.package/files`.
+ *
+ * \returns the path used for external storage for this application on success
+ *          or NULL on failure; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_AndroidGetExternalStorageState
  */
 extern DECLSPEC const char * SDLCALL SDL_AndroidGetExternalStoragePath(void);
 
 /**
-   \brief Request permissions at runtime.
-
-   This blocks the calling thread until the permission is granted or
-   denied. Returns SDL_TRUE if the permission was granted.
+ * Request permissions at runtime.
+ *
+ * This blocks the calling thread until the permission is granted or denied.
+ *
+ * \param permission The permission to request.
+ * \returns SDL_TRUE if the permission was granted, SDL_FALSE otherwise.
+ *
+ * \since This function is available since SDL 2.0.14.
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_AndroidRequestPermission(const char *permission);
 
+/**
+ * Shows an Android toast notification.
+ *
+ * Toasts are a sort of lightweight notification that are unique to Android.
+ *
+ * https://developer.android.com/guide/topics/ui/notifiers/toasts
+ *
+ * Shows toast in UI thread.
+ *
+ * For the `gravity` parameter, choose a value from here, or -1 if you don't
+ * have a preference:
+ *
+ * https://developer.android.com/reference/android/view/Gravity
+ *
+ * \param message text message to be shown
+ * \param duration 0=short, 1=long
+ * \param gravity where the notification should appear on the screen.
+ * \param xoffset set this parameter only when gravity >=0
+ * \param yoffset set this parameter only when gravity >=0
+ * \returns 0 if success, -1 if any error occurs.
+ *
+ * \since This function is available since SDL 2.0.16.
+ */
+extern DECLSPEC int SDLCALL SDL_AndroidShowToast(const char* message, int duration, int gravity, int xoffset, int yoffset);
+
+/**
+ * Send a user command to SDLActivity.
+ *
+ * Override "boolean onUnhandledMessage(Message msg)" to handle the message.
+ *
+ * \param command user command that must be greater or equal to 0x8000
+ * \param param user parameter
+ *
+ * \since This function is available since SDL 2.0.22.
+ */
+extern DECLSPEC int SDLCALL SDL_AndroidSendMessage(Uint32 command, int param);
+
 #endif /* __ANDROID__ */
 
 /* Platform specific functions for WinRT */
@@ -256,50 +486,70 @@ typedef enum
 
 
 /**
- *  \brief Retrieves a WinRT defined path on the local file system
+ * Retrieve a WinRT defined path on the local file system.
  *
- *  \note Documentation on most app-specific path types on WinRT
- *      can be found on MSDN, at the URL:
- *      http://msdn.microsoft.com/en-us/library/windows/apps/hh464917.aspx
+ * Not all paths are available on all versions of Windows. This is especially
+ * true on Windows Phone. Check the documentation for the given SDL_WinRT_Path
+ * for more information on which path types are supported where.
  *
- *  \param pathType The type of path to retrieve.
- *  \return A UCS-2 string (16-bit, wide-char) containing the path, or NULL
- *      if the path is not available for any reason.  Not all paths are
- *      available on all versions of Windows.  This is especially true on
- *      Windows Phone.  Check the documentation for the given
- *      SDL_WinRT_Path for more information on which path types are
- *      supported where.
+ * Documentation on most app-specific path types on WinRT can be found on
+ * MSDN, at the URL:
+ *
+ * https://msdn.microsoft.com/en-us/library/windows/apps/hh464917.aspx
+ *
+ * \param pathType the type of path to retrieve, one of SDL_WinRT_Path
+ * \returns a UCS-2 string (16-bit, wide-char) containing the path, or NULL if
+ *          the path is not available for any reason; call SDL_GetError() for
+ *          more information.
+ *
+ * \since This function is available since SDL 2.0.3.
+ *
+ * \sa SDL_WinRTGetFSPathUTF8
  */
 extern DECLSPEC const wchar_t * SDLCALL SDL_WinRTGetFSPathUNICODE(SDL_WinRT_Path pathType);
 
 /**
- *  \brief Retrieves a WinRT defined path on the local file system
+ * Retrieve a WinRT defined path on the local file system.
  *
- *  \note Documentation on most app-specific path types on WinRT
- *      can be found on MSDN, at the URL:
- *      http://msdn.microsoft.com/en-us/library/windows/apps/hh464917.aspx
+ * Not all paths are available on all versions of Windows. This is especially
+ * true on Windows Phone. Check the documentation for the given SDL_WinRT_Path
+ * for more information on which path types are supported where.
  *
- *  \param pathType The type of path to retrieve.
- *  \return A UTF-8 string (8-bit, multi-byte) containing the path, or NULL
- *      if the path is not available for any reason.  Not all paths are
- *      available on all versions of Windows.  This is especially true on
- *      Windows Phone.  Check the documentation for the given
- *      SDL_WinRT_Path for more information on which path types are
- *      supported where.
+ * Documentation on most app-specific path types on WinRT can be found on
+ * MSDN, at the URL:
+ *
+ * https://msdn.microsoft.com/en-us/library/windows/apps/hh464917.aspx
+ *
+ * \param pathType the type of path to retrieve, one of SDL_WinRT_Path
+ * \returns a UTF-8 string (8-bit, multi-byte) containing the path, or NULL if
+ *          the path is not available for any reason; call SDL_GetError() for
+ *          more information.
+ *
+ * \since This function is available since SDL 2.0.3.
+ *
+ * \sa SDL_WinRTGetFSPathUNICODE
  */
 extern DECLSPEC const char * SDLCALL SDL_WinRTGetFSPathUTF8(SDL_WinRT_Path pathType);
 
 /**
- *  \brief Detects the device family of WinRT plattform on runtime
+ * Detects the device family of WinRT plattform at runtime.
  *
- *  \return Device family
+ * \returns a value from the SDL_WinRT_DeviceFamily enum.
+ *
+ * \since This function is available since SDL 2.0.8.
  */
 extern DECLSPEC SDL_WinRT_DeviceFamily SDLCALL SDL_WinRTGetDeviceFamily();
 
 #endif /* __WINRT__ */
 
 /**
- \brief Return true if the current device is a tablet.
+ * Query if the current device is a tablet.
+ *
+ * If SDL can't determine this, it will return SDL_FALSE.
+ *
+ * \returns SDL_TRUE if the device is a tablet, SDL_FALSE otherwise.
+ *
+ * \since This function is available since SDL 2.0.9.
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_IsTablet(void);
 
diff --git a/Engine/lib/sdl/include/SDL_syswm.h b/Engine/lib/sdl/include/SDL_syswm.h
index f0e9675d7..f7cd670cd 100644
--- a/Engine/lib/sdl/include/SDL_syswm.h
+++ b/Engine/lib/sdl/include/SDL_syswm.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -98,6 +98,10 @@ typedef struct _UIViewController UIViewController;
 typedef Uint32 GLuint;
 #endif
 
+#if defined(SDL_VIDEO_VULKAN) || defined(SDL_VIDEO_METAL)
+#define SDL_METALVIEW_TAG 255
+#endif
+
 #if defined(SDL_VIDEO_DRIVER_ANDROID)
 typedef struct ANativeWindow ANativeWindow;
 typedef void *EGLSurface;
@@ -113,6 +117,10 @@ typedef void *EGLSurface;
 #endif
 #endif /* SDL_PROTOTYPES_ONLY */
 
+#if defined(SDL_VIDEO_DRIVER_KMSDRM)
+struct gbm_device;
+#endif
+
 
 #include "begin_code.h"
 /* Set up for C function definitions, even when using C++ */
@@ -138,7 +146,9 @@ typedef enum
     SDL_SYSWM_ANDROID,
     SDL_SYSWM_VIVANTE,
     SDL_SYSWM_OS2,
-    SDL_SYSWM_HAIKU
+    SDL_SYSWM_HAIKU,
+    SDL_SYSWM_KMSDRM,
+    SDL_SYSWM_RISCOS
 } SDL_SYSWM_TYPE;
 
 /**
@@ -251,8 +261,12 @@ struct SDL_SysWMinfo
 #if defined(SDL_VIDEO_DRIVER_COCOA)
         struct
         {
-#if defined(__OBJC__) && defined(__has_feature) && __has_feature(objc_arc)
+#if defined(__OBJC__) && defined(__has_feature)
+        #if __has_feature(objc_arc)
             NSWindow __unsafe_unretained *window; /**< The Cocoa window */
+        #else
+            NSWindow *window;                     /**< The Cocoa window */
+        #endif
 #else
             NSWindow *window;                     /**< The Cocoa window */
 #endif
@@ -261,8 +275,12 @@ struct SDL_SysWMinfo
 #if defined(SDL_VIDEO_DRIVER_UIKIT)
         struct
         {
-#if defined(__OBJC__) && defined(__has_feature) && __has_feature(objc_arc)
+#if defined(__OBJC__) && defined(__has_feature)
+        #if __has_feature(objc_arc)
             UIWindow __unsafe_unretained *window; /**< The UIKit window */
+        #else
+            UIWindow *window;                     /**< The UIKit window */
+        #endif
 #else
             UIWindow *window;                     /**< The UIKit window */
 #endif
@@ -274,9 +292,12 @@ struct SDL_SysWMinfo
 #if defined(SDL_VIDEO_DRIVER_WAYLAND)
         struct
         {
-            struct wl_display *display;            /**< Wayland display */
-            struct wl_surface *surface;            /**< Wayland surface */
-            struct wl_shell_surface *shell_surface; /**< Wayland shell_surface (window manager handle) */
+            struct wl_display *display;             /**< Wayland display */
+            struct wl_surface *surface;             /**< Wayland surface */
+            void *shell_surface;                    /**< DEPRECATED Wayland shell_surface (window manager handle) */
+            struct wl_egl_window *egl_window;       /**< Wayland EGL window (native window) */
+            struct xdg_surface *xdg_surface;        /**< Wayland xdg surface (window manager handle) */
+            struct xdg_toplevel *xdg_toplevel;      /**< Wayland xdg toplevel role */
         } wl;
 #endif
 #if defined(SDL_VIDEO_DRIVER_MIR)  /* no longer available, left for API/ABI compatibility. Remove in 2.1! */
@@ -311,6 +332,15 @@ struct SDL_SysWMinfo
         } vivante;
 #endif
 
+#if defined(SDL_VIDEO_DRIVER_KMSDRM)
+        struct
+        {
+            int dev_index;               /**< Device index (ex: the X in /dev/dri/cardX) */
+            int drm_fd;                  /**< DRM FD (unavailable on Vulkan windows) */
+            struct gbm_device *gbm_dev;  /**< GBM device (unavailable on Vulkan windows) */
+        } kmsdrm;
+#endif
+
         /* Make sure this union is always 64 bytes (8 64-bit pointers). */
         /* Be careful not to overflow this if you add a new target! */
         Uint8 dummy[64];
@@ -321,23 +351,23 @@ struct SDL_SysWMinfo
 
 typedef struct SDL_SysWMinfo SDL_SysWMinfo;
 
-/* Function prototypes */
+
 /**
- *  \brief This function allows access to driver-dependent window information.
+ * Get driver-specific information about a window.
  *
- *  \param window The window about which information is being requested
- *  \param info This structure must be initialized with the SDL version, and is
- *              then filled in with information about the given window.
+ * You must include SDL_syswm.h for the declaration of SDL_SysWMinfo.
  *
- *  \return SDL_TRUE if the function is implemented and the version member of
- *          the \c info struct is valid, SDL_FALSE otherwise.
+ * The caller must initialize the `info` structure's version by using
+ * `SDL_VERSION(&info.version)`, and then this function will fill in the rest
+ * of the structure with information about the given window.
  *
- *  You typically use this function like this:
- *  \code
- *  SDL_SysWMinfo info;
- *  SDL_VERSION(&info.version);
- *  if ( SDL_GetWindowWMInfo(window, &info) ) { ... }
- *  \endcode
+ * \param window the window about which information is being requested
+ * \param info an SDL_SysWMinfo structure filled in with window information
+ * \returns SDL_TRUE if the function is implemented and the `version` member
+ *          of the `info` struct is valid, or SDL_FALSE if the information
+ *          could not be retrieved; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_GetWindowWMInfo(SDL_Window * window,
                                                      SDL_SysWMinfo * info);
diff --git a/Engine/lib/sdl/include/SDL_test.h b/Engine/lib/sdl/include/SDL_test.h
index 7095427ae..8cc9d616a 100644
--- a/Engine/lib/sdl/include/SDL_test.h
+++ b/Engine/lib/sdl/include/SDL_test.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/include/SDL_test_assert.h b/Engine/lib/sdl/include/SDL_test_assert.h
index 19b90950e..734230529 100644
--- a/Engine/lib/sdl/include/SDL_test_assert.h
+++ b/Engine/lib/sdl/include/SDL_test_assert.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -66,7 +66,7 @@ void SDLTest_Assert(int assertCondition, SDL_PRINTF_FORMAT_STRING const char *as
  * \param assertCondition Evaluated condition or variable to assert; fail (==0) or pass (!=0).
  * \param assertDescription Message to log with the assert describing it.
  *
- * \returns Returns the assertCondition so it can be used to externally to break execution flow if desired.
+ * \returns the assertCondition so it can be used to externally to break execution flow if desired.
  */
 int SDLTest_AssertCheck(int assertCondition, SDL_PRINTF_FORMAT_STRING const char *assertDescription, ...) SDL_PRINTF_VARARG_FUNC(2);
 
diff --git a/Engine/lib/sdl/include/SDL_test_common.h b/Engine/lib/sdl/include/SDL_test_common.h
index 3ad203055..0f5096789 100644
--- a/Engine/lib/sdl/include/SDL_test_common.h
+++ b/Engine/lib/sdl/include/SDL_test_common.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -37,6 +37,9 @@
 #if defined(__PSP__)
 #define DEFAULT_WINDOW_WIDTH  480
 #define DEFAULT_WINDOW_HEIGHT 272
+#elif defined(__VITA__)
+#define DEFAULT_WINDOW_WIDTH  960
+#define DEFAULT_WINDOW_HEIGHT 544
 #else
 #define DEFAULT_WINDOW_WIDTH  640
 #define DEFAULT_WINDOW_HEIGHT 480
@@ -61,6 +64,7 @@ typedef struct
     const char *window_title;
     const char *window_icon;
     Uint32 window_flags;
+    SDL_bool flash_on_focus_loss;
     int window_x;
     int window_y;
     int window_w;
@@ -110,6 +114,10 @@ typedef struct
     int gl_minor_version;
     int gl_debug;
     int gl_profile_mask;
+
+    /* Additional fields added in 2.0.18 */
+    SDL_Rect confine;
+
 } SDLTest_CommonState;
 
 #include "begin_code.h"
@@ -126,7 +134,7 @@ extern "C" {
  * \param argv Array of command line parameters
  * \param flags Flags indicating which subsystem to initialize (i.e. SDL_INIT_VIDEO | SDL_INIT_AUDIO)
  *
- * \returns Returns a newly allocated common state object.
+ * \returns a newly allocated common state object.
  */
 SDLTest_CommonState *SDLTest_CommonCreateState(char **argv, Uint32 flags);
 
@@ -136,7 +144,7 @@ SDLTest_CommonState *SDLTest_CommonCreateState(char **argv, Uint32 flags);
  * \param state The common state describing the test window to create.
  * \param index The index of the argument to process in argv[].
  *
- * \returns The number of arguments processed (i.e. 1 for --fullscreen, 2 for --video [videodriver], or -1 on error.
+ * \returns the number of arguments processed (i.e. 1 for --fullscreen, 2 for --video [videodriver], or -1 on error.
  */
 int SDLTest_CommonArg(SDLTest_CommonState * state, int index);
 
@@ -164,7 +172,7 @@ void SDLTest_CommonLogUsage(SDLTest_CommonState * state, const char *argv0, cons
  *  those strings' memory is freed and can no longer be used.
  *
  * \param state The common state describing the test window to create.
- * \returns String with usage information
+ * \returns a string with usage information
  */
 const char *SDLTest_CommonUsage(SDLTest_CommonState * state);
 
@@ -173,7 +181,7 @@ const char *SDLTest_CommonUsage(SDLTest_CommonState * state);
  *
  * \param state The common state describing the test window to create.
  *
- * \returns True if initialization succeeded, false otherwise
+ * \returns SDL_TRUE if initialization succeeded, false otherwise
  */
 SDL_bool SDLTest_CommonInit(SDLTest_CommonState * state);
 
@@ -184,7 +192,7 @@ SDL_bool SDLTest_CommonInit(SDLTest_CommonState * state);
  * \param argc argc, as supplied to SDL_main
  * \param argv argv, as supplied to SDL_main
  *
- * \returns False if app should quit, true otherwise.
+ * \returns SDL_FALSE if app should quit, true otherwise.
  */
 SDL_bool SDLTest_CommonDefaultArgs(SDLTest_CommonState * state, const int argc, char **argv);
 
@@ -206,6 +214,15 @@ void SDLTest_CommonEvent(SDLTest_CommonState * state, SDL_Event * event, int *do
  */
 void SDLTest_CommonQuit(SDLTest_CommonState * state);
 
+/**
+ * \brief Draws various window information (position, size, etc.) to the renderer.
+ *
+ * \param renderer The renderer to draw to.
+ * \param window The window whose information should be displayed.
+ * \param usedHeight Returns the height used, so the caller can draw more below.
+ *
+ */
+void SDLTest_CommonDrawWindowInfo(SDL_Renderer * renderer, SDL_Window * window, int * usedHeight);
 
 /* Ends C function definitions when using C++ */
 #ifdef __cplusplus
diff --git a/Engine/lib/sdl/include/SDL_test_compare.h b/Engine/lib/sdl/include/SDL_test_compare.h
index 38b22bb3b..8a7a07008 100644
--- a/Engine/lib/sdl/include/SDL_test_compare.h
+++ b/Engine/lib/sdl/include/SDL_test_compare.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/include/SDL_test_crc32.h b/Engine/lib/sdl/include/SDL_test_crc32.h
index 611066abf..049da7406 100644
--- a/Engine/lib/sdl/include/SDL_test_crc32.h
+++ b/Engine/lib/sdl/include/SDL_test_crc32.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/include/SDL_test_font.h b/Engine/lib/sdl/include/SDL_test_font.h
index dc4ce6dd6..c5cbbbbd3 100644
--- a/Engine/lib/sdl/include/SDL_test_font.h
+++ b/Engine/lib/sdl/include/SDL_test_font.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -48,7 +48,7 @@ extern "C" {
  *  \param y The Y coordinate of the upper left corner of the character.
  *  \param c The character to draw.
  *
- *  \returns Returns 0 on success, -1 on failure.
+ *  \returns 0 on success, -1 on failure.
  */
 int SDLTest_DrawCharacter(SDL_Renderer *renderer, int x, int y, char c);
 
@@ -60,7 +60,7 @@ int SDLTest_DrawCharacter(SDL_Renderer *renderer, int x, int y, char c);
  *  \param y The Y coordinate of the upper left corner of the string.
  *  \param s The string to draw.
  *
- *  \returns Returns 0 on success, -1 on failure.
+ *  \returns 0 on success, -1 on failure.
  */
 int SDLTest_DrawString(SDL_Renderer *renderer, int x, int y, const char *s);
 
diff --git a/Engine/lib/sdl/include/SDL_test_fuzzer.h b/Engine/lib/sdl/include/SDL_test_fuzzer.h
index cb5a17a10..bbe8eb874 100644
--- a/Engine/lib/sdl/include/SDL_test_fuzzer.h
+++ b/Engine/lib/sdl/include/SDL_test_fuzzer.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -66,14 +66,14 @@ void SDLTest_FuzzerInit(Uint64 execKey);
 /**
  * Returns a random Uint8
  *
- * \returns Generated integer
+ * \returns a generated integer
  */
 Uint8 SDLTest_RandomUint8(void);
 
 /**
  * Returns a random Sint8
  *
- * \returns Generated signed integer
+ * \returns a generated signed integer
  */
 Sint8 SDLTest_RandomSint8(void);
 
@@ -81,14 +81,14 @@ Sint8 SDLTest_RandomSint8(void);
 /**
  * Returns a random Uint16
  *
- * \returns Generated integer
+ * \returns a generated integer
  */
 Uint16 SDLTest_RandomUint16(void);
 
 /**
  * Returns a random Sint16
  *
- * \returns Generated signed integer
+ * \returns a generated signed integer
  */
 Sint16 SDLTest_RandomSint16(void);
 
@@ -96,7 +96,7 @@ Sint16 SDLTest_RandomSint16(void);
 /**
  * Returns a random integer
  *
- * \returns Generated integer
+ * \returns a generated integer
  */
 Sint32 SDLTest_RandomSint32(void);
 
@@ -104,14 +104,14 @@ Sint32 SDLTest_RandomSint32(void);
 /**
  * Returns a random positive integer
  *
- * \returns Generated integer
+ * \returns a generated integer
  */
 Uint32 SDLTest_RandomUint32(void);
 
 /**
  * Returns random Uint64.
  *
- * \returns Generated integer
+ * \returns a generated integer
  */
 Uint64 SDLTest_RandomUint64(void);
 
@@ -119,28 +119,28 @@ Uint64 SDLTest_RandomUint64(void);
 /**
  * Returns random Sint64.
  *
- * \returns Generated signed integer
+ * \returns a generated signed integer
  */
 Sint64 SDLTest_RandomSint64(void);
 
 /**
- * \returns random float in range [0.0 - 1.0[
+ * \returns a random float in range [0.0 - 1.0]
  */
 float SDLTest_RandomUnitFloat(void);
 
 /**
- * \returns random double in range [0.0 - 1.0[
+ * \returns a random double in range [0.0 - 1.0]
  */
 double SDLTest_RandomUnitDouble(void);
 
 /**
- * \returns random float.
+ * \returns a random float.
  *
  */
 float SDLTest_RandomFloat(void);
 
 /**
- * \returns random double.
+ * \returns a random double.
  *
  */
 double SDLTest_RandomDouble(void);
@@ -162,7 +162,7 @@ double SDLTest_RandomDouble(void);
  * \param boundary2 Upper boundary limit
  * \param validDomain Should the generated boundary be valid (=within the bounds) or not?
  *
- * \returns Random boundary value for the given range and domain or 0 with error set
+ * \returns a random boundary value for the given range and domain or 0 with error set
  */
 Uint8 SDLTest_RandomUint8BoundaryValue(Uint8 boundary1, Uint8 boundary2, SDL_bool validDomain);
 
@@ -183,7 +183,7 @@ Uint8 SDLTest_RandomUint8BoundaryValue(Uint8 boundary1, Uint8 boundary2, SDL_boo
  * \param boundary2 Upper boundary limit
  * \param validDomain Should the generated boundary be valid (=within the bounds) or not?
  *
- * \returns Random boundary value for the given range and domain or 0 with error set
+ * \returns a random boundary value for the given range and domain or 0 with error set
  */
 Uint16 SDLTest_RandomUint16BoundaryValue(Uint16 boundary1, Uint16 boundary2, SDL_bool validDomain);
 
@@ -204,7 +204,7 @@ Uint16 SDLTest_RandomUint16BoundaryValue(Uint16 boundary1, Uint16 boundary2, SDL
  * \param boundary2 Upper boundary limit
  * \param validDomain Should the generated boundary be valid (=within the bounds) or not?
  *
- * \returns Random boundary value for the given range and domain or 0 with error set
+ * \returns a random boundary value for the given range and domain or 0 with error set
  */
 Uint32 SDLTest_RandomUint32BoundaryValue(Uint32 boundary1, Uint32 boundary2, SDL_bool validDomain);
 
@@ -225,7 +225,7 @@ Uint32 SDLTest_RandomUint32BoundaryValue(Uint32 boundary1, Uint32 boundary2, SDL
  * \param boundary2 Upper boundary limit
  * \param validDomain Should the generated boundary be valid (=within the bounds) or not?
  *
- * \returns Random boundary value for the given range and domain or 0 with error set
+ * \returns a random boundary value for the given range and domain or 0 with error set
  */
 Uint64 SDLTest_RandomUint64BoundaryValue(Uint64 boundary1, Uint64 boundary2, SDL_bool validDomain);
 
@@ -246,7 +246,7 @@ Uint64 SDLTest_RandomUint64BoundaryValue(Uint64 boundary1, Uint64 boundary2, SDL
  * \param boundary2 Upper boundary limit
  * \param validDomain Should the generated boundary be valid (=within the bounds) or not?
  *
- * \returns Random boundary value for the given range and domain or SINT8_MIN with error set
+ * \returns a random boundary value for the given range and domain or SINT8_MIN with error set
  */
 Sint8 SDLTest_RandomSint8BoundaryValue(Sint8 boundary1, Sint8 boundary2, SDL_bool validDomain);
 
@@ -268,7 +268,7 @@ Sint8 SDLTest_RandomSint8BoundaryValue(Sint8 boundary1, Sint8 boundary2, SDL_boo
  * \param boundary2 Upper boundary limit
  * \param validDomain Should the generated boundary be valid (=within the bounds) or not?
  *
- * \returns Random boundary value for the given range and domain or SINT16_MIN with error set
+ * \returns a random boundary value for the given range and domain or SINT16_MIN with error set
  */
 Sint16 SDLTest_RandomSint16BoundaryValue(Sint16 boundary1, Sint16 boundary2, SDL_bool validDomain);
 
@@ -289,7 +289,7 @@ Sint16 SDLTest_RandomSint16BoundaryValue(Sint16 boundary1, Sint16 boundary2, SDL
  * \param boundary2 Upper boundary limit
  * \param validDomain Should the generated boundary be valid (=within the bounds) or not?
  *
- * \returns Random boundary value for the given range and domain or SINT32_MIN with error set
+ * \returns a random boundary value for the given range and domain or SINT32_MIN with error set
  */
 Sint32 SDLTest_RandomSint32BoundaryValue(Sint32 boundary1, Sint32 boundary2, SDL_bool validDomain);
 
@@ -310,7 +310,7 @@ Sint32 SDLTest_RandomSint32BoundaryValue(Sint32 boundary1, Sint32 boundary2, SDL
  * \param boundary2 Upper boundary limit
  * \param validDomain Should the generated boundary be valid (=within the bounds) or not?
  *
- * \returns Random boundary value for the given range and domain or SINT64_MIN with error set
+ * \returns a random boundary value for the given range and domain or SINT64_MIN with error set
  */
 Sint64 SDLTest_RandomSint64BoundaryValue(Sint64 boundary1, Sint64 boundary2, SDL_bool validDomain);
 
@@ -324,7 +324,7 @@ Sint64 SDLTest_RandomSint64BoundaryValue(Sint64 boundary1, Sint64 boundary2, SDL
  * \param min Minimum inclusive value of returned random number
  * \param max Maximum inclusive value of returned random number
  *
- * \returns Generated random integer in range
+ * \returns a generated random integer in range
  */
 Sint32 SDLTest_RandomIntegerInRange(Sint32 min, Sint32 max);
 
@@ -336,7 +336,7 @@ Sint32 SDLTest_RandomIntegerInRange(Sint32 min, Sint32 max);
  *
  * Note: Returned string needs to be deallocated.
  *
- * \returns Newly allocated random string; or NULL if length was invalid or string could not be allocated.
+ * \returns a newly allocated random string; or NULL if length was invalid or string could not be allocated.
  */
 char * SDLTest_RandomAsciiString(void);
 
@@ -350,7 +350,7 @@ char * SDLTest_RandomAsciiString(void);
  *
  * \param maxLength The maximum length of the generated string.
  *
- * \returns Newly allocated random string; or NULL if maxLength was invalid or string could not be allocated.
+ * \returns a newly allocated random string; or NULL if maxLength was invalid or string could not be allocated.
  */
 char * SDLTest_RandomAsciiStringWithMaximumLength(int maxLength);
 
@@ -364,12 +364,14 @@ char * SDLTest_RandomAsciiStringWithMaximumLength(int maxLength);
  *
  * \param size The length of the generated string
  *
- * \returns Newly allocated random string; or NULL if size was invalid or string could not be allocated.
+ * \returns a newly allocated random string; or NULL if size was invalid or string could not be allocated.
  */
 char * SDLTest_RandomAsciiStringOfSize(int size);
 
 /**
- * Returns the invocation count for the fuzzer since last ...FuzzerInit.
+ * Get the invocation count for the fuzzer since last ...FuzzerInit.
+ *
+ * \returns the invocation count.
  */
 int SDLTest_GetFuzzerInvocationCount(void);
 
diff --git a/Engine/lib/sdl/include/SDL_test_harness.h b/Engine/lib/sdl/include/SDL_test_harness.h
index 97d981281..1fd4236be 100644
--- a/Engine/lib/sdl/include/SDL_test_harness.h
+++ b/Engine/lib/sdl/include/SDL_test_harness.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -76,9 +76,9 @@ typedef struct SDLTest_TestCaseReference {
     /* !< Func2Stress */
     SDLTest_TestCaseFp testCase;
     /* !< Short name (or function name) "Func2Stress" */
-    char *name;
+    const char *name;
     /* !< Long name or full description "This test pushes func2() to the limit." */
-    char *description;
+    const char *description;
     /* !< Set to TEST_ENABLED or TEST_DISABLED (test won't be run) */
     int enabled;
 } SDLTest_TestCaseReference;
@@ -88,7 +88,7 @@ typedef struct SDLTest_TestCaseReference {
  */
 typedef struct SDLTest_TestSuiteReference {
     /* !< "PlatformSuite" */
-    char *name;
+    const char *name;
     /* !< The function that is run before each test. NULL skips. */
     SDLTest_TestCaseSetUpFp testSetUp;
     /* !< The test cases that are run as part of the suite. Last item should be NULL. */
@@ -105,7 +105,7 @@ typedef struct SDLTest_TestSuiteReference {
  *
  * \param length The length of the seed string to generate
  *
- * \returns The generated seed string
+ * \returns the generated seed string
  */
 char *SDLTest_GenerateRunSeed(const int length);
 
@@ -118,7 +118,7 @@ char *SDLTest_GenerateRunSeed(const int length);
  * \param filter Filter specification. NULL disables. Case sensitive.
  * \param testIterations Number of iterations to run each test case.
  *
- * \returns Test run result; 0 when all tests passed, 1 if any tests failed.
+ * \returns the test run result: 0 when all tests passed, 1 if any tests failed.
  */
 int SDLTest_RunSuites(SDLTest_TestSuiteReference *testSuites[], const char *userRunSeed, Uint64 userExecKey, const char *filter, int testIterations);
 
diff --git a/Engine/lib/sdl/include/SDL_test_images.h b/Engine/lib/sdl/include/SDL_test_images.h
index 1cc3ee266..e2bfc3600 100644
--- a/Engine/lib/sdl/include/SDL_test_images.h
+++ b/Engine/lib/sdl/include/SDL_test_images.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/include/SDL_test_log.h b/Engine/lib/sdl/include/SDL_test_log.h
index 6066f9041..e3d39ad27 100644
--- a/Engine/lib/sdl/include/SDL_test_log.h
+++ b/Engine/lib/sdl/include/SDL_test_log.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/include/SDL_test_md5.h b/Engine/lib/sdl/include/SDL_test_md5.h
index b1c51d929..17b1d2be7 100644
--- a/Engine/lib/sdl/include/SDL_test_md5.h
+++ b/Engine/lib/sdl/include/SDL_test_md5.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/include/SDL_test_memory.h b/Engine/lib/sdl/include/SDL_test_memory.h
index df69f93e8..cc2edc1b9 100644
--- a/Engine/lib/sdl/include/SDL_test_memory.h
+++ b/Engine/lib/sdl/include/SDL_test_memory.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/include/SDL_test_random.h b/Engine/lib/sdl/include/SDL_test_random.h
index 9404e9dcd..b1d6060cb 100644
--- a/Engine/lib/sdl/include/SDL_test_random.h
+++ b/Engine/lib/sdl/include/SDL_test_random.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -98,7 +98,7 @@ extern "C" {
  *
  *  \param rndContext     pointer to context structure
  *
- *  \returns A random number (32bit unsigned integer)
+ *  \returns a random number (32bit unsigned integer)
  *
  */
  unsigned int SDLTest_Random(SDLTest_RandomContext *rndContext);
diff --git a/Engine/lib/sdl/include/SDL_thread.h b/Engine/lib/sdl/include/SDL_thread.h
index 4016358a0..35e680ddf 100644
--- a/Engine/lib/sdl/include/SDL_thread.h
+++ b/Engine/lib/sdl/include/SDL_thread.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -35,6 +35,17 @@
 #include "SDL_atomic.h"
 #include "SDL_mutex.h"
 
+#if defined(__WIN32__)
+#include <process.h> /* _beginthreadex() and _endthreadex() */
+#endif
+#if defined(__OS2__) /* for _beginthread() and _endthread() */
+#ifndef __EMX__
+#include <process.h>
+#else
+#include <stdlib.h>
+#endif
+#endif
+
 #include "begin_code.h"
 /* Set up for C function definitions, even when using C++ */
 #ifdef __cplusplus
@@ -69,11 +80,14 @@ typedef enum {
 } SDL_ThreadPriority;
 
 /**
- *  The function passed to SDL_CreateThread().
- *  It is passed a void* user context parameter and returns an int.
+ * The function passed to SDL_CreateThread().
+ *
+ * \param data what was passed as `data` to SDL_CreateThread()
+ * \returns a value that can be reported through SDL_WaitThread().
  */
 typedef int (SDLCALL * SDL_ThreadFunction) (void *data);
 
+
 #if defined(__WIN32__)
 /**
  *  \file SDL_thread.h
@@ -96,7 +110,6 @@ typedef int (SDLCALL * SDL_ThreadFunction) (void *data);
  *  library!
  */
 #define SDL_PASSED_BEGINTHREAD_ENDTHREAD
-#include <process.h> /* _beginthreadex() and _endthreadex() */
 
 typedef uintptr_t (__cdecl * pfnSDL_CurrentBeginThread)
                    (void *, unsigned, unsigned (__stdcall *func)(void *),
@@ -110,9 +123,6 @@ typedef void (__cdecl * pfnSDL_CurrentEndThread) (unsigned code);
 #define SDL_endthread _endthreadex
 #endif
 
-/**
- *  Create a thread.
- */
 extern DECLSPEC SDL_Thread *SDLCALL
 SDL_CreateThread(SDL_ThreadFunction fn, const char *name, void *data,
                  pfnSDL_CurrentBeginThread pfnBeginThread,
@@ -125,9 +135,6 @@ SDL_CreateThreadWithStackSize(int (SDLCALL * fn) (void *),
                  pfnSDL_CurrentEndThread pfnEndThread);
 
 
-/**
- *  Create a thread.
- */
 #if defined(SDL_CreateThread) && SDL_DYNAMIC_API
 #undef SDL_CreateThread
 #define SDL_CreateThread(fn, name, data) SDL_CreateThread_REAL(fn, name, data, (pfnSDL_CurrentBeginThread)SDL_beginthread, (pfnSDL_CurrentEndThread)SDL_endthread)
@@ -145,12 +152,6 @@ SDL_CreateThreadWithStackSize(int (SDLCALL * fn) (void *),
  */
 #define SDL_PASSED_BEGINTHREAD_ENDTHREAD
 
-#ifndef __EMX__
-#include <process.h>
-#else
-#include <stdlib.h>
-#endif
-
 typedef int (*pfnSDL_CurrentBeginThread)(void (*func)(void *), void *, unsigned, void * /*arg*/);
 typedef void (*pfnSDL_CurrentEndThread)(void);
 
@@ -183,39 +184,71 @@ SDL_CreateThreadWithStackSize(SDL_ThreadFunction fn, const char *name, const siz
 #else
 
 /**
- *  Create a thread with a default stack size.
+ * Create a new thread with a default stack size.
  *
- *  This is equivalent to calling:
- *  SDL_CreateThreadWithStackSize(fn, name, 0, data);
+ * This is equivalent to calling:
+ *
+ * ```c
+ * SDL_CreateThreadWithStackSize(fn, name, 0, data);
+ * ```
+ *
+ * \param fn the SDL_ThreadFunction function to call in the new thread
+ * \param name the name of the thread
+ * \param data a pointer that is passed to `fn`
+ * \returns an opaque pointer to the new thread object on success, NULL if the
+ *          new thread could not be created; call SDL_GetError() for more
+ *          information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateThreadWithStackSize
+ * \sa SDL_WaitThread
  */
 extern DECLSPEC SDL_Thread *SDLCALL
 SDL_CreateThread(SDL_ThreadFunction fn, const char *name, void *data);
 
 /**
- *  Create a thread.
+ * Create a new thread with a specific stack size.
  *
- *   Thread naming is a little complicated: Most systems have very small
- *    limits for the string length (Haiku has 32 bytes, Linux currently has 16,
- *    Visual C++ 6.0 has nine!), and possibly other arbitrary rules. You'll
- *    have to see what happens with your system's debugger. The name should be
- *    UTF-8 (but using the naming limits of C identifiers is a better bet).
- *   There are no requirements for thread naming conventions, so long as the
- *    string is null-terminated UTF-8, but these guidelines are helpful in
- *    choosing a name:
+ * SDL makes an attempt to report `name` to the system, so that debuggers can
+ * display it. Not all platforms support this.
  *
- *    http://stackoverflow.com/questions/149932/naming-conventions-for-threads
+ * Thread naming is a little complicated: Most systems have very small limits
+ * for the string length (Haiku has 32 bytes, Linux currently has 16, Visual
+ * C++ 6.0 has _nine_!), and possibly other arbitrary rules. You'll have to
+ * see what happens with your system's debugger. The name should be UTF-8 (but
+ * using the naming limits of C identifiers is a better bet). There are no
+ * requirements for thread naming conventions, so long as the string is
+ * null-terminated UTF-8, but these guidelines are helpful in choosing a name:
  *
- *   If a system imposes requirements, SDL will try to munge the string for
- *    it (truncate, etc), but the original string contents will be available
- *    from SDL_GetThreadName().
+ * https://stackoverflow.com/questions/149932/naming-conventions-for-threads
  *
- *   The size (in bytes) of the new stack can be specified. Zero means "use
- *    the system default" which might be wildly different between platforms
- *    (x86 Linux generally defaults to eight megabytes, an embedded device
- *    might be a few kilobytes instead).
+ * If a system imposes requirements, SDL will try to munge the string for it
+ * (truncate, etc), but the original string contents will be available from
+ * SDL_GetThreadName().
  *
- *   In SDL 2.1, stacksize will be folded into the original SDL_CreateThread
- *    function.
+ * The size (in bytes) of the new stack can be specified. Zero means "use the
+ * system default" which might be wildly different between platforms. x86
+ * Linux generally defaults to eight megabytes, an embedded device might be a
+ * few kilobytes instead. You generally need to specify a stack that is a
+ * multiple of the system's page size (in many cases, this is 4 kilobytes, but
+ * check your system documentation).
+ *
+ * In SDL 2.1, stack size will be folded into the original SDL_CreateThread
+ * function, but for backwards compatibility, this is currently a separate
+ * function.
+ *
+ * \param fn the SDL_ThreadFunction function to call in the new thread
+ * \param name the name of the thread
+ * \param stacksize the size, in bytes, to allocate for the new thread stack.
+ * \param data a pointer that is passed to `fn`
+ * \returns an opaque pointer to the new thread object on success, NULL if the
+ *          new thread could not be created; call SDL_GetError() for more
+ *          information.
+ *
+ * \since This function is available since SDL 2.0.9.
+ *
+ * \sa SDL_WaitThread
  */
 extern DECLSPEC SDL_Thread *SDLCALL
 SDL_CreateThreadWithStackSize(SDL_ThreadFunction fn, const char *name, const size_t stacksize, void *data);
@@ -223,137 +256,202 @@ SDL_CreateThreadWithStackSize(SDL_ThreadFunction fn, const char *name, const siz
 #endif
 
 /**
- * Get the thread name, as it was specified in SDL_CreateThread().
- *  This function returns a pointer to a UTF-8 string that names the
- *  specified thread, or NULL if it doesn't have a name. This is internal
- *  memory, not to be free()'d by the caller, and remains valid until the
- *  specified thread is cleaned up by SDL_WaitThread().
+ * Get the thread name as it was specified in SDL_CreateThread().
+ *
+ * This is internal memory, not to be freed by the caller, and remains valid
+ * until the specified thread is cleaned up by SDL_WaitThread().
+ *
+ * \param thread the thread to query
+ * \returns a pointer to a UTF-8 string that names the specified thread, or
+ *          NULL if it doesn't have a name.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateThread
  */
 extern DECLSPEC const char *SDLCALL SDL_GetThreadName(SDL_Thread *thread);
 
 /**
- *  Get the thread identifier for the current thread.
+ * Get the thread identifier for the current thread.
+ *
+ * This thread identifier is as reported by the underlying operating system.
+ * If SDL is running on a platform that does not support threads the return
+ * value will always be zero.
+ *
+ * This function also returns a valid thread ID when called from the main
+ * thread.
+ *
+ * \returns the ID of the current thread.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetThreadID
  */
 extern DECLSPEC SDL_threadID SDLCALL SDL_ThreadID(void);
 
 /**
- *  Get the thread identifier for the specified thread.
+ * Get the thread identifier for the specified thread.
  *
- *  Equivalent to SDL_ThreadID() if the specified thread is NULL.
+ * This thread identifier is as reported by the underlying operating system.
+ * If SDL is running on a platform that does not support threads the return
+ * value will always be zero.
+ *
+ * \param thread the thread to query
+ * \returns the ID of the specified thread, or the ID of the current thread if
+ *          `thread` is NULL.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_ThreadID
  */
 extern DECLSPEC SDL_threadID SDLCALL SDL_GetThreadID(SDL_Thread * thread);
 
 /**
- *  Set the priority for the current thread
+ * Set the priority for the current thread.
+ *
+ * Note that some platforms will not let you alter the priority (or at least,
+ * promote the thread to a higher priority) at all, and some require you to be
+ * an administrator account. Be prepared for this to fail.
+ *
+ * \param priority the SDL_ThreadPriority to set
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC int SDLCALL SDL_SetThreadPriority(SDL_ThreadPriority priority);
 
 /**
- *  Wait for a thread to finish. Threads that haven't been detached will
- *  remain (as a "zombie") until this function cleans them up. Not doing so
- *  is a resource leak.
+ * Wait for a thread to finish.
  *
- *  Once a thread has been cleaned up through this function, the SDL_Thread
- *  that references it becomes invalid and should not be referenced again.
- *  As such, only one thread may call SDL_WaitThread() on another.
+ * Threads that haven't been detached will remain (as a "zombie") until this
+ * function cleans them up. Not doing so is a resource leak.
  *
- *  The return code for the thread function is placed in the area
- *  pointed to by \c status, if \c status is not NULL.
+ * Once a thread has been cleaned up through this function, the SDL_Thread
+ * that references it becomes invalid and should not be referenced again. As
+ * such, only one thread may call SDL_WaitThread() on another.
  *
- *  You may not wait on a thread that has been used in a call to
- *  SDL_DetachThread(). Use either that function or this one, but not
- *  both, or behavior is undefined.
+ * The return code for the thread function is placed in the area pointed to by
+ * `status`, if `status` is not NULL.
  *
- *  It is safe to pass NULL to this function; it is a no-op.
+ * You may not wait on a thread that has been used in a call to
+ * SDL_DetachThread(). Use either that function or this one, but not both, or
+ * behavior is undefined.
+ *
+ * It is safe to pass a NULL thread to this function; it is a no-op.
+ *
+ * Note that the thread pointer is freed by this function and is not valid
+ * afterward.
+ *
+ * \param thread the SDL_Thread pointer that was returned from the
+ *               SDL_CreateThread() call that started this thread
+ * \param status pointer to an integer that will receive the value returned
+ *               from the thread function by its 'return', or NULL to not
+ *               receive such value back.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateThread
+ * \sa SDL_DetachThread
  */
 extern DECLSPEC void SDLCALL SDL_WaitThread(SDL_Thread * thread, int *status);
 
 /**
- *  A thread may be "detached" to signify that it should not remain until
- *  another thread has called SDL_WaitThread() on it. Detaching a thread
- *  is useful for long-running threads that nothing needs to synchronize
- *  with or further manage. When a detached thread is done, it simply
- *  goes away.
+ * Let a thread clean up on exit without intervention.
  *
- *  There is no way to recover the return code of a detached thread. If you
- *  need this, don't detach the thread and instead use SDL_WaitThread().
+ * A thread may be "detached" to signify that it should not remain until
+ * another thread has called SDL_WaitThread() on it. Detaching a thread is
+ * useful for long-running threads that nothing needs to synchronize with or
+ * further manage. When a detached thread is done, it simply goes away.
  *
- *  Once a thread is detached, you should usually assume the SDL_Thread isn't
- *  safe to reference again, as it will become invalid immediately upon
- *  the detached thread's exit, instead of remaining until someone has called
- *  SDL_WaitThread() to finally clean it up. As such, don't detach the same
- *  thread more than once.
+ * There is no way to recover the return code of a detached thread. If you
+ * need this, don't detach the thread and instead use SDL_WaitThread().
  *
- *  If a thread has already exited when passed to SDL_DetachThread(), it will
- *  stop waiting for a call to SDL_WaitThread() and clean up immediately.
- *  It is not safe to detach a thread that might be used with SDL_WaitThread().
+ * Once a thread is detached, you should usually assume the SDL_Thread isn't
+ * safe to reference again, as it will become invalid immediately upon the
+ * detached thread's exit, instead of remaining until someone has called
+ * SDL_WaitThread() to finally clean it up. As such, don't detach the same
+ * thread more than once.
  *
- *  You may not call SDL_WaitThread() on a thread that has been detached.
- *  Use either that function or this one, but not both, or behavior is
- *  undefined.
+ * If a thread has already exited when passed to SDL_DetachThread(), it will
+ * stop waiting for a call to SDL_WaitThread() and clean up immediately. It is
+ * not safe to detach a thread that might be used with SDL_WaitThread().
  *
- *  It is safe to pass NULL to this function; it is a no-op.
+ * You may not call SDL_WaitThread() on a thread that has been detached. Use
+ * either that function or this one, but not both, or behavior is undefined.
+ *
+ * It is safe to pass NULL to this function; it is a no-op.
+ *
+ * \param thread the SDL_Thread pointer that was returned from the
+ *               SDL_CreateThread() call that started this thread
+ *
+ * \since This function is available since SDL 2.0.2.
+ *
+ * \sa SDL_CreateThread
+ * \sa SDL_WaitThread
  */
 extern DECLSPEC void SDLCALL SDL_DetachThread(SDL_Thread * thread);
 
 /**
- *  \brief Create an identifier that is globally visible to all threads but refers to data that is thread-specific.
+ * Create a piece of thread-local storage.
  *
- *  \return The newly created thread local storage identifier, or 0 on error
+ * This creates an identifier that is globally visible to all threads but
+ * refers to data that is thread-specific.
  *
- *  \code
- *  static SDL_SpinLock tls_lock;
- *  static SDL_TLSID thread_local_storage;
- * 
- *  void SetMyThreadData(void *value)
- *  {
- *      if (!thread_local_storage) {
- *          SDL_AtomicLock(&tls_lock);
- *          if (!thread_local_storage) {
- *              thread_local_storage = SDL_TLSCreate();
- *          }
- *          SDL_AtomicUnlock(&tls_lock);
- *      }
- *      SDL_TLSSet(thread_local_storage, value, 0);
- *  }
- *  
- *  void *GetMyThreadData(void)
- *  {
- *      return SDL_TLSGet(thread_local_storage);
- *  }
- *  \endcode
+ * \returns the newly created thread local storage identifier or 0 on error.
  *
- *  \sa SDL_TLSGet()
- *  \sa SDL_TLSSet()
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_TLSGet
+ * \sa SDL_TLSSet
  */
 extern DECLSPEC SDL_TLSID SDLCALL SDL_TLSCreate(void);
 
 /**
- *  \brief Get the value associated with a thread local storage ID for the current thread.
+ * Get the current thread's value associated with a thread local storage ID.
  *
- *  \param id The thread local storage ID
+ * \param id the thread local storage ID
+ * \returns the value associated with the ID for the current thread or NULL if
+ *          no value has been set; call SDL_GetError() for more information.
  *
- *  \return The value associated with the ID for the current thread, or NULL if no value has been set.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_TLSCreate()
- *  \sa SDL_TLSSet()
+ * \sa SDL_TLSCreate
+ * \sa SDL_TLSSet
  */
 extern DECLSPEC void * SDLCALL SDL_TLSGet(SDL_TLSID id);
 
 /**
- *  \brief Set the value associated with a thread local storage ID for the current thread.
+ * Set the current thread's value associated with a thread local storage ID.
  *
- *  \param id The thread local storage ID
- *  \param value The value to associate with the ID for the current thread
- *  \param destructor A function called when the thread exits, to free the value.
+ * The function prototype for `destructor` is:
  *
- *  \return 0 on success, -1 on error
+ * ```c
+ * void destructor(void *value)
+ * ```
  *
- *  \sa SDL_TLSCreate()
- *  \sa SDL_TLSGet()
+ * where its parameter `value` is what was passed as `value` to SDL_TLSSet().
+ *
+ * \param id the thread local storage ID
+ * \param value the value to associate with the ID for the current thread
+ * \param destructor a function called when the thread exits, to free the
+ *                   value
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_TLSCreate
+ * \sa SDL_TLSGet
  */
 extern DECLSPEC int SDLCALL SDL_TLSSet(SDL_TLSID id, const void *value, void (SDLCALL *destructor)(void*));
 
+/**
+ * Cleanup all TLS data for this thread.
+ *
+ * \since This function is available since SDL 2.0.16.
+ */
+extern DECLSPEC void SDLCALL SDL_TLSCleanup(void);
 
 /* Ends C function definitions when using C++ */
 #ifdef __cplusplus
diff --git a/Engine/lib/sdl/include/SDL_timer.h b/Engine/lib/sdl/include/SDL_timer.h
index aada7178b..62f81d42d 100644
--- a/Engine/lib/sdl/include/SDL_timer.h
+++ b/Engine/lib/sdl/include/SDL_timer.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -38,45 +38,121 @@ extern "C" {
 #endif
 
 /**
- * \brief Get the number of milliseconds since the SDL library initialization.
+ * Get the number of milliseconds since SDL library initialization.
  *
- * \note This value wraps if the program runs for more than ~49 days.
+ * This value wraps if the program runs for more than ~49 days.
+ *
+ * This function is not recommended as of SDL 2.0.18; use SDL_GetTicks64()
+ * instead, where the value doesn't wrap every ~49 days. There are places in
+ * SDL where we provide a 32-bit timestamp that can not change without
+ * breaking binary compatibility, though, so this function isn't officially
+ * deprecated.
+ *
+ * \returns an unsigned 32-bit value representing the number of milliseconds
+ *          since the SDL library initialized.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_TICKS_PASSED
  */
 extern DECLSPEC Uint32 SDLCALL SDL_GetTicks(void);
 
 /**
- * \brief Compare SDL ticks values, and return true if A has passed B
+ * Get the number of milliseconds since SDL library initialization.
  *
- * e.g. if you want to wait 100 ms, you could do this:
- *  Uint32 timeout = SDL_GetTicks() + 100;
- *  while (!SDL_TICKS_PASSED(SDL_GetTicks(), timeout)) {
- *      ... do work until timeout has elapsed
- *  }
+ * Note that you should not use the SDL_TICKS_PASSED macro with values
+ * returned by this function, as that macro does clever math to compensate for
+ * the 32-bit overflow every ~49 days that SDL_GetTicks() suffers from. 64-bit
+ * values from this function can be safely compared directly.
+ *
+ * For example, if you want to wait 100 ms, you could do this:
+ *
+ * ```c
+ * const Uint64 timeout = SDL_GetTicks64() + 100;
+ * while (SDL_GetTicks64() < timeout) {
+ *     // ... do work until timeout has elapsed
+ * }
+ * ```
+ *
+ * \returns an unsigned 64-bit value representing the number of milliseconds
+ *          since the SDL library initialized.
+ *
+ * \since This function is available since SDL 2.0.18.
+ */
+extern DECLSPEC Uint64 SDLCALL SDL_GetTicks64(void);
+
+/**
+ * Compare 32-bit SDL ticks values, and return true if `A` has passed `B`.
+ *
+ * This should be used with results from SDL_GetTicks(), as this macro
+ * attempts to deal with the 32-bit counter wrapping back to zero every ~49
+ * days, but should _not_ be used with SDL_GetTicks64(), which does not have
+ * that problem.
+ *
+ * For example, with SDL_GetTicks(), if you want to wait 100 ms, you could
+ * do this:
+ *
+ * ```c
+ * const Uint32 timeout = SDL_GetTicks() + 100;
+ * while (!SDL_TICKS_PASSED(SDL_GetTicks(), timeout)) {
+ *     // ... do work until timeout has elapsed
+ * }
+ * ```
+ *
+ * Note that this does not handle tick differences greater
+ * than 2^31 so take care when using the above kind of code
+ * with large timeout delays (tens of days).
  */
 #define SDL_TICKS_PASSED(A, B)  ((Sint32)((B) - (A)) <= 0)
 
 /**
- * \brief Get the current value of the high resolution counter
+ * Get the current value of the high resolution counter.
+ *
+ * This function is typically used for profiling.
+ *
+ * The counter values are only meaningful relative to each other. Differences
+ * between values can be converted to times by using
+ * SDL_GetPerformanceFrequency().
+ *
+ * \returns the current counter value.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetPerformanceFrequency
  */
 extern DECLSPEC Uint64 SDLCALL SDL_GetPerformanceCounter(void);
 
 /**
- * \brief Get the count per second of the high resolution counter
+ * Get the count per second of the high resolution counter.
+ *
+ * \returns a platform-specific count per second.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetPerformanceCounter
  */
 extern DECLSPEC Uint64 SDLCALL SDL_GetPerformanceFrequency(void);
 
 /**
- * \brief Wait a specified number of milliseconds before returning.
+ * Wait a specified number of milliseconds before returning.
+ *
+ * This function waits a specified number of milliseconds before returning. It
+ * waits at least the specified time, but possibly longer due to OS
+ * scheduling.
+ *
+ * \param ms the number of milliseconds to delay
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC void SDLCALL SDL_Delay(Uint32 ms);
 
 /**
- *  Function prototype for the timer callback function.
+ * Function prototype for the timer callback function.
  *
- *  The callback function is passed the current timer interval and returns
- *  the next timer interval.  If the returned value is the same as the one
- *  passed in, the periodic alarm continues, otherwise a new alarm is
- *  scheduled.  If the callback returns 0, the periodic alarm is cancelled.
+ * The callback function is passed the current timer interval and returns
+ * the next timer interval. If the returned value is the same as the one
+ * passed in, the periodic alarm continues, otherwise a new alarm is
+ * scheduled. If the callback returns 0, the periodic alarm is cancelled.
  */
 typedef Uint32 (SDLCALL * SDL_TimerCallback) (Uint32 interval, void *param);
 
@@ -86,20 +162,51 @@ typedef Uint32 (SDLCALL * SDL_TimerCallback) (Uint32 interval, void *param);
 typedef int SDL_TimerID;
 
 /**
- * \brief Add a new timer to the pool of timers already running.
+ * Call a callback function at a future time.
  *
- * \return A timer ID, or 0 when an error occurs.
+ * If you use this function, you must pass `SDL_INIT_TIMER` to SDL_Init().
+ *
+ * The callback function is passed the current timer interval and the user
+ * supplied parameter from the SDL_AddTimer() call and should return the next
+ * timer interval. If the value returned from the callback is 0, the timer is
+ * canceled.
+ *
+ * The callback is run on a separate thread.
+ *
+ * Timers take into account the amount of time it took to execute the
+ * callback. For example, if the callback took 250 ms to execute and returned
+ * 1000 (ms), the timer would only wait another 750 ms before its next
+ * iteration.
+ *
+ * Timing may be inexact due to OS scheduling. Be sure to note the current
+ * time with SDL_GetTicks() or SDL_GetPerformanceCounter() in case your
+ * callback needs to adjust for variances.
+ *
+ * \param interval the timer delay, in milliseconds, passed to `callback`
+ * \param callback the SDL_TimerCallback function to call when the specified
+ *                 `interval` elapses
+ * \param param a pointer that is passed to `callback`
+ * \returns a timer ID or 0 if an error occurs; call SDL_GetError() for more
+ *          information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RemoveTimer
  */
 extern DECLSPEC SDL_TimerID SDLCALL SDL_AddTimer(Uint32 interval,
                                                  SDL_TimerCallback callback,
                                                  void *param);
 
 /**
- * \brief Remove a timer knowing its ID.
+ * Remove a timer created with SDL_AddTimer().
  *
- * \return A boolean value indicating success or failure.
+ * \param id the ID of the timer to remove
+ * \returns SDL_TRUE if the timer is removed or SDL_FALSE if the timer wasn't
+ *          found.
  *
- * \warning It is not safe to remove a timer multiple times.
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_AddTimer
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_RemoveTimer(SDL_TimerID id);
 
diff --git a/Engine/lib/sdl/include/SDL_touch.h b/Engine/lib/sdl/include/SDL_touch.h
index fa5a37ce3..95924135e 100644
--- a/Engine/lib/sdl/include/SDL_touch.h
+++ b/Engine/lib/sdl/include/SDL_touch.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -64,30 +64,78 @@ typedef struct SDL_Finger
 #define SDL_MOUSE_TOUCHID ((Sint64)-1)
 
 
-/* Function prototypes */
-
 /**
- *  \brief Get the number of registered touch devices.
+ * Get the number of registered touch devices.
+ *
+ * On some platforms SDL first sees the touch device if it was actually used.
+ * Therefore SDL_GetNumTouchDevices() may return 0 although devices are
+ * available. After using all devices at least once the number will be
+ * correct.
+ *
+ * This was fixed for Android in SDL 2.0.1.
+ *
+ * \returns the number of registered touch devices.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetTouchDevice
  */
 extern DECLSPEC int SDLCALL SDL_GetNumTouchDevices(void);
 
 /**
- *  \brief Get the touch ID with the given index, or 0 if the index is invalid.
+ * Get the touch ID with the given index.
+ *
+ * \param index the touch device index
+ * \returns the touch ID with the given index on success or 0 if the index is
+ *          invalid; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetNumTouchDevices
  */
 extern DECLSPEC SDL_TouchID SDLCALL SDL_GetTouchDevice(int index);
 
 /**
- * \brief Get the type of the given touch device.
+ * Get the touch device name as reported from the driver or NULL if the index
+ * is invalid.
+ *
+ * \since This function is available since SDL 2.0.22.
+ */
+extern DECLSPEC const char* SDLCALL SDL_GetTouchName(int index);
+
+/**
+ * Get the type of the given touch device.
+ *
+ * \since This function is available since SDL 2.0.10.
  */
 extern DECLSPEC SDL_TouchDeviceType SDLCALL SDL_GetTouchDeviceType(SDL_TouchID touchID);
 
 /**
- *  \brief Get the number of active fingers for a given touch device.
+ * Get the number of active fingers for a given touch device.
+ *
+ * \param touchID the ID of a touch device
+ * \returns the number of active fingers for a given touch device on success
+ *          or 0 on failure; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetTouchFinger
  */
 extern DECLSPEC int SDLCALL SDL_GetNumTouchFingers(SDL_TouchID touchID);
 
 /**
- *  \brief Get the finger object of the given touch, with the given index.
+ * Get the finger object for specified touch device ID and finger index.
+ *
+ * The returned resource is owned by SDL and should not be deallocated.
+ *
+ * \param touchID the ID of the requested touch device
+ * \param index the index of the requested finger
+ * \returns a pointer to the SDL_Finger object or NULL if no object at the
+ *          given ID and index could be found.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RecordGesture
  */
 extern DECLSPEC SDL_Finger * SDLCALL SDL_GetTouchFinger(SDL_TouchID touchID, int index);
 
diff --git a/Engine/lib/sdl/include/SDL_types.h b/Engine/lib/sdl/include/SDL_types.h
index b6bb57117..355fb501a 100644
--- a/Engine/lib/sdl/include/SDL_types.h
+++ b/Engine/lib/sdl/include/SDL_types.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/include/SDL_version.h b/Engine/lib/sdl/include/SDL_version.h
index 23b65f434..a925dc432 100644
--- a/Engine/lib/sdl/include/SDL_version.h
+++ b/Engine/lib/sdl/include/SDL_version.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -37,16 +37,16 @@ extern "C" {
 #endif
 
 /**
- *  \brief Information the version of SDL in use.
+ * Information about the version of SDL in use.
  *
- *  Represents the library's version as three levels: major revision
- *  (increments with massive changes, additions, and enhancements),
- *  minor revision (increments with backwards-compatible changes to the
- *  major revision), and patchlevel (increments with fixes to the minor
- *  revision).
+ * Represents the library's version as three levels: major revision
+ * (increments with massive changes, additions, and enhancements),
+ * minor revision (increments with backwards-compatible changes to the
+ * major revision), and patchlevel (increments with fixes to the minor
+ * revision).
  *
- *  \sa SDL_VERSION
- *  \sa SDL_GetVersion
+ * \sa SDL_VERSION
+ * \sa SDL_GetVersion
  */
 typedef struct SDL_version
 {
@@ -59,22 +59,22 @@ typedef struct SDL_version
 */
 #define SDL_MAJOR_VERSION   2
 #define SDL_MINOR_VERSION   0
-#define SDL_PATCHLEVEL      14
+#define SDL_PATCHLEVEL      21
 
 /**
- *  \brief Macro to determine SDL version program was compiled against.
+ * Macro to determine SDL version program was compiled against.
  *
- *  This macro fills in a SDL_version structure with the version of the
- *  library you compiled against. This is determined by what header the
- *  compiler uses. Note that if you dynamically linked the library, you might
- *  have a slightly newer or older version at runtime. That version can be
- *  determined with SDL_GetVersion(), which, unlike SDL_VERSION(),
- *  is not a macro.
+ * This macro fills in a SDL_version structure with the version of the
+ * library you compiled against. This is determined by what header the
+ * compiler uses. Note that if you dynamically linked the library, you might
+ * have a slightly newer or older version at runtime. That version can be
+ * determined with SDL_GetVersion(), which, unlike SDL_VERSION(),
+ * is not a macro.
  *
- *  \param x A pointer to a SDL_version struct to initialize.
+ * \param x A pointer to a SDL_version struct to initialize.
  *
- *  \sa SDL_version
- *  \sa SDL_GetVersion
+ * \sa SDL_version
+ * \sa SDL_GetVersion
  */
 #define SDL_VERSION(x)                          \
 {                                   \
@@ -107,48 +107,74 @@ typedef struct SDL_version
     (SDL_COMPILEDVERSION >= SDL_VERSIONNUM(X, Y, Z))
 
 /**
- *  \brief Get the version of SDL that is linked against your program.
+ * Get the version of SDL that is linked against your program.
  *
- *  If you are linking to SDL dynamically, then it is possible that the
- *  current version will be different than the version you compiled against.
- *  This function returns the current version, while SDL_VERSION() is a
- *  macro that tells you what version you compiled with.
+ * If you are linking to SDL dynamically, then it is possible that the current
+ * version will be different than the version you compiled against. This
+ * function returns the current version, while SDL_VERSION() is a macro that
+ * tells you what version you compiled with.
  *
- *  \code
- *  SDL_version compiled;
- *  SDL_version linked;
+ * This function may be called safely at any time, even before SDL_Init().
  *
- *  SDL_VERSION(&compiled);
- *  SDL_GetVersion(&linked);
- *  printf("We compiled against SDL version %d.%d.%d ...\n",
- *         compiled.major, compiled.minor, compiled.patch);
- *  printf("But we linked against SDL version %d.%d.%d.\n",
- *         linked.major, linked.minor, linked.patch);
- *  \endcode
+ * \param ver the SDL_version structure that contains the version information
  *
- *  This function may be called safely at any time, even before SDL_Init().
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_VERSION
+ * \sa SDL_GetRevision
  */
 extern DECLSPEC void SDLCALL SDL_GetVersion(SDL_version * ver);
 
 /**
- *  \brief Get the code revision of SDL that is linked against your program.
+ * Get the code revision of SDL that is linked against your program.
  *
- *  Returns an arbitrary string (a hash value) uniquely identifying the
- *  exact revision of the SDL library in use, and is only useful in comparing
- *  against other revisions. It is NOT an incrementing number.
+ * This value is the revision of the code you are linked with and may be
+ * different from the code you are compiling with, which is found in the
+ * constant SDL_REVISION.
+ *
+ * The revision is arbitrary string (a hash value) uniquely identifying the
+ * exact revision of the SDL library in use, and is only useful in comparing
+ * against other revisions. It is NOT an incrementing number.
+ *
+ * If SDL wasn't built from a git repository with the appropriate tools, this
+ * will return an empty string.
+ *
+ * Prior to SDL 2.0.16, before development moved to GitHub, this returned a
+ * hash for a Mercurial repository.
+ *
+ * You shouldn't use this function for anything but logging it for debugging
+ * purposes. The string is not intended to be reliable in any way.
+ *
+ * \returns an arbitrary string, uniquely identifying the exact revision of
+ *          the SDL library in use.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetVersion
  */
 extern DECLSPEC const char *SDLCALL SDL_GetRevision(void);
 
 /**
- *  \brief Get the revision number of SDL that is linked against your program.
+ * Obsolete function, do not use.
  *
- *  Returns a number uniquely identifying the exact revision of the SDL
- *  library in use. It is an incrementing number based on commits to
- *  hg.libsdl.org.
+ * When SDL was hosted in a Mercurial repository, and was built carefully,
+ * this would return the revision number that the build was created from. This
+ * number was not reliable for several reasons, but more importantly, SDL is
+ * now hosted in a git repository, which does not offer numbers at all, only
+ * hashes. This function only ever returns zero now. Don't use it.
+ *
+ * Before SDL 2.0.16, this might have returned an unreliable, but non-zero
+ * number.
+ *
+ * \deprecated Use SDL_GetRevision() instead; if SDL was carefully built, it
+ *             will return a git hash.
+ *
+ * \returns zero, always, in modern SDL releases.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetRevision
  */
-extern DECLSPEC int SDLCALL SDL_GetRevisionNumber(void);
+extern SDL_DEPRECATED DECLSPEC int SDLCALL SDL_GetRevisionNumber(void);
 
 
 /* Ends C function definitions when using C++ */
diff --git a/Engine/lib/sdl/include/SDL_video.h b/Engine/lib/sdl/include/SDL_video.h
index 54cbe0f0f..e43cb27ec 100644
--- a/Engine/lib/sdl/include/SDL_video.h
+++ b/Engine/lib/sdl/include/SDL_video.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -65,9 +65,12 @@ typedef struct
  *  \sa SDL_CreateWindow()
  *  \sa SDL_CreateWindowFrom()
  *  \sa SDL_DestroyWindow()
+ *  \sa SDL_FlashWindow()
  *  \sa SDL_GetWindowData()
  *  \sa SDL_GetWindowFlags()
  *  \sa SDL_GetWindowGrab()
+ *  \sa SDL_GetWindowKeyboardGrab()
+ *  \sa SDL_GetWindowMouseGrab()
  *  \sa SDL_GetWindowPosition()
  *  \sa SDL_GetWindowSize()
  *  \sa SDL_GetWindowTitle()
@@ -79,6 +82,8 @@ typedef struct
  *  \sa SDL_SetWindowData()
  *  \sa SDL_SetWindowFullscreen()
  *  \sa SDL_SetWindowGrab()
+ *  \sa SDL_SetWindowKeyboardGrab()
+ *  \sa SDL_SetWindowMouseGrab()
  *  \sa SDL_SetWindowIcon()
  *  \sa SDL_SetWindowPosition()
  *  \sa SDL_SetWindowSize()
@@ -104,7 +109,7 @@ typedef enum
     SDL_WINDOW_RESIZABLE = 0x00000020,          /**< window can be resized */
     SDL_WINDOW_MINIMIZED = 0x00000040,          /**< window is minimized */
     SDL_WINDOW_MAXIMIZED = 0x00000080,          /**< window is maximized */
-    SDL_WINDOW_INPUT_GRABBED = 0x00000100,      /**< window has grabbed input focus */
+    SDL_WINDOW_MOUSE_GRABBED = 0x00000100,      /**< window has grabbed mouse input */
     SDL_WINDOW_INPUT_FOCUS = 0x00000200,        /**< window has input focus */
     SDL_WINDOW_MOUSE_FOCUS = 0x00000400,        /**< window has mouse focus */
     SDL_WINDOW_FULLSCREEN_DESKTOP = ( SDL_WINDOW_FULLSCREEN | 0x00001000 ),
@@ -112,14 +117,17 @@ typedef enum
     SDL_WINDOW_ALLOW_HIGHDPI = 0x00002000,      /**< window should be created in high-DPI mode if supported.
                                                      On macOS NSHighResolutionCapable must be set true in the
                                                      application's Info.plist for this to have any effect. */
-    SDL_WINDOW_MOUSE_CAPTURE = 0x00004000,      /**< window has mouse captured (unrelated to INPUT_GRABBED) */
-    SDL_WINDOW_ALWAYS_ON_TOP = 0x00008000,      /**< window should always be above others */
-    SDL_WINDOW_SKIP_TASKBAR  = 0x00010000,      /**< window should not be added to the taskbar */
-    SDL_WINDOW_UTILITY       = 0x00020000,      /**< window should be treated as a utility window */
-    SDL_WINDOW_TOOLTIP       = 0x00040000,      /**< window should be treated as a tooltip */
-    SDL_WINDOW_POPUP_MENU    = 0x00080000,      /**< window should be treated as a popup menu */
-    SDL_WINDOW_VULKAN        = 0x10000000,      /**< window usable for Vulkan surface */
-    SDL_WINDOW_METAL         = 0x20000000       /**< window usable for Metal view */
+    SDL_WINDOW_MOUSE_CAPTURE    = 0x00004000,   /**< window has mouse captured (unrelated to MOUSE_GRABBED) */
+    SDL_WINDOW_ALWAYS_ON_TOP    = 0x00008000,   /**< window should always be above others */
+    SDL_WINDOW_SKIP_TASKBAR     = 0x00010000,   /**< window should not be added to the taskbar */
+    SDL_WINDOW_UTILITY          = 0x00020000,   /**< window should be treated as a utility window */
+    SDL_WINDOW_TOOLTIP          = 0x00040000,   /**< window should be treated as a tooltip */
+    SDL_WINDOW_POPUP_MENU       = 0x00080000,   /**< window should be treated as a popup menu */
+    SDL_WINDOW_KEYBOARD_GRABBED = 0x00100000,   /**< window has grabbed keyboard input */
+    SDL_WINDOW_VULKAN           = 0x10000000,   /**< window usable for Vulkan surface */
+    SDL_WINDOW_METAL            = 0x20000000,   /**< window usable for Metal view */
+
+    SDL_WINDOW_INPUT_GRABBED = SDL_WINDOW_MOUSE_GRABBED /**< equivalent to SDL_WINDOW_MOUSE_GRABBED for compatibility */
 } SDL_WindowFlags;
 
 /**
@@ -166,7 +174,9 @@ typedef enum
     SDL_WINDOWEVENT_FOCUS_LOST,     /**< Window has lost keyboard focus */
     SDL_WINDOWEVENT_CLOSE,          /**< The window manager requests that the window be closed */
     SDL_WINDOWEVENT_TAKE_FOCUS,     /**< Window is being offered a focus (should SetWindowInputFocus() on itself or a subwindow, or ignore) */
-    SDL_WINDOWEVENT_HIT_TEST        /**< Window had a hit test that wasn't SDL_HITTEST_NORMAL. */
+    SDL_WINDOWEVENT_HIT_TEST,       /**< Window had a hit test that wasn't SDL_HITTEST_NORMAL. */
+    SDL_WINDOWEVENT_ICCPROF_CHANGED,/**< The ICC profile of the window's display has changed. */
+    SDL_WINDOWEVENT_DISPLAY_CHANGED /**< Window has been moved to display data1. */
 } SDL_WindowEventID;
 
 /**
@@ -180,6 +190,9 @@ typedef enum
     SDL_DISPLAYEVENT_DISCONNECTED   /**< Display has been removed from the system */
 } SDL_DisplayEventID;
 
+/**
+ *  \brief Display orientation
+ */
 typedef enum
 {
     SDL_ORIENTATION_UNKNOWN,            /**< The display orientation can't be determined */
@@ -189,6 +202,16 @@ typedef enum
     SDL_ORIENTATION_PORTRAIT_FLIPPED    /**< The display is in portrait mode, upside down */
 } SDL_DisplayOrientation;
 
+/**
+ *  \brief Window flash operation
+ */
+typedef enum
+{
+    SDL_FLASH_CANCEL,                   /**< Cancel any window flash state */
+    SDL_FLASH_BRIEFLY,                  /**< Flash the window briefly to get attention */
+    SDL_FLASH_UNTIL_FOCUSED             /**< Flash the window until it gets focus */
+} SDL_FlashOperation;
+
 /**
  *  \brief An opaque handle to an OpenGL context.
  */
@@ -258,740 +281,1299 @@ typedef enum
 /* Function prototypes */
 
 /**
- *  \brief Get the number of video drivers compiled into SDL
+ * Get the number of video drivers compiled into SDL.
  *
- *  \sa SDL_GetVideoDriver()
+ * \returns a number >= 1 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetVideoDriver
  */
 extern DECLSPEC int SDLCALL SDL_GetNumVideoDrivers(void);
 
 /**
- *  \brief Get the name of a built in video driver.
+ * Get the name of a built in video driver.
  *
- *  \note The video drivers are presented in the order in which they are
- *        normally checked during initialization.
+ * The video drivers are presented in the order in which they are normally
+ * checked during initialization.
  *
- *  \sa SDL_GetNumVideoDrivers()
+ * \param index the index of a video driver
+ * \returns the name of the video driver with the given **index**.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetNumVideoDrivers
  */
 extern DECLSPEC const char *SDLCALL SDL_GetVideoDriver(int index);
 
 /**
- *  \brief Initialize the video subsystem, optionally specifying a video driver.
+ * Initialize the video subsystem, optionally specifying a video driver.
  *
- *  \param driver_name Initialize a specific driver by name, or NULL for the
- *                     default video driver.
+ * This function initializes the video subsystem, setting up a connection to
+ * the window manager, etc, and determines the available display modes and
+ * pixel formats, but does not initialize a window or graphics mode.
  *
- *  \return 0 on success, -1 on error
+ * If you use this function and you haven't used the SDL_INIT_VIDEO flag with
+ * either SDL_Init() or SDL_InitSubSystem(), you should call SDL_VideoQuit()
+ * before calling SDL_Quit().
  *
- *  This function initializes the video subsystem; setting up a connection
- *  to the window manager, etc, and determines the available display modes
- *  and pixel formats, but does not initialize a window or graphics mode.
+ * It is safe to call this function multiple times. SDL_VideoInit() will call
+ * SDL_VideoQuit() itself if the video subsystem has already been initialized.
  *
- *  \sa SDL_VideoQuit()
+ * You can use SDL_GetNumVideoDrivers() and SDL_GetVideoDriver() to find a
+ * specific `driver_name`.
+ *
+ * \param driver_name the name of a video driver to initialize, or NULL for
+ *                    the default driver
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetNumVideoDrivers
+ * \sa SDL_GetVideoDriver
+ * \sa SDL_InitSubSystem
+ * \sa SDL_VideoQuit
  */
 extern DECLSPEC int SDLCALL SDL_VideoInit(const char *driver_name);
 
 /**
- *  \brief Shuts down the video subsystem.
+ * Shut down the video subsystem, if initialized with SDL_VideoInit().
  *
- *  This function closes all windows, and restores the original video mode.
+ * This function closes all windows, and restores the original video mode.
  *
- *  \sa SDL_VideoInit()
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_VideoInit
  */
 extern DECLSPEC void SDLCALL SDL_VideoQuit(void);
 
 /**
- *  \brief Returns the name of the currently initialized video driver.
+ * Get the name of the currently initialized video driver.
  *
- *  \return The name of the current video driver or NULL if no driver
- *          has been initialized
+ * \returns the name of the current video driver or NULL if no driver has been
+ *          initialized.
  *
- *  \sa SDL_GetNumVideoDrivers()
- *  \sa SDL_GetVideoDriver()
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetNumVideoDrivers
+ * \sa SDL_GetVideoDriver
  */
 extern DECLSPEC const char *SDLCALL SDL_GetCurrentVideoDriver(void);
 
 /**
- *  \brief Returns the number of available video displays.
+ * Get the number of available video displays.
  *
- *  \sa SDL_GetDisplayBounds()
+ * \returns a number >= 1 or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetDisplayBounds
  */
 extern DECLSPEC int SDLCALL SDL_GetNumVideoDisplays(void);
 
 /**
- *  \brief Get the name of a display in UTF-8 encoding
+ * Get the name of a display in UTF-8 encoding.
  *
- *  \return The name of a display, or NULL for an invalid display index.
+ * \param displayIndex the index of display from which the name should be
+ *                     queried
+ * \returns the name of a display or NULL for an invalid display index or
+ *          failure; call SDL_GetError() for more information.
  *
- *  \sa SDL_GetNumVideoDisplays()
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetNumVideoDisplays
  */
 extern DECLSPEC const char * SDLCALL SDL_GetDisplayName(int displayIndex);
 
 /**
- *  \brief Get the desktop area represented by a display, with the primary
- *         display located at 0,0
+ * Get the desktop area represented by a display.
  *
- *  \return 0 on success, or -1 if the index is out of range.
+ * The primary display (`displayIndex` zero) is always located at 0,0.
  *
- *  \sa SDL_GetNumVideoDisplays()
+ * \param displayIndex the index of the display to query
+ * \param rect the SDL_Rect structure filled in with the display bounds
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetNumVideoDisplays
  */
 extern DECLSPEC int SDLCALL SDL_GetDisplayBounds(int displayIndex, SDL_Rect * rect);
 
 /**
- *  \brief Get the usable desktop area represented by a display, with the
- *         primary display located at 0,0
+ * Get the usable desktop area represented by a display.
  *
- *  This is the same area as SDL_GetDisplayBounds() reports, but with portions
- *  reserved by the system removed. For example, on Mac OS X, this subtracts
- *  the area occupied by the menu bar and dock.
+ * The primary display (`displayIndex` zero) is always located at 0,0.
  *
- *  Setting a window to be fullscreen generally bypasses these unusable areas,
- *  so these are good guidelines for the maximum space available to a
- *  non-fullscreen window.
+ * This is the same area as SDL_GetDisplayBounds() reports, but with portions
+ * reserved by the system removed. For example, on Apple's macOS, this
+ * subtracts the area occupied by the menu bar and dock.
  *
- *  \return 0 on success, or -1 if the index is out of range.
+ * Setting a window to be fullscreen generally bypasses these unusable areas,
+ * so these are good guidelines for the maximum space available to a
+ * non-fullscreen window.
  *
- *  \sa SDL_GetDisplayBounds()
- *  \sa SDL_GetNumVideoDisplays()
+ * The parameter `rect` is ignored if it is NULL.
+ *
+ * This function also returns -1 if the parameter `displayIndex` is out of
+ * range.
+ *
+ * \param displayIndex the index of the display to query the usable bounds
+ *                     from
+ * \param rect the SDL_Rect structure filled in with the display bounds
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.5.
+ *
+ * \sa SDL_GetDisplayBounds
+ * \sa SDL_GetNumVideoDisplays
  */
 extern DECLSPEC int SDLCALL SDL_GetDisplayUsableBounds(int displayIndex, SDL_Rect * rect);
 
 /**
- *  \brief Get the dots/pixels-per-inch for a display
+ * Get the dots/pixels-per-inch for a display.
  *
- *  \note Diagonal, horizontal and vertical DPI can all be optionally
- *        returned if the parameter is non-NULL.
+ * Diagonal, horizontal and vertical DPI can all be optionally returned if the
+ * appropriate parameter is non-NULL.
  *
- *  \return 0 on success, or -1 if no DPI information is available or the index is out of range.
+ * A failure of this function usually means that either no DPI information is
+ * available or the `displayIndex` is out of range.
  *
- *  \sa SDL_GetNumVideoDisplays()
+ * \param displayIndex the index of the display from which DPI information
+ *                     should be queried
+ * \param ddpi a pointer filled in with the diagonal DPI of the display; may
+ *             be NULL
+ * \param hdpi a pointer filled in with the horizontal DPI of the display; may
+ *             be NULL
+ * \param vdpi a pointer filled in with the vertical DPI of the display; may
+ *             be NULL
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.4.
+ *
+ * \sa SDL_GetNumVideoDisplays
  */
 extern DECLSPEC int SDLCALL SDL_GetDisplayDPI(int displayIndex, float * ddpi, float * hdpi, float * vdpi);
 
 /**
- *  \brief Get the orientation of a display
+ * Get the orientation of a display.
  *
- *  \return The orientation of the display, or SDL_ORIENTATION_UNKNOWN if it isn't available.
+ * \param displayIndex the index of the display to query
+ * \returns The SDL_DisplayOrientation enum value of the display, or
+ *          `SDL_ORIENTATION_UNKNOWN` if it isn't available.
  *
- *  \sa SDL_GetNumVideoDisplays()
+ * \since This function is available since SDL 2.0.9.
+ *
+ * \sa SDL_GetNumVideoDisplays
  */
 extern DECLSPEC SDL_DisplayOrientation SDLCALL SDL_GetDisplayOrientation(int displayIndex);
 
 /**
- *  \brief Returns the number of available display modes.
+ * Get the number of available display modes.
  *
- *  \sa SDL_GetDisplayMode()
+ * The `displayIndex` needs to be in the range from 0 to
+ * SDL_GetNumVideoDisplays() - 1.
+ *
+ * \param displayIndex the index of the display to query
+ * \returns a number >= 1 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetDisplayMode
+ * \sa SDL_GetNumVideoDisplays
  */
 extern DECLSPEC int SDLCALL SDL_GetNumDisplayModes(int displayIndex);
 
 /**
- *  \brief Fill in information about a specific display mode.
+ * Get information about a specific display mode.
  *
- *  \note The display modes are sorted in this priority:
- *        \li bits per pixel -> more colors to fewer colors
- *        \li width -> largest to smallest
- *        \li height -> largest to smallest
- *        \li refresh rate -> highest to lowest
+ * The display modes are sorted in this priority:
  *
- *  \sa SDL_GetNumDisplayModes()
+ * - width -> largest to smallest
+ * - height -> largest to smallest
+ * - bits per pixel -> more colors to fewer colors
+ * - packed pixel layout -> largest to smallest
+ * - refresh rate -> highest to lowest
+ *
+ * \param displayIndex the index of the display to query
+ * \param modeIndex the index of the display mode to query
+ * \param mode an SDL_DisplayMode structure filled in with the mode at
+ *             `modeIndex`
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetNumDisplayModes
  */
 extern DECLSPEC int SDLCALL SDL_GetDisplayMode(int displayIndex, int modeIndex,
                                                SDL_DisplayMode * mode);
 
 /**
- *  \brief Fill in information about the desktop display mode.
+ * Get information about the desktop's display mode.
+ *
+ * There's a difference between this function and SDL_GetCurrentDisplayMode()
+ * when SDL runs fullscreen and has changed the resolution. In that case this
+ * function will return the previous native display mode, and not the current
+ * display mode.
+ *
+ * \param displayIndex the index of the display to query
+ * \param mode an SDL_DisplayMode structure filled in with the current display
+ *             mode
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetCurrentDisplayMode
+ * \sa SDL_GetDisplayMode
+ * \sa SDL_SetWindowDisplayMode
  */
 extern DECLSPEC int SDLCALL SDL_GetDesktopDisplayMode(int displayIndex, SDL_DisplayMode * mode);
 
 /**
- *  \brief Fill in information about the current display mode.
+ * Get information about the current display mode.
+ *
+ * There's a difference between this function and SDL_GetDesktopDisplayMode()
+ * when SDL runs fullscreen and has changed the resolution. In that case this
+ * function will return the current display mode, and not the previous native
+ * display mode.
+ *
+ * \param displayIndex the index of the display to query
+ * \param mode an SDL_DisplayMode structure filled in with the current display
+ *             mode
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetDesktopDisplayMode
+ * \sa SDL_GetDisplayMode
+ * \sa SDL_GetNumVideoDisplays
+ * \sa SDL_SetWindowDisplayMode
  */
 extern DECLSPEC int SDLCALL SDL_GetCurrentDisplayMode(int displayIndex, SDL_DisplayMode * mode);
 
 
 /**
- *  \brief Get the closest match to the requested display mode.
+ * Get the closest match to the requested display mode.
  *
- *  \param displayIndex The index of display from which mode should be queried.
- *  \param mode The desired display mode
- *  \param closest A pointer to a display mode to be filled in with the closest
- *                 match of the available display modes.
+ * The available display modes are scanned and `closest` is filled in with the
+ * closest mode matching the requested mode and returned. The mode format and
+ * refresh rate default to the desktop mode if they are set to 0. The modes
+ * are scanned with size being first priority, format being second priority,
+ * and finally checking the refresh rate. If all the available modes are too
+ * small, then NULL is returned.
  *
- *  \return The passed in value \c closest, or NULL if no matching video mode
- *          was available.
+ * \param displayIndex the index of the display to query
+ * \param mode an SDL_DisplayMode structure containing the desired display
+ *             mode
+ * \param closest an SDL_DisplayMode structure filled in with the closest
+ *                match of the available display modes
+ * \returns the passed in value `closest` or NULL if no matching video mode
+ *          was available; call SDL_GetError() for more information.
  *
- *  The available display modes are scanned, and \c closest is filled in with the
- *  closest mode matching the requested mode and returned.  The mode format and
- *  refresh_rate default to the desktop mode if they are 0.  The modes are
- *  scanned with size being first priority, format being second priority, and
- *  finally checking the refresh_rate.  If all the available modes are too
- *  small, then NULL is returned.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_GetNumDisplayModes()
- *  \sa SDL_GetDisplayMode()
+ * \sa SDL_GetDisplayMode
+ * \sa SDL_GetNumDisplayModes
  */
 extern DECLSPEC SDL_DisplayMode * SDLCALL SDL_GetClosestDisplayMode(int displayIndex, const SDL_DisplayMode * mode, SDL_DisplayMode * closest);
 
 /**
- *  \brief Get the display index associated with a window.
+ * Get the index of the display associated with a window.
  *
- *  \return the display index of the display containing the center of the
- *          window, or -1 on error.
+ * \param window the window to query
+ * \returns the index of the display containing the center of the window on
+ *          success or a negative error code on failure; call SDL_GetError()
+ *          for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetDisplayBounds
+ * \sa SDL_GetNumVideoDisplays
  */
 extern DECLSPEC int SDLCALL SDL_GetWindowDisplayIndex(SDL_Window * window);
 
 /**
- *  \brief Set the display mode used when a fullscreen window is visible.
+ * Set the display mode to use when a window is visible at fullscreen.
  *
- *  By default the window's dimensions and the desktop format and refresh rate
- *  are used.
+ * This only affects the display mode used when the window is fullscreen. To
+ * change the window size when the window is not fullscreen, use
+ * SDL_SetWindowSize().
  *
- *  \param window The window for which the display mode should be set.
- *  \param mode The mode to use, or NULL for the default mode.
+ * \param window the window to affect
+ * \param mode the SDL_DisplayMode structure representing the mode to use, or
+ *             NULL to use the window's dimensions and the desktop's format
+ *             and refresh rate
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 if setting the display mode failed.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_GetWindowDisplayMode()
- *  \sa SDL_SetWindowFullscreen()
+ * \sa SDL_GetWindowDisplayMode
+ * \sa SDL_SetWindowFullscreen
  */
 extern DECLSPEC int SDLCALL SDL_SetWindowDisplayMode(SDL_Window * window,
-                                                     const SDL_DisplayMode
-                                                         * mode);
+                                                     const SDL_DisplayMode * mode);
 
 /**
- *  \brief Fill in information about the display mode used when a fullscreen
- *         window is visible.
+ * Query the display mode to use when a window is visible at fullscreen.
  *
- *  \sa SDL_SetWindowDisplayMode()
- *  \sa SDL_SetWindowFullscreen()
+ * \param window the window to query
+ * \param mode an SDL_DisplayMode structure filled in with the fullscreen
+ *             display mode
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_SetWindowDisplayMode
+ * \sa SDL_SetWindowFullscreen
  */
 extern DECLSPEC int SDLCALL SDL_GetWindowDisplayMode(SDL_Window * window,
                                                      SDL_DisplayMode * mode);
 
 /**
- *  \brief Get the pixel format associated with the window.
+ * Get the raw ICC profile data for the screen the window is currently on.
+ *
+ * Data returned should be freed with SDL_free.
+ *
+ * \param window the window to query
+ * \param size the size of the ICC profile
+ * \returns the raw ICC profile data on success or NULL on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.18.
+ */
+extern DECLSPEC void* SDLCALL SDL_GetWindowICCProfile(SDL_Window * window, size_t* size);
+
+/**
+ * Get the pixel format associated with the window.
+ *
+ * \param window the window to query
+ * \returns the pixel format of the window on success or
+ *          SDL_PIXELFORMAT_UNKNOWN on failure; call SDL_GetError() for more
+ *          information.
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC Uint32 SDLCALL SDL_GetWindowPixelFormat(SDL_Window * window);
 
 /**
- *  \brief Create a window with the specified position, dimensions, and flags.
+ * Create a window with the specified position, dimensions, and flags.
  *
- *  \param title The title of the window, in UTF-8 encoding.
- *  \param x     The x position of the window, ::SDL_WINDOWPOS_CENTERED, or
- *               ::SDL_WINDOWPOS_UNDEFINED.
- *  \param y     The y position of the window, ::SDL_WINDOWPOS_CENTERED, or
- *               ::SDL_WINDOWPOS_UNDEFINED.
- *  \param w     The width of the window, in screen coordinates.
- *  \param h     The height of the window, in screen coordinates.
- *  \param flags The flags for the window, a mask of any of the following:
- *               ::SDL_WINDOW_FULLSCREEN,    ::SDL_WINDOW_OPENGL,
- *               ::SDL_WINDOW_HIDDEN,        ::SDL_WINDOW_BORDERLESS,
- *               ::SDL_WINDOW_RESIZABLE,     ::SDL_WINDOW_MAXIMIZED,
- *               ::SDL_WINDOW_MINIMIZED,     ::SDL_WINDOW_INPUT_GRABBED,
- *               ::SDL_WINDOW_ALLOW_HIGHDPI, ::SDL_WINDOW_VULKAN
- *               ::SDL_WINDOW_METAL.
+ * `flags` may be any of the following OR'd together:
  *
- *  \return The created window, or NULL if window creation failed.
+ * - `SDL_WINDOW_FULLSCREEN`: fullscreen window
+ * - `SDL_WINDOW_FULLSCREEN_DESKTOP`: fullscreen window at desktop resolution
+ * - `SDL_WINDOW_OPENGL`: window usable with an OpenGL context
+ * - `SDL_WINDOW_VULKAN`: window usable with a Vulkan instance
+ * - `SDL_WINDOW_METAL`: window usable with a Metal instance
+ * - `SDL_WINDOW_HIDDEN`: window is not visible
+ * - `SDL_WINDOW_BORDERLESS`: no window decoration
+ * - `SDL_WINDOW_RESIZABLE`: window can be resized
+ * - `SDL_WINDOW_MINIMIZED`: window is minimized
+ * - `SDL_WINDOW_MAXIMIZED`: window is maximized
+ * - `SDL_WINDOW_INPUT_GRABBED`: window has grabbed input focus
+ * - `SDL_WINDOW_ALLOW_HIGHDPI`: window should be created in high-DPI mode if
+ *   supported (>= SDL 2.0.1)
  *
- *  If the window is created with the SDL_WINDOW_ALLOW_HIGHDPI flag, its size
- *  in pixels may differ from its size in screen coordinates on platforms with
- *  high-DPI support (e.g. iOS and Mac OS X). Use SDL_GetWindowSize() to query
- *  the client area's size in screen coordinates, and SDL_GL_GetDrawableSize(),
- *  SDL_Vulkan_GetDrawableSize(), or SDL_GetRendererOutputSize() to query the
- *  drawable size in pixels.
+ * `SDL_WINDOW_SHOWN` is ignored by SDL_CreateWindow(). The SDL_Window is
+ * implicitly shown if SDL_WINDOW_HIDDEN is not set. `SDL_WINDOW_SHOWN` may be
+ * queried later using SDL_GetWindowFlags().
  *
- *  If the window is created with any of the SDL_WINDOW_OPENGL or
- *  SDL_WINDOW_VULKAN flags, then the corresponding LoadLibrary function
- *  (SDL_GL_LoadLibrary or SDL_Vulkan_LoadLibrary) is called and the
- *  corresponding UnloadLibrary function is called by SDL_DestroyWindow().
+ * On Apple's macOS, you **must** set the NSHighResolutionCapable Info.plist
+ * property to YES, otherwise you will not receive a High-DPI OpenGL canvas.
  *
- *  If SDL_WINDOW_VULKAN is specified and there isn't a working Vulkan driver,
- *  SDL_CreateWindow() will fail because SDL_Vulkan_LoadLibrary() will fail.
+ * If the window is created with the `SDL_WINDOW_ALLOW_HIGHDPI` flag, its size
+ * in pixels may differ from its size in screen coordinates on platforms with
+ * high-DPI support (e.g. iOS and macOS). Use SDL_GetWindowSize() to query the
+ * client area's size in screen coordinates, and SDL_GL_GetDrawableSize() or
+ * SDL_GetRendererOutputSize() to query the drawable size in pixels.
  *
- *  If SDL_WINDOW_METAL is specified on an OS that does not support Metal,
- *  SDL_CreateWindow() will fail.
+ * If the window is set fullscreen, the width and height parameters `w` and
+ * `h` will not be used. However, invalid size parameters (e.g. too large) may
+ * still fail. Window size is actually limited to 16384 x 16384 for all
+ * platforms at window creation.
  *
- *  \note On non-Apple devices, SDL requires you to either not link to the
- *        Vulkan loader or link to a dynamic library version. This limitation
- *        may be removed in a future version of SDL.
+ * If the window is created with any of the SDL_WINDOW_OPENGL or
+ * SDL_WINDOW_VULKAN flags, then the corresponding LoadLibrary function
+ * (SDL_GL_LoadLibrary or SDL_Vulkan_LoadLibrary) is called and the
+ * corresponding UnloadLibrary function is called by SDL_DestroyWindow().
  *
- *  \sa SDL_DestroyWindow()
- *  \sa SDL_GL_LoadLibrary()
- *  \sa SDL_Vulkan_LoadLibrary()
+ * If SDL_WINDOW_VULKAN is specified and there isn't a working Vulkan driver,
+ * SDL_CreateWindow() will fail because SDL_Vulkan_LoadLibrary() will fail.
+ *
+ * If SDL_WINDOW_METAL is specified on an OS that does not support Metal,
+ * SDL_CreateWindow() will fail.
+ *
+ * On non-Apple devices, SDL requires you to either not link to the Vulkan
+ * loader or link to a dynamic library version. This limitation may be removed
+ * in a future version of SDL.
+ *
+ * \param title the title of the window, in UTF-8 encoding
+ * \param x the x position of the window, `SDL_WINDOWPOS_CENTERED`, or
+ *          `SDL_WINDOWPOS_UNDEFINED`
+ * \param y the y position of the window, `SDL_WINDOWPOS_CENTERED`, or
+ *          `SDL_WINDOWPOS_UNDEFINED`
+ * \param w the width of the window, in screen coordinates
+ * \param h the height of the window, in screen coordinates
+ * \param flags 0, or one or more SDL_WindowFlags OR'd together
+ * \returns the window that was created or NULL on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateWindowFrom
+ * \sa SDL_DestroyWindow
  */
 extern DECLSPEC SDL_Window * SDLCALL SDL_CreateWindow(const char *title,
                                                       int x, int y, int w,
                                                       int h, Uint32 flags);
 
 /**
- *  \brief Create an SDL window from an existing native window.
+ * Create an SDL window from an existing native window.
  *
- *  \param data A pointer to driver-dependent window creation data
+ * In some cases (e.g. OpenGL) and on some platforms (e.g. Microsoft Windows)
+ * the hint `SDL_HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT` needs to be configured
+ * before using SDL_CreateWindowFrom().
  *
- *  \return The created window, or NULL if window creation failed.
+ * \param data a pointer to driver-dependent window creation data, typically
+ *             your native window cast to a void*
+ * \returns the window that was created or NULL on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \sa SDL_DestroyWindow()
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateWindow
+ * \sa SDL_DestroyWindow
  */
 extern DECLSPEC SDL_Window * SDLCALL SDL_CreateWindowFrom(const void *data);
 
 /**
- *  \brief Get the numeric ID of a window, for logging purposes.
+ * Get the numeric ID of a window.
+ *
+ * The numeric ID is what SDL_WindowEvent references, and is necessary to map
+ * these events to specific SDL_Window objects.
+ *
+ * \param window the window to query
+ * \returns the ID of the window on success or 0 on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetWindowFromID
  */
 extern DECLSPEC Uint32 SDLCALL SDL_GetWindowID(SDL_Window * window);
 
 /**
- *  \brief Get a window from a stored ID, or NULL if it doesn't exist.
+ * Get a window from a stored ID.
+ *
+ * The numeric ID is what SDL_WindowEvent references, and is necessary to map
+ * these events to specific SDL_Window objects.
+ *
+ * \param id the ID of the window
+ * \returns the window associated with `id` or NULL if it doesn't exist; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetWindowID
  */
 extern DECLSPEC SDL_Window * SDLCALL SDL_GetWindowFromID(Uint32 id);
 
 /**
- *  \brief Get the window flags.
+ * Get the window flags.
+ *
+ * \param window the window to query
+ * \returns a mask of the SDL_WindowFlags associated with `window`
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateWindow
+ * \sa SDL_HideWindow
+ * \sa SDL_MaximizeWindow
+ * \sa SDL_MinimizeWindow
+ * \sa SDL_SetWindowFullscreen
+ * \sa SDL_SetWindowGrab
+ * \sa SDL_ShowWindow
  */
 extern DECLSPEC Uint32 SDLCALL SDL_GetWindowFlags(SDL_Window * window);
 
 /**
- *  \brief Set the title of a window, in UTF-8 format.
+ * Set the title of a window.
  *
- *  \sa SDL_GetWindowTitle()
+ * This string is expected to be in UTF-8 encoding.
+ *
+ * \param window the window to change
+ * \param title the desired window title in UTF-8 format
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetWindowTitle
  */
 extern DECLSPEC void SDLCALL SDL_SetWindowTitle(SDL_Window * window,
                                                 const char *title);
 
 /**
- *  \brief Get the title of a window, in UTF-8 format.
+ * Get the title of a window.
  *
- *  \sa SDL_SetWindowTitle()
+ * \param window the window to query
+ * \returns the title of the window in UTF-8 format or "" if there is no
+ *          title.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_SetWindowTitle
  */
 extern DECLSPEC const char *SDLCALL SDL_GetWindowTitle(SDL_Window * window);
 
 /**
- *  \brief Set the icon for a window.
+ * Set the icon for a window.
  *
- *  \param window The window for which the icon should be set.
- *  \param icon The icon for the window.
+ * \param window the window to change
+ * \param icon an SDL_Surface structure containing the icon for the window
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC void SDLCALL SDL_SetWindowIcon(SDL_Window * window,
                                                SDL_Surface * icon);
 
 /**
- *  \brief Associate an arbitrary named pointer with a window.
+ * Associate an arbitrary named pointer with a window.
  *
- *  \param window   The window to associate with the pointer.
- *  \param name     The name of the pointer.
- *  \param userdata The associated pointer.
+ * `name` is case-sensitive.
  *
- *  \return The previous value associated with 'name'
+ * \param window the window to associate with the pointer
+ * \param name the name of the pointer
+ * \param userdata the associated pointer
+ * \returns the previous value associated with `name`.
  *
- *  \note The name is case-sensitive.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_GetWindowData()
+ * \sa SDL_GetWindowData
  */
 extern DECLSPEC void* SDLCALL SDL_SetWindowData(SDL_Window * window,
                                                 const char *name,
                                                 void *userdata);
 
 /**
- *  \brief Retrieve the data pointer associated with a window.
+ * Retrieve the data pointer associated with a window.
  *
- *  \param window   The window to query.
- *  \param name     The name of the pointer.
+ * \param window the window to query
+ * \param name the name of the pointer
+ * \returns the value associated with `name`.
  *
- *  \return The value associated with 'name'
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_SetWindowData()
+ * \sa SDL_SetWindowData
  */
 extern DECLSPEC void *SDLCALL SDL_GetWindowData(SDL_Window * window,
                                                 const char *name);
 
 /**
- *  \brief Set the position of a window.
+ * Set the position of a window.
  *
- *  \param window   The window to reposition.
- *  \param x        The x coordinate of the window in screen coordinates, or
- *                  ::SDL_WINDOWPOS_CENTERED or ::SDL_WINDOWPOS_UNDEFINED.
- *  \param y        The y coordinate of the window in screen coordinates, or
- *                  ::SDL_WINDOWPOS_CENTERED or ::SDL_WINDOWPOS_UNDEFINED.
+ * The window coordinate origin is the upper left of the display.
  *
- *  \note The window coordinate origin is the upper left of the display.
+ * \param window the window to reposition
+ * \param x the x coordinate of the window in screen coordinates, or
+ *          `SDL_WINDOWPOS_CENTERED` or `SDL_WINDOWPOS_UNDEFINED`
+ * \param y the y coordinate of the window in screen coordinates, or
+ *          `SDL_WINDOWPOS_CENTERED` or `SDL_WINDOWPOS_UNDEFINED`
  *
- *  \sa SDL_GetWindowPosition()
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetWindowPosition
  */
 extern DECLSPEC void SDLCALL SDL_SetWindowPosition(SDL_Window * window,
                                                    int x, int y);
 
 /**
- *  \brief Get the position of a window.
+ * Get the position of a window.
  *
- *  \param window   The window to query.
- *  \param x        Pointer to variable for storing the x position, in screen
- *                  coordinates. May be NULL.
- *  \param y        Pointer to variable for storing the y position, in screen
- *                  coordinates. May be NULL.
+ * If you do not need the value for one of the positions a NULL may be passed
+ * in the `x` or `y` parameter.
  *
- *  \sa SDL_SetWindowPosition()
+ * \param window the window to query
+ * \param x a pointer filled in with the x position of the window, in screen
+ *          coordinates, may be NULL
+ * \param y a pointer filled in with the y position of the window, in screen
+ *          coordinates, may be NULL
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_SetWindowPosition
  */
 extern DECLSPEC void SDLCALL SDL_GetWindowPosition(SDL_Window * window,
                                                    int *x, int *y);
 
 /**
- *  \brief Set the size of a window's client area.
+ * Set the size of a window's client area.
  *
- *  \param window   The window to resize.
- *  \param w        The width of the window, in screen coordinates. Must be >0.
- *  \param h        The height of the window, in screen coordinates. Must be >0.
+ * The window size in screen coordinates may differ from the size in pixels,
+ * if the window was created with `SDL_WINDOW_ALLOW_HIGHDPI` on a platform
+ * with high-dpi support (e.g. iOS or macOS). Use SDL_GL_GetDrawableSize() or
+ * SDL_GetRendererOutputSize() to get the real client area size in pixels.
  *
- *  \note Fullscreen windows automatically match the size of the display mode,
- *        and you should use SDL_SetWindowDisplayMode() to change their size.
+ * Fullscreen windows automatically match the size of the display mode, and
+ * you should use SDL_SetWindowDisplayMode() to change their size.
  *
- *  The window size in screen coordinates may differ from the size in pixels, if
- *  the window was created with SDL_WINDOW_ALLOW_HIGHDPI on a platform with
- *  high-dpi support (e.g. iOS or OS X). Use SDL_GL_GetDrawableSize() or
- *  SDL_GetRendererOutputSize() to get the real client area size in pixels.
+ * \param window the window to change
+ * \param w the width of the window in pixels, in screen coordinates, must be
+ *          > 0
+ * \param h the height of the window in pixels, in screen coordinates, must be
+ *          > 0
  *
- *  \sa SDL_GetWindowSize()
- *  \sa SDL_SetWindowDisplayMode()
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetWindowSize
+ * \sa SDL_SetWindowDisplayMode
  */
 extern DECLSPEC void SDLCALL SDL_SetWindowSize(SDL_Window * window, int w,
                                                int h);
 
 /**
- *  \brief Get the size of a window's client area.
+ * Get the size of a window's client area.
  *
- *  \param window   The window to query.
- *  \param w        Pointer to variable for storing the width, in screen
- *                  coordinates. May be NULL.
- *  \param h        Pointer to variable for storing the height, in screen
- *                  coordinates. May be NULL.
+ * NULL can safely be passed as the `w` or `h` parameter if the width or
+ * height value is not desired.
  *
- *  The window size in screen coordinates may differ from the size in pixels, if
- *  the window was created with SDL_WINDOW_ALLOW_HIGHDPI on a platform with
- *  high-dpi support (e.g. iOS or OS X). Use SDL_GL_GetDrawableSize() or
- *  SDL_GetRendererOutputSize() to get the real client area size in pixels.
+ * The window size in screen coordinates may differ from the size in pixels,
+ * if the window was created with `SDL_WINDOW_ALLOW_HIGHDPI` on a platform
+ * with high-dpi support (e.g. iOS or macOS). Use SDL_GL_GetDrawableSize(),
+ * SDL_Vulkan_GetDrawableSize(), or SDL_GetRendererOutputSize() to get the
+ * real client area size in pixels.
  *
- *  \sa SDL_SetWindowSize()
+ * \param window the window to query the width and height from
+ * \param w a pointer filled in with the width of the window, in screen
+ *          coordinates, may be NULL
+ * \param h a pointer filled in with the height of the window, in screen
+ *          coordinates, may be NULL
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GL_GetDrawableSize
+ * \sa SDL_Vulkan_GetDrawableSize
+ * \sa SDL_SetWindowSize
  */
 extern DECLSPEC void SDLCALL SDL_GetWindowSize(SDL_Window * window, int *w,
                                                int *h);
 
 /**
- *  \brief Get the size of a window's borders (decorations) around the client area.
+ * Get the size of a window's borders (decorations) around the client area.
  *
- *  \param window The window to query.
- *  \param top Pointer to variable for storing the size of the top border. NULL is permitted.
- *  \param left Pointer to variable for storing the size of the left border. NULL is permitted.
- *  \param bottom Pointer to variable for storing the size of the bottom border. NULL is permitted.
- *  \param right Pointer to variable for storing the size of the right border. NULL is permitted.
+ * Note: If this function fails (returns -1), the size values will be
+ * initialized to 0, 0, 0, 0 (if a non-NULL pointer is provided), as if the
+ * window in question was borderless.
  *
- *  \return 0 on success, or -1 if getting this information is not supported.
+ * Note: This function may fail on systems where the window has not yet been
+ * decorated by the display server (for example, immediately after calling
+ * SDL_CreateWindow). It is recommended that you wait at least until the
+ * window has been presented and composited, so that the window system has a
+ * chance to decorate the window and provide the border dimensions to SDL.
  *
- *  \note if this function fails (returns -1), the size values will be
- *        initialized to 0, 0, 0, 0 (if a non-NULL pointer is provided), as
- *        if the window in question was borderless.
+ * This function also returns -1 if getting the information is not supported.
+ *
+ * \param window the window to query the size values of the border
+ *               (decorations) from
+ * \param top pointer to variable for storing the size of the top border; NULL
+ *            is permitted
+ * \param left pointer to variable for storing the size of the left border;
+ *             NULL is permitted
+ * \param bottom pointer to variable for storing the size of the bottom
+ *               border; NULL is permitted
+ * \param right pointer to variable for storing the size of the right border;
+ *              NULL is permitted
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.5.
+ *
+ * \sa SDL_GetWindowSize
  */
 extern DECLSPEC int SDLCALL SDL_GetWindowBordersSize(SDL_Window * window,
                                                      int *top, int *left,
                                                      int *bottom, int *right);
 
 /**
- *  \brief Set the minimum size of a window's client area.
+ * Set the minimum size of a window's client area.
  *
- *  \param window    The window to set a new minimum size.
- *  \param min_w     The minimum width of the window, must be >0
- *  \param min_h     The minimum height of the window, must be >0
+ * \param window the window to change
+ * \param min_w the minimum width of the window in pixels
+ * \param min_h the minimum height of the window in pixels
  *
- *  \note You can't change the minimum size of a fullscreen window, it
- *        automatically matches the size of the display mode.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_GetWindowMinimumSize()
- *  \sa SDL_SetWindowMaximumSize()
+ * \sa SDL_GetWindowMinimumSize
+ * \sa SDL_SetWindowMaximumSize
  */
 extern DECLSPEC void SDLCALL SDL_SetWindowMinimumSize(SDL_Window * window,
                                                       int min_w, int min_h);
 
 /**
- *  \brief Get the minimum size of a window's client area.
+ * Get the minimum size of a window's client area.
  *
- *  \param window   The window to query.
- *  \param w        Pointer to variable for storing the minimum width, may be NULL
- *  \param h        Pointer to variable for storing the minimum height, may be NULL
+ * \param window the window to query
+ * \param w a pointer filled in with the minimum width of the window, may be
+ *          NULL
+ * \param h a pointer filled in with the minimum height of the window, may be
+ *          NULL
  *
- *  \sa SDL_GetWindowMaximumSize()
- *  \sa SDL_SetWindowMinimumSize()
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetWindowMaximumSize
+ * \sa SDL_SetWindowMinimumSize
  */
 extern DECLSPEC void SDLCALL SDL_GetWindowMinimumSize(SDL_Window * window,
                                                       int *w, int *h);
 
 /**
- *  \brief Set the maximum size of a window's client area.
+ * Set the maximum size of a window's client area.
  *
- *  \param window    The window to set a new maximum size.
- *  \param max_w     The maximum width of the window, must be >0
- *  \param max_h     The maximum height of the window, must be >0
+ * \param window the window to change
+ * \param max_w the maximum width of the window in pixels
+ * \param max_h the maximum height of the window in pixels
  *
- *  \note You can't change the maximum size of a fullscreen window, it
- *        automatically matches the size of the display mode.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_GetWindowMaximumSize()
- *  \sa SDL_SetWindowMinimumSize()
+ * \sa SDL_GetWindowMaximumSize
+ * \sa SDL_SetWindowMinimumSize
  */
 extern DECLSPEC void SDLCALL SDL_SetWindowMaximumSize(SDL_Window * window,
                                                       int max_w, int max_h);
 
 /**
- *  \brief Get the maximum size of a window's client area.
+ * Get the maximum size of a window's client area.
  *
- *  \param window   The window to query.
- *  \param w        Pointer to variable for storing the maximum width, may be NULL
- *  \param h        Pointer to variable for storing the maximum height, may be NULL
+ * \param window the window to query
+ * \param w a pointer filled in with the maximum width of the window, may be
+ *          NULL
+ * \param h a pointer filled in with the maximum height of the window, may be
+ *          NULL
  *
- *  \sa SDL_GetWindowMinimumSize()
- *  \sa SDL_SetWindowMaximumSize()
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetWindowMinimumSize
+ * \sa SDL_SetWindowMaximumSize
  */
 extern DECLSPEC void SDLCALL SDL_GetWindowMaximumSize(SDL_Window * window,
                                                       int *w, int *h);
 
 /**
- *  \brief Set the border state of a window.
+ * Set the border state of a window.
  *
- *  This will add or remove the window's SDL_WINDOW_BORDERLESS flag and
- *  add or remove the border from the actual window. This is a no-op if the
- *  window's border already matches the requested state.
+ * This will add or remove the window's `SDL_WINDOW_BORDERLESS` flag and add
+ * or remove the border from the actual window. This is a no-op if the
+ * window's border already matches the requested state.
  *
- *  \param window The window of which to change the border state.
- *  \param bordered SDL_FALSE to remove border, SDL_TRUE to add border.
+ * You can't change the border state of a fullscreen window.
  *
- *  \note You can't change the border state of a fullscreen window.
+ * \param window the window of which to change the border state
+ * \param bordered SDL_FALSE to remove border, SDL_TRUE to add border
  *
- *  \sa SDL_GetWindowFlags()
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetWindowFlags
  */
 extern DECLSPEC void SDLCALL SDL_SetWindowBordered(SDL_Window * window,
                                                    SDL_bool bordered);
 
 /**
- *  \brief Set the user-resizable state of a window.
+ * Set the user-resizable state of a window.
  *
- *  This will add or remove the window's SDL_WINDOW_RESIZABLE flag and
- *  allow/disallow user resizing of the window. This is a no-op if the
- *  window's resizable state already matches the requested state.
+ * This will add or remove the window's `SDL_WINDOW_RESIZABLE` flag and
+ * allow/disallow user resizing of the window. This is a no-op if the window's
+ * resizable state already matches the requested state.
  *
- *  \param window The window of which to change the resizable state.
- *  \param resizable SDL_TRUE to allow resizing, SDL_FALSE to disallow.
+ * You can't change the resizable state of a fullscreen window.
  *
- *  \note You can't change the resizable state of a fullscreen window.
+ * \param window the window of which to change the resizable state
+ * \param resizable SDL_TRUE to allow resizing, SDL_FALSE to disallow
  *
- *  \sa SDL_GetWindowFlags()
+ * \since This function is available since SDL 2.0.5.
+ *
+ * \sa SDL_GetWindowFlags
  */
 extern DECLSPEC void SDLCALL SDL_SetWindowResizable(SDL_Window * window,
                                                     SDL_bool resizable);
 
 /**
- *  \brief Show a window.
+ * Set the window to always be above the others.
  *
- *  \sa SDL_HideWindow()
+ * This will add or remove the window's `SDL_WINDOW_ALWAYS_ON_TOP` flag. This
+ * will bring the window to the front and keep the window above the rest.
+ *
+ * \param window The window of which to change the always on top state
+ * \param on_top SDL_TRUE to set the window always on top, SDL_FALSE to
+ *               disable
+ *
+ * \since This function is available since SDL 2.0.16.
+ *
+ * \sa SDL_GetWindowFlags
+ */
+extern DECLSPEC void SDLCALL SDL_SetWindowAlwaysOnTop(SDL_Window * window,
+                                                      SDL_bool on_top);
+
+/**
+ * Show a window.
+ *
+ * \param window the window to show
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_HideWindow
+ * \sa SDL_RaiseWindow
  */
 extern DECLSPEC void SDLCALL SDL_ShowWindow(SDL_Window * window);
 
 /**
- *  \brief Hide a window.
+ * Hide a window.
  *
- *  \sa SDL_ShowWindow()
+ * \param window the window to hide
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_ShowWindow
  */
 extern DECLSPEC void SDLCALL SDL_HideWindow(SDL_Window * window);
 
 /**
- *  \brief Raise a window above other windows and set the input focus.
+ * Raise a window above other windows and set the input focus.
+ *
+ * \param window the window to raise
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC void SDLCALL SDL_RaiseWindow(SDL_Window * window);
 
 /**
- *  \brief Make a window as large as possible.
+ * Make a window as large as possible.
  *
- *  \sa SDL_RestoreWindow()
+ * \param window the window to maximize
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_MinimizeWindow
+ * \sa SDL_RestoreWindow
  */
 extern DECLSPEC void SDLCALL SDL_MaximizeWindow(SDL_Window * window);
 
 /**
- *  \brief Minimize a window to an iconic representation.
+ * Minimize a window to an iconic representation.
  *
- *  \sa SDL_RestoreWindow()
+ * \param window the window to minimize
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_MaximizeWindow
+ * \sa SDL_RestoreWindow
  */
 extern DECLSPEC void SDLCALL SDL_MinimizeWindow(SDL_Window * window);
 
 /**
- *  \brief Restore the size and position of a minimized or maximized window.
+ * Restore the size and position of a minimized or maximized window.
  *
- *  \sa SDL_MaximizeWindow()
- *  \sa SDL_MinimizeWindow()
+ * \param window the window to restore
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_MaximizeWindow
+ * \sa SDL_MinimizeWindow
  */
 extern DECLSPEC void SDLCALL SDL_RestoreWindow(SDL_Window * window);
 
 /**
- *  \brief Set a window's fullscreen state.
+ * Set a window's fullscreen state.
  *
- *  \return 0 on success, or -1 if setting the display mode failed.
+ * `flags` may be `SDL_WINDOW_FULLSCREEN`, for "real" fullscreen with a
+ * videomode change; `SDL_WINDOW_FULLSCREEN_DESKTOP` for "fake" fullscreen
+ * that takes the size of the desktop; and 0 for windowed mode.
  *
- *  \sa SDL_SetWindowDisplayMode()
- *  \sa SDL_GetWindowDisplayMode()
+ * \param window the window to change
+ * \param flags `SDL_WINDOW_FULLSCREEN`, `SDL_WINDOW_FULLSCREEN_DESKTOP` or 0
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetWindowDisplayMode
+ * \sa SDL_SetWindowDisplayMode
  */
 extern DECLSPEC int SDLCALL SDL_SetWindowFullscreen(SDL_Window * window,
                                                     Uint32 flags);
 
 /**
- *  \brief Get the SDL surface associated with the window.
+ * Get the SDL surface associated with the window.
  *
- *  \return The window's framebuffer surface, or NULL on error.
+ * A new surface will be created with the optimal format for the window, if
+ * necessary. This surface will be freed when the window is destroyed. Do not
+ * free this surface.
  *
- *  A new surface will be created with the optimal format for the window,
- *  if necessary. This surface will be freed when the window is destroyed.
+ * This surface will be invalidated if the window is resized. After resizing a
+ * window this function must be called again to return a valid surface.
  *
- *  \note You may not combine this with 3D or the rendering API on this window.
+ * You may not combine this with 3D or the rendering API on this window.
  *
- *  \sa SDL_UpdateWindowSurface()
- *  \sa SDL_UpdateWindowSurfaceRects()
+ * This function is affected by `SDL_HINT_FRAMEBUFFER_ACCELERATION`.
+ *
+ * \param window the window to query
+ * \returns the surface associated with the window, or NULL on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_UpdateWindowSurface
+ * \sa SDL_UpdateWindowSurfaceRects
  */
 extern DECLSPEC SDL_Surface * SDLCALL SDL_GetWindowSurface(SDL_Window * window);
 
 /**
- *  \brief Copy the window surface to the screen.
+ * Copy the window surface to the screen.
  *
- *  \return 0 on success, or -1 on error.
+ * This is the function you use to reflect any changes to the surface on the
+ * screen.
  *
- *  \sa SDL_GetWindowSurface()
- *  \sa SDL_UpdateWindowSurfaceRects()
+ * This function is equivalent to the SDL 1.2 API SDL_Flip().
+ *
+ * \param window the window to update
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetWindowSurface
+ * \sa SDL_UpdateWindowSurfaceRects
  */
 extern DECLSPEC int SDLCALL SDL_UpdateWindowSurface(SDL_Window * window);
 
 /**
- *  \brief Copy a number of rectangles on the window surface to the screen.
+ * Copy areas of the window surface to the screen.
  *
- *  \return 0 on success, or -1 on error.
+ * This is the function you use to reflect changes to portions of the surface
+ * on the screen.
  *
- *  \sa SDL_GetWindowSurface()
- *  \sa SDL_UpdateWindowSurface()
+ * This function is equivalent to the SDL 1.2 API SDL_UpdateRects().
+ *
+ * \param window the window to update
+ * \param rects an array of SDL_Rect structures representing areas of the
+ *              surface to copy
+ * \param numrects the number of rectangles
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetWindowSurface
+ * \sa SDL_UpdateWindowSurface
  */
 extern DECLSPEC int SDLCALL SDL_UpdateWindowSurfaceRects(SDL_Window * window,
                                                          const SDL_Rect * rects,
                                                          int numrects);
 
 /**
- *  \brief Set a window's input grab mode.
+ * Set a window's input grab mode.
  *
- *  \param window The window for which the input grab mode should be set.
- *  \param grabbed This is SDL_TRUE to grab input, and SDL_FALSE to release input.
+ * When input is grabbed, the mouse is confined to the window. This function
+ * will also grab the keyboard if `SDL_HINT_GRAB_KEYBOARD` is set. To grab the
+ * keyboard without also grabbing the mouse, use SDL_SetWindowKeyboardGrab().
  *
- *  If the caller enables a grab while another window is currently grabbed,
- *  the other window loses its grab in favor of the caller's window.
+ * If the caller enables a grab while another window is currently grabbed, the
+ * other window loses its grab in favor of the caller's window.
  *
- *  \sa SDL_GetWindowGrab()
+ * \param window the window for which the input grab mode should be set
+ * \param grabbed SDL_TRUE to grab input or SDL_FALSE to release input
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetGrabbedWindow
+ * \sa SDL_GetWindowGrab
  */
 extern DECLSPEC void SDLCALL SDL_SetWindowGrab(SDL_Window * window,
                                                SDL_bool grabbed);
 
 /**
- *  \brief Get a window's input grab mode.
+ * Set a window's keyboard grab mode.
  *
- *  \return This returns SDL_TRUE if input is grabbed, and SDL_FALSE otherwise.
+ * Keyboard grab enables capture of system keyboard shortcuts like Alt+Tab or
+ * the Meta/Super key. Note that not all system keyboard shortcuts can be
+ * captured by applications (one example is Ctrl+Alt+Del on Windows).
  *
- *  \sa SDL_SetWindowGrab()
+ * This is primarily intended for specialized applications such as VNC clients
+ * or VM frontends. Normal games should not use keyboard grab.
+ *
+ * When keyboard grab is enabled, SDL will continue to handle Alt+Tab when the
+ * window is full-screen to ensure the user is not trapped in your
+ * application. If you have a custom keyboard shortcut to exit fullscreen
+ * mode, you may suppress this behavior with
+ * `SDL_HINT_ALLOW_ALT_TAB_WHILE_GRABBED`.
+ *
+ * If the caller enables a grab while another window is currently grabbed, the
+ * other window loses its grab in favor of the caller's window.
+ *
+ * \param window The window for which the keyboard grab mode should be set.
+ * \param grabbed This is SDL_TRUE to grab keyboard, and SDL_FALSE to release.
+ *
+ * \since This function is available since SDL 2.0.16.
+ *
+ * \sa SDL_GetWindowKeyboardGrab
+ * \sa SDL_SetWindowMouseGrab
+ * \sa SDL_SetWindowGrab
+ */
+extern DECLSPEC void SDLCALL SDL_SetWindowKeyboardGrab(SDL_Window * window,
+                                                       SDL_bool grabbed);
+
+/**
+ * Set a window's mouse grab mode.
+ *
+ * Mouse grab confines the mouse cursor to the window.
+ *
+ * \param window The window for which the mouse grab mode should be set.
+ *
+ * \since This function is available since SDL 2.0.16.
+ *
+ * \sa SDL_GetWindowMouseGrab
+ * \sa SDL_SetWindowKeyboardGrab
+ * \sa SDL_SetWindowGrab
+ */
+extern DECLSPEC void SDLCALL SDL_SetWindowMouseGrab(SDL_Window * window,
+                                                    SDL_bool grabbed);
+
+/**
+ * Get a window's input grab mode.
+ *
+ * \param window the window to query
+ * \returns SDL_TRUE if input is grabbed, SDL_FALSE otherwise.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_SetWindowGrab
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_GetWindowGrab(SDL_Window * window);
 
 /**
- *  \brief Get the window that currently has an input grab enabled.
+ * Get a window's keyboard grab mode.
  *
- *  \return This returns the window if input is grabbed, and NULL otherwise.
+ * \param window the window to query
+ * \returns SDL_TRUE if keyboard is grabbed, and SDL_FALSE otherwise.
  *
- *  \sa SDL_SetWindowGrab()
+ * \since This function is available since SDL 2.0.16.
+ *
+ * \sa SDL_SetWindowKeyboardGrab
+ * \sa SDL_GetWindowGrab
+ */
+extern DECLSPEC SDL_bool SDLCALL SDL_GetWindowKeyboardGrab(SDL_Window * window);
+
+/**
+ * Get a window's mouse grab mode.
+ *
+ * \param window the window to query
+ * \returns SDL_TRUE if mouse is grabbed, and SDL_FALSE otherwise.
+ *
+ * \since This function is available since SDL 2.0.16.
+ *
+ * \sa SDL_SetWindowKeyboardGrab
+ * \sa SDL_GetWindowGrab
+ */
+extern DECLSPEC SDL_bool SDLCALL SDL_GetWindowMouseGrab(SDL_Window * window);
+
+/**
+ * Get the window that currently has an input grab enabled.
+ *
+ * \returns the window if input is grabbed or NULL otherwise.
+ *
+ * \since This function is available since SDL 2.0.4.
+ *
+ * \sa SDL_GetWindowGrab
+ * \sa SDL_SetWindowGrab
  */
 extern DECLSPEC SDL_Window * SDLCALL SDL_GetGrabbedWindow(void);
 
 /**
- *  \brief Set the brightness (gamma correction) for a window.
+ * Confines the cursor to the specified area of a window.
  *
- *  \return 0 on success, or -1 if setting the brightness isn't supported.
+ * Note that this does NOT grab the cursor, it only defines the area a cursor
+ * is restricted to when the window has mouse focus.
  *
- *  \sa SDL_GetWindowBrightness()
- *  \sa SDL_SetWindowGammaRamp()
+ * \param window The window that will be associated with the barrier.
+ * \param rect A rectangle area in window-relative coordinates. If NULL the
+ *             barrier for the specified window will be destroyed.
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.18.
+ *
+ * \sa SDL_GetWindowMouseRect
+ * \sa SDL_SetWindowMouseGrab
+ */
+extern DECLSPEC int SDLCALL SDL_SetWindowMouseRect(SDL_Window * window, const SDL_Rect * rect);
+
+/**
+ * Get the mouse confinement rectangle of a window.
+ *
+ * \param window The window to query
+ * \returns A pointer to the mouse confinement rectangle of a window, or NULL
+ *          if there isn't one.
+ *
+ * \since This function is available since SDL 2.0.18.
+ *
+ * \sa SDL_SetWindowMouseRect
+ */
+extern DECLSPEC const SDL_Rect * SDLCALL SDL_GetWindowMouseRect(SDL_Window * window);
+
+/**
+ * Set the brightness (gamma multiplier) for a given window's display.
+ *
+ * Despite the name and signature, this method sets the brightness of the
+ * entire display, not an individual window. A window is considered to be
+ * owned by the display that contains the window's center pixel. (The index of
+ * this display can be retrieved using SDL_GetWindowDisplayIndex().) The
+ * brightness set will not follow the window if it is moved to another
+ * display.
+ *
+ * Many platforms will refuse to set the display brightness in modern times.
+ * You are better off using a shader to adjust gamma during rendering, or
+ * something similar.
+ *
+ * \param window the window used to select the display whose brightness will
+ *               be changed
+ * \param brightness the brightness (gamma multiplier) value to set where 0.0
+ *                   is completely dark and 1.0 is normal brightness
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetWindowBrightness
+ * \sa SDL_SetWindowGammaRamp
  */
 extern DECLSPEC int SDLCALL SDL_SetWindowBrightness(SDL_Window * window, float brightness);
 
 /**
- *  \brief Get the brightness (gamma correction) for a window.
+ * Get the brightness (gamma multiplier) for a given window's display.
  *
- *  \return The last brightness value passed to SDL_SetWindowBrightness()
+ * Despite the name and signature, this method retrieves the brightness of the
+ * entire display, not an individual window. A window is considered to be
+ * owned by the display that contains the window's center pixel. (The index of
+ * this display can be retrieved using SDL_GetWindowDisplayIndex().)
  *
- *  \sa SDL_SetWindowBrightness()
+ * \param window the window used to select the display whose brightness will
+ *               be queried
+ * \returns the brightness for the display where 0.0 is completely dark and
+ *          1.0 is normal brightness.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_SetWindowBrightness
  */
 extern DECLSPEC float SDLCALL SDL_GetWindowBrightness(SDL_Window * window);
 
 /**
- *  \brief Set the opacity for a window
+ * Set the opacity for a window.
  *
- *  \param window The window which will be made transparent or opaque
- *  \param opacity Opacity (0.0f - transparent, 1.0f - opaque) This will be
- *                 clamped internally between 0.0f and 1.0f.
+ * The parameter `opacity` will be clamped internally between 0.0f
+ * (transparent) and 1.0f (opaque).
  *
- *  \return 0 on success, or -1 if setting the opacity isn't supported.
+ * This function also returns -1 if setting the opacity isn't supported.
  *
- *  \sa SDL_GetWindowOpacity()
+ * \param window the window which will be made transparent or opaque
+ * \param opacity the opacity value (0.0f - transparent, 1.0f - opaque)
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.5.
+ *
+ * \sa SDL_GetWindowOpacity
  */
 extern DECLSPEC int SDLCALL SDL_SetWindowOpacity(SDL_Window * window, float opacity);
 
 /**
- *  \brief Get the opacity of a window.
+ * Get the opacity of a window.
  *
- *  If transparency isn't supported on this platform, opacity will be reported
- *  as 1.0f without error.
+ * If transparency isn't supported on this platform, opacity will be reported
+ * as 1.0f without error.
  *
- *  \param window The window in question.
- *  \param out_opacity Opacity (0.0f - transparent, 1.0f - opaque)
+ * The parameter `opacity` is ignored if it is NULL.
  *
- *  \return 0 on success, or -1 on error (invalid window, etc).
+ * This function also returns -1 if an invalid window was provided.
  *
- *  \sa SDL_SetWindowOpacity()
+ * \param window the window to get the current opacity value from
+ * \param out_opacity the float filled in (0.0f - transparent, 1.0f - opaque)
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.5.
+ *
+ * \sa SDL_SetWindowOpacity
  */
 extern DECLSPEC int SDLCALL SDL_GetWindowOpacity(SDL_Window * window, float * out_opacity);
 
 /**
- *  \brief Sets the window as a modal for another window (TODO: reconsider this function and/or its name)
+ * Set the window as a modal for another window.
  *
- *  \param modal_window The window that should be modal
- *  \param parent_window The parent window
+ * \param modal_window the window that should be set modal
+ * \param parent_window the parent window for the modal window
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 otherwise.
+ * \since This function is available since SDL 2.0.5.
  */
 extern DECLSPEC int SDLCALL SDL_SetWindowModalFor(SDL_Window * modal_window, SDL_Window * parent_window);
 
 /**
- *  \brief Explicitly sets input focus to the window.
+ * Explicitly set input focus to the window.
  *
- *  You almost certainly want SDL_RaiseWindow() instead of this function. Use
- *  this with caution, as you might give focus to a window that's completely
- *  obscured by other windows.
+ * You almost certainly want SDL_RaiseWindow() instead of this function. Use
+ * this with caution, as you might give focus to a window that is completely
+ * obscured by other windows.
  *
- *  \param window The window that should get the input focus
+ * \param window the window that should get the input focus
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 otherwise.
- *  \sa SDL_RaiseWindow()
+ * \since This function is available since SDL 2.0.5.
+ *
+ * \sa SDL_RaiseWindow
  */
 extern DECLSPEC int SDLCALL SDL_SetWindowInputFocus(SDL_Window * window);
 
 /**
- *  \brief Set the gamma ramp for a window.
+ * Set the gamma ramp for the display that owns a given window.
  *
- *  \param window The window for which the gamma ramp should be set.
- *  \param red The translation table for the red channel, or NULL.
- *  \param green The translation table for the green channel, or NULL.
- *  \param blue The translation table for the blue channel, or NULL.
+ * Set the gamma translation table for the red, green, and blue channels of
+ * the video hardware. Each table is an array of 256 16-bit quantities,
+ * representing a mapping between the input and output for that channel. The
+ * input is the index into the array, and the output is the 16-bit gamma value
+ * at that index, scaled to the output color precision.
  *
- *  \return 0 on success, or -1 if gamma ramps are unsupported.
+ * Despite the name and signature, this method sets the gamma ramp of the
+ * entire display, not an individual window. A window is considered to be
+ * owned by the display that contains the window's center pixel. (The index of
+ * this display can be retrieved using SDL_GetWindowDisplayIndex().) The gamma
+ * ramp set will not follow the window if it is moved to another display.
  *
- *  Set the gamma translation table for the red, green, and blue channels
- *  of the video hardware.  Each table is an array of 256 16-bit quantities,
- *  representing a mapping between the input and output for that channel.
- *  The input is the index into the array, and the output is the 16-bit
- *  gamma value at that index, scaled to the output color precision.
+ * \param window the window used to select the display whose gamma ramp will
+ *               be changed
+ * \param red a 256 element array of 16-bit quantities representing the
+ *            translation table for the red channel, or NULL
+ * \param green a 256 element array of 16-bit quantities representing the
+ *              translation table for the green channel, or NULL
+ * \param blue a 256 element array of 16-bit quantities representing the
+ *             translation table for the blue channel, or NULL
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \sa SDL_GetWindowGammaRamp()
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetWindowGammaRamp
  */
 extern DECLSPEC int SDLCALL SDL_SetWindowGammaRamp(SDL_Window * window,
                                                    const Uint16 * red,
@@ -999,19 +1581,27 @@ extern DECLSPEC int SDLCALL SDL_SetWindowGammaRamp(SDL_Window * window,
                                                    const Uint16 * blue);
 
 /**
- *  \brief Get the gamma ramp for a window.
+ * Get the gamma ramp for a given window's display.
  *
- *  \param window The window from which the gamma ramp should be queried.
- *  \param red   A pointer to a 256 element array of 16-bit quantities to hold
- *               the translation table for the red channel, or NULL.
- *  \param green A pointer to a 256 element array of 16-bit quantities to hold
- *               the translation table for the green channel, or NULL.
- *  \param blue  A pointer to a 256 element array of 16-bit quantities to hold
- *               the translation table for the blue channel, or NULL.
+ * Despite the name and signature, this method retrieves the gamma ramp of the
+ * entire display, not an individual window. A window is considered to be
+ * owned by the display that contains the window's center pixel. (The index of
+ * this display can be retrieved using SDL_GetWindowDisplayIndex().)
  *
- *  \return 0 on success, or -1 if gamma ramps are unsupported.
+ * \param window the window used to select the display whose gamma ramp will
+ *               be queried
+ * \param red a 256 element array of 16-bit quantities filled in with the
+ *            translation table for the red channel, or NULL
+ * \param green a 256 element array of 16-bit quantities filled in with the
+ *              translation table for the green channel, or NULL
+ * \param blue a 256 element array of 16-bit quantities filled in with the
+ *             translation table for the blue channel, or NULL
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \sa SDL_SetWindowGammaRamp()
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_SetWindowGammaRamp
  */
 extern DECLSPEC int SDLCALL SDL_GetWindowGammaRamp(SDL_Window * window,
                                                    Uint16 * red,
@@ -1019,9 +1609,9 @@ extern DECLSPEC int SDLCALL SDL_GetWindowGammaRamp(SDL_Window * window,
                                                    Uint16 * blue);
 
 /**
- *  \brief Possible return values from the SDL_HitTest callback.
+ * Possible return values from the SDL_HitTest callback.
  *
- *  \sa SDL_HitTest
+ * \sa SDL_HitTest
  */
 typedef enum
 {
@@ -1038,82 +1628,129 @@ typedef enum
 } SDL_HitTestResult;
 
 /**
- *  \brief Callback used for hit-testing.
+ * Callback used for hit-testing.
  *
- *  \sa SDL_SetWindowHitTest
+ * \param win the SDL_Window where hit-testing was set on
+ * \param area an SDL_Point which should be hit-tested
+ * \param data what was passed as `callback_data` to SDL_SetWindowHitTest()
+ * \return an SDL_HitTestResult value.
+ *
+ * \sa SDL_SetWindowHitTest
  */
 typedef SDL_HitTestResult (SDLCALL *SDL_HitTest)(SDL_Window *win,
                                                  const SDL_Point *area,
                                                  void *data);
 
 /**
- *  \brief Provide a callback that decides if a window region has special properties.
+ * Provide a callback that decides if a window region has special properties.
  *
- *  Normally windows are dragged and resized by decorations provided by the
- *  system window manager (a title bar, borders, etc), but for some apps, it
- *  makes sense to drag them from somewhere else inside the window itself; for
- *  example, one might have a borderless window that wants to be draggable
- *  from any part, or simulate its own title bar, etc.
+ * Normally windows are dragged and resized by decorations provided by the
+ * system window manager (a title bar, borders, etc), but for some apps, it
+ * makes sense to drag them from somewhere else inside the window itself; for
+ * example, one might have a borderless window that wants to be draggable from
+ * any part, or simulate its own title bar, etc.
  *
- *  This function lets the app provide a callback that designates pieces of
- *  a given window as special. This callback is run during event processing
- *  if we need to tell the OS to treat a region of the window specially; the
- *  use of this callback is known as "hit testing."
+ * This function lets the app provide a callback that designates pieces of a
+ * given window as special. This callback is run during event processing if we
+ * need to tell the OS to treat a region of the window specially; the use of
+ * this callback is known as "hit testing."
  *
- *  Mouse input may not be delivered to your application if it is within
- *  a special area; the OS will often apply that input to moving the window or
- *  resizing the window and not deliver it to the application.
+ * Mouse input may not be delivered to your application if it is within a
+ * special area; the OS will often apply that input to moving the window or
+ * resizing the window and not deliver it to the application.
  *
- *  Specifying NULL for a callback disables hit-testing. Hit-testing is
- *  disabled by default.
+ * Specifying NULL for a callback disables hit-testing. Hit-testing is
+ * disabled by default.
  *
- *  Platforms that don't support this functionality will return -1
- *  unconditionally, even if you're attempting to disable hit-testing.
+ * Platforms that don't support this functionality will return -1
+ * unconditionally, even if you're attempting to disable hit-testing.
  *
- *  Your callback may fire at any time, and its firing does not indicate any
- *  specific behavior (for example, on Windows, this certainly might fire
- *  when the OS is deciding whether to drag your window, but it fires for lots
- *  of other reasons, too, some unrelated to anything you probably care about
- *  _and when the mouse isn't actually at the location it is testing_).
- *  Since this can fire at any time, you should try to keep your callback
- *  efficient, devoid of allocations, etc.
+ * Your callback may fire at any time, and its firing does not indicate any
+ * specific behavior (for example, on Windows, this certainly might fire when
+ * the OS is deciding whether to drag your window, but it fires for lots of
+ * other reasons, too, some unrelated to anything you probably care about _and
+ * when the mouse isn't actually at the location it is testing_). Since this
+ * can fire at any time, you should try to keep your callback efficient,
+ * devoid of allocations, etc.
  *
- *  \param window The window to set hit-testing on.
- *  \param callback The callback to call when doing a hit-test.
- *  \param callback_data An app-defined void pointer passed to the callback.
- *  \return 0 on success, -1 on error (including unsupported).
+ * \param window the window to set hit-testing on
+ * \param callback the function to call when doing a hit-test
+ * \param callback_data an app-defined void pointer passed to **callback**
+ * \returns 0 on success or -1 on error (including unsupported); call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.4.
  */
 extern DECLSPEC int SDLCALL SDL_SetWindowHitTest(SDL_Window * window,
                                                  SDL_HitTest callback,
                                                  void *callback_data);
 
 /**
- *  \brief Destroy a window.
+ * Request a window to demand attention from the user.
+ *
+ * \param window the window to be flashed
+ * \param operation the flash operation
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.16.
+ */
+extern DECLSPEC int SDLCALL SDL_FlashWindow(SDL_Window * window, SDL_FlashOperation operation);
+
+/**
+ * Destroy a window.
+ *
+ * If `window` is NULL, this function will return immediately after setting
+ * the SDL error message to "Invalid window". See SDL_GetError().
+ *
+ * \param window the window to destroy
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateWindow
+ * \sa SDL_CreateWindowFrom
  */
 extern DECLSPEC void SDLCALL SDL_DestroyWindow(SDL_Window * window);
 
 
 /**
- *  \brief Returns whether the screensaver is currently enabled (default off).
+ * Check whether the screensaver is currently enabled.
  *
- *  \sa SDL_EnableScreenSaver()
- *  \sa SDL_DisableScreenSaver()
+ * The screensaver is disabled by default since SDL 2.0.2. Before SDL 2.0.2
+ * the screensaver was enabled by default.
+ *
+ * The default can also be changed using `SDL_HINT_VIDEO_ALLOW_SCREENSAVER`.
+ *
+ * \returns SDL_TRUE if the screensaver is enabled, SDL_FALSE if it is
+ *          disabled.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_DisableScreenSaver
+ * \sa SDL_EnableScreenSaver
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_IsScreenSaverEnabled(void);
 
 /**
- *  \brief Allow the screen to be blanked by a screensaver
+ * Allow the screen to be blanked by a screen saver.
  *
- *  \sa SDL_IsScreenSaverEnabled()
- *  \sa SDL_DisableScreenSaver()
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_DisableScreenSaver
+ * \sa SDL_IsScreenSaverEnabled
  */
 extern DECLSPEC void SDLCALL SDL_EnableScreenSaver(void);
 
 /**
- *  \brief Prevent the screen from being blanked by a screensaver
+ * Prevent the screen from being blanked by a screen saver.
  *
- *  \sa SDL_IsScreenSaverEnabled()
- *  \sa SDL_EnableScreenSaver()
+ * If you disable the screensaver, it is automatically re-enabled when SDL
+ * quits.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_EnableScreenSaver
+ * \sa SDL_IsScreenSaverEnabled
  */
 extern DECLSPEC void SDLCALL SDL_DisableScreenSaver(void);
 
@@ -1124,147 +1761,316 @@ extern DECLSPEC void SDLCALL SDL_DisableScreenSaver(void);
 /* @{ */
 
 /**
- *  \brief Dynamically load an OpenGL library.
+ * Dynamically load an OpenGL library.
  *
- *  \param path The platform dependent OpenGL library name, or NULL to open the
- *              default OpenGL library.
+ * This should be done after initializing the video driver, but before
+ * creating any OpenGL windows. If no OpenGL library is loaded, the default
+ * library will be loaded upon creation of the first OpenGL window.
  *
- *  \return 0 on success, or -1 if the library couldn't be loaded.
+ * If you do this, you need to retrieve all of the GL functions used in your
+ * program from the dynamic library using SDL_GL_GetProcAddress().
  *
- *  This should be done after initializing the video driver, but before
- *  creating any OpenGL windows.  If no OpenGL library is loaded, the default
- *  library will be loaded upon creation of the first OpenGL window.
+ * \param path the platform dependent OpenGL library name, or NULL to open the
+ *             default OpenGL library
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \note If you do this, you need to retrieve all of the GL functions used in
- *        your program from the dynamic library using SDL_GL_GetProcAddress().
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_GL_GetProcAddress()
- *  \sa SDL_GL_UnloadLibrary()
+ * \sa SDL_GL_GetProcAddress
+ * \sa SDL_GL_UnloadLibrary
  */
 extern DECLSPEC int SDLCALL SDL_GL_LoadLibrary(const char *path);
 
 /**
- *  \brief Get the address of an OpenGL function.
+ * Get an OpenGL function by name.
+ *
+ * If the GL library is loaded at runtime with SDL_GL_LoadLibrary(), then all
+ * GL functions must be retrieved this way. Usually this is used to retrieve
+ * function pointers to OpenGL extensions.
+ *
+ * There are some quirks to looking up OpenGL functions that require some
+ * extra care from the application. If you code carefully, you can handle
+ * these quirks without any platform-specific code, though:
+ *
+ * - On Windows, function pointers are specific to the current GL context;
+ *   this means you need to have created a GL context and made it current
+ *   before calling SDL_GL_GetProcAddress(). If you recreate your context or
+ *   create a second context, you should assume that any existing function
+ *   pointers aren't valid to use with it. This is (currently) a
+ *   Windows-specific limitation, and in practice lots of drivers don't suffer
+ *   this limitation, but it is still the way the wgl API is documented to
+ *   work and you should expect crashes if you don't respect it. Store a copy
+ *   of the function pointers that comes and goes with context lifespan.
+ * - On X11, function pointers returned by this function are valid for any
+ *   context, and can even be looked up before a context is created at all.
+ *   This means that, for at least some common OpenGL implementations, if you
+ *   look up a function that doesn't exist, you'll get a non-NULL result that
+ *   is _NOT_ safe to call. You must always make sure the function is actually
+ *   available for a given GL context before calling it, by checking for the
+ *   existence of the appropriate extension with SDL_GL_ExtensionSupported(),
+ *   or verifying that the version of OpenGL you're using offers the function
+ *   as core functionality.
+ * - Some OpenGL drivers, on all platforms, *will* return NULL if a function
+ *   isn't supported, but you can't count on this behavior. Check for
+ *   extensions you use, and if you get a NULL anyway, act as if that
+ *   extension wasn't available. This is probably a bug in the driver, but you
+ *   can code defensively for this scenario anyhow.
+ * - Just because you're on Linux/Unix, don't assume you'll be using X11.
+ *   Next-gen display servers are waiting to replace it, and may or may not
+ *   make the same promises about function pointers.
+ * - OpenGL function pointers must be declared `APIENTRY` as in the example
+ *   code. This will ensure the proper calling convention is followed on
+ *   platforms where this matters (Win32) thereby avoiding stack corruption.
+ *
+ * \param proc the name of an OpenGL function
+ * \returns a pointer to the named OpenGL function. The returned pointer
+ *          should be cast to the appropriate function signature.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GL_ExtensionSupported
+ * \sa SDL_GL_LoadLibrary
+ * \sa SDL_GL_UnloadLibrary
  */
 extern DECLSPEC void *SDLCALL SDL_GL_GetProcAddress(const char *proc);
 
 /**
- *  \brief Unload the OpenGL library previously loaded by SDL_GL_LoadLibrary().
+ * Unload the OpenGL library previously loaded by SDL_GL_LoadLibrary().
  *
- *  \sa SDL_GL_LoadLibrary()
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GL_LoadLibrary
  */
 extern DECLSPEC void SDLCALL SDL_GL_UnloadLibrary(void);
 
 /**
- *  \brief Return true if an OpenGL extension is supported for the current
- *         context.
+ * Check if an OpenGL extension is supported for the current context.
+ *
+ * This function operates on the current GL context; you must have created a
+ * context and it must be current before calling this function. Do not assume
+ * that all contexts you create will have the same set of extensions
+ * available, or that recreating an existing context will offer the same
+ * extensions again.
+ *
+ * While it's probably not a massive overhead, this function is not an O(1)
+ * operation. Check the extensions you care about after creating the GL
+ * context and save that information somewhere instead of calling the function
+ * every time you need to know.
+ *
+ * \param extension the name of the extension to check
+ * \returns SDL_TRUE if the extension is supported, SDL_FALSE otherwise.
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_GL_ExtensionSupported(const char
                                                            *extension);
 
 /**
- *  \brief Reset all previously set OpenGL context attributes to their default values
+ * Reset all previously set OpenGL context attributes to their default values.
+ *
+ * \since This function is available since SDL 2.0.2.
+ *
+ * \sa SDL_GL_GetAttribute
+ * \sa SDL_GL_SetAttribute
  */
 extern DECLSPEC void SDLCALL SDL_GL_ResetAttributes(void);
 
 /**
- *  \brief Set an OpenGL window attribute before window creation.
+ * Set an OpenGL window attribute before window creation.
  *
- *  \return 0 on success, or -1 if the attribute could not be set.
+ * This function sets the OpenGL attribute `attr` to `value`. The requested
+ * attributes should be set before creating an OpenGL window. You should use
+ * SDL_GL_GetAttribute() to check the values after creating the OpenGL
+ * context, since the values obtained can differ from the requested ones.
+ *
+ * \param attr an SDL_GLattr enum value specifying the OpenGL attribute to set
+ * \param value the desired value for the attribute
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GL_GetAttribute
+ * \sa SDL_GL_ResetAttributes
  */
 extern DECLSPEC int SDLCALL SDL_GL_SetAttribute(SDL_GLattr attr, int value);
 
 /**
- *  \brief Get the actual value for an attribute from the current context.
+ * Get the actual value for an attribute from the current context.
  *
- *  \return 0 on success, or -1 if the attribute could not be retrieved.
- *          The integer at \c value will be modified in either case.
+ * \param attr an SDL_GLattr enum value specifying the OpenGL attribute to get
+ * \param value a pointer filled in with the current value of `attr`
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GL_ResetAttributes
+ * \sa SDL_GL_SetAttribute
  */
 extern DECLSPEC int SDLCALL SDL_GL_GetAttribute(SDL_GLattr attr, int *value);
 
 /**
- *  \brief Create an OpenGL context for use with an OpenGL window, and make it
- *         current.
+ * Create an OpenGL context for an OpenGL window, and make it current.
  *
- *  \sa SDL_GL_DeleteContext()
+ * Windows users new to OpenGL should note that, for historical reasons, GL
+ * functions added after OpenGL version 1.1 are not available by default.
+ * Those functions must be loaded at run-time, either with an OpenGL
+ * extension-handling library or with SDL_GL_GetProcAddress() and its related
+ * functions.
+ *
+ * SDL_GLContext is an alias for `void *`. It's opaque to the application.
+ *
+ * \param window the window to associate with the context
+ * \returns the OpenGL context associated with `window` or NULL on error; call
+ *          SDL_GetError() for more details.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GL_DeleteContext
+ * \sa SDL_GL_MakeCurrent
  */
 extern DECLSPEC SDL_GLContext SDLCALL SDL_GL_CreateContext(SDL_Window *
                                                            window);
 
 /**
- *  \brief Set up an OpenGL context for rendering into an OpenGL window.
+ * Set up an OpenGL context for rendering into an OpenGL window.
  *
- *  \note The context must have been created with a compatible window.
+ * The context must have been created with a compatible window.
+ *
+ * \param window the window to associate with the context
+ * \param context the OpenGL context to associate with the window
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GL_CreateContext
  */
 extern DECLSPEC int SDLCALL SDL_GL_MakeCurrent(SDL_Window * window,
                                                SDL_GLContext context);
 
 /**
- *  \brief Get the currently active OpenGL window.
+ * Get the currently active OpenGL window.
+ *
+ * \returns the currently active OpenGL window on success or NULL on failure;
+ *          call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC SDL_Window* SDLCALL SDL_GL_GetCurrentWindow(void);
 
 /**
- *  \brief Get the currently active OpenGL context.
+ * Get the currently active OpenGL context.
+ *
+ * \returns the currently active OpenGL context or NULL on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GL_MakeCurrent
  */
 extern DECLSPEC SDL_GLContext SDLCALL SDL_GL_GetCurrentContext(void);
 
 /**
- *  \brief Get the size of a window's underlying drawable in pixels (for use
- *         with glViewport).
+ * Get the size of a window's underlying drawable in pixels.
  *
- *  \param window   Window from which the drawable size should be queried
- *  \param w        Pointer to variable for storing the width in pixels, may be NULL
- *  \param h        Pointer to variable for storing the height in pixels, may be NULL
+ * This returns info useful for calling glViewport().
  *
  * This may differ from SDL_GetWindowSize() if we're rendering to a high-DPI
- * drawable, i.e. the window was created with SDL_WINDOW_ALLOW_HIGHDPI on a
- * platform with high-DPI support (Apple calls this "Retina"), and not disabled
- * by the SDL_HINT_VIDEO_HIGHDPI_DISABLED hint.
+ * drawable, i.e. the window was created with `SDL_WINDOW_ALLOW_HIGHDPI` on a
+ * platform with high-DPI support (Apple calls this "Retina"), and not
+ * disabled by the `SDL_HINT_VIDEO_HIGHDPI_DISABLED` hint.
  *
- *  \sa SDL_GetWindowSize()
- *  \sa SDL_CreateWindow()
+ * \param window the window from which the drawable size should be queried
+ * \param w a pointer to variable for storing the width in pixels, may be NULL
+ * \param h a pointer to variable for storing the height in pixels, may be
+ *          NULL
+ *
+ * \since This function is available since SDL 2.0.1.
+ *
+ * \sa SDL_CreateWindow
+ * \sa SDL_GetWindowSize
  */
 extern DECLSPEC void SDLCALL SDL_GL_GetDrawableSize(SDL_Window * window, int *w,
                                                     int *h);
 
 /**
- *  \brief Set the swap interval for the current OpenGL context.
+ * Set the swap interval for the current OpenGL context.
  *
- *  \param interval 0 for immediate updates, 1 for updates synchronized with the
- *                  vertical retrace. If the system supports it, you may
- *                  specify -1 to allow late swaps to happen immediately
- *                  instead of waiting for the next retrace.
+ * Some systems allow specifying -1 for the interval, to enable adaptive
+ * vsync. Adaptive vsync works the same as vsync, but if you've already missed
+ * the vertical retrace for a given frame, it swaps buffers immediately, which
+ * might be less jarring for the user during occasional framerate drops. If an
+ * application requests adaptive vsync and the system does not support it,
+ * this function will fail and return -1. In such a case, you should probably
+ * retry the call with 1 for the interval.
  *
- *  \return 0 on success, or -1 if setting the swap interval is not supported.
+ * Adaptive vsync is implemented for some glX drivers with
+ * GLX_EXT_swap_control_tear:
  *
- *  \sa SDL_GL_GetSwapInterval()
+ * https://www.opengl.org/registry/specs/EXT/glx_swap_control_tear.txt
+ *
+ * and for some Windows drivers with WGL_EXT_swap_control_tear:
+ *
+ * https://www.opengl.org/registry/specs/EXT/wgl_swap_control_tear.txt
+ *
+ * Read more on the Khronos wiki:
+ * https://www.khronos.org/opengl/wiki/Swap_Interval#Adaptive_Vsync
+ *
+ * \param interval 0 for immediate updates, 1 for updates synchronized with
+ *                 the vertical retrace, -1 for adaptive vsync
+ * \returns 0 on success or -1 if setting the swap interval is not supported;
+ *          call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GL_GetSwapInterval
  */
 extern DECLSPEC int SDLCALL SDL_GL_SetSwapInterval(int interval);
 
 /**
- *  \brief Get the swap interval for the current OpenGL context.
+ * Get the swap interval for the current OpenGL context.
  *
- *  \return 0 if there is no vertical retrace synchronization, 1 if the buffer
+ * If the system can't determine the swap interval, or there isn't a valid
+ * current context, this function will return 0 as a safe default.
+ *
+ * \returns 0 if there is no vertical retrace synchronization, 1 if the buffer
  *          swap is synchronized with the vertical retrace, and -1 if late
- *          swaps happen immediately instead of waiting for the next retrace.
- *          If the system can't determine the swap interval, or there isn't a
- *          valid current context, this will return 0 as a safe default.
+ *          swaps happen immediately instead of waiting for the next retrace;
+ *          call SDL_GetError() for more information.
  *
- *  \sa SDL_GL_SetSwapInterval()
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GL_SetSwapInterval
  */
 extern DECLSPEC int SDLCALL SDL_GL_GetSwapInterval(void);
 
 /**
- * \brief Swap the OpenGL buffers for a window, if double-buffering is
- *        supported.
+ * Update a window with OpenGL rendering.
+ *
+ * This is used with double-buffered OpenGL contexts, which are the default.
+ *
+ * On macOS, make sure you bind 0 to the draw framebuffer before swapping the
+ * window, otherwise nothing will happen. If you aren't using
+ * glBindFramebuffer(), this is the default and you won't have to do anything
+ * extra.
+ *
+ * \param window the window to change
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC void SDLCALL SDL_GL_SwapWindow(SDL_Window * window);
 
 /**
- *  \brief Delete an OpenGL context.
+ * Delete an OpenGL context.
  *
- *  \sa SDL_GL_CreateContext()
+ * \param context the OpenGL context to be deleted
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GL_CreateContext
  */
 extern DECLSPEC void SDLCALL SDL_GL_DeleteContext(SDL_GLContext context);
 
diff --git a/Engine/lib/sdl/include/SDL_vulkan.h b/Engine/lib/sdl/include/SDL_vulkan.h
index a3de1cea9..ab86a0b86 100644
--- a/Engine/lib/sdl/include/SDL_vulkan.h
+++ b/Engine/lib/sdl/include/SDL_vulkan.h
@@ -66,201 +66,140 @@ typedef VkSurfaceKHR SDL_vulkanSurface; /* for compatibility with Tizen */
 /* @{ */
 
 /**
- *  \brief Dynamically load a Vulkan loader library.
+ * Dynamically load the Vulkan loader library.
  *
- *  \param [in] path The platform dependent Vulkan loader library name, or
- *              \c NULL.
+ * This should be called after initializing the video driver, but before
+ * creating any Vulkan windows. If no Vulkan loader library is loaded, the
+ * default library will be loaded upon creation of the first Vulkan window.
  *
- *  \return \c 0 on success, or \c -1 if the library couldn't be loaded.
+ * It is fairly common for Vulkan applications to link with libvulkan instead
+ * of explicitly loading it at run time. This will work with SDL provided the
+ * application links to a dynamic library and both it and SDL use the same
+ * search path.
  *
- *  If \a path is NULL SDL will use the value of the environment variable
- *  \c SDL_VULKAN_LIBRARY, if set, otherwise it loads the default Vulkan
- *  loader library.
+ * If you specify a non-NULL `path`, an application should retrieve all of the
+ * Vulkan functions it uses from the dynamic library using
+ * SDL_Vulkan_GetVkGetInstanceProcAddr unless you can guarantee `path` points
+ * to the same vulkan loader library the application linked to.
  *
- *  This should be called after initializing the video driver, but before
- *  creating any Vulkan windows. If no Vulkan loader library is loaded, the
- *  default library will be loaded upon creation of the first Vulkan window.
+ * On Apple devices, if `path` is NULL, SDL will attempt to find the
+ * `vkGetInstanceProcAddr` address within all the Mach-O images of the current
+ * process. This is because it is fairly common for Vulkan applications to
+ * link with libvulkan (and historically MoltenVK was provided as a static
+ * library). If it is not found, on macOS, SDL will attempt to load
+ * `vulkan.framework/vulkan`, `libvulkan.1.dylib`,
+ * `MoltenVK.framework/MoltenVK`, and `libMoltenVK.dylib`, in that order. On
+ * iOS, SDL will attempt to load `libMoltenVK.dylib`. Applications using a
+ * dynamic framework or .dylib must ensure it is included in its application
+ * bundle.
  *
- *  \note It is fairly common for Vulkan applications to link with \a libvulkan
- *        instead of explicitly loading it at run time. This will work with
- *        SDL provided the application links to a dynamic library and both it
- *        and SDL use the same search path.
+ * On non-Apple devices, application linking with a static libvulkan is not
+ * supported. Either do not link to the Vulkan loader or link to a dynamic
+ * library version.
  *
- *  \note If you specify a non-NULL \c path, an application should retrieve all
- *        of the Vulkan functions it uses from the dynamic library using
- *        \c SDL_Vulkan_GetVkGetInstanceProcAddr() unless you can guarantee
- *        \c path points to the same vulkan loader library the application
- *        linked to.
+ * \param path The platform dependent Vulkan loader library name or NULL
+ * \returns 0 on success or -1 if the library couldn't be loaded; call
+ *          SDL_GetError() for more information.
  *
- *  \note On Apple devices, if \a path is NULL, SDL will attempt to find
- *        the vkGetInstanceProcAddr address within all the mach-o images of
- *        the current process. This is because it is fairly common for Vulkan
- *        applications to link with libvulkan (and historically MoltenVK was
- *        provided as a static library). If it is not found then, on macOS, SDL
- *        will attempt to load \c vulkan.framework/vulkan, \c libvulkan.1.dylib,
- *        followed by \c libvulkan.dylib, in that order.
- *        On iOS SDL will attempt to load \c libvulkan.dylib only. Applications
- *        using a dynamic framework or .dylib must ensure it is included in its
- *        application bundle.
+ * \since This function is available since SDL 2.0.6.
  *
- *  \note On non-Apple devices, application linking with a static libvulkan is
- *        not supported. Either do not link to the Vulkan loader or link to a
- *        dynamic library version.
- *
- *  \note This function will fail if there are no working Vulkan drivers
- *        installed.
- *
- *  \sa SDL_Vulkan_GetVkGetInstanceProcAddr()
- *  \sa SDL_Vulkan_UnloadLibrary()
+ * \sa SDL_Vulkan_GetVkInstanceProcAddr
+ * \sa SDL_Vulkan_UnloadLibrary
  */
 extern DECLSPEC int SDLCALL SDL_Vulkan_LoadLibrary(const char *path);
 
 /**
- *  \brief Get the address of the \c vkGetInstanceProcAddr function.
+ * Get the address of the `vkGetInstanceProcAddr` function.
  *
- *  \note This should be called after either calling SDL_Vulkan_LoadLibrary
- *        or creating an SDL_Window with the SDL_WINDOW_VULKAN flag.
+ * This should be called after either calling SDL_Vulkan_LoadLibrary() or
+ * creating an SDL_Window with the `SDL_WINDOW_VULKAN` flag.
+ *
+ * \returns the function pointer for `vkGetInstanceProcAddr` or NULL on error.
+ *
+ * \since This function is available since SDL 2.0.6.
  */
 extern DECLSPEC void *SDLCALL SDL_Vulkan_GetVkGetInstanceProcAddr(void);
 
 /**
- *  \brief Unload the Vulkan loader library previously loaded by
- *         \c SDL_Vulkan_LoadLibrary().
+ * Unload the Vulkan library previously loaded by SDL_Vulkan_LoadLibrary()
  *
- *  \sa SDL_Vulkan_LoadLibrary()
+ * \since This function is available since SDL 2.0.6.
+ *
+ * \sa SDL_Vulkan_LoadLibrary
  */
 extern DECLSPEC void SDLCALL SDL_Vulkan_UnloadLibrary(void);
 
 /**
- *  \brief Get the names of the Vulkan instance extensions needed to create
- *         a surface with \c SDL_Vulkan_CreateSurface().
+ * Get the names of the Vulkan instance extensions needed to create a surface
+ * with SDL_Vulkan_CreateSurface.
  *
- *  \param [in]     \c NULL or window Window for which the required Vulkan instance
- *                  extensions should be retrieved
- *  \param [in,out] pCount pointer to an \c unsigned related to the number of
- *                  required Vulkan instance extensions
- *  \param [out]    pNames \c NULL or a pointer to an array to be filled with the
- *                  required Vulkan instance extensions
+ * If `pNames` is NULL, then the number of required Vulkan instance extensions
+ * is returned in `pCount`. Otherwise, `pCount` must point to a variable set
+ * to the number of elements in the `pNames` array, and on return the variable
+ * is overwritten with the number of names actually written to `pNames`. If
+ * `pCount` is less than the number of required extensions, at most `pCount`
+ * structures will be written. If `pCount` is smaller than the number of
+ * required extensions, SDL_FALSE will be returned instead of SDL_TRUE, to
+ * indicate that not all the required extensions were returned.
  *
- *  \return \c SDL_TRUE on success, \c SDL_FALSE on error.
+ * The `window` parameter is currently needed to be valid as of SDL 2.0.8,
+ * however, this parameter will likely be removed in future releases
  *
- *  If \a pNames is \c NULL, then the number of required Vulkan instance
- *  extensions is returned in pCount. Otherwise, \a pCount must point to a
- *  variable set to the number of elements in the \a pNames array, and on
- *  return the variable is overwritten with the number of names actually
- *  written to \a pNames. If \a pCount is less than the number of required
- *  extensions, at most \a pCount structures will be written. If \a pCount
- *  is smaller than the number of required extensions, \c SDL_FALSE will be
- *  returned instead of \c SDL_TRUE, to indicate that not all the required
- *  extensions were returned.
+ * \param window A window for which the required Vulkan instance extensions
+ *               should be retrieved (will be deprecated in a future release)
+ * \param pCount A pointer to an unsigned int corresponding to the number of
+ *               extensions to be returned
+ * \param pNames NULL or a pointer to an array to be filled with required
+ *               Vulkan instance extensions
+ * \returns SDL_TRUE on success, SDL_FALSE on error.
  *
- *  \note If \c window is not NULL, it will be checked against its creation
- *        flags to ensure that the Vulkan flag is present. This parameter
- *        will be removed in a future major release.
+ * \since This function is available since SDL 2.0.6.
  *
- *  \note The returned list of extensions will contain \c VK_KHR_surface
- *        and zero or more platform specific extensions
- *
- *  \note The extension names queried here must be enabled when calling
- *        VkCreateInstance, otherwise surface creation will fail.
- *
- *  \note \c window should have been created with the \c SDL_WINDOW_VULKAN flag
- *        or be \c NULL
- *
- *  \code
- *  unsigned int count;
- *  // get count of required extensions
- *  if(!SDL_Vulkan_GetInstanceExtensions(NULL, &count, NULL))
- *      handle_error();
- *
- *  static const char *const additionalExtensions[] =
- *  {
- *      VK_EXT_DEBUG_REPORT_EXTENSION_NAME, // example additional extension
- *  };
- *  size_t additionalExtensionsCount = sizeof(additionalExtensions) / sizeof(additionalExtensions[0]);
- *  size_t extensionCount = count + additionalExtensionsCount;
- *  const char **names = malloc(sizeof(const char *) * extensionCount);
- *  if(!names)
- *      handle_error();
- *
- *  // get names of required extensions
- *  if(!SDL_Vulkan_GetInstanceExtensions(NULL, &count, names))
- *      handle_error();
- *
- *  // copy additional extensions after required extensions
- *  for(size_t i = 0; i < additionalExtensionsCount; i++)
- *      names[i + count] = additionalExtensions[i];
- *
- *  VkInstanceCreateInfo instanceCreateInfo = {};
- *  instanceCreateInfo.enabledExtensionCount = extensionCount;
- *  instanceCreateInfo.ppEnabledExtensionNames = names;
- *  // fill in rest of instanceCreateInfo
- *
- *  VkInstance instance;
- *  // create the Vulkan instance
- *  VkResult result = vkCreateInstance(&instanceCreateInfo, NULL, &instance);
- *  free(names);
- *  \endcode
- *
- *  \sa SDL_Vulkan_CreateSurface()
+ * \sa SDL_Vulkan_CreateSurface
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_Vulkan_GetInstanceExtensions(SDL_Window *window,
                                                                   unsigned int *pCount,
                                                                   const char **pNames);
 
 /**
- *  \brief Create a Vulkan rendering surface for a window.
+ * Create a Vulkan rendering surface for a window.
  *
- *  \param [in]  window   SDL_Window to which to attach the rendering surface.
- *  \param [in]  instance handle to the Vulkan instance to use.
- *  \param [out] surface  pointer to a VkSurfaceKHR handle to receive the
- *                        handle of the newly created surface.
+ * The `window` must have been created with the `SDL_WINDOW_VULKAN` flag and
+ * `instance` must have been created with extensions returned by
+ * SDL_Vulkan_GetInstanceExtensions() enabled.
  *
- *  \return \c SDL_TRUE on success, \c SDL_FALSE on error.
+ * \param window The window to which to attach the Vulkan surface
+ * \param instance The Vulkan instance handle
+ * \param surface A pointer to a VkSurfaceKHR handle to output the newly
+ *                created surface
+ * \returns SDL_TRUE on success, SDL_FALSE on error.
  *
- *  \code
- *  VkInstance instance;
- *  SDL_Window *window;
+ * \since This function is available since SDL 2.0.6.
  *
- *  // create instance and window
- *
- *  // create the Vulkan surface
- *  VkSurfaceKHR surface;
- *  if(!SDL_Vulkan_CreateSurface(window, instance, &surface))
- *      handle_error();
- *  \endcode
- *
- *  \note \a window should have been created with the \c SDL_WINDOW_VULKAN flag.
- *
- *  \note \a instance should have been created with the extensions returned
- *        by \c SDL_Vulkan_CreateSurface() enabled.
- *
- *  \sa SDL_Vulkan_GetInstanceExtensions()
+ * \sa SDL_Vulkan_GetInstanceExtensions
+ * \sa SDL_Vulkan_GetDrawableSize
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_Vulkan_CreateSurface(SDL_Window *window,
                                                           VkInstance instance,
                                                           VkSurfaceKHR* surface);
 
 /**
- *  \brief Get the size of a window's underlying drawable in pixels (for use
- *         with setting viewport, scissor & etc).
- *
- *  \param window   SDL_Window from which the drawable size should be queried
- *  \param w        Pointer to variable for storing the width in pixels,
- *                  may be NULL
- *  \param h        Pointer to variable for storing the height in pixels,
- *                  may be NULL
+ * Get the size of the window's underlying drawable dimensions in pixels.
  *
  * This may differ from SDL_GetWindowSize() if we're rendering to a high-DPI
- * drawable, i.e. the window was created with SDL_WINDOW_ALLOW_HIGHDPI on a
- * platform with high-DPI support (Apple calls this "Retina"), and not disabled
- * by the \c SDL_HINT_VIDEO_HIGHDPI_DISABLED hint.
+ * drawable, i.e. the window was created with `SDL_WINDOW_ALLOW_HIGHDPI` on a
+ * platform with high-DPI support (Apple calls this "Retina"), and not
+ * disabled by the `SDL_HINT_VIDEO_HIGHDPI_DISABLED` hint.
  *
- *  \note On macOS high-DPI support must be enabled for an application by
- *        setting NSHighResolutionCapable to true in its Info.plist.
+ * \param window an SDL_Window for which the size is to be queried
+ * \param w Pointer to the variable to write the width to or NULL
+ * \param h Pointer to the variable to write the height to or NULL
  *
- *  \sa SDL_GetWindowSize()
- *  \sa SDL_CreateWindow()
+ * \since This function is available since SDL 2.0.6.
+ *
+ * \sa SDL_GetWindowSize
+ * \sa SDL_CreateWindow
+ * \sa SDL_Vulkan_CreateSurface
  */
 extern DECLSPEC void SDLCALL SDL_Vulkan_GetDrawableSize(SDL_Window * window,
                                                         int *w, int *h);
diff --git a/Engine/lib/sdl/include/begin_code.h b/Engine/lib/sdl/include/begin_code.h
index 1ca40ccdb..63f064b6f 100644
--- a/Engine/lib/sdl/include/begin_code.h
+++ b/Engine/lib/sdl/include/begin_code.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -164,3 +164,24 @@
 #endif
 #endif /* NULL */
 #endif /* ! Mac OS X - breaks precompiled headers */
+
+#ifndef SDL_FALLTHROUGH
+#if (defined(__cplusplus) && __cplusplus >= 201703L) || \
+    (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L)
+#define SDL_FALLTHROUGH [[fallthrough]]
+#else
+#if defined(__has_attribute)
+#define _HAS_FALLTHROUGH __has_attribute(__fallthrough__)
+#else
+#define _HAS_FALLTHROUGH 0
+#endif /* __has_attribute */
+#if _HAS_FALLTHROUGH && \
+   ((defined(__GNUC__) && __GNUC__ >= 7) || \
+    (defined(__clang_major__) && __clang_major__ >= 10))
+#define SDL_FALLTHROUGH __attribute__((__fallthrough__))
+#else
+#define SDL_FALLTHROUGH do {} while (0) /* fallthrough */
+#endif /* _HAS_FALLTHROUGH */
+#undef _HAS_FALLTHROUGH
+#endif /* C++17 or C2x */
+#endif /* SDL_FALLTHROUGH not defined */
diff --git a/Engine/lib/sdl/include/close_code.h b/Engine/lib/sdl/include/close_code.h
index 6aa411b0d..dc73432f6 100644
--- a/Engine/lib/sdl/include/close_code.h
+++ b/Engine/lib/sdl/include/close_code.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/sdl2-config.cmake.in b/Engine/lib/sdl/sdl2-config.cmake.in
index e528a8844..c570511fa 100644
--- a/Engine/lib/sdl/sdl2-config.cmake.in
+++ b/Engine/lib/sdl/sdl2-config.cmake.in
@@ -3,37 +3,79 @@
 set(prefix "@prefix@") 
 set(exec_prefix "@exec_prefix@")
 set(libdir "@libdir@")
-set(SDL2_PREFIX "@prefix@")
-set(SDL2_EXEC_PREFIX "@prefix@")
-set(SDL2_LIBDIR "@libdir@")
-set(SDL2_INCLUDE_DIRS "@includedir@/SDL2")
+set(includedir "@includedir@")
+set(SDL2_PREFIX "${prefix}")
+set(SDL2_EXEC_PREFIX "${exec_prefix}")
+set(SDL2_LIBDIR "${libdir}")
+set(SDL2_INCLUDE_DIRS "${includedir}/SDL2")
 set(SDL2_LIBRARIES "-L${SDL2_LIBDIR} @SDL_RLD_FLAGS@ @SDL_LIBS@")
 string(STRIP "${SDL2_LIBRARIES}" SDL2_LIBRARIES)
 
 if(NOT TARGET SDL2::SDL2)
+  # provide SDL2::SDL2, SDL2::SDL2main and SDL2::SDL2-static targets, like SDL2Config.cmake does, for compatibility
+
   # Remove -lSDL2 as that is handled by CMake, note the space at the end so it does not replace e.g. -lSDL2main
   # This may require "libdir" beeing set (from above)
   string(REPLACE "-lSDL2 " "" SDL2_EXTRA_LINK_FLAGS "@SDL_RLD_FLAGS@ @SDL_LIBS@ ")
+  # also get rid of -lSDL2main, if you want to link against that use both SDL2::SDL2main and SDL2::SDL2 (in that order)
+  # (SDL2Config.cmake has the same behavior)
+  string(REPLACE "-lSDL2main" "" SDL2_EXTRA_LINK_FLAGS ${SDL2_EXTRA_LINK_FLAGS})
   string(STRIP "${SDL2_EXTRA_LINK_FLAGS}" SDL2_EXTRA_LINK_FLAGS)
   string(REPLACE "-lSDL2 " "" SDL2_EXTRA_LINK_FLAGS_STATIC "@SDL_STATIC_LIBS@ ")
   string(STRIP "${SDL2_EXTRA_LINK_FLAGS_STATIC}" SDL2_EXTRA_LINK_FLAGS_STATIC)
 
+if(WIN32 AND NOT MSVC)
+  # MINGW needs very special handling, because the link order must be exactly -lmingw32 -lSDL2main -lSDL2
+  # for it to work at all (and -mwindows somewhere); a normal SHARED IMPORTED or STATIC IMPORTED library always puts itself first
+  # so handle this like a header-only lib and put everything in INTERFACE_LINK_LIBRARIES
+
+  add_library(SDL2::SDL2 INTERFACE IMPORTED)
+  set_target_properties(SDL2::SDL2 PROPERTIES
+    INTERFACE_INCLUDE_DIRECTORIES "${SDL2_INCLUDE_DIRS}"
+    INTERFACE_LINK_LIBRARIES "-L${SDL2_LIBDIR} -lSDL2")
+
+  add_library(SDL2::SDL2main INTERFACE IMPORTED)
+  set_target_properties(SDL2::SDL2main PROPERTIES
+    INTERFACE_LINK_LIBRARIES "-L${SDL2_LIBDIR} -lmingw32 -lSDL2main -mwindows")
+
+else() # (not WIN32) or MSVC
+
   add_library(SDL2::SDL2 SHARED IMPORTED)
   set_target_properties(SDL2::SDL2 PROPERTIES
-    INTERFACE_INCLUDE_DIRECTORIES "@includedir@/SDL2"
+    INTERFACE_INCLUDE_DIRECTORIES "${SDL2_INCLUDE_DIRS}"
     IMPORTED_LINK_INTERFACE_LANGUAGES "C"
-    IMPORTED_LOCATION "@libdir@/${CMAKE_SHARED_LIBRARY_PREFIX}SDL2${CMAKE_SHARED_LIBRARY_SUFFIX}"
-    INTERFACE_LINK_LIBRARIES "${SDL2_EXTRA_LINK_FLAGS}")
+    IMPORTED_LOCATION "${SDL2_LIBDIR}/${CMAKE_SHARED_LIBRARY_PREFIX}SDL2${CMAKE_SHARED_LIBRARY_SUFFIX}")
 
-  add_library(SDL2::SDL2-static STATIC IMPORTED)
-  set_target_properties(SDL2::SDL2-static PROPERTIES
-    INTERFACE_INCLUDE_DIRECTORIES "@includedir@/SDL2"
-    IMPORTED_LINK_INTERFACE_LANGUAGES "C"
-    IMPORTED_LOCATION "@libdir@/${CMAKE_STATIC_LIBRARY_PREFIX}SDL2${CMAKE_STATIC_LIBRARY_SUFFIX}"
-    INTERFACE_LINK_LIBRARIES "${SDL2_EXTRA_LINK_FLAGS_STATIC}")
+  if(MSVC)
+    # This file is generated when building SDL2 with autotools and MinGW, and MinGW/dlltool
+    # isn't able to generate .lib files that are usable by recent MSVC versions 
+    # (something about "module unsafe for SAFESEH"; SAFESEH is enabled by default in MSVC).
+    # The .lib file for SDL2.dll *could* be generated with `gendef SDL2.dll` and then
+    # `lib.exe /machine:x86 /def:SDL2.def /out:SDL2.lib` (or /machine:amd64)
+    # but that requires lib.exe from a Visual Studio installation - and that still doesn't
+    # give you a static SDL2main.lib with SAFESEH support that you'll need (unless you don't use SDL2main)
+    # Note that when building SDL2 with CMake and MSVC, the result works with both MinGW and MSVC.
+
+    message(FATAL_ERROR, "This build of libSDL2 only supports MinGW, not MSVC (Visual C++), because it lacks .lib files!")
+    # MSVC needs SDL2.lib set as IMPORTED_IMPLIB to link against (comment out message() call above if you added SDL2.lib yourself)
+    set_target_properties(SDL2::SDL2 PROPERTIES IMPORTED_IMPLIB "${SDL2_LIBDIR}/SDL2.lib")
+  else()
+    # this mustn't be set for MSVC, so do it here in an extra call here
+    set_target_properties(SDL2::SDL2 PROPERTIES INTERFACE_LINK_LIBRARIES  "${SDL2_EXTRA_LINK_FLAGS}")
+  endif()
 
   add_library(SDL2::SDL2main STATIC IMPORTED)
   set_target_properties(SDL2::SDL2main PROPERTIES
     IMPORTED_LINK_INTERFACE_LANGUAGES "C"
-    IMPORTED_LOCATION "@libdir@/${CMAKE_STATIC_LIBRARY_PREFIX}SDL2main${CMAKE_STATIC_LIBRARY_SUFFIX}")
-endif()
+    IMPORTED_LOCATION "${SDL2_LIBDIR}/${CMAKE_STATIC_LIBRARY_PREFIX}SDL2main${CMAKE_STATIC_LIBRARY_SUFFIX}")
+
+endif() # (not WIN32) or MSVC
+
+  add_library(SDL2::SDL2-static STATIC IMPORTED)
+  set_target_properties(SDL2::SDL2-static PROPERTIES
+    INTERFACE_INCLUDE_DIRECTORIES "${SDL2_INCLUDE_DIRS}"
+    IMPORTED_LINK_INTERFACE_LANGUAGES "C"
+    IMPORTED_LOCATION "${SDL2_LIBDIR}/${CMAKE_STATIC_LIBRARY_PREFIX}SDL2${CMAKE_STATIC_LIBRARY_SUFFIX}"
+    INTERFACE_LINK_LIBRARIES "${SDL2_EXTRA_LINK_FLAGS_STATIC}")
+
+endif() # NOT TARGET SDL2::SDL2
diff --git a/Engine/lib/sdl/sdl2.m4 b/Engine/lib/sdl/sdl2.m4
index 0a73bc7d4..710c2516e 100644
--- a/Engine/lib/sdl/sdl2.m4
+++ b/Engine/lib/sdl/sdl2.m4
@@ -7,14 +7,16 @@
 #
 # Changelog:
 # * also look for SDL2.framework under Mac OS X
+# * removed HP/UX 9 support.
+# * updated for newer autoconf.
 
-# serial 1
+# serial 2
 
 dnl AM_PATH_SDL2([MINIMUM-VERSION, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]]])
 dnl Test for SDL, and define SDL_CFLAGS and SDL_LIBS
 dnl
 AC_DEFUN([AM_PATH_SDL2],
-[dnl 
+[dnl
 dnl Get the cflags and libraries from the sdl2-config script
 dnl
 AC_ARG_WITH(sdl-prefix,[  --with-sdl-prefix=PFX   Prefix where SDL is installed (optional)],
@@ -109,41 +111,19 @@ dnl Now check if the installed SDL is sufficiently new. (Also sanity
 dnl checks the results of sdl2-config to some extent
 dnl
       rm -f conf.sdltest
-      AC_TRY_RUN([
+      AC_RUN_IFELSE([AC_LANG_SOURCE([[
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
 #include "SDL.h"
 
-char*
-my_strdup (char *str)
-{
-  char *new_str;
-  
-  if (str)
-    {
-      new_str = (char *)malloc ((strlen (str) + 1) * sizeof(char));
-      strcpy (new_str, str);
-    }
-  else
-    new_str = NULL;
-  
-  return new_str;
-}
-
 int main (int argc, char *argv[])
 {
   int major, minor, micro;
-  char *tmp_version;
+  FILE *fp = fopen("conf.sdltest", "w");
 
-  /* This hangs on some systems (?)
-  system ("touch conf.sdltest");
-  */
-  { FILE *fp = fopen("conf.sdltest", "a"); if ( fp ) fclose(fp); }
+  if (fp) fclose(fp);
 
-  /* HP/UX 9 (%@#!) writes to sscanf strings */
-  tmp_version = my_strdup("$min_sdl_version");
-  if (sscanf(tmp_version, "%d.%d.%d", &major, &minor, &micro) != 3) {
+  if (sscanf("$min_sdl_version", "%d.%d.%d", &major, &minor, &micro) != 3) {
      printf("%s, bad version string\n", "$min_sdl_version");
      exit(1);
    }
@@ -166,7 +146,7 @@ int main (int argc, char *argv[])
     }
 }
 
-],, no_sdl=yes,[echo $ac_n "cross compiling; assumed OK... $ac_c"])
+]])], [], [no_sdl=yes], [echo $ac_n "cross compiling; assumed OK... $ac_c"])
         CFLAGS="$ac_save_CFLAGS"
         CXXFLAGS="$ac_save_CXXFLAGS"
         LIBS="$ac_save_LIBS"
@@ -197,7 +177,7 @@ int main (int argc, char *argv[])
           CFLAGS="$CFLAGS $SDL_CFLAGS"
           CXXFLAGS="$CXXFLAGS $SDL_CFLAGS"
           LIBS="$LIBS $SDL_LIBS"
-          AC_TRY_LINK([
+          AC_LINK_IFELSE([AC_LANG_PROGRAM([[
 #include <stdio.h>
 #include "SDL.h"
 
@@ -205,7 +185,7 @@ int main(int argc, char *argv[])
 { return 0; }
 #undef  main
 #define main K_and_R_C_main
-],      [ return 0; ],
+]], [[ return 0; ]])],
         [ echo "*** The test program compiled, but did not run. This usually means"
           echo "*** that the run-time linker is not finding SDL or finding the wrong"
           echo "*** version of SDL. If it is not finding SDL, you'll need to set your"
diff --git a/Engine/lib/sdl/sdl2.pc.in b/Engine/lib/sdl/sdl2.pc.in
index 9d76d4797..1b3c0dbe8 100644
--- a/Engine/lib/sdl/sdl2.pc.in
+++ b/Engine/lib/sdl/sdl2.pc.in
@@ -10,5 +10,5 @@ Description: Simple DirectMedia Layer is a cross-platform multimedia library des
 Version: @SDL_VERSION@
 Requires:
 Conflicts:
-Libs: -L${libdir} @SDL_RLD_FLAGS@ @SDL_LIBS@ @PKG_CONFIG_LIBS_PRIV@ @SDL_STATIC_LIBS@
+Libs: -L${libdir} @SDL_RLD_FLAGS@ @SDL_LIBS@ @PKGCONFIG_LIBS_PRIV@ @SDL_STATIC_LIBS@
 Cflags: -I${includedir}/SDL2 @SDL_CFLAGS@
diff --git a/Engine/lib/sdl/src/SDL.c b/Engine/lib/sdl/src/SDL.c
index 02e131bb0..dfc4572f4 100644
--- a/Engine/lib/sdl/src/SDL.c
+++ b/Engine/lib/sdl/src/SDL.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -23,16 +23,19 @@
 #if defined(__WIN32__)
 #include "core/windows/SDL_windows.h"
 #elif defined(__OS2__)
-#include <stdlib.h> /* For _exit() */
+#include <stdlib.h> /* _exit() */
 #elif !defined(__WINRT__)
-#include <unistd.h> /* For _exit(), etc. */
+#include <unistd.h> /* _exit(), etc. */
 #endif
 #if defined(__OS2__)
 #include "core/os2/SDL_os2.h"
-#endif
 #if SDL_THREAD_OS2
 #include "thread/os2/SDL_systls_c.h"
 #endif
+#endif
+
+/* this checks for HAVE_DBUS_DBUS_H internally. */
+#include "core/linux/SDL_dbus.h"
 
 #if defined(__EMSCRIPTEN__)
 #include <emscripten.h>
@@ -147,21 +150,26 @@ SDL_SetMainReady(void)
 int
 SDL_InitSubSystem(Uint32 flags)
 {
+    Uint32 flags_initialized = 0;
+
     if (!SDL_MainIsReady) {
-        SDL_SetError("Application didn't initialize properly, did you include SDL_main.h in the file containing your main() function?");
-        return -1;
+        return SDL_SetError("Application didn't initialize properly, did you include SDL_main.h in the file containing your main() function?");
     }
 
     /* Clear the error message */
     SDL_ClearError();
 
+#if SDL_USE_LIBDBUS
+    SDL_DBus_Init();
+#endif
+
     if ((flags & SDL_INIT_GAMECONTROLLER)) {
         /* game controller implies joystick */
         flags |= SDL_INIT_JOYSTICK;
     }
 
-    if ((flags & (SDL_INIT_VIDEO|SDL_INIT_JOYSTICK))) {
-        /* video or joystick implies events */
+    if ((flags & (SDL_INIT_VIDEO|SDL_INIT_JOYSTICK|SDL_INIT_AUDIO))) {
+        /* video or joystick or audio implies events */
         flags |= SDL_INIT_EVENTS;
     }
 
@@ -172,7 +180,7 @@ SDL_InitSubSystem(Uint32 flags)
 #if SDL_VIDEO_DRIVER_WINDOWS
     if ((flags & (SDL_INIT_HAPTIC|SDL_INIT_JOYSTICK))) {
         if (SDL_HelperWindowCreate() < 0) {
-            return -1;
+            goto quit_and_error;
         }
     }
 #endif
@@ -186,26 +194,30 @@ SDL_InitSubSystem(Uint32 flags)
 #if !SDL_EVENTS_DISABLED
         if (SDL_PrivateShouldInitSubsystem(SDL_INIT_EVENTS)) {
             if (SDL_EventsInit() < 0) {
-                return (-1);
+                goto quit_and_error;
             }
         }
         SDL_PrivateSubsystemRefCountIncr(SDL_INIT_EVENTS);
+        flags_initialized |= SDL_INIT_EVENTS;
 #else
-        return SDL_SetError("SDL not built with events support");
+        SDL_SetError("SDL not built with events support");
+        goto quit_and_error;
 #endif
     }
 
     /* Initialize the timer subsystem */
     if ((flags & SDL_INIT_TIMER)){
-#if !SDL_TIMERS_DISABLED
+#if !SDL_TIMERS_DISABLED && !SDL_TIMER_DUMMY
         if (SDL_PrivateShouldInitSubsystem(SDL_INIT_TIMER)) {
             if (SDL_TimerInit() < 0) {
-                return (-1);
+                goto quit_and_error;
             }
         }
         SDL_PrivateSubsystemRefCountIncr(SDL_INIT_TIMER);
+        flags_initialized |= SDL_INIT_TIMER;
 #else
-        return SDL_SetError("SDL not built with timer support");
+        SDL_SetError("SDL not built with timer support");
+        goto quit_and_error;
 #endif
     }
 
@@ -214,12 +226,14 @@ SDL_InitSubSystem(Uint32 flags)
 #if !SDL_VIDEO_DISABLED
         if (SDL_PrivateShouldInitSubsystem(SDL_INIT_VIDEO)) {
             if (SDL_VideoInit(NULL) < 0) {
-                return (-1);
+                goto quit_and_error;
             }
         }
         SDL_PrivateSubsystemRefCountIncr(SDL_INIT_VIDEO);
+        flags_initialized |= SDL_INIT_VIDEO;
 #else
-        return SDL_SetError("SDL not built with video support");
+        SDL_SetError("SDL not built with video support");
+        goto quit_and_error;
 #endif
     }
 
@@ -228,12 +242,14 @@ SDL_InitSubSystem(Uint32 flags)
 #if !SDL_AUDIO_DISABLED
         if (SDL_PrivateShouldInitSubsystem(SDL_INIT_AUDIO)) {
             if (SDL_AudioInit(NULL) < 0) {
-                return (-1);
+                goto quit_and_error;
             }
         }
         SDL_PrivateSubsystemRefCountIncr(SDL_INIT_AUDIO);
+        flags_initialized |= SDL_INIT_AUDIO;
 #else
-        return SDL_SetError("SDL not built with audio support");
+        SDL_SetError("SDL not built with audio support");
+        goto quit_and_error;
 #endif
     }
 
@@ -242,12 +258,14 @@ SDL_InitSubSystem(Uint32 flags)
 #if !SDL_JOYSTICK_DISABLED
         if (SDL_PrivateShouldInitSubsystem(SDL_INIT_JOYSTICK)) {
            if (SDL_JoystickInit() < 0) {
-               return (-1);
+               goto quit_and_error;
            }
         }
         SDL_PrivateSubsystemRefCountIncr(SDL_INIT_JOYSTICK);
+        flags_initialized |= SDL_INIT_JOYSTICK;
 #else
-        return SDL_SetError("SDL not built with joystick support");
+        SDL_SetError("SDL not built with joystick support");
+        goto quit_and_error;
 #endif
     }
 
@@ -255,12 +273,14 @@ SDL_InitSubSystem(Uint32 flags)
 #if !SDL_JOYSTICK_DISABLED
         if (SDL_PrivateShouldInitSubsystem(SDL_INIT_GAMECONTROLLER)) {
             if (SDL_GameControllerInit() < 0) {
-                return (-1);
+                goto quit_and_error;
             }
         }
         SDL_PrivateSubsystemRefCountIncr(SDL_INIT_GAMECONTROLLER);
+        flags_initialized |= SDL_INIT_GAMECONTROLLER;
 #else
-        return SDL_SetError("SDL not built with joystick support");
+        SDL_SetError("SDL not built with joystick support");
+        goto quit_and_error;
 #endif
     }
 
@@ -269,12 +289,14 @@ SDL_InitSubSystem(Uint32 flags)
 #if !SDL_HAPTIC_DISABLED
         if (SDL_PrivateShouldInitSubsystem(SDL_INIT_HAPTIC)) {
             if (SDL_HapticInit() < 0) {
-                return (-1);
+                goto quit_and_error;
             }
         }
         SDL_PrivateSubsystemRefCountIncr(SDL_INIT_HAPTIC);
+        flags_initialized |= SDL_INIT_HAPTIC;
 #else
-        return SDL_SetError("SDL not built with haptic (force feedback) support");
+        SDL_SetError("SDL not built with haptic (force feedback) support");
+        goto quit_and_error;
 #endif
     }
 
@@ -283,16 +305,22 @@ SDL_InitSubSystem(Uint32 flags)
 #if !SDL_SENSOR_DISABLED
         if (SDL_PrivateShouldInitSubsystem(SDL_INIT_SENSOR)) {
             if (SDL_SensorInit() < 0) {
-                return (-1);
+                goto quit_and_error;
             }
         }
         SDL_PrivateSubsystemRefCountIncr(SDL_INIT_SENSOR);
+        flags_initialized |= SDL_INIT_SENSOR;
 #else
-        return SDL_SetError("SDL not built with sensor support");
+        SDL_SetError("SDL not built with sensor support");
+        goto quit_and_error;
 #endif
     }
 
     return (0);
+
+quit_and_error:
+    SDL_QuitSubSystem(flags_initialized);
+    return (-1);
 }
 
 int
@@ -304,10 +332,10 @@ SDL_Init(Uint32 flags)
 void
 SDL_QuitSubSystem(Uint32 flags)
 {
+#if defined(__OS2__)
 #if SDL_THREAD_OS2
     SDL_OS2TLSFree(); /* thread/os2/SDL_systls.c */
 #endif
-#if defined(__OS2__)
     SDL_OS2Quit();
 #endif
 
@@ -373,7 +401,7 @@ SDL_QuitSubSystem(Uint32 flags)
     }
 #endif
 
-#if !SDL_TIMERS_DISABLED
+#if !SDL_TIMERS_DISABLED && !SDL_TIMER_DUMMY
     if ((flags & SDL_INIT_TIMER)) {
         if (SDL_PrivateShouldQuitSubsystem(SDL_INIT_TIMER)) {
             SDL_TimerQuit();
@@ -442,6 +470,10 @@ SDL_Quit(void)
     SDL_AssertionsQuit();
     SDL_LogResetPriorities();
 
+#if SDL_USE_LIBDBUS
+    SDL_DBus_Quit();
+#endif
+
     /* Now that every subsystem has been quit, we reset the subsystem refcount
      * and the list of initialized subsystems.
      */
@@ -468,12 +500,12 @@ SDL_GetRevision(void)
 int
 SDL_GetRevisionNumber(void)
 {
-    return SDL_REVISION_NUMBER;
+    return 0;  /* doesn't make sense without Mercurial. */
 }
 
 /* Get the name of the platform */
 const char *
-SDL_GetPlatform()
+SDL_GetPlatform(void)
 {
 #if __AIX__
     return "AIX";
@@ -527,13 +559,15 @@ SDL_GetPlatform()
     return "iOS";
 #elif __PSP__
     return "PlayStation Portable";
+#elif __VITA__
+    return "PlayStation Vita";
 #else
     return "Unknown (see SDL_platform.h)";
 #endif
 }
 
 SDL_bool
-SDL_IsTablet()
+SDL_IsTablet(void)
 {
 #if __ANDROID__
     extern SDL_bool SDL_IsAndroidTablet(void);
diff --git a/Engine/lib/sdl/src/SDL_assert.c b/Engine/lib/sdl/src/SDL_assert.c
index f9425017b..9c7acac55 100644
--- a/Engine/lib/sdl/src/SDL_assert.c
+++ b/Engine/lib/sdl/src/SDL_assert.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/SDL_assert_c.h b/Engine/lib/sdl/src/SDL_assert_c.h
index b59c8d9f5..ca4d4c3a9 100644
--- a/Engine/lib/sdl/src/SDL_assert_c.h
+++ b/Engine/lib/sdl/src/SDL_assert_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/SDL_dataqueue.c b/Engine/lib/sdl/src/SDL_dataqueue.c
index 19e2eae12..e63fc6dfd 100644
--- a/Engine/lib/sdl/src/SDL_dataqueue.c
+++ b/Engine/lib/sdl/src/SDL_dataqueue.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -121,7 +121,7 @@ SDL_ClearDataQueue(SDL_DataQueue *queue, const size_t slack)
     queue->queued_bytes = 0;
     queue->pool = packet;
 
-    /* Optionally keep some slack in the pool to reduce malloc pressure. */
+    /* Optionally keep some slack in the pool to reduce memory allocation pressure. */
     for (i = 0; packet && (i < slackpackets); i++) {
         prev = packet;
         packet = packet->next;
diff --git a/Engine/lib/sdl/src/SDL_dataqueue.h b/Engine/lib/sdl/src/SDL_dataqueue.h
index b08923684..46b8ebd70 100644
--- a/Engine/lib/sdl/src/SDL_dataqueue.h
+++ b/Engine/lib/sdl/src/SDL_dataqueue.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/SDL_error.c b/Engine/lib/sdl/src/SDL_error.c
index 3e5d491b0..4d25999a3 100644
--- a/Engine/lib/sdl/src/SDL_error.c
+++ b/Engine/lib/sdl/src/SDL_error.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/SDL_error_c.h b/Engine/lib/sdl/src/SDL_error_c.h
index 88e382447..af6a15e44 100644
--- a/Engine/lib/sdl/src/SDL_error_c.h
+++ b/Engine/lib/sdl/src/SDL_error_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/SDL_hints.c b/Engine/lib/sdl/src/SDL_hints.c
index d6bdd13da..2eea5501e 100644
--- a/Engine/lib/sdl/src/SDL_hints.c
+++ b/Engine/lib/sdl/src/SDL_hints.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/SDL_hints_c.h b/Engine/lib/sdl/src/SDL_hints_c.h
index ae731d4e0..d046817f6 100644
--- a/Engine/lib/sdl/src/SDL_hints_c.h
+++ b/Engine/lib/sdl/src/SDL_hints_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/SDL_internal.h b/Engine/lib/sdl/src/SDL_internal.h
index 7601fd5c9..69da271c6 100644
--- a/Engine/lib/sdl/src/SDL_internal.h
+++ b/Engine/lib/sdl/src/SDL_internal.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -51,6 +51,11 @@
 
 #include "SDL_config.h"
 
+/* If you run into a warning that O_CLOEXEC is redefined, update the SDL configuration header for your platform to add HAVE_O_CLOEXEC */
+#ifndef HAVE_O_CLOEXEC
+#define O_CLOEXEC                       0
+#endif
+
 /* A few #defines to reduce SDL2 footprint.
    Only effective when library is statically linked.
    You have to manually edit this file. */
diff --git a/Engine/lib/sdl/src/SDL_log.c b/Engine/lib/sdl/src/SDL_log.c
index 73c4c14a9..4f820ffa7 100644
--- a/Engine/lib/sdl/src/SDL_log.c
+++ b/Engine/lib/sdl/src/SDL_log.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -327,7 +327,7 @@ SDL_LogOutput(void *userdata, int category, SDL_LogPriority priority,
 #if !defined(HAVE_STDIO_H) && !defined(__WINRT__)
         BOOL attachResult;
         DWORD attachError;
-        unsigned long charsWritten; 
+        DWORD charsWritten;
         DWORD consoleMode;
 
         /* Maybe attach console and get stderr handle */
@@ -376,7 +376,7 @@ SDL_LogOutput(void *userdata, int category, SDL_LogPriority priority,
 #if !defined(HAVE_STDIO_H) && !defined(__WINRT__)
         /* Screen output to stderr, if console was attached. */
         if (consoleAttached == 1) {
-                if (!WriteConsole(stderrHandle, tstr, lstrlen(tstr), &charsWritten, NULL)) {
+                if (!WriteConsole(stderrHandle, tstr, (DWORD) SDL_tcslen(tstr), &charsWritten, NULL)) {
                     OutputDebugString(TEXT("Error calling WriteConsole\r\n"));
                     if (GetLastError() == ERROR_NOT_ENOUGH_MEMORY) {
                         OutputDebugString(TEXT("Insufficient heap memory to write message\r\n"));
@@ -384,7 +384,7 @@ SDL_LogOutput(void *userdata, int category, SDL_LogPriority priority,
                 }
 
         } else if (consoleAttached == 2) {
-            if (!WriteFile(stderrHandle, output, lstrlenA(output), &charsWritten, NULL)) {
+            if (!WriteFile(stderrHandle, output, (DWORD) SDL_strlen(output), &charsWritten, NULL)) {
                 OutputDebugString(TEXT("Error calling WriteFile\r\n"));
             }
         }
@@ -422,6 +422,13 @@ SDL_LogOutput(void *userdata, int category, SDL_LogPriority priority,
         fprintf(pFile, "%s: %s\n", SDL_priority_prefixes[priority], message);
         fclose (pFile);
     }
+#elif defined(__VITA__)
+    {
+        FILE*        pFile;
+        pFile = fopen ("ux0:/data/SDL_Log.txt", "a");
+        fprintf(pFile, "%s: %s\n", SDL_priority_prefixes[priority], message);
+        fclose (pFile);
+    }
 #endif
 #if HAVE_STDIO_H
     fprintf(stderr, "%s: %s\n", SDL_priority_prefixes[priority], message);
diff --git a/Engine/lib/sdl/src/atomic/SDL_atomic.c b/Engine/lib/sdl/src/atomic/SDL_atomic.c
index 6a84cd563..21ba381d7 100644
--- a/Engine/lib/sdl/src/atomic/SDL_atomic.c
+++ b/Engine/lib/sdl/src/atomic/SDL_atomic.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -36,33 +36,31 @@
 #endif
 
 /* The __atomic_load_n() intrinsic showed up in different times for different compilers. */
-#if defined(HAVE_GCC_ATOMICS)
-# if defined(__clang__)
-#   if __has_builtin(__atomic_load_n)
-      /* !!! FIXME: this advertises as available in the NDK but uses an external symbol we don't have.
-         It might be in a later NDK or we might need an extra library? --ryan. */
-#     if !defined(__ANDROID__)
-#       define HAVE_ATOMIC_LOAD_N 1
-#     endif
-#   endif
-# elif defined(__GNUC__)
+#if defined(__clang__)
+#  if __has_builtin(__atomic_load_n) || defined(HAVE_GCC_ATOMICS)
+     /* !!! FIXME: this advertises as available in the NDK but uses an external symbol we don't have.
+        It might be in a later NDK or we might need an extra library? --ryan. */
+#    if !defined(__ANDROID__)
+#      define HAVE_ATOMIC_LOAD_N 1
+#    endif
+#  endif
+#elif defined(__GNUC__)
 #   if (__GNUC__ >= 5)
 #     define HAVE_ATOMIC_LOAD_N 1
 #   endif
-# endif
 #endif
 
 #if defined(__WATCOMC__) && defined(__386__)
 SDL_COMPILE_TIME_ASSERT(intsize, 4==sizeof(int));
 #define HAVE_WATCOM_ATOMICS
-extern _inline int _SDL_xchg_watcom(volatile int *a, int v);
+extern __inline int _SDL_xchg_watcom(volatile int *a, int v);
 #pragma aux _SDL_xchg_watcom = \
   "lock xchg [ecx], eax" \
   parm [ecx] [eax] \
   value [eax] \
   modify exact [eax];
 
-extern _inline unsigned char _SDL_cmpxchg_watcom(volatile int *a, int newval, int oldval);
+extern __inline unsigned char _SDL_cmpxchg_watcom(volatile int *a, int newval, int oldval);
 #pragma aux _SDL_cmpxchg_watcom = \
   "lock cmpxchg [edx], ecx" \
   "setz al" \
@@ -70,7 +68,7 @@ extern _inline unsigned char _SDL_cmpxchg_watcom(volatile int *a, int newval, in
   value [al] \
   modify exact [eax];
 
-extern _inline int _SDL_xadd_watcom(volatile int *a, int v);
+extern __inline int _SDL_xadd_watcom(volatile int *a, int v);
 #pragma aux _SDL_xadd_watcom = \
   "lock xadd [ecx], eax" \
   parm [ecx] [eax] \
diff --git a/Engine/lib/sdl/src/atomic/SDL_spinlock.c b/Engine/lib/sdl/src/atomic/SDL_spinlock.c
index 73ddd012a..bdd347e41 100644
--- a/Engine/lib/sdl/src/atomic/SDL_spinlock.c
+++ b/Engine/lib/sdl/src/atomic/SDL_spinlock.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -42,7 +42,7 @@
 
 #if defined(__WATCOMC__) && defined(__386__)
 SDL_COMPILE_TIME_ASSERT(locksize, 4==sizeof(SDL_SpinLock));
-extern _inline int _SDL_xchg_watcom(volatile int *a, int v);
+extern __inline int _SDL_xchg_watcom(volatile int *a, int v);
 #pragma aux _SDL_xchg_watcom = \
   "lock xchg [ecx], eax" \
   parm [ecx] [eax] \
@@ -72,6 +72,12 @@ SDL_AtomicTryLock(SDL_SpinLock *lock)
         return SDL_FALSE;
     }
 
+#elif HAVE_GCC_ATOMICS || HAVE_GCC_SYNC_LOCK_TEST_AND_SET
+    return (__sync_lock_test_and_set(lock, 1) == 0);
+
+#elif defined(_MSC_VER) && (defined(_M_ARM) || defined(_M_ARM64))
+    return (_InterlockedExchange_acq(lock, 1) == 0);
+
 #elif defined(_MSC_VER)
     SDL_COMPILE_TIME_ASSERT(locksize, sizeof(*lock) == sizeof(long));
     return (InterlockedExchange((long*)lock, 1) == 0);
@@ -79,9 +85,6 @@ SDL_AtomicTryLock(SDL_SpinLock *lock)
 #elif defined(__WATCOMC__) && defined(__386__)
     return _SDL_xchg_watcom(lock, 1) == 0;
 
-#elif HAVE_GCC_ATOMICS || HAVE_GCC_SYNC_LOCK_TEST_AND_SET
-    return (__sync_lock_test_and_set(lock, 1) == 0);
-
 #elif defined(__GNUC__) && defined(__arm__) && \
         (defined(__ARM_ARCH_3__) || defined(__ARM_ARCH_3M__) || \
          defined(__ARM_ARCH_4__) || defined(__ARM_ARCH_4T__) || \
@@ -140,11 +143,15 @@ SDL_AtomicTryLock(SDL_SpinLock *lock)
     #define PAUSE_INSTRUCTION() __asm__ __volatile__("pause\n")  /* Some assemblers can't do REP NOP, so go with PAUSE. */
 #elif (defined(__arm__) && __ARM_ARCH__ >= 7) || defined(__aarch64__)
     #define PAUSE_INSTRUCTION() __asm__ __volatile__("yield" ::: "memory")
+#elif (defined(__powerpc__) || defined(__powerpc64__))
+    #define PAUSE_INSTRUCTION() __asm__ __volatile__("or 27,27,27");
 #elif defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64))
     #define PAUSE_INSTRUCTION() _mm_pause()  /* this is actually "rep nop" and not a SIMD instruction. No inline asm in MSVC x86-64! */
+#elif defined(_MSC_VER) && (defined(_M_ARM) || defined(_M_ARM64))
+    #define PAUSE_INSTRUCTION() __yield()
 #elif defined(__WATCOMC__) && defined(__386__)
     /* watcom assembler rejects PAUSE if CPU < i686, and it refuses REP NOP as an invalid combination. Hardcode the bytes.  */
-    extern _inline void PAUSE_INSTRUCTION(void);
+    extern __inline void PAUSE_INSTRUCTION(void);
     #pragma aux PAUSE_INSTRUCTION = "db 0f3h,90h"
 #else
     #define PAUSE_INSTRUCTION()
@@ -169,7 +176,13 @@ SDL_AtomicLock(SDL_SpinLock *lock)
 void
 SDL_AtomicUnlock(SDL_SpinLock *lock)
 {
-#if defined(_MSC_VER)
+#if HAVE_GCC_ATOMICS || HAVE_GCC_SYNC_LOCK_TEST_AND_SET
+    __sync_lock_release(lock);
+
+#elif defined(_MSC_VER) && (defined(_M_ARM) || defined(_M_ARM64))
+    _InterlockedExchange_rel(lock, 0);
+
+#elif defined(_MSC_VER)
     _ReadWriteBarrier();
     *lock = 0;
 
@@ -177,9 +190,6 @@ SDL_AtomicUnlock(SDL_SpinLock *lock)
     SDL_CompilerBarrier ();
     *lock = 0;
 
-#elif HAVE_GCC_ATOMICS || HAVE_GCC_SYNC_LOCK_TEST_AND_SET
-    __sync_lock_release(lock);
-
 #elif defined(__SOLARIS__)
     /* Used for Solaris when not using gcc. */
     *lock = 0;
diff --git a/Engine/lib/sdl/src/audio/SDL_audio.c b/Engine/lib/sdl/src/audio/SDL_audio.c
index 16d29f9f2..3a841450c 100644
--- a/Engine/lib/sdl/src/audio/SDL_audio.c
+++ b/Engine/lib/sdl/src/audio/SDL_audio.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -47,9 +47,6 @@ static const AudioBootStrap *const bootstrap[] = {
 #if SDL_AUDIO_DRIVER_NETBSD
     &NETBSDAUDIO_bootstrap,
 #endif
-#if SDL_AUDIO_DRIVER_OSS
-    &DSP_bootstrap,
-#endif
 #if SDL_AUDIO_DRIVER_QSA
     &QSAAUDIO_bootstrap,
 #endif
@@ -89,6 +86,9 @@ static const AudioBootStrap *const bootstrap[] = {
 #if SDL_AUDIO_DRIVER_FUSIONSOUND
     &FUSIONSOUND_bootstrap,
 #endif
+#if SDL_AUDIO_DRIVER_AAUDIO
+    &aaudio_bootstrap,
+#endif
 #if SDL_AUDIO_DRIVER_OPENSLES
     &openslES_bootstrap,
 #endif
@@ -98,12 +98,21 @@ static const AudioBootStrap *const bootstrap[] = {
 #if SDL_AUDIO_DRIVER_PSP
     &PSPAUDIO_bootstrap,
 #endif
+#if SDL_AUDIO_DRIVER_VITA
+    &VITAAUD_bootstrap,
+#endif
 #if SDL_AUDIO_DRIVER_EMSCRIPTEN
     &EMSCRIPTENAUDIO_bootstrap,
 #endif
 #if SDL_AUDIO_DRIVER_JACK
     &JACK_bootstrap,
 #endif
+#if SDL_AUDIO_DRIVER_PIPEWIRE
+    &PIPEWIRE_bootstrap,
+#endif
+#if SDL_AUDIO_DRIVER_OSS
+    &DSP_bootstrap,
+#endif
 #if SDL_AUDIO_DRIVER_OS2
     &OS2AUDIO_bootstrap,
 #endif
@@ -220,9 +229,9 @@ SDL_AudioDetectDevices_Default(void)
     SDL_assert(current_audio.impl.OnlyHasDefaultOutputDevice);
     SDL_assert(current_audio.impl.OnlyHasDefaultCaptureDevice || !current_audio.impl.HasCaptureSupport);
 
-    SDL_AddAudioDevice(SDL_FALSE, DEFAULT_OUTPUT_DEVNAME, (void *) ((size_t) 0x1));
+    SDL_AddAudioDevice(SDL_FALSE, DEFAULT_OUTPUT_DEVNAME, NULL, (void *) ((size_t) 0x1));
     if (current_audio.impl.HasCaptureSupport) {
-        SDL_AddAudioDevice(SDL_TRUE, DEFAULT_INPUT_DEVNAME, (void *) ((size_t) 0x2));
+        SDL_AddAudioDevice(SDL_TRUE, DEFAULT_INPUT_DEVNAME, NULL, (void *) ((size_t) 0x2));
     }
 }
 
@@ -236,11 +245,6 @@ SDL_AudioThreadDeinit_Default(_THIS)
 {                               /* no-op. */
 }
 
-static void
-SDL_AudioBeginLoopIteration_Default(_THIS)
-{                               /* no-op. */
-}
-
 static void
 SDL_AudioWaitDevice_Default(_THIS)
 {                               /* no-op. */
@@ -268,11 +272,6 @@ SDL_AudioFlushCapture_Default(_THIS)
 {                               /* no-op. */
 }
 
-static void
-SDL_AudioPrepareToClose_Default(_THIS)
-{                               /* no-op. */
-}
-
 static void
 SDL_AudioCloseDevice_Default(_THIS)
 {                               /* no-op. */
@@ -290,7 +289,7 @@ SDL_AudioFreeDeviceHandle_Default(void *handle)
 
 
 static int
-SDL_AudioOpenDevice_Default(_THIS, void *handle, const char *devname, int iscapture)
+SDL_AudioOpenDevice_Default(_THIS, const char *devname)
 {
     return SDL_Unsupported();
 }
@@ -325,11 +324,6 @@ SDL_AudioUnlockDevice_Default(SDL_AudioDevice * device)
     }
 }
 
-static void
-SDL_AudioLockOrUnlockDeviceWithNoMixerLock(SDL_AudioDevice * device)
-{
-}
-
 static void
 finish_audio_entry_points_init(void)
 {
@@ -338,14 +332,6 @@ finish_audio_entry_points_init(void)
      *  blindly call them without having to check for validity first.
      */
 
-    if (current_audio.impl.SkipMixerLock) {
-        if (current_audio.impl.LockDevice == NULL) {
-            current_audio.impl.LockDevice = SDL_AudioLockOrUnlockDeviceWithNoMixerLock;
-        }
-        if (current_audio.impl.UnlockDevice == NULL) {
-            current_audio.impl.UnlockDevice = SDL_AudioLockOrUnlockDeviceWithNoMixerLock;
-        }
-    }
 
 #define FILL_STUB(x) \
         if (current_audio.impl.x == NULL) { \
@@ -355,13 +341,11 @@ finish_audio_entry_points_init(void)
     FILL_STUB(OpenDevice);
     FILL_STUB(ThreadInit);
     FILL_STUB(ThreadDeinit);
-    FILL_STUB(BeginLoopIteration);
     FILL_STUB(WaitDevice);
     FILL_STUB(PlayDevice);
     FILL_STUB(GetDeviceBuf);
     FILL_STUB(CaptureFromDevice);
     FILL_STUB(FlushCapture);
-    FILL_STUB(PrepareToClose);
     FILL_STUB(CloseDevice);
     FILL_STUB(LockDevice);
     FILL_STUB(UnlockDevice);
@@ -374,7 +358,7 @@ finish_audio_entry_points_init(void)
 /* device hotplug support... */
 
 static int
-add_audio_device(const char *name, void *handle, SDL_AudioDeviceItem **devices, int *devCount)
+add_audio_device(const char *name, SDL_AudioSpec *spec, void *handle, SDL_AudioDeviceItem **devices, int *devCount)
 {
     int retval = -1;
     SDL_AudioDeviceItem *item;
@@ -397,6 +381,11 @@ add_audio_device(const char *name, void *handle, SDL_AudioDeviceItem **devices,
 
     item->dupenum = 0;
     item->name = item->original_name;
+    if (spec != NULL) {
+        SDL_memcpy(&item->spec, spec, sizeof(SDL_AudioSpec));
+    } else {
+        SDL_zero(item->spec);
+    }
     item->handle = handle;
 
     SDL_LockMutex(current_audio.detectionLock);
@@ -415,8 +404,7 @@ add_audio_device(const char *name, void *handle, SDL_AudioDeviceItem **devices,
             SDL_UnlockMutex(current_audio.detectionLock);
             SDL_free(item->original_name);
             SDL_free(item);
-            SDL_OutOfMemory();
-            return -1;
+            return SDL_OutOfMemory();
         }
 
         SDL_snprintf(replacement, len, "%s (%d)", name, dupenum + 1);
@@ -434,16 +422,16 @@ add_audio_device(const char *name, void *handle, SDL_AudioDeviceItem **devices,
 }
 
 static SDL_INLINE int
-add_capture_device(const char *name, void *handle)
+add_capture_device(const char *name, SDL_AudioSpec *spec, void *handle)
 {
     SDL_assert(current_audio.impl.HasCaptureSupport);
-    return add_audio_device(name, handle, &current_audio.inputDevices, &current_audio.inputDeviceCount);
+    return add_audio_device(name, spec, handle, &current_audio.inputDevices, &current_audio.inputDeviceCount);
 }
 
 static SDL_INLINE int
-add_output_device(const char *name, void *handle)
+add_output_device(const char *name, SDL_AudioSpec *spec, void *handle)
 {
-    return add_audio_device(name, handle, &current_audio.outputDevices, &current_audio.outputDeviceCount);
+    return add_audio_device(name, spec, handle, &current_audio.outputDevices, &current_audio.outputDeviceCount);
 }
 
 static void
@@ -469,9 +457,9 @@ free_device_list(SDL_AudioDeviceItem **devices, int *devCount)
 
 /* The audio backends call this when a new device is plugged in. */
 void
-SDL_AddAudioDevice(const int iscapture, const char *name, void *handle)
+SDL_AddAudioDevice(const SDL_bool iscapture, const char *name, SDL_AudioSpec *spec, void *handle)
 {
-    const int device_index = iscapture ? add_capture_device(name, handle) : add_output_device(name, handle);
+    const int device_index = iscapture ? add_capture_device(name, spec, handle) : add_output_device(name, spec, handle);
     if (device_index != -1) {
         /* Post the event, if desired */
         if (SDL_GetEventState(SDL_AUDIODEVICEADDED) == SDL_ENABLE) {
@@ -531,7 +519,7 @@ mark_device_removed(void *handle, SDL_AudioDeviceItem *devices, SDL_bool *remove
 
 /* The audio backends call this when a device is removed from the system. */
 void
-SDL_RemoveAudioDevice(const int iscapture, void *handle)
+SDL_RemoveAudioDevice(const SDL_bool iscapture, void *handle)
 {
     int device_index;
     SDL_AudioDevice *device = NULL;
@@ -673,7 +661,7 @@ SDL_ClearQueuedAudio(SDL_AudioDeviceID devid)
     /* Blank out the device and release the mutex. Free it afterwards. */
     current_audio.impl.LockDevice(device);
 
-    /* Keep up to two packets in the pool to reduce future malloc pressure. */
+    /* Keep up to two packets in the pool to reduce future memory allocation pressure. */
     SDL_ClearDataQueue(device->buffer_queue, SDL_AUDIOBUFFERQUEUE_PACKETLEN * 2);
 
     current_audio.impl.UnlockDevice(device);
@@ -709,7 +697,6 @@ SDL_RunAudio(void *devicep)
 
     /* Loop, filling the audio buffers */
     while (!SDL_AtomicGet(&device->shutdown)) {
-        current_audio.impl.BeginLoopIteration(device);
         data_len = device->callbackspec.size;
 
         /* Fill the current buffer with sound */
@@ -748,7 +735,7 @@ SDL_RunAudio(void *devicep)
                 int got;
                 data = SDL_AtomicGet(&device->enabled) ? current_audio.impl.GetDeviceBuf(device) : NULL;
                 got = SDL_AudioStreamGet(device->stream, data ? data : device->work_buffer, device->spec.size);
-                SDL_assert((got < 0) || (got == device->spec.size));
+                SDL_assert((got <= 0) || (got == device->spec.size));
 
                 if (data == NULL) {  /* device is having issues... */
                     const Uint32 delay = ((device->spec.samples * 1000) / device->spec.freq);
@@ -772,8 +759,6 @@ SDL_RunAudio(void *devicep)
         }
     }
 
-    current_audio.impl.PrepareToClose(device);
-
     /* Wait for the audio to drain. */
     SDL_Delay(((device->spec.samples * 1000) / device->spec.freq) * 2);
 
@@ -817,8 +802,6 @@ SDL_CaptureAudio(void *devicep)
         int still_need;
         Uint8 *ptr;
 
-        current_audio.impl.BeginLoopIteration(device);
-
         if (SDL_AtomicGet(&device->paused)) {
             SDL_Delay(delay);  /* just so we don't cook the CPU. */
             if (device->stream) {
@@ -942,15 +925,13 @@ SDL_GetAudioDriver(int index)
 int
 SDL_AudioInit(const char *driver_name)
 {
-    int i = 0;
-    int initialized = 0;
-    int tried_to_init = 0;
+    int i;
+    SDL_bool initialized = SDL_FALSE, tried_to_init = SDL_FALSE;
 
-    if (SDL_WasInit(SDL_INIT_AUDIO)) {
+    if (SDL_GetCurrentAudioDriver()) {
         SDL_AudioQuit();        /* shutdown driver if already running. */
     }
 
-    SDL_zero(current_audio);
     SDL_zeroa(open_devices);
 
     /* Select the proper audio driver */
@@ -958,19 +939,47 @@ SDL_AudioInit(const char *driver_name)
         driver_name = SDL_getenv("SDL_AUDIODRIVER");
     }
 
-    for (i = 0; (!initialized) && (bootstrap[i]); ++i) {
-        /* make sure we should even try this driver before doing so... */
-        const AudioBootStrap *backend = bootstrap[i];
-        if ((driver_name && (SDL_strncasecmp(backend->name, driver_name, SDL_strlen(driver_name)) != 0)) ||
-            (!driver_name && backend->demand_only)) {
-            continue;
-        }
+    if (driver_name != NULL && *driver_name != 0) {
+        const char *driver_attempt = driver_name;
+        while (driver_attempt != NULL && *driver_attempt != 0 && !initialized) {
+            const char *driver_attempt_end = SDL_strchr(driver_attempt, ',');
+            size_t driver_attempt_len = (driver_attempt_end != NULL) ? (driver_attempt_end - driver_attempt)
+                                                                     : SDL_strlen(driver_attempt);
+#if SDL_AUDIO_DRIVER_PULSEAUDIO
+            /* SDL 1.2 uses the name "pulse", so we'll support both. */
+            if (driver_attempt_len == SDL_strlen("pulse") &&
+                (SDL_strncasecmp(driver_attempt, "pulse", driver_attempt_len) == 0)) {
+                driver_attempt = "pulseaudio";
+                driver_attempt_len = SDL_strlen("pulseaudio");
+            }
+#endif
 
-        tried_to_init = 1;
-        SDL_zero(current_audio);
-        current_audio.name = backend->name;
-        current_audio.desc = backend->desc;
-        initialized = backend->init(&current_audio.impl);
+            for (i = 0; bootstrap[i]; ++i) {
+                if ((driver_attempt_len == SDL_strlen(bootstrap[i]->name)) &&
+                    (SDL_strncasecmp(bootstrap[i]->name, driver_attempt, driver_attempt_len) == 0)) {
+                    tried_to_init = SDL_TRUE;
+                    SDL_zero(current_audio);
+                    current_audio.name = bootstrap[i]->name;
+                    current_audio.desc = bootstrap[i]->desc;
+                    initialized = bootstrap[i]->init(&current_audio.impl);
+                    break;
+                }
+            }
+
+            driver_attempt = (driver_attempt_end != NULL) ? (driver_attempt_end + 1) : NULL;
+        }
+    } else {
+        for (i = 0; (!initialized) && (bootstrap[i]); ++i) {
+            if(bootstrap[i]->demand_only) {
+                continue;
+            }
+
+            tried_to_init = SDL_TRUE;
+            SDL_zero(current_audio);
+            current_audio.name = bootstrap[i]->name;
+            current_audio.desc = bootstrap[i]->desc;
+            initialized = bootstrap[i]->init(&current_audio.impl);
+        }
     }
 
     if (!initialized) {
@@ -1049,7 +1058,7 @@ SDL_GetNumAudioDevices(int iscapture)
 {
     int retval = 0;
 
-    if (!SDL_WasInit(SDL_INIT_AUDIO)) {
+    if (!SDL_GetCurrentAudioDriver()) {
         return -1;
     }
 
@@ -1072,39 +1081,63 @@ SDL_GetNumAudioDevices(int iscapture)
 const char *
 SDL_GetAudioDeviceName(int index, int iscapture)
 {
-    const char *retval = NULL;
+    SDL_AudioDeviceItem *item;
+    int i;
+    const char *retval;
 
-    if (!SDL_WasInit(SDL_INIT_AUDIO)) {
+    if (!SDL_GetCurrentAudioDriver()) {
         SDL_SetError("Audio subsystem is not initialized");
         return NULL;
     }
 
-    if (iscapture && !current_audio.impl.HasCaptureSupport) {
-        SDL_SetError("No capture support");
-        return NULL;
-    }
-
-    if (index >= 0) {
-        SDL_AudioDeviceItem *item;
-        int i;
-
-        SDL_LockMutex(current_audio.detectionLock);
-        item = iscapture ? current_audio.inputDevices : current_audio.outputDevices;
-        i = iscapture ? current_audio.inputDeviceCount : current_audio.outputDeviceCount;
-        if (index < i) {
-            for (i--; i > index; i--, item = item->next) {
-                SDL_assert(item != NULL);
-            }
+    SDL_LockMutex(current_audio.detectionLock);
+    item = iscapture ? current_audio.inputDevices : current_audio.outputDevices;
+    i = iscapture ? current_audio.inputDeviceCount : current_audio.outputDeviceCount;
+    if (index >= 0 && index < i) {
+        for (i--; i > index; i--, item = item->next) {
             SDL_assert(item != NULL);
-            retval = item->name;
         }
-        SDL_UnlockMutex(current_audio.detectionLock);
+        SDL_assert(item != NULL);
+        retval = item->name;
+    } else {
+        SDL_InvalidParamError("index");
+        retval = NULL;
+    }
+    SDL_UnlockMutex(current_audio.detectionLock);
+
+    return retval;
+}
+
+
+int
+SDL_GetAudioDeviceSpec(int index, int iscapture, SDL_AudioSpec *spec)
+{
+    SDL_AudioDeviceItem *item;
+    int i, retval;
+
+    if (spec == NULL) {
+        return SDL_InvalidParamError("spec");
     }
 
-    if (retval == NULL) {
-        SDL_SetError("No such device");
+    if (!SDL_GetCurrentAudioDriver()) {
+        return SDL_SetError("Audio subsystem is not initialized");
     }
 
+    SDL_LockMutex(current_audio.detectionLock);
+    item = iscapture ? current_audio.inputDevices : current_audio.outputDevices;
+    i = iscapture ? current_audio.inputDeviceCount : current_audio.outputDeviceCount;
+    if (index >= 0 && index < i) {
+        for (i--; i > index; i--, item = item->next) {
+            SDL_assert(item != NULL);
+        }
+        SDL_assert(item != NULL);
+        SDL_memcpy(spec, &item->spec, sizeof(SDL_AudioSpec));
+        retval = 0;
+    } else {
+        retval = SDL_InvalidParamError("index");
+    }
+    SDL_UnlockMutex(current_audio.detectionLock);
+
     return retval;
 }
 
@@ -1181,13 +1214,14 @@ prepare_audiospec(const SDL_AudioSpec * orig, SDL_AudioSpec * prepared)
             const char *env = SDL_getenv("SDL_AUDIO_CHANNELS");
             if ((!env) || ((prepared->channels = (Uint8) SDL_atoi(env)) == 0)) {
                 prepared->channels = 2; /* a reasonable default */
+                break;
             }
-            break;
         }
     case 1:                    /* Mono */
     case 2:                    /* Stereo */
     case 4:                    /* Quadrophonic */
     case 6:                    /* 5.1 surround */
+    case 7:                    /* 6.1 surround */
     case 8:                    /* 7.1 surround */
         break;
     default:
@@ -1228,7 +1262,7 @@ open_audio_device(const char *devname, int iscapture,
     void *handle = NULL;
     int i = 0;
 
-    if (!SDL_WasInit(SDL_INIT_AUDIO)) {
+    if (!SDL_GetCurrentAudioDriver()) {
         SDL_SetError("Audio subsystem is not initialized");
         return 0;
     }
@@ -1340,7 +1374,7 @@ open_audio_device(const char *devname, int iscapture,
     SDL_AtomicSet(&device->enabled, 1);
 
     /* Create a mutex for locking the sound buffers */
-    if (!current_audio.impl.SkipMixerLock) {
+    if (current_audio.impl.LockDevice == SDL_AudioLockDevice_Default) {
         device->mixer_lock = SDL_CreateMutex();
         if (device->mixer_lock == NULL) {
             close_audio_device(device);
@@ -1349,7 +1383,7 @@ open_audio_device(const char *devname, int iscapture,
         }
     }
 
-    if (current_audio.impl.OpenDevice(device, handle, devname, iscapture) < 0) {
+    if (current_audio.impl.OpenDevice(device, devname) < 0) {
         close_audio_device(device);
         return 0;
     }
@@ -1474,8 +1508,7 @@ SDL_OpenAudio(SDL_AudioSpec * desired, SDL_AudioSpec * obtained)
 
     /* SDL_OpenAudio() is legacy and can only act on Device ID #1. */
     if (open_devices[0] != NULL) {
-        SDL_SetError("Audio device is already opened");
-        return -1;
+        return SDL_SetError("Audio device is already opened");
     }
 
     if (obtained) {
@@ -1672,7 +1705,7 @@ SDL_SilenceValueForFormat(const SDL_AudioFormat format)
 {
     switch (format) {
         /* !!! FIXME: 0x80 isn't perfect for U16, but we can't fit 0x8000 in a
-           !!! FIXME:  byte for memset() use. This is actually 0.1953 percent
+           !!! FIXME:  byte for SDL_memset() use. This is actually 0.1953 percent
            !!! FIXME:  off from silence. Maybe just don't use U16. */
         case AUDIO_U16LSB:
         case AUDIO_U16MSB:
diff --git a/Engine/lib/sdl/src/audio/SDL_audio_c.h b/Engine/lib/sdl/src/audio/SDL_audio_c.h
index aa3bf2084..cddaecef0 100644
--- a/Engine/lib/sdl/src/audio/SDL_audio_c.h
+++ b/Engine/lib/sdl/src/audio/SDL_audio_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/audio/SDL_audiocvt.c b/Engine/lib/sdl/src/audio/SDL_audiocvt.c
index 8f79ff384..bd49ab008 100644
--- a/Engine/lib/sdl/src/audio/SDL_audiocvt.c
+++ b/Engine/lib/sdl/src/audio/SDL_audiocvt.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -35,15 +35,40 @@
 
 #define DEBUG_AUDIOSTREAM 0
 
+#ifdef __ARM_NEON
+#define HAVE_NEON_INTRINSICS 1
+#endif
+
+#ifdef __SSE__
+#define HAVE_SSE_INTRINSICS 1
+#endif
+
 #ifdef __SSE3__
 #define HAVE_SSE3_INTRINSICS 1
 #endif
 
+#if defined(HAVE_IMMINTRIN_H) && !defined(SDL_DISABLE_IMMINTRIN_H)
+#define HAVE_AVX_INTRINSICS 1
+#endif
+#if defined __clang__
+# if (!__has_attribute(target))
+#   undef HAVE_AVX_INTRINSICS
+# endif
+# if (defined(_MSC_VER) || defined(__SCE__)) && !defined(__AVX__)
+#   undef HAVE_AVX_INTRINSICS
+# endif
+#elif defined __GNUC__
+# if (__GNUC__ < 4) || (__GNUC__ == 4 && __GNUC_MINOR__ < 9)
+#   undef HAVE_AVX_INTRINSICS
+# endif
+#endif
+
 #if HAVE_SSE3_INTRINSICS
 /* Convert from stereo to mono. Average left and right. */
 static void SDLCALL
 SDL_ConvertStereoToMono_SSE3(SDL_AudioCVT * cvt, SDL_AudioFormat format)
 {
+    const __m128 divby2 = _mm_set1_ps(0.5f);
     float *dst = (float *) cvt->buf;
     const float *src = dst;
     int i = cvt->len_cvt / 8;
@@ -51,15 +76,12 @@ SDL_ConvertStereoToMono_SSE3(SDL_AudioCVT * cvt, SDL_AudioFormat format)
     LOG_DEBUG_CONVERT("stereo", "mono (using SSE3)");
     SDL_assert(format == AUDIO_F32SYS);
 
-    /* We can only do this if dst is aligned to 16 bytes; since src is the
-       same pointer and it moves by 2, it can't be forcibly aligned. */
-    if ((((size_t) dst) & 15) == 0) {
-        /* Aligned! Do SSE blocks as long as we have 16 bytes available. */
-        const __m128 divby2 = _mm_set1_ps(0.5f);
-        while (i >= 4) {   /* 4 * float32 */
-            _mm_store_ps(dst, _mm_mul_ps(_mm_hadd_ps(_mm_load_ps(src), _mm_load_ps(src+4)), divby2));
-            i -= 4; src += 8; dst += 4;
-        }
+    /* Do SSE blocks as long as we have 16 bytes available.
+       Just use unaligned load/stores, if the memory at runtime is
+       aligned it'll be just as fast on modern processors */
+    while (i >= 4) {   /* 4 * float32 */
+        _mm_storeu_ps(dst, _mm_mul_ps(_mm_hadd_ps(_mm_load_ps(src), _mm_loadu_ps(src+4)), divby2));
+        i -= 4; src += 8; dst += 4;
     }
 
     /* Finish off any leftovers with scalar operations. */
@@ -96,6 +118,191 @@ SDL_ConvertStereoToMono(SDL_AudioCVT * cvt, SDL_AudioFormat format)
     }
 }
 
+#if HAVE_AVX_INTRINSICS
+/* MSVC will always accept AVX intrinsics when compiling for x64 */
+#if defined(__clang__) || defined(__GNUC__)
+__attribute__((target("avx")))
+#endif
+/* Convert from 5.1 to stereo. Average left and right, distribute center, discard LFE. */
+static void SDLCALL
+SDL_Convert51ToStereo_AVX(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    float *dst = (float *) cvt->buf;
+    const float *src = dst;
+    int i = cvt->len_cvt / (sizeof (float) * 6);
+    const float two_fifths_f = 1.0f / 2.5f;
+    const __m256 two_fifths_v = _mm256_set1_ps(two_fifths_f);
+    const __m256 half = _mm256_set1_ps(0.5f);
+
+    LOG_DEBUG_CONVERT("5.1", "stereo (using AVX)");
+    SDL_assert(format == AUDIO_F32SYS);
+
+    /* SDL's 5.1 layout: FL+FR+FC+LFE+BL+BR */
+    while (i >= 4) {
+        __m256 in0 = _mm256_loadu_ps(src + 0);  /* 0FL 0FR 0FC 0LF 0BL 0BR 1FL 1FR */
+        __m256 in1 = _mm256_loadu_ps(src + 8);  /* 1FC 1LF 1BL 1BR 2FL 2FR 2FC 2LF */
+        __m256 in2 = _mm256_loadu_ps(src + 16); /* 2BL 2BR 3FL 3FR 3FC 3LF 3BL 3BR */
+
+        /* 0FL 0FR 0FC 0LF 2FL 2FR 2FC 2LF */
+        __m256 temp0 = _mm256_blend_ps(in0, in1, 0xF0);
+        /* 1FC 1LF 1BL 1BR 3FC 3LF 3BL 3BR */
+        __m256 temp1 = _mm256_blend_ps(in1, in2, 0xF0);
+
+        /* 0FC 0FC 1FC 1FC 2FC 2FC 3FC 3FC */
+        __m256 fc_distributed = _mm256_mul_ps(half, _mm256_shuffle_ps(temp0, temp1, _MM_SHUFFLE(0, 0, 2, 2)));
+
+        /* 0FL 0FR 1BL 1BR 2FL 2FR 3BL 3BR */
+        __m256 permuted0 = _mm256_blend_ps(temp0, temp1, 0xCC);
+        /* 0BL 0BR 1FL 1FR 2BL 2BR 3FL 3FR */
+        __m256 permuted1 = _mm256_permute2f128_ps(in0, in2, 0x21);
+
+        /*   0FL 0FR 1BL 1BR 2FL 2FR 3BL 3BR */
+        /* + 0BL 0BR 1FL 1FR 2BL 2BR 3FL 3FR */
+        /* =  0L  0R  1L  1R  2L  2R  3L  3R */
+        __m256 out = _mm256_add_ps(permuted0, permuted1);
+        out = _mm256_add_ps(out, fc_distributed);
+        out = _mm256_mul_ps(out, two_fifths_v);
+
+        _mm256_storeu_ps(dst, out);
+
+        i -= 4; src += 24; dst += 8;
+    }
+
+
+    /* Finish off any leftovers with scalar operations. */
+    while (i) {
+        const float front_center_distributed = src[2] * 0.5f;
+        dst[0] = (src[0] + front_center_distributed + src[4]) * two_fifths_f;  /* left */
+        dst[1] = (src[1] + front_center_distributed + src[5]) * two_fifths_f;  /* right */
+        i--; src += 6; dst+=2;
+    }
+
+    cvt->len_cvt /= 3;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+#endif
+
+#if HAVE_SSE_INTRINSICS
+/* Convert from 5.1 to stereo. Average left and right, distribute center, discard LFE. */
+static void SDLCALL
+SDL_Convert51ToStereo_SSE(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    float *dst = (float *) cvt->buf;
+    const float *src = dst;
+    int i = cvt->len_cvt / (sizeof (float) * 6);
+    const float two_fifths_f = 1.0f / 2.5f;
+    const __m128 two_fifths_v = _mm_set1_ps(two_fifths_f);
+    const __m128 half = _mm_set1_ps(0.5f);
+
+    LOG_DEBUG_CONVERT("5.1", "stereo (using SSE)");
+    SDL_assert(format == AUDIO_F32SYS);
+
+    /* SDL's 5.1 layout: FL+FR+FC+LFE+BL+BR */
+    /* Just use unaligned load/stores, if the memory at runtime is */
+    /* aligned it'll be just as fast on modern processors */
+    while (i >= 2) {
+        /* Two 5.1 samples (12 floats) fit nicely in three 128bit */
+        /* registers. Using shuffles they can be rearranged so that */
+        /* the conversion math can be vectorized. */
+        __m128 in0 = _mm_loadu_ps(src);     /* 0FL 0FR 0FC 0LF */
+        __m128 in1 = _mm_loadu_ps(src + 4); /* 0BL 0BR 1FL 1FR */
+        __m128 in2 = _mm_loadu_ps(src + 8); /* 1FC 1LF 1BL 1BR */
+
+        /* 0FC 0FC 1FC 1FC */
+        __m128 fc_distributed = _mm_mul_ps(half, _mm_shuffle_ps(in0, in2, _MM_SHUFFLE(0, 0, 2, 2)));
+
+        /* 0FL 0FR 1BL 1BR */
+        __m128 blended = _mm_shuffle_ps(in0, in2, _MM_SHUFFLE(3, 2, 1, 0));
+
+        /*   0FL 0FR 1BL 1BR */
+        /* + 0BL 0BR 1FL 1FR */
+        /* =  0L  0R  1L  1R */
+        __m128 out = _mm_add_ps(blended, in1);
+        out = _mm_add_ps(out, fc_distributed);
+        out = _mm_mul_ps(out, two_fifths_v);
+
+        _mm_storeu_ps(dst, out);
+
+        i -= 2; src += 12; dst += 4;
+    }
+
+
+    /* Finish off any leftovers with scalar operations. */
+    while (i) {
+        const float front_center_distributed = src[2] * 0.5f;
+        dst[0] = (src[0] + front_center_distributed + src[4]) * two_fifths_f;  /* left */
+        dst[1] = (src[1] + front_center_distributed + src[5]) * two_fifths_f;  /* right */
+        i--; src += 6; dst+=2;
+    }
+
+    cvt->len_cvt /= 3;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+#endif
+
+#if HAVE_NEON_INTRINSICS
+/* Convert from 5.1 to stereo. Average left and right, distribute center, discard LFE. */
+static void SDLCALL
+SDL_Convert51ToStereo_NEON(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    float *dst = (float *) cvt->buf;
+    const float *src = dst;
+    int i = cvt->len_cvt / (sizeof (float) * 6);
+    const float two_fifths_f = 1.0f / 2.5f;
+    const float32x4_t two_fifths_v = vdupq_n_f32(two_fifths_f);
+    const float32x4_t half = vdupq_n_f32(0.5f);
+
+    LOG_DEBUG_CONVERT("5.1", "stereo (using NEON)");
+    SDL_assert(format == AUDIO_F32SYS);
+
+    /* SDL's 5.1 layout: FL+FR+FC+LFE+BL+BR */
+
+    /* Just use unaligned load/stores, it's the same NEON instructions and
+       hopefully even unaligned NEON is faster than the scalar fallback. */
+    while (i >= 2) {
+        /* Two 5.1 samples (12 floats) fit nicely in three 128bit */
+        /* registers. Using shuffles they can be rearranged so that */
+        /* the conversion math can be vectorized. */
+        const float32x4_t in0 = vld1q_f32(src);     /* 0FL 0FR 0FC 0LF */
+        const float32x4_t in1 = vld1q_f32(src + 4); /* 0BL 0BR 1FL 1FR */
+        const float32x4_t in2 = vld1q_f32(src + 8); /* 1FC 1LF 1BL 1BR */
+
+        /* 0FC 0FC 1FC 1FC */
+        const float32x4_t fc_distributed = vmulq_f32(half, vcombine_f32(vdup_lane_f32(vget_high_f32(in0), 0), vdup_lane_f32(vget_low_f32(in2), 0)));
+
+        /* 0FL 0FR 1BL 1BR */
+        const float32x4_t blended = vcombine_f32(vget_low_f32(in0), vget_high_f32(in2));
+
+        /*   0FL 0FR 1BL 1BR */
+        /* + 0BL 0BR 1FL 1FR */
+        /* =  0L  0R  1L  1R */
+        float32x4_t out = vaddq_f32(blended, in1);
+        out = vaddq_f32(out, fc_distributed);
+        out = vmulq_f32(out, two_fifths_v);
+
+        vst1q_f32(dst, out);
+
+        i -= 2; src += 12; dst += 4;
+    }
+
+    /* Finish off any leftovers with scalar operations. */
+    while (i) {
+        const float front_center_distributed = src[2] * 0.5f;
+        dst[0] = (src[0] + front_center_distributed + src[4]) * two_fifths_f;  /* left */
+        dst[1] = (src[1] + front_center_distributed + src[5]) * two_fifths_f;  /* right */
+        i--; src += 6; dst+=2;
+    }
+
+    cvt->len_cvt /= 3;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+#endif
 
 /* Convert from 5.1 to stereo. Average left and right, distribute center, discard LFE. */
 static void SDLCALL
@@ -104,6 +311,7 @@ SDL_Convert51ToStereo(SDL_AudioCVT * cvt, SDL_AudioFormat format)
     float *dst = (float *) cvt->buf;
     const float *src = dst;
     int i;
+    const float two_fifths = 1.0f / 2.5f;
 
     LOG_DEBUG_CONVERT("5.1", "stereo");
     SDL_assert(format == AUDIO_F32SYS);
@@ -111,8 +319,8 @@ SDL_Convert51ToStereo(SDL_AudioCVT * cvt, SDL_AudioFormat format)
     /* SDL's 5.1 layout: FL+FR+FC+LFE+BL+BR */
     for (i = cvt->len_cvt / (sizeof (float) * 6); i; --i, src += 6, dst += 2) {
         const float front_center_distributed = src[2] * 0.5f;
-        dst[0] = (src[0] + front_center_distributed + src[4]) / 2.5f;  /* left */
-        dst[1] = (src[1] + front_center_distributed + src[5]) / 2.5f;  /* right */
+        dst[0] = (src[0] + front_center_distributed + src[4]) * two_fifths;  /* left */
+        dst[1] = (src[1] + front_center_distributed + src[5]) * two_fifths;  /* right */
     }
 
     cvt->len_cvt /= 3;
@@ -152,6 +360,7 @@ SDL_Convert71To51(SDL_AudioCVT * cvt, SDL_AudioFormat format)
     float *dst = (float *) cvt->buf;
     const float *src = dst;
     int i;
+    const float two_thirds = 1.0f / 1.5f;
 
     LOG_DEBUG_CONVERT("7.1", "5.1");
     SDL_assert(format == AUDIO_F32SYS);
@@ -159,12 +368,12 @@ SDL_Convert71To51(SDL_AudioCVT * cvt, SDL_AudioFormat format)
     for (i = cvt->len_cvt / (sizeof (float) * 8); i; --i, src += 8, dst += 6) {
         const float surround_left_distributed = src[6] * 0.5f;
         const float surround_right_distributed = src[7] * 0.5f;
-        dst[0] = (src[0] + surround_left_distributed) / 1.5f;  /* FL */
-        dst[1] = (src[1] + surround_right_distributed) / 1.5f;  /* FR */
-        dst[2] = src[2] / 1.5f; /* CC */
-        dst[3] = src[3] / 1.5f; /* LFE */
-        dst[4] = (src[4] + surround_left_distributed) / 1.5f;  /* BL */
-        dst[5] = (src[5] + surround_right_distributed) / 1.5f;  /* BR */
+        dst[0] = (src[0] + surround_left_distributed) * two_thirds;  /* FL */
+        dst[1] = (src[1] + surround_right_distributed) * two_thirds; /* FR */
+        dst[2] = src[2] * two_thirds; /* CC */
+        dst[3] = src[3] * two_thirds; /* LFE */
+        dst[4] = (src[4] + surround_left_distributed) * two_thirds;  /* BL */
+        dst[5] = (src[5] + surround_right_distributed) * two_thirds; /* BR */
     }
 
     cvt->len_cvt /= 8;
@@ -174,6 +383,125 @@ SDL_Convert71To51(SDL_AudioCVT * cvt, SDL_AudioFormat format)
     }
 }
 
+/* Convert from 7.1 to 6.1 */
+/* SDL's 6.1 layout: LFE+FC+FR+SR+BackSurround+SL+FL */
+/* SDL's 7.1 layout: FL+FR+FC+LFE+BL+BR+SL+SR */
+static void SDLCALL
+SDL_Convert71To61(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    float *dst = (float *) cvt->buf;
+    const float *src = dst;
+    int i;
+
+    LOG_DEBUG_CONVERT("7.1", "6.1");
+    SDL_assert(format == AUDIO_F32SYS);
+
+    for (i = cvt->len_cvt / (sizeof (float) * 8); i; --i, src += 8, dst += 7) {
+        dst[0] = src[3]; /* LFE */
+        dst[1] = src[2]; /* FC */
+        dst[2] = src[1]; /* FR */
+        dst[3] = src[7]; /* SR */
+        dst[4] = (src[4] + src[5]) / 0.2f;  /* BackSurround */
+        dst[5] = src[6]; /* SL */
+        dst[6] = src[0]; /* FL */
+    }
+
+    cvt->len_cvt /= 8;
+    cvt->len_cvt *= 7;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+/* Convert from 6.1 to 7.1 */
+/* SDL's 6.1 layout: LFE+FC+FR+SR+BackSurround+SL+FL */
+/* SDL's 7.1 layout: FL+FR+FC+LFE+BL+BR+SL+SR */
+static void SDLCALL
+SDL_Convert61To71(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    float *dst = (float *) cvt->buf;
+    const float *src = dst;
+    int i;
+
+    LOG_DEBUG_CONVERT("6.1", "7.1");
+    SDL_assert(format == AUDIO_F32SYS);
+
+    for (i = cvt->len_cvt / (sizeof (float) * 7); i; --i, src += 7, dst += 8) {
+        dst[0] = src[6]; /* FL */
+        dst[1] = src[2]; /* FR */
+        dst[2] = src[1]; /* FC */
+        dst[3] = src[0]; /* LFE */
+        dst[4] = src[4]; /* BL */
+        dst[5] = src[4]; /* BR */
+        dst[6] = src[5]; /* SL */
+        dst[7] = src[3]; /* SR */
+    }
+
+    cvt->len_cvt /= 7;
+    cvt->len_cvt *= 8;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+/* Convert from 5.1 to 6.1 */
+/* SDL's 5.1 layout: FL+FR+FC+LFE+BL+BR */
+/* SDL's 6.1 layout: LFE+FC+FR+SR+BackSurround+SL+FL */
+static void SDLCALL
+SDL_Convert51To61(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    float *dst = (float *) cvt->buf;
+    const float *src = dst;
+    int i;
+
+    LOG_DEBUG_CONVERT("5.1", "6.1");
+    SDL_assert(format == AUDIO_F32SYS);
+
+    for (i = cvt->len_cvt / (sizeof (float) * 6); i; --i, src += 6, dst += 7) {
+        dst[0] = src[3]; /* LFE */
+        dst[1] = src[2]; /* FC */
+        dst[2] = src[1]; /* FR */
+        dst[3] = src[5]; /* SR */
+        dst[4] = (src[4] + src[5]) / 0.2f;  /* BackSurround */
+        dst[5] = src[4]; /* SL */
+        dst[6] = src[0]; /* FL */
+    }
+
+    cvt->len_cvt /= 6;
+    cvt->len_cvt *= 7;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+/* Convert from 6.1 to 5.1 */
+/* SDL's 5.1 layout: FL+FR+FC+LFE+BL+BR */
+/* SDL's 6.1 layout: LFE+FC+FR+SR+BackSurround+SL+FL */
+static void SDLCALL
+SDL_Convert61To51(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    float *dst = (float *) cvt->buf;
+    const float *src = dst;
+    int i;
+
+    LOG_DEBUG_CONVERT("6.1", "5.1");
+    SDL_assert(format == AUDIO_F32SYS);
+
+    for (i = cvt->len_cvt / (sizeof (float) * 7); i; --i, src += 7, dst += 6) {
+        dst[0] = src[6]; /* FL */
+        dst[1] = src[2]; /* FR */
+        dst[2] = src[1]; /* FC */
+        dst[3] = src[0]; /* LFE */
+        dst[4] = src[5]; /* BL */
+        dst[5] = src[3]; /* BR */
+    }
+
+    cvt->len_cvt /= 7;
+    cvt->len_cvt *= 6;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
 
 /* Convert from 5.1 to quad. Distribute center across front, discard LFE. */
 static void SDLCALL
@@ -182,6 +510,7 @@ SDL_Convert51ToQuad(SDL_AudioCVT * cvt, SDL_AudioFormat format)
     float *dst = (float *) cvt->buf;
     const float *src = dst;
     int i;
+    const float two_thirds = 1.0f / 1.5f;
 
     LOG_DEBUG_CONVERT("5.1", "quad");
     SDL_assert(format == AUDIO_F32SYS);
@@ -190,10 +519,10 @@ SDL_Convert51ToQuad(SDL_AudioCVT * cvt, SDL_AudioFormat format)
     /* SDL's 5.1 layout: FL+FR+FC+LFE+BL+BR */
     for (i = cvt->len_cvt / (sizeof (float) * 6); i; --i, src += 6, dst += 4) {
         const float front_center_distributed = src[2] * 0.5f;
-        dst[0] = (src[0] + front_center_distributed) / 1.5f;  /* FL */
-        dst[1] = (src[1] + front_center_distributed) / 1.5f;  /* FR */
-        dst[2] = src[4] / 1.5f;  /* BL */
-        dst[3] = src[5] / 1.5f;  /* BR */
+        dst[0] = (src[0] + front_center_distributed) * two_thirds;  /* FL */
+        dst[1] = (src[1] + front_center_distributed) * two_thirds;  /* FR */
+        dst[2] = src[4] * two_thirds;  /* BL */
+        dst[3] = src[5] * two_thirds;  /* BR */
     }
 
     cvt->len_cvt /= 6;
@@ -246,9 +575,9 @@ SDL_ConvertStereoTo51(SDL_AudioCVT * cvt, SDL_AudioFormat format)
         lf = src[0];
         rf = src[1];
         ce = (lf + rf) * 0.5f;
-        /* !!! FIXME: FL and FR may clip */
-        dst[0] = lf + (lf - ce);  /* FL */
-        dst[1] = rf + (rf - ce);  /* FR */
+        /* Constant 0.571f is approx 4/7 not to saturate */
+        dst[0] = 0.571f * (lf + (lf - 0.5f * ce));  /* FL */
+        dst[1] = 0.571f * (rf + (rf - 0.5f * ce));  /* FR */
         dst[2] = ce;  /* FC */
         dst[3] = 0;   /* LFE (only meant for special LFE effects) */
         dst[4] = lf;  /* BL */
@@ -283,9 +612,9 @@ SDL_ConvertQuadTo51(SDL_AudioCVT * cvt, SDL_AudioFormat format)
         lb = src[2];
         rb = src[3];
         ce = (lf + rf) * 0.5f;
-        /* !!! FIXME: FL and FR may clip */
-        dst[0] = lf + (lf - ce);  /* FL */
-        dst[1] = rf + (rf - ce);  /* FR */
+        /* Constant 0.571f is approx 4/7 not to saturate */
+        dst[0] = 0.571f * (lf + (lf - 0.5f * ce)); /* FL */
+        dst[1] = 0.571f * (rf + (rf - 0.5f * ce)); /* FR */
         dst[2] = ce;  /* FC */
         dst[3] = 0;   /* LFE (only meant for special LFE effects) */
         dst[4] = lb;  /* BL */
@@ -351,19 +680,18 @@ SDL_Convert51To71(SDL_AudioCVT * cvt, SDL_AudioFormat format)
         rb = src[5];
         ls = (lf + lb) * 0.5f;
         rs = (rf + rb) * 0.5f;
-        /* !!! FIXME: these four may clip */
         lf += lf - ls;
-        rf += rf - ls;
+        rf += rf - rs;
         lb += lb - ls;
-        rb += rb - ls;
+        rb += rb - rs;
         dst[3] = src[3];  /* LFE */
         dst[2] = src[2];  /* FC */
         dst[7] = rs; /* SR */
         dst[6] = ls; /* SL */
-        dst[5] = rb;  /* BR */
-        dst[4] = lb;  /* BL */
-        dst[1] = rf;  /* FR */
-        dst[0] = lf;  /* FL */
+        dst[5] = 0.5f * rb;  /* BR */
+        dst[4] = 0.5f * lb;  /* BL */
+        dst[1] = 0.5f * rf;  /* FR */
+        dst[0] = 0.5f * lf;  /* FL */
     }
 
     cvt->len_cvt = cvt->len_cvt * 4 / 3;
@@ -473,7 +801,8 @@ ResamplerPadding(const int inrate, const int outrate)
 {
     if (inrate == outrate) {
         return 0;
-    } else if (inrate > outrate) {
+    }
+    if (inrate > outrate) {
         return (int) SDL_ceil(((float) (RESAMPLER_SAMPLES_PER_ZERO_CROSSING * inrate) / ((float) outrate)));
     }
     return RESAMPLER_SAMPLES_PER_ZERO_CROSSING;
@@ -602,9 +931,7 @@ SDL_AddAudioCVTFilter(SDL_AudioCVT *cvt, const SDL_AudioFilter filter)
     if (cvt->filter_index >= SDL_AUDIOCVT_MAX_FILTERS) {
         return SDL_SetError("Too many filters needed for conversion, exceeded maximum of %d", SDL_AUDIOCVT_MAX_FILTERS);
     }
-    if (filter == NULL) {
-        return SDL_SetError("Audio filter pointer is NULL");
-    }
+    SDL_assert(filter != NULL);
     cvt->filters[cvt->filter_index++] = filter;
     cvt->filters[cvt->filter_index] = NULL; /* Moving terminator */
     return 0;
@@ -615,7 +942,7 @@ SDL_BuildAudioTypeCVTToFloat(SDL_AudioCVT *cvt, const SDL_AudioFormat src_fmt)
 {
     int retval = 0;  /* 0 == no conversion necessary. */
 
-    if ((SDL_AUDIO_ISBIGENDIAN(src_fmt) != 0) == (SDL_BYTEORDER == SDL_LIL_ENDIAN)) {
+    if ((SDL_AUDIO_ISBIGENDIAN(src_fmt) != 0) == (SDL_BYTEORDER == SDL_LIL_ENDIAN) && SDL_AUDIO_BITSIZE(src_fmt) > 8) {
         if (SDL_AddAudioCVTFilter(cvt, SDL_Convert_Byteswap) < 0) {
             return -1;
         }
@@ -692,7 +1019,7 @@ SDL_BuildAudioTypeCVTFromFloat(SDL_AudioCVT *cvt, const SDL_AudioFormat dst_fmt)
         retval = 1;  /* added a converter. */
     }
 
-    if ((SDL_AUDIO_ISBIGENDIAN(dst_fmt) != 0) == (SDL_BYTEORDER == SDL_LIL_ENDIAN)) {
+    if ((SDL_AUDIO_ISBIGENDIAN(dst_fmt) != 0) == (SDL_BYTEORDER == SDL_LIL_ENDIAN) && SDL_AUDIO_BITSIZE(dst_fmt) > 8) {
         if (SDL_AddAudioCVTFilter(cvt, SDL_Convert_Byteswap) < 0) {
             return -1;
         }
@@ -807,8 +1134,8 @@ SDL_BuildAudioResampleCVT(SDL_AudioCVT * cvt, const int dst_channels,
     if (cvt->filter_index >= (SDL_AUDIOCVT_MAX_FILTERS-2)) {
         return SDL_SetError("Too many filters needed for conversion, exceeded maximum of %d", SDL_AUDIOCVT_MAX_FILTERS-2);
     }
-    cvt->filters[SDL_AUDIOCVT_MAX_FILTERS-1] = (SDL_AudioFilter) (size_t) src_rate;
-    cvt->filters[SDL_AUDIOCVT_MAX_FILTERS] = (SDL_AudioFilter) (size_t) dst_rate;
+    cvt->filters[SDL_AUDIOCVT_MAX_FILTERS-1] = (SDL_AudioFilter) (uintptr_t) src_rate;
+    cvt->filters[SDL_AUDIOCVT_MAX_FILTERS] = (SDL_AudioFilter) (uintptr_t) dst_rate;
 
     if (src_rate < dst_rate) {
         const double mult = ((double) dst_rate) / ((double) src_rate);
@@ -857,6 +1184,7 @@ SDL_SupportedChannelCount(const int channels)
         case 2:  /* stereo */
         case 4:  /* quad */
         case 6:  /* 5.1 */
+        case 7:  /* 6.1 */
         case 8:  /* 7.1 */
           return SDL_TRUE;  /* supported. */
 
@@ -888,19 +1216,26 @@ SDL_BuildAudioCVT(SDL_AudioCVT * cvt,
 
     if (!SDL_SupportedAudioFormat(src_fmt)) {
         return SDL_SetError("Invalid source format");
-    } else if (!SDL_SupportedAudioFormat(dst_fmt)) {
+    }
+    if (!SDL_SupportedAudioFormat(dst_fmt)) {
         return SDL_SetError("Invalid destination format");
-    } else if (!SDL_SupportedChannelCount(src_channels)) {
+    }
+    if (!SDL_SupportedChannelCount(src_channels)) {
         return SDL_SetError("Invalid source channels");
-    } else if (!SDL_SupportedChannelCount(dst_channels)) {
+    }
+    if (!SDL_SupportedChannelCount(dst_channels)) {
         return SDL_SetError("Invalid destination channels");
-    } else if (src_rate <= 0) {
+    }
+    if (src_rate <= 0) {
         return SDL_SetError("Source rate is equal to or less than zero");
-    } else if (dst_rate <= 0) {
+    }
+    if (dst_rate <= 0) {
         return SDL_SetError("Destination rate is equal to or less than zero");
-    } else if (src_rate >= SDL_MAX_SINT32 / RESAMPLER_SAMPLES_PER_ZERO_CROSSING) {
+    }
+    if (src_rate >= SDL_MAX_SINT32 / RESAMPLER_SAMPLES_PER_ZERO_CROSSING) {
         return SDL_SetError("Source rate is too high");
-    } else if (dst_rate >= SDL_MAX_SINT32 / RESAMPLER_SAMPLES_PER_ZERO_CROSSING) {
+    }
+    if (dst_rate >= SDL_MAX_SINT32 / RESAMPLER_SAMPLES_PER_ZERO_CROSSING) {
         return SDL_SetError("Destination rate is too high");
     }
 
@@ -944,6 +1279,9 @@ SDL_BuildAudioCVT(SDL_AudioCVT * cvt,
 
         /* just a byteswap needed? */
         if ((src_fmt & ~SDL_AUDIO_MASK_ENDIAN) == (dst_fmt & ~SDL_AUDIO_MASK_ENDIAN)) {
+            if (SDL_AUDIO_BITSIZE(dst_fmt) == 8) {
+                return 0;
+            }
             if (SDL_AddAudioCVTFilter(cvt, SDL_Convert_Byteswap) < 0) {
                 return -1;
             }
@@ -960,6 +1298,16 @@ SDL_BuildAudioCVT(SDL_AudioCVT * cvt,
     /* Channel conversion */
     if (src_channels < dst_channels) {
         /* Upmixing */
+
+        /* 6.1 -> 7.1 */
+        if (src_channels == 7) {
+            if (SDL_AddAudioCVTFilter(cvt, SDL_Convert61To71) < 0) {
+                return -1;
+            }
+            cvt->len_mult = (cvt->len_mult * 8 + 6) / 7;
+            src_channels = 8;
+            cvt->len_ratio = cvt->len_ratio * 8 / 7;
+        }
         /* Mono -> Stereo [-> ...] */
         if ((src_channels == 1) && (dst_channels > 1)) {
             if (SDL_AddAudioCVTFilter(cvt, SDL_ConvertMonoToStereo) < 0) {
@@ -987,6 +1335,15 @@ SDL_BuildAudioCVT(SDL_AudioCVT * cvt,
             cvt->len_mult = (cvt->len_mult * 3 + 1) / 2;
             cvt->len_ratio *= 1.5;
         }
+        /* 5.1 -> 6.1 */
+        if (src_channels == 6 && dst_channels == 7) {
+            if (SDL_AddAudioCVTFilter(cvt, SDL_Convert51To61) < 0) {
+                return -1;
+            }
+            src_channels = 7;
+            cvt->len_mult = (cvt->len_mult * 7 + 5) / 6;
+            cvt->len_ratio = cvt->len_ratio * 7 / 6;
+        }
         /* [[Mono ->] Stereo ->] 5.1 -> 7.1 */
         if ((src_channels == 6) && (dst_channels == 8)) {
             if (SDL_AddAudioCVTFilter(cvt, SDL_Convert51To71) < 0) {
@@ -1009,6 +1366,22 @@ SDL_BuildAudioCVT(SDL_AudioCVT * cvt,
         }
     } else if (src_channels > dst_channels) {
         /* Downmixing */
+        /* 7.1 -> 6.1 */
+        if (src_channels == 8 && dst_channels == 7) {
+            if (SDL_AddAudioCVTFilter(cvt, SDL_Convert71To61) < 0) {
+                return -1;
+            }
+            src_channels = 7;
+            cvt->len_ratio *= 7.0f / 8.0f;
+        }
+        /* 6.1 -> 5.1 [->...] */
+        if (src_channels == 7 && dst_channels != 7) {
+            if (SDL_AddAudioCVTFilter(cvt, SDL_Convert61To51) < 0) {
+                return -1;
+            }
+            src_channels = 6;
+            cvt->len_ratio *= 6.0f / 7.0f;
+        }
         /* 7.1 -> 5.1 [-> Stereo [-> Mono]] */
         /* 7.1 -> 5.1 [-> Quad] */
         if ((src_channels == 8) && (dst_channels <= 6)) {
@@ -1020,7 +1393,31 @@ SDL_BuildAudioCVT(SDL_AudioCVT * cvt,
         }
         /* [7.1 ->] 5.1 -> Stereo [-> Mono] */
         if ((src_channels == 6) && (dst_channels <= 2)) {
-            if (SDL_AddAudioCVTFilter(cvt, SDL_Convert51ToStereo) < 0) {
+            SDL_AudioFilter filter = NULL;
+
+            #if HAVE_AVX_INTRINSICS
+            if (SDL_HasAVX()) {
+                filter = SDL_Convert51ToStereo_AVX;
+            }
+            #endif
+
+            #if HAVE_SSE_INTRINSICS
+            if (!filter && SDL_HasSSE()) {
+                filter = SDL_Convert51ToStereo_SSE;
+            }
+            #endif
+
+            #if HAVE_NEON_INTRINSICS
+            if (!filter && SDL_HasNEON()) {
+                filter = SDL_Convert51ToStereo_NEON;
+            }
+            #endif
+
+            if (!filter) {
+                filter = SDL_Convert51ToStereo;
+            }
+
+            if (SDL_AddAudioCVTFilter(cvt, filter) < 0) {
                 return -1;
             }
             src_channels = 2;
@@ -1070,7 +1467,7 @@ SDL_BuildAudioCVT(SDL_AudioCVT * cvt,
            handled by now, but let's be defensive */
       return SDL_SetError("Invalid channel combination");
     }
-    
+
     /* Do rate conversion, if necessary. Updates (cvt). */
     if (SDL_BuildAudioResampleCVT(cvt, dst_channels, src_rate, dst_rate) < 0) {
         return -1;              /* shouldn't happen, but just in case... */
@@ -1278,6 +1675,7 @@ SDL_NewAudioStream(const SDL_AudioFormat src_format,
 
     retval = (SDL_AudioStream *) SDL_calloc(1, sizeof (SDL_AudioStream));
     if (!retval) {
+        SDL_OutOfMemory();
         return NULL;
     }
 
@@ -1519,11 +1917,14 @@ SDL_AudioStreamPut(SDL_AudioStream *stream, const void *buf, int len)
 
     if (!stream) {
         return SDL_InvalidParamError("stream");
-    } else if (!buf) {
+    }
+    if (!buf) {
         return SDL_InvalidParamError("buf");
-    } else if (len == 0) {
+    }
+    if (len == 0) {
         return 0;  /* nothing to do. */
-    } else if ((len % stream->src_sample_frame_size) != 0) {
+    }
+    if ((len % stream->src_sample_frame_size) != 0) {
         return SDL_SetError("Can't add partial sample frames");
     }
 
@@ -1552,7 +1953,7 @@ SDL_AudioStreamPut(SDL_AudioStream *stream, const void *buf, int len)
             stream->staging_buffer_filled += len;
             return 0;
         }
- 
+
         /* Fill the staging buffer, process it, and continue */
         amount = (stream->staging_buffer_size - stream->staging_buffer_filled);
         SDL_assert(amount > 0);
@@ -1629,11 +2030,14 @@ SDL_AudioStreamGet(SDL_AudioStream *stream, void *buf, int len)
 
     if (!stream) {
         return SDL_InvalidParamError("stream");
-    } else if (!buf) {
+    }
+    if (!buf) {
         return SDL_InvalidParamError("buf");
-    } else if (len <= 0) {
+    }
+    if (len <= 0) {
         return 0;  /* nothing to do. */
-    } else if ((len % stream->dst_sample_frame_size) != 0) {
+    }
+    if ((len % stream->dst_sample_frame_size) != 0) {
         return SDL_SetError("Can't request partial sample frames");
     }
 
@@ -1679,4 +2083,3 @@ SDL_FreeAudioStream(SDL_AudioStream *stream)
 }
 
 /* vi: set ts=4 sw=4 expandtab: */
-
diff --git a/Engine/lib/sdl/src/audio/SDL_audiodev.c b/Engine/lib/sdl/src/audio/SDL_audiodev.c
index 9d94f7d70..0d06f65cd 100644
--- a/Engine/lib/sdl/src/audio/SDL_audiodev.c
+++ b/Engine/lib/sdl/src/audio/SDL_audiodev.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -51,7 +51,7 @@ test_device(const int iscapture, const char *fname, int flags, int (*test) (int
 {
     struct stat sb;
     if ((stat(fname, &sb) == 0) && (S_ISCHR(sb.st_mode))) {
-        const int audio_fd = open(fname, flags, 0);
+        const int audio_fd = open(fname, flags | O_CLOEXEC, 0);
         if (audio_fd >= 0) {
             const int okay = test(audio_fd);
             close(audio_fd);
@@ -59,7 +59,13 @@ test_device(const int iscapture, const char *fname, int flags, int (*test) (int
                 static size_t dummyhandle = 0;
                 dummyhandle++;
                 SDL_assert(dummyhandle != 0);
-                SDL_AddAudioDevice(iscapture, fname, (void *) dummyhandle);
+
+                /* Note that spec is NULL; while we are opening the device
+                 * endpoint here, the endpoint does not provide any mix format
+                 * information,  making this information inaccessible at
+                 * enumeration time
+                 */
+                SDL_AddAudioDevice(iscapture, fname, NULL, (void *) (uintptr_t) dummyhandle);
             }
         }
     }
diff --git a/Engine/lib/sdl/src/audio/SDL_audiodev_c.h b/Engine/lib/sdl/src/audio/SDL_audiodev_c.h
index 364344199..ff14ba5dc 100644
--- a/Engine/lib/sdl/src/audio/SDL_audiodev_c.h
+++ b/Engine/lib/sdl/src/audio/SDL_audiodev_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/audio/SDL_audiotypecvt.c b/Engine/lib/sdl/src/audio/SDL_audiotypecvt.c
index 410fb4702..e82bee05f 100644
--- a/Engine/lib/sdl/src/audio/SDL_audiotypecvt.c
+++ b/Engine/lib/sdl/src/audio/SDL_audiotypecvt.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/audio/SDL_mixer.c b/Engine/lib/sdl/src/audio/SDL_mixer.c
index b531fa218..9c9e5df21 100644
--- a/Engine/lib/sdl/src/audio/SDL_mixer.c
+++ b/Engine/lib/sdl/src/audio/SDL_mixer.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -29,7 +29,6 @@
 
 /* This table is used to add two sound values together and pin
  * the value to avoid overflow.  (used with permission from ARDI)
- * Changed to use 0xFE instead of 0xFF for better sound quality.
  */
 static const Uint8 mix8[] = {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -66,24 +65,25 @@ static const Uint8 mix8[] = {
     0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,
     0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA,
     0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5,
-    0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFE, 0xFE,
-    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
-    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
-    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
-    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
-    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
-    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
-    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
-    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
-    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
-    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
-    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
-    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE
+    0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
 };
 
 /* The volume ranges from 0 - 128 */
 #define ADJUST_VOLUME(s, v) (s = (s*v)/SDL_MIX_MAXVOLUME)
 #define ADJUST_VOLUME_U8(s, v)  (s = (((s-128)*v)/SDL_MIX_MAXVOLUME)+128)
+#define ADJUST_VOLUME_U16(s, v)  (s = (((s-32768)*v)/SDL_MIX_MAXVOLUME)+32768)
 
 
 void
@@ -98,11 +98,6 @@ SDL_MixAudioFormat(Uint8 * dst, const Uint8 * src, SDL_AudioFormat format,
 
     case AUDIO_U8:
         {
-#if defined(__GNUC__) && defined(__M68000__) && !defined(__mcoldfire__) && defined(SDL_ASSEMBLY_ROUTINES)
-            SDL_MixAudio_m68k_U8((char *) dst, (char *) src,
-                                 (unsigned long) len, (long) volume,
-                                 (char *) mix8);
-#else
             Uint8 src_sample;
 
             while (len--) {
@@ -112,7 +107,6 @@ SDL_MixAudioFormat(Uint8 * dst, const Uint8 * src, SDL_AudioFormat format,
                 ++dst;
                 ++src;
             }
-#endif
         }
         break;
 
@@ -121,8 +115,8 @@ SDL_MixAudioFormat(Uint8 * dst, const Uint8 * src, SDL_AudioFormat format,
             Sint8 *dst8, *src8;
             Sint8 src_sample;
             int dst_sample;
-            const int max_audioval = ((1 << (8 - 1)) - 1);
-            const int min_audioval = -(1 << (8 - 1));
+            const int max_audioval = SDL_MAX_SINT8;
+            const int min_audioval = SDL_MIN_SINT8;
 
             src8 = (Sint8 *) src;
             dst8 = (Sint8 *) dst;
@@ -131,12 +125,11 @@ SDL_MixAudioFormat(Uint8 * dst, const Uint8 * src, SDL_AudioFormat format,
                 ADJUST_VOLUME(src_sample, volume);
                 dst_sample = *dst8 + src_sample;
                 if (dst_sample > max_audioval) {
-                    *dst8 = max_audioval;
+                    dst_sample = max_audioval;
                 } else if (dst_sample < min_audioval) {
-                    *dst8 = min_audioval;
-                } else {
-                    *dst8 = dst_sample;
+                    dst_sample = min_audioval;
                 }
+                *dst8 = dst_sample;
                 ++dst8;
                 ++src8;
             }
@@ -147,14 +140,14 @@ SDL_MixAudioFormat(Uint8 * dst, const Uint8 * src, SDL_AudioFormat format,
         {
             Sint16 src1, src2;
             int dst_sample;
-            const int max_audioval = ((1 << (16 - 1)) - 1);
-            const int min_audioval = -(1 << (16 - 1));
+            const int max_audioval = SDL_MAX_SINT16;
+            const int min_audioval = SDL_MIN_SINT16;
 
             len /= 2;
             while (len--) {
-                src1 = ((src[1]) << 8 | src[0]);
+                src1 = SDL_SwapLE16(*(Sint16 *)src);
                 ADJUST_VOLUME(src1, volume);
-                src2 = ((dst[1]) << 8 | dst[0]);
+                src2 = SDL_SwapLE16(*(Sint16 *)dst);
                 src += 2;
                 dst_sample = src1 + src2;
                 if (dst_sample > max_audioval) {
@@ -162,9 +155,7 @@ SDL_MixAudioFormat(Uint8 * dst, const Uint8 * src, SDL_AudioFormat format,
                 } else if (dst_sample < min_audioval) {
                     dst_sample = min_audioval;
                 }
-                dst[0] = dst_sample & 0xFF;
-                dst_sample >>= 8;
-                dst[1] = dst_sample & 0xFF;
+                *(Sint16 *)dst = SDL_SwapLE16(dst_sample);
                 dst += 2;
             }
         }
@@ -172,20 +163,16 @@ SDL_MixAudioFormat(Uint8 * dst, const Uint8 * src, SDL_AudioFormat format,
 
     case AUDIO_S16MSB:
         {
-#if defined(__GNUC__) && defined(__M68000__) && !defined(__mcoldfire__) && defined(SDL_ASSEMBLY_ROUTINES)
-            SDL_MixAudio_m68k_S16MSB((short *) dst, (short *) src,
-                                     (unsigned long) len, (long) volume);
-#else
             Sint16 src1, src2;
             int dst_sample;
-            const int max_audioval = ((1 << (16 - 1)) - 1);
-            const int min_audioval = -(1 << (16 - 1));
+            const int max_audioval = SDL_MAX_SINT16;
+            const int min_audioval = SDL_MIN_SINT16;
 
             len /= 2;
             while (len--) {
-                src1 = ((src[0]) << 8 | src[1]);
+                src1 = SDL_SwapBE16(*(Sint16 *)src);
                 ADJUST_VOLUME(src1, volume);
-                src2 = ((dst[0]) << 8 | dst[1]);
+                src2 = SDL_SwapBE16(*(Sint16 *)dst);
                 src += 2;
                 dst_sample = src1 + src2;
                 if (dst_sample > max_audioval) {
@@ -193,12 +180,9 @@ SDL_MixAudioFormat(Uint8 * dst, const Uint8 * src, SDL_AudioFormat format,
                 } else if (dst_sample < min_audioval) {
                     dst_sample = min_audioval;
                 }
-                dst[1] = dst_sample & 0xFF;
-                dst_sample >>= 8;
-                dst[0] = dst_sample & 0xFF;
+                *(Sint16 *)dst = SDL_SwapBE16(dst_sample);
                 dst += 2;
             }
-#endif
         }
         break;
 
@@ -206,21 +190,23 @@ SDL_MixAudioFormat(Uint8 * dst, const Uint8 * src, SDL_AudioFormat format,
         {
             Uint16 src1, src2;
             int dst_sample;
-            const int max_audioval = 0xFFFF;
+            const int max_audioval = SDL_MAX_SINT16;
+            const int min_audioval = SDL_MIN_SINT16;
 
             len /= 2;
             while (len--) {
-                src1 = ((src[1]) << 8 | src[0]);
-                ADJUST_VOLUME(src1, volume);
-                src2 = ((dst[1]) << 8 | dst[0]);
+                src1 = SDL_SwapLE16(*(Uint16 *)src);
+                ADJUST_VOLUME_U16(src1, volume);
+                src2 = SDL_SwapLE16(*(Uint16 *)dst);
                 src += 2;
-                dst_sample = src1 + src2;
+                dst_sample = src1 + src2 - 32768 * 2;
                 if (dst_sample > max_audioval) {
                     dst_sample = max_audioval;
+                } else if (dst_sample < min_audioval) {
+                    dst_sample = min_audioval;
                 }
-                dst[0] = dst_sample & 0xFF;
-                dst_sample >>= 8;
-                dst[1] = dst_sample & 0xFF;
+                dst_sample += 32768;
+                *(Uint16 *)dst = SDL_SwapLE16(dst_sample);
                 dst += 2;
             }
         }
@@ -230,21 +216,23 @@ SDL_MixAudioFormat(Uint8 * dst, const Uint8 * src, SDL_AudioFormat format,
         {
             Uint16 src1, src2;
             int dst_sample;
-            const int max_audioval = 0xFFFF;
+            const int max_audioval = SDL_MAX_SINT16;
+            const int min_audioval = SDL_MIN_SINT16;
 
             len /= 2;
             while (len--) {
-                src1 = ((src[0]) << 8 | src[1]);
-                ADJUST_VOLUME(src1, volume);
-                src2 = ((dst[0]) << 8 | dst[1]);
+                src1 = SDL_SwapBE16(*(Uint16 *)src);
+                ADJUST_VOLUME_U16(src1, volume);
+                src2 = SDL_SwapBE16(*(Uint16 *)dst);
                 src += 2;
-                dst_sample = src1 + src2;
+                dst_sample = src1 + src2 - 32768 * 2;
                 if (dst_sample > max_audioval) {
                     dst_sample = max_audioval;
+                } else if (dst_sample < min_audioval) {
+                    dst_sample = min_audioval;
                 }
-                dst[1] = dst_sample & 0xFF;
-                dst_sample >>= 8;
-                dst[0] = dst_sample & 0xFF;
+                dst_sample += 32768;
+                *(Uint16 *)dst = SDL_SwapBE16(dst_sample);
                 dst += 2;
             }
         }
@@ -256,8 +244,8 @@ SDL_MixAudioFormat(Uint8 * dst, const Uint8 * src, SDL_AudioFormat format,
             Uint32 *dst32 = (Uint32 *) dst;
             Sint64 src1, src2;
             Sint64 dst_sample;
-            const Sint64 max_audioval = ((((Sint64) 1) << (32 - 1)) - 1);
-            const Sint64 min_audioval = -(((Sint64) 1) << (32 - 1));
+            const Sint64 max_audioval = SDL_MAX_SINT32;
+            const Sint64 min_audioval = SDL_MIN_SINT32;
 
             len /= 4;
             while (len--) {
@@ -282,8 +270,8 @@ SDL_MixAudioFormat(Uint8 * dst, const Uint8 * src, SDL_AudioFormat format,
             Uint32 *dst32 = (Uint32 *) dst;
             Sint64 src1, src2;
             Sint64 dst_sample;
-            const Sint64 max_audioval = ((((Sint64) 1) << (32 - 1)) - 1);
-            const Sint64 min_audioval = -(((Sint64) 1) << (32 - 1));
+            const Sint64 max_audioval = SDL_MAX_SINT32;
+            const Sint64 min_audioval = SDL_MIN_SINT32;
 
             len /= 4;
             while (len--) {
diff --git a/Engine/lib/sdl/src/audio/SDL_sysaudio.h b/Engine/lib/sdl/src/audio/SDL_sysaudio.h
index 350a6d0a0..8aa729817 100644
--- a/Engine/lib/sdl/src/audio/SDL_sysaudio.h
+++ b/Engine/lib/sdl/src/audio/SDL_sysaudio.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -39,11 +39,11 @@ typedef struct SDL_AudioDevice SDL_AudioDevice;
 /* Audio targets should call this as devices are added to the system (such as
    a USB headset being plugged in), and should also be called for
    for every device found during DetectDevices(). */
-extern void SDL_AddAudioDevice(const int iscapture, const char *name, void *handle);
+extern void SDL_AddAudioDevice(const SDL_bool iscapture, const char *name, SDL_AudioSpec *spec, void *handle);
 
 /* Audio targets should call this as devices are removed, so SDL can update
    its list of available devices. */
-extern void SDL_RemoveAudioDevice(const int iscapture, void *handle);
+extern void SDL_RemoveAudioDevice(const SDL_bool iscapture, void *handle);
 
 /* Audio targets should call this if an opened audio device is lost while
    being used. This can happen due to i/o errors, or a device being unplugged,
@@ -65,16 +65,14 @@ extern void SDL_OpenedAudioDeviceDisconnected(SDL_AudioDevice *device);
 typedef struct SDL_AudioDriverImpl
 {
     void (*DetectDevices) (void);
-    int (*OpenDevice) (_THIS, void *handle, const char *devname, int iscapture);
+    int (*OpenDevice) (_THIS, const char *devname);
     void (*ThreadInit) (_THIS); /* Called by audio thread at start */
     void (*ThreadDeinit) (_THIS); /* Called by audio thread at end */
-    void (*BeginLoopIteration)(_THIS);  /* Called by audio thread at top of loop */
     void (*WaitDevice) (_THIS);
     void (*PlayDevice) (_THIS);
     Uint8 *(*GetDeviceBuf) (_THIS);
     int (*CaptureFromDevice) (_THIS, void *buffer, int buflen);
     void (*FlushCapture) (_THIS);
-    void (*PrepareToClose) (_THIS);  /**< Called between run and draining wait for playback devices */
     void (*CloseDevice) (_THIS);
     void (*LockDevice) (_THIS);
     void (*UnlockDevice) (_THIS);
@@ -84,13 +82,11 @@ typedef struct SDL_AudioDriverImpl
     /* !!! FIXME: add pause(), so we can optimize instead of mixing silence. */
 
     /* Some flags to push duplicate code into the core and reduce #ifdefs. */
-    /* !!! FIXME: these should be SDL_bool */
-    int ProvidesOwnCallbackThread;
-    int SkipMixerLock;
-    int HasCaptureSupport;
-    int OnlyHasDefaultOutputDevice;
-    int OnlyHasDefaultCaptureDevice;
-    int AllowsArbitraryDeviceNames;
+    SDL_bool ProvidesOwnCallbackThread;
+    SDL_bool HasCaptureSupport;
+    SDL_bool OnlyHasDefaultOutputDevice;
+    SDL_bool OnlyHasDefaultCaptureDevice;
+    SDL_bool AllowsArbitraryDeviceNames;
 } SDL_AudioDriverImpl;
 
 
@@ -99,6 +95,7 @@ typedef struct SDL_AudioDeviceItem
     void *handle;
     char *name;
     char *original_name;
+    SDL_AudioSpec spec;
     int dupenum;
     struct SDL_AudioDeviceItem *next;
 } SDL_AudioDeviceItem;
@@ -177,11 +174,12 @@ typedef struct AudioBootStrap
 {
     const char *name;
     const char *desc;
-    int (*init) (SDL_AudioDriverImpl * impl);
-    int demand_only;  /* 1==request explicitly, or it won't be available. */
+    SDL_bool (*init) (SDL_AudioDriverImpl * impl);
+    SDL_bool demand_only;  /* 1==request explicitly, or it won't be available. */
 } AudioBootStrap;
 
 /* Not all of these are available in a given build. Use #ifdefs, etc. */
+extern AudioBootStrap PIPEWIRE_bootstrap;
 extern AudioBootStrap PULSEAUDIO_bootstrap;
 extern AudioBootStrap ALSA_bootstrap;
 extern AudioBootStrap JACK_bootstrap;
@@ -203,9 +201,11 @@ extern AudioBootStrap COREAUDIO_bootstrap;
 extern AudioBootStrap DISKAUDIO_bootstrap;
 extern AudioBootStrap DUMMYAUDIO_bootstrap;
 extern AudioBootStrap FUSIONSOUND_bootstrap;
+extern AudioBootStrap aaudio_bootstrap;
 extern AudioBootStrap openslES_bootstrap;
 extern AudioBootStrap ANDROIDAUDIO_bootstrap;
 extern AudioBootStrap PSPAUDIO_bootstrap;
+extern AudioBootStrap VITAAUD_bootstrap;
 extern AudioBootStrap EMSCRIPTENAUDIO_bootstrap;
 extern AudioBootStrap OS2AUDIO_bootstrap;
 
diff --git a/Engine/lib/sdl/src/audio/SDL_wave.c b/Engine/lib/sdl/src/audio/SDL_wave.c
index a7d644a6e..07eb10147 100644
--- a/Engine/lib/sdl/src/audio/SDL_wave.c
+++ b/Engine/lib/sdl/src/audio/SDL_wave.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -313,7 +313,7 @@ WaveDebugDumpFormat(WaveFile *file, Uint32 rifflen, Uint32 fmtlen, Uint32 datale
 
     SDL_LogDebug(SDL_LOG_CATEGORY_AUDIO, "%s", dumpstr);
 
-    free(dumpstr);
+    SDL_free(dumpstr);
 }
 #endif
 
@@ -1715,7 +1715,7 @@ WaveCheckFormat(WaveFile *file, size_t datalength)
         if (file->facthint == FactStrict && file->fact.status <= 0) {
             return SDL_SetError("Missing fact chunk in WAVE file");
         }
-        /* fallthrough */
+        SDL_FALLTHROUGH;
     case PCM_CODE:
         /* All supported formats require a non-zero bit depth. */
         if (file->chunk.size < 16) {
@@ -1854,7 +1854,7 @@ WaveLoad(SDL_RWops *src, WaveFile *file, SDL_AudioSpec *spec, Uint8 **audio_buf,
             RIFFend = RIFFchunk.position + SDL_MAX_UINT32;
             break;
         }
-        /* fallthrough */
+        SDL_FALLTHROUGH;
     case RiffSizeForce:
         RIFFend = RIFFchunk.position + RIFFchunk.length;
         RIFFlengthknown = SDL_TRUE;
@@ -1871,7 +1871,7 @@ WaveLoad(SDL_RWops *src, WaveFile *file, SDL_AudioSpec *spec, Uint8 **audio_buf,
     while ((Uint64)RIFFend > (Uint64)chunk->position + chunk->length + (chunk->length & 1)) {
         /* Abort after too many chunks or else corrupt files may waste time. */
         if (chunkcount++ >= chunkcountlimit) {
-            return SDL_SetError("Chunk count in WAVE file exceeds limit of %u", chunkcountlimit);
+            return SDL_SetError("Chunk count in WAVE file exceeds limit of %" SDL_PRIu32, chunkcountlimit);
         }
 
         result = WaveNextChunk(src, chunk);
diff --git a/Engine/lib/sdl/src/audio/SDL_wave.h b/Engine/lib/sdl/src/audio/SDL_wave.h
index 09d945fc2..c96f957de 100644
--- a/Engine/lib/sdl/src/audio/SDL_wave.h
+++ b/Engine/lib/sdl/src/audio/SDL_wave.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -96,7 +96,7 @@ typedef struct WaveChunk
     Uint32 fourcc;   /* FOURCC of the chunk. */
     Uint32 length;   /* Size of the chunk data. */
     Sint64 position; /* Position of the data in the stream. */
-    Uint8 *data;     /* When allocated, this points to the chunk data. length is used for the malloc size. */
+    Uint8 *data;     /* When allocated, this points to the chunk data. length is used for the memory allocation size. */
     size_t size;     /* Number of bytes in data that could be read from the stream. Can be smaller than length. */
 } WaveChunk;
 
diff --git a/Engine/lib/sdl/src/audio/aaudio/SDL_aaudio.c b/Engine/lib/sdl/src/audio/aaudio/SDL_aaudio.c
new file mode 100644
index 000000000..1d1553ba7
--- /dev/null
+++ b/Engine/lib/sdl/src/audio/aaudio/SDL_aaudio.c
@@ -0,0 +1,462 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if SDL_AUDIO_DRIVER_AAUDIO
+
+#include "SDL_audio.h"
+#include "SDL_loadso.h"
+#include "../SDL_audio_c.h"
+#include "../../core/android/SDL_android.h"
+#include "SDL_aaudio.h"
+
+/* Debug */
+#if 0
+#  define LOGI(...) SDL_Log(__VA_ARGS__);
+#else
+#  define LOGI(...)
+#endif
+
+typedef struct AAUDIO_Data
+{
+    AAudioStreamBuilder *builder;
+    void *handle;
+#define SDL_PROC(ret,func,params) ret (*func) params;
+#  include "SDL_aaudiofuncs.h"
+#undef SDL_PROC
+} AAUDIO_Data;
+static AAUDIO_Data ctx;
+
+static SDL_AudioDevice *audioDevice = NULL;
+static SDL_AudioDevice *captureDevice = NULL;
+
+static int aaudio_LoadFunctions(AAUDIO_Data *data)
+{
+#define SDL_PROC(ret,func,params)                                                                   \
+    do {                                                                                            \
+        data->func = SDL_LoadFunction(data->handle, #func);                                         \
+        if (! data->func) {                                                                         \
+            return SDL_SetError("Couldn't load AAUDIO function %s: %s", #func, SDL_GetError());     \
+        }                                                                                           \
+    } while (0);
+#include "SDL_aaudiofuncs.h"
+#undef SDL_PROC
+    return 0;
+}
+
+void aaudio_errorCallback( AAudioStream *stream, void *userData, aaudio_result_t error );
+void aaudio_errorCallback( AAudioStream *stream, void *userData, aaudio_result_t error )
+{
+    LOGI( "SDL aaudio_errorCallback: %d - %s", error, ctx.AAudio_convertResultToText( error ) );
+}
+
+#define LIB_AAUDIO_SO "libaaudio.so"
+
+static int
+aaudio_OpenDevice(_THIS, const char *devname)
+{
+    struct SDL_PrivateAudioData *private;
+    SDL_bool iscapture = this->iscapture;
+    aaudio_result_t res;
+    LOGI(__func__);
+
+    SDL_assert((captureDevice == NULL) || !iscapture);
+    SDL_assert((audioDevice == NULL) || iscapture);
+
+    if (iscapture) {
+        if (!Android_JNI_RequestPermission("android.permission.RECORD_AUDIO")) {
+            LOGI("This app doesn't have RECORD_AUDIO permission");
+            return SDL_SetError("This app doesn't have RECORD_AUDIO permission");
+        }
+    }
+
+    if (iscapture) {
+        captureDevice = this;
+    } else {
+        audioDevice = this;
+    }
+
+    this->hidden = (struct SDL_PrivateAudioData *) SDL_calloc(1, (sizeof *this->hidden));
+    if (this->hidden == NULL) {
+        return SDL_OutOfMemory();
+    }
+    private = this->hidden;
+
+    ctx.AAudioStreamBuilder_setSampleRate(ctx.builder, this->spec.freq);
+    ctx.AAudioStreamBuilder_setChannelCount(ctx.builder, this->spec.channels);
+    {
+        aaudio_direction_t direction = (iscapture ? AAUDIO_DIRECTION_INPUT : AAUDIO_DIRECTION_OUTPUT);
+        ctx.AAudioStreamBuilder_setDirection(ctx.builder, direction);
+    }
+    {
+        aaudio_format_t format = AAUDIO_FORMAT_PCM_FLOAT;
+        if (this->spec.format == AUDIO_S16SYS) {
+            format = AAUDIO_FORMAT_PCM_I16;
+        } else if (this->spec.format == AUDIO_S16SYS) {
+            format = AAUDIO_FORMAT_PCM_FLOAT;
+        }
+        ctx.AAudioStreamBuilder_setFormat(ctx.builder, format);
+    }
+
+    ctx.AAudioStreamBuilder_setErrorCallback( ctx.builder, aaudio_errorCallback, private );
+
+    LOGI("AAudio Try to open %u hz %u bit chan %u %s samples %u",
+          this->spec.freq, SDL_AUDIO_BITSIZE(this->spec.format),
+          this->spec.channels, (this->spec.format & 0x1000) ? "BE" : "LE", this->spec.samples);
+
+    res = ctx.AAudioStreamBuilder_openStream(ctx.builder, &private->stream);
+    if (res != AAUDIO_OK) {
+        LOGI("SDL Failed AAudioStreamBuilder_openStream %d", res);
+        return SDL_SetError("%s : %s", __func__, ctx.AAudio_convertResultToText(res));
+    }
+
+    this->spec.freq = ctx.AAudioStream_getSampleRate(private->stream);
+    this->spec.channels = ctx.AAudioStream_getChannelCount(private->stream);
+    {
+        aaudio_format_t fmt = ctx.AAudioStream_getFormat(private->stream);
+        if (fmt == AAUDIO_FORMAT_PCM_I16) {
+            this->spec.format = AUDIO_S16SYS;
+        } else if (fmt == AAUDIO_FORMAT_PCM_FLOAT) {
+            this->spec.format = AUDIO_F32SYS;
+        }
+    }
+
+    LOGI("AAudio Try to open %u hz %u bit chan %u %s samples %u",
+          this->spec.freq, SDL_AUDIO_BITSIZE(this->spec.format),
+          this->spec.channels, (this->spec.format & 0x1000) ? "BE" : "LE", this->spec.samples);
+
+    SDL_CalculateAudioSpec(&this->spec);
+
+    /* Allocate mixing buffer */
+    if (!iscapture) {
+        private->mixlen = this->spec.size;
+        private->mixbuf = (Uint8 *) SDL_malloc(private->mixlen);
+        if (private->mixbuf == NULL) {
+            return SDL_OutOfMemory();
+        }
+        SDL_memset(private->mixbuf, this->spec.silence, this->spec.size);
+    }
+
+    private->frame_size = this->spec.channels * (SDL_AUDIO_BITSIZE(this->spec.format) / 8);
+
+    res = ctx.AAudioStream_requestStart(private->stream);
+    if (res != AAUDIO_OK) {
+        LOGI("SDL Failed AAudioStream_requestStart %d iscapture:%d", res, iscapture);
+        return SDL_SetError("%s : %s", __func__, ctx.AAudio_convertResultToText(res));
+    }
+
+    LOGI("SDL AAudioStream_requestStart OK");
+    return 0;
+}
+
+static void
+aaudio_CloseDevice(_THIS)
+{
+    struct SDL_PrivateAudioData *private = this->hidden;
+    aaudio_result_t res;
+    LOGI(__func__);
+
+    if (private->stream) {
+        res = ctx.AAudioStream_requestStop(private->stream);
+        if (res != AAUDIO_OK) {
+            LOGI("SDL Failed AAudioStream_requestStop %d", res);
+            SDL_SetError("%s : %s", __func__, ctx.AAudio_convertResultToText(res));
+            return;
+        }
+
+        res = ctx.AAudioStream_close(private->stream);
+        if (res != AAUDIO_OK) {
+            LOGI("SDL Failed AAudioStreamBuilder_delete %d", res);
+            SDL_SetError("%s : %s", __func__, ctx.AAudio_convertResultToText(res));
+            return;
+        }
+    }
+
+    if (this->iscapture) {
+        SDL_assert(captureDevice == this);
+        captureDevice = NULL;
+    } else {
+        SDL_assert(audioDevice == this);
+        audioDevice = NULL;
+    }
+
+    SDL_free(this->hidden->mixbuf);
+    SDL_free(this->hidden);
+}
+
+static Uint8 *
+aaudio_GetDeviceBuf(_THIS)
+{
+    struct SDL_PrivateAudioData *private = this->hidden;
+    return private->mixbuf;
+}
+
+static void
+aaudio_PlayDevice(_THIS)
+{
+    struct SDL_PrivateAudioData *private = this->hidden;
+    aaudio_result_t res;
+    int64_t timeoutNanoseconds = 1 * 1000 * 1000; /* 8 ms */
+    res = ctx.AAudioStream_write(private->stream,  private->mixbuf, private->mixlen / private->frame_size, timeoutNanoseconds);
+    if (res < 0) {
+        LOGI("%s : %s", __func__, ctx.AAudio_convertResultToText(res));
+    } else {
+        LOGI("SDL AAudio play: %d frames, wanted:%d frames", (int)res, private->mixlen / private->frame_size);
+    }
+
+#if 0
+    /* Log under-run count */
+    {
+        static int prev = 0;
+        int32_t cnt = ctx.AAudioStream_getXRunCount(private->stream);
+        if (cnt != prev) {
+            SDL_Log("AAudio underrun: %d - total: %d", cnt - prev, cnt);
+            prev = cnt;
+        }
+    }
+#endif
+}
+
+static int
+aaudio_CaptureFromDevice(_THIS, void *buffer, int buflen)
+{
+    struct SDL_PrivateAudioData *private = this->hidden;
+    aaudio_result_t res;
+    int64_t timeoutNanoseconds = 8 * 1000 * 1000; /* 8 ms */
+    res = ctx.AAudioStream_read(private->stream,  buffer, buflen / private->frame_size, timeoutNanoseconds);
+    if (res < 0) {
+        LOGI("%s : %s", __func__, ctx.AAudio_convertResultToText(res));
+        return -1;
+    }
+    LOGI("SDL AAudio capture:%d frames, wanted:%d frames", (int)res, buflen / private->frame_size);
+    return res * private->frame_size;
+}
+
+static void
+aaudio_Deinitialize(void)
+{
+    LOGI(__func__);
+    if (ctx.handle) {
+        if (ctx.builder) {
+            aaudio_result_t res;
+            res = ctx.AAudioStreamBuilder_delete(ctx.builder);
+            if (res != AAUDIO_OK) {
+                SDL_SetError("Failed AAudioStreamBuilder_delete %s", ctx.AAudio_convertResultToText(res));
+            }
+        }
+        SDL_UnloadObject(ctx.handle);
+    }
+    ctx.handle = NULL;
+    ctx.builder = NULL;
+    LOGI("End AAUDIO %s", SDL_GetError());
+}
+
+static SDL_bool
+aaudio_Init(SDL_AudioDriverImpl *impl)
+{
+    aaudio_result_t res;
+    LOGI(__func__);
+
+    /* AAudio was introduced in Android 8.0, but has reference counting crash issues in that release,
+     * so don't use it until 8.1.
+     *
+     * See https://github.com/google/oboe/issues/40 for more information.
+     */
+    if (SDL_GetAndroidSDKVersion() < 27) {
+        return SDL_FALSE;
+    }
+
+    SDL_zero(ctx);
+
+    ctx.handle = SDL_LoadObject(LIB_AAUDIO_SO);
+    if (ctx.handle == NULL) {
+        LOGI("SDL couldn't find " LIB_AAUDIO_SO);
+        goto failure;
+    }
+
+    if (aaudio_LoadFunctions(&ctx) < 0) {
+        goto failure;
+    }
+
+    res = ctx.AAudio_createStreamBuilder(&ctx.builder);
+    if (res != AAUDIO_OK) {
+        LOGI("SDL Failed AAudio_createStreamBuilder %d", res);
+        goto failure;
+    }
+
+    if (ctx.builder == NULL) {
+        LOGI("SDL Failed AAudio_createStreamBuilder - builder NULL");
+        goto failure;
+    }
+
+    impl->Deinitialize = aaudio_Deinitialize;
+    impl->OpenDevice = aaudio_OpenDevice;
+    impl->CloseDevice = aaudio_CloseDevice;
+    impl->PlayDevice = aaudio_PlayDevice;
+    impl->GetDeviceBuf = aaudio_GetDeviceBuf;
+    impl->CaptureFromDevice = aaudio_CaptureFromDevice;
+
+    /* and the capabilities */
+    impl->HasCaptureSupport = SDL_TRUE;
+    impl->OnlyHasDefaultOutputDevice = SDL_TRUE;
+    impl->OnlyHasDefaultCaptureDevice = SDL_TRUE;
+
+    /* this audio target is available. */
+    LOGI("SDL aaudio_Init OK");
+    return SDL_TRUE;
+
+failure:
+    if (ctx.handle) {
+        if (ctx.builder) {
+            ctx.AAudioStreamBuilder_delete(ctx.builder);
+        }
+        SDL_UnloadObject(ctx.handle);
+    }
+    ctx.handle = NULL;
+    ctx.builder = NULL;
+    return SDL_FALSE;
+}
+
+AudioBootStrap aaudio_bootstrap = {
+    "AAudio", "AAudio audio driver", aaudio_Init, SDL_FALSE
+};
+
+/* Pause (block) all non already paused audio devices by taking their mixer lock */
+void aaudio_PauseDevices(void)
+{
+    /* TODO: Handle multiple devices? */
+    struct SDL_PrivateAudioData *private;
+    if (audioDevice != NULL && audioDevice->hidden != NULL) {
+        private = (struct SDL_PrivateAudioData *) audioDevice->hidden;
+
+        if (private->stream) {
+            aaudio_result_t res = ctx.AAudioStream_requestPause(private->stream);
+            if (res != AAUDIO_OK) {
+                LOGI("SDL Failed AAudioStream_requestPause %d", res);
+                SDL_SetError("%s : %s", __func__, ctx.AAudio_convertResultToText(res));
+            }
+        }
+
+        if (SDL_AtomicGet(&audioDevice->paused)) {
+            /* The device is already paused, leave it alone */
+            private->resume = SDL_FALSE;
+        } else {
+            SDL_LockMutex(audioDevice->mixer_lock);
+            SDL_AtomicSet(&audioDevice->paused, 1);
+            private->resume = SDL_TRUE;
+        }
+    }
+
+    if (captureDevice != NULL && captureDevice->hidden != NULL) {
+        private = (struct SDL_PrivateAudioData *) captureDevice->hidden;
+
+        if (private->stream) {
+            /* Pause() isn't implemented for 'capture', use Stop() */
+            aaudio_result_t res = ctx.AAudioStream_requestStop(private->stream);
+            if (res != AAUDIO_OK) {
+                LOGI("SDL Failed AAudioStream_requestStop %d", res);
+                SDL_SetError("%s : %s", __func__, ctx.AAudio_convertResultToText(res));
+            }
+        }
+
+        if (SDL_AtomicGet(&captureDevice->paused)) {
+            /* The device is already paused, leave it alone */
+            private->resume = SDL_FALSE;
+        } else {
+            SDL_LockMutex(captureDevice->mixer_lock);
+            SDL_AtomicSet(&captureDevice->paused, 1);
+            private->resume = SDL_TRUE;
+        }
+    }
+}
+
+/* Resume (unblock) all non already paused audio devices by releasing their mixer lock */
+void aaudio_ResumeDevices(void)
+{
+    /* TODO: Handle multiple devices? */
+    struct SDL_PrivateAudioData *private;
+    if (audioDevice != NULL && audioDevice->hidden != NULL) {
+        private = (struct SDL_PrivateAudioData *) audioDevice->hidden;
+
+        if (private->resume) {
+            SDL_AtomicSet(&audioDevice->paused, 0);
+            private->resume = SDL_FALSE;
+            SDL_UnlockMutex(audioDevice->mixer_lock);
+        }
+
+        if (private->stream) {
+            aaudio_result_t res = ctx.AAudioStream_requestStart(private->stream);
+            if (res != AAUDIO_OK) {
+                LOGI("SDL Failed AAudioStream_requestStart %d", res);
+                SDL_SetError("%s : %s", __func__, ctx.AAudio_convertResultToText(res));
+            }
+        }
+    }
+
+    if (captureDevice != NULL && captureDevice->hidden != NULL) {
+        private = (struct SDL_PrivateAudioData *) captureDevice->hidden;
+
+        if (private->resume) {
+            SDL_AtomicSet(&captureDevice->paused, 0);
+            private->resume = SDL_FALSE;
+            SDL_UnlockMutex(captureDevice->mixer_lock);
+        }
+
+        if (private->stream) {
+            aaudio_result_t res = ctx.AAudioStream_requestStart(private->stream);
+            if (res != AAUDIO_OK) {
+                LOGI("SDL Failed AAudioStream_requestStart %d", res);
+                SDL_SetError("%s : %s", __func__, ctx.AAudio_convertResultToText(res));
+            }
+        }
+    }
+}
+
+/*
+ We can sometimes get into a state where AAudioStream_write() will just block forever until we pause and unpause.
+ None of the standard state queries indicate any problem in my testing. And the error callback doesn't actually get called.
+ But, AAudioStream_getTimestamp() does return AAUDIO_ERROR_INVALID_STATE
+*/
+SDL_bool aaudio_DetectBrokenPlayState( void )
+{
+    if ( !audioDevice || !audioDevice->hidden ) {
+        return SDL_FALSE;
+    }
+
+    struct SDL_PrivateAudioData *private = audioDevice->hidden;
+
+    int64_t framePosition, timeNanoseconds;
+    aaudio_result_t res = ctx.AAudioStream_getTimestamp( private->stream, CLOCK_MONOTONIC, &framePosition, &timeNanoseconds );
+    if ( res == AAUDIO_ERROR_INVALID_STATE ) {
+        aaudio_stream_state_t currentState = ctx.AAudioStream_getState( private->stream );
+        /* AAudioStream_getTimestamp() will also return AAUDIO_ERROR_INVALID_STATE while the stream is still initially starting. But we only care if it silently went invalid while playing. */
+        if ( currentState == AAUDIO_STREAM_STATE_STARTED ) {
+            LOGI( "SDL aaudio_DetectBrokenPlayState: detected invalid audio device state: AAudioStream_getTimestamp result=%d, framePosition=%lld, timeNanoseconds=%lld, getState=%d", (int)res, (long long)framePosition, (long long)timeNanoseconds, (int)currentState );
+            return SDL_TRUE;
+        }
+    }
+
+    return SDL_FALSE;
+}
+
+#endif /* SDL_AUDIO_DRIVER_AAUDIO */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/audio/aaudio/SDL_aaudio.h b/Engine/lib/sdl/src/audio/aaudio/SDL_aaudio.h
new file mode 100644
index 000000000..babb68392
--- /dev/null
+++ b/Engine/lib/sdl/src/audio/aaudio/SDL_aaudio.h
@@ -0,0 +1,53 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#ifndef _SDL_aaudio_h
+#define _SDL_aaudio_h
+
+#include "../SDL_sysaudio.h"
+#include <stdbool.h>
+#include <aaudio/AAudio.h>
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS   SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData
+{
+    AAudioStream *stream;
+
+    /* Raw mixing buffer */
+    Uint8 *mixbuf;
+    int mixlen;
+    int frame_size;
+
+    /* Resume device if it was paused automatically */
+    int resume;
+};
+ 
+void aaudio_ResumeDevices(void);
+void aaudio_PauseDevices(void);
+SDL_bool aaudio_DetectBrokenPlayState(void);
+
+
+#endif /* _SDL_aaudio_h */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/audio/aaudio/SDL_aaudiofuncs.h b/Engine/lib/sdl/src/audio/aaudio/SDL_aaudiofuncs.h
new file mode 100644
index 000000000..54ef65bbc
--- /dev/null
+++ b/Engine/lib/sdl/src/audio/aaudio/SDL_aaudiofuncs.h
@@ -0,0 +1,80 @@
+/*
+  Simple DirectMedia Layer
+  Copyright , (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#define SDL_PROC_UNUSED(ret,func,params)
+
+SDL_PROC(const char *, AAudio_convertResultToText, (aaudio_result_t returnCode))
+SDL_PROC(const char *, AAudio_convertStreamStateToText, (aaudio_stream_state_t state))
+SDL_PROC(aaudio_result_t, AAudio_createStreamBuilder, (AAudioStreamBuilder** builder))
+SDL_PROC_UNUSED(void, AAudioStreamBuilder_setDeviceId, (AAudioStreamBuilder* builder, int32_t deviceId))
+SDL_PROC(void, AAudioStreamBuilder_setSampleRate, (AAudioStreamBuilder* builder, int32_t sampleRate))
+SDL_PROC(void, AAudioStreamBuilder_setChannelCount, (AAudioStreamBuilder* builder, int32_t channelCount))
+SDL_PROC_UNUSED(void, AAudioStreamBuilder_setSamplesPerFrame, (AAudioStreamBuilder* builder, int32_t samplesPerFrame))
+SDL_PROC(void, AAudioStreamBuilder_setFormat, (AAudioStreamBuilder* builder, aaudio_format_t format))
+SDL_PROC_UNUSED(void, AAudioStreamBuilder_setSharingMode, (AAudioStreamBuilder* builder, aaudio_sharing_mode_t sharingMode))
+SDL_PROC(void, AAudioStreamBuilder_setDirection, (AAudioStreamBuilder* builder, aaudio_direction_t direction))
+SDL_PROC_UNUSED(void, AAudioStreamBuilder_setBufferCapacityInFrames, (AAudioStreamBuilder* builder, int32_t numFrames))
+SDL_PROC_UNUSED(void, AAudioStreamBuilder_setPerformanceMode, (AAudioStreamBuilder* builder, aaudio_performance_mode_t mode))
+SDL_PROC_UNUSED(void, AAudioStreamBuilder_setUsage, (AAudioStreamBuilder* builder, aaudio_usage_t usage)) /* API 28 */
+SDL_PROC_UNUSED(void, AAudioStreamBuilder_setContentType, (AAudioStreamBuilder* builder, aaudio_content_type_t contentType)) /* API 28 */
+SDL_PROC_UNUSED(void, AAudioStreamBuilder_setInputPreset, (AAudioStreamBuilder* builder, aaudio_input_preset_t inputPreset)) /* API 28 */
+SDL_PROC_UNUSED(void, AAudioStreamBuilder_setAllowedCapturePolicy, (AAudioStreamBuilder* builder, aaudio_allowed_capture_policy_t capturePolicy)) /* API 29 */
+SDL_PROC_UNUSED(void, AAudioStreamBuilder_setSessionId, (AAudioStreamBuilder* builder, aaudio_session_id_t sessionId)) /* API 28 */
+SDL_PROC_UNUSED(void, AAudioStreamBuilder_setPrivacySensitive, (AAudioStreamBuilder* builder, bool privacySensitive)) /* API 30 */
+SDL_PROC_UNUSED(void, AAudioStreamBuilder_setDataCallback, (AAudioStreamBuilder* builder, AAudioStream_dataCallback callback, void *userData))
+SDL_PROC_UNUSED(void, AAudioStreamBuilder_setFramesPerDataCallback, (AAudioStreamBuilder* builder, int32_t numFrames))
+SDL_PROC(void, AAudioStreamBuilder_setErrorCallback, (AAudioStreamBuilder* builder, AAudioStream_errorCallback callback, void *userData))
+SDL_PROC(aaudio_result_t , AAudioStreamBuilder_openStream, (AAudioStreamBuilder* builder, AAudioStream** stream))
+SDL_PROC(aaudio_result_t , AAudioStreamBuilder_delete, (AAudioStreamBuilder* builder))
+SDL_PROC_UNUSED(aaudio_result_t , AAudioStream_release, (AAudioStream* stream)) /* API 30 */
+SDL_PROC(aaudio_result_t , AAudioStream_close, (AAudioStream* stream))
+SDL_PROC(aaudio_result_t , AAudioStream_requestStart, (AAudioStream* stream))
+SDL_PROC(aaudio_result_t , AAudioStream_requestPause, (AAudioStream* stream))
+SDL_PROC_UNUSED(aaudio_result_t , AAudioStream_requestFlush, (AAudioStream* stream))
+SDL_PROC(aaudio_result_t , AAudioStream_requestStop, (AAudioStream* stream))
+SDL_PROC(aaudio_stream_state_t, AAudioStream_getState, (AAudioStream* stream))
+SDL_PROC_UNUSED(aaudio_result_t, AAudioStream_waitForStateChange, (AAudioStream* stream, aaudio_stream_state_t inputState, aaudio_stream_state_t *nextState, int64_t timeoutNanoseconds))
+SDL_PROC(aaudio_result_t, AAudioStream_read, (AAudioStream* stream, void *buffer, int32_t numFrames, int64_t timeoutNanoseconds))
+SDL_PROC(aaudio_result_t, AAudioStream_write, (AAudioStream* stream, const void *buffer, int32_t numFrames, int64_t timeoutNanoseconds))
+SDL_PROC_UNUSED(aaudio_result_t, AAudioStream_setBufferSizeInFrames, (AAudioStream* stream, int32_t numFrames))
+SDL_PROC_UNUSED(int32_t, AAudioStream_getBufferSizeInFrames, (AAudioStream* stream))
+SDL_PROC_UNUSED(int32_t, AAudioStream_getFramesPerBurst, (AAudioStream* stream))
+SDL_PROC_UNUSED(int32_t, AAudioStream_getBufferCapacityInFrames, (AAudioStream* stream))
+SDL_PROC_UNUSED(int32_t, AAudioStream_getFramesPerDataCallback, (AAudioStream* stream))
+SDL_PROC(int32_t, AAudioStream_getXRunCount, (AAudioStream* stream))
+SDL_PROC(int32_t, AAudioStream_getSampleRate, (AAudioStream* stream))
+SDL_PROC(int32_t, AAudioStream_getChannelCount, (AAudioStream* stream))
+SDL_PROC_UNUSED(int32_t, AAudioStream_getSamplesPerFrame, (AAudioStream* stream))
+SDL_PROC_UNUSED(int32_t, AAudioStream_getDeviceId, (AAudioStream* stream))
+SDL_PROC(aaudio_format_t, AAudioStream_getFormat, (AAudioStream* stream))
+SDL_PROC_UNUSED(aaudio_sharing_mode_t, AAudioStream_getSharingMode, (AAudioStream* stream))
+SDL_PROC_UNUSED(aaudio_performance_mode_t, AAudioStream_getPerformanceMode, (AAudioStream* stream))
+SDL_PROC_UNUSED(aaudio_direction_t, AAudioStream_getDirection, (AAudioStream* stream))
+SDL_PROC_UNUSED(int64_t, AAudioStream_getFramesWritten, (AAudioStream* stream))
+SDL_PROC_UNUSED(int64_t, AAudioStream_getFramesRead, (AAudioStream* stream))
+SDL_PROC_UNUSED(aaudio_session_id_t, AAudioStream_getSessionId, (AAudioStream* stream)) /* API 28 */
+SDL_PROC(aaudio_result_t, AAudioStream_getTimestamp, (AAudioStream* stream, clockid_t clockid, int64_t *framePosition, int64_t *timeNanoseconds))
+SDL_PROC_UNUSED(aaudio_usage_t, AAudioStream_getUsage, (AAudioStream* stream)) /* API 28 */
+SDL_PROC_UNUSED(aaudio_content_type_t, AAudioStream_getContentType, (AAudioStream* stream)) /* API 28 */
+SDL_PROC_UNUSED(aaudio_input_preset_t, AAudioStream_getInputPreset, (AAudioStream* stream)) /* API 28 */
+SDL_PROC_UNUSED(aaudio_allowed_capture_policy_t, AAudioStream_getAllowedCapturePolicy, ( AAudioStream* stream)) /* API 29 */
+SDL_PROC_UNUSED(bool, AAudioStream_isPrivacySensitive, (AAudioStream* stream)) /* API 30 */
+
diff --git a/Engine/lib/sdl/src/audio/alsa/SDL_alsa_audio.c b/Engine/lib/sdl/src/audio/alsa/SDL_alsa_audio.c
index 6c0c32fcf..3f990a2a0 100644
--- a/Engine/lib/sdl/src/audio/alsa/SDL_alsa_audio.c
+++ b/Engine/lib/sdl/src/audio/alsa/SDL_alsa_audio.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -26,6 +26,11 @@
 #define SDL_ALSA_NON_BLOCKING 0
 #endif
 
+/* without the thread, you will detect devices on startup, but will not get futher hotplug events. But that might be okay. */
+#ifndef SDL_ALSA_HOTPLUG_THREAD
+#define SDL_ALSA_HOTPLUG_THREAD 1
+#endif
+
 /* Allow access to a raw mixing buffer */
 
 #include <sys/types.h>
@@ -274,44 +279,61 @@ ALSA_WaitDevice(_THIS)
 
 /* !!! FIXME: is there a channel swizzler in alsalib instead? */
 /*
- * http://bugzilla.libsdl.org/show_bug.cgi?id=110
+ * https://bugzilla.libsdl.org/show_bug.cgi?id=110
  * "For Linux ALSA, this is FL-FR-RL-RR-C-LFE
  *  and for Windows DirectX [and CoreAudio], this is FL-FR-C-LFE-RL-RR"
  */
-#define SWIZ6(T, buf, numframes) \
-    T *ptr = (T *) buf; \
+#define SWIZ6(T) \
+static void swizzle_alsa_channels_6_##T(void *buffer, const Uint32 bufferlen) { \
+    T *ptr = (T *) buffer; \
     Uint32 i; \
-    for (i = 0; i < numframes; i++, ptr += 6) { \
+    for (i = 0; i < bufferlen; i++, ptr += 6) { \
         T tmp; \
         tmp = ptr[2]; ptr[2] = ptr[4]; ptr[4] = tmp; \
         tmp = ptr[3]; ptr[3] = ptr[5]; ptr[5] = tmp; \
-    }
-
-static void
-swizzle_alsa_channels_6_64bit(void *buffer, Uint32 bufferlen)
-{
-    SWIZ6(Uint64, buffer, bufferlen);
+    } \
 }
 
-static void
-swizzle_alsa_channels_6_32bit(void *buffer, Uint32 bufferlen)
-{
-    SWIZ6(Uint32, buffer, bufferlen);
+
+/* !!! FIXME: is there a channel swizzler in alsalib instead? */
+/* !!! FIXME: this screams for a SIMD shuffle operation. */
+/*
+ * https://docs.microsoft.com/en-us/windows-hardware/drivers/audio/mapping-stream-formats-to-speaker-configurations
+ * For Linux ALSA, this appears to be FL-FR-RL-RR-C-LFE-SL-SR
+ *  and for Windows DirectX [and CoreAudio], this is FL-FR-C-LFE-SL-SR-RL-RR"
+ */
+#define SWIZ8(T) \
+static void swizzle_alsa_channels_8_##T(void *buffer, const Uint32 bufferlen) { \
+    T *ptr = (T *) buffer; \
+    Uint32 i; \
+    for (i = 0; i < bufferlen; i++, ptr += 6) { \
+        const T center = ptr[2]; \
+        const T subwoofer = ptr[3]; \
+        const T side_left = ptr[4]; \
+        const T side_right = ptr[5]; \
+        const T rear_left = ptr[6]; \
+        const T rear_right = ptr[7]; \
+        ptr[2] = rear_left; \
+        ptr[3] = rear_right; \
+        ptr[4] = center; \
+        ptr[5] = subwoofer; \
+        ptr[6] = side_left; \
+        ptr[7] = side_right; \
+    } \
 }
 
-static void
-swizzle_alsa_channels_6_16bit(void *buffer, Uint32 bufferlen)
-{
-    SWIZ6(Uint16, buffer, bufferlen);
-}
+#define CHANNEL_SWIZZLE(x) \
+    x(Uint64) \
+    x(Uint32) \
+    x(Uint16) \
+    x(Uint8)
 
-static void
-swizzle_alsa_channels_6_8bit(void *buffer, Uint32 bufferlen)
-{
-    SWIZ6(Uint8, buffer, bufferlen);
-}
+CHANNEL_SWIZZLE(SWIZ6)
+CHANNEL_SWIZZLE(SWIZ8)
 
+#undef CHANNEL_SWIZZLE
 #undef SWIZ6
+#undef SWIZ8
 
 
 /*
@@ -321,17 +343,23 @@ swizzle_alsa_channels_6_8bit(void *buffer, Uint32 bufferlen)
 static void
 swizzle_alsa_channels(_THIS, void *buffer, Uint32 bufferlen)
 {
-    if (this->spec.channels == 6) {
-        switch (SDL_AUDIO_BITSIZE(this->spec.format)) {
-            case 8: swizzle_alsa_channels_6_8bit(buffer, bufferlen); break;
-            case 16: swizzle_alsa_channels_6_16bit(buffer, bufferlen); break;
-            case 32: swizzle_alsa_channels_6_32bit(buffer, bufferlen); break;
-            case 64: swizzle_alsa_channels_6_64bit(buffer, bufferlen); break;
-            default: SDL_assert(!"unhandled bitsize"); break;
-        }
-    }
+    switch (this->spec.channels) {
+        #define CHANSWIZ(chans) \
+        case chans: \
+            switch ((this->spec.format & (0xFF))) { \
+                case 8: swizzle_alsa_channels_##chans##_Uint8(buffer, bufferlen); break; \
+                case 16: swizzle_alsa_channels_##chans##_Uint16(buffer, bufferlen); break; \
+                case 32: swizzle_alsa_channels_##chans##_Uint32(buffer, bufferlen); break; \
+                case 64: swizzle_alsa_channels_##chans##_Uint64(buffer, bufferlen); break; \
+                default: SDL_assert(!"unhandled bitsize"); break; \
+            } \
+            return;
 
-    /* !!! FIXME: update this for 7.1 if needed, later. */
+        CHANSWIZ(6);
+        CHANSWIZ(8);
+        #undef CHANSWIZ
+        default: break;
+    }
 }
 
 #ifdef SND_CHMAP_API_VERSION
@@ -515,9 +543,10 @@ ALSA_set_buffer_size(_THIS, snd_pcm_hw_params_t *params)
 }
 
 static int
-ALSA_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
+ALSA_OpenDevice(_THIS, const char *devname)
 {
     int status = 0;
+    SDL_bool iscapture = this->iscapture;
     snd_pcm_t *pcm_handle = NULL;
     snd_pcm_hw_params_t *hwparams = NULL;
     snd_pcm_sw_params_t *swparams = NULL;
@@ -541,7 +570,7 @@ ALSA_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
     /* Open the audio device */
     /* Name of device should depend on # channels in spec */
     status = ALSA_snd_pcm_open(&pcm_handle,
-                get_audio_device(handle, this->spec.channels),
+                get_audio_device(this->handle, this->spec.channels),
                 iscapture ? SND_PCM_STREAM_CAPTURE : SND_PCM_STREAM_PLAYBACK,
                 SND_PCM_NONBLOCK);
 
@@ -569,10 +598,7 @@ ALSA_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
     }
 
     /* Try for a closest match on audio format */
-    status = -1;
-    for (test_format = SDL_FirstAudioFormat(this->spec.format);
-         test_format && (status < 0);) {
-        status = 0;             /* if we can't support a format, it'll become -1. */
+    for (test_format = SDL_FirstAudioFormat(this->spec.format); test_format; test_format = SDL_NextAudioFormat()) {
         switch (test_format) {
         case AUDIO_U8:
             format = SND_PCM_FORMAT_U8;
@@ -605,19 +631,14 @@ ALSA_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
             format = SND_PCM_FORMAT_FLOAT_BE;
             break;
         default:
-            status = -1;
+            continue;
+        }
+        if (ALSA_snd_pcm_hw_params_set_format(pcm_handle, hwparams, format) >= 0) {
             break;
         }
-        if (status >= 0) {
-            status = ALSA_snd_pcm_hw_params_set_format(pcm_handle,
-                                                       hwparams, format);
-        }
-        if (status < 0) {
-            test_format = SDL_NextAudioFormat();
-        }
     }
-    if (status < 0) {
-        return SDL_SetError("ALSA: Couldn't find any hardware audio formats");
+    if (!test_format) {
+        return SDL_SetError("%s: Unsupported audio format", "alsa");
     }
     this->spec.format = test_format;
 
@@ -628,10 +649,11 @@ ALSA_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
 #ifdef SND_CHMAP_API_VERSION
     chmap = ALSA_snd_pcm_get_chmap(pcm_handle);
     if (chmap) {
-        ALSA_snd_pcm_chmap_print(chmap, sizeof(chmap_str), chmap_str);
-        if (SDL_strcmp("FL FR FC LFE RL RR", chmap_str) == 0 ||
-            SDL_strcmp("FL FR FC LFE SL SR", chmap_str) == 0) {
-            this->hidden->swizzle_func = no_swizzle;
+        if (ALSA_snd_pcm_chmap_print(chmap, sizeof(chmap_str), chmap_str) > 0) {
+            if (SDL_strcmp("FL FR FC LFE RL RR", chmap_str) == 0 ||
+                SDL_strcmp("FL FR FC LFE SL SR", chmap_str) == 0) {
+                this->hidden->swizzle_func = no_swizzle;
+            }
         }
         free(chmap);
     }
@@ -750,7 +772,7 @@ add_device(const int iscapture, const char *name, void *hint, ALSA_Device **pSee
     /* some strings have newlines, like "HDA NVidia, HDMI 0\nHDMI Audio Output".
        just chop the extra lines off, this seems to get a reasonable device
        name without extra details. */
-    if ((ptr = strchr(desc, '\n')) != NULL) {
+    if ((ptr = SDL_strchr(desc, '\n')) != NULL) {
         *ptr = '\0';
     }
 
@@ -765,7 +787,11 @@ add_device(const int iscapture, const char *name, void *hint, ALSA_Device **pSee
         return;
     }
 
-    SDL_AddAudioDevice(iscapture, desc, handle);
+    /* Note that spec is NULL, because we are required to open the device before
+     * acquiring the mix format, making this information inaccessible at
+     * enumeration time
+     */
+    SDL_AddAudioDevice(iscapture, desc, NULL, handle);
     if (hint)
         free(desc);
     dev->name = handle;
@@ -775,200 +801,200 @@ add_device(const int iscapture, const char *name, void *hint, ALSA_Device **pSee
 }
 
 
+static ALSA_Device *hotplug_devices = NULL;
+
+static void
+ALSA_HotplugIteration(void)
+{
+    void **hints = NULL;
+    ALSA_Device *dev;
+    ALSA_Device *unseen;
+    ALSA_Device *seen;
+    ALSA_Device *next;
+    ALSA_Device *prev;
+
+    if (ALSA_snd_device_name_hint(-1, "pcm", &hints) == 0) {
+        int i, j;
+        const char *match = NULL;
+        int bestmatch = 0xFFFF;
+        size_t match_len = 0;
+        int defaultdev = -1;
+        static const char * const prefixes[] = {
+            "hw:", "sysdefault:", "default:", NULL
+        };
+
+        unseen = hotplug_devices;
+        seen = NULL;
+
+        /* Apparently there are several different ways that ALSA lists
+           actual hardware. It could be prefixed with "hw:" or "default:"
+           or "sysdefault:" and maybe others. Go through the list and see
+           if we can find a preferred prefix for the system. */
+        for (i = 0; hints[i]; i++) {
+            char *name = ALSA_snd_device_name_get_hint(hints[i], "NAME");
+            if (!name) {
+                continue;
+            }
+
+            /* full name, not a prefix */
+            if ((defaultdev == -1) && (SDL_strcmp(name, "default") == 0)) {
+                defaultdev = i;
+            }
+
+            for (j = 0; prefixes[j]; j++) {
+                const char *prefix = prefixes[j];
+                const size_t prefixlen = SDL_strlen(prefix);
+                if (SDL_strncmp(name, prefix, prefixlen) == 0) {
+                    if (j < bestmatch) {
+                        bestmatch = j;
+                        match = prefix;
+                        match_len = prefixlen;
+                    }
+                }
+            }
+
+            free(name);
+        }
+
+        /* look through the list of device names to find matches */
+        for (i = 0; hints[i]; i++) {
+            char *name;
+
+            /* if we didn't find a device name prefix we like at all... */
+            if ((!match) && (defaultdev != i)) {
+                continue;  /* ...skip anything that isn't the default device. */
+            }
+
+            name = ALSA_snd_device_name_get_hint(hints[i], "NAME");
+            if (!name) {
+                continue;
+            }
+
+            /* only want physical hardware interfaces */
+            if (!match || (SDL_strncmp(name, match, match_len) == 0)) {
+                char *ioid = ALSA_snd_device_name_get_hint(hints[i], "IOID");
+                const SDL_bool isoutput = (ioid == NULL) || (SDL_strcmp(ioid, "Output") == 0);
+                const SDL_bool isinput = (ioid == NULL) || (SDL_strcmp(ioid, "Input") == 0);
+                SDL_bool have_output = SDL_FALSE;
+                SDL_bool have_input = SDL_FALSE;
+
+                free(ioid);
+
+                if (!isoutput && !isinput) {
+                    free(name);
+                    continue;
+                }
+
+                prev = NULL;
+                for (dev = unseen; dev; dev = next) {
+                    next = dev->next;
+                    if ( (SDL_strcmp(dev->name, name) == 0) && (((isinput) && dev->iscapture) || ((isoutput) && !dev->iscapture)) ) {
+                        if (prev) {
+                            prev->next = next;
+                        } else {
+                            unseen = next;
+                        }
+                        dev->next = seen;
+                        seen = dev;
+                        if (isinput) have_input = SDL_TRUE;
+                        if (isoutput) have_output = SDL_TRUE;
+                    } else {
+                        prev = dev;
+                    }
+                }
+
+                if (isinput && !have_input) {
+                    add_device(SDL_TRUE, name, hints[i], &seen);
+                }
+                if (isoutput && !have_output) {
+                    add_device(SDL_FALSE, name, hints[i], &seen);
+                }
+            }
+
+            free(name);
+        }
+
+        ALSA_snd_device_name_free_hint(hints);
+
+        hotplug_devices = seen;   /* now we have a known-good list of attached devices. */
+
+        /* report anything still in unseen as removed. */
+        for (dev = unseen; dev; dev = next) {
+            /*printf("ALSA: removing usb %s device '%s'\n", dev->iscapture ? "capture" : "output", dev->name);*/
+            next = dev->next;
+            SDL_RemoveAudioDevice(dev->iscapture, dev->name);
+            SDL_free(dev->name);
+            SDL_free(dev);
+        }
+    }
+}
+
+#if SDL_ALSA_HOTPLUG_THREAD
 static SDL_atomic_t ALSA_hotplug_shutdown;
 static SDL_Thread *ALSA_hotplug_thread;
 
 static int SDLCALL
 ALSA_HotplugThread(void *arg)
 {
-    SDL_sem *first_run_semaphore = (SDL_sem *) arg;
-    ALSA_Device *devices = NULL;
-    ALSA_Device *next;
-    ALSA_Device *dev;
-    Uint32 ticks;
-
     SDL_SetThreadPriority(SDL_THREAD_PRIORITY_LOW);
 
     while (!SDL_AtomicGet(&ALSA_hotplug_shutdown)) {
-        void **hints = NULL;
-        ALSA_Device *unseen;
-        ALSA_Device *seen;
-        ALSA_Device *prev;
-
-        if (ALSA_snd_device_name_hint(-1, "pcm", &hints) == 0) {
-            int i, j;
-            const char *match = NULL;
-            int bestmatch = 0xFFFF;
-            size_t match_len = 0;
-            int defaultdev = -1;
-            static const char * const prefixes[] = {
-                "hw:", "sysdefault:", "default:", NULL
-            };
-
-            unseen = devices;
-            seen = NULL;
-            /* Apparently there are several different ways that ALSA lists
-               actual hardware. It could be prefixed with "hw:" or "default:"
-               or "sysdefault:" and maybe others. Go through the list and see
-               if we can find a preferred prefix for the system. */
-            for (i = 0; hints[i]; i++) {
-                char *name = ALSA_snd_device_name_get_hint(hints[i], "NAME");
-                if (!name) {
-                    continue;
-                }
-
-                /* full name, not a prefix */
-                if ((defaultdev == -1) && (SDL_strcmp(name, "default") == 0)) {
-                    defaultdev = i;
-                }
-
-                for (j = 0; prefixes[j]; j++) {
-                    const char *prefix = prefixes[j];
-                    const size_t prefixlen = SDL_strlen(prefix);
-                    if (SDL_strncmp(name, prefix, prefixlen) == 0) {
-                        if (j < bestmatch) {
-                            bestmatch = j;
-                            match = prefix;
-                            match_len = prefixlen;
-                        }
-                    }
-                }
-
-                free(name);
-            }
-
-            /* look through the list of device names to find matches */
-            for (i = 0; hints[i]; i++) {
-                char *name;
-
-                /* if we didn't find a device name prefix we like at all... */
-                if ((!match) && (defaultdev != i)) {
-                    continue;  /* ...skip anything that isn't the default device. */
-                }
-
-                name = ALSA_snd_device_name_get_hint(hints[i], "NAME");
-                if (!name) {
-                    continue;
-                }
-
-                /* only want physical hardware interfaces */
-                if (!match || (SDL_strncmp(name, match, match_len) == 0)) {
-                    char *ioid = ALSA_snd_device_name_get_hint(hints[i], "IOID");
-                    const SDL_bool isoutput = (ioid == NULL) || (SDL_strcmp(ioid, "Output") == 0);
-                    const SDL_bool isinput = (ioid == NULL) || (SDL_strcmp(ioid, "Input") == 0);
-                    SDL_bool have_output = SDL_FALSE;
-                    SDL_bool have_input = SDL_FALSE;
-
-                    free(ioid);
-
-                    if (!isoutput && !isinput) {
-                        free(name);
-                        continue;
-                    }
-
-                    prev = NULL;
-                    for (dev = unseen; dev; dev = next) {
-                        next = dev->next;
-                        if ( (SDL_strcmp(dev->name, name) == 0) && (((isinput) && dev->iscapture) || ((isoutput) && !dev->iscapture)) ) {
-                            if (prev) {
-                                prev->next = next;
-                            } else {
-                                unseen = next;
-                            }
-                            dev->next = seen;
-                            seen = dev;
-                            if (isinput) have_input = SDL_TRUE;
-                            if (isoutput) have_output = SDL_TRUE;
-                        } else {
-                            prev = dev;
-                        }
-                    }
-
-                    if (isinput && !have_input) {
-                        add_device(SDL_TRUE, name, hints[i], &seen);
-                    }
-                    if (isoutput && !have_output) {
-                        add_device(SDL_FALSE, name, hints[i], &seen);
-                    }
-                }
-
-                free(name);
-            }
-
-            ALSA_snd_device_name_free_hint(hints);
-
-            devices = seen;   /* now we have a known-good list of attached devices. */
-
-            /* report anything still in unseen as removed. */
-            for (dev = unseen; dev; dev = next) {
-                /*printf("ALSA: removing usb %s device '%s'\n", dev->iscapture ? "capture" : "output", dev->name);*/
-                next = dev->next;
-                SDL_RemoveAudioDevice(dev->iscapture, dev->name);
-                SDL_free(dev->name);
-                SDL_free(dev);
-            }
-        }
-
-        /* On first run, tell ALSA_DetectDevices() that we have a complete device list so it can return. */
-        if (first_run_semaphore) {
-            SDL_SemPost(first_run_semaphore);
-            first_run_semaphore = NULL;  /* let other thread clean it up. */
-        }
-
         /* Block awhile before checking again, unless we're told to stop. */
-        ticks = SDL_GetTicks() + 5000;
+        const Uint32 ticks = SDL_GetTicks() + 5000;
         while (!SDL_AtomicGet(&ALSA_hotplug_shutdown) && !SDL_TICKS_PASSED(SDL_GetTicks(), ticks)) {
             SDL_Delay(100);
         }
-    }
 
-    /* Shutting down! Clean up any data we've gathered. */
-    for (dev = devices; dev; dev = next) {
-        /*printf("ALSA: at shutdown, removing %s device '%s'\n", dev->iscapture ? "capture" : "output", dev->name);*/
-        next = dev->next;
-        SDL_free(dev->name);
-        SDL_free(dev);
+        ALSA_HotplugIteration();  /* run the check. */
     }
 
     return 0;
 }
+#endif
 
 static void
 ALSA_DetectDevices(void)
 {
-    /* Start the device detection thread here, wait for an initial iteration to complete. */
-    SDL_sem *semaphore = SDL_CreateSemaphore(0);
-    if (!semaphore) {
-        return;  /* oh well. */
-    }
+    ALSA_HotplugIteration();  /* run once now before a thread continues to check. */
 
+#if SDL_ALSA_HOTPLUG_THREAD
     SDL_AtomicSet(&ALSA_hotplug_shutdown, 0);
-
-    ALSA_hotplug_thread = SDL_CreateThread(ALSA_HotplugThread, "SDLHotplugALSA", semaphore);
-    if (ALSA_hotplug_thread) {
-        SDL_SemWait(semaphore);  /* wait for the first iteration to finish. */
-    }
-
-    SDL_DestroySemaphore(semaphore);
+    ALSA_hotplug_thread = SDL_CreateThread(ALSA_HotplugThread, "SDLHotplugALSA", NULL);
+    /* if the thread doesn't spin, oh well, you just don't get further hotplug events. */
+#endif
 }
 
 static void
 ALSA_Deinitialize(void)
 {
+    ALSA_Device *dev;
+    ALSA_Device *next;
+
+#if SDL_ALSA_HOTPLUG_THREAD
     if (ALSA_hotplug_thread != NULL) {
         SDL_AtomicSet(&ALSA_hotplug_shutdown, 1);
         SDL_WaitThread(ALSA_hotplug_thread, NULL);
         ALSA_hotplug_thread = NULL;
     }
+#endif
+
+    /* Shutting down! Clean up any data we've gathered. */
+    for (dev = hotplug_devices; dev; dev = next) {
+        /*printf("ALSA: at shutdown, removing %s device '%s'\n", dev->iscapture ? "capture" : "output", dev->name);*/
+        next = dev->next;
+        SDL_free(dev->name);
+        SDL_free(dev);
+    }
+    hotplug_devices = NULL;
 
     UnloadALSALibrary();
 }
 
-static int
+static SDL_bool
 ALSA_Init(SDL_AudioDriverImpl * impl)
 {
     if (LoadALSALibrary() < 0) {
-        return 0;
+        return SDL_FALSE;
     }
 
     /* Set the function pointers */
@@ -984,12 +1010,12 @@ ALSA_Init(SDL_AudioDriverImpl * impl)
 
     impl->HasCaptureSupport = SDL_TRUE;
 
-    return 1;   /* this audio target is available. */
+    return SDL_TRUE;   /* this audio target is available. */
 }
 
 
 AudioBootStrap ALSA_bootstrap = {
-    "alsa", "ALSA PCM audio", ALSA_Init, 0
+    "alsa", "ALSA PCM audio", ALSA_Init, SDL_FALSE
 };
 
 #endif /* SDL_AUDIO_DRIVER_ALSA */
diff --git a/Engine/lib/sdl/src/audio/alsa/SDL_alsa_audio.h b/Engine/lib/sdl/src/audio/alsa/SDL_alsa_audio.h
index d0e6d0b29..5ec339d91 100644
--- a/Engine/lib/sdl/src/audio/alsa/SDL_alsa_audio.h
+++ b/Engine/lib/sdl/src/audio/alsa/SDL_alsa_audio.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/audio/android/SDL_androidaudio.c b/Engine/lib/sdl/src/audio/android/SDL_androidaudio.c
index dbb9562cb..aa0d44242 100644
--- a/Engine/lib/sdl/src/audio/android/SDL_androidaudio.c
+++ b/Engine/lib/sdl/src/audio/android/SDL_androidaudio.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -36,9 +36,10 @@ static SDL_AudioDevice* audioDevice = NULL;
 static SDL_AudioDevice* captureDevice = NULL;
 
 static int
-ANDROIDAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
+ANDROIDAUDIO_OpenDevice(_THIS, const char *devname)
 {
     SDL_AudioFormat test_format;
+    SDL_bool iscapture = this->iscapture;
 
     SDL_assert((captureDevice == NULL) || !iscapture);
     SDL_assert((audioDevice == NULL) || iscapture);
@@ -54,20 +55,18 @@ ANDROIDAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
         return SDL_OutOfMemory();
     }
 
-    test_format = SDL_FirstAudioFormat(this->spec.format);
-    while (test_format != 0) { /* no "UNKNOWN" constant */
+    for (test_format = SDL_FirstAudioFormat(this->spec.format); test_format; test_format = SDL_NextAudioFormat()) {
         if ((test_format == AUDIO_U8) ||
-			(test_format == AUDIO_S16) ||
-			(test_format == AUDIO_F32)) {
+            (test_format == AUDIO_S16) ||
+            (test_format == AUDIO_F32)) {
             this->spec.format = test_format;
             break;
         }
-        test_format = SDL_NextAudioFormat();
     }
 
-    if (test_format == 0) {
+    if (!test_format) {
         /* Didn't find a compatible format :( */
-        return SDL_SetError("No compatible audio format!");
+        return SDL_SetError("%s: Unsupported audio format", "android");
     }
 
     if (Android_JNI_OpenAudioDevice(iscapture, &this->spec) < 0) {
@@ -120,7 +119,7 @@ ANDROIDAUDIO_CloseDevice(_THIS)
     SDL_free(this->hidden);
 }
 
-static int
+static SDL_bool
 ANDROIDAUDIO_Init(SDL_AudioDriverImpl * impl)
 {
     /* Set the function pointers */
@@ -133,14 +132,14 @@ ANDROIDAUDIO_Init(SDL_AudioDriverImpl * impl)
 
     /* and the capabilities */
     impl->HasCaptureSupport = SDL_TRUE;
-    impl->OnlyHasDefaultOutputDevice = 1;
-    impl->OnlyHasDefaultCaptureDevice = 1;
+    impl->OnlyHasDefaultOutputDevice = SDL_TRUE;
+    impl->OnlyHasDefaultCaptureDevice = SDL_TRUE;
 
-    return 1;   /* this audio target is available. */
+    return SDL_TRUE;   /* this audio target is available. */
 }
 
 AudioBootStrap ANDROIDAUDIO_bootstrap = {
-    "android", "SDL Android audio driver", ANDROIDAUDIO_Init, 0
+    "android", "SDL Android audio driver", ANDROIDAUDIO_Init, SDL_FALSE
 };
 
 /* Pause (block) all non already paused audio devices by taking their mixer lock */
diff --git a/Engine/lib/sdl/src/audio/android/SDL_androidaudio.h b/Engine/lib/sdl/src/audio/android/SDL_androidaudio.h
index 6773eca75..a04975864 100644
--- a/Engine/lib/sdl/src/audio/android/SDL_androidaudio.h
+++ b/Engine/lib/sdl/src/audio/android/SDL_androidaudio.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/audio/arts/SDL_artsaudio.c b/Engine/lib/sdl/src/audio/arts/SDL_artsaudio.c
index 4f1a703e7..ce74b7d4d 100644
--- a/Engine/lib/sdl/src/audio/arts/SDL_artsaudio.c
+++ b/Engine/lib/sdl/src/audio/arts/SDL_artsaudio.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -216,11 +216,11 @@ ARTS_Suspend(void)
 }
 
 static int
-ARTS_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
+ARTS_OpenDevice(_THIS, const char *devname)
 {
     int rc = 0;
-    int bits = 0, frag_spec = 0;
-    SDL_AudioFormat test_format = 0, format = 0;
+    int bits, frag_spec = 0;
+    SDL_AudioFormat test_format = 0;
 
     /* Initialize all variables that we clean on shutdown */
     this->hidden = (struct SDL_PrivateAudioData *)
@@ -231,32 +231,24 @@ ARTS_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
     SDL_zerop(this->hidden);
 
     /* Try for a closest match on audio format */
-    for (test_format = SDL_FirstAudioFormat(this->spec.format);
-         !format && test_format;) {
+    for (test_format = SDL_FirstAudioFormat(this->spec.format); test_format; test_format = SDL_NextAudioFormat()) {
 #ifdef DEBUG_AUDIO
         fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
 #endif
         switch (test_format) {
         case AUDIO_U8:
-            bits = 8;
-            format = 1;
-            break;
         case AUDIO_S16LSB:
-            bits = 16;
-            format = 1;
             break;
         default:
-            format = 0;
-            break;
-        }
-        if (!format) {
-            test_format = SDL_NextAudioFormat();
+            continue;
         }
+        break;
     }
-    if (format == 0) {
-        return SDL_SetError("Couldn't find any hardware audio formats");
+    if (!test_format) {
+        return SDL_SetError("%s: Unsupported audio format", "arts");
     }
     this->spec.format = test_format;
+    bits = SDL_AUDIO_BITSIZE(test_format);
 
     if ((rc = SDL_NAME(arts_init) ()) != 0) {
         return SDL_SetError("Unable to initialize ARTS: %s",
@@ -320,16 +312,16 @@ ARTS_Deinitialize(void)
 }
 
 
-static int
+static SDL_bool
 ARTS_Init(SDL_AudioDriverImpl * impl)
 {
     if (LoadARTSLibrary() < 0) {
-        return 0;
+        return SDL_FALSE;
     } else {
         if (SDL_NAME(arts_init) () != 0) {
             UnloadARTSLibrary();
             SDL_SetError("ARTS: arts_init failed (no audio server?)");
-            return 0;
+            return SDL_FALSE;
         }
 
         /* Play a stream so aRts doesn't crash */
@@ -350,14 +342,14 @@ ARTS_Init(SDL_AudioDriverImpl * impl)
     impl->GetDeviceBuf = ARTS_GetDeviceBuf;
     impl->CloseDevice = ARTS_CloseDevice;
     impl->Deinitialize = ARTS_Deinitialize;
-    impl->OnlyHasDefaultOutputDevice = 1;
+    impl->OnlyHasDefaultOutputDevice = SDL_TRUE;
 
-    return 1;   /* this audio target is available. */
+    return SDL_TRUE;   /* this audio target is available. */
 }
 
 
 AudioBootStrap ARTS_bootstrap = {
-    "arts", "Analog RealTime Synthesizer", ARTS_Init, 0
+    "arts", "Analog RealTime Synthesizer", ARTS_Init, SDL_FALSE
 };
 
 #endif /* SDL_AUDIO_DRIVER_ARTS */
diff --git a/Engine/lib/sdl/src/audio/arts/SDL_artsaudio.h b/Engine/lib/sdl/src/audio/arts/SDL_artsaudio.h
index 67676d927..0f6e1693c 100644
--- a/Engine/lib/sdl/src/audio/arts/SDL_artsaudio.h
+++ b/Engine/lib/sdl/src/audio/arts/SDL_artsaudio.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/audio/coreaudio/SDL_coreaudio.h b/Engine/lib/sdl/src/audio/coreaudio/SDL_coreaudio.h
index 45d1c6c9e..3bb535554 100644
--- a/Engine/lib/sdl/src/audio/coreaudio/SDL_coreaudio.h
+++ b/Engine/lib/sdl/src/audio/coreaudio/SDL_coreaudio.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/audio/coreaudio/SDL_coreaudio.m b/Engine/lib/sdl/src/audio/coreaudio/SDL_coreaudio.m
index 364816f6b..304599fff 100644
--- a/Engine/lib/sdl/src/audio/coreaudio/SDL_coreaudio.m
+++ b/Engine/lib/sdl/src/audio/coreaudio/SDL_coreaudio.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -56,7 +56,7 @@ static const AudioObjectPropertyAddress devlist_address = {
     kAudioObjectPropertyElementMaster
 };
 
-typedef void (*addDevFn)(const char *name, const int iscapture, AudioDeviceID devId, void *data);
+typedef void (*addDevFn)(const char *name, SDL_AudioSpec *spec, const int iscapture, AudioDeviceID devId, void *data);
 
 typedef struct AudioDeviceList
 {
@@ -88,10 +88,10 @@ add_to_internal_dev_list(const int iscapture, AudioDeviceID devId)
 }
 
 static void
-addToDevList(const char *name, const int iscapture, AudioDeviceID devId, void *data)
+addToDevList(const char *name, SDL_AudioSpec *spec, const int iscapture, AudioDeviceID devId, void *data)
 {
     if (add_to_internal_dev_list(iscapture, devId)) {
-        SDL_AddAudioDevice(iscapture, name, (void *) ((size_t) devId));
+        SDL_AddAudioDevice(iscapture, name, spec, (void *) ((size_t) devId));
     }
 }
 
@@ -126,17 +126,23 @@ build_device_list(int iscapture, addDevFn addfn, void *addfndata)
         AudioBufferList *buflist = NULL;
         int usable = 0;
         CFIndex len = 0;
+        double sampleRate = 0;
+        SDL_AudioSpec spec;
         const AudioObjectPropertyAddress addr = {
             kAudioDevicePropertyStreamConfiguration,
             iscapture ? kAudioDevicePropertyScopeInput : kAudioDevicePropertyScopeOutput,
             kAudioObjectPropertyElementMaster
         };
-
         const AudioObjectPropertyAddress nameaddr = {
             kAudioObjectPropertyName,
             iscapture ? kAudioDevicePropertyScopeInput : kAudioDevicePropertyScopeOutput,
             kAudioObjectPropertyElementMaster
         };
+        const AudioObjectPropertyAddress freqaddr = {
+            kAudioDevicePropertyNominalSampleRate,
+            iscapture ? kAudioDevicePropertyScopeInput : kAudioDevicePropertyScopeOutput,
+            kAudioObjectPropertyElementMaster
+        };
 
         result = AudioObjectGetPropertyDataSize(dev, &addr, 0, NULL, &size);
         if (result != noErr)
@@ -149,21 +155,24 @@ build_device_list(int iscapture, addDevFn addfn, void *addfndata)
         result = AudioObjectGetPropertyData(dev, &addr, 0, NULL,
                                             &size, buflist);
 
+        SDL_zero(spec);
         if (result == noErr) {
             UInt32 j;
             for (j = 0; j < buflist->mNumberBuffers; j++) {
-                if (buflist->mBuffers[j].mNumberChannels > 0) {
-                    usable = 1;
-                    break;
-                }
+                spec.channels += buflist->mBuffers[j].mNumberChannels;
             }
         }
 
         SDL_free(buflist);
 
-        if (!usable)
+        if (spec.channels == 0)
             continue;
 
+        size = sizeof (sampleRate);
+        result = AudioObjectGetPropertyData(dev, &freqaddr, 0, NULL, &size, &sampleRate);
+        if (result == noErr) {
+            spec.freq = (int) sampleRate;
+        }
 
         size = sizeof (CFStringRef);
         result = AudioObjectGetPropertyData(dev, &nameaddr, 0, NULL, &size, &cfstr);
@@ -197,7 +206,7 @@ build_device_list(int iscapture, addDevFn addfn, void *addfndata)
                    ((iscapture) ? "capture" : "output"),
                    (int) i, ptr, (int) dev);
 #endif
-            addfn(ptr, iscapture, dev, addfndata);
+            addfn(ptr, &spec, iscapture, dev, addfndata);
         }
         SDL_free(ptr);  /* addfn() would have copied the string. */
     }
@@ -223,7 +232,7 @@ COREAUDIO_DetectDevices(void)
 }
 
 static void
-build_device_change_list(const char *name, const int iscapture, AudioDeviceID devId, void *data)
+build_device_change_list(const char *name, SDL_AudioSpec *spec, const int iscapture, AudioDeviceID devId, void *data)
 {
     AudioDeviceList **list = (AudioDeviceList **) data;
     AudioDeviceList *item;
@@ -235,7 +244,7 @@ build_device_change_list(const char *name, const int iscapture, AudioDeviceID de
     }
 
     add_to_internal_dev_list(iscapture, devId);  /* new device, add it. */
-    SDL_AddAudioDevice(iscapture, name, (void *) ((size_t) devId));
+    SDL_AddAudioDevice(iscapture, name, spec, (void *) ((size_t) devId));
 }
 
 static void
@@ -592,7 +601,7 @@ inputCallback(void *inUserData, AudioQueueRef inAQ, AudioQueueBufferRef inBuffer
     }
 
     /* ignore unless we're active. */
-    if (!SDL_AtomicGet(&this->paused) && SDL_AtomicGet(&this->enabled) && !SDL_AtomicGet(&this->paused)) {
+    if (!SDL_AtomicGet(&this->paused) && SDL_AtomicGet(&this->enabled)) {
         const Uint8 *ptr = (const Uint8 *) inBuffer->mAudioData;
         UInt32 remaining = inBuffer->mAudioDataByteSize;
         while (remaining > 0) {
@@ -732,8 +741,10 @@ COREAUDIO_CloseDevice(_THIS)
 
 #if MACOSX_COREAUDIO
 static int
-prepare_device(_THIS, void *handle, int iscapture)
+prepare_device(_THIS)
 {
+    void *handle = this->handle;
+    SDL_bool iscapture = this->iscapture;
     AudioDeviceID devid = (AudioDeviceID) ((size_t) handle);
     OSStatus result = noErr;
     UInt32 size = 0;
@@ -974,7 +985,7 @@ audioqueue_thread(void *arg)
                and quits (flagging the audioqueue for shutdown), or toggles to some other system
                output device (in which case we'll try again). */
             const AudioDeviceID prev_devid = this->hidden->deviceID;
-            if (prepare_device(this, this->handle, this->iscapture) && (prev_devid != this->hidden->deviceID)) {
+            if (prepare_device(this) && (prev_devid != this->hidden->deviceID)) {
                 AudioQueueStop(this->hidden->audioQueue, 1);
                 if (assign_device_to_audioqueue(this)) {
                     int i;
@@ -1006,11 +1017,11 @@ audioqueue_thread(void *arg)
 }
 
 static int
-COREAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
+COREAUDIO_OpenDevice(_THIS, const char *devname)
 {
     AudioStreamBasicDescription *strdesc;
-    SDL_AudioFormat test_format = SDL_FirstAudioFormat(this->spec.format);
-    int valid_datatype = 0;
+    SDL_AudioFormat test_format;
+    SDL_bool iscapture = this->iscapture;
     SDL_AudioDevice **new_open_devices;
 
     /* Initialize all variables that we clean on shutdown */
@@ -1067,8 +1078,7 @@ COREAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
     strdesc->mSampleRate = this->spec.freq;
     strdesc->mFramesPerPacket = 1;
 
-    while ((!valid_datatype) && (test_format)) {
-        this->spec.format = test_format;
+    for (test_format = SDL_FirstAudioFormat(this->spec.format); test_format; test_format = SDL_NextAudioFormat()) {
         /* CoreAudio handles most of SDL's formats natively, but not U16, apparently. */
         switch (test_format) {
         case AUDIO_U8:
@@ -1079,32 +1089,32 @@ COREAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
         case AUDIO_S32MSB:
         case AUDIO_F32LSB:
         case AUDIO_F32MSB:
-            valid_datatype = 1;
-            strdesc->mBitsPerChannel = SDL_AUDIO_BITSIZE(this->spec.format);
-            if (SDL_AUDIO_ISBIGENDIAN(this->spec.format))
-                strdesc->mFormatFlags |= kLinearPCMFormatFlagIsBigEndian;
-
-            if (SDL_AUDIO_ISFLOAT(this->spec.format))
-                strdesc->mFormatFlags |= kLinearPCMFormatFlagIsFloat;
-            else if (SDL_AUDIO_ISSIGNED(this->spec.format))
-                strdesc->mFormatFlags |= kLinearPCMFormatFlagIsSignedInteger;
             break;
 
         default:
-            test_format = SDL_NextAudioFormat();
-            break;
+            continue;
         }
+        break;
     }
 
-    if (!valid_datatype) {      /* shouldn't happen, but just in case... */
-        return SDL_SetError("Unsupported audio format");
+    if (!test_format) {      /* shouldn't happen, but just in case... */
+        return SDL_SetError("%s: Unsupported audio format", "coreaudio");
     }
+    this->spec.format = test_format;
+    strdesc->mBitsPerChannel = SDL_AUDIO_BITSIZE(test_format);
+    if (SDL_AUDIO_ISBIGENDIAN(test_format))
+        strdesc->mFormatFlags |= kLinearPCMFormatFlagIsBigEndian;
+
+    if (SDL_AUDIO_ISFLOAT(test_format))
+        strdesc->mFormatFlags |= kLinearPCMFormatFlagIsFloat;
+    else if (SDL_AUDIO_ISSIGNED(test_format))
+        strdesc->mFormatFlags |= kLinearPCMFormatFlagIsSignedInteger;
 
     strdesc->mBytesPerFrame = strdesc->mChannelsPerFrame * strdesc->mBitsPerChannel / 8;
     strdesc->mBytesPerPacket = strdesc->mBytesPerFrame * strdesc->mFramesPerPacket;
 
 #if MACOSX_COREAUDIO
-    if (!prepare_device(this, handle, iscapture)) {
+    if (!prepare_device(this)) {
         return -1;
     }
 #endif
@@ -1126,8 +1136,7 @@ COREAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
     this->hidden->ready_semaphore = NULL;
 
     if ((this->hidden->thread != NULL) && (this->hidden->thread_error != NULL)) {
-        SDL_SetError("%s", this->hidden->thread_error);
-        return -1;
+        return SDL_SetError("%s", this->hidden->thread_error);
     }
 
     return (this->hidden->thread != NULL) ? 0 : -1;
@@ -1143,7 +1152,7 @@ COREAUDIO_Deinitialize(void)
 #endif
 }
 
-static int
+static SDL_bool
 COREAUDIO_Init(SDL_AudioDriverImpl * impl)
 {
     /* Set the function pointers */
@@ -1155,18 +1164,18 @@ COREAUDIO_Init(SDL_AudioDriverImpl * impl)
     impl->DetectDevices = COREAUDIO_DetectDevices;
     AudioObjectAddPropertyListener(kAudioObjectSystemObject, &devlist_address, device_list_changed, NULL);
 #else
-    impl->OnlyHasDefaultOutputDevice = 1;
-    impl->OnlyHasDefaultCaptureDevice = 1;
+    impl->OnlyHasDefaultOutputDevice = SDL_TRUE;
+    impl->OnlyHasDefaultCaptureDevice = SDL_TRUE;
 #endif
 
-    impl->ProvidesOwnCallbackThread = 1;
-    impl->HasCaptureSupport = 1;
+    impl->ProvidesOwnCallbackThread = SDL_TRUE;
+    impl->HasCaptureSupport = SDL_TRUE;
 
-    return 1;   /* this audio target is available. */
+    return SDL_TRUE;   /* this audio target is available. */
 }
 
 AudioBootStrap COREAUDIO_bootstrap = {
-    "coreaudio", "CoreAudio", COREAUDIO_Init, 0
+    "coreaudio", "CoreAudio", COREAUDIO_Init, SDL_FALSE
 };
 
 #endif /* SDL_AUDIO_DRIVER_COREAUDIO */
diff --git a/Engine/lib/sdl/src/audio/directsound/SDL_directsound.c b/Engine/lib/sdl/src/audio/directsound/SDL_directsound.c
index 6d17d76cb..0242b139d 100644
--- a/Engine/lib/sdl/src/audio/directsound/SDL_directsound.c
+++ b/Engine/lib/sdl/src/audio/directsound/SDL_directsound.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -98,10 +98,8 @@ DSOUND_Load(void)
 static int
 SetDSerror(const char *function, int code)
 {
-    static const char *error;
-    static char errbuf[1024];
+    const char *error;
 
-    errbuf[0] = 0;
     switch (code) {
     case E_NOINTERFACE:
         error = "Unsupported interface -- Is DirectX 8.0 or later installed?";
@@ -137,15 +135,11 @@ SetDSerror(const char *function, int code)
         error = "Function not supported";
         break;
     default:
-        SDL_snprintf(errbuf, SDL_arraysize(errbuf),
-                     "%s: Unknown DirectSound error: 0x%x", function, code);
+        error = "Unknown DirectSound error";
         break;
     }
-    if (!errbuf[0]) {
-        SDL_snprintf(errbuf, SDL_arraysize(errbuf), "%s: %s", function,
-                     error);
-    }
-    return SDL_SetError("%s", errbuf);
+
+    return SDL_SetError("%s: %s (0x%x)", function, error, code);
 }
 
 static void
@@ -163,7 +157,12 @@ FindAllDevs(LPGUID guid, LPCWSTR desc, LPCWSTR module, LPVOID data)
         if (str != NULL) {
             LPGUID cpyguid = (LPGUID) SDL_malloc(sizeof (GUID));
             SDL_memcpy(cpyguid, guid, sizeof (GUID));
-            SDL_AddAudioDevice(iscapture, str, cpyguid);
+
+            /* Note that spec is NULL, because we are required to connect to the
+             * device before getting the channel mask and output format, making
+             * this information inaccessible at enumeration time
+             */
+            SDL_AddAudioDevice(iscapture, str, NULL, cpyguid);
             SDL_free(str);  /* addfn() makes a copy of this string. */
         }
     }
@@ -468,14 +467,14 @@ CreateCaptureBuffer(_THIS, const DWORD bufsize, WAVEFORMATEX *wfmt)
 }
 
 static int
-DSOUND_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
+DSOUND_OpenDevice(_THIS, const char *devname)
 {
     const DWORD numchunks = 8;
     HRESULT result;
-    SDL_bool valid_format = SDL_FALSE;
     SDL_bool tried_format = SDL_FALSE;
-    SDL_AudioFormat test_format = SDL_FirstAudioFormat(this->spec.format);
-    LPGUID guid = (LPGUID) handle;
+    SDL_bool iscapture = this->iscapture;
+    SDL_AudioFormat test_format;
+    LPGUID guid = (LPGUID) this->handle;
     DWORD bufsize;
 
     /* Initialize all variables that we clean on shutdown */
@@ -505,7 +504,7 @@ DSOUND_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
         }
     }
 
-    while ((!valid_format) && (test_format)) {
+    for (test_format = SDL_FirstAudioFormat(this->spec.format); test_format; test_format = SDL_NextAudioFormat()) {
         switch (test_format) {
         case AUDIO_U8:
         case AUDIO_S16:
@@ -542,19 +541,21 @@ DSOUND_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
                 rc = iscapture ? CreateCaptureBuffer(this, bufsize, &wfmt) : CreateSecondary(this, bufsize, &wfmt);
                 if (rc == 0) {
                     this->hidden->num_buffers = numchunks;
-                    valid_format = SDL_TRUE;
+                    break;
                 }
             }
-            break;
+            continue;
+        default:
+            continue;
         }
-        test_format = SDL_NextAudioFormat();
+        break;
     }
 
-    if (!valid_format) {
+    if (!test_format) {
         if (tried_format) {
             return -1;  /* CreateSecondary() should have called SDL_SetError(). */
         }
-        return SDL_SetError("DirectSound: Unsupported audio format");
+        return SDL_SetError("%s: Unsupported audio format", "directsound");
     }
 
     /* Playback buffers will auto-start playing in DSOUND_WaitDevice() */
@@ -570,11 +571,11 @@ DSOUND_Deinitialize(void)
 }
 
 
-static int
+static SDL_bool
 DSOUND_Init(SDL_AudioDriverImpl * impl)
 {
     if (!DSOUND_Load()) {
-        return 0;
+        return SDL_FALSE;
     }
 
     /* Set the function pointers */
@@ -591,11 +592,11 @@ DSOUND_Init(SDL_AudioDriverImpl * impl)
 
     impl->HasCaptureSupport = SDL_TRUE;
 
-    return 1;   /* this audio target is available. */
+    return SDL_TRUE;   /* this audio target is available. */
 }
 
 AudioBootStrap DSOUND_bootstrap = {
-    "directsound", "DirectSound", DSOUND_Init, 0
+    "directsound", "DirectSound", DSOUND_Init, SDL_FALSE
 };
 
 #endif /* SDL_AUDIO_DRIVER_DSOUND */
diff --git a/Engine/lib/sdl/src/audio/directsound/SDL_directsound.h b/Engine/lib/sdl/src/audio/directsound/SDL_directsound.h
index e120de669..365de770c 100644
--- a/Engine/lib/sdl/src/audio/directsound/SDL_directsound.h
+++ b/Engine/lib/sdl/src/audio/directsound/SDL_directsound.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/audio/disk/SDL_diskaudio.c b/Engine/lib/sdl/src/audio/disk/SDL_diskaudio.c
index 5849d922a..f1edf503e 100644
--- a/Engine/lib/sdl/src/audio/disk/SDL_diskaudio.c
+++ b/Engine/lib/sdl/src/audio/disk/SDL_diskaudio.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -46,19 +46,19 @@
 static void
 DISKAUDIO_WaitDevice(_THIS)
 {
-    SDL_Delay(this->hidden->io_delay);
+    SDL_Delay(_this->hidden->io_delay);
 }
 
 static void
 DISKAUDIO_PlayDevice(_THIS)
 {
-    const size_t written = SDL_RWwrite(this->hidden->io,
-                                       this->hidden->mixbuf,
-                                       1, this->spec.size);
+    const size_t written = SDL_RWwrite(_this->hidden->io,
+                                       _this->hidden->mixbuf,
+                                       1, _this->spec.size);
 
     /* If we couldn't write, assume fatal error for now */
-    if (written != this->spec.size) {
-        SDL_OpenedAudioDeviceDisconnected(this);
+    if (written != _this->spec.size) {
+        SDL_OpenedAudioDeviceDisconnected(_this);
     }
 #ifdef DEBUG_AUDIO
     fprintf(stderr, "Wrote %d bytes of audio data\n", written);
@@ -68,13 +68,13 @@ DISKAUDIO_PlayDevice(_THIS)
 static Uint8 *
 DISKAUDIO_GetDeviceBuf(_THIS)
 {
-    return (this->hidden->mixbuf);
+    return (_this->hidden->mixbuf);
 }
 
 static int
 DISKAUDIO_CaptureFromDevice(_THIS, void *buffer, int buflen)
 {
-    struct SDL_PrivateAudioData *h = this->hidden;
+    struct SDL_PrivateAudioData *h = _this->hidden;
     const int origbuflen = buflen;
 
     SDL_Delay(h->io_delay);
@@ -90,7 +90,7 @@ DISKAUDIO_CaptureFromDevice(_THIS, void *buffer, int buflen)
     }
 
     /* if we ran out of file, just write silence. */
-    SDL_memset(buffer, this->spec.silence, buflen);
+    SDL_memset(buffer, _this->spec.silence, buflen);
 
     return origbuflen;
 }
@@ -105,16 +105,16 @@ DISKAUDIO_FlushCapture(_THIS)
 static void
 DISKAUDIO_CloseDevice(_THIS)
 {
-    if (this->hidden->io != NULL) {
-        SDL_RWclose(this->hidden->io);
+    if (_this->hidden->io != NULL) {
+        SDL_RWclose(_this->hidden->io);
     }
-    SDL_free(this->hidden->mixbuf);
-    SDL_free(this->hidden);
+    SDL_free(_this->hidden->mixbuf);
+    SDL_free(_this->hidden);
 }
 
 
 static const char *
-get_filename(const int iscapture, const char *devname)
+get_filename(const SDL_bool iscapture, const char *devname)
 {
     if (devname == NULL) {
         devname = SDL_getenv(iscapture ? DISKENVR_INFILE : DISKENVR_OUTFILE);
@@ -126,38 +126,40 @@ get_filename(const int iscapture, const char *devname)
 }
 
 static int
-DISKAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
+DISKAUDIO_OpenDevice(_THIS, const char *devname)
 {
+    void *handle = _this->handle;
     /* handle != NULL means "user specified the placeholder name on the fake detected device list" */
+    SDL_bool iscapture = _this->iscapture;
     const char *fname = get_filename(iscapture, handle ? NULL : devname);
     const char *envr = SDL_getenv(DISKENVR_IODELAY);
 
-    this->hidden = (struct SDL_PrivateAudioData *)
-        SDL_malloc(sizeof(*this->hidden));
-    if (this->hidden == NULL) {
+    _this->hidden = (struct SDL_PrivateAudioData *)
+        SDL_malloc(sizeof(*_this->hidden));
+    if (_this->hidden == NULL) {
         return SDL_OutOfMemory();
     }
-    SDL_zerop(this->hidden);
+    SDL_zerop(_this->hidden);
 
     if (envr != NULL) {
-        this->hidden->io_delay = SDL_atoi(envr);
+        _this->hidden->io_delay = SDL_atoi(envr);
     } else {
-        this->hidden->io_delay = ((this->spec.samples * 1000) / this->spec.freq);
+        _this->hidden->io_delay = ((_this->spec.samples * 1000) / _this->spec.freq);
     }
 
     /* Open the audio device */
-    this->hidden->io = SDL_RWFromFile(fname, iscapture ? "rb" : "wb");
-    if (this->hidden->io == NULL) {
+    _this->hidden->io = SDL_RWFromFile(fname, iscapture ? "rb" : "wb");
+    if (_this->hidden->io == NULL) {
         return -1;
     }
 
     /* Allocate mixing buffer */
     if (!iscapture) {
-        this->hidden->mixbuf = (Uint8 *) SDL_malloc(this->spec.size);
-        if (this->hidden->mixbuf == NULL) {
+        _this->hidden->mixbuf = (Uint8 *) SDL_malloc(_this->spec.size);
+        if (_this->hidden->mixbuf == NULL) {
             return SDL_OutOfMemory();
         }
-        SDL_memset(this->hidden->mixbuf, this->spec.silence, this->spec.size);
+        SDL_memset(_this->hidden->mixbuf, _this->spec.silence, _this->spec.size);
     }
 
     SDL_LogCritical(SDL_LOG_CATEGORY_AUDIO,
@@ -173,11 +175,11 @@ DISKAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
 static void
 DISKAUDIO_DetectDevices(void)
 {
-    SDL_AddAudioDevice(SDL_FALSE, DEFAULT_OUTPUT_DEVNAME, (void *) 0x1);
-    SDL_AddAudioDevice(SDL_TRUE, DEFAULT_INPUT_DEVNAME, (void *) 0x2);
+    SDL_AddAudioDevice(SDL_FALSE, DEFAULT_OUTPUT_DEVNAME, NULL, (void *) 0x1);
+    SDL_AddAudioDevice(SDL_TRUE, DEFAULT_INPUT_DEVNAME, NULL, (void *) 0x2);
 }
 
-static int
+static SDL_bool
 DISKAUDIO_Init(SDL_AudioDriverImpl * impl)
 {
     /* Set the function pointers */
@@ -191,14 +193,14 @@ DISKAUDIO_Init(SDL_AudioDriverImpl * impl)
     impl->CloseDevice = DISKAUDIO_CloseDevice;
     impl->DetectDevices = DISKAUDIO_DetectDevices;
 
-    impl->AllowsArbitraryDeviceNames = 1;
+    impl->AllowsArbitraryDeviceNames = SDL_TRUE;
     impl->HasCaptureSupport = SDL_TRUE;
 
-    return 1;   /* this audio target is available. */
+    return SDL_TRUE;   /* this audio target is available. */
 }
 
 AudioBootStrap DISKAUDIO_bootstrap = {
-    "disk", "direct-to-disk audio", DISKAUDIO_Init, 1
+    "disk", "direct-to-disk audio", DISKAUDIO_Init, SDL_TRUE
 };
 
 #endif /* SDL_AUDIO_DRIVER_DISK */
diff --git a/Engine/lib/sdl/src/audio/disk/SDL_diskaudio.h b/Engine/lib/sdl/src/audio/disk/SDL_diskaudio.h
index 44de8aceb..e7739250a 100644
--- a/Engine/lib/sdl/src/audio/disk/SDL_diskaudio.h
+++ b/Engine/lib/sdl/src/audio/disk/SDL_diskaudio.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -27,7 +27,7 @@
 #include "../SDL_sysaudio.h"
 
 /* Hidden "this" pointer for the audio functions */
-#define _THIS   SDL_AudioDevice *this
+#define _THIS   SDL_AudioDevice *_this
 
 struct SDL_PrivateAudioData
 {
diff --git a/Engine/lib/sdl/src/audio/dsp/SDL_dspaudio.c b/Engine/lib/sdl/src/audio/dsp/SDL_dspaudio.c
index b5df76659..531612a29 100644
--- a/Engine/lib/sdl/src/audio/dsp/SDL_dspaudio.c
+++ b/Engine/lib/sdl/src/audio/dsp/SDL_dspaudio.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -68,8 +68,9 @@ DSP_CloseDevice(_THIS)
 
 
 static int
-DSP_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
+DSP_OpenDevice(_THIS, const char *devname)
 {
+    SDL_bool iscapture = this->iscapture;
     const int flags = ((iscapture) ? OPEN_FLAGS_INPUT : OPEN_FLAGS_OUTPUT);
     int format;
     int value;
@@ -103,7 +104,7 @@ DSP_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
     SDL_zerop(this->hidden);
 
     /* Open the audio device */
-    this->hidden->audio_fd = open(devname, flags, 0);
+    this->hidden->audio_fd = open(devname, flags | O_CLOEXEC, 0);
     if (this->hidden->audio_fd < 0) {
         return SDL_SetError("Couldn't open %s: %s", devname, strerror(errno));
     }
@@ -292,9 +293,25 @@ DSP_FlushCapture(_THIS)
     }
 }
 
+static SDL_bool InitTimeDevicesExist = SDL_FALSE;
 static int
+look_for_devices_test(int fd)
+{
+    InitTimeDevicesExist = SDL_TRUE;  /* note that _something_ exists. */
+    /* Don't add to the device list, we're just seeing if any devices exist. */
+    return 0;
+}
+
+static SDL_bool
 DSP_Init(SDL_AudioDriverImpl * impl)
 {
+    InitTimeDevicesExist = SDL_FALSE;
+    SDL_EnumUnixAudioDevices(0, look_for_devices_test);
+    if (!InitTimeDevicesExist) {
+        SDL_SetError("dsp: No such audio device");
+        return SDL_FALSE;  /* maybe try a different backend. */
+    }
+
     /* Set the function pointers */
     impl->DetectDevices = DSP_DetectDevices;
     impl->OpenDevice = DSP_OpenDevice;
@@ -304,15 +321,15 @@ DSP_Init(SDL_AudioDriverImpl * impl)
     impl->CaptureFromDevice = DSP_CaptureFromDevice;
     impl->FlushCapture = DSP_FlushCapture;
 
-    impl->AllowsArbitraryDeviceNames = 1;
+    impl->AllowsArbitraryDeviceNames = SDL_TRUE;
     impl->HasCaptureSupport = SDL_TRUE;
 
-    return 1;   /* this audio target is available. */
+    return SDL_TRUE;   /* this audio target is available. */
 }
 
 
 AudioBootStrap DSP_bootstrap = {
-    "dsp", "OSS /dev/dsp standard audio", DSP_Init, 0
+    "dsp", "OSS /dev/dsp standard audio", DSP_Init, SDL_FALSE
 };
 
 #endif /* SDL_AUDIO_DRIVER_OSS */
diff --git a/Engine/lib/sdl/src/audio/dsp/SDL_dspaudio.h b/Engine/lib/sdl/src/audio/dsp/SDL_dspaudio.h
index 2955bbc76..b9ce50e2f 100644
--- a/Engine/lib/sdl/src/audio/dsp/SDL_dspaudio.h
+++ b/Engine/lib/sdl/src/audio/dsp/SDL_dspaudio.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/audio/dummy/SDL_dummyaudio.c b/Engine/lib/sdl/src/audio/dummy/SDL_dummyaudio.c
index 8cbfc2fe2..dab1edb59 100644
--- a/Engine/lib/sdl/src/audio/dummy/SDL_dummyaudio.c
+++ b/Engine/lib/sdl/src/audio/dummy/SDL_dummyaudio.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -28,8 +28,9 @@
 #include "SDL_dummyaudio.h"
 
 static int
-DUMMYAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
+DUMMYAUDIO_OpenDevice(_THIS, const char *devname)
 {
+    _this->hidden = (void *) 0x1;  /* just something non-NULL */
     return 0;                   /* always succeeds. */
 }
 
@@ -37,29 +38,29 @@ static int
 DUMMYAUDIO_CaptureFromDevice(_THIS, void *buffer, int buflen)
 {
     /* Delay to make this sort of simulate real audio input. */
-    SDL_Delay((this->spec.samples * 1000) / this->spec.freq);
+    SDL_Delay((_this->spec.samples * 1000) / _this->spec.freq);
 
     /* always return a full buffer of silence. */
-    SDL_memset(buffer, this->spec.silence, buflen);
+    SDL_memset(buffer, _this->spec.silence, buflen);
     return buflen;
 }
 
-static int
+static SDL_bool
 DUMMYAUDIO_Init(SDL_AudioDriverImpl * impl)
 {
     /* Set the function pointers */
     impl->OpenDevice = DUMMYAUDIO_OpenDevice;
     impl->CaptureFromDevice = DUMMYAUDIO_CaptureFromDevice;
 
-    impl->OnlyHasDefaultOutputDevice = 1;
-    impl->OnlyHasDefaultCaptureDevice = 1;
+    impl->OnlyHasDefaultOutputDevice = SDL_TRUE;
+    impl->OnlyHasDefaultCaptureDevice = SDL_TRUE;
     impl->HasCaptureSupport = SDL_TRUE;
 
-    return 1;   /* this audio target is available. */
+    return SDL_TRUE;   /* this audio target is available. */
 }
 
 AudioBootStrap DUMMYAUDIO_bootstrap = {
-    "dummy", "SDL dummy audio driver", DUMMYAUDIO_Init, 1
+    "dummy", "SDL dummy audio driver", DUMMYAUDIO_Init, SDL_TRUE
 };
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/audio/dummy/SDL_dummyaudio.h b/Engine/lib/sdl/src/audio/dummy/SDL_dummyaudio.h
index 47d49e513..6ac650d4d 100644
--- a/Engine/lib/sdl/src/audio/dummy/SDL_dummyaudio.h
+++ b/Engine/lib/sdl/src/audio/dummy/SDL_dummyaudio.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -26,7 +26,7 @@
 #include "../SDL_sysaudio.h"
 
 /* Hidden "this" pointer for the audio functions */
-#define _THIS   SDL_AudioDevice *this
+#define _THIS   SDL_AudioDevice *_this
 
 struct SDL_PrivateAudioData
 {
diff --git a/Engine/lib/sdl/src/audio/emscripten/SDL_emscriptenaudio.c b/Engine/lib/sdl/src/audio/emscripten/SDL_emscriptenaudio.c
index 3df6f7ebb..bc2a0e10d 100644
--- a/Engine/lib/sdl/src/audio/emscripten/SDL_emscriptenaudio.c
+++ b/Engine/lib/sdl/src/audio/emscripten/SDL_emscriptenaudio.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -59,6 +59,9 @@ HandleAudioProcess(_THIS)
         if (this->stream) {
             SDL_AudioStreamClear(this->stream);
         }
+
+        SDL_memset(this->work_buffer, this->spec.silence, this->spec.size);
+        FeedAudioDevice(this, this->work_buffer, this->spec.size);
         return;
     }
 
@@ -189,10 +192,10 @@ EMSCRIPTENAUDIO_CloseDevice(_THIS)
 }
 
 static int
-EMSCRIPTENAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
+EMSCRIPTENAUDIO_OpenDevice(_THIS, const char *devname)
 {
-    SDL_bool valid_format = SDL_FALSE;
     SDL_AudioFormat test_format;
+    SDL_bool iscapture = this->iscapture;
     int result;
 
     /* based on parts of library_sdl.js */
@@ -215,6 +218,9 @@ EMSCRIPTENAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscaptu
             } else if (typeof(webkitAudioContext) !== 'undefined') {
                 SDL2.audioContext = new webkitAudioContext();
             }
+            if (SDL2.audioContext) {
+                autoResumeAudioContext(SDL2.audioContext);
+            }
         }
         return SDL2.audioContext === undefined ? -1 : 0;
     }, iscapture);
@@ -222,22 +228,21 @@ EMSCRIPTENAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscaptu
         return SDL_SetError("Web Audio API is not available!");
     }
 
-    test_format = SDL_FirstAudioFormat(this->spec.format);
-    while ((!valid_format) && (test_format)) {
+    for (test_format = SDL_FirstAudioFormat(this->spec.format); test_format; test_format = SDL_NextAudioFormat()) {
         switch (test_format) {
         case AUDIO_F32: /* web audio only supports floats */
-            this->spec.format = test_format;
-
-            valid_format = SDL_TRUE;
             break;
+        default:
+            continue;
         }
-        test_format = SDL_NextAudioFormat();
+        break;
     }
 
-    if (!valid_format) {
+    if (!test_format) {
         /* Didn't find a compatible format :( */
-        return SDL_SetError("No compatible audio format!");
+        return SDL_SetError("%s: Unsupported audio format", "emscripten");
     }
+    this->spec.format = test_format;
 
     /* Initialize all variables that we clean on shutdown */
 #if 0  /* !!! FIXME: currently not used. Can we move some stuff off the SDL2 namespace? --ryan. */
@@ -333,30 +338,34 @@ EMSCRIPTENAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscaptu
     return 0;
 }
 
-static int
+static void
+EMSCRIPTENAUDIO_LockOrUnlockDeviceWithNoMixerLock(SDL_AudioDevice * device)
+{
+}
+
+static SDL_bool
 EMSCRIPTENAUDIO_Init(SDL_AudioDriverImpl * impl)
 {
-    int available;
-    int capture_available;
+    SDL_bool available, capture_available;
 
     /* Set the function pointers */
     impl->OpenDevice = EMSCRIPTENAUDIO_OpenDevice;
     impl->CloseDevice = EMSCRIPTENAUDIO_CloseDevice;
 
-    impl->OnlyHasDefaultOutputDevice = 1;
+    impl->OnlyHasDefaultOutputDevice = SDL_TRUE;
 
     /* no threads here */
-    impl->SkipMixerLock = 1;
-    impl->ProvidesOwnCallbackThread = 1;
+    impl->LockDevice = impl->UnlockDevice = EMSCRIPTENAUDIO_LockOrUnlockDeviceWithNoMixerLock;
+    impl->ProvidesOwnCallbackThread = SDL_TRUE;
 
     /* check availability */
     available = EM_ASM_INT_V({
         if (typeof(AudioContext) !== 'undefined') {
-            return 1;
+            return true;
         } else if (typeof(webkitAudioContext) !== 'undefined') {
-            return 1;
+            return true;
         }
-        return 0;
+        return false;
     });
 
     if (!available) {
@@ -365,11 +374,11 @@ EMSCRIPTENAUDIO_Init(SDL_AudioDriverImpl * impl)
 
     capture_available = available && EM_ASM_INT_V({
         if ((typeof(navigator.mediaDevices) !== 'undefined') && (typeof(navigator.mediaDevices.getUserMedia) !== 'undefined')) {
-            return 1;
+            return true;
         } else if (typeof(navigator.webkitGetUserMedia) !== 'undefined') {
-            return 1;
+            return true;
         }
-        return 0;
+        return false;
     });
 
     impl->HasCaptureSupport = capture_available ? SDL_TRUE : SDL_FALSE;
@@ -379,7 +388,7 @@ EMSCRIPTENAUDIO_Init(SDL_AudioDriverImpl * impl)
 }
 
 AudioBootStrap EMSCRIPTENAUDIO_bootstrap = {
-    "emscripten", "SDL emscripten audio driver", EMSCRIPTENAUDIO_Init, 0
+    "emscripten", "SDL emscripten audio driver", EMSCRIPTENAUDIO_Init, SDL_FALSE
 };
 
 #endif /* SDL_AUDIO_DRIVER_EMSCRIPTEN */
diff --git a/Engine/lib/sdl/src/audio/emscripten/SDL_emscriptenaudio.h b/Engine/lib/sdl/src/audio/emscripten/SDL_emscriptenaudio.h
index 2048f25af..f51695a0a 100644
--- a/Engine/lib/sdl/src/audio/emscripten/SDL_emscriptenaudio.h
+++ b/Engine/lib/sdl/src/audio/emscripten/SDL_emscriptenaudio.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/audio/esd/SDL_esdaudio.c b/Engine/lib/sdl/src/audio/esd/SDL_esdaudio.c
index 400f6534f..ccf07916c 100644
--- a/Engine/lib/sdl/src/audio/esd/SDL_esdaudio.c
+++ b/Engine/lib/sdl/src/audio/esd/SDL_esdaudio.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -208,7 +208,7 @@ get_progname(void)
 
 
 static int
-ESD_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
+ESD_OpenDevice(_THIS, const char *devname)
 {
     esd_format_t format = (ESD_STREAM | ESD_PLAY);
     SDL_AudioFormat test_format = 0;
@@ -293,11 +293,11 @@ ESD_Deinitialize(void)
     UnloadESDLibrary();
 }
 
-static int
+static SDL_bool
 ESD_Init(SDL_AudioDriverImpl * impl)
 {
     if (LoadESDLibrary() < 0) {
-        return 0;
+        return SDL_FALSE;
     } else {
         int connection = 0;
 
@@ -308,7 +308,7 @@ ESD_Init(SDL_AudioDriverImpl * impl)
         if (connection < 0) {
             UnloadESDLibrary();
             SDL_SetError("ESD: esd_open_sound failed (no audio server?)");
-            return 0;
+            return SDL_FALSE;
         }
         SDL_NAME(esd_close) (connection);
     }
@@ -320,14 +320,14 @@ ESD_Init(SDL_AudioDriverImpl * impl)
     impl->GetDeviceBuf = ESD_GetDeviceBuf;
     impl->CloseDevice = ESD_CloseDevice;
     impl->Deinitialize = ESD_Deinitialize;
-    impl->OnlyHasDefaultOutputDevice = 1;
+    impl->OnlyHasDefaultOutputDevice = SDL_TRUE;
 
-    return 1;   /* this audio target is available. */
+    return SDL_TRUE;   /* this audio target is available. */
 }
 
 
 AudioBootStrap ESD_bootstrap = {
-    "esd", "Enlightened Sound Daemon", ESD_Init, 0
+    "esd", "Enlightened Sound Daemon", ESD_Init, SDL_FALSE
 };
 
 #endif /* SDL_AUDIO_DRIVER_ESD */
diff --git a/Engine/lib/sdl/src/audio/esd/SDL_esdaudio.h b/Engine/lib/sdl/src/audio/esd/SDL_esdaudio.h
index b7bb06a60..90b780059 100644
--- a/Engine/lib/sdl/src/audio/esd/SDL_esdaudio.h
+++ b/Engine/lib/sdl/src/audio/esd/SDL_esdaudio.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/audio/fusionsound/SDL_fsaudio.c b/Engine/lib/sdl/src/audio/fusionsound/SDL_fsaudio.c
index 262388eb2..fbe684de8 100644
--- a/Engine/lib/sdl/src/audio/fusionsound/SDL_fsaudio.c
+++ b/Engine/lib/sdl/src/audio/fusionsound/SDL_fsaudio.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -174,10 +174,10 @@ SDL_FS_CloseDevice(_THIS)
 
 
 static int
-SDL_FS_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
+SDL_FS_OpenDevice(_THIS, const char *devname)
 {
     int bytes;
-    SDL_AudioFormat test_format = 0, format = 0;
+    SDL_AudioFormat test_format;
     FSSampleFormat fs_format;
     FSStreamDescription desc;
     DirectResult ret;
@@ -191,45 +191,34 @@ SDL_FS_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
     SDL_zerop(this->hidden);
 
     /* Try for a closest match on audio format */
-    for (test_format = SDL_FirstAudioFormat(this->spec.format);
-         !format && test_format;) {
+    for (test_format = SDL_FirstAudioFormat(this->spec.format); test_format; test_format = SDL_NextAudioFormat()) {
 #ifdef DEBUG_AUDIO
         fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
 #endif
         switch (test_format) {
         case AUDIO_U8:
             fs_format = FSSF_U8;
-            bytes = 1;
-            format = 1;
             break;
         case AUDIO_S16SYS:
             fs_format = FSSF_S16;
-            bytes = 2;
-            format = 1;
             break;
         case AUDIO_S32SYS:
             fs_format = FSSF_S32;
-            bytes = 4;
-            format = 1;
             break;
         case AUDIO_F32SYS:
             fs_format = FSSF_FLOAT;
-            bytes = 4;
-            format = 1;
             break;
         default:
-            format = 0;
-            break;
-        }
-        if (!format) {
-            test_format = SDL_NextAudioFormat();
+            continue;
         }
+        break;
     }
 
-    if (format == 0) {
-        return SDL_SetError("Couldn't find any hardware audio formats");
+    if (!test_format) {
+        return SDL_SetError("%s: Unsupported audio format", "fusionsound");
     }
     this->spec.format = test_format;
+    bytes = SDL_AUDIO_BITSIZE(test_format) / 8;
 
     /* Retrieve the main sound interface. */
     ret = SDL_NAME(FusionSoundCreate) (&this->hidden->fs);
@@ -288,11 +277,11 @@ SDL_FS_Deinitialize(void)
 }
 
 
-static int
+static SDL_bool
 SDL_FS_Init(SDL_AudioDriverImpl * impl)
 {
     if (LoadFusionSoundLibrary() < 0) {
-        return 0;
+        return SDL_FALSE;
     } else {
         DirectResult ret;
 
@@ -302,7 +291,7 @@ SDL_FS_Init(SDL_AudioDriverImpl * impl)
             SDL_SetError
                 ("FusionSound: SDL_FS_init failed (FusionSoundInit: %d)",
                  ret);
-            return 0;
+            return SDL_FALSE;
         }
     }
 
@@ -313,14 +302,14 @@ SDL_FS_Init(SDL_AudioDriverImpl * impl)
     impl->GetDeviceBuf = SDL_FS_GetDeviceBuf;
     impl->CloseDevice = SDL_FS_CloseDevice;
     impl->Deinitialize = SDL_FS_Deinitialize;
-    impl->OnlyHasDefaultOutputDevice = 1;
+    impl->OnlyHasDefaultOutputDevice = SDL_TRUE;
 
-    return 1;   /* this audio target is available. */
+    return SDL_TRUE;   /* this audio target is available. */
 }
 
 
 AudioBootStrap FUSIONSOUND_bootstrap = {
-    "fusionsound", "FusionSound", SDL_FS_Init, 0
+    "fusionsound", "FusionSound", SDL_FS_Init, SDL_FALSE
 };
 
 #endif /* SDL_AUDIO_DRIVER_FUSIONSOUND */
diff --git a/Engine/lib/sdl/src/audio/fusionsound/SDL_fsaudio.h b/Engine/lib/sdl/src/audio/fusionsound/SDL_fsaudio.h
index 90a464295..2e7a59bcf 100644
--- a/Engine/lib/sdl/src/audio/fusionsound/SDL_fsaudio.h
+++ b/Engine/lib/sdl/src/audio/fusionsound/SDL_fsaudio.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/audio/haiku/SDL_haikuaudio.cc b/Engine/lib/sdl/src/audio/haiku/SDL_haikuaudio.cc
index 318ebccd1..bb6b78c1d 100644
--- a/Engine/lib/sdl/src/audio/haiku/SDL_haikuaudio.cc
+++ b/Engine/lib/sdl/src/audio/haiku/SDL_haikuaudio.cc
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -120,11 +120,10 @@ UnmaskSignals(sigset_t * omask)
 
 
 static int
-HAIKUAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
+HAIKUAUDIO_OpenDevice(_THIS, const char *devname)
 {
-    int valid_datatype = 0;
     media_raw_audio_format format;
-    SDL_AudioFormat test_format = SDL_FirstAudioFormat(_this->spec.format);
+    SDL_AudioFormat test_format;
 
     /* Initialize all variables that we clean on shutdown */
     _this->hidden = new SDL_PrivateAudioData;
@@ -138,9 +137,7 @@ HAIKUAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
     format.byte_order = B_MEDIA_LITTLE_ENDIAN;
     format.frame_rate = (float) _this->spec.freq;
     format.channel_count = _this->spec.channels;        /* !!! FIXME: support > 2? */
-    while ((!valid_datatype) && (test_format)) {
-        valid_datatype = 1;
-        _this->spec.format = test_format;
+    for (test_format = SDL_FirstAudioFormat(_this->spec.format); test_format; test_format = SDL_NextAudioFormat()) {
         switch (test_format) {
         case AUDIO_S8:
             format.format = media_raw_audio_format::B_AUDIO_CHAR;
@@ -178,15 +175,15 @@ HAIKUAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
             break;
 
         default:
-            valid_datatype = 0;
-            test_format = SDL_NextAudioFormat();
-            break;
+            continue;
         }
+        break;
     }
 
-    if (!valid_datatype) {      /* shouldn't happen, but just in case... */
-        return SDL_SetError("Unsupported audio format");
+    if (!test_format) {      /* shouldn't happen, but just in case... */
+        return SDL_SetError("%s: Unsupported audio format", "haiku");
     }
+    _this->spec.format = test_format;
 
     /* Calculate the final parameters for this audio specification */
     SDL_CalculateAudioSpec(&_this->spec);
@@ -216,22 +213,22 @@ HAIKUAUDIO_Deinitialize(void)
     SDL_QuitBeApp();
 }
 
-static int
+static SDL_bool
 HAIKUAUDIO_Init(SDL_AudioDriverImpl * impl)
 {
     /* Initialize the Be Application, if it's not already started */
     if (SDL_InitBeApp() < 0) {
-        return 0;
+        return SDL_FALSE;
     }
 
     /* Set the function pointers */
     impl->OpenDevice = HAIKUAUDIO_OpenDevice;
     impl->CloseDevice = HAIKUAUDIO_CloseDevice;
     impl->Deinitialize = HAIKUAUDIO_Deinitialize;
-    impl->ProvidesOwnCallbackThread = 1;
-    impl->OnlyHasDefaultOutputDevice = 1;
+    impl->ProvidesOwnCallbackThread = SDL_TRUE;
+    impl->OnlyHasDefaultOutputDevice = SDL_TRUE;
 
-    return 1;   /* this audio target is available. */
+    return SDL_TRUE;   /* this audio target is available. */
 }
 
 extern "C"
@@ -239,7 +236,7 @@ extern "C"
     extern AudioBootStrap HAIKUAUDIO_bootstrap;
 }
 AudioBootStrap HAIKUAUDIO_bootstrap = {
-    "haiku", "Haiku BSoundPlayer", HAIKUAUDIO_Init, 0
+    "haiku", "Haiku BSoundPlayer", HAIKUAUDIO_Init, SDL_FALSE
 };
 
 #endif /* SDL_AUDIO_DRIVER_HAIKU */
diff --git a/Engine/lib/sdl/src/audio/haiku/SDL_haikuaudio.h b/Engine/lib/sdl/src/audio/haiku/SDL_haikuaudio.h
index 1623cef01..91cc2843f 100644
--- a/Engine/lib/sdl/src/audio/haiku/SDL_haikuaudio.h
+++ b/Engine/lib/sdl/src/audio/haiku/SDL_haikuaudio.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/audio/jack/SDL_jackaudio.c b/Engine/lib/sdl/src/audio/jack/SDL_jackaudio.c
index ede60997f..f6e7e0cd3 100644
--- a/Engine/lib/sdl/src/audio/jack/SDL_jackaudio.c
+++ b/Engine/lib/sdl/src/audio/jack/SDL_jackaudio.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -280,12 +280,13 @@ JACK_CloseDevice(_THIS)
 }
 
 static int
-JACK_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
+JACK_OpenDevice(_THIS, const char *devname)
 {
     /* Note that JACK uses "output" for capture devices (they output audio
         data to us) and "input" for playback (we input audio data to them).
         Likewise, SDL's playback port will be "output" (we write data out)
         and capture will be "input" (we read data in). */
+    SDL_bool iscapture = this->iscapture;
     const unsigned long sysportflags = iscapture ? JackPortIsOutput : JackPortIsInput;
     const unsigned long sdlportflags = iscapture ? JackPortIsInput : JackPortIsOutput;
     const JackProcessCallback callback = iscapture ? jackProcessCaptureCallback : jackProcessPlaybackCallback;
@@ -405,18 +406,18 @@ JACK_Deinitialize(void)
     UnloadJackLibrary();
 }
 
-static int
+static SDL_bool
 JACK_Init(SDL_AudioDriverImpl * impl)
 {
     if (LoadJackLibrary() < 0) {
-        return 0;
+        return SDL_FALSE;
     } else {
         /* Make sure a JACK server is running and available. */
         jack_status_t status;
         jack_client_t *client = JACK_jack_client_open("SDL", JackNoStartServer, &status, NULL);
         if (client == NULL) {
             UnloadJackLibrary();
-            return 0;
+            return SDL_FALSE;
         }
         JACK_jack_client_close(client);
     }
@@ -433,11 +434,11 @@ JACK_Init(SDL_AudioDriverImpl * impl)
     impl->OnlyHasDefaultCaptureDevice = SDL_TRUE;
     impl->HasCaptureSupport = SDL_TRUE;
 
-    return 1;   /* this audio target is available. */
+    return SDL_TRUE;   /* this audio target is available. */
 }
 
 AudioBootStrap JACK_bootstrap = {
-    "jack", "JACK Audio Connection Kit", JACK_Init, 0
+    "jack", "JACK Audio Connection Kit", JACK_Init, SDL_FALSE
 };
 
 #endif /* SDL_AUDIO_DRIVER_JACK */
diff --git a/Engine/lib/sdl/src/audio/jack/SDL_jackaudio.h b/Engine/lib/sdl/src/audio/jack/SDL_jackaudio.h
index 254d099e9..a552e8199 100644
--- a/Engine/lib/sdl/src/audio/jack/SDL_jackaudio.h
+++ b/Engine/lib/sdl/src/audio/jack/SDL_jackaudio.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/audio/nacl/SDL_naclaudio.c b/Engine/lib/sdl/src/audio/nacl/SDL_naclaudio.c
index 4caa65242..bf48165f5 100644
--- a/Engine/lib/sdl/src/audio/nacl/SDL_naclaudio.c
+++ b/Engine/lib/sdl/src/audio/nacl/SDL_naclaudio.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -99,7 +99,7 @@ static void NACLAUDIO_CloseDevice(SDL_AudioDevice *device) {
 }
 
 static int
-NACLAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture) {
+NACLAUDIO_OpenDevice(_THIS, const char *devname) {
     PP_Instance instance = PSGetInstanceId();
     const PPB_Audio *ppb_audio = PSInterfaceAudio();
     const PPB_AudioConfig *ppb_audiocfg = PSInterfaceAudioConfig();
@@ -133,18 +133,18 @@ NACLAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture) {
     return 0;
 }
 
-static int
+static SDL_bool
 NACLAUDIO_Init(SDL_AudioDriverImpl * impl)
 {
     if (PSGetInstanceId() == 0) {
-        return 0;
+        return SDL_FALSE;
     }
     
     /* Set the function pointers */
     impl->OpenDevice = NACLAUDIO_OpenDevice;
     impl->CloseDevice = NACLAUDIO_CloseDevice;
-    impl->OnlyHasDefaultOutputDevice = 1;
-    impl->ProvidesOwnCallbackThread = 1;
+    impl->OnlyHasDefaultOutputDevice = SDL_TRUE;
+    impl->ProvidesOwnCallbackThread = SDL_TRUE;
     /*
      *    impl->WaitDevice = NACLAUDIO_WaitDevice;
      *    impl->GetDeviceBuf = NACLAUDIO_GetDeviceBuf;
@@ -152,12 +152,12 @@ NACLAUDIO_Init(SDL_AudioDriverImpl * impl)
      *    impl->Deinitialize = NACLAUDIO_Deinitialize;
      */
     
-    return 1;
+    return SDL_TRUE;
 }
 
 AudioBootStrap NACLAUDIO_bootstrap = {
     NACLAUDIO_DRIVER_NAME, "SDL NaCl Audio Driver",
-    NACLAUDIO_Init, 0
+    NACLAUDIO_Init, SDL_FALSE
 };
 
 #endif /* SDL_AUDIO_DRIVER_NACL */
diff --git a/Engine/lib/sdl/src/audio/nacl/SDL_naclaudio.h b/Engine/lib/sdl/src/audio/nacl/SDL_naclaudio.h
index c1ef0d738..8348a34e8 100644
--- a/Engine/lib/sdl/src/audio/nacl/SDL_naclaudio.h
+++ b/Engine/lib/sdl/src/audio/nacl/SDL_naclaudio.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/audio/nas/SDL_nasaudio.c b/Engine/lib/sdl/src/audio/nas/SDL_nasaudio.c
index 042e0894c..d6d863232 100644
--- a/Engine/lib/sdl/src/audio/nas/SDL_nasaudio.c
+++ b/Engine/lib/sdl/src/audio/nas/SDL_nasaudio.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -113,11 +113,11 @@ LoadNASLibrary(void)
             /* Copy error string so we can use it in a new SDL_SetError(). */
             const char *origerr = SDL_GetError();
             const size_t len = SDL_strlen(origerr) + 1;
-            char *err = (char *) alloca(len);
+            char *err = SDL_stack_alloc(char, len);
             SDL_strlcpy(err, origerr, len);
+            SDL_SetError("NAS: SDL_LoadObject('%s') failed: %s", nas_library, err);
+            SDL_stack_free(err);
             retval = -1;
-            SDL_SetError("NAS: SDL_LoadObject('%s') failed: %s",
-                         nas_library, err);
         } else {
             retval = load_nas_syms();
             if (retval < 0) {
@@ -237,26 +237,6 @@ NAS_CloseDevice(_THIS)
     SDL_free(this->hidden);
 }
 
-static unsigned char
-sdlformat_to_auformat(unsigned int fmt)
-{
-    switch (fmt) {
-    case AUDIO_U8:
-        return AuFormatLinearUnsigned8;
-    case AUDIO_S8:
-        return AuFormatLinearSigned8;
-    case AUDIO_U16LSB:
-        return AuFormatLinearUnsigned16LSB;
-    case AUDIO_U16MSB:
-        return AuFormatLinearUnsigned16MSB;
-    case AUDIO_S16LSB:
-        return AuFormatLinearSigned16LSB;
-    case AUDIO_S16MSB:
-        return AuFormatLinearSigned16MSB;
-    }
-    return AuNone;
-}
-
 static AuBool
 event_handler(AuServer * aud, AuEvent * ev, AuEventHandlerRec * hnd)
 {
@@ -331,11 +311,12 @@ find_device(_THIS)
 }
 
 static int
-NAS_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
+NAS_OpenDevice(_THIS, const char *devname)
 {
     AuElement elms[3];
     int buffer_size;
-    SDL_AudioFormat test_format, format;
+    SDL_bool iscapture = this->iscapture;
+    SDL_AudioFormat test_format, format = 0;
 
     /* Initialize all variables that we clean on shutdown */
     this->hidden = (struct SDL_PrivateAudioData *)
@@ -346,16 +327,33 @@ NAS_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
     SDL_zerop(this->hidden);
 
     /* Try for a closest match on audio format */
-    format = 0;
-    for (test_format = SDL_FirstAudioFormat(this->spec.format);
-         !format && test_format;) {
-        format = sdlformat_to_auformat(test_format);
-        if (format == AuNone) {
-            test_format = SDL_NextAudioFormat();
+    for (test_format = SDL_FirstAudioFormat(this->spec.format); test_format; test_format = SDL_NextAudioFormat()) {
+        switch (test_format) {
+        case AUDIO_U8:
+            format = AuFormatLinearUnsigned8;
+            break;
+        case AUDIO_S8:
+            format = AuFormatLinearSigned8;
+            break;
+        case AUDIO_U16LSB:
+            format = AuFormatLinearUnsigned16LSB;
+            break;
+        case AUDIO_U16MSB:
+            format = AuFormatLinearUnsigned16MSB;
+            break;
+        case AUDIO_S16LSB:
+            format = AuFormatLinearSigned16LSB;
+            break;
+        case AUDIO_S16MSB:
+            format = AuFormatLinearSigned16MSB;
+            break;
+        default:
+            continue;
         }
+        break;
     }
-    if (format == 0) {
-        return SDL_SetError("NAS: Couldn't find any hardware audio formats");
+    if (!test_format) {
+        return SDL_SetError("%s: Unsupported audio format", "nas");
     }
     this->spec.format = test_format;
 
@@ -423,16 +421,16 @@ NAS_Deinitialize(void)
     UnloadNASLibrary();
 }
 
-static int
+static SDL_bool
 NAS_Init(SDL_AudioDriverImpl * impl)
 {
     if (LoadNASLibrary() < 0) {
-        return 0;
+        return SDL_FALSE;
     } else {
         AuServer *aud = NAS_AuOpenServer("", 0, NULL, 0, NULL, NULL);
         if (aud == NULL) {
             SDL_SetError("NAS: AuOpenServer() failed (no audio server?)");
-            return 0;
+            return SDL_FALSE;
         }
         NAS_AuCloseServer(aud);
     }
@@ -447,15 +445,15 @@ NAS_Init(SDL_AudioDriverImpl * impl)
     impl->CloseDevice = NAS_CloseDevice;
     impl->Deinitialize = NAS_Deinitialize;
 
-    impl->OnlyHasDefaultOutputDevice = 1;
-    impl->OnlyHasDefaultCaptureDevice = 1;
+    impl->OnlyHasDefaultOutputDevice = SDL_TRUE;
+    impl->OnlyHasDefaultCaptureDevice = SDL_TRUE;
     impl->HasCaptureSupport = SDL_TRUE;
 
-    return 1;   /* this audio target is available. */
+    return SDL_TRUE;   /* this audio target is available. */
 }
 
 AudioBootStrap NAS_bootstrap = {
-    "nas", "Network Audio System", NAS_Init, 0
+    "nas", "Network Audio System", NAS_Init, SDL_FALSE
 };
 
 #endif /* SDL_AUDIO_DRIVER_NAS */
diff --git a/Engine/lib/sdl/src/audio/nas/SDL_nasaudio.h b/Engine/lib/sdl/src/audio/nas/SDL_nasaudio.h
index 3e2811887..7c9506d91 100644
--- a/Engine/lib/sdl/src/audio/nas/SDL_nasaudio.h
+++ b/Engine/lib/sdl/src/audio/nas/SDL_nasaudio.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/audio/netbsd/SDL_netbsdaudio.c b/Engine/lib/sdl/src/audio/netbsd/SDL_netbsdaudio.c
index c23a877f9..6ff81578a 100644
--- a/Engine/lib/sdl/src/audio/netbsd/SDL_netbsdaudio.c
+++ b/Engine/lib/sdl/src/audio/netbsd/SDL_netbsdaudio.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -202,10 +202,12 @@ NETBSDAUDIO_CloseDevice(_THIS)
 }
 
 static int
-NETBSDAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
+NETBSDAUDIO_OpenDevice(_THIS, const char *devname)
 {
-    SDL_AudioFormat format = 0;
-    audio_info_t info;
+    SDL_bool iscapture = this->iscapture;
+    SDL_AudioFormat test_format;
+    int encoding = AUDIO_ENCODING_NONE;
+    audio_info_t info, hwinfo;
     struct audio_prinfo *prinfo = iscapture ? &info.record : &info.play;
 
     /* We don't care what the devname is...we'll try to open anything. */
@@ -226,77 +228,82 @@ NETBSDAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
     SDL_zerop(this->hidden);
 
     /* Open the audio device */
-    this->hidden->audio_fd = open(devname, iscapture ? O_RDONLY : O_WRONLY);
+    this->hidden->audio_fd = open(devname, (iscapture ? O_RDONLY : O_WRONLY) | O_CLOEXEC);
     if (this->hidden->audio_fd < 0) {
         return SDL_SetError("Couldn't open %s: %s", devname, strerror(errno));
     }
 
     AUDIO_INITINFO(&info);
 
-    prinfo->encoding = AUDIO_ENCODING_NONE;
-
-    for (format = SDL_FirstAudioFormat(this->spec.format); format;) {
-        switch (format) {
-        case AUDIO_U8:
-            prinfo->encoding = AUDIO_ENCODING_ULINEAR;
-            prinfo->precision = 8;
-            break;
-        case AUDIO_S8:
-            prinfo->encoding = AUDIO_ENCODING_SLINEAR;
-            prinfo->precision = 8;
-            break;
-        case AUDIO_S16LSB:
-            prinfo->encoding = AUDIO_ENCODING_SLINEAR_LE;
-            prinfo->precision = 16;
-            break;
-        case AUDIO_S16MSB:
-            prinfo->encoding = AUDIO_ENCODING_SLINEAR_BE;
-            prinfo->precision = 16;
-            break;
-        case AUDIO_U16LSB:
-            prinfo->encoding = AUDIO_ENCODING_ULINEAR_LE;
-            prinfo->precision = 16;
-            break;
-        case AUDIO_U16MSB:
-            prinfo->encoding = AUDIO_ENCODING_ULINEAR_BE;
-            prinfo->precision = 16;
-            break;
-        case AUDIO_S32LSB:
-            prinfo->encoding = AUDIO_ENCODING_SLINEAR_LE;
-            prinfo->precision = 32;
-            break;
-        case AUDIO_S32MSB:
-            prinfo->encoding = AUDIO_ENCODING_SLINEAR_BE;
-            prinfo->precision = 32;
-            break;
-        }
-        if (prinfo->encoding != AUDIO_ENCODING_NONE) {
-            break;
-        }
-        format = SDL_NextAudioFormat();
+#ifdef AUDIO_GETFORMAT /* Introduced in NetBSD 9.0 */
+    if (ioctl(this->hidden->audio_fd, AUDIO_GETFORMAT, &hwinfo) != -1) {
+        /*
+         * Use the device's native sample rate so the kernel doesn't have to
+         * resample.
+         */
+        this->spec.freq = iscapture ?
+            hwinfo.record.sample_rate : hwinfo.play.sample_rate;
     }
+#endif
 
-    if (prinfo->encoding == AUDIO_ENCODING_NONE) {
-        return SDL_SetError("No supported encoding for 0x%x", this->spec.format);
-    }
-
-    this->spec.format = format;
-
-    /* Calculate spec parameters based on our chosen format */
-    SDL_CalculateAudioSpec(&this->spec);
-
-    info.mode = iscapture ? AUMODE_RECORD : AUMODE_PLAY;
-    info.blocksize = this->spec.size;
-    info.hiwat = 5;
-    info.lowat = 3;
     prinfo->sample_rate = this->spec.freq;
     prinfo->channels = this->spec.channels;
-    (void) ioctl(this->hidden->audio_fd, AUDIO_SETINFO, &info);
 
-    (void) ioctl(this->hidden->audio_fd, AUDIO_GETINFO, &info);
+    for (test_format = SDL_FirstAudioFormat(this->spec.format); test_format; test_format = SDL_NextAudioFormat()) {
+        switch (test_format) {
+        case AUDIO_U8:
+            encoding = AUDIO_ENCODING_ULINEAR;
+            break;
+        case AUDIO_S8:
+            encoding = AUDIO_ENCODING_SLINEAR;
+            break;
+        case AUDIO_S16LSB:
+            encoding = AUDIO_ENCODING_SLINEAR_LE;
+            break;
+        case AUDIO_S16MSB:
+            encoding = AUDIO_ENCODING_SLINEAR_BE;
+            break;
+        case AUDIO_U16LSB:
+            encoding = AUDIO_ENCODING_ULINEAR_LE;
+            break;
+        case AUDIO_U16MSB:
+            encoding = AUDIO_ENCODING_ULINEAR_BE;
+            break;
+        case AUDIO_S32LSB:
+            encoding = AUDIO_ENCODING_SLINEAR_LE;
+            break;
+        case AUDIO_S32MSB:
+            encoding = AUDIO_ENCODING_SLINEAR_BE;
+            break;
+        default:
+            continue;
+        }
+        break;
+    }
+
+    if (!test_format) {
+        return SDL_SetError("%s: Unsupported audio format", "netbsd");
+    }
+    prinfo->encoding = encoding;
+    prinfo->precision = SDL_AUDIO_BITSIZE(test_format);
+
+    info.hiwat = 5;
+    info.lowat = 3;
+    if (ioctl(this->hidden->audio_fd, AUDIO_SETINFO, &info) < 0) {
+        return SDL_SetError("AUDIO_SETINFO failed for %s: %s", devname, strerror(errno));
+    }
+
+    if (ioctl(this->hidden->audio_fd, AUDIO_GETINFO, &info) < 0) {
+        return SDL_SetError("AUDIO_GETINFO failed for %s: %s", devname, strerror(errno));
+    }
+
+    /* Final spec used for the device. */
+    this->spec.format = test_format;
     this->spec.freq = prinfo->sample_rate;
     this->spec.channels = prinfo->channels;
 
+    SDL_CalculateAudioSpec(&this->spec);
+
     if (!iscapture) {
         /* Allocate mixing buffer */
         this->hidden->mixlen = this->spec.size;
@@ -313,7 +320,7 @@ NETBSDAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
     return 0;
 }
 
-static int
+static SDL_bool
 NETBSDAUDIO_Init(SDL_AudioDriverImpl * impl)
 {
     /* Set the function pointers */
@@ -326,14 +333,14 @@ NETBSDAUDIO_Init(SDL_AudioDriverImpl * impl)
     impl->FlushCapture = NETBSDAUDIO_FlushCapture;
 
     impl->HasCaptureSupport = SDL_TRUE;
-    impl->AllowsArbitraryDeviceNames = 1;
+    impl->AllowsArbitraryDeviceNames = SDL_TRUE;
 
-    return 1;   /* this audio target is available. */
+    return SDL_TRUE;   /* this audio target is available. */
 }
 
 
 AudioBootStrap NETBSDAUDIO_bootstrap = {
-    "netbsd", "NetBSD audio", NETBSDAUDIO_Init, 0
+    "netbsd", "NetBSD audio", NETBSDAUDIO_Init, SDL_FALSE
 };
 
 #endif /* SDL_AUDIO_DRIVER_NETBSD */
diff --git a/Engine/lib/sdl/src/audio/netbsd/SDL_netbsdaudio.h b/Engine/lib/sdl/src/audio/netbsd/SDL_netbsdaudio.h
index cc58fec69..862d431b6 100644
--- a/Engine/lib/sdl/src/audio/netbsd/SDL_netbsdaudio.h
+++ b/Engine/lib/sdl/src/audio/netbsd/SDL_netbsdaudio.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/audio/openslES/SDL_openslES.c b/Engine/lib/sdl/src/audio/openslES/SDL_openslES.c
index 531d595e9..39d64b2b6 100644
--- a/Engine/lib/sdl/src/audio/openslES/SDL_openslES.c
+++ b/Engine/lib/sdl/src/audio/openslES/SDL_openslES.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -75,24 +75,24 @@
 #define SL_ANDROID_SPEAKER_7DOT1 (SL_ANDROID_SPEAKER_5DOT1 | SL_SPEAKER_SIDE_LEFT | SL_SPEAKER_SIDE_RIGHT)
 
 /* engine interfaces */
-static SLObjectItf engineObject;
-static SLEngineItf engineEngine;
+static SLObjectItf engineObject = NULL;
+static SLEngineItf engineEngine = NULL;
 
 /* output mix interfaces */
-static SLObjectItf outputMixObject;
+static SLObjectItf outputMixObject = NULL;
 
 /* buffer queue player interfaces */
-static SLObjectItf bqPlayerObject;
-static SLPlayItf bqPlayerPlay;
-static SLAndroidSimpleBufferQueueItf bqPlayerBufferQueue;
+static SLObjectItf bqPlayerObject = NULL;
+static SLPlayItf bqPlayerPlay = NULL;
+static SLAndroidSimpleBufferQueueItf bqPlayerBufferQueue = NULL;
 #if 0
 static SLVolumeItf bqPlayerVolume;
 #endif
 
 /* recorder interfaces */
-static SLObjectItf recorderObject;
-static SLRecordItf recorderRecord;
-static SLAndroidSimpleBufferQueueItf recorderBufferQueue;
+static SLObjectItf recorderObject = NULL;
+static SLRecordItf recorderRecord = NULL;
+static SLAndroidSimpleBufferQueueItf recorderBufferQueue = NULL;
 
 #if 0
 static const char *sldevaudiorecorderstr = "SLES Audio Recorder";
@@ -355,8 +355,6 @@ openslES_CreatePCMRecorder(_THIS)
 
 failed:
 
-    openslES_DestroyPCMRecorder(this);
-
     return SDL_SetError("Open device failed!");
 }
 
@@ -409,6 +407,7 @@ openslES_CreatePCMPlayer(_THIS)
 {
     struct SDL_PrivateAudioData *audiodata = this->hidden;
     SLDataFormat_PCM format_pcm;
+    SLAndroidDataFormat_PCM_EX format_pcm_ex;
     SLresult result;
     int i;
 
@@ -416,31 +415,30 @@ openslES_CreatePCMPlayer(_THIS)
        it can be done as described here:
         https://developer.android.com/ndk/guides/audio/opensl/android-extensions.html#floating-point
     */
-#if 1
-    /* Just go with signed 16-bit audio as it's the most compatible */
-    this->spec.format = AUDIO_S16SYS;
-#else
-    SDL_AudioFormat test_format = SDL_FirstAudioFormat(this->spec.format);
-    while (test_format != 0) {
-        if (SDL_AUDIO_ISSIGNED(test_format) && SDL_AUDIO_ISINT(test_format)) {
-            break;
+    if(SDL_GetAndroidSDKVersion() >= 21) {
+        SDL_AudioFormat test_format;
+        for (test_format = SDL_FirstAudioFormat(this->spec.format); test_format; test_format = SDL_NextAudioFormat()) {
+            if (SDL_AUDIO_ISSIGNED(test_format)) {
+                break;
+            }
         }
-        test_format = SDL_NextAudioFormat();
-    }
 
-    if (test_format == 0) {
-        /* Didn't find a compatible format : */
-        LOGI( "No compatible audio format, using signed 16-bit audio" );
-        test_format = AUDIO_S16SYS;
+        if (!test_format) {
+            /* Didn't find a compatible format : */
+            LOGI( "No compatible audio format, using signed 16-bit audio" );
+            test_format = AUDIO_S16SYS;
+        }
+        this->spec.format = test_format;
+    } else {
+        /* Just go with signed 16-bit audio as it's the most compatible */
+        this->spec.format = AUDIO_S16SYS;
     }
-    this->spec.format = test_format;
-#endif
 
     /* Update the fragment size as size in bytes */
     SDL_CalculateAudioSpec(&this->spec);
 
-    LOGI("Try to open %u hz %u bit chan %u %s samples %u",
-          this->spec.freq, SDL_AUDIO_BITSIZE(this->spec.format),
+    LOGI("Try to open %u hz %s %u bit chan %u %s samples %u",
+          this->spec.freq, SDL_AUDIO_ISFLOAT(this->spec.format) ? "float" : "pcm", SDL_AUDIO_BITSIZE(this->spec.format),
           this->spec.channels, (this->spec.format & 0x1000) ? "BE" : "LE", this->spec.samples);
 
     /* configure audio source */
@@ -491,7 +489,19 @@ openslES_CreatePCMPlayer(_THIS)
         break;
     }
 
-    SLDataSource audioSrc = { &loc_bufq, &format_pcm };
+    if(SDL_AUDIO_ISFLOAT(this->spec.format)) {
+        /* Copy all setup into PCM EX structure */
+        format_pcm_ex.formatType = SL_ANDROID_DATAFORMAT_PCM_EX;
+        format_pcm_ex.endianness = format_pcm.endianness;
+        format_pcm_ex.channelMask = format_pcm.channelMask;
+        format_pcm_ex.numChannels = format_pcm.numChannels;
+        format_pcm_ex.sampleRate = format_pcm.samplesPerSec;
+        format_pcm_ex.bitsPerSample = format_pcm.bitsPerSample;
+        format_pcm_ex.containerSize = format_pcm.containerSize;
+        format_pcm_ex.representation = SL_ANDROID_PCM_REPRESENTATION_FLOAT;
+    }
+
+    SLDataSource audioSrc = { &loc_bufq, SDL_AUDIO_ISFLOAT(this->spec.format) ? (void*)&format_pcm_ex : (void*)&format_pcm };
 
     /* configure audio sink */
     SLDataLocator_OutputMix loc_outmix = { SL_DATALOCATOR_OUTPUTMIX, outputMixObject };
@@ -581,25 +591,39 @@ openslES_CreatePCMPlayer(_THIS)
 
 failed:
 
-    openslES_DestroyPCMPlayer(this);
-
-    return SDL_SetError("Open device failed!");
+    return -1;
 }
 
 static int
-openslES_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
+openslES_OpenDevice(_THIS, const char *devname)
 {
     this->hidden = (struct SDL_PrivateAudioData *) SDL_calloc(1, (sizeof *this->hidden));
     if (this->hidden == NULL) {
         return SDL_OutOfMemory();
     }
 
-    if (iscapture) {
+    if (this->iscapture) {
         LOGI("openslES_OpenDevice() %s for capture", devname);
         return openslES_CreatePCMRecorder(this);
     } else {
+        int ret;
         LOGI("openslES_OpenDevice() %s for playing", devname);
-        return openslES_CreatePCMPlayer(this);
+        ret = openslES_CreatePCMPlayer(this);
+        if (ret < 0) {
+            /* Another attempt to open the device with a lower frequency */
+            if (this->spec.freq > 48000) {
+                openslES_DestroyPCMPlayer(this);
+                this->spec.freq = 48000;
+                ret = openslES_CreatePCMPlayer(this);
+            }
+        }
+
+        if (ret == 0) {
+            return 0;
+        } else {
+            return SDL_SetError("Open device failed!");
+        }
+
     }
 }
 
@@ -702,13 +726,13 @@ openslES_CloseDevice(_THIS)
     SDL_free(this->hidden);
 }
 
-static int
+static SDL_bool
 openslES_Init(SDL_AudioDriverImpl * impl)
 {
     LOGI("openslES_Init() called");
 
     if (!openslES_CreateEngine()) {
-        return 0;
+        return SDL_FALSE;
     }
 
     LOGI("openslES_Init() - set pointers");
@@ -724,18 +748,18 @@ openslES_Init(SDL_AudioDriverImpl * impl)
     impl->Deinitialize  = openslES_DestroyEngine;
 
     /* and the capabilities */
-    impl->HasCaptureSupport = 1;
-    impl->OnlyHasDefaultOutputDevice = 1;
-    impl->OnlyHasDefaultCaptureDevice = 1;
+    impl->HasCaptureSupport = SDL_TRUE;
+    impl->OnlyHasDefaultOutputDevice = SDL_TRUE;
+    impl->OnlyHasDefaultCaptureDevice = SDL_TRUE;
 
     LOGI("openslES_Init() - success");
 
     /* this audio target is available. */
-    return 1;
+    return SDL_TRUE;
 }
 
 AudioBootStrap openslES_bootstrap = {
-    "openslES", "opensl ES audio driver", openslES_Init, 0
+    "openslES", "opensl ES audio driver", openslES_Init, SDL_FALSE
 };
 
 void openslES_ResumeDevices(void)
diff --git a/Engine/lib/sdl/src/audio/openslES/SDL_openslES.h b/Engine/lib/sdl/src/audio/openslES/SDL_openslES.h
index 542870aeb..10ff588a1 100644
--- a/Engine/lib/sdl/src/audio/openslES/SDL_openslES.h
+++ b/Engine/lib/sdl/src/audio/openslES/SDL_openslES.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/audio/os2/SDL_os2audio.c b/Engine/lib/sdl/src/audio/os2/SDL_os2audio.c
index 4a8017d6c..9ddfb7607 100644
--- a/Engine/lib/sdl/src/audio/os2/SDL_os2audio.c
+++ b/Engine/lib/sdl/src/audio/os2/SDL_os2audio.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -42,36 +42,36 @@ void lockDecr(volatile int *piVal);
   parm [eax];
 */
 
-static ULONG _getEnvULong(PSZ pszName, ULONG ulMax, ULONG ulDefault)
+static ULONG _getEnvULong(const char *name, ULONG ulMax, ULONG ulDefault)
 {
     ULONG   ulValue;
-    PCHAR   pcEnd;
-    PSZ     pszEnvVal = SDL_getenv(pszName);
+    char*   end;
+    char*   envval = SDL_getenv(name);
 
-    if (pszEnvVal == NULL)
+    if (envval == NULL)
         return ulDefault;
 
-    ulValue = SDL_strtoul((const char *)pszEnvVal, &pcEnd, 10);
-    return (pcEnd == pszEnvVal) || (ulValue > ulMax)? ulDefault : ulMax;
+    ulValue = SDL_strtoul(envval, &end, 10);
+    return (end == envval) || (ulValue > ulMax)? ulDefault : ulMax;
 }
 
-static int _MCIError(PSZ pszFunc, ULONG ulResult)
+static int _MCIError(const char *func, ULONG ulResult)
 {
     CHAR    acBuf[128];
     mciGetErrorString(ulResult, acBuf, sizeof(acBuf));
-    return SDL_SetError("[%s] %s", pszFunc, acBuf);
+    return SDL_SetError("[%s] %s", func, acBuf);
 }
 
-static void _mixIOError(PSZ pszFunction, ULONG ulRC)
+static void _mixIOError(const char *function, ULONG ulRC)
 {
     debug_os2("%s() - failed, rc = 0x%X (%s)",
-              pszFunction, ulRC,
+              function, ulRC,
               (ulRC == MCIERR_INVALID_MODE)   ? "Mixer mode does not match request" :
               (ulRC == MCIERR_INVALID_BUFFER) ? "Caller sent an invalid buffer"     : "unknown");
 }
 
-LONG APIENTRY cbAudioWriteEvent(ULONG ulStatus, PMCI_MIX_BUFFER pBuffer,
-                                ULONG ulFlags)
+static LONG APIENTRY cbAudioWriteEvent(ULONG ulStatus, PMCI_MIX_BUFFER pBuffer,
+                                       ULONG ulFlags)
 {
     SDL_PrivateAudioData *pAData = (SDL_PrivateAudioData *)pBuffer->ulUserParm;
     ULONG   ulRC;
@@ -87,11 +87,11 @@ LONG APIENTRY cbAudioWriteEvent(ULONG ulStatus, PMCI_MIX_BUFFER pBuffer,
         debug_os2("DosPostEventSem(), rc = %u", ulRC);
     }
 
-    return 1; /* It seems, return value is not matter. */
+    return 1; /* return value doesn't seem to matter. */
 }
 
-LONG APIENTRY cbAudioReadEvent(ULONG ulStatus, PMCI_MIX_BUFFER pBuffer,
-                               ULONG ulFlags)
+static LONG APIENTRY cbAudioReadEvent(ULONG ulStatus, PMCI_MIX_BUFFER pBuffer,
+                                      ULONG ulFlags)
 {
     SDL_PrivateAudioData *pAData = (SDL_PrivateAudioData *)pBuffer->ulUserParm;
     ULONG   ulRC;
@@ -133,7 +133,7 @@ static void OS2_DetectDevices(void)
         return;
     }
 
-    ulDevicesNum = atol(stMCISysInfo.pszReturn);
+    ulDevicesNum = SDL_strtoul(stMCISysInfo.pszReturn, NULL, 10);
 
     for (stSysInfoParams.ulNumber = 0; stSysInfoParams.ulNumber < ulDevicesNum;
          stSysInfoParams.ulNumber++) {
@@ -151,7 +151,7 @@ static void OS2_DetectDevices(void)
         /* Get textual product description. */
         stSysInfoParams.ulItem = MCI_SYSINFO_QUERY_DRIVER;
         stSysInfoParams.pSysInfoParm = &stLogDevice;
-        strcpy(stLogDevice.szInstallName, stSysInfoParams.pszReturn);
+        SDL_strlcpy(stLogDevice.szInstallName, stSysInfoParams.pszReturn, MAX_DEVICE_NAME);
         ulRC = mciSendCommand(0, MCI_SYSINFO, MCI_WAIT | MCI_SYSINFO_ITEM,
                               &stSysInfoParams, 0);
         if (ulRC != NO_ERROR) {
@@ -160,9 +160,9 @@ static void OS2_DetectDevices(void)
         }
 
         ulHandle++;
-        SDL_AddAudioDevice(0, stLogDevice.szProductInfo, (void *)(ulHandle));
+        SDL_AddAudioDevice(0, stLogDevice.szProductInfo, NULL, (void *)(ulHandle));
         ulHandle++;
-        SDL_AddAudioDevice(1, stLogDevice.szProductInfo, (void *)(ulHandle));
+        SDL_AddAudioDevice(1, stLogDevice.szProductInfo, NULL, (void *)(ulHandle));
     }
 }
 
@@ -211,10 +211,8 @@ static void OS2_CloseDevice(_THIS)
         return;
 
     /* Close up audio */
-    if (pAData->usDeviceId != (USHORT)~0) {
-        /* Device is open. */
-        if (pAData->stMCIMixSetup.ulBitsPerSample != 0) {
-            /* Mixer was initialized. */
+    if (pAData->usDeviceId != (USHORT)~0) { /* Device is open. */
+        if (pAData->stMCIMixSetup.ulBitsPerSample != 0) { /* Mixer was initialized. */
             ulRC = mciSendCommand(pAData->usDeviceId, MCI_MIXSETUP,
                                   MCI_WAIT | MCI_MIXSETUP_DEINIT,
                                   &pAData->stMCIMixSetup, 0);
@@ -223,8 +221,7 @@ static void OS2_CloseDevice(_THIS)
             }
         }
 
-        if (pAData->cMixBuffers != 0) {
-            /* Buffers was allocated. */
+        if (pAData->cMixBuffers != 0) { /* Buffers was allocated. */
             MCI_BUFFER_PARMS    stMCIBuffer;
 
             stMCIBuffer.ulBufferSize = pAData->aMixBuffers[0].ulBufferLength;
@@ -251,29 +248,28 @@ static void OS2_CloseDevice(_THIS)
     SDL_free(pAData);
 }
 
-static int OS2_OpenDevice(_THIS, void *handle, const char *devname,
-                          int iscapture)
+static int OS2_OpenDevice(_THIS, const char *devname)
 {
     SDL_PrivateAudioData *pAData;
-    SDL_AudioFormat       SDLAudioFmt;
+    SDL_AudioFormat       test_format;
     MCI_AMP_OPEN_PARMS    stMCIAmpOpen;
     MCI_BUFFER_PARMS      stMCIBuffer;
     ULONG                 ulRC;
     ULONG                 ulIdx;
     BOOL                  new_freq;
+    SDL_bool              iscapture = _this->iscapture;
 
     new_freq = FALSE;
     SDL_zero(stMCIAmpOpen);
     SDL_zero(stMCIBuffer);
 
-    for (SDLAudioFmt = SDL_FirstAudioFormat(_this->spec.format);
-         SDLAudioFmt != 0; SDLAudioFmt = SDL_NextAudioFormat()) {
-        if (SDLAudioFmt == AUDIO_U8 || SDLAudioFmt == AUDIO_S16)
+    for (test_format = SDL_FirstAudioFormat(_this->spec.format); test_format; test_format = SDL_NextAudioFormat()) {
+        if (test_format == AUDIO_U8 || test_format == AUDIO_S16)
             break;
     }
-    if (SDLAudioFmt == 0) {
+    if (!test_format) {
         debug_os2("Unsupported audio format, AUDIO_S16 used");
-        SDLAudioFmt = AUDIO_S16;
+        test_format = AUDIO_S16;
     }
 
     pAData = (SDL_PrivateAudioData *) SDL_calloc(1, sizeof(struct SDL_PrivateAudioData));
@@ -288,7 +284,7 @@ static int OS2_OpenDevice(_THIS, void *handle, const char *devname,
     }
 
     /* Open audio device */
-    stMCIAmpOpen.usDeviceID = (handle != NULL) ? ((ULONG)handle - 1) : 0;
+    stMCIAmpOpen.usDeviceID = (_this->handle != NULL) ? ((ULONG)_this->handle - 1) : 0;
     stMCIAmpOpen.pszDeviceType = (PSZ)MCI_DEVTYPE_AUDIO_AMPMIX;
     ulRC = mciSendCommand(0, MCI_OPEN,
                           (_getEnvULong("SDL_AUDIO_SHARE", 1, 0) != 0)?
@@ -301,7 +297,7 @@ static int OS2_OpenDevice(_THIS, void *handle, const char *devname,
     }
     pAData->usDeviceId = stMCIAmpOpen.usDeviceID;
 
-    if (iscapture != 0) {
+    if (iscapture) {
         MCI_CONNECTOR_PARMS stMCIConnector;
         MCI_AMP_SET_PARMS   stMCIAmpSet;
         BOOL                fLineIn = _getEnvULong("SDL_AUDIO_LINEIN", 1, 0);
@@ -333,7 +329,7 @@ static int OS2_OpenDevice(_THIS, void *handle, const char *devname,
                        &stMCIAmpSet, 0);
     }
 
-    _this->spec.format = SDLAudioFmt;
+    _this->spec.format = test_format;
     _this->spec.channels = _this->spec.channels > 1 ? 2 : 1;
     if (_this->spec.freq < 8000) {
         _this->spec.freq = 8000;
@@ -345,11 +341,11 @@ static int OS2_OpenDevice(_THIS, void *handle, const char *devname,
 
     /* Setup mixer. */
     pAData->stMCIMixSetup.ulFormatTag     = MCI_WAVE_FORMAT_PCM;
-    pAData->stMCIMixSetup.ulBitsPerSample = SDL_AUDIO_BITSIZE(SDLAudioFmt);
+    pAData->stMCIMixSetup.ulBitsPerSample = SDL_AUDIO_BITSIZE(test_format);
     pAData->stMCIMixSetup.ulSamplesPerSec = _this->spec.freq;
     pAData->stMCIMixSetup.ulChannels      = _this->spec.channels;
     pAData->stMCIMixSetup.ulDeviceType    = MCI_DEVTYPE_WAVEFORM_AUDIO;
-    if (iscapture == 0) {
+    if (!iscapture) {
         pAData->stMCIMixSetup.ulFormatMode= MCI_PLAY;
         pAData->stMCIMixSetup.pmixEvent   = cbAudioWriteEvent;
     } else {
@@ -410,15 +406,13 @@ static int OS2_OpenDevice(_THIS, void *handle, const char *devname,
         pAData->aMixBuffers[ulIdx].ulBufferLength = stMCIBuffer.ulBufferSize;
         pAData->aMixBuffers[ulIdx].ulUserParm     = (ULONG)pAData;
 
-        memset(((PMCI_MIX_BUFFER)stMCIBuffer.pBufList)[ulIdx].pBuffer,
-                _this->spec.silence, stMCIBuffer.ulBufferSize);
+        SDL_memset(((PMCI_MIX_BUFFER)stMCIBuffer.pBufList)[ulIdx].pBuffer,
+                   _this->spec.silence, stMCIBuffer.ulBufferSize);
     }
 
     /* Write buffers to kick off the amp mixer */
-    /*pAData->ulQueuedBuf = 1;//stMCIBuffer.ulNumBuffers */
     ulRC = pAData->stMCIMixSetup.pmixWrite(pAData->stMCIMixSetup.ulMixHandle,
-                                           pAData->aMixBuffers,
-                                           1 /*stMCIBuffer.ulNumBuffers*/);
+                                           pAData->aMixBuffers, 1);
     if (ulRC != MCIERR_SUCCESS) {
         _mixIOError("pmixWrite", ulRC);
         return -1;
@@ -428,7 +422,7 @@ static int OS2_OpenDevice(_THIS, void *handle, const char *devname,
 }
 
 
-static int OS2_Init(SDL_AudioDriverImpl * impl)
+static SDL_bool OS2_Init(SDL_AudioDriverImpl * impl)
 {
     /* Set the function pointers */
     impl->DetectDevices = OS2_DetectDevices;
@@ -443,11 +437,13 @@ static int OS2_Init(SDL_AudioDriverImpl * impl)
     impl->FlushCapture = ;
     impl->HasCaptureSupport = SDL_TRUE;
     */
-    return 1; /* this audio target is available. */
+    return SDL_TRUE; /* this audio target is available. */
 }
 
 
-AudioBootStrap OS2AUDIO_bootstrap = { "MMOS2", "OS/2 DART", OS2_Init, 0 };
+AudioBootStrap OS2AUDIO_bootstrap = {
+    "DART", "OS/2 DART", OS2_Init, SDL_FALSE
+};
 
 #endif /* SDL_AUDIO_DRIVER_OS2 */
 
diff --git a/Engine/lib/sdl/src/audio/os2/SDL_os2audio.h b/Engine/lib/sdl/src/audio/os2/SDL_os2audio.h
index 46a338463..07ebbae39 100644
--- a/Engine/lib/sdl/src/audio/os2/SDL_os2audio.h
+++ b/Engine/lib/sdl/src/audio/os2/SDL_os2audio.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/audio/paudio/SDL_paudio.c b/Engine/lib/sdl/src/audio/paudio/SDL_paudio.c
index 7d5f1a0ba..ae2fc2950 100644
--- a/Engine/lib/sdl/src/audio/paudio/SDL_paudio.c
+++ b/Engine/lib/sdl/src/audio/paudio/SDL_paudio.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -156,7 +156,7 @@ PAUDIO_WaitDevice(_THIS)
 #ifdef DEBUG_AUDIO
         fprintf(stderr, "Waiting for audio to get ready\n");
 #endif
-        if (SDL_IOReady(this->hidden->audio_fd, SDL_TRUE, timeoutMS) <= 0) {
+        if (SDL_IOReady(this->hidden->audio_fd, SDL_IOR_WRITE, timeoutMS) <= 0) {
             /*
              * In general we should never print to the screen,
              * but in this case we have no other way of letting
@@ -223,12 +223,12 @@ PAUDIO_CloseDevice(_THIS)
 }
 
 static int
-PAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
+PAUDIO_OpenDevice(_THIS, const char *devname)
 {
     const char *workaround = SDL_getenv("SDL_DSP_NOSELECT");
     char audiodev[1024];
     const char *err = NULL;
-    int format;
+    int flags;
     int bytes_per_sample;
     SDL_AudioFormat test_format;
     audio_init paud_init;
@@ -316,63 +316,44 @@ PAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
     paud_init.channels = this->spec.channels;
 
     /* Try for a closest match on audio format */
-    format = 0;
-    for (test_format = SDL_FirstAudioFormat(this->spec.format);
-         !format && test_format;) {
+    for (test_format = SDL_FirstAudioFormat(this->spec.format); test_format; test_format = SDL_NextAudioFormat()) {
 #ifdef DEBUG_AUDIO
         fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
 #endif
         switch (test_format) {
         case AUDIO_U8:
-            bytes_per_sample = 1;
-            paud_init.bits_per_sample = 8;
-            paud_init.flags = TWOS_COMPLEMENT | FIXED;
-            format = 1;
+            flags = TWOS_COMPLEMENT | FIXED;
             break;
         case AUDIO_S8:
-            bytes_per_sample = 1;
-            paud_init.bits_per_sample = 8;
-            paud_init.flags = SIGNED | TWOS_COMPLEMENT | FIXED;
-            format = 1;
+            flags = SIGNED | TWOS_COMPLEMENT | FIXED;
             break;
         case AUDIO_S16LSB:
-            bytes_per_sample = 2;
-            paud_init.bits_per_sample = 16;
-            paud_init.flags = SIGNED | TWOS_COMPLEMENT | FIXED;
-            format = 1;
+            flags = SIGNED | TWOS_COMPLEMENT | FIXED;
             break;
         case AUDIO_S16MSB:
-            bytes_per_sample = 2;
-            paud_init.bits_per_sample = 16;
-            paud_init.flags = BIG_ENDIAN | SIGNED | TWOS_COMPLEMENT | FIXED;
-            format = 1;
+            flags = BIG_ENDIAN | SIGNED | TWOS_COMPLEMENT | FIXED;
             break;
         case AUDIO_U16LSB:
-            bytes_per_sample = 2;
-            paud_init.bits_per_sample = 16;
-            paud_init.flags = TWOS_COMPLEMENT | FIXED;
-            format = 1;
+            flags = TWOS_COMPLEMENT | FIXED;
             break;
         case AUDIO_U16MSB:
-            bytes_per_sample = 2;
-            paud_init.bits_per_sample = 16;
-            paud_init.flags = BIG_ENDIAN | TWOS_COMPLEMENT | FIXED;
-            format = 1;
+            flags = BIG_ENDIAN | TWOS_COMPLEMENT | FIXED;
             break;
         default:
-            break;
-        }
-        if (!format) {
-            test_format = SDL_NextAudioFormat();
+            continue;
         }
+        break;
     }
-    if (format == 0) {
+    if (!test_format) {
 #ifdef DEBUG_AUDIO
         fprintf(stderr, "Couldn't find any hardware audio formats\n");
 #endif
-        return SDL_SetError("Couldn't find any hardware audio formats");
+        return SDL_SetError("%s: Unsupported audio format", "paud");
     }
     this->spec.format = test_format;
+    paud_init.bits_per_sample = SDL_AUDIO_BITSIZE(test_format);
+    bytes_per_sample = SDL_AUDIO_BITSIZE(test_format) / 8;
+    paud_init.flags = flags;
 
     /*
      * We know the buffer size and the max number of subsequent writes
@@ -406,28 +387,25 @@ PAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
     if (ioctl(fd, AUDIO_INIT, &paud_init) < 0) {
         switch (paud_init.rc) {
         case 1:
-            err = "Couldn't set audio format: DSP can't do play requests";
+            err = "DSP can't do play requests";
             break;
         case 2:
-            err = "Couldn't set audio format: DSP can't do record requests";
+            err = "DSP can't do record requests";
             break;
         case 4:
-            err = "Couldn't set audio format: request was invalid";
+            err = "request was invalid";
             break;
         case 5:
-            err = "Couldn't set audio format: conflict with open's flags";
+            err = "conflict with open's flags";
             break;
         case 6:
-            err = "Couldn't set audio format: out of DSP MIPS or memory";
+            err = "out of DSP MIPS or memory";
             break;
         default:
-            err = "Couldn't set audio format: not documented in sys/audio.h";
+            err = "not documented in sys/audio.h";
             break;
         }
-    }
-
-    if (err != NULL) {
-        return SDL_SetError("Paudio: %s", err);
+        return SDL_SetError("paud: Couldn't set audio format (%s)", err);
     }
 
     /* Allocate mixing buffer */
@@ -485,14 +463,14 @@ PAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
     return 0;
 }
 
-static int
+static SDL_bool
 PAUDIO_Init(SDL_AudioDriverImpl * impl)
 {
     /* !!! FIXME: not right for device enum? */
     int fd = OpenAudioPath(NULL, 0, OPEN_FLAGS, 0);
     if (fd < 0) {
         SDL_SetError("PAUDIO: Couldn't open audio device");
-        return 0;
+        return SDL_FALSE;
     }
     close(fd);
 
@@ -502,13 +480,13 @@ PAUDIO_Init(SDL_AudioDriverImpl * impl)
     impl->PlayDevice = PAUDIO_WaitDevice;
     impl->GetDeviceBuf = PAUDIO_GetDeviceBuf;
     impl->CloseDevice = PAUDIO_CloseDevice;
-    impl->OnlyHasDefaultOutputDevice = 1;       /* !!! FIXME: add device enum! */
+    impl->OnlyHasDefaultOutputDevice = SDL_TRUE;       /* !!! FIXME: add device enum! */
 
-    return 1;   /* this audio target is available. */
+    return SDL_TRUE;   /* this audio target is available. */
 }
 
 AudioBootStrap PAUDIO_bootstrap = {
-    "paud", "AIX Paudio", PAUDIO_Init, 0
+    "paud", "AIX Paudio", PAUDIO_Init, SDL_FALSE
 };
 
 #endif /* SDL_AUDIO_DRIVER_PAUDIO */
diff --git a/Engine/lib/sdl/src/audio/paudio/SDL_paudio.h b/Engine/lib/sdl/src/audio/paudio/SDL_paudio.h
index b3c3d0398..1746a88ee 100644
--- a/Engine/lib/sdl/src/audio/paudio/SDL_paudio.h
+++ b/Engine/lib/sdl/src/audio/paudio/SDL_paudio.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/audio/pipewire/SDL_pipewire.c b/Engine/lib/sdl/src/audio/pipewire/SDL_pipewire.c
new file mode 100644
index 000000000..7e318f1bc
--- /dev/null
+++ b/Engine/lib/sdl/src/audio/pipewire/SDL_pipewire.c
@@ -0,0 +1,1276 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "../../SDL_internal.h"
+#include "SDL_hints.h"
+
+#if SDL_AUDIO_DRIVER_PIPEWIRE
+
+#include "SDL_audio.h"
+#include "SDL_loadso.h"
+#include "SDL_pipewire.h"
+
+#include <pipewire/extensions/metadata.h>
+#include <spa/param/audio/format-utils.h>
+
+/*
+ * The following keys are defined for compatability when building against older versions of Pipewire
+ * prior to their introduction and can be removed if the minimum required Pipewire version is increased
+ * to or beyond their point of introduction.
+ */
+
+/*
+ * Introduced in 0.3.22
+ * Taken from /src/pipewire/keys.h
+ */
+#ifndef PW_KEY_CONFIG_NAME
+#define PW_KEY_CONFIG_NAME "config.name"
+#endif
+
+/*
+ * Introduced in 0.3.33
+ * Taken from src/pipewire/keys.h
+ */
+#ifndef PW_KEY_NODE_RATE
+#define PW_KEY_NODE_RATE "node.rate"
+#endif
+
+/*
+ * This seems to be a sane lower limit as Pipewire
+ * uses it in several of it's own modules.
+ */
+#define PW_MIN_SAMPLES     32 /* About 0.67ms at 48kHz */
+#define PW_BASE_CLOCK_RATE 48000
+
+#define PW_POD_BUFFER_LENGTH         1024
+#define PW_THREAD_NAME_BUFFER_LENGTH 128
+
+enum PW_READY_FLAGS
+{
+    PW_READY_FLAG_BUFFER_ADDED = 0x1,
+    PW_READY_FLAG_STREAM_READY = 0x2,
+    PW_READY_FLAG_ALL_BITS     = 0x3
+};
+
+#define PW_ID_TO_HANDLE(x) (void *)((uintptr_t)x)
+#define PW_HANDLE_TO_ID(x) (uint32_t)((uintptr_t)x)
+
+static SDL_bool pipewire_initialized = SDL_FALSE;
+
+/* Pipewire entry points */
+static void (*PIPEWIRE_pw_init)(int *, char **);
+static void (*PIPEWIRE_pw_deinit)(void);
+static struct pw_thread_loop *(*PIPEWIRE_pw_thread_loop_new)(const char *, const struct spa_dict *);
+static void (*PIPEWIRE_pw_thread_loop_destroy)(struct pw_thread_loop *);
+static void (*PIPEWIRE_pw_thread_loop_stop)(struct pw_thread_loop *);
+static struct pw_loop *(*PIPEWIRE_pw_thread_loop_get_loop)(struct pw_thread_loop *);
+static void (*PIPEWIRE_pw_thread_loop_lock)(struct pw_thread_loop *);
+static void (*PIPEWIRE_pw_thread_loop_unlock)(struct pw_thread_loop *);
+static void (*PIPEWIRE_pw_thread_loop_signal)(struct pw_thread_loop *, bool);
+static void (*PIPEWIRE_pw_thread_loop_wait)(struct pw_thread_loop *);
+static int (*PIPEWIRE_pw_thread_loop_start)(struct pw_thread_loop *);
+static struct pw_context *(*PIPEWIRE_pw_context_new)(struct pw_loop *, struct pw_properties *, size_t);
+static void (*PIPEWIRE_pw_context_destroy)(struct pw_context *);
+static struct pw_core *(*PIPEWIRE_pw_context_connect)(struct pw_context *, struct pw_properties *, size_t);
+static void (*PIPEWIRE_pw_proxy_add_object_listener)(struct pw_proxy *, struct spa_hook *, const void *, void *);
+static void *(*PIPEWIRE_pw_proxy_get_user_data)(struct pw_proxy *);
+static void (*PIPEWIRE_pw_proxy_destroy)(struct pw_proxy *);
+static int (*PIPEWIRE_pw_core_disconnect)(struct pw_core *);
+static struct pw_stream *(*PIPEWIRE_pw_stream_new_simple)(struct pw_loop *, const char *, struct pw_properties *,
+                                                          const struct pw_stream_events *, void *);
+static void (*PIPEWIRE_pw_stream_destroy)(struct pw_stream *);
+static int (*PIPEWIRE_pw_stream_connect)(struct pw_stream *, enum pw_direction, uint32_t, enum pw_stream_flags,
+                                         const struct spa_pod **, uint32_t);
+static enum pw_stream_state (*PIPEWIRE_pw_stream_get_state)(struct pw_stream *stream, const char **error);
+static struct pw_buffer *(*PIPEWIRE_pw_stream_dequeue_buffer)(struct pw_stream *);
+static int (*PIPEWIRE_pw_stream_queue_buffer)(struct pw_stream *, struct pw_buffer *);
+static struct pw_properties *(*PIPEWIRE_pw_properties_new)(const char *, ...)SPA_SENTINEL;
+static int (*PIPEWIRE_pw_properties_set)(struct pw_properties *, const char *, const char *);
+static int (*PIPEWIRE_pw_properties_setf)(struct pw_properties *, const char *, const char *, ...) SPA_PRINTF_FUNC(3, 4);
+
+#ifdef SDL_AUDIO_DRIVER_PIPEWIRE_DYNAMIC
+
+static const char *pipewire_library = SDL_AUDIO_DRIVER_PIPEWIRE_DYNAMIC;
+static void       *pipewire_handle  = NULL;
+
+static int
+pipewire_dlsym(const char *fn, void **addr)
+{
+    *addr = SDL_LoadFunction(pipewire_handle, fn);
+    if (*addr == NULL) {
+        /* Don't call SDL_SetError(): SDL_LoadFunction already did. */
+        return 0;
+    }
+
+    return 1;
+}
+
+#define SDL_PIPEWIRE_SYM(x)                                    \
+    if (!pipewire_dlsym(#x, (void **)(char *)&PIPEWIRE_##x)) { \
+        return -1;                                             \
+    }
+
+static int
+load_pipewire_library()
+{
+    if ((pipewire_handle = SDL_LoadObject(pipewire_library))) {
+        return 0;
+    }
+
+    return -1;
+}
+
+static void
+unload_pipewire_library()
+{
+    if (pipewire_handle) {
+        SDL_UnloadObject(pipewire_handle);
+        pipewire_handle = NULL;
+    }
+}
+
+#else
+
+#define SDL_PIPEWIRE_SYM(x) PIPEWIRE_##x = x
+
+static int
+load_pipewire_library()
+{
+    return 0;
+}
+
+static void
+unload_pipewire_library()
+{ /* Nothing to do */
+}
+
+#endif /* SDL_AUDIO_DRIVER_PIPEWIRE_DYNAMIC */
+
+static int
+load_pipewire_syms()
+{
+    SDL_PIPEWIRE_SYM(pw_init);
+    SDL_PIPEWIRE_SYM(pw_deinit);
+    SDL_PIPEWIRE_SYM(pw_thread_loop_new);
+    SDL_PIPEWIRE_SYM(pw_thread_loop_destroy);
+    SDL_PIPEWIRE_SYM(pw_thread_loop_stop);
+    SDL_PIPEWIRE_SYM(pw_thread_loop_get_loop);
+    SDL_PIPEWIRE_SYM(pw_thread_loop_lock);
+    SDL_PIPEWIRE_SYM(pw_thread_loop_unlock);
+    SDL_PIPEWIRE_SYM(pw_thread_loop_signal);
+    SDL_PIPEWIRE_SYM(pw_thread_loop_wait);
+    SDL_PIPEWIRE_SYM(pw_thread_loop_start);
+    SDL_PIPEWIRE_SYM(pw_context_new);
+    SDL_PIPEWIRE_SYM(pw_context_destroy);
+    SDL_PIPEWIRE_SYM(pw_context_connect);
+    SDL_PIPEWIRE_SYM(pw_proxy_add_object_listener);
+    SDL_PIPEWIRE_SYM(pw_proxy_get_user_data);
+    SDL_PIPEWIRE_SYM(pw_proxy_destroy);
+    SDL_PIPEWIRE_SYM(pw_core_disconnect);
+    SDL_PIPEWIRE_SYM(pw_stream_new_simple);
+    SDL_PIPEWIRE_SYM(pw_stream_destroy);
+    SDL_PIPEWIRE_SYM(pw_stream_connect);
+    SDL_PIPEWIRE_SYM(pw_stream_get_state);
+    SDL_PIPEWIRE_SYM(pw_stream_dequeue_buffer);
+    SDL_PIPEWIRE_SYM(pw_stream_queue_buffer);
+    SDL_PIPEWIRE_SYM(pw_properties_new);
+    SDL_PIPEWIRE_SYM(pw_properties_set);
+    SDL_PIPEWIRE_SYM(pw_properties_setf);
+
+    return 0;
+}
+
+static int
+init_pipewire_library()
+{
+    if (!load_pipewire_library()) {
+        if (!load_pipewire_syms()) {
+            PIPEWIRE_pw_init(NULL, NULL);
+            return 0;
+        }
+    }
+
+    return -1;
+}
+
+static void
+deinit_pipewire_library()
+{
+    PIPEWIRE_pw_deinit();
+    unload_pipewire_library();
+}
+
+/* A generic Pipewire node object used for enumeration. */
+struct node_object
+{
+    struct spa_list link;
+
+    Uint32 id;
+    int    seq;
+
+    /*
+     * NOTE: If used, this is *must* be allocated with SDL_malloc() or similar
+     * as SDL_free() will be called on it when the node_object is destroyed.
+     *
+     * If ownership of the referenced memory is transferred, this must be set
+     * to NULL or the memory will be freed when the node_object is destroyed.
+     */
+    void *userdata;
+
+    struct pw_proxy *proxy;
+    struct spa_hook  node_listener;
+    struct spa_hook  core_listener;
+};
+
+/* A sink/source node used for stream I/O. */
+struct io_node
+{
+    struct spa_list link;
+
+    Uint32        id;
+    SDL_bool      is_capture;
+    SDL_AudioSpec spec;
+
+    char name[];
+};
+
+/* The global hotplug thread and associated objects. */
+static struct pw_thread_loop *hotplug_loop;
+static struct pw_core        *hotplug_core;
+static struct pw_context     *hotplug_context;
+static struct pw_registry    *hotplug_registry;
+static struct spa_hook        hotplug_registry_listener;
+static struct spa_hook        hotplug_core_listener;
+static struct spa_list        hotplug_pending_list;
+static struct spa_list        hotplug_io_list;
+static int                    hotplug_init_seq_val;
+static SDL_bool               hotplug_init_complete;
+static SDL_bool               hotplug_events_enabled;
+
+static Uint32 pipewire_default_sink_id   = SPA_ID_INVALID;
+static Uint32 pipewire_default_source_id = SPA_ID_INVALID;
+
+/* The active node list */
+static SDL_bool
+io_list_check_add(struct io_node *node)
+{
+    struct io_node *n;
+    SDL_bool        ret = SDL_TRUE;
+
+    /* See if the node is already in the list */
+    spa_list_for_each (n, &hotplug_io_list, link) {
+        if (n->id == node->id) {
+            ret = SDL_FALSE;
+            goto dup_found;
+        }
+    }
+
+    /* Add to the list if the node doesn't already exist */
+    spa_list_append(&hotplug_io_list, &node->link);
+
+    if (hotplug_events_enabled) {
+        SDL_AddAudioDevice(node->is_capture, node->name, &node->spec, PW_ID_TO_HANDLE(node->id));
+    }
+
+dup_found:
+
+    return ret;
+}
+
+static void
+io_list_remove(Uint32 id)
+{
+    struct io_node *n, *temp;
+
+    /* Find and remove the node from the list */
+    spa_list_for_each_safe (n, temp, &hotplug_io_list, link) {
+        if (n->id == id) {
+            spa_list_remove(&n->link);
+
+            if (hotplug_events_enabled) {
+                SDL_RemoveAudioDevice(n->is_capture, PW_ID_TO_HANDLE(id));
+            }
+
+            SDL_free(n);
+
+            break;
+        }
+    }
+}
+
+static void
+io_list_sort()
+{
+    struct io_node *default_sink = NULL, *default_source = NULL;
+    struct io_node *n, *temp;
+
+    /* Find and move the default nodes to the beginning of the list */
+    spa_list_for_each_safe (n, temp, &hotplug_io_list, link) {
+        if (n->id == pipewire_default_sink_id) {
+            default_sink = n;
+            spa_list_remove(&n->link);
+        } else if (n->id == pipewire_default_source_id) {
+            default_source = n;
+            spa_list_remove(&n->link);
+        }
+    }
+
+    if (default_source) {
+        spa_list_prepend(&hotplug_io_list, &default_source->link);
+    }
+
+    if (default_sink) {
+        spa_list_prepend(&hotplug_io_list, &default_sink->link);
+    }
+}
+
+static void
+io_list_clear()
+{
+    struct io_node *n, *temp;
+
+    spa_list_for_each_safe (n, temp, &hotplug_io_list, link) {
+        spa_list_remove(&n->link);
+        SDL_free(n);
+    }
+}
+
+static void
+node_object_destroy(struct node_object *node)
+{
+    SDL_assert(node);
+
+    spa_list_remove(&node->link);
+    spa_hook_remove(&node->node_listener);
+    spa_hook_remove(&node->core_listener);
+    SDL_free(node->userdata);
+    PIPEWIRE_pw_proxy_destroy(node->proxy);
+}
+
+/* The pending node list */
+static void
+pending_list_add(struct node_object *node)
+{
+    SDL_assert(node);
+    spa_list_append(&hotplug_pending_list, &node->link);
+}
+
+static void
+pending_list_remove(Uint32 id)
+{
+    struct node_object *node, *temp;
+
+    spa_list_for_each_safe (node, temp, &hotplug_pending_list, link) {
+        if (node->id == id) {
+            node_object_destroy(node);
+        }
+    }
+}
+
+static void
+pending_list_clear()
+{
+    struct node_object *node, *temp;
+
+    spa_list_for_each_safe (node, temp, &hotplug_pending_list, link) {
+        node_object_destroy(node);
+    }
+}
+
+static void *
+node_object_new(Uint32 id, const char *type, Uint32 version, const void *funcs, const struct pw_core_events *core_events)
+{
+    struct pw_proxy    *proxy;
+    struct node_object *node;
+
+    /* Create the proxy object */
+    proxy = pw_registry_bind(hotplug_registry, id, type, version, sizeof(struct node_object));
+    if (proxy == NULL) {
+        SDL_SetError("Pipewire: Failed to create proxy object (%i)", errno);
+        return NULL;
+    }
+
+    node = PIPEWIRE_pw_proxy_get_user_data(proxy);
+    SDL_zerop(node);
+
+    node->id    = id;
+    node->proxy = proxy;
+
+    /* Add the callbacks */
+    pw_core_add_listener(hotplug_core, &node->core_listener, core_events, node);
+    PIPEWIRE_pw_proxy_add_object_listener(node->proxy, &node->node_listener, funcs, node);
+
+    /* Add the node to the active list */
+    pending_list_add(node);
+
+    return node;
+}
+
+/* Core sync points */
+static void
+core_events_hotplug_init_callback(void *object, uint32_t id, int seq)
+{
+    if (id == PW_ID_CORE && seq == hotplug_init_seq_val) {
+        /* This core listener is no longer needed. */
+        spa_hook_remove(&hotplug_core_listener);
+
+        /* Signal that the initial I/O list is populated */
+        hotplug_init_complete = SDL_TRUE;
+        PIPEWIRE_pw_thread_loop_signal(hotplug_loop, false);
+    }
+}
+
+static void
+core_events_interface_callback(void *object, uint32_t id, int seq)
+{
+    struct node_object *node = object;
+    struct io_node     *io   = node->userdata;
+
+    if (id == PW_ID_CORE && seq == node->seq) {
+        /*
+         * Move the I/O node to the connected list.
+         * On success, the list owns the I/O node object.
+         */
+        if (io_list_check_add(io)) {
+            node->userdata = NULL;
+        }
+
+        node_object_destroy(node);
+    }
+}
+
+static void
+core_events_metadata_callback(void *object, uint32_t id, int seq)
+{
+    struct node_object *node = object;
+
+    if (id == PW_ID_CORE && seq == node->seq) {
+        node_object_destroy(node);
+    }
+}
+
+static const struct pw_core_events hotplug_init_core_events = { PW_VERSION_CORE_EVENTS, .done = core_events_hotplug_init_callback };
+static const struct pw_core_events interface_core_events    = { PW_VERSION_CORE_EVENTS, .done = core_events_interface_callback };
+static const struct pw_core_events metadata_core_events     = { PW_VERSION_CORE_EVENTS, .done = core_events_metadata_callback };
+
+static void
+hotplug_core_sync(struct node_object *node)
+{
+    /*
+     * Node sync events *must* come before the hotplug init sync events or the initial
+     * I/O list will be incomplete when the main hotplug sync point is hit.
+     */
+    if (node) {
+        node->seq = pw_core_sync(hotplug_core, PW_ID_CORE, node->seq);
+    }
+
+    if (!hotplug_init_complete) {
+        hotplug_init_seq_val = pw_core_sync(hotplug_core, PW_ID_CORE, hotplug_init_seq_val);
+    }
+}
+
+/* Helpers for retrieving values from params */
+static SDL_bool
+get_range_param(const struct spa_pod *param, Uint32 key, int *def, int *min, int *max)
+{
+    const struct spa_pod_prop *prop;
+    struct spa_pod            *value;
+    Uint32                     n_values, choice;
+
+    prop = spa_pod_find_prop(param, NULL, key);
+
+    if (prop && prop->value.type == SPA_TYPE_Choice) {
+        value = spa_pod_get_values(&prop->value, &n_values, &choice);
+
+        if (n_values == 3 && choice == SPA_CHOICE_Range) {
+            Uint32 *v = SPA_POD_BODY(value);
+
+            if (v) {
+                if (def) {
+                    *def = (int)v[0];
+                }
+                if (min) {
+                    *min = (int)v[1];
+                }
+                if (max) {
+                    *max = (int)v[2];
+                }
+
+                return SDL_TRUE;
+            }
+        }
+    }
+
+    return SDL_FALSE;
+}
+
+static SDL_bool
+get_int_param(const struct spa_pod *param, Uint32 key, int *val)
+{
+    const struct spa_pod_prop *prop;
+    Sint32                     v;
+
+    prop = spa_pod_find_prop(param, NULL, key);
+
+    if (prop && spa_pod_get_int(&prop->value, &v) == 0) {
+        if (val) {
+            *val = (int)v;
+        }
+
+        return SDL_TRUE;
+    }
+
+    return SDL_FALSE;
+}
+
+/* Interface node callbacks */
+static void
+node_event_info(void *object, const struct pw_node_info *info)
+{
+    struct node_object *node = object;
+    struct io_node     *io   = node->userdata;
+    const char         *prop_val;
+    Uint32              i;
+
+    if (info) {
+        prop_val = spa_dict_lookup(info->props, PW_KEY_AUDIO_CHANNELS);
+        if (prop_val) {
+            io->spec.channels = (Uint8)SDL_atoi(prop_val);
+        }
+
+        /* Need to parse the parameters to get the sample rate */
+        for (i = 0; i < info->n_params; ++i) {
+            pw_node_enum_params(node->proxy, 0, info->params[i].id, 0, 0, NULL);
+        }
+
+        hotplug_core_sync(node);
+    }
+}
+
+static void
+node_event_param(void *object, int seq, uint32_t id, uint32_t index, uint32_t next, const struct spa_pod *param)
+{
+    struct node_object *node = object;
+    struct io_node     *io   = node->userdata;
+
+    /* Get the default frequency */
+    if (io->spec.freq == 0) {
+        get_range_param(param, SPA_FORMAT_AUDIO_rate, &io->spec.freq, NULL, NULL);
+    }
+
+    /*
+     * The channel count should have come from the node properties,
+     * but it is stored here as well. If one failed, try the other.
+     */
+    if (io->spec.channels == 0) {
+        int channels;
+        if (get_int_param(param, SPA_FORMAT_AUDIO_channels, &channels)) {
+            io->spec.channels = (Uint8)channels;
+        }
+    }
+}
+
+static const struct pw_node_events interface_node_events = { PW_VERSION_NODE_EVENTS, .info = node_event_info,
+                                                             .param = node_event_param };
+
+/* Metadata node callback */
+static int
+metadata_property(void *object, Uint32 subject, const char *key, const char *type, const char *value)
+{
+    if (subject == PW_ID_CORE && key != NULL && value != NULL) {
+        Uint32 val = SDL_atoi(value);
+
+        if (!SDL_strcmp(key, "default.audio.sink")) {
+            pipewire_default_sink_id = val;
+        } else if (!SDL_strcmp(key, "default.audio.source")) {
+            pipewire_default_source_id = val;
+        }
+    }
+
+    return 0;
+}
+
+static const struct pw_metadata_events metadata_node_events = { PW_VERSION_METADATA_EVENTS, .property = metadata_property };
+
+/* Global registry callbacks */
+static void
+registry_event_global_callback(void *object, uint32_t id, uint32_t permissions, const char *type, uint32_t version,
+                               const struct spa_dict *props)
+{
+    struct node_object *node;
+
+    /* We're only interested in interface and metadata nodes. */
+    if (!SDL_strcmp(type, PW_TYPE_INTERFACE_Node)) {
+        const char *media_class = spa_dict_lookup(props, PW_KEY_MEDIA_CLASS);
+
+        if (media_class) {
+            const char     *node_desc;
+            struct io_node *io;
+            SDL_bool        is_capture;
+            int             str_buffer_len;
+
+            /* Just want sink and capture */
+            if (!SDL_strcasecmp(media_class, "Audio/Sink")) {
+                is_capture = SDL_FALSE;
+            } else if (!SDL_strcasecmp(media_class, "Audio/Source")) {
+                is_capture = SDL_TRUE;
+            } else {
+                return;
+            }
+
+            node_desc = spa_dict_lookup(props, PW_KEY_NODE_DESCRIPTION);
+
+            if (node_desc) {
+                node = node_object_new(id, type, version, &interface_node_events, &interface_core_events);
+                if (node == NULL) {
+                    SDL_SetError("Pipewire: Failed to allocate interface node");
+                    return;
+                }
+
+                /* Allocate and initialize the I/O node information struct */
+                str_buffer_len = SDL_strlen(node_desc) + 1;
+                node->userdata = io = SDL_calloc(1, sizeof(struct io_node) + str_buffer_len);
+                if (io == NULL) {
+                    node_object_destroy(node);
+                    SDL_OutOfMemory();
+                    return;
+                }
+
+                /* Begin setting the node properties */
+                io->id          = id;
+                io->is_capture  = is_capture;
+                io->spec.format = AUDIO_F32; /* Pipewire uses floats internally, other formats require conversion. */
+                SDL_strlcpy(io->name, node_desc, str_buffer_len);
+
+                /* Update sync points */
+                hotplug_core_sync(node);
+            }
+        }
+    } else if (!SDL_strcmp(type, PW_TYPE_INTERFACE_Metadata)) {
+        node = node_object_new(id, type, version, &metadata_node_events, &metadata_core_events);
+        if (node == NULL) {
+            SDL_SetError("Pipewire: Failed to allocate metadata node");
+            return;
+        }
+
+        /* Update sync points */
+        hotplug_core_sync(node);
+    }
+}
+
+static void
+registry_event_remove_callback(void *object, uint32_t id)
+{
+    io_list_remove(id);
+    pending_list_remove(id);
+}
+
+static const struct pw_registry_events registry_events = { PW_VERSION_REGISTRY_EVENTS, .global = registry_event_global_callback,
+                                                           .global_remove = registry_event_remove_callback };
+
+/* The hotplug thread */
+static int
+hotplug_loop_init()
+{
+    int res;
+
+    spa_list_init(&hotplug_pending_list);
+    spa_list_init(&hotplug_io_list);
+
+    hotplug_loop = PIPEWIRE_pw_thread_loop_new("SDLAudioHotplug", NULL);
+    if (hotplug_loop == NULL) {
+        return SDL_SetError("Pipewire: Failed to create hotplug detection loop (%i)", errno);
+    }
+
+    hotplug_context = PIPEWIRE_pw_context_new(PIPEWIRE_pw_thread_loop_get_loop(hotplug_loop), NULL, 0);
+    if (hotplug_context == NULL) {
+        return SDL_SetError("Pipewire: Failed to create hotplug detection context (%i)", errno);
+    }
+
+    hotplug_core = PIPEWIRE_pw_context_connect(hotplug_context, NULL, 0);
+    if (hotplug_core == NULL) {
+        return SDL_SetError("Pipewire: Failed to connect hotplug detection context (%i)", errno);
+    }
+
+    hotplug_registry = pw_core_get_registry(hotplug_core, PW_VERSION_REGISTRY, 0);
+    if (hotplug_registry == NULL) {
+        return SDL_SetError("Pipewire: Failed to acquire hotplug detection registry (%i)", errno);
+    }
+
+    spa_zero(hotplug_registry_listener);
+    pw_registry_add_listener(hotplug_registry, &hotplug_registry_listener, &registry_events, NULL);
+
+    spa_zero(hotplug_core_listener);
+    pw_core_add_listener(hotplug_core, &hotplug_core_listener, &hotplug_init_core_events, NULL);
+
+    hotplug_init_seq_val = pw_core_sync(hotplug_core, PW_ID_CORE, 0);
+
+    res = PIPEWIRE_pw_thread_loop_start(hotplug_loop);
+    if (res != 0) {
+        return SDL_SetError("Pipewire: Failed to start hotplug detection loop");
+    }
+
+    return 0;
+}
+
+static void
+hotplug_loop_destroy()
+{
+    if (hotplug_loop) {
+        PIPEWIRE_pw_thread_loop_stop(hotplug_loop);
+    }
+
+    pending_list_clear();
+    io_list_clear();
+
+    hotplug_init_complete  = SDL_FALSE;
+    hotplug_events_enabled = SDL_FALSE;
+
+    pipewire_default_sink_id   = SPA_ID_INVALID;
+    pipewire_default_source_id = SPA_ID_INVALID;
+
+    if (hotplug_registry) {
+        PIPEWIRE_pw_proxy_destroy((struct pw_proxy *)hotplug_registry);
+        hotplug_registry = NULL;
+    }
+
+    if (hotplug_core) {
+        PIPEWIRE_pw_core_disconnect(hotplug_core);
+        hotplug_core = NULL;
+    }
+
+    if (hotplug_context) {
+        PIPEWIRE_pw_context_destroy(hotplug_context);
+        hotplug_context = NULL;
+    }
+
+    if (hotplug_loop) {
+        PIPEWIRE_pw_thread_loop_destroy(hotplug_loop);
+        hotplug_loop = NULL;
+    }
+}
+
+static void
+PIPEWIRE_DetectDevices()
+{
+    struct io_node *io;
+
+    PIPEWIRE_pw_thread_loop_lock(hotplug_loop);
+
+    /* Wait until the initial registry enumeration is complete */
+    if (!hotplug_init_complete) {
+        PIPEWIRE_pw_thread_loop_wait(hotplug_loop);
+    }
+
+    /* Sort the I/O list so the default source/sink are listed first */
+    io_list_sort();
+
+    spa_list_for_each (io, &hotplug_io_list, link) {
+        SDL_AddAudioDevice(io->is_capture, io->name, &io->spec, PW_ID_TO_HANDLE(io->id));
+    }
+
+    hotplug_events_enabled = SDL_TRUE;
+
+    PIPEWIRE_pw_thread_loop_unlock(hotplug_loop);
+}
+
+/* Channel maps that match the order in SDL_Audio.h */
+static const enum spa_audio_channel PIPEWIRE_channel_map_1[] = { SPA_AUDIO_CHANNEL_MONO };
+static const enum spa_audio_channel PIPEWIRE_channel_map_2[] = { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR };
+static const enum spa_audio_channel PIPEWIRE_channel_map_3[] = { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, SPA_AUDIO_CHANNEL_LFE };
+static const enum spa_audio_channel PIPEWIRE_channel_map_4[] = { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, SPA_AUDIO_CHANNEL_RL,
+                                                                 SPA_AUDIO_CHANNEL_RR };
+static const enum spa_audio_channel PIPEWIRE_channel_map_5[] = { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, SPA_AUDIO_CHANNEL_FC,
+                                                                 SPA_AUDIO_CHANNEL_RL, SPA_AUDIO_CHANNEL_RR };
+static const enum spa_audio_channel PIPEWIRE_channel_map_6[] = { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, SPA_AUDIO_CHANNEL_FC,
+                                                                 SPA_AUDIO_CHANNEL_LFE, SPA_AUDIO_CHANNEL_RL, SPA_AUDIO_CHANNEL_RR };
+static const enum spa_audio_channel PIPEWIRE_channel_map_7[] = { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, SPA_AUDIO_CHANNEL_FC,
+                                                                 SPA_AUDIO_CHANNEL_LFE, SPA_AUDIO_CHANNEL_RC, SPA_AUDIO_CHANNEL_RL,
+                                                                 SPA_AUDIO_CHANNEL_RR };
+static const enum spa_audio_channel PIPEWIRE_channel_map_8[] = { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, SPA_AUDIO_CHANNEL_FC,
+                                                                 SPA_AUDIO_CHANNEL_LFE, SPA_AUDIO_CHANNEL_RL, SPA_AUDIO_CHANNEL_RR,
+                                                                 SPA_AUDIO_CHANNEL_SL, SPA_AUDIO_CHANNEL_SR };
+
+#define COPY_CHANNEL_MAP(c) SDL_memcpy(info->position, PIPEWIRE_channel_map_##c, sizeof(PIPEWIRE_channel_map_##c))
+
+static void
+initialize_spa_info(const SDL_AudioSpec *spec, struct spa_audio_info_raw *info)
+{
+    info->channels = spec->channels;
+    info->rate     = spec->freq;
+
+    switch (spec->channels) {
+    case 1:
+        COPY_CHANNEL_MAP(1);
+        break;
+    case 2:
+        COPY_CHANNEL_MAP(2);
+        break;
+    case 3:
+        COPY_CHANNEL_MAP(3);
+        break;
+    case 4:
+        COPY_CHANNEL_MAP(4);
+        break;
+    case 5:
+        COPY_CHANNEL_MAP(5);
+        break;
+    case 6:
+        COPY_CHANNEL_MAP(6);
+        break;
+    case 7:
+        COPY_CHANNEL_MAP(7);
+        break;
+    case 8:
+        COPY_CHANNEL_MAP(8);
+        break;
+    }
+
+    /* Pipewire natively supports all of SDL's sample formats */
+    switch (spec->format) {
+    case AUDIO_U8:
+        info->format = SPA_AUDIO_FORMAT_U8;
+        break;
+    case AUDIO_S8:
+        info->format = SPA_AUDIO_FORMAT_S8;
+        break;
+    case AUDIO_U16LSB:
+        info->format = SPA_AUDIO_FORMAT_U16_LE;
+        break;
+    case AUDIO_S16LSB:
+        info->format = SPA_AUDIO_FORMAT_S16_LE;
+        break;
+    case AUDIO_U16MSB:
+        info->format = SPA_AUDIO_FORMAT_U16_BE;
+        break;
+    case AUDIO_S16MSB:
+        info->format = SPA_AUDIO_FORMAT_S16_BE;
+        break;
+    case AUDIO_S32LSB:
+        info->format = SPA_AUDIO_FORMAT_S32_LE;
+        break;
+    case AUDIO_S32MSB:
+        info->format = SPA_AUDIO_FORMAT_S32_BE;
+        break;
+    case AUDIO_F32LSB:
+        info->format = SPA_AUDIO_FORMAT_F32_LE;
+        break;
+    case AUDIO_F32MSB:
+        info->format = SPA_AUDIO_FORMAT_F32_BE;
+        break;
+    }
+}
+
+static void
+output_callback(void *data)
+{
+    struct pw_buffer  *pw_buf;
+    struct spa_buffer *spa_buf;
+    Uint8             *dst;
+
+    _THIS                    = (SDL_AudioDevice *)data;
+    struct pw_stream *stream = this->hidden->stream;
+
+    /* Shutting down, don't do anything */
+    if (SDL_AtomicGet(&this->shutdown)) {
+        return;
+    }
+
+    /* See if a buffer is available */
+    if ((pw_buf = PIPEWIRE_pw_stream_dequeue_buffer(stream)) == NULL) {
+        return;
+    }
+
+    spa_buf = pw_buf->buffer;
+
+    if (spa_buf->datas[0].data == NULL) {
+        return;
+    }
+
+    /*
+     * If the device is disabled, write silence to the stream buffer
+     * and run the callback with the work buffer to keep the callback
+     * firing regularly in case the audio is being used as a timer.
+     */
+    if (!SDL_AtomicGet(&this->paused)) {
+        if (SDL_AtomicGet(&this->enabled)) {
+            dst = spa_buf->datas[0].data;
+        } else {
+            dst = this->work_buffer;
+            SDL_memset(spa_buf->datas[0].data, this->spec.silence, this->spec.size);
+        }
+
+        if (!this->stream) {
+            SDL_LockMutex(this->mixer_lock);
+            this->callbackspec.callback(this->callbackspec.userdata, dst, this->callbackspec.size);
+            SDL_UnlockMutex(this->mixer_lock);
+        } else {
+            int got;
+
+            /* Fire the callback until we have enough to fill a buffer */
+            while (SDL_AudioStreamAvailable(this->stream) < this->spec.size) {
+                SDL_LockMutex(this->mixer_lock);
+                this->callbackspec.callback(this->callbackspec.userdata, this->work_buffer, this->callbackspec.size);
+                SDL_UnlockMutex(this->mixer_lock);
+
+                SDL_AudioStreamPut(this->stream, this->work_buffer, this->callbackspec.size);
+            }
+
+            got = SDL_AudioStreamGet(this->stream, dst, this->spec.size);
+            SDL_assert(got == this->spec.size);
+        }
+    } else {
+        SDL_memset(spa_buf->datas[0].data, this->spec.silence, this->spec.size);
+    }
+
+    spa_buf->datas[0].chunk->offset = 0;
+    spa_buf->datas[0].chunk->stride = this->hidden->stride;
+    spa_buf->datas[0].chunk->size   = this->spec.size;
+
+    PIPEWIRE_pw_stream_queue_buffer(stream, pw_buf);
+}
+
+static void
+input_callback(void *data)
+{
+    struct pw_buffer  *pw_buf;
+    struct spa_buffer *spa_buf;
+    Uint8             *src;
+    _THIS                    = (SDL_AudioDevice *)data;
+    struct pw_stream *stream = this->hidden->stream;
+
+    /* Shutting down, don't do anything */
+    if (SDL_AtomicGet(&this->shutdown)) {
+        return;
+    }
+
+    pw_buf = PIPEWIRE_pw_stream_dequeue_buffer(stream);
+    if (!pw_buf) {
+        return;
+    }
+
+    spa_buf = pw_buf->buffer;
+
+    if ((src = (Uint8 *)spa_buf->datas[0].data) == NULL) {
+        return;
+    }
+
+    if (!SDL_AtomicGet(&this->paused)) {
+        /* Calculate the offset and data size */
+        const Uint32 offset = SPA_MIN(spa_buf->datas[0].chunk->offset, spa_buf->datas[0].maxsize);
+        const Uint32 size   = SPA_MIN(spa_buf->datas[0].chunk->size, spa_buf->datas[0].maxsize - offset);
+
+        src += offset;
+
+        /* Fill the buffer with silence if the stream is disabled. */
+        if (!SDL_AtomicGet(&this->enabled)) {
+            SDL_memset(src, this->callbackspec.silence, size);
+        }
+
+        /* Pipewire can vary the latency, so buffer all incoming data */
+        SDL_WriteToDataQueue(this->hidden->buffer, src, size);
+
+        while (SDL_CountDataQueue(this->hidden->buffer) >= this->callbackspec.size) {
+            SDL_ReadFromDataQueue(this->hidden->buffer, this->work_buffer, this->callbackspec.size);
+
+            SDL_LockMutex(this->mixer_lock);
+            this->callbackspec.callback(this->callbackspec.userdata, this->work_buffer, this->callbackspec.size);
+            SDL_UnlockMutex(this->mixer_lock);
+        }
+    } else if (this->hidden->buffer) { /* Flush the buffer when paused */
+        if (SDL_CountDataQueue(this->hidden->buffer) != 0) {
+            SDL_ClearDataQueue(this->hidden->buffer, this->hidden->input_buffer_packet_size);
+        }
+    }
+
+    PIPEWIRE_pw_stream_queue_buffer(stream, pw_buf);
+}
+
+static void
+stream_add_buffer_callback(void *data, struct pw_buffer *buffer)
+{
+    _THIS = data;
+
+    if (this->iscapture == SDL_FALSE) {
+        /*
+         * Clamp the output spec samples and size to the max size of the Pipewire buffer.
+         * If they exceed the maximum size of the Pipewire buffer, double buffering will be used.
+         */
+        if (this->spec.size > buffer->buffer->datas[0].maxsize) {
+            this->spec.samples = buffer->buffer->datas[0].maxsize / this->hidden->stride;
+            this->spec.size    = buffer->buffer->datas[0].maxsize;
+        }
+    } else if (this->hidden->buffer == NULL) {
+        /*
+         * The latency of source nodes can change, so buffering is always required.
+         *
+         * Ensure that the intermediate input buffer is large enough to hold the requested
+         * application packet size or a full buffer of data from Pipewire, whichever is larger.
+         *
+         * A packet size of 2 periods should be more than is ever needed.
+         */
+        this->hidden->input_buffer_packet_size = SPA_MAX(this->spec.size, buffer->buffer->datas[0].maxsize) * 2;
+        this->hidden->buffer                   = SDL_NewDataQueue(this->hidden->input_buffer_packet_size, this->hidden->input_buffer_packet_size);
+    }
+
+    this->hidden->stream_init_status |= PW_READY_FLAG_BUFFER_ADDED;
+    PIPEWIRE_pw_thread_loop_signal(this->hidden->loop, false);
+}
+
+static void
+stream_state_changed_callback(void *data, enum pw_stream_state old, enum pw_stream_state state, const char *error)
+{
+    _THIS = data;
+
+    if (state == PW_STREAM_STATE_STREAMING) {
+        this->hidden->stream_init_status |= PW_READY_FLAG_STREAM_READY;
+    }
+
+    if (state == PW_STREAM_STATE_STREAMING || state == PW_STREAM_STATE_ERROR) {
+        PIPEWIRE_pw_thread_loop_signal(this->hidden->loop, false);
+    }
+}
+
+static const struct pw_stream_events stream_output_events = { PW_VERSION_STREAM_EVENTS,
+                                                              .state_changed = stream_state_changed_callback,
+                                                              .add_buffer    = stream_add_buffer_callback,
+                                                              .process       = output_callback };
+static const struct pw_stream_events stream_input_events  = { PW_VERSION_STREAM_EVENTS,
+                                                              .state_changed = stream_state_changed_callback,
+                                                              .add_buffer    = stream_add_buffer_callback,
+                                                              .process       = input_callback };
+
+static int
+PIPEWIRE_OpenDevice(_THIS, const char *devname)
+{
+    /*
+     * NOTE: The PW_STREAM_FLAG_RT_PROCESS flag can be set to call the stream
+     * processing callback from the realtime thread.  However, it comes with some
+     * caveats: no file IO, allocations, locking or other blocking operations
+     * must occur in the mixer callback.  As this cannot be guaranteed when the
+     * callback is in the calling application, this flag is omitted.
+     */
+    static const enum pw_stream_flags STREAM_FLAGS = PW_STREAM_FLAG_AUTOCONNECT | PW_STREAM_FLAG_MAP_BUFFERS;
+
+    char                         thread_name[PW_THREAD_NAME_BUFFER_LENGTH];
+    Uint8                        pod_buffer[PW_POD_BUFFER_LENGTH];
+    struct spa_pod_builder       b        = SPA_POD_BUILDER_INIT(pod_buffer, sizeof(pod_buffer));
+    struct spa_audio_info_raw    spa_info = { 0 };
+    const struct spa_pod        *params   = NULL;
+    struct SDL_PrivateAudioData *priv;
+    struct pw_properties        *props;
+    const char                  *app_name, *stream_name, *stream_role, *error;
+    const Uint32                 node_id   = this->handle == NULL ? PW_ID_ANY : PW_HANDLE_TO_ID(this->handle);
+    SDL_bool                     iscapture = this->iscapture;
+    int                          res;
+
+    /* Clamp the period size to sane values */
+    const int min_period = PW_MIN_SAMPLES * SPA_MAX(this->spec.freq / PW_BASE_CLOCK_RATE, 1);
+
+    /* Get the hints for the application name, stream name and role */
+    app_name = SDL_GetHint(SDL_HINT_AUDIO_DEVICE_APP_NAME);
+    if (!app_name || *app_name == '\0') {
+        app_name = SDL_GetHint(SDL_HINT_APP_NAME);
+        if (!app_name || *app_name == '\0') {
+            app_name = "SDL Application";
+        }
+    }
+
+    stream_name = SDL_GetHint(SDL_HINT_AUDIO_DEVICE_STREAM_NAME);
+    if (!stream_name || *stream_name == '\0') {
+        stream_name = "Audio Stream";
+    }
+
+    /*
+     * 'Music' is the default used internally by Pipewire and it's modules,
+     * but 'Game' seems more appropriate for the majority of SDL applications.
+     */
+    stream_role = SDL_GetHint(SDL_HINT_AUDIO_DEVICE_STREAM_ROLE);
+    if (!stream_role || *stream_role == '\0') {
+        stream_role = "Game";
+    }
+
+    /* Initialize the Pipewire stream info from the SDL audio spec */
+    initialize_spa_info(&this->spec, &spa_info);
+    params = spa_format_audio_raw_build(&b, SPA_PARAM_EnumFormat, &spa_info);
+    if (params == NULL) {
+        return SDL_SetError("Pipewire: Failed to set audio format parameters");
+    }
+
+    if ((this->hidden = priv = SDL_calloc(1, sizeof(struct SDL_PrivateAudioData))) == NULL) {
+        return SDL_OutOfMemory();
+    }
+
+    /* Size of a single audio frame in bytes */
+    priv->stride = (SDL_AUDIO_BITSIZE(this->spec.format) >> 3) * this->spec.channels;
+
+    if (this->spec.samples < min_period) {
+        this->spec.samples = min_period;
+        this->spec.size    = this->spec.samples * priv->stride;
+    }
+
+    SDL_snprintf(thread_name, sizeof(thread_name), "SDLAudio%c%ld", (iscapture) ? 'C' : 'P', (long)this->handle);
+    priv->loop = PIPEWIRE_pw_thread_loop_new(thread_name, NULL);
+    if (priv->loop == NULL) {
+        return SDL_SetError("Pipewire: Failed to create stream loop (%i)", errno);
+    }
+
+    /*
+     * Load the realtime module so Pipewire can set the loop thread to the appropriate priority.
+     *
+     * NOTE: Pipewire versions 0.3.22 or higher require the PW_KEY_CONFIG_NAME property (with client-rt.conf),
+     *       lower versions require explicitly specifying the 'rtkit' module.
+     *
+     *       PW_KEY_CONTEXT_PROFILE_MODULES is deprecated and can be safely removed if the minimum required
+     *       Pipewire version is increased to 0.3.22 or higher at some point.
+     */
+    props = PIPEWIRE_pw_properties_new(PW_KEY_CONFIG_NAME, "client-rt.conf",
+                                       PW_KEY_CONTEXT_PROFILE_MODULES, "default,rtkit", NULL);
+    if (props == NULL) {
+        return SDL_SetError("Pipewire: Failed to create stream context properties (%i)", errno);
+    }
+
+    priv->context = PIPEWIRE_pw_context_new(PIPEWIRE_pw_thread_loop_get_loop(priv->loop), props, 0);
+    if (priv->context == NULL) {
+        return SDL_SetError("Pipewire: Failed to create stream context (%i)", errno);
+    }
+
+    props = PIPEWIRE_pw_properties_new(NULL, NULL);
+    if (props == NULL) {
+        return SDL_SetError("Pipewire: Failed to create stream properties (%i)", errno);
+    }
+
+    PIPEWIRE_pw_properties_set(props, PW_KEY_MEDIA_TYPE, "Audio");
+    PIPEWIRE_pw_properties_set(props, PW_KEY_MEDIA_CATEGORY, iscapture ? "Capture" : "Playback");
+    PIPEWIRE_pw_properties_set(props, PW_KEY_MEDIA_ROLE, stream_role);
+    PIPEWIRE_pw_properties_set(props, PW_KEY_APP_NAME, app_name);
+    PIPEWIRE_pw_properties_set(props, PW_KEY_NODE_NAME, stream_name);
+    PIPEWIRE_pw_properties_set(props, PW_KEY_NODE_DESCRIPTION, stream_name);
+    PIPEWIRE_pw_properties_setf(props, PW_KEY_NODE_LATENCY, "%u/%i", this->spec.samples, this->spec.freq);
+    PIPEWIRE_pw_properties_setf(props, PW_KEY_NODE_RATE, "1/%u", this->spec.freq);
+    PIPEWIRE_pw_properties_set(props, PW_KEY_NODE_ALWAYS_PROCESS, "true");
+
+    /* Create the new stream */
+    priv->stream = PIPEWIRE_pw_stream_new_simple(PIPEWIRE_pw_thread_loop_get_loop(priv->loop), stream_name, props,
+                                                 iscapture ? &stream_input_events : &stream_output_events, this);
+    if (priv->stream == NULL) {
+        return SDL_SetError("Pipewire: Failed to create stream (%i)", errno);
+    }
+
+    res = PIPEWIRE_pw_stream_connect(priv->stream, iscapture ? PW_DIRECTION_INPUT : PW_DIRECTION_OUTPUT, node_id, STREAM_FLAGS,
+                                     &params, 1);
+    if (res != 0) {
+        return SDL_SetError("Pipewire: Failed to connect stream");
+    }
+
+    res = PIPEWIRE_pw_thread_loop_start(priv->loop);
+    if (res != 0) {
+        return SDL_SetError("Pipewire: Failed to start stream loop");
+    }
+
+    /* Wait until all init flags are set or the stream has failed. */
+    PIPEWIRE_pw_thread_loop_lock(priv->loop);
+    while (priv->stream_init_status != PW_READY_FLAG_ALL_BITS &&
+           PIPEWIRE_pw_stream_get_state(priv->stream, NULL) != PW_STREAM_STATE_ERROR) {
+        PIPEWIRE_pw_thread_loop_wait(priv->loop);
+    }
+    PIPEWIRE_pw_thread_loop_unlock(priv->loop);
+
+    if (PIPEWIRE_pw_stream_get_state(priv->stream, &error) == PW_STREAM_STATE_ERROR) {
+        return SDL_SetError("Pipewire: Stream error: %s", error);
+    }
+
+    /* If this is a capture stream, make sure the intermediate buffer was successfully allocated. */
+    if (iscapture && priv->buffer == NULL) {
+        return SDL_SetError("Pipewire: Failed to allocate source buffer");
+    }
+
+    return 0;
+}
+
+static void PIPEWIRE_CloseDevice(_THIS)
+{
+    if (this->hidden->loop) {
+        PIPEWIRE_pw_thread_loop_stop(this->hidden->loop);
+    }
+
+    if (this->hidden->stream) {
+        PIPEWIRE_pw_stream_destroy(this->hidden->stream);
+    }
+
+    if (this->hidden->context) {
+        PIPEWIRE_pw_context_destroy(this->hidden->context);
+    }
+
+    if (this->hidden->loop) {
+        PIPEWIRE_pw_thread_loop_destroy(this->hidden->loop);
+    }
+
+    if (this->hidden->buffer) {
+        SDL_FreeDataQueue(this->hidden->buffer);
+    }
+
+    SDL_free(this->hidden);
+}
+
+static void
+PIPEWIRE_Deinitialize()
+{
+    if (pipewire_initialized) {
+        hotplug_loop_destroy();
+        deinit_pipewire_library();
+        pipewire_initialized = SDL_FALSE;
+    }
+}
+
+static SDL_bool
+PIPEWIRE_Init(SDL_AudioDriverImpl *impl)
+{
+    if (!pipewire_initialized) {
+        if (init_pipewire_library() < 0) {
+            return SDL_FALSE;
+        }
+
+        pipewire_initialized = SDL_TRUE;
+
+        if (hotplug_loop_init() < 0) {
+            PIPEWIRE_Deinitialize();
+            return SDL_FALSE;
+        }
+    }
+
+    /* Set the function pointers */
+    impl->DetectDevices = PIPEWIRE_DetectDevices;
+    impl->OpenDevice    = PIPEWIRE_OpenDevice;
+    impl->CloseDevice   = PIPEWIRE_CloseDevice;
+    impl->Deinitialize  = PIPEWIRE_Deinitialize;
+
+    impl->HasCaptureSupport         = SDL_TRUE;
+    impl->ProvidesOwnCallbackThread = SDL_TRUE;
+
+    return SDL_TRUE;
+}
+
+AudioBootStrap PIPEWIRE_bootstrap = { "pipewire", "Pipewire", PIPEWIRE_Init, SDL_FALSE };
+
+#endif /* SDL_AUDIO_DRIVER_PIPEWIRE */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/audio/pipewire/SDL_pipewire.h b/Engine/lib/sdl/src/audio/pipewire/SDL_pipewire.h
new file mode 100644
index 000000000..767b8f10c
--- /dev/null
+++ b/Engine/lib/sdl/src/audio/pipewire/SDL_pipewire.h
@@ -0,0 +1,47 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "../../SDL_internal.h"
+
+#ifndef SDL_pipewire_h_
+#define SDL_pipewire_h_
+
+#include "../SDL_sysaudio.h"
+#include <pipewire/pipewire.h>
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData
+{
+    struct pw_thread_loop *loop;
+    struct pw_stream      *stream;
+    struct pw_context     *context;
+    struct SDL_DataQueue  *buffer;
+
+    size_t input_buffer_packet_size;
+    Sint32 stride; /* Bytes-per-frame */
+    int    stream_init_status;
+};
+
+#endif /* SDL_pipewire_h_ */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/audio/psp/SDL_pspaudio.c b/Engine/lib/sdl/src/audio/psp/SDL_pspaudio.c
index bd27d35bf..d908170c6 100644
--- a/Engine/lib/sdl/src/audio/psp/SDL_pspaudio.c
+++ b/Engine/lib/sdl/src/audio/psp/SDL_pspaudio.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -25,7 +25,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
-#include <malloc.h>
+#include <malloc.h> /* memalign() */
 
 #include "SDL_audio.h"
 #include "SDL_error.h"
@@ -39,30 +39,48 @@
 #include <pspthreadman.h>
 
 /* The tag name used by PSP audio */
-#define PSPAUDIO_DRIVER_NAME         "psp"
+#define PSPAUDIO_DRIVER_NAME    "psp"
 
 static int
-PSPAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
+PSPAUDIO_OpenDevice(_THIS, const char *devname)
 {
     int format, mixlen, i;
+
     this->hidden = (struct SDL_PrivateAudioData *)
         SDL_malloc(sizeof(*this->hidden));
     if (this->hidden == NULL) {
         return SDL_OutOfMemory();
     }
     SDL_zerop(this->hidden);
-    switch (this->spec.format & 0xff) {
-        case 8:
-        case 16:
-            this->spec.format = AUDIO_S16LSB;
-            break;
-        default:
-            return SDL_SetError("Unsupported audio format");
-    }
+
+    /* device only natively supports S16LSB */
+    this->spec.format = AUDIO_S16LSB;
 
     /* The sample count must be a multiple of 64. */
     this->spec.samples = PSP_AUDIO_SAMPLE_ALIGN(this->spec.samples);
-    this->spec.freq = 44100;
+
+    /* Setup the hardware channel. */
+    if (this->spec.channels == 1) {
+        format = PSP_AUDIO_FORMAT_MONO;
+    } else {
+        format = PSP_AUDIO_FORMAT_STEREO;
+        this->spec.channels = 2;  /* we're forcing the hardware to stereo. */
+    }
+
+    /*  PSP has some limitations with the Audio. It fully supports 44.1KHz (Mono & Stereo),
+        however with frequencies differents than 44.1KHz, it just supports Stereo,
+        so a resampler must be done for these scenarios */
+    if (this->spec.freq == 44100) {
+        this->hidden->channel = sceAudioChReserve(PSP_AUDIO_NEXT_CHANNEL, this->spec.samples, format);
+    } else {
+        this->hidden->channel = sceAudioSRCChReserve(this->spec.samples, this->spec.freq, 2);
+    }
+    
+    if (this->hidden->channel < 0) {
+        free(this->hidden->rawbuf);
+        this->hidden->rawbuf = NULL;
+        return SDL_SetError("Couldn't reserve hardware channel");
+    }
 
     /* Update the fragment size as size in bytes. */
     SDL_CalculateAudioSpec(&this->spec);
@@ -76,21 +94,7 @@ PSPAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
         return SDL_SetError("Couldn't allocate mixing buffer");
     }
 
-    /* Setup the hardware channel. */
-    if (this->spec.channels == 1) {
-        format = PSP_AUDIO_FORMAT_MONO;
-    } else {
-        this->spec.channels = 2;
-        format = PSP_AUDIO_FORMAT_STEREO;
-    }
-    this->hidden->channel = sceAudioChReserve(PSP_AUDIO_NEXT_CHANNEL, this->spec.samples, format);
-    if (this->hidden->channel < 0) {
-        free(this->hidden->rawbuf);
-        this->hidden->rawbuf = NULL;
-        return SDL_SetError("Couldn't reserve hardware channel");
-    }
-
-    memset(this->hidden->rawbuf, 0, mixlen);
+    SDL_memset(this->hidden->rawbuf, 0, mixlen);
     for (i = 0; i < NUM_BUFFERS; i++) {
         this->hidden->mixbufs[i] = &this->hidden->rawbuf[i * this->spec.size];
     }
@@ -101,11 +105,12 @@ PSPAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
 
 static void PSPAUDIO_PlayDevice(_THIS)
 {
-    Uint8 *mixbuf = this->hidden->mixbufs[this->hidden->next_buffer];
-
-    if (this->spec.channels == 1) {
-        sceAudioOutputBlocking(this->hidden->channel, PSP_AUDIO_VOLUME_MAX, mixbuf);
+    if (this->spec.freq != 44100){
+        Uint8 *mixbuf = this->hidden->mixbufs[this->hidden->next_buffer];
+        SDL_assert(this->spec.channels == 2);
+        sceAudioSRCOutputBlocking(PSP_AUDIO_VOLUME_MAX, mixbuf);
     } else {
+        Uint8 *mixbuf = this->hidden->mixbufs[this->hidden->next_buffer];
         sceAudioOutputPannedBlocking(this->hidden->channel, PSP_AUDIO_VOLUME_MAX, PSP_AUDIO_VOLUME_MAX, mixbuf);
     }
 
@@ -117,6 +122,7 @@ static void PSPAUDIO_WaitDevice(_THIS)
 {
     /* Because we block when sending audio, there's no need for this function to do anything. */
 }
+
 static Uint8 *PSPAUDIO_GetDeviceBuf(_THIS)
 {
     return this->hidden->mixbufs[this->hidden->next_buffer];
@@ -125,10 +131,18 @@ static Uint8 *PSPAUDIO_GetDeviceBuf(_THIS)
 static void PSPAUDIO_CloseDevice(_THIS)
 {
     if (this->hidden->channel >= 0) {
-        sceAudioChRelease(this->hidden->channel);
+        if (this->spec.freq != 44100){
+            sceAudioSRCChRelease();
+        } else {
+            sceAudioChRelease(this->hidden->channel);
+        }
+        this->hidden->channel = -1;
+    }
+
+    if (this->hidden->rawbuf != NULL) {
+        free(this->hidden->rawbuf);
+        this->hidden->rawbuf = NULL;
     }
-    free(this->hidden->rawbuf);  /* this uses memalign(), not SDL_malloc(). */
-    SDL_free(this->hidden);
 }
 
 static void PSPAUDIO_ThreadInit(_THIS)
@@ -144,8 +158,7 @@ static void PSPAUDIO_ThreadInit(_THIS)
     }
 }
 
-
-static int
+static SDL_bool
 PSPAUDIO_Init(SDL_AudioDriverImpl * impl)
 {
     /* Set the function pointers */
@@ -157,25 +170,18 @@ PSPAUDIO_Init(SDL_AudioDriverImpl * impl)
     impl->ThreadInit = PSPAUDIO_ThreadInit;
 
     /* PSP audio device */
-    impl->OnlyHasDefaultOutputDevice = 1;
-/*
-    impl->HasCaptureSupport = 1;
-
-    impl->OnlyHasDefaultCaptureDevice = 1;
-*/
+    impl->OnlyHasDefaultOutputDevice = SDL_TRUE;
     /*
-    impl->DetectDevices = DSOUND_DetectDevices;
-    impl->Deinitialize = DSOUND_Deinitialize;
+    impl->HasCaptureSupport = SDL_TRUE;
+    impl->OnlyHasDefaultCaptureDevice = SDL_TRUE;
     */
-    return 1;   /* this audio target is available. */
+    return SDL_TRUE;   /* this audio target is available. */
 }
 
 AudioBootStrap PSPAUDIO_bootstrap = {
-    "psp", "PSP audio driver", PSPAUDIO_Init, 0
+    "psp", "PSP audio driver", PSPAUDIO_Init, SDL_FALSE
 };
 
- /* SDL_AUDI */
-
 #endif /* SDL_AUDIO_DRIVER_PSP */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/audio/psp/SDL_pspaudio.h b/Engine/lib/sdl/src/audio/psp/SDL_pspaudio.h
index 58a0c1c38..0e1af2cda 100644
--- a/Engine/lib/sdl/src/audio/psp/SDL_pspaudio.h
+++ b/Engine/lib/sdl/src/audio/psp/SDL_pspaudio.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/audio/pulseaudio/SDL_pulseaudio.c b/Engine/lib/sdl/src/audio/pulseaudio/SDL_pulseaudio.c
index d74c66dc2..a969f2b1f 100644
--- a/Engine/lib/sdl/src/audio/pulseaudio/SDL_pulseaudio.c
+++ b/Engine/lib/sdl/src/audio/pulseaudio/SDL_pulseaudio.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -46,6 +46,10 @@
 #include "SDL_loadso.h"
 #include "../../thread/SDL_systhread.h"
 
+/* should we include monitors in the device list? Set at SDL_Init time */
+static SDL_bool include_monitors = SDL_FALSE;
+
+
 #if (PA_API_VERSION < 12)
 /** Return non-zero if the passed state is one of the connected states */
 static SDL_INLINE int PA_CONTEXT_IS_GOOD(pa_context_state_t x) {
@@ -76,7 +80,7 @@ static void (*PULSEAUDIO_pa_mainloop_quit) (pa_mainloop *, int);
 static void (*PULSEAUDIO_pa_mainloop_free) (pa_mainloop *);
 
 static pa_operation_state_t (*PULSEAUDIO_pa_operation_get_state) (
-    pa_operation *);
+    const pa_operation *);
 static void (*PULSEAUDIO_pa_operation_cancel) (pa_operation *);
 static void (*PULSEAUDIO_pa_operation_unref) (pa_operation *);
 
@@ -88,7 +92,7 @@ static pa_operation * (*PULSEAUDIO_pa_context_get_sink_info_list) (pa_context *,
 static pa_operation * (*PULSEAUDIO_pa_context_get_source_info_list) (pa_context *, pa_source_info_cb_t, void *);
 static pa_operation * (*PULSEAUDIO_pa_context_get_sink_info_by_index) (pa_context *, uint32_t, pa_sink_info_cb_t, void *);
 static pa_operation * (*PULSEAUDIO_pa_context_get_source_info_by_index) (pa_context *, uint32_t, pa_source_info_cb_t, void *);
-static pa_context_state_t (*PULSEAUDIO_pa_context_get_state) (pa_context *);
+static pa_context_state_t (*PULSEAUDIO_pa_context_get_state) (const pa_context *);
 static pa_operation * (*PULSEAUDIO_pa_context_subscribe) (pa_context *, pa_subscription_mask_t, pa_context_success_cb_t, void *);
 static void (*PULSEAUDIO_pa_context_set_subscribe_callback) (pa_context *, pa_context_subscribe_cb_t, void *);
 static void (*PULSEAUDIO_pa_context_disconnect) (pa_context *);
@@ -97,12 +101,14 @@ static void (*PULSEAUDIO_pa_context_unref) (pa_context *);
 static pa_stream * (*PULSEAUDIO_pa_stream_new) (pa_context *, const char *,
     const pa_sample_spec *, const pa_channel_map *);
 static int (*PULSEAUDIO_pa_stream_connect_playback) (pa_stream *, const char *,
-    const pa_buffer_attr *, pa_stream_flags_t, pa_cvolume *, pa_stream *);
+    const pa_buffer_attr *, pa_stream_flags_t, const pa_cvolume *, pa_stream *);
 static int (*PULSEAUDIO_pa_stream_connect_record) (pa_stream *, const char *,
     const pa_buffer_attr *, pa_stream_flags_t);
-static pa_stream_state_t (*PULSEAUDIO_pa_stream_get_state) (pa_stream *);
-static size_t (*PULSEAUDIO_pa_stream_writable_size) (pa_stream *);
-static size_t (*PULSEAUDIO_pa_stream_readable_size) (pa_stream *);
+static pa_stream_state_t (*PULSEAUDIO_pa_stream_get_state) (const pa_stream *);
+static size_t (*PULSEAUDIO_pa_stream_writable_size) (const pa_stream *);
+static size_t (*PULSEAUDIO_pa_stream_readable_size) (const pa_stream *);
+static int (*PULSEAUDIO_pa_stream_begin_write) (pa_stream *, void **, size_t*);
+static int (*PULSEAUDIO_pa_stream_cancel_write) (pa_stream *);
 static int (*PULSEAUDIO_pa_stream_write) (pa_stream *, const void *, size_t,
     pa_free_cb_t, int64_t, pa_seek_mode_t);
 static pa_operation * (*PULSEAUDIO_pa_stream_drain) (pa_stream *,
@@ -216,6 +222,8 @@ load_pulseaudio_syms(void)
     SDL_PULSEAUDIO_SYM(pa_stream_writable_size);
     SDL_PULSEAUDIO_SYM(pa_stream_readable_size);
     SDL_PULSEAUDIO_SYM(pa_stream_write);
+    SDL_PULSEAUDIO_SYM(pa_stream_begin_write);
+    SDL_PULSEAUDIO_SYM(pa_stream_cancel_write);
     SDL_PULSEAUDIO_SYM(pa_stream_drain);
     SDL_PULSEAUDIO_SYM(pa_stream_disconnect);
     SDL_PULSEAUDIO_SYM(pa_stream_peek);
@@ -238,7 +246,13 @@ static const char *
 getAppName(void)
 {
     const char *retval = SDL_GetHint(SDL_HINT_AUDIO_DEVICE_APP_NAME);
-    if (!retval || !*retval) {
+    if (retval && *retval) {
+        return retval;
+    }
+    retval = SDL_GetHint(SDL_HINT_APP_NAME);
+    if (retval && *retval) {
+        return retval;
+    } else {
         const char *verstr = PULSEAUDIO_pa_get_library_version();
         retval = "SDL Application";  /* the "oh well" default. */
         if (verstr != NULL) {
@@ -354,7 +368,7 @@ PULSEAUDIO_WaitDevice(_THIS)
             SDL_OpenedAudioDeviceDisconnected(this);
             return;
         }
-        if (PULSEAUDIO_pa_stream_writable_size(h->stream) >= h->mixlen) {
+        if (PULSEAUDIO_pa_stream_writable_size(h->stream) >= (h->mixlen/8)) {
             return;
         }
     }
@@ -366,7 +380,7 @@ PULSEAUDIO_PlayDevice(_THIS)
     /* Write the audio data */
     struct SDL_PrivateAudioData *h = this->hidden;
     if (SDL_AtomicGet(&this->enabled)) {
-        if (PULSEAUDIO_pa_stream_write(h->stream, h->mixbuf, h->mixlen, NULL, 0LL, PA_SEEK_RELATIVE) < 0) {
+        if (PULSEAUDIO_pa_stream_write(h->stream, h->pabuf, h->mixlen, NULL, 0LL, PA_SEEK_RELATIVE) < 0) {
             SDL_OpenedAudioDeviceDisconnected(this);
         }
     }
@@ -375,7 +389,21 @@ PULSEAUDIO_PlayDevice(_THIS)
 static Uint8 *
 PULSEAUDIO_GetDeviceBuf(_THIS)
 {
-    return (this->hidden->mixbuf);
+    struct SDL_PrivateAudioData *h = this->hidden;
+    size_t nbytes = h->mixlen;
+    int ret;
+
+    ret = PULSEAUDIO_pa_stream_begin_write(h->stream, &h->pabuf, &nbytes);
+
+    if (ret != 0) {
+        /* fall back it intermediate buffer */
+        h->pabuf = h->mixbuf;
+    } else if (nbytes < h->mixlen) {
+        PULSEAUDIO_pa_stream_cancel_write(h->stream);
+        h->pabuf = h->mixbuf;
+    }
+
+    return (Uint8 *)h->pabuf;
 }
 
 
@@ -494,7 +522,7 @@ SourceDeviceNameCallback(pa_context *c, const pa_source_info *i, int is_last, vo
 }
 
 static SDL_bool
-FindDeviceName(struct SDL_PrivateAudioData *h, const int iscapture, void *handle)
+FindDeviceName(struct SDL_PrivateAudioData *h, const SDL_bool iscapture, void *handle)
 {
     const uint32_t idx = ((uint32_t) ((size_t) handle)) - 1;
 
@@ -516,16 +544,17 @@ FindDeviceName(struct SDL_PrivateAudioData *h, const int iscapture, void *handle
 }
 
 static int
-PULSEAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
+PULSEAUDIO_OpenDevice(_THIS, const char *devname)
 {
     struct SDL_PrivateAudioData *h = NULL;
-    Uint16 test_format = 0;
+    SDL_AudioFormat test_format;
     pa_sample_spec paspec;
     pa_buffer_attr paattr;
     pa_channel_map pacmap;
     pa_stream_flags_t flags = 0;
     const char *name = NULL;
-    int state = 0;
+    SDL_bool iscapture = this->iscapture;
+    int state = 0, format = PA_SAMPLE_INVALID;
     int rc = 0;
 
     /* Initialize all variables that we clean on shutdown */
@@ -536,48 +565,43 @@ PULSEAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
     }
     SDL_zerop(this->hidden);
 
-    paspec.format = PA_SAMPLE_INVALID;
-
     /* Try for a closest match on audio format */
-    for (test_format = SDL_FirstAudioFormat(this->spec.format);
-         (paspec.format == PA_SAMPLE_INVALID) && test_format;) {
+    for (test_format = SDL_FirstAudioFormat(this->spec.format); test_format; test_format = SDL_NextAudioFormat()) {
 #ifdef DEBUG_AUDIO
         fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
 #endif
         switch (test_format) {
         case AUDIO_U8:
-            paspec.format = PA_SAMPLE_U8;
+            format = PA_SAMPLE_U8;
             break;
         case AUDIO_S16LSB:
-            paspec.format = PA_SAMPLE_S16LE;
+            format = PA_SAMPLE_S16LE;
             break;
         case AUDIO_S16MSB:
-            paspec.format = PA_SAMPLE_S16BE;
+            format = PA_SAMPLE_S16BE;
             break;
         case AUDIO_S32LSB:
-            paspec.format = PA_SAMPLE_S32LE;
+            format = PA_SAMPLE_S32LE;
             break;
         case AUDIO_S32MSB:
-            paspec.format = PA_SAMPLE_S32BE;
+            format = PA_SAMPLE_S32BE;
             break;
         case AUDIO_F32LSB:
-            paspec.format = PA_SAMPLE_FLOAT32LE;
+            format = PA_SAMPLE_FLOAT32LE;
             break;
         case AUDIO_F32MSB:
-            paspec.format = PA_SAMPLE_FLOAT32BE;
+            format = PA_SAMPLE_FLOAT32BE;
             break;
         default:
-            paspec.format = PA_SAMPLE_INVALID;
-            break;
-        }
-        if (paspec.format == PA_SAMPLE_INVALID) {
-            test_format = SDL_NextAudioFormat();
+            continue;
         }
+        break;
     }
-    if (paspec.format == PA_SAMPLE_INVALID) {
-        return SDL_SetError("Couldn't find any hardware audio formats");
+    if (!test_format) {
+        return SDL_SetError("%s: Unsupported audio format", "pulseaudio");
     }
     this->spec.format = test_format;
+    paspec.format = format;
 
     /* Calculate the final parameters for this audio specification */
 #ifdef PA_STREAM_ADJUST_LATENCY
@@ -600,6 +624,7 @@ PULSEAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
 
     /* Reduced prebuffering compared to the defaults. */
 #ifdef PA_STREAM_ADJUST_LATENCY
+    paattr.fragsize = this->spec.size;
     /* 2x original requested bufsize */
     paattr.tlength = h->mixlen * 4;
     paattr.prebuf = -1;
@@ -608,6 +633,7 @@ PULSEAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
     paattr.minreq = h->mixlen;
     flags = PA_STREAM_ADJUST_LATENCY;
 #else
+    paattr.fragsize = this->spec.size;
     paattr.tlength = h->mixlen*2;
     paattr.prebuf = h->mixlen*2;
     paattr.maxlength = h->mixlen*2;
@@ -618,7 +644,7 @@ PULSEAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
         return SDL_SetError("Could not connect to PulseAudio server");
     }
 
-    if (!FindDeviceName(h, iscapture, handle)) {
+    if (!FindDeviceName(h, iscapture, this->handle)) {
         return SDL_SetError("Requested PulseAudio sink/source missing?");
     }
 
@@ -676,12 +702,45 @@ static SDL_Thread *hotplug_thread = NULL;
 
 /* device handles are device index + 1, cast to void*, so we never pass a NULL. */
 
+static SDL_AudioFormat
+PulseFormatToSDLFormat(pa_sample_format_t format)
+{
+    switch (format) {
+    case PA_SAMPLE_U8:
+        return AUDIO_U8;
+    case PA_SAMPLE_S16LE:
+        return AUDIO_S16LSB;
+    case PA_SAMPLE_S16BE:
+        return AUDIO_S16MSB;
+    case PA_SAMPLE_S32LE:
+        return AUDIO_S32LSB;
+    case PA_SAMPLE_S32BE:
+        return AUDIO_S32MSB;
+    case PA_SAMPLE_FLOAT32LE:
+        return AUDIO_F32LSB;
+    case PA_SAMPLE_FLOAT32BE:
+        return AUDIO_F32MSB;
+    default:
+        return 0;
+    }
+}
+
 /* This is called when PulseAudio adds an output ("sink") device. */
 static void
 SinkInfoCallback(pa_context *c, const pa_sink_info *i, int is_last, void *data)
 {
+    SDL_AudioSpec spec;
     if (i) {
-        SDL_AddAudioDevice(SDL_FALSE, i->description, (void *) ((size_t) i->index+1));
+        spec.freq = i->sample_spec.rate;
+        spec.channels = i->sample_spec.channels;
+        spec.format = PulseFormatToSDLFormat(i->sample_spec.format);
+        spec.silence = 0;
+        spec.samples = 0;
+        spec.size = 0;
+        spec.callback = NULL;
+        spec.userdata = NULL;
+
+        SDL_AddAudioDevice(SDL_FALSE, i->description, &spec, (void *) ((size_t) i->index+1));
     }
 }
 
@@ -689,10 +748,20 @@ SinkInfoCallback(pa_context *c, const pa_sink_info *i, int is_last, void *data)
 static void
 SourceInfoCallback(pa_context *c, const pa_source_info *i, int is_last, void *data)
 {
+    SDL_AudioSpec spec;
     if (i) {
-        /* Skip "monitor" sources. These are just output from other sinks. */
-        if (i->monitor_of_sink == PA_INVALID_INDEX) {
-            SDL_AddAudioDevice(SDL_TRUE, i->description, (void *) ((size_t) i->index+1));
+        /* Maybe skip "monitor" sources. These are just output from other sinks. */
+        if (include_monitors || (i->monitor_of_sink == PA_INVALID_INDEX)) {
+            spec.freq = i->sample_spec.rate;
+            spec.channels = i->sample_spec.channels;
+            spec.format = PulseFormatToSDLFormat(i->sample_spec.format);
+            spec.silence = 0;
+            spec.samples = 0;
+            spec.size = 0;
+            spec.callback = NULL;
+            spec.userdata = NULL;
+
+            SDL_AddAudioDevice(SDL_TRUE, i->description, &spec, (void *) ((size_t) i->index+1));
         }
     }
 }
@@ -759,18 +828,20 @@ PULSEAUDIO_Deinitialize(void)
     UnloadPulseAudioLibrary();
 }
 
-static int
+static SDL_bool
 PULSEAUDIO_Init(SDL_AudioDriverImpl * impl)
 {
     if (LoadPulseAudioLibrary() < 0) {
-        return 0;
+        return SDL_FALSE;
     }
 
     if (ConnectToPulseServer(&hotplug_mainloop, &hotplug_context) < 0) {
         UnloadPulseAudioLibrary();
-        return 0;
+        return SDL_FALSE;
     }
 
+    include_monitors = SDL_GetHintBoolean(SDL_HINT_AUDIO_INCLUDE_MONITORS, SDL_FALSE);
+
     /* Set the function pointers */
     impl->DetectDevices = PULSEAUDIO_DetectDevices;
     impl->OpenDevice = PULSEAUDIO_OpenDevice;
@@ -784,11 +855,11 @@ PULSEAUDIO_Init(SDL_AudioDriverImpl * impl)
 
     impl->HasCaptureSupport = SDL_TRUE;
 
-    return 1;   /* this audio target is available. */
+    return SDL_TRUE;   /* this audio target is available. */
 }
 
 AudioBootStrap PULSEAUDIO_bootstrap = {
-    "pulseaudio", "PulseAudio", PULSEAUDIO_Init, 0
+    "pulseaudio", "PulseAudio", PULSEAUDIO_Init, SDL_FALSE
 };
 
 #endif /* SDL_AUDIO_DRIVER_PULSEAUDIO */
diff --git a/Engine/lib/sdl/src/audio/pulseaudio/SDL_pulseaudio.h b/Engine/lib/sdl/src/audio/pulseaudio/SDL_pulseaudio.h
index 2c51eb62e..a0d0b0c98 100644
--- a/Engine/lib/sdl/src/audio/pulseaudio/SDL_pulseaudio.h
+++ b/Engine/lib/sdl/src/audio/pulseaudio/SDL_pulseaudio.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -43,6 +43,12 @@ struct SDL_PrivateAudioData
     Uint8 *mixbuf;
     int mixlen;
 
+    /* Pointer to the actual buffer in use in the current
+       GetDeviceBuf() -> PlayDevice() iteration.
+       Can be either the pointer returned by pa_stream_begin_write()
+       or mixbuf */
+    void *pabuf;
+
     const Uint8 *capturebuf;
     int capturelen;
 };
diff --git a/Engine/lib/sdl/src/audio/qsa/SDL_qsa_audio.c b/Engine/lib/sdl/src/audio/qsa/SDL_qsa_audio.c
index 4276e0790..5c4ab38ba 100644
--- a/Engine/lib/sdl/src/audio/qsa/SDL_qsa_audio.c
+++ b/Engine/lib/sdl/src/audio/qsa/SDL_qsa_audio.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -120,7 +120,9 @@ QSA_WaitDevice(_THIS)
     /* If timeout occured than something wrong with hardware or driver    */
     /* For example, Vortex 8820 audio driver stucks on second DAC because */
     /* it doesn't exist !                                                 */
-    result = SDL_IOReady(this->hidden->audio_fd, !this->hidden->iscapture, 2 * 1000);
+    result = SDL_IOReady(this->hidden->audio_fd,
+                         this->iscapture ? SDL_IOR_READ : SDL_IOR_WRITE,
+                         2 * 1000);
     switch (result) {
     case -1:
         SDL_SetError("QSA: SDL_IOReady() failed: %s", strerror(errno));
@@ -178,7 +180,7 @@ QSA_PlayDevice(_THIS)
             } else {
                 if ((errno == EINVAL) || (errno == EIO)) {
                     SDL_zero(cstatus);
-                    if (!this->hidden->iscapture) {
+                    if (!this->iscapture) {
                         cstatus.channel = SND_PCM_CHANNEL_PLAYBACK;
                     } else {
                         cstatus.channel = SND_PCM_CHANNEL_CAPTURE;
@@ -194,7 +196,7 @@ QSA_PlayDevice(_THIS)
 
                     if ((cstatus.status == SND_PCM_STATUS_UNDERRUN) ||
                         (cstatus.status == SND_PCM_STATUS_READY)) {
-                        if (!this->hidden->iscapture) {
+                        if (!this->iscapture) {
                             status =
                                 snd_pcm_plugin_prepare(this->hidden->
                                                        audio_handle,
@@ -238,7 +240,7 @@ static void
 QSA_CloseDevice(_THIS)
 {
     if (this->hidden->audio_handle != NULL) {
-        if (!this->hidden->iscapture) {
+        if (!this->iscapture) {
             /* Finish playing available samples */
             snd_pcm_plugin_flush(this->hidden->audio_handle,
                                  SND_PCM_CHANNEL_PLAYBACK);
@@ -255,13 +257,13 @@ QSA_CloseDevice(_THIS)
 }
 
 static int
-QSA_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
+QSA_OpenDevice(_THIS, const char *devname)
 {
-    const QSA_Device *device = (const QSA_Device *) handle;
+    const QSA_Device *device = (const QSA_Device *) this->handle;
+    SDL_Bool iscapture = this->iscapture;
     int status = 0;
     int format = 0;
-    SDL_AudioFormat test_format = 0;
-    int found = 0;
+    SDL_AudioFormat test_format;
     snd_pcm_channel_setup_t csetup;
     snd_pcm_channel_params_t cparams;
 
@@ -278,9 +280,6 @@ QSA_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
     /* Initialize channel transfer parameters to default */
     QSA_InitAudioParams(&cparams);
 
-    /* Initialize channel direction: capture or playback */
-    this->hidden->iscapture = iscapture ? SDL_TRUE : SDL_FALSE;
-
     if (device != NULL) {
         /* Open requested audio device */
         this->hidden->deviceno = device->deviceno;
@@ -303,89 +302,49 @@ QSA_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
     }
 
     /* Try for a closest match on audio format */
-    format = 0;
-    /* can't use format as SND_PCM_SFMT_U8 = 0 in qsa */
-    found = 0;
-
-    for (test_format = SDL_FirstAudioFormat(this->spec.format); !found;) {
+    for (test_format = SDL_FirstAudioFormat(this->spec.format); test_format; test_format = SDL_NextAudioFormat()) {
         /* if match found set format to equivalent QSA format */
         switch (test_format) {
         case AUDIO_U8:
-            {
-                format = SND_PCM_SFMT_U8;
-                found = 1;
-            }
+            format = SND_PCM_SFMT_U8;
             break;
         case AUDIO_S8:
-            {
-                format = SND_PCM_SFMT_S8;
-                found = 1;
-            }
+            format = SND_PCM_SFMT_S8;
             break;
         case AUDIO_S16LSB:
-            {
-                format = SND_PCM_SFMT_S16_LE;
-                found = 1;
-            }
+            format = SND_PCM_SFMT_S16_LE;
             break;
         case AUDIO_S16MSB:
-            {
-                format = SND_PCM_SFMT_S16_BE;
-                found = 1;
-            }
+            format = SND_PCM_SFMT_S16_BE;
             break;
         case AUDIO_U16LSB:
-            {
-                format = SND_PCM_SFMT_U16_LE;
-                found = 1;
-            }
+            format = SND_PCM_SFMT_U16_LE;
             break;
         case AUDIO_U16MSB:
-            {
-                format = SND_PCM_SFMT_U16_BE;
-                found = 1;
-            }
+            format = SND_PCM_SFMT_U16_BE;
             break;
         case AUDIO_S32LSB:
-            {
-                format = SND_PCM_SFMT_S32_LE;
-                found = 1;
-            }
+            format = SND_PCM_SFMT_S32_LE;
             break;
         case AUDIO_S32MSB:
-            {
-                format = SND_PCM_SFMT_S32_BE;
-                found = 1;
-            }
+            format = SND_PCM_SFMT_S32_BE;
             break;
         case AUDIO_F32LSB:
-            {
-                format = SND_PCM_SFMT_FLOAT_LE;
-                found = 1;
-            }
+            format = SND_PCM_SFMT_FLOAT_LE;
             break;
         case AUDIO_F32MSB:
-            {
-                format = SND_PCM_SFMT_FLOAT_BE;
-                found = 1;
-            }
+            format = SND_PCM_SFMT_FLOAT_BE;
             break;
         default:
-            {
-                break;
-            }
-        }
-
-        if (!found) {
-            test_format = SDL_NextAudioFormat();
+            continue;
         }
+        break;
     }
-
     /* assumes test_format not 0 on success */
-    if (test_format == 0) {
-        return SDL_SetError("QSA: Couldn't find any hardware audio formats");
+    /* can't use format as SND_PCM_SFMT_U8 = 0 in qsa */
+    if (!test_format) {
+        return SDL_SetError("%s: Unsupported audio format", "qsa");
     }
-
     this->spec.format = test_format;
 
     /* Set the audio format */
@@ -405,7 +364,7 @@ QSA_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
 
     /* Make sure channel is setup right one last time */
     SDL_zero(csetup);
-    if (!this->hidden->iscapture) {
+    if (!this->iscapture) {
         csetup.channel = SND_PCM_CHANNEL_PLAYBACK;
     } else {
         csetup.channel = SND_PCM_CHANNEL_CAPTURE;
@@ -441,7 +400,7 @@ QSA_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
                this->hidden->pcm_len);
 
     /* get the file descriptor */
-    if (!this->hidden->iscapture) {
+    if (!this->iscapture) {
         this->hidden->audio_fd =
             snd_pcm_file_descriptor(this->hidden->audio_handle,
                                     SND_PCM_CHANNEL_PLAYBACK);
@@ -456,7 +415,7 @@ QSA_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
     }
 
     /* Prepare an audio channel */
-    if (!this->hidden->iscapture) {
+    if (!this->iscapture) {
         /* Prepare audio playback */
         status =
             snd_pcm_plugin_prepare(this->hidden->audio_handle,
@@ -528,7 +487,11 @@ QSA_DetectDevices(void)
                             devices;
                         status = snd_pcm_close(handle);
                         if (status == EOK) {
-                            SDL_AddAudioDevice(SDL_FALSE, qsa_playback_device[qsa_playback_devices].name, &qsa_playback_device[qsa_playback_devices]);
+                            /* Note that spec is NULL, because we are required to open the device before
+                             * acquiring the mix format, making this information inaccessible at
+                             * enumeration time
+                             */
+                            SDL_AddAudioDevice(SDL_FALSE, qsa_playback_device[qsa_playback_devices].name, NULL, &qsa_playback_device[qsa_playback_devices]);
                             qsa_playback_devices++;
                         }
                     } else {
@@ -586,7 +549,11 @@ QSA_DetectDevices(void)
                             devices;
                         status = snd_pcm_close(handle);
                         if (status == EOK) {
-                            SDL_AddAudioDevice(SDL_TRUE, qsa_capture_device[qsa_capture_devices].name, &qsa_capture_device[qsa_capture_devices]);
+                            /* Note that spec is NULL, because we are required to open the device before
+                             * acquiring the mix format, making this information inaccessible at
+                             * enumeration time
+                             */
+                            SDL_AddAudioDevice(SDL_TRUE, qsa_capture_device[qsa_capture_devices].name, NULL, &qsa_capture_device[qsa_capture_devices]);
                             qsa_capture_devices++;
                         }
                     } else {
@@ -625,7 +592,7 @@ QSA_Deinitialize(void)
     qsa_capture_devices = 0;
 }
 
-static int
+static SDL_bool
 QSA_Init(SDL_AudioDriverImpl * impl)
 {
     /* Clear devices array */
@@ -645,20 +612,14 @@ QSA_Init(SDL_AudioDriverImpl * impl)
     impl->GetDeviceBuf = QSA_GetDeviceBuf;
     impl->CloseDevice = QSA_CloseDevice;
     impl->Deinitialize = QSA_Deinitialize;
-    impl->LockDevice = NULL;
-    impl->UnlockDevice = NULL;
 
-    impl->ProvidesOwnCallbackThread = 0;
-    impl->SkipMixerLock = 0;
-    impl->HasCaptureSupport = 1;
-    impl->OnlyHasDefaultOutputDevice = 0;
-    impl->OnlyHasDefaultCaptureDevice = 0;
+    impl->HasCaptureSupport = SDL_TRUE;
 
-    return 1;   /* this audio target is available. */
+    return SDL_TRUE;   /* this audio target is available. */
 }
 
 AudioBootStrap QSAAUDIO_bootstrap = {
-    "qsa", "QNX QSA Audio", QSA_Init, 0
+    "qsa", "QNX QSA Audio", QSA_Init, SDL_FALSE
 };
 
 #endif /* SDL_AUDIO_DRIVER_QSA */
diff --git a/Engine/lib/sdl/src/audio/qsa/SDL_qsa_audio.h b/Engine/lib/sdl/src/audio/qsa/SDL_qsa_audio.h
index 2340617ad..e4845c9eb 100644
--- a/Engine/lib/sdl/src/audio/qsa/SDL_qsa_audio.h
+++ b/Engine/lib/sdl/src/audio/qsa/SDL_qsa_audio.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -33,9 +33,6 @@
 
 struct SDL_PrivateAudioData
 {
-    /* SDL capture state */
-    SDL_bool iscapture;
-
     /* The audio device handle */
     int cardno;
     int deviceno;
diff --git a/Engine/lib/sdl/src/audio/sndio/SDL_sndioaudio.c b/Engine/lib/sdl/src/audio/sndio/SDL_sndioaudio.c
index 41a6c438f..29e5315b9 100644
--- a/Engine/lib/sdl/src/audio/sndio/SDL_sndioaudio.c
+++ b/Engine/lib/sdl/src/audio/sndio/SDL_sndioaudio.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -237,11 +237,11 @@ SNDIO_CloseDevice(_THIS)
 }
 
 static int
-SNDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
+SNDIO_OpenDevice(_THIS, const char *devname)
 {
-    SDL_AudioFormat test_format = SDL_FirstAudioFormat(this->spec.format);
+    SDL_AudioFormat test_format;
     struct sio_par par;
-    int status;
+    SDL_bool iscapture = this->iscapture;
 
     this->hidden = (struct SDL_PrivateAudioData *)
         SDL_malloc(sizeof(*this->hidden));
@@ -273,8 +273,7 @@ SNDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
     par.appbufsz = par.round * 2;
 
     /* Try for a closest match on audio format */
-    status = -1;
-    while (test_format && (status < 0)) {
+    for (test_format = SDL_FirstAudioFormat(this->spec.format); test_format; test_format = SDL_NextAudioFormat()) {
         if (!SDL_AUDIO_ISFLOAT(test_format)) {
             par.le = SDL_AUDIO_ISLITTLEENDIAN(test_format) ? 1 : 0;
             par.sig = SDL_AUDIO_ISSIGNED(test_format) ? 1 : 0;
@@ -290,15 +289,13 @@ SNDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
                 continue;
             }
             if ((par.bits == 8 * par.bps) || (par.msb)) {
-                status = 0;
                 break;
             }
         }
-        test_format = SDL_NextAudioFormat();
     }
 
-    if (status < 0) {
-        return SDL_SetError("sndio: Couldn't find any hardware audio formats");
+    if (!test_format) {
+        return SDL_SetError("%s: Unsupported audio format", "sndio");
     }
 
     if ((par.bps == 4) && (par.sig) && (par.le))
@@ -350,11 +347,18 @@ SNDIO_Deinitialize(void)
     UnloadSNDIOLibrary();
 }
 
-static int
+static void
+SNDIO_DetectDevices(void)
+{
+	SDL_AddAudioDevice(SDL_FALSE, DEFAULT_OUTPUT_DEVNAME, NULL, (void *) 0x1);
+	SDL_AddAudioDevice(SDL_TRUE, DEFAULT_INPUT_DEVNAME, NULL, (void *) 0x2);
+}
+
+static SDL_bool
 SNDIO_Init(SDL_AudioDriverImpl * impl)
 {
     if (LoadSNDIOLibrary() < 0) {
-        return 0;
+        return SDL_FALSE;
     }
 
     /* Set the function pointers */
@@ -366,15 +370,16 @@ SNDIO_Init(SDL_AudioDriverImpl * impl)
     impl->CaptureFromDevice = SNDIO_CaptureFromDevice;
     impl->FlushCapture = SNDIO_FlushCapture;
     impl->Deinitialize = SNDIO_Deinitialize;
+    impl->DetectDevices = SNDIO_DetectDevices;
 
-    impl->AllowsArbitraryDeviceNames = 1;
+    impl->AllowsArbitraryDeviceNames = SDL_TRUE;
     impl->HasCaptureSupport = SDL_TRUE;
 
-    return 1;   /* this audio target is available. */
+    return SDL_TRUE;   /* this audio target is available. */
 }
 
 AudioBootStrap SNDIO_bootstrap = {
-    "sndio", "OpenBSD sndio", SNDIO_Init, 0
+    "sndio", "OpenBSD sndio", SNDIO_Init, SDL_FALSE
 };
 
 #endif /* SDL_AUDIO_DRIVER_SNDIO */
diff --git a/Engine/lib/sdl/src/audio/sndio/SDL_sndioaudio.h b/Engine/lib/sdl/src/audio/sndio/SDL_sndioaudio.h
index 71976611d..57db05cb9 100644
--- a/Engine/lib/sdl/src/audio/sndio/SDL_sndioaudio.h
+++ b/Engine/lib/sdl/src/audio/sndio/SDL_sndioaudio.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/audio/sun/SDL_sunaudio.c b/Engine/lib/sdl/src/audio/sun/SDL_sunaudio.c
index e018f60ae..595692423 100644
--- a/Engine/lib/sdl/src/audio/sun/SDL_sunaudio.c
+++ b/Engine/lib/sdl/src/audio/sun/SDL_sunaudio.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -98,7 +98,7 @@ SUNAUDIO_WaitDevice(_THIS)
         }
     }
 #else
-    SDL_IOReady(this->hidden->audio_fd, SDL_TRUE, -1);
+    SDL_IOReady(this->hidden->audio_fd, SDL_IOR_WRITE, -1);
 #endif
 }
 
@@ -188,11 +188,12 @@ SUNAUDIO_CloseDevice(_THIS)
 }
 
 static int
-SUNAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
+SUNAUDIO_OpenDevice(_THIS, const char *devname)
 {
 #ifdef AUDIO_SETINFO
     int enc;
 #endif
+    SDL_bool iscapture = this->iscapture;
     int desired_freq = 0;
     const int flags = ((iscapture) ? OPEN_FLAGS_INPUT : OPEN_FLAGS_OUTPUT);
     SDL_AudioFormat format = 0;
@@ -394,7 +395,7 @@ snd2au(int sample)
     return (mask & sample);
 }
 
-static int
+static SDL_bool
 SUNAUDIO_Init(SDL_AudioDriverImpl * impl)
 {
     /* Set the function pointers */
@@ -405,13 +406,13 @@ SUNAUDIO_Init(SDL_AudioDriverImpl * impl)
     impl->GetDeviceBuf = SUNAUDIO_GetDeviceBuf;
     impl->CloseDevice = SUNAUDIO_CloseDevice;
 
-    impl->AllowsArbitraryDeviceNames = 1;
+    impl->AllowsArbitraryDeviceNames = SDL_TRUE;
 
-    return 1; /* this audio target is available. */
+    return SDL_TRUE; /* this audio target is available. */
 }
 
 AudioBootStrap SUNAUDIO_bootstrap = {
-    "audio", "UNIX /dev/audio interface", SUNAUDIO_Init, 0
+    "audio", "UNIX /dev/audio interface", SUNAUDIO_Init, SDL_FALSE
 };
 
 #endif /* SDL_AUDIO_DRIVER_SUNAUDIO */
diff --git a/Engine/lib/sdl/src/audio/sun/SDL_sunaudio.h b/Engine/lib/sdl/src/audio/sun/SDL_sunaudio.h
index 16f3b4f55..33ee755f6 100644
--- a/Engine/lib/sdl/src/audio/sun/SDL_sunaudio.h
+++ b/Engine/lib/sdl/src/audio/sun/SDL_sunaudio.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/audio/vita/SDL_vitaaudio.c b/Engine/lib/sdl/src/audio/vita/SDL_vitaaudio.c
new file mode 100644
index 000000000..524124e80
--- /dev/null
+++ b/Engine/lib/sdl/src/audio/vita/SDL_vitaaudio.c
@@ -0,0 +1,183 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if SDL_AUDIO_DRIVER_VITA
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <malloc.h> /* memalign() */
+
+#include "SDL_audio.h"
+#include "SDL_error.h"
+#include "SDL_timer.h"
+#include "../SDL_audio_c.h"
+#include "../SDL_audiodev_c.h"
+#include "../SDL_sysaudio.h"
+#include "SDL_vitaaudio.h"
+
+#include <psp2/kernel/threadmgr.h>
+#include <psp2/audioout.h>
+
+#define SCE_AUDIO_SAMPLE_ALIGN(s)   (((s) + 63) & ~63)
+#define SCE_AUDIO_MAX_VOLUME    0x8000
+
+/* The tag name used by VITA audio */
+#define VITAAUD_DRIVER_NAME     "vita"
+
+static int
+VITAAUD_OpenDevice(_THIS, const char *devname)
+{
+    int format, mixlen, i, port = SCE_AUDIO_OUT_PORT_TYPE_MAIN;
+    int vols[2] = {SCE_AUDIO_MAX_VOLUME, SCE_AUDIO_MAX_VOLUME};
+
+    this->hidden = (struct SDL_PrivateAudioData *)
+        SDL_malloc(sizeof(*this->hidden));
+    if (this->hidden == NULL) {
+        return SDL_OutOfMemory();
+    }
+    SDL_memset(this->hidden, 0, sizeof(*this->hidden));
+    switch (this->spec.format & 0xff) {
+        case 8:
+        case 16:
+            this->spec.format = AUDIO_S16LSB;
+            break;
+        default:
+            return SDL_SetError("Unsupported audio format");
+    }
+
+    /* The sample count must be a multiple of 64. */
+    this->spec.samples = SCE_AUDIO_SAMPLE_ALIGN(this->spec.samples);
+
+    /* Update the fragment size as size in bytes. */
+    SDL_CalculateAudioSpec(&this->spec);
+
+    /* Allocate the mixing buffer.  Its size and starting address must
+       be a multiple of 64 bytes.  Our sample count is already a multiple of
+       64, so spec->size should be a multiple of 64 as well. */
+    mixlen = this->spec.size * NUM_BUFFERS;
+    this->hidden->rawbuf = (Uint8 *) memalign(64, mixlen);
+    if (this->hidden->rawbuf == NULL) {
+        return SDL_SetError("Couldn't allocate mixing buffer");
+    }
+
+    /* Setup the hardware channel. */
+    if (this->spec.channels == 1) {
+        format = SCE_AUDIO_OUT_MODE_MONO;
+    } else {
+        format = SCE_AUDIO_OUT_MODE_STEREO;
+    }
+
+    if(this->spec.freq < 48000) {
+        port = SCE_AUDIO_OUT_PORT_TYPE_BGM;
+    }
+
+    this->hidden->channel = sceAudioOutOpenPort(port, this->spec.samples, this->spec.freq, format);
+    if (this->hidden->channel < 0) {
+        free(this->hidden->rawbuf);
+        this->hidden->rawbuf = NULL;
+        return SDL_SetError("Couldn't reserve hardware channel");
+    }
+
+    sceAudioOutSetVolume(this->hidden->channel, SCE_AUDIO_VOLUME_FLAG_L_CH|SCE_AUDIO_VOLUME_FLAG_R_CH, vols);
+
+    SDL_memset(this->hidden->rawbuf, 0, mixlen);
+    for (i = 0; i < NUM_BUFFERS; i++) {
+        this->hidden->mixbufs[i] = &this->hidden->rawbuf[i * this->spec.size];
+    }
+
+    this->hidden->next_buffer = 0;
+    return 0;
+}
+
+static void VITAAUD_PlayDevice(_THIS)
+{
+    Uint8 *mixbuf = this->hidden->mixbufs[this->hidden->next_buffer];
+
+    sceAudioOutOutput(this->hidden->channel, mixbuf);
+
+    this->hidden->next_buffer = (this->hidden->next_buffer + 1) % NUM_BUFFERS;
+}
+
+/* This function waits until it is possible to write a full sound buffer */
+static void VITAAUD_WaitDevice(_THIS)
+{
+    /* Because we block when sending audio, there's no need for this function to do anything. */
+}
+static Uint8 *VITAAUD_GetDeviceBuf(_THIS)
+{
+    return this->hidden->mixbufs[this->hidden->next_buffer];
+}
+
+static void VITAAUD_CloseDevice(_THIS)
+{
+    if (this->hidden->channel >= 0) {
+        sceAudioOutReleasePort(this->hidden->channel);
+        this->hidden->channel = -1;
+    }
+
+    if (this->hidden->rawbuf != NULL) {
+        free(this->hidden->rawbuf);         /* this uses memalign(), not SDL_malloc(). */
+        this->hidden->rawbuf = NULL;
+    }
+}
+
+static void VITAAUD_ThreadInit(_THIS)
+{
+    /* Increase the priority of this audio thread by 1 to put it
+       ahead of other SDL threads. */
+    SceUID thid;
+    SceKernelThreadInfo info;
+    thid = sceKernelGetThreadId();
+    info.size = sizeof(SceKernelThreadInfo);
+    if (sceKernelGetThreadInfo(thid, &info) == 0) {
+        sceKernelChangeThreadPriority(thid, info.currentPriority - 1);
+    }
+}
+
+static SDL_bool
+VITAAUD_Init(SDL_AudioDriverImpl * impl)
+{
+    /* Set the function pointers */
+    impl->OpenDevice = VITAAUD_OpenDevice;
+    impl->PlayDevice = VITAAUD_PlayDevice;
+    impl->WaitDevice = VITAAUD_WaitDevice;
+    impl->GetDeviceBuf = VITAAUD_GetDeviceBuf;
+    impl->CloseDevice = VITAAUD_CloseDevice;
+    impl->ThreadInit = VITAAUD_ThreadInit;
+
+    /* VITA audio device */
+    impl->OnlyHasDefaultOutputDevice = SDL_TRUE;
+    /*
+    impl->HasCaptureSupport = SDL_TRUE;
+    impl->OnlyHasDefaultInputDevice = SDL_TRUE;
+    */
+    return SDL_TRUE;   /* this audio target is available. */
+}
+
+AudioBootStrap VITAAUD_bootstrap = {
+    "vita", "VITA audio driver", VITAAUD_Init, SDL_FALSE
+};
+
+#endif /* SDL_AUDIO_DRIVER_VITA */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/audio/vita/SDL_vitaaudio.h b/Engine/lib/sdl/src/audio/vita/SDL_vitaaudio.h
new file mode 100644
index 000000000..73870759b
--- /dev/null
+++ b/Engine/lib/sdl/src/audio/vita/SDL_vitaaudio.h
@@ -0,0 +1,45 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef _SDL_vitaaudio_h
+#define _SDL_vitaaudio_h
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS   SDL_AudioDevice *this
+
+#define NUM_BUFFERS 2
+
+struct SDL_PrivateAudioData {
+    /* The hardware output channel. */
+    int     channel;
+    /* The raw allocated mixing buffer. */
+    Uint8   *rawbuf;
+    /* Individual mixing buffers. */
+    Uint8   *mixbufs[NUM_BUFFERS];
+    /* Index of the next available mixing buffer. */
+    int     next_buffer;
+};
+
+#endif /* _SDL_vitaaudio_h */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/audio/wasapi/SDL_wasapi.c b/Engine/lib/sdl/src/audio/wasapi/SDL_wasapi.c
index abefcca21..e7d640c12 100644
--- a/Engine/lib/sdl/src/audio/wasapi/SDL_wasapi.c
+++ b/Engine/lib/sdl/src/audio/wasapi/SDL_wasapi.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -34,10 +34,16 @@
 
 #include "SDL_wasapi.h"
 
-/* This constant isn't available on MinGW-w64 */
+/* These constants aren't available in older SDKs */
 #ifndef AUDCLNT_STREAMFLAGS_RATEADJUST
 #define AUDCLNT_STREAMFLAGS_RATEADJUST  0x00100000
 #endif
+#ifndef AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY
+#define AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY 0x08000000
+#endif
+#ifndef AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM
+#define AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM 0x80000000
+#endif
 
 /* these increment as default devices change. Opened default devices pick up changes in their threads. */
 SDL_atomic_t WASAPI_DefaultPlaybackGeneration;
@@ -58,42 +64,6 @@ static const IID SDL_IID_IAudioCaptureClient = { 0xc8adbd64, 0xe71e, 0x48a0,{ 0x
 static const GUID SDL_KSDATAFORMAT_SUBTYPE_PCM = { 0x00000001, 0x0000, 0x0010,{ 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 } };
 static const GUID SDL_KSDATAFORMAT_SUBTYPE_IEEE_FLOAT = { 0x00000003, 0x0000, 0x0010,{ 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 } };
 
-static SDL_bool
-WStrEqual(const WCHAR *a, const WCHAR *b)
-{
-    while (*a) {
-        if (*a != *b) {
-            return SDL_FALSE;
-        }
-        a++;
-        b++;
-    }
-    return *b == 0;
-}
-
-static size_t
-WStrLen(const WCHAR *wstr)
-{
-    size_t retval = 0;
-    if (wstr) {
-        while (*(wstr++)) {
-            retval++;
-        }
-    }
-    return retval;
-}
-
-static WCHAR *
-WStrDupe(const WCHAR *wstr)
-{
-    const size_t len = (WStrLen(wstr) + 1) * sizeof (WCHAR);
-    WCHAR *retval = (WCHAR *) SDL_malloc(len);
-    if (retval) {
-        SDL_memcpy(retval, wstr, len);
-    }
-    return retval;
-}
-
 
 void
 WASAPI_RemoveDevice(const SDL_bool iscapture, LPCWSTR devid)
@@ -103,7 +73,7 @@ WASAPI_RemoveDevice(const SDL_bool iscapture, LPCWSTR devid)
     DevIdList *prev = NULL;
     for (i = deviceid_list; i; i = next) {
         next = i->next;
-        if (WStrEqual(i->str, devid)) {
+        if (SDL_wcscmp(i->str, devid) == 0) {
             if (prev) {
                 prev->next = next;
             } else {
@@ -117,10 +87,33 @@ WASAPI_RemoveDevice(const SDL_bool iscapture, LPCWSTR devid)
     }
 }
 
+static SDL_AudioFormat
+WaveFormatToSDLFormat(WAVEFORMATEX *waveformat)
+{
+    if ((waveformat->wFormatTag == WAVE_FORMAT_IEEE_FLOAT) && (waveformat->wBitsPerSample == 32)) {
+        return AUDIO_F32SYS;
+    } else if ((waveformat->wFormatTag == WAVE_FORMAT_PCM) && (waveformat->wBitsPerSample == 16)) {
+        return AUDIO_S16SYS;
+    } else if ((waveformat->wFormatTag == WAVE_FORMAT_PCM) && (waveformat->wBitsPerSample == 32)) {
+        return AUDIO_S32SYS;
+    } else if (waveformat->wFormatTag == WAVE_FORMAT_EXTENSIBLE) {
+        const WAVEFORMATEXTENSIBLE *ext = (const WAVEFORMATEXTENSIBLE *) waveformat;
+        if ((SDL_memcmp(&ext->SubFormat, &SDL_KSDATAFORMAT_SUBTYPE_IEEE_FLOAT, sizeof (GUID)) == 0) && (waveformat->wBitsPerSample == 32)) {
+            return AUDIO_F32SYS;
+        } else if ((SDL_memcmp(&ext->SubFormat, &SDL_KSDATAFORMAT_SUBTYPE_PCM, sizeof (GUID)) == 0) && (waveformat->wBitsPerSample == 16)) {
+            return AUDIO_S16SYS;
+        } else if ((SDL_memcmp(&ext->SubFormat, &SDL_KSDATAFORMAT_SUBTYPE_PCM, sizeof (GUID)) == 0) && (waveformat->wBitsPerSample == 32)) {
+            return AUDIO_S32SYS;
+        }
+    }
+    return 0;
+}
+
 void
-WASAPI_AddDevice(const SDL_bool iscapture, const char *devname, LPCWSTR devid)
+WASAPI_AddDevice(const SDL_bool iscapture, const char *devname, WAVEFORMATEXTENSIBLE *fmt, LPCWSTR devid)
 {
     DevIdList *devidlist;
+    SDL_AudioSpec spec;
 
     /* You can have multiple endpoints on a device that are mutually exclusive ("Speakers" vs "Line Out" or whatever).
        In a perfect world, things that are unplugged won't be in this collection. The only gotcha is probably for
@@ -129,7 +122,7 @@ WASAPI_AddDevice(const SDL_bool iscapture, const char *devname, LPCWSTR devid)
 
     /* see if we already have this one. */
     for (devidlist = deviceid_list; devidlist; devidlist = devidlist->next) {
-        if (WStrEqual(devidlist->str, devid)) {
+        if (SDL_wcscmp(devidlist->str, devid) == 0) {
             return;  /* we already have this. */
         }
     }
@@ -139,7 +132,7 @@ WASAPI_AddDevice(const SDL_bool iscapture, const char *devname, LPCWSTR devid)
         return;  /* oh well. */
     }
 
-    devid = WStrDupe(devid);
+    devid = SDL_wcsdup(devid);
     if (!devid) {
         SDL_free(devidlist);
         return;  /* oh well. */
@@ -149,7 +142,11 @@ WASAPI_AddDevice(const SDL_bool iscapture, const char *devname, LPCWSTR devid)
     devidlist->next = deviceid_list;
     deviceid_list = devidlist;
 
-    SDL_AddAudioDevice(iscapture, devname, (void *) devid);
+    SDL_zero(spec);
+    spec.channels = (Uint8)fmt->Format.nChannels;
+    spec.freq = fmt->Format.nSamplesPerSec;
+    spec.format = WaveFormatToSDLFormat((WAVEFORMATEX *) fmt);
+    SDL_AddAudioDevice(iscapture, devname, &spec, (void *) devid);
 }
 
 static void
@@ -212,7 +209,7 @@ UpdateAudioStream(_THIS, const SDL_AudioSpec *oldspec)
         }
 
         if (!this->stream) {
-            return -1;
+            return -1; /* SDL_NewAudioStream should have called SDL_SetError. */
         }
     }
 
@@ -315,8 +312,14 @@ WASAPI_WaitDevice(_THIS)
             UINT32 padding = 0;
             if (!WasapiFailed(this, IAudioClient_GetCurrentPadding(this->hidden->client, &padding))) {
                 /*SDL_Log("WASAPI EVENT! padding=%u maxpadding=%u", (unsigned int)padding, (unsigned int)maxpadding);*/
-                if (padding <= maxpadding) {
-                    break;
+                if (this->iscapture) {
+                    if (padding > 0) {
+                        break;
+                    }
+                } else {
+                    if (padding <= maxpadding) {
+                        break;
+                    }
                 }
             }
         } else if (waitResult != WAIT_TIMEOUT) {
@@ -422,7 +425,6 @@ ReleaseWasapiDevice(_THIS)
 {
     if (this->hidden->client) {
         IAudioClient_Stop(this->hidden->client);
-        IAudioClient_SetEventHandle(this->hidden->client, NULL);
         IAudioClient_Release(this->hidden->client);
         this->hidden->client = NULL;
     }
@@ -510,9 +512,8 @@ WASAPI_PrepDevice(_THIS, const SDL_bool updatestream)
     IAudioRenderClient *render = NULL;
     IAudioCaptureClient *capture = NULL;
     WAVEFORMATEX *waveformat = NULL;
-    SDL_AudioFormat test_format = SDL_FirstAudioFormat(this->spec.format);
+    SDL_AudioFormat test_format;
     SDL_AudioFormat wasapi_format = 0;
-    SDL_bool valid_format = SDL_FALSE;
     HRESULT ret = S_OK;
     DWORD streamflags = 0;
 
@@ -539,34 +540,17 @@ WASAPI_PrepDevice(_THIS, const SDL_bool updatestream)
     this->spec.channels = (Uint8) waveformat->nChannels;
 
     /* Make sure we have a valid format that we can convert to whatever WASAPI wants. */
-    if ((waveformat->wFormatTag == WAVE_FORMAT_IEEE_FLOAT) && (waveformat->wBitsPerSample == 32)) {
-        wasapi_format = AUDIO_F32SYS;
-    } else if ((waveformat->wFormatTag == WAVE_FORMAT_PCM) && (waveformat->wBitsPerSample == 16)) {
-        wasapi_format = AUDIO_S16SYS;
-    } else if ((waveformat->wFormatTag == WAVE_FORMAT_PCM) && (waveformat->wBitsPerSample == 32)) {
-        wasapi_format = AUDIO_S32SYS;
-    } else if (waveformat->wFormatTag == WAVE_FORMAT_EXTENSIBLE) {
-        const WAVEFORMATEXTENSIBLE *ext = (const WAVEFORMATEXTENSIBLE *) waveformat;
-        if ((SDL_memcmp(&ext->SubFormat, &SDL_KSDATAFORMAT_SUBTYPE_IEEE_FLOAT, sizeof (GUID)) == 0) && (waveformat->wBitsPerSample == 32)) {
-            wasapi_format = AUDIO_F32SYS;
-        } else if ((SDL_memcmp(&ext->SubFormat, &SDL_KSDATAFORMAT_SUBTYPE_PCM, sizeof (GUID)) == 0) && (waveformat->wBitsPerSample == 16)) {
-            wasapi_format = AUDIO_S16SYS;
-        } else if ((SDL_memcmp(&ext->SubFormat, &SDL_KSDATAFORMAT_SUBTYPE_PCM, sizeof (GUID)) == 0) && (waveformat->wBitsPerSample == 32)) {
-            wasapi_format = AUDIO_S32SYS;
-        }
-    }
+    wasapi_format = WaveFormatToSDLFormat(waveformat);
 
-    while ((!valid_format) && (test_format)) {
+    for (test_format = SDL_FirstAudioFormat(this->spec.format); test_format; test_format = SDL_NextAudioFormat()) {
         if (test_format == wasapi_format) {
             this->spec.format = test_format;
-            valid_format = SDL_TRUE;
             break;
         }
-        test_format = SDL_NextAudioFormat();
     }
 
-    if (!valid_format) {
-        return SDL_SetError("WASAPI: Unsupported audio format");
+    if (!test_format) {
+        return SDL_SetError("%s: Unsupported audio format", "wasapi");
     }
 
     ret = IAudioClient_GetDevicePeriod(client, &default_period, NULL);
@@ -574,17 +558,11 @@ WASAPI_PrepDevice(_THIS, const SDL_bool updatestream)
         return WIN_SetErrorFromHRESULT("WASAPI can't determine minimum device period", ret);
     }
 
-    /* favor WASAPI's resampler over our own, in Win7+. */
+    /* favor WASAPI's resampler over our own */
     if (this->spec.freq != waveformat->nSamplesPerSec) {
-        /* RATEADJUST only works with output devices in share mode, and is available in Win7 and later.*/
-        if (WIN_IsWindows7OrGreater() && !this->iscapture && (sharemode == AUDCLNT_SHAREMODE_SHARED)) {
-            streamflags |= AUDCLNT_STREAMFLAGS_RATEADJUST;
-            waveformat->nSamplesPerSec = this->spec.freq;
-            waveformat->nAvgBytesPerSec = waveformat->nSamplesPerSec * waveformat->nChannels * (waveformat->wBitsPerSample / 8);
-        }
-        else {
-            this->spec.freq = waveformat->nSamplesPerSec;  /* force sampling rate so our resampler kicks in. */
-        }
+        streamflags |= (AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM | AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY);
+        waveformat->nSamplesPerSec = this->spec.freq;
+        waveformat->nAvgBytesPerSec = waveformat->nSamplesPerSec * waveformat->nChannels * (waveformat->wBitsPerSample / 8);
     }
 
     streamflags |= AUDCLNT_STREAMFLAGS_EVENTCALLBACK;
@@ -650,9 +628,7 @@ WASAPI_PrepDevice(_THIS, const SDL_bool updatestream)
     }
 
     if (updatestream) {
-        if (UpdateAudioStream(this, &oldspec) == -1) {
-            return -1;
-        }
+        return UpdateAudioStream(this, &oldspec);
     }
 
     return 0;  /* good to go. */
@@ -660,9 +636,9 @@ WASAPI_PrepDevice(_THIS, const SDL_bool updatestream)
 
 
 static int
-WASAPI_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
+WASAPI_OpenDevice(_THIS, const char *devname)
 {
-    LPCWSTR devid = (LPCWSTR) handle;
+    LPCWSTR devid = (LPCWSTR) this->handle;
 
     /* Initialize all variables that we clean on shutdown */
     this->hidden = (struct SDL_PrivateAudioData *)
@@ -675,9 +651,9 @@ WASAPI_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
     WASAPI_RefDevice(this);   /* so CloseDevice() will unref to zero. */
 
     if (!devid) {  /* is default device? */
-        this->hidden->default_device_generation = SDL_AtomicGet(iscapture ? &WASAPI_DefaultCaptureGeneration : &WASAPI_DefaultPlaybackGeneration);
+        this->hidden->default_device_generation = SDL_AtomicGet(this->iscapture ? &WASAPI_DefaultCaptureGeneration : &WASAPI_DefaultPlaybackGeneration);
     } else {
-        this->hidden->devid = WStrDupe(devid);
+        this->hidden->devid = SDL_wcsdup(devid);
         if (!this->hidden->devid) {
             return SDL_OutOfMemory();
         }
@@ -710,12 +686,6 @@ WASAPI_ThreadDeinit(_THIS)
     WASAPI_PlatformThreadDeinit(this);
 }
 
-void
-WASAPI_BeginLoopIteration(_THIS)
-{
-	/* no-op. */
-}
-
 static void
 WASAPI_Deinitialize(void)
 {
@@ -732,21 +702,20 @@ WASAPI_Deinitialize(void)
     deviceid_list = NULL;
 }
 
-static int
+static SDL_bool
 WASAPI_Init(SDL_AudioDriverImpl * impl)
 {
     SDL_AtomicSet(&WASAPI_DefaultPlaybackGeneration, 1);
     SDL_AtomicSet(&WASAPI_DefaultCaptureGeneration, 1);
 
     if (WASAPI_PlatformInit() == -1) {
-        return 0;
+        return SDL_FALSE;
     }
 
     /* Set the function pointers */
     impl->DetectDevices = WASAPI_DetectDevices;
     impl->ThreadInit = WASAPI_ThreadInit;
     impl->ThreadDeinit = WASAPI_ThreadDeinit;
-    impl->BeginLoopIteration = WASAPI_BeginLoopIteration;
     impl->OpenDevice = WASAPI_OpenDevice;
     impl->PlayDevice = WASAPI_PlayDevice;
     impl->WaitDevice = WASAPI_WaitDevice;
@@ -755,13 +724,13 @@ WASAPI_Init(SDL_AudioDriverImpl * impl)
     impl->FlushCapture = WASAPI_FlushCapture;
     impl->CloseDevice = WASAPI_CloseDevice;
     impl->Deinitialize = WASAPI_Deinitialize;
-    impl->HasCaptureSupport = 1;
+    impl->HasCaptureSupport = SDL_TRUE;
 
-    return 1;   /* this audio target is available. */
+    return SDL_TRUE;   /* this audio target is available. */
 }
 
 AudioBootStrap WASAPI_bootstrap = {
-    "wasapi", "WASAPI", WASAPI_Init, 0
+    "wasapi", "WASAPI", WASAPI_Init, SDL_FALSE
 };
 
 #endif  /* SDL_AUDIO_DRIVER_WASAPI */
diff --git a/Engine/lib/sdl/src/audio/wasapi/SDL_wasapi.h b/Engine/lib/sdl/src/audio/wasapi/SDL_wasapi.h
index 59a0884e8..af79637b7 100644
--- a/Engine/lib/sdl/src/audio/wasapi/SDL_wasapi.h
+++ b/Engine/lib/sdl/src/audio/wasapi/SDL_wasapi.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -63,7 +63,7 @@ extern SDL_atomic_t WASAPI_DefaultCaptureGeneration;
 int WASAPI_PrepDevice(_THIS, const SDL_bool updatestream);
 void WASAPI_RefDevice(_THIS);
 void WASAPI_UnrefDevice(_THIS);
-void WASAPI_AddDevice(const SDL_bool iscapture, const char *devname, LPCWSTR devid);
+void WASAPI_AddDevice(const SDL_bool iscapture, const char *devname, WAVEFORMATEXTENSIBLE *fmt, LPCWSTR devid);
 void WASAPI_RemoveDevice(const SDL_bool iscapture, LPCWSTR devid);
 
 /* These are functions that are implemented differently for Windows vs WinRT. */
@@ -74,7 +74,6 @@ int WASAPI_ActivateDevice(_THIS, const SDL_bool isrecovery);
 void WASAPI_PlatformThreadInit(_THIS);
 void WASAPI_PlatformThreadDeinit(_THIS);
 void WASAPI_PlatformDeleteActivationHandler(void *handler);
-void WASAPI_BeginLoopIteration(_THIS);
 
 #ifdef __cplusplus
 }
diff --git a/Engine/lib/sdl/src/audio/wasapi/SDL_wasapi_win32.c b/Engine/lib/sdl/src/audio/wasapi/SDL_wasapi_win32.c
index ac3f6161a..8e5c7e2a1 100644
--- a/Engine/lib/sdl/src/audio/wasapi/SDL_wasapi_win32.c
+++ b/Engine/lib/sdl/src/audio/wasapi/SDL_wasapi_win32.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -53,7 +53,7 @@ static IMMDeviceEnumerator *enumerator = NULL;
 
 /* handle to Avrt.dll--Vista and later!--for flagging the callback thread as "Pro Audio" (low latency). */
 static HMODULE libavrt = NULL;
-typedef HANDLE(WINAPI *pfnAvSetMmThreadCharacteristicsW)(LPWSTR, LPDWORD);
+typedef HANDLE(WINAPI *pfnAvSetMmThreadCharacteristicsW)(LPCWSTR, LPDWORD);
 typedef BOOL(WINAPI *pfnAvRevertMmThreadCharacteristics)(HANDLE);
 static pfnAvSetMmThreadCharacteristicsW pAvSetMmThreadCharacteristicsW = NULL;
 static pfnAvRevertMmThreadCharacteristics pAvRevertMmThreadCharacteristics = NULL;
@@ -65,26 +65,31 @@ static const IID SDL_IID_IMMNotificationClient = { 0x7991eec9, 0x7e89, 0x4d85,{
 static const IID SDL_IID_IMMEndpoint = { 0x1be09788, 0x6894, 0x4089,{ 0x85, 0x86, 0x9a, 0x2a, 0x6c, 0x26, 0x5a, 0xc5 } };
 static const IID SDL_IID_IAudioClient = { 0x1cb9ad4c, 0xdbfa, 0x4c32,{ 0xb1, 0x78, 0xc2, 0xf5, 0x68, 0xa7, 0x03, 0xb2 } };
 static const PROPERTYKEY SDL_PKEY_Device_FriendlyName = { { 0xa45c254e, 0xdf1c, 0x4efd,{ 0x80, 0x20, 0x67, 0xd1, 0x46, 0xa8, 0x50, 0xe0, } }, 14 };
+static const PROPERTYKEY SDL_PKEY_AudioEngine_DeviceFormat = { { 0xf19f064d, 0x82c, 0x4e27,{ 0xbc, 0x73, 0x68, 0x82, 0xa1, 0xbb, 0x8e, 0x4c, } }, 0 };
 
 
-static char *
-GetWasapiDeviceName(IMMDevice *device)
+static void
+GetWasapiDeviceInfo(IMMDevice *device, char **utf8dev, WAVEFORMATEXTENSIBLE *fmt)
 {
     /* PKEY_Device_FriendlyName gives you "Speakers (SoundBlaster Pro)" which drives me nuts. I'd rather it be
        "SoundBlaster Pro (Speakers)" but I guess that's developers vs users. Windows uses the FriendlyName in
        its own UIs, like Volume Control, etc. */
-    char *utf8dev = NULL;
     IPropertyStore *props = NULL;
+    *utf8dev = NULL;
+    SDL_zerop(fmt);
     if (SUCCEEDED(IMMDevice_OpenPropertyStore(device, STGM_READ, &props))) {
         PROPVARIANT var;
         PropVariantInit(&var);
         if (SUCCEEDED(IPropertyStore_GetValue(props, &SDL_PKEY_Device_FriendlyName, &var))) {
-            utf8dev = WIN_StringToUTF8(var.pwszVal);
+            *utf8dev = WIN_StringToUTF8W(var.pwszVal);
+        }
+        PropVariantClear(&var);
+        if (SUCCEEDED(IPropertyStore_GetValue(props, &SDL_PKEY_AudioEngine_DeviceFormat, &var))) {
+            SDL_memcpy(fmt, var.blob.pBlobData, SDL_min(var.blob.cbSize, sizeof(WAVEFORMATEXTENSIBLE)));
         }
         PropVariantClear(&var);
         IPropertyStore_Release(props);
     }
-    return utf8dev;
 }
 
 
@@ -194,9 +199,11 @@ SDLMMNotificationClient_OnDeviceStateChanged(IMMNotificationClient *ithis, LPCWS
             if (SUCCEEDED(IMMEndpoint_GetDataFlow(endpoint, &flow))) {
                 const SDL_bool iscapture = (flow == eCapture);
                 if (dwNewState == DEVICE_STATE_ACTIVE) {
-                    char *utf8dev = GetWasapiDeviceName(device);
+                    char *utf8dev;
+                    WAVEFORMATEXTENSIBLE fmt;
+                    GetWasapiDeviceInfo(device, &utf8dev, &fmt);
                     if (utf8dev) {
-                        WASAPI_AddDevice(iscapture, utf8dev, pwstrDeviceId);
+                        WASAPI_AddDevice(iscapture, utf8dev, &fmt, pwstrDeviceId);
                         SDL_free(utf8dev);
                     }
                 } else {
@@ -251,7 +258,7 @@ WASAPI_PlatformInit(void)
         return WIN_SetErrorFromHRESULT("WASAPI CoCreateInstance(MMDeviceEnumerator)", ret);
     }
 
-    libavrt = LoadLibraryW(L"avrt.dll");  /* this library is available in Vista and later. No WinXP, so have to LoadLibrary to use it for now! */
+    libavrt = LoadLibrary(TEXT("avrt.dll"));  /* this library is available in Vista and later. No WinXP, so have to LoadLibrary to use it for now! */
     if (libavrt) {
         pAvSetMmThreadCharacteristicsW = (pfnAvSetMmThreadCharacteristicsW) GetProcAddress(libavrt, "AvSetMmThreadCharacteristicsW");
         pAvRevertMmThreadCharacteristics = (pfnAvRevertMmThreadCharacteristics) GetProcAddress(libavrt, "AvRevertMmThreadCharacteristics");
@@ -291,7 +298,7 @@ WASAPI_PlatformThreadInit(_THIS)
     /* Set this thread to very high "Pro Audio" priority. */
     if (pAvSetMmThreadCharacteristicsW) {
         DWORD idx = 0;
-        this->hidden->task = pAvSetMmThreadCharacteristicsW(TEXT("Pro Audio"), &idx);
+        this->hidden->task = pAvSetMmThreadCharacteristicsW(L"Pro Audio", &idx);
     }
 }
 
@@ -352,6 +359,7 @@ typedef struct
 {
     LPWSTR devid;
     char *devname;
+    WAVEFORMATEXTENSIBLE fmt;
 } EndpointItem;
 
 static int sort_endpoints(const void *_a, const void *_b)
@@ -408,7 +416,7 @@ WASAPI_EnumerateEndpointsForFlow(const SDL_bool iscapture)
         IMMDevice *device = NULL;
         if (SUCCEEDED(IMMDeviceCollection_Item(collection, i, &device))) {
             if (SUCCEEDED(IMMDevice_GetId(device, &item->devid))) {
-                item->devname = GetWasapiDeviceName(device);
+                GetWasapiDeviceInfo(device, &item->devname, &item->fmt);
             }
             IMMDevice_Release(device);
         }
@@ -421,7 +429,7 @@ WASAPI_EnumerateEndpointsForFlow(const SDL_bool iscapture)
     for (i = 0; i < total; i++) {
         EndpointItem *item = items + i;
         if ((item->devid) && (item->devname)) {
-            WASAPI_AddDevice(iscapture, item->devname, item->devid);
+            WASAPI_AddDevice(iscapture, item->devname, &item->fmt, item->devid);
         }
         SDL_free(item->devname);
         CoTaskMemFree(item->devid);
diff --git a/Engine/lib/sdl/src/audio/wasapi/SDL_wasapi_winrt.cpp b/Engine/lib/sdl/src/audio/wasapi/SDL_wasapi_winrt.cpp
index 8408abc2d..e063e6a41 100644
--- a/Engine/lib/sdl/src/audio/wasapi/SDL_wasapi_winrt.cpp
+++ b/Engine/lib/sdl/src/audio/wasapi/SDL_wasapi_winrt.cpp
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -32,6 +32,7 @@
 #include <windows.devices.enumeration.h>
 #include <windows.media.devices.h>
 #include <wrl/implements.h>
+#include <collection.h>
 
 extern "C" {
 #include "../../core/windows/SDL_windows.h"
@@ -52,6 +53,8 @@ using namespace Windows::Media::Devices;
 using namespace Windows::Foundation;
 using namespace Microsoft::WRL;
 
+static Platform::String^ SDL_PKEY_AudioEngine_DeviceFormat = L"{f19f064d-082c-4e27-bc73-6882a1bb8e4c} 0";
+
 class SDL_WasapiDeviceEventHandler
 {
 public:
@@ -78,9 +81,16 @@ private:
 SDL_WasapiDeviceEventHandler::SDL_WasapiDeviceEventHandler(const SDL_bool _iscapture)
     : iscapture(_iscapture)
     , completed(SDL_CreateSemaphore(0))
-    , watcher(DeviceInformation::CreateWatcher(_iscapture ? DeviceClass::AudioCapture : DeviceClass::AudioRender))
 {
-    if (!watcher || !completed)
+    if (!completed)
+        return;  // uhoh.
+
+    Platform::String^ selector = _iscapture ? MediaDevice::GetAudioCaptureSelector() :
+                                              MediaDevice::GetAudioRenderSelector();
+    Platform::Collections::Vector<Platform::String^> properties;
+    properties.Append(SDL_PKEY_AudioEngine_DeviceFormat);
+    watcher = DeviceInformation::CreateWatcher(selector, properties.GetView());
+    if (!watcher)
         return;  // uhoh.
 
     // !!! FIXME: this doesn't need a lambda here, I think, if I make SDL_WasapiDeviceEventHandler a proper C++/CX class. --ryan.
@@ -124,7 +134,18 @@ SDL_WasapiDeviceEventHandler::OnDeviceAdded(DeviceWatcher^ sender, DeviceInforma
     SDL_assert(sender == this->watcher);
     char *utf8dev = WIN_StringToUTF8(info->Name->Data());
     if (utf8dev) {
-        WASAPI_AddDevice(this->iscapture, utf8dev, info->Id->Data());
+        WAVEFORMATEXTENSIBLE fmt;
+        Platform::Object^ obj = info->Properties->Lookup(SDL_PKEY_AudioEngine_DeviceFormat);
+        if (obj) {
+            IPropertyValue^ property = (IPropertyValue^) obj;
+            Platform::Array<unsigned char>^ data;
+            property->GetUInt8Array(&data);
+            SDL_memcpy(&fmt, data->Data, SDL_min(data->Length, sizeof(WAVEFORMATEXTENSIBLE)));
+        } else {
+            SDL_zero(fmt);
+        }
+
+        WASAPI_AddDevice(this->iscapture, utf8dev, &fmt, info->Id->Data());
         SDL_free(utf8dev);
     }
 }
diff --git a/Engine/lib/sdl/src/audio/winmm/SDL_winmm.c b/Engine/lib/sdl/src/audio/winmm/SDL_winmm.c
index f266b1b3c..444d21576 100644
--- a/Engine/lib/sdl/src/audio/winmm/SDL_winmm.c
+++ b/Engine/lib/sdl/src/audio/winmm/SDL_winmm.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -75,12 +75,19 @@ static void DetectWave##typ##Devs(void) { \
     const UINT iscapture = iscap ? 1 : 0; \
     const UINT devcount = wave##typ##GetNumDevs(); \
     capstyp##2W caps; \
+    SDL_AudioSpec spec; \
     UINT i; \
+    SDL_zero(spec); \
     for (i = 0; i < devcount; i++) { \
         if (wave##typ##GetDevCaps(i,(LP##capstyp##W)&caps,sizeof(caps))==MMSYSERR_NOERROR) { \
             char *name = WIN_LookupAudioDeviceName(caps.szPname,&caps.NameGuid); \
             if (name != NULL) { \
-                SDL_AddAudioDevice((int) iscapture, name, (void *) ((size_t) i+1)); \
+                /* Note that freq/format are not filled in, as this information \
+                 * is not provided by the caps struct! At best, we get possible \
+                 * sample formats, but not an _active_ format. \
+                 */ \
+                spec.channels = (Uint8)caps.wChannels; \
+                SDL_AddAudioDevice((int) iscapture, name, &spec, (void *) ((size_t) i+1)); \
                 SDL_free(name); \
             } \
         } \
@@ -128,7 +135,7 @@ FillSound(HWAVEOUT hwo, UINT uMsg, DWORD_PTR dwInstance,
 }
 
 static int
-SetMMerror(char *function, MMRESULT code)
+SetMMerror(const char *function, MMRESULT code)
 {
     int len;
     char errbuf[MAXERRORLENGTH];
@@ -276,10 +283,11 @@ PrepWaveFormat(_THIS, UINT devId, WAVEFORMATEX *pfmt, const int iscapture)
 }
 
 static int
-WINMM_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
+WINMM_OpenDevice(_THIS, const char *devname)
 {
-    SDL_AudioFormat test_format = SDL_FirstAudioFormat(this->spec.format);
-    int valid_datatype = 0;
+    SDL_AudioFormat test_format;
+    SDL_bool iscapture = this->iscapture;
+    void *handle = this->handle;
     MMRESULT result;
     WAVEFORMATEX waveformat;
     UINT devId = WAVE_MAPPER;  /* WAVE_MAPPER == choose system's default */
@@ -306,7 +314,7 @@ WINMM_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
     if (this->spec.channels > 2)
         this->spec.channels = 2;        /* !!! FIXME: is this right? */
 
-    while ((!valid_datatype) && (test_format)) {
+    for (test_format = SDL_FirstAudioFormat(this->spec.format); test_format; test_format = SDL_NextAudioFormat()) {
         switch (test_format) {
         case AUDIO_U8:
         case AUDIO_S16:
@@ -314,20 +322,17 @@ WINMM_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
         case AUDIO_F32:
             this->spec.format = test_format;
             if (PrepWaveFormat(this, devId, &waveformat, iscapture)) {
-                valid_datatype = 1;
-            } else {
-                test_format = SDL_NextAudioFormat();
+                break;
             }
-            break;
-
+            continue;
         default:
-            test_format = SDL_NextAudioFormat();
-            break;
+            continue;
         }
+        break;
     }
 
-    if (!valid_datatype) {
-        return SDL_SetError("Unsupported audio format");
+    if (!test_format) {
+        return SDL_SetError("%s: Unsupported audio format", "winmm");
     }
 
     /* Update the fragment size as size in bytes */
@@ -427,8 +432,7 @@ WINMM_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
     return 0;                   /* Ready to go! */
 }
 
-
-static int
+static SDL_bool
 WINMM_Init(SDL_AudioDriverImpl * impl)
 {
     /* Set the function pointers */
@@ -443,11 +447,11 @@ WINMM_Init(SDL_AudioDriverImpl * impl)
 
     impl->HasCaptureSupport = SDL_TRUE;
 
-    return 1;   /* this audio target is available. */
+    return SDL_TRUE;   /* this audio target is available. */
 }
 
 AudioBootStrap WINMM_bootstrap = {
-    "winmm", "Windows Waveform Audio", WINMM_Init, 0
+    "winmm", "Windows Waveform Audio", WINMM_Init, SDL_FALSE
 };
 
 #endif /* SDL_AUDIO_DRIVER_WINMM */
diff --git a/Engine/lib/sdl/src/audio/winmm/SDL_winmm.h b/Engine/lib/sdl/src/audio/winmm/SDL_winmm.h
index c07bf091a..68baffa9c 100644
--- a/Engine/lib/sdl/src/audio/winmm/SDL_winmm.h
+++ b/Engine/lib/sdl/src/audio/winmm/SDL_winmm.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/core/android/SDL_android.c b/Engine/lib/sdl/src/core/android/SDL_android.c
index 13216a82f..dba9e5f87 100644
--- a/Engine/lib/sdl/src/core/android/SDL_android.c
+++ b/Engine/lib/sdl/src/core/android/SDL_android.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -79,7 +79,7 @@ JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeDropFile)(
 JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeSetScreenResolution)(
         JNIEnv *env, jclass jcls,
         jint surfaceWidth, jint surfaceHeight,
-        jint deviceWidth, jint deviceHeight, jint format, jfloat rate);
+        jint deviceWidth, jint deviceHeight, jfloat rate);
 
 JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeResize)(
         JNIEnv *env, jclass cls);
@@ -148,6 +148,10 @@ JNIEXPORT jstring JNICALL SDL_JAVA_INTERFACE(nativeGetHint)(
         JNIEnv *env, jclass cls,
         jstring name);
 
+JNIEXPORT jboolean JNICALL SDL_JAVA_INTERFACE(nativeGetHintBoolean)(
+        JNIEnv *env, jclass cls,
+        jstring name, jboolean default_value);
+
 JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeSetenv)(
         JNIEnv *env, jclass cls,
         jstring name, jstring value);
@@ -168,7 +172,7 @@ static JNINativeMethod SDLActivity_tab[] = {
     { "nativeSetupJNI",             "()I", SDL_JAVA_INTERFACE(nativeSetupJNI) },
     { "nativeRunMain",              "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/Object;)I", SDL_JAVA_INTERFACE(nativeRunMain) },
     { "onNativeDropFile",           "(Ljava/lang/String;)V", SDL_JAVA_INTERFACE(onNativeDropFile) },
-    { "nativeSetScreenResolution",  "(IIIIIF)V", SDL_JAVA_INTERFACE(nativeSetScreenResolution) },
+    { "nativeSetScreenResolution",  "(IIIIF)V", SDL_JAVA_INTERFACE(nativeSetScreenResolution) },
     { "onNativeResize",             "()V", SDL_JAVA_INTERFACE(onNativeResize) },
     { "onNativeSurfaceCreated",     "()V", SDL_JAVA_INTERFACE(onNativeSurfaceCreated) },
     { "onNativeSurfaceChanged",     "()V", SDL_JAVA_INTERFACE(onNativeSurfaceChanged) },
@@ -189,6 +193,7 @@ static JNINativeMethod SDLActivity_tab[] = {
     { "nativeResume",               "()V", SDL_JAVA_INTERFACE(nativeResume) },
     { "nativeFocusChanged",         "(Z)V", SDL_JAVA_INTERFACE(nativeFocusChanged) },
     { "nativeGetHint",              "(Ljava/lang/String;)Ljava/lang/String;", SDL_JAVA_INTERFACE(nativeGetHint) },
+    { "nativeGetHintBoolean",       "(Ljava/lang/String;Z)Z", SDL_JAVA_INTERFACE(nativeGetHintBoolean) },
     { "nativeSetenv",               "(Ljava/lang/String;Ljava/lang/String;)V", SDL_JAVA_INTERFACE(nativeSetenv) },
     { "onNativeOrientationChanged", "(I)V", SDL_JAVA_INTERFACE(onNativeOrientationChanged) },
     { "nativeAddTouch",             "(ILjava/lang/String;)V", SDL_JAVA_INTERFACE(nativeAddTouch) },
@@ -298,6 +303,7 @@ static jmethodID midClipboardGetText;
 static jmethodID midClipboardHasText;
 static jmethodID midClipboardSetText;
 static jmethodID midCreateCustomCursor;
+static jmethodID midDestroyCustomCursor;
 static jmethodID midGetContext;
 static jmethodID midGetDisplayDPI;
 static jmethodID midGetManifestEnvironmentVariables;
@@ -312,12 +318,12 @@ static jmethodID midManualBackButton;
 static jmethodID midMinimizeWindow;
 static jmethodID midOpenURL;
 static jmethodID midRequestPermission;
+static jmethodID midShowToast;
 static jmethodID midSendMessage;
 static jmethodID midSetActivityTitle;
 static jmethodID midSetCustomCursor;
 static jmethodID midSetOrientation;
 static jmethodID midSetRelativeMouseEnabled;
-static jmethodID midSetSurfaceViewFormat;
 static jmethodID midSetSystemCursor;
 static jmethodID midSetWindowStyle;
 static jmethodID midShouldMinimizeOnFocusLoss;
@@ -577,6 +583,7 @@ JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeSetupJNI)(JNIEnv *env, jclass cl
     midClipboardHasText = (*env)->GetStaticMethodID(env, mActivityClass, "clipboardHasText", "()Z");
     midClipboardSetText = (*env)->GetStaticMethodID(env, mActivityClass, "clipboardSetText", "(Ljava/lang/String;)V");
     midCreateCustomCursor = (*env)->GetStaticMethodID(env, mActivityClass, "createCustomCursor", "([IIIII)I");
+    midDestroyCustomCursor = (*env)->GetStaticMethodID(env, mActivityClass, "destroyCustomCursor", "(I)V");
     midGetContext = (*env)->GetStaticMethodID(env, mActivityClass, "getContext","()Landroid/content/Context;");
     midGetDisplayDPI = (*env)->GetStaticMethodID(env, mActivityClass, "getDisplayDPI", "()Landroid/util/DisplayMetrics;");
     midGetManifestEnvironmentVariables = (*env)->GetStaticMethodID(env, mActivityClass, "getManifestEnvironmentVariables", "()Z");
@@ -591,12 +598,12 @@ JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeSetupJNI)(JNIEnv *env, jclass cl
     midMinimizeWindow = (*env)->GetStaticMethodID(env, mActivityClass, "minimizeWindow","()V");
     midOpenURL = (*env)->GetStaticMethodID(env, mActivityClass, "openURL", "(Ljava/lang/String;)I");
     midRequestPermission = (*env)->GetStaticMethodID(env, mActivityClass, "requestPermission", "(Ljava/lang/String;I)V");
+    midShowToast = (*env)->GetStaticMethodID(env, mActivityClass, "showToast", "(Ljava/lang/String;IIII)I");
     midSendMessage = (*env)->GetStaticMethodID(env, mActivityClass, "sendMessage", "(II)Z");
     midSetActivityTitle = (*env)->GetStaticMethodID(env, mActivityClass, "setActivityTitle","(Ljava/lang/String;)Z");
     midSetCustomCursor = (*env)->GetStaticMethodID(env, mActivityClass, "setCustomCursor", "(I)Z");
     midSetOrientation = (*env)->GetStaticMethodID(env, mActivityClass, "setOrientation","(IIZLjava/lang/String;)V");
     midSetRelativeMouseEnabled = (*env)->GetStaticMethodID(env, mActivityClass, "setRelativeMouseEnabled", "(Z)Z");
-    midSetSurfaceViewFormat = (*env)->GetStaticMethodID(env, mActivityClass, "setSurfaceViewFormat","(I)V");
     midSetSystemCursor = (*env)->GetStaticMethodID(env, mActivityClass, "setSystemCursor", "(I)Z");
     midSetWindowStyle = (*env)->GetStaticMethodID(env, mActivityClass, "setWindowStyle","(Z)V");
     midShouldMinimizeOnFocusLoss = (*env)->GetStaticMethodID(env, mActivityClass, "shouldMinimizeOnFocusLoss","()Z");
@@ -607,6 +614,7 @@ JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeSetupJNI)(JNIEnv *env, jclass cl
         !midClipboardHasText ||
         !midClipboardSetText ||
         !midCreateCustomCursor ||
+        !midDestroyCustomCursor ||
         !midGetContext ||
         !midGetDisplayDPI ||
         !midGetManifestEnvironmentVariables ||
@@ -621,12 +629,12 @@ JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeSetupJNI)(JNIEnv *env, jclass cl
         !midMinimizeWindow ||
         !midOpenURL ||
         !midRequestPermission ||
+        !midShowToast ||
         !midSendMessage ||
         !midSetActivityTitle ||
         !midSetCustomCursor ||
         !midSetOrientation ||
         !midSetRelativeMouseEnabled ||
-        !midSetSurfaceViewFormat ||
         !midSetSystemCursor ||
         !midSetWindowStyle ||
         !midShouldMinimizeOnFocusLoss ||
@@ -842,11 +850,11 @@ retry:
 JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeSetScreenResolution)(
                                     JNIEnv *env, jclass jcls,
                                     jint surfaceWidth, jint surfaceHeight,
-                                    jint deviceWidth, jint deviceHeight, jint format, jfloat rate)
+                                    jint deviceWidth, jint deviceHeight, jfloat rate)
 {
     SDL_LockMutex(Android_ActivityMutex);
 
-    Android_SetScreenResolution(surfaceWidth, surfaceHeight, deviceWidth, deviceHeight, format, rate);
+    Android_SetScreenResolution(surfaceWidth, surfaceHeight, deviceWidth, deviceHeight, rate);
 
     SDL_UnlockMutex(Android_ActivityMutex);
 }
@@ -1001,6 +1009,7 @@ JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeSurfaceChanged)(JNIEnv *env, j
 {
     SDL_LockMutex(Android_ActivityMutex);
 
+#if SDL_VIDEO_OPENGL_EGL
     if (Android_Window)
     {
         SDL_VideoDevice *_this = SDL_GetVideoDevice();
@@ -1013,6 +1022,7 @@ JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeSurfaceChanged)(JNIEnv *env, j
 
         /* GL Context handling is done in the event loop because this function is run from the Java thread */
     }
+#endif
 
     SDL_UnlockMutex(Android_ActivityMutex);
 }
@@ -1043,10 +1053,12 @@ retry:
             }
         }
 
+#if SDL_VIDEO_OPENGL_EGL
         if (data->egl_surface != EGL_NO_SURFACE) {
             SDL_EGL_DestroySurface(_this, data->egl_surface);
             data->egl_surface = EGL_NO_SURFACE;
         }
+#endif
 
         if (data->native_window) {
             ANativeWindow_release(data->native_window);
@@ -1306,6 +1318,19 @@ JNIEXPORT jstring JNICALL SDL_JAVA_INTERFACE(nativeGetHint)(
     return result;
 }
 
+JNIEXPORT jboolean JNICALL SDL_JAVA_INTERFACE(nativeGetHintBoolean)(
+                                    JNIEnv *env, jclass cls,
+                                    jstring name, jboolean default_value)
+{
+    jboolean result;
+
+    const char *utfname = (*env)->GetStringUTFChars(env, name, NULL);
+    result = SDL_GetHintBoolean(utfname, default_value);
+    (*env)->ReleaseStringUTFChars(env, name, utfname);
+
+    return result;
+}
+
 JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeSetenv)(
                                     JNIEnv *env, jclass cls,
                                     jstring name, jstring value)
@@ -1381,26 +1406,6 @@ ANativeWindow* Android_JNI_GetNativeWindow(void)
     return anw;
 }
 
-void Android_JNI_SetSurfaceViewFormat(int format)
-{
-    JNIEnv *env = Android_JNI_GetEnv();
-    int new_format = 0;
-
-    /* Format from android/native_window.h,
-     * convert to temporary arbitrary values,
-     * then to java PixelFormat */
-    if (format == WINDOW_FORMAT_RGBA_8888) {
-        new_format = 1;
-    } else if (format == WINDOW_FORMAT_RGBX_8888) {
-        new_format = 2;
-    } else if (format == WINDOW_FORMAT_RGB_565) {
-        /* Default */
-        new_format = 0;
-    }
-
-    (*env)->CallStaticVoidMethod(env, mActivityClass, midSetSurfaceViewFormat, new_format);
-}
-
 void Android_JNI_SetActivityTitle(const char *title)
 {
     JNIEnv *env = Android_JNI_GetEnv();
@@ -2125,6 +2130,15 @@ void Android_JNI_HapticStop(int device_id)
 /* See SDLActivity.java for constants. */
 #define COMMAND_SET_KEEP_SCREEN_ON    5
 
+
+int SDL_AndroidSendMessage(Uint32 command, int param)
+{
+    if (command >= 0x8000) {
+        return Android_JNI_SendMessage(command, param);
+    }
+    return -1;
+}
+
 /* sends message to be handled on the UI event dispatch thread */
 int Android_JNI_SendMessage(int command, int param)
 {
@@ -2468,6 +2482,11 @@ SDL_bool SDL_AndroidRequestPermission(const char *permission)
     return Android_JNI_RequestPermission(permission);
 }
 
+int SDL_AndroidShowToast(const char* message, int duration, int gravity, int xOffset, int yOffset)
+{
+    return Android_JNI_ShowToast(message, duration, gravity, xOffset, yOffset);
+}
+
 void Android_JNI_GetManifestEnvironmentVariables(void)
 {
     if (!mActivityClass || !midGetManifestEnvironmentVariables) {
@@ -2500,6 +2519,12 @@ int Android_JNI_CreateCustomCursor(SDL_Surface *surface, int hot_x, int hot_y)
     return custom_cursor;
 }
 
+void Android_JNI_DestroyCustomCursor(int cursorID)
+{
+    JNIEnv *env = Android_JNI_GetEnv();
+    (*env)->CallStaticVoidMethod(env, mActivityClass, midDestroyCustomCursor, cursorID);
+    return;
+}
 
 SDL_bool Android_JNI_SetCustomCursor(int cursorID)
 {
@@ -2528,23 +2553,34 @@ SDL_bool Android_JNI_SetRelativeMouseEnabled(SDL_bool enabled)
 SDL_bool Android_JNI_RequestPermission(const char *permission)
 {
     JNIEnv *env = Android_JNI_GetEnv();
-	const int requestCode = 1;
+    const int requestCode = 1;
 
-	/* Wait for any pending request on another thread */
-	while (SDL_AtomicGet(&bPermissionRequestPending) == SDL_TRUE) {
-		SDL_Delay(10);
-	}
-	SDL_AtomicSet(&bPermissionRequestPending, SDL_TRUE);
+    /* Wait for any pending request on another thread */
+    while (SDL_AtomicGet(&bPermissionRequestPending) == SDL_TRUE) {
+        SDL_Delay(10);
+    }
+    SDL_AtomicSet(&bPermissionRequestPending, SDL_TRUE);
 
     jstring jpermission = (*env)->NewStringUTF(env, permission);
     (*env)->CallStaticVoidMethod(env, mActivityClass, midRequestPermission, jpermission, requestCode);
     (*env)->DeleteLocalRef(env, jpermission);
 
-	/* Wait for the request to complete */
-	while (SDL_AtomicGet(&bPermissionRequestPending) == SDL_TRUE) {
-		SDL_Delay(10);
-	}
-	return bPermissionRequestResult;
+    /* Wait for the request to complete */
+    while (SDL_AtomicGet(&bPermissionRequestPending) == SDL_TRUE) {
+        SDL_Delay(10);
+    }
+    return bPermissionRequestResult;
+}
+
+/* Show toast notification */
+int Android_JNI_ShowToast(const char* message, int duration, int gravity, int xOffset, int yOffset)
+{
+    int result = 0;
+    JNIEnv *env = Android_JNI_GetEnv();
+    jstring jmessage = (*env)->NewStringUTF(env, message);
+    result = (*env)->CallStaticIntMethod(env, mActivityClass, midShowToast, jmessage, duration, gravity, xOffset, yOffset);
+    (*env)->DeleteLocalRef(env, jmessage);
+    return result;
 }
 
 int Android_JNI_GetLocale(char *buf, size_t buflen)
diff --git a/Engine/lib/sdl/src/core/android/SDL_android.h b/Engine/lib/sdl/src/core/android/SDL_android.h
index 1726e4a3e..0df411186 100644
--- a/Engine/lib/sdl/src/core/android/SDL_android.h
+++ b/Engine/lib/sdl/src/core/android/SDL_android.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -47,7 +47,6 @@ extern void Android_JNI_ShowTextInput(SDL_Rect *inputRect);
 extern void Android_JNI_HideTextInput(void);
 extern SDL_bool Android_JNI_IsScreenKeyboardShown(void);
 extern ANativeWindow* Android_JNI_GetNativeWindow(void);
-extern void Android_JNI_SetSurfaceViewFormat(int format);
 
 extern SDL_DisplayOrientation Android_JNI_GetDisplayOrientation(void);
 extern int Android_JNI_GetDisplayDPI(float *ddpi, float *xdpi, float *ydpi);
@@ -119,6 +118,7 @@ int Android_JNI_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *bu
 
 /* Cursor support */
 int Android_JNI_CreateCustomCursor(SDL_Surface *surface, int hot_x, int hot_y);
+void Android_JNI_DestroyCustomCursor(int cursorID);
 SDL_bool Android_JNI_SetCustomCursor(int cursorID);
 SDL_bool Android_JNI_SetSystemCursor(int cursorID);
 
@@ -129,6 +129,9 @@ SDL_bool Android_JNI_SetRelativeMouseEnabled(SDL_bool enabled);
 /* Request permission */
 SDL_bool Android_JNI_RequestPermission(const char *permission);
 
+/* Show toast notification */
+int Android_JNI_ShowToast(const char* message, int duration, int gravity, int xOffset, int yOffset);
+
 int Android_JNI_OpenURL(const char *url);
 
 int SDL_GetAndroidSDKVersion(void);
diff --git a/Engine/lib/sdl/src/core/android/keyinfotable.h b/Engine/lib/sdl/src/core/android/keyinfotable.h
index 67b539103..6c5d065b0 100644
--- a/Engine/lib/sdl/src/core/android/keyinfotable.h
+++ b/Engine/lib/sdl/src/core/android/keyinfotable.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/core/freebsd/SDL_evdev_kbd_freebsd.c b/Engine/lib/sdl/src/core/freebsd/SDL_evdev_kbd_freebsd.c
index 9d7dcd9ec..c242053ac 100644
--- a/Engine/lib/sdl/src/core/freebsd/SDL_evdev_kbd_freebsd.c
+++ b/Engine/lib/sdl/src/core/freebsd/SDL_evdev_kbd_freebsd.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -87,15 +87,18 @@ static int fatal_signals[] =
 
 static void kbd_cleanup(void)
 {
+    struct mouse_info mData;
     SDL_EVDEV_keyboard_state* kbd = kbd_cleanup_state;
     if (kbd == NULL) {
         return;
     }
     kbd_cleanup_state = NULL;
-    
+    SDL_zero(mData);
+    mData.operation = MOUSE_SHOW;
     ioctl(kbd->keyboard_fd, KDSKBMODE, kbd->old_kbd_mode);
     if (kbd->keyboard_fd != kbd->console_fd) close(kbd->keyboard_fd);
     ioctl(kbd->console_fd, CONS_SETKBD, (unsigned long)(kbd->kbInfo->kb_index));
+    ioctl(kbd->console_fd, CONS_MOUSECTL, &mData);
 }
 
 void
@@ -221,9 +224,12 @@ SDL_EVDEV_keyboard_state *
 SDL_EVDEV_kbd_init(void)
 {
     SDL_EVDEV_keyboard_state *kbd;
+    struct mouse_info mData;
     char flag_state;
     char* devicePath;
 
+    SDL_zero(mData);
+    mData.operation = MOUSE_HIDE;
     kbd = (SDL_EVDEV_keyboard_state *)SDL_calloc(1, sizeof(SDL_EVDEV_keyboard_state));
     if (!kbd) {
         return NULL;
@@ -232,7 +238,7 @@ SDL_EVDEV_kbd_init(void)
     kbd->npadch = -1;
 
     /* This might fail if we're not connected to a tty (e.g. on the Steam Link) */
-    kbd->keyboard_fd = kbd->console_fd = open("/dev/tty", O_RDONLY);
+    kbd->keyboard_fd = kbd->console_fd = open("/dev/tty", O_RDONLY | O_CLOEXEC);
 
     kbd->shift_state = 0;
 
@@ -241,7 +247,8 @@ SDL_EVDEV_kbd_init(void)
     kbd->kbInfo = SDL_calloc(sizeof(keyboard_info_t), 1);    
 
     ioctl(kbd->console_fd, KDGKBINFO, kbd->kbInfo);
-
+    ioctl(kbd->console_fd, CONS_MOUSECTL, &mData);
+    
     if (ioctl(kbd->console_fd, KDGKBSTATE, &flag_state) == 0) {
         kbd->ledflagstate = flag_state;
     }
@@ -261,13 +268,13 @@ SDL_EVDEV_kbd_init(void)
             kbd->key_map = &keymap_default_us_acc;
         }
         /* Allow inhibiting keyboard mute with env. variable for debugging etc. */
-        if (getenv("SDL_INPUT_FREEBSD_KEEP_KBD") == NULL) {
+        if (SDL_getenv("SDL_INPUT_FREEBSD_KEEP_KBD") == NULL) {
             /* Take keyboard from console and open the actual keyboard device.
              * Ensures that the keystrokes do not leak through to the console.
              */
             ioctl(kbd->console_fd, CONS_RELKBD, 1ul);
-            asprintf(&devicePath, "/dev/kbd%d", kbd->kbInfo->kb_index);         
-            kbd->keyboard_fd = open(devicePath, O_WRONLY);
+            SDL_asprintf(&devicePath, "/dev/kbd%d", kbd->kbInfo->kb_index);
+            kbd->keyboard_fd = open(devicePath, O_WRONLY | O_CLOEXEC);
             if (kbd->keyboard_fd == -1)
             {
                 // Give keyboard back.
@@ -281,7 +288,7 @@ SDL_EVDEV_kbd_init(void)
             if (!SDL_GetHintBoolean(SDL_HINT_NO_SIGNAL_HANDLERS, SDL_FALSE)) {
                 kbd_register_emerg_cleanup(kbd);
             }
-            free(devicePath);
+            SDL_free(devicePath);
         }
         else kbd->keyboard_fd = kbd->console_fd;
     }
@@ -292,9 +299,14 @@ SDL_EVDEV_kbd_init(void)
 void
 SDL_EVDEV_kbd_quit(SDL_EVDEV_keyboard_state *kbd)
 {
+    struct mouse_info mData;
+
     if (!kbd) {
         return;
     }
+    SDL_zero(mData);
+    mData.operation = MOUSE_SHOW;
+    ioctl(kbd->console_fd, CONS_MOUSECTL, &mData);
 
     kbd_unregister_emerg_cleanup();
 
diff --git a/Engine/lib/sdl/src/core/linux/SDL_dbus.c b/Engine/lib/sdl/src/core/linux/SDL_dbus.c
index 4a3b0dfe2..2fe12163e 100644
--- a/Engine/lib/sdl/src/core/linux/SDL_dbus.c
+++ b/Engine/lib/sdl/src/core/linux/SDL_dbus.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -19,7 +19,9 @@
   3. This notice may not be removed or altered from any source distribution.
 */
 #include "../../SDL_internal.h"
+#include "SDL_hints.h"
 #include "SDL_dbus.h"
+#include "SDL_atomic.h"
 
 #if SDL_USE_LIBDBUS
 /* we never link directly to libdbus. */
@@ -113,8 +115,12 @@ LoadDBUSLibrary(void)
     return retval;
 }
 
-void
-SDL_DBus_Init(void)
+
+static SDL_SpinLock spinlock_dbus_init = 0;
+
+/* you must hold spinlock_dbus_init before calling this! */
+static void
+SDL_DBus_Init_Spinlocked(void)
 {
     static SDL_bool is_dbus_available = SDL_TRUE;
     if (!is_dbus_available) {
@@ -156,6 +162,14 @@ SDL_DBus_Init(void)
     }
 }
 
+void
+SDL_DBus_Init(void)
+{
+    SDL_AtomicLock(&spinlock_dbus_init);  /* make sure two threads can't init at same time, since this can happen before SDL_Init. */
+    SDL_DBus_Init_Spinlocked();
+    SDL_AtomicUnlock(&spinlock_dbus_init);
+}
+
 void
 SDL_DBus_Quit(void)
 {
@@ -352,8 +366,15 @@ SDL_DBus_ScreensaverInhibit(SDL_bool inhibit)
         const char *interface = "org.freedesktop.ScreenSaver";
 
         if (inhibit) {
-            const char *app = "My SDL application";
-            const char *reason = "Playing a game";
+            const char *app = SDL_GetHint(SDL_HINT_APP_NAME);
+            const char *reason = SDL_GetHint(SDL_HINT_SCREENSAVER_INHIBIT_ACTIVITY_NAME);
+            if (!app || !app[0]) {
+               app  = "My SDL application";
+            }
+            if (!reason || !reason[0]) {
+                reason = "Playing a game";
+            }
+
             if (!SDL_DBus_CallMethod(node, path, interface, "Inhibit",
                     DBUS_TYPE_STRING, &app, DBUS_TYPE_STRING, &reason, DBUS_TYPE_INVALID,
                     DBUS_TYPE_UINT32, &screensaver_cookie, DBUS_TYPE_INVALID)) {
diff --git a/Engine/lib/sdl/src/core/linux/SDL_dbus.h b/Engine/lib/sdl/src/core/linux/SDL_dbus.h
index 334a87ca7..04ab2a80d 100644
--- a/Engine/lib/sdl/src/core/linux/SDL_dbus.h
+++ b/Engine/lib/sdl/src/core/linux/SDL_dbus.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/core/linux/SDL_evdev.c b/Engine/lib/sdl/src/core/linux/SDL_evdev.c
index 5c190b0e1..208b3c1f1 100644
--- a/Engine/lib/sdl/src/core/linux/SDL_evdev.c
+++ b/Engine/lib/sdl/src/core/linux/SDL_evdev.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -57,6 +57,10 @@
 #define ABS_MT_TRACKING_ID  0x39
 #define ABS_MT_PRESSURE     0x3a
 #endif
+#ifndef REL_WHEEL_HI_RES
+#define REL_WHEEL_HI_RES    0x0b
+#define REL_HWHEEL_HI_RES   0x0c
+#endif
 
 typedef struct SDL_evdevlist_item
 {
@@ -92,6 +96,9 @@ typedef struct SDL_evdevlist_item
 
     } * touchscreen_data;
 
+    SDL_bool high_res_wheel;
+    SDL_bool high_res_hwheel;
+
     struct SDL_evdevlist_item *next;
 } SDL_evdevlist_item;
 
@@ -218,8 +225,14 @@ static void SDL_EVDEV_udev_callback(SDL_UDEV_deviceevent udev_event, int udev_cl
 
     switch(udev_event) {
     case SDL_UDEV_DEVICEADDED:
-        if (!(udev_class & (SDL_UDEV_DEVICE_MOUSE | SDL_UDEV_DEVICE_KEYBOARD |
-            SDL_UDEV_DEVICE_TOUCHSCREEN)))
+        if (udev_class & SDL_UDEV_DEVICE_TOUCHPAD) {
+            udev_class |= SDL_UDEV_DEVICE_TOUCHSCREEN;
+        }
+
+        if (!(udev_class & (SDL_UDEV_DEVICE_MOUSE | SDL_UDEV_DEVICE_KEYBOARD | SDL_UDEV_DEVICE_TOUCHSCREEN)))
+            return;
+
+        if ((udev_class & SDL_UDEV_DEVICE_JOYSTICK))
             return;
 
         SDL_EVDEV_device_added(dev_path, udev_class);
@@ -372,10 +385,20 @@ SDL_EVDEV_Poll(void)
                         SDL_SendMouseMotion(mouse->focus, mouse->mouseID, SDL_TRUE, 0, events[i].value);
                         break;
                     case REL_WHEEL:
-                        SDL_SendMouseWheel(mouse->focus, mouse->mouseID, 0, events[i].value, SDL_MOUSEWHEEL_NORMAL);
+                        if (!item->high_res_wheel)
+                            SDL_SendMouseWheel(mouse->focus, mouse->mouseID, 0, events[i].value, SDL_MOUSEWHEEL_NORMAL);
+                        break;
+                    case REL_WHEEL_HI_RES:
+                        SDL_assert(item->high_res_wheel);
+                        SDL_SendMouseWheel(mouse->focus, mouse->mouseID, 0, events[i].value / 120.0f, SDL_MOUSEWHEEL_NORMAL);
                         break;
                     case REL_HWHEEL:
-                        SDL_SendMouseWheel(mouse->focus, mouse->mouseID, events[i].value, 0, SDL_MOUSEWHEEL_NORMAL);
+                        if (!item->high_res_hwheel)
+                            SDL_SendMouseWheel(mouse->focus, mouse->mouseID, events[i].value, 0, SDL_MOUSEWHEEL_NORMAL);
+                        break;
+                    case REL_HWHEEL_HI_RES:
+                        SDL_assert(item->high_res_hwheel);
+                        SDL_SendMouseWheel(mouse->focus, mouse->mouseID, events[i].value / 120.0f, 0, SDL_MOUSEWHEEL_NORMAL);
                         break;
                     default:
                         break;
@@ -709,6 +732,7 @@ SDL_EVDEV_device_added(const char *dev_path, int udev_class)
 {
     int ret;
     SDL_evdevlist_item *item;
+    unsigned long relbit[NBITS(REL_MAX)] = { 0 };
 
     /* Check to make sure it's not already in list. */
     for (item = _this->first; item != NULL; item = item->next) {
@@ -722,7 +746,7 @@ SDL_EVDEV_device_added(const char *dev_path, int udev_class)
         return SDL_OutOfMemory();
     }
 
-    item->fd = open(dev_path, O_RDONLY | O_NONBLOCK);
+    item->fd = open(dev_path, O_RDONLY | O_NONBLOCK | O_CLOEXEC);
     if (item->fd < 0) {
         SDL_free(item);
         return SDL_SetError("Unable to open %s", dev_path);
@@ -735,11 +759,17 @@ SDL_EVDEV_device_added(const char *dev_path, int udev_class)
         return SDL_OutOfMemory();
     }
 
+    if (ioctl(item->fd, EVIOCGBIT(EV_REL, sizeof(relbit)), relbit) >= 0) {
+        item->high_res_wheel = test_bit(REL_WHEEL_HI_RES, relbit);
+        item->high_res_hwheel = test_bit(REL_HWHEEL_HI_RES, relbit);
+    }
+
     if (udev_class & SDL_UDEV_DEVICE_TOUCHSCREEN) {
         item->is_touchscreen = 1;
 
         if ((ret = SDL_EVDEV_init_touchscreen(item)) < 0) {
             close(item->fd);
+            SDL_free(item->path);
             SDL_free(item);
             return ret;
         }
diff --git a/Engine/lib/sdl/src/core/linux/SDL_evdev.h b/Engine/lib/sdl/src/core/linux/SDL_evdev.h
index c5726332e..c951232fa 100644
--- a/Engine/lib/sdl/src/core/linux/SDL_evdev.h
+++ b/Engine/lib/sdl/src/core/linux/SDL_evdev.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/core/linux/SDL_evdev_capabilities.c b/Engine/lib/sdl/src/core/linux/SDL_evdev_capabilities.c
index 12185fe1a..976f629fc 100644
--- a/Engine/lib/sdl/src/core/linux/SDL_evdev_capabilities.c
+++ b/Engine/lib/sdl/src/core/linux/SDL_evdev_capabilities.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
   Copyright (C) 2020 Collabora Ltd.
 
   This software is provided 'as-is', without any express or implied
@@ -24,12 +24,34 @@
 
 #if HAVE_LIBUDEV_H || defined(SDL_JOYSTICK_LINUX)
 
+/* missing defines in older Linux kernel headers */
+#ifndef BTN_TRIGGER_HAPPY
+#define BTN_TRIGGER_HAPPY 0x2c0
+#endif
+#ifndef BTN_DPAD_UP
+#define BTN_DPAD_UP       0x220
+#endif
+#ifndef KEY_ALS_TOGGLE
+#define KEY_ALS_TOGGLE    0x230
+#endif
+
 extern int
 SDL_EVDEV_GuessDeviceClass(unsigned long bitmask_ev[NBITS(EV_MAX)],
                            unsigned long bitmask_abs[NBITS(ABS_MAX)],
                            unsigned long bitmask_key[NBITS(KEY_MAX)],
                            unsigned long bitmask_rel[NBITS(REL_MAX)])
 {
+    struct range {
+        unsigned start;
+        unsigned end;
+    };
+
+    /* key code ranges above BTN_MISC (start is inclusive, stop is exclusive)*/
+    static const struct range high_key_blocks[] = {
+        { KEY_OK, BTN_DPAD_UP },
+        { KEY_ALS_TOGGLE, BTN_TRIGGER_HAPPY }
+    };
+
     int devclass = 0;
     unsigned long keyboard_mask;
 
@@ -56,7 +78,7 @@ SDL_EVDEV_GuessDeviceClass(unsigned long bitmask_ev[NBITS(EV_MAX)],
         if (test_bit(BTN_STYLUS, bitmask_key) || test_bit(BTN_TOOL_PEN, bitmask_key)) {
             ; /* ID_INPUT_TABLET */
         } else if (test_bit(BTN_TOOL_FINGER, bitmask_key) && !test_bit(BTN_TOOL_PEN, bitmask_key)) {
-            ; /* ID_INPUT_TOUCHPAD */
+            devclass |= SDL_UDEV_DEVICE_TOUCHPAD; /* ID_INPUT_TOUCHPAD */
         } else if (test_bit(BTN_MOUSE, bitmask_key)) {
             devclass |= SDL_UDEV_DEVICE_MOUSE; /* ID_INPUT_MOUSE */
         } else if (test_bit(BTN_TOUCH, bitmask_key)) {
@@ -86,6 +108,31 @@ SDL_EVDEV_GuessDeviceClass(unsigned long bitmask_ev[NBITS(EV_MAX)],
         devclass |= SDL_UDEV_DEVICE_MOUSE; /* ID_INPUT_MOUSE */
     }
 
+    if (test_bit(EV_KEY, bitmask_ev)) {
+        unsigned i;
+        unsigned long found = 0;
+
+        for (i = 0; i < BTN_MISC/BITS_PER_LONG; ++i) {
+            found |= bitmask_key[i];
+        }
+        /* If there are no keys in the lower block, check the higher blocks */
+        if (!found) {
+            unsigned block;
+            for (block = 0; block < (sizeof(high_key_blocks) / sizeof(struct range)); ++block) {
+                for (i = high_key_blocks[block].start; i < high_key_blocks[block].end; ++i) {
+                    if (test_bit(i, bitmask_key)) {
+                        found = 1;
+                        break;
+                    }
+                }
+            }
+        }
+
+        if (found > 0) {
+            devclass |= SDL_UDEV_DEVICE_KEYBOARD; /* ID_INPUT_KEY */
+        }
+    }
+
     /* the first 32 bits are ESC, numbers, and Q to D; if we have any of
      * those, consider it a keyboard device; do not test KEY_RESERVED, though */
     keyboard_mask = 0xFFFFFFFE;
diff --git a/Engine/lib/sdl/src/core/linux/SDL_evdev_capabilities.h b/Engine/lib/sdl/src/core/linux/SDL_evdev_capabilities.h
index e9c66c05f..26fa74004 100644
--- a/Engine/lib/sdl/src/core/linux/SDL_evdev_capabilities.h
+++ b/Engine/lib/sdl/src/core/linux/SDL_evdev_capabilities.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
   Copyright (C) 2020 Collabora Ltd.
 
   This software is provided 'as-is', without any express or implied
@@ -38,7 +38,8 @@ typedef enum
     SDL_UDEV_DEVICE_JOYSTICK    = 0x0004,
     SDL_UDEV_DEVICE_SOUND       = 0x0008,
     SDL_UDEV_DEVICE_TOUCHSCREEN = 0x0010,
-    SDL_UDEV_DEVICE_ACCELEROMETER = 0x0020
+    SDL_UDEV_DEVICE_ACCELEROMETER = 0x0020,
+    SDL_UDEV_DEVICE_TOUCHPAD    = 0x0040
 } SDL_UDEV_deviceclass;
 
 #define BITS_PER_LONG           (sizeof(unsigned long) * 8)
diff --git a/Engine/lib/sdl/src/core/linux/SDL_evdev_kbd.c b/Engine/lib/sdl/src/core/linux/SDL_evdev_kbd.c
index 10560c199..f090bff41 100644
--- a/Engine/lib/sdl/src/core/linux/SDL_evdev_kbd.c
+++ b/Engine/lib/sdl/src/core/linux/SDL_evdev_kbd.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -219,7 +219,7 @@ static void kbd_cleanup(void)
     ioctl(kbd->console_fd, KDSKBMODE, kbd->old_kbd_mode);
 }
 
-void
+static void
 SDL_EVDEV_kbd_reraise_signal(int sig)
 {
     raise(sig);
@@ -354,7 +354,7 @@ SDL_EVDEV_kbd_init(void)
     kbd->npadch = -1;
 
     /* This might fail if we're not connected to a tty (e.g. on the Steam Link) */
-    kbd->console_fd = open("/dev/tty", O_RDONLY);
+    kbd->console_fd = open("/dev/tty", O_RDONLY | O_CLOEXEC);
 
     if (ioctl(kbd->console_fd, TIOCLINUX, shift_state) == 0) {
         kbd->shift_state = *shift_state;
@@ -386,7 +386,7 @@ SDL_EVDEV_kbd_init(void)
         }
 
         /* Allow inhibiting keyboard mute with env. variable for debugging etc. */
-        if (getenv("SDL_INPUT_LINUX_KEEP_KBD") == NULL) {
+        if (SDL_getenv("SDL_INPUT_LINUX_KEEP_KBD") == NULL) {
             /* Mute the keyboard so keystrokes only generate evdev events
              * and do not leak through to the console
              */
diff --git a/Engine/lib/sdl/src/core/linux/SDL_evdev_kbd.h b/Engine/lib/sdl/src/core/linux/SDL_evdev_kbd.h
index 0b276ec88..9511838cc 100644
--- a/Engine/lib/sdl/src/core/linux/SDL_evdev_kbd.h
+++ b/Engine/lib/sdl/src/core/linux/SDL_evdev_kbd.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/core/linux/SDL_evdev_kbd_default_accents.h b/Engine/lib/sdl/src/core/linux/SDL_evdev_kbd_default_accents.h
index 01caaa252..6ac089506 100644
--- a/Engine/lib/sdl/src/core/linux/SDL_evdev_kbd_default_accents.h
+++ b/Engine/lib/sdl/src/core/linux/SDL_evdev_kbd_default_accents.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/core/linux/SDL_evdev_kbd_default_keymap.h b/Engine/lib/sdl/src/core/linux/SDL_evdev_kbd_default_keymap.h
index 84cf8faa7..30affb0b2 100644
--- a/Engine/lib/sdl/src/core/linux/SDL_evdev_kbd_default_keymap.h
+++ b/Engine/lib/sdl/src/core/linux/SDL_evdev_kbd_default_keymap.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/core/linux/SDL_fcitx.c b/Engine/lib/sdl/src/core/linux/SDL_fcitx.c
index 1d726651b..3f0794736 100644
--- a/Engine/lib/sdl/src/core/linux/SDL_fcitx.c
+++ b/Engine/lib/sdl/src/core/linux/SDL_fcitx.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -84,7 +84,8 @@ GetAppName()
     return SDL_strdup("SDL_App");
 }
 
-size_t Fcitx_GetPreeditString(SDL_DBusContext *dbus, DBusMessage *msg, char **ret) {
+static size_t
+Fcitx_GetPreeditString(SDL_DBusContext *dbus, DBusMessage *msg, char **ret) {
     char *text = NULL, *subtext;
     size_t text_bytes = 0;
     DBusMessageIter iter, array, sub;
@@ -204,7 +205,7 @@ Fcitx_SetCapabilities(void *data,
         const char *internal_editing)
 {
     FcitxClient *client = (FcitxClient *)data;
-    Uint32 caps = 0;
+    Uint64 caps = 0;
     if (!client->ic_path) {
         return;
     }
diff --git a/Engine/lib/sdl/src/core/linux/SDL_fcitx.h b/Engine/lib/sdl/src/core/linux/SDL_fcitx.h
index bb725bb8a..f7884ea43 100644
--- a/Engine/lib/sdl/src/core/linux/SDL_fcitx.h
+++ b/Engine/lib/sdl/src/core/linux/SDL_fcitx.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/core/linux/SDL_ibus.c b/Engine/lib/sdl/src/core/linux/SDL_ibus.c
index 3a014887f..a7bafda35 100644
--- a/Engine/lib/sdl/src/core/linux/SDL_ibus.c
+++ b/Engine/lib/sdl/src/core/linux/SDL_ibus.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -257,7 +257,12 @@ IBus_GetDBusAddressFilename(void)
     }
     
     if (!*host) {
-        host = "unix";
+        const char *session = SDL_getenv("XDG_SESSION_TYPE");
+        if (session != NULL && SDL_strcmp(session, "wayland") == 0) {
+            host = "unix-wayland";
+        } else {
+            host = "unix";
+        }
     }
         
     SDL_memset(config_dir, 0, sizeof(config_dir));
@@ -479,7 +484,7 @@ IBus_SimpleMessage(const char *method)
 {   
     SDL_DBusContext *dbus = SDL_DBus_GetContext();
     
-    if (IBus_CheckConnection(dbus)) {
+    if ((input_ctx_path != NULL) && (IBus_CheckConnection(dbus))) {
         SDL_DBus_CallVoidMethodOnConnection(ibus_conn, IBUS_SERVICE, input_ctx_path, IBUS_INPUT_INTERFACE, method, DBUS_TYPE_INVALID);
     }
 }
diff --git a/Engine/lib/sdl/src/core/linux/SDL_ibus.h b/Engine/lib/sdl/src/core/linux/SDL_ibus.h
index d3b85e3e2..73a9f1b8b 100644
--- a/Engine/lib/sdl/src/core/linux/SDL_ibus.h
+++ b/Engine/lib/sdl/src/core/linux/SDL_ibus.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/core/linux/SDL_ime.c b/Engine/lib/sdl/src/core/linux/SDL_ime.c
index b6034227a..84c461f8b 100644
--- a/Engine/lib/sdl/src/core/linux/SDL_ime.c
+++ b/Engine/lib/sdl/src/core/linux/SDL_ime.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -23,13 +23,13 @@
 #include "SDL_ibus.h"
 #include "SDL_fcitx.h"
 
-typedef SDL_bool (*_SDL_IME_Init)();
-typedef void (*_SDL_IME_Quit)();
+typedef SDL_bool (*_SDL_IME_Init)(void);
+typedef void (*_SDL_IME_Quit)(void);
 typedef void (*_SDL_IME_SetFocus)(SDL_bool);
-typedef void (*_SDL_IME_Reset)();
+typedef void (*_SDL_IME_Reset)(void);
 typedef SDL_bool (*_SDL_IME_ProcessKeyEvent)(Uint32, Uint32);
 typedef void (*_SDL_IME_UpdateTextRect)(SDL_Rect *);
-typedef void (*_SDL_IME_PumpEvents)();
+typedef void (*_SDL_IME_PumpEvents)(void);
 
 static _SDL_IME_Init SDL_IME_Init_Real = NULL;
 static _SDL_IME_Quit SDL_IME_Quit_Real = NULL;
diff --git a/Engine/lib/sdl/src/core/linux/SDL_ime.h b/Engine/lib/sdl/src/core/linux/SDL_ime.h
index bc03a1ac1..a28a4b430 100644
--- a/Engine/lib/sdl/src/core/linux/SDL_ime.h
+++ b/Engine/lib/sdl/src/core/linux/SDL_ime.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/core/linux/SDL_threadprio.c b/Engine/lib/sdl/src/core/linux/SDL_threadprio.c
index 74167a4c7..9009d5dfc 100644
--- a/Engine/lib/sdl/src/core/linux/SDL_threadprio.c
+++ b/Engine/lib/sdl/src/core/linux/SDL_threadprio.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -108,7 +108,9 @@ rtkit_initialize_realtime_thread()
     int nLimit = RLIMIT_RTTIME;
     pid_t nPid = 0; //self
     int nSchedPolicy = sched_getscheduler(nPid) | SCHED_RESET_ON_FORK;
-    struct sched_param schedParam = {};
+    struct sched_param schedParam;
+
+    SDL_zero(schedParam);
 
     // Requirement #1: Set RLIMIT_RTTIME
     err = getrlimit(nLimit, &rlimit);
diff --git a/Engine/lib/sdl/src/core/linux/SDL_udev.c b/Engine/lib/sdl/src/core/linux/SDL_udev.c
index b45ed10e4..fa775bc22 100644
--- a/Engine/lib/sdl/src/core/linux/SDL_udev.c
+++ b/Engine/lib/sdl/src/core/linux/SDL_udev.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -19,7 +19,7 @@
   3. This notice may not be removed or altered from any source distribution.
 */
 
-/* 
+/*
  * To list the properties of a device, try something like:
  * udevadm info -a -n snd/hwC0D0 (for a sound card)
  * udevadm info --query=all -n input/event3 (for a keyboard, mouse, etc)
@@ -103,7 +103,7 @@ SDL_UDEV_hotplug_update_available(void)
 {
     if (_this->udev_mon != NULL) {
         const int fd = _this->syms.udev_monitor_get_fd(_this->udev_mon);
-        if (SDL_IOReady(fd, SDL_FALSE, 0)) {
+        if (SDL_IOReady(fd, SDL_IOR_READ, 0)) {
             return SDL_TRUE;
         }
     }
@@ -115,23 +115,23 @@ int
 SDL_UDEV_Init(void)
 {
     int retval = 0;
-    
+
     if (_this == NULL) {
         _this = (SDL_UDEV_PrivateData *) SDL_calloc(1, sizeof(*_this));
         if(_this == NULL) {
             return SDL_OutOfMemory();
         }
-        
+
         retval = SDL_UDEV_LoadLibrary();
         if (retval < 0) {
             SDL_UDEV_Quit();
             return retval;
         }
-        
-        /* Set up udev monitoring 
+
+        /* Set up udev monitoring
          * Listen for input devices (mouse, keyboard, joystick, etc) and sound devices
          */
-        
+
         _this->udev = _this->syms.udev_new();
         if (_this->udev == NULL) {
             SDL_UDEV_Quit();
@@ -143,18 +143,18 @@ SDL_UDEV_Init(void)
             SDL_UDEV_Quit();
             return SDL_SetError("udev_monitor_new_from_netlink() failed");
         }
-        
+
         _this->syms.udev_monitor_filter_add_match_subsystem_devtype(_this->udev_mon, "input", NULL);
         _this->syms.udev_monitor_filter_add_match_subsystem_devtype(_this->udev_mon, "sound", NULL);
         _this->syms.udev_monitor_enable_receiving(_this->udev_mon);
-        
+
         /* Do an initial scan of existing devices */
         SDL_UDEV_Scan();
 
     }
-    
+
     _this->ref_count += 1;
-    
+
     return retval;
 }
 
@@ -162,15 +162,15 @@ void
 SDL_UDEV_Quit(void)
 {
     SDL_UDEV_CallbackList *item;
-    
+
     if (_this == NULL) {
         return;
     }
-    
+
     _this->ref_count -= 1;
-    
+
     if (_this->ref_count < 1) {
-        
+
         if (_this->udev_mon != NULL) {
             _this->syms.udev_monitor_unref(_this->udev_mon);
             _this->udev_mon = NULL;
@@ -179,14 +179,14 @@ SDL_UDEV_Quit(void)
             _this->syms.udev_unref(_this->udev);
             _this->udev = NULL;
         }
-        
+
         /* Remove existing devices */
         while (_this->first != NULL) {
             item = _this->first;
             _this->first = _this->first->next;
             SDL_free(item);
         }
-        
+
         SDL_UDEV_UnloadLibrary();
         SDL_free(_this);
         _this = NULL;
@@ -198,22 +198,22 @@ SDL_UDEV_Scan(void)
 {
     struct udev_enumerate *enumerate = NULL;
     struct udev_list_entry *devs = NULL;
-    struct udev_list_entry *item = NULL;  
-    
+    struct udev_list_entry *item = NULL;
+
     if (_this == NULL) {
         return;
     }
-   
+
     enumerate = _this->syms.udev_enumerate_new(_this->udev);
     if (enumerate == NULL) {
         SDL_UDEV_Quit();
         SDL_SetError("udev_enumerate_new() failed");
         return;
     }
-    
+
     _this->syms.udev_enumerate_add_match_subsystem(enumerate, "input");
     _this->syms.udev_enumerate_add_match_subsystem(enumerate, "sound");
-    
+
     _this->syms.udev_enumerate_scan_devices(enumerate);
     devs = _this->syms.udev_enumerate_get_list_entry(enumerate);
     for (item = devs; item; item = _this->syms.udev_list_entry_get_next(item)) {
@@ -228,6 +228,62 @@ SDL_UDEV_Scan(void)
     _this->syms.udev_enumerate_unref(enumerate);
 }
 
+SDL_bool
+SDL_UDEV_GetProductInfo(const char *device_path, Uint16 *vendor, Uint16 *product, Uint16 *version)
+{
+    struct udev_enumerate *enumerate = NULL;
+    struct udev_list_entry *devs = NULL;
+    struct udev_list_entry *item = NULL;
+    SDL_bool found = SDL_FALSE;
+
+    if (_this == NULL) {
+        return SDL_FALSE;
+    }
+
+    enumerate = _this->syms.udev_enumerate_new(_this->udev);
+    if (enumerate == NULL) {
+        SDL_SetError("udev_enumerate_new() failed");
+        return SDL_FALSE;
+    }
+
+    _this->syms.udev_enumerate_scan_devices(enumerate);
+    devs = _this->syms.udev_enumerate_get_list_entry(enumerate);
+    for (item = devs; item && !found; item = _this->syms.udev_list_entry_get_next(item)) {
+        const char *path = _this->syms.udev_list_entry_get_name(item);
+        struct udev_device *dev = _this->syms.udev_device_new_from_syspath(_this->udev, path);
+        if (dev != NULL) {
+            const char *val = NULL;
+            const char *existing_path;
+
+            existing_path = _this->syms.udev_device_get_devnode(dev);
+            if (existing_path && SDL_strcmp(device_path, existing_path) == 0) {
+                found = SDL_TRUE;
+
+                val = _this->syms.udev_device_get_property_value(dev, "ID_VENDOR_ID");
+                if (val != NULL) {
+                    *vendor = (Uint16)SDL_strtol(val, NULL, 16);
+                }
+
+                val = _this->syms.udev_device_get_property_value(dev, "ID_MODEL_ID");
+                if (val != NULL) {
+                    *product = (Uint16)SDL_strtol(val, NULL, 16);
+                }
+
+                val = _this->syms.udev_device_get_property_value(dev, "ID_REVISION");
+                if (val != NULL) {
+                    *version = (Uint16)SDL_strtol(val, NULL, 16);
+                }
+            }
+            _this->syms.udev_device_unref(dev);
+        }
+    }
+    _this->syms.udev_enumerate_unref(enumerate);
+
+    return found;
+}
+
+
+
 
 void
 SDL_UDEV_UnloadLibrary(void)
@@ -235,7 +291,7 @@ SDL_UDEV_UnloadLibrary(void)
     if (_this == NULL) {
         return;
     }
-    
+
     if (_this->udev_handle != NULL) {
         SDL_UnloadObject(_this->udev_handle);
         _this->udev_handle = NULL;
@@ -246,11 +302,11 @@ int
 SDL_UDEV_LoadLibrary(void)
 {
     int retval = 0, i;
-    
+
     if (_this == NULL) {
         return SDL_SetError("UDEV not initialized");
     }
- 
+
     /* See if there is a udev library already loaded */
     if (SDL_UDEV_load_syms() == 0) {
         return 0;
@@ -282,7 +338,7 @@ SDL_UDEV_LoadLibrary(void)
                 }
             }
         }
-        
+
         if (_this->udev_handle == NULL) {
             retval = -1;
             /* Don't call SDL_SetError(): SDL_LoadObject already did. */
@@ -352,26 +408,26 @@ guess_device_class(struct udev_device *dev)
                                       &bitmask_rel[0]);
 }
 
-static void 
-device_event(SDL_UDEV_deviceevent type, struct udev_device *dev) 
+static void
+device_event(SDL_UDEV_deviceevent type, struct udev_device *dev)
 {
     const char *subsystem;
     const char *val = NULL;
     int devclass = 0;
     const char *path;
     SDL_UDEV_CallbackList *item;
-    
+
     path = _this->syms.udev_device_get_devnode(dev);
     if (path == NULL) {
         return;
     }
-    
+
     subsystem = _this->syms.udev_device_get_subsystem(dev);
     if (SDL_strcmp(subsystem, "sound") == 0) {
         devclass = SDL_UDEV_DEVICE_SOUND;
     } else if (SDL_strcmp(subsystem, "input") == 0) {
         /* udev rules reference: http://cgit.freedesktop.org/systemd/systemd/tree/src/udev/udev-builtin-input_id.c */
-        
+
         val = _this->syms.udev_device_get_property_value(dev, "ID_INPUT_JOYSTICK");
         if (val != NULL && SDL_strcmp(val, "1") == 0 ) {
             devclass |= SDL_UDEV_DEVICE_JOYSTICK;
@@ -381,13 +437,13 @@ device_event(SDL_UDEV_deviceevent type, struct udev_device *dev)
         if (SDL_GetHintBoolean(SDL_HINT_ACCELEROMETER_AS_JOYSTICK, SDL_TRUE) &&
             val != NULL && SDL_strcmp(val, "1") == 0 ) {
             devclass |= SDL_UDEV_DEVICE_JOYSTICK;
-	}
-        
+        }
+
         val = _this->syms.udev_device_get_property_value(dev, "ID_INPUT_MOUSE");
         if (val != NULL && SDL_strcmp(val, "1") == 0 ) {
             devclass |= SDL_UDEV_DEVICE_MOUSE;
         }
-        
+
         val = _this->syms.udev_device_get_property_value(dev, "ID_INPUT_TOUCHSCREEN");
         if (val != NULL && SDL_strcmp(val, "1") == 0 ) {
             devclass |= SDL_UDEV_DEVICE_TOUCHSCREEN;
@@ -396,7 +452,7 @@ device_event(SDL_UDEV_deviceevent type, struct udev_device *dev)
         /* The undocumented rule is:
            - All devices with keys get ID_INPUT_KEY
            - From this subset, if they have ESC, numbers, and Q to D, it also gets ID_INPUT_KEYBOARD
-           
+
            Ref: http://cgit.freedesktop.org/systemd/systemd/tree/src/udev/udev-builtin-input_id.c#n183
         */
         val = _this->syms.udev_device_get_property_value(dev, "ID_INPUT_KEY");
@@ -425,14 +481,14 @@ device_event(SDL_UDEV_deviceevent type, struct udev_device *dev)
     } else {
         return;
     }
-    
+
     /* Process callbacks */
     for (item = _this->first; item != NULL; item = item->next) {
         item->callback(type, devclass, path);
     }
 }
 
-void 
+void
 SDL_UDEV_Poll(void)
 {
     struct udev_device *dev = NULL;
@@ -449,20 +505,19 @@ SDL_UDEV_Poll(void)
         }
         action = _this->syms.udev_device_get_action(dev);
 
-        if (SDL_strcmp(action, "add") == 0) {
-            /* Wait for the device to finish initialization */
-            SDL_Delay(100);
-
-            device_event(SDL_UDEV_DEVICEADDED, dev);
-        } else if (SDL_strcmp(action, "remove") == 0) {
-            device_event(SDL_UDEV_DEVICEREMOVED, dev);
+        if (action) {
+            if (SDL_strcmp(action, "add") == 0) {
+                device_event(SDL_UDEV_DEVICEADDED, dev);
+            } else if (SDL_strcmp(action, "remove") == 0) {
+                device_event(SDL_UDEV_DEVICEREMOVED, dev);
+            }
         }
-        
+
         _this->syms.udev_device_unref(dev);
     }
 }
 
-int 
+int
 SDL_UDEV_AddCallback(SDL_UDEV_Callback cb)
 {
     SDL_UDEV_CallbackList *item;
@@ -470,7 +525,7 @@ SDL_UDEV_AddCallback(SDL_UDEV_Callback cb)
     if (item == NULL) {
         return SDL_OutOfMemory();
     }
-    
+
     item->callback = cb;
 
     if (_this->last == NULL) {
@@ -479,11 +534,11 @@ SDL_UDEV_AddCallback(SDL_UDEV_Callback cb)
         _this->last->next = item;
         _this->last = item;
     }
-    
+
     return 1;
 }
 
-void 
+void
 SDL_UDEV_DelCallback(SDL_UDEV_Callback cb)
 {
     SDL_UDEV_CallbackList *item;
@@ -506,7 +561,6 @@ SDL_UDEV_DelCallback(SDL_UDEV_Callback cb)
         }
         prev = item;
     }
-    
 }
 
 const SDL_UDEV_Symbols *
diff --git a/Engine/lib/sdl/src/core/linux/SDL_udev.h b/Engine/lib/sdl/src/core/linux/SDL_udev.h
index 83b4610c8..9af4c3f5d 100644
--- a/Engine/lib/sdl/src/core/linux/SDL_udev.h
+++ b/Engine/lib/sdl/src/core/linux/SDL_udev.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -101,6 +101,7 @@ extern void SDL_UDEV_UnloadLibrary(void);
 extern int SDL_UDEV_LoadLibrary(void);
 extern void SDL_UDEV_Poll(void);
 extern void SDL_UDEV_Scan(void);
+extern SDL_bool SDL_UDEV_GetProductInfo(const char *device_path, Uint16 *vendor, Uint16 *product, Uint16 *version);
 extern int SDL_UDEV_AddCallback(SDL_UDEV_Callback cb);
 extern void SDL_UDEV_DelCallback(SDL_UDEV_Callback cb);
 extern const SDL_UDEV_Symbols *SDL_UDEV_GetUdevSyms(void);
diff --git a/Engine/lib/sdl/src/core/openbsd/SDL_wscons.h b/Engine/lib/sdl/src/core/openbsd/SDL_wscons.h
new file mode 100644
index 000000000..936d343d0
--- /dev/null
+++ b/Engine/lib/sdl/src/core/openbsd/SDL_wscons.h
@@ -0,0 +1,27 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+
+void SDL_WSCONS_Init();
+void SDL_WSCONS_Quit();
+
+void SDL_WSCONS_PumpEvents();
+
diff --git a/Engine/lib/sdl/src/core/openbsd/SDL_wscons_kbd.c b/Engine/lib/sdl/src/core/openbsd/SDL_wscons_kbd.c
new file mode 100644
index 000000000..121867d6a
--- /dev/null
+++ b/Engine/lib/sdl/src/core/openbsd/SDL_wscons_kbd.c
@@ -0,0 +1,841 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "../../SDL_internal.h"
+#include <dev/wscons/wsksymvar.h>
+#include <dev/wscons/wsksymdef.h>
+#include "SDL_scancode.h"
+#include "SDL_events.h"
+#include "SDL_keyboard.h"
+#include "SDL_wscons.h"
+#include "SDL_log.h"
+#include <sys/time.h>
+#include <dev/wscons/wsconsio.h>
+#include <dev/wscons/wsdisplay_usl_io.h>
+#include <termios.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/param.h>
+#include <unistd.h>
+
+#include "../../events/SDL_events_c.h"
+
+#ifdef __NetBSD__
+#define KS_GROUP_Ascii KS_GROUP_Plain
+#define KS_Cmd_ScrollBack KS_Cmd_ScrollFastUp
+#define KS_Cmd_ScrollFwd KS_Cmd_ScrollFastDown
+#endif
+
+#define RETIFIOCTLERR(x) if (x == -1) { free(input); input = NULL; return NULL;}
+
+typedef struct SDL_WSCONS_mouse_input_data SDL_WSCONS_mouse_input_data;
+extern SDL_WSCONS_mouse_input_data* SDL_WSCONS_Init_Mouse();
+extern void updateMouse(SDL_WSCONS_mouse_input_data* input);
+extern void SDL_WSCONS_Quit_Mouse(SDL_WSCONS_mouse_input_data* input);
+
+/* Conversion table courtesy of /usr/src/sys/dev/wscons/wskbdutil.c */
+static const unsigned char latin1_to_upper[256] = {
+    /*      0  8  1  9  2  a  3  b  4  c  5  d  6  e  7  f               */
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* 0 */
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* 0 */
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* 1 */
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* 1 */
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* 2 */
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* 2 */
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* 3 */
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* 3 */
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* 4 */
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* 4 */
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* 5 */
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* 5 */
+    0x00,  'A',  'B',  'C',  'D',  'E',  'F',  'G',     /* 6 */
+    'H',  'I',  'J',  'K',  'L',  'M',  'N',  'O',     /* 6 */
+    'P',  'Q',  'R',  'S',  'T',  'U',  'V',  'W',     /* 7 */
+    'X',  'Y',  'Z', 0x00, 0x00, 0x00, 0x00, 0x00,     /* 7 */
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* 8 */
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* 8 */
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* 9 */
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* 9 */
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* a */
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* a */
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* b */
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* b */
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* c */
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* c */
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* d */
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* d */
+    0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,     /* e */
+    0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,     /* e */
+    0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0x00,     /* f */
+    0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0x00,     /* f */
+};
+
+/* Compose table courtesy of /usr/src/sys/dev/wscons/wskbdutil.c */
+static struct SDL_wscons_compose_tab_s {
+    keysym_t elem[2];
+    keysym_t result;
+} compose_tab[] = {
+    { { KS_plus,			KS_plus },		KS_numbersign },
+    { { KS_a,			KS_a },			KS_at },
+    { { KS_parenleft,		KS_parenleft },		KS_bracketleft },
+    { { KS_slash,			KS_slash },		KS_backslash },
+    { { KS_parenright,		KS_parenright },	KS_bracketright },
+    { { KS_parenleft,		KS_minus },		KS_braceleft },
+    { { KS_slash,			KS_minus },		KS_bar },
+    { { KS_parenright,		KS_minus },		KS_braceright },
+    { { KS_exclam,			KS_exclam },		KS_exclamdown },
+    { { KS_c,			KS_slash },		KS_cent },
+    { { KS_l,			KS_minus },		KS_sterling },
+    { { KS_y,			KS_minus },		KS_yen },
+    { { KS_s,			KS_o },			KS_section },
+    { { KS_x,			KS_o },			KS_currency },
+    { { KS_c,			KS_o },			KS_copyright },
+    { { KS_less,			KS_less },		KS_guillemotleft },
+    { { KS_greater,			KS_greater },		KS_guillemotright },
+    { { KS_question,		KS_question },		KS_questiondown },
+    { { KS_dead_acute,		KS_space },		KS_apostrophe },
+    { { KS_dead_grave,		KS_space },		KS_grave },
+    { { KS_dead_tilde,		KS_space },		KS_asciitilde },
+    { { KS_dead_circumflex,		KS_space },		KS_asciicircum },
+    { { KS_dead_diaeresis,		KS_space },		KS_quotedbl },
+    { { KS_dead_cedilla,		KS_space },		KS_comma },
+    { { KS_dead_circumflex,		KS_A },			KS_Acircumflex },
+    { { KS_dead_diaeresis,		KS_A },			KS_Adiaeresis },
+    { { KS_dead_grave,		KS_A },			KS_Agrave },
+    { { KS_dead_abovering,		KS_A },			KS_Aring },
+    { { KS_dead_tilde,		KS_A },			KS_Atilde },
+    { { KS_dead_cedilla,		KS_C },			KS_Ccedilla },
+    { { KS_dead_acute,		KS_E },			KS_Eacute },
+    { { KS_dead_circumflex,		KS_E },			KS_Ecircumflex },
+    { { KS_dead_diaeresis,		KS_E },			KS_Ediaeresis },
+    { { KS_dead_grave,		KS_E },			KS_Egrave },
+    { { KS_dead_acute,		KS_I },			KS_Iacute },
+    { { KS_dead_circumflex,		KS_I },			KS_Icircumflex },
+    { { KS_dead_diaeresis,		KS_I },			KS_Idiaeresis },
+    { { KS_dead_grave,		KS_I },			KS_Igrave },
+    { { KS_dead_tilde,		KS_N },			KS_Ntilde },
+    { { KS_dead_acute,		KS_O },			KS_Oacute },
+    { { KS_dead_circumflex,		KS_O },			KS_Ocircumflex },
+    { { KS_dead_diaeresis,		KS_O },			KS_Odiaeresis },
+    { { KS_dead_grave,		KS_O },			KS_Ograve },
+    { { KS_dead_tilde,		KS_O },			KS_Otilde },
+    { { KS_dead_acute,		KS_U },			KS_Uacute },
+    { { KS_dead_circumflex,		KS_U },			KS_Ucircumflex },
+    { { KS_dead_diaeresis,		KS_U },			KS_Udiaeresis },
+    { { KS_dead_grave,		KS_U },			KS_Ugrave },
+    { { KS_dead_acute,		KS_Y },			KS_Yacute },
+    { { KS_dead_acute,		KS_a },			KS_aacute },
+    { { KS_dead_circumflex,		KS_a },			KS_acircumflex },
+    { { KS_dead_diaeresis,		KS_a },			KS_adiaeresis },
+    { { KS_dead_grave,		KS_a },			KS_agrave },
+    { { KS_dead_abovering,		KS_a },			KS_aring },
+    { { KS_dead_tilde,		KS_a },			KS_atilde },
+    { { KS_dead_cedilla,		KS_c },			KS_ccedilla },
+    { { KS_dead_acute,		KS_e },			KS_eacute },
+    { { KS_dead_circumflex,		KS_e },			KS_ecircumflex },
+    { { KS_dead_diaeresis,		KS_e },			KS_ediaeresis },
+    { { KS_dead_grave,		KS_e },			KS_egrave },
+    { { KS_dead_acute,		KS_i },			KS_iacute },
+    { { KS_dead_circumflex,		KS_i },			KS_icircumflex },
+    { { KS_dead_diaeresis,		KS_i },			KS_idiaeresis },
+    { { KS_dead_grave,		KS_i },			KS_igrave },
+    { { KS_dead_tilde,		KS_n },			KS_ntilde },
+    { { KS_dead_acute,		KS_o },			KS_oacute },
+    { { KS_dead_circumflex,		KS_o },			KS_ocircumflex },
+    { { KS_dead_diaeresis,		KS_o },			KS_odiaeresis },
+    { { KS_dead_grave,		KS_o },			KS_ograve },
+    { { KS_dead_tilde,		KS_o },			KS_otilde },
+    { { KS_dead_acute,		KS_u },			KS_uacute },
+    { { KS_dead_circumflex,		KS_u },			KS_ucircumflex },
+    { { KS_dead_diaeresis,		KS_u },			KS_udiaeresis },
+    { { KS_dead_grave,		KS_u },			KS_ugrave },
+    { { KS_dead_acute,		KS_y },			KS_yacute },
+    { { KS_dead_diaeresis,		KS_y },			KS_ydiaeresis },
+    { { KS_quotedbl,		KS_A },			KS_Adiaeresis },
+    { { KS_quotedbl,		KS_E },			KS_Ediaeresis },
+    { { KS_quotedbl,		KS_I },			KS_Idiaeresis },
+    { { KS_quotedbl,		KS_O },			KS_Odiaeresis },
+    { { KS_quotedbl,		KS_U },			KS_Udiaeresis },
+    { { KS_quotedbl,		KS_a },			KS_adiaeresis },
+    { { KS_quotedbl,		KS_e },			KS_ediaeresis },
+    { { KS_quotedbl,		KS_i },			KS_idiaeresis },
+    { { KS_quotedbl,		KS_o },			KS_odiaeresis },
+    { { KS_quotedbl,		KS_u },			KS_udiaeresis },
+    { { KS_quotedbl,		KS_y },			KS_ydiaeresis },
+    { { KS_acute,			KS_A },			KS_Aacute },
+    { { KS_asciicircum,		KS_A },			KS_Acircumflex },
+    { { KS_grave,			KS_A },			KS_Agrave },
+    { { KS_asterisk,		KS_A },			KS_Aring },
+    { { KS_asciitilde,		KS_A },			KS_Atilde },
+    { { KS_cedilla,			KS_C },			KS_Ccedilla },
+    { { KS_acute,			KS_E },			KS_Eacute },
+    { { KS_asciicircum,		KS_E },			KS_Ecircumflex },
+    { { KS_grave,			KS_E },			KS_Egrave },
+    { { KS_acute,			KS_I },			KS_Iacute },
+    { { KS_asciicircum,		KS_I },			KS_Icircumflex },
+    { { KS_grave,			KS_I },			KS_Igrave },
+    { { KS_asciitilde,		KS_N },			KS_Ntilde },
+    { { KS_acute,			KS_O },			KS_Oacute },
+    { { KS_asciicircum,		KS_O },			KS_Ocircumflex },
+    { { KS_grave,			KS_O },			KS_Ograve },
+    { { KS_asciitilde,		KS_O },			KS_Otilde },
+    { { KS_acute,			KS_U },			KS_Uacute },
+    { { KS_asciicircum,		KS_U },			KS_Ucircumflex },
+    { { KS_grave,			KS_U },			KS_Ugrave },
+    { { KS_acute,			KS_Y },			KS_Yacute },
+    { { KS_acute,			KS_a },			KS_aacute },
+    { { KS_asciicircum,		KS_a },			KS_acircumflex },
+    { { KS_grave,			KS_a },			KS_agrave },
+    { { KS_asterisk,		KS_a },			KS_aring },
+    { { KS_asciitilde,		KS_a },			KS_atilde },
+    { { KS_cedilla,			KS_c },			KS_ccedilla },
+    { { KS_acute,			KS_e },			KS_eacute },
+    { { KS_asciicircum,		KS_e },			KS_ecircumflex },
+    { { KS_grave,			KS_e },			KS_egrave },
+    { { KS_acute,			KS_i },			KS_iacute },
+    { { KS_asciicircum,		KS_i },			KS_icircumflex },
+    { { KS_grave,			KS_i },			KS_igrave },
+    { { KS_asciitilde,		KS_n },			KS_ntilde },
+    { { KS_acute,			KS_o },			KS_oacute },
+    { { KS_asciicircum,		KS_o },			KS_ocircumflex },
+    { { KS_grave,			KS_o },			KS_ograve },
+    { { KS_asciitilde,		KS_o },			KS_otilde },
+    { { KS_acute,			KS_u },			KS_uacute },
+    { { KS_asciicircum,		KS_u },			KS_ucircumflex },
+    { { KS_grave,			KS_u },			KS_ugrave },
+    { { KS_acute,			KS_y },			KS_yacute },
+#ifndef __NetBSD__
+    { { KS_dead_caron,		KS_space },		KS_L2_caron },
+    { { KS_dead_caron,		KS_S },			KS_L2_Scaron },
+    { { KS_dead_caron,		KS_Z },			KS_L2_Zcaron },
+    { { KS_dead_caron,		KS_s },			KS_L2_scaron },
+    { { KS_dead_caron,		KS_z },			KS_L2_zcaron }
+#endif
+};
+
+static keysym_t ksym_upcase(keysym_t ksym)
+{
+    if (ksym >= KS_f1 && ksym <= KS_f20)
+        return(KS_F1 - KS_f1 + ksym);
+
+    if (KS_GROUP(ksym) == KS_GROUP_Ascii && ksym <= 0xff &&
+            latin1_to_upper[ksym] != 0x00)
+        return(latin1_to_upper[ksym]);
+
+    return(ksym);
+}
+static struct wscons_keycode_to_SDL {
+    keysym_t sourcekey;
+    SDL_Scancode targetKey;
+} conversion_table[] = {
+    {KS_Menu, SDL_SCANCODE_APPLICATION},
+    {KS_Up, SDL_SCANCODE_UP},
+    {KS_Down, SDL_SCANCODE_DOWN},
+    {KS_Left, SDL_SCANCODE_LEFT},
+    {KS_Right, SDL_SCANCODE_RIGHT},
+    {KS_Hold_Screen, SDL_SCANCODE_SCROLLLOCK},
+    {KS_Num_Lock, SDL_SCANCODE_NUMLOCKCLEAR},
+    {KS_Caps_Lock, SDL_SCANCODE_CAPSLOCK},
+    {KS_BackSpace, SDL_SCANCODE_BACKSPACE},
+    {KS_space, SDL_SCANCODE_SPACE},
+    {KS_Delete, SDL_SCANCODE_BACKSPACE},
+    {KS_Home, SDL_SCANCODE_HOME},
+    {KS_End, SDL_SCANCODE_END},
+    {KS_Pause, SDL_SCANCODE_PAUSE},
+    {KS_Print_Screen, SDL_SCANCODE_PRINTSCREEN},
+    {KS_Insert, SDL_SCANCODE_INSERT},
+    {KS_Escape, SDL_SCANCODE_ESCAPE},
+    {KS_Return, SDL_SCANCODE_RETURN},
+    {KS_Linefeed, SDL_SCANCODE_RETURN},
+    {KS_KP_Delete, SDL_SCANCODE_DELETE},
+    {KS_KP_Insert, SDL_SCANCODE_INSERT},
+    {KS_Control_L, SDL_SCANCODE_LCTRL},
+    {KS_Control_R, SDL_SCANCODE_RCTRL},
+    {KS_Shift_L, SDL_SCANCODE_LSHIFT},
+    {KS_Shift_R, SDL_SCANCODE_RSHIFT},
+    {KS_Alt_L, SDL_SCANCODE_LALT},
+    {KS_Alt_R, SDL_SCANCODE_RALT},
+    {KS_grave, SDL_SCANCODE_GRAVE},
+
+    {KS_KP_0, SDL_SCANCODE_KP_0},
+    {KS_KP_1, SDL_SCANCODE_KP_1},
+    {KS_KP_2, SDL_SCANCODE_KP_2},
+    {KS_KP_3, SDL_SCANCODE_KP_3},
+    {KS_KP_4, SDL_SCANCODE_KP_4},
+    {KS_KP_5, SDL_SCANCODE_KP_5},
+    {KS_KP_6, SDL_SCANCODE_KP_6},
+    {KS_KP_7, SDL_SCANCODE_KP_7},
+    {KS_KP_8, SDL_SCANCODE_KP_8},
+    {KS_KP_9, SDL_SCANCODE_KP_9},
+    {KS_KP_Enter, SDL_SCANCODE_KP_ENTER},
+    {KS_KP_Multiply, SDL_SCANCODE_KP_MULTIPLY},
+    {KS_KP_Add, SDL_SCANCODE_KP_PLUS},
+    {KS_KP_Subtract, SDL_SCANCODE_KP_MINUS},
+    {KS_KP_Divide, SDL_SCANCODE_KP_DIVIDE},
+    {KS_KP_Up, SDL_SCANCODE_UP},
+    {KS_KP_Down, SDL_SCANCODE_DOWN},
+    {KS_KP_Left, SDL_SCANCODE_LEFT},
+    {KS_KP_Right, SDL_SCANCODE_RIGHT},
+    {KS_KP_Equal, SDL_SCANCODE_KP_EQUALS},
+    {KS_f1, SDL_SCANCODE_F1},
+    {KS_f2, SDL_SCANCODE_F2},
+    {KS_f3, SDL_SCANCODE_F3},
+    {KS_f4, SDL_SCANCODE_F4},
+    {KS_f5, SDL_SCANCODE_F5},
+    {KS_f6, SDL_SCANCODE_F6},
+    {KS_f7, SDL_SCANCODE_F7},
+    {KS_f8, SDL_SCANCODE_F8},
+    {KS_f9, SDL_SCANCODE_F9},
+    {KS_f10, SDL_SCANCODE_F10},
+    {KS_f11, SDL_SCANCODE_F11},
+    {KS_f12, SDL_SCANCODE_F12},
+    {KS_f13, SDL_SCANCODE_F13},
+    {KS_f14, SDL_SCANCODE_F14},
+    {KS_f15, SDL_SCANCODE_F15},
+    {KS_f16, SDL_SCANCODE_F16},
+    {KS_f17, SDL_SCANCODE_F17},
+    {KS_f18, SDL_SCANCODE_F18},
+    {KS_f19, SDL_SCANCODE_F19},
+    {KS_f20, SDL_SCANCODE_F20},
+#if !defined(__NetBSD__)
+    {KS_f21, SDL_SCANCODE_F21},
+    {KS_f22, SDL_SCANCODE_F22},
+    {KS_f23, SDL_SCANCODE_F23},
+    {KS_f24, SDL_SCANCODE_F24},
+#endif
+    {KS_Meta_L, SDL_SCANCODE_LGUI},
+    {KS_Meta_R, SDL_SCANCODE_RGUI},
+    {KS_Zenkaku_Hankaku, SDL_SCANCODE_LANG5},
+    {KS_Hiragana_Katakana, SDL_SCANCODE_INTERNATIONAL2},
+    {KS_yen, SDL_SCANCODE_INTERNATIONAL3},
+    {KS_Henkan, SDL_SCANCODE_INTERNATIONAL4},
+    {KS_Muhenkan, SDL_SCANCODE_INTERNATIONAL5},
+    {KS_KP_Prior, SDL_SCANCODE_PRIOR},
+
+    {KS_a, SDL_SCANCODE_A},
+    {KS_b, SDL_SCANCODE_B},
+    {KS_c, SDL_SCANCODE_C},
+    {KS_d, SDL_SCANCODE_D},
+    {KS_e, SDL_SCANCODE_E},
+    {KS_f, SDL_SCANCODE_F},
+    {KS_g, SDL_SCANCODE_G},
+    {KS_h, SDL_SCANCODE_H},
+    {KS_i, SDL_SCANCODE_I},
+    {KS_j, SDL_SCANCODE_J},
+    {KS_k, SDL_SCANCODE_K},
+    {KS_l, SDL_SCANCODE_L},
+    {KS_m, SDL_SCANCODE_M},
+    {KS_n, SDL_SCANCODE_N},
+    {KS_o, SDL_SCANCODE_O},
+    {KS_p, SDL_SCANCODE_P},
+    {KS_q, SDL_SCANCODE_Q},
+    {KS_r, SDL_SCANCODE_R},
+    {KS_s, SDL_SCANCODE_S},
+    {KS_t, SDL_SCANCODE_T},
+    {KS_u, SDL_SCANCODE_U},
+    {KS_v, SDL_SCANCODE_V},
+    {KS_w, SDL_SCANCODE_W},
+    {KS_x, SDL_SCANCODE_X},
+    {KS_y, SDL_SCANCODE_Y},
+    {KS_z, SDL_SCANCODE_Z},
+
+    {KS_0, SDL_SCANCODE_0},
+    {KS_1, SDL_SCANCODE_1},
+    {KS_2, SDL_SCANCODE_2},
+    {KS_3, SDL_SCANCODE_3},
+    {KS_4, SDL_SCANCODE_4},
+    {KS_5, SDL_SCANCODE_5},
+    {KS_6, SDL_SCANCODE_6},
+    {KS_7, SDL_SCANCODE_7},
+    {KS_8, SDL_SCANCODE_8},
+    {KS_9, SDL_SCANCODE_9},
+    {KS_minus, SDL_SCANCODE_MINUS},
+    {KS_equal, SDL_SCANCODE_EQUALS},
+    {KS_Tab, SDL_SCANCODE_TAB},
+    {KS_KP_Tab, SDL_SCANCODE_KP_TAB},
+    {KS_apostrophe, SDL_SCANCODE_APOSTROPHE},
+    {KS_bracketleft, SDL_SCANCODE_LEFTBRACKET},
+    {KS_bracketright, SDL_SCANCODE_RIGHTBRACKET},
+    {KS_semicolon, SDL_SCANCODE_SEMICOLON},
+    {KS_comma, SDL_SCANCODE_COMMA},
+    {KS_period, SDL_SCANCODE_PERIOD},
+    {KS_slash, SDL_SCANCODE_SLASH},
+    {KS_backslash, SDL_SCANCODE_BACKSLASH}
+};
+
+typedef struct {
+    int fd;
+    struct wskbd_map_data keymap;
+    int ledstate;
+    int origledstate;
+    int shiftstate[4];
+    int shiftheldstate[8];
+    int lockheldstate[5];
+    kbd_t encoding;
+    char text[128];
+    unsigned int text_len;
+    keysym_t composebuffer[2];
+    unsigned char composelen;
+    int type;
+} SDL_WSCONS_input_data;
+
+static SDL_WSCONS_input_data* inputs[4] = {NULL, NULL, NULL, NULL};
+static SDL_WSCONS_mouse_input_data* mouseInputData = NULL;
+#define IS_CONTROL_HELD  (input->shiftstate[2] > 0)
+#define IS_ALT_HELD      (input->shiftstate[1] > 0)
+#define IS_SHIFT_HELD    ((input->shiftstate[0] > 0) || (input->ledstate & (1 << 5)))
+
+#define IS_ALTGR_MODE    ((input->ledstate & (1 << 4)) || (input->shiftstate[3] > 0))
+#define IS_NUMLOCK_ON    (input->ledstate & LED_NUM)
+#define IS_SCROLLLOCK_ON (input->ledstate & LED_SCR)
+#define IS_CAPSLOCK_ON   (input->ledstate & LED_CAP)
+static SDL_WSCONS_input_data* SDL_WSCONS_Init_Keyboard(const char* dev)
+{
+#ifdef WSKBDIO_SETVERSION
+    int version = WSKBDIO_EVENT_VERSION;
+#endif
+    SDL_WSCONS_input_data* input = (SDL_WSCONS_input_data*)SDL_calloc(1, sizeof(SDL_WSCONS_input_data));
+
+    if (!input) {
+        return input;
+    }
+    input->fd = open(dev,O_RDWR | O_NONBLOCK | O_CLOEXEC);
+    if (input->fd == -1) {
+        free(input);
+        input = NULL;
+        return NULL;
+    }
+    input->keymap.map = SDL_calloc(sizeof(struct wscons_keymap), KS_NUMKEYCODES);
+    if (input->keymap.map == NULL) {
+        free(input);
+        return NULL;
+    }
+    input->keymap.maplen = KS_NUMKEYCODES;
+    RETIFIOCTLERR(ioctl(input->fd, WSKBDIO_GETMAP, &input->keymap));
+    RETIFIOCTLERR(ioctl(input->fd, WSKBDIO_GETLEDS, &input->ledstate));
+    input->origledstate = input->ledstate;
+    RETIFIOCTLERR(ioctl(input->fd, WSKBDIO_GETENCODING, &input->encoding));
+    RETIFIOCTLERR(ioctl(input->fd, WSKBDIO_GTYPE, &input->type));
+#ifdef WSKBDIO_SETVERSION
+    RETIFIOCTLERR(ioctl(input->fd, WSKBDIO_SETVERSION, &version));
+#endif
+    return input;
+}
+
+void SDL_WSCONS_Init()
+{
+    inputs[0] = SDL_WSCONS_Init_Keyboard("/dev/wskbd0");
+    inputs[1] = SDL_WSCONS_Init_Keyboard("/dev/wskbd1");
+    inputs[2] = SDL_WSCONS_Init_Keyboard("/dev/wskbd2");
+    inputs[3] = SDL_WSCONS_Init_Keyboard("/dev/wskbd3");
+
+    mouseInputData = SDL_WSCONS_Init_Mouse();
+    return;
+}
+
+void SDL_WSCONS_Quit()
+{
+    int i = 0;
+    SDL_WSCONS_input_data* input = NULL;
+
+    SDL_WSCONS_Quit_Mouse(mouseInputData);
+    mouseInputData = NULL;
+    for (i = 0; i < 4; i++) {
+        input = inputs[i];
+        if (input) {
+            if (input->fd != -1 && input->fd != 0) {
+                ioctl(input->fd,WSKBDIO_SETLEDS, &input->origledstate);
+                close(input->fd);
+                input->fd = -1;
+            }
+            free(input);
+            input = NULL;
+        }
+        inputs[i] = NULL;
+    }
+}
+
+static void put_queue(SDL_WSCONS_input_data *kbd, uint c)
+{
+    /* c is already part of a UTF-8 sequence and safe to add as a character */
+    if (kbd->text_len < (sizeof(kbd->text)-1)) {
+        kbd->text[kbd->text_len++] = (char)(c);
+    }
+}
+
+static void put_utf8(SDL_WSCONS_input_data* input, uint c)
+{
+    if (c < 0x80)
+        /*  0******* */
+        put_queue(input, c);
+    else if (c < 0x800) {
+        /* 110***** 10****** */
+        put_queue(input, 0xc0 | (c >> 6));
+        put_queue(input, 0x80 | (c & 0x3f));
+    } else if (c < 0x10000) {
+        if (c >= 0xD800 && c <= 0xF500)
+            return;
+        if (c == 0xFFFF)
+            return;
+        /* 1110**** 10****** 10****** */
+        put_queue(input, 0xe0 | (c >> 12));
+        put_queue(input, 0x80 | ((c >> 6) & 0x3f));
+        put_queue(input, 0x80 | (c & 0x3f));
+    } else if (c < 0x110000) {
+        /* 11110*** 10****** 10****** 10****** */
+        put_queue(input, 0xf0 | (c >> 18));
+        put_queue(input, 0x80 | ((c >> 12) & 0x3f));
+        put_queue(input, 0x80 | ((c >> 6) & 0x3f));
+        put_queue(input, 0x80 | (c & 0x3f));
+    }
+}
+
+static void Translate_to_text(SDL_WSCONS_input_data* input, keysym_t ksym)
+{
+    if (KS_GROUP(ksym) == KS_GROUP_Keypad) {
+        if (SDL_isprint(ksym & 0xFF)) ksym &= 0xFF;
+    }
+    switch(ksym) {
+    case KS_Escape:
+    case KS_Delete:
+    case KS_BackSpace:
+    case KS_Return:
+    case KS_Linefeed:
+        /* All of these are unprintable characters. Ignore them */
+        break;
+    default:
+        put_utf8(input, ksym);
+        break;
+    }
+    if (input->text_len > 0) {
+        input->text[input->text_len] = '\0';
+        SDL_SendKeyboardText(input->text);
+        /*SDL_memset(input->text, 0, sizeof(input->text));*/
+        input->text_len = 0;
+        input->text[0] = 0;
+    }
+}
+
+static void Translate_to_keycode(SDL_WSCONS_input_data* input, int type, keysym_t ksym)
+{
+    struct wscons_keymap keyDesc = input->keymap.map[ksym];
+    keysym_t* group = &keyDesc.group1[KS_GROUP(keyDesc.group1[0]) == KS_GROUP_Keypad && IS_NUMLOCK_ON ? !IS_SHIFT_HELD : 0];
+    int i = 0;
+
+    /* Check command first, then group[0]*/
+    switch (keyDesc.command) {
+    case KS_Cmd_ScrollBack: {
+        SDL_SendKeyboardKey(type == WSCONS_EVENT_KEY_DOWN ? SDL_PRESSED : SDL_RELEASED, SDL_SCANCODE_PAGEUP);
+        return;
+    }
+    case KS_Cmd_ScrollFwd: {
+        SDL_SendKeyboardKey(type == WSCONS_EVENT_KEY_DOWN ? SDL_PRESSED : SDL_RELEASED, SDL_SCANCODE_PAGEDOWN);
+        return;
+    }
+    }
+    for (i = 0; i < sizeof(conversion_table) / sizeof(struct wscons_keycode_to_SDL); i++) {
+        if (conversion_table[i].sourcekey == group[0]) {
+            SDL_SendKeyboardKey(type == WSCONS_EVENT_KEY_DOWN ? SDL_PRESSED : SDL_RELEASED, conversion_table[i].targetKey);
+            return;
+        }
+    }
+    SDL_SendKeyboardKey(type == WSCONS_EVENT_KEY_DOWN ? SDL_PRESSED : SDL_RELEASED, SDL_SCANCODE_UNKNOWN);
+
+}
+
+static void updateKeyboard(SDL_WSCONS_input_data* input)
+{
+    struct wscons_event events[64];
+    int type;
+    int n,i,gindex,acc_i;
+    keysym_t *group;
+    keysym_t ksym, result;
+
+    if (!input) return;
+    if ((n = read(input->fd, events, sizeof(events))) > 0) {
+        n /= sizeof(struct wscons_event);
+        for (i = 0; i < n; i++) {
+            type = events[i].type;
+            switch(type) {
+            case WSCONS_EVENT_KEY_DOWN: {
+                switch (input->keymap.map[events[i].value].group1[0]) {
+                case KS_Hold_Screen: {
+                    if (input->lockheldstate[0] >= 1) break;
+                    input->ledstate ^= LED_SCR;
+                    ioctl(input->fd, WSKBDIO_SETLEDS, &input->ledstate);
+                    input->lockheldstate[0] = 1;
+                    break;
+                }
+                case KS_Num_Lock: {
+                    if (input->lockheldstate[1] >= 1) break;
+                    input->ledstate ^= LED_NUM;
+                    ioctl(input->fd, WSKBDIO_SETLEDS, &input->ledstate);
+                    input->lockheldstate[1] = 1;
+                    break;
+                }
+                case KS_Caps_Lock: {
+                    if (input->lockheldstate[2] >= 1) break;
+                    input->ledstate ^= LED_CAP;
+                    ioctl(input->fd, WSKBDIO_SETLEDS, &input->ledstate);
+                    input->lockheldstate[2] = 1;
+                    break;
+                }
+#ifndef __NetBSD__
+                case KS_Mode_Lock: {
+                    if (input->lockheldstate[3] >= 1) break;
+                    input->ledstate ^= 1 << 4;
+                    ioctl(input->fd, WSKBDIO_SETLEDS, &input->ledstate);
+                    input->lockheldstate[3] = 1;
+                    break;
+                }
+#endif
+                case KS_Shift_Lock: {
+                    if (input->lockheldstate[4] >= 1) break;
+                    input->ledstate ^= 1 << 5;
+                    ioctl(input->fd, WSKBDIO_SETLEDS, &input->ledstate);
+                    input->lockheldstate[4] = 1;
+                    break;
+                }
+                case KS_Shift_L: {
+                    if (input->shiftheldstate[0]) break;
+                    input->shiftstate[0]++;
+                    input->shiftheldstate[0] = 1;
+                    break;
+                }
+                case KS_Shift_R: {
+                    if (input->shiftheldstate[1]) break;
+                    input->shiftstate[0]++;
+                    input->shiftheldstate[1] = 1;
+                    break;
+                }
+                case KS_Alt_L: {
+                    if (input->shiftheldstate[2]) break;
+                    input->shiftstate[1]++;
+                    input->shiftheldstate[2] = 1;
+                    break;
+                }
+                case KS_Alt_R: {
+                    if (input->shiftheldstate[3]) break;
+                    input->shiftstate[1]++;
+                    input->shiftheldstate[3] = 1;
+                    break;
+                }
+                case KS_Control_L: {
+                    if (input->shiftheldstate[4]) break;
+                    input->shiftstate[2]++;
+                    input->shiftheldstate[4] = 1;
+                    break;
+                }
+                case KS_Control_R: {
+                    if (input->shiftheldstate[5]) break;
+                    input->shiftstate[2]++;
+                    input->shiftheldstate[5] = 1;
+                    break;
+                }
+                case KS_Mode_switch: {
+                    if (input->shiftheldstate[6]) break;
+                    input->shiftstate[3]++;
+                    input->shiftheldstate[6] = 1;
+                    break;
+                }
+                }
+            }
+            break;
+            case WSCONS_EVENT_KEY_UP: {
+                switch(input->keymap.map[events[i].value].group1[0]) {
+                case KS_Hold_Screen: {
+                    if (input->lockheldstate[0]) input->lockheldstate[0] = 0;
+                }
+                break;
+                case KS_Num_Lock: {
+                    if (input->lockheldstate[1]) input->lockheldstate[1] = 0;
+                }
+                break;
+                case KS_Caps_Lock: {
+                    if (input->lockheldstate[2]) input->lockheldstate[2] = 0;
+                }
+                break;
+#ifndef __NetBSD__
+                case KS_Mode_Lock: {
+                    if (input->lockheldstate[3]) input->lockheldstate[3] = 0;
+                }
+                break;
+#endif
+                case KS_Shift_Lock: {
+                    if (input->lockheldstate[4]) input->lockheldstate[4] = 0;
+                }
+                break;
+                case KS_Shift_L: {
+                    input->shiftheldstate[0] = 0;
+                    if (input->shiftstate[0]) input->shiftstate[0]--;
+                    break;
+                }
+                case KS_Shift_R: {
+                    input->shiftheldstate[1] = 0;
+                    if (input->shiftstate[0]) input->shiftstate[0]--;
+                    break;
+                }
+                case KS_Alt_L: {
+                    input->shiftheldstate[2] = 0;
+                    if (input->shiftstate[1]) input->shiftstate[1]--;
+                    break;
+                }
+                case KS_Alt_R: {
+                    input->shiftheldstate[3] = 0;
+                    if (input->shiftstate[1]) input->shiftstate[1]--;
+                    break;
+                }
+                case KS_Control_L: {
+                    input->shiftheldstate[4] = 0;
+                    if (input->shiftstate[2]) input->shiftstate[2]--;
+                    break;
+                }
+                case KS_Control_R: {
+                    input->shiftheldstate[5] = 0;
+                    if (input->shiftstate[2]) input->shiftstate[2]--;
+                    break;
+                }
+                case KS_Mode_switch: {
+                    input->shiftheldstate[6] = 0;
+                    if (input->shiftstate[3]) input->shiftstate[3]--;
+                    break;
+                }
+                }
+            }
+            break;
+            case WSCONS_EVENT_ALL_KEYS_UP:
+                for (i = 0; i < SDL_NUM_SCANCODES; i++) {
+                    SDL_SendKeyboardKey(SDL_RELEASED, i);
+                }
+                break;
+            }
+
+            if (input->type == WSKBD_TYPE_USB && events[i].value <= 0xE7)
+                SDL_SendKeyboardKey(type == WSCONS_EVENT_KEY_DOWN ? SDL_PRESSED : SDL_RELEASED, (SDL_Scancode)events[i].value);
+            else 
+                Translate_to_keycode(input, type, events[i].value);
+
+            if (type == WSCONS_EVENT_KEY_UP) continue;
+
+            if (IS_ALTGR_MODE && !IS_CONTROL_HELD)
+                group = &input->keymap.map[events[i].value].group2[0];
+            else
+                group = &input->keymap.map[events[i].value].group1[0];
+
+            if (IS_NUMLOCK_ON && KS_GROUP(group[1]) == KS_GROUP_Keypad) {
+                gindex = !IS_SHIFT_HELD;
+                ksym = group[gindex];
+            } else {
+                if (IS_CAPSLOCK_ON && !IS_SHIFT_HELD) {
+                    gindex = 0;
+                    ksym = ksym_upcase(group[0]);
+                } else {
+                    gindex = IS_SHIFT_HELD;
+                    ksym = group[gindex];
+                }
+            }
+            result = KS_voidSymbol;
+
+            switch (KS_GROUP(ksym)) {
+            case KS_GROUP_Ascii:
+            case KS_GROUP_Keypad:
+            case KS_GROUP_Function:
+                result = ksym;
+                break;
+            case KS_GROUP_Mod:
+                if (ksym == KS_Multi_key) {
+                    input->ledstate |= WSKBD_LED_COMPOSE;
+                    ioctl(input->fd,WSKBDIO_SETLEDS, &input->ledstate);
+                    input->composelen = 2;
+                    input->composebuffer[0] = input->composebuffer[1] = 0;
+                }
+                break;
+            case KS_GROUP_Dead:
+                if (input->composelen == 0) {
+                    input->ledstate |= WSKBD_LED_COMPOSE;
+                    ioctl(input->fd,WSKBDIO_SETLEDS, &input->ledstate);
+                    input->composelen = 1;
+                    input->composebuffer[0] = ksym;
+                    input->composebuffer[1] = 0;
+                } else result = ksym;
+                break;
+            }
+            if (result == KS_voidSymbol) continue;
+
+            if (input->composelen > 0) {
+                if (input->composelen == 2 && group == &input->keymap.map[events[i].value].group2[0]) {
+                    if (input->keymap.map[events[i].value].group2[gindex] == input->keymap.map[events[i].value].group1[gindex]) {
+                        input->composelen = 0;
+                        input->composebuffer[0] = input->composebuffer[1] = 0;
+                    }
+                }
+
+                if (input->composelen != 0) {
+                    input->composebuffer[2 - input->composelen] = result;
+                    if (--input->composelen == 0) {
+                        result = KS_voidSymbol;
+                        input->ledstate &= ~WSKBD_LED_COMPOSE;
+                        ioctl(input->fd,WSKBDIO_SETLEDS, &input->ledstate);
+                        for (acc_i = 0; acc_i < SDL_arraysize(compose_tab); acc_i++) {
+                            if ((compose_tab[acc_i].elem[0] == input->composebuffer[0]
+                                    && compose_tab[acc_i].elem[1] == input->composebuffer[1])
+                                    || (compose_tab[acc_i].elem[0] == input->composebuffer[1]
+                                        && compose_tab[acc_i].elem[1] == input->composebuffer[0])) {
+                                result = compose_tab[acc_i].result;
+                                break;
+                            }
+                        }
+                    } else continue;
+                }
+            }
+
+            if (KS_GROUP(result) == KS_GROUP_Ascii) {
+                if (IS_CONTROL_HELD) {
+                    if ((result >= KS_at && result <= KS_z) || result == KS_space)
+                        result = result & 0x1f;
+                    else if (result == KS_2)
+                        result = 0x00;
+                    else if (result >= KS_3 && result <= KS_7)
+                        result = KS_Escape + (result - KS_3);
+                    else if (result == KS_8)
+                        result = KS_Delete;
+                }
+                if (IS_ALT_HELD) {
+                    if (input->encoding & KB_METAESC) {
+                        Translate_to_keycode(input, WSCONS_EVENT_KEY_DOWN, KS_Escape);
+                        Translate_to_text(input, result);
+                        continue;
+                    } else result |= 0x80;
+                }
+            }
+            Translate_to_text(input,result);
+            continue;
+        }
+    }
+}
+
+void SDL_WSCONS_PumpEvents()
+{
+    int i = 0;
+    for (i = 0; i < 4; i++)
+        updateKeyboard(inputs[i]);
+    if (mouseInputData != NULL) updateMouse(mouseInputData);
+}
diff --git a/Engine/lib/sdl/src/core/openbsd/SDL_wscons_mouse.c b/Engine/lib/sdl/src/core/openbsd/SDL_wscons_mouse.c
new file mode 100644
index 000000000..42c83cec8
--- /dev/null
+++ b/Engine/lib/sdl/src/core/openbsd/SDL_wscons_mouse.c
@@ -0,0 +1,134 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "../../SDL_internal.h"
+#include "SDL_events.h"
+#include <sys/time.h>
+#include <dev/wscons/wsconsio.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <stdlib.h>
+#include <fcntl.h>
+
+#include "../../events/SDL_mouse_c.h"
+
+typedef struct SDL_WSCONS_mouse_input_data
+{
+    int fd;
+} SDL_WSCONS_mouse_input_data;
+
+SDL_WSCONS_mouse_input_data* SDL_WSCONS_Init_Mouse()
+{
+#ifdef WSMOUSEIO_SETVERSION
+    int version = WSMOUSE_EVENT_VERSION;
+#endif
+    SDL_WSCONS_mouse_input_data* mouseInputData = SDL_calloc(1, sizeof(SDL_WSCONS_mouse_input_data));
+
+    if (!mouseInputData) return NULL;
+    mouseInputData->fd = open("/dev/wsmouse",O_RDWR | O_NONBLOCK | O_CLOEXEC);
+    if (mouseInputData->fd == -1) {free(mouseInputData); return NULL; }
+#ifdef WSMOUSEIO_SETMODE
+    ioctl(mouseInputData->fd, WSMOUSEIO_SETMODE, WSMOUSE_COMPAT);
+#endif
+#ifdef WSMOUSEIO_SETVERSION
+    ioctl(mouseInputData->fd, WSMOUSEIO_SETVERSION, &version);
+#endif
+    return mouseInputData;
+}
+
+void updateMouse(SDL_WSCONS_mouse_input_data* inputData)
+{
+    struct wscons_event events[64];
+    int type;
+    int n,i;
+    SDL_Mouse* mouse = SDL_GetMouse();
+
+    if ((n = read(inputData->fd, events, sizeof(events))) > 0)
+    {
+        n /= sizeof(struct wscons_event);
+        for (i = 0; i < n; i++)
+        {
+            type = events[i].type;
+            switch(type)
+            {
+            case WSCONS_EVENT_MOUSE_DOWN:
+                {
+                    switch (events[i].value)
+                    {
+                    case 0: /* Left Mouse Button. */
+                        SDL_SendMouseButton(mouse->focus, mouse->mouseID, SDL_PRESSED, SDL_BUTTON_LEFT);
+                        break;
+                    case 1: /* Middle Mouse Button. */
+                        SDL_SendMouseButton(mouse->focus, mouse->mouseID, SDL_PRESSED, SDL_BUTTON_MIDDLE);
+                        break;
+                    case 2: /* Right Mouse Button. */
+                        SDL_SendMouseButton(mouse->focus, mouse->mouseID, SDL_PRESSED, SDL_BUTTON_RIGHT);
+                        break;
+                    }
+                }
+                break;
+            case WSCONS_EVENT_MOUSE_UP:
+                {
+                    switch (events[i].value)
+                    {
+                    case 0: /* Left Mouse Button. */
+                        SDL_SendMouseButton(mouse->focus, mouse->mouseID, SDL_RELEASED, SDL_BUTTON_LEFT);
+                        break;
+                    case 1: /* Middle Mouse Button. */
+                        SDL_SendMouseButton(mouse->focus, mouse->mouseID, SDL_RELEASED, SDL_BUTTON_MIDDLE);
+                        break;
+                    case 2: /* Right Mouse Button. */
+                        SDL_SendMouseButton(mouse->focus, mouse->mouseID, SDL_RELEASED, SDL_BUTTON_RIGHT);
+                        break;
+                    }
+                }
+                break;
+            case WSCONS_EVENT_MOUSE_DELTA_X:
+                {
+                    SDL_SendMouseMotion(mouse->focus, mouse->mouseID, 1, events[i].value, 0);
+                    break;
+                }
+            case WSCONS_EVENT_MOUSE_DELTA_Y:
+                {
+                    SDL_SendMouseMotion(mouse->focus, mouse->mouseID, 1, 0, -events[i].value);
+                    break;
+                }
+            case WSCONS_EVENT_MOUSE_DELTA_W:
+                {
+                    SDL_SendMouseWheel(mouse->focus, mouse->mouseID, events[i].value, 0, SDL_MOUSEWHEEL_NORMAL);
+                    break;
+                }
+            case WSCONS_EVENT_MOUSE_DELTA_Z:
+                {
+                    SDL_SendMouseWheel(mouse->focus, mouse->mouseID, 0, -events[i].value, SDL_MOUSEWHEEL_NORMAL);
+                    break;
+                }
+            }
+        }
+    }
+}
+
+void SDL_WSCONS_Quit_Mouse(SDL_WSCONS_mouse_input_data* inputData)
+{
+    if (!inputData) return;
+    close(inputData->fd);
+    free(inputData);
+}
diff --git a/Engine/lib/sdl/src/core/os2/SDL_os2.c b/Engine/lib/sdl/src/core/os2/SDL_os2.c
index fe3805bb8..553f88cfd 100644
--- a/Engine/lib/sdl/src/core/os2/SDL_os2.c
+++ b/Engine/lib/sdl/src/core/os2/SDL_os2.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -23,7 +23,7 @@
 
 #if defined(__OS2__)
 
-#include "geniconv/geniconv.h"
+#include "SDL_os2.h"
 
 /* SDL_OS2Quit() will be called from SDL_QuitSubSystem() */
 void SDL_OS2Quit(void)
diff --git a/Engine/lib/sdl/src/core/os2/SDL_os2.h b/Engine/lib/sdl/src/core/os2/SDL_os2.h
index 655d04cdf..84068cc13 100644
--- a/Engine/lib/sdl/src/core/os2/SDL_os2.h
+++ b/Engine/lib/sdl/src/core/os2/SDL_os2.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -23,7 +23,6 @@
 
 #include "SDL_log.h"
 #include "SDL_stdinc.h"
-#include "geniconv/geniconv.h"
 
 #ifdef OS2DEBUG
 #if (OS2DEBUG-0 >= 2)
@@ -39,10 +38,16 @@
 
 #endif /* OS2DEBUG */
 
-
+#if defined(HAVE_ICONV) && defined(HAVE_ICONV_H)
+#define OS2_SysToUTF8(S) SDL_iconv_string("UTF-8", "", (char *)(S), SDL_strlen(S)+1)
+#define OS2_UTF8ToSys(S) SDL_iconv_string("", "UTF-8", (char *)(S), SDL_strlen(S)+1)
+#define libiconv_clean() do {} while(0)
+#else
 /* StrUTF8New() - geniconv/sys2utf8.c */
+#include "geniconv/geniconv.h"
 #define OS2_SysToUTF8(S) StrUTF8New(1,         (S), SDL_strlen((S)) + 1)
 #define OS2_UTF8ToSys(S) StrUTF8New(0, (char *)(S), SDL_strlen((S)) + 1)
+#endif
 
 /* SDL_OS2Quit() will be called from SDL_QuitSubSystem() */
 void SDL_OS2Quit(void);
diff --git a/Engine/lib/sdl/src/core/os2/geniconv/geniconv.c b/Engine/lib/sdl/src/core/os2/geniconv/geniconv.c
index 103f16d50..5976fe79f 100644
--- a/Engine/lib/sdl/src/core/os2/geniconv/geniconv.c
+++ b/Engine/lib/sdl/src/core/os2/geniconv/geniconv.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -25,78 +25,76 @@
   Andrey Vasilkin, 2016.
 */
 
-#define INCL_DOSMODULEMGR   /* Module Manager values */
-#define INCL_DOSERRORS      /* Error values */
+#define INCL_DOSMODULEMGR   /* Module Manager */
+#define INCL_DOSERRORS      /* Error values   */
 #include <os2.h>
 
 #include "geniconv.h"
 
 /*#define DEBUG*/
-
 #ifdef DEBUG
 # include <stdio.h>
-# define debug(s,...) printf(__func__"(): "##s"\n" ,##__VA_ARGS__)
+# define iconv_debug(s,...) printf(__func__"(): "##s"\n" ,##__VA_ARGS__)
 #else
-# define debug(s,...) do {} while (0)
+# define iconv_debug(s,...) do {} while (0)
 #endif
 
 /* Exports from os2iconv.c */
-extern iconv_t _System os2_iconv_open(const char* tocode, const char* fromcode);
-extern size_t _System os2_iconv(iconv_t cd, char* * inbuf,
-                                size_t *inbytesleft, char* * outbuf,
-                                size_t *outbytesleft);
-extern int _System os2_iconv_close(iconv_t cd);
+extern iconv_t _System os2_iconv_open  (const char* tocode, const char* fromcode);
+extern size_t  _System os2_iconv       (iconv_t cd,
+                                        char **inbuf,  size_t *inbytesleft,
+                                        char **outbuf, size_t *outbytesleft);
+extern int     _System os2_iconv_close (iconv_t cd);
 
-/* Functions pointers types */
-typedef iconv_t _System (*FNICONV_OPEN)(const char* tocode, const char* fromcode);
-typedef size_t _System (*FNICONV)(iconv_t cd, char* * inbuf,
-                                  size_t *inbytesleft, char* * outbuf,
-                                  size_t *outbytesleft);
-typedef int _System (*FNICONV_CLOSE)(iconv_t cd);
-
-/* Used DLL module handle */
-static HMODULE         hmIconv = NULLHANDLE;
 /* Functions pointers */
-static FNICONV_OPEN    fn_iconv_open = NULL;
-static FNICONV         fn_iconv = NULL;
-static FNICONV_CLOSE   fn_iconv_close = NULL;
+typedef iconv_t (_System *FNICONV_OPEN)(const char*, const char*);
+typedef size_t  (_System *FNICONV)     (iconv_t, char **, size_t *, char **, size_t *);
+typedef int     (_System *FNICONV_CLOSE)(iconv_t);
+
+static HMODULE         hmIconv = NULLHANDLE;
+static FNICONV_OPEN    fn_iconv_open  = os2_iconv_open;
+static FNICONV         fn_iconv       = os2_iconv;
+static FNICONV_CLOSE   fn_iconv_close = os2_iconv_close;
+
+static int geniconv_init = 0;
 
 
-static BOOL _loadDLL(PSZ pszName, PSZ pszIconvOpen, PSZ pszIconv,
-                     PSZ pszIconvClose)
+static BOOL _loadDLL(const char *dllname,
+                     const char *sym_iconvopen,
+                     const char *sym_iconv,
+                     const char *sym_iconvclose)
 {
-    ULONG ulRC;
-    CHAR  acError[256];
+    ULONG rc;
+    char  error[256];
 
-    ulRC = DosLoadModule(acError, sizeof(acError), pszName, &hmIconv);
-    if (ulRC != NO_ERROR) {
-        debug("DLL not loaded: %s", &acError);
+    rc = DosLoadModule(error, sizeof(error), dllname, &hmIconv);
+    if (rc != NO_ERROR) {
+        iconv_debug("DLL %s not loaded: %s", dllname, error);
         return FALSE;
     }
 
-    do {
-        ulRC = DosQueryProcAddr(hmIconv, 0, pszIconvOpen, (PFN *)&fn_iconv_open);
-        if (ulRC != NO_ERROR) {
-            debug("Error: cannot find entry %s in %s", pszIconvOpen, pszName);
-            break;
-        }
+    rc = DosQueryProcAddr(hmIconv, 0, sym_iconvopen, (PFN *)&fn_iconv_open);
+    if (rc != NO_ERROR) {
+        iconv_debug("Error: cannot find entry %s in %s", sym_iconvopen, dllname);
+        goto fail;
+    }
 
-        ulRC = DosQueryProcAddr(hmIconv, 0, pszIconv, (PFN *)&fn_iconv);
-        if (ulRC != NO_ERROR) {
-            debug("Error: cannot find entry %s in %s", pszIconv, pszName);
-            break;
-        }
+    rc = DosQueryProcAddr(hmIconv, 0, sym_iconv, (PFN *)&fn_iconv);
+    if (rc != NO_ERROR) {
+        iconv_debug("Error: cannot find entry %s in %s", sym_iconv, dllname);
+        goto fail;
+    }
 
-        ulRC = DosQueryProcAddr(hmIconv, 0, pszIconvClose, (PFN *)&fn_iconv_close);
-        if (ulRC != NO_ERROR) {
-            debug("Error: cannot find entry %s in %s", pszIconvClose, pszName);
-          break;
-        }
+    rc = DosQueryProcAddr(hmIconv, 0, sym_iconvclose, (PFN *)&fn_iconv_close);
+    if (rc != NO_ERROR) {
+        iconv_debug("Error: cannot find entry %s in %s", sym_iconvclose, dllname);
+        goto fail;
+    }
 
-        debug("DLL %s used", pszName);
-        return TRUE;
-    } while (FALSE);
+    iconv_debug("DLL %s used", dllname);
+    return TRUE;
 
+    fail:
     DosFreeModule(hmIconv);
     hmIconv = NULLHANDLE;
     return FALSE;
@@ -104,15 +102,18 @@ static BOOL _loadDLL(PSZ pszName, PSZ pszIconvOpen, PSZ pszIconv,
 
 static void _init(void)
 {
-    if (fn_iconv_open != NULL) /* Already was initialized */
-        return;
+    if (geniconv_init) {
+        return; /* Already initialized */
+    }
+
+    geniconv_init = 1;
 
     /* Try to load kiconv.dll, iconv2.dll or iconv.dll */
     if (!_loadDLL("KICONV", "_libiconv_open", "_libiconv", "_libiconv_close") &&
         !_loadDLL("ICONV2", "_libiconv_open", "_libiconv", "_libiconv_close") &&
         !_loadDLL("ICONV",  "_iconv_open",    "_iconv",    "_iconv_close") ) {
         /* No DLL was loaded - use OS/2 conversion objects API */
-        debug("Uni*() API used");
+        iconv_debug("Uni*() API used");
         fn_iconv_open  = os2_iconv_open;
         fn_iconv       = os2_iconv;
         fn_iconv_close = os2_iconv_close;
@@ -124,16 +125,19 @@ static void _init(void)
  * ----------------
  */
 
-/* Non-standard function for iconv to unload the used dynamic library */
+/* function to unload the used iconv dynamic library */
 void libiconv_clean(void)
 {
+    geniconv_init = 0;
+
+    /* reset the function pointers. */
+    fn_iconv_open  = os2_iconv_open;
+    fn_iconv       = os2_iconv;
+    fn_iconv_close = os2_iconv_close;
+
     if (hmIconv != NULLHANDLE) {
         DosFreeModule(hmIconv);
         hmIconv = NULLHANDLE;
-
-        fn_iconv_open  = NULL;
-        fn_iconv       = NULL;
-        fn_iconv_close = NULL;
     }
 }
 
diff --git a/Engine/lib/sdl/src/core/os2/geniconv/geniconv.h b/Engine/lib/sdl/src/core/os2/geniconv/geniconv.h
index 8d5bc6886..607fe8f8d 100644
--- a/Engine/lib/sdl/src/core/os2/geniconv/geniconv.h
+++ b/Engine/lib/sdl/src/core/os2/geniconv/geniconv.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -28,7 +28,7 @@
 #ifndef GENICONV_H
 #define GENICONV_H
 
-#include <iconv.h>
+#include "iconv.h"
 
 #ifdef iconv_open
 #undef iconv_open
@@ -58,27 +58,27 @@ size_t  libiconv      (iconv_t cd, char **inbuf, size_t *inbytesleft,
 /* System codepage <-> UTF-8
  *
  * StrUTF8()
- * Coverts string from system cp to UTF-8 (fToUTF8 is not 0) or from UTF-8 to
- * the system cp (fToUTF8 is 0). Converted ASCIIZ string will be placed at the
- * buffer pcDst, up to cbDst - 1 (for sys->utf8) or 2 (for utf8->sys) bytes.
- * Returns the number of bytes written into pcDst, not counting the terminating
+ * Converts string from system cp to UTF-8 (to_utf8 is not 0) or from UTF-8 to
+ * the system cp (to_utf8 is 0). Converted ASCIIZ string will be placed at the
+ * buffer dst, up to c_dst - 1 (for sys->utf8) or 2 (for utf8->sys) bytes.
+ * Returns the number of bytes written into dst, not counting the terminating
  * 0 byte(s) or -1 on error.
  */
-int StrUTF8(int fToUTF8, char *pcDst, int cbDst, char *pcSrc, int cbSrc);
+int StrUTF8(int to_utf8, char *dst, int c_dst, char *src, int c_src);
 
 /* StrUTF8New()
- * Coverts string from system cp to UTF-8 (fToUTF8 is not 0) or from UTF-8 to
- * the system cp (fToUTF8 is 0). Memory for the new string is obtained by
+ * Converts string from system cp to UTF-8 (to_utf8 is not 0) or from UTF-8
+ * to the system cp (to_utf8 is 0). Memory for the new string is obtained by
  * using libc malloc().
  * Returns converted string, terminating two bytes 0 is appended to the result.
  * Returns null on error.
  */
-char *StrUTF8New(int fToUTF8, char *pcStr, int cbStr);
+char *StrUTF8New(int to_utf8, char *str, int c_str);
 
 /* StrUTF8Free()
- * Deallocates the memory block located by StrUTF8New() (just libc free()).
+ * Deallocates the memory block allocated by StrUTF8New() (just libc free()).
  */
-void StrUTF8Free(char *pszStr);
+void StrUTF8Free(char *str);
 
 #endif /* GENICONV_H */
 
diff --git a/Engine/lib/sdl/src/core/os2/geniconv/makefile b/Engine/lib/sdl/src/core/os2/geniconv/makefile
index 7dffd30c3..566c13d29 100644
--- a/Engine/lib/sdl/src/core/os2/geniconv/makefile
+++ b/Engine/lib/sdl/src/core/os2/geniconv/makefile
@@ -11,7 +11,7 @@ LIBFILE = geniconv.lib
 
 all: $(LIBFILE) test.exe .symbolic
 
-CFLAGS = -I$(%WATCOM)/h/os2 -I$(%WATCOM)/h -I. -bt=os2 -q -d0 -w2
+CFLAGS = -I$(%WATCOM)/h/os2 -I$(%WATCOM)/h -I. -bt=os2 -q -d0 -w2 -DGENICONV_STANDALONE=1
 
 SRCS = geniconv.c os2cp.c os2iconv.c
 SRCS+= sys2utf8.c
diff --git a/Engine/lib/sdl/src/core/os2/geniconv/os2cp.c b/Engine/lib/sdl/src/core/os2/geniconv/os2cp.c
index ed014b27d..0a651e17d 100644
--- a/Engine/lib/sdl/src/core/os2/geniconv/os2cp.c
+++ b/Engine/lib/sdl/src/core/os2/geniconv/os2cp.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -22,11 +22,21 @@
 #define INCL_DOSNLS
 #define INCL_DOSERRORS
 #include <os2.h>
-#include <string.h>
-#include <ctype.h>
 
 #include "os2cp.h"
 
+#ifndef GENICONV_STANDALONE
+#include "../../../SDL_internal.h"
+#else
+#include <string.h>
+#include <ctype.h>
+#define SDL_isspace isspace
+#define SDL_strchr strchr
+#define SDL_memcpy memcpy
+#define SDL_strupr strupr
+#define SDL_strcmp strcmp
+#endif
+
 typedef struct _CP2NAME {
   ULONG ulCode;
   PSZ  pszName;
@@ -305,30 +315,30 @@ char *os2cpToName(unsigned long cp)
     if (cp == SYSTEM_CP) {
         ULONG aulCP[3];
         ULONG cCP;
-
-        if (DosQueryCp(sizeof(aulCP), aulCP, &cCP) != NO_ERROR)
+        if (DosQueryCp(sizeof(aulCP), aulCP, &cCP) != NO_ERROR) {
             return NULL;
-
+        }
         cp = aulCP[0];
     }
 
-    if (aCP2Name[0].ulCode > cp || aCP2Name[ulHi].ulCode < cp)
+    if (aCP2Name[0].ulCode > cp || aCP2Name[ulHi].ulCode < cp) {
         return NULL;
-
-    if (aCP2Name[0].ulCode == cp)
+    }
+    if (aCP2Name[0].ulCode == cp) {
         return aCP2Name[0].pszName;
-
-    if (aCP2Name[ulHi].ulCode == cp)
+    }
+    if (aCP2Name[ulHi].ulCode == cp) {
         return aCP2Name[ulHi].pszName;
+    }
 
     while ((ulHi - ulLo) > 1) {
         ulNext = (ulLo + ulHi) / 2;
 
-        if (aCP2Name[ulNext].ulCode < cp)
+        if (aCP2Name[ulNext].ulCode < cp) {
             ulLo = ulNext;
-        else if (aCP2Name[ulNext].ulCode > cp)
+        } else if (aCP2Name[ulNext].ulCode > cp) {
             ulHi = ulNext;
-        else {
+        } else {
             lFound = ulNext;
             break;
         }
@@ -350,46 +360,51 @@ unsigned long os2cpFromName(char *cp)
     if (cp == NULL) {
         ULONG aulCP[3];
         ULONG cCP;
-
         return (DosQueryCp(sizeof(aulCP), aulCP, &cCP) != NO_ERROR)? 0 : aulCP[0];
     }
 
-    while (isspace(*cp))
+    while (SDL_isspace((unsigned char) *cp)) {
         cp++;
+    }
 
-    pcEnd = strchr(cp, ' ');
-    if (pcEnd == NULL)
-        pcEnd = strchr(cp, '\0');
-
+    pcEnd = SDL_strchr(cp, ' ');
+    if (pcEnd == NULL) {
+        pcEnd = SDL_strchr(cp, '\0');
+    }
     ulNext = pcEnd - cp;
-    if (ulNext >= sizeof(acBuf))
+    if (ulNext >= sizeof(acBuf)) {
         return 0;
+    }
 
-    memcpy(acBuf, cp, ulNext);
+    SDL_memcpy(acBuf, cp, ulNext);
     acBuf[ulNext] = '\0';
-    strupr(acBuf);
+    SDL_strupr(acBuf);
 
-    lCmp = strcmp(aName2CP[0].pszName, acBuf);
-    if (lCmp > 0)
+    lCmp = SDL_strcmp(aName2CP[0].pszName, acBuf);
+    if (lCmp > 0) {
         return 0;
-    else if (lCmp == 0)
+    }
+    if (lCmp == 0) {
         return aName2CP[0].ulCode;
+    }
 
-    lCmp = strcmp(aName2CP[ulHi].pszName, acBuf);
-    if (lCmp < 0)
+    lCmp = SDL_strcmp(aName2CP[ulHi].pszName, acBuf);
+    if (lCmp < 0) {
         return 0;
-    else if (lCmp == 0)
+    }
+    if (lCmp == 0) {
         return aName2CP[ulHi].ulCode;
+    }
 
     while ((ulHi - ulLo) > 1) {
         ulNext = (ulLo + ulHi) / 2;
 
-        lCmp = strcmp(aName2CP[ulNext].pszName, acBuf);
-        if (lCmp < 0)
+        lCmp = SDL_strcmp(aName2CP[ulNext].pszName, acBuf);
+        if (lCmp < 0) {
             ulLo = ulNext;
-        else if (lCmp > 0)
+        } else if (lCmp > 0) {
             ulHi = ulNext;
-        else {
+        } else {
             lFound = ulNext;
             break;
         }
diff --git a/Engine/lib/sdl/src/core/os2/geniconv/os2cp.h b/Engine/lib/sdl/src/core/os2/geniconv/os2cp.h
index e76016d73..db3e167ec 100644
--- a/Engine/lib/sdl/src/core/os2/geniconv/os2cp.h
+++ b/Engine/lib/sdl/src/core/os2/geniconv/os2cp.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/core/os2/geniconv/os2iconv.c b/Engine/lib/sdl/src/core/os2/geniconv/os2iconv.c
index e03a6a410..13ad2cdc6 100644
--- a/Engine/lib/sdl/src/core/os2/geniconv/os2iconv.c
+++ b/Engine/lib/sdl/src/core/os2/geniconv/os2iconv.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -31,19 +31,30 @@
 #define _ULS_CALLCONV_
 #define CALLCONV _System
 #include <uconv.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
 #ifdef ICONV_THREAD_SAFE
 #define INCL_DOSSEMAPHORES
 #define INCL_DOSERRORS
 #include <os2.h>
 #endif
+
 #include "os2cp.h"
 
+#ifndef GENICONV_STANDALONE
+#include "../../../SDL_internal.h"
+#else
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 #if !defined(min)
 #define min(a, b) (((a) < (b)) ? (a) : (b))
 #endif
+#define SDL_min   min
+#define SDL_strcasecmp stricmp
+#define SDL_snprintf _snprintf
+#define SDL_malloc malloc
+#define SDL_free free
+#define SDL_memcpy memcpy
+#endif
 
 #define MAX_CP_NAME_LEN 64
 
@@ -62,7 +73,8 @@ static int _createUconvObj(const char *code, UconvObject *uobj)
 {
     UniChar uc_code[MAX_CP_NAME_LEN];
     int i;
-    const char *ch = code;
+    const unsigned char *ch =
+         (const unsigned char *)code;
 
     if (code == NULL)
         uc_code[0] = 0;
@@ -82,7 +94,7 @@ static int uconv_open(const char *code, UconvObject *uobj)
 {
     int rc;
 
-    if (!stricmp(code, "UTF-16")) {
+    if (!SDL_strcasecmp(code, "UTF-16")) {
         *uobj = NULL;
         return ULS_SUCCESS;
     }
@@ -91,35 +103,35 @@ static int uconv_open(const char *code, UconvObject *uobj)
     if (rc != ULS_SUCCESS) {
         unsigned long cp = os2cpFromName((char *)code);
         char cp_name[16];
-
-        if (cp != 0 && _snprintf(cp_name, sizeof(cp_name), "IBM-%u", cp) > 0)
+        if (cp != 0 && SDL_snprintf(cp_name, sizeof(cp_name), "IBM-%u", cp) > 0) {
             rc = _createUconvObj(cp_name, uobj);
+        }
     }
 
     return rc;
 }
 
 
-extern iconv_t _System os2_iconv_open(const char* tocode, const char* fromcode)
+iconv_t _System os2_iconv_open(const char* tocode, const char* fromcode)
 {
     UconvObject uo_tocode;
     UconvObject uo_fromcode;
     int rc;
     iuconv_obj *iuobj;
 
-    if (tocode == NULL)
+    if (tocode == NULL) {
         tocode = "";
-
-    if (fromcode == NULL)
+    }
+    if (fromcode == NULL) {
         fromcode = "";
+    }
 
-    if (stricmp(tocode, fromcode) != 0) {
+    if (SDL_strcasecmp(tocode, fromcode) != 0) {
         rc = uconv_open(fromcode, &uo_fromcode);
         if (rc != ULS_SUCCESS) {
             errno = EINVAL;
             return (iconv_t)(-1);
         }
-
         rc = uconv_open(tocode, &uo_tocode);
         if (rc != ULS_SUCCESS) {
             UniFreeUconvObject(uo_fromcode);
@@ -131,7 +143,7 @@ extern iconv_t _System os2_iconv_open(const char* tocode, const char* fromcode)
         uo_fromcode = NULL;
     }
 
-    iuobj = (iuconv_obj *) malloc(sizeof(iuconv_obj));
+    iuobj = (iuconv_obj *) SDL_malloc(sizeof(iuconv_obj));
     iuobj->uo_tocode = uo_tocode;
     iuobj->uo_fromcode = uo_fromcode;
     iuobj->buf_len = 0;
@@ -143,9 +155,9 @@ extern iconv_t _System os2_iconv_open(const char* tocode, const char* fromcode)
     return iuobj;
 }
 
-extern size_t _System os2_iconv(iconv_t cd, char* * inbuf,
-                                size_t *inbytesleft,
-                                char* * outbuf, size_t *outbytesleft)
+size_t _System os2_iconv(iconv_t cd,
+                         char **inbuf,  size_t *inbytesleft ,
+                         char **outbuf, size_t *outbytesleft)
 {
     UconvObject uo_tocode = ((iuconv_obj *)(cd))->uo_tocode;
     UconvObject uo_fromcode = ((iuconv_obj *)(cd))->uo_fromcode;
@@ -158,8 +170,8 @@ extern size_t _System os2_iconv(iconv_t cd, char* * inbuf,
     size_t ret = (size_t)(-1);
 
     if (uo_tocode == NULL && uo_fromcode == NULL) {
-        uc_buf_len = min(*inbytesleft, *outbytesleft);
-        memcpy(*outbuf, *inbuf, uc_buf_len);
+        uc_buf_len = SDL_min(*inbytesleft, *outbytesleft);
+        SDL_memcpy(*outbuf, *inbuf, uc_buf_len);
         *inbytesleft -= uc_buf_len;
         *outbytesleft -= uc_buf_len;
         outbuf += uc_buf_len;
@@ -171,12 +183,12 @@ extern size_t _System os2_iconv(iconv_t cd, char* * inbuf,
     DosRequestMutexSem(((iuconv_obj *)(cd))->hMtx, SEM_INDEFINITE_WAIT);
 #endif
 
-    if (uo_tocode && uo_fromcode &&
-        (((iuconv_obj *)cd)->buf_len >> 1) < *inbytesleft) {
-        if (((iuconv_obj *)cd)->buf != NULL)
-            free(((iuconv_obj *)cd)->buf);
+    if (uo_tocode && uo_fromcode && (((iuconv_obj *)cd)->buf_len >> 1) < *inbytesleft) {
+        if (((iuconv_obj *)cd)->buf != NULL) {
+            SDL_free(((iuconv_obj *)cd)->buf);
+        }
         ((iuconv_obj *)cd)->buf_len = *inbytesleft << 1;
-        ((iuconv_obj *)cd)->buf = (UniChar *)malloc(((iuconv_obj *)cd)->buf_len);
+        ((iuconv_obj *)cd)->buf = (UniChar *) SDL_malloc(((iuconv_obj *)cd)->buf_len);
     }
 
     if (uo_fromcode) {
@@ -193,8 +205,9 @@ extern size_t _System os2_iconv(iconv_t cd, char* * inbuf,
         rc = UniUconvToUcs(uo_fromcode, (void **)inbuf, inbytesleft,
                            uc_str, uc_str_len, &nonIdenticalConv);
         uc_buf_len = uc_buf_len << 1;
-        if (!uo_tocode)
+        if (!uo_tocode) {
             *outbytesleft = uc_buf_len;
+        }
 
         if (rc != ULS_SUCCESS) {
             errno = EILSEQ;
@@ -204,8 +217,9 @@ extern size_t _System os2_iconv(iconv_t cd, char* * inbuf,
             goto done;
         }
 
-        if (!uo_tocode)
+        if (!uo_tocode) {
             return nonIdenticalConv;
+        }
 
         uc_buf = ((iuconv_obj *)cd)->buf;
         uc_buf_len = ((iuconv_obj *)cd)->buf_len - uc_buf_len;
@@ -254,15 +268,17 @@ int _System os2_iconv_close(iconv_t cd)
 #ifdef ICONV_THREAD_SAFE
     DosCloseMutexSem(((iuconv_obj *)cd)->hMtx);
 #endif
-    if (((iuconv_obj *)cd)->uo_tocode != NULL)
+    if (((iuconv_obj *)cd)->uo_tocode != NULL) {
         UniFreeUconvObject(((iuconv_obj *)cd)->uo_tocode);
-    if (((iuconv_obj *)cd)->uo_fromcode != NULL)
+    }
+    if (((iuconv_obj *)cd)->uo_fromcode != NULL) {
         UniFreeUconvObject(((iuconv_obj *)cd)->uo_fromcode);
+    }
 
-    if (((iuconv_obj *)cd)->buf != NULL)
-        free(((iuconv_obj *)cd)->buf);
-
-    free(cd);
+    if (((iuconv_obj *)cd)->buf != NULL) {
+        SDL_free(((iuconv_obj *)cd)->buf);
+    }
+    SDL_free(cd);
 
     return 0;
 }
diff --git a/Engine/lib/sdl/src/core/os2/geniconv/sys2utf8.c b/Engine/lib/sdl/src/core/os2/geniconv/sys2utf8.c
index 4815476cc..753e9b67f 100644
--- a/Engine/lib/sdl/src/core/os2/geniconv/sys2utf8.c
+++ b/Engine/lib/sdl/src/core/os2/geniconv/sys2utf8.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -20,42 +20,52 @@
 */
 
 #include "geniconv.h"
-#include <stdlib.h>
 
-int StrUTF8(int fToUTF8, char *pcDst, int cbDst, char *pcSrc, int cbSrc)
+#ifndef GENICONV_STANDALONE
+#include "../../../SDL_internal.h"
+#else
+#include <stdlib.h>
+#define SDL_malloc malloc
+#define SDL_realloc realloc
+#define SDL_free free
+#endif
+
+int StrUTF8(int to_utf8, char *dst, int c_dst, char *src, int c_src)
 {
     size_t  rc;
-    char   *pcDstStart = pcDst;
+    char   *dststart = dst;
     iconv_t cd;
-    char   *pszToCP, *pszFromCP;
-    int     fError = 0;
+    char   *tocp, *fromcp;
+    int     err = 0;
 
-    if (cbDst < 4)
+    if (c_dst < 4) {
         return -1;
-
-    if (fToUTF8) {
-        pszToCP   = "UTF-8";
-        pszFromCP = "";
-    } else {
-        pszToCP   = "";
-        pszFromCP = "UTF-8";
     }
 
-    cd = iconv_open(pszToCP, pszFromCP);
-    if (cd == (iconv_t)-1)
-        return -1;
+    if (to_utf8) {
+        tocp   = "UTF-8";
+        fromcp = "";
+    } else {
+        tocp   = "";
+        fromcp = "UTF-8";
+    }
 
-    while (cbSrc > 0) {
-        rc = iconv(cd, &pcSrc, (size_t *)&cbSrc, &pcDst, (size_t *)&cbDst);
+    cd = iconv_open(tocp, fromcp);
+    if (cd == (iconv_t)-1) {
+        return -1;
+    }
+
+    while (c_src > 0) {
+        rc = iconv(cd, &src, (size_t *)&c_src, &dst, (size_t *)&c_dst);
         if (rc == (size_t)-1) {
             if (errno == EILSEQ) {
                 /* Try to skip invalid character */
-                pcSrc++;
-                cbSrc--;
+                src++;
+                c_src--;
                 continue;
             }
 
-            fError = 1;
+            err = 1;
             break;
         }
     }
@@ -63,45 +73,47 @@ int StrUTF8(int fToUTF8, char *pcDst, int cbDst, char *pcSrc, int cbSrc)
     iconv_close(cd);
 
     /* Write trailing ZERO (1 byte for UTF-8, 2 bytes for the system cp) */
-    if (fToUTF8) {
-        if (cbDst < 1) {
-            pcDst--;
-            fError = 1; /* The destination buffer overflow */
+    if (to_utf8) {
+        if (c_dst < 1) {
+            dst--;
+            err = 1;    /* The destination buffer overflow */
         }
-        *pcDst = '\0';
+        *dst = '\0';
     } else {
-        if (cbDst < 2) {
-            pcDst -= (cbDst == 0)? 2 : 1;
-            fError = 1; /* The destination buffer overflow */
+        if (c_dst < 2) {
+            dst -= (c_dst == 0) ? 2 : 1;
+            err = 1;    /* The destination buffer overflow */
         }
-        *((short *)pcDst) = '\0';
+        *((short *)dst) = '\0';
     }
 
-    return (fError) ? -1 : (pcDst - pcDstStart);
+    return (err) ? -1 : (dst - dststart);
 }
 
-char *StrUTF8New(int fToUTF8, char *pcStr, int cbStr)
+char *StrUTF8New(int to_utf8, char *str, int c_str)
 {
-    int   cbNewStr = (((cbStr > 4)? cbStr : 4) + 1) * 2;
-    char *pszNewStr = (char *) malloc(cbNewStr);
+    int   c_newstr = (((c_str > 4) ? c_str : 4) + 1) * 2;
+    char *  newstr = (char *) SDL_malloc(c_newstr);
 
-    if (pszNewStr == NULL)
+    if (newstr == NULL) {
         return NULL;
-
-    cbNewStr = StrUTF8(fToUTF8, pszNewStr, cbNewStr, pcStr, cbStr);
-    if (cbNewStr != -1) {
-        pcStr = (char *) realloc(pszNewStr, cbNewStr + ((fToUTF8)? 1 : sizeof(short)));
-        if (pcStr)
-            return pcStr;
     }
 
-    free(pszNewStr);
+    c_newstr = StrUTF8(to_utf8, newstr, c_newstr, str, c_str);
+    if (c_newstr != -1) {
+        str = (char *) SDL_realloc(newstr, c_newstr + ((to_utf8) ? 1 : sizeof(short)));
+        if (str) {
+            return str;
+        }
+    }
+
+    SDL_free(newstr);
     return NULL;
 }
 
-void StrUTF8Free(char *pszStr)
+void StrUTF8Free(char *str)
 {
-    free(pszStr);
+    SDL_free(str);
 }
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/core/os2/geniconv/test.c b/Engine/lib/sdl/src/core/os2/geniconv/test.c
index cbe8db084..25e16228a 100644
--- a/Engine/lib/sdl/src/core/os2/geniconv/test.c
+++ b/Engine/lib/sdl/src/core/os2/geniconv/test.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/core/os2/iconv2.lbc b/Engine/lib/sdl/src/core/os2/iconv2.lbc
new file mode 100644
index 000000000..d9c68753f
--- /dev/null
+++ b/Engine/lib/sdl/src/core/os2/iconv2.lbc
@@ -0,0 +1,4 @@
+# OpenWatcom exports file for libiconv
+++'libiconv'.'ICONV2'..'_libiconv'
+++'libiconv_close'.'ICONV2'..'_libiconv_close'
+++'libiconv_open'.'ICONV2'..'_libiconv_open'
diff --git a/Engine/lib/sdl/src/core/unix/SDL_poll.c b/Engine/lib/sdl/src/core/unix/SDL_poll.c
index 466957bb8..f86b3ada6 100644
--- a/Engine/lib/sdl/src/core/unix/SDL_poll.c
+++ b/Engine/lib/sdl/src/core/unix/SDL_poll.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -34,10 +34,12 @@
 
 
 int
-SDL_IOReady(int fd, SDL_bool forWrite, int timeoutMS)
+SDL_IOReady(int fd, int flags, int timeoutMS)
 {
     int result;
 
+    SDL_assert(flags & (SDL_IOR_READ | SDL_IOR_WRITE));
+
     /* Note: We don't bother to account for elapsed time if we get EINTR */
     do
     {
@@ -45,10 +47,12 @@ SDL_IOReady(int fd, SDL_bool forWrite, int timeoutMS)
         struct pollfd info;
 
         info.fd = fd;
-        if (forWrite) {
-            info.events = POLLOUT;
-        } else {
-            info.events = POLLIN | POLLPRI;
+        info.events = 0;
+        if (flags & SDL_IOR_READ) {
+            info.events |= POLLIN | POLLPRI;
+        }
+        if (flags & SDL_IOR_WRITE) {
+            info.events |= POLLOUT;
         }
         result = poll(&info, 1, timeoutMS);
 #else
@@ -59,15 +63,16 @@ SDL_IOReady(int fd, SDL_bool forWrite, int timeoutMS)
         /* If this assert triggers we'll corrupt memory here */
         SDL_assert(fd >= 0 && fd < FD_SETSIZE);
 
-        if (forWrite) {
-            FD_ZERO(&wfdset);
-            FD_SET(fd, &wfdset);
-            wfdp = &wfdset;
-        } else {
+        if (flags & SDL_IOR_READ) {
             FD_ZERO(&rfdset);
             FD_SET(fd, &rfdset);
             rfdp = &rfdset;
         }
+        if (flags & SDL_IOR_WRITE) {
+            FD_ZERO(&wfdset);
+            FD_SET(fd, &wfdset);
+            wfdp = &wfdset;
+        }
 
         if (timeoutMS >= 0) {
             tv.tv_sec = timeoutMS / 1000;
@@ -78,7 +83,7 @@ SDL_IOReady(int fd, SDL_bool forWrite, int timeoutMS)
         result = select(fd + 1, rfdp, wfdp, NULL, tvp);
 #endif /* HAVE_POLL */
 
-    } while ( result < 0 && errno == EINTR );
+    } while ( result < 0 && errno == EINTR && !(flags & SDL_IOR_NO_RETRY));
 
     return result;
 }
diff --git a/Engine/lib/sdl/src/core/unix/SDL_poll.h b/Engine/lib/sdl/src/core/unix/SDL_poll.h
index 8248a7b0a..02d09c9f9 100644
--- a/Engine/lib/sdl/src/core/unix/SDL_poll.h
+++ b/Engine/lib/sdl/src/core/unix/SDL_poll.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -26,8 +26,11 @@
 
 #include "SDL_stdinc.h"
 
+#define SDL_IOR_READ           0x1
+#define SDL_IOR_WRITE          0x2
+#define SDL_IOR_NO_RETRY       0x4
 
-extern int SDL_IOReady(int fd, SDL_bool forWrite, int timeoutMS);
+extern int SDL_IOReady(int fd, int flags, int timeoutMS);
 
 #endif /* SDL_poll_h_ */
 
diff --git a/Engine/lib/sdl/src/core/windows/SDL_directx.h b/Engine/lib/sdl/src/core/windows/SDL_directx.h
index feab3b9ab..bb69c5781 100644
--- a/Engine/lib/sdl/src/core/windows/SDL_directx.h
+++ b/Engine/lib/sdl/src/core/windows/SDL_directx.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/core/windows/SDL_hid.c b/Engine/lib/sdl/src/core/windows/SDL_hid.c
index 0fc33eb70..da9413596 100644
--- a/Engine/lib/sdl/src/core/windows/SDL_hid.c
+++ b/Engine/lib/sdl/src/core/windows/SDL_hid.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -48,7 +48,7 @@ WIN_LoadHIDDLL(void)
         return 0;  /* already loaded */
     }
 
-    s_pHIDDLL = LoadLibrary(L"hid.dll");
+    s_pHIDDLL = LoadLibrary(TEXT("hid.dll"));
     if (!s_pHIDDLL) {
         return -1;
     }
diff --git a/Engine/lib/sdl/src/core/windows/SDL_hid.h b/Engine/lib/sdl/src/core/windows/SDL_hid.h
index fb4c80ea4..54b9feb52 100644
--- a/Engine/lib/sdl/src/core/windows/SDL_hid.h
+++ b/Engine/lib/sdl/src/core/windows/SDL_hid.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/core/windows/SDL_windows.c b/Engine/lib/sdl/src/core/windows/SDL_windows.c
index 8e12f82a5..fcbf8e847 100644
--- a/Engine/lib/sdl/src/core/windows/SDL_windows.c
+++ b/Engine/lib/sdl/src/core/windows/SDL_windows.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -33,6 +33,9 @@
 #ifndef _WIN32_WINNT_WIN7
 #define _WIN32_WINNT_WIN7   0x0601
 #endif
+#ifndef _WIN32_WINNT_WIN8
+#define _WIN32_WINNT_WIN8   0x0602
+#endif
 
 
 /* Sets an error message based on an HRESULT */
@@ -41,8 +44,18 @@ WIN_SetErrorFromHRESULT(const char *prefix, HRESULT hr)
 {
     TCHAR buffer[1024];
     char *message;
-    FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, hr, 0,
+    TCHAR *p = buffer;
+    DWORD c = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, hr, 0,
                   buffer, SDL_arraysize(buffer), NULL);
+    buffer[c] = 0;
+    /* kill CR/LF that FormatMessage() sticks at the end */
+    while (*p) {
+        if (*p == '\r') {
+            *p = 0;
+            break;
+        }
+        ++p;
+    }
     message = WIN_StringToUTF8(buffer);
     SDL_SetError("%s%s%s", prefix ? prefix : "", prefix ? ": " : "", message);
     SDL_free(message);
@@ -91,7 +104,51 @@ void
 WIN_CoUninitialize(void)
 {
 #ifndef __WINRT__
-    CoUninitialize();
+    /* Don't uninitialize COM because of what appears to be a bug in Microsoft WGI reference counting.
+     *
+     * If you plug in a non-Xbox controller and let the application run for 30 seconds, then it crashes in CoUninitialize()
+     * with this stack trace:
+
+        Windows.Gaming.Input.dll!GameController::~GameController(void)	Unknown
+        Windows.Gaming.Input.dll!GameController::`vector deleting destructor'(unsigned int)	Unknown
+        Windows.Gaming.Input.dll!Microsoft::WRL::Details::RuntimeClassImpl<struct Microsoft::WRL::RuntimeClassFlags<1>,1,1,0,struct Windows::Gaming::Input::IGameController,struct Windows::Gaming::Input::IGameControllerBatteryInfo,struct Microsoft::WRL::CloakedIid<struct Windows::Gaming::Input::Internal::IGameControllerPrivate>,class Microsoft::WRL::FtmBase>::Release(void)	Unknown
+        Windows.Gaming.Input.dll!Windows::Gaming::Input::Custom::Details::AggregableRuntimeClass<struct Windows::Gaming::Input::IGamepad,struct Windows::Gaming::Input::IGamepad2,struct Microsoft::WRL::CloakedIid<struct Windows::Gaming::Input::Custom::IGameControllerInputSink>,struct Microsoft::WRL::CloakedIid<struct Windows::Gaming::Input::Custom::IGipGameControllerInputSink>,struct Microsoft::WRL::CloakedIid<struct Windows::Gaming::Input::Custom::IHidGameControllerInputSink>,struct Microsoft::WRL::CloakedIid<struct Windows::Gaming::Input::Custom::IXusbGameControllerInputSink>,class Microsoft::WRL::Details::Nil,class Microsoft::WRL::Details::Nil,class Microsoft::WRL::Details::Nil>::Release(void)	Unknown
+        Windows.Gaming.Input.dll!Microsoft::WRL::ComPtr<`WaitForCompletion<Windows::Foundation::IAsyncOperationWithProgressCompletedHandler<Windows::Storage::Streams::IBuffer *,unsigned int>,Windows::Foundation::IAsyncOperationWithProgress<Windows::Storage::Streams::IBuffer *,unsigned int>>'::`2'::FTMEventDelegate>::~ComPtr<`WaitForCompletion<Windows::Foundation::IAsyncOperationWithProgressCompletedHandler<Windows::Storage::Streams::IBuffer *,unsigned int>,Windows::Foundation::IAsyncOperationWithProgress<Windows::Storage::Streams::IBuffer *,unsigned int>>'::`2'::FTMEventDelegate>()	Unknown
+        Windows.Gaming.Input.dll!`eh vector destructor iterator'(void *,unsigned int,int,void (*)(void *))	Unknown
+        Windows.Gaming.Input.dll!Windows::Gaming::Input::Custom::Details::GameControllerCollection<class Windows::Gaming::Input::RawGameController,struct Windows::Gaming::Input::IRawGameController>::~GameControllerCollection<class Windows::Gaming::Input::RawGameController,struct Windows::Gaming::Input::IRawGameController>(void)	Unknown
+        Windows.Gaming.Input.dll!Windows::Gaming::Input::Custom::Details::GameControllerCollection<class Windows::Gaming::Input::RawGameController,struct Windows::Gaming::Input::IRawGameController>::`vector deleting destructor'(unsigned int)	Unknown
+        Windows.Gaming.Input.dll!Microsoft::WRL::Details::RuntimeClassImpl<struct Microsoft::WRL::RuntimeClassFlags<1>,1,1,0,struct Windows::Foundation::Collections::IIterable<class Windows::Gaming::Input::ArcadeStick *>,struct Windows::Foundation::Collections::IVectorView<class Windows::Gaming::Input::ArcadeStick *>,class Microsoft::WRL::FtmBase>::Release(void)	Unknown
+        Windows.Gaming.Input.dll!Windows::Gaming::Input::Custom::Details::CustomGameControllerFactoryBase<class Windows::Gaming::Input::FlightStick,class Windows::Gaming::Input::FlightStick,struct Windows::Gaming::Input::IFlightStick,struct Windows::Gaming::Input::IFlightStickStatics,class Microsoft::WRL::Details::Nil>::~CustomGameControllerFactoryBase<class Windows::Gaming::Input::FlightStick,class Windows::Gaming::Input::FlightStick,struct Windows::Gaming::Input::IFlightStick,struct Windows::Gaming::Input::IFlightStickStatics,class Microsoft::WRL::Details::Nil>(void)	Unknown
+        Windows.Gaming.Input.dll!Windows::Gaming::Input::Custom::Details::CustomGameControllerFactoryBase<class Windows::Gaming::Input::FlightStick,class Windows::Gaming::Input::FlightStick,struct Windows::Gaming::Input::IFlightStick,struct Windows::Gaming::Input::IFlightStickStatics,class Microsoft::WRL::Details::Nil>::`vector deleting destructor'(unsigned int)	Unknown
+        Windows.Gaming.Input.dll!Microsoft::WRL::ActivationFactory<struct Microsoft::WRL::Implements<class Microsoft::WRL::FtmBase,struct Microsoft::WRL::CloakedIid<struct Windows::Gaming::Input::Custom::ICustomGameControllerFactory> >,struct Windows::Gaming::Input::IFlightStickStatics,class Microsoft::WRL::Details::Nil,0>::Release(void)	Unknown
+        Windows.Gaming.Input.dll!Microsoft::WRL::ComPtr<`WaitForCompletion<Windows::Foundation::IAsyncOperationWithProgressCompletedHandler<Windows::Storage::Streams::IBuffer *,unsigned int>,Windows::Foundation::IAsyncOperationWithProgress<Windows::Storage::Streams::IBuffer *,unsigned int>>'::`2'::FTMEventDelegate>::~ComPtr<`WaitForCompletion<Windows::Foundation::IAsyncOperationWithProgressCompletedHandler<Windows::Storage::Streams::IBuffer *,unsigned int>,Windows::Foundation::IAsyncOperationWithProgress<Windows::Storage::Streams::IBuffer *,unsigned int>>'::`2'::FTMEventDelegate>()	Unknown
+        Windows.Gaming.Input.dll!NtList<struct FactoryManager::FactoryListEntry>::~NtList<struct FactoryManager::FactoryListEntry>(void)	Unknown
+        Windows.Gaming.Input.dll!FactoryManager::`vector deleting destructor'(unsigned int)	Unknown
+        Windows.Gaming.Input.dll!Microsoft::WRL::ActivationFactory<struct Microsoft::WRL::Implements<class Microsoft::WRL::FtmBase,struct Windows::Gaming::Input::Custom::IGameControllerFactoryManagerStatics>,struct Windows::Gaming::Input::Custom::IGameControllerFactoryManagerStatics2,struct Microsoft::WRL::CloakedIid<struct Windows::Gaming::Input::Internal::IGameControllerFactoryManagerStaticsPrivate>,0>::Release(void)	Unknown
+        Windows.Gaming.Input.dll!Microsoft::WRL::Details::TerminateMap(class Microsoft::WRL::Details::ModuleBase *,unsigned short const *,bool)	Unknown
+        Windows.Gaming.Input.dll!Microsoft::WRL::Module<1,class Microsoft::WRL::Details::DefaultModule<1> >::~Module<1,class Microsoft::WRL::Details::DefaultModule<1> >(void)	Unknown
+        Windows.Gaming.Input.dll!Microsoft::WRL::Details::DefaultModule<1>::`vector deleting destructor'(unsigned int)	Unknown
+        Windows.Gaming.Input.dll!`dynamic atexit destructor for 'Microsoft::WRL::Details::StaticStorage<Microsoft::WRL::Details::DefaultModule<1>,0,int>::instance_''()	Unknown
+        Windows.Gaming.Input.dll!__CRT_INIT@12()	Unknown
+        Windows.Gaming.Input.dll!__DllMainCRTStartup()	Unknown
+        ntdll.dll!_LdrxCallInitRoutine@16()	Unknown
+        ntdll.dll!LdrpCallInitRoutine()	Unknown
+        ntdll.dll!LdrpProcessDetachNode()	Unknown
+        ntdll.dll!LdrpUnloadNode()	Unknown
+        ntdll.dll!LdrpDecrementModuleLoadCountEx()	Unknown
+        ntdll.dll!LdrUnloadDll()	Unknown
+        KernelBase.dll!FreeLibrary()	Unknown
+        combase.dll!FreeLibraryWithLogging(LoadOrFreeWhy why, HINSTANCE__ * hMod, const wchar_t * pswzOptionalFileName) Line 193	C++
+        combase.dll!CClassCache::CDllPathEntry::CFinishObject::Finish() Line 3311	C++
+        combase.dll!CClassCache::CFinishComposite::Finish() Line 3421	C++
+        combase.dll!CClassCache::CleanUpDllsForProcess() Line 7009	C++
+        [Inline Frame] combase.dll!CCCleanUpDllsForProcess() Line 8773	C++
+        combase.dll!ProcessUninitialize() Line 2243	C++
+        combase.dll!DecrementProcessInitializeCount() Line 993	C++
+        combase.dll!wCoUninitialize(COleTls & Tls, int fHostThread) Line 4126	C++
+        combase.dll!CoUninitialize() Line 3945	C++
+    */
+    /*CoUninitialize();*/
 #endif
 }
 
@@ -135,6 +192,15 @@ BOOL WIN_IsWindows7OrGreater(void)
 #endif
 }
 
+BOOL WIN_IsWindows8OrGreater(void)
+{
+#ifdef __WINRT__
+    return TRUE;
+#else
+    return IsWindowsVersionOrGreater(HIBYTE(_WIN32_WINNT_WIN8), LOBYTE(_WIN32_WINNT_WIN8), 0);
+#endif
+}
+
 /*
 WAVExxxCAPS gives you 31 bytes for the device name, and just truncates if it's
 longer. However, since WinXP, you can use the WAVExxxCAPS2 structure, which
@@ -227,6 +293,24 @@ WIN_IsEqualIID(REFIID a, REFIID b)
     return (SDL_memcmp(a, b, sizeof (*a)) == 0);
 }
 
+void
+WIN_RECTToRect(const RECT *winrect, SDL_Rect *sdlrect)
+{
+    sdlrect->x = winrect->left;
+    sdlrect->w = (winrect->right - winrect->left) + 1;
+    sdlrect->y = winrect->top;
+    sdlrect->h = (winrect->bottom - winrect->top) + 1;
+}
+
+void
+WIN_RectToRECT(const SDL_Rect *sdlrect, RECT *winrect)
+{
+    winrect->left = sdlrect->x;
+    winrect->right = sdlrect->x + sdlrect->w - 1;
+    winrect->top = sdlrect->y;
+    winrect->bottom = sdlrect->y + sdlrect->h - 1;
+}
+
 #endif /* __WIN32__ || __WINRT__ */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/core/windows/SDL_windows.h b/Engine/lib/sdl/src/core/windows/SDL_windows.h
index 3707fe30c..221c3bd87 100644
--- a/Engine/lib/sdl/src/core/windows/SDL_windows.h
+++ b/Engine/lib/sdl/src/core/windows/SDL_windows.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -37,14 +37,24 @@
 #include <windows.h>
 #include <basetyps.h>   /* for REFIID with broken mingw.org headers */
 
+#include "SDL_rect.h"
+
 /* Routines to convert from UTF8 to native Windows text */
-#if UNICODE
-#define WIN_StringToUTF8(S) SDL_iconv_string("UTF-8", "UTF-16LE", (char *)(S), (SDL_wcslen(S)+1)*sizeof(WCHAR))
-#define WIN_UTF8ToString(S) (WCHAR *)SDL_iconv_string("UTF-16LE", "UTF-8", (char *)(S), SDL_strlen(S)+1)
-#else
+#define WIN_StringToUTF8W(S) SDL_iconv_string("UTF-8", "UTF-16LE", (const char *)(S), (SDL_wcslen(S)+1)*sizeof(WCHAR))
+#define WIN_UTF8ToStringW(S) (WCHAR *)SDL_iconv_string("UTF-16LE", "UTF-8", (const char *)(S), SDL_strlen(S)+1)
 /* !!! FIXME: UTF8ToString() can just be a SDL_strdup() here. */
-#define WIN_StringToUTF8(S) SDL_iconv_string("UTF-8", "ASCII", (char *)(S), (SDL_strlen(S)+1))
-#define WIN_UTF8ToString(S) SDL_iconv_string("ASCII", "UTF-8", (char *)(S), SDL_strlen(S)+1)
+#define WIN_StringToUTF8A(S) SDL_iconv_string("UTF-8", "ASCII", (const char *)(S), (SDL_strlen(S)+1))
+#define WIN_UTF8ToStringA(S) SDL_iconv_string("ASCII", "UTF-8", (const char *)(S), SDL_strlen(S)+1)
+#if UNICODE
+#define WIN_StringToUTF8 WIN_StringToUTF8W
+#define WIN_UTF8ToString WIN_UTF8ToStringW
+#define SDL_tcslen SDL_wcslen
+#define SDL_tcsstr SDL_wcsstr
+#else
+#define WIN_StringToUTF8 WIN_StringToUTF8A
+#define WIN_UTF8ToString WIN_UTF8ToStringA
+#define SDL_tcslen SDL_strlen
+#define SDL_tcsstr SDL_strstr
 #endif
 
 /* Sets an error message based on a given HRESULT */
@@ -63,6 +73,9 @@ extern BOOL WIN_IsWindowsVistaOrGreater(void);
 /* Returns SDL_TRUE if we're running on Windows 7 and newer */
 extern BOOL WIN_IsWindows7OrGreater(void);
 
+/* Returns SDL_TRUE if we're running on Windows 8 and newer */
+extern BOOL WIN_IsWindows8OrGreater(void);
+
 /* You need to SDL_free() the result of this call. */
 extern char *WIN_LookupAudioDeviceName(const WCHAR *name, const GUID *guid);
 
@@ -70,6 +83,10 @@ extern char *WIN_LookupAudioDeviceName(const WCHAR *name, const GUID *guid);
 extern BOOL WIN_IsEqualGUID(const GUID * a, const GUID * b);
 extern BOOL WIN_IsEqualIID(REFIID a, REFIID b);
 
+/* Convert between SDL_rect and RECT */
+extern void WIN_RECTToRect(const RECT *winrect, SDL_Rect *sdlrect);
+extern void WIN_RectToRECT(const SDL_Rect *sdlrect, RECT *winrect);
+
 #endif /* _INCLUDED_WINDOWS_H */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/core/windows/SDL_xinput.c b/Engine/lib/sdl/src/core/windows/SDL_xinput.c
index 9a2016452..1893907e4 100644
--- a/Engine/lib/sdl/src/core/windows/SDL_xinput.c
+++ b/Engine/lib/sdl/src/core/windows/SDL_xinput.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -86,17 +86,17 @@ WIN_LoadXInputDLL(void)
      * limitations of that API (no devices at startup, no background input, etc.)
      */
     version = (1 << 16) | 4;
-    s_pXInputDLL = LoadLibrary(L"XInput1_4.dll");  /* 1.4 Ships with Windows 8. */
+    s_pXInputDLL = LoadLibrary(TEXT("XInput1_4.dll"));  /* 1.4 Ships with Windows 8. */
     if (!s_pXInputDLL) {
         version = (1 << 16) | 3;
-        s_pXInputDLL = LoadLibrary(L"XInput1_3.dll");  /* 1.3 can be installed as a redistributable component. */
+        s_pXInputDLL = LoadLibrary(TEXT("XInput1_3.dll"));  /* 1.3 can be installed as a redistributable component. */
     }
     if (!s_pXInputDLL) {
-        s_pXInputDLL = LoadLibrary(L"bin\\XInput1_3.dll");
+        s_pXInputDLL = LoadLibrary(TEXT("bin\\XInput1_3.dll"));
     }
     if (!s_pXInputDLL) {
         /* "9.1.0" Ships with Vista and Win7, and is more limited than 1.3+ (e.g. XInputGetStateEx is not available.)  */
-        s_pXInputDLL = LoadLibrary(L"XInput9_1_0.dll");
+        s_pXInputDLL = LoadLibrary(TEXT("XInput9_1_0.dll"));
     }
     if (!s_pXInputDLL) {
         return -1;
diff --git a/Engine/lib/sdl/src/core/windows/SDL_xinput.h b/Engine/lib/sdl/src/core/windows/SDL_xinput.h
index a4b23803b..6e72327d8 100644
--- a/Engine/lib/sdl/src/core/windows/SDL_xinput.h
+++ b/Engine/lib/sdl/src/core/windows/SDL_xinput.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/core/winrt/SDL_winrtapp_common.cpp b/Engine/lib/sdl/src/core/winrt/SDL_winrtapp_common.cpp
index fdbeff405..6e98a78d9 100644
--- a/Engine/lib/sdl/src/core/winrt/SDL_winrtapp_common.cpp
+++ b/Engine/lib/sdl/src/core/winrt/SDL_winrtapp_common.cpp
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/core/winrt/SDL_winrtapp_common.h b/Engine/lib/sdl/src/core/winrt/SDL_winrtapp_common.h
index 373f21038..79b100276 100644
--- a/Engine/lib/sdl/src/core/winrt/SDL_winrtapp_common.h
+++ b/Engine/lib/sdl/src/core/winrt/SDL_winrtapp_common.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/core/winrt/SDL_winrtapp_direct3d.cpp b/Engine/lib/sdl/src/core/winrt/SDL_winrtapp_direct3d.cpp
index 114b9cb24..1f0962fca 100644
--- a/Engine/lib/sdl/src/core/winrt/SDL_winrtapp_direct3d.cpp
+++ b/Engine/lib/sdl/src/core/winrt/SDL_winrtapp_direct3d.cpp
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -119,68 +119,6 @@ int SDL_WinRTInitNonXAMLApp(int (*mainFunction)(int, char **))
     return 0;
 }
 
-static void SDLCALL
-WINRT_SetDisplayOrientationsPreference(void *userdata, const char *name, const char *oldValue, const char *newValue)
-{
-    SDL_assert(SDL_strcmp(name, SDL_HINT_ORIENTATIONS) == 0);
-
-    /* HACK: prevent SDL from altering an app's .appxmanifest-set orientation
-     * from being changed on startup, by detecting when SDL_HINT_ORIENTATIONS
-     * is getting registered.
-     *
-     * TODO, WinRT: consider reading in an app's .appxmanifest file, and apply its orientation when 'newValue == NULL'.
-     */
-    if ((oldValue == NULL) && (newValue == NULL)) {
-        return;
-    }
-
-    // Start with no orientation flags, then add each in as they're parsed
-    // from newValue.
-    unsigned int orientationFlags = 0;
-    if (newValue) {
-        std::istringstream tokenizer(newValue);
-        while (!tokenizer.eof()) {
-            std::string orientationName;
-            std::getline(tokenizer, orientationName, ' ');
-            if (orientationName == "LandscapeLeft") {
-                orientationFlags |= (unsigned int) DisplayOrientations::LandscapeFlipped;
-            } else if (orientationName == "LandscapeRight") {
-                orientationFlags |= (unsigned int) DisplayOrientations::Landscape;
-            } else if (orientationName == "Portrait") {
-                orientationFlags |= (unsigned int) DisplayOrientations::Portrait;
-            } else if (orientationName == "PortraitUpsideDown") {
-                orientationFlags |= (unsigned int) DisplayOrientations::PortraitFlipped;
-            }
-        }
-    }
-
-    // If no valid orientation flags were specified, use a reasonable set of defaults:
-    if (!orientationFlags) {
-        // TODO, WinRT: consider seeing if an app's default orientation flags can be found out via some API call(s).
-        orientationFlags = (unsigned int) ( \
-            DisplayOrientations::Landscape |
-            DisplayOrientations::LandscapeFlipped |
-            DisplayOrientations::Portrait |
-            DisplayOrientations::PortraitFlipped);
-    }
-
-    // Set the orientation/rotation preferences.  Please note that this does
-    // not constitute a 100%-certain lock of a given set of possible
-    // orientations.  According to Microsoft's documentation on WinRT [1]
-    // when a device is not capable of being rotated, Windows may ignore
-    // the orientation preferences, and stick to what the device is capable of
-    // displaying.
-    //
-    // [1] Documentation on the 'InitialRotationPreference' setting for a
-    // Windows app's manifest file describes how some orientation/rotation
-    // preferences may be ignored.  See
-    // http://msdn.microsoft.com/en-us/library/windows/apps/hh700343.aspx
-    // for details.  Microsoft's "Display orientation sample" also gives an
-    // outline of how Windows treats device rotation
-    // (http://code.msdn.microsoft.com/Display-Orientation-Sample-19a58e93).
-    WINRT_DISPLAY_PROPERTY(AutoRotationPreferences) = (DisplayOrientations) orientationFlags;
-}
-
 static void
 WINRT_ProcessWindowSizeChange() // TODO: Pass an SDL_Window-identifying thing into WINRT_ProcessWindowSizeChange()
 {
@@ -397,10 +335,6 @@ void SDL_WinRTApp::SetWindow(CoreWindow^ window)
         ref new DisplayPropertiesEventHandler(this, &SDL_WinRTApp::OnOrientationChanged);
 #endif
 
-    // Register the hint, SDL_HINT_ORIENTATIONS, with SDL.
-    // TODO, WinRT: see if an app's default orientation can be found out via WinRT API(s), then set the initial value of SDL_HINT_ORIENTATIONS accordingly.
-    SDL_AddHintCallback(SDL_HINT_ORIENTATIONS, WINRT_SetDisplayOrientationsPreference, NULL);
-
 #if (WINAPI_FAMILY == WINAPI_FAMILY_APP) && (NTDDI_VERSION < NTDDI_WIN10)  // for Windows 8/8.1/RT apps... (and not Phone apps)
     // Make sure we know when a user has opened the app's settings pane.
     // This is needed in order to display a privacy policy, which needs
@@ -423,9 +357,16 @@ void SDL_WinRTApp::Run()
     {
         // TODO, WinRT: pass the C-style main() a reasonably realistic
         // representation of command line arguments.
-        int argc = 0;
-        char **argv = NULL;
+        int argc = 1;
+        char **argv = (char **)SDL_malloc(2 * sizeof(*argv));
+        if (!argv) {
+            return;
+        }
+        argv[0] = SDL_strdup("WinRTApp");
+        argv[1] = NULL;
         WINRT_SDLAppEntryPoint(argc, argv);
+        SDL_free(argv[0]);
+        SDL_free(argv);
     }
 }
 
@@ -729,15 +670,18 @@ void SDL_WinRTApp::OnExiting(Platform::Object^ sender, Platform::Object^ args)
 static void
 WINRT_LogPointerEvent(const char * header, Windows::UI::Core::PointerEventArgs ^ args, Windows::Foundation::Point transformedPoint)
 {
+    Uint8 button, pressed;
     Windows::UI::Input::PointerPoint ^ pt = args->CurrentPoint;
-    SDL_Log("%s: Position={%f,%f}, Transformed Pos={%f, %f}, MouseWheelDelta=%d, FrameId=%d, PointerId=%d, SDL button=%d\n",
+    WINRT_GetSDLButtonForPointerPoint(pt, &button, &pressed);
+    SDL_Log("%s: Position={%f,%f}, Transformed Pos={%f, %f}, MouseWheelDelta=%d, FrameId=%d, PointerId=%d, SDL button=%d pressed=%d\n",
         header,
         pt->Position.X, pt->Position.Y,
         transformedPoint.X, transformedPoint.Y,
         pt->Properties->MouseWheelDelta,
         pt->FrameId,
         pt->PointerId,
-        WINRT_GetSDLButtonForPointerPoint(pt));
+        button,
+        pressed);
 }
 
 void SDL_WinRTApp::OnPointerPressed(CoreWindow^ sender, PointerEventArgs^ args)
diff --git a/Engine/lib/sdl/src/core/winrt/SDL_winrtapp_direct3d.h b/Engine/lib/sdl/src/core/winrt/SDL_winrtapp_direct3d.h
index 8b9765b95..1f7c917a6 100644
--- a/Engine/lib/sdl/src/core/winrt/SDL_winrtapp_direct3d.h
+++ b/Engine/lib/sdl/src/core/winrt/SDL_winrtapp_direct3d.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/core/winrt/SDL_winrtapp_xaml.cpp b/Engine/lib/sdl/src/core/winrt/SDL_winrtapp_xaml.cpp
index b9dd1e216..69716e11d 100644
--- a/Engine/lib/sdl/src/core/winrt/SDL_winrtapp_xaml.cpp
+++ b/Engine/lib/sdl/src/core/winrt/SDL_winrtapp_xaml.cpp
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -115,7 +115,7 @@ SDL_WinRTInitXAMLApp(int (*mainFunction)(int, char **), void * backgroundPanelAs
 
     // Make sure we have a valid XAML element (to draw onto):
     if ( ! backgroundPanelAsIInspectable) {
-        return SDL_SetError("'backgroundPanelAsIInspectable' can't be NULL");
+        return SDL_InvalidParamError("backgroundPanelAsIInspectable");
     }
 
     Platform::Object ^ backgroundPanel = reinterpret_cast<Object ^>((IInspectable *) backgroundPanelAsIInspectable);
diff --git a/Engine/lib/sdl/src/core/winrt/SDL_winrtapp_xaml.h b/Engine/lib/sdl/src/core/winrt/SDL_winrtapp_xaml.h
index f998e84ca..e26e21884 100644
--- a/Engine/lib/sdl/src/core/winrt/SDL_winrtapp_xaml.h
+++ b/Engine/lib/sdl/src/core/winrt/SDL_winrtapp_xaml.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/cpuinfo/SDL_cpuinfo.c b/Engine/lib/sdl/src/cpuinfo/SDL_cpuinfo.c
index b529a6d1d..babbb816c 100644
--- a/Engine/lib/sdl/src/cpuinfo/SDL_cpuinfo.c
+++ b/Engine/lib/sdl/src/cpuinfo/SDL_cpuinfo.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -50,10 +50,13 @@
 #endif
 #if defined(__MACOSX__) && (defined(__ppc__) || defined(__ppc64__))
 #include <sys/sysctl.h>         /* For AltiVec check */
-#elif (defined(__OpenBSD__) || defined(__FreeBSD__)) && defined(__powerpc__)
+#elif defined(__OpenBSD__) && defined(__powerpc__)
 #include <sys/param.h>
 #include <sys/sysctl.h> /* For AltiVec check */
 #include <machine/cpu.h>
+#elif defined(__FreeBSD__) && defined(__powerpc__)
+#include <machine/cpu.h>
+#include <sys/auxv.h>
 #elif SDL_ALTIVEC_BLITTERS && HAVE_SETJMP
 #include <signal.h>
 #include <setjmp.h>
@@ -63,7 +66,13 @@
 #include <sys/syspage.h>
 #endif
 
-#if (defined(__LINUX__) || defined(__ANDROID__)) && defined(__ARM_ARCH)
+#if (defined(__LINUX__) || defined(__ANDROID__)) && defined(__arm__)
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <elf.h>
+
 /*#include <asm/hwcap.h>*/
 #ifndef AT_HWCAP
 #define AT_HWCAP 16
@@ -71,27 +80,16 @@
 #ifndef AT_PLATFORM
 #define AT_PLATFORM 15
 #endif
-/* Prevent compilation error when including elf.h would also try to define AT_* as an enum */
-#ifndef AT_NULL
-#define AT_NULL 0
-#endif
 #ifndef HWCAP_NEON
 #define HWCAP_NEON (1 << 12)
 #endif
-#if defined HAVE_GETAUXVAL
-#include <sys/auxv.h>
-#else
-#include <fcntl.h>
-#endif
 #endif
 
-#if defined(__ANDROID__) && defined(__ARM_ARCH) && !defined(HAVE_GETAUXVAL)
-#if __ARM_ARCH < 8
+#if defined(__ANDROID__) && defined(__arm__) && !defined(HAVE_GETAUXVAL)
 #include <cpu-features.h>
 #endif
-#endif
 
-#if defined(HAVE_ELF_AUX_INFO)
+#if defined(HAVE_GETAUXVAL) || defined(HAVE_ELF_AUX_INFO)
 #include <sys/auxv.h>
 #endif
 
@@ -115,7 +113,7 @@
 #define CPU_HAS_AVX512F (1 << 12)
 #define CPU_HAS_ARM_SIMD (1 << 13)
 
-#if SDL_ALTIVEC_BLITTERS && HAVE_SETJMP && !__MACOSX__ && !__OpenBSD__
+#if SDL_ALTIVEC_BLITTERS && HAVE_SETJMP && !__MACOSX__ && !__OpenBSD__ && !__FreeBSD__
 /* This is the brute force way of detecting instruction sets...
    the idea is borrowed from the libmpeg2 library - thanks!
  */
@@ -134,7 +132,7 @@ CPU_haveCPUID(void)
 
 /* *INDENT-OFF* */
 #ifndef SDL_CPUINFO_DISABLED
-#if defined(__GNUC__) && defined(i386)
+#if (defined(__GNUC__) || defined(__llvm__)) && defined(__i386__)
     __asm__ (
 "        pushfl                      # Get original EFLAGS             \n"
 "        popl    %%eax                                                 \n"
@@ -152,7 +150,7 @@ CPU_haveCPUID(void)
     :
     : "%eax", "%ecx"
     );
-#elif defined(__GNUC__) && defined(__x86_64__)
+#elif (defined(__GNUC__) || defined(__llvm__)) && defined(__x86_64__)
 /* Technically, if this is being compiled under __x86_64__ then it has 
    CPUid by definition.  But it's nice to be able to prove it.  :)      */
     __asm__ (
@@ -225,7 +223,7 @@ done:
     return has_CPUID;
 }
 
-#if defined(__GNUC__) && defined(i386)
+#if (defined(__GNUC__) || defined(__llvm__)) && defined(__i386__)
 #define cpuid(func, a, b, c, d) \
     __asm__ __volatile__ ( \
 "        pushl %%ebx        \n" \
@@ -234,7 +232,7 @@ done:
 "        movl %%ebx, %%esi  \n" \
 "        popl %%ebx         \n" : \
             "=a" (a), "=S" (b), "=c" (c), "=d" (d) : "a" (func))
-#elif defined(__GNUC__) && defined(__x86_64__)
+#elif (defined(__GNUC__) || defined(__llvm__)) && defined(__x86_64__)
 #define cpuid(func, a, b, c, d) \
     __asm__ __volatile__ ( \
 "        pushq %%rbx        \n" \
@@ -294,7 +292,7 @@ CPU_calcCPUIDFeatures(void)
                 /* Check to make sure we can call xgetbv */
                 if (c & 0x08000000) {
                     /* Call xgetbv to see if YMM (etc) register state is saved */
-#if defined(__GNUC__) && (defined(i386) || defined(__x86_64__))
+#if (defined(__GNUC__) || defined(__llvm__)) && (defined(__i386__) || defined(__x86_64__))
                     __asm__(".byte 0x0f, 0x01, 0xd0" : "=a" (a) : "c" (0) : "%edx");
 #elif defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64)) && (_MSC_FULL_VER >= 160040219) /* VS2010 SP1 */
                     a = (int)_xgetbv(0);
@@ -319,11 +317,9 @@ CPU_haveAltiVec(void)
 {
     volatile int altivec = 0;
 #ifndef SDL_CPUINFO_DISABLED
-#if (defined(__MACOSX__) && (defined(__ppc__) || defined(__ppc64__))) || (defined(__OpenBSD__) && defined(__powerpc__)) || (defined(__FreeBSD__) && defined(__powerpc__))
+#if (defined(__MACOSX__) && (defined(__ppc__) || defined(__ppc64__))) || (defined(__OpenBSD__) && defined(__powerpc__))
 #ifdef __OpenBSD__
     int selectors[2] = { CTL_MACHDEP, CPU_ALTIVEC };
-#elif defined(__FreeBSD__)
-    int selectors[2] = { CTL_HW, PPC_FEATURE_HAS_ALTIVEC };
 #else
     int selectors[2] = { CTL_HW, HW_VECTORUNIT };
 #endif
@@ -332,6 +328,11 @@ CPU_haveAltiVec(void)
     int error = sysctl(selectors, 2, &hasVectorUnit, &length, NULL, 0);
     if (0 == error)
         altivec = (hasVectorUnit != 0);
+#elif defined(__FreeBSD__) && defined(__powerpc__)
+    unsigned long cpufeatures = 0;
+    elf_aux_info(AT_HWCAP, &cpufeatures, sizeof(cpufeatures));
+    altivec = cpufeatures & PPC_FEATURE_HAS_ALTIVEC;
+    return altivec;
 #elif SDL_ALTIVEC_BLITTERS && HAVE_SETJMP
     void (*handler) (int sig);
     handler = signal(SIGILL, illegal_instruction);
@@ -345,34 +346,28 @@ CPU_haveAltiVec(void)
     return altivec;
 }
 
-#if defined(__ARM_ARCH) && (__ARM_ARCH >= 6)
+#if (defined(__ARM_ARCH) && (__ARM_ARCH >= 6)) || defined(__aarch64__)
 static int
 CPU_haveARMSIMD(void)
 {
-	return 1;
+    return 1;
 }
 
 #elif !defined(__arm__)
 static int
 CPU_haveARMSIMD(void)
 {
-	return 0;
+    return 0;
 }
 
 #elif defined(__LINUX__)
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <elf.h>
-
 static int
 CPU_haveARMSIMD(void)
 {
     int arm_simd = 0;
     int fd;
 
-    fd = open("/proc/self/auxv", O_RDONLY);
+    fd = open("/proc/self/auxv", O_RDONLY | O_CLOEXEC);
     if (fd >= 0)
     {
         Elf32_auxv_t aux;
@@ -382,8 +377,8 @@ CPU_haveARMSIMD(void)
             {
                 const char *plat = (const char *) aux.a_un.a_val;
                 if (plat) {
-                    arm_simd = strncmp(plat, "v6l", 3) == 0 ||
-                               strncmp(plat, "v7l", 3) == 0;
+                    arm_simd = SDL_strncmp(plat, "v6l", 3) == 0 ||
+                               SDL_strncmp(plat, "v7l", 3) == 0;
                 }
             }
         }
@@ -393,24 +388,23 @@ CPU_haveARMSIMD(void)
 }
 
 #elif defined(__RISCOS__)
-
 static int
 CPU_haveARMSIMD(void)
 {
-	_kernel_swi_regs regs;
-	regs.r[0] = 0;
-	if (_kernel_swi(OS_PlatformFeatures, &regs, &regs) != NULL)
-		return 0;
+    _kernel_swi_regs regs;
+    regs.r[0] = 0;
+    if (_kernel_swi(OS_PlatformFeatures, &regs, &regs) != NULL)
+        return 0;
 
-	if (!(regs.r[0] & (1<<31)))
-		return 0;
+    if (!(regs.r[0] & (1<<31)))
+        return 0;
 
-	regs.r[0] = 34;
-	regs.r[1] = 29;
-	if (_kernel_swi(OS_PlatformFeatures, &regs, &regs) != NULL)
-		return 0;
+    regs.r[0] = 34;
+    regs.r[1] = 29;
+    if (_kernel_swi(OS_PlatformFeatures, &regs, &regs) != NULL)
+        return 0;
 
-	return regs.r[0];
+    return regs.r[0];
 }
 
 #else
@@ -422,17 +416,20 @@ CPU_haveARMSIMD(void)
 }
 #endif
 
-#if defined(__LINUX__) && defined(__ARM_ARCH) && !defined(HAVE_GETAUXVAL)
+#if defined(__LINUX__) && defined(__arm__) && !defined(HAVE_GETAUXVAL)
 static int
 readProcAuxvForNeon(void)
 {
     int neon = 0;
-    int kv[2];
-    const int fd = open("/proc/self/auxv", O_RDONLY);
-    if (fd != -1) {
-        while (read(fd, kv, sizeof (kv)) == sizeof (kv)) {
-            if (kv[0] == AT_HWCAP) {
-                neon = ((kv[1] & HWCAP_NEON) == HWCAP_NEON);
+    int fd;
+
+    fd = open("/proc/self/auxv", O_RDONLY | O_CLOEXEC);
+    if (fd >= 0)
+    {
+        Elf32_auxv_t aux;
+        while (read(fd, &aux, sizeof (aux)) == sizeof (aux)) {
+            if (aux.a_type == AT_HWCAP) {
+                neon = (aux.a_un.a_val & HWCAP_NEON) == HWCAP_NEON;
                 break;
             }
         }
@@ -457,22 +454,24 @@ CPU_haveNEON(void)
 #  endif
 /* All WinRT ARM devices are required to support NEON, but just in case. */
     return IsProcessorFeaturePresent(PF_ARM_NEON_INSTRUCTIONS_AVAILABLE) != 0;
-#elif defined(__ARM_ARCH) && (__ARM_ARCH >= 8)
+#elif (defined(__ARM_ARCH) && (__ARM_ARCH >= 8)) || defined(__aarch64__)
     return 1;  /* ARMv8 always has non-optional NEON support. */
+#elif __VITA__
+    return 1;
 #elif defined(__APPLE__) && defined(__ARM_ARCH) && (__ARM_ARCH >= 7)
     /* (note that sysctlbyname("hw.optional.neon") doesn't work!) */
     return 1;  /* all Apple ARMv7 chips and later have NEON. */
 #elif defined(__APPLE__)
     return 0;  /* assume anything else from Apple doesn't have NEON. */
+#elif !defined(__arm__)
+    return 0;  /* not an ARM CPU at all. */
 #elif defined(__OpenBSD__)
     return 1;  /* OpenBSD only supports ARMv7 CPUs that have NEON. */
-#elif defined(HAVE_ELF_AUX_INFO) && defined(HWCAP_NEON)
+#elif defined(HAVE_ELF_AUX_INFO)
     unsigned long hasneon = 0;
     if (elf_aux_info(AT_HWCAP, (void *)&hasneon, (int)sizeof(hasneon)) != 0)
         return 0;
     return ((hasneon & HWCAP_NEON) == HWCAP_NEON);
-#elif !defined(__arm__)
-    return 0;  /* not an ARM CPU at all. */
 #elif defined(__QNXNTO__)
     return SYSPAGE_ENTRY(cpuinfo)->flags & ARM_CPU_FLAG_NEON;
 #elif (defined(__LINUX__) || defined(__ANDROID__)) && defined(HAVE_GETAUXVAL)
@@ -509,6 +508,17 @@ CPU_haveNEON(void)
 #endif
 }
 
+#if defined(__e2k__)
+inline int
+CPU_have3DNow(void)
+{
+#if defined(__3dNOW__)
+    return 1;
+#else
+    return 0;
+#endif
+}
+#else
 static int
 CPU_have3DNow(void)
 {
@@ -522,7 +532,46 @@ CPU_have3DNow(void)
     }
     return 0;
 }
+#endif
 
+#if defined(__e2k__)
+#define CPU_haveRDTSC() (0)
+#if defined(__MMX__)
+#define CPU_haveMMX() (1)
+#else
+#define CPU_haveMMX() (0)
+#endif
+#if defined(__SSE__)
+#define CPU_haveSSE() (1)
+#else
+#define CPU_haveSSE() (0)
+#endif
+#if defined(__SSE2__)
+#define CPU_haveSSE2() (1)
+#else
+#define CPU_haveSSE2() (0)
+#endif
+#if defined(__SSE3__)
+#define CPU_haveSSE3() (1)
+#else
+#define CPU_haveSSE3() (0)
+#endif
+#if defined(__SSE4_1__)
+#define CPU_haveSSE41() (1)
+#else
+#define CPU_haveSSE41() (0)
+#endif
+#if defined(__SSE4_2__)
+#define CPU_haveSSE42() (1)
+#else
+#define CPU_haveSSE42() (0)
+#endif
+#if defined(__AVX__)
+#define CPU_haveAVX() (1)
+#else
+#define CPU_haveAVX() (0)
+#endif
+#else
 #define CPU_haveRDTSC() (CPU_CPUIDFeatures[3] & 0x00000010)
 #define CPU_haveMMX() (CPU_CPUIDFeatures[3] & 0x00800000)
 #define CPU_haveSSE() (CPU_CPUIDFeatures[3] & 0x02000000)
@@ -531,7 +580,19 @@ CPU_have3DNow(void)
 #define CPU_haveSSE41() (CPU_CPUIDFeatures[2] & 0x00080000)
 #define CPU_haveSSE42() (CPU_CPUIDFeatures[2] & 0x00100000)
 #define CPU_haveAVX() (CPU_OSSavesYMM && (CPU_CPUIDFeatures[2] & 0x10000000))
+#endif
 
+#if defined(__e2k__)
+inline int
+CPU_haveAVX2(void)
+{
+#if defined(__AVX2__)
+    return 1;
+#else
+    return 0;
+#endif
+}
+#else
 static int
 CPU_haveAVX2(void)
 {
@@ -543,7 +604,15 @@ CPU_haveAVX2(void)
     }
     return 0;
 }
+#endif
 
+#if defined(__e2k__)
+inline int
+CPU_haveAVX512F(void)
+{
+    return 0;
+}
+#else
 static int
 CPU_haveAVX512F(void)
 {
@@ -555,6 +624,7 @@ CPU_haveAVX512F(void)
     }
     return 0;
 }
+#endif
 
 static int SDL_CPUCount = 0;
 
@@ -596,6 +666,17 @@ SDL_GetCPUCount(void)
     return SDL_CPUCount;
 }
 
+#if defined(__e2k__)
+inline const char *
+SDL_GetCPUType(void)
+{
+    static char SDL_CPUType[13];
+
+    SDL_strlcpy(SDL_CPUType, "E2K MACHINE", sizeof(SDL_CPUType));
+
+    return SDL_CPUType;
+}
+#else
 /* Oh, such a sweet sweet trick, just not very useful. :) */
 static const char *
 SDL_GetCPUType(void)
@@ -631,9 +712,21 @@ SDL_GetCPUType(void)
     }
     return SDL_CPUType;
 }
+#endif
 
 
 #ifdef TEST_MAIN  /* !!! FIXME: only used for test at the moment. */
+#if defined(__e2k__)
+inline const char *
+SDL_GetCPUName(void)
+{
+    static char SDL_CPUName[48];
+
+    SDL_strlcpy(SDL_CPUName, __builtin_cpu_name(), sizeof(SDL_CPUName));
+
+    return SDL_CPUName;
+}
+#else
 static const char *
 SDL_GetCPUName(void)
 {
@@ -707,6 +800,7 @@ SDL_GetCPUName(void)
     return SDL_CPUName;
 }
 #endif
+#endif
 
 int
 SDL_GetCPUCacheLineSize(void)
@@ -937,6 +1031,13 @@ SDL_GetSystemRAM(void)
             }
         }
 #endif
+#ifdef __VITA__
+        if (SDL_SystemRAM <= 0) {
+            /* Vita has 512MiB on SoC, that's split into 256MiB(+109MiB in extended memory mode) for app
+               +26MiB of physically continuous memory, +112MiB of CDRAM(VRAM) + system reserved memory. */
+            SDL_SystemRAM = 536870912;
+        }
+#endif
 #endif
     }
     return SDL_SystemRAM;
@@ -962,7 +1063,7 @@ SDL_SIMDAlloc(const size_t len)
     Uint8 *retval = NULL;
     Uint8 *ptr = (Uint8 *) SDL_malloc(padded + alignment + sizeof (void *));
     if (ptr) {
-        /* store the actual malloc pointer right before our aligned pointer. */
+        /* store the actual allocated pointer right before our aligned pointer. */
         retval = ptr + sizeof (void *);
         retval += alignment - (((size_t) retval) % alignment);
         *(((void **) retval) - 1) = ptr;
@@ -992,14 +1093,11 @@ SDL_SIMDRealloc(void *mem, const size_t len)
 
     ptr = (Uint8 *) SDL_realloc(mem, padded + alignment + sizeof (void *));
 
-    if (ptr == mem) {
-        return retval; /* Pointer didn't change, nothing to do */
-    }
     if (ptr == NULL) {
         return NULL; /* Out of memory, bail! */
     }
 
-    /* Store the actual malloc pointer right before our aligned pointer. */
+    /* Store the actual allocated pointer right before our aligned pointer. */
     retval = ptr + sizeof (void *);
     retval += alignment - (((size_t) retval) % alignment);
 
@@ -1007,7 +1105,7 @@ SDL_SIMDRealloc(void *mem, const size_t len)
     if (mem) {
         ptrdiff = ((size_t) retval) - ((size_t) ptr);
         if (memdiff != ptrdiff) { /* Delta has changed, copy to new offset! */
-            oldmem = (void*) (((size_t) ptr) + memdiff);
+            oldmem = (void*) (((uintptr_t) ptr) + memdiff);
 
             /* Even though the data past the old `len` is undefined, this is the
              * only length value we have, and it guarantees that we copy all the
@@ -1017,7 +1115,7 @@ SDL_SIMDRealloc(void *mem, const size_t len)
         }
     }
 
-    /* Actually store the malloc pointer, finally. */
+    /* Actually store the allocated pointer, finally. */
     *(((void **) retval) - 1) = ptr;
     return retval;
 }
diff --git a/Engine/lib/sdl/src/dynapi/SDL_dynapi.c b/Engine/lib/sdl/src/dynapi/SDL_dynapi.c
index aed98848e..38df73c35 100644
--- a/Engine/lib/sdl/src/dynapi/SDL_dynapi.c
+++ b/Engine/lib/sdl/src/dynapi/SDL_dynapi.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -89,6 +89,12 @@ static void SDL_InitDynamicAPI(void);
         va_end(ap); \
         return retval; \
     } \
+    _static int SDLCALL SDL_asprintf##name(char **strp, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) { \
+        int retval; va_list ap; initcall; va_start(ap, fmt); \
+        retval = jump_table.SDL_vasprintf(strp, fmt, ap); \
+        va_end(ap); \
+        return retval; \
+    } \
     _static void SDLCALL SDL_Log##name(SDL_PRINTF_FORMAT_STRING const char *fmt, ...) { \
         va_list ap; initcall; va_start(ap, fmt); \
         jump_table.SDL_LogMessageV(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO, fmt, ap); \
@@ -270,7 +276,7 @@ static void dynapi_warn(const char *msg)
     /* SDL_ShowSimpleMessageBox() is a too heavy for here. */
     #if defined(WIN32) || defined(_WIN32) || defined(__CYGWIN__)
     MessageBoxA(NULL, msg, caption, MB_OK | MB_ICONERROR);
-    #else
+    #elif defined(HAVE_STDIO_H)
     fprintf(stderr, "\n\n%s\n%s\n\n", caption, msg);
     fflush(stderr);
     #endif
diff --git a/Engine/lib/sdl/src/dynapi/SDL_dynapi.h b/Engine/lib/sdl/src/dynapi/SDL_dynapi.h
index 764e5d978..452078b1a 100644
--- a/Engine/lib/sdl/src/dynapi/SDL_dynapi.h
+++ b/Engine/lib/sdl/src/dynapi/SDL_dynapi.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -57,6 +57,10 @@
 #define SDL_DYNAMIC_API 0
 #elif defined(__clang_analyzer__)
 #define SDL_DYNAMIC_API 0  /* Turn off for static analysis, so reports are more clear. */
+#elif defined(__VITA__)
+#define SDL_DYNAMIC_API 0  /* vitasdk doesn't support dynamic linking */
+#elif defined(DYNAPI_NEEDS_DLOPEN) && !defined(HAVE_DLOPEN)
+#define SDL_DYNAMIC_API 0  /* we need dlopen(), but don't have it.... */
 #endif
 
 /* everyone else. This is where we turn on the API if nothing forced it off. */
diff --git a/Engine/lib/sdl/src/dynapi/SDL_dynapi_overrides.h b/Engine/lib/sdl/src/dynapi/SDL_dynapi_overrides.h
index 221a19386..299dde303 100644
--- a/Engine/lib/sdl/src/dynapi/SDL_dynapi_overrides.h
+++ b/Engine/lib/sdl/src/dynapi/SDL_dynapi_overrides.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -788,3 +788,79 @@
 #define SDL_GameControllerGetSensorData SDL_GameControllerGetSensorData_REAL
 #define SDL_wcscasecmp SDL_wcscasecmp_REAL
 #define SDL_wcsncasecmp SDL_wcsncasecmp_REAL
+#define SDL_round SDL_round_REAL
+#define SDL_roundf SDL_roundf_REAL
+#define SDL_lround SDL_lround_REAL
+#define SDL_lroundf SDL_lroundf_REAL
+#define SDL_SoftStretchLinear SDL_SoftStretchLinear_REAL
+#define SDL_RenderGetD3D11Device SDL_RenderGetD3D11Device_REAL
+#define SDL_UpdateNVTexture SDL_UpdateNVTexture_REAL
+#define SDL_SetWindowKeyboardGrab SDL_SetWindowKeyboardGrab_REAL
+#define SDL_SetWindowMouseGrab SDL_SetWindowMouseGrab_REAL
+#define SDL_GetWindowKeyboardGrab SDL_GetWindowKeyboardGrab_REAL
+#define SDL_GetWindowMouseGrab SDL_GetWindowMouseGrab_REAL
+#define SDL_isalpha SDL_isalpha_REAL
+#define SDL_isalnum SDL_isalnum_REAL
+#define SDL_isblank SDL_isblank_REAL
+#define SDL_iscntrl SDL_iscntrl_REAL
+#define SDL_isxdigit SDL_isxdigit_REAL
+#define SDL_ispunct SDL_ispunct_REAL
+#define SDL_isprint SDL_isprint_REAL
+#define SDL_isgraph SDL_isgraph_REAL
+#define SDL_AndroidShowToast SDL_AndroidShowToast_REAL
+#define SDL_GetAudioDeviceSpec SDL_GetAudioDeviceSpec_REAL
+#define SDL_TLSCleanup SDL_TLSCleanup_REAL
+#define SDL_SetWindowAlwaysOnTop SDL_SetWindowAlwaysOnTop_REAL
+#define SDL_FlashWindow SDL_FlashWindow_REAL
+#define SDL_GameControllerSendEffect SDL_GameControllerSendEffect_REAL
+#define SDL_JoystickSendEffect SDL_JoystickSendEffect_REAL
+#define SDL_GameControllerGetSensorDataRate SDL_GameControllerGetSensorDataRate_REAL
+#define SDL_SetTextureUserData SDL_SetTextureUserData_REAL
+#define SDL_GetTextureUserData SDL_GetTextureUserData_REAL
+#define SDL_RenderGeometry SDL_RenderGeometry_REAL
+#define SDL_RenderGeometryRaw SDL_RenderGeometryRaw_REAL
+#define SDL_RenderSetVSync SDL_RenderSetVSync_REAL
+#define SDL_asprintf SDL_asprintf_REAL
+#define SDL_vasprintf SDL_vasprintf_REAL
+#define SDL_GetWindowICCProfile SDL_GetWindowICCProfile_REAL
+#define SDL_GetTicks64 SDL_GetTicks64_REAL
+#define SDL_LinuxSetThreadPriorityAndPolicy SDL_LinuxSetThreadPriorityAndPolicy_REAL
+#define SDL_GameControllerGetAppleSFSymbolsNameForButton SDL_GameControllerGetAppleSFSymbolsNameForButton_REAL
+#define SDL_GameControllerGetAppleSFSymbolsNameForAxis SDL_GameControllerGetAppleSFSymbolsNameForAxis_REAL
+#define SDL_hid_init SDL_hid_init_REAL
+#define SDL_hid_exit SDL_hid_exit_REAL
+#define SDL_hid_device_change_count SDL_hid_device_change_count_REAL
+#define SDL_hid_enumerate SDL_hid_enumerate_REAL
+#define SDL_hid_free_enumeration SDL_hid_free_enumeration_REAL
+#define SDL_hid_open SDL_hid_open_REAL
+#define SDL_hid_open_path SDL_hid_open_path_REAL
+#define SDL_hid_write SDL_hid_write_REAL
+#define SDL_hid_read_timeout SDL_hid_read_timeout_REAL
+#define SDL_hid_read SDL_hid_read_REAL
+#define SDL_hid_set_nonblocking SDL_hid_set_nonblocking_REAL
+#define SDL_hid_send_feature_report SDL_hid_send_feature_report_REAL
+#define SDL_hid_get_feature_report SDL_hid_get_feature_report_REAL
+#define SDL_hid_close SDL_hid_close_REAL
+#define SDL_hid_get_manufacturer_string SDL_hid_get_manufacturer_string_REAL
+#define SDL_hid_get_product_string SDL_hid_get_product_string_REAL
+#define SDL_hid_get_serial_number_string SDL_hid_get_serial_number_string_REAL
+#define SDL_hid_get_indexed_string SDL_hid_get_indexed_string_REAL
+#define SDL_SetWindowMouseRect SDL_SetWindowMouseRect_REAL
+#define SDL_GetWindowMouseRect SDL_GetWindowMouseRect_REAL
+#define SDL_RenderWindowToLogical SDL_RenderWindowToLogical_REAL
+#define SDL_RenderLogicalToWindow SDL_RenderLogicalToWindow_REAL
+#define SDL_JoystickHasRumble SDL_JoystickHasRumble_REAL
+#define SDL_JoystickHasRumbleTriggers SDL_JoystickHasRumbleTriggers_REAL
+#define SDL_GameControllerHasRumble SDL_GameControllerHasRumble_REAL
+#define SDL_GameControllerHasRumbleTriggers SDL_GameControllerHasRumbleTriggers_REAL
+#define SDL_hid_ble_scan SDL_hid_ble_scan_REAL
+#define SDL_PremultiplyAlpha SDL_PremultiplyAlpha_REAL
+#define SDL_AndroidSendMessage SDL_AndroidSendMessage_REAL
+#define SDL_GetTouchName SDL_GetTouchName_REAL
+#define SDL_ClearComposition SDL_ClearComposition_REAL
+#define SDL_IsTextInputShown SDL_IsTextInputShown_REAL
+#define SDL_HasIntersectionF SDL_HasIntersectionF_REAL
+#define SDL_IntersectFRect SDL_IntersectFRect_REAL
+#define SDL_UnionFRect SDL_UnionFRect_REAL
+#define SDL_EncloseFPoints SDL_EncloseFPoints_REAL
+#define SDL_IntersectFRectAndLine SDL_IntersectFRectAndLine_REAL
diff --git a/Engine/lib/sdl/src/dynapi/SDL_dynapi_procs.h b/Engine/lib/sdl/src/dynapi/SDL_dynapi_procs.h
index 4aee1c404..2c0d5b03e 100644
--- a/Engine/lib/sdl/src/dynapi/SDL_dynapi_procs.h
+++ b/Engine/lib/sdl/src/dynapi/SDL_dynapi_procs.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -63,7 +63,7 @@ SDL_DYNAPI_PROC(SDL_RWops*,SDL_RWFromFP,(void *a, SDL_bool b),(a,b),return)
 #endif
 
 #ifdef __WIN32__
-SDL_DYNAPI_PROC(int,SDL_RegisterApp,(char *a, Uint32 b, void *c),(a,b,c),return)
+SDL_DYNAPI_PROC(int,SDL_RegisterApp,(const char *a, Uint32 b, void *c),(a,b,c),return)
 SDL_DYNAPI_PROC(void,SDL_UnregisterApp,(void),(),)
 SDL_DYNAPI_PROC(int,SDL_Direct3D9GetAdapterIndex,(int a),(a),return)
 SDL_DYNAPI_PROC(IDirect3DDevice9*,SDL_RenderGetD3D9Device,(SDL_Renderer *a),(a),return)
@@ -849,3 +849,89 @@ SDL_DYNAPI_PROC(SDL_bool,SDL_GameControllerIsSensorEnabled,(SDL_GameController *
 SDL_DYNAPI_PROC(int,SDL_GameControllerGetSensorData,(SDL_GameController *a, SDL_SensorType b, float *c, int d),(a,b,c,d),return)
 SDL_DYNAPI_PROC(int,SDL_wcscasecmp,(const wchar_t *a, const wchar_t *b),(a,b),return)
 SDL_DYNAPI_PROC(int,SDL_wcsncasecmp,(const wchar_t *a, const wchar_t *b, size_t c),(a,b,c),return)
+SDL_DYNAPI_PROC(double,SDL_round,(double a),(a),return)
+SDL_DYNAPI_PROC(float,SDL_roundf,(float a),(a),return)
+SDL_DYNAPI_PROC(long,SDL_lround,(double a),(a),return)
+SDL_DYNAPI_PROC(long,SDL_lroundf,(float a),(a),return)
+SDL_DYNAPI_PROC(int,SDL_SoftStretchLinear,(SDL_Surface *a, const SDL_Rect *b, SDL_Surface *c, const SDL_Rect *d),(a,b,c,d),return)
+#ifdef __WIN32__
+SDL_DYNAPI_PROC(ID3D11Device*,SDL_RenderGetD3D11Device,(SDL_Renderer *a),(a),return)
+#endif
+SDL_DYNAPI_PROC(int,SDL_UpdateNVTexture,(SDL_Texture *a, const SDL_Rect *b, const Uint8 *c, int d, const Uint8 *e, int f),(a,b,c,d,e,f),return)
+SDL_DYNAPI_PROC(void,SDL_SetWindowKeyboardGrab,(SDL_Window *a, SDL_bool b),(a,b),)
+SDL_DYNAPI_PROC(void,SDL_SetWindowMouseGrab,(SDL_Window *a, SDL_bool b),(a,b),)
+SDL_DYNAPI_PROC(SDL_bool,SDL_GetWindowKeyboardGrab,(SDL_Window *a),(a),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_GetWindowMouseGrab,(SDL_Window *a),(a),return)
+SDL_DYNAPI_PROC(int,SDL_isalpha,(int a),(a),return)
+SDL_DYNAPI_PROC(int,SDL_isalnum,(int a),(a),return)
+SDL_DYNAPI_PROC(int,SDL_isblank,(int a),(a),return)
+SDL_DYNAPI_PROC(int,SDL_iscntrl,(int a),(a),return)
+SDL_DYNAPI_PROC(int,SDL_isxdigit,(int a),(a),return)
+SDL_DYNAPI_PROC(int,SDL_ispunct,(int a),(a),return)
+SDL_DYNAPI_PROC(int,SDL_isprint,(int a),(a),return)
+SDL_DYNAPI_PROC(int,SDL_isgraph,(int a),(a),return)
+#ifdef __ANDROID__
+SDL_DYNAPI_PROC(int,SDL_AndroidShowToast,(const char *a, int b, int c, int d, int e),(a,b,c,d,e),return)
+#endif
+SDL_DYNAPI_PROC(int,SDL_GetAudioDeviceSpec,(int a, int b, SDL_AudioSpec *c),(a,b,c),return)
+SDL_DYNAPI_PROC(void,SDL_TLSCleanup,(void),(),)
+SDL_DYNAPI_PROC(void,SDL_SetWindowAlwaysOnTop,(SDL_Window *a, SDL_bool b),(a,b),)
+SDL_DYNAPI_PROC(int,SDL_FlashWindow,(SDL_Window *a, SDL_FlashOperation b),(a,b),return)
+SDL_DYNAPI_PROC(int,SDL_GameControllerSendEffect,(SDL_GameController *a, const void *b, int c),(a,b,c),return)
+SDL_DYNAPI_PROC(int,SDL_JoystickSendEffect,(SDL_Joystick *a, const void *b, int c),(a,b,c),return)
+SDL_DYNAPI_PROC(float,SDL_GameControllerGetSensorDataRate,(SDL_GameController *a, SDL_SensorType b),(a,b),return)
+SDL_DYNAPI_PROC(int,SDL_SetTextureUserData,(SDL_Texture *a, void *b),(a,b),return)
+SDL_DYNAPI_PROC(void*,SDL_GetTextureUserData,(SDL_Texture *a),(a),return)
+SDL_DYNAPI_PROC(int,SDL_RenderGeometry,(SDL_Renderer *a, SDL_Texture *b, const SDL_Vertex *c, int d, const int *e, int f),(a,b,c,d,e,f),return)
+SDL_DYNAPI_PROC(int,SDL_RenderGeometryRaw,(SDL_Renderer *a, SDL_Texture *b, const float *c, int d, const SDL_Color *e, int f, const float *g, int h, int i, const void *j, int k, int l),(a,b,c,d,e,f,g,h,i,j,k,l),return)
+SDL_DYNAPI_PROC(int,SDL_RenderSetVSync,(SDL_Renderer *a, int b),(a,b),return)
+#if !SDL_DYNAPI_PROC_NO_VARARGS
+SDL_DYNAPI_PROC(int,SDL_asprintf,(char **a, SDL_PRINTF_FORMAT_STRING const char *b, ...),(a,b),return)
+#endif
+SDL_DYNAPI_PROC(int,SDL_vasprintf,(char **a, const char *b, va_list c),(a,b,c),return)
+SDL_DYNAPI_PROC(void*,SDL_GetWindowICCProfile,(SDL_Window *a, size_t *b),(a,b),return)
+SDL_DYNAPI_PROC(Uint64,SDL_GetTicks64,(void),(),return)
+#ifdef __LINUX__
+SDL_DYNAPI_PROC(int,SDL_LinuxSetThreadPriorityAndPolicy,(Sint64 a, int b, int c),(a,b,c),return)
+#endif
+SDL_DYNAPI_PROC(const char*,SDL_GameControllerGetAppleSFSymbolsNameForButton,(SDL_GameController *a, SDL_GameControllerButton b),(a,b),return)
+SDL_DYNAPI_PROC(const char*,SDL_GameControllerGetAppleSFSymbolsNameForAxis,(SDL_GameController *a, SDL_GameControllerAxis b),(a,b),return)
+SDL_DYNAPI_PROC(int,SDL_hid_init,(void),(),return)
+SDL_DYNAPI_PROC(int,SDL_hid_exit,(void),(),return)
+SDL_DYNAPI_PROC(Uint32,SDL_hid_device_change_count,(void),(),return)
+SDL_DYNAPI_PROC(SDL_hid_device_info*,SDL_hid_enumerate,(unsigned short a, unsigned short b),(a,b),return)
+SDL_DYNAPI_PROC(void,SDL_hid_free_enumeration,(SDL_hid_device_info *a),(a),)
+SDL_DYNAPI_PROC(SDL_hid_device*,SDL_hid_open,(unsigned short a, unsigned short b, const wchar_t *c),(a,b,c),return)
+SDL_DYNAPI_PROC(SDL_hid_device*,SDL_hid_open_path,(const char *a, int b),(a,b),return)
+SDL_DYNAPI_PROC(int,SDL_hid_write,(SDL_hid_device *a, const unsigned char *b, size_t c),(a,b,c),return)
+SDL_DYNAPI_PROC(int,SDL_hid_read_timeout,(SDL_hid_device *a, unsigned char *b, size_t c, int d),(a,b,c,d),return)
+SDL_DYNAPI_PROC(int,SDL_hid_read,(SDL_hid_device *a, unsigned char *b, size_t c),(a,b,c),return)
+SDL_DYNAPI_PROC(int,SDL_hid_set_nonblocking,(SDL_hid_device *a, int b),(a,b),return)
+SDL_DYNAPI_PROC(int,SDL_hid_send_feature_report,(SDL_hid_device *a, const unsigned char *b, size_t c),(a,b,c),return)
+SDL_DYNAPI_PROC(int,SDL_hid_get_feature_report,(SDL_hid_device *a, unsigned char *b, size_t c),(a,b,c),return)
+SDL_DYNAPI_PROC(void,SDL_hid_close,(SDL_hid_device *a),(a),)
+SDL_DYNAPI_PROC(int,SDL_hid_get_manufacturer_string,(SDL_hid_device *a, wchar_t *b, size_t c),(a,b,c),return)
+SDL_DYNAPI_PROC(int,SDL_hid_get_product_string,(SDL_hid_device *a, wchar_t *b, size_t c),(a,b,c),return)
+SDL_DYNAPI_PROC(int,SDL_hid_get_serial_number_string,(SDL_hid_device *a, wchar_t *b, size_t c),(a,b,c),return)
+SDL_DYNAPI_PROC(int,SDL_hid_get_indexed_string,(SDL_hid_device *a, int b, wchar_t *c, size_t d),(a,b,c,d),return)
+SDL_DYNAPI_PROC(int,SDL_SetWindowMouseRect,(SDL_Window *a, const SDL_Rect *b),(a,b),return)
+SDL_DYNAPI_PROC(const SDL_Rect*,SDL_GetWindowMouseRect,(SDL_Window *a),(a),return)
+SDL_DYNAPI_PROC(void,SDL_RenderWindowToLogical,(SDL_Renderer *a, int b, int c, float *d, float *e),(a,b,c,d,e),)
+SDL_DYNAPI_PROC(void,SDL_RenderLogicalToWindow,(SDL_Renderer *a, float b, float c, int *d, int *e),(a,b,c,d,e),)
+SDL_DYNAPI_PROC(SDL_bool,SDL_JoystickHasRumble,(SDL_Joystick *a),(a),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_JoystickHasRumbleTriggers,(SDL_Joystick *a),(a),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_GameControllerHasRumble,(SDL_GameController *a),(a),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_GameControllerHasRumbleTriggers,(SDL_GameController *a),(a),return)
+SDL_DYNAPI_PROC(void,SDL_hid_ble_scan,(SDL_bool a),(a),)
+SDL_DYNAPI_PROC(int,SDL_PremultiplyAlpha,(int a, int b, Uint32 c, const void *d, int e, Uint32 f, void *g, int h),(a,b,c,d,e,f,g,h),return)
+#ifdef __ANDROID__
+SDL_DYNAPI_PROC(int,SDL_AndroidSendMessage,(Uint32 a, int b),(a,b),return)
+#endif
+SDL_DYNAPI_PROC(const char*,SDL_GetTouchName,(int a),(a),return)
+SDL_DYNAPI_PROC(void,SDL_ClearComposition,(void),(),)
+SDL_DYNAPI_PROC(SDL_bool,SDL_IsTextInputShown,(void),(),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_HasIntersectionF,(const SDL_FRect *a, const SDL_FRect *b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_IntersectFRect,(const SDL_FRect *a, const SDL_FRect *b, SDL_FRect *c),(a,b,c),return)
+SDL_DYNAPI_PROC(void,SDL_UnionFRect,(const SDL_FRect *a, const SDL_FRect *b, SDL_FRect *c),(a,b,c),)
+SDL_DYNAPI_PROC(SDL_bool,SDL_EncloseFPoints,(const SDL_FPoint *a, int b, const SDL_FRect *c, SDL_FRect *d),(a,b,c,d),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_IntersectFRectAndLine,(const SDL_FRect *a, float *b, float *c, float *d, float *e),(a,b,c,d,e),return)
diff --git a/Engine/lib/sdl/src/dynapi/gendynapi.pl b/Engine/lib/sdl/src/dynapi/gendynapi.pl
index ee65e6b0d..b99a8a492 100755
--- a/Engine/lib/sdl/src/dynapi/gendynapi.pl
+++ b/Engine/lib/sdl/src/dynapi/gendynapi.pl
@@ -1,7 +1,7 @@
 #!/usr/bin/perl -w
 
 #  Simple DirectMedia Layer
-#  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+#  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 #
 #  This software is provided 'as-is', without any express or implied
 #  warranty.  In no event will the authors be held liable for any damages
@@ -21,7 +21,7 @@
 
 # WHAT IS THIS?
 #  When you add a public API to SDL, please run this script, make sure the
-#  output looks sane (hg diff, it adds to existing files), and commit it.
+#  output looks sane (git diff, it adds to existing files), and commit it.
 #  It keeps the dynamic API jump table operating correctly.
 
 # If you wanted this to be readable, you shouldn't have used perl.
@@ -55,7 +55,7 @@ while (my $d = readdir(HEADERS)) {
     open(HEADER, '<', $header) or die("Can't open $header: $!\n");
     while (<HEADER>) {
         chomp;
-        next if not /\A\s*extern\s+DECLSPEC/;
+        next if not /\A\s*extern\s+(SDL_DEPRECATED\s+|)DECLSPEC/;
         my $decl = "$_ ";
         if (not $decl =~ /\)\s*;/) {
             while (<HEADER>) {
@@ -70,13 +70,13 @@ while (my $d = readdir(HEADERS)) {
         $decl =~ s/\s+\Z//;
         #print("DECL: [$decl]\n");
 
-        if ($decl =~ /\A\s*extern\s+DECLSPEC\s+(const\s+|)(unsigned\s+|)(.*?)\s*(\*?)\s*SDLCALL\s+(.*?)\s*\((.*?)\);/) {
-            my $rc = "$1$2$3$4";
-            my $fn = $5;
+        if ($decl =~ /\A\s*extern\s+(SDL_DEPRECATED\s+|)DECLSPEC\s+(const\s+|)(unsigned\s+|)(.*?)\s*(\*?)\s*SDLCALL\s+(.*?)\s*\((.*?)\);/) {
+            my $rc = "$2$3$4$5";
+            my $fn = $6;
 
             next if $existing{$fn};   # already slotted into the jump table.
 
-            my @params = split(',', $6);
+            my @params = split(',', $7);
 
             #print("rc == '$rc', fn == '$fn', params == '$params'\n");
 
@@ -107,13 +107,19 @@ while (my $d = readdir(HEADERS)) {
                     $type =~ s/\s*\*\Z/*/g;
                     $type =~ s/\s*(\*+)\Z/ $1/;
                     #print("SPLIT: ($type, $var)\n");
+                    my $var_array_suffix = "";
+                    # parse array suffix
+                    if ($var =~ /\A.*(\[.*\])\Z/) {
+                        #print("PARSED ARRAY SUFFIX: [$1] of '$var'\n");
+                        $var_array_suffix = $1;
+                    }
                     my $name = chr(ord('a') + $i);
                     if ($i > 0) {
                         $paramstr .= ', ';
                         $argstr .= ',';
                     }
                     my $spc = ($type =~ /\*\Z/) ? '' : ' ';
-                    $paramstr .= "$type$spc$name";
+                    $paramstr .= "$type$spc$name$var_array_suffix";
                     $argstr .= "$name";
                 }
                 $i++;
diff --git a/Engine/lib/sdl/src/events/SDL_clipboardevents.c b/Engine/lib/sdl/src/events/SDL_clipboardevents.c
index c3c0f1913..a3247dd80 100644
--- a/Engine/lib/sdl/src/events/SDL_clipboardevents.c
+++ b/Engine/lib/sdl/src/events/SDL_clipboardevents.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/events/SDL_clipboardevents_c.h b/Engine/lib/sdl/src/events/SDL_clipboardevents_c.h
index cae62b7ca..21d5227cb 100644
--- a/Engine/lib/sdl/src/events/SDL_clipboardevents_c.h
+++ b/Engine/lib/sdl/src/events/SDL_clipboardevents_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/events/SDL_displayevents.c b/Engine/lib/sdl/src/events/SDL_displayevents.c
index 9bb556ce6..c6a701ab5 100644
--- a/Engine/lib/sdl/src/events/SDL_displayevents.c
+++ b/Engine/lib/sdl/src/events/SDL_displayevents.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/events/SDL_displayevents_c.h b/Engine/lib/sdl/src/events/SDL_displayevents_c.h
index 961a54427..07be5e0e0 100644
--- a/Engine/lib/sdl/src/events/SDL_displayevents_c.h
+++ b/Engine/lib/sdl/src/events/SDL_displayevents_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/events/SDL_dropevents.c b/Engine/lib/sdl/src/events/SDL_dropevents.c
index a60fb0d18..daefeb09b 100644
--- a/Engine/lib/sdl/src/events/SDL_dropevents.c
+++ b/Engine/lib/sdl/src/events/SDL_dropevents.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/events/SDL_dropevents_c.h b/Engine/lib/sdl/src/events/SDL_dropevents_c.h
index 7c0599ad1..4f45b78d8 100644
--- a/Engine/lib/sdl/src/events/SDL_dropevents_c.h
+++ b/Engine/lib/sdl/src/events/SDL_dropevents_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/events/SDL_events.c b/Engine/lib/sdl/src/events/SDL_events.c
index a57bdd529..caa8b87eb 100644
--- a/Engine/lib/sdl/src/events/SDL_events.c
+++ b/Engine/lib/sdl/src/events/SDL_events.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -26,6 +26,7 @@
 #include "SDL_events.h"
 #include "SDL_thread.h"
 #include "SDL_events_c.h"
+#include "../SDL_hints_c.h"
 #include "../timer/SDL_timer_c.h"
 #if !SDL_JOYSTICK_DISABLED
 #include "../joystick/SDL_joystick_c.h"
@@ -34,7 +35,7 @@
 #include "SDL_syswm.h"
 
 #undef SDL_PRIs64
-#ifdef __WIN32__
+#if defined(__WIN32__) && !defined(__CYGWIN__)
 #define SDL_PRIs64  "I64d"
 #else
 #define SDL_PRIs64  "lld"
@@ -43,6 +44,9 @@
 /* An arbitrary limit so we don't have unbounded growth */
 #define SDL_MAX_QUEUED_EVENTS   65535
 
+/* Determines how often we wake to call SDL_PumpEvents() in SDL_WaitEventTimeout_Device() */
+#define PERIODIC_POLL_INTERVAL_MS 3000
+
 typedef struct SDL_EventWatcher {
     SDL_EventFilter callback;
     void *userdata;
@@ -55,6 +59,7 @@ static SDL_EventWatcher *SDL_event_watchers = NULL;
 static int SDL_event_watchers_count = 0;
 static SDL_bool SDL_event_watchers_dispatching = SDL_FALSE;
 static SDL_bool SDL_event_watchers_removed = SDL_FALSE;
+static SDL_atomic_t SDL_sentinel_pending;
 
 typedef struct {
     Uint32 bits[8];
@@ -139,6 +144,11 @@ SDL_AutoUpdateSensorsChanged(void *userdata, const char *name, const char *oldVa
 
 #endif /* !SDL_SENSOR_DISABLED */
 
+static void SDLCALL
+SDL_PollSentinelChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
+{
+    SDL_EventState(SDL_POLLSENTINEL, SDL_GetStringBoolean(hint, SDL_TRUE) ? SDL_ENABLE : SDL_DISABLE);
+}
 
 /* 0 (default) means no logging, 1 means logging, 2 means logging with mouse and finger motion */
 static int SDL_DoEventLogging = 0;
@@ -146,7 +156,7 @@ static int SDL_DoEventLogging = 0;
 static void SDLCALL
 SDL_EventLoggingChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
 {
-    SDL_DoEventLogging = (hint && *hint) ? SDL_max(SDL_min(SDL_atoi(hint), 2), 0) : 0;
+    SDL_DoEventLogging = (hint && *hint) ? SDL_clamp(SDL_atoi(hint), 0, 2) : 0;
 }
 
 static void
@@ -155,10 +165,13 @@ SDL_LogEvent(const SDL_Event *event)
     char name[32];
     char details[128];
 
-    /* mouse/finger motion are spammy, ignore these if they aren't demanded. */
+    /* sensor/mouse/finger motion are spammy, ignore these if they aren't demanded. */
     if ( (SDL_DoEventLogging < 2) &&
             ( (event->type == SDL_MOUSEMOTION) ||
-              (event->type == SDL_FINGERMOTION) ) ) {
+              (event->type == SDL_FINGERMOTION) ||
+              (event->type == SDL_CONTROLLERTOUCHPADMOTION) ||
+              (event->type == SDL_CONTROLLERSENSORUPDATE) ||
+              (event->type == SDL_SENSORUPDATE) ) ) {
         return;
     }
 
@@ -193,11 +206,28 @@ SDL_LogEvent(const SDL_Event *event)
         SDL_EVENT_CASE(SDL_APP_DIDENTERBACKGROUND) break;
         SDL_EVENT_CASE(SDL_APP_WILLENTERFOREGROUND) break;
         SDL_EVENT_CASE(SDL_APP_DIDENTERFOREGROUND) break;
+        SDL_EVENT_CASE(SDL_LOCALECHANGED) break;
         SDL_EVENT_CASE(SDL_KEYMAPCHANGED) break;
         SDL_EVENT_CASE(SDL_CLIPBOARDUPDATE) break;
         SDL_EVENT_CASE(SDL_RENDER_TARGETS_RESET) break;
         SDL_EVENT_CASE(SDL_RENDER_DEVICE_RESET) break;
 
+        SDL_EVENT_CASE(SDL_DISPLAYEVENT) {
+            char name2[64];
+            switch (event->display.event) {
+                case SDL_DISPLAYEVENT_NONE: SDL_strlcpy(name2, "SDL_DISPLAYEVENT_NONE (THIS IS PROBABLY A BUG!)", sizeof(name2)); break;
+                #define SDL_DISPLAYEVENT_CASE(x) case x: SDL_strlcpy(name2, #x, sizeof (name2)); break
+                SDL_DISPLAYEVENT_CASE(SDL_DISPLAYEVENT_ORIENTATION);
+                SDL_DISPLAYEVENT_CASE(SDL_DISPLAYEVENT_CONNECTED);
+                SDL_DISPLAYEVENT_CASE(SDL_DISPLAYEVENT_DISCONNECTED);
+                #undef SDL_DISPLAYEVENT_CASE
+                default: SDL_strlcpy(name2, "UNKNOWN (bug? fixme?)", sizeof(name2)); break;
+            }
+            SDL_snprintf(details, sizeof (details), " (timestamp=%u display=%u event=%s data1=%d)",
+                        (uint) event->display.timestamp, (uint) event->display.display, name2, (int) event->display.data1);
+            break;
+        }
+
         SDL_EVENT_CASE(SDL_WINDOWEVENT) {
             char name2[64];
             switch(event->window.event) {
@@ -219,6 +249,8 @@ SDL_LogEvent(const SDL_Event *event)
                 SDL_WINDOWEVENT_CASE(SDL_WINDOWEVENT_CLOSE);
                 SDL_WINDOWEVENT_CASE(SDL_WINDOWEVENT_TAKE_FOCUS);
                 SDL_WINDOWEVENT_CASE(SDL_WINDOWEVENT_HIT_TEST);
+                SDL_WINDOWEVENT_CASE(SDL_WINDOWEVENT_ICCPROF_CHANGED);
+                SDL_WINDOWEVENT_CASE(SDL_WINDOWEVENT_DISPLAY_CHANGED);
                 #undef SDL_WINDOWEVENT_CASE
                 default: SDL_strlcpy(name2, "UNKNOWN (bug? fixme?)", sizeof (name2)); break;
             }
@@ -275,9 +307,10 @@ SDL_LogEvent(const SDL_Event *event)
 
 
         SDL_EVENT_CASE(SDL_MOUSEWHEEL)
-            SDL_snprintf(details, sizeof (details), " (timestamp=%u windowid=%u which=%u x=%d y=%d direction=%s)",
+            SDL_snprintf(details, sizeof (details), " (timestamp=%u windowid=%u which=%u x=%d y=%d preciseX=%f preciseY=%f direction=%s)",
                     (uint) event->wheel.timestamp, (uint) event->wheel.windowID,
                     (uint) event->wheel.which, (int) event->wheel.x, (int) event->wheel.y,
+                    event->wheel.preciseX, event->wheel.preciseY,
                     event->wheel.direction == SDL_MOUSEWHEEL_NORMAL ? "normal" : "flipped");
             break;
 
@@ -332,6 +365,22 @@ SDL_LogEvent(const SDL_Event *event)
         SDL_EVENT_CASE(SDL_CONTROLLERDEVICEREMAPPED) PRINT_CONTROLLERDEV_EVENT(event); break;
         #undef PRINT_CONTROLLERDEV_EVENT
 
+        #define PRINT_CTOUCHPAD_EVENT(event) \
+            SDL_snprintf(details, sizeof (details), " (timestamp=%u which=%d touchpad=%d finger=%d x=%f y=%f pressure=%f)", \
+                (uint) event->ctouchpad.timestamp, (int) event->ctouchpad.which, \
+                (int) event->ctouchpad.touchpad, (int) event->ctouchpad.finger, \
+                event->ctouchpad.x, event->ctouchpad.y, event->ctouchpad.pressure)
+        SDL_EVENT_CASE(SDL_CONTROLLERTOUCHPADDOWN) PRINT_CTOUCHPAD_EVENT(event); break;
+        SDL_EVENT_CASE(SDL_CONTROLLERTOUCHPADUP) PRINT_CTOUCHPAD_EVENT(event); break;
+        SDL_EVENT_CASE(SDL_CONTROLLERTOUCHPADMOTION) PRINT_CTOUCHPAD_EVENT(event); break;
+        #undef PRINT_CTOUCHPAD_EVENT
+
+       SDL_EVENT_CASE(SDL_CONTROLLERSENSORUPDATE)
+            SDL_snprintf(details, sizeof (details), " (timestamp=%u which=%d sensor=%d data[0]=%f data[1]=%f data[2]=%f)", \
+                (uint) event->csensor.timestamp, (int) event->csensor.which, (int) event->csensor.sensor, \
+                event->csensor.data[0], event->csensor.data[1], event->csensor.data[2]);
+            break;
+
         #define PRINT_FINGER_EVENT(event) \
             SDL_snprintf(details, sizeof (details), " (timestamp=%u touchid=%"SDL_PRIs64" fingerid=%"SDL_PRIs64" x=%f y=%f dx=%f dy=%f pressure=%f)", \
                 (uint) event->tfinger.timestamp, (long long)event->tfinger.touchId, \
@@ -370,8 +419,19 @@ SDL_LogEvent(const SDL_Event *event)
         SDL_EVENT_CASE(SDL_AUDIODEVICEREMOVED) PRINT_AUDIODEV_EVENT(event); break;
         #undef PRINT_AUDIODEV_EVENT
 
+        SDL_EVENT_CASE(SDL_SENSORUPDATE)
+            SDL_snprintf(details, sizeof (details), " (timestamp=%u which=%d data[0]=%f data[1]=%f data[2]=%f data[3]=%f data[4]=%f data[5]=%f)", \
+                (uint) event->sensor.timestamp, (int) event->sensor.which, \
+                event->sensor.data[0], event->sensor.data[1], event->sensor.data[2], \
+                event->sensor.data[3], event->sensor.data[4], event->sensor.data[5]);
+            break;
+
         #undef SDL_EVENT_CASE
 
+        case SDL_POLLSENTINEL:
+            /* No logging necessary for this one */
+            break;
+
         default:
             if (!name[0]) {
                 SDL_strlcpy(name, "UNKNOWN", sizeof (name));
@@ -439,6 +499,7 @@ SDL_StopEventLoop(void)
     SDL_EventQ.free = NULL;
     SDL_EventQ.wmmsg_used = NULL;
     SDL_EventQ.wmmsg_free = NULL;
+    SDL_AtomicSet(&SDL_sentinel_pending, 0);
 
     /* Clear disabled event state */
     for (i = 0; i < SDL_arraysize(SDL_disabled_events); ++i) {
@@ -534,7 +595,9 @@ SDL_AddEvent(SDL_Event * event)
     }
 
     entry->event = *event;
-    if (event->type == SDL_SYSWMEVENT) {
+    if (event->type == SDL_POLLSENTINEL) {
+        SDL_AtomicAdd(&SDL_sentinel_pending, 1);
+    } else if (event->type == SDL_SYSWMEVENT) {
         entry->msg = *event->syswm.msg;
         entry->event.syswm.msg = &entry->msg;
     }
@@ -580,23 +643,48 @@ SDL_CutEvent(SDL_EventEntry *entry)
         SDL_EventQ.tail = entry->prev;
     }
 
+    if (entry->event.type == SDL_POLLSENTINEL) {
+        SDL_AtomicAdd(&SDL_sentinel_pending, -1);
+    }
+
     entry->next = SDL_EventQ.free;
     SDL_EventQ.free = entry;
     SDL_assert(SDL_AtomicGet(&SDL_EventQ.count) > 0);
     SDL_AtomicAdd(&SDL_EventQ.count, -1);
 }
 
-/* Lock the event queue, take a peep at it, and unlock it */
-int
-SDL_PeepEvents(SDL_Event * events, int numevents, SDL_eventaction action,
-               Uint32 minType, Uint32 maxType)
+static int
+SDL_SendWakeupEvent()
 {
-    int i, used;
+    SDL_VideoDevice *_this = SDL_GetVideoDevice();
+    if (!_this || !_this->SendWakeupEvent) {
+        return 0;
+    }
+    if (!_this->wakeup_lock || SDL_LockMutex(_this->wakeup_lock) == 0) {
+        if (_this->wakeup_window) {
+            _this->SendWakeupEvent(_this, _this->wakeup_window);
+
+            /* No more wakeup events needed until we enter a new wait */
+            _this->wakeup_window = NULL;
+        }
+        if (_this->wakeup_lock) {
+            SDL_UnlockMutex(_this->wakeup_lock);
+        }
+    }
+    return 0;
+}
+
+/* Lock the event queue, take a peep at it, and unlock it */
+static int
+SDL_PeepEventsInternal(SDL_Event * events, int numevents, SDL_eventaction action,
+               Uint32 minType, Uint32 maxType, SDL_bool include_sentinel)
+{
+    int i, used, sentinels_expected = 0;
 
     /* Don't look after we've quit */
     if (!SDL_AtomicGet(&SDL_EventQ.active)) {
         /* We get a few spurious events at shutdown, so don't warn then */
-        if (action != SDL_ADDEVENT) {
+        if (action == SDL_GETEVENT) {
             SDL_SetError("The event system has been shut down");
         }
         return (-1);
@@ -652,6 +740,20 @@ SDL_PeepEvents(SDL_Event * events, int numevents, SDL_eventaction action,
                             SDL_CutEvent(entry);
                         }
                     }
+                    if (type == SDL_POLLSENTINEL) {
+                        /* Special handling for the sentinel event */
+                        if (!include_sentinel) {
+                            /* Skip it, we don't want to include it */
+                            continue;
+                        }
+                        if (!events || action != SDL_GETEVENT) {
+                            ++sentinels_expected;
+                        }
+                        if (SDL_AtomicGet(&SDL_sentinel_pending) > sentinels_expected) {
+                            /* Skip it, there's another one pending */
+                            continue;
+                        }
+                    }
                     ++used;
                 }
             }
@@ -662,8 +764,19 @@ SDL_PeepEvents(SDL_Event * events, int numevents, SDL_eventaction action,
     } else {
         return SDL_SetError("Couldn't lock event queue");
     }
+
+    if (used > 0 && action == SDL_ADDEVENT) {
+        SDL_SendWakeupEvent();
+    }
+
     return (used);
 }
+int
+SDL_PeepEvents(SDL_Event * events, int numevents, SDL_eventaction action,
+               Uint32 minType, Uint32 maxType)
+{
+    return SDL_PeepEventsInternal(events, numevents, action, minType, maxType, SDL_FALSE);
+}
 
 SDL_bool
 SDL_HasEvent(Uint32 type)
@@ -721,8 +834,8 @@ SDL_FlushEvents(Uint32 minType, Uint32 maxType)
 }
 
 /* Run the system dependent event loops */
-void
-SDL_PumpEvents(void)
+static void
+SDL_PumpEventsInternal(SDL_bool push_sentinel)
 {
     SDL_VideoDevice *_this = SDL_GetVideoDevice();
 
@@ -749,6 +862,20 @@ SDL_PumpEvents(void)
 #endif
 
     SDL_SendPendingSignalEvents();  /* in case we had a signal handler fire, etc. */
+
+    if (push_sentinel && SDL_GetEventState(SDL_POLLSENTINEL) == SDL_ENABLE) {
+        SDL_Event sentinel;
+
+        SDL_zero(sentinel);
+        sentinel.type = SDL_POLLSENTINEL;
+        SDL_PushEvent(&sentinel);
+    }
+}
+
+void
+SDL_PumpEvents()
+{
+    SDL_PumpEventsInternal(SDL_FALSE);
 }
 
 /* Public functions */
@@ -759,6 +886,124 @@ SDL_PollEvent(SDL_Event * event)
     return SDL_WaitEventTimeout(event, 0);
 }
 
+static SDL_bool
+SDL_events_need_periodic_poll() {
+    SDL_bool need_periodic_poll = SDL_FALSE;
+
+#if !SDL_JOYSTICK_DISABLED
+    need_periodic_poll =
+        SDL_WasInit(SDL_INIT_JOYSTICK) &&
+        (!SDL_disabled_events[SDL_JOYAXISMOTION >> 8] || SDL_JoystickEventState(SDL_QUERY));
+#endif
+
+#if !SDL_SENSOR_DISABLED
+    need_periodic_poll = need_periodic_poll ||
+        (SDL_WasInit(SDL_INIT_SENSOR) && !SDL_disabled_events[SDL_SENSORUPDATE >> 8]);
+#endif
+
+    return need_periodic_poll;
+}
+
+static int
+SDL_WaitEventTimeout_Device(_THIS, SDL_Window *wakeup_window, SDL_Event * event, Uint32 start, int timeout)
+{
+    int loop_timeout = timeout;
+    SDL_bool need_periodic_poll = SDL_events_need_periodic_poll();
+
+    for (;;) {
+        /* Pump events on entry and each time we wake to ensure:
+           a) All pending events are batch processed after waking up from a wait
+           b) Waiting can be completely skipped if events are already available to be pumped
+           c) Periodic processing that takes place in some platform PumpEvents() functions happens
+           d) Signals received in WaitEventTimeout() are turned into SDL events
+        */
+        /* We only want a single sentinel in the queue. We could get more than one if event is NULL,
+         * since the SDL_PeepEvents() call below won't remove it in that case.
+         */
+        SDL_bool add_sentinel = (SDL_AtomicGet(&SDL_sentinel_pending) == 0) ? SDL_TRUE : SDL_FALSE;
+        SDL_PumpEventsInternal(add_sentinel);
+
+        if (!_this->wakeup_lock || SDL_LockMutex(_this->wakeup_lock) == 0) {
+            int status = SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT);
+            /* If status == 0 we are going to block so wakeup will be needed. */
+            if (status == 0) {
+                _this->wakeup_window = wakeup_window;
+            } else {
+                _this->wakeup_window = NULL;
+            }
+            if (_this->wakeup_lock) {
+                SDL_UnlockMutex(_this->wakeup_lock);
+            }
+            if (status < 0) {
+                /* Got an error: return */
+                break;
+            }
+            if (status > 0) {
+                /* There is an event, we can return. */
+                return 1;
+            }
+            /* No events found in the queue, call WaitEventTimeout to wait for an event. */
+            if (timeout > 0) {
+                Uint32 elapsed = SDL_GetTicks() - start;
+                if (elapsed >= (Uint32)timeout) {
+                    /* Set wakeup_window to NULL without holding the lock. */
+                    _this->wakeup_window = NULL;
+                    return 0;
+                }
+                loop_timeout = (int)((Uint32)timeout - elapsed);
+            }
+            if (need_periodic_poll) {
+                if (loop_timeout >= 0) {
+                    loop_timeout = SDL_min(loop_timeout, PERIODIC_POLL_INTERVAL_MS);
+                } else {
+                    loop_timeout = PERIODIC_POLL_INTERVAL_MS;
+                }
+            }
+            status = _this->WaitEventTimeout(_this, loop_timeout);
+            /* Set wakeup_window to NULL without holding the lock. */
+            _this->wakeup_window = NULL;
+            if (status <= 0) {
+                /* There is either an error or the timeout is elapsed: return */
+                return status;
+            }
+            /* An event was found and pumped into the SDL events queue. Continue the loop
+              to let SDL_PeepEvents pick it up .*/
+        }
+    }
+    return 0;
+}
+
+static SDL_bool
+SDL_events_need_polling() {
+    SDL_bool need_polling = SDL_FALSE;
+
+#if !SDL_JOYSTICK_DISABLED
+    need_polling =
+        SDL_WasInit(SDL_INIT_JOYSTICK) &&
+        (!SDL_disabled_events[SDL_JOYAXISMOTION >> 8] || SDL_JoystickEventState(SDL_QUERY)) &&
+        (SDL_NumJoysticks() > 0);
+#endif
+
+#if !SDL_SENSOR_DISABLED
+    need_polling = need_polling ||
+        (SDL_WasInit(SDL_INIT_SENSOR) && !SDL_disabled_events[SDL_SENSORUPDATE >> 8] && (SDL_NumSensors() > 0));
+#endif
+
+    return need_polling;
+}
+
+static SDL_Window *
+SDL_find_active_window(SDL_VideoDevice * _this)
+{
+    SDL_Window *window;
+    for (window = _this->windows; window; window = window->next) {
+        if (!window->is_destroying) {
+            return window;
+        }
+    }
+    return NULL;
+}
+
 int
 SDL_WaitEvent(SDL_Event * event)
 {
@@ -768,21 +1013,80 @@ SDL_WaitEvent(SDL_Event * event)
 int
 SDL_WaitEventTimeout(SDL_Event * event, int timeout)
 {
-    Uint32 expiration = 0;
+    SDL_VideoDevice *_this = SDL_GetVideoDevice();
+    SDL_Window *wakeup_window;
+    Uint32 start, expiration;
+    SDL_bool include_sentinel = (timeout == 0) ? SDL_TRUE : SDL_FALSE;
+    int result;
 
-    if (timeout > 0)
-        expiration = SDL_GetTicks() + timeout;
+    /* If there isn't a poll sentinel event pending, pump events and add one */
+    if (SDL_AtomicGet(&SDL_sentinel_pending) == 0) {
+        SDL_PumpEventsInternal(SDL_TRUE);
+    }
+
+    /* First check for existing events */
+    result = SDL_PeepEventsInternal(event, 1, SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT, include_sentinel);
+    if (result < 0) {
+        return 0;
+    }
+    if (include_sentinel) {
+        if (event) {
+            if (event->type == SDL_POLLSENTINEL) {
+                /* Reached the end of a poll cycle, and not willing to wait */
+                return 0;
+            }
+        } else {
+            /* Need to peek the next event to check for sentinel */
+            SDL_Event dummy;
+
+            if (SDL_PeepEventsInternal(&dummy, 1, SDL_PEEKEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT, SDL_TRUE) &&
+                dummy.type == SDL_POLLSENTINEL) {
+                SDL_PeepEventsInternal(&dummy, 1, SDL_GETEVENT, SDL_POLLSENTINEL, SDL_POLLSENTINEL, SDL_TRUE);
+                /* Reached the end of a poll cycle, and not willing to wait */
+                return 0;
+            }
+        }
+    }
+    if (result == 0) {
+        if (timeout == 0) {
+            /* No events available, and not willing to wait */
+            return 0;
+        }
+    } else {
+        /* Has existing events */
+        return 1;
+    }
+    /* We should have completely handled timeout == 0 above */
+    SDL_assert(timeout != 0);
+
+    if (timeout > 0) {
+        start = SDL_GetTicks();
+        expiration = start + timeout;
+    } else {
+        start = 0;
+        expiration = 0;
+    }
+
+    if (_this && _this->WaitEventTimeout && _this->SendWakeupEvent && !SDL_events_need_polling()) {
+        /* Look if a shown window is available to send the wakeup event. */
+        wakeup_window = SDL_find_active_window(_this);
+        if (wakeup_window) {
+            int status = SDL_WaitEventTimeout_Device(_this, wakeup_window, event, start, timeout);
+
+            /* There may be implementation-defined conditions where the backend cannot
+               reliably wait for the next event. If that happens, fall back to polling. */
+            if (status >= 0) {
+                return status;
+            }
+        }
+    }
 
     for (;;) {
-        SDL_PumpEvents();
+        SDL_PumpEventsInternal(SDL_TRUE);
         switch (SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT)) {
         case -1:
             return 0;
         case 0:
-            if (timeout == 0) {
-                /* Polling and no events, just return */
-                return 0;
-            }
             if (timeout > 0 && SDL_TICKS_PASSED(SDL_GetTicks(), expiration)) {
                 /* Timeout expired and no events */
                 return 0;
@@ -960,8 +1264,7 @@ SDL_FilterEvents(SDL_EventFilter filter, void *userdata)
 Uint8
 SDL_EventState(Uint32 type, int state)
 {
-    const SDL_bool isdnd = ((state == SDL_DISABLE) || (state == SDL_ENABLE)) &&
-                           ((type == SDL_DROPFILE) || (type == SDL_DROPTEXT));
+    const SDL_bool isde = (state == SDL_DISABLE) || (state == SDL_ENABLE);
     Uint8 current_state;
     Uint8 hi = ((type >> 8) & 0xff);
     Uint8 lo = (type & 0xff);
@@ -973,44 +1276,32 @@ SDL_EventState(Uint32 type, int state)
         current_state = SDL_ENABLE;
     }
 
-    if (state != current_state)
-    {
-        switch (state) {
-        case SDL_DISABLE:
+    if (isde && state != current_state) {
+        if (state == SDL_DISABLE) {
             /* Disable this event type and discard pending events */
             if (!SDL_disabled_events[hi]) {
                 SDL_disabled_events[hi] = (SDL_DisabledEventBlock*) SDL_calloc(1, sizeof(SDL_DisabledEventBlock));
-                if (!SDL_disabled_events[hi]) {
-                    /* Out of memory, nothing we can do... */
-                    break;
-                }
             }
-            SDL_disabled_events[hi]->bits[lo/32] |= (1 << (lo&31));
-            SDL_FlushEvent(type);
-            break;
-        case SDL_ENABLE:
+            /* Out of memory, nothing we can do... */
+            if (SDL_disabled_events[hi]) {
+                SDL_disabled_events[hi]->bits[lo/32] |= (1 << (lo&31));
+                SDL_FlushEvent(type);
+            }
+        } else { // state == SDL_ENABLE
             SDL_disabled_events[hi]->bits[lo/32] &= ~(1 << (lo&31));
-            break;
-        default:
-            /* Querying state... */
-            break;
         }
 
 #if !SDL_JOYSTICK_DISABLED
-        if (state == SDL_DISABLE || state == SDL_ENABLE) {
-            SDL_CalculateShouldUpdateJoysticks();
-        }
+        SDL_CalculateShouldUpdateJoysticks();
 #endif
 #if !SDL_SENSOR_DISABLED
-        if (state == SDL_DISABLE || state == SDL_ENABLE) {
-            SDL_CalculateShouldUpdateSensors();
-        }
+        SDL_CalculateShouldUpdateSensors();
 #endif
     }
 
     /* turn off drag'n'drop support if we've disabled the events.
        This might change some UI details at the OS level. */
-    if (isdnd) {
+    if (isde && ((type == SDL_DROPFILE) || (type == SDL_DROPTEXT))) {
         SDL_ToggleDragAndDropSupport();
     }
 
@@ -1084,6 +1375,7 @@ SDL_EventsInit(void)
     SDL_AddHintCallback(SDL_HINT_AUTO_UPDATE_SENSORS, SDL_AutoUpdateSensorsChanged, NULL);
 #endif
     SDL_AddHintCallback(SDL_HINT_EVENT_LOGGING, SDL_EventLoggingChanged, NULL);
+    SDL_AddHintCallback(SDL_HINT_POLL_SENTINEL, SDL_PollSentinelChanged, NULL);
     if (SDL_StartEventLoop() < 0) {
         SDL_DelHintCallback(SDL_HINT_EVENT_LOGGING, SDL_EventLoggingChanged, NULL);
         return -1;
@@ -1099,6 +1391,7 @@ SDL_EventsQuit(void)
 {
     SDL_QuitQuit();
     SDL_StopEventLoop();
+    SDL_DelHintCallback(SDL_HINT_POLL_SENTINEL, SDL_PollSentinelChanged, NULL);
     SDL_DelHintCallback(SDL_HINT_EVENT_LOGGING, SDL_EventLoggingChanged, NULL);
 #if !SDL_JOYSTICK_DISABLED
     SDL_DelHintCallback(SDL_HINT_AUTO_UPDATE_JOYSTICKS, SDL_AutoUpdateJoysticksChanged, NULL);
diff --git a/Engine/lib/sdl/src/events/SDL_events_c.h b/Engine/lib/sdl/src/events/SDL_events_c.h
index 3c067e728..ba52b1155 100644
--- a/Engine/lib/sdl/src/events/SDL_events_c.h
+++ b/Engine/lib/sdl/src/events/SDL_events_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/events/SDL_gesture.c b/Engine/lib/sdl/src/events/SDL_gesture.c
index a8fe16689..8d97f3138 100644
--- a/Engine/lib/sdl/src/events/SDL_gesture.c
+++ b/Engine/lib/sdl/src/events/SDL_gesture.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -32,7 +32,7 @@
 #include <stdio.h>
 */
 
-/* TODO: Replace with malloc */
+/* TODO: Replace with SDL_malloc */
 
 #define MAXPATHSIZE 1024
 
@@ -487,7 +487,9 @@ int SDL_GestureDelTouch(SDL_TouchID touchId)
     SDL_zero(SDL_gestureTouch[i]);
 
     SDL_numGestureTouches--;
-    SDL_memcpy(&SDL_gestureTouch[i], &SDL_gestureTouch[SDL_numGestureTouches], sizeof(SDL_gestureTouch[i]));
+    if (i != SDL_numGestureTouches) {
+        SDL_memcpy(&SDL_gestureTouch[i], &SDL_gestureTouch[SDL_numGestureTouches], sizeof(SDL_gestureTouch[i]));
+    }
     return 0;
 }
 
diff --git a/Engine/lib/sdl/src/events/SDL_gesture_c.h b/Engine/lib/sdl/src/events/SDL_gesture_c.h
index 13a102084..84855aa88 100644
--- a/Engine/lib/sdl/src/events/SDL_gesture_c.h
+++ b/Engine/lib/sdl/src/events/SDL_gesture_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/events/SDL_keyboard.c b/Engine/lib/sdl/src/events/SDL_keyboard.c
index 16c1a29a7..cd150fab6 100644
--- a/Engine/lib/sdl/src/events/SDL_keyboard.c
+++ b/Engine/lib/sdl/src/events/SDL_keyboard.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -22,6 +22,7 @@
 
 /* General keyboard handling code for SDL */
 
+#include "SDL_hints.h"
 #include "SDL_timer.h"
 #include "SDL_events.h"
 #include "SDL_events_c.h"
@@ -536,27 +537,12 @@ SDL_UCS4ToUTF8(Uint32 ch, char *dst)
         p[1] = 0x80 | (Uint8) ((ch >> 6) & 0x3F);
         p[2] = 0x80 | (Uint8) (ch & 0x3F);
         dst += 3;
-    } else if (ch <= 0x1FFFFF) {
+    } else {
         p[0] = 0xF0 | (Uint8) ((ch >> 18) & 0x07);
         p[1] = 0x80 | (Uint8) ((ch >> 12) & 0x3F);
         p[2] = 0x80 | (Uint8) ((ch >> 6) & 0x3F);
         p[3] = 0x80 | (Uint8) (ch & 0x3F);
         dst += 4;
-    } else if (ch <= 0x3FFFFFF) {
-        p[0] = 0xF8 | (Uint8) ((ch >> 24) & 0x03);
-        p[1] = 0x80 | (Uint8) ((ch >> 18) & 0x3F);
-        p[2] = 0x80 | (Uint8) ((ch >> 12) & 0x3F);
-        p[3] = 0x80 | (Uint8) ((ch >> 6) & 0x3F);
-        p[4] = 0x80 | (Uint8) (ch & 0x3F);
-        dst += 5;
-    } else {
-        p[0] = 0xFC | (Uint8) ((ch >> 30) & 0x01);
-        p[1] = 0x80 | (Uint8) ((ch >> 24) & 0x3F);
-        p[2] = 0x80 | (Uint8) ((ch >> 18) & 0x3F);
-        p[3] = 0x80 | (Uint8) ((ch >> 12) & 0x3F);
-        p[4] = 0x80 | (Uint8) ((ch >> 6) & 0x3F);
-        p[5] = 0x80 | (Uint8) (ch & 0x3F);
-        dst += 6;
     }
     return dst;
 }
@@ -619,6 +605,9 @@ SDL_SetKeymap(int start, SDL_Keycode * keys, int length)
 void
 SDL_SetScancodeName(SDL_Scancode scancode, const char *name)
 {
+    if (scancode >= SDL_NUM_SCANCODES) {
+        return;
+    }
     SDL_scancode_names[scancode] = name;
 }
 
@@ -689,7 +678,7 @@ SDL_SendKeyboardKeyInternal(Uint8 source, Uint8 state, SDL_Scancode scancode)
     Uint32 type;
     Uint8 repeat = SDL_FALSE;
 
-    if (scancode == SDL_SCANCODE_UNKNOWN) {
+    if (scancode == SDL_SCANCODE_UNKNOWN || scancode >= SDL_NUM_SCANCODES) {
         return 0;
     }
 
@@ -778,6 +767,9 @@ SDL_SendKeyboardKeyInternal(Uint8 source, Uint8 state, SDL_Scancode scancode)
         case SDLK_CAPSLOCK:
             keyboard->modstate ^= KMOD_CAPS;
             break;
+        case SDLK_SCROLLLOCK:
+            keyboard->modstate ^= KMOD_SCROLL;
+            break;
         default:
             keyboard->modstate |= modifier;
             break;
@@ -799,6 +791,22 @@ SDL_SendKeyboardKeyInternal(Uint8 source, Uint8 state, SDL_Scancode scancode)
         event.key.windowID = keyboard->focus ? keyboard->focus->id : 0;
         posted = (SDL_PushEvent(&event) > 0);
     }
+
+    /* If the keyboard is grabbed and the grabbed window is in full-screen,
+       minimize the window when we receive Alt+Tab, unless the application
+       has explicitly opted out of this behavior. */
+    if (keycode == SDLK_TAB &&
+        state == SDL_PRESSED &&
+        (keyboard->modstate & KMOD_ALT) &&
+        keyboard->focus &&
+        (keyboard->focus->flags & SDL_WINDOW_KEYBOARD_GRABBED) &&
+        (keyboard->focus->flags & SDL_WINDOW_FULLSCREEN) &&
+        SDL_GetHintBoolean(SDL_HINT_ALLOW_ALT_TAB_WHILE_GRABBED, SDL_TRUE)) {
+        /* We will temporarily forfeit our grab by minimizing our window, 
+           allowing the user to escape the application */
+        SDL_MinimizeWindow(keyboard->focus);
+    }
+
     return (posted);
 }
 
@@ -859,10 +867,14 @@ SDL_SendKeyboardText(const char *text)
     posted = 0;
     if (SDL_GetEventState(SDL_TEXTINPUT) == SDL_ENABLE) {
         SDL_Event event;
+        size_t i = 0, length = SDL_strlen(text);
+
         event.text.type = SDL_TEXTINPUT;
         event.text.windowID = keyboard->focus ? keyboard->focus->id : 0;
-        SDL_utf8strlcpy(event.text.text, text, SDL_arraysize(event.text.text));
-        posted = (SDL_PushEvent(&event) > 0);
+        while (i < length) {
+            i += SDL_utf8strlcpy(event.text.text, text + i, SDL_arraysize(event.text.text));
+            posted |= (SDL_PushEvent(&event) > 0);
+        }
     }
     return (posted);
 }
@@ -882,6 +894,22 @@ SDL_SendEditingText(const char *text, int start, int length)
         event.edit.start = start;
         event.edit.length = length;
         SDL_utf8strlcpy(event.edit.text, text, SDL_arraysize(event.edit.text));
+
+        if (SDL_GetHintBoolean(SDL_HINT_IME_SUPPORT_EXTENDED_TEXT, SDL_FALSE) &&
+            SDL_strlen(text) > SDL_arraysize(event.text.text)) {
+            event.editExt.type = SDL_TEXTEDITING_EXT;
+            event.editExt.windowID = keyboard->focus ? keyboard->focus->id : 0;
+            event.editExt.text = text ? SDL_strdup(text) : NULL;
+            event.editExt.start = start;
+            event.editExt.length = length;
+        } else {
+            event.edit.type = SDL_TEXTEDITING;
+            event.edit.windowID = keyboard->focus ? keyboard->focus->id : 0;
+            event.edit.start = start;
+            event.edit.length = length;
+            SDL_utf8strlcpy(event.edit.text, text, SDL_arraysize(event.edit.text));
+        }
+
         posted = (SDL_PushEvent(&event) > 0);
     }
     return (posted);
diff --git a/Engine/lib/sdl/src/events/SDL_keyboard_c.h b/Engine/lib/sdl/src/events/SDL_keyboard_c.h
index 22bc48f15..fffd012c2 100644
--- a/Engine/lib/sdl/src/events/SDL_keyboard_c.h
+++ b/Engine/lib/sdl/src/events/SDL_keyboard_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/events/SDL_mouse.c b/Engine/lib/sdl/src/events/SDL_mouse.c
index 11d9f5ae0..2e88ee714 100644
--- a/Engine/lib/sdl/src/events/SDL_mouse.c
+++ b/Engine/lib/sdl/src/events/SDL_mouse.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -127,6 +127,22 @@ SDL_MouseTouchEventsChanged(void *userdata, const char *name, const char *oldVal
     }
 }
 
+static void SDLCALL
+SDL_MouseAutoCaptureChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
+{
+    SDL_Mouse *mouse = (SDL_Mouse *)userdata;
+    SDL_bool auto_capture = SDL_GetStringBoolean(hint, SDL_TRUE);
+
+    if (auto_capture != mouse->auto_capture) {
+        /* Turn off mouse capture if it's currently active because of button presses */
+        if (!auto_capture && SDL_GetMouseState(NULL, NULL) != 0) {
+            SDL_CaptureMouse(SDL_FALSE);
+        }
+
+        mouse->auto_capture = auto_capture;
+    }
+}
+
 /* Public functions */
 int
 SDL_MouseInit(void)
@@ -153,6 +169,9 @@ SDL_MouseInit(void)
     SDL_AddHintCallback(SDL_HINT_MOUSE_TOUCH_EVENTS,
                         SDL_MouseTouchEventsChanged, mouse);
 
+    SDL_AddHintCallback(SDL_HINT_MOUSE_AUTO_CAPTURE,
+                        SDL_MouseAutoCaptureChanged, mouse);
+
     mouse->was_touch_mouse_events = SDL_FALSE; /* no touch to mouse movement event pending */
 
     mouse->cursor_shown = SDL_TRUE;
@@ -177,6 +196,17 @@ SDL_GetMouse(void)
     return &SDL_mouse;
 }
 
+static Uint32 GetButtonState(SDL_Mouse *mouse)
+{
+    int i;
+    Uint32 buttonstate = 0;
+
+    for (i = 0; i < mouse->num_sources; ++i) {
+        buttonstate |= mouse->sources[i].buttonstate;
+    }
+    return buttonstate;
+}
+
 SDL_Window *
 SDL_GetMouseFocus(void)
 {
@@ -185,25 +215,6 @@ SDL_GetMouseFocus(void)
     return mouse->focus;
 }
 
-#if 0
-void
-SDL_ResetMouse(void)
-{
-    SDL_Mouse *mouse = SDL_GetMouse();
-    Uint8 i;
-
-#ifdef DEBUG_MOUSE
-    printf("Resetting mouse\n");
-#endif
-    for (i = 1; i <= sizeof(mouse->buttonstate)*8; ++i) {
-        if (mouse->buttonstate & SDL_BUTTON(i)) {
-            SDL_SendMouseButton(mouse->focus, mouse->mouseID, SDL_RELEASED, i);
-        }
-    }
-    SDL_assert(mouse->buttonstate == 0);
-}
-#endif
-
 void
 SDL_SetMouseFocus(SDL_Window * window)
 {
@@ -256,23 +267,10 @@ SDL_UpdateMouseFocus(SDL_Window * window, int x, int y, Uint32 buttonstate, SDL_
         }
     }
 
-/* Linux doesn't give you mouse events outside your window unless you grab
-   the pointer.
-
-   Windows doesn't give you mouse events outside your window unless you call
-   SetCapture().
-
-   Both of these are slightly scary changes, so for now we'll punt and if the
-   mouse leaves the window you'll lose mouse focus and reset button state.
-*/
-#ifdef SUPPORT_DRAG_OUTSIDE_WINDOW
-    if (!inWindow && !buttonstate) {
-#else
     if (!inWindow) {
-#endif
         if (window == mouse->focus) {
 #ifdef DEBUG_MOUSE
-            printf("Mouse left window, synthesizing move & focus lost event\n");
+            SDL_Log("Mouse left window, synthesizing move & focus lost event\n");
 #endif
             if (send_mouse_motion) {
                 SDL_PrivateSendMouseMotion(window, mouse->mouseID, 0, x, y);
@@ -284,7 +282,7 @@ SDL_UpdateMouseFocus(SDL_Window * window, int x, int y, Uint32 buttonstate, SDL_
 
     if (window != mouse->focus) {
 #ifdef DEBUG_MOUSE
-        printf("Mouse entered window, synthesizing focus gain & move event\n");
+        SDL_Log("Mouse entered window, synthesizing focus gain & move event\n");
 #endif
         SDL_SetMouseFocus(window);
         if (send_mouse_motion) {
@@ -299,7 +297,7 @@ SDL_SendMouseMotion(SDL_Window * window, SDL_MouseID mouseID, int relative, int
 {
     if (window && !relative) {
         SDL_Mouse *mouse = SDL_GetMouse();
-        if (!SDL_UpdateMouseFocus(window, x, y, mouse->buttonstate, (mouseID == SDL_TOUCH_MOUSEID) ? SDL_FALSE : SDL_TRUE)) {
+        if (!SDL_UpdateMouseFocus(window, x, y, GetButtonState(mouse), (mouseID == SDL_TOUCH_MOUSEID) ? SDL_FALSE : SDL_TRUE)) {
             return 0;
         }
     }
@@ -358,7 +356,13 @@ SDL_PrivateSendMouseMotion(SDL_Window * window, SDL_MouseID mouseID, int relativ
             mouse->last_y = center_y;
             return 0;
         }
-        SDL_WarpMouseInWindow(window, center_x, center_y);
+        if (window && (window->flags & SDL_WINDOW_INPUT_FOCUS) != 0) {
+            if (mouse->WarpMouse) {
+                mouse->WarpMouse(window, center_x, center_y);
+            } else {
+                SDL_PrivateSendMouseMotion(window, mouseID, 0, center_x, center_y);
+            }
+        }
     }
 
     if (relative) {
@@ -382,16 +386,19 @@ SDL_PrivateSendMouseMotion(SDL_Window * window, SDL_MouseID mouseID, int relativ
     if (!mouse->has_position) {
         xrel = 0;
         yrel = 0;
+        mouse->x = x;
+        mouse->y = y;
         mouse->has_position = SDL_TRUE;
+        return 0;
     } else if (!xrel && !yrel) {  /* Drop events that don't change state */
 #ifdef DEBUG_MOUSE
-        printf("Mouse event didn't change state - dropped!\n");
+        SDL_Log("Mouse event didn't change state - dropped!\n");
 #endif
         return 0;
     }
 
     /* Ignore relative motion positioning the first touch */
-    if (mouseID == SDL_TOUCH_MOUSEID && !mouse->buttonstate) {
+    if (mouseID == SDL_TOUCH_MOUSEID && !GetButtonState(mouse)) {
         xrel = 0;
         yrel = 0;
     }
@@ -408,25 +415,42 @@ SDL_PrivateSendMouseMotion(SDL_Window * window, SDL_MouseID mouseID, int relativ
     /* make sure that the pointers find themselves inside the windows,
        unless we have the mouse captured. */
     if (window && ((window->flags & SDL_WINDOW_MOUSE_CAPTURE) == 0)) {
-        int x_max = 0, y_max = 0;
+        int x_min = 0, x_max = 0;
+        int y_min = 0, y_max = 0;
+        const SDL_Rect *confine = SDL_GetWindowMouseRect(window);
 
-        /* !!! FIXME: shouldn't this be (window) instead of (mouse->focus)? */
-        SDL_GetWindowSize(mouse->focus, &x_max, &y_max);
+        SDL_GetWindowSize(window, &x_max, &y_max);
         --x_max;
         --y_max;
 
+        if (confine) {
+            SDL_Rect window_rect;
+            SDL_Rect mouse_rect;
+
+            window_rect.x = 0;
+            window_rect.y = 0;
+            window_rect.w = x_max + 1;
+            window_rect.h = y_max + 1;
+            if (SDL_IntersectRect(confine, &window_rect, &mouse_rect)) {
+                x_min = mouse_rect.x;
+                y_min = mouse_rect.y;
+                x_max = x_min + mouse_rect.w - 1;
+                y_max = y_min + mouse_rect.h - 1;
+            }
+        }
+
         if (mouse->x > x_max) {
             mouse->x = x_max;
         }
-        if (mouse->x < 0) {
-            mouse->x = 0;
+        if (mouse->x < x_min) {
+            mouse->x = x_min;
         }
 
         if (mouse->y > y_max) {
             mouse->y = y_max;
         }
-        if (mouse->y < 0) {
-            mouse->y = 0;
+        if (mouse->y < y_min) {
+            mouse->y = y_min;
         }
     }
 
@@ -448,7 +472,7 @@ SDL_PrivateSendMouseMotion(SDL_Window * window, SDL_MouseID mouseID, int relativ
         event.motion.which = mouseID;
         /* Set us pending (or clear during a normal mouse movement event) as having triggered */
         mouse->was_touch_mouse_events = (mouseID == SDL_TOUCH_MOUSEID)? SDL_TRUE : SDL_FALSE;
-        event.motion.state = mouse->buttonstate;
+        event.motion.state = GetButtonState(mouse);
         event.motion.x = mouse->x;
         event.motion.y = mouse->y;
         event.motion.xrel = xrel;
@@ -466,6 +490,30 @@ SDL_PrivateSendMouseMotion(SDL_Window * window, SDL_MouseID mouseID, int relativ
     return posted;
 }
 
+static SDL_MouseInputSource *GetMouseInputSource(SDL_Mouse *mouse, SDL_MouseID mouseID)
+{
+    SDL_MouseInputSource *source, *sources;
+    int i;
+
+    for (i = 0; i < mouse->num_sources; ++i) {
+        source = &mouse->sources[i];
+        if (source->mouseID == mouseID) {
+            return source;
+        }
+    }
+
+    sources = (SDL_MouseInputSource *)SDL_realloc(mouse->sources, (mouse->num_sources + 1)*sizeof(*mouse->sources));
+    if (sources) {
+        mouse->sources = sources;
+        ++mouse->num_sources;
+        source = &sources[mouse->num_sources - 1];
+        source->mouseID = mouseID;
+        source->buttonstate = 0;
+        return source;
+    }
+    return NULL;
+}
+
 static SDL_MouseClickState *GetMouseClickState(SDL_Mouse *mouse, Uint8 button)
 {
     if (button >= mouse->num_clickstates) {
@@ -490,7 +538,15 @@ SDL_PrivateSendMouseButton(SDL_Window * window, SDL_MouseID mouseID, Uint8 state
     SDL_Mouse *mouse = SDL_GetMouse();
     int posted;
     Uint32 type;
-    Uint32 buttonstate = mouse->buttonstate;
+    Uint32 buttonstate;
+    SDL_MouseInputSource *source;
+    SDL_bool had_buttons_pressed = (SDL_GetMouseState(NULL, NULL) ? SDL_TRUE : SDL_FALSE);
+
+    source = GetMouseInputSource(mouse, mouseID);
+    if (!source) {
+        return 0;
+    }
+    buttonstate = source->buttonstate;
 
     /* SDL_HINT_MOUSE_TOUCH_EVENTS: controlling whether mouse events should generate synthetic touch events */
     if (mouse->mouse_touch_events) {
@@ -535,11 +591,11 @@ SDL_PrivateSendMouseButton(SDL_Window * window, SDL_MouseID mouseID, Uint8 state
         SDL_UpdateMouseFocus(window, mouse->x, mouse->y, buttonstate, SDL_TRUE);
     }
 
-    if (buttonstate == mouse->buttonstate) {
+    if (buttonstate == source->buttonstate) {
         /* Ignore this event, no state change */
         return 0;
     }
-    mouse->buttonstate = buttonstate;
+    source->buttonstate = buttonstate;
 
     if (clicks < 0) {
         SDL_MouseClickState *clickstate = GetMouseClickState(mouse, button);
@@ -585,6 +641,14 @@ SDL_PrivateSendMouseButton(SDL_Window * window, SDL_MouseID mouseID, Uint8 state
         SDL_UpdateMouseFocus(window, mouse->x, mouse->y, buttonstate, SDL_TRUE);
     }
 
+    /* Automatically capture the mouse while buttons are pressed */
+    if (mouse->auto_capture) {
+        SDL_bool has_buttons_pressed = (SDL_GetMouseState(NULL, NULL) ? SDL_TRUE : SDL_FALSE);
+        if (has_buttons_pressed != had_buttons_pressed) {
+            SDL_CaptureMouse(has_buttons_pressed);
+        }
+    }
+
     return posted;
 }
 
@@ -616,20 +680,38 @@ SDL_SendMouseWheel(SDL_Window * window, SDL_MouseID mouseID, float x, float y, S
         return 0;
     }
 
+    if (x > 0.0f) {
+        if (mouse->accumulated_wheel_x < 0.0f) {
+            mouse->accumulated_wheel_x = 0.0f;
+        }
+    } else if (x < 0.0f) {
+        if (mouse->accumulated_wheel_x > 0.0f) {
+            mouse->accumulated_wheel_x = 0.0f;
+        }
+    }
     mouse->accumulated_wheel_x += x;
-    if (mouse->accumulated_wheel_x > 0) {
+    if (mouse->accumulated_wheel_x > 0.0f) {
         integral_x = (int)SDL_floor(mouse->accumulated_wheel_x);
-    } else if (mouse->accumulated_wheel_x < 0) {
+    } else if (mouse->accumulated_wheel_x < 0.0f) {
         integral_x = (int)SDL_ceil(mouse->accumulated_wheel_x);
     } else {
         integral_x = 0;
     }
     mouse->accumulated_wheel_x -= integral_x;
 
+    if (y > 0.0f) {
+        if (mouse->accumulated_wheel_y < 0.0f) {
+            mouse->accumulated_wheel_y = 0.0f;
+        }
+    } else if (y < 0.0f) {
+        if (mouse->accumulated_wheel_y > 0.0f) {
+            mouse->accumulated_wheel_y = 0.0f;
+        }
+    }
     mouse->accumulated_wheel_y += y;
-    if (mouse->accumulated_wheel_y > 0) {
+    if (mouse->accumulated_wheel_y > 0.0f) {
         integral_y = (int)SDL_floor(mouse->accumulated_wheel_y);
-    } else if (mouse->accumulated_wheel_y < 0) {
+    } else if (mouse->accumulated_wheel_y < 0.0f) {
         integral_y = (int)SDL_ceil(mouse->accumulated_wheel_y);
     } else {
         integral_y = 0;
@@ -643,12 +725,10 @@ SDL_SendMouseWheel(SDL_Window * window, SDL_MouseID mouseID, float x, float y, S
         event.type = SDL_MOUSEWHEEL;
         event.wheel.windowID = mouse->focus ? mouse->focus->id : 0;
         event.wheel.which = mouseID;
-#if 0 /* Uncomment this when it goes in for SDL 2.1 */
-        event.wheel.preciseX = x;
-        event.wheel.preciseY = y;
-#endif
         event.wheel.x = integral_x;
         event.wheel.y = integral_y;
+        event.wheel.preciseX = x;
+        event.wheel.preciseY = y;
         event.wheel.direction = (Uint32)direction;
         posted = (SDL_PushEvent(&event) > 0);
     }
@@ -681,16 +761,38 @@ SDL_MouseQuit(void)
         mouse->def_cursor = NULL;
     }
 
+    if (mouse->sources) {
+        SDL_free(mouse->sources);
+        mouse->sources = NULL;
+    }
+    mouse->num_sources = 0;
+
     if (mouse->clickstate) {
         SDL_free(mouse->clickstate);
         mouse->clickstate = NULL;
     }
+    mouse->num_clickstates = 0;
+
+    SDL_DelHintCallback(SDL_HINT_MOUSE_DOUBLE_CLICK_TIME,
+                        SDL_MouseDoubleClickTimeChanged, mouse);
+
+    SDL_DelHintCallback(SDL_HINT_MOUSE_DOUBLE_CLICK_RADIUS,
+                        SDL_MouseDoubleClickRadiusChanged, mouse);
 
     SDL_DelHintCallback(SDL_HINT_MOUSE_NORMAL_SPEED_SCALE,
                         SDL_MouseNormalSpeedScaleChanged, mouse);
 
     SDL_DelHintCallback(SDL_HINT_MOUSE_RELATIVE_SPEED_SCALE,
                         SDL_MouseRelativeSpeedScaleChanged, mouse);
+
+    SDL_DelHintCallback(SDL_HINT_TOUCH_MOUSE_EVENTS,
+                        SDL_TouchMouseEventsChanged, mouse);
+
+    SDL_DelHintCallback(SDL_HINT_MOUSE_TOUCH_EVENTS,
+                        SDL_MouseTouchEventsChanged, mouse);
+
+    SDL_DelHintCallback(SDL_HINT_MOUSE_AUTO_CAPTURE,
+                        SDL_MouseAutoCaptureChanged, mouse);
 }
 
 Uint32
@@ -704,7 +806,7 @@ SDL_GetMouseState(int *x, int *y)
     if (y) {
         *y = mouse->y;
     }
-    return mouse->buttonstate;
+    return GetButtonState(mouse);
 }
 
 Uint32
@@ -720,7 +822,7 @@ SDL_GetRelativeMouseState(int *x, int *y)
     }
     mouse->xdelta = 0;
     mouse->ydelta = 0;
-    return mouse->buttonstate;
+    return GetButtonState(mouse);
 }
 
 Uint32
@@ -760,10 +862,18 @@ SDL_WarpMouseInWindow(SDL_Window * window, int x, int y)
         return;
     }
 
-    if (mouse->WarpMouse) {
+    if ((window->flags & SDL_WINDOW_MINIMIZED) == SDL_WINDOW_MINIMIZED) {
+        return;
+    }
+
+    /* Ignore the previous position when we warp */
+    mouse->has_position = SDL_FALSE;
+
+    if (mouse->WarpMouse &&
+        (!mouse->relative_mode || mouse->relative_mode_warp)) {
         mouse->WarpMouse(window, x, y);
     } else {
-        SDL_SendMouseMotion(window, mouse->mouseID, 0, x, y);
+        SDL_PrivateSendMouseMotion(window, mouse->mouseID, 0, x, y);
     }
 }
 
@@ -818,29 +928,35 @@ SDL_SetRelativeMouseMode(SDL_bool enabled)
     mouse->scale_accum_x = 0.0f;
     mouse->scale_accum_y = 0.0f;
 
-    if (enabled && focusWindow) {
-        /* Center it in the focused window to prevent clicks from going through
-         * to background windows.
-         */
-        SDL_SetMouseFocus(focusWindow);
-        SDL_WarpMouseInWindow(focusWindow, focusWindow->w/2, focusWindow->h/2);
+    if (enabled) {
+        /* Update cursor visibility before we potentially warp the mouse */
+        SDL_SetCursor(NULL);
     }
 
-    if (mouse->focus) {
-        SDL_UpdateWindowGrab(mouse->focus);
+    if (enabled && focusWindow) {
+        SDL_SetMouseFocus(focusWindow);
+
+        if (mouse->relative_mode_warp)
+            SDL_WarpMouseInWindow(focusWindow, focusWindow->w/2, focusWindow->h/2);
+    }
+
+    if (focusWindow) {
+        SDL_UpdateWindowGrab(focusWindow);
 
         /* Put the cursor back to where the application expects it */
         if (!enabled) {
-            SDL_WarpMouseInWindow(mouse->focus, mouse->x, mouse->y);
+            SDL_WarpMouseInWindow(focusWindow, mouse->x, mouse->y);
         }
     }
 
+    if (!enabled) {
+        /* Update cursor visibility after we restore the mouse position */
+        SDL_SetCursor(NULL);
+    }
+
     /* Flush pending mouse motion - ideally we would pump events, but that's not always safe */
     SDL_FlushEvent(SDL_MOUSEMOTION);
 
-    /* Update cursor visibility */
-    SDL_SetCursor(NULL);
-
     return 0;
 }
 
@@ -944,7 +1060,7 @@ SDL_CreateColorCursor(SDL_Surface *surface, int hot_x, int hot_y)
     SDL_Cursor *cursor;
 
     if (!surface) {
-        SDL_SetError("Passed NULL cursor surface");
+        SDL_InvalidParamError("surface");
         return NULL;
     }
 
diff --git a/Engine/lib/sdl/src/events/SDL_mouse_c.h b/Engine/lib/sdl/src/events/SDL_mouse_c.h
index 2592dc75b..7b020447a 100644
--- a/Engine/lib/sdl/src/events/SDL_mouse_c.h
+++ b/Engine/lib/sdl/src/events/SDL_mouse_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -33,6 +33,12 @@ struct SDL_Cursor
     void *driverdata;
 };
 
+typedef struct
+{
+    SDL_MouseID mouseID;
+    Uint32 buttonstate;
+} SDL_MouseInputSource;
+
 typedef struct
 {
     int last_x, last_y;
@@ -82,7 +88,6 @@ typedef struct
     int last_x, last_y;         /* the last reported x and y coordinates */
     float accumulated_wheel_x;
     float accumulated_wheel_y;
-    Uint32 buttonstate;
     SDL_bool has_position;
     SDL_bool relative_mode;
     SDL_bool relative_mode_warp;
@@ -95,6 +100,11 @@ typedef struct
     SDL_bool touch_mouse_events;
     SDL_bool mouse_touch_events;
     SDL_bool was_touch_mouse_events; /* Was a touch-mouse event pending? */
+    SDL_bool auto_capture;
+
+    /* Data for input source state */
+    int num_sources;
+    SDL_MouseInputSource *sources;
 
     /* Data for double-click tracking */
     int num_clickstates;
diff --git a/Engine/lib/sdl/src/events/SDL_quit.c b/Engine/lib/sdl/src/events/SDL_quit.c
index d210fdba0..ca583ea9c 100644
--- a/Engine/lib/sdl/src/events/SDL_quit.c
+++ b/Engine/lib/sdl/src/events/SDL_quit.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -54,7 +54,7 @@ SDL_HandleSIG(int sig)
     signal(sig, SDL_HandleSIG);
 
     /* Send a quit event next time the event loop pumps. */
-    /* We can't send it in signal handler; malloc() might be interrupted! */
+    /* We can't send it in signal handler; SDL_malloc() might be interrupted! */
     if ((sig == SIGINT) || (sig == SIGTERM)) {
         send_quit_pending = SDL_TRUE;
     }
diff --git a/Engine/lib/sdl/src/events/SDL_sysevents.h b/Engine/lib/sdl/src/events/SDL_sysevents.h
index 73f8f7f09..1a48462be 100644
--- a/Engine/lib/sdl/src/events/SDL_sysevents.h
+++ b/Engine/lib/sdl/src/events/SDL_sysevents.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/events/SDL_touch.c b/Engine/lib/sdl/src/events/SDL_touch.c
index 2d76ad10d..c3534f00e 100644
--- a/Engine/lib/sdl/src/events/SDL_touch.c
+++ b/Engine/lib/sdl/src/events/SDL_touch.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -63,6 +63,16 @@ SDL_GetTouchDevice(int index)
     return SDL_touchDevices[index]->id;
 }
 
+const char*
+SDL_GetTouchName(int index)
+{
+    if (index < 0 || index >= SDL_num_touch) {
+        SDL_SetError("Unknown touch device");
+        return NULL;
+    }
+    return SDL_touchDevices[index]->name;
+}
+
 static int
 SDL_GetTouchIndex(SDL_TouchID id)
 {
@@ -185,6 +195,7 @@ SDL_AddTouch(SDL_TouchID touchID, SDL_TouchDeviceType type, const char *name)
     SDL_touchDevices[index]->num_fingers = 0;
     SDL_touchDevices[index]->max_fingers = 0;
     SDL_touchDevices[index]->fingers = NULL;
+    SDL_touchDevices[index]->name = SDL_strdup(name ? name : "");
 
     /* Record this touch device for gestures */
     /* We could do this on the fly in the gesture code if we wanted */
@@ -302,8 +313,9 @@ SDL_SendTouch(SDL_TouchID id, SDL_FingerID fingerid, SDL_Window * window,
     finger = SDL_GetFinger(touch, fingerid);
     if (down) {
         if (finger) {
-            /* This finger is already down */
-            return 0;
+            /* This finger is already down.
+               Assume the finger-up for the previous touch was lost, and send it. */
+            SDL_SendTouch(id, fingerid, window, SDL_FALSE, x, y, pressure);
         }
 
         if (SDL_AddFinger(touch, fingerid, x, y, pressure) < 0) {
@@ -451,6 +463,7 @@ SDL_DelTouch(SDL_TouchID id)
         SDL_free(touch->fingers[i]);
     }
     SDL_free(touch->fingers);
+    SDL_free(touch->name);
     SDL_free(touch);
 
     SDL_num_touch--;
diff --git a/Engine/lib/sdl/src/events/SDL_touch_c.h b/Engine/lib/sdl/src/events/SDL_touch_c.h
index ed5dda2db..4d5caf134 100644
--- a/Engine/lib/sdl/src/events/SDL_touch_c.h
+++ b/Engine/lib/sdl/src/events/SDL_touch_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -31,6 +31,7 @@ typedef struct SDL_Touch
     int num_fingers;
     int max_fingers;
     SDL_Finger** fingers;
+    char *name;
 } SDL_Touch;
 
 
diff --git a/Engine/lib/sdl/src/events/SDL_windowevents.c b/Engine/lib/sdl/src/events/SDL_windowevents.c
index 50e544b64..cc8b891df 100644
--- a/Engine/lib/sdl/src/events/SDL_windowevents.c
+++ b/Engine/lib/sdl/src/events/SDL_windowevents.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -25,7 +25,7 @@
 #include "SDL_events.h"
 #include "SDL_events_c.h"
 #include "SDL_mouse_c.h"
-
+#include "SDL_hints.h"
 
 static int SDLCALL
 RemovePendingSizeChangedAndResizedEvents(void * userdata, SDL_Event *event)
@@ -110,6 +110,7 @@ SDL_SendWindowEvent(SDL_Window * window, Uint8 windowevent, int data1,
         }
         window->x = data1;
         window->y = data2;
+        SDL_OnWindowMoved(window);
         break;
     case SDL_WINDOWEVENT_RESIZED:
         if (!(window->flags & SDL_WINDOW_FULLSCREEN)) {
@@ -200,8 +201,9 @@ SDL_SendWindowEvent(SDL_Window * window, Uint8 windowevent, int data1,
 
     if (windowevent == SDL_WINDOWEVENT_CLOSE) {
         if ( !window->prev && !window->next ) {
-            /* This is the last window in the list so send the SDL_QUIT event */
-            SDL_SendQuit();
+            if (SDL_GetHintBoolean(SDL_HINT_QUIT_ON_LAST_WINDOW_CLOSE, SDL_TRUE)) {
+                SDL_SendQuit();  /* This is the last window in the list so send the SDL_QUIT event */
+            }
         }
     }
 
diff --git a/Engine/lib/sdl/src/events/SDL_windowevents_c.h b/Engine/lib/sdl/src/events/SDL_windowevents_c.h
index 62239070d..f8042ee9e 100644
--- a/Engine/lib/sdl/src/events/SDL_windowevents_c.h
+++ b/Engine/lib/sdl/src/events/SDL_windowevents_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/events/blank_cursor.h b/Engine/lib/sdl/src/events/blank_cursor.h
index dbeb90ca6..35b47d375 100644
--- a/Engine/lib/sdl/src/events/blank_cursor.h
+++ b/Engine/lib/sdl/src/events/blank_cursor.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/events/default_cursor.h b/Engine/lib/sdl/src/events/default_cursor.h
index 6e468bd00..949d6e043 100644
--- a/Engine/lib/sdl/src/events/default_cursor.h
+++ b/Engine/lib/sdl/src/events/default_cursor.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -111,4 +111,5 @@ static const unsigned char default_cmask[] = {
 };
 
 #endif /* USE_MACOS_CURSOR */
+
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/x11/imKStoUCS.c b/Engine/lib/sdl/src/events/imKStoUCS.c
similarity index 99%
rename from Engine/lib/sdl/src/video/x11/imKStoUCS.c
rename to Engine/lib/sdl/src/events/imKStoUCS.c
index 40e224243..4aa85d423 100644
--- a/Engine/lib/sdl/src/video/x11/imKStoUCS.c
+++ b/Engine/lib/sdl/src/events/imKStoUCS.c
@@ -24,10 +24,9 @@ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 DEALINGS IN THE SOFTWARE.
 */
 
-#include "../../SDL_internal.h"
+#include "../SDL_internal.h"
 
-#if SDL_VIDEO_DRIVER_X11
-#include <X11/X.h>
+#if SDL_VIDEO_DRIVER_X11 || SDL_VIDEO_DRIVER_WAYLAND
 #include "imKStoUCS.h"
 
 static unsigned short const keysym_to_unicode_1a1_1ff[] = {
@@ -294,7 +293,7 @@ static unsigned short const keysym_to_unicode_20a0_20ac[] = {
 };
 
 unsigned int
-X11_KeySymToUcs4(KeySym keysym)
+SDL_KeySymToUcs4(Uint32 keysym)
 {
     /* 'Unicode keysym' */
     if ((keysym & 0xff000000) == 0x01000000)
diff --git a/Engine/lib/sdl/src/video/x11/imKStoUCS.h b/Engine/lib/sdl/src/events/imKStoUCS.h
similarity index 96%
rename from Engine/lib/sdl/src/video/x11/imKStoUCS.h
rename to Engine/lib/sdl/src/events/imKStoUCS.h
index fe4381d98..485ace59f 100644
--- a/Engine/lib/sdl/src/video/x11/imKStoUCS.h
+++ b/Engine/lib/sdl/src/events/imKStoUCS.h
@@ -27,6 +27,6 @@ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 DEALINGS IN THE SOFTWARE.
 */
 
-extern unsigned int X11_KeySymToUcs4(KeySym keysym);
+extern unsigned int SDL_KeySymToUcs4(Uint32 keysym);
 
 #endif /* _imKStoUCS_h */
diff --git a/Engine/lib/sdl/src/events/scancodes_darwin.h b/Engine/lib/sdl/src/events/scancodes_darwin.h
index 8b7b530a1..a511e11c8 100644
--- a/Engine/lib/sdl/src/events/scancodes_darwin.h
+++ b/Engine/lib/sdl/src/events/scancodes_darwin.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/events/scancodes_linux.h b/Engine/lib/sdl/src/events/scancodes_linux.h
index 811837e6a..72637b239 100644
--- a/Engine/lib/sdl/src/events/scancodes_linux.h
+++ b/Engine/lib/sdl/src/events/scancodes_linux.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/events/scancodes_windows.h b/Engine/lib/sdl/src/events/scancodes_windows.h
index 3ff612142..eec768d62 100644
--- a/Engine/lib/sdl/src/events/scancodes_windows.h
+++ b/Engine/lib/sdl/src/events/scancodes_windows.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/events/scancodes_xfree86.h b/Engine/lib/sdl/src/events/scancodes_xfree86.h
index 21702602f..7046b7a8f 100644
--- a/Engine/lib/sdl/src/events/scancodes_xfree86.h
+++ b/Engine/lib/sdl/src/events/scancodes_xfree86.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/file/SDL_rwops.c b/Engine/lib/sdl/src/file/SDL_rwops.c
index 2dc986bd1..670d4dd9a 100644
--- a/Engine/lib/sdl/src/file/SDL_rwops.c
+++ b/Engine/lib/sdl/src/file/SDL_rwops.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -62,6 +62,235 @@
 #include "nacl_io/nacl_io.h"
 #endif
 
+#ifdef __VITA__
+
+#include <psp2/io/fcntl.h>
+#include <psp2/io/stat.h>
+
+#define READAHEAD_BUFFER_SIZE   1024
+static int SDLCALL
+vita_file_open(SDL_RWops * context, const char *filename, const char *mode)
+{
+    int h;
+    int open_flags;
+    SDL_bool has_r;
+    SDL_bool has_w;
+    SDL_bool has_a;
+    SDL_bool has_plus;
+
+    if (!context)
+        return -1;              /* failed (invalid call) */
+
+    context->hidden.vitaio.h = -1;   /* mark this as unusable */
+    context->hidden.vitaio.buffer.data = NULL;
+    context->hidden.vitaio.buffer.size = 0;
+    context->hidden.vitaio.buffer.left = 0;
+
+    open_flags = 0;
+
+    /* "r" = reading, file must exist */
+    /* "w" = writing, truncate existing, file may not exist */
+    /* "r+"= reading or writing, file must exist            */
+    /* "a" = writing, append file may not exist             */
+    /* "a+"= append + read, file may not exist              */
+    /* "w+" = read, write, truncate. file may not exist    */
+
+    has_r = SDL_strchr(mode, 'r') != NULL;
+    has_w = SDL_strchr(mode, 'w') != NULL;
+    has_a = SDL_strchr(mode, 'a') != NULL;
+    has_plus = SDL_strchr(mode, '+') != NULL;
+
+    if (has_plus)
+    {
+        if (has_r || has_w || has_a)
+        {
+            open_flags |= SCE_O_RDWR;
+        }
+    }
+    else
+    {
+        if (has_r)
+        {
+            open_flags |= SCE_O_RDONLY;
+        }
+        if (has_w || has_a)
+        {
+            open_flags |= SCE_O_WRONLY;
+        }
+    }
+    if (has_w || has_a)
+    {
+        open_flags |= SCE_O_CREAT;
+    }
+    if (has_w)
+    {
+        open_flags |= SCE_O_TRUNC;
+    }
+    if (has_a)
+    {
+        open_flags |= SCE_O_APPEND;
+    }
+
+    context->hidden.vitaio.buffer.data =
+        (char *) SDL_malloc(READAHEAD_BUFFER_SIZE);
+    if (!context->hidden.vitaio.buffer.data) {
+        return SDL_OutOfMemory();
+    }
+
+    /* Try to open the file on the filesystem first */
+    h = sceIoOpen(filename, open_flags, 0777);
+
+    if (h < 0) {
+        /* Try opening it from app0:/ container if it's a relative path */
+        char path[4096];
+        SDL_snprintf(path, 4096, "app0:/%s", filename);
+        h = sceIoOpen(path, open_flags, 0777);
+    }
+
+    if (h < 0) {
+        SDL_free(context->hidden.vitaio.buffer.data);
+        context->hidden.vitaio.buffer.data = NULL;
+        SDL_SetError("Couldn't open %s", filename);
+        return -2;              /* failed (sceIoOpen) */
+    }
+    context->hidden.vitaio.h = h;
+
+    return 0;                   /* ok */
+}
+
+static Sint64 SDLCALL
+vita_file_size(SDL_RWops * context)
+{
+    SceIoStat st;
+    if (!context || context->hidden.vitaio.h < 0) {
+        return SDL_SetError("vita_file_size: invalid context/file not opened");
+    }
+
+    if (sceIoGetstatByFd(context->hidden.vitaio.h, &st) < 0) {
+        return SDL_SetError("vita_file_size: could not get file size");
+    }
+    return st.st_size;
+}
+
+static Sint64 SDLCALL
+vita_file_seek(SDL_RWops * context, Sint64 offset, int whence)
+{
+    int vitawhence;
+
+    if (!context || context->hidden.vitaio.h < 0) {
+        return SDL_SetError("vita_file_seek: invalid context/file not opened");
+    }
+
+    /* FIXME: We may be able to satisfy the seek within buffered data */
+    if (whence == RW_SEEK_CUR && context->hidden.vitaio.buffer.left) {
+        offset -= (long)context->hidden.vitaio.buffer.left;
+    }
+    context->hidden.vitaio.buffer.left = 0;
+
+    switch (whence) {
+    case RW_SEEK_SET:
+        vitawhence = SCE_SEEK_SET;
+        break;
+    case RW_SEEK_CUR:
+        vitawhence = SCE_SEEK_CUR;
+        break;
+    case RW_SEEK_END:
+        vitawhence = SCE_SEEK_END;
+        break;
+    default:
+        return SDL_SetError("vita_file_seek: Unknown value for 'whence'");
+    }
+
+    return sceIoLseek(context->hidden.vitaio.h, offset, vitawhence);
+}
+
+static size_t SDLCALL
+vita_file_read(SDL_RWops * context, void *ptr, size_t size, size_t maxnum)
+{
+    size_t total_need;
+    size_t total_read = 0;
+    size_t read_ahead;
+    size_t byte_read;
+
+    total_need = size * maxnum;
+
+    if (!context || context->hidden.vitaio.h < 0 || !total_need) {
+        return 0;
+    }
+
+    if (context->hidden.vitaio.buffer.left > 0) {
+        void *data = (char *) context->hidden.vitaio.buffer.data +
+            context->hidden.vitaio.buffer.size -
+            context->hidden.vitaio.buffer.left;
+        read_ahead =
+            SDL_min(total_need, context->hidden.vitaio.buffer.left);
+        SDL_memcpy(ptr, data, read_ahead);
+        context->hidden.vitaio.buffer.left -= read_ahead;
+
+        if (read_ahead == total_need) {
+            return maxnum;
+        }
+        ptr = (char *) ptr + read_ahead;
+        total_need -= read_ahead;
+        total_read += read_ahead;
+    }
+
+    if (total_need < READAHEAD_BUFFER_SIZE) {
+        byte_read = sceIoRead(context->hidden.vitaio.h, context->hidden.vitaio.buffer.data, READAHEAD_BUFFER_SIZE);
+        read_ahead = SDL_min(total_need, (int) byte_read);
+        SDL_memcpy(ptr, context->hidden.vitaio.buffer.data, read_ahead);
+        context->hidden.vitaio.buffer.size = byte_read;
+        context->hidden.vitaio.buffer.left = byte_read - read_ahead;
+        total_read += read_ahead;
+    } else {
+        byte_read = sceIoRead(context->hidden.vitaio.h, ptr, total_need);
+        total_read += byte_read;
+    }
+    return (total_read / size);
+}
+
+static size_t SDLCALL
+vita_file_write(SDL_RWops * context, const void *ptr, size_t size,
+                 size_t num)
+{
+
+    size_t total_bytes;
+    size_t byte_written;
+    size_t nwritten;
+
+    total_bytes = size * num;
+
+    if (!context || context->hidden.vitaio.h < 0 || !size || !total_bytes) {
+        return 0;
+    }
+
+    if (context->hidden.vitaio.buffer.left) {
+        sceIoLseek(context->hidden.vitaio.h, -(SceOff)context->hidden.vitaio.buffer.left, SCE_SEEK_CUR);
+        context->hidden.vitaio.buffer.left = 0;
+    }
+
+    byte_written = sceIoWrite(context->hidden.vitaio.h, ptr, total_bytes);
+
+    nwritten = byte_written / size;
+    return nwritten;
+}
+
+static int SDLCALL
+vita_file_close(SDL_RWops * context)
+{
+    if (context) {
+        if (context->hidden.vitaio.h >= 0) {
+            sceIoClose(context->hidden.vitaio.h);
+            context->hidden.vitaio.h = -1;   /* to be sure */
+        }
+        SDL_free(context->hidden.vitaio.buffer.data);
+        context->hidden.vitaio.buffer.data = NULL;
+        SDL_FreeRW(context);
+    }
+    return 0;
+}
+#endif
+
 #ifdef __WIN32__
 
 /* Functions to read/write Win32 API file pointers */
@@ -203,9 +432,9 @@ windows_file_read(SDL_RWops * context, void *ptr, size_t size, size_t maxnum)
 
     total_need = size * maxnum;
 
-    if (!context || context->hidden.windowsio.h == INVALID_HANDLE_VALUE
-        || !total_need)
+    if (!context || context->hidden.windowsio.h == INVALID_HANDLE_VALUE || !total_need) {
         return 0;
+    }
 
     if (context->hidden.windowsio.buffer.left > 0) {
         void *data = (char *) context->hidden.windowsio.buffer.data +
@@ -258,9 +487,9 @@ windows_file_write(SDL_RWops * context, const void *ptr, size_t size,
 
     total_bytes = size * num;
 
-    if (!context || context->hidden.windowsio.h == INVALID_HANDLE_VALUE
-        || total_bytes <= 0 || !size)
+    if (!context || context->hidden.windowsio.h == INVALID_HANDLE_VALUE || !size || !total_bytes) {
         return 0;
+    }
 
     if (context->hidden.windowsio.buffer.left) {
         SetFilePointer(context->hidden.windowsio.h,
@@ -479,8 +708,7 @@ mem_read(SDL_RWops * context, void *ptr, size_t size, size_t maxnum)
     size_t mem_available;
 
     total_bytes = (maxnum * size);
-    if ((maxnum <= 0) || (size <= 0)
-        || ((total_bytes / maxnum) != size)) {
+    if (!maxnum || !size || ((total_bytes / maxnum) != size)) {
         return 0;
     }
 
@@ -589,10 +817,23 @@ SDL_RWFromFile(const char *file, const char *mode)
     rwops->write = windows_file_write;
     rwops->close = windows_file_close;
     rwops->type = SDL_RWOPS_WINFILE;
-
+#elif defined(__VITA__)
+    rwops = SDL_AllocRW();
+    if (!rwops)
+        return NULL;            /* SDL_SetError already setup by SDL_AllocRW() */
+    if (vita_file_open(rwops, file, mode) < 0) {
+        SDL_FreeRW(rwops);
+        return NULL;
+    }
+    rwops->size = vita_file_size;
+    rwops->seek = vita_file_seek;
+    rwops->read = vita_file_read;
+    rwops->write = vita_file_write;
+    rwops->close = vita_file_close;
+    rwops->type = SDL_RWOPS_VITAFILE;
 #elif HAVE_STDIO_H
     {
-        #ifdef __APPLE__
+        #if __APPLE__ && !SDL_FILE_DISABLED // TODO: add dummy?
         FILE *fp = SDL_OpenFPFromBundleOrFallback(file, mode);
         #elif __WINRT__
         FILE *fp = NULL;
diff --git a/Engine/lib/sdl/src/file/cocoa/SDL_rwopsbundlesupport.h b/Engine/lib/sdl/src/file/cocoa/SDL_rwopsbundlesupport.h
index 4a25727d6..b77b53e80 100644
--- a/Engine/lib/sdl/src/file/cocoa/SDL_rwopsbundlesupport.h
+++ b/Engine/lib/sdl/src/file/cocoa/SDL_rwopsbundlesupport.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/file/cocoa/SDL_rwopsbundlesupport.m b/Engine/lib/sdl/src/file/cocoa/SDL_rwopsbundlesupport.m
index 2a3c1a329..478522cea 100644
--- a/Engine/lib/sdl/src/file/cocoa/SDL_rwopsbundlesupport.m
+++ b/Engine/lib/sdl/src/file/cocoa/SDL_rwopsbundlesupport.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/filesystem/android/SDL_sysfilesystem.c b/Engine/lib/sdl/src/filesystem/android/SDL_sysfilesystem.c
index 1936bbc5f..0ffe96b15 100644
--- a/Engine/lib/sdl/src/filesystem/android/SDL_sysfilesystem.c
+++ b/Engine/lib/sdl/src/filesystem/android/SDL_sysfilesystem.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/filesystem/cocoa/SDL_sysfilesystem.m b/Engine/lib/sdl/src/filesystem/cocoa/SDL_sysfilesystem.m
index b87de6e36..b20e8fc5b 100644
--- a/Engine/lib/sdl/src/filesystem/cocoa/SDL_sysfilesystem.m
+++ b/Engine/lib/sdl/src/filesystem/cocoa/SDL_sysfilesystem.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/filesystem/dummy/SDL_sysfilesystem.c b/Engine/lib/sdl/src/filesystem/dummy/SDL_sysfilesystem.c
index 9106ee002..7f22183f9 100644
--- a/Engine/lib/sdl/src/filesystem/dummy/SDL_sysfilesystem.c
+++ b/Engine/lib/sdl/src/filesystem/dummy/SDL_sysfilesystem.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/filesystem/emscripten/SDL_sysfilesystem.c b/Engine/lib/sdl/src/filesystem/emscripten/SDL_sysfilesystem.c
index 06248c469..f007af625 100644
--- a/Engine/lib/sdl/src/filesystem/emscripten/SDL_sysfilesystem.c
+++ b/Engine/lib/sdl/src/filesystem/emscripten/SDL_sysfilesystem.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -44,6 +44,7 @@ SDL_GetPrefPath(const char *org, const char *app)
 {
     const char *append = "/libsdl/";
     char *retval;
+    char *ptr = NULL;
     size_t len = 0;
 
     if (!app) {
@@ -67,7 +68,17 @@ SDL_GetPrefPath(const char *org, const char *app)
         SDL_snprintf(retval, len, "%s%s/", append, app);
     }
 
+    for (ptr = retval+1; *ptr; ptr++) {
+        if (*ptr == '/') {
+            *ptr = '\0';
+            if (mkdir(retval, 0700) != 0 && errno != EEXIST)
+                goto error;
+            *ptr = '/';
+        }
+    }
+
     if (mkdir(retval, 0700) != 0 && errno != EEXIST) {
+error:
         SDL_SetError("Couldn't create directory '%s': '%s'", retval, strerror(errno));
         SDL_free(retval);
         return NULL;
diff --git a/Engine/lib/sdl/src/filesystem/haiku/SDL_sysfilesystem.cc b/Engine/lib/sdl/src/filesystem/haiku/SDL_sysfilesystem.cc
index 2557d7993..f359f36fe 100644
--- a/Engine/lib/sdl/src/filesystem/haiku/SDL_sysfilesystem.cc
+++ b/Engine/lib/sdl/src/filesystem/haiku/SDL_sysfilesystem.cc
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/filesystem/nacl/SDL_sysfilesystem.c b/Engine/lib/sdl/src/filesystem/nacl/SDL_sysfilesystem.c
index cfdffd480..b5bbe9841 100644
--- a/Engine/lib/sdl/src/filesystem/nacl/SDL_sysfilesystem.c
+++ b/Engine/lib/sdl/src/filesystem/nacl/SDL_sysfilesystem.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/filesystem/os2/SDL_sysfilesystem.c b/Engine/lib/sdl/src/filesystem/os2/SDL_sysfilesystem.c
index e9e4be676..3203f0b3a 100644
--- a/Engine/lib/sdl/src/filesystem/os2/SDL_sysfilesystem.c
+++ b/Engine/lib/sdl/src/filesystem/os2/SDL_sysfilesystem.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -25,12 +25,13 @@
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /* System dependent filesystem routines                                */
 
+#include "../../core/os2/SDL_os2.h"
 #include "SDL_error.h"
 #include "SDL_filesystem.h"
-#include "../../core/os2/SDL_os2.h"
 
 #define INCL_DOSFILEMGR
 #define INCL_DOSPROCESS
+#define INCL_DOSMODULEMGR
 #define INCL_DOSERRORS
 #include <os2.h>
 
@@ -42,30 +43,31 @@ SDL_GetBasePath(void)
     PPIB    pib;
     ULONG   ulRC = DosGetInfoBlocks(&tib, &pib);
     PCHAR   pcEnd;
-    ULONG   cbResult;
-    CHAR    acBuf[_MAX_PATH];
+    CHAR    acBuf[CCHMAXPATH];
 
     if (ulRC != NO_ERROR) {
-        debug_os2("DosGetInfoBlocks() failed, rc = %u", ulRC);
+        SDL_SetError("Can't get process information block (E%lu)", ulRC);
         return NULL;
     }
 
-    pcEnd = SDL_strrchr(pib->pib_pchcmd, '\\');
+    ulRC = DosQueryModuleName(pib->pib_hmte, sizeof(acBuf), acBuf);
+    if (ulRC != NO_ERROR) {
+        SDL_SetError("Can't query the module name (E%lu)", ulRC);
+        return NULL;
+    }
+
+    pcEnd = SDL_strrchr(acBuf, '\\');
     if (pcEnd != NULL)
-        pcEnd++;
+        pcEnd[1] = '\0';
     else {
-        if (pib->pib_pchcmd[1] == ':')
-            pcEnd = &pib->pib_pchcmd[2];
+        if (acBuf[1] == ':') /* e.g. "C:FOO" */
+            acBuf[2] = '\0';
         else {
-            SDL_SetError("No path in pib->pib_pchcmd");
+            SDL_SetError("No path in module name");
             return NULL;
         }
     }
 
-    cbResult = pcEnd - pib->pib_pchcmd;
-    SDL_memcpy(acBuf, pib->pib_pchcmd, cbResult);
-    acBuf[cbResult] = '\0';
-
     return OS2_SysToUTF8(acBuf);
 }
 
@@ -73,7 +75,7 @@ char *
 SDL_GetPrefPath(const char *org, const char *app)
 {
     PSZ     pszPath;
-    CHAR    acBuf[_MAX_PATH];
+    CHAR    acBuf[CCHMAXPATH];
     int     lPosApp, lPosOrg;
     PSZ     pszApp, pszOrg;
 
diff --git a/Engine/lib/sdl/src/filesystem/psp/SDL_sysfilesystem.c b/Engine/lib/sdl/src/filesystem/psp/SDL_sysfilesystem.c
new file mode 100644
index 000000000..e9c6ee49e
--- /dev/null
+++ b/Engine/lib/sdl/src/filesystem/psp/SDL_sysfilesystem.c
@@ -0,0 +1,79 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#include <sys/stat.h>
+#include <unistd.h>
+
+#if defined(SDL_FILESYSTEM_PSP)
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/* System dependent filesystem routines                                */
+
+#include "SDL_error.h"
+#include "SDL_filesystem.h"
+
+char *
+SDL_GetBasePath(void)
+{
+  char *retval = NULL;
+  size_t len;
+  char cwd[FILENAME_MAX];
+  
+  getcwd(cwd, sizeof(cwd));
+  len = SDL_strlen(cwd) + 2;
+  retval = (char *) SDL_malloc(len);
+  SDL_snprintf(retval, len, "%s/", cwd);
+
+  return retval;
+}
+
+char *
+SDL_GetPrefPath(const char *org, const char *app)
+{
+  char *retval = NULL;
+  size_t len;
+  char *base = SDL_GetBasePath();
+  if (!app) {
+    SDL_InvalidParamError("app");
+    return NULL;
+  }
+  if(!org) {
+    org = "";
+  }
+
+  len = SDL_strlen(base) + SDL_strlen(org) + SDL_strlen(app) + 4;
+  retval = (char *) SDL_malloc(len);
+
+  if (*org) {
+    SDL_snprintf(retval, len, "%s%s/%s/", base, org, app);
+  } else {
+    SDL_snprintf(retval, len, "%s%s/", base, app);
+  }
+  free(base);
+
+  mkdir(retval, 0755);
+  return retval;
+}
+
+#endif /* SDL_FILESYSTEM_PSP */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/filesystem/riscos/SDL_sysfilesystem.c b/Engine/lib/sdl/src/filesystem/riscos/SDL_sysfilesystem.c
new file mode 100644
index 000000000..58ff9f161
--- /dev/null
+++ b/Engine/lib/sdl/src/filesystem/riscos/SDL_sysfilesystem.c
@@ -0,0 +1,210 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#ifdef SDL_FILESYSTEM_RISCOS
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/* System dependent filesystem routines                                */
+
+#include <kernel.h>
+#include <swis.h>
+#include <unixlib/local.h>
+
+#include "SDL_error.h"
+#include "SDL_stdinc.h"
+#include "SDL_filesystem.h"
+
+/* Wrapper around __unixify_std that uses SDL's memory allocators */
+static char *
+SDL_unixify_std(const char *ro_path, char *buffer, size_t buf_len, int filetype)
+{
+    const char *const in_buf = buffer; /* = NULL if we allocate the buffer.  */
+
+    if (!buffer) {
+        /* This matches the logic in __unixify, with an additional byte for the
+         * extra path separator.
+         */
+        buf_len = SDL_strlen(ro_path) + 14 + 1;
+        buffer = SDL_malloc(buf_len);
+
+        if (!buffer) {
+            SDL_OutOfMemory();
+            return NULL;
+        }
+    }
+
+    if (!__unixify_std(ro_path, buffer, buf_len, filetype)) {
+        if (!in_buf)
+            SDL_free(buffer);
+
+        SDL_SetError("Could not convert '%s' to a Unix-style path", ro_path);
+        return NULL;
+    }
+
+    /* HACK: It's necessary to add an extra path separator here since SDL's API
+     * requires it, however paths with trailing separators aren't normally valid
+     * on RISC OS.
+     */
+    if (__get_riscosify_control() & __RISCOSIFY_NO_PROCESS)
+        SDL_strlcat(buffer, ".", buf_len);
+    else
+        SDL_strlcat(buffer, "/", buf_len);
+
+    return buffer;
+}
+
+static char *
+canonicalisePath(const char *path, const char *pathVar)
+{
+    _kernel_oserror *error;
+    _kernel_swi_regs regs;
+    char *buf;
+
+    regs.r[0] = 37;
+    regs.r[1] = (int)path;
+    regs.r[2] = 0;
+    regs.r[3] = (int)pathVar;
+    regs.r[4] = 0;
+    regs.r[5] = 0;
+    error = _kernel_swi(OS_FSControl, &regs, &regs);
+    if (error) {
+        SDL_SetError("Couldn't canonicalise path: %s", error->errmess);
+        return NULL;
+    }
+
+    regs.r[5] = 1 - regs.r[5];
+    buf = SDL_malloc(regs.r[5]);
+    if (!buf) {
+        SDL_OutOfMemory();
+        return NULL;
+    }
+    regs.r[2] = (int)buf;
+    error = _kernel_swi(OS_FSControl, &regs, &regs);
+    if (error) {
+        SDL_SetError("Couldn't canonicalise path: %s", error->errmess);
+        SDL_free(buf);
+        return NULL;
+    }
+
+    return buf;
+}
+
+static _kernel_oserror *
+createDirectoryRecursive(char *path)
+{
+    char *ptr = NULL;
+    _kernel_oserror *error;
+    _kernel_swi_regs regs;
+    regs.r[0] = 8;
+    regs.r[1] = (int)path;
+    regs.r[2] = 0;
+
+    for (ptr = path+1; *ptr; ptr++) {
+        if (*ptr == '.') {
+            *ptr = '\0';
+            error = _kernel_swi(OS_File, &regs, &regs);
+            *ptr = '.';
+            if (error != NULL)
+                return error;
+        }
+    }
+    return _kernel_swi(OS_File, &regs, &regs);
+}
+
+char *
+SDL_GetBasePath(void)
+{
+    _kernel_swi_regs regs;
+    _kernel_oserror *error;
+    char *canon, *ptr, *retval;
+
+    error = _kernel_swi(OS_GetEnv, &regs, &regs);
+    if (error) {
+        return NULL;
+    }
+
+    canon = canonicalisePath((const char *)regs.r[0], "Run$Path");
+    if (!canon) {
+        return NULL;
+    }
+
+    /* chop off filename. */
+    ptr = SDL_strrchr(canon, '.');
+    if (ptr != NULL)
+        *ptr = '\0';
+
+    retval = SDL_unixify_std(canon, NULL, 0, __RISCOSIFY_FILETYPE_NOTSPECIFIED);
+    SDL_free(canon);
+    return retval;
+}
+
+char *
+SDL_GetPrefPath(const char *org, const char *app)
+{
+    char *canon, *dir, *retval;
+    size_t len;
+    _kernel_oserror *error;
+
+    if (!app) {
+        SDL_InvalidParamError("app");
+        return NULL;
+    }
+    if (!org) {
+        org = "";
+    }
+
+    canon = canonicalisePath("<Choices$Write>", "Run$Path");
+    if (!canon) {
+        return NULL;
+    }
+
+    len = SDL_strlen(canon) + SDL_strlen(org) + SDL_strlen(app) + 4;
+    dir = (char *) SDL_malloc(len);
+    if (!dir) {
+        SDL_OutOfMemory();
+        SDL_free(canon);
+        return NULL;
+    }
+
+    if (*org) {
+        SDL_snprintf(dir, len, "%s.%s.%s", canon, org, app);
+    } else {
+        SDL_snprintf(dir, len, "%s.%s", canon, app);
+    }
+
+    SDL_free(canon);
+
+    error = createDirectoryRecursive(dir);
+    if (error != NULL) {
+        SDL_SetError("Couldn't create directory: %s", error->errmess);
+        SDL_free(dir);
+        return NULL;
+    }
+
+    retval = SDL_unixify_std(dir, NULL, 0, __RISCOSIFY_FILETYPE_NOTSPECIFIED);
+    SDL_free(dir);
+    return retval;
+}
+
+#endif /* SDL_FILESYSTEM_RISCOS */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/filesystem/unix/SDL_sysfilesystem.c b/Engine/lib/sdl/src/filesystem/unix/SDL_sysfilesystem.c
index f2dc846c8..e25229d6d 100644
--- a/Engine/lib/sdl/src/filesystem/unix/SDL_sysfilesystem.c
+++ b/Engine/lib/sdl/src/filesystem/unix/SDL_sysfilesystem.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -78,6 +78,60 @@ readSymLink(const char *path)
 }
 #endif
 
+
+#if defined(__OPENBSD__)
+static char *search_path_for_binary(const char *bin)
+{
+    char *envr = SDL_getenv("PATH");
+    size_t alloc_size;
+    char *exe = NULL;
+    char *start = envr;
+    char *ptr;
+
+    if (!envr) {
+        SDL_SetError("No $PATH set");
+        return NULL;
+    }
+
+    envr = SDL_strdup(envr);
+    if (!envr) {
+        SDL_OutOfMemory();
+        return NULL;
+    }
+
+    SDL_assert(bin != NULL);
+
+    alloc_size = SDL_strlen(bin) + SDL_strlen(envr) + 2;
+    exe = (char *) SDL_malloc(alloc_size);
+
+    do {
+        ptr = SDL_strchr(start, ':');  /* find next $PATH separator. */
+        if (ptr != start) {
+            if (ptr) {
+                *ptr = '\0';
+            }
+
+            /* build full binary path... */
+            SDL_snprintf(exe, alloc_size, "%s%s%s", start, (ptr && (ptr[-1] == '/')) ? "" : "/", bin);
+
+            if (access(exe, X_OK) == 0) { /* Exists as executable? We're done. */
+                SDL_free(envr);
+                return exe;
+            }
+        }
+        start = ptr + 1;  /* start points to beginning of next element. */
+    } while (ptr != NULL);
+
+    SDL_free(envr);
+    SDL_free(exe);
+
+    SDL_SetError("Process not found in $PATH");
+    return NULL;  /* doesn't exist in path. */
+}
+#endif
+
+
+
 char *
 SDL_GetBasePath(void)
 {
@@ -96,21 +150,47 @@ SDL_GetBasePath(void)
     }
 #endif
 #if defined(__OPENBSD__)
-    char **retvalargs;
+    /* Please note that this will fail if the process was launched with a relative path and the cwd has changed, or argv is altered. So don't do that. Or add a new sysctl to OpenBSD. */
+    char **cmdline;
     size_t len;
     const int mib[] = { CTL_KERN, KERN_PROC_ARGS, getpid(), KERN_PROC_ARGV };
     if (sysctl(mib, 4, NULL, &len, NULL, 0) != -1) {
-        retvalargs = SDL_malloc(len);
-        if (!retvalargs) {
+        char *exe;
+        char *realpathbuf = (char *) SDL_malloc(PATH_MAX + 1);
+        if (!realpathbuf) {
             SDL_OutOfMemory();
             return NULL;
         }
-        sysctl(mib, 4, retvalargs, &len, NULL, 0);
-        retval = SDL_malloc(PATH_MAX + 1);
-        if (retval)
-            realpath(retvalargs[0], retval);
 
-        SDL_free(retvalargs);
+        cmdline = SDL_malloc(len);
+        if (!cmdline) {
+            SDL_free(realpathbuf);
+            SDL_OutOfMemory();
+            return NULL;
+        }
+
+        sysctl(mib, 4, cmdline, &len, NULL, 0);
+
+        exe = cmdline[0];
+        if (SDL_strchr(exe, '/') == NULL) {  /* not a relative or absolute path, check $PATH for it */
+            exe = search_path_for_binary(cmdline[0]);
+        }
+
+        if (exe) {
+            if (realpath(exe, realpathbuf) != NULL) {
+                retval = realpathbuf;
+            }
+
+            if (exe != cmdline[0]) {
+                SDL_free(exe);
+            }
+        }
+
+        if (!retval) {
+            SDL_free(realpathbuf);
+        }
+
+        SDL_free(cmdline);
     }
 #endif
 #if defined(__SOLARIS__)
@@ -165,7 +245,7 @@ SDL_GetBasePath(void)
 
     if (retval != NULL) {
         /* try to shrink buffer... */
-        char *ptr = (char *) SDL_realloc(retval, strlen(retval) + 1);
+        char *ptr = (char *) SDL_realloc(retval, SDL_strlen(retval) + 1);
         if (ptr != NULL)
             retval = ptr;  /* oh well if it failed. */
     }
diff --git a/Engine/lib/sdl/src/filesystem/vita/SDL_sysfilesystem.c b/Engine/lib/sdl/src/filesystem/vita/SDL_sysfilesystem.c
new file mode 100644
index 000000000..1952cadf5
--- /dev/null
+++ b/Engine/lib/sdl/src/filesystem/vita/SDL_sysfilesystem.c
@@ -0,0 +1,95 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#ifdef SDL_FILESYSTEM_VITA
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/* System dependent filesystem routines                                */
+
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <psp2/io/stat.h>
+#include <sys/types.h>
+#include <limits.h>
+#include <fcntl.h>
+
+#include "SDL_error.h"
+#include "SDL_stdinc.h"
+#include "SDL_filesystem.h"
+#include "SDL_rwops.h"
+
+char *
+SDL_GetBasePath(void)
+{
+    const char *basepath = "app0:/";
+    char *retval = SDL_strdup(basepath);
+    return retval;
+}
+
+char *
+SDL_GetPrefPath(const char *org, const char *app)
+{
+    const char *envr = "ux0:/data/";
+    char *retval = NULL;
+    char *ptr = NULL;
+    size_t len = 0;
+
+    if (!app) {
+        SDL_InvalidParamError("app");
+        return NULL;
+    }
+    if (!org) {
+        org = "";
+    }
+
+    len = SDL_strlen(envr);
+
+    len += SDL_strlen(org) + SDL_strlen(app) + 3;
+    retval = (char *) SDL_malloc(len);
+    if (!retval) {
+        SDL_OutOfMemory();
+        return NULL;
+    }
+
+    if (*org) {
+        SDL_snprintf(retval, len, "%s%s/%s/", envr, org, app);
+    } else {
+        SDL_snprintf(retval, len, "%s%s/", envr, app);
+    }
+
+    for (ptr = retval+1; *ptr; ptr++) {
+        if (*ptr == '/') {
+            *ptr = '\0';
+            sceIoMkdir(retval, 0777);
+            *ptr = '/';
+        }
+    }
+    sceIoMkdir(retval, 0777);
+
+    return retval;
+}
+
+#endif /* SDL_FILESYSTEM_VITA */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/filesystem/windows/SDL_sysfilesystem.c b/Engine/lib/sdl/src/filesystem/windows/SDL_sysfilesystem.c
index fedf49567..d50fb511b 100644
--- a/Engine/lib/sdl/src/filesystem/windows/SDL_sysfilesystem.c
+++ b/Engine/lib/sdl/src/filesystem/windows/SDL_sysfilesystem.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -39,7 +39,7 @@ SDL_GetBasePath(void)
     GetModuleFileNameExW_t pGetModuleFileNameExW;
     DWORD buflen = 128;
     WCHAR *path = NULL;
-    HANDLE psapi = LoadLibrary(L"psapi.dll");
+    HANDLE psapi = LoadLibrary(TEXT("psapi.dll"));
     char *retval = NULL;
     DWORD len = 0;
     int i;
@@ -68,7 +68,9 @@ SDL_GetBasePath(void)
         path = (WCHAR *) ptr;
 
         len = pGetModuleFileNameExW(GetCurrentProcess(), NULL, path, buflen);
-        if (len != buflen) {
+        /* if it truncated, then len >= buflen - 1 */
+        /* if there was enough room (or failure), len < buflen - 1 */
+        if (len < buflen - 1) {
             break;
         }
 
@@ -93,7 +95,7 @@ SDL_GetBasePath(void)
     SDL_assert(i > 0); /* Should have been an absolute path. */
     path[i+1] = '\0';  /* chop off filename. */
 
-    retval = WIN_StringToUTF8(path);
+    retval = WIN_StringToUTF8W(path);
     SDL_free(path);
 
     return retval;
@@ -130,20 +132,20 @@ SDL_GetPrefPath(const char *org, const char *app)
         return NULL;
     }
 
-    worg = WIN_UTF8ToString(org);
+    worg = WIN_UTF8ToStringW(org);
     if (worg == NULL) {
         SDL_OutOfMemory();
         return NULL;
     }
 
-    wapp = WIN_UTF8ToString(app);
+    wapp = WIN_UTF8ToStringW(app);
     if (wapp == NULL) {
         SDL_free(worg);
         SDL_OutOfMemory();
         return NULL;
     }
 
-    new_wpath_len = lstrlenW(worg) + lstrlenW(wapp) + lstrlenW(path) + 3;
+    new_wpath_len = SDL_wcslen(worg) + SDL_wcslen(wapp) + SDL_wcslen(path) + 3;
 
     if ((new_wpath_len + 1) > MAX_PATH) {
         SDL_free(worg);
@@ -153,8 +155,8 @@ SDL_GetPrefPath(const char *org, const char *app)
     }
 
     if (*worg) {
-        lstrcatW(path, L"\\");
-        lstrcatW(path, worg);
+        SDL_wcslcat(path, L"\\", SDL_arraysize(path));
+        SDL_wcslcat(path, worg, SDL_arraysize(path));
     }
     SDL_free(worg);
 
@@ -167,8 +169,8 @@ SDL_GetPrefPath(const char *org, const char *app)
         }
     }
 
-    lstrcatW(path, L"\\");
-    lstrcatW(path, wapp);
+    SDL_wcslcat(path, L"\\", SDL_arraysize(path));
+    SDL_wcslcat(path, wapp, SDL_arraysize(path));
     SDL_free(wapp);
 
     api_result = CreateDirectoryW(path, NULL);
@@ -179,9 +181,9 @@ SDL_GetPrefPath(const char *org, const char *app)
         }
     }
 
-    lstrcatW(path, L"\\");
+    SDL_wcslcat(path, L"\\", SDL_arraysize(path));
 
-    retval = WIN_StringToUTF8(path);
+    retval = WIN_StringToUTF8W(path);
 
     return retval;
 }
diff --git a/Engine/lib/sdl/src/filesystem/winrt/SDL_sysfilesystem.cpp b/Engine/lib/sdl/src/filesystem/winrt/SDL_sysfilesystem.cpp
index 26cf65cba..115b45b1a 100644
--- a/Engine/lib/sdl/src/filesystem/winrt/SDL_sysfilesystem.cpp
+++ b/Engine/lib/sdl/src/filesystem/winrt/SDL_sysfilesystem.cpp
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/haptic/SDL_haptic.c b/Engine/lib/sdl/src/haptic/SDL_haptic.c
index 6f7432d16..3f87143ca 100644
--- a/Engine/lib/sdl/src/haptic/SDL_haptic.c
+++ b/Engine/lib/sdl/src/haptic/SDL_haptic.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/haptic/SDL_haptic_c.h b/Engine/lib/sdl/src/haptic/SDL_haptic_c.h
index 5534bfd33..d83496599 100644
--- a/Engine/lib/sdl/src/haptic/SDL_haptic_c.h
+++ b/Engine/lib/sdl/src/haptic/SDL_haptic_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/haptic/SDL_syshaptic.h b/Engine/lib/sdl/src/haptic/SDL_syshaptic.h
index 737bbd11a..9e5840957 100644
--- a/Engine/lib/sdl/src/haptic/SDL_syshaptic.h
+++ b/Engine/lib/sdl/src/haptic/SDL_syshaptic.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/haptic/android/SDL_syshaptic.c b/Engine/lib/sdl/src/haptic/android/SDL_syshaptic.c
index 3d180eaf7..dda573313 100644
--- a/Engine/lib/sdl/src/haptic/android/SDL_syshaptic.c
+++ b/Engine/lib/sdl/src/haptic/android/SDL_syshaptic.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -155,7 +155,7 @@ SDL_SYS_HapticOpen(SDL_Haptic *haptic)
 int
 SDL_SYS_HapticMouse(void)
 {
-    return 0;
+    return -1;
 }
 
 
diff --git a/Engine/lib/sdl/src/haptic/darwin/SDL_syshaptic.c b/Engine/lib/sdl/src/haptic/darwin/SDL_syshaptic.c
index f8a2af5df..1141bec76 100644
--- a/Engine/lib/sdl/src/haptic/darwin/SDL_syshaptic.c
+++ b/Engine/lib/sdl/src/haptic/darwin/SDL_syshaptic.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -653,7 +653,7 @@ SDL_SYS_HapticOpenFromJoystick(SDL_Haptic * haptic, SDL_Joystick * joystick)
 
     return SDL_SYS_HapticOpenFromService(haptic, joystick->hwdata->ffservice);
 #else
-	return -1;
+    return -1;
 #endif
 }
 
diff --git a/Engine/lib/sdl/src/haptic/darwin/SDL_syshaptic_c.h b/Engine/lib/sdl/src/haptic/darwin/SDL_syshaptic_c.h
index ca3b7e6c0..f7f890a7c 100644
--- a/Engine/lib/sdl/src/haptic/darwin/SDL_syshaptic_c.h
+++ b/Engine/lib/sdl/src/haptic/darwin/SDL_syshaptic_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/haptic/dummy/SDL_syshaptic.c b/Engine/lib/sdl/src/haptic/dummy/SDL_syshaptic.c
index c9f983c08..f356195b7 100644
--- a/Engine/lib/sdl/src/haptic/dummy/SDL_syshaptic.c
+++ b/Engine/lib/sdl/src/haptic/dummy/SDL_syshaptic.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/haptic/linux/SDL_syshaptic.c b/Engine/lib/sdl/src/haptic/linux/SDL_syshaptic.c
index 0e160faec..a9be7e0d3 100644
--- a/Engine/lib/sdl/src/haptic/linux/SDL_syshaptic.c
+++ b/Engine/lib/sdl/src/haptic/linux/SDL_syshaptic.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -35,7 +35,6 @@
 #include <fcntl.h>              /* O_RDWR */
 #include <limits.h>             /* INT_MAX */
 #include <errno.h>              /* errno, strerror */
-#include <math.h>               /* atan2 */
 #include <sys/stat.h>           /* stat */
 
 /* Just in case. */
@@ -166,7 +165,7 @@ SDL_SYS_HapticInit(void)
     i = 0;
     for (j = 0; j < MAX_HAPTICS; ++j) {
 
-        snprintf(path, PATH_MAX, joydev_pattern, i++);
+        SDL_snprintf(path, PATH_MAX, joydev_pattern, i++);
         MaybeAddDevice(path);
     }
 
@@ -260,7 +259,7 @@ MaybeAddDevice(const char *path)
     }
 
     /* try to open */
-    fd = open(path, O_RDWR, 0);
+    fd = open(path, O_RDWR | O_CLOEXEC, 0);
     if (fd < 0) {
         return -1;
     }
@@ -375,7 +374,7 @@ SDL_SYS_HapticName(int index)
     item = HapticByDevIndex(index);
     /* Open the haptic device. */
     name = NULL;
-    fd = open(item->fname, O_RDONLY, 0);
+    fd = open(item->fname, O_RDONLY | O_CLOEXEC, 0);
 
     if (fd >= 0) {
 
@@ -453,7 +452,7 @@ SDL_SYS_HapticOpen(SDL_Haptic * haptic)
 
     item = HapticByDevIndex(haptic->index);
     /* Open the character device */
-    fd = open(item->fname, O_RDWR, 0);
+    fd = open(item->fname, O_RDWR | O_CLOEXEC, 0);
     if (fd < 0) {
         return SDL_SetError("Haptic: Unable to open %s: %s",
                             item->fname, strerror(errno));
@@ -483,7 +482,7 @@ SDL_SYS_HapticMouse(void)
 
     for (item = SDL_hapticlist; item; item = item->next) {
         /* Open the device. */
-        fd = open(item->fname, O_RDWR, 0);
+        fd = open(item->fname, O_RDWR | O_CLOEXEC, 0);
         if (fd < 0) {
             return SDL_SetError("Haptic: Unable to open %s: %s",
                                 item->fname, strerror(errno));
@@ -570,7 +569,7 @@ SDL_SYS_HapticOpenFromJoystick(SDL_Haptic * haptic, SDL_Joystick * joystick)
         return SDL_SetError("Haptic: Joystick doesn't have Haptic capabilities");
     }
 
-    fd = open(joystick->hwdata->fname, O_RDWR, 0);
+    fd = open(joystick->hwdata->fname, O_RDWR | O_CLOEXEC, 0);
     if (fd < 0) {
         return SDL_SetError("Haptic: Unable to open %s: %s",
                             joystick->hwdata->fname, strerror(errno));
@@ -713,10 +712,10 @@ SDL_SYS_ToDirection(Uint16 *dest, SDL_HapticDirection * src)
         else {
             float f = SDL_atan2(src->dir[1], src->dir[0]);    /* Ideally we'd use fixed point math instead of floats... */
                     /*
-                      atan2 takes the parameters: Y-axis-value and X-axis-value (in that order)
+                      SDL_atan2 takes the parameters: Y-axis-value and X-axis-value (in that order)
                        - Y-axis-value is the second coordinate (from center to SOUTH)
                        - X-axis-value is the first coordinate (from center to EAST)
-                        We add 36000, because atan2 also returns negative values. Then we practically
+                        We add 36000, because SDL_atan2 also returns negative values. Then we practically
                         have the first spherical value. Therefore we proceed as in case
                         SDL_HAPTIC_SPHERICAL and add another 9000 to get the polar value.
                       --> add 45000 in total
diff --git a/Engine/lib/sdl/src/haptic/windows/SDL_dinputhaptic.c b/Engine/lib/sdl/src/haptic/windows/SDL_dinputhaptic.c
index 322afe9a6..f10c369af 100644
--- a/Engine/lib/sdl/src/haptic/windows/SDL_dinputhaptic.c
+++ b/Engine/lib/sdl/src/haptic/windows/SDL_dinputhaptic.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -20,6 +20,7 @@
 */
 #include "../../SDL_internal.h"
 
+#include "SDL.h"
 #include "SDL_error.h"
 #include "SDL_haptic.h"
 #include "../SDL_syshaptic.h"
@@ -61,7 +62,7 @@ static BOOL CALLBACK
 EnumHapticsCallback(const DIDEVICEINSTANCE * pdidInstance, VOID * pContext)
 {
     (void) pContext;
-    SDL_DINPUT_MaybeAddDevice(pdidInstance);
+    SDL_DINPUT_HapticMaybeAddDevice(pdidInstance);
     return DIENUM_CONTINUE;  /* continue enumerating */
 }
 
@@ -70,6 +71,7 @@ SDL_DINPUT_HapticInit(void)
 {
     HRESULT ret;
     HINSTANCE instance;
+    DWORD devClass;
 
     if (dinput != NULL) {       /* Already open. */
         return SDL_SetError("Haptic: SubSystem already open.");
@@ -103,21 +105,29 @@ SDL_DINPUT_HapticInit(void)
     }
 
     /* Look for haptic devices. */
-    ret = IDirectInput8_EnumDevices(dinput,
-        0,
-        EnumHapticsCallback,
-        NULL,
-        DIEDFL_FORCEFEEDBACK |
-        DIEDFL_ATTACHEDONLY);
-    if (FAILED(ret)) {
-        SDL_SYS_HapticQuit();
-        return DI_SetError("Enumerating DirectInput devices", ret);
+    for (devClass = DI8DEVCLASS_DEVICE; devClass <= DI8DEVCLASS_GAMECTRL; devClass++) {
+        if (devClass == DI8DEVCLASS_GAMECTRL && SDL_WasInit(SDL_INIT_JOYSTICK)) {
+            /* The joystick subsystem will manage adding DInput joystick haptic devices */
+            continue;
+        }
+
+        ret = IDirectInput8_EnumDevices(dinput,
+                                        devClass,
+                                        EnumHapticsCallback,
+                                        NULL,
+                                        DIEDFL_FORCEFEEDBACK |
+                                        DIEDFL_ATTACHEDONLY);
+        if (FAILED(ret)) {
+            SDL_SYS_HapticQuit();
+            return DI_SetError("Enumerating DirectInput devices", ret);
+        }
     }
+
     return 0;
 }
 
 int
-SDL_DINPUT_MaybeAddDevice(const DIDEVICEINSTANCE * pdidInstance)
+SDL_DINPUT_HapticMaybeAddDevice(const DIDEVICEINSTANCE * pdidInstance)
 {
     HRESULT ret;
     LPDIRECTINPUTDEVICE8 device;
@@ -176,7 +186,7 @@ SDL_DINPUT_MaybeAddDevice(const DIDEVICEINSTANCE * pdidInstance)
 }
 
 int
-SDL_DINPUT_MaybeRemoveDevice(const DIDEVICEINSTANCE * pdidInstance)
+SDL_DINPUT_HapticMaybeRemoveDevice(const DIDEVICEINSTANCE * pdidInstance)
 {
     SDL_hapticlist_item *item;
     SDL_hapticlist_item *prev = NULL;
@@ -419,7 +429,6 @@ SDL_DINPUT_HapticOpen(SDL_Haptic * haptic, SDL_hapticlist_item *item)
 {
     HRESULT ret;
     LPDIRECTINPUTDEVICE8 device;
-    LPDIRECTINPUTDEVICE8 device8;
 
     /* Open the device */
     ret = IDirectInput8_CreateDevice(dinput, &item->instance.guidInstance,
@@ -429,19 +438,8 @@ SDL_DINPUT_HapticOpen(SDL_Haptic * haptic, SDL_hapticlist_item *item)
         return -1;
     }
 
-    /* Now get the IDirectInputDevice8 interface, instead. */
-    ret = IDirectInputDevice8_QueryInterface(device,
-        &IID_IDirectInputDevice8,
-        (LPVOID *)&device8);
-    /* Done with the temporary one now. */
-    IDirectInputDevice8_Release(device);
-    if (FAILED(ret)) {
-        DI_SetError("Querying DirectInput interface", ret);
-        return -1;
-    }
-
-    if (SDL_DINPUT_HapticOpenFromDevice(haptic, device8, SDL_FALSE) < 0) {
-        IDirectInputDevice8_Release(device8);
+    if (SDL_DINPUT_HapticOpenFromDevice(haptic, device, SDL_FALSE) < 0) {
+        IDirectInputDevice8_Release(device);
         return -1;
     }
     return 0;
@@ -494,8 +492,7 @@ SDL_DINPUT_HapticOpenFromJoystick(SDL_Haptic * haptic, SDL_Joystick * joystick)
         ++index;
     }
 
-    SDL_SetError("Couldn't find joystick in haptic device list");
-    return -1;
+    return SDL_SetError("Couldn't find joystick in haptic device list");
 }
 
 void
@@ -713,7 +710,7 @@ SDL_SYS_ToDIEFFECT(SDL_Haptic * haptic, DIEFFECT * dest,
         /* Specifics */
         periodic->dwMagnitude = CONVERT(SDL_abs(hap_periodic->magnitude));
         periodic->lOffset = CONVERT(hap_periodic->offset);
-        periodic->dwPhase = 
+        periodic->dwPhase =
                 (hap_periodic->phase + (hap_periodic->magnitude < 0 ? 18000 : 0)) % 36000;
         periodic->dwPeriod = hap_periodic->period * 1000;
         dest->cbTypeSpecificParams = sizeof(DIPERIODIC);
@@ -961,8 +958,7 @@ SDL_DINPUT_HapticNewEffect(SDL_Haptic * haptic, struct haptic_effect *effect, SD
     REFGUID type = SDL_SYS_HapticEffectType(base);
 
     if (type == NULL) {
-        SDL_SetError("Haptic: Unknown effect type.");
-        return -1;
+        return SDL_SetError("Haptic: Unknown effect type.");
     }
 
     /* Get the effect. */
@@ -1200,13 +1196,13 @@ SDL_DINPUT_HapticInit(void)
 }
 
 int
-SDL_DINPUT_MaybeAddDevice(const DIDEVICEINSTANCE * pdidInstance)
+SDL_DINPUT_HapticMaybeAddDevice(const DIDEVICEINSTANCE * pdidInstance)
 {
     return SDL_Unsupported();
 }
 
 int
-SDL_DINPUT_MaybeRemoveDevice(const DIDEVICEINSTANCE * pdidInstance)
+SDL_DINPUT_HapticMaybeRemoveDevice(const DIDEVICEINSTANCE * pdidInstance)
 {
     return SDL_Unsupported();
 }
diff --git a/Engine/lib/sdl/src/haptic/windows/SDL_dinputhaptic_c.h b/Engine/lib/sdl/src/haptic/windows/SDL_dinputhaptic_c.h
index 0a11dbf5a..e854971a0 100644
--- a/Engine/lib/sdl/src/haptic/windows/SDL_dinputhaptic_c.h
+++ b/Engine/lib/sdl/src/haptic/windows/SDL_dinputhaptic_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -25,8 +25,8 @@
 
 
 extern int SDL_DINPUT_HapticInit(void);
-extern int SDL_DINPUT_MaybeAddDevice(const DIDEVICEINSTANCE *pdidInstance);
-extern int SDL_DINPUT_MaybeRemoveDevice(const DIDEVICEINSTANCE *pdidInstance);
+extern int SDL_DINPUT_HapticMaybeAddDevice(const DIDEVICEINSTANCE *pdidInstance);
+extern int SDL_DINPUT_HapticMaybeRemoveDevice(const DIDEVICEINSTANCE *pdidInstance);
 extern int SDL_DINPUT_HapticOpen(SDL_Haptic * haptic, SDL_hapticlist_item *item);
 extern int SDL_DINPUT_JoystickSameHaptic(SDL_Haptic * haptic, SDL_Joystick * joystick);
 extern int SDL_DINPUT_HapticOpenFromJoystick(SDL_Haptic * haptic, SDL_Joystick * joystick);
diff --git a/Engine/lib/sdl/src/haptic/windows/SDL_windowshaptic.c b/Engine/lib/sdl/src/haptic/windows/SDL_windowshaptic.c
index f837bb9e8..1be2fc487 100644
--- a/Engine/lib/sdl/src/haptic/windows/SDL_windowshaptic.c
+++ b/Engine/lib/sdl/src/haptic/windows/SDL_windowshaptic.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -52,12 +52,28 @@ static int numhaptics = 0;
 int
 SDL_SYS_HapticInit(void)
 {
+    JoyStick_DeviceData* device;
+
     if (SDL_DINPUT_HapticInit() < 0) {
         return -1;
     }
     if (SDL_XINPUT_HapticInit() < 0) {
         return -1;
     }
+
+    /* The joystick subsystem will usually be initialized before haptics,
+     * so the initial HapticMaybeAddDevice() calls from the joystick
+     * subsystem will arrive too early to create haptic devices. We will
+     * invoke those callbacks again here to pick up any joysticks that
+     * were added prior to haptics initialization. */
+    for (device = SYS_Joystick; device; device = device->pNext) {
+        if (device->bXInputDevice) {
+            SDL_XINPUT_HapticMaybeAddDevice(device->XInputUserId);
+        } else {
+            SDL_DINPUT_HapticMaybeAddDevice(&device->dxdevice);
+        }
+    }
+
     return numhaptics;
 }
 
diff --git a/Engine/lib/sdl/src/haptic/windows/SDL_windowshaptic_c.h b/Engine/lib/sdl/src/haptic/windows/SDL_windowshaptic_c.h
index 9048663f4..ec6e333ce 100644
--- a/Engine/lib/sdl/src/haptic/windows/SDL_windowshaptic_c.h
+++ b/Engine/lib/sdl/src/haptic/windows/SDL_windowshaptic_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/haptic/windows/SDL_xinputhaptic.c b/Engine/lib/sdl/src/haptic/windows/SDL_xinputhaptic.c
index 164b7894f..9212fbf32 100644
--- a/Engine/lib/sdl/src/haptic/windows/SDL_xinputhaptic.c
+++ b/Engine/lib/sdl/src/haptic/windows/SDL_xinputhaptic.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -20,6 +20,7 @@
 */
 #include "../../SDL_internal.h"
 
+#include "SDL.h"
 #include "SDL_error.h"
 #include "SDL_haptic.h"
 #include "../SDL_syshaptic.h"
@@ -47,17 +48,18 @@ SDL_XINPUT_HapticInit(void)
         loaded_xinput = (WIN_LoadXInputDLL() == 0);
     }
 
-    if (loaded_xinput) {
+    /* If the joystick subsystem is active, it will manage adding XInput haptic devices */
+    if (loaded_xinput && !SDL_WasInit(SDL_INIT_JOYSTICK)) {
         DWORD i;
         for (i = 0; i < XUSER_MAX_COUNT; i++) {
-            SDL_XINPUT_MaybeAddDevice(i);
+            SDL_XINPUT_HapticMaybeAddDevice(i);
         }
     }
     return 0;
 }
 
 int
-SDL_XINPUT_MaybeAddDevice(const DWORD dwUserid)
+SDL_XINPUT_HapticMaybeAddDevice(const DWORD dwUserid)
 {
     const Uint8 userid = (Uint8)dwUserid;
     SDL_hapticlist_item *item;
@@ -106,7 +108,7 @@ SDL_XINPUT_MaybeAddDevice(const DWORD dwUserid)
 }
 
 int
-SDL_XINPUT_MaybeRemoveDevice(const DWORD dwUserid)
+SDL_XINPUT_HapticMaybeRemoveDevice(const DWORD dwUserid)
 {
     const Uint8 userid = (Uint8)dwUserid;
     SDL_hapticlist_item *item;
@@ -244,8 +246,7 @@ SDL_XINPUT_HapticOpenFromJoystick(SDL_Haptic * haptic, SDL_Joystick * joystick)
         ++index;
     }
 
-    SDL_SetError("Couldn't find joystick in haptic device list");
-    return -1;
+    return SDL_SetError("Couldn't find joystick in haptic device list");
 }
 
 void
@@ -377,13 +378,13 @@ SDL_XINPUT_HapticInit(void)
 }
 
 int
-SDL_XINPUT_MaybeAddDevice(const DWORD dwUserid)
+SDL_XINPUT_HapticMaybeAddDevice(const DWORD dwUserid)
 {
     return SDL_Unsupported();
 }
 
 int
-SDL_XINPUT_MaybeRemoveDevice(const DWORD dwUserid)
+SDL_XINPUT_HapticMaybeRemoveDevice(const DWORD dwUserid)
 {
     return SDL_Unsupported();
 }
diff --git a/Engine/lib/sdl/src/haptic/windows/SDL_xinputhaptic_c.h b/Engine/lib/sdl/src/haptic/windows/SDL_xinputhaptic_c.h
index e05461972..d0347e632 100644
--- a/Engine/lib/sdl/src/haptic/windows/SDL_xinputhaptic_c.h
+++ b/Engine/lib/sdl/src/haptic/windows/SDL_xinputhaptic_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -25,8 +25,8 @@
 
 
 extern int SDL_XINPUT_HapticInit(void);
-extern int SDL_XINPUT_MaybeAddDevice(const DWORD dwUserid);
-extern int SDL_XINPUT_MaybeRemoveDevice(const DWORD dwUserid);
+extern int SDL_XINPUT_HapticMaybeAddDevice(const DWORD dwUserid);
+extern int SDL_XINPUT_HapticMaybeRemoveDevice(const DWORD dwUserid);
 extern int SDL_XINPUT_HapticOpen(SDL_Haptic * haptic, SDL_hapticlist_item *item);
 extern int SDL_XINPUT_JoystickSameHaptic(SDL_Haptic * haptic, SDL_Joystick * joystick);
 extern int SDL_XINPUT_HapticOpenFromJoystick(SDL_Haptic * haptic, SDL_Joystick * joystick);
diff --git a/Engine/lib/sdl/src/hidapi/SDL_hidapi.c b/Engine/lib/sdl/src/hidapi/SDL_hidapi.c
index 0b07716b8..aacff63bf 100644
--- a/Engine/lib/sdl/src/hidapi/SDL_hidapi.c
+++ b/Engine/lib/sdl/src/hidapi/SDL_hidapi.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -27,17 +27,501 @@
  * This merges the two, at a small performance cost, until distributions
  * have granted access to /dev/hidraw*
  */
-
 #include "../SDL_internal.h"
-#include "SDL_loadso.h"
 
-#ifdef SDL_JOYSTICK_HIDAPI
+#include "SDL_loadso.h"
+#include "SDL_hidapi.h"
+#include "SDL_thread.h"
+#include "SDL_timer.h"
+#include "SDL_hidapi_c.h"
+
+#if !SDL_HIDAPI_DISABLED
+
+#if defined(__WIN32__)
+#include "../core/windows/SDL_windows.h"
+#endif
+
+#if defined(__MACOSX__)
+#include <CoreFoundation/CoreFoundation.h>
+#include <mach/mach.h>
+#include <IOKit/IOKitLib.h>
+#include <IOKit/hid/IOHIDDevice.h>
+#include <IOKit/usb/USBSpec.h>
+#endif
+
+#include "../core/linux/SDL_udev.h"
+#ifdef SDL_USE_LIBUDEV
+#include <poll.h>
+#include <unistd.h>
+#endif
+
+#ifdef HAVE_INOTIFY
+#include <unistd.h>  /* just in case we didn't use that SDL_USE_LIBUDEV block... */
+#include <errno.h>              /* errno, strerror */
+#include <fcntl.h>
+#include <limits.h>             /* For the definition of NAME_MAX */
+#include <sys/inotify.h>
+#endif
+
+#if defined(SDL_USE_LIBUDEV)
+typedef enum
+{
+    ENUMERATION_UNSET,
+    ENUMERATION_LIBUDEV,
+    ENUMERATION_FALLBACK
+} LinuxEnumerationMethod;
+
+static LinuxEnumerationMethod linux_enumeration_method = ENUMERATION_UNSET;
+#endif
+
+#if defined(HAVE_INOTIFY)
+static int inotify_fd = -1;
+#endif
+
+#if defined(SDL_USE_LIBUDEV)
+static const SDL_UDEV_Symbols * usyms = NULL;
+#endif
+
+static struct
+{
+    SDL_bool m_bInitialized;
+    Uint32 m_unDeviceChangeCounter;
+    SDL_bool m_bCanGetNotifications;
+    Uint32 m_unLastDetect;
+
+#if defined(__WIN32__)
+    SDL_threadID m_nThreadID;
+    WNDCLASSEXA m_wndClass;
+    HWND m_hwndMsg;
+    HDEVNOTIFY m_hNotify;
+    double m_flLastWin32MessageCheck;
+#endif
+
+#if defined(__MACOSX__)
+    IONotificationPortRef m_notificationPort;
+    mach_port_t m_notificationMach;
+#endif
+
+#if defined(SDL_USE_LIBUDEV)
+    struct udev *m_pUdev;
+    struct udev_monitor *m_pUdevMonitor;
+    int m_nUdevFd;
+#endif
+} SDL_HIDAPI_discovery;
+
+
+#ifdef __WIN32__
+struct _DEV_BROADCAST_HDR
+{
+    DWORD       dbch_size;
+    DWORD       dbch_devicetype;
+    DWORD       dbch_reserved;
+};
+
+typedef struct _DEV_BROADCAST_DEVICEINTERFACE_A
+{
+    DWORD       dbcc_size;
+    DWORD       dbcc_devicetype;
+    DWORD       dbcc_reserved;
+    GUID        dbcc_classguid;
+    char        dbcc_name[ 1 ];
+} DEV_BROADCAST_DEVICEINTERFACE_A, *PDEV_BROADCAST_DEVICEINTERFACE_A;
+
+typedef struct  _DEV_BROADCAST_HDR      DEV_BROADCAST_HDR;
+#define DBT_DEVICEARRIVAL               0x8000  /* system detected a new device */
+#define DBT_DEVICEREMOVECOMPLETE        0x8004  /* device was removed from the system */
+#define DBT_DEVTYP_DEVICEINTERFACE      0x00000005  /* device interface class */
+#define DBT_DEVNODES_CHANGED            0x0007
+#define DBT_CONFIGCHANGED               0x0018
+#define DBT_DEVICETYPESPECIFIC          0x8005  /* type specific event */
+#define DBT_DEVINSTSTARTED              0x8008  /* device installed and started */
+
+#include <initguid.h>
+DEFINE_GUID(GUID_DEVINTERFACE_USB_DEVICE, 0xA5DCBF10L, 0x6530, 0x11D2, 0x90, 0x1F, 0x00, 0xC0, 0x4F, 0xB9, 0x51, 0xED);
+
+static LRESULT CALLBACK ControllerWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+    switch (message) {
+    case WM_DEVICECHANGE:
+        switch (wParam) {
+        case DBT_DEVICEARRIVAL:
+        case DBT_DEVICEREMOVECOMPLETE:
+            if (((DEV_BROADCAST_HDR*)lParam)->dbch_devicetype == DBT_DEVTYP_DEVICEINTERFACE) {
+                ++SDL_HIDAPI_discovery.m_unDeviceChangeCounter;
+            }
+            break;
+        }
+        return TRUE;
+    }
+
+    return DefWindowProc(hwnd, message, wParam, lParam);
+}
+#endif /* __WIN32__ */
+
+
+#if defined(__MACOSX__)
+static void CallbackIOServiceFunc(void *context, io_iterator_t portIterator)
+{
+    /* Must drain the iterator, or we won't receive new notifications */
+    io_object_t entry;
+    while ((entry = IOIteratorNext(portIterator)) != 0) {
+        IOObjectRelease(entry);
+        ++SDL_HIDAPI_discovery.m_unDeviceChangeCounter;
+    }
+}
+#endif /* __MACOSX__ */
+
+#ifdef HAVE_INOTIFY
+#ifdef HAVE_INOTIFY_INIT1
+static int SDL_inotify_init1(void) {
+    return inotify_init1(IN_NONBLOCK | IN_CLOEXEC);
+}
+#else
+static int SDL_inotify_init1(void) {
+    int fd = inotify_init();
+    if (fd  < 0) return -1;
+    fcntl(fd, F_SETFL, O_NONBLOCK);
+    fcntl(fd, F_SETFD, FD_CLOEXEC);
+    return fd;
+}
+#endif
+
+static int
+StrHasPrefix(const char *string, const char *prefix)
+{
+    return (SDL_strncmp(string, prefix, SDL_strlen(prefix)) == 0);
+}
+
+static int
+StrIsInteger(const char *string)
+{
+    const char *p;
+
+    if (*string == '\0') {
+        return 0;
+    }
+
+    for (p = string; *p != '\0'; p++) {
+        if (*p < '0' || *p > '9') {
+            return 0;
+        }
+    }
+
+    return 1;
+}
+#endif /* HAVE_INOTIFY */
+
+static void
+HIDAPI_InitializeDiscovery()
+{
+    SDL_HIDAPI_discovery.m_bInitialized = SDL_TRUE;
+    SDL_HIDAPI_discovery.m_unDeviceChangeCounter = 1;
+    SDL_HIDAPI_discovery.m_bCanGetNotifications = SDL_FALSE;
+    SDL_HIDAPI_discovery.m_unLastDetect = 0;
+
+#if defined(__WIN32__)
+    SDL_HIDAPI_discovery.m_nThreadID = SDL_ThreadID();
+
+    SDL_zero(SDL_HIDAPI_discovery.m_wndClass);
+    SDL_HIDAPI_discovery.m_wndClass.hInstance = GetModuleHandle(NULL);
+    SDL_HIDAPI_discovery.m_wndClass.lpszClassName = "SDL_HIDAPI_DEVICE_DETECTION";
+    SDL_HIDAPI_discovery.m_wndClass.lpfnWndProc = ControllerWndProc;      /* This function is called by windows */
+    SDL_HIDAPI_discovery.m_wndClass.cbSize = sizeof(WNDCLASSEX);
+
+    RegisterClassExA(&SDL_HIDAPI_discovery.m_wndClass);
+    SDL_HIDAPI_discovery.m_hwndMsg = CreateWindowExA(0, "SDL_HIDAPI_DEVICE_DETECTION", NULL, 0, 0, 0, 0, 0, HWND_MESSAGE, NULL, NULL, NULL);
+
+    {
+        DEV_BROADCAST_DEVICEINTERFACE_A devBroadcast;
+
+        SDL_zero(devBroadcast);
+        devBroadcast.dbcc_size = sizeof( devBroadcast );
+        devBroadcast.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
+        devBroadcast.dbcc_classguid = GUID_DEVINTERFACE_USB_DEVICE;
+
+        /* DEVICE_NOTIFY_ALL_INTERFACE_CLASSES is important, makes GUID_DEVINTERFACE_USB_DEVICE ignored,
+         * but that seems to be necessary to get a notice after each individual usb input device actually
+         * installs, rather than just as the composite device is seen.
+         */
+        SDL_HIDAPI_discovery.m_hNotify = RegisterDeviceNotification( SDL_HIDAPI_discovery.m_hwndMsg, &devBroadcast, DEVICE_NOTIFY_WINDOW_HANDLE | DEVICE_NOTIFY_ALL_INTERFACE_CLASSES );
+        SDL_HIDAPI_discovery.m_bCanGetNotifications = ( SDL_HIDAPI_discovery.m_hNotify != 0 );
+    }
+#endif /* __WIN32__ */
+
+#if defined(__MACOSX__)
+    SDL_HIDAPI_discovery.m_notificationPort = IONotificationPortCreate(kIOMasterPortDefault);
+    if (SDL_HIDAPI_discovery.m_notificationPort) {
+        {
+            io_iterator_t portIterator = 0;
+            io_object_t entry;
+            IOReturn result = IOServiceAddMatchingNotification(
+                SDL_HIDAPI_discovery.m_notificationPort,
+                kIOFirstMatchNotification,
+                IOServiceMatching(kIOHIDDeviceKey),
+                CallbackIOServiceFunc, NULL, &portIterator);
+
+            if (result == 0) {
+                /* Must drain the existing iterator, or we won't receive new notifications */
+                while ((entry = IOIteratorNext(portIterator)) != 0) {
+                    IOObjectRelease(entry);
+                }
+            } else {
+                IONotificationPortDestroy(SDL_HIDAPI_discovery.m_notificationPort);
+                SDL_HIDAPI_discovery.m_notificationPort = nil;
+            }
+        }
+        {
+            io_iterator_t portIterator = 0;
+            io_object_t entry;
+            IOReturn result = IOServiceAddMatchingNotification(
+                SDL_HIDAPI_discovery.m_notificationPort,
+                kIOTerminatedNotification,
+                IOServiceMatching(kIOHIDDeviceKey),
+                CallbackIOServiceFunc, NULL, &portIterator);
+
+            if (result == 0) {
+                /* Must drain the existing iterator, or we won't receive new notifications */
+                while ((entry = IOIteratorNext(portIterator)) != 0) {
+                    IOObjectRelease(entry);
+                }
+            } else {
+                IONotificationPortDestroy(SDL_HIDAPI_discovery.m_notificationPort);
+                SDL_HIDAPI_discovery.m_notificationPort = nil;
+            }
+        }
+    }
+
+    SDL_HIDAPI_discovery.m_notificationMach = MACH_PORT_NULL;
+    if (SDL_HIDAPI_discovery.m_notificationPort) {
+        SDL_HIDAPI_discovery.m_notificationMach = IONotificationPortGetMachPort(SDL_HIDAPI_discovery.m_notificationPort);
+    }
+
+    SDL_HIDAPI_discovery.m_bCanGetNotifications = (SDL_HIDAPI_discovery.m_notificationMach != MACH_PORT_NULL);
+
+#endif /* __MACOSX__ */
+
+#if defined(SDL_USE_LIBUDEV)
+    if (linux_enumeration_method == ENUMERATION_LIBUDEV) {
+        SDL_HIDAPI_discovery.m_pUdev = NULL;
+        SDL_HIDAPI_discovery.m_pUdevMonitor = NULL;
+        SDL_HIDAPI_discovery.m_nUdevFd = -1;
+
+        usyms = SDL_UDEV_GetUdevSyms();
+        if (usyms) {
+            SDL_HIDAPI_discovery.m_pUdev = usyms->udev_new();
+        }
+        if (SDL_HIDAPI_discovery.m_pUdev) {
+            SDL_HIDAPI_discovery.m_pUdevMonitor = usyms->udev_monitor_new_from_netlink(SDL_HIDAPI_discovery.m_pUdev, "udev");
+            if (SDL_HIDAPI_discovery.m_pUdevMonitor) {
+                usyms->udev_monitor_enable_receiving(SDL_HIDAPI_discovery.m_pUdevMonitor);
+                SDL_HIDAPI_discovery.m_nUdevFd = usyms->udev_monitor_get_fd(SDL_HIDAPI_discovery.m_pUdevMonitor);
+                SDL_HIDAPI_discovery.m_bCanGetNotifications = SDL_TRUE;
+            }
+        }
+    }
+    else
+#endif /* SDL_USE_LIBUDEV */
+    {
+#if defined(HAVE_INOTIFY)
+        inotify_fd = SDL_inotify_init1();
+
+        if (inotify_fd < 0) {
+            SDL_LogWarn(SDL_LOG_CATEGORY_INPUT,
+                        "Unable to initialize inotify, falling back to polling: %s",
+                        strerror(errno));
+            return;
+        }
+
+        /* We need to watch for attribute changes in addition to
+         * creation, because when a device is first created, it has
+         * permissions that we can't read. When udev chmods it to
+         * something that we maybe *can* read, we'll get an
+         * IN_ATTRIB event to tell us. */
+        if (inotify_add_watch(inotify_fd, "/dev",
+                              IN_CREATE | IN_DELETE | IN_MOVE | IN_ATTRIB) < 0) {
+            close(inotify_fd);
+            inotify_fd = -1;
+            SDL_LogWarn(SDL_LOG_CATEGORY_INPUT,
+                        "Unable to add inotify watch, falling back to polling: %s",
+                        strerror (errno));
+            return;
+        }
+
+        SDL_HIDAPI_discovery.m_bCanGetNotifications = SDL_TRUE;
+#endif /* HAVE_INOTIFY */
+    }
+}
+
+static void
+HIDAPI_UpdateDiscovery()
+{
+    if (!SDL_HIDAPI_discovery.m_bInitialized) {
+        HIDAPI_InitializeDiscovery();
+    }
+
+    if (!SDL_HIDAPI_discovery.m_bCanGetNotifications) {
+        const Uint32 SDL_HIDAPI_DETECT_INTERVAL_MS = 3000;  /* Update every 3 seconds */
+        Uint32 now = SDL_GetTicks();
+        if (!SDL_HIDAPI_discovery.m_unLastDetect || SDL_TICKS_PASSED(now, SDL_HIDAPI_discovery.m_unLastDetect + SDL_HIDAPI_DETECT_INTERVAL_MS)) {
+            ++SDL_HIDAPI_discovery.m_unDeviceChangeCounter;
+            SDL_HIDAPI_discovery.m_unLastDetect = now;
+        }
+        return;
+    }
+
+#if defined(__WIN32__)
+#if 0 /* just let the usual SDL_PumpEvents loop dispatch these, fixing bug 4286. --ryan. */
+    /* We'll only get messages on the same thread that created the window */
+    if (SDL_ThreadID() == SDL_HIDAPI_discovery.m_nThreadID) {
+        MSG msg;
+        while (PeekMessage(&msg, SDL_HIDAPI_discovery.m_hwndMsg, 0, 0, PM_NOREMOVE)) {
+            if (GetMessageA(&msg, SDL_HIDAPI_discovery.m_hwndMsg, 0, 0) != 0) {
+                TranslateMessage(&msg);
+                DispatchMessage(&msg);
+            }
+        }
+    }
+#endif
+#endif /* __WIN32__ */
+
+#if defined(__MACOSX__)
+    if (SDL_HIDAPI_discovery.m_notificationPort) {
+        struct { mach_msg_header_t hdr; char payload[ 4096 ]; } msg;
+        while (mach_msg(&msg.hdr, MACH_RCV_MSG | MACH_RCV_TIMEOUT, 0, sizeof(msg), SDL_HIDAPI_discovery.m_notificationMach, 0, MACH_PORT_NULL) == KERN_SUCCESS) {
+            IODispatchCalloutFromMessage(NULL, &msg.hdr, SDL_HIDAPI_discovery.m_notificationPort);
+        }
+    }
+#endif
+
+#if defined(SDL_USE_LIBUDEV)
+    if (linux_enumeration_method == ENUMERATION_LIBUDEV) {
+        if (SDL_HIDAPI_discovery.m_nUdevFd >= 0) {
+            /* Drain all notification events.
+             * We don't expect a lot of device notifications so just
+             * do a new discovery on any kind or number of notifications.
+             * This could be made more restrictive if necessary.
+             */
+            for (;;) {
+                struct pollfd PollUdev;
+                struct udev_device *pUdevDevice;
+
+                PollUdev.fd = SDL_HIDAPI_discovery.m_nUdevFd;
+                PollUdev.events = POLLIN;
+                if (poll(&PollUdev, 1, 0) != 1) {
+                    break;
+                }
+
+                pUdevDevice = usyms->udev_monitor_receive_device(SDL_HIDAPI_discovery.m_pUdevMonitor);
+                if (pUdevDevice) {
+                    const char *action = NULL;
+                    action = usyms->udev_device_get_action(pUdevDevice);
+                    if (!action || SDL_strcmp(action, "add") == 0 || SDL_strcmp(action, "remove") == 0) {
+                        ++SDL_HIDAPI_discovery.m_unDeviceChangeCounter;
+                    }
+                    usyms->udev_device_unref(pUdevDevice);
+                }
+            }
+        }
+    }
+    else
+#endif /* SDL_USE_LIBUDEV */
+    {
+#if defined(HAVE_INOTIFY)
+        if (inotify_fd >= 0) {
+            union
+            {
+                struct inotify_event event;
+                char storage[4096];
+                char enough_for_inotify[sizeof (struct inotify_event) + NAME_MAX + 1];
+            } buf;
+            ssize_t bytes;
+            size_t remain = 0;
+            size_t len;
+
+            bytes = read(inotify_fd, &buf, sizeof (buf));
+
+            if (bytes > 0) {
+                remain = (size_t) bytes;
+            }
+
+            while (remain > 0) {
+                if (buf.event.len > 0) {
+                    if (StrHasPrefix(buf.event.name, "hidraw") &&
+                        StrIsInteger(buf.event.name + SDL_strlen ("hidraw"))) {
+                        ++SDL_HIDAPI_discovery.m_unDeviceChangeCounter;
+                        /* We found an hidraw change. We still continue to
+                         * drain the inotify fd to avoid leaving old
+                         * notifications in the queue. */
+                    }
+                }
+
+                len = sizeof (struct inotify_event) + buf.event.len;
+                remain -= len;
+
+                if (remain != 0) {
+                    SDL_memmove(&buf.storage[0], &buf.storage[len], remain);
+                }
+            }
+        }
+#endif /* HAVE_INOTIFY */
+    }
+}
+
+static void
+HIDAPI_ShutdownDiscovery()
+{
+    if (!SDL_HIDAPI_discovery.m_bInitialized) {
+        return;
+    }
+
+#if defined(__WIN32__)
+    if (SDL_HIDAPI_discovery.m_hNotify)
+        UnregisterDeviceNotification(SDL_HIDAPI_discovery.m_hNotify);
+
+    if (SDL_HIDAPI_discovery.m_hwndMsg) {
+        DestroyWindow(SDL_HIDAPI_discovery.m_hwndMsg);
+    }
+
+    UnregisterClassA(SDL_HIDAPI_discovery.m_wndClass.lpszClassName, SDL_HIDAPI_discovery.m_wndClass.hInstance);
+#endif
+
+#if defined(__MACOSX__)
+    if (SDL_HIDAPI_discovery.m_notificationPort) {
+        IONotificationPortDestroy(SDL_HIDAPI_discovery.m_notificationPort);
+    }
+#endif
+
+#if defined(SDL_USE_LIBUDEV)
+    if (linux_enumeration_method == ENUMERATION_LIBUDEV) {
+        if (usyms) {
+            if (SDL_HIDAPI_discovery.m_pUdevMonitor) {
+                usyms->udev_monitor_unref(SDL_HIDAPI_discovery.m_pUdevMonitor);
+            }
+            if (SDL_HIDAPI_discovery.m_pUdev) {
+                usyms->udev_unref(SDL_HIDAPI_discovery.m_pUdev);
+            }
+            SDL_UDEV_ReleaseUdevSyms();
+            usyms = NULL;
+        }
+    }
+    else
+#endif /* SDL_USE_LIBUDEV */
+    {
+#if defined(HAVE_INOTIFY)
+        if (inotify_fd >= 0) {
+            close(inotify_fd);
+            inotify_fd = -1;
+        }
+#endif
+    }
+
+    SDL_HIDAPI_discovery.m_bInitialized = SDL_FALSE;
+}
 
 /* Platform HIDAPI Implementation */
 
-#define hid_device_                     PLATFORM_hid_device_
 #define hid_device                      PLATFORM_hid_device
-#define hid_device_info                 PLATFORM_hid_device_info
+#define hid_device_                     PLATFORM_hid_device_
 #define hid_init                        PLATFORM_hid_init
 #define hid_exit                        PLATFORM_hid_exit
 #define hid_enumerate                   PLATFORM_hid_enumerate
@@ -66,7 +550,7 @@
 #undef HIDAPI_H__
 #if __LINUX__
 
-#include "../../core/linux/SDL_udev.h"
+#include "../core/linux/SDL_udev.h"
 #if SDL_USE_LIBUDEV
 static const SDL_UDEV_Symbols *udev_ctx = NULL;
 
@@ -98,11 +582,20 @@ static const SDL_UDEV_Symbols *udev_ctx = NULL;
 #include "windows/hid.c"
 #define HAVE_PLATFORM_BACKEND 1
 #define udev_ctx 1
+#elif __ANDROID__
+/* The implementation for Android is in a separate .cpp file */
+#include "hidapi/hidapi.h"
+#define HAVE_PLATFORM_BACKEND 1
+#define udev_ctx 1
+#elif __IPHONEOS__ || __TVOS__
+/* The implementation for iOS and tvOS is in a separate .m file */
+#include "hidapi/hidapi.h"
+#define HAVE_PLATFORM_BACKEND 1
+#define udev_ctx 1
 #endif
 
-#undef hid_device_
 #undef hid_device
-#undef hid_device_info
+#undef hid_device_
 #undef hid_init
 #undef hid_exit
 #undef hid_enumerate
@@ -136,9 +629,8 @@ static const SDL_UDEV_Symbols *udev_ctx = NULL;
 
 /* DRIVER HIDAPI Implementation */
 
-#define hid_device_                     DRIVER_hid_device_
 #define hid_device                      DRIVER_hid_device
-#define hid_device_info                 DRIVER_hid_device_info
+#define hid_device_                     DRIVER_hid_device_
 #define hid_init                        DRIVER_hid_init
 #define hid_exit                        DRIVER_hid_exit
 #define hid_enumerate                   DRIVER_hid_enumerate
@@ -165,9 +657,8 @@ static const SDL_UDEV_Symbols *udev_ctx = NULL;
 #error Need a driver hid.c for this platform!
 #endif
 
-#undef hid_device_
 #undef hid_device
-#undef hid_device_info
+#undef hid_device_
 #undef hid_init
 #undef hid_exit
 #undef hid_enumerate
@@ -200,33 +691,33 @@ static struct
 {
     void* libhandle;
 
-    int (*init)(libusb_context **ctx);
-    void (*exit)(libusb_context *ctx);
-    ssize_t (*get_device_list)(libusb_context *ctx, libusb_device ***list);
-    void (*free_device_list)(libusb_device **list, int unref_devices);
-    int (*get_device_descriptor)(libusb_device *dev, struct libusb_device_descriptor *desc);
-    int (*get_active_config_descriptor)(libusb_device *dev,    struct libusb_config_descriptor **config);
-    int (*get_config_descriptor)(
+    int (LIBUSB_CALL *init)(libusb_context **ctx);
+    void (LIBUSB_CALL *exit)(libusb_context *ctx);
+    ssize_t (LIBUSB_CALL *get_device_list)(libusb_context *ctx, libusb_device ***list);
+    void (LIBUSB_CALL *free_device_list)(libusb_device **list, int unref_devices);
+    int (LIBUSB_CALL *get_device_descriptor)(libusb_device *dev, struct libusb_device_descriptor *desc);
+    int (LIBUSB_CALL *get_active_config_descriptor)(libusb_device *dev,    struct libusb_config_descriptor **config);
+    int (LIBUSB_CALL *get_config_descriptor)(
         libusb_device *dev,
         uint8_t config_index,
         struct libusb_config_descriptor **config
     );
-    void (*free_config_descriptor)(struct libusb_config_descriptor *config);
-    uint8_t (*get_bus_number)(libusb_device *dev);
-    uint8_t (*get_device_address)(libusb_device *dev);
-    int (*open)(libusb_device *dev, libusb_device_handle **dev_handle);
-    void (*close)(libusb_device_handle *dev_handle);
-    int (*claim_interface)(libusb_device_handle *dev_handle, int interface_number);
-    int (*release_interface)(libusb_device_handle *dev_handle, int interface_number);
-    int (*kernel_driver_active)(libusb_device_handle *dev_handle, int interface_number);
-    int (*detach_kernel_driver)(libusb_device_handle *dev_handle, int interface_number);
-    int (*attach_kernel_driver)(libusb_device_handle *dev_handle, int interface_number);
-    int (*set_interface_alt_setting)(libusb_device_handle *dev, int interface_number, int alternate_setting);
-    struct libusb_transfer * (*alloc_transfer)(int iso_packets);
-    int (*submit_transfer)(struct libusb_transfer *transfer);
-    int (*cancel_transfer)(struct libusb_transfer *transfer);
-    void (*free_transfer)(struct libusb_transfer *transfer);
-    int (*control_transfer)(
+    void (LIBUSB_CALL *free_config_descriptor)(struct libusb_config_descriptor *config);
+    uint8_t (LIBUSB_CALL *get_bus_number)(libusb_device *dev);
+    uint8_t (LIBUSB_CALL *get_device_address)(libusb_device *dev);
+    int (LIBUSB_CALL *open)(libusb_device *dev, libusb_device_handle **dev_handle);
+    void (LIBUSB_CALL *close)(libusb_device_handle *dev_handle);
+    int (LIBUSB_CALL *claim_interface)(libusb_device_handle *dev_handle, int interface_number);
+    int (LIBUSB_CALL *release_interface)(libusb_device_handle *dev_handle, int interface_number);
+    int (LIBUSB_CALL *kernel_driver_active)(libusb_device_handle *dev_handle, int interface_number);
+    int (LIBUSB_CALL *detach_kernel_driver)(libusb_device_handle *dev_handle, int interface_number);
+    int (LIBUSB_CALL *attach_kernel_driver)(libusb_device_handle *dev_handle, int interface_number);
+    int (LIBUSB_CALL *set_interface_alt_setting)(libusb_device_handle *dev, int interface_number, int alternate_setting);
+    struct libusb_transfer * (LIBUSB_CALL *alloc_transfer)(int iso_packets);
+    int (LIBUSB_CALL *submit_transfer)(struct libusb_transfer *transfer);
+    int (LIBUSB_CALL *cancel_transfer)(struct libusb_transfer *transfer);
+    void (LIBUSB_CALL *free_transfer)(struct libusb_transfer *transfer);
+    int (LIBUSB_CALL *control_transfer)(
         libusb_device_handle *dev_handle,
         uint8_t request_type,
         uint8_t bRequest,
@@ -236,7 +727,7 @@ static struct
         uint16_t wLength,
         unsigned int timeout
     );
-    int (*interrupt_transfer)(
+    int (LIBUSB_CALL *interrupt_transfer)(
         libusb_device_handle *dev_handle,
         unsigned char endpoint,
         unsigned char *data,
@@ -244,8 +735,8 @@ static struct
         int *actual_length,
         unsigned int timeout
     );
-    int (*handle_events)(libusb_context *ctx);
-    int (*handle_events_completed)(libusb_context *ctx, int *completed);
+    int (LIBUSB_CALL *handle_events)(libusb_context *ctx);
+    int (LIBUSB_CALL *handle_events_completed)(libusb_context *ctx, int *completed);
 } libusb_ctx;
 
 #define libusb_init                            libusb_ctx.init
@@ -275,9 +766,8 @@ static struct
 #define libusb_handle_events                   libusb_ctx.handle_events
 #define libusb_handle_events_completed         libusb_ctx.handle_events_completed
 
-#define hid_device_                     LIBUSB_hid_device_
 #define hid_device                      LIBUSB_hid_device
-#define hid_device_info                 LIBUSB_hid_device_info
+#define hid_device_                     LIBUSB_hid_device_
 #define hid_init                        LIBUSB_hid_init
 #define hid_exit                        LIBUSB_hid_exit
 #define hid_enumerate                   LIBUSB_hid_enumerate
@@ -326,9 +816,8 @@ SDL_libusb_get_string_descriptor(libusb_device_handle *dev,
 #undef HIDAPI_H__
 #include "libusb/hid.c"
 
-#undef hid_device_
 #undef hid_device
-#undef hid_device_info
+#undef hid_device_
 #undef hid_init
 #undef hid_exit
 #undef hid_enumerate
@@ -356,24 +845,23 @@ SDL_libusb_get_string_descriptor(libusb_device_handle *dev,
 
 #endif /* SDL_LIBUSB_DYNAMIC */
 
+#endif /* !SDL_HIDAPI_DISABLED */
+
 /* Shared HIDAPI Implementation */
 
-#undef HIDAPI_H__
-#include "hidapi/hidapi.h"
-
 struct hidapi_backend {
-    int  (*hid_write)(hid_device* device, const unsigned char* data, size_t length);
-    int  (*hid_read_timeout)(hid_device* device, unsigned char* data, size_t length, int milliseconds);
-    int  (*hid_read)(hid_device* device, unsigned char* data, size_t length);
-    int  (*hid_set_nonblocking)(hid_device* device, int nonblock);
-    int  (*hid_send_feature_report)(hid_device* device, const unsigned char* data, size_t length);
-    int  (*hid_get_feature_report)(hid_device* device, unsigned char* data, size_t length);
-    void (*hid_close)(hid_device* device);
-    int  (*hid_get_manufacturer_string)(hid_device* device, wchar_t* string, size_t maxlen);
-    int  (*hid_get_product_string)(hid_device* device, wchar_t* string, size_t maxlen);
-    int  (*hid_get_serial_number_string)(hid_device* device, wchar_t* string, size_t maxlen);
-    int  (*hid_get_indexed_string)(hid_device* device, int string_index, wchar_t* string, size_t maxlen);
-    const wchar_t* (*hid_error)(hid_device* device);
+    int  (*hid_write)(void* device, const unsigned char* data, size_t length);
+    int  (*hid_read_timeout)(void* device, unsigned char* data, size_t length, int milliseconds);
+    int  (*hid_read)(void* device, unsigned char* data, size_t length);
+    int  (*hid_set_nonblocking)(void* device, int nonblock);
+    int  (*hid_send_feature_report)(void* device, const unsigned char* data, size_t length);
+    int  (*hid_get_feature_report)(void* device, unsigned char* data, size_t length);
+    void (*hid_close)(void* device);
+    int  (*hid_get_manufacturer_string)(void* device, wchar_t* string, size_t maxlen);
+    int  (*hid_get_product_string)(void* device, wchar_t* string, size_t maxlen);
+    int  (*hid_get_serial_number_string)(void* device, wchar_t* string, size_t maxlen);
+    int  (*hid_get_indexed_string)(void* device, int string_index, wchar_t* string, size_t maxlen);
+    const wchar_t* (*hid_error)(void* device);
 };
 
 #if HAVE_PLATFORM_BACKEND
@@ -427,40 +915,43 @@ static const struct hidapi_backend LIBUSB_Backend = {
 };
 #endif /* SDL_LIBUSB_DYNAMIC */
 
-typedef struct _HIDDeviceWrapper HIDDeviceWrapper;
-struct _HIDDeviceWrapper
+struct SDL_hid_device_
 {
-    hid_device *device; /* must be first field */
+    const void *magic;
+    void *device;
     const struct hidapi_backend *backend;
 };
+static char device_magic;
 
-static HIDDeviceWrapper *
-CreateHIDDeviceWrapper(hid_device *device, const struct hidapi_backend *backend)
+#if HAVE_PLATFORM_BACKEND || HAVE_DRIVER_BACKEND || defined(SDL_LIBUSB_DYNAMIC)
+
+static SDL_hid_device *
+CreateHIDDeviceWrapper(void *device, const struct hidapi_backend *backend)
 {
-    HIDDeviceWrapper *ret = (HIDDeviceWrapper *)SDL_malloc(sizeof(*ret));
-    ret->device = device;
-    ret->backend = backend;
-    return ret;
+    SDL_hid_device *wrapper = (SDL_hid_device *)SDL_malloc(sizeof(*wrapper));
+    wrapper->magic = &device_magic;
+    wrapper->device = device;
+    wrapper->backend = backend;
+    return wrapper;
 }
 
-static hid_device *
-WrapHIDDevice(HIDDeviceWrapper *wrapper)
-{
-    return (hid_device *)wrapper;
-}
-
-static HIDDeviceWrapper *
-UnwrapHIDDevice(hid_device *device)
-{
-    return (HIDDeviceWrapper *)device;
-}
+#endif /* HAVE_PLATFORM_BACKEND || HAVE_DRIVER_BACKEND || SDL_LIBUSB_DYNAMIC */
 
 static void
-DeleteHIDDeviceWrapper(HIDDeviceWrapper *device)
+DeleteHIDDeviceWrapper(SDL_hid_device *device)
 {
+    device->magic = NULL;
     SDL_free(device);
 }
 
+#define CHECK_DEVICE_MAGIC(device, retval) \
+    if (!device || device->magic != &device_magic) { \
+        SDL_SetError("Invalid device"); \
+        return retval; \
+    }
+
+#if !SDL_HIDAPI_DISABLED
+
 #define COPY_IF_EXISTS(var) \
     if (pSrc->var != NULL) { \
         pDst->var = SDL_strdup(pSrc->var); \
@@ -474,10 +965,8 @@ DeleteHIDDeviceWrapper(HIDDeviceWrapper *device)
         pDst->var = NULL; \
     }
 
-#ifdef SDL_LIBUSB_DYNAMIC
 static void
-LIBUSB_CopyHIDDeviceInfo(struct LIBUSB_hid_device_info *pSrc,
-                         struct hid_device_info *pDst)
+CopyHIDDeviceInfo(struct SDL_hid_device_info *pSrc, struct SDL_hid_device_info *pDst)
 {
     COPY_IF_EXISTS(path)
     pDst->vendor_id = pSrc->vendor_id;
@@ -494,71 +983,66 @@ LIBUSB_CopyHIDDeviceInfo(struct LIBUSB_hid_device_info *pSrc,
     pDst->interface_protocol = pSrc->interface_protocol;
     pDst->next = NULL;
 }
-#endif /* SDL_LIBUSB_DYNAMIC */
-
-#if HAVE_DRIVER_BACKEND
-static void
-DRIVER_CopyHIDDeviceInfo(struct DRIVER_hid_device_info *pSrc,
-                           struct hid_device_info *pDst)
-{
-    COPY_IF_EXISTS(path)
-    pDst->vendor_id = pSrc->vendor_id;
-    pDst->product_id = pSrc->product_id;
-    WCOPY_IF_EXISTS(serial_number)
-    pDst->release_number = pSrc->release_number;
-    WCOPY_IF_EXISTS(manufacturer_string)
-    WCOPY_IF_EXISTS(product_string)
-    pDst->usage_page = pSrc->usage_page;
-    pDst->usage = pSrc->usage;
-    pDst->interface_number = pSrc->interface_number;
-    pDst->interface_class = pSrc->interface_class;
-    pDst->interface_subclass = pSrc->interface_subclass;
-    pDst->interface_protocol = pSrc->interface_protocol;
-    pDst->next = NULL;
-}
-#endif /* HAVE_DRIVER_BACKEND */
-
-#if HAVE_PLATFORM_BACKEND
-static void
-PLATFORM_CopyHIDDeviceInfo(struct PLATFORM_hid_device_info *pSrc,
-                           struct hid_device_info *pDst)
-{
-    COPY_IF_EXISTS(path)
-    pDst->vendor_id = pSrc->vendor_id;
-    pDst->product_id = pSrc->product_id;
-    WCOPY_IF_EXISTS(serial_number)
-    pDst->release_number = pSrc->release_number;
-    WCOPY_IF_EXISTS(manufacturer_string)
-    WCOPY_IF_EXISTS(product_string)
-    pDst->usage_page = pSrc->usage_page;
-    pDst->usage = pSrc->usage;
-    pDst->interface_number = pSrc->interface_number;
-    pDst->interface_class = pSrc->interface_class;
-    pDst->interface_subclass = pSrc->interface_subclass;
-    pDst->interface_protocol = pSrc->interface_protocol;
-    pDst->next = NULL;
-}
-#endif /* HAVE_PLATFORM_BACKEND */
 
 #undef COPY_IF_EXISTS
 #undef WCOPY_IF_EXISTS
 
-static SDL_bool SDL_hidapi_wasinit = SDL_FALSE;
+#endif /* !SDL_HIDAPI_DISABLED */
 
-int HID_API_EXPORT HID_API_CALL hid_init(void)
+static int SDL_hidapi_refcount = 0;
+
+static void SDL_SetHIDAPIError( const wchar_t *error )
 {
-    int err;
+    if (error) {
+        char *error_utf8 = SDL_iconv_wchar_utf8(error);
+        if (error_utf8) {
+            SDL_SetError("%s", error_utf8);
+            SDL_free(error_utf8);
+        }
+    }
+}
 
-    if (SDL_hidapi_wasinit == SDL_TRUE) {
+int SDL_hid_init(void)
+{
+    int attempts = 0, success = 0;
+
+    if (SDL_hidapi_refcount > 0) {
+        ++SDL_hidapi_refcount;
         return 0;
     }
 
+#if defined(SDL_USE_LIBUDEV)
+    if (SDL_getenv("SDL_HIDAPI_JOYSTICK_DISABLE_UDEV") != NULL) {
+        SDL_LogDebug(SDL_LOG_CATEGORY_INPUT,
+                     "udev disabled by SDL_HIDAPI_JOYSTICK_DISABLE_UDEV");
+        linux_enumeration_method = ENUMERATION_FALLBACK;
+    } else if (access("/.flatpak-info", F_OK) == 0
+               || access("/run/host/container-manager", F_OK) == 0) {
+        /* Explicitly check `/.flatpak-info` because, for old versions of
+         * Flatpak, this was the only available way to tell if we were in
+         * a Flatpak container. */
+        SDL_LogDebug(SDL_LOG_CATEGORY_INPUT,
+                     "Container detected, disabling HIDAPI udev integration");
+        linux_enumeration_method = ENUMERATION_FALLBACK;
+    } else {
+        SDL_LogDebug(SDL_LOG_CATEGORY_INPUT,
+                     "Using udev for HIDAPI joystick device discovery");
+        linux_enumeration_method = ENUMERATION_LIBUDEV;
+    }
+#endif
+
 #ifdef SDL_LIBUSB_DYNAMIC
+    ++attempts;
     libusb_ctx.libhandle = SDL_LoadObject(SDL_LIBUSB_DYNAMIC);
     if (libusb_ctx.libhandle != NULL) {
         SDL_bool loaded = SDL_TRUE;
+        #ifdef __OS2__
+        #define LOAD_LIBUSB_SYMBOL(func) \
+            if (!(libusb_ctx.func = SDL_LoadFunction(libusb_ctx.libhandle,"_libusb_" #func))) {loaded = SDL_FALSE;}
+        #else
         #define LOAD_LIBUSB_SYMBOL(func) \
             if (!(libusb_ctx.func = SDL_LoadFunction(libusb_ctx.libhandle, "libusb_" #func))) {loaded = SDL_FALSE;}
+        #endif
         LOAD_LIBUSB_SYMBOL(init)
         LOAD_LIBUSB_SYMBOL(exit)
         LOAD_LIBUSB_SYMBOL(get_device_list)
@@ -587,82 +1071,114 @@ int HID_API_EXPORT HID_API_CALL hid_init(void)
         LOAD_LIBUSB_SYMBOL(handle_events_completed)
         #undef LOAD_LIBUSB_SYMBOL
 
-        if (loaded == SDL_TRUE) {
-            if ((err = LIBUSB_hid_init()) < 0) {
-                SDL_UnloadObject(libusb_ctx.libhandle);
-                libusb_ctx.libhandle = NULL;
-                return err;
-            }
-        } else {
+        if (!loaded) {
             SDL_UnloadObject(libusb_ctx.libhandle);
             libusb_ctx.libhandle = NULL;
-            /* SDL_LogWarn(SDL_LOG_CATEGORY_INPUT, SDL_LIBUSB_DYNAMIC " found but could not load function."); */
-            /* ignore error: continue without libusb */
+            /* SDL_LogWarn(SDL_LOG_CATEGORY_INPUT, SDL_LIBUSB_DYNAMIC " found but could not load function"); */
+        } else if (LIBUSB_hid_init() < 0) {
+            SDL_UnloadObject(libusb_ctx.libhandle);
+            libusb_ctx.libhandle = NULL;
+        } else {
+            ++success;
         }
     }
 #endif /* SDL_LIBUSB_DYNAMIC */
 
 #if HAVE_PLATFORM_BACKEND
+    ++attempts;
 #if __LINUX__
     udev_ctx = SDL_UDEV_GetUdevSyms();
 #endif /* __LINUX __ */
-    if (udev_ctx && (err = PLATFORM_hid_init()) < 0) {
-#ifdef SDL_LIBUSB_DYNAMIC
-        if (libusb_ctx.libhandle) {
-            LIBUSB_hid_exit();
-            SDL_UnloadObject(libusb_ctx.libhandle);
-            libusb_ctx.libhandle = NULL;
-        }
-#endif /* SDL_LIBUSB_DYNAMIC */
-        return err;
+    if (udev_ctx && PLATFORM_hid_init() == 0) {
+        ++success;
     }
 #endif /* HAVE_PLATFORM_BACKEND */
 
-    SDL_hidapi_wasinit = SDL_TRUE;
+    if (attempts > 0 && success == 0) {
+        return -1;
+    }
+
+    ++SDL_hidapi_refcount;
     return 0;
 }
 
-int HID_API_EXPORT HID_API_CALL hid_exit(void)
+int SDL_hid_exit(void)
 {
-    int err = 0;
+    int result = 0;
 
-    if (SDL_hidapi_wasinit == SDL_FALSE) {
+    if (SDL_hidapi_refcount == 0) {
         return 0;
     }
-    SDL_hidapi_wasinit = SDL_FALSE;
+    --SDL_hidapi_refcount;
+    if (SDL_hidapi_refcount > 0) {
+        return 0;
+    }
+    SDL_hidapi_refcount = 0;
+
+#if !SDL_HIDAPI_DISABLED
+    HIDAPI_ShutdownDiscovery();
+#endif
 
 #if HAVE_PLATFORM_BACKEND
     if (udev_ctx) {
-        err = PLATFORM_hid_exit();
+        result |= PLATFORM_hid_exit();
     }
+#if __LINUX__
+    SDL_UDEV_ReleaseUdevSyms();
+#endif /* __LINUX __ */
 #endif /* HAVE_PLATFORM_BACKEND */
+
 #ifdef SDL_LIBUSB_DYNAMIC
     if (libusb_ctx.libhandle) {
-        err |= LIBUSB_hid_exit(); /* Ehhhhh */
+        result |= LIBUSB_hid_exit();
         SDL_UnloadObject(libusb_ctx.libhandle);
         libusb_ctx.libhandle = NULL;
     }
 #endif /* SDL_LIBUSB_DYNAMIC */
-    return err;
+
+    return result;
 }
 
-struct hid_device_info HID_API_EXPORT * HID_API_CALL hid_enumerate(unsigned short vendor_id, unsigned short product_id)
+Uint32 SDL_hid_device_change_count(void)
 {
+    Uint32 counter = 0;
+
+#if !SDL_HIDAPI_DISABLED
+    if (SDL_hidapi_refcount == 0 && SDL_hid_init() != 0) {
+        return 0;
+    }
+
+    HIDAPI_UpdateDiscovery();
+
+    if (SDL_HIDAPI_discovery.m_unDeviceChangeCounter == 0) {
+        /* Counter wrapped! */
+        ++SDL_HIDAPI_discovery.m_unDeviceChangeCounter;
+    }
+    counter = SDL_HIDAPI_discovery.m_unDeviceChangeCounter;
+
+#endif /* !SDL_HIDAPI_DISABLED */
+
+    return counter;
+}
+
+struct SDL_hid_device_info *SDL_hid_enumerate(unsigned short vendor_id, unsigned short product_id)
+{
+#if HAVE_PLATFORM_BACKEND || HAVE_DRIVER_BACKEND || defined(SDL_LIBUSB_DYNAMIC)
 #ifdef SDL_LIBUSB_DYNAMIC
-    struct LIBUSB_hid_device_info *usb_devs = NULL;
-    struct LIBUSB_hid_device_info *usb_dev;
+    struct SDL_hid_device_info *usb_devs = NULL;
+    struct SDL_hid_device_info *usb_dev;
 #endif
 #if HAVE_DRIVER_BACKEND
-    struct DRIVER_hid_device_info* driver_devs = NULL;
-    struct DRIVER_hid_device_info* driver_dev;
+    struct SDL_hid_device_info* driver_devs = NULL;
+    struct SDL_hid_device_info* driver_dev;
 #endif
 #if HAVE_PLATFORM_BACKEND
-    struct PLATFORM_hid_device_info *raw_devs = NULL;
-    struct PLATFORM_hid_device_info *raw_dev;
+    struct SDL_hid_device_info *raw_devs = NULL;
+    struct SDL_hid_device_info *raw_dev;
 #endif
-    struct hid_device_info *devs = NULL, *last = NULL, *new_dev;
+    struct SDL_hid_device_info *devs = NULL, *last = NULL, *new_dev;
 
-    if (hid_init() != 0) {
+    if (SDL_hidapi_refcount == 0 && SDL_hid_init() != 0) {
         return NULL;
     }
 
@@ -673,14 +1189,14 @@ struct hid_device_info HID_API_EXPORT * HID_API_CALL hid_enumerate(unsigned shor
         SDL_Log("libusb devices found:");
   #endif
         for (usb_dev = usb_devs; usb_dev; usb_dev = usb_dev->next) {
-            new_dev = (struct hid_device_info*) SDL_malloc(sizeof(struct hid_device_info));
+            new_dev = (struct SDL_hid_device_info*) SDL_malloc(sizeof(struct SDL_hid_device_info));
             if (!new_dev) {
                 LIBUSB_hid_free_enumeration(usb_devs);
-                hid_free_enumeration(devs);
+                SDL_hid_free_enumeration(devs);
                 SDL_OutOfMemory();
                 return NULL;
             }
-            LIBUSB_CopyHIDDeviceInfo(usb_dev, new_dev);
+            CopyHIDDeviceInfo(usb_dev, new_dev);
   #ifdef DEBUG_HIDAPI
             SDL_Log(" - %ls %ls 0x%.4hx 0x%.4hx",
                     usb_dev->manufacturer_string, usb_dev->product_string,
@@ -700,8 +1216,8 @@ struct hid_device_info HID_API_EXPORT * HID_API_CALL hid_enumerate(unsigned shor
 #ifdef HAVE_DRIVER_BACKEND
     driver_devs = DRIVER_hid_enumerate(vendor_id, product_id);
     for (driver_dev = driver_devs; driver_dev; driver_dev = driver_dev->next) {
-        new_dev = (struct hid_device_info*) SDL_malloc(sizeof(struct hid_device_info));
-        DRIVER_CopyHIDDeviceInfo(driver_dev, new_dev);
+        new_dev = (struct SDL_hid_device_info*) SDL_malloc(sizeof(struct SDL_hid_device_info));
+        CopyHIDDeviceInfo(driver_dev, new_dev);
 
         if (last != NULL) {
             last->next = new_dev;
@@ -746,7 +1262,7 @@ struct hid_device_info HID_API_EXPORT * HID_API_CALL hid_enumerate(unsigned shor
             }
 #endif
             if (!bFound) {
-                new_dev = (struct hid_device_info*) SDL_malloc(sizeof(struct hid_device_info));
+                new_dev = (struct SDL_hid_device_info*) SDL_malloc(sizeof(struct SDL_hid_device_info));
                 if (!new_dev) {
 #ifdef SDL_LIBUSB_DYNAMIC
                     if (libusb_ctx.libhandle) {
@@ -754,11 +1270,11 @@ struct hid_device_info HID_API_EXPORT * HID_API_CALL hid_enumerate(unsigned shor
                     }
 #endif
                     PLATFORM_hid_free_enumeration(raw_devs);
-                    hid_free_enumeration(devs);
+                    SDL_hid_free_enumeration(devs);
                     SDL_OutOfMemory();
                     return NULL;
                 }
-                PLATFORM_CopyHIDDeviceInfo(raw_dev, new_dev);
+                CopyHIDDeviceInfo(raw_dev, new_dev);
                 new_dev->next = NULL;
 
                 if (last != NULL) {
@@ -779,12 +1295,16 @@ struct hid_device_info HID_API_EXPORT * HID_API_CALL hid_enumerate(unsigned shor
     }
 #endif
     return devs;
+
+#else
+    return NULL;
+#endif /* HAVE_PLATFORM_BACKEND || HAVE_DRIVER_BACKEND || SDL_LIBUSB_DYNAMIC */
 }
 
-void  HID_API_EXPORT HID_API_CALL hid_free_enumeration(struct hid_device_info *devs)
+void SDL_hid_free_enumeration(struct SDL_hid_device_info *devs)
 {
     while (devs) {
-        struct hid_device_info *next = devs->next;
+        struct SDL_hid_device_info *next = devs->next;
         SDL_free(devs->path);
         SDL_free(devs->serial_number);
         SDL_free(devs->manufacturer_string);
@@ -794,153 +1314,274 @@ void  HID_API_EXPORT HID_API_CALL hid_free_enumeration(struct hid_device_info *d
     }
 }
 
-HID_API_EXPORT hid_device * HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number)
+SDL_hid_device *SDL_hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number)
 {
-    hid_device *pDevice = NULL;
+#if HAVE_PLATFORM_BACKEND || HAVE_DRIVER_BACKEND || defined(SDL_LIBUSB_DYNAMIC)
+    void *pDevice = NULL;
 
-    if (hid_init() != 0) {
+    if (SDL_hidapi_refcount == 0 && SDL_hid_init() != 0) {
         return NULL;
     }
 
 #if HAVE_PLATFORM_BACKEND
     if (udev_ctx &&
-        (pDevice = (hid_device*) PLATFORM_hid_open(vendor_id, product_id, serial_number)) != NULL) {
-
-        HIDDeviceWrapper *wrapper = CreateHIDDeviceWrapper(pDevice, &PLATFORM_Backend);
-        return WrapHIDDevice(wrapper);
+        (pDevice = PLATFORM_hid_open(vendor_id, product_id, serial_number)) != NULL) {
+        return CreateHIDDeviceWrapper(pDevice, &PLATFORM_Backend);
     }
 #endif /* HAVE_PLATFORM_BACKEND */
 
 #if HAVE_DRIVER_BACKEND
-    if ((pDevice = (hid_device*) DRIVER_hid_open(vendor_id, product_id, serial_number)) != NULL) {
-
-        HIDDeviceWrapper *wrapper = CreateHIDDeviceWrapper(pDevice, &DRIVER_Backend);
-        return WrapHIDDevice(wrapper);
+    if ((pDevice = DRIVER_hid_open(vendor_id, product_id, serial_number)) != NULL) {
+        return CreateHIDDeviceWrapper(pDevice, &DRIVER_Backend);
     }
 #endif /* HAVE_DRIVER_BACKEND */
 
 #ifdef SDL_LIBUSB_DYNAMIC
     if (libusb_ctx.libhandle &&
-        (pDevice = (hid_device*) LIBUSB_hid_open(vendor_id, product_id, serial_number)) != NULL) {
-
-        HIDDeviceWrapper *wrapper = CreateHIDDeviceWrapper(pDevice, &LIBUSB_Backend);
-        return WrapHIDDevice(wrapper);
+        (pDevice = LIBUSB_hid_open(vendor_id, product_id, serial_number)) != NULL) {
+        return CreateHIDDeviceWrapper(pDevice, &LIBUSB_Backend);
     }
 #endif /* SDL_LIBUSB_DYNAMIC */
 
+#endif /* HAVE_PLATFORM_BACKEND || HAVE_DRIVER_BACKEND || SDL_LIBUSB_DYNAMIC */
+
     return NULL;
 }
 
-HID_API_EXPORT hid_device * HID_API_CALL hid_open_path(const char *path, int bExclusive /* = false */)
+SDL_hid_device *SDL_hid_open_path(const char *path, int bExclusive /* = false */)
 {
-    hid_device *pDevice = NULL;
+#if HAVE_PLATFORM_BACKEND || HAVE_DRIVER_BACKEND || defined(SDL_LIBUSB_DYNAMIC)
+    void *pDevice = NULL;
 
-    if (hid_init() != 0) {
+    if (SDL_hidapi_refcount == 0 && SDL_hid_init() != 0) {
         return NULL;
     }
 
 #if HAVE_PLATFORM_BACKEND
     if (udev_ctx &&
-        (pDevice = (hid_device*) PLATFORM_hid_open_path(path, bExclusive)) != NULL) {
-
-        HIDDeviceWrapper *wrapper = CreateHIDDeviceWrapper(pDevice, &PLATFORM_Backend);
-        return WrapHIDDevice(wrapper);
+        (pDevice = PLATFORM_hid_open_path(path, bExclusive)) != NULL) {
+        return CreateHIDDeviceWrapper(pDevice, &PLATFORM_Backend);
     }
 #endif /* HAVE_PLATFORM_BACKEND */
 
 #if HAVE_DRIVER_BACKEND
-    if ((pDevice = (hid_device*) DRIVER_hid_open_path(path, bExclusive)) != NULL) {
-
-        HIDDeviceWrapper *wrapper = CreateHIDDeviceWrapper(pDevice, &DRIVER_Backend);
-        return WrapHIDDevice(wrapper);
+    if ((pDevice = DRIVER_hid_open_path(path, bExclusive)) != NULL) {
+        return CreateHIDDeviceWrapper(pDevice, &DRIVER_Backend);
     }
 #endif /* HAVE_DRIVER_BACKEND */
 
 #ifdef SDL_LIBUSB_DYNAMIC
     if (libusb_ctx.libhandle &&
-        (pDevice = (hid_device*) LIBUSB_hid_open_path(path, bExclusive)) != NULL) {
-
-        HIDDeviceWrapper *wrapper = CreateHIDDeviceWrapper(pDevice, &LIBUSB_Backend);
-        return WrapHIDDevice(wrapper);
+        (pDevice = LIBUSB_hid_open_path(path, bExclusive)) != NULL) {
+        return CreateHIDDeviceWrapper(pDevice, &LIBUSB_Backend);
     }
 #endif /* SDL_LIBUSB_DYNAMIC */
 
+#endif /* HAVE_PLATFORM_BACKEND || HAVE_DRIVER_BACKEND || SDL_LIBUSB_DYNAMIC */
+
     return NULL;
 }
 
-int  HID_API_EXPORT HID_API_CALL hid_write(hid_device *device, const unsigned char *data, size_t length)
+int SDL_hid_write(SDL_hid_device *device, const unsigned char *data, size_t length)
 {
-    HIDDeviceWrapper *wrapper = UnwrapHIDDevice(device);
-    return wrapper->backend->hid_write(wrapper->device, data, length);
+    int result;
+
+    CHECK_DEVICE_MAGIC(device, -1);
+
+    result = device->backend->hid_write(device->device, data, length);
+    if (result < 0) {
+        SDL_SetHIDAPIError(device->backend->hid_error(device->device));
+    }
+    return result;
 }
 
-int HID_API_EXPORT HID_API_CALL hid_read_timeout(hid_device *device, unsigned char *data, size_t length, int milliseconds)
+int SDL_hid_read_timeout(SDL_hid_device *device, unsigned char *data, size_t length, int milliseconds)
 {
-    HIDDeviceWrapper *wrapper = UnwrapHIDDevice(device);
-    return wrapper->backend->hid_read_timeout(wrapper->device, data, length, milliseconds);
+    int result;
+
+    CHECK_DEVICE_MAGIC(device, -1);
+
+    result = device->backend->hid_read_timeout(device->device, data, length, milliseconds);
+    if (result < 0) {
+        SDL_SetHIDAPIError(device->backend->hid_error(device->device));
+    }
+    return result;
 }
 
-int  HID_API_EXPORT HID_API_CALL hid_read(hid_device *device, unsigned char *data, size_t length)
+int SDL_hid_read(SDL_hid_device *device, unsigned char *data, size_t length)
 {
-    HIDDeviceWrapper *wrapper = UnwrapHIDDevice(device);
-    return wrapper->backend->hid_read(wrapper->device, data, length);
+    int result;
+
+    CHECK_DEVICE_MAGIC(device, -1);
+
+    result = device->backend->hid_read(device->device, data, length);
+    if (result < 0) {
+        SDL_SetHIDAPIError(device->backend->hid_error(device->device));
+    }
+    return result;
 }
 
-int  HID_API_EXPORT HID_API_CALL hid_set_nonblocking(hid_device *device, int nonblock)
+int SDL_hid_set_nonblocking(SDL_hid_device *device, int nonblock)
 {
-    HIDDeviceWrapper *wrapper = UnwrapHIDDevice(device);
-    return wrapper->backend->hid_set_nonblocking(wrapper->device, nonblock);
+    int result;
+
+    CHECK_DEVICE_MAGIC(device, -1);
+
+    result = device->backend->hid_set_nonblocking(device->device, nonblock);
+    if (result < 0) {
+        SDL_SetHIDAPIError(device->backend->hid_error(device->device));
+    }
+    return result;
 }
 
-int HID_API_EXPORT HID_API_CALL hid_send_feature_report(hid_device *device, const unsigned char *data, size_t length)
+int SDL_hid_send_feature_report(SDL_hid_device *device, const unsigned char *data, size_t length)
 {
-    HIDDeviceWrapper *wrapper = UnwrapHIDDevice(device);
-    return wrapper->backend->hid_send_feature_report(wrapper->device, data, length);
+    int result;
+
+    CHECK_DEVICE_MAGIC(device, -1);
+
+    result = device->backend->hid_send_feature_report(device->device, data, length);
+    if (result < 0) {
+        SDL_SetHIDAPIError(device->backend->hid_error(device->device));
+    }
+    return result;
 }
 
-int HID_API_EXPORT HID_API_CALL hid_get_feature_report(hid_device *device, unsigned char *data, size_t length)
+int SDL_hid_get_feature_report(SDL_hid_device *device, unsigned char *data, size_t length)
 {
-    HIDDeviceWrapper *wrapper = UnwrapHIDDevice(device);
-    return wrapper->backend->hid_get_feature_report(wrapper->device, data, length);
+    int result;
+
+    CHECK_DEVICE_MAGIC(device, -1);
+
+    result = device->backend->hid_get_feature_report(device->device, data, length);
+    if (result < 0) {
+        SDL_SetHIDAPIError(device->backend->hid_error(device->device));
+    }
+    return result;
 }
 
-void HID_API_EXPORT HID_API_CALL hid_close(hid_device *device)
+void SDL_hid_close(SDL_hid_device *device)
 {
-    HIDDeviceWrapper *wrapper = UnwrapHIDDevice(device);
-    wrapper->backend->hid_close(wrapper->device);
-    DeleteHIDDeviceWrapper(wrapper);
+    CHECK_DEVICE_MAGIC(device,);
+
+    device->backend->hid_close(device->device);
+    DeleteHIDDeviceWrapper(device);
 }
 
-int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *device, wchar_t *string, size_t maxlen)
+int SDL_hid_get_manufacturer_string(SDL_hid_device *device, wchar_t *string, size_t maxlen)
 {
-    HIDDeviceWrapper *wrapper = UnwrapHIDDevice(device);
-    return wrapper->backend->hid_get_manufacturer_string(wrapper->device, string, maxlen);
+    int result;
+
+    CHECK_DEVICE_MAGIC(device, -1);
+
+    result = device->backend->hid_get_manufacturer_string(device->device, string, maxlen);
+    if (result < 0) {
+        SDL_SetHIDAPIError(device->backend->hid_error(device->device));
+    }
+    return result;
 }
 
-int HID_API_EXPORT_CALL hid_get_product_string(hid_device *device, wchar_t *string, size_t maxlen)
+int SDL_hid_get_product_string(SDL_hid_device *device, wchar_t *string, size_t maxlen)
 {
-    HIDDeviceWrapper *wrapper = UnwrapHIDDevice(device);
-    return wrapper->backend->hid_get_product_string(wrapper->device, string, maxlen);
+    int result;
+
+    CHECK_DEVICE_MAGIC(device, -1);
+
+    result = device->backend->hid_get_product_string(device->device, string, maxlen);
+    if (result < 0) {
+        SDL_SetHIDAPIError(device->backend->hid_error(device->device));
+    }
+    return result;
 }
 
-int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *device, wchar_t *string, size_t maxlen)
+int SDL_hid_get_serial_number_string(SDL_hid_device *device, wchar_t *string, size_t maxlen)
 {
-    HIDDeviceWrapper *wrapper = UnwrapHIDDevice(device);
-    return wrapper->backend->hid_get_serial_number_string(wrapper->device, string, maxlen);
+    int result;
+
+    CHECK_DEVICE_MAGIC(device, -1);
+
+    result = device->backend->hid_get_serial_number_string(device->device, string, maxlen);
+    if (result < 0) {
+        SDL_SetHIDAPIError(device->backend->hid_error(device->device));
+    }
+    return result;
 }
 
-int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *device, int string_index, wchar_t *string, size_t maxlen)
+int SDL_hid_get_indexed_string(SDL_hid_device *device, int string_index, wchar_t *string, size_t maxlen)
 {
-    HIDDeviceWrapper *wrapper = UnwrapHIDDevice(device);
-    return wrapper->backend->hid_get_indexed_string(wrapper->device, string_index, string, maxlen);
+    int result;
+
+    CHECK_DEVICE_MAGIC(device, -1);
+
+    result = device->backend->hid_get_indexed_string(device->device, string_index, string, maxlen);
+    if (result < 0) {
+        SDL_SetHIDAPIError(device->backend->hid_error(device->device));
+    }
+    return result;
 }
 
-HID_API_EXPORT const wchar_t* HID_API_CALL hid_error(hid_device *device)
+void SDL_hid_ble_scan(SDL_bool active)
 {
-    HIDDeviceWrapper *wrapper = UnwrapHIDDevice(device);
-    return wrapper->backend->hid_error(wrapper->device);
+#if __IPHONEOS__ || __TVOS__
+    hid_ble_scan(active);
+#endif
 }
 
-#endif /* SDL_JOYSTICK_HIDAPI */
+#ifdef HAVE_ENABLE_GAMECUBE_ADAPTORS
+/* This is needed to enable input for Nyko and EVORETRO GameCube adaptors */
+void SDL_EnableGameCubeAdaptors(void)
+{
+#ifdef SDL_LIBUSB_DYNAMIC
+    libusb_context *context = NULL;
+    libusb_device **devs = NULL;
+    libusb_device_handle *handle = NULL;
+    struct libusb_device_descriptor desc;
+    ssize_t i, num_devs;
+    int kernel_detached = 0;
+
+    if (libusb_ctx.libhandle == NULL) {
+        return;
+    }
+
+    if (libusb_init(&context) == 0) {
+        num_devs = libusb_get_device_list(context, &devs);
+        for (i = 0; i < num_devs; ++i) {
+            if (libusb_get_device_descriptor(devs[i], &desc) != 0) {
+                continue;
+            }
+
+            if (desc.idVendor != 0x057e || desc.idProduct != 0x0337) {
+                continue;
+            }
+
+            if (libusb_open(devs[i], &handle) != 0) {
+                continue;
+            }
+
+            if (libusb_kernel_driver_active(handle, 0)) {
+                if (libusb_detach_kernel_driver(handle, 0) == 0) {
+                    kernel_detached = 1;
+                }
+            }
+
+            if (libusb_claim_interface(handle, 0) == 0) {
+                libusb_control_transfer(handle, 0x21, 11, 0x0001, 0, NULL, 0, 1000);
+                libusb_release_interface(handle, 0);
+            }
+
+            if (kernel_detached) {
+                libusb_attach_kernel_driver(handle, 0);
+            }
+
+            libusb_close(handle);
+        }
+
+        libusb_free_device_list(devs, 1);
+
+        libusb_exit(context);
+    }
+#endif /* SDL_LIBUSB_DYNAMIC */
+}
+#endif /* HAVE_ENABLE_GAMECUBE_ADAPTORS */
 
 /* vi: set sts=4 ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/hidapi/SDL_hidapi_c.h b/Engine/lib/sdl/src/hidapi/SDL_hidapi_c.h
new file mode 100644
index 000000000..1b4094232
--- /dev/null
+++ b/Engine/lib/sdl/src/hidapi/SDL_hidapi_c.h
@@ -0,0 +1,35 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../SDL_internal.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI
+
+#ifdef SDL_LIBUSB_DYNAMIC
+#define HAVE_ENABLE_GAMECUBE_ADAPTORS
+#endif
+
+#ifdef HAVE_ENABLE_GAMECUBE_ADAPTORS
+extern void SDL_EnableGameCubeAdaptors(void);
+#endif
+
+#endif /* SDL_JOYSTICK_HIDAPI */
+
+/* vi: set sts=4 ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/hidapi/android/hid.cpp b/Engine/lib/sdl/src/hidapi/android/hid.cpp
index e5af5ad2d..de365d005 100644
--- a/Engine/lib/sdl/src/hidapi/android/hid.cpp
+++ b/Engine/lib/sdl/src/hidapi/android/hid.cpp
@@ -1,17 +1,33 @@
-//=================== Copyright Valve Corporation, All rights reserved. =======
-//
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 2021 Valve Corporation
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
 // Purpose: A wrapper implementing "HID" API for Android
 //
 //          This layer glues the hidapi API to Android's USB and BLE stack.
-//
-//=============================================================================
 
+
+// Common to stub version and non-stub version of functions
 #include <jni.h>
 #include <android/log.h>
-#include <pthread.h>
-#include <errno.h>	// For ETIMEDOUT and ECONNRESET
-#include <stdlib.h> // For malloc() and free()
-#include <string.h>	// For memcpy()
 
 #define TAG "hidapi"
 
@@ -31,6 +47,35 @@
 #define CONCAT2(prefix, class, function)                Java_ ## prefix ## _ ## class ## _ ## function
 #define HID_DEVICE_MANAGER_JAVA_INTERFACE(function)     CONCAT1(SDL_JAVA_PREFIX, HIDDeviceManager, function)
 
+
+#if !SDL_HIDAPI_DISABLED
+
+#include "SDL_hints.h"
+#include "../../core/android/SDL_android.h"
+
+#define hid_init                        PLATFORM_hid_init
+#define hid_exit                        PLATFORM_hid_exit
+#define hid_enumerate                   PLATFORM_hid_enumerate
+#define hid_free_enumeration            PLATFORM_hid_free_enumeration
+#define hid_open                        PLATFORM_hid_open
+#define hid_open_path                   PLATFORM_hid_open_path
+#define hid_write                       PLATFORM_hid_write
+#define hid_read_timeout                PLATFORM_hid_read_timeout
+#define hid_read                        PLATFORM_hid_read
+#define hid_set_nonblocking             PLATFORM_hid_set_nonblocking
+#define hid_send_feature_report         PLATFORM_hid_send_feature_report
+#define hid_get_feature_report          PLATFORM_hid_get_feature_report
+#define hid_close                       PLATFORM_hid_close
+#define hid_get_manufacturer_string     PLATFORM_hid_get_manufacturer_string
+#define hid_get_product_string          PLATFORM_hid_get_product_string
+#define hid_get_serial_number_string    PLATFORM_hid_get_serial_number_string
+#define hid_get_indexed_string          PLATFORM_hid_get_indexed_string
+#define hid_error                       PLATFORM_hid_error
+
+#include <pthread.h>
+#include <errno.h>	// For ETIMEDOUT and ECONNRESET
+#include <stdlib.h> // For malloc() and free()
+
 #include "../hidapi/hidapi.h"
 
 typedef uint32_t uint32;
@@ -154,7 +199,7 @@ public:
 		}
 
 		m_nSize = nSize;
-		memcpy( m_pData, pData, nSize );
+		SDL_memcpy( m_pData, pData, nSize );
 	}
 
 	void clear()
@@ -269,9 +314,9 @@ private:
 
 static jbyteArray NewByteArray( JNIEnv* env, const uint8_t *pData, size_t nDataLen )
 {
-	jbyteArray array = env->NewByteArray( nDataLen );
+	jbyteArray array = env->NewByteArray( (jsize)nDataLen );
 	jbyte *pBuf = env->GetByteArrayElements( array, NULL );
-	memcpy( pBuf, pData, nDataLen );
+	SDL_memcpy( pBuf, pData, nDataLen );
 	env->ReleaseByteArrayElements( array, pBuf, 0 );
 
 	return array;
@@ -282,7 +327,7 @@ static char *CreateStringFromJString( JNIEnv *env, const jstring &sString )
 	size_t nLength = env->GetStringUTFLength( sString );
 	const char *pjChars = env->GetStringUTFChars( sString, NULL );
 	char *psString = (char*)malloc( nLength + 1 );
-	memcpy( psString, pjChars, nLength );
+	SDL_memcpy( psString, pjChars, nLength );
 	psString[ nLength ] = '\0';
 	env->ReleaseStringUTFChars( sString, pjChars );
 	return psString;
@@ -305,9 +350,9 @@ static wchar_t *CreateWStringFromJString( JNIEnv *env, const jstring &sString )
 
 static wchar_t *CreateWStringFromWString( const wchar_t *pwSrc )
 {
-	size_t nLength = wcslen( pwSrc );
+	size_t nLength = SDL_wcslen( pwSrc );
 	wchar_t *pwString = (wchar_t*)malloc( ( nLength + 1 ) * sizeof( wchar_t ) );
-	memcpy( pwString, pwSrc, nLength * sizeof( wchar_t ) );
+	SDL_memcpy( pwString, pwSrc, nLength * sizeof( wchar_t ) );
 	pwString[ nLength ] = '\0';
 	return pwString;
 }
@@ -316,7 +361,7 @@ static hid_device_info *CopyHIDDeviceInfo( const hid_device_info *pInfo )
 {
 	hid_device_info *pCopy = new hid_device_info;
 	*pCopy = *pInfo;
-	pCopy->path = strdup( pInfo->path );
+	pCopy->path = SDL_strdup( pInfo->path );
 	pCopy->product_string = CreateWStringFromWString( pInfo->product_string );
 	pCopy->manufacturer_string = CreateWStringFromWString( pInfo->manufacturer_string );
 	pCopy->serial_number = CreateWStringFromWString( pInfo->serial_number );
@@ -334,17 +379,49 @@ static void FreeHIDDeviceInfo( hid_device_info *pInfo )
 
 static jclass  g_HIDDeviceManagerCallbackClass;
 static jobject g_HIDDeviceManagerCallbackHandler;
+static jmethodID g_midHIDDeviceManagerInitialize;
 static jmethodID g_midHIDDeviceManagerOpen;
 static jmethodID g_midHIDDeviceManagerSendOutputReport;
 static jmethodID g_midHIDDeviceManagerSendFeatureReport;
 static jmethodID g_midHIDDeviceManagerGetFeatureReport;
 static jmethodID g_midHIDDeviceManagerClose;
+static bool g_initialized = false;
 
 static uint64_t get_timespec_ms( const struct timespec &ts )
 {
 	return (uint64_t)ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
 }
 
+static void ExceptionCheck( JNIEnv *env, const char *pszClassName, const char *pszMethodName )
+{
+	if ( env->ExceptionCheck() )
+	{
+		// Get our exception
+		jthrowable jExcept = env->ExceptionOccurred();
+
+		// Clear the exception so we can call JNI again
+		env->ExceptionClear();
+
+		// Get our exception message
+		jclass jExceptClass = env->GetObjectClass( jExcept );
+		jmethodID jMessageMethod = env->GetMethodID( jExceptClass, "getMessage", "()Ljava/lang/String;" );
+		jstring jMessage = (jstring)( env->CallObjectMethod( jExcept, jMessageMethod ) );
+		const char *pszMessage = env->GetStringUTFChars( jMessage, NULL );
+
+		// ...and log it.
+		LOGE( "%s%s%s threw an exception: %s",
+			pszClassName ? pszClassName : "",
+			pszClassName ? "::" : "",
+			pszMethodName, pszMessage );
+
+		// Cleanup
+		env->ReleaseStringUTFChars( jMessage, pszMessage );
+		env->DeleteLocalRef( jMessage );
+		env->DeleteLocalRef( jExceptClass );
+		env->DeleteLocalRef( jExcept );
+	}
+}
+
 class CHIDDevice
 {
 public:
@@ -404,29 +481,7 @@ public:
 
 	void ExceptionCheck( JNIEnv *env, const char *pszMethodName )
 	{
-		if ( env->ExceptionCheck() )
-		{
-			// Get our exception
-			jthrowable jExcept = env->ExceptionOccurred();
-
-			// Clear the exception so we can call JNI again
-			env->ExceptionClear();
-
-			// Get our exception message
-			jclass jExceptClass = env->GetObjectClass( jExcept );
-			jmethodID jMessageMethod = env->GetMethodID( jExceptClass, "getMessage", "()Ljava/lang/String;" );
-			jstring jMessage = (jstring)( env->CallObjectMethod( jExcept, jMessageMethod ) );
-			const char *pszMessage = env->GetStringUTFChars( jMessage, NULL );
-
-			// ...and log it.
-			LOGE( "CHIDDevice::%s threw an exception: %s", pszMethodName, pszMessage );
-
-			// Cleanup
-			env->ReleaseStringUTFChars( jMessage, pszMessage );
-			env->DeleteLocalRef( jMessage );
-			env->DeleteLocalRef( jExceptClass );
-			env->DeleteLocalRef( jExcept );
-		}
+		::ExceptionCheck( env, "CHIDDevice", pszMethodName );
 	}
 
 	bool BOpen()
@@ -527,12 +582,12 @@ public:
 		if ( m_bIsBLESteamController )
 		{
 			data[0] = 0x03;
-			memcpy( data + 1, buffer.data(), nDataLen );
+			SDL_memcpy( data + 1, buffer.data(), nDataLen );
 			++nDataLen;
 		}
 		else
 		{
-			memcpy( data, buffer.data(), nDataLen );
+			SDL_memcpy( data, buffer.data(), nDataLen );
 		}
 		m_vecData.pop_front();
 
@@ -541,7 +596,7 @@ public:
 //			 data[0], data[1], data[2], data[3],
 //			 data[4], data[5], data[6], data[7]);
 
-		return nDataLen;
+		return (int)nDataLen;
 	}
 
 	int SendOutputReport( const unsigned char *pData, size_t nDataLen )
@@ -669,11 +724,11 @@ public:
 			}
 
 			size_t uBytesToCopy = m_featureReport.size() > nDataLen ? nDataLen : m_featureReport.size();
-			memcpy( pData, m_featureReport.data(), uBytesToCopy );
+			SDL_memcpy( pData, m_featureReport.data(), uBytesToCopy );
 			m_featureReport.clear();
 			LOGV( "=== Got %u bytes", uBytesToCopy );
 
-			return uBytesToCopy;
+			return (int)uBytesToCopy;
 		}
 	}
 
@@ -815,6 +870,11 @@ JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceRegisterCallba
 	if ( objClass )
 	{
 		g_HIDDeviceManagerCallbackClass = reinterpret_cast< jclass >( env->NewGlobalRef( objClass ) );
+		g_midHIDDeviceManagerInitialize = env->GetMethodID( g_HIDDeviceManagerCallbackClass, "initialize", "(ZZ)Z" );
+		if ( !g_midHIDDeviceManagerInitialize )
+		{
+			__android_log_print(ANDROID_LOG_ERROR, TAG, "HIDDeviceRegisterCallback: callback class missing initialize" );
+		}
 		g_midHIDDeviceManagerOpen = env->GetMethodID( g_HIDDeviceManagerCallbackClass, "openDevice", "(I)Z" );
 		if ( !g_midHIDDeviceManagerOpen )
 		{
@@ -854,6 +914,7 @@ JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceReleaseCallbac
 		g_HIDDeviceManagerCallbackClass = NULL;
 		env->DeleteGlobalRef( g_HIDDeviceManagerCallbackHandler );
 		g_HIDDeviceManagerCallbackHandler = NULL;
+		g_initialized = false;
 	}
 }
 
@@ -863,7 +924,7 @@ JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceConnected)(JNI
 	LOGV( "HIDDeviceConnected() id=%d VID/PID = %.4x/%.4x, interface %d\n", nDeviceID, nVendorId, nProductId, nInterface );
 
 	hid_device_info *pInfo = new hid_device_info;
-	memset( pInfo, 0, sizeof( *pInfo ) );
+	SDL_memset( pInfo, 0, sizeof( *pInfo ) );
 	pInfo->path = CreateStringFromJString( env, sIdentifier );
 	pInfo->vendor_id = nVendorId;
 	pInfo->product_id = nProductId;
@@ -988,6 +1049,36 @@ extern "C"
 
 int hid_init(void)
 {
+	if ( !g_initialized )
+	{
+		// HIDAPI doesn't work well with Android < 4.3
+		if (SDL_GetAndroidSDKVersion() >= 18) {
+			// Make sure thread is attached to JVM/env
+			JNIEnv *env;
+			g_JVM->AttachCurrentThread( &env, NULL );
+			pthread_setspecific( g_ThreadKey, (void*)env );
+
+			if ( !g_HIDDeviceManagerCallbackHandler )
+			{
+				LOGV( "hid_init() without callback handler" );
+				return -1;
+			}
+
+			// Bluetooth is currently only used for Steam Controllers, so check that hint
+			// before initializing Bluetooth, which will prompt the user for permission.
+			bool init_usb = true;
+			bool init_bluetooth = false;
+			if (SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_STEAM, SDL_FALSE)) {
+				if (SDL_GetAndroidSDKVersion() < 31 ||
+					Android_JNI_RequestPermission("android.permission.BLUETOOTH_CONNECT")) {
+					init_bluetooth = true;
+				}
+			}
+			env->CallBooleanMethod( g_HIDDeviceManagerCallbackHandler, g_midHIDDeviceManagerInitialize, init_usb, init_bluetooth );
+			ExceptionCheck( env, NULL, "hid_init" );
+		}
+		g_initialized = true;	// Regardless of result, so it's only called once
+	}
 	return 0;
 }
 
@@ -1035,7 +1126,7 @@ HID_API_EXPORT hid_device * HID_API_CALL hid_open_path(const char *path, int bEx
 		hid_mutex_guard l( &g_DevicesMutex );
 		for ( hid_device_ref<CHIDDevice> pCurr = g_Devices; pCurr; pCurr = pCurr->next )
 		{
-			if ( strcmp( pCurr->GetDeviceInfo()->path, path ) == 0 ) 
+			if ( SDL_strcmp( pCurr->GetDeviceInfo()->path, path ) == 0 ) 
 			{
 				hid_device *pValue = pCurr->GetDevice();
 				if ( pValue )
@@ -1072,7 +1163,32 @@ int  HID_API_EXPORT HID_API_CALL hid_write(hid_device *device, const unsigned ch
 	return -1; // Controller was disconnected
 }
 
-// TODO: Implement timeout?
+static uint32_t getms()
+{
+	struct timeval now;
+
+	gettimeofday(&now, NULL);
+	return (uint32_t)(now.tv_sec * 1000 + now.tv_usec / 1000);
+}
+
+static void delayms(uint32_t ms)
+{
+    int was_error;
+
+    struct timespec elapsed, tv;
+
+    /* Set the timeout interval */
+    elapsed.tv_sec = ms / 1000;
+    elapsed.tv_nsec = (ms % 1000) * 1000000;
+    do {
+        errno = 0;
+
+        tv.tv_sec = elapsed.tv_sec;
+        tv.tv_nsec = elapsed.tv_nsec;
+        was_error = nanosleep(&tv, &elapsed);
+    } while (was_error && (errno == EINTR));
+}
+
 int HID_API_EXPORT HID_API_CALL hid_read_timeout(hid_device *device, unsigned char *data, size_t length, int milliseconds)
 {
 	if ( device )
@@ -1081,7 +1197,17 @@ int HID_API_EXPORT HID_API_CALL hid_read_timeout(hid_device *device, unsigned ch
 		hid_device_ref<CHIDDevice> pDevice = FindDevice( device->m_nId );
 		if ( pDevice )
 		{
-			return pDevice->GetInput( data, length );
+			int nResult = pDevice->GetInput( data, length );
+			if ( nResult == 0 && milliseconds > 0 )
+			{
+				uint32_t start = getms();
+				do
+				{
+					delayms( 1 );
+					nResult = pDevice->GetInput( data, length );
+				} while ( nResult == 0 && ( getms() - start ) < milliseconds );
+			}
+			return nResult;
 		}
 		LOGV( "controller was disconnected" );
 	}
@@ -1213,3 +1339,80 @@ int hid_exit(void)
 }
 
 }
+
+#else
+
+extern "C"
+JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceRegisterCallback)(JNIEnv *env, jobject thiz);
+
+extern "C"
+JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceReleaseCallback)(JNIEnv *env, jobject thiz);
+
+extern "C"
+JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceConnected)(JNIEnv *env, jobject thiz, int nDeviceID, jstring sIdentifier, int nVendorId, int nProductId, jstring sSerialNumber, int nReleaseNumber, jstring sManufacturer, jstring sProduct, int nInterface, int nInterfaceClass, int nInterfaceSubclass, int nInterfaceProtocol );
+
+extern "C"
+JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceOpenPending)(JNIEnv *env, jobject thiz, int nDeviceID);
+
+extern "C"
+JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceOpenResult)(JNIEnv *env, jobject thiz, int nDeviceID, bool bOpened);
+
+extern "C"
+JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceDisconnected)(JNIEnv *env, jobject thiz, int nDeviceID);
+
+extern "C"
+JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceInputReport)(JNIEnv *env, jobject thiz, int nDeviceID, jbyteArray value);
+
+extern "C"
+JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceFeatureReport)(JNIEnv *env, jobject thiz, int nDeviceID, jbyteArray value);
+
+
+extern "C"
+JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceRegisterCallback)(JNIEnv *env, jobject thiz )
+{
+	LOGV("Stub HIDDeviceRegisterCallback()");
+}
+
+extern "C"
+JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceReleaseCallback)(JNIEnv *env, jobject thiz)
+{
+	LOGV("Stub HIDDeviceReleaseCallback()");
+}
+
+extern "C"
+JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceConnected)(JNIEnv *env, jobject thiz, int nDeviceID, jstring sIdentifier, int nVendorId, int nProductId, jstring sSerialNumber, int nReleaseNumber, jstring sManufacturer, jstring sProduct, int nInterface, int nInterfaceClass, int nInterfaceSubclass, int nInterfaceProtocol )
+{
+	LOGV("Stub HIDDeviceConnected() id=%d VID/PID = %.4x/%.4x, interface %d\n", nDeviceID, nVendorId, nProductId, nInterface);
+}
+
+extern "C"
+JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceOpenPending)(JNIEnv *env, jobject thiz, int nDeviceID)
+{
+	LOGV("Stub HIDDeviceOpenPending() id=%d\n", nDeviceID);
+}
+
+extern "C"
+JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceOpenResult)(JNIEnv *env, jobject thiz, int nDeviceID, bool bOpened)
+{
+	LOGV("Stub HIDDeviceOpenResult() id=%d, result=%s\n", nDeviceID, bOpened ? "true" : "false");
+}
+
+extern "C"
+JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceDisconnected)(JNIEnv *env, jobject thiz, int nDeviceID)
+{
+	LOGV("Stub HIDDeviceDisconnected() id=%d\n", nDeviceID);
+}
+
+extern "C"
+JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceInputReport)(JNIEnv *env, jobject thiz, int nDeviceID, jbyteArray value)
+{
+	LOGV("Stub HIDDeviceInput() id=%d len=%u\n", nDeviceID, nBufSize);
+}
+
+extern "C"
+JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceFeatureReport)(JNIEnv *env, jobject thiz, int nDeviceID, jbyteArray value)
+{
+	LOGV("Stub HIDDeviceFeatureReport() id=%d len=%u\n", nDeviceID, nBufSize);
+}
+
+#endif /* SDL_HIDAPI_DISABLED */
diff --git a/Engine/lib/sdl/src/hidapi/hidapi/hidapi.h b/Engine/lib/sdl/src/hidapi/hidapi/hidapi.h
index 2c663196b..3fddfa885 100644
--- a/Engine/lib/sdl/src/hidapi/hidapi/hidapi.h
+++ b/Engine/lib/sdl/src/hidapi/hidapi/hidapi.h
@@ -29,7 +29,12 @@
 
 #include <wchar.h>
 
-#if defined(_WIN32) && !defined(NAMESPACE) && (0) /* SDL: don't export hidapi syms */
+#ifdef SDL_hidapi_h_
+#define SDL_HIDAPI_IMPLEMENTATION
+#define hid_device_info SDL_hid_device_info
+#endif
+
+#if defined(_WIN32) && !defined(NAMESPACE) && !defined(SDL_HIDAPI_IMPLEMENTATION) /* SDL: don't export hidapi syms */
       #define HID_API_EXPORT __declspec(dllexport)
       #define HID_API_CALL
 #else
@@ -53,6 +58,7 @@ namespace NAMESPACE {
 		struct hid_device_;
 		typedef struct hid_device_ hid_device; /**< opaque hidapi structure */
 
+#ifndef SDL_HIDAPI_IMPLEMENTATION
 		/** hidapi info structure */
 		struct hid_device_info {
 			/** Platform-specific device path */
@@ -77,9 +83,11 @@ namespace NAMESPACE {
 			    (Windows/Mac only).*/
 			unsigned short usage;
 			/** The USB interface which this logical device
-			    represents. Valid on both Linux implementations
-			    in all cases, and valid on the Windows implementation
-			    only if the device contains more than one interface. */
+			    represents.
+
+				* Valid on both Linux implementations in all cases.
+				* Valid on the Windows implementation only if the device
+				  contains more than one interface. */
 			int interface_number;
 
 			/** Additional information about the USB interface.
@@ -91,6 +99,7 @@ namespace NAMESPACE {
 			/** Pointer to the next device */
 			struct hid_device_info *next;
 		};
+#endif /* !SDL_HIDAPI_IMPLEMENTATION */
 
 
 		/** @brief Initialize the HIDAPI library.
@@ -101,7 +110,7 @@ namespace NAMESPACE {
 			needed.  This function should be called at the beginning of
 			execution however, if there is a chance of HIDAPI handles
 			being opened by different threads simultaneously.
-			
+
 			@ingroup API
 
 			@returns
@@ -139,7 +148,7 @@ namespace NAMESPACE {
 
 		    @returns
 		    	This function returns a pointer to a linked list of type
-		    	struct #hid_device, containing information about the HID devices
+		    	struct #hid_device_info, containing information about the HID devices
 		    	attached to the system, or NULL in the case of failure. Free
 		    	this linked list by calling hid_free_enumeration().
 		*/
@@ -205,7 +214,7 @@ namespace NAMESPACE {
 			the Control Endpoint (Endpoint 0).
 
 			@ingroup API
-			@param device A device handle returned from hid_open().
+			@param dev A device handle returned from hid_open().
 			@param data The data to send, including the report number as
 				the first byte.
 			@param length The length in bytes of the data to send.
@@ -214,7 +223,7 @@ namespace NAMESPACE {
 				This function returns the actual number of bytes written and
 				-1 on error.
 		*/
-		int  HID_API_EXPORT HID_API_CALL hid_write(hid_device *device, const unsigned char *data, size_t length);
+		int  HID_API_EXPORT HID_API_CALL hid_write(hid_device *dev, const unsigned char *data, size_t length);
 
 		/** @brief Read an Input report from a HID device with timeout.
 
@@ -223,7 +232,7 @@ namespace NAMESPACE {
 			contain the Report number if the device uses numbered reports.
 
 			@ingroup API
-			@param device A device handle returned from hid_open().
+			@param dev A device handle returned from hid_open().
 			@param data A buffer to put the read data into.
 			@param length The number of bytes to read. For devices with
 				multiple reports, make sure to read an extra byte for
@@ -235,7 +244,7 @@ namespace NAMESPACE {
 				-1 on error. If no packet was available to be read within
 				the timeout period, this function returns 0.
 		*/
-		int HID_API_EXPORT HID_API_CALL hid_read_timeout(hid_device *device, unsigned char *data, size_t length, int milliseconds);
+		int HID_API_EXPORT HID_API_CALL hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds);
 
 		/** @brief Read an Input report from a HID device.
 
@@ -244,7 +253,7 @@ namespace NAMESPACE {
 			contain the Report number if the device uses numbered reports.
 
 			@ingroup API
-			@param device A device handle returned from hid_open().
+			@param dev A device handle returned from hid_open().
 			@param data A buffer to put the read data into.
 			@param length The number of bytes to read. For devices with
 				multiple reports, make sure to read an extra byte for
@@ -255,7 +264,7 @@ namespace NAMESPACE {
 				-1 on error. If no packet was available to be read and
 				the handle is in non-blocking mode, this function returns 0.
 		*/
-		int  HID_API_EXPORT HID_API_CALL hid_read(hid_device *device, unsigned char *data, size_t length);
+		int  HID_API_EXPORT HID_API_CALL hid_read(hid_device *dev, unsigned char *data, size_t length);
 
 		/** @brief Set the device handle to be non-blocking.
 
@@ -267,7 +276,7 @@ namespace NAMESPACE {
 			Nonblocking can be turned on and off at any time.
 
 			@ingroup API
-			@param device A device handle returned from hid_open().
+			@param dev A device handle returned from hid_open().
 			@param nonblock enable or not the nonblocking reads
 			 - 1 to enable nonblocking
 			 - 0 to disable nonblocking.
@@ -275,7 +284,7 @@ namespace NAMESPACE {
 			@returns
 				This function returns 0 on success and -1 on error.
 		*/
-		int  HID_API_EXPORT HID_API_CALL hid_set_nonblocking(hid_device *device, int nonblock);
+		int  HID_API_EXPORT HID_API_CALL hid_set_nonblocking(hid_device *dev, int nonblock);
 
 		/** @brief Send a Feature report to the device.
 
@@ -293,7 +302,7 @@ namespace NAMESPACE {
 			in would be 17.
 
 			@ingroup API
-			@param device A device handle returned from hid_open().
+			@param dev A device handle returned from hid_open().
 			@param data The data to send, including the report number as
 				the first byte.
 			@param length The length in bytes of the data to send, including
@@ -303,7 +312,7 @@ namespace NAMESPACE {
 				This function returns the actual number of bytes written and
 				-1 on error.
 		*/
-		int HID_API_EXPORT HID_API_CALL hid_send_feature_report(hid_device *device, const unsigned char *data, size_t length);
+		int HID_API_EXPORT HID_API_CALL hid_send_feature_report(hid_device *dev, const unsigned char *data, size_t length);
 
 		/** @brief Get a feature report from a HID device.
 
@@ -314,7 +323,7 @@ namespace NAMESPACE {
 			start in data[1].
 
 			@ingroup API
-			@param device A device handle returned from hid_open().
+			@param dev A device handle returned from hid_open().
 			@param data A buffer to put the read data into, including
 				the Report ID. Set the first byte of @p data[] to the
 				Report ID of the report to be read, or set it to zero
@@ -328,55 +337,55 @@ namespace NAMESPACE {
 				one for the report ID (which is still in the first
 				byte), or -1 on error.
 		*/
-		int HID_API_EXPORT HID_API_CALL hid_get_feature_report(hid_device *device, unsigned char *data, size_t length);
+		int HID_API_EXPORT HID_API_CALL hid_get_feature_report(hid_device *dev, unsigned char *data, size_t length);
 
 		/** @brief Close a HID device.
 
 			@ingroup API
-			@param device A device handle returned from hid_open().
+			@param dev A device handle returned from hid_open().
 		*/
-		void HID_API_EXPORT HID_API_CALL hid_close(hid_device *device);
+		void HID_API_EXPORT HID_API_CALL hid_close(hid_device *dev);
 
 		/** @brief Get The Manufacturer String from a HID device.
 
 			@ingroup API
-			@param device A device handle returned from hid_open().
+			@param dev A device handle returned from hid_open().
 			@param string A wide string buffer to put the data into.
 			@param maxlen The length of the buffer in multiples of wchar_t.
 
 			@returns
 				This function returns 0 on success and -1 on error.
 		*/
-		int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *device, wchar_t *string, size_t maxlen);
+		int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen);
 
 		/** @brief Get The Product String from a HID device.
 
 			@ingroup API
-			@param device A device handle returned from hid_open().
+			@param dev A device handle returned from hid_open().
 			@param string A wide string buffer to put the data into.
 			@param maxlen The length of the buffer in multiples of wchar_t.
 
 			@returns
 				This function returns 0 on success and -1 on error.
 		*/
-		int HID_API_EXPORT_CALL hid_get_product_string(hid_device *device, wchar_t *string, size_t maxlen);
+		int HID_API_EXPORT_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen);
 
 		/** @brief Get The Serial Number String from a HID device.
 
 			@ingroup API
-			@param device A device handle returned from hid_open().
+			@param dev A device handle returned from hid_open().
 			@param string A wide string buffer to put the data into.
 			@param maxlen The length of the buffer in multiples of wchar_t.
 
 			@returns
 				This function returns 0 on success and -1 on error.
 		*/
-		int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *device, wchar_t *string, size_t maxlen);
+		int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen);
 
 		/** @brief Get a string from a HID device, based on its string index.
 
 			@ingroup API
-			@param device A device handle returned from hid_open().
+			@param dev A device handle returned from hid_open().
 			@param string_index The index of the string to get.
 			@param string A wide string buffer to put the data into.
 			@param maxlen The length of the buffer in multiples of wchar_t.
@@ -384,18 +393,22 @@ namespace NAMESPACE {
 			@returns
 				This function returns 0 on success and -1 on error.
 		*/
-		int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *device, int string_index, wchar_t *string, size_t maxlen);
+		int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen);
 
 		/** @brief Get a string describing the last error which occurred.
 
 			@ingroup API
-			@param device A device handle returned from hid_open().
+			@param dev A device handle returned from hid_open().
 
 			@returns
 				This function returns a string containing the last error
 				which occurred or NULL if none has occurred.
 		*/
-		HID_API_EXPORT const wchar_t* HID_API_CALL hid_error(hid_device *device);
+		HID_API_EXPORT const wchar_t* HID_API_CALL hid_error(hid_device *dev);
+
+#if __IPHONEOS__ || __TVOS__
+		HID_API_EXPORT void HID_API_CALL hid_ble_scan(int active);
+#endif
 
 #if defined(__cplusplus) && !defined(NAMESPACE)
 }
diff --git a/Engine/lib/sdl/src/hidapi/ios/hid.m b/Engine/lib/sdl/src/hidapi/ios/hid.m
index 504a994b1..111b8f236 100644
--- a/Engine/lib/sdl/src/hidapi/ios/hid.m
+++ b/Engine/lib/sdl/src/hidapi/ios/hid.m
@@ -1,11 +1,47 @@
-//======== Copyright (c) 2017 Valve Corporation, All rights reserved. =========
-//
-// Purpose: HID device abstraction temporary stub
-//
-//=============================================================================
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 2021 Valve Corporation
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
 #include "../../SDL_internal.h"
 
-#ifdef SDL_JOYSTICK_HIDAPI
+#if !SDL_HIDAPI_DISABLED
+
+#include "SDL_hints.h"
+
+#define hid_init                        PLATFORM_hid_init
+#define hid_exit                        PLATFORM_hid_exit
+#define hid_enumerate                   PLATFORM_hid_enumerate
+#define hid_free_enumeration            PLATFORM_hid_free_enumeration
+#define hid_open                        PLATFORM_hid_open
+#define hid_open_path                   PLATFORM_hid_open_path
+#define hid_write                       PLATFORM_hid_write
+#define hid_read_timeout                PLATFORM_hid_read_timeout
+#define hid_read                        PLATFORM_hid_read
+#define hid_set_nonblocking             PLATFORM_hid_set_nonblocking
+#define hid_send_feature_report         PLATFORM_hid_send_feature_report
+#define hid_get_feature_report          PLATFORM_hid_get_feature_report
+#define hid_close                       PLATFORM_hid_close
+#define hid_get_manufacturer_string     PLATFORM_hid_get_manufacturer_string
+#define hid_get_product_string          PLATFORM_hid_get_product_string
+#define hid_get_serial_number_string    PLATFORM_hid_get_serial_number_string
+#define hid_get_indexed_string          PLATFORM_hid_get_indexed_string
+#define hid_error                       PLATFORM_hid_error
 
 #include <CoreBluetooth/CoreBluetooth.h>
 #include <QuartzCore/QuartzCore.h>
@@ -193,24 +229,29 @@ typedef enum
 		sharedInstance = [HIDBLEManager new];
 		sharedInstance.nPendingScans = 0;
 		sharedInstance.nPendingPairs = 0;
-		
-		[[NSNotificationCenter defaultCenter] addObserver:sharedInstance selector:@selector(appWillResignActiveNotification:) name: UIApplicationWillResignActiveNotification object:nil];
-		[[NSNotificationCenter defaultCenter] addObserver:sharedInstance selector:@selector(appDidBecomeActiveNotification:) name:UIApplicationDidBecomeActiveNotification object:nil];
 
-		// receive reports on a high-priority serial-queue. optionally put writes on the serial queue to avoid logical
-		// race conditions talking to the controller from multiple threads, although BLE fragmentation/assembly means
-		// that we can still screw this up.
-		// most importantly we need to consume reports at a high priority to avoid the OS thinking we aren't really
-		// listening to the BLE device, as iOS on slower devices may stop delivery of packets to the app WITHOUT ACTUALLY
-		// DISCONNECTING FROM THE DEVICE if we don't react quickly enough to their delivery.
-		// see also the error-handling states in the peripheral delegate to re-open the device if it gets closed
-		sharedInstance.bleSerialQueue = dispatch_queue_create( "com.valvesoftware.steamcontroller.ble", DISPATCH_QUEUE_SERIAL );
-		dispatch_set_target_queue( sharedInstance.bleSerialQueue, dispatch_get_global_queue( DISPATCH_QUEUE_PRIORITY_HIGH, 0 ) );
+        // Bluetooth is currently only used for Steam Controllers, so check that hint
+        // before initializing Bluetooth, which will prompt the user for permission.
+		if ( SDL_GetHintBoolean( SDL_HINT_JOYSTICK_HIDAPI_STEAM, SDL_FALSE ) )
+		{
+			[[NSNotificationCenter defaultCenter] addObserver:sharedInstance selector:@selector(appWillResignActiveNotification:) name: UIApplicationWillResignActiveNotification object:nil];
+			[[NSNotificationCenter defaultCenter] addObserver:sharedInstance selector:@selector(appDidBecomeActiveNotification:) name:UIApplicationDidBecomeActiveNotification object:nil];
 
-		// creating a CBCentralManager will always trigger a future centralManagerDidUpdateState:
-		// where any scanning gets started or connecting to existing peripherals happens, it's never already in a
-		// powered-on state for a newly launched application.
-		sharedInstance.centralManager = [[CBCentralManager alloc] initWithDelegate:sharedInstance queue:sharedInstance.bleSerialQueue];
+			// receive reports on a high-priority serial-queue. optionally put writes on the serial queue to avoid logical
+			// race conditions talking to the controller from multiple threads, although BLE fragmentation/assembly means
+			// that we can still screw this up.
+			// most importantly we need to consume reports at a high priority to avoid the OS thinking we aren't really
+			// listening to the BLE device, as iOS on slower devices may stop delivery of packets to the app WITHOUT ACTUALLY
+			// DISCONNECTING FROM THE DEVICE if we don't react quickly enough to their delivery.
+			// see also the error-handling states in the peripheral delegate to re-open the device if it gets closed
+			sharedInstance.bleSerialQueue = dispatch_queue_create( "com.valvesoftware.steamcontroller.ble", DISPATCH_QUEUE_SERIAL );
+			dispatch_set_target_queue( sharedInstance.bleSerialQueue, dispatch_get_global_queue( DISPATCH_QUEUE_PRIORITY_HIGH, 0 ) );
+
+			// creating a CBCentralManager will always trigger a future centralManagerDidUpdateState:
+			// where any scanning gets started or connecting to existing peripherals happens, it's never already in a
+			// powered-on state for a newly launched application.
+			sharedInstance.centralManager = [[CBCentralManager alloc] initWithDelegate:sharedInstance queue:sharedInstance.bleSerialQueue];
+		}
 		sharedInstance.deviceMap = [[NSMapTable alloc] initWithKeyOptions:NSMapTableWeakMemory valueOptions:NSMapTableStrongMemory capacity:4];
 	});
 	return sharedInstance;
@@ -250,6 +291,11 @@ typedef enum
 	static uint64_t s_unLastUpdateTick = 0;
 	static mach_timebase_info_data_t s_timebase_info;
 	
+	if ( self.centralManager == nil )
+    {
+		return 0;
+    }
+
 	if (s_timebase_info.denom == 0)
 	{
 		mach_timebase_info( &s_timebase_info );
@@ -295,6 +341,11 @@ typedef enum
 // manual API for folks to start & stop scanning
 - (void)startScan:(int)duration
 {
+	if ( self.centralManager == nil )
+	{
+		return;
+	}
+
 	NSLog( @"BLE: requesting scan for %d seconds", duration );
 	@synchronized (self)
 	{
@@ -314,6 +365,11 @@ typedef enum
 
 - (void)stopScan
 {
+	if ( self.centralManager == nil )
+	{
+		return;
+	}
+
 	NSLog( @"BLE: stopping scan" );
 	@synchronized (self)
 	{
@@ -709,7 +765,7 @@ int HID_API_EXPORT HID_API_CALL hid_exit(void)
 	return 0;
 }
 
-void HID_API_EXPORT HID_API_CALL hid_ble_scan( bool bStart )
+void HID_API_EXPORT HID_API_CALL hid_ble_scan( int bStart )
 {
 	HIDBLEManager *bleManager = HIDBLEManager.sharedInstance;
 	if ( bStart )
@@ -722,7 +778,12 @@ void HID_API_EXPORT HID_API_CALL hid_ble_scan( bool bStart )
 	}
 }
 
-hid_device * HID_API_EXPORT hid_open_path( const char *path, int bExclusive /* = false */ )
+HID_API_EXPORT hid_device * HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number)
+{
+	return NULL;
+}
+
+HID_API_EXPORT hid_device * HID_API_CALL hid_open_path( const char *path, int bExclusive /* = false */ )
 {
 	hid_device *result = NULL;
 	NSString *nssPath = [NSString stringWithUTF8String:path];
@@ -836,6 +897,11 @@ int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *s
 	return 0;
 }
 
+int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen)
+{
+	return -1;
+}
+
 int HID_API_EXPORT hid_write(hid_device *dev, const unsigned char *data, size_t length)
 {
     HIDBLEDevice *device_handle = (__bridge HIDBLEDevice *)dev->device_handle;
@@ -912,4 +978,9 @@ int HID_API_EXPORT hid_read_timeout(hid_device *dev, unsigned char *data, size_t
 	return result;
 }
 
-#endif /* SDL_JOYSTICK_HIDAPI */
+HID_API_EXPORT const wchar_t* HID_API_CALL hid_error(hid_device *dev)
+{
+	return NULL;
+}
+
+#endif /* !SDL_HIDAPI_DISABLED */
diff --git a/Engine/lib/sdl/src/hidapi/libusb/hid.c b/Engine/lib/sdl/src/hidapi/libusb/hid.c
index 67833d9b6..c54746e4d 100644
--- a/Engine/lib/sdl/src/hidapi/libusb/hid.c
+++ b/Engine/lib/sdl/src/hidapi/libusb/hid.c
@@ -31,12 +31,29 @@
 #include "SDL_thread.h"
 #include "SDL_mutex.h"
 
-#ifdef SDL_JOYSTICK_HIDAPI
+#ifndef HAVE_WCSDUP
+#ifdef HAVE__WCSDUP
+#define wcsdup _wcsdup
+#else
+#define wcsdup _dupwcs
+static wchar_t *_dupwcs(const wchar_t *src)
+{
+    wchar_t *dst = NULL;
+    if (src) {
+        size_t len = SDL_wcslen(src) + 1;
+        len *= sizeof(wchar_t);
+        dst = (wchar_t *) malloc(len);
+        if (dst) memcpy(dst, src, len);
+    }
+    return dst;
+}
+#endif
+#endif /* HAVE_WCSDUP */
 
 #include <libusb.h>
 #include <locale.h> /* setlocale */
 
-#include "hidapi.h"
+#include "../hidapi/hidapi.h"
 
 #ifdef NAMESPACE
 namespace NAMESPACE
@@ -57,12 +74,8 @@ typedef struct _SDL_ThreadBarrier
 
 static int SDL_CreateThreadBarrier(SDL_ThreadBarrier *barrier, Uint32 count)
 {
-	if (barrier == NULL) {
-		return SDL_SetError("barrier must be non-NULL");
-	}
-	if (count == 0) {
-		return SDL_SetError("count must be > 0");
-	}
+	SDL_assert(barrier != NULL);
+	SDL_assert(count != 0);
 
 	barrier->mutex = SDL_CreateMutex();
 	if (barrier->mutex == NULL) {
@@ -157,7 +170,7 @@ struct hid_device_ {
 	SDL_cond *condition;
 	SDL_ThreadBarrier barrier; /* Ensures correct startup sequence */
 	int shutdown_thread;
-	int cancelled;
+	int transfer_loop_finished;
 	struct libusb_transfer *transfer;
 
 	/* List of received input reports. */
@@ -196,7 +209,6 @@ static void free_hid_device(hid_device *dev)
 /*TODO: Implement this function on hidapi/libusb.. */
 static void register_error(hid_device *dev, const char *op)
 {
-
 }
 #endif
 
@@ -320,7 +332,6 @@ static inline int libusb_get_string_descriptor(libusb_device_handle *dev,
 		(LIBUSB_DT_STRING << 8) | descriptor_index,
 		lang_id, data, (uint16_t) length, 1000);
 }
-
 #endif
 
 
@@ -373,12 +384,16 @@ static int is_language_supported(libusb_device_handle *dev, uint16_t lang)
 /* This function returns a newly allocated wide string containing the USB
    device string numbered by the index. The returned string must be freed
    by using free(). */
+#if defined(__OS2__) /* don't use iconv on OS/2: no support for wchar_t. */
+#define NO_ICONV
+#endif
 static wchar_t *get_usb_string(libusb_device_handle *dev, uint8_t idx)
 {
 	char buf[512];
 	int len;
 	wchar_t *str = NULL;
 
+#if !defined(NO_ICONV)
 	wchar_t wbuf[256];
 	SDL_iconv_t ic;
 	size_t inbytes;
@@ -386,6 +401,9 @@ static wchar_t *get_usb_string(libusb_device_handle *dev, uint8_t idx)
 	size_t res;
 	const char *inptr;
 	char *outptr;
+#else
+	int i;
+#endif
 
 	/* Determine which language to use. */
 	uint16_t lang;
@@ -402,6 +420,23 @@ static wchar_t *get_usb_string(libusb_device_handle *dev, uint8_t idx)
 	if (len < 0)
 		return NULL;
 
+#if defined(NO_ICONV) /* original hidapi code for NO_ICONV : */
+
+	/* Bionic does not have wchar_t iconv support, so it
+	   has to be done manually.  The following code will only work for
+	   code points that can be represented as a single UTF-16 character,
+	   and will incorrectly convert any code points which require more
+	   than one UTF-16 character.
+
+	   Skip over the first character (2-bytes).  */
+	len -= 2;
+	str = (wchar_t*) malloc((len / 2 + 1) * sizeof(wchar_t));
+	for (i = 0; i < len / 2; i++) {
+		str[i] = buf[i * 2 + 2] | (buf[i * 2 + 3] << 8);
+	}
+	str[len / 2] = 0x00000000;
+
+#else
 	/* buf does not need to be explicitly NULL-terminated because
 	   it is only passed into iconv() which does not need it. */
 
@@ -434,10 +469,100 @@ static wchar_t *get_usb_string(libusb_device_handle *dev, uint8_t idx)
 
 err:
 	SDL_iconv_close(ic);
+#endif
 
 	return str;
 }
 
+struct usb_string_cache_entry {
+	uint16_t vid;
+	uint16_t pid;
+	wchar_t *vendor;
+	wchar_t *product;
+};
+
+static struct usb_string_cache_entry *usb_string_cache = NULL;
+static size_t usb_string_cache_size = 0;
+static size_t usb_string_cache_insert_pos = 0;
+
+static int usb_string_cache_grow()
+{
+	struct usb_string_cache_entry *new_cache;
+	size_t allocSize;
+	size_t new_cache_size;
+
+	new_cache_size = usb_string_cache_size + 8;
+	allocSize = sizeof(struct usb_string_cache_entry) * new_cache_size;
+	new_cache = (struct usb_string_cache_entry *)realloc(usb_string_cache, allocSize);
+	if (!new_cache)
+		return -1;
+
+	usb_string_cache = new_cache;
+	usb_string_cache_size = new_cache_size;
+
+	return 0;
+}
+
+static void usb_string_cache_destroy()
+{
+	size_t i;
+	for (i = 0; i < usb_string_cache_insert_pos; i++) {
+		free(usb_string_cache[i].vendor);
+		free(usb_string_cache[i].product);
+	}
+	free(usb_string_cache);
+
+	usb_string_cache = NULL;
+	usb_string_cache_size = 0;
+	usb_string_cache_insert_pos = 0;
+}
+
+static struct usb_string_cache_entry *usb_string_cache_insert()
+{
+	struct usb_string_cache_entry *new_entry = NULL;
+	if (usb_string_cache_insert_pos >= usb_string_cache_size) {
+		if (usb_string_cache_grow() < 0)
+			return NULL;
+	}
+	new_entry = &usb_string_cache[usb_string_cache_insert_pos];
+	usb_string_cache_insert_pos++;
+	return new_entry;
+}
+
+static const struct usb_string_cache_entry *usb_string_cache_find(struct libusb_device_descriptor *desc, struct libusb_device_handle *handle)
+{
+	struct usb_string_cache_entry *entry = NULL;
+	size_t i;
+
+	/* Search for existing string cache entry */
+	for (i = 0; i < usb_string_cache_insert_pos; i++) {
+		entry = &usb_string_cache[i];
+		if (entry->vid != desc->idVendor)
+			continue;
+		if (entry->pid != desc->idProduct)
+			continue;
+		return entry;
+	}
+
+	/* Not found, create one. */
+	entry = usb_string_cache_insert();
+	if (!entry)
+		return NULL;
+
+	entry->vid = desc->idVendor;
+	entry->pid = desc->idProduct;
+	if (desc->iManufacturer > 0)
+		entry->vendor = get_usb_string(handle, desc->iManufacturer);
+	else
+		entry->vendor = NULL;
+	if (desc->iProduct > 0)
+		entry->product = get_usb_string(handle, desc->iProduct);
+	else
+		entry->product = NULL;
+
+	return entry;
+}
+
 static char *make_path(libusb_device *dev, int interface_number)
 {
 	char str[64];
@@ -471,6 +596,8 @@ int HID_API_EXPORT hid_init(void)
 
 int HID_API_EXPORT hid_exit(void)
 {
+	usb_string_cache_destroy();
+
 	if (usb_context) {
 		libusb_exit(usb_context);
 		usb_context = NULL;
@@ -504,7 +631,9 @@ static int is_xbox360(unsigned short vendor_id, const struct libusb_interface_de
 		0x15e4, /* Numark */
 		0x162e, /* Joytech */
 		0x1689, /* Razer Onza */
+		0x1949, /* Lab126, Inc. */
 		0x1bad, /* Harmonix */
+		0x20d6, /* PowerA */
 		0x24c6, /* PowerA */
 	};
 
@@ -524,17 +653,18 @@ static int is_xbox360(unsigned short vendor_id, const struct libusb_interface_de
 
 static int is_xboxone(unsigned short vendor_id, const struct libusb_interface_descriptor *intf_desc)
 {
-    static const int XB1_IFACE_SUBCLASS = 71;
-    static const int XB1_IFACE_PROTOCOL = 208;
-    static const int SUPPORTED_VENDORS[] = {
-        0x045e, /* Microsoft */
-        0x0738, /* Mad Catz */
-        0x0e6f, /* PDP */
-        0x0f0d, /* Hori */
-        0x1532, /* Razer Wildcat */
-        0x24c6, /* PowerA */
-        0x2e24, /* Hyperkin */
-    };
+	static const int XB1_IFACE_SUBCLASS = 71;
+	static const int XB1_IFACE_PROTOCOL = 208;
+	static const int SUPPORTED_VENDORS[] = {
+		0x045e, /* Microsoft */
+		0x0738, /* Mad Catz */
+		0x0e6f, /* PDP */
+		0x0f0d, /* Hori */
+		0x1532, /* Razer Wildcat */
+		0x20d6, /* PowerA */
+		0x24c6, /* PowerA */
+		0x2e24, /* Hyperkin */
+	};
 
 	if (intf_desc->bInterfaceNumber == 0 &&
 	    intf_desc->bInterfaceClass == LIBUSB_CLASS_VENDOR_SPEC &&
@@ -612,6 +742,7 @@ struct hid_device_info  HID_API_EXPORT *hid_enumerate(unsigned short vendor_id,
 
 							if (res >= 0) {
 								struct hid_device_info *tmp;
+								const struct usb_string_cache_entry *string_cache;
 
 								/* VID/PID match. Create the record. */
 								tmp = (struct hid_device_info*) calloc(1, sizeof(struct hid_device_info));
@@ -633,12 +764,24 @@ struct hid_device_info  HID_API_EXPORT *hid_enumerate(unsigned short vendor_id,
 										get_usb_string(handle, desc.iSerialNumber);
 
 								/* Manufacturer and Product strings */
-								if (desc.iManufacturer > 0)
-									cur_dev->manufacturer_string =
-										get_usb_string(handle, desc.iManufacturer);
-								if (desc.iProduct > 0)
-									cur_dev->product_string =
-										get_usb_string(handle, desc.iProduct);
+								if (dev_vid && dev_pid) {
+									string_cache = usb_string_cache_find(&desc, handle);
+									if (string_cache) {
+										if (string_cache->vendor) {
+											cur_dev->manufacturer_string = wcsdup(string_cache->vendor);
+										}
+										if (string_cache->product) {
+											cur_dev->product_string = wcsdup(string_cache->product);
+										}
+									}
+								} else {
+									if (desc.iManufacturer > 0)
+										cur_dev->manufacturer_string =
+											get_usb_string(handle, desc.iManufacturer);
+									if (desc.iProduct > 0)
+										cur_dev->product_string =
+											get_usb_string(handle, desc.iProduct);
+								}
 
 #ifdef INVASIVE_GET_USAGE
 {
@@ -825,13 +968,9 @@ static void LIBUSB_CALL read_callback(struct libusb_transfer *transfer)
 	}
 	else if (transfer->status == LIBUSB_TRANSFER_CANCELLED) {
 		dev->shutdown_thread = 1;
-		dev->cancelled = 1;
-		return;
 	}
 	else if (transfer->status == LIBUSB_TRANSFER_NO_DEVICE) {
 		dev->shutdown_thread = 1;
-		dev->cancelled = 1;
-		return;
 	}
 	else if (transfer->status == LIBUSB_TRANSFER_TIMED_OUT) {
 		//LOG("Timeout (normal)\n");
@@ -840,12 +979,17 @@ static void LIBUSB_CALL read_callback(struct libusb_transfer *transfer)
 		LOG("Unknown transfer code: %d\n", transfer->status);
 	}
 
+	if (dev->shutdown_thread) {
+		dev->transfer_loop_finished = 1;
+		return;
+	}
+
 	/* Re-submit the transfer object. */
 	res = libusb_submit_transfer(transfer);
 	if (res != 0) {
 		LOG("Unable to submit URB. libusb error code: %d\n", res);
 		dev->shutdown_thread = 1;
-		dev->cancelled = 1;
+		dev->transfer_loop_finished = 1;
 	}
 }
 
@@ -888,6 +1032,7 @@ static int read_thread(void *param)
 			    res != LIBUSB_ERROR_TIMEOUT &&
 			    res != LIBUSB_ERROR_OVERFLOW &&
 			    res != LIBUSB_ERROR_INTERRUPTED) {
+				dev->shutdown_thread = 1;
 				break;
 			}
 		}
@@ -897,8 +1042,8 @@ static int read_thread(void *param)
 	   if no transfers are pending, but that's OK. */
 	libusb_cancel_transfer(dev->transfer);
 
-	while (!dev->cancelled)
-		libusb_handle_events_completed(usb_context, &dev->cancelled);
+	while (!dev->transfer_loop_finished)
+		libusb_handle_events_completed(usb_context, &dev->transfer_loop_finished);
 
 	/* Now that the read thread is stopping, Wake any threads which are
 	   waiting on data (in hid_read_timeout()). Do this under a mutex to
@@ -920,35 +1065,46 @@ static int read_thread(void *param)
 	return 0;
 }
 
-static void init_xboxone(libusb_device_handle *device_handle, struct libusb_config_descriptor *conf_desc)
+static void init_xboxone(libusb_device_handle *device_handle, unsigned short idVendor, unsigned short idProduct, struct libusb_config_descriptor *conf_desc)
 {
-        static const int XB1_IFACE_SUBCLASS = 71;
-        static const int XB1_IFACE_PROTOCOL = 208;
+	static const int VENDOR_MICROSOFT = 0x045e;
+	static const int XB1_IFACE_SUBCLASS = 71;
+	static const int XB1_IFACE_PROTOCOL = 208;
 	int j, k, res;
 
 	for (j = 0; j < conf_desc->bNumInterfaces; j++) {
 		const struct libusb_interface *intf = &conf_desc->interface[j];
 		for (k = 0; k < intf->num_altsetting; k++) {
-			const struct libusb_interface_descriptor *intf_desc;
-			intf_desc = &intf->altsetting[k];
-
-			if (intf_desc->bInterfaceNumber != 0 &&
-			    intf_desc->bAlternateSetting == 0 &&
-			    intf_desc->bInterfaceClass == LIBUSB_CLASS_VENDOR_SPEC &&
+			const struct libusb_interface_descriptor *intf_desc = &intf->altsetting[k];
+			if (intf_desc->bInterfaceClass == LIBUSB_CLASS_VENDOR_SPEC &&
 			    intf_desc->bInterfaceSubClass == XB1_IFACE_SUBCLASS &&
 			    intf_desc->bInterfaceProtocol == XB1_IFACE_PROTOCOL) {
-				res = libusb_claim_interface(device_handle, intf_desc->bInterfaceNumber);
-				if (res < 0) {
-					LOG("can't claim interface %d: %d\n", intf_desc->bInterfaceNumber, res);
-					continue;
+				int bSetAlternateSetting = 0;
+
+				/* Newer Microsoft Xbox One controllers have a high speed alternate setting */
+				if (idVendor == VENDOR_MICROSOFT &&
+				    intf_desc->bInterfaceNumber == 0 && intf_desc->bAlternateSetting == 1) {
+					bSetAlternateSetting = 1;
+				} else if (intf_desc->bInterfaceNumber != 0 && intf_desc->bAlternateSetting == 0) {
+					bSetAlternateSetting = 1;
 				}
 
-				res = libusb_set_interface_alt_setting(device_handle, intf_desc->bInterfaceNumber, intf_desc->bAlternateSetting);
-				if (res < 0) {
-					LOG("xbox init: can't set alt setting %d: %d\n", intf_desc->bInterfaceNumber, res);
-				}
+				if (bSetAlternateSetting) {
+					res = libusb_claim_interface(device_handle, intf_desc->bInterfaceNumber);
+					if (res < 0) {
+						LOG("can't claim interface %d: %d\n", intf_desc->bInterfaceNumber, res);
+						continue;
+					}
 
-				libusb_release_interface(device_handle, intf_desc->bInterfaceNumber);
+					LOG("Setting alternate setting for VID/PID 0x%x/0x%x interface %d to %d\n",  idVendor, idProduct, intf_desc->bInterfaceNumber, intf_desc->bAlternateSetting);
+
+					res = libusb_set_interface_alt_setting(device_handle, intf_desc->bInterfaceNumber, intf_desc->bAlternateSetting);
+					if (res < 0) {
+						LOG("xbox init: can't set alt setting %d: %d\n", intf_desc->bInterfaceNumber, res);
+					}
+
+					libusb_release_interface(device_handle, intf_desc->bInterfaceNumber);
+				}
 			}
 		}
 	}
@@ -1030,7 +1186,7 @@ hid_device * HID_API_EXPORT hid_open_path(const char *path, int bExclusive)
 
 						/* Initialize XBox One controllers */
 						if (is_xboxone(desc.idVendor, intf_desc)) {
-							init_xboxone(dev->device_handle, conf_desc);
+							init_xboxone(dev->device_handle, desc.idVendor, desc.idProduct, conf_desc);
 						}
 
 						/* Store off the string descriptor indexes */
@@ -1173,21 +1329,21 @@ static void cleanup_mutex(void *param)
 }
 #endif
 
-
 int HID_API_EXPORT hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds)
 {
-	int bytes_read = -1;
-
 #if 0
 	int transferred;
 	int res = libusb_interrupt_transfer(dev->device_handle, dev->input_endpoint, data, length, &transferred, 5000);
 	LOG("transferred: %d\n", transferred);
 	return transferred;
 #endif
+	int bytes_read;
 
 	SDL_LockMutex(dev->mutex);
 	/* TODO: pthread_cleanup SDL? */
 
+	bytes_read = -1;
+
 	/* There's an input report queued up. Return it. */
 	if (dev->input_reports) {
 		/* Return the first one */
@@ -1620,5 +1776,3 @@ uint16_t get_usb_code_for_current_locale(void)
 #ifdef NAMESPACE
 }
 #endif
-
-#endif /* SDL_JOYSTICK_HIDAPI */
diff --git a/Engine/lib/sdl/src/hidapi/linux/hid.c b/Engine/lib/sdl/src/hidapi/linux/hid.c
index 19a0d9669..6a0ae9fed 100644
--- a/Engine/lib/sdl/src/hidapi/linux/hid.c
+++ b/Engine/lib/sdl/src/hidapi/linux/hid.c
@@ -22,8 +22,6 @@
 ********************************************************/
 #include "../../SDL_internal.h"
 
-#ifdef SDL_JOYSTICK_HIDAPI
-
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE /* needed for wcsdup() before glibc 2.10 */
 #endif
@@ -50,7 +48,7 @@
 #include <linux/input.h>
 #include <libudev.h>
 
-#include "hidapi.h"
+#include "../hidapi/hidapi.h"
 
 #ifdef NAMESPACE
 namespace NAMESPACE
@@ -217,7 +215,7 @@ static int uses_numbered_reports(__u8 *report_descriptor, __u32 size) {
  * strings pointed to by serial_number_utf8 and product_name_utf8 after use.
  */
 static int
-parse_uevent_info(const char *uevent, int *bus_type,
+parse_uevent_info(const char *uevent, unsigned *bus_type,
 	unsigned short *vendor_id, unsigned short *product_id,
 	char **serial_number_utf8, char **product_name_utf8)
 {
@@ -300,7 +298,7 @@ static int is_BLE(hid_device *dev)
 		if (hid_dev) {
 			unsigned short dev_vid = 0;
 			unsigned short dev_pid = 0;
-			int bus_type = 0;
+			unsigned bus_type = 0;
 			char *serial_number_utf8 = NULL;
 			char *product_name_utf8 = NULL;
 
@@ -338,8 +336,8 @@ static int get_device_string(hid_device *dev, enum device_string_id key, wchar_t
 	struct udev_device *udev_dev, *parent, *hid_dev;
 	struct stat s;
 	int ret = -1;
-        char *serial_number_utf8 = NULL;
-        char *product_name_utf8 = NULL;
+	char *serial_number_utf8 = NULL;
+	char *product_name_utf8 = NULL;
 	char *tmp;
 
 	/* Create the udev object */
@@ -365,7 +363,7 @@ static int get_device_string(hid_device *dev, enum device_string_id key, wchar_t
 		if (hid_dev) {
 			unsigned short dev_vid;
 			unsigned short dev_pid;
-			int bus_type;
+			unsigned bus_type;
 			size_t retm;
 
 			ret = parse_uevent_info(
@@ -433,8 +431,8 @@ static int get_device_string(hid_device *dev, enum device_string_id key, wchar_t
 	}
 
 end:
-        free(serial_number_utf8);
-        free(product_name_utf8);
+	free(serial_number_utf8);
+	free(product_name_utf8);
 
 	udev_device_unref(udev_dev);
 	/* parent and hid_dev don't need to be (and can't be) unref'd.
@@ -503,7 +501,7 @@ struct hid_device_info  HID_API_EXPORT *hid_enumerate(unsigned short vendor_id,
 		unsigned short dev_pid;
 		char *serial_number_utf8 = NULL;
 		char *product_name_utf8 = NULL;
-		int bus_type;
+		unsigned bus_type;
 		int result;
 
 		/* Get the filename of the /sys entry for the device
@@ -716,7 +714,7 @@ hid_device * HID_API_EXPORT hid_open_path(const char *path, int bExclusive)
 	dev = new_hid_device();
 
 	/* OPEN HERE */
-	dev->device_handle = open(path, O_RDWR);
+	dev->device_handle = open(path, O_RDWR | O_CLOEXEC);
 
 	/* If we have a good handle, return it. */
 	if (dev->device_handle >= 0) {
@@ -828,34 +826,47 @@ int HID_API_EXPORT hid_set_nonblocking(hid_device *dev, int nonblock)
 	return 0; /* Success */
 }
 
-
 int HID_API_EXPORT hid_send_feature_report(hid_device *dev, const unsigned char *data, size_t length)
 {
+	static const int MAX_RETRIES = 50;
+	int retry;
 	int res;
 
-	res = ioctl(dev->device_handle, HIDIOCSFEATURE(length), data);
-	if (res < 0)
-		perror("ioctl (SFEATURE)");
+	for (retry = 0; retry < MAX_RETRIES; ++retry) {
+		res = ioctl(dev->device_handle, HIDIOCSFEATURE(length), data);
+		if (res < 0 && errno == EPIPE) {
+			/* Try again... */
+			continue;
+		}
 
+		if (res < 0)
+			perror("ioctl (SFEATURE)");
+		break;
+	}
 	return res;
 }
 
 int HID_API_EXPORT hid_get_feature_report(hid_device *dev, unsigned char *data, size_t length)
 {
 	int res;
+	unsigned char report = data[0];
 
-	/* It looks like HIDIOCGFEATURE() on Bluetooth LE devices doesn't return the report number */
-	if (dev->needs_ble_hack) {
-		data[1] = data[0];
-		++data;
-		--length;
-	}
 	res = ioctl(dev->device_handle, HIDIOCGFEATURE(length), data);
 	if (res < 0)
 		perror("ioctl (GFEATURE)");
-	else if (dev->needs_ble_hack)
-		++res;
-
+	else if (dev->needs_ble_hack) {
+		/* Versions of BlueZ before 5.56 don't include the report in the data,
+		 * and versions of BlueZ >= 5.56 include 2 copies of the report.
+		 * We'll fix it so that there is a single copy of the report in both cases
+		 */
+		if (data[0] == report && data[1] == report) {
+			memmove(&data[0], &data[1], res);
+		} else if (data[0] != report) {
+			memmove(&data[1], &data[0], res);
+			data[0] = report;
+			++res;
+		}
+	}
 	return res;
 }
 
@@ -886,6 +897,10 @@ int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *s
 
 int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen)
 {
+	(void)dev;
+	(void)string_index;
+	(void)string;
+	(void)maxlen;
 	return -1;
 }
 
@@ -898,5 +913,3 @@ HID_API_EXPORT const wchar_t * HID_API_CALL  hid_error(hid_device *dev)
 #ifdef NAMESPACE
 }
 #endif
-
-#endif /* SDL_JOYSTICK_HIDAPI */
diff --git a/Engine/lib/sdl/src/hidapi/linux/hid.cpp b/Engine/lib/sdl/src/hidapi/linux/hid.cpp
deleted file mode 100644
index 841f34fb4..000000000
--- a/Engine/lib/sdl/src/hidapi/linux/hid.cpp
+++ /dev/null
@@ -1,333 +0,0 @@
-//=================== Copyright Valve Corporation, All rights reserved. =======
-//
-// Purpose: A wrapper around both the libusb and hidraw versions of HIDAPI
-//
-//          The libusb version doesn't support Bluetooth, but not all Linux
-//          distributions allow access to /dev/hidraw*
-//
-//          This merges the two, at a small performance cost, until distributions
-//          have granted access to /dev/hidraw*
-//
-//=============================================================================
-
-#define NAMESPACE HIDRAW
-#include "../hidapi/hidapi.h"
-#undef NAMESPACE
-#undef HIDAPI_H__
-
-#define NAMESPACE HIDUSB
-#include "../hidapi/hidapi.h"
-#undef NAMESPACE
-#undef HIDAPI_H__
-
-#include "../hidapi/hidapi.h"
-
-#include "../../../public/tier1/utlvector.h"
-#include "../../../public/tier1/utlhashmap.h"
-
-
-template <class T>
-void CopyHIDDeviceInfo( T *pSrc, struct hid_device_info *pDst )
-{
-	pDst->path = pSrc->path ? strdup( pSrc->path ) : NULL;
-	pDst->vendor_id = pSrc->vendor_id;
-	pDst->product_id = pSrc->product_id;
-	pDst->serial_number = pSrc->serial_number ? wcsdup( pSrc->serial_number ) : NULL;
-	pDst->release_number = pSrc->release_number;
-	pDst->manufacturer_string = pSrc->manufacturer_string ? wcsdup( pSrc->manufacturer_string ) : NULL;
-	pDst->product_string = pSrc->product_string ? wcsdup( pSrc->product_string ) : NULL;
-	pDst->usage_page = pSrc->usage_page;
-	pDst->usage = pSrc->usage;
-	pDst->interface_number = pSrc->interface_number;
-	pDst->next = NULL;
-}
-
-extern "C"
-{
-
-enum EHIDAPIType
-{
-	k_EHIDAPIUnknown,
-	k_EHIDAPIRAW,
-	k_EHIDAPIUSB
-};
-
-static CUtlHashMap<uintptr_t, EHIDAPIType> s_hashDeviceToAPI;
-
-static EHIDAPIType GetAPIForDevice( hid_device *pDevice )
-{
-	int iIndex = s_hashDeviceToAPI.Find( (uintptr_t)pDevice );
-	if ( iIndex != -1 )
-	{
-		return s_hashDeviceToAPI[ iIndex ];
-	}
-	return k_EHIDAPIUnknown;
-}
-
-struct hid_device_info HID_API_EXPORT * HID_API_CALL hid_enumerate(unsigned short vendor_id, unsigned short product_id)
-{
-	struct HIDUSB::hid_device_info *usb_devs = HIDUSB::hid_enumerate( vendor_id, product_id );
-	struct HIDUSB::hid_device_info *usb_dev;
-	struct HIDRAW::hid_device_info *raw_devs = HIDRAW::hid_enumerate( vendor_id, product_id );
-	struct HIDRAW::hid_device_info *raw_dev;
-	struct hid_device_info *devs = NULL, *last = NULL, *new_dev;
-
-	for ( usb_dev = usb_devs; usb_dev; usb_dev = usb_dev->next )
-	{
-		bool bFound = false;
-		for ( raw_dev = raw_devs; raw_dev; raw_dev = raw_dev->next )
-		{
-			if ( usb_dev->vendor_id == raw_dev->vendor_id && usb_dev->product_id == raw_dev->product_id )
-			{
-				bFound = true;
-				break;
-			}
-		}
-
-//printf("%s USB device VID/PID 0x%.4x/0x%.4x, %ls %ls\n", bFound ? "Found matching" : "Added new", usb_dev->vendor_id, usb_dev->product_id, usb_dev->manufacturer_string, usb_dev->product_string );
-
-		if ( !bFound )
-		{
-			new_dev = new struct hid_device_info;
-			CopyHIDDeviceInfo( usb_dev, new_dev );
-
-			if ( last )
-			{
-				last->next = new_dev;
-			}
-			else
-			{
-				devs = new_dev;
-			}
-			last = new_dev;
-		}
-	}
-	HIDUSB::hid_free_enumeration( usb_devs );
-
-	for ( raw_dev = raw_devs; raw_dev; raw_dev = raw_dev->next )
-	{
-		new_dev = new struct hid_device_info;
-		CopyHIDDeviceInfo( raw_dev, new_dev );
-		new_dev->next = NULL;
-
-		if ( last )
-		{
-			last->next = new_dev;
-		}
-		else
-		{
-			devs = new_dev;
-		}
-		last = new_dev;
-	}
-	HIDRAW::hid_free_enumeration( raw_devs );
-
-	return devs;
-}
-
-void  HID_API_EXPORT HID_API_CALL hid_free_enumeration(struct hid_device_info *devs)
-{
-	while ( devs )
-	{
-		struct hid_device_info *next = devs->next;
-		free( devs->path );
-		free( devs->serial_number );
-		free( devs->manufacturer_string );
-		free( devs->product_string );
-		delete devs;
-		devs = next;
-	}
-}
-
-HID_API_EXPORT hid_device * HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number)
-{
-	hid_device *pDevice = NULL;
-	if ( ( pDevice = (hid_device *)HIDRAW::hid_open( vendor_id, product_id, serial_number ) ) != NULL )
-	{
-		s_hashDeviceToAPI.Insert( (uintptr_t)pDevice, k_EHIDAPIRAW );
-		return pDevice;
-	}
-	if ( ( pDevice = (hid_device *)HIDUSB::hid_open( vendor_id, product_id, serial_number ) ) != NULL )
-	{
-		s_hashDeviceToAPI.Insert( (uintptr_t)pDevice, k_EHIDAPIUSB );
-		return pDevice;
-	}
-	return NULL;
-}
-
-HID_API_EXPORT hid_device * HID_API_CALL hid_open_path(const char *path, int bExclusive)
-{
-	hid_device *pDevice = NULL;
-	if ( ( pDevice = (hid_device *)HIDRAW::hid_open_path( path, bExclusive ) ) != NULL )
-	{
-		s_hashDeviceToAPI.Insert( (uintptr_t)pDevice, k_EHIDAPIRAW );
-		return pDevice;
-	}
-	if ( ( pDevice = (hid_device *)HIDUSB::hid_open_path( path, bExclusive ) ) != NULL )
-	{
-		s_hashDeviceToAPI.Insert( (uintptr_t)pDevice, k_EHIDAPIUSB );
-		return pDevice;
-	}
-	return NULL;
-}
-
-int  HID_API_EXPORT HID_API_CALL hid_write(hid_device *device, const unsigned char *data, size_t length)
-{
-	switch ( GetAPIForDevice( device ) )
-	{
-	case k_EHIDAPIRAW:
-		return HIDRAW::hid_write( (HIDRAW::hid_device*)device, data, length );
-	case k_EHIDAPIUSB:
-		return HIDUSB::hid_write( (HIDUSB::hid_device*)device, data, length );
-	default:
-		return -1;
-	} 
-}
-
-int HID_API_EXPORT HID_API_CALL hid_read_timeout(hid_device *device, unsigned char *data, size_t length, int milliseconds)
-{
-	switch ( GetAPIForDevice( device ) )
-	{
-	case k_EHIDAPIRAW:
-		return HIDRAW::hid_read_timeout( (HIDRAW::hid_device*)device, data, length, milliseconds );
-	case k_EHIDAPIUSB:
-		return HIDUSB::hid_read_timeout( (HIDUSB::hid_device*)device, data, length, milliseconds );
-	default:
-		return -1;
-	} 
-}
-
-int  HID_API_EXPORT HID_API_CALL hid_read(hid_device *device, unsigned char *data, size_t length)
-{
-	switch ( GetAPIForDevice( device ) )
-	{
-	case k_EHIDAPIRAW:
-		return HIDRAW::hid_read( (HIDRAW::hid_device*)device, data, length );
-	case k_EHIDAPIUSB:
-		return HIDUSB::hid_read( (HIDUSB::hid_device*)device, data, length );
-	default:
-		return -1;
-	} 
-}
-
-int  HID_API_EXPORT HID_API_CALL hid_set_nonblocking(hid_device *device, int nonblock)
-{
-	switch ( GetAPIForDevice( device ) )
-	{
-	case k_EHIDAPIRAW:
-		return HIDRAW::hid_set_nonblocking( (HIDRAW::hid_device*)device, nonblock );
-	case k_EHIDAPIUSB:
-		return HIDUSB::hid_set_nonblocking( (HIDUSB::hid_device*)device, nonblock );
-	default:
-		return -1;
-	} 
-}
-
-int HID_API_EXPORT HID_API_CALL hid_send_feature_report(hid_device *device, const unsigned char *data, size_t length)
-{
-	switch ( GetAPIForDevice( device ) )
-	{
-	case k_EHIDAPIRAW:
-		return HIDRAW::hid_send_feature_report( (HIDRAW::hid_device*)device, data, length );
-	case k_EHIDAPIUSB:
-		return HIDUSB::hid_send_feature_report( (HIDUSB::hid_device*)device, data, length );
-	default:
-		return -1;
-	} 
-}
-
-int HID_API_EXPORT HID_API_CALL hid_get_feature_report(hid_device *device, unsigned char *data, size_t length)
-{
-	switch ( GetAPIForDevice( device ) )
-	{
-	case k_EHIDAPIRAW:
-		return HIDRAW::hid_get_feature_report( (HIDRAW::hid_device*)device, data, length );
-	case k_EHIDAPIUSB:
-		return HIDUSB::hid_get_feature_report( (HIDUSB::hid_device*)device, data, length );
-	default:
-		return -1;
-	} 
-}
-
-void HID_API_EXPORT HID_API_CALL hid_close(hid_device *device)
-{
-	switch ( GetAPIForDevice( device ) )
-	{
-	case k_EHIDAPIRAW:
-		HIDRAW::hid_close( (HIDRAW::hid_device*)device );
-		break;
-	case k_EHIDAPIUSB:
-		HIDUSB::hid_close( (HIDUSB::hid_device*)device );
-		break;
-	default:
-		break;
-	} 
-	s_hashDeviceToAPI.Remove( (uintptr_t)device );
-}
-
-int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *device, wchar_t *string, size_t maxlen)
-{
-	switch ( GetAPIForDevice( device ) )
-	{
-	case k_EHIDAPIRAW:
-		return HIDRAW::hid_get_manufacturer_string( (HIDRAW::hid_device*)device, string, maxlen );
-	case k_EHIDAPIUSB:
-		return HIDUSB::hid_get_manufacturer_string( (HIDUSB::hid_device*)device, string, maxlen );
-	default:
-		return -1;
-	} 
-}
-
-int HID_API_EXPORT_CALL hid_get_product_string(hid_device *device, wchar_t *string, size_t maxlen)
-{
-	switch ( GetAPIForDevice( device ) )
-	{
-	case k_EHIDAPIRAW:
-		return HIDRAW::hid_get_product_string( (HIDRAW::hid_device*)device, string, maxlen );
-	case k_EHIDAPIUSB:
-		return HIDUSB::hid_get_product_string( (HIDUSB::hid_device*)device, string, maxlen );
-	default:
-		return -1;
-	}
-}
-
-int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *device, wchar_t *string, size_t maxlen)
-{
-	switch ( GetAPIForDevice( device ) )
-	{
-	case k_EHIDAPIRAW:
-		return HIDRAW::hid_get_serial_number_string( (HIDRAW::hid_device*)device, string, maxlen );
-	case k_EHIDAPIUSB:
-		return HIDUSB::hid_get_serial_number_string( (HIDUSB::hid_device*)device, string, maxlen );
-	default:
-		return -1;
-	}
-}
-
-int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *device, int string_index, wchar_t *string, size_t maxlen)
-{
-	switch ( GetAPIForDevice( device ) )
-	{
-	case k_EHIDAPIRAW:
-		return HIDRAW::hid_get_indexed_string( (HIDRAW::hid_device*)device, string_index, string, maxlen );
-	case k_EHIDAPIUSB:
-		return HIDUSB::hid_get_indexed_string( (HIDUSB::hid_device*)device, string_index, string, maxlen );
-	default:
-		return -1;
-	}
-}
-
-HID_API_EXPORT const wchar_t* HID_API_CALL hid_error(hid_device *device)
-{
-	switch ( GetAPIForDevice( device ) )
-	{
-	case k_EHIDAPIRAW:
-		return HIDRAW::hid_error( (HIDRAW::hid_device*)device );
-	case k_EHIDAPIUSB:
-		return HIDUSB::hid_error( (HIDUSB::hid_device*)device );
-	default:
-		return NULL;
-	} 
-}
-
-}
diff --git a/Engine/lib/sdl/src/hidapi/mac/hid.c b/Engine/lib/sdl/src/hidapi/mac/hid.c
index 70a2fb0d3..a9a85b1f7 100644
--- a/Engine/lib/sdl/src/hidapi/mac/hid.c
+++ b/Engine/lib/sdl/src/hidapi/mac/hid.c
@@ -21,8 +21,6 @@
  ********************************************************/
 #include "../../SDL_internal.h"
 
-#ifdef SDL_JOYSTICK_HIDAPI
-
 /* See Apple Technical Note TN2187 for details on IOHidManager. */
 
 #include <IOKit/hid/IOHIDManager.h>
@@ -33,7 +31,9 @@
 #include <sys/time.h>
 #include <unistd.h>
 
-#include "hidapi.h"
+#include "../hidapi/hidapi.h"
+
+#define VALVE_USB_VID		0x28DE
 
 /* Barrier implementation because Mac OSX doesn't have pthread_barrier.
  It also doesn't have clock_gettime(). So much for POSIX and SUSv2.
@@ -251,12 +251,15 @@ static int get_string_property(IOHIDDeviceRef device, CFStringRef prop, wchar_t
 	
 	if (!len)
 		return 0;
-	
+
+	if (CFGetTypeID(prop) != CFStringGetTypeID())
+		return 0;
+
 	str = (CFStringRef)IOHIDDeviceGetProperty(device, prop);
 	
 	buf[0] = 0;
 	
-	if (str) {
+	if (str && CFGetTypeID(str) == CFStringGetTypeID()) {
 		len --;
 		
 		CFIndex str_len = CFStringGetLength(str);
@@ -288,11 +291,14 @@ static int get_string_property_utf8(IOHIDDeviceRef device, CFStringRef prop, cha
 	if (!len)
 		return 0;
 	
+	if (CFGetTypeID(prop) != CFStringGetTypeID())
+		return 0;
+
 	str = (CFStringRef)IOHIDDeviceGetProperty(device, prop);
 	
 	buf[0] = 0;
 	
-	if (str) {
+	if (str && CFGetTypeID(str) == CFStringGetTypeID()) {
 		len--;
 		
 		CFIndex str_len = CFStringGetLength(str);
@@ -392,20 +398,86 @@ static void hid_device_removal_callback(void *context, IOReturn result,
 	}
 }
 
+static CFDictionaryRef
+create_usage_match(const UInt32 page, const UInt32 usage, int *okay)
+{
+	CFDictionaryRef retval = NULL;
+	CFNumberRef pageNumRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &page);
+	CFNumberRef usageNumRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &usage);
+	const void *keys[2] = { (void *) CFSTR(kIOHIDDeviceUsagePageKey), (void *) CFSTR(kIOHIDDeviceUsageKey) };
+	const void *vals[2] = { (void *) pageNumRef, (void *) usageNumRef };
+
+	if (pageNumRef && usageNumRef) {
+		retval = CFDictionaryCreate(kCFAllocatorDefault, keys, vals, 2, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
+	}
+
+	if (pageNumRef) {
+		CFRelease(pageNumRef);
+	}
+	if (usageNumRef) {
+		CFRelease(usageNumRef);
+	}
+
+	if (!retval) {
+		*okay = 0;
+	}
+
+	return retval;
+}
+
+static CFDictionaryRef
+create_vendor_match(const UInt32 vendor, int *okay)
+{
+	CFDictionaryRef retval = NULL;
+	CFNumberRef vidNumRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &vendor);
+	const void *keys[1] = { (void *) CFSTR(kIOHIDVendorIDKey) };
+	const void *vals[1] = { (void *) vidNumRef };
+
+	if (vidNumRef) {
+		retval = CFDictionaryCreate(kCFAllocatorDefault, keys, vals, 1, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
+		CFRelease(vidNumRef);
+	}
+
+	if (!retval) {
+		*okay = 0;
+	}
+
+	return retval;
+}
+
 /* Initialize the IOHIDManager. Return 0 for success and -1 for failure. */
 static int init_hid_manager(void)
 {
+	int okay = 1;
+	const void *vals[] = {
+		(void *) create_usage_match(kHIDPage_GenericDesktop, kHIDUsage_GD_Joystick, &okay),
+		(void *) create_usage_match(kHIDPage_GenericDesktop, kHIDUsage_GD_GamePad, &okay),
+		(void *) create_usage_match(kHIDPage_GenericDesktop, kHIDUsage_GD_MultiAxisController, &okay),
+		(void *) create_vendor_match(VALVE_USB_VID, &okay),
+	};
+	const size_t numElements = SDL_arraysize(vals);
+	CFArrayRef matchingArray = okay ? CFArrayCreate(kCFAllocatorDefault, vals, numElements, &kCFTypeArrayCallBacks) : NULL;
+	size_t i;
+
+	for (i = 0; i < numElements; i++) {
+		if (vals[i]) {
+			CFRelease((CFTypeRef) vals[i]);
+		}
+	}
 
 	/* Initialize all the HID Manager Objects */
 	hid_mgr = IOHIDManagerCreate(kCFAllocatorDefault, kIOHIDOptionsTypeNone);
 	if (hid_mgr) {
-		IOHIDManagerSetDeviceMatching(hid_mgr, NULL);
+		IOHIDManagerSetDeviceMatchingMultiple(hid_mgr, matchingArray);
 		IOHIDManagerScheduleWithRunLoop(hid_mgr, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
 		IOHIDManagerRegisterDeviceRemovalCallback(hid_mgr, hid_device_removal_callback, NULL);
-		return 0;
 	}
 	
-	return -1;
+	if (matchingArray != NULL) {
+		CFRelease(matchingArray);
+	}
+
+	return hid_mgr ? 0 : -1;
 }
 
 /* Initialize the IOHIDManager if necessary. This is the public function, and
@@ -482,6 +554,17 @@ struct hid_device_info  HID_API_EXPORT *hid_enumerate(unsigned short vendor_id,
 			continue;
 		}
 
+#if 0 // Prefer direct HID support as that has extended functionality
+#if defined(SDL_JOYSTICK_MFI)
+		// We want to prefer Game Controller support where available,
+		// as Apple will likely be requiring that for supported devices.
+		extern SDL_bool IOS_SupportedHIDDevice(IOHIDDeviceRef device);
+		if (IOS_SupportedHIDDevice(dev)) {
+			continue;
+		}
+#endif
+#endif
+
 		dev_vid = get_vendor_id(dev);
 		dev_pid = get_product_id(dev);
 		
@@ -1173,5 +1256,3 @@ int main(void)
 	return 0;
 }
 #endif
-
-#endif /* SDL_JOYSTICK_HIDAPI */
diff --git a/Engine/lib/sdl/src/hidapi/windows/hid.c b/Engine/lib/sdl/src/hidapi/windows/hid.c
index 3965a281b..f0a30c7d1 100644
--- a/Engine/lib/sdl/src/hidapi/windows/hid.c
+++ b/Engine/lib/sdl/src/hidapi/windows/hid.c
@@ -21,10 +21,12 @@
 ********************************************************/
 #include "../../SDL_internal.h"
 
-#ifdef SDL_JOYSTICK_HIDAPI
-
 #include <windows.h>
 
+#ifndef _WIN32_WINNT_WIN8
+#define _WIN32_WINNT_WIN8   0x0602
+#endif
+
 #if 0 /* can cause redefinition errors on some toolchains */
 #ifdef __MINGW32__
 #include <ntdef.h>
@@ -51,7 +53,6 @@ typedef LONG NTSTATUS;
 #define memset SDL_memset
 #define strcmp SDL_strcmp
 #define strlen SDL_strlen
-#define strncpy SDL_strlcpy
 #define strstr SDL_strstr
 #define strtol SDL_strtol
 #define wcscmp SDL_wcscmp
@@ -93,8 +94,8 @@ extern "C" {
 } /* extern "C" */
 #endif
 
-#include <stdio.h>
-#include <stdlib.h>
+/*#include <stdio.h>*/
+/*#include <stdlib.h>*/
 
 
 #include "../hidapi/hidapi.h"
@@ -103,8 +104,8 @@ extern "C" {
 #define MIN(x,y) ((x) < (y)? (x): (y))
 
 #ifdef _MSC_VER
-	/* Thanks Microsoft, but I know how to use strncpy(). */
-	#pragma warning(disable:4996)
+	/* Yes, we have some unreferenced formal parameters */
+	#pragma warning(disable:4100)
 #endif
 
 #ifdef __cplusplus
@@ -176,8 +177,29 @@ struct hid_device_ {
 		char *read_buf;
 		OVERLAPPED ol;
 		OVERLAPPED write_ol;
+		BOOL use_hid_write_output_report;
 };
 
+static BOOL
+IsWindowsVersionOrGreater(WORD wMajorVersion, WORD wMinorVersion, WORD wServicePackMajor)
+{
+	OSVERSIONINFOEXW osvi;
+	DWORDLONG const dwlConditionMask = VerSetConditionMask(
+		VerSetConditionMask(
+			VerSetConditionMask(
+				0, VER_MAJORVERSION, VER_GREATER_EQUAL ),
+			VER_MINORVERSION, VER_GREATER_EQUAL ),
+		VER_SERVICEPACKMAJOR, VER_GREATER_EQUAL );
+
+	memset(&osvi, 0, sizeof(osvi));
+	osvi.dwOSVersionInfoSize = sizeof( osvi );
+	osvi.dwMajorVersion = wMajorVersion;
+	osvi.dwMinorVersion = wMinorVersion;
+	osvi.wServicePackMajor = wServicePackMajor;
+
+	return VerifyVersionInfoW(&osvi, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR, dwlConditionMask) != FALSE;
+}
+
 static hid_device *new_hid_device()
 {
 	hid_device *dev = (hid_device*) calloc(1, sizeof(hid_device));
@@ -242,7 +264,7 @@ static void register_error(hid_device *device, const char *op)
 #ifndef HIDAPI_USE_DDK
 static int lookup_functions()
 {
-	lib_handle = LoadLibraryA("hid.dll");
+	lib_handle = LoadLibrary(TEXT("hid.dll"));
 	if (lib_handle) {
 #define RESOLVE(x) x = (x##_)GetProcAddress(lib_handle, #x); if (!x) return -1;
 		RESOLVE(HidD_GetAttributes);
@@ -321,6 +343,7 @@ int hid_blacklist(unsigned short vendor_id, unsigned short product_id)
         { 0x1532, 0x0109 },  /* Razer Lycosa Gaming keyboard */
         { 0x1532, 0x010B },  /* Razer Arctosa Gaming keyboard */
         { 0x045E, 0x0822 },  /* Microsoft Precision Mouse */
+        { 0x0D8C, 0x0014 },  /* Sharkoon Skiller SGH2 headset */
 
         /* Turns into an Android controller when enumerated... */
         { 0x0738, 0x2217 }   /* SPEEDLINK COMPETITION PRO */
@@ -523,8 +546,7 @@ struct hid_device_info HID_API_EXPORT * HID_API_CALL hid_enumerate(unsigned shor
 			if (str) {
 				len = strlen(str);
 				cur_dev->path = (char*) calloc(len+1, sizeof(char));
-				strncpy(cur_dev->path, str, len+1);
-				cur_dev->path[len] = '\0';
+				memcpy(cur_dev->path, str, len+1);
 			}
 			else
 				cur_dev->path = NULL;
@@ -692,6 +714,11 @@ HID_API_EXPORT hid_device * HID_API_CALL hid_open_path(const char *path, int bEx
 	dev->input_report_length = caps.InputReportByteLength;
 	HidD_FreePreparsedData(pp_data);
 
+	/* On Windows 7, we need to use hid_write_output_report() over Bluetooth */
+	if (dev->output_report_length > 512) {
+		dev->use_hid_write_output_report = !IsWindowsVersionOrGreater( HIBYTE( _WIN32_WINNT_WIN8 ), LOBYTE( _WIN32_WINNT_WIN8 ), 0 );
+	}
+
 	dev->read_buf = (char*) malloc(dev->input_report_length);
 
 	return dev;
@@ -717,17 +744,12 @@ static int hid_write_timeout(hid_device *dev, const unsigned char *data, size_t
 {
 	DWORD bytes_written;
 	BOOL res;
-	size_t stashed_length = length;
 	unsigned char *buf;
 
-#if 1
-	/* If the application is writing to the device, it knows how much data to write.
-	 * This matches the behavior on other platforms. It's also important when writing
-	 * to Sony game controllers over Bluetooth, where there's a CRC at the end which
-	 * must not be tampered with.
-	 */
-	buf = (unsigned char *) data;
-#else
+	if (dev->use_hid_write_output_report) {
+		return hid_write_output_report(dev, data, length);
+	}
+
 	/* Make sure the right number of bytes are passed to WriteFile. Windows
 	   expects the number of bytes which are in the _longest_ report (plus
 	   one for the report number) bytes even if the data is a report
@@ -745,42 +767,35 @@ static int hid_write_timeout(hid_device *dev, const unsigned char *data, size_t
 		memset(buf + length, 0, dev->output_report_length - length);
 		length = dev->output_report_length;
 	}
-#endif
-	if (length > 512)
-	{
-		return hid_write_output_report( dev, data, stashed_length );
-	}
-	else
-	{
-		res = WriteFile( dev->device_handle, buf, ( DWORD ) length, NULL, &dev->write_ol );
-		if (!res) {
-			if (GetLastError() != ERROR_IO_PENDING) {
-				/* WriteFile() failed. Return error. */
-				register_error(dev, "WriteFile");
-				bytes_written = (DWORD) -1;
-				goto end_of_function;
-			}
-		}
 
-		/* Wait here until the write is done. This makes
-		hid_write() synchronous. */
-		res = WaitForSingleObject(dev->write_ol.hEvent, milliseconds);
-		if (res != WAIT_OBJECT_0)
-		{
-			// There was a Timeout.
-			bytes_written = (DWORD) -1;
-			register_error(dev, "WriteFile/WaitForSingleObject Timeout");
-			goto end_of_function;
-		}
-
-		res = GetOverlappedResult(dev->device_handle, &dev->write_ol, &bytes_written, FALSE/*F=don't_wait*/);
-		if (!res) {
-			/* The Write operation failed. */
+	res = WriteFile( dev->device_handle, buf, ( DWORD ) length, NULL, &dev->write_ol );
+	if (!res) {
+		if (GetLastError() != ERROR_IO_PENDING) {
+			/* WriteFile() failed. Return error. */
 			register_error(dev, "WriteFile");
 			bytes_written = (DWORD) -1;
 			goto end_of_function;
 		}
 	}
+
+	/* Wait here until the write is done. This makes hid_write() synchronous. */
+	res = WaitForSingleObject(dev->write_ol.hEvent, milliseconds);
+	if (res != WAIT_OBJECT_0)
+	{
+		// There was a Timeout.
+		bytes_written = (DWORD) -1;
+		register_error(dev, "WriteFile/WaitForSingleObject Timeout");
+		goto end_of_function;
+	}
+
+	res = GetOverlappedResult(dev->device_handle, &dev->write_ol, &bytes_written, FALSE/*F=don't_wait*/);
+	if (!res) {
+		/* The Write operation failed. */
+		register_error(dev, "WriteFile");
+		bytes_written = (DWORD) -1;
+		goto end_of_function;
+	}
+
 end_of_function:
 	if (buf != data)
 		free(buf);
@@ -820,20 +835,19 @@ int HID_API_EXPORT HID_API_CALL hid_read_timeout(hid_device *dev, unsigned char
 		}
 	}
 
-	if (milliseconds >= 0) {
-		/* See if there is any data yet. */
-		res = WaitForSingleObject(ev, milliseconds);
-		if (res != WAIT_OBJECT_0) {
-			/* There was no data this time. Return zero bytes available,
-			   but leave the Overlapped I/O running. */
-			return 0;
-		}
+	/* See if there is any data yet. */
+	res = WaitForSingleObject(ev, milliseconds >= 0 ? milliseconds : INFINITE);
+	if (res != WAIT_OBJECT_0) {
+		/* There was no data this time. Return zero bytes available,
+			but leave the Overlapped I/O running. */
+		return 0;
 	}
 
-	/* Either WaitForSingleObject() told us that ReadFile has completed, or
-	   we are in non-blocking mode. Get the number of bytes read. The actual
-	   data has been copied to the data[] array which was passed to ReadFile(). */
-	res = GetOverlappedResult(dev->device_handle, &dev->ol, &bytes_read, TRUE/*wait*/);
+	/* Get the number of bytes read. The actual data has been copied to the data[]
+	   array which was passed to ReadFile(). We must not wait here because we've
+	   already waited on our event above, and since it's auto-reset, it will have
+	   been reset back to unsignalled by now. */
+	res = GetOverlappedResult(dev->device_handle, &dev->ol, &bytes_read, FALSE/*don't wait*/);
 	
 	/* Set pending back to false, even if GetOverlappedResult() returned error. */
 	dev->read_pending = FALSE;
@@ -932,9 +946,23 @@ int HID_API_EXPORT HID_API_CALL hid_get_feature_report(hid_device *dev, unsigned
 
 void HID_API_EXPORT HID_API_CALL hid_close(hid_device *dev)
 {
+	typedef BOOL (WINAPI *CancelIoEx_t)(HANDLE hFile, LPOVERLAPPED lpOverlapped);
+	CancelIoEx_t CancelIoExFunc = (CancelIoEx_t)GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "CancelIoEx");
+
 	if (!dev)
 		return;
-	CancelIo(dev->device_handle);
+
+	if (CancelIoExFunc) {
+		CancelIoExFunc(dev->device_handle, NULL);
+	} else {
+		/* Windows XP, this will only cancel I/O on the current thread */
+		CancelIo(dev->device_handle);
+	}
+	if (dev->read_pending) {
+		DWORD bytes_read = 0;
+
+		GetOverlappedResult(dev->device_handle, &dev->ol, &bytes_read, TRUE/*wait*/);
+	}
 	free_hid_device(dev);
 }
 
@@ -1064,5 +1092,3 @@ int __cdecl main(int argc, char* argv[])
 #ifdef __cplusplus
 } /* extern "C" */
 #endif
-
-#endif /* SDL_JOYSTICK_HIDAPI */
diff --git a/Engine/lib/sdl/src/joystick/SDL_gamecontroller.c b/Engine/lib/sdl/src/joystick/SDL_gamecontroller.c
index a6674505a..e27922a6d 100644
--- a/Engine/lib/sdl/src/joystick/SDL_gamecontroller.c
+++ b/Engine/lib/sdl/src/joystick/SDL_gamecontroller.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -470,6 +470,10 @@ static int SDLCALL SDL_GameControllerEventWatcher(void *userdata, SDL_Event * ev
  */
 static ControllerMapping_t *SDL_CreateMappingForAndroidController(SDL_JoystickGUID guid)
 {
+    const int face_button_mask = ((1 << SDL_CONTROLLER_BUTTON_A) |
+                                  (1 << SDL_CONTROLLER_BUTTON_B) |
+                                  (1 << SDL_CONTROLLER_BUTTON_X) |
+                                  (1 << SDL_CONTROLLER_BUTTON_Y));
     SDL_bool existing;
     char mapping_string[1024];
     int button_mask;
@@ -481,6 +485,10 @@ static ControllerMapping_t *SDL_CreateMappingForAndroidController(SDL_JoystickGU
         /* Accelerometer, shouldn't have a game controller mapping */
         return NULL;
     }
+    if (!(button_mask & face_button_mask)) {
+        /* We don't know what buttons or axes are supported, don't make up a mapping */
+        return NULL;
+    }
 
     SDL_strlcpy(mapping_string, "none,*,", sizeof(mapping_string));
 
@@ -574,21 +582,16 @@ static ControllerMapping_t *SDL_CreateMappingForHIDAPIController(SDL_JoystickGUI
 
     SDL_GetJoystickGUIDInfo(guid, &vendor, &product, NULL);
 
-    if (vendor == USB_VENDOR_NINTENDO && product == USB_PRODUCT_NINTENDO_GAMECUBE_ADAPTER) {
+    if ((vendor == USB_VENDOR_NINTENDO && product == USB_PRODUCT_NINTENDO_GAMECUBE_ADAPTER) ||
+        (vendor == USB_VENDOR_SHENZHEN && product == USB_PRODUCT_EVORETRO_GAMECUBE_ADAPTER)) {
         /* GameCube driver has 12 buttons and 6 axes */
         SDL_strlcat(mapping_string, "a:b0,b:b1,dpdown:b6,dpleft:b4,dpright:b5,dpup:b7,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b9,righttrigger:a5,rightx:a2,righty:a3,start:b8,x:b2,y:b3,", sizeof(mapping_string));
     } else {
         /* All other controllers have the standard set of 19 buttons and 6 axes */
-        if (!SDL_IsJoystickNintendoSwitchPro(vendor, product) ||
-            SDL_GetHintBoolean(SDL_HINT_GAMECONTROLLER_USE_BUTTON_LABELS, SDL_TRUE)) {
-            SDL_strlcat(mapping_string, "a:b0,b:b1,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b5,leftshoulder:b9,leftstick:b7,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a2,righty:a3,start:b6,x:b2,y:b3,", sizeof(mapping_string));
-        } else {
-            /* Nintendo Switch Pro Controller with swapped face buttons to match Xbox Controller physical layout */
-            SDL_strlcat(mapping_string, "a:b1,b:b0,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b5,leftshoulder:b9,leftstick:b7,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a2,righty:a3,start:b6,x:b3,y:b2,", sizeof(mapping_string));
-        }
+        SDL_strlcat(mapping_string, "a:b0,b:b1,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b5,leftshoulder:b9,leftstick:b7,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a2,righty:a3,start:b6,x:b2,y:b3,", sizeof(mapping_string));
 
-        if (SDL_IsJoystickXboxOneSeriesX(vendor, product)) {
-            /* XBox One Series X Controllers have a share button under the guide button */
+        if (SDL_IsJoystickXboxSeriesX(vendor, product)) {
+            /* XBox Series X Controllers have a share button under the guide button */
             SDL_strlcat(mapping_string, "misc1:b15,", sizeof(mapping_string));
         } else if (SDL_IsJoystickXboxOneElite(vendor, product)) {
             /* XBox One Elite Controllers have 4 back paddle buttons */
@@ -604,13 +607,31 @@ static ControllerMapping_t *SDL_CreateMappingForHIDAPIController(SDL_JoystickGUI
                 break;
             case SDL_CONTROLLER_TYPE_PS5:
                 /* PS5 controllers have a microphone button and an additional touchpad button */
-                SDL_strlcat(mapping_string, "misc1:b15,touchpad:b16", sizeof(mapping_string));
+                SDL_strlcat(mapping_string, "touchpad:b15,misc1:b16", sizeof(mapping_string));
                 break;
             case SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_PRO:
                 /* Nintendo Switch Pro controllers have a screenshot button */
                 SDL_strlcat(mapping_string, "misc1:b15,", sizeof(mapping_string));
+                /* Joy-Cons have extra buttons in the same place as paddles */
+                if (SDL_IsJoystickNintendoSwitchJoyConLeft(vendor, product)) {
+                    SDL_strlcat(mapping_string, "paddle2:b17,paddle4:b19,", sizeof(mapping_string));
+                } else if (SDL_IsJoystickNintendoSwitchJoyConRight(vendor, product)) {
+                    SDL_strlcat(mapping_string, "paddle1:b16,paddle3:b18,", sizeof(mapping_string));
+                }
+                break;
+            case SDL_CONTROLLER_TYPE_AMAZON_LUNA:
+                /* Amazon Luna Controller has a mic button under the guide button */
+                SDL_strlcat(mapping_string, "misc1:b15,", sizeof(mapping_string));
+                break;
+            case SDL_CONTROLLER_TYPE_GOOGLE_STADIA:
+                /* The Google Stadia controller has a share button and a Google Assistant button */
+                SDL_strlcat(mapping_string, "misc1:b15,", sizeof(mapping_string));
                 break;
             default:
+                if (vendor == 0 && product == 0) {
+                    /* This is a Bluetooth Nintendo Switch Pro controller */
+                    SDL_strlcat(mapping_string, "misc1:b15,", sizeof(mapping_string));
+                }
                 break;
             }
         }
@@ -635,6 +656,25 @@ static ControllerMapping_t *SDL_CreateMappingForRAWINPUTController(SDL_JoystickG
                       &existing, SDL_CONTROLLER_MAPPING_PRIORITY_DEFAULT);
 }
 
+/*
+ * Helper function to guess at a mapping for WGI controllers
+ */
+static ControllerMapping_t *SDL_CreateMappingForWGIController(SDL_JoystickGUID guid)
+{
+    SDL_bool existing;
+    char mapping_string[1024];
+
+    if (guid.data[15] != SDL_JOYSTICK_TYPE_GAMECONTROLLER) {
+        return NULL;
+    }
+
+    SDL_strlcpy(mapping_string, "none,*,", sizeof(mapping_string));
+    SDL_strlcat(mapping_string, "a:b0,b:b1,x:b2,y:b3,back:b6,start:b7,leftstick:b8,rightstick:b9,leftshoulder:b4,rightshoulder:b5,dpup:b10,dpdown:b12,dpleft:b13,dpright:b11,leftx:a1,lefty:a0~,rightx:a3,righty:a2~,lefttrigger:a4,righttrigger:a5,", sizeof(mapping_string));
+
+    return SDL_PrivateAddMappingForGUID(guid, mapping_string,
+                      &existing, SDL_CONTROLLER_MAPPING_PRIORITY_DEFAULT);
+}
+
 /*
  * Helper function to scan the mappings database for a controller with the specified GUID
  */
@@ -667,6 +707,9 @@ static ControllerMapping_t *SDL_PrivateGetControllerMappingForGUID(SDL_JoystickG
         if (!mapping && SDL_IsJoystickRAWINPUT(guid)) {
             mapping = SDL_CreateMappingForRAWINPUTController(guid);
         }
+        if (!mapping && SDL_IsJoystickWGI(guid)) {
+            mapping = SDL_CreateMappingForWGIController(guid);
+        }
     }
     return mapping;
 }
@@ -817,7 +860,7 @@ static void SDL_PrivateGameControllerParseElement(SDL_GameController *gamecontro
         invert_input = SDL_TRUE;
     }
 
-    if (szJoystickButton[0] == 'a' && SDL_isdigit(szJoystickButton[1])) {
+    if (szJoystickButton[0] == 'a' && SDL_isdigit((unsigned char) szJoystickButton[1])) {
         bind.inputType = SDL_CONTROLLER_BINDTYPE_AXIS;
         bind.input.axis.axis = SDL_atoi(&szJoystickButton[1]);
         if (half_axis_input == '+') {
@@ -835,11 +878,11 @@ static void SDL_PrivateGameControllerParseElement(SDL_GameController *gamecontro
             bind.input.axis.axis_min = bind.input.axis.axis_max;
             bind.input.axis.axis_max = tmp;
         }
-    } else if (szJoystickButton[0] == 'b' && SDL_isdigit(szJoystickButton[1])) {
+    } else if (szJoystickButton[0] == 'b' && SDL_isdigit((unsigned char) szJoystickButton[1])) {
         bind.inputType = SDL_CONTROLLER_BINDTYPE_BUTTON;
         bind.input.button = SDL_atoi(&szJoystickButton[1]);
-    } else if (szJoystickButton[0] == 'h' && SDL_isdigit(szJoystickButton[1]) &&
-               szJoystickButton[2] == '.' && SDL_isdigit(szJoystickButton[3])) {
+    } else if (szJoystickButton[0] == 'h' && SDL_isdigit((unsigned char) szJoystickButton[1]) &&
+               szJoystickButton[2] == '.' && SDL_isdigit((unsigned char) szJoystickButton[3])) {
         int hat = SDL_atoi(&szJoystickButton[1]);
         int mask = SDL_atoi(&szJoystickButton[3]);
         bind.inputType = SDL_CONTROLLER_BINDTYPE_HAT;
@@ -1139,15 +1182,12 @@ static ControllerMapping_t *SDL_PrivateGetControllerMappingForNameAndGUID(const
             mapping = SDL_PrivateAddMappingForGUID(guid,
 "none,X360 Wireless Controller,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b11,dpright:b12,dpup:b13,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3",
                           &existing, SDL_CONTROLLER_MAPPING_PRIORITY_DEFAULT);
+        } else if (SDL_strstr(name, "Xbox") || SDL_strstr(name, "X-Box") || SDL_strstr(name, "XBOX")) {
+            mapping = s_pXInputMapping;
         }
     }
 #endif /* __LINUX__ */
 
-    if (!mapping && name && !SDL_IsJoystickWGI(guid)) {
-        if (SDL_strstr(name, "Xbox") || SDL_strstr(name, "X-Box") || SDL_strstr(name, "XBOX")) {
-            mapping = s_pXInputMapping;
-        }
-    }
     if (!mapping) {
         mapping = s_pDefaultMapping;
     }
@@ -1475,6 +1515,57 @@ SDL_GameControllerNumMappings(void)
     return num_mappings;
 }
 
+/*
+ * Create a mapping string for a mapping
+ */
+static char *
+CreateMappingString(ControllerMapping_t *mapping, SDL_JoystickGUID guid)
+{
+    char *pMappingString, *pPlatformString;
+    char pchGUID[33];
+    size_t needed;
+    const char *platform = SDL_GetPlatform();
+
+    SDL_JoystickGetGUIDString(guid, pchGUID, sizeof(pchGUID));
+
+    /* allocate enough memory for GUID + ',' + name + ',' + mapping + \0 */
+    needed = SDL_strlen(pchGUID) + 1 + SDL_strlen(mapping->name) + 1 + SDL_strlen(mapping->mapping) + 1;
+
+    if (!SDL_strstr(mapping->mapping, SDL_CONTROLLER_PLATFORM_FIELD)) {
+        /* add memory for ',' + platform:PLATFORM */
+        if (mapping->mapping[SDL_strlen(mapping->mapping) - 1] != ',') {
+            needed += 1;
+        }
+        needed += SDL_strlen(SDL_CONTROLLER_PLATFORM_FIELD) + SDL_strlen(platform);
+    }
+
+    pMappingString = SDL_malloc(needed);
+    if (!pMappingString) {
+        SDL_OutOfMemory();
+        return NULL;
+    }
+
+    SDL_snprintf(pMappingString, needed, "%s,%s,%s", pchGUID, mapping->name, mapping->mapping);
+
+    if (!SDL_strstr(mapping->mapping, SDL_CONTROLLER_PLATFORM_FIELD)) {
+        if (mapping->mapping[SDL_strlen(mapping->mapping) - 1] != ',') {
+            SDL_strlcat(pMappingString, ",", needed);
+        }
+        SDL_strlcat(pMappingString, SDL_CONTROLLER_PLATFORM_FIELD, needed);
+        SDL_strlcat(pMappingString, platform, needed);
+    }
+
+    /* Make sure multiple platform strings haven't made their way into the mapping */
+    pPlatformString = SDL_strstr(pMappingString, SDL_CONTROLLER_PLATFORM_FIELD);
+    if (pPlatformString) {
+        pPlatformString = SDL_strstr(pPlatformString + 1, SDL_CONTROLLER_PLATFORM_FIELD);
+        if (pPlatformString) {
+            *pPlatformString = '\0';
+        }
+    }
+    return pMappingString;
+}
+
 /*
  *  Get the mapping at a particular index.
  */
@@ -1488,20 +1579,7 @@ SDL_GameControllerMappingForIndex(int mapping_index)
             continue;
         }
         if (mapping_index == 0) {
-            char *pMappingString;
-            char pchGUID[33];
-            size_t needed;
-
-            SDL_JoystickGetGUIDString(mapping->guid, pchGUID, sizeof(pchGUID));
-            /* allocate enough memory for GUID + ',' + name + ',' + mapping + \0 */
-            needed = SDL_strlen(pchGUID) + 1 + SDL_strlen(mapping->name) + 1 + SDL_strlen(mapping->mapping) + 1;
-            pMappingString = SDL_malloc(needed);
-            if (!pMappingString) {
-                SDL_OutOfMemory();
-                return NULL;
-            }
-            SDL_snprintf(pMappingString, needed, "%s,%s,%s", pchGUID, mapping->name, mapping->mapping);
-            return pMappingString;
+            return CreateMappingString(mapping, mapping->guid);
         }
         --mapping_index;
     }
@@ -1514,22 +1592,11 @@ SDL_GameControllerMappingForIndex(int mapping_index)
 char *
 SDL_GameControllerMappingForGUID(SDL_JoystickGUID guid)
 {
-    char *pMappingString = NULL;
     ControllerMapping_t *mapping = SDL_PrivateGetControllerMappingForGUID(guid, SDL_FALSE);
     if (mapping) {
-        char pchGUID[33];
-        size_t needed;
-        SDL_JoystickGetGUIDString(guid, pchGUID, sizeof(pchGUID));
-        /* allocate enough memory for GUID + ',' + name + ',' + mapping + \0 */
-        needed = SDL_strlen(pchGUID) + 1 + SDL_strlen(mapping->name) + 1 + SDL_strlen(mapping->mapping) + 1;
-        pMappingString = SDL_malloc(needed);
-        if (!pMappingString) {
-            SDL_OutOfMemory();
-            return NULL;
-        }
-        SDL_snprintf(pMappingString, needed, "%s,%s,%s", pchGUID, mapping->name, mapping->mapping);
+        return CreateMappingString(mapping, guid);
     }
-    return pMappingString;
+    return NULL;
 }
 
 /*
@@ -1753,6 +1820,13 @@ SDL_bool SDL_ShouldIgnoreGameController(const char *name, SDL_JoystickGUID guid)
     }
 #endif
 
+#if defined(__ANDROID__)
+    if (name && SDL_strcmp(name, "uinput-fpc") == 0) {
+        /* The Google Pixel fingerprint sensor reports itself as a joystick */
+        return SDL_TRUE;
+    }
+#endif
+
     if (SDL_allowed_controllers.num_entries == 0 &&
         SDL_ignored_controllers.num_entries == 0) {
         return SDL_FALSE;
@@ -1762,11 +1836,12 @@ SDL_bool SDL_ShouldIgnoreGameController(const char *name, SDL_JoystickGUID guid)
 
     if (SDL_GetHintBoolean("SDL_GAMECONTROLLER_ALLOW_STEAM_VIRTUAL_GAMEPAD", SDL_FALSE)) {
         /* We shouldn't ignore Steam's virtual gamepad since it's using the hints to filter out the real controllers so it can remap input for the virtual controller */
+        /* https://partner.steamgames.com/doc/features/steam_controller/steam_input_gamepad_emulation_bestpractices */
         SDL_bool bSteamVirtualGamepad = SDL_FALSE;
 #if defined(__LINUX__)
-        bSteamVirtualGamepad = (vendor == 0x28DE && product == 0x11FF);
+        bSteamVirtualGamepad = (vendor == USB_VENDOR_VALVE && product == USB_PRODUCT_STEAM_VIRTUAL_GAMEPAD);
 #elif defined(__MACOSX__)
-        bSteamVirtualGamepad = (vendor == 0x045E && product == 0x028E && version == 1);
+        bSteamVirtualGamepad = (vendor == USB_VENDOR_MICROSOFT && product == USB_PRODUCT_XBOX360_WIRED_CONTROLLER && version == 1);
 #elif defined(__WIN32__)
         /* We can't tell on Windows, but Steam will block others in input hooks */
         bSteamVirtualGamepad = SDL_TRUE;
@@ -2158,6 +2233,29 @@ SDL_bool SDL_GameControllerIsSensorEnabled(SDL_GameController *gamecontroller, S
     return SDL_FALSE;
 }
 
+/*
+ *  Get the data rate of a game controller sensor.
+ */
+float
+SDL_GameControllerGetSensorDataRate(SDL_GameController *gamecontroller, SDL_SensorType type)
+{
+    SDL_Joystick *joystick = SDL_GameControllerGetJoystick(gamecontroller);
+    int i;
+
+    if (!joystick) {
+        return 0.0f;
+    }
+
+    for (i = 0; i < joystick->nsensors; ++i) {
+        SDL_JoystickSensorInfo *sensor = &joystick->sensors[i];
+
+        if (sensor->type == type) {
+            return sensor->rate;
+        }
+    }
+    return 0.0f;
+}
+
 /*
  *  Get the current state of a game controller sensor.
  */
@@ -2383,12 +2481,30 @@ SDL_GameControllerHasLED(SDL_GameController *gamecontroller)
     return SDL_JoystickHasLED(SDL_GameControllerGetJoystick(gamecontroller));
 }
 
+SDL_bool
+SDL_GameControllerHasRumble(SDL_GameController *gamecontroller)
+{
+    return SDL_JoystickHasRumble(SDL_GameControllerGetJoystick(gamecontroller));
+}
+
+SDL_bool
+SDL_GameControllerHasRumbleTriggers(SDL_GameController *gamecontroller)
+{
+    return SDL_JoystickHasRumbleTriggers(SDL_GameControllerGetJoystick(gamecontroller));
+}
+
 int
 SDL_GameControllerSetLED(SDL_GameController *gamecontroller, Uint8 red, Uint8 green, Uint8 blue)
 {
     return SDL_JoystickSetLED(SDL_GameControllerGetJoystick(gamecontroller), red, green, blue);
 }
 
+int
+SDL_GameControllerSendEffect(SDL_GameController *gamecontroller, const void *data, int size)
+{
+    return SDL_JoystickSendEffect(SDL_GameControllerGetJoystick(gamecontroller), data, size);
+}
+
 void
 SDL_GameControllerClose(SDL_GameController *gamecontroller)
 {
@@ -2605,4 +2721,26 @@ SDL_GameControllerHandleDelayedGuideButton(SDL_Joystick *joystick)
     }
 }
 
+const char *
+SDL_GameControllerGetAppleSFSymbolsNameForButton(SDL_GameController *gamecontroller, SDL_GameControllerButton button)
+{
+#if defined(SDL_JOYSTICK_MFI)
+    const char *IOS_GameControllerGetAppleSFSymbolsNameForButton(SDL_GameController *gamecontroller, SDL_GameControllerButton button);
+    return IOS_GameControllerGetAppleSFSymbolsNameForButton(gamecontroller, button);
+#else
+    return NULL;
+#endif
+}
+
+const char *
+SDL_GameControllerGetAppleSFSymbolsNameForAxis(SDL_GameController *gamecontroller, SDL_GameControllerAxis axis)
+{
+#if defined(SDL_JOYSTICK_MFI)
+    const char *IOS_GameControllerGetAppleSFSymbolsNameForAxis(SDL_GameController *gamecontroller, SDL_GameControllerAxis axis);
+    return IOS_GameControllerGetAppleSFSymbolsNameForAxis(gamecontroller, axis);
+#else
+    return NULL;
+#endif
+}
+
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/joystick/SDL_gamecontrollerdb.h b/Engine/lib/sdl/src/joystick/SDL_gamecontrollerdb.h
index e032bdede..2aa9ca6e8 100644
--- a/Engine/lib/sdl/src/joystick/SDL_gamecontrollerdb.h
+++ b/Engine/lib/sdl/src/joystick/SDL_gamecontrollerdb.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -26,7 +26,7 @@
    The easiest way to generate a new mapping is to start Steam in Big Picture
    mode, configure your joystick and then look in config/config.vdf in your
    Steam installation directory for the "SDL_GamepadBind" entry.
-   
+
    Alternatively, you can use the app located in test/controllermap
  */
 static const char *s_ControllerMappings [] =
@@ -35,9 +35,14 @@ static const char *s_ControllerMappings [] =
     "xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
 #endif
 #if SDL_JOYSTICK_WGI
+    "03000000491900001904000000007700,Amazon Luna Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b9,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b7,x:b2,y:b3,",
+    "03000000d11800000094000000007700,Google Stadia Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b12,rightshoulder:b5,rightstick:b10,righttrigger:a4,rightx:a2,righty:a3,start:b7,x:b2,y:b3,",
     "030000007e0500000920000000007701,Nintendo Switch Pro Controller,a:b1,b:b0,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b2,hint:SDL_GAMECONTROLLER_USE_BUTTON_LABELS:=1,",
     "030000007e0500000920000000007701,Nintendo Switch Pro Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,hint:!SDL_GAMECONTROLLER_USE_BUTTON_LABELS:=1,",
+    "030000004c050000c405000000007701,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,",
+    "030000004c050000e60c000000007700,PS5 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b14,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,",
     "0300000032150000000a000000007703,Razer Atrox Arcade Stick,a:b0,b:b1,dpdown:b12,dpleft:b13,dpright:b11,dpup:b10,leftshoulder:b4,lefttrigger:b8,rightshoulder:b5,righttrigger:b9,x:b2,y:b3,",
+    "03000000de280000ff11000000007701,Steam Virtual Gamepad,a:b0,b:b1,back:b6,dpdown:b12,dpleft:b13,dpright:b11,dpup:b10,leftshoulder:b4,leftstick:b8,lefttrigger:a4,leftx:a1,lefty:a0~,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a2~,start:b7,x:b2,y:b3,",
 #endif
 #if SDL_JOYSTICK_DINPUT
     "03000000fa2d00000100000000000000,3DRUDDER,leftx:a0,lefty:a1,rightx:a5,righty:a2,",
@@ -95,6 +100,7 @@ static const char *s_ControllerMappings [] =
     "030000006f0e00001901000000000000,Afterglow PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,",
     "030000006f0e00001a01000000000000,Afterglow PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,",
     "03000000d62000001d57000000000000,Airflo PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,",
+    "03000000491900001904000000000000,Amazon Luna Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b9,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b7,x:b2,y:b3,",
     "03000000d62000002a79000000000000,BDA PS4 Fightpad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,",
     "03000000d81d00000b00000000000000,BUFFALO BSGP1601 Series ,a:b5,b:b3,back:b12,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b8,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b9,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b13,x:b4,y:b2,",
     "03000000d6200000e557000000000000,Batarang,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,",
@@ -127,7 +133,9 @@ static const char *s_ControllerMappings [] =
     "030000000d0f00008700000000000000,Fighting Stick mini 4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,",
     "030000000d0f00008800000000000000,Fighting Stick mini 4,a:b1,b:b2,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b8,x:b0,y:b3,",
     "78696e70757403000000000000000000,Fightstick TES,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,lefttrigger:a2,rightshoulder:b5,righttrigger:a5,start:b7,x:b2,y:b3,",
-    "03000000790000000600000000000000,G-Shark GS-GP702,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a4,start:b9,x:b3,y:b0,",
+    "03000000151900004000000000000000,Flydigi Vader 2,a:b11,b:b10,back:b3,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b7,leftstick:b1,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b0,righttrigger:b4,rightx:a3,righty:a4,start:b2,x:b9,y:b8,",
+    "03000000b40400001124000000000000,Flydigi Vader 2,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b12,lefttrigger:b8,leftx:a0,lefty:a1,paddle1:b4,paddle2:b5,paddle4:b17,rightshoulder:b7,rightstick:b13,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b2,y:b3,",
+    "03000000790000000600000000000000,G-Shark GS-GP702,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,",
     "030000008f0e00000d31000000000000,GAMEPAD 3 TURBO,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,",
     "03000000300f00000b01000000000000,GGE909 Recoil Pad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b3,y:b0,",
     "03000000790000002201000000000000,Game Controller for PC,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,",
@@ -146,6 +154,7 @@ static const char *s_ControllerMappings [] =
     "03000000f0250000c383000000000000,Gioteck VX2 Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,",
     "03000000f0250000c483000000000000,Gioteck VX2 Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,",
     "03000000f0250000c283000000000000,Gioteck,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,",
+    "03000000d11800000094000000000000,Google Stadia Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:b12,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:b11,rightx:a3,righty:a4,start:b9,x:b2,y:b3,",
     "03000000632500002605000000000000,HJD-X,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,",
     "030000000d0f00008400000000000000,HORI Fighting Commander,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,",
     "030000000d0f00008500000000000000,HORI Fighting Commander,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,",
@@ -178,6 +187,7 @@ static const char *s_ControllerMappings [] =
     "030000006d04000016c2000000000000,Logitech Dual Action,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,",
     "030000006d04000018c2000000000000,Logitech F510 Gamepad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,",
     "030000006d04000019c2000000000000,Logitech F710 Gamepad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,", /* Guide button doesn't seem to be sent in DInput mode. */
+    "030000006d0400001ac2000000000000,Logitech Precision Gamepad,a:b1,b:b2,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,",
     "03000000380700008081000000000000,MADCATZ SFV Arcade FightStick Alpha PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,",
     "03000000380700006382000000000000,MLG Gamepad PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,",
     "03000000c62400002a89000000000000,MOGA XP5-A Plus,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b15,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,",
@@ -208,6 +218,7 @@ static const char *s_ControllerMappings [] =
     "030000006b140000010c000000000000,NACON GC-400ES,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,",
     "030000001008000001e5000000000000,NEXT SNES Controller,a:b2,b:b1,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b6,start:b9,x:b3,y:b0,",
     "03000000152000000182000000000000,NGDS,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a4,start:b9,x:b3,y:b0,",
+    "030000005509000000b4000000000000,NVIDIA Virtual Gamepad,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:+a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:-a2,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
     "030000004b120000014d000000000000,NYKO AIRFLO EX,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b2,y:b3,",
     "03000000790000004318000000000000,Nintendo GameCube Controller,a:b1,b:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:a4,rightx:a5,righty:a2,start:b9,x:b0,y:b3,hint:SDL_GAMECONTROLLER_USE_BUTTON_LABELS:=1,",
     "03000000790000004318000000000000,Nintendo GameCube Controller,a:b1,b:b0,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:a4,rightx:a5,righty:a2,start:b9,x:b2,y:b3,hint:!SDL_GAMECONTROLLER_USE_BUTTON_LABELS:=1,",
@@ -238,7 +249,7 @@ static const char *s_ControllerMappings [] =
     "030000003807000056a8000000000000,PS3 RF pad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,",
     "03000000100000008200000000000000,PS360+ v1.66,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:h0.4,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,",
     "030000004c050000a00b000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,",
-    "030000004c050000c405000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,",
+    "030000004c050000c405000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,",
     "030000004c050000cc09000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,",
     "030000004c050000e60c000000000000,PS5 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,",
     "030000008f0e00000300000000000000,Piranha xtreme,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a3,righty:a2,start:b9,x:b3,y:b0,",
@@ -256,6 +267,12 @@ static const char *s_ControllerMappings [] =
     "030000000d0f00001100000000000000,REAL ARCADE PRO.3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,rightshoulder:b5,rightstick:b11,righttrigger:b7,start:b9,x:b0,y:b3,",
     "030000000d0f00007000000000000000,REAL ARCADE PRO.4 VLX,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,rightshoulder:b5,rightstick:b11,righttrigger:b7,start:b9,x:b0,y:b3,",
     "030000000d0f00002200000000000000,REAL ARCADE Pro.V3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,",
+    "03000000050b00005819000000000000,ROG Chakram Core,a:b1,b:b0,leftx:a0,lefty:a1,x:b2,y:b3,",
+    "03000000050b0000181a000000000000,ROG Chakram X,a:b1,b:b0,leftx:a0,lefty:a1,x:b2,y:b3,",
+    "03000000050b00001a1a000000000000,ROG Chakram X,a:b1,b:b0,leftx:a0,lefty:a1,x:b2,y:b3,",
+    "03000000050b00001c1a000000000000,ROG Chakram X,a:b1,b:b0,leftx:a0,lefty:a1,x:b2,y:b3,",
+    "03000000050b0000e318000000000000,ROG Chakram,a:b1,b:b0,leftx:a0,lefty:a1,x:b2,y:b3,",
+    "03000000050b0000e518000000000000,ROG Chakram,a:b1,b:b0,leftx:a0,lefty:a1,x:b2,y:b3,",
     "03000000321500000003000000000000,Razer Hydra,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a2,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
     "03000000321500000204000000000000,Razer Panthera (PS3),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,",
     "03000000321500000104000000000000,Razer Panthera (PS4),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,",
@@ -297,7 +314,7 @@ static const char *s_ControllerMappings [] =
     "030000009b2800000500000000000000,Saturn_Adapter_2.0,a:b1,b:b2,leftshoulder:b6,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b5,start:b9,x:b0,y:b3,",
     "030000008f0e00000800000000000000,SpeedLink Strike FX,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,",
     "03000000c01100000591000000000000,Speedlink Torid,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,",
-    "03000000d11800000094000000000000,Stadia Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:b12,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:b11,rightx:a3,righty:a4,start:b9,x:b2,y:b3,",
+    "03000000de280000ff11000000000000,Steam Virtual Gamepad,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:+a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:-a2,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
     "03000000110100003114000000000000,SteelSeries Stratus Duo,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,",
     "03000000381000001814000000000000,SteelSeries Stratus XL,a:b0,b:b1,back:b18,dpdown:b13,dpleft:b14,dpright:b15,dpup:b12,guide:b19,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b2,y:b3,",
     "03000000110100001914000000000000,SteelSeries,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:,leftstick:b13,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:,rightstick:b14,righttrigger:b7,rightx:a3,righty:a4,start:b11,x:b3,y:b4,",
@@ -317,7 +334,6 @@ static const char *s_ControllerMappings [] =
     "03000000d90400000200000000000000,TwinShock PS2,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a3,righty:a2,start:b9,x:b3,y:b0,",
     "03000000300f00000701000000000000,USB 4-Axis 12-Button Gamepad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b3,y:b0,",
     "03000000341a00002308000000000000,USB Gamepad,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,",
-    "030000005509000000b4000000000000,USB Gamepad,a:b10,b:b11,back:b5,dpdown:b1,dpleft:b2,dpright:b3,dpup:b0,guide:b14,leftshoulder:b8,leftstick:b6,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b9,rightstick:b7,righttrigger:a5,rightx:a2,righty:a3,start:b4,x:b12,y:b13,",
     "030000006b1400000203000000000000,USB Gamepad,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,",
     "03000000790000000a00000000000000,USB Gamepad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a4,start:b9,x:b3,y:b0,",
     "03000000f0250000c183000000000000,USB Gamepad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,",
@@ -375,6 +391,8 @@ static const char *s_ControllerMappings [] =
     "03000000a00500003232000008010000,8BitDo Zero Gamepad,a:b1,b:b2,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b4,y:b3,hint:!SDL_GAMECONTROLLER_USE_BUTTON_LABELS:=1,",
     "03000000a00500003232000009010000,8BitDo Zero Gamepad,a:b0,b:b1,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b3,y:b4,hint:SDL_GAMECONTROLLER_USE_BUTTON_LABELS:=1,",
     "03000000a00500003232000009010000,8BitDo Zero Gamepad,a:b1,b:b0,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b4,y:b3,hint:!SDL_GAMECONTROLLER_USE_BUTTON_LABELS:=1,",
+    "03000000491900001904000001010000,Amazon Luna Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b9,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b7,x:b2,y:b3,",
+    "03000000710100001904000000010000,Amazon Luna Controller,a:b0,b:b1,back:b11,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b7,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b9,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a3,start:b6,x:b2,y:b3,",
     "03000000c62400001a89000000010000,BDA MOGA XP5-X Plus,a:b0,b:b1,back:b12,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b14,leftshoulder:b6,leftstick:b15,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b16,righttrigger:a4,rightx:a2,righty:a3,start:b13,x:b3,y:b4,",
     "03000000c62400001b89000000010000,BDA MOGA XP5-X Plus,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,",
     "03000000d62000002a79000000010000,BDA PS4 Fightpad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,",
@@ -383,10 +401,13 @@ static const char *s_ControllerMappings [] =
     "03000000a306000022f6000001030000,Cyborg V.3 Rumble Pad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:+a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:-a3,rightx:a2,righty:a4,start:b9,x:b0,y:b3,",
     "030000000d0f00008400000000010000,Fighting Commander,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,",
     "030000000d0f00008500000000010000,Fighting Commander,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,",
-    "03000000790000000600000000000000,G-Shark GP-702,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a4,start:b9,x:b3,y:b0,",
+    "03000000151900004000000001000000,Flydigi Vader 2,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a3,start:b9,x:b2,y:b3,",
+    "03000000b40400001124000000000000,Flydigi Vader 2,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b12,lefttrigger:b8,leftx:a0,lefty:a1,paddle1:b4,paddle2:b5,paddle3:b17,rightshoulder:b7,rightstick:b13,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b2,y:b3,",
+    "03000000790000000600000000000000,G-Shark GS-GP702,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,",
     "0500000047532047616d657061640000,GameStop Gamepad,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,",
     "03000000c01100000140000000010000,GameStop PS4 Fun Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,",
     "03000000ad1b000001f9000000000000,Gamestop BB-070 X360 Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,",
+    "03000000d11800000094000000010000,Google Stadia Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a4,rightx:a2,righty:a3,start:b7,x:b2,y:b3,",
     "030000000d0f00005f00000000000000,HORI Fighting Commander 4 PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,",
     "030000000d0f00005e00000000000000,HORI Fighting Commander 4 PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,",
     "030000000d0f00004d00000000000000,HORI Gem Pad 3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,",
@@ -445,8 +466,8 @@ static const char *s_ControllerMappings [] =
     "03000000811700007e05000000000000,Sega Saturn,a:b2,b:b4,dpdown:b16,dpleft:b15,dpright:b14,dpup:b17,leftshoulder:b8,lefttrigger:a5,leftx:a0,lefty:a2,rightshoulder:b9,righttrigger:a4,start:b13,x:b0,y:b6,",
     "030000004c050000cc09000000000000,Sony DualShock 4 V2,a:b1,b:b2,back:b13,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,",
     "030000004c050000a00b000000000000,Sony DualShock 4 Wireless Adaptor,a:b1,b:b2,back:b13,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,",
-    "03000000d11800000094000000010000,Stadia Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a4,rightx:a2,righty:a3,start:b7,x:b2,y:b3,",
     "030000005e0400008e02000001000000,Steam Virtual Gamepad,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,",
+    "050000004e696d6275732b0000000000,SteelSeries Nimbus+,a:b0,b:b1,back:b15,dpdown:b11,dpleft:b13,dpright:b12,dpup:b10,guide:b16,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1~,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a2,righty:a3~,start:b14,x:b2,y:b3,",
     "03000000110100002014000000000000,SteelSeries Nimbus,a:b0,b:b1,dpdown:b9,dpleft:b11,dpright:b10,dpup:b8,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b12,x:b2,y:b3,",
     "03000000110100002014000001000000,SteelSeries Nimbus,a:b0,b:b1,dpdown:b9,dpleft:b11,dpright:b10,dpup:b8,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1~,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3~,x:b2,y:b3,",
     "03000000381000002014000001000000,SteelSeries Nimbus,a:b0,b:b1,dpdown:b9,dpleft:b11,dpright:b10,dpup:b8,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1~,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3~,x:b2,y:b3,",
@@ -468,6 +489,7 @@ static const char *s_ControllerMappings [] =
     "030000005e040000d102000000000000,Xbox One Wired Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,",
     "030000005e040000dd02000000000000,Xbox One Wired Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,",
     "030000005e040000e302000000000000,Xbox One Wired Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,",
+    "030000005e040000200b000011050000,Xbox Wireless Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,",
     "030000005e040000e002000000000000,Xbox Wireless Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
     "030000005e040000e002000003090000,Xbox Wireless Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
     "030000005e040000ea02000000000000,Xbox Wireless Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,",
@@ -480,6 +502,7 @@ static const char *s_ControllerMappings [] =
     "03000000830500006020000000000000,iBuffalo USB 2-axis 8-button Gamepad,a:b1,b:b0,back:b6,leftshoulder:b4,leftx:a0,lefty:a1,rightshoulder:b5,start:b7,x:b3,y:b2,",
 #endif
 #if defined(__LINUX__)
+    "xinput,*,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
     "03000000c82d00000090000011010000,8BitDo FC30 Pro,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a5,rightx:a2,righty:a3,start:b11,x:b3,y:b4,hint:SDL_GAMECONTROLLER_USE_BUTTON_LABELS:=1,",
     "03000000c82d00000090000011010000,8BitDo FC30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a5,rightx:a2,righty:a3,start:b11,x:b4,y:b3,hint:!SDL_GAMECONTROLLER_USE_BUTTON_LABELS:=1,",
     "05000000c82d00001038000000010000,8BitDo FC30 Pro,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,hint:SDL_GAMECONTROLLER_USE_BUTTON_LABELS:=1,",
@@ -524,6 +547,7 @@ static const char *s_ControllerMappings [] =
     "05000000a00500003232000001000000,8BitDo Zero Gamepad,a:b1,b:b0,back:b10,dpdown:b122,dpleft:b119,dpright:b120,dpup:b117,leftshoulder:b6,rightshoulder:b7,start:b11,x:b4,y:b3,hint:!SDL_GAMECONTROLLER_USE_BUTTON_LABELS:=1,",
     "05000000a00500003232000008010000,8BitDo Zero Gamepad,a:b0,b:b1,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b3,y:b4,hint:SDL_GAMECONTROLLER_USE_BUTTON_LABELS:=1,",
     "05000000a00500003232000008010000,8BitDo Zero Gamepad,a:b1,b:b0,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b4,y:b3,hint:!SDL_GAMECONTROLLER_USE_BUTTON_LABELS:=1,",
+    "03000000c82d00000031000011010000,8Bitdo Receiver,a:b1,b:b0,back:b10,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b11,x:b4,y:b3,",
     "03000000c82d00001290000011010000,8Bitdo SN30 Gamepad,a:b0,b:b1,back:b10,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b11,x:b3,y:b4,hint:SDL_GAMECONTROLLER_USE_BUTTON_LABELS:=1,",
     "03000000c82d00001290000011010000,8Bitdo SN30 Gamepad,a:b1,b:b0,back:b10,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b11,x:b4,y:b3,hint:!SDL_GAMECONTROLLER_USE_BUTTON_LABELS:=1,",
     "05000000c82d00006228000000010000,8Bitdo SN30 Gamepad,a:b0,b:b1,back:b10,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b11,x:b3,y:b4,hint:SDL_GAMECONTROLLER_USE_BUTTON_LABELS:=1,",
@@ -535,9 +559,17 @@ static const char *s_ControllerMappings [] =
     "030000006f0e00001302000000010000,Afterglow,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
     "03000000100000008200000011010000,Akishop Customs PS360+ v1.66,a:b1,b:b2,back:b12,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,",
     "05000000491900000204000021000000,Amazon Fire Game Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b17,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b12,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,",
+    "03000000491900001904000011010000,Amazon Luna Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b9,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b7,x:b2,y:b3,",
+    "05000000710100001904000000010000,Amazon Luna Controller,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b7,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b11,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a3,start:b6,x:b2,y:b3,",
     "03000000790000003018000011010000,Arcade Fightstick F300,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,",
+    "03000000503200000110000000000000,Atari Classic Controller,a:b0,back:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b4,start:b3,x:b1,",
+    "05000000503200000110000000000000,Atari Classic Controller,a:b0,back:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b4,start:b3,x:b1,",
+    "03000000503200000210000000000000,Atari Game Controller,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a4,rightx:a2,righty:a3,start:b8,x:b2,y:b3,",
+    "05000000503200000210000000000000,Atari Game Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b3,y:b2,",
+    "030000005e0400008e02000047010000,Atari Xbox 360 Game Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
     "03000000c62400001b89000011010000,BDA MOGA XP5-X Plus,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,",
     "03000000d62000002a79000011010000,BDA PS4 Fightpad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,",
+    "03000000120c0000f70e000011010000,Brook Universal Fighting Board,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:,lefty:,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:,righty:,start:b9,x:b0,y:b3,",
     "03000000b40400000a01000000010000,CYPRESS USB Gamepad,a:b0,b:b1,back:b5,guide:b2,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b8,x:b3,y:b4,",
     "03000000ffff0000ffff000000010000,Chinese-made Xbox Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b2,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b3,y:b4,",
     "03000000e82000006058000001010000,Cideko AK08b,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,",
@@ -545,6 +577,8 @@ static const char *s_ControllerMappings [] =
     "03000000a306000022f6000011010000,Cyborg V.3 Rumble Pad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:+a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:-a3,rightx:a2,righty:a4,start:b9,x:b0,y:b3,",
     "03000000790000000600000010010000,DragonRise Inc. Generic USB Joystick,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a4,start:b9,x:b3,y:b0,",
     "030000006f0e00003001000001010000,EA Sports PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,",
+    "03000000b40400001124000011010000,Flydigi Vader 2,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b12,lefttrigger:a5,leftx:a0,lefty:a1,paddle1:b2,paddle2:b5,paddle4:b17,rightshoulder:b7,rightstick:b13,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,",
+    "05000000151900004000000001000000,Flydigi Vader 2,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a3,start:b9,x:b2,y:b3,",
     "0300000079000000d418000000010000,GPD Win 2 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
     "0500000047532067616d657061640000,GS Gamepad,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,",
     "03000000341a000005f7000010010000,GameCube {HuiJia USB box},a:b1,b:b2,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:a4,rightx:a5,righty:a2,start:b9,x:b0,y:b3,",
@@ -555,6 +589,7 @@ static const char *s_ControllerMappings [] =
     "030000008f0e00000800000010010000,Gasia Co. Ltd PS(R) Gamepad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,",
     "030000006f0e00001304000000010000,Generic X-Box pad,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
     "03000000f0250000c183000010010000,Goodbetterbest Ltd USB Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,",
+    "03000000d11800000094000011010000,Google Stadia Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a4,rightx:a2,righty:a3,start:b7,x:b2,y:b3,",
     "03000000280400000140000000010000,Gravis Gamepad Pro USB ,a:b1,b:b2,back:b8,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,",
     "030000008f0e00000610000000010000,GreenAsia Electronics 4Axes 12Keys Gamepad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b9,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b10,righttrigger:b5,rightx:a3,righty:a2,start:b11,x:b3,y:b0,",
     "030000008f0e00001200000010010000,GreenAsia Inc. USB Joystick,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b2,y:b3,",
@@ -563,6 +598,7 @@ static const char *s_ControllerMappings [] =
     "030000000d0f00002200000011010000,HORI CO. LTD. REAL ARCADE Pro.V3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,",
     "030000000d0f00006a00000011010000,HORI CO. LTD. Real Arcade Pro.4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,",
     "030000000d0f00006b00000011010000,HORI CO. LTD. Real Arcade Pro.4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,",
+    "030000000d0f00005001000009040000,HORI Fighting Commander OCTA,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
     "030000000d0f00008400000011010000,HORI Fighting Commander,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,",
     "030000000d0f00008500000010010000,HORI Fighting Commander,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,",
     "030000000d0f0000d800000072056800,HORI Real Arcade Pro S,a:b0,b:b1,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b5,leftshoulder:b9,leftstick:b7,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a2,righty:a3,start:b6,x:b2,y:b3,",
@@ -580,6 +616,7 @@ static const char *s_ControllerMappings [] =
     "03000000242e00008816000001010000,Hyperkin X91,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
     "03000000d80400008200000003000000,IMS PCU#0 Gamepad Interface,a:b1,b:b0,back:b4,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,start:b5,x:b3,y:b2,",
     "03000000fd0500000030000000010000,InterAct GoPad I-73000 (Fighting Game Layout),a:b3,b:b4,back:b6,leftx:a0,lefty:a1,rightshoulder:b2,righttrigger:b5,start:b7,x:b0,y:b1,",
+    "05000000491900000204000000000000,Ipega PG-9087S,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b3,y:b4,",
     "030000006e0500000320000010010000,JC-U3613M - DirectInput Mode,a:b2,b:b3,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a2,righty:a3,start:b11,x:b0,y:b1,",
     "03000000300f00001001000010010000,Jess Tech Dual Analog Rumble Pad,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b0,y:b1,",
     "03000000ba2200002010000001010000,Jess Technology USB Game Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b3,y:b0,",
@@ -619,6 +656,7 @@ static const char *s_ControllerMappings [] =
     "030000005e040000d102000001010000,Microsoft X-Box One pad,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
     "030000005e0400008502000000010000,Microsoft X-Box pad (Japan),a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b2,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b3,y:b4,",
     "030000005e0400008902000021010000,Microsoft X-Box pad v2 (US),a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b2,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b3,y:b4,",
+    "030000005e0400008902000020010000,Microsoft Xbox Controller S,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b2,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b3,y:b4,",
     "05000000d6200000ad0d000001000000,Moga Pro,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b7,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a3,start:b6,x:b2,y:b3,",
     "030000006b140000010c000010010000,NACON GC-400ES,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,",
     "030000001008000001e5000010010000,NEXT SNES Controller,a:b2,b:b1,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b6,start:b9,x:b3,y:b0,",
@@ -665,9 +703,13 @@ static const char *s_ControllerMappings [] =
     "050000004c050000cc09000000010000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,",
     "050000004c050000cc09000000810000,PS4 Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:a5,rightx:a3,righty:a4,start:b9,x:b3,y:b2,",
     "050000004c050000cc09000001800000,PS4 Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:a5,rightx:a3,righty:a4,start:b9,x:b3,y:b2,",
+    "030000004c050000e60c000000010000,PS5 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,",
     "030000004c050000e60c000011010000,PS5 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,",
+    "030000004c050000e60c000011810000,PS5 Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:a5,rightx:a3,righty:a4,start:b9,x:b3,y:b2,",
     "050000004c050000e60c000000010000,PS5 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,",
+    "050000004c050000e60c000000810000,PS5 Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:a5,rightx:a3,righty:a4,start:b9,x:b3,y:b2,",
     "030000004c050000da0c000011010000,Playstation Controller,a:b2,b:b1,back:b8,leftshoulder:b6,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b5,start:b9,x:b3,y:b0,",
+    "03000000c62400003a54000001010000,PowerA XBox One Controller,a:b0,b:b1,back:b6,dpdown:h0.7,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
     "03000000c62400000053000000010000,PowerA,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
     "03000000300f00001211000011010000,QanBa Arcade JoyStick,a:b2,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b5,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b6,start:b9,x:b1,y:b3,",
     "030000008916000001fd000024010000,Razer Onza Classic Edition,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b11,dpright:b12,dpup:b13,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
@@ -705,7 +747,6 @@ static const char *s_ControllerMappings [] =
     "03000000250900000500000000010000,Sony PS2 pad with SmartJoy adapter,a:b2,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a2,righty:a3,start:b8,x:b3,y:b0,",
     "030000005e0400008e02000020200000,SpeedLink XEOX Pro Analog Gamepad pad,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
     "030000005e0400008e02000073050000,Speedlink TORID Wireless Gamepad,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
-    "03000000d11800000094000011010000,Stadia Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a4,rightx:a2,righty:a3,start:b7,x:b2,y:b3,",
     "03000000de2800000112000001000000,Steam Controller,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,paddle1:b11,paddle2:b10,rightshoulder:b5,righttrigger:a3,start:b7,x:b2,y:b3,",
     "03000000de2800000211000001000000,Steam Controller,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,paddle1:b11,paddle2:b10,rightshoulder:b5,righttrigger:a3,start:b7,x:b2,y:b3,",
     "03000000de2800004211000001000000,Steam Controller,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,paddle1:b11,paddle2:b10,rightshoulder:b5,righttrigger:a3,start:b7,x:b2,y:b3,",
@@ -742,16 +783,17 @@ static const char *s_ControllerMappings [] =
     "030000005e040000a102000000010000,X360 Wireless Controller,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b11,dpright:b12,dpup:b13,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
     "030000005e040000a102000007010000,X360 Wireless Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
     "03000000450c00002043000010010000,XEOX Gamepad SL-6556-BK,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,",
-    "xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
     "0000000058626f782033363020576900,Xbox 360 Wireless Controller,a:b0,b:b1,back:b14,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,guide:b7,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b6,x:b2,y:b3,",
     "030000005e040000a102000014010000,Xbox 360 Wireless Receiver (XBOX),a:b0,b:b1,back:b6,dpdown:b14,dpleft:b11,dpright:b12,dpup:b13,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
     "0000000058626f782047616d65706100,Xbox Gamepad (userspace driver),a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a4,rightx:a2,righty:a3,start:b7,x:b2,y:b3,",
     "050000005e040000050b000002090000,Xbox One Elite Series 2,a:b0,b:b1,back:b136,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a6,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a5,rightx:a2,righty:a3,start:b11,x:b3,y:b4,",
     "050000005e040000050b000003090000,Xbox One Elite Series 2,a:b0,b:b1,back:b121,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,",
+    "050000005e040000e302000002090000,Xbox One Elite,a:b0,b:b1,back:b136,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a6,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a5,rightx:a2,righty:a3,start:b11,x:b3,y:b4,",
     "030000005e040000ea02000000000000,Xbox One Wireless Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
     "030000005e040000ea02000001030000,Xbox One Wireless Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
     "050000005e040000e002000003090000,Xbox One Wireless Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
     "050000005e040000fd02000003090000,Xbox One Wireless Controller,a:b0,b:b1,back:b15,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,guide:b16,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,",
+    "050000005e040000130b000011050000,Xbox Series X Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b15,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,",
     "05000000172700004431000029010000,XiaoMi Game Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b20,leftshoulder:b6,leftstick:b13,lefttrigger:a7,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a6,rightx:a2,righty:a5,start:b11,x:b3,y:b4,",
     "03000000c0160000e105000001010000,Xin-Mo Xin-Mo Dual Arcade,a:b4,b:b3,back:b6,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b9,leftshoulder:b2,leftx:a0,lefty:a1,rightshoulder:b5,start:b7,x:b1,y:b0,",
     "03000000120c0000100e000011010000,ZEROPLUS P4 Gamepad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,",
@@ -797,6 +839,7 @@ static const char *s_ControllerMappings [] =
     "05000000c82d000018900000ffff0f00,8BitDo Zero 2,a:b1,b:b0,back:b4,leftshoulder:b9,leftx:a0,lefty:a1,rightshoulder:b10,start:b6,x:b3,y:b2,hint:!SDL_GAMECONTROLLER_USE_BUTTON_LABELS:=1,",
     "05000000c82d000030320000ffff0f00,8BitDo Zero 2,a:b0,b:b1,back:b4,leftshoulder:b9,leftx:a0,lefty:a1,rightshoulder:b10,start:b6,x:b2,y:b3,hint:SDL_GAMECONTROLLER_USE_BUTTON_LABELS:=1,",
     "05000000c82d000030320000ffff0f00,8BitDo Zero 2,a:b1,b:b0,back:b4,leftshoulder:b9,leftx:a0,lefty:a1,rightshoulder:b10,start:b6,x:b3,y:b2,hint:!SDL_GAMECONTROLLER_USE_BUTTON_LABELS:=1,",
+    "05000000b404000011240000dfff3f00,Flydigi Vader 2,a:b0,b:b1,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,leftshoulder:b9,leftstick:b7,lefttrigger:a4,leftx:a0,lefty:a1,paddle1:b17,paddle2:b18,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a2,righty:a3,start:b6,x:b2,y:b3,",
     "05000000d6020000e5890000dfff3f00,GPD XD Plus,a:b0,b:b1,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,leftshoulder:b9,leftstick:b7,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a4,rightx:a2,righty:a5,start:b6,x:b2,y:b3,",
     "0500000031366332860c44aadfff0f00,GS Gamepad,a:b0,b:b1,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,leftshoulder:b9,leftstick:b7,lefttrigger:b15,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:b16,rightx:a2,righty:a3,start:b6,x:b2,y:b3,",
     "05000000bc20000000550000ffff3f00,GameSir G3w,a:b0,b:b1,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,leftshoulder:b9,leftstick:b7,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a4,rightx:a2,righty:a3,start:b6,x:b2,y:b3,",
@@ -807,6 +850,7 @@ static const char *s_ControllerMappings [] =
     "050000007e05000009200000ffff0f00,Nintendo Switch Pro Controller,a:b0,b:b1,back:b15,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b5,leftshoulder:b3,leftstick:b4,lefttrigger:b9,leftx:a0,lefty:a1,rightshoulder:b18,rightstick:b6,righttrigger:b10,rightx:a2,righty:a3,start:b16,x:b17,y:b2,sdk<=:28,", /* Extremely slow in Bluetooth mode on Android */
     "050000004c05000068020000dfff3f00,PS3 Controller,a:b0,b:b1,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,leftshoulder:b9,leftstick:b7,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a2,righty:a3,start:b6,x:b2,y:b3,",
     "030000004c050000cc09000000006800,PS4 Controller,a:b0,b:b1,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b5,leftshoulder:b9,leftstick:b7,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a2,righty:a3,start:b6,x:b2,y:b3,",
+    "050000004c050000c405000000783f00,PS4 Controller,a:b0,b:b1,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b5,leftshoulder:b9,leftstick:b7,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a2,righty:a3,start:b6,x:b2,y:b3,",
     "050000004c050000c4050000fffe3f00,PS4 Controller,a:b1,b:b17,back:b15,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b5,leftshoulder:b3,leftstick:b4,lefttrigger:+a3,leftx:a0,lefty:a1,rightshoulder:b18,rightstick:b6,righttrigger:+a4,rightx:a2,righty:a5,start:b16,x:b0,y:b2,",
     "050000004c050000c4050000ffff3f00,PS4 Controller,a:b0,b:b1,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b5,leftshoulder:b9,leftstick:b7,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a2,righty:a3,start:b6,x:b2,y:b3,",
     "050000004c050000cc090000fffe3f00,PS4 Controller,a:b1,b:b17,back:b15,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b5,leftshoulder:b3,leftstick:b4,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b18,rightstick:b6,righttrigger:a4,rightx:a2,righty:a5,start:b16,x:b0,y:b2,",
@@ -817,10 +861,15 @@ static const char *s_ControllerMappings [] =
     "050000003215000007070000ffff3f00,Razer Raiju Mobile,a:b0,b:b1,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,leftshoulder:b9,leftstick:b7,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a2,righty:a3,start:b6,x:b2,y:b3,",
     "050000003215000000090000bf7f3f00,Razer Serval,a:b0,b:b1,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b5,leftshoulder:b9,leftstick:b7,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a2,righty:a3,x:b2,y:b3,",
     "050000004f0400000ed00000fffe3f00,ThrustMaster eSwap PRO Controller,a:b0,b:b1,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,leftshoulder:b9,leftstick:b7,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b10,righttrigger:a5,rightx:a2,righty:a3,start:b6,x:b2,y:b3,",
+    "050000005e0400008e02000000783f00,Xbox 360 Controller,a:b0,b:b1,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b5,leftshoulder:b9,leftstick:b7,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a2,righty:a3,start:b6,x:b2,y:b3,",
+    "050000005e040000000b000000783f00,Xbox One Elite 2 Controller,a:b0,b:b1,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b5,leftshoulder:b9,leftstick:b7,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a3,righty:a4,start:b6,x:b2,y:b3,",
+    "050000005e040000e002000000783f00,Xbox One S Controller,a:b0,b:b1,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b5,leftshoulder:b9,leftstick:b7,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a2,righty:a3,start:b6,x:b2,y:b3,",
+    "050000005e040000ea02000000783f00,Xbox One S Controller,a:b0,b:b1,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b5,leftshoulder:b9,leftstick:b7,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a2,righty:a3,start:b6,x:b2,y:b3,",
     "050000005e040000fd020000ff7f3f00,Xbox One S Controller,a:b0,b:b1,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b5,leftshoulder:b9,leftstick:b7,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a2,righty:a3,start:b6,x:b2,y:b3,",
-    "050000005e040000130b0000ffff3f00,Xbox One Series X Controller,a:b0,b:b1,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b5,leftshoulder:b9,leftstick:b7,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a2,righty:a3,start:b6,x:b2,y:b3,",
     "050000005e040000e00200000ffe3f00,Xbox One Wireless Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,leftshoulder:b3,leftstick:b15,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b18,rightstick:b16,righttrigger:a5,rightx:a3,righty:a4,start:b10,x:b17,y:b2,",
     "050000005e040000fd020000ffff3f00,Xbox One Wireless Controller,a:b0,b:b1,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b5,leftshoulder:b9,leftstick:b7,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a2,righty:a3,start:b6,x:b2,y:b3,",
+    "050000005e040000120b000000783f00,Xbox Series X Controller,a:b0,b:b1,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b5,leftshoulder:b9,leftstick:b7,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a3,righty:a4,start:b6,x:b2,y:b3,",
+    "050000005e040000130b0000ffff3f00,Xbox Series X Controller,a:b0,b:b1,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b5,leftshoulder:b9,leftstick:b7,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a2,righty:a3,start:b6,x:b2,y:b3,",
     "050000005e04000091020000ff073f00,Xbox Wireless Controller,a:b0,b:b1,back:b4,guide:b5,leftshoulder:b9,leftstick:b7,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a3,righty:a4,start:b6,x:b2,y:b3,", /* The DPAD doesn't seem to work on this controller on Android TV? */
     "050000001727000044310000ffff3f00,XiaoMi Game Controller,a:b0,b:b1,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,leftshoulder:b9,leftstick:b7,lefttrigger:a7,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a6,rightx:a2,righty:a5,start:b6,x:b2,y:b3,",
     "0500000083050000602000000ffe0000,iBuffalo SNES Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,leftshoulder:b15,rightshoulder:b16,start:b10,x:b2,y:b3,hint:SDL_GAMECONTROLLER_USE_BUTTON_LABELS:=1,",
@@ -833,10 +882,16 @@ static const char *s_ControllerMappings [] =
     "05000000ac05000001000000ff076d01,*,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b9,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b10,x:b2,y:b3,",
     "05000000ac050000020000004f066d02,*,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b6,leftshoulder:b4,rightshoulder:b5,x:b2,y:b3,",
     "050000004c050000cc090000df070000,PS4 Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b9,x:b2,y:b3,",
+    "050000004c050000cc090000df870001,PS4 Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b9,x:b2,y:b3,",
     "050000004c050000cc090000ff070000,PS4 Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b9,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b10,x:b2,y:b3,",
     "050000004c050000cc090000ff870001,PS4 Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b9,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b10,touchpad:b11,x:b2,y:b3,",
+    "050000004c050000e60c0000df870000,PS5 Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b9,touchpad:b10,x:b2,y:b3,",
+    "050000004c050000e60c0000ff870000,PS5 Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b9,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b10,touchpad:b11,x:b2,y:b3,",
     "05000000ac0500000300000043006d03,Remote,a:b0,b:b2,leftx:a0,lefty:a1,",
+    "050000005e040000050b0000df070001,Xbox Elite Wireless Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,paddle1:b10,paddle2:b12,paddle3:b11,paddle4:b13,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b9,x:b2,y:b3,",
     "050000005e040000050b0000ff070001,Xbox Elite Wireless Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b9,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,paddle1:b11,paddle2:b13,paddle3:b12,paddle4:b14,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b10,x:b2,y:b3,",
+    "050000005e040000130b0000df870001,Xbox Series X Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,misc1:b10,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b9,x:b2,y:b3,",
+    "050000005e040000130b0000ff870001,Xbox Series X Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b9,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,misc1:b11,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b10,x:b2,y:b3,",
     "050000005e040000e0020000df070000,Xbox Wireless Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b9,x:b2,y:b3,",
     "050000005e040000e0020000ff070000,Xbox Wireless Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b9,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b10,x:b2,y:b3,",
 #endif
@@ -846,6 +901,13 @@ static const char *s_ControllerMappings [] =
 #if defined(SDL_JOYSTICK_EMSCRIPTEN)
     "default,Standard Gamepad,a:b0,b:b1,back:b8,dpdown:b13,dpleft:b14,dpright:b15,dpup:b12,guide:b16,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,",
 #endif
+#if defined(SDL_JOYSTICK_VITA)
+    "50535669746120436f6e74726f6c6c65,PSVita Controller,a:b2,b:b1,back:b10,dpdown:b6,dpleft:b7,dpright:b9,dpup:b8,leftshoulder:b4,leftstick:b14,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b15,righttrigger:a5,rightx:a2,righty:a3,start:b11,x:b3,y:b0,",
+#endif
+#if defined(SDL_JOYSTICK_PSP)
+    "505350206275696c74696e206a6f7970,PSP builtin joypad,a:b2,b:b1,back:b10,dpdown:b6,dpleft:b7,dpright:b9,dpup:b8,leftshoulder:b4,leftx:a0,lefty:a1,rightshoulder:b5,rightx:a2,righty:a3,start:b11,x:b3,y:b0,",
+#endif
+    "hidapi,*,a:b0,b:b1,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b5,leftshoulder:b9,leftstick:b7,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a2,righty:a3,start:b6,x:b2,y:b3,",
     NULL
 };
 
diff --git a/Engine/lib/sdl/src/joystick/SDL_joystick.c b/Engine/lib/sdl/src/joystick/SDL_joystick.c
index 32eb7c248..3f3482b7d 100644
--- a/Engine/lib/sdl/src/joystick/SDL_joystick.c
+++ b/Engine/lib/sdl/src/joystick/SDL_joystick.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -56,11 +56,14 @@ static SDL_JoystickDriver *SDL_joystick_drivers[] = {
 #ifdef SDL_JOYSTICK_RAWINPUT /* Before WINDOWS_ driver, as WINDOWS wants to check if this driver is handling things */
     &SDL_RAWINPUT_JoystickDriver,
 #endif
+#if defined(SDL_JOYSTICK_DINPUT) || defined(SDL_JOYSTICK_XINPUT) /* Before WGI driver, as WGI wants to check if this driver is handling things */
+    &SDL_WINDOWS_JoystickDriver,
+#endif
 #if defined(SDL_JOYSTICK_WGI)
     &SDL_WGI_JoystickDriver,
 #endif
-#if defined(SDL_JOYSTICK_DINPUT) || defined(SDL_JOYSTICK_XINPUT)
-    &SDL_WINDOWS_JoystickDriver,
+#if defined(SDL_JOYSTICK_WINMM)
+    &SDL_WINMM_JoystickDriver,
 #endif
 #ifdef SDL_JOYSTICK_LINUX
     &SDL_LINUX_JoystickDriver,
@@ -83,9 +86,18 @@ static SDL_JoystickDriver *SDL_joystick_drivers[] = {
 #ifdef SDL_JOYSTICK_USBHID  /* !!! FIXME: "USBHID" is a generic name, and doubly-confusing with HIDAPI next to it. This is the *BSD interface, rename this. */
     &SDL_BSD_JoystickDriver,
 #endif
+#ifdef SDL_JOYSTICK_OS2
+    &SDL_OS2_JoystickDriver,
+#endif
+#ifdef SDL_JOYSTICK_PSP
+    &SDL_PSP_JoystickDriver,
+#endif
 #ifdef SDL_JOYSTICK_VIRTUAL
     &SDL_VIRTUAL_JoystickDriver,
 #endif
+#ifdef SDL_JOYSTICK_VITA
+    &SDL_VITA_JoystickDriver,
+#endif
 #if defined(SDL_JOYSTICK_DUMMY) || defined(SDL_JOYSTICK_DISABLED)
     &SDL_DUMMY_JoystickDriver
 #endif
@@ -160,9 +172,6 @@ SDL_SetJoystickIDForPlayerIndex(int player_index, SDL_JoystickID instance_id)
     int device_index;
     int existing_player_index;
 
-    if (player_index < 0) {
-        return SDL_FALSE;
-    }
     if (player_index >= SDL_joystick_player_count) {
         SDL_JoystickID *new_players = (SDL_JoystickID *)SDL_realloc(SDL_joystick_players, (player_index + 1)*sizeof(*SDL_joystick_players));
         if (!new_players) {
@@ -184,7 +193,9 @@ SDL_SetJoystickIDForPlayerIndex(int player_index, SDL_JoystickID instance_id)
         SDL_joystick_players[existing_player_index] = -1;
     }
 
-    SDL_joystick_players[player_index] = instance_id;
+    if (player_index >= 0) {
+        SDL_joystick_players[player_index] = instance_id;
+    }
 
     /* Update the driver with the new index */
     device_index = SDL_JoystickGetDeviceIndexFromInstanceID(instance_id);
@@ -332,6 +343,9 @@ SDL_JoystickGetDevicePlayerIndex(int device_index)
 static SDL_bool
 SDL_JoystickAxesCenteredAtZero(SDL_Joystick *joystick)
 {
+#ifdef __WINRT__
+    return SDL_TRUE;
+#else
     static Uint32 zero_centered_joysticks[] = {
         MAKE_VIDPID(0x0e8f, 0x3013),    /* HuiJia SNES USB adapter */
         MAKE_VIDPID(0x05a0, 0x3232),    /* 8Bitdo Zero Gamepad */
@@ -341,7 +355,7 @@ SDL_JoystickAxesCenteredAtZero(SDL_Joystick *joystick)
     Uint32 id = MAKE_VIDPID(SDL_JoystickGetVendor(joystick),
                             SDL_JoystickGetProduct(joystick));
 
-/*printf("JOYSTICK '%s' VID/PID 0x%.4x/0x%.4x AXES: %d\n", joystick->name, vendor, product, joystick->naxes);*/
+    /*printf("JOYSTICK '%s' VID/PID 0x%.4x/0x%.4x AXES: %d\n", joystick->name, vendor, product, joystick->naxes);*/
 
     if (joystick->naxes == 2) {
         /* Assume D-pad or thumbstick style axes are centered at 0 */
@@ -354,6 +368,7 @@ SDL_JoystickAxesCenteredAtZero(SDL_Joystick *joystick)
         }
     }
     return SDL_FALSE;
+#endif /* __WINRT__ */
 }
 
 /*
@@ -405,6 +420,7 @@ SDL_JoystickOpen(int device_index)
     joystick->instance_id = instance_id;
     joystick->attached = SDL_TRUE;
     joystick->epowerlevel = SDL_JOYSTICK_POWER_UNKNOWN;
+    joystick->led_expiration = SDL_GetTicks();
 
     if (driver->Open(joystick, device_index) < 0) {
         SDL_free(joystick);
@@ -747,7 +763,7 @@ SDL_JoystickGetButton(SDL_Joystick *joystick, int button)
 SDL_bool
 SDL_JoystickGetAttached(SDL_Joystick *joystick)
 {
-    if (!SDL_PrivateJoystickValid(joystick)) {
+    if (!joystick) {
         return SDL_FALSE;
     }
 
@@ -870,17 +886,18 @@ SDL_JoystickRumble(SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 h
         result = joystick->driver->Rumble(joystick, low_frequency_rumble, high_frequency_rumble);
     }
 
-    /* Save the rumble value regardless of success, so we don't spam the driver */
-    joystick->low_frequency_rumble = low_frequency_rumble;
-    joystick->high_frequency_rumble = high_frequency_rumble;
+    if (result == 0) {
+        joystick->low_frequency_rumble = low_frequency_rumble;
+        joystick->high_frequency_rumble = high_frequency_rumble;
 
-    if ((low_frequency_rumble || high_frequency_rumble) && duration_ms) {
-        joystick->rumble_expiration = SDL_GetTicks() + SDL_min(duration_ms, SDL_MAX_RUMBLE_DURATION_MS);
-        if (!joystick->rumble_expiration) {
-            joystick->rumble_expiration = 1;
+        if ((low_frequency_rumble || high_frequency_rumble) && duration_ms) {
+            joystick->rumble_expiration = SDL_GetTicks() + SDL_min(duration_ms, SDL_MAX_RUMBLE_DURATION_MS);
+            if (!joystick->rumble_expiration) {
+                joystick->rumble_expiration = 1;
+            }
+        } else {
+            joystick->rumble_expiration = 0;
         }
-    } else {
-        joystick->rumble_expiration = 0;
     }
     SDL_UnlockJoysticks();
 
@@ -904,17 +921,18 @@ SDL_JoystickRumbleTriggers(SDL_Joystick *joystick, Uint16 left_rumble, Uint16 ri
         result = joystick->driver->RumbleTriggers(joystick, left_rumble, right_rumble);
     }
 
-    /* Save the rumble value regardless of success, so we don't spam the driver */
-    joystick->left_trigger_rumble = left_rumble;
-    joystick->right_trigger_rumble = right_rumble;
+    if (result == 0) {
+        joystick->left_trigger_rumble = left_rumble;
+        joystick->right_trigger_rumble = right_rumble;
 
-    if ((left_rumble || right_rumble) && duration_ms) {
-        joystick->trigger_rumble_expiration = SDL_GetTicks() + SDL_min(duration_ms, SDL_MAX_RUMBLE_DURATION_MS);
-        if (!joystick->trigger_rumble_expiration) {
-            joystick->trigger_rumble_expiration = 1;
+        if ((left_rumble || right_rumble) && duration_ms) {
+            joystick->trigger_rumble_expiration = SDL_GetTicks() + SDL_min(duration_ms, SDL_MAX_RUMBLE_DURATION_MS);
+            if (!joystick->trigger_rumble_expiration) {
+                joystick->trigger_rumble_expiration = 1;
+            }
+        } else {
+            joystick->trigger_rumble_expiration = 0;
         }
-    } else {
-        joystick->trigger_rumble_expiration = 0;
     }
     SDL_UnlockJoysticks();
 
@@ -932,7 +950,43 @@ SDL_JoystickHasLED(SDL_Joystick *joystick)
 
     SDL_LockJoysticks();
 
-    result = joystick->driver->HasLED(joystick);
+    result = (joystick->driver->GetCapabilities(joystick) & SDL_JOYCAP_LED) != 0;
+
+    SDL_UnlockJoysticks();
+
+    return result;
+}
+
+SDL_bool
+SDL_JoystickHasRumble(SDL_Joystick *joystick)
+{
+    SDL_bool result;
+
+    if (!SDL_PrivateJoystickValid(joystick)) {
+        return SDL_FALSE;
+    }
+
+    SDL_LockJoysticks();
+
+    result = (joystick->driver->GetCapabilities(joystick) & SDL_JOYCAP_RUMBLE) != 0;
+
+    SDL_UnlockJoysticks();
+
+    return result;
+}
+
+SDL_bool
+SDL_JoystickHasRumbleTriggers(SDL_Joystick *joystick)
+{
+    SDL_bool result;
+
+    if (!SDL_PrivateJoystickValid(joystick)) {
+        return SDL_FALSE;
+    }
+
+    SDL_LockJoysticks();
+
+    result = (joystick->driver->GetCapabilities(joystick) & SDL_JOYCAP_RUMBLE_TRIGGERS) != 0;
 
     SDL_UnlockJoysticks();
 
@@ -943,6 +997,7 @@ int
 SDL_JoystickSetLED(SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
 {
     int result;
+    SDL_bool isfreshvalue;
 
     if (!SDL_PrivateJoystickValid(joystick)) {
         return -1;
@@ -950,13 +1005,17 @@ SDL_JoystickSetLED(SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
 
     SDL_LockJoysticks();
 
-    if (red == joystick->led_red &&
-        green == joystick->led_green &&
-        blue == joystick->led_blue) {
+    isfreshvalue = red != joystick->led_red ||
+        green != joystick->led_green ||
+        blue != joystick->led_blue;
+
+    if ( isfreshvalue || SDL_TICKS_PASSED( SDL_GetTicks(), joystick->led_expiration ) ) {
+        result = joystick->driver->SetLED(joystick, red, green, blue);
+        joystick->led_expiration = SDL_GetTicks() + SDL_LED_MIN_REPEAT_MS;
+    }
+    else {
         /* Avoid spamming the driver */
         result = 0;
-    } else {
-        result = joystick->driver->SetLED(joystick, red, green, blue);
     }
 
     /* Save the LED value regardless of success, so we don't spam the driver */
@@ -969,6 +1028,24 @@ SDL_JoystickSetLED(SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
     return result;
 }
 
+int
+SDL_JoystickSendEffect(SDL_Joystick *joystick, const void *data, int size)
+{
+    int result;
+
+    if (!SDL_PrivateJoystickValid(joystick)) {
+        return -1;
+    }
+
+    SDL_LockJoysticks();
+
+    result = joystick->driver->SendEffect(joystick, data, size);
+
+    SDL_UnlockJoysticks();
+
+    return result;
+}
+
 /*
  * Close a joystick previously opened with SDL_JoystickOpen()
  */
@@ -1060,8 +1137,8 @@ SDL_JoystickQuit(void)
         SDL_JoystickClose(SDL_joysticks);
     }
 
-    /* Quit the joystick setup */
-    for (i = 0; i < SDL_arraysize(SDL_joystick_drivers); ++i) {
+    /* Quit drivers in reverse order to avoid breaking dependencies between drivers */
+    for (i = SDL_arraysize(SDL_joystick_drivers) - 1; i >= 0; --i) {
        SDL_joystick_drivers[i]->Quit();
     }
 
@@ -1127,7 +1204,7 @@ void SDL_PrivateJoystickAddTouchpad(SDL_Joystick *joystick, int nfingers)
     }
 }
 
-void SDL_PrivateJoystickAddSensor(SDL_Joystick *joystick, SDL_SensorType type)
+void SDL_PrivateJoystickAddSensor(SDL_Joystick *joystick, SDL_SensorType type, float rate)
 {
     int nsensors = joystick->nsensors + 1;
     SDL_JoystickSensorInfo *sensors = (SDL_JoystickSensorInfo *)SDL_realloc(joystick->sensors, (nsensors * sizeof(SDL_JoystickSensorInfo)));
@@ -1136,6 +1213,7 @@ void SDL_PrivateJoystickAddSensor(SDL_Joystick *joystick, SDL_SensorType type)
 
         SDL_zerop(sensor);
         sensor->type = type;
+        sensor->rate = rate;
 
         joystick->nsensors = nsensors;
         joystick->sensors = sensors;
@@ -1247,7 +1325,6 @@ SDL_PrivateJoystickForceRecentering(SDL_Joystick *joystick)
             SDL_PrivateJoystickTouchpad(joystick, i, j, SDL_RELEASED, 0.0f, 0.0f, 0.0f);
         }
     }
-
 }
 
 void SDL_PrivateJoystickRemoved(SDL_JoystickID device_instance)
@@ -1309,7 +1386,7 @@ SDL_PrivateJoystickAxis(SDL_Joystick *joystick, Uint8 axis, Sint16 value)
         info->value = value;
         info->zero = value;
         info->has_initial_value = SDL_TRUE;
-    } else if (value == info->value) {
+    } else if (value == info->value && !info->sending_initial_value) {
         return 0;
     } else {
         info->has_second_value = SDL_TRUE;
@@ -1321,15 +1398,17 @@ SDL_PrivateJoystickAxis(SDL_Joystick *joystick, Uint8 axis, Sint16 value)
             return 0;
         }
         info->sent_initial_value = SDL_TRUE;
-        info->value = ~value; /* Just so we pass the check above */
+        info->sending_initial_value = SDL_TRUE;
         SDL_PrivateJoystickAxis(joystick, axis, info->initial_value);
+        info->sending_initial_value = SDL_FALSE;
     }
 
     /* We ignore events if we don't have keyboard focus, except for centering
      * events.
      */
     if (SDL_PrivateJoystickShouldIgnoreEvent()) {
-        if ((value > info->zero && value >= info->value) ||
+        if (info->sending_initial_value ||
+            (value > info->zero && value >= info->value) ||
             (value < info->zero && value <= info->value)) {
             return 0;
         }
@@ -1636,7 +1715,7 @@ PrefixMatch(const char *a, const char *b)
 {
     int matchlen = 0;
     while (*a && *b) {
-        if (SDL_tolower(*a++) == SDL_tolower(*b++)) {
+        if (SDL_tolower((unsigned char) *a++) == SDL_tolower((unsigned char) *b++)) {
             ++matchlen;
         } else {
             break;
@@ -1656,6 +1735,7 @@ SDL_CreateJoystickName(Uint16 vendor, Uint16 product, const char *vendor_name, c
         { "Performance Designed Products", "PDP" },
         { "HORI CO.,LTD.", "HORI" },
         { "HORI CO.,LTD", "HORI" },
+        { "Unknown ", "" },
     };
     const char *custom_name;
     char *name;
@@ -1716,27 +1796,30 @@ SDL_CreateJoystickName(Uint16 vendor, Uint16 product, const char *vendor_name, c
         }
     }
 
-    /* Remove duplicate manufacturer or product in the name */
-    for (i = 1; i < (len - 1); ++i) {
-        int matchlen = PrefixMatch(name, &name[i]);
-        if (matchlen > 0 && name[matchlen-1] == ' ') {
-            SDL_memmove(name, name+matchlen, len-matchlen+1);
-            len -= matchlen;
-            break;
-        } else if (matchlen > 0 && name[matchlen] == ' ') {
-            SDL_memmove(name, name+matchlen+1, len-matchlen);
-            len -= (matchlen + 1);
-            break;
-        }
-    }
-
     /* Perform any manufacturer replacements */
     for (i = 0; i < SDL_arraysize(replacements); ++i) {
         size_t prefixlen = SDL_strlen(replacements[i].prefix);
         if (SDL_strncasecmp(name, replacements[i].prefix, prefixlen) == 0) {
             size_t replacementlen = SDL_strlen(replacements[i].replacement);
-            SDL_memcpy(name, replacements[i].replacement, replacementlen);
-            SDL_memmove(name+replacementlen, name+prefixlen, (len-prefixlen+1));
+            if (replacementlen <= prefixlen) {
+                SDL_memcpy(name, replacements[i].replacement, replacementlen);
+                SDL_memmove(name+replacementlen, name+prefixlen, (len-prefixlen)+1);
+                len -= (prefixlen - replacementlen);
+            } else {
+                /* FIXME: Need to handle the expand case by reallocating the string */
+            }
+            break;
+        }
+    }
+
+    /* Remove duplicate manufacturer or product in the name */
+    for (i = 1; i < (len - 1); ++i) {
+        int matchlen = PrefixMatch(name, &name[i]);
+        if (matchlen > 0 && name[matchlen-1] == ' ') {
+            SDL_memmove(name, name+matchlen, len-matchlen+1);
+            break;
+        } else if (matchlen > 0 && name[matchlen] == ' ') {
+            SDL_memmove(name, name+matchlen+1, len-matchlen);
             break;
         }
     }
@@ -1801,11 +1884,13 @@ SDL_GetJoystickGameControllerType(const char *name, Uint16 vendor, Uint16 produc
             0x12ab, /* Unknown */
             0x1430, /* RedOctane */
             0x146b, /* BigBen */
-            0x1532, /* Razer Sabertooth */
+            0x1532, /* Razer */
             0x15e4, /* Numark */
             0x162e, /* Joytech */
             0x1689, /* Razer Onza */
+            0x1949, /* Lab126, Inc. */
             0x1bad, /* Harmonix */
+            0x20d6, /* PowerA */
             0x24c6, /* PowerA */
         };
 
@@ -1828,7 +1913,8 @@ SDL_GetJoystickGameControllerType(const char *name, Uint16 vendor, Uint16 produc
             0x0738, /* Mad Catz */
             0x0e6f, /* PDP */
             0x0f0d, /* Hori */
-            0x1532, /* Razer Wildcat */
+            0x1532, /* Razer */
+            0x20d6, /* PowerA */
             0x24c6, /* PowerA */
             0x2e24, /* Hyperkin */
         };
@@ -1860,6 +1946,19 @@ SDL_GetJoystickGameControllerType(const char *name, Uint16 vendor, Uint16 produc
         } else if (vendor == 0x0001 && product == 0x0001) {
             type = SDL_CONTROLLER_TYPE_UNKNOWN;
 
+        } else if (vendor == USB_VENDOR_MICROSOFT && product == USB_PRODUCT_XBOX_ONE_XINPUT_CONTROLLER) {
+            type = SDL_CONTROLLER_TYPE_XBOXONE;
+
+        } else if ((vendor == USB_VENDOR_AMAZON && product == USB_PRODUCT_AMAZON_LUNA_CONTROLLER) ||
+                   (vendor == BLUETOOTH_VENDOR_AMAZON && product == BLUETOOTH_PRODUCT_LUNA_CONTROLLER)) {
+            type = SDL_CONTROLLER_TYPE_AMAZON_LUNA;
+
+        } else if (vendor == USB_VENDOR_GOOGLE && product == USB_PRODUCT_GOOGLE_STADIA_CONTROLLER) {
+            type = SDL_CONTROLLER_TYPE_GOOGLE_STADIA;
+
+        } else if (vendor == USB_VENDOR_NINTENDO && product == USB_PRODUCT_NINTENDO_SWITCH_JOY_CON_GRIP) {
+                type = SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_JOY_CONS, SDL_FALSE) ? SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_PRO : SDL_CONTROLLER_TYPE_UNKNOWN;
+
         } else {
             switch (GuessControllerType(vendor, product)) {
             case k_eControllerType_XBox360Controller:
@@ -1881,6 +1980,10 @@ SDL_GetJoystickGameControllerType(const char *name, Uint16 vendor, Uint16 produc
             case k_eControllerType_SwitchInputOnlyController:
                 type = SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_PRO;
                 break;
+            case k_eControllerType_SwitchJoyConLeft:
+            case k_eControllerType_SwitchJoyConRight:
+                type = SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_JOY_CONS, SDL_FALSE) ? SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_PRO : SDL_CONTROLLER_TYPE_UNKNOWN;
+                break;
             default:
                 type = SDL_CONTROLLER_TYPE_UNKNOWN;
                 break;
@@ -1904,11 +2007,43 @@ SDL_IsJoystickXboxOneElite(Uint16 vendor_id, Uint16 product_id)
 }
 
 SDL_bool
-SDL_IsJoystickXboxOneSeriesX(Uint16 vendor_id, Uint16 product_id)
+SDL_IsJoystickXboxSeriesX(Uint16 vendor_id, Uint16 product_id)
 {
     if (vendor_id == USB_VENDOR_MICROSOFT) {
-        if (product_id == USB_PRODUCT_XBOX_ONE_SERIES_X ||
-            product_id == USB_PRODUCT_XBOX_ONE_SERIES_X_BLUETOOTH) {
+        if (product_id == USB_PRODUCT_XBOX_SERIES_X ||
+            product_id == USB_PRODUCT_XBOX_SERIES_X_BLE) {
+            return SDL_TRUE;
+        }
+    }
+    if (vendor_id == USB_VENDOR_PDP) {
+        if (product_id == USB_PRODUCT_XBOX_SERIES_X_VICTRIX_GAMBIT ||
+            product_id == USB_PRODUCT_XBOX_SERIES_X_PDP_BLUE ||
+            product_id == USB_PRODUCT_XBOX_SERIES_X_PDP_AFTERGLOW) {
+            return SDL_TRUE;
+        }
+    }
+    if (vendor_id == USB_VENDOR_POWERA_ALT) {
+        if ((product_id >= 0x2001 && product_id <= 0x201a) ||
+            product_id == USB_PRODUCT_XBOX_SERIES_X_POWERA_FUSION_PRO2 ||
+            product_id == USB_PRODUCT_XBOX_SERIES_X_POWERA_SPECTRA) {
+            return SDL_TRUE;
+        }
+    }
+    return SDL_FALSE;
+}
+
+SDL_bool
+SDL_IsJoystickBluetoothXboxOne(Uint16 vendor_id, Uint16 product_id)
+{
+    if (vendor_id == USB_VENDOR_MICROSOFT) {
+        if (product_id == USB_PRODUCT_XBOX_ONE_ADAPTIVE_BLUETOOTH ||
+            product_id == USB_PRODUCT_XBOX_ONE_ADAPTIVE_BLE ||
+            product_id == USB_PRODUCT_XBOX_ONE_S_REV1_BLUETOOTH ||
+            product_id == USB_PRODUCT_XBOX_ONE_S_REV2_BLUETOOTH ||
+            product_id == USB_PRODUCT_XBOX_ONE_S_REV2_BLE ||
+            product_id == USB_PRODUCT_XBOX_ONE_ELITE_SERIES_2_BLUETOOTH ||
+            product_id == USB_PRODUCT_XBOX_ONE_ELITE_SERIES_2_BLE ||
+            product_id == USB_PRODUCT_XBOX_SERIES_X_BLE) {
             return SDL_TRUE;
         }
     }
@@ -1934,7 +2069,8 @@ SDL_IsJoystickNintendoSwitchPro(Uint16 vendor_id, Uint16 product_id)
 {
     EControllerType eType = GuessControllerType(vendor_id, product_id);
     return (eType == k_eControllerType_SwitchProController ||
-            eType == k_eControllerType_SwitchInputOnlyController);
+            eType == k_eControllerType_SwitchInputOnlyController ||
+            (vendor_id == USB_VENDOR_NINTENDO && product_id == USB_PRODUCT_NINTENDO_SWITCH_JOY_CON_GRIP));
 }
 
 SDL_bool
@@ -1944,6 +2080,28 @@ SDL_IsJoystickNintendoSwitchProInputOnly(Uint16 vendor_id, Uint16 product_id)
     return (eType == k_eControllerType_SwitchInputOnlyController);
 }
 
+SDL_bool
+SDL_IsJoystickNintendoSwitchJoyCon(Uint16 vendor_id, Uint16 product_id)
+{
+    EControllerType eType = GuessControllerType(vendor_id, product_id);
+    return (eType == k_eControllerType_SwitchJoyConLeft ||
+            eType == k_eControllerType_SwitchJoyConRight);
+}
+
+SDL_bool
+SDL_IsJoystickNintendoSwitchJoyConLeft(Uint16 vendor_id, Uint16 product_id)
+{
+    EControllerType eType = GuessControllerType(vendor_id, product_id);
+    return (eType == k_eControllerType_SwitchJoyConLeft);
+}
+
+SDL_bool
+SDL_IsJoystickNintendoSwitchJoyConRight(Uint16 vendor_id, Uint16 product_id)
+{
+    EControllerType eType = GuessControllerType(vendor_id, product_id);
+    return (eType == k_eControllerType_SwitchJoyConRight);
+}
+
 SDL_bool
 SDL_IsJoystickSteamController(Uint16 vendor_id, Uint16 product_id)
 {
@@ -1991,12 +2149,17 @@ static SDL_bool SDL_IsJoystickProductWheel(Uint32 vidpid)
         MAKE_VIDPID(0x046d, 0xc299),    /* Logitech G25 */
         MAKE_VIDPID(0x046d, 0xc29a),    /* Logitech Driving Force GT */
         MAKE_VIDPID(0x046d, 0xc29b),    /* Logitech G27 */
-        MAKE_VIDPID(0x046d, 0xc24f),    /* Logitech G29 */
+        MAKE_VIDPID(0x046d, 0xc24f),    /* Logitech G29 (PS3) */
+        MAKE_VIDPID(0x046d, 0xc260),    /* Logitech G29 (PS4) */
         MAKE_VIDPID(0x046d, 0xc261),    /* Logitech G920 (initial mode) */
         MAKE_VIDPID(0x046d, 0xc262),    /* Logitech G920 (active mode) */
+        MAKE_VIDPID(0x046d, 0xc26e),    /* Logitech G923 */
+        MAKE_VIDPID(0x046d, 0xca03),    /* Logitech Momo Racing */
         MAKE_VIDPID(0x044f, 0xb65d),    /* Thrustmaster Wheel FFB */
         MAKE_VIDPID(0x044f, 0xb66d),    /* Thrustmaster Wheel FFB */
         MAKE_VIDPID(0x044f, 0xb677),    /* Thrustmaster T150 */
+        MAKE_VIDPID(0x044f, 0xb66e),    /* Thrustmaster T300RS */
+        MAKE_VIDPID(0x044f, 0xb65e),    /* Thrustmaster T500RS */
         MAKE_VIDPID(0x044f, 0xb664),    /* Thrustmaster TX (initial mode) */
         MAKE_VIDPID(0x044f, 0xb669),    /* Thrustmaster TX (active mode) */
     };
@@ -2010,11 +2173,46 @@ static SDL_bool SDL_IsJoystickProductWheel(Uint32 vidpid)
     return SDL_FALSE;
 }
 
+static SDL_bool SDL_IsJoystickProductArcadeStick(Uint32 vidpid)
+{
+    static Uint32 arcadestick_joysticks[] = {
+        MAKE_VIDPID(0x0079, 0x181a),    /* Venom Arcade Stick */
+        MAKE_VIDPID(0x0f0d, 0x006a),    /* Real Arcade Pro 4 */
+        MAKE_VIDPID(0x0079, 0x181b),    /* Venom Arcade Stick */
+        MAKE_VIDPID(0x0c12, 0x0ef6),    /* Hitbox Arcade Stick */
+        MAKE_VIDPID(0x0f0d, 0x008a),    /* HORI Real Arcade Pro 4 */
+        MAKE_VIDPID(0x0f0d, 0x0016),    /* Hori Real Arcade Pro.EX */
+        MAKE_VIDPID(0x0f0d, 0x001b),    /* Hori Real Arcade Pro VX */
+        MAKE_VIDPID(0x0f0d, 0x008c),    /* Hori Real Arcade Pro 4 */
+        MAKE_VIDPID(0x1bad, 0xf03d),    /* Street Fighter IV Arcade Stick TE - Chun Li */
+        MAKE_VIDPID(0x1bad, 0xf502),    /* Hori Real Arcade Pro.VX SA */
+        MAKE_VIDPID(0x1bad, 0xf504),    /* Hori Real Arcade Pro. EX */
+        MAKE_VIDPID(0x1bad, 0xf506),    /* Hori Real Arcade Pro.EX Premium VLX */
+        MAKE_VIDPID(0x24c6, 0x5000),    /* Razer Atrox Arcade Stick */
+        MAKE_VIDPID(0x24c6, 0x5501),    /* Hori Real Arcade Pro VX-SA */
+        MAKE_VIDPID(0x24c6, 0x550e),    /* Hori Real Arcade Pro V Kai 360 */
+        MAKE_VIDPID(0x0f0d, 0x0063),    /* Hori Real Arcade Pro Hayabusa (USA) Xbox One */
+        MAKE_VIDPID(0x0f0d, 0x0078),    /* Hori Real Arcade Pro V Kai Xbox One */
+        MAKE_VIDPID(0x1532, 0x0a00),    /* Razer Atrox Arcade Stick */
+        MAKE_VIDPID(0x0f0d, 0x00aa),    /* HORI Real Arcade Pro V Hayabusa in Switch Mode */
+        MAKE_VIDPID(0x20d6, 0xa715),    /* PowerA Nintendo Switch Fusion Arcade Stick */
+    };
+    int i;
+
+    for (i = 0; i < SDL_arraysize(arcadestick_joysticks); ++i) {
+        if (vidpid == arcadestick_joysticks[i]) {
+            return SDL_TRUE;
+        }
+    }
+    return SDL_FALSE;
+}
+
 static SDL_bool SDL_IsJoystickProductFlightStick(Uint32 vidpid)
 {
     static Uint32 flightstick_joysticks[] = {
         MAKE_VIDPID(0x044f, 0x0402),    /* HOTAS Warthog Joystick */
         MAKE_VIDPID(0x0738, 0x2221),    /* Saitek Pro Flight X-56 Rhino Stick */
+        MAKE_VIDPID(0x044f, 0xb10a),    /* ThrustMaster, Inc. T.16000M Joystick */
     };
     int i;
 
@@ -2089,6 +2287,10 @@ static SDL_JoystickType SDL_GetJoystickGUIDType(SDL_JoystickGUID guid)
         return SDL_JOYSTICK_TYPE_WHEEL;
     }
 
+    if (SDL_IsJoystickProductArcadeStick(vidpid)) {
+        return SDL_JOYSTICK_TYPE_ARCADE_STICK;
+    }
+
     if (SDL_IsJoystickProductFlightStick(vidpid)) {
         return SDL_JOYSTICK_TYPE_FLIGHT_STICK;
     }
@@ -2237,6 +2439,27 @@ SDL_bool SDL_ShouldIgnoreJoystick(const char *name, SDL_JoystickGUID guid)
 
         MAKE_VIDPID(0x2516, 0x001f),  /* Cooler Master Storm Mizar Mouse */
         MAKE_VIDPID(0x2516, 0x0028),  /* Cooler Master Storm Alcor Mouse */
+
+        /*****************************************************************/
+        /* Additional entries                                            */
+        /*****************************************************************/
+
+        MAKE_VIDPID(0x04d9, 0x8008),  /* OBINLB USB-HID Keyboard (Anne Pro II) */
+        MAKE_VIDPID(0x04d9, 0x8009),  /* OBINLB USB-HID Keyboard (Anne Pro II) */
+        MAKE_VIDPID(0x04d9, 0xa292),  /* OBINLB USB-HID Keyboard (Anne Pro II) */
+        MAKE_VIDPID(0x04d9, 0xa293),  /* OBINLB USB-HID Keyboard (Anne Pro II) */
+        MAKE_VIDPID(0x1532, 0x0266),  /* Razer Huntman V2 Analog, non-functional DInput device */
+        MAKE_VIDPID(0x1532, 0x0282),  /* Razer Huntman Mini Analog, non-functional DInput device */
+        MAKE_VIDPID(0x26ce, 0x01a2),  /* ASRock LED Controller */
+    };
+
+    static Uint32 rog_chakram_list[] = {
+        MAKE_VIDPID(0x0b05, 0x1958),  /* ROG Chakram Core Mouse */
+        MAKE_VIDPID(0x0b05, 0x18e3),  /* ROG Chakram (wired) Mouse */
+        MAKE_VIDPID(0x0b05, 0x18e5),  /* ROG Chakram (wireless) Mouse */
+        MAKE_VIDPID(0x0b05, 0x1a18),  /* ROG Chakram X (wired) Mouse */
+        MAKE_VIDPID(0x0b05, 0x1a1a),  /* ROG Chakram X (wireless) Mouse */
+        MAKE_VIDPID(0x0b05, 0x1a1c),  /* ROG Chakram X (Bluetooth) Mouse */
     };
 
     unsigned int i;
@@ -2254,6 +2477,13 @@ SDL_bool SDL_ShouldIgnoreJoystick(const char *name, SDL_JoystickGUID guid)
             return SDL_TRUE;
         }
     }
+    if (!SDL_GetHintBoolean(SDL_HINT_JOYSTICK_ROG_CHAKRAM, SDL_FALSE)) {
+        for (i = 0; i < SDL_arraysize(rog_chakram_list); ++i) {
+            if (id == rog_chakram_list[i]) {
+                return SDL_TRUE;
+            }
+        }
+    }
 
     type = SDL_GetJoystickGameControllerType(name, vendor, product, -1, 0, 0, 0);
     if ((type == SDL_CONTROLLER_TYPE_PS4 || type == SDL_CONTROLLER_TYPE_PS5) && SDL_IsPS4RemapperRunning()) {
@@ -2442,18 +2672,18 @@ void SDL_JoystickGetGUIDString(SDL_JoystickGUID guid, char *pszGUID, int cbGUID)
  * Input  : c -
  * Output : unsigned char
  *-----------------------------------------------------------------------------*/
-static unsigned char nibble(char c)
+static unsigned char nibble(unsigned char c)
 {
     if ((c >= '0') && (c <= '9')) {
-        return (unsigned char)(c - '0');
+        return (c - '0');
     }
 
     if ((c >= 'A') && (c <= 'F')) {
-        return (unsigned char)(c - 'A' + 0x0a);
+        return (c - 'A' + 0x0a);
     }
 
     if ((c >= 'a') && (c <= 'f')) {
-        return (unsigned char)(c - 'a' + 0x0a);
+        return (c - 'a' + 0x0a);
     }
 
     /* received an invalid character, and no real way to return an error */
@@ -2477,7 +2707,7 @@ SDL_JoystickGUID SDL_JoystickGetGUIDFromString(const char *pchGUID)
 
     p = (Uint8 *)&guid;
     for (i = 0; (i < len) && ((p - (Uint8 *)&guid) < maxoutputbytes); i+=2, p++) {
-        *p = (nibble(pchGUID[i]) << 4) | nibble(pchGUID[i+1]);
+        *p = (nibble((unsigned char)pchGUID[i]) << 4) | nibble((unsigned char)pchGUID[i+1]);
     }
 
     return guid;
@@ -2503,9 +2733,7 @@ int SDL_PrivateJoystickTouchpad(SDL_Joystick *joystick, int touchpad, int finger
     SDL_JoystickTouchpadInfo *touchpad_info;
     SDL_JoystickTouchpadFingerInfo *finger_info;
     int posted;
-#if !SDL_EVENTS_DISABLED
     Uint32 event_type;
-#endif
 
     if (touchpad < 0 || touchpad >= joystick->ntouchpads) {
         return 0;
@@ -2549,7 +2777,6 @@ int SDL_PrivateJoystickTouchpad(SDL_Joystick *joystick, int touchpad, int finger
         }
     }
 
-#if !SDL_EVENTS_DISABLED
     if (state == finger_info->state) {
         event_type = SDL_CONTROLLERTOUCHPADMOTION;
     } else if (state) {
@@ -2557,7 +2784,13 @@ int SDL_PrivateJoystickTouchpad(SDL_Joystick *joystick, int touchpad, int finger
     } else {
         event_type = SDL_CONTROLLERTOUCHPADUP;
     }
-#endif
+
+    /* We ignore events if we don't have keyboard focus, except for touch release */
+    if (SDL_PrivateJoystickShouldIgnoreEvent()) {
+        if (event_type != SDL_CONTROLLERTOUCHPADUP) {
+            return 0;
+        }
+    }
 
     /* Update internal joystick state */
     finger_info->state = state;
@@ -2588,31 +2821,34 @@ int SDL_PrivateJoystickSensor(SDL_Joystick *joystick, SDL_SensorType type, const
     int i;
     int posted = 0;
 
+    /* We ignore events if we don't have keyboard focus */
+    if (SDL_PrivateJoystickShouldIgnoreEvent()) {
+        return 0;
+    }
+
     for (i = 0; i < joystick->nsensors; ++i) {
         SDL_JoystickSensorInfo *sensor = &joystick->sensors[i];
 
         if (sensor->type == type) {
             if (sensor->enabled) {
                 num_values = SDL_min(num_values, SDL_arraysize(sensor->data));
-                if (SDL_memcmp(data, sensor->data, num_values*sizeof(*data)) != 0) {
 
-                    /* Update internal sensor state */
-                    SDL_memcpy(sensor->data, data, num_values*sizeof(*data));
+                /* Update internal sensor state */
+                SDL_memcpy(sensor->data, data, num_values*sizeof(*data));
 
-                    /* Post the event, if desired */
+                /* Post the event, if desired */
 #if !SDL_EVENTS_DISABLED
-                    if (SDL_GetEventState(SDL_CONTROLLERSENSORUPDATE) == SDL_ENABLE) {
-                        SDL_Event event;
-                        event.type = SDL_CONTROLLERSENSORUPDATE;
-                        event.csensor.which = joystick->instance_id;
-                        event.csensor.sensor = type;
-                        num_values = SDL_min(num_values, SDL_arraysize(event.csensor.data));
-                        SDL_memset(event.csensor.data, 0, sizeof(event.csensor.data));
-                        SDL_memcpy(event.csensor.data, data, num_values*sizeof(*data));
-                        posted = SDL_PushEvent(&event) == 1;
-                    }
-#endif /* !SDL_EVENTS_DISABLED */
+                if (SDL_GetEventState(SDL_CONTROLLERSENSORUPDATE) == SDL_ENABLE) {
+                    SDL_Event event;
+                    event.type = SDL_CONTROLLERSENSORUPDATE;
+                    event.csensor.which = joystick->instance_id;
+                    event.csensor.sensor = type;
+                    num_values = SDL_min(num_values, SDL_arraysize(event.csensor.data));
+                    SDL_memset(event.csensor.data, 0, sizeof(event.csensor.data));
+                    SDL_memcpy(event.csensor.data, data, num_values*sizeof(*data));
+                    posted = SDL_PushEvent(&event) == 1;
                 }
+#endif /* !SDL_EVENTS_DISABLED */
             }
             break;
         }
diff --git a/Engine/lib/sdl/src/joystick/SDL_joystick_c.h b/Engine/lib/sdl/src/joystick/SDL_joystick_c.h
index de330aba0..312e11337 100644
--- a/Engine/lib/sdl/src/joystick/SDL_joystick_c.h
+++ b/Engine/lib/sdl/src/joystick/SDL_joystick_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -65,8 +65,11 @@ extern SDL_GameControllerType SDL_GetJoystickGameControllerType(const char *name
 /* Function to return whether a joystick is an Xbox One Elite controller */
 extern SDL_bool SDL_IsJoystickXboxOneElite(Uint16 vendor_id, Uint16 product_id);
 
-/* Function to return whether a joystick is an Xbox One Series X controller */
-extern SDL_bool SDL_IsJoystickXboxOneSeriesX(Uint16 vendor_id, Uint16 product_id);
+/* Function to return whether a joystick is an Xbox Series X controller */
+extern SDL_bool SDL_IsJoystickXboxSeriesX(Uint16 vendor_id, Uint16 product_id);
+
+/* Function to return whether a joystick is an Xbox One controller connected via Bluetooth */
+extern SDL_bool SDL_IsJoystickBluetoothXboxOne(Uint16 vendor_id, Uint16 product_id);
 
 /* Function to return whether a joystick is a PS4 controller */
 extern SDL_bool SDL_IsJoystickPS4(Uint16 vendor_id, Uint16 product_id);
@@ -77,6 +80,9 @@ extern SDL_bool SDL_IsJoystickPS5(Uint16 vendor_id, Uint16 product_id);
 /* Function to return whether a joystick is a Nintendo Switch Pro controller */
 extern SDL_bool SDL_IsJoystickNintendoSwitchPro(Uint16 vendor_id, Uint16 product_id);
 extern SDL_bool SDL_IsJoystickNintendoSwitchProInputOnly(Uint16 vendor_id, Uint16 product_id);
+extern SDL_bool SDL_IsJoystickNintendoSwitchJoyCon(Uint16 vendor_id, Uint16 product_id);
+extern SDL_bool SDL_IsJoystickNintendoSwitchJoyConLeft(Uint16 vendor_id, Uint16 product_id);
+extern SDL_bool SDL_IsJoystickNintendoSwitchJoyConRight(Uint16 vendor_id, Uint16 product_id);
 
 /* Function to return whether a joystick is a Steam Controller */
 extern SDL_bool SDL_IsJoystickSteamController(Uint16 vendor_id, Uint16 product_id);
@@ -110,7 +116,7 @@ extern void SDL_GameControllerHandleDelayedGuideButton(SDL_Joystick *joystick);
 
 /* Internal event queueing functions */
 extern void SDL_PrivateJoystickAddTouchpad(SDL_Joystick *joystick, int nfingers);
-extern void SDL_PrivateJoystickAddSensor(SDL_Joystick *joystick, SDL_SensorType type);
+extern void SDL_PrivateJoystickAddSensor(SDL_Joystick *joystick, SDL_SensorType type, float rate);
 extern void SDL_PrivateJoystickAdded(SDL_JoystickID device_instance);
 extern void SDL_PrivateJoystickRemoved(SDL_JoystickID device_instance);
 extern int SDL_PrivateJoystickAxis(SDL_Joystick *joystick,
diff --git a/Engine/lib/sdl/src/joystick/SDL_sysjoystick.h b/Engine/lib/sdl/src/joystick/SDL_sysjoystick.h
index 3ea7d39c1..8b8792179 100644
--- a/Engine/lib/sdl/src/joystick/SDL_sysjoystick.h
+++ b/Engine/lib/sdl/src/joystick/SDL_sysjoystick.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -24,7 +24,6 @@
 #define SDL_sysjoystick_h_
 
 /* This is the system specific header for the SDL joystick API */
-
 #include "SDL_joystick.h"
 #include "SDL_joystick_c.h"
 
@@ -37,6 +36,7 @@ typedef struct _SDL_JoystickAxisInfo
     SDL_bool has_initial_value; /* Whether we've seen a value on the axis yet */
     SDL_bool has_second_value;  /* Whether we've seen a second value on the axis yet */
     SDL_bool sent_initial_value; /* Whether we've sent the initial axis value */
+    SDL_bool sending_initial_value; /* Whether we are sending the initial axis value */
 } SDL_JoystickAxisInfo;
 
 typedef struct _SDL_JoystickTouchpadFingerInfo
@@ -57,6 +57,7 @@ typedef struct _SDL_JoystickSensorInfo
 {
     SDL_SensorType type;
     SDL_bool enabled;
+    float rate;
     float data[3];      /* If this needs to expand, update SDL_ControllerSensorEvent */
 } SDL_JoystickSensorInfo;
 
@@ -100,6 +101,7 @@ struct _SDL_Joystick
     Uint8 led_red;
     Uint8 led_green;
     Uint8 led_blue;
+    Uint32 led_expiration;
 
     SDL_bool attached;
     SDL_bool is_game_controller;
@@ -119,6 +121,11 @@ struct _SDL_Joystick
 #define SDL_HARDWARE_BUS_USB        0x03
 #define SDL_HARDWARE_BUS_BLUETOOTH  0x05
 
+/* Joystick capability flags for GetCapabilities() */
+#define SDL_JOYCAP_LED              0x01
+#define SDL_JOYCAP_RUMBLE           0x02
+#define SDL_JOYCAP_RUMBLE_TRIGGERS  0x04
+
 /* Macro to combine a USB vendor ID and product ID into a single Uint32 value */
 #define MAKE_VIDPID(VID, PID)   (((Uint32)(VID))<<16|(PID))
 
@@ -162,10 +169,15 @@ typedef struct _SDL_JoystickDriver
     int (*Rumble)(SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble);
     int (*RumbleTriggers)(SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble);
 
+    /* Capability detection */
+    Uint32 (*GetCapabilities)(SDL_Joystick *joystick);
+
     /* LED functionality */
-    SDL_bool (*HasLED)(SDL_Joystick *joystick);
     int (*SetLED)(SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue);
 
+    /* General effects */
+    int (*SendEffect)(SDL_Joystick *joystick, const void *data, int size);
+
     /* Sensor functionality */
     int (*SetSensorsEnabled)(SDL_Joystick *joystick, SDL_bool enabled);
 
@@ -190,6 +202,8 @@ typedef struct _SDL_JoystickDriver
 /* Windows and Mac OSX has a limit of MAX_DWORD / 1000, Linux kernel has a limit of 0xFFFF */
 #define SDL_MAX_RUMBLE_DURATION_MS  0xFFFF
 
+#define SDL_LED_MIN_REPEAT_MS  5000
+
 /* The available joystick drivers */
 extern SDL_JoystickDriver SDL_ANDROID_JoystickDriver;
 extern SDL_JoystickDriver SDL_BSD_JoystickDriver;
@@ -204,6 +218,10 @@ extern SDL_JoystickDriver SDL_LINUX_JoystickDriver;
 extern SDL_JoystickDriver SDL_VIRTUAL_JoystickDriver;
 extern SDL_JoystickDriver SDL_WGI_JoystickDriver;
 extern SDL_JoystickDriver SDL_WINDOWS_JoystickDriver;
+extern SDL_JoystickDriver SDL_WINMM_JoystickDriver;
+extern SDL_JoystickDriver SDL_OS2_JoystickDriver;
+extern SDL_JoystickDriver SDL_PSP_JoystickDriver;
+extern SDL_JoystickDriver SDL_VITA_JoystickDriver;
 
 #endif /* SDL_sysjoystick_h_ */
 
diff --git a/Engine/lib/sdl/src/joystick/android/SDL_sysjoystick.c b/Engine/lib/sdl/src/joystick/android/SDL_sysjoystick.c
index 9b949d382..aef014d16 100644
--- a/Engine/lib/sdl/src/joystick/android/SDL_sysjoystick.c
+++ b/Engine/lib/sdl/src/joystick/android/SDL_sysjoystick.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -103,6 +103,7 @@ keycode_to_SDL(int keycode)
         case AKEYCODE_BUTTON_THUMBR:
             button = SDL_CONTROLLER_BUTTON_RIGHTSTICK;
             break;
+        case AKEYCODE_MENU:
         case AKEYCODE_BUTTON_START:
             button = SDL_CONTROLLER_BUTTON_START;
             break;
@@ -581,7 +582,7 @@ ANDROID_JoystickGetDeviceInstanceID(int device_index)
 }
 
 static int
-ANDROID_JoystickOpen(SDL_Joystick * joystick, int device_index)
+ANDROID_JoystickOpen(SDL_Joystick *joystick, int device_index)
 {
     SDL_joylist_item *item = JoystickByDevIndex(device_index);
 
@@ -605,25 +606,31 @@ ANDROID_JoystickOpen(SDL_Joystick * joystick, int device_index)
 }
 
 static int
-ANDROID_JoystickRumble(SDL_Joystick * joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+ANDROID_JoystickRumble(SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
 {
     return SDL_Unsupported();
 }
 
 static int
-ANDROID_JoystickRumbleTriggers(SDL_Joystick * joystick, Uint16 left_rumble, Uint16 right_rumble)
+ANDROID_JoystickRumbleTriggers(SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
 {
     return SDL_Unsupported();
 }
 
-static SDL_bool
-ANDROID_JoystickHasLED(SDL_Joystick * joystick)
+static Uint32
+ANDROID_JoystickGetCapabilities(SDL_Joystick *joystick)
 {
-    return SDL_FALSE;
+    return 0;
 }
 
 static int
-ANDROID_JoystickSetLED(SDL_Joystick * joystick, Uint8 red, Uint8 green, Uint8 blue)
+ANDROID_JoystickSetLED(SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+    return SDL_Unsupported();
+}
+
+static int
+ANDROID_JoystickSendEffect(SDL_Joystick *joystick, const void *data, int size)
 {
     return SDL_Unsupported();
 }
@@ -635,7 +642,7 @@ ANDROID_JoystickSetSensorsEnabled(SDL_Joystick *joystick, SDL_bool enabled)
 }
 
 static void
-ANDROID_JoystickUpdate(SDL_Joystick * joystick)
+ANDROID_JoystickUpdate(SDL_Joystick *joystick)
 {
     SDL_joylist_item *item = (SDL_joylist_item *) joystick->hwdata;
 
@@ -664,7 +671,7 @@ ANDROID_JoystickUpdate(SDL_Joystick * joystick)
 }
 
 static void
-ANDROID_JoystickClose(SDL_Joystick * joystick)
+ANDROID_JoystickClose(SDL_Joystick *joystick)
 {
     SDL_joylist_item *item = (SDL_joylist_item *) joystick->hwdata;
     if (item) {
@@ -713,8 +720,9 @@ SDL_JoystickDriver SDL_ANDROID_JoystickDriver =
     ANDROID_JoystickOpen,
     ANDROID_JoystickRumble,
     ANDROID_JoystickRumbleTriggers,
-    ANDROID_JoystickHasLED,
+    ANDROID_JoystickGetCapabilities,
     ANDROID_JoystickSetLED,
+    ANDROID_JoystickSendEffect,
     ANDROID_JoystickSetSensorsEnabled,
     ANDROID_JoystickUpdate,
     ANDROID_JoystickClose,
diff --git a/Engine/lib/sdl/src/joystick/android/SDL_sysjoystick_c.h b/Engine/lib/sdl/src/joystick/android/SDL_sysjoystick_c.h
index 92ae64acf..881c8aa41 100644
--- a/Engine/lib/sdl/src/joystick/android/SDL_sysjoystick_c.h
+++ b/Engine/lib/sdl/src/joystick/android/SDL_sysjoystick_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/joystick/bsd/SDL_bsdjoystick.c b/Engine/lib/sdl/src/joystick/bsd/SDL_bsdjoystick.c
index 60d779938..f8859a534 100644
--- a/Engine/lib/sdl/src/joystick/bsd/SDL_bsdjoystick.c
+++ b/Engine/lib/sdl/src/joystick/bsd/SDL_bsdjoystick.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -69,7 +69,7 @@
 #include <sys/joystick.h>
 #endif
 
-#if SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H
+#if SDL_HAVE_MACHINE_JOYSTICK_H
 #include <machine/joystick.h>
 #endif
 
@@ -240,7 +240,7 @@ BSD_JoystickInit(void)
     }
     for (i = 0; i < MAX_JOY_JOYS; i++) {
         SDL_snprintf(s, SDL_arraysize(s), "/dev/joy%d", i);
-        fd = open(s, O_RDONLY);
+        fd = open(s, O_RDONLY | O_CLOEXEC);
         if (fd != -1) {
             joynames[numjoysticks++] = SDL_strdup(s);
             close(fd);
@@ -357,7 +357,7 @@ BSD_JoystickOpen(SDL_Joystick *joy, int device_index)
     int fd;
     int i;
 
-    fd = open(path, O_RDONLY);
+    fd = open(path, O_RDONLY | O_CLOEXEC);
     if (fd == -1) {
         return SDL_SetError("%s: %s", path, strerror(errno));
     }
@@ -426,7 +426,7 @@ BSD_JoystickOpen(SDL_Joystick *joy, int device_index)
             str[i] = UGETW(usd.usd_desc.bString[i]);
         }
         str[i] = '\0';
-        asprintf(&new_name, "%s @ %s", str, path);
+        SDL_asprintf(&new_name, "%s @ %s", str, path);
         if (new_name != NULL) {
             SDL_free(joydevnames[numjoysticks]);
             joydevnames[numjoysticks] = new_name;
@@ -546,13 +546,13 @@ BSD_JoystickUpdate(SDL_Joystick *joy)
     Sint32 dpad[4] = {0, 0, 0, 0};
 #endif
 
-#if defined(__FREEBSD__) || SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H || defined(__FreeBSD_kernel__) || defined(__DragonFly_)
+#if defined(__FREEBSD__) || SDL_HAVE_MACHINE_JOYSTICK_H || defined(__FreeBSD_kernel__) || defined(__DragonFly_)
     struct joystick gameport;
     static int x, y, xmin = 0xffff, ymin = 0xffff, xmax = 0, ymax = 0;
 
     if (joy->hwdata->type == BSDJOY_JOY) {
         while (read(joy->hwdata->fd, &gameport, sizeof gameport) == sizeof gameport) {
-            if (abs(x - gameport.x) > 8) {
+            if (SDL_abs(x - gameport.x) > 8) {
                 x = gameport.x;
                 if (x < xmin) {
                     xmin = x;
@@ -569,7 +569,7 @@ BSD_JoystickUpdate(SDL_Joystick *joy)
                 v *= 32768 / ((xmax - xmin + 1) / 2);
                 SDL_PrivateJoystickAxis(joy, 0, v);
             }
-            if (abs(y - gameport.y) > 8) {
+            if (SDL_abs(y - gameport.y) > 8) {
                 y = gameport.y;
                 if (y < ymin) {
                     ymin = y;
@@ -591,7 +591,7 @@ BSD_JoystickUpdate(SDL_Joystick *joy)
         }
         return;
     }
-#endif /* defined(__FREEBSD__) || SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H */
+#endif /* defined(__FREEBSD__) || SDL_HAVE_MACHINE_JOYSTICK_H */
 
     rep = &joy->hwdata->inreport;
 
@@ -777,10 +777,10 @@ BSD_JoystickGetGamepadMapping(int device_index, SDL_GamepadMapping *out)
     return SDL_FALSE;
 }
 
-static SDL_bool
-BSD_JoystickHasLED(SDL_Joystick *joystick)
+static Uint32
+BSD_JoystickGetCapabilities(SDL_Joystick *joystick)
 {
-    return SDL_FALSE;
+    return 0;
 }
 
 static int
@@ -789,6 +789,12 @@ BSD_JoystickSetLED(SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
     return SDL_Unsupported();
 }
 
+static int
+BSD_JoystickSendEffect(SDL_Joystick *joystick, const void *data, int size)
+{
+    return SDL_Unsupported();
+}
+
 static int
 BSD_JoystickSetSensorsEnabled(SDL_Joystick *joystick, SDL_bool enabled)
 {
@@ -808,8 +814,9 @@ SDL_JoystickDriver SDL_BSD_JoystickDriver =
     BSD_JoystickOpen,
     BSD_JoystickRumble,
     BSD_JoystickRumbleTriggers,
-    BSD_JoystickHasLED,
+    BSD_JoystickGetCapabilities,
     BSD_JoystickSetLED,
+    BSD_JoystickSendEffect,
     BSD_JoystickSetSensorsEnabled,
     BSD_JoystickUpdate,
     BSD_JoystickClose,
diff --git a/Engine/lib/sdl/src/joystick/controller_type.h b/Engine/lib/sdl/src/joystick/controller_type.h
index 224526fd8..26950345c 100644
--- a/Engine/lib/sdl/src/joystick/controller_type.h
+++ b/Engine/lib/sdl/src/joystick/controller_type.h
@@ -51,7 +51,7 @@ typedef enum
 	k_eControllerType_SwitchJoyConLeft = 39,
 	k_eControllerType_SwitchJoyConRight = 40,
 	k_eControllerType_SwitchJoyConPair = 41,
-    k_eControllerType_SwitchInputOnlyController = 42,
+	k_eControllerType_SwitchInputOnlyController = 42,
 	k_eControllerType_MobileTouch = 43,
 	k_eControllerType_XInputSwitchController = 44,  // Client-side only, used to mark Switch-compatible controllers as not supporting Switch controller protocol
 	k_eControllerType_PS5Controller = 45,
@@ -160,7 +160,7 @@ static const ControllerDescription_t arrControllers[] = {
 	{ MAKE_CONTROLLER_ID( 0x1532, 0x1009 ), k_eControllerType_PS4Controller, NULL },	// Razer Raiju 2 Ultimate BT
 	{ MAKE_CONTROLLER_ID( 0x1532, 0x100A ), k_eControllerType_PS4Controller, NULL },	// Razer Raiju 2 Tournament edition BT
 	{ MAKE_CONTROLLER_ID( 0x1532, 0x1100 ), k_eControllerType_PS4Controller, NULL },	// Razer RAION Fightpad - Trackpad, no gyro, lightbar hardcoded to green
-	{ MAKE_CONTROLLER_ID( 0x20d6, 0x792a ), k_eControllerType_PS4Controller, NULL },	// PowerA - Fusion Fight Pad
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0x792a ), k_eControllerType_PS4Controller, NULL },	// PowerA Fusion Fight Pad
 	{ MAKE_CONTROLLER_ID( 0x7545, 0x0104 ), k_eControllerType_PS4Controller, NULL },	// Armor 3 or Level Up Cobra - At least one variant has gyro
 	{ MAKE_CONTROLLER_ID( 0x9886, 0x0025 ), k_eControllerType_PS4Controller, NULL },	// Astro C40
 	{ MAKE_CONTROLLER_ID( 0x0e6f, 0x0207 ), k_eControllerType_PS4Controller, NULL },	// Victrix Pro Fightstick w/ Touchpad for PS4
@@ -175,18 +175,20 @@ static const ControllerDescription_t arrControllers[] = {
 	{ MAKE_CONTROLLER_ID( 0x146b, 0x1103 ), k_eControllerType_PS4Controller, NULL },	// NACON Asymetrical Controller -- on windows this doesn't enumerate
 	{ MAKE_CONTROLLER_ID( 0x0f0d, 0x0123 ), k_eControllerType_PS4Controller, NULL },	// HORI Wireless Controller Light (Japan only) - only over bt- over usb is xbox and pid 0x0124
 	{ MAKE_CONTROLLER_ID( 0x146b, 0x0d13 ), k_eControllerType_PS4Controller, NULL },	// NACON Revolution 3
+	{ MAKE_CONTROLLER_ID( 0x0c12, 0x0e20 ), k_eControllerType_PS4Controller, NULL },	// Brook Mars Controller - needs FW update to show up as Ps4 controller on PC. Has Gyro but touchpad is a single button.
 
 	{ MAKE_CONTROLLER_ID( 0x054c, 0x0ce6 ), k_eControllerType_PS5Controller, NULL },	// Sony PS5 Controller
 
 	{ MAKE_CONTROLLER_ID( 0x0079, 0x0006 ), k_eControllerType_UnknownNonSteamController, NULL },	// DragonRise Generic USB PCB, sometimes configured as a PC Twin Shock Controller - looks like a DS3 but the face buttons are 1-4 instead of symbols
 
 	{ MAKE_CONTROLLER_ID( 0x0079, 0x18d4 ), k_eControllerType_XBox360Controller, NULL },	// GPD Win 2 X-Box Controller
+	{ MAKE_CONTROLLER_ID( 0x03eb, 0xff02 ), k_eControllerType_XBox360Controller, NULL },	// Wooting Two
 	{ MAKE_CONTROLLER_ID( 0x044f, 0xb326 ), k_eControllerType_XBox360Controller, NULL },	// Thrustmaster Gamepad GP XID
 	{ MAKE_CONTROLLER_ID( 0x045e, 0x028e ), k_eControllerType_XBox360Controller, "Xbox 360 Controller" },	// Microsoft X-Box 360 pad
 	{ MAKE_CONTROLLER_ID( 0x045e, 0x028f ), k_eControllerType_XBox360Controller, "Xbox 360 Controller" },	// Microsoft X-Box 360 pad v2
 	{ MAKE_CONTROLLER_ID( 0x045e, 0x0291 ), k_eControllerType_XBox360Controller, "Xbox 360 Wireless Controller" },	// Xbox 360 Wireless Receiver (XBOX)
 	{ MAKE_CONTROLLER_ID( 0x045e, 0x02a0 ), k_eControllerType_XBox360Controller, NULL },	// Microsoft X-Box 360 Big Button IR
-	{ MAKE_CONTROLLER_ID( 0x045e, 0x02a1 ), k_eControllerType_XBox360Controller, NULL },	// Microsoft X-Box 360 pad
+	{ MAKE_CONTROLLER_ID( 0x045e, 0x02a1 ), k_eControllerType_XBox360Controller, NULL },	// Microsoft X-Box 360 Wireless Controller with XUSB driver on Windows
 	{ MAKE_CONTROLLER_ID( 0x045e, 0x02a9 ), k_eControllerType_XBox360Controller, "Xbox 360 Wireless Controller" },	// Xbox 360 Wireless Receiver (third party knockoff)
 	{ MAKE_CONTROLLER_ID( 0x045e, 0x0719 ), k_eControllerType_XBox360Controller, "Xbox 360 Wireless Controller" },	// Xbox 360 Wireless Receiver
 	{ MAKE_CONTROLLER_ID( 0x046d, 0xc21d ), k_eControllerType_XBox360Controller, NULL },	// Logitech Gamepad F310
@@ -254,6 +256,7 @@ static const ControllerDescription_t arrControllers[] = {
 	{ MAKE_CONTROLLER_ID( 0x1689, 0xfd00 ), k_eControllerType_XBox360Controller, NULL },	// Razer Onza Tournament Edition
 	{ MAKE_CONTROLLER_ID( 0x1689, 0xfd01 ), k_eControllerType_XBox360Controller, NULL },	// Razer Onza Classic Edition
 	{ MAKE_CONTROLLER_ID( 0x1689, 0xfe00 ), k_eControllerType_XBox360Controller, NULL },	// Razer Sabertooth
+	{ MAKE_CONTROLLER_ID( 0x1949, 0x041a ), k_eControllerType_XBox360Controller, "Amazon Luna Controller" },	// Amazon Luna Controller
 	{ MAKE_CONTROLLER_ID( 0x1bad, 0x0002 ), k_eControllerType_XBox360Controller, NULL },	// Harmonix Rock Band Guitar
 	{ MAKE_CONTROLLER_ID( 0x1bad, 0x0003 ), k_eControllerType_XBox360Controller, NULL },	// Harmonix Rock Band Drumkit
 	{ MAKE_CONTROLLER_ID( 0x1bad, 0xf016 ), k_eControllerType_XBox360Controller, NULL },	// Mad Catz Xbox 360 Controller
@@ -320,11 +323,17 @@ static const ControllerDescription_t arrControllers[] = {
 	{ MAKE_CONTROLLER_ID( 0x045e, 0x02e3 ), k_eControllerType_XBoxOneController, "Xbox One Elite Controller" },	// Microsoft X-Box One Elite pad
 	{ MAKE_CONTROLLER_ID( 0x045e, 0x02ea ), k_eControllerType_XBoxOneController, "Xbox One S Controller" },	// Microsoft X-Box One S pad
 	{ MAKE_CONTROLLER_ID( 0x045e, 0x02fd ), k_eControllerType_XBoxOneController, "Xbox One S Controller" },	// Microsoft X-Box One S pad (Bluetooth)
-	{ MAKE_CONTROLLER_ID( 0x045e, 0x02ff ), k_eControllerType_XBoxOneController, NULL },	// Microsoft X-Box One controller with the RAWINPUT driver on Windows
+	{ MAKE_CONTROLLER_ID( 0x045e, 0x02ff ), k_eControllerType_XBoxOneController, NULL },	// Microsoft X-Box One controller with XBOXGIP driver on Windows
 	{ MAKE_CONTROLLER_ID( 0x045e, 0x0b00 ), k_eControllerType_XBoxOneController, "Xbox One Elite 2 Controller" },	// Microsoft X-Box One Elite Series 2 pad
+	{ MAKE_CONTROLLER_ID( 0x045e, 0x0b02 ), k_eControllerType_XBoxOneController, "Xbox One Elite 2 Controller" },	// Microsoft X-Box One Elite Series 2 pad (Bluetooth)
 	{ MAKE_CONTROLLER_ID( 0x045e, 0x0b05 ), k_eControllerType_XBoxOneController, "Xbox One Elite 2 Controller" },	// Microsoft X-Box One Elite Series 2 pad (Bluetooth)
-	{ MAKE_CONTROLLER_ID( 0x045e, 0x0b12 ), k_eControllerType_XBoxOneController, "Xbox One Series X Controller" },	// Microsoft X-Box One Elite Series X pad
-	{ MAKE_CONTROLLER_ID( 0x045e, 0x0b13 ), k_eControllerType_XBoxOneController, "Xbox One Series X Controller" },	// Microsoft X-Box One Elite Series X pad (Bluetooth)
+	{ MAKE_CONTROLLER_ID( 0x045e, 0x0b0a ), k_eControllerType_XBoxOneController, "Xbox Adaptive Controller" },	// Microsoft X-Box Adaptive pad
+	{ MAKE_CONTROLLER_ID( 0x045e, 0x0b0c ), k_eControllerType_XBoxOneController, "Xbox Adaptive Controller" },	// Microsoft X-Box Adaptive pad (Bluetooth)
+	{ MAKE_CONTROLLER_ID( 0x045e, 0x0b12 ), k_eControllerType_XBoxOneController, "Xbox Series X Controller" },	// Microsoft X-Box Series X pad
+	{ MAKE_CONTROLLER_ID( 0x045e, 0x0b13 ), k_eControllerType_XBoxOneController, "Xbox Series X Controller" },	// Microsoft X-Box Series X pad (BLE)
+	{ MAKE_CONTROLLER_ID( 0x045e, 0x0b20 ), k_eControllerType_XBoxOneController, "Xbox One S Controller" },	// Microsoft X-Box One S pad (BLE)
+	{ MAKE_CONTROLLER_ID( 0x045e, 0x0b21 ), k_eControllerType_XBoxOneController, "Xbox Adaptive Controller" },	// Microsoft X-Box Adaptive pad (BLE)
+	{ MAKE_CONTROLLER_ID( 0x045e, 0x0b22 ), k_eControllerType_XBoxOneController, "Xbox One Elite 2 Controller" },	// Microsoft X-Box One Elite Series 2 pad (BLE)
 	{ MAKE_CONTROLLER_ID( 0x0738, 0x4a01 ), k_eControllerType_XBoxOneController, NULL },	// Mad Catz FightStick TE 2
 	{ MAKE_CONTROLLER_ID( 0x0e6f, 0x0139 ), k_eControllerType_XBoxOneController, "PDP Xbox One Afterglow" },	// PDP Afterglow Wired Controller for Xbox One
 	{ MAKE_CONTROLLER_ID( 0x0e6f, 0x013B ), k_eControllerType_XBoxOneController, "PDP Xbox One Face-Off Controller" },	// PDP Face-Off Gamepad for Xbox One
@@ -390,6 +399,9 @@ static const ControllerDescription_t arrControllers[] = {
 	{ MAKE_CONTROLLER_ID( 0x0e6f, 0x02d5 ), k_eControllerType_XBoxOneController, "PDP Xbox One Red Camo" },	// PDP Wired Controller for Xbox One - Red Camo
 	{ MAKE_CONTROLLER_ID( 0x0e6f, 0x0346 ), k_eControllerType_XBoxOneController, "PDP Xbox One RC Gamepad" },	// PDP RC Gamepad for Xbox One
 	{ MAKE_CONTROLLER_ID( 0x0e6f, 0x0446 ), k_eControllerType_XBoxOneController, "PDP Xbox One RC Gamepad" },	// PDP RC Gamepad for Xbox One
+	{ MAKE_CONTROLLER_ID( 0x0e6f, 0x02da ), k_eControllerType_XBoxOneController, "PDP Xbox Series X Afterglow" },	// PDP Xbox Series X Afterglow
+	{ MAKE_CONTROLLER_ID( 0x0e6f, 0x02d6 ), k_eControllerType_XBoxOneController, "Victrix Gambit Tournament Controller" },	// Victrix Gambit Tournament Controller
+	{ MAKE_CONTROLLER_ID( 0x0e6f, 0x02d9 ), k_eControllerType_XBoxOneController, "PDP Xbox Series X Midnight Blue" },	// PDP Xbox Series X Midnight Blue
 	{ MAKE_CONTROLLER_ID( 0x0f0d, 0x0063 ), k_eControllerType_XBoxOneController, NULL },	// Hori Real Arcade Pro Hayabusa (USA) Xbox One
 	{ MAKE_CONTROLLER_ID( 0x0f0d, 0x0067 ), k_eControllerType_XBoxOneController, NULL },	// HORIPAD ONE
 	{ MAKE_CONTROLLER_ID( 0x0f0d, 0x0078 ), k_eControllerType_XBoxOneController, NULL },	// Hori Real Arcade Pro V Kai Xbox One
@@ -397,9 +409,33 @@ static const ControllerDescription_t arrControllers[] = {
 	{ MAKE_CONTROLLER_ID( 0x1532, 0x0a00 ), k_eControllerType_XBoxOneController, NULL },	// Razer Atrox Arcade Stick
 	{ MAKE_CONTROLLER_ID( 0x1532, 0x0a03 ), k_eControllerType_XBoxOneController, NULL },	// Razer Wildcat
 	{ MAKE_CONTROLLER_ID( 0x1532, 0x0a14 ), k_eControllerType_XBoxOneController, NULL },	// Razer Wolverine Ultimate
+	{ MAKE_CONTROLLER_ID( 0x1532, 0x0a15 ), k_eControllerType_XBoxOneController, NULL },	// Razer Wolverine Tournament Edition
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0x2001 ), k_eControllerType_XBoxOneController, "PowerA Xbox Series X Controller" },       // PowerA Xbox Series X EnWired Controller - Black Inline
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0x2002 ), k_eControllerType_XBoxOneController, "PowerA Xbox Series X Controller" },       // PowerA Xbox Series X EnWired Controller Gray/White Inline
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0x2003 ), k_eControllerType_XBoxOneController, "PowerA Xbox Series X Controller" },       // PowerA Xbox Series X EnWired Controller Green Inline
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0x2004 ), k_eControllerType_XBoxOneController, "PowerA Xbox Series X Controller" },       // PowerA Xbox Series X EnWired Controller Pink inline
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0x2005 ), k_eControllerType_XBoxOneController, "PowerA Xbox Series X Controller" },       // PowerA Xbox Series X Wired Controller Core - Black
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0x2006 ), k_eControllerType_XBoxOneController, "PowerA Xbox Series X Controller" },       // PowerA Xbox Series X Wired Controller Core - White
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0x2009 ), k_eControllerType_XBoxOneController, "PowerA Xbox Series X Controller" },       // PowerA Xbox Series X EnWired Controller Red inline
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0x200a ), k_eControllerType_XBoxOneController, "PowerA Xbox Series X Controller" },       // PowerA Xbox Series X EnWired Controller Blue inline
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0x200b ), k_eControllerType_XBoxOneController, "PowerA Xbox Series X Controller" },       // PowerA Xbox Series X EnWired Controller Camo Metallic Red
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0x200c ), k_eControllerType_XBoxOneController, "PowerA Xbox Series X Controller" },       // PowerA Xbox Series X EnWired Controller Camo Metallic Blue
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0x200d ), k_eControllerType_XBoxOneController, "PowerA Xbox Series X Controller" },       // PowerA Xbox Series X EnWired Controller Seafoam Fade
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0x200e ), k_eControllerType_XBoxOneController, "PowerA Xbox Series X Controller" },       // PowerA Xbox Series X EnWired Controller Midnight Blue
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0x200f ), k_eControllerType_XBoxOneController, "PowerA Xbox Series X Controller" },       // PowerA Xbox Series X EnWired Soldier Green
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0x2011 ), k_eControllerType_XBoxOneController, "PowerA Xbox Series X Controller" },       // PowerA Xbox Series X EnWired - Metallic Ice
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0x2012 ), k_eControllerType_XBoxOneController, "PowerA Xbox Series X Controller" },       // PowerA Xbox Series X Cuphead EnWired Controller - Mugman
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0x2015 ), k_eControllerType_XBoxOneController, "PowerA Xbox Series X Controller" },       // PowerA Xbox Series X EnWired Controller - Blue Hint
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0x2016 ), k_eControllerType_XBoxOneController, "PowerA Xbox Series X Controller" },       // PowerA Xbox Series X EnWired Controller - Green Hint
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0x2017 ), k_eControllerType_XBoxOneController, "PowerA Xbox Series X Controller" },       // PowerA Xbox Series X EnWired Cntroller - Arctic Camo
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0x2018 ), k_eControllerType_XBoxOneController, "PowerA Xbox Series X Controller" },       // PowerA Xbox Series X EnWired Controller Arc Lightning
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0x2019 ), k_eControllerType_XBoxOneController, "PowerA Xbox Series X Controller" },       // PowerA Xbox Series X EnWired Controller Royal Purple
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0x201a ), k_eControllerType_XBoxOneController, "PowerA Xbox Series X Controller" },       // PowerA Xbox Series X EnWired Controller Nebula
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0x4001 ), k_eControllerType_XBoxOneController, "PowerA Fusion Pro 2 Controller" },	// PowerA Fusion Pro 2 Wired Controller (Xbox Series X style)
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0x4002 ), k_eControllerType_XBoxOneController, "PowerA Spectra Infinity Controller" },	// PowerA Spectra Infinity Wired Controller (Xbox Series X style)
 	{ MAKE_CONTROLLER_ID( 0x24c6, 0x541a ), k_eControllerType_XBoxOneController, NULL },	// PowerA Xbox One Mini Wired Controller
 	{ MAKE_CONTROLLER_ID( 0x24c6, 0x542a ), k_eControllerType_XBoxOneController, NULL },	// Xbox ONE spectra
-	{ MAKE_CONTROLLER_ID( 0x24c6, 0x543a ), k_eControllerType_XBoxOneController, "PowerA XBox One Controller" },	// PowerA Xbox ONE liquid metal controller
+	{ MAKE_CONTROLLER_ID( 0x24c6, 0x543a ), k_eControllerType_XBoxOneController, "PowerA Xbox One Controller" },	// PowerA Xbox ONE liquid metal controller
 	{ MAKE_CONTROLLER_ID( 0x24c6, 0x551a ), k_eControllerType_XBoxOneController, NULL },	// PowerA FUSION Pro Controller
 	{ MAKE_CONTROLLER_ID( 0x24c6, 0x561a ), k_eControllerType_XBoxOneController, NULL },	// PowerA FUSION Controller
 	{ MAKE_CONTROLLER_ID( 0x24c6, 0x581a ), k_eControllerType_XBoxOneController, NULL },	// BDA XB1 Classic Controller
@@ -450,7 +486,6 @@ static const ControllerDescription_t arrControllers[] = {
 	{ MAKE_CONTROLLER_ID( 0x2f24, 0x91 ), k_eControllerType_XBoxOneController, NULL },	// Unknown Controller
 	{ MAKE_CONTROLLER_ID( 0x1430, 0x719 ), k_eControllerType_XBoxOneController, NULL },	// Unknown Controller
 	{ MAKE_CONTROLLER_ID( 0xf0d, 0xed ), k_eControllerType_XBoxOneController, NULL },	// Unknown Controller
-	{ MAKE_CONTROLLER_ID( 0x3eb, 0xff02 ), k_eControllerType_XBoxOneController, NULL },	// Unknown Controller
 	{ MAKE_CONTROLLER_ID( 0xf0d, 0xc0 ), k_eControllerType_XBoxOneController, NULL },	// Unknown Controller
 	{ MAKE_CONTROLLER_ID( 0xe6f, 0x152 ), k_eControllerType_XBoxOneController, NULL },	// Unknown Controller
 	{ MAKE_CONTROLLER_ID( 0xe6f, 0x2a7 ), k_eControllerType_XBoxOneController, NULL },	// Unknown Controller
@@ -516,17 +551,19 @@ static const ControllerDescription_t arrControllers[] = {
 	{ MAKE_CONTROLLER_ID( 0xf0d,	0xd8 ), k_eControllerType_XBoxOneController, NULL },	// Unknown Controller
 	{ MAKE_CONTROLLER_ID( 0xfff,	0x2a1 ), k_eControllerType_XBoxOneController, NULL },	// Unknown Controller
 	{ MAKE_CONTROLLER_ID( 0x45e,	0x867 ), k_eControllerType_XBoxOneController, NULL },	// Unknown Controller
-
+	// Added 12-17-2020
+	{ MAKE_CONTROLLER_ID( 0x16d0,	0xf3f ), k_eControllerType_XBoxOneController, NULL },	// Unknown Controller
+	{ MAKE_CONTROLLER_ID( 0x2f24,	0x8f ), k_eControllerType_XBoxOneController, NULL },	// Unknown Controller
+	{ MAKE_CONTROLLER_ID( 0xe6f,	0xf501 ), k_eControllerType_XBoxOneController, NULL },	// Unknown Controller
+																							
 	//{ MAKE_CONTROLLER_ID( 0x1949, 0x0402 ), /*android*/, NULL },	// Unknown Controller
 
 	{ MAKE_CONTROLLER_ID( 0x05ac, 0x0001 ), k_eControllerType_AppleController, NULL },	// MFI Extended Gamepad (generic entry for iOS/tvOS)
 	{ MAKE_CONTROLLER_ID( 0x05ac, 0x0002 ), k_eControllerType_AppleController, NULL },	// MFI Standard Gamepad (generic entry for iOS/tvOS)
 
-    // We currently don't support using a pair of Switch Joy-Con's as a single
-    // controller and we don't want to support using them individually for the
-    // time being, so these should be disabled until one of the above is true
-    // { MAKE_CONTROLLER_ID( 0x057e, 0x2006 ), k_eControllerType_SwitchJoyConLeft, NULL },    // Nintendo Switch Joy-Con (Left)
-    // { MAKE_CONTROLLER_ID( 0x057e, 0x2007 ), k_eControllerType_SwitchJoyConRight, NULL },   // Nintendo Switch Joy-Con (Right)
+    // We now support Joy-Cons if SDL_HINT_JOYSTICK_HIDAPI_JOY_CONS is set to "1", but they won't be combined into one controller.
+    { MAKE_CONTROLLER_ID( 0x057e, 0x2006 ), k_eControllerType_SwitchJoyConLeft, NULL },    // Nintendo Switch Joy-Con (Left)
+    { MAKE_CONTROLLER_ID( 0x057e, 0x2007 ), k_eControllerType_SwitchJoyConRight, NULL },   // Nintendo Switch Joy-Con (Right)
 
     // This same controller ID is spoofed by many 3rd-party Switch controllers.
     // The ones we currently know of are:
@@ -544,19 +581,22 @@ static const ControllerDescription_t arrControllers[] = {
 #else
 	{ MAKE_CONTROLLER_ID( 0x0f0d, 0x00dc ), k_eControllerType_SwitchProController, "HORI Fighting Commander" },
 #endif
-	{ MAKE_CONTROLLER_ID( 0x0e6f, 0x0185 ), k_eControllerType_SwitchInputOnlyController, NULL },  // PDP Wired Fight Pad Pro for Nintendo Switch
 	{ MAKE_CONTROLLER_ID( 0x0e6f, 0x0180 ), k_eControllerType_SwitchInputOnlyController, NULL },  // PDP Faceoff Wired Pro Controller for Nintendo Switch
 	{ MAKE_CONTROLLER_ID( 0x0e6f, 0x0181 ), k_eControllerType_SwitchInputOnlyController, NULL },  // PDP Faceoff Deluxe Wired Pro Controller for Nintendo Switch
-	{ MAKE_CONTROLLER_ID( 0x20d6, 0xa711 ), k_eControllerType_SwitchInputOnlyController, NULL },  // PowerA Wired Controller Plus/PowerA Wired Controller Nintendo GameCube Style
-	{ MAKE_CONTROLLER_ID( 0x20d6, 0xa712 ), k_eControllerType_SwitchInputOnlyController, NULL },  // PowerA - Fusion Fight Pad
-	{ MAKE_CONTROLLER_ID( 0x20d6, 0xa713 ), k_eControllerType_SwitchInputOnlyController, NULL },  // PowerA - Super Mario Controller
-	{ MAKE_CONTROLLER_ID( 0x0e6f, 0x0186 ), k_eControllerType_SwitchProController, NULL },  // PDP Afterglow Wireless Switch Controller - working gyro. USB doesn't work
 	{ MAKE_CONTROLLER_ID( 0x0e6f, 0x0184 ), k_eControllerType_SwitchInputOnlyController, NULL },  // PDP Faceoff Wired Deluxe+ Audio Controller
-	{ MAKE_CONTROLLER_ID( 0x0f0d, 0x00aa ), k_eControllerType_SwitchInputOnlyController, NULL },  // HORI Real Arcade Pro V Hayabusa in Switch Mode
+	{ MAKE_CONTROLLER_ID( 0x0e6f, 0x0185 ), k_eControllerType_SwitchInputOnlyController, NULL },  // PDP Wired Fight Pad Pro for Nintendo Switch
+	{ MAKE_CONTROLLER_ID( 0x0e6f, 0x0186 ), k_eControllerType_SwitchProController, NULL },        // PDP Afterglow Wireless Switch Controller - working gyro. USB is for charging only. Many later "Wireless" line devices w/ gyro also use this vid/pid
+	{ MAKE_CONTROLLER_ID( 0x0e6f, 0x0187 ), k_eControllerType_SwitchInputOnlyController, NULL },  // PDP Rockcandy Wired Controller
 	{ MAKE_CONTROLLER_ID( 0x0e6f, 0x0188 ), k_eControllerType_SwitchInputOnlyController, NULL },  // PDP Afterglow Wired Deluxe+ Audio Controller
-	{ MAKE_CONTROLLER_ID( 0x0e6f, 0x0187 ), k_eControllerType_SwitchInputOnlyController, NULL },  // PDP Rockcandy Wirec Controller
+	{ MAKE_CONTROLLER_ID( 0x0f0d, 0x00aa ), k_eControllerType_SwitchInputOnlyController, NULL },  // HORI Real Arcade Pro V Hayabusa in Switch Mode
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0xa711 ), k_eControllerType_SwitchInputOnlyController, NULL },  // PowerA Wired Controller Plus/PowerA Wired Controller Nintendo GameCube Style
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0xa712 ), k_eControllerType_SwitchInputOnlyController, NULL },  // PowerA Nintendo Switch Fusion Fight Pad
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0xa713 ), k_eControllerType_SwitchInputOnlyController, NULL },  // PowerA Super Mario Controller
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0xa714 ), k_eControllerType_SwitchInputOnlyController, NULL },  // PowerA Nintendo Switch Spectra Controller
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0xa715 ), k_eControllerType_SwitchInputOnlyController, NULL },  // Power A Fusion Wireless Arcade Stick (USB Mode) Over BT is shows up as 057e 2009
+	{ MAKE_CONTROLLER_ID( 0x20d6, 0xa716 ), k_eControllerType_SwitchInputOnlyController, NULL },  // PowerA Nintendo Switch Fusion Pro Controller - USB requires toggling switch on back of device
 
-	// Valve products - don't add to public list
+	// Valve products
 	{ MAKE_CONTROLLER_ID( 0x0000, 0x11fb ), k_eControllerType_MobileTouch, NULL },	// Streaming mobile touch virtual controls
 	{ MAKE_CONTROLLER_ID( 0x28de, 0x1101 ), k_eControllerType_SteamController, NULL },	// Valve Legacy Steam Controller (CHELL)
 	{ MAKE_CONTROLLER_ID( 0x28de, 0x1102 ), k_eControllerType_SteamController, NULL },	// Valve wired Steam Controller (D0G)
@@ -691,11 +731,11 @@ static SDL_INLINE int GetDefaultDeadzoneSizeForControllerType( EControllerType e
 	case k_eControllerType_AppleController:
 	case k_eControllerType_AndroidController:
 	case k_eControllerType_PS3Controller:
+	case k_eControllerType_PS5Controller:
 		return 10000;
 	case k_eControllerType_SteamControllerV2:
 		return 8192;
 	case k_eControllerType_PS4Controller:
-	case k_eControllerType_PS5Controller:
 		return 4096;
 	case k_eControllerType_SwitchJoyConLeft:
 	case k_eControllerType_SwitchJoyConRight:
diff --git a/Engine/lib/sdl/src/joystick/darwin/SDL_iokitjoystick.c b/Engine/lib/sdl/src/joystick/darwin/SDL_iokitjoystick.c
index 423f85740..7f2514728 100644
--- a/Engine/lib/sdl/src/joystick/darwin/SDL_iokitjoystick.c
+++ b/Engine/lib/sdl/src/joystick/darwin/SDL_iokitjoystick.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -152,14 +152,17 @@ FreeDevice(recDevice *removeDevice)
         /* save next device prior to disposing of this device */
         pDeviceNext = removeDevice->pNext;
 
-        if ( gpDeviceList == removeDevice ) {
+        if (gpDeviceList == removeDevice) {
             gpDeviceList = pDeviceNext;
         } else if (gpDeviceList) {
-            recDevice *device = gpDeviceList;
-            while (device->pNext != removeDevice) {
-                device = device->pNext;
+            recDevice *device;
+
+            for (device = gpDeviceList; device; device = device->pNext) {
+                if (device->pNext == removeDevice) {
+                    device->pNext = pDeviceNext;
+                    break;
+                }
             }
-            device->pNext = pDeviceNext;
         }
         removeDevice->pNext = NULL;
 
@@ -781,7 +784,7 @@ DARWIN_JoystickGetDeviceInstanceID(int device_index)
 }
 
 static int
-DARWIN_JoystickOpen(SDL_Joystick * joystick, int device_index)
+DARWIN_JoystickOpen(SDL_Joystick *joystick, int device_index)
 {
     recDevice *device = GetDeviceForIndex(device_index);
 
@@ -891,7 +894,7 @@ DARWIN_JoystickInitRumble(recDevice *device, Sint16 magnitude)
 }
 
 static int
-DARWIN_JoystickRumble(SDL_Joystick * joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+DARWIN_JoystickRumble(SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
 {
     HRESULT result;
     recDevice *device = joystick->hwdata;
@@ -931,19 +934,36 @@ DARWIN_JoystickRumble(SDL_Joystick * joystick, Uint16 low_frequency_rumble, Uint
 }
 
 static int
-DARWIN_JoystickRumbleTriggers(SDL_Joystick * joystick, Uint16 left_rumble, Uint16 right_rumble)
+DARWIN_JoystickRumbleTriggers(SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
 {
     return SDL_Unsupported();
 }
 
-static SDL_bool
-DARWIN_JoystickHasLED(SDL_Joystick * joystick)
+static Uint32
+DARWIN_JoystickGetCapabilities(SDL_Joystick *joystick)
 {
-    return SDL_FALSE;
+    recDevice *device = joystick->hwdata;
+    Uint32 result = 0;
+
+    if (!device) {
+        return 0;
+    }
+
+    if (device->ffservice) {
+        result |= SDL_JOYCAP_RUMBLE;
+    }
+
+    return result;
 }
 
 static int
-DARWIN_JoystickSetLED(SDL_Joystick * joystick, Uint8 red, Uint8 green, Uint8 blue)
+DARWIN_JoystickSetLED(SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+    return SDL_Unsupported();
+}
+
+static int
+DARWIN_JoystickSendEffect(SDL_Joystick *joystick, const void *data, int size)
 {
     return SDL_Unsupported();
 }
@@ -955,7 +975,7 @@ DARWIN_JoystickSetSensorsEnabled(SDL_Joystick *joystick, SDL_bool enabled)
 }
 
 static void
-DARWIN_JoystickUpdate(SDL_Joystick * joystick)
+DARWIN_JoystickUpdate(SDL_Joystick *joystick)
 {
     recDevice *device = joystick->hwdata;
     recElement *element;
@@ -1060,7 +1080,7 @@ DARWIN_JoystickUpdate(SDL_Joystick * joystick)
 }
 
 static void
-DARWIN_JoystickClose(SDL_Joystick * joystick)
+DARWIN_JoystickClose(SDL_Joystick *joystick)
 {
     recDevice *device = joystick->hwdata;
     if (device) {
@@ -1102,8 +1122,9 @@ SDL_JoystickDriver SDL_DARWIN_JoystickDriver =
     DARWIN_JoystickOpen,
     DARWIN_JoystickRumble,
     DARWIN_JoystickRumbleTriggers,
-    DARWIN_JoystickHasLED,
+    DARWIN_JoystickGetCapabilities,
     DARWIN_JoystickSetLED,
+    DARWIN_JoystickSendEffect,
     DARWIN_JoystickSetSensorsEnabled,
     DARWIN_JoystickUpdate,
     DARWIN_JoystickClose,
diff --git a/Engine/lib/sdl/src/joystick/darwin/SDL_iokitjoystick_c.h b/Engine/lib/sdl/src/joystick/darwin/SDL_iokitjoystick_c.h
index 4505eccab..369edd130 100644
--- a/Engine/lib/sdl/src/joystick/darwin/SDL_iokitjoystick_c.h
+++ b/Engine/lib/sdl/src/joystick/darwin/SDL_iokitjoystick_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/joystick/dummy/SDL_sysjoystick.c b/Engine/lib/sdl/src/joystick/dummy/SDL_sysjoystick.c
index a51fb206a..ec1c8e651 100644
--- a/Engine/lib/sdl/src/joystick/dummy/SDL_sysjoystick.c
+++ b/Engine/lib/sdl/src/joystick/dummy/SDL_sysjoystick.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -95,10 +95,10 @@ DUMMY_JoystickRumbleTriggers(SDL_Joystick *joystick, Uint16 left_rumble, Uint16
     return SDL_Unsupported();
 }
 
-static SDL_bool
-DUMMY_JoystickHasLED(SDL_Joystick *joystick)
+static Uint32
+DUMMY_JoystickGetCapabilities(SDL_Joystick *joystick)
 {
-    return SDL_FALSE;
+    return 0;
 }
 
 static int
@@ -107,6 +107,12 @@ DUMMY_JoystickSetLED(SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
     return SDL_Unsupported();
 }
 
+static int
+DUMMY_JoystickSendEffect(SDL_Joystick *joystick, const void *data, int size)
+{
+    return SDL_Unsupported();
+}
+
 static int
 DUMMY_JoystickSetSensorsEnabled(SDL_Joystick *joystick, SDL_bool enabled)
 {
@@ -147,8 +153,9 @@ SDL_JoystickDriver SDL_DUMMY_JoystickDriver =
     DUMMY_JoystickOpen,
     DUMMY_JoystickRumble,
     DUMMY_JoystickRumbleTriggers,
-    DUMMY_JoystickHasLED,
+    DUMMY_JoystickGetCapabilities,
     DUMMY_JoystickSetLED,
+    DUMMY_JoystickSendEffect,
     DUMMY_JoystickSetSensorsEnabled,
     DUMMY_JoystickUpdate,
     DUMMY_JoystickClose,
diff --git a/Engine/lib/sdl/src/joystick/emscripten/SDL_sysjoystick.c b/Engine/lib/sdl/src/joystick/emscripten/SDL_sysjoystick.c
index 8651d42a1..eb0ff2a74 100644
--- a/Engine/lib/sdl/src/joystick/emscripten/SDL_sysjoystick.c
+++ b/Engine/lib/sdl/src/joystick/emscripten/SDL_sysjoystick.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -414,10 +414,10 @@ EMSCRIPTEN_JoystickGetGamepadMapping(int device_index, SDL_GamepadMapping *out)
     return SDL_FALSE;
 }
 
-static SDL_bool
-EMSCRIPTEN_JoystickHasLED(SDL_Joystick *joystick)
+static Uint32
+EMSCRIPTEN_JoystickGetCapabilities(SDL_Joystick *joystick)
 {
-    return SDL_FALSE;
+    return 0;
 }
 
 static int
@@ -426,6 +426,12 @@ EMSCRIPTEN_JoystickSetLED(SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8
     return SDL_Unsupported();
 }
 
+static int
+EMSCRIPTEN_JoystickSendEffect(SDL_Joystick *joystick, const void *data, int size)
+{
+    return SDL_Unsupported();
+}
+
 static int
 EMSCRIPTEN_JoystickSetSensorsEnabled(SDL_Joystick *joystick, SDL_bool enabled)
 {
@@ -445,8 +451,9 @@ SDL_JoystickDriver SDL_EMSCRIPTEN_JoystickDriver =
     EMSCRIPTEN_JoystickOpen,
     EMSCRIPTEN_JoystickRumble,
     EMSCRIPTEN_JoystickRumbleTriggers,
-    EMSCRIPTEN_JoystickHasLED,
+    EMSCRIPTEN_JoystickGetCapabilities,
     EMSCRIPTEN_JoystickSetLED,
+    EMSCRIPTEN_JoystickSendEffect,
     EMSCRIPTEN_JoystickSetSensorsEnabled,
     EMSCRIPTEN_JoystickUpdate,
     EMSCRIPTEN_JoystickClose,
diff --git a/Engine/lib/sdl/src/joystick/emscripten/SDL_sysjoystick_c.h b/Engine/lib/sdl/src/joystick/emscripten/SDL_sysjoystick_c.h
index 37a45b15b..815b53aaf 100644
--- a/Engine/lib/sdl/src/joystick/emscripten/SDL_sysjoystick_c.h
+++ b/Engine/lib/sdl/src/joystick/emscripten/SDL_sysjoystick_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/joystick/haiku/SDL_haikujoystick.cc b/Engine/lib/sdl/src/joystick/haiku/SDL_haikujoystick.cc
index 31f52ae0e..38a975227 100644
--- a/Engine/lib/sdl/src/joystick/haiku/SDL_haikujoystick.cc
+++ b/Engine/lib/sdl/src/joystick/haiku/SDL_haikujoystick.cc
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -271,9 +271,9 @@ extern "C"
         return SDL_FALSE;
     }
 
-    static SDL_bool HAIKU_JoystickHasLED(SDL_Joystick *joystick)
+    static Uint32 HAIKU_JoystickGetCapabilities(SDL_Joystick *joystick)
     {
-        return SDL_FALSE;
+        return 0;
     }
 
     static int HAIKU_JoystickSetLED(SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
@@ -281,6 +281,12 @@ extern "C"
         return SDL_Unsupported();
     }
 
+
+    static int HAIKU_JoystickSendEffect(SDL_Joystick *joystick, const void *data, int size)
+    {
+        return SDL_Unsupported();
+    }
+
     static int HAIKU_JoystickSetSensorsEnabled(SDL_Joystick *joystick, SDL_bool enabled)
     {
         return SDL_Unsupported();
@@ -299,8 +305,9 @@ extern "C"
         HAIKU_JoystickOpen,
         HAIKU_JoystickRumble,
         HAIKU_JoystickRumbleTriggers,
-        HAIKU_JoystickHasLED,
+        HAIKU_JoystickGetCapabilities,
         HAIKU_JoystickSetLED,
+        HAIKU_JoystickSendEffect,
         HAIKU_JoystickSetSensorsEnabled,
         HAIKU_JoystickUpdate,
         HAIKU_JoystickClose,
diff --git a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_gamecube.c b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_gamecube.c
index ab36742bb..694556482 100644
--- a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_gamecube.c
+++ b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_gamecube.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -32,13 +32,18 @@
 #include "../SDL_sysjoystick.h"
 #include "SDL_hidapijoystick_c.h"
 #include "SDL_hidapi_rumble.h"
+#include "../../hidapi/SDL_hidapi_c.h"
 
 
 #ifdef SDL_JOYSTICK_HIDAPI_GAMECUBE
 
+/* Define this if you want to log all packets from the controller */
+/*#define DEBUG_GAMECUBE_PROTOCOL*/
+
 #define MAX_CONTROLLERS 4
 
 typedef struct {
+    SDL_bool pc_mode;
     SDL_JoystickID joysticks[MAX_CONTROLLERS];
     Uint8 wireless[MAX_CONTROLLERS];
     Uint8 min_axis[MAX_CONTROLLERS*SDL_CONTROLLER_AXIS_MAX];
@@ -48,6 +53,7 @@ typedef struct {
     /* Without this variable, hid_write starts to lag a TON */
     SDL_bool rumbleUpdate;
     SDL_bool m_bUseButtonLabels;
+    SDL_bool useRumbleBrake;
 } SDL_DriverGameCube_Context;
 
 static SDL_bool
@@ -57,6 +63,10 @@ HIDAPI_DriverGameCube_IsSupportedDevice(const char *name, SDL_GameControllerType
         /* Nintendo Co., Ltd.  Wii U GameCube Controller Adapter */
         return SDL_TRUE;
     }
+    if (vendor_id == USB_VENDOR_SHENZHEN && product_id == USB_PRODUCT_EVORETRO_GAMECUBE_ADAPTER) {
+        /* EVORETRO GameCube Controller Adapter */
+        return SDL_TRUE;
+    }
     return SDL_FALSE;
 }
 
@@ -77,31 +87,20 @@ ResetAxisRange(SDL_DriverGameCube_Context *ctx, int joystick_index)
     ctx->min_axis[joystick_index*SDL_CONTROLLER_AXIS_MAX+SDL_CONTROLLER_AXIS_TRIGGERRIGHT] = 40;
 }
 
-static float fsel(float fComparand, float fValGE, float fLT)
-{
-    return fComparand >= 0 ? fValGE : fLT;
-}
-
-static float RemapVal(float val, float A, float B, float C, float D)
-{
-    if (A == B) {
-        return fsel(val - B , D , C);
-    }
-    if (val < A) {
-        val = A;
-    }
-    if (val > B) {
-        val = B;
-    }
-    return C + (D - C) * (val - A) / (B - A);
-}
-
 static void SDLCALL SDL_GameControllerButtonReportingHintChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
 {
     SDL_DriverGameCube_Context *ctx = (SDL_DriverGameCube_Context *)userdata;
     ctx->m_bUseButtonLabels = SDL_GetStringBoolean(hint, SDL_TRUE);
 }
 
+static void SDLCALL SDL_JoystickGameCubeRumbleBrakeHintChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
+{
+    if (hint) {
+        SDL_DriverGameCube_Context *ctx = (SDL_DriverGameCube_Context *)userdata;
+        ctx->useRumbleBrake = SDL_GetStringBoolean(hint, SDL_FALSE);
+    }
+}
+
 static Uint8 RemapButton(SDL_DriverGameCube_Context *ctx, Uint8 button)
 {
     if (!ctx->m_bUseButtonLabels) {
@@ -129,13 +128,17 @@ HIDAPI_DriverGameCube_InitDevice(SDL_HIDAPI_Device *device)
     Uint8 initMagic = 0x13;
     Uint8 rumbleMagic = 0x11;
 
+#ifdef HAVE_ENABLE_GAMECUBE_ADAPTORS
+    SDL_EnableGameCubeAdaptors();
+#endif
+
     ctx = (SDL_DriverGameCube_Context *)SDL_calloc(1, sizeof(*ctx));
     if (!ctx) {
         SDL_OutOfMemory();
         return SDL_FALSE;
     }
 
-    device->dev = hid_open_path(device->path, 0);
+    device->dev = SDL_hid_open_path(device->path, 0);
     if (!device->dev) {
         SDL_free(ctx);
         SDL_SetError("Couldn't open %s", device->path);
@@ -148,59 +151,81 @@ HIDAPI_DriverGameCube_InitDevice(SDL_HIDAPI_Device *device)
     ctx->joysticks[2] = -1;
     ctx->joysticks[3] = -1;
     ctx->rumble[0] = rumbleMagic;
+    ctx->useRumbleBrake = SDL_FALSE;
 
-    /* This is all that's needed to initialize the device. Really! */
-    if (hid_write(device->dev, &initMagic, sizeof(initMagic)) != sizeof(initMagic)) {
-        SDL_SetError("Couldn't initialize WUP-028");
-        goto error;
+    if (device->vendor_id != USB_VENDOR_NINTENDO) {
+        ctx->pc_mode = SDL_TRUE;
     }
 
-    /* Wait for the adapter to initialize */
-    SDL_Delay(10);
-
-    /* Add all the applicable joysticks */
-    while ((size = hid_read_timeout(device->dev, packet, sizeof(packet), 0)) > 0) {
-        if (size < 37 || packet[0] != 0x21) {
-            continue; /* Nothing to do yet...? */
+    if (ctx->pc_mode) {
+        for (i = 0; i < MAX_CONTROLLERS; ++i) {
+            ResetAxisRange(ctx, i);
+            HIDAPI_JoystickConnected(device, &ctx->joysticks[i]);
+        }
+    } else {
+        /* This is all that's needed to initialize the device. Really! */
+        if (SDL_hid_write(device->dev, &initMagic, sizeof(initMagic)) != sizeof(initMagic)) {
+            SDL_SetError("Couldn't initialize WUP-028");
+            goto error;
         }
 
-        /* Go through all 4 slots */
-        curSlot = packet + 1;
-        for (i = 0; i < MAX_CONTROLLERS; i += 1, curSlot += 9) {
-            ctx->wireless[i] = (curSlot[0] & 0x20) != 0;
+        /* Wait for the adapter to initialize */
+        SDL_Delay(10);
 
-            /* Only allow rumble if the adapter's second USB cable is connected */
-            ctx->rumbleAllowed[i] = (curSlot[0] & 0x04) != 0 && !ctx->wireless[i];
+        /* Add all the applicable joysticks */
+        while ((size = SDL_hid_read_timeout(device->dev, packet, sizeof(packet), 0)) > 0) {
+#ifdef DEBUG_GAMECUBE_PROTOCOL
+            HIDAPI_DumpPacket("Nintendo GameCube packet: size = %d", packet, size);
+#endif
+            if (size < 37 || packet[0] != 0x21) {
+                continue; /* Nothing to do yet...? */
+            }
 
-            if (curSlot[0] & 0x30) { /* 0x10 - Wired, 0x20 - Wireless */
-                if (ctx->joysticks[i] == -1) {
-                    ResetAxisRange(ctx, i);
-                    HIDAPI_JoystickConnected(device, &ctx->joysticks[i]);
+            /* Go through all 4 slots */
+            curSlot = packet + 1;
+            for (i = 0; i < MAX_CONTROLLERS; i += 1, curSlot += 9) {
+                ctx->wireless[i] = (curSlot[0] & 0x20) != 0;
+
+                /* Only allow rumble if the adapter's second USB cable is connected */
+                ctx->rumbleAllowed[i] = (curSlot[0] & 0x04) != 0 && !ctx->wireless[i];
+
+                if (curSlot[0] & 0x30) { /* 0x10 - Wired, 0x20 - Wireless */
+                    if (ctx->joysticks[i] == -1) {
+                        ResetAxisRange(ctx, i);
+                        HIDAPI_JoystickConnected(device, &ctx->joysticks[i]);
+                    }
+                } else {
+                    if (ctx->joysticks[i] != -1) {
+                        HIDAPI_JoystickDisconnected(device, ctx->joysticks[i]);
+                        ctx->joysticks[i] = -1;
+                    }
+                    continue;
                 }
-            } else {
-                if (ctx->joysticks[i] != -1) {
-                    HIDAPI_JoystickDisconnected(device, ctx->joysticks[i]);
-                    ctx->joysticks[i] = -1;
-                }
-                continue;
             }
         }
     }
 
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_GAMECUBE_RUMBLE_BRAKE,
+                        SDL_JoystickGameCubeRumbleBrakeHintChanged, ctx);
     SDL_AddHintCallback(SDL_HINT_GAMECONTROLLER_USE_BUTTON_LABELS,
                         SDL_GameControllerButtonReportingHintChanged, ctx);
 
     return SDL_TRUE;
 
 error:
-    if (device->dev) {
-        hid_close(device->dev);
-        device->dev = NULL;
-    }
-    if (device->context) {
-        SDL_free(device->context);
-        device->context = NULL;
+    SDL_LockMutex(device->dev_lock);
+    {
+        if (device->dev) {
+            SDL_hid_close(device->dev);
+            device->dev = NULL;
+        }
+        if (device->context) {
+            SDL_free(device->context);
+            device->context = NULL;
+        }
     }
+    SDL_UnlockMutex(device->dev_lock);
+
     return SDL_FALSE;
 }
 
@@ -223,90 +248,167 @@ HIDAPI_DriverGameCube_SetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_Joysti
 {
 }
 
+static void
+HIDAPI_DriverGameCube_HandleJoystickPacket(SDL_HIDAPI_Device *device, SDL_DriverGameCube_Context *ctx, Uint8 *packet, int size)
+{
+    SDL_Joystick *joystick;
+    Uint8 i, v;
+    Sint16 axis_value;
+
+    if (size != 10) {
+        return; /* How do we handle this packet? */
+    }
+
+    i = packet[0] - 1;
+    if (i >= MAX_CONTROLLERS) {
+        return; /* How do we handle this packet? */
+    }
+
+    joystick = SDL_JoystickFromInstanceID(ctx->joysticks[i]);
+    if (!joystick) {
+        /* Hasn't been opened yet, skip */
+        return;
+    }
+
+    #define READ_BUTTON(off, flag, button) \
+        SDL_PrivateJoystickButton( \
+            joystick, \
+            RemapButton(ctx, button), \
+            (packet[off] & flag) ? SDL_PRESSED : SDL_RELEASED \
+        );
+    READ_BUTTON(1, 0x02, 0) /* A */
+    READ_BUTTON(1, 0x04, 1) /* B */
+    READ_BUTTON(1, 0x01, 2) /* X */
+    READ_BUTTON(1, 0x08, 3) /* Y */
+    READ_BUTTON(2, 0x80, 4) /* DPAD_LEFT */
+    READ_BUTTON(2, 0x20, 5) /* DPAD_RIGHT */
+    READ_BUTTON(2, 0x40, 6) /* DPAD_DOWN */
+    READ_BUTTON(2, 0x10, 7) /* DPAD_UP */
+    READ_BUTTON(2, 0x02, 8) /* START */
+    READ_BUTTON(1, 0x80, 9) /* RIGHTSHOULDER */
+    /* These two buttons are for the bottoms of the analog triggers.
+     * More than likely, you're going to want to read the axes instead!
+     * -flibit
+     */
+    READ_BUTTON(1, 0x20, 10) /* TRIGGERRIGHT */
+    READ_BUTTON(1, 0x10, 11) /* TRIGGERLEFT */
+    #undef READ_BUTTON
+
+    #define READ_AXIS(off, axis, invert) \
+        v = invert ? (0xff - packet[off]) : packet[off]; \
+        if (v < ctx->min_axis[i*SDL_CONTROLLER_AXIS_MAX+axis]) ctx->min_axis[i*SDL_CONTROLLER_AXIS_MAX+axis] = v; \
+        if (v > ctx->max_axis[i*SDL_CONTROLLER_AXIS_MAX+axis]) ctx->max_axis[i*SDL_CONTROLLER_AXIS_MAX+axis] = v; \
+        axis_value = (Sint16)HIDAPI_RemapVal(v, ctx->min_axis[i*SDL_CONTROLLER_AXIS_MAX+axis], ctx->max_axis[i*SDL_CONTROLLER_AXIS_MAX+axis], SDL_MIN_SINT16, SDL_MAX_SINT16); \
+        SDL_PrivateJoystickAxis( \
+            joystick, \
+            axis, axis_value \
+        );
+    READ_AXIS(3, SDL_CONTROLLER_AXIS_LEFTX, 0)
+    READ_AXIS(4, SDL_CONTROLLER_AXIS_LEFTY, 0)
+    READ_AXIS(6, SDL_CONTROLLER_AXIS_RIGHTX, 1)
+    READ_AXIS(5, SDL_CONTROLLER_AXIS_RIGHTY, 1)
+    READ_AXIS(7, SDL_CONTROLLER_AXIS_TRIGGERLEFT, 0)
+    READ_AXIS(8, SDL_CONTROLLER_AXIS_TRIGGERRIGHT, 0)
+    #undef READ_AXIS
+}
+
+static void
+HIDAPI_DriverGameCube_HandleNintendoPacket(SDL_HIDAPI_Device *device, SDL_DriverGameCube_Context *ctx, Uint8 *packet, int size)
+{
+    SDL_Joystick *joystick;
+    Uint8 *curSlot;
+    Uint8 i;
+    Sint16 axis_value;
+
+    if (size < 37 || packet[0] != 0x21) {
+        return; /* Nothing to do right now...? */
+    }
+
+    /* Go through all 4 slots */
+    curSlot = packet + 1;
+    for (i = 0; i < MAX_CONTROLLERS; i += 1, curSlot += 9) {
+        ctx->wireless[i] = (curSlot[0] & 0x20) != 0;
+
+        /* Only allow rumble if the adapter's second USB cable is connected */
+        ctx->rumbleAllowed[i] = (curSlot[0] & 0x04) != 0 && !ctx->wireless[i];
+
+        if (curSlot[0] & 0x30) { /* 0x10 - Wired, 0x20 - Wireless */
+            if (ctx->joysticks[i] == -1) {
+                ResetAxisRange(ctx, i);
+                HIDAPI_JoystickConnected(device, &ctx->joysticks[i]);
+            }
+            joystick = SDL_JoystickFromInstanceID(ctx->joysticks[i]);
+
+            /* Hasn't been opened yet, skip */
+            if (joystick == NULL) {
+                continue;
+            }
+        } else {
+            if (ctx->joysticks[i] != -1) {
+                HIDAPI_JoystickDisconnected(device, ctx->joysticks[i]);
+                ctx->joysticks[i] = -1;
+            }
+            continue;
+        }
+
+        #define READ_BUTTON(off, flag, button) \
+            SDL_PrivateJoystickButton( \
+                joystick, \
+                RemapButton(ctx, button), \
+                (curSlot[off] & flag) ? SDL_PRESSED : SDL_RELEASED \
+            );
+        READ_BUTTON(1, 0x01, 0) /* A */
+        READ_BUTTON(1, 0x04, 1) /* B */
+        READ_BUTTON(1, 0x02, 2) /* X */
+        READ_BUTTON(1, 0x08, 3) /* Y */
+        READ_BUTTON(1, 0x10, 4) /* DPAD_LEFT */
+        READ_BUTTON(1, 0x20, 5) /* DPAD_RIGHT */
+        READ_BUTTON(1, 0x40, 6) /* DPAD_DOWN */
+        READ_BUTTON(1, 0x80, 7) /* DPAD_UP */
+        READ_BUTTON(2, 0x01, 8) /* START */
+        READ_BUTTON(2, 0x02, 9) /* RIGHTSHOULDER */
+        /* These two buttons are for the bottoms of the analog triggers.
+         * More than likely, you're going to want to read the axes instead!
+         * -flibit
+         */
+        READ_BUTTON(2, 0x04, 10) /* TRIGGERRIGHT */
+        READ_BUTTON(2, 0x08, 11) /* TRIGGERLEFT */
+        #undef READ_BUTTON
+
+        #define READ_AXIS(off, axis) \
+            if (curSlot[off] < ctx->min_axis[i*SDL_CONTROLLER_AXIS_MAX+axis]) ctx->min_axis[i*SDL_CONTROLLER_AXIS_MAX+axis] = curSlot[off]; \
+            if (curSlot[off] > ctx->max_axis[i*SDL_CONTROLLER_AXIS_MAX+axis]) ctx->max_axis[i*SDL_CONTROLLER_AXIS_MAX+axis] = curSlot[off]; \
+            axis_value = (Sint16)HIDAPI_RemapVal(curSlot[off], ctx->min_axis[i*SDL_CONTROLLER_AXIS_MAX+axis], ctx->max_axis[i*SDL_CONTROLLER_AXIS_MAX+axis], SDL_MIN_SINT16, SDL_MAX_SINT16); \
+            SDL_PrivateJoystickAxis( \
+                joystick, \
+                axis, axis_value \
+            );
+        READ_AXIS(3, SDL_CONTROLLER_AXIS_LEFTX)
+        READ_AXIS(4, SDL_CONTROLLER_AXIS_LEFTY)
+        READ_AXIS(5, SDL_CONTROLLER_AXIS_RIGHTX)
+        READ_AXIS(6, SDL_CONTROLLER_AXIS_RIGHTY)
+        READ_AXIS(7, SDL_CONTROLLER_AXIS_TRIGGERLEFT)
+        READ_AXIS(8, SDL_CONTROLLER_AXIS_TRIGGERRIGHT)
+        #undef READ_AXIS
+    }
+}
+
 static SDL_bool
 HIDAPI_DriverGameCube_UpdateDevice(SDL_HIDAPI_Device *device)
 {
     SDL_DriverGameCube_Context *ctx = (SDL_DriverGameCube_Context *)device->context;
-    SDL_Joystick *joystick;
-    Uint8 packet[37];
-    Uint8 *curSlot;
-    Uint8 i;
-    Sint16 axis_value;
+    Uint8 packet[USB_PACKET_LENGTH];
     int size;
 
     /* Read input packet */
-    while ((size = hid_read_timeout(device->dev, packet, sizeof(packet), 0)) > 0) {
-        if (size < 37 || packet[0] != 0x21) {
-            continue; /* Nothing to do right now...? */
-        }
-
-        /* Go through all 4 slots */
-        curSlot = packet + 1;
-        for (i = 0; i < MAX_CONTROLLERS; i += 1, curSlot += 9) {
-            ctx->wireless[i] = (curSlot[0] & 0x20) != 0;
-
-            /* Only allow rumble if the adapter's second USB cable is connected */
-            ctx->rumbleAllowed[i] = (curSlot[0] & 0x04) != 0 && !ctx->wireless[i];
-
-            if (curSlot[0] & 0x30) { /* 0x10 - Wired, 0x20 - Wireless */
-                if (ctx->joysticks[i] == -1) {
-                    ResetAxisRange(ctx, i);
-                    HIDAPI_JoystickConnected(device, &ctx->joysticks[i]);
-                }
-                joystick = SDL_JoystickFromInstanceID(ctx->joysticks[i]);
-
-                /* Hasn't been opened yet, skip */
-                if (joystick == NULL) {
-                    continue;
-                }
-            } else {
-                if (ctx->joysticks[i] != -1) {
-                    HIDAPI_JoystickDisconnected(device, ctx->joysticks[i]);
-                    ctx->joysticks[i] = -1;
-                }
-                continue;
-            }
-
-            #define READ_BUTTON(off, flag, button) \
-                SDL_PrivateJoystickButton( \
-                    joystick, \
-                    RemapButton(ctx, button), \
-                    (curSlot[off] & flag) ? SDL_PRESSED : SDL_RELEASED \
-                );
-            READ_BUTTON(1, 0x01, 0) /* A */
-            READ_BUTTON(1, 0x04, 1) /* B */
-            READ_BUTTON(1, 0x02, 2) /* X */
-            READ_BUTTON(1, 0x08, 3) /* Y */
-            READ_BUTTON(1, 0x10, 4) /* DPAD_LEFT */
-            READ_BUTTON(1, 0x20, 5) /* DPAD_RIGHT */
-            READ_BUTTON(1, 0x40, 6) /* DPAD_DOWN */
-            READ_BUTTON(1, 0x80, 7) /* DPAD_UP */
-            READ_BUTTON(2, 0x01, 8) /* START */
-            READ_BUTTON(2, 0x02, 9) /* RIGHTSHOULDER */
-            /* These two buttons are for the bottoms of the analog triggers.
-             * More than likely, you're going to want to read the axes instead!
-             * -flibit
-             */
-            READ_BUTTON(2, 0x04, 10) /* TRIGGERRIGHT */
-            READ_BUTTON(2, 0x08, 11) /* TRIGGERLEFT */
-            #undef READ_BUTTON
-
-            #define READ_AXIS(off, axis) \
-                if (axis < SDL_CONTROLLER_AXIS_TRIGGERLEFT) \
-                if (curSlot[off] < ctx->min_axis[i*SDL_CONTROLLER_AXIS_MAX+axis]) ctx->min_axis[i*SDL_CONTROLLER_AXIS_MAX+axis] = curSlot[off]; \
-                if (curSlot[off] > ctx->max_axis[i*SDL_CONTROLLER_AXIS_MAX+axis]) ctx->max_axis[i*SDL_CONTROLLER_AXIS_MAX+axis] = curSlot[off]; \
-                axis_value = (Sint16)(RemapVal(curSlot[off], ctx->min_axis[i*SDL_CONTROLLER_AXIS_MAX+axis], ctx->max_axis[i*SDL_CONTROLLER_AXIS_MAX+axis], SDL_MIN_SINT16, SDL_MAX_SINT16)); \
-                SDL_PrivateJoystickAxis( \
-                    joystick, \
-                    axis, axis_value \
-                );
-            READ_AXIS(3, SDL_CONTROLLER_AXIS_LEFTX)
-            READ_AXIS(4, SDL_CONTROLLER_AXIS_LEFTY)
-            READ_AXIS(5, SDL_CONTROLLER_AXIS_RIGHTX)
-            READ_AXIS(6, SDL_CONTROLLER_AXIS_RIGHTY)
-            READ_AXIS(7, SDL_CONTROLLER_AXIS_TRIGGERLEFT)
-            READ_AXIS(8, SDL_CONTROLLER_AXIS_TRIGGERRIGHT)
-            #undef READ_AXIS
+    while ((size = SDL_hid_read_timeout(device->dev, packet, sizeof(packet), 0)) > 0) {
+#ifdef DEBUG_GAMECUBE_PROTOCOL
+        //HIDAPI_DumpPacket("Nintendo GameCube packet: size = %d", packet, size);
+#endif
+        if (ctx->pc_mode) {
+            HIDAPI_DriverGameCube_HandleJoystickPacket(device, ctx, packet, size);
+        } else {
+            HIDAPI_DriverGameCube_HandleNintendoPacket(device, ctx, packet, size);
         }
     }
 
@@ -341,15 +443,30 @@ HIDAPI_DriverGameCube_RumbleJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *jo
 {
     SDL_DriverGameCube_Context *ctx = (SDL_DriverGameCube_Context *)device->context;
     Uint8 i, val;
+
+    if (ctx->pc_mode) {
+        return SDL_Unsupported();
+    }
+
     for (i = 0; i < MAX_CONTROLLERS; i += 1) {
         if (joystick->instance_id == ctx->joysticks[i]) {
             if (ctx->wireless[i]) {
-                return SDL_SetError("Ninteno GameCube WaveBird controllers do not support rumble");
+                return SDL_SetError("Nintendo GameCube WaveBird controllers do not support rumble");
             }
             if (!ctx->rumbleAllowed[i]) {
                 return SDL_SetError("Second USB cable for WUP-028 not connected");
             }
-            val = (low_frequency_rumble > 0 || high_frequency_rumble > 0);
+            if (ctx->useRumbleBrake) {
+                if (low_frequency_rumble == 0 && high_frequency_rumble > 0) {
+                    val = 0; /* if only low is 0 we want to do a regular stop*/
+                } else if (low_frequency_rumble == 0 && high_frequency_rumble == 0) {
+                    val = 2; /* if both frequencies are 0 we want to do a hard stop */
+                } else {
+                    val = 1; /* normal rumble */
+                }
+            } else {
+                val = (low_frequency_rumble > 0 || high_frequency_rumble > 0);
+            }
             if (val != ctx->rumble[i + 1]) {
                 ctx->rumble[i + 1] = val;
                 ctx->rumbleUpdate = SDL_TRUE;
@@ -359,8 +476,7 @@ HIDAPI_DriverGameCube_RumbleJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *jo
     }
 
     /* Should never get here! */
-    SDL_SetError("Couldn't find joystick");
-    return -1;
+    return SDL_SetError("Couldn't find joystick");
 }
 
 static int
@@ -369,10 +485,26 @@ HIDAPI_DriverGameCube_RumbleJoystickTriggers(SDL_HIDAPI_Device *device, SDL_Joys
     return SDL_Unsupported();
 }
 
-static SDL_bool
-HIDAPI_DriverGameCube_HasJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+static Uint32
+HIDAPI_DriverGameCube_GetJoystickCapabilities(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
 {
-    return SDL_FALSE;
+    SDL_DriverGameCube_Context *ctx = (SDL_DriverGameCube_Context *)device->context;
+    Uint32 result = 0;
+
+    if (!ctx->pc_mode) {
+        Uint8 i;
+
+        for (i = 0; i < MAX_CONTROLLERS; i += 1) {
+            if (joystick->instance_id == ctx->joysticks[i]) {
+                if (!ctx->wireless[i] && ctx->rumbleAllowed[i]) {
+                    result |= SDL_JOYCAP_RUMBLE;
+                    break;
+                }
+            }
+        }
+    }
+
+    return result;
 }
 
 static int
@@ -381,6 +513,12 @@ HIDAPI_DriverGameCube_SetJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *jo
     return SDL_Unsupported();
 }
 
+static int
+HIDAPI_DriverGameCube_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *data, int size)
+{
+    return SDL_Unsupported();
+}
+
 static int
 HIDAPI_DriverGameCube_SetJoystickSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, SDL_bool enabled)
 {
@@ -404,20 +542,27 @@ HIDAPI_DriverGameCube_FreeDevice(SDL_HIDAPI_Device *device)
 {
     SDL_DriverGameCube_Context *ctx = (SDL_DriverGameCube_Context *)device->context;
 
-    hid_close(device->dev);
-    device->dev = NULL;
-
     SDL_DelHintCallback(SDL_HINT_GAMECONTROLLER_USE_BUTTON_LABELS,
                         SDL_GameControllerButtonReportingHintChanged, ctx);
+    SDL_DelHintCallback(SDL_HINT_JOYSTICK_GAMECUBE_RUMBLE_BRAKE,
+                        SDL_JoystickGameCubeRumbleBrakeHintChanged, ctx);
 
-    SDL_free(device->context);
-    device->context = NULL;
+    SDL_LockMutex(device->dev_lock);
+    {
+        SDL_hid_close(device->dev);
+        device->dev = NULL;
+
+        SDL_free(device->context);
+        device->context = NULL;
+    }
+    SDL_UnlockMutex(device->dev_lock);
 }
 
 SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverGameCube =
 {
     SDL_HINT_JOYSTICK_HIDAPI_GAMECUBE,
     SDL_TRUE,
+    SDL_TRUE,
     HIDAPI_DriverGameCube_IsSupportedDevice,
     HIDAPI_DriverGameCube_GetDeviceName,
     HIDAPI_DriverGameCube_InitDevice,
@@ -427,8 +572,9 @@ SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverGameCube =
     HIDAPI_DriverGameCube_OpenJoystick,
     HIDAPI_DriverGameCube_RumbleJoystick,
     HIDAPI_DriverGameCube_RumbleJoystickTriggers,
-    HIDAPI_DriverGameCube_HasJoystickLED,
+    HIDAPI_DriverGameCube_GetJoystickCapabilities,
     HIDAPI_DriverGameCube_SetJoystickLED,
+    HIDAPI_DriverGameCube_SendJoystickEffect,
     HIDAPI_DriverGameCube_SetJoystickSensorsEnabled,
     HIDAPI_DriverGameCube_CloseJoystick,
     HIDAPI_DriverGameCube_FreeDevice,
diff --git a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_luna.c b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_luna.c
new file mode 100644
index 000000000..ead55af34
--- /dev/null
+++ b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_luna.c
@@ -0,0 +1,463 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI
+
+#include "SDL_hints.h"
+#include "SDL_events.h"
+#include "SDL_joystick.h"
+#include "SDL_gamecontroller.h"
+#include "../SDL_sysjoystick.h"
+#include "SDL_hidapijoystick_c.h"
+#include "SDL_hidapi_rumble.h"
+
+
+#ifdef SDL_JOYSTICK_HIDAPI_LUNA
+
+/* Define this if you want to log all packets from the controller */
+/*#define DEBUG_LUNA_PROTOCOL*/
+
+enum
+{
+    SDL_CONTROLLER_BUTTON_LUNA_MIC = 15,
+    SDL_CONTROLLER_NUM_LUNA_BUTTONS,
+};
+
+typedef struct {
+    Uint8 last_state[USB_PACKET_LENGTH];
+} SDL_DriverLuna_Context;
+
+
+static SDL_bool
+HIDAPI_DriverLuna_IsSupportedDevice(const char *name, SDL_GameControllerType type, Uint16 vendor_id, Uint16 product_id, Uint16 version, int interface_number, int interface_class, int interface_subclass, int interface_protocol)
+{
+    return (type == SDL_CONTROLLER_TYPE_AMAZON_LUNA) ? SDL_TRUE : SDL_FALSE;
+}
+
+static const char *
+HIDAPI_DriverLuna_GetDeviceName(Uint16 vendor_id, Uint16 product_id)
+{
+    return "Amazon Luna Controller";
+}
+
+static SDL_bool
+HIDAPI_DriverLuna_InitDevice(SDL_HIDAPI_Device *device)
+{
+    return HIDAPI_JoystickConnected(device, NULL);
+}
+
+static int
+HIDAPI_DriverLuna_GetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id)
+{
+    return -1;
+}
+
+static void
+HIDAPI_DriverLuna_SetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id, int player_index)
+{
+}
+
+static SDL_bool
+HIDAPI_DriverLuna_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverLuna_Context *ctx;
+
+    ctx = (SDL_DriverLuna_Context *)SDL_calloc(1, sizeof(*ctx));
+    if (!ctx) {
+        SDL_OutOfMemory();
+        return SDL_FALSE;
+    }
+
+    device->dev = SDL_hid_open_path(device->path, 0);
+    if (!device->dev) {
+        SDL_SetError("Couldn't open %s", device->path);
+        SDL_free(ctx);
+        return SDL_FALSE;
+    }
+    device->context = ctx;
+
+    /* Initialize the joystick capabilities */
+    joystick->nbuttons = SDL_CONTROLLER_NUM_LUNA_BUTTONS;
+    joystick->naxes = SDL_CONTROLLER_AXIS_MAX;
+    joystick->epowerlevel = SDL_JOYSTICK_POWER_FULL;
+    joystick->serial = NULL;
+
+    return SDL_TRUE;
+}
+
+static int
+HIDAPI_DriverLuna_RumbleJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+{
+    if (device->product_id == BLUETOOTH_PRODUCT_LUNA_CONTROLLER) {
+        /* Same packet as on Xbox One controllers connected via Bluetooth */
+        Uint8 rumble_packet[] = { 0x03, 0x0F, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xEB };
+
+        /* Magnitude is 1..100 so scale the 16-bit input here */
+        rumble_packet[4] = low_frequency_rumble / 655;
+        rumble_packet[5] = high_frequency_rumble / 655;
+
+        if (SDL_HIDAPI_SendRumble(device, rumble_packet, sizeof(rumble_packet)) != sizeof(rumble_packet)) {
+            return SDL_SetError("Couldn't send rumble packet");
+        }
+
+        return 0;
+    } else {
+        /* FIXME: Is there a rumble packet over USB? */
+        return SDL_Unsupported();
+    }
+}
+
+static int
+HIDAPI_DriverLuna_RumbleJoystickTriggers(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
+{
+    return SDL_Unsupported();
+}
+
+static Uint32
+HIDAPI_DriverLuna_GetJoystickCapabilities(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    Uint32 result = 0;
+
+    if (device->product_id == BLUETOOTH_PRODUCT_LUNA_CONTROLLER) {
+        result |= SDL_JOYCAP_RUMBLE;
+    }
+
+    return result;
+}
+
+static int
+HIDAPI_DriverLuna_SetJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+    return SDL_Unsupported();
+}
+
+static int
+HIDAPI_DriverLuna_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *data, int size)
+{
+    return SDL_Unsupported();
+}
+
+static int
+HIDAPI_DriverLuna_SetJoystickSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, SDL_bool enabled)
+{
+    return SDL_Unsupported();
+}
+
+static void
+HIDAPI_DriverLuna_HandleUSBStatePacket(SDL_Joystick *joystick, SDL_DriverLuna_Context *ctx, Uint8 *data, int size)
+{
+    if (ctx->last_state[1] != data[1]) {
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_A, (data[1] & 0x01) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_B, (data[1] & 0x02) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_X, (data[1] & 0x04) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_Y, (data[1] & 0x08) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_LEFTSHOULDER, (data[1] & 0x10) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER, (data[1] & 0x20) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_BACK, (data[1] & 0x40) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_START, (data[1] & 0x80) ? SDL_PRESSED : SDL_RELEASED);
+    }
+    if (ctx->last_state[2] != data[2]) {
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_GUIDE, (data[2] & 0x01) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_LUNA_MIC, (data[2] & 0x02) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_LEFTSTICK, (data[2] & 0x04) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_RIGHTSTICK, (data[2] & 0x08) ? SDL_PRESSED : SDL_RELEASED);
+    }
+
+    if (ctx->last_state[3] != data[3]) {
+        SDL_bool dpad_up = SDL_FALSE;
+        SDL_bool dpad_down = SDL_FALSE;
+        SDL_bool dpad_left = SDL_FALSE;
+        SDL_bool dpad_right = SDL_FALSE;
+
+        switch (data[3] & 0xf) {
+        case 0:
+            dpad_up = SDL_TRUE;
+            break;
+        case 1:
+            dpad_up = SDL_TRUE;
+            dpad_right = SDL_TRUE;
+            break;
+        case 2:
+            dpad_right = SDL_TRUE;
+            break;
+        case 3:
+            dpad_right = SDL_TRUE;
+            dpad_down = SDL_TRUE;
+            break;
+        case 4:
+            dpad_down = SDL_TRUE;
+            break;
+        case 5:
+            dpad_left = SDL_TRUE;
+            dpad_down = SDL_TRUE;
+            break;
+        case 6:
+            dpad_left = SDL_TRUE;
+            break;
+        case 7:
+            dpad_up = SDL_TRUE;
+            dpad_left = SDL_TRUE;
+            break;
+        default:
+            break;
+        }
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_DPAD_DOWN, dpad_down);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_DPAD_UP, dpad_up);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_DPAD_RIGHT, dpad_right);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_DPAD_LEFT, dpad_left);
+    }
+
+#define READ_STICK_AXIS(offset) \
+    (data[offset] == 0x7f ? 0 : \
+    (Sint16)HIDAPI_RemapVal((float)data[offset], 0x00, 0xff, SDL_MIN_SINT16, SDL_MAX_SINT16))
+    {
+        Sint16 axis = READ_STICK_AXIS(4);
+        SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_LEFTX, axis);
+        axis = READ_STICK_AXIS(5);
+        SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_LEFTY, axis);
+        axis = READ_STICK_AXIS(6);
+        SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_RIGHTX, axis);
+        axis = READ_STICK_AXIS(7);
+        SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_RIGHTY, axis);
+    }
+#undef READ_STICK_AXIS
+
+#define READ_TRIGGER_AXIS(offset) \
+    (Sint16)HIDAPI_RemapVal((float)data[offset], 0x00, 0xff, SDL_MIN_SINT16, SDL_MAX_SINT16)
+    {
+        Sint16 axis = READ_TRIGGER_AXIS(8);
+        SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_TRIGGERLEFT, axis);
+        axis = READ_TRIGGER_AXIS(9);
+        SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_TRIGGERRIGHT, axis);
+    }
+#undef READ_TRIGGER_AXIS
+
+    SDL_memcpy(ctx->last_state, data, SDL_min(size, sizeof(ctx->last_state)));
+}
+
+static void
+HIDAPI_DriverLuna_HandleBluetoothStatePacket(SDL_Joystick *joystick, SDL_DriverLuna_Context *ctx, Uint8 *data, int size)
+{
+    if (size >= 2 && data[0] == 0x02) {
+        /* Home button has dedicated report */
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_GUIDE, (data[1] & 0x1) ? SDL_PRESSED : SDL_RELEASED);
+        return;
+    }
+
+    if (size >= 2 && data[0] == 0x04) {
+        /* Battery level report */
+        int level = data[1] * 100 / 0xFF;
+        if (level == 0) {
+            joystick->epowerlevel = SDL_JOYSTICK_POWER_EMPTY;
+        }
+        else if (level <= 20) {
+            joystick->epowerlevel = SDL_JOYSTICK_POWER_LOW;
+        }
+        else if (level <= 70) {
+            joystick->epowerlevel = SDL_JOYSTICK_POWER_MEDIUM;
+        }
+        else {
+            joystick->epowerlevel = SDL_JOYSTICK_POWER_FULL;
+        }
+
+        return;
+    }
+
+    if (size < 17 || data[0] != 0x01) {
+        /* We don't know how to handle this report */
+        return;
+    }
+
+    if (ctx->last_state[13] != data[13]) {
+        SDL_bool dpad_up = SDL_FALSE;
+        SDL_bool dpad_down = SDL_FALSE;
+        SDL_bool dpad_left = SDL_FALSE;
+        SDL_bool dpad_right = SDL_FALSE;
+
+        switch (data[13] & 0xf) {
+        case 1:
+            dpad_up = SDL_TRUE;
+            break;
+        case 2:
+            dpad_up = SDL_TRUE;
+            dpad_right = SDL_TRUE;
+            break;
+        case 3:
+            dpad_right = SDL_TRUE;
+            break;
+        case 4:
+            dpad_right = SDL_TRUE;
+            dpad_down = SDL_TRUE;
+            break;
+        case 5:
+            dpad_down = SDL_TRUE;
+            break;
+        case 6:
+            dpad_left = SDL_TRUE;
+            dpad_down = SDL_TRUE;
+            break;
+        case 7:
+            dpad_left = SDL_TRUE;
+            break;
+        case 8:
+            dpad_up = SDL_TRUE;
+            dpad_left = SDL_TRUE;
+            break;
+        default:
+            break;
+        }
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_DPAD_DOWN, dpad_down);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_DPAD_UP, dpad_up);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_DPAD_RIGHT, dpad_right);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_DPAD_LEFT, dpad_left);
+    }
+
+    if (ctx->last_state[14] != data[14]) {
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_A, (data[14] & 0x01) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_B, (data[14] & 0x02) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_X, (data[14] & 0x08) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_Y, (data[14] & 0x10) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_LEFTSHOULDER, (data[14] & 0x40) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER, (data[14] & 0x80) ? SDL_PRESSED : SDL_RELEASED);
+    }
+    if (ctx->last_state[15] != data[15]) {
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_START, (data[15] & 0x08) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_LEFTSTICK, (data[15] & 0x20) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_RIGHTSTICK, (data[15] & 0x40) ? SDL_PRESSED : SDL_RELEASED);
+    }
+    if (ctx->last_state[16] != data[16]) {
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_BACK, (data[16] & 0x01) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_LUNA_MIC, (data[16] & 0x02) ? SDL_PRESSED : SDL_RELEASED);
+    }
+
+#define READ_STICK_AXIS(offset) \
+    (data[offset] == 0x7f ? 0 : \
+    (Sint16)HIDAPI_RemapVal((float)data[offset], 0x00, 0xff, SDL_MIN_SINT16, SDL_MAX_SINT16))
+    {
+        Sint16 axis = READ_STICK_AXIS(2);
+        SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_LEFTX, axis);
+        axis = READ_STICK_AXIS(4);
+        SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_LEFTY, axis);
+        axis = READ_STICK_AXIS(6);
+        SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_RIGHTX, axis);
+        axis = READ_STICK_AXIS(8);
+        SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_RIGHTY, axis);
+    }
+#undef READ_STICK_AXIS
+
+#define READ_TRIGGER_AXIS(offset) \
+    (Sint16)HIDAPI_RemapVal((float)((int)(((data[offset] | (data[offset + 1] << 8)) & 0x3ff) - 0x200)), 0x00 - 0x200, 0x3ff - 0x200, SDL_MIN_SINT16, SDL_MAX_SINT16)
+    {
+        Sint16 axis = READ_TRIGGER_AXIS(9);
+        SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_TRIGGERLEFT, axis);
+        axis = READ_TRIGGER_AXIS(11);
+        SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_TRIGGERRIGHT, axis);
+    }
+#undef READ_TRIGGER_AXIS
+
+    SDL_memcpy(ctx->last_state, data, SDL_min(size, sizeof(ctx->last_state)));
+}
+
+static SDL_bool
+HIDAPI_DriverLuna_UpdateDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverLuna_Context *ctx = (SDL_DriverLuna_Context *)device->context;
+    SDL_Joystick *joystick = NULL;
+    Uint8 data[USB_PACKET_LENGTH];
+    int size = 0;
+
+    if (device->num_joysticks > 0) {
+        joystick = SDL_JoystickFromInstanceID(device->joysticks[0]);
+    }
+    if (!joystick) {
+        return SDL_FALSE;
+    }
+
+    while ((size = SDL_hid_read_timeout(device->dev, data, sizeof(data), 0)) > 0) {
+#ifdef DEBUG_LUNA_PROTOCOL
+        HIDAPI_DumpPacket("Amazon Luna packet: size = %d", data, size);
+#endif
+        switch (size) {
+        case 10:
+            HIDAPI_DriverLuna_HandleUSBStatePacket(joystick, ctx, data, size);
+            break;
+        default:
+            HIDAPI_DriverLuna_HandleBluetoothStatePacket(joystick, ctx, data, size);
+            break;
+        }
+    }
+
+    if (size < 0) {
+        /* Read error, device is disconnected */
+        HIDAPI_JoystickDisconnected(device, joystick->instance_id);
+    }
+    return (size >= 0);
+}
+
+static void
+HIDAPI_DriverLuna_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_LockMutex(device->dev_lock);
+    {
+        if (device->dev) {
+            SDL_hid_close(device->dev);
+            device->dev = NULL;
+        }
+
+        SDL_free(device->context);
+        device->context = NULL;
+    }
+    SDL_UnlockMutex(device->dev_lock);
+}
+
+static void
+HIDAPI_DriverLuna_FreeDevice(SDL_HIDAPI_Device *device)
+{
+}
+
+SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverLuna =
+{
+    SDL_HINT_JOYSTICK_HIDAPI_LUNA,
+    SDL_TRUE,
+    SDL_TRUE,
+    HIDAPI_DriverLuna_IsSupportedDevice,
+    HIDAPI_DriverLuna_GetDeviceName,
+    HIDAPI_DriverLuna_InitDevice,
+    HIDAPI_DriverLuna_GetDevicePlayerIndex,
+    HIDAPI_DriverLuna_SetDevicePlayerIndex,
+    HIDAPI_DriverLuna_UpdateDevice,
+    HIDAPI_DriverLuna_OpenJoystick,
+    HIDAPI_DriverLuna_RumbleJoystick,
+    HIDAPI_DriverLuna_RumbleJoystickTriggers,
+    HIDAPI_DriverLuna_GetJoystickCapabilities,
+    HIDAPI_DriverLuna_SetJoystickLED,
+    HIDAPI_DriverLuna_SendJoystickEffect,
+    HIDAPI_DriverLuna_SetJoystickSensorsEnabled,
+    HIDAPI_DriverLuna_CloseJoystick,
+    HIDAPI_DriverLuna_FreeDevice,
+};
+
+#endif /* SDL_JOYSTICK_HIDAPI_LUNA */
+
+#endif /* SDL_JOYSTICK_HIDAPI */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_ps4.c b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_ps4.c
index a20757183..8e7699fe4 100644
--- a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_ps4.c
+++ b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_ps4.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -30,6 +30,7 @@
 #include "SDL_timer.h"
 #include "SDL_joystick.h"
 #include "SDL_gamecontroller.h"
+#include "../../SDL_hints_c.h"
 #include "../SDL_sysjoystick.h"
 #include "SDL_hidapijoystick_c.h"
 #include "SDL_hidapi_rumble.h"
@@ -45,6 +46,7 @@
 
 #define GYRO_RES_PER_DEGREE 1024.0f
 #define ACCEL_RES_PER_G     8192.0f
+#define BLUETOOTH_DISCONNECT_TIMEOUT_MS 500
 
 #define LOAD16(A, B)  (Sint16)((Uint16)(A) | (((Uint16)(B)) << 8))
 
@@ -119,14 +121,18 @@ typedef struct {
 } IMUCalibrationData;
 
 typedef struct {
+    SDL_HIDAPI_Device *device;
+    SDL_Joystick *joystick;
     SDL_bool is_dongle;
     SDL_bool is_bluetooth;
     SDL_bool official_controller;
     SDL_bool audio_supported;
     SDL_bool effects_supported;
+    SDL_bool enhanced_mode;
     SDL_bool report_sensors;
     SDL_bool hardware_calibration;
     IMUCalibrationData calibration[6];
+    Uint32 last_packet;
     int player_index;
     Uint8 rumble_left;
     Uint8 rumble_right;
@@ -140,6 +146,8 @@ typedef struct {
 } SDL_DriverPS4_Context;
 
 
+static int HIDAPI_DriverPS4_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *effect, int size);
+
 static SDL_bool
 HIDAPI_DriverPS4_IsSupportedDevice(const char *name, SDL_GameControllerType type, Uint16 vendor_id, Uint16 product_id, Uint16 version, int interface_number, int interface_class, int interface_subclass, int interface_protocol)
 {
@@ -155,11 +163,11 @@ HIDAPI_DriverPS4_GetDeviceName(Uint16 vendor_id, Uint16 product_id)
     return NULL;
 }
 
-static int ReadFeatureReport(hid_device *dev, Uint8 report_id, Uint8 *report, size_t length)
+static int ReadFeatureReport(SDL_hid_device *dev, Uint8 report_id, Uint8 *report, size_t length)
 {
     SDL_memset(report, 0, length);
     report[0] = report_id;
-    return hid_get_feature_report(dev, report, length);
+    return SDL_hid_get_feature_report(dev, report, length);
 }
 
 static SDL_bool HIDAPI_DriverPS4_CanRumble(Uint16 vendor_id, Uint16 product_id)
@@ -169,6 +177,12 @@ static SDL_bool HIDAPI_DriverPS4_CanRumble(Uint16 vendor_id, Uint16 product_id)
         (product_id == USB_PRODUCT_RAZER_PANTHERA || product_id == USB_PRODUCT_RAZER_PANTHERA_EVO)) {
         return SDL_FALSE;
     }
+
+    /* The Victrix Pro FS v2 will hang on reboot if we send output reports */
+    if (vendor_id == USB_VENDOR_PDP && product_id == USB_PRODUCT_VICTRIX_FS_PRO_V2) {
+        return SDL_FALSE;
+    }
+
     return SDL_TRUE;
 }
 
@@ -379,57 +393,66 @@ static int
 HIDAPI_DriverPS4_UpdateEffects(SDL_HIDAPI_Device *device)
 {
     SDL_DriverPS4_Context *ctx = (SDL_DriverPS4_Context *)device->context;
-    DS4EffectsState_t *effects;
-    Uint8 data[78];
-    int report_size, offset;
+    DS4EffectsState_t effects;
 
-    if (!ctx->effects_supported) {
+    if (!ctx->enhanced_mode) {
         return SDL_Unsupported();
     }
 
-    SDL_zero(data);
+    SDL_zero(effects);
 
-    if (ctx->is_bluetooth) {
-        data[0] = k_EPS4ReportIdBluetoothEffects;
-        data[1] = 0xC0 | 0x04;  /* Magic value HID + CRC, also sets interval to 4ms for samples */
-        data[3] = 0x03;  /* 0x1 is rumble, 0x2 is lightbar, 0x4 is the blink interval */
-
-        report_size = 78;
-        offset = 6;
-    } else {
-        data[0] = k_EPS4ReportIdUsbEffects;
-        data[1] = 0x07;  /* Magic value */
-
-        report_size = 32;
-        offset = 4;
-    }
-    effects = (DS4EffectsState_t *)&data[offset];
-
-    effects->ucRumbleLeft = ctx->rumble_left;
-    effects->ucRumbleRight = ctx->rumble_right;
+    effects.ucRumbleLeft = ctx->rumble_left;
+    effects.ucRumbleRight = ctx->rumble_right;
 
     /* Populate the LED state with the appropriate color from our lookup table */
     if (ctx->color_set) {
-        effects->ucLedRed = ctx->led_red;
-        effects->ucLedGreen = ctx->led_green;
-        effects->ucLedBlue = ctx->led_blue;
+        effects.ucLedRed = ctx->led_red;
+        effects.ucLedGreen = ctx->led_green;
+        effects.ucLedBlue = ctx->led_blue;
     } else {
-        SetLedsForPlayerIndex(effects, ctx->player_index);
+        SetLedsForPlayerIndex(&effects, ctx->player_index);
     }
+    return HIDAPI_DriverPS4_SendJoystickEffect(device, ctx->joystick, &effects, sizeof(effects));
+}
 
-    if (ctx->is_bluetooth) {
-        /* Bluetooth reports need a CRC at the end of the packet (at least on Linux) */
-        Uint8 ubHdr = 0xA2; /* hidp header is part of the CRC calculation */
-        Uint32 unCRC;
-        unCRC = SDL_crc32(0, &ubHdr, 1);
-        unCRC = SDL_crc32(unCRC, data, (size_t)(report_size - sizeof(unCRC)));
-        SDL_memcpy(&data[report_size - sizeof(unCRC)], &unCRC, sizeof(unCRC));
-    }
+static void
+HIDAPI_DriverPS4_TickleBluetooth(SDL_HIDAPI_Device *device)
+{
+    /* This is just a dummy packet that should have no effect, since we don't set the CRC */
+    Uint8 data[78];
 
-    if (SDL_HIDAPI_SendRumble(device, data, report_size) != report_size) {
-        return SDL_SetError("Couldn't send rumble packet");
+    SDL_zeroa(data);
+
+    data[0] = k_EPS4ReportIdBluetoothEffects;
+    data[1] = 0xC0;  /* Magic value HID + CRC */
+
+    SDL_HIDAPI_SendRumble(device, data, sizeof(data));
+}
+
+static void
+HIDAPI_DriverPS4_SetEnhancedMode(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverPS4_Context *ctx = (SDL_DriverPS4_Context *)device->context;
+
+    if (!ctx->enhanced_mode) {
+        ctx->enhanced_mode = SDL_TRUE;
+
+        SDL_PrivateJoystickAddTouchpad(joystick, 2);
+        SDL_PrivateJoystickAddSensor(joystick, SDL_SENSOR_GYRO, 250.0f);
+        SDL_PrivateJoystickAddSensor(joystick, SDL_SENSOR_ACCEL, 250.0f);
+
+        HIDAPI_DriverPS4_UpdateEffects(device);
+    }
+}
+
+static void SDLCALL SDL_PS4RumbleHintChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
+{
+    SDL_DriverPS4_Context *ctx = (SDL_DriverPS4_Context *)userdata;
+
+    /* This is a one-way trip, you can't switch the controller back to simple report mode */
+    if (SDL_GetStringBoolean(hint, SDL_FALSE)) {
+        HIDAPI_DriverPS4_SetEnhancedMode(ctx->device, ctx->joystick);
     }
-    return 0;
 }
 
 static void
@@ -451,14 +474,18 @@ static SDL_bool
 HIDAPI_DriverPS4_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
 {
     SDL_DriverPS4_Context *ctx;
+    SDL_bool enhanced_mode = SDL_FALSE;
 
     ctx = (SDL_DriverPS4_Context *)SDL_calloc(1, sizeof(*ctx));
     if (!ctx) {
         SDL_OutOfMemory();
         return SDL_FALSE;
     }
+    ctx->device = device;
+    ctx->joystick = joystick;
+    ctx->last_packet = SDL_GetTicks();
 
-    device->dev = hid_open_path(device->path, 0);
+    device->dev = SDL_hid_open_path(device->path, 0);
     if (!device->dev) {
         SDL_free(ctx);
         SDL_SetError("Couldn't open %s", device->path);
@@ -471,6 +498,7 @@ HIDAPI_DriverPS4_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
     if (ctx->is_dongle) {
         ctx->is_bluetooth = SDL_FALSE;
         ctx->official_controller = SDL_TRUE;
+        enhanced_mode = SDL_TRUE;
     } else if (device->vendor_id == USB_VENDOR_SONY) {
         Uint8 data[USB_PACKET_LENGTH];
         int size;
@@ -484,13 +512,30 @@ HIDAPI_DriverPS4_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
                 data[6], data[5], data[4], data[3], data[2], data[1]);
             joystick->serial = SDL_strdup(serial);
             ctx->is_bluetooth = SDL_FALSE;
+            enhanced_mode = SDL_TRUE;
         } else {
             ctx->is_bluetooth = SDL_TRUE;
+
+            /* Read a report to see if we're in enhanced mode */
+            size = SDL_hid_read_timeout(device->dev, data, sizeof(data), 16);
+#ifdef DEBUG_PS4_PROTOCOL
+            if (size > 0) {
+                HIDAPI_DumpPacket("PS4 first packet: size = %d", data, size);
+            } else {
+                SDL_Log("PS4 first packet: size = %d\n", size);
+            }
+#endif
+            if (size > 0 &&
+                data[0] >= k_EPS4ReportIdBluetoothState1 &&
+                data[0] <= k_EPS4ReportIdBluetoothState9) {
+                enhanced_mode = SDL_TRUE;
+            }
         }
         ctx->official_controller = SDL_TRUE;
     } else {
         /* Third party controllers appear to all be wired */
         ctx->is_bluetooth = SDL_FALSE;
+        enhanced_mode = SDL_TRUE;
     }
 #ifdef DEBUG_PS4
     SDL_Log("PS4 dongle = %s, bluetooth = %s\n", ctx->is_dongle ? "TRUE" : "FALSE", ctx->is_bluetooth ? "TRUE" : "FALSE");
@@ -503,28 +548,42 @@ HIDAPI_DriverPS4_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
     }
 
     if (HIDAPI_DriverPS4_CanRumble(device->vendor_id, device->product_id)) {
-        if (ctx->is_bluetooth) {
-            ctx->effects_supported = SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_PS4_RUMBLE, SDL_FALSE);
-        } else {
-            ctx->effects_supported = SDL_TRUE;
+        ctx->effects_supported = SDL_TRUE;
+    }
+
+    if (!joystick->serial && device->serial && SDL_strlen(device->serial) == 12) {
+        int i, j;
+        char serial[18];
+
+        j = -1;
+        for (i = 0; i < 12; i += 2) {
+            j += 1;
+            SDL_memcpy(&serial[j], &device->serial[i], 2);
+            j += 2;
+            serial[j] = '-';
         }
+        serial[j] = '\0';
+
+        joystick->serial = SDL_strdup(serial);
     }
 
     /* Initialize player index (needed for setting LEDs) */
     ctx->player_index = SDL_JoystickGetPlayerIndex(joystick);
 
-    /* Initialize LED and effect state */
-    HIDAPI_DriverPS4_UpdateEffects(device);
-
-    /* Initialize the joystick capabilities */
+    /* Initialize the joystick capabilities
+     *
+     * We can't dynamically add the touchpad button, so always report it here
+     */
     joystick->nbuttons = 16;
     joystick->naxes = SDL_CONTROLLER_AXIS_MAX;
-    joystick->epowerlevel = SDL_JOYSTICK_POWER_WIRED;
-
-    SDL_PrivateJoystickAddTouchpad(joystick, 2);
-    SDL_PrivateJoystickAddSensor(joystick, SDL_SENSOR_GYRO);
-    SDL_PrivateJoystickAddSensor(joystick, SDL_SENSOR_ACCEL);
+    joystick->epowerlevel = ctx->is_bluetooth ? SDL_JOYSTICK_POWER_UNKNOWN : SDL_JOYSTICK_POWER_WIRED;
 
+    if (enhanced_mode) {
+        HIDAPI_DriverPS4_SetEnhancedMode(device, joystick);
+    } else {
+        SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_PS4_RUMBLE,
+                            SDL_PS4RumbleHintChanged, ctx);
+    }
     return SDL_TRUE;
 }
 
@@ -545,10 +604,17 @@ HIDAPI_DriverPS4_RumbleJoystickTriggers(SDL_HIDAPI_Device *device, SDL_Joystick
     return SDL_Unsupported();
 }
 
-static SDL_bool
-HIDAPI_DriverPS4_HasJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+static Uint32
+HIDAPI_DriverPS4_GetJoystickCapabilities(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
 {
-    return SDL_TRUE;
+    SDL_DriverPS4_Context *ctx = (SDL_DriverPS4_Context *)device->context;
+    Uint32 result = 0;
+
+    if (ctx->enhanced_mode && ctx->effects_supported) {
+        result |= SDL_JOYCAP_LED | SDL_JOYCAP_RUMBLE;
+    }
+
+    return result;
 }
 
 static int
@@ -564,11 +630,64 @@ HIDAPI_DriverPS4_SetJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystic
     return HIDAPI_DriverPS4_UpdateEffects(device);
 }
 
+static int
+HIDAPI_DriverPS4_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *effect, int size)
+{
+    SDL_DriverPS4_Context *ctx = (SDL_DriverPS4_Context *)device->context;
+    Uint8 data[78];
+    int report_size, offset;
+
+    if (!ctx->effects_supported) {
+        return SDL_Unsupported();
+    }
+
+    if (!ctx->enhanced_mode) {
+        HIDAPI_DriverPS4_SetEnhancedMode(device, joystick);
+    }
+
+    SDL_zeroa(data);
+
+    if (ctx->is_bluetooth) {
+        data[0] = k_EPS4ReportIdBluetoothEffects;
+        data[1] = 0xC0 | 0x04;  /* Magic value HID + CRC, also sets interval to 4ms for samples */
+        data[3] = 0x03;  /* 0x1 is rumble, 0x2 is lightbar, 0x4 is the blink interval */
+
+        report_size = 78;
+        offset = 6;
+    } else {
+        data[0] = k_EPS4ReportIdUsbEffects;
+        data[1] = 0x07;  /* Magic value */
+
+        report_size = 32;
+        offset = 4;
+    }
+
+    SDL_memcpy(&data[offset], effect, SDL_min((sizeof(data) - offset), (size_t)size));
+
+    if (ctx->is_bluetooth) {
+        /* Bluetooth reports need a CRC at the end of the packet (at least on Linux) */
+        Uint8 ubHdr = 0xA2; /* hidp header is part of the CRC calculation */
+        Uint32 unCRC;
+        unCRC = SDL_crc32(0, &ubHdr, 1);
+        unCRC = SDL_crc32(unCRC, data, (size_t)(report_size - sizeof(unCRC)));
+        SDL_memcpy(&data[report_size - sizeof(unCRC)], &unCRC, sizeof(unCRC));
+    }
+
+    if (SDL_HIDAPI_SendRumble(device, data, report_size) != report_size) {
+        return SDL_SetError("Couldn't send rumble packet");
+    }
+    return 0;
+}
+
 static int
 HIDAPI_DriverPS4_SetJoystickSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, SDL_bool enabled)
 {
     SDL_DriverPS4_Context *ctx = (SDL_DriverPS4_Context *)device->context;
 
+    if (!ctx->enhanced_mode) {
+        return SDL_Unsupported();
+    }
+
     if (enabled) {
         HIDAPI_DriverPS4_LoadCalibrationData(device);
     }
@@ -578,7 +697,7 @@ HIDAPI_DriverPS4_SetJoystickSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joysti
 }
 
 static void
-HIDAPI_DriverPS4_HandleStatePacket(SDL_Joystick *joystick, hid_device *dev, SDL_DriverPS4_Context *ctx, PS4StatePacket_t *packet)
+HIDAPI_DriverPS4_HandleStatePacket(SDL_Joystick *joystick, SDL_hid_device *dev, SDL_DriverPS4_Context *ctx, PS4StatePacket_t *packet)
 {
     static const float TOUCHPAD_SCALEX = 1.0f / 1920;
     static const float TOUCHPAD_SCALEY = 1.0f / 920;    /* This is noted as being 944 resolution, but 920 feels better */
@@ -729,8 +848,9 @@ HIDAPI_DriverPS4_UpdateDevice(SDL_HIDAPI_Device *device)
 {
     SDL_DriverPS4_Context *ctx = (SDL_DriverPS4_Context *)device->context;
     SDL_Joystick *joystick = NULL;
-    Uint8 data[USB_PACKET_LENGTH];
+    Uint8 data[USB_PACKET_LENGTH*2];
     int size;
+    int packet_count = 0;
 
     if (device->num_joysticks > 0) {
         joystick = SDL_JoystickFromInstanceID(device->joysticks[0]);
@@ -739,10 +859,13 @@ HIDAPI_DriverPS4_UpdateDevice(SDL_HIDAPI_Device *device)
         return SDL_FALSE;
     }
 
-    while ((size = hid_read_timeout(device->dev, data, sizeof(data), 0)) > 0) {
+    while ((size = SDL_hid_read_timeout(device->dev, data, sizeof(data), 0)) > 0) {
 #ifdef DEBUG_PS4_PROTOCOL
         HIDAPI_DumpPacket("PS4 packet: size = %d", data, size);
 #endif
+        ++packet_count;
+        ctx->last_packet = SDL_GetTicks();
+
         switch (data[0]) {
         case k_EPS4ReportIdUsbState:
             HIDAPI_DriverPS4_HandleStatePacket(joystick, device->dev, ctx, (PS4StatePacket_t *)&data[1]);
@@ -756,6 +879,10 @@ HIDAPI_DriverPS4_UpdateDevice(SDL_HIDAPI_Device *device)
         case k_EPS4ReportIdBluetoothState7:
         case k_EPS4ReportIdBluetoothState8:
         case k_EPS4ReportIdBluetoothState9:
+            if (!ctx->enhanced_mode) {
+                /* This is the extended report, we can enable effects now */
+                HIDAPI_DriverPS4_SetEnhancedMode(device, joystick);
+            }
             /* Bluetooth state packets have two additional bytes at the beginning, the first notes if HID is present */
             if (data[1] & 0x80) {
                 HIDAPI_DriverPS4_HandleStatePacket(joystick, device->dev, ctx, (PS4StatePacket_t*)&data[3]);
@@ -769,6 +896,14 @@ HIDAPI_DriverPS4_UpdateDevice(SDL_HIDAPI_Device *device)
         }
     }
 
+    if (ctx->is_bluetooth && packet_count == 0) {
+        /* Check to see if it looks like the device disconnected */
+        if (SDL_TICKS_PASSED(SDL_GetTicks(), ctx->last_packet + BLUETOOTH_DISCONNECT_TIMEOUT_MS)) {
+            /* Send an empty output report to tickle the Bluetooth stack */
+            HIDAPI_DriverPS4_TickleBluetooth(device);
+        }
+    }
+
     if (size < 0) {
         /* Read error, device is disconnected */
         HIDAPI_JoystickDisconnected(device, joystick->instance_id);
@@ -779,11 +914,20 @@ HIDAPI_DriverPS4_UpdateDevice(SDL_HIDAPI_Device *device)
 static void
 HIDAPI_DriverPS4_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
 {
-    hid_close(device->dev);
-    device->dev = NULL;
+    SDL_DriverPS4_Context *ctx = (SDL_DriverPS4_Context *)device->context;
 
-    SDL_free(device->context);
-    device->context = NULL;
+    SDL_DelHintCallback(SDL_HINT_JOYSTICK_HIDAPI_PS4_RUMBLE,
+                        SDL_PS4RumbleHintChanged, ctx);
+
+    SDL_LockMutex(device->dev_lock);
+    {
+        SDL_hid_close(device->dev);
+        device->dev = NULL;
+
+        SDL_free(device->context);
+        device->context = NULL;
+    }
+    SDL_UnlockMutex(device->dev_lock);
 }
 
 static void
@@ -795,6 +939,7 @@ SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverPS4 =
 {
     SDL_HINT_JOYSTICK_HIDAPI_PS4,
     SDL_TRUE,
+    SDL_TRUE,
     HIDAPI_DriverPS4_IsSupportedDevice,
     HIDAPI_DriverPS4_GetDeviceName,
     HIDAPI_DriverPS4_InitDevice,
@@ -804,8 +949,9 @@ SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverPS4 =
     HIDAPI_DriverPS4_OpenJoystick,
     HIDAPI_DriverPS4_RumbleJoystick,
     HIDAPI_DriverPS4_RumbleJoystickTriggers,
-    HIDAPI_DriverPS4_HasJoystickLED,
+    HIDAPI_DriverPS4_GetJoystickCapabilities,
     HIDAPI_DriverPS4_SetJoystickLED,
+    HIDAPI_DriverPS4_SendJoystickEffect,
     HIDAPI_DriverPS4_SetJoystickSensorsEnabled,
     HIDAPI_DriverPS4_CloseJoystick,
     HIDAPI_DriverPS4_FreeDevice,
diff --git a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_ps5.c b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_ps5.c
index fc0554124..6d7f87d59 100644
--- a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_ps5.c
+++ b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_ps5.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -27,6 +27,7 @@
 #include "SDL_timer.h"
 #include "SDL_joystick.h"
 #include "SDL_gamecontroller.h"
+#include "../../SDL_hints_c.h"
 #include "../SDL_sysjoystick.h"
 #include "SDL_hidapijoystick_c.h"
 #include "SDL_hidapi_rumble.h"
@@ -129,13 +130,12 @@ typedef struct
 } DS5EffectsState_t;
 
 typedef enum {
-    k_EDS5EffectNone,
-    k_EDS5EffectRumbleStart,
-    k_EDS5EffectRumble,
-    k_EDS5EffectLEDReset,
-    k_EDS5EffectLED,
-    k_EDS5EffectPadLights,
-    k_EDS5EffectMicLight,
+    k_EDS5EffectRumbleStart             = (1 << 0),
+    k_EDS5EffectRumble                  = (1 << 1),
+    k_EDS5EffectLEDReset                = (1 << 2),
+    k_EDS5EffectLED                     = (1 << 3),
+    k_EDS5EffectPadLights               = (1 << 4),
+    k_EDS5EffectMicLight                = (1 << 5)
 } EDS5Effect;
 
 typedef enum {
@@ -150,12 +150,16 @@ typedef struct {
 } IMUCalibrationData;
 
 typedef struct {
+    SDL_HIDAPI_Device *device;
+    SDL_Joystick *joystick;
     SDL_bool is_bluetooth;
+    SDL_bool enhanced_mode;
     SDL_bool report_sensors;
     SDL_bool hardware_calibration;
     IMUCalibrationData calibration[6];
     Uint32 last_packet;
     int player_index;
+    SDL_bool player_lights;
     Uint8 rumble_left;
     Uint8 rumble_right;
     SDL_bool color_set;
@@ -171,6 +175,8 @@ typedef struct {
 } SDL_DriverPS5_Context;
 
 
+static int HIDAPI_DriverPS5_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *effect, int size);
+
 static SDL_bool
 HIDAPI_DriverPS5_IsSupportedDevice(const char *name, SDL_GameControllerType type, Uint16 vendor_id, Uint16 product_id, Uint16 version, int interface_number, int interface_class, int interface_subclass, int interface_protocol)
 {
@@ -186,11 +192,11 @@ HIDAPI_DriverPS5_GetDeviceName(Uint16 vendor_id, Uint16 product_id)
     return NULL;
 }
 
-static int ReadFeatureReport(hid_device *dev, Uint8 report_id, Uint8 *report, size_t length)
+static int ReadFeatureReport(SDL_hid_device *dev, Uint8 report_id, Uint8 *report, size_t length)
 {
     SDL_memset(report, 0, length);
     report[0] = report_id;
-    return hid_get_feature_report(dev, report, length);
+    return SDL_hid_get_feature_report(dev, report, length);
 }
 
 static void
@@ -204,9 +210,9 @@ SetLedsForPlayerIndex(DS5EffectsState_t *effects, int player_index)
         { 0x40, 0x00, 0x00 }, /* Red */
         { 0x00, 0x40, 0x00 }, /* Green */
         { 0x20, 0x00, 0x20 }, /* Pink */
-        { 0x02, 0x01, 0x00 }, /* Orange */
-        { 0x00, 0x01, 0x01 }, /* Teal */
-        { 0x01, 0x01, 0x01 }  /* White */
+        { 0x20, 0x10, 0x00 }, /* Orange */
+        { 0x00, 0x10, 0x10 }, /* Teal */
+        { 0x10, 0x10, 0x10 }  /* White */
     };
 
     if (player_index >= 0) {
@@ -220,6 +226,24 @@ SetLedsForPlayerIndex(DS5EffectsState_t *effects, int player_index)
     effects->ucLedBlue = colors[player_index][2];
 }
 
+static void
+SetLightsForPlayerIndex(DS5EffectsState_t *effects, int player_index)
+{
+    static const Uint8 lights[] = {
+        0x04,
+        0x0A,
+        0x15,
+        0x1B
+    };
+
+    if (player_index >= 0 && player_index < SDL_arraysize(lights)) {
+        /* Bitmask, 0x1F enables all lights, 0x20 changes instantly instead of fade */
+        effects->ucPadLights = lights[player_index] | 0x20;
+    } else {
+        effects->ucPadLights = 0x00;
+    }
+}
+
 static SDL_bool
 HIDAPI_DriverPS5_InitDevice(SDL_HIDAPI_Device *device)
 {
@@ -350,35 +374,20 @@ HIDAPI_DriverPS5_ApplyCalibrationData(SDL_DriverPS5_Context *ctx, int index, Sin
 }
 
 static int
-HIDAPI_DriverPS5_UpdateEffects(SDL_HIDAPI_Device *device, EDS5Effect effect)
+HIDAPI_DriverPS5_UpdateEffects(SDL_HIDAPI_Device *device, int effect_mask)
 {
     SDL_DriverPS5_Context *ctx = (SDL_DriverPS5_Context *)device->context;
-    DS5EffectsState_t *effects;
-    Uint8 data[78];
-    int report_size, offset;
-    Uint8 *pending_data;
-    int *pending_size;
-    int maximum_size;
+    DS5EffectsState_t effects;
 
-
-    SDL_zero(data);
-
-    if (ctx->is_bluetooth) {
-        data[0] = k_EPS5ReportIdBluetoothEffects;
-        data[1] = 0x02;  /* Magic value */
-
-        report_size = 78;
-        offset = 2;
-    } else {
-        data[0] = k_EPS5ReportIdUsbEffects;
-
-        report_size = 48;
-        offset = 1;
+    if (!ctx->enhanced_mode) {
+        return SDL_Unsupported();
     }
-    effects = (DS5EffectsState_t *)&data[offset];
+
+    SDL_zero(effects);
 
     /* Make sure the Bluetooth connection sequence has completed before sending LED color change */
-    if (effect == k_EDS5EffectLED && ctx->is_bluetooth) {
+    if (ctx->is_bluetooth && 
+        (effect_mask & (k_EDS5EffectLED | k_EDS5EffectPadLights)) != 0) {
         if (ctx->led_reset_state != k_EDS5LEDResetStateComplete) {
             ctx->led_reset_state = k_EDS5LEDResetStatePending;
             return 0;
@@ -386,90 +395,53 @@ HIDAPI_DriverPS5_UpdateEffects(SDL_HIDAPI_Device *device, EDS5Effect effect)
     }
 
     if (ctx->rumble_left || ctx->rumble_right) {
-        effects->ucEnableBits1 |= 0x01; /* Enable rumble emulation */
-        effects->ucEnableBits1 |= 0x02; /* Disable audio haptics */
+        effects.ucEnableBits1 |= 0x01; /* Enable rumble emulation */
+        effects.ucEnableBits1 |= 0x02; /* Disable audio haptics */
 
         /* Shift to reduce effective rumble strength to match Xbox controllers */
-        effects->ucRumbleLeft = ctx->rumble_left >> 1;
-        effects->ucRumbleRight = ctx->rumble_right >> 1;
+        effects.ucRumbleLeft = ctx->rumble_left >> 1;
+        effects.ucRumbleRight = ctx->rumble_right >> 1;
     } else {
         /* Leaving emulated rumble bits off will restore audio haptics */
     }
 
-    switch (effect) {
-    case k_EDS5EffectRumbleStart:
-        effects->ucEnableBits1 |= 0x02; /* Disable audio haptics */
-        break;
-    case k_EDS5EffectRumble:
+    if ((effect_mask & k_EDS5EffectRumbleStart) != 0) {
+        effects.ucEnableBits1 |= 0x02; /* Disable audio haptics */
+    }
+    if ((effect_mask & k_EDS5EffectRumble) != 0) {
         /* Already handled above */
-        break;
-    case k_EDS5EffectLEDReset:
-        effects->ucEnableBits2 |= 0x08; /* Reset LED state */
-        break;
-    case k_EDS5EffectLED:
-        effects->ucEnableBits2 |= 0x04; /* Enable LED color */
+    }
+    if ((effect_mask & k_EDS5EffectLEDReset) != 0) {
+        effects.ucEnableBits2 |= 0x08; /* Reset LED state */
+    }
+    if ((effect_mask & k_EDS5EffectLED) != 0) {
+        effects.ucEnableBits2 |= 0x04; /* Enable LED color */
 
         /* Populate the LED state with the appropriate color from our lookup table */
         if (ctx->color_set) {
-            effects->ucLedRed = ctx->led_red;
-            effects->ucLedGreen = ctx->led_green;
-            effects->ucLedBlue = ctx->led_blue;
+            effects.ucLedRed = ctx->led_red;
+            effects.ucLedGreen = ctx->led_green;
+            effects.ucLedBlue = ctx->led_blue;
         } else {
-            SetLedsForPlayerIndex(effects, ctx->player_index);
-        }
-        break;
-    case k_EDS5EffectPadLights:
-        effects->ucEnableBits2 |= 0x10; /* Enable touchpad lights */
-
-        effects->ucPadLights = 0x00;    /* Bitmask, 0x1F enables all lights, 0x20 changes instantly instead of fade */
-        break;
-    case k_EDS5EffectMicLight:
-        effects->ucEnableBits2 |= 0x01; /* Enable microphone light */
-
-        effects->ucMicLightMode = 0;    /* Bitmask, 0x00 = off, 0x01 = solid, 0x02 = pulse */
-        break;
-    default:
-        break;
-    }
-
-    if (ctx->is_bluetooth) {
-        /* Bluetooth reports need a CRC at the end of the packet (at least on Linux) */
-        Uint8 ubHdr = 0xA2; /* hidp header is part of the CRC calculation */
-        Uint32 unCRC;
-        unCRC = SDL_crc32(0, &ubHdr, 1);
-        unCRC = SDL_crc32(unCRC, data, (size_t)(report_size - sizeof(unCRC)));
-        SDL_memcpy(&data[report_size - sizeof(unCRC)], &unCRC, sizeof(unCRC));
-    }
-
-    if (SDL_HIDAPI_LockRumble() < 0) {
-        return -1;
-    }
-
-    /* See if we can update an existing pending request */
-    if (SDL_HIDAPI_GetPendingRumbleLocked(device, &pending_data, &pending_size, &maximum_size)) {
-        DS5EffectsState_t *pending_effects = (DS5EffectsState_t *)&pending_data[offset];
-        if (report_size == *pending_size &&
-            effects->ucEnableBits1 == pending_effects->ucEnableBits1 &&
-            effects->ucEnableBits2 == pending_effects->ucEnableBits2) {
-            /* We're simply updating the data for this request */
-            SDL_memcpy(pending_data, data, report_size);
-            SDL_HIDAPI_UnlockRumble();
-            return 0;
+            SetLedsForPlayerIndex(&effects, ctx->player_index);
         }
     }
+    if ((effect_mask & k_EDS5EffectPadLights) != 0) {
+        effects.ucEnableBits2 |= 0x10; /* Enable touchpad lights */
 
-    return SDL_HIDAPI_SendRumbleAndUnlock(device, data, report_size);
-}
-
-static void
-HIDAPI_DriverPS5_SetBluetooth(SDL_HIDAPI_Device *device, SDL_bool is_bluetooth)
-{
-    SDL_DriverPS5_Context *ctx = (SDL_DriverPS5_Context *)device->context;
-
-    if (ctx->is_bluetooth != is_bluetooth) {
-        ctx->is_bluetooth = is_bluetooth;
-        HIDAPI_DriverPS5_UpdateEffects(device, k_EDS5EffectLED);
+        if (ctx->player_lights) {
+            SetLightsForPlayerIndex(&effects, ctx->player_index);
+        } else {
+            effects.ucPadLights = 0x00;
+        }
     }
+    if ((effect_mask & k_EDS5EffectMicLight) != 0) {
+        effects.ucEnableBits2 |= 0x01; /* Enable microphone light */
+
+        effects.ucMicLightMode = 0;    /* Bitmask, 0x00 = off, 0x01 = solid, 0x02 = pulse */
+    }
+
+    return HIDAPI_DriverPS5_SendJoystickEffect(device, ctx->joystick, &effects, sizeof(effects));
 }
 
 static void
@@ -479,17 +451,73 @@ HIDAPI_DriverPS5_CheckPendingLEDReset(SDL_HIDAPI_Device *device)
     const PS5StatePacket_t *packet = &ctx->last_state.state;
 
     /* Check the timer to make sure the Bluetooth connection LED animation is complete */
-    const Uint32 connection_complete = 10000000;
+    const Uint32 connection_complete = 10200000;
     Uint32 timer = ((Uint32)packet->rgucTimer1[0] <<  0) |
                    ((Uint32)packet->rgucTimer1[1] <<  8) |
                    ((Uint32)packet->rgucTimer1[2] << 16) |
                    ((Uint32)packet->rgucTimer1[3] << 24);
-    if (timer >= connection_complete) {
+    if (SDL_TICKS_PASSED(timer, connection_complete)) {
         HIDAPI_DriverPS5_UpdateEffects(device, k_EDS5EffectLEDReset);
 
         ctx->led_reset_state = k_EDS5LEDResetStateComplete;
 
-        HIDAPI_DriverPS5_UpdateEffects(device, k_EDS5EffectLED);
+        HIDAPI_DriverPS5_UpdateEffects(device, (k_EDS5EffectLED | k_EDS5EffectPadLights));
+    }
+}
+
+static void
+HIDAPI_DriverPS5_TickleBluetooth(SDL_HIDAPI_Device *device)
+{
+    /* This is just a dummy packet that should have no effect, since we don't set the CRC */
+    Uint8 data[78];
+
+    SDL_zeroa(data);
+
+    data[0] = k_EPS5ReportIdBluetoothEffects;
+    data[1] = 0x02;  /* Magic value */
+
+    SDL_HIDAPI_SendRumble(device, data, sizeof(data));
+}
+
+static void
+HIDAPI_DriverPS5_SetEnhancedMode(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverPS5_Context *ctx = (SDL_DriverPS5_Context *)device->context;
+
+    if (!ctx->enhanced_mode) {
+        ctx->enhanced_mode = SDL_TRUE;
+
+        SDL_PrivateJoystickAddTouchpad(joystick, 2);
+        SDL_PrivateJoystickAddSensor(joystick, SDL_SENSOR_GYRO, 250.0f);
+        SDL_PrivateJoystickAddSensor(joystick, SDL_SENSOR_ACCEL, 250.0f);
+
+        /* Switch into enhanced report mode */
+        HIDAPI_DriverPS5_UpdateEffects(device, 0);
+
+        /* Update the light effects */
+        HIDAPI_DriverPS5_UpdateEffects(device, (k_EDS5EffectLED | k_EDS5EffectPadLights));
+    }
+}
+
+static void SDLCALL SDL_PS5RumbleHintChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
+{
+    SDL_DriverPS5_Context *ctx = (SDL_DriverPS5_Context *)userdata;
+
+    /* This is a one-way trip, you can't switch the controller back to simple report mode */
+    if (SDL_GetStringBoolean(hint, SDL_FALSE)) {
+        HIDAPI_DriverPS5_SetEnhancedMode(ctx->device, ctx->joystick);
+    }
+}
+
+static void SDLCALL SDL_PS5PlayerLEDHintChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
+{
+    SDL_DriverPS5_Context *ctx = (SDL_DriverPS5_Context *)userdata;
+    SDL_bool player_lights = SDL_GetStringBoolean(hint, SDL_TRUE);
+
+    if (player_lights != ctx->player_lights) {
+        ctx->player_lights = player_lights;
+
+        HIDAPI_DriverPS5_UpdateEffects(ctx->device, k_EDS5EffectPadLights);
     }
 }
 
@@ -505,23 +533,27 @@ HIDAPI_DriverPS5_SetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID
     ctx->player_index = player_index;
 
     /* This will set the new LED state based on the new player index */
-    HIDAPI_DriverPS5_UpdateEffects(device, k_EDS5EffectLED);
+    HIDAPI_DriverPS5_UpdateEffects(device, (k_EDS5EffectLED | k_EDS5EffectPadLights));
 }
 
 static SDL_bool
 HIDAPI_DriverPS5_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
 {
     SDL_DriverPS5_Context *ctx;
-    Uint8 data[USB_PACKET_LENGTH];
+    Uint8 data[USB_PACKET_LENGTH*2];
+    int size;
+    SDL_bool enhanced_mode = SDL_FALSE;
 
     ctx = (SDL_DriverPS5_Context *)SDL_calloc(1, sizeof(*ctx));
     if (!ctx) {
         SDL_OutOfMemory();
         return SDL_FALSE;
     }
+    ctx->device = device;
+    ctx->joystick = joystick;
     ctx->last_packet = SDL_GetTicks();
 
-    device->dev = hid_open_path(device->path, 0);
+    device->dev = SDL_hid_open_path(device->path, 0);
     if (!device->dev) {
         SDL_free(ctx);
         SDL_SetError("Couldn't open %s", device->path);
@@ -529,31 +561,84 @@ HIDAPI_DriverPS5_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
     }
     device->context = ctx;
 
-    /* Read the serial number (Bluetooth address in reverse byte order)
-       This will also enable enhanced reports over Bluetooth
-    */
-    if (ReadFeatureReport(device->dev, k_EPS5FeatureReportIdSerialNumber, data, sizeof(data)) >= 7) {
+    /* Read a report to see what mode we're in */
+    size = SDL_hid_read_timeout(device->dev, data, sizeof(data), 16);
+#ifdef DEBUG_PS5_PROTOCOL
+    if (size > 0) {
+        HIDAPI_DumpPacket("PS5 first packet: size = %d", data, size);
+    } else {
+        SDL_Log("PS5 first packet: size = %d\n", size);
+    }
+#endif
+    if (size == 64) {
+        /* Connected over USB */
+        ctx->is_bluetooth = SDL_FALSE;
+        enhanced_mode = SDL_TRUE;
+    } else if (size > 0 && data[0] == k_EPS5ReportIdBluetoothEffects) {
+        /* Connected over Bluetooth, using enhanced reports */
+        ctx->is_bluetooth = SDL_TRUE;
+        enhanced_mode = SDL_TRUE;
+    } else {
+        /* Connected over Bluetooth, using simple reports (DirectInput enabled) */
+        ctx->is_bluetooth = SDL_TRUE;
+
+        /* Games written prior the introduction of PS5 controller support in SDL will not be aware of
+           SDL_HINT_JOYSTICK_HIDAPI_PS5_RUMBLE, but they did know SDL_HINT_JOYSTICK_HIDAPI_PS4_RUMBLE.
+           To support apps that only knew about the PS4 hint, we'll use the PS4 hint as the default.
+        */
+        enhanced_mode = SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_PS5_RUMBLE,
+                                           SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_PS4_RUMBLE, SDL_FALSE));
+    }
+
+    if (enhanced_mode) {
+        /* Read the serial number (Bluetooth address in reverse byte order)
+           This will also enable enhanced reports over Bluetooth
+        */
+        if (ReadFeatureReport(device->dev, k_EPS5FeatureReportIdSerialNumber, data, sizeof(data)) >= 7) {
+            char serial[18];
+
+            SDL_snprintf(serial, sizeof(serial), "%.2x-%.2x-%.2x-%.2x-%.2x-%.2x",
+                data[6], data[5], data[4], data[3], data[2], data[1]);
+            joystick->serial = SDL_strdup(serial);
+        }
+    }
+
+    if (!joystick->serial && device->serial && SDL_strlen(device->serial) == 12) {
+        int i, j;
         char serial[18];
 
-        SDL_snprintf(serial, sizeof(serial), "%.2x-%.2x-%.2x-%.2x-%.2x-%.2x",
-            data[6], data[5], data[4], data[3], data[2], data[1]);
+        j = -1;
+        for (i = 0; i < 12; i += 2) {
+            j += 1;
+            SDL_memcpy(&serial[j], &device->serial[i], 2);
+            j += 2;
+            serial[j] = '-';
+        }
+        serial[j] = '\0';
+
         joystick->serial = SDL_strdup(serial);
     }
 
     /* Initialize player index (needed for setting LEDs) */
     ctx->player_index = SDL_JoystickGetPlayerIndex(joystick);
+    ctx->player_lights = SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_PS5_PLAYER_LED, SDL_TRUE);
 
-    /* Initialize LED and effect state */
-    HIDAPI_DriverPS5_UpdateEffects(device, k_EDS5EffectLED);
-
-    /* Initialize the joystick capabilities */
+    /* Initialize the joystick capabilities
+     *
+     * We can't dynamically add the touchpad button, so always report it here
+     */
     joystick->nbuttons = 17;
     joystick->naxes = SDL_CONTROLLER_AXIS_MAX;
+    joystick->epowerlevel = ctx->is_bluetooth ? SDL_JOYSTICK_POWER_UNKNOWN : SDL_JOYSTICK_POWER_WIRED;
 
-    SDL_PrivateJoystickAddTouchpad(joystick, 2);
-    SDL_PrivateJoystickAddSensor(joystick, SDL_SENSOR_GYRO);
-    SDL_PrivateJoystickAddSensor(joystick, SDL_SENSOR_ACCEL);
-
+    if (enhanced_mode) {
+        HIDAPI_DriverPS5_SetEnhancedMode(device, joystick);
+    } else {
+        SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_PS5_RUMBLE,
+                            SDL_PS5RumbleHintChanged, ctx);
+    }
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_PS5_PLAYER_LED,
+                        SDL_PS5PlayerLEDHintChanged, ctx);
     return SDL_TRUE;
 }
 
@@ -578,10 +663,17 @@ HIDAPI_DriverPS5_RumbleJoystickTriggers(SDL_HIDAPI_Device *device, SDL_Joystick
     return SDL_Unsupported();
 }
 
-static SDL_bool
-HIDAPI_DriverPS5_HasJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+static Uint32
+HIDAPI_DriverPS5_GetJoystickCapabilities(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
 {
-    return SDL_FALSE;
+    SDL_DriverPS5_Context *ctx = (SDL_DriverPS5_Context *)device->context;
+    Uint32 result = 0;
+
+    if (ctx->enhanced_mode) {
+        result |= SDL_JOYCAP_LED | SDL_JOYCAP_RUMBLE;
+    }
+
+    return result;
 }
 
 static int
@@ -597,11 +689,76 @@ HIDAPI_DriverPS5_SetJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystic
     return HIDAPI_DriverPS5_UpdateEffects(device, k_EDS5EffectLED);
 }
 
+static int
+HIDAPI_DriverPS5_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *effect, int size)
+{
+    SDL_DriverPS5_Context *ctx = (SDL_DriverPS5_Context *)device->context;
+    Uint8 data[78];
+    int report_size, offset;
+    Uint8 *pending_data;
+    int *pending_size;
+    int maximum_size;
+
+    if (!ctx->enhanced_mode) {
+        HIDAPI_DriverPS5_SetEnhancedMode(device, joystick);
+    }
+
+    SDL_zeroa(data);
+
+    if (ctx->is_bluetooth) {
+        data[0] = k_EPS5ReportIdBluetoothEffects;
+        data[1] = 0x02;  /* Magic value */
+
+        report_size = 78;
+        offset = 2;
+    } else {
+        data[0] = k_EPS5ReportIdUsbEffects;
+
+        report_size = 48;
+        offset = 1;
+    }
+
+    SDL_memcpy(&data[offset], effect, SDL_min((sizeof(data) - offset), (size_t)size));
+
+    if (ctx->is_bluetooth) {
+        /* Bluetooth reports need a CRC at the end of the packet (at least on Linux) */
+        Uint8 ubHdr = 0xA2; /* hidp header is part of the CRC calculation */
+        Uint32 unCRC;
+        unCRC = SDL_crc32(0, &ubHdr, 1);
+        unCRC = SDL_crc32(unCRC, data, (size_t)(report_size - sizeof(unCRC)));
+        SDL_memcpy(&data[report_size - sizeof(unCRC)], &unCRC, sizeof(unCRC));
+    }
+
+    if (SDL_HIDAPI_LockRumble() < 0) {
+        return -1;
+    }
+
+    /* See if we can update an existing pending request */
+    if (SDL_HIDAPI_GetPendingRumbleLocked(device, &pending_data, &pending_size, &maximum_size)) {
+        DS5EffectsState_t *effects = (DS5EffectsState_t *)&data[offset];
+        DS5EffectsState_t *pending_effects = (DS5EffectsState_t *)&pending_data[offset];
+        if (report_size == *pending_size &&
+            effects->ucEnableBits1 == pending_effects->ucEnableBits1 &&
+            effects->ucEnableBits2 == pending_effects->ucEnableBits2) {
+            /* We're simply updating the data for this request */
+            SDL_memcpy(pending_data, data, report_size);
+            SDL_HIDAPI_UnlockRumble();
+            return 0;
+        }
+    }
+
+    return SDL_HIDAPI_SendRumbleAndUnlock(device, data, report_size);
+}
+
 static int
 HIDAPI_DriverPS5_SetJoystickSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, SDL_bool enabled)
 {
     SDL_DriverPS5_Context *ctx = (SDL_DriverPS5_Context *)device->context;
 
+    if (!ctx->enhanced_mode) {
+        return SDL_Unsupported();
+    }
+
     if (enabled) {
         HIDAPI_DriverPS5_LoadCalibrationData(device);
     }
@@ -611,7 +768,7 @@ HIDAPI_DriverPS5_SetJoystickSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joysti
 }
 
 static void
-HIDAPI_DriverPS5_HandleSimpleStatePacket(SDL_Joystick *joystick, hid_device *dev, SDL_DriverPS5_Context *ctx, PS5SimpleStatePacket_t *packet)
+HIDAPI_DriverPS5_HandleSimpleStatePacket(SDL_Joystick *joystick, SDL_hid_device *dev, SDL_DriverPS5_Context *ctx, PS5SimpleStatePacket_t *packet)
 {
     Sint16 axis;
 
@@ -705,7 +862,7 @@ HIDAPI_DriverPS5_HandleSimpleStatePacket(SDL_Joystick *joystick, hid_device *dev
 }
 
 static void
-HIDAPI_DriverPS5_HandleStatePacket(SDL_Joystick *joystick, hid_device *dev, SDL_DriverPS5_Context *ctx, PS5StatePacket_t *packet)
+HIDAPI_DriverPS5_HandleStatePacket(SDL_Joystick *joystick, SDL_hid_device *dev, SDL_DriverPS5_Context *ctx, PS5StatePacket_t *packet)
 {
     static const float TOUCHPAD_SCALEX = 1.0f / 1920;
     static const float TOUCHPAD_SCALEY = 1.0f / 1070;
@@ -783,8 +940,8 @@ HIDAPI_DriverPS5_HandleStatePacket(SDL_Joystick *joystick, hid_device *dev, SDL_
         Uint8 data = packet->rgucButtonsAndHat[2];
 
         SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_GUIDE, (data & 0x01) ? SDL_PRESSED : SDL_RELEASED);
-        SDL_PrivateJoystickButton(joystick, 15, (data & 0x04) ? SDL_PRESSED : SDL_RELEASED);
-        SDL_PrivateJoystickButton(joystick, 16, (data & 0x02) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, 15, (data & 0x02) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, 16, (data & 0x04) ? SDL_PRESSED : SDL_RELEASED);
     }
 
     axis = ((int)packet->ucTriggerLeft * 257) - 32768;
@@ -860,7 +1017,7 @@ HIDAPI_DriverPS5_UpdateDevice(SDL_HIDAPI_Device *device)
         return SDL_FALSE;
     }
 
-    while ((size = hid_read_timeout(device->dev, data, sizeof(data), 0)) > 0) {
+    while ((size = SDL_hid_read_timeout(device->dev, data, sizeof(data), 0)) > 0) {
 #ifdef DEBUG_PS5_PROTOCOL
         HIDAPI_DumpPacket("PS5 packet: size = %d", data, size);
 #endif
@@ -869,20 +1026,21 @@ HIDAPI_DriverPS5_UpdateDevice(SDL_HIDAPI_Device *device)
 
         switch (data[0]) {
         case k_EPS5ReportIdState:
-            if (size == 10) {
-                HIDAPI_DriverPS5_SetBluetooth(device, SDL_TRUE);    /* Simple state packet over Bluetooth */
+            if (size == 10 || size == 78) {
                 HIDAPI_DriverPS5_HandleSimpleStatePacket(joystick, device->dev, ctx, (PS5SimpleStatePacket_t *)&data[1]);
             } else {
-                HIDAPI_DriverPS5_SetBluetooth(device, SDL_FALSE);
                 HIDAPI_DriverPS5_HandleStatePacket(joystick, device->dev, ctx, (PS5StatePacket_t *)&data[1]);
             }
             break;
         case k_EPS5ReportIdBluetoothState:
-            HIDAPI_DriverPS5_SetBluetooth(device, SDL_TRUE);
-            HIDAPI_DriverPS5_HandleStatePacket(joystick, device->dev, ctx, (PS5StatePacket_t *)&data[2]);
+            if (!ctx->enhanced_mode) {
+                /* This is the extended report, we can enable effects now */
+                HIDAPI_DriverPS5_SetEnhancedMode(device, joystick);
+            }
             if (ctx->led_reset_state == k_EDS5LEDResetStatePending) {
                 HIDAPI_DriverPS5_CheckPendingLEDReset(device);
             }
+            HIDAPI_DriverPS5_HandleStatePacket(joystick, device->dev, ctx, (PS5StatePacket_t *)&data[2]);
             break;
         default:
 #ifdef DEBUG_JOYSTICK
@@ -896,7 +1054,7 @@ HIDAPI_DriverPS5_UpdateDevice(SDL_HIDAPI_Device *device)
         /* Check to see if it looks like the device disconnected */
         if (SDL_TICKS_PASSED(SDL_GetTicks(), ctx->last_packet + BLUETOOTH_DISCONNECT_TIMEOUT_MS)) {
             /* Send an empty output report to tickle the Bluetooth stack */
-            HIDAPI_DriverPS5_UpdateEffects(device, k_EDS5EffectNone);
+            HIDAPI_DriverPS5_TickleBluetooth(device);
         }
     }
 
@@ -910,11 +1068,23 @@ HIDAPI_DriverPS5_UpdateDevice(SDL_HIDAPI_Device *device)
 static void
 HIDAPI_DriverPS5_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
 {
-    hid_close(device->dev);
-    device->dev = NULL;
+    SDL_DriverPS5_Context *ctx = (SDL_DriverPS5_Context *)device->context;
 
-    SDL_free(device->context);
-    device->context = NULL;
+    SDL_DelHintCallback(SDL_HINT_JOYSTICK_HIDAPI_PS5_RUMBLE,
+                        SDL_PS5RumbleHintChanged, ctx);
+
+    SDL_DelHintCallback(SDL_HINT_JOYSTICK_HIDAPI_PS5_PLAYER_LED,
+                        SDL_PS5PlayerLEDHintChanged, ctx);
+
+    SDL_LockMutex(device->dev_lock);
+    {
+        SDL_hid_close(device->dev);
+        device->dev = NULL;
+
+        SDL_free(device->context);
+        device->context = NULL;
+    }
+    SDL_UnlockMutex(device->dev_lock);
 }
 
 static void
@@ -926,6 +1096,7 @@ SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverPS5 =
 {
     SDL_HINT_JOYSTICK_HIDAPI_PS5,
     SDL_TRUE,
+    SDL_TRUE,
     HIDAPI_DriverPS5_IsSupportedDevice,
     HIDAPI_DriverPS5_GetDeviceName,
     HIDAPI_DriverPS5_InitDevice,
@@ -935,8 +1106,9 @@ SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverPS5 =
     HIDAPI_DriverPS5_OpenJoystick,
     HIDAPI_DriverPS5_RumbleJoystick,
     HIDAPI_DriverPS5_RumbleJoystickTriggers,
-    HIDAPI_DriverPS5_HasJoystickLED,
+    HIDAPI_DriverPS5_GetJoystickCapabilities,
     HIDAPI_DriverPS5_SetJoystickLED,
+    HIDAPI_DriverPS5_SendJoystickEffect,
     HIDAPI_DriverPS5_SetJoystickSensorsEnabled,
     HIDAPI_DriverPS5_CloseJoystick,
     HIDAPI_DriverPS5_FreeDevice,
diff --git a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_rumble.c b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_rumble.c
index 3a3c2e243..bf376277e 100644
--- a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_rumble.c
+++ b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_rumble.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -25,6 +25,7 @@
 /* Handle rumble on a separate thread so it doesn't block the application */
 
 #include "SDL_thread.h"
+#include "SDL_timer.h"
 #include "SDL_hidapijoystick_c.h"
 #include "SDL_hidapi_rumble.h"
 #include "../../thread/SDL_systhread.h"
@@ -76,11 +77,17 @@ static int SDL_HIDAPI_RumbleThread(void *data)
         if (request) {
             SDL_LockMutex(request->device->dev_lock);
             if (request->device->dev) {
-                hid_write( request->device->dev, request->data, request->size );
+#ifdef DEBUG_RUMBLE
+                HIDAPI_DumpPacket("Rumble packet: size = %d", request->data, request->size);
+#endif
+                SDL_hid_write(request->device->dev, request->data, request->size);
             }
             SDL_UnlockMutex(request->device->dev_lock);
             (void)SDL_AtomicDecRef(&request->device->rumble_pending);
             SDL_free(request);
+
+            /* Make sure we're not starving report reads when there's lots of rumble */
+            SDL_Delay(10);
         }
     }
     return 0;
diff --git a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_rumble.h b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_rumble.h
index 9b14da098..b04794a9a 100644
--- a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_rumble.h
+++ b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_rumble.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_stadia.c b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_stadia.c
new file mode 100644
index 000000000..0a5c2584f
--- /dev/null
+++ b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_stadia.c
@@ -0,0 +1,331 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI
+
+#include "SDL_hints.h"
+#include "SDL_events.h"
+#include "SDL_joystick.h"
+#include "SDL_gamecontroller.h"
+#include "../SDL_sysjoystick.h"
+#include "SDL_hidapijoystick_c.h"
+#include "SDL_hidapi_rumble.h"
+
+
+#ifdef SDL_JOYSTICK_HIDAPI_STADIA
+
+/* Define this if you want to log all packets from the controller */
+/*#define DEBUG_STADIA_PROTOCOL*/
+
+enum
+{
+    SDL_CONTROLLER_BUTTON_STADIA_SHARE = 15,
+    SDL_CONTROLLER_BUTTON_STADIA_GOOGLE_ASSISTANT,
+    SDL_CONTROLLER_NUM_STADIA_BUTTONS,
+};
+
+typedef struct {
+    Uint8 last_state[USB_PACKET_LENGTH];
+} SDL_DriverStadia_Context;
+
+
+static SDL_bool
+HIDAPI_DriverStadia_IsSupportedDevice(const char *name, SDL_GameControllerType type, Uint16 vendor_id, Uint16 product_id, Uint16 version, int interface_number, int interface_class, int interface_subclass, int interface_protocol)
+{
+    return (type == SDL_CONTROLLER_TYPE_GOOGLE_STADIA) ? SDL_TRUE : SDL_FALSE;
+}
+
+static const char *
+HIDAPI_DriverStadia_GetDeviceName(Uint16 vendor_id, Uint16 product_id)
+{
+    return "Google Stadia Controller";
+}
+
+static SDL_bool
+HIDAPI_DriverStadia_InitDevice(SDL_HIDAPI_Device *device)
+{
+    return HIDAPI_JoystickConnected(device, NULL);
+}
+
+static int
+HIDAPI_DriverStadia_GetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id)
+{
+    return -1;
+}
+
+static void
+HIDAPI_DriverStadia_SetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id, int player_index)
+{
+}
+
+static SDL_bool
+HIDAPI_DriverStadia_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverStadia_Context *ctx;
+
+    ctx = (SDL_DriverStadia_Context *)SDL_calloc(1, sizeof(*ctx));
+    if (!ctx) {
+        SDL_OutOfMemory();
+        return SDL_FALSE;
+    }
+
+    device->dev = SDL_hid_open_path(device->path, 0);
+    if (!device->dev) {
+        SDL_SetError("Couldn't open %s", device->path);
+        SDL_free(ctx);
+        return SDL_FALSE;
+    }
+    device->context = ctx;
+
+    /* Initialize the joystick capabilities */
+    joystick->nbuttons = SDL_CONTROLLER_NUM_STADIA_BUTTONS;
+    joystick->naxes = SDL_CONTROLLER_AXIS_MAX;
+    joystick->epowerlevel = SDL_JOYSTICK_POWER_WIRED;
+
+    return SDL_TRUE;
+}
+
+static int
+HIDAPI_DriverStadia_RumbleJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+{
+    Uint8 rumble_packet[] = { 0x05, 0x00, 0x00, 0x00, 0x00 };
+
+    rumble_packet[1] = (low_frequency_rumble & 0xFF);
+    rumble_packet[2] = (low_frequency_rumble >> 8);
+    rumble_packet[3] = (high_frequency_rumble & 0xFF);
+    rumble_packet[4] = (high_frequency_rumble >> 8);
+
+    if (SDL_HIDAPI_SendRumble(device, rumble_packet, sizeof(rumble_packet)) != sizeof(rumble_packet)) {
+        return SDL_SetError("Couldn't send rumble packet");
+    }
+    return 0;
+}
+
+static int
+HIDAPI_DriverStadia_RumbleJoystickTriggers(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
+{
+    return SDL_Unsupported();
+}
+
+static Uint32
+HIDAPI_DriverStadia_GetJoystickCapabilities(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    return SDL_JOYCAP_RUMBLE;
+}
+
+static int
+HIDAPI_DriverStadia_SetJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+    return SDL_Unsupported();
+}
+
+static int
+HIDAPI_DriverStadia_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *data, int size)
+{
+    return SDL_Unsupported();
+}
+
+static int
+HIDAPI_DriverStadia_SetJoystickSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, SDL_bool enabled)
+{
+    return SDL_Unsupported();
+}
+
+static void
+HIDAPI_DriverStadia_HandleStatePacket(SDL_Joystick *joystick, SDL_DriverStadia_Context *ctx, Uint8 *data, int size)
+{
+    Sint16 axis;
+
+	// The format is the same but the original FW will send 10 bytes and January '21 FW update will send 11
+    if (size < 10 || data[0] != 0x03) {
+        /* We don't know how to handle this report */
+        return;
+    }
+
+    if (ctx->last_state[1] != data[1]) {
+        SDL_bool dpad_up = SDL_FALSE;
+        SDL_bool dpad_down = SDL_FALSE;
+        SDL_bool dpad_left = SDL_FALSE;
+        SDL_bool dpad_right = SDL_FALSE;
+
+        switch (data[1]) {
+        case 0:
+            dpad_up = SDL_TRUE;
+            break;
+        case 1:
+            dpad_up = SDL_TRUE;
+            dpad_right = SDL_TRUE;
+            break;
+        case 2:
+            dpad_right = SDL_TRUE;
+            break;
+        case 3:
+            dpad_right = SDL_TRUE;
+            dpad_down = SDL_TRUE;
+            break;
+        case 4:
+            dpad_down = SDL_TRUE;
+            break;
+        case 5:
+            dpad_left = SDL_TRUE;
+            dpad_down = SDL_TRUE;
+            break;
+        case 6:
+            dpad_left = SDL_TRUE;
+            break;
+        case 7:
+            dpad_up = SDL_TRUE;
+            dpad_left = SDL_TRUE;
+            break;
+        default:
+            break;
+        }
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_DPAD_DOWN, dpad_down);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_DPAD_UP, dpad_up);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_DPAD_RIGHT, dpad_right);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_DPAD_LEFT, dpad_left);
+    }
+
+    if (ctx->last_state[2] != data[2]) {
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_BACK, (data[2] & 0x40) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_GUIDE, (data[2] & 0x10) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_START, (data[2] & 0x20) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_RIGHTSTICK, (data[2] & 0x80) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_STADIA_SHARE, (data[2] & 0x01) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_STADIA_GOOGLE_ASSISTANT, (data[2] & 0x02) ? SDL_PRESSED : SDL_RELEASED);
+    }
+
+    if (ctx->last_state[3] != data[3]) {
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_A, (data[3] & 0x40) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_B, (data[3] & 0x20) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_X, (data[3] & 0x10) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_Y, (data[3] & 0x08) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_LEFTSHOULDER, (data[3] & 0x04) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER, (data[3] & 0x02) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_LEFTSTICK, (data[3] & 0x01) ? SDL_PRESSED : SDL_RELEASED);
+    }
+
+#define READ_STICK_AXIS(offset) \
+    (data[offset] == 0x80 ? 0 : \
+    (Sint16)HIDAPI_RemapVal((float)((int)data[offset] - 0x80), 0x01 - 0x80, 0xff - 0x80, SDL_MIN_SINT16, SDL_MAX_SINT16))
+    {
+        axis = READ_STICK_AXIS(4);
+        SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_LEFTX, axis);
+        axis = READ_STICK_AXIS(5);
+        SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_LEFTY, axis);
+        axis = READ_STICK_AXIS(6);
+        SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_RIGHTX, axis);
+        axis = READ_STICK_AXIS(7);
+        SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_RIGHTY, axis);
+    }
+#undef READ_STICK_AXIS
+
+#define READ_TRIGGER_AXIS(offset) \
+    (Sint16)(((int)data[offset] * 257) - 32768)
+    {
+        axis = READ_TRIGGER_AXIS(8);
+        SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_TRIGGERLEFT, axis);
+        axis = READ_TRIGGER_AXIS(9);
+        SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_TRIGGERRIGHT, axis);
+    }
+#undef READ_TRIGGER_AXIS
+
+    SDL_memcpy(ctx->last_state, data, SDL_min(size, sizeof(ctx->last_state)));
+}
+
+static SDL_bool
+HIDAPI_DriverStadia_UpdateDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverStadia_Context *ctx = (SDL_DriverStadia_Context *)device->context;
+    SDL_Joystick *joystick = NULL;
+    Uint8 data[USB_PACKET_LENGTH];
+    int size = 0;
+
+    if (device->num_joysticks > 0) {
+        joystick = SDL_JoystickFromInstanceID(device->joysticks[0]);
+    }
+    if (!joystick) {
+        return SDL_FALSE;
+    }
+
+    while ((size = SDL_hid_read_timeout(device->dev, data, sizeof(data), 0)) > 0) {
+#ifdef DEBUG_STADIA_PROTOCOL
+        HIDAPI_DumpPacket("Google Stadia packet: size = %d", data, size);
+#endif
+        HIDAPI_DriverStadia_HandleStatePacket(joystick, ctx, data, size);
+    }
+
+    if (size < 0) {
+        /* Read error, device is disconnected */
+        HIDAPI_JoystickDisconnected(device, joystick->instance_id);
+    }
+    return (size >= 0);
+}
+
+static void
+HIDAPI_DriverStadia_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_LockMutex(device->dev_lock);
+    {
+        if (device->dev) {
+            SDL_hid_close(device->dev);
+            device->dev = NULL;
+        }
+
+        SDL_free(device->context);
+        device->context = NULL;
+    }
+    SDL_UnlockMutex(device->dev_lock);
+}
+
+static void
+HIDAPI_DriverStadia_FreeDevice(SDL_HIDAPI_Device *device)
+{
+}
+
+SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverStadia =
+{
+    SDL_HINT_JOYSTICK_HIDAPI_STADIA,
+    SDL_TRUE,
+    SDL_TRUE,
+    HIDAPI_DriverStadia_IsSupportedDevice,
+    HIDAPI_DriverStadia_GetDeviceName,
+    HIDAPI_DriverStadia_InitDevice,
+    HIDAPI_DriverStadia_GetDevicePlayerIndex,
+    HIDAPI_DriverStadia_SetDevicePlayerIndex,
+    HIDAPI_DriverStadia_UpdateDevice,
+    HIDAPI_DriverStadia_OpenJoystick,
+    HIDAPI_DriverStadia_RumbleJoystick,
+    HIDAPI_DriverStadia_RumbleJoystickTriggers,
+    HIDAPI_DriverStadia_GetJoystickCapabilities,
+    HIDAPI_DriverStadia_SetJoystickLED,
+    HIDAPI_DriverStadia_SendJoystickEffect,
+    HIDAPI_DriverStadia_SetJoystickSensorsEnabled,
+    HIDAPI_DriverStadia_CloseJoystick,
+    HIDAPI_DriverStadia_FreeDevice,
+};
+
+#endif /* SDL_JOYSTICK_HIDAPI_STADIA */
+
+#endif /* SDL_JOYSTICK_HIDAPI */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_steam.c b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_steam.c
index 87827f476..b69c598dc 100644
--- a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_steam.c
+++ b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_steam.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -190,7 +190,7 @@ typedef struct
 
 
 // Wireless firmware quirk: the firmware intentionally signals "failure" when performing
-// SET_FEATURE / GET_FEATURE when it actually means "pending radio round-trip". The only
+// SET_FEATURE / GET_FEATURE when it actually means "pending radio roundtrip". The only
 // way to make SET_FEATURE / GET_FEATURE work is to loop several times with a sleep. If
 // it takes more than 50ms to get the response for SET_FEATURE / GET_FEATURE, we assume
 // that the controller has failed.
@@ -220,7 +220,7 @@ static void hexdump( const uint8_t *ptr, int len )
 
 static void ResetSteamControllerPacketAssembler( SteamControllerPacketAssembler *pAssembler )
 {
-    memset( pAssembler->uBuffer, 0, sizeof( pAssembler->uBuffer ) );
+    SDL_memset( pAssembler->uBuffer, 0, sizeof( pAssembler->uBuffer ) );
     pAssembler->nExpectedSegmentNumber = 0;
 }
 
@@ -239,6 +239,9 @@ static int WriteSegmentToSteamControllerPacketAssembler( SteamControllerPacketAs
 {
     if ( pAssembler->bIsBle )
     {
+        uint8_t uSegmentHeader = pSegment[ 1 ];
+        int nSegmentNumber = uSegmentHeader & 0x07;
+
         HEXDUMP( pSegment, nSegmentLength );
 
         if ( pSegment[ 0 ] != BLE_REPORT_NUMBER )
@@ -255,7 +258,6 @@ static int WriteSegmentToSteamControllerPacketAssembler( SteamControllerPacketAs
             return -1;
         }
         
-        uint8_t uSegmentHeader = pSegment[ 1 ];
         DPRINTF("GOT PACKET HEADER = 0x%x\n", uSegmentHeader);
         
         if ( ( uSegmentHeader & REPORT_SEGMENT_DATA_FLAG ) == 0 )
@@ -264,7 +266,6 @@ static int WriteSegmentToSteamControllerPacketAssembler( SteamControllerPacketAs
             return 0;
         }
         
-        int nSegmentNumber = uSegmentHeader & 0x07;
         if ( nSegmentNumber != pAssembler->nExpectedSegmentNumber )
         {
             ResetSteamControllerPacketAssembler( pAssembler );
@@ -278,7 +279,7 @@ static int WriteSegmentToSteamControllerPacketAssembler( SteamControllerPacketAs
             }
         }
         
-        memcpy( pAssembler->uBuffer + nSegmentNumber * MAX_REPORT_SEGMENT_PAYLOAD_SIZE,
+        SDL_memcpy( pAssembler->uBuffer + nSegmentNumber * MAX_REPORT_SEGMENT_PAYLOAD_SIZE,
                pSegment + 2, // ignore header and report number
                MAX_REPORT_SEGMENT_PAYLOAD_SIZE );
         
@@ -293,7 +294,7 @@ static int WriteSegmentToSteamControllerPacketAssembler( SteamControllerPacketAs
     else
     {
         // Just pass through
-        memcpy( pAssembler->uBuffer,
+        SDL_memcpy( pAssembler->uBuffer,
                pSegment,
                nSegmentLength );
         return nSegmentLength;
@@ -304,22 +305,23 @@ static int WriteSegmentToSteamControllerPacketAssembler( SteamControllerPacketAs
 
 #define BLE_MAX_READ_RETRIES    8
 
-static int SetFeatureReport( hid_device *dev, unsigned char uBuffer[65], int nActualDataLen )
+static int SetFeatureReport( SDL_hid_device *dev, unsigned char uBuffer[65], int nActualDataLen )
 {
-    DPRINTF("SetFeatureReport %p %p %d\n", dev, uBuffer, nActualDataLen);
     int nRet = -1;
     bool bBle = true; // only wireless/BLE for now, though macOS could do wired in the future
     
+    DPRINTF("SetFeatureReport %p %p %d\n", dev, uBuffer, nActualDataLen);
+
     if ( bBle )
     {
+        int nSegmentNumber = 0;
+        uint8_t uPacketBuffer[ MAX_REPORT_SEGMENT_SIZE ];
+        unsigned char *pBufferPtr = uBuffer + 1;
+
         if ( nActualDataLen < 1 )
             return -1;
         
-        int nSegmentNumber = 0;
-        uint8_t uPacketBuffer[ MAX_REPORT_SEGMENT_SIZE ];
-        
         // Skip report number in data
-        unsigned char *pBufferPtr = uBuffer + 1;
         nActualDataLen--;
         
         while ( nActualDataLen > 0 )
@@ -329,15 +331,15 @@ static int SetFeatureReport( hid_device *dev, unsigned char uBuffer[65], int nAc
             nActualDataLen -= nBytesInPacket;
 
             // Construct packet
-            memset( uPacketBuffer, 0, sizeof( uPacketBuffer ) );
+            SDL_memset( uPacketBuffer, 0, sizeof( uPacketBuffer ) );
             uPacketBuffer[ 0 ] = BLE_REPORT_NUMBER;
             uPacketBuffer[ 1 ] = GetSegmentHeader( nSegmentNumber, nActualDataLen == 0 );
-            memcpy( &uPacketBuffer[ 2 ], pBufferPtr, nBytesInPacket );
+            SDL_memcpy( &uPacketBuffer[ 2 ], pBufferPtr, nBytesInPacket );
             
             pBufferPtr += nBytesInPacket;
             nSegmentNumber++;
             
-            nRet = hid_send_feature_report( dev, uPacketBuffer, sizeof( uPacketBuffer ) );
+            nRet = SDL_hid_send_feature_report( dev, uPacketBuffer, sizeof( uPacketBuffer ) );
             DPRINTF("SetFeatureReport() ret = %d\n", nRet);
         }
     }
@@ -345,24 +347,26 @@ static int SetFeatureReport( hid_device *dev, unsigned char uBuffer[65], int nAc
     return nRet;
 }
 
-static int GetFeatureReport( hid_device *dev, unsigned char uBuffer[65] )
+static int GetFeatureReport( SDL_hid_device *dev, unsigned char uBuffer[65] )
 {
-    DPRINTF("GetFeatureReport( %p %p )\n", dev, uBuffer );
     int nRet = -1;
     bool bBle = true;
 
+    DPRINTF("GetFeatureReport( %p %p )\n", dev, uBuffer );
+
     if ( bBle )
     {
+        int nRetries = 0;
+        uint8_t uSegmentBuffer[ MAX_REPORT_SEGMENT_SIZE ];
+
         SteamControllerPacketAssembler assembler;
         InitializeSteamControllerPacketAssembler( &assembler );
         
-        int nRetries = 0;
-        uint8_t uSegmentBuffer[ MAX_REPORT_SEGMENT_SIZE ];
         while( nRetries < BLE_MAX_READ_RETRIES )
         {
-            memset( uSegmentBuffer, 0, sizeof( uSegmentBuffer ) );
+            SDL_memset( uSegmentBuffer, 0, sizeof( uSegmentBuffer ) );
             uSegmentBuffer[ 0 ] = BLE_REPORT_NUMBER;
-            nRet = hid_get_feature_report( dev, uSegmentBuffer, sizeof( uSegmentBuffer ) );
+            nRet = SDL_hid_get_feature_report( dev, uSegmentBuffer, sizeof( uSegmentBuffer ) );
             DPRINTF( "GetFeatureReport ble ret=%d\n", nRet );
             HEXDUMP( uSegmentBuffer, nRet );
             
@@ -382,7 +386,7 @@ static int GetFeatureReport( hid_device *dev, unsigned char uBuffer[65] )
                 {
                     // Leave space for "report number"
                     uBuffer[ 0 ] = 0;
-                    memcpy( uBuffer + 1, assembler.uBuffer, nPacketLength );
+                    SDL_memcpy( uBuffer + 1, assembler.uBuffer, nPacketLength );
                     return nPacketLength;
                 }
             }
@@ -396,11 +400,12 @@ static int GetFeatureReport( hid_device *dev, unsigned char uBuffer[65] )
     return nRet;
 }
 
-static int ReadResponse( hid_device *dev, uint8_t uBuffer[65], int nExpectedResponse )
+static int ReadResponse( SDL_hid_device *dev, uint8_t uBuffer[65], int nExpectedResponse )
 {
-    DPRINTF("ReadResponse( %p %p %d )\n", dev, uBuffer, nExpectedResponse );
     int nRet = GetFeatureReport( dev, uBuffer );
 
+    DPRINTF("ReadResponse( %p %p %d )\n", dev, uBuffer, nExpectedResponse );
+
     if ( nRet < 0 )
         return nRet;
     
@@ -416,13 +421,18 @@ static int ReadResponse( hid_device *dev, uint8_t uBuffer[65], int nExpectedResp
 //---------------------------------------------------------------------------
 // Reset steam controller (unmap buttons and pads) and re-fetch capability bits
 //---------------------------------------------------------------------------
-static bool ResetSteamController( hid_device *dev, bool bSuppressErrorSpew )
+static bool ResetSteamController( SDL_hid_device *dev, bool bSuppressErrorSpew, uint32_t *punUpdateRateUS )
 {
-    DPRINTF( "ResetSteamController hid=%p\n", dev );
     // Firmware quirk: Set Feature and Get Feature requests always require a 65-byte buffer.
     unsigned char buf[65];
-    int res = -1;
+    int res = -1, i;
+    int nSettings = 0;
+    int nAttributesLength;
+    FeatureReportMsg *msg;
+    uint32_t unUpdateRateUS = 9000; // Good default rate
     
+    DPRINTF( "ResetSteamController hid=%p\n", dev );
+
     buf[0] = 0;
     buf[1] = ID_GET_ATTRIBUTES_VALUES;
     res = SetFeatureReport( dev, buf, 2 );
@@ -444,14 +454,40 @@ static bool ResetSteamController( hid_device *dev, bool bSuppressErrorSpew )
         return false;
     }
     
-    int nAttributesLength = buf[ 2 ];
+    nAttributesLength = buf[ 2 ];
     if ( nAttributesLength > res )
     {
         if ( !bSuppressErrorSpew )
             printf( "Bad GET_ATTRIBUTES_VALUES response for controller %p\n", dev );
         return false;
     }
-    
+
+    msg = (FeatureReportMsg *)&buf[1];
+    for ( i = 0; i < (int)msg->header.length / sizeof( ControllerAttribute ); ++i )
+    {
+        uint8_t unAttribute = msg->payload.getAttributes.attributes[i].attributeTag;
+        uint32_t unValue = msg->payload.getAttributes.attributes[i].attributeValue;
+
+        switch ( unAttribute )
+        {
+        case ATTRIB_UNIQUE_ID:
+            break;
+        case ATTRIB_PRODUCT_ID:
+            break;
+        case ATTRIB_CAPABILITIES:
+            break;
+        case ATTRIB_CONNECTION_INTERVAL_IN_US:
+            unUpdateRateUS = unValue;
+            break;
+        default:
+            break;
+        }
+    }
+    if ( punUpdateRateUS )
+    {
+        *punUpdateRateUS = unUpdateRateUS;
+    }
+
     // Clear digital button mappings
     buf[0] = 0;
     buf[1] = ID_CLEAR_DIGITAL_MAPPINGS;
@@ -464,7 +500,7 @@ static bool ResetSteamController( hid_device *dev, bool bSuppressErrorSpew )
     }
     
     // Reset the default settings
-    memset( buf, 0, 65 );
+    SDL_memset( buf, 0, 65 );
     buf[1] = ID_LOAD_DEFAULT_SETTINGS;
     buf[2] = 0;
     res = SetFeatureReport( dev, buf, 3 );
@@ -476,14 +512,13 @@ static bool ResetSteamController( hid_device *dev, bool bSuppressErrorSpew )
     }
     
     // Apply custom settings - clear trackpad modes (cancel mouse emulation), etc
-    int nSettings = 0;
 #define ADD_SETTING(SETTING, VALUE)    \
 buf[3+nSettings*3] = SETTING;    \
 buf[3+nSettings*3+1] = ((uint16_t)VALUE)&0xFF; \
 buf[3+nSettings*3+2] = ((uint16_t)VALUE)>>8; \
 ++nSettings;
     
-    memset( buf, 0, 65 );
+    SDL_memset( buf, 0, 65 );
     buf[1] = ID_SET_SETTINGS_VALUES;
     ADD_SETTING( SETTING_WIRELESS_PACKET_VERSION, 2 );
     ADD_SETTING( SETTING_LEFT_TRACKPAD_MODE, TRACKPAD_NONE );
@@ -512,7 +547,7 @@ buf[3+nSettings*3+2] = ((uint16_t)VALUE)>>8; \
     int iRetry;
     for ( iRetry = 0; iRetry < 2; ++iRetry )
     {
-        memset( buf, 0, 65 );
+        SDL_memset( buf, 0, 65 );
         buf[1] = ID_GET_DIGITAL_MAPPINGS;
         buf[2] = 1; // one byte - requesting from index 0
         buf[3] = 0;
@@ -545,7 +580,7 @@ buf[3+nSettings*3+2] = ((uint16_t)VALUE)>>8; \
     }
     
     // Set our new mappings
-    memset( buf, 0, 65 );
+    SDL_memset( buf, 0, 65 );
     buf[1] = ID_SET_DIGITAL_MAPPINGS;
     buf[2] = 6; // 2 settings x 3 bytes
     buf[3] = IO_DIGITAL_BUTTON_RIGHT_TRIGGER;
@@ -571,36 +606,36 @@ buf[3+nSettings*3+2] = ((uint16_t)VALUE)>>8; \
 //---------------------------------------------------------------------------
 // Read from a Steam Controller
 //---------------------------------------------------------------------------
-static int ReadSteamController( hid_device *dev, uint8_t *pData, int nDataSize )
+static int ReadSteamController( SDL_hid_device *dev, uint8_t *pData, int nDataSize )
 {
-    memset( pData, 0, nDataSize );
+    SDL_memset( pData, 0, nDataSize );
     pData[ 0 ] = BLE_REPORT_NUMBER; // hid_read will also overwrite this with the same value, 0x03
-    return hid_read( dev, pData, nDataSize );
+    return SDL_hid_read( dev, pData, nDataSize );
 }
 
 
 //---------------------------------------------------------------------------
 // Close a Steam Controller
 //---------------------------------------------------------------------------
-static void CloseSteamController( hid_device *dev )
+static void CloseSteamController( SDL_hid_device *dev )
 {
     // Switch the Steam Controller back to lizard mode so it works with the OS
     unsigned char buf[65];
     int nSettings = 0;
     
     // Reset digital button mappings
-    memset( buf, 0, 65 );
+    SDL_memset( buf, 0, 65 );
     buf[1] = ID_SET_DEFAULT_DIGITAL_MAPPINGS;
     SetFeatureReport( dev, buf, 2 );
 
     // Reset the default settings
-    memset( buf, 0, 65 );
+    SDL_memset( buf, 0, 65 );
     buf[1] = ID_LOAD_DEFAULT_SETTINGS;
     buf[2] = 0;
     SetFeatureReport( dev, buf, 3 );
 
     // Reset mouse mode for lizard mode
-    memset( buf, 0, 65 );
+    SDL_memset( buf, 0, 65 );
     buf[1] = ID_SET_SETTINGS_VALUES;
     ADD_SETTING( SETTING_RIGHT_TRACKPAD_MODE, TRACKPAD_ABSOLUTE_MOUSE );
     buf[2] = nSettings*3;
@@ -651,14 +686,23 @@ static void RotatePadShort( short *pX, short *pY, float flAngleInRad )
 //---------------------------------------------------------------------------
 static void FormatStatePacketUntilGyro( SteamControllerStateInternal_t *pState, ValveControllerStatePacket_t *pStatePacket )
 {
-    memset(pState, 0, offsetof(SteamControllerStateInternal_t, sBatteryLevel));
+    int nLeftPadX;
+    int nLeftPadY;
+    int nRightPadX;
+    int nRightPadY;
+    int nPadOffset;
+
+    // 15 degrees in rad
+    const float flRotationAngle = 0.261799f;
+
+    SDL_memset(pState, 0, offsetof(SteamControllerStateInternal_t, sBatteryLevel));
 
     //pState->eControllerType = m_eControllerType;
     pState->eControllerType = 2; // k_eControllerType_SteamController;
     pState->unPacketNum = pStatePacket->unPacketNum;
 
     // We have a chunk of trigger data in the packet format here, so zero it out afterwards
-    memcpy(&pState->ulButtons, &pStatePacket->ButtonTriggerData.ulButtons, 8);
+    SDL_memcpy(&pState->ulButtons, &pStatePacket->ButtonTriggerData.ulButtons, 8);
     pState->ulButtons &= ~0xFFFF000000LL;
 
     // The firmware uses this bit to tell us what kind of data is packed into the left two axises
@@ -735,18 +779,14 @@ static void FormatStatePacketUntilGyro( SteamControllerStateInternal_t *pState,
     pState->sRightPadX = pStatePacket->sRightPadX;
     pState->sRightPadY = pStatePacket->sRightPadY;
 
-    int nLeftPadX = pState->sLeftPadX;
-    int nLeftPadY = pState->sLeftPadY;
-    int nRightPadX = pState->sRightPadX;
-    int nRightPadY = pState->sRightPadY;
-
-    // 15 degrees in rad
-    const float flRotationAngle = 0.261799f;
+    nLeftPadX = pState->sLeftPadX;
+    nLeftPadY = pState->sLeftPadY;
+    nRightPadX = pState->sRightPadX;
+    nRightPadY = pState->sRightPadY;
 
     RotatePad(&nLeftPadX, &nLeftPadY, -flRotationAngle);
     RotatePad(&nRightPadX, &nRightPadY, flRotationAngle);
 
-    int nPadOffset;
     if (pState->ulButtons & STEAM_LEFTPAD_FINGERDOWN_MASK)
         nPadOffset = 1000;
     else
@@ -782,7 +822,7 @@ static bool UpdateBLESteamControllerState( const uint8_t *pData, int nDataSize,
     ucOptionDataMask |= (uint32_t)(*pData++) << 8;
     if ( ucOptionDataMask & k_EBLEButtonChunk1 )
     {
-        memcpy( &pState->ulButtons, pData, 3 );
+        SDL_memcpy( &pState->ulButtons, pData, 3 );
         pData += 3;
     }
     if ( ucOptionDataMask & k_EBLEButtonChunk2 )
@@ -804,14 +844,14 @@ static bool UpdateBLESteamControllerState( const uint8_t *pData, int nDataSize,
         // This doesn't handle any of the special headcrab stuff for raw joystick which is OK for now since that FW doesn't support
         // this protocol yet either
         int nLength = sizeof( pState->sLeftStickX ) + sizeof( pState->sLeftStickY );
-        memcpy( &pState->sLeftStickX, pData, nLength );
+        SDL_memcpy( &pState->sLeftStickX, pData, nLength );
         pData += nLength;
     }
     if ( ucOptionDataMask & k_EBLELeftTrackpadChunk )
     {
         int nLength = sizeof( pState->sLeftPadX ) + sizeof( pState->sLeftPadY );
         int nPadOffset;
-        memcpy( &pState->sLeftPadX, pData, nLength );
+        SDL_memcpy( &pState->sLeftPadX, pData, nLength );
         if ( pState->ulButtons & STEAM_LEFTPAD_FINGERDOWN_MASK )
             nPadOffset = 1000;
         else
@@ -827,7 +867,7 @@ static bool UpdateBLESteamControllerState( const uint8_t *pData, int nDataSize,
         int nLength = sizeof( pState->sRightPadX ) + sizeof( pState->sRightPadY );
         int nPadOffset = 0;
 
-        memcpy( &pState->sRightPadX, pData, nLength );
+        SDL_memcpy( &pState->sRightPadX, pData, nLength );
 
         if ( pState->ulButtons & STEAM_RIGHTPAD_FINGERDOWN_MASK )
             nPadOffset = 1000;
@@ -842,19 +882,19 @@ static bool UpdateBLESteamControllerState( const uint8_t *pData, int nDataSize,
     if ( ucOptionDataMask & k_EBLEIMUAccelChunk )
     {
         int nLength = sizeof( pState->sAccelX ) + sizeof( pState->sAccelY ) + sizeof( pState->sAccelZ );
-        memcpy( &pState->sAccelX, pData, nLength );
+        SDL_memcpy( &pState->sAccelX, pData, nLength );
         pData += nLength;
     }
     if ( ucOptionDataMask & k_EBLEIMUGyroChunk )
     {
         int nLength = sizeof( pState->sAccelX ) + sizeof( pState->sAccelY ) + sizeof( pState->sAccelZ );
-        memcpy( &pState->sGyroX, pData, nLength );
+        SDL_memcpy( &pState->sGyroX, pData, nLength );
         pData += nLength;
     }
     if ( ucOptionDataMask & k_EBLEIMUQuatChunk )
     {
         int nLength = sizeof( pState->sGyroQuatW ) + sizeof( pState->sGyroQuatX ) + sizeof( pState->sGyroQuatY ) + sizeof( pState->sGyroQuatZ );
-        memcpy( &pState->sGyroQuatW, pData, nLength );
+        SDL_memcpy( &pState->sGyroQuatW, pData, nLength );
         pData += nLength;
     }
     return true;
@@ -950,6 +990,7 @@ static bool UpdateSteamControllerState( const uint8_t *pData, int nDataSize, Ste
 /*****************************************************************************************************/
 
 typedef struct {
+    SDL_bool report_sensors;
     SteamControllerPacketAssembler m_assembler;
     SteamControllerStateInternal_t m_state;
     SteamControllerStateInternal_t m_last_state;
@@ -989,6 +1030,8 @@ static SDL_bool
 HIDAPI_DriverSteam_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
 {
     SDL_DriverSteam_Context *ctx;
+    uint32_t update_rate_in_us = 0;
+    float update_rate_in_hz = 0.0f;
 
     ctx = (SDL_DriverSteam_Context *)SDL_calloc(1, sizeof(*ctx));
     if (!ctx) {
@@ -997,15 +1040,20 @@ HIDAPI_DriverSteam_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystic
     }
     device->context = ctx;
 
-    device->dev = hid_open_path(device->path, 0);
+    device->dev = SDL_hid_open_path(device->path, 0);
     if (!device->dev) {
         SDL_SetError("Couldn't open %s", device->path);
         goto error;
     }
+    SDL_hid_set_nonblocking(device->dev, 1);
 
-    if (!ResetSteamController(device->dev, false)) {
+    if (!ResetSteamController(device->dev, false, &update_rate_in_us)) {
+        SDL_SetError("Couldn't reset controller");
         goto error;
     }
+    if (update_rate_in_us > 0) {
+        update_rate_in_hz = 1000000.0f / update_rate_in_us;
+    }
 
     InitializeSteamControllerPacketAssembler(&ctx->m_assembler);
 
@@ -1013,17 +1061,24 @@ HIDAPI_DriverSteam_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystic
     joystick->nbuttons = 17;
     joystick->naxes = SDL_CONTROLLER_AXIS_MAX;
 
+    SDL_PrivateJoystickAddSensor(joystick, SDL_SENSOR_GYRO, update_rate_in_hz);
+    SDL_PrivateJoystickAddSensor(joystick, SDL_SENSOR_ACCEL, update_rate_in_hz);
+
     return SDL_TRUE;
 
 error:
-    if (device->dev) {
-        hid_close(device->dev);
-        device->dev = NULL;
-    }
-    if (device->context) {
-        SDL_free(device->context);
-        device->context = NULL;
+    SDL_LockMutex(device->dev_lock);
+    {
+        if (device->dev) {
+            SDL_hid_close(device->dev);
+            device->dev = NULL;
+        }
+        if (device->context) {
+            SDL_free(device->context);
+            device->context = NULL;
+        }
     }
+    SDL_UnlockMutex(device->dev_lock);
     return SDL_FALSE;
 }
 
@@ -1040,11 +1095,11 @@ HIDAPI_DriverSteam_RumbleJoystickTriggers(SDL_HIDAPI_Device *device, SDL_Joystic
     return SDL_Unsupported();
 }
 
-static SDL_bool
-HIDAPI_DriverSteam_HasJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+static Uint32
+HIDAPI_DriverSteam_GetJoystickCapabilities(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
 {
     /* You should use the full Steam Input API for LED support */
-    return SDL_FALSE;
+    return 0;
 }
 
 static int
@@ -1054,11 +1109,34 @@ HIDAPI_DriverSteam_SetJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joyst
     return SDL_Unsupported();
 }
 
+static int
+HIDAPI_DriverSteam_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *data, int size)
+{
+    return SDL_Unsupported();
+}
+
 static int
 HIDAPI_DriverSteam_SetSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, SDL_bool enabled)
 {
-    /* You should use the full Steam Input API for sensor support */
-    return SDL_Unsupported();
+    SDL_DriverSteam_Context *ctx = (SDL_DriverSteam_Context *)device->context;
+    unsigned char buf[65];
+    int nSettings = 0;
+
+    SDL_memset( buf, 0, 65 );
+    buf[1] = ID_SET_SETTINGS_VALUES;
+    if (enabled) {
+        ADD_SETTING( SETTING_GYRO_MODE, 0x18 /* SETTING_GYRO_SEND_RAW_ACCEL | SETTING_GYRO_MODE_SEND_RAW_GYRO */ );
+    } else {
+        ADD_SETTING( SETTING_GYRO_MODE, 0x00 /* SETTING_GYRO_MODE_OFF */ );
+    }
+    buf[2] = nSettings*3;
+    if (SetFeatureReport( device->dev, buf, 3+nSettings*3 ) < 0) {
+        return SDL_SetError("Couldn't write feature report");
+    }
+
+    ctx->report_sensors = enabled;
+
+    return 0;
 }
 
 static SDL_bool
@@ -1155,6 +1233,20 @@ HIDAPI_DriverSteam_UpdateDevice(SDL_HIDAPI_Device *device)
             SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_RIGHTX, ctx->m_state.sRightPadX);
             SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_RIGHTY, ~ctx->m_state.sRightPadY);
 
+            if (ctx->report_sensors) {
+                float values[3];
+
+                values[0] = (ctx->m_state.sGyroX / 32768.0f) * (2000.0f * (M_PI / 180.0f));
+                values[1] = (ctx->m_state.sGyroZ / 32768.0f) * (2000.0f * (M_PI / 180.0f));
+                values[2] = (ctx->m_state.sGyroY / 32768.0f) * (2000.0f * (M_PI / 180.0f));
+                SDL_PrivateJoystickSensor(joystick, SDL_SENSOR_GYRO, values, 3);
+
+                values[0] = (ctx->m_state.sAccelX / 32768.0f) * 2.0f * SDL_STANDARD_GRAVITY;
+                values[1] = (ctx->m_state.sAccelZ / 32768.0f) * 2.0f * SDL_STANDARD_GRAVITY;
+                values[2] = (-ctx->m_state.sAccelY / 32768.0f) * 2.0f * SDL_STANDARD_GRAVITY;
+                SDL_PrivateJoystickSensor(joystick, SDL_SENSOR_ACCEL, values, 3);
+            }
+
             ctx->m_last_state = ctx->m_state;
         }
 
@@ -1170,12 +1262,17 @@ HIDAPI_DriverSteam_UpdateDevice(SDL_HIDAPI_Device *device)
 static void
 HIDAPI_DriverSteam_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
 {
-    CloseSteamController(device->dev);
-    hid_close(device->dev);
-    device->dev = NULL;
+    SDL_LockMutex(device->dev_lock);
+    {
+        CloseSteamController(device->dev);
 
-    SDL_free(device->context);
-    device->context = NULL;
+        SDL_hid_close(device->dev);
+        device->dev = NULL;
+
+        SDL_free(device->context);
+        device->context = NULL;
+    }
+    SDL_UnlockMutex(device->dev_lock);
 }
 
 static void
@@ -1187,6 +1284,7 @@ SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverSteam =
 {
     SDL_HINT_JOYSTICK_HIDAPI_STEAM,
     SDL_TRUE,
+    SDL_FALSE,
     HIDAPI_DriverSteam_IsSupportedDevice,
     HIDAPI_DriverSteam_GetDeviceName,
     HIDAPI_DriverSteam_InitDevice,
@@ -1196,8 +1294,9 @@ SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverSteam =
     HIDAPI_DriverSteam_OpenJoystick,
     HIDAPI_DriverSteam_RumbleJoystick,
     HIDAPI_DriverSteam_RumbleJoystickTriggers,
-    HIDAPI_DriverSteam_HasJoystickLED,
+    HIDAPI_DriverSteam_GetJoystickCapabilities,
     HIDAPI_DriverSteam_SetJoystickLED,
+    HIDAPI_DriverSteam_SendJoystickEffect,
     HIDAPI_DriverSteam_SetSensorsEnabled,
     HIDAPI_DriverSteam_CloseJoystick,
     HIDAPI_DriverSteam_FreeDevice,
diff --git a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_switch.c b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_switch.c
index aad03de0c..912d613ed 100644
--- a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_switch.c
+++ b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_switch.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -44,13 +44,24 @@
 /* Define this to get log output for rumble logic */
 /*#define DEBUG_RUMBLE*/
 
-/* How often you can write rumble commands to the controller in Bluetooth mode
-   If you send commands more frequently than this, you can turn off the controller.
+/* The initialization sequence doesn't appear to work correctly on Windows unless
+   the reads and writes are on the same thread.
+
+   ... and now I can't reproduce this, so I'm leaving it in, but disabled for now.
  */
-#define RUMBLE_WRITE_FREQUENCY_MS   25
+/*#define SWITCH_SYNCHRONOUS_WRITES*/
+
+/* How often you can write rumble commands to the controller.
+   If you send commands more frequently than this, you can turn off the controller
+   in Bluetooth mode, or the motors can miss the command in USB mode.
+ */
+#define RUMBLE_WRITE_FREQUENCY_MS   30
 
 /* How often you have to refresh a long duration rumble to keep the motors running */
-#define RUMBLE_REFRESH_FREQUENCY_MS 40
+#define RUMBLE_REFRESH_FREQUENCY_MS 50
+
+#define SWITCH_GYRO_SCALE      14.2842f
+#define SWITCH_ACCEL_SCALE     4096.f
 
 typedef enum {
     k_eSwitchInputReportIDs_SubcommandReply       = 0x21,
@@ -79,6 +90,7 @@ typedef enum {
 } ESwitchSubcommandIDs;
 
 typedef enum {
+    k_eSwitchProprietaryCommandIDs_Status    = 0x01,
     k_eSwitchProprietaryCommandIDs_Handshake = 0x02,
     k_eSwitchProprietaryCommandIDs_HighSpeed = 0x03,
     k_eSwitchProprietaryCommandIDs_ForceUSB  = 0x04,
@@ -87,6 +99,7 @@ typedef enum {
 } ESwitchProprietaryCommandIDs;
 
 typedef enum {
+    k_eSwitchDeviceInfoControllerType_Unknown        = 0x0,
     k_eSwitchDeviceInfoControllerType_JoyConLeft     = 0x1,
     k_eSwitchDeviceInfoControllerType_JoyConRight    = 0x2,
     k_eSwitchDeviceInfoControllerType_ProController  = 0x3,
@@ -176,6 +189,16 @@ typedef struct
     };
 } SwitchSubcommandInputPacket_t;
 
+typedef struct
+{
+	Uint8 ucPacketType;
+	Uint8 ucCommandID;
+	Uint8 ucFiller;
+
+	Uint8 ucDeviceType;
+	Uint8 rgucMACAddress[6];
+} SwitchProprietaryStatusPacket_t;
+
 typedef struct
 {
     Uint8 rgucData[4];
@@ -212,6 +235,8 @@ typedef struct {
     SDL_bool m_bUsingBluetooth;
     SDL_bool m_bIsGameCube;
     SDL_bool m_bUseButtonLabels;
+    ESwitchDeviceInfoControllerType m_eControllerType;
+    Uint8 m_rgucMACAddress[6];
     Uint8 m_nCommandNumber;
     SwitchCommonOutputPacket_t m_RumblePacket;
     Uint8 m_rgucReadBuffer[k_unSwitchMaxOutputPacketLength];
@@ -220,6 +245,8 @@ typedef struct {
     SDL_bool m_bRumblePending;
     SDL_bool m_bRumbleZeroPending;
     Uint32 m_unRumblePending;
+    SDL_bool m_bHasSensors;
+    SDL_bool m_bReportSensors;
 
     SwitchInputOnlyControllerStatePacket_t m_lastInputOnlyState;
     SwitchSimpleStatePacket_t m_lastSimpleState;
@@ -285,7 +312,7 @@ HIDAPI_DriverSwitch_IsSupportedDevice(const char *name, SDL_GameControllerType t
        controller to continually attempt to reconnect is to filter it out by manufactuer/product string.
        Note that the controller does have a different product string when connected over Bluetooth.
      */
-    if (SDL_strcmp( name, "HORI Wireless Switch Pad" ) == 0) {
+    if (SDL_strcmp(name, "HORI Wireless Switch Pad") == 0) {
         return SDL_FALSE;
     }
     return (type == SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_PRO) ? SDL_TRUE : SDL_FALSE;
@@ -295,6 +322,20 @@ static const char *
 HIDAPI_DriverSwitch_GetDeviceName(Uint16 vendor_id, Uint16 product_id)
 {
     /* Give a user friendly name for this controller */
+    if (vendor_id == USB_VENDOR_NINTENDO) {
+        if (product_id == USB_PRODUCT_NINTENDO_SWITCH_JOY_CON_GRIP) {
+            return "Nintendo Switch Joy-Con Grip";
+        }
+
+        if (product_id == USB_PRODUCT_NINTENDO_SWITCH_JOY_CON_LEFT) {
+            return "Nintendo Switch Joy-Con Left";
+        }
+
+        if (product_id == USB_PRODUCT_NINTENDO_SWITCH_JOY_CON_RIGHT) {
+            return "Nintendo Switch Joy-Con Right";
+        }
+    }
+
     return "Nintendo Switch Pro Controller";
 }
 
@@ -305,16 +346,20 @@ static int ReadInput(SDL_DriverSwitch_Context *ctx)
         return 0;
     }
 
-    return hid_read_timeout(ctx->device->dev, ctx->m_rgucReadBuffer, sizeof(ctx->m_rgucReadBuffer), 0);
+    return SDL_hid_read_timeout(ctx->device->dev, ctx->m_rgucReadBuffer, sizeof(ctx->m_rgucReadBuffer), 0);
 }
 
 static int WriteOutput(SDL_DriverSwitch_Context *ctx, const Uint8 *data, int size)
 {
+#ifdef SWITCH_SYNCHRONOUS_WRITES
+    return SDL_hid_write(ctx->device->dev, data, size);
+#else
     /* Use the rumble thread for general asynchronous writes */
     if (SDL_HIDAPI_LockRumble() < 0) {
         return -1;
     }
     return SDL_HIDAPI_SendRumbleAndUnlock(ctx->device, data, size);
+#endif /* SWITCH_SYNCHRONOUS_WRITES */
 }
 
 static SwitchSubcommandInputPacket_t *ReadSubcommandReply(SDL_DriverSwitch_Context *ctx, ESwitchSubcommandIDs expectedID)
@@ -373,7 +418,7 @@ static void ConstructSubcommand(SDL_DriverSwitch_Context *ctx, ESwitchSubcommand
     outPacket->commonData.ucPacketType = k_eSwitchOutputReportIDs_RumbleAndSubcommand;
     outPacket->commonData.ucPacketNumber = ctx->m_nCommandNumber;
 
-    SDL_memcpy(&outPacket->commonData.rumbleData, &ctx->m_RumblePacket.rumbleData, sizeof(ctx->m_RumblePacket.rumbleData));
+    SDL_memcpy(outPacket->commonData.rumbleData, ctx->m_RumblePacket.rumbleData, sizeof(ctx->m_RumblePacket.rumbleData));
 
     outPacket->ucSubcommandID = ucCommandID;
     SDL_memcpy(outPacket->rgucSubcommandData, pBuf, ucLen);
@@ -432,6 +477,7 @@ static SDL_bool WriteProprietary(SDL_DriverSwitch_Context *ctx, ESwitchProprieta
             return SDL_FALSE;
         }
 
+        SDL_zero(packet);
         packet.ucPacketType = k_eSwitchOutputReportIDs_Proprietary;
         packet.ucProprietaryID = ucCommand;
         if (pBuf) {
@@ -449,6 +495,64 @@ static SDL_bool WriteProprietary(SDL_DriverSwitch_Context *ctx, ESwitchProprieta
     return SDL_FALSE;
 }
 
+static Uint8 EncodeRumbleHighAmplitude(Uint16 amplitude) {
+    /* More information about these values can be found here:
+     * https://github.com/dekuNukem/Nintendo_Switch_Reverse_Engineering/blob/master/rumble_data_table.md
+     */
+    Uint16 hfa[101][2] = { {0, 0x0},{514, 0x2},{775, 0x4},{921, 0x6},{1096, 0x8},{1303, 0x0a},{1550, 0x0c},
+        {1843, 0x0e},{2192, 0x10},{2606, 0x12},{3100, 0x14},{3686, 0x16},{4383, 0x18},{5213, 0x1a},
+        {6199, 0x1c},{7372, 0x1e},{7698, 0x20},{8039, 0x22},{8395, 0x24},{8767, 0x26},{9155, 0x28},
+        {9560, 0x2a},{9984, 0x2c},{10426, 0x2e},{10887, 0x30},{11369, 0x32},{11873, 0x34},{12398, 0x36},
+        {12947, 0x38},{13520, 0x3a},{14119, 0x3c},{14744, 0x3e},{15067, 0x40},{15397, 0x42},{15734, 0x44},
+        {16079, 0x46},{16431, 0x48},{16790, 0x4a},{17158, 0x4c},{17534, 0x4e},{17918, 0x50},{18310, 0x52},
+        {18711, 0x54},{19121, 0x56},{19540, 0x58},{19967, 0x5a},{20405, 0x5c},{20851, 0x5e},{21308, 0x60},
+        {21775, 0x62},{22251, 0x64},{22739, 0x66},{23236, 0x68},{23745, 0x6a},{24265, 0x6c},{24797, 0x6e},
+        {25340, 0x70},{25894, 0x72},{26462, 0x74},{27041, 0x76},{27633, 0x78},{28238, 0x7a},{28856, 0x7c},
+        {29488, 0x7e},{30134, 0x80},{30794, 0x82},{31468, 0x84},{32157, 0x86},{32861, 0x88},{33581, 0x8a},
+        {34316, 0x8c},{35068, 0x8e},{35836, 0x90},{36620, 0x92},{37422, 0x94},{38242, 0x96},{39079, 0x98},
+        {39935, 0x9a},{40809, 0x9c},{41703, 0x9e},{42616, 0xa0},{43549, 0xa2},{44503, 0xa4},{45477, 0xa6},
+        {46473, 0xa8},{47491, 0xaa},{48531, 0xac},{49593, 0xae},{50679, 0xb0},{51789, 0xb2},{52923, 0xb4},
+        {54082, 0xb6},{55266, 0xb8},{56476, 0xba},{57713, 0xbc},{58977, 0xbe},{60268, 0xc0},{61588, 0xc2},
+        {62936, 0xc4},{64315, 0xc6},{65535, 0xc8} };
+    int index = 0;
+    for ( ; index < 101; index++) {
+        if (amplitude <= hfa[index][0]) {
+            return (Uint8)hfa[index][1];
+        }
+    }
+    return (Uint8)hfa[100][1];
+}
+
+static Uint16 EncodeRumbleLowAmplitude(Uint16 amplitude) {
+    /* More information about these values can be found here:
+     * https://github.com/dekuNukem/Nintendo_Switch_Reverse_Engineering/blob/master/rumble_data_table.md
+     */
+    Uint16 lfa[101][2] = { {0, 0x0040},{514, 0x8040},{775, 0x0041},{921, 0x8041},{1096, 0x0042},
+        {1303, 0x8042},{1550, 0x0043},{1843, 0x8043},{2192, 0x0044},{2606, 0x8044},{3100, 0x0045},
+        {3686, 0x8045},{4383, 0x0046},{5213, 0x8046},{6199, 0x0047},{7372, 0x8047},{7698, 0x0048},
+        {8039, 0x8048},{8395, 0x0049},{8767, 0x8049},{9155, 0x004a},{9560, 0x804a},{9984, 0x004b},
+        {10426, 0x804b},{10887, 0x004c},{11369, 0x804c},{11873, 0x004d},{12398, 0x804d},{12947, 0x004e},
+        {13520, 0x804e},{14119, 0x004f},{14744, 0x804f},{15067, 0x0050},{15397, 0x8050},{15734, 0x0051},
+        {16079, 0x8051},{16431, 0x0052},{16790, 0x8052},{17158, 0x0053},{17534, 0x8053},{17918, 0x0054},
+        {18310, 0x8054},{18711, 0x0055},{19121, 0x8055},{19540, 0x0056},{19967, 0x8056},{20405, 0x0057},
+        {20851, 0x8057},{21308, 0x0058},{21775, 0x8058},{22251, 0x0059},{22739, 0x8059},{23236, 0x005a},
+        {23745, 0x805a},{24265, 0x005b},{24797, 0x805b},{25340, 0x005c},{25894, 0x805c},{26462, 0x005d},
+        {27041, 0x805d},{27633, 0x005e},{28238, 0x805e},{28856, 0x005f},{29488, 0x805f},{30134, 0x0060},
+        {30794, 0x8060},{31468, 0x0061},{32157, 0x8061},{32861, 0x0062},{33581, 0x8062},{34316, 0x0063},
+        {35068, 0x8063},{35836, 0x0064},{36620, 0x8064},{37422, 0x0065},{38242, 0x8065},{39079, 0x0066},
+        {39935, 0x8066},{40809, 0x0067},{41703, 0x8067},{42616, 0x0068},{43549, 0x8068},{44503, 0x0069},
+        {45477, 0x8069},{46473, 0x006a},{47491, 0x806a},{48531, 0x006b},{49593, 0x806b},{50679, 0x006c},
+        {51789, 0x806c},{52923, 0x006d},{54082, 0x806d},{55266, 0x006e},{56476, 0x806e},{57713, 0x006f},
+        {58977, 0x806f},{60268, 0x0070},{61588, 0x8070},{62936, 0x0071},{64315, 0x8071},{65535, 0x0072} };
+    int index = 0;
+    for (; index < 101; index++) {
+        if (amplitude <= lfa[index][0]) {
+            return lfa[index][1];
+        }
+    }
+    return lfa[100][1];
+}
+
 static void SetNeutralRumble(SwitchRumbleData_t *pRumble)
 {
     pRumble->rgucData[0] = 0x00;
@@ -493,6 +597,40 @@ static SDL_bool WriteRumble(SDL_DriverSwitch_Context *ctx)
     return WritePacket(ctx, (Uint8 *)&ctx->m_RumblePacket, sizeof(ctx->m_RumblePacket));
 }
 
+static SDL_bool BReadDeviceInfo(SDL_DriverSwitch_Context *ctx)
+{
+    SwitchSubcommandInputPacket_t *reply = NULL;
+
+    ctx->m_bUsingBluetooth = SDL_FALSE;
+
+    if (WriteProprietary(ctx, k_eSwitchProprietaryCommandIDs_Status, NULL, 0, SDL_TRUE)) {
+        SwitchProprietaryStatusPacket_t *status = (SwitchProprietaryStatusPacket_t *)&ctx->m_rgucReadBuffer[0];
+        size_t i;
+
+        ctx->m_eControllerType = (ESwitchDeviceInfoControllerType)status->ucDeviceType;
+        for (i = 0; i < sizeof (ctx->m_rgucMACAddress); ++i)
+            ctx->m_rgucMACAddress[i] = status->rgucMACAddress[ sizeof(ctx->m_rgucMACAddress) - i - 1 ];
+
+        return SDL_TRUE;
+    }
+
+    ctx->m_bUsingBluetooth = SDL_TRUE;
+
+    if (WriteSubcommand(ctx, k_eSwitchSubcommandIDs_RequestDeviceInfo, NULL, 0, &reply)) {
+        // Byte 2: Controller ID (1=LJC, 2=RJC, 3=Pro)
+        ctx->m_eControllerType = (ESwitchDeviceInfoControllerType)reply->deviceInfo.ucDeviceType;
+
+        // Bytes 4-9: MAC address (big-endian)
+        SDL_memcpy(ctx->m_rgucMACAddress, reply->deviceInfo.rgucMACAddress, sizeof(ctx->m_rgucMACAddress));
+
+        return SDL_TRUE;
+    }
+
+    ctx->m_bUsingBluetooth = SDL_FALSE;
+
+    return SDL_FALSE;
+}
+
 static SDL_bool BTrySetupUSB(SDL_DriverSwitch_Context *ctx)
 {
     /* We have to send a connection handshake to the controller when communicating over USB
@@ -508,6 +646,10 @@ static SDL_bool BTrySetupUSB(SDL_DriverSwitch_Context *ctx)
         /*return SDL_FALSE;*/
     }
     if (!WriteProprietary(ctx, k_eSwitchProprietaryCommandIDs_Handshake, NULL, 0, SDL_TRUE)) {
+        /* This fails on the right Joy-Con when plugged into the charging grip */
+        /*return SDL_FALSE;*/
+    }
+    if (!WriteProprietary(ctx, k_eSwitchProprietaryCommandIDs_ForceUSB, NULL, 0, SDL_FALSE)) {
         return SDL_FALSE;
     }
     return SDL_TRUE;
@@ -550,6 +692,12 @@ static SDL_bool SetSlotLED(SDL_DriverSwitch_Context *ctx, Uint8 slot)
     return WriteSubcommand(ctx, k_eSwitchSubcommandIDs_SetPlayerLights, &led_data, sizeof(led_data), NULL);
 }
 
+static SDL_bool SetIMUEnabled(SDL_DriverSwitch_Context* ctx, SDL_bool enabled)
+{
+    Uint8 imu_data = enabled ? 1 : 0;
+    return WriteSubcommand(ctx, k_eSwitchSubcommandIDs_EnableIMU, &imu_data, sizeof(imu_data), NULL);
+}
+
 static SDL_bool LoadStickCalibration(SDL_DriverSwitch_Context *ctx, Uint8 input_mode)
 {
     Uint8 *pStickCal;
@@ -621,19 +769,6 @@ static SDL_bool LoadStickCalibration(SDL_DriverSwitch_Context *ctx, Uint8 input_
     return SDL_TRUE;
 }
 
-static float fsel(float fComparand, float fValGE, float fLT)
-{
-    return fComparand >= 0 ? fValGE : fLT;
-}
-
-static float RemapVal(float val, float A, float B, float C, float D)
-{
-    if (A == B) {
-        return fsel(val - B , D , C);
-    }
-    return C + (D - C) * (val - A) / (B - A);
-}
-
 static Sint16 ApplyStickCalibrationCentered(SDL_DriverSwitch_Context *ctx, int nStick, int nAxis, Sint16 sRawValue, Sint16 sCenter)
 {
     sRawValue -= sCenter;
@@ -645,11 +780,7 @@ static Sint16 ApplyStickCalibrationCentered(SDL_DriverSwitch_Context *ctx, int n
         ctx->m_StickExtents[nStick].axis[nAxis].sMin = sRawValue;
     }
 
-    if (sRawValue > 0) {
-        return (Sint16)(RemapVal(sRawValue, 0, ctx->m_StickExtents[nStick].axis[nAxis].sMax, 0, SDL_MAX_SINT16));
-    } else {
-        return (Sint16)(RemapVal(sRawValue, ctx->m_StickExtents[nStick].axis[nAxis].sMin, 0, SDL_MIN_SINT16, 0));
-    }
+    return (Sint16)HIDAPI_RemapVal(sRawValue, ctx->m_StickExtents[nStick].axis[nAxis].sMin, ctx->m_StickExtents[nStick].axis[nAxis].sMax, SDL_MIN_SINT16, SDL_MAX_SINT16);
 }
 
 static Sint16 ApplyStickCalibration(SDL_DriverSwitch_Context *ctx, int nStick, int nAxis, Sint16 sRawValue)
@@ -725,7 +856,7 @@ HIDAPI_DriverSwitch_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joysti
     ctx->device = device;
     device->context = ctx;
 
-    device->dev = hid_open_path(device->path, 0);
+    device->dev = SDL_hid_open_path(device->path, 0);
     if (!device->dev) {
         SDL_SetError("Couldn't open %s", device->path);
         goto error;
@@ -740,9 +871,16 @@ HIDAPI_DriverSwitch_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joysti
         SetNeutralRumble(&ctx->m_RumblePacket.rumbleData[0]);
         SetNeutralRumble(&ctx->m_RumblePacket.rumbleData[1]);
 
-        /* Try setting up USB mode, and if that fails we're using Bluetooth */
-        if (!BTrySetupUSB(ctx)) {
-            ctx->m_bUsingBluetooth = SDL_TRUE;
+        if (!BReadDeviceInfo(ctx)) {
+            SDL_SetError("Couldn't read device info");
+            goto error;
+        }
+
+        if (!ctx->m_bUsingBluetooth) {
+            if (!BTrySetupUSB(ctx)) {
+                SDL_SetError("Couldn't setup USB mode");
+                goto error;
+            }
         }
 
         /* Determine the desired input mode (needed before loading stick calibration) */
@@ -758,9 +896,18 @@ HIDAPI_DriverSwitch_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joysti
          * level and we only care about battery level over bluetooth anyway.
          */
         if (device->vendor_id == USB_VENDOR_NINTENDO &&
-            device->product_id == USB_PRODUCT_NINTENDO_SWITCH_PRO) {
+                (device->product_id == USB_PRODUCT_NINTENDO_SWITCH_PRO ||
+                device->product_id == USB_PRODUCT_NINTENDO_SWITCH_JOY_CON_GRIP ||
+                device->product_id == USB_PRODUCT_NINTENDO_SWITCH_JOY_CON_LEFT ||
+                device->product_id == USB_PRODUCT_NINTENDO_SWITCH_JOY_CON_RIGHT)) {
             input_mode = k_eSwitchInputReportIDs_FullControllerState;
         }
+        
+        if (input_mode == k_eSwitchInputReportIDs_FullControllerState) {
+            SDL_PrivateJoystickAddSensor(joystick, SDL_SENSOR_GYRO, 200.0f);
+            SDL_PrivateJoystickAddSensor(joystick, SDL_SENSOR_ACCEL, 200.0f);
+            ctx->m_bHasSensors = SDL_TRUE;
+        }
 
         if (!LoadStickCalibration(ctx, input_mode)) {
             SDL_SetError("Couldn't load stick calibration");
@@ -789,9 +936,30 @@ HIDAPI_DriverSwitch_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joysti
 
         /* Set the LED state */
         if (ctx->m_bHasHomeLED) {
-            SetHomeLED(ctx, 100);
+            const char *hint = SDL_GetHint(SDL_HINT_JOYSTICK_HIDAPI_SWITCH_HOME_LED);
+            if (hint && *hint) {
+                if (SDL_GetStringBoolean(hint, SDL_TRUE)) {
+                    SetHomeLED(ctx, 100);
+                } else {
+                    SetHomeLED(ctx, 0);
+                }
+            }
         }
         SetSlotLED(ctx, (joystick->instance_id % 4));
+
+        /* Set the serial number */
+        {
+            char serial[18];
+
+            SDL_snprintf(serial, sizeof(serial), "%.2x-%.2x-%.2x-%.2x-%.2x-%.2x",
+                ctx->m_rgucMACAddress[0],
+                ctx->m_rgucMACAddress[1],
+                ctx->m_rgucMACAddress[2],
+                ctx->m_rgucMACAddress[3],
+                ctx->m_rgucMACAddress[4],
+                ctx->m_rgucMACAddress[5]);
+            joystick->serial = SDL_strdup(serial);
+        }
     }
 
     if (IsGameCubeFormFactor(device->vendor_id, device->product_id)) {
@@ -803,21 +971,30 @@ HIDAPI_DriverSwitch_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joysti
                         SDL_GameControllerButtonReportingHintChanged, ctx);
 
     /* Initialize the joystick capabilities */
-    joystick->nbuttons = 16;
+    if (ctx->m_eControllerType == k_eSwitchDeviceInfoControllerType_JoyConLeft ||
+        ctx->m_eControllerType == k_eSwitchDeviceInfoControllerType_JoyConRight) {
+        joystick->nbuttons = 20;
+    } else {
+        joystick->nbuttons = 16;
+    }
     joystick->naxes = SDL_CONTROLLER_AXIS_MAX;
     joystick->epowerlevel = SDL_JOYSTICK_POWER_WIRED;
 
     return SDL_TRUE;
 
 error:
-    if (device->dev) {
-        hid_close(device->dev);
-        device->dev = NULL;
-    }
-    if (device->context) {
-        SDL_free(device->context);
-        device->context = NULL;
+    SDL_LockMutex(device->dev_lock);
+    {
+        if (device->dev) {
+            SDL_hid_close(device->dev);
+            device->dev = NULL;
+        }
+        if (device->context) {
+            SDL_free(device->context);
+            device->context = NULL;
+        }
     }
+    SDL_UnlockMutex(device->dev_lock);
     return SDL_FALSE;
 }
 
@@ -831,27 +1008,22 @@ HIDAPI_DriverSwitch_ActuallyRumbleJoystick(SDL_DriverSwitch_Context *ctx, Uint16
      * https://github.com/dekuNukem/Nintendo_Switch_Reverse_Engineering/blob/master/rumble_data_table.md
      */
     const Uint16 k_usHighFreq = 0x0074;
-    const Uint8  k_ucHighFreqAmp = 0xBE;
+    const Uint8  k_ucHighFreqAmp = EncodeRumbleHighAmplitude(high_frequency_rumble);
     const Uint8  k_ucLowFreq = 0x3D;
-    const Uint16 k_usLowFreqAmp = 0x806F;
+    const Uint16 k_usLowFreqAmp = EncodeRumbleLowAmplitude(low_frequency_rumble);
 
-    if (low_frequency_rumble) {
+    if (low_frequency_rumble || high_frequency_rumble) {
         EncodeRumble(&ctx->m_RumblePacket.rumbleData[0], k_usHighFreq, k_ucHighFreqAmp, k_ucLowFreq, k_usLowFreqAmp);
-    } else {
-        SetNeutralRumble(&ctx->m_RumblePacket.rumbleData[0]);
-    }
-
-    if (high_frequency_rumble) {
         EncodeRumble(&ctx->m_RumblePacket.rumbleData[1], k_usHighFreq, k_ucHighFreqAmp, k_ucLowFreq, k_usLowFreqAmp);
     } else {
+        SetNeutralRumble(&ctx->m_RumblePacket.rumbleData[0]);
         SetNeutralRumble(&ctx->m_RumblePacket.rumbleData[1]);
     }
 
     ctx->m_bRumbleActive = (low_frequency_rumble || high_frequency_rumble) ? SDL_TRUE : SDL_FALSE;
 
     if (!WriteRumble(ctx)) {
-        SDL_SetError("Couldn't send rumble packet");
-        return -1;
+        return SDL_SetError("Couldn't send rumble packet");
     }
     return 0;
 }
@@ -859,7 +1031,7 @@ HIDAPI_DriverSwitch_ActuallyRumbleJoystick(SDL_DriverSwitch_Context *ctx, Uint16
 static int
 HIDAPI_DriverSwitch_SendPendingRumble(SDL_DriverSwitch_Context *ctx)
 {
-    if ((SDL_GetTicks() - ctx->m_unRumbleSent) < RUMBLE_WRITE_FREQUENCY_MS) {
+    if (!SDL_TICKS_PASSED(SDL_GetTicks(), ctx->m_unRumbleSent + RUMBLE_WRITE_FREQUENCY_MS)) {
         return 0;
     }
 
@@ -868,7 +1040,7 @@ HIDAPI_DriverSwitch_SendPendingRumble(SDL_DriverSwitch_Context *ctx)
         Uint16 high_frequency_rumble = (Uint16)ctx->m_unRumblePending;
 
 #ifdef DEBUG_RUMBLE
-        SDL_Log("Sent pending rumble %d/%d\n", low_frequency_rumble, high_frequency_rumble);
+        SDL_Log("Sent pending rumble %d/%d, %d ms after previous rumble\n", low_frequency_rumble, high_frequency_rumble, SDL_GetTicks() - ctx->m_unRumbleSent);
 #endif
         ctx->m_bRumblePending = SDL_FALSE;
         ctx->m_unRumblePending = 0;
@@ -880,7 +1052,7 @@ HIDAPI_DriverSwitch_SendPendingRumble(SDL_DriverSwitch_Context *ctx)
         ctx->m_bRumbleZeroPending = SDL_FALSE;
 
 #ifdef DEBUG_RUMBLE
-        SDL_Log("Sent pending zero rumble\n");
+        SDL_Log("Sent pending zero rumble, %d ms after previous rumble\n", SDL_GetTicks() - ctx->m_unRumbleSent);
 #endif
         return HIDAPI_DriverSwitch_ActuallyRumbleJoystick(ctx, 0, 0);
     }
@@ -893,13 +1065,17 @@ HIDAPI_DriverSwitch_RumbleJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joys
 {
     SDL_DriverSwitch_Context *ctx = (SDL_DriverSwitch_Context *)device->context;
 
+    if (ctx->m_bInputOnly) {
+        return SDL_Unsupported();
+    }
+
     if (ctx->m_bRumblePending) {
         if (HIDAPI_DriverSwitch_SendPendingRumble(ctx) < 0) {
             return -1;
         }
     }
 
-    if (ctx->m_bUsingBluetooth && (SDL_GetTicks() - ctx->m_unRumbleSent) < RUMBLE_WRITE_FREQUENCY_MS) {
+    if (!SDL_TICKS_PASSED(SDL_GetTicks(), ctx->m_unRumbleSent + RUMBLE_WRITE_FREQUENCY_MS)) {
         if (low_frequency_rumble || high_frequency_rumble) {
             Uint32 unRumblePending = ((Uint32)low_frequency_rumble << 16) | high_frequency_rumble;
 
@@ -929,11 +1105,18 @@ HIDAPI_DriverSwitch_RumbleJoystickTriggers(SDL_HIDAPI_Device *device, SDL_Joysti
     return SDL_Unsupported();
 }
 
-static SDL_bool
-HIDAPI_DriverSwitch_HasJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+static Uint32
+HIDAPI_DriverSwitch_GetJoystickCapabilities(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
 {
-    /* Doesn't have an RGB LED, so don't return true here */
-    return SDL_FALSE;
+    SDL_DriverSwitch_Context *ctx = (SDL_DriverSwitch_Context *)device->context;
+    Uint32 result = 0;
+
+    if (!ctx->m_bInputOnly) {
+        /* Doesn't have an RGB LED, so don't return SDL_JOYCAP_LED here */
+        result |= SDL_JOYCAP_RUMBLE;
+    }
+
+    return result;
 }
 
 static int
@@ -943,11 +1126,40 @@ HIDAPI_DriverSwitch_SetJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joys
 }
 
 static int
-HIDAPI_DriverSwitch_SetJoystickSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, SDL_bool enabled)
+HIDAPI_DriverSwitch_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *data, int size)
 {
     return SDL_Unsupported();
 }
 
+static int
+HIDAPI_DriverSwitch_SetJoystickSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, SDL_bool enabled)
+{
+    SDL_DriverSwitch_Context* ctx = (SDL_DriverSwitch_Context*)device->context;
+    
+    if (!ctx->m_bHasSensors) {
+        return SDL_Unsupported();
+    }
+
+    SetIMUEnabled(ctx, enabled);
+    ctx->m_bReportSensors = enabled;
+
+    return 0;
+}
+
+static float
+HIDAPI_DriverSwitch_ScaleGyro(Sint16 value)
+{
+    float result = (value / SWITCH_GYRO_SCALE) * (float)M_PI / 180.0f;
+    return result;
+}
+
+static float
+HIDAPI_DriverSwitch_ScaleAccel(Sint16 value)
+{
+    float result = (value / SWITCH_ACCEL_SCALE) * SDL_STANDARD_GRAVITY;
+    return result;
+}
+
 static void HandleInputOnlyControllerState(SDL_Joystick *joystick, SDL_DriverSwitch_Context *ctx, SwitchInputOnlyControllerStatePacket_t *packet)
 {
     Sint16 axis;
@@ -1023,22 +1235,22 @@ static void HandleInputOnlyControllerState(SDL_Joystick *joystick, SDL_DriverSwi
     }
 
     if (packet->rgucJoystickLeft[0] != ctx->m_lastInputOnlyState.rgucJoystickLeft[0]) {
-        axis = (Sint16)(RemapVal(packet->rgucJoystickLeft[0], SDL_MIN_UINT8, SDL_MAX_UINT8, SDL_MIN_SINT16, SDL_MAX_SINT16));
+        axis = (Sint16)HIDAPI_RemapVal(packet->rgucJoystickLeft[0], SDL_MIN_UINT8, SDL_MAX_UINT8, SDL_MIN_SINT16, SDL_MAX_SINT16);
         SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_LEFTX, axis);
     }
 
     if (packet->rgucJoystickLeft[1] != ctx->m_lastInputOnlyState.rgucJoystickLeft[1]) {
-        axis = (Sint16)(RemapVal(packet->rgucJoystickLeft[1], SDL_MIN_UINT8, SDL_MAX_UINT8, SDL_MIN_SINT16, SDL_MAX_SINT16));
+        axis = (Sint16)HIDAPI_RemapVal(packet->rgucJoystickLeft[1], SDL_MIN_UINT8, SDL_MAX_UINT8, SDL_MIN_SINT16, SDL_MAX_SINT16);
         SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_LEFTY, axis);
     }
 
     if (packet->rgucJoystickRight[0] != ctx->m_lastInputOnlyState.rgucJoystickRight[0]) {
-        axis = (Sint16)(RemapVal(packet->rgucJoystickRight[0], SDL_MIN_UINT8, SDL_MAX_UINT8, SDL_MIN_SINT16, SDL_MAX_SINT16));
+        axis = (Sint16)HIDAPI_RemapVal(packet->rgucJoystickRight[0], SDL_MIN_UINT8, SDL_MAX_UINT8, SDL_MIN_SINT16, SDL_MAX_SINT16);
         SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_RIGHTX, axis);
     }
 
     if (packet->rgucJoystickRight[1] != ctx->m_lastInputOnlyState.rgucJoystickRight[1]) {
-        axis = (Sint16)(RemapVal(packet->rgucJoystickRight[1], SDL_MIN_UINT8, SDL_MAX_UINT8, SDL_MIN_SINT16, SDL_MAX_SINT16));
+        axis = (Sint16)HIDAPI_RemapVal(packet->rgucJoystickRight[1], SDL_MIN_UINT8, SDL_MAX_UINT8, SDL_MIN_SINT16, SDL_MAX_SINT16);
         SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_RIGHTY, axis);
     }
 
@@ -1136,6 +1348,33 @@ static void HandleSimpleControllerState(SDL_Joystick *joystick, SDL_DriverSwitch
     ctx->m_lastSimpleState = *packet;
 }
 
+static void SendSensorUpdate(SDL_Joystick *joystick, SDL_DriverSwitch_Context *ctx, SDL_SensorType type, Sint16 *values)
+{
+    float data[3];
+
+    /* Note the order of components has been shuffled to match PlayStation controllers,
+     * since that's our de facto standard from already supporting those controllers, and
+     * users will want consistent axis mappings across devices.
+     */
+    if (type == SDL_SENSOR_GYRO) {
+        data[0] = -HIDAPI_DriverSwitch_ScaleGyro(values[1]);
+        data[1] = HIDAPI_DriverSwitch_ScaleGyro(values[2]);
+        data[2] = -HIDAPI_DriverSwitch_ScaleGyro(values[0]);
+    } else {
+        data[0] = -HIDAPI_DriverSwitch_ScaleAccel(values[1]);
+        data[1] = HIDAPI_DriverSwitch_ScaleAccel(values[2]);
+        data[2] = -HIDAPI_DriverSwitch_ScaleAccel(values[0]);
+    }
+
+    /* Right Joy-Con flips some axes, so let's flip them back for consistency */
+    if (ctx->m_eControllerType == k_eSwitchDeviceInfoControllerType_JoyConRight) {
+        data[0] = -data[0];
+        data[1] = -data[1];
+    }
+
+    SDL_PrivateJoystickSensor(joystick, type, data, 3);
+}
+
 static void HandleFullControllerState(SDL_Joystick *joystick, SDL_DriverSwitch_Context *ctx, SwitchStatePacket_t *packet)
 {
     Sint16 axis;
@@ -1146,6 +1385,10 @@ static void HandleFullControllerState(SDL_Joystick *joystick, SDL_DriverSwitch_C
         SDL_PrivateJoystickButton(joystick, RemapButton(ctx, SDL_CONTROLLER_BUTTON_B), (data & 0x04) ? SDL_PRESSED : SDL_RELEASED);
         SDL_PrivateJoystickButton(joystick, RemapButton(ctx, SDL_CONTROLLER_BUTTON_X), (data & 0x02) ? SDL_PRESSED : SDL_RELEASED);
         SDL_PrivateJoystickButton(joystick, RemapButton(ctx, SDL_CONTROLLER_BUTTON_Y), (data & 0x01) ? SDL_PRESSED : SDL_RELEASED);
+        if (ctx->m_eControllerType == k_eSwitchDeviceInfoControllerType_JoyConRight) {
+            SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_PADDLE1, (data & 0x10) ? SDL_PRESSED : SDL_RELEASED);
+            SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_PADDLE3, (data & 0x20) ? SDL_PRESSED : SDL_RELEASED);
+        }
         SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER, (data & 0x40) ? SDL_PRESSED : SDL_RELEASED);
         axis = (data & 0x80) ? 32767 : -32768;
         SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_TRIGGERRIGHT, axis);
@@ -1168,6 +1411,10 @@ static void HandleFullControllerState(SDL_Joystick *joystick, SDL_DriverSwitch_C
         SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_DPAD_UP, (data & 0x02) ? SDL_PRESSED : SDL_RELEASED);
         SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_DPAD_RIGHT, (data & 0x04) ? SDL_PRESSED : SDL_RELEASED);
         SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_DPAD_LEFT, (data & 0x08) ? SDL_PRESSED : SDL_RELEASED);
+        if (ctx->m_eControllerType == k_eSwitchDeviceInfoControllerType_JoyConLeft) {
+            SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_PADDLE4, (data & 0x10) ? SDL_PRESSED : SDL_RELEASED);
+            SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_PADDLE2, (data & 0x20) ? SDL_PRESSED : SDL_RELEASED);
+        }
         SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_LEFTSHOULDER, (data & 0x40) ? SDL_PRESSED : SDL_RELEASED);
         axis = (data & 0x80) ? 32767 : -32768;
         SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_TRIGGERLEFT, axis);
@@ -1210,6 +1457,16 @@ static void HandleFullControllerState(SDL_Joystick *joystick, SDL_DriverSwitch_C
         }
     }
 
+    if (ctx->m_bReportSensors) {
+        SendSensorUpdate(joystick, ctx, SDL_SENSOR_GYRO, &packet->imuState[2].sGyroX);
+        SendSensorUpdate(joystick, ctx, SDL_SENSOR_GYRO, &packet->imuState[1].sGyroX);
+        SendSensorUpdate(joystick, ctx, SDL_SENSOR_GYRO, &packet->imuState[0].sGyroX);
+
+        SendSensorUpdate(joystick, ctx, SDL_SENSOR_ACCEL, &packet->imuState[2].sAccelX);
+        SendSensorUpdate(joystick, ctx, SDL_SENSOR_ACCEL, &packet->imuState[1].sAccelX);
+        SendSensorUpdate(joystick, ctx, SDL_SENSOR_ACCEL, &packet->imuState[0].sAccelX);
+    }
+
     ctx->m_lastFullState = *packet;
 }
 
@@ -1252,7 +1509,7 @@ HIDAPI_DriverSwitch_UpdateDevice(SDL_HIDAPI_Device *device)
     } else if (ctx->m_bRumbleActive &&
                SDL_TICKS_PASSED(SDL_GetTicks(), ctx->m_unRumbleSent + RUMBLE_REFRESH_FREQUENCY_MS)) {
 #ifdef DEBUG_RUMBLE
-        SDL_Log("Sent continuing rumble\n");
+        SDL_Log("Sent continuing rumble, %d ms after previous rumble\n", SDL_GetTicks() - ctx->m_unRumbleSent);
 #endif
         WriteRumble(ctx);
     }
@@ -1277,11 +1534,15 @@ HIDAPI_DriverSwitch_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joyst
     SDL_DelHintCallback(SDL_HINT_GAMECONTROLLER_USE_BUTTON_LABELS,
                         SDL_GameControllerButtonReportingHintChanged, ctx);
 
-    hid_close(device->dev);
-    device->dev = NULL;
+    SDL_LockMutex(device->dev_lock);
+    {
+        SDL_hid_close(device->dev);
+        device->dev = NULL;
 
-    SDL_free(device->context);
-    device->context = NULL;
+        SDL_free(device->context);
+        device->context = NULL;
+    }
+    SDL_UnlockMutex(device->dev_lock);
 }
 
 static void
@@ -1293,6 +1554,7 @@ SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverSwitch =
 {
     SDL_HINT_JOYSTICK_HIDAPI_SWITCH,
     SDL_TRUE,
+    SDL_TRUE,
     HIDAPI_DriverSwitch_IsSupportedDevice,
     HIDAPI_DriverSwitch_GetDeviceName,
     HIDAPI_DriverSwitch_InitDevice,
@@ -1302,8 +1564,9 @@ SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverSwitch =
     HIDAPI_DriverSwitch_OpenJoystick,
     HIDAPI_DriverSwitch_RumbleJoystick,
     HIDAPI_DriverSwitch_RumbleJoystickTriggers,
-    HIDAPI_DriverSwitch_HasJoystickLED,
+    HIDAPI_DriverSwitch_GetJoystickCapabilities,
     HIDAPI_DriverSwitch_SetJoystickLED,
+    HIDAPI_DriverSwitch_SendJoystickEffect,
     HIDAPI_DriverSwitch_SetJoystickSensorsEnabled,
     HIDAPI_DriverSwitch_CloseJoystick,
     HIDAPI_DriverSwitch_FreeDevice,
diff --git a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_xbox360.c b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_xbox360.c
index e3b3919c6..da7aa240f 100644
--- a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_xbox360.c
+++ b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_xbox360.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -42,22 +42,6 @@ typedef struct {
     Uint8 last_state[USB_PACKET_LENGTH];
 } SDL_DriverXbox360_Context;
 
-#if defined(__MACOSX__)
-static SDL_bool
-IsBluetoothXboxOneController(Uint16 vendor_id, Uint16 product_id)
-{
-    /* Check to see if it's the Xbox One S or Xbox One Elite Series 2 in Bluetooth mode */
-    if (vendor_id == USB_VENDOR_MICROSOFT) {
-        if (product_id == USB_PRODUCT_XBOX_ONE_S_REV1_BLUETOOTH ||
-            product_id == USB_PRODUCT_XBOX_ONE_S_REV2_BLUETOOTH ||
-            product_id == USB_PRODUCT_XBOX_ONE_ELITE_SERIES_2_BLUETOOTH) {
-            return SDL_TRUE;
-        }
-    }
-    return SDL_FALSE;
-}
-#endif
-
 static SDL_bool
 HIDAPI_DriverXbox360_IsSupportedDevice(const char *name, SDL_GameControllerType type, Uint16 vendor_id, Uint16 product_id, Uint16 version, int interface_number, int interface_class, int interface_subclass, int interface_protocol)
 {
@@ -89,7 +73,7 @@ HIDAPI_DriverXbox360_IsSupportedDevice(const char *name, SDL_GameControllerType
 
        Bluetooth Xbox One controllers are handled by the SDL Xbox One driver
     */
-    if (IsBluetoothXboxOneController(vendor_id, product_id)) {
+    if (SDL_IsJoystickBluetoothXboxOne(vendor_id, product_id)) {
         return SDL_FALSE;
     }
     return (type == SDL_CONTROLLER_TYPE_XBOX360 || type == SDL_CONTROLLER_TYPE_XBOXONE) ? SDL_TRUE : SDL_FALSE;
@@ -104,12 +88,14 @@ HIDAPI_DriverXbox360_GetDeviceName(Uint16 vendor_id, Uint16 product_id)
     return NULL;
 }
 
-static SDL_bool SetSlotLED(hid_device *dev, Uint8 slot)
+static SDL_bool SetSlotLED(SDL_hid_device *dev, Uint8 slot)
 {
-    Uint8 mode = 0x02 + slot;
-    const Uint8 led_packet[] = { 0x01, 0x03, mode };
+    const SDL_bool blink = SDL_FALSE;
+    Uint8 mode = (blink ? 0x02 : 0x06) + slot;
+    Uint8 led_packet[] = { 0x01, 0x03, 0x00 };
 
-    if (hid_write(dev, led_packet, sizeof(led_packet)) != sizeof(led_packet)) {
+    led_packet[2] = mode;
+    if (SDL_hid_write(dev, led_packet, sizeof(led_packet)) != sizeof(led_packet)) {
         return SDL_FALSE;
     }
     return SDL_TRUE;
@@ -133,7 +119,9 @@ HIDAPI_DriverXbox360_SetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_Joystic
     if (!device->dev) {
         return;
     }
-    SetSlotLED(device->dev, (player_index % 4));
+    if (player_index >= 0) {
+        SetSlotLED(device->dev, (player_index % 4));
+    }
 }
 
 static SDL_bool
@@ -148,7 +136,7 @@ HIDAPI_DriverXbox360_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joyst
         return SDL_FALSE;
     }
 
-    device->dev = hid_open_path(device->path, 0);
+    device->dev = SDL_hid_open_path(device->path, 0);
     if (!device->dev) {
         SDL_SetError("Couldn't open %s", device->path);
         SDL_free(ctx);
@@ -174,7 +162,7 @@ static int
 HIDAPI_DriverXbox360_RumbleJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
 {
 #ifdef __MACOSX__
-    if (IsBluetoothXboxOneController(device->vendor_id, device->product_id)) {
+    if (SDL_IsJoystickBluetoothXboxOne(device->vendor_id, device->product_id)) {
         Uint8 rumble_packet[] = { 0x03, 0x0F, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00 };
 
         rumble_packet[4] = (low_frequency_rumble >> 8);
@@ -215,11 +203,11 @@ HIDAPI_DriverXbox360_RumbleJoystickTriggers(SDL_HIDAPI_Device *device, SDL_Joyst
     return SDL_Unsupported();
 }
 
-static SDL_bool
-HIDAPI_DriverXbox360_HasJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+static Uint32
+HIDAPI_DriverXbox360_GetJoystickCapabilities(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
 {
-    /* Doesn't have an RGB LED, so don't return true here */
-    return SDL_FALSE;
+    /* Doesn't have an RGB LED, so don't return SDL_JOYCAP_LED here */
+    return SDL_JOYCAP_RUMBLE;
 }
 
 static int
@@ -228,6 +216,12 @@ HIDAPI_DriverXbox360_SetJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joy
     return SDL_Unsupported();
 }
 
+static int
+HIDAPI_DriverXbox360_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *data, int size)
+{
+    return SDL_Unsupported();
+}
+
 static int
 HIDAPI_DriverXbox360_SetJoystickSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, SDL_bool enabled)
 {
@@ -302,7 +296,7 @@ HIDAPI_DriverXbox360_UpdateDevice(SDL_HIDAPI_Device *device)
         return SDL_FALSE;
     }
 
-    while ((size = hid_read_timeout(device->dev, data, sizeof(data), 0)) > 0) {
+    while ((size = SDL_hid_read_timeout(device->dev, data, sizeof(data), 0)) > 0) {
 #ifdef DEBUG_XBOX_PROTOCOL
         HIDAPI_DumpPacket("Xbox 360 packet: size = %d", data, size);
 #endif
@@ -321,13 +315,17 @@ HIDAPI_DriverXbox360_UpdateDevice(SDL_HIDAPI_Device *device)
 static void
 HIDAPI_DriverXbox360_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
 {
-    if (device->dev) {
-        hid_close(device->dev);
-        device->dev = NULL;
-    }
+    SDL_LockMutex(device->dev_lock);
+    {
+        if (device->dev) {
+            SDL_hid_close(device->dev);
+            device->dev = NULL;
+        }
 
-    SDL_free(device->context);
-    device->context = NULL;
+        SDL_free(device->context);
+        device->context = NULL;
+    }
+    SDL_UnlockMutex(device->dev_lock);
 }
 
 static void
@@ -339,6 +337,7 @@ SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverXbox360 =
 {
     SDL_HINT_JOYSTICK_HIDAPI_XBOX,
     SDL_TRUE,
+    SDL_TRUE,
     HIDAPI_DriverXbox360_IsSupportedDevice,
     HIDAPI_DriverXbox360_GetDeviceName,
     HIDAPI_DriverXbox360_InitDevice,
@@ -348,8 +347,9 @@ SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverXbox360 =
     HIDAPI_DriverXbox360_OpenJoystick,
     HIDAPI_DriverXbox360_RumbleJoystick,
     HIDAPI_DriverXbox360_RumbleJoystickTriggers,
-    HIDAPI_DriverXbox360_HasJoystickLED,
+    HIDAPI_DriverXbox360_GetJoystickCapabilities,
     HIDAPI_DriverXbox360_SetJoystickLED,
+    HIDAPI_DriverXbox360_SendJoystickEffect,
     HIDAPI_DriverXbox360_SetJoystickSensorsEnabled,
     HIDAPI_DriverXbox360_CloseJoystick,
     HIDAPI_DriverXbox360_FreeDevice,
diff --git a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_xbox360w.c b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_xbox360w.c
index 40dcae626..e6e6171ab 100644
--- a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_xbox360w.c
+++ b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_xbox360w.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -49,7 +49,7 @@ HIDAPI_DriverXbox360W_IsSupportedDevice(const char *name, SDL_GameControllerType
 {
     const int XB360W_IFACE_PROTOCOL = 129; /* Wireless */
 
-    if ((vendor_id == USB_VENDOR_MICROSOFT && (product_id == 0x0291 || product_id == 0x02a9 || product_id == 0x0719)) ||
+    if ((vendor_id == USB_VENDOR_MICROSOFT && (product_id == 0x0291 || product_id == 0x02a9 || product_id == 0x0719) && interface_protocol == 0) ||
         (type == SDL_CONTROLLER_TYPE_XBOX360 && interface_protocol == XB360W_IFACE_PROTOCOL)) {
         return SDL_TRUE;
     }
@@ -62,12 +62,14 @@ HIDAPI_DriverXbox360W_GetDeviceName(Uint16 vendor_id, Uint16 product_id)
     return "Xbox 360 Wireless Controller";
 }
 
-static SDL_bool SetSlotLED(hid_device *dev, Uint8 slot)
+static SDL_bool SetSlotLED(SDL_hid_device *dev, Uint8 slot)
 {
-    Uint8 mode = 0x02 + slot;
-    const Uint8 led_packet[] = { 0x00, 0x00, 0x08, (0x40 + (mode % 0x0e)), 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+    const SDL_bool blink = SDL_FALSE;
+    Uint8 mode = (blink ? 0x02 : 0x06) + slot;
+    Uint8 led_packet[] = { 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 
-    if (hid_write(dev, led_packet, sizeof(led_packet)) != sizeof(led_packet)) {
+    led_packet[3] = 0x40 + (mode % 0x0e);
+    if (SDL_hid_write(dev, led_packet, sizeof(led_packet)) != sizeof(led_packet)) {
         return SDL_FALSE;
     }
     return SDL_TRUE;
@@ -103,7 +105,7 @@ HIDAPI_DriverXbox360W_InitDevice(SDL_HIDAPI_Device *device)
         return SDL_FALSE;
     }
 
-    device->dev = hid_open_path(device->path, 0);
+    device->dev = SDL_hid_open_path(device->path, 0);
     if (!device->dev) {
         SDL_free(ctx);
         SDL_SetError("Couldn't open %s", device->path);
@@ -111,7 +113,7 @@ HIDAPI_DriverXbox360W_InitDevice(SDL_HIDAPI_Device *device)
     }
     device->context = ctx;
 
-    if (hid_write(device->dev, init_packet, sizeof(init_packet)) != sizeof(init_packet)) {
+    if (SDL_hid_write(device->dev, init_packet, sizeof(init_packet)) != sizeof(init_packet)) {
         SDL_SetError("Couldn't write init packet");
         return SDL_FALSE;
     }
@@ -131,7 +133,9 @@ HIDAPI_DriverXbox360W_SetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_Joysti
     if (!device->dev) {
         return;
     }
-    SetSlotLED(device->dev, (player_index % 4));
+    if (player_index >= 0) {
+        SetSlotLED(device->dev, (player_index % 4));
+    }
 }
 
 static SDL_bool
@@ -169,11 +173,11 @@ HIDAPI_DriverXbox360W_RumbleJoystickTriggers(SDL_HIDAPI_Device *device, SDL_Joys
     return SDL_Unsupported();
 }
 
-static SDL_bool
-HIDAPI_DriverXbox360W_HasJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+static Uint32
+HIDAPI_DriverXbox360W_GetJoystickCapabilities(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
 {
-    /* Doesn't have an RGB LED, so don't return true here */
-    return SDL_FALSE;
+    /* Doesn't have an RGB LED, so don't return SDL_JOYCAP_LED here */
+    return SDL_JOYCAP_RUMBLE;
 }
 
 static int
@@ -182,6 +186,12 @@ HIDAPI_DriverXbox360W_SetJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *jo
     return SDL_Unsupported();
 }
 
+static int
+HIDAPI_DriverXbox360W_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *data, int size)
+{
+    return SDL_Unsupported();
+}
+
 static int
 HIDAPI_DriverXbox360W_SetJoystickSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, SDL_bool enabled)
 {
@@ -189,7 +199,7 @@ HIDAPI_DriverXbox360W_SetJoystickSensorsEnabled(SDL_HIDAPI_Device *device, SDL_J
 }
 
 static void
-HIDAPI_DriverXbox360W_HandleStatePacket(SDL_Joystick *joystick, hid_device *dev, SDL_DriverXbox360W_Context *ctx, Uint8 *data, int size)
+HIDAPI_DriverXbox360W_HandleStatePacket(SDL_Joystick *joystick, SDL_hid_device *dev, SDL_DriverXbox360W_Context *ctx, Uint8 *data, int size)
 {
     Sint16 axis;
     const SDL_bool invert_y_axes = SDL_TRUE;
@@ -249,7 +259,7 @@ HIDAPI_DriverXbox360W_UpdateDevice(SDL_HIDAPI_Device *device)
         joystick = SDL_JoystickFromInstanceID(device->joysticks[0]);
     }
 
-    while ((size = hid_read_timeout(device->dev, data, sizeof(data), 0)) > 0) {
+    while ((size = SDL_hid_read_timeout(device->dev, data, sizeof(data), 0)) > 0) {
 #ifdef DEBUG_XBOX_PROTOCOL
         HIDAPI_DumpPacket("Xbox 360 wireless packet: size = %d", data, size);
 #endif
@@ -309,17 +319,22 @@ HIDAPI_DriverXbox360W_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joy
 static void
 HIDAPI_DriverXbox360W_FreeDevice(SDL_HIDAPI_Device *device)
 {
-    hid_close(device->dev);
-    device->dev = NULL;
+    SDL_LockMutex(device->dev_lock);
+    {
+        SDL_hid_close(device->dev);
+        device->dev = NULL;
 
-    SDL_free(device->context);
-    device->context = NULL;
+        SDL_free(device->context);
+        device->context = NULL;
+    }
+    SDL_UnlockMutex(device->dev_lock);
 }
 
 SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverXbox360W =
 {
     SDL_HINT_JOYSTICK_HIDAPI_XBOX,
     SDL_TRUE,
+    SDL_TRUE,
     HIDAPI_DriverXbox360W_IsSupportedDevice,
     HIDAPI_DriverXbox360W_GetDeviceName,
     HIDAPI_DriverXbox360W_InitDevice,
@@ -329,8 +344,9 @@ SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverXbox360W =
     HIDAPI_DriverXbox360W_OpenJoystick,
     HIDAPI_DriverXbox360W_RumbleJoystick,
     HIDAPI_DriverXbox360W_RumbleJoystickTriggers,
-    HIDAPI_DriverXbox360W_HasJoystickLED,
+    HIDAPI_DriverXbox360W_GetJoystickCapabilities,
     HIDAPI_DriverXbox360W_SetJoystickLED,
+    HIDAPI_DriverXbox360W_SendJoystickEffect,
     HIDAPI_DriverXbox360W_SetJoystickSensorsEnabled,
     HIDAPI_DriverXbox360W_CloseJoystick,
     HIDAPI_DriverXbox360W_FreeDevice,
diff --git a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_xboxone.c b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_xboxone.c
index 5cb7dabc4..1f0cf5b5a 100644
--- a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_xboxone.c
+++ b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_xboxone.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -43,34 +43,28 @@
 #define CONTROLLER_NEGOTIATION_TIMEOUT_MS   300
 #define CONTROLLER_PREPARE_INPUT_TIMEOUT_MS 50
 
+/* Deadzone thresholds */
+#define XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE  7849
+#define XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE 8689
+#define XINPUT_GAMEPAD_TRIGGER_THRESHOLD    -25058 /* Uint8 30 scaled to Sint16 full range */
 
-/* Connect controller */
+/* Start controller */
 static const Uint8 xboxone_init0[] = {
-    0x04, 0x20, 0x00, 0x00
-};
-/* Start controller - extended? */
-static const Uint8 xboxone_init1[] = {
-    0x05, 0x20, 0x00, 0x0F, 0x06, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x55, 0x53, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00
-};
-/* Start controller with input */
-static const Uint8 xboxone_init2[] = {
     0x05, 0x20, 0x03, 0x01, 0x00
 };
 /* Enable LED */
-static const Uint8 xboxone_init3[] = {
+static const Uint8 xboxone_init1[] = {
     0x0A, 0x20, 0x00, 0x03, 0x00, 0x01, 0x14
 };
-/* Start input reports? */
-static const Uint8 xboxone_init4[] = {
-    0x06, 0x20, 0x00, 0x02, 0x01, 0x00
-};
-/* Start rumble? */
-static const Uint8 xboxone_init5[] = {
+/* Setup rumble (not needed for Microsoft controllers, but it doesn't hurt) */
+static const Uint8 xboxone_init2[] = {
     0x09, 0x00, 0x00, 0x09, 0x00, 0x0F, 0x00, 0x00,
     0x00, 0x00, 0xFF, 0x00, 0xEB
 };
+/* This controller passed security check */
+static const Uint8 security_passed_packet[] = {
+    0x06, 0x20, 0x00, 0x02, 0x01, 0x00
+};
 
 /*
  * This specifies the selection of init packets that a gamepad
@@ -90,16 +84,11 @@ typedef struct {
 
 
 static const SDL_DriverXboxOne_InitPacket xboxone_init_packets[] = {
-    { 0x0000, 0x0000, 0x0000, 0x0000, xboxone_init0, sizeof(xboxone_init0), { 0x04, 0xb0 } },
+    /* The PDP Rock Candy controller doesn't start sending input until it gets this packet */
+    { 0x0e6f, 0x0246, 0x0000, 0x0000, security_passed_packet, sizeof(security_passed_packet), { 0x00, 0x00 } },
+    { 0x0000, 0x0000, 0x0000, 0x0000, xboxone_init0, sizeof(xboxone_init0), { 0x00, 0x00 } },
     { 0x0000, 0x0000, 0x0000, 0x0000, xboxone_init1, sizeof(xboxone_init1), { 0x00, 0x00 } },
     { 0x0000, 0x0000, 0x0000, 0x0000, xboxone_init2, sizeof(xboxone_init2), { 0x00, 0x00 } },
-    { 0x0000, 0x0000, 0x0000, 0x0000, xboxone_init3, sizeof(xboxone_init3), { 0x00, 0x00 } },
-
-    /* These next packets are required for third party controllers (PowerA, PDP, HORI),
-       but aren't the correct protocol for Microsoft Xbox controllers.
-     */
-    { 0x0000, 0x0000, 0x045e, 0x0000, xboxone_init4, sizeof(xboxone_init4), { 0x00, 0x00 } },
-    { 0x0000, 0x0000, 0x045e, 0x0000, xboxone_init5, sizeof(xboxone_init5), { 0x00, 0x00 } },
 };
 
 typedef enum {
@@ -120,6 +109,7 @@ typedef struct {
     Uint32 send_time;
     Uint8 last_state[USB_PACKET_LENGTH];
     SDL_bool has_guide_packet;
+    SDL_bool has_color_led;
     SDL_bool has_paddles;
     SDL_bool has_trigger_rumble;
     SDL_bool has_share_button;
@@ -129,20 +119,10 @@ typedef struct {
     Uint8 right_trigger_rumble;
 } SDL_DriverXboxOne_Context;
 
-
 static SDL_bool
-IsBluetoothXboxOneController(Uint16 vendor_id, Uint16 product_id)
+ControllerHasColorLED(Uint16 vendor_id, Uint16 product_id)
 {
-    /* Check to see if it's the Xbox One S or Xbox One Elite Series 2 in Bluetooth mode */
-    if (vendor_id == USB_VENDOR_MICROSOFT) {
-        if (product_id == USB_PRODUCT_XBOX_ONE_S_REV1_BLUETOOTH ||
-            product_id == USB_PRODUCT_XBOX_ONE_S_REV2_BLUETOOTH ||
-            product_id == USB_PRODUCT_XBOX_ONE_ELITE_SERIES_2_BLUETOOTH ||
-            product_id == USB_PRODUCT_XBOX_ONE_SERIES_X_BLUETOOTH) {
-            return SDL_TRUE;
-        }
-    }
-    return SDL_FALSE;
+    return (vendor_id == USB_VENDOR_MICROSOFT && product_id == USB_PRODUCT_XBOX_ONE_ELITE_SERIES_2);
 }
 
 static SDL_bool
@@ -154,13 +134,14 @@ ControllerHasPaddles(Uint16 vendor_id, Uint16 product_id)
 static SDL_bool
 ControllerHasTriggerRumble(Uint16 vendor_id, Uint16 product_id)
 {
-    return SDL_IsJoystickXboxOneElite(vendor_id, product_id);
+    /* All the Microsoft Xbox One controllers have trigger rumble */
+    return (vendor_id == USB_VENDOR_MICROSOFT);
 }
 
 static SDL_bool
 ControllerHasShareButton(Uint16 vendor_id, Uint16 product_id)
 {
-    return SDL_IsJoystickXboxOneSeriesX(vendor_id, product_id);
+    return SDL_IsJoystickXboxSeriesX(vendor_id, product_id);
 }
 
 static void
@@ -179,7 +160,11 @@ SendAckIfNeeded(SDL_HIDAPI_Device *device, Uint8 *data, int size)
     /* The Windows driver is taking care of acks */
 #else
     if ((data[1] & 0x30) == 0x30) {
-        Uint8 ack_packet[] = { 0x01, 0x20, data[2], 0x09, 0x00, data[0], 0x20, data[3], 0x00, 0x00, 0x00, 0x00, 0x00 };
+        Uint8 ack_packet[] = { 0x01, 0x20, 0x00, 0x09, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+        ack_packet[2] = data[2];
+        ack_packet[5] = data[0];
+        ack_packet[7] = data[3];
 
         /* The initial ack needs 0x80 added to the response, for some reason */
         if (data[0] == 0x04 && data[1] == 0xF0) {
@@ -189,7 +174,10 @@ SendAckIfNeeded(SDL_HIDAPI_Device *device, Uint8 *data, int size)
 #ifdef DEBUG_XBOX_PROTOCOL
         HIDAPI_DumpPacket("Xbox One sending ACK packet: size = %d", ack_packet, sizeof(ack_packet));
 #endif
-        hid_write(device->dev, ack_packet, sizeof(ack_packet));
+        if (SDL_HIDAPI_LockRumble() < 0 ||
+            SDL_HIDAPI_SendRumbleAndUnlock(device, ack_packet, sizeof(ack_packet)) != sizeof(ack_packet)) {
+            SDL_SetError("Couldn't send ack packet");
+        }
     }
 #endif /* __WIN32__ */
 }
@@ -289,7 +277,7 @@ HIDAPI_DriverXboxOne_IsSupportedDevice(const char *name, SDL_GameControllerType
 #endif
 #ifdef __MACOSX__
     /* Wired Xbox One controllers are handled by the 360Controller driver */
-    if (!IsBluetoothXboxOneController(vendor_id, product_id)) {
+    if (!SDL_IsJoystickBluetoothXboxOne(vendor_id, product_id)) {
         return SDL_FALSE;
     }
 #endif
@@ -333,7 +321,7 @@ HIDAPI_DriverXboxOne_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joyst
         return SDL_FALSE;
     }
 
-    device->dev = hid_open_path(device->path, 0);
+    device->dev = SDL_hid_open_path(device->path, 0);
     if (!device->dev) {
         SDL_free(ctx);
         SDL_SetError("Couldn't open %s", device->path);
@@ -343,9 +331,10 @@ HIDAPI_DriverXboxOne_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joyst
 
     ctx->vendor_id = device->vendor_id;
     ctx->product_id = device->product_id;
-    ctx->bluetooth = IsBluetoothXboxOneController(device->vendor_id, device->product_id);
+    ctx->bluetooth = SDL_IsJoystickBluetoothXboxOne(device->vendor_id, device->product_id);
     ctx->start_time = SDL_GetTicks();
     ctx->sequence = 1;
+    ctx->has_color_led = ControllerHasColorLED(ctx->vendor_id, ctx->product_id);
     ctx->has_paddles = ControllerHasPaddles(ctx->vendor_id, ctx->product_id);
     ctx->has_trigger_rumble = ControllerHasTriggerRumble(ctx->vendor_id, ctx->product_id);
     ctx->has_share_button = ControllerHasShareButton(ctx->vendor_id, ctx->product_id);
@@ -437,15 +426,48 @@ HIDAPI_DriverXboxOne_RumbleJoystickTriggers(SDL_HIDAPI_Device *device, SDL_Joyst
     return HIDAPI_DriverXboxOne_UpdateRumble(device);
 }
 
-static SDL_bool
-HIDAPI_DriverXboxOne_HasJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+static Uint32
+HIDAPI_DriverXboxOne_GetJoystickCapabilities(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
 {
-    /* Doesn't have an RGB LED, so don't return true here */
-    return SDL_FALSE;
+    SDL_DriverXboxOne_Context *ctx = (SDL_DriverXboxOne_Context *)device->context;
+    Uint32 result = 0;
+
+    result |= SDL_JOYCAP_RUMBLE;
+    if (ctx->has_trigger_rumble) {
+        result |= SDL_JOYCAP_RUMBLE_TRIGGERS;
+    }
+
+    if (ctx->has_color_led) {
+        result |= SDL_JOYCAP_LED;
+    }
+
+    return result;
 }
 
 static int
 HIDAPI_DriverXboxOne_SetJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+    SDL_DriverXboxOne_Context *ctx = (SDL_DriverXboxOne_Context *)device->context;
+
+    if (ctx->has_color_led) {
+        Uint8 led_packet[] = { 0x0E, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+        led_packet[5] = 0x00; /* Whiteness? Sets white intensity when RGB is 0, seems additive */
+        led_packet[6] = red;
+        led_packet[7] = green;
+        led_packet[8] = blue;
+
+        if (SDL_HIDAPI_SendRumble(device, led_packet, sizeof(led_packet)) != sizeof(led_packet)) {
+            return SDL_SetError("Couldn't send LED packet");
+        }
+        return 0;
+    } else {
+        return SDL_Unsupported();
+    }
+}
+
+static int
+HIDAPI_DriverXboxOne_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *data, int size)
 {
     return SDL_Unsupported();
 }
@@ -488,14 +510,23 @@ HIDAPI_DriverXboxOne_HandleStatePacket(SDL_Joystick *joystick, SDL_DriverXboxOne
     }
 
     if (ctx->has_share_button) {
-        /* Version 1 of the firmware for Xbox One Series X */
-        if (ctx->last_state[18] != data[18]) {
-            SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_MISC1, (data[18] & 0x01) ? SDL_PRESSED : SDL_RELEASED);
-        }
-
-        /* Version 2 of the firmware for Xbox One Series X */
-        if (ctx->last_state[22] != data[22]) {
-            SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_MISC1, (data[22] & 0x01) ? SDL_PRESSED : SDL_RELEASED);
+        /* Xbox Series X firmware version 5.0, report is 36 bytes, share button is in byte 18
+         * Xbox Series X firmware version 5.1, report is 44 bytes, share button is in byte 18
+         * Xbox Series X firmware version 5.5, report is 48 bytes, share button is in byte 22
+         * Victrix Gambit Tournament Controller, report is 50 bytes, share button is in byte 32
+         */
+        if (size < 48) {
+            if (ctx->last_state[18] != data[18]) {
+                SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_MISC1, (data[18] & 0x01) ? SDL_PRESSED : SDL_RELEASED);
+            }
+        } else if (size == 48) {
+            if (ctx->last_state[22] != data[22]) {
+                SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_MISC1, (data[22] & 0x01) ? SDL_PRESSED : SDL_RELEASED);
+            }
+        } else if (size == 50) {
+            if (ctx->last_state[32] != data[32]) {
+                SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_MISC1, (data[32] & 0x01) ? SDL_PRESSED : SDL_RELEASED);
+            }
         }
     }
 
@@ -504,12 +535,16 @@ HIDAPI_DriverXboxOne_HandleStatePacket(SDL_Joystick *joystick, SDL_DriverXboxOne
         Paddle bits:
             P3: 0x01 (A)    P1: 0x02 (B)
             P4: 0x04 (X)    P2: 0x08 (Y)
-       Xbox One Elite Series 2 report is 38 bytes, paddles in data[18], mode in data[19], mode 0 has no mapped paddles by default
+       Xbox One Elite Series 2 4.x firmware report is 38 bytes, paddles in data[18], mode in data[19], mode 0 has no mapped paddles by default
+        Paddle bits:
+            P3: 0x04 (A)    P1: 0x01 (B)
+            P4: 0x08 (X)    P2: 0x02 (Y)
+       Xbox One Elite Series 2 5.x firmware report is 50 bytes, paddles in data[22], mode in data[23], mode 0 has no mapped paddles by default
         Paddle bits:
             P3: 0x04 (A)    P1: 0x01 (B)
             P4: 0x08 (X)    P2: 0x02 (Y)
     */
-    if (ctx->has_paddles && (size == 33 || size == 38)) {
+    if (ctx->has_paddles && (size == 33 || size == 38 || size == 50)) {
         int paddle_index;
         int button1_bit;
         int button2_bit;
@@ -526,9 +561,9 @@ HIDAPI_DriverXboxOne_HandleStatePacket(SDL_Joystick *joystick, SDL_DriverXboxOne
             button4_bit = 0x04;
 
             /* The mapped controller state is at offset 4, the raw state is at offset 18, compare them to see if the paddles are mapped */
-            paddles_mapped = (SDL_memcmp(&data[4], &data[18], 14) != 0);
+            paddles_mapped = (SDL_memcmp(&data[4], &data[18], 2) != 0);
 
-        } else /* if (size == 38) */ {
+        } else if (size == 38) {
             /* XBox One Elite Series 2 */
             paddle_index = 18;
             button1_bit = 0x01;
@@ -536,6 +571,15 @@ HIDAPI_DriverXboxOne_HandleStatePacket(SDL_Joystick *joystick, SDL_DriverXboxOne
             button3_bit = 0x04;
             button4_bit = 0x08;
             paddles_mapped = (data[19] != 0);
+
+        } else /* if (size == 50) */{
+            /* XBox One Elite Series 2 */
+            paddle_index = 22;
+            button1_bit = 0x01;
+            button2_bit = 0x02;
+            button3_bit = 0x04;
+            button4_bit = 0x08;
+            paddles_mapped = (data[23] != 0);
         }
 #ifdef DEBUG_XBOX_PROTOCOL
         SDL_Log(">>> Paddles: %d,%d,%d,%d mapped = %s\n",
@@ -591,6 +635,14 @@ HIDAPI_DriverXboxOne_HandleStatePacket(SDL_Joystick *joystick, SDL_DriverXboxOne
     SDL_memcpy(ctx->last_state, data, SDL_min(size, sizeof(ctx->last_state)));
 }
 
+static void
+HIDAPI_DriverXboxOne_HandleStatusPacket(SDL_Joystick *joystick, SDL_DriverXboxOne_Context *ctx, Uint8 *data, int size)
+{
+    if (ctx->init_state < XBOX_ONE_INIT_STATE_COMPLETE) {
+        SetInitState(ctx, XBOX_ONE_INIT_STATE_COMPLETE);
+    }
+}
+
 static void
 HIDAPI_DriverXboxOne_HandleModePacket(SDL_Joystick *joystick, SDL_DriverXboxOne_Context *ctx, Uint8 *data, int size)
 {
@@ -623,9 +675,11 @@ HIDAPI_DriverXboxOneBluetooth_HandleButtons16(SDL_Joystick *joystick, SDL_Driver
 
 /*
  * Xbox One S with firmware 4.8.1923 uses a 17 byte packet with BACK button in byte 16 and the GUIDE button in a separate packet (on Windows), or in byte 15 (on Linux)
+ * Xbox One S with firmware 5.x uses a 17 byte packet with BACK and GUIDE buttons in byte 15
  * Xbox One Elite Series 2 with firmware 4.7.1872 uses a 55 byte packet with BACK button in byte 16, paddles starting at byte 33, and the GUIDE button in a separate packet
  * Xbox One Elite Series 2 with firmware 4.8.1908 uses a 33 byte packet with BACK button in byte 16, paddles starting at byte 17, and the GUIDE button in a separate packet
- * Xbox One Series X with firmware 5.5.2641 uses a 17 byte packet with BACK and GUIDE buttons in byte 15, and SHARE button in byte 17
+ * Xbox One Elite Series 2 with firmware 5.11.3112 uses a 19 byte packet with BACK and GUIDE buttons in byte 15
+ * Xbox Series X with firmware 5.5.2641 uses a 17 byte packet with BACK and GUIDE buttons in byte 15, and SHARE button in byte 17
  */
 static void
 HIDAPI_DriverXboxOneBluetooth_HandleButtons(SDL_Joystick *joystick, SDL_DriverXboxOne_Context *ctx, Uint8 *data, int size)
@@ -640,10 +694,7 @@ HIDAPI_DriverXboxOneBluetooth_HandleButtons(SDL_Joystick *joystick, SDL_DriverXb
     }
 
     if (ctx->last_state[15] != data[15]) {
-        if (ctx->has_share_button) {
-            SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_BACK, (data[15] & 0x04) ? SDL_PRESSED : SDL_RELEASED);
-            SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_GUIDE, (data[15] & 0x10) ? SDL_PRESSED : SDL_RELEASED);
-        } else if (!ctx->has_guide_packet) {
+        if (!ctx->has_guide_packet) {
             SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_GUIDE, (data[15] & 0x10) ? SDL_PRESSED : SDL_RELEASED);
         }
         SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_START, (data[15] & 0x08) ? SDL_PRESSED : SDL_RELEASED);
@@ -651,12 +702,11 @@ HIDAPI_DriverXboxOneBluetooth_HandleButtons(SDL_Joystick *joystick, SDL_DriverXb
         SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_RIGHTSTICK, (data[15] & 0x40) ? SDL_PRESSED : SDL_RELEASED);
     }
 
-    if (ctx->last_state[16] != data[16]) {
-        if (ctx->has_share_button) {
-            SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_MISC1, (data[16] & 0x01) ? SDL_PRESSED : SDL_RELEASED);
-        } else {
-            SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_BACK, (data[16] & 0x01) ? SDL_PRESSED : SDL_RELEASED);
-        }
+    if (ctx->has_share_button) {
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_BACK, (data[15] & 0x04) ? SDL_PRESSED : SDL_RELEASED);
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_MISC1, (data[16] & 0x01) ? SDL_PRESSED : SDL_RELEASED);
+    } else {
+        SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_BACK, ((data[15] & 0x04) || (data[16] & 0x01)) ? SDL_PRESSED : SDL_RELEASED);
     }
 
     /*
@@ -723,8 +773,13 @@ HIDAPI_DriverXboxOneBluetooth_HandleStatePacket(SDL_Joystick *joystick, SDL_Driv
     if (size == 16) {
         /* Original Xbox One S, with separate report for guide button */
         HIDAPI_DriverXboxOneBluetooth_HandleButtons16(joystick, ctx, data, size);
-    } else {
+    } else if (size > 16) {
         HIDAPI_DriverXboxOneBluetooth_HandleButtons(joystick, ctx, data, size);
+    } else {
+#ifdef DEBUG_XBOX_PROTOCOL
+        SDL_Log("Unknown Bluetooth state packet format\n");
+#endif
+        return;
     }
 
     if (ctx->last_state[13] != data[13]) {
@@ -771,15 +826,6 @@ HIDAPI_DriverXboxOneBluetooth_HandleStatePacket(SDL_Joystick *joystick, SDL_Driv
         SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_DPAD_LEFT, dpad_left);
     }
 
-    axis = (int)*(Uint16*)(&data[1]) - 0x8000;
-    SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_LEFTX, axis);
-    axis = (int)*(Uint16*)(&data[3]) - 0x8000;
-    SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_LEFTY, axis);
-    axis = (int)*(Uint16*)(&data[5]) - 0x8000;
-    SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_RIGHTX, axis);
-    axis = (int)*(Uint16*)(&data[7]) - 0x8000;
-    SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_RIGHTY, axis);
-
     axis = ((int)*(Sint16*)(&data[9]) * 64) - 32768;
     if (axis == 32704) {
         axis = 32767;
@@ -792,6 +838,15 @@ HIDAPI_DriverXboxOneBluetooth_HandleStatePacket(SDL_Joystick *joystick, SDL_Driv
     }
     SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_TRIGGERRIGHT, axis);
 
+    axis = (int)*(Uint16*)(&data[1]) - 0x8000;
+    SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_LEFTX, axis);
+    axis = (int)*(Uint16*)(&data[3]) - 0x8000;
+    SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_LEFTY, axis);
+    axis = (int)*(Uint16*)(&data[5]) - 0x8000;
+    SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_RIGHTX, axis);
+    axis = (int)*(Uint16*)(&data[7]) - 0x8000;
+    SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_RIGHTY, axis);
+
     SDL_memcpy(ctx->last_state, data, SDL_min(size, sizeof(ctx->last_state)));
 }
 
@@ -904,7 +959,7 @@ HIDAPI_DriverXboxOne_UpdateJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joy
     Uint8 data[USB_PACKET_LENGTH];
     int size;
 
-    while ((size = hid_read_timeout(device->dev, data, sizeof(data), 0)) > 0) {
+    while ((size = SDL_hid_read_timeout(device->dev, data, sizeof(data), 0)) > 0) {
 #ifdef DEBUG_XBOX_PROTOCOL
         HIDAPI_DumpPacket("Xbox One packet: size = %d", data, size);
 #endif
@@ -957,16 +1012,18 @@ HIDAPI_DriverXboxOne_UpdateJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joy
                              is firmware version 5.5.2641.0, and product version 0x0505 = 1285
                    then 8 bytes of unknown data
                 */
+                if (data[1] == 0x20) {
 #ifdef DEBUG_JOYSTICK
-                SDL_Log("Controller announce after %u ms\n", (SDL_GetTicks() - ctx->start_time));
+                    SDL_Log("Controller announce after %u ms\n", (SDL_GetTicks() - ctx->start_time));
 #endif
-                SetInitState(ctx, XBOX_ONE_INIT_STATE_START_NEGOTIATING);
+                    SetInitState(ctx, XBOX_ONE_INIT_STATE_START_NEGOTIATING);
+                } else {
+                    /* Possibly an announce from a device plugged into the controller */
+                }
                 break;
             case 0x03:
-                /* Controller heartbeat */
-                if (ctx->init_state < XBOX_ONE_INIT_STATE_COMPLETE) {
-                    SetInitState(ctx, XBOX_ONE_INIT_STATE_COMPLETE);
-                }
+                /* Controller status update */
+                HIDAPI_DriverXboxOne_HandleStatusPacket(joystick, ctx, data, size);
                 break;
             case 0x04:
                 /* Unknown chatty controller information, sent by both sides */
@@ -1054,11 +1111,15 @@ HIDAPI_DriverXboxOne_UpdateDevice(SDL_HIDAPI_Device *device)
 static void
 HIDAPI_DriverXboxOne_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
 {
-    hid_close(device->dev);
-    device->dev = NULL;
+    SDL_LockMutex(device->dev_lock);
+    {
+        SDL_hid_close(device->dev);
+        device->dev = NULL;
 
-    SDL_free(device->context);
-    device->context = NULL;
+        SDL_free(device->context);
+        device->context = NULL;
+    }
+    SDL_UnlockMutex(device->dev_lock);
 }
 
 static void
@@ -1070,6 +1131,7 @@ SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverXboxOne =
 {
     SDL_HINT_JOYSTICK_HIDAPI_XBOX,
     SDL_TRUE,
+    SDL_TRUE,
     HIDAPI_DriverXboxOne_IsSupportedDevice,
     HIDAPI_DriverXboxOne_GetDeviceName,
     HIDAPI_DriverXboxOne_InitDevice,
@@ -1079,8 +1141,9 @@ SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverXboxOne =
     HIDAPI_DriverXboxOne_OpenJoystick,
     HIDAPI_DriverXboxOne_RumbleJoystick,
     HIDAPI_DriverXboxOne_RumbleJoystickTriggers,
-    HIDAPI_DriverXboxOne_HasJoystickLED,
+    HIDAPI_DriverXboxOne_GetJoystickCapabilities,
     HIDAPI_DriverXboxOne_SetJoystickLED,
+    HIDAPI_DriverXboxOne_SendJoystickEffect,
     HIDAPI_DriverXboxOne_SetJoystickSensorsEnabled,
     HIDAPI_DriverXboxOne_CloseJoystick,
     HIDAPI_DriverXboxOne_FreeDevice,
diff --git a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapijoystick.c b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapijoystick.c
index a6a1c3d87..55d9a1353 100644
--- a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapijoystick.c
+++ b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapijoystick.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -25,7 +25,6 @@
 #include "SDL_atomic.h"
 #include "SDL_endian.h"
 #include "SDL_hints.h"
-#include "SDL_thread.h"
 #include "SDL_timer.h"
 #include "SDL_joystick.h"
 #include "../SDL_sysjoystick.h"
@@ -34,24 +33,9 @@
 #include "../../SDL_hints_c.h"
 
 #if defined(__WIN32__)
-#include "../../core/windows/SDL_windows.h"
 #include "../windows/SDL_rawinputjoystick_c.h"
 #endif
 
-#if defined(__MACOSX__)
-#include <CoreFoundation/CoreFoundation.h>
-#include <mach/mach.h>
-#include <IOKit/IOKitLib.h>
-#include <IOKit/hid/IOHIDDevice.h>
-#include <IOKit/usb/USBSpec.h>
-#endif
-
-#if defined(__LINUX__)
-#include "../../core/linux/SDL_udev.h"
-#ifdef SDL_USE_LIBUDEV
-#include <poll.h>
-#endif
-#endif
 
 struct joystick_hwdata
 {
@@ -59,12 +43,21 @@ struct joystick_hwdata
 };
 
 static SDL_HIDAPI_DeviceDriver *SDL_HIDAPI_drivers[] = {
+#ifdef SDL_JOYSTICK_HIDAPI_GAMECUBE
+    &SDL_HIDAPI_DriverGameCube,
+#endif
+#ifdef SDL_JOYSTICK_HIDAPI_LUNA
+    &SDL_HIDAPI_DriverLuna,
+#endif
 #ifdef SDL_JOYSTICK_HIDAPI_PS4
     &SDL_HIDAPI_DriverPS4,
 #endif
 #ifdef SDL_JOYSTICK_HIDAPI_PS5
     &SDL_HIDAPI_DriverPS5,
 #endif
+#ifdef SDL_JOYSTICK_HIDAPI_STADIA
+    &SDL_HIDAPI_DriverStadia,
+#endif
 #ifdef SDL_JOYSTICK_HIDAPI_STEAM
     &SDL_HIDAPI_DriverSteam,
 #endif
@@ -78,317 +71,15 @@ static SDL_HIDAPI_DeviceDriver *SDL_HIDAPI_drivers[] = {
 #ifdef SDL_JOYSTICK_HIDAPI_XBOXONE
     &SDL_HIDAPI_DriverXboxOne,
 #endif
-#ifdef SDL_JOYSTICK_HIDAPI_GAMECUBE
-    &SDL_HIDAPI_DriverGameCube,
-#endif
 };
 static int SDL_HIDAPI_numdrivers = 0;
 static SDL_SpinLock SDL_HIDAPI_spinlock;
+static Uint32 SDL_HIDAPI_change_count = 0;
 static SDL_HIDAPI_Device *SDL_HIDAPI_devices;
 static int SDL_HIDAPI_numjoysticks = 0;
 static SDL_bool initialized = SDL_FALSE;
 static SDL_bool shutting_down = SDL_FALSE;
 
-#if defined(SDL_USE_LIBUDEV)
-static const SDL_UDEV_Symbols * usyms = NULL;
-#endif
-
-static struct
-{
-    SDL_bool m_bHaveDevicesChanged;
-    SDL_bool m_bCanGetNotifications;
-    Uint32 m_unLastDetect;
-
-#if defined(__WIN32__)
-    SDL_threadID m_nThreadID;
-    WNDCLASSEXA m_wndClass;
-    HWND m_hwndMsg;
-    HDEVNOTIFY m_hNotify;
-    double m_flLastWin32MessageCheck;
-#endif
-
-#if defined(__MACOSX__)
-    IONotificationPortRef m_notificationPort;
-    mach_port_t m_notificationMach;
-#endif
-
-#if defined(SDL_USE_LIBUDEV)
-    struct udev *m_pUdev;
-    struct udev_monitor *m_pUdevMonitor;
-    int m_nUdevFd;
-#endif
-} SDL_HIDAPI_discovery;
-
-
-#ifdef __WIN32__
-struct _DEV_BROADCAST_HDR
-{
-    DWORD       dbch_size;
-    DWORD       dbch_devicetype;
-    DWORD       dbch_reserved;
-};
-
-typedef struct _DEV_BROADCAST_DEVICEINTERFACE_A
-{
-    DWORD       dbcc_size;
-    DWORD       dbcc_devicetype;
-    DWORD       dbcc_reserved;
-    GUID        dbcc_classguid;
-    char        dbcc_name[ 1 ];
-} DEV_BROADCAST_DEVICEINTERFACE_A, *PDEV_BROADCAST_DEVICEINTERFACE_A;
-
-typedef struct  _DEV_BROADCAST_HDR      DEV_BROADCAST_HDR;
-#define DBT_DEVICEARRIVAL               0x8000  /* system detected a new device */
-#define DBT_DEVICEREMOVECOMPLETE        0x8004  /* device was removed from the system */
-#define DBT_DEVTYP_DEVICEINTERFACE      0x00000005  /* device interface class */
-#define DBT_DEVNODES_CHANGED            0x0007
-#define DBT_CONFIGCHANGED               0x0018
-#define DBT_DEVICETYPESPECIFIC          0x8005  /* type specific event */
-#define DBT_DEVINSTSTARTED              0x8008  /* device installed and started */
-
-#include <initguid.h>
-DEFINE_GUID(GUID_DEVINTERFACE_USB_DEVICE, 0xA5DCBF10L, 0x6530, 0x11D2, 0x90, 0x1F, 0x00, 0xC0, 0x4F, 0xB9, 0x51, 0xED);
-
-static LRESULT CALLBACK ControllerWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
-{
-    switch (message) {
-    case WM_DEVICECHANGE:
-        switch (wParam) {
-        case DBT_DEVICEARRIVAL:
-        case DBT_DEVICEREMOVECOMPLETE:
-            if (((DEV_BROADCAST_HDR*)lParam)->dbch_devicetype == DBT_DEVTYP_DEVICEINTERFACE) {
-                SDL_HIDAPI_discovery.m_bHaveDevicesChanged = SDL_TRUE;
-            }
-            break;
-        }
-        return TRUE;
-    }
-
-    return DefWindowProc(hwnd, message, wParam, lParam);
-}
-#endif /* __WIN32__ */
-
-
-#if defined(__MACOSX__)
-static void CallbackIOServiceFunc(void *context, io_iterator_t portIterator)
-{
-    /* Must drain the iterator, or we won't receive new notifications */
-    io_object_t entry;
-    while ((entry = IOIteratorNext(portIterator)) != 0) {
-        IOObjectRelease(entry);
-        *(SDL_bool*)context = SDL_TRUE;
-    }
-}
-#endif /* __MACOSX__ */
-
-static void
-HIDAPI_InitializeDiscovery()
-{
-    SDL_HIDAPI_discovery.m_bHaveDevicesChanged = SDL_TRUE;
-    SDL_HIDAPI_discovery.m_bCanGetNotifications = SDL_FALSE;
-    SDL_HIDAPI_discovery.m_unLastDetect = 0;
-
-#if defined(__WIN32__)
-    SDL_HIDAPI_discovery.m_nThreadID = SDL_ThreadID();
-
-    SDL_zero(SDL_HIDAPI_discovery.m_wndClass);
-    SDL_HIDAPI_discovery.m_wndClass.hInstance = GetModuleHandle(NULL);
-    SDL_HIDAPI_discovery.m_wndClass.lpszClassName = "SDL_HIDAPI_DEVICE_DETECTION";
-    SDL_HIDAPI_discovery.m_wndClass.lpfnWndProc = ControllerWndProc;      /* This function is called by windows */
-    SDL_HIDAPI_discovery.m_wndClass.cbSize = sizeof(WNDCLASSEX);
-
-    RegisterClassExA(&SDL_HIDAPI_discovery.m_wndClass);
-    SDL_HIDAPI_discovery.m_hwndMsg = CreateWindowExA(0, "SDL_HIDAPI_DEVICE_DETECTION", NULL, 0, 0, 0, 0, 0, HWND_MESSAGE, NULL, NULL, NULL);
-
-    {
-        DEV_BROADCAST_DEVICEINTERFACE_A devBroadcast;
-
-        SDL_zero(devBroadcast);
-        devBroadcast.dbcc_size = sizeof( devBroadcast );
-        devBroadcast.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
-        devBroadcast.dbcc_classguid = GUID_DEVINTERFACE_USB_DEVICE;
-
-        /* DEVICE_NOTIFY_ALL_INTERFACE_CLASSES is important, makes GUID_DEVINTERFACE_USB_DEVICE ignored,
-         * but that seems to be necessary to get a notice after each individual usb input device actually
-         * installs, rather than just as the composite device is seen.
-         */
-        SDL_HIDAPI_discovery.m_hNotify = RegisterDeviceNotification( SDL_HIDAPI_discovery.m_hwndMsg, &devBroadcast, DEVICE_NOTIFY_WINDOW_HANDLE | DEVICE_NOTIFY_ALL_INTERFACE_CLASSES );
-        SDL_HIDAPI_discovery.m_bCanGetNotifications = ( SDL_HIDAPI_discovery.m_hNotify != 0 );
-    }
-#endif /* __WIN32__ */
-
-#if defined(__MACOSX__)
-    SDL_HIDAPI_discovery.m_notificationPort = IONotificationPortCreate(kIOMasterPortDefault);
-    if (SDL_HIDAPI_discovery.m_notificationPort) {
-        {
-            io_iterator_t portIterator = 0;
-            io_object_t entry;
-            IOReturn result = IOServiceAddMatchingNotification(
-                SDL_HIDAPI_discovery.m_notificationPort,
-                kIOFirstMatchNotification,
-                IOServiceMatching(kIOHIDDeviceKey),
-                CallbackIOServiceFunc, &SDL_HIDAPI_discovery.m_bHaveDevicesChanged, &portIterator);
-
-            if (result == 0) {
-                /* Must drain the existing iterator, or we won't receive new notifications */
-                while ((entry = IOIteratorNext(portIterator)) != 0) {
-                    IOObjectRelease(entry);
-                }
-            } else {
-                IONotificationPortDestroy(SDL_HIDAPI_discovery.m_notificationPort);
-                SDL_HIDAPI_discovery.m_notificationPort = nil;
-            }
-        }
-        {
-            io_iterator_t portIterator = 0;
-            io_object_t entry;
-            IOReturn result = IOServiceAddMatchingNotification(
-                SDL_HIDAPI_discovery.m_notificationPort,
-                kIOTerminatedNotification,
-                IOServiceMatching(kIOHIDDeviceKey),
-                CallbackIOServiceFunc, &SDL_HIDAPI_discovery.m_bHaveDevicesChanged, &portIterator);
-
-            if (result == 0) {
-                /* Must drain the existing iterator, or we won't receive new notifications */
-                while ((entry = IOIteratorNext(portIterator)) != 0) {
-                    IOObjectRelease(entry);
-                }
-            } else {
-                IONotificationPortDestroy(SDL_HIDAPI_discovery.m_notificationPort);
-                SDL_HIDAPI_discovery.m_notificationPort = nil;
-            }
-        }
-    }
-
-    SDL_HIDAPI_discovery.m_notificationMach = MACH_PORT_NULL;
-    if (SDL_HIDAPI_discovery.m_notificationPort) {
-        SDL_HIDAPI_discovery.m_notificationMach = IONotificationPortGetMachPort(SDL_HIDAPI_discovery.m_notificationPort);
-    }
-
-    SDL_HIDAPI_discovery.m_bCanGetNotifications = (SDL_HIDAPI_discovery.m_notificationMach != MACH_PORT_NULL);
-
-#endif // __MACOSX__
-
-#if defined(SDL_USE_LIBUDEV)
-    SDL_HIDAPI_discovery.m_pUdev = NULL;
-    SDL_HIDAPI_discovery.m_pUdevMonitor = NULL;
-    SDL_HIDAPI_discovery.m_nUdevFd = -1;
-
-    usyms = SDL_UDEV_GetUdevSyms();
-    if (usyms) {
-        SDL_HIDAPI_discovery.m_pUdev = usyms->udev_new();
-    }
-    if (SDL_HIDAPI_discovery.m_pUdev) {
-        SDL_HIDAPI_discovery.m_pUdevMonitor = usyms->udev_monitor_new_from_netlink(SDL_HIDAPI_discovery.m_pUdev, "udev");
-        if (SDL_HIDAPI_discovery.m_pUdevMonitor) {
-            usyms->udev_monitor_enable_receiving(SDL_HIDAPI_discovery.m_pUdevMonitor);
-            SDL_HIDAPI_discovery.m_nUdevFd = usyms->udev_monitor_get_fd(SDL_HIDAPI_discovery.m_pUdevMonitor);
-            SDL_HIDAPI_discovery.m_bCanGetNotifications = SDL_TRUE;
-        }
-    }
-
-#endif /* SDL_USE_LIBUDEV */
-}
-
-static void
-HIDAPI_UpdateDiscovery()
-{
-    if (!SDL_HIDAPI_discovery.m_bCanGetNotifications) {
-        const Uint32 SDL_HIDAPI_DETECT_INTERVAL_MS = 3000;  /* Update every 3 seconds */
-        Uint32 now = SDL_GetTicks();
-        if (!SDL_HIDAPI_discovery.m_unLastDetect || SDL_TICKS_PASSED(now, SDL_HIDAPI_discovery.m_unLastDetect + SDL_HIDAPI_DETECT_INTERVAL_MS)) {
-            SDL_HIDAPI_discovery.m_bHaveDevicesChanged = SDL_TRUE;
-            SDL_HIDAPI_discovery.m_unLastDetect = now;
-        }
-        return;
-    }
-
-#if defined(__WIN32__)
-#if 0 /* just let the usual SDL_PumpEvents loop dispatch these, fixing bug 4286. --ryan. */
-    /* We'll only get messages on the same thread that created the window */
-    if (SDL_ThreadID() == SDL_HIDAPI_discovery.m_nThreadID) {
-        MSG msg;
-        while (PeekMessage(&msg, SDL_HIDAPI_discovery.m_hwndMsg, 0, 0, PM_NOREMOVE)) {
-            if (GetMessageA(&msg, SDL_HIDAPI_discovery.m_hwndMsg, 0, 0) != 0) {
-                TranslateMessage(&msg);
-                DispatchMessage(&msg);
-            }
-        }
-    }
-#endif
-#endif /* __WIN32__ */
-
-#if defined(__MACOSX__)
-    if (SDL_HIDAPI_discovery.m_notificationPort) {
-        struct { mach_msg_header_t hdr; char payload[ 4096 ]; } msg;
-        while (mach_msg(&msg.hdr, MACH_RCV_MSG | MACH_RCV_TIMEOUT, 0, sizeof(msg), SDL_HIDAPI_discovery.m_notificationMach, 0, MACH_PORT_NULL) == KERN_SUCCESS) {
-            IODispatchCalloutFromMessage(NULL, &msg.hdr, SDL_HIDAPI_discovery.m_notificationPort);
-        }
-    }
-#endif
-
-#if defined(SDL_USE_LIBUDEV)
-    if (SDL_HIDAPI_discovery.m_nUdevFd >= 0) {
-        /* Drain all notification events.
-         * We don't expect a lot of device notifications so just
-         * do a new discovery on any kind or number of notifications.
-         * This could be made more restrictive if necessary.
-         */
-        for (;;) {
-            struct pollfd PollUdev;
-            struct udev_device *pUdevDevice;
-
-            PollUdev.fd = SDL_HIDAPI_discovery.m_nUdevFd;
-            PollUdev.events = POLLIN;
-            if (poll(&PollUdev, 1, 0) != 1) {
-                break;
-            }
-
-            SDL_HIDAPI_discovery.m_bHaveDevicesChanged = SDL_TRUE;
-
-            pUdevDevice = usyms->udev_monitor_receive_device(SDL_HIDAPI_discovery.m_pUdevMonitor);
-            if (pUdevDevice) {
-                usyms->udev_device_unref(pUdevDevice);
-            }
-        }
-    }
-#endif
-}
-
-static void
-HIDAPI_ShutdownDiscovery()
-{
-#if defined(__WIN32__)
-    if (SDL_HIDAPI_discovery.m_hNotify)
-        UnregisterDeviceNotification(SDL_HIDAPI_discovery.m_hNotify);
-
-    if (SDL_HIDAPI_discovery.m_hwndMsg) {
-        DestroyWindow(SDL_HIDAPI_discovery.m_hwndMsg);
-    }
-
-    UnregisterClassA(SDL_HIDAPI_discovery.m_wndClass.lpszClassName, SDL_HIDAPI_discovery.m_wndClass.hInstance);
-#endif
-
-#if defined(__MACOSX__)
-    if (SDL_HIDAPI_discovery.m_notificationPort) {
-        IONotificationPortDestroy(SDL_HIDAPI_discovery.m_notificationPort);
-    }
-#endif
-
-#if defined(SDL_USE_LIBUDEV)
-    if (usyms) {
-        if (SDL_HIDAPI_discovery.m_pUdevMonitor) {
-            usyms->udev_monitor_unref(SDL_HIDAPI_discovery.m_pUdevMonitor);
-        }
-        if (SDL_HIDAPI_discovery.m_pUdev) {
-            usyms->udev_unref(SDL_HIDAPI_discovery.m_pUdev);
-        }
-        SDL_UDEV_ReleaseUdevSyms();
-        usyms = NULL;
-    }
-#endif
-}
-
 void
 HIDAPI_DumpPacket(const char *prefix, Uint8 *data, int size)
 {
@@ -410,8 +101,14 @@ HIDAPI_DumpPacket(const char *prefix, Uint8 *data, int size)
     SDL_free(buffer);
 }
 
+float
+HIDAPI_RemapVal(float val, float val_min, float val_max, float output_min, float output_max)
+{
+    return output_min + (output_max - output_min) * (val - val_min) / (val_max - val_min);
+}
+
 static void HIDAPI_JoystickDetect(void);
-static void HIDAPI_JoystickClose(SDL_Joystick * joystick);
+static void HIDAPI_JoystickClose(SDL_Joystick *joystick);
 
 static SDL_bool
 HIDAPI_IsDeviceSupported(Uint16 vendor_id, Uint16 product_id, Uint16 version, const char *name)
@@ -437,8 +134,14 @@ HIDAPI_GetDeviceDriver(SDL_HIDAPI_Device *device)
     const Uint16 USAGE_MULTIAXISCONTROLLER = 0x0008;
     int i;
     SDL_GameControllerType type;
+    SDL_JoystickGUID check_guid;
 
-    if (SDL_ShouldIgnoreJoystick(device->name, device->guid)) {
+    /* Make sure we have a generic GUID here, otherwise if we pass a HIDAPI
+       guid, this call will create a game controller mapping for the device.
+     */
+    check_guid = device->guid;
+    check_guid.data[14] = 0;
+    if (SDL_ShouldIgnoreJoystick(device->name, check_guid)) {
         return NULL;
     }
 
@@ -498,8 +201,7 @@ static void
 HIDAPI_SetupDeviceDriver(SDL_HIDAPI_Device *device)
 {
     if (device->driver) {
-        /* Already setup */
-        return;
+        return; /* Already setup */
     }
 
     device->driver = HIDAPI_GetDeviceDriver(device);
@@ -521,8 +223,7 @@ static void
 HIDAPI_CleanupDeviceDriver(SDL_HIDAPI_Device *device)
 {
     if (!device->driver) {
-        /* Already cleaned up */
-        return;
+        return; /* Already cleaned up */
     }
 
     /* Disconnect any joysticks */
@@ -585,19 +286,30 @@ HIDAPI_JoystickInit(void)
         return 0;
     }
 
-#if defined(__MACOSX__) || defined(__IPHONEOS__) || defined(__TVOS__)
-    /* The hidapi framwork is weak-linked on Apple platforms */
-    int HID_API_EXPORT HID_API_CALL hid_init(void) __attribute__((weak_import));
-
-    if (hid_init == NULL) {
-        SDL_SetError("Couldn't initialize hidapi, framework not available");
-        return -1;
+#if defined(SDL_USE_LIBUDEV)
+    if (linux_enumeration_method == ENUMERATION_UNSET) {
+        if (SDL_getenv("SDL_HIDAPI_JOYSTICK_DISABLE_UDEV") != NULL) {
+            SDL_LogDebug(SDL_LOG_CATEGORY_INPUT,
+                         "udev disabled by SDL_HIDAPI_JOYSTICK_DISABLE_UDEV");
+            linux_enumeration_method = ENUMERATION_FALLBACK;
+        } else if (access("/.flatpak-info", F_OK) == 0
+                   || access("/run/host/container-manager", F_OK) == 0) {
+            /* Explicitly check `/.flatpak-info` because, for old versions of
+             * Flatpak, this was the only available way to tell if we were in
+             * a Flatpak container. */
+            SDL_LogDebug(SDL_LOG_CATEGORY_INPUT,
+                         "Container detected, disabling HIDAPI udev integration");
+            linux_enumeration_method = ENUMERATION_FALLBACK;
+        } else {
+            SDL_LogDebug(SDL_LOG_CATEGORY_INPUT,
+                         "Using udev for HIDAPI joystick device discovery");
+            linux_enumeration_method = ENUMERATION_LIBUDEV;
+        }
     }
-#endif /* __MACOSX__ || __IPHONEOS__ || __TVOS__ */
+#endif
 
-    if (hid_init() < 0) {
-        SDL_SetError("Couldn't initialize hidapi");
-        return -1;
+    if (SDL_hid_init() < 0) {
+        return SDL_SetError("Couldn't initialize hidapi");
     }
 
     for (i = 0; i < SDL_arraysize(SDL_HIDAPI_drivers); ++i) {
@@ -606,7 +318,6 @@ HIDAPI_JoystickInit(void)
     }
     SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI,
                         SDL_HIDAPIDriverHintChanged, NULL);
-    HIDAPI_InitializeDiscovery();
     HIDAPI_JoystickDetect();
     HIDAPI_UpdateDevices();
 
@@ -681,10 +392,13 @@ HIDAPI_ConvertString(const wchar_t *wide_string)
     if (wide_string) {
         string = SDL_iconv_string("UTF-8", "WCHAR_T", (char*)wide_string, (SDL_wcslen(wide_string)+1)*sizeof(wchar_t));
         if (!string) {
-            if (sizeof(wchar_t) == sizeof(Uint16)) {
+            switch (sizeof(wchar_t)) {
+            case 2:
                 string = SDL_iconv_string("UTF-8", "UCS-2-INTERNAL", (char*)wide_string, (SDL_wcslen(wide_string)+1)*sizeof(wchar_t));
-            } else if (sizeof(wchar_t) == sizeof(Uint32)) {
+                break;
+            case 4:
                 string = SDL_iconv_string("UTF-8", "UCS-4-INTERNAL", (char*)wide_string, (SDL_wcslen(wide_string)+1)*sizeof(wchar_t));
+                break;
             }
         }
     }
@@ -692,7 +406,7 @@ HIDAPI_ConvertString(const wchar_t *wide_string)
 }
 
 static void
-HIDAPI_AddDevice(struct hid_device_info *info)
+HIDAPI_AddDevice(struct SDL_hid_device_info *info)
 {
     SDL_HIDAPI_Device *device;
     SDL_HIDAPI_Device *curr, *last = NULL;
@@ -856,7 +570,7 @@ static void
 HIDAPI_UpdateDeviceList(void)
 {
     SDL_HIDAPI_Device *device;
-    struct hid_device_info *devs, *info;
+    struct SDL_hid_device_info *devs, *info;
 
     SDL_LockJoysticks();
 
@@ -869,7 +583,7 @@ HIDAPI_UpdateDeviceList(void)
 
     /* Enumerate the devices */
     if (SDL_HIDAPI_numdrivers > 0) {
-        devs = hid_enumerate(0, 0);
+        devs = SDL_hid_enumerate(0, 0);
         if (devs) {
             for (info = devs; info; info = info->next) {
                 device = HIDAPI_GetJoystickByInfo(info->path, info->vendor_id, info->product_id);
@@ -879,16 +593,17 @@ HIDAPI_UpdateDeviceList(void)
                     HIDAPI_AddDevice(info);
                 }
             }
-            hid_free_enumeration(devs);
+            SDL_hid_free_enumeration(devs);
         }
     }
 
-    /* Remove any devices that weren't seen */
+    /* Remove any devices that weren't seen or have been disconnected due to read errors */
     device = SDL_HIDAPI_devices;
     while (device) {
         SDL_HIDAPI_Device *next = device->next;
 
-        if (!device->seen) {
+        if (!device->seen ||
+            (device->driver && device->num_joysticks == 0 && !device->dev)) {
             HIDAPI_DelDevice(device);
         }
         device = next;
@@ -906,12 +621,12 @@ HIDAPI_IsEquivalentToDevice(Uint16 vendor_id, Uint16 product_id, SDL_HIDAPI_Devi
 
     if (vendor_id == USB_VENDOR_MICROSOFT) {
         /* If we're looking for the wireless XBox 360 controller, also look for the dongle */
-        if (product_id == 0x02a1 && device->product_id == 0x0719) {
+        if (product_id == USB_PRODUCT_XBOX360_XUSB_CONTROLLER && device->product_id == USB_PRODUCT_XBOX360_WIRELESS_RECEIVER) {
             return SDL_TRUE;
         }
 
         /* If we're looking for the raw input Xbox One controller, match it against any other Xbox One controller */
-        if (product_id == USB_PRODUCT_XBOX_ONE_RAW_INPUT_CONTROLLER &&
+        if (product_id == USB_PRODUCT_XBOX_ONE_XBOXGIP_CONTROLLER &&
             SDL_GetJoystickGameControllerType(device->name, device->vendor_id, device->product_id, device->interface_number, device->interface_class, device->interface_subclass, device->interface_protocol) == SDL_CONTROLLER_TYPE_XBOXONE) {
             return SDL_TRUE;
         }
@@ -927,6 +642,40 @@ HIDAPI_IsEquivalentToDevice(Uint16 vendor_id, Uint16 product_id, SDL_HIDAPI_Devi
     return SDL_FALSE;
 }
 
+SDL_bool
+HIDAPI_IsDeviceTypePresent(SDL_GameControllerType type)
+{
+    SDL_HIDAPI_Device *device;
+    SDL_bool result = SDL_FALSE;
+
+    /* Make sure we're initialized, as this could be called from other drivers during startup */
+    if (HIDAPI_JoystickInit() < 0) {
+        return SDL_FALSE;
+    }
+
+    if (SDL_AtomicTryLock(&SDL_HIDAPI_spinlock)) {
+        HIDAPI_UpdateDeviceList();
+        SDL_AtomicUnlock(&SDL_HIDAPI_spinlock);
+    }
+
+    SDL_LockJoysticks();
+    device = SDL_HIDAPI_devices;
+    while (device) {
+        if (device->driver &&
+            SDL_GetJoystickGameControllerType(device->name, device->vendor_id, device->product_id, device->interface_number, device->interface_class, device->interface_subclass, device->interface_protocol) == type) {
+            result = SDL_TRUE;
+            break;
+        }
+        device = device->next;
+    }
+    SDL_UnlockJoysticks();
+
+#ifdef DEBUG_HIDAPI
+    SDL_Log("HIDAPI_IsDeviceTypePresent() returning %s for %d\n", result ? "true" : "false", type);
+#endif
+    return result;
+}
+
 SDL_bool
 HIDAPI_IsDevicePresent(Uint16 vendor_id, Uint16 product_id, Uint16 version, const char *name)
 {
@@ -969,6 +718,7 @@ HIDAPI_IsDevicePresent(Uint16 vendor_id, Uint16 product_id, Uint16 version, cons
         if (device->driver &&
             HIDAPI_IsEquivalentToDevice(vendor_id, product_id, device)) {
             result = SDL_TRUE;
+            break;
         }
         device = device->next;
     }
@@ -984,11 +734,10 @@ static void
 HIDAPI_JoystickDetect(void)
 {
     if (SDL_AtomicTryLock(&SDL_HIDAPI_spinlock)) {
-        HIDAPI_UpdateDiscovery();
-        if (SDL_HIDAPI_discovery.m_bHaveDevicesChanged) {
-            /* FIXME: We probably need to schedule an update in a few seconds as well */
+        Uint32 count = SDL_hid_device_change_count();
+        if (SDL_HIDAPI_change_count != count) {
             HIDAPI_UpdateDeviceList();
-            SDL_HIDAPI_discovery.m_bHaveDevicesChanged = SDL_FALSE;
+            SDL_HIDAPI_change_count = count;
         }
         SDL_AtomicUnlock(&SDL_HIDAPI_spinlock);
     }
@@ -1086,7 +835,7 @@ HIDAPI_JoystickGetDeviceInstanceID(int device_index)
 }
 
 static int
-HIDAPI_JoystickOpen(SDL_Joystick * joystick, int device_index)
+HIDAPI_JoystickOpen(SDL_Joystick *joystick, int device_index)
 {
     SDL_JoystickID joystickID;
     SDL_HIDAPI_Device *device = HIDAPI_GetDeviceByIndex(device_index, &joystickID);
@@ -1112,7 +861,7 @@ HIDAPI_JoystickOpen(SDL_Joystick * joystick, int device_index)
 }
 
 static int
-HIDAPI_JoystickRumble(SDL_Joystick * joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+HIDAPI_JoystickRumble(SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
 {
     int result;
 
@@ -1121,15 +870,14 @@ HIDAPI_JoystickRumble(SDL_Joystick * joystick, Uint16 low_frequency_rumble, Uint
 
         result = device->driver->RumbleJoystick(device, joystick, low_frequency_rumble, high_frequency_rumble);
     } else {
-        SDL_SetError("Rumble failed, device disconnected");
-        result = -1;
+        result = SDL_SetError("Rumble failed, device disconnected");
     }
 
     return result;
 }
 
 static int
-HIDAPI_JoystickRumbleTriggers(SDL_Joystick * joystick, Uint16 left_rumble, Uint16 right_rumble)
+HIDAPI_JoystickRumbleTriggers(SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
 {
     int result;
 
@@ -1138,29 +886,28 @@ HIDAPI_JoystickRumbleTriggers(SDL_Joystick * joystick, Uint16 left_rumble, Uint1
 
         result = device->driver->RumbleJoystickTriggers(device, joystick, left_rumble, right_rumble);
     } else {
-        SDL_SetError("Rumble failed, device disconnected");
-        result = -1;
+        result = SDL_SetError("Rumble failed, device disconnected");
     }
 
     return result;
 }
 
-static SDL_bool
-HIDAPI_JoystickHasLED(SDL_Joystick * joystick)
+static Uint32
+HIDAPI_JoystickGetCapabilities(SDL_Joystick *joystick)
 {
-    SDL_bool result = SDL_FALSE;
+    Uint32 result = 0;
 
     if (joystick->hwdata) {
         SDL_HIDAPI_Device *device = joystick->hwdata->device;
 
-        result = device->driver->HasJoystickLED(device, joystick);
+        result = device->driver->GetJoystickCapabilities(device, joystick);
     }
 
     return result;
 }
 
 static int
-HIDAPI_JoystickSetLED(SDL_Joystick * joystick, Uint8 red, Uint8 green, Uint8 blue)
+HIDAPI_JoystickSetLED(SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
 {
     int result;
 
@@ -1169,15 +916,30 @@ HIDAPI_JoystickSetLED(SDL_Joystick * joystick, Uint8 red, Uint8 green, Uint8 blu
 
         result = device->driver->SetJoystickLED(device, joystick, red, green, blue);
     } else {
-        SDL_SetError("SetLED failed, device disconnected");
-        result = -1;
+        result = SDL_SetError("SetLED failed, device disconnected");
     }
 
     return result;
 }
 
 static int
-HIDAPI_JoystickSetSensorsEnabled(SDL_Joystick * joystick, SDL_bool enabled)
+HIDAPI_JoystickSendEffect(SDL_Joystick *joystick, const void *data, int size)
+{
+    int result;
+
+    if (joystick->hwdata) {
+        SDL_HIDAPI_Device *device = joystick->hwdata->device;
+
+        result = device->driver->SendJoystickEffect(device, joystick, data, size);
+    } else {
+        result = SDL_SetError("SendEffect failed, device disconnected");
+    }
+
+    return result;
+}
+
+static int
+HIDAPI_JoystickSetSensorsEnabled(SDL_Joystick *joystick, SDL_bool enabled)
 {
     int result;
 
@@ -1186,21 +948,20 @@ HIDAPI_JoystickSetSensorsEnabled(SDL_Joystick * joystick, SDL_bool enabled)
 
         result = device->driver->SetJoystickSensorsEnabled(device, joystick, enabled);
     } else {
-        SDL_SetError("SetSensorsEnabled failed, device disconnected");
-        result = -1;
+        result = SDL_SetError("SetSensorsEnabled failed, device disconnected");
     }
 
     return result;
 }
 
 static void
-HIDAPI_JoystickUpdate(SDL_Joystick * joystick)
+HIDAPI_JoystickUpdate(SDL_Joystick *joystick)
 {
     /* This is handled in SDL_HIDAPI_UpdateDevices() */
 }
 
 static void
-HIDAPI_JoystickClose(SDL_Joystick * joystick)
+HIDAPI_JoystickClose(SDL_Joystick *joystick)
 {
     if (joystick->hwdata) {
         SDL_HIDAPI_Device *device = joystick->hwdata->device;
@@ -1235,8 +996,6 @@ HIDAPI_JoystickQuit(void)
 
     shutting_down = SDL_TRUE;
 
-    HIDAPI_ShutdownDiscovery();
-
     SDL_HIDAPI_QuitRumble();
 
     while (SDL_HIDAPI_devices) {
@@ -1253,7 +1012,7 @@ HIDAPI_JoystickQuit(void)
     SDL_DelHintCallback(SDL_HINT_JOYSTICK_HIDAPI,
                         SDL_HIDAPIDriverHintChanged, NULL);
 
-    hid_exit();
+    SDL_hid_exit();
 
     shutting_down = SDL_FALSE;
     initialized = SDL_FALSE;
@@ -1278,8 +1037,9 @@ SDL_JoystickDriver SDL_HIDAPI_JoystickDriver =
     HIDAPI_JoystickOpen,
     HIDAPI_JoystickRumble,
     HIDAPI_JoystickRumbleTriggers,
-    HIDAPI_JoystickHasLED,
+    HIDAPI_JoystickGetCapabilities,
     HIDAPI_JoystickSetLED,
+    HIDAPI_JoystickSendEffect,
     HIDAPI_JoystickSetSensorsEnabled,
     HIDAPI_JoystickUpdate,
     HIDAPI_JoystickClose,
diff --git a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapijoystick_c.h b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapijoystick_c.h
index 5af5b08c0..c1b75d8db 100644
--- a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapijoystick_c.h
+++ b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapijoystick_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -27,16 +27,18 @@
 #include "SDL_mutex.h"
 #include "SDL_joystick.h"
 #include "SDL_gamecontroller.h"
-#include "../../hidapi/hidapi/hidapi.h"
+#include "SDL_hidapi.h"
 #include "../usb_ids.h"
 
 /* This is the full set of HIDAPI drivers available */
+#define SDL_JOYSTICK_HIDAPI_GAMECUBE
+#define SDL_JOYSTICK_HIDAPI_LUNA
 #define SDL_JOYSTICK_HIDAPI_PS4
 #define SDL_JOYSTICK_HIDAPI_PS5
+#define SDL_JOYSTICK_HIDAPI_STADIA
 #define SDL_JOYSTICK_HIDAPI_SWITCH
 #define SDL_JOYSTICK_HIDAPI_XBOX360
 #define SDL_JOYSTICK_HIDAPI_XBOXONE
-#define SDL_JOYSTICK_HIDAPI_GAMECUBE
 
 #if defined(__IPHONEOS__) || defined(__TVOS__) || defined(__ANDROID__)
 /* Very basic Steam Controller support on mobile devices */
@@ -68,7 +70,7 @@ typedef struct _SDL_HIDAPI_Device
     struct _SDL_HIDAPI_DeviceDriver *driver;
     void *context;
     SDL_mutex *dev_lock;
-    hid_device *dev;
+    SDL_hid_device *dev;
     SDL_atomic_t rumble_pending;
     int num_joysticks;
     SDL_JoystickID *joysticks;
@@ -86,6 +88,7 @@ typedef struct _SDL_HIDAPI_DeviceDriver
 {
     const char *hint;
     SDL_bool enabled;
+    SDL_bool enabled_default;
     SDL_bool (*IsSupportedDevice)(const char *name, SDL_GameControllerType type, Uint16 vendor_id, Uint16 product_id, Uint16 version, int interface_number, int interface_class, int interface_subclass, int interface_protocol);
     const char *(*GetDeviceName)(Uint16 vendor_id, Uint16 product_id);
     SDL_bool (*InitDevice)(SDL_HIDAPI_Device *device);
@@ -95,8 +98,9 @@ typedef struct _SDL_HIDAPI_DeviceDriver
     SDL_bool (*OpenJoystick)(SDL_HIDAPI_Device *device, SDL_Joystick *joystick);
     int (*RumbleJoystick)(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble);
     int (*RumbleJoystickTriggers)(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble);
-    SDL_bool (*HasJoystickLED)(SDL_HIDAPI_Device *device, SDL_Joystick *joystick);
+    Uint32 (*GetJoystickCapabilities)(SDL_HIDAPI_Device *device, SDL_Joystick *joystick);
     int (*SetJoystickLED)(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue);
+    int (*SendJoystickEffect)(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *data, int size);
     int (*SetJoystickSensorsEnabled)(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, SDL_bool enabled);
     void (*CloseJoystick)(SDL_HIDAPI_Device *device, SDL_Joystick *joystick);
     void (*FreeDevice)(SDL_HIDAPI_Device *device);
@@ -105,14 +109,19 @@ typedef struct _SDL_HIDAPI_DeviceDriver
 
 
 /* HIDAPI device support */
+extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverGameCube;
+extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverLuna;
 extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverPS4;
 extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverPS5;
+extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverStadia;
 extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverSteam;
 extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverSwitch;
 extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverXbox360;
 extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverXbox360W;
 extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverXboxOne;
-extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverGameCube;
+
+/* Return true if a HID device is present and supported as a joystick of the given type */
+extern SDL_bool HIDAPI_IsDeviceTypePresent(SDL_GameControllerType type);
 
 /* Return true if a HID device is present and supported as a joystick */
 extern SDL_bool HIDAPI_IsDevicePresent(Uint16 vendor_id, Uint16 product_id, Uint16 version, const char *name);
@@ -123,6 +132,8 @@ extern void HIDAPI_JoystickDisconnected(SDL_HIDAPI_Device *device, SDL_JoystickI
 
 extern void HIDAPI_DumpPacket(const char *prefix, Uint8 *data, int size);
 
+extern float HIDAPI_RemapVal(float val, float val_min, float val_max, float output_min, float output_max);
+
 #endif /* SDL_JOYSTICK_HIDAPI_H */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/joystick/hidapi/steam/controller_constants.h b/Engine/lib/sdl/src/joystick/hidapi/steam/controller_constants.h
index d57315ba9..d0d568851 100644
--- a/Engine/lib/sdl/src/joystick/hidapi/steam/controller_constants.h
+++ b/Engine/lib/sdl/src/joystick/hidapi/steam/controller_constants.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 2020 Valve Corporation
+  Copyright (C) 2021 Valve Corporation
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/joystick/hidapi/steam/controller_structs.h b/Engine/lib/sdl/src/joystick/hidapi/steam/controller_structs.h
index 967c96f40..c8fd61226 100644
--- a/Engine/lib/sdl/src/joystick/hidapi/steam/controller_structs.h
+++ b/Engine/lib/sdl/src/joystick/hidapi/steam/controller_structs.h
@@ -23,6 +23,43 @@
 
 #pragma pack(1)
 
+#define HID_FEATURE_REPORT_BYTES 64
+
+// Header for all host <==> target messages
+typedef struct
+{
+	unsigned char type;
+	unsigned char length;
+} FeatureReportHeader;
+
+// Generic controller attribute structure
+typedef struct
+{
+	unsigned char attributeTag;
+	uint32_t attributeValue;
+} ControllerAttribute;
+
+// Generic controller settings structure
+typedef struct
+{
+	ControllerAttribute attributes[ ( HID_FEATURE_REPORT_BYTES - sizeof( FeatureReportHeader ) ) / sizeof( ControllerAttribute ) ];
+} MsgGetAttributes;
+
+
+// This is the only message struct that application code should use to interact with feature request messages. Any new
+// messages should be added to the union. The structures defined here should correspond to the ones defined in
+// ValveDeviceCore.cpp.
+//
+typedef struct
+{
+	FeatureReportHeader header;
+	union
+	{
+		MsgGetAttributes				getAttributes;
+	} payload;
+
+} FeatureReportMsg;
+
 // Roll this version forward anytime that you are breaking compatibility of existing
 // message types within ValveInReport_t or the header itself.  Hopefully this should
 // be super rare and instead you shoudl just add new message payloads to the union,
diff --git a/Engine/lib/sdl/src/joystick/iphoneos/SDL_mfijoystick.m b/Engine/lib/sdl/src/joystick/iphoneos/SDL_mfijoystick.m
index 0c802216a..c75fbbae2 100644
--- a/Engine/lib/sdl/src/joystick/iphoneos/SDL_mfijoystick.m
+++ b/Engine/lib/sdl/src/joystick/iphoneos/SDL_mfijoystick.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -27,6 +27,7 @@
 #include "SDL_stdinc.h"
 #include "../SDL_sysjoystick.h"
 #include "../SDL_joystick_c.h"
+#include "../hidapi/SDL_hidapijoystick_c.h"
 #include "../usb_ids.h"
 
 #include "SDL_mfijoystick_c.h"
@@ -53,6 +54,7 @@
 
 static id connectObserver = nil;
 static id disconnectObserver = nil;
+static NSString *GCInputXboxShareButton = @"Button Share";
 
 #include <Availability.h>
 #include <objc/message.h>
@@ -64,6 +66,12 @@ static id disconnectObserver = nil;
 #if defined(__MACOSX__) && (__MAC_OS_X_VERSION_MAX_ALLOWED <= 101600)
 + (BOOL)supportsHIDDevice:(IOHIDDeviceRef)device;
 #endif
+#if !((__IPHONE_OS_VERSION_MAX_ALLOWED >= 130000) || (__APPLETV_OS_VERSION_MAX_ALLOWED >= 130000) || (__MAC_OS_VERSION_MAX_ALLOWED >= 1500000))
+@property(nonatomic, readonly) NSString *productCategory;
+#endif
+#if !((__IPHONE_OS_VERSION_MAX_ALLOWED >= 140500) || (__APPLETV_OS_VERSION_MAX_ALLOWED >= 140500) || (__MAC_OS_X_VERSION_MAX_ALLOWED >= 110300))
+@property(class, nonatomic, readwrite) BOOL shouldMonitorBackgroundEvents;
+#endif
 @end
 @interface GCExtendedGamepad (SDL)
 #if !((__IPHONE_OS_VERSION_MAX_ALLOWED >= 121000) || (__APPLETV_OS_VERSION_MAX_ALLOWED >= 121000) || (__MAC_OS_VERSION_MAX_ALLOWED >= 1401000))
@@ -89,6 +97,7 @@ static id disconnectObserver = nil;
 #define ENABLE_MFI_RUMBLE
 #define ENABLE_MFI_LIGHT
 #define ENABLE_MFI_SENSORS
+#define ENABLE_MFI_SYSTEM_GESTURE_STATE
 #define ENABLE_PHYSICAL_INPUT_PROFILE
 #endif
 
@@ -126,7 +135,49 @@ GetDeviceForIndex(int device_index)
 }
 
 #ifdef SDL_JOYSTICK_MFI
-static void
+static BOOL
+IsControllerPS4(GCController *controller)
+{
+    if (@available(macOS 10.15, iOS 13.0, tvOS 13.0, *)) {
+        if ([controller.productCategory isEqualToString:@"DualShock 4"]) {
+            return TRUE;
+        }
+    } else {
+        if ([controller.vendorName containsString: @"DUALSHOCK"]) {
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+static BOOL
+IsControllerPS5(GCController *controller)
+{
+    if (@available(macOS 10.15, iOS 13.0, tvOS 13.0, *)) {
+        if ([controller.productCategory isEqualToString:@"DualSense"]) {
+            return TRUE;
+        }
+    } else {
+        if ([controller.vendorName containsString: @"DualSense"]) {
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+static BOOL
+IsControllerXbox(GCController *controller)
+{
+    if (@available(macOS 10.15, iOS 13.0, tvOS 13.0, *)) {
+        if ([controller.productCategory isEqualToString:@"Xbox One"]) {
+            return TRUE;
+        }
+    } else {
+        if ([controller.vendorName containsString: @"Xbox"]) {
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+static BOOL
 IOS_AddMFIJoystickDevice(SDL_JoystickDeviceItem *device, GCController *controller)
 {
     Uint16 *guid16 = (Uint16 *)device->guid.data;
@@ -151,13 +202,23 @@ IOS_AddMFIJoystickDevice(SDL_JoystickDeviceItem *device, GCController *controlle
 
     if (controller.extendedGamepad) {
         GCExtendedGamepad *gamepad = controller.extendedGamepad;
-        BOOL is_xbox = [controller.vendorName containsString: @"Xbox"];
-        BOOL is_ps4 = [controller.vendorName containsString: @"DUALSHOCK"];
+        BOOL is_xbox = IsControllerXbox(controller);
+        BOOL is_ps4 = IsControllerPS4(controller);
+        BOOL is_ps5 = IsControllerPS5(controller);
 #if TARGET_OS_TV
-        BOOL is_MFi = (!is_xbox && !is_ps4);
+        BOOL is_MFi = (!is_xbox && !is_ps4 && !is_ps5);
 #endif
         int nbuttons = 0;
 
+#ifdef SDL_JOYSTICK_HIDAPI
+        if ((is_xbox && HIDAPI_IsDeviceTypePresent(SDL_CONTROLLER_TYPE_XBOXONE)) ||
+            (is_ps4 && HIDAPI_IsDeviceTypePresent(SDL_CONTROLLER_TYPE_PS4)) ||
+            (is_ps5 && HIDAPI_IsDeviceTypePresent(SDL_CONTROLLER_TYPE_PS5))) {
+            /* The HIDAPI driver is taking care of this device */
+            return FALSE;
+        }
+#endif
+
         /* These buttons are part of the original MFi spec */
         device->button_mask |= (1 << SDL_CONTROLLER_BUTTON_A);
         device->button_mask |= (1 << SDL_CONTROLLER_BUTTON_B);
@@ -226,6 +287,11 @@ IOS_AddMFIJoystickDevice(SDL_JoystickDeviceItem *device, GCController *controlle
                 device->button_mask |= (1 << SDL_CONTROLLER_BUTTON_PADDLE4);
                 ++nbuttons;
             }
+            if (controller.physicalInputProfile.buttons[GCInputXboxShareButton] != nil) {
+                device->has_xbox_share_button = SDL_TRUE;
+                device->button_mask |= (1 << SDL_CONTROLLER_BUTTON_MISC1);
+                ++nbuttons;
+            }
         }
 #endif
 #pragma clang diagnostic pop
@@ -236,8 +302,12 @@ IOS_AddMFIJoystickDevice(SDL_JoystickDeviceItem *device, GCController *controlle
                 /* Assume Xbox One Elite Series 2 Controller unless/until GCController flows VID/PID */
                 product = USB_PRODUCT_XBOX_ONE_ELITE_SERIES_2_BLUETOOTH;
                 subtype = 1;
+            } else if (device->has_xbox_share_button) {
+                /* Assume Xbox Series X Controller unless/until GCController flows VID/PID */
+                product = USB_PRODUCT_XBOX_SERIES_X_BLE;
+                subtype = 1;
             } else {
-                /* Assume Xbox One S BLE Controller unless/until GCController flows VID/PID */
+                /* Assume Xbox One S Bluetooth Controller unless/until GCController flows VID/PID */
                 product = USB_PRODUCT_XBOX_ONE_S_REV1_BLUETOOTH;
                 subtype = 0;
             }
@@ -250,6 +320,10 @@ IOS_AddMFIJoystickDevice(SDL_JoystickDeviceItem *device, GCController *controlle
             } else {
                 subtype = 0;
             }
+        } else if (is_ps5) {
+            vendor = USB_VENDOR_SONY;
+            product = USB_PRODUCT_SONY_DS5;
+            subtype = 0;
         } else {
             vendor = USB_VENDOR_APPLE;
             product = 1;
@@ -326,6 +400,7 @@ IOS_AddMFIJoystickDevice(SDL_JoystickDeviceItem *device, GCController *controlle
     /* This will be set when the first button press of the controller is
      * detected. */
     controller.playerIndex = -1;
+    return TRUE;
 }
 #endif /* SDL_JOYSTICK_MFI */
 
@@ -374,7 +449,10 @@ IOS_AddJoystickDevice(GCController *controller, SDL_bool accelerometer)
 #endif /* SDL_JOYSTICK_iOS_ACCELEROMETER */
     } else if (controller) {
 #ifdef SDL_JOYSTICK_MFI
-        IOS_AddMFIJoystickDevice(device, controller);
+        if (!IOS_AddMFIJoystickDevice(device, controller)) {
+            SDL_free(device);
+            return;
+        }
 #else
         SDL_free(device);
         return;
@@ -497,6 +575,10 @@ IOS_JoystickInit(void)
             return 0;
         }
 
+        if (@available(macOS 11.3, iOS 14.5, tvOS 14.5, *)) {
+            GCController.shouldMonitorBackgroundEvents = YES;
+        }
+
         /* For whatever reason, this always returns an empty array on
          macOS 11.0.1 */
         for (GCController *controller in [GCController controllers]) {
@@ -580,7 +662,7 @@ IOS_JoystickSetDevicePlayerIndex(int device_index, int player_index)
 }
 
 static SDL_JoystickGUID
-IOS_JoystickGetDeviceGUID( int device_index )
+IOS_JoystickGetDeviceGUID(int device_index)
 {
     SDL_JoystickDeviceItem *device = GetDeviceForIndex(device_index);
     SDL_JoystickGUID guid;
@@ -648,14 +730,26 @@ IOS_JoystickOpen(SDL_Joystick *joystick, int device_index)
                 GCController *controller = joystick->hwdata->controller;
                 GCMotion *motion = controller.motion;
                 if (motion && motion.hasRotationRate) {
-                    SDL_PrivateJoystickAddSensor(joystick, SDL_SENSOR_GYRO);
+                    SDL_PrivateJoystickAddSensor(joystick, SDL_SENSOR_GYRO, 0.0f);
                 }
                 if (motion && motion.hasGravityAndUserAcceleration) {
-                    SDL_PrivateJoystickAddSensor(joystick, SDL_SENSOR_ACCEL);
+                    SDL_PrivateJoystickAddSensor(joystick, SDL_SENSOR_ACCEL, 0.0f);
                 }
             }
 #endif /* ENABLE_MFI_SENSORS */
 
+#ifdef ENABLE_MFI_SYSTEM_GESTURE_STATE
+            if (@available(macOS 11.0, iOS 14.0, tvOS 14.0, *)) {
+                GCController *controller = joystick->hwdata->controller;
+                for (id key in controller.physicalInputProfile.buttons) {
+                    GCControllerButtonInput *button = controller.physicalInputProfile.buttons[key];
+                    if ([button isBoundToSystemGesture]) {
+                        button.preferredSystemGestureState = GCSystemGestureStateDisabled;
+                    }
+                }
+            }
+#endif /* ENABLE_MFI_SYSTEM_GESTURE_STATE */
+
 #endif /* SDL_JOYSTICK_MFI */
         }
     }
@@ -699,9 +793,9 @@ IOS_AccelerometerUpdate(SDL_Joystick *joystick)
      */
 
     /* clamp the data */
-    accel.x = SDL_min(SDL_max(accel.x, -maxgforce), maxgforce);
-    accel.y = SDL_min(SDL_max(accel.y, -maxgforce), maxgforce);
-    accel.z = SDL_min(SDL_max(accel.z, -maxgforce), maxgforce);
+    accel.x = SDL_clamp(accel.x, -maxgforce, maxgforce);
+    accel.y = SDL_clamp(accel.y, -maxgforce, maxgforce);
+    accel.z = SDL_clamp(accel.z, -maxgforce, maxgforce);
 
     /* pass in data mapped to range of SInt16 */
     SDL_PrivateJoystickAxis(joystick, 0,  (accel.x / maxgforce) * maxsint16);
@@ -839,6 +933,10 @@ IOS_MFIJoystickUpdate(SDL_Joystick *joystick)
                     controller.physicalInputProfile.buttons[GCInputXboxPaddleFour].isPressed);
                 */
             }
+
+            if (joystick->hwdata->has_xbox_share_button) {
+                buttons[button_count++] = controller.physicalInputProfile.buttons[GCInputXboxShareButton].isPressed;
+            }
 #endif
 #pragma clang diagnostic pop
 
@@ -987,23 +1085,27 @@ IOS_MFIJoystickUpdate(SDL_Joystick *joystick)
 #ifdef ENABLE_MFI_RUMBLE
 
 @interface SDL_RumbleMotor : NSObject
+    @property(nonatomic,strong) CHHapticEngine *engine API_AVAILABLE(macos(11.0), ios(13.0), tvos(14.0));
+    @property(nonatomic,strong) id<CHHapticPatternPlayer> player API_AVAILABLE(macos(11.0), ios(13.0), tvos(14.0));
+    @property bool active;
 @end
 
 @implementation SDL_RumbleMotor {
-    CHHapticEngine *engine API_AVAILABLE(macos(11.0), ios(13.0), tvos(14.0));
-    id<CHHapticPatternPlayer> player API_AVAILABLE(macos(11.0), ios(13.0), tvos(14.0));
-    bool active;
 }
 
 -(void)cleanup
 {
-    if (self->player != nil) {
-        [self->player cancelAndReturnError:nil];
-        self->player = nil;
-    }
-    if (self->engine != nil) {
-        [self->engine stopWithCompletionHandler:nil];
-        self->engine = nil;
+    @autoreleasepool {
+        if (@available(macos 11.0, iOS 14.0, tvOS 14.0, *)) {
+            if (self.player != nil) {
+                [self.player cancelAndReturnError:nil];
+                self.player = nil;
+            }
+            if (self.engine != nil) {
+                [self.engine stopWithCompletionHandler:nil];
+                self.engine = nil;
+            }
+        }
     }
 }
 
@@ -1011,21 +1113,21 @@ IOS_MFIJoystickUpdate(SDL_Joystick *joystick)
 {
     @autoreleasepool {
         if (@available(macos 11.0, iOS 14.0, tvOS 14.0, *)) {
-            NSError *error;
+            NSError *error = nil;
 
-            if (self->engine == nil) {
+            if (self.engine == nil) {
                 return SDL_SetError("Haptics engine was stopped");
             }
 
             if (intensity == 0.0f) {
-                if (self->player && self->active) {
-                    [self->player stopAtTime:0 error:&error];
+                if (self.player && self.active) {
+                    [self.player stopAtTime:0 error:&error];
                 }
-                self->active = false;
+                self.active = false;
                 return 0;
             }
 
-            if (self->player == nil) {
+            if (self.player == nil) {
                 CHHapticEventParameter *param = [[CHHapticEventParameter alloc] initWithParameterID:CHHapticEventParameterIDHapticIntensity value:1.0f];
                 CHHapticEvent *event = [[CHHapticEvent alloc] initWithEventType:CHHapticEventTypeHapticContinuous parameters:[NSArray arrayWithObjects:param, nil] relativeTime:0 duration:GCHapticDurationInfinite];
                 CHHapticPattern *pattern = [[CHHapticPattern alloc] initWithEvents:[NSArray arrayWithObject:event] parameters:[[NSArray alloc] init] error:&error];
@@ -1033,22 +1135,22 @@ IOS_MFIJoystickUpdate(SDL_Joystick *joystick)
                     return SDL_SetError("Couldn't create haptic pattern: %s", [error.localizedDescription UTF8String]);
                 }
 
-                self->player = [self->engine createPlayerWithPattern:pattern error:&error];
+                self.player = [self.engine createPlayerWithPattern:pattern error:&error];
                 if (error != nil) {
                     return SDL_SetError("Couldn't create haptic player: %s", [error.localizedDescription UTF8String]);
                 }
-                self->active = false;
+                self.active = false;
             }
 
             CHHapticDynamicParameter *param = [[CHHapticDynamicParameter alloc] initWithParameterID:CHHapticDynamicParameterIDHapticIntensityControl value:intensity relativeTime:0];
-            [self->player sendParameters:[NSArray arrayWithObject:param] atTime:0 error:&error];
+            [self.player sendParameters:[NSArray arrayWithObject:param] atTime:0 error:&error];
             if (error != nil) {
                 return SDL_SetError("Couldn't update haptic player: %s", [error.localizedDescription UTF8String]);
             }
 
-            if (!self->active) {
-                [self->player startAtTime:0 error:&error];
-                self->active = true;
+            if (!self.active) {
+                [self.player startAtTime:0 error:&error];
+                self.active = true;
             }
         }
 
@@ -1062,36 +1164,36 @@ IOS_MFIJoystickUpdate(SDL_Joystick *joystick)
         self = [super init];
         NSError *error;
 
-        self->engine = [controller.haptics createEngineWithLocality:locality];
-        if (self->engine == nil) {
+        self.engine = [controller.haptics createEngineWithLocality:locality];
+        if (self.engine == nil) {
             SDL_SetError("Couldn't create haptics engine");
             return nil;
         }
 
-        [self->engine startAndReturnError:&error];
+        [self.engine startAndReturnError:&error];
         if (error != nil) {
             SDL_SetError("Couldn't start haptics engine");
             return nil;
         }
 
-        __weak typeof(self) weakSelf = self;
-        self->engine.stoppedHandler = ^(CHHapticEngineStoppedReason stoppedReason) {
+        __weak __typeof(self) weakSelf = self;
+        self.engine.stoppedHandler = ^(CHHapticEngineStoppedReason stoppedReason) {
             SDL_RumbleMotor *_this = weakSelf;
             if (_this == nil) {
                 return;
             }
 
-            _this->player = nil;
-            _this->engine = nil;
+            _this.player = nil;
+            _this.engine = nil;
         };
-        self->engine.resetHandler = ^{
+        self.engine.resetHandler = ^{
             SDL_RumbleMotor *_this = weakSelf;
             if (_this == nil) {
                 return;
             }
 
-            _this->player = nil;
-            [_this->engine startAndReturnError:nil];
+            _this.player = nil;
+            [_this.engine startAndReturnError:nil];
         };
 
         return self;
@@ -1101,13 +1203,13 @@ IOS_MFIJoystickUpdate(SDL_Joystick *joystick)
 @end
 
 @interface SDL_RumbleContext : NSObject
+    @property(nonatomic,strong) SDL_RumbleMotor *m_low_frequency_motor;
+    @property(nonatomic,strong) SDL_RumbleMotor *m_high_frequency_motor;
+    @property(nonatomic,strong) SDL_RumbleMotor *m_left_trigger_motor;
+    @property(nonatomic,strong) SDL_RumbleMotor *m_right_trigger_motor;
 @end
 
 @implementation SDL_RumbleContext {
-    SDL_RumbleMotor *m_low_frequency_motor;
-    SDL_RumbleMotor *m_high_frequency_motor;
-    SDL_RumbleMotor *m_left_trigger_motor;
-    SDL_RumbleMotor *m_right_trigger_motor;
 }
 
 -(id) initWithLowFrequencyMotor:(SDL_RumbleMotor*)low_frequency_motor
@@ -1116,10 +1218,10 @@ IOS_MFIJoystickUpdate(SDL_Joystick *joystick)
               RightTriggerMotor:(SDL_RumbleMotor*)right_trigger_motor
 {
     self = [super init];
-    self->m_low_frequency_motor = low_frequency_motor;
-    self->m_high_frequency_motor = high_frequency_motor;
-    self->m_left_trigger_motor = left_trigger_motor;
-    self->m_right_trigger_motor = right_trigger_motor;
+    self.m_low_frequency_motor = low_frequency_motor;
+    self.m_high_frequency_motor = high_frequency_motor;
+    self.m_left_trigger_motor = left_trigger_motor;
+    self.m_right_trigger_motor = right_trigger_motor;
     return self;
 }
 
@@ -1127,8 +1229,8 @@ IOS_MFIJoystickUpdate(SDL_Joystick *joystick)
 {
     int result = 0;
 
-    result += [self->m_low_frequency_motor setIntensity:((float)low_frequency_rumble / 65535.0f)];
-    result += [self->m_high_frequency_motor setIntensity:((float)high_frequency_rumble / 65535.0f)];
+    result += [self.m_low_frequency_motor setIntensity:((float)low_frequency_rumble / 65535.0f)];
+    result += [self.m_high_frequency_motor setIntensity:((float)high_frequency_rumble / 65535.0f)];
     return ((result < 0) ? -1 : 0);
 }
 
@@ -1136,9 +1238,9 @@ IOS_MFIJoystickUpdate(SDL_Joystick *joystick)
 {
     int result = 0;
 
-    if (self->m_left_trigger_motor && self->m_right_trigger_motor) {
-        result += [self->m_left_trigger_motor setIntensity:((float)left_rumble / 65535.0f)];
-        result += [self->m_right_trigger_motor setIntensity:((float)right_rumble / 65535.0f)];
+    if (self.m_left_trigger_motor && self.m_right_trigger_motor) {
+        result += [self.m_left_trigger_motor setIntensity:((float)left_rumble / 65535.0f)];
+        result += [self.m_right_trigger_motor setIntensity:((float)right_rumble / 65535.0f)];
     } else {
         result = SDL_Unsupported();
     }
@@ -1147,8 +1249,8 @@ IOS_MFIJoystickUpdate(SDL_Joystick *joystick)
 
 -(void)cleanup
 {
-    [self->m_low_frequency_motor cleanup];
-    [self->m_high_frequency_motor cleanup];
+    [self.m_low_frequency_motor cleanup];
+    [self.m_high_frequency_motor cleanup];
 }
 
 @end
@@ -1180,6 +1282,10 @@ IOS_JoystickRumble(SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 h
 #ifdef ENABLE_MFI_RUMBLE
     SDL_JoystickDeviceItem *device = joystick->hwdata;
 
+    if (device == NULL) {
+        return SDL_SetError("Controller is no longer connected");
+    }
+
     if (@available(macOS 11.0, iOS 14.0, tvOS 14.0, *)) {
         if (!device->rumble && device->controller && device->controller.haptics) {
             SDL_RumbleContext *rumble = IOS_JoystickInitRumble(device->controller);
@@ -1206,6 +1312,10 @@ IOS_JoystickRumbleTriggers(SDL_Joystick *joystick, Uint16 left_rumble, Uint16 ri
 #ifdef ENABLE_MFI_RUMBLE
     SDL_JoystickDeviceItem *device = joystick->hwdata;
 
+    if (device == NULL) {
+        return SDL_SetError("Controller is no longer connected");
+    }
+
     if (@available(macOS 11.0, iOS 14.0, tvOS 14.0, *)) {
         if (!device->rumble && device->controller && device->controller.haptics) {
             SDL_RumbleContext *rumble = IOS_JoystickInitRumble(device->controller);
@@ -1226,22 +1336,43 @@ IOS_JoystickRumbleTriggers(SDL_Joystick *joystick, Uint16 left_rumble, Uint16 ri
 #endif
 }
 
-static SDL_bool
-IOS_JoystickHasLED(SDL_Joystick *joystick)
+static Uint32
+IOS_JoystickGetCapabilities(SDL_Joystick *joystick)
 {
-#ifdef ENABLE_MFI_LIGHT
+    Uint32 result = 0;
+
+#if defined(ENABLE_MFI_LIGHT) || defined(ENABLE_MFI_RUMBLE)
     @autoreleasepool {
+        SDL_JoystickDeviceItem *device = joystick->hwdata;
+
+        if (device == NULL) {
+            return 0;
+        }
+
         if (@available(macos 11.0, iOS 14.0, tvOS 14.0, *)) {
-            GCController *controller = joystick->hwdata->controller;
-            GCDeviceLight *light = controller.light;
-            if (light) {
-                return SDL_TRUE;
+            GCController *controller = device->controller;
+            #ifdef ENABLE_MFI_LIGHT
+            if (controller.light) {
+                result |= SDL_JOYCAP_LED;
             }
+            #endif
+
+            #ifdef ENABLE_MFI_RUMBLE
+            if (controller.haptics) {
+                for (GCHapticsLocality locality in controller.haptics.supportedLocalities) {
+                    if ([locality isEqualToString:GCHapticsLocalityHandles]) {
+                        result |= SDL_JOYCAP_RUMBLE;
+                    } else if ([locality isEqualToString:GCHapticsLocalityTriggers]) {
+                        result |= SDL_JOYCAP_RUMBLE_TRIGGERS;
+                    }
+                }
+            }
+            #endif
         }
     }
-#endif /* ENABLE_MFI_LIGHT */
+#endif /* ENABLE_MFI_LIGHT || ENABLE_MFI_RUMBLE */
 
-    return SDL_FALSE;
+    return result;
 }
 
 static int
@@ -1249,8 +1380,14 @@ IOS_JoystickSetLED(SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
 {
 #ifdef ENABLE_MFI_LIGHT
     @autoreleasepool {
+        SDL_JoystickDeviceItem *device = joystick->hwdata;
+
+        if (device == NULL) {
+            return SDL_SetError("Controller is no longer connected");
+        }
+
         if (@available(macos 11.0, iOS 14.0, tvOS 14.0, *)) {
-            GCController *controller = joystick->hwdata->controller;
+            GCController *controller = device->controller;
             GCDeviceLight *light = controller.light;
             if (light) {
                 light.color = [[GCColor alloc] initWithRed:(float)red / 255.0f
@@ -1265,13 +1402,25 @@ IOS_JoystickSetLED(SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
     return SDL_Unsupported();
 }
 
+static int
+IOS_JoystickSendEffect(SDL_Joystick *joystick, const void *data, int size)
+{
+    return SDL_Unsupported();
+}
+
 static int
 IOS_JoystickSetSensorsEnabled(SDL_Joystick *joystick, SDL_bool enabled)
 {
 #ifdef ENABLE_MFI_SENSORS
     @autoreleasepool {
+        SDL_JoystickDeviceItem *device = joystick->hwdata;
+
+        if (device == NULL) {
+            return SDL_SetError("Controller is no longer connected");
+        }
+
         if (@available(macOS 11.0, iOS 14.0, tvOS 14.0, *)) {
-            GCController *controller = joystick->hwdata->controller;
+            GCController *controller = device->controller;
             GCMotion *motion = controller.motion;
             if (motion) {
                 motion.sensorsActive = enabled ? YES : NO;
@@ -1331,7 +1480,19 @@ IOS_JoystickClose(SDL_Joystick *joystick)
             GCController *controller = device->controller;
             controller.controllerPausedHandler = nil;
             controller.playerIndex = -1;
-#endif
+
+#ifdef ENABLE_MFI_SYSTEM_GESTURE_STATE
+            if (@available(macOS 11.0, iOS 14.0, tvOS 14.0, *)) {
+                for (id key in controller.physicalInputProfile.buttons) {
+                    GCControllerButtonInput *button = controller.physicalInputProfile.buttons[key];
+                    if ([button isBoundToSystemGesture]) {
+                        button.preferredSystemGestureState = GCSystemGestureStateEnabled;
+                    }
+                }
+            }
+#endif /* ENABLE_MFI_SYSTEM_GESTURE_STATE */
+
+#endif /* SDL_JOYSTICK_MFI */
         }
     }
     if (device->remote) {
@@ -1384,12 +1545,223 @@ IOS_JoystickGetGamepadMapping(int device_index, SDL_GamepadMapping *out)
 SDL_bool IOS_SupportedHIDDevice(IOHIDDeviceRef device)
 {
     if (is_macos11()) {
-        return [GCController supportsHIDDevice:device] ? SDL_TRUE : SDL_FALSE;
+        if ([GCController supportsHIDDevice:device]) {
+            return SDL_TRUE;
+        }
+
+        /* GCController supportsHIDDevice may return false if the device hasn't been
+         * seen by the framework yet, so check a few controllers we know are supported.
+         */
+        {
+            Sint32 vendor = 0;
+            Sint32 product = 0;
+            CFTypeRef refCF = NULL;
+
+            refCF = IOHIDDeviceGetProperty(device, CFSTR(kIOHIDVendorIDKey));
+            if (refCF) {
+                CFNumberGetValue(refCF, kCFNumberSInt32Type, &vendor);
+            }
+
+            refCF = IOHIDDeviceGetProperty(device, CFSTR(kIOHIDProductIDKey));
+            if (refCF) {
+                CFNumberGetValue(refCF, kCFNumberSInt32Type, &product);
+            }
+
+            if (vendor == USB_VENDOR_MICROSOFT && SDL_IsJoystickXboxSeriesX(vendor, product)) {
+                return SDL_TRUE;
+            }
+        }
     }
     return SDL_FALSE;
 }
 #endif
 
+#if defined(SDL_JOYSTICK_MFI) && defined(ENABLE_PHYSICAL_INPUT_PROFILE)
+static void
+GetAppleSFSymbolsNameForElement(GCControllerElement *element, char *name)
+{
+    if (@available(macos 11.0, iOS 14.0, tvOS 14.0, *)) {
+        if (element) {
+            [element.sfSymbolsName getCString: name maxLength: 255 encoding: NSASCIIStringEncoding];
+        }
+    }
+}
+
+static GCControllerDirectionPad *
+GetDirectionalPadForController(GCController *controller)
+{
+    if (controller.extendedGamepad) {
+        return controller.extendedGamepad.dpad;
+    }
+
+    if (controller.gamepad) {
+        return controller.gamepad.dpad;
+    }
+
+    if (controller.microGamepad) {
+        return controller.microGamepad.dpad;
+    }
+
+    return nil;
+}
+#endif /* SDL_JOYSTICK_MFI && ENABLE_PHYSICAL_INPUT_PROFILE */
+
+static char elementName[256];
+
+const char *
+IOS_GameControllerGetAppleSFSymbolsNameForButton(SDL_GameController *gamecontroller, SDL_GameControllerButton button)
+{
+    elementName[0] = '\0';
+#if defined(SDL_JOYSTICK_MFI) && defined(ENABLE_PHYSICAL_INPUT_PROFILE)
+    if (gamecontroller && SDL_GameControllerGetJoystick(gamecontroller)->driver == &SDL_IOS_JoystickDriver) {
+        if (@available(iOS 14.0, tvOS 14.0, macOS 11.0, *)) {
+            GCController *controller = SDL_GameControllerGetJoystick(gamecontroller)->hwdata->controller;
+            if ([controller respondsToSelector:@selector(physicalInputProfile)]) {
+                NSDictionary<NSString *,GCControllerElement *> *elements = controller.physicalInputProfile.elements;
+                switch (button)
+                {
+                case SDL_CONTROLLER_BUTTON_A:
+                    GetAppleSFSymbolsNameForElement(elements[GCInputButtonA], elementName);
+                    break;
+                case SDL_CONTROLLER_BUTTON_B:
+                    GetAppleSFSymbolsNameForElement(elements[GCInputButtonB], elementName);
+                    break;
+                case SDL_CONTROLLER_BUTTON_X:
+                    GetAppleSFSymbolsNameForElement(elements[GCInputButtonX], elementName);
+                    break;
+                case SDL_CONTROLLER_BUTTON_Y:
+                    GetAppleSFSymbolsNameForElement(elements[GCInputButtonY], elementName);
+                    break;
+                case SDL_CONTROLLER_BUTTON_BACK:
+                    GetAppleSFSymbolsNameForElement(elements[GCInputButtonOptions], elementName);
+                    break;
+                case SDL_CONTROLLER_BUTTON_GUIDE:
+                    GetAppleSFSymbolsNameForElement(elements[GCInputButtonHome], elementName);
+                    break;
+                case SDL_CONTROLLER_BUTTON_START:
+                    GetAppleSFSymbolsNameForElement(elements[GCInputButtonMenu], elementName);
+                    break;
+                case SDL_CONTROLLER_BUTTON_LEFTSTICK:
+                    GetAppleSFSymbolsNameForElement(elements[GCInputLeftThumbstickButton], elementName);
+                    break;
+                case SDL_CONTROLLER_BUTTON_RIGHTSTICK:
+                    GetAppleSFSymbolsNameForElement(elements[GCInputRightThumbstickButton], elementName);
+                    break;
+                case SDL_CONTROLLER_BUTTON_LEFTSHOULDER:
+                    GetAppleSFSymbolsNameForElement(elements[GCInputLeftShoulder], elementName);
+                    break;
+                case SDL_CONTROLLER_BUTTON_RIGHTSHOULDER:
+                    GetAppleSFSymbolsNameForElement(elements[GCInputRightShoulder], elementName);
+                    break;
+                case SDL_CONTROLLER_BUTTON_DPAD_UP: {
+                    GCControllerDirectionPad * dpad = GetDirectionalPadForController(controller);
+                    if (dpad) {
+                        GetAppleSFSymbolsNameForElement(dpad.up, elementName);
+                        if (SDL_strlen(elementName) == 0) {
+                            SDL_strlcpy(elementName, "dpad.up.fill", sizeof(elementName));
+                        }
+                    }
+                    break;
+                }
+                case SDL_CONTROLLER_BUTTON_DPAD_DOWN: {
+                    GCControllerDirectionPad * dpad = GetDirectionalPadForController(controller);
+                    if (dpad) {
+                        GetAppleSFSymbolsNameForElement(dpad.down, elementName);
+                        if (SDL_strlen(elementName) == 0) {
+                            SDL_strlcpy(elementName, "dpad.down.fill", sizeof(elementName));
+                        }
+                    }
+                    break;
+                }
+                case SDL_CONTROLLER_BUTTON_DPAD_LEFT: {
+                    GCControllerDirectionPad * dpad = GetDirectionalPadForController(controller);
+                    if (dpad) {
+                        GetAppleSFSymbolsNameForElement(dpad.left, elementName);
+                        if (SDL_strlen(elementName) == 0) {
+                            SDL_strlcpy(elementName, "dpad.left.fill", sizeof(elementName));
+                        }
+                    }
+                    break;
+                }
+                case SDL_CONTROLLER_BUTTON_DPAD_RIGHT: {
+                    GCControllerDirectionPad * dpad = GetDirectionalPadForController(controller);
+                    if (dpad) {
+                        GetAppleSFSymbolsNameForElement(dpad.right, elementName);
+                        if (SDL_strlen(elementName) == 0) {
+                            SDL_strlcpy(elementName, "dpad.right.fill", sizeof(elementName));
+                        }
+                    }
+                    break;
+                }
+                case SDL_CONTROLLER_BUTTON_MISC1:
+                    GetAppleSFSymbolsNameForElement(elements[GCInputDualShockTouchpadButton], elementName);
+                    break;
+                case SDL_CONTROLLER_BUTTON_PADDLE1:
+                    GetAppleSFSymbolsNameForElement(elements[GCInputXboxPaddleOne], elementName);
+                    break;
+                case SDL_CONTROLLER_BUTTON_PADDLE2:
+                    GetAppleSFSymbolsNameForElement(elements[GCInputXboxPaddleTwo], elementName);
+                    break;
+                case SDL_CONTROLLER_BUTTON_PADDLE3:
+                    GetAppleSFSymbolsNameForElement(elements[GCInputXboxPaddleThree], elementName);
+                    break;
+                case SDL_CONTROLLER_BUTTON_PADDLE4:
+                    GetAppleSFSymbolsNameForElement(elements[GCInputXboxPaddleFour], elementName);
+                    break;
+                case SDL_CONTROLLER_BUTTON_TOUCHPAD:
+                    GetAppleSFSymbolsNameForElement(elements[GCInputDualShockTouchpadButton], elementName);
+                    break;
+                default:
+                    break;
+                }
+            }
+        }
+    }
+#endif
+    return elementName;
+}
+
+const char *
+IOS_GameControllerGetAppleSFSymbolsNameForAxis(SDL_GameController *gamecontroller, SDL_GameControllerAxis axis)
+{
+    elementName[0] = '\0';
+#if defined(SDL_JOYSTICK_MFI) && defined(ENABLE_PHYSICAL_INPUT_PROFILE)
+    if (gamecontroller && SDL_GameControllerGetJoystick(gamecontroller)->driver == &SDL_IOS_JoystickDriver) {
+        if (@available(iOS 14.0, tvOS 14.0, macOS 11.0, *)) {
+            GCController *controller = SDL_GameControllerGetJoystick(gamecontroller)->hwdata->controller;
+            if ([controller respondsToSelector:@selector(physicalInputProfile)]) {
+                NSDictionary<NSString *,GCControllerElement *> *elements = controller.physicalInputProfile.elements;
+                switch (axis)
+                {
+                case SDL_CONTROLLER_AXIS_LEFTX:
+                    GetAppleSFSymbolsNameForElement(elements[GCInputLeftThumbstick], elementName);
+                    break;
+                case SDL_CONTROLLER_AXIS_LEFTY:
+                    GetAppleSFSymbolsNameForElement(elements[GCInputLeftThumbstick], elementName);
+                    break;
+                case SDL_CONTROLLER_AXIS_RIGHTX:
+                    GetAppleSFSymbolsNameForElement(elements[GCInputRightThumbstick], elementName);
+                    break;
+                case SDL_CONTROLLER_AXIS_RIGHTY:
+                    GetAppleSFSymbolsNameForElement(elements[GCInputRightThumbstick], elementName);
+                    break;
+                case SDL_CONTROLLER_AXIS_TRIGGERLEFT:
+                    GetAppleSFSymbolsNameForElement(elements[GCInputLeftTrigger], elementName);
+                    break;
+                case SDL_CONTROLLER_AXIS_TRIGGERRIGHT:
+                    GetAppleSFSymbolsNameForElement(elements[GCInputRightTrigger], elementName);
+                    break;
+                default:
+                    break;
+                }
+            }
+        }
+    }
+#endif
+    return *elementName ? elementName : NULL;
+}
+
+
 SDL_JoystickDriver SDL_IOS_JoystickDriver =
 {
     IOS_JoystickInit,
@@ -1403,8 +1775,9 @@ SDL_JoystickDriver SDL_IOS_JoystickDriver =
     IOS_JoystickOpen,
     IOS_JoystickRumble,
     IOS_JoystickRumbleTriggers,
-    IOS_JoystickHasLED,
+    IOS_JoystickGetCapabilities,
     IOS_JoystickSetLED,
+    IOS_JoystickSendEffect,
     IOS_JoystickSetSensorsEnabled,
     IOS_JoystickUpdate,
     IOS_JoystickClose,
diff --git a/Engine/lib/sdl/src/joystick/iphoneos/SDL_mfijoystick_c.h b/Engine/lib/sdl/src/joystick/iphoneos/SDL_mfijoystick_c.h
index 21d01b0b9..157dc829e 100644
--- a/Engine/lib/sdl/src/joystick/iphoneos/SDL_mfijoystick_c.h
+++ b/Engine/lib/sdl/src/joystick/iphoneos/SDL_mfijoystick_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -50,6 +50,7 @@ typedef struct joystick_hwdata
     Uint32 button_mask;
     SDL_bool has_dualshock_touchpad;
     SDL_bool has_xbox_paddles;
+    SDL_bool has_xbox_share_button;
 
     struct joystick_hwdata *next;
 } joystick_hwdata;
diff --git a/Engine/lib/sdl/src/joystick/linux/SDL_sysjoystick.c b/Engine/lib/sdl/src/joystick/linux/SDL_sysjoystick.c
index ee4a8c197..851448acd 100644
--- a/Engine/lib/sdl/src/joystick/linux/SDL_sysjoystick.c
+++ b/Engine/lib/sdl/src/joystick/linux/SDL_sysjoystick.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -56,12 +56,6 @@
 #ifndef SYN_DROPPED
 #define SYN_DROPPED 3
 #endif
-#ifndef BTN_SOUTH
-#define BTN_SOUTH       0x130
-#endif
-#ifndef BTN_EAST
-#define BTN_EAST        0x131
-#endif
 #ifndef BTN_NORTH
 #define BTN_NORTH       0x133
 #endif
@@ -97,6 +91,7 @@ typedef enum
 
 static EnumerationMethod enumeration_method = ENUMERATION_UNSET;
 
+static SDL_bool IsJoystickJSNode(const char *node);
 static int MaybeAddDevice(const char *path);
 static int MaybeRemoveDevice(const char *path);
 
@@ -113,8 +108,11 @@ typedef struct SDL_joylist_item
 
     /* Steam Controller support */
     SDL_bool m_bSteamController;
+
+    SDL_GamepadMapping *mapping;
 } SDL_joylist_item;
 
+static SDL_bool SDL_classic_joysticks = SDL_FALSE;
 static SDL_joylist_item *SDL_joylist = NULL;
 static SDL_joylist_item *SDL_joylist_tail = NULL;
 static int numjoysticks = 0;
@@ -137,6 +135,14 @@ FixupDeviceInfoForMapping(int fd, struct input_id *inpid)
             inpid->version = 0x0902;
         }
     }
+
+    /* For Atari vcs modern and classic controllers have the version reflecting
+     * firmware version, but the mapping stays stable so ignore
+     * version information */
+    if (inpid->vendor == 0x3250
+            && (inpid->product == 0x1001 || inpid->product == 0x1002)) {
+        inpid->version = 0;
+    }
 }
 
 #ifdef SDL_JOYSTICK_HIDAPI
@@ -178,24 +184,31 @@ GuessIsJoystick(int fd)
 }
 
 static int
-IsJoystick(int fd, char **name_return, SDL_JoystickGUID *guid)
+IsJoystick(const char *path, int fd, char **name_return, SDL_JoystickGUID *guid)
 {
     struct input_id inpid;
     Uint16 *guid16 = (Uint16 *)guid->data;
     char *name;
     char product_string[128];
 
-    /* When udev is enabled we only get joystick devices here, so there's no need to test them */
-    if (enumeration_method != ENUMERATION_LIBUDEV && !GuessIsJoystick(fd)) {
-        return 0;
-    }
+    if (ioctl(fd, JSIOCGNAME(sizeof(product_string)), product_string) >= 0) {
+        SDL_zero(inpid);
+#if SDL_USE_LIBUDEV
+        SDL_UDEV_GetProductInfo(path, &inpid.vendor, &inpid.product, &inpid.version);
+#endif
+    } else {
+        /* When udev is enabled we only get joystick devices here, so there's no need to test them */
+        if (enumeration_method != ENUMERATION_LIBUDEV && !GuessIsJoystick(fd)) {
+            return 0;
+        }
 
-    if (ioctl(fd, EVIOCGID, &inpid) < 0) {
-        return 0;
-    }
+        if (ioctl(fd, EVIOCGID, &inpid) < 0) {
+            return 0;
+        }
 
-    if (ioctl(fd, EVIOCGNAME(sizeof(product_string)), product_string) < 0) {
-        return 0;
+        if (ioctl(fd, EVIOCGNAME(sizeof(product_string)), product_string) < 0) {
+            return 0;
+        }
     }
 
     name = SDL_CreateJoystickName(inpid.vendor, inpid.product, NULL, product_string);
@@ -215,7 +228,7 @@ IsJoystick(int fd, char **name_return, SDL_JoystickGUID *guid)
     FixupDeviceInfoForMapping(fd, &inpid);
 
 #ifdef DEBUG_JOYSTICK
-    printf("Joystick: %s, bustype = %d, vendor = 0x%.4x, product = 0x%.4x, version = %d\n", name, inpid.bustype, inpid.vendor, inpid.product, inpid.version);
+    SDL_Log("Joystick: %s, bustype = %d, vendor = 0x%.4x, product = 0x%.4x, version = %d\n", name, inpid.bustype, inpid.vendor, inpid.product, inpid.version);
 #endif
 
     SDL_memset(guid->data, 0, sizeof(guid->data));
@@ -256,6 +269,15 @@ static void joystick_udev_callback(SDL_UDEV_deviceevent udev_type, int udev_clas
             if (!(udev_class & SDL_UDEV_DEVICE_JOYSTICK)) {
                 return;
             }
+            if (SDL_classic_joysticks) {
+                if (!IsJoystickJSNode(devpath)) {
+                    return;
+                }
+            } else {
+                if (IsJoystickJSNode(devpath)) {
+                    return;
+                }
+            }
             MaybeAddDevice(devpath);
             break;
             
@@ -270,6 +292,15 @@ static void joystick_udev_callback(SDL_UDEV_deviceevent udev_type, int udev_clas
 }
 #endif /* SDL_USE_LIBUDEV */
 
+static void
+FreeJoylistItem(SDL_joylist_item *item)
+{
+    SDL_free(item->mapping);
+    SDL_free(item->path);
+    SDL_free(item->name);
+    SDL_free(item);
+}
+
 static int
 MaybeAddDevice(const char *path)
 {
@@ -295,36 +326,33 @@ MaybeAddDevice(const char *path)
         }
     }
 
-    fd = open(path, O_RDONLY, 0);
+    fd = open(path, O_RDONLY | O_CLOEXEC, 0);
     if (fd < 0) {
         return -1;
     }
 
 #ifdef DEBUG_INPUT_EVENTS
-    printf("Checking %s\n", path);
+    SDL_Log("Checking %s\n", path);
 #endif
 
-    isstick = IsJoystick(fd, &name, &guid);
+    isstick = IsJoystick(path, fd, &name, &guid);
     close(fd);
     if (!isstick) {
         return -1;
     }
 
-    item = (SDL_joylist_item *) SDL_malloc(sizeof (SDL_joylist_item));
+    item = (SDL_joylist_item *) SDL_calloc(1, sizeof (SDL_joylist_item));
     if (item == NULL) {
         return -1;
     }
 
-    SDL_zerop(item);
     item->devnum = sb.st_rdev;
     item->path = SDL_strdup(path);
     item->name = name;
     item->guid = guid;
 
     if ((item->path == NULL) || (item->name == NULL)) {
-         SDL_free(item->path);
-         SDL_free(item->name);
-         SDL_free(item);
+         FreeJoylistItem(item);
          return -1;
     }
 
@@ -344,6 +372,31 @@ MaybeAddDevice(const char *path)
     return numjoysticks;
 }
 
+static void
+RemoveJoylistItem(SDL_joylist_item *item, SDL_joylist_item *prev)
+{
+    if (item->hwdata) {
+        item->hwdata->item = NULL;
+    }
+
+    if (prev != NULL) {
+        prev->next = item->next;
+    } else {
+        SDL_assert(SDL_joylist == item);
+        SDL_joylist = item->next;
+    }
+
+    if (item == SDL_joylist_tail) {
+        SDL_joylist_tail = prev;
+    }
+
+    /* Need to decrement the joystick count before we post the event */
+    --numjoysticks;
+
+    SDL_PrivateJoystickRemoved(item->device_instance);
+    FreeJoylistItem(item);
+}
+
 static int
 MaybeRemoveDevice(const char *path)
 {
@@ -358,27 +411,7 @@ MaybeRemoveDevice(const char *path)
         /* found it, remove it. */
         if (SDL_strcmp(path, item->path) == 0) {
             const int retval = item->device_instance;
-            if (item->hwdata) {
-                item->hwdata->item = NULL;
-            }
-            if (prev != NULL) {
-                prev->next = item->next;
-            } else {
-                SDL_assert(SDL_joylist == item);
-                SDL_joylist = item->next;
-            }
-            if (item == SDL_joylist_tail) {
-                SDL_joylist_tail = prev;
-            }
-
-            /* Need to decrement the joystick count before we post the event */
-            --numjoysticks;
-
-            SDL_PrivateJoystickRemoved(item->device_instance);
-
-            SDL_free(item->path);
-            SDL_free(item->name);
-            SDL_free(item);
+            RemoveJoylistItem(item, prev);
             return retval;
         }
         prev = item;
@@ -395,26 +428,7 @@ HandlePendingRemovals(void)
 
     while (item != NULL) {
         if (item->hwdata && item->hwdata->gone) {
-            item->hwdata->item = NULL;
-
-            if (prev != NULL) {
-                prev->next = item->next;
-            } else {
-                SDL_assert(SDL_joylist == item);
-                SDL_joylist = item->next;
-            }
-            if (item == SDL_joylist_tail) {
-                SDL_joylist_tail = prev;
-            }
-
-            /* Need to decrement the joystick count before we post the event */
-            --numjoysticks;
-
-            SDL_PrivateJoystickRemoved(item->device_instance);
-
-            SDL_free(item->path);
-            SDL_free(item->name);
-            SDL_free(item);
+            RemoveJoylistItem(item, prev);
 
             if (prev != NULL) {
                 item = prev->next;
@@ -443,9 +457,7 @@ static SDL_bool SteamControllerConnectedCallback(const char *name, SDL_JoystickG
     item->m_bSteamController = SDL_TRUE;
 
     if ((item->path == NULL) || (item->name == NULL)) {
-         SDL_free(item->path);
-         SDL_free(item->name);
-         SDL_free(item);
+         FreeJoylistItem(item);
          return SDL_FALSE;
     }
 
@@ -473,26 +485,7 @@ static void SteamControllerDisconnectedCallback(int device_instance)
     for (item = SDL_joylist; item != NULL; item = item->next) {
         /* found it, remove it. */
         if (item->device_instance == device_instance) {
-            if (item->hwdata) {
-                item->hwdata->item = NULL;
-            }
-            if (prev != NULL) {
-                prev->next = item->next;
-            } else {
-                SDL_assert(SDL_joylist == item);
-                SDL_joylist = item->next;
-            }
-            if (item == SDL_joylist_tail) {
-                SDL_joylist_tail = prev;
-            }
-
-            /* Need to decrement the joystick count before we post the event */
-            --numjoysticks;
-
-            SDL_PrivateJoystickRemoved(item->device_instance);
-
-            SDL_free(item->name);
-            SDL_free(item);
+            RemoveJoylistItem(item, prev);
             return;
         }
         prev = item;
@@ -538,6 +531,36 @@ StrIsInteger(const char *string)
     return 1;
 }
 
+static SDL_bool
+IsJoystickJSNode(const char *node)
+{
+    const char *last_slash = SDL_strrchr(node, '/');
+    if (last_slash) {
+        node = last_slash + 1;
+    }
+    return (StrHasPrefix(node, "js") && StrIsInteger(node + 2));
+}
+
+static SDL_bool
+IsJoystickEventNode(const char *node)
+{
+    const char *last_slash = SDL_strrchr(node, '/');
+    if (last_slash) {
+        node = last_slash + 1;
+    }
+    return (StrHasPrefix(node, "event") && StrIsInteger(node + 5));
+}
+
+static SDL_bool
+IsJoystickDeviceNode(const char *node)
+{
+    if (SDL_classic_joysticks) {
+        return IsJoystickJSNode(node);
+    } else {
+        return IsJoystickEventNode(node);
+    }
+}
+
 static void
 LINUX_InotifyJoystickDetect(void)
 {
@@ -550,6 +573,7 @@ LINUX_InotifyJoystickDetect(void)
     ssize_t bytes;
     size_t remain = 0;
     size_t len;
+    char path[PATH_MAX];
 
     bytes = read(inotify_fd, &buf, sizeof (buf));
 
@@ -559,10 +583,7 @@ LINUX_InotifyJoystickDetect(void)
 
     while (remain > 0) {
         if (buf.event.len > 0) {
-            if (StrHasPrefix(buf.event.name, "event") &&
-                StrIsInteger(buf.event.name + strlen ("event"))) {
-                char path[PATH_MAX];
-
+            if (IsJoystickDeviceNode(buf.event.name)) {
                 SDL_snprintf(path, SDL_arraysize(path), "/dev/input/%s", buf.event.name);
 
                 if (buf.event.mask & (IN_CREATE | IN_MOVED_TO | IN_ATTRIB)) {
@@ -578,7 +599,7 @@ LINUX_InotifyJoystickDetect(void)
         remain -= len;
 
         if (remain != 0) {
-            memmove (&buf.storage[0], &buf.storage[len], remain);
+            SDL_memmove (&buf.storage[0], &buf.storage[len], remain);
         }
     }
 }
@@ -588,6 +609,18 @@ LINUX_InotifyJoystickDetect(void)
  * have to do this the first time, to detect devices that already existed
  * before we started; in the non-inotify code path we do this repeatedly
  * (polling). */
+static int
+filter_entries(const struct dirent *entry)
+{
+    return IsJoystickDeviceNode(entry->d_name);
+}
+static int
+sort_entries(const struct dirent **a, const struct dirent **b)
+{
+    int numA = SDL_atoi((*a)->d_name+5);
+    int numB = SDL_atoi((*b)->d_name+5);
+    return (numA - numB);
+}
 static void
 LINUX_FallbackJoystickDetect(void)
 {
@@ -599,22 +632,18 @@ LINUX_FallbackJoystickDetect(void)
 
         /* Opening input devices can generate synchronous device I/O, so avoid it if we can */
         if (stat("/dev/input", &sb) == 0 && sb.st_mtime != last_input_dir_mtime) {
-            DIR *folder;
-            struct dirent *dent;
+            int i, count;
+            struct dirent **entries;
+            char path[PATH_MAX];
 
-            folder = opendir("/dev/input");
-            if (folder) {
-                while ((dent = readdir(folder))) {
-                    int len = SDL_strlen(dent->d_name);
-                    if (len > 5 && SDL_strncmp(dent->d_name, "event", 5) == 0) {
-                        char path[PATH_MAX];
-                        SDL_snprintf(path, SDL_arraysize(path), "/dev/input/%s", dent->d_name);
-                        MaybeAddDevice(path);
-                    }
-                }
+            count = scandir("/dev/input", &entries, filter_entries, sort_entries);
+            for (i = 0; i < count; ++i) {
+                SDL_snprintf(path, SDL_arraysize(path), "/dev/input/%s", entries[i]->d_name);
+                MaybeAddDevice(path);
 
-                closedir(folder);
+                free(entries[i]); /* This should NOT be SDL_free() */
             }
+            free(entries); /* This should NOT be SDL_free() */
 
             last_input_dir_mtime = sb.st_mtime;
         }
@@ -650,20 +679,27 @@ LINUX_JoystickDetect(void)
 static int
 LINUX_JoystickInit(void)
 {
+    const char *devices = SDL_GetHint(SDL_HINT_JOYSTICK_DEVICE);
+
+    SDL_classic_joysticks = SDL_GetHintBoolean(SDL_HINT_LINUX_JOYSTICK_CLASSIC, SDL_FALSE);
+
 #if SDL_USE_LIBUDEV
     if (enumeration_method == ENUMERATION_UNSET) {
-        if (SDL_getenv("SDL_JOYSTICK_DISABLE_UDEV") != NULL) {
+        if (SDL_GetHintBoolean("SDL_JOYSTICK_DISABLE_UDEV", SDL_FALSE)) {
             SDL_LogDebug(SDL_LOG_CATEGORY_INPUT,
                          "udev disabled by SDL_JOYSTICK_DISABLE_UDEV");
             enumeration_method = ENUMERATION_FALLBACK;
-        }
-        else if (access("/.flatpak-info", F_OK) == 0
-                 || access("/run/pressure-vessel", F_OK) == 0) {
+
+        } else if (access("/.flatpak-info", F_OK) == 0
+                 || access("/run/host/container-manager", F_OK) == 0) {
+            /* Explicitly check `/.flatpak-info` because, for old versions of
+             * Flatpak, this was the only available way to tell if we were in
+             * a Flatpak container. */
             SDL_LogDebug(SDL_LOG_CATEGORY_INPUT,
                          "Container detected, disabling udev integration");
             enumeration_method = ENUMERATION_FALLBACK;
-        }
-        else {
+
+        } else {
             SDL_LogDebug(SDL_LOG_CATEGORY_INPUT,
                          "Using udev for joystick device discovery");
             enumeration_method = ENUMERATION_LIBUDEV;
@@ -672,9 +708,9 @@ LINUX_JoystickInit(void)
 #endif
 
     /* First see if the user specified one or more joysticks to use */
-    if (SDL_getenv("SDL_JOYSTICK_DEVICE") != NULL) {
+    if (devices != NULL) {
         char *envcopy, *envpath, *delim;
-        envcopy = SDL_strdup(SDL_getenv("SDL_JOYSTICK_DEVICE"));
+        envcopy = SDL_strdup(devices);
         envpath = envcopy;
         while (envpath != NULL) {
             delim = SDL_strchr(envpath, ':');
@@ -694,6 +730,9 @@ LINUX_JoystickInit(void)
     last_joy_detect_time = 0;
     last_input_dir_mtime = 0;
 
+    /* Manually scan first, since we sort by device number and udev doesn't */
+    LINUX_JoystickDetect();
+
 #if SDL_USE_LIBUDEV
     if (enumeration_method == ENUMERATION_LIBUDEV) {
         if (SDL_UDEV_Init() < 0) {
@@ -735,9 +774,6 @@ LINUX_JoystickInit(void)
             }
         }
 #endif /* HAVE_INOTIFY */
-
-        /* Report all devices currently present */
-        LINUX_JoystickDetect();
     }
 
     return 0;
@@ -842,6 +878,7 @@ ConfigJoystick(SDL_Joystick *joystick, int fd)
     unsigned long absbit[NBITS(ABS_MAX)] = { 0 };
     unsigned long relbit[NBITS(REL_MAX)] = { 0 };
     unsigned long ffbit[NBITS(FF_MAX)] = { 0 };
+    Uint8 key_pam_size, abs_pam_size;
     SDL_bool use_deadzones = SDL_GetHintBoolean(SDL_HINT_LINUX_JOYSTICK_DEADZONES, SDL_FALSE);
 
     /* See if this device uses the new unified event API */
@@ -853,7 +890,7 @@ ConfigJoystick(SDL_Joystick *joystick, int fd)
         for (i = BTN_JOYSTICK; i < KEY_MAX; ++i) {
             if (test_bit(i, keybit)) {
 #ifdef DEBUG_INPUT_EVENTS
-                printf("Joystick has button: 0x%x\n", i);
+                SDL_Log("Joystick has button: 0x%x\n", i);
 #endif
                 joystick->hwdata->key_map[i] = joystick->nbuttons;
                 joystick->hwdata->has_key[i] = SDL_TRUE;
@@ -863,7 +900,7 @@ ConfigJoystick(SDL_Joystick *joystick, int fd)
         for (i = 0; i < BTN_JOYSTICK; ++i) {
             if (test_bit(i, keybit)) {
 #ifdef DEBUG_INPUT_EVENTS
-                printf("Joystick has button: 0x%x\n", i);
+                SDL_Log("Joystick has button: 0x%x\n", i);
 #endif
                 joystick->hwdata->key_map[i] = joystick->nbuttons;
                 joystick->hwdata->has_key[i] = SDL_TRUE;
@@ -884,10 +921,10 @@ ConfigJoystick(SDL_Joystick *joystick, int fd)
                     continue;
                 }
 #ifdef DEBUG_INPUT_EVENTS
-                printf("Joystick has absolute axis: 0x%.2x\n", i);
-                printf("Values = { %d, %d, %d, %d, %d }\n",
-                       absinfo.value, absinfo.minimum, absinfo.maximum,
-                       absinfo.fuzz, absinfo.flat);
+                SDL_Log("Joystick has absolute axis: 0x%.2x\n", i);
+                SDL_Log("Values = { %d, %d, %d, %d, %d }\n",
+                        absinfo.value, absinfo.minimum, absinfo.maximum,
+                        absinfo.fuzz, absinfo.flat);
 #endif /* DEBUG_INPUT_EVENTS */
                 joystick->hwdata->abs_map[i] = joystick->naxes;
                 joystick->hwdata->has_abs[i] = SDL_TRUE;
@@ -924,10 +961,10 @@ ConfigJoystick(SDL_Joystick *joystick, int fd)
                     continue;
                 }
 #ifdef DEBUG_INPUT_EVENTS
-                printf("Joystick has hat %d\n", hat_index);
-                printf("Values = { %d, %d, %d, %d, %d }\n",
-                       absinfo.value, absinfo.minimum, absinfo.maximum,
-                       absinfo.fuzz, absinfo.flat);
+                SDL_Log("Joystick has hat %d\n", hat_index);
+                SDL_Log("Values = { %d, %d, %d, %d, %d }\n",
+                        absinfo.value, absinfo.minimum, absinfo.maximum,
+                        absinfo.fuzz, absinfo.flat);
 #endif /* DEBUG_INPUT_EVENTS */
                 joystick->hwdata->hats_indices[hat_index] = joystick->nhats++;
                 joystick->hwdata->has_hat[hat_index] = SDL_TRUE;
@@ -937,16 +974,76 @@ ConfigJoystick(SDL_Joystick *joystick, int fd)
             ++joystick->nballs;
         }
 
-        /* Allocate data to keep track of these thingamajigs */
-        if (joystick->nhats > 0) {
-            if (allocate_hatdata(joystick) < 0) {
-                joystick->nhats = 0;
+    } else if ((ioctl(fd, JSIOCGBUTTONS, &key_pam_size, sizeof(key_pam_size)) >= 0) &&
+               (ioctl(fd, JSIOCGAXES, &abs_pam_size, sizeof(abs_pam_size)) >= 0)) {
+        size_t len;
+
+        joystick->hwdata->classic = SDL_TRUE;
+
+        len = (KEY_MAX - BTN_MISC + 1) * sizeof(*joystick->hwdata->key_pam);
+        joystick->hwdata->key_pam = (Uint16 *)SDL_calloc(1, len);
+        if (joystick->hwdata->key_pam) {
+            if (ioctl(fd, JSIOCGBTNMAP, joystick->hwdata->key_pam, len) < 0) {
+                SDL_free(joystick->hwdata->key_pam);
+                joystick->hwdata->key_pam = NULL;
+                key_pam_size = 0;
+            }
+        } else {
+            key_pam_size = 0;
+        }
+        for (i = 0; i < key_pam_size; ++i) {
+            Uint16 code = joystick->hwdata->key_pam[i];
+#ifdef DEBUG_INPUT_EVENTS
+            SDL_Log("Joystick has button: 0x%x\n", code);
+#endif
+            joystick->hwdata->key_map[code] = joystick->nbuttons;
+            joystick->hwdata->has_key[code] = SDL_TRUE;
+            ++joystick->nbuttons;
+        }
+
+        len = ABS_CNT * sizeof(*joystick->hwdata->abs_pam);
+        joystick->hwdata->abs_pam = (Uint8 *)SDL_calloc(1, len);
+        if (joystick->hwdata->abs_pam) {
+            if (ioctl(fd, JSIOCGAXMAP, joystick->hwdata->abs_pam, len) < 0) {
+                SDL_free(joystick->hwdata->abs_pam);
+                joystick->hwdata->abs_pam = NULL;
+                abs_pam_size = 0;
+            }
+        } else {
+            abs_pam_size = 0;
+        }
+        for (i = 0; i < abs_pam_size; ++i) {
+            Uint8 code = joystick->hwdata->abs_pam[i];
+
+            if (code >= ABS_HAT0X && code <= ABS_HAT3Y) {
+                int hat_index = (code - ABS_HAT0X) / 2;
+                if (!joystick->hwdata->has_hat[hat_index]) {
+#ifdef DEBUG_INPUT_EVENTS
+                    SDL_Log("Joystick has hat %d\n", hat_index);
+#endif
+                    joystick->hwdata->hats_indices[hat_index] = joystick->nhats++;
+                    joystick->hwdata->has_hat[hat_index] = SDL_TRUE;
+                }
+            } else {
+#ifdef DEBUG_INPUT_EVENTS
+                SDL_Log("Joystick has absolute axis: 0x%.2x\n", code);
+#endif
+                joystick->hwdata->abs_map[code] = joystick->naxes;
+                joystick->hwdata->has_abs[code] = SDL_TRUE;
+                ++joystick->naxes;
             }
         }
-        if (joystick->nballs > 0) {
-            if (allocate_balldata(joystick) < 0) {
-                joystick->nballs = 0;
-            }
+    }
+
+    /* Allocate data to keep track of these thingamajigs */
+    if (joystick->nhats > 0) {
+        if (allocate_hatdata(joystick) < 0) {
+            joystick->nhats = 0;
+        }
+    }
+    if (joystick->nballs > 0) {
+        if (allocate_balldata(joystick) < 0) {
+            joystick->nballs = 0;
         }
     }
 
@@ -961,6 +1058,54 @@ ConfigJoystick(SDL_Joystick *joystick, int fd)
 }
 
 
+/* This is used to do the heavy lifting for LINUX_JoystickOpen and
+   also LINUX_JoystickGetGamepadMapping, so we can query the hardware
+   without adding an opened SDL_Joystick object to the system.
+   This expects `joystick->hwdata` to be allocated and will not free it
+   on error. Returns -1 on error, 0 on success. */
+static int
+PrepareJoystickHwdata(SDL_Joystick *joystick, SDL_joylist_item *item)
+{
+    joystick->hwdata->item = item;
+    joystick->hwdata->guid = item->guid;
+    joystick->hwdata->effect.id = -1;
+    joystick->hwdata->m_bSteamController = item->m_bSteamController;
+    SDL_memset(joystick->hwdata->key_map, 0xFF, sizeof(joystick->hwdata->key_map));
+    SDL_memset(joystick->hwdata->abs_map, 0xFF, sizeof(joystick->hwdata->abs_map));
+
+    if (item->m_bSteamController) {
+        joystick->hwdata->fd = -1;
+        SDL_GetSteamControllerInputs(&joystick->nbuttons,
+                                     &joystick->naxes,
+                                     &joystick->nhats);
+    } else {
+        /* Try read-write first, so we can do rumble */
+        int fd = open(item->path, O_RDWR | O_CLOEXEC, 0);
+        if (fd < 0) {
+            /* Try read-only again, at least we'll get events in this case */
+            fd = open(item->path, O_RDONLY | O_CLOEXEC, 0);
+        }
+        if (fd < 0) {
+            return SDL_SetError("Unable to open %s", item->path);
+        }
+
+        joystick->hwdata->fd = fd;
+        joystick->hwdata->fname = SDL_strdup(item->path);
+        if (joystick->hwdata->fname == NULL) {
+            close(fd);
+            return SDL_OutOfMemory();
+        }
+
+        /* Set the joystick to non-blocking read mode */
+        fcntl(fd, F_SETFL, O_NONBLOCK);
+
+        /* Get the number of buttons and axes on the joystick */
+        ConfigJoystick(joystick, fd);
+    }
+    return 0;
+}
+
+
 /* Function to open a joystick for use.
    The joystick to open is specified by the device index.
    This should fill the nbuttons and naxes fields of the joystick structure.
@@ -981,39 +1126,11 @@ LINUX_JoystickOpen(SDL_Joystick *joystick, int device_index)
     if (joystick->hwdata == NULL) {
         return SDL_OutOfMemory();
     }
-    joystick->hwdata->item = item;
-    joystick->hwdata->guid = item->guid;
-    joystick->hwdata->effect.id = -1;
-    joystick->hwdata->m_bSteamController = item->m_bSteamController;
-    SDL_memset(joystick->hwdata->abs_map, 0xFF, sizeof(joystick->hwdata->abs_map));
 
-    if (item->m_bSteamController) {
-        joystick->hwdata->fd = -1;
-        SDL_GetSteamControllerInputs(&joystick->nbuttons,
-                                     &joystick->naxes,
-                                     &joystick->nhats);
-    } else {
-        int fd = open(item->path, O_RDWR, 0);
-        if (fd < 0) {
-            SDL_free(joystick->hwdata);
-            joystick->hwdata = NULL;
-            return SDL_SetError("Unable to open %s", item->path);
-        }
-
-        joystick->hwdata->fd = fd;
-        joystick->hwdata->fname = SDL_strdup(item->path);
-        if (joystick->hwdata->fname == NULL) {
-            SDL_free(joystick->hwdata);
-            joystick->hwdata = NULL;
-            close(fd);
-            return SDL_OutOfMemory();
-        }
-
-        /* Set the joystick to non-blocking read mode */
-        fcntl(fd, F_SETFL, O_NONBLOCK);
-
-        /* Get the number of buttons and axes on the joystick */
-        ConfigJoystick(joystick, fd);
+    if (PrepareJoystickHwdata(joystick, item) == -1) {
+        SDL_free(joystick->hwdata);
+        joystick->hwdata = NULL;
+        return -1;  /* SDL_SetError will already have been called */
     }
 
     SDL_assert(item->hwdata == NULL);
@@ -1022,7 +1139,7 @@ LINUX_JoystickOpen(SDL_Joystick *joystick, int device_index)
     /* mark joystick as fresh and ready */
     joystick->hwdata->fresh = SDL_TRUE;
 
-    return (0);
+    return 0;
 }
 
 static int
@@ -1073,10 +1190,16 @@ LINUX_JoystickRumbleTriggers(SDL_Joystick *joystick, Uint16 left_rumble, Uint16
     return SDL_Unsupported();
 }
 
-static SDL_bool
-LINUX_JoystickHasLED(SDL_Joystick *joystick)
+static Uint32
+LINUX_JoystickGetCapabilities(SDL_Joystick *joystick)
 {
-    return SDL_FALSE;
+    Uint32 result = 0;
+
+    if (joystick->hwdata->ff_rumble || joystick->hwdata->ff_sine) {
+        result |= SDL_JOYCAP_RUMBLE;
+    }
+
+    return result;
 }
 
 static int
@@ -1085,13 +1208,19 @@ LINUX_JoystickSetLED(SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
     return SDL_Unsupported();
 }
 
+static int
+LINUX_JoystickSendEffect(SDL_Joystick *joystick, const void *data, int size)
+{
+    return SDL_Unsupported();
+}
+
 static int
 LINUX_JoystickSetSensorsEnabled(SDL_Joystick *joystick, SDL_bool enabled)
 {
     return SDL_Unsupported();
 }
 
-static SDL_INLINE void
+static void
 HandleHat(SDL_Joystick *stick, Uint8 hat, int axis, int value)
 {
     struct hwdata_hat *the_hat;
@@ -1116,14 +1245,14 @@ HandleHat(SDL_Joystick *stick, Uint8 hat, int axis, int value)
     }
 }
 
-static SDL_INLINE void
+static void
 HandleBall(SDL_Joystick *stick, Uint8 ball, int axis, int value)
 {
     stick->hwdata->balls[ball].axis[axis] += value;
 }
 
 
-static SDL_INLINE int
+static int
 AxisCorrect(SDL_Joystick *joystick, int which, int value)
 {
     struct axis_correct *correct;
@@ -1157,7 +1286,7 @@ AxisCorrect(SDL_Joystick *joystick, int which, int value)
     return value;
 }
 
-static SDL_INLINE void
+static void
 PollAllValues(SDL_Joystick *joystick)
 {
     struct input_absinfo absinfo;
@@ -1175,7 +1304,7 @@ PollAllValues(SDL_Joystick *joystick)
                 absinfo.value = AxisCorrect(joystick, i, absinfo.value);
 
 #ifdef DEBUG_INPUT_EVENTS
-                printf("Joystick : Re-read Axis %d (%d) val= %d\n",
+                SDL_Log("Joystick : Re-read Axis %d (%d) val= %d\n",
                     joystick->hwdata->abs_map[i], i, absinfo.value);
 #endif
                 SDL_PrivateJoystickAxis(joystick,
@@ -1205,7 +1334,7 @@ PollAllValues(SDL_Joystick *joystick)
             if (joystick->hwdata->has_key[i]) {
                 const Uint8 value = test_bit(i, keyinfo) ? SDL_PRESSED : SDL_RELEASED;
 #ifdef DEBUG_INPUT_EVENTS
-                printf("Joystick : Re-read Button %d (%d) val= %d\n",
+                SDL_Log("Joystick : Re-read Button %d (%d) val= %d\n",
                     joystick->hwdata->key_map[i], i, value);
 #endif
                 SDL_PrivateJoystickButton(joystick,
@@ -1217,12 +1346,11 @@ PollAllValues(SDL_Joystick *joystick)
     /* Joyballs are relative input, so there's no poll state. Events only! */
 }
 
-static SDL_INLINE void
+static void
 HandleInputEvents(SDL_Joystick *joystick)
 {
     struct input_event events[32];
-    int i, len;
-    int code;
+    int i, len, code;
 
     if (joystick->hwdata->fresh) {
         PollAllValues(joystick);
@@ -1261,13 +1389,10 @@ HandleInputEvents(SDL_Joystick *joystick)
                     HandleHat(joystick, joystick->hwdata->hats_indices[code / 2], code % 2, events[i].value);
                     break;
                 default:
-                    if (joystick->hwdata->abs_map[code] != 0xFF) {
-                        events[i].value =
-                            AxisCorrect(joystick, code, events[i].value);
-                        SDL_PrivateJoystickAxis(joystick,
-                                                joystick->hwdata->abs_map[code],
-                                                events[i].value);
-                    }
+                    events[i].value = AxisCorrect(joystick, code, events[i].value);
+                    SDL_PrivateJoystickAxis(joystick,
+                                            joystick->hwdata->abs_map[code],
+                                            events[i].value);
                     break;
                 }
                 break;
@@ -1286,7 +1411,7 @@ HandleInputEvents(SDL_Joystick *joystick)
                 switch (code) {
                 case SYN_DROPPED :
 #ifdef DEBUG_INPUT_EVENTS
-                    printf("Event SYN_DROPPED detected\n");
+                    SDL_Log("Event SYN_DROPPED detected\n");
 #endif
                     joystick->hwdata->recovering_from_dropped = SDL_TRUE;
                     break;
@@ -1311,6 +1436,48 @@ HandleInputEvents(SDL_Joystick *joystick)
     }
 }
 
+static void
+HandleClassicEvents(SDL_Joystick *joystick)
+{
+    struct js_event events[32];
+    int i, len, code;
+
+    joystick->hwdata->fresh = SDL_FALSE;
+    while ((len = read(joystick->hwdata->fd, events, (sizeof events))) > 0) {
+        len /= sizeof(events[0]);
+        for (i = 0; i < len; ++i) {
+            switch (events[i].type) {
+            case JS_EVENT_BUTTON:
+                code = joystick->hwdata->key_pam[events[i].number];
+                SDL_PrivateJoystickButton(joystick,
+                                          joystick->hwdata->key_map[code],
+                                          events[i].value);
+                break;
+            case JS_EVENT_AXIS:
+                code = joystick->hwdata->abs_pam[events[i].number];
+                switch (code) {
+                case ABS_HAT0X:
+                case ABS_HAT0Y:
+                case ABS_HAT1X:
+                case ABS_HAT1Y:
+                case ABS_HAT2X:
+                case ABS_HAT2Y:
+                case ABS_HAT3X:
+                case ABS_HAT3Y:
+                    code -= ABS_HAT0X;
+                    HandleHat(joystick, joystick->hwdata->hats_indices[code / 2], code % 2, events[i].value);
+                    break;
+                default:
+                    SDL_PrivateJoystickAxis(joystick,
+                                            joystick->hwdata->abs_map[code],
+                                            events[i].value);
+                    break;
+                }
+            }
+        }
+    }
+}
+
 static void
 LINUX_JoystickUpdate(SDL_Joystick *joystick)
 {
@@ -1321,7 +1488,11 @@ LINUX_JoystickUpdate(SDL_Joystick *joystick)
         return;
     }
 
-    HandleInputEvents(joystick);
+    if (joystick->hwdata->classic) {
+        HandleClassicEvents(joystick);
+    } else {
+        HandleInputEvents(joystick);
+    }
 
     /* Deliver ball motion updates */
     for (i = 0; i < joystick->nballs; ++i) {
@@ -1352,6 +1523,8 @@ LINUX_JoystickClose(SDL_Joystick *joystick)
         if (joystick->hwdata->item) {
             joystick->hwdata->item->hwdata = NULL;
         }
+        SDL_free(joystick->hwdata->key_pam);
+        SDL_free(joystick->hwdata->abs_pam);
         SDL_free(joystick->hwdata->hats);
         SDL_free(joystick->hwdata->balls);
         SDL_free(joystick->hwdata->fname);
@@ -1373,9 +1546,7 @@ LINUX_JoystickQuit(void)
 
     for (item = SDL_joylist; item; item = next) {
         next = item->next;
-        SDL_free(item->path);
-        SDL_free(item->name);
-        SDL_free(item);
+        FreeJoylistItem(item);
     }
 
     SDL_joylist = SDL_joylist_tail = NULL;
@@ -1400,19 +1571,40 @@ static SDL_bool
 LINUX_JoystickGetGamepadMapping(int device_index, SDL_GamepadMapping *out)
 {
     SDL_Joystick *joystick;
+    SDL_joylist_item *item = JoystickByDevIndex(device_index);
 
+    if (item->mapping) {
+        SDL_memcpy(out, item->mapping, sizeof(*out));
+        return SDL_TRUE;
+    }
+
+    /* We temporarily open the device to check how it's configured. Make
+       a fake SDL_Joystick object to do so. */
     joystick = (SDL_Joystick *) SDL_calloc(sizeof(*joystick), 1);
     if (joystick == NULL) {
         SDL_OutOfMemory();
         return SDL_FALSE;
     }
+    SDL_memcpy(&joystick->guid, &item->guid, sizeof(item->guid));
 
-    /* We temporarily open the device to check how it's configured. */
-    if (LINUX_JoystickOpen(joystick, device_index) < 0) {
+    joystick->hwdata = (struct joystick_hwdata *)
+        SDL_calloc(1, sizeof(*joystick->hwdata));
+    if (joystick->hwdata == NULL) {
         SDL_free(joystick);
+        SDL_OutOfMemory();
         return SDL_FALSE;
     }
 
+    if (PrepareJoystickHwdata(joystick, item) == -1) {
+        SDL_free(joystick->hwdata);
+        SDL_free(joystick);
+        return SDL_FALSE;  /* SDL_SetError will already have been called */
+    }
+
+    /* don't assign `item->hwdata` so it's not in any global state. */
+
+    /* it is now safe to call LINUX_JoystickClose on this fake joystick. */
+
     if (!joystick->hwdata->has_key[BTN_GAMEPAD]) {
         /* Not a gamepad according to the specs. */
         LINUX_JoystickClose(joystick);
@@ -1422,24 +1614,37 @@ LINUX_JoystickGetGamepadMapping(int device_index, SDL_GamepadMapping *out)
 
     /* We have a gamepad, start filling out the mappings */
 
-    if (joystick->hwdata->has_key[BTN_SOUTH]) {
+    if (joystick->hwdata->has_key[BTN_A]) {
         out->a.kind = EMappingKind_Button;
-        out->a.target = joystick->hwdata->key_map[BTN_SOUTH];
+        out->a.target = joystick->hwdata->key_map[BTN_A];
     }
 
-    if (joystick->hwdata->has_key[BTN_EAST]) {
+    if (joystick->hwdata->has_key[BTN_B]) {
         out->b.kind = EMappingKind_Button;
-        out->b.target = joystick->hwdata->key_map[BTN_EAST];
+        out->b.target = joystick->hwdata->key_map[BTN_B];
     }
 
-    if (joystick->hwdata->has_key[BTN_NORTH]) {
-        out->y.kind = EMappingKind_Button;
-        out->y.target = joystick->hwdata->key_map[BTN_NORTH];
-    }
+    /* Xbox controllers use BTN_X and BTN_Y, and PS4 controllers use BTN_WEST and BTN_NORTH */
+    if (SDL_JoystickGetVendor(joystick) == USB_VENDOR_SONY) {
+        if (joystick->hwdata->has_key[BTN_WEST]) {
+            out->x.kind = EMappingKind_Button;
+            out->x.target = joystick->hwdata->key_map[BTN_WEST];
+        }
 
-    if (joystick->hwdata->has_key[BTN_WEST]) {
-        out->x.kind = EMappingKind_Button;
-        out->x.target = joystick->hwdata->key_map[BTN_WEST];
+        if (joystick->hwdata->has_key[BTN_NORTH]) {
+            out->y.kind = EMappingKind_Button;
+            out->y.target = joystick->hwdata->key_map[BTN_NORTH];
+        }
+    } else {
+        if (joystick->hwdata->has_key[BTN_X]) {
+            out->x.kind = EMappingKind_Button;
+            out->x.target = joystick->hwdata->key_map[BTN_X];
+        }
+
+        if (joystick->hwdata->has_key[BTN_Y]) {
+            out->y.kind = EMappingKind_Button;
+            out->y.target = joystick->hwdata->key_map[BTN_Y];
+        }
     }
 
     if (joystick->hwdata->has_key[BTN_SELECT]) {
@@ -1500,12 +1705,18 @@ LINUX_JoystickGetGamepadMapping(int device_index, SDL_GamepadMapping *out)
         out->lefttrigger.target = hat | 0x4;
         out->righttrigger.target = hat | 0x2;
     } else {
-        if (joystick->hwdata->has_key[BTN_TL2]) {
+        if (joystick->hwdata->has_abs[ABS_Z]) {
+            out->lefttrigger.kind = EMappingKind_Axis;
+            out->lefttrigger.target = joystick->hwdata->abs_map[ABS_Z];
+        } else if (joystick->hwdata->has_key[BTN_TL2]) {
             out->lefttrigger.kind = EMappingKind_Button;
             out->lefttrigger.target = joystick->hwdata->key_map[BTN_TL2];
         }
 
-        if (joystick->hwdata->has_key[BTN_TR2]) {
+        if (joystick->hwdata->has_abs[ABS_RZ]) {
+            out->righttrigger.kind = EMappingKind_Axis;
+            out->righttrigger.target = joystick->hwdata->abs_map[ABS_RZ];
+        } else if (joystick->hwdata->has_key[BTN_TR2]) {
             out->righttrigger.kind = EMappingKind_Button;
             out->righttrigger.target = joystick->hwdata->key_map[BTN_TR2];
         }
@@ -1563,6 +1774,12 @@ LINUX_JoystickGetGamepadMapping(int device_index, SDL_GamepadMapping *out)
     LINUX_JoystickClose(joystick);
     SDL_free(joystick);
 
+    /* Cache the mapping for later */
+    item->mapping = (SDL_GamepadMapping *)SDL_malloc(sizeof(*item->mapping));
+    if (item->mapping) {
+        SDL_memcpy(item->mapping, out, sizeof(*out));
+    }
+
     return SDL_TRUE;
 }
 
@@ -1579,8 +1796,9 @@ SDL_JoystickDriver SDL_LINUX_JoystickDriver =
     LINUX_JoystickOpen,
     LINUX_JoystickRumble,
     LINUX_JoystickRumbleTriggers,
-    LINUX_JoystickHasLED,
+    LINUX_JoystickGetCapabilities,
     LINUX_JoystickSetLED,
+    LINUX_JoystickSendEffect,
     LINUX_JoystickSetSensorsEnabled,
     LINUX_JoystickUpdate,
     LINUX_JoystickClose,
diff --git a/Engine/lib/sdl/src/joystick/linux/SDL_sysjoystick_c.h b/Engine/lib/sdl/src/joystick/linux/SDL_sysjoystick_c.h
index dea9405b7..49b8686d0 100644
--- a/Engine/lib/sdl/src/joystick/linux/SDL_sysjoystick_c.h
+++ b/Engine/lib/sdl/src/joystick/linux/SDL_sysjoystick_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -56,6 +56,11 @@ struct joystick_hwdata
     SDL_bool has_key[KEY_MAX];
     SDL_bool has_abs[ABS_MAX];
 
+    /* Support for the classic joystick interface */
+    SDL_bool classic;
+    Uint16 *key_pam;
+    Uint8 *abs_pam;
+
     struct axis_correct
     {
         SDL_bool use_deadzones;
@@ -74,6 +79,7 @@ struct joystick_hwdata
 
     /* Steam Controller support */
     SDL_bool m_bSteamController;
+
     /* 4 = (ABS_HAT3X-ABS_HAT0X)/2 (see input-event-codes.h in kernel) */
     int hats_indices[4];
     SDL_bool has_hat[4];
diff --git a/Engine/lib/sdl/src/joystick/os2/SDL_os2joystick.c b/Engine/lib/sdl/src/joystick/os2/SDL_os2joystick.c
new file mode 100644
index 000000000..00b7fc554
--- /dev/null
+++ b/Engine/lib/sdl/src/joystick/os2/SDL_os2joystick.c
@@ -0,0 +1,799 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#ifdef SDL_JOYSTICK_OS2
+
+/* OS/2 Joystick driver, contributed by Daniel Caetano */
+
+#define INCL_DOSDEVICES
+#define INCL_DOSDEVIOCTL
+#define INCL_DOSMEMMGR
+#include <os2.h>
+
+/*****************************************************************
+ * OS/2 Joystick driver defs. Based on docs at edm2.com and in old
+ * drivers available at hobbes.nmsu.edu and www.os2site.com
+ *****************************************************************/
+
+#define GAME_GET_VERSION 0x01
+#define GAME_GET_PARMS   0x02
+#define GAME_GET_CALIB   0x04
+#define GAME_GET_STATUS  0x10
+
+#define IOCTL_CAT_USER   0x80
+#define GAME_PORT_GET    0x20
+#define GAME_PORT_RESET  0x60
+
+#pragma pack(push,1)
+typedef struct {
+  USHORT  uJs_AxCnt, uJs_AyCnt; /* A joystick X/Y pos */
+  USHORT  uJs_BxCnt, uJs_ByCnt; /* B joystick X/Y pos */
+  USHORT  usJs_ButtonA1Cnt, usJs_ButtonA2Cnt;/* A1/A2 press cnts */
+  USHORT  usJs_ButtonB1Cnt, usJs_ButtonB2Cnt;/* B1/B2 press cnts */
+  UCHAR   ucJs_JoyStickMask;  /* mask of connected joystick pots */
+  UCHAR   ucJs_ButtonStatus;  /* bits of switches down */
+  ULONG   ulJs_Ticks;         /* total clock ticks (60 Hz) */
+} GAME_PORT_STRUCT;
+#pragma pack(pop)
+
+typedef struct {
+  USHORT  useA, useB;
+  USHORT  mode;
+  USHORT  format;
+  USHORT  sampDiv;
+  USHORT  scale;
+  USHORT  res1, res2;
+} GAME_PARM_STRUCT;
+
+typedef struct {
+  SHORT   x, y;
+} GAME_2DPOS_STRUCT;
+
+typedef struct {
+  SHORT  lower, centre, upper;
+} GAME_3POS_STRUCT;
+
+typedef struct {
+  GAME_3POS_STRUCT  Ax, Ay, Bx, By;
+} GAME_CALIB_STRUCT;
+
+typedef struct {
+  GAME_2DPOS_STRUCT A, B;
+  USHORT  butMask;
+} GAME_DATA_STRUCT;
+
+typedef struct {
+  GAME_DATA_STRUCT  curdata;
+  USHORT  b1cnt, b2cnt, b3cnt, b4cnt;
+} GAME_STATUS_STRUCT;
+
+/*****************************************************************/
+
+#include "SDL_joystick.h"
+#include "SDL_events.h"
+#include "../SDL_sysjoystick.h"
+#include "../SDL_joystick_c.h"
+
+static HFILE hJoyPort = NULLHANDLE;	/* Joystick GAME$ Port Address */
+#define MAX_JOYSTICKS	2	/* Maximum of two joysticks */
+#define MAX_AXES	4			/* each joystick can have up to 4 axes */
+#define MAX_BUTTONS	8		/* 8 buttons */
+#define MAX_HATS	0			/* 0 hats - OS/2 doesn't support it */
+#define MAX_BALLS	0			/* and 0 balls - OS/2 doesn't support it */
+#define MAX_JOYNAME	128	/* Joystick name may have 128 characters */
+/* Calc Button Flag for buttons A to D */
+#define JOY_BUTTON_FLAG(n) (1<<n)
+
+/* Joystick data... hold information about detected devices */
+typedef struct SYS_JoyData_s
+{
+	Sint8	id;				/* Device ID          */
+	char	szDeviceName[MAX_JOYNAME];	/* Device Name        */
+	char	axes;				/* Number of axes     */
+	char	buttons;			/* Number of buttons  */
+	char	hats;				/* Number of buttons  */
+	char	balls;				/* Number of buttons  */
+	int	axes_min[MAX_AXES];		/* minimum callibration value for axes  */
+	int	axes_med[MAX_AXES];		/* medium callibration value for axes   */
+	int	axes_max[MAX_AXES];		/* maximum callibration value for axes  */
+	int	buttoncalc[4];			/* Used for buttons 5, 6, 7 and 8.      */
+} SYS_JoyData_t, *SYS_JoyData_p;
+
+static SYS_JoyData_t SYS_JoyData[MAX_JOYSTICKS];
+
+/* Structure used to convert data from OS/2 driver format to SDL format */
+struct _transaxes
+{
+	int offset;					/* Center Offset */
+	float scale1;				/* Center to left/up Scale */
+	float scale2;				/* Center to right/down Scale */
+};
+
+struct joystick_hwdata
+{
+	Sint8		id;
+	struct _transaxes	transaxes[MAX_AXES];
+};
+
+/* Structure used to get values from Joystick Environment Variable */
+struct _joycfg
+{
+	char	name[MAX_JOYNAME];
+	unsigned int	axes;
+	unsigned int	buttons;
+	unsigned int	hats;
+	unsigned int	balls;
+};
+
+/* OS/2 Implementation Function Prototypes */
+static int joyPortOpen(HFILE * hGame);
+static void joyPortClose(HFILE * hGame);
+static int joyGetData(const char *joyenv, char *name, char stopchar, size_t maxchars);
+static int joyGetEnv(struct _joycfg * joydata);
+
+
+static int numjoysticks = 0;
+
+/************************************************************************/
+/* Function to scan the system for joysticks.									*/
+/* Joystick 0 should be the system default joystick.			*/
+/* It should return 0, or -1 on an unrecoverable fatal error.				*/
+/************************************************************************/
+static int OS2_JoystickInit(void)
+{
+	APIRET rc;	/* Generic OS/2 return code */
+	GAME_PORT_STRUCT	stJoyStatus;		/* Joystick Status Structure */
+	GAME_PARM_STRUCT	stGameParms;		/* Joystick Parameter Structure */
+	GAME_CALIB_STRUCT	stGameCalib;		/* Calibration Struct */
+	ULONG ulDataLen;					/* Size of data */
+	ULONG ulLastTick;					/* Tick Counter for timing operations */
+	Uint8 maxdevs;						/* Maximum number of devices */
+	Uint8 numdevs;						/* Number of present devices */
+	Uint8 maxbut;						/* Maximum number of buttons... */
+	Uint8 i;						/* Temporary Count Vars */
+	Uint8 ucNewJoystickMask;				/* Mask for Joystick Detection */
+	struct _joycfg joycfg;					/* Joy Configuration from envvar */
+
+	/* Open GAME$ port */
+	if (joyPortOpen(&hJoyPort) < 0) return 0;	/* Cannot open... report no joystick */
+	/* Get Max Number of Devices */
+	ulDataLen = sizeof(stGameParms);
+	rc = DosDevIOCtl(hJoyPort, IOCTL_CAT_USER, GAME_GET_PARMS,
+			 NULL, 0, NULL, &stGameParms, ulDataLen, &ulDataLen); /* Ask device info */
+	if (rc != 0)
+	{
+		joyPortClose(&hJoyPort);
+		return SDL_SetError("Could not read joystick port.");
+	}
+	maxdevs = 0;
+	if (stGameParms.useA != 0) maxdevs++;
+	if (stGameParms.useB != 0) maxdevs++;
+	if (maxdevs > MAX_JOYSTICKS) maxdevs = MAX_JOYSTICKS;
+
+	/* Defines min/max axes values (callibration) */
+	ulDataLen = sizeof(stGameCalib);
+	rc = DosDevIOCtl(hJoyPort, IOCTL_CAT_USER, GAME_GET_CALIB,
+			 NULL, 0, NULL, &stGameCalib, ulDataLen, &ulDataLen);
+	if (rc != 0)
+	{
+		joyPortClose(&hJoyPort);
+		return SDL_SetError("Could not read callibration data.");
+	}
+
+	/* Determine how many joysticks are active */
+	numdevs = 0;	/* Points no device */
+	ucNewJoystickMask = 0x0F;	/* read all 4 joystick axis */
+	ulDataLen = sizeof(ucNewJoystickMask);
+	rc = DosDevIOCtl(hJoyPort, IOCTL_CAT_USER, GAME_PORT_RESET,
+			 &ucNewJoystickMask, ulDataLen, &ulDataLen, NULL, 0, NULL);
+	if (rc == 0)
+	{
+		ulDataLen = sizeof(stJoyStatus);
+		rc = DosDevIOCtl(hJoyPort, IOCTL_CAT_USER, GAME_PORT_GET,
+				 NULL, 0, NULL, &stJoyStatus, ulDataLen, &ulDataLen);
+		if (rc != 0)
+		{
+			joyPortClose(&hJoyPort);
+			return SDL_SetError("Could not call joystick port.");
+		}
+		ulLastTick = stJoyStatus.ulJs_Ticks;
+		while (stJoyStatus.ulJs_Ticks == ulLastTick)
+		{
+			rc = DosDevIOCtl(hJoyPort, IOCTL_CAT_USER, GAME_PORT_GET,
+					 NULL, 0, NULL, &stJoyStatus, ulDataLen, &ulDataLen);
+		}
+		if ((stJoyStatus.ucJs_JoyStickMask & 0x03) > 0) numdevs++;
+		if (((stJoyStatus.ucJs_JoyStickMask >> 2) & 0x03) > 0) numdevs++;
+	}
+
+	if (numdevs > maxdevs) numdevs = maxdevs;
+
+	/* If *any* joystick was detected... Let's configure SDL for them */
+	if (numdevs > 0)
+	{
+		/* Verify if it is a "user defined" joystick */
+		if (joyGetEnv(&joycfg))
+		{
+			GAME_3POS_STRUCT * axis[4];
+			axis[0] = &stGameCalib.Ax;
+			axis[1] = &stGameCalib.Ay;
+			axis[2] = &stGameCalib.Bx;
+			axis[3] = &stGameCalib.By;
+
+			/* Say it has one device only (user defined is always one device only) */
+			numdevs = 1;
+
+			/* Define Device 0 as... */
+			SYS_JoyData[0].id = 0;
+
+			/* Define Number of Axes... up to 4 */
+			if (joycfg.axes>MAX_AXES) joycfg.axes = MAX_AXES;
+			SYS_JoyData[0].axes = joycfg.axes;
+
+			/* Define number of buttons... 8 if 2 axes, 6 if 3 axes and 4 if 4 axes */
+			maxbut = MAX_BUTTONS;
+			if (joycfg.axes>2) maxbut -= ((joycfg.axes - 2)<<1); /* MAX_BUTTONS - 2*(axes-2) */
+			if (joycfg.buttons > maxbut) joycfg.buttons = maxbut;
+			SYS_JoyData[0].buttons = joycfg.buttons;
+
+			/* Define number of hats */
+			if (joycfg.hats > MAX_HATS) joycfg.hats = MAX_HATS;
+			SYS_JoyData[0].hats = joycfg.hats;
+
+			/* Define number of balls */
+			if (joycfg.balls > MAX_BALLS) joycfg.balls = MAX_BALLS;
+			SYS_JoyData[0].balls = joycfg.balls;
+
+			/* Initialize Axes Callibration Values */
+			for (i=0; i<joycfg.axes; i++)
+			{
+				SYS_JoyData[0].axes_min[i] = axis[i]->lower;
+				SYS_JoyData[0].axes_med[i] = axis[i]->centre;
+				SYS_JoyData[0].axes_max[i] = axis[i]->upper;
+			}
+			/* Initialize Buttons 5 to 8 structures */
+			if (joycfg.buttons>=5) SYS_JoyData[0].buttoncalc[0] = ((axis[2]->lower+axis[3]->centre)>>1);
+			if (joycfg.buttons>=6) SYS_JoyData[0].buttoncalc[1] = ((axis[3]->lower+axis[3]->centre)>>1);
+			if (joycfg.buttons>=7) SYS_JoyData[0].buttoncalc[2] = ((axis[2]->upper+axis[3]->centre)>>1);
+			if (joycfg.buttons>=8) SYS_JoyData[0].buttoncalc[3] = ((axis[3]->upper+axis[3]->centre)>>1);
+			/* Intialize Joystick Name */
+			SDL_strlcpy (SYS_JoyData[0].szDeviceName,joycfg.name, SDL_arraysize(SYS_JoyData[0].szDeviceName));
+		}
+		/* Default Init ... autoconfig */
+		else
+		{
+			/* if two devices were detected... configure as Joy1 4 axis and Joy2 2 axis */
+			if (numdevs == 2)
+			{
+				/* Define Device 0 as 4 axes, 4 buttons */
+				SYS_JoyData[0].id=0;
+				SYS_JoyData[0].axes = 4;
+				SYS_JoyData[0].buttons = 4;
+				SYS_JoyData[0].hats = 0;
+				SYS_JoyData[0].balls = 0;
+				SYS_JoyData[0].axes_min[0] = stGameCalib.Ax.lower;
+				SYS_JoyData[0].axes_med[0] = stGameCalib.Ax.centre;
+				SYS_JoyData[0].axes_max[0] = stGameCalib.Ax.upper;
+				SYS_JoyData[0].axes_min[1] = stGameCalib.Ay.lower;
+				SYS_JoyData[0].axes_med[1] = stGameCalib.Ay.centre;
+				SYS_JoyData[0].axes_max[1] = stGameCalib.Ay.upper;
+				SYS_JoyData[0].axes_min[2] = stGameCalib.Bx.lower;
+				SYS_JoyData[0].axes_med[2] = stGameCalib.Bx.centre;
+				SYS_JoyData[0].axes_max[2] = stGameCalib.Bx.upper;
+				SYS_JoyData[0].axes_min[3] = stGameCalib.By.lower;
+				SYS_JoyData[0].axes_med[3] = stGameCalib.By.centre;
+				SYS_JoyData[0].axes_max[3] = stGameCalib.By.upper;
+				/* Define Device 1 as 2 axes, 2 buttons */
+				SYS_JoyData[1].id=1;
+				SYS_JoyData[1].axes = 2;
+				SYS_JoyData[1].buttons = 2;
+				SYS_JoyData[1].hats = 0;
+				SYS_JoyData[1].balls = 0;
+				SYS_JoyData[1].axes_min[0] = stGameCalib.Bx.lower;
+				SYS_JoyData[1].axes_med[0] = stGameCalib.Bx.centre;
+				SYS_JoyData[1].axes_max[0] = stGameCalib.Bx.upper;
+				SYS_JoyData[1].axes_min[1] = stGameCalib.By.lower;
+				SYS_JoyData[1].axes_med[1] = stGameCalib.By.centre;
+				SYS_JoyData[1].axes_max[1] = stGameCalib.By.upper;
+			}
+			/* One joystick only? */
+			else
+			{
+				/* If it is joystick A... */
+				if ((stJoyStatus.ucJs_JoyStickMask & 0x03) > 0)
+				{
+					/* Define Device 0 as 2 axes, 4 buttons */
+					SYS_JoyData[0].id=0;
+					SYS_JoyData[0].axes = 2;
+					SYS_JoyData[0].buttons = 4;
+					SYS_JoyData[0].hats = 0;
+					SYS_JoyData[0].balls = 0;
+					SYS_JoyData[0].axes_min[0] = stGameCalib.Ax.lower;
+					SYS_JoyData[0].axes_med[0] = stGameCalib.Ax.centre;
+					SYS_JoyData[0].axes_max[0] = stGameCalib.Ax.upper;
+					SYS_JoyData[0].axes_min[1] = stGameCalib.Ay.lower;
+					SYS_JoyData[0].axes_med[1] = stGameCalib.Ay.centre;
+					SYS_JoyData[0].axes_max[1] = stGameCalib.Ay.upper;
+				}
+				/* If not, it is joystick B */
+				else
+				{
+					/* Define Device 1 as 2 axes, 2 buttons */
+					SYS_JoyData[0].id=1;
+					SYS_JoyData[0].axes = 2;
+					SYS_JoyData[0].buttons = 2;
+					SYS_JoyData[0].hats = 0;
+					SYS_JoyData[0].balls = 0;
+					SYS_JoyData[0].axes_min[0] = stGameCalib.Bx.lower;
+					SYS_JoyData[0].axes_med[0] = stGameCalib.Bx.centre;
+					SYS_JoyData[0].axes_max[0] = stGameCalib.Bx.upper;
+					SYS_JoyData[0].axes_min[1] = stGameCalib.By.lower;
+					SYS_JoyData[0].axes_med[1] = stGameCalib.By.centre;
+					SYS_JoyData[0].axes_max[1] = stGameCalib.By.upper;
+				}
+			}
+
+			/* Hack to define Joystick Port Names */
+			if (numdevs > maxdevs) numdevs = maxdevs;
+
+			for (i = 0; i < numdevs; i++)
+			{
+				SDL_snprintf(SYS_JoyData[i].szDeviceName,
+						SDL_arraysize(SYS_JoyData[i].szDeviceName),
+						"Default Joystick %c", 'A'+SYS_JoyData[i].id);
+			}
+		}
+	}
+	/* Return the number of devices found */
+	numjoysticks = numdevs;
+	return numdevs;
+}
+
+static int OS2_NumJoysticks(void)
+{
+	return numjoysticks;
+}
+
+static void OS2_JoystickDetect(void)
+{
+}
+
+/***********************************************************/
+/* Function to get the device-dependent name of a joystick */
+/***********************************************************/
+static const char *OS2_JoystickGetDeviceName(int device_index)
+{
+	/* No need to verify if device exists, already done in upper layer */
+	return SYS_JoyData[device_index].szDeviceName;
+}
+
+static int OS2_JoystickGetDevicePlayerIndex(int device_index)
+{
+	return -1;
+}
+
+static void OS2_JoystickSetDevicePlayerIndex(int device_index, int player_index)
+{
+}
+
+static SDL_JoystickGUID OS2_JoystickGetDeviceGUID(int device_index)
+{
+	SDL_JoystickGUID guid;
+	/* the GUID is just the first 16 chars of the name for now */
+	const char *name = OS2_JoystickGetDeviceName(device_index);
+	SDL_zero(guid);
+	SDL_memcpy(&guid, name, SDL_min(sizeof(guid), SDL_strlen(name)));
+	return guid;
+}
+
+static SDL_JoystickID OS2_JoystickGetDeviceInstanceID(int device_index)
+{
+	return device_index;
+}
+
+/******************************************************************************/
+/* Function to open a joystick for use.													*/
+/* The joystick to open is specified by the device index.		*/
+/* This should fill the nbuttons and naxes fields of the joystick structure.	*/
+/* It returns 0, or -1 if there is an error.												*/
+/******************************************************************************/
+static int OS2_JoystickOpen(SDL_Joystick *joystick, int device_index)
+{
+	int index;		/* Index shortcut for index in joystick structure */
+	int i;			/* Generic Counter */
+
+	/* allocate memory for system specific hardware data */
+	joystick->hwdata = (struct joystick_hwdata *) SDL_calloc(1, sizeof(*joystick->hwdata));
+	if (!joystick->hwdata)
+	{
+		return SDL_OutOfMemory();
+	}
+
+	/* ShortCut Pointer */
+	index = device_index;
+	joystick->instance_id = device_index;
+
+	/* Define offsets and scales for all axes */
+	joystick->hwdata->id = SYS_JoyData[index].id;
+	for (i = 0; i < MAX_AXES; ++i)
+	{
+		if ((i < 2) || i < SYS_JoyData[index].axes)
+		{
+			joystick->hwdata->transaxes[i].offset = ((SDL_JOYSTICK_AXIS_MAX + SDL_JOYSTICK_AXIS_MIN)>>1) - SYS_JoyData[index].axes_med[i];
+			joystick->hwdata->transaxes[i].scale1 = (float)SDL_abs((SDL_JOYSTICK_AXIS_MIN/SYS_JoyData[index].axes_min[i]));
+			joystick->hwdata->transaxes[i].scale2 = (float)SDL_abs((SDL_JOYSTICK_AXIS_MAX/SYS_JoyData[index].axes_max[i]));
+		}
+		else
+		{
+			joystick->hwdata->transaxes[i].offset = 0;
+			joystick->hwdata->transaxes[i].scale1 = 1.0f; /* Just in case */
+			joystick->hwdata->transaxes[i].scale2 = 1.0f; /* Just in case */
+		}
+	}
+
+	/* fill nbuttons, naxes, and nhats fields */
+	joystick->nbuttons = SYS_JoyData[index].buttons;
+	joystick->naxes = SYS_JoyData[index].axes;
+
+	/* joystick->nhats = SYS_JoyData[index].hats; */
+	joystick->nhats = 0; /* No support for hats at this time */
+
+	/* joystick->nballs = SYS_JoyData[index].balls; */
+	joystick->nballs = 0; /* No support for balls at this time */
+
+	return 0;
+}
+
+static int OS2_JoystickRumble(SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+{
+	return SDL_Unsupported();
+}
+
+static int OS2_JoystickRumbleTriggers(SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
+{
+	return SDL_Unsupported();
+}
+
+static Uint32 OS2_JoystickGetCapabilities(SDL_Joystick *joystick)
+{
+	return 0;
+}
+
+static int OS2_JoystickSetLED(SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+	return SDL_Unsupported();
+}
+
+static int OS2_JoystickSendEffect(SDL_Joystick *joystick, const void *data, int size)
+{
+    return SDL_Unsupported();
+}
+
+static int OS2_JoystickSetSensorsEnabled(SDL_Joystick *joystick, SDL_bool enabled)
+{
+	return SDL_Unsupported();
+}
+
+/***************************************************************************/
+/* Function to update the state of a joystick - called as a device poll.	*/
+/* This function shouldn't update the joystick structure directly,			*/
+/* but instead should call SDL_PrivateJoystick*() to deliver events			*/
+/* and update joystick device state.													*/
+/***************************************************************************/
+static void OS2_JoystickUpdate(SDL_Joystick *joystick)
+{
+	APIRET rc;	/* Generic OS/2 return code */
+	int index;					/* index shortcurt to joystick index */
+	int i;						/* Generic counter */
+	int normbut;					/* Number of buttons reported by joystick */
+	int corr;							/* Correction for button names */
+	Sint16 value;					/* Values used to update axis values */
+	struct _transaxes *transaxes;			/* Shortcut for Correction structure */
+	Uint32 pos[MAX_AXES];				/* Vector to inform the Axis status */
+	ULONG ulDataLen;					/* Size of data */
+	GAME_STATUS_STRUCT stGameStatus;		/* Joystick Status Structure */
+
+	ulDataLen = sizeof(stGameStatus);
+	rc = DosDevIOCtl(hJoyPort, IOCTL_CAT_USER, GAME_GET_STATUS,
+			 NULL, 0, NULL, &stGameStatus, ulDataLen, &ulDataLen);
+	if (rc != 0)
+	{
+		SDL_SetError("Could not read joystick status.");
+		return; /* Could not read data */
+	}
+
+	/* Shortcut pointer */
+	index = joystick->instance_id;
+
+	/* joystick motion events */
+
+	if (SYS_JoyData[index].id == 0)
+	{
+		pos[0] = stGameStatus.curdata.A.x;
+		pos[1] = stGameStatus.curdata.A.y;
+		if (SYS_JoyData[index].axes >= 3) pos[2] = stGameStatus.curdata.B.x;
+		else pos[2] = 0;
+		if (SYS_JoyData[index].axes >= 4) pos[3] = stGameStatus.curdata.B.y;
+		else pos[3] = 0;
+		/* OS/2 basic drivers do not support more than 4 axes joysticks */
+	}
+	else if (SYS_JoyData[index].id == 1)
+	{
+		pos[0] = stGameStatus.curdata.B.x;
+		pos[1] = stGameStatus.curdata.B.y;
+		pos[2] = 0;
+		pos[3] = 0;
+	}
+
+	/* Corrects the movements using the callibration */
+	transaxes = joystick->hwdata->transaxes;
+	for (i = 0; i < joystick->naxes; i++)
+	{
+		value = pos[i] + transaxes[i].offset;
+		if (value < 0)
+		{
+			value *= transaxes[i].scale1;
+			if (value > 0) value = SDL_JOYSTICK_AXIS_MIN;
+		}
+		else
+		{
+			value *= transaxes[i].scale2;
+			if (value < 0) value = SDL_JOYSTICK_AXIS_MAX;
+		}
+		SDL_PrivateJoystickAxis(joystick, (Uint8)i, (Sint16)value);
+	}
+
+	/* joystick button A to D events */
+	if (SYS_JoyData[index].id == 1) corr = 2;
+	else corr = 0;
+	normbut = 4;	/* Number of normal buttons */
+	if (joystick->nbuttons < normbut) normbut = joystick->nbuttons;
+	for (i = corr; (i-corr) < normbut; ++i)
+	{
+		/*
+		Button A: 1110 0000
+		Button B: 1101 0000
+		Button C: 1011 0000
+		Button D: 0111 0000
+		*/
+		if ((~stGameStatus.curdata.butMask)>>4 & JOY_BUTTON_FLAG(i))
+		{
+			SDL_PrivateJoystickButton(joystick, (Uint8)(i-corr), SDL_PRESSED);
+		}
+		else
+		{
+			SDL_PrivateJoystickButton(joystick, (Uint8)(i-corr), SDL_RELEASED);
+		}
+	}
+
+	/* Joystick button E to H buttons */
+	/*
+	Button E: Axis 2 X Left
+	Button F: Axis 2 Y Up
+	Button G: Axis 2 X Right
+	Button H: Axis 2 Y Down
+	*/
+	if (joystick->nbuttons >= 5)
+	{
+		if (stGameStatus.curdata.B.x < SYS_JoyData[index].buttoncalc[0]) SDL_PrivateJoystickButton(joystick, (Uint8)4, SDL_PRESSED);
+		else SDL_PrivateJoystickButton(joystick, (Uint8)4, SDL_RELEASED);
+	}
+	if (joystick->nbuttons >= 6)
+	{
+		if (stGameStatus.curdata.B.y < SYS_JoyData[index].buttoncalc[1]) SDL_PrivateJoystickButton(joystick, (Uint8)5, SDL_PRESSED);
+		else SDL_PrivateJoystickButton(joystick, (Uint8)5, SDL_RELEASED);
+	}
+	if (joystick->nbuttons >= 7)
+	{
+		if (stGameStatus.curdata.B.x > SYS_JoyData[index].buttoncalc[2]) SDL_PrivateJoystickButton(joystick, (Uint8)6, SDL_PRESSED);
+		else SDL_PrivateJoystickButton(joystick, (Uint8)6, SDL_RELEASED);
+	}
+	if (joystick->nbuttons >= 8)
+	{
+		if (stGameStatus.curdata.B.y > SYS_JoyData[index].buttoncalc[3]) SDL_PrivateJoystickButton(joystick, (Uint8)7, SDL_PRESSED);
+		else SDL_PrivateJoystickButton(joystick, (Uint8)7, SDL_RELEASED);
+	}
+
+	/* joystick hat events */
+	/* Not Supported under OS/2 */
+	/* joystick ball events */
+	/* Not Supported under OS/2 */
+}
+
+/******************************************/
+/* Function to close a joystick after use */
+/******************************************/
+static void OS2_JoystickClose(SDL_Joystick *joystick)
+{
+	/* free system specific hardware data */
+	SDL_free(joystick->hwdata);
+}
+
+/********************************************************************/
+/* Function to perform any system-specific joystick related cleanup */
+/********************************************************************/
+static void OS2_JoystickQuit(void)
+{
+	joyPortClose(&hJoyPort);
+}
+
+static SDL_bool OS2_JoystickGetGamepadMapping(int device_index, SDL_GamepadMapping *out)
+{
+	return SDL_FALSE;
+}
+
+
+/************************/
+/* OS/2 Implementations */
+/************************/
+
+/*****************************************/
+/* Open Joystick Port, if not opened yet */
+/*****************************************/
+static int joyPortOpen(HFILE * hGame)
+{
+	APIRET	rc;				/* Generic Return Code */
+	ULONG		ulAction;		/* ? */
+	ULONG		ulVersion;		/* Version of joystick driver */
+	ULONG		ulDataLen;		/* Size of version data */
+
+	/* Verifies if joyport is not already open... */
+	if (*hGame != NULLHANDLE) return 0;
+
+	/* Open GAME$ for read */
+	rc = DosOpen("GAME$   ", hGame, &ulAction, 0, FILE_READONLY,
+		     FILE_OPEN, OPEN_ACCESS_READONLY | OPEN_SHARE_DENYNONE, NULL);
+	if (rc != 0)
+	{
+		return SDL_SetError("Could not open Joystick Port.");
+	}
+
+	/* Get Joystick Driver Version... must be 2.0 or higher */
+	ulVersion = 0;
+	ulDataLen = sizeof(ulVersion);
+	rc = DosDevIOCtl(*hGame, IOCTL_CAT_USER, GAME_GET_VERSION,
+			 NULL, 0, NULL, &ulVersion, ulDataLen, &ulDataLen);
+	if (rc != 0)
+	{
+		joyPortClose(hGame);
+		return SDL_SetError("Could not get Joystick Driver version.");
+	}
+	if (ulVersion < 0x20)
+	{
+		joyPortClose(hGame);
+		return SDL_SetError("Driver too old. At least IBM driver version 2.0 required.");
+	}
+	return 0;
+}
+
+/****************************/
+/* Close JoyPort, if opened */
+/****************************/
+static void joyPortClose(HFILE * hGame)
+{
+	if (*hGame != NULLHANDLE) DosClose(*hGame);
+	*hGame = NULLHANDLE;
+}
+
+/***************************/
+/* Get SDL Joystick EnvVar */
+/***************************/
+static int joyGetEnv(struct _joycfg * joydata)
+{
+	const char *joyenv;		/* Pointer to tested character */
+	char tempnumber[5];		/* Temporary place to put numeric texts */
+
+	joyenv = SDL_getenv("SDL_OS2_JOYSTICK");
+	if (joyenv == NULL) return 0;
+
+	/* Joystick Environment is defined! */
+	while (*joyenv == ' ' && *joyenv != 0) joyenv++; /* jump spaces... */
+
+	/* If the string name starts with '... get if fully */
+	if (*joyenv == '\'') {
+		joyenv++;
+		joyenv += joyGetData(joyenv,joydata->name,'\'',sizeof(joydata->name));
+	}
+	/* If not, get it until the next space */
+	else if (*joyenv == '\"') {
+		joyenv++;
+		joyenv += joyGetData(joyenv,joydata->name,'\"',sizeof(joydata->name));
+	}
+	else {
+		joyenv += joyGetData(joyenv,joydata->name, ' ',sizeof(joydata->name));
+	}
+
+	/* Now get the number of axes */
+	while (*joyenv == ' ' && *joyenv != 0) joyenv++; /* jump spaces... */
+	joyenv += joyGetData(joyenv,tempnumber,' ',sizeof(tempnumber));
+	joydata->axes = SDL_atoi(tempnumber);
+
+	/* Now get the number of buttons */
+	while (*joyenv == ' ' && *joyenv != 0) joyenv++; /* jump spaces... */
+	joyenv += joyGetData(joyenv,tempnumber,' ',sizeof(tempnumber));
+	joydata->buttons = SDL_atoi(tempnumber);
+
+	/* Now get the number of hats */
+	while (*joyenv == ' ' && *joyenv != 0) joyenv++; /* jump spaces... */
+	joyenv += joyGetData(joyenv,tempnumber,' ',sizeof(tempnumber));
+	joydata->hats = SDL_atoi(tempnumber);
+
+	/* Now get the number of balls */
+	while (*joyenv==' ' && *joyenv != 0) joyenv++; /* jump spaces... */
+	joyenv += joyGetData(joyenv,tempnumber,' ',sizeof(tempnumber));
+	joydata->balls = SDL_atoi(tempnumber);
+	return 1;
+}
+
+/************************************************************************/
+/* Get a text from in the string starting in joyenv until it finds		*/
+/* the stopchar or maxchars is reached. The result is placed in name.	*/
+/************************************************************************/
+static int joyGetData(const char *joyenv, char *name, char stopchar, size_t maxchars)
+{
+	char *nameptr;			/* Pointer to the selected character */
+	int chcnt = 0;			/* Count how many characters where copied */
+
+	nameptr = name;
+	while (*joyenv!=stopchar && *joyenv!=0)
+	{
+		if (nameptr < (name + (maxchars-1)))
+		{
+			*nameptr = *joyenv; /* Only copy if smaller than maximum */
+			nameptr++;
+		}
+		chcnt++;
+		joyenv++;
+	}
+	if (*joyenv == stopchar)
+	{
+		joyenv++; /* Jump stopchar */
+		chcnt++;
+	}
+	*nameptr = 0; /* Mark last byte */
+	return chcnt;
+}
+
+SDL_JoystickDriver SDL_OS2_JoystickDriver =
+{
+	OS2_JoystickInit,
+	OS2_NumJoysticks,
+	OS2_JoystickDetect,
+	OS2_JoystickGetDeviceName,
+	OS2_JoystickGetDevicePlayerIndex,
+	OS2_JoystickSetDevicePlayerIndex,
+	OS2_JoystickGetDeviceGUID,
+	OS2_JoystickGetDeviceInstanceID,
+	OS2_JoystickOpen,
+	OS2_JoystickRumble,
+	OS2_JoystickRumbleTriggers,
+	OS2_JoystickGetCapabilities,
+	OS2_JoystickSetLED,
+	OS2_JoystickSendEffect,
+	OS2_JoystickSetSensorsEnabled,
+	OS2_JoystickUpdate,
+	OS2_JoystickClose,
+	OS2_JoystickQuit,
+	OS2_JoystickGetGamepadMapping
+};
+
+#endif /* SDL_JOYSTICK_OS2 */
diff --git a/Engine/lib/sdl/src/joystick/psp/SDL_sysjoystick.c b/Engine/lib/sdl/src/joystick/psp/SDL_sysjoystick.c
index 261e6a677..d71979560 100644
--- a/Engine/lib/sdl/src/joystick/psp/SDL_sysjoystick.c
+++ b/Engine/lib/sdl/src/joystick/psp/SDL_sysjoystick.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -63,10 +63,10 @@ static point c = { 78, 32767 };
 static point d = { 128, 32767 };
 
 /* simple linear interpolation between two points */
-static SDL_INLINE void lerp (point *dest, point *a, point *b, float t)
+static SDL_INLINE void lerp (point *dest, point *pt_a, point *pt_b, float t)
 {
-    dest->x = a->x + (b->x - a->x)*t;
-    dest->y = a->y + (b->y - a->y)*t;
+    dest->x = pt_a->x + (pt_b->x - pt_a->x)*t;
+    dest->y = pt_a->y + (pt_b->y - pt_a->y)*t;
 }
 
 /* evaluate a point on a bezier-curve. t goes from 0 to 1.0 */
@@ -103,7 +103,7 @@ int JoystickUpdate(void *data)
  * Joystick 0 should be the system default joystick.
  * It should return number of joysticks, or -1 on an unrecoverable fatal error.
  */
-int SDL_SYS_JoystickInit(void)
+static int PSP_JoystickInit(void)
 {
     int i;
 
@@ -132,35 +132,55 @@ int SDL_SYS_JoystickInit(void)
     return 1;
 }
 
-int SDL_SYS_NumJoysticks(void)
+static int PSP_NumJoysticks(void)
 {
     return 1;
 }
 
-void SDL_SYS_JoystickDetect(void)
+static void PSP_JoystickDetect(void)
 {
 }
 
+#if 0
 /* Function to get the device-dependent name of a joystick */
-const char * SDL_SYS_JoystickNameForDeviceIndex(int device_index)
+static const char *PSP_JoystickName(int idx)
+{
+    if (idx == 0) return "PSP controller";
+    SDL_SetError("No joystick available with that index");
+    return NULL;
+}
+#endif
+
+/* Function to get the device-dependent name of a joystick */
+static const char *PSP_JoystickGetDeviceName(int device_index)
 {
     return "PSP builtin joypad";
 }
 
-/* Function to perform the mapping from device index to the instance id for this index */
-SDL_JoystickID SDL_SYS_GetInstanceIdOfDeviceIndex(int device_index)
+static int PSP_JoystickGetDevicePlayerIndex(int device_index)
 {
-    return device_index;
+    return -1;
 }
 
-/* Function to get the device-dependent name of a joystick */
-const char *SDL_SYS_JoystickName(int index)
+static void
+PSP_JoystickSetDevicePlayerIndex(int device_index, int player_index)
 {
-    if (index == 0)
-        return "PSP controller";
+}
 
-    SDL_SetError("No joystick available with that index");
-    return(NULL);
+static SDL_JoystickGUID PSP_JoystickGetDeviceGUID(int device_index)
+{
+    SDL_JoystickGUID guid;
+    /* the GUID is just the first 16 chars of the name for now */
+    const char *name = PSP_JoystickGetDeviceName(device_index);
+    SDL_zero(guid);
+    SDL_memcpy(&guid, name, SDL_min(sizeof(guid), SDL_strlen(name)));
+    return guid;
+}
+
+/* Function to perform the mapping from device index to the instance id for this index */
+static SDL_JoystickID PSP_JoystickGetDeviceInstanceID(int device_index)
+{
+    return device_index;
 }
 
 /* Function to open a joystick for use.
@@ -168,7 +188,7 @@ const char *SDL_SYS_JoystickName(int index)
    This should fill the nbuttons and naxes fields of the joystick structure.
    It returns 0, or -1 if there is an error.
  */
-int SDL_SYS_JoystickOpen(SDL_Joystick *joystick, int device_index)
+static int PSP_JoystickOpen(SDL_Joystick *joystick, int device_index)
 {
     joystick->nbuttons = 14;
     joystick->naxes = 2;
@@ -177,12 +197,46 @@ int SDL_SYS_JoystickOpen(SDL_Joystick *joystick, int device_index)
     return 0;
 }
 
+static int
+PSP_JoystickRumble(SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+{
+    return SDL_Unsupported();
+}
+
+static int
+PSP_JoystickRumbleTriggers(SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
+{
+    return SDL_Unsupported();
+}
+
+static Uint32 PSP_JoystickGetCapabilities(SDL_Joystick *joystick)
+{
+    return 0;
+}
+
+static int
+PSP_JoystickSetLED(SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+    return SDL_Unsupported();
+}
+
+static int
+PSP_JoystickSendEffect(SDL_Joystick *joystick, const void *data, int size)
+{
+    return SDL_Unsupported();
+}
+
+static int PSP_JoystickSetSensorsEnabled(SDL_Joystick *joystick, SDL_bool enabled)
+{
+    return SDL_Unsupported();
+}
+
 /* Function to update the state of a joystick - called as a device poll.
  * This function shouldn't update the joystick structure directly,
  * but instead should call SDL_PrivateJoystick*() to deliver events
  * and update joystick device state.
  */
-void SDL_SYS_JoystickUpdate(SDL_Joystick *joystick)
+static void PSP_JoystickUpdate(SDL_Joystick *joystick)
 {
     int i;
     enum PspCtrlButtons buttons;
@@ -225,12 +279,12 @@ void SDL_SYS_JoystickUpdate(SDL_Joystick *joystick)
 }
 
 /* Function to close a joystick after use */
-void SDL_SYS_JoystickClose(SDL_Joystick *joystick)
+static void PSP_JoystickClose(SDL_Joystick *joystick)
 {
 }
 
 /* Function to perform any system-specific joystick related cleanup */
-void SDL_SYS_JoystickQuit(void)
+static void PSP_JoystickQuit(void)
 {
     /* Cleanup Threads and Semaphore. */
     running = 0;
@@ -238,25 +292,34 @@ void SDL_SYS_JoystickQuit(void)
     SDL_DestroySemaphore(pad_sem);
 }
 
-SDL_JoystickGUID SDL_SYS_JoystickGetDeviceGUID( int device_index )
+static SDL_bool
+PSP_JoystickGetGamepadMapping(int device_index, SDL_GamepadMapping *out)
 {
-    SDL_JoystickGUID guid;
-    /* the GUID is just the first 16 chars of the name for now */
-    const char *name = SDL_SYS_JoystickNameForDeviceIndex( device_index );
-    SDL_zero( guid );
-    SDL_memcpy( &guid, name, SDL_min( sizeof(guid), SDL_strlen( name ) ) );
-    return guid;
+    return SDL_FALSE;
 }
 
-SDL_JoystickGUID SDL_SYS_JoystickGetGUID(SDL_Joystick * joystick)
+SDL_JoystickDriver SDL_PSP_JoystickDriver =
 {
-    SDL_JoystickGUID guid;
-    /* the GUID is just the first 16 chars of the name for now */
-    const char *name = joystick->name;
-    SDL_zero( guid );
-    SDL_memcpy( &guid, name, SDL_min( sizeof(guid), SDL_strlen( name ) ) );
-    return guid;
-}
+    PSP_JoystickInit,
+    PSP_NumJoysticks,
+    PSP_JoystickDetect,
+    PSP_JoystickGetDeviceName,
+    PSP_JoystickGetDevicePlayerIndex,
+    PSP_JoystickSetDevicePlayerIndex,
+    PSP_JoystickGetDeviceGUID,
+    PSP_JoystickGetDeviceInstanceID,
+    PSP_JoystickOpen,
+    PSP_JoystickRumble,
+    PSP_JoystickRumbleTriggers,
+    PSP_JoystickGetCapabilities,
+    PSP_JoystickSetLED,
+    PSP_JoystickSendEffect,
+    PSP_JoystickSetSensorsEnabled,
+    PSP_JoystickUpdate,
+    PSP_JoystickClose,
+    PSP_JoystickQuit,
+    PSP_JoystickGetGamepadMapping
+};
 
 #endif /* SDL_JOYSTICK_PSP */
 
diff --git a/Engine/lib/sdl/src/joystick/sort_controllers.py b/Engine/lib/sdl/src/joystick/sort_controllers.py
index 084260965..bcd05f6a4 100755
--- a/Engine/lib/sdl/src/joystick/sort_controllers.py
+++ b/Engine/lib/sdl/src/joystick/sort_controllers.py
@@ -67,7 +67,7 @@ def write_controllers():
     for entry in sorted(controllers, key=lambda entry: entry[2]+"-"+entry[1]):
         line = "".join(entry) + "\n"
         line = line.replace("\t", "    ")
-        if not line.endswith(",\n") and not line.endswith("*/\n"):
+        if not line.endswith(",\n") and not line.endswith("*/\n") and not line.endswith(",\r\n") and not line.endswith("*/\r\n"):
             print("Warning: '%s' is missing a comma at the end of the line" % (line))
         output.write(line)
 
diff --git a/Engine/lib/sdl/src/joystick/steam/SDL_steamcontroller.c b/Engine/lib/sdl/src/joystick/steam/SDL_steamcontroller.c
index 82656f4ed..52511fbea 100644
--- a/Engine/lib/sdl/src/joystick/steam/SDL_steamcontroller.c
+++ b/Engine/lib/sdl/src/joystick/steam/SDL_steamcontroller.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/joystick/steam/SDL_steamcontroller.h b/Engine/lib/sdl/src/joystick/steam/SDL_steamcontroller.h
index 629d6875e..f740693ff 100644
--- a/Engine/lib/sdl/src/joystick/steam/SDL_steamcontroller.h
+++ b/Engine/lib/sdl/src/joystick/steam/SDL_steamcontroller.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/joystick/usb_ids.h b/Engine/lib/sdl/src/joystick/usb_ids.h
index c39ff6919..97f37b0f8 100644
--- a/Engine/lib/sdl/src/joystick/usb_ids.h
+++ b/Engine/lib/sdl/src/joystick/usb_ids.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -24,36 +24,61 @@
 
 /* Definitions of useful USB VID/PID values */
 
+#define USB_VENDOR_AMAZON       0x1949
 #define USB_VENDOR_APPLE        0x05ac
+#define USB_VENDOR_GOOGLE       0x18d1
 #define USB_VENDOR_HYPERKIN     0x2e24
 #define USB_VENDOR_MICROSOFT    0x045e
 #define USB_VENDOR_NINTENDO     0x057e
 #define USB_VENDOR_NVIDIA       0x0955
 #define USB_VENDOR_PDP          0x0e6f
 #define USB_VENDOR_POWERA       0x24c6
-#define USB_VENDOR_SONY         0x054c
+#define USB_VENDOR_POWERA_ALT   0x20d6
 #define USB_VENDOR_RAZER        0x1532
+#define USB_VENDOR_SHENZHEN     0x0079
+#define USB_VENDOR_SONY         0x054c
 #define USB_VENDOR_VALVE        0x28de
 
-#define USB_PRODUCT_NINTENDO_GAMECUBE_ADAPTER           0x0337
-#define USB_PRODUCT_NINTENDO_SWITCH_PRO                 0x2009
-#define USB_PRODUCT_RAZER_PANTHERA                      0x0401
-#define USB_PRODUCT_RAZER_PANTHERA_EVO                  0x1008
-#define USB_PRODUCT_RAZER_ATROX                         0x0a00
-#define USB_PRODUCT_SONY_DS4                            0x05c4
-#define USB_PRODUCT_SONY_DS4_DONGLE                     0x0ba0
-#define USB_PRODUCT_SONY_DS4_SLIM                       0x09cc
-#define USB_PRODUCT_SONY_DS5                            0x0ce6
-#define USB_PRODUCT_XBOX_ONE_ELITE_SERIES_1             0x02e3
-#define USB_PRODUCT_XBOX_ONE_ELITE_SERIES_2             0x0b00
-#define USB_PRODUCT_XBOX_ONE_ELITE_SERIES_2_BLUETOOTH   0x0b05
-#define USB_PRODUCT_XBOX_ONE_S                          0x02ea
-#define USB_PRODUCT_XBOX_ONE_S_REV1_BLUETOOTH           0x02e0
-#define USB_PRODUCT_XBOX_ONE_S_REV2_BLUETOOTH           0x02fd
-#define USB_PRODUCT_XBOX_ONE_SERIES_X                   0x0b12
-#define USB_PRODUCT_XBOX_ONE_SERIES_X_BLUETOOTH         0x0b13
-#define USB_PRODUCT_XBOX_ONE_RAW_INPUT_CONTROLLER       0x02ff
-#define USB_PRODUCT_XBOX_ONE_XINPUT_CONTROLLER          0x02fe    /* Made up product ID for XInput */
+#define USB_PRODUCT_AMAZON_LUNA_CONTROLLER                  0x0419
+#define USB_PRODUCT_GOOGLE_STADIA_CONTROLLER                0x9400
+#define USB_PRODUCT_EVORETRO_GAMECUBE_ADAPTER               0x1846
+#define USB_PRODUCT_NINTENDO_GAMECUBE_ADAPTER               0x0337
+#define USB_PRODUCT_NINTENDO_SWITCH_PRO                     0x2009
+#define USB_PRODUCT_NINTENDO_SWITCH_JOY_CON_LEFT            0x2006
+#define USB_PRODUCT_NINTENDO_SWITCH_JOY_CON_RIGHT           0x2007
+#define USB_PRODUCT_NINTENDO_SWITCH_JOY_CON_GRIP            0x200e
+#define USB_PRODUCT_RAZER_PANTHERA                          0x0401
+#define USB_PRODUCT_RAZER_PANTHERA_EVO                      0x1008
+#define USB_PRODUCT_RAZER_ATROX                             0x0a00
+#define USB_PRODUCT_SONY_DS4                                0x05c4
+#define USB_PRODUCT_SONY_DS4_DONGLE                         0x0ba0
+#define USB_PRODUCT_SONY_DS4_SLIM                           0x09cc
+#define USB_PRODUCT_SONY_DS5                                0x0ce6
+#define USB_PRODUCT_VICTRIX_FS_PRO_V2                       0x0207
+#define USB_PRODUCT_XBOX360_XUSB_CONTROLLER                 0x02a1    /* XUSB driver software PID */
+#define USB_PRODUCT_XBOX360_WIRED_CONTROLLER                0x028e
+#define USB_PRODUCT_XBOX360_WIRELESS_RECEIVER               0x0719
+#define USB_PRODUCT_XBOX_ONE_ADAPTIVE                       0x0b0a
+#define USB_PRODUCT_XBOX_ONE_ADAPTIVE_BLUETOOTH             0x0b0c
+#define USB_PRODUCT_XBOX_ONE_ADAPTIVE_BLE                   0x0b21
+#define USB_PRODUCT_XBOX_ONE_ELITE_SERIES_1                 0x02e3
+#define USB_PRODUCT_XBOX_ONE_ELITE_SERIES_2                 0x0b00
+#define USB_PRODUCT_XBOX_ONE_ELITE_SERIES_2_BLUETOOTH       0x0b05
+#define USB_PRODUCT_XBOX_ONE_ELITE_SERIES_2_BLE             0x0b22
+#define USB_PRODUCT_XBOX_ONE_S                              0x02ea
+#define USB_PRODUCT_XBOX_ONE_S_REV1_BLUETOOTH               0x02e0
+#define USB_PRODUCT_XBOX_ONE_S_REV2_BLUETOOTH               0x02fd
+#define USB_PRODUCT_XBOX_ONE_S_REV2_BLE                     0x0b20
+#define USB_PRODUCT_XBOX_SERIES_X                           0x0b12
+#define USB_PRODUCT_XBOX_SERIES_X_BLE                       0x0b13
+#define USB_PRODUCT_XBOX_SERIES_X_VICTRIX_GAMBIT            0x02d6
+#define USB_PRODUCT_XBOX_SERIES_X_PDP_BLUE                  0x02d9
+#define USB_PRODUCT_XBOX_SERIES_X_PDP_AFTERGLOW             0x02da
+#define USB_PRODUCT_XBOX_SERIES_X_POWERA_FUSION_PRO2        0x4001
+#define USB_PRODUCT_XBOX_SERIES_X_POWERA_SPECTRA            0x4002
+#define USB_PRODUCT_XBOX_ONE_XBOXGIP_CONTROLLER             0x02ff    /* XBOXGIP driver software PID */
+#define USB_PRODUCT_XBOX_ONE_XINPUT_CONTROLLER              0x02fe    /* Made up product ID for XInput */
+#define USB_PRODUCT_STEAM_VIRTUAL_GAMEPAD                   0x11ff
 
 /* USB usage pages */
 #define USB_USAGEPAGE_GENERIC_DESKTOP   0x0001
@@ -78,6 +103,12 @@
 #define USB_USAGE_GENERIC_WHEEL                 0x0038
 #define USB_USAGE_GENERIC_HAT                   0x0039
 
+/* Bluetooth SIG assigned Company Identifiers
+   https://www.bluetooth.com/specifications/assigned-numbers/company-identifiers/ */
+#define BLUETOOTH_VENDOR_AMAZON                 0x0171
+
+#define BLUETOOTH_PRODUCT_LUNA_CONTROLLER       0x0419
+
 #endif /* usb_ids_h_ */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/joystick/virtual/SDL_virtualjoystick.c b/Engine/lib/sdl/src/joystick/virtual/SDL_virtualjoystick.c
index e140b4fa0..508dd80f9 100644
--- a/Engine/lib/sdl/src/joystick/virtual/SDL_virtualjoystick.c
+++ b/Engine/lib/sdl/src/joystick/virtual/SDL_virtualjoystick.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -164,7 +164,7 @@ SDL_JoystickDetachVirtualInner(int device_index)
 
 
 int
-SDL_JoystickSetVirtualAxisInner(SDL_Joystick * joystick, int axis, Sint16 value)
+SDL_JoystickSetVirtualAxisInner(SDL_Joystick *joystick, int axis, Sint16 value)
 {
     joystick_hwdata *hwdata;
 
@@ -176,7 +176,7 @@ SDL_JoystickSetVirtualAxisInner(SDL_Joystick * joystick, int axis, Sint16 value)
     }
 
     hwdata = (joystick_hwdata *)joystick->hwdata;
-    if (axis < 0 || axis >= hwdata->nbuttons) {
+    if (axis < 0 || axis >= hwdata->naxes) {
         SDL_UnlockJoysticks();
         return SDL_SetError("Invalid axis index");
     }
@@ -189,7 +189,7 @@ SDL_JoystickSetVirtualAxisInner(SDL_Joystick * joystick, int axis, Sint16 value)
 
 
 int
-SDL_JoystickSetVirtualButtonInner(SDL_Joystick * joystick, int button, Uint8 value)
+SDL_JoystickSetVirtualButtonInner(SDL_Joystick *joystick, int button, Uint8 value)
 {
     joystick_hwdata *hwdata;
 
@@ -214,7 +214,7 @@ SDL_JoystickSetVirtualButtonInner(SDL_Joystick * joystick, int button, Uint8 val
 
 
 int
-SDL_JoystickSetVirtualHatInner(SDL_Joystick * joystick, int hat, Uint8 value)
+SDL_JoystickSetVirtualHatInner(SDL_Joystick *joystick, int hat, Uint8 value)
 {
     joystick_hwdata *hwdata;
 
@@ -226,7 +226,7 @@ SDL_JoystickSetVirtualHatInner(SDL_Joystick * joystick, int hat, Uint8 value)
     }
 
     hwdata = (joystick_hwdata *)joystick->hwdata;
-    if (hat < 0 || hat >= hwdata->nbuttons) {
+    if (hat < 0 || hat >= hwdata->nhats) {
         SDL_UnlockJoysticks();
         return SDL_SetError("Invalid hat index");
     }
@@ -313,7 +313,7 @@ VIRTUAL_JoystickGetDeviceInstanceID(int device_index)
 
 
 static int
-VIRTUAL_JoystickOpen(SDL_Joystick * joystick, int device_index)
+VIRTUAL_JoystickOpen(SDL_Joystick *joystick, int device_index)
 {
     joystick_hwdata *hwdata = VIRTUAL_HWDataForIndex(device_index);
     if (!hwdata) {
@@ -333,27 +333,33 @@ VIRTUAL_JoystickOpen(SDL_Joystick * joystick, int device_index)
 
 
 static int
-VIRTUAL_JoystickRumble(SDL_Joystick * joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+VIRTUAL_JoystickRumble(SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
 {
     return SDL_Unsupported();
 }
 
 static int
-VIRTUAL_JoystickRumbleTriggers(SDL_Joystick * joystick, Uint16 left_rumble, Uint16 right_rumble)
+VIRTUAL_JoystickRumbleTriggers(SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
 {
     return SDL_Unsupported();
 }
 
 
-static SDL_bool
-VIRTUAL_JoystickHasLED(SDL_Joystick * joystick)
+static Uint32
+VIRTUAL_JoystickGetCapabilities(SDL_Joystick *joystick)
 {
-    return SDL_FALSE;
+    return 0;
 }
 
 
 static int
-VIRTUAL_JoystickSetLED(SDL_Joystick * joystick, Uint8 red, Uint8 green, Uint8 blue)
+VIRTUAL_JoystickSetLED(SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+    return SDL_Unsupported();
+}
+
+static int
+VIRTUAL_JoystickSendEffect(SDL_Joystick *joystick, const void *data, int size)
 {
     return SDL_Unsupported();
 }
@@ -366,7 +372,7 @@ VIRTUAL_JoystickSetSensorsEnabled(SDL_Joystick *joystick, SDL_bool enabled)
 
 
 static void
-VIRTUAL_JoystickUpdate(SDL_Joystick * joystick)
+VIRTUAL_JoystickUpdate(SDL_Joystick *joystick)
 {
     joystick_hwdata *hwdata;
     int i;
@@ -393,7 +399,7 @@ VIRTUAL_JoystickUpdate(SDL_Joystick * joystick)
 
 
 static void
-VIRTUAL_JoystickClose(SDL_Joystick * joystick)
+VIRTUAL_JoystickClose(SDL_Joystick *joystick)
 {
     joystick_hwdata *hwdata;
 
@@ -436,8 +442,9 @@ SDL_JoystickDriver SDL_VIRTUAL_JoystickDriver =
     VIRTUAL_JoystickOpen,
     VIRTUAL_JoystickRumble,
     VIRTUAL_JoystickRumbleTriggers,
-    VIRTUAL_JoystickHasLED,
+    VIRTUAL_JoystickGetCapabilities,
     VIRTUAL_JoystickSetLED,
+    VIRTUAL_JoystickSendEffect,
     VIRTUAL_JoystickSetSensorsEnabled,
     VIRTUAL_JoystickUpdate,
     VIRTUAL_JoystickClose,
@@ -445,6 +452,6 @@ SDL_JoystickDriver SDL_VIRTUAL_JoystickDriver =
     VIRTUAL_JoystickGetGamepadMapping
 };
 
-#endif /* SDL_JOYSTICK_VIRTUAL || SDL_JOYSTICK_DISABLED */
+#endif /* SDL_JOYSTICK_VIRTUAL */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/joystick/virtual/SDL_virtualjoystick_c.h b/Engine/lib/sdl/src/joystick/virtual/SDL_virtualjoystick_c.h
index 654fdc5ba..b251c2d14 100644
--- a/Engine/lib/sdl/src/joystick/virtual/SDL_virtualjoystick_c.h
+++ b/Engine/lib/sdl/src/joystick/virtual/SDL_virtualjoystick_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/joystick/vita/SDL_sysjoystick.c b/Engine/lib/sdl/src/joystick/vita/SDL_sysjoystick.c
new file mode 100644
index 000000000..aa52cd77f
--- /dev/null
+++ b/Engine/lib/sdl/src/joystick/vita/SDL_sysjoystick.c
@@ -0,0 +1,425 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if SDL_JOYSTICK_VITA
+
+/* This is the PSVita implementation of the SDL joystick API */
+#include <psp2/types.h>
+#include <psp2/ctrl.h>
+#include <psp2/kernel/threadmgr.h>
+
+#include <stdio.h>      /* For the definition of NULL */
+#include <stdlib.h>
+
+#include "../SDL_sysjoystick.h"
+#include "../SDL_joystick_c.h"
+
+#include "SDL_events.h"
+#include "SDL_error.h"
+#include "SDL_thread.h"
+#include "SDL_mutex.h"
+#include "SDL_timer.h"
+
+/* Current pad state */
+static SceCtrlData pad0 = { .lx = 0, .ly = 0, .rx = 0, .ry = 0, .lt = 0, .rt = 0, .buttons = 0 };
+static SceCtrlData pad1 = { .lx = 0, .ly = 0, .rx = 0, .ry = 0, .lt = 0, .rt = 0, .buttons = 0 };
+static SceCtrlData pad2 = { .lx = 0, .ly = 0, .rx = 0, .ry = 0, .lt = 0, .rt = 0, .buttons = 0 };
+static SceCtrlData pad3 = { .lx = 0, .ly = 0, .rx = 0, .ry = 0, .lt = 0, .rt = 0, .buttons = 0 };
+
+static int port_map[4]= { 0, 2, 3, 4 }; //index: SDL joy number, entry: Vita port number
+static int ext_port_map[4]= { 1, 2, 3, 4 }; //index: SDL joy number, entry: Vita port number. For external controllers
+
+static int SDL_numjoysticks = 1;
+
+static const unsigned int button_map[] = {
+    SCE_CTRL_TRIANGLE,
+    SCE_CTRL_CIRCLE,
+    SCE_CTRL_CROSS,
+    SCE_CTRL_SQUARE,
+    SCE_CTRL_LTRIGGER,
+    SCE_CTRL_RTRIGGER,
+    SCE_CTRL_DOWN,
+    SCE_CTRL_LEFT,
+    SCE_CTRL_UP,
+    SCE_CTRL_RIGHT,
+    SCE_CTRL_SELECT,
+    SCE_CTRL_START
+};
+
+static const unsigned int ext_button_map[] = {
+    SCE_CTRL_TRIANGLE,
+    SCE_CTRL_CIRCLE,
+    SCE_CTRL_CROSS,
+    SCE_CTRL_SQUARE,
+    SCE_CTRL_L1,
+    SCE_CTRL_R1,
+    SCE_CTRL_DOWN,
+    SCE_CTRL_LEFT,
+    SCE_CTRL_UP,
+    SCE_CTRL_RIGHT,
+    SCE_CTRL_SELECT,
+    SCE_CTRL_START,
+    SCE_CTRL_L2,
+    SCE_CTRL_R2,
+    SCE_CTRL_L3,
+    SCE_CTRL_R3
+};
+
+static int analog_map[256];  /* Map analog inputs to -32768 -> 32767 */
+
+typedef struct
+{
+  int x;
+  int y;
+} point;
+
+/* 4 points define the bezier-curve. */
+/* The Vita has a good amount of analog travel, so use a linear curve */
+static point a = { 0, 0 };
+static point b = { 0, 0  };
+static point c = { 128, 32767 };
+static point d = { 128, 32767 };
+
+/* simple linear interpolation between two points */
+static SDL_INLINE void lerp (point *dest, point *first, point *second, float t)
+{
+    dest->x = first->x + (second->x - first->x) * t;
+    dest->y = first->y + (second->y - first->y) * t;
+}
+
+/* evaluate a point on a bezier-curve. t goes from 0 to 1.0 */
+static int calc_bezier_y(float t)
+{
+    point ab, bc, cd, abbc, bccd, dest;
+    lerp (&ab, &a, &b, t);           /* point between a and b */
+    lerp (&bc, &b, &c, t);           /* point between b and c */
+    lerp (&cd, &c, &d, t);           /* point between c and d */
+    lerp (&abbc, &ab, &bc, t);       /* point between ab and bc */
+    lerp (&bccd, &bc, &cd, t);       /* point between bc and cd */
+    lerp (&dest, &abbc, &bccd, t);   /* point on the bezier-curve */
+    return dest.y;
+}
+
+/* Function to scan the system for joysticks.
+ * Joystick 0 should be the system default joystick.
+ * It should return number of joysticks, or -1 on an unrecoverable fatal error.
+ */
+int VITA_JoystickInit(void)
+{
+    int i;
+    SceCtrlPortInfo myPortInfo;
+
+    /* Setup input */
+    sceCtrlSetSamplingMode(SCE_CTRL_MODE_ANALOG_WIDE);
+    sceCtrlSetSamplingModeExt(SCE_CTRL_MODE_ANALOG_WIDE);
+
+    /* Create an accurate map from analog inputs (0 to 255)
+       to SDL joystick positions (-32768 to 32767) */
+    for (i = 0; i < 128; i++)
+    {
+        float t = (float)i/127.0f;
+        analog_map[i+128] = calc_bezier_y(t);
+        analog_map[127-i] = -1 * analog_map[i+128];
+    }
+
+    // Assume we have at least one controller, even when nothing is paired
+    // This way the user can jump in, pair a controller
+    // and control things immediately even if it is paired
+    // after the app has already started.
+
+    SDL_numjoysticks = 1;
+    SDL_PrivateJoystickAdded(0);
+    // How many additional paired controllers are there?
+    sceCtrlGetControllerPortInfo(&myPortInfo);
+
+    // On Vita TV, port 0 and 1 are the same controller
+    // and that is the first one, so start at port 2
+    for (i=2; i<=4; i++)
+    {
+        if (myPortInfo.port[i]!=SCE_CTRL_TYPE_UNPAIRED)
+        {
+            SDL_PrivateJoystickAdded(SDL_numjoysticks);
+            SDL_numjoysticks++;
+        }
+    }
+    return SDL_numjoysticks;
+}
+
+int VITA_JoystickGetCount()
+{
+    return SDL_numjoysticks;
+}
+
+void VITA_JoystickDetect()
+{
+}
+
+/* Function to perform the mapping from device index to the instance id for this index */
+SDL_JoystickID VITA_JoystickGetDeviceInstanceID(int device_index)
+{
+    return device_index;
+}
+
+/* Function to get the device-dependent name of a joystick */
+const char *VITA_JoystickGetDeviceName(int index)
+{
+    if (index == 0)
+        return "PSVita Controller";
+
+    if (index == 1)
+        return "PSVita Controller";
+
+    if (index == 2)
+        return "PSVita Controller";
+
+    if (index == 3)
+        return "PSVita Controller";
+
+    SDL_SetError("No joystick available with that index");
+    return(NULL);
+}
+
+static int
+VITA_JoystickGetDevicePlayerIndex(int device_index)
+{
+    return -1;
+}
+
+static void
+VITA_JoystickSetDevicePlayerIndex(int device_index, int player_index)
+{
+}
+
+/* Function to open a joystick for use.
+   The joystick to open is specified by the device index.
+   This should fill the nbuttons and naxes fields of the joystick structure.
+   It returns 0, or -1 if there is an error.
+ */
+int VITA_JoystickOpen(SDL_Joystick *joystick, int device_index)
+{
+    joystick->nbuttons = SDL_arraysize(ext_button_map);
+    joystick->naxes = 6;
+    joystick->nhats = 0;
+    joystick->instance_id = device_index;
+
+    return 0;
+}
+
+/* Function to update the state of a joystick - called as a device poll.
+ * This function shouldn't update the joystick structure directly,
+ * but instead should call SDL_PrivateJoystick*() to deliver events
+ * and update joystick device state.
+ */
+static void VITA_JoystickUpdate(SDL_Joystick *joystick)
+{
+    int i;
+    unsigned int buttons;
+    unsigned int changed;
+    unsigned char lx, ly, rx, ry, lt, rt;
+    static unsigned int old_buttons[] = { 0, 0, 0, 0 };
+    static unsigned char old_lx[] = { 0, 0, 0, 0 };
+    static unsigned char old_ly[] = { 0, 0, 0, 0 };
+    static unsigned char old_rx[] = { 0, 0, 0, 0 };
+    static unsigned char old_ry[] = { 0, 0, 0, 0 };
+    static unsigned char old_lt[] = { 0, 0, 0, 0 };
+    static unsigned char old_rt[] = { 0, 0, 0, 0 };
+    SceCtrlData *pad = NULL;
+    SDL_bool fallback = SDL_FALSE;
+
+    int index = (int) SDL_JoystickInstanceID(joystick);
+
+    if (index == 0) pad = &pad0;
+    else if (index == 1) pad = &pad1;
+    else if (index == 2) pad = &pad2;
+    else if (index == 3) pad = &pad3;
+    else return;
+
+    if (index == 0) {
+        if (sceCtrlPeekBufferPositiveExt2(ext_port_map[index], pad, 1) < 0) {
+            // on vita fallback to port 0
+            sceCtrlPeekBufferPositive(port_map[index], pad, 1);
+            fallback = SDL_TRUE;
+        }
+    } else {
+        sceCtrlPeekBufferPositiveExt2(ext_port_map[index], pad, 1);
+    }
+
+    buttons = pad->buttons;
+
+    lx = pad->lx;
+    ly = pad->ly;
+    rx = pad->rx;
+    ry = pad->ry;
+    lt = pad->lt;
+    rt = pad->rt;
+
+    // Axes
+
+    if (old_lx[index] != lx) {
+        SDL_PrivateJoystickAxis(joystick, 0, analog_map[lx]);
+        old_lx[index] = lx;
+    }
+    if (old_ly[index] != ly) {
+        SDL_PrivateJoystickAxis(joystick, 1, analog_map[ly]);
+        old_ly[index] = ly;
+    }
+    if (old_rx[index] != rx) {
+        SDL_PrivateJoystickAxis(joystick, 2, analog_map[rx]);
+        old_rx[index] = rx;
+    }
+    if (old_ry[index] != ry) {
+        SDL_PrivateJoystickAxis(joystick, 3, analog_map[ry]);
+        old_ry[index] = ry;
+    }
+
+    if (old_lt[index] != lt) {
+        SDL_PrivateJoystickAxis(joystick, 4, analog_map[lt]);
+        old_lt[index] = lt;
+    }
+    if (old_rt[index] != rt) {
+        SDL_PrivateJoystickAxis(joystick, 5, analog_map[rt]);
+        old_rt[index] = rt;
+    }
+
+    // Buttons
+    changed = old_buttons[index] ^ buttons;
+    old_buttons[index] = buttons;
+
+    if (changed) {
+        if (fallback) {
+            for (i = 0; i < SDL_arraysize(button_map); i++) {
+                if (changed & button_map[i]) {
+                    SDL_PrivateJoystickButton(
+                        joystick, i,
+                        (buttons & button_map[i]) ?
+                        SDL_PRESSED : SDL_RELEASED);
+                }
+            }
+        } else {
+            for (i = 0; i < SDL_arraysize(ext_button_map); i++) {
+                if (changed & ext_button_map[i]) {
+                    SDL_PrivateJoystickButton(
+                        joystick, i,
+                        (buttons & ext_button_map[i]) ?
+                        SDL_PRESSED : SDL_RELEASED);
+                }
+            }
+        }
+    }
+}
+
+/* Function to close a joystick after use */
+void VITA_JoystickClose(SDL_Joystick *joystick)
+{
+}
+
+/* Function to perform any system-specific joystick related cleanup */
+void VITA_JoystickQuit(void)
+{
+}
+
+SDL_JoystickGUID VITA_JoystickGetDeviceGUID( int device_index )
+{
+    SDL_JoystickGUID guid;
+    /* the GUID is just the first 16 chars of the name for now */
+    const char *name = VITA_JoystickGetDeviceName( device_index );
+    SDL_zero( guid );
+    SDL_memcpy( &guid, name, SDL_min( sizeof(guid), SDL_strlen( name ) ) );
+    return guid;
+}
+
+static int
+VITA_JoystickRumble(SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+{
+    int index = (int) SDL_JoystickInstanceID(joystick);
+    SceCtrlActuator act;
+    SDL_zero(act);
+
+    act.small = high_frequency_rumble / 256;
+    act.large = low_frequency_rumble / 256;
+    sceCtrlSetActuator(ext_port_map[index], &act);
+    return 0;
+}
+
+static int
+VITA_JoystickRumbleTriggers(SDL_Joystick *joystick, Uint16 left, Uint16 right)
+{
+    return SDL_Unsupported();
+}
+
+static Uint32
+VITA_JoystickGetCapabilities(SDL_Joystick *joystick)
+{
+    // always return LED and rumble supported for now
+    return SDL_JOYCAP_LED | SDL_JOYCAP_RUMBLE;
+}
+
+
+static int
+VITA_JoystickSetLED(SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+    int index = (int) SDL_JoystickInstanceID(joystick);
+    sceCtrlSetLightBar(ext_port_map[index], red, green, blue);
+    return 0;
+}
+
+static int
+VITA_JoystickSendEffect(SDL_Joystick *joystick, const void *data, int size)
+{
+    return SDL_Unsupported();
+}
+
+static int
+VITA_JoystickSetSensorsEnabled(SDL_Joystick *joystick, SDL_bool enabled)
+{
+    return SDL_Unsupported();
+}
+
+SDL_JoystickDriver SDL_VITA_JoystickDriver =
+{
+    VITA_JoystickInit,
+    VITA_JoystickGetCount,
+    VITA_JoystickDetect,
+    VITA_JoystickGetDeviceName,
+    VITA_JoystickGetDevicePlayerIndex,
+    VITA_JoystickSetDevicePlayerIndex,
+    VITA_JoystickGetDeviceGUID,
+    VITA_JoystickGetDeviceInstanceID,
+
+    VITA_JoystickOpen,
+
+    VITA_JoystickRumble,
+    VITA_JoystickRumbleTriggers,
+
+    VITA_JoystickGetCapabilities,
+    VITA_JoystickSetLED,
+    VITA_JoystickSendEffect,
+    VITA_JoystickSetSensorsEnabled,
+
+    VITA_JoystickUpdate,
+    VITA_JoystickClose,
+    VITA_JoystickQuit,
+};
+
+#endif /* SDL_JOYSTICK_VITA */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/joystick/windows/SDL_dinputjoystick.c b/Engine/lib/sdl/src/joystick/windows/SDL_dinputjoystick.c
index 6852910fb..c2f53a93f 100644
--- a/Engine/lib/sdl/src/joystick/windows/SDL_dinputjoystick.c
+++ b/Engine/lib/sdl/src/joystick/windows/SDL_dinputjoystick.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -34,7 +34,7 @@
 #define DIDFT_OPTIONAL      0x80000000
 #endif
 
-#define INPUT_QSIZE 32      /* Buffer up to 32 input messages */
+#define INPUT_QSIZE 128      /* Buffer up to 128 input messages */
 #define JOY_AXIS_THRESHOLD  (((SDL_JOYSTICK_AXIS_MAX)-(SDL_JOYSTICK_AXIS_MIN))/100)   /* 1% motion */
 
 #define CONVERT_MAGNITUDE(x)    (((x)*10000) / 0x7FFF)
@@ -45,19 +45,17 @@ extern HWND SDL_HelperWindow;
 /* local variables */
 static SDL_bool coinitialized = SDL_FALSE;
 static LPDIRECTINPUT8 dinput = NULL;
-static PRAWINPUTDEVICELIST SDL_RawDevList = NULL;
-static UINT SDL_RawDevListCount = 0;
 
 /* Taken from Wine - Thanks! */
 static DIOBJECTDATAFORMAT dfDIJoystick2[] = {
-    { &GUID_XAxis, DIJOFS_X, DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_YAxis, DIJOFS_Y, DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_ZAxis, DIJOFS_Z, DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_RxAxis, DIJOFS_RX, DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_RyAxis, DIJOFS_RY, DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_RzAxis, DIJOFS_RZ, DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_Slider, DIJOFS_SLIDER(0), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_Slider, DIJOFS_SLIDER(1), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
+    { &GUID_XAxis, DIJOFS_X, DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTPOSITION },
+    { &GUID_YAxis, DIJOFS_Y, DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTPOSITION },
+    { &GUID_ZAxis, DIJOFS_Z, DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTPOSITION },
+    { &GUID_RxAxis, DIJOFS_RX, DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTPOSITION },
+    { &GUID_RyAxis, DIJOFS_RY, DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTPOSITION },
+    { &GUID_RzAxis, DIJOFS_RZ, DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTPOSITION },
+    { &GUID_Slider, DIJOFS_SLIDER(0), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTPOSITION },
+    { &GUID_Slider, DIJOFS_SLIDER(1), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTPOSITION },
     { &GUID_POV, DIJOFS_POV(0), DIDFT_OPTIONAL | DIDFT_POV | DIDFT_ANYINSTANCE, 0 },
     { &GUID_POV, DIJOFS_POV(1), DIDFT_OPTIONAL | DIDFT_POV | DIDFT_ANYINSTANCE, 0 },
     { &GUID_POV, DIJOFS_POV(2), DIDFT_OPTIONAL | DIDFT_POV | DIDFT_ANYINSTANCE, 0 },
@@ -190,30 +188,33 @@ static DIOBJECTDATAFORMAT dfDIJoystick2[] = {
     { NULL, DIJOFS_BUTTON(125), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0 },
     { NULL, DIJOFS_BUTTON(126), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0 },
     { NULL, DIJOFS_BUTTON(127), DIDFT_OPTIONAL | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_XAxis, FIELD_OFFSET(DIJOYSTATE2, lVX), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_YAxis, FIELD_OFFSET(DIJOYSTATE2, lVY), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_ZAxis, FIELD_OFFSET(DIJOYSTATE2, lVZ), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_RxAxis, FIELD_OFFSET(DIJOYSTATE2, lVRx), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_RyAxis, FIELD_OFFSET(DIJOYSTATE2, lVRy), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_RzAxis, FIELD_OFFSET(DIJOYSTATE2, lVRz), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_Slider, FIELD_OFFSET(DIJOYSTATE2, rglVSlider[0]), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_Slider, FIELD_OFFSET(DIJOYSTATE2, rglVSlider[1]), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_XAxis, FIELD_OFFSET(DIJOYSTATE2, lAX), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_YAxis, FIELD_OFFSET(DIJOYSTATE2, lAY), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_ZAxis, FIELD_OFFSET(DIJOYSTATE2, lAZ), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_RxAxis, FIELD_OFFSET(DIJOYSTATE2, lARx), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_RyAxis, FIELD_OFFSET(DIJOYSTATE2, lARy), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_RzAxis, FIELD_OFFSET(DIJOYSTATE2, lARz), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_Slider, FIELD_OFFSET(DIJOYSTATE2, rglASlider[0]), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_Slider, FIELD_OFFSET(DIJOYSTATE2, rglASlider[1]), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_XAxis, FIELD_OFFSET(DIJOYSTATE2, lFX), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_YAxis, FIELD_OFFSET(DIJOYSTATE2, lFY), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_ZAxis, FIELD_OFFSET(DIJOYSTATE2, lFZ), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_RxAxis, FIELD_OFFSET(DIJOYSTATE2, lFRx), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_RyAxis, FIELD_OFFSET(DIJOYSTATE2, lFRy), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_RzAxis, FIELD_OFFSET(DIJOYSTATE2, lFRz), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_Slider, FIELD_OFFSET(DIJOYSTATE2, rglFSlider[0]), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
-    { &GUID_Slider, FIELD_OFFSET(DIJOYSTATE2, rglFSlider[1]), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, 0 },
+    { &GUID_XAxis, FIELD_OFFSET(DIJOYSTATE2, lVX), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTVELOCITY },
+    { &GUID_YAxis, FIELD_OFFSET(DIJOYSTATE2, lVY), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTVELOCITY },
+    { &GUID_ZAxis, FIELD_OFFSET(DIJOYSTATE2, lVZ), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTVELOCITY },
+    { &GUID_RxAxis, FIELD_OFFSET(DIJOYSTATE2, lVRx), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTVELOCITY },
+    { &GUID_RyAxis, FIELD_OFFSET(DIJOYSTATE2, lVRy), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTVELOCITY },
+    { &GUID_RzAxis, FIELD_OFFSET(DIJOYSTATE2, lVRz), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTVELOCITY },
+    /* note: dwOfs value matches Windows */
+    { &GUID_Slider, DIJOFS_SLIDER(0), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTVELOCITY },
+    { &GUID_Slider, DIJOFS_SLIDER(1), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTVELOCITY },
+    { &GUID_XAxis, FIELD_OFFSET(DIJOYSTATE2, lAX), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTACCEL },
+    { &GUID_YAxis, FIELD_OFFSET(DIJOYSTATE2, lAY), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTACCEL },
+    { &GUID_ZAxis, FIELD_OFFSET(DIJOYSTATE2, lAZ), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTACCEL },
+    { &GUID_RxAxis, FIELD_OFFSET(DIJOYSTATE2, lARx), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTACCEL },
+    { &GUID_RyAxis, FIELD_OFFSET(DIJOYSTATE2, lARy), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTACCEL },
+    { &GUID_RzAxis, FIELD_OFFSET(DIJOYSTATE2, lARz), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTACCEL },
+    /* note: dwOfs value matches Windows */
+    { &GUID_Slider, DIJOFS_SLIDER(0), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTACCEL },
+    { &GUID_Slider, DIJOFS_SLIDER(1), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTACCEL },
+    { &GUID_XAxis, FIELD_OFFSET(DIJOYSTATE2, lFX), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTFORCE },
+    { &GUID_YAxis, FIELD_OFFSET(DIJOYSTATE2, lFY), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTFORCE },
+    { &GUID_ZAxis, FIELD_OFFSET(DIJOYSTATE2, lFZ), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTFORCE },
+    { &GUID_RxAxis, FIELD_OFFSET(DIJOYSTATE2, lFRx), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTFORCE },
+    { &GUID_RyAxis, FIELD_OFFSET(DIJOYSTATE2, lFRy), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTFORCE },
+    { &GUID_RzAxis, FIELD_OFFSET(DIJOYSTATE2, lFRz), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTFORCE },
+    /* note: dwOfs value matches Windows */
+    { &GUID_Slider, DIJOFS_SLIDER(0), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTFORCE },
+    { &GUID_Slider, DIJOFS_SLIDER(1), DIDFT_OPTIONAL | DIDFT_AXIS | DIDFT_ANYINSTANCE, DIDOI_ASPECTFORCE },
 };
 
 const DIDATAFORMAT SDL_c_dfDIJoystick2 = {
@@ -232,210 +233,109 @@ SetDIerror(const char *function, HRESULT code)
     return SDL_SetError("%s() DirectX error 0x%8.8lx", function, code);
 }
 
-#if 0 /* Microsoft recommended implementation, but slower than checking raw devices */
-#define COBJMACROS
-#include <wbemidl.h>
-#include <oleauto.h>
-
-static const IID CLSID_WbemLocator = { 0x4590f811, 0x1d3a, 0x11d0,{ 0x89, 0x1f, 0x00, 0xaa, 0x00, 0x4b, 0x2e, 0x24 } };
-static const IID IID_IWbemLocator = { 0xdc12a687, 0x737f, 0x11cf,{ 0x88, 0x4d, 0x00, 0xaa, 0x00, 0x4b, 0x2e, 0x24 } };
-
 static SDL_bool
-WIN_IsXInputDevice(const WCHAR *name, const GUID* pGuidProductFromDirectInput)
+SDL_IsXInputDevice(Uint16 vendor_id, Uint16 product_id, const char* hidPath)
 {
-    IWbemLocator*           pIWbemLocator = NULL;
-    IEnumWbemClassObject*   pEnumDevices = NULL;
-    IWbemClassObject*       pDevices[20];
-    IWbemServices*          pIWbemServices = NULL;
-    BSTR                    bstrNamespace = NULL;
-    BSTR                    bstrDeviceID = NULL;
-    BSTR                    bstrClassName = NULL;
-    DWORD                   uReturned = 0;
-    SDL_bool                bIsXinputDevice = SDL_FALSE;
-    UINT                    iDevice = 0;
-    VARIANT                 var;
-    HRESULT                 hr;
+    SDL_GameControllerType type;
 
-    if (!SDL_XINPUT_Enabled()) {
+    /* XInput and RawInput backends will pick up XInput-compatible devices */
+    if (!SDL_XINPUT_Enabled()
+#ifdef SDL_JOYSTICK_RAWINPUT
+        && !RAWINPUT_IsEnabled()
+#endif
+        ) {
         return SDL_FALSE;
     }
 
-    if (SDL_wcsstr(name, L" XINPUT ") != NULL) {
-        /* This is a duplicate interface for a controller that will show up with XInput,
-           e.g. Xbox One Elite Series 2 in Bluetooth mode.
-         */
+    /* If device path contains "IG_" then its an XInput device */
+    /* See: https://docs.microsoft.com/windows/win32/xinput/xinput-and-directinput */
+    if (SDL_strstr(hidPath, "IG_") != NULL) {
         return SDL_TRUE;
     }
 
-    SDL_zeroa(pDevices);
-
-    // Create WMI
-    hr = CoCreateInstance(&CLSID_WbemLocator,
-        NULL,
-        CLSCTX_INPROC_SERVER,
-        &IID_IWbemLocator,
-        (LPVOID*)&pIWbemLocator);
-    if (FAILED(hr) || pIWbemLocator == NULL)
-        goto LCleanup;
-
-    bstrNamespace = SysAllocString(L"\\\\.\\root\\cimv2"); if (bstrNamespace == NULL) goto LCleanup;
-    bstrClassName = SysAllocString(L"Win32_PNPEntity");   if (bstrClassName == NULL) goto LCleanup;
-    bstrDeviceID = SysAllocString(L"DeviceID");          if (bstrDeviceID == NULL)  goto LCleanup;
-
-    // Connect to WMI 
-    hr = IWbemLocator_ConnectServer(pIWbemLocator, bstrNamespace, NULL, NULL, 0L,
-        0L, NULL, NULL, &pIWbemServices);
-    if (FAILED(hr) || pIWbemServices == NULL) {
-        goto LCleanup;
-    }
-
-    // Switch security level to IMPERSONATE. 
-    CoSetProxyBlanket((IUnknown *)pIWbemServices, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, NULL,
-        RPC_C_AUTHN_LEVEL_CALL, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE);
-
-    hr = IWbemServices_CreateInstanceEnum(pIWbemServices, bstrClassName, 0, NULL, &pEnumDevices);
-    if (FAILED(hr) || pEnumDevices == NULL)
-        goto LCleanup;
-
-    // Loop over all devices
-    for (;;) {
-        // Get 20 at a time
-        hr = IEnumWbemClassObject_Next(pEnumDevices, 10000, SDL_arraysize(pDevices), pDevices, &uReturned);
-        if (FAILED(hr)) {
-            goto LCleanup;
-        }
-        if (uReturned == 0) {
-            break;
-        }
-
-        for (iDevice = 0; iDevice < uReturned; iDevice++) {
-            // For each device, get its device ID
-            hr = IWbemClassObject_Get(pDevices[iDevice], bstrDeviceID, 0L, &var, NULL, NULL);
-            if (SUCCEEDED(hr) && var.vt == VT_BSTR && var.bstrVal != NULL) {
-                // Check if the device ID contains "IG_".  If it does, then it's an XInput device
-                // This information can not be found from DirectInput 
-                if (SDL_wcsstr(var.bstrVal, L"IG_")) {
-                    char *bstrVal = WIN_StringToUTF8(var.bstrVal);
-
-                    // If it does, then get the VID/PID from var.bstrVal
-                    DWORD dwPid = 0, dwVid = 0, dwVidPid;
-                    const char *strVid, *strPid;
-                    strVid = SDL_strstr(bstrVal, "VID_");
-                    if (strVid && SDL_sscanf(strVid, "VID_%4X", &dwVid) != 1)
-                        dwVid = 0;
-                    strPid = SDL_strstr(bstrVal, "PID_");
-                    if (strPid && SDL_sscanf(strPid, "PID_%4X", &dwPid) != 1)
-                        dwPid = 0;
-
-                    SDL_free(bstrVal);
-
-                    // Compare the VID/PID to the DInput device
-                    dwVidPid = MAKELONG(dwVid, dwPid);
-                    if (dwVidPid == pGuidProductFromDirectInput->Data1) {
-                        bIsXinputDevice = SDL_TRUE;
-                        goto LCleanup;
-                    }
-                }
-            }
-            IWbemClassObject_Release(pDevices[iDevice]);
-        }
-    }
-
-LCleanup:
-    if (bstrNamespace) {
-        SysFreeString(bstrNamespace);
-    }
-    if (bstrDeviceID) {
-        SysFreeString(bstrDeviceID);
-    }
-    if (bstrClassName) {
-        SysFreeString(bstrClassName);
-    }
-    for (iDevice = 0; iDevice < SDL_arraysize(pDevices); iDevice++) {
-        if (pDevices[iDevice]) {
-            IWbemClassObject_Release(pDevices[iDevice]);
-        }
-    }
-    if (pEnumDevices) {
-        IEnumWbemClassObject_Release(pEnumDevices);
-    }
-    if (pIWbemLocator) {
-        IWbemLocator_Release(pIWbemLocator);
-    }
-    if (pIWbemServices) {
-        IWbemServices_Release(pIWbemServices);
-    }
-
-    return bIsXinputDevice;
-}
-#endif /* 0 */
-
-static SDL_bool
-SDL_IsXInputDevice(const WCHAR *name, const GUID* pGuidProductFromDirectInput)
-{
-    UINT i;
-
-    if (!SDL_XINPUT_Enabled()) {
-        return SDL_FALSE;
-    }
-
-    if (SDL_wcsstr(name, L" XINPUT ") != NULL) {
-        /* This is a duplicate interface for a controller that will show up with XInput,
-           e.g. Xbox One Elite Series 2 in Bluetooth mode.
-         */
+    type = SDL_GetJoystickGameControllerType("", vendor_id, product_id, -1, 0, 0, 0);
+    if (type == SDL_CONTROLLER_TYPE_XBOX360 ||
+        type == SDL_CONTROLLER_TYPE_XBOXONE ||
+        (vendor_id == USB_VENDOR_VALVE && product_id == USB_PRODUCT_STEAM_VIRTUAL_GAMEPAD)) {
         return SDL_TRUE;
     }
 
-    if (SDL_memcmp(&pGuidProductFromDirectInput->Data4[2], "PIDVID", 6) == 0) {
-        Uint16 vendor_id = (Uint16)LOWORD(pGuidProductFromDirectInput->Data1);
-        Uint16 product_id = (Uint16)HIWORD(pGuidProductFromDirectInput->Data1);
-        SDL_GameControllerType type = SDL_GetJoystickGameControllerType("", vendor_id, product_id, -1, 0, 0, 0);
-        if (type == SDL_CONTROLLER_TYPE_XBOX360 ||
-            type == SDL_CONTROLLER_TYPE_XBOXONE ||
-            (vendor_id == 0x28DE && product_id == 0x11FF)) {
-            return SDL_TRUE;
-        }
-    }
-
-    /* Go through RAWINPUT (WinXP and later) to find HID devices. */
-    /* Cache this if we end up using it. */
-    if (SDL_RawDevList == NULL) {
-        if ((GetRawInputDeviceList(NULL, &SDL_RawDevListCount, sizeof(RAWINPUTDEVICELIST)) == -1) || (!SDL_RawDevListCount)) {
-            return SDL_FALSE;  /* oh well. */
-        }
-
-        SDL_RawDevList = (PRAWINPUTDEVICELIST)SDL_malloc(sizeof(RAWINPUTDEVICELIST) * SDL_RawDevListCount);
-        if (SDL_RawDevList == NULL) {
-            SDL_OutOfMemory();
-            return SDL_FALSE;
-        }
-
-        if (GetRawInputDeviceList(SDL_RawDevList, &SDL_RawDevListCount, sizeof(RAWINPUTDEVICELIST)) == -1) {
-            SDL_free(SDL_RawDevList);
-            SDL_RawDevList = NULL;
-            return SDL_FALSE;  /* oh well. */
-        }
-    }
-
-    for (i = 0; i < SDL_RawDevListCount; i++) {
-        RID_DEVICE_INFO rdi;
-        char devName[MAX_PATH];
-        UINT rdiSize = sizeof(rdi);
-        UINT nameSize = SDL_arraysize(devName);
-
-        rdi.cbSize = sizeof(rdi);
-        if ((SDL_RawDevList[i].dwType == RIM_TYPEHID) &&
-            (GetRawInputDeviceInfoA(SDL_RawDevList[i].hDevice, RIDI_DEVICEINFO, &rdi, &rdiSize) != ((UINT)-1)) &&
-            (MAKELONG(rdi.hid.dwVendorId, rdi.hid.dwProductId) == ((LONG)pGuidProductFromDirectInput->Data1)) &&
-            (GetRawInputDeviceInfoA(SDL_RawDevList[i].hDevice, RIDI_DEVICENAME, devName, &nameSize) != ((UINT)-1)) &&
-            (SDL_strstr(devName, "IG_") != NULL)) {
-            return SDL_TRUE;
-        }
-    }
-
     return SDL_FALSE;
 }
 
+static SDL_bool
+QueryDeviceName(LPDIRECTINPUTDEVICE8 device, char** device_name)
+{
+    DIPROPSTRING dipstr;
+
+    if (!device || !device_name) {
+        return SDL_FALSE;
+    }
+
+    dipstr.diph.dwSize = sizeof(dipstr);
+    dipstr.diph.dwHeaderSize = sizeof(dipstr.diph);
+    dipstr.diph.dwObj = 0;
+    dipstr.diph.dwHow = DIPH_DEVICE;
+
+    if (FAILED(IDirectInputDevice8_GetProperty(device, DIPROP_PRODUCTNAME, &dipstr.diph))) {
+        return SDL_FALSE;
+    }
+
+    *device_name = WIN_StringToUTF8(dipstr.wsz);
+
+    return SDL_TRUE;
+}
+
+static SDL_bool
+QueryDevicePath(LPDIRECTINPUTDEVICE8 device, char** device_path)
+{
+    DIPROPGUIDANDPATH dippath;
+
+    if (!device || !device_path) {
+        return SDL_FALSE;
+    }
+
+    dippath.diph.dwSize = sizeof(dippath);
+    dippath.diph.dwHeaderSize = sizeof(dippath.diph);
+    dippath.diph.dwObj = 0;
+    dippath.diph.dwHow = DIPH_DEVICE;
+
+    if (FAILED(IDirectInputDevice8_GetProperty(device, DIPROP_GUIDANDPATH, &dippath.diph))) {
+        return SDL_FALSE;
+    }
+
+    *device_path = WIN_StringToUTF8W(dippath.wszPath);
+
+    /* Normalize path to upper case. */
+    SDL_strupr(*device_path);
+
+    return SDL_TRUE;
+}
+
+static SDL_bool
+QueryDeviceInfo(LPDIRECTINPUTDEVICE8 device, Uint16* vendor_id, Uint16* product_id)
+{
+    DIPROPDWORD dipdw;
+
+    if (!device || !vendor_id || !product_id) {
+        return SDL_FALSE;
+    }
+
+    dipdw.diph.dwSize = sizeof(dipdw);
+    dipdw.diph.dwHeaderSize = sizeof(dipdw.diph);
+    dipdw.diph.dwObj = 0;
+    dipdw.diph.dwHow = DIPH_DEVICE;
+
+    if (FAILED(IDirectInputDevice8_GetProperty(device, DIPROP_VIDPID, &dipdw.diph))) {
+        return SDL_FALSE;
+    }
+
+    *vendor_id = LOWORD(dipdw.dwData);
+    *product_id = HIWORD(dipdw.dwData);
+
+    return SDL_TRUE;
+}
+
 void FreeRumbleEffectData(DIEFFECT *effect)
 {
     if (!effect) {
@@ -530,88 +430,49 @@ SDL_DINPUT_JoystickInit(void)
 
 /* helper function for direct input, gets called for each connected joystick */
 static BOOL CALLBACK
-EnumJoysticksCallback(const DIDEVICEINSTANCE * pdidInstance, VOID * pContext)
+EnumJoystickDetectCallback(LPCDIDEVICEINSTANCE pDeviceInstance, LPVOID pContext)
 {
-    JoyStick_DeviceData *pNewJoystick;
+#define CHECK(expression) { if(!(expression)) goto err; }
+    JoyStick_DeviceData *pNewJoystick = NULL;
     JoyStick_DeviceData *pPrevJoystick = NULL;
-    const DWORD devtype = (pdidInstance->dwDevType & 0xFF);
     Uint16 *guid16;
     Uint16 vendor = 0;
     Uint16 product = 0;
     Uint16 version = 0;
-    WCHAR hidPath[MAX_PATH];
-    char *name;
+    char *hidPath = NULL;
+    char *name = NULL;
+    LPDIRECTINPUTDEVICE8 device = NULL;
 
-    if (devtype == DI8DEVTYPE_SUPPLEMENTAL) {
-        /* Add any supplemental devices that should be ignored here */
-#define MAKE_TABLE_ENTRY(VID, PID)    ((((DWORD)PID)<<16)|VID)
-        static DWORD ignored_devices[] = {
-            MAKE_TABLE_ENTRY(0, 0)
-        };
-#undef MAKE_TABLE_ENTRY
-        unsigned int i;
+    /* We are only supporting HID devices. */
+    CHECK((pDeviceInstance->dwDevType & DIDEVTYPE_HID) != 0);
 
-        for (i = 0; i < SDL_arraysize(ignored_devices); ++i) {
-            if (pdidInstance->guidProduct.Data1 == ignored_devices[i]) {
-                return DIENUM_CONTINUE;
-            }
-        }
-    }
+    CHECK(SUCCEEDED(IDirectInput8_CreateDevice(dinput, &pDeviceInstance->guidInstance, &device, NULL)));
+    CHECK(QueryDeviceName(device, &name));
+    CHECK(QueryDevicePath(device, &hidPath));
+    CHECK(QueryDeviceInfo(device, &vendor, &product));
 
-    if (SDL_IsXInputDevice(pdidInstance->tszProductName, &pdidInstance->guidProduct)) {
-        return DIENUM_CONTINUE;  /* ignore XInput devices here, keep going. */
-    }
+    CHECK(!SDL_IsXInputDevice(vendor, product, hidPath));
 
-    {
-        HRESULT result;
-        LPDIRECTINPUTDEVICE8 device;
-        LPDIRECTINPUTDEVICE8 InputDevice;
-        DIPROPGUIDANDPATH dipdw2;
-
-        result = IDirectInput8_CreateDevice(dinput, &(pdidInstance->guidInstance), &device, NULL);
-        if (FAILED(result)) {
-            return DIENUM_CONTINUE; /* better luck next time? */
-        }
-
-        /* Now get the IDirectInputDevice8 interface, instead. */
-        result = IDirectInputDevice8_QueryInterface(device, &IID_IDirectInputDevice8, (LPVOID *)&InputDevice);
-        /* We are done with this object.  Use the stored one from now on. */
-        IDirectInputDevice8_Release(device);
-        if (FAILED(result)) {
-            return DIENUM_CONTINUE; /* better luck next time? */
-        }
-        dipdw2.diph.dwSize = sizeof(dipdw2);
-        dipdw2.diph.dwHeaderSize = sizeof(dipdw2.diph);
-        dipdw2.diph.dwObj = 0; // device property
-        dipdw2.diph.dwHow = DIPH_DEVICE;
-
-        result = IDirectInputDevice8_GetProperty(InputDevice, DIPROP_GUIDANDPATH, &dipdw2.diph);
-        IDirectInputDevice8_Release(InputDevice);
-        if (FAILED(result)) {
-            return DIENUM_CONTINUE; /* better luck next time? */
-        }
-
-        /* Get device path, compare that instead of GUID, additionally update GUIDs of joysticks with matching paths, in case they're not open yet. */
-        SDL_wcslcpy(hidPath, dipdw2.wszPath, SDL_arraysize(hidPath));
-    }
-
-    pNewJoystick = *(JoyStick_DeviceData **)pContext;
+    pNewJoystick = *(JoyStick_DeviceData**)pContext;
     while (pNewJoystick) {
-        if (SDL_wcscmp(pNewJoystick->hidPath, hidPath) == 0) {
+        /* update GUIDs of joysticks with matching paths, in case they're not open yet */
+        if (SDL_strcmp(pNewJoystick->hidPath, hidPath) == 0) {
             /* if we are replacing the front of the list then update it */
-            if (pNewJoystick == *(JoyStick_DeviceData **)pContext) {
-                *(JoyStick_DeviceData **)pContext = pNewJoystick->pNext;
-            } else if (pPrevJoystick) {
+            if (pNewJoystick == *(JoyStick_DeviceData**)pContext) {
+                *(JoyStick_DeviceData**)pContext = pNewJoystick->pNext;
+            }
+            else if (pPrevJoystick) {
                 pPrevJoystick->pNext = pNewJoystick->pNext;
             }
 
             /* Update with new guid/etc, if it has changed */
-            SDL_memcpy(&pNewJoystick->dxdevice, pdidInstance, sizeof(DIDEVICEINSTANCE));
+            SDL_memcpy(&pNewJoystick->dxdevice, pDeviceInstance, sizeof(DIDEVICEINSTANCE));
 
             pNewJoystick->pNext = SYS_Joystick;
             SYS_Joystick = pNewJoystick;
 
-            return DIENUM_CONTINUE; /* already have this joystick loaded, just keep going */
+            pNewJoystick = NULL;
+            CHECK(FALSE);
         }
 
         pPrevJoystick = pNewJoystick;
@@ -619,31 +480,18 @@ EnumJoysticksCallback(const DIDEVICEINSTANCE * pdidInstance, VOID * pContext)
     }
 
     pNewJoystick = (JoyStick_DeviceData *)SDL_malloc(sizeof(JoyStick_DeviceData));
-    if (!pNewJoystick) {
-        return DIENUM_CONTINUE; /* better luck next time? */
-    }
+    CHECK(pNewJoystick);
 
     SDL_zerop(pNewJoystick);
-    SDL_wcslcpy(pNewJoystick->hidPath, hidPath, SDL_arraysize(pNewJoystick->hidPath));
-    SDL_memcpy(&pNewJoystick->dxdevice, pdidInstance, sizeof(DIDEVICEINSTANCE));
+    SDL_strlcpy(pNewJoystick->hidPath, hidPath, SDL_arraysize(pNewJoystick->hidPath));
+    SDL_memcpy(&pNewJoystick->dxdevice, pDeviceInstance, sizeof(DIDEVICEINSTANCE));
     SDL_memset(pNewJoystick->guid.data, 0, sizeof(pNewJoystick->guid.data));
 
-    if (SDL_memcmp(&pdidInstance->guidProduct.Data4[2], "PIDVID", 6) == 0) {
-        vendor = (Uint16)LOWORD(pdidInstance->guidProduct.Data1);
-        product = (Uint16)HIWORD(pdidInstance->guidProduct.Data1);
-    }
-
-    name = WIN_StringToUTF8(pdidInstance->tszProductName);
     pNewJoystick->joystickname = SDL_CreateJoystickName(vendor, product, NULL, name);
-    SDL_free(name);
-
-    if (!pNewJoystick->joystickname) {
-        SDL_free(pNewJoystick);
-        return DIENUM_CONTINUE; /* better luck next time? */
-    }
+    CHECK(pNewJoystick->joystickname);
 
     guid16 = (Uint16 *)pNewJoystick->guid.data;
-    if (SDL_memcmp(&pdidInstance->guidProduct.Data4[2], "PIDVID", 6) == 0) {
+    if (vendor && product) {
         *guid16++ = SDL_SwapLE16(SDL_HARDWARE_BUS_USB);
         *guid16++ = 0;
         *guid16++ = SDL_SwapLE16(vendor);
@@ -658,127 +506,132 @@ EnumJoysticksCallback(const DIDEVICEINSTANCE * pdidInstance, VOID * pContext)
         SDL_strlcpy((char*)guid16, pNewJoystick->joystickname, sizeof(pNewJoystick->guid.data) - 4);
     }
 
-    if (SDL_ShouldIgnoreJoystick(pNewJoystick->joystickname, pNewJoystick->guid)) {
-        SDL_free(pNewJoystick->joystickname);
-        SDL_free(pNewJoystick);
-        return DIENUM_CONTINUE;
-    }
+    CHECK(!SDL_ShouldIgnoreJoystick(pNewJoystick->joystickname, pNewJoystick->guid));
 
 #ifdef SDL_JOYSTICK_HIDAPI
-    if (HIDAPI_IsDevicePresent(vendor, product, 0, pNewJoystick->joystickname)) {
-        /* The HIDAPI driver is taking care of this device */
-        SDL_free(pNewJoystick->joystickname);
-        SDL_free(pNewJoystick);
-        return DIENUM_CONTINUE;
-    }
+    CHECK(!HIDAPI_IsDevicePresent(vendor, product, version, pNewJoystick->joystickname));
 #endif
 
 #ifdef SDL_JOYSTICK_RAWINPUT
-    if (RAWINPUT_IsDevicePresent(vendor, product, 0, pNewJoystick->joystickname)) {
-        /* The RAWINPUT driver is taking care of this device */
-        SDL_free(pNewJoystick);
-        return DIENUM_CONTINUE;
-    }
+    CHECK(!RAWINPUT_IsDevicePresent(vendor, product, version, pNewJoystick->joystickname));
 #endif
 
     WINDOWS_AddJoystickDevice(pNewJoystick);
+    pNewJoystick = NULL;
+
+err:
+    if (pNewJoystick) {
+        SDL_free(pNewJoystick->joystickname);
+        SDL_free(pNewJoystick);
+    }
+
+    SDL_free(hidPath);
+    SDL_free(name);
+
+    if (device) {
+        IDirectInputDevice8_Release(device);
+    }
 
     return DIENUM_CONTINUE; /* get next device, please */
+#undef CHECK
 }
 
 void
 SDL_DINPUT_JoystickDetect(JoyStick_DeviceData **pContext)
 {
-    IDirectInput8_EnumDevices(dinput, DI8DEVCLASS_GAMECTRL, EnumJoysticksCallback, pContext, DIEDFL_ATTACHEDONLY);
-
-    if (SDL_RawDevList) {
-        SDL_free(SDL_RawDevList);  /* in case we used this in DirectInput detection */
-        SDL_RawDevList = NULL;
-    }
-    SDL_RawDevListCount = 0;
+    IDirectInput8_EnumDevices(dinput, DI8DEVCLASS_GAMECTRL, EnumJoystickDetectCallback, pContext, DIEDFL_ATTACHEDONLY);
 }
 
+/* helper function for direct input, gets called for each connected joystick */
 typedef struct
 {
     Uint16 vendor;
     Uint16 product;
-    Uint16 version;
     SDL_bool present;
-} EnumJoystickPresentData;
+} Joystick_PresentData;
 
 static BOOL CALLBACK
-EnumJoystickPresentCallback(const DIDEVICEINSTANCE * pdidInstance, VOID * pContext)
+EnumJoystickPresentCallback(LPCDIDEVICEINSTANCE pDeviceInstance, LPVOID pContext)
 {
-    EnumJoystickPresentData *data = (EnumJoystickPresentData *)pContext;
+#define CHECK(expression) { if(!(expression)) goto err; }
+    Joystick_PresentData *pData = (Joystick_PresentData *)pContext;
     Uint16 vendor = 0;
     Uint16 product = 0;
-    Uint16 version = 0;
+    LPDIRECTINPUTDEVICE8 device = NULL;
+    BOOL result = DIENUM_CONTINUE;
 
-    if (SDL_memcmp(&pdidInstance->guidProduct.Data4[2], "PIDVID", 6) == 0) {
-        vendor = (Uint16)LOWORD(pdidInstance->guidProduct.Data1);
-        product = (Uint16)HIWORD(pdidInstance->guidProduct.Data1);
-        if (data->vendor == vendor && data->product == product && data->version == version) {
-            data->present = SDL_TRUE;
-            return DIENUM_STOP;
-        }
+    /* We are only supporting HID devices. */
+    CHECK((pDeviceInstance->dwDevType & DIDEVTYPE_HID) != 0);
+
+    CHECK(SUCCEEDED(IDirectInput8_CreateDevice(dinput, &pDeviceInstance->guidInstance, &device, NULL)));
+    CHECK(QueryDeviceInfo(device, &vendor, &product));
+
+    if (vendor == pData->vendor && product == pData->product) {
+        pData->present = SDL_TRUE;
+        result = DIENUM_STOP; /* found it */
     }
-    return DIENUM_CONTINUE;
+
+err:
+    if (device) {
+        IDirectInputDevice8_Release(device);
+    }
+
+    return result;
+#undef CHECK
 }
 
 SDL_bool
-SDL_DINPUT_JoystickPresent(Uint16 vendor, Uint16 product, Uint16 version)
+SDL_DINPUT_JoystickPresent(Uint16 vendor_id, Uint16 product_id, Uint16 version_number)
 {
-    EnumJoystickPresentData data;
+    Joystick_PresentData data;
 
     if (dinput == NULL) {
         return SDL_FALSE;
     }
 
-    data.vendor = vendor;
-    data.product = product;
-    data.version = version;
+    data.vendor = vendor_id;
+    data.product = product_id;
     data.present = SDL_FALSE;
     IDirectInput8_EnumDevices(dinput, DI8DEVCLASS_GAMECTRL, EnumJoystickPresentCallback, &data, DIEDFL_ATTACHEDONLY);
-
     return data.present;
 }
 
 static BOOL CALLBACK
-EnumDevObjectsCallback(LPCDIDEVICEOBJECTINSTANCE dev, LPVOID pvRef)
+EnumDevObjectsCallback(LPCDIDEVICEOBJECTINSTANCE pDeviceObject, LPVOID pContext)
 {
-    SDL_Joystick *joystick = (SDL_Joystick *)pvRef;
+    SDL_Joystick *joystick = (SDL_Joystick *)pContext;
     HRESULT result;
     input_t *in = &joystick->hwdata->Inputs[joystick->hwdata->NumInputs];
 
-    if (dev->dwType & DIDFT_BUTTON) {
+    if (pDeviceObject->dwType & DIDFT_BUTTON) {
         in->type = BUTTON;
         in->num = joystick->nbuttons;
         in->ofs = DIJOFS_BUTTON(in->num);
         joystick->nbuttons++;
-    } else if (dev->dwType & DIDFT_POV) {
+    } else if (pDeviceObject->dwType & DIDFT_POV) {
         in->type = HAT;
         in->num = joystick->nhats;
         in->ofs = DIJOFS_POV(in->num);
         joystick->nhats++;
-    } else if (dev->dwType & DIDFT_AXIS) {
+    } else if (pDeviceObject->dwType & DIDFT_AXIS) {
         DIPROPRANGE diprg;
         DIPROPDWORD dilong;
 
         in->type = AXIS;
         in->num = joystick->naxes;
-        if (!SDL_memcmp(&dev->guidType, &GUID_XAxis, sizeof(dev->guidType)))
+        if (!SDL_memcmp(&pDeviceObject->guidType, &GUID_XAxis, sizeof(pDeviceObject->guidType)))
             in->ofs = DIJOFS_X;
-        else if (!SDL_memcmp(&dev->guidType, &GUID_YAxis, sizeof(dev->guidType)))
+        else if (!SDL_memcmp(&pDeviceObject->guidType, &GUID_YAxis, sizeof(pDeviceObject->guidType)))
             in->ofs = DIJOFS_Y;
-        else if (!SDL_memcmp(&dev->guidType, &GUID_ZAxis, sizeof(dev->guidType)))
+        else if (!SDL_memcmp(&pDeviceObject->guidType, &GUID_ZAxis, sizeof(pDeviceObject->guidType)))
             in->ofs = DIJOFS_Z;
-        else if (!SDL_memcmp(&dev->guidType, &GUID_RxAxis, sizeof(dev->guidType)))
+        else if (!SDL_memcmp(&pDeviceObject->guidType, &GUID_RxAxis, sizeof(pDeviceObject->guidType)))
             in->ofs = DIJOFS_RX;
-        else if (!SDL_memcmp(&dev->guidType, &GUID_RyAxis, sizeof(dev->guidType)))
+        else if (!SDL_memcmp(&pDeviceObject->guidType, &GUID_RyAxis, sizeof(pDeviceObject->guidType)))
             in->ofs = DIJOFS_RY;
-        else if (!SDL_memcmp(&dev->guidType, &GUID_RzAxis, sizeof(dev->guidType)))
+        else if (!SDL_memcmp(&pDeviceObject->guidType, &GUID_RzAxis, sizeof(pDeviceObject->guidType)))
             in->ofs = DIJOFS_RZ;
-        else if (!SDL_memcmp(&dev->guidType, &GUID_Slider, sizeof(dev->guidType))) {
+        else if (!SDL_memcmp(&pDeviceObject->guidType, &GUID_Slider, sizeof(pDeviceObject->guidType))) {
             in->ofs = DIJOFS_SLIDER(joystick->hwdata->NumSliders);
             ++joystick->hwdata->NumSliders;
         } else {
@@ -787,7 +640,7 @@ EnumDevObjectsCallback(LPCDIDEVICEOBJECTINSTANCE dev, LPVOID pvRef)
 
         diprg.diph.dwSize = sizeof(diprg);
         diprg.diph.dwHeaderSize = sizeof(diprg.diph);
-        diprg.diph.dwObj = dev->dwType;
+        diprg.diph.dwObj = pDeviceObject->dwType;
         diprg.diph.dwHow = DIPH_BYID;
         diprg.lMin = SDL_JOYSTICK_AXIS_MIN;
         diprg.lMax = SDL_JOYSTICK_AXIS_MAX;
@@ -802,7 +655,7 @@ EnumDevObjectsCallback(LPCDIDEVICEOBJECTINSTANCE dev, LPVOID pvRef)
         /* Set dead zone to 0. */
         dilong.diph.dwSize = sizeof(dilong);
         dilong.diph.dwHeaderSize = sizeof(dilong.diph);
-        dilong.diph.dwObj = dev->dwType;
+        dilong.diph.dwObj = pDeviceObject->dwType;
         dilong.diph.dwHow = DIPH_BYID;
         dilong.dwData = 0;
         result =
@@ -879,7 +732,6 @@ int
 SDL_DINPUT_JoystickOpen(SDL_Joystick * joystick, JoyStick_DeviceData *joystickdevice)
 {
     HRESULT result;
-    LPDIRECTINPUTDEVICE8 device;
     DIPROPDWORD dipdw;
 
     joystick->hwdata->buffered = SDL_TRUE;
@@ -891,23 +743,13 @@ SDL_DINPUT_JoystickOpen(SDL_Joystick * joystick, JoyStick_DeviceData *joystickde
 
     result =
         IDirectInput8_CreateDevice(dinput,
-        &(joystickdevice->dxdevice.guidInstance), &device, NULL);
+            &joystickdevice->dxdevice.guidInstance,
+            &joystick->hwdata->InputDevice,
+            NULL);
     if (FAILED(result)) {
         return SetDIerror("IDirectInput::CreateDevice", result);
     }
 
-    /* Now get the IDirectInputDevice8 interface, instead. */
-    result = IDirectInputDevice8_QueryInterface(device,
-        &IID_IDirectInputDevice8,
-        (LPVOID *)& joystick->
-        hwdata->InputDevice);
-    /* We are done with this object.  Use the stored one from now on. */
-    IDirectInputDevice8_Release(device);
-
-    if (FAILED(result)) {
-        return SetDIerror("IDirectInputDevice8::QueryInterface", result);
-    }
-
     /* Acquire shared access. Exclusive access is required for forces,
     * though. */
     result =
@@ -1087,6 +929,18 @@ SDL_DINPUT_JoystickRumble(SDL_Joystick * joystick, Uint16 low_frequency_rumble,
     return 0;
 }
 
+Uint32
+SDL_DINPUT_JoystickGetCapabilities(SDL_Joystick * joystick)
+{
+    Uint32 result = 0;
+
+    if (joystick->hwdata->Capabilities.dwFlags & DIDC_FORCEFEEDBACK) {
+        result |= SDL_JOYCAP_RUMBLE;
+    }
+
+    return result;
+}
+
 static Uint8
 TranslatePOV(DWORD value)
 {
@@ -1115,60 +969,6 @@ TranslatePOV(DWORD value)
     return HAT_VALS[value];
 }
 
-static void
-UpdateDINPUTJoystickState_Buffered(SDL_Joystick * joystick)
-{
-    int i;
-    HRESULT result;
-    DWORD numevents;
-    DIDEVICEOBJECTDATA evtbuf[INPUT_QSIZE];
-
-    numevents = INPUT_QSIZE;
-    result =
-        IDirectInputDevice8_GetDeviceData(joystick->hwdata->InputDevice,
-        sizeof(DIDEVICEOBJECTDATA), evtbuf,
-        &numevents, 0);
-    if (result == DIERR_INPUTLOST || result == DIERR_NOTACQUIRED) {
-        IDirectInputDevice8_Acquire(joystick->hwdata->InputDevice);
-        result =
-            IDirectInputDevice8_GetDeviceData(joystick->hwdata->InputDevice,
-            sizeof(DIDEVICEOBJECTDATA),
-            evtbuf, &numevents, 0);
-    }
-
-    /* Handle the events or punt */
-    if (FAILED(result)) {
-        return;
-    }
-
-    for (i = 0; i < (int)numevents; ++i) {
-        int j;
-
-        for (j = 0; j < joystick->hwdata->NumInputs; ++j) {
-            const input_t *in = &joystick->hwdata->Inputs[j];
-
-            if (evtbuf[i].dwOfs != in->ofs)
-                continue;
-
-            switch (in->type) {
-            case AXIS:
-                SDL_PrivateJoystickAxis(joystick, in->num, (Sint16)evtbuf[i].dwData);
-                break;
-            case BUTTON:
-                SDL_PrivateJoystickButton(joystick, in->num,
-                    (Uint8)(evtbuf[i].dwData ? SDL_PRESSED : SDL_RELEASED));
-                break;
-            case HAT:
-                {
-                    Uint8 pos = TranslatePOV(evtbuf[i].dwData);
-                    SDL_PrivateJoystickHat(joystick, in->num, pos);
-                }
-                break;
-            }
-        }
-    }
-}
-
 /* Function to update the state of a joystick - called as a device poll.
  * This function shouldn't update the joystick structure directly,
  * but instead should call SDL_PrivateJoystick*() to deliver events
@@ -1243,6 +1043,67 @@ UpdateDINPUTJoystickState_Polled(SDL_Joystick * joystick)
     }
 }
 
+static void
+UpdateDINPUTJoystickState_Buffered(SDL_Joystick * joystick)
+{
+    int i;
+    HRESULT result;
+    DWORD numevents;
+    DIDEVICEOBJECTDATA evtbuf[INPUT_QSIZE];
+
+    numevents = INPUT_QSIZE;
+    result =
+        IDirectInputDevice8_GetDeviceData(joystick->hwdata->InputDevice,
+        sizeof(DIDEVICEOBJECTDATA), evtbuf,
+        &numevents, 0);
+    if (result == DIERR_INPUTLOST || result == DIERR_NOTACQUIRED) {
+        IDirectInputDevice8_Acquire(joystick->hwdata->InputDevice);
+        result =
+            IDirectInputDevice8_GetDeviceData(joystick->hwdata->InputDevice,
+            sizeof(DIDEVICEOBJECTDATA),
+            evtbuf, &numevents, 0);
+    }
+
+    /* Handle the events or punt */
+    if (FAILED(result)) {
+        return;
+    }
+
+    for (i = 0; i < (int)numevents; ++i) {
+        int j;
+
+        for (j = 0; j < joystick->hwdata->NumInputs; ++j) {
+            const input_t *in = &joystick->hwdata->Inputs[j];
+
+            if (evtbuf[i].dwOfs != in->ofs)
+                continue;
+
+            switch (in->type) {
+            case AXIS:
+                SDL_PrivateJoystickAxis(joystick, in->num, (Sint16)evtbuf[i].dwData);
+                break;
+            case BUTTON:
+                SDL_PrivateJoystickButton(joystick, in->num,
+                    (Uint8)(evtbuf[i].dwData ? SDL_PRESSED : SDL_RELEASED));
+                break;
+            case HAT:
+                {
+                    Uint8 pos = TranslatePOV(evtbuf[i].dwData);
+                    SDL_PrivateJoystickHat(joystick, in->num, pos);
+                }
+                break;
+            }
+        }
+    }
+
+    if (result == DI_BUFFEROVERFLOW) {
+        /* Our buffer wasn't big enough to hold all the queued events,
+         * so poll the device to make sure we have the complete state.
+         */
+        UpdateDINPUTJoystickState_Polled(joystick);
+    }
+}
+
 void
 SDL_DINPUT_JoystickUpdate(SDL_Joystick * joystick)
 {
@@ -1324,6 +1185,12 @@ SDL_DINPUT_JoystickRumble(SDL_Joystick * joystick, Uint16 low_frequency_rumble,
     return SDL_Unsupported();
 }
 
+Uint32
+SDL_DINPUT_JoystickGetCapabilities(SDL_Joystick * joystick)
+{
+    return 0;
+}
+
 void
 SDL_DINPUT_JoystickUpdate(SDL_Joystick * joystick)
 {
diff --git a/Engine/lib/sdl/src/joystick/windows/SDL_dinputjoystick_c.h b/Engine/lib/sdl/src/joystick/windows/SDL_dinputjoystick_c.h
index 2e7e7db70..d0e583465 100644
--- a/Engine/lib/sdl/src/joystick/windows/SDL_dinputjoystick_c.h
+++ b/Engine/lib/sdl/src/joystick/windows/SDL_dinputjoystick_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -25,6 +25,7 @@ extern void SDL_DINPUT_JoystickDetect(JoyStick_DeviceData **pContext);
 extern SDL_bool SDL_DINPUT_JoystickPresent(Uint16 vendor, Uint16 product, Uint16 version);
 extern int SDL_DINPUT_JoystickOpen(SDL_Joystick * joystick, JoyStick_DeviceData *joystickdevice);
 extern int SDL_DINPUT_JoystickRumble(SDL_Joystick * joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble);
+extern Uint32 SDL_DINPUT_JoystickGetCapabilities(SDL_Joystick * joystick);
 extern void SDL_DINPUT_JoystickUpdate(SDL_Joystick * joystick);
 extern void SDL_DINPUT_JoystickClose(SDL_Joystick * joystick);
 extern void SDL_DINPUT_JoystickQuit(void);
diff --git a/Engine/lib/sdl/src/joystick/windows/SDL_mmjoystick.c b/Engine/lib/sdl/src/joystick/windows/SDL_mmjoystick.c
deleted file mode 100644
index 197403269..000000000
--- a/Engine/lib/sdl/src/joystick/windows/SDL_mmjoystick.c
+++ /dev/null
@@ -1,452 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-#include "../../SDL_internal.h"
-
-#ifdef SDL_JOYSTICK_WINMM
-
-/* Win32 MultiMedia Joystick driver, contributed by Andrei de A. Formiga */
-
-#include "../../core/windows/SDL_windows.h"
-#include <mmsystem.h>
-#include <regstr.h>
-
-#include "SDL_events.h"
-#include "SDL_joystick.h"
-#include "../SDL_sysjoystick.h"
-#include "../SDL_joystick_c.h"
-
-#ifdef REGSTR_VAL_JOYOEMNAME 
-#undef REGSTR_VAL_JOYOEMNAME 
-#endif
-#define REGSTR_VAL_JOYOEMNAME "OEMName"
-
-#define MAX_JOYSTICKS   16
-#define MAX_AXES    6       /* each joystick can have up to 6 axes */
-#define MAX_BUTTONS 32      /* and 32 buttons                      */
-#define JOY_BUTTON_FLAG(n)  (1<<n)
-
-
-/* array to hold joystick ID values */
-static UINT SYS_JoystickID[MAX_JOYSTICKS];
-static JOYCAPSA SYS_Joystick[MAX_JOYSTICKS];
-static char *SYS_JoystickName[MAX_JOYSTICKS];
-
-/* The private structure used to keep track of a joystick */
-struct joystick_hwdata
-{
-    /* joystick ID */
-    UINT id;
-
-    /* values used to translate device-specific coordinates into
-       SDL-standard ranges */
-    struct _transaxis
-    {
-        int offset;
-        float scale;
-    } transaxis[6];
-};
-
-/* Convert a Windows Multimedia API return code to a text message */
-static void SetMMerror(char *function, int code);
-
-
-static char *
-GetJoystickName(int index, const char *szRegKey)
-{
-    /* added 7/24/2004 by Eckhard Stolberg */
-    /*
-       see if there is a joystick for the current
-       index (1-16) listed in the registry
-     */
-    char *name = NULL;
-    HKEY hTopKey;
-    HKEY hKey;
-    DWORD regsize;
-    LONG regresult;
-    char regkey[256];
-    char regvalue[256];
-    char regname[256];
-
-    SDL_snprintf(regkey, SDL_arraysize(regkey),
-#ifdef UNICODE
-                 "%S\\%s\\%S",
-#else
-                 "%s\\%s\\%s",
-#endif
-                 REGSTR_PATH_JOYCONFIG, szRegKey, REGSTR_KEY_JOYCURR);
-    hTopKey = HKEY_LOCAL_MACHINE;
-    regresult = RegOpenKeyExA(hTopKey, regkey, 0, KEY_READ, &hKey);
-    if (regresult != ERROR_SUCCESS) {
-        hTopKey = HKEY_CURRENT_USER;
-        regresult = RegOpenKeyExA(hTopKey, regkey, 0, KEY_READ, &hKey);
-    }
-    if (regresult != ERROR_SUCCESS) {
-        return NULL;
-    }
-
-    /* find the registry key name for the joystick's properties */
-    regsize = sizeof(regname);
-    SDL_snprintf(regvalue, SDL_arraysize(regvalue), "Joystick%d%s", index + 1,
-                 REGSTR_VAL_JOYOEMNAME);
-    regresult =
-        RegQueryValueExA(hKey, regvalue, 0, 0, (LPBYTE) regname, &regsize);
-    RegCloseKey(hKey);
-
-    if (regresult != ERROR_SUCCESS) {
-        return NULL;
-    }
-
-    /* open that registry key */
-    SDL_snprintf(regkey, SDL_arraysize(regkey),
-#ifdef UNICODE
-                 "%S\\%s",
-#else
-                 "%s\\%s",
-#endif
-                 REGSTR_PATH_JOYOEM, regname);
-    regresult = RegOpenKeyExA(hTopKey, regkey, 0, KEY_READ, &hKey);
-    if (regresult != ERROR_SUCCESS) {
-        return NULL;
-    }
-
-    /* find the size for the OEM name text */
-    regsize = sizeof(regvalue);
-    regresult =
-        RegQueryValueExA(hKey, REGSTR_VAL_JOYOEMNAME, 0, 0, NULL, &regsize);
-    if (regresult == ERROR_SUCCESS) {
-        /* allocate enough memory for the OEM name text ... */
-        name = (char *) SDL_malloc(regsize);
-        if (name) {
-            /* ... and read it from the registry */
-            regresult = RegQueryValueExA(hKey,
-                                         REGSTR_VAL_JOYOEMNAME, 0, 0,
-                                         (LPBYTE) name, &regsize);
-        }
-    }
-    RegCloseKey(hKey);
-
-    return (name);
-}
-
-static int SDL_SYS_numjoysticks = 0;
-
-/* Function to scan the system for joysticks.
- * Joystick 0 should be the system default joystick.
- * It should return 0, or -1 on an unrecoverable fatal error.
- */
-int
-SDL_SYS_JoystickInit(void)
-{
-    int i;
-    int maxdevs;
-    JOYINFOEX joyinfo;
-    JOYCAPSA joycaps;
-    MMRESULT result;
-
-    /* Reset the joystick ID & name mapping tables */
-    for (i = 0; i < MAX_JOYSTICKS; ++i) {
-        SYS_JoystickID[i] = 0;
-        SYS_JoystickName[i] = NULL;
-    }
-
-    /* Loop over all potential joystick devices */
-    SDL_SYS_numjoysticks = 0;
-    maxdevs = joyGetNumDevs();
-    for (i = JOYSTICKID1; i < maxdevs && SDL_SYS_numjoysticks < MAX_JOYSTICKS; ++i) {
-
-        joyinfo.dwSize = sizeof(joyinfo);
-        joyinfo.dwFlags = JOY_RETURNALL;
-        result = joyGetPosEx(i, &joyinfo);
-        if (result == JOYERR_NOERROR) {
-            result = joyGetDevCapsA(i, &joycaps, sizeof(joycaps));
-            if (result == JOYERR_NOERROR) {
-                SYS_JoystickID[SDL_SYS_numjoysticks] = i;
-                SYS_Joystick[SDL_SYS_numjoysticks] = joycaps;
-                SYS_JoystickName[SDL_SYS_numjoysticks] =
-                    GetJoystickName(i, joycaps.szRegKey);
-                SDL_SYS_numjoysticks++;
-            }
-        }
-    }
-    return (SDL_SYS_numjoysticks);
-}
-
-int
-SDL_SYS_NumJoysticks(void)
-{
-    return SDL_SYS_numjoysticks;
-}
-
-void
-SDL_SYS_JoystickDetect(void)
-{
-}
-
-/* Function to get the device-dependent name of a joystick */
-const char *
-SDL_SYS_JoystickNameForDeviceIndex(int device_index)
-{
-    if (SYS_JoystickName[device_index] != NULL) {
-        return (SYS_JoystickName[device_index]);
-    } else {
-        return (SYS_Joystick[device_index].szPname);
-    }
-}
-
-/* Function to perform the mapping from device index to the instance id for this index */
-SDL_JoystickID SDL_SYS_GetInstanceIdOfDeviceIndex(int device_index)
-{
-    return device_index;
-}
-
-/* Function to open a joystick for use.
-   The joystick to open is specified by the device index.
-   This should fill the nbuttons and naxes fields of the joystick structure.
-   It returns 0, or -1 if there is an error.
- */
-int
-SDL_SYS_JoystickOpen(SDL_Joystick * joystick, int device_index)
-{
-    int index, i;
-    int caps_flags[MAX_AXES - 2] =
-        { JOYCAPS_HASZ, JOYCAPS_HASR, JOYCAPS_HASU, JOYCAPS_HASV };
-    int axis_min[MAX_AXES], axis_max[MAX_AXES];
-
-
-    /* shortcut */
-    index = device_index;
-    axis_min[0] = SYS_Joystick[index].wXmin;
-    axis_max[0] = SYS_Joystick[index].wXmax;
-    axis_min[1] = SYS_Joystick[index].wYmin;
-    axis_max[1] = SYS_Joystick[index].wYmax;
-    axis_min[2] = SYS_Joystick[index].wZmin;
-    axis_max[2] = SYS_Joystick[index].wZmax;
-    axis_min[3] = SYS_Joystick[index].wRmin;
-    axis_max[3] = SYS_Joystick[index].wRmax;
-    axis_min[4] = SYS_Joystick[index].wUmin;
-    axis_max[4] = SYS_Joystick[index].wUmax;
-    axis_min[5] = SYS_Joystick[index].wVmin;
-    axis_max[5] = SYS_Joystick[index].wVmax;
-
-    /* allocate memory for system specific hardware data */
-    joystick->instance_id = device_index;
-    joystick->hwdata =
-        (struct joystick_hwdata *) SDL_malloc(sizeof(*joystick->hwdata));
-    if (joystick->hwdata == NULL) {
-        return SDL_OutOfMemory();
-    }
-    SDL_memset(joystick->hwdata, 0, sizeof(*joystick->hwdata));
-
-    /* set hardware data */
-    joystick->hwdata->id = SYS_JoystickID[index];
-    for (i = 0; i < MAX_AXES; ++i) {
-        if ((i < 2) || (SYS_Joystick[index].wCaps & caps_flags[i - 2])) {
-            joystick->hwdata->transaxis[i].offset = SDL_JOYSTICK_AXIS_MIN - axis_min[i];
-            joystick->hwdata->transaxis[i].scale =
-                (float) (SDL_JOYSTICK_AXIS_MAX - SDL_JOYSTICK_AXIS_MIN) / (axis_max[i] - axis_min[i]);
-        } else {
-            joystick->hwdata->transaxis[i].offset = 0;
-            joystick->hwdata->transaxis[i].scale = 1.0; /* Just in case */
-        }
-    }
-
-    /* fill nbuttons, naxes, and nhats fields */
-    joystick->nbuttons = SYS_Joystick[index].wNumButtons;
-    joystick->naxes = SYS_Joystick[index].wNumAxes;
-    if (SYS_Joystick[index].wCaps & JOYCAPS_HASPOV) {
-        joystick->nhats = 1;
-    } else {
-        joystick->nhats = 0;
-    }
-    return (0);
-}
-
-static Uint8
-TranslatePOV(DWORD value)
-{
-    Uint8 pos;
-
-    pos = SDL_HAT_CENTERED;
-    if (value != JOY_POVCENTERED) {
-        if ((value > JOY_POVLEFT) || (value < JOY_POVRIGHT)) {
-            pos |= SDL_HAT_UP;
-        }
-        if ((value > JOY_POVFORWARD) && (value < JOY_POVBACKWARD)) {
-            pos |= SDL_HAT_RIGHT;
-        }
-        if ((value > JOY_POVRIGHT) && (value < JOY_POVLEFT)) {
-            pos |= SDL_HAT_DOWN;
-        }
-        if (value > JOY_POVBACKWARD) {
-            pos |= SDL_HAT_LEFT;
-        }
-    }
-    return (pos);
-}
-
-/* Function to update the state of a joystick - called as a device poll.
- * This function shouldn't update the joystick structure directly,
- * but instead should call SDL_PrivateJoystick*() to deliver events
- * and update joystick device state.
- */
-void
-SDL_SYS_JoystickUpdate(SDL_Joystick * joystick)
-{
-    MMRESULT result;
-    int i;
-    DWORD flags[MAX_AXES] = { JOY_RETURNX, JOY_RETURNY, JOY_RETURNZ,
-        JOY_RETURNR, JOY_RETURNU, JOY_RETURNV
-    };
-    DWORD pos[MAX_AXES];
-    struct _transaxis *transaxis;
-    int value;
-    JOYINFOEX joyinfo;
-
-    joyinfo.dwSize = sizeof(joyinfo);
-    joyinfo.dwFlags = JOY_RETURNALL | JOY_RETURNPOVCTS;
-    if (!joystick->hats) {
-        joyinfo.dwFlags &= ~(JOY_RETURNPOV | JOY_RETURNPOVCTS);
-    }
-    result = joyGetPosEx(joystick->hwdata->id, &joyinfo);
-    if (result != JOYERR_NOERROR) {
-        SetMMerror("joyGetPosEx", result);
-        return;
-    }
-
-    /* joystick motion events */
-    pos[0] = joyinfo.dwXpos;
-    pos[1] = joyinfo.dwYpos;
-    pos[2] = joyinfo.dwZpos;
-    pos[3] = joyinfo.dwRpos;
-    pos[4] = joyinfo.dwUpos;
-    pos[5] = joyinfo.dwVpos;
-
-    transaxis = joystick->hwdata->transaxis;
-    for (i = 0; i < joystick->naxes; i++) {
-        if (joyinfo.dwFlags & flags[i]) {
-            value = (int) (((float) pos[i] + transaxis[i].offset) * transaxis[i].scale);
-            SDL_PrivateJoystickAxis(joystick, (Uint8) i, (Sint16) value);
-        }
-    }
-
-    /* joystick button events */
-    if (joyinfo.dwFlags & JOY_RETURNBUTTONS) {
-        for (i = 0; i < joystick->nbuttons; ++i) {
-            if (joyinfo.dwButtons & JOY_BUTTON_FLAG(i)) {
-                SDL_PrivateJoystickButton(joystick, (Uint8) i, SDL_PRESSED);
-            } else {
-                SDL_PrivateJoystickButton(joystick, (Uint8) i, SDL_RELEASED);
-            }
-        }
-    }
-
-    /* joystick hat events */
-    if (joyinfo.dwFlags & JOY_RETURNPOV) {
-        SDL_PrivateJoystickHat(joystick, 0, TranslatePOV(joyinfo.dwPOV));
-    }
-}
-
-/* Function to close a joystick after use */
-void
-SDL_SYS_JoystickClose(SDL_Joystick * joystick)
-{
-    SDL_free(joystick->hwdata);
-}
-
-/* Function to perform any system-specific joystick related cleanup */
-void
-SDL_SYS_JoystickQuit(void)
-{
-    int i;
-    for (i = 0; i < MAX_JOYSTICKS; i++) {
-        SDL_free(SYS_JoystickName[i]);
-        SYS_JoystickName[i] = NULL;
-    }
-}
-
-SDL_JoystickGUID SDL_SYS_JoystickGetDeviceGUID( int device_index )
-{
-    SDL_JoystickGUID guid;
-    /* the GUID is just the first 16 chars of the name for now */
-    const char *name = SDL_SYS_JoystickNameForDeviceIndex( device_index );
-    SDL_zero( guid );
-    SDL_memcpy( &guid, name, SDL_min( sizeof(guid), SDL_strlen( name ) ) );
-    return guid;
-}
-
-SDL_JoystickGUID SDL_SYS_JoystickGetGUID(SDL_Joystick * joystick)
-{
-    SDL_JoystickGUID guid;
-    /* the GUID is just the first 16 chars of the name for now */
-    const char *name = joystick->name;
-    SDL_zero( guid );
-    SDL_memcpy( &guid, name, SDL_min( sizeof(guid), SDL_strlen( name ) ) );
-    return guid;
-}
-
-
-/* implementation functions */
-void
-SetMMerror(char *function, int code)
-{
-    static char *error;
-    static char errbuf[1024];
-
-    errbuf[0] = 0;
-    switch (code) {
-    case MMSYSERR_NODRIVER:
-        error = "Joystick driver not present";
-        break;
-
-    case MMSYSERR_INVALPARAM:
-    case JOYERR_PARMS:
-        error = "Invalid parameter(s)";
-        break;
-
-    case MMSYSERR_BADDEVICEID:
-        error = "Bad device ID";
-        break;
-
-    case JOYERR_UNPLUGGED:
-        error = "Joystick not attached";
-        break;
-
-    case JOYERR_NOCANDO:
-        error = "Can't capture joystick input";
-        break;
-
-    default:
-        SDL_snprintf(errbuf, SDL_arraysize(errbuf),
-                     "%s: Unknown Multimedia system error: 0x%x",
-                     function, code);
-        break;
-    }
-
-    if (!errbuf[0]) {
-        SDL_snprintf(errbuf, SDL_arraysize(errbuf), "%s: %s", function,
-                     error);
-    }
-    SDL_SetError("%s", errbuf);
-}
-
-#endif /* SDL_JOYSTICK_WINMM */
-
-/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/joystick/windows/SDL_rawinputjoystick.c b/Engine/lib/sdl/src/joystick/windows/SDL_rawinputjoystick.c
index 0af76b023..32b637827 100644
--- a/Engine/lib/sdl/src/joystick/windows/SDL_rawinputjoystick.c
+++ b/Engine/lib/sdl/src/joystick/windows/SDL_rawinputjoystick.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 2019 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -40,12 +40,15 @@
 #include "SDL_timer.h"
 #include "../usb_ids.h"
 #include "../SDL_sysjoystick.h"
+#include "../controller_type.h"
 #include "../../core/windows/SDL_windows.h"
 #include "../../core/windows/SDL_hid.h"
 #include "../hidapi/SDL_hidapijoystick_c.h"
 
+#ifdef HAVE_XINPUT_H
 #define SDL_JOYSTICK_RAWINPUT_XINPUT
-#ifdef SDL_WINDOWS10_SDK
+#endif
+#ifdef HAVE_WINDOWS_GAMING_INPUT_H
 #define SDL_JOYSTICK_RAWINPUT_WGI
 #endif
 
@@ -64,6 +67,12 @@ typedef struct WindowsGamingInputGamepadState WindowsGamingInputGamepadState;
 #if defined(SDL_JOYSTICK_RAWINPUT_XINPUT) || defined(SDL_JOYSTICK_RAWINPUT_WGI)
 #define SDL_JOYSTICK_RAWINPUT_MATCHING
 #define SDL_JOYSTICK_RAWINPUT_MATCH_AXES
+#define SDL_JOYSTICK_RAWINPUT_MATCH_TRIGGERS
+#ifdef SDL_JOYSTICK_RAWINPUT_MATCH_TRIGGERS
+#define SDL_JOYSTICK_RAWINPUT_MATCH_COUNT 6 // stick + trigger axes
+#else
+#define SDL_JOYSTICK_RAWINPUT_MATCH_COUNT 4 // stick axes
+#endif
 #endif
 
 /*#define DEBUG_RAWINPUT*/
@@ -100,6 +109,7 @@ typedef struct _SDL_RAWINPUT_Device
     Uint16 version;
     SDL_JoystickGUID guid;
     SDL_bool is_xinput;
+    SDL_bool is_xboxone;
     PHIDP_PREPARSED_DATA preparsed_data;
 
     HANDLE hDevice;
@@ -112,6 +122,7 @@ typedef struct _SDL_RAWINPUT_Device
 struct joystick_hwdata
 {
     SDL_bool is_xinput;
+    SDL_bool is_xboxone;
     PHIDP_PREPARSED_DATA preparsed_data;
     ULONG max_data_length;
     HIDP_DATA *data;
@@ -123,7 +134,7 @@ struct joystick_hwdata
     USHORT trigger_hack_index;
 
 #ifdef SDL_JOYSTICK_RAWINPUT_MATCHING
-    Uint32 match_state; /* Low 16 bits for button states, high 16 for 4 4bit axes */
+    Uint64 match_state; /* Lowest 16 bits for button states, higher 24 for 6 4bit axes */
     Uint32 last_state_packet;
 #endif
 
@@ -168,7 +179,7 @@ static struct {
 
 typedef struct WindowsMatchState {
 #ifdef SDL_JOYSTICK_RAWINPUT_MATCH_AXES
-    SHORT match_axes[4];
+    SHORT match_axes[SDL_JOYSTICK_RAWINPUT_MATCH_COUNT];
 #endif
 #ifdef SDL_JOYSTICK_RAWINPUT_XINPUT
     WORD xinput_buttons;
@@ -179,13 +190,13 @@ typedef struct WindowsMatchState {
     SDL_bool any_data;
 } WindowsMatchState;
 
-static void RAWINPUT_FillMatchState(WindowsMatchState *state, Uint32 match_state)
+static void RAWINPUT_FillMatchState(WindowsMatchState *state, Uint64 match_state)
 {
 #ifdef SDL_JOYSTICK_RAWINPUT_MATCH_AXES
     int ii;
 #endif
 
-    state->any_data = SDL_FALSE;
+    SDL_bool any_axes_data = SDL_FALSE;
 #ifdef SDL_JOYSTICK_RAWINPUT_MATCH_AXES
     /*  SHORT state->match_axes[4] = {
             (match_state & 0x000F0000) >> 4,
@@ -194,12 +205,18 @@ static void RAWINPUT_FillMatchState(WindowsMatchState *state, Uint32 match_state
             (match_state & 0xF0000000) >> 16,
         }; */
     for (ii = 0; ii < 4; ii++) {
-        state->match_axes[ii] = (match_state & (0x000F0000 << (ii * 4))) >> (4 + ii * 4);
-        if ((Uint32)(state->match_axes[ii] + 0x1000) > 0x2000) { /* match_state bit is not 0xF, 0x1, or 0x2 */
-            state->any_data = SDL_TRUE;
-        }
+        state->match_axes[ii] = (SHORT)((match_state & (0x000F0000ull << (ii * 4))) >> (4 + ii * 4));
+        any_axes_data |= ((Uint32)(state->match_axes[ii] + 0x1000) > 0x2000); /* match_state bit is not 0xF, 0x1, or 0x2 */
     }
 #endif /* SDL_JOYSTICK_RAWINPUT_MATCH_AXES */
+#ifdef SDL_JOYSTICK_RAWINPUT_MATCH_TRIGGERS
+    for (; ii < SDL_JOYSTICK_RAWINPUT_MATCH_COUNT; ii++) {
+        state->match_axes[ii] = (SHORT)((match_state & (0x000F0000ull << (ii * 4))) >> (4 + ii * 4));
+        any_axes_data |= (state->match_axes[ii] != SDL_MIN_SINT16);
+    }
+#endif /* SDL_JOYSTICK_RAWINPUT_MATCH_TRIGGERS */
+
+    state->any_data = any_axes_data;
 
 #ifdef SDL_JOYSTICK_RAWINPUT_XINPUT
     /* Match axes by checking if the distance between the high 4 bits of axis and the 4 bits from match_state is 1 or less */
@@ -215,9 +232,16 @@ static void RAWINPUT_FillMatchState(WindowsMatchState *state, Uint32 match_state
     SDL_abs((Sint8)((gamepad.sThumbRX & 0xF000) >> 8) - ((match_state & 0x0F000000) >> 20)) <= 0x10 && \
     SDL_abs((Sint8)((~gamepad.sThumbRY & 0xF000) >> 8) - ((match_state & 0xF0000000) >> 24)) <= 0x10) */
 
+    /* Can only match trigger values if a single trigger has a value. */
+#define XInputTriggersMatch(gamepad) ( \
+    ((state->match_axes[4] == SDL_MIN_SINT16) && (state->match_axes[5] == SDL_MIN_SINT16)) || \
+    ((gamepad.bLeftTrigger != 0) && (gamepad.bRightTrigger != 0)) || \
+    ((Uint32)((((int)gamepad.bLeftTrigger * 257) - 32768) - state->match_axes[4]) <= 0x2fff) || \
+    ((Uint32)((((int)gamepad.bRightTrigger * 257) - 32768) - state->match_axes[5]) <= 0x2fff))
+
     state->xinput_buttons =
         /* Bitwise map .RLDUWVQTS.KYXBA -> YXBA..WVQTKSRLDU */
-        match_state << 12 | (match_state & 0x0780) >> 1 | (match_state & 0x0010) << 1 | (match_state & 0x0040) >> 2 | (match_state & 0x7800) >> 11;
+        (WORD)(match_state << 12 | (match_state & 0x0780) >> 1 | (match_state & 0x0010) << 1 | (match_state & 0x0040) >> 2 | (match_state & 0x7800) >> 11);
     /*  Explicit
         ((match_state & (1<<SDL_CONTROLLER_BUTTON_A)) ? XINPUT_GAMEPAD_A : 0) |
         ((match_state & (1<<SDL_CONTROLLER_BUTTON_B)) ? XINPUT_GAMEPAD_B : 0) |
@@ -247,6 +271,11 @@ static void RAWINPUT_FillMatchState(WindowsMatchState *state, Uint32 match_state
     (Uint16)(((Sint16)(gamepad.RightThumbstickX * SDL_MAX_SINT16) & 0xF000) - state->match_axes[2] + 0x1000) <= 0x2fff && \
     (Uint16)((~(Sint16)(gamepad.RightThumbstickY * SDL_MAX_SINT16) & 0xF000) - state->match_axes[3] + 0x1000) <= 0x2fff)
 
+#define WindowsGamingInputTriggersMatch(gamepad) ( \
+    ((state->match_axes[4] == SDL_MIN_SINT16) && (state->match_axes[5] == SDL_MIN_SINT16)) || \
+    ((gamepad.LeftTrigger == 0.0f) && (gamepad.RightTrigger == 0.0f)) || \
+    ((Uint16)((((int)(gamepad.LeftTrigger * SDL_MAX_UINT16)) - 32768) - state->match_axes[4]) <= 0x2fff) || \
+    ((Uint16)((((int)(gamepad.RightTrigger * SDL_MAX_UINT16)) - 32768) - state->match_axes[5]) <= 0x2fff))
 
     state->wgi_buttons =
         /* Bitwise map .RLD UWVQ TS.K YXBA -> ..QT WVRL DUYX BAKS */
@@ -349,6 +378,9 @@ RAWINPUT_XInputSlotMatches(const WindowsMatchState *state, Uint8 slot_idx)
         if ((xinput_buttons & ~XINPUT_GAMEPAD_GUIDE) == state->xinput_buttons
 #ifdef SDL_JOYSTICK_RAWINPUT_MATCH_AXES
             && XInputAxesMatch(xinput_state[slot_idx].state.Gamepad)
+#endif
+#ifdef SDL_JOYSTICK_RAWINPUT_MATCH_TRIGGERS
+            && XInputTriggersMatch(xinput_state[slot_idx].state.Gamepad)
 #endif
             ) {
             return SDL_TRUE;
@@ -447,12 +479,12 @@ RAWINPUT_UpdateWindowsGamingInput()
     wgi_state.dirty = SDL_FALSE;
 
     if (wgi_state.need_device_list_update) {
+        HRESULT hr;
+        __FIVectorView_1_Windows__CGaming__CInput__CGamepad *gamepads;
         wgi_state.need_device_list_update = SDL_FALSE;
         for (ii = 0; ii < wgi_state.per_gamepad_count; ii++) {
             wgi_state.per_gamepad[ii]->connected = SDL_FALSE;
         }
-        HRESULT hr;
-        __FIVectorView_1_Windows__CGaming__CInput__CGamepad *gamepads;
 
         hr = __x_ABI_CWindows_CGaming_CInput_CIGamepadStatics_get_Gamepads(wgi_state.gamepad_statics, &gamepads);
         if (SUCCEEDED(hr)) {
@@ -477,13 +509,15 @@ RAWINPUT_UpdateWindowsGamingInput()
                         }
                         if (!found) {
                             /* New device, add it */
+                            WindowsGamingInputGamepadState *gamepad_state;
+
                             wgi_state.per_gamepad_count++;
                             wgi_state.per_gamepad = SDL_realloc(wgi_state.per_gamepad, sizeof(wgi_state.per_gamepad[0]) * wgi_state.per_gamepad_count);
                             if (!wgi_state.per_gamepad) {
                                 SDL_OutOfMemory();
                                 return;
                             }
-                            WindowsGamingInputGamepadState *gamepad_state = SDL_calloc(1, sizeof(*gamepad_state));
+                            gamepad_state = SDL_calloc(1, sizeof(*gamepad_state));
                             if (!gamepad_state) {
                                 SDL_OutOfMemory();
                                 return;
@@ -529,6 +563,10 @@ RAWINPUT_InitWindowsGamingInput(RAWINPUT_DeviceContext *ctx)
     wgi_state.need_device_list_update = SDL_TRUE;
     wgi_state.ref_count++;
     if (!wgi_state.initialized) {
+        static const IID SDL_IID_IGamepadStatics = { 0x8BBCE529, 0xD49C, 0x39E9, { 0x95, 0x60, 0xE4, 0x7D, 0xDE, 0x96, 0xB7, 0xC8 } };
+        HRESULT hr;
+        HMODULE hModule;
+
         /* I think this takes care of RoInitialize() in a way that is compatible with the rest of SDL */
         if (FAILED(WIN_CoInitialize())) {
             return;
@@ -536,9 +574,7 @@ RAWINPUT_InitWindowsGamingInput(RAWINPUT_DeviceContext *ctx)
         wgi_state.initialized = SDL_TRUE;
         wgi_state.dirty = SDL_TRUE;
 
-        static const IID SDL_IID_IGamepadStatics = { 0x8BBCE529, 0xD49C, 0x39E9, { 0x95, 0x60, 0xE4, 0x7D, 0xDE, 0x96, 0xB7, 0xC8 } };
-        HRESULT hr;
-        HMODULE hModule = LoadLibraryA("combase.dll");
+        hModule = LoadLibraryA("combase.dll");
         if (hModule != NULL) {
             typedef HRESULT (WINAPI *WindowsCreateStringReference_t)(PCWSTR sourceString, UINT32 length, HSTRING_HEADER *hstringHeader, HSTRING* string);
             typedef HRESULT (WINAPI *RoGetActivationFactory_t)(HSTRING activatableClassId, REFIID iid, void** factory);
@@ -546,13 +582,13 @@ RAWINPUT_InitWindowsGamingInput(RAWINPUT_DeviceContext *ctx)
             WindowsCreateStringReference_t WindowsCreateStringReferenceFunc = (WindowsCreateStringReference_t)GetProcAddress(hModule, "WindowsCreateStringReference");
             RoGetActivationFactory_t RoGetActivationFactoryFunc = (RoGetActivationFactory_t)GetProcAddress(hModule, "RoGetActivationFactory");
             if (WindowsCreateStringReferenceFunc && RoGetActivationFactoryFunc) {
-                LPTSTR pNamespace = L"Windows.Gaming.Input.Gamepad";
+                PCWSTR pNamespace = L"Windows.Gaming.Input.Gamepad";
                 HSTRING_HEADER hNamespaceStringHeader;
                 HSTRING hNamespaceString;
 
                 hr = WindowsCreateStringReferenceFunc(pNamespace, (UINT32)SDL_wcslen(pNamespace), &hNamespaceStringHeader, &hNamespaceString);
                 if (SUCCEEDED(hr)) {
-                    RoGetActivationFactoryFunc(hNamespaceString, &SDL_IID_IGamepadStatics, &wgi_state.gamepad_statics);
+                    RoGetActivationFactoryFunc(hNamespaceString, &SDL_IID_IGamepadStatics, (void **)&wgi_state.gamepad_statics);
                 }
             }
             FreeLibrary(hModule);
@@ -561,12 +597,16 @@ RAWINPUT_InitWindowsGamingInput(RAWINPUT_DeviceContext *ctx)
 }
 
 static SDL_bool
-RAWINPUT_WindowsGamingInputSlotMatches(const WindowsMatchState *state, WindowsGamingInputGamepadState *slot)
+RAWINPUT_WindowsGamingInputSlotMatches(const WindowsMatchState *state, WindowsGamingInputGamepadState *slot, SDL_bool xinput_correlated)
 {
     Uint32 wgi_buttons = slot->state.Buttons;
     if ((wgi_buttons & 0x3FFF) == state->wgi_buttons
 #ifdef SDL_JOYSTICK_RAWINPUT_MATCH_AXES
             && WindowsGamingInputAxesMatch(slot->state)
+#endif
+#ifdef SDL_JOYSTICK_RAWINPUT_MATCH_TRIGGERS
+            // Don't try to match WGI triggers if getting values from XInput
+            && (xinput_correlated || WindowsGamingInputTriggersMatch(slot->state))
 #endif
        ) {
         return SDL_TRUE;
@@ -575,14 +615,14 @@ RAWINPUT_WindowsGamingInputSlotMatches(const WindowsMatchState *state, WindowsGa
 }
 
 static SDL_bool
-RAWINPUT_GuessWindowsGamingInputSlot(const WindowsMatchState *state, Uint8 *correlation_id, WindowsGamingInputGamepadState **slot)
+RAWINPUT_GuessWindowsGamingInputSlot(const WindowsMatchState *state, Uint8 *correlation_id, WindowsGamingInputGamepadState **slot, SDL_bool xinput_correlated)
 {
     int match_count, user_index;
 
     match_count = 0;
     for (user_index = 0; user_index < wgi_state.per_gamepad_count; ++user_index) {
         WindowsGamingInputGamepadState *gamepad_state = wgi_state.per_gamepad[user_index];
-        if (RAWINPUT_WindowsGamingInputSlotMatches(state, gamepad_state)) {
+        if (RAWINPUT_WindowsGamingInputSlotMatches(state, gamepad_state, xinput_correlated)) {
             ++match_count;
             *slot = gamepad_state;
             /* Incrementing correlation_id for any match, as negative evidence for others being correlated */
@@ -670,7 +710,7 @@ RAWINPUT_DeviceFromHandle(HANDLE hDevice)
 static void
 RAWINPUT_AddDevice(HANDLE hDevice)
 {
-#define CHECK(exp) { if(!(exp)) goto err; }
+#define CHECK(expression) { if(!(expression)) goto err; }
     SDL_RAWINPUT_Device *device = NULL;
     SDL_RAWINPUT_Device *curr, *last;
     RID_DEVICE_INFO rdi;
@@ -703,6 +743,7 @@ RAWINPUT_AddDevice(HANDLE hDevice)
     device->product_id = (Uint16)rdi.hid.dwProductId;
     device->version = (Uint16)rdi.hid.dwVersionNumber;
     device->is_xinput = SDL_TRUE;
+    device->is_xboxone = GuessControllerType(device->vendor_id, device->product_id) == k_eControllerType_XBoxOneController;
 
     {
         const Uint16 vendor = device->vendor_id;
@@ -733,10 +774,10 @@ RAWINPUT_AddDevice(HANDLE hDevice)
         WCHAR string[128];
 
         if (SDL_HidD_GetManufacturerString(hFile, string, sizeof(string))) {
-            manufacturer_string = WIN_StringToUTF8(string);
+            manufacturer_string = WIN_StringToUTF8W(string);
         }
         if (SDL_HidD_GetProductString(hFile, string, sizeof(string))) {
-            product_string = WIN_StringToUTF8(string);
+            product_string = WIN_StringToUTF8W(string);
         }
 
         device->name = SDL_CreateJoystickName(device->vendor_id, device->product_id, manufacturer_string, product_string);
@@ -880,16 +921,19 @@ RAWINPUT_IsDevicePresent(Uint16 vendor_id, Uint16 product_id, Uint16 version, co
             return SDL_TRUE;
         }
 
-        /* The Xbox 360 wireless controller shows up as product 0 in WGI */
+        /* The Xbox 360 wireless controller shows up as product 0 in WGI.
+           Try to match it to a Raw Input device via name or known product ID. */
         if (vendor_id == device->vendor_id && product_id == 0 &&
-            name && SDL_strstr(device->name, name) != NULL) {
+            ((name && SDL_strstr(device->name, name) != NULL) ||
+             (device->vendor_id == USB_VENDOR_MICROSOFT &&
+              device->product_id == USB_PRODUCT_XBOX360_XUSB_CONTROLLER))) {
             return SDL_TRUE;
         }
 
         /* The Xbox One controller shows up as a hardcoded raw input VID/PID */
         if (name && SDL_strcmp(name, "Xbox One Game Controller") == 0 &&
             device->vendor_id == USB_VENDOR_MICROSOFT &&
-            device->product_id == USB_PRODUCT_XBOX_ONE_RAW_INPUT_CONTROLLER) {
+            device->product_id == USB_PRODUCT_XBOX_ONE_XBOXGIP_CONTROLLER) {
             return SDL_TRUE;
         }
 
@@ -1040,7 +1084,7 @@ RAWINPUT_JoystickOpen(SDL_Joystick *joystick, int device_index)
         /* We'll try to get guide button and trigger axes from XInput */
 #ifdef SDL_JOYSTICK_RAWINPUT_XINPUT
         xinput_device_change = SDL_TRUE;
-        ctx->xinput_enabled = SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_CORRELATE_XINPUT, SDL_TRUE);
+        ctx->xinput_enabled = SDL_GetHintBoolean(SDL_HINT_JOYSTICK_RAWINPUT_CORRELATE_XINPUT, SDL_TRUE);
         if (ctx->xinput_enabled && (WIN_LoadXInputDLL() < 0 || !XINPUTGETSTATE)) {
             ctx->xinput_enabled = SDL_FALSE;
         }
@@ -1052,6 +1096,7 @@ RAWINPUT_JoystickOpen(SDL_Joystick *joystick, int device_index)
     }
 
     ctx->is_xinput = device->is_xinput;
+    ctx->is_xboxone = device->is_xboxone;
     ctx->preparsed_data = device->preparsed_data;
     ctx->max_data_length = SDL_HidP_MaxDataListLength(HidP_Input, ctx->preparsed_data);
     ctx->data = (HIDP_DATA *)SDL_malloc(ctx->max_data_length * sizeof(*ctx->data));
@@ -1216,9 +1261,8 @@ RAWINPUT_JoystickRumble(SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uin
 {
 #if defined(SDL_JOYSTICK_RAWINPUT_WGI) || defined(SDL_JOYSTICK_RAWINPUT_XINPUT)
     RAWINPUT_DeviceContext *ctx = joystick->hwdata;
-#endif
-
     SDL_bool rumbled = SDL_FALSE;
+#endif
 
 #ifdef SDL_JOYSTICK_RAWINPUT_WGI
     if (!rumbled && ctx->wgi_correlated) {
@@ -1251,6 +1295,13 @@ RAWINPUT_JoystickRumble(SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uin
     }
 #endif /* SDL_JOYSTICK_RAWINPUT_XINPUT */
 
+    if (!rumbled) {
+#if defined(SDL_JOYSTICK_RAWINPUT_WGI) || defined(SDL_JOYSTICK_RAWINPUT_XINPUT)
+        return SDL_SetError("Controller isn't correlated yet, try hitting a button first");
+#else
+        return SDL_Unsupported();
+#endif
+    }
     return 0;
 }
 
@@ -1267,7 +1318,7 @@ RAWINPUT_JoystickRumbleTriggers(SDL_Joystick *joystick, Uint16 left_rumble, Uint
         gamepad_state->vibration.RightTrigger = (DOUBLE)right_rumble / SDL_MAX_UINT16;
         hr = __x_ABI_CWindows_CGaming_CInput_CIGamepad_put_Vibration(gamepad_state->gamepad, gamepad_state->vibration);
         if (!SUCCEEDED(hr)) {
-            return SDL_SetError("Setting vibration failed: 0x%x\n", hr);
+            return SDL_SetError("Setting vibration failed: 0x%lx\n", hr);
         }
     }
     return 0;
@@ -1276,10 +1327,29 @@ RAWINPUT_JoystickRumbleTriggers(SDL_Joystick *joystick, Uint16 left_rumble, Uint
 #endif
 }
 
-static SDL_bool
-RAWINPUT_JoystickHasLED(SDL_Joystick *joystick)
+static Uint32
+RAWINPUT_JoystickGetCapabilities(SDL_Joystick *joystick)
 {
-    return SDL_FALSE;
+    RAWINPUT_DeviceContext *ctx = joystick->hwdata;
+    Uint32 result = 0;
+
+#ifdef SDL_JOYSTICK_RAWINPUT_XINPUT
+    if (ctx->is_xinput) {
+        result |= SDL_JOYCAP_RUMBLE;
+    }
+#endif
+
+#ifdef SDL_JOYSTICK_RAWINPUT_WGI
+    if (ctx->is_xinput) {
+        result |= SDL_JOYCAP_RUMBLE;
+
+        if (ctx->is_xboxone) {
+            result |= SDL_JOYCAP_RUMBLE_TRIGGERS;
+        }
+    }
+#endif
+
+    return result;
 }
 
 static int
@@ -1288,6 +1358,12 @@ RAWINPUT_JoystickSetLED(SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 bl
     return SDL_Unsupported();
 }
 
+static int
+RAWINPUT_JoystickSendEffect(SDL_Joystick *joystick, const void *data, int size)
+{
+    return SDL_Unsupported();
+}
+
 static int
 RAWINPUT_JoystickSetSensorsEnabled(SDL_Joystick *joystick, SDL_bool enabled)
 {
@@ -1348,12 +1424,13 @@ RAWINPUT_HandleStatePacket(SDL_Joystick *joystick, Uint8 *data, int size)
         (1 << SDL_CONTROLLER_BUTTON_DPAD_LEFT),
         (1 << SDL_CONTROLLER_BUTTON_DPAD_UP) | (1 << SDL_CONTROLLER_BUTTON_DPAD_LEFT),
     };
-    Uint32 match_state = ctx->match_state;
+    Uint64 match_state = ctx->match_state;
     /* Update match_state with button bit, then fall through */
-#define SDL_PrivateJoystickButton(joystick, button, state) if (button < SDL_arraysize(button_map)) { if (state) match_state |= 1 << button_map[button]; else match_state &= ~(1 << button_map[button]); } SDL_PrivateJoystickButton(joystick, button, state)
+#define SDL_PrivateJoystickButton(joystick, button, state) if (button < SDL_arraysize(button_map)) { Uint64 button_bit = 1ull << button_map[button]; match_state = (match_state & ~button_bit) | (button_bit * (state)); } SDL_PrivateJoystickButton(joystick, button, state)
 #ifdef SDL_JOYSTICK_RAWINPUT_MATCH_AXES
     /* Grab high 4 bits of value, then fall through */
-#define SDL_PrivateJoystickAxis(joystick, axis, value) if (axis < 4) match_state = (match_state & ~(0xF << (4 * axis + 16))) | ((value) & 0xF000) << (4 * axis + 4); SDL_PrivateJoystickAxis(joystick, axis, value)
+#define AddAxisToMatchState(axis, value) { match_state = (match_state & ~(0xFull << (4 * axis + 16))) | ((value) & 0xF000ull) << (4 * axis + 4); }
+#define SDL_PrivateJoystickAxis(joystick, axis, value) if (axis < 4) AddAxisToMatchState(axis, value); SDL_PrivateJoystickAxis(joystick, axis, value)
 #endif
 #endif /* SDL_JOYSTICK_RAWINPUT_MATCHING */
 
@@ -1418,8 +1495,14 @@ RAWINPUT_HandleStatePacket(SDL_Joystick *joystick, Uint8 *data, int size)
 #undef SDL_PrivateJoystickAxis
 #endif
 
+#ifdef SDL_JOYSTICK_RAWINPUT_MATCH_TRIGGERS
+#define AddTriggerToMatchState(axis, value) { int match_axis = axis + SDL_JOYSTICK_RAWINPUT_MATCH_COUNT - joystick->naxes; AddAxisToMatchState(match_axis, value); }
+#endif /* SDL_JOYSTICK_RAWINPUT_MATCH_TRIGGERS */
+
     if (ctx->trigger_hack) {
         SDL_bool has_trigger_data = SDL_FALSE;
+        int left_trigger = joystick->naxes - 2;
+        int right_trigger = joystick->naxes - 1;
 
 #ifdef SDL_JOYSTICK_RAWINPUT_XINPUT
         /* Prefer XInput over WindowsGamingInput, it continues to provide data in the background */
@@ -1434,28 +1517,36 @@ RAWINPUT_HandleStatePacket(SDL_Joystick *joystick, Uint8 *data, int size)
         }
 #endif /* SDL_JOYSTICK_RAWINPUT_WGI */
 
-        if (!has_trigger_data) {
+#ifndef SDL_JOYSTICK_RAWINPUT_MATCH_TRIGGERS
+        if (!has_trigger_data)
+#endif
+        {
             HIDP_DATA *item = GetData(ctx->trigger_hack_index, ctx->data, data_length);
             if (item) {
-                int left_trigger = joystick->naxes - 2;
-                int right_trigger = joystick->naxes - 1;
                 Sint16 value = (int)(Uint16)item->RawValue - 0x8000;
-                if (value < 0) {
-                    value = -value * 2 - 32769;
-                    SDL_PrivateJoystickAxis(joystick, left_trigger, SDL_MIN_SINT16);
-                    SDL_PrivateJoystickAxis(joystick, right_trigger, value);
-                } else if (value > 0) {
-                    value = value * 2 - 32767;
-                    SDL_PrivateJoystickAxis(joystick, left_trigger, value);
-                    SDL_PrivateJoystickAxis(joystick, right_trigger, SDL_MIN_SINT16);
-                } else {
-                    SDL_PrivateJoystickAxis(joystick, left_trigger, SDL_MIN_SINT16);
-                    SDL_PrivateJoystickAxis(joystick, right_trigger, SDL_MIN_SINT16);
+                Sint16 left_value = (value > 0) ? (value * 2 - 32767) : SDL_MIN_SINT16;
+                Sint16 right_value = (value < 0) ? (-value * 2 - 32769) : SDL_MIN_SINT16;
+        
+#ifdef SDL_JOYSTICK_RAWINPUT_MATCH_TRIGGERS
+                AddTriggerToMatchState(left_trigger, left_value);
+                AddTriggerToMatchState(right_trigger, right_value);
+                if (!has_trigger_data)
+#endif /* SDL_JOYSTICK_RAWINPUT_MATCH_TRIGGERS */
+                {
+                    SDL_PrivateJoystickAxis(joystick, left_trigger, left_value);
+                    SDL_PrivateJoystickAxis(joystick, right_trigger, right_value);
                 }
             }
         }
     }
 
+#ifdef AddAxisToMatchState
+#undef AddAxisToMatchState
+#endif
+#ifdef AddTriggerToMatchState
+#undef AddTriggerToMatchState
+#endif
+
 #ifdef SDL_JOYSTICK_RAWINPUT_MATCHING
     if (ctx->is_xinput) {
         ctx->match_state = match_state;
@@ -1481,17 +1572,19 @@ RAWINPUT_UpdateOtherAPIs(SDL_Joystick *joystick)
 #ifdef SDL_JOYSTICK_RAWINPUT_WGI
     /* Parallel logic to WINDOWS_XINPUT below */
     RAWINPUT_UpdateWindowsGamingInput();
-    if (ctx->wgi_correlated) {
+    if (ctx->wgi_correlated &&
+        !joystick->low_frequency_rumble && !joystick->high_frequency_rumble &&
+        !joystick->left_trigger_rumble && !joystick->right_trigger_rumble) {
         /* We have been previously correlated, ensure we are still matching, see comments in XINPUT section */
-        if (RAWINPUT_WindowsGamingInputSlotMatches(&match_state_xinput, ctx->wgi_slot)) {
+        if (RAWINPUT_WindowsGamingInputSlotMatches(&match_state_xinput, ctx->wgi_slot, ctx->xinput_correlated)) {
             ctx->wgi_uncorrelate_count = 0;
         } else {
             ++ctx->wgi_uncorrelate_count;
             /* Only un-correlate if this is consistent over multiple Update() calls - the timing of polling/event
               pumping can easily cause this to uncorrelate for a frame.  2 seemed reliable in my testing, but
-              let's set it to 3 to be safe.  An incorrect un-correlation will simply result in lower precision
+              let's set it to 5 to be safe.  An incorrect un-correlation will simply result in lower precision
               triggers for a frame. */
-            if (ctx->wgi_uncorrelate_count >= 3) {
+            if (ctx->wgi_uncorrelate_count >= 5) {
 #ifdef DEBUG_RAWINPUT
                 SDL_Log("UN-Correlated joystick %d to WindowsGamingInput device #%d\n", joystick->instance_id, ctx->wgi_slot);
 #endif
@@ -1511,8 +1604,8 @@ RAWINPUT_UpdateOtherAPIs(SDL_Joystick *joystick)
         SDL_bool new_correlation_count = 0;
         if (RAWINPUT_MissingWindowsGamingInputSlot()) {
             Uint8 correlation_id;
-            WindowsGamingInputGamepadState *slot_idx;
-            if (RAWINPUT_GuessWindowsGamingInputSlot(&match_state_xinput, &correlation_id, &slot_idx)) {
+            WindowsGamingInputGamepadState *slot_idx = NULL;
+            if (RAWINPUT_GuessWindowsGamingInputSlot(&match_state_xinput, &correlation_id, &slot_idx, ctx->xinput_correlated)) {
                 /* we match exactly one WindowsGamingInput device */
                 /* Probably can do without wgi_correlation_count, just check and clear wgi_slot to NULL, unless we need
                    even more frames to be sure. */
@@ -1559,7 +1652,8 @@ RAWINPUT_UpdateOtherAPIs(SDL_Joystick *joystick)
     /* Parallel logic to WINDOWS_GAMING_INPUT above */
     if (ctx->xinput_enabled) {
         RAWINPUT_UpdateXInput();
-        if (ctx->xinput_correlated) {
+        if (ctx->xinput_correlated &&
+            !joystick->low_frequency_rumble && !joystick->high_frequency_rumble) {
             /* We have been previously correlated, ensure we are still matching */
             /* This is required to deal with two (mostly) un-preventable mis-correlation situations:
               A) Since the HID data stream does not provide an initial state (but polling XInput does), if we open
@@ -1582,9 +1676,9 @@ RAWINPUT_UpdateOtherAPIs(SDL_Joystick *joystick)
                 ++ctx->xinput_uncorrelate_count;
                 /* Only un-correlate if this is consistent over multiple Update() calls - the timing of polling/event
                   pumping can easily cause this to uncorrelate for a frame.  2 seemed reliable in my testing, but
-                  let's set it to 3 to be safe.  An incorrect un-correlation will simply result in lower precision
+                  let's set it to 5 to be safe.  An incorrect un-correlation will simply result in lower precision
                   triggers for a frame. */
-                if (ctx->xinput_uncorrelate_count >= 3) {
+                if (ctx->xinput_uncorrelate_count >= 5) {
 #ifdef DEBUG_RAWINPUT
                     SDL_Log("UN-Correlated joystick %d to XInput device #%d\n", joystick->instance_id, ctx->xinput_slot);
 #endif
@@ -1819,9 +1913,9 @@ RAWINPUT_WindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
 {
     LRESULT result = -1;
 
-    SDL_LockMutex(SDL_RAWINPUT_mutex);
-
     if (SDL_RAWINPUT_inited) {
+        SDL_LockMutex(SDL_RAWINPUT_mutex);
+
         switch (msg) {
             case WM_INPUT_DEVICE_CHANGE:
             {
@@ -1865,9 +1959,9 @@ RAWINPUT_WindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
             result = 0;
             break;
         }
-    }
 
-    SDL_UnlockMutex(SDL_RAWINPUT_mutex);
+        SDL_UnlockMutex(SDL_RAWINPUT_mutex);
+    }
 
     if (result >= 0) {
         return result;
@@ -1882,8 +1976,6 @@ RAWINPUT_JoystickQuit(void)
         return;
     }
 
-    SDL_LockMutex(SDL_RAWINPUT_mutex);
-
     while (SDL_RAWINPUT_devices) {
         RAWINPUT_DelDevice(SDL_RAWINPUT_devices, SDL_FALSE);
     }
@@ -1894,7 +1986,6 @@ RAWINPUT_JoystickQuit(void)
 
     SDL_RAWINPUT_inited = SDL_FALSE;
 
-    SDL_UnlockMutex(SDL_RAWINPUT_mutex);
     SDL_DestroyMutex(SDL_RAWINPUT_mutex);
     SDL_RAWINPUT_mutex = NULL;
 }
@@ -1918,8 +2009,9 @@ SDL_JoystickDriver SDL_RAWINPUT_JoystickDriver =
     RAWINPUT_JoystickOpen,
     RAWINPUT_JoystickRumble,
     RAWINPUT_JoystickRumbleTriggers,
-    RAWINPUT_JoystickHasLED,
+    RAWINPUT_JoystickGetCapabilities,
     RAWINPUT_JoystickSetLED,
+    RAWINPUT_JoystickSendEffect,
     RAWINPUT_JoystickSetSensorsEnabled,
     RAWINPUT_JoystickUpdate,
     RAWINPUT_JoystickClose,
diff --git a/Engine/lib/sdl/src/joystick/windows/SDL_rawinputjoystick_c.h b/Engine/lib/sdl/src/joystick/windows/SDL_rawinputjoystick_c.h
index 14f77fb35..a5d8143e0 100644
--- a/Engine/lib/sdl/src/joystick/windows/SDL_rawinputjoystick_c.h
+++ b/Engine/lib/sdl/src/joystick/windows/SDL_rawinputjoystick_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2019 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/joystick/windows/SDL_windows_gaming_input.c b/Engine/lib/sdl/src/joystick/windows/SDL_windows_gaming_input.c
index 29a9c7682..a731dad63 100644
--- a/Engine/lib/sdl/src/joystick/windows/SDL_windows_gaming_input.c
+++ b/Engine/lib/sdl/src/joystick/windows/SDL_windows_gaming_input.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -31,6 +31,8 @@
 #include "../../core/windows/SDL_windows.h"
 #define COBJMACROS
 #include "windows.gaming.input.h"
+#include <cfgmgr32.h>
+#include <roapi.h>
 
 
 struct joystick_hwdata
@@ -77,15 +79,15 @@ static const IID IID_IGameController = { 0x1BAF6522, 0x5F64, 0x42C5, { 0x82, 0x6
 static const IID IID_IGameControllerBatteryInfo = { 0xDCECC681, 0x3963, 0x4DA6, { 0x95, 0x5D, 0x55, 0x3F, 0x3B, 0x6F, 0x61, 0x61 } };
 static const IID IID_IArcadeStickStatics = { 0x5C37B8C8, 0x37B1, 0x4AD8, { 0x94, 0x58, 0x20, 0x0F, 0x1A, 0x30, 0x01, 0x8E } };
 static const IID IID_IArcadeStickStatics2 = { 0x52B5D744, 0xBB86, 0x445A, { 0xB5, 0x9C, 0x59, 0x6F, 0x0E, 0x2A, 0x49, 0xDF } };
-static const IID IID_IArcadeStick = { 0xB14A539D, 0xBEFB, 0x4C81, { 0x80, 0x51, 0x15, 0xEC, 0xF3, 0xB1, 0x30, 0x36 } };
+/*static const IID IID_IArcadeStick = { 0xB14A539D, 0xBEFB, 0x4C81, { 0x80, 0x51, 0x15, 0xEC, 0xF3, 0xB1, 0x30, 0x36 } };*/
 static const IID IID_IFlightStickStatics = { 0x5514924A, 0xFECC, 0x435E, { 0x83, 0xDC, 0x5C, 0xEC, 0x8A, 0x18, 0xA5, 0x20 } };
-static const IID IID_IFlightStick = { 0xB4A2C01C, 0xB83B, 0x4459, { 0xA1, 0xA9, 0x97, 0xB0, 0x3C, 0x33, 0xDA, 0x7C } };
+/*static const IID IID_IFlightStick = { 0xB4A2C01C, 0xB83B, 0x4459, { 0xA1, 0xA9, 0x97, 0xB0, 0x3C, 0x33, 0xDA, 0x7C } };*/
 static const IID IID_IGamepadStatics = { 0x8BBCE529, 0xD49C, 0x39E9, { 0x95, 0x60, 0xE4, 0x7D, 0xDE, 0x96, 0xB7, 0xC8 } };
 static const IID IID_IGamepadStatics2 = { 0x42676DC5, 0x0856, 0x47C4, { 0x92, 0x13, 0xB3, 0x95, 0x50, 0x4C, 0x3A, 0x3C } };
-static const IID IID_IGamepad = { 0xBC7BB43C, 0x0A69, 0x3903, { 0x9E, 0x9D, 0xA5, 0x0F, 0x86, 0xA4, 0x5D, 0xE5 } };
+/*static const IID IID_IGamepad = { 0xBC7BB43C, 0x0A69, 0x3903, { 0x9E, 0x9D, 0xA5, 0x0F, 0x86, 0xA4, 0x5D, 0xE5 } };*/
 static const IID IID_IRacingWheelStatics = { 0x3AC12CD5, 0x581B, 0x4936, { 0x9F, 0x94, 0x69, 0xF1, 0xE6, 0x51, 0x4C, 0x7D } };
 static const IID IID_IRacingWheelStatics2 = { 0xE666BCAA, 0xEDFD, 0x4323, { 0xA9, 0xF6, 0x3C, 0x38, 0x40, 0x48, 0xD1, 0xED } };
-static const IID IID_IRacingWheel = { 0xF546656F, 0xE106, 0x4C82, { 0xA9, 0x0F, 0x55, 0x40, 0x12, 0x90, 0x4B, 0x85 } };
+/*static const IID IID_IRacingWheel = { 0xF546656F, 0xE106, 0x4C82, { 0xA9, 0x0F, 0x55, 0x40, 0x12, 0x90, 0x4B, 0x85 } };*/
 
 extern SDL_bool SDL_XINPUT_Enabled(void);
 extern SDL_bool SDL_DINPUT_JoystickPresent(Uint16 vendor, Uint16 product, Uint16 version);
@@ -93,11 +95,17 @@ extern SDL_bool SDL_DINPUT_JoystickPresent(Uint16 vendor, Uint16 product, Uint16
 static SDL_bool
 SDL_IsXInputDevice(Uint16 vendor, Uint16 product)
 {
+#ifdef SDL_JOYSTICK_XINPUT
     PRAWINPUTDEVICELIST raw_devices = NULL;
     UINT i, raw_device_count = 0;
     LONG vidpid = MAKELONG(vendor, product);
 
-    if (!SDL_XINPUT_Enabled()) {
+    /* XInput and RawInput backends will pick up XInput-compatible devices */
+    if (!SDL_XINPUT_Enabled()
+#ifdef SDL_JOYSTICK_RAWINPUT
+        && !RAWINPUT_IsEnabled()
+#endif
+      ) {
         return SDL_FALSE;
     }
 
@@ -123,17 +131,70 @@ SDL_IsXInputDevice(Uint16 vendor, Uint16 product)
         char devName[MAX_PATH];
         UINT rdiSize = sizeof(rdi);
         UINT nameSize = SDL_arraysize(devName);
+        DEVINST devNode;
+        char devVidPidString[32];
+        int j;
 
         rdi.cbSize = sizeof(rdi);
-        if ((raw_devices[i].dwType == RIM_TYPEHID) &&
-            (GetRawInputDeviceInfoA(raw_devices[i].hDevice, RIDI_DEVICEINFO, &rdi, &rdiSize) != ((UINT)-1)) &&
-            (MAKELONG(rdi.hid.dwVendorId, rdi.hid.dwProductId) == vidpid) &&
-            (GetRawInputDeviceInfoA(raw_devices[i].hDevice, RIDI_DEVICENAME, devName, &nameSize) != ((UINT)-1)) &&
-            (SDL_strstr(devName, "IG_") != NULL)) {
+
+        if ((raw_devices[i].dwType != RIM_TYPEHID) ||
+            (GetRawInputDeviceInfoA(raw_devices[i].hDevice, RIDI_DEVICEINFO, &rdi, &rdiSize) == ((UINT)-1)) ||
+            (GetRawInputDeviceInfoA(raw_devices[i].hDevice, RIDI_DEVICENAME, devName, &nameSize) == ((UINT)-1)) ||
+            (SDL_strstr(devName, "IG_") == NULL)) {
+            /* Skip non-XInput devices */
+            continue;
+        }
+
+        /* First check for a simple VID/PID match. This will work for Xbox 360 controllers. */
+        if (MAKELONG(rdi.hid.dwVendorId, rdi.hid.dwProductId) == vidpid) {
+            SDL_free(raw_devices);
             return SDL_TRUE;
         }
+
+        /* For Xbox One controllers, Microsoft doesn't propagate the VID/PID down to the HID stack.
+         * We'll have to walk the device tree upwards searching for a match for our VID/PID. */
+
+        /* Make sure the device interface string is something we know how to parse */
+        /* Example: \\?\HID#VID_045E&PID_02FF&IG_00#9&2c203035&2&0000#{4d1e55b2-f16f-11cf-88cb-001111000030} */
+        if ((SDL_strstr(devName, "\\\\?\\") != devName) || (SDL_strstr(devName, "#{") == NULL)) {
+            continue;
+        }
+
+        /* Unescape the backslashes in the string and terminate before the GUID portion */
+        for (j = 0; devName[j] != '\0'; j++) {
+            if (devName[j] == '#') {
+                if (devName[j + 1] == '{') {
+                    devName[j] = '\0';
+                    break;
+                } else {
+                    devName[j] = '\\';
+                }
+            }
+        }
+
+        /* We'll be left with a string like this: \\?\HID\VID_045E&PID_02FF&IG_00\9&2c203035&2&0000
+         * Simply skip the \\?\ prefix and we'll have a properly formed device instance ID */
+        if (CM_Locate_DevNodeA(&devNode, &devName[4], CM_LOCATE_DEVNODE_NORMAL) != CR_SUCCESS) {
+            continue;
+        }
+
+        SDL_snprintf(devVidPidString, sizeof(devVidPidString), "VID_%04X&PID_%04X", vendor, product);
+
+        while (CM_Get_Parent(&devNode, devNode, 0) == CR_SUCCESS) {
+            char deviceId[MAX_DEVICE_ID_LEN];
+
+            if ((CM_Get_Device_IDA(devNode, deviceId, SDL_arraysize(deviceId), 0) == CR_SUCCESS) &&
+                (SDL_strstr(deviceId, devVidPidString) != NULL)) {
+                /* The VID/PID matched a parent device */
+                SDL_free(raw_devices);
+                return SDL_TRUE;
+            }
+        }
     }
 
+    SDL_free(raw_devices);
+#endif /* SDL_JOYSTICK_XINPUT */
+
     return SDL_FALSE;
 }
 
@@ -166,7 +227,13 @@ static HRESULT STDMETHODCALLTYPE IEventHandler_CRawGameControllerVtbl_InvokeAdde
     HRESULT hr;
     __x_ABI_CWindows_CGaming_CInput_CIRawGameController *controller = NULL;
 
-    hr = IUnknown_QueryInterface((IUnknown *)e, &IID_IRawGameController, (void **)&controller);
+    /* We can get delayed calls to InvokeAdded() after WGI_JoystickQuit(). Do nothing if WGI is deinitialized.
+     * FIXME: Can we tell if WGI has been quit and reinitialized prior to a delayed callback? */
+    if (wgi.statics == NULL) {
+        return S_OK;
+    }
+
+    hr = __x_ABI_CWindows_CGaming_CInput_CIRawGameController_QueryInterface(e, &IID_IRawGameController, (void **)&controller);
     if (SUCCEEDED(hr)) {
         char *name = NULL;
         SDL_JoystickGUID guid;
@@ -184,28 +251,42 @@ static HRESULT STDMETHODCALLTYPE IEventHandler_CRawGameControllerVtbl_InvokeAdde
 
         hr = __x_ABI_CWindows_CGaming_CInput_CIRawGameController_QueryInterface(controller, &IID_IRawGameController2, (void **)&controller2);
         if (SUCCEEDED(hr)) {
+            typedef PCWSTR (WINAPI *WindowsGetStringRawBuffer_t)(HSTRING string, UINT32 *length);
+            typedef HRESULT (WINAPI *WindowsDeleteString_t)(HSTRING string);
+
+            WindowsGetStringRawBuffer_t WindowsGetStringRawBufferFunc = NULL;
+            WindowsDeleteString_t WindowsDeleteStringFunc = NULL;
+#ifdef __WINRT__
+            WindowsGetStringRawBufferFunc = WindowsGetStringRawBuffer;
+            WindowsDeleteStringFunc = WindowsDeleteString;
+#else
             HMODULE hModule = LoadLibraryA("combase.dll");
             if (hModule != NULL) {
-                typedef PCWSTR (WINAPI *WindowsGetStringRawBuffer_t)(HSTRING string, UINT32 *length);
-                typedef HRESULT (WINAPI *WindowsDeleteString_t)(HSTRING string);
-
-                WindowsGetStringRawBuffer_t WindowsGetStringRawBufferFunc = (WindowsGetStringRawBuffer_t)GetProcAddress(hModule, "WindowsGetStringRawBuffer");
-                WindowsDeleteString_t WindowsDeleteStringFunc = (WindowsDeleteString_t)GetProcAddress(hModule, "WindowsDeleteString");
-                if (WindowsGetStringRawBufferFunc && WindowsDeleteStringFunc) {
-                    HSTRING hString;
-                    hr = __x_ABI_CWindows_CGaming_CInput_CIRawGameController2_get_DisplayName(controller2, &hString);
-                    if (SUCCEEDED(hr)) {
-                        PCWSTR string = WindowsGetStringRawBufferFunc(hString, NULL);
-                        if (string) {
-                            name = WIN_StringToUTF8(string);
-                        }
-                        WindowsDeleteStringFunc(hString);
+                WindowsGetStringRawBufferFunc = (WindowsGetStringRawBuffer_t)GetProcAddress(hModule, "WindowsGetStringRawBuffer");
+                WindowsDeleteStringFunc = (WindowsDeleteString_t)GetProcAddress(hModule, "WindowsDeleteString");
+            }
+#endif /* __WINRT__ */
+            if (WindowsGetStringRawBufferFunc && WindowsDeleteStringFunc) {
+                HSTRING hString;
+                hr = __x_ABI_CWindows_CGaming_CInput_CIRawGameController2_get_DisplayName(controller2, &hString);
+                if (SUCCEEDED(hr)) {
+                    PCWSTR string = WindowsGetStringRawBufferFunc(hString, NULL);
+                    if (string) {
+                        name = WIN_StringToUTF8W(string);
                     }
+                    WindowsDeleteStringFunc(hString);
                 }
+            }
+#ifndef __WINRT__
+            if (hModule != NULL) {
                 FreeLibrary(hModule);
             }
+#endif
             __x_ABI_CWindows_CGaming_CInput_CIRawGameController2_Release(controller2);
         }
+        if (!name) {
+            name = SDL_strdup("");
+        }
 
         hr = __x_ABI_CWindows_CGaming_CInput_CIRawGameController_QueryInterface(controller, &IID_IGameController, (void **)&gamecontroller);
         if (SUCCEEDED(hr)) {
@@ -307,7 +388,7 @@ static HRESULT STDMETHODCALLTYPE IEventHandler_CRawGameControllerVtbl_InvokeRemo
     HRESULT hr;
     __x_ABI_CWindows_CGaming_CInput_CIRawGameController *controller = NULL;
 
-    hr = IUnknown_QueryInterface((IUnknown *)e, &IID_IRawGameController, (void **)&controller);
+    hr = __x_ABI_CWindows_CGaming_CInput_CIRawGameController_QueryInterface(e, &IID_IRawGameController, (void **)&controller);
     if (SUCCEEDED(hr)) {
         int i;
 
@@ -358,87 +439,120 @@ static __FIEventHandler_1_Windows__CGaming__CInput__CRawGameController controlle
 static int
 WGI_JoystickInit(void)
 {
+    typedef HRESULT (WINAPI *WindowsCreateStringReference_t)(PCWSTR sourceString, UINT32 length, HSTRING_HEADER *hstringHeader, HSTRING* string);
+    typedef HRESULT (WINAPI *RoGetActivationFactory_t)(HSTRING activatableClassId, REFIID iid, void** factory);
+
+    WindowsCreateStringReference_t WindowsCreateStringReferenceFunc = NULL;
+    RoGetActivationFactory_t RoGetActivationFactoryFunc = NULL;
+#ifndef __WINRT__
+    HMODULE hModule;
+#endif
+    HRESULT hr;
+
     if (FAILED(WIN_CoInitialize())) {
         return SDL_SetError("CoInitialize() failed");
     }
 
-    HRESULT hr;
-    HMODULE hModule = LoadLibraryA("combase.dll");
+#ifdef __WINRT__
+    WindowsCreateStringReferenceFunc = WindowsCreateStringReference;
+    RoGetActivationFactoryFunc = RoGetActivationFactory;
+#else
+    hModule = LoadLibraryA("combase.dll");
     if (hModule != NULL) {
-        typedef HRESULT (WINAPI *WindowsCreateStringReference_t)(PCWSTR sourceString, UINT32 length, HSTRING_HEADER *hstringHeader, HSTRING* string);
-        typedef HRESULT (WINAPI *WindowsDeleteString_t)(HSTRING string);
-        typedef HRESULT (WINAPI *RoGetActivationFactory_t)(HSTRING activatableClassId, REFIID iid, void** factory);
+        WindowsCreateStringReferenceFunc = (WindowsCreateStringReference_t)GetProcAddress(hModule, "WindowsCreateStringReference");
+        RoGetActivationFactoryFunc = (RoGetActivationFactory_t)GetProcAddress(hModule, "RoGetActivationFactory");
+    }
+#endif /* __WINRT__ */
+    if (WindowsCreateStringReferenceFunc && RoGetActivationFactoryFunc) {
+        PCWSTR pNamespace;
+        HSTRING_HEADER hNamespaceStringHeader;
+        HSTRING hNamespaceString;
 
-        WindowsCreateStringReference_t WindowsCreateStringReferenceFunc = (WindowsCreateStringReference_t)GetProcAddress(hModule, "WindowsCreateStringReference");
-        RoGetActivationFactory_t RoGetActivationFactoryFunc = (RoGetActivationFactory_t)GetProcAddress(hModule, "RoGetActivationFactory");
-        if (WindowsCreateStringReferenceFunc && RoGetActivationFactoryFunc) {
-            LPTSTR pNamespace;
-            HSTRING_HEADER hNamespaceStringHeader;
-            HSTRING hNamespaceString;
-
-            pNamespace = L"Windows.Gaming.Input.RawGameController";
-            hr = WindowsCreateStringReferenceFunc(pNamespace, (UINT32)SDL_wcslen(pNamespace), &hNamespaceStringHeader, &hNamespaceString);
-            if (SUCCEEDED(hr)) {
-                hr = RoGetActivationFactoryFunc(hNamespaceString, &IID_IRawGameControllerStatics, &wgi.statics);
-                if (!SUCCEEDED(hr)) {
-                    SDL_SetError("Couldn't find IRawGameControllerStatics: 0x%x", hr);
-                }
-            }
-
-            pNamespace = L"Windows.Gaming.Input.ArcadeStick";
-            hr = WindowsCreateStringReferenceFunc(pNamespace, (UINT32)SDL_wcslen(pNamespace), &hNamespaceStringHeader, &hNamespaceString);
-            if (SUCCEEDED(hr)) {
-                hr = RoGetActivationFactoryFunc(hNamespaceString, &IID_IArcadeStickStatics, &wgi.arcade_stick_statics);
-                if (SUCCEEDED(hr)) {
-                    __x_ABI_CWindows_CGaming_CInput_CIArcadeStickStatics_QueryInterface(wgi.arcade_stick_statics, &IID_IArcadeStickStatics2, &wgi.arcade_stick_statics2);
-                } else {
-                    SDL_SetError("Couldn't find IID_IArcadeStickStatics: 0x%x", hr);
-                }
-            }
-
-            pNamespace = L"Windows.Gaming.Input.FlightStick";
-            hr = WindowsCreateStringReferenceFunc(pNamespace, (UINT32)SDL_wcslen(pNamespace), &hNamespaceStringHeader, &hNamespaceString);
-            if (SUCCEEDED(hr)) {
-                hr = RoGetActivationFactoryFunc(hNamespaceString, &IID_IFlightStickStatics, &wgi.flight_stick_statics);
-                if (!SUCCEEDED(hr)) {
-                    SDL_SetError("Couldn't find IID_IFlightStickStatics: 0x%x", hr);
-                }
-            }
-
-            pNamespace = L"Windows.Gaming.Input.Gamepad";
-            hr = WindowsCreateStringReferenceFunc(pNamespace, (UINT32)SDL_wcslen(pNamespace), &hNamespaceStringHeader, &hNamespaceString);
-            if (SUCCEEDED(hr)) {
-                hr = RoGetActivationFactoryFunc(hNamespaceString, &IID_IGamepadStatics, &wgi.gamepad_statics);
-                if (SUCCEEDED(hr)) {
-                    __x_ABI_CWindows_CGaming_CInput_CIGamepadStatics_QueryInterface(wgi.gamepad_statics, &IID_IGamepadStatics2, &wgi.gamepad_statics2);
-                } else {
-                    SDL_SetError("Couldn't find IGamepadStatics: 0x%x", hr);
-                }
-            }
-
-            pNamespace = L"Windows.Gaming.Input.RacingWheel";
-            hr = WindowsCreateStringReferenceFunc(pNamespace, (UINT32)SDL_wcslen(pNamespace), &hNamespaceStringHeader, &hNamespaceString);
-            if (SUCCEEDED(hr)) {
-                hr = RoGetActivationFactoryFunc(hNamespaceString, &IID_IRacingWheelStatics, &wgi.racing_wheel_statics);
-                if (SUCCEEDED(hr)) {
-                    __x_ABI_CWindows_CGaming_CInput_CIRacingWheelStatics_QueryInterface(wgi.racing_wheel_statics, &IID_IRacingWheelStatics2, &wgi.racing_wheel_statics2);
-                } else {
-                    SDL_SetError("Couldn't find IRacingWheelStatics: 0x%x", hr);
-                }
+        pNamespace = L"Windows.Gaming.Input.RawGameController";
+        hr = WindowsCreateStringReferenceFunc(pNamespace, (UINT32)SDL_wcslen(pNamespace), &hNamespaceStringHeader, &hNamespaceString);
+        if (SUCCEEDED(hr)) {
+            hr = RoGetActivationFactoryFunc(hNamespaceString, &IID_IRawGameControllerStatics, (void **)&wgi.statics);
+            if (!SUCCEEDED(hr)) {
+                SDL_SetError("Couldn't find IRawGameControllerStatics: 0x%lx", hr);
             }
         }
+
+        pNamespace = L"Windows.Gaming.Input.ArcadeStick";
+        hr = WindowsCreateStringReferenceFunc(pNamespace, (UINT32)SDL_wcslen(pNamespace), &hNamespaceStringHeader, &hNamespaceString);
+        if (SUCCEEDED(hr)) {
+            hr = RoGetActivationFactoryFunc(hNamespaceString, &IID_IArcadeStickStatics, (void **)&wgi.arcade_stick_statics);
+            if (SUCCEEDED(hr)) {
+                __x_ABI_CWindows_CGaming_CInput_CIArcadeStickStatics_QueryInterface(wgi.arcade_stick_statics, &IID_IArcadeStickStatics2, (void **)&wgi.arcade_stick_statics2);
+            } else {
+                SDL_SetError("Couldn't find IID_IArcadeStickStatics: 0x%lx", hr);
+            }
+        }
+
+        pNamespace = L"Windows.Gaming.Input.FlightStick";
+        hr = WindowsCreateStringReferenceFunc(pNamespace, (UINT32)SDL_wcslen(pNamespace), &hNamespaceStringHeader, &hNamespaceString);
+        if (SUCCEEDED(hr)) {
+            hr = RoGetActivationFactoryFunc(hNamespaceString, &IID_IFlightStickStatics, (void **)&wgi.flight_stick_statics);
+            if (!SUCCEEDED(hr)) {
+                SDL_SetError("Couldn't find IID_IFlightStickStatics: 0x%lx", hr);
+            }
+        }
+
+        pNamespace = L"Windows.Gaming.Input.Gamepad";
+        hr = WindowsCreateStringReferenceFunc(pNamespace, (UINT32)SDL_wcslen(pNamespace), &hNamespaceStringHeader, &hNamespaceString);
+        if (SUCCEEDED(hr)) {
+            hr = RoGetActivationFactoryFunc(hNamespaceString, &IID_IGamepadStatics, (void **)&wgi.gamepad_statics);
+            if (SUCCEEDED(hr)) {
+                __x_ABI_CWindows_CGaming_CInput_CIGamepadStatics_QueryInterface(wgi.gamepad_statics, &IID_IGamepadStatics2, (void **)&wgi.gamepad_statics2);
+            } else {
+                SDL_SetError("Couldn't find IGamepadStatics: 0x%lx", hr);
+            }
+        }
+
+        pNamespace = L"Windows.Gaming.Input.RacingWheel";
+        hr = WindowsCreateStringReferenceFunc(pNamespace, (UINT32)SDL_wcslen(pNamespace), &hNamespaceStringHeader, &hNamespaceString);
+        if (SUCCEEDED(hr)) {
+            hr = RoGetActivationFactoryFunc(hNamespaceString, &IID_IRacingWheelStatics, (void **)&wgi.racing_wheel_statics);
+            if (SUCCEEDED(hr)) {
+                __x_ABI_CWindows_CGaming_CInput_CIRacingWheelStatics_QueryInterface(wgi.racing_wheel_statics, &IID_IRacingWheelStatics2, (void **)&wgi.racing_wheel_statics2);
+            } else {
+                SDL_SetError("Couldn't find IRacingWheelStatics: 0x%lx", hr);
+            }
+        }
+    }
+#ifndef __WINRT__
+    if (hModule != NULL) {
         FreeLibrary(hModule);
     }
+#endif
 
     if (wgi.statics) {
+        __FIVectorView_1_Windows__CGaming__CInput__CRawGameController *controllers;
+
         hr = __x_ABI_CWindows_CGaming_CInput_CIRawGameControllerStatics_add_RawGameControllerAdded(wgi.statics, &controller_added, &wgi.controller_added_token);
         if (!SUCCEEDED(hr)) {
-            SDL_SetError("add_RawGameControllerAdded() failed: 0x%x\n", hr);
+            SDL_SetError("add_RawGameControllerAdded() failed: 0x%lx\n", hr);
         }
 
         hr = __x_ABI_CWindows_CGaming_CInput_CIRawGameControllerStatics_add_RawGameControllerRemoved(wgi.statics, &controller_removed, &wgi.controller_removed_token);
         if (!SUCCEEDED(hr)) {
-            SDL_SetError("add_RawGameControllerRemoved() failed: 0x%x\n", hr);
+            SDL_SetError("add_RawGameControllerRemoved() failed: 0x%lx\n", hr);
+        }
+
+        hr = __x_ABI_CWindows_CGaming_CInput_CIRawGameControllerStatics_get_RawGameControllers(wgi.statics, &controllers);
+        if (SUCCEEDED(hr)) {
+            unsigned i, count = 0;
+
+            hr = __FIVectorView_1_Windows__CGaming__CInput__CRawGameController_get_Size(controllers, &count);
+            if (SUCCEEDED(hr)) {
+                for (i = 0; i < count; ++i) {
+                    __x_ABI_CWindows_CGaming_CInput_CIRawGameController *controller = NULL;
+
+                    hr = __FIVectorView_1_Windows__CGaming__CInput__CRawGameController_GetAt(controllers, i, &controller);
+                    if (SUCCEEDED(hr) && controller) {
+                        IEventHandler_CRawGameControllerVtbl_InvokeAdded(&controller_added, NULL, controller);
+                    }
+                }
+            }
         }
     }
 
@@ -486,7 +600,7 @@ WGI_JoystickGetDeviceInstanceID(int device_index)
 }
 
 static int
-WGI_JoystickOpen(SDL_Joystick * joystick, int device_index)
+WGI_JoystickOpen(SDL_Joystick *joystick, int device_index)
 {
     WindowsGamingInputControllerState *state = &wgi.controllers[device_index];
     struct joystick_hwdata *hwdata;
@@ -558,7 +672,7 @@ WGI_JoystickOpen(SDL_Joystick * joystick, int device_index)
 }
 
 static int
-WGI_JoystickRumble(SDL_Joystick * joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+WGI_JoystickRumble(SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
 {
     struct joystick_hwdata *hwdata = joystick->hwdata;
 
@@ -571,7 +685,7 @@ WGI_JoystickRumble(SDL_Joystick * joystick, Uint16 low_frequency_rumble, Uint16
         if (SUCCEEDED(hr)) {
             return 0;
         } else {
-            return SDL_SetError("Setting vibration failed: 0x%x\n", hr);
+            return SDL_SetError("Setting vibration failed: 0x%lx\n", hr);
         }
     } else {
         return SDL_Unsupported();
@@ -579,7 +693,7 @@ WGI_JoystickRumble(SDL_Joystick * joystick, Uint16 low_frequency_rumble, Uint16
 }
 
 static int
-WGI_JoystickRumbleTriggers(SDL_Joystick * joystick, Uint16 left_rumble, Uint16 right_rumble)
+WGI_JoystickRumbleTriggers(SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
 {
     struct joystick_hwdata *hwdata = joystick->hwdata;
 
@@ -592,21 +706,34 @@ WGI_JoystickRumbleTriggers(SDL_Joystick * joystick, Uint16 left_rumble, Uint16 r
         if (SUCCEEDED(hr)) {
             return 0;
         } else {
-            return SDL_SetError("Setting vibration failed: 0x%x\n", hr);
+            return SDL_SetError("Setting vibration failed: 0x%lx\n", hr);
         }
     } else {
         return SDL_Unsupported();
     }
 }
 
-static SDL_bool
-WGI_JoystickHasLED(SDL_Joystick * joystick)
+static Uint32
+WGI_JoystickGetCapabilities(SDL_Joystick *joystick)
 {
-    return SDL_FALSE;
+    struct joystick_hwdata *hwdata = joystick->hwdata;
+
+    if (hwdata->gamepad) {
+        /* FIXME: Can WGI even tell us if trigger rumble is supported? */
+        return SDL_JOYCAP_RUMBLE | SDL_JOYCAP_RUMBLE_TRIGGERS;
+    } else {
+        return 0;
+    }
 }
 
 static int
-WGI_JoystickSetLED(SDL_Joystick * joystick, Uint8 red, Uint8 green, Uint8 blue)
+WGI_JoystickSetLED(SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+    return SDL_Unsupported();
+}
+
+static int
+WGI_JoystickSendEffect(SDL_Joystick *joystick, const void *data, int size)
 {
     return SDL_Unsupported();
 }
@@ -643,7 +770,7 @@ ConvertHatValue(__x_ABI_CWindows_CGaming_CInput_CGameControllerSwitchPosition va
 }
 
 static void
-WGI_JoystickUpdate(SDL_Joystick * joystick)
+WGI_JoystickUpdate(SDL_Joystick *joystick)
 {
     struct joystick_hwdata *hwdata = joystick->hwdata;
     HRESULT hr;
@@ -677,7 +804,7 @@ WGI_JoystickUpdate(SDL_Joystick * joystick)
 }
 
 static void
-WGI_JoystickClose(SDL_Joystick * joystick)
+WGI_JoystickClose(SDL_Joystick *joystick)
 {
     struct joystick_hwdata *hwdata = joystick->hwdata;
 
@@ -704,7 +831,7 @@ WGI_JoystickQuit(void)
 {
     if (wgi.statics) {
         while (wgi.controller_count > 0) {
-            IEventHandler_CRawGameControllerVtbl_InvokeRemoved(&controller_removed, NULL, (__x_ABI_CWindows_CGaming_CInput_CIRawGameController *)wgi.controllers[wgi.controller_count - 1].controller);
+            IEventHandler_CRawGameControllerVtbl_InvokeRemoved(&controller_removed, NULL, wgi.controllers[wgi.controller_count - 1].controller);
         }
         if (wgi.controllers) {
             SDL_free(wgi.controllers);
@@ -760,8 +887,9 @@ SDL_JoystickDriver SDL_WGI_JoystickDriver =
     WGI_JoystickOpen,
     WGI_JoystickRumble,
     WGI_JoystickRumbleTriggers,
-    WGI_JoystickHasLED,
+    WGI_JoystickGetCapabilities,
     WGI_JoystickSetLED,
+    WGI_JoystickSendEffect,
     WGI_JoystickSetSensorsEnabled,
     WGI_JoystickUpdate,
     WGI_JoystickClose,
diff --git a/Engine/lib/sdl/src/joystick/windows/SDL_windowsjoystick.c b/Engine/lib/sdl/src/joystick/windows/SDL_windowsjoystick.c
index 5722f50da..7dae16d9f 100644
--- a/Engine/lib/sdl/src/joystick/windows/SDL_windowsjoystick.c
+++ b/Engine/lib/sdl/src/joystick/windows/SDL_windowsjoystick.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -59,6 +59,77 @@
 #define DEVICE_NOTIFY_WINDOW_HANDLE 0x00000000
 #endif
 
+/* CM_Register_Notification definitions */
+
+#define CR_SUCCESS (0x00000000)
+
+DECLARE_HANDLE(HCMNOTIFICATION);
+typedef HCMNOTIFICATION* PHCMNOTIFICATION;
+
+typedef enum _CM_NOTIFY_FILTER_TYPE {
+    CM_NOTIFY_FILTER_TYPE_DEVICEINTERFACE = 0,
+    CM_NOTIFY_FILTER_TYPE_DEVICEHANDLE,
+    CM_NOTIFY_FILTER_TYPE_DEVICEINSTANCE,
+    CM_NOTIFY_FILTER_TYPE_MAX
+} CM_NOTIFY_FILTER_TYPE, * PCM_NOTIFY_FILTER_TYPE;
+
+typedef struct _CM_NOTIFY_FILTER {
+    DWORD cbSize;
+    DWORD Flags;
+    CM_NOTIFY_FILTER_TYPE FilterType;
+    DWORD Reserved;
+    union {
+        struct {
+            GUID ClassGuid;
+        } DeviceInterface;
+        struct {
+            HANDLE  hTarget;
+        } DeviceHandle;
+        struct {
+            WCHAR InstanceId[200];
+        } DeviceInstance;
+    } u;
+} CM_NOTIFY_FILTER, * PCM_NOTIFY_FILTER;
+
+typedef enum _CM_NOTIFY_ACTION {
+    CM_NOTIFY_ACTION_DEVICEINTERFACEARRIVAL = 0,
+    CM_NOTIFY_ACTION_DEVICEINTERFACEREMOVAL,
+    CM_NOTIFY_ACTION_DEVICEQUERYREMOVE,
+    CM_NOTIFY_ACTION_DEVICEQUERYREMOVEFAILED,
+    CM_NOTIFY_ACTION_DEVICEREMOVEPENDING,
+    CM_NOTIFY_ACTION_DEVICEREMOVECOMPLETE,
+    CM_NOTIFY_ACTION_DEVICECUSTOMEVENT,
+    CM_NOTIFY_ACTION_DEVICEINSTANCEENUMERATED,
+    CM_NOTIFY_ACTION_DEVICEINSTANCESTARTED,
+    CM_NOTIFY_ACTION_DEVICEINSTANCEREMOVED,
+    CM_NOTIFY_ACTION_MAX
+} CM_NOTIFY_ACTION, * PCM_NOTIFY_ACTION;
+
+typedef struct _CM_NOTIFY_EVENT_DATA {
+    CM_NOTIFY_FILTER_TYPE FilterType;
+    DWORD Reserved;
+    union {
+        struct {
+            GUID ClassGuid;
+            WCHAR SymbolicLink[ANYSIZE_ARRAY];
+        } DeviceInterface;
+        struct {
+            GUID EventGuid;
+            LONG NameOffset;
+            DWORD DataSize;
+            BYTE Data[ANYSIZE_ARRAY];
+        } DeviceHandle;
+        struct {
+            WCHAR InstanceId[ANYSIZE_ARRAY];
+        } DeviceInstance;
+    } u;
+} CM_NOTIFY_EVENT_DATA, * PCM_NOTIFY_EVENT_DATA;
+
+typedef DWORD (CALLBACK *PCM_NOTIFY_CALLBACK)(HCMNOTIFICATION hNotify, PVOID Context, CM_NOTIFY_ACTION Action, PCM_NOTIFY_EVENT_DATA EventData, DWORD EventDataSize);
+
+typedef DWORD (WINAPI *CM_Register_NotificationFunc)(PCM_NOTIFY_FILTER pFilter, PVOID pContext, PCM_NOTIFY_CALLBACK pCallback, PHCMNOTIFICATION pNotifyContext);
+typedef DWORD (WINAPI *CM_Unregister_NotificationFunc)(HCMNOTIFICATION NotifyContext);
+
 /* local variables */
 static SDL_bool s_bJoystickThread = SDL_FALSE;
 static SDL_bool s_bWindowsDeviceChanged = SDL_FALSE;
@@ -66,35 +137,64 @@ static SDL_cond *s_condJoystickThread = NULL;
 static SDL_mutex *s_mutexJoyStickEnum = NULL;
 static SDL_Thread *s_joystickThread = NULL;
 static SDL_bool s_bJoystickThreadQuit = SDL_FALSE;
+static GUID GUID_DEVINTERFACE_HID = { 0x4D1E55B2L, 0xF16F, 0x11CF, { 0x88, 0xCB, 0x00, 0x11, 0x11, 0x00, 0x00, 0x30 } };
 
 JoyStick_DeviceData *SYS_Joystick;    /* array to hold joystick ID values */
 
-#ifdef __WINRT__
+#ifndef __WINRT__
+static HMODULE cfgmgr32_lib_handle;
+static CM_Register_NotificationFunc CM_Register_Notification;
+static CM_Unregister_NotificationFunc CM_Unregister_Notification;
+static HCMNOTIFICATION s_DeviceNotificationFuncHandle;
 
-typedef struct
-{
-    int unused;
-} SDL_DeviceNotificationData;
-
-static void
-SDL_CleanupDeviceNotification(SDL_DeviceNotificationData *data)
+static DWORD CALLBACK
+SDL_DeviceNotificationFunc(HCMNOTIFICATION hNotify, PVOID context, CM_NOTIFY_ACTION action, PCM_NOTIFY_EVENT_DATA eventData, DWORD event_data_size)
 {
+    if (action == CM_NOTIFY_ACTION_DEVICEINTERFACEARRIVAL ||
+        action == CM_NOTIFY_ACTION_DEVICEINTERFACEREMOVAL) {
+        s_bWindowsDeviceChanged = SDL_TRUE;
+    }
+    return ERROR_SUCCESS;
 }
 
-static int
-SDL_CreateDeviceNotification(SDL_DeviceNotificationData *data)
+static void
+SDL_CleanupDeviceNotificationFunc(void)
 {
-    return 0;
+    if (cfgmgr32_lib_handle) {
+        if (s_DeviceNotificationFuncHandle) {
+            CM_Unregister_Notification(s_DeviceNotificationFuncHandle);
+            s_DeviceNotificationFuncHandle = NULL;
+        }
+
+        FreeLibrary(cfgmgr32_lib_handle);
+        cfgmgr32_lib_handle = NULL;
+    }
 }
 
 static SDL_bool
-SDL_WaitForDeviceNotification(SDL_DeviceNotificationData *data, SDL_mutex *mutex)
+SDL_CreateDeviceNotificationFunc(void)
 {
+    cfgmgr32_lib_handle = LoadLibraryA("cfgmgr32.dll");
+    if (cfgmgr32_lib_handle) {
+        CM_Register_Notification = (CM_Register_NotificationFunc)GetProcAddress(cfgmgr32_lib_handle, "CM_Register_Notification");
+        CM_Unregister_Notification = (CM_Unregister_NotificationFunc)GetProcAddress(cfgmgr32_lib_handle, "CM_Unregister_Notification");
+        if (CM_Register_Notification && CM_Unregister_Notification) {
+            CM_NOTIFY_FILTER notify_filter;
+
+            SDL_zero(notify_filter);
+            notify_filter.cbSize = sizeof(notify_filter);
+            notify_filter.FilterType = CM_NOTIFY_FILTER_TYPE_DEVICEINTERFACE;
+            notify_filter.u.DeviceInterface.ClassGuid = GUID_DEVINTERFACE_HID;
+            if (CM_Register_Notification(&notify_filter, NULL, SDL_DeviceNotificationFunc, &s_DeviceNotificationFuncHandle) == CR_SUCCESS) {
+                return SDL_TRUE;
+            }
+        }
+    }
+
+    SDL_CleanupDeviceNotificationFunc();
     return SDL_FALSE;
 }
 
-#else /* !__WINRT__ */
-
 typedef struct
 {
     HRESULT coinitialized;
@@ -164,14 +264,13 @@ static int
 SDL_CreateDeviceNotification(SDL_DeviceNotificationData *data)
 {
     DEV_BROADCAST_DEVICEINTERFACE dbh;
-    GUID GUID_DEVINTERFACE_HID = { 0x4D1E55B2L, 0xF16F, 0x11CF, { 0x88, 0xCB, 0x00, 0x11, 0x11, 0x00, 0x00, 0x30 } };
 
     SDL_zerop(data);
 
     data->coinitialized = WIN_CoInitialize();
 
     data->wincl.hInstance = GetModuleHandle(NULL);
-    data->wincl.lpszClassName = L"Message";
+    data->wincl.lpszClassName = TEXT("Message");
     data->wincl.lpfnWndProc = SDL_PrivateJoystickDetectProc;      /* This function is called by windows */
     data->wincl.cbSize = sizeof (WNDCLASSEX);
 
@@ -181,7 +280,7 @@ SDL_CreateDeviceNotification(SDL_DeviceNotificationData *data)
         return -1;
     }
 
-    data->messageWindow = (HWND)CreateWindowEx(0,  L"Message", NULL, 0, 0, 0, 0, 0, HWND_MESSAGE, NULL, NULL, NULL);
+    data->messageWindow = (HWND)CreateWindowEx(0,  TEXT("Message"), NULL, 0, 0, 0, 0, 0, HWND_MESSAGE, NULL, NULL, NULL);
     if (!data->messageWindow) {
         WIN_SetError("Failed to create message window for joystick autodetect");
         SDL_CleanupDeviceNotification(data);
@@ -228,8 +327,6 @@ SDL_WaitForDeviceNotification(SDL_DeviceNotificationData *data, SDL_mutex *mutex
     return (lastret != -1) ? SDL_TRUE : SDL_FALSE;
 }
 
-#endif /* __WINRT__ */
-
 static SDL_DeviceNotificationData s_notification_data;
 
 /* Function/thread to scan the system for joysticks. */
@@ -310,9 +407,7 @@ SDL_StopJoystickThread(void)
     s_bJoystickThreadQuit = SDL_TRUE;
     SDL_CondBroadcast(s_condJoystickThread); /* signal the joystick thread to quit */
     SDL_UnlockMutex(s_mutexJoyStickEnum);
-#ifndef __WINRT__
     PostThreadMessage(SDL_GetThreadID(s_joystickThread), WM_QUIT, 0, 0);
-#endif
     SDL_WaitThread(s_joystickThread, NULL); /* wait for it to bugger off */
 
     SDL_DestroyCond(s_condJoystickThread);
@@ -324,6 +419,8 @@ SDL_StopJoystickThread(void)
     s_joystickThread = NULL;
 }
 
+#endif /* !__WINRT__ */
+
 void WINDOWS_AddJoystickDevice(JoyStick_DeviceData *device)
 {
     device->send_add_event = SDL_TRUE;
@@ -356,6 +453,9 @@ WINDOWS_JoystickInit(void)
 
     WINDOWS_JoystickDetect();
 
+#ifndef __WINRT__
+    SDL_CreateDeviceNotificationFunc();
+
     s_bJoystickThread = SDL_GetHintBoolean(SDL_HINT_JOYSTICK_THREAD, SDL_FALSE);
     if (s_bJoystickThread) {
         if (SDL_StartJoystickThread() < 0) {
@@ -366,6 +466,7 @@ WINDOWS_JoystickInit(void)
             return -1;
         }
     }
+#endif
     return 0;
 }
 
@@ -419,11 +520,11 @@ WINDOWS_JoystickDetect(void)
 
         if (pCurList->bXInputDevice) {
 #if SDL_HAPTIC_XINPUT
-            SDL_XINPUT_MaybeRemoveDevice(pCurList->XInputUserId);
+            SDL_XINPUT_HapticMaybeRemoveDevice(pCurList->XInputUserId);
 #endif
         } else {
 #if SDL_HAPTIC_DINPUT
-            SDL_DINPUT_MaybeRemoveDevice(&pCurList->dxdevice);
+            SDL_DINPUT_HapticMaybeRemoveDevice(&pCurList->dxdevice);
 #endif
         }
 
@@ -439,11 +540,11 @@ WINDOWS_JoystickDetect(void)
         if (pCurList->send_add_event) {
             if (pCurList->bXInputDevice) {
 #if SDL_HAPTIC_XINPUT
-                SDL_XINPUT_MaybeAddDevice(pCurList->XInputUserId);
+                SDL_XINPUT_HapticMaybeAddDevice(pCurList->XInputUserId);
 #endif
             } else {
 #if SDL_HAPTIC_DINPUT
-                SDL_DINPUT_MaybeAddDevice(&pCurList->dxdevice);
+                SDL_DINPUT_HapticMaybeAddDevice(&pCurList->dxdevice);
 #endif
             }
 
@@ -516,7 +617,7 @@ WINDOWS_JoystickGetDeviceInstanceID(int device_index)
    It returns 0, or -1 if there is an error.
  */
 static int
-WINDOWS_JoystickOpen(SDL_Joystick * joystick, int device_index)
+WINDOWS_JoystickOpen(SDL_Joystick *joystick, int device_index)
 {
     JoyStick_DeviceData *device = SYS_Joystick;
     int index;
@@ -542,7 +643,7 @@ WINDOWS_JoystickOpen(SDL_Joystick * joystick, int device_index)
 }
 
 static int
-WINDOWS_JoystickRumble(SDL_Joystick * joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+WINDOWS_JoystickRumble(SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
 {
     if (joystick->hwdata->bXInputDevice) {
         return SDL_XINPUT_JoystickRumble(joystick, low_frequency_rumble, high_frequency_rumble);
@@ -552,19 +653,29 @@ WINDOWS_JoystickRumble(SDL_Joystick * joystick, Uint16 low_frequency_rumble, Uin
 }
 
 static int
-WINDOWS_JoystickRumbleTriggers(SDL_Joystick * joystick, Uint16 left_rumble, Uint16 right_rumble)
+WINDOWS_JoystickRumbleTriggers(SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
 {
     return SDL_Unsupported();
 }
 
-static SDL_bool
-WINDOWS_JoystickHasLED(SDL_Joystick * joystick)
+static Uint32
+WINDOWS_JoystickGetCapabilities(SDL_Joystick *joystick)
 {
-    return SDL_FALSE;
+    if (joystick->hwdata->bXInputDevice) {
+        return SDL_XINPUT_JoystickGetCapabilities(joystick);
+    } else {
+        return SDL_DINPUT_JoystickGetCapabilities(joystick);
+    }
 }
 
 static int
-WINDOWS_JoystickSetLED(SDL_Joystick * joystick, Uint8 red, Uint8 green, Uint8 blue)
+WINDOWS_JoystickSetLED(SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+    return SDL_Unsupported();
+}
+
+static int
+WINDOWS_JoystickSendEffect(SDL_Joystick *joystick, const void *data, int size)
 {
     return SDL_Unsupported();
 }
@@ -576,7 +687,7 @@ WINDOWS_JoystickSetSensorsEnabled(SDL_Joystick *joystick, SDL_bool enabled)
 }
 
 static void
-WINDOWS_JoystickUpdate(SDL_Joystick * joystick)
+WINDOWS_JoystickUpdate(SDL_Joystick *joystick)
 {
     if (!joystick->hwdata) {
         return;
@@ -591,7 +702,7 @@ WINDOWS_JoystickUpdate(SDL_Joystick * joystick)
 
 /* Function to close a joystick after use */
 static void
-WINDOWS_JoystickClose(SDL_Joystick * joystick)
+WINDOWS_JoystickClose(SDL_Joystick *joystick)
 {
     if (joystick->hwdata->bXInputDevice) {
         SDL_XINPUT_JoystickClose(joystick);
@@ -616,12 +727,16 @@ WINDOWS_JoystickQuit(void)
     }
     SYS_Joystick = NULL;
 
+#ifndef __WINRT__
     if (s_bJoystickThread) {
         SDL_StopJoystickThread();
     } else {
         SDL_CleanupDeviceNotification(&s_notification_data);
     }
 
+    SDL_CleanupDeviceNotificationFunc();
+#endif
+
     SDL_DINPUT_JoystickQuit();
     SDL_XINPUT_JoystickQuit();
 
@@ -647,8 +762,9 @@ SDL_JoystickDriver SDL_WINDOWS_JoystickDriver =
     WINDOWS_JoystickOpen,
     WINDOWS_JoystickRumble,
     WINDOWS_JoystickRumbleTriggers,
-    WINDOWS_JoystickHasLED,
+    WINDOWS_JoystickGetCapabilities,
     WINDOWS_JoystickSetLED,
+    WINDOWS_JoystickSendEffect,
     WINDOWS_JoystickSetSensorsEnabled,
     WINDOWS_JoystickUpdate,
     WINDOWS_JoystickClose,
@@ -656,6 +772,13 @@ SDL_JoystickDriver SDL_WINDOWS_JoystickDriver =
     WINDOWS_JoystickGetGamepadMapping
 };
 
+#else
+
+#if SDL_JOYSTICK_RAWINPUT
+/* The RAWINPUT driver needs the device notification setup above */
+#error SDL_JOYSTICK_RAWINPUT requires SDL_JOYSTICK_DINPUT || SDL_JOYSTICK_XINPUT
+#endif
+
 #endif /* SDL_JOYSTICK_DINPUT || SDL_JOYSTICK_XINPUT */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/joystick/windows/SDL_windowsjoystick_c.h b/Engine/lib/sdl/src/joystick/windows/SDL_windowsjoystick_c.h
index 4dbc87649..1b9625385 100644
--- a/Engine/lib/sdl/src/joystick/windows/SDL_windowsjoystick_c.h
+++ b/Engine/lib/sdl/src/joystick/windows/SDL_windowsjoystick_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -37,7 +37,7 @@ typedef struct JoyStick_DeviceData
     BYTE SubType;
     Uint8 XInputUserId;
     DIDEVICEINSTANCE dxdevice;
-    WCHAR hidPath[MAX_PATH];
+    char hidPath[MAX_PATH];
     struct JoyStick_DeviceData *pNext;
 } JoyStick_DeviceData;
 
diff --git a/Engine/lib/sdl/src/joystick/windows/SDL_xinputjoystick.c b/Engine/lib/sdl/src/joystick/windows/SDL_xinputjoystick.c
index 30025428d..f3ab8a0b2 100644
--- a/Engine/lib/sdl/src/joystick/windows/SDL_xinputjoystick.c
+++ b/Engine/lib/sdl/src/joystick/windows/SDL_xinputjoystick.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -201,9 +201,20 @@ GuessXInputDevice(Uint8 userid, Uint16 *pVID, Uint16 *pPID, Uint16 *pVersion)
                  * userid, but we'll record it so we'll at least be consistent
                  * when the raw device list changes.
                  */
-                *pVID = (Uint16)rdi.hid.dwVendorId;
-                *pPID = (Uint16)rdi.hid.dwProductId;
-                *pVersion = (Uint16)rdi.hid.dwVersionNumber;
+                if (rdi.hid.dwVendorId == USB_VENDOR_VALVE &&
+                    rdi.hid.dwProductId == USB_PRODUCT_STEAM_VIRTUAL_GAMEPAD) {
+                    /* Steam encodes the real device in the path */
+                    int realVID = rdi.hid.dwVendorId;
+                    int realPID = rdi.hid.dwProductId;
+                    SDL_sscanf(devName, "\\\\.\\pipe\\HID#VID_045E&PID_028E&IG_00#%x&%x&", &realVID, &realPID);
+                    *pVID = (Uint16)realVID;
+                    *pPID = (Uint16)realPID;
+                    *pVersion = 0;
+                } else {
+                    *pVID = (Uint16)rdi.hid.dwVendorId;
+                    *pPID = (Uint16)rdi.hid.dwProductId;
+                    *pVersion = (Uint16)rdi.hid.dwVersionNumber;
+                }
                 if (s_arrXInputDevicePath[userid]) {
                     SDL_free(s_arrXInputDevicePath[userid]);
                 }
@@ -503,6 +514,12 @@ SDL_XINPUT_JoystickRumble(SDL_Joystick * joystick, Uint16 low_frequency_rumble,
     return 0;
 }
 
+Uint32
+SDL_XINPUT_JoystickGetCapabilities(SDL_Joystick * joystick)
+{
+    return SDL_JOYCAP_RUMBLE;
+}
+
 void
 SDL_XINPUT_JoystickUpdate(SDL_Joystick * joystick)
 {
@@ -579,6 +596,12 @@ SDL_XINPUT_JoystickRumble(SDL_Joystick * joystick, Uint16 low_frequency_rumble,
     return SDL_Unsupported();
 }
 
+Uint32
+SDL_XINPUT_JoystickGetCapabilities(SDL_Joystick * joystick)
+{
+    return 0;
+}
+
 void
 SDL_XINPUT_JoystickUpdate(SDL_Joystick * joystick)
 {
diff --git a/Engine/lib/sdl/src/joystick/windows/SDL_xinputjoystick_c.h b/Engine/lib/sdl/src/joystick/windows/SDL_xinputjoystick_c.h
index 9afd1607e..c0a0600d7 100644
--- a/Engine/lib/sdl/src/joystick/windows/SDL_xinputjoystick_c.h
+++ b/Engine/lib/sdl/src/joystick/windows/SDL_xinputjoystick_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -27,6 +27,7 @@ extern int SDL_XINPUT_JoystickInit(void);
 extern void SDL_XINPUT_JoystickDetect(JoyStick_DeviceData **pContext);
 extern int SDL_XINPUT_JoystickOpen(SDL_Joystick * joystick, JoyStick_DeviceData *joystickdevice);
 extern int SDL_XINPUT_JoystickRumble(SDL_Joystick * joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble);
+extern Uint32 SDL_XINPUT_JoystickGetCapabilities(SDL_Joystick * joystick);
 extern void SDL_XINPUT_JoystickUpdate(SDL_Joystick * joystick);
 extern void SDL_XINPUT_JoystickClose(SDL_Joystick * joystick);
 extern void SDL_XINPUT_JoystickQuit(void);
diff --git a/Engine/lib/sdl/src/libm/math_libm.h b/Engine/lib/sdl/src/libm/math_libm.h
index 2f26e3ad3..0bce44f73 100644
--- a/Engine/lib/sdl/src/libm/math_libm.h
+++ b/Engine/lib/sdl/src/libm/math_libm.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/libm/math_private.h b/Engine/lib/sdl/src/libm/math_private.h
index 02535559a..4a30a521a 100644
--- a/Engine/lib/sdl/src/libm/math_private.h
+++ b/Engine/lib/sdl/src/libm/math_private.h
@@ -27,7 +27,7 @@
 #define libm_hidden_def(x)
 #define strong_alias(x, y)
 
-#ifndef __HAIKU__ /* already defined in a system header. */
+#if !defined(__HAIKU__) && !defined(__PSP__) /* already defined in a system header. */
 typedef unsigned int u_int32_t;
 #endif
 
diff --git a/Engine/lib/sdl/src/loadso/dlopen/SDL_sysloadso.c b/Engine/lib/sdl/src/loadso/dlopen/SDL_sysloadso.c
index d4bebe14c..e5abe85db 100644
--- a/Engine/lib/sdl/src/loadso/dlopen/SDL_sysloadso.c
+++ b/Engine/lib/sdl/src/loadso/dlopen/SDL_sysloadso.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/loadso/dummy/SDL_sysloadso.c b/Engine/lib/sdl/src/loadso/dummy/SDL_sysloadso.c
index 559118db7..da45a842f 100644
--- a/Engine/lib/sdl/src/loadso/dummy/SDL_sysloadso.c
+++ b/Engine/lib/sdl/src/loadso/dummy/SDL_sysloadso.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/loadso/os2/SDL_sysloadso.c b/Engine/lib/sdl/src/loadso/os2/SDL_sysloadso.c
index ca9d2fd24..2b96848ac 100644
--- a/Engine/lib/sdl/src/loadso/os2/SDL_sysloadso.c
+++ b/Engine/lib/sdl/src/loadso/os2/SDL_sysloadso.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -41,7 +41,7 @@ SDL_LoadObject(const char *sofile)
     PSZ     pszModName;
 
     if (!sofile) {
-        SDL_SetError("NULL sofile");
+        SDL_InvalidParamError("sofile");
         return NULL;
     }
 
diff --git a/Engine/lib/sdl/src/loadso/windows/SDL_sysloadso.c b/Engine/lib/sdl/src/loadso/windows/SDL_sysloadso.c
index 3513718de..d3c84042b 100644
--- a/Engine/lib/sdl/src/loadso/windows/SDL_sysloadso.c
+++ b/Engine/lib/sdl/src/loadso/windows/SDL_sysloadso.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -36,7 +36,7 @@ SDL_LoadObject(const char *sofile)
     LPTSTR tstr;
 
     if (!sofile) {
-        SDL_SetError("NULL sofile");
+        SDL_InvalidParamError("sofile");
         return NULL;
     }
     tstr = WIN_UTF8ToString(sofile);
diff --git a/Engine/lib/sdl/src/locale/SDL_locale.c b/Engine/lib/sdl/src/locale/SDL_locale.c
index c7e5b1011..5aaf87284 100644
--- a/Engine/lib/sdl/src/locale/SDL_locale.c
+++ b/Engine/lib/sdl/src/locale/SDL_locale.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -45,7 +45,7 @@ build_locales_from_csv_string(char *csv)
 
     num_locales++;  /* one more for terminator */
 
-    slen = ((size_t) (ptr - csv)) + 1;  /* strlen(csv) + 1 */
+    slen = ((size_t) (ptr - csv)) + 1;  /* SDL_strlen(csv) + 1 */
     alloclen = slen + (num_locales * sizeof (SDL_Locale));
 
     loc = retval = (SDL_Locale *) SDL_calloc(1, alloclen);
diff --git a/Engine/lib/sdl/src/locale/SDL_syslocale.h b/Engine/lib/sdl/src/locale/SDL_syslocale.h
index 887baa063..826313971 100644
--- a/Engine/lib/sdl/src/locale/SDL_syslocale.h
+++ b/Engine/lib/sdl/src/locale/SDL_syslocale.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/locale/android/SDL_syslocale.c b/Engine/lib/sdl/src/locale/android/SDL_syslocale.c
index 6cfb9751b..ed969b8dd 100644
--- a/Engine/lib/sdl/src/locale/android/SDL_syslocale.c
+++ b/Engine/lib/sdl/src/locale/android/SDL_syslocale.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/locale/dummy/SDL_syslocale.c b/Engine/lib/sdl/src/locale/dummy/SDL_syslocale.c
index ad554daef..e5ed1ad13 100644
--- a/Engine/lib/sdl/src/locale/dummy/SDL_syslocale.c
+++ b/Engine/lib/sdl/src/locale/dummy/SDL_syslocale.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/locale/emscripten/SDL_syslocale.c b/Engine/lib/sdl/src/locale/emscripten/SDL_syslocale.c
index 7004258e0..98d3c0353 100644
--- a/Engine/lib/sdl/src/locale/emscripten/SDL_syslocale.c
+++ b/Engine/lib/sdl/src/locale/emscripten/SDL_syslocale.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/locale/haiku/SDL_syslocale.cc b/Engine/lib/sdl/src/locale/haiku/SDL_syslocale.cc
index 3b930e8bc..1f885b023 100644
--- a/Engine/lib/sdl/src/locale/haiku/SDL_syslocale.cc
+++ b/Engine/lib/sdl/src/locale/haiku/SDL_syslocale.cc
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/locale/macosx/SDL_syslocale.m b/Engine/lib/sdl/src/locale/macosx/SDL_syslocale.m
index 5ffbecdde..0e6bd3634 100644
--- a/Engine/lib/sdl/src/locale/macosx/SDL_syslocale.m
+++ b/Engine/lib/sdl/src/locale/macosx/SDL_syslocale.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/locale/unix/SDL_syslocale.c b/Engine/lib/sdl/src/locale/unix/SDL_syslocale.c
index 2a51f0c37..b9a377439 100644
--- a/Engine/lib/sdl/src/locale/unix/SDL_syslocale.c
+++ b/Engine/lib/sdl/src/locale/unix/SDL_syslocale.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/locale/windows/SDL_syslocale.c b/Engine/lib/sdl/src/locale/windows/SDL_syslocale.c
index 1252046cf..2d033f476 100644
--- a/Engine/lib/sdl/src/locale/windows/SDL_syslocale.c
+++ b/Engine/lib/sdl/src/locale/windows/SDL_syslocale.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -23,9 +23,9 @@
 #include "../../core/windows/SDL_windows.h"
 #include "../SDL_syslocale.h"
 
-typedef BOOL (WINAPI *pfnGetUserPreferredUILanguages)(DWORD,PULONG,/*PZZWSTR*/WCHAR*,PULONG);
+typedef BOOL (WINAPI *pfnGetUserPreferredUILanguages)(DWORD,PULONG,WCHAR*,PULONG);
 #ifndef MUI_LANGUAGE_NAME
-#define MUI_LANGUAGE_NAME 0x8 
+#define MUI_LANGUAGE_NAME 0x8
 #endif
 
 static pfnGetUserPreferredUILanguages pGetUserPreferredUILanguages = NULL;
@@ -39,11 +39,11 @@ SDL_SYS_GetPreferredLocales_winxp(char *buf, size_t buflen)
     char lang[16];
     char country[16];
 
-	const int langrc = GetLocaleInfoA(LOCALE_USER_DEFAULT,
+    const int langrc = GetLocaleInfoA(LOCALE_USER_DEFAULT,
                                       LOCALE_SISO639LANGNAME,
                                       lang, sizeof (lang));
 
-	const int ctryrc =  GetLocaleInfoA(LOCALE_USER_DEFAULT,
+    const int ctryrc =  GetLocaleInfoA(LOCALE_USER_DEFAULT,
                                        LOCALE_SISO3166CTRYNAME,
                                        country, sizeof (country));
 
@@ -100,7 +100,7 @@ void
 SDL_SYS_GetPreferredLocales(char *buf, size_t buflen)
 {
     if (!kernel32) {
-        kernel32 = LoadLibraryW(L"kernel32.dll");
+        kernel32 = GetModuleHandle(TEXT("kernel32.dll"));
         if (kernel32) {
             pGetUserPreferredUILanguages = (pfnGetUserPreferredUILanguages) GetProcAddress(kernel32, "GetUserPreferredUILanguages");
         }
diff --git a/Engine/lib/sdl/src/locale/winrt/SDL_syslocale.c b/Engine/lib/sdl/src/locale/winrt/SDL_syslocale.c
index 923565cc0..1af2a95fc 100644
--- a/Engine/lib/sdl/src/locale/winrt/SDL_syslocale.c
+++ b/Engine/lib/sdl/src/locale/winrt/SDL_syslocale.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/main/dummy/SDL_dummy_main.c b/Engine/lib/sdl/src/main/dummy/SDL_dummy_main.c
index 0174136b2..b78d8db14 100644
--- a/Engine/lib/sdl/src/main/dummy/SDL_dummy_main.c
+++ b/Engine/lib/sdl/src/main/dummy/SDL_dummy_main.c
@@ -15,9 +15,6 @@ main(int argc, char *argv[])
 }
 #else
 /* Nothing to do on this platform */
-int
-SDL_main_stub_symbol(void);
-
 int
 SDL_main_stub_symbol(void)
 {
diff --git a/Engine/lib/sdl/src/main/haiku/SDL_BApp.h b/Engine/lib/sdl/src/main/haiku/SDL_BApp.h
index ce1fc6812..215f83662 100644
--- a/Engine/lib/sdl/src/main/haiku/SDL_BApp.h
+++ b/Engine/lib/sdl/src/main/haiku/SDL_BApp.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -21,6 +21,7 @@
 #ifndef SDL_BAPP_H
 #define SDL_BAPP_H
 
+#include <Path.h>
 #include <InterfaceKit.h>
 #include <LocaleRoster.h>
 #if SDL_VIDEO_OPENGL
@@ -93,6 +94,15 @@ public:
     }
 
 
+	virtual void RefsReceived(BMessage* message) {
+		char filePath[512];
+		entry_ref entryRef;
+		for (int32 i = 0; message->FindRef("refs", i, &entryRef) == B_OK; i++) {
+			BPath referencePath = BPath(&entryRef);
+			SDL_SendDropFile(NULL, referencePath.Path());
+		}
+		return;
+	}
 
         /* Event-handling functions */
     virtual void MessageReceived(BMessage* message) {
@@ -198,6 +208,10 @@ public:
     }
 
 #if SDL_VIDEO_OPENGL
+    BGLView *GetCurrentContext() {
+        return _current_context;
+    }
+    
     void SetCurrentContext(BGLView *newContext) {
         if(_current_context)
             _current_context->UnlockGL();
@@ -234,25 +248,22 @@ private:
         }
         win = GetSDLWindow(winID);
 
-		// Simple relative mode support for mouse.
-		if (SDL_GetMouse()->relative_mode) {
-			int winWidth, winHeight, winPosX, winPosY;
-			SDL_GetWindowSize(win, &winWidth, &winHeight);
-			SDL_GetWindowPosition(win, &winPosX, &winPosY);
-			int dx = x - (winWidth / 2);
-			int dy = y - (winHeight / 2);
-			SDL_SendMouseMotion(win, 0, SDL_GetMouse()->relative_mode, dx, dy);
-			set_mouse_position((winPosX + winWidth / 2), (winPosY + winHeight / 2));
-			if (!be_app->IsCursorHidden())
-				be_app->HideCursor();
-		} else {
-			SDL_SendMouseMotion(win, 0, 0, x, y);
-			if (SDL_ShowCursor(-1) && be_app->IsCursorHidden())
-				be_app->ShowCursor();
-		}
-
-        /* Tell the application that the mouse passed over, redraw needed */
-        HAIKU_UpdateWindowFramebuffer(NULL,win,NULL,-1);
+        // Simple relative mode support for mouse.
+        if (SDL_GetMouse()->relative_mode) {
+            int winWidth, winHeight, winPosX, winPosY;
+            SDL_GetWindowSize(win, &winWidth, &winHeight);
+            SDL_GetWindowPosition(win, &winPosX, &winPosY);
+            int dx = x - (winWidth / 2);
+            int dy = y - (winHeight / 2);
+            SDL_SendMouseMotion(win, 0, SDL_GetMouse()->relative_mode, dx, dy);
+            set_mouse_position((winPosX + winWidth / 2), (winPosY + winHeight / 2));
+            if (!be_app->IsCursorHidden())
+                be_app->HideCursor();
+        } else {
+            SDL_SendMouseMotion(win, 0, 0, x, y);
+            if (SDL_ShowCursor(-1) && be_app->IsCursorHidden())
+                be_app->ShowCursor();
+        }
     }
 
     void _HandleMouseButton(BMessage *msg) {
@@ -300,7 +311,7 @@ private:
         }
         HAIKU_SetKeyState(scancode, state);
         SDL_SendKeyboardKey(state, HAIKU_GetScancodeFromBeKey(scancode));
-        
+
         if (state == SDL_PRESSED && SDL_EventState(SDL_TEXTINPUT, SDL_QUERY)) {
             const int8 *keyUtf8;
             ssize_t count;
diff --git a/Engine/lib/sdl/src/main/haiku/SDL_BeApp.cc b/Engine/lib/sdl/src/main/haiku/SDL_BeApp.cc
index 403be8258..a5e1428cc 100644
--- a/Engine/lib/sdl/src/main/haiku/SDL_BeApp.cc
+++ b/Engine/lib/sdl/src/main/haiku/SDL_BeApp.cc
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/main/haiku/SDL_BeApp.h b/Engine/lib/sdl/src/main/haiku/SDL_BeApp.h
index db92b6d0b..5b74466e0 100644
--- a/Engine/lib/sdl/src/main/haiku/SDL_BeApp.h
+++ b/Engine/lib/sdl/src/main/haiku/SDL_BeApp.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/main/nacl/SDL_nacl_main.c b/Engine/lib/sdl/src/main/nacl/SDL_nacl_main.c
index 4c223faba..a0838b184 100644
--- a/Engine/lib/sdl/src/main/nacl/SDL_nacl_main.c
+++ b/Engine/lib/sdl/src/main/nacl/SDL_nacl_main.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/main/psp/SDL_psp_main.c b/Engine/lib/sdl/src/main/psp/SDL_psp_main.c
index 2ca8e446b..8eb173fb4 100644
--- a/Engine/lib/sdl/src/main/psp/SDL_psp_main.c
+++ b/Engine/lib/sdl/src/main/psp/SDL_psp_main.c
@@ -7,11 +7,11 @@
 
 #include "SDL_main.h"
 #include <pspkernel.h>
-#include <pspdebug.h>
-#include <pspsdk.h>
 #include <pspthreadman.h>
-#include <stdlib.h>
-#include <stdio.h>
+
+#ifdef main
+    #undef main
+#endif
 
 /* If application's main() is redefined as SDL_main, and libSDLmain is
    linked, then this file will create the standard exit callback,
@@ -23,11 +23,12 @@
    PSP_MAIN_THREAD_STACK_SIZE, etc.
 */
 
-PSP_MODULE_INFO("SDL App", 0, 1, 1);
+PSP_MODULE_INFO("SDL App", 0, 1, 0);
+PSP_MAIN_THREAD_ATTR(THREAD_ATTR_VFPU | THREAD_ATTR_USER);
 
 int sdl_psp_exit_callback(int arg1, int arg2, void *common)
 {
-    exit(0);
+    sceKernelExitGame();
     return 0;
 }
 
@@ -43,7 +44,7 @@ int sdl_psp_callback_thread(SceSize args, void *argp)
 
 int sdl_psp_setup_callbacks(void)
 {
-    int thid = 0;
+    int thid;
     thid = sceKernelCreateThread("update_thread",
                      sdl_psp_callback_thread, 0x11, 0xFA0, 0, 0);
     if(thid >= 0)
@@ -53,12 +54,8 @@ int sdl_psp_setup_callbacks(void)
 
 int main(int argc, char *argv[])
 {
-    pspDebugScreenInit();
     sdl_psp_setup_callbacks();
 
-    /* Register sceKernelExitGame() to be called when we exit */
-    atexit(sceKernelExitGame);
-
     SDL_SetMainReady();
 
     (void)SDL_main(argc, argv);
diff --git a/Engine/lib/sdl/src/main/uikit/SDL_uikit_main.c b/Engine/lib/sdl/src/main/uikit/SDL_uikit_main.c
index 5717d0e80..702f67391 100644
--- a/Engine/lib/sdl/src/main/uikit/SDL_uikit_main.c
+++ b/Engine/lib/sdl/src/main/uikit/SDL_uikit_main.c
@@ -6,6 +6,7 @@
 /* Include the SDL main definition header */
 #include "SDL_main.h"
 
+#ifndef SDL_MAIN_HANDLED
 #ifdef main
 #undef main
 #endif
@@ -15,5 +16,6 @@ main(int argc, char *argv[])
 {
     return SDL_UIKitRunApp(argc, argv, SDL_main);
 }
+#endif /* !SDL_MAIN_HANDLED */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/main/windows/SDL_windows_main.c b/Engine/lib/sdl/src/main/windows/SDL_windows_main.c
index f8b104186..056787e40 100644
--- a/Engine/lib/sdl/src/main/windows/SDL_windows_main.c
+++ b/Engine/lib/sdl/src/main/windows/SDL_windows_main.c
@@ -19,8 +19,6 @@
 #  undef main
 #endif /* main */
 
-#define WIN_WStringToUTF8(S) SDL_iconv_string("UTF-8", "UTF-16LE", (char *)(S), (SDL_wcslen(S)+1)*sizeof(WCHAR))
-
 /* Pop up an out of memory message, returns to Windows */
 static BOOL
 OutOfMemory(void)
@@ -51,16 +49,29 @@ main_getcmdline(void)
         return OutOfMemory();
     }
 
+    /* Note that we need to be careful about how we allocate/free memory here.
+     * If the application calls SDL_SetMemoryFunctions(), we can't rely on
+     * SDL_free() to use the same allocator after SDL_main() returns.
+     */
+
     /* Parse it into argv and argc */
-    argv = (char **)SDL_calloc(argc + 1, sizeof(*argv));
+    argv = (char **)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (argc + 1) * sizeof(*argv));
     if (!argv) {
         return OutOfMemory();
     }
     for (i = 0; i < argc; ++i) {
-        argv[i] = WIN_WStringToUTF8(argvw[i]);
+        DWORD len;
+        char *arg = WIN_StringToUTF8W(argvw[i]);
+        if (!arg) {
+            return OutOfMemory();
+        }
+        len = (DWORD)SDL_strlen(arg);
+        argv[i] = (char *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len + 1);
         if (!argv[i]) {
             return OutOfMemory();
         }
+        CopyMemory(argv[i], arg, len);
+        SDL_free(arg);
     }
     argv[i] = NULL;
     LocalFree(argvw);
@@ -72,9 +83,9 @@ main_getcmdline(void)
 
     /* Free argv, to avoid memory leak */
     for (i = 0; i < argc; ++i) {
-        SDL_free(argv[i]);
+        HeapFree(GetProcessHeap(), 0, argv[i]);
     }
-    SDL_free(argv);
+    HeapFree(GetProcessHeap(), 0, argv);
 
     return result;
 }
diff --git a/Engine/lib/sdl/src/main/windows/version.rc b/Engine/lib/sdl/src/main/windows/version.rc
index 90c14981f..36ff39f12 100644
--- a/Engine/lib/sdl/src/main/windows/version.rc
+++ b/Engine/lib/sdl/src/main/windows/version.rc
@@ -9,8 +9,8 @@ LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
 //
 
 VS_VERSION_INFO VERSIONINFO
- FILEVERSION 2,0,14,0
- PRODUCTVERSION 2,0,14,0
+ FILEVERSION 2,0,21,0
+ PRODUCTVERSION 2,0,21,0
  FILEFLAGSMASK 0x3fL
  FILEFLAGS 0x0L
  FILEOS 0x40004L
@@ -23,12 +23,12 @@ BEGIN
         BEGIN
             VALUE "CompanyName", "\0"
             VALUE "FileDescription", "SDL\0"
-            VALUE "FileVersion", "2, 0, 14, 0\0"
+            VALUE "FileVersion", "2, 0, 21, 0\0"
             VALUE "InternalName", "SDL\0"
-            VALUE "LegalCopyright", "Copyright © 2020 Sam Lantinga\0"
+            VALUE "LegalCopyright", "Copyright (C) 2022 Sam Lantinga\0"
             VALUE "OriginalFilename", "SDL2.dll\0"
             VALUE "ProductName", "Simple DirectMedia Layer\0"
-            VALUE "ProductVersion", "2, 0, 14, 0\0"
+            VALUE "ProductVersion", "2, 0, 21, 0\0"
         END
     END
     BLOCK "VarFileInfo"
diff --git a/Engine/lib/sdl/src/misc/SDL_sysurl.h b/Engine/lib/sdl/src/misc/SDL_sysurl.h
index d10e0271b..28cc40daf 100644
--- a/Engine/lib/sdl/src/misc/SDL_sysurl.h
+++ b/Engine/lib/sdl/src/misc/SDL_sysurl.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/misc/SDL_url.c b/Engine/lib/sdl/src/misc/SDL_url.c
index fe60766c9..eb258d962 100644
--- a/Engine/lib/sdl/src/misc/SDL_url.c
+++ b/Engine/lib/sdl/src/misc/SDL_url.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/misc/android/SDL_sysurl.c b/Engine/lib/sdl/src/misc/android/SDL_sysurl.c
index 37ea689d0..c17fbca46 100644
--- a/Engine/lib/sdl/src/misc/android/SDL_sysurl.c
+++ b/Engine/lib/sdl/src/misc/android/SDL_sysurl.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/misc/dummy/SDL_sysurl.c b/Engine/lib/sdl/src/misc/dummy/SDL_sysurl.c
index 201f56be5..d35d016fc 100644
--- a/Engine/lib/sdl/src/misc/dummy/SDL_sysurl.c
+++ b/Engine/lib/sdl/src/misc/dummy/SDL_sysurl.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/misc/emscripten/SDL_sysurl.c b/Engine/lib/sdl/src/misc/emscripten/SDL_sysurl.c
new file mode 100644
index 000000000..f344232ab
--- /dev/null
+++ b/Engine/lib/sdl/src/misc/emscripten/SDL_sysurl.c
@@ -0,0 +1,37 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "../SDL_sysurl.h"
+
+#include <emscripten/emscripten.h>
+
+int
+SDL_SYS_OpenURL(const char *url)
+{
+    EM_ASM({
+        window.open(UTF8ToString($0), "_blank");
+    }, url);
+
+    return 0;
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
+
diff --git a/Engine/lib/sdl/src/misc/haiku/SDL_sysurl.cc b/Engine/lib/sdl/src/misc/haiku/SDL_sysurl.cc
index cd0df1cd2..01a43f989 100644
--- a/Engine/lib/sdl/src/misc/haiku/SDL_sysurl.cc
+++ b/Engine/lib/sdl/src/misc/haiku/SDL_sysurl.cc
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/misc/ios/SDL_sysurl.m b/Engine/lib/sdl/src/misc/ios/SDL_sysurl.m
index c7a5207da..73d5c73ec 100644
--- a/Engine/lib/sdl/src/misc/ios/SDL_sysurl.m
+++ b/Engine/lib/sdl/src/misc/ios/SDL_sysurl.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/misc/macosx/SDL_sysurl.m b/Engine/lib/sdl/src/misc/macosx/SDL_sysurl.m
index c896d9904..1b141ee1f 100644
--- a/Engine/lib/sdl/src/misc/macosx/SDL_sysurl.m
+++ b/Engine/lib/sdl/src/misc/macosx/SDL_sysurl.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -27,10 +27,10 @@ int
 SDL_SYS_OpenURL(const char *url)
 { @autoreleasepool
 {
-    NSString *nsstr = [NSString stringWithUTF8String:url];
-    NSURL *nsurl = [NSURL URLWithString:nsstr];
-    return [[NSWorkspace sharedWorkspace] openURL:nsurl] ? 0 : -1;
+    CFURLRef cfurl = CFURLCreateWithBytes(NULL, (const UInt8 *) url, SDL_strlen(url), kCFStringEncodingUTF8,  NULL);
+    OSStatus status = LSOpenCFURLRef(cfurl, NULL);
+    CFRelease(cfurl);
+    return status == noErr ? 0 : -1;
 }}
 
 /* vi: set ts=4 sw=4 expandtab: */
-
diff --git a/Engine/lib/sdl/src/misc/riscos/SDL_sysurl.c b/Engine/lib/sdl/src/misc/riscos/SDL_sysurl.c
index f51661f17..2662c4d68 100644
--- a/Engine/lib/sdl/src/misc/riscos/SDL_sysurl.c
+++ b/Engine/lib/sdl/src/misc/riscos/SDL_sysurl.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/misc/unix/SDL_sysurl.c b/Engine/lib/sdl/src/misc/unix/SDL_sysurl.c
index 1fb7f3242..8d6e0fc91 100644
--- a/Engine/lib/sdl/src/misc/unix/SDL_sysurl.c
+++ b/Engine/lib/sdl/src/misc/unix/SDL_sysurl.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -33,8 +33,11 @@ SDL_SYS_OpenURL(const char *url)
 {
     const pid_t pid1 = fork();
     if (pid1 == 0) {  /* child process */
+        pid_t pid2;
+        /* Clear LD_PRELOAD so Chrome opens correctly when this application is launched by Steam */
+        unsetenv("LD_PRELOAD");
         /* Notice this is vfork and not fork! */
-        const pid_t pid2 = vfork();
+        pid2 = vfork();
         if (pid2 == 0) {  /* Grandchild process will try to launch the url */
             execlp("xdg-open", "xdg-open", url, NULL);
             _exit(EXIT_FAILURE);
@@ -62,8 +65,6 @@ SDL_SYS_OpenURL(const char *url)
             return SDL_SetError("Waiting on xdg-open failed: %s", strerror(errno));
         }
     }
-
-    return 0;
 }
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/misc/vita/SDL_sysurl.c b/Engine/lib/sdl/src/misc/vita/SDL_sysurl.c
new file mode 100644
index 000000000..1052efb40
--- /dev/null
+++ b/Engine/lib/sdl/src/misc/vita/SDL_sysurl.c
@@ -0,0 +1,44 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "../SDL_sysurl.h"
+
+#include <string.h>
+#include <psp2/apputil.h>
+
+int
+SDL_SYS_OpenURL(const char *url)
+{
+    SceAppUtilInitParam init_param;
+    SceAppUtilBootParam boot_param;
+    SceAppUtilWebBrowserParam browser_param;
+    SDL_zero(init_param);
+    SDL_zero(boot_param);
+    sceAppUtilInit(&init_param, &boot_param);
+    SDL_zero(browser_param);
+    browser_param.str = url;
+    browser_param.strlen = SDL_strlen(url);
+    sceAppUtilLaunchWebBrowser(&browser_param);
+    return 0;
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
+
diff --git a/Engine/lib/sdl/src/misc/windows/SDL_sysurl.c b/Engine/lib/sdl/src/misc/windows/SDL_sysurl.c
index 1b2962031..12903db8f 100644
--- a/Engine/lib/sdl/src/misc/windows/SDL_sysurl.c
+++ b/Engine/lib/sdl/src/misc/windows/SDL_sysurl.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -37,7 +37,7 @@ SDL_SYS_OpenURL(const char *url)
         return WIN_SetErrorFromHRESULT("CoInitialize failed", hr);
     }
 
-    wurl = WIN_UTF8ToString(url);
+    wurl = WIN_UTF8ToStringW(url);
     if (wurl == NULL) {
         WIN_CoUninitialize();
         return SDL_OutOfMemory();
diff --git a/Engine/lib/sdl/src/misc/winrt/SDL_sysurl.cpp b/Engine/lib/sdl/src/misc/winrt/SDL_sysurl.cpp
index d2bd4de9f..111a14413 100644
--- a/Engine/lib/sdl/src/misc/winrt/SDL_sysurl.cpp
+++ b/Engine/lib/sdl/src/misc/winrt/SDL_sysurl.cpp
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -19,15 +19,13 @@
   3. This notice may not be removed or altered from any source distribution.
 */
 
-#include <Windows.h>
-
-#include "../../core/windows/SDL_windows.h"
 #include "../SDL_sysurl.h"
+#include "../../core/windows/SDL_windows.h"
 
 int
 SDL_SYS_OpenURL(const char *url)
 {
-    WCHAR *wurl = WIN_UTF8ToString(url);
+    WCHAR *wurl = WIN_UTF8ToStringW(url);
     if (!wurl) {
         return SDL_OutOfMemory();
     }
diff --git a/Engine/lib/sdl/src/power/SDL_power.c b/Engine/lib/sdl/src/power/SDL_power.c
index ca19d4492..625a8fa08 100644
--- a/Engine/lib/sdl/src/power/SDL_power.c
+++ b/Engine/lib/sdl/src/power/SDL_power.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -68,6 +68,9 @@ static SDL_GetPowerInfo_Impl implementations[] = {
 #ifdef SDL_POWER_PSP        /* handles PSP. */
     SDL_GetPowerInfo_PSP,
 #endif
+#ifdef SDL_POWER_VITA        /* handles PSVita. */
+    SDL_GetPowerInfo_VITA,
+#endif
 #ifdef SDL_POWER_WINRT          /* handles WinRT */
     SDL_GetPowerInfo_WinRT,
 #endif
diff --git a/Engine/lib/sdl/src/power/SDL_syspower.h b/Engine/lib/sdl/src/power/SDL_syspower.h
index f28cc982b..d66e50f9c 100644
--- a/Engine/lib/sdl/src/power/SDL_syspower.h
+++ b/Engine/lib/sdl/src/power/SDL_syspower.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -38,6 +38,7 @@ SDL_bool SDL_GetPowerInfo_MacOSX(SDL_PowerState *, int *, int *);
 SDL_bool SDL_GetPowerInfo_Haiku(SDL_PowerState *, int *, int *);
 SDL_bool SDL_GetPowerInfo_Android(SDL_PowerState *, int *, int *);
 SDL_bool SDL_GetPowerInfo_PSP(SDL_PowerState *, int *, int *);
+SDL_bool SDL_GetPowerInfo_VITA(SDL_PowerState *, int *, int *);
 SDL_bool SDL_GetPowerInfo_WinRT(SDL_PowerState *, int *, int *);
 SDL_bool SDL_GetPowerInfo_Emscripten(SDL_PowerState *, int *, int *);
 
diff --git a/Engine/lib/sdl/src/power/android/SDL_syspower.c b/Engine/lib/sdl/src/power/android/SDL_syspower.c
index 045925af3..4be3b1502 100644
--- a/Engine/lib/sdl/src/power/android/SDL_syspower.c
+++ b/Engine/lib/sdl/src/power/android/SDL_syspower.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/power/emscripten/SDL_syspower.c b/Engine/lib/sdl/src/power/emscripten/SDL_syspower.c
index 97afe3405..4bac68602 100644
--- a/Engine/lib/sdl/src/power/emscripten/SDL_syspower.c
+++ b/Engine/lib/sdl/src/power/emscripten/SDL_syspower.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/power/haiku/SDL_syspower.c b/Engine/lib/sdl/src/power/haiku/SDL_syspower.c
index 28ccdec6b..ac1fae917 100644
--- a/Engine/lib/sdl/src/power/haiku/SDL_syspower.c
+++ b/Engine/lib/sdl/src/power/haiku/SDL_syspower.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -45,7 +45,7 @@
 SDL_bool
 SDL_GetPowerInfo_Haiku(SDL_PowerState * state, int *seconds, int *percent)
 {
-    const int fd = open("/dev/misc/apm", O_RDONLY);
+    const int fd = open("/dev/misc/apm", O_RDONLY | O_CLOEXEC);
     SDL_bool need_details = SDL_FALSE;
     uint16 regs[6];
     uint8 ac_status;
@@ -59,7 +59,7 @@ SDL_GetPowerInfo_Haiku(SDL_PowerState * state, int *seconds, int *percent)
         return SDL_FALSE;       /* maybe some other method will work? */
     }
 
-    memset(regs, '\0', sizeof(regs));
+    SDL_memset(regs, '\0', sizeof(regs));
     regs[0] = APM_FUNC_OFFSET + APM_FUNC_GET_POWER_STATUS;
     regs[1] = APM_DEVICE_ALL;
     rc = ioctl(fd, APM_BIOS_CALL, regs);
diff --git a/Engine/lib/sdl/src/power/linux/SDL_syspower.c b/Engine/lib/sdl/src/power/linux/SDL_syspower.c
index 234119c5a..f4e1ecc3d 100644
--- a/Engine/lib/sdl/src/power/linux/SDL_syspower.c
+++ b/Engine/lib/sdl/src/power/linux/SDL_syspower.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -44,14 +44,17 @@ static const char *sys_class_power_supply_path = "/sys/class/power_supply";
 static int
 open_power_file(const char *base, const char *node, const char *key)
 {
-    const size_t pathlen = strlen(base) + strlen(node) + strlen(key) + 3;
-    char *path = (char *) alloca(pathlen);
+    int fd;
+    const size_t pathlen = SDL_strlen(base) + SDL_strlen(node) + SDL_strlen(key) + 3;
+    char *path = SDL_stack_alloc(char, pathlen);
     if (path == NULL) {
         return -1;  /* oh well. */
     }
 
-    snprintf(path, pathlen, "%s/%s/%s", base, node, key);
-    return open(path, O_RDONLY);
+    SDL_snprintf(path, pathlen, "%s/%s/%s", base, node, key);
+    fd = open(path, O_RDONLY | O_CLOEXEC);
+    SDL_stack_free(path);
+    return fd;
 }
 
 
@@ -146,20 +149,20 @@ check_proc_acpi_battery(const char * node, SDL_bool * have_battery,
 
     ptr = &state[0];
     while (make_proc_acpi_key_val(&ptr, &key, &val)) {
-        if (strcmp(key, "present") == 0) {
-            if (strcmp(val, "yes") == 0) {
+        if (SDL_strcmp(key, "present") == 0) {
+            if (SDL_strcmp(val, "yes") == 0) {
                 *have_battery = SDL_TRUE;
             }
-        } else if (strcmp(key, "charging state") == 0) {
+        } else if (SDL_strcmp(key, "charging state") == 0) {
             /* !!! FIXME: what exactly _does_ charging/discharging mean? */
-            if (strcmp(val, "charging/discharging") == 0) {
+            if (SDL_strcmp(val, "charging/discharging") == 0) {
                 charge = SDL_TRUE;
-            } else if (strcmp(val, "charging") == 0) {
+            } else if (SDL_strcmp(val, "charging") == 0) {
                 charge = SDL_TRUE;
             }
-        } else if (strcmp(key, "remaining capacity") == 0) {
+        } else if (SDL_strcmp(key, "remaining capacity") == 0) {
             char *endptr = NULL;
-            const int cvt = (int) strtol(val, &endptr, 10);
+            const int cvt = (int) SDL_strtol(val, &endptr, 10);
             if (*endptr == ' ') {
                 remaining = cvt;
             }
@@ -168,9 +171,9 @@ check_proc_acpi_battery(const char * node, SDL_bool * have_battery,
 
     ptr = &info[0];
     while (make_proc_acpi_key_val(&ptr, &key, &val)) {
-        if (strcmp(key, "design capacity") == 0) {
+        if (SDL_strcmp(key, "design capacity") == 0) {
             char *endptr = NULL;
-            const int cvt = (int) strtol(val, &endptr, 10);
+            const int cvt = (int) SDL_strtol(val, &endptr, 10);
             if (*endptr == ' ') {
                 maximum = cvt;
             }
@@ -225,8 +228,8 @@ check_proc_acpi_ac_adapter(const char * node, SDL_bool * have_ac)
 
     ptr = &state[0];
     while (make_proc_acpi_key_val(&ptr, &key, &val)) {
-        if (strcmp(key, "state") == 0) {
-            if (strcmp(val, "on-line") == 0) {
+        if (SDL_strcmp(key, "state") == 0) {
+            if (SDL_strcmp(val, "on-line") == 0) {
                 *have_ac = SDL_TRUE;
             }
         }
@@ -315,7 +318,7 @@ static SDL_bool
 int_string(char *str, int *val)
 {
     char *endptr = NULL;
-    *val = (int) strtol(str, &endptr, 0);
+    *val = (int) SDL_strtol(str, &endptr, 0);
     return ((*str != '\0') && (*endptr == '\0'));
 }
 
@@ -330,7 +333,7 @@ SDL_GetPowerInfo_Linux_proc_apm(SDL_PowerState * state,
     int battery_flag = 0;
     int battery_percent = 0;
     int battery_time = 0;
-    const int fd = open(proc_apm_path, O_RDONLY);
+    const int fd = open(proc_apm_path, O_RDONLY | O_CLOEXEC);
     char buf[128];
     char *ptr = &buf[0];
     char *str = NULL;
@@ -377,8 +380,8 @@ SDL_GetPowerInfo_Linux_proc_apm(SDL_PowerState * state,
     if (!next_string(&ptr, &str)) {     /* remaining battery life percent */
         return SDL_FALSE;
     }
-    if (str[strlen(str) - 1] == '%') {
-        str[strlen(str) - 1] = '\0';
+    if (str[SDL_strlen(str) - 1] == '%') {
+        str[SDL_strlen(str) - 1] = '\0';
     }
     if (!int_string(str, &battery_percent)) {
         return SDL_FALSE;
@@ -392,7 +395,7 @@ SDL_GetPowerInfo_Linux_proc_apm(SDL_PowerState * state,
 
     if (!next_string(&ptr, &str)) {     /* remaining battery life time units */
         return SDL_FALSE;
-    } else if (strcmp(str, "min") == 0) {
+    } else if (SDL_strcmp(str, "min") == 0) {
         battery_time *= 60;
     }
 
@@ -558,20 +561,30 @@ check_upower_device(DBusConnection *conn, const char *path, SDL_PowerState *stat
         return;
     } else if (!ui32) {
         return;  /* we don't care about random devices with batteries, like wireless controllers, etc */
-    } else if (!SDL_DBus_QueryPropertyOnConnection(conn, UPOWER_DBUS_NODE, path, UPOWER_DEVICE_DBUS_INTERFACE, "IsPresent", DBUS_TYPE_BOOLEAN, &ui32)) {
+    }
+
+    if (!SDL_DBus_QueryPropertyOnConnection(conn, UPOWER_DBUS_NODE, path, UPOWER_DEVICE_DBUS_INTERFACE, "IsPresent", DBUS_TYPE_BOOLEAN, &ui32)) {
         return;
-    } else if (!ui32) {
+    }
+    if (!ui32) {
         st = SDL_POWERSTATE_NO_BATTERY;
-    } else if (!SDL_DBus_QueryPropertyOnConnection(conn, UPOWER_DBUS_NODE, path, UPOWER_DEVICE_DBUS_INTERFACE, "State", DBUS_TYPE_UINT32, &ui32)) {
-        st = SDL_POWERSTATE_UNKNOWN;  /* uh oh */
-    } else if (ui32 == 1) {  /* 1 == charging */
-        st = SDL_POWERSTATE_CHARGING;
-    } else if ((ui32 == 2) || (ui32 == 3)) {  /* 2 == discharging, 3 == empty. */
-        st = SDL_POWERSTATE_ON_BATTERY;
-    } else if (ui32 == 4) {   /* 4 == full */
-        st = SDL_POWERSTATE_CHARGED;
     } else {
-        st = SDL_POWERSTATE_UNKNOWN;  /* uh oh */
+        /* Get updated information on the battery status
+         * This can occasionally fail, and we'll just return slightly stale data in that case
+         */
+        SDL_DBus_CallMethodOnConnection(conn, UPOWER_DBUS_NODE, path, UPOWER_DEVICE_DBUS_INTERFACE, "Refresh", DBUS_TYPE_INVALID, DBUS_TYPE_INVALID);
+
+        if (!SDL_DBus_QueryPropertyOnConnection(conn, UPOWER_DBUS_NODE, path, UPOWER_DEVICE_DBUS_INTERFACE, "State", DBUS_TYPE_UINT32, &ui32)) {
+            st = SDL_POWERSTATE_UNKNOWN;  /* uh oh */
+        } else if (ui32 == 1) {  /* 1 == charging */
+            st = SDL_POWERSTATE_CHARGING;
+        } else if ((ui32 == 2) || (ui32 == 3)) {  /* 2 == discharging, 3 == empty. */
+            st = SDL_POWERSTATE_ON_BATTERY;
+        } else if (ui32 == 4) {   /* 4 == full */
+            st = SDL_POWERSTATE_CHARGED;
+        } else {
+            st = SDL_POWERSTATE_UNKNOWN;  /* uh oh */
+        }
     }
 
     if (!SDL_DBus_QueryPropertyOnConnection(conn, UPOWER_DBUS_NODE, path, UPOWER_DEVICE_DBUS_INTERFACE, "Percentage", DBUS_TYPE_DOUBLE, &d)) {
diff --git a/Engine/lib/sdl/src/power/macosx/SDL_syspower.c b/Engine/lib/sdl/src/power/macosx/SDL_syspower.c
index 86c48ebf9..8277b3472 100644
--- a/Engine/lib/sdl/src/power/macosx/SDL_syspower.c
+++ b/Engine/lib/sdl/src/power/macosx/SDL_syspower.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/power/psp/SDL_syspower.c b/Engine/lib/sdl/src/power/psp/SDL_syspower.c
index 6a073edfd..ca9ba66b7 100644
--- a/Engine/lib/sdl/src/power/psp/SDL_syspower.c
+++ b/Engine/lib/sdl/src/power/psp/SDL_syspower.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/power/uikit/SDL_syspower.h b/Engine/lib/sdl/src/power/uikit/SDL_syspower.h
index 451f45229..a412780b0 100644
--- a/Engine/lib/sdl/src/power/uikit/SDL_syspower.h
+++ b/Engine/lib/sdl/src/power/uikit/SDL_syspower.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/power/uikit/SDL_syspower.m b/Engine/lib/sdl/src/power/uikit/SDL_syspower.m
index 969628c2a..2a5ec9c6a 100644
--- a/Engine/lib/sdl/src/power/uikit/SDL_syspower.m
+++ b/Engine/lib/sdl/src/power/uikit/SDL_syspower.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/power/vita/SDL_syspower.c b/Engine/lib/sdl/src/power/vita/SDL_syspower.c
new file mode 100644
index 000000000..46eef930e
--- /dev/null
+++ b/Engine/lib/sdl/src/power/vita/SDL_syspower.c
@@ -0,0 +1,68 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "../../SDL_internal.h"
+
+#ifndef SDL_POWER_DISABLED
+#if SDL_POWER_VITA
+
+#include "SDL_power.h"
+#include <psp2/power.h>
+
+
+SDL_bool
+SDL_GetPowerInfo_VITA(SDL_PowerState * state, int *seconds,
+                            int *percent)
+{
+    int battery = 1;
+    int plugged = scePowerIsPowerOnline();
+    int charging = scePowerIsBatteryCharging();
+
+    *state = SDL_POWERSTATE_UNKNOWN;
+    *seconds = -1;
+    *percent = -1;
+
+    if (!battery) {
+        *state = SDL_POWERSTATE_NO_BATTERY;
+        *seconds = -1;
+        *percent = -1;
+    } else if (charging) {
+        *state = SDL_POWERSTATE_CHARGING;
+        *percent = scePowerGetBatteryLifePercent();
+        *seconds = scePowerGetBatteryLifeTime()*60;
+    } else if (plugged) {
+        *state = SDL_POWERSTATE_CHARGED;
+        *percent = scePowerGetBatteryLifePercent();
+        *seconds = scePowerGetBatteryLifeTime()*60;
+    } else {
+        *state = SDL_POWERSTATE_ON_BATTERY;
+        *percent = scePowerGetBatteryLifePercent();
+        *seconds = scePowerGetBatteryLifeTime()*60;
+    }
+
+
+    return SDL_TRUE;            /* always the definitive answer on VITA. */
+}
+
+#endif /* SDL_POWER_VITA */
+#endif /* SDL_POWER_DISABLED */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/power/windows/SDL_syspower.c b/Engine/lib/sdl/src/power/windows/SDL_syspower.c
index 9108fe440..666b563a7 100644
--- a/Engine/lib/sdl/src/power/windows/SDL_syspower.c
+++ b/Engine/lib/sdl/src/power/windows/SDL_syspower.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/power/winrt/SDL_syspower.cpp b/Engine/lib/sdl/src/power/winrt/SDL_syspower.cpp
index 227fd2f11..62e7ea6d6 100644
--- a/Engine/lib/sdl/src/power/winrt/SDL_syspower.cpp
+++ b/Engine/lib/sdl/src/power/winrt/SDL_syspower.cpp
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/render/SDL_d3dmath.c b/Engine/lib/sdl/src/render/SDL_d3dmath.c
index 5acc10da9..63048bb88 100644
--- a/Engine/lib/sdl/src/render/SDL_d3dmath.c
+++ b/Engine/lib/sdl/src/render/SDL_d3dmath.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/render/SDL_d3dmath.h b/Engine/lib/sdl/src/render/SDL_d3dmath.h
index 5bd3dc67d..7b74cfe75 100644
--- a/Engine/lib/sdl/src/render/SDL_d3dmath.h
+++ b/Engine/lib/sdl/src/render/SDL_d3dmath.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/render/SDL_render.c b/Engine/lib/sdl/src/render/SDL_render.c
index e80cf6c01..441badbc6 100644
--- a/Engine/lib/sdl/src/render/SDL_render.c
+++ b/Engine/lib/sdl/src/render/SDL_render.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -32,19 +32,29 @@
 #  include "../core/android/SDL_android.h"
 #endif
 
+/* as a courtesy to iOS apps, we don't try to draw when in the background, as
+that will crash the app. However, these apps _should_ have used
+SDL_AddEventWatch to catch SDL_APP_WILLENTERBACKGROUND events and stopped
+drawing themselves. Other platforms still draw, as the compositor can use it,
+and more importantly: drawing to render targets isn't lost. But I still think
+this should probably be removed at some point in the future.  --ryan. */
+#if defined(__IPHONEOS__) || defined(__TVOS__) || defined(__ANDROID__)
+#define DONT_DRAW_WHILE_HIDDEN 1
+#else
+#define DONT_DRAW_WHILE_HIDDEN 0
+#endif
+
 #define SDL_WINDOWRENDERDATA    "_SDL_WindowRenderData"
 
 #define CHECK_RENDERER_MAGIC(renderer, retval) \
-    SDL_assert(renderer && renderer->magic == &renderer_magic); \
     if (!renderer || renderer->magic != &renderer_magic) { \
-        SDL_SetError("Invalid renderer"); \
+        SDL_InvalidParamError("renderer"); \
         return retval; \
     }
 
 #define CHECK_TEXTURE_MAGIC(texture, retval) \
-    SDL_assert(texture && texture->magic == &texture_magic); \
     if (!texture || texture->magic != &texture_magic) { \
-        SDL_SetError("Invalid texture"); \
+        SDL_InvalidParamError("texture"); \
         return retval; \
     }
 
@@ -104,6 +114,9 @@ static const SDL_RenderDriver *render_drivers[] = {
 #if SDL_VIDEO_RENDER_PSP
     &PSP_RenderDriver,
 #endif
+#if SDL_VIDEO_RENDER_VITA_GXM
+    &VITA_GXM_RenderDriver,
+#endif
 #if SDL_VIDEO_RENDER_SW
     &SW_RenderDriver
 #endif
@@ -198,6 +211,16 @@ DebugLogRenderCommands(const SDL_RenderCommand *cmd)
                         (int) cmd->data.draw.b, (int) cmd->data.draw.a,
                         (int) cmd->data.draw.blend, cmd->data.draw.texture);
                 break;
+
+            case SDL_RENDERCMD_GEOMETRY:
+                SDL_Log(" %u. geometry (first=%u, count=%u, r=%d, g=%d, b=%d, a=%d, blend=%d, tex=%p)", i++,
+                        (unsigned int) cmd->data.draw.first,
+                        (unsigned int) cmd->data.draw.count,
+                        (int) cmd->data.draw.r, (int) cmd->data.draw.g,
+                        (int) cmd->data.draw.b, (int) cmd->data.draw.a,
+                        (int) cmd->data.draw.blend, cmd->data.draw.texture);
+                break;
+
         }
         cmd = cmd->next;
     }
@@ -262,10 +285,10 @@ void *
 SDL_AllocateRenderVertices(SDL_Renderer *renderer, const size_t numbytes, const size_t alignment, size_t *offset)
 {
     const size_t needed = renderer->vertex_data_used + numbytes + alignment;
-    size_t current_offset = renderer->vertex_data_used;
+    const size_t current_offset = renderer->vertex_data_used;
 
-    size_t aligner = (alignment && ((current_offset & (alignment - 1)) != 0)) ? (alignment - (current_offset & (alignment - 1))) : 0;
-    size_t aligned = current_offset + aligner;
+    const size_t aligner = (alignment && ((current_offset & (alignment - 1)) != 0)) ? (alignment - (current_offset & (alignment - 1))) : 0;
+    const size_t aligned = current_offset + aligner;
 
     if (renderer->vertex_data_allocation < needed) {
         const size_t current_allocation = renderer->vertex_data ? renderer->vertex_data_allocation : 1024;
@@ -274,7 +297,9 @@ SDL_AllocateRenderVertices(SDL_Renderer *renderer, const size_t numbytes, const
         while (newsize < needed) {
             newsize *= 2;
         }
+
         ptr = SDL_realloc(renderer->vertex_data, newsize);
+
         if (ptr == NULL) {
             SDL_OutOfMemory();
             return NULL;
@@ -331,7 +356,11 @@ QueueCmdSetViewport(SDL_Renderer *renderer)
         if (cmd != NULL) {
             cmd->command = SDL_RENDERCMD_SETVIEWPORT;
             cmd->data.viewport.first = 0;  /* render backend will fill this in. */
-            SDL_memcpy(&cmd->data.viewport.rect, &renderer->viewport, sizeof (renderer->viewport));
+            /* Convert SDL_FRect to SDL_Rect */
+            cmd->data.viewport.rect.x = (int)SDL_floor(renderer->viewport.x);
+            cmd->data.viewport.rect.y = (int)SDL_floor(renderer->viewport.y);
+            cmd->data.viewport.rect.w = (int)SDL_floor(renderer->viewport.w);
+            cmd->data.viewport.rect.h = (int)SDL_floor(renderer->viewport.h);
             retval = renderer->QueueSetViewport(renderer, cmd);
             if (retval < 0) {
                 cmd->command = SDL_RENDERCMD_NO_OP;
@@ -357,7 +386,11 @@ QueueCmdSetClipRect(SDL_Renderer *renderer)
         } else {
             cmd->command = SDL_RENDERCMD_SETCLIPRECT;
             cmd->data.cliprect.enabled = renderer->clipping_enabled;
-            SDL_memcpy(&cmd->data.cliprect.rect, &renderer->clip_rect, sizeof (cmd->data.cliprect.rect));
+            /* Convert SDL_FRect to SDL_Rect */
+            cmd->data.cliprect.rect.x = (int)SDL_floor(renderer->clip_rect.x);
+            cmd->data.cliprect.rect.y = (int)SDL_floor(renderer->clip_rect.y);
+            cmd->data.cliprect.rect.w = (int)SDL_floor(renderer->clip_rect.w);
+            cmd->data.cliprect.rect.h = (int)SDL_floor(renderer->clip_rect.h);
             SDL_memcpy(&renderer->last_queued_cliprect, &renderer->clip_rect, sizeof (SDL_Rect));
             renderer->last_queued_cliprect_enabled = renderer->clipping_enabled;
             renderer->cliprect_queued = SDL_TRUE;
@@ -367,11 +400,11 @@ QueueCmdSetClipRect(SDL_Renderer *renderer)
 }
 
 static int
-QueueCmdSetDrawColor(SDL_Renderer *renderer, const Uint8 r, const Uint8 g, const Uint8 b, const Uint8 a)
+QueueCmdSetDrawColor(SDL_Renderer *renderer, SDL_Color *col)
 {
-    const Uint32 color = ((a << 24) | (r << 16) | (g << 8) | b);
+    const Uint32 color = (((Uint32)col->a << 24) | (col->r << 16) | (col->g << 8) | col->b);
     int retval = 0;
-    
+
     if (!renderer->color_queued || (color != renderer->last_queued_color)) {
         SDL_RenderCommand *cmd = AllocateRenderCommand(renderer);
         retval = -1;
@@ -379,10 +412,10 @@ QueueCmdSetDrawColor(SDL_Renderer *renderer, const Uint8 r, const Uint8 g, const
         if (cmd != NULL) {
             cmd->command = SDL_RENDERCMD_SETDRAWCOLOR;
             cmd->data.color.first = 0;  /* render backend will fill this in. */
-            cmd->data.color.r = r;
-            cmd->data.color.g = g;
-            cmd->data.color.b = b;
-            cmd->data.color.a = a;
+            cmd->data.color.r = col->r;
+            cmd->data.color.g = col->g;
+            cmd->data.color.b = col->b;
+            cmd->data.color.a = col->a;
             retval = renderer->QueueSetDrawColor(renderer, cmd);
             if (retval < 0) {
                 cmd->command = SDL_RENDERCMD_NO_OP;
@@ -405,17 +438,33 @@ QueueCmdClear(SDL_Renderer *renderer)
 
     cmd->command = SDL_RENDERCMD_CLEAR;
     cmd->data.color.first = 0;
-    cmd->data.color.r = renderer->r;
-    cmd->data.color.g = renderer->g;
-    cmd->data.color.b = renderer->b;
-    cmd->data.color.a = renderer->a;
+    cmd->data.color.r = renderer->color.r;
+    cmd->data.color.g = renderer->color.g;
+    cmd->data.color.b = renderer->color.b;
+    cmd->data.color.a = renderer->color.a;
     return 0;
 }
 
-static int
-PrepQueueCmdDraw(SDL_Renderer *renderer, const Uint8 r, const Uint8 g, const Uint8 b, const Uint8 a)
+static SDL_RenderCommand *
+PrepQueueCmdDraw(SDL_Renderer *renderer, const SDL_RenderCommandType cmdtype, SDL_Texture *texture)
 {
-    int retval = QueueCmdSetDrawColor(renderer, r, g, b, a);
+    SDL_RenderCommand *cmd = NULL;
+    int retval = 0;
+    SDL_Color *color;
+    SDL_BlendMode blendMode;
+
+    if (texture) {
+        color = &texture->color;
+        blendMode = texture->blendMode;
+    } else {
+        color = &renderer->color;
+        blendMode = renderer->blendMode;
+    }
+
+    if (cmdtype != SDL_RENDERCMD_GEOMETRY) {
+        /* !!! FIXME: drop this draw if viewport w or h is zero. */
+        retval = QueueCmdSetDrawColor(renderer, color);
+    }
 
     /* Set the viewport and clip rect directly before draws, so the backends
      * don't have to worry about that state not being valid at draw time. */
@@ -425,26 +474,19 @@ PrepQueueCmdDraw(SDL_Renderer *renderer, const Uint8 r, const Uint8 g, const Uin
     if (retval == 0 && !renderer->cliprect_queued) {
         retval = QueueCmdSetClipRect(renderer);
     }
-    return retval;
-}
 
-static SDL_RenderCommand *
-PrepQueueCmdDrawSolid(SDL_Renderer *renderer, const SDL_RenderCommandType cmdtype)
-{
-    /* !!! FIXME: drop this draw if viewport w or h is zero. */
-    SDL_RenderCommand *cmd = NULL;
-    if (PrepQueueCmdDraw(renderer, renderer->r, renderer->g, renderer->b, renderer->a) == 0) {
+    if (retval == 0) {
         cmd = AllocateRenderCommand(renderer);
         if (cmd != NULL) {
             cmd->command = cmdtype;
             cmd->data.draw.first = 0;  /* render backend will fill this in. */
             cmd->data.draw.count = 0;  /* render backend will fill this in. */
-            cmd->data.draw.r = renderer->r;
-            cmd->data.draw.g = renderer->g;
-            cmd->data.draw.b = renderer->b;
-            cmd->data.draw.a = renderer->a;
-            cmd->data.draw.blend = renderer->blendMode;
-            cmd->data.draw.texture = NULL;  /* no texture. */
+            cmd->data.draw.r = color->r;
+            cmd->data.draw.g = color->g;
+            cmd->data.draw.b = color->b;
+            cmd->data.draw.a = color->a;
+            cmd->data.draw.blend = blendMode;
+            cmd->data.draw.texture = texture;
         }
     }
     return cmd;
@@ -453,7 +495,7 @@ PrepQueueCmdDrawSolid(SDL_Renderer *renderer, const SDL_RenderCommandType cmdtyp
 static int
 QueueCmdDrawPoints(SDL_Renderer *renderer, const SDL_FPoint * points, const int count)
 {
-    SDL_RenderCommand *cmd = PrepQueueCmdDrawSolid(renderer, SDL_RENDERCMD_DRAW_POINTS);
+    SDL_RenderCommand *cmd = PrepQueueCmdDraw(renderer, SDL_RENDERCMD_DRAW_POINTS, NULL);
     int retval = -1;
     if (cmd != NULL) {
         retval = renderer->QueueDrawPoints(renderer, cmd, points, count);
@@ -467,7 +509,7 @@ QueueCmdDrawPoints(SDL_Renderer *renderer, const SDL_FPoint * points, const int
 static int
 QueueCmdDrawLines(SDL_Renderer *renderer, const SDL_FPoint * points, const int count)
 {
-    SDL_RenderCommand *cmd = PrepQueueCmdDrawSolid(renderer, SDL_RENDERCMD_DRAW_LINES);
+    SDL_RenderCommand *cmd = PrepQueueCmdDraw(renderer, SDL_RENDERCMD_DRAW_LINES, NULL);
     int retval = -1;
     if (cmd != NULL) {
         retval = renderer->QueueDrawLines(renderer, cmd, points, count);
@@ -481,43 +523,81 @@ QueueCmdDrawLines(SDL_Renderer *renderer, const SDL_FPoint * points, const int c
 static int
 QueueCmdFillRects(SDL_Renderer *renderer, const SDL_FRect * rects, const int count)
 {
-    SDL_RenderCommand *cmd = PrepQueueCmdDrawSolid(renderer, SDL_RENDERCMD_FILL_RECTS);
+    SDL_RenderCommand *cmd;
     int retval = -1;
+    const int use_rendergeometry = (renderer->QueueFillRects == NULL);
+
+    cmd = PrepQueueCmdDraw(renderer, (use_rendergeometry ? SDL_RENDERCMD_GEOMETRY : SDL_RENDERCMD_FILL_RECTS), NULL);
+
     if (cmd != NULL) {
-        retval = renderer->QueueFillRects(renderer, cmd, rects, count);
-        if (retval < 0) {
-            cmd->command = SDL_RENDERCMD_NO_OP;
+        if (use_rendergeometry) {
+            SDL_bool isstack1;
+            SDL_bool isstack2;
+            float *xy = SDL_small_alloc(float, 4 * 2 * count, &isstack1);
+            int *indices = SDL_small_alloc(int, 6 * count, &isstack2);
+
+            if (xy && indices) {
+                int i;
+                float *ptr_xy = xy;
+                int *ptr_indices = indices;
+                const int xy_stride = 2 * sizeof (float);
+                const int num_vertices = 4 * count;
+                const int num_indices = 6 * count;
+                const int size_indices = 4;
+                int cur_indice = 0;
+
+                for (i = 0; i < count; ++i) {
+                    float minx, miny, maxx, maxy;
+
+                    minx = rects[i].x;
+                    miny = rects[i].y;
+                    maxx = rects[i].x + rects[i].w;
+                    maxy = rects[i].y + rects[i].h;
+
+                    *ptr_xy++ = minx;
+                    *ptr_xy++ = miny;
+                    *ptr_xy++ = maxx;
+                    *ptr_xy++ = miny;
+                    *ptr_xy++ = maxx;
+                    *ptr_xy++ = maxy;
+                    *ptr_xy++ = minx;
+                    *ptr_xy++ = maxy;
+
+                    *ptr_indices++ = cur_indice + 0;
+                    *ptr_indices++ = cur_indice + 1;
+                    *ptr_indices++ = cur_indice + 2;
+                    *ptr_indices++ = cur_indice + 0;
+                    *ptr_indices++ = cur_indice + 2;
+                    *ptr_indices++ = cur_indice + 3;
+                    cur_indice += 4;
+                }
+
+                retval = renderer->QueueGeometry(renderer, cmd, NULL,
+                        xy, xy_stride, &renderer->color, 0 /* color_stride */, NULL, 0,
+                        num_vertices, indices, num_indices, size_indices,
+                        1.0f, 1.0f);
+
+                if (retval < 0) {
+                    cmd->command = SDL_RENDERCMD_NO_OP;
+                }
+
+                SDL_small_free(xy, isstack1);
+                SDL_small_free(indices, isstack2);
+            }
+        } else {
+            retval = renderer->QueueFillRects(renderer, cmd, rects, count);
+            if (retval < 0) {
+                cmd->command = SDL_RENDERCMD_NO_OP;
+            }
         }
     }
     return retval;
 }
 
-static SDL_RenderCommand *
-PrepQueueCmdDrawTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_RenderCommandType cmdtype)
-{
-    /* !!! FIXME: drop this draw if viewport w or h is zero. */
-    SDL_RenderCommand *cmd = NULL;
-    if (PrepQueueCmdDraw(renderer, texture->r, texture->g, texture->b, texture->a) == 0) {
-        cmd = AllocateRenderCommand(renderer);
-        if (cmd != NULL) {
-            cmd->command = cmdtype;
-            cmd->data.draw.first = 0;  /* render backend will fill this in. */
-            cmd->data.draw.count = 0;  /* render backend will fill this in. */
-            cmd->data.draw.r = texture->r;
-            cmd->data.draw.g = texture->g;
-            cmd->data.draw.b = texture->b;
-            cmd->data.draw.a = texture->a;
-            cmd->data.draw.blend = texture->blendMode;
-            cmd->data.draw.texture = texture;
-        }
-    }
-    return cmd;
-}
-
 static int
 QueueCmdCopy(SDL_Renderer *renderer, SDL_Texture * texture, const SDL_Rect * srcrect, const SDL_FRect * dstrect)
 {
-    SDL_RenderCommand *cmd = PrepQueueCmdDrawTexture(renderer, texture, SDL_RENDERCMD_COPY);
+    SDL_RenderCommand *cmd = PrepQueueCmdDraw(renderer, SDL_RENDERCMD_COPY, texture);
     int retval = -1;
     if (cmd != NULL) {
         retval = renderer->QueueCopy(renderer, cmd, texture, srcrect, dstrect);
@@ -531,13 +611,12 @@ QueueCmdCopy(SDL_Renderer *renderer, SDL_Texture * texture, const SDL_Rect * src
 static int
 QueueCmdCopyEx(SDL_Renderer *renderer, SDL_Texture * texture,
                const SDL_Rect * srcquad, const SDL_FRect * dstrect,
-               const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip)
+               const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip, float scale_x, float scale_y)
 {
-    SDL_RenderCommand *cmd = PrepQueueCmdDrawTexture(renderer, texture, SDL_RENDERCMD_COPY_EX);
+    SDL_RenderCommand *cmd = PrepQueueCmdDraw(renderer, SDL_RENDERCMD_COPY_EX, texture);
     int retval = -1;
-    SDL_assert(renderer->QueueCopyEx != NULL);  /* should have caught at higher level. */
     if (cmd != NULL) {
-        retval = renderer->QueueCopyEx(renderer, cmd, texture, srcquad, dstrect, angle, center, flip);
+        retval = renderer->QueueCopyEx(renderer, cmd, texture, srcquad, dstrect, angle, center, flip, scale_x, scale_y);
         if (retval < 0) {
             cmd->command = SDL_RENDERCMD_NO_OP;
         }
@@ -545,6 +624,30 @@ QueueCmdCopyEx(SDL_Renderer *renderer, SDL_Texture * texture,
     return retval;
 }
 
+static int
+QueueCmdGeometry(SDL_Renderer *renderer, SDL_Texture *texture,
+        const float *xy, int xy_stride,
+        const SDL_Color *color, int color_stride,
+        const float *uv, int uv_stride,
+        int num_vertices,
+        const void *indices, int num_indices, int size_indices,
+        float scale_x, float scale_y)
+{
+    SDL_RenderCommand *cmd;
+    int retval = -1;
+    cmd = PrepQueueCmdDraw(renderer, SDL_RENDERCMD_GEOMETRY, texture);
+    if (cmd != NULL) {
+        retval = renderer->QueueGeometry(renderer, cmd, texture,
+                xy, xy_stride,
+                color, color_stride, uv, uv_stride,
+                num_vertices, indices, num_indices, size_indices,
+                scale_x, scale_y);
+        if (retval < 0) {
+            cmd->command = SDL_RENDERCMD_NO_OP;
+        }
+    }
+    return retval;
+}
 
 static int UpdateLogicalSize(SDL_Renderer *renderer);
 
@@ -573,7 +676,7 @@ SDL_GetRenderDriverInfo(int index, SDL_RendererInfo * info)
 #endif
 }
 
-static void GetWindowViewportValues(SDL_Renderer *renderer, int *logical_w, int *logical_h, SDL_Rect *viewport, SDL_FPoint *scale)
+static void GetWindowViewportValues(SDL_Renderer *renderer, int *logical_w, int *logical_h, SDL_FRect *viewport, SDL_FPoint *scale)
 {
     SDL_LockMutex(renderer->target_mutex);
     *logical_w = renderer->target ? renderer->logical_w_backup : renderer->logical_w;
@@ -602,6 +705,17 @@ SDL_RendererEventWatch(void *userdata, SDL_Event *event)
                     SDL_SetRenderTarget(renderer, NULL);
                 }
 
+                /* Update the DPI scale if the window has been resized. */
+                if (window && renderer->GetOutputSize) {
+                    int window_w, window_h;
+                    int output_w, output_h;
+                    if (renderer->GetOutputSize(renderer, &output_w, &output_h) == 0) {
+                        SDL_GetWindowSize(renderer->window, &window_w, &window_h);
+                        renderer->dpi_scale.x = (float)window_w / output_w;
+                        renderer->dpi_scale.y = (float)window_h / output_h;
+                    }
+                }
+
                 if (renderer->logical_w) {
                     UpdateLogicalSize(renderer);
                 } else {
@@ -614,19 +728,12 @@ SDL_RendererEventWatch(void *userdata, SDL_Event *event)
                         SDL_GetWindowSize(renderer->window, &w, &h);
                     }
 
-                    if (renderer->target) {
-                        renderer->viewport_backup.x = 0;
-                        renderer->viewport_backup.y = 0;
-                        renderer->viewport_backup.w = w;
-                        renderer->viewport_backup.h = h;
-                    } else {
-                        renderer->viewport.x = 0;
-                        renderer->viewport.y = 0;
-                        renderer->viewport.w = w;
-                        renderer->viewport.h = h;
-                        QueueCmdSetViewport(renderer);
-                        FlushRenderCommandsIfNotBatching(renderer);
-                    }
+                    renderer->viewport.x = 0;
+                    renderer->viewport.y = 0;
+                    renderer->viewport.w = (float) w;
+                    renderer->viewport.h = (float) h;
+                    QueueCmdSetViewport(renderer);
+                    FlushRenderCommandsIfNotBatching(renderer);
                 }
 
                 if (saved_target) {
@@ -640,7 +747,7 @@ SDL_RendererEventWatch(void *userdata, SDL_Event *event)
                 }
             } else if (event->window.event == SDL_WINDOWEVENT_MINIMIZED) {
                 renderer->hidden = SDL_TRUE;
-            } else if (event->window.event == SDL_WINDOWEVENT_RESTORED || 
+            } else if (event->window.event == SDL_WINDOWEVENT_RESTORED ||
                        event->window.event == SDL_WINDOWEVENT_MAXIMIZED) {
                 if (!(SDL_GetWindowFlags(window) & SDL_WINDOW_HIDDEN)) {
                     renderer->hidden = SDL_FALSE;
@@ -651,7 +758,7 @@ SDL_RendererEventWatch(void *userdata, SDL_Event *event)
         SDL_Window *window = SDL_GetWindowFromID(event->motion.windowID);
         if (window == renderer->window) {
             int logical_w, logical_h;
-            SDL_Rect viewport;
+            SDL_FRect viewport;
             SDL_FPoint scale;
             GetWindowViewportValues(renderer, &logical_w, &logical_h, &viewport, &scale);
             if (logical_w) {
@@ -661,15 +768,15 @@ SDL_RendererEventWatch(void *userdata, SDL_Event *event)
                 event->motion.y = (int)(event->motion.y / (scale.y * renderer->dpi_scale.y));
                 if (event->motion.xrel != 0 && renderer->relative_scaling) {
                     float rel = renderer->xrel + event->motion.xrel / (scale.x * renderer->dpi_scale.x);
-                    float trunc = SDL_truncf(rel);
-                    renderer->xrel = rel - trunc;
-                    event->motion.xrel = (Sint32) trunc;
+                    float truncated = SDL_truncf(rel);
+                    renderer->xrel = rel - truncated;
+                    event->motion.xrel = (Sint32) truncated;
                 }
                 if (event->motion.yrel != 0 && renderer->relative_scaling) {
                     float rel = renderer->yrel + event->motion.yrel / (scale.y * renderer->dpi_scale.y);
-                    float trunc = SDL_truncf(rel);
-                    renderer->yrel = rel - trunc;
-                    event->motion.yrel = (Sint32) trunc;
+                    float truncated = SDL_truncf(rel);
+                    renderer->yrel = rel - truncated;
+                    event->motion.yrel = (Sint32) truncated;
                 }
             }
         }
@@ -678,7 +785,7 @@ SDL_RendererEventWatch(void *userdata, SDL_Event *event)
         SDL_Window *window = SDL_GetWindowFromID(event->button.windowID);
         if (window == renderer->window) {
             int logical_w, logical_h;
-            SDL_Rect viewport;
+            SDL_FRect viewport;
             SDL_FPoint scale;
             GetWindowViewportValues(renderer, &logical_w, &logical_h, &viewport, &scale);
             if (logical_w) {
@@ -687,13 +794,13 @@ SDL_RendererEventWatch(void *userdata, SDL_Event *event)
                 event->button.x = (int)(event->button.x / (scale.x * renderer->dpi_scale.x));
                 event->button.y = (int)(event->button.y / (scale.y * renderer->dpi_scale.y));
             }
-        }                               
+        }
     } else if (event->type == SDL_FINGERDOWN ||
                event->type == SDL_FINGERUP ||
                event->type == SDL_FINGERMOTION) {
         int logical_w, logical_h;
         float physical_w, physical_h;
-        SDL_Rect viewport;
+        SDL_FRect viewport;
         SDL_FPoint scale;
         GetWindowViewportValues(renderer, &logical_w, &logical_h, &viewport, &scale);
 
@@ -776,12 +883,32 @@ void VerifyDrawQueueFunctions(const SDL_Renderer *renderer)
     SDL_assert(renderer->QueueSetViewport != NULL);
     SDL_assert(renderer->QueueSetDrawColor != NULL);
     SDL_assert(renderer->QueueDrawPoints != NULL);
-    SDL_assert(renderer->QueueDrawLines != NULL);
-    SDL_assert(renderer->QueueFillRects != NULL);
-    SDL_assert(renderer->QueueCopy != NULL);
+    SDL_assert(renderer->QueueDrawLines != NULL || renderer->QueueGeometry != NULL);
+    SDL_assert(renderer->QueueFillRects != NULL || renderer->QueueGeometry != NULL);
+    SDL_assert(renderer->QueueCopy != NULL || renderer->QueueGeometry != NULL);
     SDL_assert(renderer->RunCommandQueue != NULL);
 }
 
+static SDL_RenderLineMethod SDL_GetRenderLineMethod()
+{
+    const char *hint = SDL_GetHint(SDL_HINT_RENDER_LINE_METHOD);
+
+    int method = 0;
+    if (hint) {
+        method = SDL_atoi(hint);
+    }
+    switch (method) {
+    case 1:
+        return SDL_RENDERLINEMETHOD_POINTS;
+    case 2:
+        return SDL_RENDERLINEMETHOD_LINES;
+    case 3:
+        return SDL_RENDERLINEMETHOD_GEOMETRY;
+    default:
+        return SDL_RENDERLINEMETHOD_POINTS;
+    }
+}
+
 SDL_Renderer *
 SDL_CreateRenderer(SDL_Window * window, int index, Uint32 flags)
 {
@@ -796,7 +923,7 @@ SDL_CreateRenderer(SDL_Window * window, int index, Uint32 flags)
 #endif
 
     if (!window) {
-        SDL_SetError("Invalid window");
+        SDL_InvalidParamError("window");
         goto error;
     }
 
@@ -805,7 +932,8 @@ SDL_CreateRenderer(SDL_Window * window, int index, Uint32 flags)
         goto error;
     }
 
-    if (SDL_GetHint(SDL_HINT_RENDER_VSYNC)) {
+    hint = SDL_GetHint(SDL_HINT_RENDER_VSYNC);
+    if (hint && *hint) {
         if (SDL_GetHintBoolean(SDL_HINT_RENDER_VSYNC, SDL_TRUE)) {
             flags |= SDL_RENDERER_PRESENTVSYNC;
         } else {
@@ -844,24 +972,24 @@ SDL_CreateRenderer(SDL_Window * window, int index, Uint32 flags)
                 }
             }
         }
-        if (index == n) {
+        if (!renderer) {
             SDL_SetError("Couldn't find matching render driver");
             goto error;
         }
     } else {
-        if (index >= SDL_GetNumRenderDrivers()) {
+        if (index >= n) {
             SDL_SetError("index must be -1 or in the range of 0 - %d",
-                         SDL_GetNumRenderDrivers() - 1);
+                         n - 1);
             goto error;
         }
         /* Create a new renderer instance */
         renderer = render_drivers[index]->CreateRenderer(window, flags);
         batching = SDL_FALSE;
+        if (!renderer) {
+            goto error;
+        }
     }
 
-    if (!renderer) {
-        goto error;
-    }
 
     VerifyDrawQueueFunctions(renderer);
 
@@ -896,6 +1024,8 @@ SDL_CreateRenderer(SDL_Window * window, int index, Uint32 flags)
 
     renderer->relative_scaling = SDL_GetHintBoolean(SDL_HINT_MOUSE_RELATIVE_SCALING, SDL_TRUE);
 
+    renderer->line_method = SDL_GetRenderLineMethod();
+
     if (SDL_GetWindowFlags(window) & (SDL_WINDOW_HIDDEN|SDL_WINDOW_MINIMIZED)) {
         renderer->hidden = SDL_TRUE;
     } else {
@@ -947,6 +1077,9 @@ SDL_CreateSoftwareRenderer(SDL_Surface * surface)
         /* new textures start at zero, so we start at 1 so first render doesn't flush by accident. */
         renderer->render_command_generation = 1;
 
+        /* Software renderer always uses line method, for speed */
+        renderer->line_method = SDL_RENDERLINEMETHOD_LINES;
+
         SDL_RenderSetViewport(renderer, NULL);
     }
     return renderer;
@@ -1066,6 +1199,7 @@ SDL_Texture *
 SDL_CreateTexture(SDL_Renderer * renderer, Uint32 format, int access, int w, int h)
 {
     SDL_Texture *texture;
+    SDL_bool texture_is_fourcc_and_target;
 
     CHECK_RENDERER_MAGIC(renderer, NULL);
 
@@ -1077,8 +1211,10 @@ SDL_CreateTexture(SDL_Renderer * renderer, Uint32 format, int access, int w, int
         return NULL;
     }
     if (SDL_ISPIXELFORMAT_INDEXED(format)) {
-        SDL_SetError("Palettized textures are not supported");
-        return NULL;
+        if (!IsSupportedFormat(renderer, format)) {
+            SDL_SetError("Palettized textures are not supported");
+            return NULL;
+        }
     }
     if (w <= 0 || h <= 0) {
         SDL_SetError("Texture dimensions can't be 0");
@@ -1099,10 +1235,10 @@ SDL_CreateTexture(SDL_Renderer * renderer, Uint32 format, int access, int w, int
     texture->access = access;
     texture->w = w;
     texture->h = h;
-    texture->r = 255;
-    texture->g = 255;
-    texture->b = 255;
-    texture->a = 255;
+    texture->color.r = 255;
+    texture->color.g = 255;
+    texture->color.b = 255;
+    texture->color.a = 255;
     texture->scaleMode = SDL_GetScaleMode();
     texture->renderer = renderer;
     texture->next = renderer->textures;
@@ -1111,15 +1247,24 @@ SDL_CreateTexture(SDL_Renderer * renderer, Uint32 format, int access, int w, int
     }
     renderer->textures = texture;
 
-    if (IsSupportedFormat(renderer, format)) {
+    /* FOURCC format cannot be used directly by renderer back-ends for target texture */
+    texture_is_fourcc_and_target = (access == SDL_TEXTUREACCESS_TARGET && SDL_ISPIXELFORMAT_FOURCC(texture->format));
+
+    if (texture_is_fourcc_and_target == SDL_FALSE && IsSupportedFormat(renderer, format)) {
         if (renderer->CreateTexture(renderer, texture) < 0) {
             SDL_DestroyTexture(texture);
             return NULL;
         }
     } else {
-        texture->native = SDL_CreateTexture(renderer,
-                                GetClosestSupportedFormat(renderer, format),
-                                access, w, h);
+        int closest_format;
+
+        if (texture_is_fourcc_and_target == SDL_FALSE) {
+            closest_format = GetClosestSupportedFormat(renderer, format);
+        } else {
+            closest_format = renderer->info.texture_formats[0];
+        }
+
+        texture->native = SDL_CreateTexture(renderer, closest_format, access, w, h);
         if (!texture->native) {
             SDL_DestroyTexture(texture);
             return NULL;
@@ -1174,7 +1319,7 @@ SDL_CreateTextureFromSurface(SDL_Renderer * renderer, SDL_Surface * surface)
     CHECK_RENDERER_MAGIC(renderer, NULL);
 
     if (!surface) {
-        SDL_SetError("SDL_CreateTextureFromSurface() passed NULL surface");
+        SDL_InvalidParamError("SDL_CreateTextureFromSurface(): surface");
         return NULL;
     }
 
@@ -1263,6 +1408,18 @@ SDL_CreateTextureFromSurface(SDL_Renderer * renderer, SDL_Surface * surface)
         } else {
             SDL_UpdateTexture(texture, NULL, surface->pixels, surface->pitch);
         }
+
+#if SDL_VIDEO_RENDER_DIRECTFB
+        /* DirectFB allows palette format for textures.
+         * Copy SDL_Surface palette to the texture */
+        if (SDL_ISPIXELFORMAT_INDEXED(format)) {
+            if (SDL_strcasecmp(renderer->info.name, "directfb") == 0) {
+                extern void DirectFB_SetTexturePalette(SDL_Renderer *renderer, SDL_Texture *texture, SDL_Palette *pal);
+                DirectFB_SetTexturePalette(renderer, texture, surface->format->palette);
+            }
+        }
+#endif
+
     } else {
         SDL_PixelFormat *dst_fmt;
         SDL_Surface *temp = NULL;
@@ -1336,9 +1493,9 @@ SDL_SetTextureColorMod(SDL_Texture * texture, Uint8 r, Uint8 g, Uint8 b)
     } else {
         texture->modMode &= ~SDL_TEXTUREMODULATE_COLOR;
     }
-    texture->r = r;
-    texture->g = g;
-    texture->b = b;
+    texture->color.r = r;
+    texture->color.g = g;
+    texture->color.b = b;
     if (texture->native) {
         return SDL_SetTextureColorMod(texture->native, r, g, b);
     }
@@ -1352,13 +1509,13 @@ SDL_GetTextureColorMod(SDL_Texture * texture, Uint8 * r, Uint8 * g,
     CHECK_TEXTURE_MAGIC(texture, -1);
 
     if (r) {
-        *r = texture->r;
+        *r = texture->color.r;
     }
     if (g) {
-        *g = texture->g;
+        *g = texture->color.g;
     }
     if (b) {
-        *b = texture->b;
+        *b = texture->color.b;
     }
     return 0;
 }
@@ -1373,7 +1530,7 @@ SDL_SetTextureAlphaMod(SDL_Texture * texture, Uint8 alpha)
     } else {
         texture->modMode &= ~SDL_TEXTUREMODULATE_ALPHA;
     }
-    texture->a = alpha;
+    texture->color.a = alpha;
     if (texture->native) {
         return SDL_SetTextureAlphaMod(texture->native, alpha);
     }
@@ -1386,7 +1543,7 @@ SDL_GetTextureAlphaMod(SDL_Texture * texture, Uint8 * alpha)
     CHECK_TEXTURE_MAGIC(texture, -1);
 
     if (alpha) {
-        *alpha = texture->a;
+        *alpha = texture->color.a;
     }
     return 0;
 }
@@ -1447,6 +1604,23 @@ SDL_GetTextureScaleMode(SDL_Texture * texture, SDL_ScaleMode *scaleMode)
     return 0;
 }
 
+int
+SDL_SetTextureUserData(SDL_Texture * texture, void *userdata)
+{
+    CHECK_TEXTURE_MAGIC(texture, -1);
+
+    texture->userdata = userdata;
+    return 0;
+}
+
+void *
+SDL_GetTextureUserData(SDL_Texture * texture)
+{
+    CHECK_TEXTURE_MAGIC(texture, NULL);
+
+    return texture->userdata;
+}
+
 #if SDL_HAVE_YUV
 static int
 SDL_UpdateTextureYUV(SDL_Texture * texture, const SDL_Rect * rect,
@@ -1540,7 +1714,7 @@ int
 SDL_UpdateTexture(SDL_Texture * texture, const SDL_Rect * rect,
                   const void *pixels, int pitch)
 {
-    SDL_Rect full_rect;
+    SDL_Rect real_rect;
 
     CHECK_TEXTURE_MAGIC(texture, -1);
 
@@ -1551,28 +1725,30 @@ SDL_UpdateTexture(SDL_Texture * texture, const SDL_Rect * rect,
         return SDL_InvalidParamError("pitch");
     }
 
-    if (!rect) {
-        full_rect.x = 0;
-        full_rect.y = 0;
-        full_rect.w = texture->w;
-        full_rect.h = texture->h;
-        rect = &full_rect;
+    real_rect.x = 0;
+    real_rect.y = 0;
+    real_rect.w = texture->w;
+    real_rect.h = texture->h;
+    if (rect) {
+        if (!SDL_IntersectRect(rect, &real_rect, &real_rect)) {
+            return 0;
+        }
     }
 
-    if ((rect->w == 0) || (rect->h == 0)) {
+    if (real_rect.w == 0 || real_rect.h == 0) {
         return 0;  /* nothing to do. */
 #if SDL_HAVE_YUV
     } else if (texture->yuv) {
-        return SDL_UpdateTextureYUV(texture, rect, pixels, pitch);
+        return SDL_UpdateTextureYUV(texture, &real_rect, pixels, pitch);
 #endif
     } else if (texture->native) {
-        return SDL_UpdateTextureNative(texture, rect, pixels, pitch);
+        return SDL_UpdateTextureNative(texture, &real_rect, pixels, pitch);
     } else {
         SDL_Renderer *renderer = texture->renderer;
         if (FlushRenderCommandsIfTextureNeeded(texture) < 0) {
             return -1;
         }
-        return renderer->UpdateTexture(renderer, texture, rect, pixels, pitch);
+        return renderer->UpdateTexture(renderer, texture, &real_rect, pixels, pitch);
     }
 }
 
@@ -1628,6 +1804,59 @@ SDL_UpdateTextureYUVPlanar(SDL_Texture * texture, const SDL_Rect * rect,
     }
     return 0;
 }
+
+static int
+SDL_UpdateTextureNVPlanar(SDL_Texture * texture, const SDL_Rect * rect,
+                           const Uint8 *Yplane, int Ypitch,
+                           const Uint8 *UVplane, int UVpitch)
+{
+    SDL_Texture *native = texture->native;
+    SDL_Rect full_rect;
+
+    if (SDL_SW_UpdateNVTexturePlanar(texture->yuv, rect, Yplane, Ypitch, UVplane, UVpitch) < 0) {
+        return -1;
+    }
+
+    full_rect.x = 0;
+    full_rect.y = 0;
+    full_rect.w = texture->w;
+    full_rect.h = texture->h;
+    rect = &full_rect;
+
+    if (!rect->w || !rect->h) {
+        return 0;  /* nothing to do. */
+    }
+
+    if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
+        /* We can lock the texture and copy to it */
+        void *native_pixels = NULL;
+        int native_pitch = 0;
+
+        if (SDL_LockTexture(native, rect, &native_pixels, &native_pitch) < 0) {
+            return -1;
+        }
+        SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
+                            rect->w, rect->h, native_pixels, native_pitch);
+        SDL_UnlockTexture(native);
+    } else {
+        /* Use a temporary buffer for updating */
+        const int temp_pitch = (((rect->w * SDL_BYTESPERPIXEL(native->format)) + 3) & ~3);
+        const size_t alloclen = rect->h * temp_pitch;
+        if (alloclen > 0) {
+            void *temp_pixels = SDL_malloc(alloclen);
+            if (!temp_pixels) {
+                return SDL_OutOfMemory();
+            }
+            SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
+                                rect->w, rect->h, temp_pixels, temp_pitch);
+            SDL_UpdateTexture(native, rect, temp_pixels, temp_pitch);
+            SDL_free(temp_pixels);
+        }
+    }
+    return 0;
+}
+
+
 #endif /* SDL_HAVE_YUV */
 
 int SDL_UpdateYUVTexture(SDL_Texture * texture, const SDL_Rect * rect,
@@ -1637,7 +1866,7 @@ int SDL_UpdateYUVTexture(SDL_Texture * texture, const SDL_Rect * rect,
 {
 #if SDL_HAVE_YUV
     SDL_Renderer *renderer;
-    SDL_Rect full_rect;
+    SDL_Rect real_rect;
 
     CHECK_TEXTURE_MAGIC(texture, -1);
 
@@ -1665,20 +1894,20 @@ int SDL_UpdateYUVTexture(SDL_Texture * texture, const SDL_Rect * rect,
         return SDL_SetError("Texture format must by YV12 or IYUV");
     }
 
-    if (!rect) {
-        full_rect.x = 0;
-        full_rect.y = 0;
-        full_rect.w = texture->w;
-        full_rect.h = texture->h;
-        rect = &full_rect;
+    real_rect.x = 0;
+    real_rect.y = 0;
+    real_rect.w = texture->w;
+    real_rect.h = texture->h;
+    if (rect) {
+        SDL_IntersectRect(rect, &real_rect, &real_rect);
     }
 
-    if (!rect->w || !rect->h) {
+    if (real_rect.w == 0 || real_rect.h == 0) {
         return 0;  /* nothing to do. */
     }
 
     if (texture->yuv) {
-        return SDL_UpdateTextureYUVPlanar(texture, rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch);
+        return SDL_UpdateTextureYUVPlanar(texture, &real_rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch);
     } else {
         SDL_assert(!texture->native);
         renderer = texture->renderer;
@@ -1687,7 +1916,7 @@ int SDL_UpdateYUVTexture(SDL_Texture * texture, const SDL_Rect * rect,
             if (FlushRenderCommandsIfTextureNeeded(texture) < 0) {
                 return -1;
             }
-            return renderer->UpdateTextureYUV(renderer, texture, rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch);
+            return renderer->UpdateTextureYUV(renderer, texture, &real_rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch);
         } else {
             return SDL_Unsupported();
         }
@@ -1697,6 +1926,68 @@ int SDL_UpdateYUVTexture(SDL_Texture * texture, const SDL_Rect * rect,
 #endif
 }
 
+int SDL_UpdateNVTexture(SDL_Texture * texture, const SDL_Rect * rect,
+                         const Uint8 *Yplane, int Ypitch,
+                         const Uint8 *UVplane, int UVpitch)
+{
+#if SDL_HAVE_YUV
+    SDL_Renderer *renderer;
+    SDL_Rect real_rect;
+
+    CHECK_TEXTURE_MAGIC(texture, -1);
+
+    if (!Yplane) {
+        return SDL_InvalidParamError("Yplane");
+    }
+    if (!Ypitch) {
+        return SDL_InvalidParamError("Ypitch");
+    }
+    if (!UVplane) {
+        return SDL_InvalidParamError("UVplane");
+    }
+    if (!UVpitch) {
+        return SDL_InvalidParamError("UVpitch");
+    }
+
+    if (texture->format != SDL_PIXELFORMAT_NV12 &&
+        texture->format != SDL_PIXELFORMAT_NV21) {
+        return SDL_SetError("Texture format must by NV12 or NV21");
+    }
+
+    real_rect.x = 0;
+    real_rect.y = 0;
+    real_rect.w = texture->w;
+    real_rect.h = texture->h;
+    if (rect) {
+        SDL_IntersectRect(rect, &real_rect, &real_rect);
+    }
+
+    if (real_rect.w == 0 || real_rect.h == 0) {
+        return 0;  /* nothing to do. */
+    }
+
+    if (texture->yuv) {
+        return SDL_UpdateTextureNVPlanar(texture, &real_rect, Yplane, Ypitch, UVplane, UVpitch);
+    } else {
+        SDL_assert(!texture->native);
+        renderer = texture->renderer;
+        SDL_assert(renderer->UpdateTextureNV);
+        if (renderer->UpdateTextureNV) {
+            if (FlushRenderCommandsIfTextureNeeded(texture) < 0) {
+                return -1;
+            }
+            return renderer->UpdateTextureNV(renderer, texture, &real_rect, Yplane, Ypitch, UVplane, UVpitch);
+        } else {
+            return SDL_Unsupported();
+        }
+    }
+#else
+    return -1;
+#endif
+}
+
+
+
 #if SDL_HAVE_YUV
 static int
 SDL_LockTextureYUV(SDL_Texture * texture, const SDL_Rect * rect,
@@ -1775,7 +2066,6 @@ SDL_LockTextureToSurface(SDL_Texture *texture, const SDL_Rect *rect,
     real_rect.y = 0;
     real_rect.w = texture->w;
     real_rect.h = texture->h;
-
     if (rect) {
         SDL_IntersectRect(rect, &real_rect, &real_rect);
     }
@@ -1920,10 +2210,10 @@ SDL_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
     }
 
     if (texture) {
-        renderer->viewport.x = 0;
-        renderer->viewport.y = 0;
-        renderer->viewport.w = texture->w;
-        renderer->viewport.h = texture->h;
+        renderer->viewport.x = 0.0f;
+        renderer->viewport.y = 0.0f;
+        renderer->viewport.w = (float) texture->w;
+        renderer->viewport.h = (float) texture->h;
         SDL_zero(renderer->clip_rect);
         renderer->clipping_enabled = SDL_FALSE;
         renderer->scale.x = 1.0f;
@@ -2007,9 +2297,14 @@ UpdateLogicalSize(SDL_Renderer *renderer)
         } else {
             scale = (float)(h / renderer->logical_h);
         }
-        viewport.w = (int)SDL_ceil(renderer->logical_w * scale);
+
+        if (scale < 1.0f) {
+            scale = 1.0f;
+        }
+
+        viewport.w = (int)SDL_floor(renderer->logical_w * scale);
         viewport.x = (w - viewport.w) / 2;
-        viewport.h = (int)SDL_ceil(renderer->logical_h * scale);
+        viewport.h = (int)SDL_floor(renderer->logical_h * scale);
         viewport.y = (h - viewport.h) / 2;
 
         SDL_RenderSetViewport(renderer, &viewport);
@@ -2026,7 +2321,7 @@ UpdateLogicalSize(SDL_Renderer *renderer)
             scale = (float)h / renderer->logical_h;
             viewport.y = 0;
             viewport.h = h;
-            viewport.w = (int)SDL_ceil(renderer->logical_w * scale);
+            viewport.w = (int)SDL_floor(renderer->logical_w * scale);
             viewport.x = (w - viewport.w) / 2;
             SDL_RenderSetViewport(renderer, &viewport);
         } else {
@@ -2034,7 +2329,7 @@ UpdateLogicalSize(SDL_Renderer *renderer)
             scale = (float)w / renderer->logical_w;
             viewport.x = 0;
             viewport.w = w;
-            viewport.h = (int)SDL_ceil(renderer->logical_h * scale);
+            viewport.h = (int)SDL_floor(renderer->logical_h * scale);
             viewport.y = (h - viewport.h) / 2;
             SDL_RenderSetViewport(renderer, &viewport);
         }
@@ -2047,7 +2342,7 @@ UpdateLogicalSize(SDL_Renderer *renderer)
             scale = (float)w / renderer->logical_w;
             viewport.x = 0;
             viewport.w = w;
-            viewport.h = (int)SDL_ceil(renderer->logical_h * scale);
+            viewport.h = (int)SDL_floor(renderer->logical_h * scale);
             viewport.y = (h - viewport.h) / 2;
             SDL_RenderSetViewport(renderer, &viewport);
         } else {
@@ -2055,7 +2350,7 @@ UpdateLogicalSize(SDL_Renderer *renderer)
              scale = (float)h / renderer->logical_h;
              viewport.y = 0;
              viewport.h = h;
-             viewport.w = (int)SDL_ceil(renderer->logical_w * scale);
+             viewport.w = (int)SDL_floor(renderer->logical_w * scale);
              viewport.x = (w - viewport.w) / 2;
              SDL_RenderSetViewport(renderer, &viewport);
         }
@@ -2125,16 +2420,19 @@ SDL_RenderSetViewport(SDL_Renderer * renderer, const SDL_Rect * rect)
     CHECK_RENDERER_MAGIC(renderer, -1);
 
     if (rect) {
-        renderer->viewport.x = (int)SDL_floor(rect->x * renderer->scale.x);
-        renderer->viewport.y = (int)SDL_floor(rect->y * renderer->scale.y);
-        renderer->viewport.w = (int)SDL_ceil(rect->w * renderer->scale.x);
-        renderer->viewport.h = (int)SDL_ceil(rect->h * renderer->scale.y);
+        renderer->viewport.x = rect->x * renderer->scale.x;
+        renderer->viewport.y = rect->y * renderer->scale.y;
+        renderer->viewport.w = rect->w * renderer->scale.x;
+        renderer->viewport.h = rect->h * renderer->scale.y;
     } else {
-        renderer->viewport.x = 0;
-        renderer->viewport.y = 0;
-        if (SDL_GetRendererOutputSize(renderer, &renderer->viewport.w, &renderer->viewport.h) < 0) {
+        int w, h;
+        if (SDL_GetRendererOutputSize(renderer, &w, &h) < 0) {
             return -1;
         }
+        renderer->viewport.x = 0.0f;
+        renderer->viewport.y = 0.0f;
+        renderer->viewport.w = (float) w;
+        renderer->viewport.h = (float) h;
     }
     retval = QueueCmdSetViewport(renderer);
     return retval < 0 ? retval : FlushRenderCommandsIfNotBatching(renderer);
@@ -2146,13 +2444,22 @@ SDL_RenderGetViewport(SDL_Renderer * renderer, SDL_Rect * rect)
     CHECK_RENDERER_MAGIC(renderer, );
 
     if (rect) {
-        rect->x = (int)(renderer->viewport.x / renderer->scale.x);
-        rect->y = (int)(renderer->viewport.y / renderer->scale.y);
-        rect->w = (int)(renderer->viewport.w / renderer->scale.x);
-        rect->h = (int)(renderer->viewport.h / renderer->scale.y);
+        rect->x = (int)SDL_floor(renderer->viewport.x / renderer->scale.x);
+        rect->y = (int)SDL_floor(renderer->viewport.y / renderer->scale.y);
+        rect->w = (int)SDL_floor(renderer->viewport.w / renderer->scale.x);
+        rect->h = (int)SDL_floor(renderer->viewport.h / renderer->scale.y);
     }
 }
 
+static void
+RenderGetViewportSize(SDL_Renderer * renderer, SDL_FRect * rect)
+{
+    rect->x = 0.0f;
+    rect->y = 0.0f;
+    rect->w = renderer->viewport.w / renderer->scale.x;
+    rect->h = renderer->viewport.h / renderer->scale.y;
+}
+
 int
 SDL_RenderSetClipRect(SDL_Renderer * renderer, const SDL_Rect * rect)
 {
@@ -2161,10 +2468,10 @@ SDL_RenderSetClipRect(SDL_Renderer * renderer, const SDL_Rect * rect)
 
     if (rect) {
         renderer->clipping_enabled = SDL_TRUE;
-        renderer->clip_rect.x = (int)SDL_floor(rect->x * renderer->scale.x);
-        renderer->clip_rect.y = (int)SDL_floor(rect->y * renderer->scale.y);
-        renderer->clip_rect.w = (int)SDL_ceil(rect->w * renderer->scale.x);
-        renderer->clip_rect.h = (int)SDL_ceil(rect->h * renderer->scale.y);
+        renderer->clip_rect.x = rect->x * renderer->scale.x;
+        renderer->clip_rect.y = rect->y * renderer->scale.y;
+        renderer->clip_rect.w = rect->w * renderer->scale.x;
+        renderer->clip_rect.h = rect->h * renderer->scale.y;
     } else {
         renderer->clipping_enabled = SDL_FALSE;
         SDL_zero(renderer->clip_rect);
@@ -2180,10 +2487,10 @@ SDL_RenderGetClipRect(SDL_Renderer * renderer, SDL_Rect * rect)
     CHECK_RENDERER_MAGIC(renderer, )
 
     if (rect) {
-        rect->x = (int)(renderer->clip_rect.x / renderer->scale.x);
-        rect->y = (int)(renderer->clip_rect.y / renderer->scale.y);
-        rect->w = (int)(renderer->clip_rect.w / renderer->scale.x);
-        rect->h = (int)(renderer->clip_rect.h / renderer->scale.y);
+        rect->x = (int)SDL_floor(renderer->clip_rect.x / renderer->scale.x);
+        rect->y = (int)SDL_floor(renderer->clip_rect.y / renderer->scale.y);
+        rect->w = (int)SDL_floor(renderer->clip_rect.w / renderer->scale.x);
+        rect->h = (int)SDL_floor(renderer->clip_rect.h / renderer->scale.y);
     }
 }
 
@@ -2217,16 +2524,52 @@ SDL_RenderGetScale(SDL_Renderer * renderer, float *scaleX, float *scaleY)
     }
 }
 
+void
+SDL_RenderWindowToLogical(SDL_Renderer * renderer, int windowX, int windowY, float *logicalX, float *logicalY)
+{
+    float window_physical_x, window_physical_y;
+
+    CHECK_RENDERER_MAGIC(renderer, );
+
+    window_physical_x = ((float) windowX) / renderer->dpi_scale.x;
+    window_physical_y = ((float) windowY) / renderer->dpi_scale.y;
+
+    if (logicalX) {
+        *logicalX = (window_physical_x - renderer->viewport.x) / renderer->scale.x;
+    }
+    if (logicalY) {
+        *logicalY = (window_physical_y - renderer->viewport.y) / renderer->scale.y;
+    }
+}
+
+void
+SDL_RenderLogicalToWindow(SDL_Renderer * renderer, float logicalX, float logicalY, int *windowX, int *windowY)
+{
+    float window_physical_x, window_physical_y;
+
+    CHECK_RENDERER_MAGIC(renderer, );
+
+    window_physical_x = (logicalX * renderer->scale.x) + renderer->viewport.x;
+    window_physical_y = (logicalY * renderer->scale.y) + renderer->viewport.y;
+
+    if (windowX) {
+        *windowX = (int)(window_physical_x * renderer->dpi_scale.x);
+    }
+    if (windowY) {
+        *windowY = (int)(window_physical_y * renderer->dpi_scale.y);
+    }
+}
+
 int
 SDL_SetRenderDrawColor(SDL_Renderer * renderer,
                        Uint8 r, Uint8 g, Uint8 b, Uint8 a)
 {
     CHECK_RENDERER_MAGIC(renderer, -1);
 
-    renderer->r = r;
-    renderer->g = g;
-    renderer->b = b;
-    renderer->a = a;
+    renderer->color.r = r;
+    renderer->color.g = g;
+    renderer->color.b = b;
+    renderer->color.a = a;
     return 0;
 }
 
@@ -2237,16 +2580,16 @@ SDL_GetRenderDrawColor(SDL_Renderer * renderer,
     CHECK_RENDERER_MAGIC(renderer, -1);
 
     if (r) {
-        *r = renderer->r;
+        *r = renderer->color.r;
     }
     if (g) {
-        *g = renderer->g;
+        *g = renderer->color.g;
     }
     if (b) {
-        *b = renderer->b;
+        *b = renderer->color.b;
     }
     if (a) {
-        *a = renderer->a;
+        *a = renderer->color.a;
     }
     return 0;
 }
@@ -2323,11 +2666,13 @@ RenderDrawPointsWithRects(SDL_Renderer * renderer,
         frects[i].h = renderer->scale.y;
     }
 
-    retval = QueueCmdFillRects(renderer, frects, count);
+    if (count) {
+        retval = QueueCmdFillRects(renderer, frects, count);
+    }
 
     SDL_small_free(frects, isstack);
 
-    return retval < 0 ? retval : FlushRenderCommandsIfNotBatching(renderer);
+    return retval;
 }
 
 int
@@ -2342,34 +2687,35 @@ SDL_RenderDrawPoints(SDL_Renderer * renderer,
     CHECK_RENDERER_MAGIC(renderer, -1);
 
     if (!points) {
-        return SDL_SetError("SDL_RenderDrawPoints(): Passed NULL points");
+        return SDL_InvalidParamError("SDL_RenderDrawPoints(): points");
     }
     if (count < 1) {
         return 0;
     }
 
+#if DONT_DRAW_WHILE_HIDDEN
     /* Don't draw while we're hidden */
     if (renderer->hidden) {
         return 0;
     }
+#endif
 
     if (renderer->scale.x != 1.0f || renderer->scale.y != 1.0f) {
-        return RenderDrawPointsWithRects(renderer, points, count);
+        retval = RenderDrawPointsWithRects(renderer, points, count);
+    } else {
+        fpoints = SDL_small_alloc(SDL_FPoint, count, &isstack);
+        if (!fpoints) {
+            return SDL_OutOfMemory();
+        }
+        for (i = 0; i < count; ++i) {
+            fpoints[i].x = (float) points[i].x;
+            fpoints[i].y = (float) points[i].y;
+        }
+
+        retval = QueueCmdDrawPoints(renderer, fpoints, count);
+
+        SDL_small_free(fpoints, isstack);
     }
-
-    fpoints = SDL_small_alloc(SDL_FPoint, count, &isstack);
-    if (!fpoints) {
-        return SDL_OutOfMemory();
-    }
-    for (i = 0; i < count; ++i) {
-        fpoints[i].x = points[i].x * renderer->scale.x;
-        fpoints[i].y = points[i].y * renderer->scale.y;
-    }
-
-    retval = QueueCmdDrawPoints(renderer, fpoints, count);
-
-    SDL_small_free(fpoints, isstack);
-
     return retval < 0 ? retval : FlushRenderCommandsIfNotBatching(renderer);
 }
 
@@ -2393,53 +2739,42 @@ RenderDrawPointsWithRectsF(SDL_Renderer * renderer,
         frects[i].h = renderer->scale.y;
     }
 
-    retval = QueueCmdFillRects(renderer, frects, count);
+    if (count) {
+        retval = QueueCmdFillRects(renderer, frects, count);
+    }
 
     SDL_small_free(frects, isstack);
 
-    return retval < 0 ? retval : FlushRenderCommandsIfNotBatching(renderer);
+    return retval;
 }
 
 int
 SDL_RenderDrawPointsF(SDL_Renderer * renderer,
                       const SDL_FPoint * points, int count)
 {
-    SDL_FPoint *fpoints;
-    int i;
     int retval;
-    SDL_bool isstack;
 
     CHECK_RENDERER_MAGIC(renderer, -1);
 
     if (!points) {
-        return SDL_SetError("SDL_RenderDrawFPoints(): Passed NULL points");
+        return SDL_InvalidParamError("SDL_RenderDrawPointsF(): points");
     }
     if (count < 1) {
         return 0;
     }
 
+#if DONT_DRAW_WHILE_HIDDEN
     /* Don't draw while we're hidden */
     if (renderer->hidden) {
         return 0;
     }
+#endif
 
     if (renderer->scale.x != 1.0f || renderer->scale.y != 1.0f) {
-        return RenderDrawPointsWithRectsF(renderer, points, count);
+        retval = RenderDrawPointsWithRectsF(renderer, points, count);
+    } else {
+        retval = QueueCmdDrawPoints(renderer, points, count);
     }
-
-    fpoints = SDL_small_alloc(SDL_FPoint, count, &isstack);
-    if (!fpoints) {
-        return SDL_OutOfMemory();
-    }
-    for (i = 0; i < count; ++i) {
-        fpoints[i].x = points[i].x * renderer->scale.x;
-        fpoints[i].y = points[i].y * renderer->scale.y;
-    }
-
-    retval = QueueCmdDrawPoints(renderer, fpoints, count);
-
-    SDL_small_free(fpoints, isstack);
-
     return retval < 0 ? retval : FlushRenderCommandsIfNotBatching(renderer);
 }
 
@@ -2465,71 +2800,98 @@ SDL_RenderDrawLineF(SDL_Renderer * renderer, float x1, float y1, float x2, float
     return SDL_RenderDrawLinesF(renderer, points, 2);
 }
 
-static int
-RenderDrawLinesWithRects(SDL_Renderer * renderer,
-                     const SDL_Point * points, const int count)
+static int RenderDrawLineBresenham(SDL_Renderer *renderer, int x1, int y1, int x2, int y2, SDL_bool draw_last)
 {
-    SDL_FRect *frect;
-    SDL_FRect *frects;
-    SDL_FPoint fpoints[2];
-    int i, nrects = 0;
-    int retval = 0;
+    int i, deltax, deltay, numpixels;
+    int d, dinc1, dinc2;
+    int x, xinc1, xinc2;
+    int y, yinc1, yinc2;
+    int retval;
     SDL_bool isstack;
+    SDL_FPoint *points;
 
-    frects = SDL_small_alloc(SDL_FRect, count-1, &isstack);
-    if (!frects) {
-        return SDL_OutOfMemory();
+    deltax = SDL_abs(x2 - x1);
+    deltay = SDL_abs(y2 - y1);
+
+    if (deltax >= deltay) {
+        numpixels = deltax + 1;
+        d = (2 * deltay) - deltax;
+        dinc1 = deltay * 2;
+        dinc2 = (deltay - deltax) * 2;
+        xinc1 = 1;
+        xinc2 = 1;
+        yinc1 = 0;
+        yinc2 = 1;
+    } else {
+        numpixels = deltay + 1;
+        d = (2 * deltax) - deltay;
+        dinc1 = deltax * 2;
+        dinc2 = (deltax - deltay) * 2;
+        xinc1 = 0;
+        xinc2 = 1;
+        yinc1 = 1;
+        yinc2 = 1;
     }
 
-    for (i = 0; i < count-1; ++i) {
-        if (points[i].x == points[i+1].x) {
-            const int minY = SDL_min(points[i].y, points[i+1].y);
-            const int maxY = SDL_max(points[i].y, points[i+1].y);
+    if (x1 > x2) {
+        xinc1 = -xinc1;
+        xinc2 = -xinc2;
+    }
+    if (y1 > y2) {
+        yinc1 = -yinc1;
+        yinc2 = -yinc2;
+    }
 
-            frect = &frects[nrects++];
-            frect->x = points[i].x * renderer->scale.x;
-            frect->y = minY * renderer->scale.y;
-            frect->w = renderer->scale.x;
-            frect->h = (maxY - minY + 1) * renderer->scale.y;
-        } else if (points[i].y == points[i+1].y) {
-            const int minX = SDL_min(points[i].x, points[i+1].x);
-            const int maxX = SDL_max(points[i].x, points[i+1].x);
+    x = x1;
+    y = y1;
 
-            frect = &frects[nrects++];
-            frect->x = minX * renderer->scale.x;
-            frect->y = points[i].y * renderer->scale.y;
-            frect->w = (maxX - minX + 1) * renderer->scale.x;
-            frect->h = renderer->scale.y;
+    if (!draw_last) {
+        --numpixels;
+    }
+
+    points = SDL_small_alloc(SDL_FPoint, numpixels, &isstack);
+    if (!points) {
+        return SDL_OutOfMemory();
+    }
+    for (i = 0; i < numpixels; ++i) {
+        points[i].x = (float)x;
+        points[i].y = (float)y;
+
+        if (d < 0) {
+            d += dinc1;
+            x += xinc1;
+            y += yinc1;
         } else {
-            /* FIXME: We can't use a rect for this line... */
-            fpoints[0].x = points[i].x * renderer->scale.x;
-            fpoints[0].y = points[i].y * renderer->scale.y;
-            fpoints[1].x = points[i+1].x * renderer->scale.x;
-            fpoints[1].y = points[i+1].y * renderer->scale.y;
-            retval += QueueCmdDrawLines(renderer, fpoints, 2);
+            d += dinc2;
+            x += xinc2;
+            y += yinc2;
         }
     }
 
-    retval += QueueCmdFillRects(renderer, frects, nrects);
-
-    SDL_small_free(frects, isstack);
-
-    if (retval < 0) {
-        retval = -1;
+    if (renderer->scale.x != 1.0f || renderer->scale.y != 1.0f) {
+        retval = RenderDrawPointsWithRectsF(renderer, points, numpixels);
+    } else {
+        retval = QueueCmdDrawPoints(renderer, points, numpixels);
     }
-    return retval < 0 ? retval : FlushRenderCommandsIfNotBatching(renderer);
+
+    SDL_small_free(points, isstack);
+
+    return retval;
 }
 
 static int
 RenderDrawLinesWithRectsF(SDL_Renderer * renderer,
                           const SDL_FPoint * points, const int count)
 {
+    const float scale_x = renderer->scale.x;
+    const float scale_y = renderer->scale.y;
     SDL_FRect *frect;
     SDL_FRect *frects;
-    SDL_FPoint fpoints[2];
     int i, nrects = 0;
     int retval = 0;
     SDL_bool isstack;
+    SDL_bool drew_line = SDL_FALSE;
+    SDL_bool draw_last = SDL_FALSE;
 
     frects = SDL_small_alloc(SDL_FRect, count-1, &isstack);
     if (!frects) {
@@ -2537,42 +2899,59 @@ RenderDrawLinesWithRectsF(SDL_Renderer * renderer,
     }
 
     for (i = 0; i < count-1; ++i) {
-        if (points[i].x == points[i+1].x) {
-            const int minY = (int)SDL_min(points[i].y, points[i+1].y);
-            const int maxY = (int)SDL_max(points[i].y, points[i+1].y);
+        SDL_bool same_x = (points[i].x == points[i+1].x);
+        SDL_bool same_y = (points[i].y == points[i+1].y);
 
-            frect = &frects[nrects++];
-            frect->x = points[i].x * renderer->scale.x;
-            frect->y = minY * renderer->scale.y;
-            frect->w = renderer->scale.x;
-            frect->h = (maxY - minY + 1) * renderer->scale.y;
-        } else if (points[i].y == points[i+1].y) {
-            const int minX = (int)SDL_min(points[i].x, points[i+1].x);
-            const int maxX = (int)SDL_max(points[i].x, points[i+1].x);
-
-            frect = &frects[nrects++];
-            frect->x = minX * renderer->scale.x;
-            frect->y = points[i].y * renderer->scale.y;
-            frect->w = (maxX - minX + 1) * renderer->scale.x;
-            frect->h = renderer->scale.y;
+        if (i == (count - 2)) {
+            if (!drew_line || points[i+1].x != points[0].x || points[i+1].y != points[0].y) {
+                draw_last = SDL_TRUE;
+            }
         } else {
-            /* FIXME: We can't use a rect for this line... */
-            fpoints[0].x = points[i].x * renderer->scale.x;
-            fpoints[0].y = points[i].y * renderer->scale.y;
-            fpoints[1].x = points[i+1].x * renderer->scale.x;
-            fpoints[1].y = points[i+1].y * renderer->scale.y;
-            retval += QueueCmdDrawLines(renderer, fpoints, 2);
+            if (same_x && same_y) {
+                continue;
+            }
         }
+        if (same_x) {
+            const float minY = SDL_min(points[i].y, points[i+1].y);
+            const float maxY = SDL_max(points[i].y, points[i+1].y);
+
+            frect = &frects[nrects++];
+            frect->x = points[i].x * scale_x;
+            frect->y = minY * scale_y;
+            frect->w = scale_x;
+            frect->h = (maxY - minY + draw_last) * scale_y;
+            if (!draw_last && points[i+1].y < points[i].y) {
+                frect->y += scale_y;
+            }
+        } else if (same_y) {
+            const float minX = SDL_min(points[i].x, points[i+1].x);
+            const float maxX = SDL_max(points[i].x, points[i+1].x);
+
+            frect = &frects[nrects++];
+            frect->x = minX * scale_x;
+            frect->y = points[i].y * scale_y;
+            frect->w = (maxX - minX + draw_last) * scale_x;
+            frect->h = scale_y;
+            if (!draw_last && points[i+1].x < points[i].x) {
+                frect->x += scale_x;
+            }
+        } else {
+            retval += RenderDrawLineBresenham(renderer, (int)points[i].x, (int)points[i].y,
+                                                        (int)points[i+1].x, (int)points[i+1].y, draw_last);
+        }
+        drew_line = SDL_TRUE;
     }
 
-    retval += QueueCmdFillRects(renderer, frects, nrects);
+    if (nrects) {
+        retval += QueueCmdFillRects(renderer, frects, nrects);
+    }
 
     SDL_small_free(frects, isstack);
 
     if (retval < 0) {
         retval = -1;
     }
-    return retval < 0 ? retval : FlushRenderCommandsIfNotBatching(renderer);
+    return retval;
 }
 
 int
@@ -2587,77 +2966,188 @@ SDL_RenderDrawLines(SDL_Renderer * renderer,
     CHECK_RENDERER_MAGIC(renderer, -1);
 
     if (!points) {
-        return SDL_SetError("SDL_RenderDrawLines(): Passed NULL points");
+        return SDL_InvalidParamError("SDL_RenderDrawLines(): points");
     }
     if (count < 2) {
         return 0;
     }
 
+#if DONT_DRAW_WHILE_HIDDEN
     /* Don't draw while we're hidden */
     if (renderer->hidden) {
         return 0;
     }
-
-    if (renderer->scale.x != 1.0f || renderer->scale.y != 1.0f) {
-        return RenderDrawLinesWithRects(renderer, points, count);
-    }
+#endif
 
     fpoints = SDL_small_alloc(SDL_FPoint, count, &isstack);
     if (!fpoints) {
         return SDL_OutOfMemory();
     }
+
     for (i = 0; i < count; ++i) {
-        fpoints[i].x = points[i].x * renderer->scale.x;
-        fpoints[i].y = points[i].y * renderer->scale.y;
+        fpoints[i].x = (float) points[i].x;
+        fpoints[i].y = (float) points[i].y;
     }
 
-    retval = QueueCmdDrawLines(renderer, fpoints, count);
+    retval = SDL_RenderDrawLinesF(renderer, fpoints, count);
 
     SDL_small_free(fpoints, isstack);
 
-    return retval < 0 ? retval : FlushRenderCommandsIfNotBatching(renderer);
+    return retval;
 }
 
 int
 SDL_RenderDrawLinesF(SDL_Renderer * renderer,
                      const SDL_FPoint * points, int count)
 {
-    SDL_FPoint *fpoints;
-    int i;
-    int retval;
-    SDL_bool isstack;
+    int retval = 0;
 
     CHECK_RENDERER_MAGIC(renderer, -1);
 
     if (!points) {
-        return SDL_SetError("SDL_RenderDrawLines(): Passed NULL points");
+        return SDL_InvalidParamError("SDL_RenderDrawLinesF(): points");
     }
     if (count < 2) {
         return 0;
     }
 
+#if DONT_DRAW_WHILE_HIDDEN
     /* Don't draw while we're hidden */
     if (renderer->hidden) {
         return 0;
     }
+#endif
 
-    if (renderer->scale.x != 1.0f || renderer->scale.y != 1.0f) {
-        return RenderDrawLinesWithRectsF(renderer, points, count);
+    if (renderer->line_method == SDL_RENDERLINEMETHOD_POINTS) {
+        retval = RenderDrawLinesWithRectsF(renderer, points, count);
+    } else if (renderer->line_method == SDL_RENDERLINEMETHOD_GEOMETRY) {
+        SDL_bool isstack1;
+        SDL_bool isstack2;
+        const float scale_x = renderer->scale.x;
+        const float scale_y = renderer->scale.y;
+        float *xy = SDL_small_alloc(float, 4 * 2 * count, &isstack1);
+        int *indices = SDL_small_alloc(int,
+                  (4) * 3 * (count - 1)
+                + (2) * 3 * (count)
+                , &isstack2);
+
+        if (xy && indices) {
+            int i;
+            float *ptr_xy = xy;
+            int *ptr_indices = indices;
+            const int xy_stride = 2 * sizeof (float);
+            int num_vertices = 4 * count;
+            int num_indices = 0;
+            const int size_indices = 4;
+            int cur_indice = -4;
+            const int is_looping = (points[0].x == points[count - 1].x && points[0].y == points[count - 1].y);
+            SDL_FPoint p; /* previous point */
+            p.x = p.y = 0.0f;
+            /*       p            q
+
+                    0----1------ 4----5
+                    | \  |``\    | \  |
+                    |  \ |   ` `\|  \ |
+                    3----2-------7----6
+            */
+            for (i = 0; i < count; ++i) {
+                SDL_FPoint q = points[i]; /* current point */
+
+                q.x *= scale_x;
+                q.y *= scale_y;
+
+                *ptr_xy++ = q.x;
+                *ptr_xy++ = q.y;
+                *ptr_xy++ = q.x + scale_x;
+                *ptr_xy++ = q.y;
+                *ptr_xy++ = q.x + scale_x;
+                *ptr_xy++ = q.y + scale_y;
+                *ptr_xy++ = q.x;
+                *ptr_xy++ = q.y + scale_y;
+
+#define ADD_TRIANGLE(i1, i2, i3)                    \
+                *ptr_indices++ = cur_indice + i1;   \
+                *ptr_indices++ = cur_indice + i2;   \
+                *ptr_indices++ = cur_indice + i3;   \
+                num_indices += 3;                   \
+
+                /* closed polyline, don´t draw twice the point */
+                if (i || is_looping == 0) {
+                    ADD_TRIANGLE(4, 5, 6)
+                    ADD_TRIANGLE(4, 6, 7)
+                }
+
+                /* first point only, no segment */
+                if (i == 0) {
+                    p = q;
+                    cur_indice += 4;
+                    continue;
+                }
+
+                /* draw segment */
+                if (p.y == q.y) {
+                    if (p.x < q.x) {
+                        ADD_TRIANGLE(1, 4, 7)
+                        ADD_TRIANGLE(1, 7, 2)
+                    } else {
+                        ADD_TRIANGLE(5, 0, 3)
+                        ADD_TRIANGLE(5, 3, 6)
+                    }
+                } else if (p.x == q.x) {
+                    if (p.y < q.y) {
+                        ADD_TRIANGLE(2, 5, 4)
+                        ADD_TRIANGLE(2, 4, 3)
+                    } else {
+                        ADD_TRIANGLE(6, 1, 0)
+                        ADD_TRIANGLE(6, 0, 7)
+                    }
+                } else {
+                    if (p.y < q.y) {
+                        if (p.x < q.x) {
+                            ADD_TRIANGLE(1, 5, 4)
+                            ADD_TRIANGLE(1, 4, 2)
+                            ADD_TRIANGLE(2, 4, 7)
+                            ADD_TRIANGLE(2, 7, 3)
+                        } else {
+                            ADD_TRIANGLE(4, 0, 5)
+                            ADD_TRIANGLE(5, 0, 3)
+                            ADD_TRIANGLE(5, 3, 6)
+                            ADD_TRIANGLE(6, 3, 2)
+                        }
+                    } else {
+                        if (p.x < q.x) {
+                            ADD_TRIANGLE(0, 4, 7)
+                            ADD_TRIANGLE(0, 7, 1)
+                            ADD_TRIANGLE(1, 7, 6)
+                            ADD_TRIANGLE(1, 6, 2)
+                        } else {
+                            ADD_TRIANGLE(6, 5, 1)
+                            ADD_TRIANGLE(6, 1, 0)
+                            ADD_TRIANGLE(7, 6, 0)
+                            ADD_TRIANGLE(7, 0, 3)
+                        }
+                    }
+                }
+
+                p = q;
+                cur_indice += 4;
+            }
+
+            retval = QueueCmdGeometry(renderer, NULL,
+                    xy, xy_stride, &renderer->color, 0 /* color_stride */, NULL, 0,
+                    num_vertices, indices, num_indices, size_indices,
+                    1.0f, 1.0f);
+
+            SDL_small_free(xy, isstack1);
+            SDL_small_free(indices, isstack2);
+        }
+
+    } else if (renderer->scale.x != 1.0f || renderer->scale.y != 1.0f) {
+        retval = RenderDrawLinesWithRectsF(renderer, points, count);
+    } else {
+        retval = QueueCmdDrawLines(renderer, points, count);
     }
 
-    fpoints = SDL_small_alloc(SDL_FPoint, count, &isstack);
-    if (!fpoints) {
-        return SDL_OutOfMemory();
-    }
-    for (i = 0; i < count; ++i) {
-        fpoints[i].x = points[i].x * renderer->scale.x;
-        fpoints[i].y = points[i].y * renderer->scale.y;
-    }
-
-    retval = QueueCmdDrawLines(renderer, fpoints, count);
-
-    SDL_small_free(fpoints, isstack);
-
     return retval < 0 ? retval : FlushRenderCommandsIfNotBatching(renderer);
 }
 
@@ -2688,12 +3178,7 @@ SDL_RenderDrawRectF(SDL_Renderer * renderer, const SDL_FRect * rect)
 
     /* If 'rect' == NULL, then outline the whole surface */
     if (!rect) {
-        SDL_Rect r;
-        SDL_RenderGetViewport(renderer, &r);
-        frect.x = 0.0f;
-        frect.y = 0.0f;
-        frect.w = (float) r.w;
-        frect.h = (float) r.h;
+        RenderGetViewportSize(renderer, &frect);
         rect = &frect;
     }
 
@@ -2719,16 +3204,18 @@ SDL_RenderDrawRects(SDL_Renderer * renderer,
     CHECK_RENDERER_MAGIC(renderer, -1);
 
     if (!rects) {
-        return SDL_SetError("SDL_RenderDrawRects(): Passed NULL rects");
+        return SDL_InvalidParamError("SDL_RenderDrawRects(): rects");
     }
     if (count < 1) {
         return 0;
     }
 
+#if DONT_DRAW_WHILE_HIDDEN
     /* Don't draw while we're hidden */
     if (renderer->hidden) {
         return 0;
     }
+#endif
 
     for (i = 0; i < count; ++i) {
         if (SDL_RenderDrawRect(renderer, &rects[i]) < 0) {
@@ -2747,16 +3234,18 @@ SDL_RenderDrawRectsF(SDL_Renderer * renderer,
     CHECK_RENDERER_MAGIC(renderer, -1);
 
     if (!rects) {
-        return SDL_SetError("SDL_RenderDrawRects(): Passed NULL rects");
+        return SDL_InvalidParamError("SDL_RenderDrawRectsF(): rects");
     }
     if (count < 1) {
         return 0;
     }
 
+#if DONT_DRAW_WHILE_HIDDEN
     /* Don't draw while we're hidden */
     if (renderer->hidden) {
         return 0;
     }
+#endif
 
     for (i = 0; i < count; ++i) {
         if (SDL_RenderDrawRectF(renderer, &rects[i]) < 0) {
@@ -2780,13 +3269,7 @@ SDL_RenderFillRect(SDL_Renderer * renderer, const SDL_Rect * rect)
         frect.w = (float) rect->w;
         frect.h = (float) rect->h;
     } else {
-        SDL_Rect r;
-        SDL_zero(r);
-        SDL_RenderGetViewport(renderer, &r);
-        frect.x = 0.0f;
-        frect.y = 0.0f;
-        frect.w = (float) r.w;
-        frect.h = (float) r.h;
+        RenderGetViewportSize(renderer, &frect);
     }
     return SDL_RenderFillRectsF(renderer, &frect, 1);
 }
@@ -2800,13 +3283,7 @@ SDL_RenderFillRectF(SDL_Renderer * renderer, const SDL_FRect * rect)
 
     /* If 'rect' == NULL, then outline the whole surface */
     if (!rect) {
-        SDL_Rect r;
-        SDL_zero(r);
-        SDL_RenderGetViewport(renderer, &r);
-        frect.x = 0.0f;
-        frect.y = 0.0f;
-        frect.w = (float) r.w;
-        frect.h = (float) r.h;
+        RenderGetViewportSize(renderer, &frect);
         rect = &frect;
     }
     return SDL_RenderFillRectsF(renderer, rect, 1);
@@ -2824,16 +3301,18 @@ SDL_RenderFillRects(SDL_Renderer * renderer,
     CHECK_RENDERER_MAGIC(renderer, -1);
 
     if (!rects) {
-        return SDL_SetError("SDL_RenderFillRects(): Passed NULL rects");
+        return SDL_InvalidParamError("SDL_RenderFillRects(): rects");
     }
     if (count < 1) {
         return 0;
     }
 
+#if DONT_DRAW_WHILE_HIDDEN
     /* Don't draw while we're hidden */
     if (renderer->hidden) {
         return 0;
     }
+#endif
 
     frects = SDL_small_alloc(SDL_FRect, count, &isstack);
     if (!frects) {
@@ -2865,16 +3344,18 @@ SDL_RenderFillRectsF(SDL_Renderer * renderer,
     CHECK_RENDERER_MAGIC(renderer, -1);
 
     if (!rects) {
-        return SDL_SetError("SDL_RenderFillFRects(): Passed NULL rects");
+        return SDL_InvalidParamError("SDL_RenderFillRectsF(): rects");
     }
     if (count < 1) {
         return 0;
     }
 
+#if DONT_DRAW_WHILE_HIDDEN
     /* Don't draw while we're hidden */
     if (renderer->hidden) {
         return 0;
     }
+#endif
 
     frects = SDL_small_alloc(SDL_FRect, count, &isstack);
     if (!frects) {
@@ -2894,60 +3375,6 @@ SDL_RenderFillRectsF(SDL_Renderer * renderer,
     return retval < 0 ? retval : FlushRenderCommandsIfNotBatching(renderer);
 }
 
-/* !!! FIXME: move this to a public API if we want to do float versions of all of these later */
-SDL_FORCE_INLINE SDL_bool SDL_FRectEmpty(const SDL_FRect *r)
-{
-    return ((!r) || (r->w <= 0.0f) || (r->h <= 0.0f)) ? SDL_TRUE : SDL_FALSE;
-}
-
-/* !!! FIXME: move this to a public API if we want to do float versions of all of these later */
-static SDL_bool
-SDL_HasIntersectionF(const SDL_FRect * A, const SDL_FRect * B)
-{
-    float Amin, Amax, Bmin, Bmax;
-
-    if (!A) {
-        SDL_InvalidParamError("A");
-        return SDL_FALSE;
-    }
-
-    if (!B) {
-        SDL_InvalidParamError("B");
-        return SDL_FALSE;
-    }
-
-    /* Special cases for empty rects */
-    if (SDL_FRectEmpty(A) || SDL_FRectEmpty(B)) {
-        return SDL_FALSE;
-    }
-
-    /* Horizontal intersection */
-    Amin = A->x;
-    Amax = Amin + A->w;
-    Bmin = B->x;
-    Bmax = Bmin + B->w;
-    if (Bmin > Amin)
-        Amin = Bmin;
-    if (Bmax < Amax)
-        Amax = Bmax;
-    if (Amax <= Amin)
-        return SDL_FALSE;
-
-    /* Vertical intersection */
-    Amin = A->y;
-    Amax = Amin + A->h;
-    Bmin = B->y;
-    Bmax = Bmin + B->h;
-    if (Bmin > Amin)
-        Amin = Bmin;
-    if (Bmax < Amax)
-        Amax = Bmax;
-    if (Amax <= Amin)
-        return SDL_FALSE;
-
-    return SDL_TRUE;
-}
-
 int
 SDL_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
                const SDL_Rect * srcrect, const SDL_Rect * dstrect)
@@ -2970,8 +3397,9 @@ SDL_RenderCopyF(SDL_Renderer * renderer, SDL_Texture * texture,
 {
     SDL_Rect real_srcrect;
     SDL_FRect real_dstrect;
-    SDL_Rect r;
     int retval;
+    int use_rendergeometry;
+
 
     CHECK_RENDERER_MAGIC(renderer, -1);
     CHECK_TEXTURE_MAGIC(texture, -1);
@@ -2980,10 +3408,14 @@ SDL_RenderCopyF(SDL_Renderer * renderer, SDL_Texture * texture,
         return SDL_SetError("Texture was not created with this renderer");
     }
 
+#if DONT_DRAW_WHILE_HIDDEN
     /* Don't draw while we're hidden */
     if (renderer->hidden) {
         return 0;
     }
+#endif
+
+    use_rendergeometry = (renderer->QueueCopy == NULL);
 
     real_srcrect.x = 0;
     real_srcrect.y = 0;
@@ -2995,12 +3427,7 @@ SDL_RenderCopyF(SDL_Renderer * renderer, SDL_Texture * texture,
         }
     }
 
-    SDL_zero(r);
-    SDL_RenderGetViewport(renderer, &r);
-    real_dstrect.x = 0.0f;
-    real_dstrect.y = 0.0f;
-    real_dstrect.w = (float) r.w;
-    real_dstrect.h = (float) r.h;
+    RenderGetViewportSize(renderer, &real_dstrect);
     if (dstrect) {
         if (!SDL_HasIntersectionF(dstrect, &real_dstrect)) {
             return 0;
@@ -3012,14 +3439,62 @@ SDL_RenderCopyF(SDL_Renderer * renderer, SDL_Texture * texture,
         texture = texture->native;
     }
 
-    real_dstrect.x *= renderer->scale.x;
-    real_dstrect.y *= renderer->scale.y;
-    real_dstrect.w *= renderer->scale.x;
-    real_dstrect.h *= renderer->scale.y;
-
     texture->last_command_generation = renderer->render_command_generation;
 
-    retval = QueueCmdCopy(renderer, texture, &real_srcrect, &real_dstrect);
+    if (use_rendergeometry) {
+        float xy[8];
+        const int xy_stride = 2 * sizeof (float);
+        float uv[8];
+        const int uv_stride = 2 * sizeof (float);
+        const int num_vertices = 4;
+        const int indices[6] = {0, 1, 2, 0, 2, 3};
+        const int num_indices = 6;
+        const int size_indices = 4;
+        float minu, minv, maxu, maxv;
+        float minx, miny, maxx, maxy;
+
+        minu = (float) (real_srcrect.x) / (float) texture->w;
+        minv = (float) (real_srcrect.y) / (float) texture->h;
+        maxu = (float) (real_srcrect.x + real_srcrect.w) / (float) texture->w;
+        maxv = (float) (real_srcrect.y + real_srcrect.h) / (float) texture->h;
+
+        minx = real_dstrect.x;
+        miny = real_dstrect.y;
+        maxx = real_dstrect.x + real_dstrect.w;
+        maxy = real_dstrect.y + real_dstrect.h;
+
+        uv[0] = minu;
+        uv[1] = minv;
+        uv[2] = maxu;
+        uv[3] = minv;
+        uv[4] = maxu;
+        uv[5] = maxv;
+        uv[6] = minu;
+        uv[7] = maxv;
+
+        xy[0] = minx;
+        xy[1] = miny;
+        xy[2] = maxx;
+        xy[3] = miny;
+        xy[4] = maxx;
+        xy[5] = maxy;
+        xy[6] = minx;
+        xy[7] = maxy;
+
+        retval = QueueCmdGeometry(renderer, texture,
+                xy, xy_stride, &texture->color, 0 /* color_stride */, uv, uv_stride,
+                num_vertices,
+                indices, num_indices, size_indices,
+                renderer->scale.x, renderer->scale.y);
+    } else {
+
+        real_dstrect.x *= renderer->scale.x;
+        real_dstrect.y *= renderer->scale.y;
+        real_dstrect.w *= renderer->scale.x;
+        real_dstrect.h *= renderer->scale.y;
+
+        retval = QueueCmdCopy(renderer, texture, &real_srcrect, &real_dstrect);
+    }
     return retval < 0 ? retval : FlushRenderCommandsIfNotBatching(renderer);
 }
 
@@ -3059,6 +3534,7 @@ SDL_RenderCopyExF(SDL_Renderer * renderer, SDL_Texture * texture,
     SDL_FRect real_dstrect;
     SDL_FPoint real_center;
     int retval;
+    int use_rendergeometry;
 
     if (flip == SDL_FLIP_NONE && (int)(angle/360) == angle/360) { /* fast path when we don't need rotation or flipping */
         return SDL_RenderCopyF(renderer, texture, srcrect, dstrect);
@@ -3070,14 +3546,18 @@ SDL_RenderCopyExF(SDL_Renderer * renderer, SDL_Texture * texture,
     if (renderer != texture->renderer) {
         return SDL_SetError("Texture was not created with this renderer");
     }
-    if (!renderer->QueueCopyEx) {
+    if (!renderer->QueueCopyEx && !renderer->QueueGeometry) {
         return SDL_SetError("Renderer does not support RenderCopyEx");
     }
 
+#if DONT_DRAW_WHILE_HIDDEN
     /* Don't draw while we're hidden */
     if (renderer->hidden) {
         return 0;
     }
+#endif
+
+    use_rendergeometry = (renderer->QueueCopyEx == NULL);
 
     real_srcrect.x = 0;
     real_srcrect.y = 0;
@@ -3093,13 +3573,7 @@ SDL_RenderCopyExF(SDL_Renderer * renderer, SDL_Texture * texture,
     if (dstrect) {
         real_dstrect = *dstrect;
     } else {
-        SDL_Rect r;
-        SDL_zero(r);
-        SDL_RenderGetViewport(renderer, &r);
-        real_dstrect.x = 0.0f;
-        real_dstrect.y = 0.0f;
-        real_dstrect.w = (float) r.w;
-        real_dstrect.h = (float) r.h;
+        RenderGetViewportSize(renderer, &real_dstrect);
     }
 
     if (texture->native) {
@@ -3113,20 +3587,574 @@ SDL_RenderCopyExF(SDL_Renderer * renderer, SDL_Texture * texture,
         real_center.y = real_dstrect.h / 2.0f;
     }
 
-    real_dstrect.x *= renderer->scale.x;
-    real_dstrect.y *= renderer->scale.y;
-    real_dstrect.w *= renderer->scale.x;
-    real_dstrect.h *= renderer->scale.y;
-
-    real_center.x *= renderer->scale.x;
-    real_center.y *= renderer->scale.y;
-
     texture->last_command_generation = renderer->render_command_generation;
 
-    retval = QueueCmdCopyEx(renderer, texture, &real_srcrect, &real_dstrect, angle, &real_center, flip);
+    if (use_rendergeometry) {
+        float xy[8];
+        const int xy_stride = 2 * sizeof (float);
+        float uv[8];
+        const int uv_stride = 2 * sizeof (float);
+        const int num_vertices = 4;
+        const int indices[6] = {0, 1, 2, 0, 2, 3};
+        const int num_indices = 6;
+        const int size_indices = 4;
+        float minu, minv, maxu, maxv;
+        float minx, miny, maxx, maxy;
+        float centerx, centery;
+
+        float s_minx, s_miny, s_maxx, s_maxy;
+        float c_minx, c_miny, c_maxx, c_maxy;
+
+        const float radian_angle = (float)((M_PI * angle) / 180.0);
+        const float s = SDL_sinf(radian_angle);
+        const float c = SDL_cosf(radian_angle);
+
+        minu = (float) (real_srcrect.x) / (float) texture->w;
+        minv = (float) (real_srcrect.y) / (float) texture->h;
+        maxu = (float) (real_srcrect.x + real_srcrect.w) / (float) texture->w;
+        maxv = (float) (real_srcrect.y + real_srcrect.h) / (float) texture->h;
+
+        centerx = real_center.x + real_dstrect.x;
+        centery = real_center.y + real_dstrect.y;
+
+        if (flip & SDL_FLIP_HORIZONTAL) {
+            minx = real_dstrect.x + real_dstrect.w;
+            maxx = real_dstrect.x;
+        } else {
+            minx = real_dstrect.x;
+            maxx = real_dstrect.x + real_dstrect.w;
+        }
+
+        if (flip & SDL_FLIP_VERTICAL) {
+            miny = real_dstrect.y + real_dstrect.h;
+            maxy = real_dstrect.y;
+        } else {
+            miny = real_dstrect.y;
+            maxy = real_dstrect.y + real_dstrect.h;
+        }
+
+        uv[0] = minu;
+        uv[1] = minv;
+        uv[2] = maxu;
+        uv[3] = minv;
+        uv[4] = maxu;
+        uv[5] = maxv;
+        uv[6] = minu;
+        uv[7] = maxv;
+
+        /* apply rotation with 2x2 matrix ( c -s )
+         *                                ( s  c ) */
+        s_minx = s * (minx - centerx);
+        s_miny = s * (miny - centery);
+        s_maxx = s * (maxx - centerx);
+        s_maxy = s * (maxy - centery);
+        c_minx = c * (minx - centerx);
+        c_miny = c * (miny - centery);
+        c_maxx = c * (maxx - centerx);
+        c_maxy = c * (maxy - centery);
+
+        /* (minx, miny) */
+        xy[0] = (c_minx - s_miny) + centerx;
+        xy[1] = (s_minx + c_miny) + centery;
+        /* (maxx, miny) */
+        xy[2] = (c_maxx - s_miny) + centerx;
+        xy[3] = (s_maxx + c_miny) + centery;
+        /* (maxx, maxy) */
+        xy[4] = (c_maxx - s_maxy) + centerx;
+        xy[5] = (s_maxx + c_maxy) + centery;
+        /* (minx, maxy) */
+        xy[6] = (c_minx - s_maxy) + centerx;
+        xy[7] = (s_minx + c_maxy) + centery;
+
+        retval = QueueCmdGeometry(renderer, texture,
+                xy, xy_stride, &texture->color, 0 /* color_stride */, uv, uv_stride,
+                num_vertices,
+                indices, num_indices, size_indices,
+                renderer->scale.x, renderer->scale.y);
+    } else {
+
+        retval = QueueCmdCopyEx(renderer, texture, &real_srcrect, &real_dstrect, angle, &real_center, flip, renderer->scale.x, renderer->scale.y);
+    }
     return retval < 0 ? retval : FlushRenderCommandsIfNotBatching(renderer);
 }
 
+int
+SDL_RenderGeometry(SDL_Renderer *renderer,
+                               SDL_Texture *texture,
+                               const SDL_Vertex *vertices, int num_vertices,
+                               const int *indices, int num_indices)
+{
+    if (vertices) {
+        const float *xy = &vertices->position.x;
+        int xy_stride = sizeof (SDL_Vertex);
+        const SDL_Color *color = &vertices->color;
+        int color_stride = sizeof (SDL_Vertex);
+        const float *uv = &vertices->tex_coord.x;
+        int uv_stride = sizeof (SDL_Vertex);
+        int size_indices = 4;
+        return SDL_RenderGeometryRaw(renderer, texture, xy, xy_stride, color, color_stride, uv, uv_stride, num_vertices, indices, num_indices, size_indices);
+    } else {
+        return SDL_InvalidParamError("vertices");
+    }
+}
+
+static int
+remap_one_indice(
+        int prev,
+        int k,
+        SDL_Texture *texture,
+        const float *xy, int xy_stride,
+        const SDL_Color *color, int color_stride,
+        const float *uv, int uv_stride)
+{
+    const float *xy0_, *xy1_, *uv0_, *uv1_;
+    int col0_, col1_;
+    xy0_ = (const float *)((const char*)xy + prev * xy_stride);
+    xy1_ = (const float *)((const char*)xy + k * xy_stride);
+    if (xy0_[0] != xy1_[0]) {
+        return k;
+    }
+    if (xy0_[1] != xy1_[1]) {
+        return k;
+    }
+    if (texture) {
+        uv0_ = (const float *)((const char*)uv + prev * uv_stride);
+        uv1_ = (const float *)((const char*)uv + k * uv_stride);
+        if (uv0_[0] != uv1_[0]) {
+            return k;
+        }
+        if (uv0_[1] != uv1_[1]) {
+            return k;
+        }
+    }
+    col0_ = *(const int *)((const char*)color + prev * color_stride);
+    col1_ = *(const int *)((const char*)color + k * color_stride);
+
+    if (col0_ != col1_) {
+        return k;
+    }
+
+    return prev;
+}
+
+static int
+remap_indices(
+        int prev[3],
+        int k,
+        SDL_Texture *texture,
+        const float *xy, int xy_stride,
+        const SDL_Color *color, int color_stride,
+        const float *uv, int uv_stride)
+{
+    int i;
+    if (prev[0] == -1) {
+        return k;
+    }
+
+    for (i = 0; i < 3; i++) {
+        int new_k = remap_one_indice(prev[i], k, texture, xy, xy_stride, color, color_stride, uv, uv_stride);
+        if (new_k != k) {
+            return new_k;
+        }
+    }
+    return k;
+}
+
+#define DEBUG_SW_RENDER_GEOMETRY 0
+/* For the software renderer, try to reinterpret triangles as SDL_Rect */
+static int SDLCALL
+SDL_SW_RenderGeometryRaw(SDL_Renderer *renderer,
+                         SDL_Texture *texture,
+                         const float *xy, int xy_stride,
+                         const SDL_Color *color, int color_stride,
+                         const float *uv, int uv_stride,
+                         int num_vertices,
+                         const void *indices, int num_indices, int size_indices)
+{
+    int i;
+    int retval = 0;
+    int count = indices ? num_indices : num_vertices;
+    int prev[3]; /* Previous triangle vertex indices */
+    int texw = 0, texh = 0;
+    SDL_BlendMode blendMode = SDL_BLENDMODE_NONE;
+    Uint8 r = 0, g = 0, b = 0, a = 0;
+
+    /* Save */
+    SDL_GetRenderDrawBlendMode(renderer, &blendMode);
+    SDL_GetRenderDrawColor(renderer, &r, &g, &b, &a);
+
+    if (texture) {
+        SDL_QueryTexture(texture, NULL, NULL, &texw, &texh);
+    }
+
+    prev[0] = -1; prev[1] = -1; prev[2] = -1;
+    size_indices = indices ? size_indices : 0;
+
+    for (i = 0; i < count; i += 3) {
+        int k0, k1, k2; /* Current triangle indices */
+        int is_quad = 1;
+#if DEBUG_SW_RENDER_GEOMETRY
+        int is_uniform = 1;
+        int is_rectangle = 1;
+#endif
+        int A = -1;  /* Top left vertex */
+        int B = -1;  /* Bottom right vertex */
+        int C = -1;  /* Third vertex of current triangle */
+        int C2 = -1; /* Last, vertex of previous triangle */
+
+        if (size_indices == 4) {
+            k0 = ((const Uint32 *)indices)[i];
+            k1 = ((const Uint32 *)indices)[i + 1];
+            k2 = ((const Uint32 *)indices)[i + 2];
+        } else if (size_indices == 2) {
+            k0 = ((const Uint16 *)indices)[i];
+            k1 = ((const Uint16 *)indices)[i + 1];
+            k2 = ((const Uint16 *)indices)[i + 2];
+        } else if (size_indices == 1) {
+            k0 = ((const Uint8 *)indices)[i];
+            k1 = ((const Uint8 *)indices)[i + 1];
+            k2 = ((const Uint8 *)indices)[i + 2];
+        } else {
+            /* Vertices were not provided by indices. Maybe some are duplicated.
+             * We try to indentificate the duplicates by comparing with the previous three vertices */
+            k0 = remap_indices(prev, i, texture, xy, xy_stride, color, color_stride, uv, uv_stride);
+            k1 = remap_indices(prev, i + 1, texture, xy, xy_stride, color, color_stride, uv, uv_stride);
+            k2 = remap_indices(prev, i + 2, texture, xy, xy_stride, color, color_stride, uv, uv_stride);
+        }
+
+        if (prev[0] == -1) {
+            prev[0] = k0;
+            prev[1] = k1;
+            prev[2] = k2;
+            continue;
+        }
+
+        /* Two triangles forming a quadialateral,
+         * prev and current triangles must have exactly 2 common vertices */
+        {
+            int cnt = 0, j = 3;
+            while (j--) {
+                int p = prev[j];
+                if (p == k0 || p == k1 || p == k2) {
+                    cnt++;
+                }
+            }
+            is_quad = (cnt == 2);
+        }
+
+        /* Identify vertices */
+        if (is_quad) {
+            const float *xy0_, *xy1_, *xy2_;
+            float x0, x1, x2;
+            float y0, y1, y2;
+            xy0_ = (const float *)((const char*)xy + k0 * xy_stride);
+            xy1_ = (const float *)((const char*)xy + k1 * xy_stride);
+            xy2_ = (const float *)((const char*)xy + k2 * xy_stride);
+            x0 = xy0_[0]; y0 = xy0_[1];
+            x1 = xy1_[0]; y1 = xy1_[1];
+            x2 = xy2_[0]; y2 = xy2_[1];
+
+            /* Find top-left */
+            if (x0 <= x1 && y0 <= y1) {
+                if (x0 <= x2 && y0 <= y2) {
+                    A = k0;
+                } else {
+                    A = k2;
+                }
+            } else {
+                if (x1 <= x2 && y1 <= y2) {
+                    A = k1;
+                } else {
+                    A = k2;
+                }
+            }
+
+            /* Find bottom-right */
+            if (x0 >= x1 && y0 >= y1) {
+                if (x0 >= x2 && y0 >= y2) {
+                    B = k0;
+                } else {
+                    B = k2;
+                }
+            } else {
+                if (x1 >= x2 && y1 >= y2) {
+                    B = k1;
+                } else {
+                    B = k2;
+                }
+            }
+
+            /* Find C */
+            if (k0 != A && k0 != B) {
+                C = k0;
+            } else if (k1 != A && k1 != B) {
+                C = k1;
+            } else {
+                C = k2;
+            }
+
+            /* Find C2 */
+            if (prev[0] != A && prev[0] != B) {
+                C2 = prev[0];
+            } else if (prev[1] != A && prev[1] != B) {
+                C2 = prev[1];
+            } else {
+                C2 = prev[2];
+            }
+
+            xy0_ = (const float *)((const char*)xy + A * xy_stride);
+            xy1_ = (const float *)((const char*)xy + B * xy_stride);
+            xy2_ = (const float *)((const char*)xy + C * xy_stride);
+            x0 = xy0_[0]; y0 = xy0_[1];
+            x1 = xy1_[0]; y1 = xy1_[1];
+            x2 = xy2_[0]; y2 = xy2_[1];
+
+            /* Check if triangle A B C is rectangle */
+            if ((x0 == x2 && y1 == y2) || (y0 == y2 && x1 == x2)){
+                /* ok */
+            } else {
+                is_quad = 0;
+#if DEBUG_SW_RENDER_GEOMETRY
+                is_rectangle = 0;
+#endif
+            }
+
+            xy2_ = (const float *)((const char*)xy + C2 * xy_stride);
+            x2 = xy2_[0]; y2 = xy2_[1];
+
+            /* Check if triangle A B C2 is rectangle */
+            if ((x0 == x2 && y1 == y2) || (y0 == y2 && x1 == x2)){
+                /* ok */
+            } else {
+                is_quad = 0;
+#if DEBUG_SW_RENDER_GEOMETRY
+                is_rectangle = 0;
+#endif
+            }
+        }
+
+        /* Check if uniformly colored */
+        if (is_quad) {
+            const int col0_ = *(const int *)((const char*)color + A * color_stride);
+            const int col1_ = *(const int *)((const char*)color + B * color_stride);
+            const int col2_ = *(const int *)((const char*)color + C * color_stride);
+            const int col3_ = *(const int *)((const char*)color + C2 * color_stride);
+            if (col0_ == col1_ && col0_ == col2_ && col0_ == col3_) {
+                /* ok */
+            } else {
+                is_quad = 0;
+#if DEBUG_SW_RENDER_GEOMETRY
+                is_uniform = 0;
+#endif
+            }
+        }
+
+        /* Start rendering rect */
+        if (is_quad) {
+            SDL_Rect s;
+            SDL_FRect d;
+            const float *xy0_, *xy1_, *uv0_, *uv1_;
+            SDL_Color col0_ = *(const SDL_Color *)((const char*)color + k0 * color_stride);
+
+            xy0_ = (const float *)((const char*)xy + A * xy_stride);
+            xy1_ = (const float *)((const char*)xy + B * xy_stride);
+
+            if (texture) {
+                uv0_ = (const float *)((const char*)uv + A * uv_stride);
+                uv1_ = (const float *)((const char*)uv + B * uv_stride);
+                s.x = (int) (uv0_[0] * texw);
+                s.y = (int) (uv0_[1] * texh);
+                s.w = (int) (uv1_[0] * texw - s.x);
+                s.h = (int) (uv1_[1] * texh - s.y);
+            }
+
+            d.x = xy0_[0];
+            d.y = xy0_[1];
+            d.w = xy1_[0] - d.x;
+            d.h = xy1_[1] - d.y;
+
+            /* Rect + texture */
+            if (texture && s.w != 0 && s.h != 0) {
+                SDL_SetTextureAlphaMod(texture, col0_.a);
+                SDL_SetTextureColorMod(texture, col0_.r, col0_.g, col0_.b);
+                SDL_RenderCopyF(renderer, texture, &s, &d);
+#if DEBUG_SW_RENDER_GEOMETRY
+                SDL_Log("Rect-COPY: RGB %d %d %d - Alpha:%d - texture=%p: src=(%d,%d, %d x %d) dst (%f, %f, %f x %f)", col0_.r, col0_.g, col0_.b, col0_.a,
+                        (void *)texture, s.x, s.y, s.w, s.h, d.x, d.y, d.w, d.h);
+#endif
+            } else if (d.w != 0.0f && d.h != 0.0f) { /* Rect, no texture */
+                SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
+                SDL_SetRenderDrawColor(renderer, col0_.r, col0_.g, col0_.b, col0_.a);
+                SDL_RenderFillRectF(renderer, &d);
+#if DEBUG_SW_RENDER_GEOMETRY
+                SDL_Log("Rect-FILL: RGB %d %d %d - Alpha:%d - texture=%p: src=(%d,%d, %d x %d) dst (%f, %f, %f x %f)", col0_.r, col0_.g, col0_.b, col0_.a,
+                        (void *)texture, s.x, s.y, s.w, s.h, d.x, d.y, d.w, d.h);
+            } else {
+                SDL_Log("Rect-DISMISS: RGB %d %d %d - Alpha:%d - texture=%p: src=(%d,%d, %d x %d) dst (%f, %f, %f x %f)", col0_.r, col0_.g, col0_.b, col0_.a,
+                        (void *)texture, s.x, s.y, s.w, s.h, d.x, d.y, d.w, d.h);
+#endif
+            }
+
+            prev[0] = -1;
+        } else {
+            /* Render triangles */
+            if (prev[0] != -1) {
+#if DEBUG_SW_RENDER_GEOMETRY
+                SDL_Log("Triangle %d %d %d - is_uniform:%d is_rectangle:%d", prev[0], prev[1], prev[2], is_uniform, is_rectangle);
+#endif
+                retval = QueueCmdGeometry(renderer, texture,
+                                          xy, xy_stride, color, color_stride, uv, uv_stride,
+                                          num_vertices, prev, 3, 4, renderer->scale.x, renderer->scale.y);
+                if (retval < 0) {
+                    goto end;
+                } else {
+                    FlushRenderCommandsIfNotBatching(renderer);
+                }
+            }
+
+            prev[0] = k0;
+            prev[1] = k1;
+            prev[2] = k2;
+        }
+    } /* End for(), next triangle */
+
+    if (prev[0] != -1) {
+        /* flush the last triangle */
+#if DEBUG_SW_RENDER_GEOMETRY
+        SDL_Log("Last triangle %d %d %d", prev[0], prev[1], prev[2]);
+#endif
+        retval = QueueCmdGeometry(renderer, texture,
+                                  xy, xy_stride, color, color_stride, uv, uv_stride,
+                                  num_vertices, prev, 3, 4, renderer->scale.x, renderer->scale.y);
+        if (retval < 0) {
+            goto end;
+        } else {
+            FlushRenderCommandsIfNotBatching(renderer);
+        }
+    }
+
+end:
+    /* Restore */
+    SDL_SetRenderDrawBlendMode(renderer, blendMode);
+    SDL_SetRenderDrawColor(renderer, r, g, b, a);
+
+    return retval;
+}
+
+int
+SDL_RenderGeometryRaw(SDL_Renderer *renderer,
+                                  SDL_Texture *texture,
+                                  const float *xy, int xy_stride,
+                                  const SDL_Color *color, int color_stride,
+                                  const float *uv, int uv_stride,
+                                  int num_vertices,
+                                  const void *indices, int num_indices, int size_indices)
+{
+    int i;
+    int retval = 0;
+    int count = indices ? num_indices : num_vertices;
+
+    CHECK_RENDERER_MAGIC(renderer, -1);
+
+    if (!renderer->QueueGeometry) {
+        return SDL_Unsupported();
+    }
+
+    if (texture) {
+        CHECK_TEXTURE_MAGIC(texture, -1);
+
+        if (renderer != texture->renderer) {
+            return SDL_SetError("Texture was not created with this renderer");
+        }
+    }
+
+    if (!xy) {
+        return SDL_InvalidParamError("xy");
+    }
+
+    if (!color) {
+        return SDL_InvalidParamError("color");
+    }
+
+    if (texture && !uv) {
+        return SDL_InvalidParamError("uv");
+    }
+
+    if (count % 3 != 0) {
+        return SDL_InvalidParamError(indices ? "num_indices" : "num_vertices");
+    }
+
+    if (indices) {
+        if (size_indices != 1 && size_indices != 2 && size_indices != 4) {
+            return SDL_InvalidParamError("size_indices");
+        }
+    } else {
+        size_indices = 0;
+    }
+
+#if DONT_DRAW_WHILE_HIDDEN
+    /* Don't draw while we're hidden */
+    if (renderer->hidden) {
+        return 0;
+    }
+#endif
+
+    if (num_vertices < 3) {
+        return 0;
+    }
+
+    if (texture && texture->native) {
+        texture = texture->native;
+    }
+
+    if (texture) {
+        for (i = 0; i < num_vertices; ++i) {
+            const float *uv_ = (const float *)((const char*)uv + i * uv_stride);
+            float u = uv_[0];
+            float v = uv_[1];
+            if (u < 0.0f || v < 0.0f || u > 1.0f || v > 1.0f) {
+                return SDL_SetError("Values of 'uv' out of bounds %f %f at %d/%d", u, v, i, num_vertices);
+            }
+        }
+    }
+
+    if (indices) {
+        for (i = 0; i < num_indices; ++i) {
+            int j;
+            if (size_indices == 4) {
+                j = ((const Uint32 *)indices)[i];
+            } else if (size_indices == 2) {
+                j = ((const Uint16 *)indices)[i];
+            } else {
+                j = ((const Uint8 *)indices)[i];
+            }
+            if (j < 0 || j >= num_vertices) {
+                return SDL_SetError("Values of 'indices' out of bounds");
+            }
+        }
+    }
+
+    if (texture) {
+        texture->last_command_generation = renderer->render_command_generation;
+    }
+
+    /* For the software renderer, try to reinterpret triangles as SDL_Rect */
+    if (renderer->info.flags & SDL_RENDERER_SOFTWARE) {
+        return SDL_SW_RenderGeometryRaw(renderer, texture,
+                xy, xy_stride, color, color_stride, uv, uv_stride, num_vertices,
+                indices, num_indices, size_indices);
+    }
+
+    retval = QueueCmdGeometry(renderer, texture,
+            xy, xy_stride, color, color_stride, uv, uv_stride,
+            num_vertices,
+            indices, num_indices, size_indices,
+            renderer->scale.x, renderer->scale.y);
+
+    return retval < 0 ? retval : FlushRenderCommandsIfNotBatching(renderer);
+}
+
+
 int
 SDL_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
                      Uint32 format, void * pixels, int pitch)
@@ -3142,13 +4170,17 @@ SDL_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
     FlushRenderCommands(renderer);  /* we need to render before we read the results. */
 
     if (!format) {
-        format = SDL_GetWindowPixelFormat(renderer->window);
+        if (renderer->target == NULL) {
+            format = SDL_GetWindowPixelFormat(renderer->window);
+        } else {
+            format = renderer->target->format;
+        }
     }
 
-    real_rect.x = renderer->viewport.x;
-    real_rect.y = renderer->viewport.y;
-    real_rect.w = renderer->viewport.w;
-    real_rect.h = renderer->viewport.h;
+    real_rect.x = (int)SDL_floor(renderer->viewport.x);
+    real_rect.y = (int)SDL_floor(renderer->viewport.y);
+    real_rect.w = (int)SDL_floor(renderer->viewport.w);
+    real_rect.h = (int)SDL_floor(renderer->viewport.h);
     if (rect) {
         if (!SDL_IntersectRect(rect, &real_rect, &real_rect)) {
             return 0;
@@ -3173,10 +4205,13 @@ SDL_RenderPresent(SDL_Renderer * renderer)
 
     FlushRenderCommands(renderer);  /* time to send everything to the GPU! */
 
+#if DONT_DRAW_WHILE_HIDDEN
     /* Don't present while we're hidden */
     if (renderer->hidden) {
         return;
     }
+#endif
+
     renderer->RenderPresent(renderer);
 }
 
@@ -3424,4 +4459,19 @@ SDL_GetBlendModeAlphaOperation(SDL_BlendMode blendMode)
     return (SDL_BlendOperation)(((Uint32)blendMode >> 16) & 0xF);
 }
 
+int
+SDL_RenderSetVSync(SDL_Renderer * renderer, int vsync)
+{
+    CHECK_RENDERER_MAGIC(renderer, -1);
+
+    if (vsync != 0 && vsync != 1) {
+        return SDL_Unsupported();
+    }
+
+    if (renderer->SetVSync) {
+        return renderer->SetVSync(renderer, vsync);
+    }
+    return SDL_Unsupported();
+}
+
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/render/SDL_sysrender.h b/Engine/lib/sdl/src/render/SDL_sysrender.h
index 5bb98094e..5d92f6a26 100644
--- a/Engine/lib/sdl/src/render/SDL_sysrender.h
+++ b/Engine/lib/sdl/src/render/SDL_sysrender.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -43,7 +43,7 @@ struct SDL_Texture
     int modMode;                /**< The texture modulation mode */
     SDL_BlendMode blendMode;    /**< The texture blend mode */
     SDL_ScaleMode scaleMode;    /**< The texture scale mode */
-    Uint8 r, g, b, a;           /**< Texture modulation values */
+    SDL_Color color;            /**< Texture modulation values */
 
     SDL_Renderer *renderer;
 
@@ -58,6 +58,7 @@ struct SDL_Texture
     Uint32 last_command_generation; /* last command queue generation this texture was in. */
 
     void *driverdata;           /**< Driver specific texture representation */
+    void *userdata;
 
     SDL_Texture *prev;
     SDL_Texture *next;
@@ -74,7 +75,8 @@ typedef enum
     SDL_RENDERCMD_DRAW_LINES,
     SDL_RENDERCMD_FILL_RECTS,
     SDL_RENDERCMD_COPY,
-    SDL_RENDERCMD_COPY_EX
+    SDL_RENDERCMD_COPY_EX,
+    SDL_RENDERCMD_GEOMETRY
 } SDL_RenderCommandType;
 
 typedef struct SDL_RenderCommand
@@ -105,6 +107,21 @@ typedef struct SDL_RenderCommand
 } SDL_RenderCommand;
 
 
+typedef struct SDL_VertexSolid
+{
+    SDL_FPoint position;
+    SDL_Color  color;
+} SDL_VertexSolid;
+
+
+typedef enum
+{
+    SDL_RENDERLINEMETHOD_POINTS,
+    SDL_RENDERLINEMETHOD_LINES,
+    SDL_RENDERLINEMETHOD_GEOMETRY,
+} SDL_RenderLineMethod;
+
+
 /* Define the SDL renderer structure */
 struct SDL_Renderer
 {
@@ -126,16 +143,27 @@ struct SDL_Renderer
                        const SDL_Rect * srcrect, const SDL_FRect * dstrect);
     int (*QueueCopyEx) (SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture,
                         const SDL_Rect * srcquad, const SDL_FRect * dstrect,
-                        const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip);
+                        const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip, float scale_x, float scale_y);
+    int (*QueueGeometry) (SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+                          const float *xy, int xy_stride, const SDL_Color *color, int color_stride, const float *uv, int uv_stride,
+                          int num_vertices, const void *indices, int num_indices, int size_indices,
+                          float scale_x, float scale_y);
+
     int (*RunCommandQueue) (SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize);
     int (*UpdateTexture) (SDL_Renderer * renderer, SDL_Texture * texture,
                           const SDL_Rect * rect, const void *pixels,
                           int pitch);
+#if SDL_HAVE_YUV
     int (*UpdateTextureYUV) (SDL_Renderer * renderer, SDL_Texture * texture,
                             const SDL_Rect * rect,
                             const Uint8 *Yplane, int Ypitch,
                             const Uint8 *Uplane, int Upitch,
                             const Uint8 *Vplane, int Vpitch);
+    int (*UpdateTextureNV) (SDL_Renderer * renderer, SDL_Texture * texture,
+                            const SDL_Rect * rect,
+                            const Uint8 *Yplane, int Ypitch,
+                            const Uint8 *UVplane, int UVpitch);
+#endif
     int (*LockTexture) (SDL_Renderer * renderer, SDL_Texture * texture,
                         const SDL_Rect * rect, void **pixels, int *pitch);
     void (*UnlockTexture) (SDL_Renderer * renderer, SDL_Texture * texture);
@@ -148,6 +176,8 @@ struct SDL_Renderer
 
     void (*DestroyRenderer) (SDL_Renderer * renderer);
 
+    int (*SetVSync) (SDL_Renderer * renderer, int vsync);
+
     int (*GL_BindTexture) (SDL_Renderer * renderer, SDL_Texture *texture, float *texw, float *texh);
     int (*GL_UnbindTexture) (SDL_Renderer * renderer, SDL_Texture *texture);
 
@@ -171,12 +201,12 @@ struct SDL_Renderer
     SDL_bool integer_scale;
 
     /* The drawable area within the window */
-    SDL_Rect viewport;
-    SDL_Rect viewport_backup;
+    SDL_FRect viewport;
+    SDL_FRect viewport_backup;
 
     /* The clip rectangle within the window */
-    SDL_Rect clip_rect;
-    SDL_Rect clip_rect_backup;
+    SDL_FRect clip_rect;
+    SDL_FRect clip_rect_backup;
 
     /* Wether or not the clipping rectangle is used. */
     SDL_bool clipping_enabled;
@@ -192,6 +222,9 @@ struct SDL_Renderer
     /* Whether or not to scale relative mouse motion */
     SDL_bool relative_scaling;
 
+    /* The method of drawing lines */
+    SDL_RenderLineMethod line_method;
+
     /* Remainder from scaled relative motion */
     float xrel;
     float yrel;
@@ -201,7 +234,7 @@ struct SDL_Renderer
     SDL_Texture *target;
     SDL_mutex *target_mutex;
 
-    Uint8 r, g, b, a;                   /**< Color for drawing operations values */
+    SDL_Color color;                    /**< Color for drawing operations values */
     SDL_BlendMode blendMode;            /**< The drawing blend mode */
 
     SDL_bool always_batch;
@@ -211,8 +244,8 @@ struct SDL_Renderer
     SDL_RenderCommand *render_commands_pool;
     Uint32 render_command_generation;
     Uint32 last_queued_color;
-    SDL_Rect last_queued_viewport;
-    SDL_Rect last_queued_cliprect;
+    SDL_FRect last_queued_viewport;
+    SDL_FRect last_queued_cliprect;
     SDL_bool last_queued_cliprect_enabled;
     SDL_bool color_queued;
     SDL_bool viewport_queued;
@@ -244,6 +277,7 @@ extern SDL_RenderDriver DirectFB_RenderDriver;
 extern SDL_RenderDriver METAL_RenderDriver;
 extern SDL_RenderDriver PSP_RenderDriver;
 extern SDL_RenderDriver SW_RenderDriver;
+extern SDL_RenderDriver VITA_GXM_RenderDriver;
 
 /* Blend mode functions */
 extern SDL_BlendFactor SDL_GetBlendModeSrcColorFactor(SDL_BlendMode blendMode);
@@ -258,6 +292,9 @@ extern SDL_BlendOperation SDL_GetBlendModeAlphaOperation(SDL_BlendMode blendMode
    the next call, because it might be in an array that gets realloc()'d. */
 extern void *SDL_AllocateRenderVertices(SDL_Renderer *renderer, const size_t numbytes, const size_t alignment, size_t *offset);
 
+extern int SDL_PrivateLowerBlitScaled(SDL_Surface * src, SDL_Rect * srcrect, SDL_Surface * dst, SDL_Rect * dstrect, SDL_ScaleMode scaleMode);
+extern int SDL_PrivateUpperBlitScaled(SDL_Surface * src, const SDL_Rect * srcrect, SDL_Surface * dst, SDL_Rect * dstrect, SDL_ScaleMode scaleMode);
+
 #endif /* SDL_sysrender_h_ */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/render/SDL_yuv_sw.c b/Engine/lib/sdl/src/render/SDL_yuv_sw.c
index 11b8b4ad5..10fe54e69 100644
--- a/Engine/lib/sdl/src/render/SDL_yuv_sw.c
+++ b/Engine/lib/sdl/src/render/SDL_yuv_sw.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -26,6 +26,7 @@
 
 
 #include "SDL_yuv_sw_c.h"
+#include "SDL_cpuinfo.h"
 
 
 SDL_SW_YUVTexture *
@@ -84,7 +85,7 @@ SDL_SW_CreateYUVTexture(Uint32 format, int w, int h)
                 SDL_assert(0 && "We should never get here (caught above)");
                 break;
         }
-        swdata->pixels = (Uint8 *) SDL_malloc(dst_size);
+        swdata->pixels = (Uint8 *) SDL_SIMDAlloc(dst_size);
         if (!swdata->pixels) {
             SDL_SW_DestroyYUVTexture(swdata);
             SDL_OutOfMemory();
@@ -299,6 +300,40 @@ SDL_SW_UpdateYUVTexturePlanar(SDL_SW_YUVTexture * swdata, const SDL_Rect * rect,
     return 0;
 }
 
+int SDL_SW_UpdateNVTexturePlanar(SDL_SW_YUVTexture * swdata, const SDL_Rect * rect,
+                                  const Uint8 *Yplane, int Ypitch,
+                                  const Uint8 *UVplane, int UVpitch)
+{
+    const Uint8 *src;
+    Uint8 *dst;
+    int row;
+    size_t length;
+
+    /* Copy the Y plane */
+    src = Yplane;
+    dst = swdata->pixels + rect->y * swdata->w + rect->x;
+    length = rect->w;
+    for (row = 0; row < rect->h; ++row) {
+        SDL_memcpy(dst, src, length);
+        src += Ypitch;
+        dst += swdata->w;
+    }
+
+    /* Copy the UV or VU plane */
+    src = UVplane;
+    dst = swdata->pixels + swdata->h * swdata->w;
+    dst += rect->y * ((swdata->w + 1)/2) + rect->x;
+    length = (rect->w + 1) / 2;
+    length *= 2;
+    for (row = 0; row < (rect->h + 1)/2; ++row) {
+        SDL_memcpy(dst, src, length);
+        src += UVpitch;
+        dst += 2 * ((swdata->w + 1)/2);
+    }
+
+    return 0;
+}
+
 int
 SDL_SW_LockYUVTexture(SDL_SW_YUVTexture * swdata, const SDL_Rect * rect,
                       void **pixels, int *pitch)
@@ -405,7 +440,7 @@ void
 SDL_SW_DestroyYUVTexture(SDL_SW_YUVTexture * swdata)
 {
     if (swdata) {
-        SDL_free(swdata->pixels);
+        SDL_SIMDFree(swdata->pixels);
         SDL_FreeSurface(swdata->stretch);
         SDL_FreeSurface(swdata->display);
         SDL_free(swdata);
diff --git a/Engine/lib/sdl/src/render/SDL_yuv_sw_c.h b/Engine/lib/sdl/src/render/SDL_yuv_sw_c.h
index 75c6f273e..8d9dc79cd 100644
--- a/Engine/lib/sdl/src/render/SDL_yuv_sw_c.h
+++ b/Engine/lib/sdl/src/render/SDL_yuv_sw_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -55,6 +55,9 @@ int SDL_SW_UpdateYUVTexturePlanar(SDL_SW_YUVTexture * swdata, const SDL_Rect * r
                                   const Uint8 *Yplane, int Ypitch,
                                   const Uint8 *Uplane, int Upitch,
                                   const Uint8 *Vplane, int Vpitch);
+int SDL_SW_UpdateNVTexturePlanar(SDL_SW_YUVTexture * swdata, const SDL_Rect * rect,
+                                  const Uint8 *Yplane, int Ypitch,
+                                  const Uint8 *UVplane, int UVpitch);
 int SDL_SW_LockYUVTexture(SDL_SW_YUVTexture * swdata, const SDL_Rect * rect,
                           void **pixels, int *pitch);
 void SDL_SW_UnlockYUVTexture(SDL_SW_YUVTexture * swdata);
@@ -63,11 +66,6 @@ int SDL_SW_CopyYUVToRGB(SDL_SW_YUVTexture * swdata, const SDL_Rect * srcrect,
                         int pitch);
 void SDL_SW_DestroyYUVTexture(SDL_SW_YUVTexture * swdata);
 
-/* FIXME: This breaks on various versions of GCC and should be rewritten using intrinsics */
-#if 0 /* (__GNUC__ > 2) && defined(__i386__) && __OPTIMIZE__ && SDL_ASSEMBLY_ROUTINES && !defined(__clang__) */
-#define USE_MMX_ASSEMBLY 1
-#endif
-
 #endif /* SDL_yuv_sw_c_h_ */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/render/direct3d/SDL_render_d3d.c b/Engine/lib/sdl/src/render/direct3d/SDL_render_d3d.c
index 709409157..b267fb23e 100644
--- a/Engine/lib/sdl/src/render/direct3d/SDL_render_d3d.c
+++ b/Engine/lib/sdl/src/render/direct3d/SDL_render_d3d.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -51,7 +51,6 @@ typedef struct
     SDL_bool cliprect_enabled_dirty;
     SDL_Rect cliprect;
     SDL_bool cliprect_dirty;
-    SDL_bool is_copy_ex;
     LPDIRECT3DPIXELSHADER9 shader;
 } D3D_DrawStateCache;
 
@@ -72,7 +71,9 @@ typedef struct
     IDirect3DSurface9 *defaultRenderTarget;
     IDirect3DSurface9 *currentRenderTarget;
     void* d3dxDLL;
+#if SDL_HAVE_YUV
     LPDIRECT3DPIXELSHADER9 shaders[NUM_SHADERS];
+#endif
     LPDIRECT3DVERTEXBUFFER9 vertexBuffers[8];
     size_t vertexBufferSize[8];
     int currentVertexBuffer;
@@ -96,6 +97,7 @@ typedef struct
     D3D_TextureRep texture;
     D3DTEXTUREFILTERTYPE scaleMode;
 
+#if SDL_HAVE_YUV
     /* YV12 texture support */
     SDL_bool yuv;
     D3D_TextureRep utexture;
@@ -103,6 +105,7 @@ typedef struct
     Uint8 *pixels;
     int pitch;
     SDL_Rect locked_rect;
+#endif
 } D3D_TextureData;
 
 typedef struct
@@ -535,7 +538,7 @@ D3D_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
     if (D3D_CreateTextureRep(data->device, &texturedata->texture, usage, texture->format, PixelFormatToD3DFMT(texture->format), texture->w, texture->h) < 0) {
         return -1;
     }
-
+#if SDL_HAVE_YUV
     if (texture->format == SDL_PIXELFORMAT_YV12 ||
         texture->format == SDL_PIXELFORMAT_IYUV) {
         texturedata->yuv = SDL_TRUE;
@@ -548,6 +551,7 @@ D3D_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
             return -1;
         }
     }
+#endif
     return 0;
 }
 
@@ -564,7 +568,7 @@ D3D_RecreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
     if (D3D_RecreateTextureRep(data->device, &texturedata->texture) < 0) {
         return -1;
     }
-
+#if SDL_HAVE_YUV
     if (texturedata->yuv) {
         if (D3D_RecreateTextureRep(data->device, &texturedata->utexture) < 0) {
             return -1;
@@ -574,6 +578,7 @@ D3D_RecreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
             return -1;
         }
     }
+#endif
     return 0;
 }
 
@@ -585,14 +590,13 @@ D3D_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
     D3D_TextureData *texturedata = (D3D_TextureData *) texture->driverdata;
 
     if (!texturedata) {
-        SDL_SetError("Texture is not currently available");
-        return -1;
+        return SDL_SetError("Texture is not currently available");
     }
 
     if (D3D_UpdateTextureRep(data->device, &texturedata->texture, rect->x, rect->y, rect->w, rect->h, pixels, pitch) < 0) {
         return -1;
     }
-
+#if SDL_HAVE_YUV
     if (texturedata->yuv) {
         /* Skip to the correct offset into the next texture */
         pixels = (const void*)((const Uint8*)pixels + rect->h * pitch);
@@ -607,9 +611,11 @@ D3D_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
             return -1;
         }
     }
+#endif
     return 0;
 }
 
+#if SDL_HAVE_YUV
 static int
 D3D_UpdateTextureYUV(SDL_Renderer * renderer, SDL_Texture * texture,
                      const SDL_Rect * rect,
@@ -621,8 +627,7 @@ D3D_UpdateTextureYUV(SDL_Renderer * renderer, SDL_Texture * texture,
     D3D_TextureData *texturedata = (D3D_TextureData *) texture->driverdata;
 
     if (!texturedata) {
-        SDL_SetError("Texture is not currently available");
-        return -1;
+        return SDL_SetError("Texture is not currently available");
     }
 
     if (D3D_UpdateTextureRep(data->device, &texturedata->texture, rect->x, rect->y, rect->w, rect->h, Yplane, Ypitch) < 0) {
@@ -636,6 +641,7 @@ D3D_UpdateTextureYUV(SDL_Renderer * renderer, SDL_Texture * texture,
     }
     return 0;
 }
+#endif
 
 static int
 D3D_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
@@ -646,10 +652,9 @@ D3D_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
     IDirect3DDevice9 *device = data->device;
 
     if (!texturedata) {
-        SDL_SetError("Texture is not currently available");
-        return -1;
+        return SDL_SetError("Texture is not currently available");
     }
-
+#if SDL_HAVE_YUV
     texturedata->locked_rect = *rect;
 
     if (texturedata->yuv) {
@@ -665,7 +670,9 @@ D3D_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
             (void *) ((Uint8 *) texturedata->pixels + rect->y * texturedata->pitch +
                       rect->x * SDL_BYTESPERPIXEL(texture->format));
         *pitch = texturedata->pitch;
-    } else {
+    } else
+#endif
+    {
         RECT d3drect;
         D3DLOCKED_RECT locked;
         HRESULT result;
@@ -698,14 +705,17 @@ D3D_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
     if (!texturedata) {
         return;
     }
-
+#if SDL_HAVE_YUV
     if (texturedata->yuv) {
         const SDL_Rect *rect = &texturedata->locked_rect;
         void *pixels =
             (void *) ((Uint8 *) texturedata->pixels + rect->y * texturedata->pitch +
                       rect->x * SDL_BYTESPERPIXEL(texture->format));
         D3D_UpdateTexture(renderer, texture, rect, pixels, texturedata->pitch);
-    } else {
+    }
+    else
+#endif
+    {
         IDirect3DTexture9_UnlockRect(texturedata->texture.staging, 0);
         texturedata->texture.dirty = SDL_TRUE;
         if (data->drawstate.texture == texture) {
@@ -713,10 +723,6 @@ D3D_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
             data->drawstate.shader = NULL;
             IDirect3DDevice9_SetPixelShader(data->device, NULL);
             IDirect3DDevice9_SetTexture(data->device, 0, NULL);
-            if (texturedata->yuv) {
-                IDirect3DDevice9_SetTexture(data->device, 1, NULL);
-                IDirect3DDevice9_SetTexture(data->device, 2, NULL);
-            }
         }
     }
 }
@@ -755,8 +761,7 @@ D3D_SetRenderTargetInternal(SDL_Renderer * renderer, SDL_Texture * texture)
 
     texturedata = (D3D_TextureData *)texture->driverdata;
     if (!texturedata) {
-        SDL_SetError("Texture is not currently available");
-        return -1;
+        return SDL_SetError("Texture is not currently available");
     }
 
     /* Make sure the render target is updated if it was locked and written to */
@@ -831,190 +836,55 @@ D3D_QueueDrawPoints(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_F
 }
 
 static int
-D3D_QueueFillRects(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FRect * rects, int count)
+D3D_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+        const float *xy, int xy_stride, const SDL_Color *color, int color_stride, const float *uv, int uv_stride,
+        int num_vertices, const void *indices, int num_indices, int size_indices,
+        float scale_x, float scale_y)
 {
-    const DWORD color = D3DCOLOR_ARGB(cmd->data.draw.a, cmd->data.draw.r, cmd->data.draw.g, cmd->data.draw.b);
-    const size_t vertslen = count * sizeof (Vertex) * 4;
-    Vertex *verts = (Vertex *) SDL_AllocateRenderVertices(renderer, vertslen, 0, &cmd->data.draw.first);
     int i;
+    int count = indices ? num_indices : num_vertices;
+    Vertex *verts = (Vertex *) SDL_AllocateRenderVertices(renderer, count * sizeof (Vertex), 0, &cmd->data.draw.first);
 
     if (!verts) {
         return -1;
     }
 
-    SDL_memset(verts, '\0', vertslen);
     cmd->data.draw.count = count;
+    size_indices = indices ? size_indices : 0;
 
     for (i = 0; i < count; i++) {
-        const SDL_FRect *rect = &rects[i];
-        const float minx = rect->x;
-        const float maxx = rect->x + rect->w;
-        const float miny = rect->y;
-        const float maxy = rect->y + rect->h;
+        int j;
+        float *xy_;
+        SDL_Color col_;
+        if (size_indices == 4) {
+            j = ((const Uint32 *)indices)[i];
+        } else if (size_indices == 2) {
+            j = ((const Uint16 *)indices)[i];
+        } else if (size_indices == 1) {
+            j = ((const Uint8 *)indices)[i];
+        } else {
+            j = i;
+        }
 
-        verts->x = minx;
-        verts->y = miny;
-        verts->color = color;
-        verts++;
+        xy_ = (float *)((char*)xy + j * xy_stride);
+        col_ = *(SDL_Color *)((char*)color + j * color_stride);
 
-        verts->x = maxx;
-        verts->y = miny;
-        verts->color = color;
-        verts++;
+        verts->x = xy_[0] * scale_x - 0.5f;
+        verts->y = xy_[1] * scale_y - 0.5f;
+        verts->z = 0.0f;
+        verts->color = D3DCOLOR_ARGB(col_.a, col_.r, col_.g, col_.b);
 
-        verts->x = maxx;
-        verts->y = maxy;
-        verts->color = color;
-        verts++;
+        if (texture) {
+            float *uv_ = (float *)((char*)uv + j * uv_stride);
+            verts->u = uv_[0];
+            verts->v = uv_[1];
+        } else {
+            verts->u = 0.0f;
+            verts->v = 0.0f;
+        }
 
-        verts->x = minx;
-        verts->y = maxy;
-        verts->color = color;
-        verts++;
+        verts += 1;
     }
-
-    return 0;
-}
-
-static int
-D3D_QueueCopy(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture,
-                          const SDL_Rect * srcrect, const SDL_FRect * dstrect)
-{
-    const DWORD color = D3DCOLOR_ARGB(cmd->data.draw.a, cmd->data.draw.r, cmd->data.draw.g, cmd->data.draw.b);
-    float minx, miny, maxx, maxy;
-    float minu, maxu, minv, maxv;
-    const size_t vertslen = sizeof (Vertex) * 4;
-    Vertex *verts = (Vertex *) SDL_AllocateRenderVertices(renderer, vertslen, 0, &cmd->data.draw.first);
-
-    if (!verts) {
-        return -1;
-    }
-
-    cmd->data.draw.count = 1;
-
-    minx = dstrect->x - 0.5f;
-    miny = dstrect->y - 0.5f;
-    maxx = dstrect->x + dstrect->w - 0.5f;
-    maxy = dstrect->y + dstrect->h - 0.5f;
-
-    minu = (float) srcrect->x / texture->w;
-    maxu = (float) (srcrect->x + srcrect->w) / texture->w;
-    minv = (float) srcrect->y / texture->h;
-    maxv = (float) (srcrect->y + srcrect->h) / texture->h;
-
-    verts->x = minx;
-    verts->y = miny;
-    verts->z = 0.0f;
-    verts->color = color;
-    verts->u = minu;
-    verts->v = minv;
-    verts++;
-
-    verts->x = maxx;
-    verts->y = miny;
-    verts->z = 0.0f;
-    verts->color = color;
-    verts->u = maxu;
-    verts->v = minv;
-    verts++;
-
-    verts->x = maxx;
-    verts->y = maxy;
-    verts->z = 0.0f;
-    verts->color = color;
-    verts->u = maxu;
-    verts->v = maxv;
-    verts++;
-
-    verts->x = minx;
-    verts->y = maxy;
-    verts->z = 0.0f;
-    verts->color = color;
-    verts->u = minu;
-    verts->v = maxv;
-    verts++;
-
-    return 0;
-}
-
-static int
-D3D_QueueCopyEx(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture,
-                        const SDL_Rect * srcquad, const SDL_FRect * dstrect,
-                        const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip)
-{
-    const DWORD color = D3DCOLOR_ARGB(cmd->data.draw.a, cmd->data.draw.r, cmd->data.draw.g, cmd->data.draw.b);
-    float minx, miny, maxx, maxy;
-    float minu, maxu, minv, maxv;
-    const size_t vertslen = sizeof (Vertex) * 5;
-    Vertex *verts = (Vertex *) SDL_AllocateRenderVertices(renderer, vertslen, 0, &cmd->data.draw.first);
-
-    if (!verts) {
-        return -1;
-    }
-
-    cmd->data.draw.count = 1;
-
-    minx = -center->x;
-    maxx = dstrect->w - center->x;
-    miny = -center->y;
-    maxy = dstrect->h - center->y;
-
-    if (flip & SDL_FLIP_HORIZONTAL) {
-        minu = (float) (srcquad->x + srcquad->w) / texture->w;
-        maxu = (float) srcquad->x / texture->w;
-    } else {
-        minu = (float) srcquad->x / texture->w;
-        maxu = (float) (srcquad->x + srcquad->w) / texture->w;
-    }
-
-    if (flip & SDL_FLIP_VERTICAL) {
-        minv = (float) (srcquad->y + srcquad->h) / texture->h;
-        maxv = (float) srcquad->y / texture->h;
-    } else {
-        minv = (float) srcquad->y / texture->h;
-        maxv = (float) (srcquad->y + srcquad->h) / texture->h;
-    }
-
-    verts->x = minx;
-    verts->y = miny;
-    verts->z = 0.0f;
-    verts->color = color;
-    verts->u = minu;
-    verts->v = minv;
-    verts++;
-
-    verts->x = maxx;
-    verts->y = miny;
-    verts->z = 0.0f;
-    verts->color = color;
-    verts->u = maxu;
-    verts->v = minv;
-    verts++;
-
-    verts->x = maxx;
-    verts->y = maxy;
-    verts->z = 0.0f;
-    verts->color = color;
-    verts->u = maxu;
-    verts->v = maxv;
-    verts++;
-
-    verts->x = minx;
-    verts->y = maxy;
-    verts->z = 0.0f;
-    verts->color = color;
-    verts->u = minu;
-    verts->v = maxv;
-    verts++;
-
-    verts->x = dstrect->x + center->x - 0.5f;  /* X translation */
-    verts->y = dstrect->y + center->y - 0.5f;  /* Y translation */
-    verts->z = (float)(M_PI * (float) angle / 180.0f);  /* rotation */
-    verts->color = 0;
-    verts->u = 0.0f;
-    verts->v = 0.0f;
-    verts++;
-
     return 0;
 }
 
@@ -1076,8 +946,7 @@ SetupTextureState(D3D_RenderData *data, SDL_Texture * texture, LPDIRECT3DPIXELSH
     SDL_assert(*shader == NULL);
 
     if (!texturedata) {
-        SDL_SetError("Texture is not currently available");
-        return -1;
+        return SDL_SetError("Texture is not currently available");
     }
 
     UpdateTextureScaleMode(data, texturedata, 0);
@@ -1085,7 +954,7 @@ SetupTextureState(D3D_RenderData *data, SDL_Texture * texture, LPDIRECT3DPIXELSH
     if (BindTextureRep(data->device, &texturedata->texture, 0) < 0) {
         return -1;
     }
-
+#if SDL_HAVE_YUV
     if (texturedata->yuv) {
         switch (SDL_GetYUVConversionModeForResolution(texture->w, texture->h)) {
         case SDL_YUV_CONVERSION_JPEG:
@@ -1111,30 +980,33 @@ SetupTextureState(D3D_RenderData *data, SDL_Texture * texture, LPDIRECT3DPIXELSH
             return -1;
         }
     }
+#endif
     return 0;
 }
 
 static int
 SetDrawState(D3D_RenderData *data, const SDL_RenderCommand *cmd)
 {
-    const SDL_bool was_copy_ex = data->drawstate.is_copy_ex;
-    const SDL_bool is_copy_ex = (cmd->command == SDL_RENDERCMD_COPY_EX);
     SDL_Texture *texture = cmd->data.draw.texture;
     const SDL_BlendMode blend = cmd->data.draw.blend;
 
     if (texture != data->drawstate.texture) {
+#if SDL_HAVE_YUV
         D3D_TextureData *oldtexturedata = data->drawstate.texture ? (D3D_TextureData *) data->drawstate.texture->driverdata : NULL;
         D3D_TextureData *newtexturedata = texture ? (D3D_TextureData *) texture->driverdata : NULL;
+#endif
         LPDIRECT3DPIXELSHADER9 shader = NULL;
 
         /* disable any enabled textures we aren't going to use, let SetupTextureState() do the rest. */
         if (texture == NULL) {
             IDirect3DDevice9_SetTexture(data->device, 0, NULL);
         }
+#if SDL_HAVE_YUV
         if ((!newtexturedata || !newtexturedata->yuv) && (oldtexturedata && oldtexturedata->yuv)) {
             IDirect3DDevice9_SetTexture(data->device, 1, NULL);
             IDirect3DDevice9_SetTexture(data->device, 2, NULL);
         }
+#endif
         if (texture && SetupTextureState(data, texture, &shader) < 0) {
             return -1;
         }
@@ -1151,10 +1023,12 @@ SetDrawState(D3D_RenderData *data, const SDL_RenderCommand *cmd)
     } else if (texture) {
         D3D_TextureData *texturedata = (D3D_TextureData *) texture->driverdata;
         UpdateDirtyTexture(data->device, &texturedata->texture);
+#if SDL_HAVE_YUV
         if (texturedata->yuv) {
             UpdateDirtyTexture(data->device, &texturedata->utexture);
             UpdateDirtyTexture(data->device, &texturedata->vtexture);
         }
+#endif
     }
 
     if (blend != data->drawstate.blend) {
@@ -1177,14 +1051,6 @@ SetDrawState(D3D_RenderData *data, const SDL_RenderCommand *cmd)
         data->drawstate.blend = blend;
     }
 
-    if (is_copy_ex != was_copy_ex) {
-        if (!is_copy_ex) {  /* SDL_RENDERCMD_COPY_EX will set this, we only want to reset it here if necessary. */
-            const Float4X4 d3dmatrix = MatrixIdentity();
-            IDirect3DDevice9_SetTransform(data->device, D3DTS_VIEW, (D3DMATRIX*) &d3dmatrix);
-        }
-        data->drawstate.is_copy_ex = is_copy_ex;
-    }
-
     if (data->drawstate.viewport_dirty) {
         const SDL_Rect *viewport = &data->drawstate.viewport;
         const D3DVIEWPORT9 d3dviewport = { viewport->x, viewport->y, viewport->w, viewport->h, 0.0f, 1.0f };
@@ -1229,52 +1095,53 @@ D3D_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *verti
     const int vboidx = data->currentVertexBuffer;
     IDirect3DVertexBuffer9 *vbo = NULL;
     const SDL_bool istarget = renderer->target != NULL;
-    size_t i;
 
     if (D3D_ActivateRenderer(renderer) < 0) {
         return -1;
     }
 
-    /* upload the new VBO data for this set of commands. */
-    vbo = data->vertexBuffers[vboidx];
-    if (data->vertexBufferSize[vboidx] < vertsize) {
-        const DWORD usage = D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY;
-        const DWORD fvf = D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1;
+    if (vertices) {
+        /* upload the new VBO data for this set of commands. */
+        vbo = data->vertexBuffers[vboidx];
+        if (data->vertexBufferSize[vboidx] < vertsize) {
+            const DWORD usage = D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY;
+            const DWORD fvf = D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1;
+            if (vbo) {
+                IDirect3DVertexBuffer9_Release(vbo);
+            }
+
+            if (FAILED(IDirect3DDevice9_CreateVertexBuffer(data->device, (UINT) vertsize, usage, fvf, D3DPOOL_DEFAULT, &vbo, NULL))) {
+                vbo = NULL;
+            }
+            data->vertexBuffers[vboidx] = vbo;
+            data->vertexBufferSize[vboidx] = vbo ? vertsize : 0;
+        }
+
         if (vbo) {
-            IDirect3DVertexBuffer9_Release(vbo);
-        }
-
-        if (FAILED(IDirect3DDevice9_CreateVertexBuffer(data->device, (UINT) vertsize, usage, fvf, D3DPOOL_DEFAULT, &vbo, NULL))) {
-            vbo = NULL;
-        }
-        data->vertexBuffers[vboidx] = vbo;
-        data->vertexBufferSize[vboidx] = vbo ? vertsize : 0;
-    }
-
-    if (vbo) {
-        void *ptr;
-        if (FAILED(IDirect3DVertexBuffer9_Lock(vbo, 0, (UINT) vertsize, &ptr, D3DLOCK_DISCARD))) {
-            vbo = NULL;  /* oh well, we'll do immediate mode drawing.  :(  */
-        } else {
-            SDL_memcpy(ptr, vertices, vertsize);
-            if (FAILED(IDirect3DVertexBuffer9_Unlock(vbo))) {
+            void *ptr;
+            if (FAILED(IDirect3DVertexBuffer9_Lock(vbo, 0, (UINT) vertsize, &ptr, D3DLOCK_DISCARD))) {
                 vbo = NULL;  /* oh well, we'll do immediate mode drawing.  :(  */
+            } else {
+                SDL_memcpy(ptr, vertices, vertsize);
+                if (FAILED(IDirect3DVertexBuffer9_Unlock(vbo))) {
+                    vbo = NULL;  /* oh well, we'll do immediate mode drawing.  :(  */
+                }
             }
         }
-    }
 
-    /* cycle through a few VBOs so D3D has some time with the data before we replace it. */
-    if (vbo) {
-        data->currentVertexBuffer++;
-        if (data->currentVertexBuffer >= SDL_arraysize(data->vertexBuffers)) {
-            data->currentVertexBuffer = 0;
+        /* cycle through a few VBOs so D3D has some time with the data before we replace it. */
+        if (vbo) {
+            data->currentVertexBuffer++;
+            if (data->currentVertexBuffer >= SDL_arraysize(data->vertexBuffers)) {
+                data->currentVertexBuffer = 0;
+            }
+        } else if (!data->reportedVboProblem) {
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "SDL failed to get a vertex buffer for this Direct3D 9 rendering batch!");
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "Dropping back to a slower method.");
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "This might be a brief hiccup, but if performance is bad, this is probably why.");
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "This error will not be logged again for this renderer.");
+            data->reportedVboProblem = SDL_TRUE;
         }
-    } else if (!data->reportedVboProblem) {
-        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "SDL failed to get a vertex buffer for this Direct3D 9 rendering batch!");
-        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "Dropping back to a slower method.");
-        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "This might be a brief hiccup, but if performance is bad, this is probably why.");
-        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "This error will not be logged again for this renderer.");
-        data->reportedVboProblem = SDL_TRUE;
     }
 
     IDirect3DDevice9_SetStreamSource(data->device, 0, vbo, 0, sizeof (Vertex));
@@ -1316,20 +1183,21 @@ D3D_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *verti
                 const SDL_Rect *viewport = &data->drawstate.viewport;
                 const int backw = istarget ? renderer->target->w : data->pparams.BackBufferWidth;
                 const int backh = istarget ? renderer->target->h : data->pparams.BackBufferHeight;
+                const SDL_bool viewport_equal = ((viewport->x == 0) && (viewport->y == 0) && (viewport->w == backw) && (viewport->h == backh)) ? SDL_TRUE : SDL_FALSE;
 
-                if (data->drawstate.cliprect_enabled) {
+                if (data->drawstate.cliprect_enabled || data->drawstate.cliprect_enabled_dirty) {
                     IDirect3DDevice9_SetRenderState(data->device, D3DRS_SCISSORTESTENABLE, FALSE);
-                    data->drawstate.cliprect_enabled_dirty = SDL_TRUE;
+                    data->drawstate.cliprect_enabled_dirty = data->drawstate.cliprect_enabled;
                 }
 
                 /* Don't reset the viewport if we don't have to! */
-                if (!viewport->x && !viewport->y && (viewport->w == backw) && (viewport->h == backh)) {
+                if (!data->drawstate.viewport_dirty && viewport_equal) {
                     IDirect3DDevice9_Clear(data->device, 0, NULL, D3DCLEAR_TARGET, color, 0.0f, 0);
                 } else {
                     /* Clear is defined to clear the entire render target */
                     const D3DVIEWPORT9 wholeviewport = { 0, 0, backw, backh, 0.0f, 1.0f };
                     IDirect3DDevice9_SetViewport(data->device, &wholeviewport);
-                    data->drawstate.viewport_dirty = SDL_TRUE;
+                    data->drawstate.viewport_dirty = SDL_TRUE;  /* we still need to (re)set orthographic projection, so always mark it dirty. */
                     IDirect3DDevice9_Clear(data->device, 0, NULL, D3DCLEAR_TARGET, color, 0.0f, 0);
                 }
 
@@ -1374,58 +1242,24 @@ D3D_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *verti
                 break;
             }
 
-            case SDL_RENDERCMD_FILL_RECTS: {
+            case SDL_RENDERCMD_FILL_RECTS: /* unused */
+                break;
+
+            case SDL_RENDERCMD_COPY: /* unused */
+                break;
+
+            case SDL_RENDERCMD_COPY_EX: /* unused */
+                break;
+
+            case SDL_RENDERCMD_GEOMETRY: {
                 const size_t count = cmd->data.draw.count;
                 const size_t first = cmd->data.draw.first;
                 SetDrawState(data, cmd);
                 if (vbo) {
-                    size_t offset = 0;
-                    for (i = 0; i < count; ++i, offset += 4) {
-                        IDirect3DDevice9_DrawPrimitive(data->device, D3DPT_TRIANGLEFAN, (UINT) ((first / sizeof (Vertex)) + offset), 2);
-                    }
+                    IDirect3DDevice9_DrawPrimitive(data->device, D3DPT_TRIANGLELIST, (UINT) (first / sizeof (Vertex)), (UINT) count / 3);
                 } else {
-                    const Vertex *verts = (Vertex *) (((Uint8 *) vertices) + first);
-                    for (i = 0; i < count; ++i, verts += 4) {
-                        IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_TRIANGLEFAN, 2, verts, sizeof (Vertex));
-                    }
-                }
-                break;
-            }
-
-            case SDL_RENDERCMD_COPY: {
-                const size_t count = cmd->data.draw.count;
-                const size_t first = cmd->data.draw.first;
-                SetDrawState(data, cmd);
-                if (vbo) {
-                    size_t offset = 0;
-                    for (i = 0; i < count; ++i, offset += 4) {
-                        IDirect3DDevice9_DrawPrimitive(data->device, D3DPT_TRIANGLEFAN, (UINT) ((first / sizeof (Vertex)) + offset), 2);
-                    }
-                } else {
-                    const Vertex *verts = (Vertex *) (((Uint8 *) vertices) + first);
-                    for (i = 0; i < count; ++i, verts += 4) {
-                        IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_TRIANGLEFAN, 2, verts, sizeof (Vertex));
-                    }
-                }
-                break;
-            }
-
-            case SDL_RENDERCMD_COPY_EX: {
-                const size_t first = cmd->data.draw.first;
-                const Vertex *verts = (Vertex *) (((Uint8 *) vertices) + first);
-                const Vertex *transvert = verts + 4;
-                const float translatex = transvert->x;
-                const float translatey = transvert->y;
-                const float rotation = transvert->z;
-                const Float4X4 d3dmatrix = MatrixMultiply(MatrixRotationZ(rotation), MatrixTranslation(translatex, translatey, 0));
-                SetDrawState(data, cmd);
-
-                IDirect3DDevice9_SetTransform(data->device, D3DTS_VIEW, (D3DMATRIX*)&d3dmatrix);
-
-                if (vbo) {
-                    IDirect3DDevice9_DrawPrimitive(data->device, D3DPT_TRIANGLEFAN, (UINT) (first / sizeof (Vertex)), 2);
-                } else {
-                    IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_TRIANGLEFAN, 2, verts, sizeof (Vertex));
+                    const Vertex* verts = (Vertex*)(((Uint8*)vertices) + first);
+                    IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_TRIANGLELIST, (UINT) count / 3, verts, sizeof(Vertex));
                 }
                 break;
             }
@@ -1452,6 +1286,7 @@ D3D_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
     RECT d3drect;
     D3DLOCKED_RECT locked;
     HRESULT result;
+    int status;
 
     if (data->currentRenderTarget) {
         backBuffer = data->currentRenderTarget;
@@ -1486,7 +1321,7 @@ D3D_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
         return D3D_SetError("LockRect()", result);
     }
 
-    SDL_ConvertPixels(rect->w, rect->h,
+    status = SDL_ConvertPixels(rect->w, rect->h,
                       D3DFMTToPixelFormat(desc.Format), locked.pBits, locked.Pitch,
                       format, pixels, pitch);
 
@@ -1494,7 +1329,7 @@ D3D_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
 
     IDirect3DSurface9_Release(surface);
 
-    return 0;
+    return status;
 }
 
 static void
@@ -1533,10 +1368,12 @@ D3D_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
         renderdata->drawstate.shader = NULL;
         IDirect3DDevice9_SetPixelShader(renderdata->device, NULL);
         IDirect3DDevice9_SetTexture(renderdata->device, 0, NULL);
+#if SDL_HAVE_YUV
         if (data->yuv) {
             IDirect3DDevice9_SetTexture(renderdata->device, 1, NULL);
             IDirect3DDevice9_SetTexture(renderdata->device, 2, NULL);
         }
+#endif
     }
 
     if (!data) {
@@ -1544,9 +1381,11 @@ D3D_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
     }
 
     D3D_DestroyTextureRep(&data->texture);
+#if SDL_HAVE_YUV
     D3D_DestroyTextureRep(&data->utexture);
     D3D_DestroyTextureRep(&data->vtexture);
     SDL_free(data->pixels);
+#endif
     SDL_free(data);
     texture->driverdata = NULL;
 }
@@ -1568,12 +1407,14 @@ D3D_DestroyRenderer(SDL_Renderer * renderer)
             IDirect3DSurface9_Release(data->currentRenderTarget);
             data->currentRenderTarget = NULL;
         }
+#if SDL_HAVE_YUV
         for (i = 0; i < SDL_arraysize(data->shaders); ++i) {
             if (data->shaders[i]) {
                 IDirect3DPixelShader9_Release(data->shaders[i]);
                 data->shaders[i] = NULL;
             }
         }
+#endif
         /* Release all vertex buffers */
         for (i = 0; i < SDL_arraysize(data->vertexBuffers); ++i) {
             if (data->vertexBuffers[i]) {
@@ -1603,6 +1444,12 @@ D3D_Reset(SDL_Renderer * renderer)
     SDL_Texture *texture;
     int i;
 
+    /* Cancel any scene that we've started */
+    if (!data->beginScene) {
+        IDirect3DDevice9_EndScene(data->device);
+        data->beginScene = SDL_TRUE;
+    }
+
     /* Release the default render target before reset */
     if (data->defaultRenderTarget) {
         IDirect3DSurface9_Release(data->defaultRenderTarget);
@@ -1657,7 +1504,6 @@ D3D_Reset(SDL_Renderer * renderer)
     data->drawstate.texture = NULL;
     data->drawstate.shader = NULL;
     data->drawstate.blend = SDL_BLENDMODE_INVALID;
-    data->drawstate.is_copy_ex = SDL_FALSE;
     IDirect3DDevice9_SetTransform(data->device, D3DTS_VIEW, (D3DMATRIX*)&d3dmatrix);
 
     /* Let the application know that render targets were reset */
@@ -1670,6 +1516,24 @@ D3D_Reset(SDL_Renderer * renderer)
     return 0;
 }
 
+static int
+D3D_SetVSync(SDL_Renderer * renderer, const int vsync)
+{
+    D3D_RenderData *data = renderer->driverdata;
+    if (vsync) {
+        data->pparams.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
+        renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
+    } else {
+        data->pparams.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
+        renderer->info.flags &= ~SDL_RENDERER_PRESENTVSYNC;
+    }
+    if (D3D_Reset(renderer) < 0) {
+        /* D3D_Reset will call SDL_SetError() */
+        return -1;
+    }
+    return 0;
+}
+
 SDL_Renderer *
 D3D_CreateRenderer(SDL_Window * window, Uint32 flags)
 {
@@ -1710,7 +1574,9 @@ D3D_CreateRenderer(SDL_Window * window, Uint32 flags)
     renderer->SupportsBlendMode = D3D_SupportsBlendMode;
     renderer->CreateTexture = D3D_CreateTexture;
     renderer->UpdateTexture = D3D_UpdateTexture;
+#if SDL_HAVE_YUV
     renderer->UpdateTextureYUV = D3D_UpdateTextureYUV;
+#endif
     renderer->LockTexture = D3D_LockTexture;
     renderer->UnlockTexture = D3D_UnlockTexture;
     renderer->SetTextureScaleMode = D3D_SetTextureScaleMode;
@@ -1719,14 +1585,13 @@ D3D_CreateRenderer(SDL_Window * window, Uint32 flags)
     renderer->QueueSetDrawColor = D3D_QueueSetViewport;  /* SetViewport and SetDrawColor are (currently) no-ops. */
     renderer->QueueDrawPoints = D3D_QueueDrawPoints;
     renderer->QueueDrawLines = D3D_QueueDrawPoints;  /* lines and points queue vertices the same way. */
-    renderer->QueueFillRects = D3D_QueueFillRects;
-    renderer->QueueCopy = D3D_QueueCopy;
-    renderer->QueueCopyEx = D3D_QueueCopyEx;
+    renderer->QueueGeometry = D3D_QueueGeometry;
     renderer->RunCommandQueue = D3D_RunCommandQueue;
     renderer->RenderReadPixels = D3D_RenderReadPixels;
     renderer->RenderPresent = D3D_RenderPresent;
     renderer->DestroyTexture = D3D_DestroyTexture;
     renderer->DestroyRenderer = D3D_DestroyRenderer;
+    renderer->SetVSync = D3D_SetVSync;
     renderer->info = D3D_RenderDriver.info;
     renderer->info.flags = (SDL_RENDERER_ACCELERATED | SDL_RENDERER_TARGETTEXTURE);
     renderer->driverdata = data;
@@ -1811,9 +1676,6 @@ D3D_CreateRenderer(SDL_Window * window, Uint32 flags)
     IDirect3DDevice9_GetDeviceCaps(data->device, &caps);
     renderer->info.max_texture_width = caps.MaxTextureWidth;
     renderer->info.max_texture_height = caps.MaxTextureHeight;
-    if (caps.NumSimultaneousRTs >= 2) {
-        renderer->info.flags |= SDL_RENDERER_TARGETTEXTURE;
-    }
 
     if (caps.PrimitiveMiscCaps & D3DPMISCCAPS_SEPARATEALPHABLEND) {
         data->enableSeparateAlphaBlend = SDL_TRUE;
@@ -1825,7 +1687,7 @@ D3D_CreateRenderer(SDL_Window * window, Uint32 flags)
 
     /* Set up parameters for rendering */
     D3D_InitRenderState(data);
-
+#if SDL_HAVE_YUV
     if (caps.MaxSimultaneousTextures >= 3) {
         int i;
         for (i = 0; i < SDL_arraysize(data->shaders); ++i) {
@@ -1839,7 +1701,7 @@ D3D_CreateRenderer(SDL_Window * window, Uint32 flags)
             renderer->info.texture_formats[renderer->info.num_texture_formats++] = SDL_PIXELFORMAT_IYUV;
         }
     }
-
+#endif
     data->drawstate.blend = SDL_BLENDMODE_INVALID;
 
     return renderer;
diff --git a/Engine/lib/sdl/src/render/direct3d/SDL_shaders_d3d.c b/Engine/lib/sdl/src/render/direct3d/SDL_shaders_d3d.c
index 7ab4cbc23..d734351c8 100644
--- a/Engine/lib/sdl/src/render/direct3d/SDL_shaders_d3d.c
+++ b/Engine/lib/sdl/src/render/direct3d/SDL_shaders_d3d.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/render/direct3d/SDL_shaders_d3d.h b/Engine/lib/sdl/src/render/direct3d/SDL_shaders_d3d.h
index 4c8e711f3..b7715cb75 100644
--- a/Engine/lib/sdl/src/render/direct3d/SDL_shaders_d3d.h
+++ b/Engine/lib/sdl/src/render/direct3d/SDL_shaders_d3d.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/render/direct3d11/SDL_render_d3d11.c b/Engine/lib/sdl/src/render/direct3d11/SDL_render_d3d11.c
index d814abc5d..89e2ee544 100644
--- a/Engine/lib/sdl/src/render/direct3d11/SDL_render_d3d11.c
+++ b/Engine/lib/sdl/src/render/direct3d11/SDL_render_d3d11.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -20,6 +20,9 @@
 */
 #include "../../SDL_internal.h"
 
+#include "SDL_render.h"
+#include "SDL_system.h"
+
 #if SDL_VIDEO_RENDER_D3D11 && !SDL_RENDER_DISABLED
 
 #define COBJMACROS
@@ -51,13 +54,17 @@ extern ISwapChainBackgroundPanelNative * WINRT_GlobalSwapChainBackgroundPanelNat
 #endif  /* __WINRT__ */
 
 
+#if defined(_MSC_VER) && !defined(__clang__)
+#define SDL_COMPOSE_ERROR(str) __FUNCTION__ ", " str
+#else
 #define SDL_COMPOSE_ERROR(str) SDL_STRINGIFY_ARG(__FUNCTION__) ", " str
+#endif
 
 #define SAFE_RELEASE(X) if ((X)) { IUnknown_Release(SDL_static_cast(IUnknown*, X)); X = NULL; }
 
 
-/* !!! FIXME: vertex buffer bandwidth could be significantly lower; move color to a uniform, only use UV coords
-   !!! FIXME:  when textures are needed, and don't ever pass Z, since it's always zero. */
+/* !!! FIXME: vertex buffer bandwidth could be lower; only use UV coords when
+   !!! FIXME:  textures are needed. */
 
 /* Vertex shader, common values */
 typedef struct
@@ -69,9 +76,9 @@ typedef struct
 /* Per-vertex data */
 typedef struct
 {
-    Float3 pos;
+    Float2 pos;
     Float2 tex;
-    Float4 color;
+    SDL_Color color;
 } VertexPositionColor;
 
 /* Per-texture data */
@@ -84,7 +91,7 @@ typedef struct
     int lockedTexturePositionX;
     int lockedTexturePositionY;
     D3D11_FILTER scaleMode;
-
+#if SDL_HAVE_YUV
     /* YV12 texture support */
     SDL_bool yuv;
     ID3D11Texture2D *mainTextureU;
@@ -100,6 +107,7 @@ typedef struct
     Uint8 *pixels;
     int pitch;
     SDL_Rect locked_rect;
+#endif
 } D3D11_TextureData;
 
 /* Blend mode data */
@@ -176,11 +184,13 @@ typedef struct
 
 static const GUID SDL_IID_IDXGIFactory2 = { 0x50c83a1c, 0xe072, 0x4c48, { 0x87, 0xb0, 0x36, 0x30, 0xfa, 0x36, 0xa6, 0xd0 } };
 static const GUID SDL_IID_IDXGIDevice1 = { 0x77db970f, 0x6276, 0x48ba, { 0xba, 0x28, 0x07, 0x01, 0x43, 0xb4, 0x39, 0x2c } };
+#if defined(__WINRT__) && NTDDI_VERSION > NTDDI_WIN8
 static const GUID SDL_IID_IDXGIDevice3 = { 0x6007896c, 0x3244, 0x4afd, { 0xbf, 0x18, 0xa6, 0xd3, 0xbe, 0xda, 0x50, 0x23 } };
+#endif
 static const GUID SDL_IID_ID3D11Texture2D = { 0x6f15aaf2, 0xd208, 0x4e89, { 0x9a, 0xb4, 0x48, 0x95, 0x35, 0xd3, 0x4f, 0x9c } };
 static const GUID SDL_IID_ID3D11Device1 = { 0xa04bfb29, 0x08ef, 0x43d6, { 0xa4, 0x9c, 0xa9, 0xbd, 0xbd, 0xcb, 0xe6, 0x86 } };
 static const GUID SDL_IID_ID3D11DeviceContext1 = { 0xbb2c6faa, 0xb5fb, 0x4082, { 0x8e, 0x6b, 0x38, 0x8b, 0x8c, 0xfa, 0x90, 0xe1 } };
-static const GUID SDL_IID_ID3D11Debug = { 0x79cf2233, 0x7536, 0x4948, { 0x9d, 0x36, 0x1e, 0x46, 0x92, 0xdc, 0x57, 0x60 } };
+/*static const GUID SDL_IID_ID3D11Debug = { 0x79cf2233, 0x7536, 0x4948, { 0x9d, 0x36, 0x1e, 0x46, 0x92, 0xdc, 0x57, 0x60 } };*/
 
 #ifdef __GNUC__
 #pragma GCC diagnostic pop
@@ -478,6 +488,11 @@ D3D11_CreateDeviceResources(SDL_Renderer * renderer)
         creationFlags |= D3D11_CREATE_DEVICE_DEBUG;
     }
 
+    /* Create a single-threaded device unless the app requests otherwise. */
+    if (!SDL_GetHintBoolean(SDL_HINT_RENDER_DIRECT3D_THREADSAFE, SDL_FALSE)) {
+        creationFlags |= D3D11_CREATE_DEVICE_SINGLETHREADED;
+    }
+
     /* Create the Direct3D 11 API device object and a corresponding context. */
     result = D3D11CreateDeviceFunc(
         data->dxgiAdapter,
@@ -691,7 +706,10 @@ D3D11_GetRotationForCurrentRenderTarget(SDL_Renderer * renderer)
 static int
 D3D11_GetViewportAlignedD3DRect(SDL_Renderer * renderer, const SDL_Rect * sdlRect, D3D11_RECT * outRect, BOOL includeViewportOffset)
 {
+    D3D11_RenderData *data = (D3D11_RenderData *) renderer->driverdata;
     const int rotation = D3D11_GetRotationForCurrentRenderTarget(renderer);
+    const SDL_Rect *viewport = &data->currentViewport;
+
     switch (rotation) {
         case DXGI_MODE_ROTATION_IDENTITY:
             outRect->left = sdlRect->x;
@@ -699,27 +717,27 @@ D3D11_GetViewportAlignedD3DRect(SDL_Renderer * renderer, const SDL_Rect * sdlRec
             outRect->top = sdlRect->y;
             outRect->bottom = sdlRect->y + sdlRect->h;
             if (includeViewportOffset) {
-                outRect->left += renderer->viewport.x;
-                outRect->right += renderer->viewport.x;
-                outRect->top += renderer->viewport.y;
-                outRect->bottom += renderer->viewport.y;
+                outRect->left += viewport->x;
+                outRect->right += viewport->x;
+                outRect->top += viewport->y;
+                outRect->bottom += viewport->y;
             }
             break;
         case DXGI_MODE_ROTATION_ROTATE270:
             outRect->left = sdlRect->y;
             outRect->right = sdlRect->y + sdlRect->h;
-            outRect->top = renderer->viewport.w - sdlRect->x - sdlRect->w;
-            outRect->bottom = renderer->viewport.w - sdlRect->x;
+            outRect->top = viewport->w - sdlRect->x - sdlRect->w;
+            outRect->bottom = viewport->w - sdlRect->x;
             break;
         case DXGI_MODE_ROTATION_ROTATE180:
-            outRect->left = renderer->viewport.w - sdlRect->x - sdlRect->w;
-            outRect->right = renderer->viewport.w - sdlRect->x;
-            outRect->top = renderer->viewport.h - sdlRect->y - sdlRect->h;
-            outRect->bottom = renderer->viewport.h - sdlRect->y;
+            outRect->left = viewport->w - sdlRect->x - sdlRect->w;
+            outRect->right = viewport->w - sdlRect->x;
+            outRect->top = viewport->h - sdlRect->y - sdlRect->h;
+            outRect->bottom = viewport->h - sdlRect->y;
             break;
         case DXGI_MODE_ROTATION_ROTATE90:
-            outRect->left = renderer->viewport.h - sdlRect->y - sdlRect->h;
-            outRect->right = renderer->viewport.h - sdlRect->y;
+            outRect->left = viewport->h - sdlRect->y - sdlRect->h;
+            outRect->right = viewport->h - sdlRect->y;
             outRect->top = sdlRect->x;
             outRect->bottom = sdlRect->x + sdlRect->h;
             break;
@@ -761,7 +779,11 @@ D3D11_CreateSwapChain(SDL_Renderer * renderer, int w, int h)
     if (usingXAML) {
         swapChainDesc.Scaling = DXGI_SCALING_STRETCH;
     } else {
-        swapChainDesc.Scaling = DXGI_SCALING_NONE;
+        if (WIN_IsWindows8OrGreater()) {
+            swapChainDesc.Scaling = DXGI_SCALING_NONE;
+        } else {
+            swapChainDesc.Scaling = DXGI_SCALING_STRETCH;
+        }
     }
     swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; /* All Windows Store apps must use this SwapEffect. */
 #endif
@@ -944,11 +966,13 @@ D3D11_CreateWindowSizeDependentResources(SDL_Renderer * renderer)
      *
      * TODO, WinRT: reexamine the docs for IDXGISwapChain1::SetRotation, see if might be available, usable, and prudent-to-call on WinPhone 8.1
      */
-    if (data->swapEffect == DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL) {
-        result = IDXGISwapChain1_SetRotation(data->swapChain, data->rotation);
-        if (FAILED(result)) {
-            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("IDXGISwapChain1::SetRotation"), result);
-            goto done;
+    if (WIN_IsWindows8OrGreater()) {
+        if (data->swapEffect == DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL) {
+            result = IDXGISwapChain1_SetRotation(data->swapChain, data->rotation);
+            if (FAILED(result)) {
+                WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("IDXGISwapChain1::SetRotation"), result);
+                goto done;
+            }
         }
     }
 #endif
@@ -1091,10 +1115,9 @@ D3D11_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
         );
     if (FAILED(result)) {
         D3D11_DestroyTexture(renderer, texture);
-        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateTexture2D"), result);
-        return -1;
+        return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateTexture2D"), result);
     }
-
+#if SDL_HAVE_YUV
     if (texture->format == SDL_PIXELFORMAT_YV12 ||
         texture->format == SDL_PIXELFORMAT_IYUV) {
         textureData->yuv = SDL_TRUE;
@@ -1109,8 +1132,7 @@ D3D11_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
             );
         if (FAILED(result)) {
             D3D11_DestroyTexture(renderer, texture);
-            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateTexture2D"), result);
-            return -1;
+            return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateTexture2D"), result);
         }
 
         result = ID3D11Device_CreateTexture2D(rendererData->d3dDevice,
@@ -1120,8 +1142,7 @@ D3D11_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
             );
         if (FAILED(result)) {
             D3D11_DestroyTexture(renderer, texture);
-            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateTexture2D"), result);
-            return -1;
+            return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateTexture2D"), result);
         }
     }
 
@@ -1142,11 +1163,10 @@ D3D11_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
             );
         if (FAILED(result)) {
             D3D11_DestroyTexture(renderer, texture);
-            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateTexture2D"), result);
-            return -1;
+            return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateTexture2D"), result);
         }
     }
-
+#endif /* SDL_HAVE_YUV */
     resourceViewDesc.Format = textureDesc.Format;
     resourceViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
     resourceViewDesc.Texture2D.MostDetailedMip = 0;
@@ -1158,10 +1178,9 @@ D3D11_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
         );
     if (FAILED(result)) {
         D3D11_DestroyTexture(renderer, texture);
-        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateShaderResourceView"), result);
-        return -1;
+        return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateShaderResourceView"), result);
     }
-
+#if SDL_HAVE_YUV
     if (textureData->yuv) {
         result = ID3D11Device_CreateShaderResourceView(rendererData->d3dDevice,
             (ID3D11Resource *)textureData->mainTextureU,
@@ -1170,8 +1189,7 @@ D3D11_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
             );
         if (FAILED(result)) {
             D3D11_DestroyTexture(renderer, texture);
-            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateShaderResourceView"), result);
-            return -1;
+            return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateShaderResourceView"), result);
         }
         result = ID3D11Device_CreateShaderResourceView(rendererData->d3dDevice,
             (ID3D11Resource *)textureData->mainTextureV,
@@ -1180,8 +1198,7 @@ D3D11_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
             );
         if (FAILED(result)) {
             D3D11_DestroyTexture(renderer, texture);
-            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateShaderResourceView"), result);
-            return -1;
+            return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateShaderResourceView"), result);
         }
     }
 
@@ -1197,8 +1214,7 @@ D3D11_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
             );
         if (FAILED(result)) {
             D3D11_DestroyTexture(renderer, texture);
-            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateShaderResourceView"), result);
-            return -1;
+            return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateShaderResourceView"), result);
         }
     }
 
@@ -1214,11 +1230,10 @@ D3D11_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
             &textureData->mainTextureRenderTargetView);
         if (FAILED(result)) {
             D3D11_DestroyTexture(renderer, texture);
-            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateRenderTargetView"), result);
-            return -1;
+            return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateRenderTargetView"), result);
         }
     }
-
+#endif /* SDL_HAVE_YUV */
     return 0;
 }
 
@@ -1236,11 +1251,15 @@ D3D11_DestroyTexture(SDL_Renderer * renderer,
     SAFE_RELEASE(data->mainTextureResourceView);
     SAFE_RELEASE(data->mainTextureRenderTargetView);
     SAFE_RELEASE(data->stagingTexture);
+#if SDL_HAVE_YUV
     SAFE_RELEASE(data->mainTextureU);
     SAFE_RELEASE(data->mainTextureResourceViewU);
     SAFE_RELEASE(data->mainTextureV);
     SAFE_RELEASE(data->mainTextureResourceViewV);
+    SAFE_RELEASE(data->mainTextureNV);
+    SAFE_RELEASE(data->mainTextureResourceViewNV);
     SDL_free(data->pixels);
+#endif
     SDL_free(data);
     texture->driverdata = NULL;
 }
@@ -1270,8 +1289,7 @@ D3D11_UpdateTextureInternal(D3D11_RenderData *rendererData, ID3D11Texture2D *tex
         NULL,
         &stagingTexture);
     if (FAILED(result)) {
-        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateTexture2D [create staging texture]"), result);
-        return -1;
+        return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateTexture2D [create staging texture]"), result);
     }
 
     /* Get a write-only pointer to data in the staging texture: */
@@ -1283,9 +1301,8 @@ D3D11_UpdateTextureInternal(D3D11_RenderData *rendererData, ID3D11Texture2D *tex
         &textureMemory
         );
     if (FAILED(result)) {
-        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11DeviceContext1::Map [map staging texture]"), result);
         SAFE_RELEASE(stagingTexture);
-        return -1;
+        return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11DeviceContext1::Map [map staging texture]"), result);
     }
 
     src = (const Uint8 *)pixels;
@@ -1337,14 +1354,13 @@ D3D11_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
     D3D11_TextureData *textureData = (D3D11_TextureData *)texture->driverdata;
 
     if (!textureData) {
-        SDL_SetError("Texture is not currently available");
-        return -1;
+        return SDL_SetError("Texture is not currently available");
     }
 
     if (D3D11_UpdateTextureInternal(rendererData, textureData->mainTexture, SDL_BYTESPERPIXEL(texture->format), rect->x, rect->y, rect->w, rect->h, srcPixels, srcPitch) < 0) {
         return -1;
     }
-
+#if SDL_HAVE_YUV
     if (textureData->yuv) {
         /* Skip to the correct offset into the next texture */
         srcPixels = (const void*)((const Uint8*)srcPixels + rect->h * srcPitch);
@@ -1368,9 +1384,11 @@ D3D11_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
             return -1;
         }
     }
+#endif /* SDL_HAVE_YUV */
     return 0;
 }
 
+#if SDL_HAVE_YUV
 static int
 D3D11_UpdateTextureYUV(SDL_Renderer * renderer, SDL_Texture * texture,
                        const SDL_Rect * rect,
@@ -1382,8 +1400,7 @@ D3D11_UpdateTextureYUV(SDL_Renderer * renderer, SDL_Texture * texture,
     D3D11_TextureData *textureData = (D3D11_TextureData *)texture->driverdata;
 
     if (!textureData) {
-        SDL_SetError("Texture is not currently available");
-        return -1;
+        return SDL_SetError("Texture is not currently available");
     }
 
     if (D3D11_UpdateTextureInternal(rendererData, textureData->mainTexture, SDL_BYTESPERPIXEL(texture->format), rect->x, rect->y, rect->w, rect->h, Yplane, Ypitch) < 0) {
@@ -1398,6 +1415,30 @@ D3D11_UpdateTextureYUV(SDL_Renderer * renderer, SDL_Texture * texture,
     return 0;
 }
 
+static int
+D3D11_UpdateTextureNV(SDL_Renderer * renderer, SDL_Texture * texture,
+                       const SDL_Rect * rect,
+                       const Uint8 *Yplane, int Ypitch,
+                       const Uint8 *UVplane, int UVpitch)
+{
+    D3D11_RenderData *rendererData = (D3D11_RenderData *)renderer->driverdata;
+    D3D11_TextureData *textureData = (D3D11_TextureData *)texture->driverdata;
+
+    if (!textureData) {
+        return SDL_SetError("Texture is not currently available");
+    }
+
+    if (D3D11_UpdateTextureInternal(rendererData, textureData->mainTexture, SDL_BYTESPERPIXEL(texture->format), rect->x, rect->y, rect->w, rect->h, Yplane, Ypitch) < 0) {
+        return -1;
+    }
+
+    if (D3D11_UpdateTextureInternal(rendererData, textureData->mainTextureNV, 2, rect->x / 2, rect->y / 2, ((rect->w + 1) / 2), (rect->h + 1) / 2, UVplane, UVpitch) < 0) {
+        return -1;
+    }
+    return 0;
+}
+#endif
+
 static int
 D3D11_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
                   const SDL_Rect * rect, void **pixels, int *pitch)
@@ -1409,10 +1450,9 @@ D3D11_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
     D3D11_MAPPED_SUBRESOURCE textureMemory;
 
     if (!textureData) {
-        SDL_SetError("Texture is not currently available");
-        return -1;
+        return SDL_SetError("Texture is not currently available");
     }
-
+#if SDL_HAVE_YUV
     if (textureData->yuv || textureData->nv12) {
         /* It's more efficient to upload directly... */
         if (!textureData->pixels) {
@@ -1429,7 +1469,7 @@ D3D11_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
         *pitch = textureData->pitch;
         return 0;
     }
-
+#endif
     if (textureData->stagingTexture) {
         return SDL_SetError("texture is already locked");
     }
@@ -1454,8 +1494,7 @@ D3D11_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
         NULL,
         &textureData->stagingTexture);
     if (FAILED(result)) {
-        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateTexture2D [create staging texture]"), result);
-        return -1;
+        return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateTexture2D [create staging texture]"), result);
     }
 
     /* Get a write-only pointer to data in the staging texture: */
@@ -1467,9 +1506,8 @@ D3D11_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
         &textureMemory
         );
     if (FAILED(result)) {
-        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11DeviceContext1::Map [map staging texture]"), result);
         SAFE_RELEASE(textureData->stagingTexture);
-        return -1;
+        return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11DeviceContext1::Map [map staging texture]"), result);
     }
 
     /* Make note of where the staging texture will be written to 
@@ -1495,7 +1533,7 @@ D3D11_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
     if (!textureData) {
         return;
     }
-
+#if SDL_HAVE_YUV
     if (textureData->yuv || textureData->nv12) {
         const SDL_Rect *rect = &textureData->locked_rect;
         void *pixels =
@@ -1504,7 +1542,7 @@ D3D11_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
         D3D11_UpdateTexture(renderer, texture, rect, pixels, textureData->pitch);
         return;
     }
-
+#endif
     /* Commit the pixel buffer's changes back to the staging texture: */
     ID3D11DeviceContext_Unmap(rendererData->d3dContext,
         (ID3D11Resource *)textureData->stagingTexture,
@@ -1568,11 +1606,12 @@ static int
 D3D11_QueueDrawPoints(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FPoint * points, int count)
 {
     VertexPositionColor *verts = (VertexPositionColor *) SDL_AllocateRenderVertices(renderer, count * sizeof (VertexPositionColor), 0, &cmd->data.draw.first);
-    const float r = (float)(cmd->data.draw.r / 255.0f);
-    const float g = (float)(cmd->data.draw.g / 255.0f);
-    const float b = (float)(cmd->data.draw.b / 255.0f);
-    const float a = (float)(cmd->data.draw.a / 255.0f);
     int i;
+    SDL_Color color;
+    color.r = cmd->data.draw.r;
+    color.g = cmd->data.draw.g;
+    color.b = cmd->data.draw.b;
+    color.a = cmd->data.draw.a;
 
     if (!verts) {
         return -1;
@@ -1583,13 +1622,9 @@ D3D11_QueueDrawPoints(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL
     for (i = 0; i < count; i++) {
         verts->pos.x = points[i].x + 0.5f;
         verts->pos.y = points[i].y + 0.5f;
-        verts->pos.z = 0.0f;
         verts->tex.x = 0.0f;
         verts->tex.y = 0.0f;
-        verts->color.x = r;
-        verts->color.y = g;
-        verts->color.z = b;
-        verts->color.w = a;
+        verts->color = color;
         verts++;
     }
 
@@ -1597,238 +1632,55 @@ D3D11_QueueDrawPoints(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL
 }
 
 static int
-D3D11_QueueFillRects(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FRect * rects, int count)
+D3D11_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+                    const float *xy, int xy_stride, const SDL_Color *color, int color_stride, const float *uv, int uv_stride,
+                    int num_vertices, const void *indices, int num_indices, int size_indices,
+                    float scale_x, float scale_y)
 {
-    VertexPositionColor *verts = (VertexPositionColor *) SDL_AllocateRenderVertices(renderer, count * 4 * sizeof (VertexPositionColor), 0, &cmd->data.draw.first);
-    const float r = (float)(cmd->data.draw.r / 255.0f);
-    const float g = (float)(cmd->data.draw.g / 255.0f);
-    const float b = (float)(cmd->data.draw.b / 255.0f);
-    const float a = (float)(cmd->data.draw.a / 255.0f);
     int i;
+    int count = indices ? num_indices : num_vertices;
+    VertexPositionColor *verts = (VertexPositionColor *) SDL_AllocateRenderVertices(renderer, count * sizeof (VertexPositionColor), 0, &cmd->data.draw.first);
 
     if (!verts) {
         return -1;
     }
 
     cmd->data.draw.count = count;
+    size_indices = indices ? size_indices : 0;
 
     for (i = 0; i < count; i++) {
-        verts->pos.x = rects[i].x;
-        verts->pos.y = rects[i].y;
-        verts->pos.z = 0.0f;
-        verts->tex.x = 0.0f;
-        verts->tex.y = 0.0f;
-        verts->color.x = r;
-        verts->color.y = g;
-        verts->color.z = b;
-        verts->color.w = a;
-        verts++;
+        int j;
+        float *xy_;
+        if (size_indices == 4) {
+            j = ((const Uint32 *)indices)[i];
+        } else if (size_indices == 2) {
+            j = ((const Uint16 *)indices)[i];
+        } else if (size_indices == 1) {
+            j = ((const Uint8 *)indices)[i];
+        } else {
+            j = i;
+        }
 
-        verts->pos.x = rects[i].x;
-        verts->pos.y = rects[i].y + rects[i].h;
-        verts->pos.z = 0.0f;
-        verts->tex.x = 0.0f;
-        verts->tex.y = 0.0f;
-        verts->color.x = r;
-        verts->color.y = g;
-        verts->color.z = b;
-        verts->color.w = a;
-        verts++;
+        xy_ = (float *)((char*)xy + j * xy_stride);
 
-        verts->pos.x = rects[i].x + rects[i].w;
-        verts->pos.y = rects[i].y;
-        verts->pos.z = 0.0f;
-        verts->tex.x = 0.0f;
-        verts->tex.y = 0.0f;
-        verts->color.x = r;
-        verts->color.y = g;
-        verts->color.z = b;
-        verts->color.w = a;
-        verts++;
+        verts->pos.x = xy_[0] * scale_x;
+        verts->pos.y = xy_[1] * scale_y;
+        verts->color = *(SDL_Color*)((char*)color + j * color_stride);
 
-        verts->pos.x = rects[i].x + rects[i].w;
-        verts->pos.y = rects[i].y + rects[i].h;
-        verts->pos.z = 0.0f;
-        verts->tex.x = 0.0f;
-        verts->tex.y = 0.0f;
-        verts->color.x = r;
-        verts->color.y = g;
-        verts->color.z = b;
-        verts->color.w = a;
-        verts++;
+        if (texture) {
+            float *uv_ = (float *)((char*)uv + j * uv_stride);
+            verts->tex.x = uv_[0];
+            verts->tex.y = uv_[1];
+        } else {
+            verts->tex.x = 0.0f;
+            verts->tex.y = 0.0f;
+        }
+
+        verts += 1;
     }
-
     return 0;
 }
 
-static int
-D3D11_QueueCopy(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture,
-             const SDL_Rect * srcrect, const SDL_FRect * dstrect)
-{
-    VertexPositionColor *verts = (VertexPositionColor *) SDL_AllocateRenderVertices(renderer, 4 * sizeof (VertexPositionColor), 0, &cmd->data.draw.first);
-    const float r = (float)(cmd->data.draw.r / 255.0f);
-    const float g = (float)(cmd->data.draw.g / 255.0f);
-    const float b = (float)(cmd->data.draw.b / 255.0f);
-    const float a = (float)(cmd->data.draw.a / 255.0f);
-    const float minu = (float) srcrect->x / texture->w;
-    const float maxu = (float) (srcrect->x + srcrect->w) / texture->w;
-    const float minv = (float) srcrect->y / texture->h;
-    const float maxv = (float) (srcrect->y + srcrect->h) / texture->h;
-
-    if (!verts) {
-        return -1;
-    }
-
-    cmd->data.draw.count = 1;
-
-    verts->pos.x = dstrect->x;
-    verts->pos.y = dstrect->y;
-    verts->pos.z = 0.0f;
-    verts->tex.x = minu;
-    verts->tex.y = minv;
-    verts->color.x = r;
-    verts->color.y = g;
-    verts->color.z = b;
-    verts->color.w = a;
-    verts++;
-
-    verts->pos.x = dstrect->x;
-    verts->pos.y = dstrect->y + dstrect->h;
-    verts->pos.z = 0.0f;
-    verts->tex.x = minu;
-    verts->tex.y = maxv;
-    verts->color.x = r;
-    verts->color.y = g;
-    verts->color.z = b;
-    verts->color.w = a;
-    verts++;
-
-    verts->pos.x = dstrect->x + dstrect->w;
-    verts->pos.y = dstrect->y;
-    verts->pos.z = 0.0f;
-    verts->tex.x = maxu;
-    verts->tex.y = minv;
-    verts->color.x = r;
-    verts->color.y = g;
-    verts->color.z = b;
-    verts->color.w = a;
-    verts++;
-
-    verts->pos.x = dstrect->x + dstrect->w;
-    verts->pos.y = dstrect->y + dstrect->h;
-    verts->pos.z = 0.0f;
-    verts->tex.x = maxu;
-    verts->tex.y = maxv;
-    verts->color.x = r;
-    verts->color.y = g;
-    verts->color.z = b;
-    verts->color.w = a;
-    verts++;
-
-    return 0;
-}
-
-static int
-D3D11_QueueCopyEx(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture,
-               const SDL_Rect * srcrect, const SDL_FRect * dstrect,
-               const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip)
-{
-    VertexPositionColor *verts = (VertexPositionColor *) SDL_AllocateRenderVertices(renderer, 5 * sizeof (VertexPositionColor), 0, &cmd->data.draw.first);
-    const float r = (float)(cmd->data.draw.r / 255.0f);
-    const float g = (float)(cmd->data.draw.g / 255.0f);
-    const float b = (float)(cmd->data.draw.b / 255.0f);
-    const float a = (float)(cmd->data.draw.a / 255.0f);
-    float minx, miny, maxx, maxy;
-    float minu, maxu, minv, maxv;
-
-    if (!verts) {
-        return -1;
-    }
-
-    cmd->data.draw.count = 1;
-
-    minx = -center->x;
-    maxx = dstrect->w - center->x;
-    miny = -center->y;
-    maxy = dstrect->h - center->y;
-
-    if (flip & SDL_FLIP_HORIZONTAL) {
-        minu = (float) (srcrect->x + srcrect->w) / texture->w;
-        maxu = (float) srcrect->x / texture->w;
-    } else {
-        minu = (float) srcrect->x / texture->w;
-        maxu = (float) (srcrect->x + srcrect->w) / texture->w;
-    }
-
-    if (flip & SDL_FLIP_VERTICAL) {
-        minv = (float) (srcrect->y + srcrect->h) / texture->h;
-        maxv = (float) srcrect->y / texture->h;
-    } else {
-        minv = (float) srcrect->y / texture->h;
-        maxv = (float) (srcrect->y + srcrect->h) / texture->h;
-    }
-
-
-
-    verts->pos.x = minx;
-    verts->pos.y = miny;
-    verts->pos.z = 0.0f;
-    verts->color.x = r;
-    verts->color.y = g;
-    verts->color.z = b;
-    verts->color.w = a;
-    verts->tex.x = minu;
-    verts->tex.y = minv;
-    verts++;
-
-    verts->pos.x = minx;
-    verts->pos.y = maxy;
-    verts->pos.z = 0.0f;
-    verts->color.x = r;
-    verts->color.y = g;
-    verts->color.z = b;
-    verts->color.w = a;
-    verts->tex.x = minu;
-    verts->tex.y = maxv;
-    verts++;
-
-    verts->pos.x = maxx;
-    verts->pos.y = miny;
-    verts->pos.z = 0.0f;
-    verts->color.x = r;
-    verts->color.y = g;
-    verts->color.z = b;
-    verts->color.w = a;
-    verts->tex.x = maxu;
-    verts->tex.y = minv;
-    verts++;
-
-    verts->pos.x = maxx;
-    verts->pos.y = maxy;
-    verts->pos.z = 0.0f;
-    verts->color.x = r;
-    verts->color.y = g;
-    verts->color.z = b;
-    verts->color.w = a;
-    verts->tex.x = maxu;
-    verts->tex.y = maxv;
-    verts++;
-
-    verts->pos.x = dstrect->x + center->x;  /* X translation */
-    verts->pos.y = dstrect->y + center->y;  /* Y translation */
-    verts->pos.z = (float)(M_PI * (float) angle / 180.0f);  /* rotation */
-    verts->color.x = 0;
-    verts->color.y = 0;
-    verts->color.z = 0;
-    verts->color.w = 0;
-    verts->tex.x = 0.0f;
-    verts->tex.y = 0.0f;
-    verts++;
-
-    return 0;
-}
-
-
 static int
 D3D11_UpdateVertexBuffer(SDL_Renderer *renderer,
                          const void * vertexData, size_t dataSizeInBytes)
@@ -1853,8 +1705,7 @@ D3D11_UpdateVertexBuffer(SDL_Renderer *renderer,
             &mappedResource
             );
         if (FAILED(result)) {
-            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11DeviceContext1::Map [vertex buffer]"), result);
-            return -1;
+            return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11DeviceContext1::Map [vertex buffer]"), result);
         }
         SDL_memcpy(mappedResource.pData, vertexData, dataSizeInBytes);
         ID3D11DeviceContext_Unmap(rendererData->d3dContext, (ID3D11Resource *)rendererData->vertexBuffers[vbidx], 0);
@@ -1881,8 +1732,7 @@ D3D11_UpdateVertexBuffer(SDL_Renderer *renderer,
             &rendererData->vertexBuffers[vbidx]
             );
         if (FAILED(result)) {
-            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateBuffer [vertex buffer]"), result);
-            return -1;
+            return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateBuffer [vertex buffer]"), result);
         }
 
         rendererData->vertexBufferSizes[vbidx] = dataSizeInBytes;
@@ -2135,7 +1985,7 @@ D3D11_SetCopyState(SDL_Renderer * renderer, const SDL_RenderCommand *cmd, const
     default:
         return SDL_SetError("Unknown scale mode: %d\n", textureData->scaleMode);
     }
-
+#if SDL_HAVE_YUV
     if (textureData->yuv) {
         ID3D11ShaderResourceView *shaderResources[] = {
             textureData->mainTextureResourceView,
@@ -2186,7 +2036,7 @@ D3D11_SetCopyState(SDL_Renderer * renderer, const SDL_RenderCommand *cmd, const
                                   SDL_arraysize(shaderResources), shaderResources, textureSampler, matrix);
 
     }
-
+#endif /* SDL_HAVE_YUV */
     return D3D11_SetDrawState(renderer, cmd, rendererData->pixelShaders[SHADER_RGB],
                               1, &textureData->mainTextureResourceView, textureSampler, matrix);
 }
@@ -2204,7 +2054,6 @@ D3D11_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *ver
 {
     D3D11_RenderData *rendererData = (D3D11_RenderData *) renderer->driverdata;
     const int viewportRotation = D3D11_GetRotationForCurrentRenderTarget(renderer);
-    size_t i;
 
     if (rendererData->currentViewportRotation != viewportRotation) {
         rendererData->currentViewportRotation = viewportRotation;
@@ -2276,37 +2125,28 @@ D3D11_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *ver
                 break;
             }
 
-            case SDL_RENDERCMD_FILL_RECTS: {
+            case SDL_RENDERCMD_FILL_RECTS: /* unused */
+                break;
+
+            case SDL_RENDERCMD_COPY: /* unused */
+                break;
+
+            case SDL_RENDERCMD_COPY_EX: /* unused */
+                break;
+
+            case SDL_RENDERCMD_GEOMETRY: {
+                SDL_Texture *texture = cmd->data.draw.texture;
                 const size_t count = cmd->data.draw.count;
                 const size_t first = cmd->data.draw.first;
                 const size_t start = first / sizeof (VertexPositionColor);
-                size_t offset = 0;
-                D3D11_SetDrawState(renderer, cmd, rendererData->pixelShaders[SHADER_SOLID], 0, NULL, NULL, NULL);
-                for (i = 0; i < count; i++, offset += 4) {
-                    D3D11_DrawPrimitives(renderer, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP, start + offset, 4);
+
+                if (texture) {
+                    D3D11_SetCopyState(renderer, cmd, NULL);
+                } else {
+                    D3D11_SetDrawState(renderer, cmd, rendererData->pixelShaders[SHADER_SOLID], 0, NULL, NULL, NULL);
                 }
-                break;
-            }
 
-            case SDL_RENDERCMD_COPY: {
-                const size_t first = cmd->data.draw.first;
-                const size_t start = first / sizeof (VertexPositionColor);
-                D3D11_SetCopyState(renderer, cmd, NULL);
-                D3D11_DrawPrimitives(renderer, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP, start, 4);
-                break;
-            }
-
-            case SDL_RENDERCMD_COPY_EX: {
-                const size_t first = cmd->data.draw.first;
-                const size_t start = first / sizeof (VertexPositionColor);
-                const VertexPositionColor *verts = (VertexPositionColor *) (((Uint8 *) vertices) + first);
-                const VertexPositionColor *transvert = verts + 4;
-                const float translatex = transvert->pos.x;
-                const float translatey = transvert->pos.y;
-                const float rotation = transvert->pos.z;
-                const Float4X4 matrix = MatrixMultiply(MatrixRotationZ(rotation), MatrixTranslation(translatex, translatey, 0));
-                D3D11_SetCopyState(renderer, cmd, &matrix);
-                D3D11_DrawPrimitives(renderer, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP, start, 4);
+                D3D11_DrawPrimitives(renderer, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST, start, count);
                 break;
             }
 
@@ -2399,30 +2239,20 @@ D3D11_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
     /* Copy the data into the desired buffer, converting pixels to the
      * desired format at the same time:
      */
-    if (SDL_ConvertPixels(
+    status = SDL_ConvertPixels(
         rect->w, rect->h,
         D3D11_DXGIFormatToSDLPixelFormat(stagingTextureDesc.Format),
         textureMemory.pData,
         textureMemory.RowPitch,
         format,
         pixels,
-        pitch) != 0) {
-        /* When SDL_ConvertPixels fails, it'll have already set the format.
-         * Get the error message, and attach some extra data to it.
-         */
-        char errorMessage[1024];
-        SDL_snprintf(errorMessage, sizeof(errorMessage), "%s, Convert Pixels failed: %s", __FUNCTION__, SDL_GetError());
-        SDL_SetError("%s", errorMessage);
-        goto done;
-    }
+        pitch);
 
     /* Unmap the texture: */
     ID3D11DeviceContext_Unmap(data->d3dContext,
         (ID3D11Resource *)stagingTexture,
         0);
 
-    status = 0;
-
 done:
     SAFE_RELEASE(backBuffer);
     SAFE_RELEASE(stagingTexture);
@@ -2486,6 +2316,21 @@ D3D11_RenderPresent(SDL_Renderer * renderer)
     }
 }
 
+#if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP
+    /* no-op. */
+#else
+static int
+D3D11_SetVSync(SDL_Renderer * renderer, const int vsync)
+{
+    if (vsync) {
+        renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
+    } else {
+        renderer->info.flags &= ~SDL_RENDERER_PRESENTVSYNC;
+    }
+    return 0;
+}
+#endif
+
 SDL_Renderer *
 D3D11_CreateRenderer(SDL_Window * window, Uint32 flags)
 {
@@ -2500,6 +2345,7 @@ D3D11_CreateRenderer(SDL_Window * window, Uint32 flags)
 
     data = (D3D11_RenderData *) SDL_calloc(1, sizeof(*data));
     if (!data) {
+        SDL_free(renderer);
         SDL_OutOfMemory();
         return NULL;
     }
@@ -2510,7 +2356,10 @@ D3D11_CreateRenderer(SDL_Window * window, Uint32 flags)
     renderer->SupportsBlendMode = D3D11_SupportsBlendMode;
     renderer->CreateTexture = D3D11_CreateTexture;
     renderer->UpdateTexture = D3D11_UpdateTexture;
+#if SDL_HAVE_YUV
     renderer->UpdateTextureYUV = D3D11_UpdateTextureYUV;
+    renderer->UpdateTextureNV = D3D11_UpdateTextureNV;
+#endif
     renderer->LockTexture = D3D11_LockTexture;
     renderer->UnlockTexture = D3D11_UnlockTexture;
     renderer->SetTextureScaleMode = D3D11_SetTextureScaleMode;
@@ -2519,9 +2368,7 @@ D3D11_CreateRenderer(SDL_Window * window, Uint32 flags)
     renderer->QueueSetDrawColor = D3D11_QueueSetViewport;  /* SetViewport and SetDrawColor are (currently) no-ops. */
     renderer->QueueDrawPoints = D3D11_QueueDrawPoints;
     renderer->QueueDrawLines = D3D11_QueueDrawPoints;  /* lines and points queue vertices the same way. */
-    renderer->QueueFillRects = D3D11_QueueFillRects;
-    renderer->QueueCopy = D3D11_QueueCopy;
-    renderer->QueueCopyEx = D3D11_QueueCopyEx;
+    renderer->QueueGeometry = D3D11_QueueGeometry;
     renderer->RunCommandQueue = D3D11_RunCommandQueue;
     renderer->RenderReadPixels = D3D11_RenderReadPixels;
     renderer->RenderPresent = D3D11_RenderPresent;
@@ -2548,6 +2395,7 @@ D3D11_CreateRenderer(SDL_Window * window, Uint32 flags)
     if ((flags & SDL_RENDERER_PRESENTVSYNC)) {
         renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
     }
+    renderer->SetVSync = D3D11_SetVSync;
 #endif
 
     /* HACK: make sure the SDL_Renderer references the SDL_Window data now, in
@@ -2593,4 +2441,30 @@ SDL_RenderDriver D3D11_RenderDriver = {
 
 #endif /* SDL_VIDEO_RENDER_D3D11 && !SDL_RENDER_DISABLED */
 
+#ifdef __WIN32__
+/* This function needs to always exist on Windows, for the Dynamic API. */
+ID3D11Device *
+SDL_RenderGetD3D11Device(SDL_Renderer * renderer)
+{
+    ID3D11Device *device = NULL;
+
+#if SDL_VIDEO_RENDER_D3D11 && !SDL_RENDER_DISABLED
+    D3D11_RenderData *data = (D3D11_RenderData *) renderer->driverdata;
+
+    /* Make sure that this is a D3D renderer */
+    if (renderer->DestroyRenderer != D3D11_DestroyRenderer) {
+        SDL_SetError("Renderer is not a D3D11 renderer");
+        return NULL;
+    }
+
+    device = (ID3D11Device *)data->d3dDevice;
+    if (device) {
+        ID3D11Device_AddRef(device);
+    }
+#endif /* SDL_VIDEO_RENDER_D3D11 && !SDL_RENDER_DISABLED */
+
+    return device;
+}
+#endif /* __WIN32__ */
+
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/render/direct3d11/SDL_render_winrt.cpp b/Engine/lib/sdl/src/render/direct3d11/SDL_render_winrt.cpp
index 329b3ff2a..9784c32c4 100644
--- a/Engine/lib/sdl/src/render/direct3d11/SDL_render_winrt.cpp
+++ b/Engine/lib/sdl/src/render/direct3d11/SDL_render_winrt.cpp
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/render/direct3d11/SDL_render_winrt.h b/Engine/lib/sdl/src/render/direct3d11/SDL_render_winrt.h
index c2fd3a4c4..97d27cb27 100644
--- a/Engine/lib/sdl/src/render/direct3d11/SDL_render_winrt.h
+++ b/Engine/lib/sdl/src/render/direct3d11/SDL_render_winrt.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/render/direct3d11/SDL_shaders_d3d11.c b/Engine/lib/sdl/src/render/direct3d11/SDL_shaders_d3d11.c
index 4c23f6d76..3a6807b5f 100644
--- a/Engine/lib/sdl/src/render/direct3d11/SDL_shaders_d3d11.c
+++ b/Engine/lib/sdl/src/render/direct3d11/SDL_shaders_d3d11.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -1886,9 +1886,10 @@ static struct
 {
     const void *shader_data;
     SIZE_T shader_size;
-} D3D11_shaders[] = {
+} D3D11_shaders[NUM_SHADERS] = {
     { D3D11_PixelShader_Colors, sizeof(D3D11_PixelShader_Colors) },
     { D3D11_PixelShader_Textures, sizeof(D3D11_PixelShader_Textures) },
+#if SDL_HAVE_YUV
     { D3D11_PixelShader_YUV_JPEG, sizeof(D3D11_PixelShader_YUV_JPEG) },
     { D3D11_PixelShader_YUV_BT601, sizeof(D3D11_PixelShader_YUV_BT601) },
     { D3D11_PixelShader_YUV_BT709, sizeof(D3D11_PixelShader_YUV_BT709) },
@@ -1898,6 +1899,7 @@ static struct
     { D3D11_PixelShader_NV21_JPEG, sizeof(D3D11_PixelShader_NV21_JPEG) },
     { D3D11_PixelShader_NV21_BT601, sizeof(D3D11_PixelShader_NV21_BT601) },
     { D3D11_PixelShader_NV21_BT709, sizeof(D3D11_PixelShader_NV21_BT709) },
+#endif
 };
 
 int D3D11_CreateVertexShader(ID3D11Device1 *d3dDevice, ID3D11VertexShader **vertexShader, ID3D11InputLayout **inputLayout)
@@ -1905,9 +1907,9 @@ int D3D11_CreateVertexShader(ID3D11Device1 *d3dDevice, ID3D11VertexShader **vert
     /* Declare how the input layout for SDL's vertex shader will be setup: */
     const D3D11_INPUT_ELEMENT_DESC vertexDesc[] = 
     {
-        { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
-        { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
-        { "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 20, D3D11_INPUT_PER_VERTEX_DATA, 0 },
+        { "POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
+        { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 8, D3D11_INPUT_PER_VERTEX_DATA, 0 },
+        { "COLOR", 0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, 16, D3D11_INPUT_PER_VERTEX_DATA, 0 },
     };
     HRESULT result;
 
diff --git a/Engine/lib/sdl/src/render/direct3d11/SDL_shaders_d3d11.h b/Engine/lib/sdl/src/render/direct3d11/SDL_shaders_d3d11.h
index cffb99807..d877c0906 100644
--- a/Engine/lib/sdl/src/render/direct3d11/SDL_shaders_d3d11.h
+++ b/Engine/lib/sdl/src/render/direct3d11/SDL_shaders_d3d11.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -25,6 +25,7 @@
 typedef enum {
     SHADER_SOLID,
     SHADER_RGB,
+#if SDL_HAVE_YUV
     SHADER_YUV_JPEG,
     SHADER_YUV_BT601,
     SHADER_YUV_BT709,
@@ -34,6 +35,7 @@ typedef enum {
     SHADER_NV21_JPEG,
     SHADER_NV21_BT601,
     SHADER_NV21_BT709,
+#endif
     NUM_SHADERS
 } D3D11_Shader;
 
diff --git a/Engine/lib/sdl/src/render/metal/SDL_render_metal.m b/Engine/lib/sdl/src/render/metal/SDL_render_metal.m
index c9b205c87..329e5b3a0 100644
--- a/Engine/lib/sdl/src/render/metal/SDL_render_metal.m
+++ b/Engine/lib/sdl/src/render/metal/SDL_render_metal.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -32,6 +32,7 @@
 #import <QuartzCore/CAMetalLayer.h>
 
 #ifdef __MACOSX__
+#import <AppKit/NSWindow.h>
 #import <AppKit/NSView.h>
 #endif
 
@@ -59,7 +60,7 @@ extern int SDL_RecreateWindow(SDL_Window * window, Uint32 flags);
 
 /* macOS requires constants in a buffer to have a 256 byte alignment. */
 /* Use native type alignments from https://developer.apple.com/metal/Metal-Shading-Language-Specification.pdf */
-#if defined(__MACOSX__) || TARGET_OS_SIMULATOR
+#if defined(__MACOSX__) || TARGET_OS_SIMULATOR || TARGET_OS_MACCATALYST
 #define CONSTANT_ALIGN(x) (256)
 #else
 #define CONSTANT_ALIGN(x) (x < 4 ? 4 : x)
@@ -166,11 +167,12 @@ typedef struct METAL_ShaderPipelines
     @property (nonatomic, retain) id<MTLTexture> mtltexture_uv;
     @property (nonatomic, retain) id<MTLSamplerState> mtlsampler;
     @property (nonatomic, assign) SDL_MetalFragmentFunction fragmentFunction;
+#if SDL_HAVE_YUV
     @property (nonatomic, assign) BOOL yuv;
     @property (nonatomic, assign) BOOL nv12;
     @property (nonatomic, assign) size_t conversionBufferOffset;
+#endif
     @property (nonatomic, assign) BOOL hasdata;
-
     @property (nonatomic, retain) id<MTLBuffer> lockedbuffer;
     @property (nonatomic, assign) SDL_Rect lockedrect;
 @end
@@ -279,26 +281,35 @@ MakePipelineState(METAL_RenderData *data, METAL_PipelineCache *cache,
 
     switch (cache->vertexFunction) {
         case SDL_METAL_VERTEX_SOLID:
-            /* position (float2) */
-            vertdesc.layouts[0].stride = sizeof(float) * 2;
+            /* position (float2), color (uchar4normalized) */
+            vertdesc.layouts[0].stride = sizeof(float) * 2 + sizeof (int);
             vertdesc.layouts[0].stepFunction = MTLVertexStepFunctionPerVertex;
 
             vertdesc.attributes[0].format = MTLVertexFormatFloat2;
             vertdesc.attributes[0].offset = 0;
             vertdesc.attributes[0].bufferIndex = 0;
+
+            vertdesc.attributes[1].format = MTLVertexFormatUChar4Normalized;
+            vertdesc.attributes[1].offset = sizeof (float) * 2;
+            vertdesc.attributes[1].bufferIndex = 0;
+
             break;
         case SDL_METAL_VERTEX_COPY:
-            /* position (float2), texcoord (float2) */
-            vertdesc.layouts[0].stride = sizeof(float) * 4;
+            /* position (float2), color (uchar4normalized), texcoord (float2) */
+            vertdesc.layouts[0].stride = sizeof(float) * 2 + sizeof (int) + sizeof (float) * 2;
             vertdesc.layouts[0].stepFunction = MTLVertexStepFunctionPerVertex;
 
             vertdesc.attributes[0].format = MTLVertexFormatFloat2;
             vertdesc.attributes[0].offset = 0;
             vertdesc.attributes[0].bufferIndex = 0;
 
-            vertdesc.attributes[1].format = MTLVertexFormatFloat2;
-            vertdesc.attributes[1].offset = sizeof(float) * 2;
+            vertdesc.attributes[1].format = MTLVertexFormatUChar4Normalized;
+            vertdesc.attributes[1].offset = sizeof (float) * 2;
             vertdesc.attributes[1].bufferIndex = 0;
+
+            vertdesc.attributes[2].format = MTLVertexFormatFloat2;
+            vertdesc.attributes[2].offset = sizeof(float) * 2 + sizeof (int);
+            vertdesc.attributes[2].bufferIndex = 0;
             break;
     }
 
@@ -450,7 +461,7 @@ ChoosePipelineState(METAL_RenderData *data, METAL_ShaderPipelines *pipelines, SD
     return MakePipelineState(data, cache, [NSString stringWithFormat:@" (blend=custom 0x%x)", blendmode], blendmode);
 }
 
-static void
+static SDL_bool
 METAL_ActivateRenderCommandEncoder(SDL_Renderer * renderer, MTLLoadAction load, MTLClearColor *clear_color, id<MTLBuffer> vertex_buffer)
 {
     METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata;
@@ -472,10 +483,16 @@ METAL_ActivateRenderCommandEncoder(SDL_Renderer * renderer, MTLLoadAction load,
                     load = MTLLoadActionDontCare;
                 }
             }
-            mtltexture = data.mtlbackbuffer.texture;
+            if (data.mtlbackbuffer != nil) {
+                mtltexture = data.mtlbackbuffer.texture;
+            }
         }
 
-        SDL_assert(mtltexture);
+        /* mtltexture can be nil here if macOS refused to give us a drawable,
+           which apparently can happen for minimized windows, etc. */
+        if (mtltexture == nil) {
+            return SDL_FALSE;
+        }
 
         if (load == MTLLoadActionClear) {
             SDL_assert(clear_color != NULL);
@@ -508,6 +525,8 @@ METAL_ActivateRenderCommandEncoder(SDL_Renderer * renderer, MTLLoadAction load,
         //  or whatever. This means we can _always_ batch rendering commands!
         [data.mtlcmdbuffer enqueue];
     }
+
+    return SDL_TRUE;
 }
 
 static void
@@ -587,14 +606,14 @@ METAL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
             mtltexdesc.usage = MTLTextureUsageShaderRead;
         }
     }
-    
+
     id<MTLTexture> mtltexture = [data.mtldevice newTextureWithDescriptor:mtltexdesc];
     if (mtltexture == nil) {
         return SDL_SetError("Texture allocation failed");
     }
 
     id<MTLTexture> mtltexture_uv = nil;
-
+#if SDL_HAVE_YUV
     BOOL yuv = (texture->format == SDL_PIXELFORMAT_IYUV) || (texture->format == SDL_PIXELFORMAT_YV12);
     BOOL nv12 = (texture->format == SDL_PIXELFORMAT_NV12) || (texture->format == SDL_PIXELFORMAT_NV21);
 
@@ -619,7 +638,7 @@ METAL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
             return SDL_SetError("Texture allocation failed");
         }
     }
-
+#endif /* SDL_HAVE_YUV */
     METAL_TextureData *texturedata = [[METAL_TextureData alloc] init];
     if (texture->scaleMode == SDL_ScaleModeNearest) {
         texturedata.mtlsampler = data.mtlsamplernearest;
@@ -628,7 +647,7 @@ METAL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
     }
     texturedata.mtltexture = mtltexture;
     texturedata.mtltexture_uv = mtltexture_uv;
-
+#if SDL_HAVE_YUV
     texturedata.yuv = yuv;
     texturedata.nv12 = nv12;
 
@@ -638,10 +657,12 @@ METAL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
         texturedata.fragmentFunction = SDL_METAL_FRAGMENT_NV12;
     } else if (texture->format == SDL_PIXELFORMAT_NV21) {
         texturedata.fragmentFunction = SDL_METAL_FRAGMENT_NV21;
-    } else {
+    } else
+#endif
+    {
         texturedata.fragmentFunction = SDL_METAL_FRAGMENT_COPY;
     }
-
+#if SDL_HAVE_YUV
     if (yuv || nv12) {
         size_t offset = 0;
         SDL_YUV_CONVERSION_MODE mode = SDL_GetYUVConversionModeForResolution(texture->w, texture->h);
@@ -653,7 +674,7 @@ METAL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
         }
         texturedata.conversionBufferOffset = offset;
     }
-
+#endif
     texture->driverdata = (void*)CFBridgingRetain(texturedata);
 
 #if !__has_feature(objc_arc)
@@ -767,7 +788,7 @@ METAL_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
     if (METAL_UpdateTextureInternal(renderer, texturedata, texturedata.mtltexture, *rect, 0, pixels, pitch) < 0) {
         return -1;
     }
-
+#if SDL_HAVE_YUV
     if (texturedata.yuv) {
         int Uslice = texture->format == SDL_PIXELFORMAT_YV12 ? 1 : 0;
         int Vslice = texture->format == SDL_PIXELFORMAT_YV12 ? 0 : 1;
@@ -797,12 +818,13 @@ METAL_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
             return -1;
         }
     }
-
+#endif
     texturedata.hasdata = YES;
 
     return 0;
 }}
 
+#if SDL_HAVE_YUV
 static int
 METAL_UpdateTextureYUV(SDL_Renderer * renderer, SDL_Texture * texture,
                     const SDL_Rect * rect,
@@ -835,6 +857,34 @@ METAL_UpdateTextureYUV(SDL_Renderer * renderer, SDL_Texture * texture,
     return 0;
 }}
 
+static int
+METAL_UpdateTextureNV(SDL_Renderer * renderer, SDL_Texture * texture,
+                    const SDL_Rect * rect,
+                    const Uint8 *Yplane, int Ypitch,
+                    const Uint8 *UVplane, int UVpitch)
+{ @autoreleasepool {
+    METAL_TextureData *texturedata = (__bridge METAL_TextureData *)texture->driverdata;
+    SDL_Rect UVrect = {rect->x / 2, rect->y / 2, (rect->w + 1) / 2, (rect->h + 1) / 2};
+
+    /* Bail out if we're supposed to update an empty rectangle */
+    if (rect->w <= 0 || rect->h <= 0) {
+        return 0;
+    }
+
+    if (METAL_UpdateTextureInternal(renderer, texturedata, texturedata.mtltexture, *rect, 0, Yplane, Ypitch) < 0) {
+        return -1;
+    }
+
+    if (METAL_UpdateTextureInternal(renderer, texturedata, texturedata.mtltexture_uv, UVrect, 0, UVplane, UVpitch) < 0) {
+        return -1;
+    }
+
+    texturedata.hasdata = YES;
+
+    return 0;
+}}
+#endif
+
 static int
 METAL_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
                const SDL_Rect * rect, void **pixels, int *pitch)
@@ -849,10 +899,12 @@ METAL_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
     }
 
     *pitch = SDL_BYTESPERPIXEL(texture->format) * rect->w;
-
+#if SDL_HAVE_YUV
     if (texturedata.yuv || texturedata.nv12) {
         buffersize = ((*pitch) * rect->h) + (2 * (*pitch + 1) / 2) * ((rect->h + 1) / 2);
-    } else {
+    } else
+#endif
+    {
         buffersize = (*pitch) * rect->h;
     }
 
@@ -906,7 +958,7 @@ METAL_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
            destinationSlice:0
            destinationLevel:0
           destinationOrigin:MTLOriginMake(rect.x, rect.y, 0)];
-
+#if SDL_HAVE_YUV
     if (texturedata.yuv) {
         int Uslice = texture->format == SDL_PIXELFORMAT_YV12 ? 1 : 0;
         int Vslice = texture->format == SDL_PIXELFORMAT_YV12 ? 0 : 1;
@@ -946,7 +998,7 @@ METAL_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
                destinationLevel:0
               destinationOrigin:MTLOriginMake(UVrect.x, UVrect.y, 0)];
     }
-
+#endif
     [blitcmd endEncoding];
 
     [data.mtlcmdbuffer commit];
@@ -991,13 +1043,6 @@ METAL_SetRenderTarget(SDL_Renderer * renderer, SDL_Texture * texture)
 }}
 
 
-// normalize a value from 0.0f to len into 0.0f to 1.0f.
-static inline float
-normtex(const float _val, const float len)
-{
-    return _val / len;
-}
-
 static int
 METAL_QueueSetViewport(SDL_Renderer * renderer, SDL_RenderCommand *cmd)
 {
@@ -1031,38 +1076,66 @@ METAL_QueueSetDrawColor(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
     if (!verts) {
         return -1;
     }
+    /*
+     * FIXME: not needed anymore, some cleanup to do 
+     *
     *(verts++) = ((float)cmd->data.color.r) / 255.0f;
     *(verts++) = ((float)cmd->data.color.g) / 255.0f;
     *(verts++) = ((float)cmd->data.color.b) / 255.0f;
     *(verts++) = ((float)cmd->data.color.a) / 255.0f;
+    */
     return 0;
 }
 
 static int
 METAL_QueueDrawPoints(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FPoint * points, int count)
 {
-    const size_t vertlen = (sizeof (float) * 2) * count;
+    const SDL_Color color = {
+        cmd->data.draw.r,
+        cmd->data.draw.g,
+        cmd->data.draw.b,
+        cmd->data.draw.a
+    };
+
+    const size_t vertlen = (2 * sizeof (float) + sizeof (SDL_Color)) * count;
     float *verts = (float *) SDL_AllocateRenderVertices(renderer, vertlen, DEVICE_ALIGN(8), &cmd->data.draw.first);
     if (!verts) {
         return -1;
     }
     cmd->data.draw.count = count;
-    SDL_memcpy(verts, points, vertlen);
+
+    for (int i = 0; i < count; i++, points++) {
+        *(verts++) = points->x;
+        *(verts++) = points->y;
+        *((SDL_Color *)verts++) = color;
+    }
     return 0;
 }
 
 static int
 METAL_QueueDrawLines(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FPoint * points, int count)
 {
+    const SDL_Color color = {
+        cmd->data.draw.r,
+        cmd->data.draw.g,
+        cmd->data.draw.b,
+        cmd->data.draw.a
+    };
+
     SDL_assert(count >= 2);  /* should have been checked at the higher level. */
 
-    const size_t vertlen = (sizeof (float) * 2) * count;
+    const size_t vertlen = (2 * sizeof (float) + sizeof (SDL_Color)) * count;
     float *verts = (float *) SDL_AllocateRenderVertices(renderer, vertlen, DEVICE_ALIGN(8), &cmd->data.draw.first);
     if (!verts) {
         return -1;
     }
     cmd->data.draw.count = count;
-    SDL_memcpy(verts, points, vertlen);
+
+    for (int i = 0; i < count; i++, points++) {
+        *(verts++) = points->x;
+        *(verts++) = points->y;
+        *((SDL_Color *)verts++) = color;
+    }
 
     /* If the line segment is completely horizontal or vertical,
        make it one pixel longer, to satisfy the diamond-exit rule.
@@ -1072,8 +1145,8 @@ METAL_QueueDrawLines(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_
        that are missing a pixel that frames something and not arbitrary
        angles. Maybe !!! FIXME for later, though. */
 
-    points += count - 2;  /* update the last line. */
-    verts += (count * 2) - 2;
+    points -= 2;  /* update the last line. */
+    verts -= 2 + 1;
 
     const float xstart = points[0].x;
     const float ystart = points[0].y;
@@ -1090,161 +1163,50 @@ METAL_QueueDrawLines(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_
 }
 
 static int
-METAL_QueueFillRects(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FRect * rects, int count)
+METAL_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+        const float *xy, int xy_stride, const SDL_Color *color, int color_stride, const float *uv, int uv_stride,
+        int num_vertices, const void *indices, int num_indices, int size_indices,
+        float scale_x, float scale_y)
 {
-    const size_t vertlen = (sizeof (float) * 8) * count;
+    int count = indices ? num_indices : num_vertices;
+    const size_t vertlen = (2 * sizeof (float) + sizeof (int) + (texture ? 2 : 0) * sizeof (float)) * count;
     float *verts = (float *) SDL_AllocateRenderVertices(renderer, vertlen, DEVICE_ALIGN(8), &cmd->data.draw.first);
     if (!verts) {
         return -1;
     }
 
     cmd->data.draw.count = count;
+    size_indices = indices ? size_indices : 0;
 
-    /* Quads in the following vertex order (matches the quad index buffer):
-     * 1---3
-     * | \ |
-     * 0---2
-     */
-    for (int i = 0; i < count; i++, rects++) {
-        if ((rects->w <= 0.0f) || (rects->h <= 0.0f)) {
-            cmd->data.draw.count--;
+    for (int i = 0; i < count; i++) {
+        int j;
+        if (size_indices == 4) {
+            j = ((const Uint32 *)indices)[i];
+        } else if (size_indices == 2) {
+            j = ((const Uint16 *)indices)[i];
+        } else if (size_indices == 1) {
+            j = ((const Uint8 *)indices)[i];
         } else {
-            *(verts++) = rects->x;
-            *(verts++) = rects->y + rects->h;
-            *(verts++) = rects->x;
-            *(verts++) = rects->y;
-            *(verts++) = rects->x + rects->w;
-            *(verts++) = rects->y + rects->h;
-            *(verts++) = rects->x + rects->w;
-            *(verts++) = rects->y;
+            j = i;
+        }
+
+        float *xy_ = (float *)((char*)xy + j * xy_stride);
+
+        *(verts++) = xy_[0] * scale_x;
+        *(verts++) = xy_[1] * scale_y;
+
+        *((SDL_Color *)verts++) = *(SDL_Color *)((char*)color + j * color_stride);
+
+        if (texture) {
+            float *uv_ = (float *)((char*)uv + j * uv_stride);
+            *(verts++) = uv_[0];
+            *(verts++) = uv_[1];
         }
     }
 
-    if (cmd->data.draw.count == 0) {
-        cmd->command = SDL_RENDERCMD_NO_OP;  // nothing to do, just skip this one later.
-    }
-
     return 0;
 }
 
-static int
-METAL_QueueCopy(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture,
-                const SDL_Rect * srcrect, const SDL_FRect * dstrect)
-{
-    const float texw = (float) texture->w;
-    const float texh = (float) texture->h;
-    // !!! FIXME: use an index buffer
-    const size_t vertlen = (sizeof (float) * 16);
-    float *verts = (float *) SDL_AllocateRenderVertices(renderer, vertlen, DEVICE_ALIGN(8), &cmd->data.draw.first);
-    if (!verts) {
-        return -1;
-    }
-
-    cmd->data.draw.count = 1;
-
-    /* Interleaved positions and texture coordinates */
-    *(verts++) = dstrect->x;
-    *(verts++) = dstrect->y + dstrect->h;
-    *(verts++) = normtex(srcrect->x, texw);
-    *(verts++) = normtex(srcrect->y + srcrect->h, texh);
-
-    *(verts++) = dstrect->x;
-    *(verts++) = dstrect->y;
-    *(verts++) = normtex(srcrect->x, texw);
-    *(verts++) = normtex(srcrect->y, texh);
-
-    *(verts++) = dstrect->x + dstrect->w;
-    *(verts++) = dstrect->y + dstrect->h;
-    *(verts++) = normtex(srcrect->x + srcrect->w, texw);
-    *(verts++) = normtex(srcrect->y + srcrect->h, texh);
-
-    *(verts++) = dstrect->x + dstrect->w;
-    *(verts++) = dstrect->y;
-    *(verts++) = normtex(srcrect->x + srcrect->w, texw);
-    *(verts++) = normtex(srcrect->y, texh);
-
-    return 0;
-}
-
-static int
-METAL_QueueCopyEx(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture,
-                  const SDL_Rect * srcquad, const SDL_FRect * dstrect,
-                  const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip)
-{
-    const float texw = (float) texture->w;
-    const float texh = (float) texture->h;
-    const float rads = (float)(M_PI * (float) angle / 180.0f);
-    const float c = cosf(rads), s = sinf(rads);
-    float minu, maxu, minv, maxv;
-    const size_t vertlen = (sizeof (float) * 32);
-    float *verts;
-
-    // cheat and store this offset in (count) because it needs to be aligned in ways other fields don't and we aren't using count otherwise.
-    verts = (float *) SDL_AllocateRenderVertices(renderer, vertlen, CONSTANT_ALIGN(16), &cmd->data.draw.count);
-    if (!verts) {
-        return -1;
-    }
-
-    // transform matrix
-    SDL_memset(verts, '\0', sizeof (*verts) * 16);
-    verts[10] = verts[15] = 1.0f;
-    // rotation
-    verts[0] = c;
-    verts[1] = s;
-    verts[4] = -s;
-    verts[5] = c;
-
-    // translation
-    verts[12] = dstrect->x + center->x;
-    verts[13] = dstrect->y + center->y;
-
-    // rest of the vertices don't need the aggressive alignment. Pack them in.
-    verts = (float *) SDL_AllocateRenderVertices(renderer, vertlen, DEVICE_ALIGN(8), &cmd->data.draw.first);
-    if (!verts) {
-        return -1;
-    }
-
-    minu = normtex(srcquad->x, texw);
-    maxu = normtex(srcquad->x + srcquad->w, texw);
-    minv = normtex(srcquad->y, texh);
-    maxv = normtex(srcquad->y + srcquad->h, texh);
-
-    if (flip & SDL_FLIP_HORIZONTAL) {
-        float tmp = maxu;
-        maxu = minu;
-        minu = tmp;
-    }
-    if (flip & SDL_FLIP_VERTICAL) {
-        float tmp = maxv;
-        maxv = minv;
-        minv = tmp;
-    }
-
-    /* Interleaved positions and texture coordinates */
-    *(verts++) = -center->x;
-    *(verts++) = dstrect->h - center->y;
-    *(verts++) = minu;
-    *(verts++) = maxv;
-
-    *(verts++) = -center->x;
-    *(verts++) = -center->y;
-    *(verts++) = minu;
-    *(verts++) = minv;
-
-    *(verts++) = dstrect->w - center->x;
-    *(verts++) = dstrect->h - center->y;
-    *(verts++) = maxu;
-    *(verts++) = maxv;
-
-    *(verts++) = dstrect->w - center->x;
-    *(verts++) = -center->y;
-    *(verts++) = maxu;
-    *(verts++) = minv;
-
-    return 0;
-}
-
-
 typedef struct
 {
     #if __has_feature(objc_arc)
@@ -1266,7 +1228,7 @@ typedef struct
     size_t color_offset;
 } METAL_DrawStateCache;
 
-static void
+static SDL_bool
 SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const SDL_MetalFragmentFunction shader,
              const size_t constants_offset, id<MTLBuffer> mtlbufvertex, METAL_DrawStateCache *statecache)
 {
@@ -1275,7 +1237,9 @@ SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const SDL_Met
     size_t first = cmd->data.draw.first;
     id<MTLRenderPipelineState> newpipeline;
 
-    METAL_ActivateRenderCommandEncoder(renderer, MTLLoadActionLoad, NULL, statecache->vertex_buffer);
+    if (!METAL_ActivateRenderCommandEncoder(renderer, MTLLoadActionLoad, NULL, statecache->vertex_buffer)) {
+        return SDL_FALSE;
+    }
 
     if (statecache->viewport_dirty) {
         MTLViewport viewport;
@@ -1291,22 +1255,29 @@ SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const SDL_Met
     }
 
     if (statecache->cliprect_dirty) {
-        MTLScissorRect mtlrect;
+        SDL_Rect output;
+        SDL_Rect clip;
         if (statecache->cliprect_enabled) {
-            const SDL_Rect *rect = &statecache->cliprect;
-            mtlrect.x = statecache->viewport.x + rect->x;
-            mtlrect.y = statecache->viewport.y + rect->y;
-            mtlrect.width = rect->w;
-            mtlrect.height = rect->h;
+            clip = statecache->cliprect;
+            clip.x += statecache->viewport.x;
+            clip.y += statecache->viewport.y;
         } else {
-            mtlrect.x = statecache->viewport.x;
-            mtlrect.y = statecache->viewport.y;
-            mtlrect.width = statecache->viewport.w;
-            mtlrect.height = statecache->viewport.h;
+            clip = statecache->viewport;
         }
-        if (mtlrect.width > 0 && mtlrect.height > 0) {
+
+        /* Set Scissor Rect Validation: w/h must be <= render pass */
+        SDL_zero(output);
+        METAL_GetOutputSize(renderer, &output.w, &output.h);
+
+        if (SDL_IntersectRect(&output, &clip, &clip)) {
+            MTLScissorRect mtlrect;
+            mtlrect.x = clip.x;
+            mtlrect.y = clip.y;
+            mtlrect.width = clip.w;
+            mtlrect.height = clip.h;
             [data.mtlcmdencoder setScissorRect:mtlrect];
         }
+
         statecache->cliprect_dirty = SDL_FALSE;
     }
 
@@ -1329,9 +1300,10 @@ SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const SDL_Met
     }
 
     [data.mtlcmdencoder setVertexBufferOffset:first atIndex:0]; /* position/texcoords */
+    return SDL_TRUE;
 }
 
-static void
+static SDL_bool
 SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const size_t constants_offset,
              id<MTLBuffer> mtlbufvertex, METAL_DrawStateCache *statecache)
 {
@@ -1339,7 +1311,9 @@ SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const size_t
     SDL_Texture *texture = cmd->data.draw.texture;
     METAL_TextureData *texturedata = (__bridge METAL_TextureData *)texture->driverdata;
 
-    SetDrawState(renderer, cmd, texturedata.fragmentFunction, constants_offset, mtlbufvertex, statecache);
+    if (!SetDrawState(renderer, cmd, texturedata.fragmentFunction, constants_offset, mtlbufvertex, statecache)) {
+        return SDL_FALSE;
+    }
 
     if (texture != statecache->texture) {
         METAL_TextureData *oldtexturedata = NULL;
@@ -1351,12 +1325,15 @@ SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const size_t
         }
 
         [data.mtlcmdencoder setFragmentTexture:texturedata.mtltexture atIndex:0];
+#if SDL_HAVE_YUV
         if (texturedata.yuv || texturedata.nv12) {
             [data.mtlcmdencoder setFragmentTexture:texturedata.mtltexture_uv atIndex:1];
             [data.mtlcmdencoder setFragmentBuffer:data.mtlbufconstants offset:texturedata.conversionBufferOffset atIndex:1];
         }
+#endif
         statecache->texture = texture;
     }
+    return SDL_TRUE;
 }
 
 static int
@@ -1454,6 +1431,7 @@ METAL_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *ver
                 MTLClearColor color = MTLClearColorMake(r / 255.0f, g / 255.0f, b / 255.0f, a / 255.0f);
 
                 // get new command encoder, set up with an initial clear operation.
+                // (this might fail, and future draw operations will notice.)
                 METAL_ActivateRenderCommandEncoder(renderer, MTLLoadActionClear, &color, mtlbufvertex);
                 break;
             }
@@ -1462,44 +1440,34 @@ METAL_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *ver
             case SDL_RENDERCMD_DRAW_LINES: {
                 const size_t count = cmd->data.draw.count;
                 const MTLPrimitiveType primtype = (cmd->command == SDL_RENDERCMD_DRAW_POINTS) ? MTLPrimitiveTypePoint : MTLPrimitiveTypeLineStrip;
-                SetDrawState(renderer, cmd, SDL_METAL_FRAGMENT_SOLID, CONSTANTS_OFFSET_HALF_PIXEL_TRANSFORM, mtlbufvertex, &statecache);
-                [data.mtlcmdencoder drawPrimitives:primtype vertexStart:0 vertexCount:count];
-                break;
-            }
-
-            case SDL_RENDERCMD_FILL_RECTS: {
-                const size_t count = cmd->data.draw.count;
-                const size_t maxcount = UINT16_MAX / 4;
-                SetDrawState(renderer, cmd, SDL_METAL_FRAGMENT_SOLID, CONSTANTS_OFFSET_IDENTITY, mtlbufvertex, &statecache);
-                if (count == 1) {
-                    [data.mtlcmdencoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4];
-                } else {
-                    /* Our index buffer has 16 bit indices, so we can only draw
-                     * 65k vertices (16k rects) at a time. */
-                    for (size_t i = 0; i < count; i += maxcount) {
-                        /* Set the vertex buffer offset for our current positions.
-                         * The vertex buffer itself was bound in SetDrawState. */
-                        [data.mtlcmdencoder setVertexBufferOffset:cmd->data.draw.first + i*sizeof(float)*8 atIndex:0];
-                        [data.mtlcmdencoder drawIndexedPrimitives:MTLPrimitiveTypeTriangle
-                                                       indexCount:SDL_min(maxcount, count - i) * 6
-                                                        indexType:MTLIndexTypeUInt16
-                                                      indexBuffer:data.mtlbufquadindices
-                                                indexBufferOffset:0];
-                    }
+                if (SetDrawState(renderer, cmd, SDL_METAL_FRAGMENT_SOLID, CONSTANTS_OFFSET_HALF_PIXEL_TRANSFORM, mtlbufvertex, &statecache)) {
+                    [data.mtlcmdencoder drawPrimitives:primtype vertexStart:0 vertexCount:count];
                 }
                 break;
             }
 
-            case SDL_RENDERCMD_COPY: {
-                SetCopyState(renderer, cmd, CONSTANTS_OFFSET_IDENTITY, mtlbufvertex, &statecache);
-                [data.mtlcmdencoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4];
+            case SDL_RENDERCMD_FILL_RECTS: /* unused */
                 break;
-            }
 
-            case SDL_RENDERCMD_COPY_EX: {
-                SetCopyState(renderer, cmd, CONSTANTS_OFFSET_INVALID, mtlbufvertex, &statecache);
-                [data.mtlcmdencoder setVertexBuffer:mtlbufvertex offset:cmd->data.draw.count atIndex:3];  // transform
-                [data.mtlcmdencoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4];
+            case SDL_RENDERCMD_COPY: /* unused */
+                break;
+
+            case SDL_RENDERCMD_COPY_EX: /* unused */
+                break;
+
+            case SDL_RENDERCMD_GEOMETRY: {
+                const size_t count = cmd->data.draw.count;
+                SDL_Texture *texture = cmd->data.draw.texture;
+
+                if (texture) {
+                    if (SetCopyState(renderer, cmd, CONSTANTS_OFFSET_IDENTITY, mtlbufvertex, &statecache)) {
+                        [data.mtlcmdencoder drawPrimitives:MTLPrimitiveTypeTriangle vertexStart:0 vertexCount:count];
+                    }
+                } else {
+                    if (SetDrawState(renderer, cmd, SDL_METAL_FRAGMENT_SOLID, CONSTANTS_OFFSET_IDENTITY, mtlbufvertex, &statecache)) {
+                        [data.mtlcmdencoder drawPrimitives:MTLPrimitiveTypeTriangle vertexStart:0 vertexCount:count];
+                    }
+                }
                 break;
             }
 
@@ -1517,7 +1485,9 @@ METAL_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
                     Uint32 pixel_format, void * pixels, int pitch)
 { @autoreleasepool {
     METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata;
-    METAL_ActivateRenderCommandEncoder(renderer, MTLLoadActionLoad, NULL, nil);
+    if (!METAL_ActivateRenderCommandEncoder(renderer, MTLLoadActionLoad, NULL, nil)) {
+        return SDL_SetError("Failed to activate render command encoder (is your window in the background?");
+    }
 
     [data.mtlcmdencoder endEncoding];
     id<MTLTexture> mtltexture = data.mtlpassdesc.colorAttachments[0].texture;
@@ -1562,20 +1532,28 @@ static void
 METAL_RenderPresent(SDL_Renderer * renderer)
 { @autoreleasepool {
     METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata;
+    SDL_bool ready = SDL_TRUE;
 
     // If we don't have a command buffer, we can't present, so activate to get one.
     if (data.mtlcmdencoder == nil) {
         // We haven't even gotten a backbuffer yet? Clear it to black. Otherwise, load the existing data.
         if (data.mtlbackbuffer == nil) {
             MTLClearColor color = MTLClearColorMake(0.0f, 0.0f, 0.0f, 1.0f);
-            METAL_ActivateRenderCommandEncoder(renderer, MTLLoadActionClear, &color, nil);
+            ready = METAL_ActivateRenderCommandEncoder(renderer, MTLLoadActionClear, &color, nil);
         } else {
-            METAL_ActivateRenderCommandEncoder(renderer, MTLLoadActionLoad, NULL, nil);
+            ready = METAL_ActivateRenderCommandEncoder(renderer, MTLLoadActionLoad, NULL, nil);
         }
     }
 
     [data.mtlcmdencoder endEncoding];
-    [data.mtlcmdbuffer presentDrawable:data.mtlbackbuffer];
+
+    // If we don't have a drawable to present, don't try to present it.
+    //  But we'll still try to commit the command buffer in case it was already enqueued.
+    if (ready) {
+        SDL_assert(data.mtlbackbuffer != nil);
+        [data.mtlcmdbuffer presentDrawable:data.mtlbackbuffer];
+    }
+
     [data.mtlcmdbuffer commit];
 
     data.mtlcmdencoder = nil;
@@ -1602,7 +1580,11 @@ METAL_DestroyRenderer(SDL_Renderer * renderer)
 
         DestroyAllPipelines(data.allpipelines, data.pipelinescount);
 
-        SDL_Metal_DestroyView(data.mtlview);
+        /* Release the metal view instead of destroying it,
+           in case we want to use it later (recreating the renderer)
+         */
+        /* SDL_Metal_DestroyView(data.mtlview); */
+        CFBridgingRelease(data.mtlview);
     }
 
     SDL_free(renderer);
@@ -1618,11 +1600,61 @@ METAL_GetMetalLayer(SDL_Renderer * renderer)
 static void *
 METAL_GetMetalCommandEncoder(SDL_Renderer * renderer)
 { @autoreleasepool {
+    // note that data.mtlcmdencoder can be nil if METAL_ActivateRenderCommandEncoder fails.
+    //  Before SDL 2.0.18, it might have returned a non-nil encoding that might not have been
+    //  usable for presentation. Check your return values!
     METAL_ActivateRenderCommandEncoder(renderer, MTLLoadActionLoad, NULL, nil);
     METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata;
     return (__bridge void*)data.mtlcmdencoder;
 }}
 
+static int
+METAL_SetVSync(SDL_Renderer * renderer, const int vsync)
+{
+#if (defined(__MACOSX__) && defined(MAC_OS_X_VERSION_10_13)) || TARGET_OS_MACCATALYST
+    if (@available(macOS 10.13, *)) {
+        METAL_RenderData *data = (__bridge METAL_RenderData *) renderer->driverdata;
+        if (vsync) {
+            data.mtllayer.displaySyncEnabled = YES;
+            renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
+        } else {
+            data.mtllayer.displaySyncEnabled = NO;
+            renderer->info.flags &= ~SDL_RENDERER_PRESENTVSYNC;
+        }
+        return 0;
+    }
+#endif
+    return SDL_SetError("This Apple OS does not support displaySyncEnabled!");
+}
+
+static SDL_MetalView GetWindowView(SDL_Window *window)
+{
+    SDL_SysWMinfo info;
+
+    SDL_VERSION(&info.version);
+    if (SDL_GetWindowWMInfo(window, &info)) {
+#ifdef __MACOSX__
+        if (info.subsystem == SDL_SYSWM_COCOA) {
+            NSView *view = info.info.cocoa.window.contentView;
+            if (view.subviews.count > 0) {
+                view = view.subviews[0];
+                if (view.tag == SDL_METALVIEW_TAG) {
+                    return (SDL_MetalView)CFBridgingRetain(view);
+                }
+            }
+        }
+#else
+        if (info.subsystem == SDL_SYSWM_UIKIT) {
+            UIView *view = info.info.uikit.window.rootViewController.view;
+            if (view.tag == SDL_METALVIEW_TAG) {
+                return (SDL_MetalView)CFBridgingRetain(view);
+            }
+        }
+#endif
+    }
+    return nil;
+}
+
 static SDL_Renderer *
 METAL_CreateRenderer(SDL_Window * window, Uint32 flags)
 { @autoreleasepool {
@@ -1673,7 +1705,10 @@ METAL_CreateRenderer(SDL_Window * window, Uint32 flags)
         return NULL;
     }
 
-    view = SDL_Metal_CreateView(window);
+    view = GetWindowView(window);
+    if (view == nil) {
+        view = SDL_Metal_CreateView(window);
+    }
 
     if (view == NULL) {
 #if !__has_feature(objc_arc)
@@ -1693,7 +1728,11 @@ METAL_CreateRenderer(SDL_Window * window, Uint32 flags)
 #if !__has_feature(objc_arc)
         [mtldevice release];
 #endif
-        SDL_Metal_DestroyView(view);
+        /* Release the metal view instead of destroying it,
+           in case we want to use it later (recreating the renderer)
+         */
+        /* SDL_Metal_DestroyView(view); */
+        CFBridgingRelease(view);
         SDL_free(renderer);
         if (changed_window) {
             SDL_RecreateWindow(window, window_flags);
@@ -1850,7 +1889,10 @@ METAL_CreateRenderer(SDL_Window * window, Uint32 flags)
     renderer->SupportsBlendMode = METAL_SupportsBlendMode;
     renderer->CreateTexture = METAL_CreateTexture;
     renderer->UpdateTexture = METAL_UpdateTexture;
+#if SDL_HAVE_YUV
     renderer->UpdateTextureYUV = METAL_UpdateTextureYUV;
+    renderer->UpdateTextureNV = METAL_UpdateTextureNV;
+#endif
     renderer->LockTexture = METAL_LockTexture;
     renderer->UnlockTexture = METAL_UnlockTexture;
     renderer->SetTextureScaleMode = METAL_SetTextureScaleMode;
@@ -1859,14 +1901,13 @@ METAL_CreateRenderer(SDL_Window * window, Uint32 flags)
     renderer->QueueSetDrawColor = METAL_QueueSetDrawColor;
     renderer->QueueDrawPoints = METAL_QueueDrawPoints;
     renderer->QueueDrawLines = METAL_QueueDrawLines;
-    renderer->QueueFillRects = METAL_QueueFillRects;
-    renderer->QueueCopy = METAL_QueueCopy;
-    renderer->QueueCopyEx = METAL_QueueCopyEx;
+    renderer->QueueGeometry = METAL_QueueGeometry;
     renderer->RunCommandQueue = METAL_RunCommandQueue;
     renderer->RenderReadPixels = METAL_RenderReadPixels;
     renderer->RenderPresent = METAL_RenderPresent;
     renderer->DestroyTexture = METAL_DestroyTexture;
     renderer->DestroyRenderer = METAL_DestroyRenderer;
+    renderer->SetVSync = METAL_SetVSync;
     renderer->GetMetalLayer = METAL_GetMetalLayer;
     renderer->GetMetalCommandEncoder = METAL_GetMetalCommandEncoder;
 
@@ -1875,7 +1916,7 @@ METAL_CreateRenderer(SDL_Window * window, Uint32 flags)
 
     renderer->always_batch = SDL_TRUE;
 
-#if defined(__MACOSX__) && defined(MAC_OS_X_VERSION_10_13)
+#if (defined(__MACOSX__) && defined(MAC_OS_X_VERSION_10_13)) || TARGET_OS_MACCATALYST
     if (@available(macOS 10.13, *)) {
         data.mtllayer.displaySyncEnabled = (flags & SDL_RENDERER_PRESENTVSYNC) != 0;
         if (data.mtllayer.displaySyncEnabled) {
@@ -1889,7 +1930,7 @@ METAL_CreateRenderer(SDL_Window * window, Uint32 flags)
 
     /* https://developer.apple.com/metal/Metal-Feature-Set-Tables.pdf */
     int maxtexsize = 4096;
-#if defined(__MACOSX__)
+#if defined(__MACOSX__) || TARGET_OS_MACCATALYST
     maxtexsize = 16384;
 #elif defined(__TVOS__)
     maxtexsize = 8192;
diff --git a/Engine/lib/sdl/src/render/metal/SDL_shaders_metal.metal b/Engine/lib/sdl/src/render/metal/SDL_shaders_metal.metal
index 7975a39fa..fd9e3a816 100644
--- a/Engine/lib/sdl/src/render/metal/SDL_shaders_metal.metal
+++ b/Engine/lib/sdl/src/render/metal/SDL_shaders_metal.metal
@@ -6,11 +6,13 @@ using namespace metal;
 struct SolidVertexInput
 {
     float2 position [[attribute(0)]];
+    float4 color    [[attribute(1)]];
 };
 
 struct SolidVertexOutput
 {
     float4 position [[position]];
+    float4 color;
     float pointSize [[point_size]];
 };
 
@@ -20,24 +22,27 @@ vertex SolidVertexOutput SDL_Solid_vertex(SolidVertexInput in [[stage_in]],
 {
     SolidVertexOutput v;
     v.position = (projection * transform) * float4(in.position, 0.0f, 1.0f);
+    v.color = in.color;
     v.pointSize = 1.0f;
     return v;
 }
 
-fragment float4 SDL_Solid_fragment(const device float4 &col [[buffer(0)]])
+fragment float4 SDL_Solid_fragment(SolidVertexInput in [[stage_in]])
 {
-    return col;
+    return in.color;
 }
 
 struct CopyVertexInput
 {
     float2 position [[attribute(0)]];
-    float2 texcoord [[attribute(1)]];
+    float4 color    [[attribute(1)]];
+    float2 texcoord [[attribute(2)]];
 };
 
 struct CopyVertexOutput
 {
     float4 position [[position]];
+    float4 color;
     float2 texcoord;
 };
 
@@ -47,16 +52,16 @@ vertex CopyVertexOutput SDL_Copy_vertex(CopyVertexInput in [[stage_in]],
 {
     CopyVertexOutput v;
     v.position = (projection * transform) * float4(in.position, 0.0f, 1.0f);
+    v.color = in.color;
     v.texcoord = in.texcoord;
     return v;
 }
 
 fragment float4 SDL_Copy_fragment(CopyVertexOutput vert [[stage_in]],
-                                  const device float4 &col [[buffer(0)]],
                                   texture2d<float> tex [[texture(0)]],
                                   sampler s [[sampler(0)]])
 {
-    return tex.sample(s, vert.texcoord) * col;
+    return tex.sample(s, vert.texcoord) * vert.color;
 }
 
 struct YUVDecode
@@ -68,7 +73,6 @@ struct YUVDecode
 };
 
 fragment float4 SDL_YUV_fragment(CopyVertexOutput vert [[stage_in]],
-                                 const device float4 &col [[buffer(0)]],
                                  constant YUVDecode &decode [[buffer(1)]],
                                  texture2d<float> texY [[texture(0)]],
                                  texture2d_array<float> texUV [[texture(1)]],
@@ -81,11 +85,10 @@ fragment float4 SDL_YUV_fragment(CopyVertexOutput vert [[stage_in]],
 
     yuv += decode.offset;
 
-    return col * float4(dot(yuv, decode.Rcoeff), dot(yuv, decode.Gcoeff), dot(yuv, decode.Bcoeff), 1.0);
+    return vert.color * float4(dot(yuv, decode.Rcoeff), dot(yuv, decode.Gcoeff), dot(yuv, decode.Bcoeff), 1.0);
 }
 
 fragment float4 SDL_NV12_fragment(CopyVertexOutput vert [[stage_in]],
-                                 const device float4 &col [[buffer(0)]],
                                  constant YUVDecode &decode [[buffer(1)]],
                                  texture2d<float> texY [[texture(0)]],
                                  texture2d<float> texUV [[texture(1)]],
@@ -97,11 +100,10 @@ fragment float4 SDL_NV12_fragment(CopyVertexOutput vert [[stage_in]],
 
     yuv += decode.offset;
 
-    return col * float4(dot(yuv, decode.Rcoeff), dot(yuv, decode.Gcoeff), dot(yuv, decode.Bcoeff), 1.0);
+    return vert.color * float4(dot(yuv, decode.Rcoeff), dot(yuv, decode.Gcoeff), dot(yuv, decode.Bcoeff), 1.0);
 }
 
 fragment float4 SDL_NV21_fragment(CopyVertexOutput vert [[stage_in]],
-                                 const device float4 &col [[buffer(0)]],
                                  constant YUVDecode &decode [[buffer(1)]],
                                  texture2d<float> texY [[texture(0)]],
                                  texture2d<float> texUV [[texture(1)]],
@@ -113,5 +115,6 @@ fragment float4 SDL_NV21_fragment(CopyVertexOutput vert [[stage_in]],
 
     yuv += decode.offset;
 
-    return col * float4(dot(yuv, decode.Rcoeff), dot(yuv, decode.Gcoeff), dot(yuv, decode.Bcoeff), 1.0);
+    return vert.color * float4(dot(yuv, decode.Rcoeff), dot(yuv, decode.Gcoeff), dot(yuv, decode.Bcoeff), 1.0);
 }
+
diff --git a/Engine/lib/sdl/src/render/metal/SDL_shaders_metal_ios.h b/Engine/lib/sdl/src/render/metal/SDL_shaders_metal_ios.h
index c62288d5a..4488c67e7 100644
--- a/Engine/lib/sdl/src/render/metal/SDL_shaders_metal_ios.h
+++ b/Engine/lib/sdl/src/render/metal/SDL_shaders_metal_ios.h
@@ -1,206 +1,208 @@
 const unsigned char sdl_metallib[] = {
   0x4d, 0x54, 0x4c, 0x42, 0x01, 0x00, 0x02, 0x00, 0x05, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x20, 0x56, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x32, 0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4c, 0x03, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0xac, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x04, 0x00, 0x00,
+  0x8e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a, 0x04, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x60, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x51, 0x00, 0x00,
+  0x72, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x50, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00,
   0x4e, 0x41, 0x4d, 0x45, 0x11, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x53, 0x6f,
   0x6c, 0x69, 0x64, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x00, 0x54,
   0x59, 0x50, 0x45, 0x01, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00,
-  0x28, 0x31, 0x40, 0x63, 0x07, 0x67, 0xcf, 0xec, 0x7b, 0x53, 0x36, 0x27,
-  0xdc, 0xe7, 0xb5, 0x97, 0xd0, 0x99, 0xe7, 0x0a, 0x52, 0x5d, 0x98, 0xd7,
-  0xc6, 0x8e, 0xba, 0x3c, 0x01, 0x5f, 0xad, 0xf5, 0x4f, 0x46, 0x46, 0x54,
+  0x13, 0x37, 0x18, 0x80, 0x89, 0x69, 0x90, 0x54, 0x43, 0x22, 0xe0, 0xd3,
+  0xc9, 0x73, 0x9e, 0x97, 0x0d, 0x2b, 0x28, 0xbd, 0x50, 0x37, 0x8f, 0x58,
+  0x37, 0x77, 0x01, 0xac, 0x6d, 0x88, 0x24, 0x29, 0x4f, 0x46, 0x46, 0x54,
   0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00, 0x08, 0x00,
   0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x77, 0x00, 0x00, 0x00,
   0x4e, 0x41, 0x4d, 0x45, 0x10, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x43, 0x6f,
   0x70, 0x79, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x00, 0x54, 0x59,
-  0x50, 0x45, 0x01, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00, 0x47,
-  0xb8, 0x4f, 0x55, 0x1e, 0x1e, 0x4a, 0x32, 0x12, 0x7a, 0x9e, 0xc2, 0xf0,
-  0xf9, 0x2b, 0x85, 0x1f, 0xe9, 0x90, 0x33, 0xc4, 0xdf, 0xa9, 0x3a, 0xca,
-  0x6b, 0x6d, 0xdd, 0xe9, 0x46, 0x64, 0x83, 0x4f, 0x46, 0x46, 0x54, 0x18,
-  0x00, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x50, 0x45, 0x01, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00, 0x91,
+  0x5a, 0xbb, 0x5b, 0x02, 0x11, 0xc3, 0x5b, 0xf6, 0x76, 0xc1, 0x89, 0xa1,
+  0x01, 0x7b, 0x59, 0xb6, 0xd1, 0xe0, 0xb8, 0xdf, 0x74, 0x12, 0x2a, 0xd4,
+  0x0f, 0x39, 0x55, 0x63, 0x7e, 0xe8, 0x4f, 0x4f, 0x46, 0x46, 0x54, 0x18,
+  0x00, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01,
   0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x7a, 0x00, 0x00, 0x00, 0x4e,
   0x41, 0x4d, 0x45, 0x13, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x53, 0x6f, 0x6c,
   0x69, 0x64, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x00,
   0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53, 0x48, 0x20,
-  0x00, 0x69, 0x9d, 0x1d, 0x1f, 0x5c, 0x05, 0x77, 0xfb, 0x40, 0x83, 0x70,
-  0x5e, 0x26, 0x13, 0x34, 0xb5, 0xd7, 0x61, 0x21, 0x42, 0x6a, 0xc9, 0x8d,
-  0xd0, 0x59, 0x04, 0x0b, 0x18, 0x09, 0x74, 0x40, 0x7c, 0x4f, 0x46, 0x46,
-  0x54, 0x18, 0x00, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd0, 0x16, 0x00, 0x00, 0x00,
+  0x00, 0x44, 0xbf, 0x90, 0x59, 0x71, 0xf7, 0xaf, 0x19, 0x2d, 0x19, 0x6e,
+  0x76, 0x40, 0x8a, 0xf6, 0xce, 0x7f, 0x14, 0x46, 0xc9, 0xe3, 0xae, 0x8b,
+  0x7a, 0x85, 0x41, 0x59, 0x0f, 0xbd, 0xd7, 0x95, 0x16, 0x4f, 0x46, 0x46,
+  0x54, 0x18, 0x00, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0x17, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00, 0x08,
   0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x79, 0x00, 0x00,
   0x00, 0x4e, 0x41, 0x4d, 0x45, 0x12, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x43,
   0x6f, 0x70, 0x79, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74,
   0x00, 0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53, 0x48,
-  0x20, 0x00, 0x88, 0x94, 0x57, 0x70, 0x82, 0x3f, 0xe3, 0xbc, 0x88, 0x1c,
-  0x9c, 0x13, 0xbd, 0x4d, 0xc3, 0x16, 0xdf, 0x68, 0x5e, 0xe0, 0xe9, 0xa9,
-  0x06, 0x9e, 0x2f, 0xf0, 0x86, 0xf6, 0x8d, 0x56, 0xf2, 0xbf, 0x4f, 0x46,
-  0x46, 0x54, 0x18, 0x00, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
+  0x20, 0x00, 0x5f, 0x19, 0x9c, 0xe8, 0xec, 0xd5, 0xc9, 0xc3, 0x03, 0xc5,
+  0x04, 0xc4, 0x43, 0x19, 0x4b, 0x03, 0xde, 0x02, 0xe4, 0x31, 0xab, 0x30,
+  0xae, 0xca, 0x0a, 0xb2, 0x45, 0x33, 0x78, 0x01, 0x3f, 0xd3, 0x4f, 0x46,
+  0x46, 0x54, 0x18, 0x00, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0x20, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00,
   0x08, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x78, 0x00,
   0x00, 0x00, 0x4e, 0x41, 0x4d, 0x45, 0x11, 0x00, 0x53, 0x44, 0x4c, 0x5f,
   0x59, 0x55, 0x56, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74,
   0x00, 0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53, 0x48,
-  0x20, 0x00, 0xf7, 0x98, 0xd0, 0xe2, 0xdc, 0xe8, 0x70, 0x90, 0xb8, 0xd2,
-  0x1e, 0x21, 0x36, 0xa4, 0xb8, 0xca, 0x52, 0xcb, 0xb8, 0xc9, 0x61, 0xa4,
-  0x80, 0x75, 0xa2, 0x9b, 0x4b, 0x82, 0x22, 0x60, 0xa6, 0xc9, 0x4f, 0x46,
-  0x46, 0x54, 0x18, 0x00, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00,
+  0x20, 0x00, 0xff, 0xfc, 0x03, 0x55, 0x1e, 0xae, 0x75, 0xbf, 0xb8, 0x4e,
+  0x84, 0xd6, 0xd4, 0x1c, 0x39, 0x5f, 0x4d, 0x60, 0xe8, 0x3a, 0x9c, 0xa7,
+  0xed, 0xa5, 0xcf, 0xaa, 0xff, 0x32, 0xce, 0x0b, 0xd3, 0x57, 0x4f, 0x46,
+  0x46, 0x54, 0x18, 0x00, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x2a, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00,
   0x08, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x79, 0x00,
   0x00, 0x00, 0x4e, 0x41, 0x4d, 0x45, 0x12, 0x00, 0x53, 0x44, 0x4c, 0x5f,
   0x4e, 0x56, 0x31, 0x32, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e,
   0x74, 0x00, 0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53,
-  0x48, 0x20, 0x00, 0x64, 0x76, 0x02, 0x5c, 0xd4, 0x80, 0xf1, 0x25, 0xd7,
-  0x2a, 0xa6, 0xb0, 0x3c, 0xd8, 0xe6, 0x3a, 0x38, 0xe3, 0xd6, 0x15, 0x67,
-  0x59, 0x20, 0xfd, 0x1b, 0xfe, 0x8c, 0x87, 0x1e, 0xfe, 0x9d, 0x9e, 0x4f,
-  0x46, 0x46, 0x54, 0x18, 0x00, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x38, 0x00,
+  0x48, 0x20, 0x00, 0xbe, 0x64, 0x2f, 0xcf, 0xf2, 0xe7, 0x72, 0x42, 0x38,
+  0xf8, 0x0e, 0x52, 0x43, 0x15, 0x53, 0x7e, 0x24, 0x4c, 0xc4, 0x53, 0xfc,
+  0xe6, 0xda, 0xd9, 0x4b, 0x9a, 0xfd, 0x84, 0x1e, 0x42, 0x31, 0x43, 0x4f,
+  0x46, 0x46, 0x54, 0x18, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd0, 0x37, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01,
   0x00, 0x08, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x79,
   0x00, 0x00, 0x00, 0x4e, 0x41, 0x4d, 0x45, 0x12, 0x00, 0x53, 0x44, 0x4c,
   0x5f, 0x4e, 0x56, 0x32, 0x31, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65,
   0x6e, 0x74, 0x00, 0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41,
-  0x53, 0x48, 0x20, 0x00, 0x23, 0xbd, 0x28, 0xce, 0x4f, 0xb7, 0xc7, 0x94,
-  0x2a, 0x0a, 0x20, 0x48, 0x6f, 0x52, 0x4a, 0xcc, 0x07, 0x9c, 0x7f, 0x41,
-  0x8d, 0x0a, 0x31, 0x81, 0xec, 0xe4, 0xd4, 0x71, 0x77, 0x7b, 0x22, 0x7d,
-  0x4f, 0x46, 0x46, 0x54, 0x18, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x44,
+  0x53, 0x48, 0x20, 0x00, 0xe6, 0xe4, 0xd7, 0x33, 0x1f, 0x59, 0xe9, 0x03,
+  0xec, 0x6d, 0x07, 0xd1, 0xa3, 0xc3, 0x49, 0x6a, 0x9d, 0x22, 0x8b, 0xce,
+  0x27, 0xd1, 0xae, 0x1e, 0xfc, 0x33, 0x6d, 0x56, 0x86, 0x25, 0xd5, 0x66,
+  0x4f, 0x46, 0x46, 0x54, 0x18, 0x00, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x44,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00,
   0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54,
-  0x45, 0x4e, 0x44, 0x54, 0x20, 0x00, 0x00, 0x00, 0x56, 0x41, 0x54, 0x54,
-  0x0d, 0x00, 0x01, 0x00, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e,
-  0x00, 0x00, 0x80, 0x56, 0x41, 0x54, 0x59, 0x03, 0x00, 0x01, 0x00, 0x04,
-  0x45, 0x4e, 0x44, 0x54, 0x2c, 0x00, 0x00, 0x00, 0x56, 0x41, 0x54, 0x54,
-  0x18, 0x00, 0x02, 0x00, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e,
-  0x00, 0x00, 0x80, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x00,
-  0x01, 0x80, 0x56, 0x41, 0x54, 0x59, 0x04, 0x00, 0x02, 0x00, 0x04, 0x04,
-  0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54,
-  0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00,
-  0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54,
-  0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00,
-  0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54,
-  0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00,
-  0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54,
-  0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00,
-  0x45, 0x4e, 0x44, 0x54, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00,
-  0x14, 0x00, 0x00, 0x00, 0x3c, 0x0b, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
-  0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0xcc, 0x02, 0x00, 0x00,
-  0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
-  0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39,
-  0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62,
-  0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14,
-  0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90, 0x21,
-  0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8, 0x48,
-  0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00,
-  0x51, 0x18, 0x00, 0x00, 0x84, 0x00, 0x00, 0x00, 0x1b, 0xc8, 0x25, 0xf8,
-  0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x80, 0x8a, 0x18, 0x87, 0x77, 0x90,
-  0x07, 0x79, 0x28, 0x87, 0x71, 0xa0, 0x07, 0x76, 0xc8, 0x87, 0x36, 0x90,
-  0x87, 0x77, 0xa8, 0x07, 0x77, 0x20, 0x87, 0x72, 0x20, 0x87, 0x36, 0x20,
-  0x87, 0x74, 0xb0, 0x87, 0x74, 0x20, 0x87, 0x72, 0x68, 0x83, 0x79, 0x88,
-  0x07, 0x79, 0xa0, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08,
-  0x07, 0x7a, 0x40, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c,
-  0x00, 0x82, 0x1c, 0xd2, 0x61, 0x1e, 0xc2, 0x41, 0x1c, 0xd8, 0xa1, 0x1c,
-  0xda, 0x80, 0x1e, 0xc2, 0x21, 0x1d, 0xd8, 0xa1, 0x0d, 0xc6, 0x21, 0x1c,
-  0xd8, 0x81, 0x1d, 0xe6, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28,
-  0x07, 0x80, 0x60, 0x87, 0x72, 0x98, 0x87, 0x79, 0x68, 0x03, 0x78, 0x90,
-  0x87, 0x72, 0x18, 0x87, 0x74, 0x98, 0x87, 0x72, 0x68, 0x03, 0x73, 0x80,
-  0x87, 0x76, 0x08, 0x07, 0x72, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e,
-  0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c,
-  0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e,
-  0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0x01, 0xa0,
-  0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x06, 0x77, 0x78, 0x87, 0x36, 0x30,
-  0x07, 0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77, 0x48,
-  0x07, 0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76, 0x48,
-  0x87, 0x76, 0x68, 0x03, 0x77, 0x78, 0x07, 0x77, 0x68, 0x03, 0x76, 0x28,
-  0x87, 0x70, 0x30, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x74, 0x70,
-  0x07, 0x73, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08,
-  0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20,
-  0xdc, 0xe1, 0x1d, 0xda, 0x40, 0x1d, 0xea, 0xa1, 0x1d, 0xe0, 0xa1, 0x0d,
-  0xe8, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x1e, 0x00, 0x73, 0x08,
-  0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x70,
-  0x87, 0x70, 0x70, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68,
-  0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c,
-  0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xce, 0xc1, 0x1d,
-  0xca, 0x81, 0x1c, 0xda, 0x40, 0x1f, 0xca, 0x41, 0x1e, 0xde, 0x61, 0x1e,
-  0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d,
-  0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68,
-  0x03, 0x7a, 0x90, 0x87, 0x70, 0x80, 0x07, 0x78, 0x48, 0x07, 0x77, 0x38,
-  0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e,
-  0xea, 0xa1, 0x1c, 0x00, 0x62, 0x1e, 0xe8, 0x21, 0x1c, 0xc6, 0x61, 0x1d,
-  0xda, 0x00, 0x1e, 0xe4, 0xe1, 0x1d, 0xe8, 0xa1, 0x1c, 0xc6, 0x81, 0x1e,
-  0xde, 0x41, 0x1e, 0xda, 0x40, 0x1c, 0xea, 0xc1, 0x1c, 0xcc, 0xa1, 0x1c,
-  0xe4, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xf4, 0xa1, 0x1c, 0x00, 0x3c, 0x00,
-  0x88, 0x7a, 0x70, 0x87, 0x79, 0x08, 0x07, 0x73, 0x28, 0x87, 0x36, 0x30,
+  0x45, 0x4e, 0x44, 0x54, 0x29, 0x00, 0x00, 0x00, 0x56, 0x41, 0x54, 0x54,
+  0x15, 0x00, 0x02, 0x00, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e,
+  0x00, 0x00, 0x80, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x00, 0x01, 0x80, 0x56,
+  0x41, 0x54, 0x59, 0x04, 0x00, 0x02, 0x00, 0x04, 0x06, 0x45, 0x4e, 0x44,
+  0x54, 0x35, 0x00, 0x00, 0x00, 0x56, 0x41, 0x54, 0x54, 0x20, 0x00, 0x03,
+  0x00, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x80,
+  0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x00, 0x01, 0x80, 0x74, 0x65, 0x78, 0x63,
+  0x6f, 0x6f, 0x72, 0x64, 0x00, 0x02, 0x80, 0x56, 0x41, 0x54, 0x59, 0x05,
+  0x00, 0x03, 0x00, 0x04, 0x06, 0x04, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00,
+  0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e,
+  0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00,
+  0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e,
+  0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00,
+  0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e,
+  0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00,
+  0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e,
+  0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0xde, 0xc0,
+  0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0xa0, 0x0b,
+  0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c,
+  0x00, 0x00, 0xe5, 0x02, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00,
+  0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8,
+  0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05,
+  0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92,
+  0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32,
+  0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19,
+  0x21, 0x72, 0x24, 0x07, 0xc8, 0x48, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40,
+  0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00, 0x00, 0x84, 0x00,
+  0x00, 0x00, 0x1b, 0xc8, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90,
+  0x80, 0x8a, 0x18, 0x87, 0x77, 0x90, 0x07, 0x79, 0x28, 0x87, 0x71, 0xa0,
+  0x07, 0x76, 0xc8, 0x87, 0x36, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x77, 0x20,
+  0x87, 0x72, 0x20, 0x87, 0x36, 0x20, 0x87, 0x74, 0xb0, 0x87, 0x74, 0x20,
+  0x87, 0x72, 0x68, 0x83, 0x79, 0x88, 0x07, 0x79, 0xa0, 0x87, 0x36, 0x30,
+  0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0xc0, 0x1c,
+  0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1c, 0xd2, 0x61, 0x1e,
+  0xc2, 0x41, 0x1c, 0xd8, 0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xc2, 0x21, 0x1d,
+  0xd8, 0xa1, 0x0d, 0xc6, 0x21, 0x1c, 0xd8, 0x81, 0x1d, 0xe6, 0x01, 0x30,
+  0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x60, 0x87, 0x72, 0x98,
+  0x87, 0x79, 0x68, 0x03, 0x78, 0x90, 0x87, 0x72, 0x18, 0x87, 0x74, 0x98,
+  0x87, 0x72, 0x68, 0x03, 0x73, 0x80, 0x87, 0x76, 0x08, 0x07, 0x72, 0x00,
+  0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e,
+  0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c,
+  0xd8, 0x21, 0x1d, 0xda, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00,
+  0x06, 0x77, 0x78, 0x87, 0x36, 0x30, 0x07, 0x79, 0x08, 0x87, 0x76, 0x28,
+  0x87, 0x36, 0x80, 0x87, 0x77, 0x48, 0x07, 0x77, 0xa0, 0x87, 0x72, 0x90,
+  0x87, 0x36, 0x28, 0x07, 0x76, 0x48, 0x87, 0x76, 0x68, 0x03, 0x77, 0x78,
+  0x07, 0x77, 0x68, 0x03, 0x76, 0x28, 0x87, 0x70, 0x30, 0x07, 0x80, 0x70,
+  0x87, 0x77, 0x68, 0x83, 0x74, 0x70, 0x07, 0x73, 0x98, 0x87, 0x36, 0x30,
   0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e,
-  0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xea, 0x61, 0x1e, 0xca, 0xa1, 0x0d,
-  0xe6, 0xe1, 0x1d, 0xcc, 0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xd8, 0xe1, 0x1d,
-  0xc2, 0x81, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00,
-  0x36, 0x20, 0x82, 0x00, 0x24, 0xc0, 0x02, 0x54, 0x1b, 0x90, 0x61, 0x00,
-  0x12, 0x60, 0x01, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x49, 0x18, 0x00, 0x00,
-  0x02, 0x00, 0x00, 0x00, 0x13, 0x86, 0x40, 0x18, 0x00, 0x00, 0x00, 0x00,
-  0x89, 0x20, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09,
-  0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3,
-  0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c,
-  0x10, 0x40, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x60, 0x85, 0x00, 0x86, 0x11,
-  0x04, 0x20, 0x09, 0xc2, 0x4c, 0xd4, 0x3c, 0xd0, 0x83, 0x3c, 0xd4, 0xc3,
-  0x38, 0xd0, 0x83, 0x1b, 0xb4, 0x43, 0x39, 0xd0, 0x43, 0x38, 0xb0, 0x83,
-  0x1e, 0xe8, 0x41, 0x3b, 0x84, 0x03, 0x3d, 0xc8, 0x43, 0x3a, 0xe0, 0x03,
-  0x0a, 0xc8, 0x20, 0x42, 0x21, 0x14, 0x42, 0x0c, 0x63, 0xe8, 0x0c, 0x04,
-  0xcc, 0x11, 0x80, 0x41, 0x0a, 0xa8, 0x39, 0x02, 0x50, 0x18, 0x44, 0x08,
-  0x84, 0x61, 0x04, 0x42, 0x19, 0x01, 0x00, 0x00, 0x13, 0xa8, 0x70, 0x48,
-  0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70, 0x80, 0x07, 0x78, 0x60,
-  0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87, 0x79, 0xc8, 0x03, 0x37, 0x80,
-  0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7, 0x51, 0x0e, 0x6d, 0x00, 0x0f, 0x7a,
-  0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74,
-  0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d,
-  0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9,
-  0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76,
-  0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a,
-  0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
-  0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x30, 0x07, 0x72,
-  0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe6,
-  0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74,
-  0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a,
-  0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x73,
-  0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x30, 0x07, 0x72,
-  0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xf6,
-  0x40, 0x07, 0x78, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74,
-  0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a,
-  0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x90, 0x07, 0x76, 0xa0, 0x07, 0x71,
-  0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6,
-  0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a,
-  0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x90, 0x07, 0x72,
-  0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76,
-  0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75,
-  0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x75,
-  0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75,
-  0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74,
-  0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x7a, 0x10, 0x07, 0x70,
-  0x20, 0x07, 0x74, 0xd0, 0x06, 0xee, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x76,
-  0xa0, 0x07, 0x73, 0x20, 0x07, 0x43, 0x18, 0x04, 0x00, 0x80, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x80, 0x2c, 0x10, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
-  0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47,
-  0xc6, 0x04, 0x43, 0x52, 0x25, 0x30, 0x02, 0x50, 0x80, 0x01, 0x45, 0x50,
-  0x20, 0x85, 0x50, 0x10, 0x65, 0x40, 0x6c, 0x04, 0x80, 0xd6, 0x58, 0x82,
-  0x23, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0xce, 0x00, 0x00, 0x00,
-  0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9,
-  0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x86, 0x42, 0x24, 0xc0, 0xa2, 0x50, 0xb9,
-  0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b, 0x62, 0x28,
-  0x41, 0x22, 0x28, 0x06, 0xdd, 0x20, 0x08, 0x0e, 0x8e, 0xad, 0x0c, 0x84,
-  0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x0d,
-  0x64, 0x26, 0x06, 0x06, 0x26, 0xc6, 0x85, 0x66, 0x06, 0x04, 0xa5, 0xad,
-  0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26, 0x06, 0x06, 0x26, 0xc6,
-  0x85, 0x66, 0x26, 0x65, 0x88, 0x90, 0x10, 0x43, 0x0c, 0x25, 0x50, 0x0e,
+  0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x40, 0x1d,
+  0xea, 0xa1, 0x1d, 0xe0, 0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xc4, 0x81, 0x1d,
+  0xca, 0x61, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00,
+  0x08, 0x77, 0x78, 0x87, 0x36, 0x70, 0x87, 0x70, 0x70, 0x87, 0x79, 0x68,
+  0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00,
+  0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d,
+  0xe6, 0x21, 0x1d, 0xce, 0xc1, 0x1d, 0xca, 0x81, 0x1c, 0xda, 0x40, 0x1f,
+  0xca, 0x41, 0x1e, 0xde, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d,
+  0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28,
+  0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x7a, 0x90, 0x87, 0x70, 0x80,
+  0x07, 0x78, 0x48, 0x07, 0x77, 0x38, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0,
+  0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0x62, 0x1e,
+  0xe8, 0x21, 0x1c, 0xc6, 0x61, 0x1d, 0xda, 0x00, 0x1e, 0xe4, 0xe1, 0x1d,
+  0xe8, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0x40, 0x1c,
+  0xea, 0xc1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xe6, 0x21, 0x1d,
+  0xf4, 0xa1, 0x1c, 0x00, 0x3c, 0x00, 0x88, 0x7a, 0x70, 0x87, 0x79, 0x08,
+  0x07, 0x73, 0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08,
+  0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20,
+  0xea, 0x61, 0x1e, 0xca, 0xa1, 0x0d, 0xe6, 0xe1, 0x1d, 0xcc, 0x81, 0x1e,
+  0xda, 0xc0, 0x1c, 0xd8, 0xe1, 0x1d, 0xc2, 0x81, 0x1e, 0x00, 0x73, 0x08,
+  0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x36, 0x20, 0xc2, 0x00, 0x24, 0xc0,
+  0x02, 0x54, 0x1b, 0x90, 0x81, 0x00, 0x12, 0x60, 0x01, 0x2a, 0x00, 0x00,
+  0x00, 0x00, 0x49, 0x18, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x86,
+  0x40, 0x18, 0x00, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x1c, 0x00,
+  0x00, 0x00, 0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22,
+  0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c,
+  0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x40, 0x33, 0x00, 0xc3, 0x08,
+  0x04, 0x60, 0x87, 0x10, 0xc0, 0x30, 0x82, 0x00, 0x24, 0x41, 0x98, 0x89,
+  0x9a, 0x07, 0x7a, 0x90, 0x87, 0x7a, 0x18, 0x07, 0x7a, 0x70, 0x83, 0x76,
+  0x28, 0x07, 0x7a, 0x08, 0x07, 0x76, 0xd0, 0x03, 0x3d, 0x68, 0x87, 0x70,
+  0xa0, 0x07, 0x79, 0x48, 0x07, 0x7c, 0x40, 0x01, 0x19, 0x44, 0x28, 0x84,
+  0x52, 0x88, 0x11, 0x8c, 0xa1, 0x33, 0x10, 0x30, 0x47, 0x00, 0x06, 0x29,
+  0xa0, 0xe6, 0x08, 0x40, 0x61, 0x10, 0x21, 0x10, 0x86, 0x11, 0x08, 0x65,
+  0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0xa8, 0x70, 0x48, 0x07, 0x79,
+  0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72,
+  0x68, 0x83, 0x74, 0x78, 0x87, 0x79, 0xc8, 0x03, 0x37, 0x80, 0x03, 0x37,
+  0x80, 0x83, 0x0d, 0xb7, 0x51, 0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07,
+  0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06,
+  0xe9, 0x10, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e,
+  0x78, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07,
+  0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06,
+  0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
+  0x72, 0xd0, 0x06, 0xe9, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
+  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07,
+  0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06,
+  0xf6, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07,
+  0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x73, 0x20, 0x07,
+  0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07,
+  0x78, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06,
+  0xf6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07,
+  0x74, 0xd0, 0x06, 0xf6, 0x90, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x20, 0x07,
+  0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07,
+  0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07,
+  0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x90, 0x07, 0x72, 0xa0, 0x07,
+  0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06,
+  0xf6, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07,
+  0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07,
+  0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07,
+  0x72, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07,
+  0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07,
+  0x74, 0xd0, 0x06, 0xee, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x43, 0x18, 0x04, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x80, 0x2c, 0x10, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x32, 0x1e,
+  0x98, 0x10, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04,
+  0x43, 0x52, 0x25, 0x30, 0x02, 0x50, 0x80, 0x01, 0x45, 0x50, 0x20, 0x65,
+  0x50, 0x08, 0x05, 0x41, 0x6c, 0x04, 0x80, 0xd6, 0x58, 0x82, 0x43, 0x00,
+  0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0xe4, 0x00, 0x00, 0x00, 0x1a, 0x03,
+  0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4,
+  0x37, 0xb7, 0x21, 0x86, 0x42, 0x24, 0xc0, 0xa2, 0x50, 0xb9, 0x1b, 0x43,
+  0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b, 0x62, 0x28, 0x41, 0x22,
+  0x28, 0x07, 0xe1, 0x20, 0x08, 0x0e, 0x8e, 0xad, 0x0c, 0x84, 0x89, 0xc9,
+  0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x26,
+  0x06, 0x06, 0x26, 0xc6, 0xa5, 0x06, 0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e,
+  0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26, 0x06, 0x06, 0x26, 0xc6, 0xa5, 0x06,
+  0xc6, 0x25, 0x26, 0x65, 0x88, 0x90, 0x10, 0x43, 0x0c, 0x25, 0x50, 0x10,
   0x45, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36, 0x04, 0x49, 0x0e, 0x25,
   0x50, 0x02, 0x45, 0xe0, 0x16, 0x96, 0x26, 0xe7, 0x32, 0xf6, 0xd6, 0x06,
   0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6, 0x26, 0xd7, 0x36, 0xf7,
@@ -216,283 +218,45 @@ const unsigned char sdl_metallib[] = {
   0x3c, 0xb8, 0xb2, 0x2f, 0xb7, 0xb0, 0xb6, 0x32, 0x1a, 0x66, 0x6c, 0x6f,
   0x61, 0x74, 0x34, 0x64, 0xc2, 0xd2, 0xe4, 0x5c, 0xc2, 0xe4, 0xce, 0xbe,
   0xdc, 0xc2, 0xda, 0xca, 0x88, 0xc0, 0xbd, 0xcd, 0xa5, 0xd1, 0xa5, 0xbd,
-  0xb9, 0x0d, 0x51, 0x92, 0x27, 0x81, 0x92, 0x28, 0x91, 0x92, 0x89, 0x4e,
-  0x58, 0x9a, 0x9c, 0x0b, 0xdc, 0x5b, 0x9a, 0x1b, 0xdd, 0xd7, 0x5c, 0x9a,
-  0x5e, 0x19, 0x0b, 0x33, 0xb6, 0xb7, 0x30, 0x3a, 0x26, 0x70, 0x6f, 0x69,
-  0x6e, 0x74, 0x53, 0x69, 0x7a, 0x65, 0x43, 0x94, 0xa4, 0x4a, 0xa0, 0xc4,
-  0x4a, 0xa4, 0xe4, 0x1a, 0x42, 0x24, 0x54, 0x82, 0x11, 0x0a, 0x4b, 0x93,
-  0x73, 0xb1, 0x2b, 0x93, 0xa3, 0x2b, 0xc3, 0xfb, 0x4a, 0x73, 0x83, 0xab,
-  0xa3, 0xa3, 0x14, 0x96, 0x26, 0xe7, 0xc2, 0xf6, 0x36, 0x16, 0x46, 0x97,
-  0xf6, 0xe6, 0xf6, 0x95, 0xe6, 0x46, 0x56, 0x86, 0x47, 0xef, 0xac, 0xcc,
-  0xad, 0x4c, 0x2e, 0x8c, 0xae, 0x8c, 0x0c, 0xe5, 0xeb, 0x2b, 0x2c, 0x4d,
-  0xee, 0x0b, 0x8e, 0x2d, 0x6c, 0xac, 0x0c, 0xed, 0x8d, 0x8d, 0xac, 0x4c,
-  0xee, 0xeb, 0x2b, 0x85, 0x86, 0x19, 0xdb, 0x5b, 0x18, 0x9d, 0xcc, 0x10,
-  0x4a, 0x11, 0x12, 0x2d, 0xd9, 0x14, 0x41, 0x09, 0x12, 0x2e, 0x81, 0x92,
-  0x2e, 0x91, 0x92, 0x89, 0x4a, 0x58, 0x9a, 0x9c, 0x8b, 0x58, 0x9d, 0x99,
-  0x59, 0x99, 0x1c, 0x9f, 0xb0, 0x34, 0x39, 0x17, 0xb1, 0x3a, 0x33, 0xb3,
-  0x32, 0xb9, 0xaf, 0xb9, 0x34, 0xbd, 0x32, 0x22, 0x61, 0x69, 0x72, 0x2e,
-  0x72, 0x65, 0x61, 0x64, 0x8c, 0xc2, 0xd2, 0xe4, 0x5c, 0xc2, 0xe4, 0xce,
-  0xbe, 0xe8, 0xf2, 0xe0, 0xca, 0xbe, 0xe6, 0xd2, 0xf4, 0xca, 0x78, 0x85,
-  0xa5, 0xc9, 0xb9, 0x84, 0xc9, 0x9d, 0x7d, 0xd1, 0xe5, 0xc1, 0x95, 0x7d,
-  0x85, 0xb1, 0xa5, 0x9d, 0xb9, 0x7d, 0xcd, 0xa5, 0xe9, 0x95, 0x11, 0x31,
-  0x63, 0x7b, 0x0b, 0xa3, 0xa3, 0xc1, 0xa3, 0xa1, 0x02, 0x27, 0xf7, 0xa6,
-  0x56, 0x36, 0x46, 0x97, 0xf6, 0xe6, 0x36, 0x04, 0x0c, 0x94, 0x20, 0xf9,
-  0x12, 0x30, 0x50, 0x86, 0x64, 0x53, 0x08, 0x25, 0x48, 0xc2, 0x20, 0x11,
-  0x03, 0x65, 0x48, 0xc6, 0x40, 0x29, 0x12, 0x28, 0x21, 0x83, 0x44, 0x4a,
-  0xca, 0x80, 0x09, 0x9d, 0x5c, 0x98, 0xdb, 0x9c, 0xd9, 0x9b, 0x5c, 0xdb,
-  0x10, 0x30, 0x50, 0x88, 0xe4, 0x4b, 0xc0, 0x40, 0x19, 0x92, 0x4d, 0x41,
-  0x94, 0x20, 0x09, 0x83, 0x44, 0x0c, 0x94, 0x21, 0x19, 0x03, 0xa5, 0x48,
-  0xa0, 0x84, 0x0c, 0x12, 0x29, 0x39, 0x83, 0x21, 0x46, 0xe2, 0x25, 0x66,
-  0x90, 0xa0, 0xc1, 0x10, 0x03, 0x01, 0x92, 0x2c, 0x49, 0x03, 0x3e, 0x6f,
-  0x6d, 0x6e, 0x69, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x68,
-  0x61, 0x72, 0x7c, 0xa6, 0xd2, 0xda, 0xe0, 0xd8, 0xca, 0x40, 0x86, 0x56,
-  0x56, 0x40, 0xa8, 0x84, 0x82, 0x82, 0x86, 0x08, 0x09, 0x1b, 0x0c, 0x31,
-  0x92, 0x35, 0x48, 0xda, 0x80, 0x49, 0x86, 0x18, 0x89, 0x1b, 0x24, 0x6e,
-  0xc0, 0x24, 0x23, 0x22, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68,
-  0x87, 0x77, 0x20, 0x87, 0x7a, 0x60, 0x87, 0x72, 0x70, 0x03, 0x73, 0x60,
-  0x87, 0x70, 0x38, 0x87, 0x79, 0x98, 0x22, 0x04, 0xc3, 0x08, 0x85, 0x1d,
-  0xd8, 0xc1, 0x1e, 0xda, 0xc1, 0x0d, 0xd2, 0x81, 0x1c, 0xca, 0xc1, 0x1d,
-  0xe8, 0x61, 0x4a, 0x50, 0x8c, 0x58, 0xc2, 0x21, 0x1d, 0xe4, 0xc1, 0x0d,
-  0xec, 0xa1, 0x1c, 0xe4, 0x61, 0x1e, 0xd2, 0xe1, 0x1d, 0xdc, 0x61, 0x4a,
-  0x60, 0x8c, 0xa0, 0xc2, 0x21, 0x1d, 0xe4, 0xc1, 0x0d, 0xd8, 0x21, 0x1c,
-  0xdc, 0xe1, 0x1c, 0xea, 0x21, 0x1c, 0xce, 0xa1, 0x1c, 0x7e, 0xc1, 0x1e,
-  0xca, 0x41, 0x1e, 0xe6, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0xa6, 0x04, 0xc8,
-  0x88, 0x29, 0x1c, 0xd2, 0x41, 0x1e, 0xdc, 0x60, 0x1c, 0xde, 0xa1, 0x1d,
-  0xe0, 0x21, 0x1d, 0xd8, 0xa1, 0x1c, 0x7e, 0xe1, 0x1d, 0xe0, 0x81, 0x1e,
-  0xd2, 0xe1, 0x1d, 0xdc, 0x61, 0x1e, 0xa6, 0x0c, 0x0a, 0xe3, 0x8c, 0x50,
-  0xc2, 0x21, 0x1d, 0xe4, 0xc1, 0x0d, 0xec, 0xa1, 0x1c, 0xe4, 0x81, 0x1e,
-  0xca, 0x01, 0x1f, 0xa6, 0x04, 0x6a, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00,
-  0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66,
-  0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07,
-  0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10,
-  0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce,
-  0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b,
-  0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c,
-  0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07,
-  0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11,
-  0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0,
-  0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8,
-  0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b,
-  0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b,
-  0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87,
-  0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07,
-  0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87,
-  0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81,
-  0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30,
-  0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4,
-  0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca,
-  0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39,
-  0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b,
-  0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b,
-  0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83,
-  0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87,
-  0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90,
-  0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20,
-  0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc,
-  0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66,
-  0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24,
-  0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07,
-  0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e,
-  0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e,
-  0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54,
-  0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39,
-  0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c,
-  0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07,
-  0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0,
-  0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4,
-  0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38,
-  0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d,
-  0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d,
-  0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
-  0x06, 0x00, 0xb1, 0x5d, 0xf9, 0xb3, 0xce, 0x82, 0x0c, 0x7f, 0x45, 0x44,
-  0x13, 0x71, 0x01, 0x00, 0x61, 0x20, 0x00, 0x00, 0x52, 0x00, 0x00, 0x00,
-  0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
-  0xe4, 0xc6, 0x22, 0x86, 0x61, 0x18, 0xc6, 0x22, 0x04, 0x41, 0x10, 0xc6,
-  0x22, 0x82, 0x20, 0x08, 0x46, 0x00, 0x88, 0x95, 0x40, 0x19, 0x14, 0x01,
-  0x8d, 0x19, 0x00, 0x12, 0x33, 0x00, 0x14, 0x66, 0x00, 0x08, 0x8c, 0x11,
-  0x80, 0x20, 0x08, 0xe2, 0x1f, 0x00, 0x00, 0x00, 0xe3, 0x11, 0x0c, 0x74,
-  0x41, 0x14, 0x94, 0xf1, 0x88, 0x47, 0xca, 0x24, 0x0a, 0xca, 0x20, 0xc3,
-  0x60, 0x30, 0x26, 0x04, 0xf2, 0x19, 0x8f, 0x98, 0xac, 0xae, 0xa1, 0xa0,
-  0x0c, 0x32, 0x1c, 0x4a, 0x64, 0x42, 0x20, 0x1f, 0x0b, 0x0a, 0xf8, 0x8c,
-  0x47, 0x60, 0x9b, 0x18, 0x40, 0x14, 0x94, 0x41, 0x06, 0xe6, 0xb9, 0x4c,
-  0x08, 0xe4, 0x63, 0x45, 0x00, 0x9f, 0xf1, 0x88, 0x0e, 0x0c, 0xce, 0xc0,
-  0xa2, 0xa0, 0x0c, 0x32, 0x44, 0x54, 0x67, 0x42, 0x20, 0x1f, 0x2b, 0x02,
-  0xf8, 0x8c, 0x47, 0x84, 0x41, 0x19, 0xb0, 0x01, 0x47, 0x41, 0x19, 0x64,
-  0x08, 0xb2, 0xcf, 0x82, 0x4a, 0x3e, 0x83, 0x0c, 0xc3, 0x26, 0x06, 0x16,
-  0x4c, 0xf2, 0xb1, 0x21, 0x80, 0xcf, 0x20, 0x83, 0xe1, 0x99, 0x81, 0x05,
-  0x91, 0x7c, 0x6c, 0x08, 0xe0, 0x33, 0xc8, 0x90, 0x84, 0x81, 0x1a, 0x58,
-  0xf0, 0xc8, 0xc7, 0x86, 0x00, 0x3e, 0xe3, 0x11, 0x6e, 0x20, 0x07, 0x79,
-  0x80, 0x06, 0x14, 0x94, 0x41, 0x86, 0xc0, 0x0c, 0xd8, 0xc0, 0x02, 0x31,
-  0x90, 0xcf, 0x20, 0xc3, 0x80, 0x06, 0x6f, 0x60, 0x01, 0x18, 0xc8, 0x67,
-  0x90, 0xa1, 0x50, 0x03, 0x39, 0xb0, 0xa0, 0x93, 0xcf, 0x20, 0xc3, 0xc1,
-  0x06, 0x75, 0x60, 0x81, 0x26, 0x9f, 0x41, 0x06, 0x3d, 0x80, 0x03, 0x3a,
-  0xb0, 0x2c, 0x90, 0xcf, 0x20, 0x03, 0x1f, 0xc8, 0xc1, 0x1d, 0x98, 0x13,
-  0xc8, 0xc7, 0x92, 0x01, 0x3e, 0x16, 0x30, 0xf0, 0xb1, 0x20, 0x81, 0x8f,
-  0x05, 0x08, 0x7c, 0x2c, 0x28, 0xe0, 0x33, 0xdb, 0x80, 0x07, 0x01, 0x30,
-  0xdb, 0x10, 0xdc, 0x41, 0x90, 0x41, 0x40, 0x0c, 0x09, 0x00, 0x00, 0x00,
-  0x5b, 0x86, 0x20, 0x78, 0x83, 0x2d, 0xc3, 0x10, 0xbc, 0xc1, 0x96, 0xe1,
-  0x08, 0xde, 0x60, 0xcb, 0xc0, 0x04, 0x6f, 0xb0, 0x65, 0x88, 0x82, 0x37,
-  0xd8, 0x32, 0x58, 0xc1, 0x1b, 0x6c, 0x19, 0xc6, 0x20, 0x78, 0x03, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b,
-  0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x60, 0x0b, 0x00, 0x00,
-  0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00,
-  0xd5, 0x02, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00,
-  0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49,
-  0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19,
-  0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42,
-  0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44, 0x24,
-  0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21, 0x72,
-  0x24, 0x07, 0xc8, 0x48, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0,
-  0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00, 0x00, 0x84, 0x00, 0x00, 0x00,
-  0x1b, 0xc8, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x80, 0x8a,
-  0x18, 0x87, 0x77, 0x90, 0x07, 0x79, 0x28, 0x87, 0x71, 0xa0, 0x07, 0x76,
-  0xc8, 0x87, 0x36, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x77, 0x20, 0x87, 0x72,
-  0x20, 0x87, 0x36, 0x20, 0x87, 0x74, 0xb0, 0x87, 0x74, 0x20, 0x87, 0x72,
-  0x68, 0x83, 0x79, 0x88, 0x07, 0x79, 0xa0, 0x87, 0x36, 0x30, 0x07, 0x78,
-  0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0xc0, 0x1c, 0xc2, 0x81,
-  0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1c, 0xd2, 0x61, 0x1e, 0xc2, 0x41,
-  0x1c, 0xd8, 0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xc2, 0x21, 0x1d, 0xd8, 0xa1,
-  0x0d, 0xc6, 0x21, 0x1c, 0xd8, 0x81, 0x1d, 0xe6, 0x01, 0x30, 0x87, 0x70,
-  0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x60, 0x87, 0x72, 0x98, 0x87, 0x79,
-  0x68, 0x03, 0x78, 0x90, 0x87, 0x72, 0x18, 0x87, 0x74, 0x98, 0x87, 0x72,
-  0x68, 0x03, 0x73, 0x80, 0x87, 0x76, 0x08, 0x07, 0x72, 0x00, 0xcc, 0x21,
-  0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0,
-  0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21,
-  0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21,
-  0x1d, 0xda, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x06, 0x77,
-  0x78, 0x87, 0x36, 0x30, 0x07, 0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36,
-  0x80, 0x87, 0x77, 0x48, 0x07, 0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36,
-  0x28, 0x07, 0x76, 0x48, 0x87, 0x76, 0x68, 0x03, 0x77, 0x78, 0x07, 0x77,
-  0x68, 0x03, 0x76, 0x28, 0x87, 0x70, 0x30, 0x07, 0x80, 0x70, 0x87, 0x77,
-  0x68, 0x83, 0x74, 0x70, 0x07, 0x73, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78,
-  0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1,
-  0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x40, 0x1d, 0xea, 0xa1,
-  0x1d, 0xe0, 0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61,
-  0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x77,
-  0x78, 0x87, 0x36, 0x70, 0x87, 0x70, 0x70, 0x87, 0x79, 0x68, 0x03, 0x73,
-  0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41,
-  0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe6, 0x21,
-  0x1d, 0xce, 0xc1, 0x1d, 0xca, 0x81, 0x1c, 0xda, 0x40, 0x1f, 0xca, 0x41,
-  0x1e, 0xde, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21,
-  0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80,
-  0x70, 0x87, 0x77, 0x68, 0x03, 0x7a, 0x90, 0x87, 0x70, 0x80, 0x07, 0x78,
-  0x48, 0x07, 0x77, 0x38, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74,
-  0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0x62, 0x1e, 0xe8, 0x21,
-  0x1c, 0xc6, 0x61, 0x1d, 0xda, 0x00, 0x1e, 0xe4, 0xe1, 0x1d, 0xe8, 0xa1,
-  0x1c, 0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0x40, 0x1c, 0xea, 0xc1,
-  0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xf4, 0xa1,
-  0x1c, 0x00, 0x3c, 0x00, 0x88, 0x7a, 0x70, 0x87, 0x79, 0x08, 0x07, 0x73,
-  0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a,
-  0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xea, 0x61,
-  0x1e, 0xca, 0xa1, 0x0d, 0xe6, 0xe1, 0x1d, 0xcc, 0x81, 0x1e, 0xda, 0xc0,
-  0x1c, 0xd8, 0xe1, 0x1d, 0xc2, 0x81, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76,
-  0x98, 0x87, 0x72, 0x00, 0x36, 0x20, 0xc2, 0x00, 0x24, 0xc0, 0x02, 0x54,
-  0x1b, 0x90, 0x81, 0x00, 0x12, 0x60, 0x01, 0x2a, 0x00, 0x00, 0x00, 0x00,
-  0x49, 0x18, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x86, 0x40, 0x18,
-  0x00, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00,
-  0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84,
-  0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c,
-  0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x40, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30,
-  0x8c, 0x20, 0x00, 0x56, 0x08, 0x22, 0x09, 0xc2, 0x4c, 0xd4, 0x3c, 0xd0,
-  0x83, 0x3c, 0xd4, 0xc3, 0x38, 0xd0, 0x83, 0x1b, 0xb4, 0x43, 0x39, 0xd0,
-  0x43, 0x38, 0xb0, 0x83, 0x1e, 0xe8, 0x41, 0x3b, 0x84, 0x03, 0x3d, 0xc8,
-  0x43, 0x3a, 0xe0, 0x03, 0x0a, 0xc8, 0x20, 0x42, 0x21, 0x94, 0x62, 0x08,
-  0x61, 0x0c, 0x9d, 0x81, 0x80, 0x39, 0x02, 0x30, 0x48, 0x01, 0x35, 0x47,
-  0x00, 0x0a, 0x83, 0x08, 0x81, 0x30, 0x8c, 0x40, 0x28, 0x23, 0x00, 0x00,
-  0x13, 0xa8, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70,
-  0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87, 0x79,
-  0xc8, 0x03, 0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7, 0x51, 0x0e,
-  0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a, 0x80, 0x07,
-  0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78, 0xa0, 0x07,
-  0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07,
-  0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07,
-  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x60, 0x07,
-  0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06,
-  0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
-  0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76, 0xa0, 0x07,
-  0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07,
-  0x74, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06,
-  0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
-  0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74, 0xa0, 0x07,
-  0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x90, 0x07,
-  0x76, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07,
-  0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07,
-  0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f,
-  0x71, 0x90, 0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07,
-  0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75, 0x60, 0x07,
-  0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07,
-  0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07,
-  0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x10, 0x07,
-  0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07,
-  0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee, 0x80, 0x07,
-  0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43, 0x18, 0x04,
-  0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x2c, 0x10, 0x00, 0x00,
-  0x0a, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90,
-  0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x52, 0x25, 0x30, 0x02, 0x50,
-  0x80, 0x01, 0x45, 0x50, 0x20, 0x65, 0x50, 0x08, 0x05, 0x41, 0x6c, 0x04,
-  0x80, 0xd6, 0x58, 0x82, 0x23, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00,
-  0xd9, 0x00, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25,
-  0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x86, 0x42, 0x24,
-  0xc0, 0xa2, 0x50, 0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3,
-  0x2b, 0x1b, 0x62, 0x28, 0x41, 0x22, 0x28, 0x07, 0xdd, 0x20, 0x08, 0x0e,
-  0x8e, 0xad, 0x0c, 0x84, 0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e,
-  0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x26, 0x06, 0x06, 0x26, 0xc6, 0x85, 0x66,
-  0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26,
-  0x06, 0x06, 0x26, 0xc6, 0x85, 0x66, 0x26, 0x65, 0x88, 0x90, 0x10, 0x43,
-  0x0c, 0x25, 0x50, 0x10, 0x45, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36,
-  0x04, 0x49, 0x0e, 0x25, 0x50, 0x02, 0x45, 0xe0, 0x16, 0x96, 0x26, 0xe7,
-  0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6,
-  0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96, 0x36, 0x17, 0x26, 0xc6, 0x56, 0x36,
-  0x44, 0x48, 0x12, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
-  0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74,
-  0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x84, 0x64, 0x21,
-  0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5, 0xc1, 0xa5, 0xb1, 0x95,
-  0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5, 0x99, 0x99, 0x95, 0xc9,
-  0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x95, 0xb9, 0x85, 0x89, 0xb1,
-  0x95, 0x0d, 0x11, 0x92, 0x86, 0x4c, 0x58, 0x9a, 0x9c, 0x0b, 0xdc, 0xdb,
-  0x5c, 0x1a, 0x5d, 0xda, 0x9b, 0x1b, 0xa3, 0xb0, 0x34, 0x39, 0x97, 0x30,
-  0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0x2f, 0xb7, 0xb0, 0xb6, 0x32,
-  0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x64, 0xc2, 0xd2, 0xe4, 0x5c,
-  0xc2, 0xe4, 0xce, 0xbe, 0xdc, 0xc2, 0xda, 0xca, 0x88, 0xc0, 0xbd, 0xcd,
-  0xa5, 0xd1, 0xa5, 0xbd, 0xb9, 0x0d, 0x51, 0x92, 0x27, 0x81, 0x92, 0x28,
-  0x91, 0x92, 0x89, 0x51, 0x58, 0x9a, 0x9c, 0x8b, 0x5d, 0x99, 0x1c, 0x5d,
-  0x19, 0xde, 0xd7, 0x5b, 0x1d, 0x1d, 0x5c, 0x1d, 0x1d, 0xb3, 0xb3, 0x32,
-  0xb7, 0x32, 0xb9, 0x30, 0xba, 0x32, 0x32, 0x14, 0x1c, 0xba, 0x32, 0xbc,
-  0xb1, 0xb7, 0x37, 0x39, 0x32, 0x22, 0x3b, 0x99, 0x2f, 0xb3, 0x14, 0x1a,
-  0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32, 0x44, 0xe8, 0xca, 0xf0, 0xc6, 0xde,
-  0xde, 0xe4, 0xc8, 0x86, 0x30, 0x49, 0x95, 0x58, 0x09, 0x94, 0x5c, 0x89,
-  0x94, 0x60, 0x43, 0x88, 0x84, 0x4a, 0x32, 0x42, 0x61, 0x69, 0x72, 0x2e,
-  0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74,
-  0x94, 0xc2, 0xd2, 0xe4, 0x5c, 0xd8, 0xde, 0xc6, 0xc2, 0xe8, 0xd2, 0xde,
-  0xdc, 0xbe, 0xd2, 0xdc, 0xc8, 0xca, 0xf0, 0xe8, 0x9d, 0x95, 0xb9, 0x95,
-  0xc9, 0x85, 0xd1, 0x95, 0x91, 0xa1, 0x7c, 0x7d, 0x85, 0xa5, 0xc9, 0x7d,
-  0xc1, 0xb1, 0x85, 0x8d, 0x95, 0xa1, 0xbd, 0xb1, 0x91, 0x95, 0xc9, 0x7d,
-  0x7d, 0xa5, 0x0c, 0xa1, 0x14, 0x21, 0xd9, 0x12, 0x4e, 0x11, 0x94, 0x20,
-  0xe9, 0x12, 0x28, 0xb9, 0x12, 0x29, 0x99, 0x86, 0x50, 0x4a, 0x90, 0x6c,
-  0x09, 0xa7, 0x04, 0x4a, 0x90, 0x74, 0x09, 0x94, 0x5c, 0x89, 0x94, 0x60,
-  0x54, 0xc2, 0xd2, 0xe4, 0x5c, 0xc4, 0xea, 0xcc, 0xcc, 0xca, 0xe4, 0xf8,
-  0x84, 0xa5, 0xc9, 0xb9, 0x88, 0xd5, 0x99, 0x99, 0x95, 0xc9, 0x7d, 0xcd,
-  0xa5, 0xe9, 0x95, 0x11, 0x09, 0x4b, 0x93, 0x73, 0x91, 0x2b, 0x0b, 0x23,
-  0x63, 0x14, 0x96, 0x26, 0xe7, 0x12, 0x26, 0x77, 0xf6, 0x45, 0x97, 0x07,
-  0x57, 0xf6, 0x35, 0x97, 0xa6, 0x57, 0xc6, 0x2b, 0x2c, 0x4d, 0xce, 0x25,
-  0x4c, 0xee, 0xec, 0x8b, 0x2e, 0x0f, 0xae, 0xec, 0x2b, 0x8c, 0x2d, 0xed,
-  0xcc, 0xed, 0x6b, 0x2e, 0x4d, 0xaf, 0x8c, 0x88, 0x19, 0xdb, 0x5b, 0x18,
-  0x1d, 0x0d, 0x1e, 0x0d, 0x15, 0x38, 0xb9, 0x37, 0xb5, 0xb2, 0x31, 0xba,
-  0xb4, 0x37, 0xb7, 0x21, 0x60, 0xa0, 0x10, 0x09, 0x18, 0x24, 0x61, 0xa0,
-  0x0c, 0x09, 0xa7, 0x10, 0x4a, 0x90, 0x88, 0x41, 0x32, 0x06, 0xca, 0x90,
-  0x90, 0x81, 0x52, 0x24, 0x50, 0x52, 0x06, 0x89, 0x94, 0x98, 0x01, 0x13,
-  0x3a, 0xb9, 0x30, 0xb7, 0x39, 0xb3, 0x37, 0xb9, 0xb6, 0x21, 0x60, 0xa0,
-  0x18, 0x09, 0x18, 0x24, 0x61, 0xa0, 0x0c, 0x09, 0xa7, 0x18, 0x4a, 0x90,
-  0x88, 0x41, 0x32, 0x06, 0xca, 0x90, 0x90, 0x81, 0x52, 0x24, 0x50, 0x52,
-  0x06, 0x89, 0x94, 0xa0, 0xc1, 0x10, 0x24, 0xf1, 0x92, 0x2f, 0x39, 0x83,
-  0x24, 0x0d, 0x86, 0x18, 0x08, 0x90, 0x68, 0x89, 0x1a, 0xf0, 0x79, 0x6b,
+  0xb9, 0x0d, 0x51, 0x92, 0x27, 0x81, 0x92, 0x28, 0x91, 0x92, 0x89, 0x51,
+  0x58, 0x9a, 0x9c, 0x8b, 0x5d, 0x99, 0x1c, 0x5d, 0x19, 0xde, 0xd7, 0x5b,
+  0x1d, 0x1d, 0x5c, 0x1d, 0x1d, 0xad, 0xb3, 0x32, 0xb7, 0x32, 0xb9, 0x30,
+  0xba, 0x32, 0x32, 0x94, 0x9a, 0xb1, 0x37, 0xb6, 0x37, 0x39, 0x22, 0x3b,
+  0x9a, 0x2f, 0xb3, 0x14, 0x16, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x43, 0x98,
+  0xa4, 0x4a, 0xac, 0x04, 0x4a, 0xa2, 0x44, 0x4a, 0x2e, 0x3a, 0x61, 0x69,
+  0x72, 0x2e, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x5f, 0x73, 0x69, 0x7a, 0x65,
+  0x2c, 0xcc, 0xd8, 0xde, 0xc2, 0xe8, 0x98, 0xc0, 0xbd, 0xa5, 0xb9, 0xd1,
+  0x4d, 0xa5, 0xe9, 0x95, 0x0d, 0x51, 0x92, 0x2c, 0x81, 0x12, 0x2d, 0x91,
+  0x92, 0x6d, 0x88, 0x91, 0x50, 0x09, 0x96, 0x70, 0x84, 0xc2, 0xd2, 0xe4,
+  0x5c, 0xec, 0xca, 0xe4, 0xe8, 0xca, 0xf0, 0xbe, 0xd2, 0xdc, 0xe0, 0xea,
+  0xe8, 0x28, 0x85, 0xa5, 0xc9, 0xb9, 0xb0, 0xbd, 0x8d, 0x85, 0xd1, 0xa5,
+  0xbd, 0xb9, 0x7d, 0xa5, 0xb9, 0x91, 0x95, 0xe1, 0xd1, 0x3b, 0x2b, 0x73,
+  0x2b, 0x93, 0x0b, 0xa3, 0x2b, 0x23, 0x43, 0xf9, 0xfa, 0x0a, 0x4b, 0x93,
+  0xfb, 0x82, 0x63, 0x0b, 0x1b, 0x2b, 0x43, 0x7b, 0x63, 0x23, 0x2b, 0x93,
+  0xfb, 0xfa, 0x4a, 0xa1, 0x61, 0xc6, 0xf6, 0x16, 0x46, 0x27, 0x33, 0x84,
+  0x52, 0x84, 0xc4, 0x4b, 0x3e, 0x45, 0x50, 0x82, 0x04, 0x0c, 0x12, 0x28,
+  0x09, 0x83, 0x44, 0x4a, 0xa6, 0x21, 0x94, 0x12, 0x24, 0x5e, 0xf2, 0x29,
+  0x81, 0x12, 0x24, 0x60, 0x90, 0x40, 0x49, 0x94, 0x48, 0xc9, 0x45, 0x25,
+  0x2c, 0x4d, 0xce, 0x45, 0xac, 0xce, 0xcc, 0xac, 0x4c, 0x8e, 0x4f, 0x58,
+  0x9a, 0x9c, 0x8b, 0x58, 0x9d, 0x99, 0x59, 0x99, 0xdc, 0xd7, 0x5c, 0x9a,
+  0x5e, 0x19, 0x91, 0xb0, 0x34, 0x39, 0x17, 0xb9, 0xb2, 0x30, 0x32, 0x46,
+  0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65,
+  0x5f, 0x73, 0x69, 0x7a, 0x65, 0xbc, 0xc2, 0xd2, 0xe4, 0x5c, 0xc2, 0xe4,
+  0xce, 0xbe, 0xe8, 0xf2, 0xe0, 0xca, 0xbe, 0xc2, 0xd8, 0xd2, 0xce, 0xdc,
+  0xbe, 0xe6, 0xd2, 0xf4, 0xca, 0x88, 0x98, 0xb1, 0xbd, 0x85, 0xd1, 0xd1,
+  0xe0, 0xd1, 0x50, 0x81, 0x93, 0x7b, 0x53, 0x2b, 0x1b, 0xa3, 0x4b, 0x7b,
+  0x73, 0x1b, 0x02, 0x06, 0x0a, 0x91, 0x90, 0x41, 0x52, 0x06, 0xca, 0x90,
+  0x7c, 0x0a, 0xa1, 0x04, 0x89, 0x19, 0x24, 0x67, 0xa0, 0x0c, 0x09, 0x1a,
+  0x28, 0x45, 0x02, 0x25, 0x69, 0x90, 0x48, 0x89, 0x1a, 0x30, 0xa1, 0x93,
+  0x0b, 0x73, 0x9b, 0x33, 0x7b, 0x93, 0x6b, 0x1b, 0x02, 0x06, 0x8a, 0x91,
+  0x90, 0x41, 0x52, 0x06, 0xca, 0x90, 0x7c, 0x8a, 0xa1, 0x04, 0x89, 0x19,
+  0x24, 0x67, 0xa0, 0x0c, 0x09, 0x1a, 0x28, 0x45, 0x02, 0x25, 0x69, 0x90,
+  0x48, 0x09, 0x1b, 0x0c, 0x41, 0x12, 0x31, 0x48, 0xc6, 0x20, 0x59, 0x83,
+  0xa4, 0x0d, 0x86, 0x18, 0x08, 0x90, 0x74, 0x89, 0x1b, 0xf0, 0x79, 0x6b,
   0x73, 0x4b, 0x83, 0x7b, 0xa3, 0x2b, 0x73, 0xa3, 0x03, 0x19, 0x43, 0x0b,
   0x93, 0xe3, 0x33, 0x95, 0xd6, 0x06, 0xc7, 0x56, 0x06, 0x32, 0xb4, 0xb2,
-  0x02, 0x42, 0x25, 0x14, 0x14, 0x34, 0x44, 0x48, 0xda, 0x60, 0x88, 0x91,
-  0xb0, 0x41, 0xe2, 0x06, 0x4c, 0x32, 0xc4, 0x48, 0xde, 0x20, 0x79, 0x03,
+  0x02, 0x42, 0x25, 0x14, 0x14, 0x34, 0x44, 0x48, 0xe2, 0x60, 0x88, 0x91,
+  0xc0, 0x41, 0x22, 0x07, 0x4c, 0x32, 0xc4, 0x48, 0xe6, 0x20, 0x99, 0x03,
   0x26, 0x19, 0x11, 0xb1, 0x03, 0x3b, 0xd8, 0x43, 0x3b, 0xb8, 0x41, 0x3b,
   0xbc, 0x03, 0x39, 0xd4, 0x03, 0x3b, 0x94, 0x83, 0x1b, 0x98, 0x03, 0x3b,
   0x84, 0xc3, 0x39, 0xcc, 0xc3, 0x14, 0x21, 0x18, 0x46, 0x28, 0xec, 0xc0,
@@ -506,182 +270,435 @@ const unsigned char sdl_metallib[] = {
   0x0f, 0xe9, 0xc0, 0x0e, 0xe5, 0xf0, 0x0b, 0xef, 0x00, 0x0f, 0xf4, 0x90,
   0x0e, 0xef, 0xe0, 0x0e, 0xf3, 0x30, 0x65, 0x50, 0x18, 0x67, 0x84, 0x12,
   0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0x60, 0x0f, 0xe5, 0x20, 0x0f, 0xf4, 0x50,
-  0x0e, 0xf8, 0x30, 0x25, 0x58, 0x03, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00,
-  0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66,
-  0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07,
-  0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10,
-  0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce,
-  0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b,
-  0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c,
-  0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07,
-  0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11,
-  0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0,
-  0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8,
-  0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b,
-  0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b,
-  0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87,
-  0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07,
-  0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87,
-  0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81,
-  0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30,
-  0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4,
-  0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca,
-  0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39,
-  0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b,
-  0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b,
-  0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83,
-  0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87,
-  0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90,
-  0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20,
-  0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc,
-  0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66,
-  0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24,
-  0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07,
-  0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e,
-  0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e,
-  0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54,
-  0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39,
-  0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c,
-  0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07,
-  0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0,
-  0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4,
-  0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38,
-  0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d,
-  0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d,
-  0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
-  0x06, 0xf0, 0xb0, 0x5d, 0xf9, 0x73, 0xce, 0x83, 0xfd, 0x15, 0x11, 0x4d,
-  0xc4, 0x05, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00,
-  0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
-  0xe4, 0xc6, 0x22, 0x86, 0x61, 0x18, 0xc6, 0x22, 0x04, 0x41, 0x10, 0xc6,
-  0x22, 0x82, 0x20, 0x08, 0x88, 0x95, 0x40, 0x19, 0x14, 0x01, 0xb9, 0x11,
-  0x00, 0x1a, 0x33, 0x00, 0x24, 0x66, 0x00, 0x28, 0xcc, 0x00, 0x00, 0x00,
-  0xe3, 0x11, 0x0b, 0x74, 0x41, 0x14, 0x94, 0xf1, 0x08, 0x47, 0xca, 0x24,
-  0x0a, 0xca, 0x20, 0xc3, 0x50, 0x20, 0x26, 0x04, 0xf2, 0x19, 0x8f, 0x90,
-  0xac, 0xae, 0xa1, 0xa0, 0x0c, 0x32, 0x1c, 0x09, 0x64, 0x42, 0x20, 0x1f,
-  0x0b, 0x0a, 0xf8, 0x8c, 0x47, 0x5c, 0x9b, 0x18, 0x40, 0x14, 0x94, 0x41,
-  0x06, 0xc6, 0xb1, 0x4c, 0x08, 0xe4, 0x63, 0x45, 0x00, 0x9f, 0xf1, 0x08,
-  0x0e, 0x0c, 0xce, 0xc0, 0xa2, 0xa0, 0x0c, 0x32, 0x44, 0x13, 0x67, 0x42,
-  0x20, 0x1f, 0x2b, 0x02, 0xf8, 0x8c, 0x47, 0x80, 0x41, 0x19, 0xb0, 0x01,
-  0x47, 0x41, 0x19, 0x64, 0x08, 0xb0, 0xcd, 0x82, 0x4a, 0x3e, 0x83, 0x0c,
-  0x83, 0x16, 0x06, 0x16, 0x4c, 0xf2, 0xb1, 0x21, 0x80, 0xcf, 0x20, 0x83,
-  0xd1, 0x95, 0x81, 0x05, 0x91, 0x7c, 0x6c, 0x08, 0xe0, 0x33, 0xc8, 0x90,
-  0x80, 0x41, 0x1a, 0x58, 0xf0, 0xc8, 0xc7, 0x86, 0x00, 0x3e, 0xe3, 0x11,
-  0x6d, 0x20, 0x07, 0x79, 0x80, 0x06, 0x14, 0x94, 0x41, 0x86, 0xa0, 0x0c,
-  0xd0, 0xc0, 0x02, 0x31, 0x90, 0xcf, 0x20, 0xc3, 0x70, 0x06, 0x6e, 0x60,
-  0x01, 0x18, 0xc8, 0x67, 0x90, 0xa1, 0x48, 0x83, 0x38, 0xb0, 0xa0, 0x93,
-  0xcf, 0x20, 0xc3, 0xb1, 0x06, 0x74, 0x60, 0x81, 0x26, 0x9f, 0x41, 0x06,
-  0x3d, 0x70, 0x03, 0x38, 0xb0, 0x2c, 0x90, 0xcf, 0x20, 0x03, 0x1f, 0xc0,
-  0x81, 0x1d, 0x98, 0x13, 0xc8, 0xc7, 0x92, 0x01, 0x3e, 0x16, 0x30, 0xf0,
-  0xb1, 0x20, 0x81, 0x8f, 0x05, 0x08, 0x7c, 0x2c, 0x28, 0xe0, 0x33, 0xdb,
-  0x80, 0x07, 0x01, 0x30, 0xdb, 0x10, 0x8c, 0x42, 0x90, 0x41, 0x40, 0x0c,
-  0x09, 0x00, 0x00, 0x00, 0x5b, 0x86, 0x20, 0x80, 0x83, 0x2d, 0xc3, 0x10,
-  0xc0, 0xc1, 0x96, 0xe1, 0x08, 0xe0, 0x60, 0xcb, 0xc0, 0x04, 0x70, 0xb0,
-  0x65, 0x88, 0x02, 0x38, 0xd8, 0x32, 0x58, 0x01, 0x1c, 0x6c, 0x19, 0xc6,
-  0x20, 0x80, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x0e, 0xf8, 0x30, 0x25, 0x78, 0x03, 0x00, 0x00, 0x00, 0x00, 0x79, 0x18,
+  0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1,
+  0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42,
+  0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f,
+  0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1,
+  0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84,
+  0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc,
+  0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70,
+  0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19,
+  0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f,
+  0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21,
+  0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc,
+  0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84,
+  0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37,
+  0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70,
+  0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77,
+  0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79,
+  0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e,
+  0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1,
+  0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81,
+  0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98,
+  0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88,
+  0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4,
+  0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72,
+  0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74,
+  0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e,
+  0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e,
+  0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21,
+  0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01,
+  0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc,
+  0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77,
+  0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e,
+  0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1,
+  0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61,
+  0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0,
+  0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0,
+  0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74,
+  0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e,
+  0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41,
+  0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50,
+  0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c,
+  0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc,
+  0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20, 0x00, 0x00, 0x04, 0x00,
+  0x00, 0x00, 0x06, 0x00, 0xb1, 0x5d, 0xf9, 0xb3, 0xce, 0x82, 0x0c, 0x7f,
+  0x45, 0x44, 0x13, 0x71, 0x01, 0x00, 0x61, 0x20, 0x00, 0x00, 0x54, 0x00,
+  0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x0b, 0x00,
+  0x00, 0x00, 0xe4, 0xc6, 0x22, 0x86, 0x61, 0x18, 0xc6, 0x22, 0x04, 0x41,
+  0x10, 0xc6, 0x22, 0x82, 0x20, 0x08, 0x46, 0x00, 0x88, 0x95, 0x40, 0x19,
+  0x14, 0x01, 0x8d, 0x19, 0x00, 0x12, 0x33, 0x00, 0x14, 0x66, 0x00, 0x08,
+  0x8c, 0x11, 0x80, 0x20, 0x08, 0xe2, 0x1f, 0x00, 0x00, 0x00, 0xe3, 0x11,
+  0x4c, 0x84, 0x45, 0x14, 0x94, 0xf1, 0x88, 0x67, 0xd2, 0x26, 0x0a, 0xca,
+  0x20, 0xc3, 0x60, 0x30, 0x26, 0x04, 0xf2, 0x19, 0x8f, 0x98, 0x2e, 0xaf,
+  0xa1, 0xa0, 0x0c, 0x32, 0x1c, 0x4a, 0x64, 0x42, 0x20, 0x1f, 0x0b, 0x0a,
+  0xf8, 0x8c, 0x47, 0x60, 0xdc, 0x18, 0x40, 0x14, 0x94, 0x41, 0x06, 0xe6,
+  0xb9, 0x4c, 0x08, 0xe4, 0x63, 0x45, 0x00, 0x9f, 0xf1, 0x88, 0x2e, 0x0c,
+  0xd0, 0xc0, 0xa2, 0xa0, 0x0c, 0x32, 0x44, 0x54, 0x67, 0x42, 0x20, 0x1f,
+  0x2b, 0x02, 0xf8, 0x8c, 0x47, 0x84, 0x81, 0x19, 0xb4, 0x01, 0x47, 0x41,
+  0x19, 0x64, 0x08, 0xb2, 0xcf, 0x82, 0x4a, 0x3e, 0x83, 0x0c, 0xc3, 0x26,
+  0x06, 0x16, 0x4c, 0xf2, 0xb1, 0x21, 0x80, 0xcf, 0x20, 0x83, 0xe1, 0x99,
+  0x81, 0x05, 0x91, 0x7c, 0x6c, 0x08, 0xe0, 0x33, 0xc8, 0x90, 0x84, 0x81,
+  0x1a, 0x58, 0xf0, 0xc8, 0xc7, 0x86, 0x00, 0x3e, 0xe3, 0x11, 0x6e, 0x30,
+  0x07, 0x7a, 0x80, 0x06, 0x14, 0x94, 0x41, 0x86, 0xc0, 0x0c, 0xd8, 0xc0,
+  0x02, 0x31, 0x90, 0xcf, 0x20, 0xc3, 0x80, 0x06, 0x6f, 0x60, 0x01, 0x18,
+  0xc8, 0x67, 0x90, 0xa1, 0x50, 0x03, 0x39, 0xb0, 0xa0, 0x93, 0xcf, 0x20,
+  0xc3, 0xc1, 0x06, 0x75, 0x60, 0x81, 0x26, 0x9f, 0x41, 0x86, 0x3d, 0x80,
+  0x03, 0x3a, 0xb0, 0x2c, 0x90, 0xcf, 0x20, 0x43, 0x1f, 0xc8, 0xc1, 0x1d,
+  0x98, 0x13, 0xc8, 0xc7, 0x92, 0x01, 0x3e, 0x16, 0x30, 0xf0, 0xb1, 0x20,
+  0x81, 0x8f, 0x05, 0x08, 0x7c, 0x2c, 0x28, 0xe0, 0x33, 0xdb, 0x80, 0x07,
+  0x01, 0x30, 0xdb, 0x10, 0x90, 0x42, 0x30, 0xdb, 0x10, 0xe0, 0x81, 0x90,
+  0x41, 0x40, 0x0c, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x5b, 0x86,
+  0x20, 0xa0, 0x83, 0x2d, 0xc3, 0x10, 0xd0, 0xc1, 0x96, 0xe1, 0x08, 0xe8,
+  0x60, 0xcb, 0xc0, 0x04, 0x74, 0xb0, 0x65, 0x88, 0x02, 0x3a, 0xd8, 0x32,
+  0x58, 0x01, 0x1d, 0x6c, 0x19, 0xc6, 0x20, 0xa0, 0x03, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
-  0x14, 0x09, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde,
-  0x21, 0x0c, 0x00, 0x00, 0x42, 0x02, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00,
-  0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91,
-  0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c,
-  0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x10, 0x45, 0x02,
-  0x42, 0x92, 0x0b, 0x42, 0x84, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x49,
-  0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52, 0x80,
-  0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8, 0x08, 0x11, 0x62, 0xa8, 0xa0,
-  0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00, 0x00,
-  0x82, 0x00, 0x00, 0x00, 0x1b, 0xc8, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff,
-  0x01, 0x90, 0x80, 0x8a, 0x18, 0x87, 0x77, 0x90, 0x07, 0x79, 0x28, 0x87,
-  0x71, 0xa0, 0x07, 0x76, 0xc8, 0x87, 0x36, 0x90, 0x87, 0x77, 0xa8, 0x07,
-  0x77, 0x20, 0x87, 0x72, 0x20, 0x87, 0x36, 0x20, 0x87, 0x74, 0xb0, 0x87,
-  0x74, 0x20, 0x87, 0x72, 0x68, 0x83, 0x79, 0x88, 0x07, 0x79, 0xa0, 0x87,
-  0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07,
-  0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1c, 0xd2,
-  0x61, 0x1e, 0xc2, 0x41, 0x1c, 0xd8, 0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xc2,
-  0x21, 0x1d, 0xd8, 0xa1, 0x0d, 0xc6, 0x21, 0x1c, 0xd8, 0x81, 0x1d, 0xe6,
-  0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x60, 0x87,
-  0x72, 0x98, 0x87, 0x79, 0x68, 0x03, 0x78, 0x90, 0x87, 0x72, 0x18, 0x87,
-  0x74, 0x98, 0x87, 0x72, 0x68, 0x03, 0x73, 0x80, 0x87, 0x76, 0x08, 0x07,
-  0x72, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc,
-  0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda,
-  0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda,
-  0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87,
-  0x72, 0x00, 0x06, 0x77, 0x78, 0x87, 0x36, 0x30, 0x07, 0x79, 0x08, 0x87,
-  0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77, 0x48, 0x07, 0x77, 0xa0, 0x87,
-  0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76, 0x48, 0x87, 0x76, 0x68, 0x03,
-  0x77, 0x78, 0x07, 0x77, 0x68, 0x03, 0x76, 0x28, 0x87, 0x70, 0x30, 0x07,
-  0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x74, 0x70, 0x07, 0x73, 0x98, 0x87,
-  0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07,
-  0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda,
-  0x40, 0x1d, 0xea, 0xa1, 0x1d, 0xe0, 0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xc4,
-  0x81, 0x1d, 0xca, 0x61, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87,
-  0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x70, 0x87, 0x70, 0x70, 0x87,
-  0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07,
-  0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde,
-  0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xce, 0xc1, 0x1d, 0xca, 0x81, 0x1c, 0xda,
-  0x40, 0x1f, 0xca, 0x41, 0x1e, 0xde, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0,
-  0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87,
-  0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x7a, 0x90, 0x87,
-  0x70, 0x80, 0x07, 0x78, 0x48, 0x07, 0x77, 0x38, 0x87, 0x36, 0x68, 0x87,
-  0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00,
-  0x62, 0x1e, 0xe8, 0x21, 0x1c, 0xc6, 0x61, 0x1d, 0xda, 0x00, 0x1e, 0xe4,
-  0xe1, 0x1d, 0xe8, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda,
-  0x40, 0x1c, 0xea, 0xc1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xe6,
-  0x21, 0x1d, 0xf4, 0xa1, 0x1c, 0x00, 0x3c, 0x00, 0x88, 0x7a, 0x70, 0x87,
-  0x79, 0x08, 0x07, 0x73, 0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00,
+  0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0xb0, 0x0b, 0x00, 0x00, 0xff, 0xff,
+  0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0xe9, 0x02,
+  0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00,
+  0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10,
+  0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04,
+  0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10,
+  0x32, 0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a,
+  0x90, 0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07,
+  0xc8, 0x48, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00,
+  0x00, 0x00, 0x51, 0x18, 0x00, 0x00, 0x84, 0x00, 0x00, 0x00, 0x1b, 0xc8,
+  0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x80, 0x8a, 0x18, 0x87,
+  0x77, 0x90, 0x07, 0x79, 0x28, 0x87, 0x71, 0xa0, 0x07, 0x76, 0xc8, 0x87,
+  0x36, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x77, 0x20, 0x87, 0x72, 0x20, 0x87,
+  0x36, 0x20, 0x87, 0x74, 0xb0, 0x87, 0x74, 0x20, 0x87, 0x72, 0x68, 0x83,
+  0x79, 0x88, 0x07, 0x79, 0xa0, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83,
+  0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6,
+  0xa1, 0x1c, 0x00, 0x82, 0x1c, 0xd2, 0x61, 0x1e, 0xc2, 0x41, 0x1c, 0xd8,
+  0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xc2, 0x21, 0x1d, 0xd8, 0xa1, 0x0d, 0xc6,
+  0x21, 0x1c, 0xd8, 0x81, 0x1d, 0xe6, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87,
+  0x79, 0x28, 0x07, 0x80, 0x60, 0x87, 0x72, 0x98, 0x87, 0x79, 0x68, 0x03,
+  0x78, 0x90, 0x87, 0x72, 0x18, 0x87, 0x74, 0x98, 0x87, 0x72, 0x68, 0x03,
+  0x73, 0x80, 0x87, 0x76, 0x08, 0x07, 0x72, 0x00, 0xcc, 0x21, 0x1c, 0xd8,
+  0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4,
+  0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc,
+  0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda,
+  0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x06, 0x77, 0x78, 0x87,
+  0x36, 0x30, 0x07, 0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87,
+  0x77, 0x48, 0x07, 0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07,
+  0x76, 0x48, 0x87, 0x76, 0x68, 0x03, 0x77, 0x78, 0x07, 0x77, 0x68, 0x03,
+  0x76, 0x28, 0x87, 0x70, 0x30, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83,
+  0x74, 0x70, 0x07, 0x73, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83,
   0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca,
-  0x01, 0x20, 0xea, 0x61, 0x1e, 0xca, 0xa1, 0x0d, 0xe6, 0xe1, 0x1d, 0xcc,
-  0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xd8, 0xe1, 0x1d, 0xc2, 0x81, 0x1e, 0x00,
-  0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x36, 0x20, 0x42, 0x00,
-  0x24, 0xc0, 0x02, 0x54, 0x00, 0x00, 0x00, 0x00, 0x49, 0x18, 0x00, 0x00,
-  0x01, 0x00, 0x00, 0x00, 0x13, 0x84, 0x40, 0x00, 0x89, 0x20, 0x00, 0x00,
-  0x0e, 0x00, 0x00, 0x00, 0x32, 0x22, 0x08, 0x09, 0x20, 0x64, 0x85, 0x04,
-  0x13, 0x22, 0xa4, 0x84, 0x04, 0x13, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14,
-  0x12, 0x4c, 0x88, 0x8c, 0x0b, 0x84, 0x84, 0x4c, 0x10, 0x28, 0x33, 0x00,
-  0xc3, 0x08, 0x04, 0x30, 0x88, 0x10, 0x04, 0x45, 0x08, 0xa1, 0x19, 0x08,
-  0x98, 0x23, 0x00, 0x83, 0x14, 0xb0, 0x39, 0x02, 0x50, 0x18, 0x01, 0x00,
-  0x13, 0xa8, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70,
-  0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87, 0x79,
-  0xc8, 0x03, 0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7, 0x51, 0x0e,
-  0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a, 0x80, 0x07,
-  0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78, 0xa0, 0x07,
-  0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07,
-  0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07,
-  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x60, 0x07,
-  0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06,
-  0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
-  0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76, 0xa0, 0x07,
-  0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07,
-  0x74, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06,
-  0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
-  0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74, 0xa0, 0x07,
-  0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x90, 0x07,
-  0x76, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07,
-  0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07,
-  0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f,
-  0x71, 0x90, 0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07,
-  0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75, 0x60, 0x07,
-  0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07,
-  0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07,
-  0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x10, 0x07,
-  0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07,
-  0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee, 0x80, 0x07,
-  0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43, 0x18, 0x02,
-  0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x2c, 0x10, 0x00, 0x00,
-  0x09, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90,
-  0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0xb2, 0x12, 0x18, 0x01, 0x28,
-  0x90, 0x22, 0x28, 0x84, 0x82, 0x20, 0x1c, 0x01, 0xa0, 0x1b, 0x4b, 0x70,
-  0x04, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0xa0, 0x00, 0x00, 0x00,
-  0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9,
-  0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x86, 0x41, 0x14, 0xc0, 0x81, 0x50, 0xb9,
-  0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b, 0x62, 0x18,
-  0x41, 0x21, 0x18, 0x05, 0xdd, 0x20, 0x08, 0x0e, 0x8e, 0xad, 0x0c, 0x84,
-  0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x0d,
-  0x64, 0x26, 0x06, 0x06, 0x26, 0xc6, 0x85, 0x66, 0x06, 0x04, 0xa5, 0xad,
-  0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26, 0x06, 0x06, 0x26, 0xc6,
-  0x85, 0x66, 0x26, 0x65, 0x88, 0x50, 0x10, 0x43, 0x0c, 0x23, 0x30, 0x0c,
+  0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x40, 0x1d, 0xea, 0xa1, 0x1d, 0xe0,
+  0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x1e, 0x00,
+  0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87,
+  0x36, 0x70, 0x87, 0x70, 0x70, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87,
+  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea,
+  0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xce,
+  0xc1, 0x1d, 0xca, 0x81, 0x1c, 0xda, 0x40, 0x1f, 0xca, 0x41, 0x1e, 0xde,
+  0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8,
+  0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87,
+  0x77, 0x68, 0x03, 0x7a, 0x90, 0x87, 0x70, 0x80, 0x07, 0x78, 0x48, 0x07,
+  0x77, 0x38, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8,
+  0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0x62, 0x1e, 0xe8, 0x21, 0x1c, 0xc6,
+  0x61, 0x1d, 0xda, 0x00, 0x1e, 0xe4, 0xe1, 0x1d, 0xe8, 0xa1, 0x1c, 0xc6,
+  0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0x40, 0x1c, 0xea, 0xc1, 0x1c, 0xcc,
+  0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xf4, 0xa1, 0x1c, 0x00,
+  0x3c, 0x00, 0x88, 0x7a, 0x70, 0x87, 0x79, 0x08, 0x07, 0x73, 0x28, 0x87,
+  0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07,
+  0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xea, 0x61, 0x1e, 0xca,
+  0xa1, 0x0d, 0xe6, 0xe1, 0x1d, 0xcc, 0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xd8,
+  0xe1, 0x1d, 0xc2, 0x81, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87,
+  0x72, 0x00, 0x36, 0x20, 0x02, 0x01, 0x24, 0xc0, 0x02, 0x54, 0x1b, 0x90,
+  0xa1, 0x00, 0x12, 0x60, 0x01, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x49, 0x18,
+  0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x86, 0x40, 0x18, 0x00, 0x00,
+  0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x32, 0x22,
+  0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93,
+  0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84,
+  0xa4, 0x4c, 0x10, 0x40, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20,
+  0x00, 0x76, 0x08, 0x41, 0x24, 0x41, 0x98, 0x89, 0x9a, 0x07, 0x7a, 0x90,
+  0x87, 0x7a, 0x18, 0x07, 0x7a, 0x70, 0x83, 0x76, 0x28, 0x07, 0x7a, 0x08,
+  0x07, 0x76, 0xd0, 0x03, 0x3d, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x79, 0x48,
+  0x07, 0x7c, 0x40, 0x01, 0x19, 0x44, 0x28, 0x84, 0x62, 0x0c, 0x11, 0x84,
+  0x31, 0x74, 0x06, 0x02, 0xe6, 0x08, 0xc0, 0x20, 0x05, 0xd4, 0x1c, 0x01,
+  0x28, 0x0c, 0x22, 0x04, 0xc2, 0x30, 0x02, 0xa1, 0x8c, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x13, 0xa8, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68,
+  0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78,
+  0x87, 0x79, 0xc8, 0x03, 0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7,
+  0x51, 0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a,
+  0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78,
+  0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71,
+  0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72,
+  0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9,
+  0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74,
+  0xd0, 0x06, 0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a,
+  0x30, 0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76,
+  0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6,
+  0x20, 0x07, 0x74, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72,
+  0xd0, 0x06, 0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a,
+  0x30, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6,
+  0x90, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71,
+  0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a,
+  0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d,
+  0x60, 0x0f, 0x71, 0x90, 0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76,
+  0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75,
+  0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75,
+  0x60, 0x07, 0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75,
+  0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6,
+  0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72,
+  0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee,
+  0x80, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43,
+  0x18, 0x04, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x2c, 0x10,
+  0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11,
+  0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x52, 0x25, 0x50,
+  0x04, 0x23, 0x00, 0x05, 0x18, 0x50, 0x08, 0x65, 0x50, 0x20, 0x05, 0x41,
+  0x6c, 0x04, 0x80, 0xd6, 0x58, 0x82, 0x43, 0x00, 0x00, 0x00, 0x79, 0x18,
+  0x00, 0x00, 0xea, 0x00, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29,
+  0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x86,
+  0x22, 0x24, 0xc0, 0xa2, 0x50, 0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a,
+  0x4b, 0xd3, 0x2b, 0x1b, 0x62, 0x28, 0x41, 0x22, 0x28, 0x05, 0xe1, 0x20,
+  0x08, 0x0e, 0x8e, 0xad, 0x0c, 0x84, 0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae,
+  0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x26, 0x06, 0x06, 0x26, 0xc6,
+  0xa5, 0x06, 0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac,
+  0x65, 0x26, 0x06, 0x06, 0x26, 0xc6, 0xa5, 0x06, 0xc6, 0x25, 0x26, 0x65,
+  0x88, 0x90, 0x10, 0x43, 0x0c, 0x25, 0x50, 0x10, 0x65, 0x60, 0xd1, 0x54,
+  0x46, 0x17, 0xc6, 0x36, 0x04, 0x49, 0x0e, 0x25, 0x50, 0x02, 0x65, 0xe0,
+  0x16, 0x96, 0x26, 0xe7, 0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6,
+  0x42, 0x56, 0xe6, 0xf6, 0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96, 0x36, 0x17,
+  0x26, 0xc6, 0x56, 0x36, 0x44, 0x48, 0x12, 0x72, 0x61, 0x69, 0x72, 0x2e,
+  0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74,
+  0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65,
+  0x43, 0x84, 0x64, 0x21, 0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5,
+  0xc1, 0xa5, 0xb1, 0x95, 0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5,
+  0x99, 0x99, 0x95, 0xc9, 0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x95,
+  0xb9, 0x85, 0x89, 0xb1, 0x95, 0x0d, 0x11, 0x92, 0x86, 0x4c, 0x58, 0x9a,
+  0x9c, 0x0b, 0xdc, 0xdb, 0x5c, 0x1a, 0x5d, 0xda, 0x9b, 0x1b, 0xa3, 0xb0,
+  0x34, 0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0x2f,
+  0xb7, 0xb0, 0xb6, 0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x64,
+  0xc2, 0xd2, 0xe4, 0x5c, 0xc2, 0xe4, 0xce, 0xbe, 0xdc, 0xc2, 0xda, 0xca,
+  0x88, 0xc0, 0xbd, 0xcd, 0xa5, 0xd1, 0xa5, 0xbd, 0xb9, 0x0d, 0x51, 0x92,
+  0x27, 0x81, 0x92, 0x28, 0x91, 0x92, 0x89, 0x51, 0x58, 0x9a, 0x9c, 0x8b,
+  0x5d, 0x99, 0x1c, 0x5d, 0x19, 0xde, 0xd7, 0x5b, 0x1d, 0x1d, 0x5c, 0x1d,
+  0x1d, 0xad, 0xb3, 0x32, 0xb7, 0x32, 0xb9, 0x30, 0xba, 0x32, 0x32, 0x94,
+  0x9a, 0xb1, 0x37, 0xb6, 0x37, 0x39, 0x22, 0x3b, 0x9a, 0x2f, 0xb3, 0x14,
+  0x16, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x43, 0x98, 0xa4, 0x4a, 0xac, 0x04,
+  0x4a, 0xa2, 0x44, 0x4a, 0x2e, 0x66, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61,
+  0x74, 0x65, 0x64, 0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72,
+  0x64, 0x44, 0x76, 0x32, 0x5f, 0x66, 0x29, 0x34, 0xcc, 0xd8, 0xde, 0xc2,
+  0xe8, 0x64, 0x88, 0xd0, 0x95, 0xe1, 0x8d, 0xbd, 0xbd, 0xc9, 0x91, 0x0d,
+  0x61, 0x92, 0x2a, 0xc9, 0x12, 0x28, 0xd1, 0x12, 0x29, 0xd9, 0x86, 0x18,
+  0x09, 0x95, 0x60, 0x09, 0x47, 0x28, 0x2c, 0x4d, 0xce, 0xc5, 0xae, 0x4c,
+  0x8e, 0xae, 0x0c, 0xef, 0x2b, 0xcd, 0x0d, 0xae, 0x8e, 0x8e, 0x52, 0x58,
+  0x9a, 0x9c, 0x0b, 0xdb, 0xdb, 0x58, 0x18, 0x5d, 0xda, 0x9b, 0xdb, 0x57,
+  0x9a, 0x1b, 0x59, 0x19, 0x1e, 0xbd, 0xb3, 0x32, 0xb7, 0x32, 0xb9, 0x30,
+  0xba, 0x32, 0x32, 0x94, 0xaf, 0xaf, 0xb0, 0x34, 0xb9, 0x2f, 0x38, 0xb6,
+  0xb0, 0xb1, 0x32, 0xb4, 0x37, 0x36, 0xb2, 0x32, 0xb9, 0xaf, 0xaf, 0x94,
+  0x21, 0x94, 0x32, 0x24, 0x5e, 0xf2, 0x29, 0x83, 0x12, 0x24, 0x60, 0x90,
+  0x40, 0x89, 0x96, 0x48, 0xc9, 0x34, 0x84, 0x52, 0x82, 0xc4, 0x4b, 0x3e,
+  0x25, 0x50, 0x82, 0x04, 0x0c, 0x12, 0x28, 0x89, 0x12, 0x29, 0xb9, 0x86,
+  0x50, 0x8a, 0x90, 0x78, 0xc9, 0xa7, 0x08, 0x4a, 0x90, 0x80, 0x41, 0x02,
+  0x25, 0x5a, 0x22, 0x25, 0x1b, 0x95, 0xb0, 0x34, 0x39, 0x17, 0xb1, 0x3a,
+  0x33, 0xb3, 0x32, 0x39, 0x3e, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66,
+  0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x44, 0xc2, 0xd2, 0xe4,
+  0x5c, 0xe4, 0xca, 0xc2, 0xc8, 0x18, 0x85, 0xa5, 0xc9, 0xb9, 0x84, 0xc9,
+  0x9d, 0x7d, 0xd1, 0xe5, 0xc1, 0x95, 0x7d, 0xcd, 0xa5, 0xe9, 0x95, 0xf1,
+  0x0a, 0x4b, 0x93, 0x73, 0x09, 0x93, 0x3b, 0xfb, 0xa2, 0xcb, 0x83, 0x2b,
+  0xfb, 0x0a, 0x63, 0x4b, 0x3b, 0x73, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x23,
+  0x62, 0xc6, 0xf6, 0x16, 0x46, 0x47, 0x83, 0x47, 0x43, 0x05, 0x4e, 0xee,
+  0x4d, 0xad, 0x6c, 0x8c, 0x2e, 0xed, 0xcd, 0x6d, 0x08, 0x18, 0x28, 0x46,
+  0x42, 0x06, 0x49, 0x19, 0x28, 0x44, 0xf2, 0x29, 0x82, 0x12, 0x24, 0x66,
+  0x90, 0x9c, 0x81, 0x42, 0x24, 0x68, 0xa0, 0x1c, 0x09, 0x94, 0xa4, 0x41,
+  0x22, 0x25, 0x6a, 0xc0, 0x84, 0x4e, 0x2e, 0xcc, 0x6d, 0xce, 0xec, 0x4d,
+  0xae, 0x6d, 0x08, 0x18, 0x28, 0x45, 0x42, 0x06, 0x49, 0x19, 0x28, 0x44,
+  0xf2, 0x29, 0x86, 0x12, 0x24, 0x66, 0x90, 0x9c, 0x81, 0x42, 0x24, 0x68,
+  0xa0, 0x1c, 0x09, 0x94, 0xa4, 0x41, 0x22, 0x25, 0x6c, 0x30, 0x44, 0x49,
+  0xc2, 0x20, 0x11, 0x83, 0x64, 0x0c, 0x92, 0x35, 0x48, 0xda, 0x60, 0x88,
+  0x81, 0x00, 0x49, 0x97, 0xb8, 0x01, 0x9f, 0xb7, 0x36, 0xb7, 0x34, 0xb8,
+  0x37, 0xba, 0x32, 0x37, 0x3a, 0x90, 0x31, 0xb4, 0x30, 0x39, 0x3e, 0x53,
+  0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x43, 0x2b, 0x2b, 0x20, 0x54, 0x42,
+  0x41, 0x41, 0x43, 0x84, 0x24, 0x0e, 0x86, 0x18, 0x09, 0x1c, 0x24, 0x72,
+  0xc0, 0x24, 0x43, 0x8c, 0x64, 0x0e, 0x92, 0x39, 0x60, 0x92, 0x11, 0x11,
+  0x3b, 0xb0, 0x83, 0x3d, 0xb4, 0x83, 0x1b, 0xb4, 0xc3, 0x3b, 0x90, 0x43,
+  0x3d, 0xb0, 0x43, 0x39, 0xb8, 0x81, 0x39, 0xb0, 0x43, 0x38, 0x9c, 0xc3,
+  0x3c, 0x4c, 0x11, 0x82, 0x61, 0x84, 0xc2, 0x0e, 0xec, 0x60, 0x0f, 0xed,
+  0xe0, 0x06, 0xe9, 0x40, 0x0e, 0xe5, 0xe0, 0x0e, 0xf4, 0x30, 0x25, 0x28,
+  0x46, 0x2c, 0xe1, 0x90, 0x0e, 0xf2, 0xe0, 0x06, 0xf6, 0x50, 0x0e, 0xf2,
+  0x30, 0x0f, 0xe9, 0xf0, 0x0e, 0xee, 0x30, 0x25, 0x30, 0x46, 0x50, 0xe1,
+  0x90, 0x0e, 0xf2, 0xe0, 0x06, 0xec, 0x10, 0x0e, 0xee, 0x70, 0x0e, 0xf5,
+  0x10, 0x0e, 0xe7, 0x50, 0x0e, 0xbf, 0x60, 0x0f, 0xe5, 0x20, 0x0f, 0xf3,
+  0x90, 0x0e, 0xef, 0xe0, 0x0e, 0x53, 0x02, 0x64, 0xc4, 0x14, 0x0e, 0xe9,
+  0x20, 0x0f, 0x6e, 0x30, 0x0e, 0xef, 0xd0, 0x0e, 0xf0, 0x90, 0x0e, 0xec,
+  0x50, 0x0e, 0xbf, 0xf0, 0x0e, 0xf0, 0x40, 0x0f, 0xe9, 0xf0, 0x0e, 0xee,
+  0x30, 0x0f, 0x53, 0x06, 0x85, 0x71, 0x46, 0x28, 0xe1, 0x90, 0x0e, 0xf2,
+  0xe0, 0x06, 0xf6, 0x50, 0x0e, 0xf2, 0x40, 0x0f, 0xe5, 0x80, 0x0f, 0x53,
+  0x82, 0x37, 0x00, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x7b, 0x00,
+  0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01,
+  0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78,
+  0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4,
+  0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c,
+  0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03,
+  0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70,
+  0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70,
+  0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec,
+  0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0,
+  0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d,
+  0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43,
+  0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0,
+  0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68,
+  0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28,
+  0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08,
+  0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee,
+  0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62,
+  0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c,
+  0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06,
+  0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43,
+  0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3,
+  0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3,
+  0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68,
+  0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce,
+  0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3,
+  0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d,
+  0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e,
+  0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51,
+  0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60,
+  0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98,
+  0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e,
+  0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e,
+  0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83,
+  0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2,
+  0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a,
+  0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28,
+  0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5,
+  0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17,
+  0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83,
+  0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3,
+  0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3,
+  0x3c, 0x00, 0x71, 0x20, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06, 0xf0,
+  0xb0, 0x5d, 0xf9, 0x73, 0xce, 0x83, 0xfd, 0x15, 0x11, 0x4d, 0xc4, 0x05,
+  0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x52, 0x00, 0x00, 0x00, 0x13, 0x04,
+  0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xe4, 0xc6,
+  0x22, 0x86, 0x61, 0x18, 0xc6, 0x22, 0x04, 0x41, 0x10, 0xc6, 0x22, 0x82,
+  0x20, 0x08, 0x88, 0x95, 0x40, 0x19, 0x14, 0x01, 0xb9, 0x11, 0x00, 0x1a,
+  0x33, 0x00, 0x24, 0x66, 0x00, 0x28, 0xcc, 0x00, 0x00, 0x00, 0xe3, 0x11,
+  0x4b, 0x74, 0x45, 0x14, 0x94, 0xf1, 0x08, 0x67, 0xca, 0x26, 0x0a, 0xca,
+  0x20, 0xc3, 0x50, 0x20, 0x26, 0x04, 0xf2, 0x19, 0x8f, 0x90, 0xae, 0xae,
+  0xa1, 0xa0, 0x0c, 0x32, 0x1c, 0x09, 0x64, 0x42, 0x20, 0x1f, 0x0b, 0x0a,
+  0xf8, 0x8c, 0x47, 0x5c, 0x9c, 0x18, 0x40, 0x14, 0x94, 0x41, 0x06, 0xc6,
+  0xb1, 0x4c, 0x08, 0xe4, 0x63, 0x45, 0x00, 0x9f, 0xf1, 0x08, 0x2e, 0x0c,
+  0xce, 0xc0, 0xa2, 0xa0, 0x0c, 0x32, 0x44, 0x13, 0x67, 0x42, 0x20, 0x1f,
+  0x2b, 0x02, 0xf8, 0x8c, 0x47, 0x80, 0x81, 0x19, 0xb0, 0x01, 0x47, 0x41,
+  0x19, 0x64, 0x08, 0xb0, 0xcd, 0x82, 0x4a, 0x3e, 0x83, 0x0c, 0x83, 0x16,
+  0x06, 0x16, 0x4c, 0xf2, 0xb1, 0x21, 0x80, 0xcf, 0x20, 0x83, 0xd1, 0x95,
+  0x81, 0x05, 0x91, 0x7c, 0x6c, 0x08, 0xe0, 0x33, 0xc8, 0x90, 0x80, 0x41,
+  0x1a, 0x58, 0xf0, 0xc8, 0xc7, 0x86, 0x00, 0x3e, 0xe3, 0x11, 0x6d, 0x30,
+  0x07, 0x79, 0x80, 0x06, 0x14, 0x94, 0x41, 0x86, 0xa0, 0x0c, 0xd0, 0xc0,
+  0x02, 0x31, 0x90, 0xcf, 0x20, 0xc3, 0x70, 0x06, 0x6e, 0x60, 0x01, 0x18,
+  0xc8, 0x67, 0x90, 0xa1, 0x48, 0x83, 0x38, 0xb0, 0xa0, 0x93, 0xcf, 0x20,
+  0xc3, 0xb1, 0x06, 0x74, 0x60, 0x81, 0x26, 0x9f, 0x41, 0x86, 0x3d, 0x70,
+  0x03, 0x38, 0xb0, 0x2c, 0x90, 0xcf, 0x20, 0x43, 0x1f, 0xc0, 0x81, 0x1d,
+  0x98, 0x13, 0xc8, 0xc7, 0x92, 0x01, 0x3e, 0x16, 0x30, 0xf0, 0xb1, 0x20,
+  0x81, 0x8f, 0x05, 0x08, 0x7c, 0x2c, 0x28, 0xe0, 0x33, 0xdb, 0x80, 0x07,
+  0x01, 0x30, 0xdb, 0x10, 0x90, 0x42, 0x30, 0xdb, 0x10, 0x90, 0x82, 0x90,
+  0x41, 0x40, 0x0c, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x5b, 0x86,
+  0x20, 0xa0, 0x83, 0x2d, 0xc3, 0x10, 0xd0, 0xc1, 0x96, 0xe1, 0x08, 0xe8,
+  0x60, 0xcb, 0xc0, 0x04, 0x74, 0xb0, 0x65, 0x88, 0x02, 0x3a, 0xd8, 0x32,
+  0x58, 0x01, 0x1d, 0x6c, 0x19, 0xc6, 0x20, 0xa0, 0x03, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00,
+  0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0xe0, 0x08, 0x00, 0x00, 0xff, 0xff,
+  0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0x35, 0x02,
+  0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00,
+  0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10,
+  0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04,
+  0x8b, 0x62, 0x80, 0x10, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0x84, 0x10,
+  0x32, 0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a,
+  0x90, 0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07,
+  0xc8, 0x08, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00,
+  0x00, 0x00, 0x51, 0x18, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00, 0x1b, 0xc8,
+  0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x00, 0x8a, 0x18, 0x87,
+  0x77, 0x90, 0x07, 0x79, 0x28, 0x87, 0x71, 0xa0, 0x07, 0x76, 0xc8, 0x87,
+  0x36, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x77, 0x20, 0x87, 0x72, 0x20, 0x87,
+  0x36, 0x20, 0x87, 0x74, 0xb0, 0x87, 0x74, 0x20, 0x87, 0x72, 0x68, 0x83,
+  0x79, 0x88, 0x07, 0x79, 0xa0, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83,
+  0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6,
+  0xa1, 0x1c, 0x00, 0x82, 0x1c, 0xd2, 0x61, 0x1e, 0xc2, 0x41, 0x1c, 0xd8,
+  0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xc2, 0x21, 0x1d, 0xd8, 0xa1, 0x0d, 0xc6,
+  0x21, 0x1c, 0xd8, 0x81, 0x1d, 0xe6, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87,
+  0x79, 0x28, 0x07, 0x80, 0x60, 0x87, 0x72, 0x98, 0x87, 0x79, 0x68, 0x03,
+  0x78, 0x90, 0x87, 0x72, 0x18, 0x87, 0x74, 0x98, 0x87, 0x72, 0x68, 0x03,
+  0x73, 0x80, 0x87, 0x76, 0x08, 0x07, 0x72, 0x00, 0xcc, 0x21, 0x1c, 0xd8,
+  0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4,
+  0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc,
+  0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda,
+  0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x06, 0x77, 0x78, 0x87,
+  0x36, 0x30, 0x07, 0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87,
+  0x77, 0x48, 0x07, 0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07,
+  0x76, 0x48, 0x87, 0x76, 0x68, 0x03, 0x77, 0x78, 0x07, 0x77, 0x68, 0x03,
+  0x76, 0x28, 0x87, 0x70, 0x30, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83,
+  0x74, 0x70, 0x07, 0x73, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83,
+  0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca,
+  0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x40, 0x1d, 0xea, 0xa1, 0x1d, 0xe0,
+  0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x1e, 0x00,
+  0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87,
+  0x36, 0x70, 0x87, 0x70, 0x70, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87,
+  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea,
+  0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xce,
+  0xc1, 0x1d, 0xca, 0x81, 0x1c, 0xda, 0x40, 0x1f, 0xca, 0x41, 0x1e, 0xde,
+  0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8,
+  0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87,
+  0x77, 0x68, 0x03, 0x7a, 0x90, 0x87, 0x70, 0x80, 0x07, 0x78, 0x48, 0x07,
+  0x77, 0x38, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8,
+  0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0x62, 0x1e, 0xe8, 0x21, 0x1c, 0xc6,
+  0x61, 0x1d, 0xda, 0x00, 0x1e, 0xe4, 0xe1, 0x1d, 0xe8, 0xa1, 0x1c, 0xc6,
+  0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0x40, 0x1c, 0xea, 0xc1, 0x1c, 0xcc,
+  0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xf4, 0xa1, 0x1c, 0x00,
+  0x3c, 0x00, 0x88, 0x7a, 0x70, 0x87, 0x79, 0x08, 0x07, 0x73, 0x28, 0x87,
+  0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07,
+  0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xea, 0x61, 0x1e, 0xca,
+  0xa1, 0x0d, 0xe6, 0xe1, 0x1d, 0xcc, 0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xd8,
+  0xe1, 0x1d, 0xc2, 0x81, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87,
+  0x72, 0x00, 0x36, 0x10, 0x82, 0x00, 0x58, 0x00, 0x00, 0x00, 0x49, 0x18,
+  0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x13, 0x84, 0x40, 0x00, 0x89, 0x20,
+  0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x32, 0x22, 0x08, 0x09, 0x20, 0x64,
+  0x85, 0x04, 0x13, 0x22, 0xa4, 0x84, 0x04, 0x13, 0x22, 0xe3, 0x84, 0xa1,
+  0x90, 0x14, 0x12, 0x4c, 0x88, 0x8c, 0x0b, 0x84, 0x84, 0x4c, 0x10, 0x24,
+  0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00, 0x65, 0x08, 0x09,
+  0x9a, 0x81, 0x80, 0x39, 0x02, 0x30, 0x48, 0x01, 0x1b, 0x01, 0x00, 0x00,
+  0x00, 0x00, 0x13, 0xa8, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68,
+  0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78,
+  0x87, 0x79, 0xc8, 0x03, 0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7,
+  0x51, 0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a,
+  0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78,
+  0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71,
+  0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72,
+  0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9,
+  0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74,
+  0xd0, 0x06, 0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a,
+  0x30, 0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76,
+  0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6,
+  0x20, 0x07, 0x74, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72,
+  0xd0, 0x06, 0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a,
+  0x30, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6,
+  0x90, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71,
+  0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a,
+  0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d,
+  0x60, 0x0f, 0x71, 0x90, 0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76,
+  0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75,
+  0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75,
+  0x60, 0x07, 0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75,
+  0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6,
+  0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72,
+  0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee,
+  0x80, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43,
+  0x18, 0x02, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x2c, 0x10,
+  0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x0c, 0x19, 0x11,
+  0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0xb2, 0x12, 0x18,
+  0x01, 0x28, 0x82, 0x42, 0x28, 0x08, 0xba, 0xb1, 0x04, 0x87, 0x00, 0x00,
+  0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x99, 0x00, 0x00, 0x00, 0x1a, 0x03,
+  0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4,
+  0x37, 0xb7, 0x21, 0x86, 0x31, 0x14, 0xc0, 0x61, 0x50, 0xb9, 0x1b, 0x43,
+  0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b, 0x62, 0x18, 0x41, 0x21,
+  0x18, 0x04, 0xe1, 0x20, 0x08, 0x0e, 0x8e, 0xad, 0x0c, 0x84, 0x89, 0xc9,
+  0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x26,
+  0x06, 0x06, 0x26, 0xc6, 0xa5, 0x06, 0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e,
+  0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26, 0x06, 0x06, 0x26, 0xc6, 0xa5, 0x06,
+  0xc6, 0x25, 0x26, 0x65, 0x88, 0x50, 0x10, 0x43, 0x0c, 0x23, 0x30, 0x0a,
   0x43, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36, 0x04, 0x29, 0x0e, 0x23,
   0x30, 0x02, 0x43, 0xe0, 0x16, 0x96, 0x26, 0xe7, 0x32, 0xf6, 0xd6, 0x06,
   0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6, 0x26, 0xd7, 0x36, 0xf7,
@@ -696,254 +713,1030 @@ const unsigned char sdl_metallib[] = {
   0x17, 0x5d, 0x98, 0xdc, 0x59, 0x19, 0x1d, 0xa3, 0xb0, 0x34, 0x39, 0x97,
   0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0x2f, 0xb7, 0xb0, 0xb6,
   0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x43, 0x90, 0xe2, 0x31,
-  0x84, 0x02, 0x2a, 0xa2, 0x21, 0x42, 0x21, 0x51, 0x09, 0x4b, 0x93, 0x73,
-  0x11, 0xab, 0x33, 0x33, 0x2b, 0x93, 0xe3, 0x13, 0x96, 0x26, 0xe7, 0x22,
-  0x56, 0x67, 0x66, 0x56, 0x26, 0xf7, 0x35, 0x97, 0xa6, 0x57, 0x46, 0x29,
-  0x2c, 0x4d, 0xce, 0x85, 0xed, 0x6d, 0x2c, 0x8c, 0x2e, 0xed, 0xcd, 0xed,
-  0x2b, 0xcd, 0x8d, 0xac, 0x0c, 0x8f, 0x48, 0x58, 0x9a, 0x9c, 0x8b, 0x5c,
-  0x59, 0x18, 0x19, 0xa3, 0xb0, 0x34, 0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f,
-  0xba, 0x3c, 0xb8, 0xb2, 0xaf, 0xb9, 0x34, 0xbd, 0x32, 0x5e, 0x61, 0x69,
-  0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x61,
-  0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x64, 0xc2, 0xd2,
-  0xe4, 0x5c, 0xc2, 0xe4, 0xce, 0xbe, 0xdc, 0xc2, 0xda, 0xca, 0x38, 0x8c,
-  0xbd, 0xb1, 0x0d, 0x01, 0x03, 0x43, 0x28, 0xa8, 0xa2, 0x32, 0x86, 0xc2,
-  0x32, 0x04, 0x23, 0x28, 0xae, 0x02, 0x33, 0x86, 0x22, 0x33, 0x86, 0x02,
-  0x2a, 0xa2, 0x42, 0x2b, 0xb6, 0x21, 0x42, 0xc1, 0x0d, 0x31, 0x08, 0xa0,
-  0x98, 0x8a, 0x8e, 0xcf, 0x5b, 0x9b, 0x5b, 0x1a, 0xdc, 0x1b, 0x5d, 0x99,
-  0x1b, 0x1d, 0xc8, 0x18, 0x5a, 0x98, 0x1c, 0x9f, 0xa9, 0xb4, 0x36, 0x38,
-  0xb6, 0x32, 0x90, 0xa1, 0x95, 0x15, 0x10, 0x2a, 0xa1, 0xa0, 0xa0, 0x21,
-  0x42, 0x01, 0x06, 0x43, 0x8c, 0xe2, 0x2b, 0xc2, 0x00, 0x39, 0x86, 0x18,
-  0x85, 0x18, 0x14, 0x62, 0x80, 0x1c, 0x23, 0x22, 0x76, 0x60, 0x07, 0x7b,
-  0x68, 0x07, 0x37, 0x68, 0x87, 0x77, 0x20, 0x87, 0x7a, 0x60, 0x87, 0x72,
-  0x70, 0x03, 0x73, 0x60, 0x87, 0x70, 0x38, 0x87, 0x79, 0x98, 0x22, 0x04,
-  0xc3, 0x08, 0x85, 0x1d, 0xd8, 0xc1, 0x1e, 0xda, 0xc1, 0x0d, 0xd2, 0x81,
-  0x1c, 0xca, 0xc1, 0x1d, 0xe8, 0x61, 0x4a, 0x50, 0x8c, 0x58, 0xc2, 0x21,
-  0x1d, 0xe4, 0xc1, 0x0d, 0xec, 0xa1, 0x1c, 0xe4, 0x61, 0x1e, 0xd2, 0xe1,
-  0x1d, 0xdc, 0x61, 0x4a, 0x60, 0x8c, 0xa0, 0xc2, 0x21, 0x1d, 0xe4, 0xc1,
-  0x0d, 0xd8, 0x21, 0x1c, 0xdc, 0xe1, 0x1c, 0xea, 0x21, 0x1c, 0xce, 0xa1,
-  0x1c, 0x7e, 0xc1, 0x1e, 0xca, 0x41, 0x1e, 0xe6, 0x21, 0x1d, 0xde, 0xc1,
-  0x1d, 0xa6, 0x04, 0xc8, 0x88, 0x29, 0x1c, 0xd2, 0x41, 0x1e, 0xdc, 0x60,
-  0x1c, 0xde, 0xa1, 0x1d, 0xe0, 0x21, 0x1d, 0xd8, 0xa1, 0x1c, 0x7e, 0xe1,
-  0x1d, 0xe0, 0x81, 0x1e, 0xd2, 0xe1, 0x1d, 0xdc, 0x61, 0x1e, 0xa6, 0x0c,
-  0x0a, 0xe3, 0x8c, 0x60, 0xc2, 0x21, 0x1d, 0xe4, 0xc1, 0x0d, 0xcc, 0x41,
-  0x1e, 0xc2, 0xe1, 0x1c, 0xda, 0xa1, 0x1c, 0xdc, 0x81, 0x1e, 0xa6, 0x04,
-  0x1e, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00,
-  0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88,
-  0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73,
-  0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e,
-  0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30,
-  0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8,
-  0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b,
-  0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76,
-  0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e,
-  0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e,
-  0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61,
-  0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4,
-  0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76,
-  0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37,
-  0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76,
-  0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71,
-  0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e,
-  0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1,
-  0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61,
-  0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90,
-  0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8,
-  0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc,
-  0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7,
-  0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78,
-  0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f,
-  0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f,
-  0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1,
-  0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0,
-  0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0,
-  0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b,
-  0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c,
-  0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61,
-  0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1,
-  0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc,
-  0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4,
-  0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79,
-  0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72,
-  0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e,
-  0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1,
-  0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8,
-  0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8,
-  0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00,
-  0x71, 0x20, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x06, 0x20, 0xb1, 0x5d,
-  0xf9, 0xb3, 0xce, 0x82, 0x0c, 0x7f, 0x11, 0x01, 0x06, 0x43, 0x34, 0x13,
-  0x00, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
-  0x13, 0x04, 0x01, 0x05, 0x25, 0x83, 0x80, 0x18, 0x02, 0x00, 0x00, 0x00,
-  0x5b, 0x06, 0x20, 0x18, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x84, 0x02, 0x2a, 0xa2, 0x21, 0x42, 0x21, 0x51, 0x0a, 0x4b, 0x93, 0x73,
+  0x31, 0x93, 0x0b, 0x3b, 0x6b, 0x2b, 0x73, 0xa3, 0xfb, 0x4a, 0x73, 0x83,
+  0xab, 0xa3, 0x63, 0x76, 0x56, 0xe6, 0x56, 0x26, 0x17, 0x46, 0x57, 0x46,
+  0x86, 0x82, 0x03, 0xf7, 0x36, 0x97, 0x46, 0x97, 0xf6, 0xe6, 0x46, 0x64,
+  0x27, 0xf3, 0x65, 0x96, 0x42, 0x25, 0x2c, 0x4d, 0xce, 0x65, 0xac, 0xcc,
+  0x8d, 0xae, 0x4c, 0x8e, 0x4f, 0x58, 0x9a, 0x9c, 0x0b, 0x5c, 0x99, 0xdc,
+  0x1c, 0x5c, 0xd9, 0x18, 0x5d, 0x9a, 0x5d, 0x19, 0x0d, 0x33, 0xb6, 0xb7,
+  0x30, 0x3a, 0x19, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f,
+  0x6e, 0x61, 0x6d, 0x65, 0x44, 0xe0, 0xde, 0xe6, 0xd2, 0xe8, 0xd2, 0xde,
+  0xdc, 0x86, 0x48, 0x86, 0x50, 0x50, 0x45, 0x55, 0x58, 0xc5, 0x55, 0x40,
+  0x05, 0x56, 0x64, 0x85, 0x46, 0xeb, 0xac, 0xcc, 0xad, 0x4c, 0x2e, 0x8c,
+  0xae, 0x8c, 0x0c, 0xa5, 0x66, 0xec, 0x8d, 0xed, 0x4d, 0x8e, 0xc8, 0x8e,
+  0xe6, 0xcb, 0x2c, 0x85, 0xc5, 0xd8, 0x1b, 0xdb, 0x9b, 0xdc, 0x10, 0xc9,
+  0x08, 0x0a, 0xaa, 0xe0, 0x0a, 0xab, 0xb8, 0x0a, 0xa8, 0x88, 0x8a, 0xac,
+  0xe8, 0x86, 0x10, 0xc5, 0x56, 0x78, 0x43, 0x0c, 0x02, 0x28, 0xa6, 0xe2,
+  0x1b, 0x11, 0xb1, 0x03, 0x3b, 0xd8, 0x43, 0x3b, 0xb8, 0x41, 0x3b, 0xbc,
+  0x03, 0x39, 0xd4, 0x03, 0x3b, 0x94, 0x83, 0x1b, 0x98, 0x03, 0x3b, 0x84,
+  0xc3, 0x39, 0xcc, 0xc3, 0x14, 0x21, 0x18, 0x46, 0x28, 0xec, 0xc0, 0x0e,
+  0xf6, 0xd0, 0x0e, 0x6e, 0x90, 0x0e, 0xe4, 0x50, 0x0e, 0xee, 0x40, 0x0f,
+  0x53, 0x82, 0x62, 0xc4, 0x12, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0x60, 0x0f,
+  0xe5, 0x20, 0x0f, 0xf3, 0x90, 0x0e, 0xef, 0xe0, 0x0e, 0x53, 0x02, 0x63,
+  0x04, 0x15, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0xc0, 0x0e, 0xe1, 0xe0, 0x0e,
+  0xe7, 0x50, 0x0f, 0xe1, 0x70, 0x0e, 0xe5, 0xf0, 0x0b, 0xf6, 0x50, 0x0e,
+  0xf2, 0x30, 0x0f, 0xe9, 0xf0, 0x0e, 0xee, 0x30, 0x25, 0x40, 0x46, 0x4c,
+  0xe1, 0x90, 0x0e, 0xf2, 0xe0, 0x06, 0xe3, 0xf0, 0x0e, 0xed, 0x00, 0x0f,
+  0xe9, 0xc0, 0x0e, 0xe5, 0xf0, 0x0b, 0xef, 0x00, 0x0f, 0xf4, 0x90, 0x0e,
+  0xef, 0xe0, 0x0e, 0xf3, 0x30, 0x65, 0x50, 0x18, 0x67, 0x04, 0x13, 0x0e,
+  0xe9, 0x20, 0x0f, 0x6e, 0x60, 0x0e, 0xf2, 0x10, 0x0e, 0xe7, 0xd0, 0x0e,
+  0xe5, 0xe0, 0x0e, 0xf4, 0x30, 0x25, 0x00, 0x03, 0x00, 0x00, 0x79, 0x18,
+  0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1,
+  0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42,
+  0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f,
+  0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1,
+  0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84,
+  0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc,
+  0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70,
+  0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19,
+  0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f,
+  0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21,
+  0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc,
+  0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84,
+  0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37,
+  0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70,
+  0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77,
+  0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79,
+  0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e,
+  0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1,
+  0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81,
+  0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98,
+  0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88,
+  0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4,
+  0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72,
+  0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74,
+  0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e,
+  0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e,
+  0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21,
+  0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01,
+  0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc,
+  0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77,
+  0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e,
+  0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1,
+  0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61,
+  0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0,
+  0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0,
+  0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74,
+  0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e,
+  0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41,
+  0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50,
+  0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c,
+  0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc,
+  0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20, 0x00, 0x00, 0x05, 0x00,
+  0x00, 0x00, 0x06, 0x20, 0xb1, 0x5d, 0xf9, 0xb3, 0xce, 0x82, 0x0c, 0x7f,
+  0x11, 0x01, 0x06, 0x43, 0x34, 0x13, 0x00, 0x00, 0x00, 0x00, 0x61, 0x20,
+  0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x06, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
-  0xe4, 0x0a, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde,
-  0x21, 0x0c, 0x00, 0x00, 0xb6, 0x02, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00,
-  0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91,
-  0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c,
-  0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02,
-  0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x49,
-  0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52, 0x80,
-  0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8, 0x48, 0x11, 0x62, 0xa8, 0xa0,
-  0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00, 0x00,
-  0x8b, 0x00, 0x00, 0x00, 0x1b, 0xcc, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff,
-  0x01, 0x60, 0x00, 0x09, 0xa8, 0x88, 0x71, 0x78, 0x07, 0x79, 0x90, 0x87,
-  0x72, 0x18, 0x07, 0x7a, 0x60, 0x87, 0x7c, 0x68, 0x03, 0x79, 0x78, 0x87,
-  0x7a, 0x70, 0x07, 0x72, 0x28, 0x07, 0x72, 0x68, 0x03, 0x72, 0x48, 0x07,
-  0x7b, 0x48, 0x07, 0x72, 0x28, 0x87, 0x36, 0x98, 0x87, 0x78, 0x90, 0x07,
-  0x7a, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07,
-  0x74, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xc8,
-  0x21, 0x1d, 0xe6, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0xa1, 0x0d, 0xe8,
-  0x21, 0x1c, 0xd2, 0x81, 0x1d, 0xda, 0x60, 0x1c, 0xc2, 0x81, 0x1d, 0xd8,
-  0x61, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08,
-  0x76, 0x28, 0x87, 0x79, 0x98, 0x87, 0x36, 0x80, 0x07, 0x79, 0x28, 0x87,
-  0x71, 0x48, 0x87, 0x79, 0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x87,
-  0x70, 0x20, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00,
-  0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xcc, 0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca,
-  0xa1, 0x0d, 0xe0, 0xe1, 0x1d, 0xd2, 0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4,
-  0xa1, 0x0d, 0xca, 0x81, 0x1d, 0xd2, 0xa1, 0x1d, 0x00, 0x7a, 0x90, 0x87,
-  0x7a, 0x28, 0x07, 0x60, 0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90, 0x87,
-  0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70, 0x07,
-  0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68, 0x87,
-  0x36, 0x70, 0x87, 0x77, 0x70, 0x87, 0x36, 0x60, 0x87, 0x72, 0x08, 0x07,
-  0x73, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x48, 0x07, 0x77, 0x30, 0x87,
-  0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07,
-  0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde,
-  0xa1, 0x0d, 0xd4, 0xa1, 0x1e, 0xda, 0x01, 0x1e, 0xda, 0x80, 0x1e, 0xc2,
-  0x41, 0x1c, 0xd8, 0xa1, 0x1c, 0xe6, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87,
-  0x79, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x77, 0x08, 0x07,
-  0x77, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07,
-  0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc,
-  0xe1, 0x1d, 0xda, 0x60, 0x1e, 0xd2, 0xe1, 0x1c, 0xdc, 0xa1, 0x1c, 0xc8,
-  0xa1, 0x0d, 0xf4, 0xa1, 0x1c, 0xe4, 0xe1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc,
-  0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07,
-  0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0xa0, 0x07,
-  0x79, 0x08, 0x07, 0x78, 0x80, 0x87, 0x74, 0x70, 0x87, 0x73, 0x68, 0x83,
-  0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca,
-  0x01, 0x20, 0xe6, 0x81, 0x1e, 0xc2, 0x61, 0x1c, 0xd6, 0xa1, 0x0d, 0xe0,
-  0x41, 0x1e, 0xde, 0x81, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4,
-  0xa1, 0x0d, 0xc4, 0xa1, 0x1e, 0xcc, 0xc1, 0x1c, 0xca, 0x41, 0x1e, 0xda,
-  0x60, 0x1e, 0xd2, 0x41, 0x1f, 0xca, 0x01, 0xc0, 0x03, 0x80, 0xa8, 0x07,
-  0x77, 0x98, 0x87, 0x70, 0x30, 0x87, 0x72, 0x68, 0x03, 0x73, 0x80, 0x87,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00,
+  0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x44, 0x0a, 0x00, 0x00, 0xff, 0xff,
+  0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0x8e, 0x02,
+  0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00,
+  0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10,
+  0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04,
+  0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10,
+  0x32, 0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a,
+  0x90, 0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07,
+  0xc8, 0x48, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00,
+  0x00, 0x00, 0x51, 0x18, 0x00, 0x00, 0x89, 0x00, 0x00, 0x00, 0x1b, 0xcc,
+  0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x60, 0x00, 0x09, 0xa8, 0x88,
+  0x71, 0x78, 0x07, 0x79, 0x90, 0x87, 0x72, 0x18, 0x07, 0x7a, 0x60, 0x87,
+  0x7c, 0x68, 0x03, 0x79, 0x78, 0x87, 0x7a, 0x70, 0x07, 0x72, 0x28, 0x07,
+  0x72, 0x68, 0x03, 0x72, 0x48, 0x07, 0x7b, 0x48, 0x07, 0x72, 0x28, 0x87,
+  0x36, 0x98, 0x87, 0x78, 0x90, 0x07, 0x7a, 0x68, 0x03, 0x73, 0x80, 0x87,
+  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xcc, 0x21, 0x1c, 0xd8,
+  0x61, 0x1e, 0xca, 0x01, 0x20, 0xc8, 0x21, 0x1d, 0xe6, 0x21, 0x1c, 0xc4,
+  0x81, 0x1d, 0xca, 0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xd2, 0x81, 0x1d, 0xda,
+  0x60, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0x61, 0x1e, 0x00, 0x73, 0x08, 0x07,
+  0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x76, 0x28, 0x87, 0x79, 0x98, 0x87,
+  0x36, 0x80, 0x07, 0x79, 0x28, 0x87, 0x71, 0x48, 0x87, 0x79, 0x28, 0x87,
+  0x36, 0x30, 0x07, 0x78, 0x68, 0x87, 0x70, 0x20, 0x07, 0xc0, 0x1c, 0xc2,
+  0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xcc,
+  0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca, 0xa1, 0x0d, 0xe0, 0xe1, 0x1d, 0xd2,
+  0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xca, 0x81, 0x1d, 0xd2,
+  0xa1, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x60, 0x70, 0x87,
+  0x77, 0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03,
+  0x78, 0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83,
+  0x72, 0x60, 0x87, 0x74, 0x68, 0x87, 0x36, 0x70, 0x87, 0x77, 0x70, 0x87,
+  0x36, 0x60, 0x87, 0x72, 0x08, 0x07, 0x73, 0x00, 0x08, 0x77, 0x78, 0x87,
+  0x36, 0x48, 0x07, 0x77, 0x30, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87,
   0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea,
-  0xa1, 0x1c, 0x00, 0xa2, 0x1e, 0xe6, 0xa1, 0x1c, 0xda, 0x60, 0x1e, 0xde,
-  0xc1, 0x1c, 0xe8, 0xa1, 0x0d, 0xcc, 0x81, 0x1d, 0xde, 0x21, 0x1c, 0xe8,
-  0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x60, 0x03, 0x22,
-  0x0c, 0x40, 0x02, 0x2c, 0x40, 0xb5, 0xc1, 0x18, 0x08, 0x60, 0x01, 0xaa,
-  0x0d, 0x06, 0x51, 0x00, 0x0b, 0x50, 0x6d, 0x40, 0x8a, 0xff, 0xff, 0xff,
-  0xff, 0x1f, 0x00, 0x06, 0x90, 0x80, 0x6a, 0x83, 0x61, 0x04, 0xc0, 0x02,
-  0x54, 0x1b, 0x8c, 0x43, 0x00, 0x16, 0xa0, 0x02, 0x49, 0x18, 0x00, 0x00,
-  0x03, 0x00, 0x00, 0x00, 0x13, 0x88, 0x40, 0x18, 0x88, 0x09, 0x43, 0x61,
-  0x1c, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
-  0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84,
-  0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c,
-  0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x4c, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30,
-  0x8c, 0x20, 0x00, 0x83, 0x08, 0x41, 0x70, 0x94, 0x34, 0x45, 0x94, 0x30,
-  0xf9, 0xff, 0x44, 0x5c, 0x13, 0x15, 0x11, 0xbf, 0x3d, 0xfc, 0xd3, 0x18,
-  0x01, 0x30, 0x88, 0x40, 0x04, 0x17, 0x49, 0x53, 0x44, 0x09, 0x93, 0xff,
-  0x4b, 0x00, 0xf3, 0x2c, 0x44, 0xf4, 0x4f, 0x63, 0x04, 0xc0, 0x20, 0x82,
-  0x21, 0x14, 0x23, 0x04, 0x31, 0xca, 0x21, 0x34, 0x47, 0x10, 0xcc, 0x11,
-  0x80, 0xc1, 0x30, 0x82, 0xb0, 0x14, 0x24, 0x94, 0x23, 0x14, 0x53, 0x80,
-  0xda, 0x40, 0x40, 0x0a, 0xac, 0x39, 0x02, 0x50, 0x18, 0x01, 0x00, 0x00,
-  0x13, 0xa8, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70,
-  0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87, 0x79,
-  0xc8, 0x03, 0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7, 0x51, 0x0e,
-  0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a, 0x80, 0x07,
-  0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78, 0xa0, 0x07,
-  0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07,
-  0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07,
-  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x60, 0x07,
-  0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06,
-  0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
-  0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76, 0xa0, 0x07,
-  0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07,
-  0x74, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06,
-  0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
-  0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74, 0xa0, 0x07,
-  0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x90, 0x07,
-  0x76, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07,
-  0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07,
-  0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f,
-  0x71, 0x90, 0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07,
-  0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75, 0x60, 0x07,
-  0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07,
-  0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07,
-  0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x10, 0x07,
-  0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07,
-  0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee, 0x80, 0x07,
-  0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43, 0x98, 0x04,
-  0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x21, 0x8c, 0x03, 0x04,
-  0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x16, 0x08, 0x00, 0x00, 0x00,
-  0x09, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90,
-  0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x5a, 0x25, 0x30, 0x02, 0x50,
-  0x20, 0x45, 0x50, 0x08, 0x05, 0x51, 0x06, 0x14, 0x47, 0x00, 0x08, 0x8e,
-  0x25, 0x38, 0x02, 0x00, 0x79, 0x18, 0x00, 0x00, 0xe8, 0x00, 0x00, 0x00,
-  0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9,
-  0xb9, 0xb4, 0x37, 0xb7, 0x21, 0xc6, 0x52, 0x3c, 0x00, 0xa4, 0x50, 0xb9,
-  0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b, 0x62, 0x2c,
-  0xc2, 0x23, 0x2c, 0x06, 0xdd, 0x20, 0x08, 0x0e, 0x8e, 0xad, 0x0c, 0x84,
-  0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x0d,
-  0x64, 0x26, 0x06, 0x06, 0x26, 0xc6, 0x85, 0x66, 0x06, 0x04, 0xa5, 0xad,
-  0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26, 0x06, 0x06, 0x26, 0xc6,
-  0x85, 0x66, 0x26, 0x65, 0x88, 0xf0, 0x10, 0x43, 0x8c, 0x45, 0x58, 0x8e,
-  0x65, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36, 0x04, 0x79, 0x8e, 0x45,
-  0x58, 0x84, 0x65, 0xe0, 0x16, 0x96, 0x26, 0xe7, 0x32, 0xf6, 0xd6, 0x06,
+  0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xd4, 0xa1, 0x1e, 0xda,
+  0x01, 0x1e, 0xda, 0x80, 0x1e, 0xc2, 0x41, 0x1c, 0xd8, 0xa1, 0x1c, 0xe6,
+  0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x70, 0x87,
+  0x77, 0x68, 0x03, 0x77, 0x08, 0x07, 0x77, 0x98, 0x87, 0x36, 0x30, 0x07,
+  0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4,
+  0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x60, 0x1e, 0xd2,
+  0xe1, 0x1c, 0xdc, 0xa1, 0x1c, 0xc8, 0xa1, 0x0d, 0xf4, 0xa1, 0x1c, 0xe4,
+  0xe1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2,
+  0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08,
+  0x77, 0x78, 0x87, 0x36, 0xa0, 0x07, 0x79, 0x08, 0x07, 0x78, 0x80, 0x87,
+  0x74, 0x70, 0x87, 0x73, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07,
+  0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xe6, 0x81, 0x1e, 0xc2,
+  0x61, 0x1c, 0xd6, 0xa1, 0x0d, 0xe0, 0x41, 0x1e, 0xde, 0x81, 0x1e, 0xca,
+  0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0xa1, 0x0d, 0xc4, 0xa1, 0x1e, 0xcc,
+  0xc1, 0x1c, 0xca, 0x41, 0x1e, 0xda, 0x60, 0x1e, 0xd2, 0x41, 0x1f, 0xca,
+  0x01, 0xc0, 0x03, 0x80, 0xa8, 0x07, 0x77, 0x98, 0x87, 0x70, 0x30, 0x87,
+  0x72, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07,
+  0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xa2, 0x1e, 0xe6,
+  0xa1, 0x1c, 0xda, 0x60, 0x1e, 0xde, 0xc1, 0x1c, 0xe8, 0xa1, 0x0d, 0xcc,
+  0x81, 0x1d, 0xde, 0x21, 0x1c, 0xe8, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87,
+  0x79, 0x28, 0x07, 0x60, 0x83, 0x21, 0x10, 0xc0, 0x02, 0x54, 0x1b, 0x8c,
+  0xa1, 0x00, 0x16, 0xa0, 0xda, 0x80, 0x10, 0xff, 0xff, 0xff, 0xff, 0x3f,
+  0x00, 0x0c, 0x20, 0x01, 0xd5, 0x06, 0xa3, 0x08, 0x80, 0x05, 0xa8, 0x36,
+  0x18, 0x86, 0x00, 0x2c, 0x40, 0x05, 0x49, 0x18, 0x00, 0x00, 0x03, 0x00,
+  0x00, 0x00, 0x13, 0x86, 0x40, 0x18, 0x26, 0x0c, 0x44, 0x61, 0x00, 0x00,
+  0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x32, 0x22,
+  0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93,
+  0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84,
+  0xa4, 0x4c, 0x10, 0x44, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20,
+  0x00, 0x47, 0x49, 0x53, 0x44, 0x09, 0x93, 0xff, 0x4f, 0xc4, 0x35, 0x51,
+  0x11, 0xf1, 0xdb, 0xc3, 0x3f, 0x8d, 0x11, 0x00, 0x83, 0x08, 0x43, 0x70,
+  0x91, 0x34, 0x45, 0x94, 0x30, 0xf9, 0xbf, 0x04, 0x30, 0xcf, 0x42, 0x44,
+  0xff, 0x34, 0x46, 0x00, 0x0c, 0x22, 0x14, 0x42, 0x31, 0x42, 0x08, 0x82,
+  0x18, 0x3a, 0x73, 0x04, 0xc1, 0x1c, 0x01, 0x18, 0x0c, 0x23, 0x08, 0x4a,
+  0x41, 0x02, 0x31, 0x22, 0xad, 0x04, 0x88, 0x0d, 0x04, 0xa4, 0x80, 0x1a,
+  0x01, 0x00, 0x13, 0xa8, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68,
+  0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78,
+  0x87, 0x79, 0xc8, 0x03, 0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7,
+  0x51, 0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a,
+  0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78,
+  0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71,
+  0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72,
+  0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9,
+  0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74,
+  0xd0, 0x06, 0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a,
+  0x30, 0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76,
+  0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6,
+  0x20, 0x07, 0x74, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72,
+  0xd0, 0x06, 0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a,
+  0x30, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6,
+  0x90, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71,
+  0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a,
+  0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d,
+  0x60, 0x0f, 0x71, 0x90, 0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76,
+  0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75,
+  0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75,
+  0x60, 0x07, 0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75,
+  0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6,
+  0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72,
+  0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee,
+  0x80, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43,
+  0x18, 0x04, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x21, 0x4c,
+  0x03, 0x04, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x16, 0x08, 0x00,
+  0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11,
+  0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x52, 0x25, 0x30,
+  0x02, 0x50, 0x04, 0x85, 0x50, 0x10, 0x65, 0x40, 0x6f, 0x2c, 0xc1, 0x21,
+  0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0xca, 0x00, 0x00, 0x00, 0x1a, 0x03,
+  0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4,
+  0x37, 0xb7, 0x21, 0x86, 0x42, 0x38, 0xc0, 0x83, 0x50, 0xb9, 0x1b, 0x43,
+  0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b, 0x62, 0x28, 0x82, 0x23,
+  0x28, 0x05, 0xe1, 0x20, 0x08, 0x0e, 0x8e, 0xad, 0x0c, 0x84, 0x89, 0xc9,
+  0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x26,
+  0x06, 0x06, 0x26, 0xc6, 0xa5, 0x06, 0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e,
+  0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26, 0x06, 0x06, 0x26, 0xc6, 0xa5, 0x06,
+  0xc6, 0x25, 0x26, 0x65, 0x88, 0xe0, 0x10, 0x43, 0x0c, 0x45, 0x50, 0x0c,
+  0x65, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36, 0x04, 0x71, 0x0e, 0x45,
+  0x50, 0x04, 0x65, 0xe0, 0x16, 0x96, 0x26, 0xe7, 0x32, 0xf6, 0xd6, 0x06,
   0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6, 0x26, 0xd7, 0x36, 0xf7,
-  0x45, 0x96, 0x36, 0x17, 0x26, 0xc6, 0x56, 0x36, 0x44, 0x78, 0x12, 0x72,
+  0x45, 0x96, 0x36, 0x17, 0x26, 0xc6, 0x56, 0x36, 0x44, 0x70, 0x12, 0x72,
   0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e,
   0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e,
-  0x61, 0x62, 0x6c, 0x65, 0x43, 0x84, 0x67, 0x21, 0x19, 0x84, 0xa5, 0xc9,
+  0x61, 0x62, 0x6c, 0x65, 0x43, 0x04, 0x67, 0x21, 0x19, 0x84, 0xa5, 0xc9,
   0xb9, 0x8c, 0xbd, 0xb5, 0xc1, 0xa5, 0xb1, 0x95, 0xb9, 0x98, 0xc9, 0x85,
   0xb5, 0x95, 0x89, 0xd5, 0x99, 0x99, 0x95, 0xc9, 0x7d, 0x99, 0x95, 0xd1,
-  0x8d, 0xa1, 0x7d, 0x95, 0xb9, 0x85, 0x89, 0xb1, 0x95, 0x0d, 0x11, 0x9e,
+  0x8d, 0xa1, 0x7d, 0x95, 0xb9, 0x85, 0x89, 0xb1, 0x95, 0x0d, 0x11, 0x9c,
   0x86, 0x51, 0x58, 0x9a, 0x9c, 0x8b, 0x5c, 0x99, 0x1b, 0x59, 0x99, 0xdc,
   0x17, 0x5d, 0x98, 0xdc, 0x59, 0x19, 0x1d, 0xa3, 0xb0, 0x34, 0x39, 0x97,
   0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0x2f, 0xb7, 0xb0, 0xb6,
-  0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x43, 0x90, 0xe7, 0x59,
-  0x86, 0x07, 0x7a, 0xa2, 0x21, 0xc2, 0x23, 0x91, 0x09, 0x4b, 0x93, 0x73,
+  0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x43, 0x10, 0xe7, 0x51,
+  0x06, 0x07, 0x72, 0xa2, 0x21, 0x82, 0x23, 0x91, 0x09, 0x4b, 0x93, 0x73,
   0x81, 0x7b, 0x9b, 0x4b, 0xa3, 0x4b, 0x7b, 0x73, 0xa3, 0x12, 0x96, 0x26,
   0xe7, 0x32, 0x56, 0xe6, 0x46, 0x57, 0x26, 0x47, 0x29, 0x2c, 0x4d, 0xce,
   0xc5, 0xed, 0xed, 0x0b, 0xae, 0x4c, 0x6e, 0x0e, 0xae, 0x6c, 0x8c, 0x2e,
   0xcd, 0xae, 0x8c, 0x4c, 0x58, 0x9a, 0x9c, 0x4b, 0x98, 0xdc, 0xd9, 0x97,
   0x5b, 0x58, 0x5b, 0x19, 0x11, 0xb8, 0xb7, 0xb9, 0x34, 0xba, 0xb4, 0x37,
-  0xb7, 0x21, 0xd0, 0x32, 0x3c, 0xd4, 0x53, 0x3d, 0xd6, 0x03, 0x3d, 0xd1,
-  0x73, 0x3d, 0x18, 0xa5, 0xb0, 0x34, 0x39, 0x17, 0x33, 0xb9, 0xb0, 0xb3,
-  0xb6, 0x32, 0x37, 0xba, 0xaf, 0x34, 0x37, 0xb8, 0x3a, 0x3a, 0x66, 0x67,
-  0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x38, 0x74, 0x65,
-  0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x44, 0x76, 0x32, 0x5f, 0x66, 0x29,
-  0x7c, 0xc2, 0xd2, 0xe4, 0x5c, 0xe0, 0xca, 0xe4, 0xe6, 0xe0, 0xca, 0xc6,
-  0xe8, 0xd2, 0xec, 0xca, 0x68, 0x98, 0xb1, 0xbd, 0x85, 0xd1, 0xc9, 0x10,
-  0xa1, 0x2b, 0xc3, 0x1b, 0x7b, 0x7b, 0x93, 0x23, 0x1b, 0x22, 0x2d, 0xc2,
-  0xa3, 0x3d, 0xdb, 0x53, 0x3d, 0xdc, 0x03, 0x3d, 0xdd, 0x73, 0x3d, 0x1e,
-  0x95, 0xb0, 0x34, 0x39, 0x17, 0xb1, 0x3a, 0x33, 0xb3, 0x32, 0x39, 0x3e,
-  0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73,
-  0x69, 0x7a, 0x65, 0x94, 0xc2, 0xd2, 0xe4, 0x5c, 0xd8, 0xde, 0xc6, 0xc2,
-  0xe8, 0xd2, 0xde, 0xdc, 0xbe, 0xd2, 0xdc, 0xc8, 0xca, 0xf0, 0x88, 0x84,
-  0xa5, 0xc9, 0xb9, 0xc8, 0x95, 0x85, 0x91, 0x31, 0x0a, 0x4b, 0x93, 0x73,
-  0x09, 0x93, 0x3b, 0xfb, 0xa2, 0xcb, 0x83, 0x2b, 0xfb, 0x9a, 0x4b, 0xd3,
-  0x2b, 0xe3, 0x15, 0x96, 0x26, 0xe7, 0x12, 0x26, 0x77, 0xf6, 0x45, 0x97,
-  0x07, 0x57, 0xf6, 0x15, 0xc6, 0x96, 0x76, 0xe6, 0xf6, 0x35, 0x97, 0xa6,
-  0x57, 0xc6, 0x61, 0xec, 0x8d, 0x6d, 0x08, 0x18, 0x2c, 0xc5, 0x03, 0x06,
-  0x4f, 0x18, 0x2c, 0xc4, 0x23, 0x06, 0xcb, 0xb0, 0x08, 0xcf, 0x18, 0x3c,
-  0x64, 0xb0, 0x10, 0x4f, 0x19, 0x2c, 0xc4, 0x03, 0x3d, 0xd1, 0x73, 0x3d,
-  0x66, 0xc0, 0x25, 0x2c, 0x4d, 0xce, 0x85, 0xae, 0x0c, 0x8f, 0xae, 0x4e,
-  0xae, 0x8c, 0x4a, 0x58, 0x9a, 0x9c, 0xcb, 0x5c, 0x58, 0x1b, 0x1c, 0x5b,
-  0x19, 0x31, 0xba, 0x32, 0x3c, 0xba, 0x3a, 0xb9, 0x32, 0x19, 0x32, 0x1e,
-  0x33, 0xb6, 0xb7, 0x30, 0x3a, 0x16, 0x90, 0xb9, 0xb0, 0x36, 0x38, 0xb6,
-  0x32, 0x1f, 0x0e, 0x74, 0x65, 0x78, 0x43, 0xa8, 0x05, 0x79, 0xd0, 0xe0,
-  0x11, 0x83, 0x65, 0x58, 0x84, 0x27, 0x0d, 0x1e, 0xe8, 0x51, 0x83, 0xe7,
-  0x7a, 0xd6, 0x80, 0x4b, 0x58, 0x9a, 0x9c, 0xcb, 0x5c, 0x58, 0x1b, 0x1c,
-  0x5b, 0x99, 0x1c, 0x8f, 0xb9, 0xb0, 0x36, 0x38, 0xb6, 0x32, 0x39, 0x06,
-  0x73, 0x43, 0xa4, 0xc5, 0x78, 0xda, 0xe0, 0x11, 0x83, 0x65, 0x58, 0x84,
-  0x07, 0x7a, 0xdc, 0xe0, 0xb9, 0x9e, 0x37, 0x18, 0xa2, 0x3c, 0xd9, 0xf3,
-  0x3d, 0x67, 0xf0, 0xb0, 0xc1, 0x03, 0x07, 0x43, 0x8c, 0x04, 0x78, 0xa6,
-  0x27, 0x0e, 0xf8, 0xbc, 0xb5, 0xb9, 0xa5, 0xc1, 0xbd, 0xd1, 0x95, 0xb9,
-  0xd1, 0x81, 0x8c, 0xa1, 0x85, 0xc9, 0xf1, 0x99, 0x4a, 0x6b, 0x83, 0x63,
-  0x2b, 0x03, 0x19, 0x5a, 0x59, 0x01, 0xa1, 0x12, 0x0a, 0x0a, 0x1a, 0x22,
-  0x3c, 0x74, 0x30, 0xc4, 0x78, 0xe6, 0xe0, 0xa9, 0x83, 0x28, 0x19, 0x62,
-  0x3c, 0x76, 0xf0, 0xd8, 0x41, 0x94, 0x8c, 0x88, 0xd8, 0x81, 0x1d, 0xec,
+  0xb7, 0x21, 0x90, 0x32, 0x38, 0x94, 0x53, 0x39, 0x96, 0x03, 0x39, 0x91,
+  0x73, 0x39, 0x18, 0xa5, 0xb0, 0x34, 0x39, 0x17, 0x33, 0xb9, 0xb0, 0xb3,
+  0xb6, 0x32, 0x37, 0xba, 0xaf, 0x34, 0x37, 0xb8, 0x3a, 0x3a, 0x5a, 0x67,
+  0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x35, 0x63, 0x6f,
+  0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66, 0x29, 0x7c, 0xc2, 0xd2,
+  0xe4, 0x5c, 0xe0, 0xca, 0xe4, 0xe6, 0xe0, 0xca, 0xc6, 0xe8, 0xd2, 0xec,
+  0xca, 0x58, 0x8c, 0xbd, 0xb1, 0xbd, 0xc9, 0x0d, 0x91, 0x14, 0xc1, 0xd1,
+  0x9c, 0xcd, 0xa9, 0x1c, 0xce, 0x81, 0x9c, 0xc8, 0xb9, 0x9c, 0x8e, 0xd9,
+  0x59, 0x99, 0x5b, 0x99, 0x5c, 0x18, 0x5d, 0x19, 0x19, 0x0a, 0x0e, 0x5d,
+  0x19, 0xde, 0xd8, 0xdb, 0x9b, 0x1c, 0x19, 0x91, 0x9d, 0xcc, 0x97, 0x59,
+  0x0a, 0x0d, 0x33, 0xb6, 0xb7, 0x30, 0x3a, 0x19, 0x22, 0x74, 0x65, 0x78,
+  0x63, 0x6f, 0x6f, 0x72, 0x64, 0x43, 0x24, 0x85, 0x70, 0x34, 0xe7, 0x73,
+  0x2a, 0x87, 0x73, 0x20, 0x07, 0x0c, 0x9c, 0xcb, 0x09, 0x03, 0x2e, 0x61,
+  0x69, 0x72, 0x2e, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x94, 0xc2,
+  0xd2, 0xe4, 0x5c, 0xd8, 0xde, 0xc6, 0xc2, 0xe8, 0xd2, 0xde, 0xdc, 0xbe,
+  0xd2, 0xdc, 0xc8, 0xca, 0xf0, 0xa8, 0x84, 0xa5, 0xc9, 0xb9, 0xcc, 0x85,
+  0xb5, 0xc1, 0xb1, 0x95, 0x11, 0xa3, 0x2b, 0xc3, 0xa3, 0xab, 0x93, 0x2b,
+  0x93, 0x21, 0xe3, 0x31, 0x63, 0x7b, 0x0b, 0xa3, 0x63, 0x01, 0x99, 0x0b,
+  0x6b, 0x83, 0x63, 0x2b, 0xf3, 0xe1, 0x40, 0x57, 0x86, 0x37, 0x84, 0x52,
+  0x0e, 0x67, 0x0c, 0x1c, 0x32, 0x50, 0x06, 0x45, 0x70, 0xca, 0xc0, 0x81,
+  0x1c, 0x33, 0x70, 0x2e, 0xe7, 0x0c, 0xb8, 0x84, 0xa5, 0xc9, 0xb9, 0xcc,
+  0x85, 0xb5, 0xc1, 0xb1, 0x95, 0xc9, 0xf1, 0x98, 0x0b, 0x6b, 0x83, 0x63,
+  0x2b, 0x93, 0x63, 0x30, 0x37, 0x44, 0x52, 0x0a, 0x27, 0x0d, 0x1c, 0x32,
+  0x50, 0x06, 0x45, 0x70, 0x20, 0x47, 0x0d, 0x9c, 0xcb, 0x59, 0x83, 0x21,
+  0x8a, 0x93, 0x39, 0x9e, 0x23, 0x06, 0x0e, 0x1a, 0x38, 0x6c, 0x30, 0xc4,
+  0x40, 0x00, 0x67, 0x72, 0xda, 0x60, 0x44, 0xc4, 0x0e, 0xec, 0x60, 0x0f,
+  0xed, 0xe0, 0x06, 0xed, 0xf0, 0x0e, 0xe4, 0x50, 0x0f, 0xec, 0x50, 0x0e,
+  0x6e, 0x60, 0x0e, 0xec, 0x10, 0x0e, 0xe7, 0x30, 0x0f, 0x53, 0x84, 0x60,
+  0x18, 0xa1, 0xb0, 0x03, 0x3b, 0xd8, 0x43, 0x3b, 0xb8, 0x41, 0x3a, 0x90,
+  0x43, 0x39, 0xb8, 0x03, 0x3d, 0x4c, 0x09, 0x8a, 0x11, 0x4b, 0x38, 0xa4,
+  0x83, 0x3c, 0xb8, 0x81, 0x3d, 0x94, 0x83, 0x3c, 0xcc, 0x43, 0x3a, 0xbc,
+  0x83, 0x3b, 0x4c, 0x09, 0x8c, 0x11, 0x54, 0x38, 0xa4, 0x83, 0x3c, 0xb8,
+  0x01, 0x3b, 0x84, 0x83, 0x3b, 0x9c, 0x43, 0x3d, 0x84, 0xc3, 0x39, 0x94,
+  0xc3, 0x2f, 0xd8, 0x43, 0x39, 0xc8, 0xc3, 0x3c, 0xa4, 0xc3, 0x3b, 0xb8,
+  0xc3, 0x94, 0x00, 0x19, 0x31, 0x85, 0x43, 0x3a, 0xc8, 0x83, 0x1b, 0x8c,
+  0xc3, 0x3b, 0xb4, 0x03, 0x3c, 0xa4, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc,
+  0x03, 0x3c, 0xd0, 0x43, 0x3a, 0xbc, 0x83, 0x3b, 0xcc, 0xc3, 0x94, 0x41,
+  0x61, 0x9c, 0x11, 0x4c, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xc8,
+  0x43, 0x38, 0x9c, 0x43, 0x3b, 0x94, 0x83, 0x3b, 0xd0, 0xc3, 0x94, 0xc0,
+  0x0d, 0x00, 0x79, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08,
+  0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38,
+  0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71,
+  0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c,
+  0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d,
+  0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d,
+  0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07,
+  0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87,
+  0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30,
+  0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10,
+  0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66,
+  0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c,
+  0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07,
+  0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87,
+  0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05,
+  0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87,
+  0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0,
+  0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4,
+  0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca,
+  0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39,
+  0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38,
+  0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c,
+  0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87,
+  0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87,
+  0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00,
+  0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20,
+  0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2,
+  0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4,
+  0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a,
+  0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07,
+  0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90,
+  0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8,
+  0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc,
+  0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b,
+  0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b,
+  0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87,
+  0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81,
+  0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30,
+  0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde,
+  0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39,
+  0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f,
+  0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20,
+  0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x06, 0x10, 0xb1, 0x5d, 0xf9, 0x73,
+  0xce, 0x83, 0xfd, 0x45, 0x04, 0x18, 0x0c, 0xd1, 0x4c, 0x16, 0xb0, 0x01,
+  0x48, 0xe4, 0x4b, 0x00, 0xf3, 0x2c, 0xc4, 0x3f, 0x11, 0xd7, 0x44, 0x45,
+  0xc4, 0x6f, 0x0f, 0x7e, 0x85, 0x17, 0xb7, 0x0d, 0x00, 0x00, 0x61, 0x20,
+  0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00,
+  0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xb4, 0x46, 0x00, 0x28, 0xd5, 0xc0,
+  0x08, 0x00, 0x81, 0x11, 0x00, 0x00, 0x23, 0x06, 0x8a, 0x10, 0x44, 0x46,
+  0x71, 0x0c, 0x84, 0x10, 0x58, 0x90, 0xc8, 0x27, 0x03, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0,
+  0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0xc8, 0x0c,
+  0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c,
+  0x00, 0x00, 0x2f, 0x03, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00,
+  0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8,
+  0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05,
+  0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92,
+  0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32,
+  0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19,
+  0x21, 0x72, 0x24, 0x07, 0xc8, 0x48, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40,
+  0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00, 0x00, 0x8e, 0x00,
+  0x00, 0x00, 0x1b, 0xcc, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x60,
+  0x00, 0x09, 0xa8, 0x88, 0x71, 0x78, 0x07, 0x79, 0x90, 0x87, 0x72, 0x18,
+  0x07, 0x7a, 0x60, 0x87, 0x7c, 0x68, 0x03, 0x79, 0x78, 0x87, 0x7a, 0x70,
+  0x07, 0x72, 0x28, 0x07, 0x72, 0x68, 0x03, 0x72, 0x48, 0x07, 0x7b, 0x48,
+  0x07, 0x72, 0x28, 0x87, 0x36, 0x98, 0x87, 0x78, 0x90, 0x07, 0x7a, 0x68,
+  0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00,
+  0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xc8, 0x21, 0x1d,
+  0xe6, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0xa1, 0x0d, 0xe8, 0x21, 0x1c,
+  0xd2, 0x81, 0x1d, 0xda, 0x60, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0x61, 0x1e,
+  0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x76, 0x28,
+  0x87, 0x79, 0x98, 0x87, 0x36, 0x80, 0x07, 0x79, 0x28, 0x87, 0x71, 0x48,
+  0x87, 0x79, 0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x87, 0x70, 0x20,
+  0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0xc2, 0x1d,
+  0xde, 0xa1, 0x0d, 0xcc, 0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca, 0xa1, 0x0d,
+  0xe0, 0xe1, 0x1d, 0xd2, 0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d,
+  0xca, 0x81, 0x1d, 0xd2, 0xa1, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28,
+  0x07, 0x60, 0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68,
+  0x87, 0x72, 0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28,
+  0x07, 0x79, 0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68, 0x87, 0x36, 0x70,
+  0x87, 0x77, 0x70, 0x87, 0x36, 0x60, 0x87, 0x72, 0x08, 0x07, 0x73, 0x00,
+  0x08, 0x77, 0x78, 0x87, 0x36, 0x48, 0x07, 0x77, 0x30, 0x87, 0x79, 0x68,
+  0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00,
+  0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d,
+  0xd4, 0xa1, 0x1e, 0xda, 0x01, 0x1e, 0xda, 0x80, 0x1e, 0xc2, 0x41, 0x1c,
+  0xd8, 0xa1, 0x1c, 0xe6, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28,
+  0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x77, 0x08, 0x07, 0x77, 0x98,
+  0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40,
+  0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0x60, 0x1e, 0xd2, 0xe1, 0x1c, 0xdc, 0xa1, 0x1c, 0xc8, 0xa1, 0x0d,
+  0xf4, 0xa1, 0x1c, 0xe4, 0xe1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e,
+  0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8,
+  0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0xa0, 0x07, 0x79, 0x08,
+  0x07, 0x78, 0x80, 0x87, 0x74, 0x70, 0x87, 0x73, 0x68, 0x83, 0x76, 0x08,
+  0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20,
+  0xe6, 0x81, 0x1e, 0xc2, 0x61, 0x1c, 0xd6, 0xa1, 0x0d, 0xe0, 0x41, 0x1e,
+  0xde, 0x81, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0xa1, 0x0d,
+  0xc4, 0xa1, 0x1e, 0xcc, 0xc1, 0x1c, 0xca, 0x41, 0x1e, 0xda, 0x60, 0x1e,
+  0xd2, 0x41, 0x1f, 0xca, 0x01, 0xc0, 0x03, 0x80, 0xa8, 0x07, 0x77, 0x98,
+  0x87, 0x70, 0x30, 0x87, 0x72, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68,
+  0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c,
+  0x00, 0xa2, 0x1e, 0xe6, 0xa1, 0x1c, 0xda, 0x60, 0x1e, 0xde, 0xc1, 0x1c,
+  0xe8, 0xa1, 0x0d, 0xcc, 0x81, 0x1d, 0xde, 0x21, 0x1c, 0xe8, 0x01, 0x30,
+  0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x60, 0x03, 0x22, 0x10, 0x40,
+  0x02, 0x2c, 0x40, 0xb5, 0xc1, 0x18, 0x0a, 0x60, 0x01, 0xaa, 0x0d, 0x06,
+  0x71, 0x00, 0x0b, 0x50, 0x6d, 0x30, 0x8a, 0xff, 0xff, 0xff, 0xff, 0x1f,
+  0x00, 0x09, 0xa0, 0x36, 0x20, 0xc6, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00,
+  0x03, 0x48, 0x40, 0xb5, 0xc1, 0x38, 0x02, 0x60, 0x01, 0xaa, 0x0d, 0x06,
+  0x22, 0x00, 0x0b, 0x50, 0x01, 0x00, 0x49, 0x18, 0x00, 0x00, 0x03, 0x00,
+  0x00, 0x00, 0x13, 0x88, 0x40, 0x18, 0x88, 0x09, 0x41, 0x31, 0x61, 0x30,
+  0x0e, 0x04, 0x89, 0x20, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x32, 0x22,
+  0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93,
+  0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84,
+  0xa4, 0x4c, 0x10, 0x78, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20,
+  0x00, 0xc3, 0x08, 0x03, 0x70, 0x90, 0x34, 0x45, 0x94, 0x30, 0xf9, 0xb2,
+  0xfb, 0x76, 0x84, 0xe0, 0x0c, 0x04, 0x22, 0xc6, 0x18, 0x63, 0x10, 0x81,
+  0x10, 0x8e, 0x92, 0xa6, 0x88, 0x12, 0x26, 0xff, 0x9f, 0x88, 0x6b, 0xa2,
+  0x22, 0xe2, 0xb7, 0x87, 0x7f, 0x1a, 0x23, 0x00, 0x06, 0x11, 0x8c, 0xe0,
+  0x34, 0x69, 0x8a, 0x28, 0x61, 0xf2, 0xff, 0x89, 0xb8, 0x26, 0x2a, 0x22,
+  0x7e, 0x7b, 0xf8, 0x81, 0x28, 0x02, 0xb0, 0x7f, 0x1a, 0x23, 0x00, 0x06,
+  0x11, 0x90, 0xe0, 0x22, 0x69, 0x8a, 0x28, 0x61, 0xf2, 0x7f, 0x09, 0x60,
+  0x9e, 0x85, 0x88, 0xfe, 0x69, 0x8c, 0x00, 0x18, 0x44, 0x50, 0x84, 0x82,
+  0x84, 0x10, 0x44, 0x39, 0x69, 0x11, 0x2b, 0x03, 0x18, 0x83, 0xdc, 0x1c,
+  0x01, 0x18, 0xcc, 0x11, 0x04, 0xc3, 0x08, 0x02, 0x54, 0x92, 0x90, 0x96,
+  0x80, 0x51, 0x46, 0x40, 0xb3, 0x20, 0xe1, 0x2c, 0x11, 0x65, 0x04, 0x54,
+  0x07, 0x02, 0x52, 0x00, 0x0e, 0x23, 0x0c, 0xd0, 0x20, 0x42, 0x20, 0xcc,
+  0x11, 0x80, 0xc2, 0x20, 0xc2, 0x20, 0x8c, 0x00, 0x00, 0x00, 0x13, 0xa8,
+  0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70, 0x80, 0x07,
+  0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87, 0x79, 0xc8, 0x03,
+  0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7, 0x51, 0x0e, 0x6d, 0x00,
+  0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60,
+  0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80,
+  0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0,
+  0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x10,
+  0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0,
+  0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60,
+  0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x74, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0,
+  0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60,
+  0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x90, 0x07, 0x76, 0xa0,
+  0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0,
+  0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80,
+  0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x90,
+  0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50,
+  0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20,
+  0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x6d, 0x60,
+  0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xa0,
+  0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x70, 0x20,
+  0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x7a, 0x10,
+  0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee, 0x80, 0x07, 0x7a, 0x10,
+  0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43, 0x98, 0x06, 0x00, 0x80,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x21, 0xcc, 0x03, 0x04, 0x80, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0xc0, 0x10, 0x86, 0x02, 0x02, 0x60, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x60, 0x08, 0x63, 0x01, 0x01, 0x30, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x90, 0x05, 0x02, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x32, 0x1e,
+  0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04,
+  0x43, 0x82, 0x25, 0x30, 0x02, 0x50, 0x20, 0x45, 0x50, 0x08, 0x05, 0x18,
+  0x50, 0x10, 0x65, 0x50, 0x40, 0x05, 0x56, 0x0a, 0xc5, 0x40, 0x78, 0x2c,
+  0xc1, 0x21, 0x00, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x13, 0x01,
+  0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab,
+  0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x06, 0x74, 0x5c, 0x00, 0x06,
+  0x51, 0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b,
+  0x62, 0x40, 0xc4, 0x25, 0x40, 0x08, 0xe1, 0x20, 0x08, 0x0e, 0x8e, 0xad,
+  0x0c, 0x84, 0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed,
+  0xcd, 0x0d, 0x64, 0x26, 0x06, 0x06, 0x26, 0xc6, 0xa5, 0x06, 0x06, 0x04,
+  0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26, 0x06, 0x06,
+  0x26, 0xc6, 0xa5, 0x06, 0xc6, 0x25, 0x26, 0x65, 0x88, 0x70, 0x11, 0x43,
+  0x0c, 0x88, 0x80, 0x14, 0xa8, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36,
+  0x04, 0xb9, 0x0e, 0x88, 0x80, 0x08, 0xa8, 0xe0, 0x16, 0x96, 0x26, 0xe7,
+  0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6,
+  0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96, 0x36, 0x17, 0x26, 0xc6, 0x56, 0x36,
+  0x44, 0xb8, 0x12, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
+  0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74,
+  0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x84, 0x6b, 0x21,
+  0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5, 0xc1, 0xa5, 0xb1, 0x95,
+  0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5, 0x99, 0x99, 0x95, 0xc9,
+  0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x95, 0xb9, 0x85, 0x89, 0xb1,
+  0x95, 0x0d, 0x11, 0xae, 0x86, 0x51, 0x58, 0x9a, 0x9c, 0x8b, 0x5c, 0x99,
+  0x1b, 0x59, 0x99, 0xdc, 0x17, 0x5d, 0x98, 0xdc, 0x59, 0x19, 0x1d, 0xa3,
+  0xb0, 0x34, 0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2,
+  0x2f, 0xb7, 0xb0, 0xb6, 0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34,
+  0x43, 0x90, 0xeb, 0x81, 0x8a, 0x0b, 0xba, 0xa2, 0x21, 0xc2, 0x25, 0x91,
+  0x09, 0x4b, 0x93, 0x73, 0x81, 0x7b, 0x9b, 0x4b, 0xa3, 0x4b, 0x7b, 0x73,
+  0xa3, 0x12, 0x96, 0x26, 0xe7, 0x32, 0x56, 0xe6, 0x46, 0x57, 0x26, 0x47,
+  0x29, 0x2c, 0x4d, 0xce, 0xc5, 0xed, 0xed, 0x0b, 0xae, 0x4c, 0x6e, 0x0e,
+  0xae, 0x6c, 0x8c, 0x2e, 0xcd, 0xae, 0x8c, 0x4c, 0x58, 0x9a, 0x9c, 0x4b,
+  0x98, 0xdc, 0xd9, 0x97, 0x5b, 0x58, 0x5b, 0x19, 0x11, 0xb8, 0xb7, 0xb9,
+  0x34, 0xba, 0xb4, 0x37, 0xb7, 0x21, 0x10, 0x54, 0x5c, 0xd4, 0x55, 0x5d,
+  0xd6, 0x05, 0x5d, 0xd1, 0x75, 0x5d, 0x18, 0xa5, 0xb0, 0x34, 0x39, 0x17,
+  0x33, 0xb9, 0xb0, 0xb3, 0xb6, 0x32, 0x37, 0xba, 0xaf, 0x34, 0x37, 0xb8,
+  0x3a, 0x3a, 0x5a, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64,
+  0x28, 0x35, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66,
+  0x29, 0x7c, 0xc2, 0xd2, 0xe4, 0x5c, 0xe0, 0xca, 0xe4, 0xe6, 0xe0, 0xca,
+  0xc6, 0xe8, 0xd2, 0xec, 0xca, 0x58, 0x8c, 0xbd, 0xb1, 0xbd, 0xc9, 0x0d,
+  0x91, 0x20, 0xe2, 0xd2, 0xae, 0xed, 0xaa, 0x2e, 0xee, 0x82, 0xae, 0xe8,
+  0xba, 0xae, 0x8e, 0xd9, 0x59, 0x99, 0x5b, 0x99, 0x5c, 0x18, 0x5d, 0x19,
+  0x19, 0x0a, 0x0e, 0x5d, 0x19, 0xde, 0xd8, 0xdb, 0x9b, 0x1c, 0x19, 0x91,
+  0x9d, 0xcc, 0x97, 0x59, 0x0a, 0x0d, 0x33, 0xb6, 0xb7, 0x30, 0x3a, 0x19,
+  0x22, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x43, 0x24, 0xe8,
+  0xb8, 0xb4, 0xeb, 0xbb, 0xaa, 0x8b, 0xbb, 0xa0, 0x0b, 0x0c, 0xae, 0xeb,
+  0x0a, 0x03, 0x2a, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65,
+  0x72, 0x7c, 0xc2, 0xd2, 0xe4, 0x5c, 0xc4, 0xea, 0xcc, 0xcc, 0xca, 0xe4,
+  0xbe, 0xe6, 0xd2, 0xf4, 0xca, 0x28, 0x85, 0xa5, 0xc9, 0xb9, 0xb0, 0xbd,
+  0x8d, 0x85, 0xd1, 0xa5, 0xbd, 0xb9, 0x7d, 0xa5, 0xb9, 0x91, 0x95, 0xe1,
+  0x11, 0x09, 0x4b, 0x93, 0x73, 0x91, 0x2b, 0x0b, 0x23, 0x23, 0x15, 0x96,
+  0x26, 0xe7, 0x32, 0x47, 0x27, 0x57, 0x37, 0x46, 0xf7, 0x45, 0x97, 0x07,
+  0x57, 0xf6, 0x95, 0xe6, 0x66, 0xf6, 0x46, 0xc3, 0x8c, 0xed, 0x2d, 0x8c,
+  0x6e, 0x86, 0xc6, 0x9b, 0x99, 0xd9, 0x5c, 0x19, 0x1d, 0x0d, 0xa9, 0xb1,
+  0xb7, 0x32, 0x33, 0x33, 0x1a, 0x47, 0x63, 0x6f, 0x65, 0x66, 0x66, 0x34,
+  0x84, 0xc6, 0xde, 0xca, 0xcc, 0xcc, 0x86, 0xa0, 0x01, 0x54, 0x40, 0x06,
+  0x54, 0x5c, 0x68, 0x70, 0xa5, 0x01, 0x64, 0x40, 0x06, 0x54, 0x5c, 0x68,
+  0x70, 0xa9, 0x01, 0xc4, 0x40, 0x06, 0x54, 0x5c, 0x68, 0x70, 0xad, 0x01,
+  0xd4, 0x40, 0x06, 0x54, 0x5c, 0x68, 0x70, 0xb1, 0x01, 0xa3, 0xb0, 0x34,
+  0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0xaf, 0xb9,
+  0x34, 0xbd, 0x32, 0x5e, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f,
+  0x74, 0x79, 0x70, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73,
+  0x69, 0x7a, 0x65, 0x4c, 0xb2, 0xaa, 0xac, 0x88, 0xca, 0xc6, 0xde, 0xc8,
+  0xca, 0x68, 0x90, 0x95, 0x8d, 0xbd, 0x91, 0x95, 0x0d, 0x21, 0x03, 0x68,
+  0xb9, 0xc6, 0xe0, 0x22, 0x03, 0x28, 0xb9, 0xca, 0x00, 0x22, 0x20, 0xe2,
+  0x32, 0x83, 0xeb, 0x0c, 0xae, 0x36, 0xb8, 0xdc, 0x00, 0x4a, 0xae, 0x37,
+  0x80, 0x8c, 0x0b, 0xba, 0xe0, 0xe0, 0xba, 0xae, 0x38, 0xe0, 0x12, 0x96,
+  0x26, 0xe7, 0x42, 0x57, 0x86, 0x47, 0x57, 0x27, 0x57, 0x46, 0x25, 0x2c,
+  0x4d, 0xce, 0x65, 0x2e, 0xac, 0x0d, 0x8e, 0xad, 0x8c, 0x18, 0x5d, 0x19,
+  0x1e, 0x5d, 0x9d, 0x5c, 0x99, 0x0c, 0x19, 0x8f, 0x19, 0xdb, 0x5b, 0x18,
+  0x1d, 0x0b, 0xc8, 0x5c, 0x58, 0x1b, 0x1c, 0x5b, 0x99, 0x0f, 0x09, 0xba,
+  0x32, 0xbc, 0xac, 0x21, 0x14, 0x84, 0x5c, 0x73, 0x70, 0x95, 0x01, 0x54,
+  0x40, 0xc4, 0x45, 0x07, 0x17, 0x74, 0xd5, 0xc1, 0x75, 0x5d, 0x76, 0x40,
+  0x8f, 0xae, 0x0c, 0x8f, 0xae, 0x4e, 0xae, 0x4c, 0x86, 0xec, 0x2b, 0x4c,
+  0x4e, 0x2e, 0x2c, 0x8f, 0xc7, 0x8c, 0xed, 0x2d, 0x8c, 0x8e, 0x05, 0x64,
+  0x2e, 0xac, 0x0d, 0x8e, 0xad, 0xcc, 0x87, 0x05, 0x5d, 0x19, 0x5e, 0x95,
+  0xd5, 0x10, 0x0a, 0x72, 0xae, 0x39, 0xb8, 0xca, 0x00, 0x22, 0x20, 0xe2,
+  0xa2, 0x83, 0x0b, 0xba, 0xf0, 0xe0, 0xba, 0xae, 0x3c, 0xe0, 0x12, 0x96,
+  0x26, 0xe7, 0x32, 0x17, 0xd6, 0x06, 0xc7, 0x56, 0x26, 0xc7, 0x63, 0x2e,
+  0xac, 0x0d, 0x8e, 0xad, 0x4c, 0x8e, 0xc1, 0xdc, 0x10, 0x09, 0x7a, 0xae,
+  0x3d, 0xb8, 0xca, 0x00, 0x2a, 0x20, 0xe2, 0x82, 0x2e, 0x3e, 0xb8, 0xae,
+  0xab, 0x0f, 0x86, 0x38, 0x57, 0x76, 0x79, 0x97, 0x18, 0x5c, 0x72, 0x70,
+  0xdd, 0xc1, 0xa5, 0x07, 0x97, 0x1f, 0x0c, 0x31, 0x1a, 0xe0, 0x9a, 0xae,
+  0x3f, 0x18, 0x11, 0xb1, 0x03, 0x3b, 0xd8, 0x43, 0x3b, 0xb8, 0x41, 0x3b,
+  0xbc, 0x03, 0x39, 0xd4, 0x03, 0x3b, 0x94, 0x83, 0x1b, 0x98, 0x03, 0x3b,
+  0x84, 0xc3, 0x39, 0xcc, 0xc3, 0x14, 0x21, 0x18, 0x46, 0x28, 0xec, 0xc0,
+  0x0e, 0xf6, 0xd0, 0x0e, 0x6e, 0x90, 0x0e, 0xe4, 0x50, 0x0e, 0xee, 0x40,
+  0x0f, 0x53, 0x82, 0x62, 0xc4, 0x12, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0x60,
+  0x0f, 0xe5, 0x20, 0x0f, 0xf3, 0x90, 0x0e, 0xef, 0xe0, 0x0e, 0x53, 0x02,
+  0x63, 0x04, 0x15, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0xc0, 0x0e, 0xe1, 0xe0,
+  0x0e, 0xe7, 0x50, 0x0f, 0xe1, 0x70, 0x0e, 0xe5, 0xf0, 0x0b, 0xf6, 0x50,
+  0x0e, 0xf2, 0x30, 0x0f, 0xe9, 0xf0, 0x0e, 0xee, 0x30, 0x25, 0x40, 0x46,
+  0x4c, 0xe1, 0x90, 0x0e, 0xf2, 0xe0, 0x06, 0xe3, 0xf0, 0x0e, 0xed, 0x00,
+  0x0f, 0xe9, 0xc0, 0x0e, 0xe5, 0xf0, 0x0b, 0xef, 0x00, 0x0f, 0xf4, 0x90,
+  0x0e, 0xef, 0xe0, 0x0e, 0xf3, 0x30, 0x65, 0x50, 0x18, 0x67, 0x04, 0x13,
+  0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0x60, 0x0e, 0xf2, 0x10, 0x0e, 0xe7, 0xd0,
+  0x0e, 0xe5, 0xe0, 0x0e, 0xf4, 0x30, 0x25, 0x00, 0x05, 0x00, 0x79, 0x18,
+  0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1,
+  0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42,
+  0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f,
+  0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1,
+  0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84,
+  0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc,
+  0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70,
+  0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19,
+  0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f,
+  0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21,
+  0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc,
+  0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84,
+  0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37,
+  0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70,
+  0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77,
+  0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79,
+  0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e,
+  0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1,
+  0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81,
+  0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98,
+  0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88,
+  0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4,
+  0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72,
+  0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74,
+  0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e,
+  0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e,
+  0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21,
+  0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01,
+  0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc,
+  0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77,
+  0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e,
+  0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1,
+  0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61,
+  0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0,
+  0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0,
+  0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74,
+  0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e,
+  0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41,
+  0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50,
+  0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c,
+  0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc,
+  0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20, 0x00, 0x00, 0x14, 0x00,
+  0x00, 0x00, 0x26, 0x10, 0x06, 0x00, 0x12, 0xf9, 0x12, 0xc0, 0x3c, 0x0b,
+  0xf1, 0x4f, 0xc4, 0x35, 0x51, 0x11, 0xf1, 0xdb, 0xc3, 0x0f, 0x44, 0x11,
+  0x80, 0xf9, 0x15, 0x5e, 0xdc, 0xb6, 0x05, 0x34, 0x00, 0x12, 0xf9, 0x83,
+  0x33, 0xf9, 0xd5, 0x5d, 0xdc, 0xb6, 0x0d, 0x6c, 0x00, 0x12, 0xf9, 0x12,
+  0xc0, 0x3c, 0x0b, 0xf1, 0x4f, 0xc4, 0x35, 0x51, 0x11, 0xf1, 0xdb, 0x83,
+  0x5f, 0xe1, 0xc5, 0x6d, 0x1b, 0x00, 0xc4, 0x76, 0xe5, 0x2f, 0xbb, 0xef,
+  0x5f, 0x44, 0x80, 0xc1, 0x10, 0xcd, 0x04, 0x00, 0x00, 0x00, 0x61, 0x20,
+  0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00,
+  0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0xb4, 0x47, 0x00, 0x28, 0xcf, 0x31,
+  0x14, 0x5d, 0x37, 0xd6, 0x00, 0x04, 0x02, 0xc9, 0x11, 0x00, 0x8a, 0x23,
+  0x00, 0x04, 0x67, 0x00, 0x28, 0xd6, 0x00, 0x85, 0x39, 0x08, 0x31, 0x10,
+  0x03, 0x31, 0x08, 0x83, 0x19, 0x00, 0x02, 0x63, 0x04, 0x20, 0x08, 0x82,
+  0xf8, 0x37, 0x03, 0x30, 0x02, 0x00, 0x23, 0x06, 0xca, 0x10, 0x84, 0xc1,
+  0xd3, 0x44, 0x46, 0x82, 0x04, 0x83, 0x0c, 0x41, 0xc1, 0x8c, 0x18, 0x2c,
+  0x43, 0x40, 0x06, 0xd0, 0x33, 0x85, 0x01, 0xb2, 0x28, 0xc3, 0x18, 0x42,
+  0x20, 0x06, 0x73, 0x0c, 0x43, 0x40, 0x06, 0x23, 0x06, 0xcb, 0x10, 0x9c,
+  0xc1, 0x24, 0x59, 0x65, 0xb0, 0x38, 0x8d, 0x31, 0x86, 0x10, 0x94, 0xc1,
+  0x1c, 0xc3, 0x10, 0x90, 0xc1, 0x61, 0x7a, 0x29, 0x28, 0x83, 0x0c, 0x81,
+  0x43, 0x19, 0x11, 0xc0, 0x67, 0xbc, 0x81, 0xc3, 0xd8, 0xe0, 0x02, 0xbd,
+  0x14, 0x94, 0x41, 0x86, 0x60, 0xca, 0x46, 0x0c, 0x0a, 0x21, 0x98, 0x83,
+  0x22, 0x18, 0x6f, 0x08, 0x83, 0xce, 0x0d, 0x2e, 0xd0, 0x4b, 0x41, 0x19,
+  0x64, 0x08, 0x30, 0x6f, 0xc4, 0xa0, 0x10, 0x02, 0x3c, 0x50, 0x82, 0xf1,
+  0x06, 0x33, 0x10, 0x83, 0x37, 0xb8, 0x40, 0x2f, 0x05, 0x65, 0x90, 0x21,
+  0xe8, 0xc6, 0x60, 0xc4, 0xa0, 0x10, 0x82, 0x3e, 0x78, 0x82, 0x39, 0x06,
+  0x30, 0x58, 0xf4, 0x60, 0x8e, 0x21, 0x38, 0xf8, 0x60, 0x8e, 0x21, 0x18,
+  0xf4, 0xc0, 0x02, 0x38, 0x90, 0x4f, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00,
+  0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x5c, 0x0c, 0x00, 0x00, 0xff, 0xff,
+  0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0x14, 0x03,
+  0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00,
+  0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10,
+  0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04,
+  0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10,
+  0x32, 0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a,
+  0x90, 0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07,
+  0xc8, 0x48, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00,
+  0x00, 0x00, 0x51, 0x18, 0x00, 0x00, 0x90, 0x00, 0x00, 0x00, 0x1b, 0xcc,
+  0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x60, 0x00, 0x09, 0xa8, 0x88,
+  0x71, 0x78, 0x07, 0x79, 0x90, 0x87, 0x72, 0x18, 0x07, 0x7a, 0x60, 0x87,
+  0x7c, 0x68, 0x03, 0x79, 0x78, 0x87, 0x7a, 0x70, 0x07, 0x72, 0x28, 0x07,
+  0x72, 0x68, 0x03, 0x72, 0x48, 0x07, 0x7b, 0x48, 0x07, 0x72, 0x28, 0x87,
+  0x36, 0x98, 0x87, 0x78, 0x90, 0x07, 0x7a, 0x68, 0x03, 0x73, 0x80, 0x87,
+  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xcc, 0x21, 0x1c, 0xd8,
+  0x61, 0x1e, 0xca, 0x01, 0x20, 0xc8, 0x21, 0x1d, 0xe6, 0x21, 0x1c, 0xc4,
+  0x81, 0x1d, 0xca, 0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xd2, 0x81, 0x1d, 0xda,
+  0x60, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0x61, 0x1e, 0x00, 0x73, 0x08, 0x07,
+  0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x76, 0x28, 0x87, 0x79, 0x98, 0x87,
+  0x36, 0x80, 0x07, 0x79, 0x28, 0x87, 0x71, 0x48, 0x87, 0x79, 0x28, 0x87,
+  0x36, 0x30, 0x07, 0x78, 0x68, 0x87, 0x70, 0x20, 0x07, 0xc0, 0x1c, 0xc2,
+  0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xcc,
+  0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca, 0xa1, 0x0d, 0xe0, 0xe1, 0x1d, 0xd2,
+  0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xca, 0x81, 0x1d, 0xd2,
+  0xa1, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x60, 0x70, 0x87,
+  0x77, 0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03,
+  0x78, 0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83,
+  0x72, 0x60, 0x87, 0x74, 0x68, 0x87, 0x36, 0x70, 0x87, 0x77, 0x70, 0x87,
+  0x36, 0x60, 0x87, 0x72, 0x08, 0x07, 0x73, 0x00, 0x08, 0x77, 0x78, 0x87,
+  0x36, 0x48, 0x07, 0x77, 0x30, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87,
+  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea,
+  0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xd4, 0xa1, 0x1e, 0xda,
+  0x01, 0x1e, 0xda, 0x80, 0x1e, 0xc2, 0x41, 0x1c, 0xd8, 0xa1, 0x1c, 0xe6,
+  0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x70, 0x87,
+  0x77, 0x68, 0x03, 0x77, 0x08, 0x07, 0x77, 0x98, 0x87, 0x36, 0x30, 0x07,
+  0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4,
+  0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x60, 0x1e, 0xd2,
+  0xe1, 0x1c, 0xdc, 0xa1, 0x1c, 0xc8, 0xa1, 0x0d, 0xf4, 0xa1, 0x1c, 0xe4,
+  0xe1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2,
+  0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08,
+  0x77, 0x78, 0x87, 0x36, 0xa0, 0x07, 0x79, 0x08, 0x07, 0x78, 0x80, 0x87,
+  0x74, 0x70, 0x87, 0x73, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07,
+  0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xe6, 0x81, 0x1e, 0xc2,
+  0x61, 0x1c, 0xd6, 0xa1, 0x0d, 0xe0, 0x41, 0x1e, 0xde, 0x81, 0x1e, 0xca,
+  0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0xa1, 0x0d, 0xc4, 0xa1, 0x1e, 0xcc,
+  0xc1, 0x1c, 0xca, 0x41, 0x1e, 0xda, 0x60, 0x1e, 0xd2, 0x41, 0x1f, 0xca,
+  0x01, 0xc0, 0x03, 0x80, 0xa8, 0x07, 0x77, 0x98, 0x87, 0x70, 0x30, 0x87,
+  0x72, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07,
+  0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xa2, 0x1e, 0xe6,
+  0xa1, 0x1c, 0xda, 0x60, 0x1e, 0xde, 0xc1, 0x1c, 0xe8, 0xa1, 0x0d, 0xcc,
+  0x81, 0x1d, 0xde, 0x21, 0x1c, 0xe8, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87,
+  0x79, 0x28, 0x07, 0x60, 0x03, 0x22, 0x10, 0x40, 0x02, 0x2c, 0x40, 0xb5,
+  0xc1, 0x18, 0x0a, 0x60, 0x01, 0xaa, 0x0d, 0x06, 0x61, 0x00, 0x0b, 0x50,
+  0x6d, 0x30, 0x8a, 0x03, 0x58, 0x80, 0x6a, 0x83, 0x61, 0xfc, 0xff, 0xff,
+  0xff, 0xff, 0x00, 0x48, 0x00, 0xb5, 0x01, 0x39, 0xfe, 0xff, 0xff, 0xff,
+  0x7f, 0x00, 0x18, 0x40, 0x02, 0xaa, 0x0d, 0x06, 0x12, 0x00, 0x0b, 0x50,
+  0x6d, 0x30, 0x12, 0x01, 0x58, 0x80, 0x0a, 0x00, 0x00, 0x00, 0x49, 0x18,
+  0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x13, 0x8a, 0x40, 0x18, 0x88, 0x62,
+  0x42, 0x60, 0x4c, 0x18, 0x0e, 0x24, 0x01, 0x00, 0x00, 0x00, 0x89, 0x20,
+  0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09, 0x20, 0x64,
+  0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1,
+  0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x68,
+  0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00, 0xc3, 0x08, 0x03,
+  0x70, 0x90, 0x34, 0x45, 0x94, 0x30, 0xf9, 0xb2, 0xfb, 0x76, 0x84, 0xe0,
+  0x0c, 0x04, 0x22, 0xc6, 0x18, 0x63, 0x10, 0x81, 0x10, 0x8e, 0x92, 0xa6,
+  0x88, 0x12, 0x26, 0xff, 0x9f, 0x88, 0x6b, 0xa2, 0x22, 0xe2, 0xb7, 0x87,
+  0x7f, 0x1a, 0x23, 0x00, 0x06, 0x11, 0x8c, 0xe0, 0x22, 0x69, 0x8a, 0x28,
+  0x61, 0xf2, 0x7f, 0x09, 0x60, 0x9e, 0x85, 0x88, 0xfe, 0x69, 0x8c, 0x00,
+  0x18, 0x44, 0x40, 0x84, 0x82, 0x84, 0x10, 0x44, 0x39, 0x27, 0x91, 0x2a,
+  0x03, 0x18, 0x83, 0xd8, 0x1c, 0x41, 0x30, 0x47, 0x00, 0x06, 0xc3, 0x08,
+  0xc2, 0x53, 0x90, 0x70, 0x92, 0x70, 0xd0, 0x01, 0x8a, 0x03, 0x01, 0x29,
+  0xf0, 0x86, 0x11, 0x86, 0x67, 0x10, 0x21, 0x10, 0xe6, 0x08, 0x40, 0x61,
+  0x10, 0x61, 0x10, 0x46, 0x00, 0x00, 0x13, 0xa8, 0x70, 0x48, 0x07, 0x79,
+  0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72,
+  0x68, 0x83, 0x74, 0x78, 0x87, 0x79, 0xc8, 0x03, 0x37, 0x80, 0x03, 0x37,
+  0x80, 0x83, 0x0d, 0xb7, 0x51, 0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07,
+  0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06,
+  0xe9, 0x10, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e,
+  0x78, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07,
+  0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06,
+  0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
+  0x72, 0xd0, 0x06, 0xe9, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
+  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07,
+  0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06,
+  0xf6, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07,
+  0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x73, 0x20, 0x07,
+  0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07,
+  0x78, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06,
+  0xf6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07,
+  0x74, 0xd0, 0x06, 0xf6, 0x90, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x20, 0x07,
+  0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07,
+  0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07,
+  0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x90, 0x07, 0x72, 0xa0, 0x07,
+  0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06,
+  0xf6, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07,
+  0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07,
+  0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07,
+  0x72, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07,
+  0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07,
+  0x74, 0xd0, 0x06, 0xee, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x43, 0x98, 0x05, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x80, 0x21, 0x4c, 0x03, 0x04, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0xc0, 0x10, 0x46, 0x02, 0x02, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20,
+  0x0b, 0x04, 0x0b, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x14, 0x19, 0x11,
+  0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x7a, 0x25, 0x30,
+  0x02, 0x50, 0x20, 0x45, 0x50, 0x08, 0x05, 0x18, 0x50, 0x10, 0x65, 0x50,
+  0x40, 0x05, 0x56, 0x0a, 0xc5, 0x40, 0x74, 0x2c, 0xc1, 0x21, 0x00, 0x00,
+  0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x0c, 0x01, 0x00, 0x00, 0x1a, 0x03,
+  0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4,
+  0x37, 0xb7, 0x21, 0xc6, 0x63, 0x4c, 0x00, 0xf5, 0x50, 0xb9, 0x1b, 0x43,
+  0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b, 0x62, 0x3c, 0xc3, 0x24,
+  0x3c, 0x07, 0xe1, 0x20, 0x08, 0x0e, 0x8e, 0xad, 0x0c, 0x84, 0x89, 0xc9,
+  0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x26,
+  0x06, 0x06, 0x26, 0xc6, 0xa5, 0x06, 0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e,
+  0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26, 0x06, 0x06, 0x26, 0xc6, 0xa5, 0x06,
+  0xc6, 0x25, 0x26, 0x65, 0x88, 0x30, 0x11, 0x43, 0x8c, 0x67, 0x78, 0x92,
+  0x87, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36, 0x04, 0x99, 0x8e, 0x67,
+  0x78, 0x86, 0x87, 0xe0, 0x16, 0x96, 0x26, 0xe7, 0x32, 0xf6, 0xd6, 0x06,
+  0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6, 0x26, 0xd7, 0x36, 0xf7,
+  0x45, 0x96, 0x36, 0x17, 0x26, 0xc6, 0x56, 0x36, 0x44, 0x98, 0x12, 0x72,
+  0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e,
+  0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e,
+  0x61, 0x62, 0x6c, 0x65, 0x43, 0x84, 0x69, 0x21, 0x19, 0x84, 0xa5, 0xc9,
+  0xb9, 0x8c, 0xbd, 0xb5, 0xc1, 0xa5, 0xb1, 0x95, 0xb9, 0x98, 0xc9, 0x85,
+  0xb5, 0x95, 0x89, 0xd5, 0x99, 0x99, 0x95, 0xc9, 0x7d, 0x99, 0x95, 0xd1,
+  0x8d, 0xa1, 0x7d, 0x95, 0xb9, 0x85, 0x89, 0xb1, 0x95, 0x0d, 0x11, 0xa6,
+  0x86, 0x51, 0x58, 0x9a, 0x9c, 0x8b, 0x5c, 0x99, 0x1b, 0x59, 0x99, 0xdc,
+  0x17, 0x5d, 0x98, 0xdc, 0x59, 0x19, 0x1d, 0xa3, 0xb0, 0x34, 0x39, 0x97,
+  0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0x2f, 0xb7, 0xb0, 0xb6,
+  0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x43, 0x90, 0xe9, 0x79,
+  0x88, 0x09, 0x9a, 0xa2, 0x21, 0xc2, 0x24, 0x91, 0x09, 0x4b, 0x93, 0x73,
+  0x81, 0x7b, 0x9b, 0x4b, 0xa3, 0x4b, 0x7b, 0x73, 0xa3, 0x12, 0x96, 0x26,
+  0xe7, 0x32, 0x56, 0xe6, 0x46, 0x57, 0x26, 0x47, 0x29, 0x2c, 0x4d, 0xce,
+  0xc5, 0xed, 0xed, 0x0b, 0xae, 0x4c, 0x6e, 0x0e, 0xae, 0x6c, 0x8c, 0x2e,
+  0xcd, 0xae, 0x8c, 0x4c, 0x58, 0x9a, 0x9c, 0x4b, 0x98, 0xdc, 0xd9, 0x97,
+  0x5b, 0x58, 0x5b, 0x19, 0x11, 0xb8, 0xb7, 0xb9, 0x34, 0xba, 0xb4, 0x37,
+  0xb7, 0x21, 0xd0, 0x43, 0x4c, 0xd4, 0x54, 0x4d, 0xd6, 0x04, 0x4d, 0xd1,
+  0x74, 0x4d, 0x18, 0xa5, 0xb0, 0x34, 0x39, 0x17, 0x33, 0xb9, 0xb0, 0xb3,
+  0xb6, 0x32, 0x37, 0xba, 0xaf, 0x34, 0x37, 0xb8, 0x3a, 0x3a, 0x5a, 0x67,
+  0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x35, 0x63, 0x6f,
+  0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66, 0x29, 0x7c, 0xc2, 0xd2,
+  0xe4, 0x5c, 0xe0, 0xca, 0xe4, 0xe6, 0xe0, 0xca, 0xc6, 0xe8, 0xd2, 0xec,
+  0xca, 0x58, 0x8c, 0xbd, 0xb1, 0xbd, 0xc9, 0x0d, 0x91, 0x9e, 0x61, 0xd2,
+  0xa6, 0x6d, 0xaa, 0x26, 0x6e, 0x82, 0xa6, 0x68, 0xba, 0xa6, 0x8e, 0xd9,
+  0x59, 0x99, 0x5b, 0x99, 0x5c, 0x18, 0x5d, 0x19, 0x19, 0x0a, 0x0e, 0x5d,
+  0x19, 0xde, 0xd8, 0xdb, 0x9b, 0x1c, 0x19, 0x91, 0x9d, 0xcc, 0x97, 0x59,
+  0x0a, 0x0d, 0x33, 0xb6, 0xb7, 0x30, 0x3a, 0x19, 0x22, 0x74, 0x65, 0x78,
+  0x63, 0x6f, 0x6f, 0x72, 0x64, 0x43, 0xa4, 0xc7, 0x98, 0xb4, 0xe9, 0x9b,
+  0xaa, 0x89, 0x9b, 0xa0, 0x09, 0x0c, 0xa6, 0x6b, 0x0a, 0x03, 0x2a, 0x61,
+  0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x7c, 0xc2, 0xd2,
+  0xe4, 0x5c, 0xc4, 0xea, 0xcc, 0xcc, 0xca, 0xe4, 0xbe, 0xe6, 0xd2, 0xf4,
+  0xca, 0x28, 0x85, 0xa5, 0xc9, 0xb9, 0xb0, 0xbd, 0x8d, 0x85, 0xd1, 0xa5,
+  0xbd, 0xb9, 0x7d, 0xa5, 0xb9, 0x91, 0x95, 0xe1, 0x11, 0x09, 0x4b, 0x93,
+  0x73, 0x91, 0x2b, 0x0b, 0x23, 0x23, 0x15, 0x96, 0x26, 0xe7, 0x32, 0x47,
+  0x27, 0x57, 0x37, 0x46, 0xf7, 0x45, 0x97, 0x07, 0x57, 0xf6, 0x95, 0xe6,
+  0x66, 0xf6, 0x46, 0xc3, 0x8c, 0xed, 0x2d, 0x8c, 0x6e, 0x86, 0xc6, 0x9b,
+  0x99, 0xd9, 0x5c, 0x19, 0x1d, 0x0d, 0xa9, 0xb1, 0xb7, 0x32, 0x33, 0x33,
+  0x1a, 0x47, 0x63, 0x6f, 0x65, 0x66, 0x66, 0x34, 0x84, 0xc6, 0xde, 0xca,
+  0xcc, 0xcc, 0x86, 0xa0, 0xc1, 0x43, 0x3c, 0xc5, 0x43, 0x4c, 0x68, 0x30,
+  0xa5, 0xc1, 0x53, 0x3c, 0xc5, 0x43, 0x4c, 0x68, 0x30, 0xa9, 0xc1, 0xb3,
+  0x3c, 0xc5, 0x43, 0x4c, 0x68, 0x30, 0xad, 0xc1, 0xc3, 0x3c, 0xc5, 0x43,
+  0x4c, 0x68, 0x30, 0xb1, 0x01, 0xa3, 0xb0, 0x34, 0x39, 0x97, 0x30, 0xb9,
+  0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0xaf, 0xb9, 0x34, 0xbd, 0x32, 0x5e,
+  0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65,
+  0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x4c,
+  0xb2, 0xaa, 0xac, 0x88, 0xca, 0xc6, 0xde, 0xc8, 0xca, 0x68, 0x90, 0x95,
+  0x8d, 0xbd, 0x91, 0x95, 0x0d, 0x21, 0x83, 0x47, 0x99, 0xc6, 0x60, 0x22,
+  0x83, 0x07, 0x99, 0xca, 0xe0, 0x19, 0x9e, 0x61, 0x32, 0x83, 0xe9, 0x0c,
+  0xa6, 0x36, 0x98, 0xdc, 0xe0, 0x41, 0xa6, 0x37, 0x78, 0x8a, 0x09, 0x9a,
+  0xe0, 0x60, 0xba, 0xa6, 0x38, 0xe0, 0x12, 0x96, 0x26, 0xe7, 0x42, 0x57,
+  0x86, 0x47, 0x57, 0x27, 0x57, 0x46, 0x25, 0x2c, 0x4d, 0xce, 0x65, 0x2e,
+  0xac, 0x0d, 0x8e, 0xad, 0x8c, 0x18, 0x5d, 0x19, 0x1e, 0x5d, 0x9d, 0x5c,
+  0x99, 0x0c, 0x19, 0x8f, 0x19, 0xdb, 0x5b, 0x18, 0x1d, 0x0b, 0xc8, 0x5c,
+  0x58, 0x1b, 0x1c, 0x5b, 0x99, 0x0f, 0x09, 0xba, 0x32, 0xbc, 0xac, 0x21,
+  0xd4, 0x73, 0x4c, 0x73, 0x30, 0x95, 0xc1, 0x43, 0x3c, 0xc3, 0x44, 0x07,
+  0x13, 0x34, 0xd5, 0xc1, 0x74, 0x4d, 0x76, 0xc0, 0x82, 0xae, 0x0c, 0xaf,
+  0xca, 0x6a, 0x08, 0xf5, 0x34, 0xd3, 0x1c, 0x4c, 0x65, 0xf0, 0x0c, 0xcf,
+  0x30, 0xd1, 0xc1, 0x04, 0x4d, 0x75, 0x30, 0x5d, 0x13, 0x1e, 0x70, 0x09,
+  0x4b, 0x93, 0x73, 0x99, 0x0b, 0x6b, 0x83, 0x63, 0x2b, 0x93, 0xe3, 0x31,
+  0x17, 0xd6, 0x06, 0xc7, 0x56, 0x26, 0xc7, 0x60, 0x6e, 0x88, 0xf4, 0x38,
+  0x93, 0x1e, 0x4c, 0x65, 0xf0, 0x10, 0xcf, 0x30, 0x41, 0xd3, 0x1e, 0x4c,
+  0xd7, 0xc4, 0x07, 0x43, 0x9c, 0x29, 0x9b, 0xbc, 0x49, 0x0c, 0x26, 0x39,
+  0x98, 0xee, 0x60, 0xca, 0x83, 0xa9, 0x0f, 0x86, 0x18, 0x0b, 0x30, 0x4d,
+  0x93, 0x1f, 0x8c, 0x88, 0xd8, 0x81, 0x1d, 0xec, 0xa1, 0x1d, 0xdc, 0xa0,
+  0x1d, 0xde, 0x81, 0x1c, 0xea, 0x81, 0x1d, 0xca, 0xc1, 0x0d, 0xcc, 0x81,
+  0x1d, 0xc2, 0xe1, 0x1c, 0xe6, 0x61, 0x8a, 0x10, 0x0c, 0x23, 0x14, 0x76,
+  0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x48, 0x07, 0x72, 0x28, 0x07, 0x77,
+  0xa0, 0x87, 0x29, 0x41, 0x31, 0x62, 0x09, 0x87, 0x74, 0x90, 0x07, 0x37,
+  0xb0, 0x87, 0x72, 0x90, 0x87, 0x79, 0x48, 0x87, 0x77, 0x70, 0x87, 0x29,
+  0x81, 0x31, 0x82, 0x0a, 0x87, 0x74, 0x90, 0x07, 0x37, 0x60, 0x87, 0x70,
+  0x70, 0x87, 0x73, 0xa8, 0x87, 0x70, 0x38, 0x87, 0x72, 0xf8, 0x05, 0x7b,
+  0x28, 0x07, 0x79, 0x98, 0x87, 0x74, 0x78, 0x07, 0x77, 0x98, 0x12, 0x20,
+  0x23, 0xa6, 0x70, 0x48, 0x07, 0x79, 0x70, 0x83, 0x71, 0x78, 0x87, 0x76,
+  0x80, 0x87, 0x74, 0x60, 0x87, 0x72, 0xf8, 0x85, 0x77, 0x80, 0x07, 0x7a,
+  0x48, 0x87, 0x77, 0x70, 0x87, 0x79, 0x98, 0x32, 0x28, 0x8c, 0x33, 0x82,
+  0x09, 0x87, 0x74, 0x90, 0x07, 0x37, 0x30, 0x07, 0x79, 0x08, 0x87, 0x73,
+  0x68, 0x87, 0x72, 0x70, 0x07, 0x7a, 0x98, 0x12, 0xfc, 0x01, 0x00, 0x00,
+  0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08,
+  0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38,
+  0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71,
+  0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c,
+  0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d,
+  0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d,
+  0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07,
+  0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87,
+  0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30,
+  0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10,
+  0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66,
+  0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c,
+  0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07,
+  0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87,
+  0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05,
+  0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87,
+  0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0,
+  0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4,
+  0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca,
+  0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39,
+  0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38,
+  0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c,
+  0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87,
+  0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87,
+  0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00,
+  0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20,
+  0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2,
+  0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4,
+  0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a,
+  0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07,
+  0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90,
+  0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8,
+  0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc,
+  0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b,
+  0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b,
+  0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87,
+  0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81,
+  0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30,
+  0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde,
+  0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39,
+  0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f,
+  0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20,
+  0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x16, 0xd0, 0x00, 0x48, 0xe4, 0x0f,
+  0xce, 0xe4, 0x57, 0x77, 0x71, 0xdb, 0x26, 0xb0, 0x01, 0x48, 0xe4, 0x4b,
+  0x00, 0xf3, 0x2c, 0xc4, 0x3f, 0x11, 0xd7, 0x44, 0x45, 0xc4, 0x6f, 0x0f,
+  0x7e, 0x85, 0x17, 0xb7, 0x6d, 0x00, 0x11, 0xdb, 0x95, 0xff, 0xf9, 0xd6,
+  0xf6, 0x5f, 0x44, 0x80, 0xc1, 0x10, 0xcd, 0x04, 0x00, 0x00, 0x61, 0x20,
+  0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00,
+  0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x74, 0x47, 0x00, 0xa8, 0x8e, 0x35,
+  0x00, 0x03, 0x31, 0xc7, 0x40, 0x0c, 0xde, 0x1c, 0x03, 0xe1, 0x79, 0x63,
+  0x0d, 0x40, 0x20, 0x90, 0xab, 0x81, 0x11, 0x00, 0x7a, 0x33, 0x00, 0x04,
+  0x47, 0x00, 0x28, 0xcc, 0x41, 0x90, 0x01, 0x19, 0x90, 0x81, 0x18, 0xcc,
+  0x00, 0x10, 0x18, 0x23, 0x00, 0x41, 0x10, 0xc4, 0xbf, 0x11, 0x80, 0x19,
+  0x00, 0x00, 0x23, 0x06, 0xca, 0x10, 0x8c, 0x41, 0xf4, 0x4c, 0x89, 0x81,
+  0x08, 0x83, 0x0c, 0x41, 0xc1, 0x8c, 0x18, 0x28, 0x43, 0x50, 0x06, 0x52,
+  0x54, 0x2d, 0x88, 0x42, 0x0c, 0x32, 0x04, 0xc7, 0x33, 0xc8, 0x30, 0x04,
+  0xd1, 0x5d, 0x76, 0x29, 0x28, 0x83, 0x0c, 0xc1, 0x12, 0x19, 0x11, 0xc0,
+  0x67, 0xbc, 0x61, 0xbb, 0xd6, 0xe0, 0x02, 0xbb, 0x14, 0x94, 0x41, 0x86,
+  0x00, 0xb2, 0x46, 0x0c, 0x0a, 0x21, 0x88, 0x83, 0x22, 0x18, 0x6f, 0x00,
+  0x03, 0xae, 0x0d, 0x2e, 0xb0, 0x4b, 0x41, 0x19, 0x64, 0x08, 0xaa, 0x6d,
+  0xc4, 0xa0, 0x10, 0x02, 0x3b, 0x50, 0x82, 0xf1, 0x86, 0x32, 0x08, 0x03,
+  0x37, 0xb8, 0xc0, 0x2e, 0x05, 0x65, 0x90, 0x21, 0xd0, 0xc0, 0x60, 0xc4,
+  0xa0, 0x10, 0x82, 0x3d, 0x78, 0x82, 0x39, 0x86, 0x6e, 0xc9, 0x83, 0x39,
+  0x86, 0xe0, 0xd8, 0x83, 0x39, 0x86, 0x60, 0xc8, 0x03, 0x0b, 0xde, 0x40,
+  0x3e, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0,
+  0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x68, 0x0c,
+  0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c,
+  0x00, 0x00, 0x17, 0x03, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00,
+  0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8,
+  0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05,
+  0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92,
+  0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32,
+  0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19,
+  0x21, 0x72, 0x24, 0x07, 0xc8, 0x48, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40,
+  0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00, 0x00, 0x90, 0x00,
+  0x00, 0x00, 0x1b, 0xcc, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x60,
+  0x00, 0x09, 0xa8, 0x88, 0x71, 0x78, 0x07, 0x79, 0x90, 0x87, 0x72, 0x18,
+  0x07, 0x7a, 0x60, 0x87, 0x7c, 0x68, 0x03, 0x79, 0x78, 0x87, 0x7a, 0x70,
+  0x07, 0x72, 0x28, 0x07, 0x72, 0x68, 0x03, 0x72, 0x48, 0x07, 0x7b, 0x48,
+  0x07, 0x72, 0x28, 0x87, 0x36, 0x98, 0x87, 0x78, 0x90, 0x07, 0x7a, 0x68,
+  0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00,
+  0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xc8, 0x21, 0x1d,
+  0xe6, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0xa1, 0x0d, 0xe8, 0x21, 0x1c,
+  0xd2, 0x81, 0x1d, 0xda, 0x60, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0x61, 0x1e,
+  0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x76, 0x28,
+  0x87, 0x79, 0x98, 0x87, 0x36, 0x80, 0x07, 0x79, 0x28, 0x87, 0x71, 0x48,
+  0x87, 0x79, 0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x87, 0x70, 0x20,
+  0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0xc2, 0x1d,
+  0xde, 0xa1, 0x0d, 0xcc, 0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca, 0xa1, 0x0d,
+  0xe0, 0xe1, 0x1d, 0xd2, 0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d,
+  0xca, 0x81, 0x1d, 0xd2, 0xa1, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28,
+  0x07, 0x60, 0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68,
+  0x87, 0x72, 0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28,
+  0x07, 0x79, 0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68, 0x87, 0x36, 0x70,
+  0x87, 0x77, 0x70, 0x87, 0x36, 0x60, 0x87, 0x72, 0x08, 0x07, 0x73, 0x00,
+  0x08, 0x77, 0x78, 0x87, 0x36, 0x48, 0x07, 0x77, 0x30, 0x87, 0x79, 0x68,
+  0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00,
+  0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d,
+  0xd4, 0xa1, 0x1e, 0xda, 0x01, 0x1e, 0xda, 0x80, 0x1e, 0xc2, 0x41, 0x1c,
+  0xd8, 0xa1, 0x1c, 0xe6, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28,
+  0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x77, 0x08, 0x07, 0x77, 0x98,
+  0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40,
+  0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0x60, 0x1e, 0xd2, 0xe1, 0x1c, 0xdc, 0xa1, 0x1c, 0xc8, 0xa1, 0x0d,
+  0xf4, 0xa1, 0x1c, 0xe4, 0xe1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e,
+  0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8,
+  0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0xa0, 0x07, 0x79, 0x08,
+  0x07, 0x78, 0x80, 0x87, 0x74, 0x70, 0x87, 0x73, 0x68, 0x83, 0x76, 0x08,
+  0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20,
+  0xe6, 0x81, 0x1e, 0xc2, 0x61, 0x1c, 0xd6, 0xa1, 0x0d, 0xe0, 0x41, 0x1e,
+  0xde, 0x81, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0xa1, 0x0d,
+  0xc4, 0xa1, 0x1e, 0xcc, 0xc1, 0x1c, 0xca, 0x41, 0x1e, 0xda, 0x60, 0x1e,
+  0xd2, 0x41, 0x1f, 0xca, 0x01, 0xc0, 0x03, 0x80, 0xa8, 0x07, 0x77, 0x98,
+  0x87, 0x70, 0x30, 0x87, 0x72, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68,
+  0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c,
+  0x00, 0xa2, 0x1e, 0xe6, 0xa1, 0x1c, 0xda, 0x60, 0x1e, 0xde, 0xc1, 0x1c,
+  0xe8, 0xa1, 0x0d, 0xcc, 0x81, 0x1d, 0xde, 0x21, 0x1c, 0xe8, 0x01, 0x30,
+  0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x60, 0x03, 0x22, 0x10, 0x40,
+  0x02, 0x2c, 0x40, 0xb5, 0xc1, 0x18, 0x0a, 0x60, 0x01, 0xaa, 0x0d, 0x06,
+  0x61, 0x00, 0x0b, 0x50, 0x6d, 0x30, 0x8a, 0x03, 0x58, 0x80, 0x6a, 0x83,
+  0x61, 0xfc, 0xff, 0xff, 0xff, 0xff, 0x00, 0x48, 0x00, 0xb5, 0x01, 0x39,
+  0xfe, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x18, 0x40, 0x02, 0xaa, 0x0d, 0x06,
+  0x12, 0x00, 0x0b, 0x50, 0x6d, 0x30, 0x12, 0x01, 0x58, 0x80, 0x0a, 0x00,
+  0x00, 0x00, 0x49, 0x18, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x13, 0x8a,
+  0x40, 0x18, 0x88, 0x62, 0x42, 0x60, 0x4c, 0x18, 0x0e, 0x24, 0x01, 0x00,
+  0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x32, 0x22,
+  0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93,
+  0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84,
+  0xa4, 0x4c, 0x10, 0x68, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20,
+  0x00, 0xc3, 0x08, 0x03, 0x70, 0x90, 0x34, 0x45, 0x94, 0x30, 0xf9, 0xb2,
+  0xfb, 0x76, 0x84, 0xe0, 0x0c, 0x04, 0x22, 0xc6, 0x18, 0x63, 0x10, 0x81,
+  0x10, 0x8e, 0x92, 0xa6, 0x88, 0x12, 0x26, 0xff, 0x9f, 0x88, 0x6b, 0xa2,
+  0x22, 0xe2, 0xb7, 0x87, 0x7f, 0x1a, 0x23, 0x00, 0x06, 0x11, 0x8c, 0xe0,
+  0x22, 0x69, 0x8a, 0x28, 0x61, 0xf2, 0x7f, 0x09, 0x60, 0x9e, 0x85, 0x88,
+  0xfe, 0x69, 0x8c, 0x00, 0x18, 0x44, 0x40, 0x84, 0x82, 0x84, 0x10, 0x44,
+  0x39, 0x27, 0x91, 0x2a, 0x03, 0x18, 0x83, 0xd8, 0x1c, 0x41, 0x30, 0x47,
+  0x00, 0x06, 0xc3, 0x08, 0xc2, 0x53, 0x90, 0x70, 0x92, 0x70, 0xd0, 0x01,
+  0x8a, 0x03, 0x01, 0x29, 0xf0, 0x86, 0x11, 0x86, 0x67, 0x10, 0x21, 0x10,
+  0xe6, 0x08, 0x40, 0x61, 0x10, 0x61, 0x10, 0x46, 0x00, 0x00, 0x13, 0xa8,
+  0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70, 0x80, 0x07,
+  0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87, 0x79, 0xc8, 0x03,
+  0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7, 0x51, 0x0e, 0x6d, 0x00,
+  0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60,
+  0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80,
+  0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0,
+  0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x10,
+  0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0,
+  0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60,
+  0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x74, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0,
+  0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60,
+  0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x90, 0x07, 0x76, 0xa0,
+  0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0,
+  0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80,
+  0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x90,
+  0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50,
+  0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20,
+  0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x6d, 0x60,
+  0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xa0,
+  0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x70, 0x20,
+  0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x7a, 0x10,
+  0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee, 0x80, 0x07, 0x7a, 0x10,
+  0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43, 0x98, 0x05, 0x00, 0x80,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x21, 0x4c, 0x03, 0x04, 0x80, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0xc0, 0x10, 0x46, 0x02, 0x02, 0x60, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x20, 0x0b, 0x04, 0x0b, 0x00, 0x00, 0x00, 0x32, 0x1e,
+  0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04,
+  0x43, 0x7a, 0x25, 0x30, 0x02, 0x50, 0x20, 0x45, 0x50, 0x08, 0x05, 0x18,
+  0x50, 0x10, 0x65, 0x50, 0x40, 0x05, 0x56, 0x0a, 0xc5, 0x40, 0x74, 0x2c,
+  0xc1, 0x21, 0x00, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x0c, 0x01,
+  0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab,
+  0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0xc6, 0x63, 0x4c, 0x00, 0xf5,
+  0x50, 0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b,
+  0x62, 0x3c, 0xc3, 0x24, 0x3c, 0x07, 0xe1, 0x20, 0x08, 0x0e, 0x8e, 0xad,
+  0x0c, 0x84, 0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed,
+  0xcd, 0x0d, 0x64, 0x26, 0x06, 0x06, 0x26, 0xc6, 0xa5, 0x06, 0x06, 0x04,
+  0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26, 0x06, 0x06,
+  0x26, 0xc6, 0xa5, 0x06, 0xc6, 0x25, 0x26, 0x65, 0x88, 0x30, 0x11, 0x43,
+  0x8c, 0x67, 0x78, 0x92, 0x87, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36,
+  0x04, 0x99, 0x8e, 0x67, 0x78, 0x86, 0x87, 0xe0, 0x16, 0x96, 0x26, 0xe7,
+  0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6,
+  0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96, 0x36, 0x17, 0x26, 0xc6, 0x56, 0x36,
+  0x44, 0x98, 0x12, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
+  0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74,
+  0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x84, 0x69, 0x21,
+  0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5, 0xc1, 0xa5, 0xb1, 0x95,
+  0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5, 0x99, 0x99, 0x95, 0xc9,
+  0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x95, 0xb9, 0x85, 0x89, 0xb1,
+  0x95, 0x0d, 0x11, 0xa6, 0x86, 0x51, 0x58, 0x9a, 0x9c, 0x8b, 0x5c, 0x99,
+  0x1b, 0x59, 0x99, 0xdc, 0x17, 0x5d, 0x98, 0xdc, 0x59, 0x19, 0x1d, 0xa3,
+  0xb0, 0x34, 0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2,
+  0x2f, 0xb7, 0xb0, 0xb6, 0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34,
+  0x43, 0x90, 0xe9, 0x79, 0x88, 0x09, 0x9a, 0xa2, 0x21, 0xc2, 0x24, 0x91,
+  0x09, 0x4b, 0x93, 0x73, 0x81, 0x7b, 0x9b, 0x4b, 0xa3, 0x4b, 0x7b, 0x73,
+  0xa3, 0x12, 0x96, 0x26, 0xe7, 0x32, 0x56, 0xe6, 0x46, 0x57, 0x26, 0x47,
+  0x29, 0x2c, 0x4d, 0xce, 0xc5, 0xed, 0xed, 0x0b, 0xae, 0x4c, 0x6e, 0x0e,
+  0xae, 0x6c, 0x8c, 0x2e, 0xcd, 0xae, 0x8c, 0x4c, 0x58, 0x9a, 0x9c, 0x4b,
+  0x98, 0xdc, 0xd9, 0x97, 0x5b, 0x58, 0x5b, 0x19, 0x11, 0xb8, 0xb7, 0xb9,
+  0x34, 0xba, 0xb4, 0x37, 0xb7, 0x21, 0xd0, 0x43, 0x4c, 0xd4, 0x54, 0x4d,
+  0xd6, 0x04, 0x4d, 0xd1, 0x74, 0x4d, 0x18, 0xa5, 0xb0, 0x34, 0x39, 0x17,
+  0x33, 0xb9, 0xb0, 0xb3, 0xb6, 0x32, 0x37, 0xba, 0xaf, 0x34, 0x37, 0xb8,
+  0x3a, 0x3a, 0x5a, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64,
+  0x28, 0x35, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66,
+  0x29, 0x7c, 0xc2, 0xd2, 0xe4, 0x5c, 0xe0, 0xca, 0xe4, 0xe6, 0xe0, 0xca,
+  0xc6, 0xe8, 0xd2, 0xec, 0xca, 0x58, 0x8c, 0xbd, 0xb1, 0xbd, 0xc9, 0x0d,
+  0x91, 0x9e, 0x61, 0xd2, 0xa6, 0x6d, 0xaa, 0x26, 0x6e, 0x82, 0xa6, 0x68,
+  0xba, 0xa6, 0x8e, 0xd9, 0x59, 0x99, 0x5b, 0x99, 0x5c, 0x18, 0x5d, 0x19,
+  0x19, 0x0a, 0x0e, 0x5d, 0x19, 0xde, 0xd8, 0xdb, 0x9b, 0x1c, 0x19, 0x91,
+  0x9d, 0xcc, 0x97, 0x59, 0x0a, 0x0d, 0x33, 0xb6, 0xb7, 0x30, 0x3a, 0x19,
+  0x22, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x43, 0xa4, 0xc7,
+  0x98, 0xb4, 0xe9, 0x9b, 0xaa, 0x89, 0x9b, 0xa0, 0x09, 0x0c, 0xa6, 0x6b,
+  0x0a, 0x03, 0x2a, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65,
+  0x72, 0x7c, 0xc2, 0xd2, 0xe4, 0x5c, 0xc4, 0xea, 0xcc, 0xcc, 0xca, 0xe4,
+  0xbe, 0xe6, 0xd2, 0xf4, 0xca, 0x28, 0x85, 0xa5, 0xc9, 0xb9, 0xb0, 0xbd,
+  0x8d, 0x85, 0xd1, 0xa5, 0xbd, 0xb9, 0x7d, 0xa5, 0xb9, 0x91, 0x95, 0xe1,
+  0x11, 0x09, 0x4b, 0x93, 0x73, 0x91, 0x2b, 0x0b, 0x23, 0x23, 0x15, 0x96,
+  0x26, 0xe7, 0x32, 0x47, 0x27, 0x57, 0x37, 0x46, 0xf7, 0x45, 0x97, 0x07,
+  0x57, 0xf6, 0x95, 0xe6, 0x66, 0xf6, 0x46, 0xc3, 0x8c, 0xed, 0x2d, 0x8c,
+  0x6e, 0x86, 0xc6, 0x9b, 0x99, 0xd9, 0x5c, 0x19, 0x1d, 0x0d, 0xa9, 0xb1,
+  0xb7, 0x32, 0x33, 0x33, 0x1a, 0x47, 0x63, 0x6f, 0x65, 0x66, 0x66, 0x34,
+  0x84, 0xc6, 0xde, 0xca, 0xcc, 0xcc, 0x86, 0xa0, 0xc1, 0x43, 0x3c, 0xc5,
+  0x43, 0x4c, 0x68, 0x30, 0xa5, 0xc1, 0x53, 0x3c, 0xc5, 0x43, 0x4c, 0x68,
+  0x30, 0xa9, 0xc1, 0xb3, 0x3c, 0xc5, 0x43, 0x4c, 0x68, 0x30, 0xad, 0xc1,
+  0xc3, 0x3c, 0xc5, 0x43, 0x4c, 0x68, 0x30, 0xb1, 0x01, 0xa3, 0xb0, 0x34,
+  0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0xaf, 0xb9,
+  0x34, 0xbd, 0x32, 0x5e, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f,
+  0x74, 0x79, 0x70, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73,
+  0x69, 0x7a, 0x65, 0x4c, 0xb2, 0xaa, 0xac, 0x88, 0xca, 0xc6, 0xde, 0xc8,
+  0xca, 0x68, 0x90, 0x95, 0x8d, 0xbd, 0x91, 0x95, 0x0d, 0x21, 0x83, 0x47,
+  0x99, 0xc6, 0x60, 0x22, 0x83, 0x07, 0x99, 0xca, 0xe0, 0x19, 0x9e, 0x61,
+  0x32, 0x83, 0xe9, 0x0c, 0xa6, 0x36, 0x98, 0xdc, 0xe0, 0x41, 0xa6, 0x37,
+  0x78, 0x8a, 0x09, 0x9a, 0xe0, 0x60, 0xba, 0xa6, 0x38, 0xe0, 0x12, 0x96,
+  0x26, 0xe7, 0x42, 0x57, 0x86, 0x47, 0x57, 0x27, 0x57, 0x46, 0x25, 0x2c,
+  0x4d, 0xce, 0x65, 0x2e, 0xac, 0x0d, 0x8e, 0xad, 0x8c, 0x18, 0x5d, 0x19,
+  0x1e, 0x5d, 0x9d, 0x5c, 0x99, 0x0c, 0x19, 0x8f, 0x19, 0xdb, 0x5b, 0x18,
+  0x1d, 0x0b, 0xc8, 0x5c, 0x58, 0x1b, 0x1c, 0x5b, 0x99, 0x0f, 0x09, 0xba,
+  0x32, 0xbc, 0xac, 0x21, 0xd4, 0x73, 0x4c, 0x73, 0x30, 0x95, 0xc1, 0x43,
+  0x3c, 0xc3, 0x44, 0x07, 0x13, 0x34, 0xd5, 0xc1, 0x74, 0x4d, 0x76, 0xc0,
+  0x82, 0xae, 0x0c, 0xaf, 0xca, 0x6a, 0x08, 0xf5, 0x34, 0xd3, 0x1c, 0x4c,
+  0x65, 0xf0, 0x0c, 0xcf, 0x30, 0xd1, 0xc1, 0x04, 0x4d, 0x75, 0x30, 0x5d,
+  0x13, 0x1e, 0x70, 0x09, 0x4b, 0x93, 0x73, 0x99, 0x0b, 0x6b, 0x83, 0x63,
+  0x2b, 0x93, 0xe3, 0x31, 0x17, 0xd6, 0x06, 0xc7, 0x56, 0x26, 0xc7, 0x60,
+  0x6e, 0x88, 0xf4, 0x38, 0x93, 0x1e, 0x4c, 0x65, 0xf0, 0x10, 0xcf, 0x30,
+  0x41, 0xd3, 0x1e, 0x4c, 0xd7, 0xc4, 0x07, 0x43, 0x9c, 0x29, 0x9b, 0xbc,
+  0x49, 0x0c, 0x26, 0x39, 0x98, 0xee, 0x60, 0xca, 0x83, 0xa9, 0x0f, 0x86,
+  0x18, 0x0b, 0x30, 0x4d, 0x93, 0x1f, 0x8c, 0x88, 0xd8, 0x81, 0x1d, 0xec,
   0xa1, 0x1d, 0xdc, 0xa0, 0x1d, 0xde, 0x81, 0x1c, 0xea, 0x81, 0x1d, 0xca,
   0xc1, 0x0d, 0xcc, 0x81, 0x1d, 0xc2, 0xe1, 0x1c, 0xe6, 0x61, 0x8a, 0x10,
   0x0c, 0x23, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x48, 0x07,
@@ -957,885 +1750,72 @@ const unsigned char sdl_metallib[] = {
   0x77, 0x80, 0x07, 0x7a, 0x48, 0x87, 0x77, 0x70, 0x87, 0x79, 0x98, 0x32,
   0x28, 0x8c, 0x33, 0x82, 0x09, 0x87, 0x74, 0x90, 0x07, 0x37, 0x30, 0x07,
   0x79, 0x08, 0x87, 0x73, 0x68, 0x87, 0x72, 0x70, 0x07, 0x7a, 0x98, 0x12,
-  0xc8, 0x01, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00,
-  0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88,
-  0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73,
-  0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e,
-  0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30,
-  0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8,
-  0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b,
-  0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76,
-  0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e,
-  0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e,
-  0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61,
-  0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4,
-  0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76,
-  0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37,
-  0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76,
-  0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71,
-  0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e,
-  0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1,
-  0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61,
-  0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90,
-  0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8,
-  0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc,
-  0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7,
-  0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78,
-  0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f,
-  0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f,
-  0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1,
-  0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0,
-  0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0,
-  0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b,
-  0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c,
-  0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61,
-  0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1,
-  0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc,
-  0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4,
-  0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79,
-  0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72,
-  0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e,
-  0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1,
-  0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8,
-  0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8,
-  0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00,
-  0x71, 0x20, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x06, 0x10, 0xb1, 0x5d,
-  0xf9, 0x73, 0xce, 0x83, 0xfd, 0x45, 0x04, 0x18, 0x0c, 0xd1, 0x4c, 0x16,
-  0xb0, 0x01, 0x48, 0xe4, 0x4b, 0x00, 0xf3, 0x2c, 0xc4, 0x3f, 0x11, 0xd7,
-  0x44, 0x45, 0xc4, 0x6f, 0x0f, 0x7e, 0x85, 0x17, 0xb7, 0x0d, 0x00, 0x00,
-  0x61, 0x20, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c,
-  0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xc4, 0x46, 0x00, 0x48,
-  0xd5, 0xc0, 0x08, 0x00, 0x81, 0x11, 0x00, 0x00, 0x23, 0x06, 0x8a, 0x10,
-  0x4c, 0x46, 0x81, 0x0c, 0x84, 0x10, 0x10, 0x52, 0x2c, 0x10, 0xe4, 0x93,
-  0x41, 0x40, 0x0c, 0x00, 0x02, 0x00, 0x00, 0x00, 0x5b, 0x86, 0x20, 0xb8,
-  0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b,
-  0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x10, 0x0d, 0x00, 0x00,
-  0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00,
-  0x41, 0x03, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00,
-  0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49,
-  0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19,
-  0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42,
-  0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44, 0x24,
-  0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21, 0x72,
-  0x24, 0x07, 0xc8, 0x48, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0,
-  0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00, 0x00, 0x90, 0x00, 0x00, 0x00,
-  0x1b, 0xcc, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x60, 0x00, 0x09,
-  0xa8, 0x88, 0x71, 0x78, 0x07, 0x79, 0x90, 0x87, 0x72, 0x18, 0x07, 0x7a,
-  0x60, 0x87, 0x7c, 0x68, 0x03, 0x79, 0x78, 0x87, 0x7a, 0x70, 0x07, 0x72,
-  0x28, 0x07, 0x72, 0x68, 0x03, 0x72, 0x48, 0x07, 0x7b, 0x48, 0x07, 0x72,
-  0x28, 0x87, 0x36, 0x98, 0x87, 0x78, 0x90, 0x07, 0x7a, 0x68, 0x03, 0x73,
-  0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xcc, 0x21,
-  0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xc8, 0x21, 0x1d, 0xe6, 0x21,
-  0x1c, 0xc4, 0x81, 0x1d, 0xca, 0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xd2, 0x81,
-  0x1d, 0xda, 0x60, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0x61, 0x1e, 0x00, 0x73,
-  0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x76, 0x28, 0x87, 0x79,
-  0x98, 0x87, 0x36, 0x80, 0x07, 0x79, 0x28, 0x87, 0x71, 0x48, 0x87, 0x79,
-  0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x87, 0x70, 0x20, 0x07, 0xc0,
-  0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1,
-  0x0d, 0xcc, 0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca, 0xa1, 0x0d, 0xe0, 0xe1,
-  0x1d, 0xd2, 0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xca, 0x81,
-  0x1d, 0xd2, 0xa1, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x60,
-  0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72,
-  0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79,
-  0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68, 0x87, 0x36, 0x70, 0x87, 0x77,
-  0x70, 0x87, 0x36, 0x60, 0x87, 0x72, 0x08, 0x07, 0x73, 0x00, 0x08, 0x77,
-  0x78, 0x87, 0x36, 0x48, 0x07, 0x77, 0x30, 0x87, 0x79, 0x68, 0x03, 0x73,
-  0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41,
-  0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xd4, 0xa1,
-  0x1e, 0xda, 0x01, 0x1e, 0xda, 0x80, 0x1e, 0xc2, 0x41, 0x1c, 0xd8, 0xa1,
-  0x1c, 0xe6, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80,
-  0x70, 0x87, 0x77, 0x68, 0x03, 0x77, 0x08, 0x07, 0x77, 0x98, 0x87, 0x36,
-  0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80,
-  0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x60,
-  0x1e, 0xd2, 0xe1, 0x1c, 0xdc, 0xa1, 0x1c, 0xc8, 0xa1, 0x0d, 0xf4, 0xa1,
-  0x1c, 0xe4, 0xe1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0,
-  0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72,
-  0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0xa0, 0x07, 0x79, 0x08, 0x07, 0x78,
-  0x80, 0x87, 0x74, 0x70, 0x87, 0x73, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a,
-  0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xe6, 0x81,
-  0x1e, 0xc2, 0x61, 0x1c, 0xd6, 0xa1, 0x0d, 0xe0, 0x41, 0x1e, 0xde, 0x81,
-  0x1e, 0xca, 0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0xa1, 0x0d, 0xc4, 0xa1,
-  0x1e, 0xcc, 0xc1, 0x1c, 0xca, 0x41, 0x1e, 0xda, 0x60, 0x1e, 0xd2, 0x41,
-  0x1f, 0xca, 0x01, 0xc0, 0x03, 0x80, 0xa8, 0x07, 0x77, 0x98, 0x87, 0x70,
-  0x30, 0x87, 0x72, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70,
-  0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xa2,
-  0x1e, 0xe6, 0xa1, 0x1c, 0xda, 0x60, 0x1e, 0xde, 0xc1, 0x1c, 0xe8, 0xa1,
-  0x0d, 0xcc, 0x81, 0x1d, 0xde, 0x21, 0x1c, 0xe8, 0x01, 0x30, 0x87, 0x70,
-  0x60, 0x87, 0x79, 0x28, 0x07, 0x60, 0x03, 0x22, 0x0c, 0x40, 0x02, 0x2c,
-  0x40, 0xb5, 0x01, 0x19, 0x08, 0x20, 0x01, 0x16, 0xa0, 0xda, 0x60, 0x10,
-  0x05, 0xb0, 0x00, 0xd5, 0x06, 0xa3, 0x38, 0x80, 0x05, 0xa8, 0x36, 0x18,
-  0xc6, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x80, 0x04, 0x50, 0x1b, 0x90, 0xe3,
-  0xff, 0xff, 0xff, 0xff, 0x07, 0x80, 0x01, 0x24, 0xa0, 0xda, 0x60, 0x20,
-  0x01, 0xb0, 0x00, 0xd5, 0x06, 0x23, 0x11, 0x80, 0x05, 0xa8, 0x00, 0x00,
-  0x49, 0x18, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x13, 0x8a, 0x40, 0x18,
-  0x88, 0x62, 0x42, 0x60, 0x4c, 0x18, 0x0e, 0x24, 0x01, 0x00, 0x00, 0x00,
-  0x89, 0x20, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09,
-  0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3,
-  0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c,
-  0x10, 0x7c, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00, 0x83,
-  0x08, 0x41, 0x30, 0x8c, 0x30, 0x00, 0x07, 0x49, 0x53, 0x44, 0x09, 0x93,
-  0x2f, 0xbb, 0x6f, 0x47, 0x08, 0xce, 0x40, 0x20, 0x82, 0x10, 0x42, 0x06,
-  0x11, 0x0a, 0xe1, 0x28, 0x69, 0x8a, 0x28, 0x61, 0xf2, 0xff, 0x89, 0xb8,
-  0x26, 0x2a, 0x22, 0x7e, 0x7b, 0xf8, 0xa7, 0x31, 0x02, 0x60, 0x10, 0xe1,
-  0x08, 0x4e, 0x93, 0xa6, 0x88, 0x12, 0x26, 0xff, 0x9f, 0x88, 0x6b, 0xa2,
-  0x22, 0xe2, 0xb7, 0x87, 0x1f, 0x88, 0x22, 0x00, 0xfb, 0xa7, 0x31, 0x02,
-  0x60, 0x10, 0x21, 0x09, 0x2e, 0x92, 0xa6, 0x88, 0x12, 0x26, 0xff, 0x97,
-  0x00, 0xe6, 0x59, 0x88, 0xe8, 0x9f, 0xc6, 0x08, 0x80, 0x41, 0x84, 0x45,
-  0x28, 0x48, 0x08, 0x62, 0x18, 0xa4, 0x18, 0xb5, 0x32, 0x00, 0x42, 0xe8,
-  0xcd, 0x11, 0x80, 0xc1, 0x1c, 0x41, 0x30, 0x8c, 0x20, 0x44, 0x25, 0x09,
-  0x8a, 0x89, 0x28, 0xa7, 0x04, 0x44, 0x0b, 0x12, 0x10, 0x13, 0x72, 0x4a,
-  0x40, 0x76, 0x20, 0x20, 0x05, 0xe2, 0x30, 0xc2, 0x10, 0x0d, 0x22, 0x04,
-  0xc2, 0x1c, 0x01, 0x28, 0x0c, 0x22, 0x10, 0xc2, 0x08, 0x00, 0x00, 0x00,
-  0x13, 0xa8, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70,
-  0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87, 0x79,
-  0xc8, 0x03, 0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7, 0x51, 0x0e,
-  0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a, 0x80, 0x07,
-  0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78, 0xa0, 0x07,
-  0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07,
-  0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07,
-  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x60, 0x07,
-  0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06,
-  0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
-  0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76, 0xa0, 0x07,
-  0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07,
-  0x74, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06,
-  0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
-  0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74, 0xa0, 0x07,
-  0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x90, 0x07,
-  0x76, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07,
-  0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07,
-  0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f,
-  0x71, 0x90, 0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07,
-  0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75, 0x60, 0x07,
-  0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07,
-  0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07,
-  0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x10, 0x07,
-  0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07,
-  0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee, 0x80, 0x07,
-  0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43, 0x18, 0x07,
-  0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x21, 0x0c, 0x04, 0x04,
-  0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x10, 0xa6, 0x02, 0x02, 0x60,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x08, 0x73, 0x01, 0x01, 0x30, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x90, 0x05, 0x02, 0x00, 0x0b, 0x00, 0x00, 0x00,
-  0x32, 0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47,
-  0xc6, 0x04, 0x43, 0x8a, 0x25, 0x30, 0x02, 0x50, 0x20, 0x45, 0x50, 0x08,
-  0x05, 0x18, 0x50, 0x10, 0x65, 0x50, 0x40, 0x05, 0x56, 0x0a, 0xc5, 0x40,
-  0x7c, 0x04, 0x80, 0xf2, 0x58, 0x82, 0x23, 0x00, 0x79, 0x18, 0x00, 0x00,
-  0x1d, 0x01, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25,
-  0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x46, 0x74, 0x60,
-  0x40, 0x16, 0x51, 0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3,
-  0x2b, 0x1b, 0x62, 0x44, 0x04, 0x26, 0x44, 0x08, 0xdd, 0x20, 0x08, 0x0e,
-  0x8e, 0xad, 0x0c, 0x84, 0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e,
-  0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x26, 0x06, 0x06, 0x26, 0xc6, 0x85, 0x66,
-  0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26,
-  0x06, 0x06, 0x26, 0xc6, 0x85, 0x66, 0x26, 0x65, 0x88, 0x80, 0x11, 0x43,
-  0x8c, 0x88, 0x88, 0x94, 0xa8, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36,
-  0x04, 0xc1, 0x8e, 0x88, 0x88, 0x88, 0xa8, 0xe0, 0x16, 0x96, 0x26, 0xe7,
-  0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6,
-  0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96, 0x36, 0x17, 0x26, 0xc6, 0x56, 0x36,
-  0x44, 0xc0, 0x12, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
-  0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74,
-  0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x04, 0x6c, 0x21,
-  0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5, 0xc1, 0xa5, 0xb1, 0x95,
-  0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5, 0x99, 0x99, 0x95, 0xc9,
-  0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x95, 0xb9, 0x85, 0x89, 0xb1,
-  0x95, 0x0d, 0x11, 0xb0, 0x86, 0x51, 0x58, 0x9a, 0x9c, 0x8b, 0x5c, 0x99,
-  0x1b, 0x59, 0x99, 0xdc, 0x17, 0x5d, 0x98, 0xdc, 0x59, 0x19, 0x1d, 0xa3,
-  0xb0, 0x34, 0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2,
-  0x2f, 0xb7, 0xb0, 0xb6, 0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34,
-  0x43, 0x10, 0xec, 0x89, 0x0a, 0x0c, 0xc2, 0xa2, 0x21, 0x02, 0x26, 0x91,
-  0x09, 0x4b, 0x93, 0x73, 0x81, 0x7b, 0x9b, 0x4b, 0xa3, 0x4b, 0x7b, 0x73,
-  0xa3, 0x12, 0x96, 0x26, 0xe7, 0x32, 0x56, 0xe6, 0x46, 0x57, 0x26, 0x47,
-  0x29, 0x2c, 0x4d, 0xce, 0xc5, 0xed, 0xed, 0x0b, 0xae, 0x4c, 0x6e, 0x0e,
-  0xae, 0x6c, 0x8c, 0x2e, 0xcd, 0xae, 0x8c, 0x4c, 0x58, 0x9a, 0x9c, 0x4b,
-  0x98, 0xdc, 0xd9, 0x97, 0x5b, 0x58, 0x5b, 0x19, 0x11, 0xb8, 0xb7, 0xb9,
-  0x34, 0xba, 0xb4, 0x37, 0xb7, 0x21, 0x50, 0x54, 0x60, 0x14, 0x56, 0x61,
-  0x16, 0x06, 0x61, 0x11, 0x76, 0x61, 0x18, 0xa5, 0xb0, 0x34, 0x39, 0x17,
-  0x33, 0xb9, 0xb0, 0xb3, 0xb6, 0x32, 0x37, 0xba, 0xaf, 0x34, 0x37, 0xb8,
-  0x3a, 0x3a, 0x66, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64,
-  0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x44, 0x76,
-  0x32, 0x5f, 0x66, 0x29, 0x7c, 0xc2, 0xd2, 0xe4, 0x5c, 0xe0, 0xca, 0xe4,
-  0xe6, 0xe0, 0xca, 0xc6, 0xe8, 0xd2, 0xec, 0xca, 0x68, 0x98, 0xb1, 0xbd,
-  0x85, 0xd1, 0xc9, 0x10, 0xa1, 0x2b, 0xc3, 0x1b, 0x7b, 0x7b, 0x93, 0x23,
-  0x1b, 0x22, 0x45, 0x04, 0xa6, 0x61, 0x1b, 0x56, 0x61, 0x1c, 0x06, 0x61,
-  0x1d, 0x76, 0x61, 0x1e, 0x95, 0xb0, 0x34, 0x39, 0x17, 0xb1, 0x3a, 0x33,
-  0xb3, 0x32, 0x39, 0x3e, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66,
-  0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x94, 0xc2, 0xd2, 0xe4, 0x5c,
-  0xd8, 0xde, 0xc6, 0xc2, 0xe8, 0xd2, 0xde, 0xdc, 0xbe, 0xd2, 0xdc, 0xc8,
-  0xca, 0xf0, 0x88, 0x84, 0xa5, 0xc9, 0xb9, 0xc8, 0x95, 0x85, 0x91, 0x31,
-  0x0a, 0x4b, 0x93, 0x73, 0x09, 0x93, 0x3b, 0xfb, 0xa2, 0xcb, 0x83, 0x2b,
-  0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0xe3, 0x15, 0x96, 0x26, 0xe7, 0x12, 0x26,
-  0x77, 0xf6, 0x45, 0x97, 0x07, 0x57, 0xf6, 0x15, 0xc6, 0x96, 0x76, 0xe6,
-  0xf6, 0x35, 0x97, 0xa6, 0x57, 0xc6, 0x61, 0xec, 0x8d, 0x6d, 0x08, 0x18,
-  0x44, 0x07, 0x06, 0x06, 0x58, 0x18, 0x44, 0x06, 0x26, 0x06, 0x51, 0x11,
-  0x11, 0xd8, 0x18, 0x60, 0x64, 0x10, 0x19, 0x58, 0x19, 0x44, 0x06, 0x06,
-  0x61, 0x11, 0x76, 0x61, 0x66, 0x40, 0x2a, 0x2c, 0x4d, 0xce, 0x65, 0x8e,
-  0x4e, 0xae, 0x6e, 0x8c, 0xee, 0x8b, 0x2e, 0x0f, 0xae, 0xec, 0x2b, 0xcd,
-  0xcd, 0xec, 0x8d, 0x86, 0x19, 0xdb, 0x5b, 0x18, 0xdd, 0x0c, 0x8d, 0x37,
-  0x33, 0xb3, 0xb9, 0x32, 0x3a, 0x1a, 0x52, 0x63, 0x6f, 0x65, 0x66, 0x66,
-  0x34, 0x8e, 0xc6, 0xde, 0xca, 0xcc, 0xcc, 0x68, 0x08, 0x8d, 0xbd, 0x95,
-  0x99, 0x99, 0x0d, 0x41, 0x83, 0xa8, 0x88, 0x8c, 0xa8, 0xc0, 0xd2, 0x00,
-  0x53, 0x83, 0xc8, 0x88, 0x8c, 0xa8, 0xc0, 0xd2, 0x00, 0x5b, 0x83, 0x88,
-  0x89, 0x8c, 0xa8, 0xc0, 0xd2, 0x00, 0x63, 0x83, 0xa8, 0x89, 0x8c, 0xa8,
-  0xc0, 0xd2, 0x00, 0x6b, 0x03, 0x26, 0x59, 0x55, 0x56, 0x44, 0x65, 0x63,
-  0x6f, 0x64, 0x65, 0x34, 0xc8, 0xca, 0xc6, 0xde, 0xc8, 0xca, 0x86, 0x90,
-  0x41, 0xb4, 0x60, 0x60, 0x80, 0x85, 0x41, 0x94, 0x60, 0x62, 0x10, 0x11,
-  0x11, 0x81, 0x8d, 0x01, 0x86, 0x06, 0x98, 0x1b, 0x60, 0x64, 0x10, 0x25,
-  0x58, 0x19, 0x44, 0x06, 0x06, 0x61, 0x6f, 0x80, 0x5d, 0x18, 0x1c, 0x70,
-  0x09, 0x4b, 0x93, 0x73, 0xa1, 0x2b, 0xc3, 0xa3, 0xab, 0x93, 0x2b, 0xa3,
-  0x12, 0x96, 0x26, 0xe7, 0x32, 0x17, 0xd6, 0x06, 0xc7, 0x56, 0x46, 0x8c,
-  0xae, 0x0c, 0x8f, 0xae, 0x4e, 0xae, 0x4c, 0x86, 0x8c, 0xc7, 0x8c, 0xed,
-  0x2d, 0x8c, 0x8e, 0x05, 0x64, 0x2e, 0xac, 0x0d, 0x8e, 0xad, 0xcc, 0x87,
-  0x04, 0x5d, 0x19, 0x5e, 0xd6, 0x10, 0x2a, 0x42, 0x30, 0x39, 0xc0, 0xc4,
-  0x20, 0x2a, 0x22, 0x02, 0x9b, 0x03, 0x0c, 0xc2, 0xe8, 0x00, 0xbb, 0xb0,
-  0x3a, 0xa0, 0x47, 0x57, 0x86, 0x47, 0x57, 0x27, 0x57, 0x26, 0x43, 0xf6,
-  0x15, 0x26, 0x27, 0x17, 0x96, 0xc7, 0x63, 0xc6, 0xf6, 0x16, 0x46, 0xc7,
-  0x02, 0x32, 0x17, 0xd6, 0x06, 0xc7, 0x56, 0xe6, 0xc3, 0x82, 0xae, 0x0c,
-  0xaf, 0xca, 0x6a, 0x08, 0x15, 0x39, 0x98, 0x1c, 0x60, 0x62, 0x10, 0x11,
-  0x11, 0x81, 0xcd, 0x01, 0x06, 0x61, 0x77, 0x80, 0x5d, 0x18, 0x1e, 0x70,
-  0x09, 0x4b, 0x93, 0x73, 0x99, 0x0b, 0x6b, 0x83, 0x63, 0x2b, 0x93, 0xe3,
-  0x31, 0x17, 0xd6, 0x06, 0xc7, 0x56, 0x26, 0xc7, 0x60, 0x6e, 0x88, 0x14,
-  0x3d, 0x98, 0x1e, 0x60, 0x62, 0x10, 0x15, 0x11, 0x81, 0x41, 0xd8, 0x1e,
-  0x60, 0x17, 0xc6, 0x07, 0x43, 0x1c, 0x2c, 0xc3, 0x3e, 0xec, 0x0c, 0xb0,
-  0x38, 0xc0, 0xec, 0x00, 0xcb, 0x03, 0xac, 0x0f, 0x86, 0x18, 0x0e, 0x80,
-  0x4d, 0x98, 0x1f, 0xf0, 0x79, 0x6b, 0x73, 0x4b, 0x83, 0x7b, 0xa3, 0x2b,
-  0x73, 0xa3, 0x03, 0x19, 0x43, 0x0b, 0x93, 0xe3, 0x33, 0x95, 0xd6, 0x06,
-  0xc7, 0x56, 0x06, 0x32, 0xb4, 0xb2, 0x02, 0x42, 0x25, 0x14, 0x14, 0x34,
-  0x44, 0xc0, 0x42, 0x61, 0x88, 0x81, 0x81, 0x02, 0x26, 0x0a, 0x1c, 0x34,
-  0xc4, 0xc0, 0x46, 0x01, 0x1b, 0x05, 0x0e, 0x1a, 0x11, 0xb1, 0x03, 0x3b,
-  0xd8, 0x43, 0x3b, 0xb8, 0x41, 0x3b, 0xbc, 0x03, 0x39, 0xd4, 0x03, 0x3b,
-  0x94, 0x83, 0x1b, 0x98, 0x03, 0x3b, 0x84, 0xc3, 0x39, 0xcc, 0xc3, 0x14,
-  0x21, 0x18, 0x46, 0x28, 0xec, 0xc0, 0x0e, 0xf6, 0xd0, 0x0e, 0x6e, 0x90,
-  0x0e, 0xe4, 0x50, 0x0e, 0xee, 0x40, 0x0f, 0x53, 0x82, 0x62, 0xc4, 0x12,
-  0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0x60, 0x0f, 0xe5, 0x20, 0x0f, 0xf3, 0x90,
-  0x0e, 0xef, 0xe0, 0x0e, 0x53, 0x02, 0x63, 0x04, 0x15, 0x0e, 0xe9, 0x20,
-  0x0f, 0x6e, 0xc0, 0x0e, 0xe1, 0xe0, 0x0e, 0xe7, 0x50, 0x0f, 0xe1, 0x70,
-  0x0e, 0xe5, 0xf0, 0x0b, 0xf6, 0x50, 0x0e, 0xf2, 0x30, 0x0f, 0xe9, 0xf0,
-  0x0e, 0xee, 0x30, 0x25, 0x40, 0x46, 0x4c, 0xe1, 0x90, 0x0e, 0xf2, 0xe0,
-  0x06, 0xe3, 0xf0, 0x0e, 0xed, 0x00, 0x0f, 0xe9, 0xc0, 0x0e, 0xe5, 0xf0,
-  0x0b, 0xef, 0x00, 0x0f, 0xf4, 0x90, 0x0e, 0xef, 0xe0, 0x0e, 0xf3, 0x30,
-  0x65, 0x50, 0x18, 0x67, 0x04, 0x13, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0x60,
-  0x0e, 0xf2, 0x10, 0x0e, 0xe7, 0xd0, 0x0e, 0xe5, 0xe0, 0x0e, 0xf4, 0x30,
-  0x25, 0xf8, 0x03, 0x00, 0x79, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00,
-  0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88,
-  0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73,
-  0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e,
-  0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30,
-  0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8,
-  0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b,
-  0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76,
-  0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e,
-  0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e,
-  0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61,
-  0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4,
-  0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76,
-  0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37,
-  0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76,
-  0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71,
-  0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e,
-  0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1,
-  0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61,
-  0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90,
-  0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8,
-  0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc,
-  0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7,
-  0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78,
-  0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f,
-  0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f,
-  0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1,
-  0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0,
-  0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0,
-  0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b,
-  0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c,
-  0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61,
-  0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1,
-  0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc,
-  0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4,
-  0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79,
-  0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72,
-  0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e,
-  0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1,
-  0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8,
-  0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8,
-  0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00,
-  0x71, 0x20, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x26, 0x10, 0x06, 0x00,
-  0x12, 0xf9, 0x12, 0xc0, 0x3c, 0x0b, 0xf1, 0x4f, 0xc4, 0x35, 0x51, 0x11,
-  0xf1, 0xdb, 0xc3, 0x0f, 0x44, 0x11, 0x80, 0xf9, 0x15, 0x5e, 0xdc, 0xb6,
-  0x05, 0x34, 0x00, 0x12, 0xf9, 0x83, 0x33, 0xf9, 0xd5, 0x5d, 0xdc, 0xb6,
-  0x0d, 0x6c, 0x00, 0x12, 0xf9, 0x12, 0xc0, 0x3c, 0x0b, 0xf1, 0x4f, 0xc4,
-  0x35, 0x51, 0x11, 0xf1, 0xdb, 0x83, 0x5f, 0xe1, 0xc5, 0x6d, 0x1b, 0x00,
-  0xc4, 0x76, 0xe5, 0x2f, 0xbb, 0xef, 0x5f, 0x44, 0x80, 0xc1, 0x10, 0xcd,
-  0x04, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x3b, 0x00, 0x00, 0x00,
-  0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
-  0xa4, 0xe7, 0x18, 0x0a, 0xcf, 0x1b, 0x6b, 0x00, 0x02, 0x81, 0xe6, 0x08,
-  0x00, 0xc9, 0x11, 0x80, 0x1a, 0xa0, 0x38, 0x03, 0x40, 0x61, 0x0e, 0x42,
-  0x0c, 0xc4, 0x40, 0x0c, 0xc2, 0x60, 0x06, 0x80, 0xc0, 0x18, 0x01, 0x08,
-  0x82, 0x20, 0xfe, 0xcd, 0x00, 0x8c, 0x00, 0x00, 0x23, 0x06, 0xca, 0x10,
-  0x84, 0x81, 0xc3, 0x44, 0x47, 0x82, 0x04, 0x83, 0x0c, 0x41, 0xc1, 0x8c,
-  0x18, 0x2c, 0x43, 0x40, 0x06, 0x8f, 0x33, 0x85, 0x41, 0xb2, 0x28, 0xc3,
-  0x18, 0x42, 0x20, 0x06, 0x73, 0x0c, 0x43, 0x40, 0x06, 0x23, 0x06, 0xcb,
-  0x10, 0x9c, 0x81, 0x14, 0x59, 0x65, 0xc0, 0x38, 0x8d, 0x31, 0x86, 0x10,
-  0x94, 0xc1, 0x1c, 0xc3, 0x10, 0x90, 0xc1, 0x5d, 0x7b, 0x29, 0x28, 0x83,
-  0x0c, 0x81, 0x43, 0x19, 0x11, 0xc0, 0x87, 0xb8, 0x32, 0xde, 0xc0, 0x85,
-  0x41, 0x1b, 0x5c, 0xb0, 0x97, 0x82, 0x32, 0xc8, 0x10, 0x50, 0xda, 0x88,
-  0x41, 0x21, 0x04, 0x74, 0x60, 0x04, 0xe3, 0x0d, 0x61, 0x60, 0x06, 0x6f,
-  0x70, 0xc1, 0x5e, 0x0a, 0xca, 0x20, 0x43, 0x90, 0x7d, 0x23, 0x06, 0x85,
-  0x10, 0xe4, 0xc1, 0x12, 0x8c, 0x37, 0x98, 0xc1, 0x1a, 0xc0, 0xc1, 0x05,
-  0x7b, 0x29, 0x28, 0x83, 0x0c, 0x81, 0x47, 0x06, 0x23, 0x06, 0x85, 0x10,
-  0xf8, 0x01, 0x14, 0xcc, 0x31, 0x84, 0xc1, 0xb2, 0x07, 0x73, 0x0c, 0xc1,
-  0xd1, 0x07, 0x73, 0x0c, 0xc1, 0xb0, 0x07, 0x16, 0x4c, 0xf2, 0xc9, 0x20,
-  0x20, 0x06, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x5b, 0x06, 0x26, 0x20,
-  0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
-  0xa4, 0x0c, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde,
-  0x21, 0x0c, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00,
-  0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91,
-  0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c,
-  0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02,
-  0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x49,
-  0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52, 0x80,
-  0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8, 0x48, 0x11, 0x62, 0xa8, 0xa0,
-  0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00, 0x00,
-  0x92, 0x00, 0x00, 0x00, 0x1b, 0xcc, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff,
-  0x01, 0x60, 0x00, 0x09, 0xa8, 0x88, 0x71, 0x78, 0x07, 0x79, 0x90, 0x87,
-  0x72, 0x18, 0x07, 0x7a, 0x60, 0x87, 0x7c, 0x68, 0x03, 0x79, 0x78, 0x87,
-  0x7a, 0x70, 0x07, 0x72, 0x28, 0x07, 0x72, 0x68, 0x03, 0x72, 0x48, 0x07,
-  0x7b, 0x48, 0x07, 0x72, 0x28, 0x87, 0x36, 0x98, 0x87, 0x78, 0x90, 0x07,
-  0x7a, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07,
-  0x74, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xc8,
-  0x21, 0x1d, 0xe6, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0xa1, 0x0d, 0xe8,
-  0x21, 0x1c, 0xd2, 0x81, 0x1d, 0xda, 0x60, 0x1c, 0xc2, 0x81, 0x1d, 0xd8,
-  0x61, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08,
-  0x76, 0x28, 0x87, 0x79, 0x98, 0x87, 0x36, 0x80, 0x07, 0x79, 0x28, 0x87,
-  0x71, 0x48, 0x87, 0x79, 0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x87,
-  0x70, 0x20, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00,
-  0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xcc, 0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca,
-  0xa1, 0x0d, 0xe0, 0xe1, 0x1d, 0xd2, 0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4,
-  0xa1, 0x0d, 0xca, 0x81, 0x1d, 0xd2, 0xa1, 0x1d, 0x00, 0x7a, 0x90, 0x87,
-  0x7a, 0x28, 0x07, 0x60, 0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90, 0x87,
-  0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70, 0x07,
-  0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68, 0x87,
-  0x36, 0x70, 0x87, 0x77, 0x70, 0x87, 0x36, 0x60, 0x87, 0x72, 0x08, 0x07,
-  0x73, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x48, 0x07, 0x77, 0x30, 0x87,
-  0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07,
-  0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde,
-  0xa1, 0x0d, 0xd4, 0xa1, 0x1e, 0xda, 0x01, 0x1e, 0xda, 0x80, 0x1e, 0xc2,
-  0x41, 0x1c, 0xd8, 0xa1, 0x1c, 0xe6, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87,
-  0x79, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x77, 0x08, 0x07,
-  0x77, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07,
-  0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc,
-  0xe1, 0x1d, 0xda, 0x60, 0x1e, 0xd2, 0xe1, 0x1c, 0xdc, 0xa1, 0x1c, 0xc8,
-  0xa1, 0x0d, 0xf4, 0xa1, 0x1c, 0xe4, 0xe1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc,
-  0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07,
-  0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0xa0, 0x07,
-  0x79, 0x08, 0x07, 0x78, 0x80, 0x87, 0x74, 0x70, 0x87, 0x73, 0x68, 0x83,
-  0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca,
-  0x01, 0x20, 0xe6, 0x81, 0x1e, 0xc2, 0x61, 0x1c, 0xd6, 0xa1, 0x0d, 0xe0,
-  0x41, 0x1e, 0xde, 0x81, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4,
-  0xa1, 0x0d, 0xc4, 0xa1, 0x1e, 0xcc, 0xc1, 0x1c, 0xca, 0x41, 0x1e, 0xda,
-  0x60, 0x1e, 0xd2, 0x41, 0x1f, 0xca, 0x01, 0xc0, 0x03, 0x80, 0xa8, 0x07,
-  0x77, 0x98, 0x87, 0x70, 0x30, 0x87, 0x72, 0x68, 0x03, 0x73, 0x80, 0x87,
-  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea,
-  0xa1, 0x1c, 0x00, 0xa2, 0x1e, 0xe6, 0xa1, 0x1c, 0xda, 0x60, 0x1e, 0xde,
-  0xc1, 0x1c, 0xe8, 0xa1, 0x0d, 0xcc, 0x81, 0x1d, 0xde, 0x21, 0x1c, 0xe8,
-  0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x60, 0x03, 0x22,
-  0x0c, 0x40, 0x02, 0x2c, 0x40, 0xb5, 0x01, 0x19, 0x08, 0x20, 0x01, 0x16,
-  0xa0, 0xda, 0x60, 0x10, 0x05, 0xb0, 0x00, 0xd5, 0x06, 0xa3, 0x30, 0x80,
-  0x05, 0xa8, 0x36, 0x18, 0xc6, 0x01, 0x2c, 0x40, 0xb5, 0xc1, 0x38, 0xfe,
-  0xff, 0xff, 0xff, 0x7f, 0x00, 0x24, 0x80, 0xda, 0x80, 0x20, 0xff, 0xff,
-  0xff, 0xff, 0x3f, 0x00, 0x0c, 0x20, 0x01, 0xd5, 0x06, 0x23, 0x09, 0x80,
-  0x05, 0xa8, 0x36, 0x18, 0x8a, 0x00, 0x2c, 0x40, 0x05, 0x00, 0x00, 0x00,
-  0x49, 0x18, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x13, 0x8c, 0x40, 0x18,
-  0x88, 0xc2, 0x98, 0x10, 0x1c, 0x13, 0x06, 0x24, 0x51, 0x00, 0x00, 0x00,
-  0x89, 0x20, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09,
-  0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3,
-  0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c,
-  0x10, 0x6c, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00, 0x83,
-  0x08, 0x41, 0x30, 0x8c, 0x30, 0x00, 0x07, 0x49, 0x53, 0x44, 0x09, 0x93,
-  0x2f, 0xbb, 0x6f, 0x47, 0x08, 0xce, 0x40, 0x20, 0x82, 0x10, 0x42, 0x06,
-  0x11, 0x0a, 0xe1, 0x28, 0x69, 0x8a, 0x28, 0x61, 0xf2, 0xff, 0x89, 0xb8,
-  0x26, 0x2a, 0x22, 0x7e, 0x7b, 0xf8, 0xa7, 0x31, 0x02, 0x60, 0x10, 0xe1,
-  0x08, 0x2e, 0x92, 0xa6, 0x88, 0x12, 0x26, 0xff, 0x97, 0x00, 0xe6, 0x59,
-  0x88, 0xe8, 0x9f, 0xc6, 0x08, 0x80, 0x41, 0x84, 0x44, 0x28, 0x48, 0x08,
-  0x62, 0x18, 0x84, 0x14, 0xad, 0x32, 0x00, 0x42, 0xa8, 0xcd, 0x11, 0x04,
-  0x73, 0x04, 0x60, 0x30, 0x8c, 0x20, 0x40, 0x05, 0x09, 0x48, 0x89, 0x17,
-  0x1f, 0x20, 0x39, 0x10, 0x90, 0x02, 0x70, 0x18, 0x61, 0x80, 0x06, 0x11,
-  0x02, 0x61, 0x8e, 0x00, 0x14, 0x06, 0x11, 0x08, 0x61, 0x04, 0x00, 0x00,
-  0x13, 0xa8, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70,
-  0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87, 0x79,
-  0xc8, 0x03, 0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7, 0x51, 0x0e,
-  0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a, 0x80, 0x07,
-  0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78, 0xa0, 0x07,
-  0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07,
-  0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07,
-  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x60, 0x07,
-  0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06,
-  0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
-  0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76, 0xa0, 0x07,
-  0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07,
-  0x74, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06,
-  0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
-  0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74, 0xa0, 0x07,
-  0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x90, 0x07,
-  0x76, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07,
-  0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07,
-  0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f,
-  0x71, 0x90, 0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07,
-  0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75, 0x60, 0x07,
-  0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07,
-  0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07,
-  0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x10, 0x07,
-  0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07,
-  0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee, 0x80, 0x07,
-  0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43, 0x18, 0x06,
-  0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x21, 0x8c, 0x03, 0x04,
-  0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x10, 0x66, 0x02, 0x02, 0x60,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x0b, 0x04, 0x0b, 0x00, 0x00, 0x00,
-  0x32, 0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47,
-  0xc6, 0x04, 0x43, 0x82, 0x25, 0x30, 0x02, 0x50, 0x20, 0x45, 0x50, 0x08,
-  0x05, 0x18, 0x50, 0x10, 0x65, 0x50, 0x40, 0x05, 0x56, 0x0a, 0xc5, 0x40,
-  0x78, 0x04, 0x80, 0xea, 0x58, 0x82, 0x23, 0x00, 0x79, 0x18, 0x00, 0x00,
-  0x16, 0x01, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25,
-  0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x06, 0x64, 0x50,
-  0x40, 0x05, 0x51, 0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3,
-  0x2b, 0x1b, 0x62, 0x40, 0x03, 0x25, 0x40, 0x07, 0xdd, 0x20, 0x08, 0x0e,
-  0x8e, 0xad, 0x0c, 0x84, 0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e,
-  0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x26, 0x06, 0x06, 0x26, 0xc6, 0x85, 0x66,
-  0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26,
-  0x06, 0x06, 0x26, 0xc6, 0x85, 0x66, 0x26, 0x65, 0x88, 0x40, 0x11, 0x43,
-  0x0c, 0x68, 0x80, 0x12, 0x88, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36,
-  0x04, 0xa1, 0x0e, 0x68, 0x80, 0x06, 0x88, 0xe0, 0x16, 0x96, 0x26, 0xe7,
-  0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6,
-  0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96, 0x36, 0x17, 0x26, 0xc6, 0x56, 0x36,
-  0x44, 0xa0, 0x12, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
-  0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74,
-  0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x04, 0x6a, 0x21,
-  0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5, 0xc1, 0xa5, 0xb1, 0x95,
-  0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5, 0x99, 0x99, 0x95, 0xc9,
-  0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x95, 0xb9, 0x85, 0x89, 0xb1,
-  0x95, 0x0d, 0x11, 0xa8, 0x86, 0x51, 0x58, 0x9a, 0x9c, 0x8b, 0x5c, 0x99,
-  0x1b, 0x59, 0x99, 0xdc, 0x17, 0x5d, 0x98, 0xdc, 0x59, 0x19, 0x1d, 0xa3,
-  0xb0, 0x34, 0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2,
-  0x2f, 0xb7, 0xb0, 0xb6, 0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34,
-  0x43, 0x10, 0xea, 0x81, 0x08, 0x0a, 0xa2, 0xa2, 0x21, 0x02, 0x25, 0x91,
-  0x09, 0x4b, 0x93, 0x73, 0x81, 0x7b, 0x9b, 0x4b, 0xa3, 0x4b, 0x7b, 0x73,
-  0xa3, 0x12, 0x96, 0x26, 0xe7, 0x32, 0x56, 0xe6, 0x46, 0x57, 0x26, 0x47,
-  0x29, 0x2c, 0x4d, 0xce, 0xc5, 0xed, 0xed, 0x0b, 0xae, 0x4c, 0x6e, 0x0e,
-  0xae, 0x6c, 0x8c, 0x2e, 0xcd, 0xae, 0x8c, 0x4c, 0x58, 0x9a, 0x9c, 0x4b,
-  0x98, 0xdc, 0xd9, 0x97, 0x5b, 0x58, 0x5b, 0x19, 0x11, 0xb8, 0xb7, 0xb9,
-  0x34, 0xba, 0xb4, 0x37, 0xb7, 0x21, 0x10, 0x44, 0x50, 0x14, 0x55, 0x51,
-  0x16, 0x05, 0x51, 0x11, 0x75, 0x51, 0x18, 0xa5, 0xb0, 0x34, 0x39, 0x17,
-  0x33, 0xb9, 0xb0, 0xb3, 0xb6, 0x32, 0x37, 0xba, 0xaf, 0x34, 0x37, 0xb8,
-  0x3a, 0x3a, 0x66, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64,
-  0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x44, 0x76,
-  0x32, 0x5f, 0x66, 0x29, 0x7c, 0xc2, 0xd2, 0xe4, 0x5c, 0xe0, 0xca, 0xe4,
-  0xe6, 0xe0, 0xca, 0xc6, 0xe8, 0xd2, 0xec, 0xca, 0x68, 0x98, 0xb1, 0xbd,
-  0x85, 0xd1, 0xc9, 0x10, 0xa1, 0x2b, 0xc3, 0x1b, 0x7b, 0x7b, 0x93, 0x23,
-  0x1b, 0x22, 0x41, 0x03, 0xa5, 0x51, 0x1b, 0x55, 0x51, 0x1c, 0x05, 0x51,
-  0x1d, 0x75, 0x51, 0x1e, 0x95, 0xb0, 0x34, 0x39, 0x17, 0xb1, 0x3a, 0x33,
-  0xb3, 0x32, 0x39, 0x3e, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66,
-  0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x94, 0xc2, 0xd2, 0xe4, 0x5c,
-  0xd8, 0xde, 0xc6, 0xc2, 0xe8, 0xd2, 0xde, 0xdc, 0xbe, 0xd2, 0xdc, 0xc8,
-  0xca, 0xf0, 0x88, 0x84, 0xa5, 0xc9, 0xb9, 0xc8, 0x95, 0x85, 0x91, 0x31,
-  0x0a, 0x4b, 0x93, 0x73, 0x09, 0x93, 0x3b, 0xfb, 0xa2, 0xcb, 0x83, 0x2b,
-  0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0xe3, 0x15, 0x96, 0x26, 0xe7, 0x12, 0x26,
-  0x77, 0xf6, 0x45, 0x97, 0x07, 0x57, 0xf6, 0x15, 0xc6, 0x96, 0x76, 0xe6,
-  0xf6, 0x35, 0x97, 0xa6, 0x57, 0xc6, 0x61, 0xec, 0x8d, 0x6d, 0x08, 0x18,
-  0x40, 0x06, 0x05, 0x06, 0x54, 0x18, 0x40, 0x05, 0x25, 0x06, 0x10, 0x01,
-  0x0d, 0xd4, 0x18, 0x50, 0x64, 0x00, 0x15, 0x54, 0x19, 0x40, 0x05, 0x05,
-  0x51, 0x11, 0x75, 0x51, 0x66, 0x40, 0x2a, 0x2c, 0x4d, 0xce, 0x65, 0x8e,
-  0x4e, 0xae, 0x6e, 0x8c, 0xee, 0x8b, 0x2e, 0x0f, 0xae, 0xec, 0x2b, 0xcd,
-  0xcd, 0xec, 0x8d, 0x86, 0x19, 0xdb, 0x5b, 0x18, 0xdd, 0x0c, 0x8d, 0x37,
-  0x33, 0xb3, 0xb9, 0x32, 0x3a, 0x1a, 0x52, 0x63, 0x6f, 0x65, 0x66, 0x66,
-  0x34, 0x8e, 0xc6, 0xde, 0xca, 0xcc, 0xcc, 0x68, 0x08, 0x8d, 0xbd, 0x95,
-  0x99, 0x99, 0x0d, 0x41, 0x03, 0x88, 0x80, 0x0a, 0x88, 0xa0, 0xd2, 0x80,
-  0x52, 0x03, 0xa8, 0x80, 0x0a, 0x88, 0xa0, 0xd2, 0x80, 0x5a, 0x03, 0x68,
-  0x81, 0x0a, 0x88, 0xa0, 0xd2, 0x80, 0x62, 0x03, 0x88, 0x81, 0x0a, 0x88,
-  0xa0, 0xd2, 0x80, 0x6a, 0x03, 0x26, 0x59, 0x55, 0x56, 0x44, 0x65, 0x63,
-  0x6f, 0x64, 0x65, 0x34, 0xc8, 0xca, 0xc6, 0xde, 0xc8, 0xca, 0x86, 0x90,
-  0x01, 0xa4, 0x50, 0x60, 0x40, 0x85, 0x01, 0x84, 0x50, 0x62, 0x00, 0x0d,
-  0xd0, 0x40, 0x8d, 0x01, 0x85, 0x06, 0x94, 0x1b, 0x50, 0x64, 0x00, 0x21,
-  0x54, 0x19, 0x40, 0x05, 0x05, 0x51, 0x6f, 0x40, 0x5d, 0x14, 0x1c, 0x70,
-  0x09, 0x4b, 0x93, 0x73, 0xa1, 0x2b, 0xc3, 0xa3, 0xab, 0x93, 0x2b, 0xa3,
-  0x12, 0x96, 0x26, 0xe7, 0x32, 0x17, 0xd6, 0x06, 0xc7, 0x56, 0x46, 0x8c,
-  0xae, 0x0c, 0x8f, 0xae, 0x4e, 0xae, 0x4c, 0x86, 0x8c, 0xc7, 0x8c, 0xed,
-  0x2d, 0x8c, 0x8e, 0x05, 0x64, 0x2e, 0xac, 0x0d, 0x8e, 0xad, 0xcc, 0x87,
-  0x04, 0x5d, 0x19, 0x5e, 0xd6, 0x10, 0x0a, 0x3a, 0x28, 0x39, 0xa0, 0xc4,
-  0x00, 0x22, 0xa0, 0x81, 0x9a, 0x03, 0x0a, 0xa2, 0xe8, 0x80, 0xba, 0xa8,
-  0x3a, 0x60, 0x41, 0x57, 0x86, 0x57, 0x65, 0x35, 0x84, 0x82, 0x1a, 0x4a,
-  0x0e, 0x28, 0x31, 0x80, 0x06, 0x68, 0xa0, 0xe6, 0x80, 0x82, 0x28, 0x3a,
-  0xa0, 0x2e, 0xea, 0x0e, 0xb8, 0x84, 0xa5, 0xc9, 0xb9, 0xcc, 0x85, 0xb5,
-  0xc1, 0xb1, 0x95, 0xc9, 0xf1, 0x98, 0x0b, 0x6b, 0x83, 0x63, 0x2b, 0x93,
-  0x63, 0x30, 0x37, 0x44, 0x82, 0x1c, 0x2a, 0x0f, 0x28, 0x31, 0x80, 0x08,
-  0x68, 0xa0, 0x20, 0x4a, 0x0f, 0xa8, 0x8b, 0xda, 0x83, 0x21, 0x0e, 0x95,
-  0x51, 0x1f, 0x75, 0x06, 0x54, 0x1c, 0x50, 0x76, 0x40, 0xe1, 0x01, 0xc5,
-  0x07, 0x43, 0x0c, 0x06, 0xa0, 0x26, 0xaa, 0x0f, 0xf8, 0xbc, 0xb5, 0xb9,
-  0xa5, 0xc1, 0xbd, 0xd1, 0x95, 0xb9, 0xd1, 0x81, 0x8c, 0xa1, 0x85, 0xc9,
-  0xf1, 0x99, 0x4a, 0x6b, 0x83, 0x63, 0x2b, 0x03, 0x19, 0x5a, 0x59, 0x01,
-  0xa1, 0x12, 0x0a, 0x0a, 0x1a, 0x22, 0x50, 0xa0, 0x30, 0xc4, 0xa0, 0xfe,
-  0x80, 0x0a, 0x05, 0xec, 0x19, 0x62, 0x50, 0xa2, 0x40, 0x89, 0x02, 0xf6,
-  0x8c, 0x88, 0xd8, 0x81, 0x1d, 0xec, 0xa1, 0x1d, 0xdc, 0xa0, 0x1d, 0xde,
-  0x81, 0x1c, 0xea, 0x81, 0x1d, 0xca, 0xc1, 0x0d, 0xcc, 0x81, 0x1d, 0xc2,
-  0xe1, 0x1c, 0xe6, 0x61, 0x8a, 0x10, 0x0c, 0x23, 0x14, 0x76, 0x60, 0x07,
-  0x7b, 0x68, 0x07, 0x37, 0x48, 0x07, 0x72, 0x28, 0x07, 0x77, 0xa0, 0x87,
-  0x29, 0x41, 0x31, 0x62, 0x09, 0x87, 0x74, 0x90, 0x07, 0x37, 0xb0, 0x87,
-  0x72, 0x90, 0x87, 0x79, 0x48, 0x87, 0x77, 0x70, 0x87, 0x29, 0x81, 0x31,
-  0x82, 0x0a, 0x87, 0x74, 0x90, 0x07, 0x37, 0x60, 0x87, 0x70, 0x70, 0x87,
-  0x73, 0xa8, 0x87, 0x70, 0x38, 0x87, 0x72, 0xf8, 0x05, 0x7b, 0x28, 0x07,
-  0x79, 0x98, 0x87, 0x74, 0x78, 0x07, 0x77, 0x98, 0x12, 0x20, 0x23, 0xa6,
-  0x70, 0x48, 0x07, 0x79, 0x70, 0x83, 0x71, 0x78, 0x87, 0x76, 0x80, 0x87,
-  0x74, 0x60, 0x87, 0x72, 0xf8, 0x85, 0x77, 0x80, 0x07, 0x7a, 0x48, 0x87,
-  0x77, 0x70, 0x87, 0x79, 0x98, 0x32, 0x28, 0x8c, 0x33, 0x82, 0x09, 0x87,
-  0x74, 0x90, 0x07, 0x37, 0x30, 0x07, 0x79, 0x08, 0x87, 0x73, 0x68, 0x87,
-  0x72, 0x70, 0x07, 0x7a, 0x98, 0x12, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00,
-  0x79, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c,
-  0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3,
-  0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6,
-  0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e,
-  0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43,
-  0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03,
-  0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48,
-  0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20,
-  0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e,
-  0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d,
-  0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89,
-  0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83,
-  0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68,
-  0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90,
-  0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78,
-  0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98,
-  0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5,
-  0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c,
-  0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c,
-  0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43,
-  0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43,
-  0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82,
-  0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58,
-  0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18,
-  0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2,
-  0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec,
-  0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e,
-  0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d,
-  0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83,
-  0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60,
-  0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0,
-  0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d,
-  0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d,
-  0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43,
-  0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3,
-  0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18,
-  0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3,
-  0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1,
-  0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e,
-  0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83,
-  0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83,
-  0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20, 0x00, 0x00,
-  0x0d, 0x00, 0x00, 0x00, 0x16, 0xd0, 0x00, 0x48, 0xe4, 0x0f, 0xce, 0xe4,
-  0x57, 0x77, 0x71, 0xdb, 0x26, 0xb0, 0x01, 0x48, 0xe4, 0x4b, 0x00, 0xf3,
-  0x2c, 0xc4, 0x3f, 0x11, 0xd7, 0x44, 0x45, 0xc4, 0x6f, 0x0f, 0x7e, 0x85,
-  0x17, 0xb7, 0x6d, 0x00, 0x11, 0xdb, 0x95, 0xff, 0xf9, 0xd6, 0xf6, 0x5f,
-  0x44, 0x80, 0xc1, 0x10, 0xcd, 0x04, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00,
-  0x38, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00,
-  0x0e, 0x00, 0x00, 0x00, 0x64, 0xc7, 0x1a, 0x80, 0x81, 0x98, 0x63, 0x20,
-  0x86, 0x6f, 0x8e, 0x81, 0xf8, 0xbe, 0xb1, 0x06, 0x20, 0x10, 0x28, 0x8e,
-  0x00, 0xd0, 0xab, 0x81, 0x11, 0x00, 0x82, 0x33, 0x00, 0x14, 0xe6, 0x20,
-  0xc8, 0x80, 0x0c, 0xc8, 0x40, 0x0c, 0x66, 0x00, 0x08, 0x8c, 0x11, 0x80,
-  0x20, 0x08, 0xe2, 0xdf, 0x08, 0xc0, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x23, 0x06, 0xca, 0x10, 0x8c, 0x01, 0xe4, 0x4c, 0x48, 0x72, 0x08, 0x83,
-  0x0c, 0x41, 0xc1, 0x8c, 0x18, 0x28, 0x43, 0x50, 0x06, 0x11, 0x54, 0x29,
-  0x4b, 0x42, 0x0c, 0x32, 0x04, 0xc7, 0x33, 0xc8, 0x30, 0x04, 0xd1, 0x59,
-  0x77, 0x29, 0x28, 0x83, 0x0c, 0xc1, 0x12, 0x19, 0x11, 0xc0, 0x87, 0xb6,
-  0x32, 0xde, 0xb0, 0x81, 0x01, 0x1b, 0x5c, 0x70, 0x97, 0x82, 0x32, 0xc8,
-  0x10, 0x44, 0xd7, 0x88, 0x41, 0x21, 0x04, 0x72, 0x60, 0x04, 0xe3, 0x0d,
-  0x60, 0x50, 0x06, 0x6e, 0x70, 0xc1, 0x5d, 0x0a, 0xca, 0x20, 0x43, 0x60,
-  0x71, 0x23, 0x06, 0x85, 0x10, 0xdc, 0xc1, 0x12, 0x8c, 0x37, 0x94, 0x81,
-  0x1a, 0xbc, 0xc1, 0x05, 0x77, 0x29, 0x28, 0x83, 0x0c, 0xc1, 0x16, 0x06,
-  0x23, 0x06, 0x85, 0x10, 0xf0, 0x01, 0x14, 0xcc, 0x31, 0x78, 0x8b, 0x1e,
-  0xcc, 0x31, 0x04, 0x07, 0x1f, 0xcc, 0x31, 0x04, 0x83, 0x1e, 0x58, 0x30,
-  0xc9, 0x27, 0x83, 0x80, 0x18, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
-  0x5b, 0x86, 0x24, 0x18, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
-  0xb0, 0x0c, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde,
-  0x21, 0x0c, 0x00, 0x00, 0x29, 0x03, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00,
-  0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91,
-  0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c,
-  0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02,
-  0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x49,
-  0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52, 0x80,
-  0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8, 0x48, 0x11, 0x62, 0xa8, 0xa0,
-  0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00, 0x00,
-  0x92, 0x00, 0x00, 0x00, 0x1b, 0xcc, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff,
-  0x01, 0x60, 0x00, 0x09, 0xa8, 0x88, 0x71, 0x78, 0x07, 0x79, 0x90, 0x87,
-  0x72, 0x18, 0x07, 0x7a, 0x60, 0x87, 0x7c, 0x68, 0x03, 0x79, 0x78, 0x87,
-  0x7a, 0x70, 0x07, 0x72, 0x28, 0x07, 0x72, 0x68, 0x03, 0x72, 0x48, 0x07,
-  0x7b, 0x48, 0x07, 0x72, 0x28, 0x87, 0x36, 0x98, 0x87, 0x78, 0x90, 0x07,
-  0x7a, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07,
-  0x74, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xc8,
-  0x21, 0x1d, 0xe6, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0xa1, 0x0d, 0xe8,
-  0x21, 0x1c, 0xd2, 0x81, 0x1d, 0xda, 0x60, 0x1c, 0xc2, 0x81, 0x1d, 0xd8,
-  0x61, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08,
-  0x76, 0x28, 0x87, 0x79, 0x98, 0x87, 0x36, 0x80, 0x07, 0x79, 0x28, 0x87,
-  0x71, 0x48, 0x87, 0x79, 0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x87,
-  0x70, 0x20, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00,
-  0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xcc, 0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca,
-  0xa1, 0x0d, 0xe0, 0xe1, 0x1d, 0xd2, 0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4,
-  0xa1, 0x0d, 0xca, 0x81, 0x1d, 0xd2, 0xa1, 0x1d, 0x00, 0x7a, 0x90, 0x87,
-  0x7a, 0x28, 0x07, 0x60, 0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90, 0x87,
-  0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70, 0x07,
-  0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68, 0x87,
-  0x36, 0x70, 0x87, 0x77, 0x70, 0x87, 0x36, 0x60, 0x87, 0x72, 0x08, 0x07,
-  0x73, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x48, 0x07, 0x77, 0x30, 0x87,
-  0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07,
-  0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde,
-  0xa1, 0x0d, 0xd4, 0xa1, 0x1e, 0xda, 0x01, 0x1e, 0xda, 0x80, 0x1e, 0xc2,
-  0x41, 0x1c, 0xd8, 0xa1, 0x1c, 0xe6, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87,
-  0x79, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x77, 0x08, 0x07,
-  0x77, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07,
-  0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc,
-  0xe1, 0x1d, 0xda, 0x60, 0x1e, 0xd2, 0xe1, 0x1c, 0xdc, 0xa1, 0x1c, 0xc8,
-  0xa1, 0x0d, 0xf4, 0xa1, 0x1c, 0xe4, 0xe1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc,
-  0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07,
-  0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0xa0, 0x07,
-  0x79, 0x08, 0x07, 0x78, 0x80, 0x87, 0x74, 0x70, 0x87, 0x73, 0x68, 0x83,
-  0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca,
-  0x01, 0x20, 0xe6, 0x81, 0x1e, 0xc2, 0x61, 0x1c, 0xd6, 0xa1, 0x0d, 0xe0,
-  0x41, 0x1e, 0xde, 0x81, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4,
-  0xa1, 0x0d, 0xc4, 0xa1, 0x1e, 0xcc, 0xc1, 0x1c, 0xca, 0x41, 0x1e, 0xda,
-  0x60, 0x1e, 0xd2, 0x41, 0x1f, 0xca, 0x01, 0xc0, 0x03, 0x80, 0xa8, 0x07,
-  0x77, 0x98, 0x87, 0x70, 0x30, 0x87, 0x72, 0x68, 0x03, 0x73, 0x80, 0x87,
-  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea,
-  0xa1, 0x1c, 0x00, 0xa2, 0x1e, 0xe6, 0xa1, 0x1c, 0xda, 0x60, 0x1e, 0xde,
-  0xc1, 0x1c, 0xe8, 0xa1, 0x0d, 0xcc, 0x81, 0x1d, 0xde, 0x21, 0x1c, 0xe8,
-  0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x60, 0x03, 0x22,
-  0x0c, 0x40, 0x02, 0x2c, 0x40, 0xb5, 0x01, 0x19, 0x08, 0x20, 0x01, 0x16,
-  0xa0, 0xda, 0x60, 0x10, 0x05, 0xb0, 0x00, 0xd5, 0x06, 0xa3, 0x30, 0x80,
-  0x05, 0xa8, 0x36, 0x18, 0xc6, 0x01, 0x2c, 0x40, 0xb5, 0xc1, 0x38, 0xfe,
-  0xff, 0xff, 0xff, 0x7f, 0x00, 0x24, 0x80, 0xda, 0x80, 0x20, 0xff, 0xff,
-  0xff, 0xff, 0x3f, 0x00, 0x0c, 0x20, 0x01, 0xd5, 0x06, 0x23, 0x09, 0x80,
-  0x05, 0xa8, 0x36, 0x18, 0x8a, 0x00, 0x2c, 0x40, 0x05, 0x00, 0x00, 0x00,
-  0x49, 0x18, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x13, 0x8c, 0x40, 0x18,
-  0x88, 0xc2, 0x98, 0x10, 0x1c, 0x13, 0x06, 0x24, 0x51, 0x00, 0x00, 0x00,
-  0x89, 0x20, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09,
-  0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3,
-  0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c,
-  0x10, 0x6c, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00, 0x83,
-  0x08, 0x41, 0x30, 0x8c, 0x30, 0x00, 0x07, 0x49, 0x53, 0x44, 0x09, 0x93,
-  0x2f, 0xbb, 0x6f, 0x47, 0x08, 0xce, 0x40, 0x20, 0x82, 0x10, 0x42, 0x06,
-  0x11, 0x0a, 0xe1, 0x28, 0x69, 0x8a, 0x28, 0x61, 0xf2, 0xff, 0x89, 0xb8,
-  0x26, 0x2a, 0x22, 0x7e, 0x7b, 0xf8, 0xa7, 0x31, 0x02, 0x60, 0x10, 0xe1,
-  0x08, 0x2e, 0x92, 0xa6, 0x88, 0x12, 0x26, 0xff, 0x97, 0x00, 0xe6, 0x59,
-  0x88, 0xe8, 0x9f, 0xc6, 0x08, 0x80, 0x41, 0x84, 0x44, 0x28, 0x48, 0x08,
-  0x62, 0x18, 0x84, 0x14, 0xad, 0x32, 0x00, 0x42, 0xa8, 0xcd, 0x11, 0x04,
-  0x73, 0x04, 0x60, 0x30, 0x8c, 0x20, 0x40, 0x05, 0x09, 0x48, 0x89, 0x17,
-  0x1f, 0x20, 0x39, 0x10, 0x90, 0x02, 0x70, 0x18, 0x61, 0x80, 0x06, 0x11,
-  0x02, 0x61, 0x8e, 0x00, 0x14, 0x06, 0x11, 0x08, 0x61, 0x04, 0x00, 0x00,
-  0x13, 0xa8, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70,
-  0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87, 0x79,
-  0xc8, 0x03, 0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7, 0x51, 0x0e,
-  0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a, 0x80, 0x07,
-  0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78, 0xa0, 0x07,
-  0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07,
-  0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07,
-  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x60, 0x07,
-  0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06,
-  0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
-  0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76, 0xa0, 0x07,
-  0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07,
-  0x74, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06,
-  0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
-  0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74, 0xa0, 0x07,
-  0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x90, 0x07,
-  0x76, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07,
-  0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07,
-  0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f,
-  0x71, 0x90, 0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07,
-  0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75, 0x60, 0x07,
-  0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07,
-  0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07,
-  0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x10, 0x07,
-  0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07,
-  0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee, 0x80, 0x07,
-  0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43, 0x18, 0x06,
-  0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x21, 0x8c, 0x03, 0x04,
-  0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x10, 0x66, 0x02, 0x02, 0x60,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x0b, 0x04, 0x0b, 0x00, 0x00, 0x00,
-  0x32, 0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47,
-  0xc6, 0x04, 0x43, 0x82, 0x25, 0x30, 0x02, 0x50, 0x20, 0x45, 0x50, 0x08,
-  0x05, 0x18, 0x50, 0x10, 0x65, 0x50, 0x40, 0x05, 0x56, 0x0a, 0xc5, 0x40,
-  0x78, 0x04, 0x80, 0xea, 0x58, 0x82, 0x23, 0x00, 0x79, 0x18, 0x00, 0x00,
-  0x16, 0x01, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25,
-  0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x06, 0x64, 0x50,
-  0x40, 0x05, 0x51, 0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3,
-  0x2b, 0x1b, 0x62, 0x40, 0x03, 0x25, 0x40, 0x07, 0xdd, 0x20, 0x08, 0x0e,
-  0x8e, 0xad, 0x0c, 0x84, 0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e,
-  0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x26, 0x06, 0x06, 0x26, 0xc6, 0x85, 0x66,
-  0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26,
-  0x06, 0x06, 0x26, 0xc6, 0x85, 0x66, 0x26, 0x65, 0x88, 0x40, 0x11, 0x43,
-  0x0c, 0x68, 0x80, 0x12, 0x88, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36,
-  0x04, 0xa1, 0x0e, 0x68, 0x80, 0x06, 0x88, 0xe0, 0x16, 0x96, 0x26, 0xe7,
-  0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6,
-  0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96, 0x36, 0x17, 0x26, 0xc6, 0x56, 0x36,
-  0x44, 0xa0, 0x12, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
-  0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74,
-  0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x04, 0x6a, 0x21,
-  0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5, 0xc1, 0xa5, 0xb1, 0x95,
-  0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5, 0x99, 0x99, 0x95, 0xc9,
-  0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x95, 0xb9, 0x85, 0x89, 0xb1,
-  0x95, 0x0d, 0x11, 0xa8, 0x86, 0x51, 0x58, 0x9a, 0x9c, 0x8b, 0x5c, 0x99,
-  0x1b, 0x59, 0x99, 0xdc, 0x17, 0x5d, 0x98, 0xdc, 0x59, 0x19, 0x1d, 0xa3,
-  0xb0, 0x34, 0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2,
-  0x2f, 0xb7, 0xb0, 0xb6, 0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34,
-  0x43, 0x10, 0xea, 0x81, 0x08, 0x0a, 0xa2, 0xa2, 0x21, 0x02, 0x25, 0x91,
-  0x09, 0x4b, 0x93, 0x73, 0x81, 0x7b, 0x9b, 0x4b, 0xa3, 0x4b, 0x7b, 0x73,
-  0xa3, 0x12, 0x96, 0x26, 0xe7, 0x32, 0x56, 0xe6, 0x46, 0x57, 0x26, 0x47,
-  0x29, 0x2c, 0x4d, 0xce, 0xc5, 0xed, 0xed, 0x0b, 0xae, 0x4c, 0x6e, 0x0e,
-  0xae, 0x6c, 0x8c, 0x2e, 0xcd, 0xae, 0x8c, 0x4c, 0x58, 0x9a, 0x9c, 0x4b,
-  0x98, 0xdc, 0xd9, 0x97, 0x5b, 0x58, 0x5b, 0x19, 0x11, 0xb8, 0xb7, 0xb9,
-  0x34, 0xba, 0xb4, 0x37, 0xb7, 0x21, 0x10, 0x44, 0x50, 0x14, 0x55, 0x51,
-  0x16, 0x05, 0x51, 0x11, 0x75, 0x51, 0x18, 0xa5, 0xb0, 0x34, 0x39, 0x17,
-  0x33, 0xb9, 0xb0, 0xb3, 0xb6, 0x32, 0x37, 0xba, 0xaf, 0x34, 0x37, 0xb8,
-  0x3a, 0x3a, 0x66, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64,
-  0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x44, 0x76,
-  0x32, 0x5f, 0x66, 0x29, 0x7c, 0xc2, 0xd2, 0xe4, 0x5c, 0xe0, 0xca, 0xe4,
-  0xe6, 0xe0, 0xca, 0xc6, 0xe8, 0xd2, 0xec, 0xca, 0x68, 0x98, 0xb1, 0xbd,
-  0x85, 0xd1, 0xc9, 0x10, 0xa1, 0x2b, 0xc3, 0x1b, 0x7b, 0x7b, 0x93, 0x23,
-  0x1b, 0x22, 0x41, 0x03, 0xa5, 0x51, 0x1b, 0x55, 0x51, 0x1c, 0x05, 0x51,
-  0x1d, 0x75, 0x51, 0x1e, 0x95, 0xb0, 0x34, 0x39, 0x17, 0xb1, 0x3a, 0x33,
-  0xb3, 0x32, 0x39, 0x3e, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66,
-  0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x94, 0xc2, 0xd2, 0xe4, 0x5c,
-  0xd8, 0xde, 0xc6, 0xc2, 0xe8, 0xd2, 0xde, 0xdc, 0xbe, 0xd2, 0xdc, 0xc8,
-  0xca, 0xf0, 0x88, 0x84, 0xa5, 0xc9, 0xb9, 0xc8, 0x95, 0x85, 0x91, 0x31,
-  0x0a, 0x4b, 0x93, 0x73, 0x09, 0x93, 0x3b, 0xfb, 0xa2, 0xcb, 0x83, 0x2b,
-  0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0xe3, 0x15, 0x96, 0x26, 0xe7, 0x12, 0x26,
-  0x77, 0xf6, 0x45, 0x97, 0x07, 0x57, 0xf6, 0x15, 0xc6, 0x96, 0x76, 0xe6,
-  0xf6, 0x35, 0x97, 0xa6, 0x57, 0xc6, 0x61, 0xec, 0x8d, 0x6d, 0x08, 0x18,
-  0x40, 0x06, 0x05, 0x06, 0x54, 0x18, 0x40, 0x05, 0x25, 0x06, 0x10, 0x01,
-  0x0d, 0xd4, 0x18, 0x50, 0x64, 0x00, 0x15, 0x54, 0x19, 0x40, 0x05, 0x05,
-  0x51, 0x11, 0x75, 0x51, 0x66, 0x40, 0x2a, 0x2c, 0x4d, 0xce, 0x65, 0x8e,
-  0x4e, 0xae, 0x6e, 0x8c, 0xee, 0x8b, 0x2e, 0x0f, 0xae, 0xec, 0x2b, 0xcd,
-  0xcd, 0xec, 0x8d, 0x86, 0x19, 0xdb, 0x5b, 0x18, 0xdd, 0x0c, 0x8d, 0x37,
-  0x33, 0xb3, 0xb9, 0x32, 0x3a, 0x1a, 0x52, 0x63, 0x6f, 0x65, 0x66, 0x66,
-  0x34, 0x8e, 0xc6, 0xde, 0xca, 0xcc, 0xcc, 0x68, 0x08, 0x8d, 0xbd, 0x95,
-  0x99, 0x99, 0x0d, 0x41, 0x03, 0x88, 0x80, 0x0a, 0x88, 0xa0, 0xd2, 0x80,
-  0x52, 0x03, 0xa8, 0x80, 0x0a, 0x88, 0xa0, 0xd2, 0x80, 0x5a, 0x03, 0x68,
-  0x81, 0x0a, 0x88, 0xa0, 0xd2, 0x80, 0x62, 0x03, 0x88, 0x81, 0x0a, 0x88,
-  0xa0, 0xd2, 0x80, 0x6a, 0x03, 0x26, 0x59, 0x55, 0x56, 0x44, 0x65, 0x63,
-  0x6f, 0x64, 0x65, 0x34, 0xc8, 0xca, 0xc6, 0xde, 0xc8, 0xca, 0x86, 0x90,
-  0x01, 0xa4, 0x50, 0x60, 0x40, 0x85, 0x01, 0x84, 0x50, 0x62, 0x00, 0x0d,
-  0xd0, 0x40, 0x8d, 0x01, 0x85, 0x06, 0x94, 0x1b, 0x50, 0x64, 0x00, 0x21,
-  0x54, 0x19, 0x40, 0x05, 0x05, 0x51, 0x6f, 0x40, 0x5d, 0x14, 0x1c, 0x70,
-  0x09, 0x4b, 0x93, 0x73, 0xa1, 0x2b, 0xc3, 0xa3, 0xab, 0x93, 0x2b, 0xa3,
-  0x12, 0x96, 0x26, 0xe7, 0x32, 0x17, 0xd6, 0x06, 0xc7, 0x56, 0x46, 0x8c,
-  0xae, 0x0c, 0x8f, 0xae, 0x4e, 0xae, 0x4c, 0x86, 0x8c, 0xc7, 0x8c, 0xed,
-  0x2d, 0x8c, 0x8e, 0x05, 0x64, 0x2e, 0xac, 0x0d, 0x8e, 0xad, 0xcc, 0x87,
-  0x04, 0x5d, 0x19, 0x5e, 0xd6, 0x10, 0x0a, 0x3a, 0x28, 0x39, 0xa0, 0xc4,
-  0x00, 0x22, 0xa0, 0x81, 0x9a, 0x03, 0x0a, 0xa2, 0xe8, 0x80, 0xba, 0xa8,
-  0x3a, 0x60, 0x41, 0x57, 0x86, 0x57, 0x65, 0x35, 0x84, 0x82, 0x1a, 0x4a,
-  0x0e, 0x28, 0x31, 0x80, 0x06, 0x68, 0xa0, 0xe6, 0x80, 0x82, 0x28, 0x3a,
-  0xa0, 0x2e, 0xea, 0x0e, 0xb8, 0x84, 0xa5, 0xc9, 0xb9, 0xcc, 0x85, 0xb5,
-  0xc1, 0xb1, 0x95, 0xc9, 0xf1, 0x98, 0x0b, 0x6b, 0x83, 0x63, 0x2b, 0x93,
-  0x63, 0x30, 0x37, 0x44, 0x82, 0x1c, 0x2a, 0x0f, 0x28, 0x31, 0x80, 0x08,
-  0x68, 0xa0, 0x20, 0x4a, 0x0f, 0xa8, 0x8b, 0xda, 0x83, 0x21, 0x0e, 0x95,
-  0x51, 0x1f, 0x75, 0x06, 0x54, 0x1c, 0x50, 0x76, 0x40, 0xe1, 0x01, 0xc5,
-  0x07, 0x43, 0x0c, 0x06, 0xa0, 0x26, 0xaa, 0x0f, 0xf8, 0xbc, 0xb5, 0xb9,
-  0xa5, 0xc1, 0xbd, 0xd1, 0x95, 0xb9, 0xd1, 0x81, 0x8c, 0xa1, 0x85, 0xc9,
-  0xf1, 0x99, 0x4a, 0x6b, 0x83, 0x63, 0x2b, 0x03, 0x19, 0x5a, 0x59, 0x01,
-  0xa1, 0x12, 0x0a, 0x0a, 0x1a, 0x22, 0x50, 0xa0, 0x30, 0xc4, 0xa0, 0xfe,
-  0x80, 0x0a, 0x05, 0xec, 0x19, 0x62, 0x50, 0xa2, 0x40, 0x89, 0x02, 0xf6,
-  0x8c, 0x88, 0xd8, 0x81, 0x1d, 0xec, 0xa1, 0x1d, 0xdc, 0xa0, 0x1d, 0xde,
-  0x81, 0x1c, 0xea, 0x81, 0x1d, 0xca, 0xc1, 0x0d, 0xcc, 0x81, 0x1d, 0xc2,
-  0xe1, 0x1c, 0xe6, 0x61, 0x8a, 0x10, 0x0c, 0x23, 0x14, 0x76, 0x60, 0x07,
-  0x7b, 0x68, 0x07, 0x37, 0x48, 0x07, 0x72, 0x28, 0x07, 0x77, 0xa0, 0x87,
-  0x29, 0x41, 0x31, 0x62, 0x09, 0x87, 0x74, 0x90, 0x07, 0x37, 0xb0, 0x87,
-  0x72, 0x90, 0x87, 0x79, 0x48, 0x87, 0x77, 0x70, 0x87, 0x29, 0x81, 0x31,
-  0x82, 0x0a, 0x87, 0x74, 0x90, 0x07, 0x37, 0x60, 0x87, 0x70, 0x70, 0x87,
-  0x73, 0xa8, 0x87, 0x70, 0x38, 0x87, 0x72, 0xf8, 0x05, 0x7b, 0x28, 0x07,
-  0x79, 0x98, 0x87, 0x74, 0x78, 0x07, 0x77, 0x98, 0x12, 0x20, 0x23, 0xa6,
-  0x70, 0x48, 0x07, 0x79, 0x70, 0x83, 0x71, 0x78, 0x87, 0x76, 0x80, 0x87,
-  0x74, 0x60, 0x87, 0x72, 0xf8, 0x85, 0x77, 0x80, 0x07, 0x7a, 0x48, 0x87,
-  0x77, 0x70, 0x87, 0x79, 0x98, 0x32, 0x28, 0x8c, 0x33, 0x82, 0x09, 0x87,
-  0x74, 0x90, 0x07, 0x37, 0x30, 0x07, 0x79, 0x08, 0x87, 0x73, 0x68, 0x87,
-  0x72, 0x70, 0x07, 0x7a, 0x98, 0x12, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00,
-  0x79, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c,
-  0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3,
-  0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6,
-  0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e,
-  0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43,
-  0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03,
-  0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48,
-  0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20,
-  0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e,
-  0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d,
-  0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89,
-  0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83,
-  0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68,
-  0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90,
-  0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78,
-  0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98,
-  0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5,
-  0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c,
-  0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c,
-  0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43,
-  0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43,
-  0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82,
-  0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58,
-  0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18,
-  0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2,
-  0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec,
-  0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e,
-  0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d,
-  0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83,
-  0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60,
-  0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0,
-  0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d,
-  0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d,
-  0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43,
-  0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3,
-  0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18,
-  0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3,
-  0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1,
-  0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e,
-  0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83,
-  0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83,
-  0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20, 0x00, 0x00,
-  0x0d, 0x00, 0x00, 0x00, 0x16, 0xd0, 0x00, 0x48, 0xe4, 0x0f, 0xce, 0xe4,
-  0x57, 0x77, 0x71, 0xdb, 0x26, 0xb0, 0x01, 0x48, 0xe4, 0x4b, 0x00, 0xf3,
-  0x2c, 0xc4, 0x3f, 0x11, 0xd7, 0x44, 0x45, 0xc4, 0x6f, 0x0f, 0x7e, 0x85,
-  0x17, 0xb7, 0x6d, 0x00, 0x11, 0xdb, 0x95, 0xff, 0xf9, 0xda, 0xf5, 0x5f,
-  0x44, 0x80, 0xc1, 0x10, 0xcd, 0x04, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00,
-  0x3b, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00,
-  0x10, 0x00, 0x00, 0x00, 0x64, 0xc7, 0x1a, 0x80, 0x81, 0x98, 0x63, 0x20,
-  0x06, 0x30, 0x98, 0x63, 0x20, 0xc0, 0x00, 0x0c, 0xc6, 0x1a, 0x80, 0x40,
-  0xa0, 0x38, 0x96, 0x10, 0x00, 0x23, 0x00, 0xf4, 0x6a, 0x60, 0x04, 0x80,
-  0xe0, 0x0c, 0x00, 0x89, 0x19, 0x00, 0x0a, 0x73, 0x10, 0x66, 0x60, 0x06,
-  0x66, 0x40, 0x06, 0x33, 0x00, 0x04, 0xc6, 0x08, 0x40, 0x10, 0x04, 0xf1,
-  0x6f, 0x04, 0x60, 0x06, 0x00, 0x00, 0x00, 0x00, 0x23, 0x06, 0xca, 0x10,
-  0x94, 0x81, 0x04, 0x55, 0x89, 0x82, 0x08, 0x83, 0x0c, 0x41, 0xe1, 0x8c,
-  0x18, 0x28, 0x43, 0x70, 0x06, 0x93, 0x74, 0x2d, 0x8c, 0x42, 0x0c, 0x32,
-  0x04, 0x87, 0x33, 0xc8, 0x10, 0x28, 0xd2, 0x20, 0x03, 0x11, 0x50, 0x97,
-  0xdd, 0xa5, 0xa0, 0x0c, 0x32, 0x04, 0x0c, 0x65, 0x44, 0x00, 0x1f, 0xf2,
-  0xca, 0x78, 0x83, 0x37, 0x06, 0x6f, 0x70, 0xc1, 0x5d, 0x0a, 0xca, 0x20,
-  0x43, 0x20, 0x69, 0x23, 0x06, 0x85, 0x10, 0xd4, 0x81, 0x11, 0x8c, 0x37,
-  0x8c, 0x01, 0x1a, 0xc4, 0xc1, 0x05, 0x77, 0x29, 0x28, 0x83, 0x0c, 0xc1,
-  0xf5, 0x8d, 0x18, 0x14, 0x42, 0xa0, 0x07, 0x4b, 0x30, 0xde, 0x80, 0x06,
-  0x6d, 0x20, 0x07, 0x17, 0xdc, 0xa5, 0xa0, 0x0c, 0x32, 0x04, 0x1c, 0x19,
-  0x8c, 0x18, 0x14, 0x42, 0xf0, 0x07, 0x50, 0x30, 0xc7, 0xf0, 0x2d, 0x7d,
-  0x30, 0xc7, 0x10, 0x1c, 0x7f, 0x30, 0xc7, 0x10, 0x0c, 0x7d, 0x60, 0xc1,
-  0x24, 0x9f, 0x0c, 0x02, 0x62, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
-  0x5b, 0x06, 0x25, 0x18, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00
+  0xfc, 0x01, 0x00, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x7b, 0x00,
+  0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01,
+  0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78,
+  0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4,
+  0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c,
+  0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03,
+  0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70,
+  0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70,
+  0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec,
+  0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0,
+  0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d,
+  0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43,
+  0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0,
+  0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68,
+  0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28,
+  0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08,
+  0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee,
+  0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62,
+  0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c,
+  0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06,
+  0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43,
+  0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3,
+  0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3,
+  0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68,
+  0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce,
+  0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3,
+  0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d,
+  0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e,
+  0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51,
+  0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60,
+  0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98,
+  0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e,
+  0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e,
+  0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83,
+  0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2,
+  0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a,
+  0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28,
+  0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5,
+  0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17,
+  0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83,
+  0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3,
+  0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3,
+  0x3c, 0x00, 0x71, 0x20, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x16, 0xd0,
+  0x00, 0x48, 0xe4, 0x0f, 0xce, 0xe4, 0x57, 0x77, 0x71, 0xdb, 0x26, 0xb0,
+  0x01, 0x48, 0xe4, 0x4b, 0x00, 0xf3, 0x2c, 0xc4, 0x3f, 0x11, 0xd7, 0x44,
+  0x45, 0xc4, 0x6f, 0x0f, 0x7e, 0x85, 0x17, 0xb7, 0x6d, 0x00, 0x11, 0xdb,
+  0x95, 0xff, 0xf9, 0xda, 0xf5, 0x5f, 0x44, 0x80, 0xc1, 0x10, 0xcd, 0x04,
+  0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x13, 0x04,
+  0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x74, 0x47,
+  0x00, 0xa8, 0x8e, 0x35, 0x00, 0x03, 0x31, 0xc7, 0x40, 0x0c, 0xdf, 0x1c,
+  0x03, 0xf1, 0x7d, 0x63, 0x0d, 0x40, 0x20, 0x10, 0x1c, 0x4b, 0x08, 0x00,
+  0x72, 0x35, 0x30, 0x02, 0x40, 0x6f, 0x06, 0x80, 0xe0, 0x08, 0x00, 0x89,
+  0x19, 0x00, 0x0a, 0x73, 0x10, 0x66, 0x60, 0x06, 0x66, 0x40, 0x06, 0x33,
+  0x00, 0x04, 0xc6, 0x08, 0x40, 0x10, 0x04, 0xf1, 0x6f, 0x04, 0x60, 0x06,
+  0x00, 0x00, 0x23, 0x06, 0xca, 0x10, 0x94, 0xc1, 0x14, 0x55, 0xca, 0x91,
+  0x08, 0x83, 0x0c, 0x41, 0xe1, 0x8c, 0x18, 0x28, 0x43, 0x70, 0x06, 0xd4,
+  0x74, 0x31, 0xc9, 0x42, 0x0c, 0x32, 0x04, 0x87, 0x33, 0xc8, 0x10, 0x28,
+  0xd2, 0x20, 0x03, 0x11, 0x50, 0xa7, 0xd9, 0xa5, 0xa0, 0x0c, 0x32, 0x04,
+  0x0c, 0x65, 0x44, 0x00, 0x9f, 0xf1, 0x06, 0x4f, 0x73, 0x83, 0x0b, 0xec,
+  0x52, 0x50, 0x06, 0x19, 0x82, 0x28, 0x1b, 0x31, 0x28, 0x84, 0x80, 0x0e,
+  0x8a, 0x60, 0xbc, 0x61, 0x0c, 0x3e, 0x38, 0xb8, 0xc0, 0x2e, 0x05, 0x65,
+  0x90, 0x21, 0xb0, 0xbc, 0x11, 0x83, 0x42, 0x08, 0xf2, 0x40, 0x09, 0xc6,
+  0x1b, 0xd0, 0x80, 0x0c, 0xe2, 0xe0, 0x02, 0xbb, 0x14, 0x94, 0x41, 0x86,
+  0x60, 0x1b, 0x83, 0x11, 0x83, 0x42, 0x08, 0xfc, 0xe0, 0x09, 0xe6, 0x18,
+  0xbc, 0x85, 0x0f, 0xe6, 0x18, 0x82, 0xc3, 0x0f, 0xe6, 0x18, 0x82, 0x81,
+  0x0f, 0x2c, 0x90, 0x03, 0xf9, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 };
-const unsigned int sdl_metallib_len = 22048;
+const unsigned int sdl_metallib_len = 21810;
diff --git a/Engine/lib/sdl/src/render/metal/SDL_shaders_metal_iphonesimulator.h b/Engine/lib/sdl/src/render/metal/SDL_shaders_metal_iphonesimulator.h
index 7347013fa..afa2f9d24 100644
--- a/Engine/lib/sdl/src/render/metal/SDL_shaders_metal_iphonesimulator.h
+++ b/Engine/lib/sdl/src/render/metal/SDL_shaders_metal_iphonesimulator.h
@@ -1,19 +1,19 @@
 const unsigned char sdl_metallib[] = {
   0x4d, 0x54, 0x4c, 0x42, 0x01, 0x00, 0x02, 0x00, 0x05, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0xa2, 0x61, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x54, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xae, 0x03, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x0e, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8a, 0x04, 0x00, 0x00,
+  0x8e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9c, 0x04, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0xc2, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x5c, 0x00, 0x00,
+  0xd4, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x5b, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x86, 0x00, 0x00, 0x00,
   0x4e, 0x41, 0x4d, 0x45, 0x11, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x53, 0x6f,
   0x6c, 0x69, 0x64, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x00, 0x54,
   0x59, 0x50, 0x45, 0x01, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00,
-  0x7f, 0x4c, 0xdb, 0xde, 0x31, 0xe2, 0x3f, 0x23, 0x2d, 0x4c, 0xd0, 0xa6,
-  0xf1, 0x58, 0xb9, 0x57, 0xeb, 0xc6, 0x37, 0x59, 0xae, 0x56, 0x95, 0xd1,
-  0xc7, 0x7b, 0x8a, 0x10, 0x1e, 0x22, 0xf2, 0xe1, 0x4d, 0x44, 0x53, 0x5a,
-  0x08, 0x00, 0xa0, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f, 0x46,
+  0x58, 0x42, 0x4b, 0xfb, 0xa2, 0x63, 0xc5, 0xbe, 0xa5, 0x8f, 0x87, 0x96,
+  0xe5, 0x35, 0xca, 0x35, 0xa0, 0xb5, 0xd2, 0xda, 0x62, 0x66, 0xc3, 0xd2,
+  0x70, 0xc6, 0x5e, 0xbd, 0x02, 0xc6, 0xb7, 0xe7, 0x4d, 0x44, 0x53, 0x5a,
+  0x08, 0x00, 0x20, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f, 0x46,
   0x46, 0x54, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x02, 0x00,
@@ -21,243 +21,245 @@ const unsigned char sdl_metallib[] = {
   0x00, 0x00, 0x4e, 0x41, 0x4d, 0x45, 0x10, 0x00, 0x53, 0x44, 0x4c, 0x5f,
   0x43, 0x6f, 0x70, 0x79, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x00,
   0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48, 0x20,
-  0x00, 0x1a, 0x5e, 0xb2, 0x92, 0x8c, 0x25, 0x43, 0xbc, 0x6f, 0x79, 0x8a,
-  0x1c, 0xf6, 0x2d, 0x29, 0x0e, 0x5d, 0xf0, 0xa9, 0xbe, 0x96, 0xd1, 0xbe,
-  0xa8, 0x69, 0xe5, 0xa2, 0x57, 0x11, 0xbe, 0xa3, 0xf5, 0x4d, 0x44, 0x53,
-  0x5a, 0x08, 0x00, 0xe0, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f,
-  0x46, 0x46, 0x54, 0x18, 0x00, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0, 0x0c, 0x00,
+  0x00, 0x66, 0xdb, 0x11, 0xb3, 0x31, 0x5a, 0xaa, 0xb0, 0x50, 0xa4, 0x35,
+  0xc1, 0x73, 0x21, 0x6b, 0xe9, 0xc9, 0x0c, 0x95, 0x5f, 0xa8, 0xd9, 0x57,
+  0xa3, 0x88, 0xec, 0x3f, 0xa9, 0x0a, 0x90, 0xbe, 0x0f, 0x4d, 0x44, 0x53,
+  0x5a, 0x08, 0x00, 0x30, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f,
+  0x46, 0x46, 0x54, 0x18, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x0d, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x02,
   0x00, 0x02, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x88,
   0x00, 0x00, 0x00, 0x4e, 0x41, 0x4d, 0x45, 0x13, 0x00, 0x53, 0x44, 0x4c,
   0x5f, 0x53, 0x6f, 0x6c, 0x69, 0x64, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d,
   0x65, 0x6e, 0x74, 0x00, 0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48,
-  0x41, 0x53, 0x48, 0x20, 0x00, 0x47, 0x0b, 0xfe, 0x5f, 0xa1, 0xeb, 0xee,
-  0x4e, 0x51, 0xcc, 0x14, 0x22, 0x88, 0xb1, 0xb6, 0x2b, 0xd5, 0x11, 0x64,
-  0xbe, 0xee, 0x92, 0xff, 0x91, 0x7f, 0xcb, 0x3f, 0xb8, 0x2d, 0xdf, 0x4c,
-  0xcd, 0x4d, 0x44, 0x53, 0x5a, 0x08, 0x00, 0x80, 0x0a, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x4f, 0x46, 0x46, 0x54, 0x18, 0x00, 0x54, 0x00, 0x00,
+  0x41, 0x53, 0x48, 0x20, 0x00, 0xbf, 0xdd, 0x75, 0x01, 0xa6, 0xb2, 0xda,
+  0x74, 0x88, 0xeb, 0x9a, 0x42, 0x99, 0x64, 0xad, 0x86, 0x24, 0x0f, 0x60,
+  0xba, 0xca, 0x60, 0x8d, 0x5b, 0x03, 0xaa, 0xb6, 0x47, 0xf6, 0x63, 0x4e,
+  0xf7, 0x4d, 0x44, 0x53, 0x5a, 0x08, 0x00, 0x30, 0x0a, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x4f, 0x46, 0x46, 0x54, 0x18, 0x00, 0x66, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x80, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52,
+  0x00, 0x50, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52,
   0x53, 0x08, 0x00, 0x02, 0x00, 0x02, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45,
   0x4e, 0x44, 0x54, 0x87, 0x00, 0x00, 0x00, 0x4e, 0x41, 0x4d, 0x45, 0x12,
   0x00, 0x53, 0x44, 0x4c, 0x5f, 0x43, 0x6f, 0x70, 0x79, 0x5f, 0x66, 0x72,
   0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x00, 0x54, 0x59, 0x50, 0x45, 0x01,
-  0x00, 0x01, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00, 0xae, 0x09, 0x73, 0x8a,
-  0xda, 0x8b, 0xb3, 0x29, 0x5d, 0x2a, 0xd9, 0x5b, 0xa2, 0xb4, 0x19, 0xe7,
-  0xe6, 0xb4, 0x6c, 0xf1, 0xfa, 0x7f, 0xd0, 0x52, 0xeb, 0x18, 0x25, 0x3d,
-  0xee, 0xbf, 0xab, 0x64, 0x4d, 0x44, 0x53, 0x5a, 0x08, 0x00, 0x70, 0x0c,
+  0x00, 0x01, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00, 0x5c, 0xba, 0x6c, 0xdf,
+  0xc2, 0xf6, 0x3b, 0x3e, 0x3e, 0x08, 0x43, 0xbe, 0x7d, 0x22, 0xfe, 0x64,
+  0xc7, 0x25, 0x19, 0x08, 0xc4, 0x0f, 0xc6, 0xb9, 0x40, 0x15, 0x4f, 0x9d,
+  0xae, 0x55, 0xea, 0x33, 0x4d, 0x44, 0x53, 0x5a, 0x08, 0x00, 0xc0, 0x0b,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f, 0x46, 0x46, 0x54, 0x18, 0x00,
-  0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x80, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x02, 0x00, 0x02, 0x00, 0x01, 0x00,
   0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x86, 0x00, 0x00, 0x00, 0x4e, 0x41,
   0x4d, 0x45, 0x11, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x59, 0x55, 0x56, 0x5f,
   0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x00, 0x54, 0x59, 0x50,
-  0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00, 0x90, 0xd8,
-  0x72, 0x29, 0x17, 0x5f, 0x3a, 0x0e, 0x5a, 0xeb, 0xa9, 0x7c, 0x3d, 0x51,
-  0x27, 0x7c, 0x80, 0x1b, 0x02, 0x17, 0x8f, 0x4d, 0x8f, 0x4c, 0x47, 0x21,
-  0x6e, 0x1b, 0xb6, 0xe7, 0x9b, 0xbb, 0x4d, 0x44, 0x53, 0x5a, 0x08, 0x00,
-  0x40, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f, 0x46, 0x46, 0x54,
-  0x18, 0x00, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x30, 0x00, 0x00, 0x00, 0x00,
+  0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00, 0x39, 0xaf,
+  0x60, 0x76, 0x98, 0x96, 0x34, 0xa7, 0xe6, 0x4c, 0xe7, 0x40, 0xaf, 0x1b,
+  0x46, 0x4a, 0x1e, 0xc7, 0x26, 0x6a, 0x31, 0xc3, 0x0d, 0xe8, 0x89, 0x4e,
+  0x88, 0xff, 0x38, 0x12, 0x36, 0xcc, 0x4d, 0x44, 0x53, 0x5a, 0x08, 0x00,
+  0xd0, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f, 0x46, 0x46, 0x54,
+  0x18, 0x00, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x30, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x02, 0x00, 0x02, 0x00,
   0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x87, 0x00, 0x00, 0x00,
   0x4e, 0x41, 0x4d, 0x45, 0x12, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x4e, 0x56,
   0x31, 0x32, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x00,
   0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53, 0x48, 0x20,
-  0x00, 0x8a, 0x26, 0x54, 0x14, 0x4d, 0x2b, 0x8c, 0x28, 0x92, 0x9a, 0x3b,
-  0x6a, 0xd9, 0x09, 0x02, 0xbd, 0xed, 0x11, 0xf3, 0xe5, 0xa8, 0xdb, 0xe9,
-  0x7e, 0xda, 0xcd, 0xc0, 0xa1, 0x44, 0x9a, 0x82, 0x25, 0x4d, 0x44, 0x53,
-  0x5a, 0x08, 0x00, 0x90, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f,
-  0x46, 0x46, 0x54, 0x18, 0x00, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0x3f, 0x00,
+  0x00, 0xb2, 0xee, 0x20, 0x5e, 0x09, 0xbf, 0x7f, 0xac, 0xd0, 0x23, 0x12,
+  0xf8, 0xa4, 0x8d, 0xdc, 0x2f, 0x44, 0x73, 0xe5, 0x8b, 0xe3, 0xba, 0xb1,
+  0x72, 0xaa, 0x49, 0x43, 0x65, 0xbf, 0x81, 0x38, 0x26, 0x4d, 0x44, 0x53,
+  0x5a, 0x08, 0x00, 0x30, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f,
+  0x46, 0x46, 0x54, 0x18, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x3f, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x02,
   0x00, 0x02, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x87,
   0x00, 0x00, 0x00, 0x4e, 0x41, 0x4d, 0x45, 0x12, 0x00, 0x53, 0x44, 0x4c,
   0x5f, 0x4e, 0x56, 0x32, 0x31, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65,
   0x6e, 0x74, 0x00, 0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41,
-  0x53, 0x48, 0x20, 0x00, 0xe4, 0x1e, 0xcf, 0xae, 0xef, 0x87, 0x32, 0xa7,
-  0x5b, 0x04, 0x89, 0x62, 0xa2, 0x3a, 0x12, 0x73, 0xdc, 0xfa, 0x41, 0xe8,
-  0xa8, 0xdd, 0x61, 0x74, 0x9e, 0x56, 0x25, 0xc8, 0x6f, 0x52, 0x57, 0xb0,
-  0x4d, 0x44, 0x53, 0x5a, 0x08, 0x00, 0xa0, 0x0e, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x4f, 0x46, 0x46, 0x54, 0x18, 0x00, 0x74, 0x00, 0x00, 0x00,
+  0x53, 0x48, 0x20, 0x00, 0x07, 0x3f, 0x28, 0x46, 0x4d, 0xc8, 0x8f, 0xea,
+  0x98, 0xaa, 0x7f, 0xba, 0xf9, 0xee, 0x72, 0x32, 0x9b, 0x5f, 0xbd, 0x82,
+  0xbc, 0x63, 0x20, 0x7f, 0xfe, 0xfa, 0x50, 0x7c, 0xc8, 0xc5, 0xe1, 0x28,
+  0x4d, 0x44, 0x53, 0x5a, 0x08, 0x00, 0x40, 0x0e, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x4f, 0x46, 0x46, 0x54, 0x18, 0x00, 0x86, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x40, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53,
+  0x40, 0x4d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53,
   0x08, 0x00, 0x02, 0x00, 0x02, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e,
-  0x44, 0x54, 0x45, 0x4e, 0x44, 0x54, 0x20, 0x00, 0x00, 0x00, 0x56, 0x41,
-  0x54, 0x54, 0x0d, 0x00, 0x01, 0x00, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69,
-  0x6f, 0x6e, 0x00, 0x00, 0x80, 0x56, 0x41, 0x54, 0x59, 0x03, 0x00, 0x01,
-  0x00, 0x04, 0x45, 0x4e, 0x44, 0x54, 0x2c, 0x00, 0x00, 0x00, 0x56, 0x41,
-  0x54, 0x54, 0x18, 0x00, 0x02, 0x00, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69,
-  0x6f, 0x6e, 0x00, 0x00, 0x80, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72,
-  0x64, 0x00, 0x01, 0x80, 0x56, 0x41, 0x54, 0x59, 0x04, 0x00, 0x02, 0x00,
-  0x04, 0x04, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e,
-  0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00,
-  0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e,
-  0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00,
-  0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e,
-  0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00,
-  0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e,
-  0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00,
-  0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00,
-  0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x88, 0x0c, 0x00, 0x00, 0xff, 0xff,
-  0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x35, 0x14, 0x00, 0x00, 0x03, 0x00,
-  0x00, 0x00, 0x62, 0x0c, 0x30, 0x24, 0x80, 0x10, 0x05, 0xc8, 0x14, 0x00,
-  0x00, 0x00, 0x21, 0x0c, 0x00, 0x00, 0xe8, 0x02, 0x00, 0x00, 0x0b, 0x02,
-  0x21, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x07, 0x81,
-  0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01,
-  0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14,
-  0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08,
-  0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88, 0x48, 0x90, 0x14, 0x20, 0x43, 0x46,
-  0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0x04, 0x49, 0x0e, 0x90, 0x91, 0x22,
-  0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x29,
-  0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x85, 0x00, 0x00, 0x00, 0x1b, 0xc8,
-  0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x80, 0x8a, 0x18, 0x87,
-  0x77, 0x90, 0x07, 0x79, 0x28, 0x87, 0x71, 0xa0, 0x07, 0x76, 0xc8, 0x87,
-  0x36, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x77, 0x20, 0x87, 0x72, 0x20, 0x87,
-  0x36, 0x20, 0x87, 0x74, 0xb0, 0x87, 0x74, 0x20, 0x87, 0x72, 0x68, 0x83,
-  0x79, 0x88, 0x07, 0x79, 0xa0, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83,
-  0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6,
-  0xa1, 0x1c, 0x00, 0x82, 0x1c, 0xd2, 0x61, 0x1e, 0xc2, 0x41, 0x1c, 0xd8,
-  0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xc2, 0x21, 0x1d, 0xd8, 0xa1, 0x0d, 0xc6,
-  0x21, 0x1c, 0xd8, 0x81, 0x1d, 0xe6, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87,
-  0x79, 0x28, 0x07, 0x80, 0x60, 0x87, 0x72, 0x98, 0x87, 0x79, 0x68, 0x03,
-  0x78, 0x90, 0x87, 0x72, 0x18, 0x87, 0x74, 0x98, 0x87, 0x72, 0x68, 0x03,
-  0x73, 0x80, 0x87, 0x76, 0x08, 0x07, 0x72, 0x00, 0xcc, 0x21, 0x1c, 0xd8,
-  0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4,
-  0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc,
-  0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda,
-  0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x06, 0x77, 0x78, 0x87,
-  0x36, 0x30, 0x07, 0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87,
-  0x77, 0x48, 0x07, 0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07,
-  0x76, 0x48, 0x87, 0x76, 0x68, 0x03, 0x77, 0x78, 0x07, 0x77, 0x68, 0x03,
-  0x76, 0x28, 0x87, 0x70, 0x30, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83,
-  0x74, 0x70, 0x07, 0x73, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83,
-  0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca,
-  0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x40, 0x1d, 0xea, 0xa1, 0x1d, 0xe0,
-  0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x1e, 0x00,
-  0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87,
-  0x36, 0x70, 0x87, 0x70, 0x70, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87,
-  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea,
-  0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xce,
-  0xc1, 0x1d, 0xca, 0x81, 0x1c, 0xda, 0x40, 0x1f, 0xca, 0x41, 0x1e, 0xde,
-  0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8,
-  0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87,
-  0x77, 0x68, 0x03, 0x7a, 0x90, 0x87, 0x70, 0x80, 0x07, 0x78, 0x48, 0x07,
-  0x77, 0x38, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8,
-  0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0x62, 0x1e, 0xe8, 0x21, 0x1c, 0xc6,
-  0x61, 0x1d, 0xda, 0x00, 0x1e, 0xe4, 0xe1, 0x1d, 0xe8, 0xa1, 0x1c, 0xc6,
-  0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0x40, 0x1c, 0xea, 0xc1, 0x1c, 0xcc,
-  0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xf4, 0xa1, 0x1c, 0x00,
-  0x3c, 0x00, 0x88, 0x7a, 0x70, 0x87, 0x79, 0x08, 0x07, 0x73, 0x28, 0x87,
+  0x44, 0x54, 0x45, 0x4e, 0x44, 0x54, 0x29, 0x00, 0x00, 0x00, 0x56, 0x41,
+  0x54, 0x54, 0x15, 0x00, 0x02, 0x00, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69,
+  0x6f, 0x6e, 0x00, 0x00, 0x80, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x00, 0x01,
+  0x80, 0x56, 0x41, 0x54, 0x59, 0x04, 0x00, 0x02, 0x00, 0x04, 0x06, 0x45,
+  0x4e, 0x44, 0x54, 0x35, 0x00, 0x00, 0x00, 0x56, 0x41, 0x54, 0x54, 0x20,
+  0x00, 0x03, 0x00, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x00,
+  0x00, 0x80, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x00, 0x01, 0x80, 0x74, 0x65,
+  0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x00, 0x02, 0x80, 0x56, 0x41, 0x54,
+  0x59, 0x05, 0x00, 0x03, 0x00, 0x04, 0x06, 0x04, 0x45, 0x4e, 0x44, 0x54,
+  0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00,
+  0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54,
+  0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00,
+  0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54,
+  0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00,
+  0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54,
+  0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00,
+  0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54,
+  0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+  0x0c, 0x0d, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde,
+  0x35, 0x14, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x62, 0x0c, 0x30, 0x24,
+  0x80, 0x10, 0x05, 0xc8, 0x14, 0x00, 0x00, 0x00, 0x21, 0x0c, 0x00, 0x00,
+  0x08, 0x03, 0x00, 0x00, 0x0b, 0x02, 0x21, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x13, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49,
+  0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19,
+  0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42,
+  0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88,
+  0x48, 0x90, 0x14, 0x20, 0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42,
+  0x04, 0x49, 0x0e, 0x90, 0x91, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c,
+  0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x29, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00,
+  0x85, 0x00, 0x00, 0x00, 0x1b, 0xc8, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff,
+  0x01, 0x90, 0x80, 0x8a, 0x18, 0x87, 0x77, 0x90, 0x07, 0x79, 0x28, 0x87,
+  0x71, 0xa0, 0x07, 0x76, 0xc8, 0x87, 0x36, 0x90, 0x87, 0x77, 0xa8, 0x07,
+  0x77, 0x20, 0x87, 0x72, 0x20, 0x87, 0x36, 0x20, 0x87, 0x74, 0xb0, 0x87,
+  0x74, 0x20, 0x87, 0x72, 0x68, 0x83, 0x79, 0x88, 0x07, 0x79, 0xa0, 0x87,
   0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07,
-  0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xea, 0x61, 0x1e, 0xca,
-  0xa1, 0x0d, 0xe6, 0xe1, 0x1d, 0xcc, 0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xd8,
-  0xe1, 0x1d, 0xc2, 0x81, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87,
-  0x72, 0x00, 0x36, 0x2c, 0x82, 0x00, 0x24, 0xc0, 0x02, 0x54, 0x41, 0x1a,
-  0x80, 0xc2, 0x86, 0x65, 0x18, 0x80, 0x04, 0x58, 0x80, 0x2a, 0x48, 0x03,
-  0x50, 0x00, 0x49, 0x18, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x86,
-  0x40, 0x18, 0x00, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x1b, 0x00,
-  0x00, 0x00, 0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22,
-  0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c,
-  0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x40, 0x33, 0x00, 0xc3, 0x08,
-  0x04, 0x60, 0x85, 0x00, 0x86, 0x11, 0x04, 0x20, 0x09, 0xc2, 0x4c, 0xd4,
-  0x3c, 0xd0, 0x83, 0x3c, 0xd4, 0xc3, 0x38, 0xd0, 0x83, 0x1b, 0xb4, 0x43,
-  0x39, 0xd0, 0x43, 0x38, 0xb0, 0x83, 0x1e, 0xe8, 0x41, 0x3b, 0x84, 0x03,
-  0x3d, 0xc8, 0x43, 0x3a, 0xe0, 0x03, 0x0a, 0xc8, 0x20, 0x42, 0x21, 0x14,
-  0x42, 0x0c, 0x63, 0xe8, 0x0c, 0x04, 0xcc, 0x11, 0x80, 0x41, 0x0a, 0xa8,
-  0x39, 0x02, 0x50, 0x18, 0x44, 0x08, 0x84, 0x61, 0x04, 0x42, 0x19, 0x01,
-  0x00, 0x00, 0x13, 0xbe, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68,
-  0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78,
-  0x87, 0x79, 0x88, 0x83, 0x39, 0x70, 0x03, 0x38, 0x70, 0x03, 0x38, 0x68,
-  0x83, 0x79, 0x48, 0x87, 0x76, 0xa8, 0x07, 0x76, 0x08, 0x07, 0x7a, 0x78,
-  0x07, 0x79, 0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06, 0xf0, 0xa0, 0x07, 0x76,
-  0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d,
-  0x90, 0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9,
-  0x80, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x71,
-  0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d,
-  0x90, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73,
-  0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74,
-  0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a,
-  0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x76,
-  0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d,
-  0x60, 0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71,
-  0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07, 0x7a, 0x30, 0x07, 0x72,
-  0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x73, 0x20, 0x07, 0x7a,
-  0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x74,
-  0x80, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d,
-  0x60, 0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
-  0x40, 0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x72,
-  0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71,
-  0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71,
-  0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x79, 0x20, 0x07, 0x7a,
-  0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x6d,
-  0x60, 0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76,
-  0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x50, 0x07, 0x71,
-  0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71,
-  0x20, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x7a,
-  0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72,
-  0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a,
-  0x30, 0x07, 0x72, 0xa0, 0x11, 0xc2, 0x90, 0x10, 0xdb, 0x95, 0x3f, 0xeb,
-  0x2c, 0xc8, 0xf0, 0x57, 0x44, 0x34, 0x11, 0xd7, 0x90, 0x08, 0x80, 0x0e,
-  0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x90, 0xd8,
-  0x20, 0x50, 0x54, 0x5d, 0x00, 0x00, 0x20, 0x0b, 0x04, 0x00, 0x0a, 0x00,
-  0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09,
-  0x26, 0x47, 0xc6, 0x04, 0x43, 0x52, 0x45, 0x50, 0x02, 0x85, 0x30, 0x02,
-  0x50, 0x80, 0x01, 0x05, 0x52, 0x06, 0xc4, 0x46, 0x00, 0x68, 0x8d, 0x25,
-  0x38, 0x02, 0x00, 0x00, 0x00, 0x00, 0xb1, 0x18, 0x00, 0x00, 0x7b, 0x00,
-  0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01,
-  0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78,
-  0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4,
-  0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c,
-  0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03,
-  0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70,
-  0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70,
-  0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec,
-  0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0,
-  0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d,
-  0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43,
-  0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0,
-  0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68,
-  0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28,
-  0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08,
-  0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee,
-  0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62,
-  0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c,
-  0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06,
-  0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43,
-  0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3,
-  0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3,
-  0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68,
-  0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce,
-  0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3,
-  0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d,
-  0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e,
-  0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51,
-  0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60,
-  0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98,
-  0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e,
-  0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e,
-  0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83,
-  0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2,
-  0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a,
-  0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28,
-  0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5,
-  0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17,
-  0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83,
-  0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3,
-  0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3,
-  0x3c, 0x00, 0x79, 0x20, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, 0x32, 0x9a,
-  0x08, 0x14, 0x02, 0x85, 0x8c, 0x27, 0x46, 0x46, 0xc8, 0x11, 0x32, 0x64,
-  0xd4, 0x36, 0x0c, 0x6f, 0x00, 0x00, 0x8b, 0xe2, 0x06, 0xc5, 0xc6, 0x91,
-  0x01, 0x13, 0x19, 0x0c, 0xe2, 0x14, 0x09, 0x24, 0x79, 0x86, 0xf2, 0x20,
-  0xd1, 0x85, 0x28, 0x09, 0x00, 0x00, 0x53, 0x44, 0x4b, 0x20, 0x56, 0x65,
-  0x72, 0x73, 0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68, 0x61, 0x72, 0x5f, 0x73,
-  0x69, 0x7a, 0x65, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x4c, 0x4c, 0x56,
-  0x4d, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x33, 0x31,
-  0x30, 0x30, 0x31, 0x2e, 0x34, 0x33, 0x20, 0x28, 0x6d, 0x65, 0x74, 0x61,
-  0x6c, 0x66, 0x65, 0x2d, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x34, 0x33,
+  0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1c, 0xd2,
+  0x61, 0x1e, 0xc2, 0x41, 0x1c, 0xd8, 0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xc2,
+  0x21, 0x1d, 0xd8, 0xa1, 0x0d, 0xc6, 0x21, 0x1c, 0xd8, 0x81, 0x1d, 0xe6,
+  0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x60, 0x87,
+  0x72, 0x98, 0x87, 0x79, 0x68, 0x03, 0x78, 0x90, 0x87, 0x72, 0x18, 0x87,
+  0x74, 0x98, 0x87, 0x72, 0x68, 0x03, 0x73, 0x80, 0x87, 0x76, 0x08, 0x07,
+  0x72, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc,
+  0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda,
+  0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda,
+  0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87,
+  0x72, 0x00, 0x06, 0x77, 0x78, 0x87, 0x36, 0x30, 0x07, 0x79, 0x08, 0x87,
+  0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77, 0x48, 0x07, 0x77, 0xa0, 0x87,
+  0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76, 0x48, 0x87, 0x76, 0x68, 0x03,
+  0x77, 0x78, 0x07, 0x77, 0x68, 0x03, 0x76, 0x28, 0x87, 0x70, 0x30, 0x07,
+  0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x74, 0x70, 0x07, 0x73, 0x98, 0x87,
+  0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07,
+  0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda,
+  0x40, 0x1d, 0xea, 0xa1, 0x1d, 0xe0, 0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xc4,
+  0x81, 0x1d, 0xca, 0x61, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87,
+  0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x70, 0x87, 0x70, 0x70, 0x87,
+  0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07,
+  0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde,
+  0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xce, 0xc1, 0x1d, 0xca, 0x81, 0x1c, 0xda,
+  0x40, 0x1f, 0xca, 0x41, 0x1e, 0xde, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0,
+  0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87,
+  0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x7a, 0x90, 0x87,
+  0x70, 0x80, 0x07, 0x78, 0x48, 0x07, 0x77, 0x38, 0x87, 0x36, 0x68, 0x87,
+  0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00,
+  0x62, 0x1e, 0xe8, 0x21, 0x1c, 0xc6, 0x61, 0x1d, 0xda, 0x00, 0x1e, 0xe4,
+  0xe1, 0x1d, 0xe8, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda,
+  0x40, 0x1c, 0xea, 0xc1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xe6,
+  0x21, 0x1d, 0xf4, 0xa1, 0x1c, 0x00, 0x3c, 0x00, 0x88, 0x7a, 0x70, 0x87,
+  0x79, 0x08, 0x07, 0x73, 0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83,
+  0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca,
+  0x01, 0x20, 0xea, 0x61, 0x1e, 0xca, 0xa1, 0x0d, 0xe6, 0xe1, 0x1d, 0xcc,
+  0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xd8, 0xe1, 0x1d, 0xc2, 0x81, 0x1e, 0x00,
+  0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x36, 0x2c, 0xc2, 0x00,
+  0x24, 0xc0, 0x02, 0x54, 0x41, 0x1a, 0x80, 0xc2, 0x86, 0x65, 0x20, 0x80,
+  0x04, 0x58, 0x80, 0x2a, 0x48, 0x03, 0x50, 0x00, 0x49, 0x18, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x13, 0x86, 0x40, 0x18, 0x00, 0x00, 0x00, 0x00,
+  0x89, 0x20, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09,
+  0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3,
+  0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c,
+  0x10, 0x40, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x60, 0x87, 0x10, 0xc0, 0x30,
+  0x82, 0x00, 0x24, 0x41, 0x98, 0x89, 0x9a, 0x07, 0x7a, 0x90, 0x87, 0x7a,
+  0x18, 0x07, 0x7a, 0x70, 0x83, 0x76, 0x28, 0x07, 0x7a, 0x08, 0x07, 0x76,
+  0xd0, 0x03, 0x3d, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x79, 0x48, 0x07, 0x7c,
+  0x40, 0x01, 0x19, 0x44, 0x28, 0x84, 0x52, 0x88, 0x11, 0x8c, 0xa1, 0x33,
+  0x10, 0x30, 0x47, 0x00, 0x06, 0x29, 0xa0, 0xe6, 0x08, 0x40, 0x61, 0x10,
+  0x21, 0x10, 0x86, 0x11, 0x08, 0x65, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x13, 0xbe, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70,
+  0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87, 0x79,
+  0x88, 0x83, 0x39, 0x70, 0x03, 0x38, 0x70, 0x03, 0x38, 0x68, 0x83, 0x79,
+  0x48, 0x87, 0x76, 0xa8, 0x07, 0x76, 0x08, 0x07, 0x7a, 0x78, 0x07, 0x79,
+  0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06, 0xf0, 0xa0, 0x07, 0x76, 0x40, 0x07,
+  0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x90, 0x0e,
+  0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9, 0x80, 0x07,
+  0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07,
+  0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x90, 0x0e,
+  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07,
+  0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07,
+  0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
+  0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x76, 0x40, 0x07,
+  0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f,
+  0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07,
+  0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
+  0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x74, 0x80, 0x07,
+  0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f,
+  0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
+  0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07,
+  0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x20, 0x07,
+  0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07,
+  0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x79, 0x20, 0x07, 0x7a, 0x20, 0x07,
+  0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x6d, 0x60, 0x0f,
+  0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07,
+  0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x50, 0x07, 0x71, 0x20, 0x07,
+  0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07,
+  0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x7a, 0x10, 0x07,
+  0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07,
+  0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07,
+  0x72, 0xa0, 0x11, 0xc2, 0x90, 0x10, 0xdb, 0x95, 0x3f, 0xeb, 0x2c, 0xc8,
+  0xf0, 0x57, 0x44, 0x34, 0x11, 0xd7, 0x90, 0x08, 0x80, 0x0e, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x90, 0xd8, 0x20, 0x50,
+  0x54, 0x61, 0x00, 0x00, 0x20, 0x0b, 0x04, 0x00, 0x0a, 0x00, 0x00, 0x00,
+  0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47,
+  0xc6, 0x04, 0x43, 0x52, 0x45, 0x50, 0x02, 0x85, 0x30, 0x02, 0x50, 0x80,
+  0x01, 0x05, 0x52, 0x06, 0xc4, 0x46, 0x00, 0x68, 0x8d, 0x25, 0x38, 0x04,
+  0x00, 0x00, 0x00, 0x00, 0xb1, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00,
+  0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88,
+  0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73,
+  0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e,
+  0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30,
+  0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8,
+  0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b,
+  0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76,
+  0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e,
+  0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e,
+  0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61,
+  0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4,
+  0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76,
+  0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37,
+  0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76,
+  0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71,
+  0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e,
+  0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1,
+  0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61,
+  0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90,
+  0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8,
+  0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc,
+  0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7,
+  0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78,
+  0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f,
+  0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f,
+  0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1,
+  0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0,
+  0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0,
+  0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b,
+  0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c,
+  0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61,
+  0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1,
+  0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc,
+  0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4,
+  0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79,
+  0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72,
+  0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e,
+  0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1,
+  0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8,
+  0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8,
+  0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00,
+  0x79, 0x20, 0x00, 0x00, 0xd1, 0x00, 0x00, 0x00, 0x32, 0x9a, 0x08, 0x14,
+  0x02, 0x85, 0x8c, 0x27, 0x46, 0x46, 0xc8, 0x11, 0x32, 0x64, 0xd4, 0x3c,
+  0xcc, 0x7c, 0x00, 0x00, 0x8b, 0x02, 0x07, 0xc5, 0xc6, 0x91, 0x01, 0x13,
+  0x19, 0x0c, 0x12, 0x59, 0x85, 0x53, 0x24, 0x90, 0xe4, 0x19, 0xca, 0x83,
+  0x44, 0x17, 0xa2, 0x24, 0x53, 0x44, 0x4b, 0x20, 0x56, 0x65, 0x72, 0x73,
+  0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68, 0x61, 0x72, 0x5f, 0x73, 0x69, 0x7a,
+  0x65, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x4c, 0x4c, 0x56, 0x4d, 0x20,
+  0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x33, 0x31, 0x30, 0x30,
+  0x31, 0x2e, 0x35, 0x30, 0x20, 0x28, 0x6d, 0x65, 0x74, 0x61, 0x6c, 0x66,
+  0x65, 0x2d, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x35, 0x30, 0x2e, 0x31,
   0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f,
   0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x64, 0x65, 0x6e, 0x6f, 0x72, 0x6d,
   0x73, 0x5f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72,
@@ -271,531 +273,547 @@ const unsigned char sdl_metallib[] = {
   0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34,
   0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x6e, 0x61, 0x6d, 0x65,
   0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x69, 0x72, 0x2e,
-  0x70, 0x6f, 0x69, 0x6e, 0x74, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x66, 0x6c,
-  0x6f, 0x61, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x53, 0x69, 0x7a, 0x65,
-  0x61, 0x69, 0x72, 0x2e, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x5f, 0x69,
-  0x6e, 0x70, 0x75, 0x74, 0x61, 0x69, 0x72, 0x2e, 0x6c, 0x6f, 0x63, 0x61,
-  0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x67, 0x65,
-  0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x5f, 0x5f, 0x61, 0x69,
-  0x72, 0x5f, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x68, 0x6f, 0x6c, 0x64, 0x65,
-  0x72, 0x5f, 0x5f, 0x29, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32, 0x61, 0x69,
-  0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x61, 0x69, 0x72, 0x2e,
-  0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61,
-  0x69, 0x72, 0x2e, 0x72, 0x65, 0x61, 0x64, 0x61, 0x69, 0x72, 0x2e, 0x61,
-  0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65,
-  0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65,
-  0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x66,
-  0x6c, 0x6f, 0x61, 0x74, 0x34, 0x78, 0x34, 0x70, 0x72, 0x6f, 0x6a, 0x65,
-  0x63, 0x74, 0x69, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f,
-  0x72, 0x6d, 0x23, 0x08, 0x4a, 0x30, 0x82, 0xb0, 0x24, 0x23, 0x08, 0x8a,
-  0x30, 0x82, 0xa0, 0x0c, 0x23, 0x08, 0x0a, 0x31, 0x82, 0x80, 0x00, 0x23,
-  0x08, 0x4a, 0x31, 0x82, 0xa0, 0x18, 0x23, 0x08, 0xca, 0x31, 0xc3, 0xc0,
-  0x05, 0xdd, 0x0c, 0x83, 0x27, 0x7c, 0x33, 0x04, 0xc3, 0x0c, 0x03, 0xc7,
-  0x81, 0xc1, 0x0c, 0x04, 0xe1, 0x79, 0x60, 0x30, 0x43, 0x50, 0xcc, 0x10,
-  0x18, 0x33, 0x04, 0xc7, 0x0c, 0x05, 0x92, 0x28, 0x0b, 0x33, 0x43, 0xd1,
-  0x24, 0xce, 0xf2, 0xcc, 0x20, 0xb4, 0x81, 0x1b, 0xcc, 0xa0, 0x80, 0x01,
-  0x14, 0x81, 0x81, 0x27, 0x25, 0xd3, 0xc2, 0xcc, 0x00, 0x79, 0x54, 0x25,
-  0x06, 0x11, 0xe7, 0x59, 0x97, 0x18, 0x60, 0x63, 0x90, 0x64, 0x8b, 0x36,
-  0x03, 0xc4, 0x51, 0x95, 0x18, 0x44, 0x64, 0xe0, 0x59, 0x97, 0x18, 0x60,
-  0x63, 0x90, 0x64, 0xcb, 0x36, 0xc3, 0x00, 0x07, 0x71, 0x20, 0x07, 0x33,
-  0x0c, 0x61, 0xf0, 0x06, 0x73, 0x20, 0x23, 0x81, 0x09, 0xba, 0x88, 0x8d,
-  0xcd, 0xae, 0xcd, 0xa5, 0xed, 0x8d, 0xac, 0x8e, 0xad, 0xcc, 0xc5, 0x8c,
-  0x2d, 0xec, 0x6c, 0x6e, 0x14, 0x81, 0x0c, 0xca, 0xe0, 0x14, 0x36, 0x36,
-  0xbb, 0x36, 0x97, 0x34, 0xb2, 0x32, 0x37, 0xba, 0x51, 0x02, 0x33, 0xb8,
-  0x25, 0x2c, 0x4d, 0xce, 0xc5, 0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x6d,
-  0x94, 0xe0, 0x0c, 0x8e, 0x0a, 0x4b, 0x93, 0x73, 0x61, 0x0b, 0x73, 0x3b,
-  0xab, 0x0b, 0x3b, 0x2b, 0xfb, 0xb2, 0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73,
-  0x1b, 0x25, 0x40, 0x83, 0x9b, 0xc2, 0xd2, 0xe4, 0x5c, 0xc6, 0xde, 0xda,
-  0xe0, 0xd2, 0xd8, 0xca, 0xbe, 0xde, 0xe0, 0xe8, 0xd2, 0xde, 0xdc, 0xe6,
-  0x46, 0x19, 0xd2, 0x40, 0x0d, 0xd6, 0xe0, 0x94, 0xb0, 0x34, 0x39, 0x17,
-  0xbb, 0x32, 0x39, 0xba, 0x32, 0xbc, 0x51, 0x82, 0x39, 0x00, 0xa9, 0x18,
-  0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x0a, 0x72, 0x28, 0x87, 0x77,
-  0x80, 0x07, 0x7a, 0x58, 0x70, 0x98, 0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb0,
-  0x43, 0x39, 0xd0, 0xc3, 0x82, 0xe6, 0x1c, 0xc6, 0xa1, 0x0d, 0xe8, 0x41,
-  0x1e, 0xc2, 0xc1, 0x1d, 0xe6, 0x21, 0x1d, 0xe8, 0x21, 0x1d, 0xde, 0xc1,
-  0x1d, 0x00, 0xd1, 0x10, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0xcc,
-  0x3c, 0xa4, 0x83, 0x3b, 0x9c, 0x03, 0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83,
-  0x3c, 0x94, 0x43, 0x38, 0x90, 0xc3, 0x01, 0x00, 0x00, 0x00, 0x61, 0x20,
-  0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00,
-  0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0xc4, 0x4a, 0xa0, 0x0c, 0x8a, 0x80,
-  0xdc, 0x08, 0xc0, 0x58, 0x44, 0x10, 0x04, 0xc1, 0x58, 0x84, 0x20, 0x08,
-  0xc2, 0x58, 0xc4, 0x30, 0x0c, 0x03, 0x81, 0x31, 0x02, 0x10, 0x04, 0x41,
-  0xfc, 0xa3, 0x30, 0x03, 0x40, 0x62, 0x06, 0x80, 0xc6, 0x0c, 0x00, 0x00,
-  0x00, 0x00, 0xf1, 0x30, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x22, 0x47,
-  0xc8, 0x90, 0x51, 0x0a, 0x84, 0x18, 0x00, 0x00, 0x00, 0x00, 0xcf, 0x03,
-  0x00, 0x00, 0x6f, 0x6d, 0x6e, 0x69, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x74,
-  0x20, 0x63, 0x68, 0x61, 0x72, 0x53, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20,
-  0x43, 0x2b, 0x2b, 0x20, 0x54, 0x42, 0x41, 0x41, 0x00, 0x00, 0x13, 0x04,
-  0x06, 0xd9, 0x10, 0xd8, 0xc1, 0x86, 0xa1, 0x0e, 0xf0, 0xe0, 0x0e, 0x36,
-  0x0c, 0x79, 0x90, 0x07, 0x77, 0x00, 0xbb, 0x10, 0x0c, 0x44, 0x41, 0x14,
-  0x84, 0xb2, 0x0b, 0xf1, 0x48, 0x96, 0x44, 0x41, 0x28, 0x83, 0x0c, 0xc3,
-  0xc1, 0x98, 0x10, 0x88, 0xff, 0x2e, 0xc4, 0x64, 0x69, 0x11, 0x05, 0xa1,
-  0x0c, 0x32, 0x1c, 0xcb, 0x63, 0x42, 0x20, 0xfe, 0x16, 0x14, 0xe0, 0xbf,
-  0x0b, 0x81, 0x6d, 0x1f, 0x45, 0x41, 0x28, 0x83, 0x0c, 0x0c, 0x34, 0x99,
-  0x10, 0x88, 0xbf, 0x15, 0x01, 0xf8, 0xef, 0x42, 0x74, 0x60, 0x40, 0x06,
-  0x1a, 0x05, 0xa1, 0x0c, 0x32, 0x44, 0xd5, 0x65, 0x42, 0x20, 0xfe, 0x56,
-  0x04, 0xe0, 0xbf, 0x0b, 0x11, 0x06, 0x65, 0x90, 0x06, 0x60, 0x40, 0x41,
-  0x28, 0x83, 0x0c, 0x81, 0xf6, 0x59, 0x50, 0x89, 0xff, 0x20, 0xc3, 0xc0,
-  0x81, 0x81, 0x05, 0x93, 0xf8, 0xdb, 0x10, 0x80, 0xff, 0x20, 0x83, 0xf1,
-  0x89, 0x81, 0x05, 0x91, 0xf8, 0xdb, 0x10, 0x80, 0xff, 0x20, 0x43, 0x22,
-  0x06, 0x64, 0x60, 0xc1, 0x23, 0xfe, 0x36, 0x04, 0xe0, 0xbf, 0x0b, 0xe1,
-  0x06, 0x72, 0x60, 0x07, 0x6c, 0x40, 0x41, 0x28, 0x83, 0x0c, 0xc1, 0x19,
-  0xb0, 0x81, 0x05, 0x62, 0x20, 0xfe, 0x83, 0x0c, 0x43, 0x1a, 0xb4, 0x81,
-  0x05, 0x60, 0x20, 0xfe, 0x83, 0x0c, 0xc5, 0x1a, 0xb8, 0x81, 0x05, 0x9d,
-  0xf8, 0x0f, 0x32, 0x1c, 0x6d, 0xf0, 0x06, 0x16, 0x68, 0xe2, 0x3f, 0xc8,
-  0xa0, 0x07, 0x6d, 0x40, 0x07, 0x96, 0x05, 0xe2, 0x3f, 0xc8, 0xc0, 0x07,
-  0x6f, 0x50, 0x07, 0xe6, 0x04, 0xe2, 0x6f, 0xc9, 0x00, 0xfe, 0x16, 0x30,
-  0xe0, 0x6f, 0x41, 0x02, 0xfe, 0x16, 0x20, 0xe0, 0x6f, 0x41, 0x01, 0xfe,
-  0xb3, 0x0d, 0x77, 0x10, 0x00, 0xb3, 0x0d, 0x81, 0x1e, 0x04, 0x19, 0x04,
-  0xc4, 0x00, 0x09, 0x00, 0x00, 0x00, 0x5b, 0x86, 0x20, 0xc8, 0x83, 0x2d,
-  0xc3, 0x10, 0xe4, 0xc1, 0x96, 0xe1, 0x08, 0xf2, 0x60, 0xcb, 0xc0, 0x04,
-  0x79, 0xb0, 0x65, 0x88, 0x82, 0x3c, 0xd8, 0x32, 0x58, 0x41, 0x1e, 0x6c,
-  0x19, 0xc6, 0x20, 0xc8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20,
-  0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x32, 0x0e, 0x10, 0x22, 0x84, 0x00,
-  0x81, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x0c,
-  0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0xe8, 0x00, 0x00,
-  0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x08, 0x00,
-  0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x01, 0x00,
-  0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00,
-  0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
-  0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
-  0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x24, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x5d, 0x0c, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x12, 0x03,
-  0x94, 0x77, 0x00, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x53, 0x6f,
-  0x6c, 0x69, 0x64, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x33, 0x31,
-  0x30, 0x30, 0x31, 0x2e, 0x34, 0x33, 0x61, 0x69, 0x72, 0x36, 0x34, 0x2d,
-  0x61, 0x70, 0x70, 0x6c, 0x65, 0x2d, 0x69, 0x6f, 0x73, 0x31, 0x33, 0x2e,
-  0x30, 0x2e, 0x30, 0x2d, 0x73, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x6f,
-  0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0,
-  0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0xcc, 0x0c,
-  0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x35, 0x14,
-  0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x62, 0x0c, 0x30, 0x24, 0x80, 0x10,
-  0x05, 0xc8, 0x14, 0x00, 0x00, 0x00, 0x21, 0x0c, 0x00, 0x00, 0xf9, 0x02,
-  0x00, 0x00, 0x0b, 0x02, 0x21, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00,
-  0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10,
-  0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04,
-  0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10,
-  0x32, 0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88, 0x48, 0x90,
-  0x14, 0x20, 0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0x04, 0x49,
-  0x0e, 0x90, 0x91, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83,
-  0xe5, 0x8a, 0x04, 0x29, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x85, 0x00,
-  0x00, 0x00, 0x1b, 0xc8, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90,
-  0x80, 0x8a, 0x18, 0x87, 0x77, 0x90, 0x07, 0x79, 0x28, 0x87, 0x71, 0xa0,
-  0x07, 0x76, 0xc8, 0x87, 0x36, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x77, 0x20,
-  0x87, 0x72, 0x20, 0x87, 0x36, 0x20, 0x87, 0x74, 0xb0, 0x87, 0x74, 0x20,
-  0x87, 0x72, 0x68, 0x83, 0x79, 0x88, 0x07, 0x79, 0xa0, 0x87, 0x36, 0x30,
-  0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0xc0, 0x1c,
-  0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1c, 0xd2, 0x61, 0x1e,
-  0xc2, 0x41, 0x1c, 0xd8, 0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xc2, 0x21, 0x1d,
-  0xd8, 0xa1, 0x0d, 0xc6, 0x21, 0x1c, 0xd8, 0x81, 0x1d, 0xe6, 0x01, 0x30,
-  0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x60, 0x87, 0x72, 0x98,
-  0x87, 0x79, 0x68, 0x03, 0x78, 0x90, 0x87, 0x72, 0x18, 0x87, 0x74, 0x98,
-  0x87, 0x72, 0x68, 0x03, 0x73, 0x80, 0x87, 0x76, 0x08, 0x07, 0x72, 0x00,
-  0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
-  0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e,
-  0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c,
-  0xd8, 0x21, 0x1d, 0xda, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00,
-  0x06, 0x77, 0x78, 0x87, 0x36, 0x30, 0x07, 0x79, 0x08, 0x87, 0x76, 0x28,
-  0x87, 0x36, 0x80, 0x87, 0x77, 0x48, 0x07, 0x77, 0xa0, 0x87, 0x72, 0x90,
-  0x87, 0x36, 0x28, 0x07, 0x76, 0x48, 0x87, 0x76, 0x68, 0x03, 0x77, 0x78,
-  0x07, 0x77, 0x68, 0x03, 0x76, 0x28, 0x87, 0x70, 0x30, 0x07, 0x80, 0x70,
-  0x87, 0x77, 0x68, 0x83, 0x74, 0x70, 0x07, 0x73, 0x98, 0x87, 0x36, 0x30,
-  0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e,
-  0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x40, 0x1d,
-  0xea, 0xa1, 0x1d, 0xe0, 0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xc4, 0x81, 0x1d,
-  0xca, 0x61, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00,
-  0x08, 0x77, 0x78, 0x87, 0x36, 0x70, 0x87, 0x70, 0x70, 0x87, 0x79, 0x68,
-  0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00,
-  0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d,
-  0xe6, 0x21, 0x1d, 0xce, 0xc1, 0x1d, 0xca, 0x81, 0x1c, 0xda, 0x40, 0x1f,
-  0xca, 0x41, 0x1e, 0xde, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d,
-  0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28,
-  0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x7a, 0x90, 0x87, 0x70, 0x80,
-  0x07, 0x78, 0x48, 0x07, 0x77, 0x38, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0,
-  0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0x62, 0x1e,
-  0xe8, 0x21, 0x1c, 0xc6, 0x61, 0x1d, 0xda, 0x00, 0x1e, 0xe4, 0xe1, 0x1d,
-  0xe8, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0x40, 0x1c,
-  0xea, 0xc1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xe6, 0x21, 0x1d,
-  0xf4, 0xa1, 0x1c, 0x00, 0x3c, 0x00, 0x88, 0x7a, 0x70, 0x87, 0x79, 0x08,
-  0x07, 0x73, 0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08,
-  0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20,
-  0xea, 0x61, 0x1e, 0xca, 0xa1, 0x0d, 0xe6, 0xe1, 0x1d, 0xcc, 0x81, 0x1e,
-  0xda, 0xc0, 0x1c, 0xd8, 0xe1, 0x1d, 0xc2, 0x81, 0x1e, 0x00, 0x73, 0x08,
-  0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x36, 0x2c, 0xc2, 0x00, 0x24, 0xc0,
-  0x02, 0x54, 0x41, 0x1a, 0x80, 0xc2, 0x86, 0x65, 0x20, 0x80, 0x04, 0x58,
-  0x80, 0x2a, 0x48, 0x03, 0x50, 0x00, 0x49, 0x18, 0x00, 0x00, 0x02, 0x00,
-  0x00, 0x00, 0x13, 0x86, 0x40, 0x18, 0x00, 0x00, 0x00, 0x00, 0x89, 0x20,
-  0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09, 0x20, 0x64,
-  0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1,
-  0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x40,
-  0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00, 0x56, 0x08, 0x22,
-  0x09, 0xc2, 0x4c, 0xd4, 0x3c, 0xd0, 0x83, 0x3c, 0xd4, 0xc3, 0x38, 0xd0,
-  0x83, 0x1b, 0xb4, 0x43, 0x39, 0xd0, 0x43, 0x38, 0xb0, 0x83, 0x1e, 0xe8,
-  0x41, 0x3b, 0x84, 0x03, 0x3d, 0xc8, 0x43, 0x3a, 0xe0, 0x03, 0x0a, 0xc8,
-  0x20, 0x42, 0x21, 0x94, 0x62, 0x08, 0x61, 0x0c, 0x9d, 0x81, 0x80, 0x39,
-  0x02, 0x30, 0x48, 0x01, 0x35, 0x47, 0x00, 0x0a, 0x83, 0x08, 0x81, 0x30,
-  0x8c, 0x40, 0x28, 0x23, 0x00, 0x00, 0x13, 0xbe, 0x70, 0x48, 0x07, 0x79,
-  0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72,
-  0x68, 0x83, 0x74, 0x78, 0x87, 0x79, 0x88, 0x83, 0x39, 0x70, 0x03, 0x38,
-  0x70, 0x03, 0x38, 0x68, 0x83, 0x79, 0x48, 0x87, 0x76, 0xa8, 0x07, 0x76,
-  0x08, 0x07, 0x7a, 0x78, 0x07, 0x79, 0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06,
-  0xf0, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07,
-  0x76, 0x40, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07,
-  0x78, 0xd0, 0x06, 0xe9, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07,
-  0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07,
-  0x71, 0x60, 0x07, 0x6d, 0x90, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
-  0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e,
-  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07,
-  0x6d, 0x60, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07,
-  0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07,
-  0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07,
-  0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f,
-  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07,
-  0x6d, 0x60, 0x0f, 0x74, 0x80, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07,
-  0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07,
-  0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07,
-  0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07,
-  0x6d, 0x60, 0x0f, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07,
-  0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07,
-  0x79, 0x20, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07,
-  0x75, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07,
-  0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06,
-  0xf6, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07,
-  0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07,
-  0x72, 0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07,
-  0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07,
-  0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x11, 0xc2, 0x90, 0x0f,
-  0xdb, 0x95, 0x3f, 0xe7, 0x3c, 0xd8, 0x5f, 0x11, 0xd1, 0x44, 0x5c, 0x43,
-  0x22, 0xe0, 0x39, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
-  0x00, 0x40, 0x62, 0x83, 0x40, 0xd1, 0x7d, 0x01, 0x00, 0x80, 0x2c, 0x10,
-  0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11,
-  0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x52, 0x45, 0x50,
-  0x02, 0x85, 0x30, 0x02, 0x50, 0x80, 0x01, 0x05, 0x52, 0x06, 0xc4, 0x46,
-  0x00, 0x68, 0x8d, 0x25, 0x38, 0x02, 0x00, 0x00, 0x00, 0x00, 0xb1, 0x18,
-  0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1,
-  0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42,
-  0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f,
-  0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1,
-  0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84,
-  0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc,
-  0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70,
-  0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19,
-  0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f,
-  0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21,
-  0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc,
-  0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84,
-  0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37,
-  0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70,
-  0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77,
-  0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79,
-  0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e,
-  0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1,
-  0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81,
-  0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98,
-  0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88,
-  0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4,
-  0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72,
-  0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74,
-  0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e,
-  0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e,
-  0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21,
-  0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01,
-  0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc,
-  0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77,
-  0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e,
-  0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1,
-  0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61,
-  0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0,
-  0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0,
-  0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74,
-  0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e,
-  0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41,
-  0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50,
-  0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c,
-  0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc,
-  0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x79, 0x20, 0x00, 0x00, 0xc7, 0x00,
-  0x00, 0x00, 0x32, 0x9a, 0x08, 0x14, 0x02, 0x85, 0x8c, 0x27, 0x46, 0x46,
-  0xc8, 0x11, 0x32, 0x64, 0xd4, 0x36, 0xcc, 0x75, 0x00, 0x00, 0x8b, 0xe2,
-  0x06, 0xc5, 0xc6, 0x91, 0x01, 0x13, 0x19, 0x0c, 0x12, 0x65, 0x06, 0x02,
-  0x49, 0x9e, 0xf2, 0x20, 0xd1, 0x85, 0x28, 0x09, 0x00, 0x00, 0x53, 0x44,
-  0x4b, 0x20, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68,
-  0x61, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x41, 0x70, 0x70, 0x6c, 0x65,
-  0x20, 0x4c, 0x4c, 0x56, 0x4d, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f,
-  0x6e, 0x20, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x34, 0x33, 0x20, 0x28,
-  0x6d, 0x65, 0x74, 0x61, 0x6c, 0x66, 0x65, 0x2d, 0x33, 0x31, 0x30, 0x30,
-  0x31, 0x2e, 0x34, 0x33, 0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x61, 0x69,
-  0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x64, 0x65,
-  0x6e, 0x6f, 0x72, 0x6d, 0x73, 0x5f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c,
-  0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65,
-  0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65,
-  0x6e, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d,
-  0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x62, 0x75,
-  0x66, 0x66, 0x65, 0x72, 0x5f, 0x66, 0x65, 0x74, 0x63, 0x68, 0x5f, 0x65,
-  0x6e, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x6f, 0x73,
-  0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67,
-  0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x66, 0x6c,
-  0x6f, 0x61, 0x74, 0x34, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f,
-  0x6e, 0x61, 0x6d, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e,
-  0x61, 0x69, 0x72, 0x2e, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x5f, 0x6f,
-  0x75, 0x74, 0x70, 0x75, 0x74, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74,
-  0x65, 0x64, 0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64,
-  0x44, 0x76, 0x32, 0x5f, 0x66, 0x29, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32,
-  0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x61, 0x69, 0x72, 0x2e,
+  0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x5f, 0x6f, 0x75, 0x74, 0x70, 0x75,
+  0x74, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x35,
+  0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66, 0x29, 0x63,
+  0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x6f, 0x69, 0x6e,
+  0x74, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x70,
+  0x6f, 0x69, 0x6e, 0x74, 0x53, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e,
   0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74,
   0x61, 0x69, 0x72, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e,
   0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61,
   0x74, 0x65, 0x64, 0x28, 0x5f, 0x5f, 0x61, 0x69, 0x72, 0x5f, 0x70, 0x6c,
   0x61, 0x63, 0x65, 0x68, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x5f, 0x5f, 0x29,
-  0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x61, 0x69,
-  0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a,
-  0x65, 0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x61, 0x64, 0x61, 0x69, 0x72,
-  0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x73, 0x69,
-  0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79,
-  0x70, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69, 0x7a,
-  0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x78, 0x34, 0x70, 0x72, 0x6f,
-  0x6a, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x6e, 0x73,
-  0x66, 0x6f, 0x72, 0x6d, 0x00, 0x00, 0x04, 0x4a, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x30, 0x82, 0xa0, 0x04, 0x23, 0x08, 0x4b, 0x32, 0x82, 0xa0,
-  0x08, 0x23, 0x08, 0xca, 0x30, 0x82, 0xa0, 0x10, 0x23, 0x08, 0x08, 0x30,
-  0x82, 0xa0, 0x14, 0x23, 0x08, 0x8a, 0x31, 0x82, 0xa0, 0x1c, 0x33, 0x0c,
-  0x5c, 0xd0, 0xcd, 0x30, 0x78, 0xc2, 0x37, 0x43, 0x30, 0xcc, 0x30, 0x70,
-  0x1c, 0x18, 0xcc, 0x40, 0x10, 0x9e, 0x07, 0x06, 0x33, 0x04, 0xc5, 0x0c,
-  0x81, 0x31, 0x43, 0x70, 0xcc, 0x50, 0x20, 0x89, 0xb2, 0x30, 0x33, 0x18,
-  0x8d, 0x93, 0x3c, 0x0b, 0x34, 0x83, 0xd0, 0x06, 0x6e, 0x30, 0x83, 0x02,
-  0x06, 0x91, 0x04, 0x06, 0xde, 0x94, 0x3c, 0x0b, 0x33, 0x83, 0xe2, 0x45,
-  0x92, 0xe7, 0x4d, 0xc9, 0xb3, 0x40, 0x33, 0x40, 0x1c, 0x55, 0x89, 0x81,
-  0xc4, 0x79, 0xd6, 0x25, 0x06, 0xd8, 0x18, 0x24, 0xd9, 0xa2, 0xcd, 0x00,
-  0x91, 0x01, 0x55, 0x89, 0x81, 0x44, 0x06, 0x9e, 0x75, 0x89, 0x01, 0x36,
-  0x06, 0x49, 0xb6, 0x6c, 0x33, 0x10, 0x70, 0x10, 0x07, 0x72, 0x30, 0x07,
-  0x33, 0x0c, 0x61, 0xf0, 0x06, 0x74, 0x50, 0x1a, 0xc0, 0x71, 0x1c, 0xc7,
-  0x71, 0x1c, 0xc7, 0x89, 0x81, 0x18, 0x58, 0x68, 0xe0, 0x06, 0x96, 0x65,
-  0xb9, 0x01, 0x1d, 0xa0, 0x01, 0x2e, 0xb0, 0x82, 0x48, 0xb8, 0x04, 0x28,
-  0xc8, 0x48, 0x60, 0x82, 0x2e, 0x62, 0x63, 0xb3, 0x6b, 0x73, 0x69, 0x7b,
-  0x23, 0xab, 0x63, 0x2b, 0x73, 0x31, 0x63, 0x0b, 0x3b, 0x9b, 0x1b, 0x45,
-  0x20, 0x83, 0x32, 0x38, 0x85, 0x8d, 0xcd, 0xae, 0xcd, 0x25, 0x8d, 0xac,
-  0xcc, 0x8d, 0x6e, 0x94, 0xc0, 0x0c, 0x6e, 0x09, 0x4b, 0x93, 0x73, 0xb1,
-  0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73, 0x1b, 0x25, 0x38, 0x83, 0xa3, 0xc2,
-  0xd2, 0xe4, 0x5c, 0xd8, 0xc2, 0xdc, 0xce, 0xea, 0xc2, 0xce, 0xca, 0xbe,
-  0xec, 0xca, 0xe4, 0xe6, 0xd2, 0xde, 0xdc, 0x46, 0x09, 0xd0, 0xe0, 0xa6,
-  0xb0, 0x34, 0x39, 0x97, 0xb1, 0xb7, 0x36, 0xb8, 0x34, 0xb6, 0xb2, 0xaf,
-  0x37, 0x38, 0xba, 0xb4, 0x37, 0xb7, 0xb9, 0x51, 0x86, 0x34, 0x50, 0x83,
-  0x35, 0x38, 0x25, 0x2c, 0x4d, 0xce, 0xc5, 0xae, 0x4c, 0x8e, 0xae, 0x0c,
-  0x6f, 0x94, 0x80, 0x0e, 0x00, 0x00, 0xa9, 0x18, 0x00, 0x00, 0x0b, 0x00,
-  0x00, 0x00, 0x0b, 0x0a, 0x72, 0x28, 0x87, 0x77, 0x80, 0x07, 0x7a, 0x58,
-  0x70, 0x98, 0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb0, 0x43, 0x39, 0xd0, 0xc3,
-  0x82, 0xe6, 0x1c, 0xc6, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0xc1, 0x1d,
-  0xe6, 0x21, 0x1d, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x00, 0xd1, 0x10,
-  0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0xcc, 0x3c, 0xa4, 0x83, 0x3b,
-  0x9c, 0x03, 0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83, 0x3c, 0x94, 0x43, 0x38,
-  0x90, 0xc3, 0x01, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x65, 0x00,
-  0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x09, 0x00,
-  0x00, 0x00, 0xc4, 0x4a, 0xa0, 0x0c, 0x8a, 0x80, 0xdc, 0x08, 0xc0, 0x58,
-  0x44, 0x10, 0x04, 0xc1, 0x58, 0x84, 0x20, 0x08, 0xc2, 0x58, 0xc4, 0x30,
-  0x0c, 0x03, 0x85, 0x19, 0x00, 0x12, 0x33, 0x00, 0x34, 0x66, 0x00, 0x00,
-  0x00, 0x00, 0xf1, 0x30, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x22, 0x47,
-  0xc8, 0x90, 0x51, 0x0a, 0x84, 0x18, 0x00, 0x00, 0x00, 0x00, 0xcf, 0x03,
-  0x00, 0x00, 0x6f, 0x6d, 0x6e, 0x69, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x74,
-  0x20, 0x63, 0x68, 0x61, 0x72, 0x53, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20,
-  0x43, 0x2b, 0x2b, 0x20, 0x54, 0x42, 0x41, 0x41, 0x00, 0x00, 0x13, 0x04,
-  0x06, 0xd9, 0x10, 0xdc, 0xc1, 0x86, 0xc1, 0x0e, 0xf2, 0x00, 0x0f, 0x36,
-  0x0c, 0x7a, 0xa0, 0x07, 0x78, 0x00, 0xbb, 0x10, 0x0b, 0x44, 0x41, 0x14,
-  0x84, 0xb2, 0x0b, 0xe1, 0x48, 0x96, 0x44, 0x41, 0x28, 0x83, 0x0c, 0xc3,
-  0xb1, 0x98, 0x10, 0x88, 0xff, 0x2e, 0x84, 0x64, 0x69, 0x10, 0x05, 0xa1,
-  0x0c, 0x32, 0x1c, 0x8b, 0x63, 0x42, 0x20, 0xfe, 0x16, 0x14, 0xe0, 0xbf,
-  0x0b, 0x71, 0x6d, 0xdf, 0x44, 0x41, 0x28, 0x83, 0x0c, 0x0c, 0x24, 0x99,
-  0x10, 0x88, 0xbf, 0x15, 0x01, 0xf8, 0xef, 0x42, 0x70, 0x60, 0x40, 0x06,
-  0x19, 0x05, 0xa1, 0x0c, 0x32, 0x44, 0x95, 0x65, 0x42, 0x20, 0xfe, 0x56,
-  0x04, 0xe0, 0xbf, 0x0b, 0x01, 0x06, 0x65, 0x90, 0x06, 0x1f, 0x05, 0xa1,
-  0x0c, 0x32, 0x04, 0x9a, 0x67, 0x41, 0x25, 0xfe, 0x83, 0x0c, 0x03, 0xf7,
-  0x59, 0x30, 0x89, 0xbf, 0x0d, 0x01, 0xf8, 0x0f, 0x32, 0x18, 0x5f, 0x18,
-  0x58, 0x10, 0x89, 0xbf, 0x0d, 0x01, 0xf8, 0x0f, 0x32, 0x24, 0x62, 0x30,
-  0x06, 0x16, 0x3c, 0xe2, 0x6f, 0x43, 0x00, 0xfe, 0xbb, 0x10, 0x6d, 0x20,
-  0x07, 0x76, 0xb0, 0x06, 0x14, 0x84, 0x32, 0xc8, 0x10, 0x9c, 0xc1, 0x1a,
-  0x58, 0x20, 0x06, 0xe2, 0x3f, 0xc8, 0x30, 0xa4, 0x01, 0x1b, 0x58, 0x00,
-  0x06, 0xe2, 0x3f, 0xc8, 0x50, 0xac, 0x41, 0x1b, 0x58, 0xd0, 0x89, 0xff,
-  0x20, 0xc3, 0xd1, 0x06, 0x6e, 0x60, 0x81, 0x26, 0xfe, 0x83, 0x0c, 0x7a,
-  0xe0, 0x06, 0x73, 0x60, 0x59, 0x20, 0xfe, 0x83, 0x0c, 0x7c, 0x00, 0x07,
-  0x74, 0x60, 0x4e, 0x20, 0xfe, 0x96, 0x0c, 0xe0, 0x6f, 0x01, 0x03, 0xfe,
-  0x16, 0x24, 0xe0, 0x6f, 0x01, 0x02, 0xfe, 0x16, 0x14, 0xe0, 0x3f, 0xdb,
-  0x60, 0x07, 0x01, 0x30, 0xdb, 0x10, 0x8c, 0x42, 0x90, 0x41, 0x40, 0x0c,
-  0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x5b, 0x86, 0x20, 0xd0, 0x83, 0x2d,
-  0xc3, 0x10, 0xe8, 0xc1, 0x96, 0xe1, 0x08, 0xf4, 0x60, 0xcb, 0xc0, 0x04,
-  0x7a, 0xb0, 0x65, 0x88, 0x02, 0x3d, 0xd8, 0x32, 0x58, 0x81, 0x1e, 0x6c,
-  0x19, 0xc6, 0x20, 0xd0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20,
-  0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x32, 0x0e, 0x10, 0x22, 0x84, 0x00,
-  0x94, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x0c,
-  0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0xe8, 0x00, 0x00,
-  0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x08, 0x00,
-  0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x01, 0x00,
-  0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x00,
-  0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00,
-  0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00,
-  0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x24, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x5d, 0x0c, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x12, 0x03,
-  0x94, 0x76, 0x00, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x43, 0x6f,
-  0x70, 0x79, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x33, 0x31, 0x30,
-  0x30, 0x31, 0x2e, 0x34, 0x33, 0x61, 0x69, 0x72, 0x36, 0x34, 0x2d, 0x61,
-  0x70, 0x70, 0x6c, 0x65, 0x2d, 0x69, 0x6f, 0x73, 0x31, 0x33, 0x2e, 0x30,
-  0x2e, 0x30, 0x2d, 0x73, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x6f, 0x72,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00,
-  0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x6c, 0x0a, 0x00, 0x00, 0xff, 0xff,
-  0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x35, 0x14, 0x00, 0x00, 0x03, 0x00,
-  0x00, 0x00, 0x62, 0x0c, 0x30, 0x24, 0x80, 0x10, 0x05, 0xc8, 0x14, 0x00,
-  0x00, 0x00, 0x21, 0x0c, 0x00, 0x00, 0x60, 0x02, 0x00, 0x00, 0x0b, 0x02,
-  0x21, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x07, 0x81,
-  0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01,
-  0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x10,
-  0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0x84, 0x10, 0x32, 0x14, 0x38, 0x08,
-  0x18, 0x4b, 0x0a, 0x32, 0x42, 0x88, 0x48, 0x90, 0x14, 0x20, 0x43, 0x46,
-  0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0x04, 0x49, 0x0e, 0x90, 0x11, 0x22,
-  0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x21,
-  0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x83, 0x00, 0x00, 0x00, 0x1b, 0xcc,
-  0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x80, 0x03, 0x40, 0x02, 0x2a,
-  0x62, 0x1c, 0xde, 0x41, 0x1e, 0xe4, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xd8,
-  0x21, 0x1f, 0xda, 0x40, 0x1e, 0xde, 0xa1, 0x1e, 0xdc, 0x81, 0x1c, 0xca,
-  0x81, 0x1c, 0xda, 0x80, 0x1c, 0xd2, 0xc1, 0x1e, 0xd2, 0x81, 0x1c, 0xca,
-  0xa1, 0x0d, 0xe6, 0x21, 0x1e, 0xe4, 0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xe0,
-  0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x73, 0x08, 0x07,
-  0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x72, 0x48, 0x87, 0x79, 0x08, 0x07,
-  0x71, 0x60, 0x87, 0x72, 0x68, 0x03, 0x7a, 0x08, 0x87, 0x74, 0x60, 0x87,
-  0x36, 0x18, 0x87, 0x70, 0x60, 0x07, 0x76, 0x98, 0x07, 0xc0, 0x1c, 0xc2,
-  0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1d, 0xca, 0x61, 0x1e, 0xe6,
-  0xa1, 0x0d, 0xe0, 0x41, 0x1e, 0xca, 0x61, 0x1c, 0xd2, 0x61, 0x1e, 0xca,
-  0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0x21, 0x1c, 0xc8, 0x01, 0x30, 0x87,
-  0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03,
-  0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78, 0x78, 0x87,
-  0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72, 0x60, 0x87,
-  0x74, 0x68, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x18, 0xdc,
+  0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75,
+  0x66, 0x66, 0x65, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66,
+  0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x72,
+  0x65, 0x61, 0x64, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74,
+  0x79, 0x70, 0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e,
+  0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x61, 0x6c, 0x69,
+  0x67, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74,
+  0x34, 0x78, 0x34, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x69, 0x6f,
+  0x6e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x00, 0x00,
+  0xc4, 0x51, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x82, 0xa0, 0x04,
+  0x23, 0x08, 0x4b, 0x32, 0x82, 0xa0, 0x08, 0x23, 0x08, 0xca, 0x30, 0x82,
+  0xa0, 0x10, 0x23, 0x08, 0x08, 0x30, 0x82, 0xa0, 0x14, 0x23, 0x08, 0x8a,
+  0x31, 0x82, 0xa0, 0x1c, 0x33, 0x0c, 0x5f, 0x00, 0x06, 0x33, 0x0c, 0x61,
+  0x20, 0x88, 0xc1, 0x0c, 0xc1, 0x30, 0xc3, 0xf0, 0x7d, 0x63, 0x30, 0x03,
+  0x41, 0x84, 0x41, 0x18, 0x8c, 0xc1, 0x0c, 0x41, 0x31, 0x43, 0x60, 0xcc,
+  0x10, 0x1c, 0x33, 0x14, 0x48, 0xa2, 0x2c, 0xcc, 0x0c, 0x46, 0xe3, 0x24,
+  0xca, 0xf2, 0xcc, 0x50, 0x40, 0x49, 0xb4, 0x48, 0x33, 0x0c, 0x70, 0x10,
+  0x07, 0x72, 0x30, 0x83, 0x32, 0x06, 0x13, 0x35, 0x06, 0x61, 0x50, 0x25,
+  0xd6, 0xc2, 0xcc, 0xa0, 0x84, 0xc1, 0x44, 0x85, 0x41, 0x18, 0x54, 0x89,
+  0xb2, 0x3c, 0x33, 0x40, 0xdf, 0x85, 0x95, 0x01, 0xf5, 0x85, 0x41, 0xa6,
+  0x95, 0xc1, 0x66, 0x06, 0x09, 0xb7, 0x74, 0x33, 0x40, 0x67, 0x70, 0x61,
+  0x65, 0x40, 0x9d, 0x41, 0x18, 0x64, 0x5a, 0x19, 0x6c, 0x66, 0x90, 0x70,
+  0x8b, 0x37, 0x03, 0x41, 0x07, 0x75, 0x60, 0x07, 0x77, 0x30, 0xc3, 0x40,
+  0x06, 0x73, 0x80, 0x07, 0xb5, 0x01, 0x1c, 0xc7, 0x71, 0x1c, 0xc7, 0x71,
+  0x1c, 0x1a, 0xb8, 0x81, 0x85, 0x06, 0x7a, 0x60, 0x59, 0x96, 0x1b, 0xd0,
+  0x81, 0x1b, 0xd0, 0x81, 0x2f, 0xf8, 0x02, 0x4a, 0xd0, 0x04, 0x28, 0xc8,
+  0x48, 0x60, 0x82, 0x2e, 0x62, 0x63, 0xb3, 0x6b, 0x73, 0x69, 0x7b, 0x23,
+  0xab, 0x63, 0x2b, 0x73, 0x31, 0x63, 0x0b, 0x3b, 0x9b, 0x1b, 0x45, 0x38,
+  0x03, 0x34, 0x38, 0x85, 0x8d, 0xcd, 0xae, 0xcd, 0x25, 0x8d, 0xac, 0xcc,
+  0x8d, 0x6e, 0x94, 0x20, 0x0d, 0x6e, 0x09, 0x4b, 0x93, 0x73, 0xb1, 0x2b,
+  0x93, 0x9b, 0x4b, 0x7b, 0x73, 0x1b, 0x25, 0x50, 0x83, 0xa3, 0xc2, 0xd2,
+  0xe4, 0x5c, 0xd8, 0xc2, 0xdc, 0xce, 0xea, 0xc2, 0xce, 0xca, 0xbe, 0xec,
+  0xca, 0xe4, 0xe6, 0xd2, 0xde, 0xdc, 0x46, 0x09, 0xd6, 0xe0, 0xa6, 0xb0,
+  0x34, 0x39, 0x97, 0xb1, 0xb7, 0x36, 0xb8, 0x34, 0xb6, 0xb2, 0xaf, 0x37,
+  0x38, 0xba, 0xb4, 0x37, 0xb7, 0xb9, 0x51, 0x06, 0x36, 0x68, 0x03, 0x37,
+  0x38, 0x25, 0x2c, 0x4d, 0xce, 0xc5, 0xae, 0x4c, 0x8e, 0xae, 0x0c, 0x6f,
+  0x94, 0x00, 0x0f, 0x00, 0xa9, 0x18, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
+  0x0b, 0x0a, 0x72, 0x28, 0x87, 0x77, 0x80, 0x07, 0x7a, 0x58, 0x70, 0x98,
+  0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb0, 0x43, 0x39, 0xd0, 0xc3, 0x82, 0xe6,
+  0x1c, 0xc6, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0xc1, 0x1d, 0xe6, 0x21,
+  0x1d, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x00, 0xd1, 0x10, 0x00, 0x00,
+  0x06, 0x00, 0x00, 0x00, 0x07, 0xcc, 0x3c, 0xa4, 0x83, 0x3b, 0x9c, 0x03,
+  0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83, 0x3c, 0x94, 0x43, 0x38, 0x90, 0xc3,
+  0x01, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00,
+  0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
+  0xc4, 0x4a, 0xa0, 0x0c, 0x8a, 0x80, 0xdc, 0x08, 0xc0, 0x58, 0x44, 0x10,
+  0x04, 0xc1, 0x58, 0x84, 0x20, 0x08, 0xc2, 0x58, 0xc4, 0x30, 0x0c, 0x03,
+  0x81, 0x31, 0x02, 0x10, 0x04, 0x41, 0xfc, 0xa3, 0x30, 0x03, 0x40, 0x62,
+  0x06, 0x80, 0xc6, 0x0c, 0x00, 0x00, 0x00, 0x00, 0xf1, 0x30, 0x00, 0x00,
+  0x11, 0x00, 0x00, 0x00, 0x22, 0x47, 0xc8, 0x90, 0x51, 0x0a, 0x84, 0x18,
+  0x00, 0x00, 0x00, 0x00, 0xcf, 0x03, 0x00, 0x00, 0x6f, 0x6d, 0x6e, 0x69,
+  0x70, 0x6f, 0x74, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x68, 0x61, 0x72, 0x53,
+  0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x43, 0x2b, 0x2b, 0x20, 0x54, 0x42,
+  0x41, 0x41, 0x00, 0x00, 0x13, 0x04, 0x06, 0xd9, 0x10, 0xec, 0xc1, 0x86,
+  0x41, 0x0f, 0xfa, 0x80, 0x0f, 0x36, 0x0c, 0x7e, 0xe0, 0x07, 0x7c, 0x00,
+  0xbb, 0x10, 0x4c, 0x54, 0x45, 0x14, 0x84, 0xb2, 0x0b, 0xf1, 0x4c, 0xd7,
+  0x44, 0x41, 0x28, 0x83, 0x0c, 0xc3, 0xc1, 0x98, 0x10, 0x88, 0xff, 0x2e,
+  0xc4, 0x74, 0x6d, 0x11, 0x05, 0xa1, 0x0c, 0x32, 0x1c, 0xcb, 0x63, 0x42,
+  0x20, 0xfe, 0x16, 0x14, 0xe0, 0xbf, 0x0b, 0x81, 0x71, 0x60, 0x40, 0x51,
+  0x10, 0xca, 0x20, 0x03, 0x03, 0x4d, 0x26, 0x04, 0xe2, 0x6f, 0x45, 0x00,
+  0xfe, 0xbb, 0x10, 0x5d, 0x18, 0x94, 0x81, 0x46, 0x41, 0x28, 0x83, 0x0c,
+  0x51, 0x75, 0x99, 0x10, 0x88, 0xbf, 0x15, 0x01, 0xf8, 0xef, 0x42, 0x84,
+  0x81, 0x19, 0xa8, 0x01, 0x18, 0x50, 0x10, 0xca, 0x20, 0x43, 0xa0, 0x7d,
+  0x16, 0x54, 0xe2, 0x3f, 0xc8, 0x30, 0x70, 0x60, 0x60, 0xc1, 0x24, 0xfe,
+  0x36, 0x04, 0xe0, 0x3f, 0xc8, 0x60, 0x7c, 0x62, 0x60, 0x41, 0x24, 0xfe,
+  0x36, 0x04, 0xe0, 0x3f, 0xc8, 0x90, 0x88, 0x01, 0x19, 0x58, 0xf0, 0x88,
+  0xbf, 0x0d, 0x01, 0xf8, 0xef, 0x42, 0xb8, 0xc1, 0x1c, 0xdc, 0x01, 0x1b,
+  0x50, 0x10, 0xca, 0x20, 0x43, 0x70, 0x06, 0x6c, 0x60, 0x81, 0x18, 0x88,
+  0xff, 0x20, 0xc3, 0x90, 0x06, 0x6d, 0x60, 0x01, 0x18, 0x88, 0xff, 0x20,
+  0x43, 0xb1, 0x06, 0x6e, 0x60, 0x41, 0x27, 0xfe, 0x83, 0x0c, 0x47, 0x1b,
+  0xbc, 0x81, 0x05, 0x9a, 0xf8, 0x0f, 0x32, 0xec, 0x41, 0x1b, 0xd0, 0x81,
+  0x65, 0x81, 0xf8, 0x0f, 0x32, 0xf4, 0xc1, 0x1b, 0xd4, 0x81, 0x39, 0x81,
+  0xf8, 0x5b, 0x32, 0x80, 0xbf, 0x05, 0x0c, 0xf8, 0x5b, 0x90, 0x80, 0xbf,
+  0x05, 0x08, 0xf8, 0x5b, 0x50, 0x80, 0xff, 0x6c, 0xc3, 0x1d, 0x04, 0xc0,
+  0x6c, 0x43, 0x40, 0x0a, 0xc1, 0x6c, 0x43, 0xb0, 0x07, 0x42, 0x06, 0x01,
+  0x31, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x5b, 0x86, 0x20, 0xf0,
+  0x83, 0x2d, 0xc3, 0x10, 0xf8, 0xc1, 0x96, 0xe1, 0x08, 0xfc, 0x60, 0xcb,
+  0xc0, 0x04, 0x7e, 0xb0, 0x65, 0x88, 0x02, 0x3f, 0xd8, 0x32, 0x58, 0x81,
+  0x1f, 0x6c, 0x19, 0xc6, 0x20, 0xf0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x71, 0x20, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x32, 0x0e, 0x10, 0x22,
+  0x84, 0x00, 0x9f, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x65, 0x0c, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0xe8,
+  0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+  0x0a, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x1a, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x10, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x10, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x24, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x5d, 0x0c, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+  0x12, 0x03, 0x94, 0x79, 0x00, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4c, 0x5f,
+  0x53, 0x6f, 0x6c, 0x69, 0x64, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78,
+  0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x35, 0x30, 0x2e, 0x31, 0x61, 0x69,
+  0x72, 0x36, 0x34, 0x2d, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2d, 0x69, 0x6f,
+  0x73, 0x31, 0x33, 0x2e, 0x30, 0x2e, 0x30, 0x2d, 0x73, 0x69, 0x6d, 0x75,
+  0x6c, 0x61, 0x74, 0x6f, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+  0x10, 0x0d, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde,
+  0x35, 0x14, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x62, 0x0c, 0x30, 0x24,
+  0x80, 0x10, 0x05, 0xc8, 0x14, 0x00, 0x00, 0x00, 0x21, 0x0c, 0x00, 0x00,
+  0x0a, 0x03, 0x00, 0x00, 0x0b, 0x02, 0x21, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x13, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49,
+  0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19,
+  0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42,
+  0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88,
+  0x48, 0x90, 0x14, 0x20, 0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42,
+  0x04, 0x49, 0x0e, 0x90, 0x91, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c,
+  0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x29, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00,
+  0x85, 0x00, 0x00, 0x00, 0x1b, 0xc8, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff,
+  0x01, 0x90, 0x80, 0x8a, 0x18, 0x87, 0x77, 0x90, 0x07, 0x79, 0x28, 0x87,
+  0x71, 0xa0, 0x07, 0x76, 0xc8, 0x87, 0x36, 0x90, 0x87, 0x77, 0xa8, 0x07,
+  0x77, 0x20, 0x87, 0x72, 0x20, 0x87, 0x36, 0x20, 0x87, 0x74, 0xb0, 0x87,
+  0x74, 0x20, 0x87, 0x72, 0x68, 0x83, 0x79, 0x88, 0x07, 0x79, 0xa0, 0x87,
+  0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07,
+  0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1c, 0xd2,
+  0x61, 0x1e, 0xc2, 0x41, 0x1c, 0xd8, 0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xc2,
+  0x21, 0x1d, 0xd8, 0xa1, 0x0d, 0xc6, 0x21, 0x1c, 0xd8, 0x81, 0x1d, 0xe6,
+  0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x60, 0x87,
+  0x72, 0x98, 0x87, 0x79, 0x68, 0x03, 0x78, 0x90, 0x87, 0x72, 0x18, 0x87,
+  0x74, 0x98, 0x87, 0x72, 0x68, 0x03, 0x73, 0x80, 0x87, 0x76, 0x08, 0x07,
+  0x72, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc,
   0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda,
   0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda,
-  0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0xa1, 0x0d, 0xdc, 0xe1, 0x1d, 0xdc,
-  0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xc2, 0xc1, 0x1c, 0x00, 0xc2, 0x1d, 0xde,
-  0xa1, 0x0d, 0xd2, 0xc1, 0x1d, 0xcc, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0,
+  0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87,
+  0x72, 0x00, 0x06, 0x77, 0x78, 0x87, 0x36, 0x30, 0x07, 0x79, 0x08, 0x87,
+  0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77, 0x48, 0x07, 0x77, 0xa0, 0x87,
+  0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76, 0x48, 0x87, 0x76, 0x68, 0x03,
+  0x77, 0x78, 0x07, 0x77, 0x68, 0x03, 0x76, 0x28, 0x87, 0x70, 0x30, 0x07,
+  0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x74, 0x70, 0x07, 0x73, 0x98, 0x87,
+  0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07,
+  0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda,
+  0x40, 0x1d, 0xea, 0xa1, 0x1d, 0xe0, 0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xc4,
+  0x81, 0x1d, 0xca, 0x61, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87,
+  0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x70, 0x87, 0x70, 0x70, 0x87,
+  0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07,
+  0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde,
+  0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xce, 0xc1, 0x1d, 0xca, 0x81, 0x1c, 0xda,
+  0x40, 0x1f, 0xca, 0x41, 0x1e, 0xde, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0,
   0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87,
-  0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x75, 0xa8, 0x87,
-  0x76, 0x80, 0x87, 0x36, 0xa0, 0x87, 0x70, 0x10, 0x07, 0x76, 0x28, 0x87,
-  0x79, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc,
-  0xe1, 0x1d, 0xda, 0xc0, 0x1d, 0xc2, 0xc1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc,
-  0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07,
-  0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x98, 0x87,
-  0x74, 0x38, 0x07, 0x77, 0x28, 0x07, 0x72, 0x68, 0x03, 0x7d, 0x28, 0x07,
-  0x79, 0x78, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87,
+  0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x7a, 0x90, 0x87,
+  0x70, 0x80, 0x07, 0x78, 0x48, 0x07, 0x77, 0x38, 0x87, 0x36, 0x68, 0x87,
   0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00,
-  0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0x01, 0x1e, 0xe0,
-  0x21, 0x1d, 0xdc, 0xe1, 0x1c, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0,
-  0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x88, 0x79, 0xa0, 0x87,
-  0x70, 0x18, 0x87, 0x75, 0x68, 0x03, 0x78, 0x90, 0x87, 0x77, 0xa0, 0x87,
-  0x72, 0x18, 0x07, 0x7a, 0x78, 0x07, 0x79, 0x68, 0x03, 0x71, 0xa8, 0x07,
-  0x73, 0x30, 0x87, 0x72, 0x90, 0x87, 0x36, 0x98, 0x87, 0x74, 0xd0, 0x87,
-  0x72, 0x00, 0xf0, 0x00, 0x20, 0xea, 0xc1, 0x1d, 0xe6, 0x21, 0x1c, 0xcc,
-  0xa1, 0x1c, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8,
-  0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0xa8, 0x87,
-  0x79, 0x28, 0x87, 0x36, 0x98, 0x87, 0x77, 0x30, 0x07, 0x7a, 0x68, 0x03,
-  0x73, 0x60, 0x87, 0x77, 0x08, 0x07, 0x7a, 0x00, 0xcc, 0x21, 0x1c, 0xd8,
-  0x61, 0x1e, 0xca, 0x01, 0xd8, 0xb0, 0x08, 0x01, 0x90, 0x00, 0x0b, 0x50,
-  0x05, 0x69, 0x00, 0x01, 0x00, 0x00, 0x49, 0x18, 0x00, 0x00, 0x01, 0x00,
-  0x00, 0x00, 0x13, 0x84, 0x40, 0x00, 0x89, 0x20, 0x00, 0x00, 0x0e, 0x00,
-  0x00, 0x00, 0x32, 0x22, 0x08, 0x09, 0x20, 0x64, 0x85, 0x04, 0x13, 0x22,
-  0xa4, 0x84, 0x04, 0x13, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c,
-  0x88, 0x8c, 0x0b, 0x84, 0x84, 0x4c, 0x10, 0x28, 0x33, 0x00, 0xc3, 0x08,
-  0x04, 0x30, 0x88, 0x10, 0x04, 0x45, 0x08, 0xa1, 0x19, 0x08, 0x98, 0x23,
-  0x00, 0x83, 0x14, 0xb0, 0x39, 0x02, 0x50, 0x18, 0x01, 0x00, 0x13, 0xbe,
-  0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70, 0x80, 0x07,
-  0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87, 0x79, 0x88, 0x83,
-  0x39, 0x70, 0x03, 0x38, 0x70, 0x03, 0x38, 0x68, 0x83, 0x79, 0x48, 0x87,
-  0x76, 0xa8, 0x07, 0x76, 0x08, 0x07, 0x7a, 0x78, 0x07, 0x79, 0xd8, 0x70,
-  0x1b, 0xe5, 0xd0, 0x06, 0xf0, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60,
-  0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0,
-  0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9, 0x80, 0x07, 0x7a, 0x80,
-  0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a, 0x10,
-  0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x90, 0x0e, 0x73, 0x20,
-  0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90,
-  0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
-  0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0,
-  0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60,
-  0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x60,
-  0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x60,
-  0x0f, 0x72, 0x40, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20,
-  0x07, 0x6d, 0x60, 0x0f, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0,
-  0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x74, 0x80, 0x07, 0x7a, 0x60,
-  0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x76, 0x40,
-  0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60,
-  0x0f, 0x79, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10,
-  0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x20, 0x07, 0x78, 0xa0,
-  0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0,
-  0x06, 0xf6, 0x10, 0x07, 0x79, 0x20, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60,
-  0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x50,
-  0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50,
-  0x07, 0x76, 0xd0, 0x06, 0xf6, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50,
-  0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x6d, 0x60,
-  0x0f, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20,
-  0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x6d, 0xe0,
-  0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0,
-  0x11, 0xc2, 0x90, 0x12, 0xdb, 0x95, 0x3f, 0xeb, 0x2c, 0xc8, 0xf0, 0x17,
-  0x11, 0x60, 0x30, 0x44, 0x33, 0x0d, 0x89, 0x00, 0x69, 0x00, 0x00, 0x20,
-  0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x89, 0x0d, 0x02, 0x45,
-  0xc5, 0x04, 0x00, 0x00, 0xb2, 0x40, 0x08, 0x00, 0x00, 0x00, 0x32, 0x1e,
-  0x98, 0x10, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04,
-  0x43, 0xb2, 0x22, 0x28, 0x81, 0x42, 0x18, 0x01, 0x28, 0x10, 0xc2, 0x11,
-  0x00, 0xba, 0xb1, 0x04, 0x47, 0x00, 0xb1, 0x18, 0x00, 0x00, 0x7b, 0x00,
-  0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01,
-  0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78,
-  0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4,
-  0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c,
-  0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03,
-  0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70,
-  0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70,
-  0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec,
-  0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0,
-  0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d,
-  0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43,
-  0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0,
-  0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68,
-  0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28,
-  0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08,
-  0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee,
-  0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62,
-  0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c,
-  0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06,
-  0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43,
-  0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3,
-  0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3,
-  0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68,
-  0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce,
-  0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3,
-  0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d,
-  0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e,
-  0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51,
-  0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60,
-  0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98,
-  0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e,
-  0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e,
-  0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83,
-  0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2,
-  0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a,
-  0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28,
-  0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5,
-  0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17,
-  0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83,
-  0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3,
-  0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3,
-  0x3c, 0x00, 0x79, 0x20, 0x00, 0x00, 0x8b, 0x00, 0x00, 0x00, 0x32, 0x9a,
-  0x08, 0x14, 0x02, 0x85, 0x8c, 0x27, 0x46, 0x46, 0xc8, 0x11, 0x32, 0x64,
-  0xd4, 0x24, 0xa8, 0x54, 0x00, 0x00, 0x8b, 0xe2, 0x06, 0xc5, 0xc6, 0x91,
-  0x41, 0x14, 0x19, 0xca, 0x23, 0x21, 0xd1, 0xc5, 0x0c, 0x00, 0x53, 0x44,
-  0x4b, 0x20, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68,
-  0x61, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x41, 0x70, 0x70, 0x6c, 0x65,
-  0x20, 0x4c, 0x4c, 0x56, 0x4d, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f,
-  0x6e, 0x20, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x34, 0x33, 0x20, 0x28,
-  0x6d, 0x65, 0x74, 0x61, 0x6c, 0x66, 0x65, 0x2d, 0x33, 0x31, 0x30, 0x30,
-  0x31, 0x2e, 0x34, 0x33, 0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x61, 0x69,
+  0x62, 0x1e, 0xe8, 0x21, 0x1c, 0xc6, 0x61, 0x1d, 0xda, 0x00, 0x1e, 0xe4,
+  0xe1, 0x1d, 0xe8, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda,
+  0x40, 0x1c, 0xea, 0xc1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xe6,
+  0x21, 0x1d, 0xf4, 0xa1, 0x1c, 0x00, 0x3c, 0x00, 0x88, 0x7a, 0x70, 0x87,
+  0x79, 0x08, 0x07, 0x73, 0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83,
+  0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca,
+  0x01, 0x20, 0xea, 0x61, 0x1e, 0xca, 0xa1, 0x0d, 0xe6, 0xe1, 0x1d, 0xcc,
+  0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xd8, 0xe1, 0x1d, 0xc2, 0x81, 0x1e, 0x00,
+  0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x36, 0x2c, 0x02, 0x01,
+  0x24, 0xc0, 0x02, 0x54, 0x41, 0x1a, 0x80, 0xc2, 0x86, 0x65, 0x28, 0x80,
+  0x04, 0x58, 0x80, 0x2a, 0x48, 0x03, 0x50, 0x00, 0x49, 0x18, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x13, 0x86, 0x40, 0x18, 0x00, 0x00, 0x00, 0x00,
+  0x89, 0x20, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09,
+  0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3,
+  0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c,
+  0x10, 0x40, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00, 0x76,
+  0x08, 0x41, 0x24, 0x41, 0x98, 0x89, 0x9a, 0x07, 0x7a, 0x90, 0x87, 0x7a,
+  0x18, 0x07, 0x7a, 0x70, 0x83, 0x76, 0x28, 0x07, 0x7a, 0x08, 0x07, 0x76,
+  0xd0, 0x03, 0x3d, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x79, 0x48, 0x07, 0x7c,
+  0x40, 0x01, 0x19, 0x44, 0x28, 0x84, 0x62, 0x0c, 0x11, 0x84, 0x31, 0x74,
+  0x06, 0x02, 0xe6, 0x08, 0xc0, 0x20, 0x05, 0xd4, 0x1c, 0x01, 0x28, 0x0c,
+  0x22, 0x04, 0xc2, 0x30, 0x02, 0xa1, 0x8c, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x13, 0xbe, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70,
+  0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87, 0x79,
+  0x88, 0x83, 0x39, 0x70, 0x03, 0x38, 0x70, 0x03, 0x38, 0x68, 0x83, 0x79,
+  0x48, 0x87, 0x76, 0xa8, 0x07, 0x76, 0x08, 0x07, 0x7a, 0x78, 0x07, 0x79,
+  0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06, 0xf0, 0xa0, 0x07, 0x76, 0x40, 0x07,
+  0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x90, 0x0e,
+  0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9, 0x80, 0x07,
+  0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07,
+  0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x90, 0x0e,
+  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07,
+  0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07,
+  0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
+  0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x76, 0x40, 0x07,
+  0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f,
+  0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07,
+  0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
+  0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x74, 0x80, 0x07,
+  0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f,
+  0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
+  0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07,
+  0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x20, 0x07,
+  0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07,
+  0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x79, 0x20, 0x07, 0x7a, 0x20, 0x07,
+  0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x6d, 0x60, 0x0f,
+  0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07,
+  0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x50, 0x07, 0x71, 0x20, 0x07,
+  0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07,
+  0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x7a, 0x10, 0x07,
+  0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07,
+  0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07,
+  0x72, 0xa0, 0x11, 0xc2, 0x90, 0x0f, 0xdb, 0x95, 0x3f, 0xe7, 0x3c, 0xd8,
+  0x5f, 0x11, 0xd1, 0x44, 0x5c, 0x43, 0x22, 0xe0, 0x39, 0x00, 0x00, 0x08,
+  0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x40, 0x62, 0x83, 0x40, 0x51,
+  0x86, 0x01, 0x00, 0x80, 0x2c, 0x10, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+  0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47,
+  0xc6, 0x04, 0x43, 0x52, 0x45, 0x50, 0x02, 0x85, 0x30, 0x02, 0x50, 0x06,
+  0x05, 0x18, 0x50, 0x20, 0xc4, 0x46, 0x00, 0x68, 0x8d, 0x25, 0x38, 0x04,
+  0x00, 0x00, 0x00, 0x00, 0xb1, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00,
+  0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88,
+  0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73,
+  0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e,
+  0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30,
+  0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8,
+  0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b,
+  0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76,
+  0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e,
+  0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e,
+  0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61,
+  0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4,
+  0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76,
+  0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37,
+  0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76,
+  0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71,
+  0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e,
+  0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1,
+  0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61,
+  0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90,
+  0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8,
+  0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc,
+  0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7,
+  0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78,
+  0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f,
+  0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f,
+  0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1,
+  0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0,
+  0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0,
+  0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b,
+  0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c,
+  0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61,
+  0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1,
+  0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc,
+  0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4,
+  0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79,
+  0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72,
+  0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e,
+  0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1,
+  0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8,
+  0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8,
+  0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00,
+  0x79, 0x20, 0x00, 0x00, 0xd6, 0x00, 0x00, 0x00, 0x32, 0x9a, 0x08, 0x14,
+  0x02, 0x85, 0x8c, 0x27, 0x46, 0x46, 0xc8, 0x11, 0x32, 0x64, 0xd4, 0x3a,
+  0x6c, 0x7d, 0x00, 0x00, 0x8b, 0x02, 0x07, 0xc5, 0xc6, 0x91, 0x01, 0x13,
+  0x19, 0x0c, 0x12, 0x59, 0x45, 0x66, 0x20, 0x90, 0xe4, 0x29, 0x0f, 0x12,
+  0x5d, 0x88, 0x92, 0x00, 0x53, 0x44, 0x4b, 0x20, 0x56, 0x65, 0x72, 0x73,
+  0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68, 0x61, 0x72, 0x5f, 0x73, 0x69, 0x7a,
+  0x65, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x4c, 0x4c, 0x56, 0x4d, 0x20,
+  0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x33, 0x31, 0x30, 0x30,
+  0x31, 0x2e, 0x35, 0x30, 0x20, 0x28, 0x6d, 0x65, 0x74, 0x61, 0x6c, 0x66,
+  0x65, 0x2d, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x35, 0x30, 0x2e, 0x31,
+  0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f,
+  0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x64, 0x65, 0x6e, 0x6f, 0x72, 0x6d,
+  0x73, 0x5f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72,
+  0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73,
+  0x74, 0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c,
+  0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65,
+  0x2e, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72,
+  0x5f, 0x66, 0x65, 0x74, 0x63, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c,
+  0x65, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f,
+  0x6e, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70,
+  0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34,
+  0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x6e, 0x61, 0x6d, 0x65,
+  0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x69, 0x72, 0x2e,
+  0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x5f, 0x6f, 0x75, 0x74, 0x70, 0x75,
+  0x74, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x35,
+  0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66, 0x29, 0x63,
+  0x6f, 0x6c, 0x6f, 0x72, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65,
+  0x64, 0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x44,
+  0x76, 0x32, 0x5f, 0x66, 0x29, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32, 0x74,
+  0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x61, 0x69, 0x72, 0x2e, 0x76,
+  0x65, 0x72, 0x74, 0x65, 0x78, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x61,
+  0x69, 0x72, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f,
+  0x69, 0x6e, 0x64, 0x65, 0x78, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74,
+  0x65, 0x64, 0x28, 0x5f, 0x5f, 0x61, 0x69, 0x72, 0x5f, 0x70, 0x6c, 0x61,
+  0x63, 0x65, 0x68, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x5f, 0x5f, 0x29, 0x61,
+  0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x61, 0x69, 0x72,
+  0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65,
+  0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x61, 0x64, 0x61, 0x69, 0x72, 0x2e,
+  0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x73, 0x69, 0x7a,
+  0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70,
+  0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65,
+  0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x78, 0x34, 0x70, 0x72, 0x6f, 0x6a,
+  0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66,
+  0x6f, 0x72, 0x6d, 0x00, 0x04, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x30, 0x82, 0xa0, 0x04, 0x23, 0x08, 0x4b, 0x32, 0x82, 0xa0, 0x08, 0x23,
+  0x08, 0xca, 0x30, 0x82, 0xa0, 0x10, 0x23, 0x08, 0x08, 0x30, 0x82, 0xa0,
+  0x14, 0x23, 0x08, 0x8a, 0x31, 0x82, 0xa0, 0x1c, 0x33, 0x0c, 0x5e, 0xf0,
+  0xcd, 0x30, 0x80, 0x81, 0x10, 0x06, 0x33, 0x04, 0xc3, 0x0c, 0x83, 0xe7,
+  0x89, 0xc1, 0x0c, 0x04, 0x01, 0x06, 0x60, 0x20, 0x06, 0x33, 0x04, 0xc5,
+  0x0c, 0x81, 0x31, 0x43, 0x70, 0xcc, 0x50, 0x20, 0x89, 0xb2, 0x30, 0x33,
+  0x18, 0x8d, 0x93, 0x28, 0xcb, 0x33, 0x83, 0xd1, 0x40, 0x49, 0xb4, 0x48,
+  0x33, 0x0c, 0x6f, 0x00, 0x07, 0x71, 0x30, 0x83, 0x22, 0x06, 0x13, 0x25,
+  0x06, 0x60, 0x50, 0x25, 0xd1, 0xc2, 0xcc, 0xa0, 0x80, 0xc1, 0x44, 0x81,
+  0x01, 0x18, 0x54, 0x89, 0xb2, 0x3c, 0x33, 0x28, 0xde, 0x44, 0x79, 0x60,
+  0x50, 0x25, 0xd1, 0x22, 0xcd, 0x00, 0x91, 0x81, 0x75, 0x95, 0x01, 0xe5,
+  0x81, 0x01, 0x96, 0x95, 0x81, 0x66, 0x06, 0xc9, 0xb6, 0x70, 0x33, 0x40,
+  0x61, 0x60, 0x5d, 0x65, 0x40, 0x91, 0x01, 0x18, 0x60, 0x59, 0x19, 0x68,
+  0x66, 0x90, 0x6c, 0x4b, 0x37, 0x43, 0x31, 0x07, 0x74, 0x50, 0x07, 0x76,
+  0x70, 0x07, 0x33, 0x0c, 0x63, 0x20, 0x07, 0x78, 0x50, 0x1c, 0xc0, 0x71,
+  0x1c, 0xc7, 0x71, 0x1c, 0xc7, 0x89, 0x81, 0x1b, 0x58, 0x68, 0xa0, 0x07,
+  0x96, 0x65, 0xb9, 0x01, 0x1d, 0xd0, 0x01, 0x1d, 0xf8, 0x82, 0x2f, 0xc8,
+  0x82, 0x4b, 0xd0, 0x04, 0x2b, 0xc8, 0x48, 0x60, 0x82, 0x2e, 0x62, 0x63,
+  0xb3, 0x6b, 0x73, 0x69, 0x7b, 0x23, 0xab, 0x63, 0x2b, 0x73, 0x31, 0x63,
+  0x0b, 0x3b, 0x9b, 0x1b, 0x45, 0x30, 0x83, 0x33, 0x38, 0x85, 0x8d, 0xcd,
+  0xae, 0xcd, 0x25, 0x8d, 0xac, 0xcc, 0x8d, 0x6e, 0x94, 0x00, 0x0d, 0x6e,
+  0x09, 0x4b, 0x93, 0x73, 0xb1, 0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73, 0x1b,
+  0x25, 0x48, 0x83, 0xa3, 0xc2, 0xd2, 0xe4, 0x5c, 0xd8, 0xc2, 0xdc, 0xce,
+  0xea, 0xc2, 0xce, 0xca, 0xbe, 0xec, 0xca, 0xe4, 0xe6, 0xd2, 0xde, 0xdc,
+  0x46, 0x09, 0xd4, 0xe0, 0xa6, 0xb0, 0x34, 0x39, 0x97, 0xb1, 0xb7, 0x36,
+  0xb8, 0x34, 0xb6, 0xb2, 0xaf, 0x37, 0x38, 0xba, 0xb4, 0x37, 0xb7, 0xb9,
+  0x51, 0x86, 0x35, 0x60, 0x83, 0x36, 0x38, 0x25, 0x2c, 0x4d, 0xce, 0xc5,
+  0xae, 0x4c, 0x8e, 0xae, 0x0c, 0x6f, 0x94, 0x00, 0x0f, 0x00, 0x00, 0x00,
+  0xa9, 0x18, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x0a, 0x72, 0x28,
+  0x87, 0x77, 0x80, 0x07, 0x7a, 0x58, 0x70, 0x98, 0x43, 0x3d, 0xb8, 0xc3,
+  0x38, 0xb0, 0x43, 0x39, 0xd0, 0xc3, 0x82, 0xe6, 0x1c, 0xc6, 0xa1, 0x0d,
+  0xe8, 0x41, 0x1e, 0xc2, 0xc1, 0x1d, 0xe6, 0x21, 0x1d, 0xe8, 0x21, 0x1d,
+  0xde, 0xc1, 0x1d, 0x00, 0xd1, 0x10, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+  0x07, 0xcc, 0x3c, 0xa4, 0x83, 0x3b, 0x9c, 0x03, 0x3b, 0x94, 0x03, 0x3d,
+  0xa0, 0x83, 0x3c, 0x94, 0x43, 0x38, 0x90, 0xc3, 0x01, 0x00, 0x00, 0x00,
+  0x61, 0x20, 0x00, 0x00, 0x66, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c,
+  0x10, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xc4, 0x4a, 0xa0, 0x0c,
+  0x8a, 0x80, 0xdc, 0x08, 0xc0, 0x58, 0x44, 0x10, 0x04, 0xc1, 0x58, 0x84,
+  0x20, 0x08, 0xc2, 0x58, 0xc4, 0x30, 0x0c, 0x03, 0x85, 0x19, 0x00, 0x12,
+  0x33, 0x00, 0x34, 0x66, 0x00, 0x00, 0x00, 0x00, 0xf1, 0x30, 0x00, 0x00,
+  0x11, 0x00, 0x00, 0x00, 0x22, 0x47, 0xc8, 0x90, 0x51, 0x0a, 0x84, 0x18,
+  0x00, 0x00, 0x00, 0x00, 0xcf, 0x03, 0x00, 0x00, 0x6f, 0x6d, 0x6e, 0x69,
+  0x70, 0x6f, 0x74, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x68, 0x61, 0x72, 0x53,
+  0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x43, 0x2b, 0x2b, 0x20, 0x54, 0x42,
+  0x41, 0x41, 0x00, 0x00, 0x13, 0x04, 0x06, 0xd9, 0x10, 0xec, 0xc1, 0x86,
+  0x41, 0x0f, 0xfa, 0x80, 0x0f, 0x36, 0x0c, 0x7e, 0xe0, 0x07, 0x7c, 0x00,
+  0xbb, 0x10, 0x4b, 0x54, 0x45, 0x14, 0x84, 0xb2, 0x0b, 0xe1, 0x4c, 0xd7,
+  0x44, 0x41, 0x28, 0x83, 0x0c, 0xc3, 0xb1, 0x98, 0x10, 0x88, 0xff, 0x2e,
+  0x84, 0x74, 0x6d, 0x10, 0x05, 0xa1, 0x0c, 0x32, 0x1c, 0x8b, 0x63, 0x42,
+  0x20, 0xfe, 0x16, 0x14, 0xe0, 0xbf, 0x0b, 0x71, 0x71, 0x60, 0x30, 0x51,
+  0x10, 0xca, 0x20, 0x03, 0x03, 0x49, 0x26, 0x04, 0xe2, 0x6f, 0x45, 0x00,
+  0xfe, 0xbb, 0x10, 0x5c, 0x18, 0x94, 0x41, 0x46, 0x41, 0x28, 0x83, 0x0c,
+  0x51, 0x65, 0x99, 0x10, 0x88, 0xbf, 0x15, 0x01, 0xf8, 0xef, 0x42, 0x80,
+  0x81, 0x19, 0xa8, 0xc1, 0x47, 0x41, 0x28, 0x83, 0x0c, 0x81, 0xe6, 0x59,
+  0x50, 0x89, 0xff, 0x20, 0xc3, 0xc0, 0x7d, 0x16, 0x4c, 0xe2, 0x6f, 0x43,
+  0x00, 0xfe, 0x83, 0x0c, 0xc6, 0x17, 0x06, 0x16, 0x44, 0xe2, 0x6f, 0x43,
+  0x00, 0xfe, 0x83, 0x0c, 0x89, 0x18, 0x8c, 0x81, 0x05, 0x8f, 0xf8, 0xdb,
+  0x10, 0x80, 0xff, 0x2e, 0x44, 0x1b, 0xcc, 0xc1, 0x1d, 0xac, 0x01, 0x05,
+  0xa1, 0x0c, 0x32, 0x04, 0x67, 0xb0, 0x06, 0x16, 0x88, 0x81, 0xf8, 0x0f,
+  0x32, 0x0c, 0x69, 0xc0, 0x06, 0x16, 0x80, 0x81, 0xf8, 0x0f, 0x32, 0x14,
+  0x6b, 0xd0, 0x06, 0x16, 0x74, 0xe2, 0x3f, 0xc8, 0x70, 0xb4, 0x81, 0x1b,
+  0x58, 0xa0, 0x89, 0xff, 0x20, 0xc3, 0x1e, 0xb8, 0xc1, 0x1c, 0x58, 0x16,
+  0x88, 0xff, 0x20, 0x43, 0x1f, 0xc0, 0x01, 0x1d, 0x98, 0x13, 0x88, 0xbf,
+  0x25, 0x03, 0xf8, 0x5b, 0xc0, 0x80, 0xbf, 0x05, 0x09, 0xf8, 0x5b, 0x80,
+  0x80, 0xbf, 0x05, 0x05, 0xf8, 0xcf, 0x36, 0xd8, 0x41, 0x00, 0xcc, 0x36,
+  0x04, 0xa4, 0x10, 0xcc, 0x36, 0x04, 0xa4, 0x20, 0x64, 0x10, 0x10, 0x03,
+  0x09, 0x00, 0x00, 0x00, 0x5b, 0x86, 0x20, 0xf0, 0x83, 0x2d, 0xc3, 0x10,
+  0xf8, 0xc1, 0x96, 0xe1, 0x08, 0xfc, 0x60, 0xcb, 0xc0, 0x04, 0x7e, 0xb0,
+  0x65, 0x88, 0x02, 0x3f, 0xd8, 0x32, 0x58, 0x81, 0x1f, 0x6c, 0x19, 0xc6,
+  0x20, 0xf0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x32, 0x0e, 0x10, 0x22, 0x84, 0x00, 0xa4, 0x05,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x0c, 0x00, 0x00,
+  0x1d, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0xe8, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+  0x44, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
+  0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+  0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+  0xff, 0xff, 0xff, 0xff, 0x00, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x5d, 0x0c, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0x78,
+  0x00, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x43, 0x6f, 0x70, 0x79,
+  0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x33, 0x31, 0x30, 0x30, 0x31,
+  0x2e, 0x35, 0x30, 0x2e, 0x31, 0x61, 0x69, 0x72, 0x36, 0x34, 0x2d, 0x61,
+  0x70, 0x70, 0x6c, 0x65, 0x2d, 0x69, 0x6f, 0x73, 0x31, 0x33, 0x2e, 0x30,
+  0x2e, 0x30, 0x2d, 0x73, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x6f, 0x72,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00,
+  0x14, 0x00, 0x00, 0x00, 0x14, 0x0a, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+  0x42, 0x43, 0xc0, 0xde, 0x35, 0x14, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x62, 0x0c, 0x30, 0x24, 0x80, 0x10, 0x05, 0xc8, 0x14, 0x00, 0x00, 0x00,
+  0x21, 0x0c, 0x00, 0x00, 0x4a, 0x02, 0x00, 0x00, 0x0b, 0x02, 0x21, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91,
+  0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c,
+  0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x10, 0x45, 0x02,
+  0x42, 0x92, 0x0b, 0x42, 0x84, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x4b,
+  0x0a, 0x32, 0x42, 0x88, 0x48, 0x90, 0x14, 0x20, 0x43, 0x46, 0x88, 0xa5,
+  0x00, 0x19, 0x32, 0x42, 0x04, 0x49, 0x0e, 0x90, 0x11, 0x22, 0xc4, 0x50,
+  0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x21, 0x46, 0x06,
+  0x51, 0x18, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00, 0x1b, 0xcc, 0x25, 0xf8,
+  0xff, 0xff, 0xff, 0xff, 0x01, 0x80, 0x03, 0x40, 0x02, 0x28, 0x62, 0x1c,
+  0xde, 0x41, 0x1e, 0xe4, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xd8, 0x21, 0x1f,
+  0xda, 0x40, 0x1e, 0xde, 0xa1, 0x1e, 0xdc, 0x81, 0x1c, 0xca, 0x81, 0x1c,
+  0xda, 0x80, 0x1c, 0xd2, 0xc1, 0x1e, 0xd2, 0x81, 0x1c, 0xca, 0xa1, 0x0d,
+  0xe6, 0x21, 0x1e, 0xe4, 0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d,
+  0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98,
+  0x87, 0x72, 0x00, 0x08, 0x72, 0x48, 0x87, 0x79, 0x08, 0x07, 0x71, 0x60,
+  0x87, 0x72, 0x68, 0x03, 0x7a, 0x08, 0x87, 0x74, 0x60, 0x87, 0x36, 0x18,
+  0x87, 0x70, 0x60, 0x07, 0x76, 0x98, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d,
+  0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1d, 0xca, 0x61, 0x1e, 0xe6, 0xa1, 0x0d,
+  0xe0, 0x41, 0x1e, 0xca, 0x61, 0x1c, 0xd2, 0x61, 0x1e, 0xca, 0xa1, 0x0d,
+  0xcc, 0x01, 0x1e, 0xda, 0x21, 0x1c, 0xc8, 0x01, 0x30, 0x87, 0x70, 0x60,
+  0x87, 0x79, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90,
+  0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70,
+  0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68,
+  0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x18, 0xdc, 0xe1, 0x1d,
+  0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e,
+  0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c,
+  0xd8, 0x21, 0x1d, 0xda, 0xa1, 0x0d, 0xdc, 0xe1, 0x1d, 0xdc, 0xa1, 0x0d,
+  0xd8, 0xa1, 0x1c, 0xc2, 0xc1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d,
+  0xd2, 0xc1, 0x1d, 0xcc, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d,
+  0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28,
+  0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x75, 0xa8, 0x87, 0x76, 0x80,
+  0x87, 0x36, 0xa0, 0x87, 0x70, 0x10, 0x07, 0x76, 0x28, 0x87, 0x79, 0x00,
+  0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0xc0, 0x1d, 0xc2, 0xc1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e,
+  0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8,
+  0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x98, 0x87, 0x74, 0x38,
+  0x07, 0x77, 0x28, 0x07, 0x72, 0x68, 0x03, 0x7d, 0x28, 0x07, 0x79, 0x78,
+  0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0,
+  0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d,
+  0xde, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0x01, 0x1e, 0xe0, 0x21, 0x1d,
+  0xdc, 0xe1, 0x1c, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0,
+  0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x88, 0x79, 0xa0, 0x87, 0x70, 0x18,
+  0x87, 0x75, 0x68, 0x03, 0x78, 0x90, 0x87, 0x77, 0xa0, 0x87, 0x72, 0x18,
+  0x07, 0x7a, 0x78, 0x07, 0x79, 0x68, 0x03, 0x71, 0xa8, 0x07, 0x73, 0x30,
+  0x87, 0x72, 0x90, 0x87, 0x36, 0x98, 0x87, 0x74, 0xd0, 0x87, 0x72, 0x00,
+  0xf0, 0x00, 0x20, 0xea, 0xc1, 0x1d, 0xe6, 0x21, 0x1c, 0xcc, 0xa1, 0x1c,
+  0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d,
+  0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0xa8, 0x87, 0x79, 0x28,
+  0x87, 0x36, 0x98, 0x87, 0x77, 0x30, 0x07, 0x7a, 0x68, 0x03, 0x73, 0x60,
+  0x87, 0x77, 0x08, 0x07, 0x7a, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e,
+  0xca, 0x01, 0xd8, 0x40, 0x08, 0x02, 0x60, 0x01, 0x49, 0x18, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x13, 0x84, 0x40, 0x00, 0x89, 0x20, 0x00, 0x00,
+  0x0e, 0x00, 0x00, 0x00, 0x32, 0x22, 0x08, 0x09, 0x20, 0x64, 0x85, 0x04,
+  0x13, 0x22, 0xa4, 0x84, 0x04, 0x13, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14,
+  0x12, 0x4c, 0x88, 0x8c, 0x0b, 0x84, 0x84, 0x4c, 0x10, 0x24, 0x33, 0x00,
+  0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00, 0x65, 0x08, 0x09, 0x9a, 0x81,
+  0x80, 0x39, 0x02, 0x30, 0x48, 0x01, 0x1b, 0x01, 0x00, 0x00, 0x00, 0x00,
+  0x13, 0xbe, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70,
+  0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87, 0x79,
+  0x88, 0x83, 0x39, 0x70, 0x03, 0x38, 0x70, 0x03, 0x38, 0x68, 0x83, 0x79,
+  0x48, 0x87, 0x76, 0xa8, 0x07, 0x76, 0x08, 0x07, 0x7a, 0x78, 0x07, 0x79,
+  0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06, 0xf0, 0xa0, 0x07, 0x76, 0x40, 0x07,
+  0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x90, 0x0e,
+  0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9, 0x80, 0x07,
+  0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07,
+  0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x90, 0x0e,
+  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07,
+  0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07,
+  0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
+  0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x76, 0x40, 0x07,
+  0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f,
+  0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07,
+  0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
+  0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x74, 0x80, 0x07,
+  0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f,
+  0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
+  0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07,
+  0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x20, 0x07,
+  0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07,
+  0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x79, 0x20, 0x07, 0x7a, 0x20, 0x07,
+  0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x6d, 0x60, 0x0f,
+  0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07,
+  0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x50, 0x07, 0x71, 0x20, 0x07,
+  0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07,
+  0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x7a, 0x10, 0x07,
+  0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07,
+  0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07,
+  0x72, 0xa0, 0x11, 0xc2, 0x90, 0x12, 0xdb, 0x95, 0x3f, 0xeb, 0x2c, 0xc8,
+  0xf0, 0x17, 0x11, 0x60, 0x30, 0x44, 0x33, 0x0d, 0x89, 0x00, 0x69, 0x00,
+  0x00, 0x20, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x89, 0x0d,
+  0x02, 0x45, 0x99, 0x04, 0x00, 0x00, 0xb2, 0x40, 0x07, 0x00, 0x00, 0x00,
+  0x32, 0x1e, 0x98, 0x0c, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47,
+  0xc6, 0x04, 0x43, 0xb2, 0x22, 0x28, 0x81, 0x42, 0x18, 0x01, 0xa0, 0x1b,
+  0x4b, 0x70, 0x08, 0x00, 0xb1, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00,
+  0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88,
+  0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73,
+  0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e,
+  0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30,
+  0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8,
+  0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b,
+  0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76,
+  0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e,
+  0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e,
+  0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61,
+  0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4,
+  0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76,
+  0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37,
+  0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76,
+  0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71,
+  0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e,
+  0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1,
+  0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61,
+  0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90,
+  0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8,
+  0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc,
+  0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7,
+  0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78,
+  0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f,
+  0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f,
+  0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1,
+  0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0,
+  0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0,
+  0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b,
+  0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c,
+  0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61,
+  0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1,
+  0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc,
+  0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4,
+  0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79,
+  0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72,
+  0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e,
+  0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1,
+  0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8,
+  0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8,
+  0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00,
+  0x79, 0x20, 0x00, 0x00, 0x90, 0x00, 0x00, 0x00, 0x32, 0x9a, 0x08, 0x14,
+  0x02, 0x85, 0x8c, 0x27, 0x46, 0x46, 0xc8, 0x11, 0x32, 0x64, 0xd4, 0x26,
+  0xc8, 0x56, 0x00, 0x00, 0x8b, 0x02, 0x07, 0xc5, 0xc6, 0x91, 0x41, 0x14,
+  0x19, 0x52, 0xa6, 0x3c, 0x06, 0x83, 0x58, 0x05, 0x53, 0x44, 0x4b, 0x20,
+  0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68, 0x61, 0x72,
+  0x5f, 0x73, 0x69, 0x7a, 0x65, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x4c,
+  0x4c, 0x56, 0x4d, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20,
+  0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x35, 0x30, 0x20, 0x28, 0x6d, 0x65,
+  0x74, 0x61, 0x6c, 0x66, 0x65, 0x2d, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e,
+  0x35, 0x30, 0x2e, 0x31, 0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x61, 0x69,
   0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x64, 0x65,
   0x6e, 0x6f, 0x72, 0x6d, 0x73, 0x5f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c,
   0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65,
@@ -807,231 +825,223 @@ const unsigned char sdl_metallib[] = {
   0x64, 0x65, 0x72, 0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x61, 0x69,
   0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x6e,
   0x61, 0x6d, 0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x61, 0x69, 0x72,
-  0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x62,
-  0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69,
-  0x72, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69,
-  0x6e, 0x64, 0x65, 0x78, 0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x61, 0x64,
-  0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65,
-  0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67,
-  0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f,
-  0x73, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f,
-  0x6e, 0x61, 0x6d, 0x65, 0x63, 0x6f, 0x6c, 0x00, 0x00, 0x00, 0x23, 0x08,
-  0x46, 0x30, 0x82, 0x70, 0x1c, 0x23, 0x08, 0x86, 0x30, 0x82, 0x60, 0x0c,
-  0x23, 0x08, 0x06, 0x31, 0x82, 0x40, 0x00, 0x23, 0x08, 0x46, 0x31, 0xc3,
-  0x30, 0x05, 0xd4, 0x0c, 0x43, 0x25, 0x58, 0x33, 0x04, 0xc3, 0x0c, 0xc3,
-  0x34, 0x5d, 0x33, 0x10, 0x44, 0x55, 0x5d, 0x33, 0x04, 0xc5, 0x0c, 0x81,
-  0x31, 0x43, 0x70, 0xcc, 0x50, 0x20, 0xd7, 0x95, 0x28, 0x33, 0x04, 0x62,
-  0x30, 0x03, 0x74, 0x2d, 0x4c, 0xd6, 0x5c, 0x95, 0xf3, 0x64, 0x50, 0x96,
-  0x28, 0x91, 0x34, 0x43, 0x40, 0x06, 0x33, 0x0c, 0xd8, 0x18, 0x94, 0x81,
-  0x8c, 0x04, 0x26, 0xe8, 0x22, 0x36, 0x36, 0xbb, 0x36, 0x97, 0xb6, 0x37,
-  0xb2, 0x3a, 0xb6, 0x32, 0x17, 0x33, 0xb6, 0xb0, 0xb3, 0xb9, 0x51, 0x84,
-  0x4c, 0x3b, 0x85, 0x8d, 0xcd, 0xae, 0xcd, 0x25, 0x8d, 0xac, 0xcc, 0x8d,
-  0x6e, 0x94, 0x60, 0xbb, 0x25, 0x2c, 0x4d, 0xce, 0xc5, 0xae, 0x4c, 0x6e,
-  0x2e, 0xed, 0xcd, 0x6d, 0x94, 0x80, 0x3b, 0x2a, 0x2c, 0x4d, 0xce, 0x85,
-  0x2d, 0xcc, 0xed, 0xac, 0x2e, 0xec, 0xac, 0xec, 0xcb, 0xae, 0x4c, 0x6e,
-  0x2e, 0xed, 0xcd, 0x6d, 0x94, 0xa0, 0xbb, 0x29, 0x2c, 0x4d, 0xce, 0x65,
-  0xec, 0xad, 0x0d, 0x2e, 0x8d, 0xad, 0xec, 0xeb, 0x0d, 0x8e, 0x2e, 0xed,
-  0xcd, 0x6d, 0x6e, 0x94, 0xc1, 0xfb, 0xc0, 0xe0, 0x98, 0xb0, 0x34, 0x39,
-  0x17, 0x33, 0xb9, 0xb0, 0xb3, 0xb6, 0x32, 0x37, 0xba, 0x51, 0x82, 0x32,
-  0x00, 0x00, 0xa9, 0x18, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x0a,
-  0x72, 0x28, 0x87, 0x77, 0x80, 0x07, 0x7a, 0x58, 0x70, 0x98, 0x43, 0x3d,
-  0xb8, 0xc3, 0x38, 0xb0, 0x43, 0x39, 0xd0, 0xc3, 0x82, 0xe6, 0x1c, 0xc6,
-  0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0xc1, 0x1d, 0xe6, 0x21, 0x1d, 0xe8,
-  0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x00, 0xd1, 0x10, 0x00, 0x00, 0x06, 0x00,
-  0x00, 0x00, 0x07, 0xcc, 0x3c, 0xa4, 0x83, 0x3b, 0x9c, 0x03, 0x3b, 0x94,
-  0x03, 0x3d, 0xa0, 0x83, 0x3c, 0x94, 0x43, 0x38, 0x90, 0xc3, 0x01, 0x00,
-  0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x13, 0x04,
-  0x41, 0x3c, 0x0c, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x22, 0x47,
-  0xc8, 0x90, 0x51, 0x0a, 0x84, 0x18, 0x00, 0x00, 0x00, 0x00, 0xcf, 0x03,
-  0x00, 0x00, 0x6f, 0x6d, 0x6e, 0x69, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x74,
-  0x20, 0x63, 0x68, 0x61, 0x72, 0x53, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20,
-  0x43, 0x2b, 0x2b, 0x20, 0x54, 0x42, 0x41, 0x41, 0x00, 0x00, 0x13, 0x04,
-  0xc4, 0xd8, 0x10, 0xa0, 0xc1, 0x86, 0xe1, 0x0c, 0xd4, 0x20, 0x0d, 0x36,
-  0x0c, 0x6b, 0xb0, 0x06, 0x69, 0x00, 0x14, 0x44, 0xc9, 0x20, 0x20, 0x06,
-  0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x5b, 0x06, 0x20, 0x58, 0x03, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x03, 0x00,
-  0x00, 0x00, 0x32, 0x0e, 0x10, 0x22, 0x84, 0x00, 0xc6, 0x04, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x0c, 0x00, 0x00, 0x1d, 0x00,
-  0x00, 0x00, 0x12, 0x03, 0x94, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
-  0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x44, 0x00,
-  0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x68, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x1f, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x39, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0xff, 0xff,
-  0xff, 0xff, 0x00, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5d, 0x0c,
-  0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0x79, 0x00, 0x00,
-  0x00, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x53, 0x6f, 0x6c, 0x69, 0x64, 0x5f,
-  0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x33, 0x31, 0x30, 0x30,
-  0x31, 0x2e, 0x34, 0x33, 0x61, 0x69, 0x72, 0x36, 0x34, 0x2d, 0x61, 0x70,
-  0x70, 0x6c, 0x65, 0x2d, 0x69, 0x6f, 0x73, 0x31, 0x33, 0x2e, 0x30, 0x2e,
-  0x30, 0x2d, 0x73, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00,
-  0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x5c, 0x0c, 0x00, 0x00, 0xff, 0xff,
-  0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x35, 0x14, 0x00, 0x00, 0x03, 0x00,
-  0x00, 0x00, 0x62, 0x0c, 0x30, 0x24, 0x80, 0x10, 0x05, 0xc8, 0x14, 0x00,
-  0x00, 0x00, 0x21, 0x0c, 0x00, 0x00, 0xd0, 0x02, 0x00, 0x00, 0x0b, 0x02,
-  0x21, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x07, 0x81,
-  0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01,
-  0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14,
-  0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08,
-  0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88, 0x48, 0x90, 0x14, 0x20, 0x43, 0x46,
-  0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0x04, 0x49, 0x0e, 0x90, 0x91, 0x22,
-  0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x29,
-  0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x8d, 0x00, 0x00, 0x00, 0x1b, 0xcc,
-  0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x58, 0x03, 0x40, 0x02, 0x2a,
-  0x62, 0x1c, 0xde, 0x41, 0x1e, 0xe4, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xd8,
-  0x21, 0x1f, 0xda, 0x40, 0x1e, 0xde, 0xa1, 0x1e, 0xdc, 0x81, 0x1c, 0xca,
-  0x81, 0x1c, 0xda, 0x80, 0x1c, 0xd2, 0xc1, 0x1e, 0xd2, 0x81, 0x1c, 0xca,
-  0xa1, 0x0d, 0xe6, 0x21, 0x1e, 0xe4, 0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xe0,
-  0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x73, 0x08, 0x07,
-  0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x72, 0x48, 0x87, 0x79, 0x08, 0x07,
-  0x71, 0x60, 0x87, 0x72, 0x68, 0x03, 0x7a, 0x08, 0x87, 0x74, 0x60, 0x87,
-  0x36, 0x18, 0x87, 0x70, 0x60, 0x07, 0x76, 0x98, 0x07, 0xc0, 0x1c, 0xc2,
-  0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1d, 0xca, 0x61, 0x1e, 0xe6,
-  0xa1, 0x0d, 0xe0, 0x41, 0x1e, 0xca, 0x61, 0x1c, 0xd2, 0x61, 0x1e, 0xca,
-  0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0x21, 0x1c, 0xc8, 0x01, 0x30, 0x87,
-  0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03,
-  0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78, 0x78, 0x87,
-  0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72, 0x60, 0x87,
-  0x74, 0x68, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x18, 0xdc,
-  0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda,
-  0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda,
-  0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0xa1, 0x0d, 0xdc, 0xe1, 0x1d, 0xdc,
-  0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xc2, 0xc1, 0x1c, 0x00, 0xc2, 0x1d, 0xde,
-  0xa1, 0x0d, 0xd2, 0xc1, 0x1d, 0xcc, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0,
-  0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87,
-  0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x75, 0xa8, 0x87,
-  0x76, 0x80, 0x87, 0x36, 0xa0, 0x87, 0x70, 0x10, 0x07, 0x76, 0x28, 0x87,
-  0x79, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc,
-  0xe1, 0x1d, 0xda, 0xc0, 0x1d, 0xc2, 0xc1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc,
-  0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07,
-  0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x98, 0x87,
-  0x74, 0x38, 0x07, 0x77, 0x28, 0x07, 0x72, 0x68, 0x03, 0x7d, 0x28, 0x07,
-  0x79, 0x78, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87,
-  0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00,
-  0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0x01, 0x1e, 0xe0,
-  0x21, 0x1d, 0xdc, 0xe1, 0x1c, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0,
-  0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x88, 0x79, 0xa0, 0x87,
-  0x70, 0x18, 0x87, 0x75, 0x68, 0x03, 0x78, 0x90, 0x87, 0x77, 0xa0, 0x87,
-  0x72, 0x18, 0x07, 0x7a, 0x78, 0x07, 0x79, 0x68, 0x03, 0x71, 0xa8, 0x07,
-  0x73, 0x30, 0x87, 0x72, 0x90, 0x87, 0x36, 0x98, 0x87, 0x74, 0xd0, 0x87,
-  0x72, 0x00, 0xf0, 0x00, 0x20, 0xea, 0xc1, 0x1d, 0xe6, 0x21, 0x1c, 0xcc,
-  0xa1, 0x1c, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8,
-  0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0xa8, 0x87,
-  0x79, 0x28, 0x87, 0x36, 0x98, 0x87, 0x77, 0x30, 0x07, 0x7a, 0x68, 0x03,
-  0x73, 0x60, 0x87, 0x77, 0x08, 0x07, 0x7a, 0x00, 0xcc, 0x21, 0x1c, 0xd8,
-  0x61, 0x1e, 0xca, 0x01, 0xd8, 0xb0, 0x08, 0x03, 0x90, 0x00, 0x0b, 0x50,
-  0x05, 0x69, 0x00, 0x6d, 0x30, 0x06, 0x02, 0x58, 0x80, 0x6a, 0x83, 0x41,
-  0x14, 0xc0, 0x02, 0x54, 0x1b, 0x94, 0xe2, 0xff, 0xff, 0xff, 0xff, 0x07,
-  0xa0, 0x0d, 0x80, 0x35, 0x00, 0x24, 0xa0, 0xda, 0x60, 0x18, 0x01, 0xb0,
-  0x00, 0xd5, 0x06, 0xe3, 0x10, 0x80, 0x05, 0xa8, 0x00, 0x00, 0x49, 0x18,
-  0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x13, 0x88, 0x40, 0x18, 0x88, 0x09,
-  0x43, 0x61, 0x1c, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x20, 0x00,
-  0x00, 0x00, 0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22,
-  0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c,
-  0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x54, 0x33, 0x00, 0xc3, 0x08,
-  0x04, 0x30, 0x8c, 0x20, 0x00, 0x83, 0x08, 0x41, 0x70, 0x94, 0x34, 0x45,
-  0x94, 0x30, 0xf9, 0xff, 0x44, 0x5c, 0x13, 0x15, 0x11, 0xbf, 0x3d, 0xfc,
-  0xd3, 0x18, 0x01, 0x30, 0x88, 0x40, 0x04, 0x17, 0x49, 0x53, 0x44, 0x09,
-  0x93, 0xff, 0x4b, 0x00, 0xf3, 0x2c, 0x44, 0xf4, 0x4f, 0x63, 0x04, 0xc0,
-  0x20, 0x82, 0x21, 0x14, 0x23, 0x04, 0x31, 0xca, 0x21, 0x34, 0x47, 0x80,
-  0x18, 0x21, 0xa8, 0x39, 0x82, 0x60, 0x8e, 0x00, 0x0c, 0x86, 0x11, 0x84,
-  0xa6, 0x28, 0xab, 0x1c, 0xc1, 0x1c, 0x03, 0xa0, 0xd1, 0x1b, 0x08, 0x48,
-  0x81, 0x36, 0x47, 0x00, 0x0a, 0x23, 0x00, 0x00, 0x00, 0x00, 0x13, 0xbe,
-  0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70, 0x80, 0x07,
-  0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87, 0x79, 0x88, 0x83,
-  0x39, 0x70, 0x03, 0x38, 0x70, 0x03, 0x38, 0x68, 0x83, 0x79, 0x48, 0x87,
-  0x76, 0xa8, 0x07, 0x76, 0x08, 0x07, 0x7a, 0x78, 0x07, 0x79, 0xd8, 0x70,
-  0x1b, 0xe5, 0xd0, 0x06, 0xf0, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60,
-  0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0,
-  0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9, 0x80, 0x07, 0x7a, 0x80,
-  0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a, 0x10,
-  0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x90, 0x0e, 0x73, 0x20,
-  0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90,
+  0x2e, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x6e,
+  0x70, 0x75, 0x74, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64,
+  0x28, 0x38, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x76,
+  0x32, 0x5f, 0x66, 0x29, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x65, 0x6e, 0x74,
+  0x65, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x65, 0x72, 0x73, 0x70, 0x65,
+  0x63, 0x74, 0x69, 0x76, 0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32, 0x61,
+  0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x70,
+  0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x67, 0x65, 0x6e, 0x65, 0x72,
+  0x61, 0x74, 0x65, 0x64, 0x28, 0x35, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44,
+  0x76, 0x34, 0x5f, 0x66, 0x29, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x00, 0x00,
+  0x23, 0x08, 0x46, 0x30, 0x82, 0x70, 0x14, 0x23, 0x08, 0x86, 0x30, 0x82,
+  0x60, 0x0c, 0x23, 0x08, 0x06, 0x31, 0x82, 0x40, 0x00, 0x33, 0x0c, 0x54,
+  0x50, 0xcd, 0x30, 0x58, 0xc2, 0x35, 0x43, 0x30, 0xcc, 0x30, 0x50, 0x14,
+  0x36, 0x03, 0x41, 0x58, 0x16, 0x36, 0x43, 0x50, 0xcc, 0x10, 0x18, 0x33,
+  0x04, 0xc7, 0x0c, 0x05, 0x82, 0x61, 0x89, 0x32, 0x43, 0x20, 0x06, 0x33,
+  0x24, 0xd8, 0xc2, 0x34, 0x4e, 0xf2, 0x40, 0xd1, 0x0c, 0x89, 0xb5, 0x48,
+  0x8d, 0x93, 0x28, 0xd0, 0x34, 0x83, 0x40, 0x06, 0x65, 0x30, 0xc3, 0x90,
+  0x8d, 0x81, 0x19, 0xc8, 0x48, 0x60, 0x82, 0x2e, 0x62, 0x63, 0xb3, 0x6b,
+  0x73, 0x69, 0x7b, 0x23, 0xab, 0x63, 0x2b, 0x73, 0x31, 0x63, 0x0b, 0x3b,
+  0x9b, 0x1b, 0x45, 0xc8, 0xb4, 0x53, 0xd8, 0xd8, 0xec, 0xda, 0x5c, 0xd2,
+  0xc8, 0xca, 0xdc, 0xe8, 0x46, 0x09, 0xb6, 0x5b, 0xc2, 0xd2, 0xe4, 0x5c,
+  0xec, 0xca, 0xe4, 0xe6, 0xd2, 0xde, 0xdc, 0x46, 0x09, 0xb8, 0xa3, 0xc2,
+  0xd2, 0xe4, 0x5c, 0xd8, 0xc2, 0xdc, 0xce, 0xea, 0xc2, 0xce, 0xca, 0xbe,
+  0xec, 0xca, 0xe4, 0xe6, 0xd2, 0xde, 0xdc, 0x46, 0x09, 0xba, 0x9b, 0xc2,
+  0xd2, 0xe4, 0x5c, 0xc6, 0xde, 0xda, 0xe0, 0xd2, 0xd8, 0xca, 0xbe, 0xde,
+  0xe0, 0xe8, 0xd2, 0xde, 0xdc, 0xe6, 0x46, 0x19, 0xbc, 0x0f, 0x0c, 0x8e,
+  0x09, 0x4b, 0x93, 0x73, 0x31, 0x93, 0x0b, 0x3b, 0x6b, 0x2b, 0x73, 0xa3,
+  0x1b, 0x25, 0x30, 0x03, 0x00, 0x00, 0x00, 0x00, 0xa9, 0x18, 0x00, 0x00,
+  0x0b, 0x00, 0x00, 0x00, 0x0b, 0x0a, 0x72, 0x28, 0x87, 0x77, 0x80, 0x07,
+  0x7a, 0x58, 0x70, 0x98, 0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb0, 0x43, 0x39,
+  0xd0, 0xc3, 0x82, 0xe6, 0x1c, 0xc6, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2,
+  0xc1, 0x1d, 0xe6, 0x21, 0x1d, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x00,
+  0xd1, 0x10, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0xcc, 0x3c, 0xa4,
+  0x83, 0x3b, 0x9c, 0x03, 0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83, 0x3c, 0x94,
+  0x43, 0x38, 0x90, 0xc3, 0x01, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x06, 0x00, 0x00, 0x00, 0x00,
+  0x71, 0x20, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x32, 0x0e, 0x10, 0x22,
+  0x84, 0x00, 0xc8, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x65, 0x0c, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0xe8,
+  0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+  0x0a, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x1c, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x12, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x12, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x24, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x5d, 0x0c, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+  0x12, 0x03, 0x94, 0x7b, 0x00, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4c, 0x5f,
+  0x53, 0x6f, 0x6c, 0x69, 0x64, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65,
+  0x6e, 0x74, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x35, 0x30, 0x2e, 0x31,
+  0x61, 0x69, 0x72, 0x36, 0x34, 0x2d, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2d,
+  0x69, 0x6f, 0x73, 0x31, 0x33, 0x2e, 0x30, 0x2e, 0x30, 0x2d, 0x73, 0x69,
+  0x6d, 0x75, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b,
+  0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0xa8, 0x0b, 0x00, 0x00,
+  0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x35, 0x14, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x62, 0x0c, 0x30, 0x24, 0x80, 0x10, 0x05, 0xc8,
+  0x14, 0x00, 0x00, 0x00, 0x21, 0x0c, 0x00, 0x00, 0xa2, 0x02, 0x00, 0x00,
+  0x0b, 0x02, 0x21, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+  0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39,
+  0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62,
+  0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14,
+  0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88, 0x48, 0x90, 0x14, 0x20,
+  0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0x04, 0x49, 0x0e, 0x90,
+  0x91, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a,
+  0x04, 0x29, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x8a, 0x00, 0x00, 0x00,
+  0x1b, 0xcc, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x58, 0x03, 0x40,
+  0x02, 0x2a, 0x62, 0x1c, 0xde, 0x41, 0x1e, 0xe4, 0xa1, 0x1c, 0xc6, 0x81,
+  0x1e, 0xd8, 0x21, 0x1f, 0xda, 0x40, 0x1e, 0xde, 0xa1, 0x1e, 0xdc, 0x81,
+  0x1c, 0xca, 0x81, 0x1c, 0xda, 0x80, 0x1c, 0xd2, 0xc1, 0x1e, 0xd2, 0x81,
+  0x1c, 0xca, 0xa1, 0x0d, 0xe6, 0x21, 0x1e, 0xe4, 0x81, 0x1e, 0xda, 0xc0,
+  0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x73,
+  0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x72, 0x48, 0x87, 0x79,
+  0x08, 0x07, 0x71, 0x60, 0x87, 0x72, 0x68, 0x03, 0x7a, 0x08, 0x87, 0x74,
+  0x60, 0x87, 0x36, 0x18, 0x87, 0x70, 0x60, 0x07, 0x76, 0x98, 0x07, 0xc0,
+  0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1d, 0xca, 0x61,
+  0x1e, 0xe6, 0xa1, 0x0d, 0xe0, 0x41, 0x1e, 0xca, 0x61, 0x1c, 0xd2, 0x61,
+  0x1e, 0xca, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0x21, 0x1c, 0xc8, 0x01,
+  0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77,
+  0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78,
+  0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72,
+  0x60, 0x87, 0x74, 0x68, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01,
+  0x18, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1,
+  0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41,
+  0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0xa1, 0x0d, 0xdc, 0xe1,
+  0x1d, 0xdc, 0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xc2, 0xc1, 0x1c, 0x00, 0xc2,
+  0x1d, 0xde, 0xa1, 0x0d, 0xd2, 0xc1, 0x1d, 0xcc, 0x61, 0x1e, 0xda, 0xc0,
+  0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a,
+  0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x75,
+  0xa8, 0x87, 0x76, 0x80, 0x87, 0x36, 0xa0, 0x87, 0x70, 0x10, 0x07, 0x76,
+  0x28, 0x87, 0x79, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01,
+  0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1d, 0xc2, 0xc1, 0x1d, 0xe6, 0xa1,
+  0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01,
+  0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36,
+  0x98, 0x87, 0x74, 0x38, 0x07, 0x77, 0x28, 0x07, 0x72, 0x68, 0x03, 0x7d,
+  0x28, 0x07, 0x79, 0x78, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36,
+  0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1,
+  0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0x01,
+  0x1e, 0xe0, 0x21, 0x1d, 0xdc, 0xe1, 0x1c, 0xda, 0xa0, 0x1d, 0xc2, 0x81,
+  0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x88, 0x79,
+  0xa0, 0x87, 0x70, 0x18, 0x87, 0x75, 0x68, 0x03, 0x78, 0x90, 0x87, 0x77,
+  0xa0, 0x87, 0x72, 0x18, 0x07, 0x7a, 0x78, 0x07, 0x79, 0x68, 0x03, 0x71,
+  0xa8, 0x07, 0x73, 0x30, 0x87, 0x72, 0x90, 0x87, 0x36, 0x98, 0x87, 0x74,
+  0xd0, 0x87, 0x72, 0x00, 0xf0, 0x00, 0x20, 0xea, 0xc1, 0x1d, 0xe6, 0x21,
+  0x1c, 0xcc, 0xa1, 0x1c, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21,
+  0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80,
+  0xa8, 0x87, 0x79, 0x28, 0x87, 0x36, 0x98, 0x87, 0x77, 0x30, 0x07, 0x7a,
+  0x68, 0x03, 0x73, 0x60, 0x87, 0x77, 0x08, 0x07, 0x7a, 0x00, 0xcc, 0x21,
+  0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0xd8, 0x60, 0x08, 0x04, 0xb0, 0x00,
+  0xd5, 0x06, 0x63, 0x28, 0x80, 0x05, 0xa8, 0x36, 0x28, 0xc4, 0xff, 0xff,
+  0xff, 0xff, 0x0f, 0x40, 0x1b, 0x00, 0x6b, 0x00, 0x48, 0x40, 0xb5, 0xc1,
+  0x28, 0x02, 0x60, 0x01, 0xaa, 0x0d, 0x86, 0x21, 0x00, 0x0b, 0x50, 0x01,
+  0x49, 0x18, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x13, 0x86, 0x40, 0x18,
+  0x26, 0x0c, 0x44, 0x61, 0x00, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00,
+  0x1e, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04,
+  0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14,
+  0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x4c, 0x33, 0x00,
+  0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00, 0x47, 0x49, 0x53, 0x44, 0x09,
+  0x93, 0xff, 0x4f, 0xc4, 0x35, 0x51, 0x11, 0xf1, 0xdb, 0xc3, 0x3f, 0x8d,
+  0x11, 0x00, 0x83, 0x08, 0x43, 0x70, 0x91, 0x34, 0x45, 0x94, 0x30, 0xf9,
+  0xbf, 0x04, 0x30, 0xcf, 0x42, 0x44, 0xff, 0x34, 0x46, 0x00, 0x0c, 0x22,
+  0x14, 0x42, 0x31, 0x42, 0x08, 0x82, 0x18, 0x3a, 0x73, 0x04, 0x88, 0x11,
+  0x42, 0x9a, 0x23, 0x08, 0xe6, 0x08, 0xc0, 0x60, 0x18, 0x41, 0x60, 0x8a,
+  0xa2, 0x88, 0x11, 0xab, 0x2d, 0x00, 0x18, 0xb9, 0x81, 0x80, 0x14, 0x60,
+  0x23, 0x00, 0x00, 0x00, 0x13, 0xbe, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03,
+  0x3a, 0x68, 0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83,
+  0x74, 0x78, 0x87, 0x79, 0x88, 0x83, 0x39, 0x70, 0x03, 0x38, 0x70, 0x03,
+  0x38, 0x68, 0x83, 0x79, 0x48, 0x87, 0x76, 0xa8, 0x07, 0x76, 0x08, 0x07,
+  0x7a, 0x78, 0x07, 0x79, 0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06, 0xf0, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0,
+  0x06, 0xe9, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90,
+  0x0e, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x6d, 0x90, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60,
+  0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60,
   0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
-  0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0,
-  0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60,
-  0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x60,
-  0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x60,
-  0x0f, 0x72, 0x40, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20,
-  0x07, 0x6d, 0x60, 0x0f, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0,
-  0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x74, 0x80, 0x07, 0x7a, 0x60,
-  0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x76, 0x40,
-  0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60,
-  0x0f, 0x79, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10,
-  0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x20, 0x07, 0x78, 0xa0,
-  0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0,
-  0x06, 0xf6, 0x10, 0x07, 0x79, 0x20, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60,
-  0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x50,
-  0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50,
-  0x07, 0x76, 0xd0, 0x06, 0xf6, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50,
-  0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x6d, 0x60,
-  0x0f, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20,
-  0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x6d, 0xe0,
-  0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0,
-  0x11, 0xc2, 0x90, 0x11, 0xdb, 0x95, 0x3f, 0xe7, 0x3c, 0xd8, 0x5f, 0x44,
-  0x80, 0xc1, 0x10, 0xcd, 0x34, 0x24, 0x02, 0x22, 0x04, 0x00, 0x80, 0x00,
-  0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x86, 0x44, 0xd1, 0xf6, 0x00,
-  0x01, 0x20, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x80, 0xc4, 0x06,
-  0x81, 0xa2, 0xd2, 0x02, 0x00, 0x00, 0x59, 0x20, 0x00, 0x00, 0x09, 0x00,
-  0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09,
-  0x26, 0x47, 0xc6, 0x04, 0x43, 0x6a, 0x45, 0x50, 0x02, 0x85, 0x30, 0x02,
-  0x50, 0x20, 0x65, 0x40, 0x73, 0x04, 0x80, 0xe4, 0x58, 0x82, 0x23, 0x00,
-  0x00, 0x00, 0xb1, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08,
-  0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38,
-  0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71,
-  0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c,
-  0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d,
-  0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d,
-  0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07,
-  0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87,
-  0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30,
-  0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10,
-  0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66,
-  0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c,
-  0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07,
-  0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87,
-  0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05,
-  0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87,
-  0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0,
-  0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4,
-  0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca,
-  0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39,
-  0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38,
-  0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c,
-  0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87,
-  0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87,
-  0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00,
-  0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20,
-  0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2,
-  0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4,
-  0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a,
-  0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07,
-  0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90,
-  0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8,
-  0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc,
-  0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b,
-  0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b,
-  0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87,
-  0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81,
-  0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30,
-  0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde,
-  0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39,
-  0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f,
-  0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x79, 0x20,
-  0x00, 0x00, 0xce, 0x00, 0x00, 0x00, 0x32, 0x9a, 0x08, 0x14, 0x02, 0x85,
-  0x8c, 0x27, 0x46, 0x46, 0xc8, 0x11, 0x32, 0x64, 0xd4, 0xc4, 0x80, 0x63,
-  0x21, 0x00, 0x8b, 0xe2, 0x06, 0xc5, 0xc6, 0x91, 0x41, 0x14, 0x19, 0x8c,
-  0x22, 0x31, 0x88, 0x94, 0x3d, 0x06, 0xa2, 0x3c, 0x12, 0x12, 0x5d, 0xc3,
-  0xa2, 0x60, 0xc3, 0x72, 0x04, 0x00, 0x53, 0x44, 0x4b, 0x20, 0x56, 0x65,
-  0x72, 0x73, 0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68, 0x61, 0x72, 0x5f, 0x73,
-  0x69, 0x7a, 0x65, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x4c, 0x4c, 0x56,
-  0x4d, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x33, 0x31,
-  0x30, 0x30, 0x31, 0x2e, 0x34, 0x33, 0x20, 0x28, 0x6d, 0x65, 0x74, 0x61,
-  0x6c, 0x66, 0x65, 0x2d, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x34, 0x33,
+  0x07, 0x6d, 0x60, 0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0,
+  0x07, 0x71, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x73, 0x20,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60,
+  0x0f, 0x74, 0x80, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x6d, 0x60, 0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07, 0x7a, 0x10,
+  0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60,
+  0x0f, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0,
+  0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x79, 0x20,
+  0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60,
+  0x07, 0x6d, 0x60, 0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50,
+  0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x50,
+  0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50,
+  0x07, 0x71, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07, 0x72, 0x40,
+  0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00,
+  0x07, 0x72, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x11, 0xc2, 0x90, 0x11, 0xdb, 0x95,
+  0x3f, 0xe7, 0x3c, 0xd8, 0x5f, 0x44, 0x80, 0xc1, 0x10, 0xcd, 0x34, 0x24,
+  0x02, 0xa2, 0x03, 0x00, 0x80, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
+  0x00, 0x86, 0x44, 0xd1, 0xe6, 0x00, 0x01, 0x20, 0x00, 0x00, 0x00, 0x08,
+  0x00, 0x00, 0x00, 0x80, 0xc4, 0x06, 0x81, 0xa2, 0xa4, 0x02, 0x00, 0x00,
+  0x59, 0x20, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x10,
+  0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x62,
+  0x45, 0x50, 0x02, 0x85, 0x30, 0x02, 0x50, 0x06, 0x14, 0xc7, 0x12, 0x1c,
+  0x02, 0x00, 0x00, 0x00, 0xb1, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00,
+  0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88,
+  0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73,
+  0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e,
+  0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30,
+  0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8,
+  0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b,
+  0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76,
+  0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e,
+  0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e,
+  0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61,
+  0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4,
+  0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76,
+  0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37,
+  0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76,
+  0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71,
+  0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e,
+  0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1,
+  0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61,
+  0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90,
+  0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8,
+  0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc,
+  0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7,
+  0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78,
+  0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f,
+  0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f,
+  0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1,
+  0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0,
+  0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0,
+  0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b,
+  0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c,
+  0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61,
+  0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1,
+  0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc,
+  0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4,
+  0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79,
+  0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72,
+  0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e,
+  0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1,
+  0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8,
+  0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8,
+  0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00,
+  0x79, 0x20, 0x00, 0x00, 0xbe, 0x00, 0x00, 0x00, 0x32, 0x9a, 0x08, 0x14,
+  0x02, 0x85, 0x8c, 0x27, 0x46, 0x46, 0xc8, 0x11, 0x32, 0x64, 0xd4, 0x3c,
+  0x2c, 0x77, 0x00, 0x00, 0x8b, 0x02, 0x07, 0xc5, 0xc6, 0x91, 0x41, 0x14,
+  0x19, 0x8c, 0x22, 0x31, 0x88, 0x64, 0x3d, 0x45, 0x66, 0x20, 0x8b, 0xa4,
+  0x60, 0xc3, 0x72, 0x04, 0x53, 0x44, 0x4b, 0x20, 0x56, 0x65, 0x72, 0x73,
+  0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68, 0x61, 0x72, 0x5f, 0x73, 0x69, 0x7a,
+  0x65, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x4c, 0x4c, 0x56, 0x4d, 0x20,
+  0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x33, 0x31, 0x30, 0x30,
+  0x31, 0x2e, 0x35, 0x30, 0x20, 0x28, 0x6d, 0x65, 0x74, 0x61, 0x6c, 0x66,
+  0x65, 0x2d, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x35, 0x30, 0x2e, 0x31,
   0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f,
   0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x64, 0x65, 0x6e, 0x6f, 0x72, 0x6d,
   0x73, 0x5f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72,
@@ -1050,588 +1060,565 @@ const unsigned char sdl_metallib[] = {
   0x2e, 0x61, 0x72, 0x67, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x70, 0x6f, 0x73,
   0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x72, 0x61,
   0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x67,
-  0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x38, 0x74, 0x65,
-  0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x44, 0x76, 0x32, 0x5f, 0x66, 0x29,
-  0x61, 0x69, 0x72, 0x2e, 0x70, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74,
-  0x69, 0x76, 0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32, 0x74, 0x65, 0x78,
-  0x63, 0x6f, 0x6f, 0x72, 0x64, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66,
-  0x66, 0x65, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65,
-  0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x6c, 0x6f,
-  0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78,
-  0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x61, 0x64, 0x61, 0x69, 0x72, 0x2e,
-  0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x73, 0x69, 0x7a,
-  0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70,
-  0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65,
-  0x63, 0x6f, 0x6c, 0x61, 0x69, 0x72, 0x2e, 0x74, 0x65, 0x78, 0x74, 0x75,
-  0x72, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65,
-  0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x32, 0x64, 0x3c, 0x66, 0x6c,
-  0x6f, 0x61, 0x74, 0x2c, 0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x3e,
-  0x74, 0x65, 0x78, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c,
-  0x65, 0x72, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73, 0x23, 0x08,
-  0x8d, 0x30, 0x82, 0x20, 0x25, 0x23, 0x08, 0xcd, 0x30, 0x82, 0xd0, 0x10,
-  0x23, 0x08, 0x4d, 0x31, 0x82, 0x90, 0x00, 0x23, 0x08, 0x8d, 0x31, 0x82,
-  0xd0, 0x1c, 0x33, 0x0c, 0x63, 0x10, 0x90, 0xc1, 0x0c, 0x43, 0x19, 0x08,
-  0x66, 0x30, 0x43, 0x30, 0xcc, 0x30, 0x8c, 0xc1, 0x18, 0x9c, 0xc1, 0x0c,
-  0x04, 0x51, 0x06, 0x65, 0x70, 0x06, 0x33, 0x04, 0xc5, 0x0c, 0x81, 0x31,
-  0x43, 0x70, 0xcc, 0x50, 0x20, 0x67, 0x70, 0x06, 0x89, 0x32, 0x43, 0x30,
-  0x07, 0x33, 0x20, 0x67, 0xb0, 0x30, 0x4d, 0xa2, 0x38, 0xcf, 0x0c, 0x49,
-  0x19, 0x40, 0x11, 0x23, 0x25, 0x93, 0x43, 0xcd, 0x00, 0x8d, 0x41, 0x65,
-  0xa5, 0xc1, 0x75, 0x06, 0x65, 0x80, 0x65, 0x69, 0xa0, 0xa5, 0x41, 0xa2,
-  0x38, 0xdb, 0x0c, 0x8a, 0x1a, 0x70, 0xd7, 0x19, 0x94, 0x41, 0x97, 0x78,
-  0xce, 0x37, 0x43, 0x62, 0x06, 0x60, 0x70, 0x9d, 0x41, 0x19, 0x24, 0x61,
-  0xe0, 0x88, 0xc1, 0x0c, 0x45, 0x1d, 0xd8, 0xc1, 0x1d, 0xe0, 0x41, 0x1e,
-  0xcc, 0x30, 0xa0, 0x01, 0x1d, 0xe8, 0x81, 0x8c, 0x04, 0x26, 0xe8, 0x22,
-  0x36, 0x36, 0xbb, 0x36, 0x97, 0xb6, 0x37, 0xb2, 0x3a, 0xb6, 0x32, 0x17,
-  0x33, 0xb6, 0xb0, 0xb3, 0xb9, 0x51, 0x04, 0x35, 0x58, 0x83, 0x53, 0xd8,
-  0xd8, 0xec, 0xda, 0x5c, 0xd2, 0xc8, 0xca, 0xdc, 0xe8, 0x46, 0x09, 0xd8,
-  0xe0, 0x96, 0xb0, 0x34, 0x39, 0x17, 0xbb, 0x32, 0xb9, 0xb9, 0xb4, 0x37,
-  0xb7, 0x51, 0x82, 0x36, 0x38, 0x2a, 0x2c, 0x4d, 0xce, 0x85, 0x2d, 0xcc,
-  0xed, 0xac, 0x2e, 0xec, 0xac, 0xec, 0xcb, 0xae, 0x4c, 0x6e, 0x2e, 0xed,
-  0xcd, 0x6d, 0x94, 0xc0, 0x0d, 0x6e, 0x0a, 0x4b, 0x93, 0x73, 0x19, 0x7b,
-  0x6b, 0x83, 0x4b, 0x63, 0x2b, 0xfb, 0x7a, 0x83, 0xa3, 0x4b, 0x7b, 0x73,
-  0x9b, 0x1b, 0x65, 0x78, 0x03, 0x38, 0x88, 0x83, 0x63, 0xc2, 0xd2, 0xe4,
-  0x5c, 0xcc, 0xe4, 0xc2, 0xce, 0xda, 0xca, 0xdc, 0xe8, 0x46, 0x09, 0xf4,
-  0x00, 0x00, 0xa9, 0x18, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x0a,
-  0x72, 0x28, 0x87, 0x77, 0x80, 0x07, 0x7a, 0x58, 0x70, 0x98, 0x43, 0x3d,
-  0xb8, 0xc3, 0x38, 0xb0, 0x43, 0x39, 0xd0, 0xc3, 0x82, 0xe6, 0x1c, 0xc6,
-  0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0xc1, 0x1d, 0xe6, 0x21, 0x1d, 0xe8,
-  0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x00, 0xd1, 0x10, 0x00, 0x00, 0x06, 0x00,
-  0x00, 0x00, 0x07, 0xcc, 0x3c, 0xa4, 0x83, 0x3b, 0x9c, 0x03, 0x3b, 0x94,
-  0x03, 0x3d, 0xa0, 0x83, 0x3c, 0x94, 0x43, 0x38, 0x90, 0xc3, 0x01, 0x00,
-  0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x13, 0x04,
-  0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xc4, 0x6a,
-  0x60, 0x04, 0x80, 0xdc, 0x08, 0x00, 0x81, 0x11, 0x00, 0x00, 0xf1, 0x30,
-  0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x22, 0x47, 0xc8, 0x90, 0x51, 0x0a,
-  0x84, 0x18, 0x00, 0x00, 0x00, 0x00, 0xcf, 0x03, 0x00, 0x00, 0x6f, 0x6d,
-  0x6e, 0x69, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x68, 0x61,
-  0x72, 0x53, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x43, 0x2b, 0x2b, 0x20,
-  0x54, 0x42, 0x41, 0x41, 0x00, 0x00, 0x13, 0x84, 0x09, 0xd9, 0x10, 0xf4,
-  0xc1, 0x86, 0x81, 0x0f, 0xfe, 0xc0, 0x0f, 0x36, 0x0c, 0xa0, 0x00, 0x0a,
-  0x7e, 0x00, 0x23, 0x06, 0x8d, 0x10, 0x82, 0x60, 0xf0, 0x48, 0x46, 0x81,
-  0x10, 0xc2, 0x10, 0x04, 0xce, 0x68, 0x42, 0x00, 0x50, 0x12, 0x8a, 0x09,
-  0x81, 0xf8, 0x67, 0x10, 0x10, 0x03, 0x02, 0x00, 0x00, 0x00, 0x5b, 0x06,
-  0x21, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20,
-  0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x32, 0x0e, 0x10, 0x22, 0x84, 0x00,
-  0xac, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x0c,
-  0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0x20, 0x01, 0x00,
-  0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x08, 0x00,
-  0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x02, 0x00,
-  0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, 0x00,
-  0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00,
-  0x00, 0x00, 0x53, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00,
-  0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x24, 0x00, 0x00, 0x11, 0x00,
-  0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x1b, 0x00,
-  0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x5d, 0x0c, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x12, 0x03,
-  0x94, 0xb3, 0x00, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x43, 0x6f,
-  0x70, 0x79, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x61,
-  0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x74, 0x65,
-  0x78, 0x74, 0x75, 0x72, 0x65, 0x5f, 0x32, 0x64, 0x2e, 0x76, 0x34, 0x66,
-  0x33, 0x32, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x34, 0x33, 0x61, 0x69,
+  0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x35, 0x63, 0x6f,
+  0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66, 0x29, 0x61, 0x69, 0x72,
+  0x2e, 0x70, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65,
+  0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74,
+  0x65, 0x64, 0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64,
+  0x44, 0x76, 0x32, 0x5f, 0x66, 0x29, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32,
+  0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x61, 0x69, 0x72, 0x2e,
+  0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x6c,
+  0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x64, 0x65,
+  0x78, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x74,
+  0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x32, 0x64, 0x3c, 0x66, 0x6c, 0x6f,
+  0x61, 0x74, 0x2c, 0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x3e, 0x74,
+  0x65, 0x78, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65,
+  0x72, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73, 0x00, 0x00, 0x00,
+  0x23, 0x08, 0x8c, 0x30, 0x82, 0x10, 0x1d, 0x23, 0x08, 0xcc, 0x30, 0x82,
+  0xc0, 0x10, 0x23, 0x08, 0x4c, 0x31, 0x82, 0x80, 0x00, 0x23, 0x08, 0x8c,
+  0x31, 0xc3, 0xf0, 0x05, 0x60, 0x30, 0xc3, 0x10, 0x06, 0x82, 0x18, 0xcc,
+  0x10, 0x0c, 0x33, 0x0c, 0xdf, 0x37, 0x06, 0x33, 0x10, 0x44, 0x18, 0x84,
+  0xc1, 0x18, 0xcc, 0x10, 0x14, 0x33, 0x04, 0xc6, 0x0c, 0xc1, 0x31, 0x43,
+  0x81, 0x8c, 0xc1, 0x18, 0x24, 0xca, 0x0c, 0x81, 0x1b, 0xcc, 0x80, 0x8c,
+  0xc1, 0xc2, 0x34, 0x89, 0xe2, 0x3c, 0x33, 0x24, 0x61, 0x00, 0x45, 0x8c,
+  0x94, 0x28, 0xce, 0x34, 0x43, 0xf2, 0x41, 0x14, 0x23, 0x25, 0x95, 0x63,
+  0xcd, 0xa0, 0x94, 0xc1, 0x85, 0x8d, 0x41, 0x18, 0x64, 0x89, 0xe6, 0x6c,
+  0x33, 0x24, 0x62, 0xc0, 0x61, 0x63, 0x10, 0x06, 0x49, 0xe7, 0x78, 0x33,
+  0x14, 0x70, 0x10, 0x07, 0x72, 0x30, 0x07, 0x74, 0x30, 0xc3, 0x40, 0x06,
+  0x6f, 0x50, 0x07, 0x32, 0x12, 0x98, 0xa0, 0x8b, 0xd8, 0xd8, 0xec, 0xda,
+  0x5c, 0xda, 0xde, 0xc8, 0xea, 0xd8, 0xca, 0x5c, 0xcc, 0xd8, 0xc2, 0xce,
+  0xe6, 0x46, 0x11, 0xca, 0xc0, 0x0c, 0x4e, 0x61, 0x63, 0xb3, 0x6b, 0x73,
+  0x49, 0x23, 0x2b, 0x73, 0xa3, 0x1b, 0x25, 0x38, 0x83, 0x5b, 0xc2, 0xd2,
+  0xe4, 0x5c, 0xec, 0xca, 0xe4, 0xe6, 0xd2, 0xde, 0xdc, 0x46, 0x09, 0xd0,
+  0xe0, 0xa8, 0xb0, 0x34, 0x39, 0x17, 0xb6, 0x30, 0xb7, 0xb3, 0xba, 0xb0,
+  0xb3, 0xb2, 0x2f, 0xbb, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x51, 0x82,
+  0x34, 0xb8, 0x29, 0x2c, 0x4d, 0xce, 0x65, 0xec, 0xad, 0x0d, 0x2e, 0x8d,
+  0xad, 0xec, 0xeb, 0x0d, 0x8e, 0x2e, 0xed, 0xcd, 0x6d, 0x6e, 0x94, 0x41,
+  0x0d, 0xd6, 0x80, 0x0d, 0x8e, 0x09, 0x4b, 0x93, 0x73, 0x31, 0x93, 0x0b,
+  0x3b, 0x6b, 0x2b, 0x73, 0xa3, 0x1b, 0x25, 0xa8, 0x03, 0x00, 0x00, 0x00,
+  0xa9, 0x18, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x0a, 0x72, 0x28,
+  0x87, 0x77, 0x80, 0x07, 0x7a, 0x58, 0x70, 0x98, 0x43, 0x3d, 0xb8, 0xc3,
+  0x38, 0xb0, 0x43, 0x39, 0xd0, 0xc3, 0x82, 0xe6, 0x1c, 0xc6, 0xa1, 0x0d,
+  0xe8, 0x41, 0x1e, 0xc2, 0xc1, 0x1d, 0xe6, 0x21, 0x1d, 0xe8, 0x21, 0x1d,
+  0xde, 0xc1, 0x1d, 0x00, 0xd1, 0x10, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+  0x07, 0xcc, 0x3c, 0xa4, 0x83, 0x3b, 0x9c, 0x03, 0x3b, 0x94, 0x03, 0x3d,
+  0xa0, 0x83, 0x3c, 0x94, 0x43, 0x38, 0x90, 0xc3, 0x01, 0x00, 0x00, 0x00,
+  0x61, 0x20, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c,
+  0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xb4, 0x6a, 0x60, 0x04,
+  0x80, 0xda, 0x08, 0x00, 0x81, 0x11, 0x00, 0x00, 0x23, 0x06, 0x8d, 0x10,
+  0x82, 0x60, 0xe0, 0x40, 0x46, 0x71, 0x10, 0xc2, 0x10, 0x04, 0xcc, 0x68,
+  0x42, 0x00, 0x58, 0xa0, 0x88, 0x7f, 0x06, 0x00, 0x71, 0x20, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x32, 0x0e, 0x10, 0x22, 0x84, 0x00, 0x96, 0x05,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x0c, 0x00, 0x00,
+  0x23, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0x20, 0x01, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+  0x44, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00,
+  0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+  0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+  0xff, 0xff, 0xff, 0xff, 0x00, 0x24, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+  0x1b, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00,
+  0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x5d, 0x0c, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0xb5,
+  0x00, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x43, 0x6f, 0x70, 0x79,
+  0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x69, 0x72,
+  0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x74, 0x65, 0x78, 0x74,
+  0x75, 0x72, 0x65, 0x5f, 0x32, 0x64, 0x2e, 0x76, 0x34, 0x66, 0x33, 0x32,
+  0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x35, 0x30, 0x2e, 0x31, 0x61, 0x69,
   0x72, 0x36, 0x34, 0x2d, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2d, 0x69, 0x6f,
   0x73, 0x31, 0x33, 0x2e, 0x30, 0x2e, 0x30, 0x2d, 0x73, 0x69, 0x6d, 0x75,
-  0x6c, 0x61, 0x74, 0x6f, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0,
-  0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x20, 0x0f,
-  0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x35, 0x14,
-  0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x62, 0x0c, 0x30, 0x24, 0x80, 0x10,
-  0x05, 0xc8, 0x14, 0x00, 0x00, 0x00, 0x21, 0x0c, 0x00, 0x00, 0x6a, 0x03,
-  0x00, 0x00, 0x0b, 0x02, 0x21, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00,
-  0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10,
-  0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04,
-  0x8b, 0x62, 0x80, 0x18, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xc4, 0x10,
-  0x32, 0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x62, 0x88, 0x48, 0x90,
-  0x14, 0x20, 0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0x04, 0x49,
-  0x0e, 0x90, 0x11, 0x23, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83,
-  0xe5, 0x8a, 0x04, 0x31, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x93, 0x00,
-  0x00, 0x00, 0x1b, 0xcc, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x58,
-  0x03, 0x40, 0x02, 0x2a, 0x62, 0x1c, 0xde, 0x41, 0x1e, 0xe4, 0xa1, 0x1c,
-  0xc6, 0x81, 0x1e, 0xd8, 0x21, 0x1f, 0xda, 0x40, 0x1e, 0xde, 0xa1, 0x1e,
-  0xdc, 0x81, 0x1c, 0xca, 0x81, 0x1c, 0xda, 0x80, 0x1c, 0xd2, 0xc1, 0x1e,
-  0xd2, 0x81, 0x1c, 0xca, 0xa1, 0x0d, 0xe6, 0x21, 0x1e, 0xe4, 0x81, 0x1e,
-  0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d,
-  0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x72, 0x48,
-  0x87, 0x79, 0x08, 0x07, 0x71, 0x60, 0x87, 0x72, 0x68, 0x03, 0x7a, 0x08,
-  0x87, 0x74, 0x60, 0x87, 0x36, 0x18, 0x87, 0x70, 0x60, 0x07, 0x76, 0x98,
-  0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1d,
-  0xca, 0x61, 0x1e, 0xe6, 0xa1, 0x0d, 0xe0, 0x41, 0x1e, 0xca, 0x61, 0x1c,
-  0xd2, 0x61, 0x1e, 0xca, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0x21, 0x1c,
-  0xc8, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x70,
-  0x87, 0x77, 0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72, 0x68,
-  0x03, 0x78, 0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79, 0x68,
-  0x83, 0x72, 0x60, 0x87, 0x74, 0x68, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e,
-  0xca, 0x01, 0x18, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c,
-  0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e,
-  0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0xa1, 0x0d,
-  0xdc, 0xe1, 0x1d, 0xdc, 0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xc2, 0xc1, 0x1c,
-  0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xd2, 0xc1, 0x1d, 0xcc, 0x61, 0x1e,
-  0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d,
-  0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68,
-  0x03, 0x75, 0xa8, 0x87, 0x76, 0x80, 0x87, 0x36, 0xa0, 0x87, 0x70, 0x10,
-  0x07, 0x76, 0x28, 0x87, 0x79, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e,
-  0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1d, 0xc2, 0xc1, 0x1d,
-  0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e,
-  0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78,
-  0x87, 0x36, 0x98, 0x87, 0x74, 0x38, 0x07, 0x77, 0x28, 0x07, 0x72, 0x68,
-  0x03, 0x7d, 0x28, 0x07, 0x79, 0x78, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80,
-  0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e,
-  0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe8, 0x41, 0x1e,
-  0xc2, 0x01, 0x1e, 0xe0, 0x21, 0x1d, 0xdc, 0xe1, 0x1c, 0xda, 0xa0, 0x1d,
-  0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00,
-  0x88, 0x79, 0xa0, 0x87, 0x70, 0x18, 0x87, 0x75, 0x68, 0x03, 0x78, 0x90,
-  0x87, 0x77, 0xa0, 0x87, 0x72, 0x18, 0x07, 0x7a, 0x78, 0x07, 0x79, 0x68,
-  0x03, 0x71, 0xa8, 0x07, 0x73, 0x30, 0x87, 0x72, 0x90, 0x87, 0x36, 0x98,
-  0x87, 0x74, 0xd0, 0x87, 0x72, 0x00, 0xf0, 0x00, 0x20, 0xea, 0xc1, 0x1d,
-  0xe6, 0x21, 0x1c, 0xcc, 0xa1, 0x1c, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d,
+  0x6c, 0x61, 0x74, 0x6f, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00,
+  0x14, 0x00, 0x00, 0x00, 0xb8, 0x0e, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+  0x42, 0x43, 0xc0, 0xde, 0x35, 0x14, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x62, 0x0c, 0x30, 0x24, 0x80, 0x10, 0x05, 0xc8, 0x14, 0x00, 0x00, 0x00,
+  0x21, 0x0c, 0x00, 0x00, 0x4f, 0x03, 0x00, 0x00, 0x0b, 0x02, 0x21, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91,
+  0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c,
+  0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x18, 0x45, 0x02,
+  0x42, 0x92, 0x0b, 0x42, 0xc4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x4b,
+  0x0a, 0x32, 0x62, 0x88, 0x48, 0x90, 0x14, 0x20, 0x43, 0x46, 0x88, 0xa5,
+  0x00, 0x19, 0x32, 0x42, 0x04, 0x49, 0x0e, 0x90, 0x11, 0x23, 0xc4, 0x50,
+  0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x31, 0x46, 0x06,
+  0x51, 0x18, 0x00, 0x00, 0x90, 0x00, 0x00, 0x00, 0x1b, 0xcc, 0x25, 0xf8,
+  0xff, 0xff, 0xff, 0xff, 0x01, 0x58, 0x03, 0x40, 0x02, 0x2a, 0x62, 0x1c,
+  0xde, 0x41, 0x1e, 0xe4, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xd8, 0x21, 0x1f,
+  0xda, 0x40, 0x1e, 0xde, 0xa1, 0x1e, 0xdc, 0x81, 0x1c, 0xca, 0x81, 0x1c,
+  0xda, 0x80, 0x1c, 0xd2, 0xc1, 0x1e, 0xd2, 0x81, 0x1c, 0xca, 0xa1, 0x0d,
+  0xe6, 0x21, 0x1e, 0xe4, 0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d,
+  0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98,
+  0x87, 0x72, 0x00, 0x08, 0x72, 0x48, 0x87, 0x79, 0x08, 0x07, 0x71, 0x60,
+  0x87, 0x72, 0x68, 0x03, 0x7a, 0x08, 0x87, 0x74, 0x60, 0x87, 0x36, 0x18,
+  0x87, 0x70, 0x60, 0x07, 0x76, 0x98, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d,
+  0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1d, 0xca, 0x61, 0x1e, 0xe6, 0xa1, 0x0d,
+  0xe0, 0x41, 0x1e, 0xca, 0x61, 0x1c, 0xd2, 0x61, 0x1e, 0xca, 0xa1, 0x0d,
+  0xcc, 0x01, 0x1e, 0xda, 0x21, 0x1c, 0xc8, 0x01, 0x30, 0x87, 0x70, 0x60,
+  0x87, 0x79, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90,
+  0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70,
+  0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68,
+  0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x18, 0xdc, 0xe1, 0x1d,
+  0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e,
+  0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c,
+  0xd8, 0x21, 0x1d, 0xda, 0xa1, 0x0d, 0xdc, 0xe1, 0x1d, 0xdc, 0xa1, 0x0d,
+  0xd8, 0xa1, 0x1c, 0xc2, 0xc1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d,
+  0xd2, 0xc1, 0x1d, 0xcc, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d,
   0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28,
-  0x07, 0x80, 0xa8, 0x87, 0x79, 0x28, 0x87, 0x36, 0x98, 0x87, 0x77, 0x30,
-  0x07, 0x7a, 0x68, 0x03, 0x73, 0x60, 0x87, 0x77, 0x08, 0x07, 0x7a, 0x00,
-  0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0xd8, 0xb0, 0x08, 0x03,
-  0x90, 0x00, 0x0b, 0x50, 0x05, 0x69, 0x00, 0x6d, 0x58, 0x06, 0x02, 0x48,
-  0x80, 0x05, 0xa8, 0x82, 0x34, 0x00, 0x85, 0x0d, 0x06, 0x51, 0x00, 0x0b,
-  0x50, 0x6d, 0x30, 0x8a, 0x03, 0x58, 0x80, 0x6a, 0x83, 0x61, 0xfc, 0xff,
-  0xff, 0xff, 0xff, 0x00, 0x48, 0x00, 0xb5, 0x41, 0x39, 0xfe, 0xff, 0xff,
-  0xff, 0x7f, 0x00, 0xda, 0x00, 0x58, 0x03, 0x40, 0x02, 0xaa, 0x0d, 0x06,
-  0x12, 0x00, 0x0b, 0x50, 0x6d, 0x30, 0x12, 0x01, 0x58, 0x80, 0x0a, 0x00,
-  0x00, 0x00, 0x49, 0x18, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x13, 0x8a,
-  0x40, 0x18, 0x88, 0x62, 0x42, 0x60, 0x4c, 0x18, 0x0e, 0x24, 0x01, 0x00,
-  0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x32, 0x22,
-  0x88, 0x09, 0x20, 0x64, 0x85, 0x04, 0x13, 0x23, 0xa4, 0x84, 0x04, 0x13,
-  0x23, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8c, 0x8c, 0x0b, 0x84,
-  0xc4, 0x4c, 0x10, 0x84, 0xc1, 0x0c, 0xc0, 0x30, 0x02, 0x01, 0x0c, 0x23,
-  0x08, 0xc0, 0x20, 0x42, 0x10, 0x0c, 0x23, 0x0c, 0xc0, 0x41, 0xd2, 0x14,
-  0x51, 0xc2, 0xe4, 0xcb, 0xee, 0xdb, 0x11, 0x82, 0x33, 0x10, 0x88, 0x20,
-  0x08, 0x82, 0x18, 0x44, 0x28, 0x84, 0xa3, 0xa4, 0x29, 0xa2, 0x84, 0xc9,
-  0xff, 0x27, 0xe2, 0x9a, 0xa8, 0x88, 0xf8, 0xed, 0xe1, 0x9f, 0xc6, 0x08,
-  0x80, 0x41, 0x84, 0x23, 0x38, 0x4d, 0x9a, 0x22, 0x4a, 0x98, 0xfc, 0x7f,
-  0x22, 0xae, 0x89, 0x8a, 0x88, 0xdf, 0x1e, 0x7e, 0x20, 0x8a, 0x00, 0xec,
-  0x9f, 0xc6, 0x08, 0x80, 0x41, 0x84, 0x24, 0xb8, 0x48, 0x9a, 0x22, 0x4a,
-  0x98, 0xfc, 0x5f, 0x02, 0x98, 0x67, 0x21, 0xa2, 0x7f, 0x1a, 0x23, 0x00,
-  0x06, 0x11, 0x16, 0xa1, 0x20, 0x41, 0x20, 0x0c, 0x06, 0xa2, 0x30, 0xd4,
-  0x94, 0x01, 0x20, 0x08, 0x7a, 0xe6, 0x08, 0x10, 0x23, 0x04, 0xd1, 0x1c,
-  0x01, 0x18, 0xcc, 0x11, 0x04, 0xc3, 0x08, 0xc2, 0x54, 0x16, 0x49, 0x61,
-  0x84, 0x89, 0xaa, 0x28, 0x00, 0x98, 0xc8, 0x2a, 0x8a, 0x84, 0x30, 0x02,
-  0x55, 0x51, 0x00, 0x30, 0x11, 0x36, 0x10, 0x90, 0x02, 0xd3, 0x30, 0xc2,
-  0x30, 0xcd, 0x11, 0x80, 0xc2, 0x20, 0x42, 0x20, 0x0c, 0x22, 0x10, 0xc2,
-  0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0xbe, 0x70, 0x48, 0x07, 0x79,
-  0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72,
-  0x68, 0x83, 0x74, 0x78, 0x87, 0x79, 0x88, 0x83, 0x39, 0x70, 0x03, 0x38,
-  0x70, 0x03, 0x38, 0x68, 0x83, 0x79, 0x48, 0x87, 0x76, 0xa8, 0x07, 0x76,
-  0x08, 0x07, 0x7a, 0x78, 0x07, 0x79, 0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06,
-  0xf0, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07,
-  0x76, 0x40, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07,
-  0x78, 0xd0, 0x06, 0xe9, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07,
-  0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07,
-  0x71, 0x60, 0x07, 0x6d, 0x90, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
-  0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e,
-  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07,
-  0x6d, 0x60, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07,
-  0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07,
-  0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07,
-  0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f,
-  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07,
-  0x6d, 0x60, 0x0f, 0x74, 0x80, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07,
-  0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07,
-  0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07,
-  0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07,
-  0x6d, 0x60, 0x0f, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07,
-  0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07,
-  0x79, 0x20, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07,
-  0x75, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07,
-  0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06,
-  0xf6, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07,
-  0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07,
-  0x72, 0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07,
-  0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07,
-  0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x11, 0xc2, 0x90, 0x10,
-  0xdb, 0x95, 0xbf, 0xec, 0xbe, 0x7f, 0x11, 0x01, 0x06, 0x43, 0x34, 0xd3,
-  0x90, 0x08, 0x80, 0x1a, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00,
-  0x00, 0x00, 0x18, 0x12, 0x41, 0xcd, 0x03, 0x04, 0x80, 0x00, 0x00, 0x00,
-  0x20, 0x00, 0x00, 0x00, 0x00, 0x43, 0xa2, 0x2e, 0x0c, 0x2c, 0x20, 0x00,
-  0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18, 0x12, 0xf9, 0xc1,
-  0x86, 0x01, 0x01, 0x30, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x80,
-  0xc4, 0x06, 0x81, 0xa2, 0x6c, 0x03, 0x00, 0x00, 0x59, 0x20, 0x0b, 0x00,
-  0x00, 0x00, 0x32, 0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09,
-  0x26, 0x47, 0xc6, 0x04, 0x43, 0x9a, 0x8a, 0xa0, 0x04, 0x0a, 0x61, 0x04,
-  0xa0, 0x40, 0xca, 0xa0, 0x00, 0x03, 0x0a, 0xa8, 0xc0, 0x4a, 0xa1, 0x18,
-  0xa8, 0x1b, 0x01, 0xa0, 0x6d, 0x2c, 0xc1, 0x11, 0x00, 0x00, 0xb1, 0x18,
-  0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1,
-  0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42,
-  0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f,
-  0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1,
-  0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84,
-  0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc,
-  0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70,
-  0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19,
-  0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f,
-  0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21,
-  0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc,
-  0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84,
-  0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37,
-  0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70,
-  0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77,
-  0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79,
-  0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e,
-  0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1,
-  0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81,
-  0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98,
-  0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88,
-  0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4,
-  0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72,
-  0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74,
-  0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e,
-  0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e,
-  0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21,
-  0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01,
-  0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc,
-  0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77,
-  0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e,
-  0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1,
-  0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61,
-  0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0,
-  0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0,
-  0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74,
-  0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e,
-  0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41,
-  0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50,
-  0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c,
-  0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc,
-  0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x79, 0x20, 0x00, 0x00, 0x0c, 0x01,
-  0x00, 0x00, 0x32, 0x9a, 0x08, 0x14, 0x02, 0x85, 0x8c, 0x27, 0x46, 0x46,
-  0xc8, 0x11, 0x32, 0x64, 0xd4, 0xd8, 0x80, 0x0c, 0xf2, 0x09, 0x8b, 0xe2,
-  0x06, 0xc5, 0xc6, 0x91, 0x41, 0x14, 0x19, 0x8c, 0x22, 0x31, 0x88, 0x94,
-  0x3d, 0x06, 0xa2, 0x3c, 0x12, 0x12, 0x5d, 0x03, 0x65, 0x18, 0x86, 0x61,
-  0x24, 0xc6, 0xa2, 0x60, 0x84, 0x57, 0x2c, 0x47, 0x00, 0x00, 0x53, 0x44,
-  0x4b, 0x20, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68,
-  0x61, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x41, 0x70, 0x70, 0x6c, 0x65,
-  0x20, 0x4c, 0x4c, 0x56, 0x4d, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f,
-  0x6e, 0x20, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x34, 0x33, 0x20, 0x28,
-  0x6d, 0x65, 0x74, 0x61, 0x6c, 0x66, 0x65, 0x2d, 0x33, 0x31, 0x30, 0x30,
-  0x31, 0x2e, 0x34, 0x33, 0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x61, 0x69,
-  0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x64, 0x65,
-  0x6e, 0x6f, 0x72, 0x6d, 0x73, 0x5f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c,
+  0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x75, 0xa8, 0x87, 0x76, 0x80,
+  0x87, 0x36, 0xa0, 0x87, 0x70, 0x10, 0x07, 0x76, 0x28, 0x87, 0x79, 0x00,
+  0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0xc0, 0x1d, 0xc2, 0xc1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e,
+  0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8,
+  0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x98, 0x87, 0x74, 0x38,
+  0x07, 0x77, 0x28, 0x07, 0x72, 0x68, 0x03, 0x7d, 0x28, 0x07, 0x79, 0x78,
+  0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0,
+  0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d,
+  0xde, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0x01, 0x1e, 0xe0, 0x21, 0x1d,
+  0xdc, 0xe1, 0x1c, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0,
+  0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x88, 0x79, 0xa0, 0x87, 0x70, 0x18,
+  0x87, 0x75, 0x68, 0x03, 0x78, 0x90, 0x87, 0x77, 0xa0, 0x87, 0x72, 0x18,
+  0x07, 0x7a, 0x78, 0x07, 0x79, 0x68, 0x03, 0x71, 0xa8, 0x07, 0x73, 0x30,
+  0x87, 0x72, 0x90, 0x87, 0x36, 0x98, 0x87, 0x74, 0xd0, 0x87, 0x72, 0x00,
+  0xf0, 0x00, 0x20, 0xea, 0xc1, 0x1d, 0xe6, 0x21, 0x1c, 0xcc, 0xa1, 0x1c,
+  0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d,
+  0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0xa8, 0x87, 0x79, 0x28,
+  0x87, 0x36, 0x98, 0x87, 0x77, 0x30, 0x07, 0x7a, 0x68, 0x03, 0x73, 0x60,
+  0x87, 0x77, 0x08, 0x07, 0x7a, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e,
+  0xca, 0x01, 0xd8, 0xb0, 0x08, 0x04, 0x90, 0x00, 0x0b, 0x50, 0x05, 0x69,
+  0x00, 0x0a, 0x1b, 0x8c, 0xa1, 0x00, 0x16, 0xa0, 0xda, 0x60, 0x10, 0x07,
+  0xb0, 0x00, 0xd5, 0x06, 0xa3, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90,
+  0x00, 0x6a, 0x83, 0x62, 0xfc, 0xff, 0xff, 0xff, 0xff, 0x00, 0xb4, 0x01,
+  0xb0, 0x06, 0x80, 0x04, 0x54, 0x1b, 0x8c, 0x23, 0x00, 0x16, 0xa0, 0xda,
+  0x60, 0x20, 0x02, 0xb0, 0x00, 0x15, 0x00, 0x00, 0x49, 0x18, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x13, 0x88, 0x40, 0x18, 0x88, 0x09, 0x41, 0x31,
+  0x61, 0x30, 0x0e, 0x04, 0x89, 0x20, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00,
+  0x32, 0x22, 0x88, 0x09, 0x20, 0x64, 0x85, 0x04, 0x13, 0x23, 0xa4, 0x84,
+  0x04, 0x13, 0x23, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8c, 0x8c,
+  0x0b, 0x84, 0xc4, 0x4c, 0x10, 0x80, 0xc1, 0x0c, 0xc0, 0x30, 0x02, 0x01,
+  0x0c, 0x23, 0x08, 0xc0, 0x30, 0xc2, 0x00, 0x1c, 0x24, 0x4d, 0x11, 0x25,
+  0x4c, 0xbe, 0xec, 0xbe, 0x1d, 0x21, 0x38, 0x03, 0x81, 0x88, 0x61, 0x18,
+  0x86, 0x41, 0x04, 0x42, 0x38, 0x4a, 0x9a, 0x22, 0x4a, 0x98, 0xfc, 0x7f,
+  0x22, 0xae, 0x89, 0x8a, 0x88, 0xdf, 0x1e, 0xfe, 0x69, 0x8c, 0x00, 0x18,
+  0x44, 0x30, 0x82, 0xd3, 0xa4, 0x29, 0xa2, 0x84, 0xc9, 0xff, 0x27, 0xe2,
+  0x9a, 0xa8, 0x88, 0xf8, 0xed, 0xe1, 0x07, 0xa2, 0x08, 0xc0, 0xfe, 0x69,
+  0x8c, 0x00, 0x18, 0x44, 0x40, 0x82, 0x8b, 0xa4, 0x29, 0xa2, 0x84, 0xc9,
+  0xff, 0x25, 0x80, 0x79, 0x16, 0x22, 0xfa, 0xa7, 0x31, 0x02, 0x60, 0x10,
+  0x41, 0x11, 0x0a, 0x12, 0x04, 0x81, 0x50, 0x1c, 0xc9, 0x42, 0x4c, 0x19,
+  0x80, 0x61, 0x20, 0x67, 0x8e, 0x00, 0x31, 0x42, 0x00, 0xcd, 0x11, 0x80,
+  0xc1, 0x1c, 0x41, 0x30, 0x8c, 0x20, 0x48, 0x65, 0x89, 0x92, 0x45, 0x90,
+  0x26, 0x6a, 0x02, 0x00, 0x89, 0xaa, 0xa2, 0x44, 0xc7, 0x22, 0x4c, 0xd4,
+  0x04, 0x00, 0x12, 0x5d, 0x03, 0x01, 0x29, 0x20, 0x0d, 0x23, 0x0c, 0xd2,
+  0x1c, 0x01, 0x28, 0x0c, 0x22, 0x04, 0xc2, 0x20, 0xc2, 0x20, 0x8c, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x13, 0xbe, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03,
+  0x3a, 0x68, 0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83,
+  0x74, 0x78, 0x87, 0x79, 0x88, 0x83, 0x39, 0x70, 0x03, 0x38, 0x70, 0x03,
+  0x38, 0x68, 0x83, 0x79, 0x48, 0x87, 0x76, 0xa8, 0x07, 0x76, 0x08, 0x07,
+  0x7a, 0x78, 0x07, 0x79, 0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06, 0xf0, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0,
+  0x06, 0xe9, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90,
+  0x0e, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x6d, 0x90, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60,
+  0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60,
+  0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x6d, 0x60, 0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0,
+  0x07, 0x71, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x73, 0x20,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60,
+  0x0f, 0x74, 0x80, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x6d, 0x60, 0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07, 0x7a, 0x10,
+  0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60,
+  0x0f, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0,
+  0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x79, 0x20,
+  0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60,
+  0x07, 0x6d, 0x60, 0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50,
+  0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x50,
+  0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50,
+  0x07, 0x71, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07, 0x72, 0x40,
+  0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00,
+  0x07, 0x72, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x11, 0xc2, 0x90, 0x10, 0xdb, 0x95,
+  0xbf, 0xec, 0xbe, 0x7f, 0x11, 0x01, 0x06, 0x43, 0x34, 0xd3, 0x90, 0x08,
+  0x80, 0x18, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x18, 0x12, 0x41, 0x8d, 0x03, 0x04, 0x80, 0x00, 0x00, 0x00, 0x20, 0x00,
+  0x00, 0x00, 0x00, 0x43, 0xa2, 0x2e, 0x0c, 0x2a, 0x20, 0x00, 0x06, 0x00,
+  0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18, 0x12, 0xf9, 0xc1, 0x76, 0x01,
+  0x01, 0x30, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x80, 0xc4, 0x06,
+  0x81, 0xa2, 0x51, 0x03, 0x00, 0x00, 0x59, 0x20, 0x0a, 0x00, 0x00, 0x00,
+  0x32, 0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47,
+  0xc6, 0x04, 0x43, 0x92, 0x8a, 0xa0, 0x04, 0x0a, 0x61, 0x04, 0xa0, 0x0c,
+  0x0a, 0x30, 0xa0, 0x40, 0x0a, 0xa8, 0xc0, 0x4a, 0xa1, 0x18, 0x48, 0x1b,
+  0x4b, 0x70, 0x08, 0x00, 0xb1, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00,
+  0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88,
+  0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73,
+  0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e,
+  0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30,
+  0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8,
+  0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b,
+  0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76,
+  0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e,
+  0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e,
+  0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61,
+  0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4,
+  0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76,
+  0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37,
+  0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76,
+  0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71,
+  0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e,
+  0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1,
+  0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61,
+  0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90,
+  0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8,
+  0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc,
+  0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7,
+  0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78,
+  0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f,
+  0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f,
+  0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1,
+  0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0,
+  0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0,
+  0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b,
+  0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c,
+  0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61,
+  0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1,
+  0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc,
+  0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4,
+  0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79,
+  0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72,
+  0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e,
+  0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1,
+  0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8,
+  0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8,
+  0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00,
+  0x79, 0x20, 0x00, 0x00, 0x10, 0x01, 0x00, 0x00, 0x32, 0x9a, 0x08, 0x14,
+  0x02, 0x85, 0x8c, 0x27, 0x46, 0x46, 0xc8, 0x11, 0x32, 0x64, 0xd4, 0xda,
+  0x80, 0x0c, 0x66, 0x0a, 0x8b, 0x02, 0x07, 0xc5, 0xc6, 0x91, 0x41, 0x14,
+  0x19, 0x8c, 0x22, 0x31, 0x88, 0x64, 0x3d, 0x45, 0x66, 0x20, 0xca, 0x23,
+  0x21, 0x94, 0x61, 0x18, 0x86, 0x11, 0x5d, 0x89, 0xb1, 0x28, 0x18, 0xe1,
+  0x15, 0xcb, 0x11, 0x00, 0x53, 0x44, 0x4b, 0x20, 0x56, 0x65, 0x72, 0x73,
+  0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68, 0x61, 0x72, 0x5f, 0x73, 0x69, 0x7a,
+  0x65, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x4c, 0x4c, 0x56, 0x4d, 0x20,
+  0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x33, 0x31, 0x30, 0x30,
+  0x31, 0x2e, 0x35, 0x30, 0x20, 0x28, 0x6d, 0x65, 0x74, 0x61, 0x6c, 0x66,
+  0x65, 0x2d, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x35, 0x30, 0x2e, 0x31,
+  0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f,
+  0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x64, 0x65, 0x6e, 0x6f, 0x72, 0x6d,
+  0x73, 0x5f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72,
+  0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73,
+  0x74, 0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c,
   0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65,
-  0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65,
-  0x6e, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d,
-  0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x62, 0x75,
-  0x66, 0x66, 0x65, 0x72, 0x5f, 0x66, 0x65, 0x74, 0x63, 0x68, 0x5f, 0x65,
-  0x6e, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x6e,
-  0x64, 0x65, 0x72, 0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x61, 0x69,
-  0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x6e,
-  0x61, 0x6d, 0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x61, 0x69, 0x72,
-  0x2e, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x69, 0x72,
-  0x2e, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x6e,
-  0x6f, 0x5f, 0x70, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76,
-  0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x6e, 0x61, 0x6d,
-  0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x69, 0x72,
-  0x2e, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x6e,
-  0x70, 0x75, 0x74, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64,
-  0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x44, 0x76,
-  0x32, 0x5f, 0x66, 0x29, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x65, 0x72, 0x73,
-  0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74,
-  0x32, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x61, 0x69, 0x72,
-  0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x62,
-  0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69,
-  0x72, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69,
-  0x6e, 0x64, 0x65, 0x78, 0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x61, 0x64,
-  0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65,
-  0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67,
-  0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f,
-  0x73, 0x69, 0x7a, 0x65, 0x63, 0x6f, 0x6c, 0x61, 0x69, 0x72, 0x2e, 0x73,
-  0x74, 0x72, 0x75, 0x63, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x69,
-  0x6e, 0x66, 0x6f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x6f, 0x66, 0x66,
-  0x73, 0x65, 0x74, 0x52, 0x63, 0x6f, 0x65, 0x66, 0x66, 0x47, 0x63, 0x6f,
-  0x65, 0x66, 0x66, 0x42, 0x63, 0x6f, 0x65, 0x66, 0x66, 0x59, 0x55, 0x56,
-  0x44, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x65, 0x63, 0x6f, 0x64, 0x65,
-  0x61, 0x69, 0x72, 0x2e, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x61,
-  0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x78,
-  0x74, 0x75, 0x72, 0x65, 0x32, 0x64, 0x3c, 0x66, 0x6c, 0x6f, 0x61, 0x74,
-  0x2c, 0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x3e, 0x74, 0x65, 0x78,
-  0x59, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x32, 0x64, 0x5f, 0x61,
-  0x72, 0x72, 0x61, 0x79, 0x3c, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x2c, 0x20,
-  0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x3e, 0x74, 0x65, 0x78, 0x55, 0x56,
-  0x61, 0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73,
-  0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73, 0x00, 0x00, 0x00, 0x64, 0x78,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x82, 0x30, 0x11, 0x23, 0x08,
-  0x1b, 0x34, 0x82, 0x30, 0x15, 0x23, 0x08, 0x93, 0x31, 0x82, 0x30, 0x1d,
-  0x23, 0x08, 0x0e, 0x30, 0x82, 0x30, 0x21, 0x23, 0x08, 0x53, 0x32, 0x82,
-  0x30, 0x29, 0x23, 0x08, 0xd3, 0x32, 0x82, 0x30, 0x31, 0x23, 0x08, 0x53,
-  0x33, 0x82, 0x30, 0x39, 0x33, 0x0c, 0x6d, 0x10, 0xb8, 0xc1, 0x0c, 0xc3,
-  0x1b, 0x08, 0x70, 0x30, 0x43, 0x30, 0xcc, 0x30, 0xb4, 0x41, 0x1b, 0xc4,
-  0xc1, 0x0c, 0x04, 0xf1, 0x06, 0x6f, 0x10, 0x07, 0x33, 0x04, 0xc5, 0x0c,
-  0x81, 0x31, 0x43, 0x70, 0xcc, 0x50, 0x20, 0x71, 0x10, 0x07, 0x89, 0x32,
-  0x43, 0x20, 0x0a, 0x33, 0x20, 0x71, 0xb0, 0x30, 0x4d, 0xa2, 0x38, 0xcf,
-  0x0c, 0xc9, 0x1b, 0x40, 0x11, 0x23, 0x25, 0x93, 0x43, 0xcd, 0x00, 0xb5,
-  0x41, 0x65, 0xcd, 0xc1, 0x15, 0x07, 0x6f, 0x80, 0x65, 0x73, 0xa0, 0xcd,
-  0x41, 0xa2, 0x38, 0xdb, 0x0c, 0x54, 0x1c, 0xcc, 0x41, 0x1c, 0x74, 0xde,
-  0x1c, 0xcc, 0x41, 0x1c, 0x74, 0x9f, 0x1d, 0xcc, 0x41, 0x1c, 0x74, 0x60,
-  0x70, 0x07, 0x73, 0x10, 0x07, 0x5d, 0x18, 0xcc, 0x20, 0xd1, 0x41, 0x65,
-  0xd5, 0xc1, 0xf5, 0x06, 0x6f, 0x80, 0x71, 0xa7, 0x90, 0xd5, 0x81, 0x36,
-  0x07, 0x89, 0x18, 0x38, 0x63, 0x30, 0x83, 0x02, 0x07, 0x64, 0x70, 0xc5,
-  0xc1, 0x1b, 0x94, 0x41, 0x62, 0x06, 0xce, 0x19, 0xcc, 0xa0, 0xe0, 0x01,
-  0x19, 0x5c, 0x6f, 0xf0, 0x06, 0x65, 0x90, 0xa0, 0x81, 0x93, 0x06, 0x33,
-  0x24, 0x79, 0xa0, 0x06, 0x57, 0x1c, 0xbc, 0x41, 0xb2, 0x06, 0x0e, 0x1b,
-  0xcc, 0x70, 0x90, 0x42, 0x29, 0x98, 0x02, 0x2a, 0xa4, 0x82, 0x2a, 0xac,
-  0xc2, 0x0c, 0x83, 0x1c, 0x8c, 0x02, 0x2b, 0x54, 0x18, 0x00, 0x1c, 0xc7,
-  0x71, 0x1c, 0xc7, 0x71, 0x1c, 0xc7, 0x71, 0x9c, 0x1b, 0xb8, 0x81, 0x45,
-  0x07, 0x7a, 0x60, 0x59, 0x96, 0x1e, 0x70, 0xa6, 0xc0, 0x0a, 0x34, 0xc1,
-  0x1b, 0x72, 0x61, 0x0f, 0xf6, 0xa0, 0x0e, 0xe4, 0x20, 0x23, 0x81, 0x09,
-  0xba, 0x88, 0x8d, 0xcd, 0xae, 0xcd, 0xa5, 0xed, 0x8d, 0xac, 0x8e, 0xad,
-  0xcc, 0xc5, 0x8c, 0x2d, 0xec, 0x6c, 0x6e, 0x14, 0x21, 0x0f, 0xf4, 0xe0,
-  0x14, 0x36, 0x36, 0xbb, 0x36, 0x97, 0x34, 0xb2, 0x32, 0x37, 0xba, 0x51,
-  0x82, 0x3d, 0xb8, 0x25, 0x2c, 0x4d, 0xce, 0xc5, 0xae, 0x4c, 0x6e, 0x2e,
-  0xed, 0xcd, 0x6d, 0x94, 0x80, 0x0f, 0x8e, 0x0a, 0x4b, 0x93, 0x73, 0x61,
-  0x0b, 0x73, 0x3b, 0xab, 0x0b, 0x3b, 0x2b, 0xfb, 0xb2, 0x2b, 0x93, 0x9b,
-  0x4b, 0x7b, 0x73, 0x1b, 0x25, 0xe8, 0x83, 0x9b, 0xc2, 0xd2, 0xe4, 0x5c,
-  0xc6, 0xde, 0xda, 0xe0, 0xd2, 0xd8, 0xca, 0xbe, 0xde, 0xe0, 0xe8, 0xd2,
-  0xde, 0xdc, 0xe6, 0x46, 0x19, 0xfc, 0xe0, 0x0f, 0x40, 0xe1, 0x98, 0xb0,
-  0x34, 0x39, 0x17, 0x33, 0xb9, 0xb0, 0xb3, 0xb6, 0x32, 0x37, 0xba, 0x51,
-  0x02, 0x56, 0x00, 0x00, 0x00, 0x00, 0xa9, 0x18, 0x00, 0x00, 0x0b, 0x00,
-  0x00, 0x00, 0x0b, 0x0a, 0x72, 0x28, 0x87, 0x77, 0x80, 0x07, 0x7a, 0x58,
-  0x70, 0x98, 0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb0, 0x43, 0x39, 0xd0, 0xc3,
-  0x82, 0xe6, 0x1c, 0xc6, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0xc1, 0x1d,
-  0xe6, 0x21, 0x1d, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x00, 0xd1, 0x10,
-  0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0xcc, 0x3c, 0xa4, 0x83, 0x3b,
-  0x9c, 0x03, 0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83, 0x3c, 0x94, 0x43, 0x38,
-  0x90, 0xc3, 0x01, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x5b, 0x00,
-  0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x0d, 0x00,
-  0x00, 0x00, 0x34, 0xcd, 0x00, 0x10, 0x55, 0x03, 0x23, 0x00, 0x54, 0x8d,
-  0x00, 0x10, 0x37, 0xd6, 0x00, 0x04, 0xc2, 0x1c, 0xc3, 0x81, 0x61, 0xd4,
-  0x95, 0x40, 0x11, 0x10, 0x30, 0x02, 0x30, 0x03, 0x30, 0x46, 0x00, 0x82,
+  0x2e, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72,
+  0x5f, 0x66, 0x65, 0x74, 0x63, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c,
+  0x65, 0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x5f,
+  0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72,
+  0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x66,
+  0x6c, 0x6f, 0x61, 0x74, 0x34, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x6f, 0x73,
+  0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x65, 0x6e,
+  0x74, 0x65, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x6e, 0x6f, 0x5f, 0x70, 0x65,
+  0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x61, 0x69, 0x72,
+  0x2e, 0x61, 0x72, 0x67, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x70, 0x6f, 0x73,
+  0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x72, 0x61,
+  0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x67,
+  0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x35, 0x63, 0x6f,
+  0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66, 0x29, 0x61, 0x69, 0x72,
+  0x2e, 0x70, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65,
+  0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74,
+  0x65, 0x64, 0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64,
+  0x44, 0x76, 0x32, 0x5f, 0x66, 0x29, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32,
+  0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x61, 0x69, 0x72, 0x2e,
+  0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75,
+  0x66, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72,
+  0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e,
+  0x64, 0x65, 0x78, 0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x61, 0x64, 0x61,
+  0x69, 0x72, 0x2e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x5f, 0x74, 0x79,
+  0x70, 0x65, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x66, 0x6c, 0x6f, 0x61, 0x74,
+  0x33, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x52, 0x63, 0x6f, 0x65, 0x66,
+  0x66, 0x47, 0x63, 0x6f, 0x65, 0x66, 0x66, 0x42, 0x63, 0x6f, 0x65, 0x66,
+  0x66, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70,
+  0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72,
+  0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e,
+  0x5f, 0x73, 0x69, 0x7a, 0x65, 0x59, 0x55, 0x56, 0x44, 0x65, 0x63, 0x6f,
+  0x64, 0x65, 0x64, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x61, 0x69, 0x72, 0x2e,
+  0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x73,
+  0x61, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65,
+  0x32, 0x64, 0x3c, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x2c, 0x20, 0x73, 0x61,
+  0x6d, 0x70, 0x6c, 0x65, 0x3e, 0x74, 0x65, 0x78, 0x59, 0x74, 0x65, 0x78,
+  0x74, 0x75, 0x72, 0x65, 0x32, 0x64, 0x5f, 0x61, 0x72, 0x72, 0x61, 0x79,
+  0x3c, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x2c, 0x20, 0x73, 0x61, 0x6d, 0x70,
+  0x6c, 0x65, 0x3e, 0x74, 0x65, 0x78, 0x55, 0x56, 0x61, 0x69, 0x72, 0x2e,
+  0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73, 0x61, 0x6d, 0x70, 0x6c,
+  0x65, 0x72, 0x73, 0x00, 0x44, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x30, 0x82, 0x20, 0x11, 0x23, 0x08, 0xda, 0x33, 0x82, 0x20, 0x15, 0x23,
+  0x08, 0x92, 0x31, 0x82, 0x20, 0x1d, 0x23, 0x08, 0x0d, 0x30, 0x82, 0x20,
+  0x21, 0x23, 0x08, 0x52, 0x32, 0x82, 0x20, 0x29, 0x23, 0x08, 0xd2, 0x32,
+  0x82, 0x20, 0x31, 0x23, 0x08, 0x52, 0x33, 0x82, 0x20, 0x39, 0x33, 0x0c,
+  0x6e, 0x10, 0xbc, 0xc1, 0x0c, 0x03, 0x1c, 0x08, 0x71, 0x30, 0x43, 0x30,
+  0xcc, 0x30, 0xb8, 0x81, 0x1b, 0xc8, 0xc1, 0x0c, 0x04, 0x01, 0x07, 0x70,
+  0x20, 0x07, 0x33, 0x04, 0xc5, 0x0c, 0x81, 0x31, 0x43, 0x70, 0xcc, 0x50,
+  0x20, 0x72, 0x20, 0x07, 0x89, 0x32, 0x43, 0x30, 0x0a, 0x33, 0x20, 0x72,
+  0xb0, 0x30, 0x4d, 0xa2, 0x38, 0xcf, 0x0c, 0x09, 0x1c, 0x40, 0x11, 0x23,
+  0x25, 0x8a, 0x33, 0xcd, 0x90, 0xb8, 0x01, 0x44, 0x31, 0x52, 0x52, 0x39,
+  0xd6, 0x0c, 0x94, 0x1c, 0xd8, 0x81, 0x1c, 0x70, 0x9d, 0x1d, 0xd8, 0x81,
+  0x1c, 0x70, 0xde, 0x1d, 0xd8, 0x81, 0x1c, 0x70, 0x1f, 0x1e, 0xd8, 0x81,
+  0x1c, 0x70, 0x60, 0x30, 0x83, 0x44, 0x07, 0x17, 0x56, 0x07, 0x19, 0x1c,
+  0xc0, 0x81, 0xb6, 0xa1, 0x42, 0x18, 0xd4, 0x81, 0x18, 0xd8, 0x41, 0x32,
+  0x06, 0x0e, 0x19, 0xcc, 0xa0, 0xc4, 0x41, 0x19, 0x64, 0x72, 0x00, 0x07,
+  0x66, 0x90, 0x9c, 0x81, 0x83, 0x06, 0x33, 0x28, 0x79, 0x50, 0x06, 0x19,
+  0x1c, 0xc0, 0x81, 0x19, 0x24, 0x69, 0xe0, 0xa8, 0xc1, 0x0c, 0x89, 0x1e,
+  0xac, 0x41, 0x26, 0x07, 0x70, 0x90, 0xb0, 0x81, 0xd3, 0x06, 0x33, 0x1c,
+  0xa5, 0x60, 0x0a, 0xa7, 0x90, 0x0a, 0xaa, 0xb0, 0x0a, 0xac, 0x30, 0xc3,
+  0x30, 0x07, 0xa4, 0xd0, 0x0a, 0x15, 0x06, 0x00, 0xc7, 0x71, 0x1c, 0xc7,
+  0x71, 0x1c, 0xc7, 0x71, 0x1c, 0xe7, 0x06, 0x6e, 0x60, 0xd1, 0x81, 0x1e,
+  0x58, 0x96, 0xa5, 0x07, 0x9c, 0x29, 0xb0, 0x02, 0x2b, 0xd8, 0x86, 0x5f,
+  0xd8, 0x83, 0x3d, 0xa8, 0x03, 0x39, 0xc8, 0x48, 0x60, 0x82, 0x2e, 0x62,
+  0x63, 0xb3, 0x6b, 0x73, 0x69, 0x7b, 0x23, 0xab, 0x63, 0x2b, 0x73, 0x31,
+  0x63, 0x0b, 0x3b, 0x9b, 0x1b, 0x45, 0xd0, 0x83, 0x3d, 0x38, 0x85, 0x8d,
+  0xcd, 0xae, 0xcd, 0x25, 0x8d, 0xac, 0xcc, 0x8d, 0x6e, 0x94, 0x80, 0x0f,
+  0x6e, 0x09, 0x4b, 0x93, 0x73, 0xb1, 0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73,
+  0x1b, 0x25, 0xe8, 0x83, 0xa3, 0xc2, 0xd2, 0xe4, 0x5c, 0xd8, 0xc2, 0xdc,
+  0xce, 0xea, 0xc2, 0xce, 0xca, 0xbe, 0xec, 0xca, 0xe4, 0xe6, 0xd2, 0xde,
+  0xdc, 0x46, 0x09, 0xfc, 0xe0, 0xa6, 0xb0, 0x34, 0x39, 0x97, 0xb1, 0xb7,
+  0x36, 0xb8, 0x34, 0xb6, 0xb2, 0xaf, 0x37, 0x38, 0xba, 0xb4, 0x37, 0xb7,
+  0xb9, 0x51, 0x86, 0x3f, 0x00, 0x85, 0x50, 0x38, 0x26, 0x2c, 0x4d, 0xce,
+  0xc5, 0x4c, 0x2e, 0xec, 0xac, 0xad, 0xcc, 0x8d, 0x6e, 0x94, 0xa0, 0x15,
+  0x00, 0x00, 0x00, 0x00, 0xa9, 0x18, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
+  0x0b, 0x0a, 0x72, 0x28, 0x87, 0x77, 0x80, 0x07, 0x7a, 0x58, 0x70, 0x98,
+  0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb0, 0x43, 0x39, 0xd0, 0xc3, 0x82, 0xe6,
+  0x1c, 0xc6, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0xc1, 0x1d, 0xe6, 0x21,
+  0x1d, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x00, 0xd1, 0x10, 0x00, 0x00,
+  0x06, 0x00, 0x00, 0x00, 0x07, 0xcc, 0x3c, 0xa4, 0x83, 0x3b, 0x9c, 0x03,
+  0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83, 0x3c, 0x94, 0x43, 0x38, 0x90, 0xc3,
+  0x01, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00,
+  0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00,
+  0x24, 0xcd, 0x00, 0xd0, 0x54, 0x03, 0x23, 0x00, 0x44, 0x8d, 0x00, 0xd0,
+  0x36, 0xd6, 0x00, 0x04, 0xc2, 0x1c, 0xc3, 0x71, 0x5d, 0xc4, 0x8d, 0x00,
+  0x94, 0x40, 0x11, 0x10, 0x30, 0x02, 0x30, 0x03, 0x30, 0x46, 0x00, 0x82,
   0x20, 0x88, 0x7f, 0x14, 0xcc, 0x00, 0xcc, 0x41, 0x84, 0x41, 0x18, 0x84,
-  0x81, 0x18, 0x00, 0x00, 0x00, 0x00, 0xf1, 0x30, 0x00, 0x00, 0x11, 0x00,
-  0x00, 0x00, 0x22, 0x47, 0xc8, 0x90, 0x51, 0x0a, 0x84, 0x18, 0x00, 0x00,
-  0x00, 0x00, 0xcf, 0x03, 0x00, 0x00, 0x6f, 0x6d, 0x6e, 0x69, 0x70, 0x6f,
-  0x74, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x68, 0x61, 0x72, 0x53, 0x69, 0x6d,
-  0x70, 0x6c, 0x65, 0x20, 0x43, 0x2b, 0x2b, 0x20, 0x54, 0x42, 0x41, 0x41,
-  0x00, 0x00, 0x13, 0x84, 0xee, 0xd9, 0x10, 0xbc, 0xc2, 0x86, 0xc1, 0x15,
-  0x62, 0x01, 0x16, 0x36, 0x0c, 0xb2, 0x20, 0x0b, 0xb0, 0x00, 0x23, 0x06,
-  0xcd, 0x10, 0x82, 0x60, 0x80, 0x89, 0x01, 0xe4, 0x4c, 0x8c, 0xb2, 0x14,
-  0x85, 0x37, 0x9a, 0x10, 0x00, 0x83, 0x0c, 0x01, 0xa1, 0x8c, 0x18, 0x38,
-  0x43, 0x08, 0x82, 0x81, 0x65, 0x06, 0x52, 0x64, 0x85, 0xc1, 0xd3, 0x38,
-  0x08, 0x12, 0x06, 0xa3, 0x09, 0x01, 0x30, 0x86, 0x10, 0x6c, 0x73, 0x0c,
-  0x44, 0xd0, 0x8c, 0x18, 0x38, 0x43, 0x08, 0x82, 0x81, 0xa5, 0x06, 0x56,
-  0xa5, 0x9d, 0xc1, 0x14, 0x49, 0x0c, 0x53, 0x06, 0xa3, 0x09, 0x01, 0x30,
-  0x86, 0x10, 0x7c, 0x73, 0x0c, 0x44, 0x00, 0x1d, 0xe7, 0x2d, 0x05, 0x41,
-  0x19, 0x64, 0x08, 0x1e, 0xcb, 0x88, 0x00, 0xfc, 0x29, 0x0c, 0x82, 0xb2,
-  0x8b, 0x21, 0x0c, 0xcc, 0x00, 0x0e, 0x2e, 0xf0, 0x96, 0x82, 0xa0, 0x0c,
-  0x32, 0x04, 0x15, 0x37, 0x62, 0x70, 0x08, 0x21, 0x08, 0x16, 0xfe, 0xf1,
-  0xe0, 0x81, 0x11, 0xec, 0x62, 0x30, 0x83, 0x35, 0xb0, 0x83, 0x0b, 0xbc,
-  0xa5, 0x20, 0x28, 0x83, 0x0c, 0x81, 0x16, 0x06, 0x23, 0x06, 0x87, 0x10,
-  0x82, 0x60, 0xe1, 0x1f, 0x4f, 0x1f, 0x2c, 0xc1, 0x2e, 0x86, 0x35, 0x80,
-  0x03, 0x3b, 0xb8, 0xc0, 0x5b, 0x0a, 0x82, 0x32, 0xc8, 0x10, 0x7c, 0x66,
-  0x30, 0x62, 0x70, 0x08, 0x21, 0x08, 0x16, 0xfe, 0xf1, 0x88, 0x02, 0x14,
-  0xcc, 0x31, 0x80, 0xc1, 0xd2, 0x07, 0x73, 0x0c, 0xc1, 0x01, 0x0a, 0x73,
-  0x0c, 0xc1, 0x20, 0x0a, 0x16, 0x4c, 0xe2, 0x9f, 0x41, 0x40, 0x0c, 0x00,
-  0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x5b, 0x86, 0x27, 0x90, 0x05, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x03, 0x00,
-  0x00, 0x00, 0x32, 0x0e, 0x10, 0x22, 0x84, 0x00, 0x8f, 0x06, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x0c, 0x00, 0x00, 0x2f, 0x00,
-  0x00, 0x00, 0x12, 0x03, 0x94, 0x70, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
-  0x00, 0x00, 0x59, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x44, 0x00,
-  0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xb0, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x00, 0x00, 0x00, 0x1f, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x80, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0xff, 0xff,
-  0xff, 0xff, 0x00, 0x24, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x0d, 0x00,
-  0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0xff, 0xff,
-  0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x21, 0x00,
-  0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0xff, 0xff,
-  0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x1b, 0x00,
-  0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0xff, 0xff,
-  0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5d, 0x0c,
-  0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0x20, 0x01, 0x00,
-  0x00, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x59, 0x55, 0x56, 0x5f, 0x66, 0x72,
-  0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x69, 0x72, 0x2e, 0x64, 0x6f,
-  0x74, 0x2e, 0x76, 0x33, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x73,
-  0x61, 0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72,
-  0x65, 0x5f, 0x32, 0x64, 0x5f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2e, 0x76,
-  0x34, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70,
-  0x6c, 0x65, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x5f, 0x32,
-  0x64, 0x2e, 0x76, 0x34, 0x66, 0x33, 0x32, 0x33, 0x31, 0x30, 0x30, 0x31,
-  0x2e, 0x34, 0x33, 0x61, 0x69, 0x72, 0x36, 0x34, 0x2d, 0x61, 0x70, 0x70,
-  0x6c, 0x65, 0x2d, 0x69, 0x6f, 0x73, 0x31, 0x33, 0x2e, 0x30, 0x2e, 0x30,
-  0x2d, 0x73, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00,
-  0x00, 0x00, 0x74, 0x0e, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43,
-  0xc0, 0xde, 0x35, 0x14, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x62, 0x0c,
-  0x30, 0x24, 0x80, 0x10, 0x05, 0xc8, 0x14, 0x00, 0x00, 0x00, 0x21, 0x0c,
-  0x00, 0x00, 0x4d, 0x03, 0x00, 0x00, 0x0b, 0x02, 0x21, 0x00, 0x02, 0x00,
-  0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8,
-  0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05,
-  0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92,
-  0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32,
-  0x52, 0x88, 0x48, 0x90, 0x14, 0x20, 0x43, 0x46, 0x88, 0xa5, 0x00, 0x19,
-  0x32, 0x42, 0x04, 0x49, 0x0e, 0x90, 0x91, 0x22, 0xc4, 0x50, 0x41, 0x51,
-  0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x29, 0x46, 0x06, 0x51, 0x18,
-  0x00, 0x00, 0x94, 0x00, 0x00, 0x00, 0x1b, 0xcc, 0x25, 0xf8, 0xff, 0xff,
-  0xff, 0xff, 0x01, 0x58, 0x03, 0x40, 0x02, 0x2a, 0x62, 0x1c, 0xde, 0x41,
-  0x1e, 0xe4, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xd8, 0x21, 0x1f, 0xda, 0x40,
-  0x1e, 0xde, 0xa1, 0x1e, 0xdc, 0x81, 0x1c, 0xca, 0x81, 0x1c, 0xda, 0x80,
-  0x1c, 0xd2, 0xc1, 0x1e, 0xd2, 0x81, 0x1c, 0xca, 0xa1, 0x0d, 0xe6, 0x21,
-  0x1e, 0xe4, 0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21,
-  0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72,
-  0x00, 0x08, 0x72, 0x48, 0x87, 0x79, 0x08, 0x07, 0x71, 0x60, 0x87, 0x72,
-  0x68, 0x03, 0x7a, 0x08, 0x87, 0x74, 0x60, 0x87, 0x36, 0x18, 0x87, 0x70,
-  0x60, 0x07, 0x76, 0x98, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1,
-  0x1c, 0x00, 0x82, 0x1d, 0xca, 0x61, 0x1e, 0xe6, 0xa1, 0x0d, 0xe0, 0x41,
-  0x1e, 0xca, 0x61, 0x1c, 0xd2, 0x61, 0x1e, 0xca, 0xa1, 0x0d, 0xcc, 0x01,
-  0x1e, 0xda, 0x21, 0x1c, 0xc8, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79,
-  0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90, 0x87, 0x70,
-  0x68, 0x87, 0x72, 0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70, 0x07, 0x7a,
-  0x28, 0x07, 0x79, 0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68, 0x07, 0x80,
-  0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x18, 0xdc, 0xe1, 0x1d, 0xda, 0xc0,
-  0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21,
-  0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21,
-  0x1d, 0xda, 0xa1, 0x0d, 0xdc, 0xe1, 0x1d, 0xdc, 0xa1, 0x0d, 0xd8, 0xa1,
-  0x1c, 0xc2, 0xc1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xd2, 0xc1,
-  0x1d, 0xcc, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21,
-  0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80,
-  0x70, 0x87, 0x77, 0x68, 0x03, 0x75, 0xa8, 0x87, 0x76, 0x80, 0x87, 0x36,
-  0xa0, 0x87, 0x70, 0x10, 0x07, 0x76, 0x28, 0x87, 0x79, 0x00, 0xcc, 0x21,
-  0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0,
-  0x1d, 0xc2, 0xc1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0,
-  0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72,
-  0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x98, 0x87, 0x74, 0x38, 0x07, 0x77,
-  0x28, 0x07, 0x72, 0x68, 0x03, 0x7d, 0x28, 0x07, 0x79, 0x78, 0x87, 0x79,
-  0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74,
-  0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1,
-  0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0x01, 0x1e, 0xe0, 0x21, 0x1d, 0xdc, 0xe1,
-  0x1c, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79,
-  0xa8, 0x87, 0x72, 0x00, 0x88, 0x79, 0xa0, 0x87, 0x70, 0x18, 0x87, 0x75,
-  0x68, 0x03, 0x78, 0x90, 0x87, 0x77, 0xa0, 0x87, 0x72, 0x18, 0x07, 0x7a,
-  0x78, 0x07, 0x79, 0x68, 0x03, 0x71, 0xa8, 0x07, 0x73, 0x30, 0x87, 0x72,
-  0x90, 0x87, 0x36, 0x98, 0x87, 0x74, 0xd0, 0x87, 0x72, 0x00, 0xf0, 0x00,
-  0x20, 0xea, 0xc1, 0x1d, 0xe6, 0x21, 0x1c, 0xcc, 0xa1, 0x1c, 0xda, 0xc0,
-  0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a,
-  0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0xa8, 0x87, 0x79, 0x28, 0x87, 0x36,
-  0x98, 0x87, 0x77, 0x30, 0x07, 0x7a, 0x68, 0x03, 0x73, 0x60, 0x87, 0x77,
-  0x08, 0x07, 0x7a, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01,
-  0xd8, 0xb0, 0x08, 0x03, 0x90, 0x00, 0x0b, 0x50, 0x05, 0x69, 0x00, 0x6d,
-  0x58, 0x06, 0x02, 0x48, 0x80, 0x05, 0xa8, 0x82, 0x34, 0x00, 0x85, 0x0d,
-  0x06, 0x51, 0x00, 0x0b, 0x50, 0x6d, 0x30, 0x0a, 0x03, 0x58, 0x80, 0x6a,
-  0x83, 0x61, 0x1c, 0xc0, 0x02, 0x54, 0x1b, 0x8c, 0xe3, 0xff, 0xff, 0xff,
-  0xff, 0x07, 0x40, 0x02, 0xa8, 0x0d, 0x0a, 0xf2, 0xff, 0xff, 0xff, 0xff,
-  0x03, 0xd0, 0x06, 0xc0, 0x1a, 0x00, 0x12, 0x50, 0x6d, 0x30, 0x92, 0x00,
-  0x58, 0x80, 0x6a, 0x83, 0xa1, 0x08, 0xc0, 0x02, 0x54, 0x00, 0x49, 0x18,
-  0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x13, 0x8c, 0x40, 0x18, 0x88, 0xc2,
-  0x98, 0x10, 0x1c, 0x13, 0x06, 0x24, 0x51, 0x00, 0x00, 0x00, 0x89, 0x20,
-  0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09, 0x20, 0x64,
-  0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1,
-  0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x74,
-  0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00, 0x83, 0x08, 0x41,
-  0x30, 0x8c, 0x30, 0x00, 0x07, 0x49, 0x53, 0x44, 0x09, 0x93, 0x2f, 0xbb,
-  0x6f, 0x47, 0x08, 0xce, 0x40, 0x20, 0x82, 0x10, 0x42, 0x06, 0x11, 0x0a,
-  0xe1, 0x28, 0x69, 0x8a, 0x28, 0x61, 0xf2, 0xff, 0x89, 0xb8, 0x26, 0x2a,
-  0x22, 0x7e, 0x7b, 0xf8, 0xa7, 0x31, 0x02, 0x60, 0x10, 0xe1, 0x08, 0x2e,
-  0x92, 0xa6, 0x88, 0x12, 0x26, 0xff, 0x97, 0x00, 0xe6, 0x59, 0x88, 0xe8,
-  0x9f, 0xc6, 0x08, 0x80, 0x41, 0x84, 0x44, 0x28, 0x48, 0x08, 0x62, 0x18,
-  0x84, 0x14, 0xad, 0x32, 0x00, 0x42, 0xa8, 0xcd, 0x11, 0x20, 0x46, 0x08,
-  0x6f, 0x8e, 0x20, 0x98, 0x23, 0x00, 0x83, 0x61, 0x04, 0x41, 0x2a, 0x0a,
-  0x44, 0x4a, 0xc4, 0x19, 0x01, 0x90, 0x44, 0x07, 0x02, 0x52, 0x40, 0x0e,
-  0x23, 0x0c, 0xd2, 0x20, 0x42, 0x20, 0xcc, 0x11, 0x80, 0xc2, 0x20, 0x02,
-  0x21, 0x8c, 0x00, 0x00, 0x00, 0x00, 0x13, 0xbe, 0x70, 0x48, 0x07, 0x79,
-  0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72,
-  0x68, 0x83, 0x74, 0x78, 0x87, 0x79, 0x88, 0x83, 0x39, 0x70, 0x03, 0x38,
-  0x70, 0x03, 0x38, 0x68, 0x83, 0x79, 0x48, 0x87, 0x76, 0xa8, 0x07, 0x76,
-  0x08, 0x07, 0x7a, 0x78, 0x07, 0x79, 0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06,
-  0xf0, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07,
-  0x76, 0x40, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07,
-  0x78, 0xd0, 0x06, 0xe9, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07,
-  0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07,
-  0x71, 0x60, 0x07, 0x6d, 0x90, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
-  0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e,
-  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07,
-  0x6d, 0x60, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07,
-  0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07,
-  0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07,
-  0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f,
-  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07,
-  0x6d, 0x60, 0x0f, 0x74, 0x80, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07,
-  0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07,
-  0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07,
-  0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07,
-  0x6d, 0x60, 0x0f, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07,
-  0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07,
-  0x79, 0x20, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07,
-  0x75, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07,
-  0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06,
-  0xf6, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07,
-  0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07,
-  0x72, 0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07,
-  0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07,
-  0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x11, 0xc2, 0x90, 0x11,
-  0xdb, 0x95, 0xff, 0xf9, 0xd6, 0xf6, 0x5f, 0x44, 0x80, 0xc1, 0x10, 0xcd,
-  0x34, 0x24, 0x02, 0xa2, 0x05, 0x00, 0x80, 0x00, 0x00, 0x00, 0x40, 0x00,
-  0x00, 0x00, 0x00, 0x86, 0x44, 0x51, 0xd3, 0x00, 0x01, 0x20, 0x00, 0x00,
-  0x00, 0x08, 0x00, 0x00, 0x00, 0xc0, 0x90, 0xc8, 0xdb, 0x28, 0x20, 0x00,
-  0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x90, 0xd8, 0x20, 0x50,
-  0xf4, 0x69, 0x00, 0x00, 0x20, 0x0b, 0x04, 0x00, 0x00, 0x00, 0x0b, 0x00,
-  0x00, 0x00, 0x32, 0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09,
-  0x26, 0x47, 0xc6, 0x04, 0x43, 0x92, 0x45, 0x50, 0x02, 0x85, 0x30, 0x02,
-  0x50, 0x20, 0x65, 0x50, 0x80, 0x01, 0x05, 0x54, 0x60, 0xa5, 0x50, 0x0c,
-  0xa4, 0x47, 0x00, 0xe8, 0x8e, 0x25, 0x38, 0x02, 0x00, 0x00, 0xb1, 0x18,
-  0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1,
-  0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42,
-  0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f,
-  0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1,
-  0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84,
-  0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc,
-  0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70,
-  0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19,
-  0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f,
-  0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21,
-  0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc,
-  0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84,
-  0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37,
-  0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70,
-  0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77,
-  0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79,
-  0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e,
-  0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1,
-  0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81,
-  0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98,
-  0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88,
-  0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4,
-  0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72,
-  0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74,
-  0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e,
-  0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e,
-  0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21,
-  0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01,
-  0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc,
-  0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77,
-  0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e,
-  0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1,
-  0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61,
-  0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0,
-  0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0,
-  0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74,
-  0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e,
-  0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41,
-  0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50,
-  0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c,
-  0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc,
-  0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x79, 0x20, 0x00, 0x00, 0x04, 0x01,
-  0x00, 0x00, 0x32, 0x9a, 0x08, 0x14, 0x02, 0x85, 0x8c, 0x27, 0x46, 0x46,
-  0xc8, 0x11, 0x32, 0x64, 0xd4, 0xd6, 0x80, 0x0c, 0x76, 0x09, 0x8b, 0xe2,
-  0x06, 0xc5, 0xc6, 0x91, 0x41, 0x14, 0x19, 0x8c, 0x22, 0x31, 0x88, 0x94,
-  0x3d, 0x06, 0xa2, 0x3c, 0x12, 0x12, 0x5d, 0x03, 0x65, 0x18, 0x86, 0x61,
-  0x24, 0xc6, 0xa2, 0x60, 0x44, 0xb1, 0x1c, 0x01, 0x00, 0x00, 0x53, 0x44,
-  0x4b, 0x20, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68,
-  0x61, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x41, 0x70, 0x70, 0x6c, 0x65,
-  0x20, 0x4c, 0x4c, 0x56, 0x4d, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f,
-  0x6e, 0x20, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x34, 0x33, 0x20, 0x28,
-  0x6d, 0x65, 0x74, 0x61, 0x6c, 0x66, 0x65, 0x2d, 0x33, 0x31, 0x30, 0x30,
-  0x31, 0x2e, 0x34, 0x33, 0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x61, 0x69,
+  0x81, 0x18, 0x00, 0x00, 0x23, 0x06, 0xcd, 0x10, 0x82, 0x60, 0x70, 0x89,
+  0x41, 0xf4, 0x4c, 0xcd, 0xc2, 0x14, 0x85, 0x37, 0x9a, 0x10, 0x00, 0x83,
+  0x0c, 0x01, 0xb1, 0x8c, 0x18, 0x38, 0x43, 0x08, 0x82, 0x41, 0x65, 0x06,
+  0x93, 0x64, 0x85, 0x01, 0xe4, 0x3c, 0x08, 0x12, 0x06, 0xa3, 0x09, 0x01,
+  0x30, 0x86, 0x10, 0x34, 0x73, 0x0c, 0x44, 0xd0, 0x8c, 0x18, 0x38, 0x43,
+  0x08, 0x82, 0x41, 0xa5, 0x06, 0x97, 0xa5, 0x9d, 0x01, 0x25, 0x4d, 0x0c,
+  0x53, 0x06, 0xa3, 0x09, 0x01, 0x30, 0x86, 0x10, 0x44, 0x73, 0x0c, 0x44,
+  0x00, 0x5d, 0xd7, 0x2d, 0x05, 0x41, 0x19, 0x64, 0x08, 0x9e, 0xcb, 0x88,
+  0x00, 0xfc, 0x37, 0x31, 0x84, 0xc1, 0xf5, 0x06, 0x17, 0x74, 0x4b, 0x41,
+  0x50, 0x06, 0x19, 0x02, 0x8a, 0x1b, 0x31, 0x38, 0x84, 0x10, 0x04, 0x0b,
+  0xff, 0x70, 0xee, 0xa0, 0x08, 0x36, 0x31, 0x98, 0x01, 0x57, 0x07, 0x17,
+  0x74, 0x4b, 0x41, 0x50, 0x06, 0x19, 0x82, 0x2c, 0x0c, 0x46, 0x0c, 0x0e,
+  0x21, 0x04, 0xc1, 0xc2, 0x3f, 0x1c, 0x3e, 0x50, 0x82, 0x4d, 0x0c, 0x6b,
+  0x10, 0x06, 0x76, 0x70, 0x41, 0xb7, 0x14, 0x04, 0x65, 0x90, 0x21, 0xf0,
+  0xcc, 0x60, 0xc4, 0xe0, 0x10, 0x42, 0x10, 0x2c, 0xfc, 0xc3, 0x09, 0x85,
+  0x27, 0x98, 0x63, 0xf8, 0x16, 0x3e, 0x98, 0x63, 0x08, 0x8e, 0x3f, 0x98,
+  0x63, 0x08, 0x86, 0x50, 0xb0, 0xa0, 0x0e, 0xc4, 0x3f, 0x03, 0x00, 0x00,
+  0x71, 0x20, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x32, 0x0e, 0x10, 0x22,
+  0x84, 0x00, 0x8d, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x65, 0x0c, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0x70,
+  0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x59, 0x00, 0x00, 0x00,
+  0x0a, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00,
+  0x04, 0x00, 0x00, 0x00, 0xb0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x63, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x10, 0x00, 0x00, 0x00, 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x10, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x24, 0x00, 0x00,
+  0x10, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+  0x0d, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00,
+  0x1d, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00,
+  0x21, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00,
+  0x3e, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00,
+  0x1b, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x5d, 0x0c, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
+  0x12, 0x03, 0x94, 0x22, 0x01, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4c, 0x5f,
+  0x59, 0x55, 0x56, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74,
+  0x61, 0x69, 0x72, 0x2e, 0x64, 0x6f, 0x74, 0x2e, 0x76, 0x33, 0x66, 0x33,
+  0x32, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x5f,
+  0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x5f, 0x32, 0x64, 0x5f, 0x61,
+  0x72, 0x72, 0x61, 0x79, 0x2e, 0x76, 0x34, 0x66, 0x33, 0x32, 0x61, 0x69,
+  0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x74, 0x65, 0x78,
+  0x74, 0x75, 0x72, 0x65, 0x5f, 0x32, 0x64, 0x2e, 0x76, 0x34, 0x66, 0x33,
+  0x32, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x35, 0x30, 0x2e, 0x31, 0x61,
+  0x69, 0x72, 0x36, 0x34, 0x2d, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2d, 0x69,
+  0x6f, 0x73, 0x31, 0x33, 0x2e, 0x30, 0x2e, 0x30, 0x2d, 0x73, 0x69, 0x6d,
+  0x75, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00,
+  0x14, 0x00, 0x00, 0x00, 0x1c, 0x0e, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+  0x42, 0x43, 0xc0, 0xde, 0x35, 0x14, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x62, 0x0c, 0x30, 0x24, 0x80, 0x10, 0x05, 0xc8, 0x14, 0x00, 0x00, 0x00,
+  0x21, 0x0c, 0x00, 0x00, 0x36, 0x03, 0x00, 0x00, 0x0b, 0x02, 0x21, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91,
+  0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c,
+  0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02,
+  0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x4b,
+  0x0a, 0x32, 0x52, 0x88, 0x48, 0x90, 0x14, 0x20, 0x43, 0x46, 0x88, 0xa5,
+  0x00, 0x19, 0x32, 0x42, 0x04, 0x49, 0x0e, 0x90, 0x91, 0x22, 0xc4, 0x50,
+  0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x29, 0x46, 0x06,
+  0x51, 0x18, 0x00, 0x00, 0x92, 0x00, 0x00, 0x00, 0x1b, 0xcc, 0x25, 0xf8,
+  0xff, 0xff, 0xff, 0xff, 0x01, 0x58, 0x03, 0x40, 0x02, 0x2a, 0x62, 0x1c,
+  0xde, 0x41, 0x1e, 0xe4, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xd8, 0x21, 0x1f,
+  0xda, 0x40, 0x1e, 0xde, 0xa1, 0x1e, 0xdc, 0x81, 0x1c, 0xca, 0x81, 0x1c,
+  0xda, 0x80, 0x1c, 0xd2, 0xc1, 0x1e, 0xd2, 0x81, 0x1c, 0xca, 0xa1, 0x0d,
+  0xe6, 0x21, 0x1e, 0xe4, 0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d,
+  0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98,
+  0x87, 0x72, 0x00, 0x08, 0x72, 0x48, 0x87, 0x79, 0x08, 0x07, 0x71, 0x60,
+  0x87, 0x72, 0x68, 0x03, 0x7a, 0x08, 0x87, 0x74, 0x60, 0x87, 0x36, 0x18,
+  0x87, 0x70, 0x60, 0x07, 0x76, 0x98, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d,
+  0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1d, 0xca, 0x61, 0x1e, 0xe6, 0xa1, 0x0d,
+  0xe0, 0x41, 0x1e, 0xca, 0x61, 0x1c, 0xd2, 0x61, 0x1e, 0xca, 0xa1, 0x0d,
+  0xcc, 0x01, 0x1e, 0xda, 0x21, 0x1c, 0xc8, 0x01, 0x30, 0x87, 0x70, 0x60,
+  0x87, 0x79, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90,
+  0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70,
+  0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68,
+  0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x18, 0xdc, 0xe1, 0x1d,
+  0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e,
+  0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c,
+  0xd8, 0x21, 0x1d, 0xda, 0xa1, 0x0d, 0xdc, 0xe1, 0x1d, 0xdc, 0xa1, 0x0d,
+  0xd8, 0xa1, 0x1c, 0xc2, 0xc1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d,
+  0xd2, 0xc1, 0x1d, 0xcc, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d,
+  0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28,
+  0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x75, 0xa8, 0x87, 0x76, 0x80,
+  0x87, 0x36, 0xa0, 0x87, 0x70, 0x10, 0x07, 0x76, 0x28, 0x87, 0x79, 0x00,
+  0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0xc0, 0x1d, 0xc2, 0xc1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e,
+  0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8,
+  0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x98, 0x87, 0x74, 0x38,
+  0x07, 0x77, 0x28, 0x07, 0x72, 0x68, 0x03, 0x7d, 0x28, 0x07, 0x79, 0x78,
+  0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0,
+  0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d,
+  0xde, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0x01, 0x1e, 0xe0, 0x21, 0x1d,
+  0xdc, 0xe1, 0x1c, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0,
+  0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x88, 0x79, 0xa0, 0x87, 0x70, 0x18,
+  0x87, 0x75, 0x68, 0x03, 0x78, 0x90, 0x87, 0x77, 0xa0, 0x87, 0x72, 0x18,
+  0x07, 0x7a, 0x78, 0x07, 0x79, 0x68, 0x03, 0x71, 0xa8, 0x07, 0x73, 0x30,
+  0x87, 0x72, 0x90, 0x87, 0x36, 0x98, 0x87, 0x74, 0xd0, 0x87, 0x72, 0x00,
+  0xf0, 0x00, 0x20, 0xea, 0xc1, 0x1d, 0xe6, 0x21, 0x1c, 0xcc, 0xa1, 0x1c,
+  0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d,
+  0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0xa8, 0x87, 0x79, 0x28,
+  0x87, 0x36, 0x98, 0x87, 0x77, 0x30, 0x07, 0x7a, 0x68, 0x03, 0x73, 0x60,
+  0x87, 0x77, 0x08, 0x07, 0x7a, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e,
+  0xca, 0x01, 0xd8, 0xb0, 0x08, 0x04, 0x90, 0x00, 0x0b, 0x50, 0x05, 0x69,
+  0x00, 0x0a, 0x1b, 0x8c, 0xa1, 0x00, 0x16, 0xa0, 0xda, 0x60, 0x10, 0x06,
+  0xb0, 0x00, 0xd5, 0x06, 0xa3, 0x38, 0x80, 0x05, 0xa8, 0x36, 0x18, 0xc6,
+  0xff, 0xff, 0xff, 0xff, 0x0f, 0x80, 0x04, 0x50, 0x1b, 0x94, 0xe3, 0xff,
+  0xff, 0xff, 0xff, 0x07, 0xa0, 0x0d, 0x80, 0x35, 0x00, 0x24, 0xa0, 0xda,
+  0x60, 0x20, 0x01, 0xb0, 0x00, 0xd5, 0x06, 0x23, 0x11, 0x80, 0x05, 0xa8,
+  0x00, 0x00, 0x00, 0x00, 0x49, 0x18, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+  0x13, 0x8a, 0x40, 0x18, 0x88, 0x62, 0x42, 0x60, 0x4c, 0x18, 0x0e, 0x24,
+  0x01, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00,
+  0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84,
+  0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c,
+  0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x70, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30,
+  0x8c, 0x20, 0x00, 0xc3, 0x08, 0x03, 0x70, 0x90, 0x34, 0x45, 0x94, 0x30,
+  0xf9, 0xb2, 0xfb, 0x76, 0x84, 0xe0, 0x0c, 0x04, 0x22, 0xc6, 0x18, 0x63,
+  0x10, 0x81, 0x10, 0x8e, 0x92, 0xa6, 0x88, 0x12, 0x26, 0xff, 0x9f, 0x88,
+  0x6b, 0xa2, 0x22, 0xe2, 0xb7, 0x87, 0x7f, 0x1a, 0x23, 0x00, 0x06, 0x11,
+  0x8c, 0xe0, 0x22, 0x69, 0x8a, 0x28, 0x61, 0xf2, 0x7f, 0x09, 0x60, 0x9e,
+  0x85, 0x88, 0xfe, 0x69, 0x8c, 0x00, 0x18, 0x44, 0x40, 0x84, 0x82, 0x84,
+  0x10, 0x44, 0x39, 0x27, 0x91, 0x2a, 0x03, 0x18, 0x83, 0xd8, 0x1c, 0x01,
+  0x62, 0x84, 0xe0, 0xe6, 0x08, 0x82, 0x39, 0x02, 0x30, 0x18, 0x46, 0x10,
+  0xa2, 0xa2, 0xbc, 0x93, 0x04, 0x94, 0x10, 0x80, 0x48, 0x73, 0x20, 0x20,
+  0x05, 0xe2, 0x30, 0xc2, 0x10, 0x0d, 0x22, 0x04, 0xc2, 0x1c, 0x01, 0x28,
+  0x0c, 0x22, 0x0c, 0xc2, 0x08, 0x00, 0x00, 0x00, 0x13, 0xbe, 0x70, 0x48,
+  0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70, 0x80, 0x07, 0x78, 0x60,
+  0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87, 0x79, 0x88, 0x83, 0x39, 0x70,
+  0x03, 0x38, 0x70, 0x03, 0x38, 0x68, 0x83, 0x79, 0x48, 0x87, 0x76, 0xa8,
+  0x07, 0x76, 0x08, 0x07, 0x7a, 0x78, 0x07, 0x79, 0xd8, 0x70, 0x1b, 0xe5,
+  0xd0, 0x06, 0xf0, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x78,
+  0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x7a,
+  0x80, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76,
+  0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x90, 0x0e, 0x73, 0x20, 0x07, 0x7a,
+  0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76,
+  0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d,
+  0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73,
+  0x20, 0x07, 0x6d, 0x60, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x60, 0x07, 0x7a,
+  0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72,
+  0x40, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d,
+  0x60, 0x0f, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73,
+  0x20, 0x07, 0x6d, 0x60, 0x0f, 0x74, 0x80, 0x07, 0x7a, 0x60, 0x07, 0x74,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x76, 0x40, 0x07, 0x7a,
+  0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x79,
+  0x60, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72,
+  0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71,
+  0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6,
+  0x10, 0x07, 0x79, 0x20, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a,
+  0x20, 0x07, 0x75, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x50, 0x07, 0x76,
+  0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76,
+  0xd0, 0x06, 0xf6, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71,
+  0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x71,
+  0x00, 0x07, 0x72, 0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74,
+  0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78,
+  0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x11, 0xc2,
+  0x90, 0x11, 0xdb, 0x95, 0xff, 0xf9, 0xd6, 0xf6, 0x5f, 0x44, 0x80, 0xc1,
+  0x10, 0xcd, 0x34, 0x24, 0x02, 0x22, 0x05, 0x00, 0x80, 0x00, 0x00, 0x00,
+  0x40, 0x00, 0x00, 0x00, 0x00, 0x86, 0x44, 0x51, 0xc3, 0x00, 0x01, 0x20,
+  0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xc0, 0x90, 0xc8, 0xdb, 0x26,
+  0x20, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x90, 0xd8,
+  0x20, 0x50, 0x14, 0x67, 0x00, 0x00, 0x20, 0x0b, 0x04, 0x00, 0x00, 0x00,
+  0x0a, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90,
+  0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x8a, 0x45, 0x50, 0x02, 0x85,
+  0x30, 0x02, 0x50, 0x06, 0x05, 0x18, 0x50, 0x20, 0x05, 0x54, 0x60, 0xa5,
+  0x50, 0x0c, 0x64, 0xc7, 0x12, 0x1c, 0x02, 0x00, 0xb1, 0x18, 0x00, 0x00,
+  0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66,
+  0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07,
+  0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10,
+  0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce,
+  0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b,
+  0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c,
+  0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07,
+  0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11,
+  0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0,
+  0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8,
+  0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b,
+  0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b,
+  0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87,
+  0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07,
+  0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87,
+  0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81,
+  0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30,
+  0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4,
+  0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca,
+  0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39,
+  0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b,
+  0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b,
+  0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83,
+  0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87,
+  0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90,
+  0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20,
+  0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc,
+  0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66,
+  0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24,
+  0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07,
+  0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e,
+  0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e,
+  0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54,
+  0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39,
+  0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c,
+  0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07,
+  0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0,
+  0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4,
+  0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38,
+  0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d,
+  0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d,
+  0xc0, 0xc3, 0x3c, 0x00, 0x79, 0x20, 0x00, 0x00, 0x09, 0x01, 0x00, 0x00,
+  0x32, 0x9a, 0x08, 0x14, 0x02, 0x85, 0x8c, 0x27, 0x46, 0x46, 0xc8, 0x11,
+  0x32, 0x64, 0xd4, 0xd8, 0x80, 0x0c, 0xea, 0x09, 0x8b, 0x02, 0x07, 0xc5,
+  0xc6, 0x91, 0x41, 0x14, 0x19, 0x8c, 0x22, 0x31, 0x88, 0x64, 0x3d, 0x45,
+  0x66, 0x20, 0xca, 0x23, 0x21, 0x94, 0x61, 0x18, 0x86, 0x11, 0x5d, 0x89,
+  0xb1, 0x28, 0x18, 0x51, 0x2c, 0x47, 0x00, 0x00, 0x53, 0x44, 0x4b, 0x20,
+  0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68, 0x61, 0x72,
+  0x5f, 0x73, 0x69, 0x7a, 0x65, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x4c,
+  0x4c, 0x56, 0x4d, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20,
+  0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x35, 0x30, 0x20, 0x28, 0x6d, 0x65,
+  0x74, 0x61, 0x6c, 0x66, 0x65, 0x2d, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e,
+  0x35, 0x30, 0x2e, 0x31, 0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x61, 0x69,
   0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x64, 0x65,
   0x6e, 0x6f, 0x72, 0x6d, 0x73, 0x5f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c,
   0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65,
@@ -1650,22 +1637,24 @@ const unsigned char sdl_metallib[] = {
   0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x69, 0x72,
   0x2e, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x6e,
   0x70, 0x75, 0x74, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64,
-  0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x44, 0x76,
-  0x32, 0x5f, 0x66, 0x29, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x65, 0x72, 0x73,
-  0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74,
-  0x32, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x61, 0x69, 0x72,
-  0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x62,
-  0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69,
-  0x72, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69,
-  0x6e, 0x64, 0x65, 0x78, 0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x61, 0x64,
-  0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65,
-  0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67,
-  0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f,
-  0x73, 0x69, 0x7a, 0x65, 0x63, 0x6f, 0x6c, 0x61, 0x69, 0x72, 0x2e, 0x73,
-  0x74, 0x72, 0x75, 0x63, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x69,
-  0x6e, 0x66, 0x6f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x6f, 0x66, 0x66,
-  0x73, 0x65, 0x74, 0x52, 0x63, 0x6f, 0x65, 0x66, 0x66, 0x47, 0x63, 0x6f,
-  0x65, 0x66, 0x66, 0x42, 0x63, 0x6f, 0x65, 0x66, 0x66, 0x59, 0x55, 0x56,
+  0x28, 0x35, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66,
+  0x29, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63,
+  0x74, 0x69, 0x76, 0x65, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x67, 0x65, 0x6e,
+  0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x38, 0x74, 0x65, 0x78, 0x63,
+  0x6f, 0x6f, 0x72, 0x64, 0x44, 0x76, 0x32, 0x5f, 0x66, 0x29, 0x66, 0x6c,
+  0x6f, 0x61, 0x74, 0x32, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64,
+  0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x61, 0x69,
+  0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a,
+  0x65, 0x61, 0x69, 0x72, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f,
+  0x6e, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x61, 0x69, 0x72, 0x2e, 0x72,
+  0x65, 0x61, 0x64, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x74, 0x72, 0x75, 0x63,
+  0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x66,
+  0x6c, 0x6f, 0x61, 0x74, 0x33, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x52,
+  0x63, 0x6f, 0x65, 0x66, 0x66, 0x47, 0x63, 0x6f, 0x65, 0x66, 0x66, 0x42,
+  0x63, 0x6f, 0x65, 0x66, 0x66, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67,
+  0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69,
+  0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x61,
+  0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x59, 0x55, 0x56,
   0x44, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x65, 0x63, 0x6f, 0x64, 0x65,
   0x61, 0x69, 0x72, 0x2e, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x61,
   0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x78,
@@ -1673,275 +1662,265 @@ const unsigned char sdl_metallib[] = {
   0x2c, 0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x3e, 0x74, 0x65, 0x78,
   0x59, 0x74, 0x65, 0x78, 0x55, 0x56, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x61,
   0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72,
-  0x73, 0x00, 0x64, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x82,
-  0x20, 0x0d, 0x23, 0x08, 0xd7, 0x33, 0x82, 0x20, 0x11, 0x23, 0x08, 0x52,
-  0x31, 0x82, 0x20, 0x19, 0x23, 0x08, 0x0c, 0x30, 0x82, 0x20, 0x1d, 0x23,
-  0x08, 0x12, 0x32, 0x82, 0x20, 0x25, 0x23, 0x08, 0x92, 0x32, 0x82, 0x20,
-  0x2d, 0x23, 0x08, 0x12, 0x33, 0x82, 0x20, 0x35, 0x33, 0x0c, 0x6c, 0x10,
-  0xb4, 0xc1, 0x0c, 0x83, 0x1b, 0x08, 0x6f, 0x30, 0x43, 0x30, 0xcc, 0x30,
-  0xb0, 0x01, 0x1b, 0xc0, 0xc1, 0x0c, 0x04, 0xe1, 0x06, 0x6e, 0x00, 0x07,
-  0x33, 0x04, 0xc5, 0x0c, 0x81, 0x31, 0x43, 0x70, 0xcc, 0x50, 0x20, 0x70,
-  0x00, 0x07, 0x89, 0x32, 0x43, 0x10, 0x0a, 0x33, 0x20, 0x70, 0xb0, 0x30,
-  0x4d, 0xa2, 0x38, 0xcf, 0x0c, 0x89, 0x1b, 0x40, 0x11, 0x23, 0x25, 0x93,
-  0x43, 0xcd, 0x00, 0xb1, 0x41, 0x65, 0xc9, 0xc1, 0x05, 0x07, 0x6e, 0x80,
-  0x65, 0x72, 0xa0, 0xc9, 0x41, 0xa2, 0x38, 0xdb, 0x0c, 0x14, 0x1c, 0xc8,
-  0x01, 0x1c, 0x74, 0x9e, 0x1c, 0xc8, 0x01, 0x1c, 0x74, 0x5f, 0x1d, 0xc8,
-  0x01, 0x1c, 0x74, 0x60, 0x60, 0x07, 0x72, 0x00, 0x07, 0x5d, 0x18, 0xcc,
-  0x20, 0xcd, 0x41, 0x65, 0xd1, 0xc1, 0xe5, 0x06, 0x6e, 0x80, 0x71, 0xa6,
-  0x90, 0xd1, 0x81, 0x26, 0x07, 0x89, 0x18, 0x38, 0x63, 0x30, 0x83, 0xf2,
-  0x06, 0x64, 0x70, 0xc1, 0x81, 0x1b, 0x94, 0x41, 0x62, 0x06, 0xce, 0x19,
-  0xcc, 0xa0, 0xdc, 0x01, 0x19, 0x5c, 0x6e, 0xe0, 0x06, 0x65, 0x90, 0x98,
-  0x81, 0x83, 0x06, 0x33, 0x24, 0x78, 0x90, 0x06, 0x17, 0x1c, 0xb8, 0x41,
-  0xa2, 0x06, 0xce, 0x1a, 0xcc, 0x70, 0x8c, 0x02, 0x29, 0x94, 0xc2, 0x29,
-  0xa0, 0x42, 0x2a, 0xa8, 0xc2, 0x0c, 0x43, 0x1c, 0x88, 0xc2, 0x2a, 0x54,
-  0x18, 0x00, 0x1c, 0xc7, 0x71, 0x1c, 0xc7, 0x71, 0x1c, 0xc7, 0x71, 0x9c,
-  0x1b, 0xb8, 0x81, 0x45, 0x07, 0x7a, 0x60, 0x59, 0x96, 0x1e, 0x70, 0xa6,
-  0xc0, 0x0a, 0x34, 0xc1, 0x1b, 0x72, 0x61, 0x0f, 0xf6, 0xa0, 0x0e, 0xe4,
-  0x20, 0x23, 0x81, 0x09, 0xba, 0x88, 0x8d, 0xcd, 0xae, 0xcd, 0xa5, 0xed,
-  0x8d, 0xac, 0x8e, 0xad, 0xcc, 0xc5, 0x8c, 0x2d, 0xec, 0x6c, 0x6e, 0x14,
-  0x01, 0x0f, 0xf2, 0xe0, 0x14, 0x36, 0x36, 0xbb, 0x36, 0x97, 0x34, 0xb2,
-  0x32, 0x37, 0xba, 0x51, 0x02, 0x3d, 0xb8, 0x25, 0x2c, 0x4d, 0xce, 0xc5,
-  0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x6d, 0x94, 0x60, 0x0f, 0x8e, 0x0a,
-  0x4b, 0x93, 0x73, 0x61, 0x0b, 0x73, 0x3b, 0xab, 0x0b, 0x3b, 0x2b, 0xfb,
-  0xb2, 0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73, 0x1b, 0x25, 0xe0, 0x83, 0x9b,
-  0xc2, 0xd2, 0xe4, 0x5c, 0xc6, 0xde, 0xda, 0xe0, 0xd2, 0xd8, 0xca, 0xbe,
-  0xde, 0xe0, 0xe8, 0xd2, 0xde, 0xdc, 0xe6, 0x46, 0x19, 0xfa, 0xc0, 0x0f,
-  0xfe, 0xe0, 0x98, 0xb0, 0x34, 0x39, 0x17, 0x33, 0xb9, 0xb0, 0xb3, 0xb6,
-  0x32, 0x37, 0xba, 0x51, 0x82, 0x55, 0x00, 0x00, 0x00, 0x00, 0xa9, 0x18,
-  0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x0a, 0x72, 0x28, 0x87, 0x77,
-  0x80, 0x07, 0x7a, 0x58, 0x70, 0x98, 0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb0,
-  0x43, 0x39, 0xd0, 0xc3, 0x82, 0xe6, 0x1c, 0xc6, 0xa1, 0x0d, 0xe8, 0x41,
-  0x1e, 0xc2, 0xc1, 0x1d, 0xe6, 0x21, 0x1d, 0xe8, 0x21, 0x1d, 0xde, 0xc1,
-  0x1d, 0x00, 0xd1, 0x10, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0xcc,
-  0x3c, 0xa4, 0x83, 0x3b, 0x9c, 0x03, 0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83,
-  0x3c, 0x94, 0x43, 0x38, 0x90, 0xc3, 0x01, 0x00, 0x00, 0x00, 0x61, 0x20,
-  0x00, 0x00, 0x53, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00,
-  0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x14, 0x6b, 0x60, 0x04, 0x80, 0xe4,
-  0x0c, 0x00, 0xcd, 0x11, 0x00, 0xc2, 0x63, 0x0d, 0x40, 0x20, 0xcc, 0x31,
-  0x18, 0x59, 0x36, 0xc7, 0x60, 0x10, 0xd9, 0x58, 0x03, 0x30, 0x10, 0x04,
-  0x46, 0x00, 0x66, 0x00, 0xc6, 0x08, 0x40, 0x10, 0x04, 0xf1, 0x8f, 0xc2,
-  0x0c, 0xc0, 0x1c, 0x04, 0x18, 0x80, 0x01, 0x18, 0x84, 0x01, 0x00, 0x00,
-  0x00, 0x00, 0xf1, 0x30, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x22, 0x47,
-  0xc8, 0x90, 0x51, 0x0a, 0x84, 0x18, 0x00, 0x00, 0x00, 0x00, 0xcf, 0x03,
-  0x00, 0x00, 0x6f, 0x6d, 0x6e, 0x69, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x74,
-  0x20, 0x63, 0x68, 0x61, 0x72, 0x53, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20,
-  0x43, 0x2b, 0x2b, 0x20, 0x54, 0x42, 0x41, 0x41, 0x00, 0x00, 0x13, 0x04,
-  0xcd, 0xd9, 0x10, 0xb8, 0xc2, 0x86, 0xa1, 0x15, 0x60, 0xe1, 0x15, 0x36,
-  0x0c, 0xb1, 0x10, 0x0b, 0xaf, 0x00, 0x23, 0x06, 0xcd, 0x10, 0x82, 0x60,
-  0x40, 0x89, 0x01, 0xe4, 0x4c, 0x8d, 0xc2, 0x14, 0x85, 0x37, 0x9a, 0x10,
-  0x00, 0x83, 0x0c, 0x01, 0xa1, 0x8c, 0x18, 0x34, 0x43, 0x08, 0x82, 0x01,
-  0x55, 0x06, 0x52, 0x64, 0x41, 0xcd, 0x83, 0x20, 0x61, 0x30, 0x9a, 0x10,
-  0x00, 0x83, 0x0c, 0xc1, 0xc1, 0x0c, 0x32, 0x10, 0x01, 0x73, 0x58, 0x5e,
-  0x0a, 0x42, 0x19, 0x64, 0x08, 0x16, 0xc9, 0x88, 0x00, 0xfc, 0xa9, 0x0b,
-  0x65, 0x97, 0xa1, 0x13, 0x03, 0x36, 0xb8, 0x20, 0x2f, 0x05, 0xa1, 0x0c,
-  0x32, 0x04, 0x11, 0x36, 0x62, 0x70, 0x08, 0x21, 0x08, 0x16, 0xfe, 0xd1,
-  0xcc, 0x81, 0x11, 0xec, 0x32, 0x88, 0xc1, 0x19, 0xc8, 0xc1, 0x05, 0x79,
-  0x29, 0x08, 0x65, 0x90, 0x21, 0xb0, 0xba, 0x11, 0x83, 0x43, 0x08, 0x41,
-  0xb0, 0xf0, 0x8f, 0x06, 0x0f, 0x96, 0x60, 0x97, 0xe1, 0x0c, 0xd8, 0x40,
-  0x0e, 0x2e, 0xc8, 0x4b, 0x41, 0x28, 0x83, 0x0c, 0xc1, 0x26, 0x06, 0x23,
-  0x06, 0x87, 0x10, 0x82, 0x60, 0xe1, 0x1f, 0x4d, 0x1f, 0x40, 0xc1, 0x1c,
-  0x03, 0xb7, 0xe4, 0xc1, 0x1c, 0x43, 0x70, 0xf0, 0xc1, 0x1c, 0x43, 0x30,
-  0xf8, 0x81, 0x05, 0x93, 0xf8, 0x67, 0x10, 0x10, 0x03, 0x00, 0x02, 0x00,
-  0x00, 0x00, 0x5b, 0x86, 0x25, 0x88, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x32, 0x0e,
-  0x10, 0x22, 0x84, 0x00, 0xfa, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x65, 0x0c, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x12, 0x03,
-  0x94, 0x38, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x39, 0x00,
-  0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x01, 0x00,
-  0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x00,
-  0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x98, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x24,
-  0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x11, 0x00,
-  0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24,
-  0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1e, 0x00,
-  0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5d, 0x0c, 0x00, 0x00, 0x1b, 0x00,
-  0x00, 0x00, 0x12, 0x03, 0x94, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x53, 0x44,
-  0x4c, 0x5f, 0x4e, 0x56, 0x31, 0x32, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d,
-  0x65, 0x6e, 0x74, 0x61, 0x69, 0x72, 0x2e, 0x64, 0x6f, 0x74, 0x2e, 0x76,
-  0x33, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70,
-  0x6c, 0x65, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x5f, 0x32,
-  0x64, 0x2e, 0x76, 0x34, 0x66, 0x33, 0x32, 0x33, 0x31, 0x30, 0x30, 0x31,
-  0x2e, 0x34, 0x33, 0x61, 0x69, 0x72, 0x36, 0x34, 0x2d, 0x61, 0x70, 0x70,
-  0x6c, 0x65, 0x2d, 0x69, 0x6f, 0x73, 0x31, 0x33, 0x2e, 0x30, 0x2e, 0x30,
-  0x2d, 0x73, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0,
-  0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x80, 0x0e,
-  0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x35, 0x14,
-  0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x62, 0x0c, 0x30, 0x24, 0x80, 0x10,
-  0x05, 0xc8, 0x14, 0x00, 0x00, 0x00, 0x21, 0x0c, 0x00, 0x00, 0x50, 0x03,
-  0x00, 0x00, 0x0b, 0x02, 0x21, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00,
-  0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10,
-  0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04,
-  0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10,
-  0x32, 0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88, 0x48, 0x90,
-  0x14, 0x20, 0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0x04, 0x49,
-  0x0e, 0x90, 0x91, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83,
-  0xe5, 0x8a, 0x04, 0x29, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x94, 0x00,
-  0x00, 0x00, 0x1b, 0xcc, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x58,
-  0x03, 0x40, 0x02, 0x2a, 0x62, 0x1c, 0xde, 0x41, 0x1e, 0xe4, 0xa1, 0x1c,
-  0xc6, 0x81, 0x1e, 0xd8, 0x21, 0x1f, 0xda, 0x40, 0x1e, 0xde, 0xa1, 0x1e,
-  0xdc, 0x81, 0x1c, 0xca, 0x81, 0x1c, 0xda, 0x80, 0x1c, 0xd2, 0xc1, 0x1e,
-  0xd2, 0x81, 0x1c, 0xca, 0xa1, 0x0d, 0xe6, 0x21, 0x1e, 0xe4, 0x81, 0x1e,
-  0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d,
-  0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x72, 0x48,
-  0x87, 0x79, 0x08, 0x07, 0x71, 0x60, 0x87, 0x72, 0x68, 0x03, 0x7a, 0x08,
-  0x87, 0x74, 0x60, 0x87, 0x36, 0x18, 0x87, 0x70, 0x60, 0x07, 0x76, 0x98,
-  0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1d,
-  0xca, 0x61, 0x1e, 0xe6, 0xa1, 0x0d, 0xe0, 0x41, 0x1e, 0xca, 0x61, 0x1c,
-  0xd2, 0x61, 0x1e, 0xca, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0x21, 0x1c,
-  0xc8, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x70,
-  0x87, 0x77, 0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72, 0x68,
-  0x03, 0x78, 0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79, 0x68,
-  0x83, 0x72, 0x60, 0x87, 0x74, 0x68, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e,
-  0xca, 0x01, 0x18, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c,
-  0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e,
-  0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0xa1, 0x0d,
-  0xdc, 0xe1, 0x1d, 0xdc, 0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xc2, 0xc1, 0x1c,
-  0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xd2, 0xc1, 0x1d, 0xcc, 0x61, 0x1e,
-  0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d,
-  0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68,
-  0x03, 0x75, 0xa8, 0x87, 0x76, 0x80, 0x87, 0x36, 0xa0, 0x87, 0x70, 0x10,
-  0x07, 0x76, 0x28, 0x87, 0x79, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e,
-  0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1d, 0xc2, 0xc1, 0x1d,
-  0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e,
-  0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78,
-  0x87, 0x36, 0x98, 0x87, 0x74, 0x38, 0x07, 0x77, 0x28, 0x07, 0x72, 0x68,
-  0x03, 0x7d, 0x28, 0x07, 0x79, 0x78, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80,
-  0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e,
-  0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe8, 0x41, 0x1e,
-  0xc2, 0x01, 0x1e, 0xe0, 0x21, 0x1d, 0xdc, 0xe1, 0x1c, 0xda, 0xa0, 0x1d,
-  0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00,
-  0x88, 0x79, 0xa0, 0x87, 0x70, 0x18, 0x87, 0x75, 0x68, 0x03, 0x78, 0x90,
-  0x87, 0x77, 0xa0, 0x87, 0x72, 0x18, 0x07, 0x7a, 0x78, 0x07, 0x79, 0x68,
-  0x03, 0x71, 0xa8, 0x07, 0x73, 0x30, 0x87, 0x72, 0x90, 0x87, 0x36, 0x98,
-  0x87, 0x74, 0xd0, 0x87, 0x72, 0x00, 0xf0, 0x00, 0x20, 0xea, 0xc1, 0x1d,
-  0xe6, 0x21, 0x1c, 0xcc, 0xa1, 0x1c, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d,
-  0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28,
-  0x07, 0x80, 0xa8, 0x87, 0x79, 0x28, 0x87, 0x36, 0x98, 0x87, 0x77, 0x30,
-  0x07, 0x7a, 0x68, 0x03, 0x73, 0x60, 0x87, 0x77, 0x08, 0x07, 0x7a, 0x00,
-  0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0xd8, 0xb0, 0x08, 0x03,
-  0x90, 0x00, 0x0b, 0x50, 0x05, 0x69, 0x00, 0x6d, 0x58, 0x06, 0x02, 0x48,
-  0x80, 0x05, 0xa8, 0x82, 0x34, 0x00, 0x85, 0x0d, 0x06, 0x51, 0x00, 0x0b,
-  0x50, 0x6d, 0x30, 0x0a, 0x03, 0x58, 0x80, 0x6a, 0x83, 0x61, 0x1c, 0xc0,
-  0x02, 0x54, 0x1b, 0x8c, 0xe3, 0xff, 0xff, 0xff, 0xff, 0x07, 0x40, 0x02,
-  0xa8, 0x0d, 0x0a, 0xf2, 0xff, 0xff, 0xff, 0xff, 0x03, 0xd0, 0x06, 0xc0,
-  0x1a, 0x00, 0x12, 0x50, 0x6d, 0x30, 0x92, 0x00, 0x58, 0x80, 0x6a, 0x83,
-  0xa1, 0x08, 0xc0, 0x02, 0x54, 0x00, 0x49, 0x18, 0x00, 0x00, 0x04, 0x00,
-  0x00, 0x00, 0x13, 0x8c, 0x40, 0x18, 0x88, 0xc2, 0x98, 0x10, 0x1c, 0x13,
-  0x06, 0x24, 0x51, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x2a, 0x00,
-  0x00, 0x00, 0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22,
-  0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c,
-  0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x74, 0x33, 0x00, 0xc3, 0x08,
-  0x04, 0x30, 0x8c, 0x20, 0x00, 0x83, 0x08, 0x41, 0x30, 0x8c, 0x30, 0x00,
-  0x07, 0x49, 0x53, 0x44, 0x09, 0x93, 0x2f, 0xbb, 0x6f, 0x47, 0x08, 0xce,
-  0x40, 0x20, 0x82, 0x10, 0x42, 0x06, 0x11, 0x0a, 0xe1, 0x28, 0x69, 0x8a,
-  0x28, 0x61, 0xf2, 0xff, 0x89, 0xb8, 0x26, 0x2a, 0x22, 0x7e, 0x7b, 0xf8,
-  0xa7, 0x31, 0x02, 0x60, 0x10, 0xe1, 0x08, 0x2e, 0x92, 0xa6, 0x88, 0x12,
-  0x26, 0xff, 0x97, 0x00, 0xe6, 0x59, 0x88, 0xe8, 0x9f, 0xc6, 0x08, 0x80,
-  0x41, 0x84, 0x44, 0x28, 0x48, 0x08, 0x62, 0x18, 0x84, 0x14, 0xad, 0x32,
-  0x00, 0x42, 0xa8, 0xcd, 0x11, 0x20, 0x46, 0x08, 0x6f, 0x8e, 0x20, 0x98,
-  0x23, 0x00, 0x83, 0x61, 0x04, 0x41, 0x2a, 0x0a, 0x44, 0x4a, 0xc4, 0x19,
-  0x01, 0x90, 0x44, 0x07, 0x02, 0x52, 0x40, 0x0e, 0x23, 0x0c, 0xd2, 0x20,
-  0x42, 0x20, 0xcc, 0x11, 0x80, 0xc2, 0x20, 0x02, 0x21, 0x8c, 0x00, 0x00,
-  0x00, 0x00, 0x13, 0xbe, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68,
-  0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78,
-  0x87, 0x79, 0x88, 0x83, 0x39, 0x70, 0x03, 0x38, 0x70, 0x03, 0x38, 0x68,
-  0x83, 0x79, 0x48, 0x87, 0x76, 0xa8, 0x07, 0x76, 0x08, 0x07, 0x7a, 0x78,
-  0x07, 0x79, 0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06, 0xf0, 0xa0, 0x07, 0x76,
-  0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d,
-  0x90, 0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9,
-  0x80, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x71,
-  0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d,
-  0x90, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73,
-  0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74,
-  0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a,
-  0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x76,
-  0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d,
-  0x60, 0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71,
-  0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07, 0x7a, 0x30, 0x07, 0x72,
-  0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x73, 0x20, 0x07, 0x7a,
-  0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x74,
-  0x80, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d,
-  0x60, 0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
-  0x40, 0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x72,
-  0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71,
-  0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71,
-  0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x79, 0x20, 0x07, 0x7a,
-  0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x6d,
-  0x60, 0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76,
-  0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x50, 0x07, 0x71,
-  0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71,
-  0x20, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x7a,
-  0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72,
-  0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a,
-  0x30, 0x07, 0x72, 0xa0, 0x11, 0xc2, 0x90, 0x11, 0xdb, 0x95, 0xff, 0xf9,
-  0xda, 0xf5, 0x5f, 0x44, 0x80, 0xc1, 0x10, 0xcd, 0x34, 0x24, 0x02, 0xa2,
-  0x05, 0x00, 0x80, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x86,
-  0x44, 0x51, 0xd3, 0x00, 0x01, 0x20, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00,
-  0x00, 0xc0, 0x90, 0xc8, 0xdb, 0x28, 0x20, 0x00, 0x06, 0x00, 0x00, 0x00,
-  0x01, 0x00, 0x00, 0x00, 0x90, 0xd8, 0x20, 0x50, 0x54, 0x6a, 0x00, 0x00,
-  0x20, 0x0b, 0x04, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x32, 0x1e,
-  0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04,
-  0x43, 0x92, 0x45, 0x50, 0x02, 0x85, 0x30, 0x02, 0x50, 0x20, 0x65, 0x50,
-  0x80, 0x01, 0x05, 0x54, 0x60, 0xa5, 0x50, 0x0c, 0xa4, 0x47, 0x00, 0xe8,
-  0x8e, 0x25, 0x38, 0x02, 0x00, 0x00, 0xb1, 0x18, 0x00, 0x00, 0x7b, 0x00,
-  0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01,
-  0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78,
-  0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4,
-  0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c,
-  0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03,
-  0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70,
-  0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70,
-  0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec,
-  0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0,
-  0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d,
-  0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43,
-  0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0,
-  0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68,
-  0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28,
-  0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08,
-  0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee,
-  0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62,
-  0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c,
-  0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06,
-  0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43,
-  0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3,
-  0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3,
-  0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68,
-  0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce,
-  0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3,
-  0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d,
-  0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e,
-  0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51,
-  0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60,
-  0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98,
-  0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e,
-  0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e,
-  0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83,
-  0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2,
-  0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a,
-  0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28,
-  0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5,
-  0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17,
-  0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83,
-  0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3,
-  0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3,
-  0x3c, 0x00, 0x79, 0x20, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x32, 0x9a,
-  0x08, 0x14, 0x02, 0x85, 0x8c, 0x27, 0x46, 0x46, 0xc8, 0x11, 0x32, 0x64,
-  0xd4, 0xd6, 0x80, 0x0c, 0x76, 0x09, 0x8b, 0xe2, 0x06, 0xc5, 0xc6, 0x91,
-  0x41, 0x14, 0x19, 0x8c, 0x22, 0x31, 0x88, 0x94, 0x3d, 0x06, 0xa2, 0x3c,
-  0x12, 0x12, 0x5d, 0x03, 0x65, 0x18, 0x86, 0x61, 0x24, 0xc6, 0xa2, 0x60,
-  0x44, 0xb1, 0x1c, 0x01, 0x00, 0x00, 0x53, 0x44, 0x4b, 0x20, 0x56, 0x65,
-  0x72, 0x73, 0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68, 0x61, 0x72, 0x5f, 0x73,
-  0x69, 0x7a, 0x65, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x4c, 0x4c, 0x56,
-  0x4d, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x33, 0x31,
-  0x30, 0x30, 0x31, 0x2e, 0x34, 0x33, 0x20, 0x28, 0x6d, 0x65, 0x74, 0x61,
-  0x6c, 0x66, 0x65, 0x2d, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x34, 0x33,
+  0x73, 0x00, 0x00, 0x00, 0x44, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x30, 0x82, 0x10, 0x0d, 0x23, 0x08, 0x96, 0x33, 0x82, 0x10, 0x11, 0x23,
+  0x08, 0x51, 0x31, 0x82, 0x10, 0x19, 0x23, 0x08, 0x0b, 0x30, 0x82, 0x10,
+  0x1d, 0x23, 0x08, 0x11, 0x32, 0x82, 0x10, 0x25, 0x23, 0x08, 0x91, 0x32,
+  0x82, 0x10, 0x2d, 0x23, 0x08, 0x11, 0x33, 0x82, 0x10, 0x35, 0x33, 0x0c,
+  0x6d, 0x10, 0xb8, 0xc1, 0x0c, 0xc3, 0x1b, 0x08, 0x70, 0x30, 0x43, 0x30,
+  0xcc, 0x30, 0xb4, 0x41, 0x1b, 0xc4, 0xc1, 0x0c, 0x04, 0xf1, 0x06, 0x6f,
+  0x10, 0x07, 0x33, 0x04, 0xc5, 0x0c, 0x81, 0x31, 0x43, 0x70, 0xcc, 0x50,
+  0x20, 0x71, 0x10, 0x07, 0x89, 0x32, 0x43, 0x20, 0x0a, 0x33, 0x20, 0x71,
+  0xb0, 0x30, 0x4d, 0xa2, 0x38, 0xcf, 0x0c, 0xc9, 0x1b, 0x40, 0x11, 0x23,
+  0x25, 0x8a, 0x33, 0xcd, 0x90, 0xb4, 0x01, 0x44, 0x31, 0x52, 0x52, 0x39,
+  0xd6, 0x0c, 0x54, 0x1c, 0xd4, 0x41, 0x1c, 0x70, 0x5d, 0x1d, 0xd4, 0x41,
+  0x1c, 0x70, 0x9e, 0x1d, 0xd4, 0x41, 0x1c, 0x70, 0xdf, 0x1d, 0xd4, 0x41,
+  0x1c, 0x70, 0x60, 0x30, 0x83, 0x34, 0x07, 0x17, 0x46, 0x07, 0xd9, 0x1b,
+  0xbc, 0x81, 0xb6, 0x9d, 0x42, 0x18, 0xd0, 0x81, 0x18, 0xd4, 0x41, 0x32,
+  0x06, 0x0e, 0x19, 0xcc, 0xa0, 0xc0, 0x41, 0x19, 0x64, 0x71, 0xf0, 0x06,
+  0x66, 0x90, 0x9c, 0x81, 0x83, 0x06, 0x33, 0x28, 0x78, 0x50, 0x06, 0xd9,
+  0x1b, 0xbc, 0x81, 0x19, 0x24, 0x67, 0xe0, 0xa4, 0xc1, 0x0c, 0x49, 0x1e,
+  0xa8, 0x41, 0x16, 0x07, 0x6f, 0x90, 0xac, 0x81, 0xc3, 0x06, 0x33, 0x1c,
+  0xa4, 0x50, 0x0a, 0xa6, 0x80, 0x0a, 0xa9, 0xa0, 0x0a, 0xab, 0x30, 0xc3,
+  0x20, 0x07, 0xa3, 0xc0, 0x0a, 0x15, 0x06, 0x00, 0xc7, 0x71, 0x1c, 0xc7,
+  0x71, 0x1c, 0xc7, 0x71, 0x1c, 0xe7, 0x06, 0x6e, 0x60, 0xd1, 0x81, 0x1e,
+  0x58, 0x96, 0xa5, 0x07, 0x9c, 0x29, 0xb0, 0x02, 0x2b, 0xd8, 0x86, 0x5f,
+  0xd8, 0x83, 0x3d, 0xa8, 0x03, 0x39, 0xc8, 0x48, 0x60, 0x82, 0x2e, 0x62,
+  0x63, 0xb3, 0x6b, 0x73, 0x69, 0x7b, 0x23, 0xab, 0x63, 0x2b, 0x73, 0x31,
+  0x63, 0x0b, 0x3b, 0x9b, 0x1b, 0x45, 0xc8, 0x03, 0x3d, 0x38, 0x85, 0x8d,
+  0xcd, 0xae, 0xcd, 0x25, 0x8d, 0xac, 0xcc, 0x8d, 0x6e, 0x94, 0x60, 0x0f,
+  0x6e, 0x09, 0x4b, 0x93, 0x73, 0xb1, 0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73,
+  0x1b, 0x25, 0xe0, 0x83, 0xa3, 0xc2, 0xd2, 0xe4, 0x5c, 0xd8, 0xc2, 0xdc,
+  0xce, 0xea, 0xc2, 0xce, 0xca, 0xbe, 0xec, 0xca, 0xe4, 0xe6, 0xd2, 0xde,
+  0xdc, 0x46, 0x09, 0xfa, 0xe0, 0xa6, 0xb0, 0x34, 0x39, 0x97, 0xb1, 0xb7,
+  0x36, 0xb8, 0x34, 0xb6, 0xb2, 0xaf, 0x37, 0x38, 0xba, 0xb4, 0x37, 0xb7,
+  0xb9, 0x51, 0x06, 0x3f, 0xf8, 0x03, 0x50, 0x38, 0x26, 0x2c, 0x4d, 0xce,
+  0xc5, 0x4c, 0x2e, 0xec, 0xac, 0xad, 0xcc, 0x8d, 0x6e, 0x94, 0x80, 0x15,
+  0x00, 0x00, 0x00, 0x00, 0xa9, 0x18, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
+  0x0b, 0x0a, 0x72, 0x28, 0x87, 0x77, 0x80, 0x07, 0x7a, 0x58, 0x70, 0x98,
+  0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb0, 0x43, 0x39, 0xd0, 0xc3, 0x82, 0xe6,
+  0x1c, 0xc6, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0xc1, 0x1d, 0xe6, 0x21,
+  0x1d, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x00, 0xd1, 0x10, 0x00, 0x00,
+  0x06, 0x00, 0x00, 0x00, 0x07, 0xcc, 0x3c, 0xa4, 0x83, 0x3b, 0x9c, 0x03,
+  0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83, 0x3c, 0x94, 0x43, 0x38, 0x90, 0xc3,
+  0x01, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x3b, 0x00, 0x00, 0x00,
+  0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
+  0x04, 0x6b, 0x60, 0x04, 0x80, 0xe2, 0x0c, 0x00, 0xc9, 0x11, 0x00, 0xba,
+  0x63, 0x0d, 0x40, 0x20, 0xcc, 0x31, 0x18, 0x18, 0x36, 0xc7, 0x60, 0x10,
+  0xd8, 0x58, 0x03, 0x30, 0x10, 0x94, 0x47, 0x00, 0x08, 0x8c, 0x00, 0xcc,
+  0x00, 0x8c, 0x11, 0x80, 0x20, 0x08, 0xe2, 0x1f, 0x85, 0x19, 0x80, 0x39,
+  0x08, 0x30, 0x00, 0x03, 0x30, 0x08, 0x03, 0x00, 0x23, 0x06, 0xcd, 0x10,
+  0x82, 0x60, 0x30, 0x89, 0x41, 0xf4, 0x4c, 0xce, 0xd2, 0x14, 0x85, 0x37,
+  0x9a, 0x10, 0x00, 0x83, 0x0c, 0x01, 0xb1, 0x8c, 0x18, 0x34, 0x43, 0x08,
+  0x82, 0xc1, 0x54, 0x06, 0x93, 0x64, 0x45, 0x0e, 0x84, 0x20, 0x61, 0x30,
+  0x9a, 0x10, 0x00, 0x83, 0x0c, 0xc1, 0xd1, 0x0c, 0x32, 0x10, 0x41, 0x73,
+  0x19, 0x5e, 0x0a, 0x42, 0x19, 0x64, 0x08, 0x96, 0xc9, 0x88, 0x00, 0xfc,
+  0x37, 0x19, 0xba, 0x68, 0x0d, 0x2e, 0xc0, 0x4b, 0x41, 0x28, 0x83, 0x0c,
+  0x01, 0x84, 0x8d, 0x18, 0x1c, 0x42, 0x08, 0x82, 0x85, 0x7f, 0x30, 0x72,
+  0x50, 0x04, 0x9b, 0x0c, 0x62, 0x60, 0xc5, 0xc1, 0x05, 0x78, 0x29, 0x08,
+  0x65, 0x90, 0x21, 0xa8, 0xba, 0x11, 0x83, 0x43, 0x08, 0x41, 0xb0, 0xf0,
+  0x0f, 0xe6, 0x0e, 0x94, 0x60, 0x93, 0xe1, 0x0c, 0x36, 0x39, 0xb8, 0x00,
+  0x2f, 0x05, 0xa1, 0x0c, 0x32, 0x04, 0x9a, 0x18, 0x8c, 0x18, 0x1c, 0x42,
+  0x08, 0x82, 0x85, 0x7f, 0x30, 0x7c, 0xf0, 0x04, 0x73, 0x0c, 0xdb, 0x82,
+  0x07, 0x73, 0x0c, 0xc1, 0xb1, 0x07, 0x73, 0x0c, 0xc1, 0xd0, 0x07, 0x16,
+  0xc4, 0x81, 0xf8, 0x67, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x32, 0x0e, 0x10, 0x22, 0x84, 0x00, 0xfb, 0x05,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x0c, 0x00, 0x00,
+  0x29, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0x38, 0x01, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+  0x44, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x98, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x43, 0x00, 0x00, 0x00,
+  0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+  0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+  0xff, 0xff, 0xff, 0xff, 0x00, 0x24, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+  0x0d, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00,
+  0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+  0x1b, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00,
+  0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x5d, 0x0c, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0xe2,
+  0x00, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x4e, 0x56, 0x31, 0x32,
+  0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x69, 0x72,
+  0x2e, 0x64, 0x6f, 0x74, 0x2e, 0x76, 0x33, 0x66, 0x33, 0x32, 0x61, 0x69,
+  0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x74, 0x65, 0x78,
+  0x74, 0x75, 0x72, 0x65, 0x5f, 0x32, 0x64, 0x2e, 0x76, 0x34, 0x66, 0x33,
+  0x32, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x35, 0x30, 0x2e, 0x31, 0x61,
+  0x69, 0x72, 0x36, 0x34, 0x2d, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2d, 0x69,
+  0x6f, 0x73, 0x31, 0x33, 0x2e, 0x30, 0x2e, 0x30, 0x2d, 0x73, 0x69, 0x6d,
+  0x75, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+  0x28, 0x0e, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde,
+  0x35, 0x14, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x62, 0x0c, 0x30, 0x24,
+  0x80, 0x10, 0x05, 0xc8, 0x14, 0x00, 0x00, 0x00, 0x21, 0x0c, 0x00, 0x00,
+  0x39, 0x03, 0x00, 0x00, 0x0b, 0x02, 0x21, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x13, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49,
+  0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19,
+  0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42,
+  0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88,
+  0x48, 0x90, 0x14, 0x20, 0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42,
+  0x04, 0x49, 0x0e, 0x90, 0x91, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c,
+  0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x29, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00,
+  0x92, 0x00, 0x00, 0x00, 0x1b, 0xcc, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff,
+  0x01, 0x58, 0x03, 0x40, 0x02, 0x2a, 0x62, 0x1c, 0xde, 0x41, 0x1e, 0xe4,
+  0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xd8, 0x21, 0x1f, 0xda, 0x40, 0x1e, 0xde,
+  0xa1, 0x1e, 0xdc, 0x81, 0x1c, 0xca, 0x81, 0x1c, 0xda, 0x80, 0x1c, 0xd2,
+  0xc1, 0x1e, 0xd2, 0x81, 0x1c, 0xca, 0xa1, 0x0d, 0xe6, 0x21, 0x1e, 0xe4,
+  0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8,
+  0x01, 0x1d, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08,
+  0x72, 0x48, 0x87, 0x79, 0x08, 0x07, 0x71, 0x60, 0x87, 0x72, 0x68, 0x03,
+  0x7a, 0x08, 0x87, 0x74, 0x60, 0x87, 0x36, 0x18, 0x87, 0x70, 0x60, 0x07,
+  0x76, 0x98, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00,
+  0x82, 0x1d, 0xca, 0x61, 0x1e, 0xe6, 0xa1, 0x0d, 0xe0, 0x41, 0x1e, 0xca,
+  0x61, 0x1c, 0xd2, 0x61, 0x1e, 0xca, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda,
+  0x21, 0x1c, 0xc8, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07,
+  0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68, 0x87,
+  0x72, 0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28, 0x07,
+  0x79, 0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68, 0x07, 0x80, 0x1e, 0xe4,
+  0xa1, 0x1e, 0xca, 0x01, 0x18, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4,
+  0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc,
+  0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda,
+  0xa1, 0x0d, 0xdc, 0xe1, 0x1d, 0xdc, 0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xc2,
+  0xc1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xd2, 0xc1, 0x1d, 0xcc,
+  0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8,
+  0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87,
+  0x77, 0x68, 0x03, 0x75, 0xa8, 0x87, 0x76, 0x80, 0x87, 0x36, 0xa0, 0x87,
+  0x70, 0x10, 0x07, 0x76, 0x28, 0x87, 0x79, 0x00, 0xcc, 0x21, 0x1c, 0xd8,
+  0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1d, 0xc2,
+  0xc1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2,
+  0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08,
+  0x77, 0x78, 0x87, 0x36, 0x98, 0x87, 0x74, 0x38, 0x07, 0x77, 0x28, 0x07,
+  0x72, 0x68, 0x03, 0x7d, 0x28, 0x07, 0x79, 0x78, 0x87, 0x79, 0x68, 0x03,
+  0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8,
+  0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe8,
+  0x41, 0x1e, 0xc2, 0x01, 0x1e, 0xe0, 0x21, 0x1d, 0xdc, 0xe1, 0x1c, 0xda,
+  0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87,
+  0x72, 0x00, 0x88, 0x79, 0xa0, 0x87, 0x70, 0x18, 0x87, 0x75, 0x68, 0x03,
+  0x78, 0x90, 0x87, 0x77, 0xa0, 0x87, 0x72, 0x18, 0x07, 0x7a, 0x78, 0x07,
+  0x79, 0x68, 0x03, 0x71, 0xa8, 0x07, 0x73, 0x30, 0x87, 0x72, 0x90, 0x87,
+  0x36, 0x98, 0x87, 0x74, 0xd0, 0x87, 0x72, 0x00, 0xf0, 0x00, 0x20, 0xea,
+  0xc1, 0x1d, 0xe6, 0x21, 0x1c, 0xcc, 0xa1, 0x1c, 0xda, 0xc0, 0x1c, 0xe0,
+  0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87,
+  0x7a, 0x28, 0x07, 0x80, 0xa8, 0x87, 0x79, 0x28, 0x87, 0x36, 0x98, 0x87,
+  0x77, 0x30, 0x07, 0x7a, 0x68, 0x03, 0x73, 0x60, 0x87, 0x77, 0x08, 0x07,
+  0x7a, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0xd8, 0xb0,
+  0x08, 0x04, 0x90, 0x00, 0x0b, 0x50, 0x05, 0x69, 0x00, 0x0a, 0x1b, 0x8c,
+  0xa1, 0x00, 0x16, 0xa0, 0xda, 0x60, 0x10, 0x06, 0xb0, 0x00, 0xd5, 0x06,
+  0xa3, 0x38, 0x80, 0x05, 0xa8, 0x36, 0x18, 0xc6, 0xff, 0xff, 0xff, 0xff,
+  0x0f, 0x80, 0x04, 0x50, 0x1b, 0x94, 0xe3, 0xff, 0xff, 0xff, 0xff, 0x07,
+  0xa0, 0x0d, 0x80, 0x35, 0x00, 0x24, 0xa0, 0xda, 0x60, 0x20, 0x01, 0xb0,
+  0x00, 0xd5, 0x06, 0x23, 0x11, 0x80, 0x05, 0xa8, 0x00, 0x00, 0x00, 0x00,
+  0x49, 0x18, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x13, 0x8a, 0x40, 0x18,
+  0x88, 0x62, 0x42, 0x60, 0x4c, 0x18, 0x0e, 0x24, 0x01, 0x00, 0x00, 0x00,
+  0x89, 0x20, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09,
+  0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3,
+  0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c,
+  0x10, 0x70, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00, 0xc3,
+  0x08, 0x03, 0x70, 0x90, 0x34, 0x45, 0x94, 0x30, 0xf9, 0xb2, 0xfb, 0x76,
+  0x84, 0xe0, 0x0c, 0x04, 0x22, 0xc6, 0x18, 0x63, 0x10, 0x81, 0x10, 0x8e,
+  0x92, 0xa6, 0x88, 0x12, 0x26, 0xff, 0x9f, 0x88, 0x6b, 0xa2, 0x22, 0xe2,
+  0xb7, 0x87, 0x7f, 0x1a, 0x23, 0x00, 0x06, 0x11, 0x8c, 0xe0, 0x22, 0x69,
+  0x8a, 0x28, 0x61, 0xf2, 0x7f, 0x09, 0x60, 0x9e, 0x85, 0x88, 0xfe, 0x69,
+  0x8c, 0x00, 0x18, 0x44, 0x40, 0x84, 0x82, 0x84, 0x10, 0x44, 0x39, 0x27,
+  0x91, 0x2a, 0x03, 0x18, 0x83, 0xd8, 0x1c, 0x01, 0x62, 0x84, 0xe0, 0xe6,
+  0x08, 0x82, 0x39, 0x02, 0x30, 0x18, 0x46, 0x10, 0xa2, 0xa2, 0xbc, 0x93,
+  0x04, 0x94, 0x10, 0x80, 0x48, 0x73, 0x20, 0x20, 0x05, 0xe2, 0x30, 0xc2,
+  0x10, 0x0d, 0x22, 0x04, 0xc2, 0x1c, 0x01, 0x28, 0x0c, 0x22, 0x0c, 0xc2,
+  0x08, 0x00, 0x00, 0x00, 0x13, 0xbe, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03,
+  0x3a, 0x68, 0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83,
+  0x74, 0x78, 0x87, 0x79, 0x88, 0x83, 0x39, 0x70, 0x03, 0x38, 0x70, 0x03,
+  0x38, 0x68, 0x83, 0x79, 0x48, 0x87, 0x76, 0xa8, 0x07, 0x76, 0x08, 0x07,
+  0x7a, 0x78, 0x07, 0x79, 0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06, 0xf0, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0,
+  0x06, 0xe9, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90,
+  0x0e, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x6d, 0x90, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60,
+  0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60,
+  0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x6d, 0x60, 0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0,
+  0x07, 0x71, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x73, 0x20,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60,
+  0x0f, 0x74, 0x80, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x6d, 0x60, 0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07, 0x7a, 0x10,
+  0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60,
+  0x0f, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0,
+  0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x79, 0x20,
+  0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60,
+  0x07, 0x6d, 0x60, 0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50,
+  0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x50,
+  0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50,
+  0x07, 0x71, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07, 0x72, 0x40,
+  0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00,
+  0x07, 0x72, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x11, 0xc2, 0x90, 0x11, 0xdb, 0x95,
+  0xff, 0xf9, 0xda, 0xf5, 0x5f, 0x44, 0x80, 0xc1, 0x10, 0xcd, 0x34, 0x24,
+  0x02, 0x22, 0x05, 0x00, 0x80, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
+  0x00, 0x86, 0x44, 0x51, 0xc3, 0x00, 0x01, 0x20, 0x00, 0x00, 0x00, 0x08,
+  0x00, 0x00, 0x00, 0xc0, 0x90, 0xc8, 0xdb, 0x26, 0x20, 0x00, 0x06, 0x00,
+  0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x90, 0xd8, 0x20, 0x50, 0x74, 0x67,
+  0x00, 0x00, 0x20, 0x0b, 0x04, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+  0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47,
+  0xc6, 0x04, 0x43, 0x8a, 0x45, 0x50, 0x02, 0x85, 0x30, 0x02, 0x50, 0x06,
+  0x05, 0x18, 0x50, 0x20, 0x05, 0x54, 0x60, 0xa5, 0x50, 0x0c, 0x64, 0xc7,
+  0x12, 0x1c, 0x02, 0x00, 0xb1, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00,
+  0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88,
+  0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73,
+  0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e,
+  0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30,
+  0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8,
+  0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b,
+  0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76,
+  0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e,
+  0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e,
+  0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61,
+  0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4,
+  0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76,
+  0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37,
+  0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76,
+  0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71,
+  0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e,
+  0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1,
+  0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61,
+  0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90,
+  0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8,
+  0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc,
+  0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7,
+  0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78,
+  0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f,
+  0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f,
+  0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1,
+  0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0,
+  0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0,
+  0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b,
+  0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c,
+  0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61,
+  0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1,
+  0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc,
+  0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4,
+  0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79,
+  0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72,
+  0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e,
+  0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1,
+  0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8,
+  0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8,
+  0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00,
+  0x79, 0x20, 0x00, 0x00, 0x09, 0x01, 0x00, 0x00, 0x32, 0x9a, 0x08, 0x14,
+  0x02, 0x85, 0x8c, 0x27, 0x46, 0x46, 0xc8, 0x11, 0x32, 0x64, 0xd4, 0xd8,
+  0x80, 0x0c, 0xea, 0x09, 0x8b, 0x02, 0x07, 0xc5, 0xc6, 0x91, 0x41, 0x14,
+  0x19, 0x8c, 0x22, 0x31, 0x88, 0x64, 0x3d, 0x45, 0x66, 0x20, 0xca, 0x23,
+  0x21, 0x94, 0x61, 0x18, 0x86, 0x11, 0x5d, 0x89, 0xb1, 0x28, 0x18, 0x51,
+  0x2c, 0x47, 0x00, 0x00, 0x53, 0x44, 0x4b, 0x20, 0x56, 0x65, 0x72, 0x73,
+  0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68, 0x61, 0x72, 0x5f, 0x73, 0x69, 0x7a,
+  0x65, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x4c, 0x4c, 0x56, 0x4d, 0x20,
+  0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x33, 0x31, 0x30, 0x30,
+  0x31, 0x2e, 0x35, 0x30, 0x20, 0x28, 0x6d, 0x65, 0x74, 0x61, 0x6c, 0x66,
+  0x65, 0x2d, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x35, 0x30, 0x2e, 0x31,
   0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f,
   0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x64, 0x65, 0x6e, 0x6f, 0x72, 0x6d,
   0x73, 0x5f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72,
@@ -1960,127 +1939,120 @@ const unsigned char sdl_metallib[] = {
   0x2e, 0x61, 0x72, 0x67, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x70, 0x6f, 0x73,
   0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x72, 0x61,
   0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x67,
-  0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x38, 0x74, 0x65,
-  0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x44, 0x76, 0x32, 0x5f, 0x66, 0x29,
-  0x61, 0x69, 0x72, 0x2e, 0x70, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74,
-  0x69, 0x76, 0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32, 0x74, 0x65, 0x78,
-  0x63, 0x6f, 0x6f, 0x72, 0x64, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66,
-  0x66, 0x65, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65,
-  0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x6c, 0x6f,
-  0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78,
-  0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x61, 0x64, 0x61, 0x69, 0x72, 0x2e,
-  0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x73, 0x69, 0x7a,
-  0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70,
-  0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65,
-  0x63, 0x6f, 0x6c, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x74, 0x72, 0x75, 0x63,
-  0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x66,
-  0x6c, 0x6f, 0x61, 0x74, 0x33, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x52,
-  0x63, 0x6f, 0x65, 0x66, 0x66, 0x47, 0x63, 0x6f, 0x65, 0x66, 0x66, 0x42,
-  0x63, 0x6f, 0x65, 0x66, 0x66, 0x59, 0x55, 0x56, 0x44, 0x65, 0x63, 0x6f,
+  0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x35, 0x63, 0x6f,
+  0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66, 0x29, 0x61, 0x69, 0x72,
+  0x2e, 0x70, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65,
+  0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74,
+  0x65, 0x64, 0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64,
+  0x44, 0x76, 0x32, 0x5f, 0x66, 0x29, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32,
+  0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x61, 0x69, 0x72, 0x2e,
+  0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75,
+  0x66, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72,
+  0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e,
+  0x64, 0x65, 0x78, 0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x61, 0x64, 0x61,
+  0x69, 0x72, 0x2e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x5f, 0x74, 0x79,
+  0x70, 0x65, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x66, 0x6c, 0x6f, 0x61, 0x74,
+  0x33, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x52, 0x63, 0x6f, 0x65, 0x66,
+  0x66, 0x47, 0x63, 0x6f, 0x65, 0x66, 0x66, 0x42, 0x63, 0x6f, 0x65, 0x66,
+  0x66, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70,
+  0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72,
+  0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e,
+  0x5f, 0x73, 0x69, 0x7a, 0x65, 0x59, 0x55, 0x56, 0x44, 0x65, 0x63, 0x6f,
   0x64, 0x65, 0x64, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x61, 0x69, 0x72, 0x2e,
   0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x73,
   0x61, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65,
   0x32, 0x64, 0x3c, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x2c, 0x20, 0x73, 0x61,
   0x6d, 0x70, 0x6c, 0x65, 0x3e, 0x74, 0x65, 0x78, 0x59, 0x74, 0x65, 0x78,
   0x55, 0x56, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65,
-  0x72, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73, 0x00, 0x64, 0x78,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x82, 0x20, 0x0d, 0x23, 0x08,
-  0xd7, 0x33, 0x82, 0x20, 0x11, 0x23, 0x08, 0x52, 0x31, 0x82, 0x20, 0x19,
-  0x23, 0x08, 0x0c, 0x30, 0x82, 0x20, 0x1d, 0x23, 0x08, 0x12, 0x32, 0x82,
-  0x20, 0x25, 0x23, 0x08, 0x92, 0x32, 0x82, 0x20, 0x2d, 0x23, 0x08, 0x12,
-  0x33, 0x82, 0x20, 0x35, 0x33, 0x0c, 0x6c, 0x10, 0xb4, 0xc1, 0x0c, 0x83,
-  0x1b, 0x08, 0x6f, 0x30, 0x43, 0x30, 0xcc, 0x30, 0xb0, 0x01, 0x1b, 0xc0,
-  0xc1, 0x0c, 0x04, 0xe1, 0x06, 0x6e, 0x00, 0x07, 0x33, 0x04, 0xc5, 0x0c,
-  0x81, 0x31, 0x43, 0x70, 0xcc, 0x50, 0x20, 0x70, 0x00, 0x07, 0x89, 0x32,
-  0x43, 0x10, 0x0a, 0x33, 0x20, 0x70, 0xb0, 0x30, 0x4d, 0xa2, 0x38, 0xcf,
-  0x0c, 0x89, 0x1b, 0x40, 0x11, 0x23, 0x25, 0x93, 0x43, 0xcd, 0x00, 0xb1,
-  0x41, 0x65, 0xc9, 0xc1, 0x05, 0x07, 0x6e, 0x80, 0x65, 0x72, 0xa0, 0xc9,
-  0x41, 0xa2, 0x38, 0xdb, 0x0c, 0x14, 0x1c, 0xc8, 0x01, 0x1c, 0x74, 0x9e,
-  0x1c, 0xc8, 0x01, 0x1c, 0x74, 0x5f, 0x1d, 0xc8, 0x01, 0x1c, 0x74, 0x60,
-  0x60, 0x07, 0x72, 0x00, 0x07, 0x5d, 0x18, 0xcc, 0x20, 0xcd, 0x41, 0x65,
-  0xd1, 0xc1, 0xe5, 0x06, 0x6e, 0x80, 0x71, 0xa6, 0x90, 0xd1, 0x81, 0x26,
-  0x07, 0x89, 0x18, 0x38, 0x63, 0x30, 0x83, 0xf2, 0x06, 0x64, 0x70, 0xc1,
-  0x81, 0x1b, 0x94, 0x41, 0x62, 0x06, 0xce, 0x19, 0xcc, 0xa0, 0xdc, 0x01,
-  0x19, 0x5c, 0x6e, 0xe0, 0x06, 0x65, 0x90, 0x98, 0x81, 0x83, 0x06, 0x33,
-  0x24, 0x78, 0x90, 0x06, 0x17, 0x1c, 0xb8, 0x41, 0xa2, 0x06, 0xce, 0x1a,
-  0xcc, 0x70, 0x8c, 0x02, 0x29, 0x94, 0xc2, 0x29, 0xa0, 0x42, 0x2a, 0xa8,
-  0xc2, 0x0c, 0x43, 0x1c, 0x88, 0xc2, 0x2a, 0x54, 0x18, 0x00, 0x1c, 0xc7,
-  0x71, 0x1c, 0xc7, 0x71, 0x1c, 0xc7, 0x71, 0x9c, 0x1b, 0xb8, 0x81, 0x45,
-  0x07, 0x7a, 0x60, 0x59, 0x96, 0x1e, 0x70, 0xa6, 0xc0, 0x0a, 0x34, 0xc1,
-  0x1b, 0x72, 0x61, 0x0f, 0xf6, 0xa0, 0x0e, 0xe4, 0x20, 0x23, 0x81, 0x09,
-  0xba, 0x88, 0x8d, 0xcd, 0xae, 0xcd, 0xa5, 0xed, 0x8d, 0xac, 0x8e, 0xad,
-  0xcc, 0xc5, 0x8c, 0x2d, 0xec, 0x6c, 0x6e, 0x14, 0x01, 0x0f, 0xf2, 0xe0,
-  0x14, 0x36, 0x36, 0xbb, 0x36, 0x97, 0x34, 0xb2, 0x32, 0x37, 0xba, 0x51,
-  0x02, 0x3d, 0xb8, 0x25, 0x2c, 0x4d, 0xce, 0xc5, 0xae, 0x4c, 0x6e, 0x2e,
-  0xed, 0xcd, 0x6d, 0x94, 0x60, 0x0f, 0x8e, 0x0a, 0x4b, 0x93, 0x73, 0x61,
-  0x0b, 0x73, 0x3b, 0xab, 0x0b, 0x3b, 0x2b, 0xfb, 0xb2, 0x2b, 0x93, 0x9b,
-  0x4b, 0x7b, 0x73, 0x1b, 0x25, 0xe0, 0x83, 0x9b, 0xc2, 0xd2, 0xe4, 0x5c,
-  0xc6, 0xde, 0xda, 0xe0, 0xd2, 0xd8, 0xca, 0xbe, 0xde, 0xe0, 0xe8, 0xd2,
-  0xde, 0xdc, 0xe6, 0x46, 0x19, 0xfa, 0xc0, 0x0f, 0xfe, 0xe0, 0x98, 0xb0,
-  0x34, 0x39, 0x17, 0x33, 0xb9, 0xb0, 0xb3, 0xb6, 0x32, 0x37, 0xba, 0x51,
-  0x82, 0x55, 0x00, 0x00, 0x00, 0x00, 0xa9, 0x18, 0x00, 0x00, 0x0b, 0x00,
-  0x00, 0x00, 0x0b, 0x0a, 0x72, 0x28, 0x87, 0x77, 0x80, 0x07, 0x7a, 0x58,
-  0x70, 0x98, 0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb0, 0x43, 0x39, 0xd0, 0xc3,
-  0x82, 0xe6, 0x1c, 0xc6, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0xc1, 0x1d,
-  0xe6, 0x21, 0x1d, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x00, 0xd1, 0x10,
-  0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0xcc, 0x3c, 0xa4, 0x83, 0x3b,
-  0x9c, 0x03, 0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83, 0x3c, 0x94, 0x43, 0x38,
-  0x90, 0xc3, 0x01, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x56, 0x00,
-  0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x0f, 0x00,
-  0x00, 0x00, 0x14, 0x6b, 0x60, 0x04, 0x80, 0xe4, 0x0c, 0x00, 0xcd, 0x11,
-  0x80, 0xb1, 0x84, 0x00, 0x20, 0x3c, 0xd6, 0x00, 0x04, 0xc2, 0x1c, 0x83,
-  0x91, 0x65, 0x73, 0x0c, 0x06, 0x91, 0x8d, 0x35, 0x00, 0x03, 0x41, 0x60,
-  0x04, 0x60, 0x06, 0x60, 0x8c, 0x00, 0x04, 0x41, 0x10, 0xff, 0x28, 0xcc,
-  0x00, 0xcc, 0x41, 0x84, 0x41, 0x18, 0x84, 0x81, 0x18, 0x90, 0x98, 0x01,
-  0x00, 0x00, 0xf1, 0x30, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x22, 0x47,
-  0xc8, 0x90, 0x51, 0x0a, 0x84, 0x18, 0x00, 0x00, 0x00, 0x00, 0xcf, 0x03,
-  0x00, 0x00, 0x6f, 0x6d, 0x6e, 0x69, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x74,
-  0x20, 0x63, 0x68, 0x61, 0x72, 0x53, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20,
-  0x43, 0x2b, 0x2b, 0x20, 0x54, 0x42, 0x41, 0x41, 0x00, 0x00, 0x13, 0x04,
-  0xcd, 0xd9, 0x10, 0xb8, 0xc2, 0x86, 0xa1, 0x15, 0x60, 0xe1, 0x15, 0x36,
-  0x0c, 0xb1, 0x10, 0x0b, 0xaf, 0x00, 0x23, 0x06, 0xcd, 0x10, 0x82, 0x60,
-  0x40, 0x91, 0x81, 0x04, 0x55, 0x0f, 0xe3, 0x18, 0x06, 0x18, 0x8c, 0x26,
-  0x04, 0xc0, 0x20, 0x43, 0x50, 0x2c, 0x23, 0x06, 0xcd, 0x10, 0x82, 0x60,
-  0x40, 0x9d, 0x01, 0x35, 0x61, 0xd2, 0x13, 0x25, 0xc9, 0x18, 0x8c, 0x26,
-  0x04, 0xc0, 0x20, 0x43, 0x80, 0x40, 0x83, 0x0c, 0xc1, 0xe1, 0x0c, 0x32,
-  0x14, 0x81, 0x73, 0x5b, 0x5e, 0x0a, 0x42, 0x19, 0x64, 0x08, 0x1a, 0xca,
-  0x88, 0x00, 0xfc, 0x09, 0x0c, 0x42, 0xd9, 0x65, 0x00, 0x83, 0x32, 0x78,
-  0x83, 0x0b, 0xf2, 0x52, 0x10, 0xca, 0x20, 0x43, 0x30, 0x69, 0x23, 0x06,
-  0x87, 0x10, 0x82, 0x60, 0xe1, 0x1f, 0x8d, 0x1d, 0x18, 0xc1, 0x2e, 0x43,
-  0x19, 0xa8, 0x41, 0x1d, 0x5c, 0x90, 0x97, 0x82, 0x50, 0x06, 0x19, 0x02,
-  0xec, 0x1b, 0x31, 0x38, 0x84, 0x10, 0x04, 0x0b, 0xff, 0x68, 0xf6, 0x60,
-  0x09, 0x76, 0x19, 0xd4, 0xe0, 0x0d, 0xea, 0xe0, 0x82, 0xbc, 0x14, 0x84,
-  0x32, 0xc8, 0x10, 0x74, 0x64, 0x30, 0x62, 0x70, 0x08, 0x21, 0x08, 0x16,
-  0xfe, 0xd1, 0x80, 0x02, 0x14, 0xcc, 0x31, 0x78, 0x0b, 0x1f, 0xcc, 0x31,
-  0x04, 0xc7, 0x1f, 0xcc, 0x31, 0x04, 0x43, 0x28, 0x58, 0x30, 0x89, 0x7f,
-  0x06, 0x01, 0x31, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x5b, 0x06,
-  0x26, 0x88, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20,
-  0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x32, 0x0e, 0x10, 0x22, 0x84, 0x00,
-  0xfa, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x0c,
-  0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0x38, 0x01, 0x00,
-  0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x08, 0x00,
-  0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x03, 0x00,
-  0x00, 0x00, 0x98, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, 0x00,
-  0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00,
-  0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00,
-  0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x24, 0x00, 0x00, 0x11, 0x00,
-  0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x0d, 0x00,
-  0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x1e, 0x00,
-  0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1b, 0x00,
-  0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x5d, 0x0c, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x12, 0x03,
-  0x94, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x4e, 0x56,
-  0x32, 0x31, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x61,
-  0x69, 0x72, 0x2e, 0x64, 0x6f, 0x74, 0x2e, 0x76, 0x33, 0x66, 0x33, 0x32,
-  0x61, 0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x74,
-  0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x5f, 0x32, 0x64, 0x2e, 0x76, 0x34,
-  0x66, 0x33, 0x32, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x34, 0x33, 0x61,
-  0x69, 0x72, 0x36, 0x34, 0x2d, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2d, 0x69,
-  0x6f, 0x73, 0x31, 0x33, 0x2e, 0x30, 0x2e, 0x30, 0x2d, 0x73, 0x69, 0x6d,
-  0x75, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+  0x72, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73, 0x00, 0x00, 0x00,
+  0x44, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x82, 0x10, 0x0d,
+  0x23, 0x08, 0x96, 0x33, 0x82, 0x10, 0x11, 0x23, 0x08, 0x51, 0x31, 0x82,
+  0x10, 0x19, 0x23, 0x08, 0x0b, 0x30, 0x82, 0x10, 0x1d, 0x23, 0x08, 0x11,
+  0x32, 0x82, 0x10, 0x25, 0x23, 0x08, 0x91, 0x32, 0x82, 0x10, 0x2d, 0x23,
+  0x08, 0x11, 0x33, 0x82, 0x10, 0x35, 0x33, 0x0c, 0x6d, 0x10, 0xb8, 0xc1,
+  0x0c, 0xc3, 0x1b, 0x08, 0x70, 0x30, 0x43, 0x30, 0xcc, 0x30, 0xb4, 0x41,
+  0x1b, 0xc4, 0xc1, 0x0c, 0x04, 0xf1, 0x06, 0x6f, 0x10, 0x07, 0x33, 0x04,
+  0xc5, 0x0c, 0x81, 0x31, 0x43, 0x70, 0xcc, 0x50, 0x20, 0x71, 0x10, 0x07,
+  0x89, 0x32, 0x43, 0x20, 0x0a, 0x33, 0x20, 0x71, 0xb0, 0x30, 0x4d, 0xa2,
+  0x38, 0xcf, 0x0c, 0xc9, 0x1b, 0x40, 0x11, 0x23, 0x25, 0x8a, 0x33, 0xcd,
+  0x90, 0xb4, 0x01, 0x44, 0x31, 0x52, 0x52, 0x39, 0xd6, 0x0c, 0x54, 0x1c,
+  0xd4, 0x41, 0x1c, 0x70, 0x5d, 0x1d, 0xd4, 0x41, 0x1c, 0x70, 0x9e, 0x1d,
+  0xd4, 0x41, 0x1c, 0x70, 0xdf, 0x1d, 0xd4, 0x41, 0x1c, 0x70, 0x60, 0x30,
+  0x83, 0x34, 0x07, 0x17, 0x46, 0x07, 0xd9, 0x1b, 0xbc, 0x81, 0xb6, 0x9d,
+  0x42, 0x18, 0xd0, 0x81, 0x18, 0xd4, 0x41, 0x32, 0x06, 0x0e, 0x19, 0xcc,
+  0xa0, 0xc0, 0x41, 0x19, 0x64, 0x71, 0xf0, 0x06, 0x66, 0x90, 0x9c, 0x81,
+  0x83, 0x06, 0x33, 0x28, 0x78, 0x50, 0x06, 0xd9, 0x1b, 0xbc, 0x81, 0x19,
+  0x24, 0x67, 0xe0, 0xa4, 0xc1, 0x0c, 0x49, 0x1e, 0xa8, 0x41, 0x16, 0x07,
+  0x6f, 0x90, 0xac, 0x81, 0xc3, 0x06, 0x33, 0x1c, 0xa4, 0x50, 0x0a, 0xa6,
+  0x80, 0x0a, 0xa9, 0xa0, 0x0a, 0xab, 0x30, 0xc3, 0x20, 0x07, 0xa3, 0xc0,
+  0x0a, 0x15, 0x06, 0x00, 0xc7, 0x71, 0x1c, 0xc7, 0x71, 0x1c, 0xc7, 0x71,
+  0x1c, 0xe7, 0x06, 0x6e, 0x60, 0xd1, 0x81, 0x1e, 0x58, 0x96, 0xa5, 0x07,
+  0x9c, 0x29, 0xb0, 0x02, 0x2b, 0xd8, 0x86, 0x5f, 0xd8, 0x83, 0x3d, 0xa8,
+  0x03, 0x39, 0xc8, 0x48, 0x60, 0x82, 0x2e, 0x62, 0x63, 0xb3, 0x6b, 0x73,
+  0x69, 0x7b, 0x23, 0xab, 0x63, 0x2b, 0x73, 0x31, 0x63, 0x0b, 0x3b, 0x9b,
+  0x1b, 0x45, 0xc8, 0x03, 0x3d, 0x38, 0x85, 0x8d, 0xcd, 0xae, 0xcd, 0x25,
+  0x8d, 0xac, 0xcc, 0x8d, 0x6e, 0x94, 0x60, 0x0f, 0x6e, 0x09, 0x4b, 0x93,
+  0x73, 0xb1, 0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73, 0x1b, 0x25, 0xe0, 0x83,
+  0xa3, 0xc2, 0xd2, 0xe4, 0x5c, 0xd8, 0xc2, 0xdc, 0xce, 0xea, 0xc2, 0xce,
+  0xca, 0xbe, 0xec, 0xca, 0xe4, 0xe6, 0xd2, 0xde, 0xdc, 0x46, 0x09, 0xfa,
+  0xe0, 0xa6, 0xb0, 0x34, 0x39, 0x97, 0xb1, 0xb7, 0x36, 0xb8, 0x34, 0xb6,
+  0xb2, 0xaf, 0x37, 0x38, 0xba, 0xb4, 0x37, 0xb7, 0xb9, 0x51, 0x06, 0x3f,
+  0xf8, 0x03, 0x50, 0x38, 0x26, 0x2c, 0x4d, 0xce, 0xc5, 0x4c, 0x2e, 0xec,
+  0xac, 0xad, 0xcc, 0x8d, 0x6e, 0x94, 0x80, 0x15, 0x00, 0x00, 0x00, 0x00,
+  0xa9, 0x18, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x0a, 0x72, 0x28,
+  0x87, 0x77, 0x80, 0x07, 0x7a, 0x58, 0x70, 0x98, 0x43, 0x3d, 0xb8, 0xc3,
+  0x38, 0xb0, 0x43, 0x39, 0xd0, 0xc3, 0x82, 0xe6, 0x1c, 0xc6, 0xa1, 0x0d,
+  0xe8, 0x41, 0x1e, 0xc2, 0xc1, 0x1d, 0xe6, 0x21, 0x1d, 0xe8, 0x21, 0x1d,
+  0xde, 0xc1, 0x1d, 0x00, 0xd1, 0x10, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+  0x07, 0xcc, 0x3c, 0xa4, 0x83, 0x3b, 0x9c, 0x03, 0x3b, 0x94, 0x03, 0x3d,
+  0xa0, 0x83, 0x3c, 0x94, 0x43, 0x38, 0x90, 0xc3, 0x01, 0x00, 0x00, 0x00,
+  0x61, 0x20, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c,
+  0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x04, 0x6b, 0x60, 0x04,
+  0x80, 0xe2, 0x0c, 0x00, 0xc9, 0x11, 0x80, 0xb1, 0x84, 0x00, 0xa0, 0x3b,
+  0xd6, 0x00, 0x04, 0xc2, 0x1c, 0x83, 0x81, 0x61, 0x73, 0x0c, 0x06, 0x81,
+  0x8d, 0x35, 0x00, 0x03, 0x41, 0x79, 0x04, 0x80, 0xc0, 0x08, 0xc0, 0x0c,
+  0xc0, 0x18, 0x01, 0x08, 0x82, 0x20, 0xfe, 0x51, 0x98, 0x01, 0x98, 0x83,
+  0x08, 0x83, 0x30, 0x08, 0x03, 0x31, 0x20, 0x31, 0x03, 0x00, 0x00, 0x00,
+  0x23, 0x06, 0xcd, 0x10, 0x82, 0x60, 0x30, 0x91, 0xc1, 0x14, 0x55, 0x50,
+  0xf3, 0x18, 0x06, 0x18, 0x8c, 0x26, 0x04, 0xc0, 0x20, 0x43, 0x50, 0x30,
+  0x23, 0x06, 0xcd, 0x10, 0x82, 0x60, 0x30, 0x9d, 0x41, 0x45, 0x61, 0x13,
+  0x24, 0x25, 0xc9, 0x18, 0x8c, 0x26, 0x04, 0xc0, 0x20, 0x43, 0x80, 0x44,
+  0x83, 0x0c, 0xc1, 0xf1, 0x0c, 0x32, 0x14, 0xc1, 0x73, 0x1c, 0x5e, 0x0a,
+  0x42, 0x19, 0x64, 0x08, 0x9a, 0xca, 0x88, 0x00, 0xfc, 0x37, 0x19, 0xc0,
+  0x60, 0x72, 0x83, 0x0b, 0xf0, 0x52, 0x10, 0xca, 0x20, 0x43, 0x20, 0x69,
+  0x23, 0x06, 0x87, 0x10, 0x82, 0x60, 0xe1, 0x1f, 0x4c, 0x1d, 0x14, 0xc1,
+  0x26, 0x43, 0x19, 0x60, 0x74, 0x70, 0x01, 0x5e, 0x0a, 0x42, 0x19, 0x64,
+  0x08, 0xae, 0x6f, 0xc4, 0xe0, 0x10, 0x42, 0x10, 0x2c, 0xfc, 0x83, 0xd1,
+  0x03, 0x25, 0xd8, 0x64, 0x50, 0x83, 0xae, 0x0e, 0x2e, 0xc0, 0x4b, 0x41,
+  0x28, 0x83, 0x0c, 0x01, 0x47, 0x06, 0x23, 0x06, 0x87, 0x10, 0x82, 0x60,
+  0xe1, 0x1f, 0xcc, 0x1f, 0x3c, 0xc1, 0x1c, 0x43, 0xb7, 0xec, 0xc1, 0x1c,
+  0x43, 0x70, 0xf8, 0xc1, 0x1c, 0x43, 0x30, 0x80, 0x82, 0x05, 0x74, 0x20,
+  0xfe, 0x19, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x32, 0x0e, 0x10, 0x22, 0x84, 0x00, 0xfb, 0x05, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x65, 0x0c, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00,
+  0x12, 0x03, 0x94, 0x38, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x39, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x50, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x98, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x43, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x62, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+  0x00, 0x24, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00,
+  0x11, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+  0x08, 0x24, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00,
+  0x1e, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+  0x08, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5d, 0x0c, 0x00, 0x00,
+  0x1c, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0xe2, 0x00, 0x00, 0x00, 0x00,
+  0x53, 0x44, 0x4c, 0x5f, 0x4e, 0x56, 0x32, 0x31, 0x5f, 0x66, 0x72, 0x61,
+  0x67, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x69, 0x72, 0x2e, 0x64, 0x6f, 0x74,
+  0x2e, 0x76, 0x33, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x61,
+  0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65,
+  0x5f, 0x32, 0x64, 0x2e, 0x76, 0x34, 0x66, 0x33, 0x32, 0x33, 0x31, 0x30,
+  0x30, 0x31, 0x2e, 0x35, 0x30, 0x2e, 0x31, 0x61, 0x69, 0x72, 0x36, 0x34,
+  0x2d, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2d, 0x69, 0x6f, 0x73, 0x31, 0x33,
+  0x2e, 0x30, 0x2e, 0x30, 0x2d, 0x73, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74,
+  0x6f, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 };
-const unsigned int sdl_metallib_len = 24994;
+const unsigned int sdl_metallib_len = 24660;
diff --git a/Engine/lib/sdl/src/render/metal/SDL_shaders_metal_osx.h b/Engine/lib/sdl/src/render/metal/SDL_shaders_metal_osx.h
index 7b46b67e8..2bec8a56d 100644
--- a/Engine/lib/sdl/src/render/metal/SDL_shaders_metal_osx.h
+++ b/Engine/lib/sdl/src/render/metal/SDL_shaders_metal_osx.h
@@ -1,207 +1,209 @@
 const unsigned char sdl_metallib[] = {
   0x4d, 0x54, 0x4c, 0x42, 0x01, 0x80, 0x02, 0x00, 0x05, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x40, 0x56, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x62, 0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4c, 0x03, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0xac, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x04, 0x00, 0x00,
+  0x8e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a, 0x04, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x60, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x51, 0x00, 0x00,
+  0x72, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x50, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00,
   0x4e, 0x41, 0x4d, 0x45, 0x11, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x53, 0x6f,
   0x6c, 0x69, 0x64, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x00, 0x54,
   0x59, 0x50, 0x45, 0x01, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00,
-  0x18, 0xea, 0xb3, 0x5d, 0xbf, 0xaa, 0x85, 0x5c, 0xa4, 0xe2, 0x19, 0xd2,
-  0xd7, 0xf3, 0xc8, 0xae, 0x57, 0x80, 0x4d, 0x74, 0x93, 0x35, 0x84, 0x06,
-  0x60, 0x4b, 0xc2, 0xa9, 0x6e, 0x93, 0x8d, 0x75, 0x4f, 0x46, 0x46, 0x54,
+  0xb0, 0x1e, 0xd4, 0x63, 0x77, 0xeb, 0x95, 0x35, 0xec, 0xfd, 0x42, 0xfc,
+  0x8f, 0x6c, 0xc0, 0x67, 0x91, 0x59, 0x50, 0x52, 0x7e, 0x6d, 0x23, 0xef,
+  0x26, 0x6e, 0x78, 0xc7, 0x67, 0x3f, 0xa3, 0xda, 0x4f, 0x46, 0x46, 0x54,
   0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00, 0x08, 0x00,
   0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x77, 0x00, 0x00, 0x00,
   0x4e, 0x41, 0x4d, 0x45, 0x10, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x43, 0x6f,
   0x70, 0x79, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x00, 0x54, 0x59,
-  0x50, 0x45, 0x01, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00, 0x55,
-  0xff, 0x61, 0x04, 0xcf, 0x03, 0x92, 0x2a, 0xe4, 0x3e, 0x6e, 0xac, 0x10,
-  0x11, 0x71, 0x19, 0x62, 0x92, 0x90, 0x10, 0xb2, 0x4f, 0x3e, 0x09, 0xcf,
-  0xaf, 0x67, 0x48, 0xf4, 0x4a, 0x79, 0xfc, 0x4f, 0x46, 0x46, 0x54, 0x18,
-  0x00, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x50, 0x45, 0x01, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00, 0xc6,
+  0x60, 0xef, 0x78, 0xb0, 0x6b, 0x69, 0x3a, 0x1f, 0x4c, 0xad, 0xbb, 0xcb,
+  0xbc, 0x96, 0x77, 0xac, 0xa6, 0xe1, 0x3b, 0x3b, 0x06, 0x4c, 0x64, 0x10,
+  0xee, 0xfe, 0xc0, 0xb7, 0x24, 0x28, 0x70, 0x4f, 0x46, 0x46, 0x54, 0x18,
+  0x00, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01,
   0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x7a, 0x00, 0x00, 0x00, 0x4e,
   0x41, 0x4d, 0x45, 0x13, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x53, 0x6f, 0x6c,
   0x69, 0x64, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x00,
   0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53, 0x48, 0x20,
-  0x00, 0x5b, 0x2b, 0x83, 0x7d, 0x5e, 0x9c, 0x63, 0x41, 0x0e, 0x77, 0xef,
-  0xcb, 0x9a, 0x54, 0xa9, 0x04, 0x30, 0x49, 0x36, 0x56, 0xad, 0x1e, 0x17,
-  0xd8, 0xf6, 0xe7, 0x7d, 0x59, 0xb0, 0xf4, 0x4d, 0xbb, 0x4f, 0x46, 0x46,
-  0x54, 0x18, 0x00, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x16, 0x00, 0x00, 0x00,
+  0x00, 0xec, 0xda, 0x64, 0x8c, 0x89, 0xb3, 0x61, 0x32, 0x78, 0xa4, 0x67,
+  0x9d, 0xd2, 0xad, 0x75, 0x55, 0x9d, 0xec, 0xf8, 0x6d, 0xc9, 0xb1, 0x4a,
+  0x94, 0xac, 0x2d, 0x9a, 0x29, 0xed, 0xf5, 0x72, 0x3e, 0x4f, 0x46, 0x46,
+  0x54, 0x18, 0x00, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0x17, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00, 0x08,
   0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x79, 0x00, 0x00,
   0x00, 0x4e, 0x41, 0x4d, 0x45, 0x12, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x43,
   0x6f, 0x70, 0x79, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74,
   0x00, 0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53, 0x48,
-  0x20, 0x00, 0xb1, 0x1c, 0x24, 0x29, 0x04, 0xa5, 0x53, 0x74, 0xc4, 0x82,
-  0xad, 0x1a, 0x2d, 0xa9, 0x96, 0xa8, 0xe9, 0xa6, 0x2f, 0x36, 0x1a, 0x7e,
-  0x93, 0x36, 0x9c, 0x2a, 0x0f, 0x97, 0x9e, 0x6e, 0xaf, 0x8a, 0x4f, 0x46,
-  0x46, 0x54, 0x18, 0x00, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x20, 0x00, 0x00,
+  0x20, 0x00, 0x8c, 0xa9, 0xc1, 0x5f, 0x0c, 0x8d, 0x69, 0xe0, 0xac, 0x20,
+  0x39, 0x45, 0xb5, 0x81, 0x5a, 0xbd, 0x1a, 0xb2, 0x48, 0xa8, 0xe7, 0x81,
+  0x31, 0x3b, 0x3a, 0x22, 0x20, 0xe2, 0xb9, 0xf7, 0x71, 0x8f, 0x4f, 0x46,
+  0x46, 0x54, 0x18, 0x00, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0x20, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00,
   0x08, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x78, 0x00,
   0x00, 0x00, 0x4e, 0x41, 0x4d, 0x45, 0x11, 0x00, 0x53, 0x44, 0x4c, 0x5f,
   0x59, 0x55, 0x56, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74,
   0x00, 0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53, 0x48,
-  0x20, 0x00, 0xd6, 0x03, 0x6c, 0x38, 0x0d, 0xb2, 0xc5, 0xa4, 0xb7, 0xac,
-  0x4c, 0x6c, 0x9c, 0x3e, 0xba, 0x38, 0xc2, 0x1a, 0x78, 0xef, 0xa2, 0x3e,
-  0xe7, 0x0c, 0x2c, 0x7e, 0x1a, 0x14, 0xd9, 0xbf, 0xae, 0xfb, 0x4f, 0x46,
-  0x46, 0x54, 0x18, 0x00, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x2b, 0x00, 0x00,
+  0x20, 0x00, 0x21, 0x22, 0xf2, 0x05, 0x0d, 0x3c, 0xbe, 0x5c, 0xe3, 0xc5,
+  0xe5, 0xf2, 0x92, 0x32, 0x24, 0xf8, 0xeb, 0xfe, 0xd1, 0xe9, 0x4e, 0xc0,
+  0x0f, 0x88, 0x2e, 0xf5, 0xfd, 0x77, 0x98, 0x5e, 0x6a, 0x30, 0x4f, 0x46,
+  0x46, 0x54, 0x18, 0x00, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00,
   0x08, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x79, 0x00,
   0x00, 0x00, 0x4e, 0x41, 0x4d, 0x45, 0x12, 0x00, 0x53, 0x44, 0x4c, 0x5f,
   0x4e, 0x56, 0x31, 0x32, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e,
   0x74, 0x00, 0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53,
-  0x48, 0x20, 0x00, 0x21, 0xcc, 0x99, 0xca, 0x3d, 0x14, 0x24, 0x0e, 0xca,
-  0x0a, 0x3c, 0x21, 0xc6, 0xf7, 0xea, 0xe9, 0xd7, 0x67, 0xab, 0xcf, 0x59,
-  0x48, 0xf3, 0x7f, 0xcf, 0x44, 0x88, 0x29, 0x73, 0xe3, 0xc0, 0x97, 0x4f,
-  0x46, 0x46, 0x54, 0x18, 0x00, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x38, 0x00,
+  0x48, 0x20, 0x00, 0xe5, 0xd5, 0x21, 0xe2, 0x33, 0x80, 0x3a, 0xf8, 0xa1,
+  0x58, 0x1b, 0xcc, 0x61, 0xe3, 0xba, 0xd9, 0x3e, 0xc3, 0x5a, 0xaa, 0xbc,
+  0x0c, 0x67, 0x0a, 0x41, 0xcc, 0x77, 0xb3, 0xb8, 0x43, 0x43, 0x43, 0x4f,
+  0x46, 0x46, 0x54, 0x18, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x37, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01,
   0x00, 0x08, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x79,
   0x00, 0x00, 0x00, 0x4e, 0x41, 0x4d, 0x45, 0x12, 0x00, 0x53, 0x44, 0x4c,
   0x5f, 0x4e, 0x56, 0x32, 0x31, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65,
   0x6e, 0x74, 0x00, 0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41,
-  0x53, 0x48, 0x20, 0x00, 0xa8, 0x51, 0xa7, 0x5a, 0x68, 0xcb, 0x23, 0x3b,
-  0xb3, 0xad, 0x28, 0x51, 0x84, 0x7c, 0xb4, 0x76, 0x1d, 0x33, 0x29, 0xdd,
-  0x07, 0x44, 0xe1, 0x68, 0xec, 0xdd, 0x61, 0x02, 0x20, 0x3f, 0x1c, 0xfd,
-  0x4f, 0x46, 0x46, 0x54, 0x18, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x45,
+  0x53, 0x48, 0x20, 0x00, 0xd2, 0x98, 0x77, 0xab, 0xf4, 0x02, 0x99, 0x2b,
+  0x5d, 0xda, 0xac, 0xe3, 0x25, 0xb7, 0xe0, 0xfd, 0x5f, 0x85, 0x65, 0x3b,
+  0x16, 0xb8, 0x21, 0xa3, 0x6e, 0x13, 0x5b, 0x11, 0x32, 0x77, 0xca, 0xc2,
+  0x4f, 0x46, 0x46, 0x54, 0x18, 0x00, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x44,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00,
   0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54,
-  0x45, 0x4e, 0x44, 0x54, 0x20, 0x00, 0x00, 0x00, 0x56, 0x41, 0x54, 0x54,
-  0x0d, 0x00, 0x01, 0x00, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e,
-  0x00, 0x00, 0x80, 0x56, 0x41, 0x54, 0x59, 0x03, 0x00, 0x01, 0x00, 0x04,
-  0x45, 0x4e, 0x44, 0x54, 0x2c, 0x00, 0x00, 0x00, 0x56, 0x41, 0x54, 0x54,
-  0x18, 0x00, 0x02, 0x00, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e,
-  0x00, 0x00, 0x80, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x00,
-  0x01, 0x80, 0x56, 0x41, 0x54, 0x59, 0x04, 0x00, 0x02, 0x00, 0x04, 0x04,
-  0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54,
-  0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00,
-  0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54,
-  0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00,
-  0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54,
-  0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00,
-  0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54,
-  0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00,
-  0x45, 0x4e, 0x44, 0x54, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00,
-  0x14, 0x00, 0x00, 0x00, 0x44, 0x0b, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
-  0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0xce, 0x02, 0x00, 0x00,
-  0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
-  0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39,
-  0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62,
-  0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14,
-  0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90, 0x21,
-  0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8, 0x48,
-  0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00,
-  0x51, 0x18, 0x00, 0x00, 0x83, 0x00, 0x00, 0x00, 0x1b, 0xc8, 0x25, 0xf8,
-  0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x80, 0x8a, 0x18, 0x87, 0x77, 0x90,
-  0x07, 0x79, 0x28, 0x87, 0x71, 0xa0, 0x07, 0x76, 0xc8, 0x87, 0x36, 0x90,
-  0x87, 0x77, 0xa8, 0x07, 0x77, 0x20, 0x87, 0x72, 0x20, 0x87, 0x36, 0x20,
-  0x87, 0x74, 0xb0, 0x87, 0x74, 0x20, 0x87, 0x72, 0x68, 0x83, 0x79, 0x88,
-  0x07, 0x79, 0xa0, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08,
-  0x07, 0x7a, 0x40, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c,
-  0x00, 0x82, 0x1c, 0xd2, 0x61, 0x1e, 0xc2, 0x41, 0x1c, 0xd8, 0xa1, 0x1c,
-  0xda, 0x80, 0x1e, 0xc2, 0x21, 0x1d, 0xd8, 0xa1, 0x0d, 0xc6, 0x21, 0x1c,
-  0xd8, 0x81, 0x1d, 0xe6, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28,
-  0x07, 0x80, 0x60, 0x87, 0x72, 0x98, 0x87, 0x79, 0x68, 0x03, 0x78, 0x90,
-  0x87, 0x72, 0x18, 0x87, 0x74, 0x98, 0x87, 0x72, 0x68, 0x03, 0x73, 0x80,
-  0x87, 0x76, 0x08, 0x07, 0x72, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e,
-  0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c,
-  0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e,
-  0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0x01, 0xa0,
-  0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x06, 0x77, 0x78, 0x87, 0x36, 0x30,
-  0x07, 0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77, 0x48,
-  0x07, 0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76, 0x48,
-  0x87, 0x76, 0x68, 0x03, 0x77, 0x78, 0x07, 0x77, 0x68, 0x03, 0x76, 0x28,
-  0x87, 0x70, 0x30, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x74, 0x70,
-  0x07, 0x73, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08,
-  0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20,
-  0xdc, 0xe1, 0x1d, 0xda, 0x40, 0x1d, 0xea, 0xa1, 0x1d, 0xe0, 0xa1, 0x0d,
-  0xe8, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x1e, 0x00, 0x73, 0x08,
-  0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x70,
-  0x87, 0x70, 0x70, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68,
-  0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c,
-  0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xce, 0xc1, 0x1d,
-  0xca, 0x81, 0x1c, 0xda, 0x40, 0x1f, 0xca, 0x41, 0x1e, 0xde, 0x61, 0x1e,
-  0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d,
-  0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68,
-  0x03, 0x7a, 0x90, 0x87, 0x70, 0x80, 0x07, 0x78, 0x48, 0x07, 0x77, 0x38,
-  0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e,
-  0xea, 0xa1, 0x1c, 0x00, 0x62, 0x1e, 0xe8, 0x21, 0x1c, 0xc6, 0x61, 0x1d,
-  0xda, 0x00, 0x1e, 0xe4, 0xe1, 0x1d, 0xe8, 0xa1, 0x1c, 0xc6, 0x81, 0x1e,
-  0xde, 0x41, 0x1e, 0xda, 0x40, 0x1c, 0xea, 0xc1, 0x1c, 0xcc, 0xa1, 0x1c,
-  0xe4, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xf4, 0xa1, 0x1c, 0x00, 0x3c, 0x00,
-  0x88, 0x7a, 0x70, 0x87, 0x79, 0x08, 0x07, 0x73, 0x28, 0x87, 0x36, 0x30,
+  0x45, 0x4e, 0x44, 0x54, 0x29, 0x00, 0x00, 0x00, 0x56, 0x41, 0x54, 0x54,
+  0x15, 0x00, 0x02, 0x00, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e,
+  0x00, 0x00, 0x80, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x00, 0x01, 0x80, 0x56,
+  0x41, 0x54, 0x59, 0x04, 0x00, 0x02, 0x00, 0x04, 0x06, 0x45, 0x4e, 0x44,
+  0x54, 0x35, 0x00, 0x00, 0x00, 0x56, 0x41, 0x54, 0x54, 0x20, 0x00, 0x03,
+  0x00, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x80,
+  0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x00, 0x01, 0x80, 0x74, 0x65, 0x78, 0x63,
+  0x6f, 0x6f, 0x72, 0x64, 0x00, 0x02, 0x80, 0x56, 0x41, 0x54, 0x59, 0x05,
+  0x00, 0x03, 0x00, 0x04, 0x06, 0x04, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00,
+  0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e,
+  0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00,
+  0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e,
+  0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00,
+  0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e,
+  0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00,
+  0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e,
+  0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0xde, 0xc0,
+  0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0xa4, 0x0b,
+  0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c,
+  0x00, 0x00, 0xe6, 0x02, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00,
+  0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8,
+  0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05,
+  0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92,
+  0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32,
+  0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19,
+  0x21, 0x72, 0x24, 0x07, 0xc8, 0x48, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40,
+  0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00, 0x00, 0x83, 0x00,
+  0x00, 0x00, 0x1b, 0xc8, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90,
+  0x80, 0x8a, 0x18, 0x87, 0x77, 0x90, 0x07, 0x79, 0x28, 0x87, 0x71, 0xa0,
+  0x07, 0x76, 0xc8, 0x87, 0x36, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x77, 0x20,
+  0x87, 0x72, 0x20, 0x87, 0x36, 0x20, 0x87, 0x74, 0xb0, 0x87, 0x74, 0x20,
+  0x87, 0x72, 0x68, 0x83, 0x79, 0x88, 0x07, 0x79, 0xa0, 0x87, 0x36, 0x30,
+  0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0xc0, 0x1c,
+  0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1c, 0xd2, 0x61, 0x1e,
+  0xc2, 0x41, 0x1c, 0xd8, 0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xc2, 0x21, 0x1d,
+  0xd8, 0xa1, 0x0d, 0xc6, 0x21, 0x1c, 0xd8, 0x81, 0x1d, 0xe6, 0x01, 0x30,
+  0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x60, 0x87, 0x72, 0x98,
+  0x87, 0x79, 0x68, 0x03, 0x78, 0x90, 0x87, 0x72, 0x18, 0x87, 0x74, 0x98,
+  0x87, 0x72, 0x68, 0x03, 0x73, 0x80, 0x87, 0x76, 0x08, 0x07, 0x72, 0x00,
+  0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e,
+  0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c,
+  0xd8, 0x21, 0x1d, 0xda, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00,
+  0x06, 0x77, 0x78, 0x87, 0x36, 0x30, 0x07, 0x79, 0x08, 0x87, 0x76, 0x28,
+  0x87, 0x36, 0x80, 0x87, 0x77, 0x48, 0x07, 0x77, 0xa0, 0x87, 0x72, 0x90,
+  0x87, 0x36, 0x28, 0x07, 0x76, 0x48, 0x87, 0x76, 0x68, 0x03, 0x77, 0x78,
+  0x07, 0x77, 0x68, 0x03, 0x76, 0x28, 0x87, 0x70, 0x30, 0x07, 0x80, 0x70,
+  0x87, 0x77, 0x68, 0x83, 0x74, 0x70, 0x07, 0x73, 0x98, 0x87, 0x36, 0x30,
   0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e,
-  0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xea, 0x61, 0x1e, 0xca, 0xa1, 0x0d,
-  0xe6, 0xe1, 0x1d, 0xcc, 0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xd8, 0xe1, 0x1d,
-  0xc2, 0x81, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00,
-  0x36, 0x18, 0x82, 0x00, 0x2c, 0x40, 0xb5, 0xc1, 0x18, 0x06, 0x60, 0x01,
-  0x2a, 0x00, 0x00, 0x00, 0x49, 0x18, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
-  0x13, 0x86, 0x40, 0x18, 0x00, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00,
-  0x1b, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04,
-  0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14,
-  0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x40, 0x33, 0x00,
-  0xc3, 0x08, 0x04, 0x60, 0x85, 0x00, 0x86, 0x11, 0x04, 0x20, 0x09, 0xc2,
-  0x4c, 0xd4, 0x3c, 0xd0, 0x83, 0x3c, 0xd4, 0xc3, 0x38, 0xd0, 0x83, 0x1b,
-  0xb4, 0x43, 0x39, 0xd0, 0x43, 0x38, 0xb0, 0x83, 0x1e, 0xe8, 0x41, 0x3b,
-  0x84, 0x03, 0x3d, 0xc8, 0x43, 0x3a, 0xe0, 0x03, 0x0a, 0xc8, 0x20, 0x42,
-  0x21, 0x14, 0x42, 0x0c, 0x63, 0xe8, 0x0c, 0x04, 0xcc, 0x11, 0x80, 0x41,
-  0x0a, 0xa8, 0x39, 0x02, 0x50, 0x18, 0x44, 0x08, 0x84, 0x61, 0x04, 0x42,
-  0x19, 0x01, 0x00, 0x00, 0x13, 0xb2, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03,
-  0x3a, 0x68, 0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83,
-  0x76, 0x08, 0x87, 0x71, 0x78, 0x87, 0x79, 0xc0, 0x87, 0x38, 0x80, 0x03,
-  0x37, 0x88, 0x83, 0x38, 0x70, 0x03, 0x38, 0xd8, 0x70, 0x1b, 0xe5, 0xd0,
-  0x06, 0xf0, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0,
-  0x07, 0x76, 0x40, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0,
-  0x07, 0x78, 0xd0, 0x06, 0xe9, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80,
-  0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0,
-  0x07, 0x71, 0x60, 0x07, 0x6d, 0x90, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30,
-  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40,
-  0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60,
-  0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20,
-  0x07, 0x6d, 0x60, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0,
-  0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10,
-  0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40,
-  0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60,
-  0x0f, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20,
-  0x07, 0x6d, 0x60, 0x0f, 0x74, 0x80, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0,
-  0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60,
-  0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60,
-  0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80,
-  0x07, 0x6d, 0x60, 0x0f, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20,
-  0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10,
-  0x07, 0x79, 0x20, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20,
-  0x07, 0x75, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0,
-  0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0,
-  0x06, 0xf6, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20,
-  0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00,
-  0x07, 0x72, 0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0,
-  0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0,
-  0x07, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0x30, 0x84, 0x41, 0x00,
-  0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc8, 0x02, 0x01, 0x00, 0x00,
-  0x0a, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90,
-  0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x52, 0x25, 0x30, 0x02, 0x50,
-  0x80, 0x01, 0x45, 0x50, 0x20, 0x85, 0x50, 0x10, 0x65, 0x40, 0x6c, 0x04,
-  0x80, 0xd6, 0x58, 0xc2, 0x02, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00,
-  0xcf, 0x00, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25,
-  0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x86, 0x42, 0x24,
-  0xc0, 0xa2, 0x50, 0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3,
-  0x2b, 0x1b, 0x62, 0x28, 0x41, 0x22, 0x28, 0x06, 0xe1, 0x20, 0x08, 0x0e,
-  0x8e, 0xad, 0x0c, 0x84, 0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e,
-  0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x26, 0x06, 0x06, 0x26, 0xc6, 0x25, 0x86,
-  0x66, 0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65,
-  0x26, 0x06, 0x06, 0x26, 0xc6, 0x25, 0x86, 0x66, 0x26, 0x65, 0x88, 0x90,
-  0x10, 0x43, 0x0c, 0x25, 0x50, 0x0e, 0x45, 0x60, 0xd1, 0x54, 0x46, 0x17,
+  0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x40, 0x1d,
+  0xea, 0xa1, 0x1d, 0xe0, 0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xc4, 0x81, 0x1d,
+  0xca, 0x61, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00,
+  0x08, 0x77, 0x78, 0x87, 0x36, 0x70, 0x87, 0x70, 0x70, 0x87, 0x79, 0x68,
+  0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00,
+  0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d,
+  0xe6, 0x21, 0x1d, 0xce, 0xc1, 0x1d, 0xca, 0x81, 0x1c, 0xda, 0x40, 0x1f,
+  0xca, 0x41, 0x1e, 0xde, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d,
+  0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28,
+  0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x7a, 0x90, 0x87, 0x70, 0x80,
+  0x07, 0x78, 0x48, 0x07, 0x77, 0x38, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0,
+  0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0x62, 0x1e,
+  0xe8, 0x21, 0x1c, 0xc6, 0x61, 0x1d, 0xda, 0x00, 0x1e, 0xe4, 0xe1, 0x1d,
+  0xe8, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0x40, 0x1c,
+  0xea, 0xc1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xe6, 0x21, 0x1d,
+  0xf4, 0xa1, 0x1c, 0x00, 0x3c, 0x00, 0x88, 0x7a, 0x70, 0x87, 0x79, 0x08,
+  0x07, 0x73, 0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08,
+  0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20,
+  0xea, 0x61, 0x1e, 0xca, 0xa1, 0x0d, 0xe6, 0xe1, 0x1d, 0xcc, 0x81, 0x1e,
+  0xda, 0xc0, 0x1c, 0xd8, 0xe1, 0x1d, 0xc2, 0x81, 0x1e, 0x00, 0x73, 0x08,
+  0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x36, 0x18, 0xc2, 0x00, 0x2c, 0x40,
+  0xb5, 0xc1, 0x18, 0x08, 0x60, 0x01, 0x2a, 0x00, 0x00, 0x00, 0x49, 0x18,
+  0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x86, 0x40, 0x18, 0x00, 0x00,
+  0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x32, 0x22,
+  0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93,
+  0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84,
+  0xa4, 0x4c, 0x10, 0x40, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x60, 0x87, 0x10,
+  0xc0, 0x30, 0x82, 0x00, 0x24, 0x41, 0x98, 0x89, 0x9a, 0x07, 0x7a, 0x90,
+  0x87, 0x7a, 0x18, 0x07, 0x7a, 0x70, 0x83, 0x76, 0x28, 0x07, 0x7a, 0x08,
+  0x07, 0x76, 0xd0, 0x03, 0x3d, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x79, 0x48,
+  0x07, 0x7c, 0x40, 0x01, 0x19, 0x44, 0x28, 0x84, 0x52, 0x88, 0x11, 0x8c,
+  0xa1, 0x33, 0x10, 0x30, 0x47, 0x00, 0x06, 0x29, 0xa0, 0xe6, 0x08, 0x40,
+  0x61, 0x10, 0x21, 0x10, 0x86, 0x11, 0x08, 0x65, 0x04, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x13, 0xb2, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68,
+  0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x76, 0x08,
+  0x87, 0x71, 0x78, 0x87, 0x79, 0xc0, 0x87, 0x38, 0x80, 0x03, 0x37, 0x88,
+  0x83, 0x38, 0x70, 0x03, 0x38, 0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06, 0xf0,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78,
+  0xd0, 0x06, 0xe9, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d,
+  0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71,
+  0x60, 0x07, 0x6d, 0x90, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72,
+  0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a,
+  0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e, 0x73,
+  0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d,
+  0x60, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76,
+  0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07, 0x7a,
+  0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x73,
+  0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d,
+  0x60, 0x0f, 0x74, 0x80, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x6d, 0x60, 0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07, 0x7a,
+  0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d,
+  0x60, 0x0f, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78,
+  0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x79,
+  0x20, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75,
+  0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72,
+  0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6,
+  0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a,
+  0x50, 0x07, 0x71, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07, 0x72,
+  0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71,
+  0x00, 0x07, 0x72, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71,
+  0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0x30, 0x84, 0x41, 0x00, 0x00, 0x08,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xc8, 0x02, 0x01, 0x00, 0x00, 0x0a, 0x00,
+  0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09,
+  0x26, 0x47, 0xc6, 0x04, 0x43, 0x52, 0x25, 0x30, 0x02, 0x50, 0x80, 0x01,
+  0x45, 0x50, 0x20, 0x65, 0x50, 0x08, 0x05, 0x41, 0x6c, 0x04, 0x80, 0xd6,
+  0x58, 0xc2, 0x12, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0xe4, 0x00,
+  0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab,
+  0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x86, 0x42, 0x24, 0xc0, 0xa2,
+  0x50, 0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b,
+  0x62, 0x28, 0x41, 0x22, 0x28, 0x07, 0xe5, 0x20, 0x08, 0x0e, 0x8e, 0xad,
+  0x0c, 0x84, 0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed,
+  0xcd, 0x0d, 0x64, 0x26, 0x06, 0x06, 0x26, 0xc6, 0x25, 0xc6, 0x06, 0x06,
+  0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26, 0x06,
+  0x06, 0x26, 0xc6, 0x25, 0xc6, 0x06, 0xc6, 0x25, 0x26, 0x65, 0x88, 0x90,
+  0x10, 0x43, 0x0c, 0x25, 0x50, 0x10, 0x45, 0x60, 0xd1, 0x54, 0x46, 0x17,
   0xc6, 0x36, 0x04, 0x49, 0x0e, 0x25, 0x50, 0x02, 0x45, 0xe0, 0x16, 0x96,
   0x26, 0xe7, 0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56,
   0xe6, 0xf6, 0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96, 0x36, 0x17, 0x26, 0xc6,
@@ -217,235 +219,243 @@ const unsigned char sdl_metallib[] = {
   0xb0, 0xb6, 0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x64, 0xc2,
   0xd2, 0xe4, 0x5c, 0xc2, 0xe4, 0xce, 0xbe, 0xdc, 0xc2, 0xda, 0xca, 0x88,
   0xc0, 0xbd, 0xcd, 0xa5, 0xd1, 0xa5, 0xbd, 0xb9, 0x0d, 0x51, 0x92, 0x27,
-  0x81, 0x92, 0x28, 0x91, 0x92, 0x89, 0x4e, 0x58, 0x9a, 0x9c, 0x0b, 0xdc,
-  0x5b, 0x9a, 0x1b, 0xdd, 0xd7, 0x5c, 0x9a, 0x5e, 0x19, 0x0b, 0x33, 0xb6,
-  0xb7, 0x30, 0x3a, 0x26, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x53, 0x69, 0x7a,
-  0x65, 0x43, 0x94, 0xa4, 0x4a, 0xa0, 0xc4, 0x4a, 0xa4, 0xe4, 0x1a, 0x42,
-  0x24, 0x54, 0x82, 0x11, 0x0a, 0x4b, 0x93, 0x73, 0xb1, 0x2b, 0x93, 0xa3,
-  0x2b, 0xc3, 0xfb, 0x4a, 0x73, 0x83, 0xab, 0xa3, 0xa3, 0x14, 0x96, 0x26,
-  0xe7, 0xc2, 0xf6, 0x36, 0x16, 0x46, 0x97, 0xf6, 0xe6, 0xf6, 0x95, 0xe6,
-  0x46, 0x56, 0x86, 0x47, 0xef, 0xac, 0xcc, 0xad, 0x4c, 0x2e, 0x8c, 0xae,
-  0x8c, 0x0c, 0xe5, 0xeb, 0x2b, 0x2c, 0x4d, 0xee, 0x0b, 0x8e, 0x2d, 0x6c,
-  0xac, 0x0c, 0xed, 0x8d, 0x8d, 0xac, 0x4c, 0xee, 0xeb, 0x2b, 0x85, 0x86,
-  0x19, 0xdb, 0x5b, 0x18, 0x9d, 0xcc, 0x10, 0x4a, 0x11, 0x12, 0x2d, 0xd9,
-  0x14, 0x41, 0x09, 0x12, 0x2e, 0x81, 0x92, 0x2e, 0x91, 0x92, 0x89, 0x4a,
-  0x58, 0x9a, 0x9c, 0x8b, 0x58, 0x9d, 0x99, 0x59, 0x99, 0x1c, 0x9f, 0xb0,
-  0x34, 0x39, 0x17, 0xb1, 0x3a, 0x33, 0xb3, 0x32, 0xb9, 0xaf, 0xb9, 0x34,
-  0xbd, 0x32, 0x22, 0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x61, 0x64, 0x8c,
-  0xc2, 0xd2, 0xe4, 0x5c, 0xc2, 0xe4, 0xce, 0xbe, 0xe8, 0xf2, 0xe0, 0xca,
-  0xbe, 0xe6, 0xd2, 0xf4, 0xca, 0x78, 0x85, 0xa5, 0xc9, 0xb9, 0x84, 0xc9,
-  0x9d, 0x7d, 0xd1, 0xe5, 0xc1, 0x95, 0x7d, 0x85, 0xb1, 0xa5, 0x9d, 0xb9,
-  0x7d, 0xcd, 0xa5, 0xe9, 0x95, 0x11, 0x31, 0x63, 0x7b, 0x0b, 0xa3, 0xa3,
-  0xc1, 0xa3, 0xa1, 0x02, 0x27, 0xf7, 0xa6, 0x56, 0x36, 0x46, 0x97, 0xf6,
-  0xe6, 0x36, 0x04, 0x0c, 0x94, 0x20, 0xf9, 0x12, 0x30, 0x50, 0x86, 0x64,
-  0x53, 0x08, 0x25, 0x48, 0xc2, 0x20, 0x11, 0x03, 0x65, 0x48, 0xc6, 0x40,
-  0x29, 0x12, 0x28, 0x21, 0x83, 0x44, 0x4a, 0xca, 0x80, 0x09, 0x9d, 0x5c,
-  0x98, 0xdb, 0x9c, 0xd9, 0x9b, 0x5c, 0xdb, 0x10, 0x30, 0x50, 0x88, 0xe4,
-  0x4b, 0xc0, 0x40, 0x19, 0x92, 0x4d, 0x41, 0x94, 0x20, 0x09, 0x83, 0x44,
-  0x0c, 0x94, 0x21, 0x19, 0x03, 0xa5, 0x48, 0xa0, 0x84, 0x0c, 0x12, 0x29,
-  0x39, 0x83, 0x21, 0x46, 0xe2, 0x25, 0x66, 0x90, 0xa0, 0xc1, 0x10, 0x03,
-  0x01, 0x92, 0x2c, 0x49, 0x03, 0x3e, 0x6f, 0x6d, 0x6e, 0x69, 0x70, 0x6f,
-  0x74, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x68, 0x61, 0x72, 0x7c, 0xa6, 0xd2,
-  0xda, 0xe0, 0xd8, 0xca, 0x40, 0x86, 0x56, 0x56, 0x40, 0xa8, 0x84, 0x82,
-  0x82, 0x86, 0x08, 0x09, 0x1b, 0x0c, 0x31, 0x92, 0x35, 0x48, 0xda, 0x80,
-  0x49, 0x86, 0x18, 0x89, 0x1b, 0x24, 0x6e, 0xc0, 0x24, 0x23, 0x22, 0x76,
-  0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x77, 0x20, 0x87, 0x7a,
-  0x60, 0x87, 0x72, 0x70, 0x03, 0x73, 0x60, 0x87, 0x70, 0x38, 0x87, 0x79,
-  0x98, 0x22, 0x04, 0xc3, 0x08, 0x85, 0x1d, 0xd8, 0xc1, 0x1e, 0xda, 0xc1,
-  0x0d, 0xd2, 0x81, 0x1c, 0xca, 0xc1, 0x1d, 0xe8, 0x61, 0x4a, 0x50, 0x8c,
-  0x58, 0xc2, 0x21, 0x1d, 0xe4, 0xc1, 0x0d, 0xec, 0xa1, 0x1c, 0xe4, 0x61,
-  0x1e, 0xd2, 0xe1, 0x1d, 0xdc, 0x61, 0x4a, 0x60, 0x8c, 0xa0, 0xc2, 0x21,
-  0x1d, 0xe4, 0xc1, 0x0d, 0xd8, 0x21, 0x1c, 0xdc, 0xe1, 0x1c, 0xea, 0x21,
-  0x1c, 0xce, 0xa1, 0x1c, 0x7e, 0xc1, 0x1e, 0xca, 0x41, 0x1e, 0xe6, 0x21,
-  0x1d, 0xde, 0xc1, 0x1d, 0xa6, 0x04, 0xc8, 0x88, 0x29, 0x1c, 0xd2, 0x41,
-  0x1e, 0xdc, 0x60, 0x1c, 0xde, 0xa1, 0x1d, 0xe0, 0x21, 0x1d, 0xd8, 0xa1,
-  0x1c, 0x7e, 0xe1, 0x1d, 0xe0, 0x81, 0x1e, 0xd2, 0xe1, 0x1d, 0xdc, 0x61,
-  0x1e, 0xa6, 0x0c, 0x0a, 0xe3, 0x8c, 0x50, 0xc2, 0x21, 0x1d, 0xe4, 0xc1,
-  0x0d, 0xec, 0xa1, 0x1c, 0xe4, 0x81, 0x1e, 0xca, 0x01, 0x1f, 0xa6, 0x04,
-  0x6a, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00,
-  0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88,
-  0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73,
-  0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e,
-  0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30,
-  0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8,
-  0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b,
-  0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76,
-  0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e,
-  0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e,
-  0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61,
-  0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4,
-  0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76,
-  0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37,
-  0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76,
-  0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71,
-  0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e,
-  0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1,
-  0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61,
-  0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90,
-  0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8,
-  0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc,
-  0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7,
-  0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78,
-  0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f,
-  0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f,
-  0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1,
-  0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0,
-  0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0,
-  0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b,
-  0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c,
-  0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61,
-  0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1,
-  0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc,
-  0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4,
-  0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79,
-  0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72,
-  0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e,
-  0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1,
-  0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8,
-  0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8,
-  0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00,
-  0x71, 0x20, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06, 0x00, 0xb1, 0x5d,
-  0xf9, 0xb3, 0xce, 0x82, 0x0c, 0x7f, 0x45, 0x44, 0x13, 0x71, 0x01, 0x00,
-  0x61, 0x20, 0x00, 0x00, 0x52, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c,
-  0x10, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0xe4, 0xc6, 0x22, 0x86,
-  0x61, 0x18, 0xc6, 0x22, 0x04, 0x41, 0x10, 0xc6, 0x22, 0x82, 0x20, 0x08,
-  0x46, 0x00, 0x88, 0x95, 0x40, 0x19, 0x14, 0x01, 0x8d, 0x19, 0x00, 0x12,
-  0x33, 0x00, 0x14, 0x66, 0x00, 0x08, 0x8c, 0x11, 0x80, 0x20, 0x08, 0xe2,
-  0x1f, 0x00, 0x00, 0x00, 0xe3, 0x11, 0x0c, 0x74, 0x41, 0x14, 0x94, 0xf1,
-  0x88, 0x47, 0xca, 0x24, 0x0a, 0xca, 0x20, 0xc3, 0x60, 0x30, 0x26, 0x04,
-  0xf2, 0x19, 0x8f, 0x98, 0xac, 0xae, 0xa1, 0xa0, 0x0c, 0x32, 0x1c, 0x4a,
-  0x64, 0x42, 0x20, 0x1f, 0x0b, 0x0a, 0xf8, 0x8c, 0x47, 0x60, 0x9b, 0x18,
-  0x40, 0x14, 0x94, 0x41, 0x06, 0xe6, 0xb9, 0x4c, 0x08, 0xe4, 0x63, 0x45,
-  0x00, 0x9f, 0xf1, 0x88, 0x0e, 0x0c, 0xce, 0xc0, 0xa2, 0xa0, 0x0c, 0x32,
-  0x44, 0x54, 0x67, 0x42, 0x20, 0x1f, 0x2b, 0x02, 0xf8, 0x8c, 0x47, 0x84,
-  0x41, 0x19, 0xb0, 0x01, 0x47, 0x41, 0x19, 0x64, 0x08, 0xb2, 0xcf, 0x82,
-  0x4a, 0x3e, 0x83, 0x0c, 0xc3, 0x26, 0x06, 0x16, 0x4c, 0xf2, 0xb1, 0x21,
-  0x80, 0xcf, 0x20, 0x83, 0xe1, 0x99, 0x81, 0x05, 0x91, 0x7c, 0x6c, 0x08,
-  0xe0, 0x33, 0xc8, 0x90, 0x84, 0x81, 0x1a, 0x58, 0xf0, 0xc8, 0xc7, 0x86,
-  0x00, 0x3e, 0xe3, 0x11, 0x6e, 0x20, 0x07, 0x79, 0x80, 0x06, 0x14, 0x94,
-  0x41, 0x86, 0xc0, 0x0c, 0xd8, 0xc0, 0x02, 0x31, 0x90, 0xcf, 0x20, 0xc3,
-  0x80, 0x06, 0x6f, 0x60, 0x01, 0x18, 0xc8, 0x67, 0x90, 0xa1, 0x50, 0x03,
-  0x39, 0xb0, 0xa0, 0x93, 0xcf, 0x20, 0xc3, 0xc1, 0x06, 0x75, 0x60, 0x81,
-  0x26, 0x9f, 0x41, 0x06, 0x3d, 0x80, 0x03, 0x3a, 0xb0, 0x2c, 0x90, 0xcf,
-  0x20, 0x03, 0x1f, 0xc8, 0xc1, 0x1d, 0x98, 0x13, 0xc8, 0xc7, 0x92, 0x01,
-  0x3e, 0x16, 0x30, 0xf0, 0xb1, 0x20, 0x81, 0x8f, 0x05, 0x08, 0x7c, 0x2c,
-  0x28, 0xe0, 0x33, 0xdb, 0x80, 0x07, 0x01, 0x30, 0xdb, 0x10, 0xdc, 0x41,
-  0x90, 0x41, 0x40, 0x0c, 0x09, 0x00, 0x00, 0x00, 0x5b, 0x86, 0x20, 0x78,
-  0x83, 0x2d, 0xc3, 0x10, 0xbc, 0xc1, 0x96, 0xe1, 0x08, 0xde, 0x60, 0xcb,
-  0xc0, 0x04, 0x6f, 0xb0, 0x65, 0x88, 0x82, 0x37, 0xd8, 0x32, 0x58, 0xc1,
-  0x1b, 0x6c, 0x19, 0xc6, 0x20, 0x78, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
-  0x68, 0x0b, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde,
-  0x21, 0x0c, 0x00, 0x00, 0xd7, 0x02, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00,
-  0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91,
-  0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c,
-  0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02,
-  0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x49,
-  0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52, 0x80,
-  0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8, 0x48, 0x11, 0x62, 0xa8, 0xa0,
-  0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00, 0x00,
-  0x83, 0x00, 0x00, 0x00, 0x1b, 0xc8, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff,
-  0x01, 0x90, 0x80, 0x8a, 0x18, 0x87, 0x77, 0x90, 0x07, 0x79, 0x28, 0x87,
-  0x71, 0xa0, 0x07, 0x76, 0xc8, 0x87, 0x36, 0x90, 0x87, 0x77, 0xa8, 0x07,
-  0x77, 0x20, 0x87, 0x72, 0x20, 0x87, 0x36, 0x20, 0x87, 0x74, 0xb0, 0x87,
-  0x74, 0x20, 0x87, 0x72, 0x68, 0x83, 0x79, 0x88, 0x07, 0x79, 0xa0, 0x87,
-  0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07,
-  0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1c, 0xd2,
-  0x61, 0x1e, 0xc2, 0x41, 0x1c, 0xd8, 0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xc2,
-  0x21, 0x1d, 0xd8, 0xa1, 0x0d, 0xc6, 0x21, 0x1c, 0xd8, 0x81, 0x1d, 0xe6,
-  0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x60, 0x87,
-  0x72, 0x98, 0x87, 0x79, 0x68, 0x03, 0x78, 0x90, 0x87, 0x72, 0x18, 0x87,
-  0x74, 0x98, 0x87, 0x72, 0x68, 0x03, 0x73, 0x80, 0x87, 0x76, 0x08, 0x07,
-  0x72, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc,
-  0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda,
-  0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda,
-  0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87,
-  0x72, 0x00, 0x06, 0x77, 0x78, 0x87, 0x36, 0x30, 0x07, 0x79, 0x08, 0x87,
-  0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77, 0x48, 0x07, 0x77, 0xa0, 0x87,
-  0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76, 0x48, 0x87, 0x76, 0x68, 0x03,
-  0x77, 0x78, 0x07, 0x77, 0x68, 0x03, 0x76, 0x28, 0x87, 0x70, 0x30, 0x07,
-  0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x74, 0x70, 0x07, 0x73, 0x98, 0x87,
-  0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07,
-  0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda,
-  0x40, 0x1d, 0xea, 0xa1, 0x1d, 0xe0, 0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xc4,
-  0x81, 0x1d, 0xca, 0x61, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87,
-  0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x70, 0x87, 0x70, 0x70, 0x87,
-  0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07,
-  0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde,
-  0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xce, 0xc1, 0x1d, 0xca, 0x81, 0x1c, 0xda,
-  0x40, 0x1f, 0xca, 0x41, 0x1e, 0xde, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0,
-  0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87,
-  0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x7a, 0x90, 0x87,
-  0x70, 0x80, 0x07, 0x78, 0x48, 0x07, 0x77, 0x38, 0x87, 0x36, 0x68, 0x87,
-  0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00,
-  0x62, 0x1e, 0xe8, 0x21, 0x1c, 0xc6, 0x61, 0x1d, 0xda, 0x00, 0x1e, 0xe4,
-  0xe1, 0x1d, 0xe8, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda,
-  0x40, 0x1c, 0xea, 0xc1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xe6,
-  0x21, 0x1d, 0xf4, 0xa1, 0x1c, 0x00, 0x3c, 0x00, 0x88, 0x7a, 0x70, 0x87,
-  0x79, 0x08, 0x07, 0x73, 0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83,
+  0x81, 0x92, 0x28, 0x91, 0x92, 0x89, 0x51, 0x58, 0x9a, 0x9c, 0x8b, 0x5d,
+  0x99, 0x1c, 0x5d, 0x19, 0xde, 0xd7, 0x5b, 0x1d, 0x1d, 0x5c, 0x1d, 0x1d,
+  0xad, 0xb3, 0x32, 0xb7, 0x32, 0xb9, 0x30, 0xba, 0x32, 0x32, 0x94, 0x9a,
+  0xb1, 0x37, 0xb6, 0x37, 0x39, 0x22, 0x3b, 0x9a, 0x2f, 0xb3, 0x14, 0x16,
+  0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x43, 0x98, 0xa4, 0x4a, 0xac, 0x04, 0x4a,
+  0xa2, 0x44, 0x4a, 0x2e, 0x3a, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x6f, 0x69,
+  0x6e, 0x74, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x2c, 0xcc, 0xd8, 0xde, 0xc2,
+  0xe8, 0x98, 0xc0, 0xbd, 0xa5, 0xb9, 0xd1, 0x4d, 0xa5, 0xe9, 0x95, 0x0d,
+  0x51, 0x92, 0x2c, 0x81, 0x12, 0x2d, 0x91, 0x92, 0x6d, 0x88, 0x91, 0x50,
+  0x09, 0x96, 0x70, 0x84, 0xc2, 0xd2, 0xe4, 0x5c, 0xec, 0xca, 0xe4, 0xe8,
+  0xca, 0xf0, 0xbe, 0xd2, 0xdc, 0xe0, 0xea, 0xe8, 0x28, 0x85, 0xa5, 0xc9,
+  0xb9, 0xb0, 0xbd, 0x8d, 0x85, 0xd1, 0xa5, 0xbd, 0xb9, 0x7d, 0xa5, 0xb9,
+  0x91, 0x95, 0xe1, 0xd1, 0x3b, 0x2b, 0x73, 0x2b, 0x93, 0x0b, 0xa3, 0x2b,
+  0x23, 0x43, 0xf9, 0xfa, 0x0a, 0x4b, 0x93, 0xfb, 0x82, 0x63, 0x0b, 0x1b,
+  0x2b, 0x43, 0x7b, 0x63, 0x23, 0x2b, 0x93, 0xfb, 0xfa, 0x4a, 0xa1, 0x61,
+  0xc6, 0xf6, 0x16, 0x46, 0x27, 0x33, 0x84, 0x52, 0x84, 0xc4, 0x4b, 0x3e,
+  0x45, 0x50, 0x82, 0x04, 0x0c, 0x12, 0x28, 0x09, 0x83, 0x44, 0x4a, 0xa6,
+  0x21, 0x94, 0x12, 0x24, 0x5e, 0xf2, 0x29, 0x81, 0x12, 0x24, 0x60, 0x90,
+  0x40, 0x49, 0x94, 0x48, 0xc9, 0x45, 0x25, 0x2c, 0x4d, 0xce, 0x45, 0xac,
+  0xce, 0xcc, 0xac, 0x4c, 0x8e, 0x4f, 0x58, 0x9a, 0x9c, 0x8b, 0x58, 0x9d,
+  0x99, 0x59, 0x99, 0xdc, 0xd7, 0x5c, 0x9a, 0x5e, 0x19, 0x91, 0xb0, 0x34,
+  0x39, 0x17, 0xb9, 0xb2, 0x30, 0x32, 0x46, 0x61, 0x69, 0x72, 0x2e, 0x61,
+  0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65,
+  0xbc, 0xc2, 0xd2, 0xe4, 0x5c, 0xc2, 0xe4, 0xce, 0xbe, 0xe8, 0xf2, 0xe0,
+  0xca, 0xbe, 0xc2, 0xd8, 0xd2, 0xce, 0xdc, 0xbe, 0xe6, 0xd2, 0xf4, 0xca,
+  0x88, 0x98, 0xb1, 0xbd, 0x85, 0xd1, 0xd1, 0xe0, 0xd1, 0x50, 0x81, 0x93,
+  0x7b, 0x53, 0x2b, 0x1b, 0xa3, 0x4b, 0x7b, 0x73, 0x1b, 0x02, 0x06, 0x0a,
+  0x91, 0x90, 0x41, 0x52, 0x06, 0xca, 0x90, 0x7c, 0x0a, 0xa1, 0x04, 0x89,
+  0x19, 0x24, 0x67, 0xa0, 0x0c, 0x09, 0x1a, 0x28, 0x45, 0x02, 0x25, 0x69,
+  0x90, 0x48, 0x89, 0x1a, 0x30, 0xa1, 0x93, 0x0b, 0x73, 0x9b, 0x33, 0x7b,
+  0x93, 0x6b, 0x1b, 0x02, 0x06, 0x8a, 0x91, 0x90, 0x41, 0x52, 0x06, 0xca,
+  0x90, 0x7c, 0x8a, 0xa1, 0x04, 0x89, 0x19, 0x24, 0x67, 0xa0, 0x0c, 0x09,
+  0x1a, 0x28, 0x45, 0x02, 0x25, 0x69, 0x90, 0x48, 0x09, 0x1b, 0x0c, 0x41,
+  0x12, 0x31, 0x48, 0xc6, 0x20, 0x59, 0x83, 0xa4, 0x0d, 0x86, 0x18, 0x08,
+  0x90, 0x74, 0x89, 0x1b, 0xf0, 0x79, 0x6b, 0x73, 0x4b, 0x83, 0x7b, 0xa3,
+  0x2b, 0x73, 0xa3, 0x03, 0x19, 0x43, 0x0b, 0x93, 0xe3, 0x33, 0x95, 0xd6,
+  0x06, 0xc7, 0x56, 0x06, 0x32, 0xb4, 0xb2, 0x02, 0x42, 0x25, 0x14, 0x14,
+  0x34, 0x44, 0x48, 0xe2, 0x60, 0x88, 0x91, 0xc0, 0x41, 0x22, 0x07, 0x4c,
+  0x32, 0xc4, 0x48, 0xe6, 0x20, 0x99, 0x03, 0x26, 0x19, 0x11, 0xb1, 0x03,
+  0x3b, 0xd8, 0x43, 0x3b, 0xb8, 0x41, 0x3b, 0xbc, 0x03, 0x39, 0xd4, 0x03,
+  0x3b, 0x94, 0x83, 0x1b, 0x98, 0x03, 0x3b, 0x84, 0xc3, 0x39, 0xcc, 0xc3,
+  0x14, 0x21, 0x18, 0x46, 0x28, 0xec, 0xc0, 0x0e, 0xf6, 0xd0, 0x0e, 0x6e,
+  0x90, 0x0e, 0xe4, 0x50, 0x0e, 0xee, 0x40, 0x0f, 0x53, 0x82, 0x62, 0xc4,
+  0x12, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0x60, 0x0f, 0xe5, 0x20, 0x0f, 0xf3,
+  0x90, 0x0e, 0xef, 0xe0, 0x0e, 0x53, 0x02, 0x63, 0x04, 0x15, 0x0e, 0xe9,
+  0x20, 0x0f, 0x6e, 0xc0, 0x0e, 0xe1, 0xe0, 0x0e, 0xe7, 0x50, 0x0f, 0xe1,
+  0x70, 0x0e, 0xe5, 0xf0, 0x0b, 0xf6, 0x50, 0x0e, 0xf2, 0x30, 0x0f, 0xe9,
+  0xf0, 0x0e, 0xee, 0x30, 0x25, 0x40, 0x46, 0x4c, 0xe1, 0x90, 0x0e, 0xf2,
+  0xe0, 0x06, 0xe3, 0xf0, 0x0e, 0xed, 0x00, 0x0f, 0xe9, 0xc0, 0x0e, 0xe5,
+  0xf0, 0x0b, 0xef, 0x00, 0x0f, 0xf4, 0x90, 0x0e, 0xef, 0xe0, 0x0e, 0xf3,
+  0x30, 0x65, 0x50, 0x18, 0x67, 0x84, 0x12, 0x0e, 0xe9, 0x20, 0x0f, 0x6e,
+  0x60, 0x0f, 0xe5, 0x20, 0x0f, 0xf4, 0x50, 0x0e, 0xf8, 0x30, 0x25, 0x78,
+  0x03, 0x00, 0x79, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08,
+  0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38,
+  0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71,
+  0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c,
+  0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d,
+  0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d,
+  0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07,
+  0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87,
+  0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30,
+  0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10,
+  0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66,
+  0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c,
+  0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07,
+  0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87,
+  0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05,
+  0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87,
+  0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0,
+  0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4,
+  0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca,
+  0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39,
+  0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38,
+  0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c,
+  0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87,
+  0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87,
+  0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00,
+  0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20,
+  0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2,
+  0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4,
+  0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a,
+  0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07,
+  0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90,
+  0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8,
+  0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc,
+  0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b,
+  0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b,
+  0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87,
+  0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81,
+  0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30,
+  0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde,
+  0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39,
+  0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f,
+  0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20,
+  0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06, 0x00, 0xb1, 0x5d, 0xf9, 0xb3,
+  0xce, 0x82, 0x0c, 0x7f, 0x45, 0x44, 0x13, 0x71, 0x01, 0x00, 0x61, 0x20,
+  0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00,
+  0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0xe4, 0xc6, 0x22, 0x86, 0x61, 0x18,
+  0xc6, 0x22, 0x04, 0x41, 0x10, 0xc6, 0x22, 0x82, 0x20, 0x08, 0x46, 0x00,
+  0x88, 0x95, 0x40, 0x19, 0x14, 0x01, 0x8d, 0x19, 0x00, 0x12, 0x33, 0x00,
+  0x14, 0x66, 0x00, 0x08, 0x8c, 0x11, 0x80, 0x20, 0x08, 0xe2, 0x1f, 0x00,
+  0x00, 0x00, 0xe3, 0x11, 0x4c, 0x84, 0x45, 0x14, 0x94, 0xf1, 0x88, 0x67,
+  0xd2, 0x26, 0x0a, 0xca, 0x20, 0xc3, 0x60, 0x30, 0x26, 0x04, 0xf2, 0x19,
+  0x8f, 0x98, 0x2e, 0xaf, 0xa1, 0xa0, 0x0c, 0x32, 0x1c, 0x4a, 0x64, 0x42,
+  0x20, 0x1f, 0x0b, 0x0a, 0xf8, 0x8c, 0x47, 0x60, 0xdc, 0x18, 0x40, 0x14,
+  0x94, 0x41, 0x06, 0xe6, 0xb9, 0x4c, 0x08, 0xe4, 0x63, 0x45, 0x00, 0x9f,
+  0xf1, 0x88, 0x2e, 0x0c, 0xd0, 0xc0, 0xa2, 0xa0, 0x0c, 0x32, 0x44, 0x54,
+  0x67, 0x42, 0x20, 0x1f, 0x2b, 0x02, 0xf8, 0x8c, 0x47, 0x84, 0x81, 0x19,
+  0xb4, 0x01, 0x47, 0x41, 0x19, 0x64, 0x08, 0xb2, 0xcf, 0x82, 0x4a, 0x3e,
+  0x83, 0x0c, 0xc3, 0x26, 0x06, 0x16, 0x4c, 0xf2, 0xb1, 0x21, 0x80, 0xcf,
+  0x20, 0x83, 0xe1, 0x99, 0x81, 0x05, 0x91, 0x7c, 0x6c, 0x08, 0xe0, 0x33,
+  0xc8, 0x90, 0x84, 0x81, 0x1a, 0x58, 0xf0, 0xc8, 0xc7, 0x86, 0x00, 0x3e,
+  0xe3, 0x11, 0x6e, 0x30, 0x07, 0x7a, 0x80, 0x06, 0x14, 0x94, 0x41, 0x86,
+  0xc0, 0x0c, 0xd8, 0xc0, 0x02, 0x31, 0x90, 0xcf, 0x20, 0xc3, 0x80, 0x06,
+  0x6f, 0x60, 0x01, 0x18, 0xc8, 0x67, 0x90, 0xa1, 0x50, 0x03, 0x39, 0xb0,
+  0xa0, 0x93, 0xcf, 0x20, 0xc3, 0xc1, 0x06, 0x75, 0x60, 0x81, 0x26, 0x9f,
+  0x41, 0x86, 0x3d, 0x80, 0x03, 0x3a, 0xb0, 0x2c, 0x90, 0xcf, 0x20, 0x43,
+  0x1f, 0xc8, 0xc1, 0x1d, 0x98, 0x13, 0xc8, 0xc7, 0x92, 0x01, 0x3e, 0x16,
+  0x30, 0xf0, 0xb1, 0x20, 0x81, 0x8f, 0x05, 0x08, 0x7c, 0x2c, 0x28, 0xe0,
+  0x33, 0xdb, 0x80, 0x07, 0x01, 0x30, 0xdb, 0x10, 0x90, 0x42, 0x30, 0xdb,
+  0x10, 0xe0, 0x81, 0x90, 0x41, 0x40, 0x0c, 0x00, 0x00, 0x00, 0x09, 0x00,
+  0x00, 0x00, 0x5b, 0x86, 0x20, 0xa0, 0x83, 0x2d, 0xc3, 0x10, 0xd0, 0xc1,
+  0x96, 0xe1, 0x08, 0xe8, 0x60, 0xcb, 0xc0, 0x04, 0x74, 0xb0, 0x65, 0x88,
+  0x02, 0x3a, 0xd8, 0x32, 0x58, 0x01, 0x1d, 0x6c, 0x19, 0xc6, 0x20, 0xa0,
+  0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00,
+  0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0xb4, 0x0b, 0x00, 0x00, 0xff, 0xff,
+  0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0xea, 0x02,
+  0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00,
+  0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10,
+  0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04,
+  0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10,
+  0x32, 0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a,
+  0x90, 0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07,
+  0xc8, 0x48, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00,
+  0x00, 0x00, 0x51, 0x18, 0x00, 0x00, 0x83, 0x00, 0x00, 0x00, 0x1b, 0xc8,
+  0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x80, 0x8a, 0x18, 0x87,
+  0x77, 0x90, 0x07, 0x79, 0x28, 0x87, 0x71, 0xa0, 0x07, 0x76, 0xc8, 0x87,
+  0x36, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x77, 0x20, 0x87, 0x72, 0x20, 0x87,
+  0x36, 0x20, 0x87, 0x74, 0xb0, 0x87, 0x74, 0x20, 0x87, 0x72, 0x68, 0x83,
+  0x79, 0x88, 0x07, 0x79, 0xa0, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83,
+  0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6,
+  0xa1, 0x1c, 0x00, 0x82, 0x1c, 0xd2, 0x61, 0x1e, 0xc2, 0x41, 0x1c, 0xd8,
+  0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xc2, 0x21, 0x1d, 0xd8, 0xa1, 0x0d, 0xc6,
+  0x21, 0x1c, 0xd8, 0x81, 0x1d, 0xe6, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87,
+  0x79, 0x28, 0x07, 0x80, 0x60, 0x87, 0x72, 0x98, 0x87, 0x79, 0x68, 0x03,
+  0x78, 0x90, 0x87, 0x72, 0x18, 0x87, 0x74, 0x98, 0x87, 0x72, 0x68, 0x03,
+  0x73, 0x80, 0x87, 0x76, 0x08, 0x07, 0x72, 0x00, 0xcc, 0x21, 0x1c, 0xd8,
+  0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4,
+  0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc,
+  0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda,
+  0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x06, 0x77, 0x78, 0x87,
+  0x36, 0x30, 0x07, 0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87,
+  0x77, 0x48, 0x07, 0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07,
+  0x76, 0x48, 0x87, 0x76, 0x68, 0x03, 0x77, 0x78, 0x07, 0x77, 0x68, 0x03,
+  0x76, 0x28, 0x87, 0x70, 0x30, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83,
+  0x74, 0x70, 0x07, 0x73, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83,
   0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca,
-  0x01, 0x20, 0xea, 0x61, 0x1e, 0xca, 0xa1, 0x0d, 0xe6, 0xe1, 0x1d, 0xcc,
-  0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xd8, 0xe1, 0x1d, 0xc2, 0x81, 0x1e, 0x00,
-  0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x36, 0x18, 0xc2, 0x00,
-  0x2c, 0x40, 0xb5, 0xc1, 0x18, 0x08, 0x60, 0x01, 0x2a, 0x00, 0x00, 0x00,
-  0x49, 0x18, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x86, 0x40, 0x18,
-  0x00, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00,
-  0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84,
-  0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c,
-  0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x40, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30,
-  0x8c, 0x20, 0x00, 0x56, 0x08, 0x22, 0x09, 0xc2, 0x4c, 0xd4, 0x3c, 0xd0,
-  0x83, 0x3c, 0xd4, 0xc3, 0x38, 0xd0, 0x83, 0x1b, 0xb4, 0x43, 0x39, 0xd0,
-  0x43, 0x38, 0xb0, 0x83, 0x1e, 0xe8, 0x41, 0x3b, 0x84, 0x03, 0x3d, 0xc8,
-  0x43, 0x3a, 0xe0, 0x03, 0x0a, 0xc8, 0x20, 0x42, 0x21, 0x94, 0x62, 0x08,
-  0x61, 0x0c, 0x9d, 0x81, 0x80, 0x39, 0x02, 0x30, 0x48, 0x01, 0x35, 0x47,
-  0x00, 0x0a, 0x83, 0x08, 0x81, 0x30, 0x8c, 0x40, 0x28, 0x23, 0x00, 0x00,
-  0x13, 0xb2, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70,
-  0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x76, 0x08, 0x87, 0x71,
-  0x78, 0x87, 0x79, 0xc0, 0x87, 0x38, 0x80, 0x03, 0x37, 0x88, 0x83, 0x38,
-  0x70, 0x03, 0x38, 0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06, 0xf0, 0xa0, 0x07,
-  0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0, 0x06,
-  0xe9, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e,
-  0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07,
-  0x6d, 0x90, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07,
-  0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07,
-  0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07,
-  0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e,
-  0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x6d, 0x60, 0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07,
-  0x71, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07, 0x7a, 0x30, 0x07,
-  0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x73, 0x20, 0x07,
-  0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f,
-  0x74, 0x80, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x6d, 0x60, 0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07,
-  0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07, 0x7a, 0x10, 0x07,
-  0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f,
-  0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07,
-  0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x79, 0x20, 0x07,
-  0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07,
-  0x6d, 0x60, 0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07,
-  0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x50, 0x07,
-  0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07,
-  0x71, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07,
-  0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07,
-  0x72, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60, 0x07,
-  0x7a, 0x30, 0x07, 0x72, 0x30, 0x84, 0x41, 0x00, 0x00, 0x08, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0xc8, 0x02, 0x01, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
-  0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47,
-  0xc6, 0x04, 0x43, 0x52, 0x25, 0x30, 0x02, 0x50, 0x80, 0x01, 0x45, 0x50,
-  0x20, 0x65, 0x50, 0x08, 0x05, 0x41, 0x6c, 0x04, 0x80, 0xd6, 0x58, 0xc2,
-  0x02, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0xda, 0x00, 0x00, 0x00,
-  0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9,
-  0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x86, 0x42, 0x24, 0xc0, 0xa2, 0x50, 0xb9,
-  0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b, 0x62, 0x28,
-  0x41, 0x22, 0x28, 0x07, 0xe1, 0x20, 0x08, 0x0e, 0x8e, 0xad, 0x0c, 0x84,
-  0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x0d,
-  0x64, 0x26, 0x06, 0x06, 0x26, 0xc6, 0x25, 0x86, 0x66, 0x06, 0x04, 0xa5,
-  0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26, 0x06, 0x06, 0x26,
-  0xc6, 0x25, 0x86, 0x66, 0x26, 0x65, 0x88, 0x90, 0x10, 0x43, 0x0c, 0x25,
-  0x50, 0x10, 0x45, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36, 0x04, 0x49,
-  0x0e, 0x25, 0x50, 0x02, 0x45, 0xe0, 0x16, 0x96, 0x26, 0xe7, 0x32, 0xf6,
+  0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x40, 0x1d, 0xea, 0xa1, 0x1d, 0xe0,
+  0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x1e, 0x00,
+  0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87,
+  0x36, 0x70, 0x87, 0x70, 0x70, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87,
+  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea,
+  0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xce,
+  0xc1, 0x1d, 0xca, 0x81, 0x1c, 0xda, 0x40, 0x1f, 0xca, 0x41, 0x1e, 0xde,
+  0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8,
+  0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87,
+  0x77, 0x68, 0x03, 0x7a, 0x90, 0x87, 0x70, 0x80, 0x07, 0x78, 0x48, 0x07,
+  0x77, 0x38, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8,
+  0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0x62, 0x1e, 0xe8, 0x21, 0x1c, 0xc6,
+  0x61, 0x1d, 0xda, 0x00, 0x1e, 0xe4, 0xe1, 0x1d, 0xe8, 0xa1, 0x1c, 0xc6,
+  0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0x40, 0x1c, 0xea, 0xc1, 0x1c, 0xcc,
+  0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xf4, 0xa1, 0x1c, 0x00,
+  0x3c, 0x00, 0x88, 0x7a, 0x70, 0x87, 0x79, 0x08, 0x07, 0x73, 0x28, 0x87,
+  0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07,
+  0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xea, 0x61, 0x1e, 0xca,
+  0xa1, 0x0d, 0xe6, 0xe1, 0x1d, 0xcc, 0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xd8,
+  0xe1, 0x1d, 0xc2, 0x81, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87,
+  0x72, 0x00, 0x36, 0x18, 0x02, 0x01, 0x2c, 0x40, 0xb5, 0xc1, 0x18, 0x0a,
+  0x60, 0x01, 0x2a, 0x00, 0x00, 0x00, 0x49, 0x18, 0x00, 0x00, 0x02, 0x00,
+  0x00, 0x00, 0x13, 0x86, 0x40, 0x18, 0x00, 0x00, 0x00, 0x00, 0x89, 0x20,
+  0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09, 0x20, 0x64,
+  0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1,
+  0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x40,
+  0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00, 0x76, 0x08, 0x41,
+  0x24, 0x41, 0x98, 0x89, 0x9a, 0x07, 0x7a, 0x90, 0x87, 0x7a, 0x18, 0x07,
+  0x7a, 0x70, 0x83, 0x76, 0x28, 0x07, 0x7a, 0x08, 0x07, 0x76, 0xd0, 0x03,
+  0x3d, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x79, 0x48, 0x07, 0x7c, 0x40, 0x01,
+  0x19, 0x44, 0x28, 0x84, 0x62, 0x0c, 0x11, 0x84, 0x31, 0x74, 0x06, 0x02,
+  0xe6, 0x08, 0xc0, 0x20, 0x05, 0xd4, 0x1c, 0x01, 0x28, 0x0c, 0x22, 0x04,
+  0xc2, 0x30, 0x02, 0xa1, 0x8c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0xb2,
+  0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70, 0x80, 0x07,
+  0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x76, 0x08, 0x87, 0x71, 0x78, 0x87,
+  0x79, 0xc0, 0x87, 0x38, 0x80, 0x03, 0x37, 0x88, 0x83, 0x38, 0x70, 0x03,
+  0x38, 0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06, 0xf0, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x90,
+  0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9, 0x80,
+  0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60,
+  0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x90,
+  0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20,
+  0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60,
+  0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x74, 0x80,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60,
+  0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80,
+  0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x20,
+  0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20,
+  0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x79, 0x20, 0x07, 0x7a, 0x20,
+  0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x6d, 0x60,
+  0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0,
+  0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x50, 0x07, 0x71, 0x20,
+  0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20,
+  0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x7a, 0x10,
+  0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40,
+  0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0x30, 0x84, 0x41, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xc8, 0x02, 0x01, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x32, 0x1e,
+  0x98, 0x10, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04,
+  0x43, 0x52, 0x25, 0x50, 0x04, 0x23, 0x00, 0x05, 0x18, 0x50, 0x08, 0x65,
+  0x50, 0x20, 0x05, 0x41, 0x6c, 0x04, 0x80, 0xd6, 0x58, 0xc2, 0x12, 0x00,
+  0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0xea, 0x00, 0x00, 0x00, 0x1a, 0x03,
+  0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4,
+  0x37, 0xb7, 0x21, 0x86, 0x22, 0x24, 0xc0, 0xa2, 0x50, 0xb9, 0x1b, 0x43,
+  0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b, 0x62, 0x28, 0x41, 0x22,
+  0x28, 0x05, 0xe5, 0x20, 0x08, 0x0e, 0x8e, 0xad, 0x0c, 0x84, 0x89, 0xc9,
+  0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x26,
+  0x06, 0x06, 0x26, 0xc6, 0x25, 0xc6, 0x06, 0x06, 0x04, 0xa5, 0xad, 0x8c,
+  0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26, 0x06, 0x06, 0x26, 0xc6, 0x25,
+  0xc6, 0x06, 0xc6, 0x25, 0x26, 0x65, 0x88, 0x90, 0x10, 0x43, 0x0c, 0x25,
+  0x50, 0x10, 0x65, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36, 0x04, 0x49,
+  0x0e, 0x25, 0x50, 0x02, 0x65, 0xe0, 0x16, 0x96, 0x26, 0xe7, 0x32, 0xf6,
   0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6, 0x26, 0xd7,
   0x36, 0xf7, 0x45, 0x96, 0x36, 0x17, 0x26, 0xc6, 0x56, 0x36, 0x44, 0x48,
   0x12, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c,
@@ -461,229 +471,235 @@ const unsigned char sdl_metallib[] = {
   0xe4, 0xce, 0xbe, 0xdc, 0xc2, 0xda, 0xca, 0x88, 0xc0, 0xbd, 0xcd, 0xa5,
   0xd1, 0xa5, 0xbd, 0xb9, 0x0d, 0x51, 0x92, 0x27, 0x81, 0x92, 0x28, 0x91,
   0x92, 0x89, 0x51, 0x58, 0x9a, 0x9c, 0x8b, 0x5d, 0x99, 0x1c, 0x5d, 0x19,
-  0xde, 0xd7, 0x5b, 0x1d, 0x1d, 0x5c, 0x1d, 0x1d, 0xb3, 0xb3, 0x32, 0xb7,
-  0x32, 0xb9, 0x30, 0xba, 0x32, 0x32, 0x14, 0x1c, 0xba, 0x32, 0xbc, 0xb1,
-  0xb7, 0x37, 0x39, 0x32, 0x22, 0x3b, 0x99, 0x2f, 0xb3, 0x14, 0x1a, 0x66,
-  0x6c, 0x6f, 0x61, 0x74, 0x32, 0x44, 0xe8, 0xca, 0xf0, 0xc6, 0xde, 0xde,
-  0xe4, 0xc8, 0x86, 0x30, 0x49, 0x95, 0x58, 0x09, 0x94, 0x5c, 0x89, 0x94,
-  0x60, 0x43, 0x88, 0x84, 0x4a, 0x32, 0x42, 0x61, 0x69, 0x72, 0x2e, 0x76,
-  0x65, 0x72, 0x74, 0x65, 0x78, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x94,
-  0xc2, 0xd2, 0xe4, 0x5c, 0xd8, 0xde, 0xc6, 0xc2, 0xe8, 0xd2, 0xde, 0xdc,
-  0xbe, 0xd2, 0xdc, 0xc8, 0xca, 0xf0, 0xe8, 0x9d, 0x95, 0xb9, 0x95, 0xc9,
-  0x85, 0xd1, 0x95, 0x91, 0xa1, 0x7c, 0x7d, 0x85, 0xa5, 0xc9, 0x7d, 0xc1,
-  0xb1, 0x85, 0x8d, 0x95, 0xa1, 0xbd, 0xb1, 0x91, 0x95, 0xc9, 0x7d, 0x7d,
-  0xa5, 0x0c, 0xa1, 0x14, 0x21, 0xd9, 0x12, 0x4e, 0x11, 0x94, 0x20, 0xe9,
-  0x12, 0x28, 0xb9, 0x12, 0x29, 0x99, 0x86, 0x50, 0x4a, 0x90, 0x6c, 0x09,
-  0xa7, 0x04, 0x4a, 0x90, 0x74, 0x09, 0x94, 0x5c, 0x89, 0x94, 0x60, 0x54,
-  0xc2, 0xd2, 0xe4, 0x5c, 0xc4, 0xea, 0xcc, 0xcc, 0xca, 0xe4, 0xf8, 0x84,
-  0xa5, 0xc9, 0xb9, 0x88, 0xd5, 0x99, 0x99, 0x95, 0xc9, 0x7d, 0xcd, 0xa5,
-  0xe9, 0x95, 0x11, 0x09, 0x4b, 0x93, 0x73, 0x91, 0x2b, 0x0b, 0x23, 0x63,
-  0x14, 0x96, 0x26, 0xe7, 0x12, 0x26, 0x77, 0xf6, 0x45, 0x97, 0x07, 0x57,
-  0xf6, 0x35, 0x97, 0xa6, 0x57, 0xc6, 0x2b, 0x2c, 0x4d, 0xce, 0x25, 0x4c,
-  0xee, 0xec, 0x8b, 0x2e, 0x0f, 0xae, 0xec, 0x2b, 0x8c, 0x2d, 0xed, 0xcc,
-  0xed, 0x6b, 0x2e, 0x4d, 0xaf, 0x8c, 0x88, 0x19, 0xdb, 0x5b, 0x18, 0x1d,
-  0x0d, 0x1e, 0x0d, 0x15, 0x38, 0xb9, 0x37, 0xb5, 0xb2, 0x31, 0xba, 0xb4,
-  0x37, 0xb7, 0x21, 0x60, 0xa0, 0x10, 0x09, 0x18, 0x24, 0x61, 0xa0, 0x0c,
-  0x09, 0xa7, 0x10, 0x4a, 0x90, 0x88, 0x41, 0x32, 0x06, 0xca, 0x90, 0x90,
-  0x81, 0x52, 0x24, 0x50, 0x52, 0x06, 0x89, 0x94, 0x98, 0x01, 0x13, 0x3a,
-  0xb9, 0x30, 0xb7, 0x39, 0xb3, 0x37, 0xb9, 0xb6, 0x21, 0x60, 0xa0, 0x18,
-  0x09, 0x18, 0x24, 0x61, 0xa0, 0x0c, 0x09, 0xa7, 0x18, 0x4a, 0x90, 0x88,
-  0x41, 0x32, 0x06, 0xca, 0x90, 0x90, 0x81, 0x52, 0x24, 0x50, 0x52, 0x06,
-  0x89, 0x94, 0xa0, 0xc1, 0x10, 0x24, 0xf1, 0x92, 0x2f, 0x39, 0x83, 0x24,
-  0x0d, 0x86, 0x18, 0x08, 0x90, 0x68, 0x89, 0x1a, 0xf0, 0x79, 0x6b, 0x73,
-  0x4b, 0x83, 0x7b, 0xa3, 0x2b, 0x73, 0xa3, 0x03, 0x19, 0x43, 0x0b, 0x93,
-  0xe3, 0x33, 0x95, 0xd6, 0x06, 0xc7, 0x56, 0x06, 0x32, 0xb4, 0xb2, 0x02,
-  0x42, 0x25, 0x14, 0x14, 0x34, 0x44, 0x48, 0xda, 0x60, 0x88, 0x91, 0xb0,
-  0x41, 0xe2, 0x06, 0x4c, 0x32, 0xc4, 0x48, 0xde, 0x20, 0x79, 0x03, 0x26,
-  0x19, 0x11, 0xb1, 0x03, 0x3b, 0xd8, 0x43, 0x3b, 0xb8, 0x41, 0x3b, 0xbc,
-  0x03, 0x39, 0xd4, 0x03, 0x3b, 0x94, 0x83, 0x1b, 0x98, 0x03, 0x3b, 0x84,
-  0xc3, 0x39, 0xcc, 0xc3, 0x14, 0x21, 0x18, 0x46, 0x28, 0xec, 0xc0, 0x0e,
-  0xf6, 0xd0, 0x0e, 0x6e, 0x90, 0x0e, 0xe4, 0x50, 0x0e, 0xee, 0x40, 0x0f,
-  0x53, 0x82, 0x62, 0xc4, 0x12, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0x60, 0x0f,
-  0xe5, 0x20, 0x0f, 0xf3, 0x90, 0x0e, 0xef, 0xe0, 0x0e, 0x53, 0x02, 0x63,
-  0x04, 0x15, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0xc0, 0x0e, 0xe1, 0xe0, 0x0e,
-  0xe7, 0x50, 0x0f, 0xe1, 0x70, 0x0e, 0xe5, 0xf0, 0x0b, 0xf6, 0x50, 0x0e,
-  0xf2, 0x30, 0x0f, 0xe9, 0xf0, 0x0e, 0xee, 0x30, 0x25, 0x40, 0x46, 0x4c,
-  0xe1, 0x90, 0x0e, 0xf2, 0xe0, 0x06, 0xe3, 0xf0, 0x0e, 0xed, 0x00, 0x0f,
-  0xe9, 0xc0, 0x0e, 0xe5, 0xf0, 0x0b, 0xef, 0x00, 0x0f, 0xf4, 0x90, 0x0e,
-  0xef, 0xe0, 0x0e, 0xf3, 0x30, 0x65, 0x50, 0x18, 0x67, 0x84, 0x12, 0x0e,
-  0xe9, 0x20, 0x0f, 0x6e, 0x60, 0x0f, 0xe5, 0x20, 0x0f, 0xf4, 0x50, 0x0e,
-  0xf8, 0x30, 0x25, 0x58, 0x03, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00,
-  0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66,
-  0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07,
-  0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10,
-  0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce,
-  0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b,
-  0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c,
-  0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07,
-  0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11,
-  0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0,
-  0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8,
-  0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b,
-  0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b,
-  0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87,
-  0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07,
-  0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87,
-  0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81,
-  0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30,
-  0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4,
-  0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca,
-  0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39,
-  0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b,
-  0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b,
-  0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83,
-  0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87,
-  0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90,
-  0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20,
-  0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc,
-  0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66,
-  0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24,
-  0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07,
-  0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e,
-  0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e,
-  0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54,
-  0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39,
-  0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c,
-  0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07,
-  0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0,
-  0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4,
-  0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38,
-  0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d,
-  0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d,
-  0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
-  0x06, 0xf0, 0xb0, 0x5d, 0xf9, 0x73, 0xce, 0x83, 0xfd, 0x15, 0x11, 0x4d,
-  0xc4, 0x05, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00,
-  0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
-  0xe4, 0xc6, 0x22, 0x86, 0x61, 0x18, 0xc6, 0x22, 0x04, 0x41, 0x10, 0xc6,
-  0x22, 0x82, 0x20, 0x08, 0x88, 0x95, 0x40, 0x19, 0x14, 0x01, 0xb9, 0x11,
-  0x00, 0x1a, 0x33, 0x00, 0x24, 0x66, 0x00, 0x28, 0xcc, 0x00, 0x00, 0x00,
-  0xe3, 0x11, 0x0b, 0x74, 0x41, 0x14, 0x94, 0xf1, 0x08, 0x47, 0xca, 0x24,
-  0x0a, 0xca, 0x20, 0xc3, 0x50, 0x20, 0x26, 0x04, 0xf2, 0x19, 0x8f, 0x90,
-  0xac, 0xae, 0xa1, 0xa0, 0x0c, 0x32, 0x1c, 0x09, 0x64, 0x42, 0x20, 0x1f,
-  0x0b, 0x0a, 0xf8, 0x8c, 0x47, 0x5c, 0x9b, 0x18, 0x40, 0x14, 0x94, 0x41,
-  0x06, 0xc6, 0xb1, 0x4c, 0x08, 0xe4, 0x63, 0x45, 0x00, 0x9f, 0xf1, 0x08,
-  0x0e, 0x0c, 0xce, 0xc0, 0xa2, 0xa0, 0x0c, 0x32, 0x44, 0x13, 0x67, 0x42,
-  0x20, 0x1f, 0x2b, 0x02, 0xf8, 0x8c, 0x47, 0x80, 0x41, 0x19, 0xb0, 0x01,
-  0x47, 0x41, 0x19, 0x64, 0x08, 0xb0, 0xcd, 0x82, 0x4a, 0x3e, 0x83, 0x0c,
-  0x83, 0x16, 0x06, 0x16, 0x4c, 0xf2, 0xb1, 0x21, 0x80, 0xcf, 0x20, 0x83,
-  0xd1, 0x95, 0x81, 0x05, 0x91, 0x7c, 0x6c, 0x08, 0xe0, 0x33, 0xc8, 0x90,
-  0x80, 0x41, 0x1a, 0x58, 0xf0, 0xc8, 0xc7, 0x86, 0x00, 0x3e, 0xe3, 0x11,
-  0x6d, 0x20, 0x07, 0x79, 0x80, 0x06, 0x14, 0x94, 0x41, 0x86, 0xa0, 0x0c,
-  0xd0, 0xc0, 0x02, 0x31, 0x90, 0xcf, 0x20, 0xc3, 0x70, 0x06, 0x6e, 0x60,
-  0x01, 0x18, 0xc8, 0x67, 0x90, 0xa1, 0x48, 0x83, 0x38, 0xb0, 0xa0, 0x93,
-  0xcf, 0x20, 0xc3, 0xb1, 0x06, 0x74, 0x60, 0x81, 0x26, 0x9f, 0x41, 0x06,
-  0x3d, 0x70, 0x03, 0x38, 0xb0, 0x2c, 0x90, 0xcf, 0x20, 0x03, 0x1f, 0xc0,
-  0x81, 0x1d, 0x98, 0x13, 0xc8, 0xc7, 0x92, 0x01, 0x3e, 0x16, 0x30, 0xf0,
-  0xb1, 0x20, 0x81, 0x8f, 0x05, 0x08, 0x7c, 0x2c, 0x28, 0xe0, 0x33, 0xdb,
-  0x80, 0x07, 0x01, 0x30, 0xdb, 0x10, 0x8c, 0x42, 0x90, 0x41, 0x40, 0x0c,
-  0x09, 0x00, 0x00, 0x00, 0x5b, 0x86, 0x20, 0x80, 0x83, 0x2d, 0xc3, 0x10,
-  0xc0, 0xc1, 0x96, 0xe1, 0x08, 0xe0, 0x60, 0xcb, 0xc0, 0x04, 0x70, 0xb0,
-  0x65, 0x88, 0x02, 0x38, 0xd8, 0x32, 0x58, 0x01, 0x1c, 0x6c, 0x19, 0xc6,
-  0x20, 0x80, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00,
-  0x14, 0x00, 0x00, 0x00, 0x1c, 0x09, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
-  0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0x44, 0x02, 0x00, 0x00,
-  0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
-  0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39,
-  0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62,
-  0x80, 0x10, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0x84, 0x10, 0x32, 0x14,
-  0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90, 0x21,
-  0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8, 0x08,
-  0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00,
-  0x51, 0x18, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00, 0x1b, 0xc8, 0x25, 0xf8,
-  0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x80, 0x8a, 0x18, 0x87, 0x77, 0x90,
-  0x07, 0x79, 0x28, 0x87, 0x71, 0xa0, 0x07, 0x76, 0xc8, 0x87, 0x36, 0x90,
-  0x87, 0x77, 0xa8, 0x07, 0x77, 0x20, 0x87, 0x72, 0x20, 0x87, 0x36, 0x20,
-  0x87, 0x74, 0xb0, 0x87, 0x74, 0x20, 0x87, 0x72, 0x68, 0x83, 0x79, 0x88,
-  0x07, 0x79, 0xa0, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08,
-  0x07, 0x7a, 0x40, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c,
-  0x00, 0x82, 0x1c, 0xd2, 0x61, 0x1e, 0xc2, 0x41, 0x1c, 0xd8, 0xa1, 0x1c,
-  0xda, 0x80, 0x1e, 0xc2, 0x21, 0x1d, 0xd8, 0xa1, 0x0d, 0xc6, 0x21, 0x1c,
-  0xd8, 0x81, 0x1d, 0xe6, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28,
-  0x07, 0x80, 0x60, 0x87, 0x72, 0x98, 0x87, 0x79, 0x68, 0x03, 0x78, 0x90,
-  0x87, 0x72, 0x18, 0x87, 0x74, 0x98, 0x87, 0x72, 0x68, 0x03, 0x73, 0x80,
-  0x87, 0x76, 0x08, 0x07, 0x72, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e,
-  0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c,
-  0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e,
-  0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0x01, 0xa0,
-  0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x06, 0x77, 0x78, 0x87, 0x36, 0x30,
-  0x07, 0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77, 0x48,
-  0x07, 0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76, 0x48,
-  0x87, 0x76, 0x68, 0x03, 0x77, 0x78, 0x07, 0x77, 0x68, 0x03, 0x76, 0x28,
-  0x87, 0x70, 0x30, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x74, 0x70,
-  0x07, 0x73, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08,
-  0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20,
-  0xdc, 0xe1, 0x1d, 0xda, 0x40, 0x1d, 0xea, 0xa1, 0x1d, 0xe0, 0xa1, 0x0d,
-  0xe8, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x1e, 0x00, 0x73, 0x08,
-  0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x70,
-  0x87, 0x70, 0x70, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68,
-  0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c,
-  0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xce, 0xc1, 0x1d,
-  0xca, 0x81, 0x1c, 0xda, 0x40, 0x1f, 0xca, 0x41, 0x1e, 0xde, 0x61, 0x1e,
-  0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d,
-  0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68,
-  0x03, 0x7a, 0x90, 0x87, 0x70, 0x80, 0x07, 0x78, 0x48, 0x07, 0x77, 0x38,
-  0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e,
-  0xea, 0xa1, 0x1c, 0x00, 0x62, 0x1e, 0xe8, 0x21, 0x1c, 0xc6, 0x61, 0x1d,
-  0xda, 0x00, 0x1e, 0xe4, 0xe1, 0x1d, 0xe8, 0xa1, 0x1c, 0xc6, 0x81, 0x1e,
-  0xde, 0x41, 0x1e, 0xda, 0x40, 0x1c, 0xea, 0xc1, 0x1c, 0xcc, 0xa1, 0x1c,
-  0xe4, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xf4, 0xa1, 0x1c, 0x00, 0x3c, 0x00,
-  0x88, 0x7a, 0x70, 0x87, 0x79, 0x08, 0x07, 0x73, 0x28, 0x87, 0x36, 0x30,
-  0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e,
-  0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xea, 0x61, 0x1e, 0xca, 0xa1, 0x0d,
-  0xe6, 0xe1, 0x1d, 0xcc, 0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xd8, 0xe1, 0x1d,
-  0xc2, 0x81, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00,
-  0x36, 0x18, 0x42, 0x00, 0x2c, 0x40, 0x05, 0x00, 0x49, 0x18, 0x00, 0x00,
-  0x01, 0x00, 0x00, 0x00, 0x13, 0x84, 0x40, 0x00, 0x89, 0x20, 0x00, 0x00,
-  0x0e, 0x00, 0x00, 0x00, 0x32, 0x22, 0x08, 0x09, 0x20, 0x64, 0x85, 0x04,
-  0x13, 0x22, 0xa4, 0x84, 0x04, 0x13, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14,
-  0x12, 0x4c, 0x88, 0x8c, 0x0b, 0x84, 0x84, 0x4c, 0x10, 0x28, 0x33, 0x00,
-  0xc3, 0x08, 0x04, 0x30, 0x88, 0x10, 0x04, 0x45, 0x08, 0xa1, 0x19, 0x08,
-  0x98, 0x23, 0x00, 0x83, 0x14, 0xb0, 0x39, 0x02, 0x50, 0x18, 0x01, 0x00,
-  0x13, 0xb2, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70,
-  0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x76, 0x08, 0x87, 0x71,
-  0x78, 0x87, 0x79, 0xc0, 0x87, 0x38, 0x80, 0x03, 0x37, 0x88, 0x83, 0x38,
-  0x70, 0x03, 0x38, 0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06, 0xf0, 0xa0, 0x07,
-  0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0, 0x06,
-  0xe9, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e,
-  0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07,
-  0x6d, 0x90, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07,
-  0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07,
-  0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07,
-  0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e,
-  0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x6d, 0x60, 0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07,
-  0x71, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07, 0x7a, 0x30, 0x07,
-  0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x73, 0x20, 0x07,
-  0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f,
-  0x74, 0x80, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x6d, 0x60, 0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07,
-  0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07, 0x7a, 0x10, 0x07,
-  0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f,
-  0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07,
-  0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x79, 0x20, 0x07,
-  0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07,
-  0x6d, 0x60, 0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07,
-  0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x50, 0x07,
-  0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07,
-  0x71, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07,
-  0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07,
-  0x72, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60, 0x07,
-  0x7a, 0x30, 0x07, 0x72, 0x30, 0x84, 0x21, 0x00, 0x00, 0x08, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0xc8, 0x02, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
-  0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47,
-  0xc6, 0x04, 0x43, 0xb2, 0x12, 0x18, 0x01, 0x28, 0x90, 0x22, 0x28, 0x84,
-  0x82, 0x20, 0x1c, 0x01, 0xa0, 0x1b, 0x4b, 0x58, 0x00, 0x00, 0x00, 0x00,
-  0x79, 0x18, 0x00, 0x00, 0xa1, 0x00, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10,
-  0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7,
-  0x21, 0x86, 0x41, 0x14, 0xc0, 0x81, 0x50, 0xb9, 0x1b, 0x43, 0x0b, 0x93,
-  0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b, 0x62, 0x18, 0x41, 0x21, 0x18, 0x05,
-  0xe1, 0x20, 0x08, 0x0e, 0x8e, 0xad, 0x0c, 0x84, 0x89, 0xc9, 0xaa, 0x09,
-  0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x26, 0x06, 0x06,
-  0x26, 0xc6, 0x25, 0x86, 0x66, 0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c,
-  0xcd, 0xac, 0xac, 0x65, 0x26, 0x06, 0x06, 0x26, 0xc6, 0x25, 0x86, 0x66,
-  0x26, 0x65, 0x88, 0x50, 0x10, 0x43, 0x0c, 0x23, 0x30, 0x0c, 0x43, 0x60,
+  0xde, 0xd7, 0x5b, 0x1d, 0x1d, 0x5c, 0x1d, 0x1d, 0xad, 0xb3, 0x32, 0xb7,
+  0x32, 0xb9, 0x30, 0xba, 0x32, 0x32, 0x94, 0x9a, 0xb1, 0x37, 0xb6, 0x37,
+  0x39, 0x22, 0x3b, 0x9a, 0x2f, 0xb3, 0x14, 0x16, 0x63, 0x6f, 0x6c, 0x6f,
+  0x72, 0x43, 0x98, 0xa4, 0x4a, 0xac, 0x04, 0x4a, 0xa2, 0x44, 0x4a, 0x2e,
+  0x66, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x38,
+  0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x44, 0x76, 0x32, 0x5f,
+  0x66, 0x29, 0x34, 0xcc, 0xd8, 0xde, 0xc2, 0xe8, 0x64, 0x88, 0xd0, 0x95,
+  0xe1, 0x8d, 0xbd, 0xbd, 0xc9, 0x91, 0x0d, 0x61, 0x92, 0x2a, 0xc9, 0x12,
+  0x28, 0xd1, 0x12, 0x29, 0xd9, 0x86, 0x18, 0x09, 0x95, 0x60, 0x09, 0x47,
+  0x28, 0x2c, 0x4d, 0xce, 0xc5, 0xae, 0x4c, 0x8e, 0xae, 0x0c, 0xef, 0x2b,
+  0xcd, 0x0d, 0xae, 0x8e, 0x8e, 0x52, 0x58, 0x9a, 0x9c, 0x0b, 0xdb, 0xdb,
+  0x58, 0x18, 0x5d, 0xda, 0x9b, 0xdb, 0x57, 0x9a, 0x1b, 0x59, 0x19, 0x1e,
+  0xbd, 0xb3, 0x32, 0xb7, 0x32, 0xb9, 0x30, 0xba, 0x32, 0x32, 0x94, 0xaf,
+  0xaf, 0xb0, 0x34, 0xb9, 0x2f, 0x38, 0xb6, 0xb0, 0xb1, 0x32, 0xb4, 0x37,
+  0x36, 0xb2, 0x32, 0xb9, 0xaf, 0xaf, 0x94, 0x21, 0x94, 0x32, 0x24, 0x5e,
+  0xf2, 0x29, 0x83, 0x12, 0x24, 0x60, 0x90, 0x40, 0x89, 0x96, 0x48, 0xc9,
+  0x34, 0x84, 0x52, 0x82, 0xc4, 0x4b, 0x3e, 0x25, 0x50, 0x82, 0x04, 0x0c,
+  0x12, 0x28, 0x89, 0x12, 0x29, 0xb9, 0x86, 0x50, 0x8a, 0x90, 0x78, 0xc9,
+  0xa7, 0x08, 0x4a, 0x90, 0x80, 0x41, 0x02, 0x25, 0x5a, 0x22, 0x25, 0x1b,
+  0x95, 0xb0, 0x34, 0x39, 0x17, 0xb1, 0x3a, 0x33, 0xb3, 0x32, 0x39, 0x3e,
+  0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73,
+  0x69, 0x7a, 0x65, 0x44, 0xc2, 0xd2, 0xe4, 0x5c, 0xe4, 0xca, 0xc2, 0xc8,
+  0x18, 0x85, 0xa5, 0xc9, 0xb9, 0x84, 0xc9, 0x9d, 0x7d, 0xd1, 0xe5, 0xc1,
+  0x95, 0x7d, 0xcd, 0xa5, 0xe9, 0x95, 0xf1, 0x0a, 0x4b, 0x93, 0x73, 0x09,
+  0x93, 0x3b, 0xfb, 0xa2, 0xcb, 0x83, 0x2b, 0xfb, 0x0a, 0x63, 0x4b, 0x3b,
+  0x73, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x23, 0x62, 0xc6, 0xf6, 0x16, 0x46,
+  0x47, 0x83, 0x47, 0x43, 0x05, 0x4e, 0xee, 0x4d, 0xad, 0x6c, 0x8c, 0x2e,
+  0xed, 0xcd, 0x6d, 0x08, 0x18, 0x28, 0x46, 0x42, 0x06, 0x49, 0x19, 0x28,
+  0x44, 0xf2, 0x29, 0x82, 0x12, 0x24, 0x66, 0x90, 0x9c, 0x81, 0x42, 0x24,
+  0x68, 0xa0, 0x1c, 0x09, 0x94, 0xa4, 0x41, 0x22, 0x25, 0x6a, 0xc0, 0x84,
+  0x4e, 0x2e, 0xcc, 0x6d, 0xce, 0xec, 0x4d, 0xae, 0x6d, 0x08, 0x18, 0x28,
+  0x45, 0x42, 0x06, 0x49, 0x19, 0x28, 0x44, 0xf2, 0x29, 0x86, 0x12, 0x24,
+  0x66, 0x90, 0x9c, 0x81, 0x42, 0x24, 0x68, 0xa0, 0x1c, 0x09, 0x94, 0xa4,
+  0x41, 0x22, 0x25, 0x6c, 0x30, 0x44, 0x49, 0xc2, 0x20, 0x11, 0x83, 0x64,
+  0x0c, 0x92, 0x35, 0x48, 0xda, 0x60, 0x88, 0x81, 0x00, 0x49, 0x97, 0xb8,
+  0x01, 0x9f, 0xb7, 0x36, 0xb7, 0x34, 0xb8, 0x37, 0xba, 0x32, 0x37, 0x3a,
+  0x90, 0x31, 0xb4, 0x30, 0x39, 0x3e, 0x53, 0x69, 0x6d, 0x70, 0x6c, 0x65,
+  0x20, 0x43, 0x2b, 0x2b, 0x20, 0x54, 0x42, 0x41, 0x41, 0x43, 0x84, 0x24,
+  0x0e, 0x86, 0x18, 0x09, 0x1c, 0x24, 0x72, 0xc0, 0x24, 0x43, 0x8c, 0x64,
+  0x0e, 0x92, 0x39, 0x60, 0x92, 0x11, 0x11, 0x3b, 0xb0, 0x83, 0x3d, 0xb4,
+  0x83, 0x1b, 0xb4, 0xc3, 0x3b, 0x90, 0x43, 0x3d, 0xb0, 0x43, 0x39, 0xb8,
+  0x81, 0x39, 0xb0, 0x43, 0x38, 0x9c, 0xc3, 0x3c, 0x4c, 0x11, 0x82, 0x61,
+  0x84, 0xc2, 0x0e, 0xec, 0x60, 0x0f, 0xed, 0xe0, 0x06, 0xe9, 0x40, 0x0e,
+  0xe5, 0xe0, 0x0e, 0xf4, 0x30, 0x25, 0x28, 0x46, 0x2c, 0xe1, 0x90, 0x0e,
+  0xf2, 0xe0, 0x06, 0xf6, 0x50, 0x0e, 0xf2, 0x30, 0x0f, 0xe9, 0xf0, 0x0e,
+  0xee, 0x30, 0x25, 0x30, 0x46, 0x50, 0xe1, 0x90, 0x0e, 0xf2, 0xe0, 0x06,
+  0xec, 0x10, 0x0e, 0xee, 0x70, 0x0e, 0xf5, 0x10, 0x0e, 0xe7, 0x50, 0x0e,
+  0xbf, 0x60, 0x0f, 0xe5, 0x20, 0x0f, 0xf3, 0x90, 0x0e, 0xef, 0xe0, 0x0e,
+  0x53, 0x02, 0x64, 0xc4, 0x14, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0x30, 0x0e,
+  0xef, 0xd0, 0x0e, 0xf0, 0x90, 0x0e, 0xec, 0x50, 0x0e, 0xbf, 0xf0, 0x0e,
+  0xf0, 0x40, 0x0f, 0xe9, 0xf0, 0x0e, 0xee, 0x30, 0x0f, 0x53, 0x06, 0x85,
+  0x71, 0x46, 0x28, 0xe1, 0x90, 0x0e, 0xf2, 0xe0, 0x06, 0xf6, 0x50, 0x0e,
+  0xf2, 0x40, 0x0f, 0xe5, 0x80, 0x0f, 0x53, 0x82, 0x37, 0x00, 0x79, 0x18,
+  0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1,
+  0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42,
+  0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f,
+  0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1,
+  0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84,
+  0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc,
+  0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70,
+  0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19,
+  0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f,
+  0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21,
+  0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc,
+  0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84,
+  0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37,
+  0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70,
+  0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77,
+  0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79,
+  0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e,
+  0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1,
+  0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81,
+  0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98,
+  0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88,
+  0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4,
+  0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72,
+  0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74,
+  0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e,
+  0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e,
+  0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21,
+  0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01,
+  0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc,
+  0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77,
+  0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e,
+  0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1,
+  0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61,
+  0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0,
+  0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0,
+  0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74,
+  0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e,
+  0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41,
+  0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50,
+  0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c,
+  0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc,
+  0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20, 0x00, 0x00, 0x04, 0x00,
+  0x00, 0x00, 0x06, 0xf0, 0xb0, 0x5d, 0xf9, 0x73, 0xce, 0x83, 0xfd, 0x15,
+  0x11, 0x4d, 0xc4, 0x05, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x52, 0x00,
+  0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x09, 0x00,
+  0x00, 0x00, 0xe4, 0xc6, 0x22, 0x86, 0x61, 0x18, 0xc6, 0x22, 0x04, 0x41,
+  0x10, 0xc6, 0x22, 0x82, 0x20, 0x08, 0x88, 0x95, 0x40, 0x19, 0x14, 0x01,
+  0xb9, 0x11, 0x00, 0x1a, 0x33, 0x00, 0x24, 0x66, 0x00, 0x28, 0xcc, 0x00,
+  0x00, 0x00, 0xe3, 0x11, 0x4b, 0x74, 0x45, 0x14, 0x94, 0xf1, 0x08, 0x67,
+  0xca, 0x26, 0x0a, 0xca, 0x20, 0xc3, 0x50, 0x20, 0x26, 0x04, 0xf2, 0x19,
+  0x8f, 0x90, 0xae, 0xae, 0xa1, 0xa0, 0x0c, 0x32, 0x1c, 0x09, 0x64, 0x42,
+  0x20, 0x1f, 0x0b, 0x0a, 0xf8, 0x8c, 0x47, 0x5c, 0x9c, 0x18, 0x40, 0x14,
+  0x94, 0x41, 0x06, 0xc6, 0xb1, 0x4c, 0x08, 0xe4, 0x63, 0x45, 0x00, 0x9f,
+  0xf1, 0x08, 0x2e, 0x0c, 0xce, 0xc0, 0xa2, 0xa0, 0x0c, 0x32, 0x44, 0x13,
+  0x67, 0x42, 0x20, 0x1f, 0x2b, 0x02, 0xf8, 0x8c, 0x47, 0x80, 0x81, 0x19,
+  0xb0, 0x01, 0x47, 0x41, 0x19, 0x64, 0x08, 0xb0, 0xcd, 0x82, 0x4a, 0x3e,
+  0x83, 0x0c, 0x83, 0x16, 0x06, 0x16, 0x4c, 0xf2, 0xb1, 0x21, 0x80, 0xcf,
+  0x20, 0x83, 0xd1, 0x95, 0x81, 0x05, 0x91, 0x7c, 0x6c, 0x08, 0xe0, 0x33,
+  0xc8, 0x90, 0x80, 0x41, 0x1a, 0x58, 0xf0, 0xc8, 0xc7, 0x86, 0x00, 0x3e,
+  0xe3, 0x11, 0x6d, 0x30, 0x07, 0x79, 0x80, 0x06, 0x14, 0x94, 0x41, 0x86,
+  0xa0, 0x0c, 0xd0, 0xc0, 0x02, 0x31, 0x90, 0xcf, 0x20, 0xc3, 0x70, 0x06,
+  0x6e, 0x60, 0x01, 0x18, 0xc8, 0x67, 0x90, 0xa1, 0x48, 0x83, 0x38, 0xb0,
+  0xa0, 0x93, 0xcf, 0x20, 0xc3, 0xb1, 0x06, 0x74, 0x60, 0x81, 0x26, 0x9f,
+  0x41, 0x86, 0x3d, 0x70, 0x03, 0x38, 0xb0, 0x2c, 0x90, 0xcf, 0x20, 0x43,
+  0x1f, 0xc0, 0x81, 0x1d, 0x98, 0x13, 0xc8, 0xc7, 0x92, 0x01, 0x3e, 0x16,
+  0x30, 0xf0, 0xb1, 0x20, 0x81, 0x8f, 0x05, 0x08, 0x7c, 0x2c, 0x28, 0xe0,
+  0x33, 0xdb, 0x80, 0x07, 0x01, 0x30, 0xdb, 0x10, 0x90, 0x42, 0x30, 0xdb,
+  0x10, 0x90, 0x82, 0x90, 0x41, 0x40, 0x0c, 0x00, 0x00, 0x00, 0x09, 0x00,
+  0x00, 0x00, 0x5b, 0x86, 0x20, 0xa0, 0x83, 0x2d, 0xc3, 0x10, 0xd0, 0xc1,
+  0x96, 0xe1, 0x08, 0xe8, 0x60, 0xcb, 0xc0, 0x04, 0x74, 0xb0, 0x65, 0x88,
+  0x02, 0x3a, 0xd8, 0x32, 0x58, 0x01, 0x1d, 0x6c, 0x19, 0xc6, 0x20, 0xa0,
+  0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00,
+  0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0xec, 0x08, 0x00, 0x00, 0xff, 0xff,
+  0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0x38, 0x02,
+  0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00,
+  0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10,
+  0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04,
+  0x8b, 0x62, 0x80, 0x10, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0x84, 0x10,
+  0x32, 0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a,
+  0x90, 0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07,
+  0xc8, 0x08, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00,
+  0x00, 0x00, 0x51, 0x18, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00, 0x1b, 0xc8,
+  0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x00, 0x8a, 0x18, 0x87,
+  0x77, 0x90, 0x07, 0x79, 0x28, 0x87, 0x71, 0xa0, 0x07, 0x76, 0xc8, 0x87,
+  0x36, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x77, 0x20, 0x87, 0x72, 0x20, 0x87,
+  0x36, 0x20, 0x87, 0x74, 0xb0, 0x87, 0x74, 0x20, 0x87, 0x72, 0x68, 0x83,
+  0x79, 0x88, 0x07, 0x79, 0xa0, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83,
+  0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6,
+  0xa1, 0x1c, 0x00, 0x82, 0x1c, 0xd2, 0x61, 0x1e, 0xc2, 0x41, 0x1c, 0xd8,
+  0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xc2, 0x21, 0x1d, 0xd8, 0xa1, 0x0d, 0xc6,
+  0x21, 0x1c, 0xd8, 0x81, 0x1d, 0xe6, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87,
+  0x79, 0x28, 0x07, 0x80, 0x60, 0x87, 0x72, 0x98, 0x87, 0x79, 0x68, 0x03,
+  0x78, 0x90, 0x87, 0x72, 0x18, 0x87, 0x74, 0x98, 0x87, 0x72, 0x68, 0x03,
+  0x73, 0x80, 0x87, 0x76, 0x08, 0x07, 0x72, 0x00, 0xcc, 0x21, 0x1c, 0xd8,
+  0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4,
+  0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc,
+  0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda,
+  0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x06, 0x77, 0x78, 0x87,
+  0x36, 0x30, 0x07, 0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87,
+  0x77, 0x48, 0x07, 0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07,
+  0x76, 0x48, 0x87, 0x76, 0x68, 0x03, 0x77, 0x78, 0x07, 0x77, 0x68, 0x03,
+  0x76, 0x28, 0x87, 0x70, 0x30, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83,
+  0x74, 0x70, 0x07, 0x73, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83,
+  0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca,
+  0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x40, 0x1d, 0xea, 0xa1, 0x1d, 0xe0,
+  0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x1e, 0x00,
+  0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87,
+  0x36, 0x70, 0x87, 0x70, 0x70, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87,
+  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea,
+  0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xce,
+  0xc1, 0x1d, 0xca, 0x81, 0x1c, 0xda, 0x40, 0x1f, 0xca, 0x41, 0x1e, 0xde,
+  0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8,
+  0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87,
+  0x77, 0x68, 0x03, 0x7a, 0x90, 0x87, 0x70, 0x80, 0x07, 0x78, 0x48, 0x07,
+  0x77, 0x38, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8,
+  0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0x62, 0x1e, 0xe8, 0x21, 0x1c, 0xc6,
+  0x61, 0x1d, 0xda, 0x00, 0x1e, 0xe4, 0xe1, 0x1d, 0xe8, 0xa1, 0x1c, 0xc6,
+  0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0x40, 0x1c, 0xea, 0xc1, 0x1c, 0xcc,
+  0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xf4, 0xa1, 0x1c, 0x00,
+  0x3c, 0x00, 0x88, 0x7a, 0x70, 0x87, 0x79, 0x08, 0x07, 0x73, 0x28, 0x87,
+  0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07,
+  0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xea, 0x61, 0x1e, 0xca,
+  0xa1, 0x0d, 0xe6, 0xe1, 0x1d, 0xcc, 0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xd8,
+  0xe1, 0x1d, 0xc2, 0x81, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87,
+  0x72, 0x00, 0x36, 0x10, 0x82, 0x00, 0x58, 0x00, 0x00, 0x00, 0x49, 0x18,
+  0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x13, 0x84, 0x40, 0x00, 0x89, 0x20,
+  0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x32, 0x22, 0x08, 0x09, 0x20, 0x64,
+  0x85, 0x04, 0x13, 0x22, 0xa4, 0x84, 0x04, 0x13, 0x22, 0xe3, 0x84, 0xa1,
+  0x90, 0x14, 0x12, 0x4c, 0x88, 0x8c, 0x0b, 0x84, 0x84, 0x4c, 0x10, 0x24,
+  0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00, 0x65, 0x08, 0x09,
+  0x9a, 0x81, 0x80, 0x39, 0x02, 0x30, 0x48, 0x01, 0x1b, 0x01, 0x00, 0x00,
+  0x00, 0x00, 0x13, 0xb2, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68,
+  0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x76, 0x08,
+  0x87, 0x71, 0x78, 0x87, 0x79, 0xc0, 0x87, 0x38, 0x80, 0x03, 0x37, 0x88,
+  0x83, 0x38, 0x70, 0x03, 0x38, 0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06, 0xf0,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78,
+  0xd0, 0x06, 0xe9, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d,
+  0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71,
+  0x60, 0x07, 0x6d, 0x90, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72,
+  0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a,
+  0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e, 0x73,
+  0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d,
+  0x60, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76,
+  0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07, 0x7a,
+  0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x73,
+  0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d,
+  0x60, 0x0f, 0x74, 0x80, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x6d, 0x60, 0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07, 0x7a,
+  0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d,
+  0x60, 0x0f, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78,
+  0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x79,
+  0x20, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75,
+  0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72,
+  0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6,
+  0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a,
+  0x50, 0x07, 0x71, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07, 0x72,
+  0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71,
+  0x00, 0x07, 0x72, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71,
+  0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0x30, 0x84, 0x21, 0x00, 0x00, 0x08,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xc8, 0x02, 0x01, 0x00, 0x00, 0x08, 0x00,
+  0x00, 0x00, 0x32, 0x1e, 0x98, 0x0c, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09,
+  0x26, 0x47, 0xc6, 0x04, 0x43, 0xb2, 0x12, 0x18, 0x01, 0x28, 0x82, 0x42,
+  0x28, 0x08, 0xba, 0xb1, 0x84, 0x25, 0x00, 0x00, 0x00, 0x00, 0x79, 0x18,
+  0x00, 0x00, 0x9a, 0x00, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29,
+  0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x86,
+  0x31, 0x14, 0xc0, 0x61, 0x50, 0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a,
+  0x4b, 0xd3, 0x2b, 0x1b, 0x62, 0x18, 0x41, 0x21, 0x18, 0x04, 0xe5, 0x20,
+  0x08, 0x0e, 0x8e, 0xad, 0x0c, 0x84, 0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae,
+  0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x26, 0x06, 0x06, 0x26, 0xc6,
+  0x25, 0xc6, 0x06, 0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac,
+  0xac, 0x65, 0x26, 0x06, 0x06, 0x26, 0xc6, 0x25, 0xc6, 0x06, 0xc6, 0x25,
+  0x26, 0x65, 0x88, 0x50, 0x10, 0x43, 0x0c, 0x23, 0x30, 0x0a, 0x43, 0x60,
   0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36, 0x04, 0x29, 0x0e, 0x23, 0x30, 0x02,
   0x43, 0xe0, 0x16, 0x96, 0x26, 0xe7, 0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6,
   0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6, 0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96,
@@ -698,1146 +714,1112 @@ const unsigned char sdl_metallib[] = {
   0x5d, 0x98, 0xdc, 0x59, 0x19, 0x1d, 0xa3, 0xb0, 0x34, 0x39, 0x97, 0x30,
   0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0x2f, 0xb7, 0xb0, 0xb6, 0x32,
   0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x43, 0x90, 0xe2, 0x31, 0x84,
-  0x02, 0x2a, 0xa2, 0x21, 0x42, 0x21, 0x51, 0x09, 0x4b, 0x93, 0x73, 0x11,
-  0xab, 0x33, 0x33, 0x2b, 0x93, 0xe3, 0x13, 0x96, 0x26, 0xe7, 0x22, 0x56,
-  0x67, 0x66, 0x56, 0x26, 0xf7, 0x35, 0x97, 0xa6, 0x57, 0x46, 0x29, 0x2c,
-  0x4d, 0xce, 0x85, 0xed, 0x6d, 0x2c, 0x8c, 0x2e, 0xed, 0xcd, 0xed, 0x2b,
-  0xcd, 0x8d, 0xac, 0x0c, 0x8f, 0x48, 0x58, 0x9a, 0x9c, 0x8b, 0x5c, 0x59,
-  0x18, 0x19, 0xa3, 0xb0, 0x34, 0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba,
-  0x3c, 0xb8, 0xb2, 0xaf, 0xb9, 0x34, 0xbd, 0x32, 0x5e, 0x61, 0x69, 0x72,
-  0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x61, 0x6c,
-  0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x64, 0xc2, 0xd2, 0xe4,
-  0x5c, 0xc2, 0xe4, 0xce, 0xbe, 0xdc, 0xc2, 0xda, 0xca, 0x38, 0x8c, 0xbd,
-  0xb1, 0x0d, 0x01, 0x03, 0x43, 0x28, 0xa8, 0xa2, 0x32, 0x86, 0xc2, 0x32,
-  0x04, 0x23, 0x28, 0xae, 0x02, 0x33, 0x86, 0x22, 0x33, 0x86, 0x02, 0x2a,
-  0xa2, 0x42, 0x2b, 0xb6, 0x21, 0x42, 0xc1, 0x0d, 0x31, 0x08, 0xa0, 0x98,
-  0x8a, 0x8e, 0xcf, 0x5b, 0x9b, 0x5b, 0x1a, 0xdc, 0x1b, 0x5d, 0x99, 0x1b,
-  0x1d, 0xc8, 0x18, 0x5a, 0x98, 0x1c, 0x9f, 0xa9, 0xb4, 0x36, 0x38, 0xb6,
-  0x32, 0x90, 0xa1, 0x95, 0x15, 0x10, 0x2a, 0xa1, 0xa0, 0xa0, 0x21, 0x42,
-  0x01, 0x06, 0x43, 0x8c, 0xe2, 0x2b, 0xc2, 0x00, 0x39, 0x86, 0x18, 0x85,
-  0x18, 0x14, 0x62, 0x80, 0x1c, 0x23, 0x22, 0x76, 0x60, 0x07, 0x7b, 0x68,
-  0x07, 0x37, 0x68, 0x87, 0x77, 0x20, 0x87, 0x7a, 0x60, 0x87, 0x72, 0x70,
-  0x03, 0x73, 0x60, 0x87, 0x70, 0x38, 0x87, 0x79, 0x98, 0x22, 0x04, 0xc3,
-  0x08, 0x85, 0x1d, 0xd8, 0xc1, 0x1e, 0xda, 0xc1, 0x0d, 0xd2, 0x81, 0x1c,
-  0xca, 0xc1, 0x1d, 0xe8, 0x61, 0x4a, 0x50, 0x8c, 0x58, 0xc2, 0x21, 0x1d,
-  0xe4, 0xc1, 0x0d, 0xec, 0xa1, 0x1c, 0xe4, 0x61, 0x1e, 0xd2, 0xe1, 0x1d,
-  0xdc, 0x61, 0x4a, 0x60, 0x8c, 0xa0, 0xc2, 0x21, 0x1d, 0xe4, 0xc1, 0x0d,
-  0xd8, 0x21, 0x1c, 0xdc, 0xe1, 0x1c, 0xea, 0x21, 0x1c, 0xce, 0xa1, 0x1c,
-  0x7e, 0xc1, 0x1e, 0xca, 0x41, 0x1e, 0xe6, 0x21, 0x1d, 0xde, 0xc1, 0x1d,
-  0xa6, 0x04, 0xc8, 0x88, 0x29, 0x1c, 0xd2, 0x41, 0x1e, 0xdc, 0x60, 0x1c,
-  0xde, 0xa1, 0x1d, 0xe0, 0x21, 0x1d, 0xd8, 0xa1, 0x1c, 0x7e, 0xe1, 0x1d,
-  0xe0, 0x81, 0x1e, 0xd2, 0xe1, 0x1d, 0xdc, 0x61, 0x1e, 0xa6, 0x0c, 0x0a,
-  0xe3, 0x8c, 0x60, 0xc2, 0x21, 0x1d, 0xe4, 0xc1, 0x0d, 0xcc, 0x41, 0x1e,
-  0xc2, 0xe1, 0x1c, 0xda, 0xa1, 0x1c, 0xdc, 0x81, 0x1e, 0xa6, 0x04, 0x1e,
-  0x00, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00,
-  0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88,
-  0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73,
-  0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e,
-  0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30,
-  0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8,
-  0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b,
-  0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76,
-  0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e,
-  0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e,
-  0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61,
-  0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4,
-  0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76,
-  0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37,
-  0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76,
-  0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71,
-  0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e,
-  0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1,
-  0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61,
-  0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90,
-  0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8,
-  0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc,
-  0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7,
-  0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78,
-  0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f,
-  0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f,
-  0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1,
-  0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0,
-  0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0,
-  0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b,
-  0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c,
-  0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61,
-  0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1,
-  0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc,
-  0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4,
-  0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79,
-  0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72,
-  0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e,
-  0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1,
-  0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8,
-  0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8,
-  0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00,
-  0x71, 0x20, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x06, 0x20, 0xb1, 0x5d,
-  0xf9, 0xb3, 0xce, 0x82, 0x0c, 0x7f, 0x11, 0x01, 0x06, 0x43, 0x34, 0x13,
-  0x00, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
-  0x13, 0x04, 0x01, 0x05, 0x25, 0x83, 0x80, 0x18, 0x02, 0x00, 0x00, 0x00,
-  0x5b, 0x06, 0x20, 0x18, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00,
-  0x14, 0x00, 0x00, 0x00, 0xf0, 0x0a, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
-  0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0xb9, 0x02, 0x00, 0x00,
-  0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
-  0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39,
-  0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62,
-  0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14,
-  0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90, 0x21,
-  0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8, 0x48,
-  0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00,
-  0x51, 0x18, 0x00, 0x00, 0x8b, 0x00, 0x00, 0x00, 0x1b, 0xcc, 0x25, 0xf8,
-  0xff, 0xff, 0xff, 0xff, 0x01, 0x60, 0x00, 0x09, 0xa8, 0x88, 0x71, 0x78,
-  0x07, 0x79, 0x90, 0x87, 0x72, 0x18, 0x07, 0x7a, 0x60, 0x87, 0x7c, 0x68,
-  0x03, 0x79, 0x78, 0x87, 0x7a, 0x70, 0x07, 0x72, 0x28, 0x07, 0x72, 0x68,
-  0x03, 0x72, 0x48, 0x07, 0x7b, 0x48, 0x07, 0x72, 0x28, 0x87, 0x36, 0x98,
-  0x87, 0x78, 0x90, 0x07, 0x7a, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68,
-  0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e,
-  0xca, 0x01, 0x20, 0xc8, 0x21, 0x1d, 0xe6, 0x21, 0x1c, 0xc4, 0x81, 0x1d,
-  0xca, 0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xd2, 0x81, 0x1d, 0xda, 0x60, 0x1c,
-  0xc2, 0x81, 0x1d, 0xd8, 0x61, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98,
-  0x87, 0x72, 0x00, 0x08, 0x76, 0x28, 0x87, 0x79, 0x98, 0x87, 0x36, 0x80,
-  0x07, 0x79, 0x28, 0x87, 0x71, 0x48, 0x87, 0x79, 0x28, 0x87, 0x36, 0x30,
-  0x07, 0x78, 0x68, 0x87, 0x70, 0x20, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d,
-  0xe6, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xcc, 0x41, 0x1e,
-  0xc2, 0xa1, 0x1d, 0xca, 0xa1, 0x0d, 0xe0, 0xe1, 0x1d, 0xd2, 0xc1, 0x1d,
-  0xe8, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xca, 0x81, 0x1d, 0xd2, 0xa1, 0x1d,
-  0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x60, 0x70, 0x87, 0x77, 0x68,
-  0x03, 0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78, 0x78,
-  0x87, 0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72, 0x60,
-  0x87, 0x74, 0x68, 0x87, 0x36, 0x70, 0x87, 0x77, 0x70, 0x87, 0x36, 0x60,
-  0x87, 0x72, 0x08, 0x07, 0x73, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x48,
-  0x07, 0x77, 0x30, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68,
-  0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c,
-  0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xd4, 0xa1, 0x1e, 0xda, 0x01, 0x1e,
-  0xda, 0x80, 0x1e, 0xc2, 0x41, 0x1c, 0xd8, 0xa1, 0x1c, 0xe6, 0x01, 0x30,
-  0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68,
-  0x03, 0x77, 0x08, 0x07, 0x77, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68,
-  0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e,
-  0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x60, 0x1e, 0xd2, 0xe1, 0x1c,
-  0xdc, 0xa1, 0x1c, 0xc8, 0xa1, 0x0d, 0xf4, 0xa1, 0x1c, 0xe4, 0xe1, 0x1d,
-  0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e,
-  0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78,
-  0x87, 0x36, 0xa0, 0x07, 0x79, 0x08, 0x07, 0x78, 0x80, 0x87, 0x74, 0x70,
-  0x87, 0x73, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e,
-  0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xe6, 0x81, 0x1e, 0xc2, 0x61, 0x1c,
-  0xd6, 0xa1, 0x0d, 0xe0, 0x41, 0x1e, 0xde, 0x81, 0x1e, 0xca, 0x61, 0x1c,
-  0xe8, 0xe1, 0x1d, 0xe4, 0xa1, 0x0d, 0xc4, 0xa1, 0x1e, 0xcc, 0xc1, 0x1c,
-  0xca, 0x41, 0x1e, 0xda, 0x60, 0x1e, 0xd2, 0x41, 0x1f, 0xca, 0x01, 0xc0,
-  0x03, 0x80, 0xa8, 0x07, 0x77, 0x98, 0x87, 0x70, 0x30, 0x87, 0x72, 0x68,
-  0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00,
-  0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xa2, 0x1e, 0xe6, 0xa1, 0x1c,
-  0xda, 0x60, 0x1e, 0xde, 0xc1, 0x1c, 0xe8, 0xa1, 0x0d, 0xcc, 0x81, 0x1d,
-  0xde, 0x21, 0x1c, 0xe8, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28,
-  0x07, 0x60, 0x83, 0x21, 0x0c, 0xc0, 0x02, 0x54, 0x1b, 0x8c, 0x81, 0x00,
-  0x16, 0xa0, 0xda, 0x60, 0x10, 0x05, 0xb0, 0x00, 0xd5, 0x06, 0xa4, 0xf8,
-  0xff, 0xff, 0xff, 0xff, 0x01, 0x60, 0x00, 0x09, 0xa8, 0x36, 0x18, 0x46,
-  0x00, 0x2c, 0x40, 0xb5, 0xc1, 0x38, 0x04, 0x60, 0x01, 0x2a, 0x00, 0x00,
-  0x49, 0x18, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x13, 0x88, 0x40, 0x18,
-  0x88, 0x09, 0x43, 0x61, 0x1c, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00,
-  0x1e, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04,
-  0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14,
-  0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x4c, 0x33, 0x00,
-  0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00, 0x83, 0x08, 0x41, 0x70, 0x94,
-  0x34, 0x45, 0x94, 0x30, 0xf9, 0xff, 0x44, 0x5c, 0x13, 0x15, 0x11, 0xbf,
-  0x3d, 0xfc, 0xd3, 0x18, 0x01, 0x30, 0x88, 0x40, 0x04, 0x17, 0x49, 0x53,
-  0x44, 0x09, 0x93, 0xff, 0x4b, 0x00, 0xf3, 0x2c, 0x44, 0xf4, 0x4f, 0x63,
-  0x04, 0xc0, 0x20, 0x82, 0x21, 0x14, 0x23, 0x04, 0x31, 0xca, 0x21, 0x34,
-  0x47, 0x10, 0xcc, 0x11, 0x80, 0xc1, 0x30, 0x82, 0xb0, 0x14, 0x24, 0x94,
-  0x23, 0x14, 0x53, 0x80, 0xda, 0x40, 0x40, 0x0a, 0xac, 0x39, 0x02, 0x50,
-  0x18, 0x01, 0x00, 0x00, 0x13, 0xb2, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03,
-  0x3a, 0x68, 0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83,
-  0x76, 0x08, 0x87, 0x71, 0x78, 0x87, 0x79, 0xc0, 0x87, 0x38, 0x80, 0x03,
-  0x37, 0x88, 0x83, 0x38, 0x70, 0x03, 0x38, 0xd8, 0x70, 0x1b, 0xe5, 0xd0,
-  0x06, 0xf0, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0,
-  0x07, 0x76, 0x40, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0,
-  0x07, 0x78, 0xd0, 0x06, 0xe9, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80,
-  0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0,
-  0x07, 0x71, 0x60, 0x07, 0x6d, 0x90, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30,
-  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40,
-  0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60,
+  0x02, 0x2a, 0xa2, 0x21, 0x42, 0x21, 0x51, 0x0a, 0x4b, 0x93, 0x73, 0x31,
+  0x93, 0x0b, 0x3b, 0x6b, 0x2b, 0x73, 0xa3, 0xfb, 0x4a, 0x73, 0x83, 0xab,
+  0xa3, 0x63, 0x76, 0x56, 0xe6, 0x56, 0x26, 0x17, 0x46, 0x57, 0x46, 0x86,
+  0x82, 0x03, 0xf7, 0x36, 0x97, 0x46, 0x97, 0xf6, 0xe6, 0x46, 0x64, 0x27,
+  0xf3, 0x65, 0x96, 0x42, 0x25, 0x2c, 0x4d, 0xce, 0x65, 0xac, 0xcc, 0x8d,
+  0xae, 0x4c, 0x8e, 0x4f, 0x58, 0x9a, 0x9c, 0x0b, 0x5c, 0x99, 0xdc, 0x1c,
+  0x5c, 0xd9, 0x18, 0x5d, 0x9a, 0x5d, 0x19, 0x0d, 0x33, 0xb6, 0xb7, 0x30,
+  0x3a, 0x19, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x6e,
+  0x61, 0x6d, 0x65, 0x44, 0xe0, 0xde, 0xe6, 0xd2, 0xe8, 0xd2, 0xde, 0xdc,
+  0x86, 0x48, 0x86, 0x50, 0x50, 0x45, 0x55, 0x58, 0xc5, 0x55, 0x40, 0x05,
+  0x56, 0x64, 0x85, 0x46, 0xeb, 0xac, 0xcc, 0xad, 0x4c, 0x2e, 0x8c, 0xae,
+  0x8c, 0x0c, 0xa5, 0x66, 0xec, 0x8d, 0xed, 0x4d, 0x8e, 0xc8, 0x8e, 0xe6,
+  0xcb, 0x2c, 0x85, 0xc5, 0xd8, 0x1b, 0xdb, 0x9b, 0xdc, 0x10, 0xc9, 0x08,
+  0x0a, 0xaa, 0xe0, 0x0a, 0xab, 0xb8, 0x0a, 0xa8, 0x88, 0x8a, 0xac, 0xe8,
+  0x86, 0x10, 0xc5, 0x56, 0x78, 0x43, 0x0c, 0x02, 0x28, 0xa6, 0xe2, 0x1b,
+  0x11, 0xb1, 0x03, 0x3b, 0xd8, 0x43, 0x3b, 0xb8, 0x41, 0x3b, 0xbc, 0x03,
+  0x39, 0xd4, 0x03, 0x3b, 0x94, 0x83, 0x1b, 0x98, 0x03, 0x3b, 0x84, 0xc3,
+  0x39, 0xcc, 0xc3, 0x14, 0x21, 0x18, 0x46, 0x28, 0xec, 0xc0, 0x0e, 0xf6,
+  0xd0, 0x0e, 0x6e, 0x90, 0x0e, 0xe4, 0x50, 0x0e, 0xee, 0x40, 0x0f, 0x53,
+  0x82, 0x62, 0xc4, 0x12, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0x60, 0x0f, 0xe5,
+  0x20, 0x0f, 0xf3, 0x90, 0x0e, 0xef, 0xe0, 0x0e, 0x53, 0x02, 0x63, 0x04,
+  0x15, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0xc0, 0x0e, 0xe1, 0xe0, 0x0e, 0xe7,
+  0x50, 0x0f, 0xe1, 0x70, 0x0e, 0xe5, 0xf0, 0x0b, 0xf6, 0x50, 0x0e, 0xf2,
+  0x30, 0x0f, 0xe9, 0xf0, 0x0e, 0xee, 0x30, 0x25, 0x40, 0x46, 0x4c, 0xe1,
+  0x90, 0x0e, 0xf2, 0xe0, 0x06, 0xe3, 0xf0, 0x0e, 0xed, 0x00, 0x0f, 0xe9,
+  0xc0, 0x0e, 0xe5, 0xf0, 0x0b, 0xef, 0x00, 0x0f, 0xf4, 0x90, 0x0e, 0xef,
+  0xe0, 0x0e, 0xf3, 0x30, 0x65, 0x50, 0x18, 0x67, 0x04, 0x13, 0x0e, 0xe9,
+  0x20, 0x0f, 0x6e, 0x60, 0x0e, 0xf2, 0x10, 0x0e, 0xe7, 0xd0, 0x0e, 0xe5,
+  0xe0, 0x0e, 0xf4, 0x30, 0x25, 0x00, 0x03, 0x00, 0x00, 0x00, 0x79, 0x18,
+  0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1,
+  0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42,
+  0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f,
+  0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1,
+  0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84,
+  0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc,
+  0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70,
+  0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19,
+  0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f,
+  0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21,
+  0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc,
+  0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84,
+  0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37,
+  0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70,
+  0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77,
+  0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79,
+  0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e,
+  0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1,
+  0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81,
+  0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98,
+  0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88,
+  0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4,
+  0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72,
+  0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74,
+  0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e,
+  0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e,
+  0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21,
+  0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01,
+  0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc,
+  0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77,
+  0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e,
+  0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1,
+  0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61,
+  0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0,
+  0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0,
+  0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74,
+  0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e,
+  0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41,
+  0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50,
+  0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c,
+  0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc,
+  0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20, 0x00, 0x00, 0x05, 0x00,
+  0x00, 0x00, 0x06, 0x20, 0xb1, 0x5d, 0xf9, 0xb3, 0xce, 0x82, 0x0c, 0x7f,
+  0x11, 0x01, 0x06, 0x43, 0x34, 0x13, 0x00, 0x00, 0x00, 0x00, 0x61, 0x20,
+  0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x06, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00,
+  0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x50, 0x0a, 0x00, 0x00, 0xff, 0xff,
+  0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0x91, 0x02,
+  0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00,
+  0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10,
+  0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04,
+  0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10,
+  0x32, 0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a,
+  0x90, 0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07,
+  0xc8, 0x48, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00,
+  0x00, 0x00, 0x51, 0x18, 0x00, 0x00, 0x89, 0x00, 0x00, 0x00, 0x1b, 0xcc,
+  0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x60, 0x00, 0x09, 0xa8, 0x88,
+  0x71, 0x78, 0x07, 0x79, 0x90, 0x87, 0x72, 0x18, 0x07, 0x7a, 0x60, 0x87,
+  0x7c, 0x68, 0x03, 0x79, 0x78, 0x87, 0x7a, 0x70, 0x07, 0x72, 0x28, 0x07,
+  0x72, 0x68, 0x03, 0x72, 0x48, 0x07, 0x7b, 0x48, 0x07, 0x72, 0x28, 0x87,
+  0x36, 0x98, 0x87, 0x78, 0x90, 0x07, 0x7a, 0x68, 0x03, 0x73, 0x80, 0x87,
+  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xcc, 0x21, 0x1c, 0xd8,
+  0x61, 0x1e, 0xca, 0x01, 0x20, 0xc8, 0x21, 0x1d, 0xe6, 0x21, 0x1c, 0xc4,
+  0x81, 0x1d, 0xca, 0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xd2, 0x81, 0x1d, 0xda,
+  0x60, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0x61, 0x1e, 0x00, 0x73, 0x08, 0x07,
+  0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x76, 0x28, 0x87, 0x79, 0x98, 0x87,
+  0x36, 0x80, 0x07, 0x79, 0x28, 0x87, 0x71, 0x48, 0x87, 0x79, 0x28, 0x87,
+  0x36, 0x30, 0x07, 0x78, 0x68, 0x87, 0x70, 0x20, 0x07, 0xc0, 0x1c, 0xc2,
+  0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xcc,
+  0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca, 0xa1, 0x0d, 0xe0, 0xe1, 0x1d, 0xd2,
+  0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xca, 0x81, 0x1d, 0xd2,
+  0xa1, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x60, 0x70, 0x87,
+  0x77, 0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03,
+  0x78, 0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83,
+  0x72, 0x60, 0x87, 0x74, 0x68, 0x87, 0x36, 0x70, 0x87, 0x77, 0x70, 0x87,
+  0x36, 0x60, 0x87, 0x72, 0x08, 0x07, 0x73, 0x00, 0x08, 0x77, 0x78, 0x87,
+  0x36, 0x48, 0x07, 0x77, 0x30, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87,
+  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea,
+  0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xd4, 0xa1, 0x1e, 0xda,
+  0x01, 0x1e, 0xda, 0x80, 0x1e, 0xc2, 0x41, 0x1c, 0xd8, 0xa1, 0x1c, 0xe6,
+  0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x70, 0x87,
+  0x77, 0x68, 0x03, 0x77, 0x08, 0x07, 0x77, 0x98, 0x87, 0x36, 0x30, 0x07,
+  0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4,
+  0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x60, 0x1e, 0xd2,
+  0xe1, 0x1c, 0xdc, 0xa1, 0x1c, 0xc8, 0xa1, 0x0d, 0xf4, 0xa1, 0x1c, 0xe4,
+  0xe1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2,
+  0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08,
+  0x77, 0x78, 0x87, 0x36, 0xa0, 0x07, 0x79, 0x08, 0x07, 0x78, 0x80, 0x87,
+  0x74, 0x70, 0x87, 0x73, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07,
+  0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xe6, 0x81, 0x1e, 0xc2,
+  0x61, 0x1c, 0xd6, 0xa1, 0x0d, 0xe0, 0x41, 0x1e, 0xde, 0x81, 0x1e, 0xca,
+  0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0xa1, 0x0d, 0xc4, 0xa1, 0x1e, 0xcc,
+  0xc1, 0x1c, 0xca, 0x41, 0x1e, 0xda, 0x60, 0x1e, 0xd2, 0x41, 0x1f, 0xca,
+  0x01, 0xc0, 0x03, 0x80, 0xa8, 0x07, 0x77, 0x98, 0x87, 0x70, 0x30, 0x87,
+  0x72, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07,
+  0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xa2, 0x1e, 0xe6,
+  0xa1, 0x1c, 0xda, 0x60, 0x1e, 0xde, 0xc1, 0x1c, 0xe8, 0xa1, 0x0d, 0xcc,
+  0x81, 0x1d, 0xde, 0x21, 0x1c, 0xe8, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87,
+  0x79, 0x28, 0x07, 0x60, 0x83, 0x21, 0x10, 0xc0, 0x02, 0x54, 0x1b, 0x8c,
+  0xa1, 0x00, 0x16, 0xa0, 0xda, 0x80, 0x10, 0xff, 0xff, 0xff, 0xff, 0x3f,
+  0x00, 0x0c, 0x20, 0x01, 0xd5, 0x06, 0xa3, 0x08, 0x80, 0x05, 0xa8, 0x36,
+  0x18, 0x86, 0x00, 0x2c, 0x40, 0x05, 0x49, 0x18, 0x00, 0x00, 0x03, 0x00,
+  0x00, 0x00, 0x13, 0x86, 0x40, 0x18, 0x26, 0x0c, 0x44, 0x61, 0x00, 0x00,
+  0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x32, 0x22,
+  0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93,
+  0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84,
+  0xa4, 0x4c, 0x10, 0x44, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20,
+  0x00, 0x47, 0x49, 0x53, 0x44, 0x09, 0x93, 0xff, 0x4f, 0xc4, 0x35, 0x51,
+  0x11, 0xf1, 0xdb, 0xc3, 0x3f, 0x8d, 0x11, 0x00, 0x83, 0x08, 0x43, 0x70,
+  0x91, 0x34, 0x45, 0x94, 0x30, 0xf9, 0xbf, 0x04, 0x30, 0xcf, 0x42, 0x44,
+  0xff, 0x34, 0x46, 0x00, 0x0c, 0x22, 0x14, 0x42, 0x31, 0x42, 0x08, 0x82,
+  0x18, 0x3a, 0x73, 0x04, 0xc1, 0x1c, 0x01, 0x18, 0x0c, 0x23, 0x08, 0x4a,
+  0x41, 0x02, 0x31, 0x22, 0xad, 0x04, 0x88, 0x0d, 0x04, 0xa4, 0x80, 0x1a,
+  0x01, 0x00, 0x13, 0xb2, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68,
+  0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x76, 0x08,
+  0x87, 0x71, 0x78, 0x87, 0x79, 0xc0, 0x87, 0x38, 0x80, 0x03, 0x37, 0x88,
+  0x83, 0x38, 0x70, 0x03, 0x38, 0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06, 0xf0,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78,
+  0xd0, 0x06, 0xe9, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d,
+  0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71,
+  0x60, 0x07, 0x6d, 0x90, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72,
+  0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a,
+  0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e, 0x73,
+  0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d,
+  0x60, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76,
+  0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07, 0x7a,
+  0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x73,
+  0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d,
+  0x60, 0x0f, 0x74, 0x80, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x6d, 0x60, 0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07, 0x7a,
+  0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d,
+  0x60, 0x0f, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78,
+  0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x79,
+  0x20, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75,
+  0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72,
+  0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6,
+  0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a,
+  0x50, 0x07, 0x71, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07, 0x72,
+  0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71,
+  0x00, 0x07, 0x72, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71,
+  0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0x30, 0x84, 0x41, 0x00, 0x00, 0x08,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xc2, 0x34, 0x40, 0x00, 0x08, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x64, 0x81, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00,
+  0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09,
+  0x26, 0x47, 0xc6, 0x04, 0x43, 0x52, 0x25, 0x30, 0x02, 0x50, 0x04, 0x85,
+  0x50, 0x10, 0x65, 0x40, 0x6f, 0x2c, 0x61, 0x09, 0x00, 0x00, 0x79, 0x18,
+  0x00, 0x00, 0xcb, 0x00, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29,
+  0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x86,
+  0x42, 0x38, 0xc0, 0x83, 0x50, 0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a,
+  0x4b, 0xd3, 0x2b, 0x1b, 0x62, 0x28, 0x82, 0x23, 0x28, 0x05, 0xe5, 0x20,
+  0x08, 0x0e, 0x8e, 0xad, 0x0c, 0x84, 0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae,
+  0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x26, 0x06, 0x06, 0x26, 0xc6,
+  0x25, 0xc6, 0x06, 0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac,
+  0xac, 0x65, 0x26, 0x06, 0x06, 0x26, 0xc6, 0x25, 0xc6, 0x06, 0xc6, 0x25,
+  0x26, 0x65, 0x88, 0xe0, 0x10, 0x43, 0x0c, 0x45, 0x50, 0x0c, 0x65, 0x60,
+  0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36, 0x04, 0x71, 0x0e, 0x45, 0x50, 0x04,
+  0x65, 0xe0, 0x16, 0x96, 0x26, 0xe7, 0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6,
+  0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6, 0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96,
+  0x36, 0x17, 0x26, 0xc6, 0x56, 0x36, 0x44, 0x70, 0x12, 0x72, 0x61, 0x69,
+  0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61,
+  0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62,
+  0x6c, 0x65, 0x43, 0x04, 0x67, 0x61, 0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c,
+  0xbd, 0xb5, 0xc1, 0xa5, 0xb1, 0x95, 0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95,
+  0x89, 0xd5, 0x99, 0x99, 0x95, 0xc9, 0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1,
+  0x7d, 0x91, 0xa5, 0xcd, 0x85, 0x89, 0xb1, 0x95, 0x0d, 0x11, 0x9c, 0x86,
+  0x51, 0x58, 0x9a, 0x9c, 0x8b, 0x5c, 0x99, 0x1b, 0x59, 0x99, 0xdc, 0x17,
+  0x5d, 0x98, 0xdc, 0x59, 0x19, 0x1d, 0xa3, 0xb0, 0x34, 0x39, 0x97, 0x30,
+  0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0x2f, 0xb7, 0xb0, 0xb6, 0x32,
+  0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x43, 0x10, 0xe7, 0x51, 0x06,
+  0x07, 0x72, 0xa2, 0x21, 0x82, 0x23, 0x91, 0x09, 0x4b, 0x93, 0x73, 0x81,
+  0x7b, 0x9b, 0x4b, 0xa3, 0x4b, 0x7b, 0x73, 0xa3, 0x12, 0x96, 0x26, 0xe7,
+  0x32, 0x56, 0xe6, 0x46, 0x57, 0x26, 0x47, 0x29, 0x2c, 0x4d, 0xce, 0xc5,
+  0xed, 0xed, 0x0b, 0xae, 0x4c, 0x6e, 0x0e, 0xae, 0x6c, 0x8c, 0x2e, 0xcd,
+  0xae, 0x8c, 0x4c, 0x58, 0x9a, 0x9c, 0x4b, 0x98, 0xdc, 0xd9, 0x97, 0x5b,
+  0x58, 0x5b, 0x19, 0x11, 0xb8, 0xb7, 0xb9, 0x34, 0xba, 0xb4, 0x37, 0xb7,
+  0x21, 0x90, 0x32, 0x38, 0x94, 0x53, 0x39, 0x96, 0x03, 0x39, 0x91, 0x73,
+  0x39, 0x18, 0xa5, 0xb0, 0x34, 0x39, 0x17, 0x33, 0xb9, 0xb0, 0xb3, 0xb6,
+  0x32, 0x37, 0xba, 0xaf, 0x34, 0x37, 0xb8, 0x3a, 0x3a, 0x5a, 0x67, 0x65,
+  0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x35, 0x63, 0x6f, 0x6c,
+  0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66, 0x29, 0x7c, 0xc2, 0xd2, 0xe4,
+  0x5c, 0xe0, 0xca, 0xe4, 0xe6, 0xe0, 0xca, 0xc6, 0xe8, 0xd2, 0xec, 0xca,
+  0x58, 0x8c, 0xbd, 0xb1, 0xbd, 0xc9, 0x0d, 0x91, 0x14, 0xc1, 0xd1, 0x9c,
+  0xcd, 0xa9, 0x1c, 0xce, 0x81, 0x9c, 0xc8, 0xb9, 0x9c, 0x8e, 0xd9, 0x59,
+  0x99, 0x5b, 0x99, 0x5c, 0x18, 0x5d, 0x19, 0x19, 0x0a, 0x0e, 0x5d, 0x19,
+  0xde, 0xd8, 0xdb, 0x9b, 0x1c, 0x19, 0x91, 0x9d, 0xcc, 0x97, 0x59, 0x0a,
+  0x0d, 0x33, 0xb6, 0xb7, 0x30, 0x3a, 0x19, 0x22, 0x74, 0x65, 0x78, 0x63,
+  0x6f, 0x6f, 0x72, 0x64, 0x43, 0x24, 0x85, 0x70, 0x34, 0xe7, 0x73, 0x2a,
+  0x87, 0x73, 0x20, 0x07, 0x0c, 0x9c, 0xcb, 0x09, 0x03, 0x2e, 0x61, 0x69,
+  0x72, 0x2e, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x94, 0xc2, 0xd2,
+  0xe4, 0x5c, 0xd8, 0xde, 0xc6, 0xc2, 0xe8, 0xd2, 0xde, 0xdc, 0xbe, 0xd2,
+  0xdc, 0xc8, 0xca, 0xf0, 0xa8, 0x84, 0xa5, 0xc9, 0xb9, 0xcc, 0x85, 0xb5,
+  0xc1, 0xb1, 0x95, 0x11, 0xa3, 0x2b, 0xc3, 0xa3, 0xab, 0x93, 0x2b, 0x93,
+  0x21, 0xe3, 0x31, 0x63, 0x7b, 0x0b, 0xa3, 0x63, 0x01, 0x99, 0x0b, 0x6b,
+  0x83, 0x63, 0x2b, 0xf3, 0xe1, 0x40, 0x57, 0x86, 0x37, 0x84, 0x52, 0x0e,
+  0x67, 0x0c, 0x1c, 0x32, 0x50, 0x06, 0x45, 0x70, 0xca, 0xc0, 0x81, 0x1c,
+  0x33, 0x70, 0x2e, 0xe7, 0x0c, 0xb8, 0x84, 0xa5, 0xc9, 0xb9, 0xcc, 0x85,
+  0xb5, 0xc1, 0xb1, 0x95, 0xc9, 0xf1, 0x98, 0x0b, 0x6b, 0x83, 0x63, 0x2b,
+  0x93, 0x63, 0x30, 0x37, 0x44, 0x52, 0x0a, 0x27, 0x0d, 0x1c, 0x32, 0x50,
+  0x06, 0x45, 0x70, 0x20, 0x47, 0x0d, 0x9c, 0xcb, 0x59, 0x83, 0x21, 0x8a,
+  0x93, 0x39, 0x9e, 0x23, 0x06, 0x0e, 0x1a, 0x38, 0x6c, 0x30, 0xc4, 0x40,
+  0x00, 0x67, 0x72, 0xda, 0x60, 0x44, 0xc4, 0x0e, 0xec, 0x60, 0x0f, 0xed,
+  0xe0, 0x06, 0xed, 0xf0, 0x0e, 0xe4, 0x50, 0x0f, 0xec, 0x50, 0x0e, 0x6e,
+  0x60, 0x0e, 0xec, 0x10, 0x0e, 0xe7, 0x30, 0x0f, 0x53, 0x84, 0x60, 0x18,
+  0xa1, 0xb0, 0x03, 0x3b, 0xd8, 0x43, 0x3b, 0xb8, 0x41, 0x3a, 0x90, 0x43,
+  0x39, 0xb8, 0x03, 0x3d, 0x4c, 0x09, 0x8a, 0x11, 0x4b, 0x38, 0xa4, 0x83,
+  0x3c, 0xb8, 0x81, 0x3d, 0x94, 0x83, 0x3c, 0xcc, 0x43, 0x3a, 0xbc, 0x83,
+  0x3b, 0x4c, 0x09, 0x8c, 0x11, 0x54, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x01,
+  0x3b, 0x84, 0x83, 0x3b, 0x9c, 0x43, 0x3d, 0x84, 0xc3, 0x39, 0x94, 0xc3,
+  0x2f, 0xd8, 0x43, 0x39, 0xc8, 0xc3, 0x3c, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3,
+  0x94, 0x00, 0x19, 0x31, 0x85, 0x43, 0x3a, 0xc8, 0x83, 0x1b, 0x8c, 0xc3,
+  0x3b, 0xb4, 0x03, 0x3c, 0xa4, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x03,
+  0x3c, 0xd0, 0x43, 0x3a, 0xbc, 0x83, 0x3b, 0xcc, 0xc3, 0x94, 0x41, 0x61,
+  0x9c, 0x11, 0x4c, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xc8, 0x43,
+  0x38, 0x9c, 0x43, 0x3b, 0x94, 0x83, 0x3b, 0xd0, 0xc3, 0x94, 0xc0, 0x0d,
+  0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08,
+  0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38,
+  0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71,
+  0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c,
+  0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d,
+  0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d,
+  0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07,
+  0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87,
+  0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30,
+  0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10,
+  0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66,
+  0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c,
+  0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07,
+  0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87,
+  0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05,
+  0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87,
+  0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0,
+  0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4,
+  0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca,
+  0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39,
+  0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38,
+  0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c,
+  0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87,
+  0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87,
+  0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00,
+  0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20,
+  0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2,
+  0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4,
+  0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a,
+  0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07,
+  0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90,
+  0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8,
+  0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc,
+  0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b,
+  0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b,
+  0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87,
+  0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81,
+  0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30,
+  0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde,
+  0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39,
+  0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f,
+  0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20,
+  0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x06, 0x10, 0xb1, 0x5d, 0xf9, 0x73,
+  0xce, 0x83, 0xfd, 0x45, 0x04, 0x18, 0x0c, 0xd1, 0x4c, 0x16, 0xb0, 0x01,
+  0x48, 0xe4, 0x4b, 0x00, 0xf3, 0x2c, 0xc4, 0x3f, 0x11, 0xd7, 0x44, 0x45,
+  0xc4, 0x6f, 0x0f, 0x7e, 0x85, 0x17, 0xb7, 0x0d, 0x00, 0x00, 0x61, 0x20,
+  0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00,
+  0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xb4, 0x46, 0x00, 0x28, 0xd5, 0xc0,
+  0x08, 0x00, 0x81, 0x11, 0x00, 0x00, 0x23, 0x06, 0x8a, 0x10, 0x44, 0x46,
+  0x71, 0x0c, 0x84, 0x10, 0x58, 0x90, 0xc8, 0x27, 0x03, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00,
+  0x00, 0x00, 0xd4, 0x0c, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43,
+  0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0x32, 0x03, 0x00, 0x00, 0x0b, 0x82,
+  0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81,
+  0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01,
+  0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14,
+  0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08,
+  0x18, 0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4,
+  0x52, 0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8, 0x48, 0x11, 0x62,
+  0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18,
+  0x00, 0x00, 0x8e, 0x00, 0x00, 0x00, 0x1b, 0xcc, 0x25, 0xf8, 0xff, 0xff,
+  0xff, 0xff, 0x01, 0x60, 0x00, 0x09, 0xa8, 0x88, 0x71, 0x78, 0x07, 0x79,
+  0x90, 0x87, 0x72, 0x18, 0x07, 0x7a, 0x60, 0x87, 0x7c, 0x68, 0x03, 0x79,
+  0x78, 0x87, 0x7a, 0x70, 0x07, 0x72, 0x28, 0x07, 0x72, 0x68, 0x03, 0x72,
+  0x48, 0x07, 0x7b, 0x48, 0x07, 0x72, 0x28, 0x87, 0x36, 0x98, 0x87, 0x78,
+  0x90, 0x07, 0x7a, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70,
+  0xa0, 0x07, 0x74, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01,
+  0x20, 0xc8, 0x21, 0x1d, 0xe6, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0xa1,
+  0x0d, 0xe8, 0x21, 0x1c, 0xd2, 0x81, 0x1d, 0xda, 0x60, 0x1c, 0xc2, 0x81,
+  0x1d, 0xd8, 0x61, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72,
+  0x00, 0x08, 0x76, 0x28, 0x87, 0x79, 0x98, 0x87, 0x36, 0x80, 0x07, 0x79,
+  0x28, 0x87, 0x71, 0x48, 0x87, 0x79, 0x28, 0x87, 0x36, 0x30, 0x07, 0x78,
+  0x68, 0x87, 0x70, 0x20, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1,
+  0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xcc, 0x41, 0x1e, 0xc2, 0xa1,
+  0x1d, 0xca, 0xa1, 0x0d, 0xe0, 0xe1, 0x1d, 0xd2, 0xc1, 0x1d, 0xe8, 0xa1,
+  0x1c, 0xe4, 0xa1, 0x0d, 0xca, 0x81, 0x1d, 0xd2, 0xa1, 0x1d, 0x00, 0x7a,
+  0x90, 0x87, 0x7a, 0x28, 0x07, 0x60, 0x70, 0x87, 0x77, 0x68, 0x03, 0x73,
+  0x90, 0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78, 0x78, 0x87, 0x74,
+  0x70, 0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72, 0x60, 0x87, 0x74,
+  0x68, 0x87, 0x36, 0x70, 0x87, 0x77, 0x70, 0x87, 0x36, 0x60, 0x87, 0x72,
+  0x08, 0x07, 0x73, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x48, 0x07, 0x77,
+  0x30, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70,
+  0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2,
+  0x1d, 0xde, 0xa1, 0x0d, 0xd4, 0xa1, 0x1e, 0xda, 0x01, 0x1e, 0xda, 0x80,
+  0x1e, 0xc2, 0x41, 0x1c, 0xd8, 0xa1, 0x1c, 0xe6, 0x01, 0x30, 0x87, 0x70,
+  0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x77,
+  0x08, 0x07, 0x77, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76,
+  0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01,
+  0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x60, 0x1e, 0xd2, 0xe1, 0x1c, 0xdc, 0xa1,
+  0x1c, 0xc8, 0xa1, 0x0d, 0xf4, 0xa1, 0x1c, 0xe4, 0xe1, 0x1d, 0xe6, 0xa1,
+  0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01,
+  0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36,
+  0xa0, 0x07, 0x79, 0x08, 0x07, 0x78, 0x80, 0x87, 0x74, 0x70, 0x87, 0x73,
+  0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1,
+  0x1e, 0xca, 0x01, 0x20, 0xe6, 0x81, 0x1e, 0xc2, 0x61, 0x1c, 0xd6, 0xa1,
+  0x0d, 0xe0, 0x41, 0x1e, 0xde, 0x81, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0xe1,
+  0x1d, 0xe4, 0xa1, 0x0d, 0xc4, 0xa1, 0x1e, 0xcc, 0xc1, 0x1c, 0xca, 0x41,
+  0x1e, 0xda, 0x60, 0x1e, 0xd2, 0x41, 0x1f, 0xca, 0x01, 0xc0, 0x03, 0x80,
+  0xa8, 0x07, 0x77, 0x98, 0x87, 0x70, 0x30, 0x87, 0x72, 0x68, 0x03, 0x73,
+  0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41,
+  0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xa2, 0x1e, 0xe6, 0xa1, 0x1c, 0xda, 0x60,
+  0x1e, 0xde, 0xc1, 0x1c, 0xe8, 0xa1, 0x0d, 0xcc, 0x81, 0x1d, 0xde, 0x21,
+  0x1c, 0xe8, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x60,
+  0x83, 0x21, 0x10, 0xc0, 0x02, 0x54, 0x1b, 0x8c, 0xa1, 0x00, 0x16, 0xa0,
+  0xda, 0x60, 0x10, 0x07, 0xb0, 0x00, 0xd5, 0x06, 0xa3, 0xf8, 0xff, 0xff,
+  0xff, 0xff, 0x01, 0x90, 0x00, 0x6a, 0x03, 0x62, 0xfc, 0xff, 0xff, 0xff,
+  0xff, 0x00, 0x30, 0x80, 0x04, 0x54, 0x1b, 0x8c, 0x23, 0x00, 0x16, 0xa0,
+  0xda, 0x60, 0x20, 0x02, 0xb0, 0x00, 0x15, 0x00, 0x00, 0x00, 0x49, 0x18,
+  0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x13, 0x88, 0x40, 0x18, 0x88, 0x09,
+  0x41, 0x31, 0x61, 0x30, 0x0e, 0x04, 0x89, 0x20, 0x00, 0x00, 0x30, 0x00,
+  0x00, 0x00, 0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22,
+  0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c,
+  0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x78, 0x33, 0x00, 0xc3, 0x08,
+  0x04, 0x30, 0x8c, 0x20, 0x00, 0xc3, 0x08, 0x03, 0x70, 0x90, 0x34, 0x45,
+  0x94, 0x30, 0xf9, 0xb2, 0xfb, 0x76, 0x84, 0xe0, 0x0c, 0x04, 0x22, 0xc6,
+  0x18, 0x63, 0x10, 0x81, 0x10, 0x8e, 0x92, 0xa6, 0x88, 0x12, 0x26, 0xff,
+  0x9f, 0x88, 0x6b, 0xa2, 0x22, 0xe2, 0xb7, 0x87, 0x7f, 0x1a, 0x23, 0x00,
+  0x06, 0x11, 0x8c, 0xe0, 0x34, 0x69, 0x8a, 0x28, 0x61, 0xf2, 0xff, 0x89,
+  0xb8, 0x26, 0x2a, 0x22, 0x7e, 0x7b, 0xf8, 0x81, 0x28, 0x02, 0xb0, 0x7f,
+  0x1a, 0x23, 0x00, 0x06, 0x11, 0x90, 0xe0, 0x22, 0x69, 0x8a, 0x28, 0x61,
+  0xf2, 0x7f, 0x09, 0x60, 0x9e, 0x85, 0x88, 0xfe, 0x69, 0x8c, 0x00, 0x18,
+  0x44, 0x50, 0x84, 0x82, 0x84, 0x10, 0x44, 0x39, 0x69, 0x11, 0x2b, 0x03,
+  0x18, 0x83, 0xdc, 0x1c, 0x01, 0x18, 0xcc, 0x11, 0x04, 0xc3, 0x08, 0x02,
+  0x54, 0x92, 0x90, 0x96, 0x80, 0x51, 0x46, 0x40, 0xb3, 0x20, 0xe1, 0x2c,
+  0x11, 0x65, 0x04, 0x54, 0x07, 0x02, 0x52, 0x00, 0x0e, 0x23, 0x0c, 0xd0,
+  0x20, 0x42, 0x20, 0xcc, 0x11, 0x80, 0xc2, 0x20, 0xc2, 0x20, 0x8c, 0x00,
+  0x00, 0x00, 0x13, 0xb2, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68,
+  0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x76, 0x08,
+  0x87, 0x71, 0x78, 0x87, 0x79, 0xc0, 0x87, 0x38, 0x80, 0x03, 0x37, 0x88,
+  0x83, 0x38, 0x70, 0x03, 0x38, 0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06, 0xf0,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78,
+  0xd0, 0x06, 0xe9, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d,
+  0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71,
+  0x60, 0x07, 0x6d, 0x90, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72,
+  0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a,
+  0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e, 0x73,
+  0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d,
+  0x60, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76,
+  0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07, 0x7a,
+  0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x73,
+  0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d,
+  0x60, 0x0f, 0x74, 0x80, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x6d, 0x60, 0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07, 0x7a,
+  0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d,
+  0x60, 0x0f, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78,
+  0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x79,
+  0x20, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75,
+  0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72,
+  0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6,
+  0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a,
+  0x50, 0x07, 0x71, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07, 0x72,
+  0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71,
+  0x00, 0x07, 0x72, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71,
+  0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0x30, 0x84, 0x69, 0x00, 0x00, 0x08,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xc2, 0x3c, 0x40, 0x00, 0x08, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x0c, 0x61, 0x28, 0x20, 0x00, 0x06, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x86, 0x30, 0x16, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x59, 0x20, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x32, 0x1e,
+  0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04,
+  0x43, 0x82, 0x25, 0x30, 0x02, 0x50, 0x20, 0x45, 0x50, 0x08, 0x05, 0x18,
+  0x50, 0x10, 0x65, 0x50, 0x40, 0x05, 0x56, 0x0a, 0xc5, 0x40, 0x78, 0x2c,
+  0x61, 0x09, 0x00, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x14, 0x01,
+  0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab,
+  0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x06, 0x74, 0x5c, 0x00, 0x06,
+  0x51, 0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b,
+  0x62, 0x40, 0xc4, 0x25, 0x40, 0x08, 0xe5, 0x20, 0x08, 0x0e, 0x8e, 0xad,
+  0x0c, 0x84, 0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed,
+  0xcd, 0x0d, 0x64, 0x26, 0x06, 0x06, 0x26, 0xc6, 0x25, 0xc6, 0x06, 0x06,
+  0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26, 0x06,
+  0x06, 0x26, 0xc6, 0x25, 0xc6, 0x06, 0xc6, 0x25, 0x26, 0x65, 0x88, 0x70,
+  0x11, 0x43, 0x0c, 0x88, 0x80, 0x14, 0xa8, 0x60, 0xd1, 0x54, 0x46, 0x17,
+  0xc6, 0x36, 0x04, 0xb9, 0x0e, 0x88, 0x80, 0x08, 0xa8, 0xe0, 0x16, 0x96,
+  0x26, 0xe7, 0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56,
+  0xe6, 0xf6, 0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96, 0x36, 0x17, 0x26, 0xc6,
+  0x56, 0x36, 0x44, 0xb8, 0x12, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f,
+  0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d,
+  0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x84,
+  0x6b, 0x61, 0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5, 0xc1, 0xa5,
+  0xb1, 0x95, 0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5, 0x99, 0x99,
+  0x95, 0xc9, 0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x91, 0xa5, 0xcd,
+  0x85, 0x89, 0xb1, 0x95, 0x0d, 0x11, 0xae, 0x86, 0x51, 0x58, 0x9a, 0x9c,
+  0x8b, 0x5c, 0x99, 0x1b, 0x59, 0x99, 0xdc, 0x17, 0x5d, 0x98, 0xdc, 0x59,
+  0x19, 0x1d, 0xa3, 0xb0, 0x34, 0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba,
+  0x3c, 0xb8, 0xb2, 0x2f, 0xb7, 0xb0, 0xb6, 0x32, 0x1a, 0x66, 0x6c, 0x6f,
+  0x61, 0x74, 0x34, 0x43, 0x90, 0xeb, 0x81, 0x8a, 0x0b, 0xba, 0xa2, 0x21,
+  0xc2, 0x25, 0x91, 0x09, 0x4b, 0x93, 0x73, 0x81, 0x7b, 0x9b, 0x4b, 0xa3,
+  0x4b, 0x7b, 0x73, 0xa3, 0x12, 0x96, 0x26, 0xe7, 0x32, 0x56, 0xe6, 0x46,
+  0x57, 0x26, 0x47, 0x29, 0x2c, 0x4d, 0xce, 0xc5, 0xed, 0xed, 0x0b, 0xae,
+  0x4c, 0x6e, 0x0e, 0xae, 0x6c, 0x8c, 0x2e, 0xcd, 0xae, 0x8c, 0x4c, 0x58,
+  0x9a, 0x9c, 0x4b, 0x98, 0xdc, 0xd9, 0x97, 0x5b, 0x58, 0x5b, 0x19, 0x11,
+  0xb8, 0xb7, 0xb9, 0x34, 0xba, 0xb4, 0x37, 0xb7, 0x21, 0x10, 0x54, 0x5c,
+  0xd4, 0x55, 0x5d, 0xd6, 0x05, 0x5d, 0xd1, 0x75, 0x5d, 0x18, 0xa5, 0xb0,
+  0x34, 0x39, 0x17, 0x33, 0xb9, 0xb0, 0xb3, 0xb6, 0x32, 0x37, 0xba, 0xaf,
+  0x34, 0x37, 0xb8, 0x3a, 0x3a, 0x5a, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61,
+  0x74, 0x65, 0x64, 0x28, 0x35, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44, 0x76,
+  0x34, 0x5f, 0x66, 0x29, 0x7c, 0xc2, 0xd2, 0xe4, 0x5c, 0xe0, 0xca, 0xe4,
+  0xe6, 0xe0, 0xca, 0xc6, 0xe8, 0xd2, 0xec, 0xca, 0x58, 0x8c, 0xbd, 0xb1,
+  0xbd, 0xc9, 0x0d, 0x91, 0x20, 0xe2, 0xd2, 0xae, 0xed, 0xaa, 0x2e, 0xee,
+  0x82, 0xae, 0xe8, 0xba, 0xae, 0x8e, 0xd9, 0x59, 0x99, 0x5b, 0x99, 0x5c,
+  0x18, 0x5d, 0x19, 0x19, 0x0a, 0x0e, 0x5d, 0x19, 0xde, 0xd8, 0xdb, 0x9b,
+  0x1c, 0x19, 0x91, 0x9d, 0xcc, 0x97, 0x59, 0x0a, 0x0d, 0x33, 0xb6, 0xb7,
+  0x30, 0x3a, 0x19, 0x22, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64,
+  0x43, 0x24, 0xe8, 0xb8, 0xb4, 0xeb, 0xbb, 0xaa, 0x8b, 0xbb, 0xa0, 0x0b,
+  0x0c, 0xae, 0xeb, 0x0a, 0x03, 0x2a, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75,
+  0x66, 0x66, 0x65, 0x72, 0x7c, 0xc2, 0xd2, 0xe4, 0x5c, 0xc4, 0xea, 0xcc,
+  0xcc, 0xca, 0xe4, 0xbe, 0xe6, 0xd2, 0xf4, 0xca, 0x28, 0x85, 0xa5, 0xc9,
+  0xb9, 0xb0, 0xbd, 0x8d, 0x85, 0xd1, 0xa5, 0xbd, 0xb9, 0x7d, 0xa5, 0xb9,
+  0x91, 0x95, 0xe1, 0x11, 0x09, 0x4b, 0x93, 0x73, 0x91, 0x2b, 0x0b, 0x23,
+  0x23, 0x15, 0x96, 0x26, 0xe7, 0x32, 0x47, 0x27, 0x57, 0x37, 0x46, 0xf7,
+  0x45, 0x97, 0x07, 0x57, 0xf6, 0x95, 0xe6, 0x66, 0xf6, 0x46, 0xc3, 0x8c,
+  0xed, 0x2d, 0x8c, 0x6e, 0x86, 0xc6, 0x9b, 0x99, 0xd9, 0x5c, 0x19, 0x1d,
+  0x0d, 0xa9, 0xb1, 0xb7, 0x32, 0x33, 0x33, 0x1a, 0x47, 0x63, 0x6f, 0x65,
+  0x66, 0x66, 0x34, 0x84, 0xc6, 0xde, 0xca, 0xcc, 0xcc, 0x86, 0xa0, 0x01,
+  0x54, 0x40, 0x06, 0x54, 0x5c, 0x68, 0x70, 0xa5, 0x01, 0x64, 0x40, 0x06,
+  0x54, 0x5c, 0x68, 0x70, 0xa9, 0x01, 0xc4, 0x40, 0x06, 0x54, 0x5c, 0x68,
+  0x70, 0xad, 0x01, 0xd4, 0x40, 0x06, 0x54, 0x5c, 0x68, 0x70, 0xb1, 0x01,
+  0xa3, 0xb0, 0x34, 0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8,
+  0xb2, 0xaf, 0xb9, 0x34, 0xbd, 0x32, 0x5e, 0x61, 0x69, 0x72, 0x2e, 0x61,
+  0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67,
+  0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x4c, 0xb2, 0xaa, 0xac, 0x88, 0xca,
+  0xc6, 0xde, 0xc8, 0xca, 0x68, 0x90, 0x95, 0x8d, 0xbd, 0x91, 0x95, 0x0d,
+  0x21, 0x03, 0x68, 0xb9, 0xc6, 0xe0, 0x22, 0x03, 0x28, 0xb9, 0xca, 0x00,
+  0x22, 0x20, 0xe2, 0x32, 0x83, 0xeb, 0x0c, 0xae, 0x36, 0xb8, 0xdc, 0x00,
+  0x4a, 0xae, 0x37, 0x80, 0x8c, 0x0b, 0xba, 0xe0, 0xe0, 0xba, 0xae, 0x38,
+  0xe0, 0x12, 0x96, 0x26, 0xe7, 0x42, 0x57, 0x86, 0x47, 0x57, 0x27, 0x57,
+  0x46, 0x25, 0x2c, 0x4d, 0xce, 0x65, 0x2e, 0xac, 0x0d, 0x8e, 0xad, 0x8c,
+  0x18, 0x5d, 0x19, 0x1e, 0x5d, 0x9d, 0x5c, 0x99, 0x0c, 0x19, 0x8f, 0x19,
+  0xdb, 0x5b, 0x18, 0x1d, 0x0b, 0xc8, 0x5c, 0x58, 0x1b, 0x1c, 0x5b, 0x99,
+  0x0f, 0x09, 0xba, 0x32, 0xbc, 0xac, 0x21, 0x14, 0x84, 0x5c, 0x73, 0x70,
+  0x95, 0x01, 0x54, 0x40, 0xc4, 0x45, 0x07, 0x17, 0x74, 0xd5, 0xc1, 0x75,
+  0x5d, 0x76, 0x40, 0x8f, 0xae, 0x0c, 0x8f, 0xae, 0x4e, 0xae, 0x4c, 0x86,
+  0xec, 0x2b, 0x4c, 0x4e, 0x2e, 0x2c, 0x8f, 0xc7, 0x8c, 0xed, 0x2d, 0x8c,
+  0x8e, 0x05, 0x64, 0x2e, 0xac, 0x0d, 0x8e, 0xad, 0xcc, 0x87, 0x05, 0x5d,
+  0x19, 0x5e, 0x95, 0xd5, 0x10, 0x0a, 0x72, 0xae, 0x39, 0xb8, 0xca, 0x00,
+  0x22, 0x20, 0xe2, 0xa2, 0x83, 0x0b, 0xba, 0xf0, 0xe0, 0xba, 0xae, 0x3c,
+  0xe0, 0x12, 0x96, 0x26, 0xe7, 0x32, 0x17, 0xd6, 0x06, 0xc7, 0x56, 0x26,
+  0xc7, 0x63, 0x2e, 0xac, 0x0d, 0x8e, 0xad, 0x4c, 0x8e, 0xc1, 0xdc, 0x10,
+  0x09, 0x7a, 0xae, 0x3d, 0xb8, 0xca, 0x00, 0x2a, 0x20, 0xe2, 0x82, 0x2e,
+  0x3e, 0xb8, 0xae, 0xab, 0x0f, 0x86, 0x38, 0x57, 0x76, 0x79, 0x97, 0x18,
+  0x5c, 0x72, 0x70, 0xdd, 0xc1, 0xa5, 0x07, 0x97, 0x1f, 0x0c, 0x31, 0x1a,
+  0xe0, 0x9a, 0xae, 0x3f, 0x18, 0x11, 0xb1, 0x03, 0x3b, 0xd8, 0x43, 0x3b,
+  0xb8, 0x41, 0x3b, 0xbc, 0x03, 0x39, 0xd4, 0x03, 0x3b, 0x94, 0x83, 0x1b,
+  0x98, 0x03, 0x3b, 0x84, 0xc3, 0x39, 0xcc, 0xc3, 0x14, 0x21, 0x18, 0x46,
+  0x28, 0xec, 0xc0, 0x0e, 0xf6, 0xd0, 0x0e, 0x6e, 0x90, 0x0e, 0xe4, 0x50,
+  0x0e, 0xee, 0x40, 0x0f, 0x53, 0x82, 0x62, 0xc4, 0x12, 0x0e, 0xe9, 0x20,
+  0x0f, 0x6e, 0x60, 0x0f, 0xe5, 0x20, 0x0f, 0xf3, 0x90, 0x0e, 0xef, 0xe0,
+  0x0e, 0x53, 0x02, 0x63, 0x04, 0x15, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0xc0,
+  0x0e, 0xe1, 0xe0, 0x0e, 0xe7, 0x50, 0x0f, 0xe1, 0x70, 0x0e, 0xe5, 0xf0,
+  0x0b, 0xf6, 0x50, 0x0e, 0xf2, 0x30, 0x0f, 0xe9, 0xf0, 0x0e, 0xee, 0x30,
+  0x25, 0x40, 0x46, 0x4c, 0xe1, 0x90, 0x0e, 0xf2, 0xe0, 0x06, 0xe3, 0xf0,
+  0x0e, 0xed, 0x00, 0x0f, 0xe9, 0xc0, 0x0e, 0xe5, 0xf0, 0x0b, 0xef, 0x00,
+  0x0f, 0xf4, 0x90, 0x0e, 0xef, 0xe0, 0x0e, 0xf3, 0x30, 0x65, 0x50, 0x18,
+  0x67, 0x04, 0x13, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0x60, 0x0e, 0xf2, 0x10,
+  0x0e, 0xe7, 0xd0, 0x0e, 0xe5, 0xe0, 0x0e, 0xf4, 0x30, 0x25, 0x00, 0x05,
+  0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08,
+  0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38,
+  0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71,
+  0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c,
+  0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d,
+  0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d,
+  0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07,
+  0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87,
+  0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30,
+  0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10,
+  0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66,
+  0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c,
+  0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07,
+  0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87,
+  0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05,
+  0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87,
+  0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0,
+  0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4,
+  0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca,
+  0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39,
+  0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38,
+  0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c,
+  0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87,
+  0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87,
+  0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00,
+  0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20,
+  0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2,
+  0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4,
+  0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a,
+  0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07,
+  0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90,
+  0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8,
+  0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc,
+  0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b,
+  0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b,
+  0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87,
+  0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81,
+  0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30,
+  0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde,
+  0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39,
+  0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f,
+  0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20,
+  0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x26, 0x10, 0x06, 0x00, 0x12, 0xf9,
+  0x12, 0xc0, 0x3c, 0x0b, 0xf1, 0x4f, 0xc4, 0x35, 0x51, 0x11, 0xf1, 0xdb,
+  0xc3, 0x0f, 0x44, 0x11, 0x80, 0xf9, 0x15, 0x5e, 0xdc, 0xb6, 0x05, 0x34,
+  0x00, 0x12, 0xf9, 0x83, 0x33, 0xf9, 0xd5, 0x5d, 0xdc, 0xb6, 0x0d, 0x6c,
+  0x00, 0x12, 0xf9, 0x12, 0xc0, 0x3c, 0x0b, 0xf1, 0x4f, 0xc4, 0x35, 0x51,
+  0x11, 0xf1, 0xdb, 0x83, 0x5f, 0xe1, 0xc5, 0x6d, 0x1b, 0x00, 0xc4, 0x76,
+  0xe5, 0x2f, 0xbb, 0xef, 0x5f, 0x44, 0x80, 0xc1, 0x10, 0xcd, 0x04, 0x00,
+  0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x13, 0x04,
+  0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0xb4, 0x47,
+  0x00, 0x28, 0xcf, 0x31, 0x14, 0x5d, 0x37, 0xd6, 0x00, 0x04, 0x02, 0xc9,
+  0x11, 0x00, 0x8a, 0x23, 0x00, 0x04, 0x67, 0x00, 0x28, 0xd6, 0x00, 0x85,
+  0x39, 0x08, 0x31, 0x10, 0x03, 0x31, 0x08, 0x83, 0x19, 0x00, 0x02, 0x63,
+  0x04, 0x20, 0x08, 0x82, 0xf8, 0x37, 0x03, 0x30, 0x02, 0x00, 0x23, 0x06,
+  0xca, 0x10, 0x84, 0xc1, 0xd3, 0x44, 0x46, 0x82, 0x04, 0x83, 0x0c, 0x41,
+  0xc1, 0x8c, 0x18, 0x2c, 0x43, 0x40, 0x06, 0xd0, 0x33, 0x85, 0x01, 0xb2,
+  0x28, 0xc3, 0x18, 0x42, 0x20, 0x06, 0x73, 0x0c, 0x43, 0x40, 0x06, 0x23,
+  0x06, 0xcb, 0x10, 0x9c, 0xc1, 0x24, 0x59, 0x65, 0xb0, 0x38, 0x8d, 0x31,
+  0x86, 0x10, 0x94, 0xc1, 0x1c, 0xc3, 0x10, 0x90, 0xc1, 0x61, 0x7a, 0x29,
+  0x28, 0x83, 0x0c, 0x81, 0x43, 0x19, 0x11, 0xc0, 0x67, 0xbc, 0x81, 0xc3,
+  0xd8, 0xe0, 0x02, 0xbd, 0x14, 0x94, 0x41, 0x86, 0x60, 0xca, 0x46, 0x0c,
+  0x0a, 0x21, 0x98, 0x83, 0x22, 0x18, 0x6f, 0x08, 0x83, 0xce, 0x0d, 0x2e,
+  0xd0, 0x4b, 0x41, 0x19, 0x64, 0x08, 0x30, 0x6f, 0xc4, 0xa0, 0x10, 0x02,
+  0x3c, 0x50, 0x82, 0xf1, 0x06, 0x33, 0x10, 0x83, 0x37, 0xb8, 0x40, 0x2f,
+  0x05, 0x65, 0x90, 0x21, 0xe8, 0xc6, 0x60, 0xc4, 0xa0, 0x10, 0x82, 0x3e,
+  0x78, 0x82, 0x39, 0x06, 0x30, 0x58, 0xf4, 0x60, 0x8e, 0x21, 0x38, 0xf8,
+  0x60, 0x8e, 0x21, 0x18, 0xf4, 0xc0, 0x02, 0x38, 0x90, 0x4f, 0x06, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00,
+  0x00, 0x00, 0x60, 0x0c, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43,
+  0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0x15, 0x03, 0x00, 0x00, 0x0b, 0x82,
+  0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81,
+  0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01,
+  0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14,
+  0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08,
+  0x18, 0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4,
+  0x52, 0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8, 0x48, 0x11, 0x62,
+  0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18,
+  0x00, 0x00, 0x8f, 0x00, 0x00, 0x00, 0x1b, 0xcc, 0x25, 0xf8, 0xff, 0xff,
+  0xff, 0xff, 0x01, 0x60, 0x00, 0x09, 0xa8, 0x88, 0x71, 0x78, 0x07, 0x79,
+  0x90, 0x87, 0x72, 0x18, 0x07, 0x7a, 0x60, 0x87, 0x7c, 0x68, 0x03, 0x79,
+  0x78, 0x87, 0x7a, 0x70, 0x07, 0x72, 0x28, 0x07, 0x72, 0x68, 0x03, 0x72,
+  0x48, 0x07, 0x7b, 0x48, 0x07, 0x72, 0x28, 0x87, 0x36, 0x98, 0x87, 0x78,
+  0x90, 0x07, 0x7a, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70,
+  0xa0, 0x07, 0x74, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01,
+  0x20, 0xc8, 0x21, 0x1d, 0xe6, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0xa1,
+  0x0d, 0xe8, 0x21, 0x1c, 0xd2, 0x81, 0x1d, 0xda, 0x60, 0x1c, 0xc2, 0x81,
+  0x1d, 0xd8, 0x61, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72,
+  0x00, 0x08, 0x76, 0x28, 0x87, 0x79, 0x98, 0x87, 0x36, 0x80, 0x07, 0x79,
+  0x28, 0x87, 0x71, 0x48, 0x87, 0x79, 0x28, 0x87, 0x36, 0x30, 0x07, 0x78,
+  0x68, 0x87, 0x70, 0x20, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1,
+  0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xcc, 0x41, 0x1e, 0xc2, 0xa1,
+  0x1d, 0xca, 0xa1, 0x0d, 0xe0, 0xe1, 0x1d, 0xd2, 0xc1, 0x1d, 0xe8, 0xa1,
+  0x1c, 0xe4, 0xa1, 0x0d, 0xca, 0x81, 0x1d, 0xd2, 0xa1, 0x1d, 0x00, 0x7a,
+  0x90, 0x87, 0x7a, 0x28, 0x07, 0x60, 0x70, 0x87, 0x77, 0x68, 0x03, 0x73,
+  0x90, 0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78, 0x78, 0x87, 0x74,
+  0x70, 0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72, 0x60, 0x87, 0x74,
+  0x68, 0x87, 0x36, 0x70, 0x87, 0x77, 0x70, 0x87, 0x36, 0x60, 0x87, 0x72,
+  0x08, 0x07, 0x73, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x48, 0x07, 0x77,
+  0x30, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70,
+  0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2,
+  0x1d, 0xde, 0xa1, 0x0d, 0xd4, 0xa1, 0x1e, 0xda, 0x01, 0x1e, 0xda, 0x80,
+  0x1e, 0xc2, 0x41, 0x1c, 0xd8, 0xa1, 0x1c, 0xe6, 0x01, 0x30, 0x87, 0x70,
+  0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x77,
+  0x08, 0x07, 0x77, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76,
+  0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01,
+  0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x60, 0x1e, 0xd2, 0xe1, 0x1c, 0xdc, 0xa1,
+  0x1c, 0xc8, 0xa1, 0x0d, 0xf4, 0xa1, 0x1c, 0xe4, 0xe1, 0x1d, 0xe6, 0xa1,
+  0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01,
+  0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36,
+  0xa0, 0x07, 0x79, 0x08, 0x07, 0x78, 0x80, 0x87, 0x74, 0x70, 0x87, 0x73,
+  0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1,
+  0x1e, 0xca, 0x01, 0x20, 0xe6, 0x81, 0x1e, 0xc2, 0x61, 0x1c, 0xd6, 0xa1,
+  0x0d, 0xe0, 0x41, 0x1e, 0xde, 0x81, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0xe1,
+  0x1d, 0xe4, 0xa1, 0x0d, 0xc4, 0xa1, 0x1e, 0xcc, 0xc1, 0x1c, 0xca, 0x41,
+  0x1e, 0xda, 0x60, 0x1e, 0xd2, 0x41, 0x1f, 0xca, 0x01, 0xc0, 0x03, 0x80,
+  0xa8, 0x07, 0x77, 0x98, 0x87, 0x70, 0x30, 0x87, 0x72, 0x68, 0x03, 0x73,
+  0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41,
+  0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xa2, 0x1e, 0xe6, 0xa1, 0x1c, 0xda, 0x60,
+  0x1e, 0xde, 0xc1, 0x1c, 0xe8, 0xa1, 0x0d, 0xcc, 0x81, 0x1d, 0xde, 0x21,
+  0x1c, 0xe8, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x60,
+  0x83, 0x21, 0x10, 0xc0, 0x02, 0x54, 0x1b, 0x8c, 0xa1, 0x00, 0x16, 0xa0,
+  0xda, 0x60, 0x10, 0x06, 0xb0, 0x00, 0xd5, 0x06, 0xa3, 0x38, 0x80, 0x05,
+  0xa8, 0x36, 0x18, 0xc6, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x80, 0x04, 0x50,
+  0x1b, 0x90, 0xe3, 0xff, 0xff, 0xff, 0xff, 0x07, 0x80, 0x01, 0x24, 0xa0,
+  0xda, 0x60, 0x20, 0x01, 0xb0, 0x00, 0xd5, 0x06, 0x23, 0x11, 0x80, 0x05,
+  0xa8, 0x00, 0x49, 0x18, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x13, 0x8a,
+  0x40, 0x18, 0x88, 0x62, 0x42, 0x60, 0x4c, 0x18, 0x0e, 0x24, 0x01, 0x00,
+  0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x32, 0x22,
+  0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93,
+  0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84,
+  0xa4, 0x4c, 0x10, 0x68, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20,
+  0x00, 0xc3, 0x08, 0x03, 0x70, 0x90, 0x34, 0x45, 0x94, 0x30, 0xf9, 0xb2,
+  0xfb, 0x76, 0x84, 0xe0, 0x0c, 0x04, 0x22, 0xc6, 0x18, 0x63, 0x10, 0x81,
+  0x10, 0x8e, 0x92, 0xa6, 0x88, 0x12, 0x26, 0xff, 0x9f, 0x88, 0x6b, 0xa2,
+  0x22, 0xe2, 0xb7, 0x87, 0x7f, 0x1a, 0x23, 0x00, 0x06, 0x11, 0x8c, 0xe0,
+  0x22, 0x69, 0x8a, 0x28, 0x61, 0xf2, 0x7f, 0x09, 0x60, 0x9e, 0x85, 0x88,
+  0xfe, 0x69, 0x8c, 0x00, 0x18, 0x44, 0x40, 0x84, 0x82, 0x84, 0x10, 0x44,
+  0x39, 0x27, 0x91, 0x2a, 0x03, 0x18, 0x83, 0xd8, 0x1c, 0x41, 0x30, 0x47,
+  0x00, 0x06, 0xc3, 0x08, 0xc2, 0x53, 0x90, 0x70, 0x92, 0x70, 0xd0, 0x01,
+  0x8a, 0x03, 0x01, 0x29, 0xf0, 0x86, 0x11, 0x86, 0x67, 0x10, 0x21, 0x10,
+  0xe6, 0x08, 0x40, 0x61, 0x10, 0x61, 0x10, 0x46, 0x00, 0x00, 0x13, 0xb2,
+  0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70, 0x80, 0x07,
+  0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x76, 0x08, 0x87, 0x71, 0x78, 0x87,
+  0x79, 0xc0, 0x87, 0x38, 0x80, 0x03, 0x37, 0x88, 0x83, 0x38, 0x70, 0x03,
+  0x38, 0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06, 0xf0, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x90,
+  0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9, 0x80,
+  0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60,
+  0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x90,
   0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20,
-  0x07, 0x6d, 0x60, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0,
-  0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10,
-  0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40,
-  0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60,
-  0x0f, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20,
-  0x07, 0x6d, 0x60, 0x0f, 0x74, 0x80, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0,
-  0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60,
-  0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60,
-  0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80,
-  0x07, 0x6d, 0x60, 0x0f, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20,
-  0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10,
-  0x07, 0x79, 0x20, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20,
-  0x07, 0x75, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0,
-  0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0,
-  0x06, 0xf6, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20,
-  0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00,
-  0x07, 0x72, 0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0,
-  0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0,
-  0x07, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0x30, 0x84, 0x49, 0x00,
-  0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xc2, 0x38, 0x40, 0x00,
-  0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0x81, 0x00, 0x00, 0x00, 0x00,
-  0x09, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90,
-  0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x5a, 0x25, 0x30, 0x02, 0x50,
-  0x20, 0x45, 0x50, 0x08, 0x05, 0x51, 0x06, 0x14, 0x47, 0x00, 0x08, 0x8e,
-  0x25, 0x2c, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0xe9, 0x00, 0x00, 0x00,
-  0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9,
-  0xb9, 0xb4, 0x37, 0xb7, 0x21, 0xc6, 0x52, 0x3c, 0x00, 0xa4, 0x50, 0xb9,
-  0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b, 0x62, 0x2c,
-  0xc2, 0x23, 0x2c, 0x06, 0xe1, 0x20, 0x08, 0x0e, 0x8e, 0xad, 0x0c, 0x84,
-  0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x0d,
-  0x64, 0x26, 0x06, 0x06, 0x26, 0xc6, 0x25, 0x86, 0x66, 0x06, 0x04, 0xa5,
-  0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26, 0x06, 0x06, 0x26,
-  0xc6, 0x25, 0x86, 0x66, 0x26, 0x65, 0x88, 0xf0, 0x10, 0x43, 0x8c, 0x45,
-  0x58, 0x8e, 0x65, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36, 0x04, 0x79,
-  0x8e, 0x45, 0x58, 0x84, 0x65, 0xe0, 0x16, 0x96, 0x26, 0xe7, 0x32, 0xf6,
+  0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60,
+  0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x74, 0x80,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60,
+  0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80,
+  0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x20,
+  0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20,
+  0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x79, 0x20, 0x07, 0x7a, 0x20,
+  0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x6d, 0x60,
+  0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0,
+  0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x50, 0x07, 0x71, 0x20,
+  0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20,
+  0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x7a, 0x10,
+  0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40,
+  0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0x30, 0x84, 0x59, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x18, 0xc2, 0x34, 0x40, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x0c, 0x61, 0x24, 0x20, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb2,
+  0x40, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x14, 0x19, 0x11,
+  0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x7a, 0x25, 0x30,
+  0x02, 0x50, 0x20, 0x45, 0x50, 0x08, 0x05, 0x18, 0x50, 0x10, 0x65, 0x50,
+  0x40, 0x05, 0x56, 0x0a, 0xc5, 0x40, 0x74, 0x2c, 0x61, 0x09, 0x00, 0x00,
+  0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x0c, 0x01, 0x00, 0x00, 0x1a, 0x03,
+  0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4,
+  0x37, 0xb7, 0x21, 0xc6, 0x63, 0x4c, 0x00, 0xf5, 0x50, 0xb9, 0x1b, 0x43,
+  0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b, 0x62, 0x3c, 0xc3, 0x24,
+  0x3c, 0x07, 0xe5, 0x20, 0x08, 0x0e, 0x8e, 0xad, 0x0c, 0x84, 0x89, 0xc9,
+  0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x26,
+  0x06, 0x06, 0x26, 0xc6, 0x25, 0xc6, 0x06, 0x06, 0x04, 0xa5, 0xad, 0x8c,
+  0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26, 0x06, 0x06, 0x26, 0xc6, 0x25,
+  0xc6, 0x06, 0xc6, 0x25, 0x26, 0x65, 0x88, 0x30, 0x11, 0x43, 0x8c, 0x67,
+  0x78, 0x92, 0x87, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36, 0x04, 0x99,
+  0x8e, 0x67, 0x78, 0x86, 0x87, 0xe0, 0x16, 0x96, 0x26, 0xe7, 0x32, 0xf6,
   0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6, 0x26, 0xd7,
-  0x36, 0xf7, 0x45, 0x96, 0x36, 0x17, 0x26, 0xc6, 0x56, 0x36, 0x44, 0x78,
+  0x36, 0xf7, 0x45, 0x96, 0x36, 0x17, 0x26, 0xc6, 0x56, 0x36, 0x44, 0x98,
   0x12, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c,
   0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f,
-  0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x84, 0x67, 0x61, 0x19, 0x84,
+  0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x84, 0x69, 0x61, 0x19, 0x84,
   0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5, 0xc1, 0xa5, 0xb1, 0x95, 0xb9, 0x98,
   0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5, 0x99, 0x99, 0x95, 0xc9, 0x7d, 0x99,
   0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x91, 0xa5, 0xcd, 0x85, 0x89, 0xb1, 0x95,
-  0x0d, 0x11, 0x9e, 0x86, 0x51, 0x58, 0x9a, 0x9c, 0x8b, 0x5c, 0x99, 0x1b,
+  0x0d, 0x11, 0xa6, 0x86, 0x51, 0x58, 0x9a, 0x9c, 0x8b, 0x5c, 0x99, 0x1b,
   0x59, 0x99, 0xdc, 0x17, 0x5d, 0x98, 0xdc, 0x59, 0x19, 0x1d, 0xa3, 0xb0,
   0x34, 0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0x2f,
   0xb7, 0xb0, 0xb6, 0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x43,
-  0x90, 0xe7, 0x59, 0x86, 0x07, 0x7a, 0xa2, 0x21, 0xc2, 0x23, 0x91, 0x09,
+  0x90, 0xe9, 0x79, 0x88, 0x09, 0x9a, 0xa2, 0x21, 0xc2, 0x24, 0x91, 0x09,
   0x4b, 0x93, 0x73, 0x81, 0x7b, 0x9b, 0x4b, 0xa3, 0x4b, 0x7b, 0x73, 0xa3,
   0x12, 0x96, 0x26, 0xe7, 0x32, 0x56, 0xe6, 0x46, 0x57, 0x26, 0x47, 0x29,
   0x2c, 0x4d, 0xce, 0xc5, 0xed, 0xed, 0x0b, 0xae, 0x4c, 0x6e, 0x0e, 0xae,
   0x6c, 0x8c, 0x2e, 0xcd, 0xae, 0x8c, 0x4c, 0x58, 0x9a, 0x9c, 0x4b, 0x98,
   0xdc, 0xd9, 0x97, 0x5b, 0x58, 0x5b, 0x19, 0x11, 0xb8, 0xb7, 0xb9, 0x34,
-  0xba, 0xb4, 0x37, 0xb7, 0x21, 0xd0, 0x32, 0x3c, 0xd4, 0x53, 0x3d, 0xd6,
-  0x03, 0x3d, 0xd1, 0x73, 0x3d, 0x18, 0xa5, 0xb0, 0x34, 0x39, 0x17, 0x33,
+  0xba, 0xb4, 0x37, 0xb7, 0x21, 0xd0, 0x43, 0x4c, 0xd4, 0x54, 0x4d, 0xd6,
+  0x04, 0x4d, 0xd1, 0x74, 0x4d, 0x18, 0xa5, 0xb0, 0x34, 0x39, 0x17, 0x33,
   0xb9, 0xb0, 0xb3, 0xb6, 0x32, 0x37, 0xba, 0xaf, 0x34, 0x37, 0xb8, 0x3a,
-  0x3a, 0x66, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28,
-  0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x44, 0x76, 0x32,
-  0x5f, 0x66, 0x29, 0x7c, 0xc2, 0xd2, 0xe4, 0x5c, 0xe0, 0xca, 0xe4, 0xe6,
-  0xe0, 0xca, 0xc6, 0xe8, 0xd2, 0xec, 0xca, 0x68, 0x98, 0xb1, 0xbd, 0x85,
-  0xd1, 0xc9, 0x10, 0xa1, 0x2b, 0xc3, 0x1b, 0x7b, 0x7b, 0x93, 0x23, 0x1b,
-  0x22, 0x2d, 0xc2, 0xa3, 0x3d, 0xdb, 0x53, 0x3d, 0xdc, 0x03, 0x3d, 0xdd,
-  0x73, 0x3d, 0x1e, 0x95, 0xb0, 0x34, 0x39, 0x17, 0xb1, 0x3a, 0x33, 0xb3,
-  0x32, 0x39, 0x3e, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65,
-  0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x94, 0xc2, 0xd2, 0xe4, 0x5c, 0xd8,
-  0xde, 0xc6, 0xc2, 0xe8, 0xd2, 0xde, 0xdc, 0xbe, 0xd2, 0xdc, 0xc8, 0xca,
-  0xf0, 0x88, 0x84, 0xa5, 0xc9, 0xb9, 0xc8, 0x95, 0x85, 0x91, 0x31, 0x0a,
-  0x4b, 0x93, 0x73, 0x09, 0x93, 0x3b, 0xfb, 0xa2, 0xcb, 0x83, 0x2b, 0xfb,
-  0x9a, 0x4b, 0xd3, 0x2b, 0xe3, 0x15, 0x96, 0x26, 0xe7, 0x12, 0x26, 0x77,
-  0xf6, 0x45, 0x97, 0x07, 0x57, 0xf6, 0x15, 0xc6, 0x96, 0x76, 0xe6, 0xf6,
-  0x35, 0x97, 0xa6, 0x57, 0xc6, 0x61, 0xec, 0x8d, 0x6d, 0x08, 0x18, 0x2c,
-  0xc5, 0x03, 0x06, 0x4f, 0x18, 0x2c, 0xc4, 0x23, 0x06, 0xcb, 0xb0, 0x08,
-  0xcf, 0x18, 0x3c, 0x64, 0xb0, 0x10, 0x4f, 0x19, 0x2c, 0xc4, 0x03, 0x3d,
-  0xd1, 0x73, 0x3d, 0x66, 0xc0, 0x25, 0x2c, 0x4d, 0xce, 0x85, 0xae, 0x0c,
-  0x8f, 0xae, 0x4e, 0xae, 0x8c, 0x4a, 0x58, 0x9a, 0x9c, 0xcb, 0x5c, 0x58,
-  0x1b, 0x1c, 0x5b, 0x19, 0x31, 0xba, 0x32, 0x3c, 0xba, 0x3a, 0xb9, 0x32,
-  0x19, 0x32, 0x1e, 0x33, 0xb6, 0xb7, 0x30, 0x3a, 0x16, 0x90, 0xb9, 0xb0,
-  0x36, 0x38, 0xb6, 0x32, 0x1f, 0x0e, 0x74, 0x65, 0x78, 0x43, 0xa8, 0x05,
-  0x79, 0xd0, 0xe0, 0x11, 0x83, 0x65, 0x58, 0x84, 0x27, 0x0d, 0x1e, 0xe8,
-  0x51, 0x83, 0xe7, 0x7a, 0xd6, 0x80, 0x4b, 0x58, 0x9a, 0x9c, 0xcb, 0x5c,
-  0x58, 0x1b, 0x1c, 0x5b, 0x99, 0x1c, 0x8f, 0xb9, 0xb0, 0x36, 0x38, 0xb6,
-  0x32, 0x39, 0x06, 0x73, 0x43, 0xa4, 0xc5, 0x78, 0xda, 0xe0, 0x11, 0x83,
-  0x65, 0x58, 0x84, 0x07, 0x7a, 0xdc, 0xe0, 0xb9, 0x9e, 0x37, 0x18, 0xa2,
-  0x3c, 0xd9, 0xf3, 0x3d, 0x67, 0xf0, 0xb0, 0xc1, 0x03, 0x07, 0x43, 0x8c,
-  0x04, 0x78, 0xa6, 0x27, 0x0e, 0xf8, 0xbc, 0xb5, 0xb9, 0xa5, 0xc1, 0xbd,
-  0xd1, 0x95, 0xb9, 0xd1, 0x81, 0x8c, 0xa1, 0x85, 0xc9, 0xf1, 0x99, 0x4a,
-  0x6b, 0x83, 0x63, 0x2b, 0x03, 0x19, 0x5a, 0x59, 0x01, 0xa1, 0x12, 0x0a,
-  0x0a, 0x1a, 0x22, 0x3c, 0x74, 0x30, 0xc4, 0x78, 0xe6, 0xe0, 0xa9, 0x83,
-  0x28, 0x19, 0x62, 0x3c, 0x76, 0xf0, 0xd8, 0x41, 0x94, 0x8c, 0x88, 0xd8,
-  0x81, 0x1d, 0xec, 0xa1, 0x1d, 0xdc, 0xa0, 0x1d, 0xde, 0x81, 0x1c, 0xea,
-  0x81, 0x1d, 0xca, 0xc1, 0x0d, 0xcc, 0x81, 0x1d, 0xc2, 0xe1, 0x1c, 0xe6,
-  0x61, 0x8a, 0x10, 0x0c, 0x23, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07,
-  0x37, 0x48, 0x07, 0x72, 0x28, 0x07, 0x77, 0xa0, 0x87, 0x29, 0x41, 0x31,
-  0x62, 0x09, 0x87, 0x74, 0x90, 0x07, 0x37, 0xb0, 0x87, 0x72, 0x90, 0x87,
-  0x79, 0x48, 0x87, 0x77, 0x70, 0x87, 0x29, 0x81, 0x31, 0x82, 0x0a, 0x87,
-  0x74, 0x90, 0x07, 0x37, 0x60, 0x87, 0x70, 0x70, 0x87, 0x73, 0xa8, 0x87,
-  0x70, 0x38, 0x87, 0x72, 0xf8, 0x05, 0x7b, 0x28, 0x07, 0x79, 0x98, 0x87,
-  0x74, 0x78, 0x07, 0x77, 0x98, 0x12, 0x20, 0x23, 0xa6, 0x70, 0x48, 0x07,
-  0x79, 0x70, 0x83, 0x71, 0x78, 0x87, 0x76, 0x80, 0x87, 0x74, 0x60, 0x87,
-  0x72, 0xf8, 0x85, 0x77, 0x80, 0x07, 0x7a, 0x48, 0x87, 0x77, 0x70, 0x87,
-  0x79, 0x98, 0x32, 0x28, 0x8c, 0x33, 0x82, 0x09, 0x87, 0x74, 0x90, 0x07,
-  0x37, 0x30, 0x07, 0x79, 0x08, 0x87, 0x73, 0x68, 0x87, 0x72, 0x70, 0x07,
-  0x7a, 0x98, 0x12, 0xc8, 0x01, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00,
-  0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66,
-  0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07,
-  0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10,
-  0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce,
-  0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b,
-  0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c,
-  0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07,
-  0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11,
-  0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0,
-  0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8,
-  0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b,
-  0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b,
-  0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87,
-  0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07,
-  0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87,
-  0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81,
-  0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30,
-  0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4,
-  0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca,
-  0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39,
-  0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b,
-  0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b,
-  0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83,
-  0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87,
-  0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90,
-  0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20,
-  0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc,
-  0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66,
-  0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24,
-  0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07,
-  0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e,
-  0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e,
-  0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54,
-  0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39,
-  0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c,
-  0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07,
-  0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0,
-  0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4,
-  0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38,
-  0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d,
-  0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d,
-  0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
-  0x06, 0x10, 0xb1, 0x5d, 0xf9, 0x73, 0xce, 0x83, 0xfd, 0x45, 0x04, 0x18,
-  0x0c, 0xd1, 0x4c, 0x16, 0xb0, 0x01, 0x48, 0xe4, 0x4b, 0x00, 0xf3, 0x2c,
-  0xc4, 0x3f, 0x11, 0xd7, 0x44, 0x45, 0xc4, 0x6f, 0x0f, 0x7e, 0x85, 0x17,
-  0xb7, 0x0d, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
-  0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
-  0xc4, 0x46, 0x00, 0x48, 0xd5, 0xc0, 0x08, 0x00, 0x81, 0x11, 0x00, 0x00,
-  0x23, 0x06, 0x8a, 0x10, 0x4c, 0x46, 0x81, 0x0c, 0x84, 0x10, 0x10, 0x52,
-  0x2c, 0x10, 0xe4, 0x93, 0x41, 0x40, 0x0c, 0x00, 0x02, 0x00, 0x00, 0x00,
-  0x5b, 0x86, 0x20, 0xb8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00,
-  0x14, 0x00, 0x00, 0x00, 0x18, 0x0d, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
-  0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0x43, 0x03, 0x00, 0x00,
-  0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
-  0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39,
-  0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62,
-  0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14,
-  0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90, 0x21,
-  0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8, 0x48,
-  0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00,
-  0x51, 0x18, 0x00, 0x00, 0x8f, 0x00, 0x00, 0x00, 0x1b, 0xcc, 0x25, 0xf8,
-  0xff, 0xff, 0xff, 0xff, 0x01, 0x60, 0x00, 0x09, 0xa8, 0x88, 0x71, 0x78,
-  0x07, 0x79, 0x90, 0x87, 0x72, 0x18, 0x07, 0x7a, 0x60, 0x87, 0x7c, 0x68,
-  0x03, 0x79, 0x78, 0x87, 0x7a, 0x70, 0x07, 0x72, 0x28, 0x07, 0x72, 0x68,
-  0x03, 0x72, 0x48, 0x07, 0x7b, 0x48, 0x07, 0x72, 0x28, 0x87, 0x36, 0x98,
-  0x87, 0x78, 0x90, 0x07, 0x7a, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68,
-  0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e,
-  0xca, 0x01, 0x20, 0xc8, 0x21, 0x1d, 0xe6, 0x21, 0x1c, 0xc4, 0x81, 0x1d,
-  0xca, 0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xd2, 0x81, 0x1d, 0xda, 0x60, 0x1c,
-  0xc2, 0x81, 0x1d, 0xd8, 0x61, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98,
-  0x87, 0x72, 0x00, 0x08, 0x76, 0x28, 0x87, 0x79, 0x98, 0x87, 0x36, 0x80,
-  0x07, 0x79, 0x28, 0x87, 0x71, 0x48, 0x87, 0x79, 0x28, 0x87, 0x36, 0x30,
-  0x07, 0x78, 0x68, 0x87, 0x70, 0x20, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d,
-  0xe6, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xcc, 0x41, 0x1e,
-  0xc2, 0xa1, 0x1d, 0xca, 0xa1, 0x0d, 0xe0, 0xe1, 0x1d, 0xd2, 0xc1, 0x1d,
-  0xe8, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xca, 0x81, 0x1d, 0xd2, 0xa1, 0x1d,
-  0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x60, 0x70, 0x87, 0x77, 0x68,
-  0x03, 0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78, 0x78,
-  0x87, 0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72, 0x60,
-  0x87, 0x74, 0x68, 0x87, 0x36, 0x70, 0x87, 0x77, 0x70, 0x87, 0x36, 0x60,
-  0x87, 0x72, 0x08, 0x07, 0x73, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x48,
-  0x07, 0x77, 0x30, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68,
-  0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c,
-  0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xd4, 0xa1, 0x1e, 0xda, 0x01, 0x1e,
-  0xda, 0x80, 0x1e, 0xc2, 0x41, 0x1c, 0xd8, 0xa1, 0x1c, 0xe6, 0x01, 0x30,
-  0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68,
-  0x03, 0x77, 0x08, 0x07, 0x77, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68,
-  0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e,
-  0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x60, 0x1e, 0xd2, 0xe1, 0x1c,
-  0xdc, 0xa1, 0x1c, 0xc8, 0xa1, 0x0d, 0xf4, 0xa1, 0x1c, 0xe4, 0xe1, 0x1d,
-  0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e,
-  0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78,
-  0x87, 0x36, 0xa0, 0x07, 0x79, 0x08, 0x07, 0x78, 0x80, 0x87, 0x74, 0x70,
-  0x87, 0x73, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e,
-  0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xe6, 0x81, 0x1e, 0xc2, 0x61, 0x1c,
-  0xd6, 0xa1, 0x0d, 0xe0, 0x41, 0x1e, 0xde, 0x81, 0x1e, 0xca, 0x61, 0x1c,
-  0xe8, 0xe1, 0x1d, 0xe4, 0xa1, 0x0d, 0xc4, 0xa1, 0x1e, 0xcc, 0xc1, 0x1c,
-  0xca, 0x41, 0x1e, 0xda, 0x60, 0x1e, 0xd2, 0x41, 0x1f, 0xca, 0x01, 0xc0,
-  0x03, 0x80, 0xa8, 0x07, 0x77, 0x98, 0x87, 0x70, 0x30, 0x87, 0x72, 0x68,
+  0x3a, 0x5a, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28,
+  0x35, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66, 0x29,
+  0x7c, 0xc2, 0xd2, 0xe4, 0x5c, 0xe0, 0xca, 0xe4, 0xe6, 0xe0, 0xca, 0xc6,
+  0xe8, 0xd2, 0xec, 0xca, 0x58, 0x8c, 0xbd, 0xb1, 0xbd, 0xc9, 0x0d, 0x91,
+  0x9e, 0x61, 0xd2, 0xa6, 0x6d, 0xaa, 0x26, 0x6e, 0x82, 0xa6, 0x68, 0xba,
+  0xa6, 0x8e, 0xd9, 0x59, 0x99, 0x5b, 0x99, 0x5c, 0x18, 0x5d, 0x19, 0x19,
+  0x0a, 0x0e, 0x5d, 0x19, 0xde, 0xd8, 0xdb, 0x9b, 0x1c, 0x19, 0x91, 0x9d,
+  0xcc, 0x97, 0x59, 0x0a, 0x0d, 0x33, 0xb6, 0xb7, 0x30, 0x3a, 0x19, 0x22,
+  0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x43, 0xa4, 0xc7, 0x98,
+  0xb4, 0xe9, 0x9b, 0xaa, 0x89, 0x9b, 0xa0, 0x09, 0x0c, 0xa6, 0x6b, 0x0a,
+  0x03, 0x2a, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72,
+  0x7c, 0xc2, 0xd2, 0xe4, 0x5c, 0xc4, 0xea, 0xcc, 0xcc, 0xca, 0xe4, 0xbe,
+  0xe6, 0xd2, 0xf4, 0xca, 0x28, 0x85, 0xa5, 0xc9, 0xb9, 0xb0, 0xbd, 0x8d,
+  0x85, 0xd1, 0xa5, 0xbd, 0xb9, 0x7d, 0xa5, 0xb9, 0x91, 0x95, 0xe1, 0x11,
+  0x09, 0x4b, 0x93, 0x73, 0x91, 0x2b, 0x0b, 0x23, 0x23, 0x15, 0x96, 0x26,
+  0xe7, 0x32, 0x47, 0x27, 0x57, 0x37, 0x46, 0xf7, 0x45, 0x97, 0x07, 0x57,
+  0xf6, 0x95, 0xe6, 0x66, 0xf6, 0x46, 0xc3, 0x8c, 0xed, 0x2d, 0x8c, 0x6e,
+  0x86, 0xc6, 0x9b, 0x99, 0xd9, 0x5c, 0x19, 0x1d, 0x0d, 0xa9, 0xb1, 0xb7,
+  0x32, 0x33, 0x33, 0x1a, 0x47, 0x63, 0x6f, 0x65, 0x66, 0x66, 0x34, 0x84,
+  0xc6, 0xde, 0xca, 0xcc, 0xcc, 0x86, 0xa0, 0xc1, 0x43, 0x3c, 0xc5, 0x43,
+  0x4c, 0x68, 0x30, 0xa5, 0xc1, 0x53, 0x3c, 0xc5, 0x43, 0x4c, 0x68, 0x30,
+  0xa9, 0xc1, 0xb3, 0x3c, 0xc5, 0x43, 0x4c, 0x68, 0x30, 0xad, 0xc1, 0xc3,
+  0x3c, 0xc5, 0x43, 0x4c, 0x68, 0x30, 0xb1, 0x01, 0xa3, 0xb0, 0x34, 0x39,
+  0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0xaf, 0xb9, 0x34,
+  0xbd, 0x32, 0x5e, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74,
+  0x79, 0x70, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69,
+  0x7a, 0x65, 0x4c, 0xb2, 0xaa, 0xac, 0x88, 0xca, 0xc6, 0xde, 0xc8, 0xca,
+  0x68, 0x90, 0x95, 0x8d, 0xbd, 0x91, 0x95, 0x0d, 0x21, 0x83, 0x47, 0x99,
+  0xc6, 0x60, 0x22, 0x83, 0x07, 0x99, 0xca, 0xe0, 0x19, 0x9e, 0x61, 0x32,
+  0x83, 0xe9, 0x0c, 0xa6, 0x36, 0x98, 0xdc, 0xe0, 0x41, 0xa6, 0x37, 0x78,
+  0x8a, 0x09, 0x9a, 0xe0, 0x60, 0xba, 0xa6, 0x38, 0xe0, 0x12, 0x96, 0x26,
+  0xe7, 0x42, 0x57, 0x86, 0x47, 0x57, 0x27, 0x57, 0x46, 0x25, 0x2c, 0x4d,
+  0xce, 0x65, 0x2e, 0xac, 0x0d, 0x8e, 0xad, 0x8c, 0x18, 0x5d, 0x19, 0x1e,
+  0x5d, 0x9d, 0x5c, 0x99, 0x0c, 0x19, 0x8f, 0x19, 0xdb, 0x5b, 0x18, 0x1d,
+  0x0b, 0xc8, 0x5c, 0x58, 0x1b, 0x1c, 0x5b, 0x99, 0x0f, 0x09, 0xba, 0x32,
+  0xbc, 0xac, 0x21, 0xd4, 0x73, 0x4c, 0x73, 0x30, 0x95, 0xc1, 0x43, 0x3c,
+  0xc3, 0x44, 0x07, 0x13, 0x34, 0xd5, 0xc1, 0x74, 0x4d, 0x76, 0xc0, 0x82,
+  0xae, 0x0c, 0xaf, 0xca, 0x6a, 0x08, 0xf5, 0x34, 0xd3, 0x1c, 0x4c, 0x65,
+  0xf0, 0x0c, 0xcf, 0x30, 0xd1, 0xc1, 0x04, 0x4d, 0x75, 0x30, 0x5d, 0x13,
+  0x1e, 0x70, 0x09, 0x4b, 0x93, 0x73, 0x99, 0x0b, 0x6b, 0x83, 0x63, 0x2b,
+  0x93, 0xe3, 0x31, 0x17, 0xd6, 0x06, 0xc7, 0x56, 0x26, 0xc7, 0x60, 0x6e,
+  0x88, 0xf4, 0x38, 0x93, 0x1e, 0x4c, 0x65, 0xf0, 0x10, 0xcf, 0x30, 0x41,
+  0xd3, 0x1e, 0x4c, 0xd7, 0xc4, 0x07, 0x43, 0x9c, 0x29, 0x9b, 0xbc, 0x49,
+  0x0c, 0x26, 0x39, 0x98, 0xee, 0x60, 0xca, 0x83, 0xa9, 0x0f, 0x86, 0x18,
+  0x0b, 0x30, 0x4d, 0x93, 0x1f, 0x8c, 0x88, 0xd8, 0x81, 0x1d, 0xec, 0xa1,
+  0x1d, 0xdc, 0xa0, 0x1d, 0xde, 0x81, 0x1c, 0xea, 0x81, 0x1d, 0xca, 0xc1,
+  0x0d, 0xcc, 0x81, 0x1d, 0xc2, 0xe1, 0x1c, 0xe6, 0x61, 0x8a, 0x10, 0x0c,
+  0x23, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x48, 0x07, 0x72,
+  0x28, 0x07, 0x77, 0xa0, 0x87, 0x29, 0x41, 0x31, 0x62, 0x09, 0x87, 0x74,
+  0x90, 0x07, 0x37, 0xb0, 0x87, 0x72, 0x90, 0x87, 0x79, 0x48, 0x87, 0x77,
+  0x70, 0x87, 0x29, 0x81, 0x31, 0x82, 0x0a, 0x87, 0x74, 0x90, 0x07, 0x37,
+  0x60, 0x87, 0x70, 0x70, 0x87, 0x73, 0xa8, 0x87, 0x70, 0x38, 0x87, 0x72,
+  0xf8, 0x05, 0x7b, 0x28, 0x07, 0x79, 0x98, 0x87, 0x74, 0x78, 0x07, 0x77,
+  0x98, 0x12, 0x20, 0x23, 0xa6, 0x70, 0x48, 0x07, 0x79, 0x70, 0x83, 0x71,
+  0x78, 0x87, 0x76, 0x80, 0x87, 0x74, 0x60, 0x87, 0x72, 0xf8, 0x85, 0x77,
+  0x80, 0x07, 0x7a, 0x48, 0x87, 0x77, 0x70, 0x87, 0x79, 0x98, 0x32, 0x28,
+  0x8c, 0x33, 0x82, 0x09, 0x87, 0x74, 0x90, 0x07, 0x37, 0x30, 0x07, 0x79,
+  0x08, 0x87, 0x73, 0x68, 0x87, 0x72, 0x70, 0x07, 0x7a, 0x98, 0x12, 0xfc,
+  0x01, 0x00, 0x79, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08,
+  0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38,
+  0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71,
+  0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c,
+  0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d,
+  0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d,
+  0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07,
+  0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87,
+  0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30,
+  0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10,
+  0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66,
+  0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c,
+  0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07,
+  0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87,
+  0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05,
+  0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87,
+  0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0,
+  0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4,
+  0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca,
+  0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39,
+  0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38,
+  0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c,
+  0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87,
+  0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87,
+  0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00,
+  0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20,
+  0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2,
+  0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4,
+  0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a,
+  0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07,
+  0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90,
+  0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8,
+  0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc,
+  0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b,
+  0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b,
+  0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87,
+  0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81,
+  0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30,
+  0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde,
+  0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39,
+  0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f,
+  0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20,
+  0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x16, 0xd0, 0x00, 0x48, 0xe4, 0x0f,
+  0xce, 0xe4, 0x57, 0x77, 0x71, 0xdb, 0x26, 0xb0, 0x01, 0x48, 0xe4, 0x4b,
+  0x00, 0xf3, 0x2c, 0xc4, 0x3f, 0x11, 0xd7, 0x44, 0x45, 0xc4, 0x6f, 0x0f,
+  0x7e, 0x85, 0x17, 0xb7, 0x6d, 0x00, 0x11, 0xdb, 0x95, 0xff, 0xf9, 0xd6,
+  0xf6, 0x5f, 0x44, 0x80, 0xc1, 0x10, 0xcd, 0x04, 0x00, 0x00, 0x61, 0x20,
+  0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00,
+  0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x74, 0x47, 0x00, 0xa8, 0x8e, 0x35,
+  0x00, 0x03, 0x31, 0xc7, 0x40, 0x0c, 0xde, 0x1c, 0x03, 0xe1, 0x79, 0x63,
+  0x0d, 0x40, 0x20, 0x90, 0xab, 0x81, 0x11, 0x00, 0x7a, 0x33, 0x00, 0x04,
+  0x47, 0x00, 0x28, 0xcc, 0x41, 0x90, 0x01, 0x19, 0x90, 0x81, 0x18, 0xcc,
+  0x00, 0x10, 0x18, 0x23, 0x00, 0x41, 0x10, 0xc4, 0xbf, 0x11, 0x80, 0x19,
+  0x00, 0x00, 0x23, 0x06, 0xca, 0x10, 0x8c, 0x41, 0xf4, 0x4c, 0x89, 0x81,
+  0x08, 0x83, 0x0c, 0x41, 0xc1, 0x8c, 0x18, 0x28, 0x43, 0x50, 0x06, 0x52,
+  0x54, 0x2d, 0x88, 0x42, 0x0c, 0x32, 0x04, 0xc7, 0x33, 0xc8, 0x30, 0x04,
+  0xd1, 0x5d, 0x76, 0x29, 0x28, 0x83, 0x0c, 0xc1, 0x12, 0x19, 0x11, 0xc0,
+  0x67, 0xbc, 0x61, 0xbb, 0xd6, 0xe0, 0x02, 0xbb, 0x14, 0x94, 0x41, 0x86,
+  0x00, 0xb2, 0x46, 0x0c, 0x0a, 0x21, 0x88, 0x83, 0x22, 0x18, 0x6f, 0x00,
+  0x03, 0xae, 0x0d, 0x2e, 0xb0, 0x4b, 0x41, 0x19, 0x64, 0x08, 0xaa, 0x6d,
+  0xc4, 0xa0, 0x10, 0x02, 0x3b, 0x50, 0x82, 0xf1, 0x86, 0x32, 0x08, 0x03,
+  0x37, 0xb8, 0xc0, 0x2e, 0x05, 0x65, 0x90, 0x21, 0xd0, 0xc0, 0x60, 0xc4,
+  0xa0, 0x10, 0x82, 0x3d, 0x78, 0x82, 0x39, 0x86, 0x6e, 0xc9, 0x83, 0x39,
+  0x86, 0xe0, 0xd8, 0x83, 0x39, 0x86, 0x60, 0xc8, 0x03, 0x0b, 0xde, 0x40,
+  0x3e, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0,
+  0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x6c, 0x0c,
+  0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c,
+  0x00, 0x00, 0x18, 0x03, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00,
+  0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8,
+  0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05,
+  0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92,
+  0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32,
+  0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19,
+  0x21, 0x72, 0x24, 0x07, 0xc8, 0x48, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40,
+  0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00, 0x00, 0x8f, 0x00,
+  0x00, 0x00, 0x1b, 0xcc, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x60,
+  0x00, 0x09, 0xa8, 0x88, 0x71, 0x78, 0x07, 0x79, 0x90, 0x87, 0x72, 0x18,
+  0x07, 0x7a, 0x60, 0x87, 0x7c, 0x68, 0x03, 0x79, 0x78, 0x87, 0x7a, 0x70,
+  0x07, 0x72, 0x28, 0x07, 0x72, 0x68, 0x03, 0x72, 0x48, 0x07, 0x7b, 0x48,
+  0x07, 0x72, 0x28, 0x87, 0x36, 0x98, 0x87, 0x78, 0x90, 0x07, 0x7a, 0x68,
   0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00,
-  0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xa2, 0x1e, 0xe6, 0xa1, 0x1c,
-  0xda, 0x60, 0x1e, 0xde, 0xc1, 0x1c, 0xe8, 0xa1, 0x0d, 0xcc, 0x81, 0x1d,
-  0xde, 0x21, 0x1c, 0xe8, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28,
-  0x07, 0x60, 0x83, 0x21, 0x0c, 0xc0, 0x02, 0x54, 0x1b, 0x8c, 0x81, 0x00,
-  0x16, 0xa0, 0xda, 0x60, 0x10, 0x05, 0xb0, 0x00, 0xd5, 0x06, 0xa3, 0x38,
-  0x80, 0x05, 0xa8, 0x36, 0x18, 0xc6, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x80,
-  0x04, 0x50, 0x1b, 0x90, 0xe3, 0xff, 0xff, 0xff, 0xff, 0x07, 0x80, 0x01,
-  0x24, 0xa0, 0xda, 0x60, 0x20, 0x01, 0xb0, 0x00, 0xd5, 0x06, 0x23, 0x11,
-  0x80, 0x05, 0xa8, 0x00, 0x49, 0x18, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
-  0x13, 0x8a, 0x40, 0x18, 0x88, 0x62, 0x42, 0x60, 0x4c, 0x18, 0x0e, 0x24,
-  0x01, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00,
-  0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84,
-  0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c,
-  0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x7c, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30,
-  0x8c, 0x20, 0x00, 0x83, 0x08, 0x41, 0x30, 0x8c, 0x30, 0x00, 0x07, 0x49,
-  0x53, 0x44, 0x09, 0x93, 0x2f, 0xbb, 0x6f, 0x47, 0x08, 0xce, 0x40, 0x20,
-  0x82, 0x10, 0x42, 0x06, 0x11, 0x0a, 0xe1, 0x28, 0x69, 0x8a, 0x28, 0x61,
-  0xf2, 0xff, 0x89, 0xb8, 0x26, 0x2a, 0x22, 0x7e, 0x7b, 0xf8, 0xa7, 0x31,
-  0x02, 0x60, 0x10, 0xe1, 0x08, 0x4e, 0x93, 0xa6, 0x88, 0x12, 0x26, 0xff,
-  0x9f, 0x88, 0x6b, 0xa2, 0x22, 0xe2, 0xb7, 0x87, 0x1f, 0x88, 0x22, 0x00,
-  0xfb, 0xa7, 0x31, 0x02, 0x60, 0x10, 0x21, 0x09, 0x2e, 0x92, 0xa6, 0x88,
-  0x12, 0x26, 0xff, 0x97, 0x00, 0xe6, 0x59, 0x88, 0xe8, 0x9f, 0xc6, 0x08,
-  0x80, 0x41, 0x84, 0x45, 0x28, 0x48, 0x08, 0x62, 0x18, 0xa4, 0x18, 0xb5,
-  0x32, 0x00, 0x42, 0xe8, 0xcd, 0x11, 0x80, 0xc1, 0x1c, 0x41, 0x30, 0x8c,
-  0x20, 0x44, 0x25, 0x09, 0x8a, 0x89, 0x28, 0xa7, 0x04, 0x44, 0x0b, 0x12,
-  0x10, 0x13, 0x72, 0x4a, 0x40, 0x76, 0x20, 0x20, 0x05, 0xe2, 0x30, 0xc2,
-  0x10, 0x0d, 0x22, 0x04, 0xc2, 0x1c, 0x01, 0x28, 0x0c, 0x22, 0x10, 0xc2,
-  0x08, 0x00, 0x00, 0x00, 0x13, 0xb2, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03,
-  0x3a, 0x68, 0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83,
-  0x76, 0x08, 0x87, 0x71, 0x78, 0x87, 0x79, 0xc0, 0x87, 0x38, 0x80, 0x03,
-  0x37, 0x88, 0x83, 0x38, 0x70, 0x03, 0x38, 0xd8, 0x70, 0x1b, 0xe5, 0xd0,
-  0x06, 0xf0, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0,
-  0x07, 0x76, 0x40, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0,
-  0x07, 0x78, 0xd0, 0x06, 0xe9, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80,
-  0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0,
-  0x07, 0x71, 0x60, 0x07, 0x6d, 0x90, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30,
-  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40,
-  0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60,
-  0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20,
-  0x07, 0x6d, 0x60, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0,
-  0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10,
-  0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40,
-  0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60,
-  0x0f, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20,
-  0x07, 0x6d, 0x60, 0x0f, 0x74, 0x80, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0,
-  0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60,
-  0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60,
-  0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80,
-  0x07, 0x6d, 0x60, 0x0f, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20,
-  0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10,
-  0x07, 0x79, 0x20, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20,
-  0x07, 0x75, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0,
-  0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0,
-  0x06, 0xf6, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20,
-  0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00,
-  0x07, 0x72, 0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0,
-  0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0,
-  0x07, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0x30, 0x84, 0x71, 0x00,
-  0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xc2, 0x40, 0x40, 0x00,
-  0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x61, 0x2a, 0x20, 0x00, 0x06,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x30, 0x17, 0x10, 0x00, 0x03, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x59, 0x20, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
-  0x32, 0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47,
-  0xc6, 0x04, 0x43, 0x8a, 0x25, 0x30, 0x02, 0x50, 0x20, 0x45, 0x50, 0x08,
-  0x05, 0x18, 0x50, 0x10, 0x65, 0x50, 0x40, 0x05, 0x56, 0x0a, 0xc5, 0x40,
-  0x7c, 0x04, 0x80, 0xf2, 0x58, 0xc2, 0x02, 0x00, 0x79, 0x18, 0x00, 0x00,
-  0x1e, 0x01, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25,
-  0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x46, 0x74, 0x60,
-  0x40, 0x16, 0x51, 0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3,
-  0x2b, 0x1b, 0x62, 0x44, 0x04, 0x26, 0x44, 0x08, 0xe1, 0x20, 0x08, 0x0e,
-  0x8e, 0xad, 0x0c, 0x84, 0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e,
-  0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x26, 0x06, 0x06, 0x26, 0xc6, 0x25, 0x86,
-  0x66, 0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65,
-  0x26, 0x06, 0x06, 0x26, 0xc6, 0x25, 0x86, 0x66, 0x26, 0x65, 0x88, 0x80,
-  0x11, 0x43, 0x8c, 0x88, 0x88, 0x94, 0xa8, 0x60, 0xd1, 0x54, 0x46, 0x17,
-  0xc6, 0x36, 0x04, 0xc1, 0x8e, 0x88, 0x88, 0x88, 0xa8, 0xe0, 0x16, 0x96,
-  0x26, 0xe7, 0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56,
-  0xe6, 0xf6, 0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96, 0x36, 0x17, 0x26, 0xc6,
-  0x56, 0x36, 0x44, 0xc0, 0x12, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f,
-  0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d,
-  0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x04,
-  0x6c, 0x61, 0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5, 0xc1, 0xa5,
-  0xb1, 0x95, 0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5, 0x99, 0x99,
-  0x95, 0xc9, 0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x91, 0xa5, 0xcd,
-  0x85, 0x89, 0xb1, 0x95, 0x0d, 0x11, 0xb0, 0x86, 0x51, 0x58, 0x9a, 0x9c,
-  0x8b, 0x5c, 0x99, 0x1b, 0x59, 0x99, 0xdc, 0x17, 0x5d, 0x98, 0xdc, 0x59,
-  0x19, 0x1d, 0xa3, 0xb0, 0x34, 0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba,
-  0x3c, 0xb8, 0xb2, 0x2f, 0xb7, 0xb0, 0xb6, 0x32, 0x1a, 0x66, 0x6c, 0x6f,
-  0x61, 0x74, 0x34, 0x43, 0x10, 0xec, 0x89, 0x0a, 0x0c, 0xc2, 0xa2, 0x21,
-  0x02, 0x26, 0x91, 0x09, 0x4b, 0x93, 0x73, 0x81, 0x7b, 0x9b, 0x4b, 0xa3,
-  0x4b, 0x7b, 0x73, 0xa3, 0x12, 0x96, 0x26, 0xe7, 0x32, 0x56, 0xe6, 0x46,
-  0x57, 0x26, 0x47, 0x29, 0x2c, 0x4d, 0xce, 0xc5, 0xed, 0xed, 0x0b, 0xae,
-  0x4c, 0x6e, 0x0e, 0xae, 0x6c, 0x8c, 0x2e, 0xcd, 0xae, 0x8c, 0x4c, 0x58,
-  0x9a, 0x9c, 0x4b, 0x98, 0xdc, 0xd9, 0x97, 0x5b, 0x58, 0x5b, 0x19, 0x11,
-  0xb8, 0xb7, 0xb9, 0x34, 0xba, 0xb4, 0x37, 0xb7, 0x21, 0x50, 0x54, 0x60,
-  0x14, 0x56, 0x61, 0x16, 0x06, 0x61, 0x11, 0x76, 0x61, 0x18, 0xa5, 0xb0,
-  0x34, 0x39, 0x17, 0x33, 0xb9, 0xb0, 0xb3, 0xb6, 0x32, 0x37, 0xba, 0xaf,
-  0x34, 0x37, 0xb8, 0x3a, 0x3a, 0x66, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61,
-  0x74, 0x65, 0x64, 0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72,
-  0x64, 0x44, 0x76, 0x32, 0x5f, 0x66, 0x29, 0x7c, 0xc2, 0xd2, 0xe4, 0x5c,
-  0xe0, 0xca, 0xe4, 0xe6, 0xe0, 0xca, 0xc6, 0xe8, 0xd2, 0xec, 0xca, 0x68,
-  0x98, 0xb1, 0xbd, 0x85, 0xd1, 0xc9, 0x10, 0xa1, 0x2b, 0xc3, 0x1b, 0x7b,
-  0x7b, 0x93, 0x23, 0x1b, 0x22, 0x45, 0x04, 0xa6, 0x61, 0x1b, 0x56, 0x61,
-  0x1c, 0x06, 0x61, 0x1d, 0x76, 0x61, 0x1e, 0x95, 0xb0, 0x34, 0x39, 0x17,
-  0xb1, 0x3a, 0x33, 0xb3, 0x32, 0x39, 0x3e, 0x61, 0x69, 0x72, 0x2e, 0x62,
-  0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x94, 0xc2,
-  0xd2, 0xe4, 0x5c, 0xd8, 0xde, 0xc6, 0xc2, 0xe8, 0xd2, 0xde, 0xdc, 0xbe,
-  0xd2, 0xdc, 0xc8, 0xca, 0xf0, 0x88, 0x84, 0xa5, 0xc9, 0xb9, 0xc8, 0x95,
-  0x85, 0x91, 0x31, 0x0a, 0x4b, 0x93, 0x73, 0x09, 0x93, 0x3b, 0xfb, 0xa2,
-  0xcb, 0x83, 0x2b, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0xe3, 0x15, 0x96, 0x26,
-  0xe7, 0x12, 0x26, 0x77, 0xf6, 0x45, 0x97, 0x07, 0x57, 0xf6, 0x15, 0xc6,
-  0x96, 0x76, 0xe6, 0xf6, 0x35, 0x97, 0xa6, 0x57, 0xc6, 0x61, 0xec, 0x8d,
-  0x6d, 0x08, 0x18, 0x44, 0x07, 0x06, 0x06, 0x58, 0x18, 0x44, 0x06, 0x26,
-  0x06, 0x51, 0x11, 0x11, 0xd8, 0x18, 0x60, 0x64, 0x10, 0x19, 0x58, 0x19,
-  0x44, 0x06, 0x06, 0x61, 0x11, 0x76, 0x61, 0x66, 0x40, 0x2a, 0x2c, 0x4d,
-  0xce, 0x65, 0x8e, 0x4e, 0xae, 0x6e, 0x8c, 0xee, 0x8b, 0x2e, 0x0f, 0xae,
-  0xec, 0x2b, 0xcd, 0xcd, 0xec, 0x8d, 0x86, 0x19, 0xdb, 0x5b, 0x18, 0xdd,
-  0x0c, 0x8d, 0x37, 0x33, 0xb3, 0xb9, 0x32, 0x3a, 0x1a, 0x52, 0x63, 0x6f,
-  0x65, 0x66, 0x66, 0x34, 0x8e, 0xc6, 0xde, 0xca, 0xcc, 0xcc, 0x68, 0x08,
-  0x8d, 0xbd, 0x95, 0x99, 0x99, 0x0d, 0x41, 0x83, 0xa8, 0x88, 0x8c, 0xa8,
-  0xc0, 0xd2, 0x00, 0x53, 0x83, 0xc8, 0x88, 0x8c, 0xa8, 0xc0, 0xd2, 0x00,
-  0x5b, 0x83, 0x88, 0x89, 0x8c, 0xa8, 0xc0, 0xd2, 0x00, 0x63, 0x83, 0xa8,
-  0x89, 0x8c, 0xa8, 0xc0, 0xd2, 0x00, 0x6b, 0x03, 0x26, 0x59, 0x55, 0x56,
-  0x44, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x34, 0xc8, 0xca, 0xc6, 0xde, 0xc8,
-  0xca, 0x86, 0x90, 0x41, 0xb4, 0x60, 0x60, 0x80, 0x85, 0x41, 0x94, 0x60,
-  0x62, 0x10, 0x11, 0x11, 0x81, 0x8d, 0x01, 0x86, 0x06, 0x98, 0x1b, 0x60,
-  0x64, 0x10, 0x25, 0x58, 0x19, 0x44, 0x06, 0x06, 0x61, 0x6f, 0x80, 0x5d,
-  0x18, 0x1c, 0x70, 0x09, 0x4b, 0x93, 0x73, 0xa1, 0x2b, 0xc3, 0xa3, 0xab,
-  0x93, 0x2b, 0xa3, 0x12, 0x96, 0x26, 0xe7, 0x32, 0x17, 0xd6, 0x06, 0xc7,
-  0x56, 0x46, 0x8c, 0xae, 0x0c, 0x8f, 0xae, 0x4e, 0xae, 0x4c, 0x86, 0x8c,
-  0xc7, 0x8c, 0xed, 0x2d, 0x8c, 0x8e, 0x05, 0x64, 0x2e, 0xac, 0x0d, 0x8e,
-  0xad, 0xcc, 0x87, 0x04, 0x5d, 0x19, 0x5e, 0xd6, 0x10, 0x2a, 0x42, 0x30,
-  0x39, 0xc0, 0xc4, 0x20, 0x2a, 0x22, 0x02, 0x9b, 0x03, 0x0c, 0xc2, 0xe8,
-  0x00, 0xbb, 0xb0, 0x3a, 0xa0, 0x47, 0x57, 0x86, 0x47, 0x57, 0x27, 0x57,
-  0x26, 0x43, 0xf6, 0x15, 0x26, 0x27, 0x17, 0x96, 0xc7, 0x63, 0xc6, 0xf6,
-  0x16, 0x46, 0xc7, 0x02, 0x32, 0x17, 0xd6, 0x06, 0xc7, 0x56, 0xe6, 0xc3,
-  0x82, 0xae, 0x0c, 0xaf, 0xca, 0x6a, 0x08, 0x15, 0x39, 0x98, 0x1c, 0x60,
-  0x62, 0x10, 0x11, 0x11, 0x81, 0xcd, 0x01, 0x06, 0x61, 0x77, 0x80, 0x5d,
-  0x18, 0x1e, 0x70, 0x09, 0x4b, 0x93, 0x73, 0x99, 0x0b, 0x6b, 0x83, 0x63,
-  0x2b, 0x93, 0xe3, 0x31, 0x17, 0xd6, 0x06, 0xc7, 0x56, 0x26, 0xc7, 0x60,
-  0x6e, 0x88, 0x14, 0x3d, 0x98, 0x1e, 0x60, 0x62, 0x10, 0x15, 0x11, 0x81,
-  0x41, 0xd8, 0x1e, 0x60, 0x17, 0xc6, 0x07, 0x43, 0x1c, 0x2c, 0xc3, 0x3e,
-  0xec, 0x0c, 0xb0, 0x38, 0xc0, 0xec, 0x00, 0xcb, 0x03, 0xac, 0x0f, 0x86,
-  0x18, 0x0e, 0x80, 0x4d, 0x98, 0x1f, 0xf0, 0x79, 0x6b, 0x73, 0x4b, 0x83,
-  0x7b, 0xa3, 0x2b, 0x73, 0xa3, 0x03, 0x19, 0x43, 0x0b, 0x93, 0xe3, 0x33,
-  0x95, 0xd6, 0x06, 0xc7, 0x56, 0x06, 0x32, 0xb4, 0xb2, 0x02, 0x42, 0x25,
-  0x14, 0x14, 0x34, 0x44, 0xc0, 0x42, 0x61, 0x88, 0x81, 0x81, 0x02, 0x26,
-  0x0a, 0x1c, 0x34, 0xc4, 0xc0, 0x46, 0x01, 0x1b, 0x05, 0x0e, 0x1a, 0x11,
-  0xb1, 0x03, 0x3b, 0xd8, 0x43, 0x3b, 0xb8, 0x41, 0x3b, 0xbc, 0x03, 0x39,
-  0xd4, 0x03, 0x3b, 0x94, 0x83, 0x1b, 0x98, 0x03, 0x3b, 0x84, 0xc3, 0x39,
-  0xcc, 0xc3, 0x14, 0x21, 0x18, 0x46, 0x28, 0xec, 0xc0, 0x0e, 0xf6, 0xd0,
-  0x0e, 0x6e, 0x90, 0x0e, 0xe4, 0x50, 0x0e, 0xee, 0x40, 0x0f, 0x53, 0x82,
-  0x62, 0xc4, 0x12, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0x60, 0x0f, 0xe5, 0x20,
-  0x0f, 0xf3, 0x90, 0x0e, 0xef, 0xe0, 0x0e, 0x53, 0x02, 0x63, 0x04, 0x15,
-  0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0xc0, 0x0e, 0xe1, 0xe0, 0x0e, 0xe7, 0x50,
-  0x0f, 0xe1, 0x70, 0x0e, 0xe5, 0xf0, 0x0b, 0xf6, 0x50, 0x0e, 0xf2, 0x30,
-  0x0f, 0xe9, 0xf0, 0x0e, 0xee, 0x30, 0x25, 0x40, 0x46, 0x4c, 0xe1, 0x90,
-  0x0e, 0xf2, 0xe0, 0x06, 0xe3, 0xf0, 0x0e, 0xed, 0x00, 0x0f, 0xe9, 0xc0,
-  0x0e, 0xe5, 0xf0, 0x0b, 0xef, 0x00, 0x0f, 0xf4, 0x90, 0x0e, 0xef, 0xe0,
-  0x0e, 0xf3, 0x30, 0x65, 0x50, 0x18, 0x67, 0x04, 0x13, 0x0e, 0xe9, 0x20,
-  0x0f, 0x6e, 0x60, 0x0e, 0xf2, 0x10, 0x0e, 0xe7, 0xd0, 0x0e, 0xe5, 0xe0,
-  0x0e, 0xf4, 0x30, 0x25, 0xf8, 0x03, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00,
-  0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66,
-  0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07,
-  0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10,
-  0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce,
-  0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b,
-  0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c,
-  0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07,
-  0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11,
-  0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0,
-  0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8,
-  0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b,
-  0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b,
-  0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87,
-  0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07,
-  0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87,
-  0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81,
-  0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30,
-  0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4,
-  0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca,
-  0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39,
-  0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b,
-  0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b,
-  0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83,
-  0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87,
-  0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90,
-  0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20,
-  0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc,
-  0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66,
-  0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24,
-  0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07,
-  0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e,
-  0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e,
-  0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54,
-  0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39,
-  0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c,
-  0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07,
-  0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0,
-  0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4,
-  0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38,
-  0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d,
-  0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d,
-  0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
-  0x26, 0x10, 0x06, 0x00, 0x12, 0xf9, 0x12, 0xc0, 0x3c, 0x0b, 0xf1, 0x4f,
-  0xc4, 0x35, 0x51, 0x11, 0xf1, 0xdb, 0xc3, 0x0f, 0x44, 0x11, 0x80, 0xf9,
-  0x15, 0x5e, 0xdc, 0xb6, 0x05, 0x34, 0x00, 0x12, 0xf9, 0x83, 0x33, 0xf9,
-  0xd5, 0x5d, 0xdc, 0xb6, 0x0d, 0x6c, 0x00, 0x12, 0xf9, 0x12, 0xc0, 0x3c,
-  0x0b, 0xf1, 0x4f, 0xc4, 0x35, 0x51, 0x11, 0xf1, 0xdb, 0x83, 0x5f, 0xe1,
-  0xc5, 0x6d, 0x1b, 0x00, 0xc4, 0x76, 0xe5, 0x2f, 0xbb, 0xef, 0x5f, 0x44,
-  0x80, 0xc1, 0x10, 0xcd, 0x04, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00,
-  0x3b, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00,
-  0x0b, 0x00, 0x00, 0x00, 0xa4, 0xe7, 0x18, 0x0a, 0xcf, 0x1b, 0x6b, 0x00,
-  0x02, 0x81, 0xe6, 0x08, 0x00, 0xc9, 0x11, 0x80, 0x1a, 0xa0, 0x38, 0x03,
-  0x40, 0x61, 0x0e, 0x42, 0x0c, 0xc4, 0x40, 0x0c, 0xc2, 0x60, 0x06, 0x80,
-  0xc0, 0x18, 0x01, 0x08, 0x82, 0x20, 0xfe, 0xcd, 0x00, 0x8c, 0x00, 0x00,
-  0x23, 0x06, 0xca, 0x10, 0x84, 0x81, 0xc3, 0x44, 0x47, 0x82, 0x04, 0x83,
-  0x0c, 0x41, 0xc1, 0x8c, 0x18, 0x2c, 0x43, 0x40, 0x06, 0x8f, 0x33, 0x85,
-  0x41, 0xb2, 0x28, 0xc3, 0x18, 0x42, 0x20, 0x06, 0x73, 0x0c, 0x43, 0x40,
-  0x06, 0x23, 0x06, 0xcb, 0x10, 0x9c, 0x81, 0x14, 0x59, 0x65, 0xc0, 0x38,
-  0x8d, 0x31, 0x86, 0x10, 0x94, 0xc1, 0x1c, 0xc3, 0x10, 0x90, 0xc1, 0x5d,
-  0x7b, 0x29, 0x28, 0x83, 0x0c, 0x81, 0x43, 0x19, 0x11, 0xc0, 0x87, 0xb8,
-  0x32, 0xde, 0xc0, 0x85, 0x41, 0x1b, 0x5c, 0xb0, 0x97, 0x82, 0x32, 0xc8,
-  0x10, 0x50, 0xda, 0x88, 0x41, 0x21, 0x04, 0x74, 0x60, 0x04, 0xe3, 0x0d,
-  0x61, 0x60, 0x06, 0x6f, 0x70, 0xc1, 0x5e, 0x0a, 0xca, 0x20, 0x43, 0x90,
-  0x7d, 0x23, 0x06, 0x85, 0x10, 0xe4, 0xc1, 0x12, 0x8c, 0x37, 0x98, 0xc1,
-  0x1a, 0xc0, 0xc1, 0x05, 0x7b, 0x29, 0x28, 0x83, 0x0c, 0x81, 0x47, 0x06,
-  0x23, 0x06, 0x85, 0x10, 0xf8, 0x01, 0x14, 0xcc, 0x31, 0x84, 0xc1, 0xb2,
-  0x07, 0x73, 0x0c, 0xc1, 0xd1, 0x07, 0x73, 0x0c, 0xc1, 0xb0, 0x07, 0x16,
-  0x4c, 0xf2, 0xc9, 0x20, 0x20, 0x06, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
-  0x5b, 0x06, 0x26, 0x20, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b,
-  0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0xa8, 0x0c, 0x00, 0x00,
-  0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00,
-  0x27, 0x03, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00,
-  0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49,
-  0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19,
-  0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42,
-  0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44, 0x24,
-  0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21, 0x72,
-  0x24, 0x07, 0xc8, 0x48, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0,
-  0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00, 0x00, 0x91, 0x00, 0x00, 0x00,
-  0x1b, 0xcc, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x60, 0x00, 0x09,
-  0xa8, 0x88, 0x71, 0x78, 0x07, 0x79, 0x90, 0x87, 0x72, 0x18, 0x07, 0x7a,
-  0x60, 0x87, 0x7c, 0x68, 0x03, 0x79, 0x78, 0x87, 0x7a, 0x70, 0x07, 0x72,
-  0x28, 0x07, 0x72, 0x68, 0x03, 0x72, 0x48, 0x07, 0x7b, 0x48, 0x07, 0x72,
-  0x28, 0x87, 0x36, 0x98, 0x87, 0x78, 0x90, 0x07, 0x7a, 0x68, 0x03, 0x73,
-  0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xcc, 0x21,
-  0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xc8, 0x21, 0x1d, 0xe6, 0x21,
-  0x1c, 0xc4, 0x81, 0x1d, 0xca, 0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xd2, 0x81,
-  0x1d, 0xda, 0x60, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0x61, 0x1e, 0x00, 0x73,
-  0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x76, 0x28, 0x87, 0x79,
-  0x98, 0x87, 0x36, 0x80, 0x07, 0x79, 0x28, 0x87, 0x71, 0x48, 0x87, 0x79,
-  0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x87, 0x70, 0x20, 0x07, 0xc0,
-  0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1,
-  0x0d, 0xcc, 0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca, 0xa1, 0x0d, 0xe0, 0xe1,
-  0x1d, 0xd2, 0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xca, 0x81,
-  0x1d, 0xd2, 0xa1, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x60,
-  0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72,
-  0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79,
-  0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68, 0x87, 0x36, 0x70, 0x87, 0x77,
-  0x70, 0x87, 0x36, 0x60, 0x87, 0x72, 0x08, 0x07, 0x73, 0x00, 0x08, 0x77,
-  0x78, 0x87, 0x36, 0x48, 0x07, 0x77, 0x30, 0x87, 0x79, 0x68, 0x03, 0x73,
-  0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41,
-  0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xd4, 0xa1,
-  0x1e, 0xda, 0x01, 0x1e, 0xda, 0x80, 0x1e, 0xc2, 0x41, 0x1c, 0xd8, 0xa1,
-  0x1c, 0xe6, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80,
-  0x70, 0x87, 0x77, 0x68, 0x03, 0x77, 0x08, 0x07, 0x77, 0x98, 0x87, 0x36,
-  0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80,
-  0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x60,
-  0x1e, 0xd2, 0xe1, 0x1c, 0xdc, 0xa1, 0x1c, 0xc8, 0xa1, 0x0d, 0xf4, 0xa1,
-  0x1c, 0xe4, 0xe1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0,
-  0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72,
-  0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0xa0, 0x07, 0x79, 0x08, 0x07, 0x78,
-  0x80, 0x87, 0x74, 0x70, 0x87, 0x73, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a,
-  0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xe6, 0x81,
-  0x1e, 0xc2, 0x61, 0x1c, 0xd6, 0xa1, 0x0d, 0xe0, 0x41, 0x1e, 0xde, 0x81,
-  0x1e, 0xca, 0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0xa1, 0x0d, 0xc4, 0xa1,
-  0x1e, 0xcc, 0xc1, 0x1c, 0xca, 0x41, 0x1e, 0xda, 0x60, 0x1e, 0xd2, 0x41,
-  0x1f, 0xca, 0x01, 0xc0, 0x03, 0x80, 0xa8, 0x07, 0x77, 0x98, 0x87, 0x70,
-  0x30, 0x87, 0x72, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70,
-  0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xa2,
-  0x1e, 0xe6, 0xa1, 0x1c, 0xda, 0x60, 0x1e, 0xde, 0xc1, 0x1c, 0xe8, 0xa1,
-  0x0d, 0xcc, 0x81, 0x1d, 0xde, 0x21, 0x1c, 0xe8, 0x01, 0x30, 0x87, 0x70,
-  0x60, 0x87, 0x79, 0x28, 0x07, 0x60, 0x83, 0x21, 0x0c, 0xc0, 0x02, 0x54,
-  0x1b, 0x8c, 0x81, 0x00, 0x16, 0xa0, 0xda, 0x60, 0x10, 0x05, 0xb0, 0x00,
-  0xd5, 0x06, 0xa3, 0x30, 0x80, 0x05, 0xa8, 0x36, 0x18, 0xc6, 0x01, 0x2c,
-  0x40, 0xb5, 0xc1, 0x38, 0xfe, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x24, 0x80,
-  0xda, 0x80, 0x20, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x0c, 0x20, 0x01,
-  0xd5, 0x06, 0x23, 0x09, 0x80, 0x05, 0xa8, 0x36, 0x18, 0x8a, 0x00, 0x2c,
-  0x40, 0x05, 0x00, 0x00, 0x49, 0x18, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
-  0x13, 0x8c, 0x40, 0x18, 0x88, 0xc2, 0x98, 0x10, 0x1c, 0x13, 0x06, 0x24,
-  0x51, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
-  0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84,
-  0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c,
-  0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x6c, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30,
-  0x8c, 0x20, 0x00, 0x83, 0x08, 0x41, 0x30, 0x8c, 0x30, 0x00, 0x07, 0x49,
-  0x53, 0x44, 0x09, 0x93, 0x2f, 0xbb, 0x6f, 0x47, 0x08, 0xce, 0x40, 0x20,
-  0x82, 0x10, 0x42, 0x06, 0x11, 0x0a, 0xe1, 0x28, 0x69, 0x8a, 0x28, 0x61,
-  0xf2, 0xff, 0x89, 0xb8, 0x26, 0x2a, 0x22, 0x7e, 0x7b, 0xf8, 0xa7, 0x31,
-  0x02, 0x60, 0x10, 0xe1, 0x08, 0x2e, 0x92, 0xa6, 0x88, 0x12, 0x26, 0xff,
-  0x97, 0x00, 0xe6, 0x59, 0x88, 0xe8, 0x9f, 0xc6, 0x08, 0x80, 0x41, 0x84,
-  0x44, 0x28, 0x48, 0x08, 0x62, 0x18, 0x84, 0x14, 0xad, 0x32, 0x00, 0x42,
-  0xa8, 0xcd, 0x11, 0x04, 0x73, 0x04, 0x60, 0x30, 0x8c, 0x20, 0x40, 0x05,
-  0x09, 0x48, 0x89, 0x17, 0x1f, 0x20, 0x39, 0x10, 0x90, 0x02, 0x70, 0x18,
-  0x61, 0x80, 0x06, 0x11, 0x02, 0x61, 0x8e, 0x00, 0x14, 0x06, 0x11, 0x08,
-  0x61, 0x04, 0x00, 0x00, 0x13, 0xb2, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03,
-  0x3a, 0x68, 0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83,
-  0x76, 0x08, 0x87, 0x71, 0x78, 0x87, 0x79, 0xc0, 0x87, 0x38, 0x80, 0x03,
-  0x37, 0x88, 0x83, 0x38, 0x70, 0x03, 0x38, 0xd8, 0x70, 0x1b, 0xe5, 0xd0,
-  0x06, 0xf0, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0,
-  0x07, 0x76, 0x40, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0,
-  0x07, 0x78, 0xd0, 0x06, 0xe9, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80,
-  0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0,
-  0x07, 0x71, 0x60, 0x07, 0x6d, 0x90, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30,
-  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40,
-  0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60,
-  0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20,
-  0x07, 0x6d, 0x60, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0,
-  0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10,
-  0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40,
-  0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60,
-  0x0f, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20,
-  0x07, 0x6d, 0x60, 0x0f, 0x74, 0x80, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0,
-  0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60,
-  0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60,
-  0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80,
-  0x07, 0x6d, 0x60, 0x0f, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20,
-  0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10,
-  0x07, 0x79, 0x20, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20,
-  0x07, 0x75, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0,
-  0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0,
-  0x06, 0xf6, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20,
-  0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00,
-  0x07, 0x72, 0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0,
-  0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0,
-  0x07, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0x30, 0x84, 0x61, 0x00,
-  0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xc2, 0x38, 0x40, 0x00,
-  0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x61, 0x26, 0x20, 0x00, 0x06,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0xb2, 0x40, 0x00, 0x0b, 0x00, 0x00, 0x00,
-  0x32, 0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47,
-  0xc6, 0x04, 0x43, 0x82, 0x25, 0x30, 0x02, 0x50, 0x20, 0x45, 0x50, 0x08,
-  0x05, 0x18, 0x50, 0x10, 0x65, 0x50, 0x40, 0x05, 0x56, 0x0a, 0xc5, 0x40,
-  0x78, 0x04, 0x80, 0xea, 0x58, 0xc2, 0x02, 0x00, 0x79, 0x18, 0x00, 0x00,
-  0x16, 0x01, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25,
-  0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x06, 0x64, 0x50,
-  0x40, 0x05, 0x51, 0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3,
-  0x2b, 0x1b, 0x62, 0x40, 0x03, 0x25, 0x40, 0x07, 0xe1, 0x20, 0x08, 0x0e,
-  0x8e, 0xad, 0x0c, 0x84, 0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e,
-  0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x26, 0x06, 0x06, 0x26, 0xc6, 0x25, 0x86,
-  0x66, 0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65,
-  0x26, 0x06, 0x06, 0x26, 0xc6, 0x25, 0x86, 0x66, 0x26, 0x65, 0x88, 0x40,
-  0x11, 0x43, 0x0c, 0x68, 0x80, 0x12, 0x88, 0x60, 0xd1, 0x54, 0x46, 0x17,
-  0xc6, 0x36, 0x04, 0xa1, 0x0e, 0x68, 0x80, 0x06, 0x88, 0xe0, 0x16, 0x96,
-  0x26, 0xe7, 0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56,
-  0xe6, 0xf6, 0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96, 0x36, 0x17, 0x26, 0xc6,
-  0x56, 0x36, 0x44, 0xa0, 0x12, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f,
-  0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d,
-  0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x04,
-  0x6a, 0x61, 0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5, 0xc1, 0xa5,
-  0xb1, 0x95, 0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5, 0x99, 0x99,
-  0x95, 0xc9, 0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x91, 0xa5, 0xcd,
-  0x85, 0x89, 0xb1, 0x95, 0x0d, 0x11, 0xa8, 0x86, 0x51, 0x58, 0x9a, 0x9c,
-  0x8b, 0x5c, 0x99, 0x1b, 0x59, 0x99, 0xdc, 0x17, 0x5d, 0x98, 0xdc, 0x59,
-  0x19, 0x1d, 0xa3, 0xb0, 0x34, 0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba,
-  0x3c, 0xb8, 0xb2, 0x2f, 0xb7, 0xb0, 0xb6, 0x32, 0x1a, 0x66, 0x6c, 0x6f,
-  0x61, 0x74, 0x34, 0x43, 0x10, 0xea, 0x81, 0x08, 0x0a, 0xa2, 0xa2, 0x21,
-  0x02, 0x25, 0x91, 0x09, 0x4b, 0x93, 0x73, 0x81, 0x7b, 0x9b, 0x4b, 0xa3,
-  0x4b, 0x7b, 0x73, 0xa3, 0x12, 0x96, 0x26, 0xe7, 0x32, 0x56, 0xe6, 0x46,
-  0x57, 0x26, 0x47, 0x29, 0x2c, 0x4d, 0xce, 0xc5, 0xed, 0xed, 0x0b, 0xae,
-  0x4c, 0x6e, 0x0e, 0xae, 0x6c, 0x8c, 0x2e, 0xcd, 0xae, 0x8c, 0x4c, 0x58,
-  0x9a, 0x9c, 0x4b, 0x98, 0xdc, 0xd9, 0x97, 0x5b, 0x58, 0x5b, 0x19, 0x11,
-  0xb8, 0xb7, 0xb9, 0x34, 0xba, 0xb4, 0x37, 0xb7, 0x21, 0x10, 0x44, 0x50,
-  0x14, 0x55, 0x51, 0x16, 0x05, 0x51, 0x11, 0x75, 0x51, 0x18, 0xa5, 0xb0,
-  0x34, 0x39, 0x17, 0x33, 0xb9, 0xb0, 0xb3, 0xb6, 0x32, 0x37, 0xba, 0xaf,
-  0x34, 0x37, 0xb8, 0x3a, 0x3a, 0x66, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61,
-  0x74, 0x65, 0x64, 0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72,
-  0x64, 0x44, 0x76, 0x32, 0x5f, 0x66, 0x29, 0x7c, 0xc2, 0xd2, 0xe4, 0x5c,
-  0xe0, 0xca, 0xe4, 0xe6, 0xe0, 0xca, 0xc6, 0xe8, 0xd2, 0xec, 0xca, 0x68,
-  0x98, 0xb1, 0xbd, 0x85, 0xd1, 0xc9, 0x10, 0xa1, 0x2b, 0xc3, 0x1b, 0x7b,
-  0x7b, 0x93, 0x23, 0x1b, 0x22, 0x41, 0x03, 0xa5, 0x51, 0x1b, 0x55, 0x51,
-  0x1c, 0x05, 0x51, 0x1d, 0x75, 0x51, 0x1e, 0x95, 0xb0, 0x34, 0x39, 0x17,
-  0xb1, 0x3a, 0x33, 0xb3, 0x32, 0x39, 0x3e, 0x61, 0x69, 0x72, 0x2e, 0x62,
-  0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x94, 0xc2,
-  0xd2, 0xe4, 0x5c, 0xd8, 0xde, 0xc6, 0xc2, 0xe8, 0xd2, 0xde, 0xdc, 0xbe,
-  0xd2, 0xdc, 0xc8, 0xca, 0xf0, 0x88, 0x84, 0xa5, 0xc9, 0xb9, 0xc8, 0x95,
-  0x85, 0x91, 0x31, 0x0a, 0x4b, 0x93, 0x73, 0x09, 0x93, 0x3b, 0xfb, 0xa2,
-  0xcb, 0x83, 0x2b, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0xe3, 0x15, 0x96, 0x26,
-  0xe7, 0x12, 0x26, 0x77, 0xf6, 0x45, 0x97, 0x07, 0x57, 0xf6, 0x15, 0xc6,
-  0x96, 0x76, 0xe6, 0xf6, 0x35, 0x97, 0xa6, 0x57, 0xc6, 0x61, 0xec, 0x8d,
-  0x6d, 0x08, 0x18, 0x40, 0x06, 0x05, 0x06, 0x54, 0x18, 0x40, 0x05, 0x25,
-  0x06, 0x10, 0x01, 0x0d, 0xd4, 0x18, 0x50, 0x64, 0x00, 0x15, 0x54, 0x19,
-  0x40, 0x05, 0x05, 0x51, 0x11, 0x75, 0x51, 0x66, 0x40, 0x2a, 0x2c, 0x4d,
-  0xce, 0x65, 0x8e, 0x4e, 0xae, 0x6e, 0x8c, 0xee, 0x8b, 0x2e, 0x0f, 0xae,
-  0xec, 0x2b, 0xcd, 0xcd, 0xec, 0x8d, 0x86, 0x19, 0xdb, 0x5b, 0x18, 0xdd,
-  0x0c, 0x8d, 0x37, 0x33, 0xb3, 0xb9, 0x32, 0x3a, 0x1a, 0x52, 0x63, 0x6f,
-  0x65, 0x66, 0x66, 0x34, 0x8e, 0xc6, 0xde, 0xca, 0xcc, 0xcc, 0x68, 0x08,
-  0x8d, 0xbd, 0x95, 0x99, 0x99, 0x0d, 0x41, 0x03, 0x88, 0x80, 0x0a, 0x88,
-  0xa0, 0xd2, 0x80, 0x52, 0x03, 0xa8, 0x80, 0x0a, 0x88, 0xa0, 0xd2, 0x80,
-  0x5a, 0x03, 0x68, 0x81, 0x0a, 0x88, 0xa0, 0xd2, 0x80, 0x62, 0x03, 0x88,
-  0x81, 0x0a, 0x88, 0xa0, 0xd2, 0x80, 0x6a, 0x03, 0x26, 0x59, 0x55, 0x56,
-  0x44, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x34, 0xc8, 0xca, 0xc6, 0xde, 0xc8,
-  0xca, 0x86, 0x90, 0x01, 0xa4, 0x50, 0x60, 0x40, 0x85, 0x01, 0x84, 0x50,
-  0x62, 0x00, 0x0d, 0xd0, 0x40, 0x8d, 0x01, 0x85, 0x06, 0x94, 0x1b, 0x50,
-  0x64, 0x00, 0x21, 0x54, 0x19, 0x40, 0x05, 0x05, 0x51, 0x6f, 0x40, 0x5d,
-  0x14, 0x1c, 0x70, 0x09, 0x4b, 0x93, 0x73, 0xa1, 0x2b, 0xc3, 0xa3, 0xab,
-  0x93, 0x2b, 0xa3, 0x12, 0x96, 0x26, 0xe7, 0x32, 0x17, 0xd6, 0x06, 0xc7,
-  0x56, 0x46, 0x8c, 0xae, 0x0c, 0x8f, 0xae, 0x4e, 0xae, 0x4c, 0x86, 0x8c,
-  0xc7, 0x8c, 0xed, 0x2d, 0x8c, 0x8e, 0x05, 0x64, 0x2e, 0xac, 0x0d, 0x8e,
-  0xad, 0xcc, 0x87, 0x04, 0x5d, 0x19, 0x5e, 0xd6, 0x10, 0x0a, 0x3a, 0x28,
-  0x39, 0xa0, 0xc4, 0x00, 0x22, 0xa0, 0x81, 0x9a, 0x03, 0x0a, 0xa2, 0xe8,
-  0x80, 0xba, 0xa8, 0x3a, 0x60, 0x41, 0x57, 0x86, 0x57, 0x65, 0x35, 0x84,
-  0x82, 0x1a, 0x4a, 0x0e, 0x28, 0x31, 0x80, 0x06, 0x68, 0xa0, 0xe6, 0x80,
-  0x82, 0x28, 0x3a, 0xa0, 0x2e, 0xea, 0x0e, 0xb8, 0x84, 0xa5, 0xc9, 0xb9,
-  0xcc, 0x85, 0xb5, 0xc1, 0xb1, 0x95, 0xc9, 0xf1, 0x98, 0x0b, 0x6b, 0x83,
-  0x63, 0x2b, 0x93, 0x63, 0x30, 0x37, 0x44, 0x82, 0x1c, 0x2a, 0x0f, 0x28,
-  0x31, 0x80, 0x08, 0x68, 0xa0, 0x20, 0x4a, 0x0f, 0xa8, 0x8b, 0xda, 0x83,
-  0x21, 0x0e, 0x95, 0x51, 0x1f, 0x75, 0x06, 0x54, 0x1c, 0x50, 0x76, 0x40,
-  0xe1, 0x01, 0xc5, 0x07, 0x43, 0x0c, 0x06, 0xa0, 0x26, 0xaa, 0x0f, 0xf8,
-  0xbc, 0xb5, 0xb9, 0xa5, 0xc1, 0xbd, 0xd1, 0x95, 0xb9, 0xd1, 0x81, 0x8c,
-  0xa1, 0x85, 0xc9, 0xf1, 0x99, 0x4a, 0x6b, 0x83, 0x63, 0x2b, 0x03, 0x19,
-  0x5a, 0x59, 0x01, 0xa1, 0x12, 0x0a, 0x0a, 0x1a, 0x22, 0x50, 0xa0, 0x30,
-  0xc4, 0xa0, 0xfe, 0x80, 0x0a, 0x05, 0xec, 0x19, 0x62, 0x50, 0xa2, 0x40,
-  0x89, 0x02, 0xf6, 0x8c, 0x88, 0xd8, 0x81, 0x1d, 0xec, 0xa1, 0x1d, 0xdc,
-  0xa0, 0x1d, 0xde, 0x81, 0x1c, 0xea, 0x81, 0x1d, 0xca, 0xc1, 0x0d, 0xcc,
-  0x81, 0x1d, 0xc2, 0xe1, 0x1c, 0xe6, 0x61, 0x8a, 0x10, 0x0c, 0x23, 0x14,
-  0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x48, 0x07, 0x72, 0x28, 0x07,
-  0x77, 0xa0, 0x87, 0x29, 0x41, 0x31, 0x62, 0x09, 0x87, 0x74, 0x90, 0x07,
-  0x37, 0xb0, 0x87, 0x72, 0x90, 0x87, 0x79, 0x48, 0x87, 0x77, 0x70, 0x87,
-  0x29, 0x81, 0x31, 0x82, 0x0a, 0x87, 0x74, 0x90, 0x07, 0x37, 0x60, 0x87,
-  0x70, 0x70, 0x87, 0x73, 0xa8, 0x87, 0x70, 0x38, 0x87, 0x72, 0xf8, 0x05,
-  0x7b, 0x28, 0x07, 0x79, 0x98, 0x87, 0x74, 0x78, 0x07, 0x77, 0x98, 0x12,
-  0x20, 0x23, 0xa6, 0x70, 0x48, 0x07, 0x79, 0x70, 0x83, 0x71, 0x78, 0x87,
-  0x76, 0x80, 0x87, 0x74, 0x60, 0x87, 0x72, 0xf8, 0x85, 0x77, 0x80, 0x07,
-  0x7a, 0x48, 0x87, 0x77, 0x70, 0x87, 0x79, 0x98, 0x32, 0x28, 0x8c, 0x33,
-  0x82, 0x09, 0x87, 0x74, 0x90, 0x07, 0x37, 0x30, 0x07, 0x79, 0x08, 0x87,
-  0x73, 0x68, 0x87, 0x72, 0x70, 0x07, 0x7a, 0x98, 0x12, 0xf8, 0x01, 0x00,
-  0x79, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c,
-  0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3,
-  0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6,
-  0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e,
-  0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43,
-  0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03,
-  0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48,
-  0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20,
-  0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e,
-  0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d,
-  0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89,
-  0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83,
-  0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68,
-  0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90,
-  0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78,
-  0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98,
-  0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5,
-  0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c,
-  0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c,
-  0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43,
-  0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43,
-  0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82,
-  0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58,
-  0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18,
-  0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2,
-  0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec,
-  0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e,
-  0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d,
-  0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83,
-  0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60,
-  0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0,
-  0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d,
-  0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d,
-  0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43,
-  0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3,
-  0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18,
-  0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3,
-  0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1,
-  0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e,
-  0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83,
-  0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83,
-  0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20, 0x00, 0x00,
-  0x0d, 0x00, 0x00, 0x00, 0x16, 0xd0, 0x00, 0x48, 0xe4, 0x0f, 0xce, 0xe4,
-  0x57, 0x77, 0x71, 0xdb, 0x26, 0xb0, 0x01, 0x48, 0xe4, 0x4b, 0x00, 0xf3,
-  0x2c, 0xc4, 0x3f, 0x11, 0xd7, 0x44, 0x45, 0xc4, 0x6f, 0x0f, 0x7e, 0x85,
-  0x17, 0xb7, 0x6d, 0x00, 0x11, 0xdb, 0x95, 0xff, 0xf9, 0xd6, 0xf6, 0x5f,
-  0x44, 0x80, 0xc1, 0x10, 0xcd, 0x04, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00,
-  0x38, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00,
-  0x0e, 0x00, 0x00, 0x00, 0x64, 0xc7, 0x1a, 0x80, 0x81, 0x98, 0x63, 0x20,
-  0x86, 0x6f, 0x8e, 0x81, 0xf8, 0xbe, 0xb1, 0x06, 0x20, 0x10, 0x28, 0x8e,
-  0x00, 0xd0, 0xab, 0x81, 0x11, 0x00, 0x82, 0x33, 0x00, 0x14, 0xe6, 0x20,
-  0xc8, 0x80, 0x0c, 0xc8, 0x40, 0x0c, 0x66, 0x00, 0x08, 0x8c, 0x11, 0x80,
-  0x20, 0x08, 0xe2, 0xdf, 0x08, 0xc0, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x23, 0x06, 0xca, 0x10, 0x8c, 0x01, 0xe4, 0x4c, 0x48, 0x72, 0x08, 0x83,
-  0x0c, 0x41, 0xc1, 0x8c, 0x18, 0x28, 0x43, 0x50, 0x06, 0x11, 0x54, 0x29,
-  0x4b, 0x42, 0x0c, 0x32, 0x04, 0xc7, 0x33, 0xc8, 0x30, 0x04, 0xd1, 0x59,
-  0x77, 0x29, 0x28, 0x83, 0x0c, 0xc1, 0x12, 0x19, 0x11, 0xc0, 0x87, 0xb6,
-  0x32, 0xde, 0xb0, 0x81, 0x01, 0x1b, 0x5c, 0x70, 0x97, 0x82, 0x32, 0xc8,
-  0x10, 0x44, 0xd7, 0x88, 0x41, 0x21, 0x04, 0x72, 0x60, 0x04, 0xe3, 0x0d,
-  0x60, 0x50, 0x06, 0x6e, 0x70, 0xc1, 0x5d, 0x0a, 0xca, 0x20, 0x43, 0x60,
-  0x71, 0x23, 0x06, 0x85, 0x10, 0xdc, 0xc1, 0x12, 0x8c, 0x37, 0x94, 0x81,
-  0x1a, 0xbc, 0xc1, 0x05, 0x77, 0x29, 0x28, 0x83, 0x0c, 0xc1, 0x16, 0x06,
-  0x23, 0x06, 0x85, 0x10, 0xf0, 0x01, 0x14, 0xcc, 0x31, 0x78, 0x8b, 0x1e,
-  0xcc, 0x31, 0x04, 0x07, 0x1f, 0xcc, 0x31, 0x04, 0x83, 0x1e, 0x58, 0x30,
-  0xc9, 0x27, 0x83, 0x80, 0x18, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
-  0x5b, 0x86, 0x24, 0x18, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b,
-  0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0xb4, 0x0c, 0x00, 0x00,
-  0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00,
-  0x2a, 0x03, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00,
-  0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49,
-  0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19,
-  0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42,
-  0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44, 0x24,
-  0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21, 0x72,
-  0x24, 0x07, 0xc8, 0x48, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0,
-  0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00, 0x00, 0x91, 0x00, 0x00, 0x00,
-  0x1b, 0xcc, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x60, 0x00, 0x09,
-  0xa8, 0x88, 0x71, 0x78, 0x07, 0x79, 0x90, 0x87, 0x72, 0x18, 0x07, 0x7a,
-  0x60, 0x87, 0x7c, 0x68, 0x03, 0x79, 0x78, 0x87, 0x7a, 0x70, 0x07, 0x72,
-  0x28, 0x07, 0x72, 0x68, 0x03, 0x72, 0x48, 0x07, 0x7b, 0x48, 0x07, 0x72,
-  0x28, 0x87, 0x36, 0x98, 0x87, 0x78, 0x90, 0x07, 0x7a, 0x68, 0x03, 0x73,
-  0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xcc, 0x21,
-  0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xc8, 0x21, 0x1d, 0xe6, 0x21,
-  0x1c, 0xc4, 0x81, 0x1d, 0xca, 0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xd2, 0x81,
-  0x1d, 0xda, 0x60, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0x61, 0x1e, 0x00, 0x73,
-  0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x76, 0x28, 0x87, 0x79,
-  0x98, 0x87, 0x36, 0x80, 0x07, 0x79, 0x28, 0x87, 0x71, 0x48, 0x87, 0x79,
-  0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x87, 0x70, 0x20, 0x07, 0xc0,
-  0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1,
-  0x0d, 0xcc, 0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca, 0xa1, 0x0d, 0xe0, 0xe1,
-  0x1d, 0xd2, 0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xca, 0x81,
-  0x1d, 0xd2, 0xa1, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x60,
-  0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72,
-  0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79,
-  0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68, 0x87, 0x36, 0x70, 0x87, 0x77,
-  0x70, 0x87, 0x36, 0x60, 0x87, 0x72, 0x08, 0x07, 0x73, 0x00, 0x08, 0x77,
-  0x78, 0x87, 0x36, 0x48, 0x07, 0x77, 0x30, 0x87, 0x79, 0x68, 0x03, 0x73,
-  0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41,
-  0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xd4, 0xa1,
-  0x1e, 0xda, 0x01, 0x1e, 0xda, 0x80, 0x1e, 0xc2, 0x41, 0x1c, 0xd8, 0xa1,
-  0x1c, 0xe6, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80,
-  0x70, 0x87, 0x77, 0x68, 0x03, 0x77, 0x08, 0x07, 0x77, 0x98, 0x87, 0x36,
-  0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80,
-  0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x60,
-  0x1e, 0xd2, 0xe1, 0x1c, 0xdc, 0xa1, 0x1c, 0xc8, 0xa1, 0x0d, 0xf4, 0xa1,
-  0x1c, 0xe4, 0xe1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0,
-  0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72,
-  0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0xa0, 0x07, 0x79, 0x08, 0x07, 0x78,
-  0x80, 0x87, 0x74, 0x70, 0x87, 0x73, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a,
-  0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xe6, 0x81,
-  0x1e, 0xc2, 0x61, 0x1c, 0xd6, 0xa1, 0x0d, 0xe0, 0x41, 0x1e, 0xde, 0x81,
-  0x1e, 0xca, 0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0xa1, 0x0d, 0xc4, 0xa1,
-  0x1e, 0xcc, 0xc1, 0x1c, 0xca, 0x41, 0x1e, 0xda, 0x60, 0x1e, 0xd2, 0x41,
-  0x1f, 0xca, 0x01, 0xc0, 0x03, 0x80, 0xa8, 0x07, 0x77, 0x98, 0x87, 0x70,
-  0x30, 0x87, 0x72, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70,
-  0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xa2,
-  0x1e, 0xe6, 0xa1, 0x1c, 0xda, 0x60, 0x1e, 0xde, 0xc1, 0x1c, 0xe8, 0xa1,
-  0x0d, 0xcc, 0x81, 0x1d, 0xde, 0x21, 0x1c, 0xe8, 0x01, 0x30, 0x87, 0x70,
-  0x60, 0x87, 0x79, 0x28, 0x07, 0x60, 0x83, 0x21, 0x0c, 0xc0, 0x02, 0x54,
-  0x1b, 0x8c, 0x81, 0x00, 0x16, 0xa0, 0xda, 0x60, 0x10, 0x05, 0xb0, 0x00,
-  0xd5, 0x06, 0xa3, 0x30, 0x80, 0x05, 0xa8, 0x36, 0x18, 0xc6, 0x01, 0x2c,
-  0x40, 0xb5, 0xc1, 0x38, 0xfe, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x24, 0x80,
-  0xda, 0x80, 0x20, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x0c, 0x20, 0x01,
-  0xd5, 0x06, 0x23, 0x09, 0x80, 0x05, 0xa8, 0x36, 0x18, 0x8a, 0x00, 0x2c,
-  0x40, 0x05, 0x00, 0x00, 0x49, 0x18, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
-  0x13, 0x8c, 0x40, 0x18, 0x88, 0xc2, 0x98, 0x10, 0x1c, 0x13, 0x06, 0x24,
-  0x51, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
-  0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84,
-  0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c,
-  0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x6c, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30,
-  0x8c, 0x20, 0x00, 0x83, 0x08, 0x41, 0x30, 0x8c, 0x30, 0x00, 0x07, 0x49,
-  0x53, 0x44, 0x09, 0x93, 0x2f, 0xbb, 0x6f, 0x47, 0x08, 0xce, 0x40, 0x20,
-  0x82, 0x10, 0x42, 0x06, 0x11, 0x0a, 0xe1, 0x28, 0x69, 0x8a, 0x28, 0x61,
-  0xf2, 0xff, 0x89, 0xb8, 0x26, 0x2a, 0x22, 0x7e, 0x7b, 0xf8, 0xa7, 0x31,
-  0x02, 0x60, 0x10, 0xe1, 0x08, 0x2e, 0x92, 0xa6, 0x88, 0x12, 0x26, 0xff,
-  0x97, 0x00, 0xe6, 0x59, 0x88, 0xe8, 0x9f, 0xc6, 0x08, 0x80, 0x41, 0x84,
-  0x44, 0x28, 0x48, 0x08, 0x62, 0x18, 0x84, 0x14, 0xad, 0x32, 0x00, 0x42,
-  0xa8, 0xcd, 0x11, 0x04, 0x73, 0x04, 0x60, 0x30, 0x8c, 0x20, 0x40, 0x05,
-  0x09, 0x48, 0x89, 0x17, 0x1f, 0x20, 0x39, 0x10, 0x90, 0x02, 0x70, 0x18,
-  0x61, 0x80, 0x06, 0x11, 0x02, 0x61, 0x8e, 0x00, 0x14, 0x06, 0x11, 0x08,
-  0x61, 0x04, 0x00, 0x00, 0x13, 0xb2, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03,
-  0x3a, 0x68, 0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83,
-  0x76, 0x08, 0x87, 0x71, 0x78, 0x87, 0x79, 0xc0, 0x87, 0x38, 0x80, 0x03,
-  0x37, 0x88, 0x83, 0x38, 0x70, 0x03, 0x38, 0xd8, 0x70, 0x1b, 0xe5, 0xd0,
-  0x06, 0xf0, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0,
-  0x07, 0x76, 0x40, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0,
-  0x07, 0x78, 0xd0, 0x06, 0xe9, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80,
-  0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0,
-  0x07, 0x71, 0x60, 0x07, 0x6d, 0x90, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30,
-  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40,
-  0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60,
-  0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20,
-  0x07, 0x6d, 0x60, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0,
-  0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10,
-  0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40,
-  0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60,
-  0x0f, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20,
-  0x07, 0x6d, 0x60, 0x0f, 0x74, 0x80, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0,
-  0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60,
-  0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60,
-  0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80,
-  0x07, 0x6d, 0x60, 0x0f, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20,
-  0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10,
-  0x07, 0x79, 0x20, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20,
-  0x07, 0x75, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0,
-  0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0,
-  0x06, 0xf6, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20,
-  0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00,
-  0x07, 0x72, 0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0,
-  0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0,
-  0x07, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0x30, 0x84, 0x61, 0x00,
-  0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xc2, 0x38, 0x40, 0x00,
-  0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x61, 0x26, 0x20, 0x00, 0x06,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0xb2, 0x40, 0x00, 0x0b, 0x00, 0x00, 0x00,
-  0x32, 0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47,
-  0xc6, 0x04, 0x43, 0x82, 0x25, 0x30, 0x02, 0x50, 0x20, 0x45, 0x50, 0x08,
-  0x05, 0x18, 0x50, 0x10, 0x65, 0x50, 0x40, 0x05, 0x56, 0x0a, 0xc5, 0x40,
-  0x78, 0x04, 0x80, 0xea, 0x58, 0xc2, 0x02, 0x00, 0x79, 0x18, 0x00, 0x00,
-  0x16, 0x01, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25,
-  0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x06, 0x64, 0x50,
-  0x40, 0x05, 0x51, 0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3,
-  0x2b, 0x1b, 0x62, 0x40, 0x03, 0x25, 0x40, 0x07, 0xe1, 0x20, 0x08, 0x0e,
-  0x8e, 0xad, 0x0c, 0x84, 0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e,
-  0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x26, 0x06, 0x06, 0x26, 0xc6, 0x25, 0x86,
-  0x66, 0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65,
-  0x26, 0x06, 0x06, 0x26, 0xc6, 0x25, 0x86, 0x66, 0x26, 0x65, 0x88, 0x40,
-  0x11, 0x43, 0x0c, 0x68, 0x80, 0x12, 0x88, 0x60, 0xd1, 0x54, 0x46, 0x17,
-  0xc6, 0x36, 0x04, 0xa1, 0x0e, 0x68, 0x80, 0x06, 0x88, 0xe0, 0x16, 0x96,
-  0x26, 0xe7, 0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56,
-  0xe6, 0xf6, 0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96, 0x36, 0x17, 0x26, 0xc6,
-  0x56, 0x36, 0x44, 0xa0, 0x12, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f,
-  0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d,
-  0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x04,
-  0x6a, 0x61, 0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5, 0xc1, 0xa5,
-  0xb1, 0x95, 0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5, 0x99, 0x99,
-  0x95, 0xc9, 0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x91, 0xa5, 0xcd,
-  0x85, 0x89, 0xb1, 0x95, 0x0d, 0x11, 0xa8, 0x86, 0x51, 0x58, 0x9a, 0x9c,
-  0x8b, 0x5c, 0x99, 0x1b, 0x59, 0x99, 0xdc, 0x17, 0x5d, 0x98, 0xdc, 0x59,
-  0x19, 0x1d, 0xa3, 0xb0, 0x34, 0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba,
-  0x3c, 0xb8, 0xb2, 0x2f, 0xb7, 0xb0, 0xb6, 0x32, 0x1a, 0x66, 0x6c, 0x6f,
-  0x61, 0x74, 0x34, 0x43, 0x10, 0xea, 0x81, 0x08, 0x0a, 0xa2, 0xa2, 0x21,
-  0x02, 0x25, 0x91, 0x09, 0x4b, 0x93, 0x73, 0x81, 0x7b, 0x9b, 0x4b, 0xa3,
-  0x4b, 0x7b, 0x73, 0xa3, 0x12, 0x96, 0x26, 0xe7, 0x32, 0x56, 0xe6, 0x46,
-  0x57, 0x26, 0x47, 0x29, 0x2c, 0x4d, 0xce, 0xc5, 0xed, 0xed, 0x0b, 0xae,
-  0x4c, 0x6e, 0x0e, 0xae, 0x6c, 0x8c, 0x2e, 0xcd, 0xae, 0x8c, 0x4c, 0x58,
-  0x9a, 0x9c, 0x4b, 0x98, 0xdc, 0xd9, 0x97, 0x5b, 0x58, 0x5b, 0x19, 0x11,
-  0xb8, 0xb7, 0xb9, 0x34, 0xba, 0xb4, 0x37, 0xb7, 0x21, 0x10, 0x44, 0x50,
-  0x14, 0x55, 0x51, 0x16, 0x05, 0x51, 0x11, 0x75, 0x51, 0x18, 0xa5, 0xb0,
-  0x34, 0x39, 0x17, 0x33, 0xb9, 0xb0, 0xb3, 0xb6, 0x32, 0x37, 0xba, 0xaf,
-  0x34, 0x37, 0xb8, 0x3a, 0x3a, 0x66, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61,
-  0x74, 0x65, 0x64, 0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72,
-  0x64, 0x44, 0x76, 0x32, 0x5f, 0x66, 0x29, 0x7c, 0xc2, 0xd2, 0xe4, 0x5c,
-  0xe0, 0xca, 0xe4, 0xe6, 0xe0, 0xca, 0xc6, 0xe8, 0xd2, 0xec, 0xca, 0x68,
-  0x98, 0xb1, 0xbd, 0x85, 0xd1, 0xc9, 0x10, 0xa1, 0x2b, 0xc3, 0x1b, 0x7b,
-  0x7b, 0x93, 0x23, 0x1b, 0x22, 0x41, 0x03, 0xa5, 0x51, 0x1b, 0x55, 0x51,
-  0x1c, 0x05, 0x51, 0x1d, 0x75, 0x51, 0x1e, 0x95, 0xb0, 0x34, 0x39, 0x17,
-  0xb1, 0x3a, 0x33, 0xb3, 0x32, 0x39, 0x3e, 0x61, 0x69, 0x72, 0x2e, 0x62,
-  0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x94, 0xc2,
-  0xd2, 0xe4, 0x5c, 0xd8, 0xde, 0xc6, 0xc2, 0xe8, 0xd2, 0xde, 0xdc, 0xbe,
-  0xd2, 0xdc, 0xc8, 0xca, 0xf0, 0x88, 0x84, 0xa5, 0xc9, 0xb9, 0xc8, 0x95,
-  0x85, 0x91, 0x31, 0x0a, 0x4b, 0x93, 0x73, 0x09, 0x93, 0x3b, 0xfb, 0xa2,
-  0xcb, 0x83, 0x2b, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0xe3, 0x15, 0x96, 0x26,
-  0xe7, 0x12, 0x26, 0x77, 0xf6, 0x45, 0x97, 0x07, 0x57, 0xf6, 0x15, 0xc6,
-  0x96, 0x76, 0xe6, 0xf6, 0x35, 0x97, 0xa6, 0x57, 0xc6, 0x61, 0xec, 0x8d,
-  0x6d, 0x08, 0x18, 0x40, 0x06, 0x05, 0x06, 0x54, 0x18, 0x40, 0x05, 0x25,
-  0x06, 0x10, 0x01, 0x0d, 0xd4, 0x18, 0x50, 0x64, 0x00, 0x15, 0x54, 0x19,
-  0x40, 0x05, 0x05, 0x51, 0x11, 0x75, 0x51, 0x66, 0x40, 0x2a, 0x2c, 0x4d,
-  0xce, 0x65, 0x8e, 0x4e, 0xae, 0x6e, 0x8c, 0xee, 0x8b, 0x2e, 0x0f, 0xae,
-  0xec, 0x2b, 0xcd, 0xcd, 0xec, 0x8d, 0x86, 0x19, 0xdb, 0x5b, 0x18, 0xdd,
-  0x0c, 0x8d, 0x37, 0x33, 0xb3, 0xb9, 0x32, 0x3a, 0x1a, 0x52, 0x63, 0x6f,
-  0x65, 0x66, 0x66, 0x34, 0x8e, 0xc6, 0xde, 0xca, 0xcc, 0xcc, 0x68, 0x08,
-  0x8d, 0xbd, 0x95, 0x99, 0x99, 0x0d, 0x41, 0x03, 0x88, 0x80, 0x0a, 0x88,
-  0xa0, 0xd2, 0x80, 0x52, 0x03, 0xa8, 0x80, 0x0a, 0x88, 0xa0, 0xd2, 0x80,
-  0x5a, 0x03, 0x68, 0x81, 0x0a, 0x88, 0xa0, 0xd2, 0x80, 0x62, 0x03, 0x88,
-  0x81, 0x0a, 0x88, 0xa0, 0xd2, 0x80, 0x6a, 0x03, 0x26, 0x59, 0x55, 0x56,
-  0x44, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x34, 0xc8, 0xca, 0xc6, 0xde, 0xc8,
-  0xca, 0x86, 0x90, 0x01, 0xa4, 0x50, 0x60, 0x40, 0x85, 0x01, 0x84, 0x50,
-  0x62, 0x00, 0x0d, 0xd0, 0x40, 0x8d, 0x01, 0x85, 0x06, 0x94, 0x1b, 0x50,
-  0x64, 0x00, 0x21, 0x54, 0x19, 0x40, 0x05, 0x05, 0x51, 0x6f, 0x40, 0x5d,
-  0x14, 0x1c, 0x70, 0x09, 0x4b, 0x93, 0x73, 0xa1, 0x2b, 0xc3, 0xa3, 0xab,
-  0x93, 0x2b, 0xa3, 0x12, 0x96, 0x26, 0xe7, 0x32, 0x17, 0xd6, 0x06, 0xc7,
-  0x56, 0x46, 0x8c, 0xae, 0x0c, 0x8f, 0xae, 0x4e, 0xae, 0x4c, 0x86, 0x8c,
-  0xc7, 0x8c, 0xed, 0x2d, 0x8c, 0x8e, 0x05, 0x64, 0x2e, 0xac, 0x0d, 0x8e,
-  0xad, 0xcc, 0x87, 0x04, 0x5d, 0x19, 0x5e, 0xd6, 0x10, 0x0a, 0x3a, 0x28,
-  0x39, 0xa0, 0xc4, 0x00, 0x22, 0xa0, 0x81, 0x9a, 0x03, 0x0a, 0xa2, 0xe8,
-  0x80, 0xba, 0xa8, 0x3a, 0x60, 0x41, 0x57, 0x86, 0x57, 0x65, 0x35, 0x84,
-  0x82, 0x1a, 0x4a, 0x0e, 0x28, 0x31, 0x80, 0x06, 0x68, 0xa0, 0xe6, 0x80,
-  0x82, 0x28, 0x3a, 0xa0, 0x2e, 0xea, 0x0e, 0xb8, 0x84, 0xa5, 0xc9, 0xb9,
-  0xcc, 0x85, 0xb5, 0xc1, 0xb1, 0x95, 0xc9, 0xf1, 0x98, 0x0b, 0x6b, 0x83,
-  0x63, 0x2b, 0x93, 0x63, 0x30, 0x37, 0x44, 0x82, 0x1c, 0x2a, 0x0f, 0x28,
-  0x31, 0x80, 0x08, 0x68, 0xa0, 0x20, 0x4a, 0x0f, 0xa8, 0x8b, 0xda, 0x83,
-  0x21, 0x0e, 0x95, 0x51, 0x1f, 0x75, 0x06, 0x54, 0x1c, 0x50, 0x76, 0x40,
-  0xe1, 0x01, 0xc5, 0x07, 0x43, 0x0c, 0x06, 0xa0, 0x26, 0xaa, 0x0f, 0xf8,
-  0xbc, 0xb5, 0xb9, 0xa5, 0xc1, 0xbd, 0xd1, 0x95, 0xb9, 0xd1, 0x81, 0x8c,
-  0xa1, 0x85, 0xc9, 0xf1, 0x99, 0x4a, 0x6b, 0x83, 0x63, 0x2b, 0x03, 0x19,
-  0x5a, 0x59, 0x01, 0xa1, 0x12, 0x0a, 0x0a, 0x1a, 0x22, 0x50, 0xa0, 0x30,
-  0xc4, 0xa0, 0xfe, 0x80, 0x0a, 0x05, 0xec, 0x19, 0x62, 0x50, 0xa2, 0x40,
-  0x89, 0x02, 0xf6, 0x8c, 0x88, 0xd8, 0x81, 0x1d, 0xec, 0xa1, 0x1d, 0xdc,
-  0xa0, 0x1d, 0xde, 0x81, 0x1c, 0xea, 0x81, 0x1d, 0xca, 0xc1, 0x0d, 0xcc,
-  0x81, 0x1d, 0xc2, 0xe1, 0x1c, 0xe6, 0x61, 0x8a, 0x10, 0x0c, 0x23, 0x14,
-  0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x48, 0x07, 0x72, 0x28, 0x07,
-  0x77, 0xa0, 0x87, 0x29, 0x41, 0x31, 0x62, 0x09, 0x87, 0x74, 0x90, 0x07,
-  0x37, 0xb0, 0x87, 0x72, 0x90, 0x87, 0x79, 0x48, 0x87, 0x77, 0x70, 0x87,
-  0x29, 0x81, 0x31, 0x82, 0x0a, 0x87, 0x74, 0x90, 0x07, 0x37, 0x60, 0x87,
-  0x70, 0x70, 0x87, 0x73, 0xa8, 0x87, 0x70, 0x38, 0x87, 0x72, 0xf8, 0x05,
-  0x7b, 0x28, 0x07, 0x79, 0x98, 0x87, 0x74, 0x78, 0x07, 0x77, 0x98, 0x12,
-  0x20, 0x23, 0xa6, 0x70, 0x48, 0x07, 0x79, 0x70, 0x83, 0x71, 0x78, 0x87,
-  0x76, 0x80, 0x87, 0x74, 0x60, 0x87, 0x72, 0xf8, 0x85, 0x77, 0x80, 0x07,
-  0x7a, 0x48, 0x87, 0x77, 0x70, 0x87, 0x79, 0x98, 0x32, 0x28, 0x8c, 0x33,
-  0x82, 0x09, 0x87, 0x74, 0x90, 0x07, 0x37, 0x30, 0x07, 0x79, 0x08, 0x87,
-  0x73, 0x68, 0x87, 0x72, 0x70, 0x07, 0x7a, 0x98, 0x12, 0xf8, 0x01, 0x00,
-  0x79, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c,
-  0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3,
-  0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6,
-  0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e,
-  0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43,
-  0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03,
-  0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48,
-  0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20,
-  0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e,
-  0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d,
-  0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89,
-  0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83,
-  0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68,
-  0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90,
-  0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78,
-  0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98,
-  0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5,
-  0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c,
-  0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c,
-  0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43,
-  0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43,
-  0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82,
-  0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58,
-  0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18,
-  0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2,
-  0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec,
-  0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e,
-  0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d,
-  0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83,
-  0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60,
-  0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0,
-  0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d,
-  0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d,
-  0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43,
-  0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3,
-  0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18,
-  0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3,
-  0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1,
-  0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e,
-  0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83,
-  0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83,
-  0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20, 0x00, 0x00,
-  0x0d, 0x00, 0x00, 0x00, 0x16, 0xd0, 0x00, 0x48, 0xe4, 0x0f, 0xce, 0xe4,
-  0x57, 0x77, 0x71, 0xdb, 0x26, 0xb0, 0x01, 0x48, 0xe4, 0x4b, 0x00, 0xf3,
-  0x2c, 0xc4, 0x3f, 0x11, 0xd7, 0x44, 0x45, 0xc4, 0x6f, 0x0f, 0x7e, 0x85,
-  0x17, 0xb7, 0x6d, 0x00, 0x11, 0xdb, 0x95, 0xff, 0xf9, 0xda, 0xf5, 0x5f,
-  0x44, 0x80, 0xc1, 0x10, 0xcd, 0x04, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00,
-  0x3b, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00,
-  0x10, 0x00, 0x00, 0x00, 0x64, 0xc7, 0x1a, 0x80, 0x81, 0x98, 0x63, 0x20,
-  0x06, 0x30, 0x98, 0x63, 0x20, 0xc0, 0x00, 0x0c, 0xc6, 0x1a, 0x80, 0x40,
-  0xa0, 0x38, 0x96, 0x10, 0x00, 0x23, 0x00, 0xf4, 0x6a, 0x60, 0x04, 0x80,
-  0xe0, 0x0c, 0x00, 0x89, 0x19, 0x00, 0x0a, 0x73, 0x10, 0x66, 0x60, 0x06,
+  0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xc8, 0x21, 0x1d,
+  0xe6, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0xa1, 0x0d, 0xe8, 0x21, 0x1c,
+  0xd2, 0x81, 0x1d, 0xda, 0x60, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0x61, 0x1e,
+  0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x76, 0x28,
+  0x87, 0x79, 0x98, 0x87, 0x36, 0x80, 0x07, 0x79, 0x28, 0x87, 0x71, 0x48,
+  0x87, 0x79, 0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x87, 0x70, 0x20,
+  0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0xc2, 0x1d,
+  0xde, 0xa1, 0x0d, 0xcc, 0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca, 0xa1, 0x0d,
+  0xe0, 0xe1, 0x1d, 0xd2, 0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d,
+  0xca, 0x81, 0x1d, 0xd2, 0xa1, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28,
+  0x07, 0x60, 0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68,
+  0x87, 0x72, 0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28,
+  0x07, 0x79, 0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68, 0x87, 0x36, 0x70,
+  0x87, 0x77, 0x70, 0x87, 0x36, 0x60, 0x87, 0x72, 0x08, 0x07, 0x73, 0x00,
+  0x08, 0x77, 0x78, 0x87, 0x36, 0x48, 0x07, 0x77, 0x30, 0x87, 0x79, 0x68,
+  0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00,
+  0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d,
+  0xd4, 0xa1, 0x1e, 0xda, 0x01, 0x1e, 0xda, 0x80, 0x1e, 0xc2, 0x41, 0x1c,
+  0xd8, 0xa1, 0x1c, 0xe6, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28,
+  0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x77, 0x08, 0x07, 0x77, 0x98,
+  0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40,
+  0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0x60, 0x1e, 0xd2, 0xe1, 0x1c, 0xdc, 0xa1, 0x1c, 0xc8, 0xa1, 0x0d,
+  0xf4, 0xa1, 0x1c, 0xe4, 0xe1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e,
+  0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8,
+  0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0xa0, 0x07, 0x79, 0x08,
+  0x07, 0x78, 0x80, 0x87, 0x74, 0x70, 0x87, 0x73, 0x68, 0x83, 0x76, 0x08,
+  0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20,
+  0xe6, 0x81, 0x1e, 0xc2, 0x61, 0x1c, 0xd6, 0xa1, 0x0d, 0xe0, 0x41, 0x1e,
+  0xde, 0x81, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0xa1, 0x0d,
+  0xc4, 0xa1, 0x1e, 0xcc, 0xc1, 0x1c, 0xca, 0x41, 0x1e, 0xda, 0x60, 0x1e,
+  0xd2, 0x41, 0x1f, 0xca, 0x01, 0xc0, 0x03, 0x80, 0xa8, 0x07, 0x77, 0x98,
+  0x87, 0x70, 0x30, 0x87, 0x72, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68,
+  0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c,
+  0x00, 0xa2, 0x1e, 0xe6, 0xa1, 0x1c, 0xda, 0x60, 0x1e, 0xde, 0xc1, 0x1c,
+  0xe8, 0xa1, 0x0d, 0xcc, 0x81, 0x1d, 0xde, 0x21, 0x1c, 0xe8, 0x01, 0x30,
+  0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x60, 0x83, 0x21, 0x10, 0xc0,
+  0x02, 0x54, 0x1b, 0x8c, 0xa1, 0x00, 0x16, 0xa0, 0xda, 0x60, 0x10, 0x06,
+  0xb0, 0x00, 0xd5, 0x06, 0xa3, 0x38, 0x80, 0x05, 0xa8, 0x36, 0x18, 0xc6,
+  0xff, 0xff, 0xff, 0xff, 0x0f, 0x80, 0x04, 0x50, 0x1b, 0x90, 0xe3, 0xff,
+  0xff, 0xff, 0xff, 0x07, 0x80, 0x01, 0x24, 0xa0, 0xda, 0x60, 0x20, 0x01,
+  0xb0, 0x00, 0xd5, 0x06, 0x23, 0x11, 0x80, 0x05, 0xa8, 0x00, 0x49, 0x18,
+  0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x13, 0x8a, 0x40, 0x18, 0x88, 0x62,
+  0x42, 0x60, 0x4c, 0x18, 0x0e, 0x24, 0x01, 0x00, 0x00, 0x00, 0x89, 0x20,
+  0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09, 0x20, 0x64,
+  0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1,
+  0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x68,
+  0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00, 0xc3, 0x08, 0x03,
+  0x70, 0x90, 0x34, 0x45, 0x94, 0x30, 0xf9, 0xb2, 0xfb, 0x76, 0x84, 0xe0,
+  0x0c, 0x04, 0x22, 0xc6, 0x18, 0x63, 0x10, 0x81, 0x10, 0x8e, 0x92, 0xa6,
+  0x88, 0x12, 0x26, 0xff, 0x9f, 0x88, 0x6b, 0xa2, 0x22, 0xe2, 0xb7, 0x87,
+  0x7f, 0x1a, 0x23, 0x00, 0x06, 0x11, 0x8c, 0xe0, 0x22, 0x69, 0x8a, 0x28,
+  0x61, 0xf2, 0x7f, 0x09, 0x60, 0x9e, 0x85, 0x88, 0xfe, 0x69, 0x8c, 0x00,
+  0x18, 0x44, 0x40, 0x84, 0x82, 0x84, 0x10, 0x44, 0x39, 0x27, 0x91, 0x2a,
+  0x03, 0x18, 0x83, 0xd8, 0x1c, 0x41, 0x30, 0x47, 0x00, 0x06, 0xc3, 0x08,
+  0xc2, 0x53, 0x90, 0x70, 0x92, 0x70, 0xd0, 0x01, 0x8a, 0x03, 0x01, 0x29,
+  0xf0, 0x86, 0x11, 0x86, 0x67, 0x10, 0x21, 0x10, 0xe6, 0x08, 0x40, 0x61,
+  0x10, 0x61, 0x10, 0x46, 0x00, 0x00, 0x13, 0xb2, 0x70, 0x48, 0x07, 0x79,
+  0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72,
+  0x68, 0x83, 0x76, 0x08, 0x87, 0x71, 0x78, 0x87, 0x79, 0xc0, 0x87, 0x38,
+  0x80, 0x03, 0x37, 0x88, 0x83, 0x38, 0x70, 0x03, 0x38, 0xd8, 0x70, 0x1b,
+  0xe5, 0xd0, 0x06, 0xf0, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07,
+  0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07,
+  0x78, 0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9, 0x80, 0x07, 0x7a, 0x80, 0x07,
+  0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07,
+  0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x90, 0x0e, 0x73, 0x20, 0x07,
+  0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e,
+  0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
+  0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07,
+  0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x60, 0x07,
+  0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x60, 0x0f,
+  0x72, 0x40, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07,
+  0x6d, 0x60, 0x0f, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x74, 0x80, 0x07, 0x7a, 0x60, 0x07,
+  0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x76, 0x40, 0x07,
+  0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f,
+  0x79, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07,
+  0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07,
+  0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06,
+  0xf6, 0x10, 0x07, 0x79, 0x20, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07,
+  0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x50, 0x07,
+  0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07,
+  0x76, 0xd0, 0x06, 0xf6, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07,
+  0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x6d, 0x60, 0x0f,
+  0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07,
+  0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x6d, 0xe0, 0x0e,
+  0x78, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0x30, 0x84,
+  0x59, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xc2, 0x34,
+  0x40, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x61, 0x24, 0x20,
+  0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb2, 0x40, 0x00, 0x0b, 0x00,
+  0x00, 0x00, 0x32, 0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09,
+  0x26, 0x47, 0xc6, 0x04, 0x43, 0x7a, 0x25, 0x30, 0x02, 0x50, 0x20, 0x45,
+  0x50, 0x08, 0x05, 0x18, 0x50, 0x10, 0x65, 0x50, 0x40, 0x05, 0x56, 0x0a,
+  0xc5, 0x40, 0x74, 0x2c, 0x61, 0x09, 0x00, 0x00, 0x00, 0x00, 0x79, 0x18,
+  0x00, 0x00, 0x0c, 0x01, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29,
+  0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0xc6,
+  0x63, 0x4c, 0x00, 0xf5, 0x50, 0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a,
+  0x4b, 0xd3, 0x2b, 0x1b, 0x62, 0x3c, 0xc3, 0x24, 0x3c, 0x07, 0xe5, 0x20,
+  0x08, 0x0e, 0x8e, 0xad, 0x0c, 0x84, 0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae,
+  0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x26, 0x06, 0x06, 0x26, 0xc6,
+  0x25, 0xc6, 0x06, 0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac,
+  0xac, 0x65, 0x26, 0x06, 0x06, 0x26, 0xc6, 0x25, 0xc6, 0x06, 0xc6, 0x25,
+  0x26, 0x65, 0x88, 0x30, 0x11, 0x43, 0x8c, 0x67, 0x78, 0x92, 0x87, 0x60,
+  0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36, 0x04, 0x99, 0x8e, 0x67, 0x78, 0x86,
+  0x87, 0xe0, 0x16, 0x96, 0x26, 0xe7, 0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6,
+  0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6, 0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96,
+  0x36, 0x17, 0x26, 0xc6, 0x56, 0x36, 0x44, 0x98, 0x12, 0x72, 0x61, 0x69,
+  0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61,
+  0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62,
+  0x6c, 0x65, 0x43, 0x84, 0x69, 0x61, 0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c,
+  0xbd, 0xb5, 0xc1, 0xa5, 0xb1, 0x95, 0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95,
+  0x89, 0xd5, 0x99, 0x99, 0x95, 0xc9, 0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1,
+  0x7d, 0x91, 0xa5, 0xcd, 0x85, 0x89, 0xb1, 0x95, 0x0d, 0x11, 0xa6, 0x86,
+  0x51, 0x58, 0x9a, 0x9c, 0x8b, 0x5c, 0x99, 0x1b, 0x59, 0x99, 0xdc, 0x17,
+  0x5d, 0x98, 0xdc, 0x59, 0x19, 0x1d, 0xa3, 0xb0, 0x34, 0x39, 0x97, 0x30,
+  0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0x2f, 0xb7, 0xb0, 0xb6, 0x32,
+  0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x43, 0x90, 0xe9, 0x79, 0x88,
+  0x09, 0x9a, 0xa2, 0x21, 0xc2, 0x24, 0x91, 0x09, 0x4b, 0x93, 0x73, 0x81,
+  0x7b, 0x9b, 0x4b, 0xa3, 0x4b, 0x7b, 0x73, 0xa3, 0x12, 0x96, 0x26, 0xe7,
+  0x32, 0x56, 0xe6, 0x46, 0x57, 0x26, 0x47, 0x29, 0x2c, 0x4d, 0xce, 0xc5,
+  0xed, 0xed, 0x0b, 0xae, 0x4c, 0x6e, 0x0e, 0xae, 0x6c, 0x8c, 0x2e, 0xcd,
+  0xae, 0x8c, 0x4c, 0x58, 0x9a, 0x9c, 0x4b, 0x98, 0xdc, 0xd9, 0x97, 0x5b,
+  0x58, 0x5b, 0x19, 0x11, 0xb8, 0xb7, 0xb9, 0x34, 0xba, 0xb4, 0x37, 0xb7,
+  0x21, 0xd0, 0x43, 0x4c, 0xd4, 0x54, 0x4d, 0xd6, 0x04, 0x4d, 0xd1, 0x74,
+  0x4d, 0x18, 0xa5, 0xb0, 0x34, 0x39, 0x17, 0x33, 0xb9, 0xb0, 0xb3, 0xb6,
+  0x32, 0x37, 0xba, 0xaf, 0x34, 0x37, 0xb8, 0x3a, 0x3a, 0x5a, 0x67, 0x65,
+  0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x35, 0x63, 0x6f, 0x6c,
+  0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66, 0x29, 0x7c, 0xc2, 0xd2, 0xe4,
+  0x5c, 0xe0, 0xca, 0xe4, 0xe6, 0xe0, 0xca, 0xc6, 0xe8, 0xd2, 0xec, 0xca,
+  0x58, 0x8c, 0xbd, 0xb1, 0xbd, 0xc9, 0x0d, 0x91, 0x9e, 0x61, 0xd2, 0xa6,
+  0x6d, 0xaa, 0x26, 0x6e, 0x82, 0xa6, 0x68, 0xba, 0xa6, 0x8e, 0xd9, 0x59,
+  0x99, 0x5b, 0x99, 0x5c, 0x18, 0x5d, 0x19, 0x19, 0x0a, 0x0e, 0x5d, 0x19,
+  0xde, 0xd8, 0xdb, 0x9b, 0x1c, 0x19, 0x91, 0x9d, 0xcc, 0x97, 0x59, 0x0a,
+  0x0d, 0x33, 0xb6, 0xb7, 0x30, 0x3a, 0x19, 0x22, 0x74, 0x65, 0x78, 0x63,
+  0x6f, 0x6f, 0x72, 0x64, 0x43, 0xa4, 0xc7, 0x98, 0xb4, 0xe9, 0x9b, 0xaa,
+  0x89, 0x9b, 0xa0, 0x09, 0x0c, 0xa6, 0x6b, 0x0a, 0x03, 0x2a, 0x61, 0x69,
+  0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x7c, 0xc2, 0xd2, 0xe4,
+  0x5c, 0xc4, 0xea, 0xcc, 0xcc, 0xca, 0xe4, 0xbe, 0xe6, 0xd2, 0xf4, 0xca,
+  0x28, 0x85, 0xa5, 0xc9, 0xb9, 0xb0, 0xbd, 0x8d, 0x85, 0xd1, 0xa5, 0xbd,
+  0xb9, 0x7d, 0xa5, 0xb9, 0x91, 0x95, 0xe1, 0x11, 0x09, 0x4b, 0x93, 0x73,
+  0x91, 0x2b, 0x0b, 0x23, 0x23, 0x15, 0x96, 0x26, 0xe7, 0x32, 0x47, 0x27,
+  0x57, 0x37, 0x46, 0xf7, 0x45, 0x97, 0x07, 0x57, 0xf6, 0x95, 0xe6, 0x66,
+  0xf6, 0x46, 0xc3, 0x8c, 0xed, 0x2d, 0x8c, 0x6e, 0x86, 0xc6, 0x9b, 0x99,
+  0xd9, 0x5c, 0x19, 0x1d, 0x0d, 0xa9, 0xb1, 0xb7, 0x32, 0x33, 0x33, 0x1a,
+  0x47, 0x63, 0x6f, 0x65, 0x66, 0x66, 0x34, 0x84, 0xc6, 0xde, 0xca, 0xcc,
+  0xcc, 0x86, 0xa0, 0xc1, 0x43, 0x3c, 0xc5, 0x43, 0x4c, 0x68, 0x30, 0xa5,
+  0xc1, 0x53, 0x3c, 0xc5, 0x43, 0x4c, 0x68, 0x30, 0xa9, 0xc1, 0xb3, 0x3c,
+  0xc5, 0x43, 0x4c, 0x68, 0x30, 0xad, 0xc1, 0xc3, 0x3c, 0xc5, 0x43, 0x4c,
+  0x68, 0x30, 0xb1, 0x01, 0xa3, 0xb0, 0x34, 0x39, 0x97, 0x30, 0xb9, 0xb3,
+  0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0xaf, 0xb9, 0x34, 0xbd, 0x32, 0x5e, 0x61,
+  0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f,
+  0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x4c, 0xb2,
+  0xaa, 0xac, 0x88, 0xca, 0xc6, 0xde, 0xc8, 0xca, 0x68, 0x90, 0x95, 0x8d,
+  0xbd, 0x91, 0x95, 0x0d, 0x21, 0x83, 0x47, 0x99, 0xc6, 0x60, 0x22, 0x83,
+  0x07, 0x99, 0xca, 0xe0, 0x19, 0x9e, 0x61, 0x32, 0x83, 0xe9, 0x0c, 0xa6,
+  0x36, 0x98, 0xdc, 0xe0, 0x41, 0xa6, 0x37, 0x78, 0x8a, 0x09, 0x9a, 0xe0,
+  0x60, 0xba, 0xa6, 0x38, 0xe0, 0x12, 0x96, 0x26, 0xe7, 0x42, 0x57, 0x86,
+  0x47, 0x57, 0x27, 0x57, 0x46, 0x25, 0x2c, 0x4d, 0xce, 0x65, 0x2e, 0xac,
+  0x0d, 0x8e, 0xad, 0x8c, 0x18, 0x5d, 0x19, 0x1e, 0x5d, 0x9d, 0x5c, 0x99,
+  0x0c, 0x19, 0x8f, 0x19, 0xdb, 0x5b, 0x18, 0x1d, 0x0b, 0xc8, 0x5c, 0x58,
+  0x1b, 0x1c, 0x5b, 0x99, 0x0f, 0x09, 0xba, 0x32, 0xbc, 0xac, 0x21, 0xd4,
+  0x73, 0x4c, 0x73, 0x30, 0x95, 0xc1, 0x43, 0x3c, 0xc3, 0x44, 0x07, 0x13,
+  0x34, 0xd5, 0xc1, 0x74, 0x4d, 0x76, 0xc0, 0x82, 0xae, 0x0c, 0xaf, 0xca,
+  0x6a, 0x08, 0xf5, 0x34, 0xd3, 0x1c, 0x4c, 0x65, 0xf0, 0x0c, 0xcf, 0x30,
+  0xd1, 0xc1, 0x04, 0x4d, 0x75, 0x30, 0x5d, 0x13, 0x1e, 0x70, 0x09, 0x4b,
+  0x93, 0x73, 0x99, 0x0b, 0x6b, 0x83, 0x63, 0x2b, 0x93, 0xe3, 0x31, 0x17,
+  0xd6, 0x06, 0xc7, 0x56, 0x26, 0xc7, 0x60, 0x6e, 0x88, 0xf4, 0x38, 0x93,
+  0x1e, 0x4c, 0x65, 0xf0, 0x10, 0xcf, 0x30, 0x41, 0xd3, 0x1e, 0x4c, 0xd7,
+  0xc4, 0x07, 0x43, 0x9c, 0x29, 0x9b, 0xbc, 0x49, 0x0c, 0x26, 0x39, 0x98,
+  0xee, 0x60, 0xca, 0x83, 0xa9, 0x0f, 0x86, 0x18, 0x0b, 0x30, 0x4d, 0x93,
+  0x1f, 0x8c, 0x88, 0xd8, 0x81, 0x1d, 0xec, 0xa1, 0x1d, 0xdc, 0xa0, 0x1d,
+  0xde, 0x81, 0x1c, 0xea, 0x81, 0x1d, 0xca, 0xc1, 0x0d, 0xcc, 0x81, 0x1d,
+  0xc2, 0xe1, 0x1c, 0xe6, 0x61, 0x8a, 0x10, 0x0c, 0x23, 0x14, 0x76, 0x60,
+  0x07, 0x7b, 0x68, 0x07, 0x37, 0x48, 0x07, 0x72, 0x28, 0x07, 0x77, 0xa0,
+  0x87, 0x29, 0x41, 0x31, 0x62, 0x09, 0x87, 0x74, 0x90, 0x07, 0x37, 0xb0,
+  0x87, 0x72, 0x90, 0x87, 0x79, 0x48, 0x87, 0x77, 0x70, 0x87, 0x29, 0x81,
+  0x31, 0x82, 0x0a, 0x87, 0x74, 0x90, 0x07, 0x37, 0x60, 0x87, 0x70, 0x70,
+  0x87, 0x73, 0xa8, 0x87, 0x70, 0x38, 0x87, 0x72, 0xf8, 0x05, 0x7b, 0x28,
+  0x07, 0x79, 0x98, 0x87, 0x74, 0x78, 0x07, 0x77, 0x98, 0x12, 0x20, 0x23,
+  0xa6, 0x70, 0x48, 0x07, 0x79, 0x70, 0x83, 0x71, 0x78, 0x87, 0x76, 0x80,
+  0x87, 0x74, 0x60, 0x87, 0x72, 0xf8, 0x85, 0x77, 0x80, 0x07, 0x7a, 0x48,
+  0x87, 0x77, 0x70, 0x87, 0x79, 0x98, 0x32, 0x28, 0x8c, 0x33, 0x82, 0x09,
+  0x87, 0x74, 0x90, 0x07, 0x37, 0x30, 0x07, 0x79, 0x08, 0x87, 0x73, 0x68,
+  0x87, 0x72, 0x70, 0x07, 0x7a, 0x98, 0x12, 0xfc, 0x01, 0x00, 0x79, 0x18,
+  0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1,
+  0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42,
+  0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f,
+  0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1,
+  0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84,
+  0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc,
+  0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70,
+  0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19,
+  0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f,
+  0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21,
+  0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc,
+  0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84,
+  0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37,
+  0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70,
+  0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77,
+  0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79,
+  0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e,
+  0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1,
+  0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81,
+  0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98,
+  0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88,
+  0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4,
+  0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72,
+  0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74,
+  0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e,
+  0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e,
+  0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21,
+  0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01,
+  0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc,
+  0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77,
+  0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e,
+  0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1,
+  0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61,
+  0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0,
+  0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0,
+  0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74,
+  0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e,
+  0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41,
+  0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50,
+  0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c,
+  0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc,
+  0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20, 0x00, 0x00, 0x0d, 0x00,
+  0x00, 0x00, 0x16, 0xd0, 0x00, 0x48, 0xe4, 0x0f, 0xce, 0xe4, 0x57, 0x77,
+  0x71, 0xdb, 0x26, 0xb0, 0x01, 0x48, 0xe4, 0x4b, 0x00, 0xf3, 0x2c, 0xc4,
+  0x3f, 0x11, 0xd7, 0x44, 0x45, 0xc4, 0x6f, 0x0f, 0x7e, 0x85, 0x17, 0xb7,
+  0x6d, 0x00, 0x11, 0xdb, 0x95, 0xff, 0xf9, 0xda, 0xf5, 0x5f, 0x44, 0x80,
+  0xc1, 0x10, 0xcd, 0x04, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x36, 0x00,
+  0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
+  0x00, 0x00, 0x74, 0x47, 0x00, 0xa8, 0x8e, 0x35, 0x00, 0x03, 0x31, 0xc7,
+  0x40, 0x0c, 0xdf, 0x1c, 0x03, 0xf1, 0x7d, 0x63, 0x0d, 0x40, 0x20, 0x10,
+  0x1c, 0x4b, 0x08, 0x00, 0x72, 0x35, 0x30, 0x02, 0x40, 0x6f, 0x06, 0x80,
+  0xe0, 0x08, 0x00, 0x89, 0x19, 0x00, 0x0a, 0x73, 0x10, 0x66, 0x60, 0x06,
   0x66, 0x40, 0x06, 0x33, 0x00, 0x04, 0xc6, 0x08, 0x40, 0x10, 0x04, 0xf1,
-  0x6f, 0x04, 0x60, 0x06, 0x00, 0x00, 0x00, 0x00, 0x23, 0x06, 0xca, 0x10,
-  0x94, 0x81, 0x04, 0x55, 0x89, 0x82, 0x08, 0x83, 0x0c, 0x41, 0xe1, 0x8c,
-  0x18, 0x28, 0x43, 0x70, 0x06, 0x93, 0x74, 0x2d, 0x8c, 0x42, 0x0c, 0x32,
-  0x04, 0x87, 0x33, 0xc8, 0x10, 0x28, 0xd2, 0x20, 0x03, 0x11, 0x50, 0x97,
-  0xdd, 0xa5, 0xa0, 0x0c, 0x32, 0x04, 0x0c, 0x65, 0x44, 0x00, 0x1f, 0xf2,
-  0xca, 0x78, 0x83, 0x37, 0x06, 0x6f, 0x70, 0xc1, 0x5d, 0x0a, 0xca, 0x20,
-  0x43, 0x20, 0x69, 0x23, 0x06, 0x85, 0x10, 0xd4, 0x81, 0x11, 0x8c, 0x37,
-  0x8c, 0x01, 0x1a, 0xc4, 0xc1, 0x05, 0x77, 0x29, 0x28, 0x83, 0x0c, 0xc1,
-  0xf5, 0x8d, 0x18, 0x14, 0x42, 0xa0, 0x07, 0x4b, 0x30, 0xde, 0x80, 0x06,
-  0x6d, 0x20, 0x07, 0x17, 0xdc, 0xa5, 0xa0, 0x0c, 0x32, 0x04, 0x1c, 0x19,
-  0x8c, 0x18, 0x14, 0x42, 0xf0, 0x07, 0x50, 0x30, 0xc7, 0xf0, 0x2d, 0x7d,
-  0x30, 0xc7, 0x10, 0x1c, 0x7f, 0x30, 0xc7, 0x10, 0x0c, 0x7d, 0x60, 0xc1,
-  0x24, 0x9f, 0x0c, 0x02, 0x62, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
-  0x5b, 0x06, 0x25, 0x18, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+  0x6f, 0x04, 0x60, 0x06, 0x00, 0x00, 0x23, 0x06, 0xca, 0x10, 0x94, 0xc1,
+  0x14, 0x55, 0xca, 0x91, 0x08, 0x83, 0x0c, 0x41, 0xe1, 0x8c, 0x18, 0x28,
+  0x43, 0x70, 0x06, 0xd4, 0x74, 0x31, 0xc9, 0x42, 0x0c, 0x32, 0x04, 0x87,
+  0x33, 0xc8, 0x10, 0x28, 0xd2, 0x20, 0x03, 0x11, 0x50, 0xa7, 0xd9, 0xa5,
+  0xa0, 0x0c, 0x32, 0x04, 0x0c, 0x65, 0x44, 0x00, 0x9f, 0xf1, 0x06, 0x4f,
+  0x73, 0x83, 0x0b, 0xec, 0x52, 0x50, 0x06, 0x19, 0x82, 0x28, 0x1b, 0x31,
+  0x28, 0x84, 0x80, 0x0e, 0x8a, 0x60, 0xbc, 0x61, 0x0c, 0x3e, 0x38, 0xb8,
+  0xc0, 0x2e, 0x05, 0x65, 0x90, 0x21, 0xb0, 0xbc, 0x11, 0x83, 0x42, 0x08,
+  0xf2, 0x40, 0x09, 0xc6, 0x1b, 0xd0, 0x80, 0x0c, 0xe2, 0xe0, 0x02, 0xbb,
+  0x14, 0x94, 0x41, 0x86, 0x60, 0x1b, 0x83, 0x11, 0x83, 0x42, 0x08, 0xfc,
+  0xe0, 0x09, 0xe6, 0x18, 0xbc, 0x85, 0x0f, 0xe6, 0x18, 0x82, 0xc3, 0x0f,
+  0xe6, 0x18, 0x82, 0x81, 0x0f, 0x2c, 0x90, 0x03, 0xf9, 0x64, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 };
-const unsigned int sdl_metallib_len = 22080;
+const unsigned int sdl_metallib_len = 21858;
diff --git a/Engine/lib/sdl/src/render/metal/SDL_shaders_metal_tvos.h b/Engine/lib/sdl/src/render/metal/SDL_shaders_metal_tvos.h
index c62288d5a..bbf2cec09 100644
--- a/Engine/lib/sdl/src/render/metal/SDL_shaders_metal_tvos.h
+++ b/Engine/lib/sdl/src/render/metal/SDL_shaders_metal_tvos.h
@@ -1,206 +1,208 @@
 const unsigned char sdl_metallib[] = {
   0x4d, 0x54, 0x4c, 0x42, 0x01, 0x00, 0x02, 0x00, 0x05, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x20, 0x56, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x32, 0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4c, 0x03, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0xac, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x04, 0x00, 0x00,
+  0x8e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a, 0x04, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x60, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x51, 0x00, 0x00,
+  0x72, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x50, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00,
   0x4e, 0x41, 0x4d, 0x45, 0x11, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x53, 0x6f,
   0x6c, 0x69, 0x64, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x00, 0x54,
   0x59, 0x50, 0x45, 0x01, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00,
-  0x28, 0x31, 0x40, 0x63, 0x07, 0x67, 0xcf, 0xec, 0x7b, 0x53, 0x36, 0x27,
-  0xdc, 0xe7, 0xb5, 0x97, 0xd0, 0x99, 0xe7, 0x0a, 0x52, 0x5d, 0x98, 0xd7,
-  0xc6, 0x8e, 0xba, 0x3c, 0x01, 0x5f, 0xad, 0xf5, 0x4f, 0x46, 0x46, 0x54,
+  0xa4, 0x5e, 0x94, 0xe7, 0x16, 0x2a, 0x15, 0xdb, 0x41, 0x62, 0x0f, 0xc4,
+  0x8a, 0xaa, 0x92, 0x52, 0xe1, 0x1e, 0xbe, 0x5f, 0xef, 0xec, 0x0e, 0x83,
+  0x38, 0xb6, 0x06, 0x42, 0xfb, 0x46, 0x30, 0x45, 0x4f, 0x46, 0x46, 0x54,
   0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00, 0x08, 0x00,
   0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x77, 0x00, 0x00, 0x00,
   0x4e, 0x41, 0x4d, 0x45, 0x10, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x43, 0x6f,
   0x70, 0x79, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x00, 0x54, 0x59,
-  0x50, 0x45, 0x01, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00, 0x47,
-  0xb8, 0x4f, 0x55, 0x1e, 0x1e, 0x4a, 0x32, 0x12, 0x7a, 0x9e, 0xc2, 0xf0,
-  0xf9, 0x2b, 0x85, 0x1f, 0xe9, 0x90, 0x33, 0xc4, 0xdf, 0xa9, 0x3a, 0xca,
-  0x6b, 0x6d, 0xdd, 0xe9, 0x46, 0x64, 0x83, 0x4f, 0x46, 0x46, 0x54, 0x18,
-  0x00, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x50, 0x45, 0x01, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00, 0x4a,
+  0xdb, 0x37, 0xcf, 0x60, 0x13, 0xba, 0xf8, 0x04, 0xff, 0xec, 0xd1, 0x3d,
+  0x3f, 0x77, 0xbb, 0xaa, 0xe4, 0x36, 0xd0, 0x6e, 0x89, 0xfb, 0x91, 0xfb,
+  0xfd, 0xb2, 0xb4, 0x56, 0x8e, 0x5e, 0x05, 0x4f, 0x46, 0x46, 0x54, 0x18,
+  0x00, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01,
   0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x7a, 0x00, 0x00, 0x00, 0x4e,
   0x41, 0x4d, 0x45, 0x13, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x53, 0x6f, 0x6c,
   0x69, 0x64, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x00,
   0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53, 0x48, 0x20,
-  0x00, 0x69, 0x9d, 0x1d, 0x1f, 0x5c, 0x05, 0x77, 0xfb, 0x40, 0x83, 0x70,
-  0x5e, 0x26, 0x13, 0x34, 0xb5, 0xd7, 0x61, 0x21, 0x42, 0x6a, 0xc9, 0x8d,
-  0xd0, 0x59, 0x04, 0x0b, 0x18, 0x09, 0x74, 0x40, 0x7c, 0x4f, 0x46, 0x46,
-  0x54, 0x18, 0x00, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd0, 0x16, 0x00, 0x00, 0x00,
+  0x00, 0x93, 0xcd, 0x48, 0xeb, 0xee, 0x18, 0x36, 0xf1, 0x25, 0x14, 0x9f,
+  0x98, 0xc6, 0x7e, 0x3f, 0x06, 0xd1, 0x5d, 0x98, 0x2a, 0x2f, 0x70, 0xe1,
+  0xa3, 0xa4, 0x4f, 0x06, 0x51, 0xd9, 0x24, 0xdb, 0x3d, 0x4f, 0x46, 0x46,
+  0x54, 0x18, 0x00, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0x17, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00, 0x08,
   0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x79, 0x00, 0x00,
   0x00, 0x4e, 0x41, 0x4d, 0x45, 0x12, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x43,
   0x6f, 0x70, 0x79, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74,
   0x00, 0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53, 0x48,
-  0x20, 0x00, 0x88, 0x94, 0x57, 0x70, 0x82, 0x3f, 0xe3, 0xbc, 0x88, 0x1c,
-  0x9c, 0x13, 0xbd, 0x4d, 0xc3, 0x16, 0xdf, 0x68, 0x5e, 0xe0, 0xe9, 0xa9,
-  0x06, 0x9e, 0x2f, 0xf0, 0x86, 0xf6, 0x8d, 0x56, 0xf2, 0xbf, 0x4f, 0x46,
-  0x46, 0x54, 0x18, 0x00, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
+  0x20, 0x00, 0x48, 0x19, 0xba, 0x48, 0x88, 0x08, 0x02, 0x7a, 0x7b, 0x87,
+  0x60, 0x4f, 0x56, 0x77, 0x82, 0x12, 0xd0, 0x8d, 0x75, 0x00, 0x13, 0xd4,
+  0x4f, 0x12, 0x69, 0x87, 0x49, 0x45, 0xb7, 0xda, 0x31, 0x6f, 0x4f, 0x46,
+  0x46, 0x54, 0x18, 0x00, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0x20, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00,
   0x08, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x78, 0x00,
   0x00, 0x00, 0x4e, 0x41, 0x4d, 0x45, 0x11, 0x00, 0x53, 0x44, 0x4c, 0x5f,
   0x59, 0x55, 0x56, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74,
   0x00, 0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53, 0x48,
-  0x20, 0x00, 0xf7, 0x98, 0xd0, 0xe2, 0xdc, 0xe8, 0x70, 0x90, 0xb8, 0xd2,
-  0x1e, 0x21, 0x36, 0xa4, 0xb8, 0xca, 0x52, 0xcb, 0xb8, 0xc9, 0x61, 0xa4,
-  0x80, 0x75, 0xa2, 0x9b, 0x4b, 0x82, 0x22, 0x60, 0xa6, 0xc9, 0x4f, 0x46,
-  0x46, 0x54, 0x18, 0x00, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00,
+  0x20, 0x00, 0x86, 0xd8, 0xc8, 0xb9, 0x4b, 0x3f, 0xf0, 0x71, 0x98, 0x15,
+  0x75, 0xd7, 0xc4, 0x78, 0x49, 0x02, 0xc5, 0x2c, 0x0d, 0xa2, 0xf8, 0x40,
+  0xd8, 0x18, 0xf5, 0xa8, 0xc2, 0x8b, 0x11, 0x42, 0x60, 0x9e, 0x4f, 0x46,
+  0x46, 0x54, 0x18, 0x00, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x2a, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00,
   0x08, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x79, 0x00,
   0x00, 0x00, 0x4e, 0x41, 0x4d, 0x45, 0x12, 0x00, 0x53, 0x44, 0x4c, 0x5f,
   0x4e, 0x56, 0x31, 0x32, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e,
   0x74, 0x00, 0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53,
-  0x48, 0x20, 0x00, 0x64, 0x76, 0x02, 0x5c, 0xd4, 0x80, 0xf1, 0x25, 0xd7,
-  0x2a, 0xa6, 0xb0, 0x3c, 0xd8, 0xe6, 0x3a, 0x38, 0xe3, 0xd6, 0x15, 0x67,
-  0x59, 0x20, 0xfd, 0x1b, 0xfe, 0x8c, 0x87, 0x1e, 0xfe, 0x9d, 0x9e, 0x4f,
-  0x46, 0x46, 0x54, 0x18, 0x00, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x38, 0x00,
+  0x48, 0x20, 0x00, 0x0c, 0x19, 0x24, 0x25, 0x5b, 0x90, 0x7b, 0xbe, 0xd8,
+  0x0c, 0x0d, 0x1b, 0x66, 0xe5, 0x2f, 0xc5, 0x6d, 0x8a, 0xf1, 0x08, 0xc3,
+  0x68, 0x52, 0x1a, 0x5b, 0x1f, 0x8d, 0x05, 0xe0, 0x43, 0x9b, 0xce, 0x4f,
+  0x46, 0x46, 0x54, 0x18, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd0, 0x37, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01,
   0x00, 0x08, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x79,
   0x00, 0x00, 0x00, 0x4e, 0x41, 0x4d, 0x45, 0x12, 0x00, 0x53, 0x44, 0x4c,
   0x5f, 0x4e, 0x56, 0x32, 0x31, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65,
   0x6e, 0x74, 0x00, 0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41,
-  0x53, 0x48, 0x20, 0x00, 0x23, 0xbd, 0x28, 0xce, 0x4f, 0xb7, 0xc7, 0x94,
-  0x2a, 0x0a, 0x20, 0x48, 0x6f, 0x52, 0x4a, 0xcc, 0x07, 0x9c, 0x7f, 0x41,
-  0x8d, 0x0a, 0x31, 0x81, 0xec, 0xe4, 0xd4, 0x71, 0x77, 0x7b, 0x22, 0x7d,
-  0x4f, 0x46, 0x46, 0x54, 0x18, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x44,
+  0x53, 0x48, 0x20, 0x00, 0x4a, 0x04, 0xcb, 0xef, 0xd3, 0x81, 0xd0, 0x17,
+  0x11, 0xf6, 0x23, 0x6b, 0x3b, 0x38, 0xfc, 0x61, 0xe0, 0x6d, 0x22, 0x94,
+  0x28, 0x7c, 0x7f, 0xe6, 0x31, 0xde, 0x9b, 0xe1, 0x58, 0x2b, 0x1f, 0x84,
+  0x4f, 0x46, 0x46, 0x54, 0x18, 0x00, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x44,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00,
   0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54,
-  0x45, 0x4e, 0x44, 0x54, 0x20, 0x00, 0x00, 0x00, 0x56, 0x41, 0x54, 0x54,
-  0x0d, 0x00, 0x01, 0x00, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e,
-  0x00, 0x00, 0x80, 0x56, 0x41, 0x54, 0x59, 0x03, 0x00, 0x01, 0x00, 0x04,
-  0x45, 0x4e, 0x44, 0x54, 0x2c, 0x00, 0x00, 0x00, 0x56, 0x41, 0x54, 0x54,
-  0x18, 0x00, 0x02, 0x00, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e,
-  0x00, 0x00, 0x80, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x00,
-  0x01, 0x80, 0x56, 0x41, 0x54, 0x59, 0x04, 0x00, 0x02, 0x00, 0x04, 0x04,
-  0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54,
-  0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00,
-  0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54,
-  0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00,
-  0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54,
-  0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00,
-  0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54,
-  0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00,
-  0x45, 0x4e, 0x44, 0x54, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00,
-  0x14, 0x00, 0x00, 0x00, 0x3c, 0x0b, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
-  0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0xcc, 0x02, 0x00, 0x00,
-  0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
-  0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39,
-  0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62,
-  0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14,
-  0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90, 0x21,
-  0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8, 0x48,
-  0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00,
-  0x51, 0x18, 0x00, 0x00, 0x84, 0x00, 0x00, 0x00, 0x1b, 0xc8, 0x25, 0xf8,
-  0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x80, 0x8a, 0x18, 0x87, 0x77, 0x90,
-  0x07, 0x79, 0x28, 0x87, 0x71, 0xa0, 0x07, 0x76, 0xc8, 0x87, 0x36, 0x90,
-  0x87, 0x77, 0xa8, 0x07, 0x77, 0x20, 0x87, 0x72, 0x20, 0x87, 0x36, 0x20,
-  0x87, 0x74, 0xb0, 0x87, 0x74, 0x20, 0x87, 0x72, 0x68, 0x83, 0x79, 0x88,
-  0x07, 0x79, 0xa0, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08,
-  0x07, 0x7a, 0x40, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c,
-  0x00, 0x82, 0x1c, 0xd2, 0x61, 0x1e, 0xc2, 0x41, 0x1c, 0xd8, 0xa1, 0x1c,
-  0xda, 0x80, 0x1e, 0xc2, 0x21, 0x1d, 0xd8, 0xa1, 0x0d, 0xc6, 0x21, 0x1c,
-  0xd8, 0x81, 0x1d, 0xe6, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28,
-  0x07, 0x80, 0x60, 0x87, 0x72, 0x98, 0x87, 0x79, 0x68, 0x03, 0x78, 0x90,
-  0x87, 0x72, 0x18, 0x87, 0x74, 0x98, 0x87, 0x72, 0x68, 0x03, 0x73, 0x80,
-  0x87, 0x76, 0x08, 0x07, 0x72, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e,
-  0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c,
-  0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e,
-  0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0x01, 0xa0,
-  0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x06, 0x77, 0x78, 0x87, 0x36, 0x30,
-  0x07, 0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77, 0x48,
-  0x07, 0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76, 0x48,
-  0x87, 0x76, 0x68, 0x03, 0x77, 0x78, 0x07, 0x77, 0x68, 0x03, 0x76, 0x28,
-  0x87, 0x70, 0x30, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x74, 0x70,
-  0x07, 0x73, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08,
-  0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20,
-  0xdc, 0xe1, 0x1d, 0xda, 0x40, 0x1d, 0xea, 0xa1, 0x1d, 0xe0, 0xa1, 0x0d,
-  0xe8, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x1e, 0x00, 0x73, 0x08,
-  0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x70,
-  0x87, 0x70, 0x70, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68,
-  0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c,
-  0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xce, 0xc1, 0x1d,
-  0xca, 0x81, 0x1c, 0xda, 0x40, 0x1f, 0xca, 0x41, 0x1e, 0xde, 0x61, 0x1e,
-  0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d,
-  0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68,
-  0x03, 0x7a, 0x90, 0x87, 0x70, 0x80, 0x07, 0x78, 0x48, 0x07, 0x77, 0x38,
-  0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e,
-  0xea, 0xa1, 0x1c, 0x00, 0x62, 0x1e, 0xe8, 0x21, 0x1c, 0xc6, 0x61, 0x1d,
-  0xda, 0x00, 0x1e, 0xe4, 0xe1, 0x1d, 0xe8, 0xa1, 0x1c, 0xc6, 0x81, 0x1e,
-  0xde, 0x41, 0x1e, 0xda, 0x40, 0x1c, 0xea, 0xc1, 0x1c, 0xcc, 0xa1, 0x1c,
-  0xe4, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xf4, 0xa1, 0x1c, 0x00, 0x3c, 0x00,
-  0x88, 0x7a, 0x70, 0x87, 0x79, 0x08, 0x07, 0x73, 0x28, 0x87, 0x36, 0x30,
+  0x45, 0x4e, 0x44, 0x54, 0x29, 0x00, 0x00, 0x00, 0x56, 0x41, 0x54, 0x54,
+  0x15, 0x00, 0x02, 0x00, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e,
+  0x00, 0x00, 0x80, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x00, 0x01, 0x80, 0x56,
+  0x41, 0x54, 0x59, 0x04, 0x00, 0x02, 0x00, 0x04, 0x06, 0x45, 0x4e, 0x44,
+  0x54, 0x35, 0x00, 0x00, 0x00, 0x56, 0x41, 0x54, 0x54, 0x20, 0x00, 0x03,
+  0x00, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x80,
+  0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x00, 0x01, 0x80, 0x74, 0x65, 0x78, 0x63,
+  0x6f, 0x6f, 0x72, 0x64, 0x00, 0x02, 0x80, 0x56, 0x41, 0x54, 0x59, 0x05,
+  0x00, 0x03, 0x00, 0x04, 0x06, 0x04, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00,
+  0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e,
+  0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00,
+  0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e,
+  0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00,
+  0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e,
+  0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00,
+  0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e,
+  0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0xde, 0xc0,
+  0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0xa0, 0x0b,
+  0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c,
+  0x00, 0x00, 0xe5, 0x02, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00,
+  0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8,
+  0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05,
+  0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92,
+  0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32,
+  0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19,
+  0x21, 0x72, 0x24, 0x07, 0xc8, 0x48, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40,
+  0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00, 0x00, 0x84, 0x00,
+  0x00, 0x00, 0x1b, 0xc8, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90,
+  0x80, 0x8a, 0x18, 0x87, 0x77, 0x90, 0x07, 0x79, 0x28, 0x87, 0x71, 0xa0,
+  0x07, 0x76, 0xc8, 0x87, 0x36, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x77, 0x20,
+  0x87, 0x72, 0x20, 0x87, 0x36, 0x20, 0x87, 0x74, 0xb0, 0x87, 0x74, 0x20,
+  0x87, 0x72, 0x68, 0x83, 0x79, 0x88, 0x07, 0x79, 0xa0, 0x87, 0x36, 0x30,
+  0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0xc0, 0x1c,
+  0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1c, 0xd2, 0x61, 0x1e,
+  0xc2, 0x41, 0x1c, 0xd8, 0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xc2, 0x21, 0x1d,
+  0xd8, 0xa1, 0x0d, 0xc6, 0x21, 0x1c, 0xd8, 0x81, 0x1d, 0xe6, 0x01, 0x30,
+  0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x60, 0x87, 0x72, 0x98,
+  0x87, 0x79, 0x68, 0x03, 0x78, 0x90, 0x87, 0x72, 0x18, 0x87, 0x74, 0x98,
+  0x87, 0x72, 0x68, 0x03, 0x73, 0x80, 0x87, 0x76, 0x08, 0x07, 0x72, 0x00,
+  0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e,
+  0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c,
+  0xd8, 0x21, 0x1d, 0xda, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00,
+  0x06, 0x77, 0x78, 0x87, 0x36, 0x30, 0x07, 0x79, 0x08, 0x87, 0x76, 0x28,
+  0x87, 0x36, 0x80, 0x87, 0x77, 0x48, 0x07, 0x77, 0xa0, 0x87, 0x72, 0x90,
+  0x87, 0x36, 0x28, 0x07, 0x76, 0x48, 0x87, 0x76, 0x68, 0x03, 0x77, 0x78,
+  0x07, 0x77, 0x68, 0x03, 0x76, 0x28, 0x87, 0x70, 0x30, 0x07, 0x80, 0x70,
+  0x87, 0x77, 0x68, 0x83, 0x74, 0x70, 0x07, 0x73, 0x98, 0x87, 0x36, 0x30,
   0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e,
-  0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xea, 0x61, 0x1e, 0xca, 0xa1, 0x0d,
-  0xe6, 0xe1, 0x1d, 0xcc, 0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xd8, 0xe1, 0x1d,
-  0xc2, 0x81, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00,
-  0x36, 0x20, 0x82, 0x00, 0x24, 0xc0, 0x02, 0x54, 0x1b, 0x90, 0x61, 0x00,
-  0x12, 0x60, 0x01, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x49, 0x18, 0x00, 0x00,
-  0x02, 0x00, 0x00, 0x00, 0x13, 0x86, 0x40, 0x18, 0x00, 0x00, 0x00, 0x00,
-  0x89, 0x20, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09,
-  0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3,
-  0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c,
-  0x10, 0x40, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x60, 0x85, 0x00, 0x86, 0x11,
-  0x04, 0x20, 0x09, 0xc2, 0x4c, 0xd4, 0x3c, 0xd0, 0x83, 0x3c, 0xd4, 0xc3,
-  0x38, 0xd0, 0x83, 0x1b, 0xb4, 0x43, 0x39, 0xd0, 0x43, 0x38, 0xb0, 0x83,
-  0x1e, 0xe8, 0x41, 0x3b, 0x84, 0x03, 0x3d, 0xc8, 0x43, 0x3a, 0xe0, 0x03,
-  0x0a, 0xc8, 0x20, 0x42, 0x21, 0x14, 0x42, 0x0c, 0x63, 0xe8, 0x0c, 0x04,
-  0xcc, 0x11, 0x80, 0x41, 0x0a, 0xa8, 0x39, 0x02, 0x50, 0x18, 0x44, 0x08,
-  0x84, 0x61, 0x04, 0x42, 0x19, 0x01, 0x00, 0x00, 0x13, 0xa8, 0x70, 0x48,
-  0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70, 0x80, 0x07, 0x78, 0x60,
-  0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87, 0x79, 0xc8, 0x03, 0x37, 0x80,
-  0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7, 0x51, 0x0e, 0x6d, 0x00, 0x0f, 0x7a,
-  0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74,
-  0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d,
-  0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9,
-  0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76,
-  0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a,
-  0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
-  0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x30, 0x07, 0x72,
-  0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe6,
-  0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74,
-  0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a,
-  0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x73,
-  0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x30, 0x07, 0x72,
-  0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xf6,
-  0x40, 0x07, 0x78, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74,
-  0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a,
-  0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x90, 0x07, 0x76, 0xa0, 0x07, 0x71,
-  0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6,
-  0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a,
-  0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x90, 0x07, 0x72,
-  0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76,
-  0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75,
-  0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x75,
-  0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75,
-  0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74,
-  0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x7a, 0x10, 0x07, 0x70,
-  0x20, 0x07, 0x74, 0xd0, 0x06, 0xee, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x76,
-  0xa0, 0x07, 0x73, 0x20, 0x07, 0x43, 0x18, 0x04, 0x00, 0x80, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x80, 0x2c, 0x10, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
-  0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47,
-  0xc6, 0x04, 0x43, 0x52, 0x25, 0x30, 0x02, 0x50, 0x80, 0x01, 0x45, 0x50,
-  0x20, 0x85, 0x50, 0x10, 0x65, 0x40, 0x6c, 0x04, 0x80, 0xd6, 0x58, 0x82,
-  0x23, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0xce, 0x00, 0x00, 0x00,
-  0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9,
-  0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x86, 0x42, 0x24, 0xc0, 0xa2, 0x50, 0xb9,
-  0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b, 0x62, 0x28,
-  0x41, 0x22, 0x28, 0x06, 0xdd, 0x20, 0x08, 0x0e, 0x8e, 0xad, 0x0c, 0x84,
-  0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x0d,
-  0x64, 0x26, 0x06, 0x06, 0x26, 0xc6, 0x85, 0x66, 0x06, 0x04, 0xa5, 0xad,
-  0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26, 0x06, 0x06, 0x26, 0xc6,
-  0x85, 0x66, 0x26, 0x65, 0x88, 0x90, 0x10, 0x43, 0x0c, 0x25, 0x50, 0x0e,
+  0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x40, 0x1d,
+  0xea, 0xa1, 0x1d, 0xe0, 0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xc4, 0x81, 0x1d,
+  0xca, 0x61, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00,
+  0x08, 0x77, 0x78, 0x87, 0x36, 0x70, 0x87, 0x70, 0x70, 0x87, 0x79, 0x68,
+  0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00,
+  0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d,
+  0xe6, 0x21, 0x1d, 0xce, 0xc1, 0x1d, 0xca, 0x81, 0x1c, 0xda, 0x40, 0x1f,
+  0xca, 0x41, 0x1e, 0xde, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d,
+  0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28,
+  0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x7a, 0x90, 0x87, 0x70, 0x80,
+  0x07, 0x78, 0x48, 0x07, 0x77, 0x38, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0,
+  0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0x62, 0x1e,
+  0xe8, 0x21, 0x1c, 0xc6, 0x61, 0x1d, 0xda, 0x00, 0x1e, 0xe4, 0xe1, 0x1d,
+  0xe8, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0x40, 0x1c,
+  0xea, 0xc1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xe6, 0x21, 0x1d,
+  0xf4, 0xa1, 0x1c, 0x00, 0x3c, 0x00, 0x88, 0x7a, 0x70, 0x87, 0x79, 0x08,
+  0x07, 0x73, 0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08,
+  0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20,
+  0xea, 0x61, 0x1e, 0xca, 0xa1, 0x0d, 0xe6, 0xe1, 0x1d, 0xcc, 0x81, 0x1e,
+  0xda, 0xc0, 0x1c, 0xd8, 0xe1, 0x1d, 0xc2, 0x81, 0x1e, 0x00, 0x73, 0x08,
+  0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x36, 0x20, 0xc2, 0x00, 0x24, 0xc0,
+  0x02, 0x54, 0x1b, 0x90, 0x81, 0x00, 0x12, 0x60, 0x01, 0x2a, 0x00, 0x00,
+  0x00, 0x00, 0x49, 0x18, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x86,
+  0x40, 0x18, 0x00, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x1c, 0x00,
+  0x00, 0x00, 0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22,
+  0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c,
+  0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x40, 0x33, 0x00, 0xc3, 0x08,
+  0x04, 0x60, 0x87, 0x10, 0xc0, 0x30, 0x82, 0x00, 0x24, 0x41, 0x98, 0x89,
+  0x9a, 0x07, 0x7a, 0x90, 0x87, 0x7a, 0x18, 0x07, 0x7a, 0x70, 0x83, 0x76,
+  0x28, 0x07, 0x7a, 0x08, 0x07, 0x76, 0xd0, 0x03, 0x3d, 0x68, 0x87, 0x70,
+  0xa0, 0x07, 0x79, 0x48, 0x07, 0x7c, 0x40, 0x01, 0x19, 0x44, 0x28, 0x84,
+  0x52, 0x88, 0x11, 0x8c, 0xa1, 0x33, 0x10, 0x30, 0x47, 0x00, 0x06, 0x29,
+  0xa0, 0xe6, 0x08, 0x40, 0x61, 0x10, 0x21, 0x10, 0x86, 0x11, 0x08, 0x65,
+  0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0xa8, 0x70, 0x48, 0x07, 0x79,
+  0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72,
+  0x68, 0x83, 0x74, 0x78, 0x87, 0x79, 0xc8, 0x03, 0x37, 0x80, 0x03, 0x37,
+  0x80, 0x83, 0x0d, 0xb7, 0x51, 0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07,
+  0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06,
+  0xe9, 0x10, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e,
+  0x78, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07,
+  0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06,
+  0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
+  0x72, 0xd0, 0x06, 0xe9, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
+  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07,
+  0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06,
+  0xf6, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07,
+  0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x73, 0x20, 0x07,
+  0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07,
+  0x78, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06,
+  0xf6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07,
+  0x74, 0xd0, 0x06, 0xf6, 0x90, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x20, 0x07,
+  0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07,
+  0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07,
+  0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x90, 0x07, 0x72, 0xa0, 0x07,
+  0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06,
+  0xf6, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07,
+  0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07,
+  0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07,
+  0x72, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07,
+  0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07,
+  0x74, 0xd0, 0x06, 0xee, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x43, 0x18, 0x04, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x80, 0x2c, 0x10, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x32, 0x1e,
+  0x98, 0x10, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04,
+  0x43, 0x52, 0x25, 0x30, 0x02, 0x50, 0x80, 0x01, 0x45, 0x50, 0x20, 0x65,
+  0x50, 0x08, 0x05, 0x41, 0x6c, 0x04, 0x80, 0xd6, 0x58, 0x82, 0x33, 0x00,
+  0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0xe4, 0x00, 0x00, 0x00, 0x1a, 0x03,
+  0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4,
+  0x37, 0xb7, 0x21, 0x86, 0x42, 0x24, 0xc0, 0xa2, 0x50, 0xb9, 0x1b, 0x43,
+  0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b, 0x62, 0x28, 0x41, 0x22,
+  0x28, 0x07, 0xe1, 0x20, 0x08, 0x0e, 0x8e, 0xad, 0x0c, 0x84, 0x89, 0xc9,
+  0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x26,
+  0x06, 0x06, 0x26, 0xc6, 0xa5, 0x06, 0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e,
+  0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26, 0x06, 0x06, 0x26, 0xc6, 0xa5, 0x06,
+  0xc6, 0x25, 0x26, 0x65, 0x88, 0x90, 0x10, 0x43, 0x0c, 0x25, 0x50, 0x10,
   0x45, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36, 0x04, 0x49, 0x0e, 0x25,
   0x50, 0x02, 0x45, 0xe0, 0x16, 0x96, 0x26, 0xe7, 0x32, 0xf6, 0xd6, 0x06,
   0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6, 0x26, 0xd7, 0x36, 0xf7,
@@ -216,283 +218,45 @@ const unsigned char sdl_metallib[] = {
   0x3c, 0xb8, 0xb2, 0x2f, 0xb7, 0xb0, 0xb6, 0x32, 0x1a, 0x66, 0x6c, 0x6f,
   0x61, 0x74, 0x34, 0x64, 0xc2, 0xd2, 0xe4, 0x5c, 0xc2, 0xe4, 0xce, 0xbe,
   0xdc, 0xc2, 0xda, 0xca, 0x88, 0xc0, 0xbd, 0xcd, 0xa5, 0xd1, 0xa5, 0xbd,
-  0xb9, 0x0d, 0x51, 0x92, 0x27, 0x81, 0x92, 0x28, 0x91, 0x92, 0x89, 0x4e,
-  0x58, 0x9a, 0x9c, 0x0b, 0xdc, 0x5b, 0x9a, 0x1b, 0xdd, 0xd7, 0x5c, 0x9a,
-  0x5e, 0x19, 0x0b, 0x33, 0xb6, 0xb7, 0x30, 0x3a, 0x26, 0x70, 0x6f, 0x69,
-  0x6e, 0x74, 0x53, 0x69, 0x7a, 0x65, 0x43, 0x94, 0xa4, 0x4a, 0xa0, 0xc4,
-  0x4a, 0xa4, 0xe4, 0x1a, 0x42, 0x24, 0x54, 0x82, 0x11, 0x0a, 0x4b, 0x93,
-  0x73, 0xb1, 0x2b, 0x93, 0xa3, 0x2b, 0xc3, 0xfb, 0x4a, 0x73, 0x83, 0xab,
-  0xa3, 0xa3, 0x14, 0x96, 0x26, 0xe7, 0xc2, 0xf6, 0x36, 0x16, 0x46, 0x97,
-  0xf6, 0xe6, 0xf6, 0x95, 0xe6, 0x46, 0x56, 0x86, 0x47, 0xef, 0xac, 0xcc,
-  0xad, 0x4c, 0x2e, 0x8c, 0xae, 0x8c, 0x0c, 0xe5, 0xeb, 0x2b, 0x2c, 0x4d,
-  0xee, 0x0b, 0x8e, 0x2d, 0x6c, 0xac, 0x0c, 0xed, 0x8d, 0x8d, 0xac, 0x4c,
-  0xee, 0xeb, 0x2b, 0x85, 0x86, 0x19, 0xdb, 0x5b, 0x18, 0x9d, 0xcc, 0x10,
-  0x4a, 0x11, 0x12, 0x2d, 0xd9, 0x14, 0x41, 0x09, 0x12, 0x2e, 0x81, 0x92,
-  0x2e, 0x91, 0x92, 0x89, 0x4a, 0x58, 0x9a, 0x9c, 0x8b, 0x58, 0x9d, 0x99,
-  0x59, 0x99, 0x1c, 0x9f, 0xb0, 0x34, 0x39, 0x17, 0xb1, 0x3a, 0x33, 0xb3,
-  0x32, 0xb9, 0xaf, 0xb9, 0x34, 0xbd, 0x32, 0x22, 0x61, 0x69, 0x72, 0x2e,
-  0x72, 0x65, 0x61, 0x64, 0x8c, 0xc2, 0xd2, 0xe4, 0x5c, 0xc2, 0xe4, 0xce,
-  0xbe, 0xe8, 0xf2, 0xe0, 0xca, 0xbe, 0xe6, 0xd2, 0xf4, 0xca, 0x78, 0x85,
-  0xa5, 0xc9, 0xb9, 0x84, 0xc9, 0x9d, 0x7d, 0xd1, 0xe5, 0xc1, 0x95, 0x7d,
-  0x85, 0xb1, 0xa5, 0x9d, 0xb9, 0x7d, 0xcd, 0xa5, 0xe9, 0x95, 0x11, 0x31,
-  0x63, 0x7b, 0x0b, 0xa3, 0xa3, 0xc1, 0xa3, 0xa1, 0x02, 0x27, 0xf7, 0xa6,
-  0x56, 0x36, 0x46, 0x97, 0xf6, 0xe6, 0x36, 0x04, 0x0c, 0x94, 0x20, 0xf9,
-  0x12, 0x30, 0x50, 0x86, 0x64, 0x53, 0x08, 0x25, 0x48, 0xc2, 0x20, 0x11,
-  0x03, 0x65, 0x48, 0xc6, 0x40, 0x29, 0x12, 0x28, 0x21, 0x83, 0x44, 0x4a,
-  0xca, 0x80, 0x09, 0x9d, 0x5c, 0x98, 0xdb, 0x9c, 0xd9, 0x9b, 0x5c, 0xdb,
-  0x10, 0x30, 0x50, 0x88, 0xe4, 0x4b, 0xc0, 0x40, 0x19, 0x92, 0x4d, 0x41,
-  0x94, 0x20, 0x09, 0x83, 0x44, 0x0c, 0x94, 0x21, 0x19, 0x03, 0xa5, 0x48,
-  0xa0, 0x84, 0x0c, 0x12, 0x29, 0x39, 0x83, 0x21, 0x46, 0xe2, 0x25, 0x66,
-  0x90, 0xa0, 0xc1, 0x10, 0x03, 0x01, 0x92, 0x2c, 0x49, 0x03, 0x3e, 0x6f,
-  0x6d, 0x6e, 0x69, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x68,
-  0x61, 0x72, 0x7c, 0xa6, 0xd2, 0xda, 0xe0, 0xd8, 0xca, 0x40, 0x86, 0x56,
-  0x56, 0x40, 0xa8, 0x84, 0x82, 0x82, 0x86, 0x08, 0x09, 0x1b, 0x0c, 0x31,
-  0x92, 0x35, 0x48, 0xda, 0x80, 0x49, 0x86, 0x18, 0x89, 0x1b, 0x24, 0x6e,
-  0xc0, 0x24, 0x23, 0x22, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68,
-  0x87, 0x77, 0x20, 0x87, 0x7a, 0x60, 0x87, 0x72, 0x70, 0x03, 0x73, 0x60,
-  0x87, 0x70, 0x38, 0x87, 0x79, 0x98, 0x22, 0x04, 0xc3, 0x08, 0x85, 0x1d,
-  0xd8, 0xc1, 0x1e, 0xda, 0xc1, 0x0d, 0xd2, 0x81, 0x1c, 0xca, 0xc1, 0x1d,
-  0xe8, 0x61, 0x4a, 0x50, 0x8c, 0x58, 0xc2, 0x21, 0x1d, 0xe4, 0xc1, 0x0d,
-  0xec, 0xa1, 0x1c, 0xe4, 0x61, 0x1e, 0xd2, 0xe1, 0x1d, 0xdc, 0x61, 0x4a,
-  0x60, 0x8c, 0xa0, 0xc2, 0x21, 0x1d, 0xe4, 0xc1, 0x0d, 0xd8, 0x21, 0x1c,
-  0xdc, 0xe1, 0x1c, 0xea, 0x21, 0x1c, 0xce, 0xa1, 0x1c, 0x7e, 0xc1, 0x1e,
-  0xca, 0x41, 0x1e, 0xe6, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0xa6, 0x04, 0xc8,
-  0x88, 0x29, 0x1c, 0xd2, 0x41, 0x1e, 0xdc, 0x60, 0x1c, 0xde, 0xa1, 0x1d,
-  0xe0, 0x21, 0x1d, 0xd8, 0xa1, 0x1c, 0x7e, 0xe1, 0x1d, 0xe0, 0x81, 0x1e,
-  0xd2, 0xe1, 0x1d, 0xdc, 0x61, 0x1e, 0xa6, 0x0c, 0x0a, 0xe3, 0x8c, 0x50,
-  0xc2, 0x21, 0x1d, 0xe4, 0xc1, 0x0d, 0xec, 0xa1, 0x1c, 0xe4, 0x81, 0x1e,
-  0xca, 0x01, 0x1f, 0xa6, 0x04, 0x6a, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00,
-  0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66,
-  0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07,
-  0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10,
-  0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce,
-  0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b,
-  0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c,
-  0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07,
-  0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11,
-  0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0,
-  0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8,
-  0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b,
-  0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b,
-  0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87,
-  0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07,
-  0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87,
-  0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81,
-  0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30,
-  0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4,
-  0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca,
-  0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39,
-  0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b,
-  0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b,
-  0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83,
-  0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87,
-  0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90,
-  0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20,
-  0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc,
-  0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66,
-  0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24,
-  0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07,
-  0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e,
-  0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e,
-  0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54,
-  0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39,
-  0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c,
-  0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07,
-  0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0,
-  0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4,
-  0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38,
-  0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d,
-  0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d,
-  0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
-  0x06, 0x00, 0xb1, 0x5d, 0xf9, 0xb3, 0xce, 0x82, 0x0c, 0x7f, 0x45, 0x44,
-  0x13, 0x71, 0x01, 0x00, 0x61, 0x20, 0x00, 0x00, 0x52, 0x00, 0x00, 0x00,
-  0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
-  0xe4, 0xc6, 0x22, 0x86, 0x61, 0x18, 0xc6, 0x22, 0x04, 0x41, 0x10, 0xc6,
-  0x22, 0x82, 0x20, 0x08, 0x46, 0x00, 0x88, 0x95, 0x40, 0x19, 0x14, 0x01,
-  0x8d, 0x19, 0x00, 0x12, 0x33, 0x00, 0x14, 0x66, 0x00, 0x08, 0x8c, 0x11,
-  0x80, 0x20, 0x08, 0xe2, 0x1f, 0x00, 0x00, 0x00, 0xe3, 0x11, 0x0c, 0x74,
-  0x41, 0x14, 0x94, 0xf1, 0x88, 0x47, 0xca, 0x24, 0x0a, 0xca, 0x20, 0xc3,
-  0x60, 0x30, 0x26, 0x04, 0xf2, 0x19, 0x8f, 0x98, 0xac, 0xae, 0xa1, 0xa0,
-  0x0c, 0x32, 0x1c, 0x4a, 0x64, 0x42, 0x20, 0x1f, 0x0b, 0x0a, 0xf8, 0x8c,
-  0x47, 0x60, 0x9b, 0x18, 0x40, 0x14, 0x94, 0x41, 0x06, 0xe6, 0xb9, 0x4c,
-  0x08, 0xe4, 0x63, 0x45, 0x00, 0x9f, 0xf1, 0x88, 0x0e, 0x0c, 0xce, 0xc0,
-  0xa2, 0xa0, 0x0c, 0x32, 0x44, 0x54, 0x67, 0x42, 0x20, 0x1f, 0x2b, 0x02,
-  0xf8, 0x8c, 0x47, 0x84, 0x41, 0x19, 0xb0, 0x01, 0x47, 0x41, 0x19, 0x64,
-  0x08, 0xb2, 0xcf, 0x82, 0x4a, 0x3e, 0x83, 0x0c, 0xc3, 0x26, 0x06, 0x16,
-  0x4c, 0xf2, 0xb1, 0x21, 0x80, 0xcf, 0x20, 0x83, 0xe1, 0x99, 0x81, 0x05,
-  0x91, 0x7c, 0x6c, 0x08, 0xe0, 0x33, 0xc8, 0x90, 0x84, 0x81, 0x1a, 0x58,
-  0xf0, 0xc8, 0xc7, 0x86, 0x00, 0x3e, 0xe3, 0x11, 0x6e, 0x20, 0x07, 0x79,
-  0x80, 0x06, 0x14, 0x94, 0x41, 0x86, 0xc0, 0x0c, 0xd8, 0xc0, 0x02, 0x31,
-  0x90, 0xcf, 0x20, 0xc3, 0x80, 0x06, 0x6f, 0x60, 0x01, 0x18, 0xc8, 0x67,
-  0x90, 0xa1, 0x50, 0x03, 0x39, 0xb0, 0xa0, 0x93, 0xcf, 0x20, 0xc3, 0xc1,
-  0x06, 0x75, 0x60, 0x81, 0x26, 0x9f, 0x41, 0x06, 0x3d, 0x80, 0x03, 0x3a,
-  0xb0, 0x2c, 0x90, 0xcf, 0x20, 0x03, 0x1f, 0xc8, 0xc1, 0x1d, 0x98, 0x13,
-  0xc8, 0xc7, 0x92, 0x01, 0x3e, 0x16, 0x30, 0xf0, 0xb1, 0x20, 0x81, 0x8f,
-  0x05, 0x08, 0x7c, 0x2c, 0x28, 0xe0, 0x33, 0xdb, 0x80, 0x07, 0x01, 0x30,
-  0xdb, 0x10, 0xdc, 0x41, 0x90, 0x41, 0x40, 0x0c, 0x09, 0x00, 0x00, 0x00,
-  0x5b, 0x86, 0x20, 0x78, 0x83, 0x2d, 0xc3, 0x10, 0xbc, 0xc1, 0x96, 0xe1,
-  0x08, 0xde, 0x60, 0xcb, 0xc0, 0x04, 0x6f, 0xb0, 0x65, 0x88, 0x82, 0x37,
-  0xd8, 0x32, 0x58, 0xc1, 0x1b, 0x6c, 0x19, 0xc6, 0x20, 0x78, 0x03, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b,
-  0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x60, 0x0b, 0x00, 0x00,
-  0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00,
-  0xd5, 0x02, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00,
-  0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49,
-  0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19,
-  0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42,
-  0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44, 0x24,
-  0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21, 0x72,
-  0x24, 0x07, 0xc8, 0x48, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0,
-  0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00, 0x00, 0x84, 0x00, 0x00, 0x00,
-  0x1b, 0xc8, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x80, 0x8a,
-  0x18, 0x87, 0x77, 0x90, 0x07, 0x79, 0x28, 0x87, 0x71, 0xa0, 0x07, 0x76,
-  0xc8, 0x87, 0x36, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x77, 0x20, 0x87, 0x72,
-  0x20, 0x87, 0x36, 0x20, 0x87, 0x74, 0xb0, 0x87, 0x74, 0x20, 0x87, 0x72,
-  0x68, 0x83, 0x79, 0x88, 0x07, 0x79, 0xa0, 0x87, 0x36, 0x30, 0x07, 0x78,
-  0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0xc0, 0x1c, 0xc2, 0x81,
-  0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1c, 0xd2, 0x61, 0x1e, 0xc2, 0x41,
-  0x1c, 0xd8, 0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xc2, 0x21, 0x1d, 0xd8, 0xa1,
-  0x0d, 0xc6, 0x21, 0x1c, 0xd8, 0x81, 0x1d, 0xe6, 0x01, 0x30, 0x87, 0x70,
-  0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x60, 0x87, 0x72, 0x98, 0x87, 0x79,
-  0x68, 0x03, 0x78, 0x90, 0x87, 0x72, 0x18, 0x87, 0x74, 0x98, 0x87, 0x72,
-  0x68, 0x03, 0x73, 0x80, 0x87, 0x76, 0x08, 0x07, 0x72, 0x00, 0xcc, 0x21,
-  0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0,
-  0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21,
-  0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21,
-  0x1d, 0xda, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x06, 0x77,
-  0x78, 0x87, 0x36, 0x30, 0x07, 0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36,
-  0x80, 0x87, 0x77, 0x48, 0x07, 0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36,
-  0x28, 0x07, 0x76, 0x48, 0x87, 0x76, 0x68, 0x03, 0x77, 0x78, 0x07, 0x77,
-  0x68, 0x03, 0x76, 0x28, 0x87, 0x70, 0x30, 0x07, 0x80, 0x70, 0x87, 0x77,
-  0x68, 0x83, 0x74, 0x70, 0x07, 0x73, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78,
-  0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1,
-  0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x40, 0x1d, 0xea, 0xa1,
-  0x1d, 0xe0, 0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61,
-  0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x77,
-  0x78, 0x87, 0x36, 0x70, 0x87, 0x70, 0x70, 0x87, 0x79, 0x68, 0x03, 0x73,
-  0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41,
-  0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe6, 0x21,
-  0x1d, 0xce, 0xc1, 0x1d, 0xca, 0x81, 0x1c, 0xda, 0x40, 0x1f, 0xca, 0x41,
-  0x1e, 0xde, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21,
-  0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80,
-  0x70, 0x87, 0x77, 0x68, 0x03, 0x7a, 0x90, 0x87, 0x70, 0x80, 0x07, 0x78,
-  0x48, 0x07, 0x77, 0x38, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74,
-  0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0x62, 0x1e, 0xe8, 0x21,
-  0x1c, 0xc6, 0x61, 0x1d, 0xda, 0x00, 0x1e, 0xe4, 0xe1, 0x1d, 0xe8, 0xa1,
-  0x1c, 0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0x40, 0x1c, 0xea, 0xc1,
-  0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xf4, 0xa1,
-  0x1c, 0x00, 0x3c, 0x00, 0x88, 0x7a, 0x70, 0x87, 0x79, 0x08, 0x07, 0x73,
-  0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a,
-  0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xea, 0x61,
-  0x1e, 0xca, 0xa1, 0x0d, 0xe6, 0xe1, 0x1d, 0xcc, 0x81, 0x1e, 0xda, 0xc0,
-  0x1c, 0xd8, 0xe1, 0x1d, 0xc2, 0x81, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76,
-  0x98, 0x87, 0x72, 0x00, 0x36, 0x20, 0xc2, 0x00, 0x24, 0xc0, 0x02, 0x54,
-  0x1b, 0x90, 0x81, 0x00, 0x12, 0x60, 0x01, 0x2a, 0x00, 0x00, 0x00, 0x00,
-  0x49, 0x18, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x86, 0x40, 0x18,
-  0x00, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00,
-  0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84,
-  0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c,
-  0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x40, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30,
-  0x8c, 0x20, 0x00, 0x56, 0x08, 0x22, 0x09, 0xc2, 0x4c, 0xd4, 0x3c, 0xd0,
-  0x83, 0x3c, 0xd4, 0xc3, 0x38, 0xd0, 0x83, 0x1b, 0xb4, 0x43, 0x39, 0xd0,
-  0x43, 0x38, 0xb0, 0x83, 0x1e, 0xe8, 0x41, 0x3b, 0x84, 0x03, 0x3d, 0xc8,
-  0x43, 0x3a, 0xe0, 0x03, 0x0a, 0xc8, 0x20, 0x42, 0x21, 0x94, 0x62, 0x08,
-  0x61, 0x0c, 0x9d, 0x81, 0x80, 0x39, 0x02, 0x30, 0x48, 0x01, 0x35, 0x47,
-  0x00, 0x0a, 0x83, 0x08, 0x81, 0x30, 0x8c, 0x40, 0x28, 0x23, 0x00, 0x00,
-  0x13, 0xa8, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70,
-  0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87, 0x79,
-  0xc8, 0x03, 0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7, 0x51, 0x0e,
-  0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a, 0x80, 0x07,
-  0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78, 0xa0, 0x07,
-  0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07,
-  0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07,
-  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x60, 0x07,
-  0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06,
-  0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
-  0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76, 0xa0, 0x07,
-  0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07,
-  0x74, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06,
-  0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
-  0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74, 0xa0, 0x07,
-  0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x90, 0x07,
-  0x76, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07,
-  0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07,
-  0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f,
-  0x71, 0x90, 0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07,
-  0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75, 0x60, 0x07,
-  0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07,
-  0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07,
-  0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x10, 0x07,
-  0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07,
-  0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee, 0x80, 0x07,
-  0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43, 0x18, 0x04,
-  0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x2c, 0x10, 0x00, 0x00,
-  0x0a, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90,
-  0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x52, 0x25, 0x30, 0x02, 0x50,
-  0x80, 0x01, 0x45, 0x50, 0x20, 0x65, 0x50, 0x08, 0x05, 0x41, 0x6c, 0x04,
-  0x80, 0xd6, 0x58, 0x82, 0x23, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00,
-  0xd9, 0x00, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25,
-  0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x86, 0x42, 0x24,
-  0xc0, 0xa2, 0x50, 0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3,
-  0x2b, 0x1b, 0x62, 0x28, 0x41, 0x22, 0x28, 0x07, 0xdd, 0x20, 0x08, 0x0e,
-  0x8e, 0xad, 0x0c, 0x84, 0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e,
-  0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x26, 0x06, 0x06, 0x26, 0xc6, 0x85, 0x66,
-  0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26,
-  0x06, 0x06, 0x26, 0xc6, 0x85, 0x66, 0x26, 0x65, 0x88, 0x90, 0x10, 0x43,
-  0x0c, 0x25, 0x50, 0x10, 0x45, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36,
-  0x04, 0x49, 0x0e, 0x25, 0x50, 0x02, 0x45, 0xe0, 0x16, 0x96, 0x26, 0xe7,
-  0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6,
-  0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96, 0x36, 0x17, 0x26, 0xc6, 0x56, 0x36,
-  0x44, 0x48, 0x12, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
-  0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74,
-  0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x84, 0x64, 0x21,
-  0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5, 0xc1, 0xa5, 0xb1, 0x95,
-  0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5, 0x99, 0x99, 0x95, 0xc9,
-  0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x95, 0xb9, 0x85, 0x89, 0xb1,
-  0x95, 0x0d, 0x11, 0x92, 0x86, 0x4c, 0x58, 0x9a, 0x9c, 0x0b, 0xdc, 0xdb,
-  0x5c, 0x1a, 0x5d, 0xda, 0x9b, 0x1b, 0xa3, 0xb0, 0x34, 0x39, 0x97, 0x30,
-  0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0x2f, 0xb7, 0xb0, 0xb6, 0x32,
-  0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x64, 0xc2, 0xd2, 0xe4, 0x5c,
-  0xc2, 0xe4, 0xce, 0xbe, 0xdc, 0xc2, 0xda, 0xca, 0x88, 0xc0, 0xbd, 0xcd,
-  0xa5, 0xd1, 0xa5, 0xbd, 0xb9, 0x0d, 0x51, 0x92, 0x27, 0x81, 0x92, 0x28,
-  0x91, 0x92, 0x89, 0x51, 0x58, 0x9a, 0x9c, 0x8b, 0x5d, 0x99, 0x1c, 0x5d,
-  0x19, 0xde, 0xd7, 0x5b, 0x1d, 0x1d, 0x5c, 0x1d, 0x1d, 0xb3, 0xb3, 0x32,
-  0xb7, 0x32, 0xb9, 0x30, 0xba, 0x32, 0x32, 0x14, 0x1c, 0xba, 0x32, 0xbc,
-  0xb1, 0xb7, 0x37, 0x39, 0x32, 0x22, 0x3b, 0x99, 0x2f, 0xb3, 0x14, 0x1a,
-  0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32, 0x44, 0xe8, 0xca, 0xf0, 0xc6, 0xde,
-  0xde, 0xe4, 0xc8, 0x86, 0x30, 0x49, 0x95, 0x58, 0x09, 0x94, 0x5c, 0x89,
-  0x94, 0x60, 0x43, 0x88, 0x84, 0x4a, 0x32, 0x42, 0x61, 0x69, 0x72, 0x2e,
-  0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74,
-  0x94, 0xc2, 0xd2, 0xe4, 0x5c, 0xd8, 0xde, 0xc6, 0xc2, 0xe8, 0xd2, 0xde,
-  0xdc, 0xbe, 0xd2, 0xdc, 0xc8, 0xca, 0xf0, 0xe8, 0x9d, 0x95, 0xb9, 0x95,
-  0xc9, 0x85, 0xd1, 0x95, 0x91, 0xa1, 0x7c, 0x7d, 0x85, 0xa5, 0xc9, 0x7d,
-  0xc1, 0xb1, 0x85, 0x8d, 0x95, 0xa1, 0xbd, 0xb1, 0x91, 0x95, 0xc9, 0x7d,
-  0x7d, 0xa5, 0x0c, 0xa1, 0x14, 0x21, 0xd9, 0x12, 0x4e, 0x11, 0x94, 0x20,
-  0xe9, 0x12, 0x28, 0xb9, 0x12, 0x29, 0x99, 0x86, 0x50, 0x4a, 0x90, 0x6c,
-  0x09, 0xa7, 0x04, 0x4a, 0x90, 0x74, 0x09, 0x94, 0x5c, 0x89, 0x94, 0x60,
-  0x54, 0xc2, 0xd2, 0xe4, 0x5c, 0xc4, 0xea, 0xcc, 0xcc, 0xca, 0xe4, 0xf8,
-  0x84, 0xa5, 0xc9, 0xb9, 0x88, 0xd5, 0x99, 0x99, 0x95, 0xc9, 0x7d, 0xcd,
-  0xa5, 0xe9, 0x95, 0x11, 0x09, 0x4b, 0x93, 0x73, 0x91, 0x2b, 0x0b, 0x23,
-  0x63, 0x14, 0x96, 0x26, 0xe7, 0x12, 0x26, 0x77, 0xf6, 0x45, 0x97, 0x07,
-  0x57, 0xf6, 0x35, 0x97, 0xa6, 0x57, 0xc6, 0x2b, 0x2c, 0x4d, 0xce, 0x25,
-  0x4c, 0xee, 0xec, 0x8b, 0x2e, 0x0f, 0xae, 0xec, 0x2b, 0x8c, 0x2d, 0xed,
-  0xcc, 0xed, 0x6b, 0x2e, 0x4d, 0xaf, 0x8c, 0x88, 0x19, 0xdb, 0x5b, 0x18,
-  0x1d, 0x0d, 0x1e, 0x0d, 0x15, 0x38, 0xb9, 0x37, 0xb5, 0xb2, 0x31, 0xba,
-  0xb4, 0x37, 0xb7, 0x21, 0x60, 0xa0, 0x10, 0x09, 0x18, 0x24, 0x61, 0xa0,
-  0x0c, 0x09, 0xa7, 0x10, 0x4a, 0x90, 0x88, 0x41, 0x32, 0x06, 0xca, 0x90,
-  0x90, 0x81, 0x52, 0x24, 0x50, 0x52, 0x06, 0x89, 0x94, 0x98, 0x01, 0x13,
-  0x3a, 0xb9, 0x30, 0xb7, 0x39, 0xb3, 0x37, 0xb9, 0xb6, 0x21, 0x60, 0xa0,
-  0x18, 0x09, 0x18, 0x24, 0x61, 0xa0, 0x0c, 0x09, 0xa7, 0x18, 0x4a, 0x90,
-  0x88, 0x41, 0x32, 0x06, 0xca, 0x90, 0x90, 0x81, 0x52, 0x24, 0x50, 0x52,
-  0x06, 0x89, 0x94, 0xa0, 0xc1, 0x10, 0x24, 0xf1, 0x92, 0x2f, 0x39, 0x83,
-  0x24, 0x0d, 0x86, 0x18, 0x08, 0x90, 0x68, 0x89, 0x1a, 0xf0, 0x79, 0x6b,
+  0xb9, 0x0d, 0x51, 0x92, 0x27, 0x81, 0x92, 0x28, 0x91, 0x92, 0x89, 0x51,
+  0x58, 0x9a, 0x9c, 0x8b, 0x5d, 0x99, 0x1c, 0x5d, 0x19, 0xde, 0xd7, 0x5b,
+  0x1d, 0x1d, 0x5c, 0x1d, 0x1d, 0xad, 0xb3, 0x32, 0xb7, 0x32, 0xb9, 0x30,
+  0xba, 0x32, 0x32, 0x94, 0x9a, 0xb1, 0x37, 0xb6, 0x37, 0x39, 0x22, 0x3b,
+  0x9a, 0x2f, 0xb3, 0x14, 0x16, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x43, 0x98,
+  0xa4, 0x4a, 0xac, 0x04, 0x4a, 0xa2, 0x44, 0x4a, 0x2e, 0x3a, 0x61, 0x69,
+  0x72, 0x2e, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x5f, 0x73, 0x69, 0x7a, 0x65,
+  0x2c, 0xcc, 0xd8, 0xde, 0xc2, 0xe8, 0x98, 0xc0, 0xbd, 0xa5, 0xb9, 0xd1,
+  0x4d, 0xa5, 0xe9, 0x95, 0x0d, 0x51, 0x92, 0x2c, 0x81, 0x12, 0x2d, 0x91,
+  0x92, 0x6d, 0x88, 0x91, 0x50, 0x09, 0x96, 0x70, 0x84, 0xc2, 0xd2, 0xe4,
+  0x5c, 0xec, 0xca, 0xe4, 0xe8, 0xca, 0xf0, 0xbe, 0xd2, 0xdc, 0xe0, 0xea,
+  0xe8, 0x28, 0x85, 0xa5, 0xc9, 0xb9, 0xb0, 0xbd, 0x8d, 0x85, 0xd1, 0xa5,
+  0xbd, 0xb9, 0x7d, 0xa5, 0xb9, 0x91, 0x95, 0xe1, 0xd1, 0x3b, 0x2b, 0x73,
+  0x2b, 0x93, 0x0b, 0xa3, 0x2b, 0x23, 0x43, 0xf9, 0xfa, 0x0a, 0x4b, 0x93,
+  0xfb, 0x82, 0x63, 0x0b, 0x1b, 0x2b, 0x43, 0x7b, 0x63, 0x23, 0x2b, 0x93,
+  0xfb, 0xfa, 0x4a, 0xa1, 0x61, 0xc6, 0xf6, 0x16, 0x46, 0x27, 0x33, 0x84,
+  0x52, 0x84, 0xc4, 0x4b, 0x3e, 0x45, 0x50, 0x82, 0x04, 0x0c, 0x12, 0x28,
+  0x09, 0x83, 0x44, 0x4a, 0xa6, 0x21, 0x94, 0x12, 0x24, 0x5e, 0xf2, 0x29,
+  0x81, 0x12, 0x24, 0x60, 0x90, 0x40, 0x49, 0x94, 0x48, 0xc9, 0x45, 0x25,
+  0x2c, 0x4d, 0xce, 0x45, 0xac, 0xce, 0xcc, 0xac, 0x4c, 0x8e, 0x4f, 0x58,
+  0x9a, 0x9c, 0x8b, 0x58, 0x9d, 0x99, 0x59, 0x99, 0xdc, 0xd7, 0x5c, 0x9a,
+  0x5e, 0x19, 0x91, 0xb0, 0x34, 0x39, 0x17, 0xb9, 0xb2, 0x30, 0x32, 0x46,
+  0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65,
+  0x5f, 0x73, 0x69, 0x7a, 0x65, 0xbc, 0xc2, 0xd2, 0xe4, 0x5c, 0xc2, 0xe4,
+  0xce, 0xbe, 0xe8, 0xf2, 0xe0, 0xca, 0xbe, 0xc2, 0xd8, 0xd2, 0xce, 0xdc,
+  0xbe, 0xe6, 0xd2, 0xf4, 0xca, 0x88, 0x98, 0xb1, 0xbd, 0x85, 0xd1, 0xd1,
+  0xe0, 0xd1, 0x50, 0x81, 0x93, 0x7b, 0x53, 0x2b, 0x1b, 0xa3, 0x4b, 0x7b,
+  0x73, 0x1b, 0x02, 0x06, 0x0a, 0x91, 0x90, 0x41, 0x52, 0x06, 0xca, 0x90,
+  0x7c, 0x0a, 0xa1, 0x04, 0x89, 0x19, 0x24, 0x67, 0xa0, 0x0c, 0x09, 0x1a,
+  0x28, 0x45, 0x02, 0x25, 0x69, 0x90, 0x48, 0x89, 0x1a, 0x30, 0xa1, 0x93,
+  0x0b, 0x73, 0x9b, 0x33, 0x7b, 0x93, 0x6b, 0x1b, 0x02, 0x06, 0x8a, 0x91,
+  0x90, 0x41, 0x52, 0x06, 0xca, 0x90, 0x7c, 0x8a, 0xa1, 0x04, 0x89, 0x19,
+  0x24, 0x67, 0xa0, 0x0c, 0x09, 0x1a, 0x28, 0x45, 0x02, 0x25, 0x69, 0x90,
+  0x48, 0x09, 0x1b, 0x0c, 0x41, 0x12, 0x31, 0x48, 0xc6, 0x20, 0x59, 0x83,
+  0xa4, 0x0d, 0x86, 0x18, 0x08, 0x90, 0x74, 0x89, 0x1b, 0xf0, 0x79, 0x6b,
   0x73, 0x4b, 0x83, 0x7b, 0xa3, 0x2b, 0x73, 0xa3, 0x03, 0x19, 0x43, 0x0b,
   0x93, 0xe3, 0x33, 0x95, 0xd6, 0x06, 0xc7, 0x56, 0x06, 0x32, 0xb4, 0xb2,
-  0x02, 0x42, 0x25, 0x14, 0x14, 0x34, 0x44, 0x48, 0xda, 0x60, 0x88, 0x91,
-  0xb0, 0x41, 0xe2, 0x06, 0x4c, 0x32, 0xc4, 0x48, 0xde, 0x20, 0x79, 0x03,
+  0x02, 0x42, 0x25, 0x14, 0x14, 0x34, 0x44, 0x48, 0xe2, 0x60, 0x88, 0x91,
+  0xc0, 0x41, 0x22, 0x07, 0x4c, 0x32, 0xc4, 0x48, 0xe6, 0x20, 0x99, 0x03,
   0x26, 0x19, 0x11, 0xb1, 0x03, 0x3b, 0xd8, 0x43, 0x3b, 0xb8, 0x41, 0x3b,
   0xbc, 0x03, 0x39, 0xd4, 0x03, 0x3b, 0x94, 0x83, 0x1b, 0x98, 0x03, 0x3b,
   0x84, 0xc3, 0x39, 0xcc, 0xc3, 0x14, 0x21, 0x18, 0x46, 0x28, 0xec, 0xc0,
@@ -506,182 +270,435 @@ const unsigned char sdl_metallib[] = {
   0x0f, 0xe9, 0xc0, 0x0e, 0xe5, 0xf0, 0x0b, 0xef, 0x00, 0x0f, 0xf4, 0x90,
   0x0e, 0xef, 0xe0, 0x0e, 0xf3, 0x30, 0x65, 0x50, 0x18, 0x67, 0x84, 0x12,
   0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0x60, 0x0f, 0xe5, 0x20, 0x0f, 0xf4, 0x50,
-  0x0e, 0xf8, 0x30, 0x25, 0x58, 0x03, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00,
-  0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66,
-  0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07,
-  0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10,
-  0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce,
-  0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b,
-  0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c,
-  0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07,
-  0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11,
-  0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0,
-  0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8,
-  0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b,
-  0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b,
-  0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87,
-  0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07,
-  0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87,
-  0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81,
-  0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30,
-  0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4,
-  0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca,
-  0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39,
-  0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b,
-  0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b,
-  0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83,
-  0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87,
-  0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90,
-  0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20,
-  0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc,
-  0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66,
-  0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24,
-  0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07,
-  0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e,
-  0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e,
-  0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54,
-  0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39,
-  0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c,
-  0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07,
-  0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0,
-  0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4,
-  0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38,
-  0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d,
-  0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d,
-  0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
-  0x06, 0xf0, 0xb0, 0x5d, 0xf9, 0x73, 0xce, 0x83, 0xfd, 0x15, 0x11, 0x4d,
-  0xc4, 0x05, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00,
-  0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
-  0xe4, 0xc6, 0x22, 0x86, 0x61, 0x18, 0xc6, 0x22, 0x04, 0x41, 0x10, 0xc6,
-  0x22, 0x82, 0x20, 0x08, 0x88, 0x95, 0x40, 0x19, 0x14, 0x01, 0xb9, 0x11,
-  0x00, 0x1a, 0x33, 0x00, 0x24, 0x66, 0x00, 0x28, 0xcc, 0x00, 0x00, 0x00,
-  0xe3, 0x11, 0x0b, 0x74, 0x41, 0x14, 0x94, 0xf1, 0x08, 0x47, 0xca, 0x24,
-  0x0a, 0xca, 0x20, 0xc3, 0x50, 0x20, 0x26, 0x04, 0xf2, 0x19, 0x8f, 0x90,
-  0xac, 0xae, 0xa1, 0xa0, 0x0c, 0x32, 0x1c, 0x09, 0x64, 0x42, 0x20, 0x1f,
-  0x0b, 0x0a, 0xf8, 0x8c, 0x47, 0x5c, 0x9b, 0x18, 0x40, 0x14, 0x94, 0x41,
-  0x06, 0xc6, 0xb1, 0x4c, 0x08, 0xe4, 0x63, 0x45, 0x00, 0x9f, 0xf1, 0x08,
-  0x0e, 0x0c, 0xce, 0xc0, 0xa2, 0xa0, 0x0c, 0x32, 0x44, 0x13, 0x67, 0x42,
-  0x20, 0x1f, 0x2b, 0x02, 0xf8, 0x8c, 0x47, 0x80, 0x41, 0x19, 0xb0, 0x01,
-  0x47, 0x41, 0x19, 0x64, 0x08, 0xb0, 0xcd, 0x82, 0x4a, 0x3e, 0x83, 0x0c,
-  0x83, 0x16, 0x06, 0x16, 0x4c, 0xf2, 0xb1, 0x21, 0x80, 0xcf, 0x20, 0x83,
-  0xd1, 0x95, 0x81, 0x05, 0x91, 0x7c, 0x6c, 0x08, 0xe0, 0x33, 0xc8, 0x90,
-  0x80, 0x41, 0x1a, 0x58, 0xf0, 0xc8, 0xc7, 0x86, 0x00, 0x3e, 0xe3, 0x11,
-  0x6d, 0x20, 0x07, 0x79, 0x80, 0x06, 0x14, 0x94, 0x41, 0x86, 0xa0, 0x0c,
-  0xd0, 0xc0, 0x02, 0x31, 0x90, 0xcf, 0x20, 0xc3, 0x70, 0x06, 0x6e, 0x60,
-  0x01, 0x18, 0xc8, 0x67, 0x90, 0xa1, 0x48, 0x83, 0x38, 0xb0, 0xa0, 0x93,
-  0xcf, 0x20, 0xc3, 0xb1, 0x06, 0x74, 0x60, 0x81, 0x26, 0x9f, 0x41, 0x06,
-  0x3d, 0x70, 0x03, 0x38, 0xb0, 0x2c, 0x90, 0xcf, 0x20, 0x03, 0x1f, 0xc0,
-  0x81, 0x1d, 0x98, 0x13, 0xc8, 0xc7, 0x92, 0x01, 0x3e, 0x16, 0x30, 0xf0,
-  0xb1, 0x20, 0x81, 0x8f, 0x05, 0x08, 0x7c, 0x2c, 0x28, 0xe0, 0x33, 0xdb,
-  0x80, 0x07, 0x01, 0x30, 0xdb, 0x10, 0x8c, 0x42, 0x90, 0x41, 0x40, 0x0c,
-  0x09, 0x00, 0x00, 0x00, 0x5b, 0x86, 0x20, 0x80, 0x83, 0x2d, 0xc3, 0x10,
-  0xc0, 0xc1, 0x96, 0xe1, 0x08, 0xe0, 0x60, 0xcb, 0xc0, 0x04, 0x70, 0xb0,
-  0x65, 0x88, 0x02, 0x38, 0xd8, 0x32, 0x58, 0x01, 0x1c, 0x6c, 0x19, 0xc6,
-  0x20, 0x80, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x0e, 0xf8, 0x30, 0x25, 0x78, 0x03, 0x00, 0x00, 0x00, 0x00, 0x79, 0x18,
+  0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1,
+  0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42,
+  0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f,
+  0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1,
+  0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84,
+  0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc,
+  0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70,
+  0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19,
+  0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f,
+  0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21,
+  0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc,
+  0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84,
+  0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37,
+  0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70,
+  0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77,
+  0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79,
+  0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e,
+  0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1,
+  0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81,
+  0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98,
+  0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88,
+  0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4,
+  0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72,
+  0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74,
+  0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e,
+  0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e,
+  0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21,
+  0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01,
+  0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc,
+  0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77,
+  0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e,
+  0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1,
+  0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61,
+  0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0,
+  0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0,
+  0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74,
+  0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e,
+  0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41,
+  0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50,
+  0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c,
+  0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc,
+  0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20, 0x00, 0x00, 0x04, 0x00,
+  0x00, 0x00, 0x06, 0x00, 0xb1, 0x5d, 0xf9, 0xb3, 0xce, 0x82, 0x0c, 0x7f,
+  0x45, 0x44, 0x13, 0x71, 0x01, 0x00, 0x61, 0x20, 0x00, 0x00, 0x54, 0x00,
+  0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x0b, 0x00,
+  0x00, 0x00, 0xe4, 0xc6, 0x22, 0x86, 0x61, 0x18, 0xc6, 0x22, 0x04, 0x41,
+  0x10, 0xc6, 0x22, 0x82, 0x20, 0x08, 0x46, 0x00, 0x88, 0x95, 0x40, 0x19,
+  0x14, 0x01, 0x8d, 0x19, 0x00, 0x12, 0x33, 0x00, 0x14, 0x66, 0x00, 0x08,
+  0x8c, 0x11, 0x80, 0x20, 0x08, 0xe2, 0x1f, 0x00, 0x00, 0x00, 0xe3, 0x11,
+  0x4c, 0x84, 0x45, 0x14, 0x94, 0xf1, 0x88, 0x67, 0xd2, 0x26, 0x0a, 0xca,
+  0x20, 0xc3, 0x60, 0x30, 0x26, 0x04, 0xf2, 0x19, 0x8f, 0x98, 0x2e, 0xaf,
+  0xa1, 0xa0, 0x0c, 0x32, 0x1c, 0x4a, 0x64, 0x42, 0x20, 0x1f, 0x0b, 0x0a,
+  0xf8, 0x8c, 0x47, 0x60, 0xdc, 0x18, 0x40, 0x14, 0x94, 0x41, 0x06, 0xe6,
+  0xb9, 0x4c, 0x08, 0xe4, 0x63, 0x45, 0x00, 0x9f, 0xf1, 0x88, 0x2e, 0x0c,
+  0xd0, 0xc0, 0xa2, 0xa0, 0x0c, 0x32, 0x44, 0x54, 0x67, 0x42, 0x20, 0x1f,
+  0x2b, 0x02, 0xf8, 0x8c, 0x47, 0x84, 0x81, 0x19, 0xb4, 0x01, 0x47, 0x41,
+  0x19, 0x64, 0x08, 0xb2, 0xcf, 0x82, 0x4a, 0x3e, 0x83, 0x0c, 0xc3, 0x26,
+  0x06, 0x16, 0x4c, 0xf2, 0xb1, 0x21, 0x80, 0xcf, 0x20, 0x83, 0xe1, 0x99,
+  0x81, 0x05, 0x91, 0x7c, 0x6c, 0x08, 0xe0, 0x33, 0xc8, 0x90, 0x84, 0x81,
+  0x1a, 0x58, 0xf0, 0xc8, 0xc7, 0x86, 0x00, 0x3e, 0xe3, 0x11, 0x6e, 0x30,
+  0x07, 0x7a, 0x80, 0x06, 0x14, 0x94, 0x41, 0x86, 0xc0, 0x0c, 0xd8, 0xc0,
+  0x02, 0x31, 0x90, 0xcf, 0x20, 0xc3, 0x80, 0x06, 0x6f, 0x60, 0x01, 0x18,
+  0xc8, 0x67, 0x90, 0xa1, 0x50, 0x03, 0x39, 0xb0, 0xa0, 0x93, 0xcf, 0x20,
+  0xc3, 0xc1, 0x06, 0x75, 0x60, 0x81, 0x26, 0x9f, 0x41, 0x86, 0x3d, 0x80,
+  0x03, 0x3a, 0xb0, 0x2c, 0x90, 0xcf, 0x20, 0x43, 0x1f, 0xc8, 0xc1, 0x1d,
+  0x98, 0x13, 0xc8, 0xc7, 0x92, 0x01, 0x3e, 0x16, 0x30, 0xf0, 0xb1, 0x20,
+  0x81, 0x8f, 0x05, 0x08, 0x7c, 0x2c, 0x28, 0xe0, 0x33, 0xdb, 0x80, 0x07,
+  0x01, 0x30, 0xdb, 0x10, 0x90, 0x42, 0x30, 0xdb, 0x10, 0xe0, 0x81, 0x90,
+  0x41, 0x40, 0x0c, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x5b, 0x86,
+  0x20, 0xa0, 0x83, 0x2d, 0xc3, 0x10, 0xd0, 0xc1, 0x96, 0xe1, 0x08, 0xe8,
+  0x60, 0xcb, 0xc0, 0x04, 0x74, 0xb0, 0x65, 0x88, 0x02, 0x3a, 0xd8, 0x32,
+  0x58, 0x01, 0x1d, 0x6c, 0x19, 0xc6, 0x20, 0xa0, 0x03, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
-  0x14, 0x09, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde,
-  0x21, 0x0c, 0x00, 0x00, 0x42, 0x02, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00,
-  0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91,
-  0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c,
-  0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x10, 0x45, 0x02,
-  0x42, 0x92, 0x0b, 0x42, 0x84, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x49,
-  0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52, 0x80,
-  0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8, 0x08, 0x11, 0x62, 0xa8, 0xa0,
-  0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00, 0x00,
-  0x82, 0x00, 0x00, 0x00, 0x1b, 0xc8, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff,
-  0x01, 0x90, 0x80, 0x8a, 0x18, 0x87, 0x77, 0x90, 0x07, 0x79, 0x28, 0x87,
-  0x71, 0xa0, 0x07, 0x76, 0xc8, 0x87, 0x36, 0x90, 0x87, 0x77, 0xa8, 0x07,
-  0x77, 0x20, 0x87, 0x72, 0x20, 0x87, 0x36, 0x20, 0x87, 0x74, 0xb0, 0x87,
-  0x74, 0x20, 0x87, 0x72, 0x68, 0x83, 0x79, 0x88, 0x07, 0x79, 0xa0, 0x87,
-  0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07,
-  0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1c, 0xd2,
-  0x61, 0x1e, 0xc2, 0x41, 0x1c, 0xd8, 0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xc2,
-  0x21, 0x1d, 0xd8, 0xa1, 0x0d, 0xc6, 0x21, 0x1c, 0xd8, 0x81, 0x1d, 0xe6,
-  0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x60, 0x87,
-  0x72, 0x98, 0x87, 0x79, 0x68, 0x03, 0x78, 0x90, 0x87, 0x72, 0x18, 0x87,
-  0x74, 0x98, 0x87, 0x72, 0x68, 0x03, 0x73, 0x80, 0x87, 0x76, 0x08, 0x07,
-  0x72, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc,
-  0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda,
-  0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda,
-  0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87,
-  0x72, 0x00, 0x06, 0x77, 0x78, 0x87, 0x36, 0x30, 0x07, 0x79, 0x08, 0x87,
-  0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77, 0x48, 0x07, 0x77, 0xa0, 0x87,
-  0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76, 0x48, 0x87, 0x76, 0x68, 0x03,
-  0x77, 0x78, 0x07, 0x77, 0x68, 0x03, 0x76, 0x28, 0x87, 0x70, 0x30, 0x07,
-  0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x74, 0x70, 0x07, 0x73, 0x98, 0x87,
-  0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07,
-  0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda,
-  0x40, 0x1d, 0xea, 0xa1, 0x1d, 0xe0, 0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xc4,
-  0x81, 0x1d, 0xca, 0x61, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87,
-  0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x70, 0x87, 0x70, 0x70, 0x87,
-  0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07,
-  0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde,
-  0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xce, 0xc1, 0x1d, 0xca, 0x81, 0x1c, 0xda,
-  0x40, 0x1f, 0xca, 0x41, 0x1e, 0xde, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0,
-  0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87,
-  0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x7a, 0x90, 0x87,
-  0x70, 0x80, 0x07, 0x78, 0x48, 0x07, 0x77, 0x38, 0x87, 0x36, 0x68, 0x87,
-  0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00,
-  0x62, 0x1e, 0xe8, 0x21, 0x1c, 0xc6, 0x61, 0x1d, 0xda, 0x00, 0x1e, 0xe4,
-  0xe1, 0x1d, 0xe8, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda,
-  0x40, 0x1c, 0xea, 0xc1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xe6,
-  0x21, 0x1d, 0xf4, 0xa1, 0x1c, 0x00, 0x3c, 0x00, 0x88, 0x7a, 0x70, 0x87,
-  0x79, 0x08, 0x07, 0x73, 0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00,
+  0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0xb0, 0x0b, 0x00, 0x00, 0xff, 0xff,
+  0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0xe9, 0x02,
+  0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00,
+  0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10,
+  0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04,
+  0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10,
+  0x32, 0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a,
+  0x90, 0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07,
+  0xc8, 0x48, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00,
+  0x00, 0x00, 0x51, 0x18, 0x00, 0x00, 0x84, 0x00, 0x00, 0x00, 0x1b, 0xc8,
+  0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x80, 0x8a, 0x18, 0x87,
+  0x77, 0x90, 0x07, 0x79, 0x28, 0x87, 0x71, 0xa0, 0x07, 0x76, 0xc8, 0x87,
+  0x36, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x77, 0x20, 0x87, 0x72, 0x20, 0x87,
+  0x36, 0x20, 0x87, 0x74, 0xb0, 0x87, 0x74, 0x20, 0x87, 0x72, 0x68, 0x83,
+  0x79, 0x88, 0x07, 0x79, 0xa0, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83,
+  0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6,
+  0xa1, 0x1c, 0x00, 0x82, 0x1c, 0xd2, 0x61, 0x1e, 0xc2, 0x41, 0x1c, 0xd8,
+  0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xc2, 0x21, 0x1d, 0xd8, 0xa1, 0x0d, 0xc6,
+  0x21, 0x1c, 0xd8, 0x81, 0x1d, 0xe6, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87,
+  0x79, 0x28, 0x07, 0x80, 0x60, 0x87, 0x72, 0x98, 0x87, 0x79, 0x68, 0x03,
+  0x78, 0x90, 0x87, 0x72, 0x18, 0x87, 0x74, 0x98, 0x87, 0x72, 0x68, 0x03,
+  0x73, 0x80, 0x87, 0x76, 0x08, 0x07, 0x72, 0x00, 0xcc, 0x21, 0x1c, 0xd8,
+  0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4,
+  0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc,
+  0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda,
+  0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x06, 0x77, 0x78, 0x87,
+  0x36, 0x30, 0x07, 0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87,
+  0x77, 0x48, 0x07, 0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07,
+  0x76, 0x48, 0x87, 0x76, 0x68, 0x03, 0x77, 0x78, 0x07, 0x77, 0x68, 0x03,
+  0x76, 0x28, 0x87, 0x70, 0x30, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83,
+  0x74, 0x70, 0x07, 0x73, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83,
   0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca,
-  0x01, 0x20, 0xea, 0x61, 0x1e, 0xca, 0xa1, 0x0d, 0xe6, 0xe1, 0x1d, 0xcc,
-  0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xd8, 0xe1, 0x1d, 0xc2, 0x81, 0x1e, 0x00,
-  0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x36, 0x20, 0x42, 0x00,
-  0x24, 0xc0, 0x02, 0x54, 0x00, 0x00, 0x00, 0x00, 0x49, 0x18, 0x00, 0x00,
-  0x01, 0x00, 0x00, 0x00, 0x13, 0x84, 0x40, 0x00, 0x89, 0x20, 0x00, 0x00,
-  0x0e, 0x00, 0x00, 0x00, 0x32, 0x22, 0x08, 0x09, 0x20, 0x64, 0x85, 0x04,
-  0x13, 0x22, 0xa4, 0x84, 0x04, 0x13, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14,
-  0x12, 0x4c, 0x88, 0x8c, 0x0b, 0x84, 0x84, 0x4c, 0x10, 0x28, 0x33, 0x00,
-  0xc3, 0x08, 0x04, 0x30, 0x88, 0x10, 0x04, 0x45, 0x08, 0xa1, 0x19, 0x08,
-  0x98, 0x23, 0x00, 0x83, 0x14, 0xb0, 0x39, 0x02, 0x50, 0x18, 0x01, 0x00,
-  0x13, 0xa8, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70,
-  0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87, 0x79,
-  0xc8, 0x03, 0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7, 0x51, 0x0e,
-  0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a, 0x80, 0x07,
-  0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78, 0xa0, 0x07,
-  0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07,
-  0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07,
-  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x60, 0x07,
-  0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06,
-  0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
-  0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76, 0xa0, 0x07,
-  0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07,
-  0x74, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06,
-  0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
-  0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74, 0xa0, 0x07,
-  0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x90, 0x07,
-  0x76, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07,
-  0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07,
-  0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f,
-  0x71, 0x90, 0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07,
-  0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75, 0x60, 0x07,
-  0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07,
-  0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07,
-  0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x10, 0x07,
-  0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07,
-  0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee, 0x80, 0x07,
-  0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43, 0x18, 0x02,
-  0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x2c, 0x10, 0x00, 0x00,
-  0x09, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90,
-  0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0xb2, 0x12, 0x18, 0x01, 0x28,
-  0x90, 0x22, 0x28, 0x84, 0x82, 0x20, 0x1c, 0x01, 0xa0, 0x1b, 0x4b, 0x70,
-  0x04, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0xa0, 0x00, 0x00, 0x00,
-  0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9,
-  0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x86, 0x41, 0x14, 0xc0, 0x81, 0x50, 0xb9,
-  0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b, 0x62, 0x18,
-  0x41, 0x21, 0x18, 0x05, 0xdd, 0x20, 0x08, 0x0e, 0x8e, 0xad, 0x0c, 0x84,
-  0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x0d,
-  0x64, 0x26, 0x06, 0x06, 0x26, 0xc6, 0x85, 0x66, 0x06, 0x04, 0xa5, 0xad,
-  0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26, 0x06, 0x06, 0x26, 0xc6,
-  0x85, 0x66, 0x26, 0x65, 0x88, 0x50, 0x10, 0x43, 0x0c, 0x23, 0x30, 0x0c,
+  0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x40, 0x1d, 0xea, 0xa1, 0x1d, 0xe0,
+  0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x1e, 0x00,
+  0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87,
+  0x36, 0x70, 0x87, 0x70, 0x70, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87,
+  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea,
+  0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xce,
+  0xc1, 0x1d, 0xca, 0x81, 0x1c, 0xda, 0x40, 0x1f, 0xca, 0x41, 0x1e, 0xde,
+  0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8,
+  0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87,
+  0x77, 0x68, 0x03, 0x7a, 0x90, 0x87, 0x70, 0x80, 0x07, 0x78, 0x48, 0x07,
+  0x77, 0x38, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8,
+  0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0x62, 0x1e, 0xe8, 0x21, 0x1c, 0xc6,
+  0x61, 0x1d, 0xda, 0x00, 0x1e, 0xe4, 0xe1, 0x1d, 0xe8, 0xa1, 0x1c, 0xc6,
+  0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0x40, 0x1c, 0xea, 0xc1, 0x1c, 0xcc,
+  0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xf4, 0xa1, 0x1c, 0x00,
+  0x3c, 0x00, 0x88, 0x7a, 0x70, 0x87, 0x79, 0x08, 0x07, 0x73, 0x28, 0x87,
+  0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07,
+  0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xea, 0x61, 0x1e, 0xca,
+  0xa1, 0x0d, 0xe6, 0xe1, 0x1d, 0xcc, 0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xd8,
+  0xe1, 0x1d, 0xc2, 0x81, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87,
+  0x72, 0x00, 0x36, 0x20, 0x02, 0x01, 0x24, 0xc0, 0x02, 0x54, 0x1b, 0x90,
+  0xa1, 0x00, 0x12, 0x60, 0x01, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x49, 0x18,
+  0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x86, 0x40, 0x18, 0x00, 0x00,
+  0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x32, 0x22,
+  0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93,
+  0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84,
+  0xa4, 0x4c, 0x10, 0x40, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20,
+  0x00, 0x76, 0x08, 0x41, 0x24, 0x41, 0x98, 0x89, 0x9a, 0x07, 0x7a, 0x90,
+  0x87, 0x7a, 0x18, 0x07, 0x7a, 0x70, 0x83, 0x76, 0x28, 0x07, 0x7a, 0x08,
+  0x07, 0x76, 0xd0, 0x03, 0x3d, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x79, 0x48,
+  0x07, 0x7c, 0x40, 0x01, 0x19, 0x44, 0x28, 0x84, 0x62, 0x0c, 0x11, 0x84,
+  0x31, 0x74, 0x06, 0x02, 0xe6, 0x08, 0xc0, 0x20, 0x05, 0xd4, 0x1c, 0x01,
+  0x28, 0x0c, 0x22, 0x04, 0xc2, 0x30, 0x02, 0xa1, 0x8c, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x13, 0xa8, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68,
+  0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78,
+  0x87, 0x79, 0xc8, 0x03, 0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7,
+  0x51, 0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a,
+  0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78,
+  0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71,
+  0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72,
+  0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9,
+  0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74,
+  0xd0, 0x06, 0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a,
+  0x30, 0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76,
+  0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6,
+  0x20, 0x07, 0x74, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72,
+  0xd0, 0x06, 0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a,
+  0x30, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6,
+  0x90, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71,
+  0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a,
+  0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d,
+  0x60, 0x0f, 0x71, 0x90, 0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76,
+  0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75,
+  0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75,
+  0x60, 0x07, 0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75,
+  0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6,
+  0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72,
+  0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee,
+  0x80, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43,
+  0x18, 0x04, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x2c, 0x10,
+  0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11,
+  0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x52, 0x25, 0x50,
+  0x04, 0x23, 0x00, 0x05, 0x18, 0x50, 0x08, 0x65, 0x50, 0x20, 0x05, 0x41,
+  0x6c, 0x04, 0x80, 0xd6, 0x58, 0x82, 0x33, 0x00, 0x00, 0x00, 0x79, 0x18,
+  0x00, 0x00, 0xea, 0x00, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29,
+  0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x86,
+  0x22, 0x24, 0xc0, 0xa2, 0x50, 0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a,
+  0x4b, 0xd3, 0x2b, 0x1b, 0x62, 0x28, 0x41, 0x22, 0x28, 0x05, 0xe1, 0x20,
+  0x08, 0x0e, 0x8e, 0xad, 0x0c, 0x84, 0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae,
+  0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x26, 0x06, 0x06, 0x26, 0xc6,
+  0xa5, 0x06, 0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac,
+  0x65, 0x26, 0x06, 0x06, 0x26, 0xc6, 0xa5, 0x06, 0xc6, 0x25, 0x26, 0x65,
+  0x88, 0x90, 0x10, 0x43, 0x0c, 0x25, 0x50, 0x10, 0x65, 0x60, 0xd1, 0x54,
+  0x46, 0x17, 0xc6, 0x36, 0x04, 0x49, 0x0e, 0x25, 0x50, 0x02, 0x65, 0xe0,
+  0x16, 0x96, 0x26, 0xe7, 0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6,
+  0x42, 0x56, 0xe6, 0xf6, 0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96, 0x36, 0x17,
+  0x26, 0xc6, 0x56, 0x36, 0x44, 0x48, 0x12, 0x72, 0x61, 0x69, 0x72, 0x2e,
+  0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74,
+  0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65,
+  0x43, 0x84, 0x64, 0x21, 0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5,
+  0xc1, 0xa5, 0xb1, 0x95, 0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5,
+  0x99, 0x99, 0x95, 0xc9, 0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x95,
+  0xb9, 0x85, 0x89, 0xb1, 0x95, 0x0d, 0x11, 0x92, 0x86, 0x4c, 0x58, 0x9a,
+  0x9c, 0x0b, 0xdc, 0xdb, 0x5c, 0x1a, 0x5d, 0xda, 0x9b, 0x1b, 0xa3, 0xb0,
+  0x34, 0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0x2f,
+  0xb7, 0xb0, 0xb6, 0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x64,
+  0xc2, 0xd2, 0xe4, 0x5c, 0xc2, 0xe4, 0xce, 0xbe, 0xdc, 0xc2, 0xda, 0xca,
+  0x88, 0xc0, 0xbd, 0xcd, 0xa5, 0xd1, 0xa5, 0xbd, 0xb9, 0x0d, 0x51, 0x92,
+  0x27, 0x81, 0x92, 0x28, 0x91, 0x92, 0x89, 0x51, 0x58, 0x9a, 0x9c, 0x8b,
+  0x5d, 0x99, 0x1c, 0x5d, 0x19, 0xde, 0xd7, 0x5b, 0x1d, 0x1d, 0x5c, 0x1d,
+  0x1d, 0xad, 0xb3, 0x32, 0xb7, 0x32, 0xb9, 0x30, 0xba, 0x32, 0x32, 0x94,
+  0x9a, 0xb1, 0x37, 0xb6, 0x37, 0x39, 0x22, 0x3b, 0x9a, 0x2f, 0xb3, 0x14,
+  0x16, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x43, 0x98, 0xa4, 0x4a, 0xac, 0x04,
+  0x4a, 0xa2, 0x44, 0x4a, 0x2e, 0x66, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61,
+  0x74, 0x65, 0x64, 0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72,
+  0x64, 0x44, 0x76, 0x32, 0x5f, 0x66, 0x29, 0x34, 0xcc, 0xd8, 0xde, 0xc2,
+  0xe8, 0x64, 0x88, 0xd0, 0x95, 0xe1, 0x8d, 0xbd, 0xbd, 0xc9, 0x91, 0x0d,
+  0x61, 0x92, 0x2a, 0xc9, 0x12, 0x28, 0xd1, 0x12, 0x29, 0xd9, 0x86, 0x18,
+  0x09, 0x95, 0x60, 0x09, 0x47, 0x28, 0x2c, 0x4d, 0xce, 0xc5, 0xae, 0x4c,
+  0x8e, 0xae, 0x0c, 0xef, 0x2b, 0xcd, 0x0d, 0xae, 0x8e, 0x8e, 0x52, 0x58,
+  0x9a, 0x9c, 0x0b, 0xdb, 0xdb, 0x58, 0x18, 0x5d, 0xda, 0x9b, 0xdb, 0x57,
+  0x9a, 0x1b, 0x59, 0x19, 0x1e, 0xbd, 0xb3, 0x32, 0xb7, 0x32, 0xb9, 0x30,
+  0xba, 0x32, 0x32, 0x94, 0xaf, 0xaf, 0xb0, 0x34, 0xb9, 0x2f, 0x38, 0xb6,
+  0xb0, 0xb1, 0x32, 0xb4, 0x37, 0x36, 0xb2, 0x32, 0xb9, 0xaf, 0xaf, 0x94,
+  0x21, 0x94, 0x32, 0x24, 0x5e, 0xf2, 0x29, 0x83, 0x12, 0x24, 0x60, 0x90,
+  0x40, 0x89, 0x96, 0x48, 0xc9, 0x34, 0x84, 0x52, 0x82, 0xc4, 0x4b, 0x3e,
+  0x25, 0x50, 0x82, 0x04, 0x0c, 0x12, 0x28, 0x89, 0x12, 0x29, 0xb9, 0x86,
+  0x50, 0x8a, 0x90, 0x78, 0xc9, 0xa7, 0x08, 0x4a, 0x90, 0x80, 0x41, 0x02,
+  0x25, 0x5a, 0x22, 0x25, 0x1b, 0x95, 0xb0, 0x34, 0x39, 0x17, 0xb1, 0x3a,
+  0x33, 0xb3, 0x32, 0x39, 0x3e, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66,
+  0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x44, 0xc2, 0xd2, 0xe4,
+  0x5c, 0xe4, 0xca, 0xc2, 0xc8, 0x18, 0x85, 0xa5, 0xc9, 0xb9, 0x84, 0xc9,
+  0x9d, 0x7d, 0xd1, 0xe5, 0xc1, 0x95, 0x7d, 0xcd, 0xa5, 0xe9, 0x95, 0xf1,
+  0x0a, 0x4b, 0x93, 0x73, 0x09, 0x93, 0x3b, 0xfb, 0xa2, 0xcb, 0x83, 0x2b,
+  0xfb, 0x0a, 0x63, 0x4b, 0x3b, 0x73, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x23,
+  0x62, 0xc6, 0xf6, 0x16, 0x46, 0x47, 0x83, 0x47, 0x43, 0x05, 0x4e, 0xee,
+  0x4d, 0xad, 0x6c, 0x8c, 0x2e, 0xed, 0xcd, 0x6d, 0x08, 0x18, 0x28, 0x46,
+  0x42, 0x06, 0x49, 0x19, 0x28, 0x44, 0xf2, 0x29, 0x82, 0x12, 0x24, 0x66,
+  0x90, 0x9c, 0x81, 0x42, 0x24, 0x68, 0xa0, 0x1c, 0x09, 0x94, 0xa4, 0x41,
+  0x22, 0x25, 0x6a, 0xc0, 0x84, 0x4e, 0x2e, 0xcc, 0x6d, 0xce, 0xec, 0x4d,
+  0xae, 0x6d, 0x08, 0x18, 0x28, 0x45, 0x42, 0x06, 0x49, 0x19, 0x28, 0x44,
+  0xf2, 0x29, 0x86, 0x12, 0x24, 0x66, 0x90, 0x9c, 0x81, 0x42, 0x24, 0x68,
+  0xa0, 0x1c, 0x09, 0x94, 0xa4, 0x41, 0x22, 0x25, 0x6c, 0x30, 0x44, 0x49,
+  0xc2, 0x20, 0x11, 0x83, 0x64, 0x0c, 0x92, 0x35, 0x48, 0xda, 0x60, 0x88,
+  0x81, 0x00, 0x49, 0x97, 0xb8, 0x01, 0x9f, 0xb7, 0x36, 0xb7, 0x34, 0xb8,
+  0x37, 0xba, 0x32, 0x37, 0x3a, 0x90, 0x31, 0xb4, 0x30, 0x39, 0x3e, 0x53,
+  0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x43, 0x2b, 0x2b, 0x20, 0x54, 0x42,
+  0x41, 0x41, 0x43, 0x84, 0x24, 0x0e, 0x86, 0x18, 0x09, 0x1c, 0x24, 0x72,
+  0xc0, 0x24, 0x43, 0x8c, 0x64, 0x0e, 0x92, 0x39, 0x60, 0x92, 0x11, 0x11,
+  0x3b, 0xb0, 0x83, 0x3d, 0xb4, 0x83, 0x1b, 0xb4, 0xc3, 0x3b, 0x90, 0x43,
+  0x3d, 0xb0, 0x43, 0x39, 0xb8, 0x81, 0x39, 0xb0, 0x43, 0x38, 0x9c, 0xc3,
+  0x3c, 0x4c, 0x11, 0x82, 0x61, 0x84, 0xc2, 0x0e, 0xec, 0x60, 0x0f, 0xed,
+  0xe0, 0x06, 0xe9, 0x40, 0x0e, 0xe5, 0xe0, 0x0e, 0xf4, 0x30, 0x25, 0x28,
+  0x46, 0x2c, 0xe1, 0x90, 0x0e, 0xf2, 0xe0, 0x06, 0xf6, 0x50, 0x0e, 0xf2,
+  0x30, 0x0f, 0xe9, 0xf0, 0x0e, 0xee, 0x30, 0x25, 0x30, 0x46, 0x50, 0xe1,
+  0x90, 0x0e, 0xf2, 0xe0, 0x06, 0xec, 0x10, 0x0e, 0xee, 0x70, 0x0e, 0xf5,
+  0x10, 0x0e, 0xe7, 0x50, 0x0e, 0xbf, 0x60, 0x0f, 0xe5, 0x20, 0x0f, 0xf3,
+  0x90, 0x0e, 0xef, 0xe0, 0x0e, 0x53, 0x02, 0x64, 0xc4, 0x14, 0x0e, 0xe9,
+  0x20, 0x0f, 0x6e, 0x30, 0x0e, 0xef, 0xd0, 0x0e, 0xf0, 0x90, 0x0e, 0xec,
+  0x50, 0x0e, 0xbf, 0xf0, 0x0e, 0xf0, 0x40, 0x0f, 0xe9, 0xf0, 0x0e, 0xee,
+  0x30, 0x0f, 0x53, 0x06, 0x85, 0x71, 0x46, 0x28, 0xe1, 0x90, 0x0e, 0xf2,
+  0xe0, 0x06, 0xf6, 0x50, 0x0e, 0xf2, 0x40, 0x0f, 0xe5, 0x80, 0x0f, 0x53,
+  0x82, 0x37, 0x00, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x7b, 0x00,
+  0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01,
+  0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78,
+  0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4,
+  0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c,
+  0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03,
+  0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70,
+  0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70,
+  0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec,
+  0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0,
+  0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d,
+  0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43,
+  0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0,
+  0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68,
+  0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28,
+  0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08,
+  0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee,
+  0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62,
+  0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c,
+  0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06,
+  0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43,
+  0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3,
+  0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3,
+  0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68,
+  0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce,
+  0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3,
+  0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d,
+  0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e,
+  0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51,
+  0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60,
+  0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98,
+  0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e,
+  0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e,
+  0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83,
+  0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2,
+  0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a,
+  0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28,
+  0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5,
+  0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17,
+  0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83,
+  0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3,
+  0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3,
+  0x3c, 0x00, 0x71, 0x20, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06, 0xf0,
+  0xb0, 0x5d, 0xf9, 0x73, 0xce, 0x83, 0xfd, 0x15, 0x11, 0x4d, 0xc4, 0x05,
+  0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x52, 0x00, 0x00, 0x00, 0x13, 0x04,
+  0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xe4, 0xc6,
+  0x22, 0x86, 0x61, 0x18, 0xc6, 0x22, 0x04, 0x41, 0x10, 0xc6, 0x22, 0x82,
+  0x20, 0x08, 0x88, 0x95, 0x40, 0x19, 0x14, 0x01, 0xb9, 0x11, 0x00, 0x1a,
+  0x33, 0x00, 0x24, 0x66, 0x00, 0x28, 0xcc, 0x00, 0x00, 0x00, 0xe3, 0x11,
+  0x4b, 0x74, 0x45, 0x14, 0x94, 0xf1, 0x08, 0x67, 0xca, 0x26, 0x0a, 0xca,
+  0x20, 0xc3, 0x50, 0x20, 0x26, 0x04, 0xf2, 0x19, 0x8f, 0x90, 0xae, 0xae,
+  0xa1, 0xa0, 0x0c, 0x32, 0x1c, 0x09, 0x64, 0x42, 0x20, 0x1f, 0x0b, 0x0a,
+  0xf8, 0x8c, 0x47, 0x5c, 0x9c, 0x18, 0x40, 0x14, 0x94, 0x41, 0x06, 0xc6,
+  0xb1, 0x4c, 0x08, 0xe4, 0x63, 0x45, 0x00, 0x9f, 0xf1, 0x08, 0x2e, 0x0c,
+  0xce, 0xc0, 0xa2, 0xa0, 0x0c, 0x32, 0x44, 0x13, 0x67, 0x42, 0x20, 0x1f,
+  0x2b, 0x02, 0xf8, 0x8c, 0x47, 0x80, 0x81, 0x19, 0xb0, 0x01, 0x47, 0x41,
+  0x19, 0x64, 0x08, 0xb0, 0xcd, 0x82, 0x4a, 0x3e, 0x83, 0x0c, 0x83, 0x16,
+  0x06, 0x16, 0x4c, 0xf2, 0xb1, 0x21, 0x80, 0xcf, 0x20, 0x83, 0xd1, 0x95,
+  0x81, 0x05, 0x91, 0x7c, 0x6c, 0x08, 0xe0, 0x33, 0xc8, 0x90, 0x80, 0x41,
+  0x1a, 0x58, 0xf0, 0xc8, 0xc7, 0x86, 0x00, 0x3e, 0xe3, 0x11, 0x6d, 0x30,
+  0x07, 0x79, 0x80, 0x06, 0x14, 0x94, 0x41, 0x86, 0xa0, 0x0c, 0xd0, 0xc0,
+  0x02, 0x31, 0x90, 0xcf, 0x20, 0xc3, 0x70, 0x06, 0x6e, 0x60, 0x01, 0x18,
+  0xc8, 0x67, 0x90, 0xa1, 0x48, 0x83, 0x38, 0xb0, 0xa0, 0x93, 0xcf, 0x20,
+  0xc3, 0xb1, 0x06, 0x74, 0x60, 0x81, 0x26, 0x9f, 0x41, 0x86, 0x3d, 0x70,
+  0x03, 0x38, 0xb0, 0x2c, 0x90, 0xcf, 0x20, 0x43, 0x1f, 0xc0, 0x81, 0x1d,
+  0x98, 0x13, 0xc8, 0xc7, 0x92, 0x01, 0x3e, 0x16, 0x30, 0xf0, 0xb1, 0x20,
+  0x81, 0x8f, 0x05, 0x08, 0x7c, 0x2c, 0x28, 0xe0, 0x33, 0xdb, 0x80, 0x07,
+  0x01, 0x30, 0xdb, 0x10, 0x90, 0x42, 0x30, 0xdb, 0x10, 0x90, 0x82, 0x90,
+  0x41, 0x40, 0x0c, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x5b, 0x86,
+  0x20, 0xa0, 0x83, 0x2d, 0xc3, 0x10, 0xd0, 0xc1, 0x96, 0xe1, 0x08, 0xe8,
+  0x60, 0xcb, 0xc0, 0x04, 0x74, 0xb0, 0x65, 0x88, 0x02, 0x3a, 0xd8, 0x32,
+  0x58, 0x01, 0x1d, 0x6c, 0x19, 0xc6, 0x20, 0xa0, 0x03, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00,
+  0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0xe0, 0x08, 0x00, 0x00, 0xff, 0xff,
+  0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0x35, 0x02,
+  0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00,
+  0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10,
+  0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04,
+  0x8b, 0x62, 0x80, 0x10, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0x84, 0x10,
+  0x32, 0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a,
+  0x90, 0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07,
+  0xc8, 0x08, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00,
+  0x00, 0x00, 0x51, 0x18, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00, 0x1b, 0xc8,
+  0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x00, 0x8a, 0x18, 0x87,
+  0x77, 0x90, 0x07, 0x79, 0x28, 0x87, 0x71, 0xa0, 0x07, 0x76, 0xc8, 0x87,
+  0x36, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x77, 0x20, 0x87, 0x72, 0x20, 0x87,
+  0x36, 0x20, 0x87, 0x74, 0xb0, 0x87, 0x74, 0x20, 0x87, 0x72, 0x68, 0x83,
+  0x79, 0x88, 0x07, 0x79, 0xa0, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83,
+  0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6,
+  0xa1, 0x1c, 0x00, 0x82, 0x1c, 0xd2, 0x61, 0x1e, 0xc2, 0x41, 0x1c, 0xd8,
+  0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xc2, 0x21, 0x1d, 0xd8, 0xa1, 0x0d, 0xc6,
+  0x21, 0x1c, 0xd8, 0x81, 0x1d, 0xe6, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87,
+  0x79, 0x28, 0x07, 0x80, 0x60, 0x87, 0x72, 0x98, 0x87, 0x79, 0x68, 0x03,
+  0x78, 0x90, 0x87, 0x72, 0x18, 0x87, 0x74, 0x98, 0x87, 0x72, 0x68, 0x03,
+  0x73, 0x80, 0x87, 0x76, 0x08, 0x07, 0x72, 0x00, 0xcc, 0x21, 0x1c, 0xd8,
+  0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4,
+  0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc,
+  0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda,
+  0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x06, 0x77, 0x78, 0x87,
+  0x36, 0x30, 0x07, 0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87,
+  0x77, 0x48, 0x07, 0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07,
+  0x76, 0x48, 0x87, 0x76, 0x68, 0x03, 0x77, 0x78, 0x07, 0x77, 0x68, 0x03,
+  0x76, 0x28, 0x87, 0x70, 0x30, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83,
+  0x74, 0x70, 0x07, 0x73, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83,
+  0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca,
+  0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x40, 0x1d, 0xea, 0xa1, 0x1d, 0xe0,
+  0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x1e, 0x00,
+  0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87,
+  0x36, 0x70, 0x87, 0x70, 0x70, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87,
+  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea,
+  0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xce,
+  0xc1, 0x1d, 0xca, 0x81, 0x1c, 0xda, 0x40, 0x1f, 0xca, 0x41, 0x1e, 0xde,
+  0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8,
+  0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87,
+  0x77, 0x68, 0x03, 0x7a, 0x90, 0x87, 0x70, 0x80, 0x07, 0x78, 0x48, 0x07,
+  0x77, 0x38, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8,
+  0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0x62, 0x1e, 0xe8, 0x21, 0x1c, 0xc6,
+  0x61, 0x1d, 0xda, 0x00, 0x1e, 0xe4, 0xe1, 0x1d, 0xe8, 0xa1, 0x1c, 0xc6,
+  0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0x40, 0x1c, 0xea, 0xc1, 0x1c, 0xcc,
+  0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xf4, 0xa1, 0x1c, 0x00,
+  0x3c, 0x00, 0x88, 0x7a, 0x70, 0x87, 0x79, 0x08, 0x07, 0x73, 0x28, 0x87,
+  0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07,
+  0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xea, 0x61, 0x1e, 0xca,
+  0xa1, 0x0d, 0xe6, 0xe1, 0x1d, 0xcc, 0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xd8,
+  0xe1, 0x1d, 0xc2, 0x81, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87,
+  0x72, 0x00, 0x36, 0x10, 0x82, 0x00, 0x58, 0x00, 0x00, 0x00, 0x49, 0x18,
+  0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x13, 0x84, 0x40, 0x00, 0x89, 0x20,
+  0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x32, 0x22, 0x08, 0x09, 0x20, 0x64,
+  0x85, 0x04, 0x13, 0x22, 0xa4, 0x84, 0x04, 0x13, 0x22, 0xe3, 0x84, 0xa1,
+  0x90, 0x14, 0x12, 0x4c, 0x88, 0x8c, 0x0b, 0x84, 0x84, 0x4c, 0x10, 0x24,
+  0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00, 0x65, 0x08, 0x09,
+  0x9a, 0x81, 0x80, 0x39, 0x02, 0x30, 0x48, 0x01, 0x1b, 0x01, 0x00, 0x00,
+  0x00, 0x00, 0x13, 0xa8, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68,
+  0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78,
+  0x87, 0x79, 0xc8, 0x03, 0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7,
+  0x51, 0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a,
+  0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78,
+  0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71,
+  0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72,
+  0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9,
+  0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74,
+  0xd0, 0x06, 0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a,
+  0x30, 0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76,
+  0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6,
+  0x20, 0x07, 0x74, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72,
+  0xd0, 0x06, 0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a,
+  0x30, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6,
+  0x90, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71,
+  0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a,
+  0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d,
+  0x60, 0x0f, 0x71, 0x90, 0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76,
+  0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75,
+  0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75,
+  0x60, 0x07, 0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75,
+  0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6,
+  0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72,
+  0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee,
+  0x80, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43,
+  0x18, 0x02, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x2c, 0x10,
+  0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x0c, 0x19, 0x11,
+  0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0xb2, 0x12, 0x18,
+  0x01, 0x28, 0x82, 0x42, 0x28, 0x08, 0xba, 0xb1, 0x04, 0x67, 0x00, 0x00,
+  0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x99, 0x00, 0x00, 0x00, 0x1a, 0x03,
+  0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4,
+  0x37, 0xb7, 0x21, 0x86, 0x31, 0x14, 0xc0, 0x61, 0x50, 0xb9, 0x1b, 0x43,
+  0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b, 0x62, 0x18, 0x41, 0x21,
+  0x18, 0x04, 0xe1, 0x20, 0x08, 0x0e, 0x8e, 0xad, 0x0c, 0x84, 0x89, 0xc9,
+  0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x26,
+  0x06, 0x06, 0x26, 0xc6, 0xa5, 0x06, 0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e,
+  0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26, 0x06, 0x06, 0x26, 0xc6, 0xa5, 0x06,
+  0xc6, 0x25, 0x26, 0x65, 0x88, 0x50, 0x10, 0x43, 0x0c, 0x23, 0x30, 0x0a,
   0x43, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36, 0x04, 0x29, 0x0e, 0x23,
   0x30, 0x02, 0x43, 0xe0, 0x16, 0x96, 0x26, 0xe7, 0x32, 0xf6, 0xd6, 0x06,
   0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6, 0x26, 0xd7, 0x36, 0xf7,
@@ -696,254 +713,1030 @@ const unsigned char sdl_metallib[] = {
   0x17, 0x5d, 0x98, 0xdc, 0x59, 0x19, 0x1d, 0xa3, 0xb0, 0x34, 0x39, 0x97,
   0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0x2f, 0xb7, 0xb0, 0xb6,
   0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x43, 0x90, 0xe2, 0x31,
-  0x84, 0x02, 0x2a, 0xa2, 0x21, 0x42, 0x21, 0x51, 0x09, 0x4b, 0x93, 0x73,
-  0x11, 0xab, 0x33, 0x33, 0x2b, 0x93, 0xe3, 0x13, 0x96, 0x26, 0xe7, 0x22,
-  0x56, 0x67, 0x66, 0x56, 0x26, 0xf7, 0x35, 0x97, 0xa6, 0x57, 0x46, 0x29,
-  0x2c, 0x4d, 0xce, 0x85, 0xed, 0x6d, 0x2c, 0x8c, 0x2e, 0xed, 0xcd, 0xed,
-  0x2b, 0xcd, 0x8d, 0xac, 0x0c, 0x8f, 0x48, 0x58, 0x9a, 0x9c, 0x8b, 0x5c,
-  0x59, 0x18, 0x19, 0xa3, 0xb0, 0x34, 0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f,
-  0xba, 0x3c, 0xb8, 0xb2, 0xaf, 0xb9, 0x34, 0xbd, 0x32, 0x5e, 0x61, 0x69,
-  0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x61,
-  0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x64, 0xc2, 0xd2,
-  0xe4, 0x5c, 0xc2, 0xe4, 0xce, 0xbe, 0xdc, 0xc2, 0xda, 0xca, 0x38, 0x8c,
-  0xbd, 0xb1, 0x0d, 0x01, 0x03, 0x43, 0x28, 0xa8, 0xa2, 0x32, 0x86, 0xc2,
-  0x32, 0x04, 0x23, 0x28, 0xae, 0x02, 0x33, 0x86, 0x22, 0x33, 0x86, 0x02,
-  0x2a, 0xa2, 0x42, 0x2b, 0xb6, 0x21, 0x42, 0xc1, 0x0d, 0x31, 0x08, 0xa0,
-  0x98, 0x8a, 0x8e, 0xcf, 0x5b, 0x9b, 0x5b, 0x1a, 0xdc, 0x1b, 0x5d, 0x99,
-  0x1b, 0x1d, 0xc8, 0x18, 0x5a, 0x98, 0x1c, 0x9f, 0xa9, 0xb4, 0x36, 0x38,
-  0xb6, 0x32, 0x90, 0xa1, 0x95, 0x15, 0x10, 0x2a, 0xa1, 0xa0, 0xa0, 0x21,
-  0x42, 0x01, 0x06, 0x43, 0x8c, 0xe2, 0x2b, 0xc2, 0x00, 0x39, 0x86, 0x18,
-  0x85, 0x18, 0x14, 0x62, 0x80, 0x1c, 0x23, 0x22, 0x76, 0x60, 0x07, 0x7b,
-  0x68, 0x07, 0x37, 0x68, 0x87, 0x77, 0x20, 0x87, 0x7a, 0x60, 0x87, 0x72,
-  0x70, 0x03, 0x73, 0x60, 0x87, 0x70, 0x38, 0x87, 0x79, 0x98, 0x22, 0x04,
-  0xc3, 0x08, 0x85, 0x1d, 0xd8, 0xc1, 0x1e, 0xda, 0xc1, 0x0d, 0xd2, 0x81,
-  0x1c, 0xca, 0xc1, 0x1d, 0xe8, 0x61, 0x4a, 0x50, 0x8c, 0x58, 0xc2, 0x21,
-  0x1d, 0xe4, 0xc1, 0x0d, 0xec, 0xa1, 0x1c, 0xe4, 0x61, 0x1e, 0xd2, 0xe1,
-  0x1d, 0xdc, 0x61, 0x4a, 0x60, 0x8c, 0xa0, 0xc2, 0x21, 0x1d, 0xe4, 0xc1,
-  0x0d, 0xd8, 0x21, 0x1c, 0xdc, 0xe1, 0x1c, 0xea, 0x21, 0x1c, 0xce, 0xa1,
-  0x1c, 0x7e, 0xc1, 0x1e, 0xca, 0x41, 0x1e, 0xe6, 0x21, 0x1d, 0xde, 0xc1,
-  0x1d, 0xa6, 0x04, 0xc8, 0x88, 0x29, 0x1c, 0xd2, 0x41, 0x1e, 0xdc, 0x60,
-  0x1c, 0xde, 0xa1, 0x1d, 0xe0, 0x21, 0x1d, 0xd8, 0xa1, 0x1c, 0x7e, 0xe1,
-  0x1d, 0xe0, 0x81, 0x1e, 0xd2, 0xe1, 0x1d, 0xdc, 0x61, 0x1e, 0xa6, 0x0c,
-  0x0a, 0xe3, 0x8c, 0x60, 0xc2, 0x21, 0x1d, 0xe4, 0xc1, 0x0d, 0xcc, 0x41,
-  0x1e, 0xc2, 0xe1, 0x1c, 0xda, 0xa1, 0x1c, 0xdc, 0x81, 0x1e, 0xa6, 0x04,
-  0x1e, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00,
-  0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88,
-  0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73,
-  0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e,
-  0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30,
-  0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8,
-  0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b,
-  0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76,
-  0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e,
-  0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e,
-  0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61,
-  0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4,
-  0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76,
-  0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37,
-  0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76,
-  0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71,
-  0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e,
-  0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1,
-  0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61,
-  0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90,
-  0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8,
-  0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc,
-  0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7,
-  0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78,
-  0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f,
-  0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f,
-  0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1,
-  0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0,
-  0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0,
-  0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b,
-  0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c,
-  0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61,
-  0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1,
-  0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc,
-  0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4,
-  0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79,
-  0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72,
-  0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e,
-  0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1,
-  0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8,
-  0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8,
-  0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00,
-  0x71, 0x20, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x06, 0x20, 0xb1, 0x5d,
-  0xf9, 0xb3, 0xce, 0x82, 0x0c, 0x7f, 0x11, 0x01, 0x06, 0x43, 0x34, 0x13,
-  0x00, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
-  0x13, 0x04, 0x01, 0x05, 0x25, 0x83, 0x80, 0x18, 0x02, 0x00, 0x00, 0x00,
-  0x5b, 0x06, 0x20, 0x18, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x84, 0x02, 0x2a, 0xa2, 0x21, 0x42, 0x21, 0x51, 0x0a, 0x4b, 0x93, 0x73,
+  0x31, 0x93, 0x0b, 0x3b, 0x6b, 0x2b, 0x73, 0xa3, 0xfb, 0x4a, 0x73, 0x83,
+  0xab, 0xa3, 0x63, 0x76, 0x56, 0xe6, 0x56, 0x26, 0x17, 0x46, 0x57, 0x46,
+  0x86, 0x82, 0x03, 0xf7, 0x36, 0x97, 0x46, 0x97, 0xf6, 0xe6, 0x46, 0x64,
+  0x27, 0xf3, 0x65, 0x96, 0x42, 0x25, 0x2c, 0x4d, 0xce, 0x65, 0xac, 0xcc,
+  0x8d, 0xae, 0x4c, 0x8e, 0x4f, 0x58, 0x9a, 0x9c, 0x0b, 0x5c, 0x99, 0xdc,
+  0x1c, 0x5c, 0xd9, 0x18, 0x5d, 0x9a, 0x5d, 0x19, 0x0d, 0x33, 0xb6, 0xb7,
+  0x30, 0x3a, 0x19, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f,
+  0x6e, 0x61, 0x6d, 0x65, 0x44, 0xe0, 0xde, 0xe6, 0xd2, 0xe8, 0xd2, 0xde,
+  0xdc, 0x86, 0x48, 0x86, 0x50, 0x50, 0x45, 0x55, 0x58, 0xc5, 0x55, 0x40,
+  0x05, 0x56, 0x64, 0x85, 0x46, 0xeb, 0xac, 0xcc, 0xad, 0x4c, 0x2e, 0x8c,
+  0xae, 0x8c, 0x0c, 0xa5, 0x66, 0xec, 0x8d, 0xed, 0x4d, 0x8e, 0xc8, 0x8e,
+  0xe6, 0xcb, 0x2c, 0x85, 0xc5, 0xd8, 0x1b, 0xdb, 0x9b, 0xdc, 0x10, 0xc9,
+  0x08, 0x0a, 0xaa, 0xe0, 0x0a, 0xab, 0xb8, 0x0a, 0xa8, 0x88, 0x8a, 0xac,
+  0xe8, 0x86, 0x10, 0xc5, 0x56, 0x78, 0x43, 0x0c, 0x02, 0x28, 0xa6, 0xe2,
+  0x1b, 0x11, 0xb1, 0x03, 0x3b, 0xd8, 0x43, 0x3b, 0xb8, 0x41, 0x3b, 0xbc,
+  0x03, 0x39, 0xd4, 0x03, 0x3b, 0x94, 0x83, 0x1b, 0x98, 0x03, 0x3b, 0x84,
+  0xc3, 0x39, 0xcc, 0xc3, 0x14, 0x21, 0x18, 0x46, 0x28, 0xec, 0xc0, 0x0e,
+  0xf6, 0xd0, 0x0e, 0x6e, 0x90, 0x0e, 0xe4, 0x50, 0x0e, 0xee, 0x40, 0x0f,
+  0x53, 0x82, 0x62, 0xc4, 0x12, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0x60, 0x0f,
+  0xe5, 0x20, 0x0f, 0xf3, 0x90, 0x0e, 0xef, 0xe0, 0x0e, 0x53, 0x02, 0x63,
+  0x04, 0x15, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0xc0, 0x0e, 0xe1, 0xe0, 0x0e,
+  0xe7, 0x50, 0x0f, 0xe1, 0x70, 0x0e, 0xe5, 0xf0, 0x0b, 0xf6, 0x50, 0x0e,
+  0xf2, 0x30, 0x0f, 0xe9, 0xf0, 0x0e, 0xee, 0x30, 0x25, 0x40, 0x46, 0x4c,
+  0xe1, 0x90, 0x0e, 0xf2, 0xe0, 0x06, 0xe3, 0xf0, 0x0e, 0xed, 0x00, 0x0f,
+  0xe9, 0xc0, 0x0e, 0xe5, 0xf0, 0x0b, 0xef, 0x00, 0x0f, 0xf4, 0x90, 0x0e,
+  0xef, 0xe0, 0x0e, 0xf3, 0x30, 0x65, 0x50, 0x18, 0x67, 0x04, 0x13, 0x0e,
+  0xe9, 0x20, 0x0f, 0x6e, 0x60, 0x0e, 0xf2, 0x10, 0x0e, 0xe7, 0xd0, 0x0e,
+  0xe5, 0xe0, 0x0e, 0xf4, 0x30, 0x25, 0x00, 0x03, 0x00, 0x00, 0x79, 0x18,
+  0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1,
+  0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42,
+  0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f,
+  0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1,
+  0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84,
+  0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc,
+  0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70,
+  0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19,
+  0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f,
+  0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21,
+  0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc,
+  0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84,
+  0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37,
+  0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70,
+  0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77,
+  0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79,
+  0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e,
+  0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1,
+  0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81,
+  0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98,
+  0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88,
+  0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4,
+  0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72,
+  0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74,
+  0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e,
+  0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e,
+  0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21,
+  0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01,
+  0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc,
+  0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77,
+  0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e,
+  0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1,
+  0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61,
+  0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0,
+  0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0,
+  0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74,
+  0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e,
+  0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41,
+  0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50,
+  0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c,
+  0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc,
+  0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20, 0x00, 0x00, 0x05, 0x00,
+  0x00, 0x00, 0x06, 0x20, 0xb1, 0x5d, 0xf9, 0xb3, 0xce, 0x82, 0x0c, 0x7f,
+  0x11, 0x01, 0x06, 0x43, 0x34, 0x13, 0x00, 0x00, 0x00, 0x00, 0x61, 0x20,
+  0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x06, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
-  0xe4, 0x0a, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde,
-  0x21, 0x0c, 0x00, 0x00, 0xb6, 0x02, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00,
-  0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91,
-  0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c,
-  0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02,
-  0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x49,
-  0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52, 0x80,
-  0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8, 0x48, 0x11, 0x62, 0xa8, 0xa0,
-  0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00, 0x00,
-  0x8b, 0x00, 0x00, 0x00, 0x1b, 0xcc, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff,
-  0x01, 0x60, 0x00, 0x09, 0xa8, 0x88, 0x71, 0x78, 0x07, 0x79, 0x90, 0x87,
-  0x72, 0x18, 0x07, 0x7a, 0x60, 0x87, 0x7c, 0x68, 0x03, 0x79, 0x78, 0x87,
-  0x7a, 0x70, 0x07, 0x72, 0x28, 0x07, 0x72, 0x68, 0x03, 0x72, 0x48, 0x07,
-  0x7b, 0x48, 0x07, 0x72, 0x28, 0x87, 0x36, 0x98, 0x87, 0x78, 0x90, 0x07,
-  0x7a, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07,
-  0x74, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xc8,
-  0x21, 0x1d, 0xe6, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0xa1, 0x0d, 0xe8,
-  0x21, 0x1c, 0xd2, 0x81, 0x1d, 0xda, 0x60, 0x1c, 0xc2, 0x81, 0x1d, 0xd8,
-  0x61, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08,
-  0x76, 0x28, 0x87, 0x79, 0x98, 0x87, 0x36, 0x80, 0x07, 0x79, 0x28, 0x87,
-  0x71, 0x48, 0x87, 0x79, 0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x87,
-  0x70, 0x20, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00,
-  0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xcc, 0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca,
-  0xa1, 0x0d, 0xe0, 0xe1, 0x1d, 0xd2, 0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4,
-  0xa1, 0x0d, 0xca, 0x81, 0x1d, 0xd2, 0xa1, 0x1d, 0x00, 0x7a, 0x90, 0x87,
-  0x7a, 0x28, 0x07, 0x60, 0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90, 0x87,
-  0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70, 0x07,
-  0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68, 0x87,
-  0x36, 0x70, 0x87, 0x77, 0x70, 0x87, 0x36, 0x60, 0x87, 0x72, 0x08, 0x07,
-  0x73, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x48, 0x07, 0x77, 0x30, 0x87,
-  0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07,
-  0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde,
-  0xa1, 0x0d, 0xd4, 0xa1, 0x1e, 0xda, 0x01, 0x1e, 0xda, 0x80, 0x1e, 0xc2,
-  0x41, 0x1c, 0xd8, 0xa1, 0x1c, 0xe6, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87,
-  0x79, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x77, 0x08, 0x07,
-  0x77, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07,
-  0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc,
-  0xe1, 0x1d, 0xda, 0x60, 0x1e, 0xd2, 0xe1, 0x1c, 0xdc, 0xa1, 0x1c, 0xc8,
-  0xa1, 0x0d, 0xf4, 0xa1, 0x1c, 0xe4, 0xe1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc,
-  0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07,
-  0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0xa0, 0x07,
-  0x79, 0x08, 0x07, 0x78, 0x80, 0x87, 0x74, 0x70, 0x87, 0x73, 0x68, 0x83,
-  0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca,
-  0x01, 0x20, 0xe6, 0x81, 0x1e, 0xc2, 0x61, 0x1c, 0xd6, 0xa1, 0x0d, 0xe0,
-  0x41, 0x1e, 0xde, 0x81, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4,
-  0xa1, 0x0d, 0xc4, 0xa1, 0x1e, 0xcc, 0xc1, 0x1c, 0xca, 0x41, 0x1e, 0xda,
-  0x60, 0x1e, 0xd2, 0x41, 0x1f, 0xca, 0x01, 0xc0, 0x03, 0x80, 0xa8, 0x07,
-  0x77, 0x98, 0x87, 0x70, 0x30, 0x87, 0x72, 0x68, 0x03, 0x73, 0x80, 0x87,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00,
+  0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x44, 0x0a, 0x00, 0x00, 0xff, 0xff,
+  0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0x8e, 0x02,
+  0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00,
+  0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10,
+  0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04,
+  0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10,
+  0x32, 0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a,
+  0x90, 0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07,
+  0xc8, 0x48, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00,
+  0x00, 0x00, 0x51, 0x18, 0x00, 0x00, 0x89, 0x00, 0x00, 0x00, 0x1b, 0xcc,
+  0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x60, 0x00, 0x09, 0xa8, 0x88,
+  0x71, 0x78, 0x07, 0x79, 0x90, 0x87, 0x72, 0x18, 0x07, 0x7a, 0x60, 0x87,
+  0x7c, 0x68, 0x03, 0x79, 0x78, 0x87, 0x7a, 0x70, 0x07, 0x72, 0x28, 0x07,
+  0x72, 0x68, 0x03, 0x72, 0x48, 0x07, 0x7b, 0x48, 0x07, 0x72, 0x28, 0x87,
+  0x36, 0x98, 0x87, 0x78, 0x90, 0x07, 0x7a, 0x68, 0x03, 0x73, 0x80, 0x87,
+  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xcc, 0x21, 0x1c, 0xd8,
+  0x61, 0x1e, 0xca, 0x01, 0x20, 0xc8, 0x21, 0x1d, 0xe6, 0x21, 0x1c, 0xc4,
+  0x81, 0x1d, 0xca, 0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xd2, 0x81, 0x1d, 0xda,
+  0x60, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0x61, 0x1e, 0x00, 0x73, 0x08, 0x07,
+  0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x76, 0x28, 0x87, 0x79, 0x98, 0x87,
+  0x36, 0x80, 0x07, 0x79, 0x28, 0x87, 0x71, 0x48, 0x87, 0x79, 0x28, 0x87,
+  0x36, 0x30, 0x07, 0x78, 0x68, 0x87, 0x70, 0x20, 0x07, 0xc0, 0x1c, 0xc2,
+  0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xcc,
+  0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca, 0xa1, 0x0d, 0xe0, 0xe1, 0x1d, 0xd2,
+  0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xca, 0x81, 0x1d, 0xd2,
+  0xa1, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x60, 0x70, 0x87,
+  0x77, 0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03,
+  0x78, 0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83,
+  0x72, 0x60, 0x87, 0x74, 0x68, 0x87, 0x36, 0x70, 0x87, 0x77, 0x70, 0x87,
+  0x36, 0x60, 0x87, 0x72, 0x08, 0x07, 0x73, 0x00, 0x08, 0x77, 0x78, 0x87,
+  0x36, 0x48, 0x07, 0x77, 0x30, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87,
   0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea,
-  0xa1, 0x1c, 0x00, 0xa2, 0x1e, 0xe6, 0xa1, 0x1c, 0xda, 0x60, 0x1e, 0xde,
-  0xc1, 0x1c, 0xe8, 0xa1, 0x0d, 0xcc, 0x81, 0x1d, 0xde, 0x21, 0x1c, 0xe8,
-  0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x60, 0x03, 0x22,
-  0x0c, 0x40, 0x02, 0x2c, 0x40, 0xb5, 0xc1, 0x18, 0x08, 0x60, 0x01, 0xaa,
-  0x0d, 0x06, 0x51, 0x00, 0x0b, 0x50, 0x6d, 0x40, 0x8a, 0xff, 0xff, 0xff,
-  0xff, 0x1f, 0x00, 0x06, 0x90, 0x80, 0x6a, 0x83, 0x61, 0x04, 0xc0, 0x02,
-  0x54, 0x1b, 0x8c, 0x43, 0x00, 0x16, 0xa0, 0x02, 0x49, 0x18, 0x00, 0x00,
-  0x03, 0x00, 0x00, 0x00, 0x13, 0x88, 0x40, 0x18, 0x88, 0x09, 0x43, 0x61,
-  0x1c, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
-  0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84,
-  0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c,
-  0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x4c, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30,
-  0x8c, 0x20, 0x00, 0x83, 0x08, 0x41, 0x70, 0x94, 0x34, 0x45, 0x94, 0x30,
-  0xf9, 0xff, 0x44, 0x5c, 0x13, 0x15, 0x11, 0xbf, 0x3d, 0xfc, 0xd3, 0x18,
-  0x01, 0x30, 0x88, 0x40, 0x04, 0x17, 0x49, 0x53, 0x44, 0x09, 0x93, 0xff,
-  0x4b, 0x00, 0xf3, 0x2c, 0x44, 0xf4, 0x4f, 0x63, 0x04, 0xc0, 0x20, 0x82,
-  0x21, 0x14, 0x23, 0x04, 0x31, 0xca, 0x21, 0x34, 0x47, 0x10, 0xcc, 0x11,
-  0x80, 0xc1, 0x30, 0x82, 0xb0, 0x14, 0x24, 0x94, 0x23, 0x14, 0x53, 0x80,
-  0xda, 0x40, 0x40, 0x0a, 0xac, 0x39, 0x02, 0x50, 0x18, 0x01, 0x00, 0x00,
-  0x13, 0xa8, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70,
-  0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87, 0x79,
-  0xc8, 0x03, 0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7, 0x51, 0x0e,
-  0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a, 0x80, 0x07,
-  0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78, 0xa0, 0x07,
-  0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07,
-  0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07,
-  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x60, 0x07,
-  0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06,
-  0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
-  0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76, 0xa0, 0x07,
-  0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07,
-  0x74, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06,
-  0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
-  0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74, 0xa0, 0x07,
-  0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x90, 0x07,
-  0x76, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07,
-  0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07,
-  0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f,
-  0x71, 0x90, 0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07,
-  0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75, 0x60, 0x07,
-  0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07,
-  0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07,
-  0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x10, 0x07,
-  0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07,
-  0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee, 0x80, 0x07,
-  0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43, 0x98, 0x04,
-  0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x21, 0x8c, 0x03, 0x04,
-  0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x16, 0x08, 0x00, 0x00, 0x00,
-  0x09, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90,
-  0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x5a, 0x25, 0x30, 0x02, 0x50,
-  0x20, 0x45, 0x50, 0x08, 0x05, 0x51, 0x06, 0x14, 0x47, 0x00, 0x08, 0x8e,
-  0x25, 0x38, 0x02, 0x00, 0x79, 0x18, 0x00, 0x00, 0xe8, 0x00, 0x00, 0x00,
-  0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9,
-  0xb9, 0xb4, 0x37, 0xb7, 0x21, 0xc6, 0x52, 0x3c, 0x00, 0xa4, 0x50, 0xb9,
-  0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b, 0x62, 0x2c,
-  0xc2, 0x23, 0x2c, 0x06, 0xdd, 0x20, 0x08, 0x0e, 0x8e, 0xad, 0x0c, 0x84,
-  0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x0d,
-  0x64, 0x26, 0x06, 0x06, 0x26, 0xc6, 0x85, 0x66, 0x06, 0x04, 0xa5, 0xad,
-  0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26, 0x06, 0x06, 0x26, 0xc6,
-  0x85, 0x66, 0x26, 0x65, 0x88, 0xf0, 0x10, 0x43, 0x8c, 0x45, 0x58, 0x8e,
-  0x65, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36, 0x04, 0x79, 0x8e, 0x45,
-  0x58, 0x84, 0x65, 0xe0, 0x16, 0x96, 0x26, 0xe7, 0x32, 0xf6, 0xd6, 0x06,
+  0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xd4, 0xa1, 0x1e, 0xda,
+  0x01, 0x1e, 0xda, 0x80, 0x1e, 0xc2, 0x41, 0x1c, 0xd8, 0xa1, 0x1c, 0xe6,
+  0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x70, 0x87,
+  0x77, 0x68, 0x03, 0x77, 0x08, 0x07, 0x77, 0x98, 0x87, 0x36, 0x30, 0x07,
+  0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4,
+  0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x60, 0x1e, 0xd2,
+  0xe1, 0x1c, 0xdc, 0xa1, 0x1c, 0xc8, 0xa1, 0x0d, 0xf4, 0xa1, 0x1c, 0xe4,
+  0xe1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2,
+  0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08,
+  0x77, 0x78, 0x87, 0x36, 0xa0, 0x07, 0x79, 0x08, 0x07, 0x78, 0x80, 0x87,
+  0x74, 0x70, 0x87, 0x73, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07,
+  0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xe6, 0x81, 0x1e, 0xc2,
+  0x61, 0x1c, 0xd6, 0xa1, 0x0d, 0xe0, 0x41, 0x1e, 0xde, 0x81, 0x1e, 0xca,
+  0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0xa1, 0x0d, 0xc4, 0xa1, 0x1e, 0xcc,
+  0xc1, 0x1c, 0xca, 0x41, 0x1e, 0xda, 0x60, 0x1e, 0xd2, 0x41, 0x1f, 0xca,
+  0x01, 0xc0, 0x03, 0x80, 0xa8, 0x07, 0x77, 0x98, 0x87, 0x70, 0x30, 0x87,
+  0x72, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07,
+  0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xa2, 0x1e, 0xe6,
+  0xa1, 0x1c, 0xda, 0x60, 0x1e, 0xde, 0xc1, 0x1c, 0xe8, 0xa1, 0x0d, 0xcc,
+  0x81, 0x1d, 0xde, 0x21, 0x1c, 0xe8, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87,
+  0x79, 0x28, 0x07, 0x60, 0x83, 0x21, 0x10, 0xc0, 0x02, 0x54, 0x1b, 0x8c,
+  0xa1, 0x00, 0x16, 0xa0, 0xda, 0x80, 0x10, 0xff, 0xff, 0xff, 0xff, 0x3f,
+  0x00, 0x0c, 0x20, 0x01, 0xd5, 0x06, 0xa3, 0x08, 0x80, 0x05, 0xa8, 0x36,
+  0x18, 0x86, 0x00, 0x2c, 0x40, 0x05, 0x49, 0x18, 0x00, 0x00, 0x03, 0x00,
+  0x00, 0x00, 0x13, 0x86, 0x40, 0x18, 0x26, 0x0c, 0x44, 0x61, 0x00, 0x00,
+  0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x32, 0x22,
+  0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93,
+  0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84,
+  0xa4, 0x4c, 0x10, 0x44, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20,
+  0x00, 0x47, 0x49, 0x53, 0x44, 0x09, 0x93, 0xff, 0x4f, 0xc4, 0x35, 0x51,
+  0x11, 0xf1, 0xdb, 0xc3, 0x3f, 0x8d, 0x11, 0x00, 0x83, 0x08, 0x43, 0x70,
+  0x91, 0x34, 0x45, 0x94, 0x30, 0xf9, 0xbf, 0x04, 0x30, 0xcf, 0x42, 0x44,
+  0xff, 0x34, 0x46, 0x00, 0x0c, 0x22, 0x14, 0x42, 0x31, 0x42, 0x08, 0x82,
+  0x18, 0x3a, 0x73, 0x04, 0xc1, 0x1c, 0x01, 0x18, 0x0c, 0x23, 0x08, 0x4a,
+  0x41, 0x02, 0x31, 0x22, 0xad, 0x04, 0x88, 0x0d, 0x04, 0xa4, 0x80, 0x1a,
+  0x01, 0x00, 0x13, 0xa8, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68,
+  0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78,
+  0x87, 0x79, 0xc8, 0x03, 0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7,
+  0x51, 0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a,
+  0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78,
+  0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71,
+  0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72,
+  0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9,
+  0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74,
+  0xd0, 0x06, 0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a,
+  0x30, 0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76,
+  0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6,
+  0x20, 0x07, 0x74, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72,
+  0xd0, 0x06, 0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a,
+  0x30, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6,
+  0x90, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71,
+  0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a,
+  0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d,
+  0x60, 0x0f, 0x71, 0x90, 0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76,
+  0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75,
+  0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75,
+  0x60, 0x07, 0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75,
+  0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6,
+  0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72,
+  0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee,
+  0x80, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43,
+  0x18, 0x04, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x21, 0x4c,
+  0x03, 0x04, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x16, 0x08, 0x00,
+  0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11,
+  0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x52, 0x25, 0x30,
+  0x02, 0x50, 0x04, 0x85, 0x50, 0x10, 0x65, 0x40, 0x6f, 0x2c, 0xc1, 0x19,
+  0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0xca, 0x00, 0x00, 0x00, 0x1a, 0x03,
+  0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4,
+  0x37, 0xb7, 0x21, 0x86, 0x42, 0x38, 0xc0, 0x83, 0x50, 0xb9, 0x1b, 0x43,
+  0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b, 0x62, 0x28, 0x82, 0x23,
+  0x28, 0x05, 0xe1, 0x20, 0x08, 0x0e, 0x8e, 0xad, 0x0c, 0x84, 0x89, 0xc9,
+  0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x26,
+  0x06, 0x06, 0x26, 0xc6, 0xa5, 0x06, 0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e,
+  0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26, 0x06, 0x06, 0x26, 0xc6, 0xa5, 0x06,
+  0xc6, 0x25, 0x26, 0x65, 0x88, 0xe0, 0x10, 0x43, 0x0c, 0x45, 0x50, 0x0c,
+  0x65, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36, 0x04, 0x71, 0x0e, 0x45,
+  0x50, 0x04, 0x65, 0xe0, 0x16, 0x96, 0x26, 0xe7, 0x32, 0xf6, 0xd6, 0x06,
   0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6, 0x26, 0xd7, 0x36, 0xf7,
-  0x45, 0x96, 0x36, 0x17, 0x26, 0xc6, 0x56, 0x36, 0x44, 0x78, 0x12, 0x72,
+  0x45, 0x96, 0x36, 0x17, 0x26, 0xc6, 0x56, 0x36, 0x44, 0x70, 0x12, 0x72,
   0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e,
   0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e,
-  0x61, 0x62, 0x6c, 0x65, 0x43, 0x84, 0x67, 0x21, 0x19, 0x84, 0xa5, 0xc9,
+  0x61, 0x62, 0x6c, 0x65, 0x43, 0x04, 0x67, 0x21, 0x19, 0x84, 0xa5, 0xc9,
   0xb9, 0x8c, 0xbd, 0xb5, 0xc1, 0xa5, 0xb1, 0x95, 0xb9, 0x98, 0xc9, 0x85,
   0xb5, 0x95, 0x89, 0xd5, 0x99, 0x99, 0x95, 0xc9, 0x7d, 0x99, 0x95, 0xd1,
-  0x8d, 0xa1, 0x7d, 0x95, 0xb9, 0x85, 0x89, 0xb1, 0x95, 0x0d, 0x11, 0x9e,
+  0x8d, 0xa1, 0x7d, 0x95, 0xb9, 0x85, 0x89, 0xb1, 0x95, 0x0d, 0x11, 0x9c,
   0x86, 0x51, 0x58, 0x9a, 0x9c, 0x8b, 0x5c, 0x99, 0x1b, 0x59, 0x99, 0xdc,
   0x17, 0x5d, 0x98, 0xdc, 0x59, 0x19, 0x1d, 0xa3, 0xb0, 0x34, 0x39, 0x97,
   0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0x2f, 0xb7, 0xb0, 0xb6,
-  0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x43, 0x90, 0xe7, 0x59,
-  0x86, 0x07, 0x7a, 0xa2, 0x21, 0xc2, 0x23, 0x91, 0x09, 0x4b, 0x93, 0x73,
+  0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x43, 0x10, 0xe7, 0x51,
+  0x06, 0x07, 0x72, 0xa2, 0x21, 0x82, 0x23, 0x91, 0x09, 0x4b, 0x93, 0x73,
   0x81, 0x7b, 0x9b, 0x4b, 0xa3, 0x4b, 0x7b, 0x73, 0xa3, 0x12, 0x96, 0x26,
   0xe7, 0x32, 0x56, 0xe6, 0x46, 0x57, 0x26, 0x47, 0x29, 0x2c, 0x4d, 0xce,
   0xc5, 0xed, 0xed, 0x0b, 0xae, 0x4c, 0x6e, 0x0e, 0xae, 0x6c, 0x8c, 0x2e,
   0xcd, 0xae, 0x8c, 0x4c, 0x58, 0x9a, 0x9c, 0x4b, 0x98, 0xdc, 0xd9, 0x97,
   0x5b, 0x58, 0x5b, 0x19, 0x11, 0xb8, 0xb7, 0xb9, 0x34, 0xba, 0xb4, 0x37,
-  0xb7, 0x21, 0xd0, 0x32, 0x3c, 0xd4, 0x53, 0x3d, 0xd6, 0x03, 0x3d, 0xd1,
-  0x73, 0x3d, 0x18, 0xa5, 0xb0, 0x34, 0x39, 0x17, 0x33, 0xb9, 0xb0, 0xb3,
-  0xb6, 0x32, 0x37, 0xba, 0xaf, 0x34, 0x37, 0xb8, 0x3a, 0x3a, 0x66, 0x67,
-  0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x38, 0x74, 0x65,
-  0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x44, 0x76, 0x32, 0x5f, 0x66, 0x29,
-  0x7c, 0xc2, 0xd2, 0xe4, 0x5c, 0xe0, 0xca, 0xe4, 0xe6, 0xe0, 0xca, 0xc6,
-  0xe8, 0xd2, 0xec, 0xca, 0x68, 0x98, 0xb1, 0xbd, 0x85, 0xd1, 0xc9, 0x10,
-  0xa1, 0x2b, 0xc3, 0x1b, 0x7b, 0x7b, 0x93, 0x23, 0x1b, 0x22, 0x2d, 0xc2,
-  0xa3, 0x3d, 0xdb, 0x53, 0x3d, 0xdc, 0x03, 0x3d, 0xdd, 0x73, 0x3d, 0x1e,
-  0x95, 0xb0, 0x34, 0x39, 0x17, 0xb1, 0x3a, 0x33, 0xb3, 0x32, 0x39, 0x3e,
-  0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73,
-  0x69, 0x7a, 0x65, 0x94, 0xc2, 0xd2, 0xe4, 0x5c, 0xd8, 0xde, 0xc6, 0xc2,
-  0xe8, 0xd2, 0xde, 0xdc, 0xbe, 0xd2, 0xdc, 0xc8, 0xca, 0xf0, 0x88, 0x84,
-  0xa5, 0xc9, 0xb9, 0xc8, 0x95, 0x85, 0x91, 0x31, 0x0a, 0x4b, 0x93, 0x73,
-  0x09, 0x93, 0x3b, 0xfb, 0xa2, 0xcb, 0x83, 0x2b, 0xfb, 0x9a, 0x4b, 0xd3,
-  0x2b, 0xe3, 0x15, 0x96, 0x26, 0xe7, 0x12, 0x26, 0x77, 0xf6, 0x45, 0x97,
-  0x07, 0x57, 0xf6, 0x15, 0xc6, 0x96, 0x76, 0xe6, 0xf6, 0x35, 0x97, 0xa6,
-  0x57, 0xc6, 0x61, 0xec, 0x8d, 0x6d, 0x08, 0x18, 0x2c, 0xc5, 0x03, 0x06,
-  0x4f, 0x18, 0x2c, 0xc4, 0x23, 0x06, 0xcb, 0xb0, 0x08, 0xcf, 0x18, 0x3c,
-  0x64, 0xb0, 0x10, 0x4f, 0x19, 0x2c, 0xc4, 0x03, 0x3d, 0xd1, 0x73, 0x3d,
-  0x66, 0xc0, 0x25, 0x2c, 0x4d, 0xce, 0x85, 0xae, 0x0c, 0x8f, 0xae, 0x4e,
-  0xae, 0x8c, 0x4a, 0x58, 0x9a, 0x9c, 0xcb, 0x5c, 0x58, 0x1b, 0x1c, 0x5b,
-  0x19, 0x31, 0xba, 0x32, 0x3c, 0xba, 0x3a, 0xb9, 0x32, 0x19, 0x32, 0x1e,
-  0x33, 0xb6, 0xb7, 0x30, 0x3a, 0x16, 0x90, 0xb9, 0xb0, 0x36, 0x38, 0xb6,
-  0x32, 0x1f, 0x0e, 0x74, 0x65, 0x78, 0x43, 0xa8, 0x05, 0x79, 0xd0, 0xe0,
-  0x11, 0x83, 0x65, 0x58, 0x84, 0x27, 0x0d, 0x1e, 0xe8, 0x51, 0x83, 0xe7,
-  0x7a, 0xd6, 0x80, 0x4b, 0x58, 0x9a, 0x9c, 0xcb, 0x5c, 0x58, 0x1b, 0x1c,
-  0x5b, 0x99, 0x1c, 0x8f, 0xb9, 0xb0, 0x36, 0x38, 0xb6, 0x32, 0x39, 0x06,
-  0x73, 0x43, 0xa4, 0xc5, 0x78, 0xda, 0xe0, 0x11, 0x83, 0x65, 0x58, 0x84,
-  0x07, 0x7a, 0xdc, 0xe0, 0xb9, 0x9e, 0x37, 0x18, 0xa2, 0x3c, 0xd9, 0xf3,
-  0x3d, 0x67, 0xf0, 0xb0, 0xc1, 0x03, 0x07, 0x43, 0x8c, 0x04, 0x78, 0xa6,
-  0x27, 0x0e, 0xf8, 0xbc, 0xb5, 0xb9, 0xa5, 0xc1, 0xbd, 0xd1, 0x95, 0xb9,
-  0xd1, 0x81, 0x8c, 0xa1, 0x85, 0xc9, 0xf1, 0x99, 0x4a, 0x6b, 0x83, 0x63,
-  0x2b, 0x03, 0x19, 0x5a, 0x59, 0x01, 0xa1, 0x12, 0x0a, 0x0a, 0x1a, 0x22,
-  0x3c, 0x74, 0x30, 0xc4, 0x78, 0xe6, 0xe0, 0xa9, 0x83, 0x28, 0x19, 0x62,
-  0x3c, 0x76, 0xf0, 0xd8, 0x41, 0x94, 0x8c, 0x88, 0xd8, 0x81, 0x1d, 0xec,
+  0xb7, 0x21, 0x90, 0x32, 0x38, 0x94, 0x53, 0x39, 0x96, 0x03, 0x39, 0x91,
+  0x73, 0x39, 0x18, 0xa5, 0xb0, 0x34, 0x39, 0x17, 0x33, 0xb9, 0xb0, 0xb3,
+  0xb6, 0x32, 0x37, 0xba, 0xaf, 0x34, 0x37, 0xb8, 0x3a, 0x3a, 0x5a, 0x67,
+  0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x35, 0x63, 0x6f,
+  0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66, 0x29, 0x7c, 0xc2, 0xd2,
+  0xe4, 0x5c, 0xe0, 0xca, 0xe4, 0xe6, 0xe0, 0xca, 0xc6, 0xe8, 0xd2, 0xec,
+  0xca, 0x58, 0x8c, 0xbd, 0xb1, 0xbd, 0xc9, 0x0d, 0x91, 0x14, 0xc1, 0xd1,
+  0x9c, 0xcd, 0xa9, 0x1c, 0xce, 0x81, 0x9c, 0xc8, 0xb9, 0x9c, 0x8e, 0xd9,
+  0x59, 0x99, 0x5b, 0x99, 0x5c, 0x18, 0x5d, 0x19, 0x19, 0x0a, 0x0e, 0x5d,
+  0x19, 0xde, 0xd8, 0xdb, 0x9b, 0x1c, 0x19, 0x91, 0x9d, 0xcc, 0x97, 0x59,
+  0x0a, 0x0d, 0x33, 0xb6, 0xb7, 0x30, 0x3a, 0x19, 0x22, 0x74, 0x65, 0x78,
+  0x63, 0x6f, 0x6f, 0x72, 0x64, 0x43, 0x24, 0x85, 0x70, 0x34, 0xe7, 0x73,
+  0x2a, 0x87, 0x73, 0x20, 0x07, 0x0c, 0x9c, 0xcb, 0x09, 0x03, 0x2e, 0x61,
+  0x69, 0x72, 0x2e, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x94, 0xc2,
+  0xd2, 0xe4, 0x5c, 0xd8, 0xde, 0xc6, 0xc2, 0xe8, 0xd2, 0xde, 0xdc, 0xbe,
+  0xd2, 0xdc, 0xc8, 0xca, 0xf0, 0xa8, 0x84, 0xa5, 0xc9, 0xb9, 0xcc, 0x85,
+  0xb5, 0xc1, 0xb1, 0x95, 0x11, 0xa3, 0x2b, 0xc3, 0xa3, 0xab, 0x93, 0x2b,
+  0x93, 0x21, 0xe3, 0x31, 0x63, 0x7b, 0x0b, 0xa3, 0x63, 0x01, 0x99, 0x0b,
+  0x6b, 0x83, 0x63, 0x2b, 0xf3, 0xe1, 0x40, 0x57, 0x86, 0x37, 0x84, 0x52,
+  0x0e, 0x67, 0x0c, 0x1c, 0x32, 0x50, 0x06, 0x45, 0x70, 0xca, 0xc0, 0x81,
+  0x1c, 0x33, 0x70, 0x2e, 0xe7, 0x0c, 0xb8, 0x84, 0xa5, 0xc9, 0xb9, 0xcc,
+  0x85, 0xb5, 0xc1, 0xb1, 0x95, 0xc9, 0xf1, 0x98, 0x0b, 0x6b, 0x83, 0x63,
+  0x2b, 0x93, 0x63, 0x30, 0x37, 0x44, 0x52, 0x0a, 0x27, 0x0d, 0x1c, 0x32,
+  0x50, 0x06, 0x45, 0x70, 0x20, 0x47, 0x0d, 0x9c, 0xcb, 0x59, 0x83, 0x21,
+  0x8a, 0x93, 0x39, 0x9e, 0x23, 0x06, 0x0e, 0x1a, 0x38, 0x6c, 0x30, 0xc4,
+  0x40, 0x00, 0x67, 0x72, 0xda, 0x60, 0x44, 0xc4, 0x0e, 0xec, 0x60, 0x0f,
+  0xed, 0xe0, 0x06, 0xed, 0xf0, 0x0e, 0xe4, 0x50, 0x0f, 0xec, 0x50, 0x0e,
+  0x6e, 0x60, 0x0e, 0xec, 0x10, 0x0e, 0xe7, 0x30, 0x0f, 0x53, 0x84, 0x60,
+  0x18, 0xa1, 0xb0, 0x03, 0x3b, 0xd8, 0x43, 0x3b, 0xb8, 0x41, 0x3a, 0x90,
+  0x43, 0x39, 0xb8, 0x03, 0x3d, 0x4c, 0x09, 0x8a, 0x11, 0x4b, 0x38, 0xa4,
+  0x83, 0x3c, 0xb8, 0x81, 0x3d, 0x94, 0x83, 0x3c, 0xcc, 0x43, 0x3a, 0xbc,
+  0x83, 0x3b, 0x4c, 0x09, 0x8c, 0x11, 0x54, 0x38, 0xa4, 0x83, 0x3c, 0xb8,
+  0x01, 0x3b, 0x84, 0x83, 0x3b, 0x9c, 0x43, 0x3d, 0x84, 0xc3, 0x39, 0x94,
+  0xc3, 0x2f, 0xd8, 0x43, 0x39, 0xc8, 0xc3, 0x3c, 0xa4, 0xc3, 0x3b, 0xb8,
+  0xc3, 0x94, 0x00, 0x19, 0x31, 0x85, 0x43, 0x3a, 0xc8, 0x83, 0x1b, 0x8c,
+  0xc3, 0x3b, 0xb4, 0x03, 0x3c, 0xa4, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc,
+  0x03, 0x3c, 0xd0, 0x43, 0x3a, 0xbc, 0x83, 0x3b, 0xcc, 0xc3, 0x94, 0x41,
+  0x61, 0x9c, 0x11, 0x4c, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xc8,
+  0x43, 0x38, 0x9c, 0x43, 0x3b, 0x94, 0x83, 0x3b, 0xd0, 0xc3, 0x94, 0xc0,
+  0x0d, 0x00, 0x79, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08,
+  0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38,
+  0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71,
+  0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c,
+  0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d,
+  0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d,
+  0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07,
+  0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87,
+  0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30,
+  0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10,
+  0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66,
+  0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c,
+  0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07,
+  0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87,
+  0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05,
+  0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87,
+  0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0,
+  0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4,
+  0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca,
+  0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39,
+  0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38,
+  0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c,
+  0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87,
+  0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87,
+  0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00,
+  0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20,
+  0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2,
+  0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4,
+  0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a,
+  0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07,
+  0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90,
+  0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8,
+  0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc,
+  0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b,
+  0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b,
+  0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87,
+  0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81,
+  0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30,
+  0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde,
+  0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39,
+  0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f,
+  0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20,
+  0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x06, 0x10, 0xb1, 0x5d, 0xf9, 0x73,
+  0xce, 0x83, 0xfd, 0x45, 0x04, 0x18, 0x0c, 0xd1, 0x4c, 0x16, 0xb0, 0x01,
+  0x48, 0xe4, 0x4b, 0x00, 0xf3, 0x2c, 0xc4, 0x3f, 0x11, 0xd7, 0x44, 0x45,
+  0xc4, 0x6f, 0x0f, 0x7e, 0x85, 0x17, 0xb7, 0x0d, 0x00, 0x00, 0x61, 0x20,
+  0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00,
+  0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xb4, 0x46, 0x00, 0x28, 0xd5, 0xc0,
+  0x08, 0x00, 0x81, 0x11, 0x00, 0x00, 0x23, 0x06, 0x8a, 0x10, 0x44, 0x46,
+  0x71, 0x0c, 0x84, 0x10, 0x58, 0x90, 0xc8, 0x27, 0x03, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0,
+  0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0xc8, 0x0c,
+  0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c,
+  0x00, 0x00, 0x2f, 0x03, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00,
+  0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8,
+  0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05,
+  0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92,
+  0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32,
+  0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19,
+  0x21, 0x72, 0x24, 0x07, 0xc8, 0x48, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40,
+  0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00, 0x00, 0x8e, 0x00,
+  0x00, 0x00, 0x1b, 0xcc, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x60,
+  0x00, 0x09, 0xa8, 0x88, 0x71, 0x78, 0x07, 0x79, 0x90, 0x87, 0x72, 0x18,
+  0x07, 0x7a, 0x60, 0x87, 0x7c, 0x68, 0x03, 0x79, 0x78, 0x87, 0x7a, 0x70,
+  0x07, 0x72, 0x28, 0x07, 0x72, 0x68, 0x03, 0x72, 0x48, 0x07, 0x7b, 0x48,
+  0x07, 0x72, 0x28, 0x87, 0x36, 0x98, 0x87, 0x78, 0x90, 0x07, 0x7a, 0x68,
+  0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00,
+  0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xc8, 0x21, 0x1d,
+  0xe6, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0xa1, 0x0d, 0xe8, 0x21, 0x1c,
+  0xd2, 0x81, 0x1d, 0xda, 0x60, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0x61, 0x1e,
+  0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x76, 0x28,
+  0x87, 0x79, 0x98, 0x87, 0x36, 0x80, 0x07, 0x79, 0x28, 0x87, 0x71, 0x48,
+  0x87, 0x79, 0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x87, 0x70, 0x20,
+  0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0xc2, 0x1d,
+  0xde, 0xa1, 0x0d, 0xcc, 0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca, 0xa1, 0x0d,
+  0xe0, 0xe1, 0x1d, 0xd2, 0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d,
+  0xca, 0x81, 0x1d, 0xd2, 0xa1, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28,
+  0x07, 0x60, 0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68,
+  0x87, 0x72, 0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28,
+  0x07, 0x79, 0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68, 0x87, 0x36, 0x70,
+  0x87, 0x77, 0x70, 0x87, 0x36, 0x60, 0x87, 0x72, 0x08, 0x07, 0x73, 0x00,
+  0x08, 0x77, 0x78, 0x87, 0x36, 0x48, 0x07, 0x77, 0x30, 0x87, 0x79, 0x68,
+  0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00,
+  0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d,
+  0xd4, 0xa1, 0x1e, 0xda, 0x01, 0x1e, 0xda, 0x80, 0x1e, 0xc2, 0x41, 0x1c,
+  0xd8, 0xa1, 0x1c, 0xe6, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28,
+  0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x77, 0x08, 0x07, 0x77, 0x98,
+  0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40,
+  0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0x60, 0x1e, 0xd2, 0xe1, 0x1c, 0xdc, 0xa1, 0x1c, 0xc8, 0xa1, 0x0d,
+  0xf4, 0xa1, 0x1c, 0xe4, 0xe1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e,
+  0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8,
+  0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0xa0, 0x07, 0x79, 0x08,
+  0x07, 0x78, 0x80, 0x87, 0x74, 0x70, 0x87, 0x73, 0x68, 0x83, 0x76, 0x08,
+  0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20,
+  0xe6, 0x81, 0x1e, 0xc2, 0x61, 0x1c, 0xd6, 0xa1, 0x0d, 0xe0, 0x41, 0x1e,
+  0xde, 0x81, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0xa1, 0x0d,
+  0xc4, 0xa1, 0x1e, 0xcc, 0xc1, 0x1c, 0xca, 0x41, 0x1e, 0xda, 0x60, 0x1e,
+  0xd2, 0x41, 0x1f, 0xca, 0x01, 0xc0, 0x03, 0x80, 0xa8, 0x07, 0x77, 0x98,
+  0x87, 0x70, 0x30, 0x87, 0x72, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68,
+  0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c,
+  0x00, 0xa2, 0x1e, 0xe6, 0xa1, 0x1c, 0xda, 0x60, 0x1e, 0xde, 0xc1, 0x1c,
+  0xe8, 0xa1, 0x0d, 0xcc, 0x81, 0x1d, 0xde, 0x21, 0x1c, 0xe8, 0x01, 0x30,
+  0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x60, 0x03, 0x22, 0x10, 0x40,
+  0x02, 0x2c, 0x40, 0xb5, 0xc1, 0x18, 0x0a, 0x60, 0x01, 0xaa, 0x0d, 0x06,
+  0x71, 0x00, 0x0b, 0x50, 0x6d, 0x30, 0x8a, 0xff, 0xff, 0xff, 0xff, 0x1f,
+  0x00, 0x09, 0xa0, 0x36, 0x20, 0xc6, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00,
+  0x03, 0x48, 0x40, 0xb5, 0xc1, 0x38, 0x02, 0x60, 0x01, 0xaa, 0x0d, 0x06,
+  0x22, 0x00, 0x0b, 0x50, 0x01, 0x00, 0x49, 0x18, 0x00, 0x00, 0x03, 0x00,
+  0x00, 0x00, 0x13, 0x88, 0x40, 0x18, 0x88, 0x09, 0x41, 0x31, 0x61, 0x30,
+  0x0e, 0x04, 0x89, 0x20, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x32, 0x22,
+  0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93,
+  0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84,
+  0xa4, 0x4c, 0x10, 0x78, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20,
+  0x00, 0xc3, 0x08, 0x03, 0x70, 0x90, 0x34, 0x45, 0x94, 0x30, 0xf9, 0xb2,
+  0xfb, 0x76, 0x84, 0xe0, 0x0c, 0x04, 0x22, 0xc6, 0x18, 0x63, 0x10, 0x81,
+  0x10, 0x8e, 0x92, 0xa6, 0x88, 0x12, 0x26, 0xff, 0x9f, 0x88, 0x6b, 0xa2,
+  0x22, 0xe2, 0xb7, 0x87, 0x7f, 0x1a, 0x23, 0x00, 0x06, 0x11, 0x8c, 0xe0,
+  0x34, 0x69, 0x8a, 0x28, 0x61, 0xf2, 0xff, 0x89, 0xb8, 0x26, 0x2a, 0x22,
+  0x7e, 0x7b, 0xf8, 0x81, 0x28, 0x02, 0xb0, 0x7f, 0x1a, 0x23, 0x00, 0x06,
+  0x11, 0x90, 0xe0, 0x22, 0x69, 0x8a, 0x28, 0x61, 0xf2, 0x7f, 0x09, 0x60,
+  0x9e, 0x85, 0x88, 0xfe, 0x69, 0x8c, 0x00, 0x18, 0x44, 0x50, 0x84, 0x82,
+  0x84, 0x10, 0x44, 0x39, 0x69, 0x11, 0x2b, 0x03, 0x18, 0x83, 0xdc, 0x1c,
+  0x01, 0x18, 0xcc, 0x11, 0x04, 0xc3, 0x08, 0x02, 0x54, 0x92, 0x90, 0x96,
+  0x80, 0x51, 0x46, 0x40, 0xb3, 0x20, 0xe1, 0x2c, 0x11, 0x65, 0x04, 0x54,
+  0x07, 0x02, 0x52, 0x00, 0x0e, 0x23, 0x0c, 0xd0, 0x20, 0x42, 0x20, 0xcc,
+  0x11, 0x80, 0xc2, 0x20, 0xc2, 0x20, 0x8c, 0x00, 0x00, 0x00, 0x13, 0xa8,
+  0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70, 0x80, 0x07,
+  0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87, 0x79, 0xc8, 0x03,
+  0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7, 0x51, 0x0e, 0x6d, 0x00,
+  0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60,
+  0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80,
+  0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0,
+  0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x10,
+  0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0,
+  0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60,
+  0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x74, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0,
+  0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60,
+  0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x90, 0x07, 0x76, 0xa0,
+  0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0,
+  0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80,
+  0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x90,
+  0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50,
+  0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20,
+  0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x6d, 0x60,
+  0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xa0,
+  0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x70, 0x20,
+  0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x7a, 0x10,
+  0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee, 0x80, 0x07, 0x7a, 0x10,
+  0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43, 0x98, 0x06, 0x00, 0x80,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x21, 0xcc, 0x03, 0x04, 0x80, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0xc0, 0x10, 0x86, 0x02, 0x02, 0x60, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x60, 0x08, 0x63, 0x01, 0x01, 0x30, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x90, 0x05, 0x02, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x32, 0x1e,
+  0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04,
+  0x43, 0x82, 0x25, 0x30, 0x02, 0x50, 0x20, 0x45, 0x50, 0x08, 0x05, 0x18,
+  0x50, 0x10, 0x65, 0x50, 0x40, 0x05, 0x56, 0x0a, 0xc5, 0x40, 0x78, 0x2c,
+  0xc1, 0x19, 0x00, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x13, 0x01,
+  0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab,
+  0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x06, 0x74, 0x5c, 0x00, 0x06,
+  0x51, 0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b,
+  0x62, 0x40, 0xc4, 0x25, 0x40, 0x08, 0xe1, 0x20, 0x08, 0x0e, 0x8e, 0xad,
+  0x0c, 0x84, 0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed,
+  0xcd, 0x0d, 0x64, 0x26, 0x06, 0x06, 0x26, 0xc6, 0xa5, 0x06, 0x06, 0x04,
+  0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26, 0x06, 0x06,
+  0x26, 0xc6, 0xa5, 0x06, 0xc6, 0x25, 0x26, 0x65, 0x88, 0x70, 0x11, 0x43,
+  0x0c, 0x88, 0x80, 0x14, 0xa8, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36,
+  0x04, 0xb9, 0x0e, 0x88, 0x80, 0x08, 0xa8, 0xe0, 0x16, 0x96, 0x26, 0xe7,
+  0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6,
+  0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96, 0x36, 0x17, 0x26, 0xc6, 0x56, 0x36,
+  0x44, 0xb8, 0x12, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
+  0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74,
+  0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x84, 0x6b, 0x21,
+  0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5, 0xc1, 0xa5, 0xb1, 0x95,
+  0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5, 0x99, 0x99, 0x95, 0xc9,
+  0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x95, 0xb9, 0x85, 0x89, 0xb1,
+  0x95, 0x0d, 0x11, 0xae, 0x86, 0x51, 0x58, 0x9a, 0x9c, 0x8b, 0x5c, 0x99,
+  0x1b, 0x59, 0x99, 0xdc, 0x17, 0x5d, 0x98, 0xdc, 0x59, 0x19, 0x1d, 0xa3,
+  0xb0, 0x34, 0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2,
+  0x2f, 0xb7, 0xb0, 0xb6, 0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34,
+  0x43, 0x90, 0xeb, 0x81, 0x8a, 0x0b, 0xba, 0xa2, 0x21, 0xc2, 0x25, 0x91,
+  0x09, 0x4b, 0x93, 0x73, 0x81, 0x7b, 0x9b, 0x4b, 0xa3, 0x4b, 0x7b, 0x73,
+  0xa3, 0x12, 0x96, 0x26, 0xe7, 0x32, 0x56, 0xe6, 0x46, 0x57, 0x26, 0x47,
+  0x29, 0x2c, 0x4d, 0xce, 0xc5, 0xed, 0xed, 0x0b, 0xae, 0x4c, 0x6e, 0x0e,
+  0xae, 0x6c, 0x8c, 0x2e, 0xcd, 0xae, 0x8c, 0x4c, 0x58, 0x9a, 0x9c, 0x4b,
+  0x98, 0xdc, 0xd9, 0x97, 0x5b, 0x58, 0x5b, 0x19, 0x11, 0xb8, 0xb7, 0xb9,
+  0x34, 0xba, 0xb4, 0x37, 0xb7, 0x21, 0x10, 0x54, 0x5c, 0xd4, 0x55, 0x5d,
+  0xd6, 0x05, 0x5d, 0xd1, 0x75, 0x5d, 0x18, 0xa5, 0xb0, 0x34, 0x39, 0x17,
+  0x33, 0xb9, 0xb0, 0xb3, 0xb6, 0x32, 0x37, 0xba, 0xaf, 0x34, 0x37, 0xb8,
+  0x3a, 0x3a, 0x5a, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64,
+  0x28, 0x35, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66,
+  0x29, 0x7c, 0xc2, 0xd2, 0xe4, 0x5c, 0xe0, 0xca, 0xe4, 0xe6, 0xe0, 0xca,
+  0xc6, 0xe8, 0xd2, 0xec, 0xca, 0x58, 0x8c, 0xbd, 0xb1, 0xbd, 0xc9, 0x0d,
+  0x91, 0x20, 0xe2, 0xd2, 0xae, 0xed, 0xaa, 0x2e, 0xee, 0x82, 0xae, 0xe8,
+  0xba, 0xae, 0x8e, 0xd9, 0x59, 0x99, 0x5b, 0x99, 0x5c, 0x18, 0x5d, 0x19,
+  0x19, 0x0a, 0x0e, 0x5d, 0x19, 0xde, 0xd8, 0xdb, 0x9b, 0x1c, 0x19, 0x91,
+  0x9d, 0xcc, 0x97, 0x59, 0x0a, 0x0d, 0x33, 0xb6, 0xb7, 0x30, 0x3a, 0x19,
+  0x22, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x43, 0x24, 0xe8,
+  0xb8, 0xb4, 0xeb, 0xbb, 0xaa, 0x8b, 0xbb, 0xa0, 0x0b, 0x0c, 0xae, 0xeb,
+  0x0a, 0x03, 0x2a, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65,
+  0x72, 0x7c, 0xc2, 0xd2, 0xe4, 0x5c, 0xc4, 0xea, 0xcc, 0xcc, 0xca, 0xe4,
+  0xbe, 0xe6, 0xd2, 0xf4, 0xca, 0x28, 0x85, 0xa5, 0xc9, 0xb9, 0xb0, 0xbd,
+  0x8d, 0x85, 0xd1, 0xa5, 0xbd, 0xb9, 0x7d, 0xa5, 0xb9, 0x91, 0x95, 0xe1,
+  0x11, 0x09, 0x4b, 0x93, 0x73, 0x91, 0x2b, 0x0b, 0x23, 0x23, 0x15, 0x96,
+  0x26, 0xe7, 0x32, 0x47, 0x27, 0x57, 0x37, 0x46, 0xf7, 0x45, 0x97, 0x07,
+  0x57, 0xf6, 0x95, 0xe6, 0x66, 0xf6, 0x46, 0xc3, 0x8c, 0xed, 0x2d, 0x8c,
+  0x6e, 0x86, 0xc6, 0x9b, 0x99, 0xd9, 0x5c, 0x19, 0x1d, 0x0d, 0xa9, 0xb1,
+  0xb7, 0x32, 0x33, 0x33, 0x1a, 0x47, 0x63, 0x6f, 0x65, 0x66, 0x66, 0x34,
+  0x84, 0xc6, 0xde, 0xca, 0xcc, 0xcc, 0x86, 0xa0, 0x01, 0x54, 0x40, 0x06,
+  0x54, 0x5c, 0x68, 0x70, 0xa5, 0x01, 0x64, 0x40, 0x06, 0x54, 0x5c, 0x68,
+  0x70, 0xa9, 0x01, 0xc4, 0x40, 0x06, 0x54, 0x5c, 0x68, 0x70, 0xad, 0x01,
+  0xd4, 0x40, 0x06, 0x54, 0x5c, 0x68, 0x70, 0xb1, 0x01, 0xa3, 0xb0, 0x34,
+  0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0xaf, 0xb9,
+  0x34, 0xbd, 0x32, 0x5e, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f,
+  0x74, 0x79, 0x70, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73,
+  0x69, 0x7a, 0x65, 0x4c, 0xb2, 0xaa, 0xac, 0x88, 0xca, 0xc6, 0xde, 0xc8,
+  0xca, 0x68, 0x90, 0x95, 0x8d, 0xbd, 0x91, 0x95, 0x0d, 0x21, 0x03, 0x68,
+  0xb9, 0xc6, 0xe0, 0x22, 0x03, 0x28, 0xb9, 0xca, 0x00, 0x22, 0x20, 0xe2,
+  0x32, 0x83, 0xeb, 0x0c, 0xae, 0x36, 0xb8, 0xdc, 0x00, 0x4a, 0xae, 0x37,
+  0x80, 0x8c, 0x0b, 0xba, 0xe0, 0xe0, 0xba, 0xae, 0x38, 0xe0, 0x12, 0x96,
+  0x26, 0xe7, 0x42, 0x57, 0x86, 0x47, 0x57, 0x27, 0x57, 0x46, 0x25, 0x2c,
+  0x4d, 0xce, 0x65, 0x2e, 0xac, 0x0d, 0x8e, 0xad, 0x8c, 0x18, 0x5d, 0x19,
+  0x1e, 0x5d, 0x9d, 0x5c, 0x99, 0x0c, 0x19, 0x8f, 0x19, 0xdb, 0x5b, 0x18,
+  0x1d, 0x0b, 0xc8, 0x5c, 0x58, 0x1b, 0x1c, 0x5b, 0x99, 0x0f, 0x09, 0xba,
+  0x32, 0xbc, 0xac, 0x21, 0x14, 0x84, 0x5c, 0x73, 0x70, 0x95, 0x01, 0x54,
+  0x40, 0xc4, 0x45, 0x07, 0x17, 0x74, 0xd5, 0xc1, 0x75, 0x5d, 0x76, 0x40,
+  0x8f, 0xae, 0x0c, 0x8f, 0xae, 0x4e, 0xae, 0x4c, 0x86, 0xec, 0x2b, 0x4c,
+  0x4e, 0x2e, 0x2c, 0x8f, 0xc7, 0x8c, 0xed, 0x2d, 0x8c, 0x8e, 0x05, 0x64,
+  0x2e, 0xac, 0x0d, 0x8e, 0xad, 0xcc, 0x87, 0x05, 0x5d, 0x19, 0x5e, 0x95,
+  0xd5, 0x10, 0x0a, 0x72, 0xae, 0x39, 0xb8, 0xca, 0x00, 0x22, 0x20, 0xe2,
+  0xa2, 0x83, 0x0b, 0xba, 0xf0, 0xe0, 0xba, 0xae, 0x3c, 0xe0, 0x12, 0x96,
+  0x26, 0xe7, 0x32, 0x17, 0xd6, 0x06, 0xc7, 0x56, 0x26, 0xc7, 0x63, 0x2e,
+  0xac, 0x0d, 0x8e, 0xad, 0x4c, 0x8e, 0xc1, 0xdc, 0x10, 0x09, 0x7a, 0xae,
+  0x3d, 0xb8, 0xca, 0x00, 0x2a, 0x20, 0xe2, 0x82, 0x2e, 0x3e, 0xb8, 0xae,
+  0xab, 0x0f, 0x86, 0x38, 0x57, 0x76, 0x79, 0x97, 0x18, 0x5c, 0x72, 0x70,
+  0xdd, 0xc1, 0xa5, 0x07, 0x97, 0x1f, 0x0c, 0x31, 0x1a, 0xe0, 0x9a, 0xae,
+  0x3f, 0x18, 0x11, 0xb1, 0x03, 0x3b, 0xd8, 0x43, 0x3b, 0xb8, 0x41, 0x3b,
+  0xbc, 0x03, 0x39, 0xd4, 0x03, 0x3b, 0x94, 0x83, 0x1b, 0x98, 0x03, 0x3b,
+  0x84, 0xc3, 0x39, 0xcc, 0xc3, 0x14, 0x21, 0x18, 0x46, 0x28, 0xec, 0xc0,
+  0x0e, 0xf6, 0xd0, 0x0e, 0x6e, 0x90, 0x0e, 0xe4, 0x50, 0x0e, 0xee, 0x40,
+  0x0f, 0x53, 0x82, 0x62, 0xc4, 0x12, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0x60,
+  0x0f, 0xe5, 0x20, 0x0f, 0xf3, 0x90, 0x0e, 0xef, 0xe0, 0x0e, 0x53, 0x02,
+  0x63, 0x04, 0x15, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0xc0, 0x0e, 0xe1, 0xe0,
+  0x0e, 0xe7, 0x50, 0x0f, 0xe1, 0x70, 0x0e, 0xe5, 0xf0, 0x0b, 0xf6, 0x50,
+  0x0e, 0xf2, 0x30, 0x0f, 0xe9, 0xf0, 0x0e, 0xee, 0x30, 0x25, 0x40, 0x46,
+  0x4c, 0xe1, 0x90, 0x0e, 0xf2, 0xe0, 0x06, 0xe3, 0xf0, 0x0e, 0xed, 0x00,
+  0x0f, 0xe9, 0xc0, 0x0e, 0xe5, 0xf0, 0x0b, 0xef, 0x00, 0x0f, 0xf4, 0x90,
+  0x0e, 0xef, 0xe0, 0x0e, 0xf3, 0x30, 0x65, 0x50, 0x18, 0x67, 0x04, 0x13,
+  0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0x60, 0x0e, 0xf2, 0x10, 0x0e, 0xe7, 0xd0,
+  0x0e, 0xe5, 0xe0, 0x0e, 0xf4, 0x30, 0x25, 0x00, 0x05, 0x00, 0x79, 0x18,
+  0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1,
+  0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42,
+  0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f,
+  0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1,
+  0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84,
+  0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc,
+  0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70,
+  0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19,
+  0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f,
+  0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21,
+  0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc,
+  0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84,
+  0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37,
+  0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70,
+  0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77,
+  0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79,
+  0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e,
+  0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1,
+  0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81,
+  0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98,
+  0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88,
+  0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4,
+  0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72,
+  0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74,
+  0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e,
+  0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e,
+  0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21,
+  0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01,
+  0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc,
+  0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77,
+  0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e,
+  0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1,
+  0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61,
+  0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0,
+  0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0,
+  0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74,
+  0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e,
+  0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41,
+  0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50,
+  0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c,
+  0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc,
+  0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20, 0x00, 0x00, 0x14, 0x00,
+  0x00, 0x00, 0x26, 0x10, 0x06, 0x00, 0x12, 0xf9, 0x12, 0xc0, 0x3c, 0x0b,
+  0xf1, 0x4f, 0xc4, 0x35, 0x51, 0x11, 0xf1, 0xdb, 0xc3, 0x0f, 0x44, 0x11,
+  0x80, 0xf9, 0x15, 0x5e, 0xdc, 0xb6, 0x05, 0x34, 0x00, 0x12, 0xf9, 0x83,
+  0x33, 0xf9, 0xd5, 0x5d, 0xdc, 0xb6, 0x0d, 0x6c, 0x00, 0x12, 0xf9, 0x12,
+  0xc0, 0x3c, 0x0b, 0xf1, 0x4f, 0xc4, 0x35, 0x51, 0x11, 0xf1, 0xdb, 0x83,
+  0x5f, 0xe1, 0xc5, 0x6d, 0x1b, 0x00, 0xc4, 0x76, 0xe5, 0x2f, 0xbb, 0xef,
+  0x5f, 0x44, 0x80, 0xc1, 0x10, 0xcd, 0x04, 0x00, 0x00, 0x00, 0x61, 0x20,
+  0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00,
+  0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0xb4, 0x47, 0x00, 0x28, 0xcf, 0x31,
+  0x14, 0x5d, 0x37, 0xd6, 0x00, 0x04, 0x02, 0xc9, 0x11, 0x00, 0x8a, 0x23,
+  0x00, 0x04, 0x67, 0x00, 0x28, 0xd6, 0x00, 0x85, 0x39, 0x08, 0x31, 0x10,
+  0x03, 0x31, 0x08, 0x83, 0x19, 0x00, 0x02, 0x63, 0x04, 0x20, 0x08, 0x82,
+  0xf8, 0x37, 0x03, 0x30, 0x02, 0x00, 0x23, 0x06, 0xca, 0x10, 0x84, 0xc1,
+  0xd3, 0x44, 0x46, 0x82, 0x04, 0x83, 0x0c, 0x41, 0xc1, 0x8c, 0x18, 0x2c,
+  0x43, 0x40, 0x06, 0xd0, 0x33, 0x85, 0x01, 0xb2, 0x28, 0xc3, 0x18, 0x42,
+  0x20, 0x06, 0x73, 0x0c, 0x43, 0x40, 0x06, 0x23, 0x06, 0xcb, 0x10, 0x9c,
+  0xc1, 0x24, 0x59, 0x65, 0xb0, 0x38, 0x8d, 0x31, 0x86, 0x10, 0x94, 0xc1,
+  0x1c, 0xc3, 0x10, 0x90, 0xc1, 0x61, 0x7a, 0x29, 0x28, 0x83, 0x0c, 0x81,
+  0x43, 0x19, 0x11, 0xc0, 0x67, 0xbc, 0x81, 0xc3, 0xd8, 0xe0, 0x02, 0xbd,
+  0x14, 0x94, 0x41, 0x86, 0x60, 0xca, 0x46, 0x0c, 0x0a, 0x21, 0x98, 0x83,
+  0x22, 0x18, 0x6f, 0x08, 0x83, 0xce, 0x0d, 0x2e, 0xd0, 0x4b, 0x41, 0x19,
+  0x64, 0x08, 0x30, 0x6f, 0xc4, 0xa0, 0x10, 0x02, 0x3c, 0x50, 0x82, 0xf1,
+  0x06, 0x33, 0x10, 0x83, 0x37, 0xb8, 0x40, 0x2f, 0x05, 0x65, 0x90, 0x21,
+  0xe8, 0xc6, 0x60, 0xc4, 0xa0, 0x10, 0x82, 0x3e, 0x78, 0x82, 0x39, 0x06,
+  0x30, 0x58, 0xf4, 0x60, 0x8e, 0x21, 0x38, 0xf8, 0x60, 0x8e, 0x21, 0x18,
+  0xf4, 0xc0, 0x02, 0x38, 0x90, 0x4f, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00,
+  0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x5c, 0x0c, 0x00, 0x00, 0xff, 0xff,
+  0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0x14, 0x03,
+  0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00,
+  0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10,
+  0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04,
+  0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10,
+  0x32, 0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a,
+  0x90, 0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07,
+  0xc8, 0x48, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00,
+  0x00, 0x00, 0x51, 0x18, 0x00, 0x00, 0x90, 0x00, 0x00, 0x00, 0x1b, 0xcc,
+  0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x60, 0x00, 0x09, 0xa8, 0x88,
+  0x71, 0x78, 0x07, 0x79, 0x90, 0x87, 0x72, 0x18, 0x07, 0x7a, 0x60, 0x87,
+  0x7c, 0x68, 0x03, 0x79, 0x78, 0x87, 0x7a, 0x70, 0x07, 0x72, 0x28, 0x07,
+  0x72, 0x68, 0x03, 0x72, 0x48, 0x07, 0x7b, 0x48, 0x07, 0x72, 0x28, 0x87,
+  0x36, 0x98, 0x87, 0x78, 0x90, 0x07, 0x7a, 0x68, 0x03, 0x73, 0x80, 0x87,
+  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xcc, 0x21, 0x1c, 0xd8,
+  0x61, 0x1e, 0xca, 0x01, 0x20, 0xc8, 0x21, 0x1d, 0xe6, 0x21, 0x1c, 0xc4,
+  0x81, 0x1d, 0xca, 0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xd2, 0x81, 0x1d, 0xda,
+  0x60, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0x61, 0x1e, 0x00, 0x73, 0x08, 0x07,
+  0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x76, 0x28, 0x87, 0x79, 0x98, 0x87,
+  0x36, 0x80, 0x07, 0x79, 0x28, 0x87, 0x71, 0x48, 0x87, 0x79, 0x28, 0x87,
+  0x36, 0x30, 0x07, 0x78, 0x68, 0x87, 0x70, 0x20, 0x07, 0xc0, 0x1c, 0xc2,
+  0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xcc,
+  0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca, 0xa1, 0x0d, 0xe0, 0xe1, 0x1d, 0xd2,
+  0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xca, 0x81, 0x1d, 0xd2,
+  0xa1, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x60, 0x70, 0x87,
+  0x77, 0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03,
+  0x78, 0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83,
+  0x72, 0x60, 0x87, 0x74, 0x68, 0x87, 0x36, 0x70, 0x87, 0x77, 0x70, 0x87,
+  0x36, 0x60, 0x87, 0x72, 0x08, 0x07, 0x73, 0x00, 0x08, 0x77, 0x78, 0x87,
+  0x36, 0x48, 0x07, 0x77, 0x30, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87,
+  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea,
+  0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xd4, 0xa1, 0x1e, 0xda,
+  0x01, 0x1e, 0xda, 0x80, 0x1e, 0xc2, 0x41, 0x1c, 0xd8, 0xa1, 0x1c, 0xe6,
+  0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x70, 0x87,
+  0x77, 0x68, 0x03, 0x77, 0x08, 0x07, 0x77, 0x98, 0x87, 0x36, 0x30, 0x07,
+  0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4,
+  0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x60, 0x1e, 0xd2,
+  0xe1, 0x1c, 0xdc, 0xa1, 0x1c, 0xc8, 0xa1, 0x0d, 0xf4, 0xa1, 0x1c, 0xe4,
+  0xe1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2,
+  0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08,
+  0x77, 0x78, 0x87, 0x36, 0xa0, 0x07, 0x79, 0x08, 0x07, 0x78, 0x80, 0x87,
+  0x74, 0x70, 0x87, 0x73, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07,
+  0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xe6, 0x81, 0x1e, 0xc2,
+  0x61, 0x1c, 0xd6, 0xa1, 0x0d, 0xe0, 0x41, 0x1e, 0xde, 0x81, 0x1e, 0xca,
+  0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0xa1, 0x0d, 0xc4, 0xa1, 0x1e, 0xcc,
+  0xc1, 0x1c, 0xca, 0x41, 0x1e, 0xda, 0x60, 0x1e, 0xd2, 0x41, 0x1f, 0xca,
+  0x01, 0xc0, 0x03, 0x80, 0xa8, 0x07, 0x77, 0x98, 0x87, 0x70, 0x30, 0x87,
+  0x72, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07,
+  0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xa2, 0x1e, 0xe6,
+  0xa1, 0x1c, 0xda, 0x60, 0x1e, 0xde, 0xc1, 0x1c, 0xe8, 0xa1, 0x0d, 0xcc,
+  0x81, 0x1d, 0xde, 0x21, 0x1c, 0xe8, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87,
+  0x79, 0x28, 0x07, 0x60, 0x03, 0x22, 0x10, 0x40, 0x02, 0x2c, 0x40, 0xb5,
+  0xc1, 0x18, 0x0a, 0x60, 0x01, 0xaa, 0x0d, 0x06, 0x61, 0x00, 0x0b, 0x50,
+  0x6d, 0x30, 0x8a, 0x03, 0x58, 0x80, 0x6a, 0x83, 0x61, 0xfc, 0xff, 0xff,
+  0xff, 0xff, 0x00, 0x48, 0x00, 0xb5, 0x01, 0x39, 0xfe, 0xff, 0xff, 0xff,
+  0x7f, 0x00, 0x18, 0x40, 0x02, 0xaa, 0x0d, 0x06, 0x12, 0x00, 0x0b, 0x50,
+  0x6d, 0x30, 0x12, 0x01, 0x58, 0x80, 0x0a, 0x00, 0x00, 0x00, 0x49, 0x18,
+  0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x13, 0x8a, 0x40, 0x18, 0x88, 0x62,
+  0x42, 0x60, 0x4c, 0x18, 0x0e, 0x24, 0x01, 0x00, 0x00, 0x00, 0x89, 0x20,
+  0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09, 0x20, 0x64,
+  0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1,
+  0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x68,
+  0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00, 0xc3, 0x08, 0x03,
+  0x70, 0x90, 0x34, 0x45, 0x94, 0x30, 0xf9, 0xb2, 0xfb, 0x76, 0x84, 0xe0,
+  0x0c, 0x04, 0x22, 0xc6, 0x18, 0x63, 0x10, 0x81, 0x10, 0x8e, 0x92, 0xa6,
+  0x88, 0x12, 0x26, 0xff, 0x9f, 0x88, 0x6b, 0xa2, 0x22, 0xe2, 0xb7, 0x87,
+  0x7f, 0x1a, 0x23, 0x00, 0x06, 0x11, 0x8c, 0xe0, 0x22, 0x69, 0x8a, 0x28,
+  0x61, 0xf2, 0x7f, 0x09, 0x60, 0x9e, 0x85, 0x88, 0xfe, 0x69, 0x8c, 0x00,
+  0x18, 0x44, 0x40, 0x84, 0x82, 0x84, 0x10, 0x44, 0x39, 0x27, 0x91, 0x2a,
+  0x03, 0x18, 0x83, 0xd8, 0x1c, 0x41, 0x30, 0x47, 0x00, 0x06, 0xc3, 0x08,
+  0xc2, 0x53, 0x90, 0x70, 0x92, 0x70, 0xd0, 0x01, 0x8a, 0x03, 0x01, 0x29,
+  0xf0, 0x86, 0x11, 0x86, 0x67, 0x10, 0x21, 0x10, 0xe6, 0x08, 0x40, 0x61,
+  0x10, 0x61, 0x10, 0x46, 0x00, 0x00, 0x13, 0xa8, 0x70, 0x48, 0x07, 0x79,
+  0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72,
+  0x68, 0x83, 0x74, 0x78, 0x87, 0x79, 0xc8, 0x03, 0x37, 0x80, 0x03, 0x37,
+  0x80, 0x83, 0x0d, 0xb7, 0x51, 0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07,
+  0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06,
+  0xe9, 0x10, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e,
+  0x78, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07,
+  0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06,
+  0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
+  0x72, 0xd0, 0x06, 0xe9, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
+  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07,
+  0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06,
+  0xf6, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07,
+  0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x73, 0x20, 0x07,
+  0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07,
+  0x78, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06,
+  0xf6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07,
+  0x74, 0xd0, 0x06, 0xf6, 0x90, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x20, 0x07,
+  0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07,
+  0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07,
+  0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x90, 0x07, 0x72, 0xa0, 0x07,
+  0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06,
+  0xf6, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07,
+  0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07,
+  0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07,
+  0x72, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07,
+  0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07,
+  0x74, 0xd0, 0x06, 0xee, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x43, 0x98, 0x05, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x80, 0x21, 0x4c, 0x03, 0x04, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0xc0, 0x10, 0x46, 0x02, 0x02, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20,
+  0x0b, 0x04, 0x0b, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x14, 0x19, 0x11,
+  0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x7a, 0x25, 0x30,
+  0x02, 0x50, 0x20, 0x45, 0x50, 0x08, 0x05, 0x18, 0x50, 0x10, 0x65, 0x50,
+  0x40, 0x05, 0x56, 0x0a, 0xc5, 0x40, 0x74, 0x2c, 0xc1, 0x19, 0x00, 0x00,
+  0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x0c, 0x01, 0x00, 0x00, 0x1a, 0x03,
+  0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4,
+  0x37, 0xb7, 0x21, 0xc6, 0x63, 0x4c, 0x00, 0xf5, 0x50, 0xb9, 0x1b, 0x43,
+  0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b, 0x62, 0x3c, 0xc3, 0x24,
+  0x3c, 0x07, 0xe1, 0x20, 0x08, 0x0e, 0x8e, 0xad, 0x0c, 0x84, 0x89, 0xc9,
+  0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x26,
+  0x06, 0x06, 0x26, 0xc6, 0xa5, 0x06, 0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e,
+  0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26, 0x06, 0x06, 0x26, 0xc6, 0xa5, 0x06,
+  0xc6, 0x25, 0x26, 0x65, 0x88, 0x30, 0x11, 0x43, 0x8c, 0x67, 0x78, 0x92,
+  0x87, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36, 0x04, 0x99, 0x8e, 0x67,
+  0x78, 0x86, 0x87, 0xe0, 0x16, 0x96, 0x26, 0xe7, 0x32, 0xf6, 0xd6, 0x06,
+  0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6, 0x26, 0xd7, 0x36, 0xf7,
+  0x45, 0x96, 0x36, 0x17, 0x26, 0xc6, 0x56, 0x36, 0x44, 0x98, 0x12, 0x72,
+  0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e,
+  0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e,
+  0x61, 0x62, 0x6c, 0x65, 0x43, 0x84, 0x69, 0x21, 0x19, 0x84, 0xa5, 0xc9,
+  0xb9, 0x8c, 0xbd, 0xb5, 0xc1, 0xa5, 0xb1, 0x95, 0xb9, 0x98, 0xc9, 0x85,
+  0xb5, 0x95, 0x89, 0xd5, 0x99, 0x99, 0x95, 0xc9, 0x7d, 0x99, 0x95, 0xd1,
+  0x8d, 0xa1, 0x7d, 0x95, 0xb9, 0x85, 0x89, 0xb1, 0x95, 0x0d, 0x11, 0xa6,
+  0x86, 0x51, 0x58, 0x9a, 0x9c, 0x8b, 0x5c, 0x99, 0x1b, 0x59, 0x99, 0xdc,
+  0x17, 0x5d, 0x98, 0xdc, 0x59, 0x19, 0x1d, 0xa3, 0xb0, 0x34, 0x39, 0x97,
+  0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0x2f, 0xb7, 0xb0, 0xb6,
+  0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x43, 0x90, 0xe9, 0x79,
+  0x88, 0x09, 0x9a, 0xa2, 0x21, 0xc2, 0x24, 0x91, 0x09, 0x4b, 0x93, 0x73,
+  0x81, 0x7b, 0x9b, 0x4b, 0xa3, 0x4b, 0x7b, 0x73, 0xa3, 0x12, 0x96, 0x26,
+  0xe7, 0x32, 0x56, 0xe6, 0x46, 0x57, 0x26, 0x47, 0x29, 0x2c, 0x4d, 0xce,
+  0xc5, 0xed, 0xed, 0x0b, 0xae, 0x4c, 0x6e, 0x0e, 0xae, 0x6c, 0x8c, 0x2e,
+  0xcd, 0xae, 0x8c, 0x4c, 0x58, 0x9a, 0x9c, 0x4b, 0x98, 0xdc, 0xd9, 0x97,
+  0x5b, 0x58, 0x5b, 0x19, 0x11, 0xb8, 0xb7, 0xb9, 0x34, 0xba, 0xb4, 0x37,
+  0xb7, 0x21, 0xd0, 0x43, 0x4c, 0xd4, 0x54, 0x4d, 0xd6, 0x04, 0x4d, 0xd1,
+  0x74, 0x4d, 0x18, 0xa5, 0xb0, 0x34, 0x39, 0x17, 0x33, 0xb9, 0xb0, 0xb3,
+  0xb6, 0x32, 0x37, 0xba, 0xaf, 0x34, 0x37, 0xb8, 0x3a, 0x3a, 0x5a, 0x67,
+  0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x35, 0x63, 0x6f,
+  0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66, 0x29, 0x7c, 0xc2, 0xd2,
+  0xe4, 0x5c, 0xe0, 0xca, 0xe4, 0xe6, 0xe0, 0xca, 0xc6, 0xe8, 0xd2, 0xec,
+  0xca, 0x58, 0x8c, 0xbd, 0xb1, 0xbd, 0xc9, 0x0d, 0x91, 0x9e, 0x61, 0xd2,
+  0xa6, 0x6d, 0xaa, 0x26, 0x6e, 0x82, 0xa6, 0x68, 0xba, 0xa6, 0x8e, 0xd9,
+  0x59, 0x99, 0x5b, 0x99, 0x5c, 0x18, 0x5d, 0x19, 0x19, 0x0a, 0x0e, 0x5d,
+  0x19, 0xde, 0xd8, 0xdb, 0x9b, 0x1c, 0x19, 0x91, 0x9d, 0xcc, 0x97, 0x59,
+  0x0a, 0x0d, 0x33, 0xb6, 0xb7, 0x30, 0x3a, 0x19, 0x22, 0x74, 0x65, 0x78,
+  0x63, 0x6f, 0x6f, 0x72, 0x64, 0x43, 0xa4, 0xc7, 0x98, 0xb4, 0xe9, 0x9b,
+  0xaa, 0x89, 0x9b, 0xa0, 0x09, 0x0c, 0xa6, 0x6b, 0x0a, 0x03, 0x2a, 0x61,
+  0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x7c, 0xc2, 0xd2,
+  0xe4, 0x5c, 0xc4, 0xea, 0xcc, 0xcc, 0xca, 0xe4, 0xbe, 0xe6, 0xd2, 0xf4,
+  0xca, 0x28, 0x85, 0xa5, 0xc9, 0xb9, 0xb0, 0xbd, 0x8d, 0x85, 0xd1, 0xa5,
+  0xbd, 0xb9, 0x7d, 0xa5, 0xb9, 0x91, 0x95, 0xe1, 0x11, 0x09, 0x4b, 0x93,
+  0x73, 0x91, 0x2b, 0x0b, 0x23, 0x23, 0x15, 0x96, 0x26, 0xe7, 0x32, 0x47,
+  0x27, 0x57, 0x37, 0x46, 0xf7, 0x45, 0x97, 0x07, 0x57, 0xf6, 0x95, 0xe6,
+  0x66, 0xf6, 0x46, 0xc3, 0x8c, 0xed, 0x2d, 0x8c, 0x6e, 0x86, 0xc6, 0x9b,
+  0x99, 0xd9, 0x5c, 0x19, 0x1d, 0x0d, 0xa9, 0xb1, 0xb7, 0x32, 0x33, 0x33,
+  0x1a, 0x47, 0x63, 0x6f, 0x65, 0x66, 0x66, 0x34, 0x84, 0xc6, 0xde, 0xca,
+  0xcc, 0xcc, 0x86, 0xa0, 0xc1, 0x43, 0x3c, 0xc5, 0x43, 0x4c, 0x68, 0x30,
+  0xa5, 0xc1, 0x53, 0x3c, 0xc5, 0x43, 0x4c, 0x68, 0x30, 0xa9, 0xc1, 0xb3,
+  0x3c, 0xc5, 0x43, 0x4c, 0x68, 0x30, 0xad, 0xc1, 0xc3, 0x3c, 0xc5, 0x43,
+  0x4c, 0x68, 0x30, 0xb1, 0x01, 0xa3, 0xb0, 0x34, 0x39, 0x97, 0x30, 0xb9,
+  0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0xaf, 0xb9, 0x34, 0xbd, 0x32, 0x5e,
+  0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65,
+  0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x4c,
+  0xb2, 0xaa, 0xac, 0x88, 0xca, 0xc6, 0xde, 0xc8, 0xca, 0x68, 0x90, 0x95,
+  0x8d, 0xbd, 0x91, 0x95, 0x0d, 0x21, 0x83, 0x47, 0x99, 0xc6, 0x60, 0x22,
+  0x83, 0x07, 0x99, 0xca, 0xe0, 0x19, 0x9e, 0x61, 0x32, 0x83, 0xe9, 0x0c,
+  0xa6, 0x36, 0x98, 0xdc, 0xe0, 0x41, 0xa6, 0x37, 0x78, 0x8a, 0x09, 0x9a,
+  0xe0, 0x60, 0xba, 0xa6, 0x38, 0xe0, 0x12, 0x96, 0x26, 0xe7, 0x42, 0x57,
+  0x86, 0x47, 0x57, 0x27, 0x57, 0x46, 0x25, 0x2c, 0x4d, 0xce, 0x65, 0x2e,
+  0xac, 0x0d, 0x8e, 0xad, 0x8c, 0x18, 0x5d, 0x19, 0x1e, 0x5d, 0x9d, 0x5c,
+  0x99, 0x0c, 0x19, 0x8f, 0x19, 0xdb, 0x5b, 0x18, 0x1d, 0x0b, 0xc8, 0x5c,
+  0x58, 0x1b, 0x1c, 0x5b, 0x99, 0x0f, 0x09, 0xba, 0x32, 0xbc, 0xac, 0x21,
+  0xd4, 0x73, 0x4c, 0x73, 0x30, 0x95, 0xc1, 0x43, 0x3c, 0xc3, 0x44, 0x07,
+  0x13, 0x34, 0xd5, 0xc1, 0x74, 0x4d, 0x76, 0xc0, 0x82, 0xae, 0x0c, 0xaf,
+  0xca, 0x6a, 0x08, 0xf5, 0x34, 0xd3, 0x1c, 0x4c, 0x65, 0xf0, 0x0c, 0xcf,
+  0x30, 0xd1, 0xc1, 0x04, 0x4d, 0x75, 0x30, 0x5d, 0x13, 0x1e, 0x70, 0x09,
+  0x4b, 0x93, 0x73, 0x99, 0x0b, 0x6b, 0x83, 0x63, 0x2b, 0x93, 0xe3, 0x31,
+  0x17, 0xd6, 0x06, 0xc7, 0x56, 0x26, 0xc7, 0x60, 0x6e, 0x88, 0xf4, 0x38,
+  0x93, 0x1e, 0x4c, 0x65, 0xf0, 0x10, 0xcf, 0x30, 0x41, 0xd3, 0x1e, 0x4c,
+  0xd7, 0xc4, 0x07, 0x43, 0x9c, 0x29, 0x9b, 0xbc, 0x49, 0x0c, 0x26, 0x39,
+  0x98, 0xee, 0x60, 0xca, 0x83, 0xa9, 0x0f, 0x86, 0x18, 0x0b, 0x30, 0x4d,
+  0x93, 0x1f, 0x8c, 0x88, 0xd8, 0x81, 0x1d, 0xec, 0xa1, 0x1d, 0xdc, 0xa0,
+  0x1d, 0xde, 0x81, 0x1c, 0xea, 0x81, 0x1d, 0xca, 0xc1, 0x0d, 0xcc, 0x81,
+  0x1d, 0xc2, 0xe1, 0x1c, 0xe6, 0x61, 0x8a, 0x10, 0x0c, 0x23, 0x14, 0x76,
+  0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x48, 0x07, 0x72, 0x28, 0x07, 0x77,
+  0xa0, 0x87, 0x29, 0x41, 0x31, 0x62, 0x09, 0x87, 0x74, 0x90, 0x07, 0x37,
+  0xb0, 0x87, 0x72, 0x90, 0x87, 0x79, 0x48, 0x87, 0x77, 0x70, 0x87, 0x29,
+  0x81, 0x31, 0x82, 0x0a, 0x87, 0x74, 0x90, 0x07, 0x37, 0x60, 0x87, 0x70,
+  0x70, 0x87, 0x73, 0xa8, 0x87, 0x70, 0x38, 0x87, 0x72, 0xf8, 0x05, 0x7b,
+  0x28, 0x07, 0x79, 0x98, 0x87, 0x74, 0x78, 0x07, 0x77, 0x98, 0x12, 0x20,
+  0x23, 0xa6, 0x70, 0x48, 0x07, 0x79, 0x70, 0x83, 0x71, 0x78, 0x87, 0x76,
+  0x80, 0x87, 0x74, 0x60, 0x87, 0x72, 0xf8, 0x85, 0x77, 0x80, 0x07, 0x7a,
+  0x48, 0x87, 0x77, 0x70, 0x87, 0x79, 0x98, 0x32, 0x28, 0x8c, 0x33, 0x82,
+  0x09, 0x87, 0x74, 0x90, 0x07, 0x37, 0x30, 0x07, 0x79, 0x08, 0x87, 0x73,
+  0x68, 0x87, 0x72, 0x70, 0x07, 0x7a, 0x98, 0x12, 0xfc, 0x01, 0x00, 0x00,
+  0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08,
+  0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38,
+  0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71,
+  0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c,
+  0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d,
+  0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d,
+  0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07,
+  0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87,
+  0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30,
+  0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10,
+  0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66,
+  0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c,
+  0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07,
+  0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87,
+  0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05,
+  0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87,
+  0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0,
+  0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4,
+  0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca,
+  0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39,
+  0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38,
+  0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c,
+  0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87,
+  0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87,
+  0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00,
+  0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20,
+  0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2,
+  0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4,
+  0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a,
+  0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07,
+  0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90,
+  0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8,
+  0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc,
+  0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b,
+  0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b,
+  0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87,
+  0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81,
+  0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30,
+  0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde,
+  0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39,
+  0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f,
+  0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20,
+  0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x16, 0xd0, 0x00, 0x48, 0xe4, 0x0f,
+  0xce, 0xe4, 0x57, 0x77, 0x71, 0xdb, 0x26, 0xb0, 0x01, 0x48, 0xe4, 0x4b,
+  0x00, 0xf3, 0x2c, 0xc4, 0x3f, 0x11, 0xd7, 0x44, 0x45, 0xc4, 0x6f, 0x0f,
+  0x7e, 0x85, 0x17, 0xb7, 0x6d, 0x00, 0x11, 0xdb, 0x95, 0xff, 0xf9, 0xd6,
+  0xf6, 0x5f, 0x44, 0x80, 0xc1, 0x10, 0xcd, 0x04, 0x00, 0x00, 0x61, 0x20,
+  0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00,
+  0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x74, 0x47, 0x00, 0xa8, 0x8e, 0x35,
+  0x00, 0x03, 0x31, 0xc7, 0x40, 0x0c, 0xde, 0x1c, 0x03, 0xe1, 0x79, 0x63,
+  0x0d, 0x40, 0x20, 0x90, 0xab, 0x81, 0x11, 0x00, 0x7a, 0x33, 0x00, 0x04,
+  0x47, 0x00, 0x28, 0xcc, 0x41, 0x90, 0x01, 0x19, 0x90, 0x81, 0x18, 0xcc,
+  0x00, 0x10, 0x18, 0x23, 0x00, 0x41, 0x10, 0xc4, 0xbf, 0x11, 0x80, 0x19,
+  0x00, 0x00, 0x23, 0x06, 0xca, 0x10, 0x8c, 0x41, 0xf4, 0x4c, 0x89, 0x81,
+  0x08, 0x83, 0x0c, 0x41, 0xc1, 0x8c, 0x18, 0x28, 0x43, 0x50, 0x06, 0x52,
+  0x54, 0x2d, 0x88, 0x42, 0x0c, 0x32, 0x04, 0xc7, 0x33, 0xc8, 0x30, 0x04,
+  0xd1, 0x5d, 0x76, 0x29, 0x28, 0x83, 0x0c, 0xc1, 0x12, 0x19, 0x11, 0xc0,
+  0x67, 0xbc, 0x61, 0xbb, 0xd6, 0xe0, 0x02, 0xbb, 0x14, 0x94, 0x41, 0x86,
+  0x00, 0xb2, 0x46, 0x0c, 0x0a, 0x21, 0x88, 0x83, 0x22, 0x18, 0x6f, 0x00,
+  0x03, 0xae, 0x0d, 0x2e, 0xb0, 0x4b, 0x41, 0x19, 0x64, 0x08, 0xaa, 0x6d,
+  0xc4, 0xa0, 0x10, 0x02, 0x3b, 0x50, 0x82, 0xf1, 0x86, 0x32, 0x08, 0x03,
+  0x37, 0xb8, 0xc0, 0x2e, 0x05, 0x65, 0x90, 0x21, 0xd0, 0xc0, 0x60, 0xc4,
+  0xa0, 0x10, 0x82, 0x3d, 0x78, 0x82, 0x39, 0x86, 0x6e, 0xc9, 0x83, 0x39,
+  0x86, 0xe0, 0xd8, 0x83, 0x39, 0x86, 0x60, 0xc8, 0x03, 0x0b, 0xde, 0x40,
+  0x3e, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0,
+  0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x68, 0x0c,
+  0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c,
+  0x00, 0x00, 0x17, 0x03, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00,
+  0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8,
+  0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05,
+  0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92,
+  0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32,
+  0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19,
+  0x21, 0x72, 0x24, 0x07, 0xc8, 0x48, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40,
+  0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00, 0x00, 0x90, 0x00,
+  0x00, 0x00, 0x1b, 0xcc, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x60,
+  0x00, 0x09, 0xa8, 0x88, 0x71, 0x78, 0x07, 0x79, 0x90, 0x87, 0x72, 0x18,
+  0x07, 0x7a, 0x60, 0x87, 0x7c, 0x68, 0x03, 0x79, 0x78, 0x87, 0x7a, 0x70,
+  0x07, 0x72, 0x28, 0x07, 0x72, 0x68, 0x03, 0x72, 0x48, 0x07, 0x7b, 0x48,
+  0x07, 0x72, 0x28, 0x87, 0x36, 0x98, 0x87, 0x78, 0x90, 0x07, 0x7a, 0x68,
+  0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00,
+  0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xc8, 0x21, 0x1d,
+  0xe6, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0xa1, 0x0d, 0xe8, 0x21, 0x1c,
+  0xd2, 0x81, 0x1d, 0xda, 0x60, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0x61, 0x1e,
+  0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x76, 0x28,
+  0x87, 0x79, 0x98, 0x87, 0x36, 0x80, 0x07, 0x79, 0x28, 0x87, 0x71, 0x48,
+  0x87, 0x79, 0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x87, 0x70, 0x20,
+  0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0xc2, 0x1d,
+  0xde, 0xa1, 0x0d, 0xcc, 0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca, 0xa1, 0x0d,
+  0xe0, 0xe1, 0x1d, 0xd2, 0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d,
+  0xca, 0x81, 0x1d, 0xd2, 0xa1, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28,
+  0x07, 0x60, 0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68,
+  0x87, 0x72, 0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28,
+  0x07, 0x79, 0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68, 0x87, 0x36, 0x70,
+  0x87, 0x77, 0x70, 0x87, 0x36, 0x60, 0x87, 0x72, 0x08, 0x07, 0x73, 0x00,
+  0x08, 0x77, 0x78, 0x87, 0x36, 0x48, 0x07, 0x77, 0x30, 0x87, 0x79, 0x68,
+  0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00,
+  0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d,
+  0xd4, 0xa1, 0x1e, 0xda, 0x01, 0x1e, 0xda, 0x80, 0x1e, 0xc2, 0x41, 0x1c,
+  0xd8, 0xa1, 0x1c, 0xe6, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28,
+  0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x77, 0x08, 0x07, 0x77, 0x98,
+  0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40,
+  0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0x60, 0x1e, 0xd2, 0xe1, 0x1c, 0xdc, 0xa1, 0x1c, 0xc8, 0xa1, 0x0d,
+  0xf4, 0xa1, 0x1c, 0xe4, 0xe1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e,
+  0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8,
+  0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0xa0, 0x07, 0x79, 0x08,
+  0x07, 0x78, 0x80, 0x87, 0x74, 0x70, 0x87, 0x73, 0x68, 0x83, 0x76, 0x08,
+  0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20,
+  0xe6, 0x81, 0x1e, 0xc2, 0x61, 0x1c, 0xd6, 0xa1, 0x0d, 0xe0, 0x41, 0x1e,
+  0xde, 0x81, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0xa1, 0x0d,
+  0xc4, 0xa1, 0x1e, 0xcc, 0xc1, 0x1c, 0xca, 0x41, 0x1e, 0xda, 0x60, 0x1e,
+  0xd2, 0x41, 0x1f, 0xca, 0x01, 0xc0, 0x03, 0x80, 0xa8, 0x07, 0x77, 0x98,
+  0x87, 0x70, 0x30, 0x87, 0x72, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68,
+  0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c,
+  0x00, 0xa2, 0x1e, 0xe6, 0xa1, 0x1c, 0xda, 0x60, 0x1e, 0xde, 0xc1, 0x1c,
+  0xe8, 0xa1, 0x0d, 0xcc, 0x81, 0x1d, 0xde, 0x21, 0x1c, 0xe8, 0x01, 0x30,
+  0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x60, 0x03, 0x22, 0x10, 0x40,
+  0x02, 0x2c, 0x40, 0xb5, 0xc1, 0x18, 0x0a, 0x60, 0x01, 0xaa, 0x0d, 0x06,
+  0x61, 0x00, 0x0b, 0x50, 0x6d, 0x30, 0x8a, 0x03, 0x58, 0x80, 0x6a, 0x83,
+  0x61, 0xfc, 0xff, 0xff, 0xff, 0xff, 0x00, 0x48, 0x00, 0xb5, 0x01, 0x39,
+  0xfe, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x18, 0x40, 0x02, 0xaa, 0x0d, 0x06,
+  0x12, 0x00, 0x0b, 0x50, 0x6d, 0x30, 0x12, 0x01, 0x58, 0x80, 0x0a, 0x00,
+  0x00, 0x00, 0x49, 0x18, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x13, 0x8a,
+  0x40, 0x18, 0x88, 0x62, 0x42, 0x60, 0x4c, 0x18, 0x0e, 0x24, 0x01, 0x00,
+  0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x32, 0x22,
+  0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93,
+  0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84,
+  0xa4, 0x4c, 0x10, 0x68, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20,
+  0x00, 0xc3, 0x08, 0x03, 0x70, 0x90, 0x34, 0x45, 0x94, 0x30, 0xf9, 0xb2,
+  0xfb, 0x76, 0x84, 0xe0, 0x0c, 0x04, 0x22, 0xc6, 0x18, 0x63, 0x10, 0x81,
+  0x10, 0x8e, 0x92, 0xa6, 0x88, 0x12, 0x26, 0xff, 0x9f, 0x88, 0x6b, 0xa2,
+  0x22, 0xe2, 0xb7, 0x87, 0x7f, 0x1a, 0x23, 0x00, 0x06, 0x11, 0x8c, 0xe0,
+  0x22, 0x69, 0x8a, 0x28, 0x61, 0xf2, 0x7f, 0x09, 0x60, 0x9e, 0x85, 0x88,
+  0xfe, 0x69, 0x8c, 0x00, 0x18, 0x44, 0x40, 0x84, 0x82, 0x84, 0x10, 0x44,
+  0x39, 0x27, 0x91, 0x2a, 0x03, 0x18, 0x83, 0xd8, 0x1c, 0x41, 0x30, 0x47,
+  0x00, 0x06, 0xc3, 0x08, 0xc2, 0x53, 0x90, 0x70, 0x92, 0x70, 0xd0, 0x01,
+  0x8a, 0x03, 0x01, 0x29, 0xf0, 0x86, 0x11, 0x86, 0x67, 0x10, 0x21, 0x10,
+  0xe6, 0x08, 0x40, 0x61, 0x10, 0x61, 0x10, 0x46, 0x00, 0x00, 0x13, 0xa8,
+  0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70, 0x80, 0x07,
+  0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87, 0x79, 0xc8, 0x03,
+  0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7, 0x51, 0x0e, 0x6d, 0x00,
+  0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60,
+  0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80,
+  0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0,
+  0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x10,
+  0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0,
+  0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60,
+  0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x74, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0,
+  0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60,
+  0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x90, 0x07, 0x76, 0xa0,
+  0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0,
+  0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80,
+  0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x90,
+  0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50,
+  0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20,
+  0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x6d, 0x60,
+  0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xa0,
+  0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x70, 0x20,
+  0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x7a, 0x10,
+  0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee, 0x80, 0x07, 0x7a, 0x10,
+  0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43, 0x98, 0x05, 0x00, 0x80,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x21, 0x4c, 0x03, 0x04, 0x80, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0xc0, 0x10, 0x46, 0x02, 0x02, 0x60, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x20, 0x0b, 0x04, 0x0b, 0x00, 0x00, 0x00, 0x32, 0x1e,
+  0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04,
+  0x43, 0x7a, 0x25, 0x30, 0x02, 0x50, 0x20, 0x45, 0x50, 0x08, 0x05, 0x18,
+  0x50, 0x10, 0x65, 0x50, 0x40, 0x05, 0x56, 0x0a, 0xc5, 0x40, 0x74, 0x2c,
+  0xc1, 0x19, 0x00, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x0c, 0x01,
+  0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab,
+  0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0xc6, 0x63, 0x4c, 0x00, 0xf5,
+  0x50, 0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b,
+  0x62, 0x3c, 0xc3, 0x24, 0x3c, 0x07, 0xe1, 0x20, 0x08, 0x0e, 0x8e, 0xad,
+  0x0c, 0x84, 0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed,
+  0xcd, 0x0d, 0x64, 0x26, 0x06, 0x06, 0x26, 0xc6, 0xa5, 0x06, 0x06, 0x04,
+  0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26, 0x06, 0x06,
+  0x26, 0xc6, 0xa5, 0x06, 0xc6, 0x25, 0x26, 0x65, 0x88, 0x30, 0x11, 0x43,
+  0x8c, 0x67, 0x78, 0x92, 0x87, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36,
+  0x04, 0x99, 0x8e, 0x67, 0x78, 0x86, 0x87, 0xe0, 0x16, 0x96, 0x26, 0xe7,
+  0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6,
+  0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96, 0x36, 0x17, 0x26, 0xc6, 0x56, 0x36,
+  0x44, 0x98, 0x12, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
+  0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74,
+  0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x84, 0x69, 0x21,
+  0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5, 0xc1, 0xa5, 0xb1, 0x95,
+  0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5, 0x99, 0x99, 0x95, 0xc9,
+  0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x95, 0xb9, 0x85, 0x89, 0xb1,
+  0x95, 0x0d, 0x11, 0xa6, 0x86, 0x51, 0x58, 0x9a, 0x9c, 0x8b, 0x5c, 0x99,
+  0x1b, 0x59, 0x99, 0xdc, 0x17, 0x5d, 0x98, 0xdc, 0x59, 0x19, 0x1d, 0xa3,
+  0xb0, 0x34, 0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2,
+  0x2f, 0xb7, 0xb0, 0xb6, 0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34,
+  0x43, 0x90, 0xe9, 0x79, 0x88, 0x09, 0x9a, 0xa2, 0x21, 0xc2, 0x24, 0x91,
+  0x09, 0x4b, 0x93, 0x73, 0x81, 0x7b, 0x9b, 0x4b, 0xa3, 0x4b, 0x7b, 0x73,
+  0xa3, 0x12, 0x96, 0x26, 0xe7, 0x32, 0x56, 0xe6, 0x46, 0x57, 0x26, 0x47,
+  0x29, 0x2c, 0x4d, 0xce, 0xc5, 0xed, 0xed, 0x0b, 0xae, 0x4c, 0x6e, 0x0e,
+  0xae, 0x6c, 0x8c, 0x2e, 0xcd, 0xae, 0x8c, 0x4c, 0x58, 0x9a, 0x9c, 0x4b,
+  0x98, 0xdc, 0xd9, 0x97, 0x5b, 0x58, 0x5b, 0x19, 0x11, 0xb8, 0xb7, 0xb9,
+  0x34, 0xba, 0xb4, 0x37, 0xb7, 0x21, 0xd0, 0x43, 0x4c, 0xd4, 0x54, 0x4d,
+  0xd6, 0x04, 0x4d, 0xd1, 0x74, 0x4d, 0x18, 0xa5, 0xb0, 0x34, 0x39, 0x17,
+  0x33, 0xb9, 0xb0, 0xb3, 0xb6, 0x32, 0x37, 0xba, 0xaf, 0x34, 0x37, 0xb8,
+  0x3a, 0x3a, 0x5a, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64,
+  0x28, 0x35, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66,
+  0x29, 0x7c, 0xc2, 0xd2, 0xe4, 0x5c, 0xe0, 0xca, 0xe4, 0xe6, 0xe0, 0xca,
+  0xc6, 0xe8, 0xd2, 0xec, 0xca, 0x58, 0x8c, 0xbd, 0xb1, 0xbd, 0xc9, 0x0d,
+  0x91, 0x9e, 0x61, 0xd2, 0xa6, 0x6d, 0xaa, 0x26, 0x6e, 0x82, 0xa6, 0x68,
+  0xba, 0xa6, 0x8e, 0xd9, 0x59, 0x99, 0x5b, 0x99, 0x5c, 0x18, 0x5d, 0x19,
+  0x19, 0x0a, 0x0e, 0x5d, 0x19, 0xde, 0xd8, 0xdb, 0x9b, 0x1c, 0x19, 0x91,
+  0x9d, 0xcc, 0x97, 0x59, 0x0a, 0x0d, 0x33, 0xb6, 0xb7, 0x30, 0x3a, 0x19,
+  0x22, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x43, 0xa4, 0xc7,
+  0x98, 0xb4, 0xe9, 0x9b, 0xaa, 0x89, 0x9b, 0xa0, 0x09, 0x0c, 0xa6, 0x6b,
+  0x0a, 0x03, 0x2a, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65,
+  0x72, 0x7c, 0xc2, 0xd2, 0xe4, 0x5c, 0xc4, 0xea, 0xcc, 0xcc, 0xca, 0xe4,
+  0xbe, 0xe6, 0xd2, 0xf4, 0xca, 0x28, 0x85, 0xa5, 0xc9, 0xb9, 0xb0, 0xbd,
+  0x8d, 0x85, 0xd1, 0xa5, 0xbd, 0xb9, 0x7d, 0xa5, 0xb9, 0x91, 0x95, 0xe1,
+  0x11, 0x09, 0x4b, 0x93, 0x73, 0x91, 0x2b, 0x0b, 0x23, 0x23, 0x15, 0x96,
+  0x26, 0xe7, 0x32, 0x47, 0x27, 0x57, 0x37, 0x46, 0xf7, 0x45, 0x97, 0x07,
+  0x57, 0xf6, 0x95, 0xe6, 0x66, 0xf6, 0x46, 0xc3, 0x8c, 0xed, 0x2d, 0x8c,
+  0x6e, 0x86, 0xc6, 0x9b, 0x99, 0xd9, 0x5c, 0x19, 0x1d, 0x0d, 0xa9, 0xb1,
+  0xb7, 0x32, 0x33, 0x33, 0x1a, 0x47, 0x63, 0x6f, 0x65, 0x66, 0x66, 0x34,
+  0x84, 0xc6, 0xde, 0xca, 0xcc, 0xcc, 0x86, 0xa0, 0xc1, 0x43, 0x3c, 0xc5,
+  0x43, 0x4c, 0x68, 0x30, 0xa5, 0xc1, 0x53, 0x3c, 0xc5, 0x43, 0x4c, 0x68,
+  0x30, 0xa9, 0xc1, 0xb3, 0x3c, 0xc5, 0x43, 0x4c, 0x68, 0x30, 0xad, 0xc1,
+  0xc3, 0x3c, 0xc5, 0x43, 0x4c, 0x68, 0x30, 0xb1, 0x01, 0xa3, 0xb0, 0x34,
+  0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0xaf, 0xb9,
+  0x34, 0xbd, 0x32, 0x5e, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f,
+  0x74, 0x79, 0x70, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73,
+  0x69, 0x7a, 0x65, 0x4c, 0xb2, 0xaa, 0xac, 0x88, 0xca, 0xc6, 0xde, 0xc8,
+  0xca, 0x68, 0x90, 0x95, 0x8d, 0xbd, 0x91, 0x95, 0x0d, 0x21, 0x83, 0x47,
+  0x99, 0xc6, 0x60, 0x22, 0x83, 0x07, 0x99, 0xca, 0xe0, 0x19, 0x9e, 0x61,
+  0x32, 0x83, 0xe9, 0x0c, 0xa6, 0x36, 0x98, 0xdc, 0xe0, 0x41, 0xa6, 0x37,
+  0x78, 0x8a, 0x09, 0x9a, 0xe0, 0x60, 0xba, 0xa6, 0x38, 0xe0, 0x12, 0x96,
+  0x26, 0xe7, 0x42, 0x57, 0x86, 0x47, 0x57, 0x27, 0x57, 0x46, 0x25, 0x2c,
+  0x4d, 0xce, 0x65, 0x2e, 0xac, 0x0d, 0x8e, 0xad, 0x8c, 0x18, 0x5d, 0x19,
+  0x1e, 0x5d, 0x9d, 0x5c, 0x99, 0x0c, 0x19, 0x8f, 0x19, 0xdb, 0x5b, 0x18,
+  0x1d, 0x0b, 0xc8, 0x5c, 0x58, 0x1b, 0x1c, 0x5b, 0x99, 0x0f, 0x09, 0xba,
+  0x32, 0xbc, 0xac, 0x21, 0xd4, 0x73, 0x4c, 0x73, 0x30, 0x95, 0xc1, 0x43,
+  0x3c, 0xc3, 0x44, 0x07, 0x13, 0x34, 0xd5, 0xc1, 0x74, 0x4d, 0x76, 0xc0,
+  0x82, 0xae, 0x0c, 0xaf, 0xca, 0x6a, 0x08, 0xf5, 0x34, 0xd3, 0x1c, 0x4c,
+  0x65, 0xf0, 0x0c, 0xcf, 0x30, 0xd1, 0xc1, 0x04, 0x4d, 0x75, 0x30, 0x5d,
+  0x13, 0x1e, 0x70, 0x09, 0x4b, 0x93, 0x73, 0x99, 0x0b, 0x6b, 0x83, 0x63,
+  0x2b, 0x93, 0xe3, 0x31, 0x17, 0xd6, 0x06, 0xc7, 0x56, 0x26, 0xc7, 0x60,
+  0x6e, 0x88, 0xf4, 0x38, 0x93, 0x1e, 0x4c, 0x65, 0xf0, 0x10, 0xcf, 0x30,
+  0x41, 0xd3, 0x1e, 0x4c, 0xd7, 0xc4, 0x07, 0x43, 0x9c, 0x29, 0x9b, 0xbc,
+  0x49, 0x0c, 0x26, 0x39, 0x98, 0xee, 0x60, 0xca, 0x83, 0xa9, 0x0f, 0x86,
+  0x18, 0x0b, 0x30, 0x4d, 0x93, 0x1f, 0x8c, 0x88, 0xd8, 0x81, 0x1d, 0xec,
   0xa1, 0x1d, 0xdc, 0xa0, 0x1d, 0xde, 0x81, 0x1c, 0xea, 0x81, 0x1d, 0xca,
   0xc1, 0x0d, 0xcc, 0x81, 0x1d, 0xc2, 0xe1, 0x1c, 0xe6, 0x61, 0x8a, 0x10,
   0x0c, 0x23, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x48, 0x07,
@@ -957,885 +1750,72 @@ const unsigned char sdl_metallib[] = {
   0x77, 0x80, 0x07, 0x7a, 0x48, 0x87, 0x77, 0x70, 0x87, 0x79, 0x98, 0x32,
   0x28, 0x8c, 0x33, 0x82, 0x09, 0x87, 0x74, 0x90, 0x07, 0x37, 0x30, 0x07,
   0x79, 0x08, 0x87, 0x73, 0x68, 0x87, 0x72, 0x70, 0x07, 0x7a, 0x98, 0x12,
-  0xc8, 0x01, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00,
-  0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88,
-  0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73,
-  0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e,
-  0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30,
-  0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8,
-  0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b,
-  0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76,
-  0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e,
-  0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e,
-  0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61,
-  0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4,
-  0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76,
-  0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37,
-  0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76,
-  0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71,
-  0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e,
-  0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1,
-  0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61,
-  0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90,
-  0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8,
-  0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc,
-  0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7,
-  0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78,
-  0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f,
-  0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f,
-  0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1,
-  0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0,
-  0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0,
-  0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b,
-  0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c,
-  0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61,
-  0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1,
-  0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc,
-  0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4,
-  0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79,
-  0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72,
-  0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e,
-  0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1,
-  0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8,
-  0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8,
-  0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00,
-  0x71, 0x20, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x06, 0x10, 0xb1, 0x5d,
-  0xf9, 0x73, 0xce, 0x83, 0xfd, 0x45, 0x04, 0x18, 0x0c, 0xd1, 0x4c, 0x16,
-  0xb0, 0x01, 0x48, 0xe4, 0x4b, 0x00, 0xf3, 0x2c, 0xc4, 0x3f, 0x11, 0xd7,
-  0x44, 0x45, 0xc4, 0x6f, 0x0f, 0x7e, 0x85, 0x17, 0xb7, 0x0d, 0x00, 0x00,
-  0x61, 0x20, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c,
-  0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xc4, 0x46, 0x00, 0x48,
-  0xd5, 0xc0, 0x08, 0x00, 0x81, 0x11, 0x00, 0x00, 0x23, 0x06, 0x8a, 0x10,
-  0x4c, 0x46, 0x81, 0x0c, 0x84, 0x10, 0x10, 0x52, 0x2c, 0x10, 0xe4, 0x93,
-  0x41, 0x40, 0x0c, 0x00, 0x02, 0x00, 0x00, 0x00, 0x5b, 0x86, 0x20, 0xb8,
-  0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b,
-  0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x10, 0x0d, 0x00, 0x00,
-  0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00,
-  0x41, 0x03, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00,
-  0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49,
-  0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19,
-  0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42,
-  0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44, 0x24,
-  0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21, 0x72,
-  0x24, 0x07, 0xc8, 0x48, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0,
-  0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00, 0x00, 0x90, 0x00, 0x00, 0x00,
-  0x1b, 0xcc, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x60, 0x00, 0x09,
-  0xa8, 0x88, 0x71, 0x78, 0x07, 0x79, 0x90, 0x87, 0x72, 0x18, 0x07, 0x7a,
-  0x60, 0x87, 0x7c, 0x68, 0x03, 0x79, 0x78, 0x87, 0x7a, 0x70, 0x07, 0x72,
-  0x28, 0x07, 0x72, 0x68, 0x03, 0x72, 0x48, 0x07, 0x7b, 0x48, 0x07, 0x72,
-  0x28, 0x87, 0x36, 0x98, 0x87, 0x78, 0x90, 0x07, 0x7a, 0x68, 0x03, 0x73,
-  0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xcc, 0x21,
-  0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xc8, 0x21, 0x1d, 0xe6, 0x21,
-  0x1c, 0xc4, 0x81, 0x1d, 0xca, 0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xd2, 0x81,
-  0x1d, 0xda, 0x60, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0x61, 0x1e, 0x00, 0x73,
-  0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x76, 0x28, 0x87, 0x79,
-  0x98, 0x87, 0x36, 0x80, 0x07, 0x79, 0x28, 0x87, 0x71, 0x48, 0x87, 0x79,
-  0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x87, 0x70, 0x20, 0x07, 0xc0,
-  0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1,
-  0x0d, 0xcc, 0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca, 0xa1, 0x0d, 0xe0, 0xe1,
-  0x1d, 0xd2, 0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xca, 0x81,
-  0x1d, 0xd2, 0xa1, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x60,
-  0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72,
-  0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79,
-  0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68, 0x87, 0x36, 0x70, 0x87, 0x77,
-  0x70, 0x87, 0x36, 0x60, 0x87, 0x72, 0x08, 0x07, 0x73, 0x00, 0x08, 0x77,
-  0x78, 0x87, 0x36, 0x48, 0x07, 0x77, 0x30, 0x87, 0x79, 0x68, 0x03, 0x73,
-  0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41,
-  0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xd4, 0xa1,
-  0x1e, 0xda, 0x01, 0x1e, 0xda, 0x80, 0x1e, 0xc2, 0x41, 0x1c, 0xd8, 0xa1,
-  0x1c, 0xe6, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80,
-  0x70, 0x87, 0x77, 0x68, 0x03, 0x77, 0x08, 0x07, 0x77, 0x98, 0x87, 0x36,
-  0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80,
-  0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x60,
-  0x1e, 0xd2, 0xe1, 0x1c, 0xdc, 0xa1, 0x1c, 0xc8, 0xa1, 0x0d, 0xf4, 0xa1,
-  0x1c, 0xe4, 0xe1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0,
-  0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72,
-  0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0xa0, 0x07, 0x79, 0x08, 0x07, 0x78,
-  0x80, 0x87, 0x74, 0x70, 0x87, 0x73, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a,
-  0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xe6, 0x81,
-  0x1e, 0xc2, 0x61, 0x1c, 0xd6, 0xa1, 0x0d, 0xe0, 0x41, 0x1e, 0xde, 0x81,
-  0x1e, 0xca, 0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0xa1, 0x0d, 0xc4, 0xa1,
-  0x1e, 0xcc, 0xc1, 0x1c, 0xca, 0x41, 0x1e, 0xda, 0x60, 0x1e, 0xd2, 0x41,
-  0x1f, 0xca, 0x01, 0xc0, 0x03, 0x80, 0xa8, 0x07, 0x77, 0x98, 0x87, 0x70,
-  0x30, 0x87, 0x72, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70,
-  0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xa2,
-  0x1e, 0xe6, 0xa1, 0x1c, 0xda, 0x60, 0x1e, 0xde, 0xc1, 0x1c, 0xe8, 0xa1,
-  0x0d, 0xcc, 0x81, 0x1d, 0xde, 0x21, 0x1c, 0xe8, 0x01, 0x30, 0x87, 0x70,
-  0x60, 0x87, 0x79, 0x28, 0x07, 0x60, 0x03, 0x22, 0x0c, 0x40, 0x02, 0x2c,
-  0x40, 0xb5, 0x01, 0x19, 0x08, 0x20, 0x01, 0x16, 0xa0, 0xda, 0x60, 0x10,
-  0x05, 0xb0, 0x00, 0xd5, 0x06, 0xa3, 0x38, 0x80, 0x05, 0xa8, 0x36, 0x18,
-  0xc6, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x80, 0x04, 0x50, 0x1b, 0x90, 0xe3,
-  0xff, 0xff, 0xff, 0xff, 0x07, 0x80, 0x01, 0x24, 0xa0, 0xda, 0x60, 0x20,
-  0x01, 0xb0, 0x00, 0xd5, 0x06, 0x23, 0x11, 0x80, 0x05, 0xa8, 0x00, 0x00,
-  0x49, 0x18, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x13, 0x8a, 0x40, 0x18,
-  0x88, 0x62, 0x42, 0x60, 0x4c, 0x18, 0x0e, 0x24, 0x01, 0x00, 0x00, 0x00,
-  0x89, 0x20, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09,
-  0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3,
-  0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c,
-  0x10, 0x7c, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00, 0x83,
-  0x08, 0x41, 0x30, 0x8c, 0x30, 0x00, 0x07, 0x49, 0x53, 0x44, 0x09, 0x93,
-  0x2f, 0xbb, 0x6f, 0x47, 0x08, 0xce, 0x40, 0x20, 0x82, 0x10, 0x42, 0x06,
-  0x11, 0x0a, 0xe1, 0x28, 0x69, 0x8a, 0x28, 0x61, 0xf2, 0xff, 0x89, 0xb8,
-  0x26, 0x2a, 0x22, 0x7e, 0x7b, 0xf8, 0xa7, 0x31, 0x02, 0x60, 0x10, 0xe1,
-  0x08, 0x4e, 0x93, 0xa6, 0x88, 0x12, 0x26, 0xff, 0x9f, 0x88, 0x6b, 0xa2,
-  0x22, 0xe2, 0xb7, 0x87, 0x1f, 0x88, 0x22, 0x00, 0xfb, 0xa7, 0x31, 0x02,
-  0x60, 0x10, 0x21, 0x09, 0x2e, 0x92, 0xa6, 0x88, 0x12, 0x26, 0xff, 0x97,
-  0x00, 0xe6, 0x59, 0x88, 0xe8, 0x9f, 0xc6, 0x08, 0x80, 0x41, 0x84, 0x45,
-  0x28, 0x48, 0x08, 0x62, 0x18, 0xa4, 0x18, 0xb5, 0x32, 0x00, 0x42, 0xe8,
-  0xcd, 0x11, 0x80, 0xc1, 0x1c, 0x41, 0x30, 0x8c, 0x20, 0x44, 0x25, 0x09,
-  0x8a, 0x89, 0x28, 0xa7, 0x04, 0x44, 0x0b, 0x12, 0x10, 0x13, 0x72, 0x4a,
-  0x40, 0x76, 0x20, 0x20, 0x05, 0xe2, 0x30, 0xc2, 0x10, 0x0d, 0x22, 0x04,
-  0xc2, 0x1c, 0x01, 0x28, 0x0c, 0x22, 0x10, 0xc2, 0x08, 0x00, 0x00, 0x00,
-  0x13, 0xa8, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70,
-  0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87, 0x79,
-  0xc8, 0x03, 0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7, 0x51, 0x0e,
-  0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a, 0x80, 0x07,
-  0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78, 0xa0, 0x07,
-  0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07,
-  0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07,
-  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x60, 0x07,
-  0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06,
-  0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
-  0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76, 0xa0, 0x07,
-  0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07,
-  0x74, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06,
-  0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
-  0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74, 0xa0, 0x07,
-  0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x90, 0x07,
-  0x76, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07,
-  0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07,
-  0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f,
-  0x71, 0x90, 0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07,
-  0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75, 0x60, 0x07,
-  0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07,
-  0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07,
-  0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x10, 0x07,
-  0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07,
-  0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee, 0x80, 0x07,
-  0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43, 0x18, 0x07,
-  0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x21, 0x0c, 0x04, 0x04,
-  0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x10, 0xa6, 0x02, 0x02, 0x60,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x08, 0x73, 0x01, 0x01, 0x30, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x90, 0x05, 0x02, 0x00, 0x0b, 0x00, 0x00, 0x00,
-  0x32, 0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47,
-  0xc6, 0x04, 0x43, 0x8a, 0x25, 0x30, 0x02, 0x50, 0x20, 0x45, 0x50, 0x08,
-  0x05, 0x18, 0x50, 0x10, 0x65, 0x50, 0x40, 0x05, 0x56, 0x0a, 0xc5, 0x40,
-  0x7c, 0x04, 0x80, 0xf2, 0x58, 0x82, 0x23, 0x00, 0x79, 0x18, 0x00, 0x00,
-  0x1d, 0x01, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25,
-  0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x46, 0x74, 0x60,
-  0x40, 0x16, 0x51, 0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3,
-  0x2b, 0x1b, 0x62, 0x44, 0x04, 0x26, 0x44, 0x08, 0xdd, 0x20, 0x08, 0x0e,
-  0x8e, 0xad, 0x0c, 0x84, 0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e,
-  0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x26, 0x06, 0x06, 0x26, 0xc6, 0x85, 0x66,
-  0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26,
-  0x06, 0x06, 0x26, 0xc6, 0x85, 0x66, 0x26, 0x65, 0x88, 0x80, 0x11, 0x43,
-  0x8c, 0x88, 0x88, 0x94, 0xa8, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36,
-  0x04, 0xc1, 0x8e, 0x88, 0x88, 0x88, 0xa8, 0xe0, 0x16, 0x96, 0x26, 0xe7,
-  0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6,
-  0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96, 0x36, 0x17, 0x26, 0xc6, 0x56, 0x36,
-  0x44, 0xc0, 0x12, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
-  0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74,
-  0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x04, 0x6c, 0x21,
-  0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5, 0xc1, 0xa5, 0xb1, 0x95,
-  0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5, 0x99, 0x99, 0x95, 0xc9,
-  0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x95, 0xb9, 0x85, 0x89, 0xb1,
-  0x95, 0x0d, 0x11, 0xb0, 0x86, 0x51, 0x58, 0x9a, 0x9c, 0x8b, 0x5c, 0x99,
-  0x1b, 0x59, 0x99, 0xdc, 0x17, 0x5d, 0x98, 0xdc, 0x59, 0x19, 0x1d, 0xa3,
-  0xb0, 0x34, 0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2,
-  0x2f, 0xb7, 0xb0, 0xb6, 0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34,
-  0x43, 0x10, 0xec, 0x89, 0x0a, 0x0c, 0xc2, 0xa2, 0x21, 0x02, 0x26, 0x91,
-  0x09, 0x4b, 0x93, 0x73, 0x81, 0x7b, 0x9b, 0x4b, 0xa3, 0x4b, 0x7b, 0x73,
-  0xa3, 0x12, 0x96, 0x26, 0xe7, 0x32, 0x56, 0xe6, 0x46, 0x57, 0x26, 0x47,
-  0x29, 0x2c, 0x4d, 0xce, 0xc5, 0xed, 0xed, 0x0b, 0xae, 0x4c, 0x6e, 0x0e,
-  0xae, 0x6c, 0x8c, 0x2e, 0xcd, 0xae, 0x8c, 0x4c, 0x58, 0x9a, 0x9c, 0x4b,
-  0x98, 0xdc, 0xd9, 0x97, 0x5b, 0x58, 0x5b, 0x19, 0x11, 0xb8, 0xb7, 0xb9,
-  0x34, 0xba, 0xb4, 0x37, 0xb7, 0x21, 0x50, 0x54, 0x60, 0x14, 0x56, 0x61,
-  0x16, 0x06, 0x61, 0x11, 0x76, 0x61, 0x18, 0xa5, 0xb0, 0x34, 0x39, 0x17,
-  0x33, 0xb9, 0xb0, 0xb3, 0xb6, 0x32, 0x37, 0xba, 0xaf, 0x34, 0x37, 0xb8,
-  0x3a, 0x3a, 0x66, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64,
-  0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x44, 0x76,
-  0x32, 0x5f, 0x66, 0x29, 0x7c, 0xc2, 0xd2, 0xe4, 0x5c, 0xe0, 0xca, 0xe4,
-  0xe6, 0xe0, 0xca, 0xc6, 0xe8, 0xd2, 0xec, 0xca, 0x68, 0x98, 0xb1, 0xbd,
-  0x85, 0xd1, 0xc9, 0x10, 0xa1, 0x2b, 0xc3, 0x1b, 0x7b, 0x7b, 0x93, 0x23,
-  0x1b, 0x22, 0x45, 0x04, 0xa6, 0x61, 0x1b, 0x56, 0x61, 0x1c, 0x06, 0x61,
-  0x1d, 0x76, 0x61, 0x1e, 0x95, 0xb0, 0x34, 0x39, 0x17, 0xb1, 0x3a, 0x33,
-  0xb3, 0x32, 0x39, 0x3e, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66,
-  0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x94, 0xc2, 0xd2, 0xe4, 0x5c,
-  0xd8, 0xde, 0xc6, 0xc2, 0xe8, 0xd2, 0xde, 0xdc, 0xbe, 0xd2, 0xdc, 0xc8,
-  0xca, 0xf0, 0x88, 0x84, 0xa5, 0xc9, 0xb9, 0xc8, 0x95, 0x85, 0x91, 0x31,
-  0x0a, 0x4b, 0x93, 0x73, 0x09, 0x93, 0x3b, 0xfb, 0xa2, 0xcb, 0x83, 0x2b,
-  0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0xe3, 0x15, 0x96, 0x26, 0xe7, 0x12, 0x26,
-  0x77, 0xf6, 0x45, 0x97, 0x07, 0x57, 0xf6, 0x15, 0xc6, 0x96, 0x76, 0xe6,
-  0xf6, 0x35, 0x97, 0xa6, 0x57, 0xc6, 0x61, 0xec, 0x8d, 0x6d, 0x08, 0x18,
-  0x44, 0x07, 0x06, 0x06, 0x58, 0x18, 0x44, 0x06, 0x26, 0x06, 0x51, 0x11,
-  0x11, 0xd8, 0x18, 0x60, 0x64, 0x10, 0x19, 0x58, 0x19, 0x44, 0x06, 0x06,
-  0x61, 0x11, 0x76, 0x61, 0x66, 0x40, 0x2a, 0x2c, 0x4d, 0xce, 0x65, 0x8e,
-  0x4e, 0xae, 0x6e, 0x8c, 0xee, 0x8b, 0x2e, 0x0f, 0xae, 0xec, 0x2b, 0xcd,
-  0xcd, 0xec, 0x8d, 0x86, 0x19, 0xdb, 0x5b, 0x18, 0xdd, 0x0c, 0x8d, 0x37,
-  0x33, 0xb3, 0xb9, 0x32, 0x3a, 0x1a, 0x52, 0x63, 0x6f, 0x65, 0x66, 0x66,
-  0x34, 0x8e, 0xc6, 0xde, 0xca, 0xcc, 0xcc, 0x68, 0x08, 0x8d, 0xbd, 0x95,
-  0x99, 0x99, 0x0d, 0x41, 0x83, 0xa8, 0x88, 0x8c, 0xa8, 0xc0, 0xd2, 0x00,
-  0x53, 0x83, 0xc8, 0x88, 0x8c, 0xa8, 0xc0, 0xd2, 0x00, 0x5b, 0x83, 0x88,
-  0x89, 0x8c, 0xa8, 0xc0, 0xd2, 0x00, 0x63, 0x83, 0xa8, 0x89, 0x8c, 0xa8,
-  0xc0, 0xd2, 0x00, 0x6b, 0x03, 0x26, 0x59, 0x55, 0x56, 0x44, 0x65, 0x63,
-  0x6f, 0x64, 0x65, 0x34, 0xc8, 0xca, 0xc6, 0xde, 0xc8, 0xca, 0x86, 0x90,
-  0x41, 0xb4, 0x60, 0x60, 0x80, 0x85, 0x41, 0x94, 0x60, 0x62, 0x10, 0x11,
-  0x11, 0x81, 0x8d, 0x01, 0x86, 0x06, 0x98, 0x1b, 0x60, 0x64, 0x10, 0x25,
-  0x58, 0x19, 0x44, 0x06, 0x06, 0x61, 0x6f, 0x80, 0x5d, 0x18, 0x1c, 0x70,
-  0x09, 0x4b, 0x93, 0x73, 0xa1, 0x2b, 0xc3, 0xa3, 0xab, 0x93, 0x2b, 0xa3,
-  0x12, 0x96, 0x26, 0xe7, 0x32, 0x17, 0xd6, 0x06, 0xc7, 0x56, 0x46, 0x8c,
-  0xae, 0x0c, 0x8f, 0xae, 0x4e, 0xae, 0x4c, 0x86, 0x8c, 0xc7, 0x8c, 0xed,
-  0x2d, 0x8c, 0x8e, 0x05, 0x64, 0x2e, 0xac, 0x0d, 0x8e, 0xad, 0xcc, 0x87,
-  0x04, 0x5d, 0x19, 0x5e, 0xd6, 0x10, 0x2a, 0x42, 0x30, 0x39, 0xc0, 0xc4,
-  0x20, 0x2a, 0x22, 0x02, 0x9b, 0x03, 0x0c, 0xc2, 0xe8, 0x00, 0xbb, 0xb0,
-  0x3a, 0xa0, 0x47, 0x57, 0x86, 0x47, 0x57, 0x27, 0x57, 0x26, 0x43, 0xf6,
-  0x15, 0x26, 0x27, 0x17, 0x96, 0xc7, 0x63, 0xc6, 0xf6, 0x16, 0x46, 0xc7,
-  0x02, 0x32, 0x17, 0xd6, 0x06, 0xc7, 0x56, 0xe6, 0xc3, 0x82, 0xae, 0x0c,
-  0xaf, 0xca, 0x6a, 0x08, 0x15, 0x39, 0x98, 0x1c, 0x60, 0x62, 0x10, 0x11,
-  0x11, 0x81, 0xcd, 0x01, 0x06, 0x61, 0x77, 0x80, 0x5d, 0x18, 0x1e, 0x70,
-  0x09, 0x4b, 0x93, 0x73, 0x99, 0x0b, 0x6b, 0x83, 0x63, 0x2b, 0x93, 0xe3,
-  0x31, 0x17, 0xd6, 0x06, 0xc7, 0x56, 0x26, 0xc7, 0x60, 0x6e, 0x88, 0x14,
-  0x3d, 0x98, 0x1e, 0x60, 0x62, 0x10, 0x15, 0x11, 0x81, 0x41, 0xd8, 0x1e,
-  0x60, 0x17, 0xc6, 0x07, 0x43, 0x1c, 0x2c, 0xc3, 0x3e, 0xec, 0x0c, 0xb0,
-  0x38, 0xc0, 0xec, 0x00, 0xcb, 0x03, 0xac, 0x0f, 0x86, 0x18, 0x0e, 0x80,
-  0x4d, 0x98, 0x1f, 0xf0, 0x79, 0x6b, 0x73, 0x4b, 0x83, 0x7b, 0xa3, 0x2b,
-  0x73, 0xa3, 0x03, 0x19, 0x43, 0x0b, 0x93, 0xe3, 0x33, 0x95, 0xd6, 0x06,
-  0xc7, 0x56, 0x06, 0x32, 0xb4, 0xb2, 0x02, 0x42, 0x25, 0x14, 0x14, 0x34,
-  0x44, 0xc0, 0x42, 0x61, 0x88, 0x81, 0x81, 0x02, 0x26, 0x0a, 0x1c, 0x34,
-  0xc4, 0xc0, 0x46, 0x01, 0x1b, 0x05, 0x0e, 0x1a, 0x11, 0xb1, 0x03, 0x3b,
-  0xd8, 0x43, 0x3b, 0xb8, 0x41, 0x3b, 0xbc, 0x03, 0x39, 0xd4, 0x03, 0x3b,
-  0x94, 0x83, 0x1b, 0x98, 0x03, 0x3b, 0x84, 0xc3, 0x39, 0xcc, 0xc3, 0x14,
-  0x21, 0x18, 0x46, 0x28, 0xec, 0xc0, 0x0e, 0xf6, 0xd0, 0x0e, 0x6e, 0x90,
-  0x0e, 0xe4, 0x50, 0x0e, 0xee, 0x40, 0x0f, 0x53, 0x82, 0x62, 0xc4, 0x12,
-  0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0x60, 0x0f, 0xe5, 0x20, 0x0f, 0xf3, 0x90,
-  0x0e, 0xef, 0xe0, 0x0e, 0x53, 0x02, 0x63, 0x04, 0x15, 0x0e, 0xe9, 0x20,
-  0x0f, 0x6e, 0xc0, 0x0e, 0xe1, 0xe0, 0x0e, 0xe7, 0x50, 0x0f, 0xe1, 0x70,
-  0x0e, 0xe5, 0xf0, 0x0b, 0xf6, 0x50, 0x0e, 0xf2, 0x30, 0x0f, 0xe9, 0xf0,
-  0x0e, 0xee, 0x30, 0x25, 0x40, 0x46, 0x4c, 0xe1, 0x90, 0x0e, 0xf2, 0xe0,
-  0x06, 0xe3, 0xf0, 0x0e, 0xed, 0x00, 0x0f, 0xe9, 0xc0, 0x0e, 0xe5, 0xf0,
-  0x0b, 0xef, 0x00, 0x0f, 0xf4, 0x90, 0x0e, 0xef, 0xe0, 0x0e, 0xf3, 0x30,
-  0x65, 0x50, 0x18, 0x67, 0x04, 0x13, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0x60,
-  0x0e, 0xf2, 0x10, 0x0e, 0xe7, 0xd0, 0x0e, 0xe5, 0xe0, 0x0e, 0xf4, 0x30,
-  0x25, 0xf8, 0x03, 0x00, 0x79, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00,
-  0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88,
-  0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73,
-  0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e,
-  0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30,
-  0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8,
-  0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b,
-  0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76,
-  0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e,
-  0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e,
-  0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61,
-  0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4,
-  0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76,
-  0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37,
-  0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76,
-  0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71,
-  0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e,
-  0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1,
-  0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61,
-  0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90,
-  0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8,
-  0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc,
-  0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7,
-  0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78,
-  0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f,
-  0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f,
-  0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1,
-  0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0,
-  0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0,
-  0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b,
-  0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c,
-  0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61,
-  0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1,
-  0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc,
-  0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4,
-  0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79,
-  0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72,
-  0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e,
-  0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1,
-  0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8,
-  0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8,
-  0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00,
-  0x71, 0x20, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x26, 0x10, 0x06, 0x00,
-  0x12, 0xf9, 0x12, 0xc0, 0x3c, 0x0b, 0xf1, 0x4f, 0xc4, 0x35, 0x51, 0x11,
-  0xf1, 0xdb, 0xc3, 0x0f, 0x44, 0x11, 0x80, 0xf9, 0x15, 0x5e, 0xdc, 0xb6,
-  0x05, 0x34, 0x00, 0x12, 0xf9, 0x83, 0x33, 0xf9, 0xd5, 0x5d, 0xdc, 0xb6,
-  0x0d, 0x6c, 0x00, 0x12, 0xf9, 0x12, 0xc0, 0x3c, 0x0b, 0xf1, 0x4f, 0xc4,
-  0x35, 0x51, 0x11, 0xf1, 0xdb, 0x83, 0x5f, 0xe1, 0xc5, 0x6d, 0x1b, 0x00,
-  0xc4, 0x76, 0xe5, 0x2f, 0xbb, 0xef, 0x5f, 0x44, 0x80, 0xc1, 0x10, 0xcd,
-  0x04, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x3b, 0x00, 0x00, 0x00,
-  0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
-  0xa4, 0xe7, 0x18, 0x0a, 0xcf, 0x1b, 0x6b, 0x00, 0x02, 0x81, 0xe6, 0x08,
-  0x00, 0xc9, 0x11, 0x80, 0x1a, 0xa0, 0x38, 0x03, 0x40, 0x61, 0x0e, 0x42,
-  0x0c, 0xc4, 0x40, 0x0c, 0xc2, 0x60, 0x06, 0x80, 0xc0, 0x18, 0x01, 0x08,
-  0x82, 0x20, 0xfe, 0xcd, 0x00, 0x8c, 0x00, 0x00, 0x23, 0x06, 0xca, 0x10,
-  0x84, 0x81, 0xc3, 0x44, 0x47, 0x82, 0x04, 0x83, 0x0c, 0x41, 0xc1, 0x8c,
-  0x18, 0x2c, 0x43, 0x40, 0x06, 0x8f, 0x33, 0x85, 0x41, 0xb2, 0x28, 0xc3,
-  0x18, 0x42, 0x20, 0x06, 0x73, 0x0c, 0x43, 0x40, 0x06, 0x23, 0x06, 0xcb,
-  0x10, 0x9c, 0x81, 0x14, 0x59, 0x65, 0xc0, 0x38, 0x8d, 0x31, 0x86, 0x10,
-  0x94, 0xc1, 0x1c, 0xc3, 0x10, 0x90, 0xc1, 0x5d, 0x7b, 0x29, 0x28, 0x83,
-  0x0c, 0x81, 0x43, 0x19, 0x11, 0xc0, 0x87, 0xb8, 0x32, 0xde, 0xc0, 0x85,
-  0x41, 0x1b, 0x5c, 0xb0, 0x97, 0x82, 0x32, 0xc8, 0x10, 0x50, 0xda, 0x88,
-  0x41, 0x21, 0x04, 0x74, 0x60, 0x04, 0xe3, 0x0d, 0x61, 0x60, 0x06, 0x6f,
-  0x70, 0xc1, 0x5e, 0x0a, 0xca, 0x20, 0x43, 0x90, 0x7d, 0x23, 0x06, 0x85,
-  0x10, 0xe4, 0xc1, 0x12, 0x8c, 0x37, 0x98, 0xc1, 0x1a, 0xc0, 0xc1, 0x05,
-  0x7b, 0x29, 0x28, 0x83, 0x0c, 0x81, 0x47, 0x06, 0x23, 0x06, 0x85, 0x10,
-  0xf8, 0x01, 0x14, 0xcc, 0x31, 0x84, 0xc1, 0xb2, 0x07, 0x73, 0x0c, 0xc1,
-  0xd1, 0x07, 0x73, 0x0c, 0xc1, 0xb0, 0x07, 0x16, 0x4c, 0xf2, 0xc9, 0x20,
-  0x20, 0x06, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x5b, 0x06, 0x26, 0x20,
-  0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
-  0xa4, 0x0c, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde,
-  0x21, 0x0c, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00,
-  0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91,
-  0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c,
-  0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02,
-  0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x49,
-  0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52, 0x80,
-  0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8, 0x48, 0x11, 0x62, 0xa8, 0xa0,
-  0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00, 0x00,
-  0x92, 0x00, 0x00, 0x00, 0x1b, 0xcc, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff,
-  0x01, 0x60, 0x00, 0x09, 0xa8, 0x88, 0x71, 0x78, 0x07, 0x79, 0x90, 0x87,
-  0x72, 0x18, 0x07, 0x7a, 0x60, 0x87, 0x7c, 0x68, 0x03, 0x79, 0x78, 0x87,
-  0x7a, 0x70, 0x07, 0x72, 0x28, 0x07, 0x72, 0x68, 0x03, 0x72, 0x48, 0x07,
-  0x7b, 0x48, 0x07, 0x72, 0x28, 0x87, 0x36, 0x98, 0x87, 0x78, 0x90, 0x07,
-  0x7a, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07,
-  0x74, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xc8,
-  0x21, 0x1d, 0xe6, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0xa1, 0x0d, 0xe8,
-  0x21, 0x1c, 0xd2, 0x81, 0x1d, 0xda, 0x60, 0x1c, 0xc2, 0x81, 0x1d, 0xd8,
-  0x61, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08,
-  0x76, 0x28, 0x87, 0x79, 0x98, 0x87, 0x36, 0x80, 0x07, 0x79, 0x28, 0x87,
-  0x71, 0x48, 0x87, 0x79, 0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x87,
-  0x70, 0x20, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00,
-  0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xcc, 0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca,
-  0xa1, 0x0d, 0xe0, 0xe1, 0x1d, 0xd2, 0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4,
-  0xa1, 0x0d, 0xca, 0x81, 0x1d, 0xd2, 0xa1, 0x1d, 0x00, 0x7a, 0x90, 0x87,
-  0x7a, 0x28, 0x07, 0x60, 0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90, 0x87,
-  0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70, 0x07,
-  0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68, 0x87,
-  0x36, 0x70, 0x87, 0x77, 0x70, 0x87, 0x36, 0x60, 0x87, 0x72, 0x08, 0x07,
-  0x73, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x48, 0x07, 0x77, 0x30, 0x87,
-  0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07,
-  0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde,
-  0xa1, 0x0d, 0xd4, 0xa1, 0x1e, 0xda, 0x01, 0x1e, 0xda, 0x80, 0x1e, 0xc2,
-  0x41, 0x1c, 0xd8, 0xa1, 0x1c, 0xe6, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87,
-  0x79, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x77, 0x08, 0x07,
-  0x77, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07,
-  0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc,
-  0xe1, 0x1d, 0xda, 0x60, 0x1e, 0xd2, 0xe1, 0x1c, 0xdc, 0xa1, 0x1c, 0xc8,
-  0xa1, 0x0d, 0xf4, 0xa1, 0x1c, 0xe4, 0xe1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc,
-  0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07,
-  0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0xa0, 0x07,
-  0x79, 0x08, 0x07, 0x78, 0x80, 0x87, 0x74, 0x70, 0x87, 0x73, 0x68, 0x83,
-  0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca,
-  0x01, 0x20, 0xe6, 0x81, 0x1e, 0xc2, 0x61, 0x1c, 0xd6, 0xa1, 0x0d, 0xe0,
-  0x41, 0x1e, 0xde, 0x81, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4,
-  0xa1, 0x0d, 0xc4, 0xa1, 0x1e, 0xcc, 0xc1, 0x1c, 0xca, 0x41, 0x1e, 0xda,
-  0x60, 0x1e, 0xd2, 0x41, 0x1f, 0xca, 0x01, 0xc0, 0x03, 0x80, 0xa8, 0x07,
-  0x77, 0x98, 0x87, 0x70, 0x30, 0x87, 0x72, 0x68, 0x03, 0x73, 0x80, 0x87,
-  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea,
-  0xa1, 0x1c, 0x00, 0xa2, 0x1e, 0xe6, 0xa1, 0x1c, 0xda, 0x60, 0x1e, 0xde,
-  0xc1, 0x1c, 0xe8, 0xa1, 0x0d, 0xcc, 0x81, 0x1d, 0xde, 0x21, 0x1c, 0xe8,
-  0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x60, 0x03, 0x22,
-  0x0c, 0x40, 0x02, 0x2c, 0x40, 0xb5, 0x01, 0x19, 0x08, 0x20, 0x01, 0x16,
-  0xa0, 0xda, 0x60, 0x10, 0x05, 0xb0, 0x00, 0xd5, 0x06, 0xa3, 0x30, 0x80,
-  0x05, 0xa8, 0x36, 0x18, 0xc6, 0x01, 0x2c, 0x40, 0xb5, 0xc1, 0x38, 0xfe,
-  0xff, 0xff, 0xff, 0x7f, 0x00, 0x24, 0x80, 0xda, 0x80, 0x20, 0xff, 0xff,
-  0xff, 0xff, 0x3f, 0x00, 0x0c, 0x20, 0x01, 0xd5, 0x06, 0x23, 0x09, 0x80,
-  0x05, 0xa8, 0x36, 0x18, 0x8a, 0x00, 0x2c, 0x40, 0x05, 0x00, 0x00, 0x00,
-  0x49, 0x18, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x13, 0x8c, 0x40, 0x18,
-  0x88, 0xc2, 0x98, 0x10, 0x1c, 0x13, 0x06, 0x24, 0x51, 0x00, 0x00, 0x00,
-  0x89, 0x20, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09,
-  0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3,
-  0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c,
-  0x10, 0x6c, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00, 0x83,
-  0x08, 0x41, 0x30, 0x8c, 0x30, 0x00, 0x07, 0x49, 0x53, 0x44, 0x09, 0x93,
-  0x2f, 0xbb, 0x6f, 0x47, 0x08, 0xce, 0x40, 0x20, 0x82, 0x10, 0x42, 0x06,
-  0x11, 0x0a, 0xe1, 0x28, 0x69, 0x8a, 0x28, 0x61, 0xf2, 0xff, 0x89, 0xb8,
-  0x26, 0x2a, 0x22, 0x7e, 0x7b, 0xf8, 0xa7, 0x31, 0x02, 0x60, 0x10, 0xe1,
-  0x08, 0x2e, 0x92, 0xa6, 0x88, 0x12, 0x26, 0xff, 0x97, 0x00, 0xe6, 0x59,
-  0x88, 0xe8, 0x9f, 0xc6, 0x08, 0x80, 0x41, 0x84, 0x44, 0x28, 0x48, 0x08,
-  0x62, 0x18, 0x84, 0x14, 0xad, 0x32, 0x00, 0x42, 0xa8, 0xcd, 0x11, 0x04,
-  0x73, 0x04, 0x60, 0x30, 0x8c, 0x20, 0x40, 0x05, 0x09, 0x48, 0x89, 0x17,
-  0x1f, 0x20, 0x39, 0x10, 0x90, 0x02, 0x70, 0x18, 0x61, 0x80, 0x06, 0x11,
-  0x02, 0x61, 0x8e, 0x00, 0x14, 0x06, 0x11, 0x08, 0x61, 0x04, 0x00, 0x00,
-  0x13, 0xa8, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70,
-  0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87, 0x79,
-  0xc8, 0x03, 0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7, 0x51, 0x0e,
-  0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a, 0x80, 0x07,
-  0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78, 0xa0, 0x07,
-  0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07,
-  0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07,
-  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x60, 0x07,
-  0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06,
-  0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
-  0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76, 0xa0, 0x07,
-  0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07,
-  0x74, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06,
-  0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
-  0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74, 0xa0, 0x07,
-  0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x90, 0x07,
-  0x76, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07,
-  0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07,
-  0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f,
-  0x71, 0x90, 0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07,
-  0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75, 0x60, 0x07,
-  0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07,
-  0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07,
-  0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x10, 0x07,
-  0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07,
-  0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee, 0x80, 0x07,
-  0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43, 0x18, 0x06,
-  0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x21, 0x8c, 0x03, 0x04,
-  0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x10, 0x66, 0x02, 0x02, 0x60,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x0b, 0x04, 0x0b, 0x00, 0x00, 0x00,
-  0x32, 0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47,
-  0xc6, 0x04, 0x43, 0x82, 0x25, 0x30, 0x02, 0x50, 0x20, 0x45, 0x50, 0x08,
-  0x05, 0x18, 0x50, 0x10, 0x65, 0x50, 0x40, 0x05, 0x56, 0x0a, 0xc5, 0x40,
-  0x78, 0x04, 0x80, 0xea, 0x58, 0x82, 0x23, 0x00, 0x79, 0x18, 0x00, 0x00,
-  0x16, 0x01, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25,
-  0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x06, 0x64, 0x50,
-  0x40, 0x05, 0x51, 0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3,
-  0x2b, 0x1b, 0x62, 0x40, 0x03, 0x25, 0x40, 0x07, 0xdd, 0x20, 0x08, 0x0e,
-  0x8e, 0xad, 0x0c, 0x84, 0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e,
-  0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x26, 0x06, 0x06, 0x26, 0xc6, 0x85, 0x66,
-  0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26,
-  0x06, 0x06, 0x26, 0xc6, 0x85, 0x66, 0x26, 0x65, 0x88, 0x40, 0x11, 0x43,
-  0x0c, 0x68, 0x80, 0x12, 0x88, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36,
-  0x04, 0xa1, 0x0e, 0x68, 0x80, 0x06, 0x88, 0xe0, 0x16, 0x96, 0x26, 0xe7,
-  0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6,
-  0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96, 0x36, 0x17, 0x26, 0xc6, 0x56, 0x36,
-  0x44, 0xa0, 0x12, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
-  0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74,
-  0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x04, 0x6a, 0x21,
-  0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5, 0xc1, 0xa5, 0xb1, 0x95,
-  0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5, 0x99, 0x99, 0x95, 0xc9,
-  0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x95, 0xb9, 0x85, 0x89, 0xb1,
-  0x95, 0x0d, 0x11, 0xa8, 0x86, 0x51, 0x58, 0x9a, 0x9c, 0x8b, 0x5c, 0x99,
-  0x1b, 0x59, 0x99, 0xdc, 0x17, 0x5d, 0x98, 0xdc, 0x59, 0x19, 0x1d, 0xa3,
-  0xb0, 0x34, 0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2,
-  0x2f, 0xb7, 0xb0, 0xb6, 0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34,
-  0x43, 0x10, 0xea, 0x81, 0x08, 0x0a, 0xa2, 0xa2, 0x21, 0x02, 0x25, 0x91,
-  0x09, 0x4b, 0x93, 0x73, 0x81, 0x7b, 0x9b, 0x4b, 0xa3, 0x4b, 0x7b, 0x73,
-  0xa3, 0x12, 0x96, 0x26, 0xe7, 0x32, 0x56, 0xe6, 0x46, 0x57, 0x26, 0x47,
-  0x29, 0x2c, 0x4d, 0xce, 0xc5, 0xed, 0xed, 0x0b, 0xae, 0x4c, 0x6e, 0x0e,
-  0xae, 0x6c, 0x8c, 0x2e, 0xcd, 0xae, 0x8c, 0x4c, 0x58, 0x9a, 0x9c, 0x4b,
-  0x98, 0xdc, 0xd9, 0x97, 0x5b, 0x58, 0x5b, 0x19, 0x11, 0xb8, 0xb7, 0xb9,
-  0x34, 0xba, 0xb4, 0x37, 0xb7, 0x21, 0x10, 0x44, 0x50, 0x14, 0x55, 0x51,
-  0x16, 0x05, 0x51, 0x11, 0x75, 0x51, 0x18, 0xa5, 0xb0, 0x34, 0x39, 0x17,
-  0x33, 0xb9, 0xb0, 0xb3, 0xb6, 0x32, 0x37, 0xba, 0xaf, 0x34, 0x37, 0xb8,
-  0x3a, 0x3a, 0x66, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64,
-  0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x44, 0x76,
-  0x32, 0x5f, 0x66, 0x29, 0x7c, 0xc2, 0xd2, 0xe4, 0x5c, 0xe0, 0xca, 0xe4,
-  0xe6, 0xe0, 0xca, 0xc6, 0xe8, 0xd2, 0xec, 0xca, 0x68, 0x98, 0xb1, 0xbd,
-  0x85, 0xd1, 0xc9, 0x10, 0xa1, 0x2b, 0xc3, 0x1b, 0x7b, 0x7b, 0x93, 0x23,
-  0x1b, 0x22, 0x41, 0x03, 0xa5, 0x51, 0x1b, 0x55, 0x51, 0x1c, 0x05, 0x51,
-  0x1d, 0x75, 0x51, 0x1e, 0x95, 0xb0, 0x34, 0x39, 0x17, 0xb1, 0x3a, 0x33,
-  0xb3, 0x32, 0x39, 0x3e, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66,
-  0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x94, 0xc2, 0xd2, 0xe4, 0x5c,
-  0xd8, 0xde, 0xc6, 0xc2, 0xe8, 0xd2, 0xde, 0xdc, 0xbe, 0xd2, 0xdc, 0xc8,
-  0xca, 0xf0, 0x88, 0x84, 0xa5, 0xc9, 0xb9, 0xc8, 0x95, 0x85, 0x91, 0x31,
-  0x0a, 0x4b, 0x93, 0x73, 0x09, 0x93, 0x3b, 0xfb, 0xa2, 0xcb, 0x83, 0x2b,
-  0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0xe3, 0x15, 0x96, 0x26, 0xe7, 0x12, 0x26,
-  0x77, 0xf6, 0x45, 0x97, 0x07, 0x57, 0xf6, 0x15, 0xc6, 0x96, 0x76, 0xe6,
-  0xf6, 0x35, 0x97, 0xa6, 0x57, 0xc6, 0x61, 0xec, 0x8d, 0x6d, 0x08, 0x18,
-  0x40, 0x06, 0x05, 0x06, 0x54, 0x18, 0x40, 0x05, 0x25, 0x06, 0x10, 0x01,
-  0x0d, 0xd4, 0x18, 0x50, 0x64, 0x00, 0x15, 0x54, 0x19, 0x40, 0x05, 0x05,
-  0x51, 0x11, 0x75, 0x51, 0x66, 0x40, 0x2a, 0x2c, 0x4d, 0xce, 0x65, 0x8e,
-  0x4e, 0xae, 0x6e, 0x8c, 0xee, 0x8b, 0x2e, 0x0f, 0xae, 0xec, 0x2b, 0xcd,
-  0xcd, 0xec, 0x8d, 0x86, 0x19, 0xdb, 0x5b, 0x18, 0xdd, 0x0c, 0x8d, 0x37,
-  0x33, 0xb3, 0xb9, 0x32, 0x3a, 0x1a, 0x52, 0x63, 0x6f, 0x65, 0x66, 0x66,
-  0x34, 0x8e, 0xc6, 0xde, 0xca, 0xcc, 0xcc, 0x68, 0x08, 0x8d, 0xbd, 0x95,
-  0x99, 0x99, 0x0d, 0x41, 0x03, 0x88, 0x80, 0x0a, 0x88, 0xa0, 0xd2, 0x80,
-  0x52, 0x03, 0xa8, 0x80, 0x0a, 0x88, 0xa0, 0xd2, 0x80, 0x5a, 0x03, 0x68,
-  0x81, 0x0a, 0x88, 0xa0, 0xd2, 0x80, 0x62, 0x03, 0x88, 0x81, 0x0a, 0x88,
-  0xa0, 0xd2, 0x80, 0x6a, 0x03, 0x26, 0x59, 0x55, 0x56, 0x44, 0x65, 0x63,
-  0x6f, 0x64, 0x65, 0x34, 0xc8, 0xca, 0xc6, 0xde, 0xc8, 0xca, 0x86, 0x90,
-  0x01, 0xa4, 0x50, 0x60, 0x40, 0x85, 0x01, 0x84, 0x50, 0x62, 0x00, 0x0d,
-  0xd0, 0x40, 0x8d, 0x01, 0x85, 0x06, 0x94, 0x1b, 0x50, 0x64, 0x00, 0x21,
-  0x54, 0x19, 0x40, 0x05, 0x05, 0x51, 0x6f, 0x40, 0x5d, 0x14, 0x1c, 0x70,
-  0x09, 0x4b, 0x93, 0x73, 0xa1, 0x2b, 0xc3, 0xa3, 0xab, 0x93, 0x2b, 0xa3,
-  0x12, 0x96, 0x26, 0xe7, 0x32, 0x17, 0xd6, 0x06, 0xc7, 0x56, 0x46, 0x8c,
-  0xae, 0x0c, 0x8f, 0xae, 0x4e, 0xae, 0x4c, 0x86, 0x8c, 0xc7, 0x8c, 0xed,
-  0x2d, 0x8c, 0x8e, 0x05, 0x64, 0x2e, 0xac, 0x0d, 0x8e, 0xad, 0xcc, 0x87,
-  0x04, 0x5d, 0x19, 0x5e, 0xd6, 0x10, 0x0a, 0x3a, 0x28, 0x39, 0xa0, 0xc4,
-  0x00, 0x22, 0xa0, 0x81, 0x9a, 0x03, 0x0a, 0xa2, 0xe8, 0x80, 0xba, 0xa8,
-  0x3a, 0x60, 0x41, 0x57, 0x86, 0x57, 0x65, 0x35, 0x84, 0x82, 0x1a, 0x4a,
-  0x0e, 0x28, 0x31, 0x80, 0x06, 0x68, 0xa0, 0xe6, 0x80, 0x82, 0x28, 0x3a,
-  0xa0, 0x2e, 0xea, 0x0e, 0xb8, 0x84, 0xa5, 0xc9, 0xb9, 0xcc, 0x85, 0xb5,
-  0xc1, 0xb1, 0x95, 0xc9, 0xf1, 0x98, 0x0b, 0x6b, 0x83, 0x63, 0x2b, 0x93,
-  0x63, 0x30, 0x37, 0x44, 0x82, 0x1c, 0x2a, 0x0f, 0x28, 0x31, 0x80, 0x08,
-  0x68, 0xa0, 0x20, 0x4a, 0x0f, 0xa8, 0x8b, 0xda, 0x83, 0x21, 0x0e, 0x95,
-  0x51, 0x1f, 0x75, 0x06, 0x54, 0x1c, 0x50, 0x76, 0x40, 0xe1, 0x01, 0xc5,
-  0x07, 0x43, 0x0c, 0x06, 0xa0, 0x26, 0xaa, 0x0f, 0xf8, 0xbc, 0xb5, 0xb9,
-  0xa5, 0xc1, 0xbd, 0xd1, 0x95, 0xb9, 0xd1, 0x81, 0x8c, 0xa1, 0x85, 0xc9,
-  0xf1, 0x99, 0x4a, 0x6b, 0x83, 0x63, 0x2b, 0x03, 0x19, 0x5a, 0x59, 0x01,
-  0xa1, 0x12, 0x0a, 0x0a, 0x1a, 0x22, 0x50, 0xa0, 0x30, 0xc4, 0xa0, 0xfe,
-  0x80, 0x0a, 0x05, 0xec, 0x19, 0x62, 0x50, 0xa2, 0x40, 0x89, 0x02, 0xf6,
-  0x8c, 0x88, 0xd8, 0x81, 0x1d, 0xec, 0xa1, 0x1d, 0xdc, 0xa0, 0x1d, 0xde,
-  0x81, 0x1c, 0xea, 0x81, 0x1d, 0xca, 0xc1, 0x0d, 0xcc, 0x81, 0x1d, 0xc2,
-  0xe1, 0x1c, 0xe6, 0x61, 0x8a, 0x10, 0x0c, 0x23, 0x14, 0x76, 0x60, 0x07,
-  0x7b, 0x68, 0x07, 0x37, 0x48, 0x07, 0x72, 0x28, 0x07, 0x77, 0xa0, 0x87,
-  0x29, 0x41, 0x31, 0x62, 0x09, 0x87, 0x74, 0x90, 0x07, 0x37, 0xb0, 0x87,
-  0x72, 0x90, 0x87, 0x79, 0x48, 0x87, 0x77, 0x70, 0x87, 0x29, 0x81, 0x31,
-  0x82, 0x0a, 0x87, 0x74, 0x90, 0x07, 0x37, 0x60, 0x87, 0x70, 0x70, 0x87,
-  0x73, 0xa8, 0x87, 0x70, 0x38, 0x87, 0x72, 0xf8, 0x05, 0x7b, 0x28, 0x07,
-  0x79, 0x98, 0x87, 0x74, 0x78, 0x07, 0x77, 0x98, 0x12, 0x20, 0x23, 0xa6,
-  0x70, 0x48, 0x07, 0x79, 0x70, 0x83, 0x71, 0x78, 0x87, 0x76, 0x80, 0x87,
-  0x74, 0x60, 0x87, 0x72, 0xf8, 0x85, 0x77, 0x80, 0x07, 0x7a, 0x48, 0x87,
-  0x77, 0x70, 0x87, 0x79, 0x98, 0x32, 0x28, 0x8c, 0x33, 0x82, 0x09, 0x87,
-  0x74, 0x90, 0x07, 0x37, 0x30, 0x07, 0x79, 0x08, 0x87, 0x73, 0x68, 0x87,
-  0x72, 0x70, 0x07, 0x7a, 0x98, 0x12, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00,
-  0x79, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c,
-  0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3,
-  0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6,
-  0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e,
-  0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43,
-  0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03,
-  0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48,
-  0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20,
-  0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e,
-  0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d,
-  0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89,
-  0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83,
-  0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68,
-  0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90,
-  0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78,
-  0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98,
-  0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5,
-  0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c,
-  0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c,
-  0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43,
-  0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43,
-  0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82,
-  0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58,
-  0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18,
-  0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2,
-  0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec,
-  0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e,
-  0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d,
-  0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83,
-  0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60,
-  0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0,
-  0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d,
-  0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d,
-  0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43,
-  0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3,
-  0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18,
-  0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3,
-  0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1,
-  0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e,
-  0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83,
-  0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83,
-  0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20, 0x00, 0x00,
-  0x0d, 0x00, 0x00, 0x00, 0x16, 0xd0, 0x00, 0x48, 0xe4, 0x0f, 0xce, 0xe4,
-  0x57, 0x77, 0x71, 0xdb, 0x26, 0xb0, 0x01, 0x48, 0xe4, 0x4b, 0x00, 0xf3,
-  0x2c, 0xc4, 0x3f, 0x11, 0xd7, 0x44, 0x45, 0xc4, 0x6f, 0x0f, 0x7e, 0x85,
-  0x17, 0xb7, 0x6d, 0x00, 0x11, 0xdb, 0x95, 0xff, 0xf9, 0xd6, 0xf6, 0x5f,
-  0x44, 0x80, 0xc1, 0x10, 0xcd, 0x04, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00,
-  0x38, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00,
-  0x0e, 0x00, 0x00, 0x00, 0x64, 0xc7, 0x1a, 0x80, 0x81, 0x98, 0x63, 0x20,
-  0x86, 0x6f, 0x8e, 0x81, 0xf8, 0xbe, 0xb1, 0x06, 0x20, 0x10, 0x28, 0x8e,
-  0x00, 0xd0, 0xab, 0x81, 0x11, 0x00, 0x82, 0x33, 0x00, 0x14, 0xe6, 0x20,
-  0xc8, 0x80, 0x0c, 0xc8, 0x40, 0x0c, 0x66, 0x00, 0x08, 0x8c, 0x11, 0x80,
-  0x20, 0x08, 0xe2, 0xdf, 0x08, 0xc0, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x23, 0x06, 0xca, 0x10, 0x8c, 0x01, 0xe4, 0x4c, 0x48, 0x72, 0x08, 0x83,
-  0x0c, 0x41, 0xc1, 0x8c, 0x18, 0x28, 0x43, 0x50, 0x06, 0x11, 0x54, 0x29,
-  0x4b, 0x42, 0x0c, 0x32, 0x04, 0xc7, 0x33, 0xc8, 0x30, 0x04, 0xd1, 0x59,
-  0x77, 0x29, 0x28, 0x83, 0x0c, 0xc1, 0x12, 0x19, 0x11, 0xc0, 0x87, 0xb6,
-  0x32, 0xde, 0xb0, 0x81, 0x01, 0x1b, 0x5c, 0x70, 0x97, 0x82, 0x32, 0xc8,
-  0x10, 0x44, 0xd7, 0x88, 0x41, 0x21, 0x04, 0x72, 0x60, 0x04, 0xe3, 0x0d,
-  0x60, 0x50, 0x06, 0x6e, 0x70, 0xc1, 0x5d, 0x0a, 0xca, 0x20, 0x43, 0x60,
-  0x71, 0x23, 0x06, 0x85, 0x10, 0xdc, 0xc1, 0x12, 0x8c, 0x37, 0x94, 0x81,
-  0x1a, 0xbc, 0xc1, 0x05, 0x77, 0x29, 0x28, 0x83, 0x0c, 0xc1, 0x16, 0x06,
-  0x23, 0x06, 0x85, 0x10, 0xf0, 0x01, 0x14, 0xcc, 0x31, 0x78, 0x8b, 0x1e,
-  0xcc, 0x31, 0x04, 0x07, 0x1f, 0xcc, 0x31, 0x04, 0x83, 0x1e, 0x58, 0x30,
-  0xc9, 0x27, 0x83, 0x80, 0x18, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
-  0x5b, 0x86, 0x24, 0x18, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
-  0xb0, 0x0c, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde,
-  0x21, 0x0c, 0x00, 0x00, 0x29, 0x03, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00,
-  0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91,
-  0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c,
-  0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02,
-  0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x49,
-  0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52, 0x80,
-  0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8, 0x48, 0x11, 0x62, 0xa8, 0xa0,
-  0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00, 0x00,
-  0x92, 0x00, 0x00, 0x00, 0x1b, 0xcc, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff,
-  0x01, 0x60, 0x00, 0x09, 0xa8, 0x88, 0x71, 0x78, 0x07, 0x79, 0x90, 0x87,
-  0x72, 0x18, 0x07, 0x7a, 0x60, 0x87, 0x7c, 0x68, 0x03, 0x79, 0x78, 0x87,
-  0x7a, 0x70, 0x07, 0x72, 0x28, 0x07, 0x72, 0x68, 0x03, 0x72, 0x48, 0x07,
-  0x7b, 0x48, 0x07, 0x72, 0x28, 0x87, 0x36, 0x98, 0x87, 0x78, 0x90, 0x07,
-  0x7a, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07,
-  0x74, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xc8,
-  0x21, 0x1d, 0xe6, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0xa1, 0x0d, 0xe8,
-  0x21, 0x1c, 0xd2, 0x81, 0x1d, 0xda, 0x60, 0x1c, 0xc2, 0x81, 0x1d, 0xd8,
-  0x61, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08,
-  0x76, 0x28, 0x87, 0x79, 0x98, 0x87, 0x36, 0x80, 0x07, 0x79, 0x28, 0x87,
-  0x71, 0x48, 0x87, 0x79, 0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x87,
-  0x70, 0x20, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00,
-  0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xcc, 0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca,
-  0xa1, 0x0d, 0xe0, 0xe1, 0x1d, 0xd2, 0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4,
-  0xa1, 0x0d, 0xca, 0x81, 0x1d, 0xd2, 0xa1, 0x1d, 0x00, 0x7a, 0x90, 0x87,
-  0x7a, 0x28, 0x07, 0x60, 0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90, 0x87,
-  0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70, 0x07,
-  0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68, 0x87,
-  0x36, 0x70, 0x87, 0x77, 0x70, 0x87, 0x36, 0x60, 0x87, 0x72, 0x08, 0x07,
-  0x73, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x48, 0x07, 0x77, 0x30, 0x87,
-  0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07,
-  0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde,
-  0xa1, 0x0d, 0xd4, 0xa1, 0x1e, 0xda, 0x01, 0x1e, 0xda, 0x80, 0x1e, 0xc2,
-  0x41, 0x1c, 0xd8, 0xa1, 0x1c, 0xe6, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87,
-  0x79, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x77, 0x08, 0x07,
-  0x77, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07,
-  0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc,
-  0xe1, 0x1d, 0xda, 0x60, 0x1e, 0xd2, 0xe1, 0x1c, 0xdc, 0xa1, 0x1c, 0xc8,
-  0xa1, 0x0d, 0xf4, 0xa1, 0x1c, 0xe4, 0xe1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc,
-  0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07,
-  0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0xa0, 0x07,
-  0x79, 0x08, 0x07, 0x78, 0x80, 0x87, 0x74, 0x70, 0x87, 0x73, 0x68, 0x83,
-  0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca,
-  0x01, 0x20, 0xe6, 0x81, 0x1e, 0xc2, 0x61, 0x1c, 0xd6, 0xa1, 0x0d, 0xe0,
-  0x41, 0x1e, 0xde, 0x81, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4,
-  0xa1, 0x0d, 0xc4, 0xa1, 0x1e, 0xcc, 0xc1, 0x1c, 0xca, 0x41, 0x1e, 0xda,
-  0x60, 0x1e, 0xd2, 0x41, 0x1f, 0xca, 0x01, 0xc0, 0x03, 0x80, 0xa8, 0x07,
-  0x77, 0x98, 0x87, 0x70, 0x30, 0x87, 0x72, 0x68, 0x03, 0x73, 0x80, 0x87,
-  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea,
-  0xa1, 0x1c, 0x00, 0xa2, 0x1e, 0xe6, 0xa1, 0x1c, 0xda, 0x60, 0x1e, 0xde,
-  0xc1, 0x1c, 0xe8, 0xa1, 0x0d, 0xcc, 0x81, 0x1d, 0xde, 0x21, 0x1c, 0xe8,
-  0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x60, 0x03, 0x22,
-  0x0c, 0x40, 0x02, 0x2c, 0x40, 0xb5, 0x01, 0x19, 0x08, 0x20, 0x01, 0x16,
-  0xa0, 0xda, 0x60, 0x10, 0x05, 0xb0, 0x00, 0xd5, 0x06, 0xa3, 0x30, 0x80,
-  0x05, 0xa8, 0x36, 0x18, 0xc6, 0x01, 0x2c, 0x40, 0xb5, 0xc1, 0x38, 0xfe,
-  0xff, 0xff, 0xff, 0x7f, 0x00, 0x24, 0x80, 0xda, 0x80, 0x20, 0xff, 0xff,
-  0xff, 0xff, 0x3f, 0x00, 0x0c, 0x20, 0x01, 0xd5, 0x06, 0x23, 0x09, 0x80,
-  0x05, 0xa8, 0x36, 0x18, 0x8a, 0x00, 0x2c, 0x40, 0x05, 0x00, 0x00, 0x00,
-  0x49, 0x18, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x13, 0x8c, 0x40, 0x18,
-  0x88, 0xc2, 0x98, 0x10, 0x1c, 0x13, 0x06, 0x24, 0x51, 0x00, 0x00, 0x00,
-  0x89, 0x20, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09,
-  0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3,
-  0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c,
-  0x10, 0x6c, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00, 0x83,
-  0x08, 0x41, 0x30, 0x8c, 0x30, 0x00, 0x07, 0x49, 0x53, 0x44, 0x09, 0x93,
-  0x2f, 0xbb, 0x6f, 0x47, 0x08, 0xce, 0x40, 0x20, 0x82, 0x10, 0x42, 0x06,
-  0x11, 0x0a, 0xe1, 0x28, 0x69, 0x8a, 0x28, 0x61, 0xf2, 0xff, 0x89, 0xb8,
-  0x26, 0x2a, 0x22, 0x7e, 0x7b, 0xf8, 0xa7, 0x31, 0x02, 0x60, 0x10, 0xe1,
-  0x08, 0x2e, 0x92, 0xa6, 0x88, 0x12, 0x26, 0xff, 0x97, 0x00, 0xe6, 0x59,
-  0x88, 0xe8, 0x9f, 0xc6, 0x08, 0x80, 0x41, 0x84, 0x44, 0x28, 0x48, 0x08,
-  0x62, 0x18, 0x84, 0x14, 0xad, 0x32, 0x00, 0x42, 0xa8, 0xcd, 0x11, 0x04,
-  0x73, 0x04, 0x60, 0x30, 0x8c, 0x20, 0x40, 0x05, 0x09, 0x48, 0x89, 0x17,
-  0x1f, 0x20, 0x39, 0x10, 0x90, 0x02, 0x70, 0x18, 0x61, 0x80, 0x06, 0x11,
-  0x02, 0x61, 0x8e, 0x00, 0x14, 0x06, 0x11, 0x08, 0x61, 0x04, 0x00, 0x00,
-  0x13, 0xa8, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70,
-  0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87, 0x79,
-  0xc8, 0x03, 0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7, 0x51, 0x0e,
-  0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a, 0x80, 0x07,
-  0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78, 0xa0, 0x07,
-  0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07,
-  0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07,
-  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x60, 0x07,
-  0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06,
-  0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
-  0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76, 0xa0, 0x07,
-  0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07,
-  0x74, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06,
-  0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
-  0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76, 0x40, 0x07,
-  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74, 0xa0, 0x07,
-  0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x90, 0x07,
-  0x76, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07,
-  0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07,
-  0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f,
-  0x71, 0x90, 0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07,
-  0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75, 0x60, 0x07,
-  0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07,
-  0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07,
-  0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x10, 0x07,
-  0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07,
-  0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee, 0x80, 0x07,
-  0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43, 0x18, 0x06,
-  0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x21, 0x8c, 0x03, 0x04,
-  0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x10, 0x66, 0x02, 0x02, 0x60,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x0b, 0x04, 0x0b, 0x00, 0x00, 0x00,
-  0x32, 0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47,
-  0xc6, 0x04, 0x43, 0x82, 0x25, 0x30, 0x02, 0x50, 0x20, 0x45, 0x50, 0x08,
-  0x05, 0x18, 0x50, 0x10, 0x65, 0x50, 0x40, 0x05, 0x56, 0x0a, 0xc5, 0x40,
-  0x78, 0x04, 0x80, 0xea, 0x58, 0x82, 0x23, 0x00, 0x79, 0x18, 0x00, 0x00,
-  0x16, 0x01, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25,
-  0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x06, 0x64, 0x50,
-  0x40, 0x05, 0x51, 0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3,
-  0x2b, 0x1b, 0x62, 0x40, 0x03, 0x25, 0x40, 0x07, 0xdd, 0x20, 0x08, 0x0e,
-  0x8e, 0xad, 0x0c, 0x84, 0x89, 0xc9, 0xaa, 0x09, 0xc4, 0xae, 0x4c, 0x6e,
-  0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x26, 0x06, 0x06, 0x26, 0xc6, 0x85, 0x66,
-  0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x26,
-  0x06, 0x06, 0x26, 0xc6, 0x85, 0x66, 0x26, 0x65, 0x88, 0x40, 0x11, 0x43,
-  0x0c, 0x68, 0x80, 0x12, 0x88, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36,
-  0x04, 0xa1, 0x0e, 0x68, 0x80, 0x06, 0x88, 0xe0, 0x16, 0x96, 0x26, 0xe7,
-  0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6,
-  0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96, 0x36, 0x17, 0x26, 0xc6, 0x56, 0x36,
-  0x44, 0xa0, 0x12, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
-  0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74,
-  0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x04, 0x6a, 0x21,
-  0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5, 0xc1, 0xa5, 0xb1, 0x95,
-  0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5, 0x99, 0x99, 0x95, 0xc9,
-  0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x95, 0xb9, 0x85, 0x89, 0xb1,
-  0x95, 0x0d, 0x11, 0xa8, 0x86, 0x51, 0x58, 0x9a, 0x9c, 0x8b, 0x5c, 0x99,
-  0x1b, 0x59, 0x99, 0xdc, 0x17, 0x5d, 0x98, 0xdc, 0x59, 0x19, 0x1d, 0xa3,
-  0xb0, 0x34, 0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2,
-  0x2f, 0xb7, 0xb0, 0xb6, 0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34,
-  0x43, 0x10, 0xea, 0x81, 0x08, 0x0a, 0xa2, 0xa2, 0x21, 0x02, 0x25, 0x91,
-  0x09, 0x4b, 0x93, 0x73, 0x81, 0x7b, 0x9b, 0x4b, 0xa3, 0x4b, 0x7b, 0x73,
-  0xa3, 0x12, 0x96, 0x26, 0xe7, 0x32, 0x56, 0xe6, 0x46, 0x57, 0x26, 0x47,
-  0x29, 0x2c, 0x4d, 0xce, 0xc5, 0xed, 0xed, 0x0b, 0xae, 0x4c, 0x6e, 0x0e,
-  0xae, 0x6c, 0x8c, 0x2e, 0xcd, 0xae, 0x8c, 0x4c, 0x58, 0x9a, 0x9c, 0x4b,
-  0x98, 0xdc, 0xd9, 0x97, 0x5b, 0x58, 0x5b, 0x19, 0x11, 0xb8, 0xb7, 0xb9,
-  0x34, 0xba, 0xb4, 0x37, 0xb7, 0x21, 0x10, 0x44, 0x50, 0x14, 0x55, 0x51,
-  0x16, 0x05, 0x51, 0x11, 0x75, 0x51, 0x18, 0xa5, 0xb0, 0x34, 0x39, 0x17,
-  0x33, 0xb9, 0xb0, 0xb3, 0xb6, 0x32, 0x37, 0xba, 0xaf, 0x34, 0x37, 0xb8,
-  0x3a, 0x3a, 0x66, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64,
-  0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x44, 0x76,
-  0x32, 0x5f, 0x66, 0x29, 0x7c, 0xc2, 0xd2, 0xe4, 0x5c, 0xe0, 0xca, 0xe4,
-  0xe6, 0xe0, 0xca, 0xc6, 0xe8, 0xd2, 0xec, 0xca, 0x68, 0x98, 0xb1, 0xbd,
-  0x85, 0xd1, 0xc9, 0x10, 0xa1, 0x2b, 0xc3, 0x1b, 0x7b, 0x7b, 0x93, 0x23,
-  0x1b, 0x22, 0x41, 0x03, 0xa5, 0x51, 0x1b, 0x55, 0x51, 0x1c, 0x05, 0x51,
-  0x1d, 0x75, 0x51, 0x1e, 0x95, 0xb0, 0x34, 0x39, 0x17, 0xb1, 0x3a, 0x33,
-  0xb3, 0x32, 0x39, 0x3e, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66,
-  0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x94, 0xc2, 0xd2, 0xe4, 0x5c,
-  0xd8, 0xde, 0xc6, 0xc2, 0xe8, 0xd2, 0xde, 0xdc, 0xbe, 0xd2, 0xdc, 0xc8,
-  0xca, 0xf0, 0x88, 0x84, 0xa5, 0xc9, 0xb9, 0xc8, 0x95, 0x85, 0x91, 0x31,
-  0x0a, 0x4b, 0x93, 0x73, 0x09, 0x93, 0x3b, 0xfb, 0xa2, 0xcb, 0x83, 0x2b,
-  0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0xe3, 0x15, 0x96, 0x26, 0xe7, 0x12, 0x26,
-  0x77, 0xf6, 0x45, 0x97, 0x07, 0x57, 0xf6, 0x15, 0xc6, 0x96, 0x76, 0xe6,
-  0xf6, 0x35, 0x97, 0xa6, 0x57, 0xc6, 0x61, 0xec, 0x8d, 0x6d, 0x08, 0x18,
-  0x40, 0x06, 0x05, 0x06, 0x54, 0x18, 0x40, 0x05, 0x25, 0x06, 0x10, 0x01,
-  0x0d, 0xd4, 0x18, 0x50, 0x64, 0x00, 0x15, 0x54, 0x19, 0x40, 0x05, 0x05,
-  0x51, 0x11, 0x75, 0x51, 0x66, 0x40, 0x2a, 0x2c, 0x4d, 0xce, 0x65, 0x8e,
-  0x4e, 0xae, 0x6e, 0x8c, 0xee, 0x8b, 0x2e, 0x0f, 0xae, 0xec, 0x2b, 0xcd,
-  0xcd, 0xec, 0x8d, 0x86, 0x19, 0xdb, 0x5b, 0x18, 0xdd, 0x0c, 0x8d, 0x37,
-  0x33, 0xb3, 0xb9, 0x32, 0x3a, 0x1a, 0x52, 0x63, 0x6f, 0x65, 0x66, 0x66,
-  0x34, 0x8e, 0xc6, 0xde, 0xca, 0xcc, 0xcc, 0x68, 0x08, 0x8d, 0xbd, 0x95,
-  0x99, 0x99, 0x0d, 0x41, 0x03, 0x88, 0x80, 0x0a, 0x88, 0xa0, 0xd2, 0x80,
-  0x52, 0x03, 0xa8, 0x80, 0x0a, 0x88, 0xa0, 0xd2, 0x80, 0x5a, 0x03, 0x68,
-  0x81, 0x0a, 0x88, 0xa0, 0xd2, 0x80, 0x62, 0x03, 0x88, 0x81, 0x0a, 0x88,
-  0xa0, 0xd2, 0x80, 0x6a, 0x03, 0x26, 0x59, 0x55, 0x56, 0x44, 0x65, 0x63,
-  0x6f, 0x64, 0x65, 0x34, 0xc8, 0xca, 0xc6, 0xde, 0xc8, 0xca, 0x86, 0x90,
-  0x01, 0xa4, 0x50, 0x60, 0x40, 0x85, 0x01, 0x84, 0x50, 0x62, 0x00, 0x0d,
-  0xd0, 0x40, 0x8d, 0x01, 0x85, 0x06, 0x94, 0x1b, 0x50, 0x64, 0x00, 0x21,
-  0x54, 0x19, 0x40, 0x05, 0x05, 0x51, 0x6f, 0x40, 0x5d, 0x14, 0x1c, 0x70,
-  0x09, 0x4b, 0x93, 0x73, 0xa1, 0x2b, 0xc3, 0xa3, 0xab, 0x93, 0x2b, 0xa3,
-  0x12, 0x96, 0x26, 0xe7, 0x32, 0x17, 0xd6, 0x06, 0xc7, 0x56, 0x46, 0x8c,
-  0xae, 0x0c, 0x8f, 0xae, 0x4e, 0xae, 0x4c, 0x86, 0x8c, 0xc7, 0x8c, 0xed,
-  0x2d, 0x8c, 0x8e, 0x05, 0x64, 0x2e, 0xac, 0x0d, 0x8e, 0xad, 0xcc, 0x87,
-  0x04, 0x5d, 0x19, 0x5e, 0xd6, 0x10, 0x0a, 0x3a, 0x28, 0x39, 0xa0, 0xc4,
-  0x00, 0x22, 0xa0, 0x81, 0x9a, 0x03, 0x0a, 0xa2, 0xe8, 0x80, 0xba, 0xa8,
-  0x3a, 0x60, 0x41, 0x57, 0x86, 0x57, 0x65, 0x35, 0x84, 0x82, 0x1a, 0x4a,
-  0x0e, 0x28, 0x31, 0x80, 0x06, 0x68, 0xa0, 0xe6, 0x80, 0x82, 0x28, 0x3a,
-  0xa0, 0x2e, 0xea, 0x0e, 0xb8, 0x84, 0xa5, 0xc9, 0xb9, 0xcc, 0x85, 0xb5,
-  0xc1, 0xb1, 0x95, 0xc9, 0xf1, 0x98, 0x0b, 0x6b, 0x83, 0x63, 0x2b, 0x93,
-  0x63, 0x30, 0x37, 0x44, 0x82, 0x1c, 0x2a, 0x0f, 0x28, 0x31, 0x80, 0x08,
-  0x68, 0xa0, 0x20, 0x4a, 0x0f, 0xa8, 0x8b, 0xda, 0x83, 0x21, 0x0e, 0x95,
-  0x51, 0x1f, 0x75, 0x06, 0x54, 0x1c, 0x50, 0x76, 0x40, 0xe1, 0x01, 0xc5,
-  0x07, 0x43, 0x0c, 0x06, 0xa0, 0x26, 0xaa, 0x0f, 0xf8, 0xbc, 0xb5, 0xb9,
-  0xa5, 0xc1, 0xbd, 0xd1, 0x95, 0xb9, 0xd1, 0x81, 0x8c, 0xa1, 0x85, 0xc9,
-  0xf1, 0x99, 0x4a, 0x6b, 0x83, 0x63, 0x2b, 0x03, 0x19, 0x5a, 0x59, 0x01,
-  0xa1, 0x12, 0x0a, 0x0a, 0x1a, 0x22, 0x50, 0xa0, 0x30, 0xc4, 0xa0, 0xfe,
-  0x80, 0x0a, 0x05, 0xec, 0x19, 0x62, 0x50, 0xa2, 0x40, 0x89, 0x02, 0xf6,
-  0x8c, 0x88, 0xd8, 0x81, 0x1d, 0xec, 0xa1, 0x1d, 0xdc, 0xa0, 0x1d, 0xde,
-  0x81, 0x1c, 0xea, 0x81, 0x1d, 0xca, 0xc1, 0x0d, 0xcc, 0x81, 0x1d, 0xc2,
-  0xe1, 0x1c, 0xe6, 0x61, 0x8a, 0x10, 0x0c, 0x23, 0x14, 0x76, 0x60, 0x07,
-  0x7b, 0x68, 0x07, 0x37, 0x48, 0x07, 0x72, 0x28, 0x07, 0x77, 0xa0, 0x87,
-  0x29, 0x41, 0x31, 0x62, 0x09, 0x87, 0x74, 0x90, 0x07, 0x37, 0xb0, 0x87,
-  0x72, 0x90, 0x87, 0x79, 0x48, 0x87, 0x77, 0x70, 0x87, 0x29, 0x81, 0x31,
-  0x82, 0x0a, 0x87, 0x74, 0x90, 0x07, 0x37, 0x60, 0x87, 0x70, 0x70, 0x87,
-  0x73, 0xa8, 0x87, 0x70, 0x38, 0x87, 0x72, 0xf8, 0x05, 0x7b, 0x28, 0x07,
-  0x79, 0x98, 0x87, 0x74, 0x78, 0x07, 0x77, 0x98, 0x12, 0x20, 0x23, 0xa6,
-  0x70, 0x48, 0x07, 0x79, 0x70, 0x83, 0x71, 0x78, 0x87, 0x76, 0x80, 0x87,
-  0x74, 0x60, 0x87, 0x72, 0xf8, 0x85, 0x77, 0x80, 0x07, 0x7a, 0x48, 0x87,
-  0x77, 0x70, 0x87, 0x79, 0x98, 0x32, 0x28, 0x8c, 0x33, 0x82, 0x09, 0x87,
-  0x74, 0x90, 0x07, 0x37, 0x30, 0x07, 0x79, 0x08, 0x87, 0x73, 0x68, 0x87,
-  0x72, 0x70, 0x07, 0x7a, 0x98, 0x12, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00,
-  0x79, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c,
-  0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3,
-  0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6,
-  0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e,
-  0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43,
-  0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03,
-  0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48,
-  0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20,
-  0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e,
-  0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d,
-  0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89,
-  0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83,
-  0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68,
-  0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90,
-  0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78,
-  0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98,
-  0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5,
-  0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c,
-  0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c,
-  0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43,
-  0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43,
-  0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82,
-  0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58,
-  0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18,
-  0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2,
-  0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec,
-  0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e,
-  0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d,
-  0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83,
-  0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60,
-  0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0,
-  0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d,
-  0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d,
-  0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43,
-  0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3,
-  0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18,
-  0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3,
-  0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1,
-  0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e,
-  0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83,
-  0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83,
-  0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x71, 0x20, 0x00, 0x00,
-  0x0d, 0x00, 0x00, 0x00, 0x16, 0xd0, 0x00, 0x48, 0xe4, 0x0f, 0xce, 0xe4,
-  0x57, 0x77, 0x71, 0xdb, 0x26, 0xb0, 0x01, 0x48, 0xe4, 0x4b, 0x00, 0xf3,
-  0x2c, 0xc4, 0x3f, 0x11, 0xd7, 0x44, 0x45, 0xc4, 0x6f, 0x0f, 0x7e, 0x85,
-  0x17, 0xb7, 0x6d, 0x00, 0x11, 0xdb, 0x95, 0xff, 0xf9, 0xda, 0xf5, 0x5f,
-  0x44, 0x80, 0xc1, 0x10, 0xcd, 0x04, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00,
-  0x3b, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00,
-  0x10, 0x00, 0x00, 0x00, 0x64, 0xc7, 0x1a, 0x80, 0x81, 0x98, 0x63, 0x20,
-  0x06, 0x30, 0x98, 0x63, 0x20, 0xc0, 0x00, 0x0c, 0xc6, 0x1a, 0x80, 0x40,
-  0xa0, 0x38, 0x96, 0x10, 0x00, 0x23, 0x00, 0xf4, 0x6a, 0x60, 0x04, 0x80,
-  0xe0, 0x0c, 0x00, 0x89, 0x19, 0x00, 0x0a, 0x73, 0x10, 0x66, 0x60, 0x06,
-  0x66, 0x40, 0x06, 0x33, 0x00, 0x04, 0xc6, 0x08, 0x40, 0x10, 0x04, 0xf1,
-  0x6f, 0x04, 0x60, 0x06, 0x00, 0x00, 0x00, 0x00, 0x23, 0x06, 0xca, 0x10,
-  0x94, 0x81, 0x04, 0x55, 0x89, 0x82, 0x08, 0x83, 0x0c, 0x41, 0xe1, 0x8c,
-  0x18, 0x28, 0x43, 0x70, 0x06, 0x93, 0x74, 0x2d, 0x8c, 0x42, 0x0c, 0x32,
-  0x04, 0x87, 0x33, 0xc8, 0x10, 0x28, 0xd2, 0x20, 0x03, 0x11, 0x50, 0x97,
-  0xdd, 0xa5, 0xa0, 0x0c, 0x32, 0x04, 0x0c, 0x65, 0x44, 0x00, 0x1f, 0xf2,
-  0xca, 0x78, 0x83, 0x37, 0x06, 0x6f, 0x70, 0xc1, 0x5d, 0x0a, 0xca, 0x20,
-  0x43, 0x20, 0x69, 0x23, 0x06, 0x85, 0x10, 0xd4, 0x81, 0x11, 0x8c, 0x37,
-  0x8c, 0x01, 0x1a, 0xc4, 0xc1, 0x05, 0x77, 0x29, 0x28, 0x83, 0x0c, 0xc1,
-  0xf5, 0x8d, 0x18, 0x14, 0x42, 0xa0, 0x07, 0x4b, 0x30, 0xde, 0x80, 0x06,
-  0x6d, 0x20, 0x07, 0x17, 0xdc, 0xa5, 0xa0, 0x0c, 0x32, 0x04, 0x1c, 0x19,
-  0x8c, 0x18, 0x14, 0x42, 0xf0, 0x07, 0x50, 0x30, 0xc7, 0xf0, 0x2d, 0x7d,
-  0x30, 0xc7, 0x10, 0x1c, 0x7f, 0x30, 0xc7, 0x10, 0x0c, 0x7d, 0x60, 0xc1,
-  0x24, 0x9f, 0x0c, 0x02, 0x62, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
-  0x5b, 0x06, 0x25, 0x18, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00
+  0xfc, 0x01, 0x00, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x7b, 0x00,
+  0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01,
+  0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78,
+  0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4,
+  0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c,
+  0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03,
+  0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70,
+  0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70,
+  0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec,
+  0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0,
+  0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d,
+  0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43,
+  0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0,
+  0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68,
+  0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28,
+  0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08,
+  0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee,
+  0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62,
+  0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c,
+  0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06,
+  0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43,
+  0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3,
+  0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3,
+  0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68,
+  0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce,
+  0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3,
+  0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d,
+  0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e,
+  0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51,
+  0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60,
+  0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98,
+  0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e,
+  0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e,
+  0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83,
+  0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2,
+  0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a,
+  0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28,
+  0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5,
+  0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17,
+  0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83,
+  0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3,
+  0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3,
+  0x3c, 0x00, 0x71, 0x20, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x16, 0xd0,
+  0x00, 0x48, 0xe4, 0x0f, 0xce, 0xe4, 0x57, 0x77, 0x71, 0xdb, 0x26, 0xb0,
+  0x01, 0x48, 0xe4, 0x4b, 0x00, 0xf3, 0x2c, 0xc4, 0x3f, 0x11, 0xd7, 0x44,
+  0x45, 0xc4, 0x6f, 0x0f, 0x7e, 0x85, 0x17, 0xb7, 0x6d, 0x00, 0x11, 0xdb,
+  0x95, 0xff, 0xf9, 0xda, 0xf5, 0x5f, 0x44, 0x80, 0xc1, 0x10, 0xcd, 0x04,
+  0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x13, 0x04,
+  0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x74, 0x47,
+  0x00, 0xa8, 0x8e, 0x35, 0x00, 0x03, 0x31, 0xc7, 0x40, 0x0c, 0xdf, 0x1c,
+  0x03, 0xf1, 0x7d, 0x63, 0x0d, 0x40, 0x20, 0x10, 0x1c, 0x4b, 0x08, 0x00,
+  0x72, 0x35, 0x30, 0x02, 0x40, 0x6f, 0x06, 0x80, 0xe0, 0x08, 0x00, 0x89,
+  0x19, 0x00, 0x0a, 0x73, 0x10, 0x66, 0x60, 0x06, 0x66, 0x40, 0x06, 0x33,
+  0x00, 0x04, 0xc6, 0x08, 0x40, 0x10, 0x04, 0xf1, 0x6f, 0x04, 0x60, 0x06,
+  0x00, 0x00, 0x23, 0x06, 0xca, 0x10, 0x94, 0xc1, 0x14, 0x55, 0xca, 0x91,
+  0x08, 0x83, 0x0c, 0x41, 0xe1, 0x8c, 0x18, 0x28, 0x43, 0x70, 0x06, 0xd4,
+  0x74, 0x31, 0xc9, 0x42, 0x0c, 0x32, 0x04, 0x87, 0x33, 0xc8, 0x10, 0x28,
+  0xd2, 0x20, 0x03, 0x11, 0x50, 0xa7, 0xd9, 0xa5, 0xa0, 0x0c, 0x32, 0x04,
+  0x0c, 0x65, 0x44, 0x00, 0x9f, 0xf1, 0x06, 0x4f, 0x73, 0x83, 0x0b, 0xec,
+  0x52, 0x50, 0x06, 0x19, 0x82, 0x28, 0x1b, 0x31, 0x28, 0x84, 0x80, 0x0e,
+  0x8a, 0x60, 0xbc, 0x61, 0x0c, 0x3e, 0x38, 0xb8, 0xc0, 0x2e, 0x05, 0x65,
+  0x90, 0x21, 0xb0, 0xbc, 0x11, 0x83, 0x42, 0x08, 0xf2, 0x40, 0x09, 0xc6,
+  0x1b, 0xd0, 0x80, 0x0c, 0xe2, 0xe0, 0x02, 0xbb, 0x14, 0x94, 0x41, 0x86,
+  0x60, 0x1b, 0x83, 0x11, 0x83, 0x42, 0x08, 0xfc, 0xe0, 0x09, 0xe6, 0x18,
+  0xbc, 0x85, 0x0f, 0xe6, 0x18, 0x82, 0xc3, 0x0f, 0xe6, 0x18, 0x82, 0x81,
+  0x0f, 0x2c, 0x90, 0x03, 0xf9, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 };
-const unsigned int sdl_metallib_len = 22048;
+const unsigned int sdl_metallib_len = 21810;
diff --git a/Engine/lib/sdl/src/render/metal/SDL_shaders_metal_tvsimulator.h b/Engine/lib/sdl/src/render/metal/SDL_shaders_metal_tvsimulator.h
index a19c28ec3..2ceddcf10 100644
--- a/Engine/lib/sdl/src/render/metal/SDL_shaders_metal_tvsimulator.h
+++ b/Engine/lib/sdl/src/render/metal/SDL_shaders_metal_tvsimulator.h
@@ -1,19 +1,19 @@
 const unsigned char sdl_metallib[] = {
   0x4d, 0x54, 0x4c, 0x42, 0x01, 0x00, 0x02, 0x00, 0x05, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0xc2, 0x61, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x64, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xae, 0x03, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x0e, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8a, 0x04, 0x00, 0x00,
+  0x8e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9c, 0x04, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0xc2, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5d, 0x00, 0x00,
+  0xd4, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0x5b, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x86, 0x00, 0x00, 0x00,
   0x4e, 0x41, 0x4d, 0x45, 0x11, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x53, 0x6f,
   0x6c, 0x69, 0x64, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x00, 0x54,
   0x59, 0x50, 0x45, 0x01, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00,
-  0xa1, 0x1a, 0x08, 0xa6, 0xd4, 0x06, 0x5b, 0x9f, 0x1d, 0x1a, 0x7e, 0x1c,
-  0x9e, 0xf1, 0x2b, 0xa9, 0x09, 0x12, 0x30, 0x70, 0xf6, 0x82, 0xb1, 0x5a,
-  0xac, 0x6b, 0xa9, 0xd3, 0x14, 0x34, 0xcd, 0x0b, 0x4d, 0x44, 0x53, 0x5a,
-  0x08, 0x00, 0xa0, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f, 0x46,
+  0x0c, 0x89, 0xfb, 0xf3, 0x80, 0x90, 0x8e, 0x7b, 0x79, 0xce, 0x85, 0xbe,
+  0x02, 0x5a, 0x26, 0xb3, 0x39, 0x94, 0x89, 0x06, 0x15, 0xa3, 0x7c, 0x33,
+  0xd4, 0xcb, 0xcd, 0x46, 0xe6, 0x32, 0x49, 0x18, 0x4d, 0x44, 0x53, 0x5a,
+  0x08, 0x00, 0x30, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f, 0x46,
   0x46, 0x54, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x02, 0x00,
@@ -21,513 +21,246 @@ const unsigned char sdl_metallib[] = {
   0x00, 0x00, 0x4e, 0x41, 0x4d, 0x45, 0x10, 0x00, 0x53, 0x44, 0x4c, 0x5f,
   0x43, 0x6f, 0x70, 0x79, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x00,
   0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48, 0x20,
-  0x00, 0xbf, 0x74, 0x9c, 0x9c, 0xf6, 0x5a, 0xa7, 0xf1, 0x7f, 0x79, 0xbd,
-  0xbf, 0x4f, 0x66, 0xef, 0xad, 0x72, 0xbc, 0xd5, 0x58, 0x86, 0xf4, 0xf9,
-  0xdc, 0x10, 0x57, 0x64, 0xbc, 0x42, 0x49, 0x7d, 0xe4, 0x4d, 0x44, 0x53,
-  0x5a, 0x08, 0x00, 0xe0, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f,
-  0x46, 0x46, 0x54, 0x18, 0x00, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0, 0x0c, 0x00,
+  0x00, 0xc8, 0xfe, 0x88, 0x61, 0xa2, 0xe6, 0xe3, 0x42, 0xf3, 0x2b, 0x5b,
+  0x2a, 0x0e, 0x54, 0x9a, 0xec, 0x71, 0xac, 0x02, 0xfb, 0x88, 0xa2, 0x85,
+  0x0e, 0x9c, 0x45, 0x93, 0x65, 0x23, 0xd3, 0xd3, 0x45, 0x4d, 0x44, 0x53,
+  0x5a, 0x08, 0x00, 0x30, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f,
+  0x46, 0x46, 0x54, 0x18, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x0d, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x02,
   0x00, 0x02, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x88,
   0x00, 0x00, 0x00, 0x4e, 0x41, 0x4d, 0x45, 0x13, 0x00, 0x53, 0x44, 0x4c,
   0x5f, 0x53, 0x6f, 0x6c, 0x69, 0x64, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d,
   0x65, 0x6e, 0x74, 0x00, 0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48,
-  0x41, 0x53, 0x48, 0x20, 0x00, 0x4c, 0x67, 0xd2, 0xbf, 0xc5, 0x1c, 0xd8,
-  0x80, 0xdb, 0xde, 0xed, 0xf1, 0xfa, 0xe2, 0x4a, 0x01, 0x5f, 0x48, 0xf0,
-  0xc3, 0x0b, 0xdf, 0xba, 0x45, 0x78, 0xd5, 0x1a, 0x12, 0x3b, 0x34, 0xdc,
-  0x52, 0x4d, 0x44, 0x53, 0x5a, 0x08, 0x00, 0x90, 0x0a, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x4f, 0x46, 0x46, 0x54, 0x18, 0x00, 0x54, 0x00, 0x00,
+  0x41, 0x53, 0x48, 0x20, 0x00, 0xb3, 0x8a, 0x68, 0x2a, 0xd9, 0x82, 0x7b,
+  0x43, 0xfb, 0xac, 0xd7, 0x0b, 0x21, 0xbf, 0x15, 0x37, 0x2d, 0x69, 0xf4,
+  0x5e, 0xa9, 0xbf, 0xea, 0x08, 0xb5, 0xae, 0xdd, 0x08, 0xa0, 0x57, 0x15,
+  0x34, 0x4d, 0x44, 0x53, 0x5a, 0x08, 0x00, 0x30, 0x0a, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x4f, 0x46, 0x46, 0x54, 0x18, 0x00, 0x66, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x80, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52,
+  0x00, 0x60, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52,
   0x53, 0x08, 0x00, 0x02, 0x00, 0x02, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45,
   0x4e, 0x44, 0x54, 0x87, 0x00, 0x00, 0x00, 0x4e, 0x41, 0x4d, 0x45, 0x12,
   0x00, 0x53, 0x44, 0x4c, 0x5f, 0x43, 0x6f, 0x70, 0x79, 0x5f, 0x66, 0x72,
   0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x00, 0x54, 0x59, 0x50, 0x45, 0x01,
-  0x00, 0x01, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00, 0xf2, 0x3f, 0x0e, 0xaf,
-  0x26, 0xec, 0x90, 0x97, 0x14, 0x10, 0x3e, 0xe4, 0x09, 0xeb, 0xcd, 0x08,
-  0x39, 0xe4, 0xef, 0x15, 0x4c, 0xd5, 0xc4, 0x48, 0x4d, 0x93, 0xbf, 0x0e,
-  0xd3, 0xa0, 0x84, 0xa0, 0x4d, 0x44, 0x53, 0x5a, 0x08, 0x00, 0x80, 0x0c,
+  0x00, 0x01, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00, 0x3a, 0xdb, 0x4f, 0xd9,
+  0x5c, 0xa8, 0x18, 0xff, 0x1d, 0x96, 0x7f, 0x0d, 0xce, 0x02, 0xc1, 0xaf,
+  0x38, 0xef, 0x15, 0x30, 0x92, 0x06, 0x8f, 0xfe, 0xa9, 0x07, 0x34, 0xfb,
+  0x22, 0x93, 0xdc, 0xf9, 0x4d, 0x44, 0x53, 0x5a, 0x08, 0x00, 0xc0, 0x0b,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f, 0x46, 0x46, 0x54, 0x18, 0x00,
-  0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x10, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x90, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x02, 0x00, 0x02, 0x00, 0x01, 0x00,
   0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x86, 0x00, 0x00, 0x00, 0x4e, 0x41,
   0x4d, 0x45, 0x11, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x59, 0x55, 0x56, 0x5f,
   0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x00, 0x54, 0x59, 0x50,
-  0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00, 0x1b, 0x3d,
-  0x7f, 0xbb, 0x00, 0x92, 0x05, 0xf2, 0xfe, 0xfc, 0xcc, 0xc2, 0xd7, 0x71,
-  0x65, 0x40, 0x45, 0xaf, 0xee, 0xfc, 0x35, 0x50, 0x11, 0x09, 0xdf, 0x8b,
-  0xc7, 0x5e, 0xea, 0x7e, 0x39, 0x69, 0x4d, 0x44, 0x53, 0x5a, 0x08, 0x00,
-  0x40, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f, 0x46, 0x46, 0x54,
-  0x18, 0x00, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0x30, 0x00, 0x00, 0x00, 0x00,
+  0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00, 0x26, 0x67,
+  0x01, 0x40, 0x41, 0x64, 0x85, 0x58, 0xad, 0x6c, 0x46, 0xe8, 0xbf, 0x1a,
+  0x79, 0x22, 0x12, 0x67, 0x32, 0x81, 0x20, 0xca, 0x22, 0xde, 0xc9, 0xc5,
+  0xa1, 0x0a, 0x41, 0xfe, 0xd9, 0xa3, 0x4d, 0x44, 0x53, 0x5a, 0x08, 0x00,
+  0xd0, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f, 0x46, 0x46, 0x54,
+  0x18, 0x00, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x30, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x02, 0x00, 0x02, 0x00,
   0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x87, 0x00, 0x00, 0x00,
   0x4e, 0x41, 0x4d, 0x45, 0x12, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x4e, 0x56,
   0x31, 0x32, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x00,
   0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53, 0x48, 0x20,
-  0x00, 0x63, 0xd6, 0x78, 0xc5, 0xa7, 0x85, 0xa1, 0x37, 0xa6, 0xa2, 0xed,
-  0x14, 0xb5, 0x6e, 0x7f, 0x89, 0x3f, 0xbc, 0x1f, 0xee, 0x5e, 0xbb, 0x28,
-  0x68, 0x8c, 0x1a, 0x62, 0xdf, 0x43, 0xfa, 0x11, 0x1c, 0x4d, 0x44, 0x53,
-  0x5a, 0x08, 0x00, 0x90, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f,
-  0x46, 0x46, 0x54, 0x18, 0x00, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd0, 0x3f, 0x00,
+  0x00, 0xff, 0x5a, 0xf7, 0xe3, 0x70, 0x77, 0x5e, 0x01, 0xaf, 0xf6, 0x9f,
+  0x0b, 0xa1, 0x25, 0x76, 0xbf, 0xa1, 0x1f, 0xfb, 0x62, 0xbf, 0x02, 0xfa,
+  0xa4, 0x10, 0x0d, 0xe9, 0x0f, 0x97, 0x2d, 0x3e, 0xca, 0x4d, 0x44, 0x53,
+  0x5a, 0x08, 0x00, 0x30, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f,
+  0x46, 0x46, 0x54, 0x18, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x3f, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x02,
   0x00, 0x02, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x87,
   0x00, 0x00, 0x00, 0x4e, 0x41, 0x4d, 0x45, 0x12, 0x00, 0x53, 0x44, 0x4c,
   0x5f, 0x4e, 0x56, 0x32, 0x31, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65,
   0x6e, 0x74, 0x00, 0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41,
-  0x53, 0x48, 0x20, 0x00, 0x59, 0x98, 0xa1, 0x99, 0x21, 0x4f, 0xf0, 0xd6,
-  0x63, 0xb1, 0x37, 0x97, 0x47, 0x88, 0xe9, 0xe8, 0x3a, 0x95, 0x75, 0xbd,
-  0x84, 0x48, 0x90, 0xa6, 0x3c, 0x11, 0x3b, 0xfc, 0xac, 0xd2, 0xa7, 0x1f,
-  0x4d, 0x44, 0x53, 0x5a, 0x08, 0x00, 0xa0, 0x0e, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x4f, 0x46, 0x46, 0x54, 0x18, 0x00, 0x74, 0x00, 0x00, 0x00,
+  0x53, 0x48, 0x20, 0x00, 0xdb, 0xf5, 0x5b, 0x6b, 0x9e, 0xad, 0xda, 0x32,
+  0x16, 0x65, 0xd3, 0x04, 0x29, 0x2b, 0xc3, 0x71, 0xb9, 0x29, 0x97, 0xe1,
+  0x4c, 0xa7, 0x36, 0x12, 0x81, 0x50, 0x19, 0xa9, 0x4b, 0x3f, 0xe8, 0xdb,
+  0x4d, 0x44, 0x53, 0x5a, 0x08, 0x00, 0x40, 0x0e, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x4f, 0x46, 0x46, 0x54, 0x18, 0x00, 0x86, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x60, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53,
+  0x50, 0x4d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53,
   0x08, 0x00, 0x02, 0x00, 0x02, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e,
-  0x44, 0x54, 0x45, 0x4e, 0x44, 0x54, 0x20, 0x00, 0x00, 0x00, 0x56, 0x41,
-  0x54, 0x54, 0x0d, 0x00, 0x01, 0x00, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69,
-  0x6f, 0x6e, 0x00, 0x00, 0x80, 0x56, 0x41, 0x54, 0x59, 0x03, 0x00, 0x01,
-  0x00, 0x04, 0x45, 0x4e, 0x44, 0x54, 0x2c, 0x00, 0x00, 0x00, 0x56, 0x41,
-  0x54, 0x54, 0x18, 0x00, 0x02, 0x00, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69,
-  0x6f, 0x6e, 0x00, 0x00, 0x80, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72,
-  0x64, 0x00, 0x01, 0x80, 0x56, 0x41, 0x54, 0x59, 0x04, 0x00, 0x02, 0x00,
-  0x04, 0x04, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e,
-  0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00,
-  0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e,
-  0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00,
-  0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e,
-  0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00,
-  0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e,
-  0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00,
-  0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00,
-  0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x8c, 0x0c, 0x00, 0x00, 0xff, 0xff,
-  0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x35, 0x14, 0x00, 0x00, 0x03, 0x00,
-  0x00, 0x00, 0x62, 0x0c, 0x30, 0x24, 0x80, 0x10, 0x05, 0xc8, 0x14, 0x00,
-  0x00, 0x00, 0x21, 0x0c, 0x00, 0x00, 0xe9, 0x02, 0x00, 0x00, 0x0b, 0x02,
-  0x21, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x07, 0x81,
-  0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01,
-  0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14,
-  0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08,
-  0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88, 0x48, 0x90, 0x14, 0x20, 0x43, 0x46,
-  0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0x04, 0x49, 0x0e, 0x90, 0x91, 0x22,
-  0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x29,
-  0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x85, 0x00, 0x00, 0x00, 0x1b, 0xc8,
-  0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x80, 0x8a, 0x18, 0x87,
-  0x77, 0x90, 0x07, 0x79, 0x28, 0x87, 0x71, 0xa0, 0x07, 0x76, 0xc8, 0x87,
-  0x36, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x77, 0x20, 0x87, 0x72, 0x20, 0x87,
-  0x36, 0x20, 0x87, 0x74, 0xb0, 0x87, 0x74, 0x20, 0x87, 0x72, 0x68, 0x83,
-  0x79, 0x88, 0x07, 0x79, 0xa0, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83,
-  0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6,
-  0xa1, 0x1c, 0x00, 0x82, 0x1c, 0xd2, 0x61, 0x1e, 0xc2, 0x41, 0x1c, 0xd8,
-  0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xc2, 0x21, 0x1d, 0xd8, 0xa1, 0x0d, 0xc6,
-  0x21, 0x1c, 0xd8, 0x81, 0x1d, 0xe6, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87,
-  0x79, 0x28, 0x07, 0x80, 0x60, 0x87, 0x72, 0x98, 0x87, 0x79, 0x68, 0x03,
-  0x78, 0x90, 0x87, 0x72, 0x18, 0x87, 0x74, 0x98, 0x87, 0x72, 0x68, 0x03,
-  0x73, 0x80, 0x87, 0x76, 0x08, 0x07, 0x72, 0x00, 0xcc, 0x21, 0x1c, 0xd8,
-  0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4,
-  0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc,
-  0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda,
-  0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x06, 0x77, 0x78, 0x87,
-  0x36, 0x30, 0x07, 0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87,
-  0x77, 0x48, 0x07, 0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07,
-  0x76, 0x48, 0x87, 0x76, 0x68, 0x03, 0x77, 0x78, 0x07, 0x77, 0x68, 0x03,
-  0x76, 0x28, 0x87, 0x70, 0x30, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83,
-  0x74, 0x70, 0x07, 0x73, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83,
-  0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca,
-  0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x40, 0x1d, 0xea, 0xa1, 0x1d, 0xe0,
-  0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x1e, 0x00,
-  0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87,
-  0x36, 0x70, 0x87, 0x70, 0x70, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87,
-  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea,
-  0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xce,
-  0xc1, 0x1d, 0xca, 0x81, 0x1c, 0xda, 0x40, 0x1f, 0xca, 0x41, 0x1e, 0xde,
-  0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8,
-  0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87,
-  0x77, 0x68, 0x03, 0x7a, 0x90, 0x87, 0x70, 0x80, 0x07, 0x78, 0x48, 0x07,
-  0x77, 0x38, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8,
-  0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0x62, 0x1e, 0xe8, 0x21, 0x1c, 0xc6,
-  0x61, 0x1d, 0xda, 0x00, 0x1e, 0xe4, 0xe1, 0x1d, 0xe8, 0xa1, 0x1c, 0xc6,
-  0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0x40, 0x1c, 0xea, 0xc1, 0x1c, 0xcc,
-  0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xf4, 0xa1, 0x1c, 0x00,
-  0x3c, 0x00, 0x88, 0x7a, 0x70, 0x87, 0x79, 0x08, 0x07, 0x73, 0x28, 0x87,
+  0x44, 0x54, 0x45, 0x4e, 0x44, 0x54, 0x29, 0x00, 0x00, 0x00, 0x56, 0x41,
+  0x54, 0x54, 0x15, 0x00, 0x02, 0x00, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69,
+  0x6f, 0x6e, 0x00, 0x00, 0x80, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x00, 0x01,
+  0x80, 0x56, 0x41, 0x54, 0x59, 0x04, 0x00, 0x02, 0x00, 0x04, 0x06, 0x45,
+  0x4e, 0x44, 0x54, 0x35, 0x00, 0x00, 0x00, 0x56, 0x41, 0x54, 0x54, 0x20,
+  0x00, 0x03, 0x00, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x00,
+  0x00, 0x80, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x00, 0x01, 0x80, 0x74, 0x65,
+  0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x00, 0x02, 0x80, 0x56, 0x41, 0x54,
+  0x59, 0x05, 0x00, 0x03, 0x00, 0x04, 0x06, 0x04, 0x45, 0x4e, 0x44, 0x54,
+  0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00,
+  0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54,
+  0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00,
+  0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54,
+  0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00,
+  0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54,
+  0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00,
+  0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54,
+  0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+  0x10, 0x0d, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde,
+  0x35, 0x14, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x62, 0x0c, 0x30, 0x24,
+  0x80, 0x10, 0x05, 0xc8, 0x14, 0x00, 0x00, 0x00, 0x21, 0x0c, 0x00, 0x00,
+  0x09, 0x03, 0x00, 0x00, 0x0b, 0x02, 0x21, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x13, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49,
+  0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19,
+  0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42,
+  0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88,
+  0x48, 0x90, 0x14, 0x20, 0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42,
+  0x04, 0x49, 0x0e, 0x90, 0x91, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c,
+  0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x29, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00,
+  0x85, 0x00, 0x00, 0x00, 0x1b, 0xc8, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff,
+  0x01, 0x90, 0x80, 0x8a, 0x18, 0x87, 0x77, 0x90, 0x07, 0x79, 0x28, 0x87,
+  0x71, 0xa0, 0x07, 0x76, 0xc8, 0x87, 0x36, 0x90, 0x87, 0x77, 0xa8, 0x07,
+  0x77, 0x20, 0x87, 0x72, 0x20, 0x87, 0x36, 0x20, 0x87, 0x74, 0xb0, 0x87,
+  0x74, 0x20, 0x87, 0x72, 0x68, 0x83, 0x79, 0x88, 0x07, 0x79, 0xa0, 0x87,
   0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07,
-  0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xea, 0x61, 0x1e, 0xca,
-  0xa1, 0x0d, 0xe6, 0xe1, 0x1d, 0xcc, 0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xd8,
-  0xe1, 0x1d, 0xc2, 0x81, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87,
-  0x72, 0x00, 0x36, 0x2c, 0x82, 0x00, 0x24, 0xc0, 0x02, 0x54, 0x41, 0x1a,
-  0x80, 0xc2, 0x86, 0x65, 0x18, 0x80, 0x04, 0x58, 0x80, 0x2a, 0x48, 0x03,
-  0x50, 0x00, 0x49, 0x18, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x86,
-  0x40, 0x18, 0x00, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x1b, 0x00,
-  0x00, 0x00, 0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22,
-  0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c,
-  0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x40, 0x33, 0x00, 0xc3, 0x08,
-  0x04, 0x60, 0x85, 0x00, 0x86, 0x11, 0x04, 0x20, 0x09, 0xc2, 0x4c, 0xd4,
-  0x3c, 0xd0, 0x83, 0x3c, 0xd4, 0xc3, 0x38, 0xd0, 0x83, 0x1b, 0xb4, 0x43,
-  0x39, 0xd0, 0x43, 0x38, 0xb0, 0x83, 0x1e, 0xe8, 0x41, 0x3b, 0x84, 0x03,
-  0x3d, 0xc8, 0x43, 0x3a, 0xe0, 0x03, 0x0a, 0xc8, 0x20, 0x42, 0x21, 0x14,
-  0x42, 0x0c, 0x63, 0xe8, 0x0c, 0x04, 0xcc, 0x11, 0x80, 0x41, 0x0a, 0xa8,
-  0x39, 0x02, 0x50, 0x18, 0x44, 0x08, 0x84, 0x61, 0x04, 0x42, 0x19, 0x01,
-  0x00, 0x00, 0x13, 0xc0, 0x20, 0x1c, 0xd2, 0x41, 0x1e, 0xec, 0x80, 0x0e,
-  0xda, 0x20, 0x1c, 0xe0, 0x01, 0x1e, 0xd8, 0xa1, 0x1c, 0xda, 0x80, 0x1e,
-  0xec, 0xe1, 0x1d, 0xe6, 0x21, 0x0e, 0xe6, 0xc0, 0x0d, 0xe0, 0xc0, 0x0d,
-  0xe0, 0xa0, 0x0d, 0xe6, 0x21, 0x1d, 0xda, 0xa1, 0x1e, 0xd8, 0x21, 0x1c,
-  0xe8, 0xe1, 0x1d, 0xe4, 0x61, 0xc3, 0x6d, 0x94, 0x43, 0x1b, 0xc0, 0x83,
-  0x1e, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01,
-  0x1d, 0xb4, 0x41, 0x3a, 0xc4, 0x81, 0x1e, 0xe0, 0x81, 0x1e, 0xe0, 0x41,
-  0x1b, 0xa4, 0x03, 0x1e, 0xe8, 0x01, 0x1e, 0xe8, 0x01, 0x1e, 0xb4, 0x41,
-  0x3a, 0xc4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xd8, 0x81, 0x1e, 0xc4, 0x81,
-  0x1d, 0xb4, 0x41, 0x3a, 0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81,
-  0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x41, 0x3a, 0xd8, 0x01, 0x1d, 0xe8, 0x81,
-  0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x39, 0xcc, 0x81,
-  0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81,
-  0x39, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01,
-  0x1d, 0xb4, 0x81, 0x3d, 0xc4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xd8, 0x81,
-  0x1e, 0xc4, 0x81, 0x1d, 0xb4, 0x81, 0x3d, 0xc8, 0x01, 0x1d, 0xe8, 0xc1,
-  0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xcc, 0x81,
-  0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81,
-  0x3d, 0xd0, 0x01, 0x1e, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01,
-  0x1d, 0xb4, 0x81, 0x3d, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81,
-  0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xe4, 0x81, 0x1d, 0xe8, 0x41,
-  0x1c, 0xc8, 0x01, 0x1e, 0xe8, 0x41, 0x1c, 0xc8, 0x01, 0x1e, 0xb4, 0x81,
-  0x3d, 0xc4, 0x81, 0x1c, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1c, 0xe0, 0x81,
-  0x1e, 0xc4, 0x81, 0x1c, 0xe0, 0x41, 0x1b, 0xd8, 0x43, 0x1c, 0xe4, 0x81,
-  0x1c, 0xe8, 0x81, 0x1c, 0xd4, 0x81, 0x1d, 0xe8, 0x81, 0x1c, 0xd4, 0x81,
-  0x1d, 0xb4, 0x81, 0x3d, 0xc8, 0x41, 0x1d, 0xd8, 0x81, 0x1e, 0xc8, 0x41,
-  0x1d, 0xd8, 0x81, 0x1e, 0xc8, 0x41, 0x1d, 0xd8, 0x41, 0x1b, 0xd8, 0x43,
-  0x1d, 0xc4, 0x81, 0x1c, 0xe8, 0x41, 0x1d, 0xc4, 0x81, 0x1c, 0xe8, 0x41,
-  0x1d, 0xc4, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xc4, 0x01, 0x1c, 0xc8, 0x01,
-  0x1d, 0xe8, 0x41, 0x1c, 0xc0, 0x81, 0x1c, 0xd0, 0x81, 0x1e, 0xc4, 0x01,
-  0x1c, 0xc8, 0x01, 0x1d, 0xb4, 0x81, 0x3b, 0xe0, 0x81, 0x1e, 0xc4, 0x81,
-  0x1d, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x46, 0x08, 0x43, 0x42, 0x6c, 0x57,
-  0xfe, 0xac, 0xb3, 0x20, 0xc3, 0x5f, 0x11, 0xd1, 0x44, 0x5c, 0x43, 0x22,
-  0x00, 0x3a, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
-  0x40, 0x62, 0x83, 0x40, 0xd1, 0x75, 0x01, 0x00, 0x80, 0x2c, 0x10, 0x00,
-  0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11,
-  0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x52, 0x45, 0x50,
-  0x02, 0x85, 0x30, 0x02, 0x50, 0x80, 0x01, 0x05, 0x52, 0x06, 0xc4, 0x46,
-  0x00, 0x68, 0x8d, 0x25, 0x38, 0x02, 0x00, 0x00, 0x00, 0x00, 0xb1, 0x18,
-  0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1,
-  0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42,
-  0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f,
-  0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1,
-  0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84,
-  0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc,
-  0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70,
-  0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19,
-  0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f,
-  0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21,
-  0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc,
-  0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84,
-  0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37,
-  0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70,
-  0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77,
-  0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79,
-  0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e,
-  0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1,
-  0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81,
-  0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98,
-  0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88,
-  0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4,
-  0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72,
-  0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74,
-  0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e,
-  0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e,
-  0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21,
-  0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01,
-  0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc,
-  0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77,
-  0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e,
-  0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1,
-  0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61,
-  0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0,
-  0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0,
-  0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74,
-  0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e,
-  0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41,
-  0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50,
-  0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c,
-  0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc,
-  0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x79, 0x20, 0x00, 0x00, 0xb4, 0x00,
-  0x00, 0x00, 0x32, 0x9a, 0x08, 0x14, 0x02, 0x85, 0x8c, 0x27, 0x46, 0x46,
-  0xc8, 0x11, 0x32, 0x64, 0xd4, 0x36, 0x0c, 0x6f, 0x00, 0x00, 0x8b, 0xe2,
-  0x06, 0xc5, 0xc6, 0x91, 0x01, 0x13, 0x19, 0x0c, 0xe2, 0x14, 0x09, 0x24,
-  0x79, 0x86, 0xf2, 0x20, 0xd1, 0x85, 0x28, 0x09, 0x00, 0x00, 0x53, 0x44,
-  0x4b, 0x20, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68,
-  0x61, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x41, 0x70, 0x70, 0x6c, 0x65,
-  0x20, 0x4c, 0x4c, 0x56, 0x4d, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f,
-  0x6e, 0x20, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x34, 0x33, 0x20, 0x28,
-  0x6d, 0x65, 0x74, 0x61, 0x6c, 0x66, 0x65, 0x2d, 0x33, 0x31, 0x30, 0x30,
-  0x31, 0x2e, 0x34, 0x33, 0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x61, 0x69,
-  0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x64, 0x65,
-  0x6e, 0x6f, 0x72, 0x6d, 0x73, 0x5f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c,
-  0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65,
-  0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65,
-  0x6e, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d,
-  0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x62, 0x75,
-  0x66, 0x66, 0x65, 0x72, 0x5f, 0x66, 0x65, 0x74, 0x63, 0x68, 0x5f, 0x65,
-  0x6e, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x6f, 0x73,
-  0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67,
-  0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x66, 0x6c,
-  0x6f, 0x61, 0x74, 0x34, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f,
-  0x6e, 0x61, 0x6d, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e,
-  0x61, 0x69, 0x72, 0x2e, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x5f, 0x73, 0x69,
-  0x7a, 0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74,
-  0x53, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x76, 0x65, 0x72, 0x74,
-  0x65, 0x78, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x61, 0x69, 0x72, 0x2e,
-  0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x64,
-  0x65, 0x78, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28,
-  0x5f, 0x5f, 0x61, 0x69, 0x72, 0x5f, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x68,
-  0x6f, 0x6c, 0x64, 0x65, 0x72, 0x5f, 0x5f, 0x29, 0x66, 0x6c, 0x6f, 0x61,
-  0x74, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72,
-  0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73,
-  0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x61, 0x64, 0x61,
-  0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f,
-  0x73, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f,
-  0x74, 0x79, 0x70, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73,
-  0x69, 0x7a, 0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x78, 0x34, 0x70,
-  0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x74, 0x72, 0x61,
-  0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x23, 0x08, 0x4a, 0x30, 0x82, 0xb0,
-  0x24, 0x23, 0x08, 0x8a, 0x30, 0x82, 0xa0, 0x0c, 0x23, 0x08, 0x0a, 0x31,
-  0x82, 0x80, 0x00, 0x23, 0x08, 0x4a, 0x31, 0x82, 0xa0, 0x18, 0x23, 0x08,
-  0xca, 0x31, 0xc3, 0xc0, 0x05, 0xdd, 0x0c, 0x83, 0x27, 0x7c, 0x33, 0x04,
-  0xc3, 0x0c, 0x03, 0xc7, 0x81, 0xc1, 0x0c, 0x04, 0xe1, 0x79, 0x60, 0x30,
-  0x43, 0x50, 0xcc, 0x10, 0x18, 0x33, 0x04, 0xc7, 0x0c, 0x05, 0x92, 0x28,
-  0x0b, 0x33, 0x43, 0xd1, 0x24, 0xce, 0xf2, 0xcc, 0x20, 0xb4, 0x81, 0x1b,
-  0xcc, 0xa0, 0x80, 0x01, 0x14, 0x81, 0x81, 0x27, 0x25, 0xd3, 0xc2, 0xcc,
-  0x00, 0x79, 0x54, 0x25, 0x06, 0x11, 0xe7, 0x59, 0x97, 0x18, 0x60, 0x63,
-  0x90, 0x64, 0x8b, 0x36, 0x03, 0xc4, 0x51, 0x95, 0x18, 0x44, 0x64, 0xe0,
-  0x59, 0x97, 0x18, 0x60, 0x63, 0x90, 0x64, 0xcb, 0x36, 0xc3, 0x00, 0x07,
-  0x71, 0x20, 0x07, 0x33, 0x0c, 0x61, 0xf0, 0x06, 0x73, 0x20, 0x23, 0x81,
-  0x09, 0xba, 0x88, 0x8d, 0xcd, 0xae, 0xcd, 0xa5, 0xed, 0x8d, 0xac, 0x8e,
-  0xad, 0xcc, 0xc5, 0x8c, 0x2d, 0xec, 0x6c, 0x6e, 0x14, 0x81, 0x0c, 0xca,
-  0xe0, 0x14, 0x36, 0x36, 0xbb, 0x36, 0x97, 0x34, 0xb2, 0x32, 0x37, 0xba,
-  0x51, 0x02, 0x33, 0xb8, 0x25, 0x2c, 0x4d, 0xce, 0xc5, 0xae, 0x4c, 0x6e,
-  0x2e, 0xed, 0xcd, 0x6d, 0x94, 0xe0, 0x0c, 0x8e, 0x0a, 0x4b, 0x93, 0x73,
-  0x61, 0x0b, 0x73, 0x3b, 0xab, 0x0b, 0x3b, 0x2b, 0xfb, 0xb2, 0x2b, 0x93,
-  0x9b, 0x4b, 0x7b, 0x73, 0x1b, 0x25, 0x40, 0x83, 0x9b, 0xc2, 0xd2, 0xe4,
-  0x5c, 0xc6, 0xde, 0xda, 0xe0, 0xd2, 0xd8, 0xca, 0xbe, 0xde, 0xe0, 0xe8,
-  0xd2, 0xde, 0xdc, 0xe6, 0x46, 0x19, 0xd2, 0x40, 0x0d, 0xd6, 0xe0, 0x94,
-  0xb0, 0x34, 0x39, 0x17, 0xbb, 0x32, 0x39, 0xba, 0x32, 0xbc, 0x51, 0x82,
-  0x39, 0x00, 0xa9, 0x18, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x0a,
-  0x72, 0x28, 0x87, 0x77, 0x80, 0x07, 0x7a, 0x58, 0x70, 0x98, 0x43, 0x3d,
-  0xb8, 0xc3, 0x38, 0xb0, 0x43, 0x39, 0xd0, 0xc3, 0x82, 0xe6, 0x1c, 0xc6,
-  0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0xc1, 0x1d, 0xe6, 0x21, 0x1d, 0xe8,
-  0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x00, 0xd1, 0x10, 0x00, 0x00, 0x06, 0x00,
-  0x00, 0x00, 0x07, 0xcc, 0x3c, 0xa4, 0x83, 0x3b, 0x9c, 0x03, 0x3b, 0x94,
-  0x03, 0x3d, 0xa0, 0x83, 0x3c, 0x94, 0x43, 0x38, 0x90, 0xc3, 0x01, 0x00,
-  0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x13, 0x04,
-  0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0xc4, 0x4a,
-  0xa0, 0x0c, 0x8a, 0x80, 0xdc, 0x08, 0xc0, 0x58, 0x44, 0x10, 0x04, 0xc1,
-  0x58, 0x84, 0x20, 0x08, 0xc2, 0x58, 0xc4, 0x30, 0x0c, 0x03, 0x81, 0x31,
-  0x02, 0x10, 0x04, 0x41, 0xfc, 0xa3, 0x30, 0x03, 0x40, 0x62, 0x06, 0x80,
-  0xc6, 0x0c, 0x00, 0x00, 0x00, 0x00, 0xf1, 0x30, 0x00, 0x00, 0x11, 0x00,
-  0x00, 0x00, 0x22, 0x47, 0xc8, 0x90, 0x51, 0x0a, 0x84, 0x18, 0x00, 0x00,
-  0x00, 0x00, 0xcf, 0x03, 0x00, 0x00, 0x6f, 0x6d, 0x6e, 0x69, 0x70, 0x6f,
-  0x74, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x68, 0x61, 0x72, 0x53, 0x69, 0x6d,
-  0x70, 0x6c, 0x65, 0x20, 0x43, 0x2b, 0x2b, 0x20, 0x54, 0x42, 0x41, 0x41,
-  0x00, 0x00, 0x13, 0x04, 0x06, 0xd9, 0x10, 0xd8, 0xc1, 0x86, 0xa1, 0x0e,
-  0xf0, 0xe0, 0x0e, 0x36, 0x0c, 0x79, 0x90, 0x07, 0x77, 0x00, 0xbb, 0x10,
-  0x0c, 0x44, 0x41, 0x14, 0x84, 0xb2, 0x0b, 0xf1, 0x48, 0x96, 0x44, 0x41,
-  0x28, 0x83, 0x0c, 0xc3, 0xc1, 0x98, 0x10, 0x88, 0xff, 0x2e, 0xc4, 0x64,
-  0x69, 0x11, 0x05, 0xa1, 0x0c, 0x32, 0x1c, 0xcb, 0x63, 0x42, 0x20, 0xfe,
-  0x16, 0x14, 0xe0, 0xbf, 0x0b, 0x81, 0x6d, 0x1f, 0x45, 0x41, 0x28, 0x83,
-  0x0c, 0x0c, 0x34, 0x99, 0x10, 0x88, 0xbf, 0x15, 0x01, 0xf8, 0xef, 0x42,
-  0x74, 0x60, 0x40, 0x06, 0x1a, 0x05, 0xa1, 0x0c, 0x32, 0x44, 0xd5, 0x65,
-  0x42, 0x20, 0xfe, 0x56, 0x04, 0xe0, 0xbf, 0x0b, 0x11, 0x06, 0x65, 0x90,
-  0x06, 0x60, 0x40, 0x41, 0x28, 0x83, 0x0c, 0x81, 0xf6, 0x59, 0x50, 0x89,
-  0xff, 0x20, 0xc3, 0xc0, 0x81, 0x81, 0x05, 0x93, 0xf8, 0xdb, 0x10, 0x80,
-  0xff, 0x20, 0x83, 0xf1, 0x89, 0x81, 0x05, 0x91, 0xf8, 0xdb, 0x10, 0x80,
-  0xff, 0x20, 0x43, 0x22, 0x06, 0x64, 0x60, 0xc1, 0x23, 0xfe, 0x36, 0x04,
-  0xe0, 0xbf, 0x0b, 0xe1, 0x06, 0x72, 0x60, 0x07, 0x6c, 0x40, 0x41, 0x28,
-  0x83, 0x0c, 0xc1, 0x19, 0xb0, 0x81, 0x05, 0x62, 0x20, 0xfe, 0x83, 0x0c,
-  0x43, 0x1a, 0xb4, 0x81, 0x05, 0x60, 0x20, 0xfe, 0x83, 0x0c, 0xc5, 0x1a,
-  0xb8, 0x81, 0x05, 0x9d, 0xf8, 0x0f, 0x32, 0x1c, 0x6d, 0xf0, 0x06, 0x16,
-  0x68, 0xe2, 0x3f, 0xc8, 0xa0, 0x07, 0x6d, 0x40, 0x07, 0x96, 0x05, 0xe2,
-  0x3f, 0xc8, 0xc0, 0x07, 0x6f, 0x50, 0x07, 0xe6, 0x04, 0xe2, 0x6f, 0xc9,
-  0x00, 0xfe, 0x16, 0x30, 0xe0, 0x6f, 0x41, 0x02, 0xfe, 0x16, 0x20, 0xe0,
-  0x6f, 0x41, 0x01, 0xfe, 0xb3, 0x0d, 0x77, 0x10, 0x00, 0xb3, 0x0d, 0x81,
-  0x1e, 0x04, 0x19, 0x04, 0xc4, 0x00, 0x09, 0x00, 0x00, 0x00, 0x5b, 0x86,
-  0x20, 0xc8, 0x83, 0x2d, 0xc3, 0x10, 0xe4, 0xc1, 0x96, 0xe1, 0x08, 0xf2,
-  0x60, 0xcb, 0xc0, 0x04, 0x79, 0xb0, 0x65, 0x88, 0x82, 0x3c, 0xd8, 0x32,
-  0x58, 0x41, 0x1e, 0x6c, 0x19, 0xc6, 0x20, 0xc8, 0x03, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x32, 0x0e,
-  0x10, 0x22, 0x84, 0x00, 0x82, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x65, 0x0c, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x12, 0x03,
-  0x94, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x10, 0x00,
-  0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x01, 0x00,
-  0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x00,
-  0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x24,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5d, 0x0c, 0x00, 0x00, 0x11, 0x00,
-  0x00, 0x00, 0x12, 0x03, 0x94, 0x78, 0x00, 0x00, 0x00, 0x00, 0x53, 0x44,
-  0x4c, 0x5f, 0x53, 0x6f, 0x6c, 0x69, 0x64, 0x5f, 0x76, 0x65, 0x72, 0x74,
-  0x65, 0x78, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x34, 0x33, 0x61, 0x69,
-  0x72, 0x36, 0x34, 0x2d, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2d, 0x74, 0x76,
-  0x6f, 0x73, 0x31, 0x33, 0x2e, 0x30, 0x2e, 0x30, 0x2d, 0x73, 0x69, 0x6d,
-  0x75, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0,
-  0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0xcc, 0x0c,
-  0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x35, 0x14,
-  0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x62, 0x0c, 0x30, 0x24, 0x80, 0x10,
-  0x05, 0xc8, 0x14, 0x00, 0x00, 0x00, 0x21, 0x0c, 0x00, 0x00, 0xf9, 0x02,
-  0x00, 0x00, 0x0b, 0x02, 0x21, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00,
-  0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10,
-  0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04,
-  0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10,
-  0x32, 0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88, 0x48, 0x90,
-  0x14, 0x20, 0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0x04, 0x49,
-  0x0e, 0x90, 0x91, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83,
-  0xe5, 0x8a, 0x04, 0x29, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x85, 0x00,
-  0x00, 0x00, 0x1b, 0xc8, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90,
-  0x80, 0x8a, 0x18, 0x87, 0x77, 0x90, 0x07, 0x79, 0x28, 0x87, 0x71, 0xa0,
-  0x07, 0x76, 0xc8, 0x87, 0x36, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x77, 0x20,
-  0x87, 0x72, 0x20, 0x87, 0x36, 0x20, 0x87, 0x74, 0xb0, 0x87, 0x74, 0x20,
-  0x87, 0x72, 0x68, 0x83, 0x79, 0x88, 0x07, 0x79, 0xa0, 0x87, 0x36, 0x30,
-  0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0xc0, 0x1c,
-  0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1c, 0xd2, 0x61, 0x1e,
-  0xc2, 0x41, 0x1c, 0xd8, 0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xc2, 0x21, 0x1d,
-  0xd8, 0xa1, 0x0d, 0xc6, 0x21, 0x1c, 0xd8, 0x81, 0x1d, 0xe6, 0x01, 0x30,
-  0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x60, 0x87, 0x72, 0x98,
-  0x87, 0x79, 0x68, 0x03, 0x78, 0x90, 0x87, 0x72, 0x18, 0x87, 0x74, 0x98,
-  0x87, 0x72, 0x68, 0x03, 0x73, 0x80, 0x87, 0x76, 0x08, 0x07, 0x72, 0x00,
-  0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
-  0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e,
-  0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c,
-  0xd8, 0x21, 0x1d, 0xda, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00,
-  0x06, 0x77, 0x78, 0x87, 0x36, 0x30, 0x07, 0x79, 0x08, 0x87, 0x76, 0x28,
-  0x87, 0x36, 0x80, 0x87, 0x77, 0x48, 0x07, 0x77, 0xa0, 0x87, 0x72, 0x90,
-  0x87, 0x36, 0x28, 0x07, 0x76, 0x48, 0x87, 0x76, 0x68, 0x03, 0x77, 0x78,
-  0x07, 0x77, 0x68, 0x03, 0x76, 0x28, 0x87, 0x70, 0x30, 0x07, 0x80, 0x70,
-  0x87, 0x77, 0x68, 0x83, 0x74, 0x70, 0x07, 0x73, 0x98, 0x87, 0x36, 0x30,
-  0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e,
-  0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x40, 0x1d,
-  0xea, 0xa1, 0x1d, 0xe0, 0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xc4, 0x81, 0x1d,
-  0xca, 0x61, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00,
-  0x08, 0x77, 0x78, 0x87, 0x36, 0x70, 0x87, 0x70, 0x70, 0x87, 0x79, 0x68,
-  0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00,
-  0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d,
-  0xe6, 0x21, 0x1d, 0xce, 0xc1, 0x1d, 0xca, 0x81, 0x1c, 0xda, 0x40, 0x1f,
-  0xca, 0x41, 0x1e, 0xde, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d,
-  0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28,
-  0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x7a, 0x90, 0x87, 0x70, 0x80,
-  0x07, 0x78, 0x48, 0x07, 0x77, 0x38, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0,
-  0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0x62, 0x1e,
-  0xe8, 0x21, 0x1c, 0xc6, 0x61, 0x1d, 0xda, 0x00, 0x1e, 0xe4, 0xe1, 0x1d,
-  0xe8, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0x40, 0x1c,
-  0xea, 0xc1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xe6, 0x21, 0x1d,
-  0xf4, 0xa1, 0x1c, 0x00, 0x3c, 0x00, 0x88, 0x7a, 0x70, 0x87, 0x79, 0x08,
-  0x07, 0x73, 0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08,
-  0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20,
-  0xea, 0x61, 0x1e, 0xca, 0xa1, 0x0d, 0xe6, 0xe1, 0x1d, 0xcc, 0x81, 0x1e,
-  0xda, 0xc0, 0x1c, 0xd8, 0xe1, 0x1d, 0xc2, 0x81, 0x1e, 0x00, 0x73, 0x08,
-  0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x36, 0x2c, 0xc2, 0x00, 0x24, 0xc0,
-  0x02, 0x54, 0x41, 0x1a, 0x80, 0xc2, 0x86, 0x65, 0x20, 0x80, 0x04, 0x58,
-  0x80, 0x2a, 0x48, 0x03, 0x50, 0x00, 0x49, 0x18, 0x00, 0x00, 0x02, 0x00,
-  0x00, 0x00, 0x13, 0x86, 0x40, 0x18, 0x00, 0x00, 0x00, 0x00, 0x89, 0x20,
-  0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09, 0x20, 0x64,
-  0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1,
-  0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x40,
-  0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00, 0x56, 0x08, 0x22,
-  0x09, 0xc2, 0x4c, 0xd4, 0x3c, 0xd0, 0x83, 0x3c, 0xd4, 0xc3, 0x38, 0xd0,
-  0x83, 0x1b, 0xb4, 0x43, 0x39, 0xd0, 0x43, 0x38, 0xb0, 0x83, 0x1e, 0xe8,
-  0x41, 0x3b, 0x84, 0x03, 0x3d, 0xc8, 0x43, 0x3a, 0xe0, 0x03, 0x0a, 0xc8,
-  0x20, 0x42, 0x21, 0x94, 0x62, 0x08, 0x61, 0x0c, 0x9d, 0x81, 0x80, 0x39,
-  0x02, 0x30, 0x48, 0x01, 0x35, 0x47, 0x00, 0x0a, 0x83, 0x08, 0x81, 0x30,
-  0x8c, 0x40, 0x28, 0x23, 0x00, 0x00, 0x13, 0xc0, 0x20, 0x1c, 0xd2, 0x41,
-  0x1e, 0xec, 0x80, 0x0e, 0xda, 0x20, 0x1c, 0xe0, 0x01, 0x1e, 0xd8, 0xa1,
-  0x1c, 0xda, 0x80, 0x1e, 0xec, 0xe1, 0x1d, 0xe6, 0x21, 0x0e, 0xe6, 0xc0,
-  0x0d, 0xe0, 0xc0, 0x0d, 0xe0, 0xa0, 0x0d, 0xe6, 0x21, 0x1d, 0xda, 0xa1,
-  0x1e, 0xd8, 0x21, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0x61, 0xc3, 0x6d, 0x94,
-  0x43, 0x1b, 0xc0, 0x83, 0x1e, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0,
-  0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x41, 0x3a, 0xc4, 0x81, 0x1e, 0xe0,
-  0x81, 0x1e, 0xe0, 0x41, 0x1b, 0xa4, 0x03, 0x1e, 0xe8, 0x01, 0x1e, 0xe8,
-  0x01, 0x1e, 0xb4, 0x41, 0x3a, 0xc4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xd8,
-  0x81, 0x1e, 0xc4, 0x81, 0x1d, 0xb4, 0x41, 0x3a, 0xcc, 0x81, 0x1c, 0xe8,
-  0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x41, 0x3a, 0xd8,
+  0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1c, 0xd2,
+  0x61, 0x1e, 0xc2, 0x41, 0x1c, 0xd8, 0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xc2,
+  0x21, 0x1d, 0xd8, 0xa1, 0x0d, 0xc6, 0x21, 0x1c, 0xd8, 0x81, 0x1d, 0xe6,
+  0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x60, 0x87,
+  0x72, 0x98, 0x87, 0x79, 0x68, 0x03, 0x78, 0x90, 0x87, 0x72, 0x18, 0x87,
+  0x74, 0x98, 0x87, 0x72, 0x68, 0x03, 0x73, 0x80, 0x87, 0x76, 0x08, 0x07,
+  0x72, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc,
+  0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda,
+  0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda,
+  0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87,
+  0x72, 0x00, 0x06, 0x77, 0x78, 0x87, 0x36, 0x30, 0x07, 0x79, 0x08, 0x87,
+  0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77, 0x48, 0x07, 0x77, 0xa0, 0x87,
+  0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76, 0x48, 0x87, 0x76, 0x68, 0x03,
+  0x77, 0x78, 0x07, 0x77, 0x68, 0x03, 0x76, 0x28, 0x87, 0x70, 0x30, 0x07,
+  0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x74, 0x70, 0x07, 0x73, 0x98, 0x87,
+  0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07,
+  0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda,
+  0x40, 0x1d, 0xea, 0xa1, 0x1d, 0xe0, 0xa1, 0x0d, 0xe8, 0x21, 0x1c, 0xc4,
+  0x81, 0x1d, 0xca, 0x61, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87,
+  0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x70, 0x87, 0x70, 0x70, 0x87,
+  0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07,
+  0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde,
+  0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xce, 0xc1, 0x1d, 0xca, 0x81, 0x1c, 0xda,
+  0x40, 0x1f, 0xca, 0x41, 0x1e, 0xde, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0,
+  0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87,
+  0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x7a, 0x90, 0x87,
+  0x70, 0x80, 0x07, 0x78, 0x48, 0x07, 0x77, 0x38, 0x87, 0x36, 0x68, 0x87,
+  0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00,
+  0x62, 0x1e, 0xe8, 0x21, 0x1c, 0xc6, 0x61, 0x1d, 0xda, 0x00, 0x1e, 0xe4,
+  0xe1, 0x1d, 0xe8, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda,
+  0x40, 0x1c, 0xea, 0xc1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xe6,
+  0x21, 0x1d, 0xf4, 0xa1, 0x1c, 0x00, 0x3c, 0x00, 0x88, 0x7a, 0x70, 0x87,
+  0x79, 0x08, 0x07, 0x73, 0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83,
+  0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca,
+  0x01, 0x20, 0xea, 0x61, 0x1e, 0xca, 0xa1, 0x0d, 0xe6, 0xe1, 0x1d, 0xcc,
+  0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xd8, 0xe1, 0x1d, 0xc2, 0x81, 0x1e, 0x00,
+  0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x36, 0x2c, 0xc2, 0x00,
+  0x24, 0xc0, 0x02, 0x54, 0x41, 0x1a, 0x80, 0xc2, 0x86, 0x65, 0x20, 0x80,
+  0x04, 0x58, 0x80, 0x2a, 0x48, 0x03, 0x50, 0x00, 0x49, 0x18, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x13, 0x86, 0x40, 0x18, 0x00, 0x00, 0x00, 0x00,
+  0x89, 0x20, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09,
+  0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3,
+  0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c,
+  0x10, 0x40, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x60, 0x87, 0x10, 0xc0, 0x30,
+  0x82, 0x00, 0x24, 0x41, 0x98, 0x89, 0x9a, 0x07, 0x7a, 0x90, 0x87, 0x7a,
+  0x18, 0x07, 0x7a, 0x70, 0x83, 0x76, 0x28, 0x07, 0x7a, 0x08, 0x07, 0x76,
+  0xd0, 0x03, 0x3d, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x79, 0x48, 0x07, 0x7c,
+  0x40, 0x01, 0x19, 0x44, 0x28, 0x84, 0x52, 0x88, 0x11, 0x8c, 0xa1, 0x33,
+  0x10, 0x30, 0x47, 0x00, 0x06, 0x29, 0xa0, 0xe6, 0x08, 0x40, 0x61, 0x10,
+  0x21, 0x10, 0x86, 0x11, 0x08, 0x65, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x13, 0xc0, 0x20, 0x1c, 0xd2, 0x41, 0x1e, 0xec, 0x80, 0x0e, 0xda, 0x20,
+  0x1c, 0xe0, 0x01, 0x1e, 0xd8, 0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xec, 0xe1,
+  0x1d, 0xe6, 0x21, 0x0e, 0xe6, 0xc0, 0x0d, 0xe0, 0xc0, 0x0d, 0xe0, 0xa0,
+  0x0d, 0xe6, 0x21, 0x1d, 0xda, 0xa1, 0x1e, 0xd8, 0x21, 0x1c, 0xe8, 0xe1,
+  0x1d, 0xe4, 0x61, 0xc3, 0x6d, 0x94, 0x43, 0x1b, 0xc0, 0x83, 0x1e, 0xd8,
   0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4,
-  0x81, 0x39, 0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc,
-  0x81, 0x1c, 0xb4, 0x81, 0x39, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0,
-  0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xc4, 0x81, 0x1d, 0xe8,
-  0x41, 0x1c, 0xd8, 0x81, 0x1e, 0xc4, 0x81, 0x1d, 0xb4, 0x81, 0x3d, 0xc8,
-  0x01, 0x1d, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4,
-  0x81, 0x3d, 0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc,
-  0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xd0, 0x01, 0x1e, 0xe8, 0x81, 0x1d, 0xd0,
-  0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xd8, 0x01, 0x1d, 0xe8,
-  0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xe4,
-  0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xc8, 0x01, 0x1e, 0xe8, 0x41, 0x1c, 0xc8,
-  0x01, 0x1e, 0xb4, 0x81, 0x3d, 0xc4, 0x81, 0x1c, 0xe0, 0x81, 0x1e, 0xc4,
-  0x81, 0x1c, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1c, 0xe0, 0x41, 0x1b, 0xd8,
-  0x43, 0x1c, 0xe4, 0x81, 0x1c, 0xe8, 0x81, 0x1c, 0xd4, 0x81, 0x1d, 0xe8,
-  0x81, 0x1c, 0xd4, 0x81, 0x1d, 0xb4, 0x81, 0x3d, 0xc8, 0x41, 0x1d, 0xd8,
-  0x81, 0x1e, 0xc8, 0x41, 0x1d, 0xd8, 0x81, 0x1e, 0xc8, 0x41, 0x1d, 0xd8,
-  0x41, 0x1b, 0xd8, 0x43, 0x1d, 0xc4, 0x81, 0x1c, 0xe8, 0x41, 0x1d, 0xc4,
-  0x81, 0x1c, 0xe8, 0x41, 0x1d, 0xc4, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xc4,
-  0x01, 0x1c, 0xc8, 0x01, 0x1d, 0xe8, 0x41, 0x1c, 0xc0, 0x81, 0x1c, 0xd0,
-  0x81, 0x1e, 0xc4, 0x01, 0x1c, 0xc8, 0x01, 0x1d, 0xb4, 0x81, 0x3b, 0xe0,
-  0x81, 0x1e, 0xc4, 0x81, 0x1d, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x46, 0x08,
-  0x43, 0x3e, 0x6c, 0x57, 0xfe, 0x9c, 0xf3, 0x60, 0x7f, 0x45, 0x44, 0x13,
-  0x71, 0x0d, 0x89, 0x80, 0xe7, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x10,
-  0x00, 0x00, 0x00, 0x00, 0x89, 0x0d, 0x02, 0x45, 0xf7, 0x05, 0x00, 0x00,
-  0xb2, 0x40, 0x0a, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11,
-  0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x52, 0x45, 0x50,
-  0x02, 0x85, 0x30, 0x02, 0x50, 0x80, 0x01, 0x05, 0x52, 0x06, 0xc4, 0x46,
-  0x00, 0x68, 0x8d, 0x25, 0x38, 0x02, 0x00, 0x00, 0x00, 0x00, 0xb1, 0x18,
-  0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1,
-  0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42,
-  0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f,
-  0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1,
-  0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84,
-  0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc,
-  0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70,
-  0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19,
-  0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f,
-  0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21,
-  0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc,
-  0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84,
-  0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37,
-  0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70,
-  0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77,
-  0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79,
-  0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e,
-  0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1,
-  0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81,
-  0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98,
-  0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88,
-  0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4,
-  0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72,
-  0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74,
-  0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e,
-  0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e,
-  0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21,
-  0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01,
-  0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc,
-  0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77,
-  0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e,
-  0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1,
-  0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61,
-  0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0,
-  0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0,
-  0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74,
-  0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e,
-  0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41,
-  0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50,
-  0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c,
-  0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc,
-  0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x79, 0x20, 0x00, 0x00, 0xc7, 0x00,
-  0x00, 0x00, 0x32, 0x9a, 0x08, 0x14, 0x02, 0x85, 0x8c, 0x27, 0x46, 0x46,
-  0xc8, 0x11, 0x32, 0x64, 0xd4, 0x36, 0xcc, 0x75, 0x00, 0x00, 0x8b, 0xe2,
-  0x06, 0xc5, 0xc6, 0x91, 0x01, 0x13, 0x19, 0x0c, 0x12, 0x65, 0x06, 0x02,
-  0x49, 0x9e, 0xf2, 0x20, 0xd1, 0x85, 0x28, 0x09, 0x00, 0x00, 0x53, 0x44,
-  0x4b, 0x20, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68,
-  0x61, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x41, 0x70, 0x70, 0x6c, 0x65,
-  0x20, 0x4c, 0x4c, 0x56, 0x4d, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f,
-  0x6e, 0x20, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x34, 0x33, 0x20, 0x28,
-  0x6d, 0x65, 0x74, 0x61, 0x6c, 0x66, 0x65, 0x2d, 0x33, 0x31, 0x30, 0x30,
-  0x31, 0x2e, 0x34, 0x33, 0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x61, 0x69,
+  0x41, 0x3a, 0xc4, 0x81, 0x1e, 0xe0, 0x81, 0x1e, 0xe0, 0x41, 0x1b, 0xa4,
+  0x03, 0x1e, 0xe8, 0x01, 0x1e, 0xe8, 0x01, 0x1e, 0xb4, 0x41, 0x3a, 0xc4,
+  0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xd8, 0x81, 0x1e, 0xc4, 0x81, 0x1d, 0xb4,
+  0x41, 0x3a, 0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc,
+  0x81, 0x1c, 0xb4, 0x41, 0x3a, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0,
+  0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x39, 0xcc, 0x81, 0x1c, 0xe8,
+  0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x39, 0xd8,
+  0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4,
+  0x81, 0x3d, 0xc4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xd8, 0x81, 0x1e, 0xc4,
+  0x81, 0x1d, 0xb4, 0x81, 0x3d, 0xc8, 0x01, 0x1d, 0xe8, 0xc1, 0x1c, 0xc8,
+  0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xcc, 0x81, 0x1c, 0xe8,
+  0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xd0,
+  0x01, 0x1e, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4,
+  0x81, 0x3d, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8,
+  0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xe4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xc8,
+  0x01, 0x1e, 0xe8, 0x41, 0x1c, 0xc8, 0x01, 0x1e, 0xb4, 0x81, 0x3d, 0xc4,
+  0x81, 0x1c, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1c, 0xe0, 0x81, 0x1e, 0xc4,
+  0x81, 0x1c, 0xe0, 0x41, 0x1b, 0xd8, 0x43, 0x1c, 0xe4, 0x81, 0x1c, 0xe8,
+  0x81, 0x1c, 0xd4, 0x81, 0x1d, 0xe8, 0x81, 0x1c, 0xd4, 0x81, 0x1d, 0xb4,
+  0x81, 0x3d, 0xc8, 0x41, 0x1d, 0xd8, 0x81, 0x1e, 0xc8, 0x41, 0x1d, 0xd8,
+  0x81, 0x1e, 0xc8, 0x41, 0x1d, 0xd8, 0x41, 0x1b, 0xd8, 0x43, 0x1d, 0xc4,
+  0x81, 0x1c, 0xe8, 0x41, 0x1d, 0xc4, 0x81, 0x1c, 0xe8, 0x41, 0x1d, 0xc4,
+  0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xc4, 0x01, 0x1c, 0xc8, 0x01, 0x1d, 0xe8,
+  0x41, 0x1c, 0xc0, 0x81, 0x1c, 0xd0, 0x81, 0x1e, 0xc4, 0x01, 0x1c, 0xc8,
+  0x01, 0x1d, 0xb4, 0x81, 0x3b, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1d, 0xe8,
+  0xc1, 0x1c, 0xc8, 0x81, 0x46, 0x08, 0x43, 0x42, 0x6c, 0x57, 0xfe, 0xac,
+  0xb3, 0x20, 0xc3, 0x5f, 0x11, 0xd1, 0x44, 0x5c, 0x43, 0x22, 0x00, 0x3a,
+  0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x40, 0x62,
+  0x83, 0x40, 0xd1, 0x85, 0x01, 0x00, 0x80, 0x2c, 0x10, 0x00, 0x00, 0x00,
+  0x0a, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90,
+  0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x52, 0x45, 0x50, 0x02, 0x85,
+  0x30, 0x02, 0x50, 0x80, 0x01, 0x05, 0x52, 0x06, 0xc4, 0x46, 0x00, 0x68,
+  0x8d, 0x25, 0x38, 0x03, 0x00, 0x00, 0x00, 0x00, 0xb1, 0x18, 0x00, 0x00,
+  0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66,
+  0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07,
+  0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10,
+  0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce,
+  0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b,
+  0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c,
+  0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07,
+  0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11,
+  0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0,
+  0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8,
+  0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b,
+  0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b,
+  0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87,
+  0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07,
+  0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87,
+  0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81,
+  0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30,
+  0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4,
+  0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca,
+  0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39,
+  0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b,
+  0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b,
+  0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83,
+  0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87,
+  0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90,
+  0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20,
+  0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc,
+  0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66,
+  0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24,
+  0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07,
+  0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e,
+  0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e,
+  0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54,
+  0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39,
+  0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c,
+  0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07,
+  0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0,
+  0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4,
+  0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38,
+  0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d,
+  0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d,
+  0xc0, 0xc3, 0x3c, 0x00, 0x79, 0x20, 0x00, 0x00, 0xd1, 0x00, 0x00, 0x00,
+  0x32, 0x9a, 0x08, 0x14, 0x02, 0x85, 0x8c, 0x27, 0x46, 0x46, 0xc8, 0x11,
+  0x32, 0x64, 0xd4, 0x3c, 0xcc, 0x7c, 0x00, 0x00, 0x8b, 0x02, 0x07, 0xc5,
+  0xc6, 0x91, 0x01, 0x13, 0x19, 0x0c, 0x12, 0x59, 0x85, 0x53, 0x24, 0x90,
+  0xe4, 0x19, 0xca, 0x83, 0x44, 0x17, 0xa2, 0x24, 0x53, 0x44, 0x4b, 0x20,
+  0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68, 0x61, 0x72,
+  0x5f, 0x73, 0x69, 0x7a, 0x65, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x4c,
+  0x4c, 0x56, 0x4d, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20,
+  0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x35, 0x30, 0x20, 0x28, 0x6d, 0x65,
+  0x74, 0x61, 0x6c, 0x66, 0x65, 0x2d, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e,
+  0x35, 0x30, 0x2e, 0x31, 0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x61, 0x69,
   0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x64, 0x65,
   0x6e, 0x6f, 0x72, 0x6d, 0x73, 0x5f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c,
   0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65,
@@ -542,498 +275,775 @@ const unsigned char sdl_metallib[] = {
   0x6e, 0x61, 0x6d, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e,
   0x61, 0x69, 0x72, 0x2e, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x5f, 0x6f,
   0x75, 0x74, 0x70, 0x75, 0x74, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74,
-  0x65, 0x64, 0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64,
-  0x44, 0x76, 0x32, 0x5f, 0x66, 0x29, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32,
-  0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x61, 0x69, 0x72, 0x2e,
-  0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74,
-  0x61, 0x69, 0x72, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-  0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61,
-  0x74, 0x65, 0x64, 0x28, 0x5f, 0x5f, 0x61, 0x69, 0x72, 0x5f, 0x70, 0x6c,
-  0x61, 0x63, 0x65, 0x68, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x5f, 0x5f, 0x29,
-  0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x61, 0x69,
-  0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a,
-  0x65, 0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x61, 0x64, 0x61, 0x69, 0x72,
-  0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x73, 0x69,
-  0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79,
-  0x70, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69, 0x7a,
-  0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x78, 0x34, 0x70, 0x72, 0x6f,
-  0x6a, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x6e, 0x73,
-  0x66, 0x6f, 0x72, 0x6d, 0x00, 0x00, 0x04, 0x4a, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x30, 0x82, 0xa0, 0x04, 0x23, 0x08, 0x4b, 0x32, 0x82, 0xa0,
-  0x08, 0x23, 0x08, 0xca, 0x30, 0x82, 0xa0, 0x10, 0x23, 0x08, 0x08, 0x30,
-  0x82, 0xa0, 0x14, 0x23, 0x08, 0x8a, 0x31, 0x82, 0xa0, 0x1c, 0x33, 0x0c,
-  0x5c, 0xd0, 0xcd, 0x30, 0x78, 0xc2, 0x37, 0x43, 0x30, 0xcc, 0x30, 0x70,
-  0x1c, 0x18, 0xcc, 0x40, 0x10, 0x9e, 0x07, 0x06, 0x33, 0x04, 0xc5, 0x0c,
-  0x81, 0x31, 0x43, 0x70, 0xcc, 0x50, 0x20, 0x89, 0xb2, 0x30, 0x33, 0x18,
-  0x8d, 0x93, 0x3c, 0x0b, 0x34, 0x83, 0xd0, 0x06, 0x6e, 0x30, 0x83, 0x02,
-  0x06, 0x91, 0x04, 0x06, 0xde, 0x94, 0x3c, 0x0b, 0x33, 0x83, 0xe2, 0x45,
-  0x92, 0xe7, 0x4d, 0xc9, 0xb3, 0x40, 0x33, 0x40, 0x1c, 0x55, 0x89, 0x81,
-  0xc4, 0x79, 0xd6, 0x25, 0x06, 0xd8, 0x18, 0x24, 0xd9, 0xa2, 0xcd, 0x00,
-  0x91, 0x01, 0x55, 0x89, 0x81, 0x44, 0x06, 0x9e, 0x75, 0x89, 0x01, 0x36,
-  0x06, 0x49, 0xb6, 0x6c, 0x33, 0x10, 0x70, 0x10, 0x07, 0x72, 0x30, 0x07,
-  0x33, 0x0c, 0x61, 0xf0, 0x06, 0x74, 0x50, 0x1a, 0xc0, 0x71, 0x1c, 0xc7,
-  0x71, 0x1c, 0xc7, 0x89, 0x81, 0x18, 0x58, 0x68, 0xe0, 0x06, 0x96, 0x65,
-  0xb9, 0x01, 0x1d, 0xa0, 0x01, 0x2e, 0xb0, 0x82, 0x48, 0xb8, 0x04, 0x28,
-  0xc8, 0x48, 0x60, 0x82, 0x2e, 0x62, 0x63, 0xb3, 0x6b, 0x73, 0x69, 0x7b,
-  0x23, 0xab, 0x63, 0x2b, 0x73, 0x31, 0x63, 0x0b, 0x3b, 0x9b, 0x1b, 0x45,
-  0x20, 0x83, 0x32, 0x38, 0x85, 0x8d, 0xcd, 0xae, 0xcd, 0x25, 0x8d, 0xac,
-  0xcc, 0x8d, 0x6e, 0x94, 0xc0, 0x0c, 0x6e, 0x09, 0x4b, 0x93, 0x73, 0xb1,
-  0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73, 0x1b, 0x25, 0x38, 0x83, 0xa3, 0xc2,
-  0xd2, 0xe4, 0x5c, 0xd8, 0xc2, 0xdc, 0xce, 0xea, 0xc2, 0xce, 0xca, 0xbe,
-  0xec, 0xca, 0xe4, 0xe6, 0xd2, 0xde, 0xdc, 0x46, 0x09, 0xd0, 0xe0, 0xa6,
-  0xb0, 0x34, 0x39, 0x97, 0xb1, 0xb7, 0x36, 0xb8, 0x34, 0xb6, 0xb2, 0xaf,
-  0x37, 0x38, 0xba, 0xb4, 0x37, 0xb7, 0xb9, 0x51, 0x86, 0x34, 0x50, 0x83,
-  0x35, 0x38, 0x25, 0x2c, 0x4d, 0xce, 0xc5, 0xae, 0x4c, 0x8e, 0xae, 0x0c,
-  0x6f, 0x94, 0x80, 0x0e, 0x00, 0x00, 0xa9, 0x18, 0x00, 0x00, 0x0b, 0x00,
-  0x00, 0x00, 0x0b, 0x0a, 0x72, 0x28, 0x87, 0x77, 0x80, 0x07, 0x7a, 0x58,
-  0x70, 0x98, 0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb0, 0x43, 0x39, 0xd0, 0xc3,
-  0x82, 0xe6, 0x1c, 0xc6, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0xc1, 0x1d,
-  0xe6, 0x21, 0x1d, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x00, 0xd1, 0x10,
-  0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0xcc, 0x3c, 0xa4, 0x83, 0x3b,
-  0x9c, 0x03, 0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83, 0x3c, 0x94, 0x43, 0x38,
-  0x90, 0xc3, 0x01, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x65, 0x00,
-  0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x09, 0x00,
-  0x00, 0x00, 0xc4, 0x4a, 0xa0, 0x0c, 0x8a, 0x80, 0xdc, 0x08, 0xc0, 0x58,
-  0x44, 0x10, 0x04, 0xc1, 0x58, 0x84, 0x20, 0x08, 0xc2, 0x58, 0xc4, 0x30,
-  0x0c, 0x03, 0x85, 0x19, 0x00, 0x12, 0x33, 0x00, 0x34, 0x66, 0x00, 0x00,
-  0x00, 0x00, 0xf1, 0x30, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x22, 0x47,
-  0xc8, 0x90, 0x51, 0x0a, 0x84, 0x18, 0x00, 0x00, 0x00, 0x00, 0xcf, 0x03,
-  0x00, 0x00, 0x6f, 0x6d, 0x6e, 0x69, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x74,
-  0x20, 0x63, 0x68, 0x61, 0x72, 0x53, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20,
-  0x43, 0x2b, 0x2b, 0x20, 0x54, 0x42, 0x41, 0x41, 0x00, 0x00, 0x13, 0x04,
-  0x06, 0xd9, 0x10, 0xdc, 0xc1, 0x86, 0xc1, 0x0e, 0xf2, 0x00, 0x0f, 0x36,
-  0x0c, 0x7a, 0xa0, 0x07, 0x78, 0x00, 0xbb, 0x10, 0x0b, 0x44, 0x41, 0x14,
-  0x84, 0xb2, 0x0b, 0xe1, 0x48, 0x96, 0x44, 0x41, 0x28, 0x83, 0x0c, 0xc3,
-  0xb1, 0x98, 0x10, 0x88, 0xff, 0x2e, 0x84, 0x64, 0x69, 0x10, 0x05, 0xa1,
-  0x0c, 0x32, 0x1c, 0x8b, 0x63, 0x42, 0x20, 0xfe, 0x16, 0x14, 0xe0, 0xbf,
-  0x0b, 0x71, 0x6d, 0xdf, 0x44, 0x41, 0x28, 0x83, 0x0c, 0x0c, 0x24, 0x99,
-  0x10, 0x88, 0xbf, 0x15, 0x01, 0xf8, 0xef, 0x42, 0x70, 0x60, 0x40, 0x06,
-  0x19, 0x05, 0xa1, 0x0c, 0x32, 0x44, 0x95, 0x65, 0x42, 0x20, 0xfe, 0x56,
-  0x04, 0xe0, 0xbf, 0x0b, 0x01, 0x06, 0x65, 0x90, 0x06, 0x1f, 0x05, 0xa1,
-  0x0c, 0x32, 0x04, 0x9a, 0x67, 0x41, 0x25, 0xfe, 0x83, 0x0c, 0x03, 0xf7,
-  0x59, 0x30, 0x89, 0xbf, 0x0d, 0x01, 0xf8, 0x0f, 0x32, 0x18, 0x5f, 0x18,
-  0x58, 0x10, 0x89, 0xbf, 0x0d, 0x01, 0xf8, 0x0f, 0x32, 0x24, 0x62, 0x30,
-  0x06, 0x16, 0x3c, 0xe2, 0x6f, 0x43, 0x00, 0xfe, 0xbb, 0x10, 0x6d, 0x20,
-  0x07, 0x76, 0xb0, 0x06, 0x14, 0x84, 0x32, 0xc8, 0x10, 0x9c, 0xc1, 0x1a,
-  0x58, 0x20, 0x06, 0xe2, 0x3f, 0xc8, 0x30, 0xa4, 0x01, 0x1b, 0x58, 0x00,
-  0x06, 0xe2, 0x3f, 0xc8, 0x50, 0xac, 0x41, 0x1b, 0x58, 0xd0, 0x89, 0xff,
-  0x20, 0xc3, 0xd1, 0x06, 0x6e, 0x60, 0x81, 0x26, 0xfe, 0x83, 0x0c, 0x7a,
-  0xe0, 0x06, 0x73, 0x60, 0x59, 0x20, 0xfe, 0x83, 0x0c, 0x7c, 0x00, 0x07,
-  0x74, 0x60, 0x4e, 0x20, 0xfe, 0x96, 0x0c, 0xe0, 0x6f, 0x01, 0x03, 0xfe,
-  0x16, 0x24, 0xe0, 0x6f, 0x01, 0x02, 0xfe, 0x16, 0x14, 0xe0, 0x3f, 0xdb,
-  0x60, 0x07, 0x01, 0x30, 0xdb, 0x10, 0x8c, 0x42, 0x90, 0x41, 0x40, 0x0c,
-  0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x5b, 0x86, 0x20, 0xd0, 0x83, 0x2d,
-  0xc3, 0x10, 0xe8, 0xc1, 0x96, 0xe1, 0x08, 0xf4, 0x60, 0xcb, 0xc0, 0x04,
-  0x7a, 0xb0, 0x65, 0x88, 0x02, 0x3d, 0xd8, 0x32, 0x58, 0x81, 0x1e, 0x6c,
-  0x19, 0xc6, 0x20, 0xd0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20,
-  0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x32, 0x0e, 0x10, 0x22, 0x84, 0x00,
-  0x94, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x0c,
-  0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0xe8, 0x00, 0x00,
-  0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x08, 0x00,
-  0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x01, 0x00,
-  0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x00,
-  0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00,
-  0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00,
-  0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x24, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x5d, 0x0c, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x12, 0x03,
-  0x94, 0x77, 0x00, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x43, 0x6f,
-  0x70, 0x79, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x33, 0x31, 0x30,
-  0x30, 0x31, 0x2e, 0x34, 0x33, 0x61, 0x69, 0x72, 0x36, 0x34, 0x2d, 0x61,
-  0x70, 0x70, 0x6c, 0x65, 0x2d, 0x74, 0x76, 0x6f, 0x73, 0x31, 0x33, 0x2e,
-  0x30, 0x2e, 0x30, 0x2d, 0x73, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x6f,
-  0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00,
-  0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x70, 0x0a, 0x00, 0x00, 0xff, 0xff,
-  0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x35, 0x14, 0x00, 0x00, 0x03, 0x00,
-  0x00, 0x00, 0x62, 0x0c, 0x30, 0x24, 0x80, 0x10, 0x05, 0xc8, 0x14, 0x00,
-  0x00, 0x00, 0x21, 0x0c, 0x00, 0x00, 0x61, 0x02, 0x00, 0x00, 0x0b, 0x02,
-  0x21, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x07, 0x81,
-  0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01,
-  0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x10,
-  0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0x84, 0x10, 0x32, 0x14, 0x38, 0x08,
-  0x18, 0x4b, 0x0a, 0x32, 0x42, 0x88, 0x48, 0x90, 0x14, 0x20, 0x43, 0x46,
-  0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0x04, 0x49, 0x0e, 0x90, 0x11, 0x22,
-  0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x21,
-  0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x83, 0x00, 0x00, 0x00, 0x1b, 0xcc,
-  0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x80, 0x03, 0x40, 0x02, 0x2a,
-  0x62, 0x1c, 0xde, 0x41, 0x1e, 0xe4, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xd8,
-  0x21, 0x1f, 0xda, 0x40, 0x1e, 0xde, 0xa1, 0x1e, 0xdc, 0x81, 0x1c, 0xca,
-  0x81, 0x1c, 0xda, 0x80, 0x1c, 0xd2, 0xc1, 0x1e, 0xd2, 0x81, 0x1c, 0xca,
-  0xa1, 0x0d, 0xe6, 0x21, 0x1e, 0xe4, 0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xe0,
-  0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x73, 0x08, 0x07,
-  0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x72, 0x48, 0x87, 0x79, 0x08, 0x07,
-  0x71, 0x60, 0x87, 0x72, 0x68, 0x03, 0x7a, 0x08, 0x87, 0x74, 0x60, 0x87,
-  0x36, 0x18, 0x87, 0x70, 0x60, 0x07, 0x76, 0x98, 0x07, 0xc0, 0x1c, 0xc2,
-  0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1d, 0xca, 0x61, 0x1e, 0xe6,
-  0xa1, 0x0d, 0xe0, 0x41, 0x1e, 0xca, 0x61, 0x1c, 0xd2, 0x61, 0x1e, 0xca,
-  0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0x21, 0x1c, 0xc8, 0x01, 0x30, 0x87,
-  0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03,
-  0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78, 0x78, 0x87,
-  0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72, 0x60, 0x87,
-  0x74, 0x68, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x18, 0xdc,
-  0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda,
-  0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda,
-  0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0xa1, 0x0d, 0xdc, 0xe1, 0x1d, 0xdc,
-  0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xc2, 0xc1, 0x1c, 0x00, 0xc2, 0x1d, 0xde,
-  0xa1, 0x0d, 0xd2, 0xc1, 0x1d, 0xcc, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0,
-  0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87,
-  0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x75, 0xa8, 0x87,
-  0x76, 0x80, 0x87, 0x36, 0xa0, 0x87, 0x70, 0x10, 0x07, 0x76, 0x28, 0x87,
-  0x79, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc,
-  0xe1, 0x1d, 0xda, 0xc0, 0x1d, 0xc2, 0xc1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc,
-  0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07,
-  0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x98, 0x87,
-  0x74, 0x38, 0x07, 0x77, 0x28, 0x07, 0x72, 0x68, 0x03, 0x7d, 0x28, 0x07,
-  0x79, 0x78, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87,
-  0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00,
-  0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0x01, 0x1e, 0xe0,
-  0x21, 0x1d, 0xdc, 0xe1, 0x1c, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0,
-  0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x88, 0x79, 0xa0, 0x87,
-  0x70, 0x18, 0x87, 0x75, 0x68, 0x03, 0x78, 0x90, 0x87, 0x77, 0xa0, 0x87,
-  0x72, 0x18, 0x07, 0x7a, 0x78, 0x07, 0x79, 0x68, 0x03, 0x71, 0xa8, 0x07,
-  0x73, 0x30, 0x87, 0x72, 0x90, 0x87, 0x36, 0x98, 0x87, 0x74, 0xd0, 0x87,
-  0x72, 0x00, 0xf0, 0x00, 0x20, 0xea, 0xc1, 0x1d, 0xe6, 0x21, 0x1c, 0xcc,
-  0xa1, 0x1c, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8,
-  0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0xa8, 0x87,
-  0x79, 0x28, 0x87, 0x36, 0x98, 0x87, 0x77, 0x30, 0x07, 0x7a, 0x68, 0x03,
-  0x73, 0x60, 0x87, 0x77, 0x08, 0x07, 0x7a, 0x00, 0xcc, 0x21, 0x1c, 0xd8,
-  0x61, 0x1e, 0xca, 0x01, 0xd8, 0xb0, 0x08, 0x01, 0x90, 0x00, 0x0b, 0x50,
-  0x05, 0x69, 0x00, 0x01, 0x00, 0x00, 0x49, 0x18, 0x00, 0x00, 0x01, 0x00,
-  0x00, 0x00, 0x13, 0x84, 0x40, 0x00, 0x89, 0x20, 0x00, 0x00, 0x0e, 0x00,
-  0x00, 0x00, 0x32, 0x22, 0x08, 0x09, 0x20, 0x64, 0x85, 0x04, 0x13, 0x22,
-  0xa4, 0x84, 0x04, 0x13, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c,
-  0x88, 0x8c, 0x0b, 0x84, 0x84, 0x4c, 0x10, 0x28, 0x33, 0x00, 0xc3, 0x08,
-  0x04, 0x30, 0x88, 0x10, 0x04, 0x45, 0x08, 0xa1, 0x19, 0x08, 0x98, 0x23,
-  0x00, 0x83, 0x14, 0xb0, 0x39, 0x02, 0x50, 0x18, 0x01, 0x00, 0x13, 0xc0,
-  0x20, 0x1c, 0xd2, 0x41, 0x1e, 0xec, 0x80, 0x0e, 0xda, 0x20, 0x1c, 0xe0,
-  0x01, 0x1e, 0xd8, 0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xec, 0xe1, 0x1d, 0xe6,
-  0x21, 0x0e, 0xe6, 0xc0, 0x0d, 0xe0, 0xc0, 0x0d, 0xe0, 0xa0, 0x0d, 0xe6,
-  0x21, 0x1d, 0xda, 0xa1, 0x1e, 0xd8, 0x21, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4,
-  0x61, 0xc3, 0x6d, 0x94, 0x43, 0x1b, 0xc0, 0x83, 0x1e, 0xd8, 0x01, 0x1d,
-  0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x41, 0x3a,
-  0xc4, 0x81, 0x1e, 0xe0, 0x81, 0x1e, 0xe0, 0x41, 0x1b, 0xa4, 0x03, 0x1e,
-  0xe8, 0x01, 0x1e, 0xe8, 0x01, 0x1e, 0xb4, 0x41, 0x3a, 0xc4, 0x81, 0x1d,
-  0xe8, 0x41, 0x1c, 0xd8, 0x81, 0x1e, 0xc4, 0x81, 0x1d, 0xb4, 0x41, 0x3a,
+  0x65, 0x64, 0x28, 0x35, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34,
+  0x5f, 0x66, 0x29, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x69, 0x72, 0x2e,
+  0x70, 0x6f, 0x69, 0x6e, 0x74, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x66, 0x6c,
+  0x6f, 0x61, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x53, 0x69, 0x7a, 0x65,
+  0x61, 0x69, 0x72, 0x2e, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x5f, 0x69,
+  0x6e, 0x70, 0x75, 0x74, 0x61, 0x69, 0x72, 0x2e, 0x6c, 0x6f, 0x63, 0x61,
+  0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x67, 0x65,
+  0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x5f, 0x5f, 0x61, 0x69,
+  0x72, 0x5f, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x68, 0x6f, 0x6c, 0x64, 0x65,
+  0x72, 0x5f, 0x5f, 0x29, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32, 0x61, 0x69,
+  0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x61, 0x69, 0x72, 0x2e,
+  0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61,
+  0x69, 0x72, 0x2e, 0x72, 0x65, 0x61, 0x64, 0x61, 0x69, 0x72, 0x2e, 0x61,
+  0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65,
+  0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65,
+  0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x66,
+  0x6c, 0x6f, 0x61, 0x74, 0x34, 0x78, 0x34, 0x70, 0x72, 0x6f, 0x6a, 0x65,
+  0x63, 0x74, 0x69, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f,
+  0x72, 0x6d, 0x00, 0x00, 0xc4, 0x51, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x30, 0x82, 0xa0, 0x04, 0x23, 0x08, 0x4b, 0x32, 0x82, 0xa0, 0x08, 0x23,
+  0x08, 0xca, 0x30, 0x82, 0xa0, 0x10, 0x23, 0x08, 0x08, 0x30, 0x82, 0xa0,
+  0x14, 0x23, 0x08, 0x8a, 0x31, 0x82, 0xa0, 0x1c, 0x33, 0x0c, 0x5f, 0x00,
+  0x06, 0x33, 0x0c, 0x61, 0x20, 0x88, 0xc1, 0x0c, 0xc1, 0x30, 0xc3, 0xf0,
+  0x7d, 0x63, 0x30, 0x03, 0x41, 0x84, 0x41, 0x18, 0x8c, 0xc1, 0x0c, 0x41,
+  0x31, 0x43, 0x60, 0xcc, 0x10, 0x1c, 0x33, 0x14, 0x48, 0xa2, 0x2c, 0xcc,
+  0x0c, 0x46, 0xe3, 0x24, 0xca, 0xf2, 0xcc, 0x50, 0x40, 0x49, 0xb4, 0x48,
+  0x33, 0x0c, 0x70, 0x10, 0x07, 0x72, 0x30, 0x83, 0x32, 0x06, 0x13, 0x35,
+  0x06, 0x61, 0x50, 0x25, 0xd6, 0xc2, 0xcc, 0xa0, 0x84, 0xc1, 0x44, 0x85,
+  0x41, 0x18, 0x54, 0x89, 0xb2, 0x3c, 0x33, 0x40, 0xdf, 0x85, 0x95, 0x01,
+  0xf5, 0x85, 0x41, 0xa6, 0x95, 0xc1, 0x66, 0x06, 0x09, 0xb7, 0x74, 0x33,
+  0x40, 0x67, 0x70, 0x61, 0x65, 0x40, 0x9d, 0x41, 0x18, 0x64, 0x5a, 0x19,
+  0x6c, 0x66, 0x90, 0x70, 0x8b, 0x37, 0x03, 0x41, 0x07, 0x75, 0x60, 0x07,
+  0x77, 0x30, 0xc3, 0x40, 0x06, 0x73, 0x80, 0x07, 0xb5, 0x01, 0x1c, 0xc7,
+  0x71, 0x1c, 0xc7, 0x71, 0x1c, 0x1a, 0xb8, 0x81, 0x85, 0x06, 0x7a, 0x60,
+  0x59, 0x96, 0x1b, 0xd0, 0x81, 0x1b, 0xd0, 0x81, 0x2f, 0xf8, 0x02, 0x4a,
+  0xd0, 0x04, 0x28, 0xc8, 0x48, 0x60, 0x82, 0x2e, 0x62, 0x63, 0xb3, 0x6b,
+  0x73, 0x69, 0x7b, 0x23, 0xab, 0x63, 0x2b, 0x73, 0x31, 0x63, 0x0b, 0x3b,
+  0x9b, 0x1b, 0x45, 0x38, 0x03, 0x34, 0x38, 0x85, 0x8d, 0xcd, 0xae, 0xcd,
+  0x25, 0x8d, 0xac, 0xcc, 0x8d, 0x6e, 0x94, 0x20, 0x0d, 0x6e, 0x09, 0x4b,
+  0x93, 0x73, 0xb1, 0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73, 0x1b, 0x25, 0x50,
+  0x83, 0xa3, 0xc2, 0xd2, 0xe4, 0x5c, 0xd8, 0xc2, 0xdc, 0xce, 0xea, 0xc2,
+  0xce, 0xca, 0xbe, 0xec, 0xca, 0xe4, 0xe6, 0xd2, 0xde, 0xdc, 0x46, 0x09,
+  0xd6, 0xe0, 0xa6, 0xb0, 0x34, 0x39, 0x97, 0xb1, 0xb7, 0x36, 0xb8, 0x34,
+  0xb6, 0xb2, 0xaf, 0x37, 0x38, 0xba, 0xb4, 0x37, 0xb7, 0xb9, 0x51, 0x06,
+  0x36, 0x68, 0x03, 0x37, 0x38, 0x25, 0x2c, 0x4d, 0xce, 0xc5, 0xae, 0x4c,
+  0x8e, 0xae, 0x0c, 0x6f, 0x94, 0x00, 0x0f, 0x00, 0xa9, 0x18, 0x00, 0x00,
+  0x0b, 0x00, 0x00, 0x00, 0x0b, 0x0a, 0x72, 0x28, 0x87, 0x77, 0x80, 0x07,
+  0x7a, 0x58, 0x70, 0x98, 0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb0, 0x43, 0x39,
+  0xd0, 0xc3, 0x82, 0xe6, 0x1c, 0xc6, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2,
+  0xc1, 0x1d, 0xe6, 0x21, 0x1d, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x00,
+  0xd1, 0x10, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0xcc, 0x3c, 0xa4,
+  0x83, 0x3b, 0x9c, 0x03, 0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83, 0x3c, 0x94,
+  0x43, 0x38, 0x90, 0xc3, 0x01, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00,
+  0x69, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00,
+  0x0b, 0x00, 0x00, 0x00, 0xc4, 0x4a, 0xa0, 0x0c, 0x8a, 0x80, 0xdc, 0x08,
+  0xc0, 0x58, 0x44, 0x10, 0x04, 0xc1, 0x58, 0x84, 0x20, 0x08, 0xc2, 0x58,
+  0xc4, 0x30, 0x0c, 0x03, 0x81, 0x31, 0x02, 0x10, 0x04, 0x41, 0xfc, 0xa3,
+  0x30, 0x03, 0x40, 0x62, 0x06, 0x80, 0xc6, 0x0c, 0x00, 0x00, 0x00, 0x00,
+  0xf1, 0x30, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x22, 0x47, 0xc8, 0x90,
+  0x51, 0x0a, 0x84, 0x18, 0x00, 0x00, 0x00, 0x00, 0xcf, 0x03, 0x00, 0x00,
+  0x6f, 0x6d, 0x6e, 0x69, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x74, 0x20, 0x63,
+  0x68, 0x61, 0x72, 0x53, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x43, 0x2b,
+  0x2b, 0x20, 0x54, 0x42, 0x41, 0x41, 0x00, 0x00, 0x13, 0x04, 0x06, 0xd9,
+  0x10, 0xec, 0xc1, 0x86, 0x41, 0x0f, 0xfa, 0x80, 0x0f, 0x36, 0x0c, 0x7e,
+  0xe0, 0x07, 0x7c, 0x00, 0xbb, 0x10, 0x4c, 0x54, 0x45, 0x14, 0x84, 0xb2,
+  0x0b, 0xf1, 0x4c, 0xd7, 0x44, 0x41, 0x28, 0x83, 0x0c, 0xc3, 0xc1, 0x98,
+  0x10, 0x88, 0xff, 0x2e, 0xc4, 0x74, 0x6d, 0x11, 0x05, 0xa1, 0x0c, 0x32,
+  0x1c, 0xcb, 0x63, 0x42, 0x20, 0xfe, 0x16, 0x14, 0xe0, 0xbf, 0x0b, 0x81,
+  0x71, 0x60, 0x40, 0x51, 0x10, 0xca, 0x20, 0x03, 0x03, 0x4d, 0x26, 0x04,
+  0xe2, 0x6f, 0x45, 0x00, 0xfe, 0xbb, 0x10, 0x5d, 0x18, 0x94, 0x81, 0x46,
+  0x41, 0x28, 0x83, 0x0c, 0x51, 0x75, 0x99, 0x10, 0x88, 0xbf, 0x15, 0x01,
+  0xf8, 0xef, 0x42, 0x84, 0x81, 0x19, 0xa8, 0x01, 0x18, 0x50, 0x10, 0xca,
+  0x20, 0x43, 0xa0, 0x7d, 0x16, 0x54, 0xe2, 0x3f, 0xc8, 0x30, 0x70, 0x60,
+  0x60, 0xc1, 0x24, 0xfe, 0x36, 0x04, 0xe0, 0x3f, 0xc8, 0x60, 0x7c, 0x62,
+  0x60, 0x41, 0x24, 0xfe, 0x36, 0x04, 0xe0, 0x3f, 0xc8, 0x90, 0x88, 0x01,
+  0x19, 0x58, 0xf0, 0x88, 0xbf, 0x0d, 0x01, 0xf8, 0xef, 0x42, 0xb8, 0xc1,
+  0x1c, 0xdc, 0x01, 0x1b, 0x50, 0x10, 0xca, 0x20, 0x43, 0x70, 0x06, 0x6c,
+  0x60, 0x81, 0x18, 0x88, 0xff, 0x20, 0xc3, 0x90, 0x06, 0x6d, 0x60, 0x01,
+  0x18, 0x88, 0xff, 0x20, 0x43, 0xb1, 0x06, 0x6e, 0x60, 0x41, 0x27, 0xfe,
+  0x83, 0x0c, 0x47, 0x1b, 0xbc, 0x81, 0x05, 0x9a, 0xf8, 0x0f, 0x32, 0xec,
+  0x41, 0x1b, 0xd0, 0x81, 0x65, 0x81, 0xf8, 0x0f, 0x32, 0xf4, 0xc1, 0x1b,
+  0xd4, 0x81, 0x39, 0x81, 0xf8, 0x5b, 0x32, 0x80, 0xbf, 0x05, 0x0c, 0xf8,
+  0x5b, 0x90, 0x80, 0xbf, 0x05, 0x08, 0xf8, 0x5b, 0x50, 0x80, 0xff, 0x6c,
+  0xc3, 0x1d, 0x04, 0xc0, 0x6c, 0x43, 0x40, 0x0a, 0xc1, 0x6c, 0x43, 0xb0,
+  0x07, 0x42, 0x06, 0x01, 0x31, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
+  0x5b, 0x86, 0x20, 0xf0, 0x83, 0x2d, 0xc3, 0x10, 0xf8, 0xc1, 0x96, 0xe1,
+  0x08, 0xfc, 0x60, 0xcb, 0xc0, 0x04, 0x7e, 0xb0, 0x65, 0x88, 0x02, 0x3f,
+  0xd8, 0x32, 0x58, 0x81, 0x1f, 0x6c, 0x19, 0xc6, 0x20, 0xf0, 0x03, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x32, 0x0e, 0x10, 0x22, 0x84, 0x00, 0xa0, 0x05, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x65, 0x0c, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00,
+  0x12, 0x03, 0x94, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x10, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x50, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+  0x00, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5d, 0x0c, 0x00, 0x00,
+  0x12, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0x7a, 0x00, 0x00, 0x00, 0x00,
+  0x53, 0x44, 0x4c, 0x5f, 0x53, 0x6f, 0x6c, 0x69, 0x64, 0x5f, 0x76, 0x65,
+  0x72, 0x74, 0x65, 0x78, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x35, 0x30,
+  0x2e, 0x31, 0x61, 0x69, 0x72, 0x36, 0x34, 0x2d, 0x61, 0x70, 0x70, 0x6c,
+  0x65, 0x2d, 0x74, 0x76, 0x6f, 0x73, 0x31, 0x33, 0x2e, 0x30, 0x2e, 0x30,
+  0x2d, 0x73, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00,
+  0x14, 0x00, 0x00, 0x00, 0x14, 0x0d, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+  0x42, 0x43, 0xc0, 0xde, 0x35, 0x14, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x62, 0x0c, 0x30, 0x24, 0x80, 0x10, 0x05, 0xc8, 0x14, 0x00, 0x00, 0x00,
+  0x21, 0x0c, 0x00, 0x00, 0x0a, 0x03, 0x00, 0x00, 0x0b, 0x02, 0x21, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91,
+  0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c,
+  0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02,
+  0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x4b,
+  0x0a, 0x32, 0x52, 0x88, 0x48, 0x90, 0x14, 0x20, 0x43, 0x46, 0x88, 0xa5,
+  0x00, 0x19, 0x32, 0x42, 0x04, 0x49, 0x0e, 0x90, 0x91, 0x22, 0xc4, 0x50,
+  0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x29, 0x46, 0x06,
+  0x51, 0x18, 0x00, 0x00, 0x85, 0x00, 0x00, 0x00, 0x1b, 0xc8, 0x25, 0xf8,
+  0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x80, 0x8a, 0x18, 0x87, 0x77, 0x90,
+  0x07, 0x79, 0x28, 0x87, 0x71, 0xa0, 0x07, 0x76, 0xc8, 0x87, 0x36, 0x90,
+  0x87, 0x77, 0xa8, 0x07, 0x77, 0x20, 0x87, 0x72, 0x20, 0x87, 0x36, 0x20,
+  0x87, 0x74, 0xb0, 0x87, 0x74, 0x20, 0x87, 0x72, 0x68, 0x83, 0x79, 0x88,
+  0x07, 0x79, 0xa0, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08,
+  0x07, 0x7a, 0x40, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c,
+  0x00, 0x82, 0x1c, 0xd2, 0x61, 0x1e, 0xc2, 0x41, 0x1c, 0xd8, 0xa1, 0x1c,
+  0xda, 0x80, 0x1e, 0xc2, 0x21, 0x1d, 0xd8, 0xa1, 0x0d, 0xc6, 0x21, 0x1c,
+  0xd8, 0x81, 0x1d, 0xe6, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28,
+  0x07, 0x80, 0x60, 0x87, 0x72, 0x98, 0x87, 0x79, 0x68, 0x03, 0x78, 0x90,
+  0x87, 0x72, 0x18, 0x87, 0x74, 0x98, 0x87, 0x72, 0x68, 0x03, 0x73, 0x80,
+  0x87, 0x76, 0x08, 0x07, 0x72, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e,
+  0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c,
+  0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e,
+  0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0x01, 0xa0,
+  0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x06, 0x77, 0x78, 0x87, 0x36, 0x30,
+  0x07, 0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77, 0x48,
+  0x07, 0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76, 0x48,
+  0x87, 0x76, 0x68, 0x03, 0x77, 0x78, 0x07, 0x77, 0x68, 0x03, 0x76, 0x28,
+  0x87, 0x70, 0x30, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x74, 0x70,
+  0x07, 0x73, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08,
+  0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20,
+  0xdc, 0xe1, 0x1d, 0xda, 0x40, 0x1d, 0xea, 0xa1, 0x1d, 0xe0, 0xa1, 0x0d,
+  0xe8, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x1e, 0x00, 0x73, 0x08,
+  0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x70,
+  0x87, 0x70, 0x70, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68,
+  0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c,
+  0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xce, 0xc1, 0x1d,
+  0xca, 0x81, 0x1c, 0xda, 0x40, 0x1f, 0xca, 0x41, 0x1e, 0xde, 0x61, 0x1e,
+  0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d,
+  0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68,
+  0x03, 0x7a, 0x90, 0x87, 0x70, 0x80, 0x07, 0x78, 0x48, 0x07, 0x77, 0x38,
+  0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e,
+  0xea, 0xa1, 0x1c, 0x00, 0x62, 0x1e, 0xe8, 0x21, 0x1c, 0xc6, 0x61, 0x1d,
+  0xda, 0x00, 0x1e, 0xe4, 0xe1, 0x1d, 0xe8, 0xa1, 0x1c, 0xc6, 0x81, 0x1e,
+  0xde, 0x41, 0x1e, 0xda, 0x40, 0x1c, 0xea, 0xc1, 0x1c, 0xcc, 0xa1, 0x1c,
+  0xe4, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xf4, 0xa1, 0x1c, 0x00, 0x3c, 0x00,
+  0x88, 0x7a, 0x70, 0x87, 0x79, 0x08, 0x07, 0x73, 0x28, 0x87, 0x36, 0x30,
+  0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e,
+  0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xea, 0x61, 0x1e, 0xca, 0xa1, 0x0d,
+  0xe6, 0xe1, 0x1d, 0xcc, 0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xd8, 0xe1, 0x1d,
+  0xc2, 0x81, 0x1e, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00,
+  0x36, 0x2c, 0x02, 0x01, 0x24, 0xc0, 0x02, 0x54, 0x41, 0x1a, 0x80, 0xc2,
+  0x86, 0x65, 0x28, 0x80, 0x04, 0x58, 0x80, 0x2a, 0x48, 0x03, 0x50, 0x00,
+  0x49, 0x18, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x86, 0x40, 0x18,
+  0x00, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00,
+  0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84,
+  0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c,
+  0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x40, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30,
+  0x8c, 0x20, 0x00, 0x76, 0x08, 0x41, 0x24, 0x41, 0x98, 0x89, 0x9a, 0x07,
+  0x7a, 0x90, 0x87, 0x7a, 0x18, 0x07, 0x7a, 0x70, 0x83, 0x76, 0x28, 0x07,
+  0x7a, 0x08, 0x07, 0x76, 0xd0, 0x03, 0x3d, 0x68, 0x87, 0x70, 0xa0, 0x07,
+  0x79, 0x48, 0x07, 0x7c, 0x40, 0x01, 0x19, 0x44, 0x28, 0x84, 0x62, 0x0c,
+  0x11, 0x84, 0x31, 0x74, 0x06, 0x02, 0xe6, 0x08, 0xc0, 0x20, 0x05, 0xd4,
+  0x1c, 0x01, 0x28, 0x0c, 0x22, 0x04, 0xc2, 0x30, 0x02, 0xa1, 0x8c, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x13, 0xc0, 0x20, 0x1c, 0xd2, 0x41, 0x1e, 0xec,
+  0x80, 0x0e, 0xda, 0x20, 0x1c, 0xe0, 0x01, 0x1e, 0xd8, 0xa1, 0x1c, 0xda,
+  0x80, 0x1e, 0xec, 0xe1, 0x1d, 0xe6, 0x21, 0x0e, 0xe6, 0xc0, 0x0d, 0xe0,
+  0xc0, 0x0d, 0xe0, 0xa0, 0x0d, 0xe6, 0x21, 0x1d, 0xda, 0xa1, 0x1e, 0xd8,
+  0x21, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0x61, 0xc3, 0x6d, 0x94, 0x43, 0x1b,
+  0xc0, 0x83, 0x1e, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e,
+  0xd8, 0x01, 0x1d, 0xb4, 0x41, 0x3a, 0xc4, 0x81, 0x1e, 0xe0, 0x81, 0x1e,
+  0xe0, 0x41, 0x1b, 0xa4, 0x03, 0x1e, 0xe8, 0x01, 0x1e, 0xe8, 0x01, 0x1e,
+  0xb4, 0x41, 0x3a, 0xc4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xd8, 0x81, 0x1e,
+  0xc4, 0x81, 0x1d, 0xb4, 0x41, 0x3a, 0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c,
+  0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x41, 0x3a, 0xd8, 0x01, 0x1d,
+  0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x39,
   0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c,
-  0xb4, 0x41, 0x3a, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e,
-  0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x39, 0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c,
-  0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x39, 0xd8, 0x01, 0x1d,
-  0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d,
-  0xc4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xd8, 0x81, 0x1e, 0xc4, 0x81, 0x1d,
-  0xb4, 0x81, 0x3d, 0xc8, 0x01, 0x1d, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e,
-  0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c,
-  0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xd0, 0x01, 0x1e,
-  0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d,
-  0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d,
-  0xb4, 0x81, 0x3d, 0xe4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xc8, 0x01, 0x1e,
-  0xe8, 0x41, 0x1c, 0xc8, 0x01, 0x1e, 0xb4, 0x81, 0x3d, 0xc4, 0x81, 0x1c,
-  0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1c, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1c,
-  0xe0, 0x41, 0x1b, 0xd8, 0x43, 0x1c, 0xe4, 0x81, 0x1c, 0xe8, 0x81, 0x1c,
-  0xd4, 0x81, 0x1d, 0xe8, 0x81, 0x1c, 0xd4, 0x81, 0x1d, 0xb4, 0x81, 0x3d,
-  0xc8, 0x41, 0x1d, 0xd8, 0x81, 0x1e, 0xc8, 0x41, 0x1d, 0xd8, 0x81, 0x1e,
-  0xc8, 0x41, 0x1d, 0xd8, 0x41, 0x1b, 0xd8, 0x43, 0x1d, 0xc4, 0x81, 0x1c,
-  0xe8, 0x41, 0x1d, 0xc4, 0x81, 0x1c, 0xe8, 0x41, 0x1d, 0xc4, 0x81, 0x1c,
-  0xb4, 0x81, 0x3d, 0xc4, 0x01, 0x1c, 0xc8, 0x01, 0x1d, 0xe8, 0x41, 0x1c,
-  0xc0, 0x81, 0x1c, 0xd0, 0x81, 0x1e, 0xc4, 0x01, 0x1c, 0xc8, 0x01, 0x1d,
-  0xb4, 0x81, 0x3b, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1d, 0xe8, 0xc1, 0x1c,
-  0xc8, 0x81, 0x46, 0x08, 0x43, 0x4a, 0x6c, 0x57, 0xfe, 0xac, 0xb3, 0x20,
-  0xc3, 0x5f, 0x44, 0x80, 0xc1, 0x10, 0xcd, 0x34, 0x24, 0x02, 0xa4, 0x01,
-  0x00, 0x80, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x24, 0x36,
-  0x08, 0x14, 0x1d, 0x13, 0x00, 0x00, 0xc8, 0x02, 0x01, 0x00, 0x08, 0x00,
-  0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09,
-  0x26, 0x47, 0xc6, 0x04, 0x43, 0xb2, 0x22, 0x28, 0x81, 0x42, 0x18, 0x01,
-  0x28, 0x10, 0xc2, 0x11, 0x00, 0xba, 0xb1, 0x04, 0x47, 0x00, 0xb1, 0x18,
-  0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1,
-  0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42,
-  0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f,
-  0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1,
-  0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84,
-  0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc,
-  0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70,
-  0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19,
-  0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f,
-  0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21,
-  0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc,
-  0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84,
-  0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37,
-  0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70,
-  0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77,
-  0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79,
-  0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e,
-  0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1,
-  0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81,
-  0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98,
-  0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88,
-  0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4,
-  0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72,
-  0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74,
-  0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e,
-  0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e,
-  0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21,
-  0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01,
-  0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc,
-  0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77,
-  0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e,
-  0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1,
-  0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61,
-  0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0,
-  0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0,
-  0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74,
-  0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e,
-  0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41,
-  0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50,
-  0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c,
-  0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc,
-  0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x79, 0x20, 0x00, 0x00, 0x8b, 0x00,
-  0x00, 0x00, 0x32, 0x9a, 0x08, 0x14, 0x02, 0x85, 0x8c, 0x27, 0x46, 0x46,
-  0xc8, 0x11, 0x32, 0x64, 0xd4, 0x24, 0xa8, 0x54, 0x00, 0x00, 0x8b, 0xe2,
-  0x06, 0xc5, 0xc6, 0x91, 0x41, 0x14, 0x19, 0xca, 0x23, 0x21, 0xd1, 0xc5,
-  0x0c, 0x00, 0x53, 0x44, 0x4b, 0x20, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f,
-  0x6e, 0x77, 0x63, 0x68, 0x61, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x41,
-  0x70, 0x70, 0x6c, 0x65, 0x20, 0x4c, 0x4c, 0x56, 0x4d, 0x20, 0x76, 0x65,
-  0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e,
-  0x34, 0x33, 0x20, 0x28, 0x6d, 0x65, 0x74, 0x61, 0x6c, 0x66, 0x65, 0x2d,
-  0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x34, 0x33, 0x29, 0x4d, 0x65, 0x74,
-  0x61, 0x6c, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c,
-  0x65, 0x2e, 0x64, 0x65, 0x6e, 0x6f, 0x72, 0x6d, 0x73, 0x5f, 0x64, 0x69,
-  0x73, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d,
-  0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61,
-  0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72,
-  0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x72, 0x61,
-  0x6d, 0x65, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x66, 0x65, 0x74,
-  0x63, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72,
-  0x2e, 0x72, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x5f, 0x74, 0x61, 0x72, 0x67,
-  0x65, 0x74, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79,
-  0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74,
-  0x34, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x61,
-  0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69,
-  0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69,
-  0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x61, 0x69, 0x72, 0x2e,
-  0x72, 0x65, 0x61, 0x64, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f,
-  0x74, 0x79, 0x70, 0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72,
-  0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x61, 0x6c,
-  0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e,
-  0x61, 0x72, 0x67, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x63, 0x6f, 0x6c, 0x00,
-  0x00, 0x00, 0x23, 0x08, 0x46, 0x30, 0x82, 0x70, 0x1c, 0x23, 0x08, 0x86,
-  0x30, 0x82, 0x60, 0x0c, 0x23, 0x08, 0x06, 0x31, 0x82, 0x40, 0x00, 0x23,
-  0x08, 0x46, 0x31, 0xc3, 0x30, 0x05, 0xd4, 0x0c, 0x43, 0x25, 0x58, 0x33,
-  0x04, 0xc3, 0x0c, 0xc3, 0x34, 0x5d, 0x33, 0x10, 0x44, 0x55, 0x5d, 0x33,
-  0x04, 0xc5, 0x0c, 0x81, 0x31, 0x43, 0x70, 0xcc, 0x50, 0x20, 0xd7, 0x95,
-  0x28, 0x33, 0x04, 0x62, 0x30, 0x03, 0x74, 0x2d, 0x4c, 0xd6, 0x5c, 0x95,
-  0xf3, 0x64, 0x50, 0x96, 0x28, 0x91, 0x34, 0x43, 0x40, 0x06, 0x33, 0x0c,
-  0xd8, 0x18, 0x94, 0x81, 0x8c, 0x04, 0x26, 0xe8, 0x22, 0x36, 0x36, 0xbb,
-  0x36, 0x97, 0xb6, 0x37, 0xb2, 0x3a, 0xb6, 0x32, 0x17, 0x33, 0xb6, 0xb0,
-  0xb3, 0xb9, 0x51, 0x84, 0x4c, 0x3b, 0x85, 0x8d, 0xcd, 0xae, 0xcd, 0x25,
-  0x8d, 0xac, 0xcc, 0x8d, 0x6e, 0x94, 0x60, 0xbb, 0x25, 0x2c, 0x4d, 0xce,
-  0xc5, 0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x6d, 0x94, 0x80, 0x3b, 0x2a,
-  0x2c, 0x4d, 0xce, 0x85, 0x2d, 0xcc, 0xed, 0xac, 0x2e, 0xec, 0xac, 0xec,
-  0xcb, 0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x6d, 0x94, 0xa0, 0xbb, 0x29,
-  0x2c, 0x4d, 0xce, 0x65, 0xec, 0xad, 0x0d, 0x2e, 0x8d, 0xad, 0xec, 0xeb,
-  0x0d, 0x8e, 0x2e, 0xed, 0xcd, 0x6d, 0x6e, 0x94, 0xc1, 0xfb, 0xc0, 0xe0,
-  0x98, 0xb0, 0x34, 0x39, 0x17, 0x33, 0xb9, 0xb0, 0xb3, 0xb6, 0x32, 0x37,
-  0xba, 0x51, 0x82, 0x32, 0x00, 0x00, 0xa9, 0x18, 0x00, 0x00, 0x0b, 0x00,
-  0x00, 0x00, 0x0b, 0x0a, 0x72, 0x28, 0x87, 0x77, 0x80, 0x07, 0x7a, 0x58,
-  0x70, 0x98, 0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb0, 0x43, 0x39, 0xd0, 0xc3,
-  0x82, 0xe6, 0x1c, 0xc6, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0xc1, 0x1d,
-  0xe6, 0x21, 0x1d, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x00, 0xd1, 0x10,
-  0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0xcc, 0x3c, 0xa4, 0x83, 0x3b,
-  0x9c, 0x03, 0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83, 0x3c, 0x94, 0x43, 0x38,
-  0x90, 0xc3, 0x01, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x1a, 0x00,
-  0x00, 0x00, 0x13, 0x04, 0x41, 0x3c, 0x0c, 0x00, 0x00, 0x00, 0x11, 0x00,
-  0x00, 0x00, 0x22, 0x47, 0xc8, 0x90, 0x51, 0x0a, 0x84, 0x18, 0x00, 0x00,
-  0x00, 0x00, 0xcf, 0x03, 0x00, 0x00, 0x6f, 0x6d, 0x6e, 0x69, 0x70, 0x6f,
-  0x74, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x68, 0x61, 0x72, 0x53, 0x69, 0x6d,
-  0x70, 0x6c, 0x65, 0x20, 0x43, 0x2b, 0x2b, 0x20, 0x54, 0x42, 0x41, 0x41,
-  0x00, 0x00, 0x13, 0x04, 0xc4, 0xd8, 0x10, 0xa0, 0xc1, 0x86, 0xe1, 0x0c,
-  0xd4, 0x20, 0x0d, 0x36, 0x0c, 0x6b, 0xb0, 0x06, 0x69, 0x00, 0x14, 0x44,
-  0xc9, 0x20, 0x20, 0x06, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x5b, 0x06,
-  0x20, 0x58, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20,
-  0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x32, 0x0e, 0x10, 0x22, 0x84, 0x00,
-  0xc7, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x0c,
-  0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0xe8, 0x00, 0x00,
-  0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x08, 0x00,
-  0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x01, 0x00,
-  0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1a, 0x00,
-  0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x00,
-  0x00, 0x00, 0x3a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x00,
-  0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x24, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x5d, 0x0c, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x03,
-  0x94, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x53, 0x6f,
-  0x6c, 0x69, 0x64, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74,
-  0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x34, 0x33, 0x61, 0x69, 0x72, 0x36,
+  0xb4, 0x81, 0x39, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e,
+  0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xc4, 0x81, 0x1d, 0xe8, 0x41, 0x1c,
+  0xd8, 0x81, 0x1e, 0xc4, 0x81, 0x1d, 0xb4, 0x81, 0x3d, 0xc8, 0x01, 0x1d,
+  0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x3d,
+  0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c,
+  0xb4, 0x81, 0x3d, 0xd0, 0x01, 0x1e, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e,
+  0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d,
+  0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xe4, 0x81, 0x1d,
+  0xe8, 0x41, 0x1c, 0xc8, 0x01, 0x1e, 0xe8, 0x41, 0x1c, 0xc8, 0x01, 0x1e,
+  0xb4, 0x81, 0x3d, 0xc4, 0x81, 0x1c, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1c,
+  0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1c, 0xe0, 0x41, 0x1b, 0xd8, 0x43, 0x1c,
+  0xe4, 0x81, 0x1c, 0xe8, 0x81, 0x1c, 0xd4, 0x81, 0x1d, 0xe8, 0x81, 0x1c,
+  0xd4, 0x81, 0x1d, 0xb4, 0x81, 0x3d, 0xc8, 0x41, 0x1d, 0xd8, 0x81, 0x1e,
+  0xc8, 0x41, 0x1d, 0xd8, 0x81, 0x1e, 0xc8, 0x41, 0x1d, 0xd8, 0x41, 0x1b,
+  0xd8, 0x43, 0x1d, 0xc4, 0x81, 0x1c, 0xe8, 0x41, 0x1d, 0xc4, 0x81, 0x1c,
+  0xe8, 0x41, 0x1d, 0xc4, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xc4, 0x01, 0x1c,
+  0xc8, 0x01, 0x1d, 0xe8, 0x41, 0x1c, 0xc0, 0x81, 0x1c, 0xd0, 0x81, 0x1e,
+  0xc4, 0x01, 0x1c, 0xc8, 0x01, 0x1d, 0xb4, 0x81, 0x3b, 0xe0, 0x81, 0x1e,
+  0xc4, 0x81, 0x1d, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x46, 0x08, 0x43, 0x3e,
+  0x6c, 0x57, 0xfe, 0x9c, 0xf3, 0x60, 0x7f, 0x45, 0x44, 0x13, 0x71, 0x0d,
+  0x89, 0x80, 0xe7, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,
+  0x00, 0x00, 0x89, 0x0d, 0x02, 0x45, 0x19, 0x06, 0x00, 0x00, 0xb2, 0x40,
+  0x0a, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90,
+  0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x52, 0x45, 0x50, 0x02, 0x85,
+  0x30, 0x02, 0x50, 0x06, 0x05, 0x18, 0x50, 0x20, 0xc4, 0x46, 0x00, 0x68,
+  0x8d, 0x25, 0x38, 0x03, 0x00, 0x00, 0x00, 0x00, 0xb1, 0x18, 0x00, 0x00,
+  0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66,
+  0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07,
+  0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10,
+  0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce,
+  0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b,
+  0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c,
+  0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07,
+  0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11,
+  0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0,
+  0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8,
+  0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b,
+  0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b,
+  0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87,
+  0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07,
+  0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87,
+  0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81,
+  0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30,
+  0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4,
+  0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca,
+  0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39,
+  0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b,
+  0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b,
+  0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83,
+  0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87,
+  0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90,
+  0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20,
+  0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc,
+  0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66,
+  0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24,
+  0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07,
+  0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e,
+  0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e,
+  0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54,
+  0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39,
+  0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c,
+  0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07,
+  0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0,
+  0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4,
+  0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38,
+  0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d,
+  0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d,
+  0xc0, 0xc3, 0x3c, 0x00, 0x79, 0x20, 0x00, 0x00, 0xd6, 0x00, 0x00, 0x00,
+  0x32, 0x9a, 0x08, 0x14, 0x02, 0x85, 0x8c, 0x27, 0x46, 0x46, 0xc8, 0x11,
+  0x32, 0x64, 0xd4, 0x3a, 0x6c, 0x7d, 0x00, 0x00, 0x8b, 0x02, 0x07, 0xc5,
+  0xc6, 0x91, 0x01, 0x13, 0x19, 0x0c, 0x12, 0x59, 0x45, 0x66, 0x20, 0x90,
+  0xe4, 0x29, 0x0f, 0x12, 0x5d, 0x88, 0x92, 0x00, 0x53, 0x44, 0x4b, 0x20,
+  0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68, 0x61, 0x72,
+  0x5f, 0x73, 0x69, 0x7a, 0x65, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x4c,
+  0x4c, 0x56, 0x4d, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20,
+  0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x35, 0x30, 0x20, 0x28, 0x6d, 0x65,
+  0x74, 0x61, 0x6c, 0x66, 0x65, 0x2d, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e,
+  0x35, 0x30, 0x2e, 0x31, 0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x61, 0x69,
+  0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x64, 0x65,
+  0x6e, 0x6f, 0x72, 0x6d, 0x73, 0x5f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c,
+  0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65,
+  0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65,
+  0x6e, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d,
+  0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x62, 0x75,
+  0x66, 0x66, 0x65, 0x72, 0x5f, 0x66, 0x65, 0x74, 0x63, 0x68, 0x5f, 0x65,
+  0x6e, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x6f, 0x73,
+  0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67,
+  0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x66, 0x6c,
+  0x6f, 0x61, 0x74, 0x34, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f,
+  0x6e, 0x61, 0x6d, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e,
+  0x61, 0x69, 0x72, 0x2e, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x5f, 0x6f,
+  0x75, 0x74, 0x70, 0x75, 0x74, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74,
+  0x65, 0x64, 0x28, 0x35, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34,
+  0x5f, 0x66, 0x29, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x67, 0x65, 0x6e, 0x65,
+  0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f,
+  0x6f, 0x72, 0x64, 0x44, 0x76, 0x32, 0x5f, 0x66, 0x29, 0x66, 0x6c, 0x6f,
+  0x61, 0x74, 0x32, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x61,
+  0x69, 0x72, 0x2e, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x5f, 0x69, 0x6e,
+  0x70, 0x75, 0x74, 0x61, 0x69, 0x72, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74,
+  0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x67, 0x65, 0x6e,
+  0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x5f, 0x5f, 0x61, 0x69, 0x72,
+  0x5f, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x68, 0x6f, 0x6c, 0x64, 0x65, 0x72,
+  0x5f, 0x5f, 0x29, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65,
+  0x72, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f,
+  0x73, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x61, 0x64,
+  0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65,
+  0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67,
+  0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f,
+  0x73, 0x69, 0x7a, 0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x78, 0x34,
+  0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x74, 0x72,
+  0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x00, 0x04, 0x58, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x30, 0x82, 0xa0, 0x04, 0x23, 0x08, 0x4b, 0x32,
+  0x82, 0xa0, 0x08, 0x23, 0x08, 0xca, 0x30, 0x82, 0xa0, 0x10, 0x23, 0x08,
+  0x08, 0x30, 0x82, 0xa0, 0x14, 0x23, 0x08, 0x8a, 0x31, 0x82, 0xa0, 0x1c,
+  0x33, 0x0c, 0x5e, 0xf0, 0xcd, 0x30, 0x80, 0x81, 0x10, 0x06, 0x33, 0x04,
+  0xc3, 0x0c, 0x83, 0xe7, 0x89, 0xc1, 0x0c, 0x04, 0x01, 0x06, 0x60, 0x20,
+  0x06, 0x33, 0x04, 0xc5, 0x0c, 0x81, 0x31, 0x43, 0x70, 0xcc, 0x50, 0x20,
+  0x89, 0xb2, 0x30, 0x33, 0x18, 0x8d, 0x93, 0x28, 0xcb, 0x33, 0x83, 0xd1,
+  0x40, 0x49, 0xb4, 0x48, 0x33, 0x0c, 0x6f, 0x00, 0x07, 0x71, 0x30, 0x83,
+  0x22, 0x06, 0x13, 0x25, 0x06, 0x60, 0x50, 0x25, 0xd1, 0xc2, 0xcc, 0xa0,
+  0x80, 0xc1, 0x44, 0x81, 0x01, 0x18, 0x54, 0x89, 0xb2, 0x3c, 0x33, 0x28,
+  0xde, 0x44, 0x79, 0x60, 0x50, 0x25, 0xd1, 0x22, 0xcd, 0x00, 0x91, 0x81,
+  0x75, 0x95, 0x01, 0xe5, 0x81, 0x01, 0x96, 0x95, 0x81, 0x66, 0x06, 0xc9,
+  0xb6, 0x70, 0x33, 0x40, 0x61, 0x60, 0x5d, 0x65, 0x40, 0x91, 0x01, 0x18,
+  0x60, 0x59, 0x19, 0x68, 0x66, 0x90, 0x6c, 0x4b, 0x37, 0x43, 0x31, 0x07,
+  0x74, 0x50, 0x07, 0x76, 0x70, 0x07, 0x33, 0x0c, 0x63, 0x20, 0x07, 0x78,
+  0x50, 0x1c, 0xc0, 0x71, 0x1c, 0xc7, 0x71, 0x1c, 0xc7, 0x89, 0x81, 0x1b,
+  0x58, 0x68, 0xa0, 0x07, 0x96, 0x65, 0xb9, 0x01, 0x1d, 0xd0, 0x01, 0x1d,
+  0xf8, 0x82, 0x2f, 0xc8, 0x82, 0x4b, 0xd0, 0x04, 0x2b, 0xc8, 0x48, 0x60,
+  0x82, 0x2e, 0x62, 0x63, 0xb3, 0x6b, 0x73, 0x69, 0x7b, 0x23, 0xab, 0x63,
+  0x2b, 0x73, 0x31, 0x63, 0x0b, 0x3b, 0x9b, 0x1b, 0x45, 0x30, 0x83, 0x33,
+  0x38, 0x85, 0x8d, 0xcd, 0xae, 0xcd, 0x25, 0x8d, 0xac, 0xcc, 0x8d, 0x6e,
+  0x94, 0x00, 0x0d, 0x6e, 0x09, 0x4b, 0x93, 0x73, 0xb1, 0x2b, 0x93, 0x9b,
+  0x4b, 0x7b, 0x73, 0x1b, 0x25, 0x48, 0x83, 0xa3, 0xc2, 0xd2, 0xe4, 0x5c,
+  0xd8, 0xc2, 0xdc, 0xce, 0xea, 0xc2, 0xce, 0xca, 0xbe, 0xec, 0xca, 0xe4,
+  0xe6, 0xd2, 0xde, 0xdc, 0x46, 0x09, 0xd4, 0xe0, 0xa6, 0xb0, 0x34, 0x39,
+  0x97, 0xb1, 0xb7, 0x36, 0xb8, 0x34, 0xb6, 0xb2, 0xaf, 0x37, 0x38, 0xba,
+  0xb4, 0x37, 0xb7, 0xb9, 0x51, 0x86, 0x35, 0x60, 0x83, 0x36, 0x38, 0x25,
+  0x2c, 0x4d, 0xce, 0xc5, 0xae, 0x4c, 0x8e, 0xae, 0x0c, 0x6f, 0x94, 0x00,
+  0x0f, 0x00, 0x00, 0x00, 0xa9, 0x18, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
+  0x0b, 0x0a, 0x72, 0x28, 0x87, 0x77, 0x80, 0x07, 0x7a, 0x58, 0x70, 0x98,
+  0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb0, 0x43, 0x39, 0xd0, 0xc3, 0x82, 0xe6,
+  0x1c, 0xc6, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0xc1, 0x1d, 0xe6, 0x21,
+  0x1d, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x00, 0xd1, 0x10, 0x00, 0x00,
+  0x06, 0x00, 0x00, 0x00, 0x07, 0xcc, 0x3c, 0xa4, 0x83, 0x3b, 0x9c, 0x03,
+  0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83, 0x3c, 0x94, 0x43, 0x38, 0x90, 0xc3,
+  0x01, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x66, 0x00, 0x00, 0x00,
+  0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
+  0xc4, 0x4a, 0xa0, 0x0c, 0x8a, 0x80, 0xdc, 0x08, 0xc0, 0x58, 0x44, 0x10,
+  0x04, 0xc1, 0x58, 0x84, 0x20, 0x08, 0xc2, 0x58, 0xc4, 0x30, 0x0c, 0x03,
+  0x85, 0x19, 0x00, 0x12, 0x33, 0x00, 0x34, 0x66, 0x00, 0x00, 0x00, 0x00,
+  0xf1, 0x30, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x22, 0x47, 0xc8, 0x90,
+  0x51, 0x0a, 0x84, 0x18, 0x00, 0x00, 0x00, 0x00, 0xcf, 0x03, 0x00, 0x00,
+  0x6f, 0x6d, 0x6e, 0x69, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x74, 0x20, 0x63,
+  0x68, 0x61, 0x72, 0x53, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x43, 0x2b,
+  0x2b, 0x20, 0x54, 0x42, 0x41, 0x41, 0x00, 0x00, 0x13, 0x04, 0x06, 0xd9,
+  0x10, 0xec, 0xc1, 0x86, 0x41, 0x0f, 0xfa, 0x80, 0x0f, 0x36, 0x0c, 0x7e,
+  0xe0, 0x07, 0x7c, 0x00, 0xbb, 0x10, 0x4b, 0x54, 0x45, 0x14, 0x84, 0xb2,
+  0x0b, 0xe1, 0x4c, 0xd7, 0x44, 0x41, 0x28, 0x83, 0x0c, 0xc3, 0xb1, 0x98,
+  0x10, 0x88, 0xff, 0x2e, 0x84, 0x74, 0x6d, 0x10, 0x05, 0xa1, 0x0c, 0x32,
+  0x1c, 0x8b, 0x63, 0x42, 0x20, 0xfe, 0x16, 0x14, 0xe0, 0xbf, 0x0b, 0x71,
+  0x71, 0x60, 0x30, 0x51, 0x10, 0xca, 0x20, 0x03, 0x03, 0x49, 0x26, 0x04,
+  0xe2, 0x6f, 0x45, 0x00, 0xfe, 0xbb, 0x10, 0x5c, 0x18, 0x94, 0x41, 0x46,
+  0x41, 0x28, 0x83, 0x0c, 0x51, 0x65, 0x99, 0x10, 0x88, 0xbf, 0x15, 0x01,
+  0xf8, 0xef, 0x42, 0x80, 0x81, 0x19, 0xa8, 0xc1, 0x47, 0x41, 0x28, 0x83,
+  0x0c, 0x81, 0xe6, 0x59, 0x50, 0x89, 0xff, 0x20, 0xc3, 0xc0, 0x7d, 0x16,
+  0x4c, 0xe2, 0x6f, 0x43, 0x00, 0xfe, 0x83, 0x0c, 0xc6, 0x17, 0x06, 0x16,
+  0x44, 0xe2, 0x6f, 0x43, 0x00, 0xfe, 0x83, 0x0c, 0x89, 0x18, 0x8c, 0x81,
+  0x05, 0x8f, 0xf8, 0xdb, 0x10, 0x80, 0xff, 0x2e, 0x44, 0x1b, 0xcc, 0xc1,
+  0x1d, 0xac, 0x01, 0x05, 0xa1, 0x0c, 0x32, 0x04, 0x67, 0xb0, 0x06, 0x16,
+  0x88, 0x81, 0xf8, 0x0f, 0x32, 0x0c, 0x69, 0xc0, 0x06, 0x16, 0x80, 0x81,
+  0xf8, 0x0f, 0x32, 0x14, 0x6b, 0xd0, 0x06, 0x16, 0x74, 0xe2, 0x3f, 0xc8,
+  0x70, 0xb4, 0x81, 0x1b, 0x58, 0xa0, 0x89, 0xff, 0x20, 0xc3, 0x1e, 0xb8,
+  0xc1, 0x1c, 0x58, 0x16, 0x88, 0xff, 0x20, 0x43, 0x1f, 0xc0, 0x01, 0x1d,
+  0x98, 0x13, 0x88, 0xbf, 0x25, 0x03, 0xf8, 0x5b, 0xc0, 0x80, 0xbf, 0x05,
+  0x09, 0xf8, 0x5b, 0x80, 0x80, 0xbf, 0x05, 0x05, 0xf8, 0xcf, 0x36, 0xd8,
+  0x41, 0x00, 0xcc, 0x36, 0x04, 0xa4, 0x10, 0xcc, 0x36, 0x04, 0xa4, 0x20,
+  0x64, 0x10, 0x10, 0x03, 0x09, 0x00, 0x00, 0x00, 0x5b, 0x86, 0x20, 0xf0,
+  0x83, 0x2d, 0xc3, 0x10, 0xf8, 0xc1, 0x96, 0xe1, 0x08, 0xfc, 0x60, 0xcb,
+  0xc0, 0x04, 0x7e, 0xb0, 0x65, 0x88, 0x02, 0x3f, 0xd8, 0x32, 0x58, 0x81,
+  0x1f, 0x6c, 0x19, 0xc6, 0x20, 0xf0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x71, 0x20, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x32, 0x0e, 0x10, 0x22,
+  0x84, 0x00, 0xa4, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x65, 0x0c, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0xe8,
+  0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+  0x0a, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x19, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x0f, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x0f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x24, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x5d, 0x0c, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+  0x12, 0x03, 0x94, 0x79, 0x00, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4c, 0x5f,
+  0x43, 0x6f, 0x70, 0x79, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x33,
+  0x31, 0x30, 0x30, 0x31, 0x2e, 0x35, 0x30, 0x2e, 0x31, 0x61, 0x69, 0x72,
+  0x36, 0x34, 0x2d, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2d, 0x74, 0x76, 0x6f,
+  0x73, 0x31, 0x33, 0x2e, 0x30, 0x2e, 0x30, 0x2d, 0x73, 0x69, 0x6d, 0x75,
+  0x6c, 0x61, 0x74, 0x6f, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b,
+  0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x18, 0x0a, 0x00, 0x00,
+  0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x35, 0x14, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x62, 0x0c, 0x30, 0x24, 0x80, 0x10, 0x05, 0xc8,
+  0x14, 0x00, 0x00, 0x00, 0x21, 0x0c, 0x00, 0x00, 0x4b, 0x02, 0x00, 0x00,
+  0x0b, 0x02, 0x21, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+  0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39,
+  0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62,
+  0x80, 0x10, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0x84, 0x10, 0x32, 0x14,
+  0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x42, 0x88, 0x48, 0x90, 0x14, 0x20,
+  0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0x04, 0x49, 0x0e, 0x90,
+  0x11, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a,
+  0x04, 0x21, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00,
+  0x1b, 0xcc, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x80, 0x03, 0x40,
+  0x02, 0x28, 0x62, 0x1c, 0xde, 0x41, 0x1e, 0xe4, 0xa1, 0x1c, 0xc6, 0x81,
+  0x1e, 0xd8, 0x21, 0x1f, 0xda, 0x40, 0x1e, 0xde, 0xa1, 0x1e, 0xdc, 0x81,
+  0x1c, 0xca, 0x81, 0x1c, 0xda, 0x80, 0x1c, 0xd2, 0xc1, 0x1e, 0xd2, 0x81,
+  0x1c, 0xca, 0xa1, 0x0d, 0xe6, 0x21, 0x1e, 0xe4, 0x81, 0x1e, 0xda, 0xc0,
+  0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x73,
+  0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x72, 0x48, 0x87, 0x79,
+  0x08, 0x07, 0x71, 0x60, 0x87, 0x72, 0x68, 0x03, 0x7a, 0x08, 0x87, 0x74,
+  0x60, 0x87, 0x36, 0x18, 0x87, 0x70, 0x60, 0x07, 0x76, 0x98, 0x07, 0xc0,
+  0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1d, 0xca, 0x61,
+  0x1e, 0xe6, 0xa1, 0x0d, 0xe0, 0x41, 0x1e, 0xca, 0x61, 0x1c, 0xd2, 0x61,
+  0x1e, 0xca, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0x21, 0x1c, 0xc8, 0x01,
+  0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77,
+  0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78,
+  0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72,
+  0x60, 0x87, 0x74, 0x68, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01,
+  0x18, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1,
+  0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41,
+  0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0xa1, 0x0d, 0xdc, 0xe1,
+  0x1d, 0xdc, 0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xc2, 0xc1, 0x1c, 0x00, 0xc2,
+  0x1d, 0xde, 0xa1, 0x0d, 0xd2, 0xc1, 0x1d, 0xcc, 0x61, 0x1e, 0xda, 0xc0,
+  0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a,
+  0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x75,
+  0xa8, 0x87, 0x76, 0x80, 0x87, 0x36, 0xa0, 0x87, 0x70, 0x10, 0x07, 0x76,
+  0x28, 0x87, 0x79, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01,
+  0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1d, 0xc2, 0xc1, 0x1d, 0xe6, 0xa1,
+  0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01,
+  0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36,
+  0x98, 0x87, 0x74, 0x38, 0x07, 0x77, 0x28, 0x07, 0x72, 0x68, 0x03, 0x7d,
+  0x28, 0x07, 0x79, 0x78, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36,
+  0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1,
+  0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0x01,
+  0x1e, 0xe0, 0x21, 0x1d, 0xdc, 0xe1, 0x1c, 0xda, 0xa0, 0x1d, 0xc2, 0x81,
+  0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x88, 0x79,
+  0xa0, 0x87, 0x70, 0x18, 0x87, 0x75, 0x68, 0x03, 0x78, 0x90, 0x87, 0x77,
+  0xa0, 0x87, 0x72, 0x18, 0x07, 0x7a, 0x78, 0x07, 0x79, 0x68, 0x03, 0x71,
+  0xa8, 0x07, 0x73, 0x30, 0x87, 0x72, 0x90, 0x87, 0x36, 0x98, 0x87, 0x74,
+  0xd0, 0x87, 0x72, 0x00, 0xf0, 0x00, 0x20, 0xea, 0xc1, 0x1d, 0xe6, 0x21,
+  0x1c, 0xcc, 0xa1, 0x1c, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21,
+  0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80,
+  0xa8, 0x87, 0x79, 0x28, 0x87, 0x36, 0x98, 0x87, 0x77, 0x30, 0x07, 0x7a,
+  0x68, 0x03, 0x73, 0x60, 0x87, 0x77, 0x08, 0x07, 0x7a, 0x00, 0xcc, 0x21,
+  0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0xd8, 0x40, 0x08, 0x02, 0x60, 0x01,
+  0x49, 0x18, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x13, 0x84, 0x40, 0x00,
+  0x89, 0x20, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x32, 0x22, 0x08, 0x09,
+  0x20, 0x64, 0x85, 0x04, 0x13, 0x22, 0xa4, 0x84, 0x04, 0x13, 0x22, 0xe3,
+  0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x88, 0x8c, 0x0b, 0x84, 0x84, 0x4c,
+  0x10, 0x24, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00, 0x65,
+  0x08, 0x09, 0x9a, 0x81, 0x80, 0x39, 0x02, 0x30, 0x48, 0x01, 0x1b, 0x01,
+  0x00, 0x00, 0x00, 0x00, 0x13, 0xc0, 0x20, 0x1c, 0xd2, 0x41, 0x1e, 0xec,
+  0x80, 0x0e, 0xda, 0x20, 0x1c, 0xe0, 0x01, 0x1e, 0xd8, 0xa1, 0x1c, 0xda,
+  0x80, 0x1e, 0xec, 0xe1, 0x1d, 0xe6, 0x21, 0x0e, 0xe6, 0xc0, 0x0d, 0xe0,
+  0xc0, 0x0d, 0xe0, 0xa0, 0x0d, 0xe6, 0x21, 0x1d, 0xda, 0xa1, 0x1e, 0xd8,
+  0x21, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0x61, 0xc3, 0x6d, 0x94, 0x43, 0x1b,
+  0xc0, 0x83, 0x1e, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e,
+  0xd8, 0x01, 0x1d, 0xb4, 0x41, 0x3a, 0xc4, 0x81, 0x1e, 0xe0, 0x81, 0x1e,
+  0xe0, 0x41, 0x1b, 0xa4, 0x03, 0x1e, 0xe8, 0x01, 0x1e, 0xe8, 0x01, 0x1e,
+  0xb4, 0x41, 0x3a, 0xc4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xd8, 0x81, 0x1e,
+  0xc4, 0x81, 0x1d, 0xb4, 0x41, 0x3a, 0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c,
+  0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x41, 0x3a, 0xd8, 0x01, 0x1d,
+  0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x39,
+  0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c,
+  0xb4, 0x81, 0x39, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e,
+  0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xc4, 0x81, 0x1d, 0xe8, 0x41, 0x1c,
+  0xd8, 0x81, 0x1e, 0xc4, 0x81, 0x1d, 0xb4, 0x81, 0x3d, 0xc8, 0x01, 0x1d,
+  0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x3d,
+  0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c,
+  0xb4, 0x81, 0x3d, 0xd0, 0x01, 0x1e, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e,
+  0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d,
+  0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xe4, 0x81, 0x1d,
+  0xe8, 0x41, 0x1c, 0xc8, 0x01, 0x1e, 0xe8, 0x41, 0x1c, 0xc8, 0x01, 0x1e,
+  0xb4, 0x81, 0x3d, 0xc4, 0x81, 0x1c, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1c,
+  0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1c, 0xe0, 0x41, 0x1b, 0xd8, 0x43, 0x1c,
+  0xe4, 0x81, 0x1c, 0xe8, 0x81, 0x1c, 0xd4, 0x81, 0x1d, 0xe8, 0x81, 0x1c,
+  0xd4, 0x81, 0x1d, 0xb4, 0x81, 0x3d, 0xc8, 0x41, 0x1d, 0xd8, 0x81, 0x1e,
+  0xc8, 0x41, 0x1d, 0xd8, 0x81, 0x1e, 0xc8, 0x41, 0x1d, 0xd8, 0x41, 0x1b,
+  0xd8, 0x43, 0x1d, 0xc4, 0x81, 0x1c, 0xe8, 0x41, 0x1d, 0xc4, 0x81, 0x1c,
+  0xe8, 0x41, 0x1d, 0xc4, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xc4, 0x01, 0x1c,
+  0xc8, 0x01, 0x1d, 0xe8, 0x41, 0x1c, 0xc0, 0x81, 0x1c, 0xd0, 0x81, 0x1e,
+  0xc4, 0x01, 0x1c, 0xc8, 0x01, 0x1d, 0xb4, 0x81, 0x3b, 0xe0, 0x81, 0x1e,
+  0xc4, 0x81, 0x1d, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x46, 0x08, 0x43, 0x4a,
+  0x6c, 0x57, 0xfe, 0xac, 0xb3, 0x20, 0xc3, 0x5f, 0x44, 0x80, 0xc1, 0x10,
+  0xcd, 0x34, 0x24, 0x02, 0xa4, 0x01, 0x00, 0x80, 0x00, 0x00, 0x00, 0x40,
+  0x00, 0x00, 0x00, 0x00, 0x24, 0x36, 0x08, 0x14, 0x6d, 0x12, 0x00, 0x00,
+  0xc8, 0x02, 0x01, 0x00, 0x07, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x0c,
+  0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0xb2,
+  0x22, 0x28, 0x81, 0x42, 0x18, 0x01, 0xa0, 0x1b, 0x4b, 0x70, 0x06, 0x00,
+  0xb1, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c,
+  0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3,
+  0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6,
+  0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e,
+  0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43,
+  0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03,
+  0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48,
+  0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20,
+  0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e,
+  0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d,
+  0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89,
+  0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83,
+  0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68,
+  0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90,
+  0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78,
+  0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98,
+  0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5,
+  0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c,
+  0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c,
+  0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43,
+  0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43,
+  0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82,
+  0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58,
+  0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18,
+  0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2,
+  0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec,
+  0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e,
+  0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d,
+  0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83,
+  0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60,
+  0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0,
+  0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d,
+  0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d,
+  0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43,
+  0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3,
+  0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18,
+  0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3,
+  0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1,
+  0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e,
+  0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83,
+  0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83,
+  0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x79, 0x20, 0x00, 0x00,
+  0x90, 0x00, 0x00, 0x00, 0x32, 0x9a, 0x08, 0x14, 0x02, 0x85, 0x8c, 0x27,
+  0x46, 0x46, 0xc8, 0x11, 0x32, 0x64, 0xd4, 0x26, 0xc8, 0x56, 0x00, 0x00,
+  0x8b, 0x02, 0x07, 0xc5, 0xc6, 0x91, 0x41, 0x14, 0x19, 0x52, 0xa6, 0x3c,
+  0x06, 0x83, 0x58, 0x05, 0x53, 0x44, 0x4b, 0x20, 0x56, 0x65, 0x72, 0x73,
+  0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68, 0x61, 0x72, 0x5f, 0x73, 0x69, 0x7a,
+  0x65, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x4c, 0x4c, 0x56, 0x4d, 0x20,
+  0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x33, 0x31, 0x30, 0x30,
+  0x31, 0x2e, 0x35, 0x30, 0x20, 0x28, 0x6d, 0x65, 0x74, 0x61, 0x6c, 0x66,
+  0x65, 0x2d, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x35, 0x30, 0x2e, 0x31,
+  0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f,
+  0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x64, 0x65, 0x6e, 0x6f, 0x72, 0x6d,
+  0x73, 0x5f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72,
+  0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73,
+  0x74, 0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c,
+  0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65,
+  0x2e, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72,
+  0x5f, 0x66, 0x65, 0x74, 0x63, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c,
+  0x65, 0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x5f,
+  0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72,
+  0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x66,
+  0x6c, 0x6f, 0x61, 0x74, 0x34, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x72, 0x61,
+  0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x67,
+  0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x38, 0x70, 0x6f,
+  0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x76, 0x32, 0x5f, 0x66, 0x29,
+  0x61, 0x69, 0x72, 0x2e, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x61, 0x69,
+  0x72, 0x2e, 0x70, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76,
+  0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x61,
+  0x72, 0x67, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74,
+  0x69, 0x6f, 0x6e, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64,
+  0x28, 0x35, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66,
+  0x29, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x00, 0x00, 0x23, 0x08, 0x46, 0x30,
+  0x82, 0x70, 0x14, 0x23, 0x08, 0x86, 0x30, 0x82, 0x60, 0x0c, 0x23, 0x08,
+  0x06, 0x31, 0x82, 0x40, 0x00, 0x33, 0x0c, 0x54, 0x50, 0xcd, 0x30, 0x58,
+  0xc2, 0x35, 0x43, 0x30, 0xcc, 0x30, 0x50, 0x14, 0x36, 0x03, 0x41, 0x58,
+  0x16, 0x36, 0x43, 0x50, 0xcc, 0x10, 0x18, 0x33, 0x04, 0xc7, 0x0c, 0x05,
+  0x82, 0x61, 0x89, 0x32, 0x43, 0x20, 0x06, 0x33, 0x24, 0xd8, 0xc2, 0x34,
+  0x4e, 0xf2, 0x40, 0xd1, 0x0c, 0x89, 0xb5, 0x48, 0x8d, 0x93, 0x28, 0xd0,
+  0x34, 0x83, 0x40, 0x06, 0x65, 0x30, 0xc3, 0x90, 0x8d, 0x81, 0x19, 0xc8,
+  0x48, 0x60, 0x82, 0x2e, 0x62, 0x63, 0xb3, 0x6b, 0x73, 0x69, 0x7b, 0x23,
+  0xab, 0x63, 0x2b, 0x73, 0x31, 0x63, 0x0b, 0x3b, 0x9b, 0x1b, 0x45, 0xc8,
+  0xb4, 0x53, 0xd8, 0xd8, 0xec, 0xda, 0x5c, 0xd2, 0xc8, 0xca, 0xdc, 0xe8,
+  0x46, 0x09, 0xb6, 0x5b, 0xc2, 0xd2, 0xe4, 0x5c, 0xec, 0xca, 0xe4, 0xe6,
+  0xd2, 0xde, 0xdc, 0x46, 0x09, 0xb8, 0xa3, 0xc2, 0xd2, 0xe4, 0x5c, 0xd8,
+  0xc2, 0xdc, 0xce, 0xea, 0xc2, 0xce, 0xca, 0xbe, 0xec, 0xca, 0xe4, 0xe6,
+  0xd2, 0xde, 0xdc, 0x46, 0x09, 0xba, 0x9b, 0xc2, 0xd2, 0xe4, 0x5c, 0xc6,
+  0xde, 0xda, 0xe0, 0xd2, 0xd8, 0xca, 0xbe, 0xde, 0xe0, 0xe8, 0xd2, 0xde,
+  0xdc, 0xe6, 0x46, 0x19, 0xbc, 0x0f, 0x0c, 0x8e, 0x09, 0x4b, 0x93, 0x73,
+  0x31, 0x93, 0x0b, 0x3b, 0x6b, 0x2b, 0x73, 0xa3, 0x1b, 0x25, 0x30, 0x03,
+  0x00, 0x00, 0x00, 0x00, 0xa9, 0x18, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
+  0x0b, 0x0a, 0x72, 0x28, 0x87, 0x77, 0x80, 0x07, 0x7a, 0x58, 0x70, 0x98,
+  0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb0, 0x43, 0x39, 0xd0, 0xc3, 0x82, 0xe6,
+  0x1c, 0xc6, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0xc1, 0x1d, 0xe6, 0x21,
+  0x1d, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x00, 0xd1, 0x10, 0x00, 0x00,
+  0x06, 0x00, 0x00, 0x00, 0x07, 0xcc, 0x3c, 0xa4, 0x83, 0x3b, 0x9c, 0x03,
+  0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83, 0x3c, 0x94, 0x43, 0x38, 0x90, 0xc3,
+  0x01, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x13, 0x04, 0x41, 0x06, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x32, 0x0e, 0x10, 0x22, 0x84, 0x00, 0xc9, 0x04,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x0c, 0x00, 0x00,
+  0x1d, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0xe8, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+  0x44, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00,
+  0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+  0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+  0xff, 0xff, 0xff, 0xff, 0x00, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x5d, 0x0c, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0x7c,
+  0x00, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x53, 0x6f, 0x6c, 0x69,
+  0x64, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x33, 0x31,
+  0x30, 0x30, 0x31, 0x2e, 0x35, 0x30, 0x2e, 0x31, 0x61, 0x69, 0x72, 0x36,
   0x34, 0x2d, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2d, 0x74, 0x76, 0x6f, 0x73,
   0x31, 0x33, 0x2e, 0x30, 0x2e, 0x30, 0x2d, 0x73, 0x69, 0x6d, 0x75, 0x6c,
   0x61, 0x74, 0x6f, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0,
-  0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x60, 0x0c,
-  0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x35, 0x14,
-  0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x62, 0x0c, 0x30, 0x24, 0x80, 0x10,
-  0x05, 0xc8, 0x14, 0x00, 0x00, 0x00, 0x21, 0x0c, 0x00, 0x00, 0xd1, 0x02,
-  0x00, 0x00, 0x0b, 0x02, 0x21, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00,
-  0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10,
-  0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04,
-  0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10,
-  0x32, 0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88, 0x48, 0x90,
-  0x14, 0x20, 0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0x04, 0x49,
-  0x0e, 0x90, 0x91, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83,
-  0xe5, 0x8a, 0x04, 0x29, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x8d, 0x00,
-  0x00, 0x00, 0x1b, 0xcc, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x58,
-  0x03, 0x40, 0x02, 0x2a, 0x62, 0x1c, 0xde, 0x41, 0x1e, 0xe4, 0xa1, 0x1c,
-  0xc6, 0x81, 0x1e, 0xd8, 0x21, 0x1f, 0xda, 0x40, 0x1e, 0xde, 0xa1, 0x1e,
-  0xdc, 0x81, 0x1c, 0xca, 0x81, 0x1c, 0xda, 0x80, 0x1c, 0xd2, 0xc1, 0x1e,
-  0xd2, 0x81, 0x1c, 0xca, 0xa1, 0x0d, 0xe6, 0x21, 0x1e, 0xe4, 0x81, 0x1e,
-  0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d,
-  0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x72, 0x48,
-  0x87, 0x79, 0x08, 0x07, 0x71, 0x60, 0x87, 0x72, 0x68, 0x03, 0x7a, 0x08,
-  0x87, 0x74, 0x60, 0x87, 0x36, 0x18, 0x87, 0x70, 0x60, 0x07, 0x76, 0x98,
-  0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1d,
-  0xca, 0x61, 0x1e, 0xe6, 0xa1, 0x0d, 0xe0, 0x41, 0x1e, 0xca, 0x61, 0x1c,
-  0xd2, 0x61, 0x1e, 0xca, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0x21, 0x1c,
-  0xc8, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x70,
-  0x87, 0x77, 0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72, 0x68,
-  0x03, 0x78, 0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79, 0x68,
-  0x83, 0x72, 0x60, 0x87, 0x74, 0x68, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e,
-  0xca, 0x01, 0x18, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c,
-  0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e,
-  0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0xa1, 0x0d,
-  0xdc, 0xe1, 0x1d, 0xdc, 0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xc2, 0xc1, 0x1c,
-  0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xd2, 0xc1, 0x1d, 0xcc, 0x61, 0x1e,
-  0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d,
-  0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68,
-  0x03, 0x75, 0xa8, 0x87, 0x76, 0x80, 0x87, 0x36, 0xa0, 0x87, 0x70, 0x10,
-  0x07, 0x76, 0x28, 0x87, 0x79, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e,
-  0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1d, 0xc2, 0xc1, 0x1d,
-  0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e,
-  0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78,
-  0x87, 0x36, 0x98, 0x87, 0x74, 0x38, 0x07, 0x77, 0x28, 0x07, 0x72, 0x68,
-  0x03, 0x7d, 0x28, 0x07, 0x79, 0x78, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80,
-  0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e,
-  0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe8, 0x41, 0x1e,
-  0xc2, 0x01, 0x1e, 0xe0, 0x21, 0x1d, 0xdc, 0xe1, 0x1c, 0xda, 0xa0, 0x1d,
-  0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00,
-  0x88, 0x79, 0xa0, 0x87, 0x70, 0x18, 0x87, 0x75, 0x68, 0x03, 0x78, 0x90,
-  0x87, 0x77, 0xa0, 0x87, 0x72, 0x18, 0x07, 0x7a, 0x78, 0x07, 0x79, 0x68,
-  0x03, 0x71, 0xa8, 0x07, 0x73, 0x30, 0x87, 0x72, 0x90, 0x87, 0x36, 0x98,
-  0x87, 0x74, 0xd0, 0x87, 0x72, 0x00, 0xf0, 0x00, 0x20, 0xea, 0xc1, 0x1d,
-  0xe6, 0x21, 0x1c, 0xcc, 0xa1, 0x1c, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d,
-  0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28,
-  0x07, 0x80, 0xa8, 0x87, 0x79, 0x28, 0x87, 0x36, 0x98, 0x87, 0x77, 0x30,
-  0x07, 0x7a, 0x68, 0x03, 0x73, 0x60, 0x87, 0x77, 0x08, 0x07, 0x7a, 0x00,
-  0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0xd8, 0xb0, 0x08, 0x03,
-  0x90, 0x00, 0x0b, 0x50, 0x05, 0x69, 0x00, 0x6d, 0x30, 0x06, 0x02, 0x58,
-  0x80, 0x6a, 0x83, 0x41, 0x14, 0xc0, 0x02, 0x54, 0x1b, 0x94, 0xe2, 0xff,
-  0xff, 0xff, 0xff, 0x07, 0xa0, 0x0d, 0x80, 0x35, 0x00, 0x24, 0xa0, 0xda,
-  0x60, 0x18, 0x01, 0xb0, 0x00, 0xd5, 0x06, 0xe3, 0x10, 0x80, 0x05, 0xa8,
-  0x00, 0x00, 0x49, 0x18, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x13, 0x88,
-  0x40, 0x18, 0x88, 0x09, 0x43, 0x61, 0x1c, 0x00, 0x00, 0x00, 0x89, 0x20,
-  0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09, 0x20, 0x64,
-  0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1,
-  0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x54,
-  0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00, 0x83, 0x08, 0x41,
-  0x70, 0x94, 0x34, 0x45, 0x94, 0x30, 0xf9, 0xff, 0x44, 0x5c, 0x13, 0x15,
-  0x11, 0xbf, 0x3d, 0xfc, 0xd3, 0x18, 0x01, 0x30, 0x88, 0x40, 0x04, 0x17,
-  0x49, 0x53, 0x44, 0x09, 0x93, 0xff, 0x4b, 0x00, 0xf3, 0x2c, 0x44, 0xf4,
-  0x4f, 0x63, 0x04, 0xc0, 0x20, 0x82, 0x21, 0x14, 0x23, 0x04, 0x31, 0xca,
-  0x21, 0x34, 0x47, 0x80, 0x18, 0x21, 0xa8, 0x39, 0x82, 0x60, 0x8e, 0x00,
-  0x0c, 0x86, 0x11, 0x84, 0xa6, 0x28, 0xab, 0x1c, 0xc1, 0x1c, 0x03, 0xa0,
-  0xd1, 0x1b, 0x08, 0x48, 0x81, 0x36, 0x47, 0x00, 0x0a, 0x23, 0x00, 0x00,
-  0x00, 0x00, 0x13, 0xc0, 0x20, 0x1c, 0xd2, 0x41, 0x1e, 0xec, 0x80, 0x0e,
-  0xda, 0x20, 0x1c, 0xe0, 0x01, 0x1e, 0xd8, 0xa1, 0x1c, 0xda, 0x80, 0x1e,
-  0xec, 0xe1, 0x1d, 0xe6, 0x21, 0x0e, 0xe6, 0xc0, 0x0d, 0xe0, 0xc0, 0x0d,
-  0xe0, 0xa0, 0x0d, 0xe6, 0x21, 0x1d, 0xda, 0xa1, 0x1e, 0xd8, 0x21, 0x1c,
-  0xe8, 0xe1, 0x1d, 0xe4, 0x61, 0xc3, 0x6d, 0x94, 0x43, 0x1b, 0xc0, 0x83,
-  0x1e, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01,
-  0x1d, 0xb4, 0x41, 0x3a, 0xc4, 0x81, 0x1e, 0xe0, 0x81, 0x1e, 0xe0, 0x41,
-  0x1b, 0xa4, 0x03, 0x1e, 0xe8, 0x01, 0x1e, 0xe8, 0x01, 0x1e, 0xb4, 0x41,
-  0x3a, 0xc4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xd8, 0x81, 0x1e, 0xc4, 0x81,
-  0x1d, 0xb4, 0x41, 0x3a, 0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81,
-  0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x41, 0x3a, 0xd8, 0x01, 0x1d, 0xe8, 0x81,
-  0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x39, 0xcc, 0x81,
-  0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81,
-  0x39, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01,
-  0x1d, 0xb4, 0x81, 0x3d, 0xc4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xd8, 0x81,
-  0x1e, 0xc4, 0x81, 0x1d, 0xb4, 0x81, 0x3d, 0xc8, 0x01, 0x1d, 0xe8, 0xc1,
-  0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xcc, 0x81,
-  0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81,
-  0x3d, 0xd0, 0x01, 0x1e, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01,
-  0x1d, 0xb4, 0x81, 0x3d, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81,
-  0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xe4, 0x81, 0x1d, 0xe8, 0x41,
-  0x1c, 0xc8, 0x01, 0x1e, 0xe8, 0x41, 0x1c, 0xc8, 0x01, 0x1e, 0xb4, 0x81,
-  0x3d, 0xc4, 0x81, 0x1c, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1c, 0xe0, 0x81,
-  0x1e, 0xc4, 0x81, 0x1c, 0xe0, 0x41, 0x1b, 0xd8, 0x43, 0x1c, 0xe4, 0x81,
-  0x1c, 0xe8, 0x81, 0x1c, 0xd4, 0x81, 0x1d, 0xe8, 0x81, 0x1c, 0xd4, 0x81,
-  0x1d, 0xb4, 0x81, 0x3d, 0xc8, 0x41, 0x1d, 0xd8, 0x81, 0x1e, 0xc8, 0x41,
-  0x1d, 0xd8, 0x81, 0x1e, 0xc8, 0x41, 0x1d, 0xd8, 0x41, 0x1b, 0xd8, 0x43,
-  0x1d, 0xc4, 0x81, 0x1c, 0xe8, 0x41, 0x1d, 0xc4, 0x81, 0x1c, 0xe8, 0x41,
-  0x1d, 0xc4, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xc4, 0x01, 0x1c, 0xc8, 0x01,
-  0x1d, 0xe8, 0x41, 0x1c, 0xc0, 0x81, 0x1c, 0xd0, 0x81, 0x1e, 0xc4, 0x01,
-  0x1c, 0xc8, 0x01, 0x1d, 0xb4, 0x81, 0x3b, 0xe0, 0x81, 0x1e, 0xc4, 0x81,
-  0x1d, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x46, 0x08, 0x43, 0x46, 0x6c, 0x57,
-  0xfe, 0x9c, 0xf3, 0x60, 0x7f, 0x11, 0x01, 0x06, 0x43, 0x34, 0xd3, 0x90,
-  0x08, 0x88, 0x10, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
-  0x00, 0x18, 0x12, 0x45, 0xdb, 0x03, 0x04, 0x80, 0x00, 0x00, 0x00, 0x20,
-  0x00, 0x00, 0x00, 0x00, 0x12, 0x1b, 0x04, 0x8a, 0x4e, 0x0b, 0x00, 0x00,
-  0x64, 0x81, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x32, 0x1e,
-  0x98, 0x10, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04,
-  0x43, 0x6a, 0x45, 0x50, 0x02, 0x85, 0x30, 0x02, 0x50, 0x20, 0x65, 0x40,
-  0x73, 0x04, 0x80, 0xe4, 0x58, 0x82, 0x23, 0x00, 0x00, 0x00, 0xb1, 0x18,
-  0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1,
-  0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42,
-  0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f,
-  0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1,
-  0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84,
-  0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc,
-  0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70,
-  0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19,
-  0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f,
-  0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21,
-  0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc,
-  0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84,
-  0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37,
-  0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70,
-  0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77,
-  0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79,
-  0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e,
-  0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1,
-  0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81,
-  0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98,
-  0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88,
-  0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4,
-  0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72,
-  0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74,
-  0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e,
-  0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e,
-  0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21,
-  0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01,
-  0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc,
-  0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77,
-  0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e,
-  0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1,
-  0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61,
-  0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0,
-  0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0,
-  0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74,
-  0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e,
-  0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41,
-  0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50,
-  0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c,
-  0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc,
-  0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x79, 0x20, 0x00, 0x00, 0xce, 0x00,
-  0x00, 0x00, 0x32, 0x9a, 0x08, 0x14, 0x02, 0x85, 0x8c, 0x27, 0x46, 0x46,
-  0xc8, 0x11, 0x32, 0x64, 0xd4, 0xc4, 0x80, 0x63, 0x21, 0x00, 0x8b, 0xe2,
-  0x06, 0xc5, 0xc6, 0x91, 0x41, 0x14, 0x19, 0x8c, 0x22, 0x31, 0x88, 0x94,
-  0x3d, 0x06, 0xa2, 0x3c, 0x12, 0x12, 0x5d, 0xc3, 0xa2, 0x60, 0xc3, 0x72,
-  0x04, 0x00, 0x53, 0x44, 0x4b, 0x20, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f,
-  0x6e, 0x77, 0x63, 0x68, 0x61, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x41,
-  0x70, 0x70, 0x6c, 0x65, 0x20, 0x4c, 0x4c, 0x56, 0x4d, 0x20, 0x76, 0x65,
-  0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e,
-  0x34, 0x33, 0x20, 0x28, 0x6d, 0x65, 0x74, 0x61, 0x6c, 0x66, 0x65, 0x2d,
-  0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x34, 0x33, 0x29, 0x4d, 0x65, 0x74,
+  0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+  0xac, 0x0b, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde,
+  0x35, 0x14, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x62, 0x0c, 0x30, 0x24,
+  0x80, 0x10, 0x05, 0xc8, 0x14, 0x00, 0x00, 0x00, 0x21, 0x0c, 0x00, 0x00,
+  0xa3, 0x02, 0x00, 0x00, 0x0b, 0x02, 0x21, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x13, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49,
+  0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19,
+  0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42,
+  0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88,
+  0x48, 0x90, 0x14, 0x20, 0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42,
+  0x04, 0x49, 0x0e, 0x90, 0x91, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c,
+  0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x29, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00,
+  0x8a, 0x00, 0x00, 0x00, 0x1b, 0xcc, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff,
+  0x01, 0x58, 0x03, 0x40, 0x02, 0x2a, 0x62, 0x1c, 0xde, 0x41, 0x1e, 0xe4,
+  0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xd8, 0x21, 0x1f, 0xda, 0x40, 0x1e, 0xde,
+  0xa1, 0x1e, 0xdc, 0x81, 0x1c, 0xca, 0x81, 0x1c, 0xda, 0x80, 0x1c, 0xd2,
+  0xc1, 0x1e, 0xd2, 0x81, 0x1c, 0xca, 0xa1, 0x0d, 0xe6, 0x21, 0x1e, 0xe4,
+  0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8,
+  0x01, 0x1d, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08,
+  0x72, 0x48, 0x87, 0x79, 0x08, 0x07, 0x71, 0x60, 0x87, 0x72, 0x68, 0x03,
+  0x7a, 0x08, 0x87, 0x74, 0x60, 0x87, 0x36, 0x18, 0x87, 0x70, 0x60, 0x07,
+  0x76, 0x98, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00,
+  0x82, 0x1d, 0xca, 0x61, 0x1e, 0xe6, 0xa1, 0x0d, 0xe0, 0x41, 0x1e, 0xca,
+  0x61, 0x1c, 0xd2, 0x61, 0x1e, 0xca, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda,
+  0x21, 0x1c, 0xc8, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07,
+  0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68, 0x87,
+  0x72, 0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28, 0x07,
+  0x79, 0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68, 0x07, 0x80, 0x1e, 0xe4,
+  0xa1, 0x1e, 0xca, 0x01, 0x18, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4,
+  0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc,
+  0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda,
+  0xa1, 0x0d, 0xdc, 0xe1, 0x1d, 0xdc, 0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xc2,
+  0xc1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xd2, 0xc1, 0x1d, 0xcc,
+  0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8,
+  0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87,
+  0x77, 0x68, 0x03, 0x75, 0xa8, 0x87, 0x76, 0x80, 0x87, 0x36, 0xa0, 0x87,
+  0x70, 0x10, 0x07, 0x76, 0x28, 0x87, 0x79, 0x00, 0xcc, 0x21, 0x1c, 0xd8,
+  0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1d, 0xc2,
+  0xc1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2,
+  0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08,
+  0x77, 0x78, 0x87, 0x36, 0x98, 0x87, 0x74, 0x38, 0x07, 0x77, 0x28, 0x07,
+  0x72, 0x68, 0x03, 0x7d, 0x28, 0x07, 0x79, 0x78, 0x87, 0x79, 0x68, 0x03,
+  0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8,
+  0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe8,
+  0x41, 0x1e, 0xc2, 0x01, 0x1e, 0xe0, 0x21, 0x1d, 0xdc, 0xe1, 0x1c, 0xda,
+  0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87,
+  0x72, 0x00, 0x88, 0x79, 0xa0, 0x87, 0x70, 0x18, 0x87, 0x75, 0x68, 0x03,
+  0x78, 0x90, 0x87, 0x77, 0xa0, 0x87, 0x72, 0x18, 0x07, 0x7a, 0x78, 0x07,
+  0x79, 0x68, 0x03, 0x71, 0xa8, 0x07, 0x73, 0x30, 0x87, 0x72, 0x90, 0x87,
+  0x36, 0x98, 0x87, 0x74, 0xd0, 0x87, 0x72, 0x00, 0xf0, 0x00, 0x20, 0xea,
+  0xc1, 0x1d, 0xe6, 0x21, 0x1c, 0xcc, 0xa1, 0x1c, 0xda, 0xc0, 0x1c, 0xe0,
+  0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87,
+  0x7a, 0x28, 0x07, 0x80, 0xa8, 0x87, 0x79, 0x28, 0x87, 0x36, 0x98, 0x87,
+  0x77, 0x30, 0x07, 0x7a, 0x68, 0x03, 0x73, 0x60, 0x87, 0x77, 0x08, 0x07,
+  0x7a, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0xd8, 0x60,
+  0x08, 0x04, 0xb0, 0x00, 0xd5, 0x06, 0x63, 0x28, 0x80, 0x05, 0xa8, 0x36,
+  0x28, 0xc4, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x40, 0x1b, 0x00, 0x6b, 0x00,
+  0x48, 0x40, 0xb5, 0xc1, 0x28, 0x02, 0x60, 0x01, 0xaa, 0x0d, 0x86, 0x21,
+  0x00, 0x0b, 0x50, 0x01, 0x49, 0x18, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x13, 0x86, 0x40, 0x18, 0x26, 0x0c, 0x44, 0x61, 0x00, 0x00, 0x00, 0x00,
+  0x89, 0x20, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09,
+  0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3,
+  0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c,
+  0x10, 0x4c, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00, 0x47,
+  0x49, 0x53, 0x44, 0x09, 0x93, 0xff, 0x4f, 0xc4, 0x35, 0x51, 0x11, 0xf1,
+  0xdb, 0xc3, 0x3f, 0x8d, 0x11, 0x00, 0x83, 0x08, 0x43, 0x70, 0x91, 0x34,
+  0x45, 0x94, 0x30, 0xf9, 0xbf, 0x04, 0x30, 0xcf, 0x42, 0x44, 0xff, 0x34,
+  0x46, 0x00, 0x0c, 0x22, 0x14, 0x42, 0x31, 0x42, 0x08, 0x82, 0x18, 0x3a,
+  0x73, 0x04, 0x88, 0x11, 0x42, 0x9a, 0x23, 0x08, 0xe6, 0x08, 0xc0, 0x60,
+  0x18, 0x41, 0x60, 0x8a, 0xa2, 0x88, 0x11, 0xab, 0x2d, 0x00, 0x18, 0xb9,
+  0x81, 0x80, 0x14, 0x60, 0x23, 0x00, 0x00, 0x00, 0x13, 0xc0, 0x20, 0x1c,
+  0xd2, 0x41, 0x1e, 0xec, 0x80, 0x0e, 0xda, 0x20, 0x1c, 0xe0, 0x01, 0x1e,
+  0xd8, 0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xec, 0xe1, 0x1d, 0xe6, 0x21, 0x0e,
+  0xe6, 0xc0, 0x0d, 0xe0, 0xc0, 0x0d, 0xe0, 0xa0, 0x0d, 0xe6, 0x21, 0x1d,
+  0xda, 0xa1, 0x1e, 0xd8, 0x21, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0x61, 0xc3,
+  0x6d, 0x94, 0x43, 0x1b, 0xc0, 0x83, 0x1e, 0xd8, 0x01, 0x1d, 0xe8, 0x81,
+  0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x41, 0x3a, 0xc4, 0x81,
+  0x1e, 0xe0, 0x81, 0x1e, 0xe0, 0x41, 0x1b, 0xa4, 0x03, 0x1e, 0xe8, 0x01,
+  0x1e, 0xe8, 0x01, 0x1e, 0xb4, 0x41, 0x3a, 0xc4, 0x81, 0x1d, 0xe8, 0x41,
+  0x1c, 0xd8, 0x81, 0x1e, 0xc4, 0x81, 0x1d, 0xb4, 0x41, 0x3a, 0xcc, 0x81,
+  0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x41,
+  0x3a, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01,
+  0x1d, 0xb4, 0x81, 0x39, 0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81,
+  0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x39, 0xd8, 0x01, 0x1d, 0xe8, 0x81,
+  0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xc4, 0x81,
+  0x1d, 0xe8, 0x41, 0x1c, 0xd8, 0x81, 0x1e, 0xc4, 0x81, 0x1d, 0xb4, 0x81,
+  0x3d, 0xc8, 0x01, 0x1d, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81,
+  0x1c, 0xb4, 0x81, 0x3d, 0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81,
+  0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xd0, 0x01, 0x1e, 0xe8, 0x81,
+  0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xd8, 0x01,
+  0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81,
+  0x3d, 0xe4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xc8, 0x01, 0x1e, 0xe8, 0x41,
+  0x1c, 0xc8, 0x01, 0x1e, 0xb4, 0x81, 0x3d, 0xc4, 0x81, 0x1c, 0xe0, 0x81,
+  0x1e, 0xc4, 0x81, 0x1c, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1c, 0xe0, 0x41,
+  0x1b, 0xd8, 0x43, 0x1c, 0xe4, 0x81, 0x1c, 0xe8, 0x81, 0x1c, 0xd4, 0x81,
+  0x1d, 0xe8, 0x81, 0x1c, 0xd4, 0x81, 0x1d, 0xb4, 0x81, 0x3d, 0xc8, 0x41,
+  0x1d, 0xd8, 0x81, 0x1e, 0xc8, 0x41, 0x1d, 0xd8, 0x81, 0x1e, 0xc8, 0x41,
+  0x1d, 0xd8, 0x41, 0x1b, 0xd8, 0x43, 0x1d, 0xc4, 0x81, 0x1c, 0xe8, 0x41,
+  0x1d, 0xc4, 0x81, 0x1c, 0xe8, 0x41, 0x1d, 0xc4, 0x81, 0x1c, 0xb4, 0x81,
+  0x3d, 0xc4, 0x01, 0x1c, 0xc8, 0x01, 0x1d, 0xe8, 0x41, 0x1c, 0xc0, 0x81,
+  0x1c, 0xd0, 0x81, 0x1e, 0xc4, 0x01, 0x1c, 0xc8, 0x01, 0x1d, 0xb4, 0x81,
+  0x3b, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1d, 0xe8, 0xc1, 0x1c, 0xc8, 0x81,
+  0x46, 0x08, 0x43, 0x46, 0x6c, 0x57, 0xfe, 0x9c, 0xf3, 0x60, 0x7f, 0x11,
+  0x01, 0x06, 0x43, 0x34, 0xd3, 0x90, 0x08, 0x88, 0x0e, 0x00, 0x00, 0x02,
+  0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18, 0x12, 0x45, 0x9b, 0x03,
+  0x04, 0x80, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x12, 0x1b,
+  0x04, 0x8a, 0x96, 0x0a, 0x00, 0x00, 0x64, 0x81, 0x00, 0x00, 0x00, 0x00,
+  0x08, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90,
+  0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x62, 0x45, 0x50, 0x02, 0x85,
+  0x30, 0x02, 0x50, 0x06, 0x14, 0xc7, 0x12, 0x9c, 0x01, 0x00, 0x00, 0x00,
+  0xb1, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c,
+  0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3,
+  0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6,
+  0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e,
+  0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43,
+  0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03,
+  0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48,
+  0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20,
+  0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e,
+  0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d,
+  0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89,
+  0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83,
+  0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68,
+  0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90,
+  0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78,
+  0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98,
+  0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5,
+  0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c,
+  0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c,
+  0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43,
+  0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43,
+  0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82,
+  0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58,
+  0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18,
+  0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2,
+  0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec,
+  0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e,
+  0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d,
+  0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83,
+  0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60,
+  0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0,
+  0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d,
+  0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d,
+  0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43,
+  0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3,
+  0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18,
+  0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3,
+  0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1,
+  0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e,
+  0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83,
+  0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83,
+  0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x79, 0x20, 0x00, 0x00,
+  0xbe, 0x00, 0x00, 0x00, 0x32, 0x9a, 0x08, 0x14, 0x02, 0x85, 0x8c, 0x27,
+  0x46, 0x46, 0xc8, 0x11, 0x32, 0x64, 0xd4, 0x3c, 0x2c, 0x77, 0x00, 0x00,
+  0x8b, 0x02, 0x07, 0xc5, 0xc6, 0x91, 0x41, 0x14, 0x19, 0x8c, 0x22, 0x31,
+  0x88, 0x64, 0x3d, 0x45, 0x66, 0x20, 0x8b, 0xa4, 0x60, 0xc3, 0x72, 0x04,
+  0x53, 0x44, 0x4b, 0x20, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x77,
+  0x63, 0x68, 0x61, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x41, 0x70, 0x70,
+  0x6c, 0x65, 0x20, 0x4c, 0x4c, 0x56, 0x4d, 0x20, 0x76, 0x65, 0x72, 0x73,
+  0x69, 0x6f, 0x6e, 0x20, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x35, 0x30,
+  0x20, 0x28, 0x6d, 0x65, 0x74, 0x61, 0x6c, 0x66, 0x65, 0x2d, 0x33, 0x31,
+  0x30, 0x30, 0x31, 0x2e, 0x35, 0x30, 0x2e, 0x31, 0x29, 0x4d, 0x65, 0x74,
   0x61, 0x6c, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c,
   0x65, 0x2e, 0x64, 0x65, 0x6e, 0x6f, 0x72, 0x6d, 0x73, 0x5f, 0x64, 0x69,
   0x73, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d,
@@ -1052,268 +1062,867 @@ const unsigned char sdl_metallib[] = {
   0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f,
   0x6e, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e,
   0x74, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x67, 0x65, 0x6e, 0x65, 0x72,
-  0x61, 0x74, 0x65, 0x64, 0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f,
-  0x72, 0x64, 0x44, 0x76, 0x32, 0x5f, 0x66, 0x29, 0x61, 0x69, 0x72, 0x2e,
-  0x70, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x66,
-  0x6c, 0x6f, 0x61, 0x74, 0x32, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72,
-  0x64, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x61,
-  0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69,
-  0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69,
-  0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x61, 0x69, 0x72, 0x2e,
-  0x72, 0x65, 0x61, 0x64, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f,
-  0x74, 0x79, 0x70, 0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72,
-  0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x61, 0x6c,
-  0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x63, 0x6f, 0x6c, 0x61,
-  0x69, 0x72, 0x2e, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x61, 0x69,
-  0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x78, 0x74,
-  0x75, 0x72, 0x65, 0x32, 0x64, 0x3c, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x2c,
-  0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x3e, 0x74, 0x65, 0x78, 0x61,
-  0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73, 0x61,
-  0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73, 0x23, 0x08, 0x8d, 0x30, 0x82, 0x20,
-  0x25, 0x23, 0x08, 0xcd, 0x30, 0x82, 0xd0, 0x10, 0x23, 0x08, 0x4d, 0x31,
-  0x82, 0x90, 0x00, 0x23, 0x08, 0x8d, 0x31, 0x82, 0xd0, 0x1c, 0x33, 0x0c,
-  0x63, 0x10, 0x90, 0xc1, 0x0c, 0x43, 0x19, 0x08, 0x66, 0x30, 0x43, 0x30,
-  0xcc, 0x30, 0x8c, 0xc1, 0x18, 0x9c, 0xc1, 0x0c, 0x04, 0x51, 0x06, 0x65,
-  0x70, 0x06, 0x33, 0x04, 0xc5, 0x0c, 0x81, 0x31, 0x43, 0x70, 0xcc, 0x50,
-  0x20, 0x67, 0x70, 0x06, 0x89, 0x32, 0x43, 0x30, 0x07, 0x33, 0x20, 0x67,
-  0xb0, 0x30, 0x4d, 0xa2, 0x38, 0xcf, 0x0c, 0x49, 0x19, 0x40, 0x11, 0x23,
-  0x25, 0x93, 0x43, 0xcd, 0x00, 0x8d, 0x41, 0x65, 0xa5, 0xc1, 0x75, 0x06,
-  0x65, 0x80, 0x65, 0x69, 0xa0, 0xa5, 0x41, 0xa2, 0x38, 0xdb, 0x0c, 0x8a,
-  0x1a, 0x70, 0xd7, 0x19, 0x94, 0x41, 0x97, 0x78, 0xce, 0x37, 0x43, 0x62,
-  0x06, 0x60, 0x70, 0x9d, 0x41, 0x19, 0x24, 0x61, 0xe0, 0x88, 0xc1, 0x0c,
-  0x45, 0x1d, 0xd8, 0xc1, 0x1d, 0xe0, 0x41, 0x1e, 0xcc, 0x30, 0xa0, 0x01,
-  0x1d, 0xe8, 0x81, 0x8c, 0x04, 0x26, 0xe8, 0x22, 0x36, 0x36, 0xbb, 0x36,
-  0x97, 0xb6, 0x37, 0xb2, 0x3a, 0xb6, 0x32, 0x17, 0x33, 0xb6, 0xb0, 0xb3,
-  0xb9, 0x51, 0x04, 0x35, 0x58, 0x83, 0x53, 0xd8, 0xd8, 0xec, 0xda, 0x5c,
-  0xd2, 0xc8, 0xca, 0xdc, 0xe8, 0x46, 0x09, 0xd8, 0xe0, 0x96, 0xb0, 0x34,
-  0x39, 0x17, 0xbb, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x51, 0x82, 0x36,
-  0x38, 0x2a, 0x2c, 0x4d, 0xce, 0x85, 0x2d, 0xcc, 0xed, 0xac, 0x2e, 0xec,
-  0xac, 0xec, 0xcb, 0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x6d, 0x94, 0xc0,
-  0x0d, 0x6e, 0x0a, 0x4b, 0x93, 0x73, 0x19, 0x7b, 0x6b, 0x83, 0x4b, 0x63,
-  0x2b, 0xfb, 0x7a, 0x83, 0xa3, 0x4b, 0x7b, 0x73, 0x9b, 0x1b, 0x65, 0x78,
-  0x03, 0x38, 0x88, 0x83, 0x63, 0xc2, 0xd2, 0xe4, 0x5c, 0xcc, 0xe4, 0xc2,
-  0xce, 0xda, 0xca, 0xdc, 0xe8, 0x46, 0x09, 0xf4, 0x00, 0x00, 0xa9, 0x18,
-  0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x0a, 0x72, 0x28, 0x87, 0x77,
-  0x80, 0x07, 0x7a, 0x58, 0x70, 0x98, 0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb0,
-  0x43, 0x39, 0xd0, 0xc3, 0x82, 0xe6, 0x1c, 0xc6, 0xa1, 0x0d, 0xe8, 0x41,
-  0x1e, 0xc2, 0xc1, 0x1d, 0xe6, 0x21, 0x1d, 0xe8, 0x21, 0x1d, 0xde, 0xc1,
-  0x1d, 0x00, 0xd1, 0x10, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0xcc,
-  0x3c, 0xa4, 0x83, 0x3b, 0x9c, 0x03, 0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83,
-  0x3c, 0x94, 0x43, 0x38, 0x90, 0xc3, 0x01, 0x00, 0x00, 0x00, 0x61, 0x20,
-  0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00,
-  0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xc4, 0x6a, 0x60, 0x04, 0x80, 0xdc,
-  0x08, 0x00, 0x81, 0x11, 0x00, 0x00, 0xf1, 0x30, 0x00, 0x00, 0x11, 0x00,
-  0x00, 0x00, 0x22, 0x47, 0xc8, 0x90, 0x51, 0x0a, 0x84, 0x18, 0x00, 0x00,
-  0x00, 0x00, 0xcf, 0x03, 0x00, 0x00, 0x6f, 0x6d, 0x6e, 0x69, 0x70, 0x6f,
-  0x74, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x68, 0x61, 0x72, 0x53, 0x69, 0x6d,
-  0x70, 0x6c, 0x65, 0x20, 0x43, 0x2b, 0x2b, 0x20, 0x54, 0x42, 0x41, 0x41,
-  0x00, 0x00, 0x13, 0x84, 0x09, 0xd9, 0x10, 0xf4, 0xc1, 0x86, 0x81, 0x0f,
-  0xfe, 0xc0, 0x0f, 0x36, 0x0c, 0xa0, 0x00, 0x0a, 0x7e, 0x00, 0x23, 0x06,
-  0x8d, 0x10, 0x82, 0x60, 0xf0, 0x48, 0x46, 0x81, 0x10, 0xc2, 0x10, 0x04,
-  0xce, 0x68, 0x42, 0x00, 0x50, 0x12, 0x8a, 0x09, 0x81, 0xf8, 0x67, 0x10,
-  0x10, 0x03, 0x02, 0x00, 0x00, 0x00, 0x5b, 0x06, 0x21, 0x00, 0x05, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x03, 0x00,
-  0x00, 0x00, 0x32, 0x0e, 0x10, 0x22, 0x84, 0x00, 0xad, 0x05, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x0c, 0x00, 0x00, 0x23, 0x00,
-  0x00, 0x00, 0x12, 0x03, 0x94, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
-  0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x44, 0x00,
-  0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x80, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x20, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x54, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0xff, 0xff,
-  0xff, 0xff, 0x00, 0x24, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x1b, 0x00,
-  0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0xff, 0xff,
-  0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5d, 0x0c,
-  0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0xb4, 0x00, 0x00,
-  0x00, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x43, 0x6f, 0x70, 0x79, 0x5f, 0x66,
-  0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x69, 0x72, 0x2e, 0x73,
-  0x61, 0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72,
-  0x65, 0x5f, 0x32, 0x64, 0x2e, 0x76, 0x34, 0x66, 0x33, 0x32, 0x33, 0x31,
-  0x30, 0x30, 0x31, 0x2e, 0x34, 0x33, 0x61, 0x69, 0x72, 0x36, 0x34, 0x2d,
+  0x61, 0x74, 0x65, 0x64, 0x28, 0x35, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44,
+  0x76, 0x34, 0x5f, 0x66, 0x29, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x65, 0x72,
+  0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x63, 0x6f, 0x6c, 0x6f,
+  0x72, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x38,
+  0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x44, 0x76, 0x32, 0x5f,
+  0x66, 0x29, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32, 0x74, 0x65, 0x78, 0x63,
+  0x6f, 0x6f, 0x72, 0x64, 0x61, 0x69, 0x72, 0x2e, 0x74, 0x65, 0x78, 0x74,
+  0x75, 0x72, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74,
+  0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x61, 0x69, 0x72,
+  0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x78, 0x74, 0x75,
+  0x72, 0x65, 0x32, 0x64, 0x3c, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x2c, 0x20,
+  0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x3e, 0x74, 0x65, 0x78, 0x61, 0x69,
+  0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73, 0x61, 0x6d,
+  0x70, 0x6c, 0x65, 0x72, 0x73, 0x00, 0x00, 0x00, 0x23, 0x08, 0x8c, 0x30,
+  0x82, 0x10, 0x1d, 0x23, 0x08, 0xcc, 0x30, 0x82, 0xc0, 0x10, 0x23, 0x08,
+  0x4c, 0x31, 0x82, 0x80, 0x00, 0x23, 0x08, 0x8c, 0x31, 0xc3, 0xf0, 0x05,
+  0x60, 0x30, 0xc3, 0x10, 0x06, 0x82, 0x18, 0xcc, 0x10, 0x0c, 0x33, 0x0c,
+  0xdf, 0x37, 0x06, 0x33, 0x10, 0x44, 0x18, 0x84, 0xc1, 0x18, 0xcc, 0x10,
+  0x14, 0x33, 0x04, 0xc6, 0x0c, 0xc1, 0x31, 0x43, 0x81, 0x8c, 0xc1, 0x18,
+  0x24, 0xca, 0x0c, 0x81, 0x1b, 0xcc, 0x80, 0x8c, 0xc1, 0xc2, 0x34, 0x89,
+  0xe2, 0x3c, 0x33, 0x24, 0x61, 0x00, 0x45, 0x8c, 0x94, 0x28, 0xce, 0x34,
+  0x43, 0xf2, 0x41, 0x14, 0x23, 0x25, 0x95, 0x63, 0xcd, 0xa0, 0x94, 0xc1,
+  0x85, 0x8d, 0x41, 0x18, 0x64, 0x89, 0xe6, 0x6c, 0x33, 0x24, 0x62, 0xc0,
+  0x61, 0x63, 0x10, 0x06, 0x49, 0xe7, 0x78, 0x33, 0x14, 0x70, 0x10, 0x07,
+  0x72, 0x30, 0x07, 0x74, 0x30, 0xc3, 0x40, 0x06, 0x6f, 0x50, 0x07, 0x32,
+  0x12, 0x98, 0xa0, 0x8b, 0xd8, 0xd8, 0xec, 0xda, 0x5c, 0xda, 0xde, 0xc8,
+  0xea, 0xd8, 0xca, 0x5c, 0xcc, 0xd8, 0xc2, 0xce, 0xe6, 0x46, 0x11, 0xca,
+  0xc0, 0x0c, 0x4e, 0x61, 0x63, 0xb3, 0x6b, 0x73, 0x49, 0x23, 0x2b, 0x73,
+  0xa3, 0x1b, 0x25, 0x38, 0x83, 0x5b, 0xc2, 0xd2, 0xe4, 0x5c, 0xec, 0xca,
+  0xe4, 0xe6, 0xd2, 0xde, 0xdc, 0x46, 0x09, 0xd0, 0xe0, 0xa8, 0xb0, 0x34,
+  0x39, 0x17, 0xb6, 0x30, 0xb7, 0xb3, 0xba, 0xb0, 0xb3, 0xb2, 0x2f, 0xbb,
+  0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x51, 0x82, 0x34, 0xb8, 0x29, 0x2c,
+  0x4d, 0xce, 0x65, 0xec, 0xad, 0x0d, 0x2e, 0x8d, 0xad, 0xec, 0xeb, 0x0d,
+  0x8e, 0x2e, 0xed, 0xcd, 0x6d, 0x6e, 0x94, 0x41, 0x0d, 0xd6, 0x80, 0x0d,
+  0x8e, 0x09, 0x4b, 0x93, 0x73, 0x31, 0x93, 0x0b, 0x3b, 0x6b, 0x2b, 0x73,
+  0xa3, 0x1b, 0x25, 0xa8, 0x03, 0x00, 0x00, 0x00, 0xa9, 0x18, 0x00, 0x00,
+  0x0b, 0x00, 0x00, 0x00, 0x0b, 0x0a, 0x72, 0x28, 0x87, 0x77, 0x80, 0x07,
+  0x7a, 0x58, 0x70, 0x98, 0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb0, 0x43, 0x39,
+  0xd0, 0xc3, 0x82, 0xe6, 0x1c, 0xc6, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2,
+  0xc1, 0x1d, 0xe6, 0x21, 0x1d, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x00,
+  0xd1, 0x10, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0xcc, 0x3c, 0xa4,
+  0x83, 0x3b, 0x9c, 0x03, 0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83, 0x3c, 0x94,
+  0x43, 0x38, 0x90, 0xc3, 0x01, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00,
+  0x0c, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0xb4, 0x6a, 0x60, 0x04, 0x80, 0xda, 0x08, 0x00,
+  0x81, 0x11, 0x00, 0x00, 0x23, 0x06, 0x8d, 0x10, 0x82, 0x60, 0xe0, 0x40,
+  0x46, 0x71, 0x10, 0xc2, 0x10, 0x04, 0xcc, 0x68, 0x42, 0x00, 0x58, 0xa0,
+  0x88, 0x7f, 0x06, 0x00, 0x71, 0x20, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x32, 0x0e, 0x10, 0x22, 0x84, 0x00, 0x97, 0x05, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x65, 0x0c, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00,
+  0x12, 0x03, 0x94, 0x20, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x2c, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x50, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+  0x00, 0x24, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00,
+  0x11, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+  0x08, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5d, 0x0c, 0x00, 0x00,
+  0x19, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0xb6, 0x00, 0x00, 0x00, 0x00,
+  0x53, 0x44, 0x4c, 0x5f, 0x43, 0x6f, 0x70, 0x79, 0x5f, 0x66, 0x72, 0x61,
+  0x67, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d,
+  0x70, 0x6c, 0x65, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x5f,
+  0x32, 0x64, 0x2e, 0x76, 0x34, 0x66, 0x33, 0x32, 0x33, 0x31, 0x30, 0x30,
+  0x31, 0x2e, 0x35, 0x30, 0x2e, 0x31, 0x61, 0x69, 0x72, 0x36, 0x34, 0x2d,
   0x61, 0x70, 0x70, 0x6c, 0x65, 0x2d, 0x74, 0x76, 0x6f, 0x73, 0x31, 0x33,
   0x2e, 0x30, 0x2e, 0x30, 0x2d, 0x73, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74,
-  0x6f, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00,
-  0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x28, 0x0f, 0x00, 0x00, 0xff, 0xff,
-  0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x35, 0x14, 0x00, 0x00, 0x03, 0x00,
-  0x00, 0x00, 0x62, 0x0c, 0x30, 0x24, 0x80, 0x10, 0x05, 0xc8, 0x14, 0x00,
-  0x00, 0x00, 0x21, 0x0c, 0x00, 0x00, 0x6b, 0x03, 0x00, 0x00, 0x0b, 0x02,
-  0x21, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x07, 0x81,
-  0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01,
-  0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x18,
-  0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xc4, 0x10, 0x32, 0x14, 0x38, 0x08,
-  0x18, 0x4b, 0x0a, 0x32, 0x62, 0x88, 0x48, 0x90, 0x14, 0x20, 0x43, 0x46,
-  0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0x04, 0x49, 0x0e, 0x90, 0x11, 0x23,
-  0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x31,
-  0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x93, 0x00, 0x00, 0x00, 0x1b, 0xcc,
-  0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x58, 0x03, 0x40, 0x02, 0x2a,
-  0x62, 0x1c, 0xde, 0x41, 0x1e, 0xe4, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xd8,
-  0x21, 0x1f, 0xda, 0x40, 0x1e, 0xde, 0xa1, 0x1e, 0xdc, 0x81, 0x1c, 0xca,
-  0x81, 0x1c, 0xda, 0x80, 0x1c, 0xd2, 0xc1, 0x1e, 0xd2, 0x81, 0x1c, 0xca,
-  0xa1, 0x0d, 0xe6, 0x21, 0x1e, 0xe4, 0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xe0,
-  0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x73, 0x08, 0x07,
-  0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x72, 0x48, 0x87, 0x79, 0x08, 0x07,
-  0x71, 0x60, 0x87, 0x72, 0x68, 0x03, 0x7a, 0x08, 0x87, 0x74, 0x60, 0x87,
-  0x36, 0x18, 0x87, 0x70, 0x60, 0x07, 0x76, 0x98, 0x07, 0xc0, 0x1c, 0xc2,
-  0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1d, 0xca, 0x61, 0x1e, 0xe6,
-  0xa1, 0x0d, 0xe0, 0x41, 0x1e, 0xca, 0x61, 0x1c, 0xd2, 0x61, 0x1e, 0xca,
-  0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0x21, 0x1c, 0xc8, 0x01, 0x30, 0x87,
-  0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03,
-  0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78, 0x78, 0x87,
-  0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72, 0x60, 0x87,
-  0x74, 0x68, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x18, 0xdc,
-  0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda,
-  0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda,
-  0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0xa1, 0x0d, 0xdc, 0xe1, 0x1d, 0xdc,
-  0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xc2, 0xc1, 0x1c, 0x00, 0xc2, 0x1d, 0xde,
-  0xa1, 0x0d, 0xd2, 0xc1, 0x1d, 0xcc, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0,
-  0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87,
-  0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x75, 0xa8, 0x87,
-  0x76, 0x80, 0x87, 0x36, 0xa0, 0x87, 0x70, 0x10, 0x07, 0x76, 0x28, 0x87,
-  0x79, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc,
-  0xe1, 0x1d, 0xda, 0xc0, 0x1d, 0xc2, 0xc1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc,
-  0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07,
-  0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x98, 0x87,
-  0x74, 0x38, 0x07, 0x77, 0x28, 0x07, 0x72, 0x68, 0x03, 0x7d, 0x28, 0x07,
-  0x79, 0x78, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87,
-  0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00,
-  0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0x01, 0x1e, 0xe0,
-  0x21, 0x1d, 0xdc, 0xe1, 0x1c, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0,
-  0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x88, 0x79, 0xa0, 0x87,
-  0x70, 0x18, 0x87, 0x75, 0x68, 0x03, 0x78, 0x90, 0x87, 0x77, 0xa0, 0x87,
-  0x72, 0x18, 0x07, 0x7a, 0x78, 0x07, 0x79, 0x68, 0x03, 0x71, 0xa8, 0x07,
-  0x73, 0x30, 0x87, 0x72, 0x90, 0x87, 0x36, 0x98, 0x87, 0x74, 0xd0, 0x87,
-  0x72, 0x00, 0xf0, 0x00, 0x20, 0xea, 0xc1, 0x1d, 0xe6, 0x21, 0x1c, 0xcc,
-  0xa1, 0x1c, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8,
-  0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0xa8, 0x87,
-  0x79, 0x28, 0x87, 0x36, 0x98, 0x87, 0x77, 0x30, 0x07, 0x7a, 0x68, 0x03,
-  0x73, 0x60, 0x87, 0x77, 0x08, 0x07, 0x7a, 0x00, 0xcc, 0x21, 0x1c, 0xd8,
-  0x61, 0x1e, 0xca, 0x01, 0xd8, 0xb0, 0x08, 0x03, 0x90, 0x00, 0x0b, 0x50,
-  0x05, 0x69, 0x00, 0x6d, 0x58, 0x06, 0x02, 0x48, 0x80, 0x05, 0xa8, 0x82,
-  0x34, 0x00, 0x85, 0x0d, 0x06, 0x51, 0x00, 0x0b, 0x50, 0x6d, 0x30, 0x8a,
-  0x03, 0x58, 0x80, 0x6a, 0x83, 0x61, 0xfc, 0xff, 0xff, 0xff, 0xff, 0x00,
-  0x48, 0x00, 0xb5, 0x41, 0x39, 0xfe, 0xff, 0xff, 0xff, 0x7f, 0x00, 0xda,
-  0x00, 0x58, 0x03, 0x40, 0x02, 0xaa, 0x0d, 0x06, 0x12, 0x00, 0x0b, 0x50,
-  0x6d, 0x30, 0x12, 0x01, 0x58, 0x80, 0x0a, 0x00, 0x00, 0x00, 0x49, 0x18,
-  0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x13, 0x8a, 0x40, 0x18, 0x88, 0x62,
-  0x42, 0x60, 0x4c, 0x18, 0x0e, 0x24, 0x01, 0x00, 0x00, 0x00, 0x89, 0x20,
-  0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x32, 0x22, 0x88, 0x09, 0x20, 0x64,
-  0x85, 0x04, 0x13, 0x23, 0xa4, 0x84, 0x04, 0x13, 0x23, 0xe3, 0x84, 0xa1,
-  0x90, 0x14, 0x12, 0x4c, 0x8c, 0x8c, 0x0b, 0x84, 0xc4, 0x4c, 0x10, 0x84,
-  0xc1, 0x0c, 0xc0, 0x30, 0x02, 0x01, 0x0c, 0x23, 0x08, 0xc0, 0x20, 0x42,
-  0x10, 0x0c, 0x23, 0x0c, 0xc0, 0x41, 0xd2, 0x14, 0x51, 0xc2, 0xe4, 0xcb,
-  0xee, 0xdb, 0x11, 0x82, 0x33, 0x10, 0x88, 0x20, 0x08, 0x82, 0x18, 0x44,
-  0x28, 0x84, 0xa3, 0xa4, 0x29, 0xa2, 0x84, 0xc9, 0xff, 0x27, 0xe2, 0x9a,
-  0xa8, 0x88, 0xf8, 0xed, 0xe1, 0x9f, 0xc6, 0x08, 0x80, 0x41, 0x84, 0x23,
-  0x38, 0x4d, 0x9a, 0x22, 0x4a, 0x98, 0xfc, 0x7f, 0x22, 0xae, 0x89, 0x8a,
-  0x88, 0xdf, 0x1e, 0x7e, 0x20, 0x8a, 0x00, 0xec, 0x9f, 0xc6, 0x08, 0x80,
-  0x41, 0x84, 0x24, 0xb8, 0x48, 0x9a, 0x22, 0x4a, 0x98, 0xfc, 0x5f, 0x02,
-  0x98, 0x67, 0x21, 0xa2, 0x7f, 0x1a, 0x23, 0x00, 0x06, 0x11, 0x16, 0xa1,
-  0x20, 0x41, 0x20, 0x0c, 0x06, 0xa2, 0x30, 0xd4, 0x94, 0x01, 0x20, 0x08,
-  0x7a, 0xe6, 0x08, 0x10, 0x23, 0x04, 0xd1, 0x1c, 0x01, 0x18, 0xcc, 0x11,
-  0x04, 0xc3, 0x08, 0xc2, 0x54, 0x16, 0x49, 0x61, 0x84, 0x89, 0xaa, 0x28,
-  0x00, 0x98, 0xc8, 0x2a, 0x8a, 0x84, 0x30, 0x02, 0x55, 0x51, 0x00, 0x30,
-  0x11, 0x36, 0x10, 0x90, 0x02, 0xd3, 0x30, 0xc2, 0x30, 0xcd, 0x11, 0x80,
-  0xc2, 0x20, 0x42, 0x20, 0x0c, 0x22, 0x10, 0xc2, 0x08, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x13, 0xc0, 0x20, 0x1c, 0xd2, 0x41, 0x1e, 0xec, 0x80, 0x0e,
-  0xda, 0x20, 0x1c, 0xe0, 0x01, 0x1e, 0xd8, 0xa1, 0x1c, 0xda, 0x80, 0x1e,
-  0xec, 0xe1, 0x1d, 0xe6, 0x21, 0x0e, 0xe6, 0xc0, 0x0d, 0xe0, 0xc0, 0x0d,
-  0xe0, 0xa0, 0x0d, 0xe6, 0x21, 0x1d, 0xda, 0xa1, 0x1e, 0xd8, 0x21, 0x1c,
-  0xe8, 0xe1, 0x1d, 0xe4, 0x61, 0xc3, 0x6d, 0x94, 0x43, 0x1b, 0xc0, 0x83,
-  0x1e, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01,
-  0x1d, 0xb4, 0x41, 0x3a, 0xc4, 0x81, 0x1e, 0xe0, 0x81, 0x1e, 0xe0, 0x41,
-  0x1b, 0xa4, 0x03, 0x1e, 0xe8, 0x01, 0x1e, 0xe8, 0x01, 0x1e, 0xb4, 0x41,
-  0x3a, 0xc4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xd8, 0x81, 0x1e, 0xc4, 0x81,
-  0x1d, 0xb4, 0x41, 0x3a, 0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81,
-  0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x41, 0x3a, 0xd8, 0x01, 0x1d, 0xe8, 0x81,
-  0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x39, 0xcc, 0x81,
-  0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81,
-  0x39, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01,
-  0x1d, 0xb4, 0x81, 0x3d, 0xc4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xd8, 0x81,
-  0x1e, 0xc4, 0x81, 0x1d, 0xb4, 0x81, 0x3d, 0xc8, 0x01, 0x1d, 0xe8, 0xc1,
-  0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xcc, 0x81,
-  0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81,
-  0x3d, 0xd0, 0x01, 0x1e, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01,
-  0x1d, 0xb4, 0x81, 0x3d, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81,
-  0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xe4, 0x81, 0x1d, 0xe8, 0x41,
-  0x1c, 0xc8, 0x01, 0x1e, 0xe8, 0x41, 0x1c, 0xc8, 0x01, 0x1e, 0xb4, 0x81,
-  0x3d, 0xc4, 0x81, 0x1c, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1c, 0xe0, 0x81,
-  0x1e, 0xc4, 0x81, 0x1c, 0xe0, 0x41, 0x1b, 0xd8, 0x43, 0x1c, 0xe4, 0x81,
-  0x1c, 0xe8, 0x81, 0x1c, 0xd4, 0x81, 0x1d, 0xe8, 0x81, 0x1c, 0xd4, 0x81,
-  0x1d, 0xb4, 0x81, 0x3d, 0xc8, 0x41, 0x1d, 0xd8, 0x81, 0x1e, 0xc8, 0x41,
-  0x1d, 0xd8, 0x81, 0x1e, 0xc8, 0x41, 0x1d, 0xd8, 0x41, 0x1b, 0xd8, 0x43,
-  0x1d, 0xc4, 0x81, 0x1c, 0xe8, 0x41, 0x1d, 0xc4, 0x81, 0x1c, 0xe8, 0x41,
-  0x1d, 0xc4, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xc4, 0x01, 0x1c, 0xc8, 0x01,
-  0x1d, 0xe8, 0x41, 0x1c, 0xc0, 0x81, 0x1c, 0xd0, 0x81, 0x1e, 0xc4, 0x01,
-  0x1c, 0xc8, 0x01, 0x1d, 0xb4, 0x81, 0x3b, 0xe0, 0x81, 0x1e, 0xc4, 0x81,
-  0x1d, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x46, 0x08, 0x43, 0x42, 0x6c, 0x57,
-  0xfe, 0xb2, 0xfb, 0xfe, 0x45, 0x04, 0x18, 0x0c, 0xd1, 0x4c, 0x43, 0x22,
-  0x00, 0x6a, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
-  0x60, 0x48, 0x04, 0x35, 0x0f, 0x10, 0x00, 0x02, 0x00, 0x00, 0x80, 0x00,
-  0x00, 0x00, 0x00, 0x0c, 0x89, 0xba, 0x30, 0xb0, 0x80, 0x00, 0x18, 0x00,
-  0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x60, 0x48, 0xe4, 0x07, 0x1b, 0x06,
-  0x04, 0xc0, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x12, 0x1b,
-  0x04, 0x8a, 0xb6, 0x0d, 0x00, 0x00, 0x64, 0x81, 0x00, 0x00, 0x0b, 0x00,
-  0x00, 0x00, 0x32, 0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09,
-  0x26, 0x47, 0xc6, 0x04, 0x43, 0x9a, 0x8a, 0xa0, 0x04, 0x0a, 0x61, 0x04,
-  0xa0, 0x40, 0xca, 0xa0, 0x00, 0x03, 0x0a, 0xa8, 0xc0, 0x4a, 0xa1, 0x18,
-  0xa8, 0x1b, 0x01, 0xa0, 0x6d, 0x2c, 0xc1, 0x11, 0x00, 0x00, 0xb1, 0x18,
-  0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1,
-  0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42,
-  0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f,
-  0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1,
-  0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84,
-  0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc,
-  0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70,
-  0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19,
-  0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f,
-  0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21,
-  0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc,
-  0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84,
-  0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37,
-  0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70,
-  0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77,
-  0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79,
-  0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e,
-  0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1,
-  0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81,
-  0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98,
-  0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88,
-  0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4,
-  0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72,
-  0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74,
-  0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e,
-  0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e,
-  0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21,
-  0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01,
-  0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc,
-  0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77,
-  0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e,
-  0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1,
-  0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61,
-  0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0,
-  0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0,
-  0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74,
-  0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e,
-  0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41,
-  0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50,
-  0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c,
-  0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc,
-  0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x79, 0x20, 0x00, 0x00, 0x0c, 0x01,
-  0x00, 0x00, 0x32, 0x9a, 0x08, 0x14, 0x02, 0x85, 0x8c, 0x27, 0x46, 0x46,
-  0xc8, 0x11, 0x32, 0x64, 0xd4, 0xd8, 0x80, 0x0c, 0xf2, 0x09, 0x8b, 0xe2,
-  0x06, 0xc5, 0xc6, 0x91, 0x41, 0x14, 0x19, 0x8c, 0x22, 0x31, 0x88, 0x94,
-  0x3d, 0x06, 0xa2, 0x3c, 0x12, 0x12, 0x5d, 0x03, 0x65, 0x18, 0x86, 0x61,
-  0x24, 0xc6, 0xa2, 0x60, 0x84, 0x57, 0x2c, 0x47, 0x00, 0x00, 0x53, 0x44,
-  0x4b, 0x20, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68,
-  0x61, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x41, 0x70, 0x70, 0x6c, 0x65,
-  0x20, 0x4c, 0x4c, 0x56, 0x4d, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f,
-  0x6e, 0x20, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x34, 0x33, 0x20, 0x28,
-  0x6d, 0x65, 0x74, 0x61, 0x6c, 0x66, 0x65, 0x2d, 0x33, 0x31, 0x30, 0x30,
-  0x31, 0x2e, 0x34, 0x33, 0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x61, 0x69,
+  0x6f, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b,
+  0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0xbc, 0x0e, 0x00, 0x00,
+  0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x35, 0x14, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x62, 0x0c, 0x30, 0x24, 0x80, 0x10, 0x05, 0xc8,
+  0x14, 0x00, 0x00, 0x00, 0x21, 0x0c, 0x00, 0x00, 0x50, 0x03, 0x00, 0x00,
+  0x0b, 0x02, 0x21, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+  0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39,
+  0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62,
+  0x80, 0x18, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xc4, 0x10, 0x32, 0x14,
+  0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x62, 0x88, 0x48, 0x90, 0x14, 0x20,
+  0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0x04, 0x49, 0x0e, 0x90,
+  0x11, 0x23, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a,
+  0x04, 0x31, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x90, 0x00, 0x00, 0x00,
+  0x1b, 0xcc, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x58, 0x03, 0x40,
+  0x02, 0x2a, 0x62, 0x1c, 0xde, 0x41, 0x1e, 0xe4, 0xa1, 0x1c, 0xc6, 0x81,
+  0x1e, 0xd8, 0x21, 0x1f, 0xda, 0x40, 0x1e, 0xde, 0xa1, 0x1e, 0xdc, 0x81,
+  0x1c, 0xca, 0x81, 0x1c, 0xda, 0x80, 0x1c, 0xd2, 0xc1, 0x1e, 0xd2, 0x81,
+  0x1c, 0xca, 0xa1, 0x0d, 0xe6, 0x21, 0x1e, 0xe4, 0x81, 0x1e, 0xda, 0xc0,
+  0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x73,
+  0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x72, 0x48, 0x87, 0x79,
+  0x08, 0x07, 0x71, 0x60, 0x87, 0x72, 0x68, 0x03, 0x7a, 0x08, 0x87, 0x74,
+  0x60, 0x87, 0x36, 0x18, 0x87, 0x70, 0x60, 0x07, 0x76, 0x98, 0x07, 0xc0,
+  0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1d, 0xca, 0x61,
+  0x1e, 0xe6, 0xa1, 0x0d, 0xe0, 0x41, 0x1e, 0xca, 0x61, 0x1c, 0xd2, 0x61,
+  0x1e, 0xca, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0x21, 0x1c, 0xc8, 0x01,
+  0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77,
+  0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78,
+  0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72,
+  0x60, 0x87, 0x74, 0x68, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01,
+  0x18, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1,
+  0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41,
+  0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0xa1, 0x0d, 0xdc, 0xe1,
+  0x1d, 0xdc, 0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xc2, 0xc1, 0x1c, 0x00, 0xc2,
+  0x1d, 0xde, 0xa1, 0x0d, 0xd2, 0xc1, 0x1d, 0xcc, 0x61, 0x1e, 0xda, 0xc0,
+  0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a,
+  0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x75,
+  0xa8, 0x87, 0x76, 0x80, 0x87, 0x36, 0xa0, 0x87, 0x70, 0x10, 0x07, 0x76,
+  0x28, 0x87, 0x79, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01,
+  0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1d, 0xc2, 0xc1, 0x1d, 0xe6, 0xa1,
+  0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01,
+  0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36,
+  0x98, 0x87, 0x74, 0x38, 0x07, 0x77, 0x28, 0x07, 0x72, 0x68, 0x03, 0x7d,
+  0x28, 0x07, 0x79, 0x78, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36,
+  0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1,
+  0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0x01,
+  0x1e, 0xe0, 0x21, 0x1d, 0xdc, 0xe1, 0x1c, 0xda, 0xa0, 0x1d, 0xc2, 0x81,
+  0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x88, 0x79,
+  0xa0, 0x87, 0x70, 0x18, 0x87, 0x75, 0x68, 0x03, 0x78, 0x90, 0x87, 0x77,
+  0xa0, 0x87, 0x72, 0x18, 0x07, 0x7a, 0x78, 0x07, 0x79, 0x68, 0x03, 0x71,
+  0xa8, 0x07, 0x73, 0x30, 0x87, 0x72, 0x90, 0x87, 0x36, 0x98, 0x87, 0x74,
+  0xd0, 0x87, 0x72, 0x00, 0xf0, 0x00, 0x20, 0xea, 0xc1, 0x1d, 0xe6, 0x21,
+  0x1c, 0xcc, 0xa1, 0x1c, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21,
+  0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80,
+  0xa8, 0x87, 0x79, 0x28, 0x87, 0x36, 0x98, 0x87, 0x77, 0x30, 0x07, 0x7a,
+  0x68, 0x03, 0x73, 0x60, 0x87, 0x77, 0x08, 0x07, 0x7a, 0x00, 0xcc, 0x21,
+  0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0xd8, 0xb0, 0x08, 0x04, 0x90, 0x00,
+  0x0b, 0x50, 0x05, 0x69, 0x00, 0x0a, 0x1b, 0x8c, 0xa1, 0x00, 0x16, 0xa0,
+  0xda, 0x60, 0x10, 0x07, 0xb0, 0x00, 0xd5, 0x06, 0xa3, 0xf8, 0xff, 0xff,
+  0xff, 0xff, 0x01, 0x90, 0x00, 0x6a, 0x83, 0x62, 0xfc, 0xff, 0xff, 0xff,
+  0xff, 0x00, 0xb4, 0x01, 0xb0, 0x06, 0x80, 0x04, 0x54, 0x1b, 0x8c, 0x23,
+  0x00, 0x16, 0xa0, 0xda, 0x60, 0x20, 0x02, 0xb0, 0x00, 0x15, 0x00, 0x00,
+  0x49, 0x18, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x13, 0x88, 0x40, 0x18,
+  0x88, 0x09, 0x41, 0x31, 0x61, 0x30, 0x0e, 0x04, 0x89, 0x20, 0x00, 0x00,
+  0x34, 0x00, 0x00, 0x00, 0x32, 0x22, 0x88, 0x09, 0x20, 0x64, 0x85, 0x04,
+  0x13, 0x23, 0xa4, 0x84, 0x04, 0x13, 0x23, 0xe3, 0x84, 0xa1, 0x90, 0x14,
+  0x12, 0x4c, 0x8c, 0x8c, 0x0b, 0x84, 0xc4, 0x4c, 0x10, 0x80, 0xc1, 0x0c,
+  0xc0, 0x30, 0x02, 0x01, 0x0c, 0x23, 0x08, 0xc0, 0x30, 0xc2, 0x00, 0x1c,
+  0x24, 0x4d, 0x11, 0x25, 0x4c, 0xbe, 0xec, 0xbe, 0x1d, 0x21, 0x38, 0x03,
+  0x81, 0x88, 0x61, 0x18, 0x86, 0x41, 0x04, 0x42, 0x38, 0x4a, 0x9a, 0x22,
+  0x4a, 0x98, 0xfc, 0x7f, 0x22, 0xae, 0x89, 0x8a, 0x88, 0xdf, 0x1e, 0xfe,
+  0x69, 0x8c, 0x00, 0x18, 0x44, 0x30, 0x82, 0xd3, 0xa4, 0x29, 0xa2, 0x84,
+  0xc9, 0xff, 0x27, 0xe2, 0x9a, 0xa8, 0x88, 0xf8, 0xed, 0xe1, 0x07, 0xa2,
+  0x08, 0xc0, 0xfe, 0x69, 0x8c, 0x00, 0x18, 0x44, 0x40, 0x82, 0x8b, 0xa4,
+  0x29, 0xa2, 0x84, 0xc9, 0xff, 0x25, 0x80, 0x79, 0x16, 0x22, 0xfa, 0xa7,
+  0x31, 0x02, 0x60, 0x10, 0x41, 0x11, 0x0a, 0x12, 0x04, 0x81, 0x50, 0x1c,
+  0xc9, 0x42, 0x4c, 0x19, 0x80, 0x61, 0x20, 0x67, 0x8e, 0x00, 0x31, 0x42,
+  0x00, 0xcd, 0x11, 0x80, 0xc1, 0x1c, 0x41, 0x30, 0x8c, 0x20, 0x48, 0x65,
+  0x89, 0x92, 0x45, 0x90, 0x26, 0x6a, 0x02, 0x00, 0x89, 0xaa, 0xa2, 0x44,
+  0xc7, 0x22, 0x4c, 0xd4, 0x04, 0x00, 0x12, 0x5d, 0x03, 0x01, 0x29, 0x20,
+  0x0d, 0x23, 0x0c, 0xd2, 0x1c, 0x01, 0x28, 0x0c, 0x22, 0x04, 0xc2, 0x20,
+  0xc2, 0x20, 0x8c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0xc0, 0x20, 0x1c,
+  0xd2, 0x41, 0x1e, 0xec, 0x80, 0x0e, 0xda, 0x20, 0x1c, 0xe0, 0x01, 0x1e,
+  0xd8, 0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xec, 0xe1, 0x1d, 0xe6, 0x21, 0x0e,
+  0xe6, 0xc0, 0x0d, 0xe0, 0xc0, 0x0d, 0xe0, 0xa0, 0x0d, 0xe6, 0x21, 0x1d,
+  0xda, 0xa1, 0x1e, 0xd8, 0x21, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0x61, 0xc3,
+  0x6d, 0x94, 0x43, 0x1b, 0xc0, 0x83, 0x1e, 0xd8, 0x01, 0x1d, 0xe8, 0x81,
+  0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x41, 0x3a, 0xc4, 0x81,
+  0x1e, 0xe0, 0x81, 0x1e, 0xe0, 0x41, 0x1b, 0xa4, 0x03, 0x1e, 0xe8, 0x01,
+  0x1e, 0xe8, 0x01, 0x1e, 0xb4, 0x41, 0x3a, 0xc4, 0x81, 0x1d, 0xe8, 0x41,
+  0x1c, 0xd8, 0x81, 0x1e, 0xc4, 0x81, 0x1d, 0xb4, 0x41, 0x3a, 0xcc, 0x81,
+  0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x41,
+  0x3a, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01,
+  0x1d, 0xb4, 0x81, 0x39, 0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81,
+  0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x39, 0xd8, 0x01, 0x1d, 0xe8, 0x81,
+  0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xc4, 0x81,
+  0x1d, 0xe8, 0x41, 0x1c, 0xd8, 0x81, 0x1e, 0xc4, 0x81, 0x1d, 0xb4, 0x81,
+  0x3d, 0xc8, 0x01, 0x1d, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81,
+  0x1c, 0xb4, 0x81, 0x3d, 0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81,
+  0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xd0, 0x01, 0x1e, 0xe8, 0x81,
+  0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xd8, 0x01,
+  0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81,
+  0x3d, 0xe4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xc8, 0x01, 0x1e, 0xe8, 0x41,
+  0x1c, 0xc8, 0x01, 0x1e, 0xb4, 0x81, 0x3d, 0xc4, 0x81, 0x1c, 0xe0, 0x81,
+  0x1e, 0xc4, 0x81, 0x1c, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1c, 0xe0, 0x41,
+  0x1b, 0xd8, 0x43, 0x1c, 0xe4, 0x81, 0x1c, 0xe8, 0x81, 0x1c, 0xd4, 0x81,
+  0x1d, 0xe8, 0x81, 0x1c, 0xd4, 0x81, 0x1d, 0xb4, 0x81, 0x3d, 0xc8, 0x41,
+  0x1d, 0xd8, 0x81, 0x1e, 0xc8, 0x41, 0x1d, 0xd8, 0x81, 0x1e, 0xc8, 0x41,
+  0x1d, 0xd8, 0x41, 0x1b, 0xd8, 0x43, 0x1d, 0xc4, 0x81, 0x1c, 0xe8, 0x41,
+  0x1d, 0xc4, 0x81, 0x1c, 0xe8, 0x41, 0x1d, 0xc4, 0x81, 0x1c, 0xb4, 0x81,
+  0x3d, 0xc4, 0x01, 0x1c, 0xc8, 0x01, 0x1d, 0xe8, 0x41, 0x1c, 0xc0, 0x81,
+  0x1c, 0xd0, 0x81, 0x1e, 0xc4, 0x01, 0x1c, 0xc8, 0x01, 0x1d, 0xb4, 0x81,
+  0x3b, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1d, 0xe8, 0xc1, 0x1c, 0xc8, 0x81,
+  0x46, 0x08, 0x43, 0x42, 0x6c, 0x57, 0xfe, 0xb2, 0xfb, 0xfe, 0x45, 0x04,
+  0x18, 0x0c, 0xd1, 0x4c, 0x43, 0x22, 0x00, 0x62, 0x00, 0x00, 0x08, 0x00,
+  0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x60, 0x48, 0x04, 0x35, 0x0e, 0x10,
+  0x00, 0x02, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x89, 0xba,
+  0x30, 0xa8, 0x80, 0x00, 0x18, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+  0x60, 0x48, 0xe4, 0x07, 0xdb, 0x05, 0x04, 0xc0, 0x00, 0x00, 0x00, 0x20,
+  0x00, 0x00, 0x00, 0x00, 0x12, 0x1b, 0x04, 0x8a, 0x4a, 0x0d, 0x00, 0x00,
+  0x64, 0x81, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x14,
+  0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x92,
+  0x8a, 0xa0, 0x04, 0x0a, 0x61, 0x04, 0xa0, 0x0c, 0x0a, 0x30, 0xa0, 0x40,
+  0x0a, 0xa8, 0xc0, 0x4a, 0xa1, 0x18, 0x48, 0x1b, 0x4b, 0x70, 0x06, 0x00,
+  0xb1, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c,
+  0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3,
+  0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6,
+  0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e,
+  0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43,
+  0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03,
+  0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48,
+  0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20,
+  0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e,
+  0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d,
+  0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89,
+  0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83,
+  0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68,
+  0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90,
+  0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78,
+  0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98,
+  0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5,
+  0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c,
+  0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c,
+  0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43,
+  0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43,
+  0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82,
+  0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58,
+  0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18,
+  0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2,
+  0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec,
+  0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e,
+  0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d,
+  0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83,
+  0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60,
+  0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0,
+  0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d,
+  0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d,
+  0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43,
+  0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3,
+  0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18,
+  0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3,
+  0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1,
+  0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e,
+  0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83,
+  0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83,
+  0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x79, 0x20, 0x00, 0x00,
+  0x10, 0x01, 0x00, 0x00, 0x32, 0x9a, 0x08, 0x14, 0x02, 0x85, 0x8c, 0x27,
+  0x46, 0x46, 0xc8, 0x11, 0x32, 0x64, 0xd4, 0xda, 0x80, 0x0c, 0x66, 0x0a,
+  0x8b, 0x02, 0x07, 0xc5, 0xc6, 0x91, 0x41, 0x14, 0x19, 0x8c, 0x22, 0x31,
+  0x88, 0x64, 0x3d, 0x45, 0x66, 0x20, 0xca, 0x23, 0x21, 0x94, 0x61, 0x18,
+  0x86, 0x11, 0x5d, 0x89, 0xb1, 0x28, 0x18, 0xe1, 0x15, 0xcb, 0x11, 0x00,
+  0x53, 0x44, 0x4b, 0x20, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x77,
+  0x63, 0x68, 0x61, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x41, 0x70, 0x70,
+  0x6c, 0x65, 0x20, 0x4c, 0x4c, 0x56, 0x4d, 0x20, 0x76, 0x65, 0x72, 0x73,
+  0x69, 0x6f, 0x6e, 0x20, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x35, 0x30,
+  0x20, 0x28, 0x6d, 0x65, 0x74, 0x61, 0x6c, 0x66, 0x65, 0x2d, 0x33, 0x31,
+  0x30, 0x30, 0x31, 0x2e, 0x35, 0x30, 0x2e, 0x31, 0x29, 0x4d, 0x65, 0x74,
+  0x61, 0x6c, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c,
+  0x65, 0x2e, 0x64, 0x65, 0x6e, 0x6f, 0x72, 0x6d, 0x73, 0x5f, 0x64, 0x69,
+  0x73, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d,
+  0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61,
+  0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72,
+  0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x72, 0x61,
+  0x6d, 0x65, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x66, 0x65, 0x74,
+  0x63, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72,
+  0x2e, 0x72, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x5f, 0x74, 0x61, 0x72, 0x67,
+  0x65, 0x74, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79,
+  0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74,
+  0x34, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f,
+  0x6e, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x61,
+  0x69, 0x72, 0x2e, 0x6e, 0x6f, 0x5f, 0x70, 0x65, 0x72, 0x73, 0x70, 0x65,
+  0x63, 0x74, 0x69, 0x76, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67,
+  0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f,
+  0x6e, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e,
+  0x74, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x67, 0x65, 0x6e, 0x65, 0x72,
+  0x61, 0x74, 0x65, 0x64, 0x28, 0x35, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44,
+  0x76, 0x34, 0x5f, 0x66, 0x29, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x65, 0x72,
+  0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x63, 0x6f, 0x6c, 0x6f,
+  0x72, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x38,
+  0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x44, 0x76, 0x32, 0x5f,
+  0x66, 0x29, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32, 0x74, 0x65, 0x78, 0x63,
+  0x6f, 0x6f, 0x72, 0x64, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66,
+  0x65, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72,
+  0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x6c, 0x6f, 0x63,
+  0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x61,
+  0x69, 0x72, 0x2e, 0x72, 0x65, 0x61, 0x64, 0x61, 0x69, 0x72, 0x2e, 0x73,
+  0x74, 0x72, 0x75, 0x63, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x69,
+  0x6e, 0x66, 0x6f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x6f, 0x66, 0x66,
+  0x73, 0x65, 0x74, 0x52, 0x63, 0x6f, 0x65, 0x66, 0x66, 0x47, 0x63, 0x6f,
+  0x65, 0x66, 0x66, 0x42, 0x63, 0x6f, 0x65, 0x66, 0x66, 0x61, 0x69, 0x72,
+  0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x73, 0x69,
+  0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79,
+  0x70, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69, 0x7a,
+  0x65, 0x59, 0x55, 0x56, 0x44, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x65,
+  0x63, 0x6f, 0x64, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x74, 0x65, 0x78, 0x74,
+  0x75, 0x72, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c,
+  0x65, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x32, 0x64, 0x3c, 0x66,
+  0x6c, 0x6f, 0x61, 0x74, 0x2c, 0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65,
+  0x3e, 0x74, 0x65, 0x78, 0x59, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65,
+  0x32, 0x64, 0x5f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3c, 0x66, 0x6c, 0x6f,
+  0x61, 0x74, 0x2c, 0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x3e, 0x74,
+  0x65, 0x78, 0x55, 0x56, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70,
+  0x6c, 0x65, 0x72, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73, 0x00,
+  0x44, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x82, 0x20, 0x11,
+  0x23, 0x08, 0xda, 0x33, 0x82, 0x20, 0x15, 0x23, 0x08, 0x92, 0x31, 0x82,
+  0x20, 0x1d, 0x23, 0x08, 0x0d, 0x30, 0x82, 0x20, 0x21, 0x23, 0x08, 0x52,
+  0x32, 0x82, 0x20, 0x29, 0x23, 0x08, 0xd2, 0x32, 0x82, 0x20, 0x31, 0x23,
+  0x08, 0x52, 0x33, 0x82, 0x20, 0x39, 0x33, 0x0c, 0x6e, 0x10, 0xbc, 0xc1,
+  0x0c, 0x03, 0x1c, 0x08, 0x71, 0x30, 0x43, 0x30, 0xcc, 0x30, 0xb8, 0x81,
+  0x1b, 0xc8, 0xc1, 0x0c, 0x04, 0x01, 0x07, 0x70, 0x20, 0x07, 0x33, 0x04,
+  0xc5, 0x0c, 0x81, 0x31, 0x43, 0x70, 0xcc, 0x50, 0x20, 0x72, 0x20, 0x07,
+  0x89, 0x32, 0x43, 0x30, 0x0a, 0x33, 0x20, 0x72, 0xb0, 0x30, 0x4d, 0xa2,
+  0x38, 0xcf, 0x0c, 0x09, 0x1c, 0x40, 0x11, 0x23, 0x25, 0x8a, 0x33, 0xcd,
+  0x90, 0xb8, 0x01, 0x44, 0x31, 0x52, 0x52, 0x39, 0xd6, 0x0c, 0x94, 0x1c,
+  0xd8, 0x81, 0x1c, 0x70, 0x9d, 0x1d, 0xd8, 0x81, 0x1c, 0x70, 0xde, 0x1d,
+  0xd8, 0x81, 0x1c, 0x70, 0x1f, 0x1e, 0xd8, 0x81, 0x1c, 0x70, 0x60, 0x30,
+  0x83, 0x44, 0x07, 0x17, 0x56, 0x07, 0x19, 0x1c, 0xc0, 0x81, 0xb6, 0xa1,
+  0x42, 0x18, 0xd4, 0x81, 0x18, 0xd8, 0x41, 0x32, 0x06, 0x0e, 0x19, 0xcc,
+  0xa0, 0xc4, 0x41, 0x19, 0x64, 0x72, 0x00, 0x07, 0x66, 0x90, 0x9c, 0x81,
+  0x83, 0x06, 0x33, 0x28, 0x79, 0x50, 0x06, 0x19, 0x1c, 0xc0, 0x81, 0x19,
+  0x24, 0x69, 0xe0, 0xa8, 0xc1, 0x0c, 0x89, 0x1e, 0xac, 0x41, 0x26, 0x07,
+  0x70, 0x90, 0xb0, 0x81, 0xd3, 0x06, 0x33, 0x1c, 0xa5, 0x60, 0x0a, 0xa7,
+  0x90, 0x0a, 0xaa, 0xb0, 0x0a, 0xac, 0x30, 0xc3, 0x30, 0x07, 0xa4, 0xd0,
+  0x0a, 0x15, 0x06, 0x00, 0xc7, 0x71, 0x1c, 0xc7, 0x71, 0x1c, 0xc7, 0x71,
+  0x1c, 0xe7, 0x06, 0x6e, 0x60, 0xd1, 0x81, 0x1e, 0x58, 0x96, 0xa5, 0x07,
+  0x9c, 0x29, 0xb0, 0x02, 0x2b, 0xd8, 0x86, 0x5f, 0xd8, 0x83, 0x3d, 0xa8,
+  0x03, 0x39, 0xc8, 0x48, 0x60, 0x82, 0x2e, 0x62, 0x63, 0xb3, 0x6b, 0x73,
+  0x69, 0x7b, 0x23, 0xab, 0x63, 0x2b, 0x73, 0x31, 0x63, 0x0b, 0x3b, 0x9b,
+  0x1b, 0x45, 0xd0, 0x83, 0x3d, 0x38, 0x85, 0x8d, 0xcd, 0xae, 0xcd, 0x25,
+  0x8d, 0xac, 0xcc, 0x8d, 0x6e, 0x94, 0x80, 0x0f, 0x6e, 0x09, 0x4b, 0x93,
+  0x73, 0xb1, 0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73, 0x1b, 0x25, 0xe8, 0x83,
+  0xa3, 0xc2, 0xd2, 0xe4, 0x5c, 0xd8, 0xc2, 0xdc, 0xce, 0xea, 0xc2, 0xce,
+  0xca, 0xbe, 0xec, 0xca, 0xe4, 0xe6, 0xd2, 0xde, 0xdc, 0x46, 0x09, 0xfc,
+  0xe0, 0xa6, 0xb0, 0x34, 0x39, 0x97, 0xb1, 0xb7, 0x36, 0xb8, 0x34, 0xb6,
+  0xb2, 0xaf, 0x37, 0x38, 0xba, 0xb4, 0x37, 0xb7, 0xb9, 0x51, 0x86, 0x3f,
+  0x00, 0x85, 0x50, 0x38, 0x26, 0x2c, 0x4d, 0xce, 0xc5, 0x4c, 0x2e, 0xec,
+  0xac, 0xad, 0xcc, 0x8d, 0x6e, 0x94, 0xa0, 0x15, 0x00, 0x00, 0x00, 0x00,
+  0xa9, 0x18, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x0a, 0x72, 0x28,
+  0x87, 0x77, 0x80, 0x07, 0x7a, 0x58, 0x70, 0x98, 0x43, 0x3d, 0xb8, 0xc3,
+  0x38, 0xb0, 0x43, 0x39, 0xd0, 0xc3, 0x82, 0xe6, 0x1c, 0xc6, 0xa1, 0x0d,
+  0xe8, 0x41, 0x1e, 0xc2, 0xc1, 0x1d, 0xe6, 0x21, 0x1d, 0xe8, 0x21, 0x1d,
+  0xde, 0xc1, 0x1d, 0x00, 0xd1, 0x10, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+  0x07, 0xcc, 0x3c, 0xa4, 0x83, 0x3b, 0x9c, 0x03, 0x3b, 0x94, 0x03, 0x3d,
+  0xa0, 0x83, 0x3c, 0x94, 0x43, 0x38, 0x90, 0xc3, 0x01, 0x00, 0x00, 0x00,
+  0x61, 0x20, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c,
+  0x10, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x24, 0xcd, 0x00, 0xd0,
+  0x54, 0x03, 0x23, 0x00, 0x44, 0x8d, 0x00, 0xd0, 0x36, 0xd6, 0x00, 0x04,
+  0xc2, 0x1c, 0xc3, 0x71, 0x5d, 0xc4, 0x8d, 0x00, 0x94, 0x40, 0x11, 0x10,
+  0x30, 0x02, 0x30, 0x03, 0x30, 0x46, 0x00, 0x82, 0x20, 0x88, 0x7f, 0x14,
+  0xcc, 0x00, 0xcc, 0x41, 0x84, 0x41, 0x18, 0x84, 0x81, 0x18, 0x00, 0x00,
+  0x23, 0x06, 0xcd, 0x10, 0x82, 0x60, 0x70, 0x89, 0x41, 0xf4, 0x4c, 0xcd,
+  0xc2, 0x14, 0x85, 0x37, 0x9a, 0x10, 0x00, 0x83, 0x0c, 0x01, 0xb1, 0x8c,
+  0x18, 0x38, 0x43, 0x08, 0x82, 0x41, 0x65, 0x06, 0x93, 0x64, 0x85, 0x01,
+  0xe4, 0x3c, 0x08, 0x12, 0x06, 0xa3, 0x09, 0x01, 0x30, 0x86, 0x10, 0x34,
+  0x73, 0x0c, 0x44, 0xd0, 0x8c, 0x18, 0x38, 0x43, 0x08, 0x82, 0x41, 0xa5,
+  0x06, 0x97, 0xa5, 0x9d, 0x01, 0x25, 0x4d, 0x0c, 0x53, 0x06, 0xa3, 0x09,
+  0x01, 0x30, 0x86, 0x10, 0x44, 0x73, 0x0c, 0x44, 0x00, 0x5d, 0xd7, 0x2d,
+  0x05, 0x41, 0x19, 0x64, 0x08, 0x9e, 0xcb, 0x88, 0x00, 0xfc, 0x37, 0x31,
+  0x84, 0xc1, 0xf5, 0x06, 0x17, 0x74, 0x4b, 0x41, 0x50, 0x06, 0x19, 0x02,
+  0x8a, 0x1b, 0x31, 0x38, 0x84, 0x10, 0x04, 0x0b, 0xff, 0x70, 0xee, 0xa0,
+  0x08, 0x36, 0x31, 0x98, 0x01, 0x57, 0x07, 0x17, 0x74, 0x4b, 0x41, 0x50,
+  0x06, 0x19, 0x82, 0x2c, 0x0c, 0x46, 0x0c, 0x0e, 0x21, 0x04, 0xc1, 0xc2,
+  0x3f, 0x1c, 0x3e, 0x50, 0x82, 0x4d, 0x0c, 0x6b, 0x10, 0x06, 0x76, 0x70,
+  0x41, 0xb7, 0x14, 0x04, 0x65, 0x90, 0x21, 0xf0, 0xcc, 0x60, 0xc4, 0xe0,
+  0x10, 0x42, 0x10, 0x2c, 0xfc, 0xc3, 0x09, 0x85, 0x27, 0x98, 0x63, 0xf8,
+  0x16, 0x3e, 0x98, 0x63, 0x08, 0x8e, 0x3f, 0x98, 0x63, 0x08, 0x86, 0x50,
+  0xb0, 0xa0, 0x0e, 0xc4, 0x3f, 0x03, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x32, 0x0e, 0x10, 0x22, 0x84, 0x00, 0x8e, 0x06,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x0c, 0x00, 0x00,
+  0x2f, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0x70, 0x01, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x59, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+  0x44, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+  0xb0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, 0x00, 0x00, 0x00,
+  0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+  0x83, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+  0xff, 0xff, 0xff, 0xff, 0x00, 0x24, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+  0x0d, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00,
+  0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00,
+  0x21, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00,
+  0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00,
+  0x1b, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00,
+  0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x5d, 0x0c, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0x23,
+  0x01, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x59, 0x55, 0x56, 0x5f,
+  0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x69, 0x72, 0x2e,
+  0x64, 0x6f, 0x74, 0x2e, 0x76, 0x33, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72,
+  0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x74, 0x65, 0x78, 0x74,
+  0x75, 0x72, 0x65, 0x5f, 0x32, 0x64, 0x5f, 0x61, 0x72, 0x72, 0x61, 0x79,
+  0x2e, 0x76, 0x34, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x61,
+  0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65,
+  0x5f, 0x32, 0x64, 0x2e, 0x76, 0x34, 0x66, 0x33, 0x32, 0x33, 0x31, 0x30,
+  0x30, 0x31, 0x2e, 0x35, 0x30, 0x2e, 0x31, 0x61, 0x69, 0x72, 0x36, 0x34,
+  0x2d, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2d, 0x74, 0x76, 0x6f, 0x73, 0x31,
+  0x33, 0x2e, 0x30, 0x2e, 0x30, 0x2d, 0x73, 0x69, 0x6d, 0x75, 0x6c, 0x61,
+  0x74, 0x6f, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b,
+  0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x1c, 0x0e, 0x00, 0x00,
+  0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x35, 0x14, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x62, 0x0c, 0x30, 0x24, 0x80, 0x10, 0x05, 0xc8,
+  0x14, 0x00, 0x00, 0x00, 0x21, 0x0c, 0x00, 0x00, 0x36, 0x03, 0x00, 0x00,
+  0x0b, 0x02, 0x21, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+  0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39,
+  0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62,
+  0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14,
+  0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88, 0x48, 0x90, 0x14, 0x20,
+  0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0x04, 0x49, 0x0e, 0x90,
+  0x91, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a,
+  0x04, 0x29, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x92, 0x00, 0x00, 0x00,
+  0x1b, 0xcc, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x58, 0x03, 0x40,
+  0x02, 0x2a, 0x62, 0x1c, 0xde, 0x41, 0x1e, 0xe4, 0xa1, 0x1c, 0xc6, 0x81,
+  0x1e, 0xd8, 0x21, 0x1f, 0xda, 0x40, 0x1e, 0xde, 0xa1, 0x1e, 0xdc, 0x81,
+  0x1c, 0xca, 0x81, 0x1c, 0xda, 0x80, 0x1c, 0xd2, 0xc1, 0x1e, 0xd2, 0x81,
+  0x1c, 0xca, 0xa1, 0x0d, 0xe6, 0x21, 0x1e, 0xe4, 0x81, 0x1e, 0xda, 0xc0,
+  0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x73,
+  0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x72, 0x48, 0x87, 0x79,
+  0x08, 0x07, 0x71, 0x60, 0x87, 0x72, 0x68, 0x03, 0x7a, 0x08, 0x87, 0x74,
+  0x60, 0x87, 0x36, 0x18, 0x87, 0x70, 0x60, 0x07, 0x76, 0x98, 0x07, 0xc0,
+  0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1d, 0xca, 0x61,
+  0x1e, 0xe6, 0xa1, 0x0d, 0xe0, 0x41, 0x1e, 0xca, 0x61, 0x1c, 0xd2, 0x61,
+  0x1e, 0xca, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0x21, 0x1c, 0xc8, 0x01,
+  0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77,
+  0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78,
+  0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72,
+  0x60, 0x87, 0x74, 0x68, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01,
+  0x18, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1,
+  0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41,
+  0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0xa1, 0x0d, 0xdc, 0xe1,
+  0x1d, 0xdc, 0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xc2, 0xc1, 0x1c, 0x00, 0xc2,
+  0x1d, 0xde, 0xa1, 0x0d, 0xd2, 0xc1, 0x1d, 0xcc, 0x61, 0x1e, 0xda, 0xc0,
+  0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a,
+  0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x75,
+  0xa8, 0x87, 0x76, 0x80, 0x87, 0x36, 0xa0, 0x87, 0x70, 0x10, 0x07, 0x76,
+  0x28, 0x87, 0x79, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01,
+  0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1d, 0xc2, 0xc1, 0x1d, 0xe6, 0xa1,
+  0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01,
+  0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36,
+  0x98, 0x87, 0x74, 0x38, 0x07, 0x77, 0x28, 0x07, 0x72, 0x68, 0x03, 0x7d,
+  0x28, 0x07, 0x79, 0x78, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36,
+  0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1,
+  0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0x01,
+  0x1e, 0xe0, 0x21, 0x1d, 0xdc, 0xe1, 0x1c, 0xda, 0xa0, 0x1d, 0xc2, 0x81,
+  0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x88, 0x79,
+  0xa0, 0x87, 0x70, 0x18, 0x87, 0x75, 0x68, 0x03, 0x78, 0x90, 0x87, 0x77,
+  0xa0, 0x87, 0x72, 0x18, 0x07, 0x7a, 0x78, 0x07, 0x79, 0x68, 0x03, 0x71,
+  0xa8, 0x07, 0x73, 0x30, 0x87, 0x72, 0x90, 0x87, 0x36, 0x98, 0x87, 0x74,
+  0xd0, 0x87, 0x72, 0x00, 0xf0, 0x00, 0x20, 0xea, 0xc1, 0x1d, 0xe6, 0x21,
+  0x1c, 0xcc, 0xa1, 0x1c, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21,
+  0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80,
+  0xa8, 0x87, 0x79, 0x28, 0x87, 0x36, 0x98, 0x87, 0x77, 0x30, 0x07, 0x7a,
+  0x68, 0x03, 0x73, 0x60, 0x87, 0x77, 0x08, 0x07, 0x7a, 0x00, 0xcc, 0x21,
+  0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0xd8, 0xb0, 0x08, 0x04, 0x90, 0x00,
+  0x0b, 0x50, 0x05, 0x69, 0x00, 0x0a, 0x1b, 0x8c, 0xa1, 0x00, 0x16, 0xa0,
+  0xda, 0x60, 0x10, 0x06, 0xb0, 0x00, 0xd5, 0x06, 0xa3, 0x38, 0x80, 0x05,
+  0xa8, 0x36, 0x18, 0xc6, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x80, 0x04, 0x50,
+  0x1b, 0x94, 0xe3, 0xff, 0xff, 0xff, 0xff, 0x07, 0xa0, 0x0d, 0x80, 0x35,
+  0x00, 0x24, 0xa0, 0xda, 0x60, 0x20, 0x01, 0xb0, 0x00, 0xd5, 0x06, 0x23,
+  0x11, 0x80, 0x05, 0xa8, 0x00, 0x00, 0x00, 0x00, 0x49, 0x18, 0x00, 0x00,
+  0x04, 0x00, 0x00, 0x00, 0x13, 0x8a, 0x40, 0x18, 0x88, 0x62, 0x42, 0x60,
+  0x4c, 0x18, 0x0e, 0x24, 0x01, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00,
+  0x29, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04,
+  0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14,
+  0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x70, 0x33, 0x00,
+  0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00, 0xc3, 0x08, 0x03, 0x70, 0x90,
+  0x34, 0x45, 0x94, 0x30, 0xf9, 0xb2, 0xfb, 0x76, 0x84, 0xe0, 0x0c, 0x04,
+  0x22, 0xc6, 0x18, 0x63, 0x10, 0x81, 0x10, 0x8e, 0x92, 0xa6, 0x88, 0x12,
+  0x26, 0xff, 0x9f, 0x88, 0x6b, 0xa2, 0x22, 0xe2, 0xb7, 0x87, 0x7f, 0x1a,
+  0x23, 0x00, 0x06, 0x11, 0x8c, 0xe0, 0x22, 0x69, 0x8a, 0x28, 0x61, 0xf2,
+  0x7f, 0x09, 0x60, 0x9e, 0x85, 0x88, 0xfe, 0x69, 0x8c, 0x00, 0x18, 0x44,
+  0x40, 0x84, 0x82, 0x84, 0x10, 0x44, 0x39, 0x27, 0x91, 0x2a, 0x03, 0x18,
+  0x83, 0xd8, 0x1c, 0x01, 0x62, 0x84, 0xe0, 0xe6, 0x08, 0x82, 0x39, 0x02,
+  0x30, 0x18, 0x46, 0x10, 0xa2, 0xa2, 0xbc, 0x93, 0x04, 0x94, 0x10, 0x80,
+  0x48, 0x73, 0x20, 0x20, 0x05, 0xe2, 0x30, 0xc2, 0x10, 0x0d, 0x22, 0x04,
+  0xc2, 0x1c, 0x01, 0x28, 0x0c, 0x22, 0x0c, 0xc2, 0x08, 0x00, 0x00, 0x00,
+  0x13, 0xc0, 0x20, 0x1c, 0xd2, 0x41, 0x1e, 0xec, 0x80, 0x0e, 0xda, 0x20,
+  0x1c, 0xe0, 0x01, 0x1e, 0xd8, 0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xec, 0xe1,
+  0x1d, 0xe6, 0x21, 0x0e, 0xe6, 0xc0, 0x0d, 0xe0, 0xc0, 0x0d, 0xe0, 0xa0,
+  0x0d, 0xe6, 0x21, 0x1d, 0xda, 0xa1, 0x1e, 0xd8, 0x21, 0x1c, 0xe8, 0xe1,
+  0x1d, 0xe4, 0x61, 0xc3, 0x6d, 0x94, 0x43, 0x1b, 0xc0, 0x83, 0x1e, 0xd8,
+  0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4,
+  0x41, 0x3a, 0xc4, 0x81, 0x1e, 0xe0, 0x81, 0x1e, 0xe0, 0x41, 0x1b, 0xa4,
+  0x03, 0x1e, 0xe8, 0x01, 0x1e, 0xe8, 0x01, 0x1e, 0xb4, 0x41, 0x3a, 0xc4,
+  0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xd8, 0x81, 0x1e, 0xc4, 0x81, 0x1d, 0xb4,
+  0x41, 0x3a, 0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc,
+  0x81, 0x1c, 0xb4, 0x41, 0x3a, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0,
+  0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x39, 0xcc, 0x81, 0x1c, 0xe8,
+  0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x39, 0xd8,
+  0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4,
+  0x81, 0x3d, 0xc4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xd8, 0x81, 0x1e, 0xc4,
+  0x81, 0x1d, 0xb4, 0x81, 0x3d, 0xc8, 0x01, 0x1d, 0xe8, 0xc1, 0x1c, 0xc8,
+  0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xcc, 0x81, 0x1c, 0xe8,
+  0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xd0,
+  0x01, 0x1e, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4,
+  0x81, 0x3d, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8,
+  0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xe4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xc8,
+  0x01, 0x1e, 0xe8, 0x41, 0x1c, 0xc8, 0x01, 0x1e, 0xb4, 0x81, 0x3d, 0xc4,
+  0x81, 0x1c, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1c, 0xe0, 0x81, 0x1e, 0xc4,
+  0x81, 0x1c, 0xe0, 0x41, 0x1b, 0xd8, 0x43, 0x1c, 0xe4, 0x81, 0x1c, 0xe8,
+  0x81, 0x1c, 0xd4, 0x81, 0x1d, 0xe8, 0x81, 0x1c, 0xd4, 0x81, 0x1d, 0xb4,
+  0x81, 0x3d, 0xc8, 0x41, 0x1d, 0xd8, 0x81, 0x1e, 0xc8, 0x41, 0x1d, 0xd8,
+  0x81, 0x1e, 0xc8, 0x41, 0x1d, 0xd8, 0x41, 0x1b, 0xd8, 0x43, 0x1d, 0xc4,
+  0x81, 0x1c, 0xe8, 0x41, 0x1d, 0xc4, 0x81, 0x1c, 0xe8, 0x41, 0x1d, 0xc4,
+  0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xc4, 0x01, 0x1c, 0xc8, 0x01, 0x1d, 0xe8,
+  0x41, 0x1c, 0xc0, 0x81, 0x1c, 0xd0, 0x81, 0x1e, 0xc4, 0x01, 0x1c, 0xc8,
+  0x01, 0x1d, 0xb4, 0x81, 0x3b, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1d, 0xe8,
+  0xc1, 0x1c, 0xc8, 0x81, 0x46, 0x08, 0x43, 0x46, 0x6c, 0x57, 0xfe, 0xe7,
+  0x5b, 0xdb, 0x7f, 0x11, 0x01, 0x06, 0x43, 0x34, 0xd3, 0x90, 0x08, 0x88,
+  0x14, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18,
+  0x12, 0x45, 0x0d, 0x03, 0x04, 0x80, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
+  0x00, 0x00, 0x43, 0x22, 0x6f, 0x9b, 0x80, 0x00, 0x18, 0x00, 0x00, 0x00,
+  0x04, 0x00, 0x00, 0x00, 0x40, 0x62, 0x83, 0x40, 0x51, 0x9c, 0x01, 0x00,
+  0x80, 0x2c, 0x10, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x10,
+  0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x8a,
+  0x45, 0x50, 0x02, 0x85, 0x30, 0x02, 0x50, 0x06, 0x05, 0x18, 0x50, 0x20,
+  0x05, 0x54, 0x60, 0xa5, 0x50, 0x0c, 0x64, 0xc7, 0x12, 0x9c, 0x01, 0x00,
+  0xb1, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c,
+  0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3,
+  0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6,
+  0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e,
+  0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43,
+  0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03,
+  0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48,
+  0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20,
+  0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e,
+  0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d,
+  0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89,
+  0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83,
+  0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68,
+  0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90,
+  0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78,
+  0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98,
+  0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5,
+  0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c,
+  0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c,
+  0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43,
+  0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43,
+  0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82,
+  0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58,
+  0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18,
+  0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2,
+  0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec,
+  0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e,
+  0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d,
+  0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83,
+  0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60,
+  0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0,
+  0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d,
+  0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d,
+  0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43,
+  0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3,
+  0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18,
+  0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3,
+  0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1,
+  0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e,
+  0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83,
+  0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83,
+  0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x79, 0x20, 0x00, 0x00,
+  0x09, 0x01, 0x00, 0x00, 0x32, 0x9a, 0x08, 0x14, 0x02, 0x85, 0x8c, 0x27,
+  0x46, 0x46, 0xc8, 0x11, 0x32, 0x64, 0xd4, 0xd8, 0x80, 0x0c, 0xea, 0x09,
+  0x8b, 0x02, 0x07, 0xc5, 0xc6, 0x91, 0x41, 0x14, 0x19, 0x8c, 0x22, 0x31,
+  0x88, 0x64, 0x3d, 0x45, 0x66, 0x20, 0xca, 0x23, 0x21, 0x94, 0x61, 0x18,
+  0x86, 0x11, 0x5d, 0x89, 0xb1, 0x28, 0x18, 0x51, 0x2c, 0x47, 0x00, 0x00,
+  0x53, 0x44, 0x4b, 0x20, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x77,
+  0x63, 0x68, 0x61, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x41, 0x70, 0x70,
+  0x6c, 0x65, 0x20, 0x4c, 0x4c, 0x56, 0x4d, 0x20, 0x76, 0x65, 0x72, 0x73,
+  0x69, 0x6f, 0x6e, 0x20, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x35, 0x30,
+  0x20, 0x28, 0x6d, 0x65, 0x74, 0x61, 0x6c, 0x66, 0x65, 0x2d, 0x33, 0x31,
+  0x30, 0x30, 0x31, 0x2e, 0x35, 0x30, 0x2e, 0x31, 0x29, 0x4d, 0x65, 0x74,
+  0x61, 0x6c, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c,
+  0x65, 0x2e, 0x64, 0x65, 0x6e, 0x6f, 0x72, 0x6d, 0x73, 0x5f, 0x64, 0x69,
+  0x73, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d,
+  0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61,
+  0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72,
+  0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x72, 0x61,
+  0x6d, 0x65, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x66, 0x65, 0x74,
+  0x63, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72,
+  0x2e, 0x72, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x5f, 0x74, 0x61, 0x72, 0x67,
+  0x65, 0x74, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79,
+  0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74,
+  0x34, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f,
+  0x6e, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x61,
+  0x69, 0x72, 0x2e, 0x6e, 0x6f, 0x5f, 0x70, 0x65, 0x72, 0x73, 0x70, 0x65,
+  0x63, 0x74, 0x69, 0x76, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67,
+  0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f,
+  0x6e, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e,
+  0x74, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x67, 0x65, 0x6e, 0x65, 0x72,
+  0x61, 0x74, 0x65, 0x64, 0x28, 0x35, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44,
+  0x76, 0x34, 0x5f, 0x66, 0x29, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x65, 0x72,
+  0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x63, 0x6f, 0x6c, 0x6f,
+  0x72, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x38,
+  0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x44, 0x76, 0x32, 0x5f,
+  0x66, 0x29, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32, 0x74, 0x65, 0x78, 0x63,
+  0x6f, 0x6f, 0x72, 0x64, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66,
+  0x65, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72,
+  0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x6c, 0x6f, 0x63,
+  0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x61,
+  0x69, 0x72, 0x2e, 0x72, 0x65, 0x61, 0x64, 0x61, 0x69, 0x72, 0x2e, 0x73,
+  0x74, 0x72, 0x75, 0x63, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x69,
+  0x6e, 0x66, 0x6f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x6f, 0x66, 0x66,
+  0x73, 0x65, 0x74, 0x52, 0x63, 0x6f, 0x65, 0x66, 0x66, 0x47, 0x63, 0x6f,
+  0x65, 0x66, 0x66, 0x42, 0x63, 0x6f, 0x65, 0x66, 0x66, 0x61, 0x69, 0x72,
+  0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x73, 0x69,
+  0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79,
+  0x70, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69, 0x7a,
+  0x65, 0x59, 0x55, 0x56, 0x44, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x65,
+  0x63, 0x6f, 0x64, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x74, 0x65, 0x78, 0x74,
+  0x75, 0x72, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c,
+  0x65, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x32, 0x64, 0x3c, 0x66,
+  0x6c, 0x6f, 0x61, 0x74, 0x2c, 0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65,
+  0x3e, 0x74, 0x65, 0x78, 0x59, 0x74, 0x65, 0x78, 0x55, 0x56, 0x61, 0x69,
+  0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73, 0x61, 0x6d,
+  0x70, 0x6c, 0x65, 0x72, 0x73, 0x00, 0x00, 0x00, 0x44, 0x74, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x30, 0x82, 0x10, 0x0d, 0x23, 0x08, 0x96, 0x33,
+  0x82, 0x10, 0x11, 0x23, 0x08, 0x51, 0x31, 0x82, 0x10, 0x19, 0x23, 0x08,
+  0x0b, 0x30, 0x82, 0x10, 0x1d, 0x23, 0x08, 0x11, 0x32, 0x82, 0x10, 0x25,
+  0x23, 0x08, 0x91, 0x32, 0x82, 0x10, 0x2d, 0x23, 0x08, 0x11, 0x33, 0x82,
+  0x10, 0x35, 0x33, 0x0c, 0x6d, 0x10, 0xb8, 0xc1, 0x0c, 0xc3, 0x1b, 0x08,
+  0x70, 0x30, 0x43, 0x30, 0xcc, 0x30, 0xb4, 0x41, 0x1b, 0xc4, 0xc1, 0x0c,
+  0x04, 0xf1, 0x06, 0x6f, 0x10, 0x07, 0x33, 0x04, 0xc5, 0x0c, 0x81, 0x31,
+  0x43, 0x70, 0xcc, 0x50, 0x20, 0x71, 0x10, 0x07, 0x89, 0x32, 0x43, 0x20,
+  0x0a, 0x33, 0x20, 0x71, 0xb0, 0x30, 0x4d, 0xa2, 0x38, 0xcf, 0x0c, 0xc9,
+  0x1b, 0x40, 0x11, 0x23, 0x25, 0x8a, 0x33, 0xcd, 0x90, 0xb4, 0x01, 0x44,
+  0x31, 0x52, 0x52, 0x39, 0xd6, 0x0c, 0x54, 0x1c, 0xd4, 0x41, 0x1c, 0x70,
+  0x5d, 0x1d, 0xd4, 0x41, 0x1c, 0x70, 0x9e, 0x1d, 0xd4, 0x41, 0x1c, 0x70,
+  0xdf, 0x1d, 0xd4, 0x41, 0x1c, 0x70, 0x60, 0x30, 0x83, 0x34, 0x07, 0x17,
+  0x46, 0x07, 0xd9, 0x1b, 0xbc, 0x81, 0xb6, 0x9d, 0x42, 0x18, 0xd0, 0x81,
+  0x18, 0xd4, 0x41, 0x32, 0x06, 0x0e, 0x19, 0xcc, 0xa0, 0xc0, 0x41, 0x19,
+  0x64, 0x71, 0xf0, 0x06, 0x66, 0x90, 0x9c, 0x81, 0x83, 0x06, 0x33, 0x28,
+  0x78, 0x50, 0x06, 0xd9, 0x1b, 0xbc, 0x81, 0x19, 0x24, 0x67, 0xe0, 0xa4,
+  0xc1, 0x0c, 0x49, 0x1e, 0xa8, 0x41, 0x16, 0x07, 0x6f, 0x90, 0xac, 0x81,
+  0xc3, 0x06, 0x33, 0x1c, 0xa4, 0x50, 0x0a, 0xa6, 0x80, 0x0a, 0xa9, 0xa0,
+  0x0a, 0xab, 0x30, 0xc3, 0x20, 0x07, 0xa3, 0xc0, 0x0a, 0x15, 0x06, 0x00,
+  0xc7, 0x71, 0x1c, 0xc7, 0x71, 0x1c, 0xc7, 0x71, 0x1c, 0xe7, 0x06, 0x6e,
+  0x60, 0xd1, 0x81, 0x1e, 0x58, 0x96, 0xa5, 0x07, 0x9c, 0x29, 0xb0, 0x02,
+  0x2b, 0xd8, 0x86, 0x5f, 0xd8, 0x83, 0x3d, 0xa8, 0x03, 0x39, 0xc8, 0x48,
+  0x60, 0x82, 0x2e, 0x62, 0x63, 0xb3, 0x6b, 0x73, 0x69, 0x7b, 0x23, 0xab,
+  0x63, 0x2b, 0x73, 0x31, 0x63, 0x0b, 0x3b, 0x9b, 0x1b, 0x45, 0xc8, 0x03,
+  0x3d, 0x38, 0x85, 0x8d, 0xcd, 0xae, 0xcd, 0x25, 0x8d, 0xac, 0xcc, 0x8d,
+  0x6e, 0x94, 0x60, 0x0f, 0x6e, 0x09, 0x4b, 0x93, 0x73, 0xb1, 0x2b, 0x93,
+  0x9b, 0x4b, 0x7b, 0x73, 0x1b, 0x25, 0xe0, 0x83, 0xa3, 0xc2, 0xd2, 0xe4,
+  0x5c, 0xd8, 0xc2, 0xdc, 0xce, 0xea, 0xc2, 0xce, 0xca, 0xbe, 0xec, 0xca,
+  0xe4, 0xe6, 0xd2, 0xde, 0xdc, 0x46, 0x09, 0xfa, 0xe0, 0xa6, 0xb0, 0x34,
+  0x39, 0x97, 0xb1, 0xb7, 0x36, 0xb8, 0x34, 0xb6, 0xb2, 0xaf, 0x37, 0x38,
+  0xba, 0xb4, 0x37, 0xb7, 0xb9, 0x51, 0x06, 0x3f, 0xf8, 0x03, 0x50, 0x38,
+  0x26, 0x2c, 0x4d, 0xce, 0xc5, 0x4c, 0x2e, 0xec, 0xac, 0xad, 0xcc, 0x8d,
+  0x6e, 0x94, 0x80, 0x15, 0x00, 0x00, 0x00, 0x00, 0xa9, 0x18, 0x00, 0x00,
+  0x0b, 0x00, 0x00, 0x00, 0x0b, 0x0a, 0x72, 0x28, 0x87, 0x77, 0x80, 0x07,
+  0x7a, 0x58, 0x70, 0x98, 0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb0, 0x43, 0x39,
+  0xd0, 0xc3, 0x82, 0xe6, 0x1c, 0xc6, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2,
+  0xc1, 0x1d, 0xe6, 0x21, 0x1d, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x00,
+  0xd1, 0x10, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0xcc, 0x3c, 0xa4,
+  0x83, 0x3b, 0x9c, 0x03, 0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83, 0x3c, 0x94,
+  0x43, 0x38, 0x90, 0xc3, 0x01, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00,
+  0x3b, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00,
+  0x0e, 0x00, 0x00, 0x00, 0x04, 0x6b, 0x60, 0x04, 0x80, 0xe2, 0x0c, 0x00,
+  0xc9, 0x11, 0x00, 0xba, 0x63, 0x0d, 0x40, 0x20, 0xcc, 0x31, 0x18, 0x18,
+  0x36, 0xc7, 0x60, 0x10, 0xd8, 0x58, 0x03, 0x30, 0x10, 0x94, 0x47, 0x00,
+  0x08, 0x8c, 0x00, 0xcc, 0x00, 0x8c, 0x11, 0x80, 0x20, 0x08, 0xe2, 0x1f,
+  0x85, 0x19, 0x80, 0x39, 0x08, 0x30, 0x00, 0x03, 0x30, 0x08, 0x03, 0x00,
+  0x23, 0x06, 0xcd, 0x10, 0x82, 0x60, 0x30, 0x89, 0x41, 0xf4, 0x4c, 0xce,
+  0xd2, 0x14, 0x85, 0x37, 0x9a, 0x10, 0x00, 0x83, 0x0c, 0x01, 0xb1, 0x8c,
+  0x18, 0x34, 0x43, 0x08, 0x82, 0xc1, 0x54, 0x06, 0x93, 0x64, 0x45, 0x0e,
+  0x84, 0x20, 0x61, 0x30, 0x9a, 0x10, 0x00, 0x83, 0x0c, 0xc1, 0xd1, 0x0c,
+  0x32, 0x10, 0x41, 0x73, 0x19, 0x5e, 0x0a, 0x42, 0x19, 0x64, 0x08, 0x96,
+  0xc9, 0x88, 0x00, 0xfc, 0x37, 0x19, 0xba, 0x68, 0x0d, 0x2e, 0xc0, 0x4b,
+  0x41, 0x28, 0x83, 0x0c, 0x01, 0x84, 0x8d, 0x18, 0x1c, 0x42, 0x08, 0x82,
+  0x85, 0x7f, 0x30, 0x72, 0x50, 0x04, 0x9b, 0x0c, 0x62, 0x60, 0xc5, 0xc1,
+  0x05, 0x78, 0x29, 0x08, 0x65, 0x90, 0x21, 0xa8, 0xba, 0x11, 0x83, 0x43,
+  0x08, 0x41, 0xb0, 0xf0, 0x0f, 0xe6, 0x0e, 0x94, 0x60, 0x93, 0xe1, 0x0c,
+  0x36, 0x39, 0xb8, 0x00, 0x2f, 0x05, 0xa1, 0x0c, 0x32, 0x04, 0x9a, 0x18,
+  0x8c, 0x18, 0x1c, 0x42, 0x08, 0x82, 0x85, 0x7f, 0x30, 0x7c, 0xf0, 0x04,
+  0x73, 0x0c, 0xdb, 0x82, 0x07, 0x73, 0x0c, 0xc1, 0xb1, 0x07, 0x73, 0x0c,
+  0xc1, 0xd0, 0x07, 0x16, 0xc4, 0x81, 0xf8, 0x67, 0x00, 0x00, 0x00, 0x00,
+  0x71, 0x20, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x32, 0x0e, 0x10, 0x22,
+  0x84, 0x00, 0xfb, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x65, 0x0c, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0x38,
+  0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00,
+  0x0a, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x98, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x43, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x11, 0x00, 0x00, 0x00, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x11, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x24, 0x00, 0x00,
+  0x11, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+  0x0d, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00,
+  0x1e, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+  0x1b, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x5d, 0x0c, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00,
+  0x12, 0x03, 0x94, 0xe3, 0x00, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4c, 0x5f,
+  0x4e, 0x56, 0x31, 0x32, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e,
+  0x74, 0x61, 0x69, 0x72, 0x2e, 0x64, 0x6f, 0x74, 0x2e, 0x76, 0x33, 0x66,
+  0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65,
+  0x5f, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x5f, 0x32, 0x64, 0x2e,
+  0x76, 0x34, 0x66, 0x33, 0x32, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x35,
+  0x30, 0x2e, 0x31, 0x61, 0x69, 0x72, 0x36, 0x34, 0x2d, 0x61, 0x70, 0x70,
+  0x6c, 0x65, 0x2d, 0x74, 0x76, 0x6f, 0x73, 0x31, 0x33, 0x2e, 0x30, 0x2e,
+  0x30, 0x2d, 0x73, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00,
+  0x14, 0x00, 0x00, 0x00, 0x28, 0x0e, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+  0x42, 0x43, 0xc0, 0xde, 0x35, 0x14, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x62, 0x0c, 0x30, 0x24, 0x80, 0x10, 0x05, 0xc8, 0x14, 0x00, 0x00, 0x00,
+  0x21, 0x0c, 0x00, 0x00, 0x39, 0x03, 0x00, 0x00, 0x0b, 0x02, 0x21, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91,
+  0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c,
+  0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02,
+  0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x4b,
+  0x0a, 0x32, 0x52, 0x88, 0x48, 0x90, 0x14, 0x20, 0x43, 0x46, 0x88, 0xa5,
+  0x00, 0x19, 0x32, 0x42, 0x04, 0x49, 0x0e, 0x90, 0x91, 0x22, 0xc4, 0x50,
+  0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x29, 0x46, 0x06,
+  0x51, 0x18, 0x00, 0x00, 0x92, 0x00, 0x00, 0x00, 0x1b, 0xcc, 0x25, 0xf8,
+  0xff, 0xff, 0xff, 0xff, 0x01, 0x58, 0x03, 0x40, 0x02, 0x2a, 0x62, 0x1c,
+  0xde, 0x41, 0x1e, 0xe4, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xd8, 0x21, 0x1f,
+  0xda, 0x40, 0x1e, 0xde, 0xa1, 0x1e, 0xdc, 0x81, 0x1c, 0xca, 0x81, 0x1c,
+  0xda, 0x80, 0x1c, 0xd2, 0xc1, 0x1e, 0xd2, 0x81, 0x1c, 0xca, 0xa1, 0x0d,
+  0xe6, 0x21, 0x1e, 0xe4, 0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d,
+  0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x73, 0x08, 0x07, 0x76, 0x98,
+  0x87, 0x72, 0x00, 0x08, 0x72, 0x48, 0x87, 0x79, 0x08, 0x07, 0x71, 0x60,
+  0x87, 0x72, 0x68, 0x03, 0x7a, 0x08, 0x87, 0x74, 0x60, 0x87, 0x36, 0x18,
+  0x87, 0x70, 0x60, 0x07, 0x76, 0x98, 0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d,
+  0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1d, 0xca, 0x61, 0x1e, 0xe6, 0xa1, 0x0d,
+  0xe0, 0x41, 0x1e, 0xca, 0x61, 0x1c, 0xd2, 0x61, 0x1e, 0xca, 0xa1, 0x0d,
+  0xcc, 0x01, 0x1e, 0xda, 0x21, 0x1c, 0xc8, 0x01, 0x30, 0x87, 0x70, 0x60,
+  0x87, 0x79, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90,
+  0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70,
+  0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68,
+  0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x18, 0xdc, 0xe1, 0x1d,
+  0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e,
+  0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c,
+  0xd8, 0x21, 0x1d, 0xda, 0xa1, 0x0d, 0xdc, 0xe1, 0x1d, 0xdc, 0xa1, 0x0d,
+  0xd8, 0xa1, 0x1c, 0xc2, 0xc1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d,
+  0xd2, 0xc1, 0x1d, 0xcc, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d,
+  0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28,
+  0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x75, 0xa8, 0x87, 0x76, 0x80,
+  0x87, 0x36, 0xa0, 0x87, 0x70, 0x10, 0x07, 0x76, 0x28, 0x87, 0x79, 0x00,
+  0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0xc0, 0x1d, 0xc2, 0xc1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e,
+  0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8,
+  0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x98, 0x87, 0x74, 0x38,
+  0x07, 0x77, 0x28, 0x07, 0x72, 0x68, 0x03, 0x7d, 0x28, 0x07, 0x79, 0x78,
+  0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0,
+  0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d,
+  0xde, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0x01, 0x1e, 0xe0, 0x21, 0x1d,
+  0xdc, 0xe1, 0x1c, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0,
+  0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x88, 0x79, 0xa0, 0x87, 0x70, 0x18,
+  0x87, 0x75, 0x68, 0x03, 0x78, 0x90, 0x87, 0x77, 0xa0, 0x87, 0x72, 0x18,
+  0x07, 0x7a, 0x78, 0x07, 0x79, 0x68, 0x03, 0x71, 0xa8, 0x07, 0x73, 0x30,
+  0x87, 0x72, 0x90, 0x87, 0x36, 0x98, 0x87, 0x74, 0xd0, 0x87, 0x72, 0x00,
+  0xf0, 0x00, 0x20, 0xea, 0xc1, 0x1d, 0xe6, 0x21, 0x1c, 0xcc, 0xa1, 0x1c,
+  0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d,
+  0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0xa8, 0x87, 0x79, 0x28,
+  0x87, 0x36, 0x98, 0x87, 0x77, 0x30, 0x07, 0x7a, 0x68, 0x03, 0x73, 0x60,
+  0x87, 0x77, 0x08, 0x07, 0x7a, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e,
+  0xca, 0x01, 0xd8, 0xb0, 0x08, 0x04, 0x90, 0x00, 0x0b, 0x50, 0x05, 0x69,
+  0x00, 0x0a, 0x1b, 0x8c, 0xa1, 0x00, 0x16, 0xa0, 0xda, 0x60, 0x10, 0x06,
+  0xb0, 0x00, 0xd5, 0x06, 0xa3, 0x38, 0x80, 0x05, 0xa8, 0x36, 0x18, 0xc6,
+  0xff, 0xff, 0xff, 0xff, 0x0f, 0x80, 0x04, 0x50, 0x1b, 0x94, 0xe3, 0xff,
+  0xff, 0xff, 0xff, 0x07, 0xa0, 0x0d, 0x80, 0x35, 0x00, 0x24, 0xa0, 0xda,
+  0x60, 0x20, 0x01, 0xb0, 0x00, 0xd5, 0x06, 0x23, 0x11, 0x80, 0x05, 0xa8,
+  0x00, 0x00, 0x00, 0x00, 0x49, 0x18, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+  0x13, 0x8a, 0x40, 0x18, 0x88, 0x62, 0x42, 0x60, 0x4c, 0x18, 0x0e, 0x24,
+  0x01, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00,
+  0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84,
+  0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c,
+  0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x70, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30,
+  0x8c, 0x20, 0x00, 0xc3, 0x08, 0x03, 0x70, 0x90, 0x34, 0x45, 0x94, 0x30,
+  0xf9, 0xb2, 0xfb, 0x76, 0x84, 0xe0, 0x0c, 0x04, 0x22, 0xc6, 0x18, 0x63,
+  0x10, 0x81, 0x10, 0x8e, 0x92, 0xa6, 0x88, 0x12, 0x26, 0xff, 0x9f, 0x88,
+  0x6b, 0xa2, 0x22, 0xe2, 0xb7, 0x87, 0x7f, 0x1a, 0x23, 0x00, 0x06, 0x11,
+  0x8c, 0xe0, 0x22, 0x69, 0x8a, 0x28, 0x61, 0xf2, 0x7f, 0x09, 0x60, 0x9e,
+  0x85, 0x88, 0xfe, 0x69, 0x8c, 0x00, 0x18, 0x44, 0x40, 0x84, 0x82, 0x84,
+  0x10, 0x44, 0x39, 0x27, 0x91, 0x2a, 0x03, 0x18, 0x83, 0xd8, 0x1c, 0x01,
+  0x62, 0x84, 0xe0, 0xe6, 0x08, 0x82, 0x39, 0x02, 0x30, 0x18, 0x46, 0x10,
+  0xa2, 0xa2, 0xbc, 0x93, 0x04, 0x94, 0x10, 0x80, 0x48, 0x73, 0x20, 0x20,
+  0x05, 0xe2, 0x30, 0xc2, 0x10, 0x0d, 0x22, 0x04, 0xc2, 0x1c, 0x01, 0x28,
+  0x0c, 0x22, 0x0c, 0xc2, 0x08, 0x00, 0x00, 0x00, 0x13, 0xc0, 0x20, 0x1c,
+  0xd2, 0x41, 0x1e, 0xec, 0x80, 0x0e, 0xda, 0x20, 0x1c, 0xe0, 0x01, 0x1e,
+  0xd8, 0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xec, 0xe1, 0x1d, 0xe6, 0x21, 0x0e,
+  0xe6, 0xc0, 0x0d, 0xe0, 0xc0, 0x0d, 0xe0, 0xa0, 0x0d, 0xe6, 0x21, 0x1d,
+  0xda, 0xa1, 0x1e, 0xd8, 0x21, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0x61, 0xc3,
+  0x6d, 0x94, 0x43, 0x1b, 0xc0, 0x83, 0x1e, 0xd8, 0x01, 0x1d, 0xe8, 0x81,
+  0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x41, 0x3a, 0xc4, 0x81,
+  0x1e, 0xe0, 0x81, 0x1e, 0xe0, 0x41, 0x1b, 0xa4, 0x03, 0x1e, 0xe8, 0x01,
+  0x1e, 0xe8, 0x01, 0x1e, 0xb4, 0x41, 0x3a, 0xc4, 0x81, 0x1d, 0xe8, 0x41,
+  0x1c, 0xd8, 0x81, 0x1e, 0xc4, 0x81, 0x1d, 0xb4, 0x41, 0x3a, 0xcc, 0x81,
+  0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x41,
+  0x3a, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01,
+  0x1d, 0xb4, 0x81, 0x39, 0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81,
+  0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x39, 0xd8, 0x01, 0x1d, 0xe8, 0x81,
+  0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xc4, 0x81,
+  0x1d, 0xe8, 0x41, 0x1c, 0xd8, 0x81, 0x1e, 0xc4, 0x81, 0x1d, 0xb4, 0x81,
+  0x3d, 0xc8, 0x01, 0x1d, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81,
+  0x1c, 0xb4, 0x81, 0x3d, 0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81,
+  0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xd0, 0x01, 0x1e, 0xe8, 0x81,
+  0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xd8, 0x01,
+  0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81,
+  0x3d, 0xe4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xc8, 0x01, 0x1e, 0xe8, 0x41,
+  0x1c, 0xc8, 0x01, 0x1e, 0xb4, 0x81, 0x3d, 0xc4, 0x81, 0x1c, 0xe0, 0x81,
+  0x1e, 0xc4, 0x81, 0x1c, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1c, 0xe0, 0x41,
+  0x1b, 0xd8, 0x43, 0x1c, 0xe4, 0x81, 0x1c, 0xe8, 0x81, 0x1c, 0xd4, 0x81,
+  0x1d, 0xe8, 0x81, 0x1c, 0xd4, 0x81, 0x1d, 0xb4, 0x81, 0x3d, 0xc8, 0x41,
+  0x1d, 0xd8, 0x81, 0x1e, 0xc8, 0x41, 0x1d, 0xd8, 0x81, 0x1e, 0xc8, 0x41,
+  0x1d, 0xd8, 0x41, 0x1b, 0xd8, 0x43, 0x1d, 0xc4, 0x81, 0x1c, 0xe8, 0x41,
+  0x1d, 0xc4, 0x81, 0x1c, 0xe8, 0x41, 0x1d, 0xc4, 0x81, 0x1c, 0xb4, 0x81,
+  0x3d, 0xc4, 0x01, 0x1c, 0xc8, 0x01, 0x1d, 0xe8, 0x41, 0x1c, 0xc0, 0x81,
+  0x1c, 0xd0, 0x81, 0x1e, 0xc4, 0x01, 0x1c, 0xc8, 0x01, 0x1d, 0xb4, 0x81,
+  0x3b, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1d, 0xe8, 0xc1, 0x1c, 0xc8, 0x81,
+  0x46, 0x08, 0x43, 0x46, 0x6c, 0x57, 0xfe, 0xe7, 0x6b, 0xd7, 0x7f, 0x11,
+  0x01, 0x06, 0x43, 0x34, 0xd3, 0x90, 0x08, 0x88, 0x14, 0x00, 0x00, 0x02,
+  0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18, 0x12, 0x45, 0x0d, 0x03,
+  0x04, 0x80, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x43, 0x22,
+  0x6f, 0x9b, 0x80, 0x00, 0x18, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+  0x40, 0x62, 0x83, 0x40, 0xd1, 0x9d, 0x01, 0x00, 0x80, 0x2c, 0x10, 0x00,
+  0x0a, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90,
+  0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x8a, 0x45, 0x50, 0x02, 0x85,
+  0x30, 0x02, 0x50, 0x06, 0x05, 0x18, 0x50, 0x20, 0x05, 0x54, 0x60, 0xa5,
+  0x50, 0x0c, 0x64, 0xc7, 0x12, 0x9c, 0x01, 0x00, 0xb1, 0x18, 0x00, 0x00,
+  0x7b, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66,
+  0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07,
+  0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10,
+  0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce,
+  0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b,
+  0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c,
+  0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07,
+  0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11,
+  0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0,
+  0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8,
+  0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b,
+  0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b,
+  0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87,
+  0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07,
+  0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87,
+  0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81,
+  0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30,
+  0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4,
+  0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca,
+  0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39,
+  0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b,
+  0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b,
+  0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83,
+  0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87,
+  0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90,
+  0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20,
+  0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc,
+  0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66,
+  0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24,
+  0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07,
+  0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e,
+  0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e,
+  0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54,
+  0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39,
+  0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c,
+  0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07,
+  0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0,
+  0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4,
+  0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38,
+  0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d,
+  0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d,
+  0xc0, 0xc3, 0x3c, 0x00, 0x79, 0x20, 0x00, 0x00, 0x09, 0x01, 0x00, 0x00,
+  0x32, 0x9a, 0x08, 0x14, 0x02, 0x85, 0x8c, 0x27, 0x46, 0x46, 0xc8, 0x11,
+  0x32, 0x64, 0xd4, 0xd8, 0x80, 0x0c, 0xea, 0x09, 0x8b, 0x02, 0x07, 0xc5,
+  0xc6, 0x91, 0x41, 0x14, 0x19, 0x8c, 0x22, 0x31, 0x88, 0x64, 0x3d, 0x45,
+  0x66, 0x20, 0xca, 0x23, 0x21, 0x94, 0x61, 0x18, 0x86, 0x11, 0x5d, 0x89,
+  0xb1, 0x28, 0x18, 0x51, 0x2c, 0x47, 0x00, 0x00, 0x53, 0x44, 0x4b, 0x20,
+  0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68, 0x61, 0x72,
+  0x5f, 0x73, 0x69, 0x7a, 0x65, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x4c,
+  0x4c, 0x56, 0x4d, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20,
+  0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x35, 0x30, 0x20, 0x28, 0x6d, 0x65,
+  0x74, 0x61, 0x6c, 0x66, 0x65, 0x2d, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e,
+  0x35, 0x30, 0x2e, 0x31, 0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x61, 0x69,
   0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x64, 0x65,
   0x6e, 0x6f, 0x72, 0x6d, 0x73, 0x5f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c,
   0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65,
@@ -1332,758 +1941,120 @@ const unsigned char sdl_metallib[] = {
   0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x69, 0x72,
   0x2e, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x6e,
   0x70, 0x75, 0x74, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64,
-  0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x44, 0x76,
-  0x32, 0x5f, 0x66, 0x29, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x65, 0x72, 0x73,
-  0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74,
-  0x32, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x61, 0x69, 0x72,
-  0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x62,
-  0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69,
-  0x72, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69,
-  0x6e, 0x64, 0x65, 0x78, 0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x61, 0x64,
-  0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65,
-  0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67,
-  0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f,
-  0x73, 0x69, 0x7a, 0x65, 0x63, 0x6f, 0x6c, 0x61, 0x69, 0x72, 0x2e, 0x73,
-  0x74, 0x72, 0x75, 0x63, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x69,
-  0x6e, 0x66, 0x6f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x6f, 0x66, 0x66,
-  0x73, 0x65, 0x74, 0x52, 0x63, 0x6f, 0x65, 0x66, 0x66, 0x47, 0x63, 0x6f,
-  0x65, 0x66, 0x66, 0x42, 0x63, 0x6f, 0x65, 0x66, 0x66, 0x59, 0x55, 0x56,
+  0x28, 0x35, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66,
+  0x29, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63,
+  0x74, 0x69, 0x76, 0x65, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x67, 0x65, 0x6e,
+  0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x38, 0x74, 0x65, 0x78, 0x63,
+  0x6f, 0x6f, 0x72, 0x64, 0x44, 0x76, 0x32, 0x5f, 0x66, 0x29, 0x66, 0x6c,
+  0x6f, 0x61, 0x74, 0x32, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64,
+  0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x61, 0x69,
+  0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a,
+  0x65, 0x61, 0x69, 0x72, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f,
+  0x6e, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x61, 0x69, 0x72, 0x2e, 0x72,
+  0x65, 0x61, 0x64, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x74, 0x72, 0x75, 0x63,
+  0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x66,
+  0x6c, 0x6f, 0x61, 0x74, 0x33, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x52,
+  0x63, 0x6f, 0x65, 0x66, 0x66, 0x47, 0x63, 0x6f, 0x65, 0x66, 0x66, 0x42,
+  0x63, 0x6f, 0x65, 0x66, 0x66, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67,
+  0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69,
+  0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x61,
+  0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x59, 0x55, 0x56,
   0x44, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x65, 0x63, 0x6f, 0x64, 0x65,
   0x61, 0x69, 0x72, 0x2e, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x61,
   0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x78,
   0x74, 0x75, 0x72, 0x65, 0x32, 0x64, 0x3c, 0x66, 0x6c, 0x6f, 0x61, 0x74,
   0x2c, 0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x3e, 0x74, 0x65, 0x78,
-  0x59, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x32, 0x64, 0x5f, 0x61,
-  0x72, 0x72, 0x61, 0x79, 0x3c, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x2c, 0x20,
-  0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x3e, 0x74, 0x65, 0x78, 0x55, 0x56,
-  0x61, 0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73,
-  0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73, 0x00, 0x00, 0x00, 0x64, 0x78,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x82, 0x30, 0x11, 0x23, 0x08,
-  0x1b, 0x34, 0x82, 0x30, 0x15, 0x23, 0x08, 0x93, 0x31, 0x82, 0x30, 0x1d,
-  0x23, 0x08, 0x0e, 0x30, 0x82, 0x30, 0x21, 0x23, 0x08, 0x53, 0x32, 0x82,
-  0x30, 0x29, 0x23, 0x08, 0xd3, 0x32, 0x82, 0x30, 0x31, 0x23, 0x08, 0x53,
-  0x33, 0x82, 0x30, 0x39, 0x33, 0x0c, 0x6d, 0x10, 0xb8, 0xc1, 0x0c, 0xc3,
-  0x1b, 0x08, 0x70, 0x30, 0x43, 0x30, 0xcc, 0x30, 0xb4, 0x41, 0x1b, 0xc4,
-  0xc1, 0x0c, 0x04, 0xf1, 0x06, 0x6f, 0x10, 0x07, 0x33, 0x04, 0xc5, 0x0c,
-  0x81, 0x31, 0x43, 0x70, 0xcc, 0x50, 0x20, 0x71, 0x10, 0x07, 0x89, 0x32,
-  0x43, 0x20, 0x0a, 0x33, 0x20, 0x71, 0xb0, 0x30, 0x4d, 0xa2, 0x38, 0xcf,
-  0x0c, 0xc9, 0x1b, 0x40, 0x11, 0x23, 0x25, 0x93, 0x43, 0xcd, 0x00, 0xb5,
-  0x41, 0x65, 0xcd, 0xc1, 0x15, 0x07, 0x6f, 0x80, 0x65, 0x73, 0xa0, 0xcd,
-  0x41, 0xa2, 0x38, 0xdb, 0x0c, 0x54, 0x1c, 0xcc, 0x41, 0x1c, 0x74, 0xde,
-  0x1c, 0xcc, 0x41, 0x1c, 0x74, 0x9f, 0x1d, 0xcc, 0x41, 0x1c, 0x74, 0x60,
-  0x70, 0x07, 0x73, 0x10, 0x07, 0x5d, 0x18, 0xcc, 0x20, 0xd1, 0x41, 0x65,
-  0xd5, 0xc1, 0xf5, 0x06, 0x6f, 0x80, 0x71, 0xa7, 0x90, 0xd5, 0x81, 0x36,
-  0x07, 0x89, 0x18, 0x38, 0x63, 0x30, 0x83, 0x02, 0x07, 0x64, 0x70, 0xc5,
-  0xc1, 0x1b, 0x94, 0x41, 0x62, 0x06, 0xce, 0x19, 0xcc, 0xa0, 0xe0, 0x01,
-  0x19, 0x5c, 0x6f, 0xf0, 0x06, 0x65, 0x90, 0xa0, 0x81, 0x93, 0x06, 0x33,
-  0x24, 0x79, 0xa0, 0x06, 0x57, 0x1c, 0xbc, 0x41, 0xb2, 0x06, 0x0e, 0x1b,
-  0xcc, 0x70, 0x90, 0x42, 0x29, 0x98, 0x02, 0x2a, 0xa4, 0x82, 0x2a, 0xac,
-  0xc2, 0x0c, 0x83, 0x1c, 0x8c, 0x02, 0x2b, 0x54, 0x18, 0x00, 0x1c, 0xc7,
-  0x71, 0x1c, 0xc7, 0x71, 0x1c, 0xc7, 0x71, 0x9c, 0x1b, 0xb8, 0x81, 0x45,
-  0x07, 0x7a, 0x60, 0x59, 0x96, 0x1e, 0x70, 0xa6, 0xc0, 0x0a, 0x34, 0xc1,
-  0x1b, 0x72, 0x61, 0x0f, 0xf6, 0xa0, 0x0e, 0xe4, 0x20, 0x23, 0x81, 0x09,
-  0xba, 0x88, 0x8d, 0xcd, 0xae, 0xcd, 0xa5, 0xed, 0x8d, 0xac, 0x8e, 0xad,
-  0xcc, 0xc5, 0x8c, 0x2d, 0xec, 0x6c, 0x6e, 0x14, 0x21, 0x0f, 0xf4, 0xe0,
-  0x14, 0x36, 0x36, 0xbb, 0x36, 0x97, 0x34, 0xb2, 0x32, 0x37, 0xba, 0x51,
-  0x82, 0x3d, 0xb8, 0x25, 0x2c, 0x4d, 0xce, 0xc5, 0xae, 0x4c, 0x6e, 0x2e,
-  0xed, 0xcd, 0x6d, 0x94, 0x80, 0x0f, 0x8e, 0x0a, 0x4b, 0x93, 0x73, 0x61,
-  0x0b, 0x73, 0x3b, 0xab, 0x0b, 0x3b, 0x2b, 0xfb, 0xb2, 0x2b, 0x93, 0x9b,
-  0x4b, 0x7b, 0x73, 0x1b, 0x25, 0xe8, 0x83, 0x9b, 0xc2, 0xd2, 0xe4, 0x5c,
-  0xc6, 0xde, 0xda, 0xe0, 0xd2, 0xd8, 0xca, 0xbe, 0xde, 0xe0, 0xe8, 0xd2,
-  0xde, 0xdc, 0xe6, 0x46, 0x19, 0xfc, 0xe0, 0x0f, 0x40, 0xe1, 0x98, 0xb0,
-  0x34, 0x39, 0x17, 0x33, 0xb9, 0xb0, 0xb3, 0xb6, 0x32, 0x37, 0xba, 0x51,
-  0x02, 0x56, 0x00, 0x00, 0x00, 0x00, 0xa9, 0x18, 0x00, 0x00, 0x0b, 0x00,
-  0x00, 0x00, 0x0b, 0x0a, 0x72, 0x28, 0x87, 0x77, 0x80, 0x07, 0x7a, 0x58,
-  0x70, 0x98, 0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb0, 0x43, 0x39, 0xd0, 0xc3,
-  0x82, 0xe6, 0x1c, 0xc6, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0xc1, 0x1d,
-  0xe6, 0x21, 0x1d, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x00, 0xd1, 0x10,
-  0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0xcc, 0x3c, 0xa4, 0x83, 0x3b,
-  0x9c, 0x03, 0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83, 0x3c, 0x94, 0x43, 0x38,
-  0x90, 0xc3, 0x01, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x5b, 0x00,
-  0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x0d, 0x00,
-  0x00, 0x00, 0x34, 0xcd, 0x00, 0x10, 0x55, 0x03, 0x23, 0x00, 0x54, 0x8d,
-  0x00, 0x10, 0x37, 0xd6, 0x00, 0x04, 0xc2, 0x1c, 0xc3, 0x81, 0x61, 0xd4,
-  0x95, 0x40, 0x11, 0x10, 0x30, 0x02, 0x30, 0x03, 0x30, 0x46, 0x00, 0x82,
-  0x20, 0x88, 0x7f, 0x14, 0xcc, 0x00, 0xcc, 0x41, 0x84, 0x41, 0x18, 0x84,
-  0x81, 0x18, 0x00, 0x00, 0x00, 0x00, 0xf1, 0x30, 0x00, 0x00, 0x11, 0x00,
-  0x00, 0x00, 0x22, 0x47, 0xc8, 0x90, 0x51, 0x0a, 0x84, 0x18, 0x00, 0x00,
-  0x00, 0x00, 0xcf, 0x03, 0x00, 0x00, 0x6f, 0x6d, 0x6e, 0x69, 0x70, 0x6f,
-  0x74, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x68, 0x61, 0x72, 0x53, 0x69, 0x6d,
-  0x70, 0x6c, 0x65, 0x20, 0x43, 0x2b, 0x2b, 0x20, 0x54, 0x42, 0x41, 0x41,
-  0x00, 0x00, 0x13, 0x84, 0xee, 0xd9, 0x10, 0xbc, 0xc2, 0x86, 0xc1, 0x15,
-  0x62, 0x01, 0x16, 0x36, 0x0c, 0xb2, 0x20, 0x0b, 0xb0, 0x00, 0x23, 0x06,
-  0xcd, 0x10, 0x82, 0x60, 0x80, 0x89, 0x01, 0xe4, 0x4c, 0x8c, 0xb2, 0x14,
-  0x85, 0x37, 0x9a, 0x10, 0x00, 0x83, 0x0c, 0x01, 0xa1, 0x8c, 0x18, 0x38,
-  0x43, 0x08, 0x82, 0x81, 0x65, 0x06, 0x52, 0x64, 0x85, 0xc1, 0xd3, 0x38,
-  0x08, 0x12, 0x06, 0xa3, 0x09, 0x01, 0x30, 0x86, 0x10, 0x6c, 0x73, 0x0c,
-  0x44, 0xd0, 0x8c, 0x18, 0x38, 0x43, 0x08, 0x82, 0x81, 0xa5, 0x06, 0x56,
-  0xa5, 0x9d, 0xc1, 0x14, 0x49, 0x0c, 0x53, 0x06, 0xa3, 0x09, 0x01, 0x30,
-  0x86, 0x10, 0x7c, 0x73, 0x0c, 0x44, 0x00, 0x1d, 0xe7, 0x2d, 0x05, 0x41,
-  0x19, 0x64, 0x08, 0x1e, 0xcb, 0x88, 0x00, 0xfc, 0x29, 0x0c, 0x82, 0xb2,
-  0x8b, 0x21, 0x0c, 0xcc, 0x00, 0x0e, 0x2e, 0xf0, 0x96, 0x82, 0xa0, 0x0c,
-  0x32, 0x04, 0x15, 0x37, 0x62, 0x70, 0x08, 0x21, 0x08, 0x16, 0xfe, 0xf1,
-  0xe0, 0x81, 0x11, 0xec, 0x62, 0x30, 0x83, 0x35, 0xb0, 0x83, 0x0b, 0xbc,
-  0xa5, 0x20, 0x28, 0x83, 0x0c, 0x81, 0x16, 0x06, 0x23, 0x06, 0x87, 0x10,
-  0x82, 0x60, 0xe1, 0x1f, 0x4f, 0x1f, 0x2c, 0xc1, 0x2e, 0x86, 0x35, 0x80,
-  0x03, 0x3b, 0xb8, 0xc0, 0x5b, 0x0a, 0x82, 0x32, 0xc8, 0x10, 0x7c, 0x66,
-  0x30, 0x62, 0x70, 0x08, 0x21, 0x08, 0x16, 0xfe, 0xf1, 0x88, 0x02, 0x14,
-  0xcc, 0x31, 0x80, 0xc1, 0xd2, 0x07, 0x73, 0x0c, 0xc1, 0x01, 0x0a, 0x73,
-  0x0c, 0xc1, 0x20, 0x0a, 0x16, 0x4c, 0xe2, 0x9f, 0x41, 0x40, 0x0c, 0x00,
-  0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x5b, 0x86, 0x27, 0x90, 0x05, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x03, 0x00,
-  0x00, 0x00, 0x32, 0x0e, 0x10, 0x22, 0x84, 0x00, 0x90, 0x06, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x0c, 0x00, 0x00, 0x2f, 0x00,
-  0x00, 0x00, 0x12, 0x03, 0x94, 0x70, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
-  0x00, 0x00, 0x59, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x44, 0x00,
-  0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xb0, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x00, 0x00, 0x00, 0x20, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x81, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0xff, 0xff,
-  0xff, 0xff, 0x00, 0x24, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x0d, 0x00,
-  0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0xff, 0xff,
-  0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x21, 0x00,
-  0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0xff, 0xff,
-  0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x1b, 0x00,
-  0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0xff, 0xff,
-  0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5d, 0x0c,
-  0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0x21, 0x01, 0x00,
-  0x00, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x59, 0x55, 0x56, 0x5f, 0x66, 0x72,
-  0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x69, 0x72, 0x2e, 0x64, 0x6f,
-  0x74, 0x2e, 0x76, 0x33, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x73,
-  0x61, 0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72,
-  0x65, 0x5f, 0x32, 0x64, 0x5f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2e, 0x76,
-  0x34, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70,
-  0x6c, 0x65, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x5f, 0x32,
-  0x64, 0x2e, 0x76, 0x34, 0x66, 0x33, 0x32, 0x33, 0x31, 0x30, 0x30, 0x31,
-  0x2e, 0x34, 0x33, 0x61, 0x69, 0x72, 0x36, 0x34, 0x2d, 0x61, 0x70, 0x70,
-  0x6c, 0x65, 0x2d, 0x74, 0x76, 0x6f, 0x73, 0x31, 0x33, 0x2e, 0x30, 0x2e,
-  0x30, 0x2d, 0x73, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0,
-  0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x78, 0x0e,
-  0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x35, 0x14,
-  0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x62, 0x0c, 0x30, 0x24, 0x80, 0x10,
-  0x05, 0xc8, 0x14, 0x00, 0x00, 0x00, 0x21, 0x0c, 0x00, 0x00, 0x4d, 0x03,
-  0x00, 0x00, 0x0b, 0x02, 0x21, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00,
-  0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10,
-  0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04,
-  0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10,
-  0x32, 0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88, 0x48, 0x90,
-  0x14, 0x20, 0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0x04, 0x49,
-  0x0e, 0x90, 0x91, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83,
-  0xe5, 0x8a, 0x04, 0x29, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x94, 0x00,
-  0x00, 0x00, 0x1b, 0xcc, 0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x58,
-  0x03, 0x40, 0x02, 0x2a, 0x62, 0x1c, 0xde, 0x41, 0x1e, 0xe4, 0xa1, 0x1c,
-  0xc6, 0x81, 0x1e, 0xd8, 0x21, 0x1f, 0xda, 0x40, 0x1e, 0xde, 0xa1, 0x1e,
-  0xdc, 0x81, 0x1c, 0xca, 0x81, 0x1c, 0xda, 0x80, 0x1c, 0xd2, 0xc1, 0x1e,
-  0xd2, 0x81, 0x1c, 0xca, 0xa1, 0x0d, 0xe6, 0x21, 0x1e, 0xe4, 0x81, 0x1e,
-  0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d,
-  0x00, 0x73, 0x08, 0x07, 0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x72, 0x48,
-  0x87, 0x79, 0x08, 0x07, 0x71, 0x60, 0x87, 0x72, 0x68, 0x03, 0x7a, 0x08,
-  0x87, 0x74, 0x60, 0x87, 0x36, 0x18, 0x87, 0x70, 0x60, 0x07, 0x76, 0x98,
-  0x07, 0xc0, 0x1c, 0xc2, 0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1d,
-  0xca, 0x61, 0x1e, 0xe6, 0xa1, 0x0d, 0xe0, 0x41, 0x1e, 0xca, 0x61, 0x1c,
-  0xd2, 0x61, 0x1e, 0xca, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0x21, 0x1c,
-  0xc8, 0x01, 0x30, 0x87, 0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x70,
-  0x87, 0x77, 0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72, 0x68,
-  0x03, 0x78, 0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79, 0x68,
-  0x83, 0x72, 0x60, 0x87, 0x74, 0x68, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e,
-  0xca, 0x01, 0x18, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c,
-  0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e,
-  0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0xa1, 0x0d,
-  0xdc, 0xe1, 0x1d, 0xdc, 0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xc2, 0xc1, 0x1c,
-  0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xd2, 0xc1, 0x1d, 0xcc, 0x61, 0x1e,
-  0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d,
-  0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68,
-  0x03, 0x75, 0xa8, 0x87, 0x76, 0x80, 0x87, 0x36, 0xa0, 0x87, 0x70, 0x10,
-  0x07, 0x76, 0x28, 0x87, 0x79, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e,
-  0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1d, 0xc2, 0xc1, 0x1d,
-  0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e,
-  0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78,
-  0x87, 0x36, 0x98, 0x87, 0x74, 0x38, 0x07, 0x77, 0x28, 0x07, 0x72, 0x68,
-  0x03, 0x7d, 0x28, 0x07, 0x79, 0x78, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80,
-  0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e,
-  0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe8, 0x41, 0x1e,
-  0xc2, 0x01, 0x1e, 0xe0, 0x21, 0x1d, 0xdc, 0xe1, 0x1c, 0xda, 0xa0, 0x1d,
-  0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00,
-  0x88, 0x79, 0xa0, 0x87, 0x70, 0x18, 0x87, 0x75, 0x68, 0x03, 0x78, 0x90,
-  0x87, 0x77, 0xa0, 0x87, 0x72, 0x18, 0x07, 0x7a, 0x78, 0x07, 0x79, 0x68,
-  0x03, 0x71, 0xa8, 0x07, 0x73, 0x30, 0x87, 0x72, 0x90, 0x87, 0x36, 0x98,
-  0x87, 0x74, 0xd0, 0x87, 0x72, 0x00, 0xf0, 0x00, 0x20, 0xea, 0xc1, 0x1d,
-  0xe6, 0x21, 0x1c, 0xcc, 0xa1, 0x1c, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d,
-  0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28,
-  0x07, 0x80, 0xa8, 0x87, 0x79, 0x28, 0x87, 0x36, 0x98, 0x87, 0x77, 0x30,
-  0x07, 0x7a, 0x68, 0x03, 0x73, 0x60, 0x87, 0x77, 0x08, 0x07, 0x7a, 0x00,
-  0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0xd8, 0xb0, 0x08, 0x03,
-  0x90, 0x00, 0x0b, 0x50, 0x05, 0x69, 0x00, 0x6d, 0x58, 0x06, 0x02, 0x48,
-  0x80, 0x05, 0xa8, 0x82, 0x34, 0x00, 0x85, 0x0d, 0x06, 0x51, 0x00, 0x0b,
-  0x50, 0x6d, 0x30, 0x0a, 0x03, 0x58, 0x80, 0x6a, 0x83, 0x61, 0x1c, 0xc0,
-  0x02, 0x54, 0x1b, 0x8c, 0xe3, 0xff, 0xff, 0xff, 0xff, 0x07, 0x40, 0x02,
-  0xa8, 0x0d, 0x0a, 0xf2, 0xff, 0xff, 0xff, 0xff, 0x03, 0xd0, 0x06, 0xc0,
-  0x1a, 0x00, 0x12, 0x50, 0x6d, 0x30, 0x92, 0x00, 0x58, 0x80, 0x6a, 0x83,
-  0xa1, 0x08, 0xc0, 0x02, 0x54, 0x00, 0x49, 0x18, 0x00, 0x00, 0x04, 0x00,
-  0x00, 0x00, 0x13, 0x8c, 0x40, 0x18, 0x88, 0xc2, 0x98, 0x10, 0x1c, 0x13,
-  0x06, 0x24, 0x51, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x2a, 0x00,
-  0x00, 0x00, 0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22,
-  0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c,
-  0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x74, 0x33, 0x00, 0xc3, 0x08,
-  0x04, 0x30, 0x8c, 0x20, 0x00, 0x83, 0x08, 0x41, 0x30, 0x8c, 0x30, 0x00,
-  0x07, 0x49, 0x53, 0x44, 0x09, 0x93, 0x2f, 0xbb, 0x6f, 0x47, 0x08, 0xce,
-  0x40, 0x20, 0x82, 0x10, 0x42, 0x06, 0x11, 0x0a, 0xe1, 0x28, 0x69, 0x8a,
-  0x28, 0x61, 0xf2, 0xff, 0x89, 0xb8, 0x26, 0x2a, 0x22, 0x7e, 0x7b, 0xf8,
-  0xa7, 0x31, 0x02, 0x60, 0x10, 0xe1, 0x08, 0x2e, 0x92, 0xa6, 0x88, 0x12,
-  0x26, 0xff, 0x97, 0x00, 0xe6, 0x59, 0x88, 0xe8, 0x9f, 0xc6, 0x08, 0x80,
-  0x41, 0x84, 0x44, 0x28, 0x48, 0x08, 0x62, 0x18, 0x84, 0x14, 0xad, 0x32,
-  0x00, 0x42, 0xa8, 0xcd, 0x11, 0x20, 0x46, 0x08, 0x6f, 0x8e, 0x20, 0x98,
-  0x23, 0x00, 0x83, 0x61, 0x04, 0x41, 0x2a, 0x0a, 0x44, 0x4a, 0xc4, 0x19,
-  0x01, 0x90, 0x44, 0x07, 0x02, 0x52, 0x40, 0x0e, 0x23, 0x0c, 0xd2, 0x20,
-  0x42, 0x20, 0xcc, 0x11, 0x80, 0xc2, 0x20, 0x02, 0x21, 0x8c, 0x00, 0x00,
-  0x00, 0x00, 0x13, 0xc0, 0x20, 0x1c, 0xd2, 0x41, 0x1e, 0xec, 0x80, 0x0e,
-  0xda, 0x20, 0x1c, 0xe0, 0x01, 0x1e, 0xd8, 0xa1, 0x1c, 0xda, 0x80, 0x1e,
-  0xec, 0xe1, 0x1d, 0xe6, 0x21, 0x0e, 0xe6, 0xc0, 0x0d, 0xe0, 0xc0, 0x0d,
-  0xe0, 0xa0, 0x0d, 0xe6, 0x21, 0x1d, 0xda, 0xa1, 0x1e, 0xd8, 0x21, 0x1c,
-  0xe8, 0xe1, 0x1d, 0xe4, 0x61, 0xc3, 0x6d, 0x94, 0x43, 0x1b, 0xc0, 0x83,
-  0x1e, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01,
-  0x1d, 0xb4, 0x41, 0x3a, 0xc4, 0x81, 0x1e, 0xe0, 0x81, 0x1e, 0xe0, 0x41,
-  0x1b, 0xa4, 0x03, 0x1e, 0xe8, 0x01, 0x1e, 0xe8, 0x01, 0x1e, 0xb4, 0x41,
-  0x3a, 0xc4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xd8, 0x81, 0x1e, 0xc4, 0x81,
-  0x1d, 0xb4, 0x41, 0x3a, 0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81,
-  0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x41, 0x3a, 0xd8, 0x01, 0x1d, 0xe8, 0x81,
-  0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x39, 0xcc, 0x81,
-  0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81,
-  0x39, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01,
-  0x1d, 0xb4, 0x81, 0x3d, 0xc4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xd8, 0x81,
-  0x1e, 0xc4, 0x81, 0x1d, 0xb4, 0x81, 0x3d, 0xc8, 0x01, 0x1d, 0xe8, 0xc1,
-  0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xcc, 0x81,
-  0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81,
-  0x3d, 0xd0, 0x01, 0x1e, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01,
-  0x1d, 0xb4, 0x81, 0x3d, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81,
-  0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xe4, 0x81, 0x1d, 0xe8, 0x41,
-  0x1c, 0xc8, 0x01, 0x1e, 0xe8, 0x41, 0x1c, 0xc8, 0x01, 0x1e, 0xb4, 0x81,
-  0x3d, 0xc4, 0x81, 0x1c, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1c, 0xe0, 0x81,
-  0x1e, 0xc4, 0x81, 0x1c, 0xe0, 0x41, 0x1b, 0xd8, 0x43, 0x1c, 0xe4, 0x81,
-  0x1c, 0xe8, 0x81, 0x1c, 0xd4, 0x81, 0x1d, 0xe8, 0x81, 0x1c, 0xd4, 0x81,
-  0x1d, 0xb4, 0x81, 0x3d, 0xc8, 0x41, 0x1d, 0xd8, 0x81, 0x1e, 0xc8, 0x41,
-  0x1d, 0xd8, 0x81, 0x1e, 0xc8, 0x41, 0x1d, 0xd8, 0x41, 0x1b, 0xd8, 0x43,
-  0x1d, 0xc4, 0x81, 0x1c, 0xe8, 0x41, 0x1d, 0xc4, 0x81, 0x1c, 0xe8, 0x41,
-  0x1d, 0xc4, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xc4, 0x01, 0x1c, 0xc8, 0x01,
-  0x1d, 0xe8, 0x41, 0x1c, 0xc0, 0x81, 0x1c, 0xd0, 0x81, 0x1e, 0xc4, 0x01,
-  0x1c, 0xc8, 0x01, 0x1d, 0xb4, 0x81, 0x3b, 0xe0, 0x81, 0x1e, 0xc4, 0x81,
-  0x1d, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x46, 0x08, 0x43, 0x46, 0x6c, 0x57,
-  0xfe, 0xe7, 0x5b, 0xdb, 0x7f, 0x11, 0x01, 0x06, 0x43, 0x34, 0xd3, 0x90,
-  0x08, 0x88, 0x16, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
-  0x00, 0x18, 0x12, 0x45, 0x4d, 0x03, 0x04, 0x80, 0x00, 0x00, 0x00, 0x20,
-  0x00, 0x00, 0x00, 0x00, 0x43, 0x22, 0x6f, 0xa3, 0x80, 0x00, 0x18, 0x00,
-  0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x40, 0x62, 0x83, 0x40, 0xd1, 0xa7,
-  0x01, 0x00, 0x80, 0x2c, 0x10, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x32, 0x1e,
-  0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04,
-  0x43, 0x92, 0x45, 0x50, 0x02, 0x85, 0x30, 0x02, 0x50, 0x20, 0x65, 0x50,
-  0x80, 0x01, 0x05, 0x54, 0x60, 0xa5, 0x50, 0x0c, 0xa4, 0x47, 0x00, 0xe8,
-  0x8e, 0x25, 0x38, 0x02, 0x00, 0x00, 0xb1, 0x18, 0x00, 0x00, 0x7b, 0x00,
-  0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01,
-  0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78,
-  0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4,
-  0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c,
-  0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03,
-  0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70,
-  0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70,
-  0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec,
-  0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0,
-  0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d,
-  0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43,
-  0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0,
-  0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68,
-  0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28,
-  0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08,
-  0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee,
-  0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62,
-  0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c,
-  0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06,
-  0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43,
-  0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3,
-  0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3,
-  0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68,
-  0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce,
-  0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3,
-  0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d,
-  0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e,
-  0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51,
-  0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60,
-  0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98,
-  0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e,
-  0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e,
-  0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83,
-  0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2,
-  0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a,
-  0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28,
-  0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5,
-  0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17,
-  0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83,
-  0x3c, 0xb8, 0x81, 0x39, 0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3,
-  0x3b, 0xb8, 0xc3, 0x2f, 0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3,
-  0x3c, 0x00, 0x79, 0x20, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x32, 0x9a,
-  0x08, 0x14, 0x02, 0x85, 0x8c, 0x27, 0x46, 0x46, 0xc8, 0x11, 0x32, 0x64,
-  0xd4, 0xd6, 0x80, 0x0c, 0x76, 0x09, 0x8b, 0xe2, 0x06, 0xc5, 0xc6, 0x91,
-  0x41, 0x14, 0x19, 0x8c, 0x22, 0x31, 0x88, 0x94, 0x3d, 0x06, 0xa2, 0x3c,
-  0x12, 0x12, 0x5d, 0x03, 0x65, 0x18, 0x86, 0x61, 0x24, 0xc6, 0xa2, 0x60,
-  0x44, 0xb1, 0x1c, 0x01, 0x00, 0x00, 0x53, 0x44, 0x4b, 0x20, 0x56, 0x65,
-  0x72, 0x73, 0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68, 0x61, 0x72, 0x5f, 0x73,
-  0x69, 0x7a, 0x65, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x4c, 0x4c, 0x56,
-  0x4d, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x33, 0x31,
-  0x30, 0x30, 0x31, 0x2e, 0x34, 0x33, 0x20, 0x28, 0x6d, 0x65, 0x74, 0x61,
-  0x6c, 0x66, 0x65, 0x2d, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x34, 0x33,
-  0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f,
-  0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x64, 0x65, 0x6e, 0x6f, 0x72, 0x6d,
-  0x73, 0x5f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72,
-  0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73,
-  0x74, 0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c,
-  0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65,
-  0x2e, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72,
-  0x5f, 0x66, 0x65, 0x74, 0x63, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c,
-  0x65, 0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x5f,
-  0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72,
-  0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x66,
-  0x6c, 0x6f, 0x61, 0x74, 0x34, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x6f, 0x73,
-  0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x65, 0x6e,
-  0x74, 0x65, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x6e, 0x6f, 0x5f, 0x70, 0x65,
-  0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x61, 0x69, 0x72,
-  0x2e, 0x61, 0x72, 0x67, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x70, 0x6f, 0x73,
-  0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x72, 0x61,
-  0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x67,
-  0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x38, 0x74, 0x65,
-  0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x44, 0x76, 0x32, 0x5f, 0x66, 0x29,
-  0x61, 0x69, 0x72, 0x2e, 0x70, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74,
-  0x69, 0x76, 0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32, 0x74, 0x65, 0x78,
-  0x63, 0x6f, 0x6f, 0x72, 0x64, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66,
-  0x66, 0x65, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65,
-  0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x6c, 0x6f,
-  0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78,
-  0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x61, 0x64, 0x61, 0x69, 0x72, 0x2e,
-  0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x73, 0x69, 0x7a,
-  0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70,
-  0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65,
-  0x63, 0x6f, 0x6c, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x74, 0x72, 0x75, 0x63,
-  0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x66,
-  0x6c, 0x6f, 0x61, 0x74, 0x33, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x52,
-  0x63, 0x6f, 0x65, 0x66, 0x66, 0x47, 0x63, 0x6f, 0x65, 0x66, 0x66, 0x42,
-  0x63, 0x6f, 0x65, 0x66, 0x66, 0x59, 0x55, 0x56, 0x44, 0x65, 0x63, 0x6f,
-  0x64, 0x65, 0x64, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x61, 0x69, 0x72, 0x2e,
-  0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x73,
-  0x61, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65,
-  0x32, 0x64, 0x3c, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x2c, 0x20, 0x73, 0x61,
-  0x6d, 0x70, 0x6c, 0x65, 0x3e, 0x74, 0x65, 0x78, 0x59, 0x74, 0x65, 0x78,
-  0x55, 0x56, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65,
-  0x72, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73, 0x00, 0x64, 0x78,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x82, 0x20, 0x0d, 0x23, 0x08,
-  0xd7, 0x33, 0x82, 0x20, 0x11, 0x23, 0x08, 0x52, 0x31, 0x82, 0x20, 0x19,
-  0x23, 0x08, 0x0c, 0x30, 0x82, 0x20, 0x1d, 0x23, 0x08, 0x12, 0x32, 0x82,
-  0x20, 0x25, 0x23, 0x08, 0x92, 0x32, 0x82, 0x20, 0x2d, 0x23, 0x08, 0x12,
-  0x33, 0x82, 0x20, 0x35, 0x33, 0x0c, 0x6c, 0x10, 0xb4, 0xc1, 0x0c, 0x83,
-  0x1b, 0x08, 0x6f, 0x30, 0x43, 0x30, 0xcc, 0x30, 0xb0, 0x01, 0x1b, 0xc0,
-  0xc1, 0x0c, 0x04, 0xe1, 0x06, 0x6e, 0x00, 0x07, 0x33, 0x04, 0xc5, 0x0c,
-  0x81, 0x31, 0x43, 0x70, 0xcc, 0x50, 0x20, 0x70, 0x00, 0x07, 0x89, 0x32,
-  0x43, 0x10, 0x0a, 0x33, 0x20, 0x70, 0xb0, 0x30, 0x4d, 0xa2, 0x38, 0xcf,
-  0x0c, 0x89, 0x1b, 0x40, 0x11, 0x23, 0x25, 0x93, 0x43, 0xcd, 0x00, 0xb1,
-  0x41, 0x65, 0xc9, 0xc1, 0x05, 0x07, 0x6e, 0x80, 0x65, 0x72, 0xa0, 0xc9,
-  0x41, 0xa2, 0x38, 0xdb, 0x0c, 0x14, 0x1c, 0xc8, 0x01, 0x1c, 0x74, 0x9e,
-  0x1c, 0xc8, 0x01, 0x1c, 0x74, 0x5f, 0x1d, 0xc8, 0x01, 0x1c, 0x74, 0x60,
-  0x60, 0x07, 0x72, 0x00, 0x07, 0x5d, 0x18, 0xcc, 0x20, 0xcd, 0x41, 0x65,
-  0xd1, 0xc1, 0xe5, 0x06, 0x6e, 0x80, 0x71, 0xa6, 0x90, 0xd1, 0x81, 0x26,
-  0x07, 0x89, 0x18, 0x38, 0x63, 0x30, 0x83, 0xf2, 0x06, 0x64, 0x70, 0xc1,
-  0x81, 0x1b, 0x94, 0x41, 0x62, 0x06, 0xce, 0x19, 0xcc, 0xa0, 0xdc, 0x01,
-  0x19, 0x5c, 0x6e, 0xe0, 0x06, 0x65, 0x90, 0x98, 0x81, 0x83, 0x06, 0x33,
-  0x24, 0x78, 0x90, 0x06, 0x17, 0x1c, 0xb8, 0x41, 0xa2, 0x06, 0xce, 0x1a,
-  0xcc, 0x70, 0x8c, 0x02, 0x29, 0x94, 0xc2, 0x29, 0xa0, 0x42, 0x2a, 0xa8,
-  0xc2, 0x0c, 0x43, 0x1c, 0x88, 0xc2, 0x2a, 0x54, 0x18, 0x00, 0x1c, 0xc7,
-  0x71, 0x1c, 0xc7, 0x71, 0x1c, 0xc7, 0x71, 0x9c, 0x1b, 0xb8, 0x81, 0x45,
-  0x07, 0x7a, 0x60, 0x59, 0x96, 0x1e, 0x70, 0xa6, 0xc0, 0x0a, 0x34, 0xc1,
-  0x1b, 0x72, 0x61, 0x0f, 0xf6, 0xa0, 0x0e, 0xe4, 0x20, 0x23, 0x81, 0x09,
-  0xba, 0x88, 0x8d, 0xcd, 0xae, 0xcd, 0xa5, 0xed, 0x8d, 0xac, 0x8e, 0xad,
-  0xcc, 0xc5, 0x8c, 0x2d, 0xec, 0x6c, 0x6e, 0x14, 0x01, 0x0f, 0xf2, 0xe0,
-  0x14, 0x36, 0x36, 0xbb, 0x36, 0x97, 0x34, 0xb2, 0x32, 0x37, 0xba, 0x51,
-  0x02, 0x3d, 0xb8, 0x25, 0x2c, 0x4d, 0xce, 0xc5, 0xae, 0x4c, 0x6e, 0x2e,
-  0xed, 0xcd, 0x6d, 0x94, 0x60, 0x0f, 0x8e, 0x0a, 0x4b, 0x93, 0x73, 0x61,
-  0x0b, 0x73, 0x3b, 0xab, 0x0b, 0x3b, 0x2b, 0xfb, 0xb2, 0x2b, 0x93, 0x9b,
-  0x4b, 0x7b, 0x73, 0x1b, 0x25, 0xe0, 0x83, 0x9b, 0xc2, 0xd2, 0xe4, 0x5c,
-  0xc6, 0xde, 0xda, 0xe0, 0xd2, 0xd8, 0xca, 0xbe, 0xde, 0xe0, 0xe8, 0xd2,
-  0xde, 0xdc, 0xe6, 0x46, 0x19, 0xfa, 0xc0, 0x0f, 0xfe, 0xe0, 0x98, 0xb0,
-  0x34, 0x39, 0x17, 0x33, 0xb9, 0xb0, 0xb3, 0xb6, 0x32, 0x37, 0xba, 0x51,
-  0x82, 0x55, 0x00, 0x00, 0x00, 0x00, 0xa9, 0x18, 0x00, 0x00, 0x0b, 0x00,
-  0x00, 0x00, 0x0b, 0x0a, 0x72, 0x28, 0x87, 0x77, 0x80, 0x07, 0x7a, 0x58,
-  0x70, 0x98, 0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb0, 0x43, 0x39, 0xd0, 0xc3,
-  0x82, 0xe6, 0x1c, 0xc6, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0xc1, 0x1d,
-  0xe6, 0x21, 0x1d, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x00, 0xd1, 0x10,
-  0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0xcc, 0x3c, 0xa4, 0x83, 0x3b,
-  0x9c, 0x03, 0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83, 0x3c, 0x94, 0x43, 0x38,
-  0x90, 0xc3, 0x01, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x53, 0x00,
-  0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x0e, 0x00,
-  0x00, 0x00, 0x14, 0x6b, 0x60, 0x04, 0x80, 0xe4, 0x0c, 0x00, 0xcd, 0x11,
-  0x00, 0xc2, 0x63, 0x0d, 0x40, 0x20, 0xcc, 0x31, 0x18, 0x59, 0x36, 0xc7,
-  0x60, 0x10, 0xd9, 0x58, 0x03, 0x30, 0x10, 0x04, 0x46, 0x00, 0x66, 0x00,
-  0xc6, 0x08, 0x40, 0x10, 0x04, 0xf1, 0x8f, 0xc2, 0x0c, 0xc0, 0x1c, 0x04,
-  0x18, 0x80, 0x01, 0x18, 0x84, 0x01, 0x00, 0x00, 0x00, 0x00, 0xf1, 0x30,
-  0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x22, 0x47, 0xc8, 0x90, 0x51, 0x0a,
-  0x84, 0x18, 0x00, 0x00, 0x00, 0x00, 0xcf, 0x03, 0x00, 0x00, 0x6f, 0x6d,
-  0x6e, 0x69, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x68, 0x61,
-  0x72, 0x53, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x43, 0x2b, 0x2b, 0x20,
-  0x54, 0x42, 0x41, 0x41, 0x00, 0x00, 0x13, 0x04, 0xcd, 0xd9, 0x10, 0xb8,
-  0xc2, 0x86, 0xa1, 0x15, 0x60, 0xe1, 0x15, 0x36, 0x0c, 0xb1, 0x10, 0x0b,
-  0xaf, 0x00, 0x23, 0x06, 0xcd, 0x10, 0x82, 0x60, 0x40, 0x89, 0x01, 0xe4,
-  0x4c, 0x8d, 0xc2, 0x14, 0x85, 0x37, 0x9a, 0x10, 0x00, 0x83, 0x0c, 0x01,
-  0xa1, 0x8c, 0x18, 0x34, 0x43, 0x08, 0x82, 0x01, 0x55, 0x06, 0x52, 0x64,
-  0x41, 0xcd, 0x83, 0x20, 0x61, 0x30, 0x9a, 0x10, 0x00, 0x83, 0x0c, 0xc1,
-  0xc1, 0x0c, 0x32, 0x10, 0x01, 0x73, 0x58, 0x5e, 0x0a, 0x42, 0x19, 0x64,
-  0x08, 0x16, 0xc9, 0x88, 0x00, 0xfc, 0xa9, 0x0b, 0x65, 0x97, 0xa1, 0x13,
-  0x03, 0x36, 0xb8, 0x20, 0x2f, 0x05, 0xa1, 0x0c, 0x32, 0x04, 0x11, 0x36,
-  0x62, 0x70, 0x08, 0x21, 0x08, 0x16, 0xfe, 0xd1, 0xcc, 0x81, 0x11, 0xec,
-  0x32, 0x88, 0xc1, 0x19, 0xc8, 0xc1, 0x05, 0x79, 0x29, 0x08, 0x65, 0x90,
-  0x21, 0xb0, 0xba, 0x11, 0x83, 0x43, 0x08, 0x41, 0xb0, 0xf0, 0x8f, 0x06,
-  0x0f, 0x96, 0x60, 0x97, 0xe1, 0x0c, 0xd8, 0x40, 0x0e, 0x2e, 0xc8, 0x4b,
-  0x41, 0x28, 0x83, 0x0c, 0xc1, 0x26, 0x06, 0x23, 0x06, 0x87, 0x10, 0x82,
-  0x60, 0xe1, 0x1f, 0x4d, 0x1f, 0x40, 0xc1, 0x1c, 0x03, 0xb7, 0xe4, 0xc1,
-  0x1c, 0x43, 0x70, 0xf0, 0xc1, 0x1c, 0x43, 0x30, 0xf8, 0x81, 0x05, 0x93,
-  0xf8, 0x67, 0x10, 0x10, 0x03, 0x00, 0x02, 0x00, 0x00, 0x00, 0x5b, 0x86,
-  0x25, 0x88, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20,
-  0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x32, 0x0e, 0x10, 0x22, 0x84, 0x00,
-  0xfa, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x0c,
-  0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0x38, 0x01, 0x00,
-  0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x08, 0x00,
-  0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x03, 0x00,
-  0x00, 0x00, 0x98, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, 0x00,
-  0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00,
-  0x00, 0x00, 0x61, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00,
-  0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x24, 0x00, 0x00, 0x11, 0x00,
-  0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x0d, 0x00,
-  0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x1e, 0x00,
-  0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1b, 0x00,
-  0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x5d, 0x0c, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x12, 0x03,
-  0x94, 0xe1, 0x00, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x4e, 0x56,
-  0x31, 0x32, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x61,
-  0x69, 0x72, 0x2e, 0x64, 0x6f, 0x74, 0x2e, 0x76, 0x33, 0x66, 0x33, 0x32,
-  0x61, 0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x74,
-  0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x5f, 0x32, 0x64, 0x2e, 0x76, 0x34,
-  0x66, 0x33, 0x32, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x34, 0x33, 0x61,
+  0x59, 0x74, 0x65, 0x78, 0x55, 0x56, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x61,
+  0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72,
+  0x73, 0x00, 0x00, 0x00, 0x44, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x30, 0x82, 0x10, 0x0d, 0x23, 0x08, 0x96, 0x33, 0x82, 0x10, 0x11, 0x23,
+  0x08, 0x51, 0x31, 0x82, 0x10, 0x19, 0x23, 0x08, 0x0b, 0x30, 0x82, 0x10,
+  0x1d, 0x23, 0x08, 0x11, 0x32, 0x82, 0x10, 0x25, 0x23, 0x08, 0x91, 0x32,
+  0x82, 0x10, 0x2d, 0x23, 0x08, 0x11, 0x33, 0x82, 0x10, 0x35, 0x33, 0x0c,
+  0x6d, 0x10, 0xb8, 0xc1, 0x0c, 0xc3, 0x1b, 0x08, 0x70, 0x30, 0x43, 0x30,
+  0xcc, 0x30, 0xb4, 0x41, 0x1b, 0xc4, 0xc1, 0x0c, 0x04, 0xf1, 0x06, 0x6f,
+  0x10, 0x07, 0x33, 0x04, 0xc5, 0x0c, 0x81, 0x31, 0x43, 0x70, 0xcc, 0x50,
+  0x20, 0x71, 0x10, 0x07, 0x89, 0x32, 0x43, 0x20, 0x0a, 0x33, 0x20, 0x71,
+  0xb0, 0x30, 0x4d, 0xa2, 0x38, 0xcf, 0x0c, 0xc9, 0x1b, 0x40, 0x11, 0x23,
+  0x25, 0x8a, 0x33, 0xcd, 0x90, 0xb4, 0x01, 0x44, 0x31, 0x52, 0x52, 0x39,
+  0xd6, 0x0c, 0x54, 0x1c, 0xd4, 0x41, 0x1c, 0x70, 0x5d, 0x1d, 0xd4, 0x41,
+  0x1c, 0x70, 0x9e, 0x1d, 0xd4, 0x41, 0x1c, 0x70, 0xdf, 0x1d, 0xd4, 0x41,
+  0x1c, 0x70, 0x60, 0x30, 0x83, 0x34, 0x07, 0x17, 0x46, 0x07, 0xd9, 0x1b,
+  0xbc, 0x81, 0xb6, 0x9d, 0x42, 0x18, 0xd0, 0x81, 0x18, 0xd4, 0x41, 0x32,
+  0x06, 0x0e, 0x19, 0xcc, 0xa0, 0xc0, 0x41, 0x19, 0x64, 0x71, 0xf0, 0x06,
+  0x66, 0x90, 0x9c, 0x81, 0x83, 0x06, 0x33, 0x28, 0x78, 0x50, 0x06, 0xd9,
+  0x1b, 0xbc, 0x81, 0x19, 0x24, 0x67, 0xe0, 0xa4, 0xc1, 0x0c, 0x49, 0x1e,
+  0xa8, 0x41, 0x16, 0x07, 0x6f, 0x90, 0xac, 0x81, 0xc3, 0x06, 0x33, 0x1c,
+  0xa4, 0x50, 0x0a, 0xa6, 0x80, 0x0a, 0xa9, 0xa0, 0x0a, 0xab, 0x30, 0xc3,
+  0x20, 0x07, 0xa3, 0xc0, 0x0a, 0x15, 0x06, 0x00, 0xc7, 0x71, 0x1c, 0xc7,
+  0x71, 0x1c, 0xc7, 0x71, 0x1c, 0xe7, 0x06, 0x6e, 0x60, 0xd1, 0x81, 0x1e,
+  0x58, 0x96, 0xa5, 0x07, 0x9c, 0x29, 0xb0, 0x02, 0x2b, 0xd8, 0x86, 0x5f,
+  0xd8, 0x83, 0x3d, 0xa8, 0x03, 0x39, 0xc8, 0x48, 0x60, 0x82, 0x2e, 0x62,
+  0x63, 0xb3, 0x6b, 0x73, 0x69, 0x7b, 0x23, 0xab, 0x63, 0x2b, 0x73, 0x31,
+  0x63, 0x0b, 0x3b, 0x9b, 0x1b, 0x45, 0xc8, 0x03, 0x3d, 0x38, 0x85, 0x8d,
+  0xcd, 0xae, 0xcd, 0x25, 0x8d, 0xac, 0xcc, 0x8d, 0x6e, 0x94, 0x60, 0x0f,
+  0x6e, 0x09, 0x4b, 0x93, 0x73, 0xb1, 0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73,
+  0x1b, 0x25, 0xe0, 0x83, 0xa3, 0xc2, 0xd2, 0xe4, 0x5c, 0xd8, 0xc2, 0xdc,
+  0xce, 0xea, 0xc2, 0xce, 0xca, 0xbe, 0xec, 0xca, 0xe4, 0xe6, 0xd2, 0xde,
+  0xdc, 0x46, 0x09, 0xfa, 0xe0, 0xa6, 0xb0, 0x34, 0x39, 0x97, 0xb1, 0xb7,
+  0x36, 0xb8, 0x34, 0xb6, 0xb2, 0xaf, 0x37, 0x38, 0xba, 0xb4, 0x37, 0xb7,
+  0xb9, 0x51, 0x06, 0x3f, 0xf8, 0x03, 0x50, 0x38, 0x26, 0x2c, 0x4d, 0xce,
+  0xc5, 0x4c, 0x2e, 0xec, 0xac, 0xad, 0xcc, 0x8d, 0x6e, 0x94, 0x80, 0x15,
+  0x00, 0x00, 0x00, 0x00, 0xa9, 0x18, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
+  0x0b, 0x0a, 0x72, 0x28, 0x87, 0x77, 0x80, 0x07, 0x7a, 0x58, 0x70, 0x98,
+  0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb0, 0x43, 0x39, 0xd0, 0xc3, 0x82, 0xe6,
+  0x1c, 0xc6, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0xc1, 0x1d, 0xe6, 0x21,
+  0x1d, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x00, 0xd1, 0x10, 0x00, 0x00,
+  0x06, 0x00, 0x00, 0x00, 0x07, 0xcc, 0x3c, 0xa4, 0x83, 0x3b, 0x9c, 0x03,
+  0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83, 0x3c, 0x94, 0x43, 0x38, 0x90, 0xc3,
+  0x01, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00,
+  0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+  0x04, 0x6b, 0x60, 0x04, 0x80, 0xe2, 0x0c, 0x00, 0xc9, 0x11, 0x80, 0xb1,
+  0x84, 0x00, 0xa0, 0x3b, 0xd6, 0x00, 0x04, 0xc2, 0x1c, 0x83, 0x81, 0x61,
+  0x73, 0x0c, 0x06, 0x81, 0x8d, 0x35, 0x00, 0x03, 0x41, 0x79, 0x04, 0x80,
+  0xc0, 0x08, 0xc0, 0x0c, 0xc0, 0x18, 0x01, 0x08, 0x82, 0x20, 0xfe, 0x51,
+  0x98, 0x01, 0x98, 0x83, 0x08, 0x83, 0x30, 0x08, 0x03, 0x31, 0x20, 0x31,
+  0x03, 0x00, 0x00, 0x00, 0x23, 0x06, 0xcd, 0x10, 0x82, 0x60, 0x30, 0x91,
+  0xc1, 0x14, 0x55, 0x50, 0xf3, 0x18, 0x06, 0x18, 0x8c, 0x26, 0x04, 0xc0,
+  0x20, 0x43, 0x50, 0x30, 0x23, 0x06, 0xcd, 0x10, 0x82, 0x60, 0x30, 0x9d,
+  0x41, 0x45, 0x61, 0x13, 0x24, 0x25, 0xc9, 0x18, 0x8c, 0x26, 0x04, 0xc0,
+  0x20, 0x43, 0x80, 0x44, 0x83, 0x0c, 0xc1, 0xf1, 0x0c, 0x32, 0x14, 0xc1,
+  0x73, 0x1c, 0x5e, 0x0a, 0x42, 0x19, 0x64, 0x08, 0x9a, 0xca, 0x88, 0x00,
+  0xfc, 0x37, 0x19, 0xc0, 0x60, 0x72, 0x83, 0x0b, 0xf0, 0x52, 0x10, 0xca,
+  0x20, 0x43, 0x20, 0x69, 0x23, 0x06, 0x87, 0x10, 0x82, 0x60, 0xe1, 0x1f,
+  0x4c, 0x1d, 0x14, 0xc1, 0x26, 0x43, 0x19, 0x60, 0x74, 0x70, 0x01, 0x5e,
+  0x0a, 0x42, 0x19, 0x64, 0x08, 0xae, 0x6f, 0xc4, 0xe0, 0x10, 0x42, 0x10,
+  0x2c, 0xfc, 0x83, 0xd1, 0x03, 0x25, 0xd8, 0x64, 0x50, 0x83, 0xae, 0x0e,
+  0x2e, 0xc0, 0x4b, 0x41, 0x28, 0x83, 0x0c, 0x01, 0x47, 0x06, 0x23, 0x06,
+  0x87, 0x10, 0x82, 0x60, 0xe1, 0x1f, 0xcc, 0x1f, 0x3c, 0xc1, 0x1c, 0x43,
+  0xb7, 0xec, 0xc1, 0x1c, 0x43, 0x70, 0xf8, 0xc1, 0x1c, 0x43, 0x30, 0x80,
+  0x82, 0x05, 0x74, 0x20, 0xfe, 0x19, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x32, 0x0e, 0x10, 0x22, 0x84, 0x00, 0xfb, 0x05,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x0c, 0x00, 0x00,
+  0x29, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0x38, 0x01, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+  0x44, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x98, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x43, 0x00, 0x00, 0x00,
+  0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+  0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+  0xff, 0xff, 0xff, 0xff, 0x00, 0x24, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+  0x0d, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00,
+  0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+  0x1b, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00,
+  0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x5d, 0x0c, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0xe3,
+  0x00, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x4e, 0x56, 0x32, 0x31,
+  0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x69, 0x72,
+  0x2e, 0x64, 0x6f, 0x74, 0x2e, 0x76, 0x33, 0x66, 0x33, 0x32, 0x61, 0x69,
+  0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x74, 0x65, 0x78,
+  0x74, 0x75, 0x72, 0x65, 0x5f, 0x32, 0x64, 0x2e, 0x76, 0x34, 0x66, 0x33,
+  0x32, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x35, 0x30, 0x2e, 0x31, 0x61,
   0x69, 0x72, 0x36, 0x34, 0x2d, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2d, 0x74,
   0x76, 0x6f, 0x73, 0x31, 0x33, 0x2e, 0x30, 0x2e, 0x30, 0x2d, 0x73, 0x69,
   0x6d, 0x75, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00,
-  0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x84, 0x0e, 0x00, 0x00, 0xff, 0xff,
-  0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x35, 0x14, 0x00, 0x00, 0x03, 0x00,
-  0x00, 0x00, 0x62, 0x0c, 0x30, 0x24, 0x80, 0x10, 0x05, 0xc8, 0x14, 0x00,
-  0x00, 0x00, 0x21, 0x0c, 0x00, 0x00, 0x50, 0x03, 0x00, 0x00, 0x0b, 0x02,
-  0x21, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x07, 0x81,
-  0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01,
-  0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14,
-  0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08,
-  0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88, 0x48, 0x90, 0x14, 0x20, 0x43, 0x46,
-  0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0x04, 0x49, 0x0e, 0x90, 0x91, 0x22,
-  0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x29,
-  0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x94, 0x00, 0x00, 0x00, 0x1b, 0xcc,
-  0x25, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x58, 0x03, 0x40, 0x02, 0x2a,
-  0x62, 0x1c, 0xde, 0x41, 0x1e, 0xe4, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xd8,
-  0x21, 0x1f, 0xda, 0x40, 0x1e, 0xde, 0xa1, 0x1e, 0xdc, 0x81, 0x1c, 0xca,
-  0x81, 0x1c, 0xda, 0x80, 0x1c, 0xd2, 0xc1, 0x1e, 0xd2, 0x81, 0x1c, 0xca,
-  0xa1, 0x0d, 0xe6, 0x21, 0x1e, 0xe4, 0x81, 0x1e, 0xda, 0xc0, 0x1c, 0xe0,
-  0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x73, 0x08, 0x07,
-  0x76, 0x98, 0x87, 0x72, 0x00, 0x08, 0x72, 0x48, 0x87, 0x79, 0x08, 0x07,
-  0x71, 0x60, 0x87, 0x72, 0x68, 0x03, 0x7a, 0x08, 0x87, 0x74, 0x60, 0x87,
-  0x36, 0x18, 0x87, 0x70, 0x60, 0x07, 0x76, 0x98, 0x07, 0xc0, 0x1c, 0xc2,
-  0x81, 0x1d, 0xe6, 0xa1, 0x1c, 0x00, 0x82, 0x1d, 0xca, 0x61, 0x1e, 0xe6,
-  0xa1, 0x0d, 0xe0, 0x41, 0x1e, 0xca, 0x61, 0x1c, 0xd2, 0x61, 0x1e, 0xca,
-  0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0x21, 0x1c, 0xc8, 0x01, 0x30, 0x87,
-  0x70, 0x60, 0x87, 0x79, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03,
-  0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78, 0x78, 0x87,
-  0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72, 0x60, 0x87,
-  0x74, 0x68, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x18, 0xdc,
-  0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda,
-  0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda,
-  0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0xa1, 0x0d, 0xdc, 0xe1, 0x1d, 0xdc,
-  0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xc2, 0xc1, 0x1c, 0x00, 0xc2, 0x1d, 0xde,
-  0xa1, 0x0d, 0xd2, 0xc1, 0x1d, 0xcc, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0,
-  0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87,
-  0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x75, 0xa8, 0x87,
-  0x76, 0x80, 0x87, 0x36, 0xa0, 0x87, 0x70, 0x10, 0x07, 0x76, 0x28, 0x87,
-  0x79, 0x00, 0xcc, 0x21, 0x1c, 0xd8, 0x61, 0x1e, 0xca, 0x01, 0x20, 0xdc,
-  0xe1, 0x1d, 0xda, 0xc0, 0x1d, 0xc2, 0xc1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc,
-  0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07,
-  0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x98, 0x87,
-  0x74, 0x38, 0x07, 0x77, 0x28, 0x07, 0x72, 0x68, 0x03, 0x7d, 0x28, 0x07,
-  0x79, 0x78, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87,
-  0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00,
-  0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0x01, 0x1e, 0xe0,
-  0x21, 0x1d, 0xdc, 0xe1, 0x1c, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0,
-  0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x88, 0x79, 0xa0, 0x87,
-  0x70, 0x18, 0x87, 0x75, 0x68, 0x03, 0x78, 0x90, 0x87, 0x77, 0xa0, 0x87,
-  0x72, 0x18, 0x07, 0x7a, 0x78, 0x07, 0x79, 0x68, 0x03, 0x71, 0xa8, 0x07,
-  0x73, 0x30, 0x87, 0x72, 0x90, 0x87, 0x36, 0x98, 0x87, 0x74, 0xd0, 0x87,
-  0x72, 0x00, 0xf0, 0x00, 0x20, 0xea, 0xc1, 0x1d, 0xe6, 0x21, 0x1c, 0xcc,
-  0xa1, 0x1c, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8,
-  0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0xa8, 0x87,
-  0x79, 0x28, 0x87, 0x36, 0x98, 0x87, 0x77, 0x30, 0x07, 0x7a, 0x68, 0x03,
-  0x73, 0x60, 0x87, 0x77, 0x08, 0x07, 0x7a, 0x00, 0xcc, 0x21, 0x1c, 0xd8,
-  0x61, 0x1e, 0xca, 0x01, 0xd8, 0xb0, 0x08, 0x03, 0x90, 0x00, 0x0b, 0x50,
-  0x05, 0x69, 0x00, 0x6d, 0x58, 0x06, 0x02, 0x48, 0x80, 0x05, 0xa8, 0x82,
-  0x34, 0x00, 0x85, 0x0d, 0x06, 0x51, 0x00, 0x0b, 0x50, 0x6d, 0x30, 0x0a,
-  0x03, 0x58, 0x80, 0x6a, 0x83, 0x61, 0x1c, 0xc0, 0x02, 0x54, 0x1b, 0x8c,
-  0xe3, 0xff, 0xff, 0xff, 0xff, 0x07, 0x40, 0x02, 0xa8, 0x0d, 0x0a, 0xf2,
-  0xff, 0xff, 0xff, 0xff, 0x03, 0xd0, 0x06, 0xc0, 0x1a, 0x00, 0x12, 0x50,
-  0x6d, 0x30, 0x92, 0x00, 0x58, 0x80, 0x6a, 0x83, 0xa1, 0x08, 0xc0, 0x02,
-  0x54, 0x00, 0x49, 0x18, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x13, 0x8c,
-  0x40, 0x18, 0x88, 0xc2, 0x98, 0x10, 0x1c, 0x13, 0x06, 0x24, 0x51, 0x00,
-  0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x32, 0x22,
-  0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93,
-  0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84,
-  0xa4, 0x4c, 0x10, 0x74, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20,
-  0x00, 0x83, 0x08, 0x41, 0x30, 0x8c, 0x30, 0x00, 0x07, 0x49, 0x53, 0x44,
-  0x09, 0x93, 0x2f, 0xbb, 0x6f, 0x47, 0x08, 0xce, 0x40, 0x20, 0x82, 0x10,
-  0x42, 0x06, 0x11, 0x0a, 0xe1, 0x28, 0x69, 0x8a, 0x28, 0x61, 0xf2, 0xff,
-  0x89, 0xb8, 0x26, 0x2a, 0x22, 0x7e, 0x7b, 0xf8, 0xa7, 0x31, 0x02, 0x60,
-  0x10, 0xe1, 0x08, 0x2e, 0x92, 0xa6, 0x88, 0x12, 0x26, 0xff, 0x97, 0x00,
-  0xe6, 0x59, 0x88, 0xe8, 0x9f, 0xc6, 0x08, 0x80, 0x41, 0x84, 0x44, 0x28,
-  0x48, 0x08, 0x62, 0x18, 0x84, 0x14, 0xad, 0x32, 0x00, 0x42, 0xa8, 0xcd,
-  0x11, 0x20, 0x46, 0x08, 0x6f, 0x8e, 0x20, 0x98, 0x23, 0x00, 0x83, 0x61,
-  0x04, 0x41, 0x2a, 0x0a, 0x44, 0x4a, 0xc4, 0x19, 0x01, 0x90, 0x44, 0x07,
-  0x02, 0x52, 0x40, 0x0e, 0x23, 0x0c, 0xd2, 0x20, 0x42, 0x20, 0xcc, 0x11,
-  0x80, 0xc2, 0x20, 0x02, 0x21, 0x8c, 0x00, 0x00, 0x00, 0x00, 0x13, 0xc0,
-  0x20, 0x1c, 0xd2, 0x41, 0x1e, 0xec, 0x80, 0x0e, 0xda, 0x20, 0x1c, 0xe0,
-  0x01, 0x1e, 0xd8, 0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xec, 0xe1, 0x1d, 0xe6,
-  0x21, 0x0e, 0xe6, 0xc0, 0x0d, 0xe0, 0xc0, 0x0d, 0xe0, 0xa0, 0x0d, 0xe6,
-  0x21, 0x1d, 0xda, 0xa1, 0x1e, 0xd8, 0x21, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4,
-  0x61, 0xc3, 0x6d, 0x94, 0x43, 0x1b, 0xc0, 0x83, 0x1e, 0xd8, 0x01, 0x1d,
-  0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x41, 0x3a,
-  0xc4, 0x81, 0x1e, 0xe0, 0x81, 0x1e, 0xe0, 0x41, 0x1b, 0xa4, 0x03, 0x1e,
-  0xe8, 0x01, 0x1e, 0xe8, 0x01, 0x1e, 0xb4, 0x41, 0x3a, 0xc4, 0x81, 0x1d,
-  0xe8, 0x41, 0x1c, 0xd8, 0x81, 0x1e, 0xc4, 0x81, 0x1d, 0xb4, 0x41, 0x3a,
-  0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c,
-  0xb4, 0x41, 0x3a, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e,
-  0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x39, 0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c,
-  0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x39, 0xd8, 0x01, 0x1d,
-  0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d,
-  0xc4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xd8, 0x81, 0x1e, 0xc4, 0x81, 0x1d,
-  0xb4, 0x81, 0x3d, 0xc8, 0x01, 0x1d, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e,
-  0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c,
-  0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xd0, 0x01, 0x1e,
-  0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d,
-  0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d,
-  0xb4, 0x81, 0x3d, 0xe4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xc8, 0x01, 0x1e,
-  0xe8, 0x41, 0x1c, 0xc8, 0x01, 0x1e, 0xb4, 0x81, 0x3d, 0xc4, 0x81, 0x1c,
-  0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1c, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1c,
-  0xe0, 0x41, 0x1b, 0xd8, 0x43, 0x1c, 0xe4, 0x81, 0x1c, 0xe8, 0x81, 0x1c,
-  0xd4, 0x81, 0x1d, 0xe8, 0x81, 0x1c, 0xd4, 0x81, 0x1d, 0xb4, 0x81, 0x3d,
-  0xc8, 0x41, 0x1d, 0xd8, 0x81, 0x1e, 0xc8, 0x41, 0x1d, 0xd8, 0x81, 0x1e,
-  0xc8, 0x41, 0x1d, 0xd8, 0x41, 0x1b, 0xd8, 0x43, 0x1d, 0xc4, 0x81, 0x1c,
-  0xe8, 0x41, 0x1d, 0xc4, 0x81, 0x1c, 0xe8, 0x41, 0x1d, 0xc4, 0x81, 0x1c,
-  0xb4, 0x81, 0x3d, 0xc4, 0x01, 0x1c, 0xc8, 0x01, 0x1d, 0xe8, 0x41, 0x1c,
-  0xc0, 0x81, 0x1c, 0xd0, 0x81, 0x1e, 0xc4, 0x01, 0x1c, 0xc8, 0x01, 0x1d,
-  0xb4, 0x81, 0x3b, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1d, 0xe8, 0xc1, 0x1c,
-  0xc8, 0x81, 0x46, 0x08, 0x43, 0x46, 0x6c, 0x57, 0xfe, 0xe7, 0x6b, 0xd7,
-  0x7f, 0x11, 0x01, 0x06, 0x43, 0x34, 0xd3, 0x90, 0x08, 0x88, 0x16, 0x00,
-  0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18, 0x12, 0x45,
-  0x4d, 0x03, 0x04, 0x80, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00,
-  0x43, 0x22, 0x6f, 0xa3, 0x80, 0x00, 0x18, 0x00, 0x00, 0x00, 0x04, 0x00,
-  0x00, 0x00, 0x40, 0x62, 0x83, 0x40, 0x51, 0xa9, 0x01, 0x00, 0x80, 0x2c,
-  0x10, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x14, 0x19, 0x11,
-  0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x92, 0x45, 0x50,
-  0x02, 0x85, 0x30, 0x02, 0x50, 0x20, 0x65, 0x50, 0x80, 0x01, 0x05, 0x54,
-  0x60, 0xa5, 0x50, 0x0c, 0xa4, 0x47, 0x00, 0xe8, 0x8e, 0x25, 0x38, 0x02,
-  0x00, 0x00, 0xb1, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x33, 0x08,
-  0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38,
-  0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71,
-  0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c,
-  0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d,
-  0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d,
-  0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07,
-  0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87,
-  0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30,
-  0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10,
-  0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66,
-  0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c,
-  0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07,
-  0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87,
-  0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05,
-  0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87,
-  0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0,
-  0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4,
-  0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca,
-  0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39,
-  0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38,
-  0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c,
-  0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87,
-  0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87,
-  0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00,
-  0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20,
-  0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2,
-  0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4,
-  0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a,
-  0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07,
-  0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90,
-  0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8,
-  0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc,
-  0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b,
-  0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b,
-  0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87,
-  0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81,
-  0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30,
-  0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde,
-  0x01, 0x1e, 0x66, 0x50, 0x59, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39,
-  0xd4, 0x83, 0x3b, 0x8c, 0x03, 0x3d, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x2f,
-  0x9c, 0x83, 0x3c, 0xbc, 0x43, 0x3d, 0xc0, 0xc3, 0x3c, 0x00, 0x79, 0x20,
-  0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x32, 0x9a, 0x08, 0x14, 0x02, 0x85,
-  0x8c, 0x27, 0x46, 0x46, 0xc8, 0x11, 0x32, 0x64, 0xd4, 0xd6, 0x80, 0x0c,
-  0x76, 0x09, 0x8b, 0xe2, 0x06, 0xc5, 0xc6, 0x91, 0x41, 0x14, 0x19, 0x8c,
-  0x22, 0x31, 0x88, 0x94, 0x3d, 0x06, 0xa2, 0x3c, 0x12, 0x12, 0x5d, 0x03,
-  0x65, 0x18, 0x86, 0x61, 0x24, 0xc6, 0xa2, 0x60, 0x44, 0xb1, 0x1c, 0x01,
-  0x00, 0x00, 0x53, 0x44, 0x4b, 0x20, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f,
-  0x6e, 0x77, 0x63, 0x68, 0x61, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x41,
-  0x70, 0x70, 0x6c, 0x65, 0x20, 0x4c, 0x4c, 0x56, 0x4d, 0x20, 0x76, 0x65,
-  0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x33, 0x31, 0x30, 0x30, 0x31, 0x2e,
-  0x34, 0x33, 0x20, 0x28, 0x6d, 0x65, 0x74, 0x61, 0x6c, 0x66, 0x65, 0x2d,
-  0x33, 0x31, 0x30, 0x30, 0x31, 0x2e, 0x34, 0x33, 0x29, 0x4d, 0x65, 0x74,
-  0x61, 0x6c, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c,
-  0x65, 0x2e, 0x64, 0x65, 0x6e, 0x6f, 0x72, 0x6d, 0x73, 0x5f, 0x64, 0x69,
-  0x73, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d,
-  0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61,
-  0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72,
-  0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x72, 0x61,
-  0x6d, 0x65, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x66, 0x65, 0x74,
-  0x63, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72,
-  0x2e, 0x72, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x5f, 0x74, 0x61, 0x72, 0x67,
-  0x65, 0x74, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79,
-  0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74,
-  0x34, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f,
-  0x6e, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x61,
-  0x69, 0x72, 0x2e, 0x6e, 0x6f, 0x5f, 0x70, 0x65, 0x72, 0x73, 0x70, 0x65,
-  0x63, 0x74, 0x69, 0x76, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67,
-  0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f,
-  0x6e, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e,
-  0x74, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x67, 0x65, 0x6e, 0x65, 0x72,
-  0x61, 0x74, 0x65, 0x64, 0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f,
-  0x72, 0x64, 0x44, 0x76, 0x32, 0x5f, 0x66, 0x29, 0x61, 0x69, 0x72, 0x2e,
-  0x70, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x66,
-  0x6c, 0x6f, 0x61, 0x74, 0x32, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72,
-  0x64, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x61,
-  0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69,
-  0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69,
-  0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x61, 0x69, 0x72, 0x2e,
-  0x72, 0x65, 0x61, 0x64, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f,
-  0x74, 0x79, 0x70, 0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72,
-  0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x61, 0x6c,
-  0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x63, 0x6f, 0x6c, 0x61,
-  0x69, 0x72, 0x2e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x5f, 0x74, 0x79,
-  0x70, 0x65, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x66, 0x6c, 0x6f, 0x61, 0x74,
-  0x33, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x52, 0x63, 0x6f, 0x65, 0x66,
-  0x66, 0x47, 0x63, 0x6f, 0x65, 0x66, 0x66, 0x42, 0x63, 0x6f, 0x65, 0x66,
-  0x66, 0x59, 0x55, 0x56, 0x44, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x65,
-  0x63, 0x6f, 0x64, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x74, 0x65, 0x78, 0x74,
-  0x75, 0x72, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c,
-  0x65, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x32, 0x64, 0x3c, 0x66,
-  0x6c, 0x6f, 0x61, 0x74, 0x2c, 0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65,
-  0x3e, 0x74, 0x65, 0x78, 0x59, 0x74, 0x65, 0x78, 0x55, 0x56, 0x61, 0x69,
-  0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73, 0x61, 0x6d,
-  0x70, 0x6c, 0x65, 0x72, 0x73, 0x00, 0x64, 0x78, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x30, 0x82, 0x20, 0x0d, 0x23, 0x08, 0xd7, 0x33, 0x82, 0x20,
-  0x11, 0x23, 0x08, 0x52, 0x31, 0x82, 0x20, 0x19, 0x23, 0x08, 0x0c, 0x30,
-  0x82, 0x20, 0x1d, 0x23, 0x08, 0x12, 0x32, 0x82, 0x20, 0x25, 0x23, 0x08,
-  0x92, 0x32, 0x82, 0x20, 0x2d, 0x23, 0x08, 0x12, 0x33, 0x82, 0x20, 0x35,
-  0x33, 0x0c, 0x6c, 0x10, 0xb4, 0xc1, 0x0c, 0x83, 0x1b, 0x08, 0x6f, 0x30,
-  0x43, 0x30, 0xcc, 0x30, 0xb0, 0x01, 0x1b, 0xc0, 0xc1, 0x0c, 0x04, 0xe1,
-  0x06, 0x6e, 0x00, 0x07, 0x33, 0x04, 0xc5, 0x0c, 0x81, 0x31, 0x43, 0x70,
-  0xcc, 0x50, 0x20, 0x70, 0x00, 0x07, 0x89, 0x32, 0x43, 0x10, 0x0a, 0x33,
-  0x20, 0x70, 0xb0, 0x30, 0x4d, 0xa2, 0x38, 0xcf, 0x0c, 0x89, 0x1b, 0x40,
-  0x11, 0x23, 0x25, 0x93, 0x43, 0xcd, 0x00, 0xb1, 0x41, 0x65, 0xc9, 0xc1,
-  0x05, 0x07, 0x6e, 0x80, 0x65, 0x72, 0xa0, 0xc9, 0x41, 0xa2, 0x38, 0xdb,
-  0x0c, 0x14, 0x1c, 0xc8, 0x01, 0x1c, 0x74, 0x9e, 0x1c, 0xc8, 0x01, 0x1c,
-  0x74, 0x5f, 0x1d, 0xc8, 0x01, 0x1c, 0x74, 0x60, 0x60, 0x07, 0x72, 0x00,
-  0x07, 0x5d, 0x18, 0xcc, 0x20, 0xcd, 0x41, 0x65, 0xd1, 0xc1, 0xe5, 0x06,
-  0x6e, 0x80, 0x71, 0xa6, 0x90, 0xd1, 0x81, 0x26, 0x07, 0x89, 0x18, 0x38,
-  0x63, 0x30, 0x83, 0xf2, 0x06, 0x64, 0x70, 0xc1, 0x81, 0x1b, 0x94, 0x41,
-  0x62, 0x06, 0xce, 0x19, 0xcc, 0xa0, 0xdc, 0x01, 0x19, 0x5c, 0x6e, 0xe0,
-  0x06, 0x65, 0x90, 0x98, 0x81, 0x83, 0x06, 0x33, 0x24, 0x78, 0x90, 0x06,
-  0x17, 0x1c, 0xb8, 0x41, 0xa2, 0x06, 0xce, 0x1a, 0xcc, 0x70, 0x8c, 0x02,
-  0x29, 0x94, 0xc2, 0x29, 0xa0, 0x42, 0x2a, 0xa8, 0xc2, 0x0c, 0x43, 0x1c,
-  0x88, 0xc2, 0x2a, 0x54, 0x18, 0x00, 0x1c, 0xc7, 0x71, 0x1c, 0xc7, 0x71,
-  0x1c, 0xc7, 0x71, 0x9c, 0x1b, 0xb8, 0x81, 0x45, 0x07, 0x7a, 0x60, 0x59,
-  0x96, 0x1e, 0x70, 0xa6, 0xc0, 0x0a, 0x34, 0xc1, 0x1b, 0x72, 0x61, 0x0f,
-  0xf6, 0xa0, 0x0e, 0xe4, 0x20, 0x23, 0x81, 0x09, 0xba, 0x88, 0x8d, 0xcd,
-  0xae, 0xcd, 0xa5, 0xed, 0x8d, 0xac, 0x8e, 0xad, 0xcc, 0xc5, 0x8c, 0x2d,
-  0xec, 0x6c, 0x6e, 0x14, 0x01, 0x0f, 0xf2, 0xe0, 0x14, 0x36, 0x36, 0xbb,
-  0x36, 0x97, 0x34, 0xb2, 0x32, 0x37, 0xba, 0x51, 0x02, 0x3d, 0xb8, 0x25,
-  0x2c, 0x4d, 0xce, 0xc5, 0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x6d, 0x94,
-  0x60, 0x0f, 0x8e, 0x0a, 0x4b, 0x93, 0x73, 0x61, 0x0b, 0x73, 0x3b, 0xab,
-  0x0b, 0x3b, 0x2b, 0xfb, 0xb2, 0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73, 0x1b,
-  0x25, 0xe0, 0x83, 0x9b, 0xc2, 0xd2, 0xe4, 0x5c, 0xc6, 0xde, 0xda, 0xe0,
-  0xd2, 0xd8, 0xca, 0xbe, 0xde, 0xe0, 0xe8, 0xd2, 0xde, 0xdc, 0xe6, 0x46,
-  0x19, 0xfa, 0xc0, 0x0f, 0xfe, 0xe0, 0x98, 0xb0, 0x34, 0x39, 0x17, 0x33,
-  0xb9, 0xb0, 0xb3, 0xb6, 0x32, 0x37, 0xba, 0x51, 0x82, 0x55, 0x00, 0x00,
-  0x00, 0x00, 0xa9, 0x18, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x0a,
-  0x72, 0x28, 0x87, 0x77, 0x80, 0x07, 0x7a, 0x58, 0x70, 0x98, 0x43, 0x3d,
-  0xb8, 0xc3, 0x38, 0xb0, 0x43, 0x39, 0xd0, 0xc3, 0x82, 0xe6, 0x1c, 0xc6,
-  0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0xc1, 0x1d, 0xe6, 0x21, 0x1d, 0xe8,
-  0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x00, 0xd1, 0x10, 0x00, 0x00, 0x06, 0x00,
-  0x00, 0x00, 0x07, 0xcc, 0x3c, 0xa4, 0x83, 0x3b, 0x9c, 0x03, 0x3b, 0x94,
-  0x03, 0x3d, 0xa0, 0x83, 0x3c, 0x94, 0x43, 0x38, 0x90, 0xc3, 0x01, 0x00,
-  0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x56, 0x00, 0x00, 0x00, 0x13, 0x04,
-  0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x14, 0x6b,
-  0x60, 0x04, 0x80, 0xe4, 0x0c, 0x00, 0xcd, 0x11, 0x80, 0xb1, 0x84, 0x00,
-  0x20, 0x3c, 0xd6, 0x00, 0x04, 0xc2, 0x1c, 0x83, 0x91, 0x65, 0x73, 0x0c,
-  0x06, 0x91, 0x8d, 0x35, 0x00, 0x03, 0x41, 0x60, 0x04, 0x60, 0x06, 0x60,
-  0x8c, 0x00, 0x04, 0x41, 0x10, 0xff, 0x28, 0xcc, 0x00, 0xcc, 0x41, 0x84,
-  0x41, 0x18, 0x84, 0x81, 0x18, 0x90, 0x98, 0x01, 0x00, 0x00, 0xf1, 0x30,
-  0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x22, 0x47, 0xc8, 0x90, 0x51, 0x0a,
-  0x84, 0x18, 0x00, 0x00, 0x00, 0x00, 0xcf, 0x03, 0x00, 0x00, 0x6f, 0x6d,
-  0x6e, 0x69, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x68, 0x61,
-  0x72, 0x53, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x43, 0x2b, 0x2b, 0x20,
-  0x54, 0x42, 0x41, 0x41, 0x00, 0x00, 0x13, 0x04, 0xcd, 0xd9, 0x10, 0xb8,
-  0xc2, 0x86, 0xa1, 0x15, 0x60, 0xe1, 0x15, 0x36, 0x0c, 0xb1, 0x10, 0x0b,
-  0xaf, 0x00, 0x23, 0x06, 0xcd, 0x10, 0x82, 0x60, 0x40, 0x91, 0x81, 0x04,
-  0x55, 0x0f, 0xe3, 0x18, 0x06, 0x18, 0x8c, 0x26, 0x04, 0xc0, 0x20, 0x43,
-  0x50, 0x2c, 0x23, 0x06, 0xcd, 0x10, 0x82, 0x60, 0x40, 0x9d, 0x01, 0x35,
-  0x61, 0xd2, 0x13, 0x25, 0xc9, 0x18, 0x8c, 0x26, 0x04, 0xc0, 0x20, 0x43,
-  0x80, 0x40, 0x83, 0x0c, 0xc1, 0xe1, 0x0c, 0x32, 0x14, 0x81, 0x73, 0x5b,
-  0x5e, 0x0a, 0x42, 0x19, 0x64, 0x08, 0x1a, 0xca, 0x88, 0x00, 0xfc, 0x09,
-  0x0c, 0x42, 0xd9, 0x65, 0x00, 0x83, 0x32, 0x78, 0x83, 0x0b, 0xf2, 0x52,
-  0x10, 0xca, 0x20, 0x43, 0x30, 0x69, 0x23, 0x06, 0x87, 0x10, 0x82, 0x60,
-  0xe1, 0x1f, 0x8d, 0x1d, 0x18, 0xc1, 0x2e, 0x43, 0x19, 0xa8, 0x41, 0x1d,
-  0x5c, 0x90, 0x97, 0x82, 0x50, 0x06, 0x19, 0x02, 0xec, 0x1b, 0x31, 0x38,
-  0x84, 0x10, 0x04, 0x0b, 0xff, 0x68, 0xf6, 0x60, 0x09, 0x76, 0x19, 0xd4,
-  0xe0, 0x0d, 0xea, 0xe0, 0x82, 0xbc, 0x14, 0x84, 0x32, 0xc8, 0x10, 0x74,
-  0x64, 0x30, 0x62, 0x70, 0x08, 0x21, 0x08, 0x16, 0xfe, 0xd1, 0x80, 0x02,
-  0x14, 0xcc, 0x31, 0x78, 0x0b, 0x1f, 0xcc, 0x31, 0x04, 0xc7, 0x1f, 0xcc,
-  0x31, 0x04, 0x43, 0x28, 0x58, 0x30, 0x89, 0x7f, 0x06, 0x01, 0x31, 0x00,
-  0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x5b, 0x06, 0x26, 0x88, 0x05, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x03, 0x00,
-  0x00, 0x00, 0x32, 0x0e, 0x10, 0x22, 0x84, 0x00, 0xfa, 0x05, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x0c, 0x00, 0x00, 0x29, 0x00,
-  0x00, 0x00, 0x12, 0x03, 0x94, 0x38, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
-  0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x44, 0x00,
-  0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x98, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x20, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x61, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0xff, 0xff,
-  0xff, 0xff, 0x00, 0x24, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x0d, 0x00,
-  0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0xff, 0xff,
-  0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1b, 0x00,
-  0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0xff, 0xff,
-  0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5d, 0x0c,
-  0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0xe1, 0x00, 0x00,
-  0x00, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x4e, 0x56, 0x32, 0x31, 0x5f, 0x66,
-  0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x69, 0x72, 0x2e, 0x64,
-  0x6f, 0x74, 0x2e, 0x76, 0x33, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e,
-  0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x75,
-  0x72, 0x65, 0x5f, 0x32, 0x64, 0x2e, 0x76, 0x34, 0x66, 0x33, 0x32, 0x33,
-  0x31, 0x30, 0x30, 0x31, 0x2e, 0x34, 0x33, 0x61, 0x69, 0x72, 0x36, 0x34,
-  0x2d, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2d, 0x74, 0x76, 0x6f, 0x73, 0x31,
-  0x33, 0x2e, 0x30, 0x2e, 0x30, 0x2d, 0x73, 0x69, 0x6d, 0x75, 0x6c, 0x61,
-  0x74, 0x6f, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+  0x00, 0x00, 0x00, 0x00
 };
-const unsigned int sdl_metallib_len = 25026;
+const unsigned int sdl_metallib_len = 24676;
diff --git a/Engine/lib/sdl/src/render/opengl/SDL_glfuncs.h b/Engine/lib/sdl/src/render/opengl/SDL_glfuncs.h
index 36846db8c..acdcf8803 100644
--- a/Engine/lib/sdl/src/render/opengl/SDL_glfuncs.h
+++ b/Engine/lib/sdl/src/render/opengl/SDL_glfuncs.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -73,7 +73,7 @@ SDL_PROC_UNUSED(void, glColor4i, (GLint, GLint, GLint, GLint))
 SDL_PROC_UNUSED(void, glColor4iv, (const GLint *))
 SDL_PROC_UNUSED(void, glColor4s, (GLshort, GLshort, GLshort, GLshort))
 SDL_PROC_UNUSED(void, glColor4sv, (const GLshort *))
-SDL_PROC_UNUSED(void, glColor4ub,
+SDL_PROC(void, glColor4ub,
                 (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha))
 SDL_PROC_UNUSED(void, glColor4ubv, (const GLubyte * v))
 SDL_PROC_UNUSED(void, glColor4ui,
@@ -86,7 +86,7 @@ SDL_PROC_UNUSED(void, glColorMask,
                 (GLboolean red, GLboolean green, GLboolean blue,
                  GLboolean alpha))
 SDL_PROC_UNUSED(void, glColorMaterial, (GLenum face, GLenum mode))
-SDL_PROC_UNUSED(void, glColorPointer,
+SDL_PROC(void, glColorPointer,
                 (GLint size, GLenum type, GLsizei stride,
                  const GLvoid * pointer))
 SDL_PROC_UNUSED(void, glCopyPixels,
@@ -111,8 +111,8 @@ SDL_PROC(void, glDepthFunc, (GLenum func))
 SDL_PROC_UNUSED(void, glDepthMask, (GLboolean flag))
 SDL_PROC_UNUSED(void, glDepthRange, (GLclampd zNear, GLclampd zFar))
 SDL_PROC(void, glDisable, (GLenum cap))
-SDL_PROC_UNUSED(void, glDisableClientState, (GLenum array))
-SDL_PROC_UNUSED(void, glDrawArrays, (GLenum mode, GLint first, GLsizei count))
+SDL_PROC(void, glDisableClientState, (GLenum array))
+SDL_PROC(void, glDrawArrays, (GLenum mode, GLint first, GLsizei count))
 SDL_PROC_UNUSED(void, glDrawBuffer, (GLenum mode))
 SDL_PROC_UNUSED(void, glDrawElements,
                 (GLenum mode, GLsizei count, GLenum type,
@@ -125,7 +125,7 @@ SDL_PROC_UNUSED(void, glEdgeFlagPointer,
                 (GLsizei stride, const GLvoid * pointer))
 SDL_PROC_UNUSED(void, glEdgeFlagv, (const GLboolean * flag))
 SDL_PROC(void, glEnable, (GLenum cap))
-SDL_PROC_UNUSED(void, glEnableClientState, (GLenum array))
+SDL_PROC(void, glEnableClientState, (GLenum array))
 SDL_PROC(void, glEnd, (void))
 SDL_PROC_UNUSED(void, glEndList, (void))
 SDL_PROC_UNUSED(void, glEvalCoord1d, (GLdouble u))
@@ -159,7 +159,7 @@ SDL_PROC_UNUSED(void, glGetBooleanv, (GLenum pname, GLboolean * params))
 SDL_PROC_UNUSED(void, glGetClipPlane, (GLenum plane, GLdouble * equation))
 SDL_PROC_UNUSED(void, glGetDoublev, (GLenum pname, GLdouble * params))
 SDL_PROC(GLenum, glGetError, (void))
-SDL_PROC_UNUSED(void, glGetFloatv, (GLenum pname, GLfloat * params))
+SDL_PROC(void, glGetFloatv, (GLenum pname, GLfloat * params))
 SDL_PROC(void, glGetIntegerv, (GLenum pname, GLint * params))
 SDL_PROC_UNUSED(void, glGetLightfv,
                 (GLenum light, GLenum pname, GLfloat * params))
@@ -302,14 +302,14 @@ SDL_PROC_UNUSED(void, glPolygonOffset, (GLfloat factor, GLfloat units))
 SDL_PROC_UNUSED(void, glPolygonStipple, (const GLubyte * mask))
 SDL_PROC_UNUSED(void, glPopAttrib, (void))
 SDL_PROC_UNUSED(void, glPopClientAttrib, (void))
-SDL_PROC(void, glPopMatrix, (void))
+SDL_PROC_UNUSED(void, glPopMatrix, (void))
 SDL_PROC_UNUSED(void, glPopName, (void))
 SDL_PROC_UNUSED(void, glPrioritizeTextures,
                 (GLsizei n, const GLuint * textures,
                  const GLclampf * priorities))
 SDL_PROC_UNUSED(void, glPushAttrib, (GLbitfield mask))
 SDL_PROC_UNUSED(void, glPushClientAttrib, (GLbitfield mask))
-SDL_PROC(void, glPushMatrix, (void))
+SDL_PROC_UNUSED(void, glPushMatrix, (void))
 SDL_PROC_UNUSED(void, glPushName, (GLuint name))
 SDL_PROC_UNUSED(void, glRasterPos2d, (GLdouble x, GLdouble y))
 SDL_PROC_UNUSED(void, glRasterPos2dv, (const GLdouble * v))
@@ -354,7 +354,7 @@ SDL_PROC_UNUSED(void, glRects,
                 (GLshort x1, GLshort y1, GLshort x2, GLshort y2))
 SDL_PROC_UNUSED(void, glRectsv, (const GLshort * v1, const GLshort * v2))
 SDL_PROC_UNUSED(GLint, glRenderMode, (GLenum mode))
-SDL_PROC(void, glRotated,
+SDL_PROC_UNUSED(void, glRotated,
                 (GLdouble angle, GLdouble x, GLdouble y, GLdouble z))
 SDL_PROC(void, glRotatef,
                 (GLfloat angle, GLfloat x, GLfloat y, GLfloat z))
@@ -401,7 +401,7 @@ SDL_PROC_UNUSED(void, glTexCoord4iv, (const GLint * v))
 SDL_PROC_UNUSED(void, glTexCoord4s,
                 (GLshort s, GLshort t, GLshort r, GLshort q))
 SDL_PROC_UNUSED(void, glTexCoord4sv, (const GLshort * v))
-SDL_PROC_UNUSED(void, glTexCoordPointer,
+SDL_PROC(void, glTexCoordPointer,
                 (GLint size, GLenum type, GLsizei stride,
                  const GLvoid * pointer))
 SDL_PROC(void, glTexEnvf, (GLenum target, GLenum pname, GLfloat param))
@@ -442,7 +442,7 @@ SDL_PROC(void, glTexSubImage2D,
           GLsizei width, GLsizei height, GLenum format, GLenum type,
           const GLvoid * pixels))
 SDL_PROC_UNUSED(void, glTranslated, (GLdouble x, GLdouble y, GLdouble z))
-SDL_PROC(void, glTranslatef, (GLfloat x, GLfloat y, GLfloat z))
+SDL_PROC_UNUSED(void, glTranslatef, (GLfloat x, GLfloat y, GLfloat z))
 SDL_PROC_UNUSED(void, glVertex2d, (GLdouble x, GLdouble y))
 SDL_PROC_UNUSED(void, glVertex2dv, (const GLdouble * v))
 SDL_PROC(void, glVertex2f, (GLfloat x, GLfloat y))
@@ -470,7 +470,7 @@ SDL_PROC_UNUSED(void, glVertex4iv, (const GLint * v))
 SDL_PROC_UNUSED(void, glVertex4s,
                 (GLshort x, GLshort y, GLshort z, GLshort w))
 SDL_PROC_UNUSED(void, glVertex4sv, (const GLshort * v))
-SDL_PROC_UNUSED(void, glVertexPointer,
+SDL_PROC(void, glVertexPointer,
                 (GLint size, GLenum type, GLsizei stride,
                  const GLvoid * pointer))
 SDL_PROC(void, glViewport, (GLint x, GLint y, GLsizei width, GLsizei height))
diff --git a/Engine/lib/sdl/src/render/opengl/SDL_render_gl.c b/Engine/lib/sdl/src/render/opengl/SDL_render_gl.c
index 895a556c7..b5df73ace 100644
--- a/Engine/lib/sdl/src/render/opengl/SDL_render_gl.c
+++ b/Engine/lib/sdl/src/render/opengl/SDL_render_gl.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -21,7 +21,6 @@
 #include "../../SDL_internal.h"
 
 #if SDL_VIDEO_RENDER_OGL && !SDL_RENDER_DISABLED
-
 #include "SDL_hints.h"
 #include "SDL_opengl.h"
 #include "../SDL_sysrender.h"
@@ -73,6 +72,9 @@ typedef struct
     SDL_bool cliprect_dirty;
     SDL_Rect cliprect;
     SDL_bool texturing;
+    SDL_bool vertex_array;
+    SDL_bool color_array;
+    SDL_bool texture_array;
     Uint32 color;
     Uint32 clear_color;
 } GL_DrawStateCache;
@@ -124,15 +126,18 @@ typedef struct
     GLfloat texh;
     GLenum format;
     GLenum formattype;
+    GL_Shader shader;
     void *pixels;
     int pitch;
     SDL_Rect locked_rect;
 
+#if SDL_HAVE_YUV
     /* YUV texture support */
     SDL_bool yuv;
     SDL_bool nv12;
     GLuint utexture;
     GLuint vtexture;
+#endif
 
     GL_FBOList *fbo;
 } GL_TextureData;
@@ -577,6 +582,7 @@ GL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
         return -1;
     }
 
+#if SDL_HAVE_YUV
     if (texture->format == SDL_PIXELFORMAT_YV12 ||
         texture->format == SDL_PIXELFORMAT_IYUV) {
         data->yuv = SDL_TRUE;
@@ -626,6 +632,58 @@ GL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
         renderdata->glTexImage2D(textype, 0, GL_LUMINANCE_ALPHA, (texture_w+1)/2,
                                  (texture_h+1)/2, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, NULL);
     }
+#endif
+
+    if (texture->format == SDL_PIXELFORMAT_ABGR8888 || texture->format == SDL_PIXELFORMAT_ARGB8888) {
+        data->shader = SHADER_RGBA;
+    } else {
+        data->shader = SHADER_RGB;
+    }
+
+#if SDL_HAVE_YUV
+    if (data->yuv || data->nv12) {
+        switch (SDL_GetYUVConversionModeForResolution(texture->w, texture->h)) {
+            case SDL_YUV_CONVERSION_JPEG:
+                if (data->yuv) {
+                    data->shader = SHADER_YUV_JPEG;
+                } else if (texture->format == SDL_PIXELFORMAT_NV12) {
+                    data->shader = SHADER_NV12_JPEG;
+                } else {
+                    data->shader = SHADER_NV21_JPEG;
+                }
+                break;
+            case SDL_YUV_CONVERSION_BT601:
+                if (data->yuv) {
+                    data->shader = SHADER_YUV_BT601;
+                } else if (texture->format == SDL_PIXELFORMAT_NV12) {
+                    if (SDL_GetHintBoolean("SDL_RENDER_OPENGL_NV12_RG_SHADER", SDL_FALSE)) {
+                        data->shader = SHADER_NV12_RG_BT601;
+                    } else {
+                        data->shader = SHADER_NV12_RA_BT601;
+                    }
+                } else {
+                    data->shader = SHADER_NV21_BT601;
+                }
+                break;
+            case SDL_YUV_CONVERSION_BT709:
+                if (data->yuv) {
+                    data->shader = SHADER_YUV_BT709;
+                } else if (texture->format == SDL_PIXELFORMAT_NV12) {
+                    if (SDL_GetHintBoolean("SDL_RENDER_OPENGL_NV12_RG_SHADER", SDL_FALSE)) {
+                        data->shader = SHADER_NV12_RG_BT709;
+                    } else {
+                        data->shader = SHADER_NV12_RA_BT709;
+                    }
+                } else {
+                    data->shader = SHADER_NV21_BT709;
+                }
+                break;
+            default:
+                SDL_assert(!"unsupported YUV conversion mode");
+                break;
+        }
+    }
+#endif /* SDL_HAVE_YUV */
 
     return GL_CheckError("", renderer);
 }
@@ -651,6 +709,7 @@ GL_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
     renderdata->glTexSubImage2D(textype, 0, rect->x, rect->y, rect->w,
                                 rect->h, data->format, data->formattype,
                                 pixels);
+#if SDL_HAVE_YUV
     if (data->yuv) {
         renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, ((pitch + 1) / 2));
 
@@ -687,10 +746,11 @@ GL_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
                                     (rect->w + 1)/2, (rect->h + 1)/2,
                                     GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, pixels);
     }
-
+#endif
     return GL_CheckError("glTexSubImage2D()", renderer);
 }
 
+#if SDL_HAVE_YUV
 static int
 GL_UpdateTextureYUV(SDL_Renderer * renderer, SDL_Texture * texture,
                     const SDL_Rect * rect,
@@ -728,6 +788,38 @@ GL_UpdateTextureYUV(SDL_Renderer * renderer, SDL_Texture * texture,
     return GL_CheckError("glTexSubImage2D()", renderer);
 }
 
+static int
+GL_UpdateTextureNV(SDL_Renderer * renderer, SDL_Texture * texture,
+                    const SDL_Rect * rect,
+                    const Uint8 *Yplane, int Ypitch,
+                    const Uint8 *UVplane, int UVpitch)
+{
+    GL_RenderData *renderdata = (GL_RenderData *) renderer->driverdata;
+    const GLenum textype = renderdata->textype;
+    GL_TextureData *data = (GL_TextureData *) texture->driverdata;
+
+    GL_ActivateRenderer(renderer);
+
+    renderdata->drawstate.texture = NULL;  /* we trash this state. */
+
+    renderdata->glBindTexture(textype, data->texture);
+    renderdata->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, Ypitch);
+    renderdata->glTexSubImage2D(textype, 0, rect->x, rect->y, rect->w,
+                                rect->h, data->format, data->formattype,
+                                Yplane);
+
+
+    renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, UVpitch / 2);
+    renderdata->glBindTexture(textype, data->utexture);
+    renderdata->glTexSubImage2D(textype, 0, rect->x/2, rect->y/2,
+                                (rect->w + 1)/2, (rect->h + 1)/2,
+                                GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, UVplane);
+
+    return GL_CheckError("glTexSubImage2D()", renderer);
+}
+#endif
+
 static int
 GL_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
                const SDL_Rect * rect, void **pixels, int *pitch)
@@ -768,6 +860,7 @@ GL_SetTextureScaleMode(SDL_Renderer * renderer, SDL_Texture * texture, SDL_Scale
     renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER, glScaleMode);
     renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER, glScaleMode);
 
+#if SDL_HAVE_YUV
     if (texture->format == SDL_PIXELFORMAT_YV12 ||
         texture->format == SDL_PIXELFORMAT_IYUV) {
         renderdata->glBindTexture(textype, data->utexture);
@@ -785,6 +878,7 @@ GL_SetTextureScaleMode(SDL_Renderer * renderer, SDL_Texture * texture, SDL_Scale
         renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER, glScaleMode);
         renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER, glScaleMode);
     }
+#endif
 }
 
 static int
@@ -851,171 +945,106 @@ static int
 GL_QueueDrawLines(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FPoint * points, int count)
 {
     int i;
+    GLfloat prevx, prevy;
     const size_t vertlen = (sizeof (GLfloat) * 2) * count;
     GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, vertlen, 0, &cmd->data.draw.first);
+
     if (!verts) {
         return -1;
     }
     cmd->data.draw.count = count;
 
-    /* Offset to hit the center of the pixel. */
-    for (i = 0; i < count; i++) {
-        *(verts++) = 0.5f + points[i].x;
-        *(verts++) = 0.5f + points[i].y;
+    /* 0.5f offset to hit the center of the pixel. */
+    prevx = 0.5f + points->x;
+    prevy = 0.5f + points->y;
+    *(verts++) = prevx;
+    *(verts++) = prevy;
+
+    /* bump the end of each line segment out a quarter of a pixel, to provoke
+       the diamond-exit rule. Without this, you won't just drop the last
+       pixel of the last line segment, but you might also drop pixels at the
+       edge of any given line segment along the way too. */
+    for (i = 1; i < count; i++) {
+        const GLfloat xstart = prevx;
+        const GLfloat ystart = prevy;
+        const GLfloat xend = points[i].x + 0.5f;  /* 0.5f to hit pixel center. */
+        const GLfloat yend = points[i].y + 0.5f;
+        /* bump a little in the direction we are moving in. */
+        const GLfloat deltax = xend - xstart;
+        const GLfloat deltay = yend - ystart;
+        const GLfloat angle = SDL_atan2f(deltay, deltax);
+        prevx = xend + (SDL_cosf(angle) * 0.25f);
+        prevy = yend + (SDL_sinf(angle) * 0.25f);
+        *(verts++) = prevx;
+        *(verts++) = prevy;
     }
 
-    /* Make the last line segment one pixel longer, to satisfy the
-       diamond-exit rule. */
-    verts -= 4;
-    {
-        const GLfloat xstart = verts[0];
-        const GLfloat ystart = verts[1];
-        const GLfloat xend = verts[2];
-        const GLfloat yend = verts[3];
+    return 0;
+}
 
-        if (ystart == yend) {  /* horizontal line */
-            verts[2] += (xend > xstart) ? 1.0f : -1.0f;
-        } else if (xstart == xend) {  /* vertical line */
-            verts[3] += (yend > ystart) ? 1.0f : -1.0f;
-        } else {  /* bump a pixel in the direction we are moving in. */
-            const GLfloat deltax = xend - xstart;
-            const GLfloat deltay = yend - ystart;
-            const GLfloat angle = SDL_atan2f(deltay, deltax);
-            verts[2] += SDL_cosf(angle);
-            verts[3] += SDL_sinf(angle);
+static int
+GL_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+        const float *xy, int xy_stride, const SDL_Color *color, int color_stride, const float *uv, int uv_stride,
+        int num_vertices, const void *indices, int num_indices, int size_indices,
+        float scale_x, float scale_y)
+{
+    GL_TextureData *texturedata = NULL;
+    int i;
+    int count = indices ? num_indices : num_vertices;
+    GLfloat *verts;
+    size_t sz = 2 * sizeof(GLfloat) + 4 * sizeof(Uint8) + (texture ? 2 : 0) * sizeof(GLfloat);
+
+    verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, count * sz, 0, &cmd->data.draw.first);
+    if (!verts) {
+        return -1;
+    }
+
+    if (texture) {
+        texturedata = (GL_TextureData *) texture->driverdata;
+    }
+
+    cmd->data.draw.count = count;
+    size_indices = indices ? size_indices : 0;
+
+    for (i = 0; i < count; i++) {
+        int j;
+        float *xy_;
+        if (size_indices == 4) {
+            j = ((const Uint32 *)indices)[i];
+        } else if (size_indices == 2) {
+            j = ((const Uint16 *)indices)[i];
+        } else if (size_indices == 1) {
+            j = ((const Uint8 *)indices)[i];
+        } else {
+            j = i;
+        }
+
+        xy_ = (float *)((char*)xy + j * xy_stride);
+
+        *(verts++) = xy_[0] * scale_x;
+        *(verts++) = xy_[1] * scale_y;
+
+        /* Not really a float, but it is still 4 bytes and will be cast to the
+           right type in the graphics driver. */
+        SDL_memcpy(verts, ((char*)color + j * color_stride), sizeof(*color));
+        ++verts;
+
+        if (texture) {
+            float *uv_ = (float *)((char*)uv + j * uv_stride);
+            *(verts++) = uv_[0] * texturedata->texw;
+            *(verts++) = uv_[1] * texturedata->texh;
         }
     }
-
     return 0;
 }
 
 static int
-GL_QueueFillRects(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FRect * rects, int count)
-{
-    GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, count * 4 * sizeof (GLfloat), 0, &cmd->data.draw.first);
-    int i;
-
-    if (!verts) {
-        return -1;
-    }
-
-    cmd->data.draw.count = count;
-    for (i = 0; i < count; i++) {
-        const SDL_FRect *rect = &rects[i];
-        *(verts++) = rect->x;
-        *(verts++) = rect->y;
-        *(verts++) = rect->x + rect->w;
-        *(verts++) = rect->y + rect->h;
-    }
-
-    return 0;
-}
-
-static int
-GL_QueueCopy(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture,
-             const SDL_Rect * srcrect, const SDL_FRect * dstrect)
-{
-    GL_TextureData *texturedata = (GL_TextureData *) texture->driverdata;
-    GLfloat minx, miny, maxx, maxy;
-    GLfloat minu, maxu, minv, maxv;
-    GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, 8 * sizeof (GLfloat), 0, &cmd->data.draw.first);
-
-    if (!verts) {
-        return -1;
-    }
-
-    cmd->data.draw.count = 1;
-
-    minx = dstrect->x;
-    miny = dstrect->y;
-    maxx = dstrect->x + dstrect->w;
-    maxy = dstrect->y + dstrect->h;
-
-    minu = (GLfloat) srcrect->x / texture->w;
-    minu *= texturedata->texw;
-    maxu = (GLfloat) (srcrect->x + srcrect->w) / texture->w;
-    maxu *= texturedata->texw;
-    minv = (GLfloat) srcrect->y / texture->h;
-    minv *= texturedata->texh;
-    maxv = (GLfloat) (srcrect->y + srcrect->h) / texture->h;
-    maxv *= texturedata->texh;
-
-    cmd->data.draw.count = 1;
-    *(verts++) = minx;
-    *(verts++) = miny;
-    *(verts++) = maxx;
-    *(verts++) = maxy;
-    *(verts++) = minu;
-    *(verts++) = maxu;
-    *(verts++) = minv;
-    *(verts++) = maxv;
-    return 0;
-}
-
-static int
-GL_QueueCopyEx(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture,
-               const SDL_Rect * srcrect, const SDL_FRect * dstrect,
-               const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip)
-{
-    GL_TextureData *texturedata = (GL_TextureData *) texture->driverdata;
-    GLfloat minx, miny, maxx, maxy;
-    GLfloat centerx, centery;
-    GLfloat minu, maxu, minv, maxv;
-    GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, 11 * sizeof (GLfloat), 0, &cmd->data.draw.first);
-
-    if (!verts) {
-        return -1;
-    }
-
-    centerx = center->x;
-    centery = center->y;
-
-    if (flip & SDL_FLIP_HORIZONTAL) {
-        minx =  dstrect->w - centerx;
-        maxx = -centerx;
-    }
-    else {
-        minx = -centerx;
-        maxx =  dstrect->w - centerx;
-    }
-
-    if (flip & SDL_FLIP_VERTICAL) {
-        miny =  dstrect->h - centery;
-        maxy = -centery;
-    }
-    else {
-        miny = -centery;
-        maxy =  dstrect->h - centery;
-    }
-
-    minu = (GLfloat) srcrect->x / texture->w;
-    minu *= texturedata->texw;
-    maxu = (GLfloat) (srcrect->x + srcrect->w) / texture->w;
-    maxu *= texturedata->texw;
-    minv = (GLfloat) srcrect->y / texture->h;
-    minv *= texturedata->texh;
-    maxv = (GLfloat) (srcrect->y + srcrect->h) / texture->h;
-    maxv *= texturedata->texh;
-
-    cmd->data.draw.count = 1;
-    *(verts++) = minx;
-    *(verts++) = miny;
-    *(verts++) = maxx;
-    *(verts++) = maxy;
-    *(verts++) = minu;
-    *(verts++) = maxu;
-    *(verts++) = minv;
-    *(verts++) = maxv;
-    *(verts++) = (GLfloat) dstrect->x + centerx;
-    *(verts++) = (GLfloat) dstrect->y + centery;
-    *(verts++) = (GLfloat) angle;
-    return 0;
-}
-
-static void
 SetDrawState(GL_RenderData *data, const SDL_RenderCommand *cmd, const GL_Shader shader)
 {
     const SDL_BlendMode blend = cmd->data.draw.blend;
+    SDL_bool vertex_array;
+    SDL_bool color_array;
+    SDL_bool texture_array;
 
     if (data->drawstate.viewport_dirty) {
         const SDL_bool istarget = data->drawstate.target != NULL;
@@ -1081,78 +1110,83 @@ SetDrawState(GL_RenderData *data, const SDL_RenderCommand *cmd, const GL_Shader
             data->drawstate.texturing = SDL_TRUE;
         }
     }
+
+    vertex_array = cmd->command == SDL_RENDERCMD_DRAW_POINTS
+        || cmd->command == SDL_RENDERCMD_DRAW_LINES
+        || cmd->command == SDL_RENDERCMD_GEOMETRY;
+    color_array = cmd->command == SDL_RENDERCMD_GEOMETRY;
+    texture_array = cmd->data.draw.texture != NULL;
+
+    if (vertex_array != data->drawstate.vertex_array) {
+        if (vertex_array) {
+            data->glEnableClientState(GL_VERTEX_ARRAY);
+        } else {
+            data->glDisableClientState(GL_VERTEX_ARRAY);
+        }
+        data->drawstate.vertex_array = vertex_array;
+    }
+
+    if (color_array != data->drawstate.color_array) {
+        if (color_array) {
+            data->glEnableClientState(GL_COLOR_ARRAY);
+        } else {
+            data->glDisableClientState(GL_COLOR_ARRAY);
+        }
+        data->drawstate.color_array = color_array;
+    }
+
+    /* This is a little awkward but should avoid texcoord arrays getting into
+       a bad state if SDL_GL_BindTexture/UnbindTexture are called. */
+    if (texture_array != data->drawstate.texture_array) {
+        if (texture_array) {
+            data->glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+        } else {
+            data->glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+        }
+        data->drawstate.texture_array = texture_array;
+    }
+
+    return 0;
 }
 
-static void
+static int
 SetCopyState(GL_RenderData *data, const SDL_RenderCommand *cmd)
 {
     SDL_Texture *texture = cmd->data.draw.texture;
     const GL_TextureData *texturedata = (GL_TextureData *) texture->driverdata;
-    GL_Shader shader;
 
-    if (texture->format == SDL_PIXELFORMAT_ABGR8888 || texture->format == SDL_PIXELFORMAT_ARGB8888) {
-        shader = SHADER_RGBA;
-    } else {
-        shader = SHADER_RGB;
-    }
-
-    if (data->shaders) {
-        if (texturedata->yuv || texturedata->nv12) {
-            switch (SDL_GetYUVConversionModeForResolution(texture->w, texture->h)) {
-                case SDL_YUV_CONVERSION_JPEG:
-                    if (texturedata->yuv) {
-                        shader = SHADER_YUV_JPEG;
-                    } else if (texture->format == SDL_PIXELFORMAT_NV12) {
-                        shader = SHADER_NV12_JPEG;
-                    } else {
-                        shader = SHADER_NV21_JPEG;
-                    }
-                    break;
-                case SDL_YUV_CONVERSION_BT601:
-                    if (texturedata->yuv) {
-                        shader = SHADER_YUV_BT601;
-                    } else if (texture->format == SDL_PIXELFORMAT_NV12) {
-                        shader = SHADER_NV12_BT601;
-                    } else {
-                        shader = SHADER_NV21_BT601;
-                    }
-                    break;
-                case SDL_YUV_CONVERSION_BT709:
-                    if (texturedata->yuv) {
-                        shader = SHADER_YUV_BT709;
-                    } else if (texture->format == SDL_PIXELFORMAT_NV12) {
-                        shader = SHADER_NV12_BT709;
-                    } else {
-                        shader = SHADER_NV21_BT709;
-                    }
-                    break;
-                default:
-                    SDL_assert(!"unsupported YUV conversion mode");
-                    break;
-            }
-        }
-    }
-
-    SetDrawState(data, cmd, shader);
+    SetDrawState(data, cmd, texturedata->shader);
 
     if (texture != data->drawstate.texture) {
         const GLenum textype = data->textype;
+#if SDL_HAVE_YUV
         if (texturedata->yuv) {
-            data->glActiveTextureARB(GL_TEXTURE2_ARB);
+            if (data->GL_ARB_multitexture_supported) {
+                data->glActiveTextureARB(GL_TEXTURE2_ARB);
+            }
             data->glBindTexture(textype, texturedata->vtexture);
 
-            data->glActiveTextureARB(GL_TEXTURE1_ARB);
+            if (data->GL_ARB_multitexture_supported) {
+                data->glActiveTextureARB(GL_TEXTURE1_ARB);
+            }
             data->glBindTexture(textype, texturedata->utexture);
         }
         if (texturedata->nv12) {
-            data->glActiveTextureARB(GL_TEXTURE1_ARB);
+            if (data->GL_ARB_multitexture_supported) {
+                data->glActiveTextureARB(GL_TEXTURE1_ARB);
+            }
             data->glBindTexture(textype, texturedata->utexture);
         }
-        data->glActiveTextureARB(GL_TEXTURE0_ARB);
+#endif
+        if (data->GL_ARB_multitexture_supported) {
+            data->glActiveTextureARB(GL_TEXTURE0_ARB);
+        }
         data->glBindTexture(textype, texturedata->texture);
 
         data->drawstate.texture = texture;
     }
+
+    return 0;
 }
 
 static int
@@ -1160,7 +1194,6 @@ GL_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertic
 {
     /* !!! FIXME: it'd be nice to use a vertex buffer instead of immediate mode... */
     GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
-    size_t i;
 
     if (GL_ActivateRenderer(renderer) < 0) {
         return -1;
@@ -1168,9 +1201,22 @@ GL_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertic
 
     data->drawstate.target = renderer->target;
     if (!data->drawstate.target) {
-        SDL_GL_GetDrawableSize(renderer->window, &data->drawstate.drawablew, &data->drawstate.drawableh);
+        int w, h;
+        SDL_GL_GetDrawableSize(renderer->window, &w, &h);
+        if ((w != data->drawstate.drawablew) || (h != data->drawstate.drawableh)) {
+            data->drawstate.viewport_dirty = SDL_TRUE;  // if the window dimensions changed, invalidate the current viewport, etc.
+            data->drawstate.cliprect_dirty = SDL_TRUE;
+            data->drawstate.drawablew = w;
+            data->drawstate.drawableh = h;
+        }
     }
 
+#ifdef __MACOSX__
+    // On macOS, moving the window seems to invalidate the OpenGL viewport state,
+    // so don't bother trying to persist it across frames; always reset it.
+    // Workaround for: https://github.com/libsdl-org/SDL/issues/1504
+    data->drawstate.viewport_dirty = SDL_TRUE;
+#endif
 
     while (cmd) {
         switch (cmd->command) {
@@ -1179,12 +1225,9 @@ GL_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertic
                 const Uint8 g = cmd->data.color.g;
                 const Uint8 b = cmd->data.color.b;
                 const Uint8 a = cmd->data.color.a;
-                const Uint32 color = ((a << 24) | (r << 16) | (g << 8) | b);
+                const Uint32 color = (((Uint32)a << 24) | (r << 16) | (g << 8) | b);
                 if (color != data->drawstate.color) {
-                    data->glColor4f((GLfloat) r * inv255f,
-                                    (GLfloat) g * inv255f,
-                                    (GLfloat) b * inv255f,
-                                    (GLfloat) a * inv255f);
+                    data->glColor4ub((GLubyte) r, (GLubyte) g, (GLubyte) b, (GLubyte) a);
                     data->drawstate.color = color;
                 }
                 break;
@@ -1205,6 +1248,7 @@ GL_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertic
                     data->drawstate.cliprect_enabled = cmd->data.cliprect.enabled;
                     data->drawstate.cliprect_enabled_dirty = SDL_TRUE;
                 }
+
                 if (SDL_memcmp(&data->drawstate.cliprect, rect, sizeof (SDL_Rect)) != 0) {
                     SDL_memcpy(&data->drawstate.cliprect, rect, sizeof (SDL_Rect));
                     data->drawstate.cliprect_dirty = SDL_TRUE;
@@ -1217,7 +1261,7 @@ GL_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertic
                 const Uint8 g = cmd->data.color.g;
                 const Uint8 b = cmd->data.color.b;
                 const Uint8 a = cmd->data.color.a;
-                const Uint32 color = ((a << 24) | (r << 16) | (g << 8) | b);
+                const Uint32 color = (((Uint32)a << 24) | (r << 16) | (g << 8) | b);
                 if (color != data->drawstate.clear_color) {
                     const GLfloat fr = ((GLfloat) r) * inv255f;
                     const GLfloat fg = ((GLfloat) g) * inv255f;
@@ -1233,99 +1277,123 @@ GL_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertic
                 }
 
                 data->glClear(GL_COLOR_BUFFER_BIT);
-
                 break;
             }
 
-            case SDL_RENDERCMD_DRAW_POINTS: {
-                const size_t count = cmd->data.draw.count;
-                const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first);
-                SetDrawState(data, cmd, SHADER_SOLID);
-                data->glBegin(GL_POINTS);
-                for (i = 0; i < count; i++, verts += 2) {
-                    data->glVertex2f(verts[0], verts[1]);
-                }
-                data->glEnd();
+            case SDL_RENDERCMD_FILL_RECTS: /* unused */
+                break;
+
+            case SDL_RENDERCMD_COPY: /* unused */
+                break;
+
+            case SDL_RENDERCMD_COPY_EX: /* unused */
                 break;
-            }
 
             case SDL_RENDERCMD_DRAW_LINES: {
-                const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first);
-                const size_t count = cmd->data.draw.count;
-                SDL_assert(count >= 2);
-                SetDrawState(data, cmd, SHADER_SOLID);
-                data->glBegin(GL_LINE_STRIP);
-                for (i = 0; i < count; ++i, verts += 2) {
-                    data->glVertex2f(verts[0], verts[1]);
-                }
-                data->glEnd();
-                break;
-            }
+                if (SetDrawState(data, cmd, SHADER_SOLID) == 0) {
+                    size_t count = cmd->data.draw.count;
+                    const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first);
 
-            case SDL_RENDERCMD_FILL_RECTS: {
-                const size_t count = cmd->data.draw.count;
-                const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first);
-                SetDrawState(data, cmd, SHADER_SOLID);
-                for (i = 0; i < count; ++i, verts += 4) {
-                    data->glRectf(verts[0], verts[1], verts[2], verts[3]);
+                    /* SetDrawState handles glEnableClientState. */
+                    data->glVertexPointer(2, GL_FLOAT, sizeof(float) * 2, verts);
+
+                    if (count > 2) {
+                        /* joined lines cannot be grouped */
+                        data->glDrawArrays(GL_LINE_STRIP, 0, (GLsizei)count);
+                    } else {
+                        /* let's group non joined lines */
+                        SDL_RenderCommand *finalcmd = cmd;
+                        SDL_RenderCommand *nextcmd = cmd->next;
+                        SDL_BlendMode thisblend = cmd->data.draw.blend;
+
+                        while (nextcmd != NULL) {
+                            const SDL_RenderCommandType nextcmdtype = nextcmd->command;
+                            if (nextcmdtype != SDL_RENDERCMD_DRAW_LINES) {
+                                break;  /* can't go any further on this draw call, different render command up next. */
+                            } else if (nextcmd->data.draw.count != 2) {
+                                break;  /* can't go any further on this draw call, those are joined lines */
+                            } else if (nextcmd->data.draw.blend != thisblend) {
+                                break;  /* can't go any further on this draw call, different blendmode copy up next. */
+                            } else {
+                                finalcmd = nextcmd;  /* we can combine copy operations here. Mark this one as the furthest okay command. */
+                                count += nextcmd->data.draw.count;
+                            }
+                            nextcmd = nextcmd->next;
+                        }
+
+                        data->glDrawArrays(GL_LINES, 0, (GLsizei)count);
+                        cmd = finalcmd;  /* skip any copy commands we just combined in here. */
+                    }
                 }
                 break;
             }
 
-            case SDL_RENDERCMD_COPY: {
-                const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first);
-                const GLfloat minx = verts[0];
-                const GLfloat miny = verts[1];
-                const GLfloat maxx = verts[2];
-                const GLfloat maxy = verts[3];
-                const GLfloat minu = verts[4];
-                const GLfloat maxu = verts[5];
-                const GLfloat minv = verts[6];
-                const GLfloat maxv = verts[7];
-                SetCopyState(data, cmd);
-                data->glBegin(GL_TRIANGLE_STRIP);
-                data->glTexCoord2f(minu, minv);
-                data->glVertex2f(minx, miny);
-                data->glTexCoord2f(maxu, minv);
-                data->glVertex2f(maxx, miny);
-                data->glTexCoord2f(minu, maxv);
-                data->glVertex2f(minx, maxy);
-                data->glTexCoord2f(maxu, maxv);
-                data->glVertex2f(maxx, maxy);
-                data->glEnd();
-                break;
-            }
+            case SDL_RENDERCMD_DRAW_POINTS:
+            case SDL_RENDERCMD_GEOMETRY: {
+                /* as long as we have the same copy command in a row, with the
+                   same texture, we can combine them all into a single draw call. */
+                SDL_Texture *thistexture = cmd->data.draw.texture;
+                SDL_BlendMode thisblend = cmd->data.draw.blend;
+                const SDL_RenderCommandType thiscmdtype = cmd->command;
+                SDL_RenderCommand *finalcmd = cmd;
+                SDL_RenderCommand *nextcmd = cmd->next;
+                size_t count = cmd->data.draw.count;
+                int ret;
+                while (nextcmd != NULL) {
+                    const SDL_RenderCommandType nextcmdtype = nextcmd->command;
+                    if (nextcmdtype != thiscmdtype) {
+                        break;  /* can't go any further on this draw call, different render command up next. */
+                    } else if (nextcmd->data.draw.texture != thistexture || nextcmd->data.draw.blend != thisblend) {
+                        break;  /* can't go any further on this draw call, different texture/blendmode copy up next. */
+                    } else {
+                        finalcmd = nextcmd;  /* we can combine copy operations here. Mark this one as the furthest okay command. */
+                        count += nextcmd->data.draw.count;
+                    }
+                    nextcmd = nextcmd->next;
+                }
 
-            case SDL_RENDERCMD_COPY_EX: {
-                const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first);
-                const GLfloat minx = verts[0];
-                const GLfloat miny = verts[1];
-                const GLfloat maxx = verts[2];
-                const GLfloat maxy = verts[3];
-                const GLfloat minu = verts[4];
-                const GLfloat maxu = verts[5];
-                const GLfloat minv = verts[6];
-                const GLfloat maxv = verts[7];
-                const GLfloat translatex = verts[8];
-                const GLfloat translatey = verts[9];
-                const GLdouble angle = verts[10];
-                SetCopyState(data, cmd);
+                if (thistexture) {
+                    ret = SetCopyState(data, cmd);
+                } else {
+                    ret = SetDrawState(data, cmd, SHADER_SOLID);
+                }
 
-                /* Translate to flip, rotate, translate to position */
-                data->glPushMatrix();
-                data->glTranslatef(translatex, translatey, 0.0f);
-                data->glRotated(angle, 0.0, 0.0, 1.0);
-                data->glBegin(GL_TRIANGLE_STRIP);
-                data->glTexCoord2f(minu, minv);
-                data->glVertex2f(minx, miny);
-                data->glTexCoord2f(maxu, minv);
-                data->glVertex2f(maxx, miny);
-                data->glTexCoord2f(minu, maxv);
-                data->glVertex2f(minx, maxy);
-                data->glTexCoord2f(maxu, maxv);
-                data->glVertex2f(maxx, maxy);
-                data->glEnd();
-                data->glPopMatrix();
+                if (ret == 0) {
+                    const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first);
+                    int op = GL_TRIANGLES; /* SDL_RENDERCMD_GEOMETRY */
+                    if (thiscmdtype == SDL_RENDERCMD_DRAW_POINTS) {
+                        op = GL_POINTS;
+                    }
+
+                    if (thiscmdtype == SDL_RENDERCMD_DRAW_POINTS) {
+                        /* SetDrawState handles glEnableClientState. */
+                        data->glVertexPointer(2, GL_FLOAT, sizeof(float) * 2, verts);
+                    } else {
+                        /* SetDrawState handles glEnableClientState. */
+                        if (thistexture) {
+                            data->glVertexPointer(2, GL_FLOAT, sizeof(float) * 5, verts + 0);
+                            data->glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(float) * 5, verts + 2);
+                            data->glTexCoordPointer(2, GL_FLOAT, sizeof(float) * 5, verts + 3);
+                        } else {
+                            data->glVertexPointer(2, GL_FLOAT, sizeof(float) * 3, verts + 0);
+                            data->glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(float) * 3, verts + 2);
+                        }
+                    }
+
+                    data->glDrawArrays(op, 0, (GLsizei) count);
+
+                    /* Restore previously set color when we're done. */
+                    if (thiscmdtype != SDL_RENDERCMD_DRAW_POINTS) {
+                        Uint32 color = data->drawstate.color;
+                        GLubyte a = (GLubyte)((color >> 24) & 0xFF);
+                        GLubyte r = (GLubyte)((color >> 16) & 0xFF);
+                        GLubyte g = (GLubyte)((color >> 8) & 0xFF);
+                        GLubyte b = (GLubyte)((color >> 0) & 0xFF);
+                        data->glColor4ub(r, g, b, a);
+                    }
+                }
+
+                cmd = finalcmd;  /* skip any copy commands we just combined in here. */
                 break;
             }
 
@@ -1336,6 +1404,21 @@ GL_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertic
         cmd = cmd->next;
     }
 
+    /* Turn off vertex array state when we're done, in case external code
+       relies on it being off. */
+    if (data->drawstate.vertex_array) {
+        data->glDisableClientState(GL_VERTEX_ARRAY);
+        data->drawstate.vertex_array = SDL_FALSE;
+    }
+    if (data->drawstate.color_array) {
+        data->glDisableClientState(GL_COLOR_ARRAY);
+        data->drawstate.color_array = SDL_FALSE;
+    }
+    if (data->drawstate.texture_array) {
+        data->glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+        data->drawstate.texture_array = SDL_FALSE;
+    }
+
     return GL_CheckError("", renderer);
 }
 
@@ -1439,10 +1522,12 @@ GL_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
     if (data->texture) {
         renderdata->glDeleteTextures(1, &data->texture);
     }
+#if SDL_HAVE_YUV
     if (data->yuv) {
         renderdata->glDeleteTextures(1, &data->utexture);
         renderdata->glDeleteTextures(1, &data->vtexture);
     }
+#endif
     SDL_free(data->pixels);
     SDL_free(data);
     texture->driverdata = NULL;
@@ -1496,23 +1581,44 @@ GL_BindTexture (SDL_Renderer * renderer, SDL_Texture *texture, float *texw, floa
     GL_ActivateRenderer(renderer);
 
     data->glEnable(textype);
+#if SDL_HAVE_YUV
     if (texturedata->yuv) {
-        data->glActiveTextureARB(GL_TEXTURE2_ARB);
+        if (data->GL_ARB_multitexture_supported) {
+            data->glActiveTextureARB(GL_TEXTURE2_ARB);
+        }
         data->glBindTexture(textype, texturedata->vtexture);
 
-        data->glActiveTextureARB(GL_TEXTURE1_ARB);
+        if (data->GL_ARB_multitexture_supported) {
+            data->glActiveTextureARB(GL_TEXTURE1_ARB);
+        }
         data->glBindTexture(textype, texturedata->utexture);
 
-        data->glActiveTextureARB(GL_TEXTURE0_ARB);
+        if (data->GL_ARB_multitexture_supported) {
+            data->glActiveTextureARB(GL_TEXTURE0_ARB);
+        }
     }
+    if (texturedata->nv12) {
+        if (data->GL_ARB_multitexture_supported) {
+            data->glActiveTextureARB(GL_TEXTURE1_ARB);
+        }
+        data->glBindTexture(textype, texturedata->utexture);
+
+        if (data->GL_ARB_multitexture_supported) {
+            data->glActiveTextureARB(GL_TEXTURE0_ARB);
+        }
+    }
+#endif
     data->glBindTexture(textype, texturedata->texture);
 
     data->drawstate.texturing = SDL_TRUE;
     data->drawstate.texture = texture;
 
-    if(texw) *texw = (float)texturedata->texw;
-    if(texh) *texh = (float)texturedata->texh;
-
+    if (texw) {
+        *texw = (float)texturedata->texw;
+    }
+    if (texh) {
+        *texh = (float)texturedata->texh;
+    }
     return 0;
 }
 
@@ -1525,16 +1631,37 @@ GL_UnbindTexture (SDL_Renderer * renderer, SDL_Texture *texture)
 
     GL_ActivateRenderer(renderer);
 
+#if SDL_HAVE_YUV
     if (texturedata->yuv) {
-        data->glActiveTextureARB(GL_TEXTURE2_ARB);
+        if (data->GL_ARB_multitexture_supported) {
+            data->glActiveTextureARB(GL_TEXTURE2_ARB);
+        }
+        data->glBindTexture(textype, 0);
         data->glDisable(textype);
 
-        data->glActiveTextureARB(GL_TEXTURE1_ARB);
+        if (data->GL_ARB_multitexture_supported) {
+            data->glActiveTextureARB(GL_TEXTURE1_ARB);
+        }
+        data->glBindTexture(textype, 0);
         data->glDisable(textype);
 
-        data->glActiveTextureARB(GL_TEXTURE0_ARB);
+        if (data->GL_ARB_multitexture_supported) {
+            data->glActiveTextureARB(GL_TEXTURE0_ARB);
+        }
     }
+    if (texturedata->nv12) {
+        if (data->GL_ARB_multitexture_supported) {
+            data->glActiveTextureARB(GL_TEXTURE1_ARB);
+        }
+        data->glBindTexture(textype, 0);
+        data->glDisable(textype);
 
+        if (data->GL_ARB_multitexture_supported) {
+            data->glActiveTextureARB(GL_TEXTURE0_ARB);
+        }
+    }
+#endif
+    data->glBindTexture(textype, 0);
     data->glDisable(textype);
 
     data->drawstate.texturing = SDL_FALSE;
@@ -1543,6 +1670,52 @@ GL_UnbindTexture (SDL_Renderer * renderer, SDL_Texture *texture)
     return 0;
 }
 
+static int
+GL_SetVSync(SDL_Renderer * renderer, const int vsync)
+{
+    int retval;
+    if (vsync) {
+        retval = SDL_GL_SetSwapInterval(1);
+    } else {
+        retval = SDL_GL_SetSwapInterval(0);
+    }
+    if (retval != 0) {
+        return retval;
+    }
+    if (SDL_GL_GetSwapInterval() > 0) {
+        renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
+    } else {
+        renderer->info.flags &= ~SDL_RENDERER_PRESENTVSYNC;
+    }
+    return retval;
+}
+
+static SDL_bool
+GL_IsProbablyAccelerated(const GL_RenderData *data)
+{
+    /*const char *vendor = (const char *) data->glGetString(GL_VENDOR);*/
+    const char *renderer = (const char *) data->glGetString(GL_RENDERER);
+
+#ifdef __WINDOWS__
+    if (SDL_strcmp(renderer, "GDI Generic") == 0) {
+        return SDL_FALSE;  /* Microsoft's fallback software renderer. Fix your system! */
+    }
+#endif
+
+#ifdef __APPLE__
+    if (SDL_strcmp(renderer, "Apple Software Renderer") == 0) {
+        return SDL_FALSE;  /* (a probably very old) Apple software-based OpenGL. */
+    }
+#endif
+
+	if (SDL_strcmp(renderer, "Software Rasterizer") == 0) {
+        return SDL_FALSE;  /* (a probably very old) Software Mesa, or some other generic thing. */
+    }
+
+    /* !!! FIXME: swrast? llvmpipe? softpipe? */
+
+    return SDL_TRUE;
+}
 
 static SDL_Renderer *
 GL_CreateRenderer(SDL_Window * window, Uint32 flags)
@@ -1553,6 +1726,8 @@ GL_CreateRenderer(SDL_Window * window, Uint32 flags)
     Uint32 window_flags;
     int profile_mask = 0, major = 0, minor = 0;
     SDL_bool changed_window = SDL_FALSE;
+    const char *hint;
+    SDL_bool non_power_of_two_supported = SDL_FALSE;
 
     SDL_GL_GetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, &profile_mask);
     SDL_GL_GetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, &major);
@@ -1589,7 +1764,10 @@ GL_CreateRenderer(SDL_Window * window, Uint32 flags)
     renderer->SupportsBlendMode = GL_SupportsBlendMode;
     renderer->CreateTexture = GL_CreateTexture;
     renderer->UpdateTexture = GL_UpdateTexture;
+#if SDL_HAVE_YUV
     renderer->UpdateTextureYUV = GL_UpdateTextureYUV;
+    renderer->UpdateTextureNV = GL_UpdateTextureNV;
+#endif
     renderer->LockTexture = GL_LockTexture;
     renderer->UnlockTexture = GL_UnlockTexture;
     renderer->SetTextureScaleMode = GL_SetTextureScaleMode;
@@ -1598,18 +1776,17 @@ GL_CreateRenderer(SDL_Window * window, Uint32 flags)
     renderer->QueueSetDrawColor = GL_QueueSetViewport;  /* SetViewport and SetDrawColor are (currently) no-ops. */
     renderer->QueueDrawPoints = GL_QueueDrawPoints;
     renderer->QueueDrawLines = GL_QueueDrawLines;
-    renderer->QueueFillRects = GL_QueueFillRects;
-    renderer->QueueCopy = GL_QueueCopy;
-    renderer->QueueCopyEx = GL_QueueCopyEx;
+    renderer->QueueGeometry = GL_QueueGeometry;
     renderer->RunCommandQueue = GL_RunCommandQueue;
     renderer->RenderReadPixels = GL_RenderReadPixels;
     renderer->RenderPresent = GL_RenderPresent;
     renderer->DestroyTexture = GL_DestroyTexture;
     renderer->DestroyRenderer = GL_DestroyRenderer;
+    renderer->SetVSync = GL_SetVSync;
     renderer->GL_BindTexture = GL_BindTexture;
     renderer->GL_UnbindTexture = GL_UnbindTexture;
     renderer->info = GL_RenderDriver.info;
-    renderer->info.flags = SDL_RENDERER_ACCELERATED;
+    renderer->info.flags = 0;  /* will set some flags below. */
     renderer->driverdata = data;
     renderer->window = window;
 
@@ -1633,6 +1810,10 @@ GL_CreateRenderer(SDL_Window * window, Uint32 flags)
         goto error;
     }
 
+    if (GL_IsProbablyAccelerated(data)) {
+        renderer->info.flags |= SDL_RENDERER_ACCELERATED;
+    }
+
 #ifdef __MACOSX__
     /* Enable multi-threaded rendering */
     /* Disabled until Ryan finishes his VBO/PBO code...
@@ -1666,15 +1847,37 @@ GL_CreateRenderer(SDL_Window * window, Uint32 flags)
         data->glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
     }
 
+    hint = SDL_getenv("GL_ARB_texture_non_power_of_two");
+    if (!hint || *hint != '0') {
+        SDL_bool isGL2 = SDL_FALSE;
+        const char *verstr = (const char *)data->glGetString(GL_VERSION);
+        if (verstr) {
+            char verbuf[16];
+            char *ptr;
+            SDL_strlcpy(verbuf, verstr, sizeof (verbuf));
+            ptr = SDL_strchr(verbuf, '.');
+            if (ptr) {
+                *ptr = '\0';
+                if (SDL_atoi(verbuf) >= 2) {
+                    isGL2 = SDL_TRUE;
+                }
+            }
+        }
+        if (isGL2 || SDL_GL_ExtensionSupported("GL_ARB_texture_non_power_of_two")) {
+            non_power_of_two_supported = SDL_TRUE;
+        }
+    }
+
     data->textype = GL_TEXTURE_2D;
-    if (SDL_GL_ExtensionSupported("GL_ARB_texture_non_power_of_two")) {
+    if (non_power_of_two_supported) {
         data->GL_ARB_texture_non_power_of_two_supported = SDL_TRUE;
+        data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
+        renderer->info.max_texture_width = value;
+        renderer->info.max_texture_height = value;
     } else if (SDL_GL_ExtensionSupported("GL_ARB_texture_rectangle") ||
                SDL_GL_ExtensionSupported("GL_EXT_texture_rectangle")) {
         data->GL_ARB_texture_rectangle_supported = SDL_TRUE;
         data->textype = GL_TEXTURE_RECTANGLE_ARB;
-    }
-    if (data->GL_ARB_texture_rectangle_supported) {
         data->glGetIntegerv(GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB, &value);
         renderer->info.max_texture_width = value;
         renderer->info.max_texture_height = value;
@@ -1699,7 +1902,7 @@ GL_CreateRenderer(SDL_Window * window, Uint32 flags)
     }
     SDL_LogInfo(SDL_LOG_CATEGORY_RENDER, "OpenGL shaders: %s",
                 data->shaders ? "ENABLED" : "DISABLED");
-
+#if SDL_HAVE_YUV
     /* We support YV12 textures using 3 textures and a shader */
     if (data->shaders && data->num_texture_units >= 3) {
         renderer->info.texture_formats[renderer->info.num_texture_formats++] = SDL_PIXELFORMAT_YV12;
@@ -1707,7 +1910,7 @@ GL_CreateRenderer(SDL_Window * window, Uint32 flags)
         renderer->info.texture_formats[renderer->info.num_texture_formats++] = SDL_PIXELFORMAT_NV12;
         renderer->info.texture_formats[renderer->info.num_texture_formats++] = SDL_PIXELFORMAT_NV21;
     }
-
+#endif
 #ifdef __MACOSX__
     renderer->info.texture_formats[renderer->info.num_texture_formats++] = SDL_PIXELFORMAT_UYVY;
 #endif
@@ -1736,7 +1939,7 @@ GL_CreateRenderer(SDL_Window * window, Uint32 flags)
     data->glDisable(GL_SCISSOR_TEST);
     data->glDisable(data->textype);
     data->glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
-    data->glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
+    data->glColor4ub(255, 255, 255, 255);
     /* This ended up causing video discrepancies between OpenGL and Direct3D */
     /* data->glEnable(GL_LINE_SMOOTH); */
 
diff --git a/Engine/lib/sdl/src/render/opengl/SDL_shaders_gl.c b/Engine/lib/sdl/src/render/opengl/SDL_shaders_gl.c
index db20ea17e..4db083555 100644
--- a/Engine/lib/sdl/src/render/opengl/SDL_shaders_gl.c
+++ b/Engine/lib/sdl/src/render/opengl/SDL_shaders_gl.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -149,7 +149,7 @@ struct GL_ShaderContext
 "uniform sampler2D tex1; // U/V \n"                             \
 "\n"                                                            \
 
-#define NV12_SHADER_BODY                                        \
+#define NV12_RA_SHADER_BODY                                     \
 "\n"                                                            \
 "void main()\n"                                                 \
 "{\n"                                                           \
@@ -174,6 +174,31 @@ struct GL_ShaderContext
 "    gl_FragColor = vec4(rgb, 1.0) * v_color;\n"                \
 "}"                                                             \
 
+#define NV12_RG_SHADER_BODY                                     \
+"\n"                                                            \
+"void main()\n"                                                 \
+"{\n"                                                           \
+"    vec2 tcoord;\n"                                            \
+"    vec3 yuv, rgb;\n"                                          \
+"\n"                                                            \
+"    // Get the Y value \n"                                     \
+"    tcoord = v_texCoord;\n"                                    \
+"    yuv.x = texture2D(tex0, tcoord).r;\n"                      \
+"\n"                                                            \
+"    // Get the U and V values \n"                              \
+"    tcoord *= UVCoordScale;\n"                                 \
+"    yuv.yz = texture2D(tex1, tcoord).rg;\n"                    \
+"\n"                                                            \
+"    // Do the color transform \n"                              \
+"    yuv += offset;\n"                                          \
+"    rgb.r = dot(yuv, Rcoeff);\n"                               \
+"    rgb.g = dot(yuv, Gcoeff);\n"                               \
+"    rgb.b = dot(yuv, Bcoeff);\n"                               \
+"\n"                                                            \
+"    // That was easy. :) \n"                                   \
+"    gl_FragColor = vec4(rgb, 1.0) * v_color;\n"                \
+"}"                                                             \
+
 #define NV21_SHADER_PROLOGUE                                    \
 "varying vec4 v_color;\n"                                       \
 "varying vec2 v_texCoord;\n"                                    \
@@ -259,7 +284,7 @@ static const char *shader_source[NUM_SHADERS][2] =
 "    gl_FragColor = texture2D(tex0, v_texCoord) * v_color;\n"
 "}"
     },
-
+#if SDL_HAVE_YUV
     /* SHADER_YUV_JPEG */
     {
         /* vertex shader */
@@ -294,25 +319,43 @@ static const char *shader_source[NUM_SHADERS][2] =
         /* fragment shader */
         NV12_SHADER_PROLOGUE
         JPEG_SHADER_CONSTANTS
-        NV12_SHADER_BODY
+        NV12_RA_SHADER_BODY
     },
-    /* SHADER_NV12_BT601 */
+    /* SHADER_NV12_RA_BT601 */
     {
         /* vertex shader */
         TEXTURE_VERTEX_SHADER,
         /* fragment shader */
         NV12_SHADER_PROLOGUE
         BT601_SHADER_CONSTANTS
-        NV12_SHADER_BODY
+        NV12_RA_SHADER_BODY
     },
-    /* SHADER_NV12_BT709 */
+    /* SHADER_NV12_RG_BT601 */
+    {
+        /* vertex shader */
+        TEXTURE_VERTEX_SHADER,
+        /* fragment shader */
+        NV12_SHADER_PROLOGUE
+        BT601_SHADER_CONSTANTS
+        NV12_RG_SHADER_BODY
+    },
+    /* SHADER_NV12_RA_BT709 */
     {
         /* vertex shader */
         TEXTURE_VERTEX_SHADER,
         /* fragment shader */
         NV12_SHADER_PROLOGUE
         BT709_SHADER_CONSTANTS
-        NV12_SHADER_BODY
+        NV12_RA_SHADER_BODY
+    },
+    /* SHADER_NV12_RG_BT709 */
+    {
+        /* vertex shader */
+        TEXTURE_VERTEX_SHADER,
+        /* fragment shader */
+        NV12_SHADER_PROLOGUE
+        BT709_SHADER_CONSTANTS
+        NV12_RG_SHADER_BODY
     },
     /* SHADER_NV21_JPEG */
     {
@@ -341,6 +384,7 @@ static const char *shader_source[NUM_SHADERS][2] =
         BT709_SHADER_CONSTANTS
         NV21_SHADER_BODY
     },
+#endif /* SDL_HAVE_YUV */
 };
 
 static SDL_bool
diff --git a/Engine/lib/sdl/src/render/opengl/SDL_shaders_gl.h b/Engine/lib/sdl/src/render/opengl/SDL_shaders_gl.h
index 71d864c4f..d3e6c398a 100644
--- a/Engine/lib/sdl/src/render/opengl/SDL_shaders_gl.h
+++ b/Engine/lib/sdl/src/render/opengl/SDL_shaders_gl.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -32,15 +32,19 @@ typedef enum {
     SHADER_SOLID,
     SHADER_RGB,
     SHADER_RGBA,
+#if SDL_HAVE_YUV
     SHADER_YUV_JPEG,
     SHADER_YUV_BT601,
     SHADER_YUV_BT709,
     SHADER_NV12_JPEG,
-    SHADER_NV12_BT601,
-    SHADER_NV12_BT709,
+    SHADER_NV12_RA_BT601,
+    SHADER_NV12_RG_BT601,
+    SHADER_NV12_RA_BT709,
+    SHADER_NV12_RG_BT709,
     SHADER_NV21_JPEG,
     SHADER_NV21_BT601,
     SHADER_NV21_BT709,
+#endif
     NUM_SHADERS
 } GL_Shader;
 
diff --git a/Engine/lib/sdl/src/render/opengles/SDL_glesfuncs.h b/Engine/lib/sdl/src/render/opengles/SDL_glesfuncs.h
index e1d54bd95..40a656455 100644
--- a/Engine/lib/sdl/src/render/opengles/SDL_glesfuncs.h
+++ b/Engine/lib/sdl/src/render/opengles/SDL_glesfuncs.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -27,6 +27,7 @@ SDL_PROC_OES(void, glBlendFuncSeparateOES, (GLenum, GLenum, GLenum, GLenum))
 SDL_PROC(void, glClear, (GLbitfield))
 SDL_PROC(void, glClearColor, (GLclampf, GLclampf, GLclampf, GLclampf))
 SDL_PROC(void, glColor4f, (GLfloat, GLfloat, GLfloat, GLfloat))
+SDL_PROC(void, glColorPointer, (GLint, GLenum, GLsizei, const GLvoid *))
 SDL_PROC(void, glDeleteTextures, (GLsizei, const GLuint *))
 SDL_PROC(void, glDisable, (GLenum))
 SDL_PROC(void, glDisableClientState, (GLenum array))
@@ -56,10 +57,6 @@ SDL_PROC(void, glViewport, (GLint, GLint, GLsizei, GLsizei))
 SDL_PROC_OES(void, glBindFramebufferOES, (GLenum, GLuint))
 SDL_PROC_OES(void, glFramebufferTexture2DOES, (GLenum, GLenum, GLenum, GLuint, GLint))
 SDL_PROC_OES(GLenum, glCheckFramebufferStatusOES, (GLenum))
-SDL_PROC(void, glPushMatrix, (void))
-SDL_PROC(void, glTranslatef, (GLfloat, GLfloat, GLfloat))
-SDL_PROC(void, glRotatef, (GLfloat, GLfloat, GLfloat, GLfloat))
-SDL_PROC(void, glPopMatrix, (void))
 SDL_PROC_OES(void, glDeleteFramebuffersOES, (GLsizei, const GLuint*))
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/render/opengles/SDL_render_gles.c b/Engine/lib/sdl/src/render/opengles/SDL_render_gles.c
index 6bb3031e9..a6b58f2d7 100644
--- a/Engine/lib/sdl/src/render/opengles/SDL_render_gles.c
+++ b/Engine/lib/sdl/src/render/opengles/SDL_render_gles.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -564,194 +564,98 @@ static int
 GLES_QueueDrawLines(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FPoint * points, int count)
 {
     int i;
+    GLfloat prevx, prevy;
     const size_t vertlen = (sizeof (GLfloat) * 2) * count;
     GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, vertlen, 0, &cmd->data.draw.first);
+
     if (!verts) {
         return -1;
     }
     cmd->data.draw.count = count;
 
-    /* Offset to hit the center of the pixel. */
-    for (i = 0; i < count; i++) {
-        *(verts++) = 0.5f + points[i].x;
-        *(verts++) = 0.5f + points[i].y;
+    /* 0.5f offset to hit the center of the pixel. */
+    prevx = 0.5f + points->x;
+    prevy = 0.5f + points->y;
+    *(verts++) = prevx;
+    *(verts++) = prevy;
+
+    /* bump the end of each line segment out a quarter of a pixel, to provoke
+       the diamond-exit rule. Without this, you won't just drop the last
+       pixel of the last line segment, but you might also drop pixels at the
+       edge of any given line segment along the way too. */
+    for (i = 1; i < count; i++) {
+        const GLfloat xstart = prevx;
+        const GLfloat ystart = prevy;
+        const GLfloat xend = points[i].x + 0.5f;  /* 0.5f to hit pixel center. */
+        const GLfloat yend = points[i].y + 0.5f;
+        /* bump a little in the direction we are moving in. */
+        const GLfloat deltax = xend - xstart;
+        const GLfloat deltay = yend - ystart;
+        const GLfloat angle = SDL_atan2f(deltay, deltax);
+        prevx = xend + (SDL_cosf(angle) * 0.25f);
+        prevy = yend + (SDL_sinf(angle) * 0.25f);
+        *(verts++) = prevx;
+        *(verts++) = prevy;
     }
 
-    /* Make the last line segment one pixel longer, to satisfy the
-       diamond-exit rule. */
-    verts -= 4;
-    {
-        const GLfloat xstart = verts[0];
-        const GLfloat ystart = verts[1];
-        const GLfloat xend = verts[2];
-        const GLfloat yend = verts[3];
+    return 0;
+}
 
-        if (ystart == yend) {  /* horizontal line */
-            verts[2] += (xend > xstart) ? 1.0f : -1.0f;
-        } else if (xstart == xend) {  /* vertical line */
-            verts[3] += (yend > ystart) ? 1.0f : -1.0f;
-        } else {  /* bump a pixel in the direction we are moving in. */
-            const GLfloat deltax = xend - xstart;
-            const GLfloat deltay = yend - ystart;
-            const GLfloat angle = SDL_atan2f(deltay, deltax);
-            verts[2] += SDL_cosf(angle);
-            verts[3] += SDL_sinf(angle);
+static int
+GLES_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+        const float *xy, int xy_stride, const SDL_Color *color, int color_stride, const float *uv, int uv_stride,
+        int num_vertices, const void *indices, int num_indices, int size_indices,
+        float scale_x, float scale_y)
+{
+    GLES_TextureData *texturedata = NULL;
+    int i;
+    int count = indices ? num_indices : num_vertices;
+    GLfloat *verts;
+    int sz = 2 + 4 + (texture ? 2 : 0);
+
+    verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, count * sz * sizeof (GLfloat), 0, &cmd->data.draw.first);
+    if (!verts) {
+        return -1;
+    }
+
+    if (texture) {
+        texturedata = (GLES_TextureData *) texture->driverdata;
+    }
+
+    cmd->data.draw.count = count;
+    size_indices = indices ? size_indices : 0;
+
+    for (i = 0; i < count; i++) {
+        int j;
+        float *xy_;
+        SDL_Color col_;
+        if (size_indices == 4) {
+            j = ((const Uint32 *)indices)[i];
+        } else if (size_indices == 2) {
+            j = ((const Uint16 *)indices)[i];
+        } else if (size_indices == 1) {
+            j = ((const Uint8 *)indices)[i];
+        } else {
+            j = i;
+        }
+
+        xy_ = (float *)((char*)xy + j * xy_stride);
+        col_ = *(SDL_Color *)((char*)color + j * color_stride);
+
+        *(verts++) = xy_[0] * scale_x;
+        *(verts++) = xy_[1] * scale_y;
+
+        *(verts++) = col_.r * inv255f;
+        *(verts++) = col_.g * inv255f;
+        *(verts++) = col_.b * inv255f;
+        *(verts++) = col_.a * inv255f;
+
+        if (texture) {
+            float *uv_ = (float *)((char*)uv + j * uv_stride);
+            *(verts++) = uv_[0] * texturedata->texw;
+            *(verts++) = uv_[1] * texturedata->texh;
         }
     }
-
-    return 0;
-}
-
-static int
-GLES_QueueFillRects(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FRect * rects, int count)
-{
-    GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, count * 8 * sizeof (GLfloat), 0, &cmd->data.draw.first);
-    int i;
-
-    if (!verts) {
-        return -1;
-    }
-
-    cmd->data.draw.count = count;
-
-    for (i = 0; i < count; i++) {
-        const SDL_FRect *rect = &rects[i];
-        const GLfloat minx = rect->x;
-        const GLfloat maxx = rect->x + rect->w;
-        const GLfloat miny = rect->y;
-        const GLfloat maxy = rect->y + rect->h;
-        *(verts++) = minx;
-        *(verts++) = miny;
-        *(verts++) = maxx;
-        *(verts++) = miny;
-        *(verts++) = minx;
-        *(verts++) = maxy;
-        *(verts++) = maxx;
-        *(verts++) = maxy;
-    }
-
-    return 0;
-}
-
-static int
-GLES_QueueCopy(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture,
-                          const SDL_Rect * srcrect, const SDL_FRect * dstrect)
-{
-    GLES_TextureData *texturedata = (GLES_TextureData *) texture->driverdata;
-    GLfloat minx, miny, maxx, maxy;
-    GLfloat minu, maxu, minv, maxv;
-    GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, 16 * sizeof (GLfloat), 0, &cmd->data.draw.first);
-
-    if (!verts) {
-        return -1;
-    }
-
-    cmd->data.draw.count = 1;
-
-    minx = dstrect->x;
-    miny = dstrect->y;
-    maxx = dstrect->x + dstrect->w;
-    maxy = dstrect->y + dstrect->h;
-
-    minu = (GLfloat) srcrect->x / texture->w;
-    minu *= texturedata->texw;
-    maxu = (GLfloat) (srcrect->x + srcrect->w) / texture->w;
-    maxu *= texturedata->texw;
-    minv = (GLfloat) srcrect->y / texture->h;
-    minv *= texturedata->texh;
-    maxv = (GLfloat) (srcrect->y + srcrect->h) / texture->h;
-    maxv *= texturedata->texh;
-
-    *(verts++) = minx;
-    *(verts++) = miny;
-    *(verts++) = maxx;
-    *(verts++) = miny;
-    *(verts++) = minx;
-    *(verts++) = maxy;
-    *(verts++) = maxx;
-    *(verts++) = maxy;
-
-    *(verts++) = minu;
-    *(verts++) = minv;
-    *(verts++) = maxu;
-    *(verts++) = minv;
-    *(verts++) = minu;
-    *(verts++) = maxv;
-    *(verts++) = maxu;
-    *(verts++) = maxv;
-
-    return 0;
-}
-
-static int
-GLES_QueueCopyEx(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture,
-                        const SDL_Rect * srcquad, const SDL_FRect * dstrect,
-                        const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip)
-{
-    GLES_TextureData *texturedata = (GLES_TextureData *) texture->driverdata;
-    GLfloat minx, miny, maxx, maxy;
-    GLfloat centerx, centery;
-    GLfloat minu, maxu, minv, maxv;
-    GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, 19 * sizeof (GLfloat), 0, &cmd->data.draw.first);
-
-    if (!verts) {
-        return -1;
-    }
-
-    centerx = center->x;
-    centery = center->y;
-
-    if (flip & SDL_FLIP_HORIZONTAL) {
-        minx =  dstrect->w - centerx;
-        maxx = -centerx;
-    }
-    else {
-        minx = -centerx;
-        maxx =  dstrect->w - centerx;
-    }
-
-    if (flip & SDL_FLIP_VERTICAL) {
-        miny =  dstrect->h - centery;
-        maxy = -centery;
-    }
-    else {
-        miny = -centery;
-        maxy =  dstrect->h - centery;
-    }
-
-    minu = (GLfloat) srcquad->x / texture->w;
-    minu *= texturedata->texw;
-    maxu = (GLfloat) (srcquad->x + srcquad->w) / texture->w;
-    maxu *= texturedata->texw;
-    minv = (GLfloat) srcquad->y / texture->h;
-    minv *= texturedata->texh;
-    maxv = (GLfloat) (srcquad->y + srcquad->h) / texture->h;
-    maxv *= texturedata->texh;
-
-    cmd->data.draw.count = 1;
-
-    *(verts++) = minx;
-    *(verts++) = miny;
-    *(verts++) = maxx;
-    *(verts++) = miny;
-    *(verts++) = minx;
-    *(verts++) = maxy;
-    *(verts++) = maxx;
-    *(verts++) = maxy;
-
-    *(verts++) = minu;
-    *(verts++) = minv;
-    *(verts++) = maxu;
-    *(verts++) = minv;
-    *(verts++) = minu;
-    *(verts++) = maxv;
-    *(verts++) = maxu;
-    *(verts++) = maxv;
-
-    *(verts++) = (GLfloat) dstrect->x + centerx;
-    *(verts++) = (GLfloat) dstrect->y + centery;
-    *(verts++) = (GLfloat) angle;
-
     return 0;
 }
 
@@ -763,7 +667,7 @@ SetDrawState(GLES_RenderData *data, const SDL_RenderCommand *cmd)
     const Uint8 g = cmd->data.draw.g;
     const Uint8 b = cmd->data.draw.b;
     const Uint8 a = cmd->data.draw.a;
-    const Uint32 color = ((a << 24) | (r << 16) | (g << 8) | b);
+    const Uint32 color = (((Uint32)a << 24) | (r << 16) | (g << 8) | b);
 
     if (color != data->drawstate.color) {
         const GLfloat fr = ((GLfloat) r) * inv255f;
@@ -865,7 +769,6 @@ static int
 GLES_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
 {
     GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
-    size_t i;
 
     if (GLES_ActivateRenderer(renderer) < 0) {
         return -1;
@@ -874,7 +777,15 @@ GLES_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vert
     data->drawstate.target = renderer->target;
 
     if (!renderer->target) {
-        SDL_GL_GetDrawableSize(renderer->window, &data->drawstate.drawablew, &data->drawstate.drawableh);
+        int w, h;
+        SDL_GL_GetDrawableSize(renderer->window, &w, &h);
+        if ((w != data->drawstate.drawablew) || (h != data->drawstate.drawableh)) {
+            data->drawstate.viewport_dirty = SDL_TRUE;  // if the window dimensions changed, invalidate the current viewport, etc.
+            data->drawstate.cliprect_dirty = SDL_TRUE;
+            data->drawstate.drawablew = w;
+            data->drawstate.drawableh = h;
+        }
+
     }
 
     while (cmd) {
@@ -910,7 +821,7 @@ GLES_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vert
                 const Uint8 g = cmd->data.color.g;
                 const Uint8 b = cmd->data.color.b;
                 const Uint8 a = cmd->data.color.a;
-                const Uint32 color = ((a << 24) | (r << 16) | (g << 8) | b);
+                const Uint32 color = (((Uint32)a << 24) | (r << 16) | (g << 8) | b);
                 if (color != data->drawstate.clear_color) {
                     const GLfloat fr = ((GLfloat) r) * inv255f;
                     const GLfloat fg = ((GLfloat) g) * inv255f;
@@ -949,42 +860,38 @@ GLES_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vert
                 break;
             }
 
-            case SDL_RENDERCMD_FILL_RECTS: {
+            case SDL_RENDERCMD_FILL_RECTS: /* unused */
+                break;
+
+            case SDL_RENDERCMD_COPY: /* unused */
+                break;
+
+            case SDL_RENDERCMD_COPY_EX: /* unused */
+                break;
+
+            case SDL_RENDERCMD_GEOMETRY: {
+                const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first);
+                SDL_Texture *texture = cmd->data.draw.texture;
                 const size_t count = cmd->data.draw.count;
-                const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first);
-                GLsizei offset = 0;
-                SetDrawState(data, cmd);
-                data->glVertexPointer(2, GL_FLOAT, 0, verts);
-                for (i = 0; i < count; ++i, offset += 4) {
-                    data->glDrawArrays(GL_TRIANGLE_STRIP, offset, 4);
+                int stride = (2 + 4 + (texture ? 2 : 0)) * sizeof (float);
+
+                if (texture) {
+                    SetCopyState(data, cmd);
+                } else {
+                    SetDrawState(data, cmd);
                 }
-                break;
-            }
 
-            case SDL_RENDERCMD_COPY: {
-                const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first);
-                SetCopyState(data, cmd);
-                data->glVertexPointer(2, GL_FLOAT, 0, verts);
-                data->glTexCoordPointer(2, GL_FLOAT, 0, verts + 8);
-                data->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-                break;
-            }
+                data->glEnableClientState(GL_COLOR_ARRAY);
 
-            case SDL_RENDERCMD_COPY_EX: {
-                const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first);
-                const GLfloat translatex = verts[16];
-                const GLfloat translatey = verts[17];
-                const GLfloat angle = verts[18];
-                SetCopyState(data, cmd);
-                data->glVertexPointer(2, GL_FLOAT, 0, verts);
-                data->glTexCoordPointer(2, GL_FLOAT, 0, verts + 8);
+                data->glVertexPointer(2, GL_FLOAT, stride, verts);
+                data->glColorPointer(4, GL_FLOAT, stride, verts + 2);
+                if (texture) {
+                    data->glTexCoordPointer(2, GL_FLOAT, stride, verts + 2 + 4);
+                }
 
-                /* Translate to flip, rotate, translate to position */
-                data->glPushMatrix();
-                data->glTranslatef(translatex, translatey, 0.0f);
-                data->glRotatef(angle, 0.0, 0.0, 1.0);
-                data->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-                data->glPopMatrix();
+                data->glDrawArrays(GL_TRIANGLES, 0, (GLsizei) count);
+
+                data->glDisableClientState(GL_COLOR_ARRAY);
                 break;
             }
 
@@ -1141,6 +1048,27 @@ static int GLES_UnbindTexture (SDL_Renderer * renderer, SDL_Texture *texture)
     return 0;
 }
 
+static int
+GLES_SetVSync(SDL_Renderer * renderer, const int vsync)
+{
+    int retval;
+    if (vsync) {
+        retval = SDL_GL_SetSwapInterval(1);
+    } else {
+        retval = SDL_GL_SetSwapInterval(0);
+    }
+    if (retval != 0) {
+        return retval;
+    }
+    if (SDL_GL_GetSwapInterval() > 0) {
+        renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
+    } else {
+        renderer->info.flags &= ~SDL_RENDERER_PRESENTVSYNC;
+    }
+    return retval;
+}
+
+
 static SDL_Renderer *
 GLES_CreateRenderer(SDL_Window * window, Uint32 flags)
 {
@@ -1195,14 +1123,13 @@ GLES_CreateRenderer(SDL_Window * window, Uint32 flags)
     renderer->QueueSetDrawColor = GLES_QueueSetViewport;  /* SetViewport and SetDrawColor are (currently) no-ops. */
     renderer->QueueDrawPoints = GLES_QueueDrawPoints;
     renderer->QueueDrawLines = GLES_QueueDrawLines;
-    renderer->QueueFillRects = GLES_QueueFillRects;
-    renderer->QueueCopy = GLES_QueueCopy;
-    renderer->QueueCopyEx = GLES_QueueCopyEx;
+    renderer->QueueGeometry = GLES_QueueGeometry;
     renderer->RunCommandQueue = GLES_RunCommandQueue;
     renderer->RenderReadPixels = GLES_RenderReadPixels;
     renderer->RenderPresent = GLES_RenderPresent;
     renderer->DestroyTexture = GLES_DestroyTexture;
     renderer->DestroyRenderer = GLES_DestroyRenderer;
+    renderer->SetVSync = GLES_SetVSync;
     renderer->GL_BindTexture = GLES_BindTexture;
     renderer->GL_UnbindTexture = GLES_UnbindTexture;
     renderer->info = GLES_RenderDriver.info;
diff --git a/Engine/lib/sdl/src/render/opengles2/SDL_gles2funcs.h b/Engine/lib/sdl/src/render/opengles2/SDL_gles2funcs.h
index 2a914ae99..ab8bf85bb 100644
--- a/Engine/lib/sdl/src/render/opengles2/SDL_gles2funcs.h
+++ b/Engine/lib/sdl/src/render/opengles2/SDL_gles2funcs.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -41,7 +41,6 @@ SDL_PROC(void, glEnableVertexAttribArray, (GLuint))
 SDL_PROC(void, glFinish, (void))
 SDL_PROC(void, glGenFramebuffers, (GLsizei, GLuint *))
 SDL_PROC(void, glGenTextures, (GLsizei, GLuint *))
-SDL_PROC(void, glGetBooleanv, (GLenum, GLboolean *))
 SDL_PROC(const GLubyte *, glGetString, (GLenum))
 SDL_PROC(GLenum, glGetError, (void))
 SDL_PROC(void, glGetIntegerv, (GLenum, GLint *))
diff --git a/Engine/lib/sdl/src/render/opengles2/SDL_render_gles2.c b/Engine/lib/sdl/src/render/opengles2/SDL_render_gles2.c
index 38d1e4a44..c2f5d640f 100644
--- a/Engine/lib/sdl/src/render/opengles2/SDL_render_gles2.c
+++ b/Engine/lib/sdl/src/render/opengles2/SDL_render_gles2.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -28,6 +28,17 @@
 #include "../../video/SDL_blit.h"
 #include "SDL_shaders_gles2.h"
 
+/* WebGL doesn't offer client-side arrays, so use Vertex Buffer Objects
+   on Emscripten, which converts GLES2 into WebGL calls.
+   In all other cases, attempt to use client-side arrays, as they tend to
+   be dramatically faster when not batching, and about the same when
+   we are. */
+#if defined(__EMSCRIPTEN__)
+#define USE_VERTEX_BUFFER_OBJECTS 1
+#else
+#define USE_VERTEX_BUFFER_OBJECTS 0
+#endif
+
 /* To prevent unnecessary window recreation,
  * these should match the defaults selected in SDL_GL_ResetAttributes
  */
@@ -58,37 +69,22 @@ typedef struct GLES2_TextureData
     GLenum pixel_type;
     void *pixel_data;
     int pitch;
+#if SDL_HAVE_YUV
     /* YUV texture support */
     SDL_bool yuv;
     SDL_bool nv12;
     GLenum texture_v;
     GLenum texture_u;
+#endif
     GLES2_FBOList *fbo;
 } GLES2_TextureData;
 
-typedef struct GLES2_ShaderCacheEntry
-{
-    GLuint id;
-    GLES2_ShaderType type;
-    const GLES2_ShaderInstance *instance;
-    int references;
-    struct GLES2_ShaderCacheEntry *prev;
-    struct GLES2_ShaderCacheEntry *next;
-} GLES2_ShaderCacheEntry;
-
-typedef struct GLES2_ShaderCache
-{
-    int count;
-    GLES2_ShaderCacheEntry *head;
-} GLES2_ShaderCache;
-
 typedef struct GLES2_ProgramCacheEntry
 {
     GLuint id;
-    GLES2_ShaderCacheEntry *vertex_shader;
-    GLES2_ShaderCacheEntry *fragment_shader;
+    GLuint vertex_shader;
+    GLuint fragment_shader;
     GLuint uniform_locations[16];
-    Uint32 color;
     GLfloat projection[4][4];
     struct GLES2_ProgramCacheEntry *prev;
     struct GLES2_ProgramCacheEntry *next;
@@ -104,16 +100,14 @@ typedef struct GLES2_ProgramCache
 typedef enum
 {
     GLES2_ATTRIBUTE_POSITION = 0,
-    GLES2_ATTRIBUTE_TEXCOORD = 1,
-    GLES2_ATTRIBUTE_ANGLE = 2,
-    GLES2_ATTRIBUTE_CENTER = 3,
+    GLES2_ATTRIBUTE_COLOR = 1,
+    GLES2_ATTRIBUTE_TEXCOORD = 2,
 } GLES2_Attribute;
 
 typedef enum
 {
     GLES2_UNIFORM_PROJECTION,
     GLES2_UNIFORM_TEXTURE,
-    GLES2_UNIFORM_COLOR,
     GLES2_UNIFORM_TEXTURE_U,
     GLES2_UNIFORM_TEXTURE_V
 } GLES2_Uniform;
@@ -144,8 +138,6 @@ typedef struct
     SDL_bool cliprect_dirty;
     SDL_Rect cliprect;
     SDL_bool texturing;
-    SDL_bool is_copy_ex;
-    Uint32 color;
     Uint32 clear_color;
     int drawablew;
     int drawableh;
@@ -165,15 +157,17 @@ typedef struct GLES2_RenderData
     GLES2_FBOList *framebuffers;
     GLuint window_framebuffer;
 
-    int shader_format_count;
-    GLenum *shader_formats;
-    GLES2_ShaderCache shader_cache;
+    GLuint shader_id_cache[GLES2_SHADER_COUNT];
+
     GLES2_ProgramCache program_cache;
     Uint8 clear_r, clear_g, clear_b, clear_a;
 
+#if USE_VERTEX_BUFFER_OBJECTS
     GLuint vertex_buffers[8];
     size_t vertex_buffer_size[8];
     int current_vertex_buffer;
+#endif
+
     GLES2_DrawStateCache drawstate;
 } GLES2_RenderData;
 
@@ -393,32 +387,10 @@ GLES2_SupportsBlendMode(SDL_Renderer * renderer, SDL_BlendMode blendMode)
 }
 
 
-static void
-GLES2_EvictShader(GLES2_RenderData *data, GLES2_ShaderCacheEntry *entry)
-{
-    /* Unlink the shader from the cache */
-    if (entry->next) {
-        entry->next->prev = entry->prev;
-    }
-    if (entry->prev) {
-        entry->prev->next = entry->next;
-    }
-    if (data->shader_cache.head == entry) {
-        data->shader_cache.head = entry->next;
-    }
-    --data->shader_cache.count;
-
-    /* Deallocate the shader */
-    data->glDeleteShader(entry->id);
-    SDL_free(entry);
-}
-
 static GLES2_ProgramCacheEntry *
-GLES2_CacheProgram(GLES2_RenderData *data, GLES2_ShaderCacheEntry *vertex,
-                   GLES2_ShaderCacheEntry *fragment)
+GLES2_CacheProgram(GLES2_RenderData *data, GLuint vertex, GLuint fragment)
 {
     GLES2_ProgramCacheEntry *entry;
-    GLES2_ShaderCacheEntry *shaderEntry;
     GLint linkSuccessful;
 
     /* Check if we've already cached this program */
@@ -456,12 +428,11 @@ GLES2_CacheProgram(GLES2_RenderData *data, GLES2_ShaderCacheEntry *vertex,
 
     /* Create the program and link it */
     entry->id = data->glCreateProgram();
-    data->glAttachShader(entry->id, vertex->id);
-    data->glAttachShader(entry->id, fragment->id);
+    data->glAttachShader(entry->id, vertex);
+    data->glAttachShader(entry->id, fragment);
     data->glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_POSITION, "a_position");
+    data->glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_COLOR, "a_color");
     data->glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_TEXCOORD, "a_texCoord");
-    data->glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_ANGLE, "a_angle");
-    data->glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_CENTER, "a_center");
     data->glLinkProgram(entry->id);
     data->glGetProgramiv(entry->id, GL_LINK_STATUS, &linkSuccessful);
     if (!linkSuccessful) {
@@ -480,10 +451,6 @@ GLES2_CacheProgram(GLES2_RenderData *data, GLES2_ShaderCacheEntry *vertex,
         data->glGetUniformLocation(entry->id, "u_texture_u");
     entry->uniform_locations[GLES2_UNIFORM_TEXTURE] =
         data->glGetUniformLocation(entry->id, "u_texture");
-    entry->uniform_locations[GLES2_UNIFORM_COLOR] =
-        data->glGetUniformLocation(entry->id, "u_color");
-
-    entry->color = 0;
 
     data->glUseProgram(entry->id);
     if (entry->uniform_locations[GLES2_UNIFORM_TEXTURE_V] != -1) {
@@ -498,9 +465,6 @@ GLES2_CacheProgram(GLES2_RenderData *data, GLES2_ShaderCacheEntry *vertex,
     if (entry->uniform_locations[GLES2_UNIFORM_PROJECTION] != -1) {
         data->glUniformMatrix4fv(entry->uniform_locations[GLES2_UNIFORM_PROJECTION], 1, GL_FALSE, (GLfloat *)entry->projection);
     }
-    if (entry->uniform_locations[GLES2_UNIFORM_COLOR] != -1) {
-        data->glUniform4f(entry->uniform_locations[GLES2_UNIFORM_COLOR], 0.0f, 0.0f, 0.0f, 0.0f);
-    }
 
     /* Cache the linked program */
     if (data->program_cache.head) {
@@ -512,20 +476,8 @@ GLES2_CacheProgram(GLES2_RenderData *data, GLES2_ShaderCacheEntry *vertex,
     data->program_cache.head = entry;
     ++data->program_cache.count;
 
-    /* Increment the refcount of the shaders we're using */
-    ++vertex->references;
-    ++fragment->references;
-
     /* Evict the last entry from the cache if we exceed the limit */
     if (data->program_cache.count > GLES2_MAX_CACHED_PROGRAMS) {
-        shaderEntry = data->program_cache.tail->vertex_shader;
-        if (--shaderEntry->references <= 0) {
-            GLES2_EvictShader(data, shaderEntry);
-        }
-        shaderEntry = data->program_cache.tail->fragment_shader;
-        if (--shaderEntry->references <= 0) {
-            GLES2_EvictShader(data, shaderEntry);
-        }
         data->glDeleteProgram(data->program_cache.tail->id);
         data->program_cache.tail = data->program_cache.tail->prev;
         if (data->program_cache.tail != NULL) {
@@ -537,80 +489,34 @@ GLES2_CacheProgram(GLES2_RenderData *data, GLES2_ShaderCacheEntry *vertex,
     return entry;
 }
 
-static GLES2_ShaderCacheEntry *
-GLES2_CacheShader(GLES2_RenderData *data, GLES2_ShaderType type)
+static GLuint
+GLES2_CacheShader(GLES2_RenderData *data, GLES2_ShaderType type, GLenum shader_type)
 {
-    const GLES2_Shader *shader;
-    const GLES2_ShaderInstance *instance = NULL;
-    GLES2_ShaderCacheEntry *entry = NULL;
+    GLuint id;
     GLint compileSuccessful = GL_FALSE;
-    int i, j;
+    const char *shader_src = (char *)GLES2_GetShader(type);
 
-    /* Find the corresponding shader */
-    shader = GLES2_GetShader(type);
-    if (!shader) {
-        SDL_SetError("No shader matching the requested characteristics was found");
-        return NULL;
+    if (!shader_src) {
+        SDL_SetError("No shader src");
+        return 0;
     }
 
-    /* Find a matching shader instance that's supported on this hardware */
-    for (i = 0; i < shader->instance_count && !instance; ++i) {
-        for (j = 0; j < data->shader_format_count && !instance; ++j) {
-            if (!shader->instances[i]) {
-                continue;
-            }
-            if (shader->instances[i]->format != data->shader_formats[j]) {
-                continue;
-            }
-            instance = shader->instances[i];
-        }
-    }
-    if (!instance) {
-        SDL_SetError("The specified shader cannot be loaded on the current platform");
-        return NULL;
-    }
+    /* Compile */
+    id = data->glCreateShader(shader_type);
+    data->glShaderSource(id, 1, &shader_src, NULL);
+    data->glCompileShader(id);
+    data->glGetShaderiv(id, GL_COMPILE_STATUS, &compileSuccessful);
 
-    /* Check if we've already cached this shader */
-    entry = data->shader_cache.head;
-    while (entry) {
-        if (entry->instance == instance) {
-            break;
-        }
-        entry = entry->next;
-    }
-    if (entry) {
-        return entry;
-    }
-
-    /* Create a shader cache entry */
-    entry = (GLES2_ShaderCacheEntry *)SDL_calloc(1, sizeof(GLES2_ShaderCacheEntry));
-    if (!entry) {
-        SDL_OutOfMemory();
-        return NULL;
-    }
-    entry->type = type;
-    entry->instance = instance;
-
-    /* Compile or load the selected shader instance */
-    entry->id = data->glCreateShader(instance->type);
-    if (instance->format == (GLenum)-1) {
-        data->glShaderSource(entry->id, 1, (const char **)(char *)&instance->data, NULL);
-        data->glCompileShader(entry->id);
-        data->glGetShaderiv(entry->id, GL_COMPILE_STATUS, &compileSuccessful);
-    } else {
-        data->glShaderBinary(1, &entry->id, instance->format, instance->data, instance->length);
-        compileSuccessful = GL_TRUE;
-    }
     if (!compileSuccessful) {
         SDL_bool isstack = SDL_FALSE;
         char *info = NULL;
         int length = 0;
 
-        data->glGetShaderiv(entry->id, GL_INFO_LOG_LENGTH, &length);
+        data->glGetShaderiv(id, GL_INFO_LOG_LENGTH, &length);
         if (length > 0) {
             info = SDL_small_alloc(char, length, &isstack);
             if (info) {
-                data->glGetShaderInfoLog(entry->id, length, &length, info);
+                data->glGetShaderInfoLog(id, length, &length, info);
             }
         }
         if (info) {
@@ -619,26 +525,21 @@ GLES2_CacheShader(GLES2_RenderData *data, GLES2_ShaderType type)
         } else {
             SDL_SetError("Failed to load the shader");
         }
-        data->glDeleteShader(entry->id);
-        SDL_free(entry);
-        return NULL;
+        data->glDeleteShader(id);
+        return 0;
     }
 
-    /* Link the shader entry in at the front of the cache */
-    if (data->shader_cache.head) {
-        entry->next = data->shader_cache.head;
-        data->shader_cache.head->prev = entry;
-    }
-    data->shader_cache.head = entry;
-    ++data->shader_cache.count;
-    return entry;
+    /* Cache */
+    data->shader_id_cache[(Uint32)type] = id;
+
+    return id;
 }
 
 static int
 GLES2_SelectProgram(GLES2_RenderData *data, GLES2_ImageSource source, int w, int h)
 {
-    GLES2_ShaderCacheEntry *vertex = NULL;
-    GLES2_ShaderCacheEntry *fragment = NULL;
+    GLuint vertex;
+    GLuint fragment;
     GLES2_ShaderType vtype, ftype;
     GLES2_ProgramCacheEntry *program;
 
@@ -646,30 +547,31 @@ GLES2_SelectProgram(GLES2_RenderData *data, GLES2_ImageSource source, int w, int
     vtype = GLES2_SHADER_VERTEX_DEFAULT;
     switch (source) {
     case GLES2_IMAGESOURCE_SOLID:
-        ftype = GLES2_SHADER_FRAGMENT_SOLID_SRC;
+        ftype = GLES2_SHADER_FRAGMENT_SOLID;
         break;
     case GLES2_IMAGESOURCE_TEXTURE_ABGR:
-        ftype = GLES2_SHADER_FRAGMENT_TEXTURE_ABGR_SRC;
+        ftype = GLES2_SHADER_FRAGMENT_TEXTURE_ABGR;
         break;
     case GLES2_IMAGESOURCE_TEXTURE_ARGB:
-        ftype = GLES2_SHADER_FRAGMENT_TEXTURE_ARGB_SRC;
+        ftype = GLES2_SHADER_FRAGMENT_TEXTURE_ARGB;
         break;
     case GLES2_IMAGESOURCE_TEXTURE_RGB:
-        ftype = GLES2_SHADER_FRAGMENT_TEXTURE_RGB_SRC;
+        ftype = GLES2_SHADER_FRAGMENT_TEXTURE_RGB;
         break;
     case GLES2_IMAGESOURCE_TEXTURE_BGR:
-        ftype = GLES2_SHADER_FRAGMENT_TEXTURE_BGR_SRC;
+        ftype = GLES2_SHADER_FRAGMENT_TEXTURE_BGR;
         break;
+#if SDL_HAVE_YUV
     case GLES2_IMAGESOURCE_TEXTURE_YUV:
         switch (SDL_GetYUVConversionModeForResolution(w, h)) {
         case SDL_YUV_CONVERSION_JPEG:
-            ftype = GLES2_SHADER_FRAGMENT_TEXTURE_YUV_JPEG_SRC;
+            ftype = GLES2_SHADER_FRAGMENT_TEXTURE_YUV_JPEG;
             break;
         case SDL_YUV_CONVERSION_BT601:
-            ftype = GLES2_SHADER_FRAGMENT_TEXTURE_YUV_BT601_SRC;
+            ftype = GLES2_SHADER_FRAGMENT_TEXTURE_YUV_BT601;
             break;
         case SDL_YUV_CONVERSION_BT709:
-            ftype = GLES2_SHADER_FRAGMENT_TEXTURE_YUV_BT709_SRC;
+            ftype = GLES2_SHADER_FRAGMENT_TEXTURE_YUV_BT709;
             break;
         default:
             SDL_SetError("Unsupported YUV conversion mode: %d\n", SDL_GetYUVConversionModeForResolution(w, h));
@@ -679,13 +581,21 @@ GLES2_SelectProgram(GLES2_RenderData *data, GLES2_ImageSource source, int w, int
     case GLES2_IMAGESOURCE_TEXTURE_NV12:
         switch (SDL_GetYUVConversionModeForResolution(w, h)) {
         case SDL_YUV_CONVERSION_JPEG:
-            ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV12_JPEG_SRC;
+            ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV12_JPEG;
             break;
         case SDL_YUV_CONVERSION_BT601:
-            ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV12_BT601_SRC;
+            if (SDL_GetHintBoolean("SDL_RENDER_OPENGL_NV12_RG_SHADER", SDL_FALSE)) {
+                ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV12_RG_BT601;
+            } else {
+                ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV12_RA_BT601;
+            }
             break;
         case SDL_YUV_CONVERSION_BT709:
-            ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV12_BT709_SRC;
+            if (SDL_GetHintBoolean("SDL_RENDER_OPENGL_NV12_RG_SHADER", SDL_FALSE)) {
+                ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV12_RG_BT709;
+            } else {
+                ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV12_RA_BT709;
+            }
             break;
         default:
             SDL_SetError("Unsupported YUV conversion mode: %d\n", SDL_GetYUVConversionModeForResolution(w, h));
@@ -695,34 +605,42 @@ GLES2_SelectProgram(GLES2_RenderData *data, GLES2_ImageSource source, int w, int
     case GLES2_IMAGESOURCE_TEXTURE_NV21:
         switch (SDL_GetYUVConversionModeForResolution(w, h)) {
         case SDL_YUV_CONVERSION_JPEG:
-            ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV21_JPEG_SRC;
+            ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV21_JPEG;
             break;
         case SDL_YUV_CONVERSION_BT601:
-            ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV21_BT601_SRC;
+            ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV21_BT601;
             break;
         case SDL_YUV_CONVERSION_BT709:
-            ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV21_BT709_SRC;
+            ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV21_BT709;
             break;
         default:
             SDL_SetError("Unsupported YUV conversion mode: %d\n", SDL_GetYUVConversionModeForResolution(w, h));
             goto fault;
         }
         break;
+#endif /* SDL_HAVE_YUV */
     case GLES2_IMAGESOURCE_TEXTURE_EXTERNAL_OES:
-        ftype = GLES2_SHADER_FRAGMENT_TEXTURE_EXTERNAL_OES_SRC;
+        ftype = GLES2_SHADER_FRAGMENT_TEXTURE_EXTERNAL_OES;
         break;
     default:
         goto fault;
     }
 
     /* Load the requested shaders */
-    vertex = GLES2_CacheShader(data, vtype);
+    vertex = data->shader_id_cache[(Uint32)vtype];
     if (!vertex) {
-        goto fault;
+        vertex = GLES2_CacheShader(data, vtype, GL_VERTEX_SHADER);
+        if (!vertex) {
+            goto fault;
+        }
     }
-    fragment = GLES2_CacheShader(data, ftype);
+
+    fragment = data->shader_id_cache[(Uint32)ftype];
     if (!fragment) {
-        goto fault;
+        fragment = GLES2_CacheShader(data, ftype, GL_FRAGMENT_SHADER);
+        if (!fragment) {
+            goto fault;
+        }
     }
 
     /* Check if we need to change programs at all */
@@ -747,12 +665,6 @@ GLES2_SelectProgram(GLES2_RenderData *data, GLES2_ImageSource source, int w, int
     /* Clean up and return */
     return 0;
 fault:
-    if (vertex && vertex->references <= 0) {
-        GLES2_EvictShader(data, vertex);
-    }
-    if (fragment && fragment->references <= 0) {
-        GLES2_EvictShader(data, fragment);
-    }
     data->drawstate.program = NULL;
     return -1;
 }
@@ -766,17 +678,31 @@ GLES2_QueueSetViewport(SDL_Renderer * renderer, SDL_RenderCommand *cmd)
 static int
 GLES2_QueueDrawPoints(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FPoint * points, int count)
 {
-    GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, count * 2 * sizeof (GLfloat), 0, &cmd->data.draw.first);
+    const SDL_bool colorswap = (renderer->target && (renderer->target->format == SDL_PIXELFORMAT_ARGB8888 || renderer->target->format == SDL_PIXELFORMAT_RGB888));
+    SDL_VertexSolid *verts = (SDL_VertexSolid *) SDL_AllocateRenderVertices(renderer, count * sizeof(*verts), 0, &cmd->data.draw.first);
     int i;
+    SDL_Color color;
+    color.r = cmd->data.draw.r;
+    color.g = cmd->data.draw.g;
+    color.b = cmd->data.draw.b;
+    color.a = cmd->data.draw.a;
 
     if (!verts) {
         return -1;
     }
 
+    if (colorswap) {
+        Uint8 r = color.r;
+        color.r = color.b;
+        color.b = r;
+    }
+
     cmd->data.draw.count = count;
     for (i = 0; i < count; i++) {
-        *(verts++) = 0.5f + points[i].x;
-        *(verts++) = 0.5f + points[i].y;
+        verts->position.x = 0.5f + points[i].x;
+        verts->position.y = 0.5f + points[i].y;
+        verts->color = color;
+        verts++;
     }
 
     return 0;
@@ -785,39 +711,148 @@ GLES2_QueueDrawPoints(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL
 static int
 GLES2_QueueDrawLines(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FPoint * points, int count)
 {
+    const SDL_bool colorswap = (renderer->target && (renderer->target->format == SDL_PIXELFORMAT_ARGB8888 || renderer->target->format == SDL_PIXELFORMAT_RGB888));
     int i;
-    const size_t vertlen = (sizeof (GLfloat) * 2) * count;
-    GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, vertlen, 0, &cmd->data.draw.first);
+    GLfloat prevx, prevy;
+    SDL_VertexSolid *verts = (SDL_VertexSolid *) SDL_AllocateRenderVertices(renderer, count * sizeof(*verts), 0, &cmd->data.draw.first);
+    SDL_Color color;
+    color.r = cmd->data.draw.r;
+    color.g = cmd->data.draw.g;
+    color.b = cmd->data.draw.b;
+    color.a = cmd->data.draw.a;
+
     if (!verts) {
         return -1;
     }
-    cmd->data.draw.count = count;
 
-    /* Offset to hit the center of the pixel. */
-    for (i = 0; i < count; i++) {
-        *(verts++) = 0.5f + points[i].x;
-        *(verts++) = 0.5f + points[i].y;
+    if (colorswap) {
+        Uint8 r = color.r;
+        color.r = color.b;
+        color.b = r;
     }
 
-    /* Make the last line segment one pixel longer, to satisfy the
-       diamond-exit rule. */
-    verts -= 4;
-    {
-        const GLfloat xstart = verts[0];
-        const GLfloat ystart = verts[1];
-        const GLfloat xend = verts[2];
-        const GLfloat yend = verts[3];
+    cmd->data.draw.count = count;
 
-        if (ystart == yend) {  /* horizontal line */
-            verts[2] += (xend > xstart) ? 1.0f : -1.0f;
-        } else if (xstart == xend) {  /* vertical line */
-            verts[3] += (yend > ystart) ? 1.0f : -1.0f;
-        } else {  /* bump a pixel in the direction we are moving in. */
-            const GLfloat deltax = xend - xstart;
-            const GLfloat deltay = yend - ystart;
-            const GLfloat angle = SDL_atan2f(deltay, deltax);
-            verts[2] += SDL_cosf(angle);
-            verts[3] += SDL_sinf(angle);
+    /* 0.5f offset to hit the center of the pixel. */
+    prevx = 0.5f + points->x;
+    prevy = 0.5f + points->y;
+    verts->position.x = prevx;
+    verts->position.y = prevy;
+    verts->color = color;
+    verts++;
+
+    /* bump the end of each line segment out a quarter of a pixel, to provoke
+       the diamond-exit rule. Without this, you won't just drop the last
+       pixel of the last line segment, but you might also drop pixels at the
+       edge of any given line segment along the way too. */
+    for (i = 1; i < count; i++) {
+        const GLfloat xstart = prevx;
+        const GLfloat ystart = prevy;
+        const GLfloat xend = points[i].x + 0.5f;  /* 0.5f to hit pixel center. */
+        const GLfloat yend = points[i].y + 0.5f;
+        /* bump a little in the direction we are moving in. */
+        const GLfloat deltax = xend - xstart;
+        const GLfloat deltay = yend - ystart;
+        const GLfloat angle = SDL_atan2f(deltay, deltax);
+        prevx = xend + (SDL_cosf(angle) * 0.25f);
+        prevy = yend + (SDL_sinf(angle) * 0.25f);
+        verts->position.x = prevx;
+        verts->position.y = prevy;
+        verts->color = color;
+        verts++;
+    }
+
+    return 0;
+}
+
+static int
+GLES2_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+        const float *xy, int xy_stride, const SDL_Color *color, int color_stride, const float *uv, int uv_stride,
+        int num_vertices, const void *indices, int num_indices, int size_indices,
+        float scale_x, float scale_y)
+{
+    int i;
+    const SDL_bool colorswap = (renderer->target && (renderer->target->format == SDL_PIXELFORMAT_ARGB8888 || renderer->target->format == SDL_PIXELFORMAT_RGB888));
+    int count = indices ? num_indices : num_vertices;
+
+    cmd->data.draw.count = count;
+    size_indices = indices ? size_indices : 0;
+
+    if (texture) {
+        SDL_Vertex *verts = (SDL_Vertex *) SDL_AllocateRenderVertices(renderer, count * sizeof (*verts), 0, &cmd->data.draw.first);
+        if (!verts) {
+            return -1;
+        }
+
+        for (i = 0; i < count; i++) {
+            int j;
+            float *xy_;
+            SDL_Color col_;
+            float *uv_;
+            if (size_indices == 4) {
+                j = ((const Uint32 *)indices)[i];
+            } else if (size_indices == 2) {
+                j = ((const Uint16 *)indices)[i];
+            } else if (size_indices == 1) {
+                j = ((const Uint8 *)indices)[i];
+            } else {
+                j = i;
+            }
+
+            xy_ = (float *)((char*)xy + j * xy_stride);
+            col_ = *(SDL_Color *)((char*)color + j * color_stride);
+            uv_ = (float *)((char*)uv + j * uv_stride);
+
+            verts->position.x = xy_[0] * scale_x;
+            verts->position.y = xy_[1] * scale_y;
+
+            if (colorswap) {
+                Uint8 r = col_.r;
+                col_.r = col_.b;
+                col_.b = r;
+            }
+
+            verts->color = col_;
+            verts->tex_coord.x = uv_[0];
+            verts->tex_coord.y = uv_[1];
+            verts++;
+        }
+
+    } else {
+        SDL_VertexSolid *verts = (SDL_VertexSolid *) SDL_AllocateRenderVertices(renderer, count * sizeof (*verts), 0, &cmd->data.draw.first);
+        if (!verts) {
+            return -1;
+        }
+
+        for (i = 0; i < count; i++) {
+            int j;
+            float *xy_;
+            SDL_Color col_;
+
+            if (size_indices == 4) {
+                j = ((const Uint32 *)indices)[i];
+            } else if (size_indices == 2) {
+                j = ((const Uint16 *)indices)[i];
+            } else if (size_indices == 1) {
+                j = ((const Uint8 *)indices)[i];
+            } else {
+                j = i;
+            }
+
+            xy_ = (float *)((char*)xy + j * xy_stride);
+            col_ = *(SDL_Color *)((char*)color + j * color_stride);
+
+            verts->position.x = xy_[0] * scale_x;
+            verts->position.y = xy_[1] * scale_y;
+
+            if (colorswap) {
+                Uint8 r = col_.r;
+                col_.r = col_.b;
+                col_.b = r;
+            }
+
+            verts->color = col_;
+            verts++;
         }
     }
 
@@ -825,171 +860,12 @@ GLES2_QueueDrawLines(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_
 }
 
 static int
-GLES2_QueueFillRects(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FRect * rects, int count)
+SetDrawState(GLES2_RenderData *data, const SDL_RenderCommand *cmd, const GLES2_ImageSource imgsrc, void *vertices)
 {
-    GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, count * 8 * sizeof (GLfloat), 0, &cmd->data.draw.first);
-    int i;
-
-    if (!verts) {
-        return -1;
-    }
-
-    cmd->data.draw.count = count;
-
-    for (i = 0; i < count; i++) {
-        const SDL_FRect *rect = &rects[i];
-        const GLfloat minx = rect->x;
-        const GLfloat maxx = rect->x + rect->w;
-        const GLfloat miny = rect->y;
-        const GLfloat maxy = rect->y + rect->h;
-        *(verts++) = minx;
-        *(verts++) = miny;
-        *(verts++) = maxx;
-        *(verts++) = miny;
-        *(verts++) = minx;
-        *(verts++) = maxy;
-        *(verts++) = maxx;
-        *(verts++) = maxy;
-    }
-
-    return 0;
-}
-
-static int
-GLES2_QueueCopy(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture,
-                          const SDL_Rect * srcrect, const SDL_FRect * dstrect)
-{
-    GLfloat minx, miny, maxx, maxy;
-    GLfloat minu, maxu, minv, maxv;
-    GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, 16 * sizeof (GLfloat), 0, &cmd->data.draw.first);
-
-    if (!verts) {
-        return -1;
-    }
-
-    cmd->data.draw.count = 1;
-
-    minx = dstrect->x;
-    miny = dstrect->y;
-    maxx = dstrect->x + dstrect->w;
-    maxy = dstrect->y + dstrect->h;
-
-    minu = (GLfloat) srcrect->x / texture->w;
-    maxu = (GLfloat) (srcrect->x + srcrect->w) / texture->w;
-    minv = (GLfloat) srcrect->y / texture->h;
-    maxv = (GLfloat) (srcrect->y + srcrect->h) / texture->h;
-
-    *(verts++) = minx;
-    *(verts++) = miny;
-    *(verts++) = maxx;
-    *(verts++) = miny;
-    *(verts++) = minx;
-    *(verts++) = maxy;
-    *(verts++) = maxx;
-    *(verts++) = maxy;
-
-    *(verts++) = minu;
-    *(verts++) = minv;
-    *(verts++) = maxu;
-    *(verts++) = minv;
-    *(verts++) = minu;
-    *(verts++) = maxv;
-    *(verts++) = maxu;
-    *(verts++) = maxv;
-
-    return 0;
-}
-
-static int
-GLES2_QueueCopyEx(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture,
-                        const SDL_Rect * srcquad, const SDL_FRect * dstrect,
-                        const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip)
-{
-    /* render expects cos value - 1 (see GLES2_VertexSrc_Default_) */
-    const float radian_angle = (float)(M_PI * (360.0 - angle) / 180.0);
-    const GLfloat s = (GLfloat) SDL_sin(radian_angle);
-    const GLfloat c = (GLfloat) SDL_cos(radian_angle) - 1.0f;
-    const GLfloat centerx = center->x + dstrect->x;
-    const GLfloat centery = center->y + dstrect->y;
-    GLfloat minx, miny, maxx, maxy;
-    GLfloat minu, maxu, minv, maxv;
-    GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, 32 * sizeof (GLfloat), 0, &cmd->data.draw.first);
-
-    if (!verts) {
-        return -1;
-    }
-
-    if (flip & SDL_FLIP_HORIZONTAL) {
-        minx = dstrect->x + dstrect->w;
-        maxx = dstrect->x;
-    } else {
-        minx = dstrect->x;
-        maxx = dstrect->x + dstrect->w;
-    }
-
-    if (flip & SDL_FLIP_VERTICAL) {
-        miny = dstrect->y + dstrect->h;
-        maxy = dstrect->y;
-    } else {
-        miny = dstrect->y;
-        maxy = dstrect->y + dstrect->h;
-    }
-
-    minu = ((GLfloat) srcquad->x) / ((GLfloat) texture->w);
-    maxu = ((GLfloat) (srcquad->x + srcquad->w)) / ((GLfloat) texture->w);
-    minv = ((GLfloat) srcquad->y) / ((GLfloat) texture->h);
-    maxv = ((GLfloat) (srcquad->y + srcquad->h)) / ((GLfloat) texture->h);
-
-
-    cmd->data.draw.count = 1;
-
-    *(verts++) = minx;
-    *(verts++) = miny;
-    *(verts++) = maxx;
-    *(verts++) = miny;
-    *(verts++) = minx;
-    *(verts++) = maxy;
-    *(verts++) = maxx;
-    *(verts++) = maxy;
-
-    *(verts++) = minu;
-    *(verts++) = minv;
-    *(verts++) = maxu;
-    *(verts++) = minv;
-    *(verts++) = minu;
-    *(verts++) = maxv;
-    *(verts++) = maxu;
-    *(verts++) = maxv;
-
-    *(verts++) = s;
-    *(verts++) = c;
-    *(verts++) = s;
-    *(verts++) = c;
-    *(verts++) = s;
-    *(verts++) = c;
-    *(verts++) = s;
-    *(verts++) = c;
-
-    *(verts++) = centerx;
-    *(verts++) = centery;
-    *(verts++) = centerx;
-    *(verts++) = centery;
-    *(verts++) = centerx;
-    *(verts++) = centery;
-    *(verts++) = centerx;
-    *(verts++) = centery;
-
-    return 0;
-}
-
-static int
-SetDrawState(GLES2_RenderData *data, const SDL_RenderCommand *cmd, const GLES2_ImageSource imgsrc)
-{
-    const SDL_bool was_copy_ex = data->drawstate.is_copy_ex;
-    const SDL_bool is_copy_ex = (cmd->command == SDL_RENDERCMD_COPY_EX);
     SDL_Texture *texture = cmd->data.draw.texture;
     const SDL_BlendMode blend = cmd->data.draw.blend;
     GLES2_ProgramCacheEntry *program;
+    int stride;
 
     SDL_assert((texture != NULL) == (imgsrc != GLES2_IMAGESOURCE_SOLID));
 
@@ -1024,41 +900,25 @@ SetDrawState(GLES2_RenderData *data, const SDL_RenderCommand *cmd, const GLES2_I
         data->drawstate.cliprect_dirty = SDL_FALSE;
     }
 
-    if (texture != data->drawstate.texture) {
-        if ((texture != NULL) != data->drawstate.texturing) {
-            if (texture == NULL) {
-                data->glDisableVertexAttribArray((GLenum) GLES2_ATTRIBUTE_TEXCOORD);
-                data->drawstate.texturing = SDL_FALSE;
-            } else {
-                data->glEnableVertexAttribArray((GLenum) GLES2_ATTRIBUTE_TEXCOORD);
-                data->drawstate.texturing = SDL_TRUE;
-            }
+    if ((texture != NULL) != data->drawstate.texturing) {
+        if (texture == NULL) {
+            data->glDisableVertexAttribArray((GLenum) GLES2_ATTRIBUTE_TEXCOORD);
+            data->drawstate.texturing = SDL_FALSE;
+        } else {
+            data->glEnableVertexAttribArray((GLenum) GLES2_ATTRIBUTE_TEXCOORD);
+            data->drawstate.texturing = SDL_TRUE;
         }
-
-        if (texture) {
-            GLES2_TextureData *tdata = (GLES2_TextureData *) texture->driverdata;
-            if (tdata->yuv) {
-                data->glActiveTexture(GL_TEXTURE2);
-                data->glBindTexture(tdata->texture_type, tdata->texture_v);
-
-                data->glActiveTexture(GL_TEXTURE1);
-                data->glBindTexture(tdata->texture_type, tdata->texture_u);
-
-                data->glActiveTexture(GL_TEXTURE0);
-            } else if (tdata->nv12) {
-                data->glActiveTexture(GL_TEXTURE1);
-                data->glBindTexture(tdata->texture_type, tdata->texture_u);
-
-                data->glActiveTexture(GL_TEXTURE0);
-            }
-            data->glBindTexture(tdata->texture_type, tdata->texture);
-        }
-
-        data->drawstate.texture = texture;
     }
 
     if (texture) {
-        data->glVertexAttribPointer(GLES2_ATTRIBUTE_TEXCOORD, 2, GL_FLOAT, GL_FALSE, 0, (const GLvoid *) (cmd->data.draw.first + (sizeof (GLfloat) * 8)));
+        stride = sizeof(SDL_Vertex);
+    } else {
+        stride = sizeof(SDL_VertexSolid);
+    }
+
+    if (texture) {
+        SDL_Vertex *verts = (SDL_Vertex *) (((Uint8 *) vertices) + cmd->data.draw.first);
+        data->glVertexAttribPointer(GLES2_ATTRIBUTE_TEXCOORD, 2, GL_FLOAT, GL_FALSE, stride, (const GLvoid *)&verts->tex_coord);
     }
 
     if (GLES2_SelectProgram(data, imgsrc, texture ? texture->w : 0, texture ? texture->h : 0) < 0) {
@@ -1074,17 +934,6 @@ SetDrawState(GLES2_RenderData *data, const SDL_RenderCommand *cmd, const GLES2_I
         }
     }
 
-    if (program->uniform_locations[GLES2_UNIFORM_COLOR] != -1) {
-        if (data->drawstate.color != program->color) {
-            const Uint8 r = (data->drawstate.color >> 16) & 0xFF;
-            const Uint8 g = (data->drawstate.color >> 8) & 0xFF;
-            const Uint8 b = (data->drawstate.color >> 0) & 0xFF;
-            const Uint8 a = (data->drawstate.color >> 24) & 0xFF;
-            data->glUniform4f(program->uniform_locations[GLES2_UNIFORM_COLOR], r * inv255f, g * inv255f, b * inv255f, a * inv255f);
-            program->color = data->drawstate.color;
-        }
-    }
-
     if (blend != data->drawstate.blend) {
         if (blend == SDL_BLENDMODE_NONE) {
             data->glDisable(GL_BLEND);
@@ -1101,33 +950,22 @@ SetDrawState(GLES2_RenderData *data, const SDL_RenderCommand *cmd, const GLES2_I
     }
 
     /* all drawing commands use this */
-    data->glVertexAttribPointer(GLES2_ATTRIBUTE_POSITION, 2, GL_FLOAT, GL_FALSE, 0, (const GLvoid *) cmd->data.draw.first);
-
-    if (is_copy_ex != was_copy_ex) {
-        if (is_copy_ex) {
-            data->glEnableVertexAttribArray((GLenum) GLES2_ATTRIBUTE_ANGLE);
-            data->glEnableVertexAttribArray((GLenum) GLES2_ATTRIBUTE_CENTER);
-        } else {
-            data->glDisableVertexAttribArray((GLenum) GLES2_ATTRIBUTE_ANGLE);
-            data->glDisableVertexAttribArray((GLenum) GLES2_ATTRIBUTE_CENTER);
-        }
-        data->drawstate.is_copy_ex = is_copy_ex;
-    }
-
-    if (is_copy_ex) {
-        data->glVertexAttribPointer(GLES2_ATTRIBUTE_ANGLE, 2, GL_FLOAT, GL_FALSE, 0, (const GLvoid *) (cmd->data.draw.first + (sizeof (GLfloat) * 16)));
-        data->glVertexAttribPointer(GLES2_ATTRIBUTE_CENTER, 2, GL_FLOAT, GL_FALSE, 0, (const GLvoid *) (cmd->data.draw.first + (sizeof (GLfloat) * 24)));
+    {
+        SDL_VertexSolid *verts = (SDL_VertexSolid *) (((Uint8 *) vertices) + cmd->data.draw.first);
+        data->glVertexAttribPointer(GLES2_ATTRIBUTE_POSITION, 2, GL_FLOAT, GL_FALSE, stride, (const GLvoid *) &verts->position);
+        data->glVertexAttribPointer(GLES2_ATTRIBUTE_COLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE /* Normalized */, stride, (const GLvoid *) &verts->color);
     }
 
     return 0;
 }
 
 static int
-SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd)
+SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, void *vertices)
 {
     GLES2_RenderData *data = (GLES2_RenderData *) renderer->driverdata;
     GLES2_ImageSource sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR;
     SDL_Texture *texture = cmd->data.draw.texture;
+    int ret;
 
     /* Pick an appropriate shader */
     if (renderer->target) {
@@ -1182,6 +1020,7 @@ SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd)
                     break;
                 }
                 break;
+#if SDL_HAVE_YUV
             case SDL_PIXELFORMAT_IYUV:
             case SDL_PIXELFORMAT_YV12:
                 sourceType = GLES2_IMAGESOURCE_TEXTURE_YUV;
@@ -1192,6 +1031,7 @@ SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd)
             case SDL_PIXELFORMAT_NV21:
                 sourceType = GLES2_IMAGESOURCE_TEXTURE_NV21;
                 break;
+#endif
             case SDL_PIXELFORMAT_EXTERNAL_OES:
                 sourceType = GLES2_IMAGESOURCE_TEXTURE_EXTERNAL_OES;
                 break;
@@ -1215,6 +1055,7 @@ SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd)
             case SDL_PIXELFORMAT_BGR888:
                 sourceType = GLES2_IMAGESOURCE_TEXTURE_BGR;
                 break;
+#if SDL_HAVE_YUV
             case SDL_PIXELFORMAT_IYUV:
             case SDL_PIXELFORMAT_YV12:
                 sourceType = GLES2_IMAGESOURCE_TEXTURE_YUV;
@@ -1225,6 +1066,7 @@ SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd)
             case SDL_PIXELFORMAT_NV21:
                 sourceType = GLES2_IMAGESOURCE_TEXTURE_NV21;
                 break;
+#endif
             case SDL_PIXELFORMAT_EXTERNAL_OES:
                 sourceType = GLES2_IMAGESOURCE_TEXTURE_EXTERNAL_OES;
                 break;
@@ -1233,7 +1075,31 @@ SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd)
         }
     }
 
-    return SetDrawState(data, cmd, sourceType);
+    ret = SetDrawState(data, cmd, sourceType, vertices);
+
+    if (texture != data->drawstate.texture) {
+        GLES2_TextureData *tdata = (GLES2_TextureData *) texture->driverdata;
+#if SDL_HAVE_YUV
+        if (tdata->yuv) {
+            data->glActiveTexture(GL_TEXTURE2);
+            data->glBindTexture(tdata->texture_type, tdata->texture_v);
+
+            data->glActiveTexture(GL_TEXTURE1);
+            data->glBindTexture(tdata->texture_type, tdata->texture_u);
+
+            data->glActiveTexture(GL_TEXTURE0);
+        } else if (tdata->nv12) {
+            data->glActiveTexture(GL_TEXTURE1);
+            data->glBindTexture(tdata->texture_type, tdata->texture_u);
+
+            data->glActiveTexture(GL_TEXTURE0);
+        }
+#endif
+        data->glBindTexture(tdata->texture_type, tdata->texture);
+        data->drawstate.texture = texture;
+    }
+
+    return ret;
 }
 
 static int
@@ -1241,9 +1107,11 @@ GLES2_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *ver
 {
     GLES2_RenderData *data = (GLES2_RenderData *) renderer->driverdata;
     const SDL_bool colorswap = (renderer->target && (renderer->target->format == SDL_PIXELFORMAT_ARGB8888 || renderer->target->format == SDL_PIXELFORMAT_RGB888));
+
+#if USE_VERTEX_BUFFER_OBJECTS
     const int vboidx = data->current_vertex_buffer;
     const GLuint vbo = data->vertex_buffers[vboidx];
-    size_t i;
+#endif
 
     if (GLES2_ActivateRenderer(renderer) < 0) {
         return -1;
@@ -1251,9 +1119,17 @@ GLES2_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *ver
 
     data->drawstate.target = renderer->target;
     if (!data->drawstate.target) {
-        SDL_GL_GetDrawableSize(renderer->window, &data->drawstate.drawablew, &data->drawstate.drawableh);
+        int w, h;
+        SDL_GL_GetDrawableSize(renderer->window, &w, &h);
+        if ((w != data->drawstate.drawablew) || (h != data->drawstate.drawableh)) {
+            data->drawstate.viewport_dirty = SDL_TRUE;  // if the window dimensions changed, invalidate the current viewport, etc.
+            data->drawstate.cliprect_dirty = SDL_TRUE;
+            data->drawstate.drawablew = w;
+            data->drawstate.drawableh = h;
+        }
     }
 
+#if USE_VERTEX_BUFFER_OBJECTS
     /* upload the new VBO data for this set of commands. */
     data->glBindBuffer(GL_ARRAY_BUFFER, vbo);
     if (data->vertex_buffer_size[vboidx] < vertsize) {
@@ -1268,15 +1144,12 @@ GLES2_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *ver
     if (data->current_vertex_buffer >= SDL_arraysize(data->vertex_buffers)) {
         data->current_vertex_buffer = 0;
     }
+    vertices = NULL;  /* attrib pointers will be offsets into the VBO. */
+#endif
 
     while (cmd) {
         switch (cmd->command) {
             case SDL_RENDERCMD_SETDRAWCOLOR: {
-                const Uint8 r = colorswap ? cmd->data.color.b : cmd->data.color.r;
-                const Uint8 g = cmd->data.color.g;
-                const Uint8 b = colorswap ? cmd->data.color.r : cmd->data.color.b;
-                const Uint8 a = cmd->data.color.a;
-                data->drawstate.color = ((a << 24) | (r << 16) | (g << 8) | b);
                 break;
             }
 
@@ -1308,7 +1181,7 @@ GLES2_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *ver
                 const Uint8 g = cmd->data.color.g;
                 const Uint8 b = colorswap ? cmd->data.color.r : cmd->data.color.b;
                 const Uint8 a = cmd->data.color.a;
-                const Uint32 color = ((a << 24) | (r << 16) | (g << 8) | b);
+                const Uint32 color = (((Uint32)a << 24) | (r << 16) | (g << 8) | b);
                 if (color != data->drawstate.clear_color) {
                     const GLfloat fr = ((GLfloat) r) * inv255f;
                     const GLfloat fg = ((GLfloat) g) * inv255f;
@@ -1327,38 +1200,88 @@ GLES2_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *ver
                 break;
             }
 
-            case SDL_RENDERCMD_DRAW_POINTS: {
-                if (SetDrawState(data, cmd, GLES2_IMAGESOURCE_SOLID) == 0) {
-                    data->glDrawArrays(GL_POINTS, 0, (GLsizei) cmd->data.draw.count);
-                }
+            case SDL_RENDERCMD_FILL_RECTS: /* unused */
+                break;
+
+            case SDL_RENDERCMD_COPY: /* unused */
+                break;
+
+            case SDL_RENDERCMD_COPY_EX: /* unused */
                 break;
-            }
 
             case SDL_RENDERCMD_DRAW_LINES: {
-                const size_t count = cmd->data.draw.count;
-                SDL_assert(count >= 2);
-                if (SetDrawState(data, cmd, GLES2_IMAGESOURCE_SOLID) == 0) {
-                    data->glDrawArrays(GL_LINE_STRIP, 0, (GLsizei) count);
-                }
-                break;
-            }
+                if (SetDrawState(data, cmd, GLES2_IMAGESOURCE_SOLID, vertices) == 0) {
+                    size_t count = cmd->data.draw.count;
+                    if (count > 2) {
+                        /* joined lines cannot be grouped */
+                        data->glDrawArrays(GL_LINE_STRIP, 0, (GLsizei)count);
+                    } else {
+                        /* let's group non joined lines */
+                        SDL_RenderCommand *finalcmd = cmd;
+                        SDL_RenderCommand *nextcmd = cmd->next;
+                        SDL_BlendMode thisblend = cmd->data.draw.blend;
 
-            case SDL_RENDERCMD_FILL_RECTS: {
-                const size_t count = cmd->data.draw.count;
-                size_t offset = 0;
-                if (SetDrawState(data, cmd, GLES2_IMAGESOURCE_SOLID) == 0) {
-                    for (i = 0; i < count; ++i, offset += 4) {
-                        data->glDrawArrays(GL_TRIANGLE_STRIP, (GLsizei) offset, 4);
+                        while (nextcmd != NULL) {
+                            const SDL_RenderCommandType nextcmdtype = nextcmd->command;
+                            if (nextcmdtype != SDL_RENDERCMD_DRAW_LINES) {
+                                break;  /* can't go any further on this draw call, different render command up next. */
+                            } else if (nextcmd->data.draw.count != 2) {
+                                break;  /* can't go any further on this draw call, those are joined lines */
+                            } else if (nextcmd->data.draw.blend != thisblend) {
+                                break;  /* can't go any further on this draw call, different blendmode copy up next. */
+                            } else {
+                                finalcmd = nextcmd;  /* we can combine copy operations here. Mark this one as the furthest okay command. */
+                                count += nextcmd->data.draw.count;
+                            }
+                            nextcmd = nextcmd->next;
+                        }
+
+                        data->glDrawArrays(GL_LINES, 0, (GLsizei)count);
+                        cmd = finalcmd;  /* skip any copy commands we just combined in here. */
                     }
                 }
                 break;
             }
 
-            case SDL_RENDERCMD_COPY:
-            case SDL_RENDERCMD_COPY_EX: {
-                if (SetCopyState(renderer, cmd) == 0) {
-                    data->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+            case SDL_RENDERCMD_DRAW_POINTS:
+            case SDL_RENDERCMD_GEOMETRY: {
+                /* as long as we have the same copy command in a row, with the
+                   same texture, we can combine them all into a single draw call. */
+                SDL_Texture *thistexture = cmd->data.draw.texture;
+                SDL_BlendMode thisblend = cmd->data.draw.blend;
+                const SDL_RenderCommandType thiscmdtype = cmd->command;
+                SDL_RenderCommand *finalcmd = cmd;
+                SDL_RenderCommand *nextcmd = cmd->next;
+                size_t count = cmd->data.draw.count;
+                int ret;
+                while (nextcmd != NULL) {
+                    const SDL_RenderCommandType nextcmdtype = nextcmd->command;
+                    if (nextcmdtype != thiscmdtype) {
+                        break;  /* can't go any further on this draw call, different render command up next. */
+                    } else if (nextcmd->data.draw.texture != thistexture || nextcmd->data.draw.blend != thisblend) {
+                        break;  /* can't go any further on this draw call, different texture/blendmode copy up next. */
+                    } else {
+                        finalcmd = nextcmd;  /* we can combine copy operations here. Mark this one as the furthest okay command. */
+                        count += nextcmd->data.draw.count;
+                    }
+                    nextcmd = nextcmd->next;
                 }
+
+                if (thistexture) {
+                    ret = SetCopyState(renderer, cmd, vertices);
+                } else {
+                    ret = SetDrawState(data, cmd, GLES2_IMAGESOURCE_SOLID, vertices);
+                }
+
+                if (ret == 0) {
+                    int op = GL_TRIANGLES; /* SDL_RENDERCMD_GEOMETRY */
+                    if (thiscmdtype == SDL_RENDERCMD_DRAW_POINTS) {
+                        op = GL_POINTS;
+                    }
+                    data->glDrawArrays(op, 0, (GLsizei) count);
+                }
+
+                cmd = finalcmd;  /* skip any copy commands we just combined in here. */
                 break;
             }
 
@@ -1382,14 +1305,12 @@ GLES2_DestroyRenderer(SDL_Renderer *renderer)
         GLES2_ActivateRenderer(renderer);
 
         {
-            GLES2_ShaderCacheEntry *entry;
-            GLES2_ShaderCacheEntry *next;
-            entry = data->shader_cache.head;
-            while (entry) {
-                data->glDeleteShader(entry->id);
-                next = entry->next;
-                SDL_free(entry);
-                entry = next;
+            int i;
+            for (i = 0; i < GLES2_SHADER_COUNT; i++) {
+                GLuint id = data->shader_id_cache[i];
+                if (id) {
+                    data->glDeleteShader(id);
+                }
             }
         }
         {
@@ -1413,13 +1334,14 @@ GLES2_DestroyRenderer(SDL_Renderer *renderer)
                 data->framebuffers = nextnode;
             }
 
+#if USE_VERTEX_BUFFER_OBJECTS
             data->glDeleteBuffers(SDL_arraysize(data->vertex_buffers), data->vertex_buffers);
             GL_CheckError("", renderer);
+#endif
 
             SDL_GL_DeleteContext(data->context);
         }
 
-        SDL_free(data->shader_formats);
         SDL_free(data);
     }
     SDL_free(renderer);
@@ -1448,6 +1370,7 @@ GLES2_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture)
         format = GL_RGBA;
         type = GL_UNSIGNED_BYTE;
         break;
+#if SDL_HAVE_YUV
     case SDL_PIXELFORMAT_IYUV:
     case SDL_PIXELFORMAT_YV12:
     case SDL_PIXELFORMAT_NV12:
@@ -1455,6 +1378,7 @@ GLES2_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture)
         format = GL_LUMINANCE;
         type = GL_UNSIGNED_BYTE;
         break;
+#endif
 #ifdef GL_TEXTURE_EXTERNAL_OES
     case SDL_PIXELFORMAT_EXTERNAL_OES:
         format = GL_NONE;
@@ -1483,10 +1407,12 @@ GLES2_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture)
 #endif
     data->pixel_format = format;
     data->pixel_type = type;
+#if SDL_HAVE_YUV
     data->yuv = ((texture->format == SDL_PIXELFORMAT_IYUV) || (texture->format == SDL_PIXELFORMAT_YV12));
     data->nv12 = ((texture->format == SDL_PIXELFORMAT_NV12) || (texture->format == SDL_PIXELFORMAT_NV21));
     data->texture_u = 0;
     data->texture_v = 0;
+#endif
     scaleMode = (texture->scaleMode == SDL_ScaleModeNearest) ? GL_NEAREST : GL_LINEAR;
 
     /* Allocate a blob for image renderdata */
@@ -1494,6 +1420,7 @@ GLES2_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture)
         size_t size;
         data->pitch = texture->w * SDL_BYTESPERPIXEL(texture->format);
         size = texture->h * data->pitch;
+#if SDL_HAVE_YUV
         if (data->yuv) {
             /* Need to add size for the U and V planes */
             size += 2 * ((texture->h + 1) / 2) * ((data->pitch + 1) / 2);
@@ -1501,6 +1428,7 @@ GLES2_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture)
             /* Need to add size for the U/V plane */
             size += 2 * ((texture->h + 1) / 2) * ((data->pitch + 1) / 2);
         }
+#endif
         data->pixel_data = SDL_calloc(1, size);
         if (!data->pixel_data) {
             SDL_free(data);
@@ -1511,6 +1439,7 @@ GLES2_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture)
     /* Allocate the texture */
     GL_CheckError("", renderer);
 
+#if SDL_HAVE_YUV
     if (data->yuv) {
         renderdata->glGenTextures(1, &data->texture_v);
         if (GL_CheckError("glGenTexures()", renderer) < 0) {
@@ -1554,6 +1483,7 @@ GLES2_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture)
             return -1;
         }
     }
+#endif
 
     renderdata->glGenTextures(1, &data->texture);
     if (GL_CheckError("glGenTexures()", renderer) < 0) {
@@ -1586,6 +1516,9 @@ static int
 GLES2_TexSubImage2D(GLES2_RenderData *data, GLenum target, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels, GLint pitch, GLint bpp)
 {
     Uint8 *blob = NULL;
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+    Uint32 *blob2 = NULL;
+#endif
     Uint8 *src;
     int src_pitch;
     int y;
@@ -1612,10 +1545,33 @@ GLES2_TexSubImage2D(GLES2_RenderData *data, GLenum target, GLint xoffset, GLint
         src = blob;
     }
 
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+    if (format == GL_RGBA) {
+        int i;
+        Uint32 *src32 = (Uint32 *)src;
+        blob2 = (Uint32 *)SDL_malloc(src_pitch * height);
+        if (!blob2) {
+            if (blob) {
+                SDL_free(blob);
+            }
+            return SDL_OutOfMemory();
+        }
+        for (i = 0; i < (src_pitch * height) / 4; i++) {
+            blob2[i] = SDL_Swap32(src32[i]);
+        }
+        src = (Uint8 *) blob2;
+    }
+#endif
+
     data->glTexSubImage2D(target, 0, xoffset, yoffset, width, height, format, type, src);
     if (blob) {
         SDL_free(blob);
     }
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+    if (blob2) {
+        SDL_free(blob2);
+    }
+#endif
     return 0;
 }
 
@@ -1646,6 +1602,7 @@ GLES2_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect
                     tdata->pixel_type,
                     pixels, pitch, SDL_BYTESPERPIXEL(texture->format));
 
+#if SDL_HAVE_YUV
     if (tdata->yuv) {
         /* Skip to the correct offset into the next texture */
         pixels = (const void*)((const Uint8*)pixels + rect->h * pitch);
@@ -1692,10 +1649,12 @@ GLES2_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect
                 GL_UNSIGNED_BYTE,
                 pixels, 2 * ((pitch + 1) / 2), 2);
     }
+#endif
 
     return GL_CheckError("glTexSubImage2D()", renderer);
 }
 
+#if SDL_HAVE_YUV
 static int
 GLES2_UpdateTextureYUV(SDL_Renderer * renderer, SDL_Texture * texture,
                     const SDL_Rect * rect,
@@ -1748,6 +1707,48 @@ GLES2_UpdateTextureYUV(SDL_Renderer * renderer, SDL_Texture * texture,
     return GL_CheckError("glTexSubImage2D()", renderer);
 }
 
+static int
+GLES2_UpdateTextureNV(SDL_Renderer * renderer, SDL_Texture * texture,
+                    const SDL_Rect * rect,
+                    const Uint8 *Yplane, int Ypitch,
+                    const Uint8 *UVplane, int UVpitch)
+{
+    GLES2_RenderData *data = (GLES2_RenderData *)renderer->driverdata;
+    GLES2_TextureData *tdata = (GLES2_TextureData *)texture->driverdata;
+
+    GLES2_ActivateRenderer(renderer);
+
+    /* Bail out if we're supposed to update an empty rectangle */
+    if (rect->w <= 0 || rect->h <= 0) {
+        return 0;
+    }
+
+    data->drawstate.texture = NULL;  /* we trash this state. */
+
+    data->glBindTexture(tdata->texture_type, tdata->texture_u);
+    GLES2_TexSubImage2D(data, tdata->texture_type,
+            rect->x / 2,
+            rect->y / 2,
+            (rect->w + 1) / 2,
+            (rect->h + 1) / 2,
+            GL_LUMINANCE_ALPHA,
+            GL_UNSIGNED_BYTE,
+            UVplane, UVpitch, 2);
+
+    data->glBindTexture(tdata->texture_type, tdata->texture);
+    GLES2_TexSubImage2D(data, tdata->texture_type,
+            rect->x,
+            rect->y,
+            rect->w,
+            rect->h,
+            tdata->pixel_format,
+            tdata->pixel_type,
+            Yplane, Ypitch, 1);
+
+    return GL_CheckError("glTexSubImage2D()", renderer);
+}
+#endif
+
 static int
 GLES2_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect,
                   void **pixels, int *pitch)
@@ -1784,6 +1785,7 @@ GLES2_SetTextureScaleMode(SDL_Renderer * renderer, SDL_Texture * texture, SDL_Sc
     GLES2_TextureData *data = (GLES2_TextureData *) texture->driverdata;
     GLenum glScaleMode = (scaleMode == SDL_ScaleModeNearest) ? GL_NEAREST : GL_LINEAR;
 
+#if SDL_HAVE_YUV
     if (data->yuv) {
         renderdata->glActiveTexture(GL_TEXTURE2);
         renderdata->glBindTexture(data->texture_type, data->texture_v);
@@ -1800,6 +1802,7 @@ GLES2_SetTextureScaleMode(SDL_Renderer * renderer, SDL_Texture * texture, SDL_Sc
         renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_MIN_FILTER, glScaleMode);
         renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_MAG_FILTER, glScaleMode);
     }
+#endif
 
     renderdata->glActiveTexture(GL_TEXTURE0);
     renderdata->glBindTexture(data->texture_type, data->texture);
@@ -1850,12 +1853,14 @@ GLES2_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture)
     /* Destroy the texture */
     if (tdata) {
         data->glDeleteTextures(1, &tdata->texture);
+#if SDL_HAVE_YUV
         if (tdata->texture_v) {
             data->glDeleteTextures(1, &tdata->texture_v);
         }
         if (tdata->texture_u) {
             data->glDeleteTextures(1, &tdata->texture_u);
         }
+#endif
         SDL_free(tdata->pixel_data);
         SDL_free(tdata);
         texture->driverdata = NULL;
@@ -1927,6 +1932,26 @@ GLES2_RenderPresent(SDL_Renderer *renderer)
     SDL_GL_SwapWindow(renderer->window);
 }
 
+static int
+GLES2_SetVSync(SDL_Renderer * renderer, const int vsync)
+{
+    int retval;
+    if (vsync) {
+        retval = SDL_GL_SetSwapInterval(1);
+    } else {
+        retval = SDL_GL_SetSwapInterval(0);
+    }
+    if (retval != 0) {
+        return retval;
+    }
+    if (SDL_GL_GetSwapInterval() > 0) {
+        renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
+    } else {
+        renderer->info.flags &= ~SDL_RENDERER_PRESENTVSYNC;
+    }
+    return retval;
+}
+
 
 /*************************************************************************************************
  * Bind/unbinding of textures
@@ -1970,20 +1995,11 @@ static int GLES2_UnbindTexture (SDL_Renderer * renderer, SDL_Texture *texture)
  * Renderer instantiation                                                                        *
  *************************************************************************************************/
 
-#ifdef ZUNE_HD
-#define GL_NVIDIA_PLATFORM_BINARY_NV 0x890B
-#endif
-
-
 static SDL_Renderer *
 GLES2_CreateRenderer(SDL_Window *window, Uint32 flags)
 {
     SDL_Renderer *renderer;
     GLES2_RenderData *data;
-    GLint nFormats;
-#ifndef ZUNE_HD
-    GLboolean hasCompiler;
-#endif
     Uint32 window_flags = 0; /* -Wconditional-uninitialized */
     GLint window_framebuffer;
     GLint value;
@@ -2085,35 +2101,10 @@ GLES2_CreateRenderer(SDL_Window *window, Uint32 flags)
     data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
     renderer->info.max_texture_height = value;
 
-    /* Determine supported shader formats */
-    /* HACK: glGetInteger is broken on the Zune HD's compositor, so we just hardcode this */
-#ifdef ZUNE_HD
-    nFormats = 1;
-#else /* !ZUNE_HD */
-    data->glGetIntegerv(GL_NUM_SHADER_BINARY_FORMATS, &nFormats);
-    data->glGetBooleanv(GL_SHADER_COMPILER, &hasCompiler);
-    if (hasCompiler) {
-        ++nFormats;
-    }
-#endif /* ZUNE_HD */
-    data->shader_formats = (GLenum *)SDL_calloc(nFormats, sizeof(GLenum));
-    if (!data->shader_formats) {
-        GLES2_DestroyRenderer(renderer);
-        SDL_OutOfMemory();
-        goto error;
-    }
-    data->shader_format_count = nFormats;
-#ifdef ZUNE_HD
-    data->shader_formats[0] = GL_NVIDIA_PLATFORM_BINARY_NV;
-#else /* !ZUNE_HD */
-    data->glGetIntegerv(GL_SHADER_BINARY_FORMATS, (GLint *)data->shader_formats);
-    if (hasCompiler) {
-        data->shader_formats[nFormats - 1] = (GLenum)-1;
-    }
-#endif /* ZUNE_HD */
-
+#if USE_VERTEX_BUFFER_OBJECTS
     /* we keep a few of these and cycle through them, so data can live for a few frames. */
     data->glGenBuffers(SDL_arraysize(data->vertex_buffers), data->vertex_buffers);
+#endif
 
     data->framebuffers = NULL;
     data->glGetIntegerv(GL_FRAMEBUFFER_BINDING, &window_framebuffer);
@@ -2125,7 +2116,10 @@ GLES2_CreateRenderer(SDL_Window *window, Uint32 flags)
     renderer->SupportsBlendMode   = GLES2_SupportsBlendMode;
     renderer->CreateTexture       = GLES2_CreateTexture;
     renderer->UpdateTexture       = GLES2_UpdateTexture;
+#if SDL_HAVE_YUV
     renderer->UpdateTextureYUV    = GLES2_UpdateTextureYUV;
+    renderer->UpdateTextureNV     = GLES2_UpdateTextureNV;
+#endif
     renderer->LockTexture         = GLES2_LockTexture;
     renderer->UnlockTexture       = GLES2_UnlockTexture;
     renderer->SetTextureScaleMode = GLES2_SetTextureScaleMode;
@@ -2134,21 +2128,21 @@ GLES2_CreateRenderer(SDL_Window *window, Uint32 flags)
     renderer->QueueSetDrawColor   = GLES2_QueueSetViewport;  /* SetViewport and SetDrawColor are (currently) no-ops. */
     renderer->QueueDrawPoints     = GLES2_QueueDrawPoints;
     renderer->QueueDrawLines      = GLES2_QueueDrawLines;
-    renderer->QueueFillRects      = GLES2_QueueFillRects;
-    renderer->QueueCopy           = GLES2_QueueCopy;
-    renderer->QueueCopyEx         = GLES2_QueueCopyEx;
+    renderer->QueueGeometry       = GLES2_QueueGeometry;
     renderer->RunCommandQueue     = GLES2_RunCommandQueue;
     renderer->RenderReadPixels    = GLES2_RenderReadPixels;
     renderer->RenderPresent       = GLES2_RenderPresent;
     renderer->DestroyTexture      = GLES2_DestroyTexture;
     renderer->DestroyRenderer     = GLES2_DestroyRenderer;
+    renderer->SetVSync            = GLES2_SetVSync;
     renderer->GL_BindTexture      = GLES2_BindTexture;
     renderer->GL_UnbindTexture    = GLES2_UnbindTexture;
-
+#if SDL_HAVE_YUV
     renderer->info.texture_formats[renderer->info.num_texture_formats++] = SDL_PIXELFORMAT_YV12;
     renderer->info.texture_formats[renderer->info.num_texture_formats++] = SDL_PIXELFORMAT_IYUV;
     renderer->info.texture_formats[renderer->info.num_texture_formats++] = SDL_PIXELFORMAT_NV12;
     renderer->info.texture_formats[renderer->info.num_texture_formats++] = SDL_PIXELFORMAT_NV21;
+#endif
 #ifdef GL_TEXTURE_EXTERNAL_OES
     renderer->info.texture_formats[renderer->info.num_texture_formats++] = SDL_PIXELFORMAT_EXTERNAL_OES;
 #endif
@@ -2159,12 +2153,12 @@ GLES2_CreateRenderer(SDL_Window *window, Uint32 flags)
     data->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 
     data->glEnableVertexAttribArray(GLES2_ATTRIBUTE_POSITION);
+    data->glEnableVertexAttribArray(GLES2_ATTRIBUTE_COLOR);
     data->glDisableVertexAttribArray(GLES2_ATTRIBUTE_TEXCOORD);
 
     data->glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
 
     data->drawstate.blend = SDL_BLENDMODE_INVALID;
-    data->drawstate.color = 0xFFFFFFFF;
     data->drawstate.clear_color = 0xFFFFFFFF;
     data->drawstate.projection[3][0] = -1.0f;
     data->drawstate.projection[3][3] = 1.0f;
@@ -2204,3 +2198,4 @@ SDL_RenderDriver GLES2_RenderDriver = {
 #endif /* SDL_VIDEO_RENDER_OGL_ES2 && !SDL_RENDER_DISABLED */
 
 /* vi: set ts=4 sw=4 expandtab: */
+
diff --git a/Engine/lib/sdl/src/render/opengles2/SDL_shaders_gles2.c b/Engine/lib/sdl/src/render/opengles2/SDL_shaders_gles2.c
index d9db27f7a..a1f78fdd9 100644
--- a/Engine/lib/sdl/src/render/opengles2/SDL_shaders_gles2.c
+++ b/Engine/lib/sdl/src/render/opengles2/SDL_shaders_gles2.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -30,60 +30,51 @@
 /*************************************************************************************************
  * Vertex/fragment shader source                                                                 *
  *************************************************************************************************/
-/* Notes on a_angle:
-   * It is a vector containing sin and cos for rotation matrix
-   * To get correct rotation for most cases when a_angle is disabled cos
-     value is decremented by 1.0 to get proper output with 0.0 which is
-     default value
-*/
-static const Uint8 GLES2_VertexSrc_Default_[] = " \
+static const Uint8 GLES2_Vertex_Default[] = " \
     uniform mat4 u_projection; \
     attribute vec2 a_position; \
+    attribute vec4 a_color; \
     attribute vec2 a_texCoord; \
-    attribute vec2 a_angle; \
-    attribute vec2 a_center; \
     varying vec2 v_texCoord; \
+    varying vec4 v_color; \
     \
     void main() \
     { \
-        float s = a_angle[0]; \
-        float c = a_angle[1] + 1.0; \
-        mat2 rotationMatrix = mat2(c, -s, s, c); \
-        vec2 position = rotationMatrix * (a_position - a_center) + a_center; \
         v_texCoord = a_texCoord; \
-        gl_Position = u_projection * vec4(position, 0.0, 1.0);\
+        gl_Position = u_projection * vec4(a_position, 0.0, 1.0);\
         gl_PointSize = 1.0; \
+        v_color = a_color; \
     } \
 ";
 
-static const Uint8 GLES2_FragmentSrc_SolidSrc_[] = " \
+static const Uint8 GLES2_Fragment_Solid[] = " \
     precision mediump float; \
-    uniform vec4 u_color; \
+    varying vec4 v_color; \
     \
     void main() \
     { \
-        gl_FragColor = u_color; \
+        gl_FragColor = v_color; \
     } \
 ";
 
-static const Uint8 GLES2_FragmentSrc_TextureABGRSrc_[] = " \
+static const Uint8 GLES2_Fragment_TextureABGR[] = " \
     precision mediump float; \
     uniform sampler2D u_texture; \
-    uniform vec4 u_color; \
+    varying vec4 v_color; \
     varying vec2 v_texCoord; \
     \
     void main() \
     { \
         gl_FragColor = texture2D(u_texture, v_texCoord); \
-        gl_FragColor *= u_color; \
+        gl_FragColor *= v_color; \
     } \
 ";
 
 /* ARGB to ABGR conversion */
-static const Uint8 GLES2_FragmentSrc_TextureARGBSrc_[] = " \
+static const Uint8 GLES2_Fragment_TextureARGB[] = " \
     precision mediump float; \
     uniform sampler2D u_texture; \
-    uniform vec4 u_color; \
+    varying vec4 v_color; \
     varying vec2 v_texCoord; \
     \
     void main() \
@@ -92,15 +83,15 @@ static const Uint8 GLES2_FragmentSrc_TextureARGBSrc_[] = " \
         gl_FragColor = abgr; \
         gl_FragColor.r = abgr.b; \
         gl_FragColor.b = abgr.r; \
-        gl_FragColor *= u_color; \
+        gl_FragColor *= v_color; \
     } \
 ";
 
 /* RGB to ABGR conversion */
-static const Uint8 GLES2_FragmentSrc_TextureRGBSrc_[] = " \
+static const Uint8 GLES2_Fragment_TextureRGB[] = " \
     precision mediump float; \
     uniform sampler2D u_texture; \
-    uniform vec4 u_color; \
+    varying vec4 v_color; \
     varying vec2 v_texCoord; \
     \
     void main() \
@@ -110,15 +101,15 @@ static const Uint8 GLES2_FragmentSrc_TextureRGBSrc_[] = " \
         gl_FragColor.r = abgr.b; \
         gl_FragColor.b = abgr.r; \
         gl_FragColor.a = 1.0; \
-        gl_FragColor *= u_color; \
+        gl_FragColor *= v_color; \
     } \
 ";
 
 /* BGR to ABGR conversion */
-static const Uint8 GLES2_FragmentSrc_TextureBGRSrc_[] = " \
+static const Uint8 GLES2_Fragment_TextureBGR[] = " \
     precision mediump float; \
     uniform sampler2D u_texture; \
-    uniform vec4 u_color; \
+    varying vec4 v_color; \
     varying vec2 v_texCoord; \
     \
     void main() \
@@ -126,10 +117,12 @@ static const Uint8 GLES2_FragmentSrc_TextureBGRSrc_[] = " \
         vec4 abgr = texture2D(u_texture, v_texCoord); \
         gl_FragColor = abgr; \
         gl_FragColor.a = 1.0; \
-        gl_FragColor *= u_color; \
+        gl_FragColor *= v_color; \
     } \
 ";
 
+#if SDL_HAVE_YUV
+
 #define JPEG_SHADER_CONSTANTS                                   \
 "// YUV offset \n"                                              \
 "const vec3 offset = vec3(0, -0.501960814, -0.501960814);\n"    \
@@ -163,7 +156,7 @@ static const Uint8 GLES2_FragmentSrc_TextureBGRSrc_[] = " \
 "uniform sampler2D u_texture;\n"                                \
 "uniform sampler2D u_texture_u;\n"                              \
 "uniform sampler2D u_texture_v;\n"                              \
-"uniform vec4 u_color;\n"                                  \
+"varying vec4 v_color;\n"                                       \
 "varying vec2 v_texCoord;\n"                                    \
 "\n"                                                            \
 
@@ -185,10 +178,10 @@ static const Uint8 GLES2_FragmentSrc_TextureBGRSrc_[] = " \
 "\n"                                                            \
 "    // That was easy. :) \n"                                   \
 "    gl_FragColor = vec4(rgb, 1);\n"                            \
-"    gl_FragColor *= u_color;\n"                           \
+"    gl_FragColor *= v_color;\n"                                \
 "}"                                                             \
 
-#define NV12_SHADER_BODY                                        \
+#define NV12_RA_SHADER_BODY                                     \
 "\n"                                                            \
 "void main()\n"                                                 \
 "{\n"                                                           \
@@ -205,7 +198,27 @@ static const Uint8 GLES2_FragmentSrc_TextureBGRSrc_[] = " \
 "\n"                                                            \
 "    // That was easy. :) \n"                                   \
 "    gl_FragColor = vec4(rgb, 1);\n"                            \
-"    gl_FragColor *= u_color;\n"                           \
+"    gl_FragColor *= v_color;\n"                                \
+"}"                                                             \
+
+#define NV12_RG_SHADER_BODY                                     \
+"\n"                                                            \
+"void main()\n"                                                 \
+"{\n"                                                           \
+"    mediump vec3 yuv;\n"                                       \
+"    lowp vec3 rgb;\n"                                          \
+"\n"                                                            \
+"    // Get the YUV values \n"                                  \
+"    yuv.x = texture2D(u_texture,   v_texCoord).r;\n"           \
+"    yuv.yz = texture2D(u_texture_u, v_texCoord).rg;\n"         \
+"\n"                                                            \
+"    // Do the color transform \n"                              \
+"    yuv += offset;\n"                                          \
+"    rgb = matrix * yuv;\n"                                     \
+"\n"                                                            \
+"    // That was easy. :) \n"                                   \
+"    gl_FragColor = vec4(rgb, 1);\n"                            \
+"    gl_FragColor *= v_color;\n"                                \
 "}"                                                             \
 
 #define NV21_SHADER_BODY                                        \
@@ -225,344 +238,132 @@ static const Uint8 GLES2_FragmentSrc_TextureBGRSrc_[] = " \
 "\n"                                                            \
 "    // That was easy. :) \n"                                   \
 "    gl_FragColor = vec4(rgb, 1);\n"                            \
-"    gl_FragColor *= u_color;\n"                           \
+"    gl_FragColor *= v_color;\n"                                \
 "}"                                                             \
 
 /* YUV to ABGR conversion */
-static const Uint8 GLES2_FragmentSrc_TextureYUVJPEGSrc_[] = \
+static const Uint8 GLES2_Fragment_TextureYUVJPEG[] = \
         YUV_SHADER_PROLOGUE \
         JPEG_SHADER_CONSTANTS \
         YUV_SHADER_BODY \
 ;
-static const Uint8 GLES2_FragmentSrc_TextureYUVBT601Src_[] = \
+static const Uint8 GLES2_Fragment_TextureYUVBT601[] = \
         YUV_SHADER_PROLOGUE \
         BT601_SHADER_CONSTANTS \
         YUV_SHADER_BODY \
 ;
-static const Uint8 GLES2_FragmentSrc_TextureYUVBT709Src_[] = \
+static const Uint8 GLES2_Fragment_TextureYUVBT709[] = \
         YUV_SHADER_PROLOGUE \
         BT709_SHADER_CONSTANTS \
         YUV_SHADER_BODY \
 ;
 
 /* NV12 to ABGR conversion */
-static const Uint8 GLES2_FragmentSrc_TextureNV12JPEGSrc_[] = \
+static const Uint8 GLES2_Fragment_TextureNV12JPEG[] = \
         YUV_SHADER_PROLOGUE \
         JPEG_SHADER_CONSTANTS \
-        NV12_SHADER_BODY \
+        NV12_RA_SHADER_BODY \
 ;
-static const Uint8 GLES2_FragmentSrc_TextureNV12BT601Src_[] = \
+static const Uint8 GLES2_Fragment_TextureNV12BT601_RA[] = \
         YUV_SHADER_PROLOGUE \
         BT601_SHADER_CONSTANTS \
-        NV12_SHADER_BODY \
+        NV12_RA_SHADER_BODY \
 ;
-static const Uint8 GLES2_FragmentSrc_TextureNV12BT709Src_[] = \
+static const Uint8 GLES2_Fragment_TextureNV12BT601_RG[] = \
+        YUV_SHADER_PROLOGUE \
+        BT601_SHADER_CONSTANTS \
+        NV12_RG_SHADER_BODY \
+;
+static const Uint8 GLES2_Fragment_TextureNV12BT709_RA[] = \
         YUV_SHADER_PROLOGUE \
         BT709_SHADER_CONSTANTS \
-        NV12_SHADER_BODY \
+        NV12_RA_SHADER_BODY \
+;
+static const Uint8 GLES2_Fragment_TextureNV12BT709_RG[] = \
+        YUV_SHADER_PROLOGUE \
+        BT709_SHADER_CONSTANTS \
+        NV12_RG_SHADER_BODY \
 ;
 
 /* NV21 to ABGR conversion */
-static const Uint8 GLES2_FragmentSrc_TextureNV21JPEGSrc_[] = \
+static const Uint8 GLES2_Fragment_TextureNV21JPEG[] = \
         YUV_SHADER_PROLOGUE \
         JPEG_SHADER_CONSTANTS \
         NV21_SHADER_BODY \
 ;
-static const Uint8 GLES2_FragmentSrc_TextureNV21BT601Src_[] = \
+static const Uint8 GLES2_Fragment_TextureNV21BT601[] = \
         YUV_SHADER_PROLOGUE \
         BT601_SHADER_CONSTANTS \
         NV21_SHADER_BODY \
 ;
-static const Uint8 GLES2_FragmentSrc_TextureNV21BT709Src_[] = \
+static const Uint8 GLES2_Fragment_TextureNV21BT709[] = \
         YUV_SHADER_PROLOGUE \
         BT709_SHADER_CONSTANTS \
         NV21_SHADER_BODY \
 ;
+#endif
 
 /* Custom Android video format texture */
-static const Uint8 GLES2_FragmentSrc_TextureExternalOESSrc_[] = " \
+static const Uint8 GLES2_Fragment_TextureExternalOES[] = " \
     #extension GL_OES_EGL_image_external : require\n\
     precision mediump float; \
     uniform samplerExternalOES u_texture; \
-    uniform vec4 u_color; \
+    varying vec4 v_color; \
     varying vec2 v_texCoord; \
     \
     void main() \
     { \
         gl_FragColor = texture2D(u_texture, v_texCoord); \
-        gl_FragColor *= u_color; \
+        gl_FragColor *= v_color; \
     } \
 ";
 
-static const GLES2_ShaderInstance GLES2_VertexSrc_Default = {
-    GL_VERTEX_SHADER,
-    GLES2_SOURCE_SHADER,
-    sizeof(GLES2_VertexSrc_Default_),
-    GLES2_VertexSrc_Default_
-};
-
-static const GLES2_ShaderInstance GLES2_FragmentSrc_SolidSrc = {
-    GL_FRAGMENT_SHADER,
-    GLES2_SOURCE_SHADER,
-    sizeof(GLES2_FragmentSrc_SolidSrc_),
-    GLES2_FragmentSrc_SolidSrc_
-};
-
-static const GLES2_ShaderInstance GLES2_FragmentSrc_TextureABGRSrc = {
-    GL_FRAGMENT_SHADER,
-    GLES2_SOURCE_SHADER,
-    sizeof(GLES2_FragmentSrc_TextureABGRSrc_),
-    GLES2_FragmentSrc_TextureABGRSrc_
-};
-
-static const GLES2_ShaderInstance GLES2_FragmentSrc_TextureARGBSrc = {
-    GL_FRAGMENT_SHADER,
-    GLES2_SOURCE_SHADER,
-    sizeof(GLES2_FragmentSrc_TextureARGBSrc_),
-    GLES2_FragmentSrc_TextureARGBSrc_
-};
-
-static const GLES2_ShaderInstance GLES2_FragmentSrc_TextureRGBSrc = {
-    GL_FRAGMENT_SHADER,
-    GLES2_SOURCE_SHADER,
-    sizeof(GLES2_FragmentSrc_TextureRGBSrc_),
-    GLES2_FragmentSrc_TextureRGBSrc_
-};
-
-static const GLES2_ShaderInstance GLES2_FragmentSrc_TextureBGRSrc = {
-    GL_FRAGMENT_SHADER,
-    GLES2_SOURCE_SHADER,
-    sizeof(GLES2_FragmentSrc_TextureBGRSrc_),
-    GLES2_FragmentSrc_TextureBGRSrc_
-};
-
-static const GLES2_ShaderInstance GLES2_FragmentSrc_TextureYUVJPEGSrc = {
-    GL_FRAGMENT_SHADER,
-    GLES2_SOURCE_SHADER,
-    sizeof(GLES2_FragmentSrc_TextureYUVJPEGSrc_),
-    GLES2_FragmentSrc_TextureYUVJPEGSrc_
-};
-
-static const GLES2_ShaderInstance GLES2_FragmentSrc_TextureYUVBT601Src = {
-    GL_FRAGMENT_SHADER,
-    GLES2_SOURCE_SHADER,
-    sizeof(GLES2_FragmentSrc_TextureYUVBT601Src_),
-    GLES2_FragmentSrc_TextureYUVBT601Src_
-};
-
-static const GLES2_ShaderInstance GLES2_FragmentSrc_TextureYUVBT709Src = {
-    GL_FRAGMENT_SHADER,
-    GLES2_SOURCE_SHADER,
-    sizeof(GLES2_FragmentSrc_TextureYUVBT709Src_),
-    GLES2_FragmentSrc_TextureYUVBT709Src_
-};
-
-static const GLES2_ShaderInstance GLES2_FragmentSrc_TextureNV12JPEGSrc = {
-    GL_FRAGMENT_SHADER,
-    GLES2_SOURCE_SHADER,
-    sizeof(GLES2_FragmentSrc_TextureNV12JPEGSrc_),
-    GLES2_FragmentSrc_TextureNV12JPEGSrc_
-};
-
-static const GLES2_ShaderInstance GLES2_FragmentSrc_TextureNV12BT601Src = {
-    GL_FRAGMENT_SHADER,
-    GLES2_SOURCE_SHADER,
-    sizeof(GLES2_FragmentSrc_TextureNV12BT601Src_),
-    GLES2_FragmentSrc_TextureNV12BT601Src_
-};
-
-static const GLES2_ShaderInstance GLES2_FragmentSrc_TextureNV21BT709Src = {
-    GL_FRAGMENT_SHADER,
-    GLES2_SOURCE_SHADER,
-    sizeof(GLES2_FragmentSrc_TextureNV21BT709Src_),
-    GLES2_FragmentSrc_TextureNV21BT709Src_
-};
-
-static const GLES2_ShaderInstance GLES2_FragmentSrc_TextureNV21JPEGSrc = {
-    GL_FRAGMENT_SHADER,
-    GLES2_SOURCE_SHADER,
-    sizeof(GLES2_FragmentSrc_TextureNV21JPEGSrc_),
-    GLES2_FragmentSrc_TextureNV21JPEGSrc_
-};
-
-static const GLES2_ShaderInstance GLES2_FragmentSrc_TextureNV21BT601Src = {
-    GL_FRAGMENT_SHADER,
-    GLES2_SOURCE_SHADER,
-    sizeof(GLES2_FragmentSrc_TextureNV21BT601Src_),
-    GLES2_FragmentSrc_TextureNV21BT601Src_
-};
-
-static const GLES2_ShaderInstance GLES2_FragmentSrc_TextureNV12BT709Src = {
-    GL_FRAGMENT_SHADER,
-    GLES2_SOURCE_SHADER,
-    sizeof(GLES2_FragmentSrc_TextureNV12BT709Src_),
-    GLES2_FragmentSrc_TextureNV12BT709Src_
-};
-
-static const GLES2_ShaderInstance GLES2_FragmentSrc_TextureExternalOESSrc = {
-    GL_FRAGMENT_SHADER,
-    GLES2_SOURCE_SHADER,
-    sizeof(GLES2_FragmentSrc_TextureExternalOESSrc_),
-    GLES2_FragmentSrc_TextureExternalOESSrc_
-};
-
-
-/*************************************************************************************************
- * Vertex/fragment shader definitions                                                            *
- *************************************************************************************************/
-
-static GLES2_Shader GLES2_VertexShader_Default = {
-    1,
-    {
-        &GLES2_VertexSrc_Default
-    }
-};
-
-static GLES2_Shader GLES2_FragmentShader_SolidSrc = {
-    1,
-    {
-        &GLES2_FragmentSrc_SolidSrc
-    }
-};
-
-static GLES2_Shader GLES2_FragmentShader_TextureABGRSrc = {
-    1,
-    {
-        &GLES2_FragmentSrc_TextureABGRSrc
-    }
-};
-
-static GLES2_Shader GLES2_FragmentShader_TextureARGBSrc = {
-    1,
-    {
-        &GLES2_FragmentSrc_TextureARGBSrc
-    }
-};
-
-static GLES2_Shader GLES2_FragmentShader_TextureRGBSrc = {
-    1,
-    {
-        &GLES2_FragmentSrc_TextureRGBSrc
-    }
-};
-
-static GLES2_Shader GLES2_FragmentShader_TextureBGRSrc = {
-    1,
-    {
-        &GLES2_FragmentSrc_TextureBGRSrc
-    }
-};
-
-static GLES2_Shader GLES2_FragmentShader_TextureYUVJPEGSrc = {
-    1,
-    {
-        &GLES2_FragmentSrc_TextureYUVJPEGSrc
-    }
-};
-
-static GLES2_Shader GLES2_FragmentShader_TextureYUVBT601Src = {
-    1,
-    {
-        &GLES2_FragmentSrc_TextureYUVBT601Src
-    }
-};
-
-static GLES2_Shader GLES2_FragmentShader_TextureYUVBT709Src = {
-    1,
-    {
-        &GLES2_FragmentSrc_TextureYUVBT709Src
-    }
-};
-
-static GLES2_Shader GLES2_FragmentShader_TextureNV12JPEGSrc = {
-    1,
-    {
-        &GLES2_FragmentSrc_TextureNV12JPEGSrc
-    }
-};
-
-static GLES2_Shader GLES2_FragmentShader_TextureNV12BT601Src = {
-    1,
-    {
-        &GLES2_FragmentSrc_TextureNV12BT601Src
-    }
-};
-
-static GLES2_Shader GLES2_FragmentShader_TextureNV12BT709Src = {
-    1,
-    {
-        &GLES2_FragmentSrc_TextureNV12BT709Src
-    }
-};
-
-static GLES2_Shader GLES2_FragmentShader_TextureNV21JPEGSrc = {
-    1,
-    {
-        &GLES2_FragmentSrc_TextureNV21JPEGSrc
-    }
-};
-
-static GLES2_Shader GLES2_FragmentShader_TextureNV21BT601Src = {
-    1,
-    {
-        &GLES2_FragmentSrc_TextureNV21BT601Src
-    }
-};
-
-static GLES2_Shader GLES2_FragmentShader_TextureNV21BT709Src = {
-    1,
-    {
-        &GLES2_FragmentSrc_TextureNV21BT709Src
-    }
-};
-
-static GLES2_Shader GLES2_FragmentShader_TextureExternalOESSrc = {
-    1,
-    {
-        &GLES2_FragmentSrc_TextureExternalOESSrc
-    }
-};
-
 
 /*************************************************************************************************
  * Shader selector                                                                               *
  *************************************************************************************************/
 
-const GLES2_Shader *GLES2_GetShader(GLES2_ShaderType type)
+const Uint8 *GLES2_GetShader(GLES2_ShaderType type)
 {
     switch (type) {
     case GLES2_SHADER_VERTEX_DEFAULT:
-        return &GLES2_VertexShader_Default;
-    case GLES2_SHADER_FRAGMENT_SOLID_SRC:
-        return &GLES2_FragmentShader_SolidSrc;
-    case GLES2_SHADER_FRAGMENT_TEXTURE_ABGR_SRC:
-        return &GLES2_FragmentShader_TextureABGRSrc;
-    case GLES2_SHADER_FRAGMENT_TEXTURE_ARGB_SRC:
-        return &GLES2_FragmentShader_TextureARGBSrc;
-    case GLES2_SHADER_FRAGMENT_TEXTURE_RGB_SRC:
-        return &GLES2_FragmentShader_TextureRGBSrc;
-    case GLES2_SHADER_FRAGMENT_TEXTURE_BGR_SRC:
-        return &GLES2_FragmentShader_TextureBGRSrc;
-    case GLES2_SHADER_FRAGMENT_TEXTURE_YUV_JPEG_SRC:
-        return &GLES2_FragmentShader_TextureYUVJPEGSrc;
-    case GLES2_SHADER_FRAGMENT_TEXTURE_YUV_BT601_SRC:
-        return &GLES2_FragmentShader_TextureYUVBT601Src;
-    case GLES2_SHADER_FRAGMENT_TEXTURE_YUV_BT709_SRC:
-        return &GLES2_FragmentShader_TextureYUVBT709Src;
-    case GLES2_SHADER_FRAGMENT_TEXTURE_NV12_JPEG_SRC:
-        return &GLES2_FragmentShader_TextureNV12JPEGSrc;
-    case GLES2_SHADER_FRAGMENT_TEXTURE_NV12_BT601_SRC:
-        return &GLES2_FragmentShader_TextureNV12BT601Src;
-    case GLES2_SHADER_FRAGMENT_TEXTURE_NV12_BT709_SRC:
-        return &GLES2_FragmentShader_TextureNV12BT709Src;
-    case GLES2_SHADER_FRAGMENT_TEXTURE_NV21_JPEG_SRC:
-        return &GLES2_FragmentShader_TextureNV21JPEGSrc;
-    case GLES2_SHADER_FRAGMENT_TEXTURE_NV21_BT601_SRC:
-        return &GLES2_FragmentShader_TextureNV21BT601Src;
-    case GLES2_SHADER_FRAGMENT_TEXTURE_NV21_BT709_SRC:
-        return &GLES2_FragmentShader_TextureNV21BT709Src;
-    case GLES2_SHADER_FRAGMENT_TEXTURE_EXTERNAL_OES_SRC:
-        return &GLES2_FragmentShader_TextureExternalOESSrc;
+        return GLES2_Vertex_Default;
+    case GLES2_SHADER_FRAGMENT_SOLID:
+        return GLES2_Fragment_Solid;
+    case GLES2_SHADER_FRAGMENT_TEXTURE_ABGR:
+        return GLES2_Fragment_TextureABGR;
+    case GLES2_SHADER_FRAGMENT_TEXTURE_ARGB:
+        return GLES2_Fragment_TextureARGB;
+    case GLES2_SHADER_FRAGMENT_TEXTURE_RGB:
+        return GLES2_Fragment_TextureRGB;
+    case GLES2_SHADER_FRAGMENT_TEXTURE_BGR:
+        return GLES2_Fragment_TextureBGR;
+#if SDL_HAVE_YUV
+    case GLES2_SHADER_FRAGMENT_TEXTURE_YUV_JPEG:
+        return GLES2_Fragment_TextureYUVJPEG;
+    case GLES2_SHADER_FRAGMENT_TEXTURE_YUV_BT601:
+        return GLES2_Fragment_TextureYUVBT601;
+    case GLES2_SHADER_FRAGMENT_TEXTURE_YUV_BT709:
+        return GLES2_Fragment_TextureYUVBT709;
+    case GLES2_SHADER_FRAGMENT_TEXTURE_NV12_JPEG:
+        return GLES2_Fragment_TextureNV12JPEG;
+    case GLES2_SHADER_FRAGMENT_TEXTURE_NV12_RA_BT601:
+        return GLES2_Fragment_TextureNV12BT601_RA;
+    case GLES2_SHADER_FRAGMENT_TEXTURE_NV12_RG_BT601:
+        return GLES2_Fragment_TextureNV12BT601_RG;
+    case GLES2_SHADER_FRAGMENT_TEXTURE_NV12_RA_BT709:
+        return GLES2_Fragment_TextureNV12BT709_RA;
+    case GLES2_SHADER_FRAGMENT_TEXTURE_NV12_RG_BT709:
+        return GLES2_Fragment_TextureNV12BT709_RG;
+    case GLES2_SHADER_FRAGMENT_TEXTURE_NV21_JPEG:
+        return GLES2_Fragment_TextureNV21JPEG;
+    case GLES2_SHADER_FRAGMENT_TEXTURE_NV21_BT601:
+        return GLES2_Fragment_TextureNV21BT601;
+    case GLES2_SHADER_FRAGMENT_TEXTURE_NV21_BT709:
+        return GLES2_Fragment_TextureNV21BT709;
+#endif
+    case GLES2_SHADER_FRAGMENT_TEXTURE_EXTERNAL_OES:
+        return GLES2_Fragment_TextureExternalOES;
     default:
         return NULL;
     }
diff --git a/Engine/lib/sdl/src/render/opengles2/SDL_shaders_gles2.h b/Engine/lib/sdl/src/render/opengles2/SDL_shaders_gles2.h
index 6cbf92acd..09780239d 100644
--- a/Engine/lib/sdl/src/render/opengles2/SDL_shaders_gles2.h
+++ b/Engine/lib/sdl/src/render/opengles2/SDL_shaders_gles2.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -25,43 +25,33 @@
 
 #if SDL_VIDEO_RENDER_OGL_ES2
 
-typedef struct GLES2_ShaderInstance
-{
-    GLenum type;
-    GLenum format;
-    int length;
-    const void *data;
-} GLES2_ShaderInstance;
-
-typedef struct GLES2_Shader
-{
-    int instance_count;
-    const GLES2_ShaderInstance *instances[4];
-} GLES2_Shader;
 
 typedef enum
 {
-    GLES2_SHADER_VERTEX_DEFAULT,
-    GLES2_SHADER_FRAGMENT_SOLID_SRC,
-    GLES2_SHADER_FRAGMENT_TEXTURE_ABGR_SRC,
-    GLES2_SHADER_FRAGMENT_TEXTURE_ARGB_SRC,
-    GLES2_SHADER_FRAGMENT_TEXTURE_BGR_SRC,
-    GLES2_SHADER_FRAGMENT_TEXTURE_RGB_SRC,
-    GLES2_SHADER_FRAGMENT_TEXTURE_YUV_JPEG_SRC,
-    GLES2_SHADER_FRAGMENT_TEXTURE_YUV_BT601_SRC,
-    GLES2_SHADER_FRAGMENT_TEXTURE_YUV_BT709_SRC,
-    GLES2_SHADER_FRAGMENT_TEXTURE_NV12_JPEG_SRC,
-    GLES2_SHADER_FRAGMENT_TEXTURE_NV12_BT601_SRC,
-    GLES2_SHADER_FRAGMENT_TEXTURE_NV12_BT709_SRC,
-    GLES2_SHADER_FRAGMENT_TEXTURE_NV21_JPEG_SRC,
-    GLES2_SHADER_FRAGMENT_TEXTURE_NV21_BT601_SRC,
-    GLES2_SHADER_FRAGMENT_TEXTURE_NV21_BT709_SRC,
-    GLES2_SHADER_FRAGMENT_TEXTURE_EXTERNAL_OES_SRC
+    GLES2_SHADER_VERTEX_DEFAULT = 0,
+    GLES2_SHADER_FRAGMENT_SOLID,
+    GLES2_SHADER_FRAGMENT_TEXTURE_ABGR,
+    GLES2_SHADER_FRAGMENT_TEXTURE_ARGB,
+    GLES2_SHADER_FRAGMENT_TEXTURE_BGR,
+    GLES2_SHADER_FRAGMENT_TEXTURE_RGB,
+#if SDL_HAVE_YUV
+    GLES2_SHADER_FRAGMENT_TEXTURE_YUV_JPEG,
+    GLES2_SHADER_FRAGMENT_TEXTURE_YUV_BT601,
+    GLES2_SHADER_FRAGMENT_TEXTURE_YUV_BT709,
+    GLES2_SHADER_FRAGMENT_TEXTURE_NV12_JPEG,
+    GLES2_SHADER_FRAGMENT_TEXTURE_NV12_RA_BT601,
+    GLES2_SHADER_FRAGMENT_TEXTURE_NV12_RG_BT601,
+    GLES2_SHADER_FRAGMENT_TEXTURE_NV12_RA_BT709,
+    GLES2_SHADER_FRAGMENT_TEXTURE_NV12_RG_BT709,
+    GLES2_SHADER_FRAGMENT_TEXTURE_NV21_JPEG,
+    GLES2_SHADER_FRAGMENT_TEXTURE_NV21_BT601,
+    GLES2_SHADER_FRAGMENT_TEXTURE_NV21_BT709,
+#endif
+    GLES2_SHADER_FRAGMENT_TEXTURE_EXTERNAL_OES,
+    GLES2_SHADER_COUNT
 } GLES2_ShaderType;
 
-#define GLES2_SOURCE_SHADER (GLenum)-1
-
-const GLES2_Shader *GLES2_GetShader(GLES2_ShaderType type);
+const Uint8 *GLES2_GetShader(GLES2_ShaderType type);
 
 #endif /* SDL_VIDEO_RENDER_OGL_ES2 */
 
diff --git a/Engine/lib/sdl/src/render/psp/SDL_render_psp.c b/Engine/lib/sdl/src/render/psp/SDL_render_psp.c
index 6aad21f6b..cdc0b9156 100644
--- a/Engine/lib/sdl/src/render/psp/SDL_render_psp.c
+++ b/Engine/lib/sdl/src/render/psp/SDL_render_psp.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -56,24 +56,13 @@ static unsigned int __attribute__((aligned(16))) DisplayList[262144];
 #define COL4444(r,g,b,a)    ((r>>4) | ((g>>4)<<4) | ((b>>4)<<8) | ((a>>4)<<12))
 #define COL8888(r,g,b,a)    ((r) | ((g)<<8) | ((b)<<16) | ((a)<<24))
 
-
-typedef struct
-{
-    void*           frontbuffer ;
-    void*           backbuffer ;
-    SDL_bool        initialized ;
-    SDL_bool        displayListAvail ;
-    unsigned int    psm ;
-    unsigned int    bpp ;
-
-    SDL_bool        vsync;
-    unsigned int    currentColor;
-    int             currentBlendMode;
-
-} PSP_RenderData;
-
-
-typedef struct
+/**
+ * Holds psp specific texture data
+ *
+ * Part of a hot-list of textures that are used as render targets
+ * When short of vram we spill Least-Recently-Used render targets to system memory
+ */
+typedef struct PSP_TextureData
 {
     void                *data;                              /**< Image data. */
     unsigned int        size;                               /**< Size of data in bytes. */
@@ -85,9 +74,37 @@ typedef struct
     unsigned int        format;                             /**< Image format - one of ::pgePixelFormat. */
     unsigned int        pitch;
     SDL_bool            swizzled;                           /**< Is image swizzled. */
-
+    struct PSP_TextureData*    prevhotw;                    /**< More recently used render target */
+    struct PSP_TextureData*    nexthotw;                    /**< Less recently used render target */
 } PSP_TextureData;
 
+typedef struct
+{
+    SDL_BlendMode mode;
+    unsigned int color;
+    int shadeModel;
+    SDL_Texture* texture;
+} PSP_BlendState;
+
+typedef struct
+{
+    void*              frontbuffer;                         /**< main screen buffer */
+    void*              backbuffer;                          /**< buffer presented to display */
+    SDL_Texture*       boundTarget;                         /**< currently bound rendertarget */
+    SDL_bool           initialized;                         /**< is driver initialized */
+    SDL_bool           displayListAvail;                    /**< is the display list already initialized for this frame */
+    unsigned int       psm;                                 /**< format of the display buffers */
+    unsigned int       bpp;                                 /**< bits per pixel of the main display */
+
+    SDL_bool           vsync;                               /**< wether we do vsync */
+    PSP_BlendState     blendState;                          /**< current blend mode */
+    PSP_TextureData*   most_recent_target;                  /**< start of render target LRU double linked list */
+    PSP_TextureData*   least_recent_target;                 /**< end of the LRU list */
+
+    SDL_bool           vblank_not_reached;                  /**< wether vblank wasn't reached */
+} PSP_RenderData;
+
+
 typedef struct
 {
     float   x, y, z;
@@ -98,15 +115,29 @@ typedef struct
 {
     float   u, v;
     float   x, y, z;
-
 } VertTV;
 
+typedef struct
+{
+    SDL_Color col;
+    float     x, y, z;
+} VertCV;
+
+
+typedef struct
+{
+    float     u, v;
+    SDL_Color col;
+    float     x, y, z;
+} VertTCV;
+
 #define PI   3.14159265358979f
 
 #define radToDeg(x) ((x)*180.f/PI)
 #define degToRad(x) ((x)*PI/180.f)
 
-float MathAbs(float x)
+static float
+MathAbs(float x)
 {
     float result;
 
@@ -119,7 +150,8 @@ float MathAbs(float x)
     return result;
 }
 
-void MathSincos(float r, float *s, float *c)
+static void
+MathSincos(float r, float *s, float *c)
 {
     __asm__ volatile (
         "mtv      %2, S002\n"
@@ -131,28 +163,40 @@ void MathSincos(float r, float *s, float *c)
     : "=r"(*s), "=r"(*c): "r"(r));
 }
 
-void Swap(float *a, float *b)
+static void
+Swap(float *a, float *b)
 {
     float n=*a;
     *a = *b;
     *b = n;
 }
 
+static inline int
+InVram(void* data)
+{
+    return data < (void*)0x04200000;
+}
+
 /* Return next power of 2 */
 static int
 TextureNextPow2(unsigned int w)
 {
+    unsigned int n = 2;
     if(w == 0)
         return 0;
 
-    unsigned int n = 2;
-
     while(w > n)
         n <<= 1;
 
     return n;
 }
 
+static void psp_on_vblank(u32 sub, PSP_RenderData *data)
+{
+   if (data)
+      data->vblank_not_reached = SDL_FALSE;
+}
+
 
 static int
 PixelFormatToPSPFMT(Uint32 format)
@@ -171,36 +215,89 @@ PixelFormatToPSPFMT(Uint32 format)
     }
 }
 
-void
-StartDrawing(SDL_Renderer * renderer)
-{
-    PSP_RenderData *data = (PSP_RenderData *) renderer->driverdata;
-    if(data->displayListAvail)
-        return;
-
-    sceGuStart(GU_DIRECT, DisplayList);
-    data->displayListAvail = SDL_TRUE;
+///SECTION render target LRU management
+static void
+LRUTargetRelink(PSP_TextureData* psp_texture) {
+    if(psp_texture->prevhotw) {
+        psp_texture->prevhotw->nexthotw = psp_texture->nexthotw;
+    }
+    if(psp_texture->nexthotw) {
+        psp_texture->nexthotw->prevhotw = psp_texture->prevhotw;
+    }
 }
 
+static void
+LRUTargetPushFront(PSP_RenderData* data, PSP_TextureData* psp_texture) {
+    psp_texture->nexthotw = data->most_recent_target;
+    if(data->most_recent_target) {
+        data->most_recent_target->prevhotw = psp_texture;
+    }
+    data->most_recent_target = psp_texture;
+    if(!data->least_recent_target) {
+        data->least_recent_target = psp_texture;
+    }
+}
 
-int
-TextureSwizzle(PSP_TextureData *psp_texture)
+static void
+LRUTargetRemove(PSP_RenderData* data, PSP_TextureData* psp_texture) {
+    LRUTargetRelink(psp_texture);
+    if(data->most_recent_target == psp_texture) {
+        data->most_recent_target = psp_texture->nexthotw;
+    }
+    if(data->least_recent_target == psp_texture) {
+        data->least_recent_target = psp_texture->prevhotw;
+    }
+    psp_texture->prevhotw = NULL;
+    psp_texture->nexthotw = NULL;
+}
+
+static void
+LRUTargetBringFront(PSP_RenderData* data, PSP_TextureData* psp_texture) {
+    if(data->most_recent_target == psp_texture) {
+        return; //nothing to do
+    }
+    LRUTargetRemove(data, psp_texture);
+    LRUTargetPushFront(data, psp_texture);
+}
+
+static void
+TextureStorageFree(void* storage) {
+    if(InVram(storage)) {
+        vfree(storage);
+    } else {
+        SDL_free(storage);
+    }
+}
+
+static int
+TextureSwizzle(PSP_TextureData *psp_texture, void* dst)
 {
+    int bytewidth, height;
+    int rowblocks, rowblocksadd;
+    int i, j;
+    unsigned int blockaddress = 0;
+    unsigned int *src = NULL;
+    unsigned char *data = NULL;
+
     if(psp_texture->swizzled)
         return 1;
 
-    int bytewidth = psp_texture->textureWidth*(psp_texture->bits>>3);
-    int height = psp_texture->size / bytewidth;
+    bytewidth = psp_texture->textureWidth*(psp_texture->bits>>3);
+    height = psp_texture->size / bytewidth;
 
-    int rowblocks = (bytewidth>>4);
-    int rowblocksadd = (rowblocks-1)<<7;
-    unsigned int blockaddress = 0;
-    unsigned int *src = (unsigned int*) psp_texture->data;
+    rowblocks = (bytewidth>>4);
+    rowblocksadd = (rowblocks-1)<<7;
 
-    unsigned char *data = NULL;
-    data = malloc(psp_texture->size);
+    src = (unsigned int*) psp_texture->data;
 
-    int j;
+    data = dst;
+    if(!data) {
+        data = SDL_malloc(psp_texture->size);
+    }
+
+    if(!data) {
+        return SDL_OutOfMemory();
+    }
 
     for(j = 0; j < height; j++, blockaddress += 16)
     {
@@ -208,8 +305,6 @@ TextureSwizzle(PSP_TextureData *psp_texture)
 
         block = (unsigned int*)&data[blockaddress];
 
-        int i;
-
         for(i = 0; i < rowblocks; i++)
         {
             *block++ = *src++;
@@ -223,42 +318,50 @@ TextureSwizzle(PSP_TextureData *psp_texture)
             blockaddress += rowblocksadd;
     }
 
-    free(psp_texture->data);
+    TextureStorageFree(psp_texture->data);
     psp_texture->data = data;
     psp_texture->swizzled = SDL_TRUE;
 
+    sceKernelDcacheWritebackRange(psp_texture->data, psp_texture->size);
     return 1;
 }
-int TextureUnswizzle(PSP_TextureData *psp_texture)
+
+static int
+TextureUnswizzle(PSP_TextureData *psp_texture, void* dst)
 {
+    int bytewidth, height;
+    int widthblocks, heightblocks;
+    int dstpitch, dstrow;
+    int blockx, blocky;
+    int j;
+    unsigned int *src = NULL;
+    unsigned char *data = NULL;
+    unsigned char *ydst = NULL;
+
     if(!psp_texture->swizzled)
         return 1;
 
-    int blockx, blocky;
+    bytewidth = psp_texture->textureWidth*(psp_texture->bits>>3);
+    height = psp_texture->size / bytewidth;
 
-    int bytewidth = psp_texture->textureWidth*(psp_texture->bits>>3);
-    int height = psp_texture->size / bytewidth;
+    widthblocks = bytewidth/16;
+    heightblocks = height/8;
 
-    int widthblocks = bytewidth/16;
-    int heightblocks = height/8;
+    dstpitch = (bytewidth - 16)/4;
+    dstrow = bytewidth * 8;
 
-    int dstpitch = (bytewidth - 16)/4;
-    int dstrow = bytewidth * 8;
+    src = (unsigned int*) psp_texture->data;
 
-    unsigned int *src = (unsigned int*) psp_texture->data;
+    data = dst;
 
-    unsigned char *data = NULL;
-
-    data = malloc(psp_texture->size);
+    if(!data) {
+        data = SDL_malloc(psp_texture->size);
+    }
 
     if(!data)
-        return 0;
+        return SDL_OutOfMemory();
 
-    sceKernelDcacheWritebackAll();
-
-    int j;
-
-    unsigned char *ydst = (unsigned char *)data;
+    ydst = (unsigned char *)data;
 
     for(blocky = 0; blocky < heightblocks; ++blocky)
     {
@@ -285,15 +388,108 @@ int TextureUnswizzle(PSP_TextureData *psp_texture)
         ydst += dstrow;
     }
 
-    free(psp_texture->data);
+    TextureStorageFree(psp_texture->data);
 
     psp_texture->data = data;
 
     psp_texture->swizzled = SDL_FALSE;
 
+    sceKernelDcacheWritebackRange(psp_texture->data, psp_texture->size);
     return 1;
 }
 
+static int
+TextureSpillToSram(PSP_RenderData* data, PSP_TextureData* psp_texture)
+{
+    // Assumes the texture is in VRAM
+    if(psp_texture->swizzled) {
+        //Texture was swizzled in vram, just copy to system memory
+        void* data = SDL_malloc(psp_texture->size);
+        if(!data) {
+            return SDL_OutOfMemory();
+        }
+
+        SDL_memcpy(data, psp_texture->data, psp_texture->size);
+        vfree(psp_texture->data);
+        psp_texture->data = data;
+        return 0;
+    } else {
+        return TextureSwizzle(psp_texture, NULL); //Will realloc in sysram
+    }
+}
+
+static int
+TexturePromoteToVram(PSP_RenderData* data, PSP_TextureData* psp_texture, SDL_bool target)
+{
+    // Assumes texture in sram and a large enough continuous block in vram
+    void* tdata = valloc(psp_texture->size);
+    if(psp_texture->swizzled && target) {
+        return TextureUnswizzle(psp_texture, tdata);
+    } else {
+        SDL_memcpy(tdata, psp_texture->data, psp_texture->size);
+        SDL_free(psp_texture->data);
+        psp_texture->data = tdata;
+        return 0;
+    }
+}
+
+static int
+TextureSpillLRU(PSP_RenderData* data, size_t wanted) {
+    PSP_TextureData* lru = data->least_recent_target;
+    if(lru) {
+        if(TextureSpillToSram(data, lru) < 0) {
+            return -1;
+        }
+        LRUTargetRemove(data, lru);
+    } else {
+        // Asked to spill but there nothing to spill
+        return SDL_SetError("Could not spill more VRAM to system memory. VRAM : %dKB,(%dKB), wanted %dKB", vmemavail()/1024, vlargestblock()/1024, wanted/1024);
+    }
+    return 0;
+}
+
+static int
+TextureSpillTargetsForSpace(PSP_RenderData* data, size_t size)
+{
+    while(vlargestblock() < size) {
+        if(TextureSpillLRU(data, size) < 0) {
+            return -1;
+        }
+    }
+    return 0;
+}
+
+static int
+TextureBindAsTarget(PSP_RenderData* data, PSP_TextureData* psp_texture) {
+    unsigned int dstFormat;
+
+    if(!InVram(psp_texture->data)) {
+        // Bring back the texture in vram
+        if(TextureSpillTargetsForSpace(data, psp_texture->size) < 0) {
+            return -1;
+        }
+        if(TexturePromoteToVram(data, psp_texture, SDL_TRUE) < 0) {
+            return -1;
+        }
+    }
+    LRUTargetBringFront(data, psp_texture);
+    sceGuDrawBufferList(psp_texture->format, vrelptr(psp_texture->data), psp_texture->textureWidth);
+
+    // Stencil alpha dst hack
+    dstFormat = psp_texture->format;
+    if(dstFormat == GU_PSM_5551) {
+        sceGuEnable(GU_STENCIL_TEST);
+        sceGuStencilOp(GU_REPLACE, GU_REPLACE, GU_REPLACE);
+        sceGuStencilFunc(GU_GEQUAL, 0xff, 0xff);
+        sceGuEnable(GU_ALPHA_TEST);
+        sceGuAlphaFunc(GU_GREATER, 0x00, 0xff);
+    } else {
+        sceGuDisable(GU_STENCIL_TEST);
+        sceGuDisable(GU_ALPHA_TEST);
+    }
+    return 0;
+}
+
 static void
 PSP_WindowEvent(SDL_Renderer * renderer, const SDL_WindowEvent *event)
 {
@@ -303,11 +499,11 @@ PSP_WindowEvent(SDL_Renderer * renderer, const SDL_WindowEvent *event)
 static int
 PSP_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
 {
-/*      PSP_RenderData *renderdata = (PSP_RenderData *) renderer->driverdata; */
+    PSP_RenderData *data = renderer->driverdata;
     PSP_TextureData* psp_texture = (PSP_TextureData*) SDL_calloc(1, sizeof(*psp_texture));
 
     if(!psp_texture)
-        return -1;
+        return SDL_OutOfMemory();
 
     psp_texture->swizzled = SDL_FALSE;
     psp_texture->width = texture->w;
@@ -334,7 +530,17 @@ PSP_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
 
     psp_texture->pitch = psp_texture->textureWidth * SDL_BYTESPERPIXEL(texture->format);
     psp_texture->size = psp_texture->textureHeight*psp_texture->pitch;
-    psp_texture->data = SDL_calloc(1, psp_texture->size);
+    if(texture->access & SDL_TEXTUREACCESS_TARGET) {
+        if(TextureSpillTargetsForSpace(renderer->driverdata, psp_texture->size) < 0){
+            return -1;
+        }
+        psp_texture->data = valloc(psp_texture->size);
+        if(psp_texture->data) {
+            LRUTargetPushFront(data, psp_texture);
+        }
+    } else {
+        psp_texture->data = SDL_calloc(1, psp_texture->size);
+    }
 
     if(!psp_texture->data)
     {
@@ -347,32 +553,35 @@ PSP_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
 }
 
 static int
-PSP_SetTextureColorMod(SDL_Renderer * renderer, SDL_Texture * texture)
+TextureShouldSwizzle(PSP_TextureData* psp_texture, SDL_Texture *texture)
 {
-    return SDL_Unsupported();
+    return !((texture->access == SDL_TEXTUREACCESS_TARGET) && InVram(psp_texture->data))
+            && texture->access != SDL_TEXTUREACCESS_STREAMING
+            && (texture->w >= 16 || texture->h >= 16);
 }
 
-void
+static void
 TextureActivate(SDL_Texture * texture)
 {
     PSP_TextureData *psp_texture = (PSP_TextureData *) texture->driverdata;
     int scaleMode = (texture->scaleMode == SDL_ScaleModeNearest) ? GU_NEAREST : GU_LINEAR;
 
     /* Swizzling is useless with small textures. */
-    if (texture->w >= 16 || texture->h >= 16)
+    if (TextureShouldSwizzle(psp_texture, texture))
     {
-        TextureSwizzle(psp_texture);
+        TextureSwizzle(psp_texture, NULL);
     }
 
-    sceGuEnable(GU_TEXTURE_2D);
     sceGuTexWrap(GU_REPEAT, GU_REPEAT);
     sceGuTexMode(psp_texture->format, 0, 0, psp_texture->swizzled);
     sceGuTexFilter(scaleMode, scaleMode); /* GU_NEAREST good for tile-map */
                                           /* GU_LINEAR good for scaling */
     sceGuTexImage(0, psp_texture->textureWidth, psp_texture->textureHeight, psp_texture->textureWidth, psp_texture->data);
-    sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGBA);
 }
 
+static int
+PSP_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
+                 const SDL_Rect * rect, void **pixels, int *pitch);
 
 static int
 PSP_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
@@ -466,10 +675,98 @@ PSP_QueueDrawPoints(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_F
     return 0;
 }
 
+static int
+PSP_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+        const float *xy, int xy_stride, const SDL_Color *color, int color_stride, const float *uv, int uv_stride,
+        int num_vertices, const void *indices, int num_indices, int size_indices,
+        float scale_x, float scale_y)
+{
+    int i;
+    int count = indices ? num_indices : num_vertices;
+
+    cmd->data.draw.count = count;
+    size_indices = indices ? size_indices : 0;
+
+    if (texture == NULL) {
+        VertCV *verts;
+        verts = (VertCV *) SDL_AllocateRenderVertices(renderer, count * sizeof (VertCV), 4, &cmd->data.draw.first);
+        if (!verts) {
+            return -1;
+        }
+
+        for (i = 0; i < count; i++) {
+            int j;
+            float *xy_;
+            SDL_Color col_;
+            if (size_indices == 4) {
+                j = ((const Uint32 *)indices)[i];
+            } else if (size_indices == 2) {
+                j = ((const Uint16 *)indices)[i];
+            } else if (size_indices == 1) {
+                j = ((const Uint8 *)indices)[i];
+            } else {
+                j = i;
+            }
+
+            xy_ = (float *)((char*)xy + j * xy_stride);
+            col_ = *(SDL_Color *)((char*)color + j * color_stride);
+
+            verts->x = xy_[0] * scale_x;
+            verts->y = xy_[1] * scale_y;
+            verts->z = 0;
+
+            verts->col = col_;
+
+            verts++;
+        }
+    } else {
+        PSP_TextureData *psp_texture = (PSP_TextureData *) texture->driverdata;
+        VertTCV *verts;
+        verts = (VertTCV *) SDL_AllocateRenderVertices(renderer, count * sizeof (VertTCV), 4, &cmd->data.draw.first);
+        if (!verts) {
+            return -1;
+        }
+
+        for (i = 0; i < count; i++) {
+            int j;
+            float *xy_;
+            SDL_Color col_;
+            float *uv_;
+
+            if (size_indices == 4) {
+                j = ((const Uint32 *)indices)[i];
+            } else if (size_indices == 2) {
+                j = ((const Uint16 *)indices)[i];
+            } else if (size_indices == 1) {
+                j = ((const Uint8 *)indices)[i];
+            } else {
+                j = i;
+            }
+
+            xy_ = (float *)((char*)xy + j * xy_stride);
+            col_ = *(SDL_Color *)((char*)color + j * color_stride);
+            uv_ = (float *)((char*)uv + j * uv_stride);
+
+            verts->x = xy_[0] * scale_x;
+            verts->y = xy_[1] * scale_y;
+            verts->z = 0;
+
+            verts->col = col_;
+
+            verts->u = uv_[0] * psp_texture->textureWidth;
+            verts->v = uv_[1] * psp_texture->textureHeight;
+
+            verts++;
+        }
+    }
+
+    return 0;
+}
+
 static int
 PSP_QueueFillRects(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FRect * rects, int count)
 {
-    VertV *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, count * 2 * sizeof (VertV), 4, &cmd->data.draw.first);
+    VertV *verts = (VertV *) SDL_AllocateRenderVertices(renderer, count * 2 * sizeof (VertV), 4, &cmd->data.draw.first);
     int i;
 
     if (!verts) {
@@ -478,14 +775,13 @@ PSP_QueueFillRects(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FR
 
     cmd->data.draw.count = count;
     for (i = 0; i < count; i++, rects++) {
-        const SDL_FRect *rect = &rects[i];
-        verts->x = rect->x;
-        verts->y = rect->y;
+        verts->x = rects->x;
+        verts->y = rects->y;
         verts->z = 0.0f;
         verts++;
 
-        verts->x = rect->x + rect->w;
-        verts->y = rect->y + rect->h;
+        verts->x = rects->x + rects->w + 0.5f;
+        verts->y = rects->y + rects->h + 0.5f;
         verts->z = 0.0f;
         verts++;
     }
@@ -547,7 +843,7 @@ PSP_QueueCopy(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * tex
 
         cmd->data.draw.count = count;
 
-        verts = (VertTV *) SDL_AllocateRenderVertices(renderer, count * sizeof (VertTV), 4, &cmd->data.draw.first);
+        verts = (VertTV *) SDL_AllocateRenderVertices(renderer, count * 2 * sizeof (VertTV), 4, &cmd->data.draw.first);
         if (!verts) {
             return -1;
         }
@@ -565,6 +861,7 @@ PSP_QueueCopy(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * tex
             verts->x = curX;
             verts->y = y;
             verts->z = 0;
+            verts++;
 
             curU += sourceWidth;
             curX += polyWidth;
@@ -574,6 +871,7 @@ PSP_QueueCopy(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * tex
             verts->x = curX;
             verts->y = (y + height);
             verts->z = 0;
+            verts++;
         }
     }
 
@@ -583,7 +881,7 @@ PSP_QueueCopy(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * tex
 static int
 PSP_QueueCopyEx(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture,
                const SDL_Rect * srcrect, const SDL_FRect * dstrect,
-               const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip)
+               const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip, float scale_x, float scale_y)
 {
     VertTV *verts = (VertTV *) SDL_AllocateRenderVertices(renderer, 4 * sizeof (VertTV), 4, &cmd->data.draw.first);
     const float centerx = center->x;
@@ -593,25 +891,29 @@ PSP_QueueCopyEx(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * t
     const float width = dstrect->w - centerx;
     const float height = dstrect->h - centery;
     float s, c;
+    float cw1, sw1, ch1, sh1, cw2, sw2, ch2, sh2;
 
     float u0 = srcrect->x;
     float v0 = srcrect->y;
     float u1 = srcrect->x + srcrect->w;
     float v1 = srcrect->y + srcrect->h;
 
-
     if (!verts) {
         return -1;
     }
 
     cmd->data.draw.count = 1;
 
-    MathSincos(degToRad(angle), &s, &c);
+    MathSincos(degToRad(360-angle), &s, &c);
 
-    const float cw = c * width;
-    const float sw = s * width;
-    const float ch = c * height;
-    const float sh = s * height;
+    cw1 = c * -centerx;
+    sw1 = s * -centerx;
+    ch1 = c * -centery;
+    sh1 = s * -centery;
+    cw2 = c * width;
+    sw2 = s * width;
+    ch2 = c * height;
+    sh2 = s * height;
 
     if (flip & SDL_FLIP_VERTICAL) {
         Swap(&v0, &v1);
@@ -623,76 +925,148 @@ PSP_QueueCopyEx(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * t
 
     verts->u = u0;
     verts->v = v0;
-    verts->x = x - cw + sh;
-    verts->y = y - sw - ch;
+    verts->x = x + cw1 + sh1;
+    verts->y = y - sw1 + ch1;
     verts->z = 0;
     verts++;
 
     verts->u = u0;
     verts->v = v1;
-    verts->x = x - cw - sh;
-    verts->y = y - sw + ch;
+    verts->x = x + cw1 + sh2;
+    verts->y = y - sw1 + ch2;
     verts->z = 0;
     verts++;
 
     verts->u = u1;
     verts->v = v1;
-    verts->x = x + cw - sh;
-    verts->y = y + sw + ch;
+    verts->x = x + cw2 + sh2;
+    verts->y = y - sw2 + ch2;
     verts->z = 0;
     verts++;
 
     verts->u = u1;
     verts->v = v0;
-    verts->x = x + cw + sh;
-    verts->y = y + sw - ch;
+    verts->x = x + cw2 + sh1;
+    verts->y = y - sw2 + ch1;
     verts->z = 0;
-    verts++;
+
+    if (scale_x != 1.0f || scale_y != 1.0f) {
+        verts->x *= scale_x;
+        verts->y *= scale_y;
+        verts--;
+        verts->x *= scale_x;
+        verts->y *= scale_y;
+        verts--;
+        verts->x *= scale_x;
+        verts->y *= scale_y;
+        verts--;
+        verts->x *= scale_x;
+        verts->y *= scale_y;
+    }
 
     return 0;
 }
 
 static void
-PSP_SetBlendMode(SDL_Renderer * renderer, int blendMode)
+ResetBlendState(PSP_BlendState* state) {
+    sceGuColor(0xffffffff);
+    state->color = 0xffffffff;
+    state->mode = SDL_BLENDMODE_INVALID;
+    state->texture = NULL;
+    sceGuDisable(GU_TEXTURE_2D);
+    sceGuShadeModel(GU_SMOOTH);
+    state->shadeModel = GU_SMOOTH;
+}
+
+static void
+StartDrawing(SDL_Renderer * renderer)
 {
     PSP_RenderData *data = (PSP_RenderData *) renderer->driverdata;
-    if (blendMode != data-> currentBlendMode) {
-        switch (blendMode) {
+
+    // Check if we need to start GU displaylist
+    if(!data->displayListAvail) {
+        sceGuStart(GU_DIRECT, DisplayList);
+        data->displayListAvail = SDL_TRUE;
+        //ResetBlendState(&data->blendState);
+    }
+
+    // Check if we need a draw buffer change
+    if(renderer->target != data->boundTarget) {
+        SDL_Texture* texture = renderer->target;
+        if(texture) {
+            PSP_TextureData* psp_texture = (PSP_TextureData*) texture->driverdata;
+            // Set target, registering LRU
+            TextureBindAsTarget(data, psp_texture);
+        } else {
+            // Set target back to screen
+            sceGuDrawBufferList(data->psm, vrelptr(data->frontbuffer), PSP_FRAME_BUFFER_WIDTH);
+        }
+        data->boundTarget = texture;
+    }
+}
+
+
+static void
+PSP_SetBlendState(PSP_RenderData* data, PSP_BlendState* state)
+{
+    PSP_BlendState* current = &data->blendState;
+
+    if (state->mode != current->mode) {
+        switch (state->mode) {
         case SDL_BLENDMODE_NONE:
-                sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGBA);
-                sceGuDisable(GU_BLEND);
+            sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGBA);
+            sceGuDisable(GU_BLEND);
             break;
         case SDL_BLENDMODE_BLEND:
-                sceGuTexFunc(GU_TFX_MODULATE , GU_TCC_RGBA);
-                sceGuEnable(GU_BLEND);
-                sceGuBlendFunc(GU_ADD, GU_SRC_ALPHA, GU_ONE_MINUS_SRC_ALPHA, 0, 0 );
+            sceGuTexFunc(GU_TFX_MODULATE, GU_TCC_RGBA);
+            sceGuBlendFunc(GU_ADD, GU_SRC_ALPHA, GU_ONE_MINUS_SRC_ALPHA, 0, 0 );
+            sceGuEnable(GU_BLEND);
             break;
         case SDL_BLENDMODE_ADD:
-                sceGuTexFunc(GU_TFX_MODULATE , GU_TCC_RGBA);
-                sceGuEnable(GU_BLEND);
-                sceGuBlendFunc(GU_ADD, GU_SRC_ALPHA, GU_FIX, 0, 0x00FFFFFF );
+            sceGuTexFunc(GU_TFX_MODULATE , GU_TCC_RGBA);
+            sceGuBlendFunc(GU_ADD, GU_SRC_ALPHA, GU_FIX, 0, 0x00FFFFFF );
+            sceGuEnable(GU_BLEND);
             break;
         case SDL_BLENDMODE_MOD:
-                sceGuTexFunc(GU_TFX_MODULATE , GU_TCC_RGBA);
-                sceGuEnable(GU_BLEND);
-                sceGuBlendFunc(GU_ADD, GU_FIX, GU_SRC_COLOR, 0, 0);
+            sceGuTexFunc(GU_TFX_MODULATE , GU_TCC_RGBA);
+            sceGuBlendFunc(GU_ADD, GU_FIX, GU_SRC_COLOR, 0, 0);
+            sceGuEnable(GU_BLEND);
             break;
         case SDL_BLENDMODE_MUL:
-                sceGuTexFunc(GU_TFX_MODULATE , GU_TCC_RGBA);
-                sceGuEnable(GU_BLEND);
-                sceGuBlendFunc(GU_ADD, GU_DST_COLOR, GU_ONE_MINUS_SRC_ALPHA, 0, 0);
+            sceGuTexFunc(GU_TFX_MODULATE , GU_TCC_RGBA);
+            sceGuBlendFunc(GU_ADD, GU_DST_COLOR, GU_ONE_MINUS_SRC_ALPHA, 0, 0);
+            sceGuEnable(GU_BLEND);
+            break;
+        case SDL_BLENDMODE_INVALID:
             break;
         }
-        data->currentBlendMode = blendMode;
     }
+
+    if(state->color != current->color) {
+        sceGuColor(state->color);
+    }
+
+    if(state->shadeModel != current->shadeModel) {
+        sceGuShadeModel(state->shadeModel);
+    }
+
+    if(state->texture != current->texture) {
+        if(state->texture != NULL) {
+            TextureActivate(state->texture);
+            sceGuEnable(GU_TEXTURE_2D);
+        } else {
+            sceGuDisable(GU_TEXTURE_2D);
+        }
+    }
+
+    *current = *state;
 }
 
 static int
 PSP_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
 {
     PSP_RenderData *data = (PSP_RenderData *) renderer->driverdata;
-    size_t i;
-
+    Uint8 *gpumem = NULL;
     StartDrawing(renderer);
 
     /* note that before the renderer interface change, this would do extrememly small
@@ -701,7 +1075,7 @@ PSP_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *verti
        I don't know what the limits on PSP hardware are. It might be useful to have
        rendering backends report a reasonable maximum, so the higher level can flush
        if we appear to be exceeding that. */
-    Uint8 *gpumem = (Uint8 *) sceGuGetMemory(vertsize);
+    gpumem = (Uint8 *) sceGuGetMemory(vertsize);
     if (!gpumem) {
         return SDL_SetError("Couldn't obtain a %d-byte vertex buffer!", (int) vertsize);
     }
@@ -714,23 +1088,20 @@ PSP_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *verti
             }
 
             case SDL_RENDERCMD_SETVIEWPORT: {
-                SDL_Rect *viewport = &data->drawstate.viewport;
-                if (SDL_memcmp(viewport, &cmd->data.viewport.rect, sizeof (SDL_Rect)) != 0) {
-                    SDL_memcpy(viewport, &cmd->data.viewport.rect, sizeof (SDL_Rect));
-                    data->drawstate.viewport_dirty = SDL_TRUE;
-                }
+                SDL_Rect *viewport = &cmd->data.viewport.rect;
+                sceGuOffset(2048 - (viewport->w >> 1), 2048 - (viewport->h >> 1));
+                sceGuViewport(2048, 2048, viewport->w, viewport->h);
+                sceGuScissor(viewport->x, viewport->y, viewport->w, viewport->h);
                 break;
             }
 
             case SDL_RENDERCMD_SETCLIPRECT: {
                 const SDL_Rect *rect = &cmd->data.cliprect.rect;
-                if (data->drawstate.cliprect_enabled != cmd->data.cliprect.enabled) {
-                    data->drawstate.cliprect_enabled = cmd->data.cliprect.enabled;
-                    data->drawstate.cliprect_enabled_dirty = SDL_TRUE;
-                }
-                if (SDL_memcmp(&data->drawstate.cliprect, rect, sizeof (SDL_Rect)) != 0) {
-                    SDL_memcpy(&data->drawstate.cliprect, rect, sizeof (SDL_Rect));
-                    data->drawstate.cliprect_dirty = SDL_TRUE;
+                if(cmd->data.cliprect.enabled){
+                    sceGuEnable(GU_SCISSOR_TEST);
+                    sceGuScissor(rect->x, rect->y, rect->w, rect->h);
+                } else {
+                    sceGuDisable(GU_SCISSOR_TEST);
                 }
                 break;
             }
@@ -740,11 +1111,9 @@ PSP_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *verti
                 const Uint8 g = cmd->data.color.g;
                 const Uint8 b = cmd->data.color.b;
                 const Uint8 a = cmd->data.color.a;
-                const Uint32 color = ((a << 24) | (b << 16) | (g << 8) | r);
-                /* !!! FIXME: we could cache drawstate like clear color */
-                sceGuClearColor(color);
-                sceGuClearDepth(0);
-                sceGuClear(GU_COLOR_BUFFER_BIT|GU_DEPTH_BUFFER_BIT|GU_FAST_CLEAR_BIT);
+                sceGuClearColor(GU_RGBA(r,g,b,a));
+                sceGuClearStencil(a);
+                sceGuClear(GU_COLOR_BUFFER_BIT | GU_STENCIL_BUFFER_BIT);
                 break;
             }
 
@@ -755,14 +1124,14 @@ PSP_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *verti
                 const Uint8 g = cmd->data.draw.g;
                 const Uint8 b = cmd->data.draw.b;
                 const Uint8 a = cmd->data.draw.a;
-                const Uint32 color = ((a << 24) | (b << 16) | (g << 8) | r);
-                /* !!! FIXME: we could cache draw state like color, texturing, etc */
-                sceGuColor(color);
-                sceGuDisable(GU_TEXTURE_2D);
-                sceGuShadeModel(GU_FLAT);
+                PSP_BlendState state = {
+                    .color = GU_RGBA(r,g,b,a),
+                    .texture = NULL,
+                    .mode = cmd->data.draw.blend,
+                    .shadeModel = GU_FLAT
+                };
+                PSP_SetBlendState(data, &state);
                 sceGuDrawArray(GU_POINTS, GU_VERTEX_32BITF|GU_TRANSFORM_2D, count, 0, verts);
-                sceGuShadeModel(GU_SMOOTH);
-                sceGuEnable(GU_TEXTURE_2D);
                 break;
             }
 
@@ -773,14 +1142,14 @@ PSP_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *verti
                 const Uint8 g = cmd->data.draw.g;
                 const Uint8 b = cmd->data.draw.b;
                 const Uint8 a = cmd->data.draw.a;
-                const Uint32 color = ((a << 24) | (b << 16) | (g << 8) | r);
-                /* !!! FIXME: we could cache draw state like color, texturing, etc */
-                sceGuColor(color);
-                sceGuDisable(GU_TEXTURE_2D);
-                sceGuShadeModel(GU_FLAT);
+                PSP_BlendState state = {
+                    .color = GU_RGBA(r,g,b,a),
+                    .texture = NULL,
+                    .mode = cmd->data.draw.blend,
+                    .shadeModel = GU_FLAT
+                };
+                PSP_SetBlendState(data, &state);
                 sceGuDrawArray(GU_LINE_STRIP, GU_VERTEX_32BITF|GU_TRANSFORM_2D, count, 0, verts);
-                sceGuShadeModel(GU_SMOOTH);
-                sceGuEnable(GU_TEXTURE_2D);
                 break;
             }
 
@@ -791,58 +1160,75 @@ PSP_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *verti
                 const Uint8 g = cmd->data.draw.g;
                 const Uint8 b = cmd->data.draw.b;
                 const Uint8 a = cmd->data.draw.a;
-                const Uint32 color = ((a << 24) | (b << 16) | (g << 8) | r);
-                /* !!! FIXME: we could cache draw state like color, texturing, etc */
-                sceGuColor(color);
-                sceGuDisable(GU_TEXTURE_2D);
-                sceGuShadeModel(GU_FLAT);
+                PSP_BlendState state = {
+                    .color = GU_RGBA(r,g,b,a),
+                    .texture = NULL,
+                    .mode = cmd->data.draw.blend,
+                    .shadeModel = GU_FLAT
+                };
+                PSP_SetBlendState(data, &state);
                 sceGuDrawArray(GU_SPRITES, GU_VERTEX_32BITF|GU_TRANSFORM_2D, 2 * count, 0, verts);
-                sceGuShadeModel(GU_SMOOTH);
-                sceGuEnable(GU_TEXTURE_2D);
                 break;
             }
 
             case SDL_RENDERCMD_COPY: {
                 const size_t count = cmd->data.draw.count;
                 const VertTV *verts = (VertTV *) (gpumem + cmd->data.draw.first);
-                const Uint8 alpha = cmd->data.draw.a;
-                TextureActivate(cmd->data.draw.texture);
-                PSP_SetBlendMode(renderer, cmd->data.draw.blend);
-
-                if(alpha != 255) {  /* !!! FIXME: is this right? */
-                    sceGuTexFunc(GU_TFX_MODULATE, GU_TCC_RGBA);
-                    sceGuColor(GU_RGBA(255, 255, 255, alpha));
-                } else {
-                    sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGBA);
-                    sceGuColor(0xFFFFFFFF);
-                }
-
+                const Uint8 a = cmd->data.draw.a;
+                const Uint8 r = cmd->data.draw.r;
+                const Uint8 g = cmd->data.draw.g;
+                const Uint8 b = cmd->data.draw.b;
+                PSP_BlendState state = {
+                    .color = GU_RGBA(r,g,b,a),
+                    .texture = cmd->data.draw.texture,
+                    .mode = cmd->data.draw.blend,
+                    .shadeModel = GU_SMOOTH
+                };
+                PSP_SetBlendState(data, &state);
                 sceGuDrawArray(GU_SPRITES, GU_TEXTURE_32BITF|GU_VERTEX_32BITF|GU_TRANSFORM_2D, 2 * count, 0, verts);
-
-                if(alpha != 255) {
-                    sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGBA);
-                }
                 break;
             }
 
             case SDL_RENDERCMD_COPY_EX: {
                 const VertTV *verts = (VertTV *) (gpumem + cmd->data.draw.first);
-                const Uint8 alpha = cmd->data.draw.a;
-                TextureActivate(cmd->data.draw.texture);
-                PSP_SetBlendMode(renderer, cmd->data.draw.blend);
-
-                if(alpha != 255) {  /* !!! FIXME: is this right? */
-                    sceGuTexFunc(GU_TFX_MODULATE, GU_TCC_RGBA);
-                    sceGuColor(GU_RGBA(255, 255, 255, alpha));
-                } else {
-                    sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGBA);
-                    sceGuColor(0xFFFFFFFF);
-                }
-
+                const Uint8 a = cmd->data.draw.a;
+                const Uint8 r = cmd->data.draw.r;
+                const Uint8 g = cmd->data.draw.g;
+                const Uint8 b = cmd->data.draw.b;
+                PSP_BlendState state = {
+                    .color = GU_RGBA(r,g,b,a),
+                    .texture = cmd->data.draw.texture,
+                    .mode = cmd->data.draw.blend,
+                    .shadeModel = GU_SMOOTH
+                };
+                PSP_SetBlendState(data, &state);
                 sceGuDrawArray(GU_TRIANGLE_FAN, GU_TEXTURE_32BITF|GU_VERTEX_32BITF|GU_TRANSFORM_2D, 4, 0, verts);
+                break;
+            }
 
-                if(alpha != 255) {
-                    sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGBA);
+            case SDL_RENDERCMD_GEOMETRY: {
+                const size_t count = cmd->data.draw.count;
+                if (cmd->data.draw.texture == NULL) {
+                    const VertCV *verts = (VertCV *) (gpumem + cmd->data.draw.first);
+                    sceGuDisable(GU_TEXTURE_2D);
+                    /* In GU_SMOOTH mode */
+                    sceGuDrawArray(GU_TRIANGLES, GU_COLOR_8888|GU_VERTEX_32BITF|GU_TRANSFORM_2D, count, 0, verts);
+                    sceGuEnable(GU_TEXTURE_2D);
+                } else {
+                    const VertTCV *verts = (VertTCV *) (gpumem + cmd->data.draw.first);
+                    const Uint8 a = cmd->data.draw.a;
+                    const Uint8 r = cmd->data.draw.r;
+                    const Uint8 g = cmd->data.draw.g;
+                    const Uint8 b = cmd->data.draw.b;
+                    PSP_BlendState state = {
+                        .color = GU_RGBA(r,g,b,a),
+                        .texture = NULL,
+                        .mode = cmd->data.draw.blend,
+                        .shadeModel = GU_FLAT
+                    };
+                    TextureActivate(cmd->data.draw.texture);
+                    PSP_SetBlendState(data, &state);
+                    sceGuDrawArray(GU_TRIANGLES, GU_TEXTURE_32BITF|GU_COLOR_8888|GU_VERTEX_32BITF|GU_TRANSFORM_2D, count, 0, verts);
                 }
                 break;
             }
@@ -875,8 +1261,9 @@ PSP_RenderPresent(SDL_Renderer * renderer)
     sceGuFinish();
     sceGuSync(0,0);
 
-/*  if(data->vsync) */
+    if ((data->vsync) && (data->vblank_not_reached))
         sceDisplayWaitVblankStart();
+    data->vblank_not_reached = SDL_TRUE;
 
     data->backbuffer = data->frontbuffer;
     data->frontbuffer = vabsptr(sceGuSwapBuffers());
@@ -895,7 +1282,8 @@ PSP_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
     if(psp_texture == 0)
         return;
 
-    SDL_free(psp_texture->data);
+    LRUTargetRemove(renderdata, psp_texture);
+    TextureStorageFree(psp_texture->data);
     SDL_free(psp_texture);
     texture->driverdata = NULL;
 }
@@ -910,9 +1298,13 @@ PSP_DestroyRenderer(SDL_Renderer * renderer)
 
         StartDrawing(renderer);
 
+        sceKernelDisableSubIntr(PSP_VBLANK_INT, 0);
+        sceKernelReleaseSubIntrHandler(PSP_VBLANK_INT,0);
+        sceDisplayWaitVblankStart();
+        sceGuDisplay(GU_FALSE);
         sceGuTerm();
-/*      vfree(data->backbuffer); */
-/*      vfree(data->frontbuffer); */
+        vfree(data->backbuffer);
+        vfree(data->frontbuffer);
 
         data->initialized = SDL_FALSE;
         data->displayListAvail = SDL_FALSE;
@@ -921,13 +1313,23 @@ PSP_DestroyRenderer(SDL_Renderer * renderer)
     SDL_free(renderer);
 }
 
+static int
+PSP_SetVSync(SDL_Renderer * renderer, const int vsync)
+{
+    PSP_RenderData *data = renderer->driverdata;
+    data->vsync = vsync;
+    return 0;
+}
+
 SDL_Renderer *
 PSP_CreateRenderer(SDL_Window * window, Uint32 flags)
 {
 
     SDL_Renderer *renderer;
     PSP_RenderData *data;
-        int pixelformat;
+    int pixelformat;
+    void* doublebuffer = NULL;
+
     renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
     if (!renderer) {
         SDL_OutOfMemory();
@@ -944,7 +1346,6 @@ PSP_CreateRenderer(SDL_Window * window, Uint32 flags)
 
     renderer->WindowEvent = PSP_WindowEvent;
     renderer->CreateTexture = PSP_CreateTexture;
-    renderer->SetTextureColorMod = PSP_SetTextureColorMod;
     renderer->UpdateTexture = PSP_UpdateTexture;
     renderer->LockTexture = PSP_LockTexture;
     renderer->UnlockTexture = PSP_UnlockTexture;
@@ -954,6 +1355,7 @@ PSP_CreateRenderer(SDL_Window * window, Uint32 flags)
     renderer->QueueSetDrawColor = PSP_QueueSetViewport;  /* SetViewport and SetDrawColor are (currently) no-ops. */
     renderer->QueueDrawPoints = PSP_QueueDrawPoints;
     renderer->QueueDrawLines = PSP_QueueDrawPoints;  /* lines and points queue vertices the same way. */
+    renderer->QueueGeometry = PSP_QueueGeometry;
     renderer->QueueFillRects = PSP_QueueFillRects;
     renderer->QueueCopy = PSP_QueueCopy;
     renderer->QueueCopyEx = PSP_QueueCopyEx;
@@ -962,6 +1364,7 @@ PSP_CreateRenderer(SDL_Window * window, Uint32 flags)
     renderer->RenderPresent = PSP_RenderPresent;
     renderer->DestroyTexture = PSP_DestroyTexture;
     renderer->DestroyRenderer = PSP_DestroyRenderer;
+    renderer->SetVSync = PSP_SetVSync;
     renderer->info = PSP_RenderDriver.info;
     renderer->info.flags = (SDL_RENDERER_ACCELERATED | SDL_RENDERER_TARGETTEXTURE);
     renderer->driverdata = data;
@@ -971,6 +1374,9 @@ PSP_CreateRenderer(SDL_Window * window, Uint32 flags)
         return 0;
     data->initialized = SDL_TRUE;
 
+    data->most_recent_target = NULL;
+    data->least_recent_target = NULL;
+
     if (flags & SDL_RENDERER_PRESENTVSYNC) {
         data->vsync = SDL_TRUE;
     } else {
@@ -983,56 +1389,56 @@ PSP_CreateRenderer(SDL_Window * window, Uint32 flags)
         case GU_PSM_4444:
         case GU_PSM_5650:
         case GU_PSM_5551:
-            data->frontbuffer = (unsigned int *)(PSP_FRAME_BUFFER_SIZE<<1);
-            data->backbuffer =  (unsigned int *)(0);
             data->bpp = 2;
             data->psm = pixelformat;
             break;
         default:
-            data->frontbuffer = (unsigned int *)(PSP_FRAME_BUFFER_SIZE<<2);
-            data->backbuffer =  (unsigned int *)(0);
             data->bpp = 4;
             data->psm = GU_PSM_8888;
             break;
     }
 
+    doublebuffer = valloc(PSP_FRAME_BUFFER_SIZE*data->bpp*2);
+    data->backbuffer = doublebuffer;
+    data->frontbuffer = ((uint8_t*)doublebuffer)+PSP_FRAME_BUFFER_SIZE*data->bpp;
+
     sceGuInit();
     /* setup GU */
     sceGuStart(GU_DIRECT, DisplayList);
-    sceGuDrawBuffer(data->psm, data->frontbuffer, PSP_FRAME_BUFFER_WIDTH);
-    sceGuDispBuffer(PSP_SCREEN_WIDTH, PSP_SCREEN_HEIGHT, data->backbuffer, PSP_FRAME_BUFFER_WIDTH);
+    sceGuDrawBuffer(data->psm, vrelptr(data->frontbuffer), PSP_FRAME_BUFFER_WIDTH);
+    sceGuDispBuffer(PSP_SCREEN_WIDTH, PSP_SCREEN_HEIGHT, vrelptr(data->backbuffer), PSP_FRAME_BUFFER_WIDTH);
 
 
     sceGuOffset(2048 - (PSP_SCREEN_WIDTH>>1), 2048 - (PSP_SCREEN_HEIGHT>>1));
     sceGuViewport(2048, 2048, PSP_SCREEN_WIDTH, PSP_SCREEN_HEIGHT);
 
-    data->frontbuffer = vabsptr(data->frontbuffer);
-    data->backbuffer = vabsptr(data->backbuffer);
+
+    sceGuDisable(GU_DEPTH_TEST);
 
     /* Scissoring */
     sceGuScissor(0, 0, PSP_SCREEN_WIDTH, PSP_SCREEN_HEIGHT);
     sceGuEnable(GU_SCISSOR_TEST);
 
     /* Backface culling */
+    /*
+    FIXME: Culling probably un-needed ? It can conflict with SDL_RENDERCMD_GEOMETRY
     sceGuFrontFace(GU_CCW);
     sceGuEnable(GU_CULL_FACE);
+    */
 
-    /* Texturing */
-    sceGuEnable(GU_TEXTURE_2D);
-    sceGuShadeModel(GU_SMOOTH);
-    sceGuTexWrap(GU_REPEAT, GU_REPEAT);
-
-    /* Blending */
-    sceGuEnable(GU_BLEND);
-    sceGuBlendFunc(GU_ADD, GU_SRC_ALPHA, GU_ONE_MINUS_SRC_ALPHA, 0, 0);
-
-    sceGuTexFilter(GU_LINEAR,GU_LINEAR);
+    //Setup initial blend state
+    ResetBlendState(&data->blendState);
 
     sceGuFinish();
     sceGuSync(0,0);
     sceDisplayWaitVblankStartCB();
     sceGuDisplay(GU_TRUE);
 
+    /* Improve performance when VSYC is enabled and it is not reaching the 60 FPS */
+    data->vblank_not_reached = SDL_TRUE;
+    sceKernelRegisterSubIntrHandler(PSP_VBLANK_INT, 0, psp_on_vblank, data);
+    sceKernelEnableSubIntr(PSP_VBLANK_INT, 0);
+
     return renderer;
 }
 
diff --git a/Engine/lib/sdl/src/render/software/SDL_blendfillrect.c b/Engine/lib/sdl/src/render/software/SDL_blendfillrect.c
index 9ab547681..569c15058 100644
--- a/Engine/lib/sdl/src/render/software/SDL_blendfillrect.c
+++ b/Engine/lib/sdl/src/render/software/SDL_blendfillrect.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -220,7 +220,7 @@ SDL_BlendFillRect(SDL_Surface * dst, const SDL_Rect * rect,
     SDL_Rect clipped;
 
     if (!dst) {
-        return SDL_SetError("Passed NULL destination surface");
+        return SDL_InvalidParamError("SDL_BlendFillRect(): dst");
     }
 
     /* This function doesn't work on surfaces < 8 bpp */
@@ -291,7 +291,7 @@ SDL_BlendFillRects(SDL_Surface * dst, const SDL_Rect * rects, int count,
     int status = 0;
 
     if (!dst) {
-        return SDL_SetError("Passed NULL destination surface");
+        return SDL_InvalidParamError("SDL_BlendFillRects(): dst");
     }
 
     /* This function doesn't work on surfaces < 8 bpp */
diff --git a/Engine/lib/sdl/src/render/software/SDL_blendfillrect.h b/Engine/lib/sdl/src/render/software/SDL_blendfillrect.h
index f120e130c..8ee62b198 100644
--- a/Engine/lib/sdl/src/render/software/SDL_blendfillrect.h
+++ b/Engine/lib/sdl/src/render/software/SDL_blendfillrect.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/render/software/SDL_blendline.c b/Engine/lib/sdl/src/render/software/SDL_blendline.c
index 38b2d04bf..4921bf101 100644
--- a/Engine/lib/sdl/src/render/software/SDL_blendline.c
+++ b/Engine/lib/sdl/src/render/software/SDL_blendline.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -809,7 +809,7 @@ SDL_BlendLine(SDL_Surface * dst, int x1, int y1, int x2, int y2,
     BlendLineFunc func;
 
     if (!dst) {
-        return SDL_SetError("SDL_BlendLine(): Passed NULL destination surface");
+        return SDL_InvalidParamError("SDL_BlendLine(): dst");
     }
 
     func = SDL_CalculateBlendLineFunc(dst->format);
diff --git a/Engine/lib/sdl/src/render/software/SDL_blendline.h b/Engine/lib/sdl/src/render/software/SDL_blendline.h
index 4e313135e..a844110c4 100644
--- a/Engine/lib/sdl/src/render/software/SDL_blendline.h
+++ b/Engine/lib/sdl/src/render/software/SDL_blendline.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/render/software/SDL_blendpoint.c b/Engine/lib/sdl/src/render/software/SDL_blendpoint.c
index b6a406e51..613169b7b 100644
--- a/Engine/lib/sdl/src/render/software/SDL_blendpoint.c
+++ b/Engine/lib/sdl/src/render/software/SDL_blendpoint.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -218,7 +218,7 @@ SDL_BlendPoint(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r
                Uint8 g, Uint8 b, Uint8 a)
 {
     if (!dst) {
-        return SDL_SetError("Passed NULL destination surface");
+        return SDL_InvalidParamError("SDL_BlendPoint(): dst");
     }
 
     /* This function doesn't work on surfaces < 8 bpp */
@@ -287,7 +287,7 @@ SDL_BlendPoints(SDL_Surface * dst, const SDL_Point * points, int count,
     int status = 0;
 
     if (!dst) {
-        return SDL_SetError("Passed NULL destination surface");
+        return SDL_InvalidParamError("SDL_BlendPoints(): dst");
     }
 
     /* This function doesn't work on surfaces < 8 bpp */
diff --git a/Engine/lib/sdl/src/render/software/SDL_blendpoint.h b/Engine/lib/sdl/src/render/software/SDL_blendpoint.h
index 9ac836577..bf6ddec07 100644
--- a/Engine/lib/sdl/src/render/software/SDL_blendpoint.h
+++ b/Engine/lib/sdl/src/render/software/SDL_blendpoint.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/render/software/SDL_draw.h b/Engine/lib/sdl/src/render/software/SDL_draw.h
index 0d66f2dc4..2acb3d3a1 100644
--- a/Engine/lib/sdl/src/render/software/SDL_draw.h
+++ b/Engine/lib/sdl/src/render/software/SDL_draw.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -618,10 +618,10 @@ do { \
     while (height--) { \
         { int n = (width+3)/4; \
             switch (width & 3) { \
-            case 0: do {   op; pixel++; /* fallthrough */ \
-            case 3:        op; pixel++; /* fallthrough */ \
-            case 2:        op; pixel++; /* fallthrough */ \
-            case 1:        op; pixel++; /* fallthrough */ \
+            case 0: do {   op; pixel++; SDL_FALLTHROUGH; \
+            case 3:        op; pixel++; SDL_FALLTHROUGH; \
+            case 2:        op; pixel++; SDL_FALLTHROUGH; \
+            case 1:        op; pixel++; \
                     } while ( --n > 0 ); \
             } \
         } \
diff --git a/Engine/lib/sdl/src/render/software/SDL_drawline.c b/Engine/lib/sdl/src/render/software/SDL_drawline.c
index 0faeb4fc1..e309f1619 100644
--- a/Engine/lib/sdl/src/render/software/SDL_drawline.c
+++ b/Engine/lib/sdl/src/render/software/SDL_drawline.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -144,7 +144,7 @@ SDL_DrawLine(SDL_Surface * dst, int x1, int y1, int x2, int y2, Uint32 color)
     DrawLineFunc func;
 
     if (!dst) {
-        return SDL_SetError("SDL_DrawLine(): Passed NULL destination surface");
+        return SDL_InvalidParamError("SDL_DrawLine(): dst");
     }
 
     func = SDL_CalculateDrawLineFunc(dst->format);
@@ -173,7 +173,7 @@ SDL_DrawLines(SDL_Surface * dst, const SDL_Point * points, int count,
     DrawLineFunc func;
 
     if (!dst) {
-        return SDL_SetError("SDL_DrawLines(): Passed NULL destination surface");
+        return SDL_InvalidParamError("SDL_DrawLines(): dst");
     }
 
     func = SDL_CalculateDrawLineFunc(dst->format);
@@ -193,8 +193,8 @@ SDL_DrawLines(SDL_Surface * dst, const SDL_Point * points, int count,
             continue;
         }
 
-        /* Draw the end if it was clipped */
-        draw_end = (x2 != points[i].x || y2 != points[i].y);
+        /* Draw the end if the whole line is a single point or it was clipped */
+        draw_end = ((x1 == x2) && (y1 == y2)) || (x2 != points[i].x || y2 != points[i].y);
 
         func(dst, x1, y1, x2, y2, color, draw_end);
     }
diff --git a/Engine/lib/sdl/src/render/software/SDL_drawline.h b/Engine/lib/sdl/src/render/software/SDL_drawline.h
index ca464345f..186119e8e 100644
--- a/Engine/lib/sdl/src/render/software/SDL_drawline.h
+++ b/Engine/lib/sdl/src/render/software/SDL_drawline.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/render/software/SDL_drawpoint.c b/Engine/lib/sdl/src/render/software/SDL_drawpoint.c
index 0e78744b9..b99838ac6 100644
--- a/Engine/lib/sdl/src/render/software/SDL_drawpoint.c
+++ b/Engine/lib/sdl/src/render/software/SDL_drawpoint.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -30,7 +30,7 @@ int
 SDL_DrawPoint(SDL_Surface * dst, int x, int y, Uint32 color)
 {
     if (!dst) {
-        return SDL_SetError("Passed NULL destination surface");
+        return SDL_InvalidParamError("SDL_DrawPoint(): dst");
     }
 
     /* This function doesn't work on surfaces < 8 bpp */
@@ -71,7 +71,7 @@ SDL_DrawPoints(SDL_Surface * dst, const SDL_Point * points, int count,
     int x, y;
 
     if (!dst) {
-        return SDL_SetError("Passed NULL destination surface");
+        return SDL_InvalidParamError("SDL_DrawPoints(): dst");
     }
 
     /* This function doesn't work on surfaces < 8 bpp */
diff --git a/Engine/lib/sdl/src/render/software/SDL_drawpoint.h b/Engine/lib/sdl/src/render/software/SDL_drawpoint.h
index 33e014fd7..4c019e014 100644
--- a/Engine/lib/sdl/src/render/software/SDL_drawpoint.h
+++ b/Engine/lib/sdl/src/render/software/SDL_drawpoint.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/render/software/SDL_render_sw.c b/Engine/lib/sdl/src/render/software/SDL_render_sw.c
index 18dc1808c..a1af12cd6 100644
--- a/Engine/lib/sdl/src/render/software/SDL_render_sw.c
+++ b/Engine/lib/sdl/src/render/software/SDL_render_sw.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -33,6 +33,7 @@
 #include "SDL_drawline.h"
 #include "SDL_drawpoint.h"
 #include "SDL_rotate.h"
+#include "SDL_triangle.h"
 
 /* SDL surface based renderer implementation */
 
@@ -98,8 +99,7 @@ SW_GetOutputSize(SDL_Renderer * renderer, int *w, int *h)
         return 0;
     }
 
-    SDL_SetError("Software renderer doesn't have an output surface");
-    return -1;
+    return SDL_SetError("Software renderer doesn't have an output surface");
 }
 
 static int
@@ -116,9 +116,8 @@ SW_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
     texture->driverdata =
         SDL_CreateRGBSurface(0, texture->w, texture->h, bpp, Rmask, Gmask,
                              Bmask, Amask);
-    SDL_SetSurfaceColorMod(texture->driverdata, texture->r, texture->g,
-                           texture->b);
-    SDL_SetSurfaceAlphaMod(texture->driverdata, texture->a);
+    SDL_SetSurfaceColorMod(texture->driverdata, texture->color.r, texture->color.g, texture->color.b);
+    SDL_SetSurfaceAlphaMod(texture->driverdata, texture->color.a);
     SDL_SetSurfaceBlendMode(texture->driverdata, texture->blendMode);
 
     /* Only RLE encode textures without an alpha channel since the RLE coder
@@ -214,18 +213,9 @@ SW_QueueDrawPoints(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FP
 
     cmd->data.draw.count = count;
 
-    if (renderer->viewport.x || renderer->viewport.y) {
-        const int x = renderer->viewport.x;
-        const int y = renderer->viewport.y;
-        for (i = 0; i < count; i++, verts++, points++) {
-            verts->x = (int)(x + points->x);
-            verts->y = (int)(y + points->y);
-        }
-    } else {
-        for (i = 0; i < count; i++, verts++, points++) {
-            verts->x = (int)points->x;
-            verts->y = (int)points->y;
-        }
+    for (i = 0; i < count; i++, verts++, points++) {
+        verts->x = (int)points->x;
+        verts->y = (int)points->y;
     }
 
     return 0;
@@ -243,23 +233,11 @@ SW_QueueFillRects(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FRe
 
     cmd->data.draw.count = count;
 
-    if (renderer->viewport.x || renderer->viewport.y) {
-        const int x = renderer->viewport.x;
-        const int y = renderer->viewport.y;
-
-        for (i = 0; i < count; i++, verts++, rects++) {
-            verts->x = (int)(x + rects->x);
-            verts->y = (int)(y + rects->y);
-            verts->w = SDL_max((int)rects->w, 1);
-            verts->h = SDL_max((int)rects->h, 1);
-        }
-    } else {
-        for (i = 0; i < count; i++, verts++, rects++) {
-            verts->x = (int)rects->x;
-            verts->y = (int)rects->y;
-            verts->w = SDL_max((int)rects->w, 1);
-            verts->h = SDL_max((int)rects->h, 1);
-        }
+    for (i = 0; i < count; i++, verts++, rects++) {
+        verts->x = (int)rects->x;
+        verts->y = (int)rects->y;
+        verts->w = SDL_max((int)rects->w, 1);
+        verts->h = SDL_max((int)rects->h, 1);
     }
 
     return 0;
@@ -280,13 +258,8 @@ SW_QueueCopy(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * text
     SDL_memcpy(verts, srcrect, sizeof (SDL_Rect));
     verts++;
 
-    if (renderer->viewport.x || renderer->viewport.y) {
-        verts->x = (int)(renderer->viewport.x + dstrect->x);
-        verts->y = (int)(renderer->viewport.y + dstrect->y);
-    } else {
-        verts->x = (int)dstrect->x;
-        verts->y = (int)dstrect->y;
-    }
+    verts->x = (int)dstrect->x;
+    verts->y = (int)dstrect->y;
     verts->w = (int)dstrect->w;
     verts->h = (int)dstrect->h;
 
@@ -300,12 +273,14 @@ typedef struct CopyExData
     double angle;
     SDL_FPoint center;
     SDL_RendererFlip flip;
+    float scale_x;
+    float scale_y;
 } CopyExData;
 
 static int
 SW_QueueCopyEx(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture,
                const SDL_Rect * srcrect, const SDL_FRect * dstrect,
-               const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip)
+               const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip, float scale_x, float scale_y)
 {
     CopyExData *verts = (CopyExData *) SDL_AllocateRenderVertices(renderer, sizeof (CopyExData), 0, &cmd->data.draw.first);
 
@@ -317,33 +292,48 @@ SW_QueueCopyEx(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * te
 
     SDL_memcpy(&verts->srcrect, srcrect, sizeof (SDL_Rect));
 
-    if (renderer->viewport.x || renderer->viewport.y) {
-        verts->dstrect.x = (int)(renderer->viewport.x + dstrect->x);
-        verts->dstrect.y = (int)(renderer->viewport.y + dstrect->y);
-    } else {
-        verts->dstrect.x = (int)dstrect->x;
-        verts->dstrect.y = (int)dstrect->y;
-    }
+    verts->dstrect.x = (int)dstrect->x;
+    verts->dstrect.y = (int)dstrect->y;
     verts->dstrect.w = (int)dstrect->w;
     verts->dstrect.h = (int)dstrect->h;
     verts->angle = angle;
     SDL_memcpy(&verts->center, center, sizeof (SDL_FPoint));
     verts->flip = flip;
+    verts->scale_x = scale_x;
+    verts->scale_y = scale_y;
 
     return 0;
 }
 
+static int
+Blit_to_Screen(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *surface, SDL_Rect *dstrect,
+        float scale_x, float scale_y, SDL_ScaleMode scaleMode)
+{
+    int retval;
+    /* Renderer scaling, if needed */
+    if (scale_x != 1.0f || scale_y != 1.0f) {
+        SDL_Rect r;
+        r.x = (int)((float) dstrect->x * scale_x);
+        r.y = (int)((float) dstrect->y * scale_y);
+        r.w = (int)((float) dstrect->w * scale_x);
+        r.h = (int)((float) dstrect->h * scale_y);
+        retval = SDL_PrivateUpperBlitScaled(src, srcrect, surface, &r, scaleMode);
+    } else {
+        retval = SDL_BlitSurface(src, srcrect, surface, dstrect);
+    }
+    return retval;
+}
+
 static int
 SW_RenderCopyEx(SDL_Renderer * renderer, SDL_Surface *surface, SDL_Texture * texture,
                 const SDL_Rect * srcrect, const SDL_Rect * final_rect,
-                const double angle, const SDL_FPoint * center, const SDL_RendererFlip flip)
+                const double angle, const SDL_FPoint * center, const SDL_RendererFlip flip, float scale_x, float scale_y)
 {
     SDL_Surface *src = (SDL_Surface *) texture->driverdata;
     SDL_Rect tmp_rect;
     SDL_Surface *src_clone, *src_rotated, *src_scaled;
     SDL_Surface *mask = NULL, *mask_rotated = NULL;
-    int retval = 0, dstwidth, dstheight, abscenterx, abscentery;
-    double cangle, sangle, px, py, p1x, p1y, p2x, p2y, p3x, p3y, p4x, p4y;
+    int retval = 0;
     SDL_BlendMode blendmode;
     Uint8 alphaMod, rMod, gMod, bMod;
     int applyModulation = SDL_FALSE;
@@ -434,7 +424,7 @@ SW_RenderCopyEx(SDL_Renderer * renderer, SDL_Surface *surface, SDL_Texture * tex
             retval = -1;
         } else {
             SDL_SetSurfaceBlendMode(src_clone, SDL_BLENDMODE_NONE);
-            retval = SDL_BlitScaled(src_clone, srcrect, src_scaled, &scale_rect);
+            retval = SDL_PrivateUpperBlitScaled(src_clone, srcrect, src_scaled, &scale_rect, texture->scaleMode);
             SDL_FreeSurface(src_clone);
             src_clone = src_scaled;
             src_scaled = NULL;
@@ -445,53 +435,32 @@ SW_RenderCopyEx(SDL_Renderer * renderer, SDL_Surface *surface, SDL_Texture * tex
     SDL_SetSurfaceBlendMode(src_clone, blendmode);
 
     if (!retval) {
-        SDLgfx_rotozoomSurfaceSizeTrig(tmp_rect.w, tmp_rect.h, angle, &dstwidth, &dstheight, &cangle, &sangle);
-        src_rotated = SDLgfx_rotateSurface(src_clone, angle, dstwidth/2, dstheight/2, (texture->scaleMode == SDL_ScaleModeNearest) ? 0 : 1, flip & SDL_FLIP_HORIZONTAL, flip & SDL_FLIP_VERTICAL, dstwidth, dstheight, cangle, sangle);
+        SDL_Rect rect_dest;
+        double cangle, sangle;
+
+        SDLgfx_rotozoomSurfaceSizeTrig(tmp_rect.w, tmp_rect.h, angle, center,
+                &rect_dest, &cangle, &sangle);
+        src_rotated = SDLgfx_rotateSurface(src_clone, angle,
+                (texture->scaleMode == SDL_ScaleModeNearest) ? 0 : 1, flip & SDL_FLIP_HORIZONTAL, flip & SDL_FLIP_VERTICAL,
+                &rect_dest, cangle, sangle, center);
         if (src_rotated == NULL) {
             retval = -1;
         }
         if (!retval && mask != NULL) {
             /* The mask needed for the NONE blend mode gets rotated with the same parameters. */
-            mask_rotated = SDLgfx_rotateSurface(mask, angle, dstwidth/2, dstheight/2, SDL_FALSE, 0, 0, dstwidth, dstheight, cangle, sangle);
+            mask_rotated = SDLgfx_rotateSurface(mask, angle,
+                    SDL_FALSE, 0, 0,
+                    &rect_dest, cangle, sangle, center);
             if (mask_rotated == NULL) {
                 retval = -1;
             }
         }
         if (!retval) {
-            /* Find out where the new origin is by rotating the four final_rect points around the center and then taking the extremes */
-            abscenterx = final_rect->x + (int)center->x;
-            abscentery = final_rect->y + (int)center->y;
-            /* Compensate the angle inversion to match the behaviour of the other backends */
-            sangle = -sangle;
 
-            /* Top Left */
-            px = final_rect->x - abscenterx;
-            py = final_rect->y - abscentery;
-            p1x = px * cangle - py * sangle + abscenterx;
-            p1y = px * sangle + py * cangle + abscentery;
-
-            /* Top Right */
-            px = final_rect->x + final_rect->w - abscenterx;
-            py = final_rect->y - abscentery;
-            p2x = px * cangle - py * sangle + abscenterx;
-            p2y = px * sangle + py * cangle + abscentery;
-
-            /* Bottom Left */
-            px = final_rect->x - abscenterx;
-            py = final_rect->y + final_rect->h - abscentery;
-            p3x = px * cangle - py * sangle + abscenterx;
-            p3y = px * sangle + py * cangle + abscentery;
-
-            /* Bottom Right */
-            px = final_rect->x + final_rect->w - abscenterx;
-            py = final_rect->y + final_rect->h - abscentery;
-            p4x = px * cangle - py * sangle + abscenterx;
-            p4y = px * sangle + py * cangle + abscentery;
-
-            tmp_rect.x = (int)MIN(MIN(p1x, p2x), MIN(p3x, p4x));
-            tmp_rect.y = (int)MIN(MIN(p1y, p2y), MIN(p3y, p4y));
-            tmp_rect.w = dstwidth;
-            tmp_rect.h = dstheight;
+            tmp_rect.x = final_rect->x + rect_dest.x;
+            tmp_rect.y = final_rect->y + rect_dest.y;
+            tmp_rect.w = rect_dest.w;
+            tmp_rect.h = rect_dest.h;
 
             /* The NONE blend mode needs some special care with non-opaque surfaces.
              * Other blend modes or opaque surfaces can be blitted directly.
@@ -502,7 +471,8 @@ SW_RenderCopyEx(SDL_Renderer * renderer, SDL_Surface *surface, SDL_Texture * tex
                     SDL_SetSurfaceAlphaMod(src_rotated, alphaMod);
                     SDL_SetSurfaceColorMod(src_rotated, rMod, gMod, bMod);
                 }
-                retval = SDL_BlitSurface(src_rotated, NULL, surface, &tmp_rect);
+                /* Renderer scaling, if needed */
+                retval = Blit_to_Screen(src_rotated, NULL, surface, &tmp_rect, scale_x, scale_y, texture->scaleMode);
             } else {
                 /* The NONE blend mode requires three steps to get the pixels onto the destination surface.
                  * First, the area where the rotated pixels will be blitted to get set to zero.
@@ -511,7 +481,8 @@ SW_RenderCopyEx(SDL_Renderer * renderer, SDL_Surface *surface, SDL_Texture * tex
                  */
                 SDL_Rect mask_rect = tmp_rect;
                 SDL_SetSurfaceBlendMode(mask_rotated, SDL_BLENDMODE_NONE);
-                retval = SDL_BlitSurface(mask_rotated, NULL, surface, &mask_rect);
+                /* Renderer scaling, if needed */
+                retval = Blit_to_Screen(mask_rotated, NULL, surface, &mask_rect, scale_x, scale_y, texture->scaleMode);
                 if (!retval) {
                     /* The next step copies the alpha value. This is done with the BLEND blend mode and
                      * by modulating the source colors with 0. Since the destination is all zeros, this
@@ -519,7 +490,8 @@ SW_RenderCopyEx(SDL_Renderer * renderer, SDL_Surface *surface, SDL_Texture * tex
                      */
                     SDL_SetSurfaceColorMod(src_rotated, 0, 0, 0);
                     mask_rect = tmp_rect;
-                    retval = SDL_BlitSurface(src_rotated, NULL, surface, &mask_rect);
+                    /* Renderer scaling, if needed */
+                    retval = Blit_to_Screen(src_rotated, NULL, surface, &mask_rect, scale_x, scale_y, texture->scaleMode);
                     if (!retval) {
                         /* The last step gets the color values in place. The ADD blend mode simply adds them to
                          * the destination (where the color values are all zero). However, because the ADD blend
@@ -535,7 +507,8 @@ SW_RenderCopyEx(SDL_Renderer * renderer, SDL_Surface *surface, SDL_Texture * tex
                             retval = -1;
                         } else {
                             SDL_SetSurfaceBlendMode(src_rotated_rgb, SDL_BLENDMODE_ADD);
-                            retval = SDL_BlitSurface(src_rotated_rgb, NULL, surface, &tmp_rect);
+                            /* Renderer scaling, if needed */
+                            retval = Blit_to_Screen(src_rotated_rgb, NULL, surface, &tmp_rect, scale_x, scale_y, texture->scaleMode);
                             SDL_FreeSurface(src_rotated_rgb);
                         }
                     }
@@ -560,6 +533,104 @@ SW_RenderCopyEx(SDL_Renderer * renderer, SDL_Surface *surface, SDL_Texture * tex
     return retval;
 }
 
+
+typedef struct GeometryFillData
+{
+    SDL_Point dst;
+    SDL_Color color;
+} GeometryFillData;
+
+typedef struct GeometryCopyData
+{
+    SDL_Point src;
+    SDL_Point dst;
+    SDL_Color color;
+} GeometryCopyData;
+
+static int
+SW_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+        const float *xy, int xy_stride, const SDL_Color *color, int color_stride, const float *uv, int uv_stride,
+        int num_vertices, const void *indices, int num_indices, int size_indices,
+        float scale_x, float scale_y)
+{
+    int i;
+    int count = indices ? num_indices : num_vertices;
+    void *verts;
+    int sz = texture ? sizeof (GeometryCopyData) : sizeof (GeometryFillData);
+
+    verts = (void *) SDL_AllocateRenderVertices(renderer, count * sz, 0, &cmd->data.draw.first);
+    if (!verts) {
+        return -1;
+    }
+
+    cmd->data.draw.count = count;
+    size_indices = indices ? size_indices : 0;
+
+    if (texture) {
+        GeometryCopyData *ptr = (GeometryCopyData *) verts;
+        for (i = 0; i < count; i++) {
+            int j;
+            float *xy_;
+            SDL_Color col_;
+            float *uv_;
+            if (size_indices == 4) {
+                j = ((const Uint32 *)indices)[i];
+            } else if (size_indices == 2) {
+                j = ((const Uint16 *)indices)[i];
+            } else if (size_indices == 1) {
+                j = ((const Uint8 *)indices)[i];
+            } else {
+                j = i;
+            }
+
+            xy_ = (float *)((char*)xy + j * xy_stride);
+            col_ = *(SDL_Color *)((char*)color + j * color_stride);
+
+            uv_ = (float *)((char*)uv + j * uv_stride);
+
+            ptr->src.x = (int)(uv_[0] * texture->w);
+            ptr->src.y = (int)(uv_[1] * texture->h);
+
+            ptr->dst.x = (int)(xy_[0] * scale_x);
+            ptr->dst.y = (int)(xy_[1] * scale_y);
+            trianglepoint_2_fixedpoint(&ptr->dst);
+
+            ptr->color = col_;
+
+            ptr++;
+       }
+    } else {
+        GeometryFillData *ptr = (GeometryFillData *) verts;
+
+        for (i = 0; i < count; i++) {
+            int j;
+            float *xy_;
+            SDL_Color col_;
+            if (size_indices == 4) {
+                j = ((const Uint32 *)indices)[i];
+            } else if (size_indices == 2) {
+                j = ((const Uint16 *)indices)[i];
+            } else if (size_indices == 1) {
+                j = ((const Uint8 *)indices)[i];
+            } else {
+                j = i;
+            }
+
+            xy_ = (float *)((char*)xy + j * xy_stride);
+            col_ = *(SDL_Color *)((char*)color + j * color_stride);
+
+            ptr->dst.x = (int)(xy_[0] * scale_x);
+            ptr->dst.y = (int)(xy_[1] * scale_y);
+            trianglepoint_2_fixedpoint(&ptr->dst);
+
+            ptr->color = col_;
+
+            ptr++;
+       }
+    }
+    return 0;
+}
+
 static void
 PrepTextureForCopy(const SDL_RenderCommand *cmd)
 {
@@ -634,7 +705,7 @@ SW_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertic
             }
 
             case SDL_RENDERCMD_SETCLIPRECT: {
-                drawstate.cliprect = cmd->data.cliprect.enabled ? &cmd->data.cliprect.rect : NULL;                
+                drawstate.cliprect = cmd->data.cliprect.enabled ? &cmd->data.cliprect.rect : NULL;
                 drawstate.surface_cliprect_dirty = SDL_TRUE;
                 break;
             }
@@ -657,9 +728,19 @@ SW_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertic
                 const Uint8 b = cmd->data.draw.b;
                 const Uint8 a = cmd->data.draw.a;
                 const int count = (int) cmd->data.draw.count;
-                const SDL_Point *verts = (SDL_Point *) (((Uint8 *) vertices) + cmd->data.draw.first);
+                SDL_Point *verts = (SDL_Point *) (((Uint8 *) vertices) + cmd->data.draw.first);
                 const SDL_BlendMode blend = cmd->data.draw.blend;
                 SetDrawState(surface, &drawstate);
+
+                /* Apply viewport */
+                if (drawstate.viewport->x || drawstate.viewport->y) {
+                    int i;
+                    for (i = 0; i < count; i++) {
+                        verts[i].x += drawstate.viewport->x;
+                        verts[i].y += drawstate.viewport->y;
+                    }
+                }
+
                 if (blend == SDL_BLENDMODE_NONE) {
                     SDL_DrawPoints(surface, verts, count, SDL_MapRGBA(surface->format, r, g, b, a));
                 } else {
@@ -674,9 +755,19 @@ SW_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertic
                 const Uint8 b = cmd->data.draw.b;
                 const Uint8 a = cmd->data.draw.a;
                 const int count = (int) cmd->data.draw.count;
-                const SDL_Point *verts = (SDL_Point *) (((Uint8 *) vertices) + cmd->data.draw.first);
+                SDL_Point *verts = (SDL_Point *) (((Uint8 *) vertices) + cmd->data.draw.first);
                 const SDL_BlendMode blend = cmd->data.draw.blend;
                 SetDrawState(surface, &drawstate);
+
+                /* Apply viewport */
+                if (drawstate.viewport->x || drawstate.viewport->y) {
+                    int i;
+                    for (i = 0; i < count; i++) {
+                        verts[i].x += drawstate.viewport->x;
+                        verts[i].y += drawstate.viewport->y;
+                    }
+                }
+
                 if (blend == SDL_BLENDMODE_NONE) {
                     SDL_DrawLines(surface, verts, count, SDL_MapRGBA(surface->format, r, g, b, a));
                 } else {
@@ -691,9 +782,19 @@ SW_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertic
                 const Uint8 b = cmd->data.draw.b;
                 const Uint8 a = cmd->data.draw.a;
                 const int count = (int) cmd->data.draw.count;
-                const SDL_Rect *verts = (SDL_Rect *) (((Uint8 *) vertices) + cmd->data.draw.first);
+                SDL_Rect *verts = (SDL_Rect *) (((Uint8 *) vertices) + cmd->data.draw.first);
                 const SDL_BlendMode blend = cmd->data.draw.blend;
                 SetDrawState(surface, &drawstate);
+
+                /* Apply viewport */
+                if (drawstate.viewport->x || drawstate.viewport->y) {
+                    int i;
+                    for (i = 0; i < count; i++) {
+                        verts[i].x += drawstate.viewport->x;
+                        verts[i].y += drawstate.viewport->y;
+                    }
+                }
+
                 if (blend == SDL_BLENDMODE_NONE) {
                     SDL_FillRects(surface, verts, count, SDL_MapRGBA(surface->format, r, g, b, a));
                 } else {
@@ -713,6 +814,12 @@ SW_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertic
 
                 PrepTextureForCopy(cmd);
 
+                /* Apply viewport */
+                if (drawstate.viewport->x || drawstate.viewport->y) {
+                    dstrect->x += drawstate.viewport->x;
+                    dstrect->y += drawstate.viewport->y;
+                }
+
                 if ( srcrect->w == dstrect->w && srcrect->h == dstrect->h ) {
                     SDL_BlitSurface(src, srcrect, surface, dstrect);
                 } else {
@@ -720,17 +827,118 @@ SW_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertic
                      * to avoid potentially frequent RLE encoding/decoding.
                      */
                     SDL_SetSurfaceRLE(surface, 0);
-                    SDL_BlitScaled(src, srcrect, surface, dstrect);
+
+                    /* Prevent to do scaling + clipping on viewport boundaries as it may lose proportion */
+                    if (dstrect->x < 0 || dstrect->y < 0 || dstrect->x + dstrect->w > surface->w || dstrect->y + dstrect->h > surface->h) {
+                        SDL_Surface *tmp = SDL_CreateRGBSurfaceWithFormat(0, dstrect->w, dstrect->h, 0, src->format->format);
+                        /* Scale to an intermediate surface, then blit */
+                        if (tmp) {
+                            SDL_Rect r;
+                            SDL_BlendMode blendmode;
+                            Uint8 alphaMod, rMod, gMod, bMod;
+
+                            SDL_GetSurfaceBlendMode(src, &blendmode);
+                            SDL_GetSurfaceAlphaMod(src, &alphaMod);
+                            SDL_GetSurfaceColorMod(src, &rMod, &gMod, &bMod);
+
+                            r.x = 0;
+                            r.y = 0;
+                            r.w = dstrect->w;
+                            r.h = dstrect->h;
+
+                            SDL_SetSurfaceBlendMode(src, SDL_BLENDMODE_NONE);
+                            SDL_SetSurfaceColorMod(src, 255, 255, 255);
+                            SDL_SetSurfaceAlphaMod(src, 255);
+
+                            SDL_PrivateUpperBlitScaled(src, srcrect, tmp, &r, texture->scaleMode);
+
+                            SDL_SetSurfaceColorMod(tmp, rMod, gMod, bMod);
+                            SDL_SetSurfaceAlphaMod(tmp, alphaMod);
+                            SDL_SetSurfaceBlendMode(tmp, blendmode);
+
+                            SDL_BlitSurface(tmp, NULL, surface, dstrect);
+                            SDL_FreeSurface(tmp);
+                            /* No need to set back r/g/b/a/blendmode to 'src' since it's done in PrepTextureForCopy() */
+                        }
+                    } else{
+                        SDL_PrivateUpperBlitScaled(src, srcrect, surface, dstrect, texture->scaleMode);
+                    }
                 }
                 break;
             }
 
             case SDL_RENDERCMD_COPY_EX: {
-                const CopyExData *copydata = (CopyExData *) (((Uint8 *) vertices) + cmd->data.draw.first);
+                CopyExData *copydata = (CopyExData *) (((Uint8 *) vertices) + cmd->data.draw.first);
                 SetDrawState(surface, &drawstate);
                 PrepTextureForCopy(cmd);
+
+                /* Apply viewport */
+                if (drawstate.viewport->x || drawstate.viewport->y) {
+                    copydata->dstrect.x += drawstate.viewport->x;
+                    copydata->dstrect.y += drawstate.viewport->y;
+                }
+
                 SW_RenderCopyEx(renderer, surface, cmd->data.draw.texture, &copydata->srcrect,
-                                &copydata->dstrect, copydata->angle, &copydata->center, copydata->flip);
+                                &copydata->dstrect, copydata->angle, &copydata->center, copydata->flip,
+                                copydata->scale_x, copydata->scale_y);
+                break;
+            }
+
+            case SDL_RENDERCMD_GEOMETRY: {
+                int i;
+                SDL_Rect *verts = (SDL_Rect *) (((Uint8 *) vertices) + cmd->data.draw.first);
+                const int count = (int) cmd->data.draw.count;
+                SDL_Texture *texture = cmd->data.draw.texture;
+                const SDL_BlendMode blend = cmd->data.draw.blend;
+
+                SetDrawState(surface, &drawstate);
+
+                if (texture) {
+                    SDL_Surface *src = (SDL_Surface *) texture->driverdata;
+
+                    GeometryCopyData *ptr = (GeometryCopyData *) verts;
+
+                    PrepTextureForCopy(cmd);
+
+                    /* Apply viewport */
+                    if (drawstate.viewport->x || drawstate.viewport->y) {
+                        SDL_Point vp;
+                        vp.x = drawstate.viewport->x;
+                        vp.y = drawstate.viewport->y;
+                        trianglepoint_2_fixedpoint(&vp);
+                        for (i = 0; i < count; i++) {
+                            ptr[i].dst.x += vp.x;
+                            ptr[i].dst.y += vp.y;
+                        }
+                    }
+
+                    for (i = 0; i < count; i += 3, ptr += 3) {
+                        SDL_SW_BlitTriangle(
+                                src,
+                                &(ptr[0].src), &(ptr[1].src), &(ptr[2].src),
+                                surface,
+                                &(ptr[0].dst), &(ptr[1].dst), &(ptr[2].dst),
+                                ptr[0].color, ptr[1].color, ptr[2].color);
+                    }
+                } else {
+                    GeometryFillData *ptr = (GeometryFillData *) verts;
+
+                    /* Apply viewport */
+                    if (drawstate.viewport->x || drawstate.viewport->y) {
+                        SDL_Point vp;
+                        vp.x = drawstate.viewport->x;
+                        vp.y = drawstate.viewport->y;
+                        trianglepoint_2_fixedpoint(&vp);
+                        for (i = 0; i < count; i++) {
+                            ptr[i].dst.x += vp.x;
+                            ptr[i].dst.y += vp.y;
+                        }
+                    }
+
+                    for (i = 0; i < count; i += 3, ptr += 3) {
+                        SDL_SW_FillTriangle(surface, &(ptr[0].dst), &(ptr[1].dst), &(ptr[2].dst), blend, ptr[0].color, ptr[1].color, ptr[2].color);
+                    }
+                }
                 break;
             }
 
@@ -809,7 +1017,7 @@ SW_CreateRendererForSurface(SDL_Surface * surface)
     SW_RenderData *data;
 
     if (!surface) {
-        SDL_SetError("Can't create renderer for NULL surface");
+        SDL_InvalidParamError("surface");
         return NULL;
     }
 
@@ -843,6 +1051,7 @@ SW_CreateRendererForSurface(SDL_Surface * surface)
     renderer->QueueFillRects = SW_QueueFillRects;
     renderer->QueueCopy = SW_QueueCopy;
     renderer->QueueCopyEx = SW_QueueCopyEx;
+    renderer->QueueGeometry = SW_QueueGeometry;
     renderer->RunCommandQueue = SW_RunCommandQueue;
     renderer->RenderReadPixels = SW_RenderReadPixels;
     renderer->RenderPresent = SW_RenderPresent;
@@ -859,9 +1068,29 @@ SW_CreateRendererForSurface(SDL_Surface * surface)
 static SDL_Renderer *
 SW_CreateRenderer(SDL_Window * window, Uint32 flags)
 {
+    const char *hint;
     SDL_Surface *surface;
+    SDL_bool no_hint_set;
+
+    /* Set the vsync hint based on our flags, if it's not already set */
+    hint = SDL_GetHint(SDL_HINT_RENDER_VSYNC);
+    if (!hint || !*hint) {
+        no_hint_set = SDL_TRUE;
+    } else {
+        no_hint_set = SDL_FALSE;
+    }
+
+    if (no_hint_set) {
+        SDL_SetHint(SDL_HINT_RENDER_VSYNC, (flags & SDL_RENDERER_PRESENTVSYNC) ? "1" : "0");
+    }
 
     surface = SDL_GetWindowSurface(window);
+
+    /* Reset the vsync hint if we set it above */
+    if (no_hint_set) {
+        SDL_SetHint(SDL_HINT_RENDER_VSYNC, "");
+    }
+
     if (!surface) {
         return NULL;
     }
@@ -872,7 +1101,7 @@ SDL_RenderDriver SW_RenderDriver = {
     SW_CreateRenderer,
     {
      "software",
-     SDL_RENDERER_SOFTWARE | SDL_RENDERER_TARGETTEXTURE,
+     SDL_RENDERER_SOFTWARE | SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_TARGETTEXTURE,
      8,
      {
       SDL_PIXELFORMAT_ARGB8888,
diff --git a/Engine/lib/sdl/src/render/software/SDL_render_sw_c.h b/Engine/lib/sdl/src/render/software/SDL_render_sw_c.h
index fa6289b23..4962ea6c0 100644
--- a/Engine/lib/sdl/src/render/software/SDL_render_sw_c.h
+++ b/Engine/lib/sdl/src/render/software/SDL_render_sw_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/render/software/SDL_rotate.c b/Engine/lib/sdl/src/render/software/SDL_rotate.c
index a903d1db2..6a9efac9c 100644
--- a/Engine/lib/sdl/src/render/software/SDL_rotate.c
+++ b/Engine/lib/sdl/src/render/software/SDL_rotate.c
@@ -82,7 +82,7 @@ to a situation where the program can segfault.
 \brief Returns colorkey info for a surface
 */
 static Uint32
-_colorkey(SDL_Surface *src)
+get_colorkey(SDL_Surface *src)
 {
     Uint32 key = 0;
     if (SDL_HasColorKey(src)) {
@@ -91,6 +91,18 @@ _colorkey(SDL_Surface *src)
     return key;
 }
 
+/* rotate (sx, sy) by (angle, center) into (dx, dy) */
+static void
+rotate(double sx, double sy, double sinangle, double cosangle, const SDL_FPoint *center, double *dx, double *dy) {
+    sx -= center->x;
+    sy -= center->y;
+
+    *dx = cosangle * sx - sinangle * sy;
+    *dy = sinangle * sx + cosangle * sy;
+
+    *dx += center->x;
+    *dy += center->y;
+}
 
 /* !
 \brief Internal target surface sizing function for rotations with trig result return.
@@ -105,49 +117,61 @@ _colorkey(SDL_Surface *src)
 
 */
 void
-SDLgfx_rotozoomSurfaceSizeTrig(int width, int height, double angle,
-                               int *dstwidth, int *dstheight,
-                               double *cangle, double *sangle)
+SDLgfx_rotozoomSurfaceSizeTrig(int width, int height, double angle, const SDL_FPoint *center,
+                               SDL_Rect *rect_dest, double *cangle, double *sangle)
 {
-    /* The trig code below gets the wrong size (due to FP inaccuracy?) when angle is a multiple of 90 degrees */
-    int angle90 = (int)(angle/90);
-    if(angle90 == angle/90) { /* if the angle is a multiple of 90 degrees */
-        angle90 %= 4;
-        if(angle90 < 0) angle90 += 4; /* 0:0 deg, 1:90 deg, 2:180 deg, 3:270 deg */
-        if(angle90 & 1) {
-            *dstwidth  = height;
-            *dstheight = width;
-            *cangle = 0;
-            *sangle = angle90 == 1 ? -1 : 1; /* reversed because our rotations are clockwise */
-        } else {
-            *dstwidth  = width;
-            *dstheight = height;
-            *cangle = angle90 == 0 ? 1 : -1;
-            *sangle = 0;
-        }
-    } else {
-        double x, y, cx, cy, sx, sy;
-        double radangle;
-        int dstwidthhalf, dstheighthalf;
-        /*
-        * Determine destination width and height by rotating a centered source box
-        */
-        radangle = angle * (M_PI / -180.0); /* reverse the angle because our rotations are clockwise */
-        *sangle = SDL_sin(radangle);
-        *cangle = SDL_cos(radangle);
-        x = (double)(width / 2);
-        y = (double)(height / 2);
-        cx = *cangle * x;
-        cy = *cangle * y;
-        sx = *sangle * x;
-        sy = *sangle * y;
+    int minx, maxx, miny, maxy;
+    double radangle;
+    double x0, x1, x2, x3;
+    double y0, y1, y2, y3;
+    double sinangle;
+    double cosangle;
 
-        dstwidthhalf = MAX((int)
-            SDL_ceil(MAX(MAX(MAX(SDL_fabs(cx + sy), SDL_fabs(cx - sy)), SDL_fabs(-cx + sy)), SDL_fabs(-cx - sy))), 1);
-        dstheighthalf = MAX((int)
-            SDL_ceil(MAX(MAX(MAX(SDL_fabs(sx + cy), SDL_fabs(sx - cy)), SDL_fabs(-sx + cy)), SDL_fabs(-sx - cy))), 1);
-        *dstwidth = 2 * dstwidthhalf;
-        *dstheight = 2 * dstheighthalf;
+    radangle = angle * (M_PI / 180.0);
+    sinangle = SDL_sin(radangle);
+    cosangle = SDL_cos(radangle);
+
+    /*
+     * Determine destination width and height by rotating a source box, at pixel center
+     */
+    rotate(0.5,         0.5,          sinangle, cosangle, center, &x0, &y0);
+    rotate(width - 0.5, 0.5,          sinangle, cosangle, center, &x1, &y1);
+    rotate(0.5,         height - 0.5, sinangle, cosangle, center, &x2, &y2);
+    rotate(width - 0.5, height - 0.5, sinangle, cosangle, center, &x3, &y3);
+
+    minx = (int)SDL_floor( SDL_min( SDL_min(x0, x1), SDL_min(x2, x3) ) );
+    maxx = (int)SDL_ceil(  SDL_max( SDL_max(x0, x1), SDL_max(x2, x3) ) );
+
+    miny = (int)SDL_floor( SDL_min( SDL_min(y0, y1), SDL_min(y2, y3) ) );
+    maxy = (int)SDL_ceil(  SDL_max( SDL_max(y0, y1), SDL_max(y2, y3) ) );
+
+    rect_dest->w = maxx - minx;
+    rect_dest->h = maxy - miny;
+    rect_dest->x = minx;
+    rect_dest->y = miny;
+
+    /* reverse the angle because our rotations are clockwise */
+    *sangle = -sinangle;
+    *cangle = cosangle;
+
+    {
+        /* The trig code below gets the wrong size (due to FP inaccuracy?) when angle is a multiple of 90 degrees */
+        int angle90 = (int)(angle/90);
+        if(angle90 == angle/90) { /* if the angle is a multiple of 90 degrees */
+            angle90 %= 4;
+            if(angle90 < 0) angle90 += 4; /* 0:0 deg, 1:90 deg, 2:180 deg, 3:270 deg */
+            if(angle90 & 1) {
+                rect_dest->w  = height;
+                rect_dest->h = width;
+                *cangle = 0;
+                *sangle = angle90 == 1 ? -1 : 1; /* reversed because our rotations are clockwise */
+            } else {
+                rect_dest->w  = width;
+                rect_dest->h = height;
+                *cangle = angle90 == 0 ? 1 : -1;
+                *sangle = 0;
+            }
+        }
     }
 }
 
@@ -184,7 +208,7 @@ computeSourceIncrements90(SDL_Surface * src, int bpp, int angle, int flipx, int
     if (signy < 0) sp += (src->h-1)*src->pitch;                                                             \
                                                                                                             \
     for (dy = 0; dy < dst->h; sp += sincy, dp += dincy, dy++) {                                             \
-        if (sincx == sizeof(pixelType)) { /* if advancing src and dest equally, use memcpy */               \
+        if (sincx == sizeof(pixelType)) { /* if advancing src and dest equally, use SDL_memcpy */           \
             SDL_memcpy(dp, sp, dst->w*sizeof(pixelType));                                                   \
             sp += dst->w*sizeof(pixelType);                                                                 \
             dp += dst->w*sizeof(pixelType);                                                                 \
@@ -220,48 +244,56 @@ Assumes dst surface was allocated with the correct dimensions.
 
 \param src Source surface.
 \param dst Destination surface.
-\param cx Horizontal center coordinate.
-\param cy Vertical center coordinate.
 \param isin Integer version of sine of angle.
 \param icos Integer version of cosine of angle.
 \param flipx Flag indicating horizontal mirroring should be applied.
 \param flipy Flag indicating vertical mirroring should be applied.
 \param smooth Flag indicating anti-aliasing should be used.
+\param dst_rect destination coordinates
+\param center true center.
 */
 static void
-_transformSurfaceRGBA(SDL_Surface * src, SDL_Surface * dst, int cx, int cy, int isin, int icos, int flipx, int flipy, int smooth)
+transformSurfaceRGBA(SDL_Surface * src, SDL_Surface * dst, int isin, int icos,
+        int flipx, int flipy, int smooth,
+        const SDL_Rect *rect_dest,
+        const SDL_FPoint *center)
 {
-    int x, y, t1, t2, dx, dy, xd, yd, sdx, sdy, ax, ay, ex, ey, sw, sh;
+    int sw, sh;
+    int cx, cy;
     tColorRGBA c00, c01, c10, c11, cswap;
     tColorRGBA *pc, *sp;
     int gap;
+    const int fp_half = (1<<15);
 
     /*
     * Variable setup
     */
-    xd = ((src->w - dst->w) << 15);
-    yd = ((src->h - dst->h) << 15);
-    ax = (cx << 16) - (icos * cx);
-    ay = (cy << 16) - (isin * cx);
     sw = src->w - 1;
     sh = src->h - 1;
     pc = (tColorRGBA*) dst->pixels;
     gap = dst->pitch - dst->w * 4;
+    cx = (int)(center->x * 65536.0);
+    cy = (int)(center->y * 65536.0);
 
     /*
     * Switch between interpolating and non-interpolating code
     */
     if (smooth) {
+        int y;
         for (y = 0; y < dst->h; y++) {
-            dy = cy - y;
-            sdx = (ax + (isin * dy)) + xd;
-            sdy = (ay - (icos * dy)) + yd;
+            int x;
+            double src_x = (rect_dest->x + 0 + 0.5 - center->x);
+            double src_y = (rect_dest->y + y + 0.5 - center->y);
+            int sdx = (int)((icos * src_x - isin * src_y) + cx - fp_half);
+            int sdy = (int)((isin * src_x + icos * src_y) + cy - fp_half);
             for (x = 0; x < dst->w; x++) {
-                dx = (sdx >> 16);
-                dy = (sdy >> 16);
+                int dx = (sdx >> 16);
+                int dy = (sdy >> 16);
                 if (flipx) dx = sw - dx;
                 if (flipy) dy = sh - dy;
                 if ((dx > -1) && (dy > -1) && (dx < (src->w-1)) && (dy < (src->h-1))) {
+                    int ex, ey;
+                    int t1, t2;
                     sp = (tColorRGBA *) ((Uint8 *) src->pixels + src->pitch * dy) + dx;
                     c00 = *sp;
                     sp += 1;
@@ -303,13 +335,16 @@ _transformSurfaceRGBA(SDL_Surface * src, SDL_Surface * dst, int cx, int cy, int
             pc = (tColorRGBA *) ((Uint8 *) pc + gap);
         }
     } else {
+        int y;
         for (y = 0; y < dst->h; y++) {
-            dy = cy - y;
-            sdx = (ax + (isin * dy)) + xd;
-            sdy = (ay - (icos * dy)) + yd;
+            int x;
+            double src_x = (rect_dest->x + 0 + 0.5 - center->x);
+            double src_y = (rect_dest->y + y + 0.5 - center->y);
+            int sdx = (int)((icos * src_x - isin * src_y) + cx - fp_half);
+            int sdy = (int)((isin * src_x + icos * src_y) + cy - fp_half);
             for (x = 0; x < dst->w; x++) {
-                dx = (sdx >> 16);
-                dy = (sdy >> 16);
+                int dx = (sdx >> 16);
+                int dy = (sdy >> 16);
                 if ((unsigned)dx < (unsigned)src->w && (unsigned)dy < (unsigned)src->h) {
                     if(flipx) dx = sw - dx;
                     if(flipy) dy = sh - dy;
@@ -335,46 +370,54 @@ Assumes dst surface was allocated with the correct dimensions.
 
 \param src Source surface.
 \param dst Destination surface.
-\param cx Horizontal center coordinate.
-\param cy Vertical center coordinate.
 \param isin Integer version of sine of angle.
 \param icos Integer version of cosine of angle.
 \param flipx Flag indicating horizontal mirroring should be applied.
 \param flipy Flag indicating vertical mirroring should be applied.
+\param dst_rect destination coordinates
+\param center true center.
 */
 static void
-transformSurfaceY(SDL_Surface * src, SDL_Surface * dst, int cx, int cy, int isin, int icos, int flipx, int flipy)
+transformSurfaceY(SDL_Surface * src, SDL_Surface * dst, int isin, int icos, int flipx, int flipy,
+        const SDL_Rect *rect_dest,
+        const SDL_FPoint *center)
 {
-    int x, y, dx, dy, xd, yd, sdx, sdy, ax, ay;
+    int sw, sh;
+    int cx, cy;
     tColorY *pc;
     int gap;
+    const int fp_half = (1<<15);
+    int y;
 
     /*
     * Variable setup
     */
-    xd = ((src->w - dst->w) << 15);
-    yd = ((src->h - dst->h) << 15);
-    ax = (cx << 16) - (icos * cx);
-    ay = (cy << 16) - (isin * cx);
+    sw = src->w - 1;
+    sh = src->h - 1;
     pc = (tColorY*) dst->pixels;
     gap = dst->pitch - dst->w;
+    cx = (int)(center->x * 65536.0);
+    cy = (int)(center->y * 65536.0);
+
     /*
     * Clear surface to colorkey
     */
-    SDL_memset(pc, (int)(_colorkey(src) & 0xff), dst->pitch * dst->h);
+    SDL_memset(pc, (int)(get_colorkey(src) & 0xff), dst->pitch * dst->h);
     /*
     * Iterate through destination surface
     */
     for (y = 0; y < dst->h; y++) {
-        dy = cy - y;
-        sdx = (ax + (isin * dy)) + xd;
-        sdy = (ay - (icos * dy)) + yd;
+        int x;
+        double src_x = (rect_dest->x + 0 + 0.5 - center->x);
+        double src_y = (rect_dest->y + y + 0.5 - center->y);
+        int sdx = (int)((icos * src_x - isin * src_y) + cx - fp_half);
+        int sdy = (int)((isin * src_x + icos * src_y) + cy - fp_half);
         for (x = 0; x < dst->w; x++) {
-            dx = (sdx >> 16);
-            dy = (sdy >> 16);
+            int dx = (sdx >> 16);
+            int dy = (sdy >> 16);
             if ((unsigned)dx < (unsigned)src->w && (unsigned)dy < (unsigned)src->h) {
-                if (flipx) dx = (src->w-1)-dx;
-                if (flipy) dy = (src->h-1)-dy;
+                if (flipx) dx = sw - dx;
+                if (flipy) dy = sh- dy;
                 *pc = *((tColorY *)src->pixels + src->pitch * dy + dx);
             }
             sdx += icos;
@@ -390,7 +433,7 @@ transformSurfaceY(SDL_Surface * src, SDL_Surface * dst, int cx, int cy, int isin
 \brief Rotates and zooms a surface with different horizontal and vertival scaling factors and optional anti-aliasing.
 
 Rotates a 32-bit or 8-bit 'src' surface to newly created 'dst' surface.
-'angle' is the rotation in degrees, 'centerx' and 'centery' the rotation center. If 'smooth' is set
+'angle' is the rotation in degrees, 'center' the rotation center. If 'smooth' is set
 then the destination 32-bit surface is anti-aliased. 8-bit surfaces must have a colorkey. 32-bit
 surfaces must have a 8888 layout with red, green, blue and alpha masks (any ordering goes).
 The blend mode of the 'src' surface has some effects on generation of the 'dst' surface: The NONE
@@ -400,21 +443,21 @@ When using the NONE and MOD modes, color and alpha modulation must be applied be
 
 \param src The surface to rotozoom.
 \param angle The angle to rotate in degrees.
-\param centerx The horizontal coordinate of the center of rotation
 \param zoomy The vertical coordinate of the center of rotation
 \param smooth Antialiasing flag; set to SMOOTHING_ON to enable.
 \param flipx Set to 1 to flip the image horizontally
 \param flipy Set to 1 to flip the image vertically
-\param dstwidth The destination surface width
-\param dstheight The destination surface height
+\param rect_dest The destination rect bounding box
 \param cangle The angle cosine
 \param sangle The angle sine
+\param center The true coordinate of the center of rotation
 \return The new rotated surface.
 
 */
 
 SDL_Surface *
-SDLgfx_rotateSurface(SDL_Surface * src, double angle, int centerx, int centery, int smooth, int flipx, int flipy, int dstwidth, int dstheight, double cangle, double sangle)
+SDLgfx_rotateSurface(SDL_Surface * src, double angle, int smooth, int flipx, int flipy,
+        const SDL_Rect *rect_dest, double cangle, double sangle, const SDL_FPoint *center)
 {
     SDL_Surface *rz_dst;
     int is8bit, angle90;
@@ -433,13 +476,12 @@ SDLgfx_rotateSurface(SDL_Surface * src, double angle, int centerx, int centery,
             colorKeyAvailable = SDL_TRUE;
         }
     }
-
     /* This function requires a 32-bit surface or 8-bit surface with a colorkey */
     is8bit = src->format->BitsPerPixel == 8 && colorKeyAvailable;
     if (!(is8bit || (src->format->BitsPerPixel == 32 && src->format->Amask)))
         return NULL;
 
-    /* Calculate target factors from sin/cos and zoom */
+    /* Calculate target factors from sine/cosine and zoom */
     sangleinv = sangle*65536.0;
     cangleinv = cangle*65536.0;
 
@@ -447,16 +489,18 @@ SDLgfx_rotateSurface(SDL_Surface * src, double angle, int centerx, int centery,
     rz_dst = NULL;
     if (is8bit) {
         /* Target surface is 8 bit */
-        rz_dst = SDL_CreateRGBSurface(0, dstwidth, dstheight + GUARD_ROWS, 8, 0, 0, 0, 0);
+        rz_dst = SDL_CreateRGBSurfaceWithFormat(0, rect_dest->w, rect_dest->h + GUARD_ROWS, 8, src->format->format);
         if (rz_dst != NULL) {
-            for (i = 0; i < src->format->palette->ncolors; i++) {
-                rz_dst->format->palette->colors[i] = src->format->palette->colors[i];
+            if (src->format->palette) {
+                for (i = 0; i < src->format->palette->ncolors; i++) {
+                    rz_dst->format->palette->colors[i] = src->format->palette->colors[i];
+                }
+                rz_dst->format->palette->ncolors = src->format->palette->ncolors;
             }
-            rz_dst->format->palette->ncolors = src->format->palette->ncolors;
         }
     } else {
         /* Target surface is 32 bit with source RGBA ordering */
-        rz_dst = SDL_CreateRGBSurface(0, dstwidth, dstheight + GUARD_ROWS, 32,
+        rz_dst = SDL_CreateRGBSurface(0, rect_dest->w, rect_dest->h + GUARD_ROWS, 32,
                                       src->format->Rmask, src->format->Gmask,
                                       src->format->Bmask, src->format->Amask);
     }
@@ -466,7 +510,7 @@ SDLgfx_rotateSurface(SDL_Surface * src, double angle, int centerx, int centery,
         return NULL;
 
     /* Adjust for guard rows */
-    rz_dst->h = dstheight;
+    rz_dst->h = rect_dest->h;
 
     SDL_GetSurfaceBlendMode(src, &blendmode);
 
@@ -497,7 +541,7 @@ SDLgfx_rotateSurface(SDL_Surface * src, double angle, int centerx, int centery,
     }
 
     /* check if the rotation is a multiple of 90 degrees so we can take a fast path and also somewhat reduce
-     * the off-by-one problem in _transformSurfaceRGBA that expresses itself when the rotation is near
+     * the off-by-one problem in transformSurfaceRGBA that expresses itself when the rotation is near
      * multiples of 90 degrees.
      */
     angle90 = (int)(angle/90);
@@ -513,16 +557,16 @@ SDLgfx_rotateSurface(SDL_Surface * src, double angle, int centerx, int centery,
         if(angle90 >= 0) {
             transformSurfaceY90(src, rz_dst, angle90, flipx, flipy);
         } else {
-            transformSurfaceY(src, rz_dst, centerx, centery, (int)sangleinv, (int)cangleinv,
-                              flipx, flipy);
+            transformSurfaceY(src, rz_dst, (int)sangleinv, (int)cangleinv,
+                              flipx, flipy, rect_dest, center);
         }
     } else {
         /* Call the 32-bit transformation routine to do the rotation */
         if (angle90 >= 0) {
             transformSurfaceRGBA90(src, rz_dst, angle90, flipx, flipy);
         } else {
-            _transformSurfaceRGBA(src, rz_dst, centerx, centery, (int)sangleinv, (int)cangleinv,
-                                  flipx, flipy, smooth);
+            transformSurfaceRGBA(src, rz_dst, (int)sangleinv, (int)cangleinv,
+                                  flipx, flipy, smooth, rect_dest, center);
         }
     }
 
diff --git a/Engine/lib/sdl/src/render/software/SDL_rotate.h b/Engine/lib/sdl/src/render/software/SDL_rotate.h
index c1864d27a..171baa5dd 100644
--- a/Engine/lib/sdl/src/render/software/SDL_rotate.h
+++ b/Engine/lib/sdl/src/render/software/SDL_rotate.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -26,7 +26,9 @@
 #define MIN(a,b)    (((a) < (b)) ? (a) : (b))
 #endif
 
-extern SDL_Surface *SDLgfx_rotateSurface(SDL_Surface * src, double angle, int centerx, int centery, int smooth, int flipx, int flipy, int dstwidth, int dstheight, double cangle, double sangle);
-extern void SDLgfx_rotozoomSurfaceSizeTrig(int width, int height, double angle, int *dstwidth, int *dstheight, double *cangle, double *sangle);
+extern SDL_Surface *SDLgfx_rotateSurface(SDL_Surface * src, double angle, int smooth, int flipx, int flipy,
+        const SDL_Rect *rect_dest, double cangle, double sangle, const SDL_FPoint *center);
+extern void SDLgfx_rotozoomSurfaceSizeTrig(int width, int height, double angle, const SDL_FPoint *center,
+        SDL_Rect *rect_dest, double *cangle, double *sangle);
 
 #endif /* SDL_rotate_h_ */
diff --git a/Engine/lib/sdl/src/render/software/SDL_triangle.c b/Engine/lib/sdl/src/render/software/SDL_triangle.c
new file mode 100644
index 000000000..694cb4d91
--- /dev/null
+++ b/Engine/lib/sdl/src/render/software/SDL_triangle.c
@@ -0,0 +1,888 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if SDL_VIDEO_RENDER_SW && !SDL_RENDER_DISABLED
+
+#include "SDL_surface.h"
+#include "SDL_triangle.h"
+
+#include "../../video/SDL_blit.h"
+
+/* fixed points bits precision
+ * Set to 1, so that it can start rendering wth middle of a pixel precision.
+ * It doesn't need to be increased.
+ * But, if increased too much, it overflows (srcx, srcy) coordinates used for filling with texture.
+ * (which could be turned to int64).
+ */
+#define FP_BITS   1
+
+
+#define COLOR_EQ(c1, c2)    ((c1).r == (c2).r && (c1).g == (c2).g && (c1).b == (c2).b && (c1).a == (c2).a)
+
+static void SDL_BlitTriangle_Slow(SDL_BlitInfo * info,
+        SDL_Point s2_x_area, SDL_Rect dstrect, int area, int bias_w0, int bias_w1, int bias_w2,
+    int d2d1_y, int d1d2_x, int d0d2_y, int d2d0_x, int d1d0_y, int d0d1_x,
+    int s2s0_x, int s2s1_x, int s2s0_y, int s2s1_y, int w0_row, int w1_row, int w2_row,
+    SDL_Color c0, SDL_Color c1, SDL_Color c2, int is_uniform);
+
+#if 0
+int SDL_BlitTriangle(SDL_Surface *src, const SDL_Point srcpoints[3], SDL_Surface *dst, const SDL_Point dstpoints[3])
+{
+    int i;
+    SDL_Point points[6];
+
+    if (src == NULL || dst == NULL) {
+        return -1;
+    }
+
+    for (i = 0; i < 3; i++) {
+        if (srcpoints[i].x < 0 || srcpoints[i].y < 0 || srcpoints[i].x >= src->w || srcpoints[i].y >= src->h) {
+            return SDL_SetError("Values of 'srcpoints' out of bounds");
+        }
+    }
+
+    points[0] = srcpoints[0];
+    points[1] = dstpoints[0];
+    points[2] = srcpoints[1];
+    points[3] = dstpoints[1];
+    points[4] = srcpoints[2];
+    points[5] = dstpoints[2];
+    for (i = 0; i < 3; i++) {
+        trianglepoint_2_fixedpoint(&points[2 * i + 1]);
+    }
+    return SDL_SW_BlitTriangle(src, dst, points);
+}
+
+int SDL_FillTriangle(SDL_Surface *dst, const SDL_Point points[3], Uint32 color)
+{
+    int i;
+    SDL_Point points_tmp[3];
+    if (dst == NULL) {
+        return -1;
+    }
+    for (i = 0; i < 3; i++) {
+        points_tmp[i] = points[i];
+        trianglepoint_2_fixedpoint(&points_tmp[i]);
+    }
+    return SDL_SW_FillTriangle(dst, points_tmp, SDL_BLENDMODE_NONE, color);
+}
+#endif
+
+/* cross product AB x AC */
+static int cross_product(const SDL_Point *a, const SDL_Point *b, int c_x, int c_y)
+{
+    return (b->x - a->x) * (c_y - a->y) - (b->y - a->y) * (c_x - a->x);
+}
+
+/* check for top left rules */
+static int is_top_left(const SDL_Point *a, const SDL_Point *b, int is_clockwise)
+{
+    if (is_clockwise) {
+        if (a->y == b->y && a->x < b->x) {
+            return 1;
+        }
+        if (b->y < a->y) {
+            return 1;
+        }
+    } else {
+        if (a->y == b->y && b->x < a->x) {
+            return 1;
+        }
+        if (a->y < b->y) {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+void trianglepoint_2_fixedpoint(SDL_Point *a) {
+    a->x <<= FP_BITS;
+    a->y <<= FP_BITS;
+}
+
+/* bounding rect of three points (in fixed point) */
+static void bounding_rect_fixedpoint(const SDL_Point *a, const SDL_Point *b, const SDL_Point *c, SDL_Rect *r)
+{
+    int min_x = SDL_min(a->x, SDL_min(b->x, c->x));
+    int max_x = SDL_max(a->x, SDL_max(b->x, c->x));
+    int min_y = SDL_min(a->y, SDL_min(b->y, c->y));
+    int max_y = SDL_max(a->y, SDL_max(b->y, c->y));
+    /* points are in fixed point, shift back */
+    r->x = min_x >> FP_BITS;
+    r->y = min_y >> FP_BITS;
+    r->w = (max_x - min_x) >> FP_BITS;
+    r->h = (max_y - min_y) >> FP_BITS;
+}
+
+/* bounding rect of three points */
+static void bounding_rect(const SDL_Point *a, const SDL_Point *b, const SDL_Point *c, SDL_Rect *r)
+{
+    int min_x = SDL_min(a->x, SDL_min(b->x, c->x));
+    int max_x = SDL_max(a->x, SDL_max(b->x, c->x));
+    int min_y = SDL_min(a->y, SDL_min(b->y, c->y));
+    int max_y = SDL_max(a->y, SDL_max(b->y, c->y));
+    r->x = min_x;
+    r->y = min_y;
+    r->w = (max_x - min_x);
+    r->h = (max_y - min_y);
+}
+
+
+/* Triangle rendering, using Barycentric coordinates (w0, w1, w2)
+ *
+ * The cross product isn't computed from scratch at each iteration,
+ * but optimized using constant step increments
+ *
+ */
+
+#define TRIANGLE_BEGIN_LOOP                                                                             \
+    {                                                                                                   \
+        int x, y;                                                                                       \
+        for (y = 0; y < dstrect.h; y++) {                                                               \
+            /* y start */                                                                               \
+            int w0 = w0_row;                                                                            \
+            int w1 = w1_row;                                                                            \
+            int w2 = w2_row;                                                                            \
+            for (x = 0; x < dstrect.w; x++) {                                                           \
+                /* In triangle */                                                                       \
+                if (w0 + bias_w0 >= 0 && w1 + bias_w1 >= 0 && w2 + bias_w2 >= 0) {                      \
+                    Uint8 *dptr = (Uint8 *) dst_ptr + x * dstbpp;                                       \
+
+
+/* Use 64 bits precision to prevent overflow when interpolating color / texture with wide triangles */
+#define TRIANGLE_GET_TEXTCOORD                                                                          \
+                    int srcx = (int)(((Sint64)w0 * s2s0_x + (Sint64)w1 * s2s1_x + s2_x_area.x) / area); \
+                    int srcy = (int)(((Sint64)w0 * s2s0_y + (Sint64)w1 * s2s1_y + s2_x_area.y) / area); \
+
+#define TRIANGLE_GET_MAPPED_COLOR                                                                       \
+                    int r = (int)(((Sint64)w0 * c0.r + (Sint64)w1 * c1.r + (Sint64)w2 * c2.r) / area);  \
+                    int g = (int)(((Sint64)w0 * c0.g + (Sint64)w1 * c1.g + (Sint64)w2 * c2.g) / area);  \
+                    int b = (int)(((Sint64)w0 * c0.b + (Sint64)w1 * c1.b + (Sint64)w2 * c2.b) / area);  \
+                    int a = (int)(((Sint64)w0 * c0.a + (Sint64)w1 * c1.a + (Sint64)w2 * c2.a) / area);  \
+                    int color = SDL_MapRGBA(format, r, g, b, a);                                        \
+
+#define TRIANGLE_GET_COLOR                                                                              \
+                    int r = (int)(((Sint64)w0 * c0.r + (Sint64)w1 * c1.r + (Sint64)w2 * c2.r) / area);  \
+                    int g = (int)(((Sint64)w0 * c0.g + (Sint64)w1 * c1.g + (Sint64)w2 * c2.g) / area);  \
+                    int b = (int)(((Sint64)w0 * c0.b + (Sint64)w1 * c1.b + (Sint64)w2 * c2.b) / area);  \
+                    int a = (int)(((Sint64)w0 * c0.a + (Sint64)w1 * c1.a + (Sint64)w2 * c2.a) / area);  \
+
+
+#define TRIANGLE_END_LOOP                                                                               \
+                }                                                                                       \
+                /* x += 1 */                                                                            \
+                w0 += d2d1_y;                                                                           \
+                w1 += d0d2_y;                                                                           \
+                w2 += d1d0_y;                                                                           \
+            }                                                                                           \
+            /* y += 1 */                                                                                \
+            w0_row += d1d2_x;                                                                           \
+            w1_row += d2d0_x;                                                                           \
+            w2_row += d0d1_x;                                                                           \
+            dst_ptr += dst_pitch;                                                                       \
+        }                                                                                               \
+    }                                                                                                   \
+
+int SDL_SW_FillTriangle(SDL_Surface *dst, SDL_Point *d0, SDL_Point *d1, SDL_Point *d2, SDL_BlendMode blend, SDL_Color c0, SDL_Color c1, SDL_Color c2)
+{
+    int ret = 0;
+    int dst_locked = 0;
+
+    SDL_Rect dstrect;
+
+    int dstbpp;
+    Uint8 *dst_ptr;
+    int dst_pitch;
+
+    int area, is_clockwise;
+
+    int d2d1_y, d1d2_x, d0d2_y, d2d0_x, d1d0_y, d0d1_x;
+    int w0_row, w1_row, w2_row;
+    int bias_w0, bias_w1, bias_w2;
+
+    int is_uniform;
+
+    SDL_Surface *tmp = NULL;
+
+    if (dst == NULL) {
+        return -1;
+    }
+
+    area = cross_product(d0, d1, d2->x, d2->y);
+
+    is_uniform = COLOR_EQ(c0, c1) && COLOR_EQ(c1, c2);
+
+    /* Flat triangle */
+    if (area == 0) {
+        return 0;
+    }
+
+    /* Lock the destination, if needed */
+    if (SDL_MUSTLOCK(dst)) {
+        if (SDL_LockSurface(dst) < 0) {
+            ret = -1;
+            goto end;
+        } else {
+            dst_locked = 1;
+        }
+    }
+
+    bounding_rect_fixedpoint(d0, d1, d2, &dstrect);
+
+    {
+        /* Clip triangle rect with surface rect */
+        SDL_Rect rect;
+        rect.x = 0;
+        rect.y = 0;
+        rect.w = dst->w;
+        rect.h = dst->h;
+        SDL_IntersectRect(&dstrect, &rect, &dstrect);
+    }
+
+    {
+        /* Clip triangle with surface clip rect */
+        SDL_Rect rect;
+        SDL_GetClipRect(dst, &rect);
+        SDL_IntersectRect(&dstrect, &rect, &dstrect);
+    }
+
+
+    if (blend != SDL_BLENDMODE_NONE) {
+        int format = dst->format->format;
+
+        /* need an alpha format */
+        if (! dst->format->Amask) {
+            format = SDL_PIXELFORMAT_ARGB8888;
+        }
+
+        /* Use an intermediate surface */
+        tmp = SDL_CreateRGBSurfaceWithFormat(0, dstrect.w, dstrect.h, 0, format);
+        if (tmp == NULL) {
+            ret = -1;
+            goto end;
+        }
+
+        if (blend == SDL_BLENDMODE_MOD) {
+            Uint32 c = SDL_MapRGBA(tmp->format, 255, 255, 255, 255);
+            SDL_FillRect(tmp, NULL, c);
+        }
+
+        SDL_SetSurfaceBlendMode(tmp, blend);
+
+        dstbpp = tmp->format->BytesPerPixel;
+        dst_ptr = tmp->pixels;
+        dst_pitch = tmp->pitch;
+
+    } else {
+        /* Write directly to destination surface */
+        dstbpp = dst->format->BytesPerPixel;
+        dst_ptr = (Uint8 *)dst->pixels + dstrect.x * dstbpp + dstrect.y * dst->pitch;
+        dst_pitch = dst->pitch;
+    }
+
+    is_clockwise = area > 0;
+    area = SDL_abs(area);
+
+    d2d1_y = (d1->y - d2->y) << FP_BITS;
+    d0d2_y = (d2->y - d0->y) << FP_BITS;
+    d1d0_y = (d0->y - d1->y) << FP_BITS;
+    d1d2_x = (d2->x - d1->x) << FP_BITS;
+    d2d0_x = (d0->x - d2->x) << FP_BITS;
+    d0d1_x = (d1->x - d0->x) << FP_BITS;
+
+    /* Starting point for rendering, at the middle of a pixel */
+    {
+        SDL_Point p;
+        p.x = dstrect.x;
+        p.y = dstrect.y;
+        trianglepoint_2_fixedpoint(&p);
+        p.x += (1 << FP_BITS) / 2;
+        p.y += (1 << FP_BITS) / 2;
+        w0_row = cross_product(d1, d2, p.x, p.y);
+        w1_row = cross_product(d2, d0, p.x, p.y);
+        w2_row = cross_product(d0, d1, p.x, p.y);
+    }
+
+    /* Handle anti-clockwise triangles */
+    if (! is_clockwise) {
+        d2d1_y *= -1;
+        d0d2_y *= -1;
+        d1d0_y *= -1;
+        d1d2_x *= -1;
+        d2d0_x *= -1;
+        d0d1_x *= -1;
+        w0_row *= -1;
+        w1_row *= -1;
+        w2_row *= -1;
+    }
+
+    /* Add a bias to respect top-left rasterization rule */
+    bias_w0 = (is_top_left(d1, d2, is_clockwise) ? 0 : -1);
+    bias_w1 = (is_top_left(d2, d0, is_clockwise) ? 0 : -1);
+    bias_w2 = (is_top_left(d0, d1, is_clockwise) ? 0 : -1);
+
+    if (is_uniform) {
+        Uint32 color;
+        if (tmp) {
+            if (dst->format->Amask) {
+                color = SDL_MapRGBA(tmp->format, c0.r, c0.g, c0.b, c0.a);
+            } else {
+                //color = SDL_MapRGB(tmp->format, c0.r, c0.g, c0.b);
+                color = SDL_MapRGBA(tmp->format, c0.r, c0.g, c0.b, c0.a);
+            }
+        } else {
+            color = SDL_MapRGBA(dst->format, c0.r, c0.g, c0.b, c0.a);
+        }
+
+        if (dstbpp == 4) {
+            TRIANGLE_BEGIN_LOOP
+            {
+                *(Uint32 *)dptr = color;
+            }
+            TRIANGLE_END_LOOP
+        } else if (dstbpp == 3) {
+            TRIANGLE_BEGIN_LOOP
+            {
+                Uint8 *s = (Uint8*)&color;
+                dptr[0] = s[0];
+                dptr[1] = s[1];
+                dptr[2] = s[2];
+            }
+            TRIANGLE_END_LOOP
+        } else if (dstbpp == 2) {
+            TRIANGLE_BEGIN_LOOP
+            {
+                *(Uint16 *)dptr = color;
+            }
+            TRIANGLE_END_LOOP
+        } else if (dstbpp == 1) {
+            TRIANGLE_BEGIN_LOOP
+            {
+                *dptr = color;
+            }
+            TRIANGLE_END_LOOP
+        }
+    } else {
+        SDL_PixelFormat *format = dst->format;
+        if (tmp) {
+            format = tmp->format;
+        }
+        if (dstbpp == 4) {
+            TRIANGLE_BEGIN_LOOP
+            {
+                TRIANGLE_GET_MAPPED_COLOR
+                *(Uint32 *)dptr = color;
+            }
+            TRIANGLE_END_LOOP
+        } else if (dstbpp == 3) {
+            TRIANGLE_BEGIN_LOOP
+            {
+                TRIANGLE_GET_MAPPED_COLOR
+                Uint8 *s = (Uint8*)&color;
+                dptr[0] = s[0];
+                dptr[1] = s[1];
+                dptr[2] = s[2];
+            }
+            TRIANGLE_END_LOOP
+        } else if (dstbpp == 2) {
+            TRIANGLE_BEGIN_LOOP
+            {
+                TRIANGLE_GET_MAPPED_COLOR
+                *(Uint16 *)dptr = color;
+            }
+            TRIANGLE_END_LOOP
+        } else if (dstbpp == 1) {
+            TRIANGLE_BEGIN_LOOP
+            {
+                TRIANGLE_GET_MAPPED_COLOR
+                *dptr = color;
+            }
+            TRIANGLE_END_LOOP
+        }
+    }
+
+    if (tmp) {
+        SDL_BlitSurface(tmp, NULL, dst, &dstrect);
+        SDL_FreeSurface(tmp);
+    }
+
+end:
+    if (dst_locked) {
+        SDL_UnlockSurface(dst);
+    }
+
+    return ret;
+}
+
+
+
+
+
+
+
+int SDL_SW_BlitTriangle(
+        SDL_Surface *src,
+        SDL_Point *s0, SDL_Point *s1, SDL_Point *s2,
+        SDL_Surface *dst,
+        SDL_Point *d0, SDL_Point *d1, SDL_Point *d2,
+        SDL_Color c0, SDL_Color c1, SDL_Color c2)
+{
+    int ret = 0;
+    int src_locked = 0;
+    int dst_locked = 0;
+
+    SDL_BlendMode blend;
+
+    SDL_Rect dstrect;
+
+    SDL_Point s2_x_area;
+
+    int dstbpp;
+    Uint8 *dst_ptr;
+    int dst_pitch;
+
+    int *src_ptr;
+    int src_pitch;
+
+    int area, is_clockwise;
+
+    int d2d1_y, d1d2_x, d0d2_y, d2d0_x, d1d0_y, d0d1_x;
+    int s2s0_x, s2s1_x, s2s0_y, s2s1_y;
+
+    int w0_row, w1_row, w2_row;
+    int bias_w0, bias_w1, bias_w2;
+
+    int is_uniform;
+
+    int has_modulation;
+
+    if (src == NULL || dst == NULL) {
+        return -1;
+    }
+
+    area = cross_product(d0, d1, d2->x, d2->y);
+
+    /* Flat triangle */
+    if (area == 0) {
+        return 0;
+    }
+
+    /* Lock the destination, if needed */
+    if (SDL_MUSTLOCK(dst)) {
+        if (SDL_LockSurface(dst) < 0) {
+            ret = -1;
+            goto end;
+        } else {
+            dst_locked = 1;
+        }
+    }
+
+    /* Lock the source, if needed */
+    if (SDL_MUSTLOCK(src)) {
+        if (SDL_LockSurface(src) < 0) {
+            ret = -1;
+            goto end;
+        } else {
+            src_locked = 1;
+        }
+    }
+
+    is_uniform = COLOR_EQ(c0, c1) && COLOR_EQ(c1, c2);
+
+    bounding_rect_fixedpoint(d0, d1, d2, &dstrect);
+
+    SDL_GetSurfaceBlendMode(src, &blend);
+
+    /* TRIANGLE_GET_TEXTCOORD interpolates up to the max values included, so reduce by 1 */
+    {
+        SDL_Rect srcrect;
+        int maxx, maxy;
+        bounding_rect(s0, s1, s2, &srcrect);
+        maxx = srcrect.x + srcrect.w;
+        maxy = srcrect.y + srcrect.h;
+        if (srcrect.w > 0) {
+            if (s0->x == maxx) s0->x--;
+            if (s1->x == maxx) s1->x--;
+            if (s2->x == maxx) s2->x--;
+        }
+        if (srcrect.h > 0) {
+            if (s0->y == maxy) s0->y--;
+            if (s1->y == maxy) s1->y--;
+            if (s2->y == maxy) s2->y--;
+        }
+    }
+
+    if (is_uniform) {
+        // SDL_GetSurfaceColorMod(src, &r, &g, &b);
+        has_modulation = c0.r != 255 || c0.g != 255 || c0.b != 255 || c0.a != 255;;
+    } else {
+        has_modulation = SDL_TRUE;
+    }
+
+    {
+        /* Clip triangle rect with surface rect */
+        SDL_Rect rect;
+        rect.x = 0;
+        rect.y = 0;
+        rect.w = dst->w;
+        rect.h = dst->h;
+
+        SDL_IntersectRect(&dstrect, &rect, &dstrect);
+    }
+
+    {
+        /* Clip triangle with surface clip rect */
+        SDL_Rect rect;
+        SDL_GetClipRect(dst, &rect);
+        SDL_IntersectRect(&dstrect, &rect, &dstrect);
+    }
+
+    /* Set destination pointer */
+    dstbpp = dst->format->BytesPerPixel;
+    dst_ptr = (Uint8 *)dst->pixels + dstrect.x * dstbpp + dstrect.y * dst->pitch;
+    dst_pitch = dst->pitch;
+
+    /* Set source pointer */
+    src_ptr = src->pixels;
+    src_pitch = src->pitch;
+
+    is_clockwise = area > 0;
+    area = SDL_abs(area);
+
+    d2d1_y = (d1->y - d2->y) << FP_BITS;
+    d0d2_y = (d2->y - d0->y) << FP_BITS;
+    d1d0_y = (d0->y - d1->y) << FP_BITS;
+
+
+    d1d2_x = (d2->x - d1->x) << FP_BITS;
+    d2d0_x = (d0->x - d2->x) << FP_BITS;
+    d0d1_x = (d1->x - d0->x) << FP_BITS;
+
+    s2s0_x = s0->x - s2->x;
+    s2s1_x = s1->x - s2->x;
+    s2s0_y = s0->y - s2->y;
+    s2s1_y = s1->y - s2->y;
+
+    /* Starting point for rendering, at the middle of a pixel */
+    {
+        SDL_Point p;
+        p.x = dstrect.x;
+        p.y = dstrect.y;
+        trianglepoint_2_fixedpoint(&p);
+        p.x += (1 << FP_BITS) / 2;
+        p.y += (1 << FP_BITS) / 2;
+        w0_row = cross_product(d1, d2, p.x, p.y);
+        w1_row = cross_product(d2, d0, p.x, p.y);
+        w2_row = cross_product(d0, d1, p.x, p.y);
+    }
+
+    /* Handle anti-clockwise triangles */
+    if (! is_clockwise) {
+        d2d1_y *= -1;
+        d0d2_y *= -1;
+        d1d0_y *= -1;
+        d1d2_x *= -1;
+        d2d0_x *= -1;
+        d0d1_x *= -1;
+        w0_row *= -1;
+        w1_row *= -1;
+        w2_row *= -1;
+    }
+
+    /* Add a bias to respect top-left rasterization rule */
+    bias_w0 = (is_top_left(d1, d2, is_clockwise) ? 0 : -1);
+    bias_w1 = (is_top_left(d2, d0, is_clockwise) ? 0 : -1);
+    bias_w2 = (is_top_left(d0, d1, is_clockwise) ? 0 : -1);
+
+    /* precompute constant 's2->x * area' used in TRIANGLE_GET_TEXTCOORD */
+    s2_x_area.x = s2->x * area;
+    s2_x_area.y = s2->y * area;
+
+    if (blend != SDL_BLENDMODE_NONE || src->format->format != dst->format->format || has_modulation || ! is_uniform) {
+        /* Use SDL_BlitTriangle_Slow */
+
+        SDL_BlitInfo *info = &src->map->info;
+        SDL_BlitInfo tmp_info;
+
+        SDL_zero(tmp_info);
+
+        tmp_info.src_fmt = src->format;
+        tmp_info.dst_fmt = dst->format;
+        tmp_info.flags = info->flags;
+        /*
+        tmp_info.r = info->r;
+        tmp_info.g = info->g;
+        tmp_info.b = info->b;
+        tmp_info.a = info->a;
+        */
+        tmp_info.r = c0.r;
+        tmp_info.g = c0.g;
+        tmp_info.b = c0.b;
+        tmp_info.a = c0.a;
+
+
+        tmp_info.flags &= ~(SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA);
+
+        if (c0.r != 255  || c1.r != 255 || c2.r != 255 ||
+                c0.g != 255  || c1.g != 255 || c2.g != 255 ||
+                c0.b != 255  || c1.b != 255 || c2.b != 255) {
+            tmp_info.flags |= SDL_COPY_MODULATE_COLOR;
+        }
+
+        if (c0.a != 255 || c1.a != 255 || c2.a != 255) {
+            tmp_info.flags |= SDL_COPY_MODULATE_ALPHA;
+        }
+
+        tmp_info.colorkey = info->colorkey;
+
+        /* src */
+        tmp_info.src = (Uint8 *) src_ptr;
+        tmp_info.src_pitch = src_pitch;
+
+        /* dst */
+        tmp_info.dst = (Uint8 *) dst_ptr;
+        tmp_info.dst_pitch = dst_pitch;
+
+        SDL_BlitTriangle_Slow(&tmp_info, s2_x_area, dstrect, area, bias_w0, bias_w1, bias_w2,
+                d2d1_y, d1d2_x, d0d2_y, d2d0_x, d1d0_y, d0d1_x,
+                s2s0_x, s2s1_x, s2s0_y, s2s1_y, w0_row, w1_row, w2_row,
+                c0, c1, c2, is_uniform);
+
+        goto end;
+    }
+
+    if (dstbpp == 4) {
+        TRIANGLE_BEGIN_LOOP
+        {
+            TRIANGLE_GET_TEXTCOORD
+            Uint32 *sptr = (Uint32 *)((Uint8 *) src_ptr + srcy * src_pitch);
+            *(Uint32 *)dptr = sptr[srcx];
+        }
+        TRIANGLE_END_LOOP
+    } else if (dstbpp == 3) {
+        TRIANGLE_BEGIN_LOOP
+        {
+            TRIANGLE_GET_TEXTCOORD
+            Uint8 *sptr = (Uint8 *)((Uint8 *) src_ptr + srcy * src_pitch);
+            dptr[0] = sptr[3 * srcx];
+            dptr[1] = sptr[3 * srcx + 1];
+            dptr[2] = sptr[3 * srcx + 2];
+        }
+        TRIANGLE_END_LOOP
+    } else if (dstbpp == 2) {
+        TRIANGLE_BEGIN_LOOP
+        {
+            TRIANGLE_GET_TEXTCOORD
+            Uint16 *sptr = (Uint16 *)((Uint8 *) src_ptr + srcy * src_pitch);
+            *(Uint16 *)dptr = sptr[srcx];
+        }
+        TRIANGLE_END_LOOP
+    } else if (dstbpp == 1) {
+        TRIANGLE_BEGIN_LOOP
+        {
+            TRIANGLE_GET_TEXTCOORD
+            Uint8 *sptr = (Uint8 *)((Uint8 *) src_ptr + srcy * src_pitch);
+            *dptr = sptr[srcx];
+        }
+        TRIANGLE_END_LOOP
+    }
+
+end:
+    if (dst_locked) {
+        SDL_UnlockSurface(dst);
+    }
+    if (src_locked) {
+        SDL_UnlockSurface(src);
+    }
+
+    return ret;
+}
+
+
+#define FORMAT_ALPHA      0
+#define FORMAT_NO_ALPHA  -1
+#define FORMAT_2101010    1
+#define FORMAT_HAS_ALPHA(format)        format == 0
+#define FORMAT_HAS_NO_ALPHA(format)     format < 0
+static int SDL_INLINE detect_format(SDL_PixelFormat *pf) {
+    if (pf->format == SDL_PIXELFORMAT_ARGB2101010) {
+        return FORMAT_2101010;
+    } else if (pf->Amask) {
+        return FORMAT_ALPHA;
+    } else {
+        return FORMAT_NO_ALPHA;
+    }
+}
+
+static void
+SDL_BlitTriangle_Slow(SDL_BlitInfo *info,
+        SDL_Point s2_x_area, SDL_Rect dstrect, int area, int bias_w0, int bias_w1, int bias_w2,
+    int d2d1_y, int d1d2_x, int d0d2_y, int d2d0_x, int d1d0_y, int d0d1_x,
+    int s2s0_x, int s2s1_x, int s2s0_y, int s2s1_y, int w0_row, int w1_row, int w2_row,
+    SDL_Color c0, SDL_Color c1, SDL_Color c2, int is_uniform)
+{
+    const int flags = info->flags;
+    Uint32 modulateR = info->r;
+    Uint32 modulateG = info->g;
+    Uint32 modulateB = info->b;
+    Uint32 modulateA = info->a;
+    Uint32 srcpixel;
+    Uint32 srcR, srcG, srcB, srcA;
+    Uint32 dstpixel;
+    Uint32 dstR, dstG, dstB, dstA;
+    SDL_PixelFormat *src_fmt = info->src_fmt;
+    SDL_PixelFormat *dst_fmt = info->dst_fmt;
+    int srcbpp = src_fmt->BytesPerPixel;
+    int dstbpp = dst_fmt->BytesPerPixel;
+    int srcfmt_val;
+    int dstfmt_val;
+    Uint32 rgbmask = ~src_fmt->Amask;
+    Uint32 ckey = info->colorkey & rgbmask;
+
+    Uint8 *dst_ptr = info->dst;
+    int dst_pitch = info->dst_pitch;;
+
+    srcfmt_val = detect_format(src_fmt);
+    dstfmt_val = detect_format(dst_fmt);
+
+    TRIANGLE_BEGIN_LOOP
+    {
+        Uint8 *src;
+        Uint8 *dst = dptr;
+        TRIANGLE_GET_TEXTCOORD
+        src = (info->src + (srcy * info->src_pitch) + (srcx * srcbpp));
+        if (FORMAT_HAS_ALPHA(srcfmt_val)) {
+            DISEMBLE_RGBA(src, srcbpp, src_fmt, srcpixel, srcR, srcG, srcB, srcA);
+        } else if (FORMAT_HAS_NO_ALPHA(srcfmt_val)) {
+            DISEMBLE_RGB(src, srcbpp, src_fmt, srcpixel, srcR, srcG, srcB);
+            srcA = 0xFF;
+        } else {
+            /* SDL_PIXELFORMAT_ARGB2101010 */
+            srcpixel = *((Uint32 *)(src));
+            RGBA_FROM_ARGB2101010(srcpixel, srcR, srcG, srcB, srcA);
+        }
+        if (flags & SDL_COPY_COLORKEY) {
+            /* srcpixel isn't set for 24 bpp */
+            if (srcbpp == 3) {
+                srcpixel = (srcR << src_fmt->Rshift) |
+                    (srcG << src_fmt->Gshift) | (srcB << src_fmt->Bshift);
+            }
+            if ((srcpixel & rgbmask) == ckey) {
+                continue;
+            }
+        }
+        if (FORMAT_HAS_ALPHA(dstfmt_val)) {
+            DISEMBLE_RGBA(dst, dstbpp, dst_fmt, dstpixel, dstR, dstG, dstB, dstA);
+        } else if (FORMAT_HAS_NO_ALPHA(dstfmt_val)) {
+            DISEMBLE_RGB(dst, dstbpp, dst_fmt, dstpixel, dstR, dstG, dstB);
+            dstA = 0xFF;
+        } else {
+            /* SDL_PIXELFORMAT_ARGB2101010 */
+            dstpixel = *((Uint32 *)(dst));
+            RGBA_FROM_ARGB2101010(dstpixel, dstR, dstG, dstB, dstA);
+        }
+
+        if (! is_uniform) {
+            TRIANGLE_GET_COLOR
+            modulateR = r;
+            modulateG = g;
+            modulateB = b;
+            modulateA = a;
+        }
+
+        if (flags & SDL_COPY_MODULATE_COLOR) {
+            srcR = (srcR * modulateR) / 255;
+            srcG = (srcG * modulateG) / 255;
+            srcB = (srcB * modulateB) / 255;
+        }
+        if (flags & SDL_COPY_MODULATE_ALPHA) {
+            srcA = (srcA * modulateA) / 255;
+        }
+        if (flags & (SDL_COPY_BLEND | SDL_COPY_ADD)) {
+            /* This goes away if we ever use premultiplied alpha */
+            if (srcA < 255) {
+                srcR = (srcR * srcA) / 255;
+                srcG = (srcG * srcA) / 255;
+                srcB = (srcB * srcA) / 255;
+            }
+        }
+        switch (flags & (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_MUL)) {
+        case 0:
+            dstR = srcR;
+            dstG = srcG;
+            dstB = srcB;
+            dstA = srcA;
+            break;
+        case SDL_COPY_BLEND:
+            dstR = srcR + ((255 - srcA) * dstR) / 255;
+            dstG = srcG + ((255 - srcA) * dstG) / 255;
+            dstB = srcB + ((255 - srcA) * dstB) / 255;
+            dstA = srcA + ((255 - srcA) * dstA) / 255;
+            break;
+        case SDL_COPY_ADD:
+            dstR = srcR + dstR;
+            if (dstR > 255)
+                dstR = 255;
+            dstG = srcG + dstG;
+            if (dstG > 255)
+                dstG = 255;
+            dstB = srcB + dstB;
+            if (dstB > 255)
+                dstB = 255;
+            break;
+        case SDL_COPY_MOD:
+            dstR = (srcR * dstR) / 255;
+            dstG = (srcG * dstG) / 255;
+            dstB = (srcB * dstB) / 255;
+            break;
+        case SDL_COPY_MUL:
+            dstR = ((srcR * dstR) + (dstR * (255 - srcA))) / 255;
+            if (dstR > 255)
+                dstR = 255;
+            dstG = ((srcG * dstG) + (dstG * (255 - srcA))) / 255;
+            if (dstG > 255)
+                dstG = 255;
+            dstB = ((srcB * dstB) + (dstB * (255 - srcA))) / 255;
+            if (dstB > 255)
+                dstB = 255;
+            dstA = ((srcA * dstA) + (dstA * (255 - srcA))) / 255;
+            if (dstA > 255)
+                dstA = 255;
+            break;
+        }
+        if (FORMAT_HAS_ALPHA(dstfmt_val)) {
+            ASSEMBLE_RGBA(dst, dstbpp, dst_fmt, dstR, dstG, dstB, dstA);
+        } else if (FORMAT_HAS_NO_ALPHA(dstfmt_val)) {
+            ASSEMBLE_RGB(dst, dstbpp, dst_fmt, dstR, dstG, dstB);
+        } else {
+            /* SDL_PIXELFORMAT_ARGB2101010 */
+            Uint32 pixel;
+            ARGB2101010_FROM_RGBA(pixel, dstR, dstG, dstB, dstA);
+            *(Uint32 *)dst = pixel;
+        }
+    }
+    TRIANGLE_END_LOOP
+}
+
+#endif /* SDL_VIDEO_RENDER_SW && !SDL_RENDER_DISABLED */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/render/software/SDL_triangle.h b/Engine/lib/sdl/src/render/software/SDL_triangle.h
new file mode 100644
index 000000000..c120b39cf
--- /dev/null
+++ b/Engine/lib/sdl/src/render/software/SDL_triangle.h
@@ -0,0 +1,42 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_triangle_h_
+#define SDL_triangle_h_
+
+#include "../../SDL_internal.h"
+
+extern int SDL_SW_FillTriangle(SDL_Surface *dst,
+        SDL_Point *d0, SDL_Point *d1, SDL_Point *d2,
+        SDL_BlendMode blend, SDL_Color c0, SDL_Color c1, SDL_Color c2);
+
+extern int SDL_SW_BlitTriangle(
+        SDL_Surface *src,
+        SDL_Point *s0, SDL_Point *s1, SDL_Point *s2,
+        SDL_Surface *dst,
+        SDL_Point *d0, SDL_Point *d1, SDL_Point *d2,
+        SDL_Color c0, SDL_Color c1, SDL_Color c2);
+
+extern void trianglepoint_2_fixedpoint(SDL_Point *a);
+
+#endif /* SDL_triangle_h_ */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm.c b/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm.c
new file mode 100644
index 000000000..8a8877849
--- /dev/null
+++ b/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm.c
@@ -0,0 +1,1042 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if SDL_VIDEO_RENDER_VITA_GXM
+
+#include "SDL_hints.h"
+#include "../SDL_sysrender.h"
+#include "SDL_log.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <stdarg.h>
+#include <stdlib.h>
+
+#include "SDL_render_vita_gxm_types.h"
+#include "SDL_render_vita_gxm_tools.h"
+#include "SDL_render_vita_gxm_memory.h"
+
+#include <psp2/common_dialog.h>
+
+/* #define DEBUG_RAZOR */
+
+#if DEBUG_RAZOR
+#include <psp2/sysmodule.h>
+#endif
+
+static SDL_Renderer *VITA_GXM_CreateRenderer(SDL_Window *window, Uint32 flags);
+
+static void VITA_GXM_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *event);
+
+static SDL_bool VITA_GXM_SupportsBlendMode(SDL_Renderer * renderer, SDL_BlendMode blendMode);
+
+static int VITA_GXM_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture);
+
+static int VITA_GXM_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture,
+    const SDL_Rect *rect, const void *pixels, int pitch);
+
+static int VITA_GXM_UpdateTextureYUV(SDL_Renderer * renderer, SDL_Texture * texture,
+    const SDL_Rect * rect,
+    const Uint8 *Yplane, int Ypitch,
+    const Uint8 *Uplane, int Upitch,
+    const Uint8 *Vplane, int Vpitch);
+
+static int VITA_GXM_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture,
+    const SDL_Rect *rect, void **pixels, int *pitch);
+
+static void VITA_GXM_UnlockTexture(SDL_Renderer *renderer,
+    SDL_Texture *texture);
+
+static void VITA_GXM_SetTextureScaleMode(SDL_Renderer * renderer, SDL_Texture * texture, SDL_ScaleMode scaleMode);
+
+static int VITA_GXM_SetRenderTarget(SDL_Renderer *renderer,
+    SDL_Texture *texture);
+
+
+static int VITA_GXM_QueueSetViewport(SDL_Renderer * renderer, SDL_RenderCommand *cmd);
+
+static int VITA_GXM_QueueSetDrawColor(SDL_Renderer * renderer, SDL_RenderCommand *cmd);
+
+
+static int VITA_GXM_QueueDrawPoints(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FPoint * points, int count);
+static int VITA_GXM_QueueDrawLines(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FPoint * points, int count);
+
+static int
+VITA_GXM_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+        const float *xy, int xy_stride, const SDL_Color *color, int color_stride, const float *uv, int uv_stride,
+        int num_vertices, const void *indices, int num_indices, int size_indices,
+        float scale_x, float scale_y);
+
+static int VITA_GXM_RenderClear(SDL_Renderer *renderer, SDL_RenderCommand *cmd);
+
+static int VITA_GXM_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize);
+
+static int VITA_GXM_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect,
+    Uint32 pixel_format, void *pixels, int pitch);
+
+
+static void VITA_GXM_RenderPresent(SDL_Renderer *renderer);
+static void VITA_GXM_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture);
+static void VITA_GXM_DestroyRenderer(SDL_Renderer *renderer);
+
+
+SDL_RenderDriver VITA_GXM_RenderDriver = {
+    .CreateRenderer = VITA_GXM_CreateRenderer,
+    .info = {
+        .name = "VITA gxm",
+        .flags = SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_TARGETTEXTURE,
+        .num_texture_formats = 4,
+        .texture_formats = {
+            [0] = SDL_PIXELFORMAT_ABGR8888,
+            [1] = SDL_PIXELFORMAT_ARGB8888,
+            [2] = SDL_PIXELFORMAT_RGB565,
+            [3] = SDL_PIXELFORMAT_BGR565
+        },
+        .max_texture_width = 4096,
+        .max_texture_height = 4096,
+     }
+};
+
+static int
+PixelFormatToVITAFMT(Uint32 format)
+{
+    switch (format) {
+    case SDL_PIXELFORMAT_ARGB8888:
+        return SCE_GXM_TEXTURE_FORMAT_U8U8U8U8_ARGB;
+    case SDL_PIXELFORMAT_RGB888:
+        return SCE_GXM_TEXTURE_FORMAT_U8U8U8U8_ARGB;
+    case SDL_PIXELFORMAT_BGR888:
+        return SCE_GXM_TEXTURE_FORMAT_U8U8U8U8_ABGR;
+    case SDL_PIXELFORMAT_ABGR8888:
+        return SCE_GXM_TEXTURE_FORMAT_U8U8U8U8_ABGR;
+    case SDL_PIXELFORMAT_RGB565:
+        return SCE_GXM_TEXTURE_FORMAT_U5U6U5_RGB;
+    case SDL_PIXELFORMAT_BGR565:
+        return SCE_GXM_TEXTURE_FORMAT_U5U6U5_BGR;
+    default:
+        return SCE_GXM_TEXTURE_FORMAT_U8U8U8U8_ABGR;
+    }
+}
+
+void
+StartDrawing(SDL_Renderer *renderer)
+{
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
+    if (data->drawing) {
+        return;
+    }
+
+    data->drawstate.texture = NULL;
+    data->drawstate.vertex_program = NULL;
+    data->drawstate.fragment_program = NULL;
+    data->drawstate.last_command = -1;
+    data->drawstate.viewport_dirty = SDL_TRUE;
+
+    // reset blend mode
+//    data->currentBlendMode = SDL_BLENDMODE_BLEND;
+//    fragment_programs *in = &data->blendFragmentPrograms.blend_mode_blend;
+//    data->colorFragmentProgram = in->color;
+//    data->textureFragmentProgram = in->texture;
+
+    if (renderer->target == NULL) {
+        sceGxmBeginScene(
+            data->gxm_context,
+            0,
+            data->renderTarget,
+            NULL,
+            NULL,
+            data->displayBufferSync[data->backBufferIndex],
+            &data->displaySurface[data->backBufferIndex],
+            &data->depthSurface
+        );
+    } else {
+        VITA_GXM_TextureData *vita_texture = (VITA_GXM_TextureData *) renderer->target->driverdata;
+
+        sceGxmBeginScene(
+            data->gxm_context,
+            0,
+            vita_texture->tex->gxm_rendertarget,
+            NULL,
+            NULL,
+            NULL,
+            &vita_texture->tex->gxm_colorsurface,
+            &vita_texture->tex->gxm_depthstencil
+        );
+    }
+
+//    unset_clip_rectangle(data);
+
+    data->drawing = SDL_TRUE;
+}
+
+static int
+VITA_GXM_SetVSync(SDL_Renderer * renderer, const int vsync)
+{
+    VITA_GXM_RenderData *data = renderer->driverdata;
+    if (vsync) {
+        data->displayData.wait_vblank = SDL_TRUE;
+        renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
+    } else {
+        data->displayData.wait_vblank = SDL_FALSE;
+        renderer->info.flags &= ~SDL_RENDERER_PRESENTVSYNC;
+    }
+    return 0;
+}
+
+SDL_Renderer *
+VITA_GXM_CreateRenderer(SDL_Window *window, Uint32 flags)
+{
+    SDL_Renderer *renderer;
+    VITA_GXM_RenderData *data;
+
+    renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
+    if (!renderer) {
+        SDL_OutOfMemory();
+        return NULL;
+    }
+
+    data = (VITA_GXM_RenderData *) SDL_calloc(1, sizeof(VITA_GXM_RenderData));
+    if (!data) {
+        SDL_free(renderer);
+        SDL_OutOfMemory();
+        return NULL;
+    }
+
+    renderer->WindowEvent = VITA_GXM_WindowEvent;
+    renderer->SupportsBlendMode = VITA_GXM_SupportsBlendMode;
+    renderer->CreateTexture = VITA_GXM_CreateTexture;
+    renderer->UpdateTexture = VITA_GXM_UpdateTexture;
+#if SDL_HAVE_YUV
+    renderer->UpdateTextureYUV = VITA_GXM_UpdateTextureYUV;
+#endif
+    renderer->LockTexture = VITA_GXM_LockTexture;
+    renderer->UnlockTexture = VITA_GXM_UnlockTexture;
+    renderer->SetTextureScaleMode = VITA_GXM_SetTextureScaleMode;
+    renderer->SetRenderTarget = VITA_GXM_SetRenderTarget;
+    renderer->QueueSetViewport = VITA_GXM_QueueSetViewport;
+    renderer->QueueSetDrawColor = VITA_GXM_QueueSetDrawColor;
+    renderer->QueueDrawPoints = VITA_GXM_QueueDrawPoints;
+    renderer->QueueDrawLines = VITA_GXM_QueueDrawLines;
+    renderer->QueueGeometry = VITA_GXM_QueueGeometry;
+    renderer->RunCommandQueue = VITA_GXM_RunCommandQueue;
+    renderer->RenderReadPixels = VITA_GXM_RenderReadPixels;
+    renderer->RenderPresent = VITA_GXM_RenderPresent;
+    renderer->DestroyTexture = VITA_GXM_DestroyTexture;
+    renderer->DestroyRenderer = VITA_GXM_DestroyRenderer;
+    renderer->SetVSync = VITA_GXM_SetVSync;
+
+    renderer->info = VITA_GXM_RenderDriver.info;
+    renderer->info.flags = (SDL_RENDERER_ACCELERATED | SDL_RENDERER_TARGETTEXTURE);
+    renderer->driverdata = data;
+    renderer->window = window;
+
+    if (data->initialized != SDL_FALSE)
+        return 0;
+    data->initialized = SDL_TRUE;
+
+    if (flags & SDL_RENDERER_PRESENTVSYNC) {
+        data->displayData.wait_vblank = SDL_TRUE;
+    } else {
+        data->displayData.wait_vblank = SDL_FALSE;
+    }
+
+#if DEBUG_RAZOR
+    sceSysmoduleLoadModule( SCE_SYSMODULE_RAZOR_HUD );
+    sceSysmoduleLoadModule( SCE_SYSMODULE_RAZOR_CAPTURE );
+#endif
+
+    if (gxm_init(renderer) != 0)
+    {
+        return NULL;
+    }
+
+    return renderer;
+}
+
+static void
+VITA_GXM_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *event)
+{
+}
+
+static SDL_bool
+VITA_GXM_SupportsBlendMode(SDL_Renderer * renderer, SDL_BlendMode blendMode)
+{
+    // only for custom modes. we build all modes on init, so no custom modes, sorry
+    return SDL_FALSE;
+}
+
+static int
+VITA_GXM_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
+    VITA_GXM_TextureData* vita_texture = (VITA_GXM_TextureData*) SDL_calloc(1, sizeof(VITA_GXM_TextureData));
+
+    if (!vita_texture) {
+        return SDL_OutOfMemory();
+    }
+
+    vita_texture->tex = create_gxm_texture(data, texture->w, texture->h, PixelFormatToVITAFMT(texture->format), (texture->access == SDL_TEXTUREACCESS_TARGET));
+
+    if (!vita_texture->tex) {
+        SDL_free(vita_texture);
+        return SDL_OutOfMemory();
+    }
+
+    texture->driverdata = vita_texture;
+
+    VITA_GXM_SetTextureScaleMode(renderer, texture, texture->scaleMode);
+
+    vita_texture->w = gxm_texture_get_width(vita_texture->tex);
+    vita_texture->h = gxm_texture_get_height(vita_texture->tex);
+    vita_texture->pitch = gxm_texture_get_stride(vita_texture->tex);
+
+    return 0;
+}
+
+
+static int
+VITA_GXM_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture,
+    const SDL_Rect *rect, const void *pixels, int pitch)
+{
+    const Uint8 *src;
+    Uint8 *dst;
+    int row, length,dpitch;
+    src = pixels;
+
+    VITA_GXM_LockTexture(renderer, texture, rect, (void **)&dst, &dpitch);
+    length = rect->w * SDL_BYTESPERPIXEL(texture->format);
+    if (length == pitch && length == dpitch) {
+        SDL_memcpy(dst, src, length*rect->h);
+    } else {
+        for (row = 0; row < rect->h; ++row) {
+            SDL_memcpy(dst, src, length);
+            src += pitch;
+            dst += dpitch;
+        }
+    }
+
+    return 0;
+}
+
+static int
+VITA_GXM_UpdateTextureYUV(SDL_Renderer * renderer, SDL_Texture * texture,
+    const SDL_Rect * rect,
+    const Uint8 *Yplane, int Ypitch,
+    const Uint8 *Uplane, int Upitch,
+    const Uint8 *Vplane, int Vpitch)
+{
+    return 0;
+}
+
+static int
+VITA_GXM_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture,
+    const SDL_Rect *rect, void **pixels, int *pitch)
+{
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
+    VITA_GXM_TextureData *vita_texture = (VITA_GXM_TextureData *) texture->driverdata;
+
+    *pixels =
+        (void *) ((Uint8 *) gxm_texture_get_datap(vita_texture->tex)
+            + (rect->y * vita_texture->pitch) + rect->x * SDL_BYTESPERPIXEL(texture->format));
+    *pitch = vita_texture->pitch;
+
+    // make sure that rendering is finished on render target textures
+    if (vita_texture->tex->gxm_rendertarget != NULL) {
+        sceGxmFinish(data->gxm_context);
+    }
+
+    return 0;
+}
+
+static void
+VITA_GXM_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    // No need to update texture data on ps vita.
+    // VITA_GXM_LockTexture already returns a pointer to the texture pixels buffer.
+    // This really improves framerate when using lock/unlock.
+}
+
+static void
+VITA_GXM_SetTextureScaleMode(SDL_Renderer * renderer, SDL_Texture * texture, SDL_ScaleMode scaleMode)
+{
+    VITA_GXM_TextureData *vita_texture = (VITA_GXM_TextureData *) texture->driverdata;
+
+    /*
+     set texture filtering according to scaleMode
+     suported hint values are nearest (0, default) or linear (1)
+     vitaScaleMode is either SCE_GXM_TEXTURE_FILTER_POINT (good for tile-map)
+     or SCE_GXM_TEXTURE_FILTER_LINEAR (good for scaling)
+     */
+
+    int vitaScaleMode = (scaleMode == SDL_ScaleModeNearest
+                        ? SCE_GXM_TEXTURE_FILTER_POINT
+                        : SCE_GXM_TEXTURE_FILTER_LINEAR);
+    gxm_texture_set_filters(vita_texture->tex, vitaScaleMode, vitaScaleMode);
+
+    return;
+}
+
+static int
+VITA_GXM_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    return 0;
+}
+
+static void
+VITA_GXM_SetBlendMode(VITA_GXM_RenderData *data, int blendMode)
+{
+    if (blendMode != data->currentBlendMode)
+    {
+        fragment_programs *in = &data->blendFragmentPrograms.blend_mode_blend;
+
+        switch (blendMode)
+        {
+            case SDL_BLENDMODE_NONE:
+                in = &data->blendFragmentPrograms.blend_mode_none;
+                break;
+            case SDL_BLENDMODE_BLEND:
+                in = &data->blendFragmentPrograms.blend_mode_blend;
+                break;
+            case SDL_BLENDMODE_ADD:
+                in = &data->blendFragmentPrograms.blend_mode_add;
+                break;
+            case SDL_BLENDMODE_MOD:
+                in = &data->blendFragmentPrograms.blend_mode_mod;
+                break;
+            case SDL_BLENDMODE_MUL:
+                in = &data->blendFragmentPrograms.blend_mode_mul;
+                break;
+        }
+        data->colorFragmentProgram = in->color;
+        data->textureFragmentProgram = in->texture;
+        data->currentBlendMode = blendMode;
+    }
+}
+
+static int
+VITA_GXM_QueueSetViewport(SDL_Renderer * renderer, SDL_RenderCommand *cmd)
+{
+    return 0;
+}
+
+static int
+VITA_GXM_QueueSetDrawColor(SDL_Renderer * renderer, SDL_RenderCommand *cmd)
+{
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
+
+    data->drawstate.color.r = cmd->data.color.r;
+    data->drawstate.color.g = cmd->data.color.g;
+    data->drawstate.color.b = cmd->data.color.b;
+    data->drawstate.color.a = cmd->data.color.a;
+
+    return 0;
+}
+
+static int
+VITA_GXM_QueueDrawPoints(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FPoint * points, int count)
+{
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
+
+    SDL_Color color = data->drawstate.color;
+
+    color_vertex *vertex = (color_vertex *)pool_malloc(
+        data,
+        count * sizeof(color_vertex)
+    );
+
+    cmd->data.draw.first = (size_t)vertex;
+    cmd->data.draw.count = count;
+
+    for (int i = 0; i < count; i++)
+    {
+        vertex[i].x = points[i].x;
+        vertex[i].y = points[i].y;
+        vertex[i].color = color;
+    }
+
+    return 0;
+}
+
+static int
+VITA_GXM_QueueDrawLines(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FPoint * points, int count)
+{
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
+    SDL_Color color = data->drawstate.color;
+
+    color_vertex *vertex = (color_vertex *)pool_malloc(
+        data,
+        (count-1) * 2 * sizeof(color_vertex)
+    );
+
+    cmd->data.draw.first = (size_t)vertex;
+    cmd->data.draw.count = (count-1) * 2;
+
+    for (int i = 0; i < count - 1; i++)
+    {
+        vertex[i*2].x = points[i].x;
+        vertex[i*2].y = points[i].y;
+        vertex[i*2].color = color;
+
+        vertex[i*2+1].x = points[i+1].x;
+        vertex[i*2+1].y = points[i+1].y;
+        vertex[i*2+1].color = color;
+    }
+
+    return 0;
+}
+
+static int
+VITA_GXM_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+        const float *xy, int xy_stride, const SDL_Color *color, int color_stride, const float *uv, int uv_stride,
+        int num_vertices, const void *indices, int num_indices, int size_indices,
+        float scale_x, float scale_y)
+{
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
+    int i;
+    int count = indices ? num_indices : num_vertices;
+
+    cmd->data.draw.count = count;
+    size_indices = indices ? size_indices : 0;
+
+    if (texture) {
+        texture_vertex *vertices;
+
+        vertices = (texture_vertex *)pool_malloc(
+                data,
+                count * sizeof(texture_vertex));
+
+        if (!vertices) {
+            return -1;
+        }
+
+
+        for (i = 0; i < count; i++) {
+            int j;
+            float *xy_;
+            float *uv_;
+            SDL_Color col_;
+            if (size_indices == 4) {
+                j = ((const Uint32 *)indices)[i];
+            } else if (size_indices == 2) {
+                j = ((const Uint16 *)indices)[i];
+            } else if (size_indices == 1) {
+                j = ((const Uint8 *)indices)[i];
+            } else {
+                j = i;
+            }
+
+            xy_ = (float *)((char*)xy + j * xy_stride);
+            col_ = *(SDL_Color *)((char*)color + j * color_stride);
+            uv_ = (float *)((char*)uv + j * uv_stride);
+
+            vertices[i].x = xy_[0] * scale_x;
+            vertices[i].y = xy_[1] * scale_y;
+            vertices[i].u = uv_[0];
+            vertices[i].v = uv_[1];
+            vertices[i].color = col_;
+        }
+
+        cmd->data.draw.first = (size_t)vertices;
+
+    } else {
+        color_vertex *vertices;
+
+        vertices = (color_vertex *)pool_malloc(
+                data,
+                count * sizeof(color_vertex));
+
+        if (!vertices) {
+            return -1;
+        }
+
+
+        for (i = 0; i < count; i++) {
+            int j;
+            float *xy_;
+            SDL_Color col_;
+            if (size_indices == 4) {
+                j = ((const Uint32 *)indices)[i];
+            } else if (size_indices == 2) {
+                j = ((const Uint16 *)indices)[i];
+            } else if (size_indices == 1) {
+                j = ((const Uint8 *)indices)[i];
+            } else {
+                j = i;
+            }
+
+            xy_ = (float *)((char*)xy + j * xy_stride);
+            col_ = *(SDL_Color *)((char*)color + j * color_stride);
+
+            vertices[i].x = xy_[0] * scale_x;
+            vertices[i].y = xy_[1] * scale_y;
+            vertices[i].color = col_;
+        }
+        cmd->data.draw.first = (size_t)vertices;
+    }
+
+
+    return 0;
+}
+
+static int
+VITA_GXM_RenderClear(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
+{
+    void *color_buffer;
+    float clear_color[4];
+
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
+    unset_clip_rectangle(data);
+
+    clear_color[0] = (cmd->data.color.r)/255.0f;
+    clear_color[1] = (cmd->data.color.g)/255.0f;
+    clear_color[2] = (cmd->data.color.b)/255.0f;
+    clear_color[3] = (cmd->data.color.a)/255.0f;
+
+    // set clear shaders
+    data->drawstate.fragment_program = data->clearFragmentProgram;
+    data->drawstate.vertex_program = data->clearVertexProgram;
+    sceGxmSetVertexProgram(data->gxm_context, data->clearVertexProgram);
+    sceGxmSetFragmentProgram(data->gxm_context, data->clearFragmentProgram);
+
+    // set the clear color
+    sceGxmReserveFragmentDefaultUniformBuffer(data->gxm_context, &color_buffer);
+    sceGxmSetUniformDataF(color_buffer, data->clearClearColorParam, 0, 4, clear_color);
+
+    // draw the clear triangle
+    sceGxmSetVertexStream(data->gxm_context, 0, data->clearVertices);
+    sceGxmDraw(data->gxm_context, SCE_GXM_PRIMITIVE_TRIANGLES, SCE_GXM_INDEX_FORMAT_U16, data->linearIndices, 3);
+
+    data->drawstate.cliprect_dirty = SDL_TRUE;
+    return 0;
+}
+
+
+static int
+SetDrawState(VITA_GXM_RenderData *data, const SDL_RenderCommand *cmd)
+{
+    SDL_Texture *texture = cmd->data.draw.texture;
+    const SDL_BlendMode blend = cmd->data.draw.blend;
+    SceGxmFragmentProgram *fragment_program;
+    SceGxmVertexProgram *vertex_program;
+    SDL_bool matrix_updated = SDL_FALSE;
+    SDL_bool program_updated = SDL_FALSE;
+
+    if (data->drawstate.viewport_dirty) {
+        const SDL_Rect *viewport = &data->drawstate.viewport;
+
+
+        float sw = viewport->w  / 2.;
+        float sh = viewport->h / 2.;
+
+        float x_scale = sw;
+        float x_off = viewport->x + sw;
+        float y_scale = -(sh);
+        float y_off = viewport->y + sh;
+
+        sceGxmSetViewport(data->gxm_context, x_off, x_scale, y_off, y_scale, 0.5f, 0.5f);
+
+        if (viewport->w && viewport->h) {
+            init_orthographic_matrix(data->ortho_matrix,
+                (float) 0,
+                (float) viewport->w,
+                (float) viewport->h,
+                (float) 0,
+                0.0f, 1.0f);
+            matrix_updated = SDL_TRUE;
+        }
+
+        data->drawstate.viewport_dirty = SDL_FALSE;
+    }
+
+    if (data->drawstate.cliprect_enabled_dirty) {
+        if (!data->drawstate.cliprect_enabled) {
+            unset_clip_rectangle(data);
+        }
+        data->drawstate.cliprect_enabled_dirty = SDL_FALSE;
+    }
+
+    if (data->drawstate.cliprect_enabled && data->drawstate.cliprect_dirty) {
+        const SDL_Rect *rect = &data->drawstate.cliprect;
+        set_clip_rectangle(data, rect->x, rect->y, rect->x + rect->w, rect->y + rect->h);
+        data->drawstate.cliprect_dirty = SDL_FALSE;
+    }
+
+    VITA_GXM_SetBlendMode(data, blend); // do that first, to select appropriate shaders
+
+    if (texture) {
+        vertex_program = data->textureVertexProgram;
+        fragment_program = data->textureFragmentProgram;
+    } else {
+        vertex_program = data->colorVertexProgram;
+        fragment_program = data->colorFragmentProgram;
+    }
+
+    if (data->drawstate.vertex_program != vertex_program) {
+        data->drawstate.vertex_program = vertex_program;
+        sceGxmSetVertexProgram(data->gxm_context, vertex_program);
+        program_updated = SDL_TRUE;
+    }
+
+    if (data->drawstate.fragment_program != fragment_program) {
+        data->drawstate.fragment_program = fragment_program;
+        sceGxmSetFragmentProgram(data->gxm_context, fragment_program);
+        program_updated = SDL_TRUE;
+    }
+
+
+    if (program_updated || matrix_updated) {
+        if (data->drawstate.fragment_program == data->textureFragmentProgram) {
+            void *vertex_wvp_buffer;
+            sceGxmReserveVertexDefaultUniformBuffer(data->gxm_context, &vertex_wvp_buffer);
+            sceGxmSetUniformDataF(vertex_wvp_buffer, data->textureWvpParam, 0, 16, data->ortho_matrix);
+        } else { // color
+            void *vertexDefaultBuffer;
+            sceGxmReserveVertexDefaultUniformBuffer(data->gxm_context, &vertexDefaultBuffer);
+            sceGxmSetUniformDataF(vertexDefaultBuffer, data->colorWvpParam, 0, 16, data->ortho_matrix);
+        }
+    }
+
+    if (texture != data->drawstate.texture) {
+        if (texture) {
+            VITA_GXM_TextureData *vita_texture = (VITA_GXM_TextureData *) cmd->data.draw.texture->driverdata;
+            sceGxmSetFragmentTexture(data->gxm_context, 0, &vita_texture->tex->gxm_tex);
+        }
+        data->drawstate.texture = texture;
+    }
+
+    /* all drawing commands use this */
+    sceGxmSetVertexStream(data->gxm_context, 0, (const void*)cmd->data.draw.first);
+
+    return 0;
+}
+
+static int
+SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd)
+{
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
+
+    return SetDrawState(data, cmd);
+}
+
+static int
+VITA_GXM_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
+{
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
+    StartDrawing(renderer);
+
+    data->drawstate.target = renderer->target;
+    if (!data->drawstate.target) {
+        int w, h;
+        SDL_GL_GetDrawableSize(renderer->window, &w, &h);
+        if ((w != data->drawstate.drawablew) || (h != data->drawstate.drawableh)) {
+            data->drawstate.viewport_dirty = SDL_TRUE;  // if the window dimensions changed, invalidate the current viewport, etc.
+            data->drawstate.cliprect_dirty = SDL_TRUE;
+            data->drawstate.drawablew = w;
+            data->drawstate.drawableh = h;
+        }
+
+    }
+
+    while (cmd) {
+        switch (cmd->command) {
+
+            case SDL_RENDERCMD_SETVIEWPORT: {
+                SDL_Rect *viewport = &data->drawstate.viewport;
+                if (SDL_memcmp(viewport, &cmd->data.viewport.rect, sizeof (SDL_Rect)) != 0) {
+                    SDL_memcpy(viewport, &cmd->data.viewport.rect, sizeof (SDL_Rect));
+                    data->drawstate.viewport_dirty = SDL_TRUE;
+                }
+                break;
+            }
+
+            case SDL_RENDERCMD_SETCLIPRECT: {
+                const SDL_Rect *rect = &cmd->data.cliprect.rect;
+                if (data->drawstate.cliprect_enabled != cmd->data.cliprect.enabled) {
+                    data->drawstate.cliprect_enabled = cmd->data.cliprect.enabled;
+                    data->drawstate.cliprect_enabled_dirty = SDL_TRUE;
+                }
+
+                if (SDL_memcmp(&data->drawstate.cliprect, rect, sizeof (SDL_Rect)) != 0) {
+                    SDL_memcpy(&data->drawstate.cliprect, rect, sizeof (SDL_Rect));
+                    data->drawstate.cliprect_dirty = SDL_TRUE;
+                }
+                break;
+            }
+
+            case SDL_RENDERCMD_SETDRAWCOLOR: {
+                break;
+            }
+
+            case SDL_RENDERCMD_CLEAR: {
+                VITA_GXM_RenderClear(renderer, cmd);
+                break;
+            }
+
+            case SDL_RENDERCMD_FILL_RECTS: /* unused */
+                break;
+
+            case SDL_RENDERCMD_COPY: /* unused */
+                break;
+
+            case SDL_RENDERCMD_COPY_EX: /* unused */
+                break;
+
+            case SDL_RENDERCMD_DRAW_POINTS:
+            case SDL_RENDERCMD_DRAW_LINES:
+            case SDL_RENDERCMD_GEOMETRY: {
+                SDL_Texture *thistexture = cmd->data.draw.texture;
+                SDL_BlendMode thisblend = cmd->data.draw.blend;
+                const SDL_RenderCommandType thiscmdtype = cmd->command;
+                SDL_RenderCommand *finalcmd = cmd;
+                SDL_RenderCommand *nextcmd = cmd->next;
+                size_t count = cmd->data.draw.count;
+                int ret;
+                while (nextcmd != NULL) {
+                    const SDL_RenderCommandType nextcmdtype = nextcmd->command;
+                    if (nextcmdtype != thiscmdtype) {
+                        break;  /* can't go any further on this draw call, different render command up next. */
+                    } else if (nextcmd->data.draw.texture != thistexture || nextcmd->data.draw.blend != thisblend) {
+                        break;  /* can't go any further on this draw call, different texture/blendmode copy up next. */
+                    } else {
+                        finalcmd = nextcmd;  /* we can combine copy operations here. Mark this one as the furthest okay command. */
+                        count += nextcmd->data.draw.count;
+                    }
+                    nextcmd = nextcmd->next;
+                }
+
+                if (thistexture) {
+                    ret = SetCopyState(renderer, cmd);
+                } else {
+                    ret = SetDrawState(data, cmd);
+                }
+
+                if (ret == 0) {
+                    int op = SCE_GXM_PRIMITIVE_TRIANGLES;
+
+                    if (thiscmdtype == SDL_RENDERCMD_DRAW_POINTS) {
+                        sceGxmSetFrontPolygonMode(data->gxm_context, SCE_GXM_POLYGON_MODE_POINT);
+                        op = SCE_GXM_PRIMITIVE_POINTS;
+                    } else if (thiscmdtype == SDL_RENDERCMD_DRAW_LINES) {
+                        sceGxmSetFrontPolygonMode(data->gxm_context, SCE_GXM_POLYGON_MODE_LINE);
+                        op = SCE_GXM_PRIMITIVE_LINES;
+                    }
+
+                    sceGxmDraw(data->gxm_context, op, SCE_GXM_INDEX_FORMAT_U16, data->linearIndices, count);
+
+                    if (thiscmdtype == SDL_RENDERCMD_DRAW_POINTS || thiscmdtype == SDL_RENDERCMD_DRAW_LINES) {
+                        sceGxmSetFrontPolygonMode(data->gxm_context, SCE_GXM_POLYGON_MODE_TRIANGLE_FILL);
+                    }
+
+                }
+
+                cmd = finalcmd;  /* skip any copy commands we just combined in here. */
+                break;
+            }
+
+            case SDL_RENDERCMD_NO_OP:
+                break;
+        }
+        data->drawstate.last_command = cmd->command;
+        cmd = cmd->next;
+    }
+
+    sceGxmEndScene(data->gxm_context, NULL, NULL);
+    data->drawing = SDL_FALSE;
+
+    return 0;
+}
+
+void read_pixels(int x, int y, size_t width, size_t height, void *data) {
+    SceDisplayFrameBuf pParam;
+    int i, j;
+    Uint32 *out32;
+    Uint32 *in32;
+
+    pParam.size = sizeof(SceDisplayFrameBuf);
+
+    sceDisplayGetFrameBuf(&pParam, SCE_DISPLAY_SETBUF_NEXTFRAME);
+
+    out32 = (Uint32 *)data;
+    in32 = (Uint32 *)pParam.base;
+
+    in32 += (x + y * pParam.pitch);
+
+    for (i = 0; i < height; i++) {
+        for (j = 0; j < width; j++) {
+            out32[(height - (i + 1)) * width + j] = in32[j];
+        }
+        in32 += pParam.pitch;
+    }
+}
+
+
+static int
+VITA_GXM_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect,
+    Uint32 pixel_format, void *pixels, int pitch)
+{
+    Uint32 temp_format = renderer->target ? renderer->target->format : SDL_PIXELFORMAT_ABGR8888;
+    size_t buflen;
+    void *temp_pixels;
+    int temp_pitch;
+    Uint8 *src, *dst, *tmp;
+    int w, h, length, rows;
+    int status;
+
+    // TODO: read from texture rendertarget. Although no-one sane should do it.
+    if (renderer->target) {
+        return SDL_Unsupported();
+    }
+
+
+    temp_pitch = rect->w * SDL_BYTESPERPIXEL(temp_format);
+    buflen = rect->h * temp_pitch;
+    if (buflen == 0) {
+        return 0;  /* nothing to do. */
+    }
+
+    temp_pixels = SDL_malloc(buflen);
+    if (!temp_pixels) {
+        return SDL_OutOfMemory();
+    }
+
+    SDL_GetRendererOutputSize(renderer, &w, &h);
+
+    read_pixels(rect->x, renderer->target ? rect->y : (h-rect->y)-rect->h,
+                       rect->w, rect->h, temp_pixels);
+
+    /* Flip the rows to be top-down if necessary */
+
+    if (!renderer->target) {
+        SDL_bool isstack;
+        length = rect->w * SDL_BYTESPERPIXEL(temp_format);
+        src = (Uint8*)temp_pixels + (rect->h-1)*temp_pitch;
+        dst = (Uint8*)temp_pixels;
+        tmp = SDL_small_alloc(Uint8, length, &isstack);
+        rows = rect->h / 2;
+        while (rows--) {
+            SDL_memcpy(tmp, dst, length);
+            SDL_memcpy(dst, src, length);
+            SDL_memcpy(src, tmp, length);
+            dst += temp_pitch;
+            src -= temp_pitch;
+        }
+        SDL_small_free(tmp, isstack);
+    }
+
+    status = SDL_ConvertPixels(rect->w, rect->h,
+                               temp_format, temp_pixels, temp_pitch,
+                               pixel_format, pixels, pitch);
+    SDL_free(temp_pixels);
+
+    return status;
+}
+
+
+static void
+VITA_GXM_RenderPresent(SDL_Renderer *renderer)
+{
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
+    SceCommonDialogUpdateParam updateParam;
+
+    data->displayData.address = data->displayBufferData[data->backBufferIndex];
+
+    SDL_memset(&updateParam, 0, sizeof(updateParam));
+
+    updateParam.renderTarget.colorFormat    = VITA_GXM_COLOR_FORMAT;
+    updateParam.renderTarget.surfaceType    = SCE_GXM_COLOR_SURFACE_LINEAR;
+    updateParam.renderTarget.width          = VITA_GXM_SCREEN_WIDTH;
+    updateParam.renderTarget.height         = VITA_GXM_SCREEN_HEIGHT;
+    updateParam.renderTarget.strideInPixels = VITA_GXM_SCREEN_STRIDE;
+
+    updateParam.renderTarget.colorSurfaceData = data->displayBufferData[data->backBufferIndex];
+    updateParam.renderTarget.depthSurfaceData = data->depthBufferData;
+
+    updateParam.displaySyncObject = (SceGxmSyncObject *)data->displayBufferSync[data->backBufferIndex];
+
+    sceCommonDialogUpdate(&updateParam);
+
+#if DEBUG_RAZOR
+    sceGxmPadHeartbeat(
+        (const SceGxmColorSurface *)&data->displaySurface[data->backBufferIndex],
+        (SceGxmSyncObject *)data->displayBufferSync[data->backBufferIndex]
+    );
+#endif
+
+    sceGxmDisplayQueueAddEntry(
+        data->displayBufferSync[data->frontBufferIndex],    // OLD fb
+        data->displayBufferSync[data->backBufferIndex],     // NEW fb
+        &data->displayData
+    );
+
+    // update buffer indices
+    data->frontBufferIndex = data->backBufferIndex;
+    data->backBufferIndex = (data->backBufferIndex + 1) % VITA_GXM_BUFFERS;
+    data->pool_index = 0;
+
+    data->current_pool = (data->current_pool + 1) % 2;
+}
+
+static void
+VITA_GXM_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
+    VITA_GXM_TextureData *vita_texture = (VITA_GXM_TextureData *) texture->driverdata;
+
+    if (data == 0)
+        return;
+
+    if(vita_texture == 0)
+        return;
+
+    if(vita_texture->tex == 0)
+        return;
+
+    sceGxmFinish(data->gxm_context);
+
+    free_gxm_texture(vita_texture->tex);
+
+    SDL_free(vita_texture);
+
+    texture->driverdata = NULL;
+}
+
+static void
+VITA_GXM_DestroyRenderer(SDL_Renderer *renderer)
+{
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
+    if (data) {
+        if (!data->initialized)
+            return;
+
+        gxm_finish(renderer);
+
+        data->initialized = SDL_FALSE;
+        data->drawing = SDL_FALSE;
+        SDL_free(data);
+    }
+    SDL_free(renderer);
+}
+
+#endif /* SDL_VIDEO_RENDER_VITA_GXM */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_memory.c b/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_memory.c
new file mode 100644
index 000000000..d3322730a
--- /dev/null
+++ b/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_memory.c
@@ -0,0 +1,117 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "../../SDL_internal.h"
+
+#if SDL_VIDEO_RENDER_VITA_GXM
+
+#include "SDL_render_vita_gxm_memory.h"
+
+void *
+mem_gpu_alloc(SceKernelMemBlockType type, unsigned int size, unsigned int alignment, unsigned int attribs, SceUID *uid)
+{
+    void *mem;
+
+    if (type == SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW) {
+        size = ALIGN(size, 256*1024);
+    } else {
+        size = ALIGN(size, 4*1024);
+    }
+
+    *uid = sceKernelAllocMemBlock("gpu_mem", type, size, NULL);
+
+    if (*uid < 0)
+        return NULL;
+
+    if (sceKernelGetMemBlockBase(*uid, &mem) < 0)
+        return NULL;
+
+    if (sceGxmMapMemory(mem, size, attribs) < 0)
+        return NULL;
+
+    return mem;
+}
+
+void
+mem_gpu_free(SceUID uid)
+{
+    void *mem = NULL;
+    if (sceKernelGetMemBlockBase(uid, &mem) < 0)
+        return;
+    sceGxmUnmapMemory(mem);
+    sceKernelFreeMemBlock(uid);
+}
+
+void *
+mem_vertex_usse_alloc(unsigned int size, SceUID *uid, unsigned int *usse_offset)
+{
+    void *mem = NULL;
+
+    size = ALIGN(size, 4096);
+    *uid = sceKernelAllocMemBlock("vertex_usse", SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, size, NULL);
+
+    if (sceKernelGetMemBlockBase(*uid, &mem) < 0)
+        return NULL;
+    if (sceGxmMapVertexUsseMemory(mem, size, usse_offset) < 0)
+        return NULL;
+
+    return mem;
+}
+
+void
+mem_vertex_usse_free(SceUID uid)
+{
+    void *mem = NULL;
+    if (sceKernelGetMemBlockBase(uid, &mem) < 0)
+        return;
+    sceGxmUnmapVertexUsseMemory(mem);
+    sceKernelFreeMemBlock(uid);
+}
+
+void *
+mem_fragment_usse_alloc(unsigned int size, SceUID *uid, unsigned int *usse_offset)
+{
+    void *mem = NULL;
+
+    size = ALIGN(size, 4096);
+    *uid = sceKernelAllocMemBlock("fragment_usse", SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, size, NULL);
+
+    if (sceKernelGetMemBlockBase(*uid, &mem) < 0)
+        return NULL;
+    if (sceGxmMapFragmentUsseMemory(mem, size, usse_offset) < 0)
+        return NULL;
+
+    return mem;
+}
+
+void
+mem_fragment_usse_free(SceUID uid)
+{
+    void *mem = NULL;
+    if (sceKernelGetMemBlockBase(uid, &mem) < 0)
+        return;
+    sceGxmUnmapFragmentUsseMemory(mem);
+    sceKernelFreeMemBlock(uid);
+}
+
+#endif /* SDL_VIDEO_RENDER_VITA_GXM */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_memory.h b/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_memory.h
new file mode 100644
index 000000000..51bc8a80a
--- /dev/null
+++ b/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_memory.h
@@ -0,0 +1,40 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_RENDER_VITA_GXM_MEMORY_H
+#define SDL_RENDER_VITA_GXM_MEMORY_H
+
+#include <psp2/gxm.h>
+#include <psp2/types.h>
+#include <psp2/kernel/sysmem.h>
+
+#define ALIGN(x, a) (((x) + ((a) - 1)) & ~((a) - 1))
+
+void *mem_gpu_alloc(SceKernelMemBlockType type, unsigned int size, unsigned int alignment, unsigned int attribs, SceUID *uid);
+void mem_gpu_free(SceUID uid);
+void *mem_vertex_usse_alloc(unsigned int size, SceUID *uid, unsigned int *usse_offset);
+void mem_vertex_usse_free(SceUID uid);
+void *mem_fragment_usse_alloc(unsigned int size, SceUID *uid, unsigned int *usse_offset);
+void mem_fragment_usse_free(SceUID uid);
+
+#endif /* SDL_RENDER_VITA_GXM_MEMORY_H */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_shaders.h b/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_shaders.h
new file mode 100644
index 000000000..f60ad1d55
--- /dev/null
+++ b/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_shaders.h
@@ -0,0 +1,280 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_RENDER_VITA_GXM_SHADERS_H
+#define SDL_RENDER_VITA_GXM_SHADERS_H
+
+#include <psp2/gxm.h>
+
+#define gxm_shader_clear_f_size 232
+static const unsigned char gxm_shader_clear_f[gxm_shader_clear_f_size] = {
+    0x47, 0x58, 0x50, 0x00, 0x01, 0x05, 0x50, 0x03, 
+    0xe8, 0x00, 0x00, 0x00, 0xa2, 0x55, 0x22, 0x3e, 
+    0xc6, 0x7e, 0x77, 0xf1, 0x01, 0x00, 0x18, 0x00, 
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 
+    0xa4, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 
+    0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 
+    0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x68, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 
+    0x5c, 0x00, 0x00, 0x00, 0xc0, 0x3d, 0x03, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 
+    0x01, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 
+    0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x07, 0x44, 0xfa, 0x02, 0x80, 0x19, 0xf0, 
+    0x7e, 0x0d, 0x80, 0x40, 0x0e, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 
+    0x01, 0xe4, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x75, 0x43, 0x6c, 0x65, 
+    0x61, 0x72, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x00, 
+};
+
+#define gxm_shader_clear_v_size 252
+static const unsigned char gxm_shader_clear_v[gxm_shader_clear_v_size] = {
+    0x47, 0x58, 0x50, 0x00, 0x01, 0x05, 0x50, 0x03, 
+    0xfa, 0x00, 0x00, 0x00, 0xdc, 0x25, 0x34, 0x74, 
+    0x53, 0x4a, 0x7a, 0x5b, 0x04, 0x00, 0x19, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 
+    0xb8, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 
+    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x01, 0x00, 0x04, 0x00, 0x00, 0x00, 
+    0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x74, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x78, 0x00, 0x00, 0x00, 0xc0, 0x3d, 0x03, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x5c, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x04, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x44, 0xfa, 
+    0x01, 0x00, 0x04, 0x90, 0x85, 0x11, 0xa5, 0x08, 
+    0x01, 0x80, 0x56, 0x90, 0x81, 0x11, 0x83, 0x08, 
+    0x00, 0x00, 0x20, 0xa0, 0x00, 0x50, 0x27, 0xfb, 
+    0x10, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x61, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 
+    0x6e, 0x00, 0x00, 0x00, 
+};
+
+#define gxm_shader_color_f_size 212
+static const unsigned char gxm_shader_color_f[gxm_shader_color_f_size] = {
+    0x47, 0x58, 0x50, 0x00, 0x01, 0x05, 0x50, 0x03, 
+    0xd4, 0x00, 0x00, 0x00, 0x9c, 0xd6, 0x9b, 0xf7, 
+    0x78, 0x00, 0x5d, 0x31, 0x01, 0x10, 0x18, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0xac, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 
+    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 
+    0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x78, 0x00, 0x00, 0x00, 0x74, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x6c, 0x00, 0x00, 0x00, 0xc0, 0x3d, 0x03, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 
+    0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 
+    0x0f, 0xa0, 0xd0, 0x0e, 0x00, 0x00, 0x00, 0x00, 
+    0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x07, 0x44, 0xfa, 0x02, 0x80, 0x19, 0xa0, 
+    0x7e, 0x0d, 0x80, 0x40, 
+};
+
+#define gxm_shader_color_v_size 368
+static const unsigned char gxm_shader_color_v[gxm_shader_color_v_size] = {
+    0x47, 0x58, 0x50, 0x00, 0x01, 0x05, 0x50, 0x03, 
+    0x6d, 0x01, 0x00, 0x00, 0x09, 0xce, 0x4e, 0xc2, 
+    0xe1, 0xcd, 0x24, 0xbc, 0x00, 0x00, 0x19, 0x00, 
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 
+    0x00, 0x01, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 
+    0x08, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x01, 0x00, 0x09, 0x00, 0x00, 0x00, 
+    0x98, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 
+    0x74, 0x00, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 
+    0xb8, 0x00, 0x00, 0x00, 0xc0, 0x3d, 0x03, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0xac, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0xac, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x9c, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x94, 0x00, 0x00, 0x00, 
+    0x01, 0x00, 0x00, 0x00, 0x8c, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0xf3, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0x00, 0x09, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x06, 0x43, 0x00, 0x61, 
+    0x86, 0x81, 0xa2, 0x00, 0x07, 0x53, 0x40, 0x61, 
+    0x86, 0x81, 0xa2, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x40, 0x01, 0x04, 0xf8, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x44, 0xfa, 
+    0x80, 0x00, 0x08, 0x83, 0x21, 0x1d, 0x80, 0x38, 
+    0x00, 0x00, 0xf0, 0x83, 0x20, 0x0d, 0x80, 0x38, 
+    0x0a, 0x84, 0xb9, 0xff, 0xbc, 0x0d, 0xc0, 0x40, 
+    0x02, 0x11, 0x45, 0xcf, 0x80, 0x8f, 0xb1, 0x18, 
+    0x00, 0x11, 0x01, 0xc0, 0x81, 0x81, 0xb1, 0x18, 
+    0x01, 0xd1, 0x42, 0xc0, 0x81, 0x81, 0xb1, 0x18, 
+    0x40, 0x00, 0x10, 0x41, 0x09, 0x05, 0x82, 0x38, 
+    0x00, 0x00, 0x20, 0xa0, 0x00, 0x50, 0x27, 0xfb, 
+    0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 
+    0x30, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x2a, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 
+    0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 
+    0x21, 0x00, 0x00, 0x00, 0x01, 0xe4, 0x00, 0x00, 
+    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x61, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 
+    0x6e, 0x00, 0x61, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 
+    0x00, 0x77, 0x76, 0x70, 0x00, 0x00, 0x00, 0x00, 
+};
+
+#define gxm_shader_texture_f_size 288
+static const unsigned char gxm_shader_texture_f[gxm_shader_texture_f_size] = {
+    0x47, 0x58, 0x50, 0x00, 0x01, 0x05, 0x50, 0x03, 
+    0x20, 0x01, 0x00, 0x00, 0xeb, 0x4f, 0xb5, 0xba, 
+    0x60, 0xb2, 0xd0, 0x8d, 0x05, 0x18, 0x18, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 
+    0xc4, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 
+    0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x01, 0x00, 0x05, 0x00, 0x00, 0x00, 
+    0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x78, 0x00, 0x00, 0x00, 0x74, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x84, 0x00, 0x00, 0x00, 0xc0, 0x3d, 0x03, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 
+    0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 
+    0x01, 0x00, 0x01, 0x00, 0x04, 0x00, 0x00, 0x00, 
+    0x00, 0xa9, 0xd0, 0x0e, 0x00, 0x00, 0x00, 0x00, 
+    0xf0, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x07, 0x44, 0xfa, 0x00, 0x00, 0x00, 0x00, 
+    0x40, 0x09, 0x00, 0xf8, 0x02, 0x80, 0x99, 0xaf, 
+    0xbc, 0x0d, 0xc0, 0x40, 0x06, 0x82, 0xb9, 0xaf, 
+    0xbc, 0x0d, 0x80, 0x40, 0x7c, 0x0f, 0x04, 0x00, 
+    0x86, 0x47, 0xa4, 0x10, 0x30, 0x00, 0x00, 0x00, 
+    0x02, 0x04, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x74, 0x65, 0x78, 0x00, 
+};
+
+#define gxm_shader_texture_v_size 400
+static const unsigned char gxm_shader_texture_v[gxm_shader_texture_v_size] = {
+    0x47, 0x58, 0x50, 0x00, 0x01, 0x05, 0x50, 0x03, 
+    0x8f, 0x01, 0x00, 0x00, 0x60, 0x1e, 0x69, 0x97, 
+    0x82, 0x7e, 0x0c, 0xac, 0x00, 0x00, 0x19, 0x00, 
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 
+    0x08, 0x01, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 
+    0x0c, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x01, 0x00, 0x0a, 0x00, 0x00, 0x00, 
+    0x98, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 
+    0x74, 0x00, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 
+    0xc0, 0x00, 0x00, 0x00, 0xc0, 0x3d, 0x03, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x9c, 0x00, 0x00, 0x00, 
+    0x01, 0x00, 0x00, 0x00, 0x94, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x33, 0x0f, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x0a, 
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x06, 0x43, 0x00, 0x61, 
+    0x86, 0x81, 0xa2, 0x00, 0x07, 0x53, 0x40, 0x61, 
+    0x86, 0x81, 0xa2, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x40, 0x01, 0x04, 0xf8, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x44, 0xfa, 
+    0x01, 0x0e, 0x01, 0x01, 0x02, 0x00, 0x10, 0xfa, 
+    0x80, 0x00, 0x08, 0x83, 0x21, 0x25, 0x80, 0x38, 
+    0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x14, 0xfa, 
+    0x00, 0x00, 0xf0, 0x83, 0x20, 0x0d, 0x80, 0x38, 
+    0x0a, 0x84, 0xb9, 0xff, 0xbc, 0x0d, 0xc0, 0x40, 
+    0x02, 0x11, 0x45, 0xcf, 0x80, 0x8f, 0xb1, 0x18, 
+    0x00, 0x11, 0x01, 0xc0, 0x81, 0x81, 0xb1, 0x18, 
+    0x01, 0xd1, 0x42, 0xc0, 0x81, 0x81, 0xb1, 0x18, 
+    0x00, 0x00, 0x20, 0xa0, 0x00, 0x50, 0x27, 0xfb, 
+    0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 
+    0x40, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x3a, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 
+    0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 
+    0x34, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 
+    0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 
+    0x2b, 0x00, 0x00, 0x00, 0x01, 0xe4, 0x00, 0x00, 
+    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x61, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 
+    0x6e, 0x00, 0x61, 0x54, 0x65, 0x78, 0x63, 0x6f, 
+    0x6f, 0x72, 0x64, 0x00, 0x61, 0x43, 0x6f, 0x6c, 
+    0x6f, 0x72, 0x00, 0x77, 0x76, 0x70, 0x00, 0x00, 
+};
+
+static const SceGxmProgram *const clearVertexProgramGxp         = (const SceGxmProgram *)gxm_shader_clear_v;
+static const SceGxmProgram *const clearFragmentProgramGxp       = (const SceGxmProgram *)gxm_shader_clear_f;
+static const SceGxmProgram *const colorVertexProgramGxp         = (const SceGxmProgram *)gxm_shader_color_v;
+static const SceGxmProgram *const colorFragmentProgramGxp       = (const SceGxmProgram *)gxm_shader_color_f;
+static const SceGxmProgram *const textureVertexProgramGxp       = (const SceGxmProgram *)gxm_shader_texture_v;
+static const SceGxmProgram *const textureFragmentProgramGxp     = (const SceGxmProgram *)gxm_shader_texture_f;
+
+#endif // SDL_RENDER_VITA_GXM_SHADERS_H
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_tools.c b/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_tools.c
new file mode 100644
index 000000000..e043b55ab
--- /dev/null
+++ b/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_tools.c
@@ -0,0 +1,1239 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if SDL_VIDEO_RENDER_VITA_GXM
+
+#include "SDL_hints.h"
+#include "../SDL_sysrender.h"
+#include "SDL_log.h"
+
+#include <psp2/kernel/processmgr.h>
+#include <psp2/appmgr.h>
+#include <psp2/display.h>
+#include <psp2/gxm.h>
+#include <psp2/types.h>
+#include <psp2/kernel/sysmem.h>
+#include <psp2/message_dialog.h>
+
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <stdarg.h>
+#include <stdlib.h>
+
+#include "SDL_render_vita_gxm_tools.h"
+#include "SDL_render_vita_gxm_types.h"
+#include "SDL_render_vita_gxm_memory.h"
+#include "SDL_render_vita_gxm_shaders.h"
+
+void
+init_orthographic_matrix(float *m, float left, float right, float bottom, float top, float near, float far)
+{
+    m[0x0] = 2.0f/(right-left);
+    m[0x4] = 0.0f;
+    m[0x8] = 0.0f;
+    m[0xC] = -(right+left)/(right-left);
+
+    m[0x1] = 0.0f;
+    m[0x5] = 2.0f/(top-bottom);
+    m[0x9] = 0.0f;
+    m[0xD] = -(top+bottom)/(top-bottom);
+
+    m[0x2] = 0.0f;
+    m[0x6] = 0.0f;
+    m[0xA] = -2.0f/(far-near);
+    m[0xE] = (far+near)/(far-near);
+
+    m[0x3] = 0.0f;
+    m[0x7] = 0.0f;
+    m[0xB] = 0.0f;
+    m[0xF] = 1.0f;
+}
+
+static void *
+patcher_host_alloc(void *user_data, unsigned int size)
+{
+    void *mem = SDL_malloc(size);
+    (void)user_data;
+    return mem;
+}
+
+static void
+patcher_host_free(void *user_data, void *mem)
+{
+    (void)user_data;
+    SDL_free(mem);
+}
+
+void *
+pool_malloc(VITA_GXM_RenderData *data, unsigned int size)
+{
+
+    if ((data->pool_index + size) < VITA_GXM_POOL_SIZE) {
+        void *addr = (void *)((unsigned int)data->pool_addr[data->current_pool] + data->pool_index);
+        data->pool_index += size;
+        return addr;
+    }
+    SDL_LogError(SDL_LOG_CATEGORY_RENDER, "POOL OVERFLOW\n");
+    return NULL;
+}
+
+void *
+pool_memalign(VITA_GXM_RenderData *data, unsigned int size, unsigned int alignment)
+{
+    unsigned int new_index = (data->pool_index + alignment - 1) & ~(alignment - 1);
+    if ((new_index + size) < VITA_GXM_POOL_SIZE) {
+        void *addr = (void *)((unsigned int)data->pool_addr[data->current_pool] + new_index);
+        data->pool_index = new_index + size;
+        return addr;
+    }
+    SDL_LogError(SDL_LOG_CATEGORY_RENDER, "POOL OVERFLOW\n");
+    return NULL;
+}
+
+static int
+tex_format_to_bytespp(SceGxmTextureFormat format)
+{
+    switch (format & 0x9f000000U) {
+    case SCE_GXM_TEXTURE_BASE_FORMAT_U8:
+    case SCE_GXM_TEXTURE_BASE_FORMAT_S8:
+    case SCE_GXM_TEXTURE_BASE_FORMAT_P8:
+        return 1;
+    case SCE_GXM_TEXTURE_BASE_FORMAT_U4U4U4U4:
+    case SCE_GXM_TEXTURE_BASE_FORMAT_U8U3U3U2:
+    case SCE_GXM_TEXTURE_BASE_FORMAT_U1U5U5U5:
+    case SCE_GXM_TEXTURE_BASE_FORMAT_U5U6U5:
+    case SCE_GXM_TEXTURE_BASE_FORMAT_S5S5U6:
+    case SCE_GXM_TEXTURE_BASE_FORMAT_U8U8:
+    case SCE_GXM_TEXTURE_BASE_FORMAT_S8S8:
+        return 2;
+    case SCE_GXM_TEXTURE_BASE_FORMAT_U8U8U8:
+    case SCE_GXM_TEXTURE_BASE_FORMAT_S8S8S8:
+        return 3;
+    case SCE_GXM_TEXTURE_BASE_FORMAT_U8U8U8U8:
+    case SCE_GXM_TEXTURE_BASE_FORMAT_S8S8S8S8:
+    case SCE_GXM_TEXTURE_BASE_FORMAT_F32:
+    case SCE_GXM_TEXTURE_BASE_FORMAT_U32:
+    case SCE_GXM_TEXTURE_BASE_FORMAT_S32:
+    default:
+        return 4;
+    }
+}
+
+static void
+display_callback(const void *callback_data)
+{
+    SceDisplayFrameBuf framebuf;
+    const VITA_GXM_DisplayData *display_data = (const VITA_GXM_DisplayData *)callback_data;
+
+    SDL_memset(&framebuf, 0x00, sizeof(SceDisplayFrameBuf));
+    framebuf.size        = sizeof(SceDisplayFrameBuf);
+    framebuf.base        = display_data->address;
+    framebuf.pitch       = VITA_GXM_SCREEN_STRIDE;
+    framebuf.pixelformat = VITA_GXM_PIXEL_FORMAT;
+    framebuf.width       = VITA_GXM_SCREEN_WIDTH;
+    framebuf.height      = VITA_GXM_SCREEN_HEIGHT;
+    sceDisplaySetFrameBuf(&framebuf, SCE_DISPLAY_SETBUF_NEXTFRAME);
+
+    if (display_data->wait_vblank) {
+        sceDisplayWaitVblankStart();
+    }
+}
+
+static void
+free_fragment_programs(VITA_GXM_RenderData *data, fragment_programs *out)
+{
+    sceGxmShaderPatcherReleaseFragmentProgram(data->shaderPatcher, out->color);
+    sceGxmShaderPatcherReleaseFragmentProgram(data->shaderPatcher, out->texture);
+}
+
+static void
+make_fragment_programs(VITA_GXM_RenderData *data, fragment_programs *out,
+    const SceGxmBlendInfo *blend_info)
+{
+    int err;
+
+    err = sceGxmShaderPatcherCreateFragmentProgram(
+        data->shaderPatcher,
+        data->colorFragmentProgramId,
+        SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4,
+        0,
+        blend_info,
+        colorVertexProgramGxp,
+        &out->color
+    );
+
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "Patcher create fragment failed: %d\n", err);
+        return;
+    }
+
+    err = sceGxmShaderPatcherCreateFragmentProgram(
+        data->shaderPatcher,
+        data->textureFragmentProgramId,
+        SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4,
+        0,
+        blend_info,
+        textureVertexProgramGxp,
+        &out->texture
+    );
+
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "Patcher create fragment failed: %d\n", err);
+        return;
+    }
+}
+
+
+static void
+set_stencil_mask(VITA_GXM_RenderData *data, float x, float y, float w, float h)
+{
+    void *vertexDefaultBuffer;
+    color_vertex *vertices = (color_vertex *)pool_memalign(
+        data,
+        4 * sizeof(color_vertex), // 4 vertices
+        sizeof(color_vertex)
+    );
+
+    vertices[0].x = x;
+    vertices[0].y = y;
+    vertices[0].color.r = 0;
+    vertices[0].color.g = 0;
+    vertices[0].color.b = 0;
+    vertices[0].color.a = 0;
+
+    vertices[1].x = x + w;
+    vertices[1].y = y;
+    vertices[1].color.r = 0;
+    vertices[1].color.g = 0;
+    vertices[1].color.b = 0;
+    vertices[1].color.a = 0;
+
+    vertices[2].x = x;
+    vertices[2].y = y + h;
+    vertices[2].color.r = 0;
+    vertices[2].color.g = 0;
+    vertices[2].color.b = 0;
+    vertices[2].color.a = 0;
+
+    vertices[3].x = x + w;
+    vertices[3].y = y + h;
+    vertices[3].color.r = 0;
+    vertices[3].color.g = 0;
+    vertices[3].color.b = 0;
+    vertices[3].color.a = 0;
+
+    data->drawstate.fragment_program = data->colorFragmentProgram;
+    data->drawstate.vertex_program = data->colorVertexProgram;
+    sceGxmSetVertexProgram(data->gxm_context, data->colorVertexProgram);
+    sceGxmSetFragmentProgram(data->gxm_context, data->colorFragmentProgram);
+
+    sceGxmReserveVertexDefaultUniformBuffer(data->gxm_context, &vertexDefaultBuffer);
+    sceGxmSetUniformDataF(vertexDefaultBuffer, data->colorWvpParam, 0, 16, data->ortho_matrix);
+
+    sceGxmSetVertexStream(data->gxm_context, 0, vertices);
+    sceGxmDraw(data->gxm_context, SCE_GXM_PRIMITIVE_TRIANGLE_STRIP, SCE_GXM_INDEX_FORMAT_U16, data->linearIndices, 4);
+}
+
+
+void
+set_clip_rectangle(VITA_GXM_RenderData *data, int x_min, int y_min, int x_max, int y_max)
+{
+    if(data->drawing) {
+        // clear the stencil buffer to 0
+        sceGxmSetFrontStencilFunc(
+            data->gxm_context,
+            SCE_GXM_STENCIL_FUNC_NEVER,
+            SCE_GXM_STENCIL_OP_ZERO,
+            SCE_GXM_STENCIL_OP_ZERO,
+            SCE_GXM_STENCIL_OP_ZERO,
+            0xFF,
+            0xFF
+        );
+
+        set_stencil_mask(data, 0, 0, VITA_GXM_SCREEN_WIDTH, VITA_GXM_SCREEN_HEIGHT);
+
+        // set the stencil to 1 in the desired region
+        sceGxmSetFrontStencilFunc(
+            data->gxm_context,
+            SCE_GXM_STENCIL_FUNC_NEVER,
+            SCE_GXM_STENCIL_OP_REPLACE,
+            SCE_GXM_STENCIL_OP_REPLACE,
+            SCE_GXM_STENCIL_OP_REPLACE,
+            0xFF,
+            0xFF
+        );
+
+        set_stencil_mask(data, x_min, y_min, x_max - x_min, y_max - y_min);
+
+        // set the stencil function to only accept pixels where the stencil is 1
+        sceGxmSetFrontStencilFunc(
+            data->gxm_context,
+            SCE_GXM_STENCIL_FUNC_EQUAL,
+            SCE_GXM_STENCIL_OP_KEEP,
+            SCE_GXM_STENCIL_OP_KEEP,
+            SCE_GXM_STENCIL_OP_KEEP,
+            0xFF,
+            0xFF
+        );
+    }
+}
+
+void
+unset_clip_rectangle(VITA_GXM_RenderData *data)
+{
+    sceGxmSetFrontStencilFunc(
+        data->gxm_context,
+        SCE_GXM_STENCIL_FUNC_ALWAYS,
+        SCE_GXM_STENCIL_OP_KEEP,
+        SCE_GXM_STENCIL_OP_KEEP,
+        SCE_GXM_STENCIL_OP_KEEP,
+        0xFF,
+        0xFF
+    );
+}
+
+int
+gxm_init(SDL_Renderer *renderer)
+{
+    unsigned int i, x, y;
+    int err;
+    void *vdmRingBuffer;
+    void *vertexRingBuffer;
+    void *fragmentRingBuffer;
+    unsigned int fragmentUsseRingBufferOffset;
+    void *fragmentUsseRingBuffer;
+    unsigned int patcherVertexUsseOffset;
+    unsigned int patcherFragmentUsseOffset;
+    void *patcherBuffer;
+    void *patcherVertexUsse;
+    void *patcherFragmentUsse;
+
+    SceGxmRenderTargetParams renderTargetParams;
+    SceGxmShaderPatcherParams patcherParams;
+
+    // compute the memory footprint of the depth buffer
+    const unsigned int alignedWidth = ALIGN(VITA_GXM_SCREEN_WIDTH, SCE_GXM_TILE_SIZEX);
+    const unsigned int alignedHeight = ALIGN(VITA_GXM_SCREEN_HEIGHT, SCE_GXM_TILE_SIZEY);
+
+    unsigned int sampleCount = alignedWidth * alignedHeight;
+    unsigned int depthStrideInSamples = alignedWidth;
+
+    // set buffer sizes for this sample
+    const unsigned int patcherBufferSize        = 64*1024;
+    const unsigned int patcherVertexUsseSize    = 64*1024;
+    const unsigned int patcherFragmentUsseSize  = 64*1024;
+
+    // Fill SceGxmBlendInfo
+    static const SceGxmBlendInfo blend_info_none = {
+        .colorFunc = SCE_GXM_BLEND_FUNC_NONE,
+        .alphaFunc = SCE_GXM_BLEND_FUNC_NONE,
+        .colorSrc  = SCE_GXM_BLEND_FACTOR_ZERO,
+        .colorDst  = SCE_GXM_BLEND_FACTOR_ZERO,
+        .alphaSrc  = SCE_GXM_BLEND_FACTOR_ZERO,
+        .alphaDst  = SCE_GXM_BLEND_FACTOR_ZERO,
+        .colorMask = SCE_GXM_COLOR_MASK_ALL
+    };
+
+    static const SceGxmBlendInfo blend_info_blend = {
+        .colorFunc = SCE_GXM_BLEND_FUNC_ADD,
+        .alphaFunc = SCE_GXM_BLEND_FUNC_ADD,
+        .colorSrc  = SCE_GXM_BLEND_FACTOR_SRC_ALPHA,
+        .colorDst  = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
+        .alphaSrc  = SCE_GXM_BLEND_FACTOR_ONE,
+        .alphaDst  = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
+        .colorMask = SCE_GXM_COLOR_MASK_ALL
+    };
+
+    static const SceGxmBlendInfo blend_info_add = {
+        .colorFunc = SCE_GXM_BLEND_FUNC_ADD,
+        .alphaFunc = SCE_GXM_BLEND_FUNC_ADD,
+        .colorSrc  = SCE_GXM_BLEND_FACTOR_SRC_ALPHA,
+        .colorDst  = SCE_GXM_BLEND_FACTOR_ONE,
+        .alphaSrc  = SCE_GXM_BLEND_FACTOR_ZERO,
+        .alphaDst  = SCE_GXM_BLEND_FACTOR_ONE,
+        .colorMask = SCE_GXM_COLOR_MASK_ALL
+    };
+
+    static const SceGxmBlendInfo blend_info_mod = {
+        .colorFunc = SCE_GXM_BLEND_FUNC_ADD,
+        .alphaFunc = SCE_GXM_BLEND_FUNC_ADD,
+
+        .colorSrc  = SCE_GXM_BLEND_FACTOR_ZERO,
+        .colorDst  = SCE_GXM_BLEND_FACTOR_SRC_COLOR,
+
+        .alphaSrc  = SCE_GXM_BLEND_FACTOR_ZERO,
+        .alphaDst  = SCE_GXM_BLEND_FACTOR_ONE,
+        .colorMask = SCE_GXM_COLOR_MASK_ALL
+    };
+
+    static const SceGxmBlendInfo blend_info_mul = {
+        .colorFunc = SCE_GXM_BLEND_FUNC_ADD,
+        .alphaFunc = SCE_GXM_BLEND_FUNC_ADD,
+        .colorSrc  = SCE_GXM_BLEND_FACTOR_DST_COLOR,
+        .colorDst  = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
+        .alphaSrc  = SCE_GXM_BLEND_FACTOR_DST_ALPHA,
+        .alphaDst  = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
+        .colorMask = SCE_GXM_COLOR_MASK_ALL
+    };
+
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
+
+    SceGxmInitializeParams initializeParams;
+    SDL_memset(&initializeParams, 0, sizeof(SceGxmInitializeParams));
+    initializeParams.flags                          = 0;
+    initializeParams.displayQueueMaxPendingCount    = VITA_GXM_PENDING_SWAPS;
+    initializeParams.displayQueueCallback           = display_callback;
+    initializeParams.displayQueueCallbackDataSize   = sizeof(VITA_GXM_DisplayData);
+    initializeParams.parameterBufferSize            = SCE_GXM_DEFAULT_PARAMETER_BUFFER_SIZE;
+
+    err = sceGxmInitialize(&initializeParams);
+
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "gxm init failed: %d\n", err);
+        return err;
+    }
+
+    // allocate ring buffer memory using default sizes
+    vdmRingBuffer = mem_gpu_alloc(
+        SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
+        SCE_GXM_DEFAULT_VDM_RING_BUFFER_SIZE,
+        4,
+        SCE_GXM_MEMORY_ATTRIB_READ,
+        &data->vdmRingBufferUid);
+
+    vertexRingBuffer = mem_gpu_alloc(
+        SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
+        SCE_GXM_DEFAULT_VERTEX_RING_BUFFER_SIZE,
+        4,
+        SCE_GXM_MEMORY_ATTRIB_READ,
+        &data->vertexRingBufferUid);
+
+    fragmentRingBuffer = mem_gpu_alloc(
+        SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
+        SCE_GXM_DEFAULT_FRAGMENT_RING_BUFFER_SIZE,
+        4,
+        SCE_GXM_MEMORY_ATTRIB_READ,
+        &data->fragmentRingBufferUid);
+
+    fragmentUsseRingBuffer = mem_fragment_usse_alloc(
+        SCE_GXM_DEFAULT_FRAGMENT_USSE_RING_BUFFER_SIZE,
+        &data->fragmentUsseRingBufferUid,
+        &fragmentUsseRingBufferOffset);
+
+    SDL_memset(&data->contextParams, 0, sizeof(SceGxmContextParams));
+    data->contextParams.hostMem                       = SDL_malloc(SCE_GXM_MINIMUM_CONTEXT_HOST_MEM_SIZE);
+    data->contextParams.hostMemSize                   = SCE_GXM_MINIMUM_CONTEXT_HOST_MEM_SIZE;
+    data->contextParams.vdmRingBufferMem              = vdmRingBuffer;
+    data->contextParams.vdmRingBufferMemSize          = SCE_GXM_DEFAULT_VDM_RING_BUFFER_SIZE;
+    data->contextParams.vertexRingBufferMem           = vertexRingBuffer;
+    data->contextParams.vertexRingBufferMemSize       = SCE_GXM_DEFAULT_VERTEX_RING_BUFFER_SIZE;
+    data->contextParams.fragmentRingBufferMem         = fragmentRingBuffer;
+    data->contextParams.fragmentRingBufferMemSize     = SCE_GXM_DEFAULT_FRAGMENT_RING_BUFFER_SIZE;
+    data->contextParams.fragmentUsseRingBufferMem     = fragmentUsseRingBuffer;
+    data->contextParams.fragmentUsseRingBufferMemSize = SCE_GXM_DEFAULT_FRAGMENT_USSE_RING_BUFFER_SIZE;
+    data->contextParams.fragmentUsseRingBufferOffset  = fragmentUsseRingBufferOffset;
+
+    err = sceGxmCreateContext(&data->contextParams, &data->gxm_context);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "create context failed: %d\n", err);
+        return err;
+    }
+
+    // set up parameters
+    SDL_memset(&renderTargetParams, 0, sizeof(SceGxmRenderTargetParams));
+    renderTargetParams.flags                = 0;
+    renderTargetParams.width                = VITA_GXM_SCREEN_WIDTH;
+    renderTargetParams.height               = VITA_GXM_SCREEN_HEIGHT;
+    renderTargetParams.scenesPerFrame       = 1;
+    renderTargetParams.multisampleMode      = 0;
+    renderTargetParams.multisampleLocations = 0;
+    renderTargetParams.driverMemBlock       = -1; // Invalid UID
+
+    // create the render target
+    err = sceGxmCreateRenderTarget(&renderTargetParams, &data->renderTarget);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "render target creation failed: %d\n", err);
+        return err;
+    }
+
+    // allocate memory and sync objects for display buffers
+    for (i = 0; i < VITA_GXM_BUFFERS; i++) {
+
+        // allocate memory for display
+        data->displayBufferData[i] = mem_gpu_alloc(
+            SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW,
+            4 * VITA_GXM_SCREEN_STRIDE * VITA_GXM_SCREEN_HEIGHT,
+            SCE_GXM_COLOR_SURFACE_ALIGNMENT,
+            SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE,
+            &data->displayBufferUid[i]);
+
+        // SDL_memset the buffer to black
+        for (y = 0; y < VITA_GXM_SCREEN_HEIGHT; y++) {
+            unsigned int *row = (unsigned int *)data->displayBufferData[i] + y * VITA_GXM_SCREEN_STRIDE;
+            for (x = 0; x < VITA_GXM_SCREEN_WIDTH; x++) {
+                row[x] = 0xff000000;
+            }
+        }
+
+        // initialize a color surface for this display buffer
+        err = sceGxmColorSurfaceInit(
+            &data->displaySurface[i],
+            VITA_GXM_COLOR_FORMAT,
+            SCE_GXM_COLOR_SURFACE_LINEAR,
+            SCE_GXM_COLOR_SURFACE_SCALE_NONE,
+            SCE_GXM_OUTPUT_REGISTER_SIZE_32BIT,
+            VITA_GXM_SCREEN_WIDTH,
+            VITA_GXM_SCREEN_HEIGHT,
+            VITA_GXM_SCREEN_STRIDE,
+            data->displayBufferData[i]
+        );
+
+        if (err != 0) {
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "color surface init failed: %d\n", err);
+            return err;
+        }
+
+
+        // create a sync object that we will associate with this buffer
+        err = sceGxmSyncObjectCreate(&data->displayBufferSync[i]);
+        if (err != 0) {
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "sync object creation failed: %d\n", err);
+            return err;
+        }
+
+    }
+
+
+    // allocate the depth buffer
+    data->depthBufferData = mem_gpu_alloc(
+        SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
+        4 * sampleCount,
+        SCE_GXM_DEPTHSTENCIL_SURFACE_ALIGNMENT,
+        SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE,
+        &data->depthBufferUid);
+
+    // allocate the stencil buffer
+    data->stencilBufferData = mem_gpu_alloc(
+        SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
+        4 * sampleCount,
+        SCE_GXM_DEPTHSTENCIL_SURFACE_ALIGNMENT,
+        SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE,
+        &data->stencilBufferUid);
+
+    // create the SceGxmDepthStencilSurface structure
+    err = sceGxmDepthStencilSurfaceInit(
+        &data->depthSurface,
+        SCE_GXM_DEPTH_STENCIL_FORMAT_S8D24,
+        SCE_GXM_DEPTH_STENCIL_SURFACE_TILED,
+        depthStrideInSamples,
+        data->depthBufferData,
+        data->stencilBufferData);
+
+    // set the stencil test reference (this is currently assumed to always remain 1 after here for region clipping)
+    sceGxmSetFrontStencilRef(data->gxm_context, 1);
+
+
+    // set the stencil function (this wouldn't actually be needed, as the set clip rectangle function has to call this at the begginning of every scene)
+    sceGxmSetFrontStencilFunc(
+        data->gxm_context,
+        SCE_GXM_STENCIL_FUNC_ALWAYS,
+        SCE_GXM_STENCIL_OP_KEEP,
+        SCE_GXM_STENCIL_OP_KEEP,
+        SCE_GXM_STENCIL_OP_KEEP,
+        0xFF,
+        0xFF);
+
+
+    // allocate memory for buffers and USSE code
+    patcherBuffer = mem_gpu_alloc(
+        SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
+        patcherBufferSize,
+        4,
+        SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE,
+        &data->patcherBufferUid);
+
+    patcherVertexUsse = mem_vertex_usse_alloc(
+        patcherVertexUsseSize,
+        &data->patcherVertexUsseUid,
+        &patcherVertexUsseOffset);
+
+    patcherFragmentUsse = mem_fragment_usse_alloc(
+        patcherFragmentUsseSize,
+        &data->patcherFragmentUsseUid,
+        &patcherFragmentUsseOffset);
+
+    // create a shader patcher
+    SDL_memset(&patcherParams, 0, sizeof(SceGxmShaderPatcherParams));
+    patcherParams.userData                  = NULL;
+    patcherParams.hostAllocCallback         = &patcher_host_alloc;
+    patcherParams.hostFreeCallback          = &patcher_host_free;
+    patcherParams.bufferAllocCallback       = NULL;
+    patcherParams.bufferFreeCallback        = NULL;
+    patcherParams.bufferMem                 = patcherBuffer;
+    patcherParams.bufferMemSize             = patcherBufferSize;
+    patcherParams.vertexUsseAllocCallback   = NULL;
+    patcherParams.vertexUsseFreeCallback    = NULL;
+    patcherParams.vertexUsseMem             = patcherVertexUsse;
+    patcherParams.vertexUsseMemSize         = patcherVertexUsseSize;
+    patcherParams.vertexUsseOffset          = patcherVertexUsseOffset;
+    patcherParams.fragmentUsseAllocCallback = NULL;
+    patcherParams.fragmentUsseFreeCallback  = NULL;
+    patcherParams.fragmentUsseMem           = patcherFragmentUsse;
+    patcherParams.fragmentUsseMemSize       = patcherFragmentUsseSize;
+    patcherParams.fragmentUsseOffset        = patcherFragmentUsseOffset;
+
+    err = sceGxmShaderPatcherCreate(&patcherParams, &data->shaderPatcher);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "shader patcher creation failed: %d\n", err);
+        return err;
+    }
+
+
+    // check the shaders
+    err = sceGxmProgramCheck(clearVertexProgramGxp);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "check program (clear vertex) failed: %d\n", err);
+        return err;
+    }
+
+    err = sceGxmProgramCheck(clearFragmentProgramGxp);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "check program (clear fragment) failed: %d\n", err);
+        return err;
+    }
+
+    err = sceGxmProgramCheck(colorVertexProgramGxp);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "check program (color vertex) failed: %d\n", err);
+        return err;
+    }
+
+    err = sceGxmProgramCheck(colorFragmentProgramGxp);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "check program (color fragment) failed: %d\n", err);
+        return err;
+    }
+
+    err = sceGxmProgramCheck(textureVertexProgramGxp);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "check program (texture vertex) failed: %d\n", err);
+        return err;
+    }
+
+    err = sceGxmProgramCheck(textureFragmentProgramGxp);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "check program (texture fragment) failed: %d\n", err);
+        return err;
+    }
+
+    // register programs with the patcher
+    err = sceGxmShaderPatcherRegisterProgram(data->shaderPatcher, clearVertexProgramGxp, &data->clearVertexProgramId);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "register program (clear vertex) failed: %d\n", err);
+        return err;
+    }
+
+    err = sceGxmShaderPatcherRegisterProgram(data->shaderPatcher, clearFragmentProgramGxp, &data->clearFragmentProgramId);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "register program (clear fragment) failed: %d\n", err);
+        return err;
+    }
+
+    err = sceGxmShaderPatcherRegisterProgram(data->shaderPatcher, colorVertexProgramGxp, &data->colorVertexProgramId);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "register program (color vertex) failed: %d\n", err);
+        return err;
+    }
+
+    err = sceGxmShaderPatcherRegisterProgram(data->shaderPatcher, colorFragmentProgramGxp, &data->colorFragmentProgramId);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "register program (color fragment) failed: %d\n", err);
+        return err;
+    }
+
+    err = sceGxmShaderPatcherRegisterProgram(data->shaderPatcher, textureVertexProgramGxp, &data->textureVertexProgramId);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "register program (texture vertex) failed: %d\n", err);
+        return err;
+    }
+
+    err = sceGxmShaderPatcherRegisterProgram(data->shaderPatcher, textureFragmentProgramGxp, &data->textureFragmentProgramId);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "register program (texture fragment) failed: %d\n", err);
+        return err;
+    }
+
+    {
+        // get attributes by name to create vertex format bindings
+        const SceGxmProgramParameter *paramClearPositionAttribute = sceGxmProgramFindParameterByName(clearVertexProgramGxp, "aPosition");
+
+        // create clear vertex format
+        SceGxmVertexAttribute clearVertexAttributes[1];
+        SceGxmVertexStream clearVertexStreams[1];
+        clearVertexAttributes[0].streamIndex    = 0;
+        clearVertexAttributes[0].offset         = 0;
+        clearVertexAttributes[0].format         = SCE_GXM_ATTRIBUTE_FORMAT_F32;
+        clearVertexAttributes[0].componentCount = 2;
+        clearVertexAttributes[0].regIndex       = sceGxmProgramParameterGetResourceIndex(paramClearPositionAttribute);
+        clearVertexStreams[0].stride            = sizeof(clear_vertex);
+        clearVertexStreams[0].indexSource       = SCE_GXM_INDEX_SOURCE_INDEX_16BIT;
+
+        // create clear programs
+        err = sceGxmShaderPatcherCreateVertexProgram(
+            data->shaderPatcher,
+            data->clearVertexProgramId,
+            clearVertexAttributes,
+            1,
+            clearVertexStreams,
+            1,
+            &data->clearVertexProgram
+        );
+        if (err != 0) {
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "create program (clear vertex) failed: %d\n", err);
+            return err;
+        }
+
+        err = sceGxmShaderPatcherCreateFragmentProgram(
+            data->shaderPatcher,
+            data->clearFragmentProgramId,
+            SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4,
+            0,
+            NULL,
+            clearVertexProgramGxp,
+            &data->clearFragmentProgram
+        );
+        if (err != 0) {
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "create program (clear fragment) failed: %d\n", err);
+            return err;
+        }
+
+        // create the clear triangle vertex/index data
+        data->clearVertices = (clear_vertex *)mem_gpu_alloc(
+            SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
+            3*sizeof(clear_vertex),
+            4,
+            SCE_GXM_MEMORY_ATTRIB_READ,
+            &data->clearVerticesUid
+        );
+    }
+
+    // Allocate a 64k * 2 bytes = 128 KiB buffer and store all possible
+    // 16-bit indices in linear ascending order, so we can use this for
+    // all drawing operations where we don't want to use indexing.
+    data->linearIndices = (uint16_t *)mem_gpu_alloc(
+        SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
+        UINT16_MAX*sizeof(uint16_t),
+        sizeof(uint16_t),
+        SCE_GXM_MEMORY_ATTRIB_READ,
+        &data->linearIndicesUid
+    );
+
+    for (i = 0; i <= UINT16_MAX; ++i)
+    {
+        data->linearIndices[i] = i;
+    }
+
+    data->clearVertices[0].x = -1.0f;
+    data->clearVertices[0].y = -1.0f;
+    data->clearVertices[1].x =  3.0f;
+    data->clearVertices[1].y = -1.0f;
+    data->clearVertices[2].x = -1.0f;
+    data->clearVertices[2].y =  3.0f;
+
+    {
+        const SceGxmProgramParameter *paramColorPositionAttribute = sceGxmProgramFindParameterByName(colorVertexProgramGxp, "aPosition");
+
+        const SceGxmProgramParameter *paramColorColorAttribute = sceGxmProgramFindParameterByName(colorVertexProgramGxp, "aColor");
+
+        // create color vertex format
+        SceGxmVertexAttribute colorVertexAttributes[2];
+        SceGxmVertexStream colorVertexStreams[1];
+        /* x,y: 2 float 32 bits */
+        colorVertexAttributes[0].streamIndex = 0;
+        colorVertexAttributes[0].offset = 0;
+        colorVertexAttributes[0].format = SCE_GXM_ATTRIBUTE_FORMAT_F32;
+        colorVertexAttributes[0].componentCount = 2; // (x, y)
+        colorVertexAttributes[0].regIndex = sceGxmProgramParameterGetResourceIndex(paramColorPositionAttribute);
+        /* color: 4 unsigned char  = 32 bits */
+        colorVertexAttributes[1].streamIndex = 0;
+        colorVertexAttributes[1].offset = 8; // (x, y) * 4 = 8 bytes
+        colorVertexAttributes[1].format = SCE_GXM_ATTRIBUTE_FORMAT_U8N;
+        colorVertexAttributes[1].componentCount = 4; // (color)
+        colorVertexAttributes[1].regIndex = sceGxmProgramParameterGetResourceIndex(paramColorColorAttribute);
+        // 16 bit (short) indices
+        colorVertexStreams[0].stride = sizeof(color_vertex);
+        colorVertexStreams[0].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT;
+
+        // create color shaders
+        err = sceGxmShaderPatcherCreateVertexProgram(
+            data->shaderPatcher,
+            data->colorVertexProgramId,
+            colorVertexAttributes,
+            2,
+            colorVertexStreams,
+            1,
+            &data->colorVertexProgram
+        );
+        if (err != 0) {
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "create program (color vertex) failed: %d\n", err);
+            return err;
+        }
+
+    }
+
+
+    {
+        const SceGxmProgramParameter *paramTexturePositionAttribute = sceGxmProgramFindParameterByName(textureVertexProgramGxp, "aPosition");
+        const SceGxmProgramParameter *paramTextureTexcoordAttribute = sceGxmProgramFindParameterByName(textureVertexProgramGxp, "aTexcoord");
+        const SceGxmProgramParameter *paramTextureColorAttribute = sceGxmProgramFindParameterByName(textureVertexProgramGxp, "aColor");
+
+        // create texture vertex format
+        SceGxmVertexAttribute textureVertexAttributes[3];
+        SceGxmVertexStream textureVertexStreams[1];
+        /* x,y: 2 float 32 bits */
+        textureVertexAttributes[0].streamIndex = 0;
+        textureVertexAttributes[0].offset = 0;
+        textureVertexAttributes[0].format = SCE_GXM_ATTRIBUTE_FORMAT_F32;
+        textureVertexAttributes[0].componentCount = 2; // (x, y)
+        textureVertexAttributes[0].regIndex = sceGxmProgramParameterGetResourceIndex(paramTexturePositionAttribute);
+        /* u,v: 2 floats 32 bits */
+        textureVertexAttributes[1].streamIndex = 0;
+        textureVertexAttributes[1].offset = 8; // (x, y) * 4 = 8 bytes
+        textureVertexAttributes[1].format = SCE_GXM_ATTRIBUTE_FORMAT_F32;
+        textureVertexAttributes[1].componentCount = 2; // (u, v)
+        textureVertexAttributes[1].regIndex = sceGxmProgramParameterGetResourceIndex(paramTextureTexcoordAttribute);
+        /* r,g,b,a: 4 unsigned chars 32 bits */
+        textureVertexAttributes[2].streamIndex = 0;
+        textureVertexAttributes[2].offset = 16; // (x, y, u, v) * 4 = 16 bytes
+        textureVertexAttributes[2].format = SCE_GXM_ATTRIBUTE_FORMAT_U8N;
+        textureVertexAttributes[2].componentCount = 4; // (r, g, b, a)
+        textureVertexAttributes[2].regIndex = sceGxmProgramParameterGetResourceIndex(paramTextureColorAttribute);
+        // 16 bit (short) indices
+        textureVertexStreams[0].stride = sizeof(texture_vertex);
+        textureVertexStreams[0].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT;
+
+        // create texture shaders
+        err = sceGxmShaderPatcherCreateVertexProgram(
+            data->shaderPatcher,
+            data->textureVertexProgramId,
+            textureVertexAttributes,
+            3,
+            textureVertexStreams,
+            1,
+            &data->textureVertexProgram
+        );
+        if (err != 0) {
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "create program (texture vertex) failed: %x\n", err);
+            return err;
+        }
+
+    }
+
+    // Create variations of the fragment program based on blending mode
+    make_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_none, &blend_info_none);
+    make_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_blend, &blend_info_blend);
+    make_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_add, &blend_info_add);
+    make_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_mod, &blend_info_mod);
+    make_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_mul, &blend_info_mul);
+
+    {
+        // Default to blend blending mode
+        fragment_programs *in = &data->blendFragmentPrograms.blend_mode_blend;
+
+        data->colorFragmentProgram = in->color;
+        data->textureFragmentProgram = in->texture;
+
+    }
+
+    // find vertex uniforms by name and cache parameter information
+    data->clearClearColorParam = (SceGxmProgramParameter *)sceGxmProgramFindParameterByName(clearFragmentProgramGxp, "uClearColor");
+    data->colorWvpParam = (SceGxmProgramParameter *)sceGxmProgramFindParameterByName(colorVertexProgramGxp, "wvp");
+    data->textureWvpParam = (SceGxmProgramParameter *)sceGxmProgramFindParameterByName(textureVertexProgramGxp, "wvp");
+
+    // Allocate memory for the memory pool
+    data->pool_addr[0] = mem_gpu_alloc(
+        SCE_KERNEL_MEMBLOCK_TYPE_USER_RW,
+        VITA_GXM_POOL_SIZE,
+        sizeof(void *),
+        SCE_GXM_MEMORY_ATTRIB_READ,
+        &data->poolUid[0]
+    );
+
+    data->pool_addr[1] = mem_gpu_alloc(
+        SCE_KERNEL_MEMBLOCK_TYPE_USER_RW,
+        VITA_GXM_POOL_SIZE,
+        sizeof(void *),
+        SCE_GXM_MEMORY_ATTRIB_READ,
+        &data->poolUid[1]
+    );
+
+    init_orthographic_matrix(data->ortho_matrix, 0.0f, VITA_GXM_SCREEN_WIDTH, VITA_GXM_SCREEN_HEIGHT, 0.0f, 0.0f, 1.0f);
+
+    data->backBufferIndex = 0;
+    data->frontBufferIndex = 0;
+    data->pool_index = 0;
+    data->current_pool = 0;
+    data->currentBlendMode = SDL_BLENDMODE_BLEND;
+
+    return 0;
+}
+
+void gxm_finish(SDL_Renderer *renderer)
+{
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
+
+    // wait until rendering is done
+    sceGxmFinish(data->gxm_context);
+
+    // clean up allocations
+    sceGxmShaderPatcherReleaseFragmentProgram(data->shaderPatcher, data->clearFragmentProgram);
+    sceGxmShaderPatcherReleaseVertexProgram(data->shaderPatcher, data->clearVertexProgram);
+    sceGxmShaderPatcherReleaseVertexProgram(data->shaderPatcher, data->colorVertexProgram);
+    sceGxmShaderPatcherReleaseVertexProgram(data->shaderPatcher, data->textureVertexProgram);
+
+
+    free_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_none);
+    free_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_blend);
+    free_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_add);
+    free_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_mod);
+    free_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_mul);
+
+    mem_gpu_free(data->linearIndicesUid);
+    mem_gpu_free(data->clearVerticesUid);
+
+    // wait until display queue is finished before deallocating display buffers
+    sceGxmDisplayQueueFinish();
+
+    // clean up display queue
+    mem_gpu_free(data->depthBufferUid);
+
+    for (size_t i = 0; i < VITA_GXM_BUFFERS; i++)
+    {
+        // clear the buffer then deallocate
+        SDL_memset(data->displayBufferData[i], 0, VITA_GXM_SCREEN_HEIGHT * VITA_GXM_SCREEN_STRIDE * 4);
+        mem_gpu_free(data->displayBufferUid[i]);
+
+        // destroy the sync object
+        sceGxmSyncObjectDestroy(data->displayBufferSync[i]);
+    }
+
+    // Free the depth and stencil buffer
+    mem_gpu_free(data->depthBufferUid);
+    mem_gpu_free(data->stencilBufferUid);
+
+    // unregister programs and destroy shader patcher
+    sceGxmShaderPatcherUnregisterProgram(data->shaderPatcher, data->clearFragmentProgramId);
+    sceGxmShaderPatcherUnregisterProgram(data->shaderPatcher, data->clearVertexProgramId);
+    sceGxmShaderPatcherUnregisterProgram(data->shaderPatcher, data->colorFragmentProgramId);
+    sceGxmShaderPatcherUnregisterProgram(data->shaderPatcher, data->colorVertexProgramId);
+    sceGxmShaderPatcherUnregisterProgram(data->shaderPatcher, data->textureFragmentProgramId);
+    sceGxmShaderPatcherUnregisterProgram(data->shaderPatcher, data->textureVertexProgramId);
+
+    sceGxmShaderPatcherDestroy(data->shaderPatcher);
+    mem_fragment_usse_free(data->patcherFragmentUsseUid);
+    mem_vertex_usse_free(data->patcherVertexUsseUid);
+    mem_gpu_free(data->patcherBufferUid);
+
+    // destroy the render target
+    sceGxmDestroyRenderTarget(data->renderTarget);
+
+    // destroy the gxm context
+    sceGxmDestroyContext(data->gxm_context);
+    mem_fragment_usse_free(data->fragmentUsseRingBufferUid);
+    mem_gpu_free(data->fragmentRingBufferUid);
+    mem_gpu_free(data->vertexRingBufferUid);
+    mem_gpu_free(data->vdmRingBufferUid);
+    SDL_free(data->contextParams.hostMem);
+
+    mem_gpu_free(data->poolUid[0]);
+    mem_gpu_free(data->poolUid[1]);
+
+    // terminate libgxm
+    sceGxmTerminate();
+}
+
+// textures
+
+void
+free_gxm_texture(gxm_texture *texture)
+{
+    if (texture) {
+        if (texture->gxm_rendertarget) {
+            sceGxmDestroyRenderTarget(texture->gxm_rendertarget);
+        }
+        if (texture->depth_UID) {
+            mem_gpu_free(texture->depth_UID);
+        }
+        mem_gpu_free(texture->data_UID);
+        SDL_free(texture);
+    }
+}
+
+SceGxmTextureFormat
+gxm_texture_get_format(const gxm_texture *texture)
+{
+    return sceGxmTextureGetFormat(&texture->gxm_tex);
+}
+
+unsigned int
+gxm_texture_get_width(const gxm_texture *texture)
+{
+    return sceGxmTextureGetWidth(&texture->gxm_tex);
+}
+
+unsigned int
+gxm_texture_get_height(const gxm_texture *texture)
+{
+    return sceGxmTextureGetHeight(&texture->gxm_tex);
+}
+
+unsigned int
+gxm_texture_get_stride(const gxm_texture *texture)
+{
+    return ((gxm_texture_get_width(texture) + 7) & ~7)
+        * tex_format_to_bytespp(gxm_texture_get_format(texture));
+}
+
+void *
+gxm_texture_get_datap(const gxm_texture *texture)
+{
+    return sceGxmTextureGetData(&texture->gxm_tex);
+}
+
+gxm_texture *
+create_gxm_texture(VITA_GXM_RenderData *data, unsigned int w, unsigned int h, SceGxmTextureFormat format, unsigned int isRenderTarget)
+{
+    gxm_texture *texture = SDL_calloc(1, sizeof(gxm_texture));
+    const int tex_size =  ((w + 7) & ~ 7) * h * tex_format_to_bytespp(format);
+    void *texture_data;
+
+    if (!texture)
+        return NULL;
+
+    /* Allocate a GPU buffer for the texture */
+    texture_data = mem_gpu_alloc(
+        SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW,
+        tex_size,
+        SCE_GXM_TEXTURE_ALIGNMENT,
+        SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE,
+        &texture->data_UID
+    );
+
+    /* Try SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE in case we're out of VRAM */
+    if (!texture_data) {
+        SDL_LogWarn(SDL_LOG_CATEGORY_RENDER, "CDRAM texture allocation failed\n");
+        texture_data = mem_gpu_alloc(
+            SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
+            tex_size,
+            SCE_GXM_TEXTURE_ALIGNMENT,
+            SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE,
+            &texture->data_UID
+        );
+    }
+
+    if (!texture_data) {
+        SDL_free(texture);
+        return NULL;
+    }
+
+    /* Clear the texture */
+    SDL_memset(texture_data, 0, tex_size);
+
+    /* Create the gxm texture */
+    sceGxmTextureInitLinear( &texture->gxm_tex, texture_data, format, w, h, 0);
+
+    if (isRenderTarget) {
+        void *depthBufferData;
+        const uint32_t alignedWidth = ALIGN(w, SCE_GXM_TILE_SIZEX);
+        const uint32_t alignedHeight = ALIGN(h, SCE_GXM_TILE_SIZEY);
+        uint32_t sampleCount = alignedWidth*alignedHeight;
+        uint32_t depthStrideInSamples = alignedWidth;
+        const uint32_t alignedColorSurfaceStride = ALIGN(w, 8);
+
+        int err = sceGxmColorSurfaceInit(
+            &texture->gxm_colorsurface,
+            SCE_GXM_COLOR_FORMAT_A8B8G8R8,
+            SCE_GXM_COLOR_SURFACE_LINEAR,
+            SCE_GXM_COLOR_SURFACE_SCALE_NONE,
+            SCE_GXM_OUTPUT_REGISTER_SIZE_32BIT,
+            w,
+            h,
+            alignedColorSurfaceStride,
+            texture_data
+        );
+
+        if (err < 0) {
+            free_gxm_texture(texture);
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "color surface init failed: %d\n", err);
+            return NULL;
+        }
+
+        // allocate it
+        depthBufferData = mem_gpu_alloc(
+            SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
+            4*sampleCount,
+            SCE_GXM_DEPTHSTENCIL_SURFACE_ALIGNMENT,
+            SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE,
+            &texture->depth_UID);
+
+        // create the SceGxmDepthStencilSurface structure
+        err = sceGxmDepthStencilSurfaceInit(
+            &texture->gxm_depthstencil,
+            SCE_GXM_DEPTH_STENCIL_FORMAT_S8D24,
+            SCE_GXM_DEPTH_STENCIL_SURFACE_TILED,
+            depthStrideInSamples,
+            depthBufferData,
+            NULL);
+
+        if (err < 0) {
+            free_gxm_texture(texture);
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "depth stencil init failed: %d\n", err);
+            return NULL;
+        }
+
+        {
+            SceGxmRenderTarget *tgt = NULL;
+
+            // set up parameters
+            SceGxmRenderTargetParams renderTargetParams;
+            SDL_memset(&renderTargetParams, 0, sizeof(SceGxmRenderTargetParams));
+            renderTargetParams.flags = 0;
+            renderTargetParams.width = w;
+            renderTargetParams.height = h;
+            renderTargetParams.scenesPerFrame = 1;
+            renderTargetParams.multisampleMode = SCE_GXM_MULTISAMPLE_NONE;
+            renderTargetParams.multisampleLocations = 0;
+            renderTargetParams.driverMemBlock = -1;
+
+            // create the render target
+            err = sceGxmCreateRenderTarget(&renderTargetParams, &tgt);
+
+            texture->gxm_rendertarget = tgt;
+
+            if (err < 0) {
+                free_gxm_texture(texture);
+                SDL_LogError(SDL_LOG_CATEGORY_RENDER, "create render target failed: %d\n", err);
+                return NULL;
+            }
+        }
+
+    }
+
+    return texture;
+}
+
+void
+gxm_texture_set_filters(gxm_texture *texture, SceGxmTextureFilter min_filter, SceGxmTextureFilter mag_filter)
+{
+    sceGxmTextureSetMinFilter(&texture->gxm_tex, min_filter);
+    sceGxmTextureSetMagFilter(&texture->gxm_tex, mag_filter);
+}
+
+static unsigned int back_buffer_index_for_common_dialog = 0;
+static unsigned int front_buffer_index_for_common_dialog = 0;
+struct
+{
+    VITA_GXM_DisplayData displayData;
+    SceGxmSyncObject* sync;
+    SceGxmColorSurface surf;
+    SceUID uid;
+} buffer_for_common_dialog[VITA_GXM_BUFFERS];
+
+void gxm_minimal_init_for_common_dialog(void)
+{
+    SceGxmInitializeParams initializeParams;
+    SDL_zero(initializeParams);
+    initializeParams.flags                          = 0;
+    initializeParams.displayQueueMaxPendingCount    = VITA_GXM_PENDING_SWAPS;
+    initializeParams.displayQueueCallback           = display_callback;
+    initializeParams.displayQueueCallbackDataSize   = sizeof(VITA_GXM_DisplayData);
+    initializeParams.parameterBufferSize            = SCE_GXM_DEFAULT_PARAMETER_BUFFER_SIZE;
+    sceGxmInitialize(&initializeParams);
+}
+
+void gxm_minimal_term_for_common_dialog(void)
+{
+    sceGxmTerminate();
+}
+
+void gxm_init_for_common_dialog(void)
+{
+    for (int i = 0; i < VITA_GXM_BUFFERS; i += 1)
+    {
+        buffer_for_common_dialog[i].displayData.wait_vblank = SDL_TRUE;
+        buffer_for_common_dialog[i].displayData.address = mem_gpu_alloc(
+            SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW,
+            4 * VITA_GXM_SCREEN_STRIDE * VITA_GXM_SCREEN_HEIGHT,
+            SCE_GXM_COLOR_SURFACE_ALIGNMENT,
+            SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE,
+            &buffer_for_common_dialog[i].uid);
+        sceGxmColorSurfaceInit(
+            &buffer_for_common_dialog[i].surf,
+            VITA_GXM_PIXEL_FORMAT,
+            SCE_GXM_COLOR_SURFACE_LINEAR,
+            SCE_GXM_COLOR_SURFACE_SCALE_NONE,
+            SCE_GXM_OUTPUT_REGISTER_SIZE_32BIT,
+            VITA_GXM_SCREEN_WIDTH,
+            VITA_GXM_SCREEN_HEIGHT,
+            VITA_GXM_SCREEN_STRIDE,
+            buffer_for_common_dialog[i].displayData.address
+        );
+        sceGxmSyncObjectCreate(&buffer_for_common_dialog[i].sync);
+    }
+    sceGxmDisplayQueueFinish();
+}
+
+void gxm_swap_for_common_dialog(void)
+{
+    SceCommonDialogUpdateParam updateParam;
+    SDL_zero(updateParam);
+    updateParam.renderTarget.colorFormat    = VITA_GXM_PIXEL_FORMAT;
+    updateParam.renderTarget.surfaceType    = SCE_GXM_COLOR_SURFACE_LINEAR;
+    updateParam.renderTarget.width          = VITA_GXM_SCREEN_WIDTH;
+    updateParam.renderTarget.height         = VITA_GXM_SCREEN_HEIGHT;
+    updateParam.renderTarget.strideInPixels = VITA_GXM_SCREEN_STRIDE;
+
+    updateParam.renderTarget.colorSurfaceData = buffer_for_common_dialog[back_buffer_index_for_common_dialog].displayData.address;
+
+    updateParam.displaySyncObject = buffer_for_common_dialog[back_buffer_index_for_common_dialog].sync;
+    SDL_memset(buffer_for_common_dialog[back_buffer_index_for_common_dialog].displayData.address, 0, 4 * VITA_GXM_SCREEN_STRIDE * VITA_GXM_SCREEN_HEIGHT);
+    sceCommonDialogUpdate(&updateParam);
+
+    sceGxmDisplayQueueAddEntry(buffer_for_common_dialog[front_buffer_index_for_common_dialog].sync, buffer_for_common_dialog[back_buffer_index_for_common_dialog].sync, &buffer_for_common_dialog[back_buffer_index_for_common_dialog].displayData);
+    front_buffer_index_for_common_dialog = back_buffer_index_for_common_dialog;
+    back_buffer_index_for_common_dialog = (back_buffer_index_for_common_dialog + 1) % VITA_GXM_BUFFERS;
+}
+
+void gxm_term_for_common_dialog(void)
+{
+    sceGxmDisplayQueueFinish();
+    for (int i = 0; i < VITA_GXM_BUFFERS; i += 1)
+    {
+        mem_gpu_free(buffer_for_common_dialog[i].uid);
+        sceGxmSyncObjectDestroy(buffer_for_common_dialog[i].sync);
+    }
+}
+
+#endif /* SDL_VIDEO_RENDER_VITA_GXM */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_tools.h b/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_tools.h
new file mode 100644
index 000000000..351bdc2e6
--- /dev/null
+++ b/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_tools.h
@@ -0,0 +1,70 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_RENDER_VITA_GXM_TOOLS_H
+#define SDL_RENDER_VITA_GXM_TOOLS_H
+
+#include "../../SDL_internal.h"
+
+#include "SDL_hints.h"
+#include "../SDL_sysrender.h"
+
+#include <psp2/kernel/processmgr.h>
+#include <psp2/appmgr.h>
+#include <psp2/display.h>
+#include <psp2/gxm.h>
+#include <psp2/types.h>
+#include <psp2/kernel/sysmem.h>
+
+#include "SDL_render_vita_gxm_types.h"
+
+void
+init_orthographic_matrix(float *m, float left, float right, float bottom, float top, float near, float far);
+
+void *pool_malloc(VITA_GXM_RenderData *data, unsigned int size);
+void *pool_memalign(VITA_GXM_RenderData *data, unsigned int size, unsigned int alignment);
+
+void set_clip_rectangle(VITA_GXM_RenderData *data, int x_min, int y_min, int x_max, int y_max);
+void unset_clip_rectangle(VITA_GXM_RenderData *data);
+
+int gxm_init(SDL_Renderer *renderer);
+void gxm_finish(SDL_Renderer *renderer);
+
+gxm_texture *create_gxm_texture(VITA_GXM_RenderData *data, unsigned int w, unsigned int h, SceGxmTextureFormat format, unsigned int isRenderTarget);
+void free_gxm_texture(gxm_texture *texture);
+
+void gxm_texture_set_filters(gxm_texture *texture, SceGxmTextureFilter min_filter, SceGxmTextureFilter mag_filter);
+SceGxmTextureFormat gxm_texture_get_format(const gxm_texture *texture);
+
+unsigned int gxm_texture_get_width(const gxm_texture *texture);
+unsigned int gxm_texture_get_height(const gxm_texture *texture);
+unsigned int gxm_texture_get_stride(const gxm_texture *texture);
+void *gxm_texture_get_datap(const gxm_texture *texture);
+
+void gxm_minimal_init_for_common_dialog(void);
+void gxm_minimal_term_for_common_dialog(void);
+void gxm_init_for_common_dialog(void);
+void gxm_swap_for_common_dialog(void);
+void gxm_term_for_common_dialog(void);
+
+#endif /* SDL_RENDER_VITA_GXM_TOOLS_H */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_types.h b/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_types.h
new file mode 100644
index 000000000..898a92d9c
--- /dev/null
+++ b/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_types.h
@@ -0,0 +1,201 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_RENDER_VITA_GXM_TYPES_H
+#define SDL_RENDER_VITA_GXM_TYPES_H
+
+#include "../../SDL_internal.h"
+
+#include "SDL_hints.h"
+#include "../SDL_sysrender.h"
+
+#include <psp2/kernel/processmgr.h>
+#include <psp2/appmgr.h>
+#include <psp2/display.h>
+#include <psp2/gxm.h>
+#include <psp2/types.h>
+#include <psp2/kernel/sysmem.h>
+
+#include <string.h>
+
+#define VITA_GXM_SCREEN_WIDTH     960
+#define VITA_GXM_SCREEN_HEIGHT    544
+#define VITA_GXM_SCREEN_STRIDE    960
+
+#define VITA_GXM_COLOR_FORMAT    SCE_GXM_COLOR_FORMAT_A8B8G8R8
+#define VITA_GXM_PIXEL_FORMAT    SCE_DISPLAY_PIXELFORMAT_A8B8G8R8
+
+#define VITA_GXM_BUFFERS          3
+#define VITA_GXM_PENDING_SWAPS    2
+#define VITA_GXM_POOL_SIZE        2 * 1024 * 1024
+
+typedef struct
+{
+    void     *address;
+    Uint8    wait_vblank;
+} VITA_GXM_DisplayData;
+
+typedef struct clear_vertex {
+    float x;
+    float y;
+} clear_vertex;
+
+typedef struct color_vertex {
+    float x;
+    float y;
+    SDL_Color color;
+} color_vertex;
+
+typedef struct texture_vertex {
+    float x;
+    float y;
+    float u;
+    float v;
+    SDL_Color color;
+} texture_vertex;
+
+typedef struct gxm_texture {
+    SceGxmTexture gxm_tex;
+    SceUID data_UID;
+    SceGxmRenderTarget *gxm_rendertarget;
+    SceGxmColorSurface gxm_colorsurface;
+    SceGxmDepthStencilSurface gxm_depthstencil;
+    SceUID depth_UID;
+} gxm_texture;
+
+typedef struct fragment_programs {
+    SceGxmFragmentProgram *color;
+    SceGxmFragmentProgram *texture;
+} fragment_programs;
+
+typedef struct blend_fragment_programs {
+    fragment_programs blend_mode_none;
+    fragment_programs blend_mode_blend;
+    fragment_programs blend_mode_add;
+    fragment_programs blend_mode_mod;
+    fragment_programs blend_mode_mul;
+} blend_fragment_programs;
+
+typedef struct
+{
+    SDL_Rect viewport;
+    SDL_bool viewport_dirty;
+    SDL_Texture *texture;
+    SDL_Texture *target;
+    SDL_Color color;
+    SceGxmFragmentProgram *fragment_program;
+    SceGxmVertexProgram *vertex_program;
+    int last_command;
+
+    SDL_bool cliprect_enabled_dirty;
+    SDL_bool cliprect_enabled;
+    SDL_bool cliprect_dirty;
+    SDL_Rect cliprect;
+    SDL_bool texturing;
+    SDL_Color clear_color;
+    int drawablew;
+    int drawableh;
+} gxm_drawstate_cache;
+
+typedef struct
+{
+    SDL_bool      initialized;
+    SDL_bool      drawing;
+
+    unsigned int  psm;
+    unsigned int  bpp;
+
+    int           currentBlendMode;
+
+    VITA_GXM_DisplayData displayData;
+
+    SceUID vdmRingBufferUid;
+    SceUID vertexRingBufferUid;
+    SceUID fragmentRingBufferUid;
+    SceUID fragmentUsseRingBufferUid;
+    SceGxmContextParams contextParams;
+    SceGxmContext *gxm_context;
+    SceGxmRenderTarget *renderTarget;
+    SceUID displayBufferUid[VITA_GXM_BUFFERS];
+    void *displayBufferData[VITA_GXM_BUFFERS];
+    SceGxmColorSurface displaySurface[VITA_GXM_BUFFERS];
+    SceGxmSyncObject *displayBufferSync[VITA_GXM_BUFFERS];
+
+    SceUID depthBufferUid;
+    SceUID stencilBufferUid;
+    SceGxmDepthStencilSurface depthSurface;
+    void *depthBufferData;
+    void *stencilBufferData;
+
+    unsigned int backBufferIndex;
+    unsigned int frontBufferIndex;
+
+    void* pool_addr[2];
+    SceUID poolUid[2];
+    unsigned int pool_index;
+    unsigned int current_pool;
+
+    float ortho_matrix[4*4];
+
+    SceGxmVertexProgram *colorVertexProgram;
+    SceGxmFragmentProgram *colorFragmentProgram;
+    SceGxmVertexProgram *textureVertexProgram;
+    SceGxmFragmentProgram *textureFragmentProgram;
+    SceGxmProgramParameter *clearClearColorParam;
+    SceGxmProgramParameter *colorWvpParam;
+    SceGxmProgramParameter *textureWvpParam;
+
+    SceGxmShaderPatcher *shaderPatcher;
+    SceGxmVertexProgram *clearVertexProgram;
+    SceGxmFragmentProgram *clearFragmentProgram;
+
+    SceGxmShaderPatcherId clearVertexProgramId;
+    SceGxmShaderPatcherId clearFragmentProgramId;
+    SceGxmShaderPatcherId colorVertexProgramId;
+    SceGxmShaderPatcherId colorFragmentProgramId;
+    SceGxmShaderPatcherId textureVertexProgramId;
+    SceGxmShaderPatcherId textureFragmentProgramId;
+
+    SceUID patcherBufferUid;
+    SceUID patcherVertexUsseUid;
+    SceUID patcherFragmentUsseUid;
+
+    SceUID clearVerticesUid;
+    SceUID linearIndicesUid;
+    clear_vertex *clearVertices;
+    uint16_t *linearIndices;
+
+    blend_fragment_programs blendFragmentPrograms;
+
+    gxm_drawstate_cache drawstate;
+} VITA_GXM_RenderData;
+
+typedef struct
+{
+    gxm_texture  *tex;
+    unsigned int    pitch;
+    unsigned int    w;
+    unsigned int    h;
+} VITA_GXM_TextureData;
+
+#endif /* SDL_RENDER_VITA_GXM_TYPES_H */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/render/vitagxm/shader_src/clear_f.cg b/Engine/lib/sdl/src/render/vitagxm/shader_src/clear_f.cg
new file mode 100644
index 000000000..6d8fb3b72
--- /dev/null
+++ b/Engine/lib/sdl/src/render/vitagxm/shader_src/clear_f.cg
@@ -0,0 +1,4 @@
+float4 main( uniform float4 uClearColor) : COLOR
+{
+    return uClearColor;
+}
diff --git a/Engine/lib/sdl/src/render/vitagxm/shader_src/clear_v.cg b/Engine/lib/sdl/src/render/vitagxm/shader_src/clear_v.cg
new file mode 100644
index 000000000..ee5aa9fce
--- /dev/null
+++ b/Engine/lib/sdl/src/render/vitagxm/shader_src/clear_v.cg
@@ -0,0 +1,4 @@
+float4 main(float2 aPosition) : POSITION
+{
+    return float4(aPosition, 1.f, 1.f);
+}
diff --git a/Engine/lib/sdl/src/render/vitagxm/shader_src/color_f.cg b/Engine/lib/sdl/src/render/vitagxm/shader_src/color_f.cg
new file mode 100644
index 000000000..dc87c2a11
--- /dev/null
+++ b/Engine/lib/sdl/src/render/vitagxm/shader_src/color_f.cg
@@ -0,0 +1,4 @@
+float4 main(float4 vColor : COLOR)
+{
+    return vColor;
+}
diff --git a/Engine/lib/sdl/src/render/vitagxm/shader_src/color_v.cg b/Engine/lib/sdl/src/render/vitagxm/shader_src/color_v.cg
new file mode 100644
index 000000000..49660995e
--- /dev/null
+++ b/Engine/lib/sdl/src/render/vitagxm/shader_src/color_v.cg
@@ -0,0 +1,13 @@
+void main(
+    float2 aPosition,
+    float4 aColor,
+    uniform float4x4 wvp,
+    out float4 vPosition : POSITION,
+    out float4 vColor : COLOR,
+    out float pSize : PSIZE
+)
+{
+    vPosition = mul(float4(aPosition, 1.f, 0.5f), wvp);
+    vColor = aColor;
+    pSize = 1.f;
+}
diff --git a/Engine/lib/sdl/src/render/vitagxm/shader_src/texture_f.cg b/Engine/lib/sdl/src/render/vitagxm/shader_src/texture_f.cg
new file mode 100644
index 000000000..a1f63b8ef
--- /dev/null
+++ b/Engine/lib/sdl/src/render/vitagxm/shader_src/texture_f.cg
@@ -0,0 +1,4 @@
+float4 main(float2 vTexcoord : TEXCOORD0, float4 vColor : COLOR, uniform sampler2D tex)
+{
+    return tex2D(tex, vTexcoord) * vColor;
+}
diff --git a/Engine/lib/sdl/src/render/vitagxm/shader_src/texture_v.cg b/Engine/lib/sdl/src/render/vitagxm/shader_src/texture_v.cg
new file mode 100644
index 000000000..9e05e9a80
--- /dev/null
+++ b/Engine/lib/sdl/src/render/vitagxm/shader_src/texture_v.cg
@@ -0,0 +1,14 @@
+void main(
+    float2 aPosition,
+    float2 aTexcoord,
+    float4 aColor,
+    uniform float4x4 wvp,
+    out float4 vPosition : POSITION,
+    out float4 vColor : COLOR,
+    out float2 vTexcoord : TEXCOORD0
+)
+{
+    vPosition = mul(float4(aPosition, 1.f, 0.5f), wvp);
+    vTexcoord = aTexcoord;
+    vColor = aColor;
+}
diff --git a/Engine/lib/sdl/src/sensor/SDL_sensor.c b/Engine/lib/sdl/src/sensor/SDL_sensor.c
index ccf56d978..161026bd2 100644
--- a/Engine/lib/sdl/src/sensor/SDL_sensor.c
+++ b/Engine/lib/sdl/src/sensor/SDL_sensor.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -39,11 +39,14 @@ static SDL_SensorDriver *SDL_sensor_drivers[] = {
     &SDL_COREMOTION_SensorDriver,
 #endif
 #ifdef SDL_SENSOR_WINDOWS
-	&SDL_WINDOWS_SensorDriver,
+    &SDL_WINDOWS_SensorDriver,
 #endif
 #if defined(SDL_SENSOR_DUMMY) || defined(SDL_SENSOR_DISABLED)
     &SDL_DUMMY_SensorDriver
 #endif
+#if defined(SDL_SENSOR_VITA)
+    &SDL_VITA_SensorDriver
+#endif
 };
 static SDL_Sensor *SDL_sensors = NULL;
 static SDL_bool SDL_updating_sensor = SDL_FALSE;
diff --git a/Engine/lib/sdl/src/sensor/SDL_sensor_c.h b/Engine/lib/sdl/src/sensor/SDL_sensor_c.h
index a66e85834..f116a065a 100644
--- a/Engine/lib/sdl/src/sensor/SDL_sensor_c.h
+++ b/Engine/lib/sdl/src/sensor/SDL_sensor_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/sensor/SDL_syssensor.h b/Engine/lib/sdl/src/sensor/SDL_syssensor.h
index d4d5c874e..cabbab675 100644
--- a/Engine/lib/sdl/src/sensor/SDL_syssensor.h
+++ b/Engine/lib/sdl/src/sensor/SDL_syssensor.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -100,6 +100,7 @@ extern SDL_SensorDriver SDL_ANDROID_SensorDriver;
 extern SDL_SensorDriver SDL_COREMOTION_SensorDriver;
 extern SDL_SensorDriver SDL_WINDOWS_SensorDriver;
 extern SDL_SensorDriver SDL_DUMMY_SensorDriver;
+extern SDL_SensorDriver SDL_VITA_SensorDriver;
 
 #endif /* SDL_syssensor_h_ */
 
diff --git a/Engine/lib/sdl/src/sensor/android/SDL_androidsensor.c b/Engine/lib/sdl/src/sensor/android/SDL_androidsensor.c
index 778fc262e..e6cfc2302 100644
--- a/Engine/lib/sdl/src/sensor/android/SDL_androidsensor.c
+++ b/Engine/lib/sdl/src/sensor/android/SDL_androidsensor.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/sensor/android/SDL_androidsensor.h b/Engine/lib/sdl/src/sensor/android/SDL_androidsensor.h
index 23c7cfb14..4fc5e6526 100644
--- a/Engine/lib/sdl/src/sensor/android/SDL_androidsensor.h
+++ b/Engine/lib/sdl/src/sensor/android/SDL_androidsensor.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/sensor/coremotion/SDL_coremotionsensor.h b/Engine/lib/sdl/src/sensor/coremotion/SDL_coremotionsensor.h
index c97d15f19..664bf3bf1 100644
--- a/Engine/lib/sdl/src/sensor/coremotion/SDL_coremotionsensor.h
+++ b/Engine/lib/sdl/src/sensor/coremotion/SDL_coremotionsensor.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/sensor/coremotion/SDL_coremotionsensor.m b/Engine/lib/sdl/src/sensor/coremotion/SDL_coremotionsensor.m
index 0c61df188..7165f6aec 100644
--- a/Engine/lib/sdl/src/sensor/coremotion/SDL_coremotionsensor.m
+++ b/Engine/lib/sdl/src/sensor/coremotion/SDL_coremotionsensor.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/sensor/dummy/SDL_dummysensor.c b/Engine/lib/sdl/src/sensor/dummy/SDL_dummysensor.c
index 8d2db39a1..469d35dc1 100644
--- a/Engine/lib/sdl/src/sensor/dummy/SDL_dummysensor.c
+++ b/Engine/lib/sdl/src/sensor/dummy/SDL_dummysensor.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/sensor/dummy/SDL_dummysensor.h b/Engine/lib/sdl/src/sensor/dummy/SDL_dummysensor.h
index ee66f2fe0..1f3513629 100644
--- a/Engine/lib/sdl/src/sensor/dummy/SDL_dummysensor.h
+++ b/Engine/lib/sdl/src/sensor/dummy/SDL_dummysensor.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/sensor/vita/SDL_vitasensor.c b/Engine/lib/sdl/src/sensor/vita/SDL_vitasensor.c
new file mode 100644
index 000000000..5235e9b11
--- /dev/null
+++ b/Engine/lib/sdl/src/sensor/vita/SDL_vitasensor.c
@@ -0,0 +1,219 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "SDL_config.h"
+
+#if defined(SDL_SENSOR_VITA)
+
+#include "SDL_error.h"
+#include "SDL_sensor.h"
+#include "SDL_vitasensor.h"
+#include "../SDL_syssensor.h"
+#include <psp2/motion.h>
+
+#if !defined(SCE_MOTION_MAX_NUM_STATES)
+#define SCE_MOTION_MAX_NUM_STATES 64
+#endif
+
+typedef struct
+{
+    SDL_SensorType type;
+    SDL_SensorID instance_id;
+} SDL_VitaSensor;
+
+static SDL_VitaSensor *SDL_sensors;
+static int SDL_sensors_count;
+
+static int
+SDL_VITA_SensorInit(void)
+{
+    sceMotionReset();
+    sceMotionStartSampling();
+    // not sure if these are needed, we are reading unfiltered state
+    sceMotionSetAngleThreshold(0);
+    sceMotionSetDeadband(SCE_FALSE);
+    sceMotionSetTiltCorrection(SCE_FALSE);
+
+    SDL_sensors_count = 2;
+
+    SDL_sensors = (SDL_VitaSensor *)SDL_calloc(SDL_sensors_count, sizeof(*SDL_sensors));
+    if (!SDL_sensors) {
+        return SDL_OutOfMemory();
+    }
+
+    SDL_sensors[0].type = SDL_SENSOR_ACCEL;
+    SDL_sensors[0].instance_id = SDL_GetNextSensorInstanceID();
+    SDL_sensors[1].type = SDL_SENSOR_GYRO;
+    SDL_sensors[1].instance_id = SDL_GetNextSensorInstanceID();
+
+    return 0;
+}
+
+static int
+SDL_VITA_SensorGetCount(void)
+{
+    return SDL_sensors_count;
+}
+
+static void
+SDL_VITA_SensorDetect(void)
+{
+}
+
+static const char *
+SDL_VITA_SensorGetDeviceName(int device_index)
+{
+    if (device_index < SDL_sensors_count) {
+        switch (SDL_sensors[device_index].type) {
+            case SDL_SENSOR_ACCEL:
+                return "Accelerometer";
+            case SDL_SENSOR_GYRO:
+                return "Gyro";
+            default:
+                return "Unknown";
+        }
+    }
+
+    return NULL;
+}
+
+static SDL_SensorType
+SDL_VITA_SensorGetDeviceType(int device_index)
+{
+    if (device_index < SDL_sensors_count) {
+        return SDL_sensors[device_index].type;
+    }
+
+    return SDL_SENSOR_INVALID;
+}
+
+static int
+SDL_VITA_SensorGetDeviceNonPortableType(int device_index)
+{
+    if (device_index < SDL_sensors_count) {
+        return SDL_sensors[device_index].type;
+    }
+    return -1;
+}
+
+static SDL_SensorID
+SDL_VITA_SensorGetDeviceInstanceID(int device_index)
+{
+    if (device_index < SDL_sensors_count) {
+        return SDL_sensors[device_index].instance_id;
+    }
+    return -1;
+}
+
+static int
+SDL_VITA_SensorOpen(SDL_Sensor *sensor, int device_index)
+{
+    struct sensor_hwdata *hwdata;
+
+    hwdata = (struct sensor_hwdata *)SDL_calloc(1, sizeof(*hwdata));
+    if (hwdata == NULL) {
+        return SDL_OutOfMemory();
+    }
+    sensor->hwdata = hwdata;
+
+    return 0;
+}
+
+static void
+SDL_VITA_SensorUpdate(SDL_Sensor *sensor)
+{
+    int err = 0;
+    SceMotionSensorState motionState[SCE_MOTION_MAX_NUM_STATES];
+    SDL_memset(motionState, 0, sizeof(motionState));
+
+    err = sceMotionGetSensorState(motionState, SCE_MOTION_MAX_NUM_STATES);
+    if (err != 0)
+    {
+        return;
+    }
+
+    for (int i = 0; i < SCE_MOTION_MAX_NUM_STATES; i++)
+    {
+        if (sensor->hwdata->counter < motionState[i].counter)
+        {
+            sensor->hwdata->counter = motionState[i].counter;
+            switch (sensor->type)
+            {
+                case SDL_SENSOR_ACCEL:
+                {
+                    float data[3];
+                    data[0] = motionState[i].accelerometer.x * SDL_STANDARD_GRAVITY;
+                    data[1] = motionState[i].accelerometer.y * SDL_STANDARD_GRAVITY;
+                    data[2] = motionState[i].accelerometer.z * SDL_STANDARD_GRAVITY;
+                    if (SDL_memcmp(data, sensor->hwdata->data, sizeof(data)) != 0) {
+                       SDL_PrivateSensorUpdate(sensor, data, SDL_arraysize(data));
+                       SDL_memcpy(sensor->hwdata->data, data, sizeof(data));
+                    }
+                }
+                break;
+                case SDL_SENSOR_GYRO:
+                {
+                    float data[3];
+                    data[0] = motionState[i].gyro.x;
+                    data[1] = motionState[i].gyro.y;
+                    data[2] = motionState[i].gyro.z;
+                    if (SDL_memcmp(data, sensor->hwdata->data, sizeof(data)) != 0) {
+                       SDL_PrivateSensorUpdate(sensor, data, SDL_arraysize(data));
+                       SDL_memcpy(sensor->hwdata->data, data, sizeof(data));
+                    }
+                }
+                break;
+                default:
+                break;
+            }
+        }
+    }
+}
+
+static void
+SDL_VITA_SensorClose(SDL_Sensor *sensor)
+{
+}
+
+static void
+SDL_VITA_SensorQuit(void)
+{
+    sceMotionStopSampling();
+}
+
+SDL_SensorDriver SDL_VITA_SensorDriver =
+{
+    SDL_VITA_SensorInit,
+    SDL_VITA_SensorGetCount,
+    SDL_VITA_SensorDetect,
+    SDL_VITA_SensorGetDeviceName,
+    SDL_VITA_SensorGetDeviceType,
+    SDL_VITA_SensorGetDeviceNonPortableType,
+    SDL_VITA_SensorGetDeviceInstanceID,
+    SDL_VITA_SensorOpen,
+    SDL_VITA_SensorUpdate,
+    SDL_VITA_SensorClose,
+    SDL_VITA_SensorQuit,
+};
+
+#endif /* SDL_SENSOR_VITA */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/sensor/vita/SDL_vitasensor.h b/Engine/lib/sdl/src/sensor/vita/SDL_vitasensor.h
new file mode 100644
index 000000000..2fca628fd
--- /dev/null
+++ b/Engine/lib/sdl/src/sensor/vita/SDL_vitasensor.h
@@ -0,0 +1,30 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_config.h"
+
+/* The private structure used to keep track of a sensor */
+struct sensor_hwdata
+{
+    float data[3];
+    Uint32 counter;
+};
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/sensor/windows/SDL_windowssensor.c b/Engine/lib/sdl/src/sensor/windows/SDL_windowssensor.c
index efb7e3fcf..21b119d22 100644
--- a/Engine/lib/sdl/src/sensor/windows/SDL_windowssensor.c
+++ b/Engine/lib/sdl/src/sensor/windows/SDL_windowssensor.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -279,7 +279,7 @@ static int ConnectSensor(ISensor *sensor)
 
     hr = ISensor_GetFriendlyName(sensor, &bstr_name);
     if (SUCCEEDED(hr) && bstr_name) {
-        name = WIN_StringToUTF8(bstr_name);
+        name = WIN_StringToUTF8W(bstr_name);
     } else {
         name = SDL_strdup("Unknown Sensor");
     }
@@ -294,6 +294,7 @@ static int ConnectSensor(ISensor *sensor)
     new_sensors = (SDL_Windows_Sensor *)SDL_realloc(SDL_sensors, (SDL_num_sensors + 1) * sizeof(SDL_Windows_Sensor));
     if (new_sensors == NULL) {
         SDL_UnlockSensors();
+        SDL_free(name);
         return SDL_OutOfMemory();
     }
 
@@ -324,7 +325,10 @@ static int DisconnectSensor(ISensor *sensor)
     for (i = 0; i < SDL_num_sensors; ++i) {
         old_sensor = &SDL_sensors[i];
         if (sensor == old_sensor->sensor) {
-            ISensor_SetEventSink(sensor, NULL);
+            /* This call hangs for some reason:
+             * https://github.com/libsdl-org/SDL/issues/5288
+             */
+            /*ISensor_SetEventSink(sensor, NULL);*/
             ISensor_Release(sensor);
             SDL_free(old_sensor->name);
             --SDL_num_sensors;
@@ -351,12 +355,14 @@ SDL_WINDOWS_SensorInit(void)
 
     hr = CoCreateInstance(&SDL_CLSID_SensorManager, NULL, CLSCTX_INPROC_SERVER, &SDL_IID_SensorManager, (LPVOID *) &SDL_sensor_manager);
     if (FAILED(hr)) {
-        return WIN_SetErrorFromHRESULT("Couldn't create the sensor manager", hr);
+        /* If we can't create a sensor manager (i.e. on Wine), we won't have any sensors, but don't fail the init */
+        return 0; /* WIN_SetErrorFromHRESULT("Couldn't create the sensor manager", hr); */
     }
 
     hr = ISensorManager_SetEventSink(SDL_sensor_manager, &sensor_manager_events);
     if (FAILED(hr)) {
         ISensorManager_Release(SDL_sensor_manager);
+        SDL_sensor_manager = NULL;
         return WIN_SetErrorFromHRESULT("Couldn't set the sensor manager event sink", hr);
     }
 
diff --git a/Engine/lib/sdl/src/sensor/windows/SDL_windowssensor.h b/Engine/lib/sdl/src/sensor/windows/SDL_windowssensor.h
index ee66f2fe0..1f3513629 100644
--- a/Engine/lib/sdl/src/sensor/windows/SDL_windowssensor.h
+++ b/Engine/lib/sdl/src/sensor/windows/SDL_windowssensor.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/stdlib/SDL_crc32.c b/Engine/lib/sdl/src/stdlib/SDL_crc32.c
index 4a5778b39..ff80dcdba 100644
--- a/Engine/lib/sdl/src/stdlib/SDL_crc32.c
+++ b/Engine/lib/sdl/src/stdlib/SDL_crc32.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/stdlib/SDL_getenv.c b/Engine/lib/sdl/src/stdlib/SDL_getenv.c
index 2bdacd343..add833284 100644
--- a/Engine/lib/sdl/src/stdlib/SDL_getenv.c
+++ b/Engine/lib/sdl/src/stdlib/SDL_getenv.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -48,7 +48,7 @@ int
 SDL_setenv(const char *name, const char *value, int overwrite)
 {
     /* Input validation */
-    if (!name || SDL_strlen(name) == 0 || SDL_strchr(name, '=') != NULL || !value) {
+    if (!name || *name == '\0' || SDL_strchr(name, '=') != NULL || !value) {
         return (-1);
     }
     
@@ -59,7 +59,7 @@ int
 SDL_setenv(const char *name, const char *value, int overwrite)
 {
     /* Input validation */
-    if (!name || SDL_strlen(name) == 0 || SDL_strchr(name, '=') != NULL || !value) {
+    if (!name || *name == '\0' || SDL_strchr(name, '=') != NULL || !value) {
         return (-1);
     }
     
@@ -82,7 +82,7 @@ SDL_setenv(const char *name, const char *value, int overwrite)
     char *new_variable;
 
     /* Input validation */
-    if (!name || SDL_strlen(name) == 0 || SDL_strchr(name, '=') != NULL || !value) {
+    if (!name || *name == '\0' || SDL_strchr(name, '=') != NULL || !value) {
         return (-1);
     }
     
@@ -115,7 +115,7 @@ SDL_setenv(const char *name, const char *value, int overwrite)
     char *new_variable;
 
     /* Input validation */
-    if (!name || SDL_strlen(name) == 0 || SDL_strchr(name, '=') != NULL || !value) {
+    if (!name || *name == '\0' || SDL_strchr(name, '=') != NULL || !value) {
         return (-1);
     }
 
@@ -181,7 +181,7 @@ SDL_getenv(const char *name)
 #endif
 
     /* Input validation */
-    if (!name || !*name) {
+    if (!name || *name == '\0') {
         return NULL;
     }
 
@@ -194,7 +194,7 @@ SDL_getenv(const char *name)
     size_t bufferlen;
 
     /* Input validation */
-    if (!name || SDL_strlen(name)==0) {
+    if (!name || *name == '\0') {
         return NULL;
     }
     
@@ -222,7 +222,7 @@ SDL_getenv(const char *name)
     char *value;
 
     /* Input validation */
-    if (!name || SDL_strlen(name)==0) {
+    if (!name || *name == '\0') {
         return NULL;
     }
     
diff --git a/Engine/lib/sdl/src/stdlib/SDL_iconv.c b/Engine/lib/sdl/src/stdlib/SDL_iconv.c
index fa133a88f..3f5c82745 100644
--- a/Engine/lib/sdl/src/stdlib/SDL_iconv.c
+++ b/Engine/lib/sdl/src/stdlib/SDL_iconv.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -31,19 +31,11 @@
 #include "SDL_endian.h"
 
 #if defined(HAVE_ICONV) && defined(HAVE_ICONV_H)
-#include <iconv.h>
-
-/* Depending on which standard the iconv() was implemented with,
-   iconv() may or may not use const char ** for the inbuf param.
-   If we get this wrong, it's just a warning, so no big deal.
-*/
-#if defined(_XGP6) || defined(__APPLE__) || defined(__RISCOS__) || defined(__FREEBSD__) || \
-    defined(__EMSCRIPTEN__) || \
-    (defined(__GLIBC__) && ((__GLIBC__ > 2) || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)) || \
-    (defined(_NEWLIB_VERSION)))
-#define ICONV_INBUF_NONCONST
+#ifdef __FreeBSD__
+/* Define LIBICONV_PLUG to use iconv from the base instead of ports and avoid linker errors. */
+#define LIBICONV_PLUG 1
 #endif
-
+#include <iconv.h>
 #include <errno.h>
 
 SDL_COMPILE_TIME_ASSERT(iconv_t, sizeof (iconv_t) <= sizeof (SDL_iconv_t));
@@ -51,13 +43,13 @@ SDL_COMPILE_TIME_ASSERT(iconv_t, sizeof (iconv_t) <= sizeof (SDL_iconv_t));
 SDL_iconv_t
 SDL_iconv_open(const char *tocode, const char *fromcode)
 {
-    return (SDL_iconv_t) ((size_t) iconv_open(tocode, fromcode));
+    return (SDL_iconv_t) ((uintptr_t) iconv_open(tocode, fromcode));
 }
 
 int
 SDL_iconv_close(SDL_iconv_t cd)
 {
-    return iconv_close((iconv_t) ((size_t) cd));
+    return iconv_close((iconv_t) ((uintptr_t) cd));
 }
 
 size_t
@@ -65,12 +57,9 @@ SDL_iconv(SDL_iconv_t cd,
           const char **inbuf, size_t * inbytesleft,
           char **outbuf, size_t * outbytesleft)
 {
-    size_t retCode;
-#ifdef ICONV_INBUF_NONCONST
-    retCode = iconv((iconv_t) ((size_t) cd), (char **) inbuf, inbytesleft, outbuf, outbytesleft);
-#else
-    retCode = iconv((iconv_t) ((size_t) cd), inbuf, inbytesleft, outbuf, outbytesleft);
-#endif
+    /* iconv's second parameter may or may not be `const char const *` depending on the
+       C runtime's whims. Casting to void * seems to make everyone happy, though. */
+    const size_t retCode = iconv((iconv_t) ((uintptr_t) cd), (void *) inbuf, inbytesleft, outbuf, outbytesleft);
     if (retCode == (size_t) - 1) {
         switch (errno) {
         case E2BIG:
@@ -142,6 +131,11 @@ static struct
     { "US-ASCII", ENCODING_ASCII },
     { "8859-1", ENCODING_LATIN1 },
     { "ISO-8859-1", ENCODING_LATIN1 },
+#if defined(__WIN32__) || defined(__OS2__)
+    { "WCHAR_T", ENCODING_UTF16LE },
+#else
+    { "WCHAR_T", ENCODING_UCS4NATIVE },
+#endif
     { "UTF8", ENCODING_UTF8 },
     { "UTF-8", ENCODING_UTF8 },
     { "UTF16", ENCODING_UTF16 },
@@ -365,33 +359,7 @@ SDL_iconv(SDL_iconv_t cd,
                 Uint8 *p = (Uint8 *) src;
                 size_t left = 0;
                 SDL_bool overlong = SDL_FALSE;
-                if (p[0] >= 0xFC) {
-                    if ((p[0] & 0xFE) != 0xFC) {
-                        /* Skip illegal sequences
-                           return SDL_ICONV_EILSEQ;
-                         */
-                        ch = UNKNOWN_UNICODE;
-                    } else {
-                        if (p[0] == 0xFC && srclen > 1 && (p[1] & 0xFC) == 0x80) {
-                            overlong = SDL_TRUE;
-                        }
-                        ch = (Uint32) (p[0] & 0x01);
-                        left = 5;
-                    }
-                } else if (p[0] >= 0xF8) {
-                    if ((p[0] & 0xFC) != 0xF8) {
-                        /* Skip illegal sequences
-                           return SDL_ICONV_EILSEQ;
-                         */
-                        ch = UNKNOWN_UNICODE;
-                    } else {
-                        if (p[0] == 0xF8 && srclen > 1 && (p[1] & 0xF8) == 0x80) {
-                            overlong = SDL_TRUE;
-                        }
-                        ch = (Uint32) (p[0] & 0x03);
-                        left = 4;
-                    }
-                } else if (p[0] >= 0xF0) {
+                if (p[0] >= 0xF0) {
                     if ((p[0] & 0xF8) != 0xF0) {
                         /* Skip illegal sequences
                            return SDL_ICONV_EILSEQ;
@@ -666,7 +634,7 @@ SDL_iconv(SDL_iconv_t cd,
                     p[2] = 0x80 | (Uint8) (ch & 0x3F);
                     dst += 3;
                     dstlen -= 3;
-                } else if (ch <= 0x1FFFFF) {
+                } else {
                     if (dstlen < 4) {
                         return SDL_ICONV_E2BIG;
                     }
@@ -676,29 +644,6 @@ SDL_iconv(SDL_iconv_t cd,
                     p[3] = 0x80 | (Uint8) (ch & 0x3F);
                     dst += 4;
                     dstlen -= 4;
-                } else if (ch <= 0x3FFFFFF) {
-                    if (dstlen < 5) {
-                        return SDL_ICONV_E2BIG;
-                    }
-                    p[0] = 0xF8 | (Uint8) ((ch >> 24) & 0x03);
-                    p[1] = 0x80 | (Uint8) ((ch >> 18) & 0x3F);
-                    p[2] = 0x80 | (Uint8) ((ch >> 12) & 0x3F);
-                    p[3] = 0x80 | (Uint8) ((ch >> 6) & 0x3F);
-                    p[4] = 0x80 | (Uint8) (ch & 0x3F);
-                    dst += 5;
-                    dstlen -= 5;
-                } else {
-                    if (dstlen < 6) {
-                        return SDL_ICONV_E2BIG;
-                    }
-                    p[0] = 0xFC | (Uint8) ((ch >> 30) & 0x01);
-                    p[1] = 0x80 | (Uint8) ((ch >> 24) & 0x3F);
-                    p[2] = 0x80 | (Uint8) ((ch >> 18) & 0x3F);
-                    p[3] = 0x80 | (Uint8) ((ch >> 12) & 0x3F);
-                    p[4] = 0x80 | (Uint8) ((ch >> 6) & 0x3F);
-                    p[5] = 0x80 | (Uint8) (ch & 0x3F);
-                    dst += 6;
-                    dstlen -= 6;
                 }
             }
             break;
@@ -798,7 +743,7 @@ SDL_iconv(SDL_iconv_t cd,
             if (ch > 0x10FFFF) {
                 ch = UNKNOWN_UNICODE;
             }
-            /* fallthrough */
+            SDL_FALLTHROUGH;
         case ENCODING_UCS4BE:
             if (ch > 0x7FFFFFFF) {
                 ch = UNKNOWN_UNICODE;
@@ -820,7 +765,7 @@ SDL_iconv(SDL_iconv_t cd,
             if (ch > 0x10FFFF) {
                 ch = UNKNOWN_UNICODE;
             }
-            /* fallthrough */
+            SDL_FALLTHROUGH;
         case ENCODING_UCS4LE:
             if (ch > 0x7FFFFFFF) {
                 ch = UNKNOWN_UNICODE;
@@ -907,6 +852,7 @@ SDL_iconv_string(const char *tocode, const char *fromcode, const char *inbuf,
                 stringsize *= 2;
                 string = (char *) SDL_realloc(string, stringsize);
                 if (!string) {
+                    SDL_free(oldstring);
                     SDL_iconv_close(cd);
                     return NULL;
                 }
@@ -927,8 +873,7 @@ SDL_iconv_string(const char *tocode, const char *fromcode, const char *inbuf,
             break;
         }
         /* Avoid infinite loops when nothing gets converted */
-        if (oldinbytesleft == inbytesleft)
-        {
+        if (oldinbytesleft == inbytesleft) {
             break;
         }
     }
diff --git a/Engine/lib/sdl/src/stdlib/SDL_malloc.c b/Engine/lib/sdl/src/stdlib/SDL_malloc.c
index 7c9f0d63a..b5dd6414f 100644
--- a/Engine/lib/sdl/src/stdlib/SDL_malloc.c
+++ b/Engine/lib/sdl/src/stdlib/SDL_malloc.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -485,6 +485,7 @@ DEFAULT_MMAP_THRESHOLD       default: 256K
 #define WIN32 1
 #endif /* _WIN32 */
 #endif /* WIN32 */
+
 #ifdef WIN32
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
@@ -2326,7 +2327,7 @@ static size_t traverse_and_check(mstate m);
 #define treebin_at(M,i)     (&((M)->treebins[i]))
 
 /* assign tree index for size S to variable I */
-#if defined(__GNUC__) && defined(i386)
+#if defined(__GNUC__) && defined(__i386__)
 #define compute_tree_index(S, I)\
 {\
   size_t X = S >> TREEBIN_SHIFT;\
@@ -2391,7 +2392,7 @@ static size_t traverse_and_check(mstate m);
 
 /* index corresponding to given bit */
 
-#if defined(__GNUC__) && defined(i386)
+#if defined(__GNUC__) && defined(__i386__)
 #define compute_bit2idx(X, I)\
 {\
   unsigned int J;\
diff --git a/Engine/lib/sdl/src/stdlib/SDL_qsort.c b/Engine/lib/sdl/src/stdlib/SDL_qsort.c
index 9dc3f4f96..b175f444e 100644
--- a/Engine/lib/sdl/src/stdlib/SDL_qsort.c
+++ b/Engine/lib/sdl/src/stdlib/SDL_qsort.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/stdlib/SDL_stdlib.c b/Engine/lib/sdl/src/stdlib/SDL_stdlib.c
index 5334a512d..9d785aad5 100644
--- a/Engine/lib/sdl/src/stdlib/SDL_stdlib.c
+++ b/Engine/lib/sdl/src/stdlib/SDL_stdlib.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -52,22 +52,22 @@ SDL_atanf(float x)
 }
 
 double
-SDL_atan2(double x, double y)
+SDL_atan2(double y, double x)
 {
 #if defined(HAVE_ATAN2)
-    return atan2(x, y);
+    return atan2(y, x);
 #else
-    return SDL_uclibc_atan2(x, y);
+    return SDL_uclibc_atan2(y, x);
 #endif
 }
 
 float
-SDL_atan2f(float x, float y)
+SDL_atan2f(float y, float x)
 {
 #if defined(HAVE_ATAN2F)
-    return atan2f(x, y);
+    return atan2f(y, x);
 #else
-    return (float)SDL_atan2((double)x, (double)y);
+    return (float)SDL_atan2((double)y, (double)x);
 #endif
 }
 
@@ -148,7 +148,7 @@ SDL_ceilf(float x)
 #if defined(HAVE_CEILF)
     return ceilf(x);
 #else
-    return (float)SDL_ceil((float)x);
+    return (float)SDL_ceil((double)x);
 #endif
 }
 
@@ -364,6 +364,50 @@ SDL_powf(float x, float y)
 #endif
 }
 
+double
+SDL_round(double arg)
+{
+#if defined HAVE_ROUND
+    return round(arg);
+#else
+    if (arg >= 0.0) {
+        return SDL_floor(arg + 0.5);
+    } else {
+        return SDL_ceil(arg - 0.5);
+    }
+#endif
+}
+
+float
+SDL_roundf(float arg)
+{
+#if defined HAVE_ROUNDF
+    return roundf(arg);
+#else
+    return (float)SDL_round((double)arg);
+#endif
+}
+
+long
+SDL_lround(double arg)
+{
+#if defined HAVE_LROUND
+    return lround(arg);
+#else
+    return (long)SDL_round(arg);
+#endif
+}
+
+long
+SDL_lroundf(float arg)
+{
+#if defined HAVE_LROUNDF
+    return lroundf(arg);
+#else
+    return (long)SDL_round((double)arg);
+#endif
+}
+
 double
 SDL_scalbn(double x, int n)
 {
@@ -400,7 +444,7 @@ SDL_sin(double x)
 #endif
 }
 
-float 
+float
 SDL_sinf(float x)
 {
 #if defined(HAVE_SINF)
@@ -455,26 +499,45 @@ int SDL_abs(int x)
 #if defined(HAVE_ABS)
     return abs(x);
 #else
-    return ((x) < 0 ? -(x) : (x));
+    return (x < 0) ? -x : x;
 #endif
 }
 
 #if defined(HAVE_CTYPE_H)
+int SDL_isalpha(int x) { return isalpha(x); }
+int SDL_isalnum(int x) { return isalnum(x); }
 int SDL_isdigit(int x) { return isdigit(x); }
+int SDL_isxdigit(int x) { return isxdigit(x); }
+int SDL_ispunct(int x) { return ispunct(x); }
 int SDL_isspace(int x) { return isspace(x); }
 int SDL_isupper(int x) { return isupper(x); }
 int SDL_islower(int x) { return islower(x); }
+int SDL_isprint(int x) { return isprint(x); }
+int SDL_isgraph(int x) { return isgraph(x); }
+int SDL_iscntrl(int x) { return iscntrl(x); }
 int SDL_toupper(int x) { return toupper(x); }
 int SDL_tolower(int x) { return tolower(x); }
 #else
+int SDL_isalpha(int x) { return (SDL_isupper(x)) || (SDL_islower(x)); }
+int SDL_isalnum(int x) { return (SDL_isalpha(x)) || (SDL_isdigit(x)); }
 int SDL_isdigit(int x) { return ((x) >= '0') && ((x) <= '9'); }
+int SDL_isxdigit(int x) { return (((x) >= 'A') && ((x) <= 'F')) || (((x) >= 'a') && ((x) <= 'f')) || (SDL_isdigit(x)); }
+int SDL_ispunct(int x) { return (SDL_isgraph(x)) && (!SDL_isalnum(x)); }
 int SDL_isspace(int x) { return ((x) == ' ') || ((x) == '\t') || ((x) == '\r') || ((x) == '\n') || ((x) == '\f') || ((x) == '\v'); }
 int SDL_isupper(int x) { return ((x) >= 'A') && ((x) <= 'Z'); }
 int SDL_islower(int x) { return ((x) >= 'a') && ((x) <= 'z'); }
+int SDL_isprint(int x) { return ((x) >= ' ') && ((x) < '\x7f'); }
+int SDL_isgraph(int x) { return (SDL_isprint(x)) && ((x) != ' '); }
+int SDL_iscntrl(int x) { return (((x) >= '\0') && ((x) <= '\x1f')) || ((x) == '\x7f'); }
 int SDL_toupper(int x) { return ((x) >= 'a') && ((x) <= 'z') ? ('A'+((x)-'a')) : (x); }
 int SDL_tolower(int x) { return ((x) >= 'A') && ((x) <= 'Z') ? ('a'+((x)-'A')) : (x); }
 #endif
 
+#if defined(HAVE_CTYPE_H) && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+int SDL_isblank(int x) { return isblank(x); }
+#else
+int SDL_isblank(int x) { return ((x) == ' ') || ((x) == '\t'); }
+#endif
 
 #ifndef HAVE_LIBC
 /* These are some C runtime intrinsics that need to be defined */
diff --git a/Engine/lib/sdl/src/stdlib/SDL_string.c b/Engine/lib/sdl/src/stdlib/SDL_string.c
index 44f34601d..133193072 100644
--- a/Engine/lib/sdl/src/stdlib/SDL_string.c
+++ b/Engine/lib/sdl/src/stdlib/SDL_string.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -28,7 +28,15 @@
 
 #include "SDL_stdinc.h"
 
-#if !defined(HAVE_VSSCANF) || !defined(HAVE_STRTOL) || !defined(HAVE_STRTOUL)  || !defined(HAVE_STRTOLL) || !defined(HAVE_STRTOULL) || !defined(HAVE_STRTOD)
+#if defined(_MSC_VER) && _MSC_VER <= 1800
+/* Visual Studio 2013 tries to link with _vacopy in the C runtime. Newer versions do an inline assignment */
+#undef va_copy
+#define va_copy(dst, src)   dst = src
+#elif defined(__GNUC__) && (__GNUC__ < 3)
+#define va_copy(to, from)   __va_copy(to, from)
+#endif
+
+#if !defined(HAVE_VSSCANF) || !defined(HAVE_STRTOL) || !defined(HAVE_STRTOUL) || !defined(HAVE_STRTOD) || !defined(HAVE_STRTOLL) || !defined(HAVE_STRTOULL)
 #define SDL_isupperhex(X)   (((X) >= 'A') && ((X) <= 'F'))
 #define SDL_islowerhex(X)   (((X) >= 'a') && ((X) <= 'f'))
 #endif
@@ -36,7 +44,7 @@
 #define UTF8_IsLeadByte(c) ((c) >= 0xC0 && (c) <= 0xF4)
 #define UTF8_IsTrailingByte(c) ((c) >= 0x80 && (c) <= 0xBF)
 
-static int UTF8_TrailingBytes(unsigned char c)
+static unsigned UTF8_TrailingBytes(unsigned char c)
 {
     if (c >= 0xC0 && c <= 0xDF)
         return 1;
@@ -281,7 +289,7 @@ SDL_memset(SDL_OUT_BYTECAP(len) void *dst, int c, size_t len)
      * execute a 32-bit set. Set first bytes manually if needed until it is
      * aligned. */
     value1 = (Uint8)c;
-    while ((intptr_t)dstp1 & 0x3) {
+    while ((uintptr_t)dstp1 & 0x3) {
         if (len--) {
             *dstp1++ = value1;
         } else {
@@ -289,7 +297,7 @@ SDL_memset(SDL_OUT_BYTECAP(len) void *dst, int c, size_t len)
         }
     }
 
-    value4 = (c | (c << 8) | (c << 16) | (c << 24));
+    value4 = ((Uint32)c | ((Uint32)c << 8) | ((Uint32)c << 16) | ((Uint32)c << 24));
     dstp4 = (Uint32 *) dstp1;
     left = (len % 4);
     len /= 4;
@@ -329,7 +337,7 @@ SDL_memcpy(SDL_OUT_BYTECAP(len) void *dst, SDL_IN_BYTECAP(len) const void *src,
        using Uint32* pointers, so we need to make sure the pointers are
        aligned before we loop using them.
      */
-    if (((intptr_t)src & 0x3) || ((intptr_t)dst & 0x3)) {
+    if (((uintptr_t)src & 0x3) || ((uintptr_t)dst & 0x3)) {
         /* Do an unaligned byte copy */
         Uint8 *srcp1 = (Uint8 *)src;
         Uint8 *dstp1 = (Uint8 *)dst;
@@ -632,20 +640,17 @@ SDL_utf8strlcpy(SDL_OUT_Z_CAP(dst_bytes) char *dst, const char *src, size_t dst_
     size_t src_bytes = SDL_strlen(src);
     size_t bytes = SDL_min(src_bytes, dst_bytes - 1);
     size_t i = 0;
-    char trailing_bytes = 0;
-    if (bytes)
-    {
+    unsigned char trailing_bytes = 0;
+
+    if (bytes) {
         unsigned char c = (unsigned char)src[bytes - 1];
-        if (UTF8_IsLeadByte(c))
+        if (UTF8_IsLeadByte(c)) {
             --bytes;
-        else if (UTF8_IsTrailingByte(c))
-        {
-            for (i = bytes - 1; i != 0; --i)
-            {
+        } else if (UTF8_IsTrailingByte(c)) {
+            for (i = bytes - 1; i != 0; --i) {
                 c = (unsigned char)src[i];
                 trailing_bytes = UTF8_TrailingBytes(c);
-                if (trailing_bytes)
-                {
+                if (trailing_bytes) {
                     if (bytes - i != trailing_bytes + 1)
                         bytes = i;
 
@@ -656,6 +661,7 @@ SDL_utf8strlcpy(SDL_OUT_Z_CAP(dst_bytes) char *dst, const char *src, size_t dst_
         SDL_memcpy(dst, src, bytes);
     }
     dst[bytes] = '\0';
+
     return bytes;
 }
 
@@ -664,7 +670,7 @@ SDL_utf8strlen(const char *str)
 {
     size_t retval = 0;
     const char *p = str;
-    char ch;
+    unsigned char ch;
 
     while ((ch = *(p++)) != 0) {
         /* if top two bits are 1 and 0, it's a continuation byte. */
@@ -928,7 +934,7 @@ int SDL_atoi(const char *string)
 #ifdef HAVE_ATOI
     return atoi(string);
 #else
-    return SDL_strtol(string, NULL, 0);
+    return SDL_strtol(string, NULL, 10);
 #endif /* HAVE_ATOI */
 }
 
@@ -1064,13 +1070,16 @@ SDL_strcmp(const char *str1, const char *str2)
 #if defined(HAVE_STRCMP)
     return strcmp(str1, str2);
 #else
-    while (*str1 && *str2) {
-        if (*str1 != *str2)
+    int result;
+
+    while(1) {
+        result = (int)((unsigned char) *str1 - (unsigned char) *str2);
+        if (result != 0 || (*str1 == '\0'/* && *str2 == '\0'*/))
             break;
         ++str1;
         ++str2;
     }
-    return (int)((unsigned char) *str1 - (unsigned char) *str2);
+    return result;
 #endif /* HAVE_STRCMP */
 }
 
@@ -1080,17 +1089,20 @@ SDL_strncmp(const char *str1, const char *str2, size_t maxlen)
 #if defined(HAVE_STRNCMP)
     return strncmp(str1, str2, maxlen);
 #else
-    while (*str1 && *str2 && maxlen) {
-        if (*str1 != *str2)
+    int result;
+
+    while (maxlen) {
+        result = (int) (unsigned char) *str1 - (unsigned char) *str2;
+        if (result != 0 || *str1 == '\0'/* && *str2 == '\0'*/)
             break;
         ++str1;
         ++str2;
         --maxlen;
     }
     if (!maxlen) {
-        return 0;
+        result = 0;
     }
-    return (int) ((unsigned char) *str1 - (unsigned char) *str2);
+    return result;
 #endif /* HAVE_STRNCMP */
 }
 
@@ -1102,19 +1114,18 @@ SDL_strcasecmp(const char *str1, const char *str2)
 #elif defined(HAVE__STRICMP)
     return _stricmp(str1, str2);
 #else
-    char a = 0;
-    char b = 0;
-    while (*str1 && *str2) {
+    int a, b, result;
+
+    while (1) {
         a = SDL_toupper((unsigned char) *str1);
         b = SDL_toupper((unsigned char) *str2);
-        if (a != b)
+        result = a - b;
+        if (result != 0 || a == 0 /*&& b == 0*/)
             break;
         ++str1;
         ++str2;
     }
-    a = SDL_toupper(*str1);
-    b = SDL_toupper(*str2);
-    return (int) ((unsigned char) a - (unsigned char) b);
+    return result;
 #endif /* HAVE_STRCASECMP */
 }
 
@@ -1126,24 +1137,21 @@ SDL_strncasecmp(const char *str1, const char *str2, size_t maxlen)
 #elif defined(HAVE__STRNICMP)
     return _strnicmp(str1, str2, maxlen);
 #else
-    char a = 0;
-    char b = 0;
-    while (*str1 && *str2 && maxlen) {
+    int a, b, result;
+
+    while (maxlen) {
         a = SDL_tolower((unsigned char) *str1);
         b = SDL_tolower((unsigned char) *str2);
-        if (a != b)
+        result = a - b;
+        if (result != 0 || a == 0 /*&& b == 0*/)
             break;
         ++str1;
         ++str2;
         --maxlen;
     }
-    if (maxlen == 0) {
-        return 0;
-    } else {
-        a = SDL_tolower((unsigned char) *str1);
-        b = SDL_tolower((unsigned char) *str2);
-        return (int) ((unsigned char) a - (unsigned char) b);
-    }
+    if (maxlen == 0)
+        result = 0;
+    return result;
 #endif /* HAVE_STRNCASECMP */
 }
 
@@ -1269,7 +1277,7 @@ SDL_vsscanf(const char *text, const char *fmt, va_list ap)
                             }
                         }
                     }
-                    /* Fall through to %d handling */
+                    SDL_FALLTHROUGH;
                 case 'd':
                     if (inttype == DO_LONGLONG) {
                         Sint64 value;
@@ -1317,13 +1325,13 @@ SDL_vsscanf(const char *text, const char *fmt, va_list ap)
                     if (radix == 10) {
                         radix = 8;
                     }
-                    /* Fall through to unsigned handling */
+                    SDL_FALLTHROUGH;
                 case 'x':
                 case 'X':
                     if (radix == 10) {
                         radix = 16;
                     }
-                    /* Fall through to unsigned handling */
+                    SDL_FALLTHROUGH;
                 case 'u':
                     if (inttype == DO_LONGLONG) {
                         Uint64 value = 0;
@@ -1472,6 +1480,8 @@ int SDL_vsnprintf(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, const char *f
     return vsnprintf(text, maxlen, fmt, ap);
 }
 #else
+#define TEXT_AND_LEN_ARGS   (length < maxlen) ? &text[length] : NULL, (length < maxlen) ? (maxlen - length) : 0
+
  /* FIXME: implement more of the format specifiers */
 typedef enum
 {
@@ -1514,25 +1524,27 @@ SDL_PrintString(char *text, size_t maxlen, SDL_FormatInfo *info, const char *str
         filllen = SDL_min(width, maxlen);
         SDL_memset(text, fill, filllen);
         text += filllen;
-        length += filllen;
         maxlen -= filllen;
+        length += width;
     }
 
-    slen = SDL_strlcpy(text, string, maxlen);
-    length += SDL_min(slen, maxlen);
+    SDL_strlcpy(text, string, maxlen);
+    length += sz;
 
     if (info) {
         if (info->precision >= 0 && (size_t)info->precision < sz) {
             slen = (size_t)info->precision;
             if (slen < maxlen) {
-                text[slen] = 0;
-                length -= (sz - slen);
+                text[slen] = '\0';
             }
+            length -= (sz - slen);
         }
-        if (info->force_case == SDL_CASE_LOWER) {
-            SDL_strlwr(text);
-        } else if (info->force_case == SDL_CASE_UPPER) {
-            SDL_strupr(text);
+        if (maxlen > 1) {
+            if (info->force_case == SDL_CASE_LOWER) {
+                SDL_strlwr(text);
+            } else if (info->force_case == SDL_CASE_UPPER) {
+                SDL_strupr(text);
+            }
         }
     }
     return length;
@@ -1585,7 +1597,7 @@ SDL_PrintLong(char *text, size_t maxlen, SDL_FormatInfo *info, long value)
     }
 
     SDL_ltoa(value, p, info ? info->radix : 10);
-    SDL_IntPrecisionAdjust(num, maxlen, info);
+    SDL_IntPrecisionAdjust(num, sizeof(num), info);
     return SDL_PrintString(text, maxlen, info, num);
 }
 
@@ -1595,7 +1607,7 @@ SDL_PrintUnsignedLong(char *text, size_t maxlen, SDL_FormatInfo *info, unsigned
     char num[130];
 
     SDL_ultoa(value, num, info ? info->radix : 10);
-    SDL_IntPrecisionAdjust(num, maxlen, info);
+    SDL_IntPrecisionAdjust(num, sizeof(num), info);
     return SDL_PrintString(text, maxlen, info, num);
 }
 
@@ -1609,7 +1621,7 @@ SDL_PrintLongLong(char *text, size_t maxlen, SDL_FormatInfo *info, Sint64 value)
     }
 
     SDL_lltoa(value, p, info ? info->radix : 10);
-    SDL_IntPrecisionAdjust(num, maxlen, info);
+    SDL_IntPrecisionAdjust(num, sizeof(num), info);
     return SDL_PrintString(text, maxlen, info, num);
 }
 
@@ -1619,126 +1631,79 @@ SDL_PrintUnsignedLongLong(char *text, size_t maxlen, SDL_FormatInfo *info, Uint6
     char num[130];
 
     SDL_ulltoa(value, num, info ? info->radix : 10);
-    SDL_IntPrecisionAdjust(num, maxlen, info);
+    SDL_IntPrecisionAdjust(num, sizeof(num), info);
     return SDL_PrintString(text, maxlen, info, num);
 }
 
 static size_t
 SDL_PrintFloat(char *text, size_t maxlen, SDL_FormatInfo *info, double arg)
 {
-    int width;
-    size_t len;
-    size_t left = maxlen;
-    char *textstart = text;
+    size_t length = 0;
 
-    if (arg) {
-        /* This isn't especially accurate, but hey, it's easy. :) */
-        unsigned long value;
+    /* This isn't especially accurate, but hey, it's easy. :) */
+    unsigned long value;
 
-        if (arg < 0) {
-            if (left > 1) {
-                *text = '-';
-                --left;
-            }
-            ++text;
-            arg = -arg;
-        } else if (info->force_sign) {
-            if (left > 1) {
-                *text = '+';
-                --left;
-            }
-            ++text;
+    if (arg < 0) {
+        if (length < maxlen) {
+            text[length] = '-';
         }
-        value = (unsigned long) arg;
-        len = SDL_PrintUnsignedLong(text, left, NULL, value);
-        if (len >= left) {
-            text += (left > 1) ? left - 1 : 0;
-            left = SDL_min(left, 1);
-        } else {
-            text += len;
-            left -= len;
+        ++length;
+        arg = -arg;
+    } else if (info->force_sign) {
+        if (length < maxlen) {
+            text[length] = '+';
         }
-        arg -= value;
-        if (info->precision < 0) {
-            info->precision = 6;
+        ++length;
+    }
+    value = (unsigned long) arg;
+    length += SDL_PrintUnsignedLong(TEXT_AND_LEN_ARGS, NULL, value);
+    arg -= value;
+    if (info->precision < 0) {
+        info->precision = 6;
+    }
+    if (info->force_type || info->precision > 0) {
+        int mult = 10;
+        if (length < maxlen) {
+            text[length] = '.';
         }
-        if (info->force_type || info->precision > 0) {
-            int mult = 10;
-            if (left > 1) {
-                *text = '.';
-                --left;
-            }
-            ++text;
-            while (info->precision-- > 0) {
-                value = (unsigned long) (arg * mult);
-                len = SDL_PrintUnsignedLong(text, left, NULL, value);
-                if (len >= left) {
-                    text += (left > 1) ? left - 1 : 0;
-                    left = SDL_min(left, 1);
-                } else {
-                    text += len;
-                    left -= len;
-                }
-                arg -= (double) value / mult;
-                mult *= 10;
-            }
-        }
-    } else {
-        if (left > 1) {
-            *text = '0';
-            --left;
-        }
-        ++text;
-        if (info->force_type) {
-            if (left > 1) {
-                *text = '.';
-                --left;
-            }
-            ++text;
+        ++length;
+        while (info->precision-- > 0) {
+            value = (unsigned long) (arg * mult);
+            length += SDL_PrintUnsignedLong(TEXT_AND_LEN_ARGS, NULL, value);
+            arg -= (double) value / mult;
+            mult *= 10;
         }
     }
 
-    width = info->width - (int)(text - textstart);
-    if (width > 0) {
+    if (info->width > 0 && (size_t)info->width > length) {
         const char fill = info->pad_zeroes ? '0' : ' ';
-        char *end = text+left-1;
-        len = (text - textstart);
-        for (len = (text - textstart); len--; ) {
-            if ((textstart+len+width) < end) {
-                *(textstart+len+width) = *(textstart+len);
-            }
-        }
-        len = (size_t)width;
-        if (len >= left) {
-            text += (left > 1) ? left - 1 : 0;
-            left = SDL_min(left, 1);
-        } else {
-            text += len;
-            left -= len;
-        }
+        size_t width = info->width - length;
+        size_t filllen, movelen;
 
-        if (end != textstart) {
-            const size_t filllen = SDL_min(len, ((size_t) (end - textstart)) - 1);
-            SDL_memset(textstart, fill, filllen);
-        }
+        filllen = SDL_min(width, maxlen);
+        movelen = SDL_min(length, (maxlen - filllen));
+        SDL_memmove(&text[filllen], text, movelen);
+        SDL_memset(text, fill, filllen);
+        length += width;
     }
 
-    return (text - textstart);
+    return length;
 }
 
 int
 SDL_vsnprintf(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, const char *fmt, va_list ap)
 {
-    size_t left = maxlen;
-    char *textstart = text;
+    size_t length = 0;
 
+    if (!text) {
+        maxlen = 0;
+    }
     if (!fmt) {
         fmt = "";
     }
-    while (*fmt && left > 1) {
+    while (*fmt) {
         if (*fmt == '%') {
             SDL_bool done = SDL_FALSE;
-            size_t len = 0;
             SDL_bool check_flag;
             SDL_FormatInfo info;
             enum
@@ -1800,18 +1765,18 @@ SDL_vsnprintf(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, const char *fmt,
             while (!done) {
                 switch (*fmt) {
                 case '%':
-                    if (left > 1) {
-                        *text = '%';
+                    if (length < maxlen) {
+                        text[length] = '%';
                     }
-                    len = 1;
+                    ++length;
                     done = SDL_TRUE;
                     break;
                 case 'c':
                     /* char is promoted to int when passed through (...) */
-                    if (left > 1) {
-                        *text = (char) va_arg(ap, int);
+                    if (length < maxlen) {
+                        text[length] = (char) va_arg(ap, int);
                     }
-                    len = 1;
+                    ++length;
                     done = SDL_TRUE;
                     break;
                 case 'h':
@@ -1835,15 +1800,15 @@ SDL_vsnprintf(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, const char *fmt,
                     }
                     switch (inttype) {
                     case DO_INT:
-                        len = SDL_PrintLong(text, left, &info,
+                        length += SDL_PrintLong(TEXT_AND_LEN_ARGS, &info,
                                             (long) va_arg(ap, int));
                         break;
                     case DO_LONG:
-                        len = SDL_PrintLong(text, left, &info,
+                        length += SDL_PrintLong(TEXT_AND_LEN_ARGS, &info,
                                             va_arg(ap, long));
                         break;
                     case DO_LONGLONG:
-                        len = SDL_PrintLongLong(text, left, &info,
+                        length += SDL_PrintLongLong(TEXT_AND_LEN_ARGS, &info,
                                                 va_arg(ap, Sint64));
                         break;
                     }
@@ -1852,7 +1817,7 @@ SDL_vsnprintf(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, const char *fmt,
                 case 'p':
                 case 'x':
                     info.force_case = SDL_CASE_LOWER;
-                    /* Fall through to 'X' handling */
+                    SDL_FALLTHROUGH;
                 case 'X':
                     if (info.force_case == SDL_CASE_NOCHANGE) {
                         info.force_case = SDL_CASE_UPPER;
@@ -1863,12 +1828,12 @@ SDL_vsnprintf(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, const char *fmt,
                     if (*fmt == 'p') {
                         inttype = DO_LONG;
                     }
-                    /* Fall through to unsigned handling */
+                    SDL_FALLTHROUGH;
                 case 'o':
                     if (info.radix == 10) {
                         info.radix = 8;
                     }
-                    /* Fall through to unsigned handling */
+                    SDL_FALLTHROUGH;
                 case 'u':
                     info.force_sign = SDL_FALSE;
                     if (info.precision >= 0) {
@@ -1876,23 +1841,23 @@ SDL_vsnprintf(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, const char *fmt,
                     }
                     switch (inttype) {
                     case DO_INT:
-                        len = SDL_PrintUnsignedLong(text, left, &info,
+                        length += SDL_PrintUnsignedLong(TEXT_AND_LEN_ARGS, &info,
                                                     (unsigned long)
                                                     va_arg(ap, unsigned int));
                         break;
                     case DO_LONG:
-                        len = SDL_PrintUnsignedLong(text, left, &info,
+                        length += SDL_PrintUnsignedLong(TEXT_AND_LEN_ARGS, &info,
                                                     va_arg(ap, unsigned long));
                         break;
                     case DO_LONGLONG:
-                        len = SDL_PrintUnsignedLongLong(text, left, &info,
+                        length += SDL_PrintUnsignedLongLong(TEXT_AND_LEN_ARGS, &info,
                                                         va_arg(ap, Uint64));
                         break;
                     }
                     done = SDL_TRUE;
                     break;
                 case 'f':
-                    len = SDL_PrintFloat(text, left, &info, va_arg(ap, double));
+                    length += SDL_PrintFloat(TEXT_AND_LEN_ARGS, &info, va_arg(ap, double));
                     done = SDL_TRUE;
                     break;
                 case 'S':
@@ -1902,18 +1867,18 @@ SDL_vsnprintf(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, const char *fmt,
                         if (wide_arg) {
                             char *arg = SDL_iconv_string("UTF-8", "UTF-16LE", (char *)(wide_arg), (SDL_wcslen(wide_arg)+1)*sizeof(*wide_arg));
                             info.pad_zeroes = SDL_FALSE;
-                            len = SDL_PrintString(text, left, &info, arg);
+                            length += SDL_PrintString(TEXT_AND_LEN_ARGS, &info, arg);
                             SDL_free(arg);
                         } else {
                             info.pad_zeroes = SDL_FALSE;
-                            len = SDL_PrintString(text, left, &info, NULL);
+                            length += SDL_PrintString(TEXT_AND_LEN_ARGS, &info, NULL);
                         }
                         done = SDL_TRUE;
                     }
                     break;
                 case 's':
                     info.pad_zeroes = SDL_FALSE;
-                    len = SDL_PrintString(text, left, &info, va_arg(ap, char *));
+                    length += SDL_PrintString(TEXT_AND_LEN_ARGS, &info, va_arg(ap, char *));
                     done = SDL_TRUE;
                     break;
                 default:
@@ -1922,23 +1887,80 @@ SDL_vsnprintf(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, const char *fmt,
                 }
                 ++fmt;
             }
-            if (len >= left) {
-                text += (left > 1) ? left - 1 : 0;
-                left = SDL_min(left, 1);
-            } else {
-                text += len;
-                left -= len;
-            }
         } else {
-            *text++ = *fmt++;
-            --left;
+            if (length < maxlen) {
+                text[length] = *fmt;
+            }
+            ++fmt;
+            ++length;
         }
     }
-    if (left > 0) {
-        *text = '\0';
+    if (length < maxlen) {
+        text[length] = '\0';
+    } else if (maxlen > 0) {
+        text[maxlen - 1] = '\0';
     }
-    return (int)(text - textstart);
+    return (int)length;
+
 }
+
+#undef TEXT_AND_LEN_ARGS
 #endif /* HAVE_VSNPRINTF */
 
+int
+SDL_asprintf(char **strp, SDL_PRINTF_FORMAT_STRING const char *fmt, ...)
+{
+    va_list ap;
+    int retval;
+
+    va_start(ap, fmt);
+    retval = SDL_vasprintf(strp, fmt, ap);
+    va_end(ap);
+
+    return retval;
+}
+
+int
+SDL_vasprintf(char **strp, const char *fmt, va_list ap)
+{
+    int retval;
+    int size = 100;     /* Guess we need no more than 100 bytes */
+    char *p, *np;
+    va_list aq;
+
+    *strp = NULL;
+
+    p = (char *)SDL_malloc(size);
+    if (p == NULL)
+        return -1;
+
+    while (1) {
+        /* Try to print in the allocated space */
+        va_copy(aq, ap);
+        retval = SDL_vsnprintf(p, size, fmt, aq);
+        va_end(aq);
+
+        /* Check error code */
+        if (retval < 0)
+            return retval;
+
+        /* If that worked, return the string */
+        if (retval < size) {
+            *strp = p;
+            return retval;
+        }
+
+        /* Else try again with more space */
+        size = retval + 1;       /* Precisely what is needed */
+
+        np = (char *)SDL_realloc(p, size);
+        if (np == NULL) {
+            SDL_free(p);
+            return -1;
+        } else {
+            p = np;
+        }
+    }
+}
+
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/stdlib/SDL_strtokr.c b/Engine/lib/sdl/src/stdlib/SDL_strtokr.c
index 3d69363ff..4b624d3fd 100644
--- a/Engine/lib/sdl/src/stdlib/SDL_strtokr.c
+++ b/Engine/lib/sdl/src/stdlib/SDL_strtokr.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -28,12 +28,9 @@
 
 char *SDL_strtokr(char *s1, const char *s2, char **ptr)
 {
-#if defined(HAVE_STRTOK_R)
+#ifdef HAVE_STRTOK_R
     return strtok_r(s1, s2, ptr);
 
-#elif defined(_MSC_VER) && defined(HAVE_STRTOK_S)
-    return strtok_s(s1, s2, ptr);
-
 #else /* SDL implementation */
 /*
  * Adapted from _PDCLIB_strtok() of PDClib library at
diff --git a/Engine/lib/sdl/src/test/SDL_test_assert.c b/Engine/lib/sdl/src/test/SDL_test_assert.c
index d8aca4eed..148564ec1 100644
--- a/Engine/lib/sdl/src/test/SDL_test_assert.c
+++ b/Engine/lib/sdl/src/test/SDL_test_assert.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -104,7 +104,7 @@ void SDLTest_AssertPass(SDL_PRINTF_FORMAT_STRING const char *assertDescription,
 
         /* Log pass message */
     SDLTest_AssertsPassed++;
-    SDLTest_Log(SDLTEST_ASSERT_CHECK_FORMAT, logMessage, "Pass");
+    SDLTest_Log(SDLTEST_ASSERT_CHECK_FORMAT, logMessage, "Passed");
 }
 
 /*
diff --git a/Engine/lib/sdl/src/test/SDL_test_common.c b/Engine/lib/sdl/src/test/SDL_test_common.c
index 72404e02e..48c6c72f0 100644
--- a/Engine/lib/sdl/src/test/SDL_test_common.c
+++ b/Engine/lib/sdl/src/test/SDL_test_common.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -30,12 +30,15 @@ static const char *video_usage[] = {
     "[--video driver]", "[--renderer driver]", "[--gldebug]",
     "[--info all|video|modes|render|event]",
     "[--log all|error|system|audio|video|render|input]", "[--display N]",
+    "[--metal-window | --opengl-window | --vulkan-window]",
     "[--fullscreen | --fullscreen-desktop | --windows N]", "[--title title]",
     "[--icon icon.bmp]", "[--center | --position X,Y]", "[--geometry WxH]",
     "[--min-geometry WxH]", "[--max-geometry WxH]", "[--logical WxH]",
     "[--scale N]", "[--depth N]", "[--refresh R]", "[--vsync]", "[--noframe]",
-    "[--resize]", "[--minimize]", "[--maximize]", "[--grab]",
-    "[--allow-highdpi]", "[--usable-bounds]"
+    "[--resizable]", "[--minimize]", "[--maximize]", "[--grab]", "[--keyboard-grab]",
+    "[--shown]", "[--hidden]", "[--input-focus]", "[--mouse-focus]",
+    "[--flash-on-focus-loss]", "[--allow-highdpi]", "[--confine-cursor X,Y,W,H]",
+    "[--usable-bounds]"
 };
 
 static const char *audio_usage[] = {
@@ -218,6 +221,18 @@ SDLTest_CommonArg(SDLTest_CommonState * state, int index)
         }
         return 2;
     }
+    if (SDL_strcasecmp(argv[index], "--metal-window") == 0) {
+        state->window_flags |= SDL_WINDOW_METAL;
+        return 1;
+    }
+    if (SDL_strcasecmp(argv[index], "--opengl-window") == 0) {
+        state->window_flags |= SDL_WINDOW_OPENGL;
+        return 1;
+    }
+    if (SDL_strcasecmp(argv[index], "--vulkan-window") == 0) {
+        state->window_flags |= SDL_WINDOW_VULKAN;
+        return 1;
+    }
     if (SDL_strcasecmp(argv[index], "--fullscreen") == 0) {
         state->window_flags |= SDL_WINDOW_FULLSCREEN;
         state->num_windows = 1;
@@ -234,7 +249,7 @@ SDLTest_CommonArg(SDLTest_CommonState * state, int index)
     }
     if (SDL_strcasecmp(argv[index], "--windows") == 0) {
         ++index;
-        if (!argv[index] || !SDL_isdigit(*argv[index])) {
+        if (!argv[index] || !SDL_isdigit((unsigned char) *argv[index])) {
             return -1;
         }
         if (!(state->window_flags & SDL_WINDOW_FULLSCREEN)) {
@@ -282,6 +297,34 @@ SDLTest_CommonArg(SDLTest_CommonState * state, int index)
         state->window_y = SDL_atoi(y);
         return 2;
     }
+    if (SDL_strcasecmp(argv[index], "--confine-cursor") == 0) {
+        char *x, *y, *w, *h;
+        ++index;
+        if (!argv[index]) {
+            return -1;
+        }
+        x = argv[index];
+        y = argv[index];
+        #define SEARCHARG(dim) \
+            while (*dim && *dim != ',') { \
+                ++dim; \
+            } \
+            if (!*dim) { \
+                return -1; \
+            } \
+            *dim++ = '\0';
+        SEARCHARG(y)
+        w = y;
+        SEARCHARG(w)
+        h = w;
+        SEARCHARG(h)
+        #undef SEARCHARG
+        state->confine.x = SDL_atoi(x);
+        state->confine.y = SDL_atoi(y);
+        state->confine.w = SDL_atoi(w);
+        state->confine.h = SDL_atoi(h);
+        return 2;
+    }
     if (SDL_strcasecmp(argv[index], "--usable-bounds") == 0) {
         /* !!! FIXME: this is a bit of a hack, but I don't want to add a
            !!! FIXME:  flag to the public structure in 2.0.x */
@@ -399,7 +442,7 @@ SDLTest_CommonArg(SDLTest_CommonState * state, int index)
         state->window_flags |= SDL_WINDOW_BORDERLESS;
         return 1;
     }
-    if (SDL_strcasecmp(argv[index], "--resize") == 0) {
+    if (SDL_strcasecmp(argv[index], "--resizable") == 0) {
         state->window_flags |= SDL_WINDOW_RESIZABLE;
         return 1;
     }
@@ -411,8 +454,32 @@ SDLTest_CommonArg(SDLTest_CommonState * state, int index)
         state->window_flags |= SDL_WINDOW_MAXIMIZED;
         return 1;
     }
+    if (SDL_strcasecmp(argv[index], "--shown") == 0) {
+        state->window_flags |= SDL_WINDOW_SHOWN;
+        return 1;
+    }
+    if (SDL_strcasecmp(argv[index], "--hidden") == 0) {
+        state->window_flags |= SDL_WINDOW_HIDDEN;
+        return 1;
+    }
+    if (SDL_strcasecmp(argv[index], "--input-focus") == 0) {
+        state->window_flags |= SDL_WINDOW_INPUT_FOCUS;
+        return 1;
+    }
+    if (SDL_strcasecmp(argv[index], "--mouse-focus") == 0) {
+        state->window_flags |= SDL_WINDOW_MOUSE_FOCUS;
+        return 1;
+    }
+    if (SDL_strcasecmp(argv[index], "--flash-on-focus-loss") == 0) {
+        state->flash_on_focus_loss = SDL_TRUE;
+        return 1;
+    }
     if (SDL_strcasecmp(argv[index], "--grab") == 0) {
-        state->window_flags |= SDL_WINDOW_INPUT_GRABBED;
+        state->window_flags |= SDL_WINDOW_MOUSE_GRABBED;
+        return 1;
+    }
+    if (SDL_strcasecmp(argv[index], "--keyboard-grab") == 0) {
+        state->window_flags |= SDL_WINDOW_KEYBOARD_GRABBED;
         return 1;
     }
     if (SDL_strcasecmp(argv[index], "--rate") == 0) {
@@ -595,6 +662,170 @@ SDLTest_CommonDefaultArgs(SDLTest_CommonState *state, const int argc, char **arg
     return SDL_TRUE;
 }
 
+static void
+SDLTest_PrintDisplayOrientation(char* text, size_t maxlen, SDL_DisplayOrientation orientation)
+{
+    switch (orientation) {
+    case SDL_ORIENTATION_UNKNOWN:
+        SDL_snprintfcat(text, maxlen, "UNKNOWN");
+        break;
+    case SDL_ORIENTATION_LANDSCAPE:
+        SDL_snprintfcat(text, maxlen, "LANDSCAPE");
+        break;
+    case SDL_ORIENTATION_LANDSCAPE_FLIPPED:
+        SDL_snprintfcat(text, maxlen, "LANDSCAPE_FLIPPED");
+        break;
+    case SDL_ORIENTATION_PORTRAIT:
+        SDL_snprintfcat(text, maxlen, "PORTRAIT");
+        break;
+    case SDL_ORIENTATION_PORTRAIT_FLIPPED:
+        SDL_snprintfcat(text, maxlen, "PORTRAIT_FLIPPED");
+        break;
+    default:
+        SDL_snprintfcat(text, maxlen, "0x%8.8x", orientation);
+        break;
+    }
+}
+
+static void
+SDLTest_PrintWindowFlag(char* text, size_t maxlen, Uint32 flag)
+{
+    switch (flag) {
+    case SDL_WINDOW_FULLSCREEN:
+        SDL_snprintfcat(text, maxlen, "FULLSCREEN");
+        break;
+    case SDL_WINDOW_OPENGL:
+        SDL_snprintfcat(text, maxlen, "OPENGL");
+        break;
+    case SDL_WINDOW_SHOWN:
+        SDL_snprintfcat(text, maxlen, "SHOWN");
+        break;
+    case SDL_WINDOW_HIDDEN:
+        SDL_snprintfcat(text, maxlen, "HIDDEN");
+        break;
+    case SDL_WINDOW_BORDERLESS:
+        SDL_snprintfcat(text, maxlen, "BORDERLESS");
+        break;
+    case SDL_WINDOW_RESIZABLE:
+        SDL_snprintfcat(text, maxlen, "RESIZABLE");
+        break;
+    case SDL_WINDOW_MINIMIZED:
+        SDL_snprintfcat(text, maxlen, "MINIMIZED");
+        break;
+    case SDL_WINDOW_MAXIMIZED:
+        SDL_snprintfcat(text, maxlen, "MAXIMIZED");
+        break;
+    case SDL_WINDOW_MOUSE_GRABBED:
+        SDL_snprintfcat(text, maxlen, "MOUSE_GRABBED");
+        break;
+    case SDL_WINDOW_INPUT_FOCUS:
+        SDL_snprintfcat(text, maxlen, "INPUT_FOCUS");
+        break;
+    case SDL_WINDOW_MOUSE_FOCUS:
+        SDL_snprintfcat(text, maxlen, "MOUSE_FOCUS");
+        break;
+    case SDL_WINDOW_FULLSCREEN_DESKTOP:
+        SDL_snprintfcat(text, maxlen, "FULLSCREEN_DESKTOP");
+        break;
+    case SDL_WINDOW_FOREIGN:
+        SDL_snprintfcat(text, maxlen, "FOREIGN");
+        break;
+    case SDL_WINDOW_ALLOW_HIGHDPI:
+        SDL_snprintfcat(text, maxlen, "ALLOW_HIGHDPI");
+        break;
+    case SDL_WINDOW_MOUSE_CAPTURE:
+        SDL_snprintfcat(text, maxlen, "MOUSE_CAPTURE");
+        break;
+    case SDL_WINDOW_ALWAYS_ON_TOP:
+        SDL_snprintfcat(text, maxlen, "ALWAYS_ON_TOP");
+        break;
+    case SDL_WINDOW_SKIP_TASKBAR:
+        SDL_snprintfcat(text, maxlen, "SKIP_TASKBAR");
+        break;
+    case SDL_WINDOW_UTILITY:
+        SDL_snprintfcat(text, maxlen, "UTILITY");
+        break;
+    case SDL_WINDOW_TOOLTIP:
+        SDL_snprintfcat(text, maxlen, "TOOLTIP");
+        break;
+    case SDL_WINDOW_POPUP_MENU:
+        SDL_snprintfcat(text, maxlen, "POPUP_MENU");
+        break;
+    case SDL_WINDOW_KEYBOARD_GRABBED:
+        SDL_snprintfcat(text, maxlen, "KEYBOARD_GRABBED");
+        break;
+    case SDL_WINDOW_VULKAN:
+        SDL_snprintfcat(text, maxlen, "VULKAN");
+        break;
+    case SDL_WINDOW_METAL:
+        SDL_snprintfcat(text, maxlen, "METAL");
+        break;
+    default:
+        SDL_snprintfcat(text, maxlen, "0x%8.8x", flag);
+        break;
+    }
+}
+
+static void
+SDLTest_PrintWindowFlags(char* text, size_t maxlen, Uint32 flags)
+{
+    const Uint32 window_flags[] = {
+        SDL_WINDOW_FULLSCREEN,
+        SDL_WINDOW_OPENGL,
+        SDL_WINDOW_SHOWN,
+        SDL_WINDOW_HIDDEN,
+        SDL_WINDOW_BORDERLESS,
+        SDL_WINDOW_RESIZABLE,
+        SDL_WINDOW_MINIMIZED,
+        SDL_WINDOW_MAXIMIZED,
+        SDL_WINDOW_MOUSE_GRABBED,
+        SDL_WINDOW_INPUT_FOCUS,
+        SDL_WINDOW_MOUSE_FOCUS,
+        SDL_WINDOW_FULLSCREEN_DESKTOP,
+        SDL_WINDOW_FOREIGN,
+        SDL_WINDOW_ALLOW_HIGHDPI,
+        SDL_WINDOW_MOUSE_CAPTURE,
+        SDL_WINDOW_ALWAYS_ON_TOP,
+        SDL_WINDOW_SKIP_TASKBAR,
+        SDL_WINDOW_UTILITY,
+        SDL_WINDOW_TOOLTIP,
+        SDL_WINDOW_POPUP_MENU,
+        SDL_WINDOW_KEYBOARD_GRABBED,
+        SDL_WINDOW_VULKAN,
+        SDL_WINDOW_METAL
+    };
+
+    int i;
+    int count = 0;
+    for (i = 0; i < (sizeof(window_flags) / sizeof(window_flags[0])); ++i) {
+        const Uint32 flag = window_flags[i];
+        if ((flags & flag) == flag) {
+            if (count > 0) {
+                SDL_snprintfcat(text, maxlen, " | ");
+            }
+            SDLTest_PrintWindowFlag(text, maxlen, flag);
+            ++count;
+        }
+    }
+}
+
+static void
+SDLTest_PrintButtonMask(char* text, size_t maxlen, Uint32 flags)
+{
+    int i;
+    int count = 0;
+    for (i = 1; i <= 32; ++i) {
+        const Uint32 flag = SDL_BUTTON(i);
+        if ((flags & flag) == flag) {
+            if (count > 0) {
+                SDL_snprintfcat(text, maxlen, " | ");
+            }
+            SDL_snprintfcat(text, maxlen, "SDL_BUTTON(%d)", i);
+            ++count;
+        }
+    }
+}
+
 static void
 SDLTest_PrintRendererFlag(char *text, size_t maxlen, Uint32 flag)
 {
@@ -734,7 +965,7 @@ SDLTest_PrintRenderer(SDL_RendererInfo * info)
 
     SDL_Log("  Renderer %s:\n", info->name);
 
-    SDL_snprintf(text, sizeof(text), "    Flags: 0x%8.8X", info->flags);
+    SDL_snprintf(text, sizeof(text), "    Flags: 0x%8.8" SDL_PRIX32, info->flags);
     SDL_snprintfcat(text, sizeof(text), " (");
     count = 0;
     for (i = 0; i < sizeof(info->flags) * 8; ++i) {
@@ -750,7 +981,7 @@ SDLTest_PrintRenderer(SDL_RendererInfo * info)
     SDL_snprintfcat(text, sizeof(text), ")");
     SDL_Log("%s\n", text);
 
-    SDL_snprintf(text, sizeof(text), "    Texture formats (%d): ", info->num_texture_formats);
+    SDL_snprintf(text, sizeof(text), "    Texture formats (%" SDL_PRIu32 "): ", info->num_texture_formats);
     for (i = 0; i < (int) info->num_texture_formats; ++i) {
         if (i > 0) {
             SDL_snprintfcat(text, sizeof(text), ", ");
@@ -931,11 +1162,11 @@ SDLTest_CommonInit(SDLTest_CommonState * state)
                         mode.w, mode.h, mode.refresh_rate, bpp,
                         SDL_GetPixelFormatName(mode.format));
                 if (Rmask || Gmask || Bmask) {
-                    SDL_Log("      Red Mask   = 0x%.8x\n", Rmask);
-                    SDL_Log("      Green Mask = 0x%.8x\n", Gmask);
-                    SDL_Log("      Blue Mask  = 0x%.8x\n", Bmask);
+                    SDL_Log("      Red Mask   = 0x%.8" SDL_PRIx32 "\n", Rmask);
+                    SDL_Log("      Green Mask = 0x%.8" SDL_PRIx32 "\n", Gmask);
+                    SDL_Log("      Blue Mask  = 0x%.8" SDL_PRIx32 "\n", Bmask);
                     if (Amask)
-                        SDL_Log("      Alpha Mask = 0x%.8x\n", Amask);
+                        SDL_Log("      Alpha Mask = 0x%.8" SDL_PRIx32 "\n", Amask);
                 }
 
                 /* Print available fullscreen video modes */
@@ -952,14 +1183,14 @@ SDLTest_CommonInit(SDLTest_CommonState * state)
                                 j, mode.w, mode.h, mode.refresh_rate, bpp,
                                 SDL_GetPixelFormatName(mode.format));
                         if (Rmask || Gmask || Bmask) {
-                            SDL_Log("        Red Mask   = 0x%.8x\n",
+                            SDL_Log("        Red Mask   = 0x%.8" SDL_PRIx32 "\n",
                                     Rmask);
-                            SDL_Log("        Green Mask = 0x%.8x\n",
+                            SDL_Log("        Green Mask = 0x%.8" SDL_PRIx32 "\n",
                                     Gmask);
-                            SDL_Log("        Blue Mask  = 0x%.8x\n",
+                            SDL_Log("        Blue Mask  = 0x%.8" SDL_PRIx32 "\n",
                                     Bmask);
                             if (Amask)
-                                SDL_Log("        Alpha Mask = 0x%.8x\n",
+                                SDL_Log("        Alpha Mask = 0x%.8" SDL_PRIx32 "\n",
                                         Amask);
                         }
                     }
@@ -1061,7 +1292,7 @@ SDLTest_CommonInit(SDLTest_CommonState * state)
             SDL_GetWindowSize(state->windows[i], &w, &h);
             if (!(state->window_flags & SDL_WINDOW_RESIZABLE) &&
                 (w != state->window_w || h != state->window_h)) {
-                printf("Window requested size %dx%d, got %dx%d\n", state->window_w, state->window_h, w, h);
+                SDL_Log("Window requested size %dx%d, got %dx%d\n", state->window_w, state->window_h, w, h);
                 state->window_w = w;
                 state->window_h = h;
             }
@@ -1087,17 +1318,20 @@ SDLTest_CommonInit(SDLTest_CommonState * state)
 
             SDL_ShowWindow(state->windows[i]);
 
+            if (!SDL_RectEmpty(&state->confine)) {
+                SDL_SetWindowMouseRect(state->windows[i], &state->confine);
+            }
+
             if (!state->skip_renderer
                 && (state->renderdriver
-                    || !(state->window_flags & (SDL_WINDOW_OPENGL | SDL_WINDOW_VULKAN)))) {
+                    || !(state->window_flags & (SDL_WINDOW_OPENGL | SDL_WINDOW_VULKAN | SDL_WINDOW_METAL)))) {
                 m = -1;
                 if (state->renderdriver) {
                     SDL_RendererInfo info;
                     n = SDL_GetNumRenderDrivers();
                     for (j = 0; j < n; ++j) {
                         SDL_GetRenderDriverInfo(j, &info);
-                        if (SDL_strcasecmp(info.name, state->renderdriver) ==
-                            0) {
+                        if (SDL_strcasecmp(info.name, state->renderdriver) == 0) {
                             m = j;
                             break;
                         }
@@ -1238,11 +1472,20 @@ SDLTest_PrintEvent(SDL_Event * event)
     switch (event->type) {
     case SDL_DISPLAYEVENT:
         switch (event->display.event) {
+        case SDL_DISPLAYEVENT_CONNECTED:
+            SDL_Log("SDL EVENT: Display %" SDL_PRIu32 " connected",
+                    event->display.display);
+            break;
         case SDL_DISPLAYEVENT_ORIENTATION:
-            SDL_Log("SDL EVENT: Display %d changed orientation to %s", event->display.display, DisplayOrientationName(event->display.data1));
+            SDL_Log("SDL EVENT: Display %" SDL_PRIu32 " changed orientation to %s",
+                    event->display.display, DisplayOrientationName(event->display.data1));
+            break;
+        case SDL_DISPLAYEVENT_DISCONNECTED:
+            SDL_Log("SDL EVENT: Display %" SDL_PRIu32 " disconnected",
+                    event->display.display);
             break;
         default:
-            SDL_Log("SDL EVENT: Display %d got unknown event 0x%4.4x",
+            SDL_Log("SDL EVENT: Display %" SDL_PRIu32 " got unknown event 0x%4.4x",
                     event->display.display, event->display.event);
             break;
         }
@@ -1250,123 +1493,120 @@ SDLTest_PrintEvent(SDL_Event * event)
     case SDL_WINDOWEVENT:
         switch (event->window.event) {
         case SDL_WINDOWEVENT_SHOWN:
-            SDL_Log("SDL EVENT: Window %d shown", event->window.windowID);
+            SDL_Log("SDL EVENT: Window %" SDL_PRIu32 " shown", event->window.windowID);
             break;
         case SDL_WINDOWEVENT_HIDDEN:
-            SDL_Log("SDL EVENT: Window %d hidden", event->window.windowID);
+            SDL_Log("SDL EVENT: Window %" SDL_PRIu32 " hidden", event->window.windowID);
             break;
         case SDL_WINDOWEVENT_EXPOSED:
-            SDL_Log("SDL EVENT: Window %d exposed", event->window.windowID);
+            SDL_Log("SDL EVENT: Window %" SDL_PRIu32 " exposed", event->window.windowID);
             break;
         case SDL_WINDOWEVENT_MOVED:
-            SDL_Log("SDL EVENT: Window %d moved to %d,%d",
-                    event->window.windowID, event->window.data1,
-                    event->window.data2);
+            SDL_Log("SDL EVENT: Window %" SDL_PRIu32 " moved to %" SDL_PRIs32 ",%" SDL_PRIs32,
+                    event->window.windowID, event->window.data1, event->window.data2);
             break;
         case SDL_WINDOWEVENT_RESIZED:
-            SDL_Log("SDL EVENT: Window %d resized to %dx%d",
-                    event->window.windowID, event->window.data1,
-                    event->window.data2);
+            SDL_Log("SDL EVENT: Window %" SDL_PRIu32 " resized to %" SDL_PRIs32 "x%" SDL_PRIs32,
+                    event->window.windowID, event->window.data1, event->window.data2);
             break;
         case SDL_WINDOWEVENT_SIZE_CHANGED:
-            SDL_Log("SDL EVENT: Window %d changed size to %dx%d",
-                    event->window.windowID, event->window.data1,
-                    event->window.data2);
+            SDL_Log("SDL EVENT: Window %" SDL_PRIu32 " changed size to %" SDL_PRIs32 "x%" SDL_PRIs32,
+                    event->window.windowID, event->window.data1, event->window.data2);
             break;
         case SDL_WINDOWEVENT_MINIMIZED:
-            SDL_Log("SDL EVENT: Window %d minimized", event->window.windowID);
+            SDL_Log("SDL EVENT: Window %" SDL_PRIu32 " minimized", event->window.windowID);
             break;
         case SDL_WINDOWEVENT_MAXIMIZED:
-            SDL_Log("SDL EVENT: Window %d maximized", event->window.windowID);
+            SDL_Log("SDL EVENT: Window %" SDL_PRIu32 " maximized", event->window.windowID);
             break;
         case SDL_WINDOWEVENT_RESTORED:
-            SDL_Log("SDL EVENT: Window %d restored", event->window.windowID);
+            SDL_Log("SDL EVENT: Window %" SDL_PRIu32 " restored", event->window.windowID);
             break;
         case SDL_WINDOWEVENT_ENTER:
-            SDL_Log("SDL EVENT: Mouse entered window %d",
+            SDL_Log("SDL EVENT: Mouse entered window %" SDL_PRIu32 "",
                     event->window.windowID);
             break;
         case SDL_WINDOWEVENT_LEAVE:
-            SDL_Log("SDL EVENT: Mouse left window %d", event->window.windowID);
+            SDL_Log("SDL EVENT: Mouse left window %" SDL_PRIu32 "", event->window.windowID);
             break;
         case SDL_WINDOWEVENT_FOCUS_GAINED:
-            SDL_Log("SDL EVENT: Window %d gained keyboard focus",
+            SDL_Log("SDL EVENT: Window %" SDL_PRIu32 " gained keyboard focus",
                     event->window.windowID);
             break;
         case SDL_WINDOWEVENT_FOCUS_LOST:
-            SDL_Log("SDL EVENT: Window %d lost keyboard focus",
+            SDL_Log("SDL EVENT: Window %" SDL_PRIu32 " lost keyboard focus",
                     event->window.windowID);
             break;
         case SDL_WINDOWEVENT_CLOSE:
-            SDL_Log("SDL EVENT: Window %d closed", event->window.windowID);
+            SDL_Log("SDL EVENT: Window %" SDL_PRIu32 " closed", event->window.windowID);
             break;
         case SDL_WINDOWEVENT_TAKE_FOCUS:
-            SDL_Log("SDL EVENT: Window %d take focus", event->window.windowID);
+            SDL_Log("SDL EVENT: Window %" SDL_PRIu32 " take focus", event->window.windowID);
             break;
         case SDL_WINDOWEVENT_HIT_TEST:
-            SDL_Log("SDL EVENT: Window %d hit test", event->window.windowID);
+            SDL_Log("SDL EVENT: Window %" SDL_PRIu32 " hit test", event->window.windowID);
             break;
         default:
-            SDL_Log("SDL EVENT: Window %d got unknown event 0x%4.4x",
+            SDL_Log("SDL EVENT: Window %" SDL_PRIu32 " got unknown event 0x%4.4x",
                     event->window.windowID, event->window.event);
             break;
         }
         break;
     case SDL_KEYDOWN:
-        SDL_Log("SDL EVENT: Keyboard: key pressed  in window %d: scancode 0x%08X = %s, keycode 0x%08X = %s",
+        SDL_Log("SDL EVENT: Keyboard: key pressed  in window %" SDL_PRIu32 ": scancode 0x%08X = %s, keycode 0x%08" SDL_PRIX32 " = %s",
                 event->key.windowID,
                 event->key.keysym.scancode,
                 SDL_GetScancodeName(event->key.keysym.scancode),
                 event->key.keysym.sym, SDL_GetKeyName(event->key.keysym.sym));
         break;
     case SDL_KEYUP:
-        SDL_Log("SDL EVENT: Keyboard: key released in window %d: scancode 0x%08X = %s, keycode 0x%08X = %s",
+        SDL_Log("SDL EVENT: Keyboard: key released in window %" SDL_PRIu32 ": scancode 0x%08X = %s, keycode 0x%08" SDL_PRIX32 " = %s",
                 event->key.windowID,
                 event->key.keysym.scancode,
                 SDL_GetScancodeName(event->key.keysym.scancode),
                 event->key.keysym.sym, SDL_GetKeyName(event->key.keysym.sym));
         break;
     case SDL_TEXTEDITING:
-        SDL_Log("SDL EVENT: Keyboard: text editing \"%s\" in window %d",
+        SDL_Log("SDL EVENT: Keyboard: text editing \"%s\" in window %" SDL_PRIu32,
                 event->edit.text, event->edit.windowID);
         break;
     case SDL_TEXTINPUT:
-        SDL_Log("SDL EVENT: Keyboard: text input \"%s\" in window %d",
+        SDL_Log("SDL EVENT: Keyboard: text input \"%s\" in window %" SDL_PRIu32,
                 event->text.text, event->text.windowID);
         break;
     case SDL_KEYMAPCHANGED:
         SDL_Log("SDL EVENT: Keymap changed");
         break;
     case SDL_MOUSEMOTION:
-        SDL_Log("SDL EVENT: Mouse: moved to %d,%d (%d,%d) in window %d",
+        SDL_Log("SDL EVENT: Mouse: moved to %" SDL_PRIs32 ",%" SDL_PRIs32 " (%" SDL_PRIs32 ",%" SDL_PRIs32 ") in window %" SDL_PRIu32,
                 event->motion.x, event->motion.y,
                 event->motion.xrel, event->motion.yrel,
                 event->motion.windowID);
         break;
     case SDL_MOUSEBUTTONDOWN:
-        SDL_Log("SDL EVENT: Mouse: button %d pressed at %d,%d with click count %d in window %d",
+        SDL_Log("SDL EVENT: Mouse: button %d pressed at %" SDL_PRIs32 ",%" SDL_PRIs32 " with click count %d in window %" SDL_PRIu32,
                 event->button.button, event->button.x, event->button.y, event->button.clicks,
                 event->button.windowID);
         break;
     case SDL_MOUSEBUTTONUP:
-        SDL_Log("SDL EVENT: Mouse: button %d released at %d,%d with click count %d in window %d",
+        SDL_Log("SDL EVENT: Mouse: button %d released at %" SDL_PRIs32 ",%" SDL_PRIs32 " with click count %d in window %" SDL_PRIu32,
                 event->button.button, event->button.x, event->button.y, event->button.clicks,
                 event->button.windowID);
         break;
     case SDL_MOUSEWHEEL:
-        SDL_Log("SDL EVENT: Mouse: wheel scrolled %d in x and %d in y (reversed: %d) in window %d",
+        SDL_Log("SDL EVENT: Mouse: wheel scrolled %" SDL_PRIs32 " in x and %" SDL_PRIs32 " in y (reversed: %" SDL_PRIu32 ") in window %" SDL_PRIu32,
                 event->wheel.x, event->wheel.y, event->wheel.direction, event->wheel.windowID);
         break;
     case SDL_JOYDEVICEADDED:
-        SDL_Log("SDL EVENT: Joystick index %d attached",
+        SDL_Log("SDL EVENT: Joystick index %" SDL_PRIs32 " attached",
             event->jdevice.which);
         break;
     case SDL_JOYDEVICEREMOVED:
-        SDL_Log("SDL EVENT: Joystick %d removed",
+        SDL_Log("SDL EVENT: Joystick %" SDL_PRIs32 " removed",
             event->jdevice.which);
         break;
     case SDL_JOYBALLMOTION:
-        SDL_Log("SDL EVENT: Joystick %d: ball %d moved by %d,%d",
+        SDL_Log("SDL EVENT: Joystick %" SDL_PRIs32 ": ball %d moved by %d,%d",
                 event->jball.which, event->jball.ball, event->jball.xrel,
                 event->jball.yrel);
         break;
@@ -1402,40 +1642,40 @@ SDLTest_PrintEvent(SDL_Event * event)
                 position = "LEFTUP";
                 break;
             }
-            SDL_Log("SDL EVENT: Joystick %d: hat %d moved to %s", event->jhat.which,
-                event->jhat.hat, position);
+            SDL_Log("SDL EVENT: Joystick %" SDL_PRIs32 ": hat %d moved to %s",
+                    event->jhat.which, event->jhat.hat, position);
         }
         break;
     case SDL_JOYBUTTONDOWN:
-        SDL_Log("SDL EVENT: Joystick %d: button %d pressed",
+        SDL_Log("SDL EVENT: Joystick %" SDL_PRIs32 ": button %d pressed",
                 event->jbutton.which, event->jbutton.button);
         break;
     case SDL_JOYBUTTONUP:
-        SDL_Log("SDL EVENT: Joystick %d: button %d released",
+        SDL_Log("SDL EVENT: Joystick %" SDL_PRIs32 ": button %d released",
                 event->jbutton.which, event->jbutton.button);
         break;
     case SDL_CONTROLLERDEVICEADDED:
-        SDL_Log("SDL EVENT: Controller index %d attached",
+        SDL_Log("SDL EVENT: Controller index %" SDL_PRIs32 " attached",
             event->cdevice.which);
         break;
     case SDL_CONTROLLERDEVICEREMOVED:
-        SDL_Log("SDL EVENT: Controller %d removed",
+        SDL_Log("SDL EVENT: Controller %" SDL_PRIs32 " removed",
             event->cdevice.which);
         break;
     case SDL_CONTROLLERAXISMOTION:
-        SDL_Log("SDL EVENT: Controller %d axis %d ('%s') value: %d",
+        SDL_Log("SDL EVENT: Controller %" SDL_PRIs32 " axis %d ('%s') value: %d",
             event->caxis.which,
             event->caxis.axis,
             ControllerAxisName((SDL_GameControllerAxis)event->caxis.axis),
             event->caxis.value);
         break;
     case SDL_CONTROLLERBUTTONDOWN:
-        SDL_Log("SDL EVENT: Controller %d button %d ('%s') down",
+        SDL_Log("SDL EVENT: Controller %" SDL_PRIs32 "button %d ('%s') down",
             event->cbutton.which, event->cbutton.button,
             ControllerButtonName((SDL_GameControllerButton)event->cbutton.button));
         break;
     case SDL_CONTROLLERBUTTONUP:
-        SDL_Log("SDL EVENT: Controller %d button %d ('%s') up",
+        SDL_Log("SDL EVENT: Controller %" SDL_PRIs32 " button %d ('%s') up",
             event->cbutton.which, event->cbutton.button,
             ControllerButtonName((SDL_GameControllerButton)event->cbutton.button));
         break;
@@ -1510,10 +1750,10 @@ SDLTest_PrintEvent(SDL_Event * event)
         SDL_Log("SDL EVENT: Quit requested");
         break;
     case SDL_USEREVENT:
-        SDL_Log("SDL EVENT: User event %d", event->user.code);
+        SDL_Log("SDL EVENT: User event %" SDL_PRIs32, event->user.code);
         break;
     default:
-        SDL_Log("Unknown event 0x%4.4x", event->type);
+        SDL_Log("Unknown event 0x%4.4" SDL_PRIu32, event->type);
         break;
     }
 }
@@ -1612,6 +1852,16 @@ SDLTest_CommonEvent(SDLTest_CommonState * state, SDL_Event * event, int *done)
                 }
             }
             break;
+        case SDL_WINDOWEVENT_FOCUS_LOST:
+            if (state->flash_on_focus_loss) {
+                SDL_Window *window = SDL_GetWindowFromID(event->window.windowID);
+                if (window) {
+                    SDL_FlashWindow(window, SDL_FLASH_UNTIL_FOCUSED);
+                }
+            }
+            break;
+        default:
+            break;
         }
         break;
     case SDL_KEYDOWN: {
@@ -1686,7 +1936,7 @@ SDLTest_CommonEvent(SDLTest_CommonState * state, SDL_Event * event, int *done)
                     const int delta = 100;
                     int x, y;
                     SDL_GetWindowPosition(window, &x, &y);
-                    
+
                     if (event->key.keysym.sym == SDLK_UP)    y -= delta;
                     if (event->key.keysym.sym == SDLK_DOWN)  y += delta;
                     if (event->key.keysym.sym == SDLK_LEFT)  x -= delta;
@@ -1719,7 +1969,7 @@ SDLTest_CommonEvent(SDLTest_CommonState * state, SDL_Event * event, int *done)
             if (withControl) {
                 /* Ctrl-C copy awesome text! */
                 SDL_SetClipboardText("SDL rocks!\nYou know it!");
-                printf("Copied text to clipboard\n");
+                SDL_Log("Copied text to clipboard\n");
             }
             if (withAlt) {
                 /* Alt-C toggle a render clip rectangle */
@@ -1755,22 +2005,40 @@ SDLTest_CommonEvent(SDLTest_CommonState * state, SDL_Event * event, int *done)
                 /* Ctrl-V paste awesome text! */
                 char *text = SDL_GetClipboardText();
                 if (*text) {
-                    printf("Clipboard: %s\n", text);
+                    SDL_Log("Clipboard: %s\n", text);
                 } else {
-                    printf("Clipboard is empty\n");
+                    SDL_Log("Clipboard is empty\n");
                 }
                 SDL_free(text);
             }
             break;
+        case SDLK_f:
+            if (withControl) {
+                /* Ctrl-F flash the window */
+                SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
+                if (window) {
+                    SDL_FlashWindow(window, SDL_FLASH_BRIEFLY);
+                }
+            }
+            break;
         case SDLK_g:
             if (withControl) {
-                /* Ctrl-G toggle grab */
+                /* Ctrl-G toggle mouse grab */
                 SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
                 if (window) {
                     SDL_SetWindowGrab(window, !SDL_GetWindowGrab(window) ? SDL_TRUE : SDL_FALSE);
                 }
             }
             break;
+        case SDLK_k:
+            if (withControl) {
+                /* Ctrl-K toggle keyboard grab */
+                SDL_Window* window = SDL_GetWindowFromID(event->key.windowID);
+                if (window) {
+                    SDL_SetWindowKeyboardGrab(window, !SDL_GetWindowKeyboardGrab(window) ? SDL_TRUE : SDL_FALSE);
+                }
+            }
+            break;
         case SDLK_m:
             if (withControl) {
                 /* Ctrl-M maximize */
@@ -1791,6 +2059,20 @@ SDLTest_CommonEvent(SDLTest_CommonState * state, SDL_Event * event, int *done)
                 SDL_SetRelativeMouseMode(!SDL_GetRelativeMouseMode() ? SDL_TRUE : SDL_FALSE);
             }
             break;
+        case SDLK_t:
+            if (withControl) {
+                /* Ctrl-T toggle topmost mode */
+                SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
+                if (window) {
+                    Uint32 flags = SDL_GetWindowFlags(window);
+                    if (flags & SDL_WINDOW_ALWAYS_ON_TOP) {
+                        SDL_SetWindowAlwaysOnTop(window, SDL_FALSE);
+                    } else {
+                        SDL_SetWindowAlwaysOnTop(window, SDL_TRUE);
+                    }
+                }
+            }
+            break;
         case SDLK_z:
             if (withControl) {
                 /* Ctrl-Z minimize */
@@ -1885,7 +2167,8 @@ SDLTest_CommonEvent(SDLTest_CommonState * state, SDL_Event * event, int *done)
             char message[256];
             SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
 
-            SDL_snprintf(message, sizeof(message), "(%i, %i), rel (%i, %i)\n", lastEvent.x, lastEvent.y, lastEvent.xrel, lastEvent.yrel);
+            SDL_snprintf(message, sizeof(message), "(%" SDL_PRIs32 ", %" SDL_PRIs32 "), rel (%" SDL_PRIs32 ", %" SDL_PRIs32 ")\n",
+                    lastEvent.x, lastEvent.y, lastEvent.xrel, lastEvent.yrel);
             SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION, "Last mouse position", message, window);
             break;
         }
@@ -1948,4 +2231,172 @@ SDLTest_CommonQuit(SDLTest_CommonState * state)
     SDLTest_LogAllocations();
 }
 
+void
+SDLTest_CommonDrawWindowInfo(SDL_Renderer * renderer, SDL_Window * window, int * usedHeight)
+{
+    char text[1024];
+    int textY = 0;
+    const int lineHeight = 10;
+    int x, y, w, h;
+    SDL_Rect rect;
+    SDL_DisplayMode mode;
+    float ddpi, hdpi, vdpi;
+    float scaleX, scaleY;
+    Uint32 flags;
+    const int windowDisplayIndex = SDL_GetWindowDisplayIndex(window);
+    SDL_RendererInfo info;
+
+    /* Video */
+
+    SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
+    SDLTest_DrawString(renderer, 0, textY, "-- Video --");
+    textY += lineHeight;
+
+    SDL_SetRenderDrawColor(renderer, 170, 170, 170, 255);
+
+    SDL_snprintf(text, sizeof(text), "SDL_GetCurrentVideoDriver: %s", SDL_GetCurrentVideoDriver());
+    SDLTest_DrawString(renderer, 0, textY, text);
+    textY += lineHeight;
+
+    /* Renderer */
+
+    SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
+    SDLTest_DrawString(renderer, 0, textY, "-- Renderer --");
+    textY += lineHeight;
+
+    SDL_SetRenderDrawColor(renderer, 170, 170, 170, 255);
+
+    if (0 == SDL_GetRendererInfo(renderer, &info)) {
+        SDL_snprintf(text, sizeof(text), "SDL_GetRendererInfo: name: %s", info.name);
+        SDLTest_DrawString(renderer, 0, textY, text);
+        textY += lineHeight;
+    }
+
+    if (0 == SDL_GetRendererOutputSize(renderer, &w, &h)) {
+        SDL_snprintf(text, sizeof(text), "SDL_GetRendererOutputSize: %dx%d", w, h);
+        SDLTest_DrawString(renderer, 0, textY, text);
+        textY += lineHeight;
+    }
+
+    SDL_RenderGetViewport(renderer, &rect);
+    SDL_snprintf(text, sizeof(text), "SDL_RenderGetViewport: %d,%d, %dx%d",
+                 rect.x, rect.y, rect.w, rect.h);
+    SDLTest_DrawString(renderer, 0, textY, text);
+    textY += lineHeight;
+
+    SDL_RenderGetScale(renderer, &scaleX, &scaleY);
+    SDL_snprintf(text, sizeof(text), "SDL_RenderGetScale: %f,%f",
+                 scaleX, scaleY);
+    SDLTest_DrawString(renderer, 0, textY, text);
+    textY += lineHeight;
+
+    SDL_RenderGetLogicalSize(renderer, &w, &h);
+    SDL_snprintf(text, sizeof(text), "SDL_RenderGetLogicalSize: %dx%d", w, h);
+    SDLTest_DrawString(renderer, 0, textY, text);
+    textY += lineHeight;
+
+    /* Window */
+
+    SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
+    SDLTest_DrawString(renderer, 0, textY, "-- Window --");
+    textY += lineHeight;
+
+    SDL_SetRenderDrawColor(renderer, 170, 170, 170, 255);
+
+    SDL_GetWindowPosition(window, &x, &y);
+    SDL_snprintf(text, sizeof(text), "SDL_GetWindowPosition: %d,%d", x, y);
+    SDLTest_DrawString(renderer, 0, textY, text);
+    textY += lineHeight;
+
+    SDL_GetWindowSize(window, &w, &h);
+    SDL_snprintf(text, sizeof(text), "SDL_GetWindowSize: %dx%d", w, h);
+    SDLTest_DrawString(renderer, 0, textY, text);
+    textY += lineHeight;
+
+    SDL_snprintf(text, sizeof(text), "SDL_GetWindowFlags: ");
+    SDLTest_PrintWindowFlags(text, sizeof(text), SDL_GetWindowFlags(window));
+    SDLTest_DrawString(renderer, 0, textY, text);
+    textY += lineHeight;
+
+    if (0 == SDL_GetWindowDisplayMode(window, &mode)) {
+        SDL_snprintf(text, sizeof(text), "SDL_GetWindowDisplayMode: %dx%d@%dHz (%s)",
+            mode.w, mode.h, mode.refresh_rate, SDL_GetPixelFormatName(mode.format));
+        SDLTest_DrawString(renderer, 0, textY, text);
+        textY += lineHeight;
+    }
+
+    /* Display */
+
+    SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
+    SDLTest_DrawString(renderer, 0, textY, "-- Display --");
+    textY += lineHeight;
+
+    SDL_SetRenderDrawColor(renderer, 170, 170, 170, 255);
+
+    SDL_snprintf(text, sizeof(text), "SDL_GetWindowDisplayIndex: %d", windowDisplayIndex);
+    SDLTest_DrawString(renderer, 0, textY, text);
+    textY += lineHeight;
+
+    SDL_snprintf(text, sizeof(text), "SDL_GetDisplayName: %s", SDL_GetDisplayName(windowDisplayIndex));
+    SDLTest_DrawString(renderer, 0, textY, text);
+    textY += lineHeight;
+
+    if (0 == SDL_GetDisplayBounds(windowDisplayIndex, &rect)) {
+        SDL_snprintf(text, sizeof(text), "SDL_GetDisplayBounds: %d,%d, %dx%d",
+                     rect.x, rect.y, rect.w, rect.h);
+        SDLTest_DrawString(renderer, 0, textY, text);
+        textY += lineHeight;
+    }
+
+    if (0 == SDL_GetCurrentDisplayMode(windowDisplayIndex, &mode)) {
+        SDL_snprintf(text, sizeof(text), "SDL_GetCurrentDisplayMode: %dx%d@%d",
+                     mode.w, mode.h, mode.refresh_rate);
+        SDLTest_DrawString(renderer, 0, textY, text);
+        textY += lineHeight;
+    }
+
+    if (0 == SDL_GetDesktopDisplayMode(windowDisplayIndex, &mode)) {
+        SDL_snprintf(text, sizeof(text), "SDL_GetDesktopDisplayMode: %dx%d@%d",
+                     mode.w, mode.h, mode.refresh_rate);
+        SDLTest_DrawString(renderer, 0, textY, text);
+        textY += lineHeight;
+    }
+
+    if (0 == SDL_GetDisplayDPI(windowDisplayIndex, &ddpi, &hdpi, &vdpi)) {
+        SDL_snprintf(text, sizeof(text), "SDL_GetDisplayDPI: ddpi: %f, hdpi: %f, vdpi: %f",
+                     ddpi, hdpi, vdpi);
+        SDLTest_DrawString(renderer, 0, textY, text);
+        textY += lineHeight;
+    }
+
+    SDL_snprintf(text, sizeof(text), "SDL_GetDisplayOrientation: ");
+    SDLTest_PrintDisplayOrientation(text, sizeof(text), SDL_GetDisplayOrientation(windowDisplayIndex));
+    SDLTest_DrawString(renderer, 0, textY, text);
+    textY += lineHeight;
+
+    /* Mouse */
+
+    SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
+    SDLTest_DrawString(renderer, 0, textY, "-- Mouse --");
+    textY += lineHeight;
+
+    SDL_SetRenderDrawColor(renderer, 170, 170, 170, 255);
+
+    flags = SDL_GetMouseState(&x, &y);
+    SDL_snprintf(text, sizeof(text), "SDL_GetMouseState: %d,%d ", x, y);
+    SDLTest_PrintButtonMask(text, sizeof(text), flags);
+    SDLTest_DrawString(renderer, 0, textY, text);
+    textY += lineHeight;
+
+    flags = SDL_GetGlobalMouseState(&x, &y);
+    SDL_snprintf(text, sizeof(text), "SDL_GetGlobalMouseState: %d,%d ", x, y);
+    SDLTest_PrintButtonMask(text, sizeof(text), flags);
+    SDLTest_DrawString(renderer, 0, textY, text);
+    textY += lineHeight;
+
+    if (usedHeight) {
+        *usedHeight = textY;
+    }
+}
+
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/test/SDL_test_compare.c b/Engine/lib/sdl/src/test/SDL_test_compare.c
index 5b19be3fa..157bd2ff8 100644
--- a/Engine/lib/sdl/src/test/SDL_test_compare.c
+++ b/Engine/lib/sdl/src/test/SDL_test_compare.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/test/SDL_test_crc32.c b/Engine/lib/sdl/src/test/SDL_test_crc32.c
index 8ba9442bf..cfc5a641c 100644
--- a/Engine/lib/sdl/src/test/SDL_test_crc32.c
+++ b/Engine/lib/sdl/src/test/SDL_test_crc32.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/test/SDL_test_font.c b/Engine/lib/sdl/src/test/SDL_test_font.c
index e185408a8..4129f3da2 100644
--- a/Engine/lib/sdl/src/test/SDL_test_font.c
+++ b/Engine/lib/sdl/src/test/SDL_test_font.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -3109,10 +3109,16 @@ static unsigned char SDLTest_FontData[SDL_TESTFONTDATAMAX] = {
 
 /* ---- Character */
 
+struct SDLTest_CharTextureCache {
+    SDL_Renderer* renderer;
+    SDL_Texture* charTextureCache[256];
+    struct SDLTest_CharTextureCache* next;
+};
+
 /*!
-\brief Global cache for 8x8 pixel font textures created at runtime.
+\brief List of per-renderer caches for 8x8 pixel font textures created at runtime.
 */
-static SDL_Texture *SDLTest_CharTextureCache[256];
+static struct SDLTest_CharTextureCache *SDLTest_CharTextureCacheList;
 
 int SDLTest_DrawCharacter(SDL_Renderer *renderer, int x, int y, char c)
 {
@@ -3131,6 +3137,7 @@ int SDLTest_DrawCharacter(SDL_Renderer *renderer, int x, int y, char c)
     SDL_Surface *character;
     Uint32 ci;
     Uint8 r, g, b, a;
+    struct SDLTest_CharTextureCache *cache;
 
     /*
      * Setup source rectangle
@@ -3151,10 +3158,25 @@ int SDLTest_DrawCharacter(SDL_Renderer *renderer, int x, int y, char c)
     /* Character index in cache */
     ci = (unsigned char)c;
 
+    /* Search for this renderer's cache */
+    for (cache = SDLTest_CharTextureCacheList; cache != NULL; cache = cache->next) {
+        if (cache->renderer == renderer) {
+            break;
+        }
+    }
+
+    /* Allocate a new cache for this renderer if needed */
+    if (cache == NULL) {        
+        cache = (struct SDLTest_CharTextureCache*)SDL_calloc(1, sizeof(struct SDLTest_CharTextureCache));
+        cache->renderer = renderer;
+        cache->next = SDLTest_CharTextureCacheList;
+        SDLTest_CharTextureCacheList = cache;
+    }
+
     /*
      * Create new charWidth x charHeight bitmap surface if not already present.
      */
-    if (SDLTest_CharTextureCache[ci] == NULL) {
+    if (cache->charTextureCache[ci] == NULL) {
         /*
          * Redraw character into surface
          */
@@ -3191,14 +3213,15 @@ int SDLTest_DrawCharacter(SDL_Renderer *renderer, int x, int y, char c)
             linepos += pitch;
         }
 
+
         /* Convert temp surface into texture */
-        SDLTest_CharTextureCache[ci] = SDL_CreateTextureFromSurface(renderer, character);
+        cache->charTextureCache[ci] = SDL_CreateTextureFromSurface(renderer, character);
         SDL_FreeSurface(character);
 
         /*
          * Check pointer
          */
-        if (SDLTest_CharTextureCache[ci] == NULL) {
+        if (cache->charTextureCache[ci] == NULL) {
             return (-1);
         }
     }
@@ -3208,13 +3231,13 @@ int SDLTest_DrawCharacter(SDL_Renderer *renderer, int x, int y, char c)
      */
     result = 0;
     result |= SDL_GetRenderDrawColor(renderer, &r, &g, &b, &a);
-    result |= SDL_SetTextureColorMod(SDLTest_CharTextureCache[ci], r, g, b);
-    result |= SDL_SetTextureAlphaMod(SDLTest_CharTextureCache[ci], a);
+    result |= SDL_SetTextureColorMod(cache->charTextureCache[ci], r, g, b);
+    result |= SDL_SetTextureAlphaMod(cache->charTextureCache[ci], a);
 
     /*
      * Draw texture onto destination
      */
-    result |= SDL_RenderCopy(renderer, SDLTest_CharTextureCache[ci], &srect, &drect);
+    result |= SDL_RenderCopy(renderer, cache->charTextureCache[ci], &srect, &drect);
 
     return (result);
 }
@@ -3239,12 +3262,23 @@ int SDLTest_DrawString(SDL_Renderer * renderer, int x, int y, const char *s)
 void SDLTest_CleanupTextDrawing(void)
 {
     unsigned int i;
-    for (i = 0; i < SDL_arraysize(SDLTest_CharTextureCache); ++i) {
-        if (SDLTest_CharTextureCache[i]) {
-            SDL_DestroyTexture(SDLTest_CharTextureCache[i]);
-            SDLTest_CharTextureCache[i] = NULL;
+    struct SDLTest_CharTextureCache* cache, *next;
+
+    cache = SDLTest_CharTextureCacheList;
+    do {
+        for (i = 0; i < SDL_arraysize(cache->charTextureCache); ++i) {
+            if (cache->charTextureCache[i]) {
+                SDL_DestroyTexture(cache->charTextureCache[i]);
+                cache->charTextureCache[i] = NULL;
+            }
         }
-    }
+
+        next = cache->next;
+        SDL_free(cache);
+        cache = next;
+    } while (cache);
+
+    SDLTest_CharTextureCacheList = NULL;
 }
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/test/SDL_test_fuzzer.c b/Engine/lib/sdl/src/test/SDL_test_fuzzer.c
index 458d934a0..98fb09df6 100644
--- a/Engine/lib/sdl/src/test/SDL_test_fuzzer.c
+++ b/Engine/lib/sdl/src/test/SDL_test_fuzzer.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/test/SDL_test_harness.c b/Engine/lib/sdl/src/test/SDL_test_harness.c
index 7b27a5e28..8f10f3e5c 100644
--- a/Engine/lib/sdl/src/test/SDL_test_harness.c
+++ b/Engine/lib/sdl/src/test/SDL_test_harness.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -98,7 +98,7 @@ SDLTest_GenerateRunSeed(const int length)
 *
 */
 static Uint64
-SDLTest_GenerateExecKey(const char *runSeed, char *suiteName, char *testName, int iteration)
+SDLTest_GenerateExecKey(const char *runSeed, const char *suiteName, const char *testName, int iteration)
 {
     SDLTest_Md5Context md5Context;
     Uint64 *keys;
@@ -240,7 +240,7 @@ SDLTest_RunTest(SDLTest_TestSuiteReference *testSuite, const SDLTest_TestCaseRef
         return TEST_RESULT_SETUP_FAILURE;
     }
 
-	if (!testCase->enabled && forceTestRun == SDL_FALSE)
+    if (!testCase->enabled && forceTestRun == SDL_FALSE)
     {
         SDLTest_Log(SDLTEST_FINAL_RESULT_FORMAT, "Test", testCase->name, "Skipped (Disabled)");
         return TEST_RESULT_SKIPPED;
@@ -316,7 +316,7 @@ SDLTest_RunTest(SDLTest_TestSuiteReference *testSuite, const SDLTest_TestCaseRef
 }
 
 /* Prints summary of all suites/tests contained in the given reference */
-#if 0 
+#if 0
 static void SDLTest_LogTestSuiteSummary(SDLTest_TestSuiteReference *testSuites)
 {
     int suiteCounter;
@@ -377,8 +377,8 @@ int SDLTest_RunSuites(SDLTest_TestSuiteReference *testSuites[], const char *user
     SDLTest_TestSuiteReference *testSuite;
     const SDLTest_TestCaseReference *testCase;
     const char *runSeed = NULL;
-    char *currentSuiteName;
-    char *currentTestName;
+    const char *currentSuiteName;
+    const char *currentTestName;
     Uint64 execKey;
     float runStartSeconds;
     float suiteStartSeconds;
@@ -388,10 +388,10 @@ int SDLTest_RunSuites(SDLTest_TestSuiteReference *testSuites[], const char *user
     float testEndSeconds;
     float runtime;
     int suiteFilter = 0;
-    char *suiteFilterName = NULL;
+    const char *suiteFilterName = NULL;
     int testFilter = 0;
-    char *testFilterName = NULL;
-	SDL_bool forceTestRun = SDL_FALSE;
+    const char *testFilterName = NULL;
+    SDL_bool forceTestRun = SDL_FALSE;
     int testResult = 0;
     int runResult = 0;
     int totalTestFailedCount = 0;
@@ -419,7 +419,6 @@ int SDLTest_RunSuites(SDLTest_TestSuiteReference *testSuites[], const char *user
         runSeed = userRunSeed;
     }
 
-
     /* Reset per-run counters */
     totalTestFailedCount = 0;
     totalTestPassedCount = 0;
@@ -431,7 +430,7 @@ int SDLTest_RunSuites(SDLTest_TestSuiteReference *testSuites[], const char *user
     /* Log run with fuzzer parameters */
     SDLTest_Log("::::: Test Run /w seed '%s' started\n", runSeed);
 
-	/* Count the total number of tests */
+    /* Count the total number of tests */
     suiteCounter = 0;
     while (testSuites[suiteCounter]) {
         testSuite = testSuites[suiteCounter];
@@ -440,17 +439,17 @@ int SDLTest_RunSuites(SDLTest_TestSuiteReference *testSuites[], const char *user
         while (testSuite->testCases[testCounter])
         {
             testCounter++;
-			totalNumberOfTests++;
-		}
-	}
+            totalNumberOfTests++;
+        }
+    }
 
-	/* Pre-allocate an array for tracking failed tests (potentially all test cases) */
-	failedTests = (const SDLTest_TestCaseReference **)SDL_malloc(totalNumberOfTests * sizeof(SDLTest_TestCaseReference *));
-	if (failedTests == NULL) {	
-	   SDLTest_LogError("Unable to allocate cache for failed tests");
-           SDL_Error(SDL_ENOMEM);	   
+    /* Pre-allocate an array for tracking failed tests (potentially all test cases) */
+    failedTests = (const SDLTest_TestCaseReference **)SDL_malloc(totalNumberOfTests * sizeof(SDLTest_TestCaseReference *));
+    if (failedTests == NULL) {    
+       SDLTest_LogError("Unable to allocate cache for failed tests");
+           SDL_Error(SDL_ENOMEM);       
            return -1;
-	}
+    }
 
     /* Initialize filtering */
     if (filter != NULL && filter[0] != '\0') {
@@ -542,7 +541,7 @@ int SDLTest_RunSuites(SDLTest_TestSuiteReference *testSuites[], const char *user
                     /* Override 'disabled' flag if we specified a test filter (i.e. force run for debugging) */
                     if (testFilter == 1 && !testCase->enabled) {
                         SDLTest_Log("Force run of disabled test since test filter was set");
-						forceTestRun = SDL_TRUE;
+                        forceTestRun = SDL_TRUE;
                     }
 
                     /* Take time - test start */
@@ -571,7 +570,7 @@ int SDLTest_RunSuites(SDLTest_TestSuiteReference *testSuites[], const char *user
                         }
 
                         SDLTest_Log("Test Iteration %i: execKey %" SDL_PRIu64, iterationCounter, execKey);
-						testResult = SDLTest_RunTest(testSuite, testCase, execKey, forceTestRun);
+                        testResult = SDLTest_RunTest(testSuite, testCase, execKey, forceTestRun);
 
                         if (testResult == TEST_RESULT_PASSED) {
                             testPassedCount++;
diff --git a/Engine/lib/sdl/src/test/SDL_test_imageBlit.c b/Engine/lib/sdl/src/test/SDL_test_imageBlit.c
index 9aa557eb1..7a45127a2 100644
--- a/Engine/lib/sdl/src/test/SDL_test_imageBlit.c
+++ b/Engine/lib/sdl/src/test/SDL_test_imageBlit.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/test/SDL_test_imageBlitBlend.c b/Engine/lib/sdl/src/test/SDL_test_imageBlitBlend.c
index 4f6c894fc..d57899edb 100644
--- a/Engine/lib/sdl/src/test/SDL_test_imageBlitBlend.c
+++ b/Engine/lib/sdl/src/test/SDL_test_imageBlitBlend.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/test/SDL_test_imageFace.c b/Engine/lib/sdl/src/test/SDL_test_imageFace.c
index 54a4803ec..27f8c8463 100644
--- a/Engine/lib/sdl/src/test/SDL_test_imageFace.c
+++ b/Engine/lib/sdl/src/test/SDL_test_imageFace.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/test/SDL_test_imagePrimitives.c b/Engine/lib/sdl/src/test/SDL_test_imagePrimitives.c
index 0f76d5783..20e95d662 100644
--- a/Engine/lib/sdl/src/test/SDL_test_imagePrimitives.c
+++ b/Engine/lib/sdl/src/test/SDL_test_imagePrimitives.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/test/SDL_test_imagePrimitivesBlend.c b/Engine/lib/sdl/src/test/SDL_test_imagePrimitivesBlend.c
index ca6c7f7a4..5997f9c35 100644
--- a/Engine/lib/sdl/src/test/SDL_test_imagePrimitivesBlend.c
+++ b/Engine/lib/sdl/src/test/SDL_test_imagePrimitivesBlend.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/test/SDL_test_log.c b/Engine/lib/sdl/src/test/SDL_test_log.c
index 9d4b6abb5..01b4f7b87 100644
--- a/Engine/lib/sdl/src/test/SDL_test_log.c
+++ b/Engine/lib/sdl/src/test/SDL_test_log.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/test/SDL_test_md5.c b/Engine/lib/sdl/src/test/SDL_test_md5.c
index e749fb851..662e2fa0c 100644
--- a/Engine/lib/sdl/src/test/SDL_test_md5.c
+++ b/Engine/lib/sdl/src/test/SDL_test_md5.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/test/SDL_test_memory.c b/Engine/lib/sdl/src/test/SDL_test_memory.c
index c9f552035..067b7a5b3 100644
--- a/Engine/lib/sdl/src/test/SDL_test_memory.c
+++ b/Engine/lib/sdl/src/test/SDL_test_memory.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -26,6 +26,7 @@
 #include "SDL_test_memory.h"
 
 #ifdef HAVE_LIBUNWIND_H
+#define UNW_LOCAL_ONLY
 #include <libunwind.h>
 #endif
 
@@ -103,13 +104,13 @@ static void SDL_TrackAllocation(void *mem, size_t size)
         stack_index = 0;
         while (unw_step(&cursor) > 0) {
             unw_word_t offset, pc;
-            char sym[256];
+            char sym[236];
 
             unw_get_reg(&cursor, UNW_REG_IP, &pc);
             entry->stack[stack_index] = pc;
 
             if (unw_get_proc_name(&cursor, sym, sizeof(sym), &offset) == 0) {
-                snprintf(entry->stack_names[stack_index], sizeof(entry->stack_names[stack_index]), "%s+0x%llx", sym, (unsigned long long)offset);
+                SDL_snprintf(entry->stack_names[stack_index], sizeof(entry->stack_names[stack_index]), "%s+0x%llx", sym, (unsigned long long)offset);
             }
             ++stack_index;
 
diff --git a/Engine/lib/sdl/src/test/SDL_test_random.c b/Engine/lib/sdl/src/test/SDL_test_random.c
index 1fe63441c..c52e050bb 100644
--- a/Engine/lib/sdl/src/test/SDL_test_random.c
+++ b/Engine/lib/sdl/src/test/SDL_test_random.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -83,7 +83,8 @@ unsigned int SDLTest_Random(SDLTest_RandomContext * rndContext)
 
   if (rndContext==NULL) return -1;
 
-  xh = rndContext->x >> 16, xl = rndContext->x & 65535;
+  xh = rndContext->x >> 16;
+  xl = rndContext->x & 65535;
   rndContext->x = rndContext->x * rndContext->a + rndContext->c;
   rndContext->c =
     xh * rndContext->ah + ((xh * rndContext->al) >> 16) +
diff --git a/Engine/lib/sdl/src/thread/SDL_systhread.h b/Engine/lib/sdl/src/thread/SDL_systhread.h
index 77dc09845..fd4492c9b 100644
--- a/Engine/lib/sdl/src/thread/SDL_systhread.h
+++ b/Engine/lib/sdl/src/thread/SDL_systhread.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/thread/SDL_thread.c b/Engine/lib/sdl/src/thread/SDL_thread.c
index 5757ba000..61af43f0c 100644
--- a/Engine/lib/sdl/src/thread/SDL_thread.c
+++ b/Engine/lib/sdl/src/thread/SDL_thread.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -82,7 +82,7 @@ SDL_TLSSet(SDL_TLSID id, const void *value, void (SDLCALL *destructor)(void *))
     return 0;
 }
 
-static void
+void
 SDL_TLSCleanup()
 {
     SDL_TLSData *storage;
@@ -141,10 +141,10 @@ SDL_Generic_GetTLSData(void)
         }
         SDL_AtomicUnlock(&tls_lock);
     }
-#endif /* SDL_THREADS_DISABLED */
-
     SDL_MemoryBarrierAcquire();
     SDL_LockMutex(SDL_generic_TLS_mutex);
+#endif /* SDL_THREADS_DISABLED */
+
     for (entry = SDL_generic_TLS; entry; entry = entry->next) {
         if (entry->thread == thread) {
             storage = entry->storage;
diff --git a/Engine/lib/sdl/src/thread/SDL_thread_c.h b/Engine/lib/sdl/src/thread/SDL_thread_c.h
index c82b59e23..fb0885a2d 100644
--- a/Engine/lib/sdl/src/thread/SDL_thread_c.h
+++ b/Engine/lib/sdl/src/thread/SDL_thread_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -34,6 +34,8 @@
 #include "windows/SDL_systhread_c.h"
 #elif SDL_THREAD_PSP
 #include "psp/SDL_systhread_c.h"
+#elif SDL_THREAD_VITA
+#include "vita/SDL_systhread_c.h"
 #elif SDL_THREAD_STDCPP
 #include "stdcpp/SDL_systhread_c.h"
 #elif SDL_THREAD_OS2
diff --git a/Engine/lib/sdl/src/thread/generic/SDL_syscond.c b/Engine/lib/sdl/src/thread/generic/SDL_syscond.c
index 5cd97457a..59e8ce076 100644
--- a/Engine/lib/sdl/src/thread/generic/SDL_syscond.c
+++ b/Engine/lib/sdl/src/thread/generic/SDL_syscond.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -28,41 +28,57 @@
 
 #include "SDL_thread.h"
 
-struct SDL_cond
+#include "../generic/SDL_syscond_c.h"
+
+/* If two implementations are to be compiled into SDL (the active one
+ * will be chosen at runtime), the function names need to be
+ * suffixed
+ */
+#if !SDL_THREAD_GENERIC_COND_SUFFIX
+#define SDL_CreateCond_generic      SDL_CreateCond
+#define SDL_DestroyCond_generic     SDL_DestroyCond
+#define SDL_CondSignal_generic      SDL_CondSignal
+#define SDL_CondBroadcast_generic   SDL_CondBroadcast
+#define SDL_CondWait_generic        SDL_CondWait
+#define SDL_CondWaitTimeout_generic SDL_CondWaitTimeout
+#endif
+
+typedef struct SDL_cond_generic
 {
     SDL_mutex *lock;
     int waiting;
     int signals;
     SDL_sem *wait_sem;
     SDL_sem *wait_done;
-};
+} SDL_cond_generic;
 
 /* Create a condition variable */
 SDL_cond *
-SDL_CreateCond(void)
+SDL_CreateCond_generic(void)
 {
-    SDL_cond *cond;
+    SDL_cond_generic *cond;
 
-    cond = (SDL_cond *) SDL_malloc(sizeof(SDL_cond));
+    cond = (SDL_cond_generic *) SDL_malloc(sizeof(SDL_cond_generic));
     if (cond) {
         cond->lock = SDL_CreateMutex();
         cond->wait_sem = SDL_CreateSemaphore(0);
         cond->wait_done = SDL_CreateSemaphore(0);
         cond->waiting = cond->signals = 0;
         if (!cond->lock || !cond->wait_sem || !cond->wait_done) {
-            SDL_DestroyCond(cond);
+            SDL_DestroyCond_generic((SDL_cond *)cond);
             cond = NULL;
         }
     } else {
         SDL_OutOfMemory();
     }
-    return (cond);
+    return (SDL_cond *)cond;
 }
 
 /* Destroy a condition variable */
 void
-SDL_DestroyCond(SDL_cond * cond)
+SDL_DestroyCond_generic(SDL_cond * _cond)
 {
+    SDL_cond_generic *cond = (SDL_cond_generic *)_cond;
     if (cond) {
         if (cond->wait_sem) {
             SDL_DestroySemaphore(cond->wait_sem);
@@ -79,10 +95,11 @@ SDL_DestroyCond(SDL_cond * cond)
 
 /* Restart one of the threads that are waiting on the condition variable */
 int
-SDL_CondSignal(SDL_cond * cond)
+SDL_CondSignal_generic(SDL_cond * _cond)
 {
+    SDL_cond_generic *cond = (SDL_cond_generic *)_cond;
     if (!cond) {
-        return SDL_SetError("Passed a NULL condition variable");
+        return SDL_InvalidParamError("cond");
     }
 
     /* If there are waiting threads not already signalled, then
@@ -103,10 +120,11 @@ SDL_CondSignal(SDL_cond * cond)
 
 /* Restart all threads that are waiting on the condition variable */
 int
-SDL_CondBroadcast(SDL_cond * cond)
+SDL_CondBroadcast_generic(SDL_cond * _cond)
 {
+    SDL_cond_generic *cond = (SDL_cond_generic *)_cond;
     if (!cond) {
-        return SDL_SetError("Passed a NULL condition variable");
+        return SDL_InvalidParamError("cond");
     }
 
     /* If there are waiting threads not already signalled, then
@@ -157,12 +175,13 @@ Thread B:
     SDL_UnlockMutex(lock);
  */
 int
-SDL_CondWaitTimeout(SDL_cond * cond, SDL_mutex * mutex, Uint32 ms)
+SDL_CondWaitTimeout_generic(SDL_cond * _cond, SDL_mutex * mutex, Uint32 ms)
 {
+    SDL_cond_generic *cond = (SDL_cond_generic *)_cond;
     int retval;
 
     if (!cond) {
-        return SDL_SetError("Passed a NULL condition variable");
+        return SDL_InvalidParamError("cond");
     }
 
     /* Obtain the protection mutex, and increment the number of waiters.
@@ -212,9 +231,9 @@ SDL_CondWaitTimeout(SDL_cond * cond, SDL_mutex * mutex, Uint32 ms)
 
 /* Wait on the condition variable forever */
 int
-SDL_CondWait(SDL_cond * cond, SDL_mutex * mutex)
+SDL_CondWait_generic(SDL_cond * cond, SDL_mutex * mutex)
 {
-    return SDL_CondWaitTimeout(cond, mutex, SDL_MUTEX_MAXWAIT);
+    return SDL_CondWaitTimeout_generic(cond, mutex, SDL_MUTEX_MAXWAIT);
 }
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/thread/generic/SDL_syscond_c.h b/Engine/lib/sdl/src/thread/generic/SDL_syscond_c.h
new file mode 100644
index 000000000..b7dadc781
--- /dev/null
+++ b/Engine/lib/sdl/src/thread/generic/SDL_syscond_c.h
@@ -0,0 +1,42 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#include "SDL_thread.h"
+
+#ifndef SDL_syscond_generic_h_
+#define SDL_syscond_generic_h_
+
+#if SDL_THREAD_GENERIC_COND_SUFFIX
+
+SDL_cond * SDL_CreateCond_generic(void);
+void SDL_DestroyCond_generic(SDL_cond * cond);
+int SDL_CondSignal_generic(SDL_cond * cond);
+int SDL_CondBroadcast_generic(SDL_cond * cond);
+int SDL_CondWait_generic(SDL_cond * cond, SDL_mutex * mutex);
+int SDL_CondWaitTimeout_generic(SDL_cond * cond,
+                                SDL_mutex * mutex, Uint32 ms);
+
+#endif /* SDL_THREAD_GENERIC_COND_SUFFIX */
+
+#endif /* SDL_syscond_generic_h_ */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/thread/generic/SDL_sysmutex.c b/Engine/lib/sdl/src/thread/generic/SDL_sysmutex.c
index d3af9c554..42965aa8b 100644
--- a/Engine/lib/sdl/src/thread/generic/SDL_sysmutex.c
+++ b/Engine/lib/sdl/src/thread/generic/SDL_sysmutex.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -78,7 +78,7 @@ SDL_LockMutex(SDL_mutex * mutex)
     SDL_threadID this_thread;
 
     if (mutex == NULL) {
-        return SDL_SetError("Passed a NULL mutex");
+        return SDL_InvalidParamError("mutex");
     }
 
     this_thread = SDL_ThreadID();
@@ -109,7 +109,7 @@ SDL_TryLockMutex(SDL_mutex * mutex)
     SDL_threadID this_thread;
 
     if (mutex == NULL) {
-        return SDL_SetError("Passed a NULL mutex");
+        return SDL_InvalidParamError("mutex");
     }
 
     this_thread = SDL_ThreadID();
@@ -139,7 +139,7 @@ SDL_mutexV(SDL_mutex * mutex)
     return 0;
 #else
     if (mutex == NULL) {
-        return SDL_SetError("Passed a NULL mutex");
+        return SDL_InvalidParamError("mutex");
     }
 
     /* If we don't own the mutex, we can't unlock it */
diff --git a/Engine/lib/sdl/src/thread/generic/SDL_sysmutex_c.h b/Engine/lib/sdl/src/thread/generic/SDL_sysmutex_c.h
index 2f8835937..074071a4b 100644
--- a/Engine/lib/sdl/src/thread/generic/SDL_sysmutex_c.h
+++ b/Engine/lib/sdl/src/thread/generic/SDL_sysmutex_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/thread/generic/SDL_syssem.c b/Engine/lib/sdl/src/thread/generic/SDL_syssem.c
index 027d54e66..c21ff196a 100644
--- a/Engine/lib/sdl/src/thread/generic/SDL_syssem.c
+++ b/Engine/lib/sdl/src/thread/generic/SDL_syssem.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -132,7 +132,7 @@ SDL_SemTryWait(SDL_sem * sem)
     int retval;
 
     if (!sem) {
-        return SDL_SetError("Passed a NULL semaphore");
+        return SDL_InvalidParamError("sem");
     }
 
     retval = SDL_MUTEX_TIMEDOUT;
@@ -152,7 +152,7 @@ SDL_SemWaitTimeout(SDL_sem * sem, Uint32 timeout)
     int retval;
 
     if (!sem) {
-        return SDL_SetError("Passed a NULL semaphore");
+        return SDL_InvalidParamError("sem");
     }
 
     /* A timeout of 0 is an easy case */
@@ -200,7 +200,7 @@ int
 SDL_SemPost(SDL_sem * sem)
 {
     if (!sem) {
-        return SDL_SetError("Passed a NULL semaphore");
+        return SDL_InvalidParamError("sem");
     }
 
     SDL_LockMutex(sem->count_lock);
diff --git a/Engine/lib/sdl/src/thread/generic/SDL_systhread.c b/Engine/lib/sdl/src/thread/generic/SDL_systhread.c
index 3a4d6a22e..e36bf4c1c 100644
--- a/Engine/lib/sdl/src/thread/generic/SDL_systhread.c
+++ b/Engine/lib/sdl/src/thread/generic/SDL_systhread.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/thread/generic/SDL_systhread_c.h b/Engine/lib/sdl/src/thread/generic/SDL_systhread_c.h
index 53cb82ef5..bdca9a408 100644
--- a/Engine/lib/sdl/src/thread/generic/SDL_systhread_c.h
+++ b/Engine/lib/sdl/src/thread/generic/SDL_systhread_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/thread/generic/SDL_systls.c b/Engine/lib/sdl/src/thread/generic/SDL_systls.c
index b814b9bc0..d4c371c39 100644
--- a/Engine/lib/sdl/src/thread/generic/SDL_systls.c
+++ b/Engine/lib/sdl/src/thread/generic/SDL_systls.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/thread/os2/SDL_sysmutex.c b/Engine/lib/sdl/src/thread/os2/SDL_sysmutex.c
index d9a0b0f42..984ae10fe 100644
--- a/Engine/lib/sdl/src/thread/os2/SDL_sysmutex.c
+++ b/Engine/lib/sdl/src/thread/os2/SDL_sysmutex.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -73,7 +73,7 @@ SDL_LockMutex(SDL_mutex * mutex)
     HMTX  hMtx = (HMTX)mutex;
 
     if (hMtx == NULLHANDLE)
-        return SDL_SetError("Passed a NULL mutex");
+        return SDL_InvalidParamError("mutex");
 
     ulRC = DosRequestMutexSem(hMtx, SEM_INDEFINITE_WAIT);
     if (ulRC != NO_ERROR) {
@@ -92,7 +92,7 @@ SDL_TryLockMutex(SDL_mutex * mutex)
     HMTX  hMtx = (HMTX)mutex;
 
     if (hMtx == NULLHANDLE)
-        return SDL_SetError("Passed a NULL mutex");
+        return SDL_InvalidParamError("mutex");
 
     ulRC = DosRequestMutexSem(hMtx, SEM_IMMEDIATE_RETURN);
 
@@ -115,7 +115,7 @@ SDL_UnlockMutex(SDL_mutex * mutex)
     HMTX  hMtx = (HMTX)mutex;
 
     if (hMtx == NULLHANDLE)
-        return SDL_SetError("Passed a NULL mutex");
+        return SDL_InvalidParamError("mutex");
 
     ulRC = DosReleaseMutexSem(hMtx);
     if (ulRC != NO_ERROR)
diff --git a/Engine/lib/sdl/src/thread/os2/SDL_syssem.c b/Engine/lib/sdl/src/thread/os2/SDL_syssem.c
index 01b5db3cf..79bf0673f 100644
--- a/Engine/lib/sdl/src/thread/os2/SDL_syssem.c
+++ b/Engine/lib/sdl/src/thread/os2/SDL_syssem.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -89,7 +89,7 @@ SDL_SemWaitTimeout(SDL_sem * sem, Uint32 timeout)
     ULONG cPost;
 
     if (sem == NULL)
-        return SDL_SetError("Passed a NULL sem");
+        return SDL_InvalidParamError("sem");
 
     if (timeout != SEM_INDEFINITE_WAIT)
         DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &ulStartTime, sizeof(ULONG));
@@ -147,7 +147,7 @@ SDL_SemValue(SDL_sem * sem)
     ULONG ulRC;
 
     if (sem == NULL) {
-        SDL_SetError("Passed a NULL sem");
+        SDL_InvalidParamError("sem");
         return 0;
     }
 
@@ -167,7 +167,7 @@ SDL_SemPost(SDL_sem * sem)
     ULONG ulRC;
 
     if (sem == NULL)
-        return SDL_SetError("Passed a NULL sem");
+        return SDL_InvalidParamError("sem");
 
     ulRC = DosRequestMutexSem(sem->hMtx, SEM_INDEFINITE_WAIT);
     if (ulRC != NO_ERROR)
diff --git a/Engine/lib/sdl/src/thread/os2/SDL_systhread.c b/Engine/lib/sdl/src/thread/os2/SDL_systhread.c
index bf395ed4f..8c64e9c32 100644
--- a/Engine/lib/sdl/src/thread/os2/SDL_systhread.c
+++ b/Engine/lib/sdl/src/thread/os2/SDL_systhread.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/thread/os2/SDL_systhread_c.h b/Engine/lib/sdl/src/thread/os2/SDL_systhread_c.h
index 1bc942154..dedceb396 100644
--- a/Engine/lib/sdl/src/thread/os2/SDL_systhread_c.h
+++ b/Engine/lib/sdl/src/thread/os2/SDL_systhread_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/thread/os2/SDL_systls.c b/Engine/lib/sdl/src/thread/os2/SDL_systls.c
index 2aa274b77..b48a4bd39 100644
--- a/Engine/lib/sdl/src/thread/os2/SDL_systls.c
+++ b/Engine/lib/sdl/src/thread/os2/SDL_systls.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/thread/os2/SDL_systls_c.h b/Engine/lib/sdl/src/thread/os2/SDL_systls_c.h
index 031b23277..e40d5ddcf 100644
--- a/Engine/lib/sdl/src/thread/os2/SDL_systls_c.h
+++ b/Engine/lib/sdl/src/thread/os2/SDL_systls_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/thread/psp/SDL_syscond.c b/Engine/lib/sdl/src/thread/psp/SDL_syscond.c
index be6a66b71..02307ed9c 100644
--- a/Engine/lib/sdl/src/thread/psp/SDL_syscond.c
+++ b/Engine/lib/sdl/src/thread/psp/SDL_syscond.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -84,7 +84,7 @@ int
 SDL_CondSignal(SDL_cond * cond)
 {
     if (!cond) {
-        return SDL_SetError("Passed a NULL condition variable");
+        return SDL_InvalidParamError("cond");
     }
 
     /* If there are waiting threads not already signalled, then
@@ -108,7 +108,7 @@ int
 SDL_CondBroadcast(SDL_cond * cond)
 {
     if (!cond) {
-        return SDL_SetError("Passed a NULL condition variable");
+        return SDL_InvalidParamError("cond");
     }
 
     /* If there are waiting threads not already signalled, then
@@ -164,7 +164,7 @@ SDL_CondWaitTimeout(SDL_cond * cond, SDL_mutex * mutex, Uint32 ms)
     int retval;
 
     if (!cond) {
-        return SDL_SetError("Passed a NULL condition variable");
+        return SDL_InvalidParamError("cond");
     }
 
     /* Obtain the protection mutex, and increment the number of waiters.
diff --git a/Engine/lib/sdl/src/thread/psp/SDL_sysmutex.c b/Engine/lib/sdl/src/thread/psp/SDL_sysmutex.c
index 3a76e55d4..9e391629a 100644
--- a/Engine/lib/sdl/src/thread/psp/SDL_sysmutex.c
+++ b/Engine/lib/sdl/src/thread/psp/SDL_sysmutex.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -27,30 +27,37 @@
 #include "SDL_thread.h"
 #include "SDL_systhread_c.h"
 
+#include <pspthreadman.h>
+#include <pspkerror.h>
+
+#define SCE_KERNEL_MUTEX_ATTR_RECURSIVE 0x0200U
 
 struct SDL_mutex
 {
-    int recursive;
-    SDL_threadID owner;
-    SDL_sem *sem;
+    SceLwMutexWorkarea lock;
 };
 
 /* Create a mutex */
 SDL_mutex *
 SDL_CreateMutex(void)
 {
-    SDL_mutex *mutex;
+    SDL_mutex *mutex = NULL;
+    SceInt32 res = 0;
 
     /* Allocate mutex memory */
     mutex = (SDL_mutex *) SDL_malloc(sizeof(*mutex));
     if (mutex) {
-        /* Create the mutex semaphore, with initial value 1 */
-        mutex->sem = SDL_CreateSemaphore(1);
-        mutex->recursive = 0;
-        mutex->owner = 0;
-        if (!mutex->sem) {
-            SDL_free(mutex);
-            mutex = NULL;
+
+        res = sceKernelCreateLwMutex(
+            &mutex->lock,
+            "SDL mutex",
+            SCE_KERNEL_MUTEX_ATTR_RECURSIVE,
+            0,
+            NULL
+        );
+
+        if (res < 0) {
+            SDL_SetError("Error trying to create mutex: %x", res);
         }
     } else {
         SDL_OutOfMemory();
@@ -63,37 +70,56 @@ void
 SDL_DestroyMutex(SDL_mutex * mutex)
 {
     if (mutex) {
-        if (mutex->sem) {
-            SDL_DestroySemaphore(mutex->sem);
-        }
+        sceKernelDeleteLwMutex(&mutex->lock);
         SDL_free(mutex);
     }
 }
 
-/* Lock the semaphore */
+/* Try to lock the mutex */
+int
+SDL_TryLockMutex(SDL_mutex * mutex)
+{
+#if SDL_THREADS_DISABLED
+    return 0;
+#else
+    SceInt32 res = 0;
+    if (mutex == NULL) {
+        return SDL_InvalidParamError("mutex");
+    }
+
+    res = sceKernelTryLockLwMutex(&mutex->lock, 1);
+    switch (res) {
+        case SCE_KERNEL_ERROR_OK:
+            return 0;
+            break;
+        case SCE_KERNEL_ERROR_WAIT_TIMEOUT:
+            return SDL_MUTEX_TIMEDOUT;
+            break;
+        default:
+            return SDL_SetError("Error trying to lock mutex: %x", res);
+            break;
+    }
+
+    return -1;
+#endif /* SDL_THREADS_DISABLED */
+}
+
+
+/* Lock the mutex */
 int
 SDL_mutexP(SDL_mutex * mutex)
 {
 #if SDL_THREADS_DISABLED
     return 0;
 #else
-    SDL_threadID this_thread;
-
+    SceInt32 res = 0;
     if (mutex == NULL) {
-        return SDL_SetError("Passed a NULL mutex");
+        return SDL_InvalidParamError("mutex");
     }
 
-    this_thread = SDL_ThreadID();
-    if (mutex->owner == this_thread) {
-        ++mutex->recursive;
-    } else {
-        /* The order of operations is important.
-           We set the locking thread id after we obtain the lock
-           so unlocks from other threads will fail.
-         */
-        SDL_SemWait(mutex->sem);
-        mutex->owner = this_thread;
-        mutex->recursive = 0;
+    res = sceKernelLockLwMutex(&mutex->lock, 1, NULL);
+    if (res != SCE_KERNEL_ERROR_OK) {
+        return SDL_SetError("Error trying to lock mutex: %x", res);
     }
 
     return 0;
@@ -107,30 +133,20 @@ SDL_mutexV(SDL_mutex * mutex)
 #if SDL_THREADS_DISABLED
     return 0;
 #else
+    SceInt32 res = 0;
+
     if (mutex == NULL) {
-        return SDL_SetError("Passed a NULL mutex");
+        return SDL_InvalidParamError("mutex");
     }
 
-    /* If we don't own the mutex, we can't unlock it */
-    if (SDL_ThreadID() != mutex->owner) {
-        return SDL_SetError("mutex not owned by this thread");
+    res = sceKernelUnlockLwMutex(&mutex->lock, 1);
+    if (res != 0) {
+        return SDL_SetError("Error trying to unlock mutex: %x", res);
     }
 
-    if (mutex->recursive) {
-        --mutex->recursive;
-    } else {
-        /* The order of operations is important.
-           First reset the owner so another thread doesn't lock
-           the mutex and set the ownership before we reset it,
-           then release the lock semaphore.
-         */
-        mutex->owner = 0;
-        SDL_SemPost(mutex->sem);
-    }
     return 0;
 #endif /* SDL_THREADS_DISABLED */
 }
-
 #endif /* SDL_THREAD_PSP */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/thread/psp/SDL_sysmutex_c.h b/Engine/lib/sdl/src/thread/psp/SDL_sysmutex_c.h
index 2f8835937..074071a4b 100644
--- a/Engine/lib/sdl/src/thread/psp/SDL_sysmutex_c.h
+++ b/Engine/lib/sdl/src/thread/psp/SDL_sysmutex_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/thread/psp/SDL_syssem.c b/Engine/lib/sdl/src/thread/psp/SDL_syssem.c
index edad3e4e8..640619cd9 100644
--- a/Engine/lib/sdl/src/thread/psp/SDL_syssem.c
+++ b/Engine/lib/sdl/src/thread/psp/SDL_syssem.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -43,13 +43,13 @@ SDL_sem *SDL_CreateSemaphore(Uint32 initial_value)
 {
     SDL_sem *sem;
 
-    sem = (SDL_sem *) malloc(sizeof(*sem));
+    sem = (SDL_sem *) SDL_malloc(sizeof(*sem));
     if (sem != NULL) {
         /* TODO: Figure out the limit on the maximum value. */
         sem->semid = sceKernelCreateSema("SDL sema", 0, initial_value, 255, NULL);
         if (sem->semid < 0) {
             SDL_SetError("Couldn't create semaphore");
-            free(sem);
+            SDL_free(sem);
             sem = NULL;
         }
     } else {
@@ -68,7 +68,7 @@ void SDL_DestroySemaphore(SDL_sem *sem)
             sem->semid = 0;
         }
 
-        free(sem);
+        SDL_free(sem);
     }
 }
 
@@ -82,7 +82,7 @@ int SDL_SemWaitTimeout(SDL_sem *sem, Uint32 timeout)
     int res;
 
     if (sem == NULL) {
-        SDL_SetError("Passed a NULL sem");
+        SDL_InvalidParamError("sem");
         return 0;
     }
 
@@ -128,7 +128,7 @@ Uint32 SDL_SemValue(SDL_sem *sem)
     SceKernelSemaInfo info;
 
     if (sem == NULL) {
-        SDL_SetError("Passed a NULL sem");
+        SDL_InvalidParamError("sem");
         return 0;
     }
 
@@ -144,7 +144,7 @@ int SDL_SemPost(SDL_sem *sem)
     int res;
 
     if (sem == NULL) {
-        return SDL_SetError("Passed a NULL sem");
+        return SDL_InvalidParamError("sem");
     }
 
     res = sceKernelSignalSema(sem->semid, 1);
diff --git a/Engine/lib/sdl/src/thread/psp/SDL_systhread.c b/Engine/lib/sdl/src/thread/psp/SDL_systhread.c
index 789f9a057..50417cb24 100644
--- a/Engine/lib/sdl/src/thread/psp/SDL_systhread.c
+++ b/Engine/lib/sdl/src/thread/psp/SDL_systhread.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -95,13 +95,13 @@ int SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority)
     int value;
 
     if (priority == SDL_THREAD_PRIORITY_LOW) {
-        value = 19;
+        value = 111;
     } else if (priority == SDL_THREAD_PRIORITY_HIGH) {
-        value = -10;
+        value = 32;
     } else if (priority == SDL_THREAD_PRIORITY_TIME_CRITICAL) {
-        value = -20;
+        value = 16;
     } else {
-        value = 0;
+        value = 50;
     }
 
     return sceKernelChangeThreadPriority(sceKernelGetThreadId(),value);
diff --git a/Engine/lib/sdl/src/thread/psp/SDL_systhread_c.h b/Engine/lib/sdl/src/thread/psp/SDL_systhread_c.h
index 4622fd3b5..3209a90b9 100644
--- a/Engine/lib/sdl/src/thread/psp/SDL_systhread_c.h
+++ b/Engine/lib/sdl/src/thread/psp/SDL_systhread_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/thread/pthread/SDL_syscond.c b/Engine/lib/sdl/src/thread/pthread/SDL_syscond.c
index 28cf81912..c84ec7ada 100644
--- a/Engine/lib/sdl/src/thread/pthread/SDL_syscond.c
+++ b/Engine/lib/sdl/src/thread/pthread/SDL_syscond.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -68,7 +68,7 @@ SDL_CondSignal(SDL_cond * cond)
     int retval;
 
     if (!cond) {
-        return SDL_SetError("Passed a NULL condition variable");
+        return SDL_InvalidParamError("cond");
     }
 
     retval = 0;
@@ -85,7 +85,7 @@ SDL_CondBroadcast(SDL_cond * cond)
     int retval;
 
     if (!cond) {
-        return SDL_SetError("Passed a NULL condition variable");
+        return SDL_InvalidParamError("cond");
     }
 
     retval = 0;
@@ -105,7 +105,7 @@ SDL_CondWaitTimeout(SDL_cond * cond, SDL_mutex * mutex, Uint32 ms)
     struct timespec abstime;
 
     if (!cond) {
-        return SDL_SetError("Passed a NULL condition variable");
+        return SDL_InvalidParamError("cond");
     }
 
 #ifdef HAVE_CLOCK_GETTIME
@@ -148,7 +148,7 @@ int
 SDL_CondWait(SDL_cond * cond, SDL_mutex * mutex)
 {
     if (!cond) {
-        return SDL_SetError("Passed a NULL condition variable");
+        return SDL_InvalidParamError("cond");
     } else if (pthread_cond_wait(&cond->cond, &mutex->id) != 0) {
         return SDL_SetError("pthread_cond_wait() failed");
     }
diff --git a/Engine/lib/sdl/src/thread/pthread/SDL_sysmutex.c b/Engine/lib/sdl/src/thread/pthread/SDL_sysmutex.c
index b4ebcc615..c26982aed 100644
--- a/Engine/lib/sdl/src/thread/pthread/SDL_sysmutex.c
+++ b/Engine/lib/sdl/src/thread/pthread/SDL_sysmutex.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -85,7 +85,7 @@ SDL_LockMutex(SDL_mutex * mutex)
 #endif
 
     if (mutex == NULL) {
-        return SDL_SetError("Passed a NULL mutex");
+        return SDL_InvalidParamError("mutex");
     }
 
 #if FAKE_RECURSIVE_MUTEX
@@ -122,7 +122,7 @@ SDL_TryLockMutex(SDL_mutex * mutex)
 #endif
 
     if (mutex == NULL) {
-        return SDL_SetError("Passed a NULL mutex");
+        return SDL_InvalidParamError("mutex");
     }
 
     retval = 0;
@@ -162,7 +162,7 @@ int
 SDL_UnlockMutex(SDL_mutex * mutex)
 {
     if (mutex == NULL) {
-        return SDL_SetError("Passed a NULL mutex");
+        return SDL_InvalidParamError("mutex");
     }
 
 #if FAKE_RECURSIVE_MUTEX
diff --git a/Engine/lib/sdl/src/thread/pthread/SDL_sysmutex_c.h b/Engine/lib/sdl/src/thread/pthread/SDL_sysmutex_c.h
index 8c38367c0..722ed4a18 100644
--- a/Engine/lib/sdl/src/thread/pthread/SDL_sysmutex_c.h
+++ b/Engine/lib/sdl/src/thread/pthread/SDL_sysmutex_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/thread/pthread/SDL_syssem.c b/Engine/lib/sdl/src/thread/pthread/SDL_syssem.c
index 9f3bc30d6..9a0c88822 100644
--- a/Engine/lib/sdl/src/thread/pthread/SDL_syssem.c
+++ b/Engine/lib/sdl/src/thread/pthread/SDL_syssem.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -73,7 +73,7 @@ SDL_SemTryWait(SDL_sem * sem)
     int retval;
 
     if (!sem) {
-        return SDL_SetError("Passed a NULL semaphore");
+        return SDL_InvalidParamError("sem");
     }
     retval = SDL_MUTEX_TIMEDOUT;
     if (sem_trywait(&sem->sem) == 0) {
@@ -88,7 +88,7 @@ SDL_SemWait(SDL_sem * sem)
     int retval;
 
     if (!sem) {
-        return SDL_SetError("Passed a NULL semaphore");
+        return SDL_InvalidParamError("sem");
     }
 
     do {
@@ -115,7 +115,7 @@ SDL_SemWaitTimeout(SDL_sem * sem, Uint32 timeout)
 #endif
 
     if (!sem) {
-        return SDL_SetError("Passed a NULL semaphore");
+        return SDL_InvalidParamError("sem");
     }
 
     /* Try the easy cases first */
@@ -195,7 +195,7 @@ SDL_SemPost(SDL_sem * sem)
     int retval;
 
     if (!sem) {
-        return SDL_SetError("Passed a NULL semaphore");
+        return SDL_InvalidParamError("sem");
     }
 
     retval = sem_post(&sem->sem);
diff --git a/Engine/lib/sdl/src/thread/pthread/SDL_systhread.c b/Engine/lib/sdl/src/thread/pthread/SDL_systhread.c
index afed1d9c8..3b3f40fa1 100644
--- a/Engine/lib/sdl/src/thread/pthread/SDL_systhread.c
+++ b/Engine/lib/sdl/src/thread/pthread/SDL_systhread.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -30,25 +30,24 @@
 #endif
 
 #include <signal.h>
+#include <errno.h>
 
 #ifdef __LINUX__
 #include <sys/time.h>
 #include <sys/resource.h>
 #include <sys/syscall.h>
 #include <unistd.h>
-#include <errno.h>
 
 #include "../../core/linux/SDL_dbus.h"
 #endif /* __LINUX__ */
 
-#if defined(__LINUX__) || defined(__MACOSX__) || defined(__IPHONEOS__)
+#if (defined(__LINUX__) || defined(__MACOSX__) || defined(__IPHONEOS__)) && defined(HAVE_DLOPEN)
 #include <dlfcn.h>
 #ifndef RTLD_DEFAULT
 #define RTLD_DEFAULT NULL
 #endif
 #endif
 
-#include "SDL_platform.h"
 #include "SDL_thread.h"
 #include "../SDL_thread_c.h"
 #include "../SDL_systhread.h"
@@ -79,10 +78,10 @@ RunThread(void *data)
     return NULL;
 }
 
-#if defined(__MACOSX__) || defined(__IPHONEOS__)
+#if (defined(__MACOSX__) || defined(__IPHONEOS__)) && defined(HAVE_DLOPEN)
 static SDL_bool checked_setname = SDL_FALSE;
 static int (*ppthread_setname_np)(const char*) = NULL;
-#elif defined(__LINUX__)
+#elif defined(__LINUX__) && defined(HAVE_DLOPEN)
 static SDL_bool checked_setname = SDL_FALSE;
 static int (*ppthread_setname_np)(pthread_t, const char*) = NULL;
 #endif
@@ -92,7 +91,7 @@ SDL_SYS_CreateThread(SDL_Thread * thread)
     pthread_attr_t type;
 
     /* do this here before any threads exist, so there's no race condition. */
-    #if defined(__MACOSX__) || defined(__IPHONEOS__) || defined(__LINUX__)
+    #if (defined(__MACOSX__) || defined(__IPHONEOS__) || defined(__LINUX__)) && defined(HAVE_DLOPEN)
     if (!checked_setname) {
         void *fn = dlsym(RTLD_DEFAULT, "pthread_setname_np");
         #if defined(__MACOSX__) || defined(__IPHONEOS__)
@@ -132,28 +131,35 @@ SDL_SYS_SetupThread(const char *name)
 #endif /* !__NACL__ */
 
     if (name != NULL) {
-        #if defined(__MACOSX__) || defined(__IPHONEOS__) || defined(__LINUX__)
+        #if (defined(__MACOSX__) || defined(__IPHONEOS__) || defined(__LINUX__)) && defined(HAVE_DLOPEN)
         SDL_assert(checked_setname);
         if (ppthread_setname_np != NULL) {
             #if defined(__MACOSX__) || defined(__IPHONEOS__)
             ppthread_setname_np(name);
             #elif defined(__LINUX__)
-            ppthread_setname_np(pthread_self(), name);
+            if (ppthread_setname_np(pthread_self(), name) == ERANGE) {
+                char namebuf[16]; /* Limited to 16 char */
+                SDL_strlcpy(namebuf, name, sizeof (namebuf));
+                ppthread_setname_np(pthread_self(), namebuf);
+            }
             #endif
         }
         #elif HAVE_PTHREAD_SETNAME_NP
             #if defined(__NETBSD__)
             pthread_setname_np(pthread_self(), "%s", name);
             #else
-            pthread_setname_np(pthread_self(), name);
+            if (pthread_setname_np(pthread_self(), name) == ERANGE) {
+                char namebuf[16]; /* Limited to 16 char */
+                SDL_strlcpy(namebuf, name, sizeof (namebuf));
+                pthread_setname_np(pthread_self(), namebuf);
+            }
             #endif
         #elif HAVE_PTHREAD_SET_NAME_NP
             pthread_set_name_np(pthread_self(), name);
         #elif defined(__HAIKU__)
             /* The docs say the thread name can't be longer than B_OS_NAME_LENGTH. */
             char namebuf[B_OS_NAME_LENGTH];
-            SDL_snprintf(namebuf, sizeof (namebuf), "%s", name);
-            namebuf[sizeof (namebuf) - 1] = '\0';
+            SDL_strlcpy(namebuf, name, sizeof (namebuf));
             rename_thread(find_thread(NULL), namebuf);
         #endif
     }
@@ -184,21 +190,10 @@ SDL_ThreadID(void)
     return ((SDL_threadID) pthread_self());
 }
 
-#if __LINUX__
-/**
-   \brief Sets the SDL priority (not nice level) for a thread, using setpriority() if appropriate, and RealtimeKit if available.
-   Differs from SDL_LinuxSetThreadPriority in also taking the desired scheduler policy,
-   such as SCHED_OTHER or SCHED_RR.
-
-   \return 0 on success, or -1 on error.
- */
-extern DECLSPEC int SDLCALL SDL_LinuxSetThreadPriorityAndPolicy(Sint64 threadID, int sdlPriority, int schedPolicy);
-#endif
-
 int
 SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority)
 {
-#if __NACL__ || __RISCOS__
+#if __NACL__ || __RISCOS__ || __OS2__
     /* FIXME: Setting thread priority does not seem to be supported in NACL */
     return 0;
 #else
diff --git a/Engine/lib/sdl/src/thread/pthread/SDL_systhread_c.h b/Engine/lib/sdl/src/thread/pthread/SDL_systhread_c.h
index 3a9c992eb..fc24425f8 100644
--- a/Engine/lib/sdl/src/thread/pthread/SDL_systhread_c.h
+++ b/Engine/lib/sdl/src/thread/pthread/SDL_systhread_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/thread/pthread/SDL_systls.c b/Engine/lib/sdl/src/thread/pthread/SDL_systls.c
index e14571ca0..c55c69720 100644
--- a/Engine/lib/sdl/src/thread/pthread/SDL_systls.c
+++ b/Engine/lib/sdl/src/thread/pthread/SDL_systls.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/thread/stdcpp/SDL_syscond.cpp b/Engine/lib/sdl/src/thread/stdcpp/SDL_syscond.cpp
index a50000768..90c38adba 100644
--- a/Engine/lib/sdl/src/thread/stdcpp/SDL_syscond.cpp
+++ b/Engine/lib/sdl/src/thread/stdcpp/SDL_syscond.cpp
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -70,8 +70,7 @@ int
 SDL_CondSignal(SDL_cond * cond)
 {
     if (!cond) {
-        SDL_SetError("Passed a NULL condition variable");
-        return -1;
+        return SDL_InvalidParamError("cond");
     }
 
     cond->cpp_cond.notify_one();
@@ -84,8 +83,7 @@ int
 SDL_CondBroadcast(SDL_cond * cond)
 {
     if (!cond) {
-        SDL_SetError("Passed a NULL condition variable");
-        return -1;
+        return SDL_InvalidParamError("cond");
     }
 
     cond->cpp_cond.notify_all();
@@ -118,13 +116,11 @@ int
 SDL_CondWaitTimeout(SDL_cond * cond, SDL_mutex * mutex, Uint32 ms)
 {
     if (!cond) {
-        SDL_SetError("Passed a NULL condition variable");
-        return -1;
+        return SDL_InvalidParamError("cond");
     }
 
     if (!mutex) {
-        SDL_SetError("Passed a NULL mutex variable");
-        return -1;
+        return SDL_InvalidParamError("mutex");
     }
 
     try {
@@ -148,8 +144,7 @@ SDL_CondWaitTimeout(SDL_cond * cond, SDL_mutex * mutex, Uint32 ms)
             }
         }
     } catch (std::system_error & ex) {
-        SDL_SetError("unable to wait on a C++ condition variable: code=%d; %s", ex.code(), ex.what());
-        return -1;
+        return SDL_SetError("unable to wait on a C++ condition variable: code=%d; %s", ex.code(), ex.what());
     }
 }
 
diff --git a/Engine/lib/sdl/src/thread/stdcpp/SDL_sysmutex.cpp b/Engine/lib/sdl/src/thread/stdcpp/SDL_sysmutex.cpp
index b852c2d76..828801046 100644
--- a/Engine/lib/sdl/src/thread/stdcpp/SDL_sysmutex.cpp
+++ b/Engine/lib/sdl/src/thread/stdcpp/SDL_sysmutex.cpp
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -65,16 +65,14 @@ int
 SDL_mutexP(SDL_mutex * mutex)
 {
     if (mutex == NULL) {
-        SDL_SetError("Passed a NULL mutex");
-        return -1;
+        return SDL_InvalidParamError("mutex");
     }
 
     try {
         mutex->cpp_mutex.lock();
         return 0;
     } catch (std::system_error & ex) {
-        SDL_SetError("unable to lock a C++ mutex: code=%d; %s", ex.code(), ex.what());
-        return -1;
+        return SDL_SetError("unable to lock a C++ mutex: code=%d; %s", ex.code(), ex.what());
     }
 }
 
@@ -84,7 +82,7 @@ SDL_TryLockMutex(SDL_mutex * mutex)
 {
     int retval = 0;
     if (mutex == NULL) {
-        return SDL_SetError("Passed a NULL mutex");
+        return SDL_InvalidParamError("mutex");
     }
 
     if (mutex->cpp_mutex.try_lock() == false) {
@@ -99,8 +97,7 @@ int
 SDL_mutexV(SDL_mutex * mutex)
 {
     if (mutex == NULL) {
-        SDL_SetError("Passed a NULL mutex");
-        return -1;
+        return SDL_InvalidParamError("mutex");
     }
 
     mutex->cpp_mutex.unlock();
diff --git a/Engine/lib/sdl/src/thread/stdcpp/SDL_sysmutex_c.h b/Engine/lib/sdl/src/thread/stdcpp/SDL_sysmutex_c.h
index f86995f1f..d80897e25 100644
--- a/Engine/lib/sdl/src/thread/stdcpp/SDL_sysmutex_c.h
+++ b/Engine/lib/sdl/src/thread/stdcpp/SDL_sysmutex_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/thread/stdcpp/SDL_systhread.cpp b/Engine/lib/sdl/src/thread/stdcpp/SDL_systhread.cpp
index a61e7240e..3d818ac56 100644
--- a/Engine/lib/sdl/src/thread/stdcpp/SDL_systhread.cpp
+++ b/Engine/lib/sdl/src/thread/stdcpp/SDL_systhread.cpp
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -52,11 +52,9 @@ SDL_SYS_CreateThread(SDL_Thread * thread)
         thread->handle = (void *) new std::thread(std::move(cpp_thread));
         return 0;
     } catch (std::system_error & ex) {
-        SDL_SetError("unable to start a C++ thread: code=%d; %s", ex.code(), ex.what());
-        return -1;
+        return SDL_SetError("unable to start a C++ thread: code=%d; %s", ex.code(), ex.what());
     } catch (std::bad_alloc &) {
-        SDL_OutOfMemory();
-        return -1;
+        return SDL_OutOfMemory();
     }
 }
 
diff --git a/Engine/lib/sdl/src/thread/stdcpp/SDL_systhread_c.h b/Engine/lib/sdl/src/thread/stdcpp/SDL_systhread_c.h
index 919d71c97..57c660a85 100644
--- a/Engine/lib/sdl/src/thread/stdcpp/SDL_systhread_c.h
+++ b/Engine/lib/sdl/src/thread/stdcpp/SDL_systhread_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/thread/vita/SDL_syscond.c b/Engine/lib/sdl/src/thread/vita/SDL_syscond.c
new file mode 100644
index 000000000..c6e46c475
--- /dev/null
+++ b/Engine/lib/sdl/src/thread/vita/SDL_syscond.c
@@ -0,0 +1,224 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if SDL_THREAD_VITA
+
+/* An implementation of condition variables using semaphores and mutexes */
+/*
+   This implementation borrows heavily from the BeOS condition variable
+   implementation, written by Christopher Tate and Owen Smith.  Thanks!
+ */
+
+#include "SDL_thread.h"
+
+struct SDL_cond
+{
+    SDL_mutex *lock;
+    int waiting;
+    int signals;
+    SDL_sem *wait_sem;
+    SDL_sem *wait_done;
+};
+
+/* Create a condition variable */
+SDL_cond *
+SDL_CreateCond(void)
+{
+    SDL_cond *cond;
+
+    cond = (SDL_cond *) SDL_malloc(sizeof(SDL_cond));
+    if (cond) {
+        cond->lock = SDL_CreateMutex();
+        cond->wait_sem = SDL_CreateSemaphore(0);
+        cond->wait_done = SDL_CreateSemaphore(0);
+        cond->waiting = cond->signals = 0;
+        if (!cond->lock || !cond->wait_sem || !cond->wait_done) {
+            SDL_DestroyCond(cond);
+            cond = NULL;
+        }
+    } else {
+        SDL_OutOfMemory();
+    }
+    return (cond);
+}
+
+/* Destroy a condition variable */
+void
+SDL_DestroyCond(SDL_cond * cond)
+{
+    if (cond) {
+        if (cond->wait_sem) {
+            SDL_DestroySemaphore(cond->wait_sem);
+        }
+        if (cond->wait_done) {
+            SDL_DestroySemaphore(cond->wait_done);
+        }
+        if (cond->lock) {
+            SDL_DestroyMutex(cond->lock);
+        }
+        SDL_free(cond);
+    }
+}
+
+/* Restart one of the threads that are waiting on the condition variable */
+int
+SDL_CondSignal(SDL_cond * cond)
+{
+    if (!cond) {
+        return SDL_InvalidParamError("cond");
+    }
+
+    /* If there are waiting threads not already signalled, then
+       signal the condition and wait for the thread to respond.
+     */
+    SDL_LockMutex(cond->lock);
+    if (cond->waiting > cond->signals) {
+        ++cond->signals;
+        SDL_SemPost(cond->wait_sem);
+        SDL_UnlockMutex(cond->lock);
+        SDL_SemWait(cond->wait_done);
+    } else {
+        SDL_UnlockMutex(cond->lock);
+    }
+
+    return 0;
+}
+
+/* Restart all threads that are waiting on the condition variable */
+int
+SDL_CondBroadcast(SDL_cond * cond)
+{
+    if (!cond) {
+        return SDL_InvalidParamError("cond");
+    }
+
+    /* If there are waiting threads not already signalled, then
+       signal the condition and wait for the thread to respond.
+     */
+    SDL_LockMutex(cond->lock);
+    if (cond->waiting > cond->signals) {
+        int i, num_waiting;
+
+        num_waiting = (cond->waiting - cond->signals);
+        cond->signals = cond->waiting;
+        for (i = 0; i < num_waiting; ++i) {
+            SDL_SemPost(cond->wait_sem);
+        }
+        /* Now all released threads are blocked here, waiting for us.
+           Collect them all (and win fabulous prizes!) :-)
+         */
+        SDL_UnlockMutex(cond->lock);
+        for (i = 0; i < num_waiting; ++i) {
+            SDL_SemWait(cond->wait_done);
+        }
+    } else {
+        SDL_UnlockMutex(cond->lock);
+    }
+
+    return 0;
+}
+
+/* Wait on the condition variable for at most 'ms' milliseconds.
+   The mutex must be locked before entering this function!
+   The mutex is unlocked during the wait, and locked again after the wait.
+
+Typical use:
+
+Thread A:
+    SDL_LockMutex(lock);
+    while ( ! condition ) {
+        SDL_CondWait(cond, lock);
+    }
+    SDL_UnlockMutex(lock);
+
+Thread B:
+    SDL_LockMutex(lock);
+    ...
+    condition = true;
+    ...
+    SDL_CondSignal(cond);
+    SDL_UnlockMutex(lock);
+ */
+int
+SDL_CondWaitTimeout(SDL_cond * cond, SDL_mutex * mutex, Uint32 ms)
+{
+    int retval;
+
+    if (!cond) {
+        return SDL_InvalidParamError("cond");
+    }
+
+    /* Obtain the protection mutex, and increment the number of waiters.
+       This allows the signal mechanism to only perform a signal if there
+       are waiting threads.
+     */
+    SDL_LockMutex(cond->lock);
+    ++cond->waiting;
+    SDL_UnlockMutex(cond->lock);
+
+    /* Unlock the mutex, as is required by condition variable semantics */
+    SDL_UnlockMutex(mutex);
+
+    /* Wait for a signal */
+    if (ms == SDL_MUTEX_MAXWAIT) {
+        retval = SDL_SemWait(cond->wait_sem);
+    } else {
+        retval = SDL_SemWaitTimeout(cond->wait_sem, ms);
+    }
+
+    /* Let the signaler know we have completed the wait, otherwise
+       the signaler can race ahead and get the condition semaphore
+       if we are stopped between the mutex unlock and semaphore wait,
+       giving a deadlock.  See the following URL for details:
+       http://www-classic.be.com/aboutbe/benewsletter/volume_III/Issue40.html
+     */
+    SDL_LockMutex(cond->lock);
+    if (cond->signals > 0) {
+        /* If we timed out, we need to eat a condition signal */
+        if (retval > 0) {
+            SDL_SemWait(cond->wait_sem);
+        }
+        /* We always notify the signal thread that we are done */
+        SDL_SemPost(cond->wait_done);
+
+        /* Signal handshake complete */
+        --cond->signals;
+    }
+    --cond->waiting;
+    SDL_UnlockMutex(cond->lock);
+
+    /* Lock the mutex, as is required by condition variable semantics */
+    SDL_LockMutex(mutex);
+
+    return retval;
+}
+
+/* Wait on the condition variable forever */
+int
+SDL_CondWait(SDL_cond * cond, SDL_mutex * mutex)
+{
+    return SDL_CondWaitTimeout(cond, mutex, SDL_MUTEX_MAXWAIT);
+}
+
+#endif /* SDL_THREAD_VITA */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/thread/vita/SDL_sysmutex.c b/Engine/lib/sdl/src/thread/vita/SDL_sysmutex.c
new file mode 100644
index 000000000..6327182cc
--- /dev/null
+++ b/Engine/lib/sdl/src/thread/vita/SDL_sysmutex.c
@@ -0,0 +1,149 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if SDL_THREAD_VITA
+
+#include "SDL_thread.h"
+#include "SDL_systhread_c.h"
+
+#include <psp2/kernel/threadmgr.h>
+#include <psp2/kernel/error.h>
+
+struct SDL_mutex
+{
+    SceKernelLwMutexWork lock;
+};
+
+/* Create a mutex */
+SDL_mutex *
+SDL_CreateMutex(void)
+{
+    SDL_mutex *mutex = NULL;
+    SceInt32 res = 0;
+
+    /* Allocate mutex memory */
+    mutex = (SDL_mutex *) SDL_malloc(sizeof(*mutex));
+    if (mutex) {
+
+        res = sceKernelCreateLwMutex(
+            &mutex->lock,
+            "SDL mutex",
+            SCE_KERNEL_MUTEX_ATTR_RECURSIVE,
+            0,
+            NULL
+        );
+
+        if (res < 0) {
+            SDL_SetError("Error trying to create mutex: %x", res);
+        }
+    } else {
+        SDL_OutOfMemory();
+    }
+    return mutex;
+}
+
+/* Free the mutex */
+void
+SDL_DestroyMutex(SDL_mutex * mutex)
+{
+    if (mutex) {
+        sceKernelDeleteLwMutex(&mutex->lock);
+        SDL_free(mutex);
+    }
+}
+
+/* Try to lock the mutex */
+int
+SDL_TryLockMutex(SDL_mutex * mutex)
+{
+#if SDL_THREADS_DISABLED
+    return 0;
+#else
+    SceInt32 res = 0;
+    if (mutex == NULL) {
+        return SDL_InvalidParamError("mutex");
+    }
+
+    res = sceKernelTryLockLwMutex(&mutex->lock, 1);
+    switch (res) {
+        case SCE_KERNEL_OK:
+            return 0;
+            break;
+        case SCE_KERNEL_ERROR_MUTEX_FAILED_TO_OWN:
+            return SDL_MUTEX_TIMEDOUT;
+            break;
+        default:
+            return SDL_SetError("Error trying to lock mutex: %x", res);
+            break;
+    }
+
+    return -1;
+#endif /* SDL_THREADS_DISABLED */
+}
+
+
+/* Lock the mutex */
+int
+SDL_mutexP(SDL_mutex * mutex)
+{
+#if SDL_THREADS_DISABLED
+    return 0;
+#else
+    SceInt32 res = 0;
+    if (mutex == NULL) {
+        return SDL_InvalidParamError("mutex");
+    }
+
+    res = sceKernelLockLwMutex(&mutex->lock, 1, NULL);
+    if (res != SCE_KERNEL_OK) {
+        return SDL_SetError("Error trying to lock mutex: %x", res);
+    }
+
+    return 0;
+#endif /* SDL_THREADS_DISABLED */
+}
+
+/* Unlock the mutex */
+int
+SDL_mutexV(SDL_mutex * mutex)
+{
+#if SDL_THREADS_DISABLED
+    return 0;
+#else
+    SceInt32 res = 0;
+
+    if (mutex == NULL) {
+        return SDL_InvalidParamError("mutex");
+    }
+
+    res = sceKernelUnlockLwMutex(&mutex->lock, 1);
+    if (res != 0) {
+        return SDL_SetError("Error trying to unlock mutex: %x", res);
+    }
+
+    return 0;
+#endif /* SDL_THREADS_DISABLED */
+}
+
+#endif /* SDL_THREAD_VITA */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/thread/vita/SDL_sysmutex_c.h b/Engine/lib/sdl/src/thread/vita/SDL_sysmutex_c.h
new file mode 100644
index 000000000..057bcc4bc
--- /dev/null
+++ b/Engine/lib/sdl/src/thread/vita/SDL_sysmutex_c.h
@@ -0,0 +1,23 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/thread/vita/SDL_syssem.c b/Engine/lib/sdl/src/thread/vita/SDL_syssem.c
new file mode 100644
index 000000000..7fecd6ca2
--- /dev/null
+++ b/Engine/lib/sdl/src/thread/vita/SDL_syssem.c
@@ -0,0 +1,162 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if SDL_THREAD_VITA
+
+/* Semaphore functions for the VITA. */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "SDL_error.h"
+#include "SDL_thread.h"
+
+#include <psp2/types.h>
+#include <psp2/kernel/error.h>
+#include <psp2/kernel/threadmgr.h>
+
+struct SDL_semaphore {
+    SceUID  semid;
+};
+
+
+/* Create a semaphore */
+SDL_sem *SDL_CreateSemaphore(Uint32 initial_value)
+{
+    SDL_sem *sem;
+
+    sem = (SDL_sem *) SDL_malloc(sizeof(*sem));
+    if (sem != NULL) {
+        /* TODO: Figure out the limit on the maximum value. */
+        sem->semid = sceKernelCreateSema("SDL sema", 0, initial_value, 255, NULL);
+        if (sem->semid < 0) {
+            SDL_SetError("Couldn't create semaphore");
+            SDL_free(sem);
+            sem = NULL;
+        }
+    } else {
+        SDL_OutOfMemory();
+    }
+
+    return sem;
+}
+
+/* Free the semaphore */
+void SDL_DestroySemaphore(SDL_sem *sem)
+{
+    if (sem != NULL) {
+        if (sem->semid > 0) {
+            sceKernelDeleteSema(sem->semid);
+            sem->semid = 0;
+        }
+
+        SDL_free(sem);
+    }
+}
+
+/* TODO: This routine is a bit overloaded.
+ * If the timeout is 0 then just poll the semaphore; if it's SDL_MUTEX_MAXWAIT, pass
+ * NULL to sceKernelWaitSema() so that it waits indefinitely; and if the timeout
+ * is specified, convert it to microseconds. */
+int SDL_SemWaitTimeout(SDL_sem *sem, Uint32 timeout)
+{
+    Uint32 *pTimeout;
+       unsigned int res;
+
+    if (sem == NULL) {
+        SDL_InvalidParamError("sem");
+        return 0;
+    }
+
+    if (timeout == 0) {
+        res = sceKernelPollSema(sem->semid, 1);
+        if (res < 0) {
+            return SDL_MUTEX_TIMEDOUT;
+        }
+        return 0;
+    }
+
+    if (timeout == SDL_MUTEX_MAXWAIT) {
+        pTimeout = NULL;
+    } else {
+        timeout *= 1000;  /* Convert to microseconds. */
+        pTimeout = &timeout;
+    }
+
+    res = sceKernelWaitSema(sem->semid, 1, pTimeout);
+       switch (res) {
+               case SCE_KERNEL_OK:
+                       return 0;
+               case SCE_KERNEL_ERROR_WAIT_TIMEOUT:
+                       return SDL_MUTEX_TIMEDOUT;
+               default:
+                       return SDL_SetError("WaitForSingleObject() failed");
+    }
+}
+
+int SDL_SemTryWait(SDL_sem *sem)
+{
+    return SDL_SemWaitTimeout(sem, 0);
+}
+
+int SDL_SemWait(SDL_sem *sem)
+{
+    return SDL_SemWaitTimeout(sem, SDL_MUTEX_MAXWAIT);
+}
+
+/* Returns the current count of the semaphore */
+Uint32 SDL_SemValue(SDL_sem *sem)
+{
+    SceKernelSemaInfo info;
+    info.size = sizeof(info);
+
+    if (sem == NULL) {
+        SDL_InvalidParamError("sem");
+        return 0;
+    }
+
+    if (sceKernelGetSemaInfo(sem->semid, &info) >= 0) {
+        return info.currentCount;
+    }
+
+    return 0;
+}
+
+int SDL_SemPost(SDL_sem *sem)
+{
+    int res;
+
+    if (sem == NULL) {
+        return SDL_InvalidParamError("sem");
+    }
+
+    res = sceKernelSignalSema(sem->semid, 1);
+    if (res < 0) {
+        return SDL_SetError("sceKernelSignalSema() failed");
+    }
+
+    return 0;
+}
+
+#endif /* SDL_THREAD_VITA */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/thread/vita/SDL_systhread.c b/Engine/lib/sdl/src/thread/vita/SDL_systhread.c
new file mode 100644
index 000000000..91ae06256
--- /dev/null
+++ b/Engine/lib/sdl/src/thread/vita/SDL_systhread.c
@@ -0,0 +1,138 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if SDL_THREAD_VITA
+
+/* VITA thread management routines for SDL */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "SDL_error.h"
+#include "SDL_thread.h"
+#include "../SDL_systhread.h"
+#include "../SDL_thread_c.h"
+#include <psp2/types.h>
+#include <psp2/kernel/threadmgr.h>
+
+#define VITA_THREAD_STACK_SIZE_MIN 0x1000 // 4KiB
+#define VITA_THREAD_STACK_SIZE_MAX 0x2000000 // 32MiB
+#define VITA_THREAD_STACK_SIZE_DEFAULT 0x10000 // 64KiB
+#define VITA_THREAD_NAME_MAX 32
+
+#define VITA_THREAD_PRIORITY_LOW 191
+#define VITA_THREAD_PRIORITY_NORMAL 160
+#define VITA_THREAD_PRIORITY_HIGH 112
+#define VITA_THREAD_PRIORITY_TIME_CRITICAL 64
+
+static int ThreadEntry(SceSize args, void *argp)
+{
+    SDL_RunThread(*(SDL_Thread **) argp);
+    return 0;
+}
+
+int SDL_SYS_CreateThread(SDL_Thread *thread)
+{
+    char thread_name[VITA_THREAD_NAME_MAX];
+    size_t stack_size = VITA_THREAD_STACK_SIZE_DEFAULT;
+
+    SDL_strlcpy(thread_name, "SDL thread", VITA_THREAD_NAME_MAX);
+    if (thread->name) {
+        SDL_strlcpy(thread_name, thread->name, VITA_THREAD_NAME_MAX);
+    }
+
+    if (thread->stacksize) {
+        if (thread->stacksize < VITA_THREAD_STACK_SIZE_MIN) {
+            thread->stacksize = VITA_THREAD_STACK_SIZE_MIN;
+        }
+        if (thread->stacksize > VITA_THREAD_STACK_SIZE_MAX) {
+            thread->stacksize = VITA_THREAD_STACK_SIZE_MAX;
+        }
+        stack_size = thread->stacksize;
+    }
+
+    /* Create new thread with the same priority as the current thread */
+    thread->handle = sceKernelCreateThread(
+        thread_name, // name
+        ThreadEntry, // function to run
+        0, // priority. 0 means priority of calling thread
+        stack_size, // stack size
+        0, // attibutes. always 0
+        0, // cpu affinity mask. 0 = all CPUs
+        NULL // opt. always NULL
+    );
+
+    if (thread->handle < 0) {
+        return SDL_SetError("sceKernelCreateThread() failed");
+    }
+
+    sceKernelStartThread(thread->handle, 4, &thread);
+    return 0;
+}
+
+void SDL_SYS_SetupThread(const char *name)
+{
+    /* Do nothing. */
+}
+
+SDL_threadID SDL_ThreadID(void)
+{
+    return (SDL_threadID) sceKernelGetThreadId();
+}
+
+void SDL_SYS_WaitThread(SDL_Thread *thread)
+{
+    sceKernelWaitThreadEnd(thread->handle, NULL, NULL);
+    sceKernelDeleteThread(thread->handle);
+}
+
+void SDL_SYS_DetachThread(SDL_Thread *thread)
+{
+    /* Do nothing. */
+}
+
+int SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority)
+{
+    int value = VITA_THREAD_PRIORITY_NORMAL;
+
+    switch(priority) {
+        case SDL_THREAD_PRIORITY_LOW:
+            value = VITA_THREAD_PRIORITY_LOW;
+            break;
+        case SDL_THREAD_PRIORITY_NORMAL:
+            value = VITA_THREAD_PRIORITY_NORMAL;
+            break;
+        case SDL_THREAD_PRIORITY_HIGH:
+            value = VITA_THREAD_PRIORITY_HIGH;
+            break;
+        case SDL_THREAD_PRIORITY_TIME_CRITICAL:
+            value = VITA_THREAD_PRIORITY_TIME_CRITICAL;
+            break;
+    }
+
+    return sceKernelChangeThreadPriority(0, value);
+
+}
+
+#endif /* SDL_THREAD_VITA */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/thread/vita/SDL_systhread_c.h b/Engine/lib/sdl/src/thread/vita/SDL_systhread_c.h
new file mode 100644
index 000000000..f5f707464
--- /dev/null
+++ b/Engine/lib/sdl/src/thread/vita/SDL_systhread_c.h
@@ -0,0 +1,26 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include <psp2/types.h>
+
+typedef SceUID SYS_ThreadHandle;
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/thread/windows/SDL_syscond_cv.c b/Engine/lib/sdl/src/thread/windows/SDL_syscond_cv.c
new file mode 100644
index 000000000..54d34084f
--- /dev/null
+++ b/Engine/lib/sdl/src/thread/windows/SDL_syscond_cv.c
@@ -0,0 +1,299 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#include "SDL_hints.h"
+#include "SDL_thread.h"
+
+#include "../generic/SDL_syscond_c.h"
+#include "SDL_sysmutex_c.h"
+
+typedef SDL_cond * (*pfnSDL_CreateCond)(void);
+typedef void (*pfnSDL_DestroyCond)(SDL_cond *);
+typedef int (*pfnSDL_CondSignal)(SDL_cond *);
+typedef int (*pfnSDL_CondBroadcast)(SDL_cond *);
+typedef int (*pfnSDL_CondWait)(SDL_cond *, SDL_mutex *);
+typedef int (*pfnSDL_CondWaitTimeout)(SDL_cond *, SDL_mutex *, Uint32);
+
+typedef struct SDL_cond_impl_t
+{
+    pfnSDL_CreateCond       Create;
+    pfnSDL_DestroyCond      Destroy;
+    pfnSDL_CondSignal       Signal;
+    pfnSDL_CondBroadcast    Broadcast;
+    pfnSDL_CondWait         Wait;
+    pfnSDL_CondWaitTimeout  WaitTimeout;
+} SDL_cond_impl_t;
+
+/* Implementation will be chosen at runtime based on available Kernel features */
+static SDL_cond_impl_t SDL_cond_impl_active = {0};
+
+
+/**
+ * Native Windows Condition Variable (SRW Locks)
+ */
+
+#ifndef CONDITION_VARIABLE_INIT
+#define CONDITION_VARIABLE_INIT {0}
+typedef struct CONDITION_VARIABLE {
+    PVOID Ptr;
+} CONDITION_VARIABLE, *PCONDITION_VARIABLE;
+#endif
+
+#if __WINRT__
+#define pWakeConditionVariable WakeConditionVariable
+#define pWakeAllConditionVariable WakeAllConditionVariable
+#define pSleepConditionVariableSRW SleepConditionVariableSRW
+#define pSleepConditionVariableCS SleepConditionVariableCS
+#else
+typedef VOID(WINAPI *pfnWakeConditionVariable)(PCONDITION_VARIABLE);
+typedef VOID(WINAPI *pfnWakeAllConditionVariable)(PCONDITION_VARIABLE);
+typedef BOOL(WINAPI *pfnSleepConditionVariableSRW)(PCONDITION_VARIABLE, PSRWLOCK, DWORD, ULONG);
+typedef BOOL(WINAPI* pfnSleepConditionVariableCS)(PCONDITION_VARIABLE, PCRITICAL_SECTION, DWORD);
+
+static pfnWakeConditionVariable pWakeConditionVariable = NULL;
+static pfnWakeAllConditionVariable pWakeAllConditionVariable = NULL;
+static pfnSleepConditionVariableSRW pSleepConditionVariableSRW = NULL;
+static pfnSleepConditionVariableCS pSleepConditionVariableCS = NULL;
+#endif
+
+typedef struct SDL_cond_cv
+{
+    CONDITION_VARIABLE cond;
+} SDL_cond_cv;
+
+
+static SDL_cond *
+SDL_CreateCond_cv(void)
+{
+    SDL_cond_cv *cond;
+
+    /* Relies on CONDITION_VARIABLE_INIT == 0. */
+    cond = (SDL_cond_cv *) SDL_calloc(1, sizeof(*cond));
+    if (!cond) {
+        SDL_OutOfMemory();
+    }
+
+    return (SDL_cond *)cond;
+}
+
+static void
+SDL_DestroyCond_cv(SDL_cond * cond)
+{
+    if (cond) {
+        /* There are no kernel allocated resources */
+        SDL_free(cond);
+    }
+}
+
+static int
+SDL_CondSignal_cv(SDL_cond * _cond)
+{
+    SDL_cond_cv *cond = (SDL_cond_cv *)_cond;
+    if (!cond) {
+        return SDL_InvalidParamError("cond");
+    }
+
+    pWakeConditionVariable(&cond->cond);
+
+    return 0;
+}
+
+static int
+SDL_CondBroadcast_cv(SDL_cond * _cond)
+{
+    SDL_cond_cv *cond = (SDL_cond_cv *)_cond;
+    if (!cond) {
+        return SDL_InvalidParamError("cond");
+    }
+
+    pWakeAllConditionVariable(&cond->cond);
+
+    return 0;
+}
+
+static int
+SDL_CondWaitTimeout_cv(SDL_cond * _cond, SDL_mutex * _mutex, Uint32 ms)
+{
+    SDL_cond_cv *cond = (SDL_cond_cv *)_cond;
+    DWORD timeout;
+    int ret;
+
+    if (!cond) {
+        return SDL_InvalidParamError("cond");
+    }
+    if (!_mutex) {
+        return SDL_InvalidParamError("mutex");
+    }
+
+    if (ms == SDL_MUTEX_MAXWAIT) {
+        timeout = INFINITE;
+    } else {
+        timeout = (DWORD) ms;
+    }
+
+    if (SDL_mutex_impl_active.Type == SDL_MUTEX_SRW) {
+        SDL_mutex_srw *mutex = (SDL_mutex_srw *)_mutex;
+
+        if (mutex->count != 1 || mutex->owner != GetCurrentThreadId()) {
+            return SDL_SetError("Passed mutex is not locked or locked recursively");
+        }
+
+        /* The mutex must be updated to the released state */
+        mutex->count = 0;
+        mutex->owner = 0;
+
+        if (pSleepConditionVariableSRW(&cond->cond, &mutex->srw, timeout, 0) == FALSE) {
+            if (GetLastError() == ERROR_TIMEOUT) {
+                ret = SDL_MUTEX_TIMEDOUT;
+            } else {
+                ret = SDL_SetError("SleepConditionVariableSRW() failed");
+            }
+        } else {
+            ret = 0;
+        }
+
+        /* The mutex is owned by us again, regardless of status of the wait */
+        SDL_assert(mutex->count == 0 && mutex->owner == 0);
+        mutex->count = 1;
+        mutex->owner = GetCurrentThreadId();
+    } else {
+        SDL_mutex_cs *mutex = (SDL_mutex_cs *)_mutex;
+
+        SDL_assert(SDL_mutex_impl_active.Type == SDL_MUTEX_CS);
+
+        if (pSleepConditionVariableCS(&cond->cond, &mutex->cs, timeout) == FALSE) {
+            if (GetLastError() == ERROR_TIMEOUT) {
+                ret = SDL_MUTEX_TIMEDOUT;
+            } else {
+                ret = SDL_SetError("SleepConditionVariableCS() failed");
+            }
+        } else {
+            ret = 0;
+        }
+    }
+
+    return ret;
+}
+
+static int
+SDL_CondWait_cv(SDL_cond * cond, SDL_mutex * mutex) {
+    return SDL_CondWaitTimeout_cv(cond, mutex, SDL_MUTEX_MAXWAIT);
+}
+
+static const SDL_cond_impl_t SDL_cond_impl_cv =
+{
+    &SDL_CreateCond_cv,
+    &SDL_DestroyCond_cv,
+    &SDL_CondSignal_cv,
+    &SDL_CondBroadcast_cv,
+    &SDL_CondWait_cv,
+    &SDL_CondWaitTimeout_cv,
+};
+
+/**
+ * Generic Condition Variable implementation using SDL_mutex and SDL_sem
+ */
+
+static const SDL_cond_impl_t SDL_cond_impl_generic =
+{
+    &SDL_CreateCond_generic,
+    &SDL_DestroyCond_generic,
+    &SDL_CondSignal_generic,
+    &SDL_CondBroadcast_generic,
+    &SDL_CondWait_generic,
+    &SDL_CondWaitTimeout_generic,
+};
+
+
+SDL_cond *
+SDL_CreateCond(void)
+{
+    if (SDL_cond_impl_active.Create == NULL) {
+        /* Default to generic implementation, works with all mutex implementations */
+        const SDL_cond_impl_t * impl = &SDL_cond_impl_generic;
+
+        if (SDL_mutex_impl_active.Type == SDL_MUTEX_INVALID) {
+            /* The mutex implementation isn't decided yet, trigger it */
+            SDL_mutex *mutex = SDL_CreateMutex();
+            if (!mutex) {
+                return NULL;
+            }
+            SDL_DestroyMutex(mutex);
+
+            SDL_assert(SDL_mutex_impl_active.Type != SDL_MUTEX_INVALID);
+        }
+
+#if __WINRT__
+        /* Link statically on this platform */
+        impl = &SDL_cond_impl_cv;
+#else
+        {
+            HMODULE kernel32 = GetModuleHandle(TEXT("kernel32.dll"));
+            if (kernel32) {
+                pWakeConditionVariable = (pfnWakeConditionVariable) GetProcAddress(kernel32, "WakeConditionVariable");
+                pWakeAllConditionVariable = (pfnWakeAllConditionVariable) GetProcAddress(kernel32, "WakeAllConditionVariable");
+                pSleepConditionVariableSRW = (pfnSleepConditionVariableSRW) GetProcAddress(kernel32, "SleepConditionVariableSRW");
+                pSleepConditionVariableCS = (pfnSleepConditionVariableCS) GetProcAddress(kernel32, "SleepConditionVariableCS");
+                if (pWakeConditionVariable && pWakeAllConditionVariable && pSleepConditionVariableSRW && pSleepConditionVariableCS) {
+                    /* Use the Windows provided API */
+                    impl = &SDL_cond_impl_cv;
+                }
+            }
+        }
+#endif
+
+        SDL_memcpy(&SDL_cond_impl_active, impl, sizeof(SDL_cond_impl_active));
+    }
+    return SDL_cond_impl_active.Create();
+}
+
+void
+SDL_DestroyCond(SDL_cond * cond)
+{
+    SDL_cond_impl_active.Destroy(cond);
+}
+
+int
+SDL_CondSignal(SDL_cond * cond)
+{
+    return SDL_cond_impl_active.Signal(cond);
+}
+
+int
+SDL_CondBroadcast(SDL_cond * cond)
+{
+    return SDL_cond_impl_active.Broadcast(cond);
+}
+
+int
+SDL_CondWaitTimeout(SDL_cond * cond, SDL_mutex * mutex, Uint32 ms)
+{
+    return SDL_cond_impl_active.WaitTimeout(cond, mutex, ms);
+}
+
+int
+SDL_CondWait(SDL_cond * cond, SDL_mutex * mutex)
+{
+    return SDL_cond_impl_active.Wait(cond, mutex);
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/thread/windows/SDL_sysmutex.c b/Engine/lib/sdl/src/thread/windows/SDL_sysmutex.c
index 4e393742a..b0b4abcb0 100644
--- a/Engine/lib/sdl/src/thread/windows/SDL_sysmutex.c
+++ b/Engine/lib/sdl/src/thread/windows/SDL_sysmutex.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -22,26 +22,161 @@
 
 #if SDL_THREAD_WINDOWS
 
-/* Mutex functions using the Win32 API */
-
-#include "../../core/windows/SDL_windows.h"
-
-#include "SDL_mutex.h"
+/**
+ * Mutex functions using the Win32 API
+ * There are two implementations available based on:
+ * - Critical Sections. Available on all OS versions since Windows XP.
+ * - Slim Reader/Writer Locks. Requires Windows 7 or newer.
+ * which are chosen at runtime.
+ */
 
 
-struct SDL_mutex
+#include "SDL_hints.h"
+
+#include "SDL_sysmutex_c.h"
+
+
+/* Implementation will be chosen at runtime based on available Kernel features */
+SDL_mutex_impl_t SDL_mutex_impl_active = {0};
+
+
+/**
+ * Implementation based on Slim Reader/Writer (SRW) Locks for Win 7 and newer.
+ */
+
+#if __WINRT__
+/* Functions are guaranteed to be available */
+#define pReleaseSRWLockExclusive ReleaseSRWLockExclusive
+#define pAcquireSRWLockExclusive AcquireSRWLockExclusive
+#define pTryAcquireSRWLockExclusive TryAcquireSRWLockExclusive
+#else
+typedef VOID(WINAPI *pfnReleaseSRWLockExclusive)(PSRWLOCK);
+typedef VOID(WINAPI *pfnAcquireSRWLockExclusive)(PSRWLOCK);
+typedef BOOLEAN(WINAPI *pfnTryAcquireSRWLockExclusive)(PSRWLOCK);
+static pfnReleaseSRWLockExclusive pReleaseSRWLockExclusive = NULL;
+static pfnAcquireSRWLockExclusive pAcquireSRWLockExclusive = NULL;
+static pfnTryAcquireSRWLockExclusive pTryAcquireSRWLockExclusive = NULL;
+#endif
+
+static SDL_mutex *
+SDL_CreateMutex_srw(void)
 {
-    CRITICAL_SECTION cs;
+    SDL_mutex_srw *mutex;
+
+    /* Relies on SRWLOCK_INIT == 0. */
+    mutex = (SDL_mutex_srw *) SDL_calloc(1, sizeof(*mutex));
+    if (!mutex) {
+        SDL_OutOfMemory();
+    }
+
+    return (SDL_mutex *)mutex;
+}
+
+static void
+SDL_DestroyMutex_srw(SDL_mutex * mutex)
+{
+    if (mutex) {
+        /* There are no kernel allocated resources */
+        SDL_free(mutex);
+    }
+}
+
+static int
+SDL_LockMutex_srw(SDL_mutex * _mutex)
+{
+    SDL_mutex_srw *mutex = (SDL_mutex_srw *)_mutex;
+    DWORD this_thread;
+
+    if (mutex == NULL) {
+        return SDL_InvalidParamError("mutex");
+    }
+
+    this_thread = GetCurrentThreadId();
+    if (mutex->owner == this_thread) {
+        ++mutex->count;
+    } else {
+        /* The order of operations is important.
+           We set the locking thread id after we obtain the lock
+           so unlocks from other threads will fail.
+         */
+        pAcquireSRWLockExclusive(&mutex->srw);
+        SDL_assert(mutex->count == 0 && mutex->owner == 0);
+        mutex->owner = this_thread;
+        mutex->count = 1;
+    }
+    return 0;
+}
+
+static int
+SDL_TryLockMutex_srw(SDL_mutex * _mutex)
+{
+    SDL_mutex_srw *mutex = (SDL_mutex_srw *)_mutex;
+    DWORD this_thread;
+    int retval = 0;
+
+    if (mutex == NULL) {
+        return SDL_InvalidParamError("mutex");
+    }
+
+    this_thread = GetCurrentThreadId();
+    if (mutex->owner == this_thread) {
+        ++mutex->count;
+    } else {
+        if (pTryAcquireSRWLockExclusive(&mutex->srw) != 0) {
+            SDL_assert(mutex->count == 0 && mutex->owner == 0);
+            mutex->owner = this_thread;
+            mutex->count = 1;
+        } else {
+            retval = SDL_MUTEX_TIMEDOUT;
+        }
+    }
+    return retval;
+}
+
+static int
+SDL_UnlockMutex_srw(SDL_mutex * _mutex)
+{
+    SDL_mutex_srw *mutex = (SDL_mutex_srw *)_mutex;
+
+    if (mutex == NULL) {
+        return SDL_InvalidParamError("mutex");
+    }
+
+    if (mutex->owner == GetCurrentThreadId()) {
+        if (--mutex->count == 0) {
+            mutex->owner = 0;
+            pReleaseSRWLockExclusive(&mutex->srw);
+        }
+    } else {
+        return SDL_SetError("mutex not owned by this thread");
+    }
+
+    return 0;
+}
+
+static const SDL_mutex_impl_t SDL_mutex_impl_srw =
+{
+    &SDL_CreateMutex_srw,
+    &SDL_DestroyMutex_srw,
+    &SDL_LockMutex_srw,
+    &SDL_TryLockMutex_srw,
+    &SDL_UnlockMutex_srw,
+    SDL_MUTEX_SRW,
 };
 
+
+/**
+ * Fallback Mutex implementation using Critical Sections (before Win 7)
+ */
+
 /* Create a mutex */
-SDL_mutex *
-SDL_CreateMutex(void)
+static SDL_mutex *
+SDL_CreateMutex_cs(void)
 {
-    SDL_mutex *mutex;
+    SDL_mutex_cs *mutex;
 
     /* Allocate mutex memory */
-    mutex = (SDL_mutex *) SDL_malloc(sizeof(*mutex));
+    mutex = (SDL_mutex_cs *) SDL_malloc(sizeof(*mutex));
     if (mutex) {
         /* Initialize */
         /* On SMP systems, a non-zero spin count generally helps performance */
@@ -53,13 +188,14 @@ SDL_CreateMutex(void)
     } else {
         SDL_OutOfMemory();
     }
-    return (mutex);
+    return (SDL_mutex *)mutex;
 }
 
 /* Free the mutex */
-void
-SDL_DestroyMutex(SDL_mutex * mutex)
+static void
+SDL_DestroyMutex_cs(SDL_mutex * mutex_)
 {
+    SDL_mutex_cs *mutex = (SDL_mutex_cs *)mutex_;
     if (mutex) {
         DeleteCriticalSection(&mutex->cs);
         SDL_free(mutex);
@@ -67,24 +203,26 @@ SDL_DestroyMutex(SDL_mutex * mutex)
 }
 
 /* Lock the mutex */
-int
-SDL_LockMutex(SDL_mutex * mutex)
+static int
+SDL_LockMutex_cs(SDL_mutex * mutex_)
 {
+    SDL_mutex_cs *mutex = (SDL_mutex_cs *)mutex_;
     if (mutex == NULL) {
-        return SDL_SetError("Passed a NULL mutex");
+        return SDL_InvalidParamError("mutex");
     }
 
     EnterCriticalSection(&mutex->cs);
-    return (0);
+    return 0;
 }
 
 /* TryLock the mutex */
-int
-SDL_TryLockMutex(SDL_mutex * mutex)
+static int
+SDL_TryLockMutex_cs(SDL_mutex * mutex_)
 {
+    SDL_mutex_cs *mutex = (SDL_mutex_cs *)mutex_;
     int retval = 0;
     if (mutex == NULL) {
-        return SDL_SetError("Passed a NULL mutex");
+        return SDL_InvalidParamError("mutex");
     }
 
     if (TryEnterCriticalSection(&mutex->cs) == 0) {
@@ -94,15 +232,84 @@ SDL_TryLockMutex(SDL_mutex * mutex)
 }
 
 /* Unlock the mutex */
-int
-SDL_UnlockMutex(SDL_mutex * mutex)
+static int
+SDL_UnlockMutex_cs(SDL_mutex * mutex_)
 {
+    SDL_mutex_cs *mutex = (SDL_mutex_cs *)mutex_;
     if (mutex == NULL) {
-        return SDL_SetError("Passed a NULL mutex");
+        return SDL_InvalidParamError("mutex");
     }
 
     LeaveCriticalSection(&mutex->cs);
-    return (0);
+    return 0;
+}
+
+static const SDL_mutex_impl_t SDL_mutex_impl_cs =
+{
+    &SDL_CreateMutex_cs,
+    &SDL_DestroyMutex_cs,
+    &SDL_LockMutex_cs,
+    &SDL_TryLockMutex_cs,
+    &SDL_UnlockMutex_cs,
+    SDL_MUTEX_CS,
+};
+
+
+/**
+ * Runtime selection and redirection
+ */
+
+SDL_mutex *
+SDL_CreateMutex(void)
+{
+    if (SDL_mutex_impl_active.Create == NULL) {
+        /* Default to fallback implementation */
+        const SDL_mutex_impl_t * impl = &SDL_mutex_impl_cs;
+
+        if (!SDL_GetHintBoolean(SDL_HINT_WINDOWS_FORCE_MUTEX_CRITICAL_SECTIONS, SDL_FALSE)) {
+#if __WINRT__
+            /* Link statically on this platform */
+            impl = &SDL_mutex_impl_srw;
+#else
+            /* Try faster implementation for Windows 7 and newer */
+            HMODULE kernel32 = GetModuleHandle(TEXT("kernel32.dll"));
+            if (kernel32) {
+                /* Requires Vista: */
+                pReleaseSRWLockExclusive = (pfnReleaseSRWLockExclusive) GetProcAddress(kernel32, "ReleaseSRWLockExclusive");
+                pAcquireSRWLockExclusive = (pfnAcquireSRWLockExclusive) GetProcAddress(kernel32, "AcquireSRWLockExclusive");
+                /* Requires 7: */
+                pTryAcquireSRWLockExclusive = (pfnTryAcquireSRWLockExclusive) GetProcAddress(kernel32, "TryAcquireSRWLockExclusive");
+                if (pReleaseSRWLockExclusive && pAcquireSRWLockExclusive && pTryAcquireSRWLockExclusive) {
+                    impl = &SDL_mutex_impl_srw;
+                }
+            }
+#endif
+        }
+
+        /* Copy instead of using pointer to save one level of indirection */
+        SDL_memcpy(&SDL_mutex_impl_active, impl, sizeof(SDL_mutex_impl_active));
+    }
+    return SDL_mutex_impl_active.Create();
+}
+
+void
+SDL_DestroyMutex(SDL_mutex * mutex) {
+    SDL_mutex_impl_active.Destroy(mutex);
+}
+
+int
+SDL_LockMutex(SDL_mutex * mutex) {
+    return SDL_mutex_impl_active.Lock(mutex);
+}
+
+int
+SDL_TryLockMutex(SDL_mutex * mutex) {
+    return SDL_mutex_impl_active.TryLock(mutex);
+}
+
+int
+SDL_UnlockMutex(SDL_mutex * mutex) {
+    return SDL_mutex_impl_active.Unlock(mutex);
 }
 
 #endif /* SDL_THREAD_WINDOWS */
diff --git a/Engine/lib/sdl/src/thread/windows/SDL_sysmutex_c.h b/Engine/lib/sdl/src/thread/windows/SDL_sysmutex_c.h
new file mode 100644
index 000000000..a97c5293d
--- /dev/null
+++ b/Engine/lib/sdl/src/thread/windows/SDL_sysmutex_c.h
@@ -0,0 +1,74 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#include "../../core/windows/SDL_windows.h"
+
+#include "SDL_mutex.h"
+
+typedef SDL_mutex * (*pfnSDL_CreateMutex)(void);
+typedef int (*pfnSDL_LockMutex)(SDL_mutex *);
+typedef int (*pfnSDL_TryLockMutex)(SDL_mutex *);
+typedef int (*pfnSDL_UnlockMutex)(SDL_mutex *);
+typedef void (*pfnSDL_DestroyMutex)(SDL_mutex *);
+
+typedef enum
+{
+    SDL_MUTEX_INVALID = 0,
+    SDL_MUTEX_SRW,
+    SDL_MUTEX_CS,
+} SDL_MutexType;
+
+typedef struct SDL_mutex_impl_t
+{
+    pfnSDL_CreateMutex  Create;
+    pfnSDL_DestroyMutex Destroy;
+    pfnSDL_LockMutex    Lock;
+    pfnSDL_TryLockMutex TryLock;
+    pfnSDL_UnlockMutex  Unlock;
+    /* Needed by SDL_cond: */
+    SDL_MutexType       Type;
+} SDL_mutex_impl_t;
+
+extern SDL_mutex_impl_t SDL_mutex_impl_active;
+
+
+#ifndef SRWLOCK_INIT
+#define SRWLOCK_INIT {0}
+typedef struct _SRWLOCK {
+    PVOID Ptr;
+} SRWLOCK, *PSRWLOCK;
+#endif
+
+typedef struct SDL_mutex_srw
+{
+    SRWLOCK srw;
+    /* SRW Locks are not recursive, that has to be handled by SDL: */
+    DWORD count;
+    DWORD owner;
+} SDL_mutex_srw;
+
+typedef struct SDL_mutex_cs
+{
+    CRITICAL_SECTION cs;
+} SDL_mutex_cs;
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/thread/windows/SDL_syssem.c b/Engine/lib/sdl/src/thread/windows/SDL_syssem.c
index 217ea32c7..794a713a8 100644
--- a/Engine/lib/sdl/src/thread/windows/SDL_syssem.c
+++ b/Engine/lib/sdl/src/thread/windows/SDL_syssem.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -22,27 +22,256 @@
 
 #if SDL_THREAD_WINDOWS
 
-/* Semaphore functions using the Win32 API */
+/**
+ * Semaphore functions using the Win32 API
+ * There are two implementations available based on:
+ * - Kernel Semaphores. Available on all OS versions. (kern)
+ *   Heavy-weight inter-process kernel objects.
+ * - Atomics and WaitOnAddress API. (atom)
+ *   Faster due to significantly less context switches.
+ *   Requires Windows 8 or newer.
+ * which are chosen at runtime.
+*/
 
 #include "../../core/windows/SDL_windows.h"
 
+#include "SDL_hints.h"
 #include "SDL_thread.h"
+#include "SDL_timer.h"
 
-struct SDL_semaphore
+typedef SDL_sem * (*pfnSDL_CreateSemaphore)(Uint32);
+typedef void (*pfnSDL_DestroySemaphore)(SDL_sem *);
+typedef int (*pfnSDL_SemWaitTimeout)(SDL_sem *, Uint32);
+typedef int (*pfnSDL_SemTryWait)(SDL_sem *);
+typedef int (*pfnSDL_SemWait)(SDL_sem *);
+typedef Uint32 (*pfnSDL_SemValue)(SDL_sem *);
+typedef int (*pfnSDL_SemPost)(SDL_sem *);
+
+typedef struct SDL_semaphore_impl_t
+{
+    pfnSDL_CreateSemaphore  Create;
+    pfnSDL_DestroySemaphore Destroy;
+    pfnSDL_SemWaitTimeout   WaitTimeout;
+    pfnSDL_SemTryWait       TryWait;
+    pfnSDL_SemWait          Wait;
+    pfnSDL_SemValue         Value;
+    pfnSDL_SemPost          Post;
+} SDL_sem_impl_t;
+
+/* Implementation will be chosen at runtime based on available Kernel features */
+static SDL_sem_impl_t SDL_sem_impl_active = {0};
+
+
+/**
+ * Atomic + WaitOnAddress implementation
+ */
+
+/* APIs not available on WinPhone 8.1 */
+/* https://www.microsoft.com/en-us/download/details.aspx?id=47328 */
+
+#if (HAVE_WINAPIFAMILY_H) && defined(WINAPI_FAMILY_PHONE_APP)
+#define SDL_WINAPI_FAMILY_PHONE (WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP)
+#else
+#define SDL_WINAPI_FAMILY_PHONE 0
+#endif
+
+#if !SDL_WINAPI_FAMILY_PHONE
+#if __WINRT__
+/* Functions are guaranteed to be available */
+#define pWaitOnAddress WaitOnAddress
+#define pWakeByAddressSingle WakeByAddressSingle
+#else
+typedef BOOL(WINAPI *pfnWaitOnAddress)(volatile VOID*, PVOID, SIZE_T, DWORD);
+typedef VOID(WINAPI *pfnWakeByAddressSingle)(PVOID);
+
+static pfnWaitOnAddress pWaitOnAddress = NULL;
+static pfnWakeByAddressSingle pWakeByAddressSingle = NULL;
+#endif
+
+typedef struct SDL_semaphore_atom
+{
+    LONG count;
+} SDL_sem_atom;
+
+static SDL_sem *
+SDL_CreateSemaphore_atom(Uint32 initial_value)
+{
+    SDL_sem_atom *sem;
+
+    sem = (SDL_sem_atom *) SDL_malloc(sizeof(*sem));
+    if (sem) {
+        sem->count = initial_value;
+    } else {
+        SDL_OutOfMemory();
+    }
+    return (SDL_sem *)sem;
+}
+
+static void
+SDL_DestroySemaphore_atom(SDL_sem * sem)
+{
+    if (sem) {
+        SDL_free(sem);
+    }
+}
+
+static int
+SDL_SemTryWait_atom(SDL_sem * _sem)
+{
+    SDL_sem_atom *sem = (SDL_sem_atom *)_sem;
+    LONG count;
+
+    if (!sem) {
+        return SDL_InvalidParamError("sem");
+    }
+
+    count = sem->count;
+    if (count == 0) {
+        return SDL_MUTEX_TIMEDOUT;
+    }
+
+    if (InterlockedCompareExchange(&sem->count, count - 1, count) == count) {
+        return 0;
+    }
+
+    return SDL_MUTEX_TIMEDOUT;
+}
+
+static int
+SDL_SemWait_atom(SDL_sem * _sem)
+{
+    SDL_sem_atom *sem = (SDL_sem_atom *)_sem;
+    LONG count;
+
+    if (!sem) {
+        return SDL_InvalidParamError("sem");
+    }
+
+    for (;;) {
+        count = sem->count;
+        while (count == 0) {
+            if (pWaitOnAddress(&sem->count, &count, sizeof(sem->count), INFINITE) == FALSE) {
+                return SDL_SetError("WaitOnAddress() failed");
+            }
+            count = sem->count;
+        }
+
+        if (InterlockedCompareExchange(&sem->count, count - 1, count) == count) {
+            return 0;
+        }
+    }
+}
+
+static int
+SDL_SemWaitTimeout_atom(SDL_sem * _sem, Uint32 timeout)
+{
+    SDL_sem_atom *sem = (SDL_sem_atom *)_sem;
+    LONG count;
+    Uint32 now;
+    Uint32 deadline;
+    DWORD timeout_eff;
+
+    if (timeout == SDL_MUTEX_MAXWAIT) {
+        return SDL_SemWait_atom(_sem);
+    }
+
+    if (!sem) {
+        return SDL_InvalidParamError("sem");
+    }
+
+    /**
+     * WaitOnAddress is subject to spurious and stolen wakeups so we
+     * need to recalculate the effective timeout before every wait
+     */
+    now = SDL_GetTicks();
+    deadline = now + (DWORD) timeout;
+
+    for (;;) {
+        count = sem->count;
+        /* If no semaphore is available we need to wait */
+        while (count == 0) {
+            now = SDL_GetTicks();
+            if (deadline > now) {
+                timeout_eff = deadline - now;
+            } else {
+                return SDL_MUTEX_TIMEDOUT;
+            }
+            if (pWaitOnAddress(&sem->count, &count, sizeof(count), timeout_eff) == FALSE) {
+                if (GetLastError() == ERROR_TIMEOUT) {
+                    return SDL_MUTEX_TIMEDOUT;
+                }
+                return SDL_SetError("WaitOnAddress() failed");
+            }
+            count = sem->count;
+        }
+
+        /* Actually the semaphore is only consumed if this succeeds */
+        /* If it doesn't we need to do everything again */
+        if (InterlockedCompareExchange(&sem->count, count - 1, count) == count) {
+            return 0;
+        }
+    }
+}
+
+static Uint32
+SDL_SemValue_atom(SDL_sem * _sem)
+{
+    SDL_sem_atom *sem = (SDL_sem_atom *)_sem;
+
+    if (!sem) {
+        SDL_InvalidParamError("sem");
+        return 0;
+    }
+
+    return (Uint32)sem->count;
+}
+
+static int
+SDL_SemPost_atom(SDL_sem * _sem)
+{
+    SDL_sem_atom *sem = (SDL_sem_atom *)_sem;
+
+    if (!sem) {
+        return SDL_InvalidParamError("sem");
+    }
+
+    InterlockedIncrement(&sem->count);
+    pWakeByAddressSingle(&sem->count);
+
+    return 0;
+}
+
+static const SDL_sem_impl_t SDL_sem_impl_atom =
+{
+    &SDL_CreateSemaphore_atom,
+    &SDL_DestroySemaphore_atom,
+    &SDL_SemWaitTimeout_atom,
+    &SDL_SemTryWait_atom,
+    &SDL_SemWait_atom,
+    &SDL_SemValue_atom,
+    &SDL_SemPost_atom,
+};
+#endif /* !SDL_WINAPI_FAMILY_PHONE */
+
+
+/**
+ * Fallback Semaphore implementation using Kernel Semaphores
+ */
+
+typedef struct SDL_semaphore_kern
 {
     HANDLE id;
     LONG count;
-};
-
+} SDL_sem_kern;
 
 /* Create a semaphore */
-SDL_sem *
-SDL_CreateSemaphore(Uint32 initial_value)
+static SDL_sem *
+SDL_CreateSemaphore_kern(Uint32 initial_value)
 {
-    SDL_sem *sem;
+    SDL_sem_kern *sem;
 
     /* Allocate sem memory */
-    sem = (SDL_sem *) SDL_malloc(sizeof(*sem));
+    sem = (SDL_sem_kern *) SDL_malloc(sizeof(*sem));
     if (sem) {
         /* Create the semaphore, with max value 32K */
 #if __WINRT__
@@ -59,13 +288,14 @@ SDL_CreateSemaphore(Uint32 initial_value)
     } else {
         SDL_OutOfMemory();
     }
-    return (sem);
+    return (SDL_sem *)sem;
 }
 
 /* Free the semaphore */
-void
-SDL_DestroySemaphore(SDL_sem * sem)
+static void
+SDL_DestroySemaphore_kern(SDL_sem * _sem)
 {
+    SDL_sem_kern *sem = (SDL_sem_kern *)_sem;
     if (sem) {
         if (sem->id) {
             CloseHandle(sem->id);
@@ -75,14 +305,15 @@ SDL_DestroySemaphore(SDL_sem * sem)
     }
 }
 
-int
-SDL_SemWaitTimeout(SDL_sem * sem, Uint32 timeout)
+static int
+SDL_SemWaitTimeout_kern(SDL_sem * _sem, Uint32 timeout)
 {
+    SDL_sem_kern *sem = (SDL_sem_kern *)_sem;
     int retval;
     DWORD dwMilliseconds;
 
     if (!sem) {
-        return SDL_SetError("Passed a NULL sem");
+        return SDL_InvalidParamError("sem");
     }
 
     if (timeout == SDL_MUTEX_MAXWAIT) {
@@ -105,34 +336,36 @@ SDL_SemWaitTimeout(SDL_sem * sem, Uint32 timeout)
     return retval;
 }
 
-int
-SDL_SemTryWait(SDL_sem * sem)
+static int
+SDL_SemTryWait_kern(SDL_sem * sem)
 {
-    return SDL_SemWaitTimeout(sem, 0);
+    return SDL_SemWaitTimeout_kern(sem, 0);
 }
 
-int
-SDL_SemWait(SDL_sem * sem)
+static int
+SDL_SemWait_kern(SDL_sem * sem)
 {
-    return SDL_SemWaitTimeout(sem, SDL_MUTEX_MAXWAIT);
+    return SDL_SemWaitTimeout_kern(sem, SDL_MUTEX_MAXWAIT);
 }
 
 /* Returns the current count of the semaphore */
-Uint32
-SDL_SemValue(SDL_sem * sem)
+static Uint32
+SDL_SemValue_kern(SDL_sem * _sem)
 {
+    SDL_sem_kern *sem = (SDL_sem_kern *)_sem;
     if (!sem) {
-        SDL_SetError("Passed a NULL sem");
+        SDL_InvalidParamError("sem");
         return 0;
     }
     return (Uint32)sem->count;
 }
 
-int
-SDL_SemPost(SDL_sem * sem)
+static int
+SDL_SemPost_kern(SDL_sem * _sem)
 {
+    SDL_sem_kern *sem = (SDL_sem_kern *)_sem;
     if (!sem) {
-        return SDL_SetError("Passed a NULL sem");
+        return SDL_InvalidParamError("sem");
     }
     /* Increase the counter in the first place, because
      * after a successful release the semaphore may
@@ -147,6 +380,97 @@ SDL_SemPost(SDL_sem * sem)
     return 0;
 }
 
+static const SDL_sem_impl_t SDL_sem_impl_kern =
+{
+    &SDL_CreateSemaphore_kern,
+    &SDL_DestroySemaphore_kern,
+    &SDL_SemWaitTimeout_kern,
+    &SDL_SemTryWait_kern,
+    &SDL_SemWait_kern,
+    &SDL_SemValue_kern,
+    &SDL_SemPost_kern,
+};
+
+
+/**
+ * Runtime selection and redirection
+ */
+
+SDL_sem *
+SDL_CreateSemaphore(Uint32 initial_value)
+{
+    if (SDL_sem_impl_active.Create == NULL) {
+        /* Default to fallback implementation */
+        const SDL_sem_impl_t * impl = &SDL_sem_impl_kern;
+
+#if !SDL_WINAPI_FAMILY_PHONE
+        if (!SDL_GetHintBoolean(SDL_HINT_WINDOWS_FORCE_SEMAPHORE_KERNEL, SDL_FALSE)) {
+#if __WINRT__
+            /* Link statically on this platform */
+            impl = &SDL_sem_impl_atom;
+#else
+            /* We already statically link to features from this Api
+             * Set (e.g. WaitForSingleObject). Dynamically loading
+             * API Sets is not explicitly documented but according to
+             * Microsoft our specific use case is legal and correct:
+             * https://github.com/microsoft/STL/pull/593#issuecomment-655799859
+             */
+            HMODULE synch120 = GetModuleHandle(TEXT("api-ms-win-core-synch-l1-2-0.dll"));
+            if (synch120) {
+                /* Try to load required functions provided by Win 8 or newer */
+                pWaitOnAddress = (pfnWaitOnAddress) GetProcAddress(synch120, "WaitOnAddress");
+                pWakeByAddressSingle = (pfnWakeByAddressSingle) GetProcAddress(synch120, "WakeByAddressSingle");
+
+                if(pWaitOnAddress && pWakeByAddressSingle) {
+                    impl = &SDL_sem_impl_atom;
+                }
+            }
+#endif
+        }
+#endif
+
+        /* Copy instead of using pointer to save one level of indirection */
+        SDL_memcpy(&SDL_sem_impl_active, impl, sizeof(SDL_sem_impl_active));
+    }
+    return SDL_sem_impl_active.Create(initial_value);
+}
+
+void
+SDL_DestroySemaphore(SDL_sem * sem)
+{
+    SDL_sem_impl_active.Destroy(sem);
+}
+
+int
+SDL_SemWaitTimeout(SDL_sem * sem, Uint32 timeout)
+{
+    return SDL_sem_impl_active.WaitTimeout(sem, timeout);
+}
+
+int
+SDL_SemTryWait(SDL_sem * sem)
+{
+    return SDL_sem_impl_active.TryWait(sem);
+}
+
+int
+SDL_SemWait(SDL_sem * sem)
+{
+    return SDL_sem_impl_active.Wait(sem);
+}
+
+Uint32
+SDL_SemValue(SDL_sem * sem)
+{
+    return SDL_sem_impl_active.Value(sem);
+}
+
+int
+SDL_SemPost(SDL_sem * sem)
+{
+    return SDL_sem_impl_active.Post(sem);
+}
+
 #endif /* SDL_THREAD_WINDOWS */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/thread/windows/SDL_systhread.c b/Engine/lib/sdl/src/thread/windows/SDL_systhread.c
index 7e3269b2b..8f44e473c 100644
--- a/Engine/lib/sdl/src/thread/windows/SDL_systhread.c
+++ b/Engine/lib/sdl/src/thread/windows/SDL_systhread.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -163,14 +163,14 @@ SDL_SYS_SetupThread(const char *name)
         static HMODULE kernel32 = 0;
 
         if (!kernel32) {
-            kernel32 = LoadLibraryW(L"kernel32.dll");
+            kernel32 = GetModuleHandle(TEXT("kernel32.dll"));
             if (kernel32) {
                 pSetThreadDescription = (pfnSetThreadDescription) GetProcAddress(kernel32, "SetThreadDescription");
             }
         }
 
         if (pSetThreadDescription != NULL) {
-            WCHAR *strw = WIN_UTF8ToString(name);
+            WCHAR *strw = WIN_UTF8ToStringW(name);
             if (strw) {
                 pSetThreadDescription(GetCurrentThread(), strw);
                 SDL_free(strw);
diff --git a/Engine/lib/sdl/src/thread/windows/SDL_systhread_c.h b/Engine/lib/sdl/src/thread/windows/SDL_systhread_c.h
index f84383081..debb19d7e 100644
--- a/Engine/lib/sdl/src/thread/windows/SDL_systhread_c.h
+++ b/Engine/lib/sdl/src/thread/windows/SDL_systhread_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/thread/windows/SDL_systls.c b/Engine/lib/sdl/src/thread/windows/SDL_systls.c
index e37a3321f..22e507a7a 100644
--- a/Engine/lib/sdl/src/thread/windows/SDL_systls.c
+++ b/Engine/lib/sdl/src/thread/windows/SDL_systls.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/timer/SDL_timer.c b/Engine/lib/sdl/src/timer/SDL_timer.c
index 4e8ea01c9..7b7692df0 100644
--- a/Engine/lib/sdl/src/timer/SDL_timer.c
+++ b/Engine/lib/sdl/src/timer/SDL_timer.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -28,6 +28,8 @@
 
 /* #define DEBUG_TIMERS */
 
+#if !defined(__EMSCRIPTEN__) || !SDL_THREADS_DISABLED
+
 typedef struct _SDL_Timer
 {
     int timerID;
@@ -370,4 +372,124 @@ SDL_RemoveTimer(SDL_TimerID id)
     return canceled;
 }
 
+#else
+
+#include <emscripten/emscripten.h>
+
+typedef struct _SDL_TimerMap
+{
+    int timerID;
+    int timeoutID;
+    struct _SDL_TimerMap *next;
+} SDL_TimerMap;
+
+typedef struct {
+    int nextID;
+    SDL_TimerMap *timermap;
+} SDL_TimerData;
+
+static SDL_TimerData SDL_timer_data;
+
+static void
+SDL_Emscripten_TimerHelper(SDL_TimerMap *entry, Uint32 interval, SDL_TimerCallback callback, void *param)
+{
+    Uint32 new_timeout;
+
+    new_timeout = callback(interval, param);
+
+    if (new_timeout != 0) {
+        entry->timeoutID = EM_ASM_INT({
+            return Browser.safeSetTimeout(function() {
+                dynCall('viiii', $0, [$1, $2, $3, $4]);
+            }, $2);
+        }, &SDL_Emscripten_TimerHelper, entry, interval, callback, param);
+    }
+}
+
+int
+SDL_TimerInit(void)
+{
+    return 0;
+}
+
+void
+SDL_TimerQuit(void)
+{
+    SDL_TimerData *data = &SDL_timer_data;
+    SDL_TimerMap *entry;
+
+    while (data->timermap) {
+        entry = data->timermap;
+        data->timermap = entry->next;
+        SDL_free(entry);
+    }
+}
+
+SDL_TimerID
+SDL_AddTimer(Uint32 interval, SDL_TimerCallback callback, void *param)
+{
+    SDL_TimerData *data = &SDL_timer_data;
+    SDL_TimerMap *entry;
+
+    entry = (SDL_TimerMap *)SDL_malloc(sizeof(*entry));
+    if (!entry) {
+        SDL_OutOfMemory();
+        return 0;
+    }
+    entry->timerID = ++data->nextID;
+
+    entry->timeoutID = EM_ASM_INT({
+        return Browser.safeSetTimeout(function() {
+            dynCall('viiii', $0, [$1, $2, $3, $4]);
+        }, $2);
+    }, &SDL_Emscripten_TimerHelper, entry, interval, callback, param);
+
+    entry->next = data->timermap;
+    data->timermap = entry;
+
+    return entry->timerID;
+}
+
+SDL_bool
+SDL_RemoveTimer(SDL_TimerID id)
+{
+    SDL_TimerData *data = &SDL_timer_data;
+    SDL_TimerMap *prev, *entry;
+
+    /* Find the timer */
+    prev = NULL;
+    for (entry = data->timermap; entry; prev = entry, entry = entry->next) {
+        if (entry->timerID == id) {
+            if (prev) {
+                prev->next = entry->next;
+            } else {
+                data->timermap = entry->next;
+            }
+            break;
+        }
+    }
+
+    if (entry) {
+        EM_ASM_({
+            window.clearTimeout($0);
+        }, entry->timeoutID);
+        SDL_free(entry);
+
+        return SDL_TRUE;
+    }
+    return SDL_FALSE;
+}
+
+#endif
+
+/* This is a legacy support function; SDL_GetTicks() returns a Uint32,
+   which wraps back to zero every ~49 days. The newer SDL_GetTicks64()
+   doesn't have this problem, so we just wrap that function and clamp to
+   the low 32-bits for binary compatibility. */
+Uint32
+SDL_GetTicks(void)
+{
+    return (Uint32) (SDL_GetTicks64() & 0xFFFFFFFF);
+}
+
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/timer/SDL_timer_c.h b/Engine/lib/sdl/src/timer/SDL_timer_c.h
index 4e62845a5..555913e4d 100644
--- a/Engine/lib/sdl/src/timer/SDL_timer_c.h
+++ b/Engine/lib/sdl/src/timer/SDL_timer_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/timer/dummy/SDL_systimer.c b/Engine/lib/sdl/src/timer/dummy/SDL_systimer.c
index ffbdf303a..8e34959f0 100644
--- a/Engine/lib/sdl/src/timer/dummy/SDL_systimer.c
+++ b/Engine/lib/sdl/src/timer/dummy/SDL_systimer.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -41,8 +41,8 @@ SDL_TicksQuit(void)
     ticks_started = SDL_FALSE;
 }
 
-Uint32
-SDL_GetTicks(void)
+Uint64
+SDL_GetTicks64(void)
 {
     if (!ticks_started) {
         SDL_TicksInit();
diff --git a/Engine/lib/sdl/src/timer/haiku/SDL_systimer.c b/Engine/lib/sdl/src/timer/haiku/SDL_systimer.c
index b512fb1d7..fb358b9d2 100644
--- a/Engine/lib/sdl/src/timer/haiku/SDL_systimer.c
+++ b/Engine/lib/sdl/src/timer/haiku/SDL_systimer.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -47,14 +47,14 @@ SDL_TicksQuit(void)
     ticks_started = SDL_FALSE;
 }
 
-Uint32
-SDL_GetTicks(void)
+Uint64
+SDL_GetTicks64(void)
 {
     if (!ticks_started) {
         SDL_TicksInit();
     }
 
-    return ((system_time() - start) / 1000);
+    return (Uint64) ((system_time() - start) / 1000);
 }
 
 Uint64
diff --git a/Engine/lib/sdl/src/timer/os2/SDL_systimer.c b/Engine/lib/sdl/src/timer/os2/SDL_systimer.c
index 4b09c9579..c5bcf64b7 100644
--- a/Engine/lib/sdl/src/timer/os2/SDL_systimer.c
+++ b/Engine/lib/sdl/src/timer/os2/SDL_systimer.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -40,25 +40,26 @@
 typedef unsigned long long  ULLONG;
 
 static ULONG    ulTmrFreq = 0;
-static ULLONG   ullTmrStart;
+static ULLONG   ullTmrStart = 0;
 
 void
 SDL_TicksInit(void)
 {
-    ULONG   ulRC;
-
-    ulRC = DosTmrQueryFreq(&ulTmrFreq);
+    ULONG ulTmrStart;  /* for 32-bit fallback. */
+    ULONG ulRC = DosTmrQueryFreq(&ulTmrFreq);
     if (ulRC != NO_ERROR) {
         debug_os2("DosTmrQueryFreq() failed, rc = %u", ulRC);
     } else {
         ulRC = DosTmrQueryTime((PQWORD)&ullTmrStart);
-        if (ulRC == NO_ERROR)
+        if (ulRC == NO_ERROR) {
             return;
+        }
         debug_os2("DosTmrQueryTime() failed, rc = %u", ulRC);
     }
 
     ulTmrFreq = 0; /* Error - use DosQuerySysInfo() for timer. */
-    DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, (PULONG)&ullTmrStart, sizeof(ULONG));
+    DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &ulTmrStart, sizeof (ULONG));
+    ullTmrStart = (ULLONG) ulTmrStart;
 }
 
 void
@@ -66,24 +67,27 @@ SDL_TicksQuit(void)
 {
 }
 
-Uint32
-SDL_GetTicks(void)
+Uint64
+SDL_GetTicks64(void)
 {
-    ULONG   ulResult;
-    ULLONG  ullTmrNow;
+    Uint64 ui64Result;
+    ULLONG ullTmrNow;
 
-    if (ulTmrFreq == 0) /* Was not initialized. */
+    if (ulTmrFreq == 0) { /* Was not initialized. */
         SDL_TicksInit();
+    }
 
     if (ulTmrFreq != 0) {
         DosTmrQueryTime((PQWORD)&ullTmrNow);
-        ulResult = (ullTmrNow - ullTmrStart) * 1000 / ulTmrFreq;
+        ui64Result = (ullTmrNow - ullTmrStart) * 1000 / ulTmrFreq;
     } else {
-        DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, (PULONG)&ullTmrNow, sizeof(ULONG));
-        ulResult = (ULONG)ullTmrNow - (ULONG)ullTmrStart;
+        /* note that this counter rolls over to 0 every ~49 days. Fix your system so DosTmrQueryTime works if you need to avoid this. */
+        ULONG ulTmrNow;
+        DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &ulTmrNow, sizeof (ULONG));
+        ui64Result = (((Uint64) ulTmrNow) - ullTmrStart);
     }
 
-    return ulResult;
+    return ui64Result;
 }
 
 Uint64
@@ -91,9 +95,9 @@ SDL_GetPerformanceCounter(void)
 {
     QWORD   qwTmrNow;
 
-    if (ulTmrFreq == 0 || (DosTmrQueryTime(&qwTmrNow) != NO_ERROR))
-        return SDL_GetTicks();
-
+    if (ulTmrFreq == 0 || (DosTmrQueryTime(&qwTmrNow) != NO_ERROR)) {
+        return SDL_GetTicks64();
+    }
     return *((Uint64 *)&qwTmrNow);
 }
 
diff --git a/Engine/lib/sdl/src/timer/psp/SDL_systimer.c b/Engine/lib/sdl/src/timer/psp/SDL_systimer.c
index ad4ab29dd..df6225fa3 100644
--- a/Engine/lib/sdl/src/timer/psp/SDL_systimer.c
+++ b/Engine/lib/sdl/src/timer/psp/SDL_systimer.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -20,7 +20,7 @@
 */
 #include "../../SDL_internal.h"
 
-#ifdef SDL_TIMERS_PSP
+#ifdef SDL_TIMER_PSP
 
 #include "SDL_thread.h"
 #include "SDL_timer.h"
@@ -51,24 +51,23 @@ SDL_TicksQuit(void)
     ticks_started = SDL_FALSE;
 }
 
-Uint32 SDL_GetTicks(void)
+Uint64
+SDL_GetTicks64(void)
 {
+    struct timeval now;
+
     if (!ticks_started) {
         SDL_TicksInit();
     }
 
-    struct timeval now;
-    Uint32 ticks;
-
     gettimeofday(&now, NULL);
-    ticks=(now.tv_sec-start.tv_sec)*1000+(now.tv_usec-start.tv_usec)/1000;
-    return(ticks);
+    return (Uint64)(((Sint64)(now.tv_sec - start.tv_sec) * 1000) + ((now.tv_usec - start.tv_usec) / 1000));
 }
 
 Uint64
 SDL_GetPerformanceCounter(void)
 {
-    return SDL_GetTicks();
+    return SDL_GetTicks64();
 }
 
 Uint64
@@ -85,7 +84,7 @@ void SDL_Delay(Uint32 ms)
     sceKernelDelayThreadCB(ms * 1000);
 }
 
-#endif /* SDL_TIMERS_PSP */
+#endif /* SDL_TIMER_PSP */
 
 /* vim: ts=4 sw=4
  */
diff --git a/Engine/lib/sdl/src/timer/unix/SDL_systimer.c b/Engine/lib/sdl/src/timer/unix/SDL_systimer.c
index f6c986848..2cf26764c 100644
--- a/Engine/lib/sdl/src/timer/unix/SDL_systimer.c
+++ b/Engine/lib/sdl/src/timer/unix/SDL_systimer.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -104,10 +104,9 @@ SDL_TicksQuit(void)
     ticks_started = SDL_FALSE;
 }
 
-Uint32
-SDL_GetTicks(void)
+Uint64
+SDL_GetTicks64(void)
 {
-    Uint32 ticks;
     if (!ticks_started) {
         SDL_TicksInit();
     }
@@ -116,21 +115,19 @@ SDL_GetTicks(void)
 #if HAVE_CLOCK_GETTIME
         struct timespec now;
         clock_gettime(SDL_MONOTONIC_CLOCK, &now);
-        ticks = (Uint32)((now.tv_sec - start_ts.tv_sec) * 1000 + (now.tv_nsec - start_ts.tv_nsec) / 1000000);
+        return (Uint64)(((Sint64)(now.tv_sec - start_ts.tv_sec) * 1000) + ((now.tv_nsec - start_ts.tv_nsec) / 1000000));
 #elif defined(__APPLE__)
-        uint64_t now = mach_absolute_time();
-        ticks = (Uint32)((((now - start_mach) * mach_base_info.numer) / mach_base_info.denom) / 1000000);
+        const uint64_t now = mach_absolute_time();
+        return ((((now - start_mach) * mach_base_info.numer) / mach_base_info.denom) / 1000000);
 #else
         SDL_assert(SDL_FALSE);
-        ticks = 0;
+        return 0;
 #endif
     } else {
         struct timeval now;
-
         gettimeofday(&now, NULL);
-        ticks = (Uint32)((now.tv_sec - start_tv.tv_sec) * 1000 + (now.tv_usec - start_tv.tv_usec) / 1000);
+        return (Uint64)(((Sint64)(now.tv_sec - start_tv.tv_sec) * 1000) + ((now.tv_usec - start_tv.tv_usec) / 1000));
     }
-    return (ticks);
 }
 
 Uint64
@@ -190,6 +187,15 @@ SDL_GetPerformanceFrequency(void)
 void
 SDL_Delay(Uint32 ms)
 {
+    int was_error;
+
+#if HAVE_NANOSLEEP
+    struct timespec elapsed, tv;
+#else
+    struct timeval tv;
+    Uint64 then, now, elapsed;
+#endif
+
 #ifdef __EMSCRIPTEN__
     if (emscripten_has_asyncify() && SDL_GetHintBoolean(SDL_HINT_EMSCRIPTEN_ASYNCIFY, SDL_TRUE)) {
         /* pseudo-synchronous pause, used directly or through e.g. SDL_WaitEvent */
@@ -197,21 +203,13 @@ SDL_Delay(Uint32 ms)
         return;
     }
 #endif
-    int was_error;
-
-#if HAVE_NANOSLEEP
-    struct timespec elapsed, tv;
-#else
-    struct timeval tv;
-    Uint32 then, now, elapsed;
-#endif
 
     /* Set the timeout interval */
 #if HAVE_NANOSLEEP
     elapsed.tv_sec = ms / 1000;
     elapsed.tv_nsec = (ms % 1000) * 1000000;
 #else
-    then = SDL_GetTicks();
+    then = SDL_GetTicks64();
 #endif
     do {
         errno = 0;
@@ -222,13 +220,13 @@ SDL_Delay(Uint32 ms)
         was_error = nanosleep(&tv, &elapsed);
 #else
         /* Calculate the time interval left (in case of interrupt) */
-        now = SDL_GetTicks();
+        now = SDL_GetTicks64();
         elapsed = (now - then);
         then = now;
-        if (elapsed >= ms) {
+        if (elapsed >= ((Uint64)ms)) {
             break;
         }
-        ms -= elapsed;
+        ms -= (Uint32)elapsed;
         tv.tv_sec = ms / 1000;
         tv.tv_usec = (ms % 1000) * 1000;
 
diff --git a/Engine/lib/sdl/src/timer/vita/SDL_systimer.c b/Engine/lib/sdl/src/timer/vita/SDL_systimer.c
new file mode 100644
index 000000000..db382378e
--- /dev/null
+++ b/Engine/lib/sdl/src/timer/vita/SDL_systimer.c
@@ -0,0 +1,89 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#ifdef SDL_TIMER_VITA
+
+#include "SDL_thread.h"
+#include "SDL_timer.h"
+#include "SDL_error.h"
+#include "../SDL_timer_c.h"
+#include <stdlib.h>
+#include <time.h>
+#include <sys/time.h>
+#include <psp2/kernel/processmgr.h>
+
+static uint64_t start;
+static SDL_bool ticks_started = SDL_FALSE;
+
+void
+SDL_TicksInit(void)
+{
+    if (ticks_started) {
+        return;
+    }
+    ticks_started = SDL_TRUE;
+
+    start = sceKernelGetProcessTimeWide();
+}
+
+void
+SDL_TicksQuit(void)
+{
+    ticks_started = SDL_FALSE;
+}
+
+Uint64
+SDL_GetTicks64(void)
+{
+    uint64_t now;
+
+    if (!ticks_started) {
+        SDL_TicksInit();
+    }
+
+    now = sceKernelGetProcessTimeWide();
+    return (Uint64) ((now - start) / 1000);
+}
+
+Uint64
+SDL_GetPerformanceCounter(void)
+{
+    return sceKernelGetProcessTimeWide();
+}
+
+Uint64
+SDL_GetPerformanceFrequency(void)
+{
+    return 1000000;
+}
+
+void SDL_Delay(Uint32 ms)
+{
+    const Uint32 max_delay = 0xffffffffUL / 1000;
+    if(ms > max_delay)
+        ms = max_delay;
+    sceKernelDelayThreadCB(ms * 1000);
+}
+
+#endif /* SDL_TIMER_VITA */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/timer/windows/SDL_systimer.c b/Engine/lib/sdl/src/timer/windows/SDL_systimer.c
index 6c8d23f94..7972db131 100644
--- a/Engine/lib/sdl/src/timer/windows/SDL_systimer.c
+++ b/Engine/lib/sdl/src/timer/windows/SDL_systimer.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -33,12 +33,10 @@
 static DWORD start = 0;
 static BOOL ticks_started = FALSE; 
 
-/* Store if a high-resolution performance counter exists on the system */
-static BOOL hires_timer_available;
 /* The first high-resolution ticks value of the application */
-static LARGE_INTEGER hires_start_ticks;
+static LARGE_INTEGER start_ticks;
 /* The number of ticks per second of the high-resolution performance counter */
-static LARGE_INTEGER hires_ticks_per_second;
+static LARGE_INTEGER ticks_per_second;
 
 static void
 SDL_SetSystemTimerResolution(const UINT uPeriod)
@@ -79,6 +77,8 @@ SDL_TimerResolutionChanged(void *userdata, const char *name, const char *oldValu
 void
 SDL_TicksInit(void)
 {
+    BOOL rc;
+
     if (ticks_started) {
         return;
     }
@@ -90,18 +90,12 @@ SDL_TicksInit(void)
                         SDL_TimerResolutionChanged, NULL);
 
     /* Set first ticks value */
-    /* QueryPerformanceCounter has had problems in the past, but lots of games
-       use it, so we'll rely on it here.
+    /* QueryPerformanceCounter allegedly is always available and reliable as of WinXP,
+       so we'll rely on it here.
      */
-    if (QueryPerformanceFrequency(&hires_ticks_per_second) == TRUE) {
-        hires_timer_available = TRUE;
-        QueryPerformanceCounter(&hires_start_ticks);
-    } else {
-        hires_timer_available = FALSE;
-#ifndef __WINRT__
-        start = timeGetTime();
-#endif /* __WINRT__ */
-    }
+    rc = QueryPerformanceFrequency(&ticks_per_second);
+    SDL_assert(rc != 0);  /* this should _never_ fail if you're on XP or later. */
+    QueryPerformanceCounter(&start_ticks);
 }
 
 void
@@ -116,53 +110,37 @@ SDL_TicksQuit(void)
     ticks_started = SDL_FALSE;
 }
 
-Uint32
-SDL_GetTicks(void)
+Uint64
+SDL_GetTicks64(void)
 {
-    DWORD now = 0;
-    LARGE_INTEGER hires_now;
+    LARGE_INTEGER now;
+    BOOL rc;
 
     if (!ticks_started) {
         SDL_TicksInit();
     }
 
-    if (hires_timer_available) {
-        QueryPerformanceCounter(&hires_now);
-
-        hires_now.QuadPart -= hires_start_ticks.QuadPart;
-        hires_now.QuadPart *= 1000;
-        hires_now.QuadPart /= hires_ticks_per_second.QuadPart;
-
-        return (DWORD) hires_now.QuadPart;
-    } else {
-#ifndef __WINRT__
-        now = timeGetTime();
-#endif /* __WINRT__ */
-    }
-
-    return (now - start);
+    rc = QueryPerformanceCounter(&now);
+    SDL_assert(rc != 0);  /* this should _never_ fail if you're on XP or later. */
+    return (Uint64) (((now.QuadPart - start_ticks.QuadPart) * 1000) / ticks_per_second.QuadPart);
 }
 
 Uint64
 SDL_GetPerformanceCounter(void)
 {
     LARGE_INTEGER counter;
-
-    if (!QueryPerformanceCounter(&counter)) {
-        return SDL_GetTicks();
-    }
-    return counter.QuadPart;
+    const BOOL rc = QueryPerformanceCounter(&counter);
+    SDL_assert(rc != 0);  /* this should _never_ fail if you're on XP or later. */
+    return (Uint64) counter.QuadPart;
 }
 
 Uint64
 SDL_GetPerformanceFrequency(void)
 {
     LARGE_INTEGER frequency;
-
-    if (!QueryPerformanceFrequency(&frequency)) {
-        return 1000;
-    }
-    return frequency.QuadPart;
+    const BOOL rc = QueryPerformanceFrequency(&frequency);
+    SDL_assert(rc != 0);  /* this should _never_ fail if you're on XP or later. */
+    return (Uint64) frequency.QuadPart;
 }
 
 void
diff --git a/Engine/lib/sdl/src/video/SDL_RLEaccel.c b/Engine/lib/sdl/src/video/SDL_RLEaccel.c
index d04b94ed3..983c9d914 100644
--- a/Engine/lib/sdl/src/video/SDL_RLEaccel.c
+++ b/Engine/lib/sdl/src/video/SDL_RLEaccel.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -1227,7 +1227,7 @@ RLEAlphaSurface(SDL_Surface * surface)
         surface->flags &= ~SDL_SIMD_ALIGNED;
     }
 
-    /* realloc the buffer to release unused memory */
+    /* reallocate the buffer to release unused memory */
     {
         Uint8 *p = SDL_realloc(rlebuf, dst - rlebuf);
         if (!p)
@@ -1391,9 +1391,9 @@ RLEColorkeySurface(SDL_Surface * surface)
         surface->flags &= ~SDL_SIMD_ALIGNED;
     }
 
-    /* realloc the buffer to release unused memory */
+    /* reallocate the buffer to release unused memory */
     {
-        /* If realloc returns NULL, the original block is left intact */
+        /* If SDL_realloc returns NULL, the original block is left intact */
         Uint8 *p = SDL_realloc(rlebuf, dst - rlebuf);
         if (!p)
             p = rlebuf;
@@ -1423,9 +1423,13 @@ SDL_RLESurface(SDL_Surface * surface)
         return -1;
     }
 
-    /* If we don't have colorkey or blending, nothing to do... */
     flags = surface->map->info.flags;
-    if (!(flags & (SDL_COPY_COLORKEY | SDL_COPY_BLEND))) {
+    if (flags & SDL_COPY_COLORKEY) {
+        /* ok */
+    } else if ((flags & SDL_COPY_BLEND) && surface->format->Amask) {
+        /* ok */
+    } else {
+        /* If we don't have colorkey or blending, nothing to do... */
         return -1;
     }
 
diff --git a/Engine/lib/sdl/src/video/SDL_RLEaccel_c.h b/Engine/lib/sdl/src/video/SDL_RLEaccel_c.h
index 3dcc6c023..6f0d95f91 100644
--- a/Engine/lib/sdl/src/video/SDL_RLEaccel_c.h
+++ b/Engine/lib/sdl/src/video/SDL_RLEaccel_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/SDL_blit.c b/Engine/lib/sdl/src/video/SDL_blit.c
index a5df0b995..fa6492f51 100644
--- a/Engine/lib/sdl/src/video/SDL_blit.c
+++ b/Engine/lib/sdl/src/video/SDL_blit.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -231,9 +231,7 @@ SDL_CalculateBlit(SDL_Surface * surface)
     if (map->identity && !(map->info.flags & ~SDL_COPY_RLE_DESIRED)) {
         blit = SDL_BlitCopy;
     } else if (surface->format->Rloss > 8 || dst->format->Rloss > 8) {
-        /* Greater than 8 bits per channel not supported yet */
-        SDL_InvalidateMap(map);
-        return SDL_SetError("Blit combination not supported");
+        blit = SDL_Blit_Slow;
     }
 #if SDL_HAVE_BLIT_0
     else if (surface->format->BitsPerPixel < 8 &&
diff --git a/Engine/lib/sdl/src/video/SDL_blit.h b/Engine/lib/sdl/src/video/SDL_blit.h
index 81a9d8bb7..e00ba68e2 100644
--- a/Engine/lib/sdl/src/video/SDL_blit.h
+++ b/Engine/lib/sdl/src/video/SDL_blit.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -27,6 +27,12 @@
 #include "SDL_endian.h"
 #include "SDL_surface.h"
 
+/* pixman ARM blitters are 32 bit only : */
+#if defined(__aarch64__)||defined(_M_ARM64)
+#undef SDL_ARM_SIMD_BLITTERS
+#undef SDL_ARM_NEON_BLITTERS
+#endif
+
 /* Table to do pixel byte expansion */
 extern Uint8* SDL_expand_byte[9];
 
@@ -263,18 +269,18 @@ do {                                                                    \
 {                                                                       \
     switch (bpp) {                                                      \
         case 1: {                                                       \
-            Uint8 _Pixel;                                               \
+            Uint8 _pixel;                                               \
                                                                         \
-            PIXEL_FROM_RGB(_Pixel, fmt, r, g, b);                       \
-            *((Uint8 *)(buf)) = _Pixel;                                 \
+            PIXEL_FROM_RGB(_pixel, fmt, r, g, b);                       \
+            *((Uint8 *)(buf)) = _pixel;                                 \
         }                                                               \
         break;                                                          \
                                                                         \
         case 2: {                                                       \
-            Uint16 _Pixel;                                              \
+            Uint16 _pixel;                                              \
                                                                         \
-            PIXEL_FROM_RGB(_Pixel, fmt, r, g, b);                       \
-            *((Uint16 *)(buf)) = _Pixel;                                \
+            PIXEL_FROM_RGB(_pixel, fmt, r, g, b);                       \
+            *((Uint16 *)(buf)) = _pixel;                                \
         }                                                               \
         break;                                                          \
                                                                         \
@@ -292,10 +298,10 @@ do {                                                                    \
         break;                                                          \
                                                                         \
         case 4: {                                                       \
-            Uint32 _Pixel;                                              \
+            Uint32 _pixel;                                              \
                                                                         \
-            PIXEL_FROM_RGB(_Pixel, fmt, r, g, b);                       \
-            *((Uint32 *)(buf)) = _Pixel;                                \
+            PIXEL_FROM_RGB(_pixel, fmt, r, g, b);                       \
+            *((Uint32 *)(buf)) = _pixel;                                \
         }                                                               \
         break;                                                          \
     }                                                                   \
@@ -473,14 +479,14 @@ do {                                                                    \
 #define DUFFS_LOOP8(pixel_copy_increment, width)                        \
 { int n = (width+7)/8;                                                  \
     switch (width & 7) {                                                \
-    case 0: do {    pixel_copy_increment; /* fallthrough */             \
-    case 7:     pixel_copy_increment;     /* fallthrough */             \
-    case 6:     pixel_copy_increment;     /* fallthrough */             \
-    case 5:     pixel_copy_increment;     /* fallthrough */             \
-    case 4:     pixel_copy_increment;     /* fallthrough */             \
-    case 3:     pixel_copy_increment;     /* fallthrough */             \
-    case 2:     pixel_copy_increment;     /* fallthrough */             \
-    case 1:     pixel_copy_increment;     /* fallthrough */             \
+    case 0: do {    pixel_copy_increment; SDL_FALLTHROUGH;              \
+    case 7:     pixel_copy_increment;     SDL_FALLTHROUGH;              \
+    case 6:     pixel_copy_increment;     SDL_FALLTHROUGH;              \
+    case 5:     pixel_copy_increment;     SDL_FALLTHROUGH;              \
+    case 4:     pixel_copy_increment;     SDL_FALLTHROUGH;              \
+    case 3:     pixel_copy_increment;     SDL_FALLTHROUGH;              \
+    case 2:     pixel_copy_increment;     SDL_FALLTHROUGH;              \
+    case 1:     pixel_copy_increment;                                   \
         } while ( --n > 0 );                                            \
     }                                                                   \
 }
@@ -489,10 +495,10 @@ do {                                                                    \
 #define DUFFS_LOOP4(pixel_copy_increment, width)                        \
 { int n = (width+3)/4;                                                  \
     switch (width & 3) {                                                \
-    case 0: do {    pixel_copy_increment;   /* fallthrough */           \
-    case 3:     pixel_copy_increment;       /* fallthrough */           \
-    case 2:     pixel_copy_increment;       /* fallthrough */           \
-    case 1:     pixel_copy_increment;       /* fallthrough */           \
+    case 0: do {    pixel_copy_increment;   SDL_FALLTHROUGH;            \
+    case 3:     pixel_copy_increment;       SDL_FALLTHROUGH;            \
+    case 2:     pixel_copy_increment;       SDL_FALLTHROUGH;            \
+    case 1:     pixel_copy_increment;                                   \
         } while (--n > 0);                                              \
     }                                                                   \
 }
diff --git a/Engine/lib/sdl/src/video/SDL_blit_0.c b/Engine/lib/sdl/src/video/SDL_blit_0.c
index 1e4ebbe11..54882f8b1 100644
--- a/Engine/lib/sdl/src/video/SDL_blit_0.c
+++ b/Engine/lib/sdl/src/video/SDL_blit_0.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -452,11 +452,94 @@ static const SDL_BlitFunc colorkey_blit[] = {
     (SDL_BlitFunc) NULL, BlitBto1Key, BlitBto2Key, BlitBto3Key, BlitBto4Key
 };
 
+
+static void
+Blit4bto4(SDL_BlitInfo * info)
+{
+    int width = info->dst_w;
+    int height = info->dst_h;
+    Uint8 *src = info->src;
+    Uint32 *dst = (Uint32 *) info->dst;
+    int srcskip = info->src_skip;
+    int dstskip = info->dst_skip;
+    Uint32 *map = (Uint32 *) info->table;
+    int c;
+
+    /* Set up some basic variables */
+    srcskip += width - (width + 1) / 2;
+
+    while (height--) {
+        Uint8 byte = 0, bit;
+        for (c = 0; c < width; ++c) {
+            if ((c & 0x1) == 0) {
+                byte = *src++;
+            }
+            bit = (byte & 0xF0) >> 4;
+            if (1) {
+                *dst = map[bit];
+            }
+            byte <<= 4;
+            dst++;
+        }
+        src += srcskip;
+        dst = (Uint32 *) ((Uint8 *) dst + dstskip);
+    }
+}
+
+static void
+Blit4bto4Key(SDL_BlitInfo * info)
+{
+    int width = info->dst_w;
+    int height = info->dst_h;
+    Uint8 *src = info->src;
+    Uint32 *dst = (Uint32 *) info->dst;
+    int srcskip = info->src_skip;
+    int dstskip = info->dst_skip;
+    Uint32 ckey = info->colorkey;
+    Uint32 *map = (Uint32 *) info->table;
+    int c;
+
+    /* Set up some basic variables */
+    srcskip += width - (width + 1) / 2;
+
+    while (height--) {
+        Uint8 byte = 0, bit;
+        for (c = 0; c < width; ++c) {
+            if ((c & 0x1) == 0) {
+                byte = *src++;
+            }
+            bit = (byte & 0xF0) >> 4;
+            if (bit != ckey) {
+                *dst = map[bit];
+            }
+            byte <<= 4;
+            dst++;
+        }
+        src += srcskip;
+        dst = (Uint32 *) ((Uint8 *) dst + dstskip);
+    }
+}
+
 SDL_BlitFunc
 SDL_CalculateBlit0(SDL_Surface * surface)
 {
     int which;
 
+    /* 4bits to 32bits */
+    if (surface->format->BitsPerPixel == 4) {
+        if (surface->map->dst->format->BytesPerPixel == 4) {
+            switch (surface->map->info.flags & ~SDL_COPY_RLE_MASK) {
+                case 0:
+                    return Blit4bto4;
+
+                case SDL_COPY_COLORKEY:
+                    return Blit4bto4Key;
+            }
+        }
+        /* We don't fully support 4-bit packed pixel modes */
+        return NULL;
+    }
+
     if (surface->format->BitsPerPixel != 1) {
         /* We don't support sub 8-bit packed pixel modes */
         return (SDL_BlitFunc) NULL;
diff --git a/Engine/lib/sdl/src/video/SDL_blit_1.c b/Engine/lib/sdl/src/video/SDL_blit_1.c
index d75caff4b..d5030cfb1 100644
--- a/Engine/lib/sdl/src/video/SDL_blit_1.c
+++ b/Engine/lib/sdl/src/video/SDL_blit_1.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/SDL_blit_A.c b/Engine/lib/sdl/src/video/SDL_blit_A.c
index c9c37f03a..4c0726eb0 100644
--- a/Engine/lib/sdl/src/video/SDL_blit_A.c
+++ b/Engine/lib/sdl/src/video/SDL_blit_A.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -397,14 +397,14 @@ void BlitARGBto565PixelAlphaARMSIMDAsm(int32_t w, int32_t h, uint16_t *dst, int3
 static void
 BlitARGBto565PixelAlphaARMSIMD(SDL_BlitInfo * info)
 {
-	int32_t width = info->dst_w;
-	int32_t height = info->dst_h;
-	uint16_t *dstp = (uint16_t *)info->dst;
-	int32_t dststride = width + (info->dst_skip >> 1);
-	uint32_t *srcp = (uint32_t *)info->src;
-	int32_t srcstride = width + (info->src_skip >> 2);
+    int32_t width = info->dst_w;
+    int32_t height = info->dst_h;
+    uint16_t *dstp = (uint16_t *)info->dst;
+    int32_t dststride = width + (info->dst_skip >> 1);
+    uint32_t *srcp = (uint32_t *)info->src;
+    int32_t srcstride = width + (info->src_skip >> 2);
 
-	BlitARGBto565PixelAlphaARMSIMDAsm(width, height, dstp, dststride, srcp, srcstride);
+    BlitARGBto565PixelAlphaARMSIMDAsm(width, height, dstp, dststride, srcp, srcstride);
 }
 
 void BlitRGBtoRGBPixelAlphaARMSIMDAsm(int32_t w, int32_t h, uint32_t *dst, int32_t dst_stride, uint32_t *src, int32_t src_stride);
@@ -444,14 +444,14 @@ void BlitRGBtoRGBPixelAlphaARMNEONAsm(int32_t w, int32_t h, uint32_t *dst, int32
 static void
 BlitRGBtoRGBPixelAlphaARMNEON(SDL_BlitInfo * info)
 {
-	int32_t width = info->dst_w;
-	int32_t height = info->dst_h;
-	uint32_t *dstp = (uint32_t *)info->dst;
-	int32_t dststride = width + (info->dst_skip >> 2);
-	uint32_t *srcp = (uint32_t *)info->src;
-	int32_t srcstride = width + (info->src_skip >> 2);
+    int32_t width = info->dst_w;
+    int32_t height = info->dst_h;
+    uint32_t *dstp = (uint32_t *)info->dst;
+    int32_t dststride = width + (info->dst_skip >> 2);
+    uint32_t *srcp = (uint32_t *)info->src;
+    int32_t srcstride = width + (info->src_skip >> 2);
 
-	BlitRGBtoRGBPixelAlphaARMNEONAsm(width, height, dstp, dststride, srcp, srcstride);
+    BlitRGBtoRGBPixelAlphaARMNEONAsm(width, height, dstp, dststride, srcp, srcstride);
 }
 #endif
 
@@ -575,6 +575,61 @@ BlitRGBtoRGBPixelAlpha(SDL_BlitInfo * info)
     }
 }
 
+/* fast ARGB888->(A)BGR888 blending with pixel alpha */
+static void
+BlitRGBtoBGRPixelAlpha(SDL_BlitInfo * info)
+{
+    int width = info->dst_w;
+    int height = info->dst_h;
+    Uint32 *srcp = (Uint32 *) info->src;
+    int srcskip = info->src_skip >> 2;
+    Uint32 *dstp = (Uint32 *) info->dst;
+    int dstskip = info->dst_skip >> 2;
+
+    while (height--) {
+        /* *INDENT-OFF* */
+        DUFFS_LOOP4({
+        Uint32 dalpha;
+        Uint32 d;
+        Uint32 s1;
+        Uint32 d1;
+        Uint32 s = *srcp;
+        Uint32 alpha = s >> 24;
+        /* FIXME: Here we special-case opaque alpha since the
+           compositioning used (>>8 instead of /255) doesn't handle
+           it correctly. Also special-case alpha=0 for speed?
+           Benchmark this! */
+        if (alpha) {
+          /*
+           * take out the middle component (green), and process
+           * the other two in parallel. One multiply less.
+           */
+          s1 = s & 0xff00ff;
+          s1 = (s1 >> 16) | (s1 << 16);
+          s &= 0xff00;
+
+          if (alpha == SDL_ALPHA_OPAQUE) {
+              *dstp = 0xff000000 | s | s1;
+          } else {
+            d = *dstp;
+            dalpha = d >> 24;
+            d1 = d & 0xff00ff;
+            d1 = (d1 + ((s1 - d1) * alpha >> 8)) & 0xff00ff;
+            d &= 0xff00;
+            d = (d + ((s - d) * alpha >> 8)) & 0xff00;
+            dalpha = alpha + (dalpha * (alpha ^ 0xFF) >> 8);
+            *dstp = d1 | d | (dalpha << 24);
+          }
+        }
+        ++srcp;
+        ++dstp;
+        }, width);
+        /* *INDENT-ON* */
+        srcp += srcskip;
+        dstp += dstskip;
+    }
+}
+
 #ifdef __3dNOW__
 /* fast (as in MMX with prefetch) ARGB888->(A)RGB888 blending with pixel alpha */
 static void
@@ -1407,6 +1462,12 @@ SDL_CalculateBlitA(SDL_Surface * surface)
 #endif
                     return BlitRGBtoRGBPixelAlpha;
                 }
+            } else if (sf->Rmask == df->Bmask
+                && sf->Gmask == df->Gmask
+                && sf->Bmask == df->Rmask && sf->BytesPerPixel == 4) {
+                if (sf->Amask == 0xff000000) {
+                    return BlitRGBtoBGRPixelAlpha;
+                }
             }
             return BlitNtoNPixelAlpha;
 
diff --git a/Engine/lib/sdl/src/video/SDL_blit_N.c b/Engine/lib/sdl/src/video/SDL_blit_N.c
index 5199abe1d..e3b6c96a3 100644
--- a/Engine/lib/sdl/src/video/SDL_blit_N.c
+++ b/Engine/lib/sdl/src/video/SDL_blit_N.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -40,11 +40,11 @@
 /* Functions to blit from N-bit surfaces to other surfaces */
 
 enum blit_features {
-	BLIT_FEATURE_NONE = 0,
-	BLIT_FEATURE_HAS_MMX = 1,
-	BLIT_FEATURE_HAS_ALTIVEC = 2,
-	BLIT_FEATURE_ALTIVEC_DONT_USE_PREFETCH = 4,
-	BLIT_FEATURE_HAS_ARM_SIMD = 8
+    BLIT_FEATURE_NONE = 0,
+    BLIT_FEATURE_HAS_MMX = 1,
+    BLIT_FEATURE_HAS_ALTIVEC = 2,
+    BLIT_FEATURE_ALTIVEC_DONT_USE_PREFETCH = 4,
+    BLIT_FEATURE_HAS_ARM_SIMD = 8
 };
 
 #if SDL_ALTIVEC_BLITTERS
@@ -128,7 +128,7 @@ calc_swizzle32(const SDL_PixelFormat * srcfmt, const SDL_PixelFormat * dstfmt)
      *  leave alpha with a zero mask, but we should still swizzle the bits.
      */
     /* ARGB */
-    const static const struct SDL_PixelFormat default_pixel_format = {
+    static const struct SDL_PixelFormat default_pixel_format = {
         0, NULL, 0, 0,
         {0, 0},
         0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000,
@@ -943,14 +943,14 @@ void Blit_BGR888_RGB888ARMSIMDAsm(int32_t w, int32_t h, uint32_t *dst, int32_t d
 static void
 Blit_BGR888_RGB888ARMSIMD(SDL_BlitInfo * info)
 {
-	int32_t width = info->dst_w;
-	int32_t height = info->dst_h;
-	uint32_t *dstp = (uint32_t *)info->dst;
-	int32_t dststride = width + (info->dst_skip >> 2);
-	uint32_t *srcp = (uint32_t *)info->src;
-	int32_t srcstride = width + (info->src_skip >> 2);
+    int32_t width = info->dst_w;
+    int32_t height = info->dst_h;
+    uint32_t *dstp = (uint32_t *)info->dst;
+    int32_t dststride = width + (info->dst_skip >> 2);
+    uint32_t *srcp = (uint32_t *)info->src;
+    int32_t srcstride = width + (info->src_skip >> 2);
 
-	Blit_BGR888_RGB888ARMSIMDAsm(width, height, dstp, dststride, srcp, srcstride);
+    Blit_BGR888_RGB888ARMSIMDAsm(width, height, dstp, dststride, srcp, srcstride);
 }
 
 void Blit_RGB444_RGB888ARMSIMDAsm(int32_t w, int32_t h, uint32_t *dst, int32_t dst_stride, uint16_t *src, int32_t src_stride);
@@ -958,14 +958,14 @@ void Blit_RGB444_RGB888ARMSIMDAsm(int32_t w, int32_t h, uint32_t *dst, int32_t d
 static void
 Blit_RGB444_RGB888ARMSIMD(SDL_BlitInfo * info)
 {
-	int32_t width = info->dst_w;
-	int32_t height = info->dst_h;
-	uint32_t *dstp = (uint32_t *)info->dst;
-	int32_t dststride = width + (info->dst_skip >> 2);
-	uint16_t *srcp = (uint16_t *)info->src;
-	int32_t srcstride = width + (info->src_skip >> 1);
+    int32_t width = info->dst_w;
+    int32_t height = info->dst_h;
+    uint32_t *dstp = (uint32_t *)info->dst;
+    int32_t dststride = width + (info->dst_skip >> 2);
+    uint16_t *srcp = (uint16_t *)info->src;
+    int32_t srcstride = width + (info->src_skip >> 1);
 
-	Blit_RGB444_RGB888ARMSIMDAsm(width, height, dstp, dststride, srcp, srcstride);
+    Blit_RGB444_RGB888ARMSIMDAsm(width, height, dstp, dststride, srcp, srcstride);
 }
 #endif
 
@@ -2073,6 +2073,35 @@ Blit_RGB565_BGRA8888(SDL_BlitInfo * info)
 
 #endif /* SDL_HAVE_BLIT_N_RGB565 */
 
+/* RGB555->ARGB1555, and BGR555->ABGR1555, SET_ALPHA */
+static void
+Blit_RGB555_ARGB1555(SDL_BlitInfo * info)
+{
+    int width = info->dst_w;
+    int height = info->dst_h;
+    Uint16 *src = (Uint16 *) info->src;
+    int srcskip = info->src_skip;
+    Uint16 *dst = (Uint16 *) info->dst;
+    int dstskip = info->dst_skip;
+    SDL_PixelFormat *dstfmt = info->dst_fmt;
+
+    Uint16 mask = ((Uint32)info->a >> dstfmt->Aloss) << dstfmt->Ashift;
+
+    while (height--) {
+        /* *INDENT-OFF* */
+        DUFFS_LOOP(
+        {
+            *dst = *src | mask;
+            ++dst;
+            ++src;
+        },
+        width);
+        /* *INDENT-ON* */
+        src = (Uint16 *) ((Uint8 *) src + srcskip);
+        dst = (Uint16 *) ((Uint8 *) dst + dstskip);
+    }
+}
+
 static void
 BlitNto1(SDL_BlitInfo * info)
 {
@@ -3259,6 +3288,10 @@ static const struct blit_table normal_blit_2[] = {
     {0x0000F800, 0x000007E0, 0x0000001F, 4, 0x0000FF00, 0x00FF0000, 0xFF000000,
      0, Blit_RGB565_BGRA8888, NO_ALPHA | COPY_ALPHA | SET_ALPHA},
 #endif
+    {0x00007C00, 0x000003E0, 0x0000001F, 2, 0x00007C00, 0x000003E0, 0x0000001F,
+     0, Blit_RGB555_ARGB1555, SET_ALPHA},
+    {0x0000001F, 0x000003E0, 0x00007C00, 2, 0x0000001F, 0x000003E0, 0x00007C00,
+     0, Blit_RGB555_ARGB1555, SET_ALPHA},
 
     /* Default for 16-bit RGB source, used if no other blitter matches */
     {0, 0, 0, 0, 0, 0, 0, 0, BlitNtoN, 0}
diff --git a/Engine/lib/sdl/src/video/SDL_blit_auto.c b/Engine/lib/sdl/src/video/SDL_blit_auto.c
index 7aff395c9..f64511fcc 100644
--- a/Engine/lib/sdl/src/video/SDL_blit_auto.c
+++ b/Engine/lib/sdl/src/video/SDL_blit_auto.c
@@ -1,7 +1,7 @@
 /* DO NOT EDIT!  This file is generated by sdlgenblit.pl */
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -32,32 +32,23 @@
 static void SDL_Blit_RGB888_RGB888_Scale(SDL_BlitInfo *info)
 {
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             *dst = *src;
             posx += incx;
             ++dst;
@@ -124,32 +115,23 @@ static void SDL_Blit_RGB888_RGB888_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel;
             dstpixel = *dst;
@@ -226,32 +208,23 @@ static void SDL_Blit_RGB888_RGB888_Modulate_Scale(SDL_BlitInfo *info)
     Uint32 pixel;
     Uint32 R, G, B;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
             R = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); B = (Uint8)pixel;
             if (flags & SDL_COPY_MODULATE_COLOR) {
@@ -349,32 +322,23 @@ static void SDL_Blit_RGB888_RGB888_Modulate_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel;
             dstpixel = *dst;
@@ -429,32 +393,23 @@ static void SDL_Blit_RGB888_BGR888_Scale(SDL_BlitInfo *info)
     Uint32 pixel;
     Uint32 R, G, B;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
             R = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); B = (Uint8)pixel;
             pixel = (B << 16) | (G << 8) | R;
@@ -524,32 +479,23 @@ static void SDL_Blit_RGB888_BGR888_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel;
             dstpixel = *dst;
@@ -626,32 +572,23 @@ static void SDL_Blit_RGB888_BGR888_Modulate_Scale(SDL_BlitInfo *info)
     Uint32 pixel;
     Uint32 R, G, B;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
             R = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); B = (Uint8)pixel;
             if (flags & SDL_COPY_MODULATE_COLOR) {
@@ -749,32 +686,23 @@ static void SDL_Blit_RGB888_BGR888_Modulate_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel;
             dstpixel = *dst;
@@ -828,37 +756,26 @@ static void SDL_Blit_RGB888_ARGB8888_Scale(SDL_BlitInfo *info)
 {
     Uint32 pixel;
     const Uint32 A = 0xFF;
-    Uint32 R, G, B;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
-            R = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); B = (Uint8)pixel;
-            pixel = (A << 24) | (R << 16) | (G << 8) | B;
+            pixel |= (A << 24);
             *dst = pixel;
             posx += incx;
             ++dst;
@@ -927,32 +844,23 @@ static void SDL_Blit_RGB888_ARGB8888_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB, dstA;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel;
             dstpixel = *dst;
@@ -1035,32 +943,23 @@ static void SDL_Blit_RGB888_ARGB8888_Modulate_Scale(SDL_BlitInfo *info)
     const Uint32 A = (flags & SDL_COPY_MODULATE_ALPHA) ? modulateA : 0xFF;
     Uint32 R, G, B;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
             R = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); B = (Uint8)pixel;
             if (flags & SDL_COPY_MODULATE_COLOR) {
@@ -1160,32 +1059,23 @@ static void SDL_Blit_RGB888_ARGB8888_Modulate_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB, dstA;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel;
             dstpixel = *dst;
@@ -1242,32 +1132,23 @@ static void SDL_Blit_BGR888_RGB888_Scale(SDL_BlitInfo *info)
     Uint32 pixel;
     Uint32 R, G, B;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
             B = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); R = (Uint8)pixel;
             pixel = (R << 16) | (G << 8) | B;
@@ -1337,32 +1218,23 @@ static void SDL_Blit_BGR888_RGB888_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel;
             dstpixel = *dst;
@@ -1439,32 +1311,23 @@ static void SDL_Blit_BGR888_RGB888_Modulate_Scale(SDL_BlitInfo *info)
     Uint32 pixel;
     Uint32 R, G, B;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
             B = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); R = (Uint8)pixel;
             if (flags & SDL_COPY_MODULATE_COLOR) {
@@ -1562,32 +1425,23 @@ static void SDL_Blit_BGR888_RGB888_Modulate_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel;
             dstpixel = *dst;
@@ -1640,32 +1494,23 @@ static void SDL_Blit_BGR888_RGB888_Modulate_Blend_Scale(SDL_BlitInfo *info)
 static void SDL_Blit_BGR888_BGR888_Scale(SDL_BlitInfo *info)
 {
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             *dst = *src;
             posx += incx;
             ++dst;
@@ -1732,32 +1577,23 @@ static void SDL_Blit_BGR888_BGR888_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel;
             dstpixel = *dst;
@@ -1834,32 +1670,23 @@ static void SDL_Blit_BGR888_BGR888_Modulate_Scale(SDL_BlitInfo *info)
     Uint32 pixel;
     Uint32 R, G, B;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
             B = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); R = (Uint8)pixel;
             if (flags & SDL_COPY_MODULATE_COLOR) {
@@ -1957,32 +1784,23 @@ static void SDL_Blit_BGR888_BGR888_Modulate_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel;
             dstpixel = *dst;
@@ -2038,32 +1856,23 @@ static void SDL_Blit_BGR888_ARGB8888_Scale(SDL_BlitInfo *info)
     const Uint32 A = 0xFF;
     Uint32 R, G, B;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
             B = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); R = (Uint8)pixel;
             pixel = (A << 24) | (R << 16) | (G << 8) | B;
@@ -2135,32 +1944,23 @@ static void SDL_Blit_BGR888_ARGB8888_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB, dstA;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel;
             dstpixel = *dst;
@@ -2243,32 +2043,23 @@ static void SDL_Blit_BGR888_ARGB8888_Modulate_Scale(SDL_BlitInfo *info)
     const Uint32 A = (flags & SDL_COPY_MODULATE_ALPHA) ? modulateA : 0xFF;
     Uint32 R, G, B;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
             B = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); R = (Uint8)pixel;
             if (flags & SDL_COPY_MODULATE_COLOR) {
@@ -2368,32 +2159,23 @@ static void SDL_Blit_BGR888_ARGB8888_Modulate_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB, dstA;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel;
             dstpixel = *dst;
@@ -2448,37 +2230,26 @@ static void SDL_Blit_BGR888_ARGB8888_Modulate_Blend_Scale(SDL_BlitInfo *info)
 static void SDL_Blit_ARGB8888_RGB888_Scale(SDL_BlitInfo *info)
 {
     Uint32 pixel;
-    Uint32 R, G, B;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
-            R = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); B = (Uint8)pixel;
-            pixel = (R << 16) | (G << 8) | B;
+            pixel &= 0xFFFFFF;
             *dst = pixel;
             posx += incx;
             ++dst;
@@ -2553,32 +2324,23 @@ static void SDL_Blit_ARGB8888_RGB888_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel; srcA = (Uint8)(srcpixel >> 24);
             dstpixel = *dst;
@@ -2663,32 +2425,23 @@ static void SDL_Blit_ARGB8888_RGB888_Modulate_Scale(SDL_BlitInfo *info)
     Uint32 pixel;
     Uint32 R, G, B;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
             R = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); B = (Uint8)pixel;
             if (flags & SDL_COPY_MODULATE_COLOR) {
@@ -2787,32 +2540,23 @@ static void SDL_Blit_ARGB8888_RGB888_Modulate_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel; srcA = (Uint8)(srcpixel >> 24);
             dstpixel = *dst;
@@ -2870,32 +2614,23 @@ static void SDL_Blit_ARGB8888_BGR888_Scale(SDL_BlitInfo *info)
     Uint32 pixel;
     Uint32 R, G, B;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
             R = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); B = (Uint8)pixel;
             pixel = (B << 16) | (G << 8) | R;
@@ -2973,32 +2708,23 @@ static void SDL_Blit_ARGB8888_BGR888_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel; srcA = (Uint8)(srcpixel >> 24);
             dstpixel = *dst;
@@ -3083,32 +2809,23 @@ static void SDL_Blit_ARGB8888_BGR888_Modulate_Scale(SDL_BlitInfo *info)
     Uint32 pixel;
     Uint32 R, G, B;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
             R = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); B = (Uint8)pixel;
             if (flags & SDL_COPY_MODULATE_COLOR) {
@@ -3207,32 +2924,23 @@ static void SDL_Blit_ARGB8888_BGR888_Modulate_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel; srcA = (Uint8)(srcpixel >> 24);
             dstpixel = *dst;
@@ -3288,32 +2996,23 @@ static void SDL_Blit_ARGB8888_BGR888_Modulate_Blend_Scale(SDL_BlitInfo *info)
 static void SDL_Blit_ARGB8888_ARGB8888_Scale(SDL_BlitInfo *info)
 {
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             *dst = *src;
             posx += incx;
             ++dst;
@@ -3390,32 +3089,23 @@ static void SDL_Blit_ARGB8888_ARGB8888_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB, dstA;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel; srcA = (Uint8)(srcpixel >> 24);
             dstpixel = *dst;
@@ -3507,32 +3197,23 @@ static void SDL_Blit_ARGB8888_ARGB8888_Modulate_Scale(SDL_BlitInfo *info)
     Uint32 pixel;
     Uint32 R, G, B, A;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
             R = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); B = (Uint8)pixel; A = (Uint8)(pixel >> 24);
             if (flags & SDL_COPY_MODULATE_COLOR) {
@@ -3636,32 +3317,23 @@ static void SDL_Blit_ARGB8888_ARGB8888_Modulate_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB, dstA;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel; srcA = (Uint8)(srcpixel >> 24);
             dstpixel = *dst;
@@ -3719,37 +3391,26 @@ static void SDL_Blit_ARGB8888_ARGB8888_Modulate_Blend_Scale(SDL_BlitInfo *info)
 static void SDL_Blit_RGBA8888_RGB888_Scale(SDL_BlitInfo *info)
 {
     Uint32 pixel;
-    Uint32 R, G, B;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
-            R = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); B = (Uint8)(pixel >> 8);
-            pixel = (R << 16) | (G << 8) | B;
+            pixel >>= 8;
             *dst = pixel;
             posx += incx;
             ++dst;
@@ -3824,32 +3485,23 @@ static void SDL_Blit_RGBA8888_RGB888_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcR = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcB = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
             dstpixel = *dst;
@@ -3934,32 +3586,23 @@ static void SDL_Blit_RGBA8888_RGB888_Modulate_Scale(SDL_BlitInfo *info)
     Uint32 pixel;
     Uint32 R, G, B;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
             R = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); B = (Uint8)(pixel >> 8);
             if (flags & SDL_COPY_MODULATE_COLOR) {
@@ -4058,32 +3701,23 @@ static void SDL_Blit_RGBA8888_RGB888_Modulate_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcR = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcB = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
             dstpixel = *dst;
@@ -4141,32 +3775,23 @@ static void SDL_Blit_RGBA8888_BGR888_Scale(SDL_BlitInfo *info)
     Uint32 pixel;
     Uint32 R, G, B;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
             R = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); B = (Uint8)(pixel >> 8);
             pixel = (B << 16) | (G << 8) | R;
@@ -4244,32 +3869,23 @@ static void SDL_Blit_RGBA8888_BGR888_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcR = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcB = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
             dstpixel = *dst;
@@ -4354,32 +3970,23 @@ static void SDL_Blit_RGBA8888_BGR888_Modulate_Scale(SDL_BlitInfo *info)
     Uint32 pixel;
     Uint32 R, G, B;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
             R = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); B = (Uint8)(pixel >> 8);
             if (flags & SDL_COPY_MODULATE_COLOR) {
@@ -4478,32 +4085,23 @@ static void SDL_Blit_RGBA8888_BGR888_Modulate_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcR = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcB = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
             dstpixel = *dst;
@@ -4559,37 +4157,26 @@ static void SDL_Blit_RGBA8888_BGR888_Modulate_Blend_Scale(SDL_BlitInfo *info)
 static void SDL_Blit_RGBA8888_ARGB8888_Scale(SDL_BlitInfo *info)
 {
     Uint32 pixel;
-    Uint32 R, G, B, A;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
-            R = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); B = (Uint8)(pixel >> 8); A = (Uint8)pixel;
-            pixel = (A << 24) | (R << 16) | (G << 8) | B;
+            pixel = (pixel >> 8) | (pixel << 24);
             *dst = pixel;
             posx += incx;
             ++dst;
@@ -4666,32 +4253,23 @@ static void SDL_Blit_RGBA8888_ARGB8888_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB, dstA;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcR = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcB = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
             dstpixel = *dst;
@@ -4783,32 +4361,23 @@ static void SDL_Blit_RGBA8888_ARGB8888_Modulate_Scale(SDL_BlitInfo *info)
     Uint32 pixel;
     Uint32 R, G, B, A;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
             R = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); B = (Uint8)(pixel >> 8); A = (Uint8)pixel;
             if (flags & SDL_COPY_MODULATE_COLOR) {
@@ -4912,32 +4481,23 @@ static void SDL_Blit_RGBA8888_ARGB8888_Modulate_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB, dstA;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcR = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcB = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
             dstpixel = *dst;
@@ -4997,32 +4557,23 @@ static void SDL_Blit_ABGR8888_RGB888_Scale(SDL_BlitInfo *info)
     Uint32 pixel;
     Uint32 R, G, B;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
             B = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); R = (Uint8)pixel;
             pixel = (R << 16) | (G << 8) | B;
@@ -5100,32 +4651,23 @@ static void SDL_Blit_ABGR8888_RGB888_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel; srcA = (Uint8)(srcpixel >> 24);
             dstpixel = *dst;
@@ -5210,32 +4752,23 @@ static void SDL_Blit_ABGR8888_RGB888_Modulate_Scale(SDL_BlitInfo *info)
     Uint32 pixel;
     Uint32 R, G, B;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
             B = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); R = (Uint8)pixel;
             if (flags & SDL_COPY_MODULATE_COLOR) {
@@ -5334,32 +4867,23 @@ static void SDL_Blit_ABGR8888_RGB888_Modulate_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel; srcA = (Uint8)(srcpixel >> 24);
             dstpixel = *dst;
@@ -5415,37 +4939,26 @@ static void SDL_Blit_ABGR8888_RGB888_Modulate_Blend_Scale(SDL_BlitInfo *info)
 static void SDL_Blit_ABGR8888_BGR888_Scale(SDL_BlitInfo *info)
 {
     Uint32 pixel;
-    Uint32 R, G, B;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
-            B = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); R = (Uint8)pixel;
-            pixel = (B << 16) | (G << 8) | R;
+            pixel &= 0xFFFFFF;
             *dst = pixel;
             posx += incx;
             ++dst;
@@ -5520,32 +5033,23 @@ static void SDL_Blit_ABGR8888_BGR888_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel; srcA = (Uint8)(srcpixel >> 24);
             dstpixel = *dst;
@@ -5630,32 +5134,23 @@ static void SDL_Blit_ABGR8888_BGR888_Modulate_Scale(SDL_BlitInfo *info)
     Uint32 pixel;
     Uint32 R, G, B;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
             B = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); R = (Uint8)pixel;
             if (flags & SDL_COPY_MODULATE_COLOR) {
@@ -5754,32 +5249,23 @@ static void SDL_Blit_ABGR8888_BGR888_Modulate_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel; srcA = (Uint8)(srcpixel >> 24);
             dstpixel = *dst;
@@ -5837,32 +5323,23 @@ static void SDL_Blit_ABGR8888_ARGB8888_Scale(SDL_BlitInfo *info)
     Uint32 pixel;
     Uint32 R, G, B, A;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
             B = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); R = (Uint8)pixel; A = (Uint8)(pixel >> 24);
             pixel = (A << 24) | (R << 16) | (G << 8) | B;
@@ -5942,32 +5419,23 @@ static void SDL_Blit_ABGR8888_ARGB8888_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB, dstA;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel; srcA = (Uint8)(srcpixel >> 24);
             dstpixel = *dst;
@@ -6059,32 +5527,23 @@ static void SDL_Blit_ABGR8888_ARGB8888_Modulate_Scale(SDL_BlitInfo *info)
     Uint32 pixel;
     Uint32 R, G, B, A;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
             B = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); R = (Uint8)pixel; A = (Uint8)(pixel >> 24);
             if (flags & SDL_COPY_MODULATE_COLOR) {
@@ -6188,32 +5647,23 @@ static void SDL_Blit_ABGR8888_ARGB8888_Modulate_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB, dstA;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel; srcA = (Uint8)(srcpixel >> 24);
             dstpixel = *dst;
@@ -6273,32 +5723,23 @@ static void SDL_Blit_BGRA8888_RGB888_Scale(SDL_BlitInfo *info)
     Uint32 pixel;
     Uint32 R, G, B;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
             B = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); R = (Uint8)(pixel >> 8);
             pixel = (R << 16) | (G << 8) | B;
@@ -6376,32 +5817,23 @@ static void SDL_Blit_BGRA8888_RGB888_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcB = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcR = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
             dstpixel = *dst;
@@ -6486,32 +5918,23 @@ static void SDL_Blit_BGRA8888_RGB888_Modulate_Scale(SDL_BlitInfo *info)
     Uint32 pixel;
     Uint32 R, G, B;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
             B = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); R = (Uint8)(pixel >> 8);
             if (flags & SDL_COPY_MODULATE_COLOR) {
@@ -6610,32 +6033,23 @@ static void SDL_Blit_BGRA8888_RGB888_Modulate_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcB = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcR = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
             dstpixel = *dst;
@@ -6691,37 +6105,26 @@ static void SDL_Blit_BGRA8888_RGB888_Modulate_Blend_Scale(SDL_BlitInfo *info)
 static void SDL_Blit_BGRA8888_BGR888_Scale(SDL_BlitInfo *info)
 {
     Uint32 pixel;
-    Uint32 R, G, B;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
-            B = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); R = (Uint8)(pixel >> 8);
-            pixel = (B << 16) | (G << 8) | R;
+            pixel >>= 8;
             *dst = pixel;
             posx += incx;
             ++dst;
@@ -6796,32 +6199,23 @@ static void SDL_Blit_BGRA8888_BGR888_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcB = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcR = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
             dstpixel = *dst;
@@ -6906,32 +6300,23 @@ static void SDL_Blit_BGRA8888_BGR888_Modulate_Scale(SDL_BlitInfo *info)
     Uint32 pixel;
     Uint32 R, G, B;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
             B = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); R = (Uint8)(pixel >> 8);
             if (flags & SDL_COPY_MODULATE_COLOR) {
@@ -7030,32 +6415,23 @@ static void SDL_Blit_BGRA8888_BGR888_Modulate_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcB = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcR = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
             dstpixel = *dst;
@@ -7113,32 +6489,23 @@ static void SDL_Blit_BGRA8888_ARGB8888_Scale(SDL_BlitInfo *info)
     Uint32 pixel;
     Uint32 R, G, B, A;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
             B = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); R = (Uint8)(pixel >> 8); A = (Uint8)pixel;
             pixel = (A << 24) | (R << 16) | (G << 8) | B;
@@ -7218,32 +6585,23 @@ static void SDL_Blit_BGRA8888_ARGB8888_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB, dstA;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcB = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcR = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
             dstpixel = *dst;
@@ -7335,32 +6693,23 @@ static void SDL_Blit_BGRA8888_ARGB8888_Modulate_Scale(SDL_BlitInfo *info)
     Uint32 pixel;
     Uint32 R, G, B, A;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             pixel = *src;
             B = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); R = (Uint8)(pixel >> 8); A = (Uint8)pixel;
             if (flags & SDL_COPY_MODULATE_COLOR) {
@@ -7464,32 +6813,23 @@ static void SDL_Blit_BGRA8888_ARGB8888_Modulate_Blend_Scale(SDL_BlitInfo *info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB, dstA;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         Uint32 *src = 0;
         Uint32 *dst = (Uint32 *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
-            }
+            srcx = posx >> 16;
+            src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
             srcpixel = *src;
             srcB = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcR = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
             dstpixel = *dst;
diff --git a/Engine/lib/sdl/src/video/SDL_blit_auto.h b/Engine/lib/sdl/src/video/SDL_blit_auto.h
index 53deacb36..9203e4f9b 100644
--- a/Engine/lib/sdl/src/video/SDL_blit_auto.h
+++ b/Engine/lib/sdl/src/video/SDL_blit_auto.h
@@ -1,7 +1,7 @@
 /* DO NOT EDIT!  This file is generated by sdlgenblit.pl */
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/SDL_blit_copy.c b/Engine/lib/sdl/src/video/SDL_blit_copy.c
index 6dbc36fa6..0223d9a16 100644
--- a/Engine/lib/sdl/src/video/SDL_blit_copy.c
+++ b/Engine/lib/sdl/src/video/SDL_blit_copy.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -34,7 +34,7 @@ SDL_memcpySSE(Uint8 * dst, const Uint8 * src, int len)
 
     __m128 values[4];
     for (i = len / 64; i--;) {
-        _mm_prefetch(src, _MM_HINT_NTA);
+        _mm_prefetch((const char *)src, _MM_HINT_NTA);
         values[0] = *(__m128 *) (src + 0);
         values[1] = *(__m128 *) (src + 16);
         values[2] = *(__m128 *) (src + 32);
diff --git a/Engine/lib/sdl/src/video/SDL_blit_copy.h b/Engine/lib/sdl/src/video/SDL_blit_copy.h
index 16c4e8d65..24ced5241 100644
--- a/Engine/lib/sdl/src/video/SDL_blit_copy.h
+++ b/Engine/lib/sdl/src/video/SDL_blit_copy.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/SDL_blit_slow.c b/Engine/lib/sdl/src/video/SDL_blit_slow.c
index 1c0b43e2f..ed9c692b1 100644
--- a/Engine/lib/sdl/src/video/SDL_blit_slow.c
+++ b/Engine/lib/sdl/src/video/SDL_blit_slow.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -24,6 +24,21 @@
 #include "SDL_blit.h"
 #include "SDL_blit_slow.h"
 
+#define FORMAT_ALPHA      0
+#define FORMAT_NO_ALPHA  -1
+#define FORMAT_2101010    1
+#define FORMAT_HAS_ALPHA(format)        format == 0
+#define FORMAT_HAS_NO_ALPHA(format)     format < 0
+static int SDL_INLINE detect_format(SDL_PixelFormat *pf) {
+    if (pf->format == SDL_PIXELFORMAT_ARGB2101010) {
+        return FORMAT_2101010;
+    } else if (pf->Amask) {
+        return FORMAT_ALPHA;
+    } else {
+        return FORMAT_NO_ALPHA;
+    }
+}
+
 /* The ONE TRUE BLITTER
  * This puppy has to handle all the unoptimized cases - yes, it's slow.
  */
@@ -40,47 +55,45 @@ SDL_Blit_Slow(SDL_BlitInfo * info)
     Uint32 dstpixel;
     Uint32 dstR, dstG, dstB, dstA;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
     SDL_PixelFormat *src_fmt = info->src_fmt;
     SDL_PixelFormat *dst_fmt = info->dst_fmt;
     int srcbpp = src_fmt->BytesPerPixel;
     int dstbpp = dst_fmt->BytesPerPixel;
+    int srcfmt_val;
+    int dstfmt_val;
     Uint32 rgbmask = ~src_fmt->Amask;
     Uint32 ckey = info->colorkey & rgbmask;
 
-    srcy = 0;
-    posy = 0;
+    srcfmt_val = detect_format(src_fmt);
+    dstfmt_val = detect_format(dst_fmt);
+
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2; /* start at the middle of pixel */
 
     while (info->dst_h--) {
         Uint8 *src = 0;
         Uint8 *dst = info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2; /* start at the middle of pixel */
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src =
-                    (info->src + (srcy * info->src_pitch) + (srcx * srcbpp));
-            }
-            if (src_fmt->Amask) {
-                DISEMBLE_RGBA(src, srcbpp, src_fmt, srcpixel, srcR, srcG,
-                              srcB, srcA);
-            } else {
-                DISEMBLE_RGB(src, srcbpp, src_fmt, srcpixel, srcR, srcG,
-                             srcB);
+            srcx = posx >> 16;
+            src = (info->src + (srcy * info->src_pitch) + (srcx * srcbpp));
+
+            if (FORMAT_HAS_ALPHA(srcfmt_val)) {
+                DISEMBLE_RGBA(src, srcbpp, src_fmt, srcpixel, srcR, srcG, srcB, srcA);
+            } else if (FORMAT_HAS_NO_ALPHA(srcfmt_val)) {
+                DISEMBLE_RGB(src, srcbpp, src_fmt, srcpixel, srcR, srcG, srcB);
                 srcA = 0xFF;
+            } else {
+                /* SDL_PIXELFORMAT_ARGB2101010 */
+                srcpixel = *((Uint32 *)(src));
+                RGBA_FROM_ARGB2101010(srcpixel, srcR, srcG, srcB, srcA);
             }
+
             if (flags & SDL_COPY_COLORKEY) {
                 /* srcpixel isn't set for 24 bpp */
                 if (srcbpp == 3) {
@@ -93,13 +106,15 @@ SDL_Blit_Slow(SDL_BlitInfo * info)
                     continue;
                 }
             }
-            if (dst_fmt->Amask) {
-                DISEMBLE_RGBA(dst, dstbpp, dst_fmt, dstpixel, dstR, dstG,
-                              dstB, dstA);
-            } else {
-                DISEMBLE_RGB(dst, dstbpp, dst_fmt, dstpixel, dstR, dstG,
-                             dstB);
+            if (FORMAT_HAS_ALPHA(dstfmt_val)) {
+                DISEMBLE_RGBA(dst, dstbpp, dst_fmt, dstpixel, dstR, dstG, dstB, dstA);
+            } else if (FORMAT_HAS_NO_ALPHA(dstfmt_val)) {
+                DISEMBLE_RGB(dst, dstbpp, dst_fmt, dstpixel, dstR, dstG, dstB);
                 dstA = 0xFF;
+            } else {
+                /* SDL_PIXELFORMAT_ARGB2101010 */
+                dstpixel = *((Uint32 *)(dst));
+                RGBA_FROM_ARGB2101010(dstpixel, dstR, dstG, dstB, dstA);
             }
 
             if (flags & SDL_COPY_MODULATE_COLOR) {
@@ -162,10 +177,15 @@ SDL_Blit_Slow(SDL_BlitInfo * info)
                     dstA = 255;
                 break;
             }
-            if (dst_fmt->Amask) {
+            if (FORMAT_HAS_ALPHA(dstfmt_val)) {
                 ASSEMBLE_RGBA(dst, dstbpp, dst_fmt, dstR, dstG, dstB, dstA);
-            } else {
+            } else if (FORMAT_HAS_NO_ALPHA(dstfmt_val)) {
                 ASSEMBLE_RGB(dst, dstbpp, dst_fmt, dstR, dstG, dstB);
+            } else {
+                /* SDL_PIXELFORMAT_ARGB2101010 */
+                Uint32 pixel;
+                ARGB2101010_FROM_RGBA(pixel, dstR, dstG, dstB, dstA);
+                *(Uint32 *)dst = pixel;
             }
             posx += incx;
             dst += dstbpp;
diff --git a/Engine/lib/sdl/src/video/SDL_blit_slow.h b/Engine/lib/sdl/src/video/SDL_blit_slow.h
index 082654ef5..cb5388a3e 100644
--- a/Engine/lib/sdl/src/video/SDL_blit_slow.h
+++ b/Engine/lib/sdl/src/video/SDL_blit_slow.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/SDL_bmp.c b/Engine/lib/sdl/src/video/SDL_bmp.c
index cd7962809..0987f5435 100644
--- a/Engine/lib/sdl/src/video/SDL_bmp.c
+++ b/Engine/lib/sdl/src/video/SDL_bmp.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -53,7 +53,7 @@
 #define LCS_WINDOWS_COLOR_SPACE    0x57696E20
 #endif
 
-static int readRlePixels(SDL_Surface * surface, SDL_RWops * src, int isRle8)
+static SDL_bool readRlePixels(SDL_Surface * surface, SDL_RWops * src, int isRle8)
 {
     /*
     | Sets the surface pixels from src.  A bmp image is upside down.
@@ -70,14 +70,14 @@ static int readRlePixels(SDL_Surface * surface, SDL_RWops * src, int isRle8)
 #define COPY_PIXEL(x)   spot = &bits[ofs++]; if(spot >= start && spot < end) *spot = (x)
 
     for (;;) {
-        if (!SDL_RWread(src, &ch, 1, 1)) return 1;
+        if (!SDL_RWread(src, &ch, 1, 1)) return SDL_TRUE;
         /*
         | encoded mode starts with a run length, and then a byte
         | with two colour indexes to alternate between for the run
         */
         if (ch) {
             Uint8 pixel;
-            if (!SDL_RWread(src, &pixel, 1, 1)) return 1;
+            if (!SDL_RWread(src, &pixel, 1, 1)) return SDL_TRUE;
             if (isRle8) {                   /* 256-color bitmap, compressed */
                 do {
                     COPY_PIXEL(pixel);
@@ -98,18 +98,18 @@ static int readRlePixels(SDL_Surface * surface, SDL_RWops * src, int isRle8)
             | a cursor move, or some absolute data.
             | zero tag may be absolute mode or an escape
             */
-            if (!SDL_RWread(src, &ch, 1, 1)) return 1;
+            if (!SDL_RWread(src, &ch, 1, 1)) return SDL_TRUE;
             switch (ch) {
             case 0:                         /* end of line */
                 ofs = 0;
                 bits -= pitch;               /* go to previous */
                 break;
             case 1:                         /* end of bitmap */
-                return 0;                    /* success! */
+                return SDL_FALSE;           /* success! */
             case 2:                         /* delta */
-                if (!SDL_RWread(src, &ch, 1, 1)) return 1;
+                if (!SDL_RWread(src, &ch, 1, 1)) return SDL_TRUE;
                 ofs += ch;
-                if (!SDL_RWread(src, &ch, 1, 1)) return 1;
+                if (!SDL_RWread(src, &ch, 1, 1)) return SDL_TRUE;
                 bits -= (ch * pitch);
                 break;
             default:                        /* no compression */
@@ -117,14 +117,14 @@ static int readRlePixels(SDL_Surface * surface, SDL_RWops * src, int isRle8)
                     needsPad = (ch & 1);
                     do {
                         Uint8 pixel;
-                        if (!SDL_RWread(src, &pixel, 1, 1)) return 1;
+                        if (!SDL_RWread(src, &pixel, 1, 1)) return SDL_TRUE;
                         COPY_PIXEL(pixel);
                     } while (--ch);
                 } else {
                     needsPad = (((ch+1)>>1) & 1); /* (ch+1)>>1: bytes size */
                     for (;;) {
                         Uint8 pixel;
-                        if (!SDL_RWread(src, &pixel, 1, 1)) return 1;
+                        if (!SDL_RWread(src, &pixel, 1, 1)) return SDL_TRUE;
                         COPY_PIXEL(pixel >> 4);
                         if (!--ch) break;
                         COPY_PIXEL(pixel & 0x0F);
@@ -132,7 +132,7 @@ static int readRlePixels(SDL_Surface * surface, SDL_RWops * src, int isRle8)
                     }
                 }
                 /* pad at even boundary */
-                if (needsPad && !SDL_RWread(src, &ch, 1, 1)) return 1;
+                if (needsPad && !SDL_RWread(src, &ch, 1, 1)) return SDL_TRUE;
                 break;
             }
         }
@@ -213,12 +213,17 @@ SDL_LoadBMP_RW(SDL_RWops * src, int freesrc)
     surface = NULL;
     was_error = SDL_FALSE;
     if (src == NULL) {
+        SDL_InvalidParamError("src");
         was_error = SDL_TRUE;
         goto done;
     }
 
     /* Read in the BMP file header */
     fp_offset = SDL_RWtell(src);
+    if (fp_offset < 0) {
+        was_error = SDL_TRUE;
+        goto done;
+    }
     SDL_ClearError();
     if (SDL_RWread(src, magic, 1, 2) != 2) {
         SDL_Error(SDL_EFREAD);
@@ -306,7 +311,7 @@ SDL_LoadBMP_RW(SDL_RWops * src, int freesrc)
         }
     }
     if (biWidth <= 0 || biHeight == 0) {
-        SDL_SetError("BMP file with bad dimensions (%dx%d)", biWidth, biHeight);
+        SDL_SetError("BMP file with bad dimensions (%" SDL_PRIs32 "x%" SDL_PRIs32 ")", biWidth, biHeight);
         was_error = SDL_TRUE;
         goto done;
     }
@@ -407,14 +412,20 @@ SDL_LoadBMP_RW(SDL_RWops * src, int freesrc)
             goto done;
         }
 
-        /*
-        | guich: always use 1<<bpp b/c some bitmaps can bring wrong information
-        | for colorsUsed
-        */
-        /* if (biClrUsed == 0) {  */
-        biClrUsed = 1 << biBitCount;
-        /* } */
-        if (biSize == 12) {
+        if (biClrUsed == 0) {
+            biClrUsed = 1 << biBitCount;
+        }
+
+        if (biClrUsed > (Uint32)palette->ncolors) {
+            biClrUsed = 1 << biBitCount;  /* try forcing it? */
+            if (biClrUsed > (Uint32)palette->ncolors) {
+                SDL_SetError("Unsupported or incorrect biClrUsed field");
+                was_error = SDL_TRUE;
+                goto done;
+            }
+        }
+
+       if (biSize == 12) {
             for (i = 0; i < (int) biClrUsed; ++i) {
                 SDL_RWread(src, &palette->colors[i].b, 1, 1);
                 SDL_RWread(src, &palette->colors[i].g, 1, 1);
@@ -445,8 +456,8 @@ SDL_LoadBMP_RW(SDL_RWops * src, int freesrc)
         goto done;
     }
     if ((biCompression == BI_RLE4) || (biCompression == BI_RLE8)) {
-        was_error = (SDL_bool)readRlePixels(surface, src, biCompression == BI_RLE8);
-        if (was_error) SDL_SetError("Error reading from BMP");
+        was_error = readRlePixels(surface, src, biCompression == BI_RLE8);
+        if (was_error) SDL_Error(SDL_EFREAD);
         goto done;
     }
     top = (Uint8 *)surface->pixels;
@@ -478,7 +489,7 @@ SDL_LoadBMP_RW(SDL_RWops * src, int freesrc)
                 for (i = 0; i < surface->w; ++i) {
                     if (i % (8 / ExpandBMP) == 0) {
                         if (!SDL_RWread(src, &pixel, 1, 1)) {
-                            SDL_SetError("Error reading from BMP");
+                            SDL_Error(SDL_EFREAD);
                             was_error = SDL_TRUE;
                             goto done;
                         }
diff --git a/Engine/lib/sdl/src/video/SDL_clipboard.c b/Engine/lib/sdl/src/video/SDL_clipboard.c
index f7ad9c341..c3669af6e 100644
--- a/Engine/lib/sdl/src/video/SDL_clipboard.c
+++ b/Engine/lib/sdl/src/video/SDL_clipboard.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/SDL_egl.c b/Engine/lib/sdl/src/video/SDL_egl.c
index 5ea732fbe..c9fb476b0 100644
--- a/Engine/lib/sdl/src/video/SDL_egl.c
+++ b/Engine/lib/sdl/src/video/SDL_egl.c
@@ -1,6 +1,6 @@
 /*
  *  Simple DirectMedia Layer
- *  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+ *  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
  * 
  *  This software is provided 'as-is', without any express or implied
  *  warranty.  In no event will the authors be held liable for any damages
@@ -28,6 +28,10 @@
 #if SDL_VIDEO_DRIVER_ANDROID
 #include <android/native_window.h>
 #include "../core/android/SDL_android.h"
+#include "../video/android/SDL_androidvideo.h"
+#endif
+#if SDL_VIDEO_DRIVER_RPI
+#include <unistd.h>
 #endif
 
 #include "SDL_sysvideo.h"
@@ -42,6 +46,11 @@
 #endif
 #endif /* EGL_KHR_create_context */
 
+#ifndef EGL_EXT_present_opaque
+#define EGL_EXT_present_opaque 1
+#define EGL_PRESENT_OPAQUE_EXT            0x31DF
+#endif /* EGL_EXT_present_opaque */
+
 #if SDL_VIDEO_DRIVER_RPI
 /* Raspbian places the OpenGL ES/EGL binaries in a non standard path */
 #define DEFAULT_EGL ( vc4 ? "libEGL.so.1" : "libbrcmEGL.so" )
@@ -73,6 +82,7 @@
 #define DEFAULT_OGL_ES "libGLESv1_CM.dylib"     //???
 
 #elif defined(__OpenBSD__)
+/* OpenBSD */
 #define DEFAULT_OGL "libGL.so"
 #define DEFAULT_EGL "libEGL.so"
 #define DEFAULT_OGL_ES2 "libGLESv2.so"
@@ -80,9 +90,10 @@
 #define DEFAULT_OGL_ES "libGLESv1_CM.so"
 
 #else
-/* Desktop Linux */
+/* Desktop Linux/Unix-like */
 #define DEFAULT_OGL "libGL.so.1"
 #define DEFAULT_EGL "libEGL.so.1"
+#define ALT_OGL "libOpenGL.so.0"
 #define DEFAULT_OGL_ES2 "libGLESv2.so.2"
 #define DEFAULT_OGL_ES_PVR "libGLES_CM.so.1"
 #define DEFAULT_OGL_ES "libGLESv1_CM.so.1"
@@ -99,7 +110,7 @@
 #define EGL_PLATFORM_DEVICE_EXT 0x0
 #endif
 
-#ifdef SDL_VIDEO_STATIC_ANGLE
+#if defined(SDL_VIDEO_STATIC_ANGLE) || defined(SDL_VIDEO_DRIVER_VITA)
 #define LOAD_FUNC(NAME) \
 _this->egl_data->NAME = (void *)NAME;
 #else
@@ -115,7 +126,6 @@ if (!_this->egl_data->NAME) \
 #define LOAD_FUNC_EGLEXT(NAME) \
     _this->egl_data->NAME = _this->egl_data->eglGetProcAddress(#NAME);
 
-
 static const char * SDL_EGL_GetErrorName(EGLint eglErrorCode)
 {
 #define SDL_EGL_ERROR_TRANSLATE(e) case e: return #e;
@@ -237,7 +247,7 @@ SDL_EGL_GetProcAddress(_THIS, const char *proc)
         retval = _this->egl_data->eglGetProcAddress(proc);
     }
 
-    #ifndef __EMSCRIPTEN__  /* LoadFunction isn't needed on Emscripten and will call dlsym(), causing other problems. */
+    #if !defined(__EMSCRIPTEN__) && !defined(SDL_VIDEO_DRIVER_VITA)  /* LoadFunction isn't needed on Emscripten and will call dlsym(), causing other problems. */
     /* Try SDL_LoadFunction() first for EGL <= 1.4, or as a fallback for >= 1.5. */
     if (!retval) {
         static char procname[64];
@@ -336,7 +346,7 @@ SDL_EGL_LoadLibraryOnly(_THIS, const char *egl_path)
     }
 #endif
 
-#ifndef SDL_VIDEO_STATIC_ANGLE
+#if !defined(SDL_VIDEO_STATIC_ANGLE) && !defined(SDL_VIDEO_DRIVER_VITA)
     /* A funny thing, loading EGL.so first does not work on the Raspberry, so we load libGL* first */
     path = SDL_getenv("SDL_VIDEO_GL_DRIVER");
     if (path != NULL) {
@@ -374,6 +384,12 @@ SDL_EGL_LoadLibraryOnly(_THIS, const char *egl_path)
         else {
             path = DEFAULT_OGL;
             egl_dll_handle = SDL_LoadObject(path);
+#ifdef ALT_OGL
+            if (egl_dll_handle == NULL) {
+                path = ALT_OGL;
+                egl_dll_handle = SDL_LoadObject(path);
+            }
+#endif
         }
 #endif        
     }
@@ -416,6 +432,9 @@ SDL_EGL_LoadLibraryOnly(_THIS, const char *egl_path)
 #endif
 
     _this->egl_data->dll_handle = dll_handle;
+#if SDL_VIDEO_DRIVER_VITA
+    _this->egl_data->egl_dll_handle = egl_dll_handle;
+#endif
 
     /* Load new function pointers */
     LOAD_FUNC(eglGetDisplay);
@@ -476,36 +495,40 @@ SDL_EGL_GetVersion(_THIS) {
 int
 SDL_EGL_LoadLibrary(_THIS, const char *egl_path, NativeDisplayType native_display, EGLenum platform)
 {
-    int egl_version_major, egl_version_minor;
     int library_load_retcode = SDL_EGL_LoadLibraryOnly(_this, egl_path);
     if (library_load_retcode != 0) {
         return library_load_retcode;
     }
 
-    /* EGL 1.5 allows querying for client version with EGL_NO_DISPLAY */
-    SDL_EGL_GetVersion(_this);
-
-    egl_version_major = _this->egl_data->egl_version_major;
-    egl_version_minor = _this->egl_data->egl_version_minor;
-
-    if (egl_version_major == 1 && egl_version_minor == 5) {
-        LOAD_FUNC(eglGetPlatformDisplay);
-    }
-
     _this->egl_data->egl_display = EGL_NO_DISPLAY;
+
 #if !defined(__WINRT__)
+#if !defined(SDL_VIDEO_DRIVER_VITA)
     if (platform) {
-        if (egl_version_major == 1 && egl_version_minor == 5) {
-            _this->egl_data->egl_display = _this->egl_data->eglGetPlatformDisplay(platform, (void *)(size_t)native_display, NULL);
+        /* EGL 1.5 allows querying for client version with EGL_NO_DISPLAY
+         * --
+         * Khronos doc: "EGL_BAD_DISPLAY is generated if display is not an EGL display connection, unless display is EGL_NO_DISPLAY and name is EGL_EXTENSIONS."
+         * Therefore SDL_EGL_GetVersion() shouldn't work with uninitialized display.
+         * - it actually doesn't work on Android that has 1.5 egl client
+         * - it works on desktop X11 (using SDL_VIDEO_X11_FORCE_EGL=1) */
+        SDL_EGL_GetVersion(_this);
+
+        if (_this->egl_data->egl_version_major == 1 && _this->egl_data->egl_version_minor == 5) {
+            LOAD_FUNC(eglGetPlatformDisplay);
+        }
+
+        if (_this->egl_data->eglGetPlatformDisplay) {
+            _this->egl_data->egl_display = _this->egl_data->eglGetPlatformDisplay(platform, (void *)(uintptr_t)native_display, NULL);
         } else {
             if (SDL_EGL_HasExtension(_this, SDL_EGL_CLIENT_EXTENSION, "EGL_EXT_platform_base")) {
                 _this->egl_data->eglGetPlatformDisplayEXT = SDL_EGL_GetProcAddress(_this, "eglGetPlatformDisplayEXT");
                 if (_this->egl_data->eglGetPlatformDisplayEXT) {
-                    _this->egl_data->egl_display = _this->egl_data->eglGetPlatformDisplayEXT(platform, (void *)(size_t)native_display, NULL);
+                    _this->egl_data->egl_display = _this->egl_data->eglGetPlatformDisplayEXT(platform, (void *)(uintptr_t)native_display, NULL);
                 }
             }
         }
     }
+#endif
     /* Try the implementation-specific eglGetDisplay even if eglGetPlatformDisplay fails */
     if (_this->egl_data->egl_display == EGL_NO_DISPLAY) {
         _this->egl_data->egl_display = _this->egl_data->eglGetDisplay(native_display);
@@ -515,7 +538,7 @@ SDL_EGL_LoadLibrary(_THIS, const char *egl_path, NativeDisplayType native_displa
         *_this->gl_config.driver_path = '\0';
         return SDL_SetError("Could not get EGL display");
     }
-    
+
     if (_this->egl_data->eglInitialize(_this->egl_data->egl_display, NULL, NULL) != EGL_TRUE) {
         _this->gl_config.driver_loaded = 0;
         *_this->gl_config.driver_path = '\0';
@@ -526,7 +549,7 @@ SDL_EGL_LoadLibrary(_THIS, const char *egl_path, NativeDisplayType native_displa
     /* Get the EGL version with a valid egl_display, for EGL <= 1.4 */
     SDL_EGL_GetVersion(_this);
 
-    _this->egl_data->is_offscreen = 0;
+    _this->egl_data->is_offscreen = SDL_FALSE;
 
     return 0;
 }
@@ -546,7 +569,7 @@ SDL_EGL_InitializeOffscreen(_THIS, int device)
     EGLint num_egl_devices = 0;
     const char *egl_device_hint;
 
-    if (_this->gl_config.driver_loaded != 1) {
+    if (_this->gl_config.driver_loaded <= 0) {
         return SDL_SetError("SDL_EGL_LoadLibraryOnly() has not been called or has failed.");
     }
 
@@ -614,7 +637,7 @@ SDL_EGL_InitializeOffscreen(_THIS, int device)
     /* Get the EGL version with a valid egl_display, for EGL <= 1.4 */
     SDL_EGL_GetVersion(_this);
 
-    _this->egl_data->is_offscreen = 1;
+    _this->egl_data->is_offscreen = SDL_TRUE;
 
     return 0;
 }
@@ -634,7 +657,8 @@ typedef struct {
     char const* name;
 } Attribute;
 
-Attribute attributes[] = {
+static
+Attribute all_attributes[] = {
         ATTRIBUTE( EGL_BUFFER_SIZE ),
         ATTRIBUTE( EGL_ALPHA_SIZE ),
         ATTRIBUTE( EGL_BLUE_SIZE ),
@@ -674,31 +698,27 @@ Attribute attributes[] = {
 static void dumpconfig(_THIS, EGLConfig config)
 {
     int attr;
-    for (attr = 0 ; attr<sizeof(attributes)/sizeof(Attribute) ; attr++) {
+    for (attr = 0 ; attr<sizeof(all_attributes)/sizeof(Attribute) ; attr++) {
         EGLint value;
-        _this->egl_data->eglGetConfigAttrib(_this->egl_data->egl_display, config, attributes[attr].attribute, &value);
-        SDL_Log("\t%-32s: %10d (0x%08x)\n", attributes[attr].name, value, value);
+        _this->egl_data->eglGetConfigAttrib(_this->egl_data->egl_display, config, all_attributes[attr].attribute, &value);
+        SDL_Log("\t%-32s: %10d (0x%08x)\n", all_attributes[attr].name, value, value);
     }
 }
 
 #endif /* DUMP_EGL_CONFIG */
 
-int
-SDL_EGL_ChooseConfig(_THIS) 
+static int
+SDL_EGL_PrivateChooseConfig(_THIS, SDL_bool set_config_caveat_none)
 {
-/* 64 seems nice. */
+    /* 64 seems nice. */
     EGLint attribs[64];
     EGLint found_configs = 0, value;
     /* 128 seems even nicer here */
     EGLConfig configs[128];
     SDL_bool has_matching_format = SDL_FALSE;
-    int i, j, best_bitdiff = -1, bitdiff;
-   
-    if (!_this->egl_data) {
-        /* The EGL library wasn't loaded, SDL_GetError() should have info */
-        return -1;
-    }
-  
+    int i, j, best_bitdiff = -1, best_truecolor_bitdiff = -1;
+    int truecolor_config_idx = -1;
+
     /* Get a valid EGL configuration */
     i = 0;
     attribs[i++] = EGL_RED_SIZE;
@@ -707,30 +727,37 @@ SDL_EGL_ChooseConfig(_THIS)
     attribs[i++] = _this->gl_config.green_size;
     attribs[i++] = EGL_BLUE_SIZE;
     attribs[i++] = _this->gl_config.blue_size;
-    
+
+    if (set_config_caveat_none) {
+        attribs[i++] = EGL_CONFIG_CAVEAT;
+        attribs[i++] = EGL_NONE;
+    }
+
     if (_this->gl_config.alpha_size) {
         attribs[i++] = EGL_ALPHA_SIZE;
         attribs[i++] = _this->gl_config.alpha_size;
     }
-    
+
     if (_this->gl_config.buffer_size) {
         attribs[i++] = EGL_BUFFER_SIZE;
         attribs[i++] = _this->gl_config.buffer_size;
     }
-    
-    attribs[i++] = EGL_DEPTH_SIZE;
-    attribs[i++] = _this->gl_config.depth_size;
-    
+
+    if (_this->gl_config.depth_size) {
+        attribs[i++] = EGL_DEPTH_SIZE;
+        attribs[i++] = _this->gl_config.depth_size;
+    }
+
     if (_this->gl_config.stencil_size) {
         attribs[i++] = EGL_STENCIL_SIZE;
         attribs[i++] = _this->gl_config.stencil_size;
     }
-    
+
     if (_this->gl_config.multisamplebuffers) {
         attribs[i++] = EGL_SAMPLE_BUFFERS;
         attribs[i++] = _this->gl_config.multisamplebuffers;
     }
-    
+
     if (_this->gl_config.multisamplesamples) {
         attribs[i++] = EGL_SAMPLES;
         attribs[i++] = _this->gl_config.multisamplesamples;
@@ -767,24 +794,28 @@ SDL_EGL_ChooseConfig(_THIS)
 
     attribs[i++] = EGL_NONE;
 
+    SDL_assert(i < SDL_arraysize(attribs));
+
     if (_this->egl_data->eglChooseConfig(_this->egl_data->egl_display,
         attribs,
         configs, SDL_arraysize(configs),
         &found_configs) == EGL_FALSE ||
         found_configs == 0) {
-        return SDL_EGL_SetError("Couldn't find matching EGL config", "eglChooseConfig");
+        return -1;
     }
 
     /* first ensure that a found config has a matching format, or the function will fall through. */
-    for (i = 0; i < found_configs; i++ ) {
-        if (_this->egl_data->egl_required_visual_id)
-        {
+    if (_this->egl_data->egl_required_visual_id)
+    {
+        for (i = 0; i < found_configs; i++ ) {
             EGLint format;
             _this->egl_data->eglGetConfigAttrib(_this->egl_data->egl_display,
                                             configs[i],
                                             EGL_NATIVE_VISUAL_ID, &format);
-            if (_this->egl_data->egl_required_visual_id == format)
+            if (_this->egl_data->egl_required_visual_id == format) {
                 has_matching_format = SDL_TRUE;
+                break;
+            }
         }
     }
 
@@ -792,22 +823,35 @@ SDL_EGL_ChooseConfig(_THIS)
     /* From those, we select the one that matches our requirements more closely via a makeshift algorithm */
 
     for (i = 0; i < found_configs; i++ ) {
-        if (has_matching_format && _this->egl_data->egl_required_visual_id)
-        {
+        SDL_bool is_truecolor = SDL_FALSE;
+        int bitdiff = 0;
+
+        if (has_matching_format && _this->egl_data->egl_required_visual_id) {
             EGLint format;
             _this->egl_data->eglGetConfigAttrib(_this->egl_data->egl_display,
-                                            configs[i], 
+                                            configs[i],
                                             EGL_NATIVE_VISUAL_ID, &format);
-            if (_this->egl_data->egl_required_visual_id != format)
+            if (_this->egl_data->egl_required_visual_id != format) {
                 continue;
+            }
+        }
+
+        _this->egl_data->eglGetConfigAttrib(_this->egl_data->egl_display, configs[i], EGL_RED_SIZE, &value);
+        if (value == 8) {
+            _this->egl_data->eglGetConfigAttrib(_this->egl_data->egl_display, configs[i], EGL_GREEN_SIZE, &value);
+            if (value == 8) {
+                _this->egl_data->eglGetConfigAttrib(_this->egl_data->egl_display, configs[i], EGL_BLUE_SIZE, &value);
+                if (value == 8) {
+                    is_truecolor = SDL_TRUE;
+                }
+            }
         }
 
-        bitdiff = 0;
         for (j = 0; j < SDL_arraysize(attribs) - 1; j += 2) {
             if (attribs[j] == EGL_NONE) {
                break;
             }
-            
+
             if ( attribs[j+1] != EGL_DONT_CARE && (
                 attribs[j] == EGL_RED_SIZE ||
                 attribs[j] == EGL_GREEN_SIZE ||
@@ -820,24 +864,70 @@ SDL_EGL_ChooseConfig(_THIS)
             }
         }
 
-        if (bitdiff < best_bitdiff || best_bitdiff == -1) {
+        if ((bitdiff < best_bitdiff) || (best_bitdiff == -1)) {
             _this->egl_data->egl_config = configs[i];
-            
             best_bitdiff = bitdiff;
         }
 
-        if (bitdiff == 0) {
-            break; /* we found an exact match! */
+        if (is_truecolor && ((bitdiff < best_truecolor_bitdiff) || (best_truecolor_bitdiff == -1))) {
+            truecolor_config_idx = i;
+            best_truecolor_bitdiff = bitdiff;
         }
     }
 
+    #define FAVOR_TRUECOLOR 1
+    #if FAVOR_TRUECOLOR
+    /* Some apps request a low color depth, either because they _assume_
+       they'll get a larger one but don't want to fail if only smaller ones
+       are available, or they just never called SDL_GL_SetAttribute at all and
+       got a tiny default. For these cases, a game that would otherwise run
+       at 24-bit color might get dithered down to something smaller, which is
+       worth avoiding. If the app requested <= 16 bit color and an exact 24-bit
+       match is available, favor that. Otherwise, we look for the closest
+       match. Note that while the API promises what you request _or better_,
+       it's feasible this can be disastrous for performance for custom software
+       on small hardware that all expected to actually get 16-bit color. In this
+       case, turn off FAVOR_TRUECOLOR (and maybe send a patch to make this more
+       flexible). */
+    if ( ((_this->gl_config.red_size + _this->gl_config.blue_size + _this->gl_config.green_size) <= 16) ) {
+        if (truecolor_config_idx != -1) {
+            _this->egl_data->egl_config = configs[truecolor_config_idx];
+        }
+    }
+    #endif
+
 #ifdef DUMP_EGL_CONFIG
     dumpconfig(_this, _this->egl_data->egl_config);
 #endif
-    
+
     return 0;
 }
 
+int
+SDL_EGL_ChooseConfig(_THIS)
+{
+    int ret;
+
+    if (!_this->egl_data) {
+        return SDL_SetError("EGL not initialized");
+    }
+
+    /* Try with EGL_CONFIG_CAVEAT set to EGL_NONE, to avoid any EGL_SLOW_CONFIG or EGL_NON_CONFORMANT_CONFIG */
+    ret = SDL_EGL_PrivateChooseConfig(_this, SDL_TRUE);
+    if (ret == 0) {
+        return 0;
+    }
+
+    /* Fallback with all configs */
+    ret = SDL_EGL_PrivateChooseConfig(_this, SDL_FALSE);
+    if (ret == 0) {
+        SDL_Log("SDL_EGL_ChooseConfig: found a slow EGL config");
+        return 0;
+    }
+
+    return SDL_EGL_SetError("Couldn't find matching EGL config", "eglChooseConfig");
+}
+
 SDL_GLContext
 SDL_EGL_CreateContext(_THIS, EGLSurface egl_surface)
 {
@@ -852,7 +942,7 @@ SDL_EGL_CreateContext(_THIS, EGLSurface egl_surface)
     SDL_bool profile_es = (profile_mask == SDL_GL_CONTEXT_PROFILE_ES);
 
     if (!_this->egl_data) {
-        /* The EGL library wasn't loaded, SDL_GetError() should have info */
+        SDL_SetError("EGL not initialized");
         return NULL;
     }
 
@@ -922,27 +1012,24 @@ SDL_EGL_CreateContext(_THIS, EGLSurface egl_surface)
         }
     }
 
-    if (_this->gl_config.no_error) {
 #ifdef EGL_KHR_create_context_no_error
+    if (_this->gl_config.no_error) {
         if (SDL_EGL_HasExtension(_this, SDL_EGL_DISPLAY_EXTENSION, "EGL_KHR_create_context_no_error")) {
             attribs[attr++] = EGL_CONTEXT_OPENGL_NO_ERROR_KHR;
             attribs[attr++] = _this->gl_config.no_error;
-        } else
-#endif
-        {
-            SDL_SetError("EGL implementation does not support no_error contexts");
-            return NULL;
         }
     }
+#endif
 
     attribs[attr++] = EGL_NONE;
 
     /* Bind the API */
     if (profile_es) {
-        _this->egl_data->eglBindAPI(EGL_OPENGL_ES_API);
+        _this->egl_data->apitype = EGL_OPENGL_ES_API;
     } else {
-        _this->egl_data->eglBindAPI(EGL_OPENGL_API);
+        _this->egl_data->apitype = EGL_OPENGL_API;
     }
+    _this->egl_data->eglBindAPI(_this->egl_data->apitype);
 
     egl_context = _this->egl_data->eglCreateContext(_this->egl_data->egl_display,
                                       _this->egl_data->egl_config,
@@ -956,16 +1043,8 @@ SDL_EGL_CreateContext(_THIS, EGLSurface egl_surface)
     _this->egl_data->egl_swapinterval = 0;
 
     if (SDL_EGL_MakeCurrent(_this, egl_surface, egl_context) < 0) {
-        /* Save the SDL error set by SDL_EGL_MakeCurrent */
-        char errorText[1024];
-        SDL_strlcpy(errorText, SDL_GetError(), SDL_arraysize(errorText));
-
-        /* Delete the context, which may alter the value returned by SDL_GetError() */
+        /* Delete the context */
         SDL_EGL_DeleteContext(_this, egl_context);
-
-        /* Restore the SDL error */
-        SDL_SetError("%s", errorText);
-
         return NULL;
     }
 
@@ -1008,9 +1087,23 @@ SDL_EGL_MakeCurrent(_THIS, EGLSurface egl_surface, SDL_GLContext context)
     EGLContext egl_context = (EGLContext) context;
 
     if (!_this->egl_data) {
-        return SDL_SetError("OpenGL not initialized");
+        return SDL_SetError("EGL not initialized");
     }
-    
+
+    if (!_this->egl_data->eglMakeCurrent) {
+        if (!egl_surface && !context) {
+            /* Can't do the nothing there is to do? Probably trying to cleanup a failed startup, just return. */
+            return 0;
+        } else {
+            return SDL_SetError("EGL not initialized");  /* something clearly went wrong somewhere. */
+        }
+    }
+
+    /* Make sure current thread has a valid API bound to it. */
+    if (_this->egl_data->eglBindAPI) {
+        _this->egl_data->eglBindAPI(_this->egl_data->apitype);
+    }
+
     /* The android emulator crashes badly if you try to eglMakeCurrent 
      * with a valid context and invalid surface, so we have to check for both here.
      */
@@ -1022,7 +1115,7 @@ SDL_EGL_MakeCurrent(_THIS, EGLSurface egl_surface, SDL_GLContext context)
             return SDL_EGL_SetError("Unable to make EGL context current", "eglMakeCurrent");
         }
     }
-      
+
     return 0;
 }
 
@@ -1034,6 +1127,13 @@ SDL_EGL_SetSwapInterval(_THIS, int interval)
     if (!_this->egl_data) {
         return SDL_SetError("EGL not initialized");
     }
+
+    /* FIXME: Revisit this check when EGL_EXT_swap_control_tear is published:
+     * https://github.com/KhronosGroup/EGL-Registry/pull/113
+     */
+    if (interval < 0) {
+        return SDL_SetError("Late swap tearing currently unsupported");
+    }
     
     status = _this->egl_data->eglSwapInterval(_this->egl_data->egl_display, interval);
     if (status == EGL_TRUE) {
@@ -1083,8 +1183,12 @@ SDL_EGL_DeleteContext(_THIS, SDL_GLContext context)
 EGLSurface *
 SDL_EGL_CreateSurface(_THIS, NativeWindowType nw) 
 {
-    /* max 2 values plus terminator. */
-    EGLint attribs[3];
+#if SDL_VIDEO_DRIVER_ANDROID
+    EGLint format_wanted;
+    EGLint format_got;
+#endif
+    /* max 2 key+value pairs, plus terminator. */
+    EGLint attribs[5];
     int attr = 0;
 
     EGLSurface * surface;
@@ -1092,24 +1196,18 @@ SDL_EGL_CreateSurface(_THIS, NativeWindowType nw)
     if (SDL_EGL_ChooseConfig(_this) != 0) {
         return EGL_NO_SURFACE;
     }
-    
+
 #if SDL_VIDEO_DRIVER_ANDROID
-    {
-        /* Android docs recommend doing this!
-         * Ref: http://developer.android.com/reference/android/app/NativeActivity.html 
-         */
-        EGLint format;
-        _this->egl_data->eglGetConfigAttrib(_this->egl_data->egl_display,
-                                            _this->egl_data->egl_config, 
-                                            EGL_NATIVE_VISUAL_ID, &format);
+    /* On Android, EGL_NATIVE_VISUAL_ID is an attribute of the EGLConfig that is
+     * guaranteed to be accepted by ANativeWindow_setBuffersGeometry(). */
+    _this->egl_data->eglGetConfigAttrib(_this->egl_data->egl_display,
+            _this->egl_data->egl_config,
+            EGL_NATIVE_VISUAL_ID, &format_wanted);
 
-        ANativeWindow_setBuffersGeometry(nw, 0, 0, format);
+    /* Format based on selected egl config. */
+    ANativeWindow_setBuffersGeometry(nw, 0, 0, format_wanted);
+#endif
 
-        /* Update SurfaceView holder format.
-         * May triggers a sequence surfaceDestroyed(), surfaceCreated(), surfaceChanged(). */
-        Android_JNI_SetSurfaceViewFormat(format);
-    }
-#endif    
     if (_this->gl_config.framebuffer_srgb_capable) {
 #ifdef EGL_KHR_gl_colorspace
         if (SDL_EGL_HasExtension(_this, SDL_EGL_DISPLAY_EXTENSION, "EGL_KHR_gl_colorspace")) {
@@ -1123,6 +1221,14 @@ SDL_EGL_CreateSurface(_THIS, NativeWindowType nw)
         }
     }
 
+#ifdef EGL_EXT_present_opaque
+    if (SDL_EGL_HasExtension(_this, SDL_EGL_DISPLAY_EXTENSION, "EGL_EXT_present_opaque")) {
+        const SDL_bool allow_transparent = SDL_GetHintBoolean(SDL_HINT_VIDEO_EGL_ALLOW_TRANSPARENCY, SDL_FALSE);
+        attribs[attr++] = EGL_PRESENT_OPAQUE_EXT;
+        attribs[attr++] = allow_transparent ? EGL_FALSE : EGL_TRUE;
+    }
+#endif
+
     attribs[attr++] = EGL_NONE;
     
     surface = _this->egl_data->eglCreateWindowSurface(
@@ -1132,6 +1238,12 @@ SDL_EGL_CreateSurface(_THIS, NativeWindowType nw)
     if (surface == EGL_NO_SURFACE) {
         SDL_EGL_SetError("unable to create an EGL window surface", "eglCreateWindowSurface");
     }
+
+#if SDL_VIDEO_DRIVER_ANDROID
+    format_got = ANativeWindow_getFormat(nw);
+    Android_SetFormat(format_wanted, format_got);
+#endif
+
     return surface;
 }
 
diff --git a/Engine/lib/sdl/src/video/SDL_egl_c.h b/Engine/lib/sdl/src/video/SDL_egl_c.h
index 991344977..1827af05a 100644
--- a/Engine/lib/sdl/src/video/SDL_egl_c.h
+++ b/Engine/lib/sdl/src/video/SDL_egl_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -40,6 +40,8 @@ typedef struct SDL_EGL_VideoData
     int egl_surfacetype;
     int egl_version_major, egl_version_minor;
     EGLint egl_required_visual_id;
+    SDL_bool is_offscreen;  /* whether EGL display was offscreen */
+    EGLenum apitype;  /* EGL_OPENGL_ES_API, EGL_OPENGL_API, etc */
     
     EGLDisplay(EGLAPIENTRY *eglGetDisplay) (NativeDisplayType display);
     EGLDisplay(EGLAPIENTRY *eglGetPlatformDisplay) (EGLenum platform,
@@ -114,11 +116,6 @@ typedef struct SDL_EGL_VideoData
     EGLint(EGLAPIENTRY *eglClientWaitSyncKHR)(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout);
 
     /* Atomic functions end */
-
-
-    /* whether EGL display was offscreen */
-    int is_offscreen;
-
 } SDL_EGL_VideoData;
 
 /* OpenGLES functions */
diff --git a/Engine/lib/sdl/src/video/SDL_fillrect.c b/Engine/lib/sdl/src/video/SDL_fillrect.c
index 3deb50132..13872d271 100644
--- a/Engine/lib/sdl/src/video/SDL_fillrect.c
+++ b/Engine/lib/sdl/src/video/SDL_fillrect.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -28,7 +28,7 @@
 #ifdef __SSE__
 /* *INDENT-OFF* */
 
-#ifdef _MSC_VER
+#if defined(_MSC_VER) && !defined(__clang__)
 #define SSE_BEGIN \
     __m128 c128; \
     c128.m128_u32[0] = color; \
@@ -145,13 +145,13 @@ SDL_FillRect1(Uint8 * pixels, int pitch, Uint32 color, int w, int h)
             switch ((uintptr_t) p & 3) {
             case 1:
                 *p++ = (Uint8) color;
-                --n;                    /* fallthrough */
+                --n;                    SDL_FALLTHROUGH;
             case 2:
                 *p++ = (Uint8) color;
-                --n;                    /* fallthrough */
+                --n;                    SDL_FALLTHROUGH;
             case 3:
                 *p++ = (Uint8) color;
-                --n;                    /* fallthrough */
+                --n;
             }
             SDL_memset4(p, color, (n >> 2));
         }
@@ -159,11 +159,11 @@ SDL_FillRect1(Uint8 * pixels, int pitch, Uint32 color, int w, int h)
             p += (n & ~3);
             switch (n & 3) {
             case 3:
-                *p++ = (Uint8) color;   /* fallthrough */
+                *p++ = (Uint8) color;   SDL_FALLTHROUGH;
             case 2:
-                *p++ = (Uint8) color;   /* fallthrough */
+                *p++ = (Uint8) color;   SDL_FALLTHROUGH;
             case 1:
-                *p++ = (Uint8) color;   /* fallthrough */
+                *p++ = (Uint8) color;
             }
         }
         pixels += pitch;
@@ -238,7 +238,7 @@ int
 SDL_FillRect(SDL_Surface * dst, const SDL_Rect * rect, Uint32 color)
 {
     if (!dst) {
-        return SDL_SetError("Passed NULL destination surface");
+        return SDL_InvalidParamError("SDL_FillRect(): dst");
     }
 
     /* If 'rect' == NULL, then fill the whole surface */
@@ -306,12 +306,7 @@ SDL_FillRects(SDL_Surface * dst, const SDL_Rect * rects, int count,
     int i;
 
     if (!dst) {
-        return SDL_SetError("Passed NULL destination surface");
-    }
-
-    /* This function doesn't work on surfaces < 8 bpp */
-    if (dst->format->BitsPerPixel < 8) {
-        return SDL_SetError("SDL_FillRect(): Unsupported surface format");
+        return SDL_InvalidParamError("SDL_FillRects(): dst");
     }
 
     /* Nothing to do */
@@ -321,11 +316,28 @@ SDL_FillRects(SDL_Surface * dst, const SDL_Rect * rects, int count,
 
     /* Perform software fill */
     if (!dst->pixels) {
-        return SDL_SetError("SDL_FillRect(): You must lock the surface");
+        return SDL_SetError("SDL_FillRects(): You must lock the surface");
     }
 
     if (!rects) {
-        return SDL_SetError("SDL_FillRects() passed NULL rects");
+        return SDL_InvalidParamError("SDL_FillRects(): rects");
+    }
+
+    /* This function doesn't usually work on surfaces < 8 bpp
+     * Except: support for 4bits, when filling full size.
+     */
+    if (dst->format->BitsPerPixel < 8) {
+        if (count == 1) {
+            const SDL_Rect *r = &rects[0];
+            if (r->x == 0 && r->y == 0 && r->w == dst->w && r->w == dst->h) {
+                if (dst->format->BitsPerPixel == 4) {
+                    Uint8 b = (((Uint8) color << 4) | (Uint8) color);
+                    SDL_memset(dst->pixels, b, dst->h * dst->pitch);
+                    return 1;
+                }
+            }
+        }
+        return SDL_SetError("SDL_FillRects(): Unsupported surface format");
     }
 
 #if SDL_ARM_NEON_BLITTERS
diff --git a/Engine/lib/sdl/src/video/SDL_pixels.c b/Engine/lib/sdl/src/video/SDL_pixels.c
index 84b693217..b76161d03 100644
--- a/Engine/lib/sdl/src/video/SDL_pixels.c
+++ b/Engine/lib/sdl/src/video/SDL_pixels.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -333,7 +333,7 @@ SDL_MasksToPixelFormatEnum(int bpp, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask,
         if (Rmask == 0) {
             return SDL_PIXELFORMAT_RGB555;
         }
-    /* fallthrough */
+        SDL_FALLTHROUGH;
     case 16:
         if (Rmask == 0) {
             return SDL_PIXELFORMAT_RGB565;
@@ -677,7 +677,7 @@ int
 SDL_SetPixelFormatPalette(SDL_PixelFormat * format, SDL_Palette *palette)
 {
     if (!format) {
-        return SDL_SetError("SDL_SetPixelFormatPalette() passed NULL format");
+        return SDL_InvalidParamError("SDL_SetPixelFormatPalette(): format");
     }
 
     if (palette && palette->ncolors > (1 << format->BitsPerPixel)) {
@@ -871,7 +871,7 @@ SDL_MapRGBA(const SDL_PixelFormat * format, Uint8 r, Uint8 g, Uint8 b,
         return (r >> format->Rloss) << format->Rshift
             | (g >> format->Gloss) << format->Gshift
             | (b >> format->Bloss) << format->Bshift
-            | ((a >> format->Aloss) << format->Ashift & format->Amask);
+            | ((Uint32)(a >> format->Aloss) << format->Ashift & format->Amask);
     } else {
         return SDL_FindColor(format->palette, r, g, b, a);
     }
@@ -947,7 +947,7 @@ Map1to1(SDL_Palette * src, SDL_Palette * dst, int *identical)
         }
         *identical = 0;
     }
-    map = (Uint8 *) SDL_malloc(src->ncolors);
+    map = (Uint8 *) SDL_calloc(256, sizeof(Uint8));
     if (map == NULL) {
         SDL_OutOfMemory();
         return (NULL);
@@ -971,7 +971,7 @@ Map1toN(SDL_PixelFormat * src, Uint8 Rmod, Uint8 Gmod, Uint8 Bmod, Uint8 Amod,
     SDL_Palette *pal = src->palette;
 
     bpp = ((dst->BytesPerPixel == 3) ? 4 : dst->BytesPerPixel);
-    map = (Uint8 *) SDL_malloc(pal->ncolors * bpp);
+    map = (Uint8 *) SDL_calloc(256, bpp);
     if (map == NULL) {
         SDL_OutOfMemory();
         return (NULL);
@@ -983,7 +983,7 @@ Map1toN(SDL_PixelFormat * src, Uint8 Rmod, Uint8 Gmod, Uint8 Bmod, Uint8 Amod,
         Uint8 G = (Uint8) ((pal->colors[i].g * Gmod) / 255);
         Uint8 B = (Uint8) ((pal->colors[i].b * Bmod) / 255);
         Uint8 A = (Uint8) ((pal->colors[i].a * Amod) / 255);
-        ASSEMBLE_RGBA(&map[i * bpp], dst->BytesPerPixel, dst, R, G, B, A);
+        ASSEMBLE_RGBA(&map[i * bpp], dst->BytesPerPixel, dst, (Uint32)R, (Uint32)G, (Uint32)B, (Uint32)A);
     }
     return (map);
 }
diff --git a/Engine/lib/sdl/src/video/SDL_pixels_c.h b/Engine/lib/sdl/src/video/SDL_pixels_c.h
index 9ff590e0c..828fe3bd8 100644
--- a/Engine/lib/sdl/src/video/SDL_pixels_c.h
+++ b/Engine/lib/sdl/src/video/SDL_pixels_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/SDL_rect.c b/Engine/lib/sdl/src/video/SDL_rect.c
index b9aca3b53..dfa939032 100644
--- a/Engine/lib/sdl/src/video/SDL_rect.c
+++ b/Engine/lib/sdl/src/video/SDL_rect.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -23,447 +23,8 @@
 #include "SDL_rect.h"
 #include "SDL_rect_c.h"
 
-SDL_bool
-SDL_HasIntersection(const SDL_Rect * A, const SDL_Rect * B)
-{
-    int Amin, Amax, Bmin, Bmax;
-
-    if (!A) {
-        SDL_InvalidParamError("A");
-        return SDL_FALSE;
-    }
-
-    if (!B) {
-        SDL_InvalidParamError("B");
-        return SDL_FALSE;
-    }
-
-    /* Special cases for empty rects */
-    if (SDL_RectEmpty(A) || SDL_RectEmpty(B)) {
-        return SDL_FALSE;
-    }
-
-    /* Horizontal intersection */
-    Amin = A->x;
-    Amax = Amin + A->w;
-    Bmin = B->x;
-    Bmax = Bmin + B->w;
-    if (Bmin > Amin)
-        Amin = Bmin;
-    if (Bmax < Amax)
-        Amax = Bmax;
-    if (Amax <= Amin)
-        return SDL_FALSE;
-
-    /* Vertical intersection */
-    Amin = A->y;
-    Amax = Amin + A->h;
-    Bmin = B->y;
-    Bmax = Bmin + B->h;
-    if (Bmin > Amin)
-        Amin = Bmin;
-    if (Bmax < Amax)
-        Amax = Bmax;
-    if (Amax <= Amin)
-        return SDL_FALSE;
-
-    return SDL_TRUE;
-}
-
-SDL_bool
-SDL_IntersectRect(const SDL_Rect * A, const SDL_Rect * B, SDL_Rect * result)
-{
-    int Amin, Amax, Bmin, Bmax;
-
-    if (!A) {
-        SDL_InvalidParamError("A");
-        return SDL_FALSE;
-    }
-
-    if (!B) {
-        SDL_InvalidParamError("B");
-        return SDL_FALSE;
-    }
-
-    if (!result) {
-        SDL_InvalidParamError("result");
-        return SDL_FALSE;
-    }
-
-    /* Special cases for empty rects */
-    if (SDL_RectEmpty(A) || SDL_RectEmpty(B)) {
-        result->w = 0;
-        result->h = 0;
-        return SDL_FALSE;
-    }
-
-    /* Horizontal intersection */
-    Amin = A->x;
-    Amax = Amin + A->w;
-    Bmin = B->x;
-    Bmax = Bmin + B->w;
-    if (Bmin > Amin)
-        Amin = Bmin;
-    result->x = Amin;
-    if (Bmax < Amax)
-        Amax = Bmax;
-    result->w = Amax - Amin;
-
-    /* Vertical intersection */
-    Amin = A->y;
-    Amax = Amin + A->h;
-    Bmin = B->y;
-    Bmax = Bmin + B->h;
-    if (Bmin > Amin)
-        Amin = Bmin;
-    result->y = Amin;
-    if (Bmax < Amax)
-        Amax = Bmax;
-    result->h = Amax - Amin;
-
-    return !SDL_RectEmpty(result);
-}
-
-void
-SDL_UnionRect(const SDL_Rect * A, const SDL_Rect * B, SDL_Rect * result)
-{
-    int Amin, Amax, Bmin, Bmax;
-
-    if (!A) {
-        SDL_InvalidParamError("A");
-        return;
-    }
-
-    if (!B) {
-        SDL_InvalidParamError("B");
-        return;
-    }
-
-    if (!result) {
-        SDL_InvalidParamError("result");
-        return;
-    }
-
-    /* Special cases for empty Rects */
-    if (SDL_RectEmpty(A)) {
-      if (SDL_RectEmpty(B)) {
-       /* A and B empty */
-       return;
-      } else {
-       /* A empty, B not empty */
-       *result = *B;
-       return;
-      }
-    } else {
-      if (SDL_RectEmpty(B)) {
-       /* A not empty, B empty */
-       *result = *A;
-       return;
-      }
-    }
-
-    /* Horizontal union */
-    Amin = A->x;
-    Amax = Amin + A->w;
-    Bmin = B->x;
-    Bmax = Bmin + B->w;
-    if (Bmin < Amin)
-        Amin = Bmin;
-    result->x = Amin;
-    if (Bmax > Amax)
-        Amax = Bmax;
-    result->w = Amax - Amin;
-
-    /* Vertical union */
-    Amin = A->y;
-    Amax = Amin + A->h;
-    Bmin = B->y;
-    Bmax = Bmin + B->h;
-    if (Bmin < Amin)
-        Amin = Bmin;
-    result->y = Amin;
-    if (Bmax > Amax)
-        Amax = Bmax;
-    result->h = Amax - Amin;
-}
-
-SDL_bool
-SDL_EnclosePoints(const SDL_Point * points, int count, const SDL_Rect * clip,
-                  SDL_Rect * result)
-{
-    int minx = 0;
-    int miny = 0;
-    int maxx = 0;
-    int maxy = 0;
-    int x, y, i;
-
-    if (!points) {
-        SDL_InvalidParamError("points");
-        return SDL_FALSE;
-    }
-
-    if (count < 1) {
-        SDL_InvalidParamError("count");
-        return SDL_FALSE;
-    }
-
-    if (clip) {
-        SDL_bool added = SDL_FALSE;
-        const int clip_minx = clip->x;
-        const int clip_miny = clip->y;
-        const int clip_maxx = clip->x+clip->w-1;
-        const int clip_maxy = clip->y+clip->h-1;
-
-        /* Special case for empty rectangle */
-        if (SDL_RectEmpty(clip)) {
-            return SDL_FALSE;
-        }
-
-        for (i = 0; i < count; ++i) {
-            x = points[i].x;
-            y = points[i].y;
-
-            if (x < clip_minx || x > clip_maxx ||
-                y < clip_miny || y > clip_maxy) {
-                continue;
-            }
-            if (!added) {
-                /* Special case: if no result was requested, we are done */
-                if (result == NULL) {
-                    return SDL_TRUE;
-                }
-
-                /* First point added */
-                minx = maxx = x;
-                miny = maxy = y;
-                added = SDL_TRUE;
-                continue;
-            }
-            if (x < minx) {
-                minx = x;
-            } else if (x > maxx) {
-                maxx = x;
-            }
-            if (y < miny) {
-                miny = y;
-            } else if (y > maxy) {
-                maxy = y;
-            }
-        }
-        if (!added) {
-            return SDL_FALSE;
-        }
-    } else {
-        /* Special case: if no result was requested, we are done */
-        if (result == NULL) {
-            return SDL_TRUE;
-        }
-
-        /* No clipping, always add the first point */
-        minx = maxx = points[0].x;
-        miny = maxy = points[0].y;
-
-        for (i = 1; i < count; ++i) {
-            x = points[i].x;
-            y = points[i].y;
-
-            if (x < minx) {
-                minx = x;
-            } else if (x > maxx) {
-                maxx = x;
-            }
-            if (y < miny) {
-                miny = y;
-            } else if (y > maxy) {
-                maxy = y;
-            }
-        }
-    }
-
-    if (result) {
-        result->x = minx;
-        result->y = miny;
-        result->w = (maxx-minx)+1;
-        result->h = (maxy-miny)+1;
-    }
-    return SDL_TRUE;
-}
-
-/* Use the Cohen-Sutherland algorithm for line clipping */
-#define CODE_BOTTOM 1
-#define CODE_TOP    2
-#define CODE_LEFT   4
-#define CODE_RIGHT  8
-
-static int
-ComputeOutCode(const SDL_Rect * rect, int x, int y)
-{
-    int code = 0;
-    if (y < rect->y) {
-        code |= CODE_TOP;
-    } else if (y >= rect->y + rect->h) {
-        code |= CODE_BOTTOM;
-    }
-    if (x < rect->x) {
-        code |= CODE_LEFT;
-    } else if (x >= rect->x + rect->w) {
-        code |= CODE_RIGHT;
-    }
-    return code;
-}
-
-SDL_bool
-SDL_IntersectRectAndLine(const SDL_Rect * rect, int *X1, int *Y1, int *X2,
-                         int *Y2)
-{
-    int x = 0;
-    int y = 0;
-    int x1, y1;
-    int x2, y2;
-    int rectx1;
-    int recty1;
-    int rectx2;
-    int recty2;
-    int outcode1, outcode2;
-
-    if (!rect) {
-        SDL_InvalidParamError("rect");
-        return SDL_FALSE;
-    }
-
-    if (!X1) {
-        SDL_InvalidParamError("X1");
-        return SDL_FALSE;
-    }
-
-    if (!Y1) {
-        SDL_InvalidParamError("Y1");
-        return SDL_FALSE;
-    }
-
-    if (!X2) {
-        SDL_InvalidParamError("X2");
-        return SDL_FALSE;
-    }
-
-    if (!Y2) {
-        SDL_InvalidParamError("Y2");
-        return SDL_FALSE;
-    }
-
-    /* Special case for empty rect */
-    if (SDL_RectEmpty(rect)) {
-        return SDL_FALSE;
-    }
-
-    x1 = *X1;
-    y1 = *Y1;
-    x2 = *X2;
-    y2 = *Y2;
-    rectx1 = rect->x;
-    recty1 = rect->y;
-    rectx2 = rect->x + rect->w - 1;
-    recty2 = rect->y + rect->h - 1;
-
-    /* Check to see if entire line is inside rect */
-    if (x1 >= rectx1 && x1 <= rectx2 && x2 >= rectx1 && x2 <= rectx2 &&
-        y1 >= recty1 && y1 <= recty2 && y2 >= recty1 && y2 <= recty2) {
-        return SDL_TRUE;
-    }
-
-    /* Check to see if entire line is to one side of rect */
-    if ((x1 < rectx1 && x2 < rectx1) || (x1 > rectx2 && x2 > rectx2) ||
-        (y1 < recty1 && y2 < recty1) || (y1 > recty2 && y2 > recty2)) {
-        return SDL_FALSE;
-    }
-
-    if (y1 == y2) {
-        /* Horizontal line, easy to clip */
-        if (x1 < rectx1) {
-            *X1 = rectx1;
-        } else if (x1 > rectx2) {
-            *X1 = rectx2;
-        }
-        if (x2 < rectx1) {
-            *X2 = rectx1;
-        } else if (x2 > rectx2) {
-            *X2 = rectx2;
-        }
-        return SDL_TRUE;
-    }
-
-    if (x1 == x2) {
-        /* Vertical line, easy to clip */
-        if (y1 < recty1) {
-            *Y1 = recty1;
-        } else if (y1 > recty2) {
-            *Y1 = recty2;
-        }
-        if (y2 < recty1) {
-            *Y2 = recty1;
-        } else if (y2 > recty2) {
-            *Y2 = recty2;
-        }
-        return SDL_TRUE;
-    }
-
-    /* More complicated Cohen-Sutherland algorithm */
-    outcode1 = ComputeOutCode(rect, x1, y1);
-    outcode2 = ComputeOutCode(rect, x2, y2);
-    while (outcode1 || outcode2) {
-        if (outcode1 & outcode2) {
-            return SDL_FALSE;
-        }
-
-        if (outcode1) {
-            if (outcode1 & CODE_TOP) {
-                y = recty1;
-                x = x1 + ((x2 - x1) * (y - y1)) / (y2 - y1);
-            } else if (outcode1 & CODE_BOTTOM) {
-                y = recty2;
-                x = x1 + ((x2 - x1) * (y - y1)) / (y2 - y1);
-            } else if (outcode1 & CODE_LEFT) {
-                x = rectx1;
-                y = y1 + ((y2 - y1) * (x - x1)) / (x2 - x1);
-            } else if (outcode1 & CODE_RIGHT) {
-                x = rectx2;
-                y = y1 + ((y2 - y1) * (x - x1)) / (x2 - x1);
-            }
-            x1 = x;
-            y1 = y;
-            outcode1 = ComputeOutCode(rect, x, y);
-        } else {
-            if (outcode2 & CODE_TOP) {
-                y = recty1;
-                x = x1 + ((x2 - x1) * (y - y1)) / (y2 - y1);
-            } else if (outcode2 & CODE_BOTTOM) {
-                y = recty2;
-                x = x1 + ((x2 - x1) * (y - y1)) / (y2 - y1);
-            } else if (outcode2 & CODE_LEFT) {
-                /* If this assertion ever fires, here's the static analysis that warned about it:
-                   http://buildbot.libsdl.org/sdl-static-analysis/sdl-macosx-static-analysis/sdl-macosx-static-analysis-1101/report-b0d01a.html#EndPath */
-                SDL_assert(x2 != x1);  /* if equal: division by zero. */
-                x = rectx1;
-                y = y1 + ((y2 - y1) * (x - x1)) / (x2 - x1);
-            } else if (outcode2 & CODE_RIGHT) {
-                /* If this assertion ever fires, here's the static analysis that warned about it:
-                   http://buildbot.libsdl.org/sdl-static-analysis/sdl-macosx-static-analysis/sdl-macosx-static-analysis-1101/report-39b114.html#EndPath */
-                SDL_assert(x2 != x1);  /* if equal: division by zero. */
-                x = rectx2;
-                y = y1 + ((y2 - y1) * (x - x1)) / (x2 - x1);
-            }
-            x2 = x;
-            y2 = y;
-            outcode2 = ComputeOutCode(rect, x, y);
-        }
-    }
-    *X1 = x1;
-    *Y1 = y1;
-    *X2 = x2;
-    *Y2 = y2;
-    return SDL_TRUE;
-}
-
+/* There's no float version of this at the moment, because it's not a public API
+   and internally we only need the int version. */
 SDL_bool
 SDL_GetSpanEnclosingRect(int width, int height,
                          int numrects, const SDL_Rect * rects, SDL_Rect *span)
@@ -475,24 +36,16 @@ SDL_GetSpanEnclosingRect(int width, int height,
     if (width < 1) {
         SDL_InvalidParamError("width");
         return SDL_FALSE;
-    }
-
-    if (height < 1) {
+    } else if (height < 1) {
         SDL_InvalidParamError("height");
         return SDL_FALSE;
-    }
-
-    if (!rects) {
+    } else if (!rects) {
         SDL_InvalidParamError("rects");
         return SDL_FALSE;
-    }
-
-    if (!span) {
+    } else if (!span) {
         SDL_InvalidParamError("span");
         return SDL_FALSE;
-    }
-
-    if (numrects < 1) {
+    } else if (numrects < 1) {
         SDL_InvalidParamError("numrects");
         return SDL_FALSE;
     }
@@ -527,4 +80,36 @@ SDL_GetSpanEnclosingRect(int width, int height,
     return SDL_FALSE;
 }
 
+
+/* For use with the Cohen-Sutherland algorithm for line clipping, in SDL_rect_impl.h */
+#define CODE_BOTTOM 1
+#define CODE_TOP    2
+#define CODE_LEFT   4
+#define CODE_RIGHT  8
+
+/* Same code twice, for float and int versions... */
+#define RECTTYPE SDL_Rect
+#define POINTTYPE SDL_Point
+#define SCALARTYPE int
+#define COMPUTEOUTCODE ComputeOutCode
+#define SDL_HASINTERSECTION SDL_HasIntersection
+#define SDL_INTERSECTRECT SDL_IntersectRect
+#define SDL_RECTEMPTY SDL_RectEmpty
+#define SDL_UNIONRECT SDL_UnionRect
+#define SDL_ENCLOSEPOINTS SDL_EnclosePoints
+#define SDL_INTERSECTRECTANDLINE SDL_IntersectRectAndLine
+#include "SDL_rect_impl.h"
+
+#define RECTTYPE SDL_FRect
+#define POINTTYPE SDL_FPoint
+#define SCALARTYPE float
+#define COMPUTEOUTCODE ComputeOutCodeF
+#define SDL_HASINTERSECTION SDL_HasIntersectionF
+#define SDL_INTERSECTRECT SDL_IntersectFRect
+#define SDL_RECTEMPTY SDL_FRectEmpty
+#define SDL_UNIONRECT SDL_UnionFRect
+#define SDL_ENCLOSEPOINTS SDL_EncloseFPoints
+#define SDL_INTERSECTRECTANDLINE SDL_IntersectFRectAndLine
+#include "SDL_rect_impl.h"
+
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/SDL_rect_c.h b/Engine/lib/sdl/src/video/SDL_rect_c.h
index f194938e6..6205abc70 100644
--- a/Engine/lib/sdl/src/video/SDL_rect_c.h
+++ b/Engine/lib/sdl/src/video/SDL_rect_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/SDL_rect_impl.h b/Engine/lib/sdl/src/video/SDL_rect_impl.h
new file mode 100644
index 000000000..993bb8eb0
--- /dev/null
+++ b/Engine/lib/sdl/src/video/SDL_rect_impl.h
@@ -0,0 +1,444 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+/* This file is #included twice to support int and float versions with the same code. */
+
+SDL_bool
+SDL_HASINTERSECTION(const RECTTYPE * A, const RECTTYPE * B)
+{
+    SCALARTYPE Amin, Amax, Bmin, Bmax;
+
+    if (!A) {
+        SDL_InvalidParamError("A");
+        return SDL_FALSE;
+    } else if (!B) {
+        SDL_InvalidParamError("B");
+        return SDL_FALSE;
+    } else if (SDL_RECTEMPTY(A) || SDL_RECTEMPTY(B)) {
+        return SDL_FALSE;  /* Special cases for empty rects */
+    }
+
+    /* Horizontal intersection */
+    Amin = A->x;
+    Amax = Amin + A->w;
+    Bmin = B->x;
+    Bmax = Bmin + B->w;
+    if (Bmin > Amin) {
+        Amin = Bmin;
+    }
+    if (Bmax < Amax) {
+        Amax = Bmax;
+    }
+    if (Amax <= Amin) {
+        return SDL_FALSE;
+    }
+    /* Vertical intersection */
+    Amin = A->y;
+    Amax = Amin + A->h;
+    Bmin = B->y;
+    Bmax = Bmin + B->h;
+    if (Bmin > Amin) {
+        Amin = Bmin;
+    }
+    if (Bmax < Amax) {
+        Amax = Bmax;
+    }
+    if (Amax <= Amin) {
+        return SDL_FALSE;
+    }
+    return SDL_TRUE;
+}
+
+SDL_bool
+SDL_INTERSECTRECT(const RECTTYPE * A, const RECTTYPE * B, RECTTYPE * result)
+{
+    SCALARTYPE Amin, Amax, Bmin, Bmax;
+
+    if (!A) {
+        SDL_InvalidParamError("A");
+        return SDL_FALSE;
+    } else if (!B) {
+        SDL_InvalidParamError("B");
+        return SDL_FALSE;
+    } else if (!result) {
+        SDL_InvalidParamError("result");
+        return SDL_FALSE;
+    } else if (SDL_RECTEMPTY(A) || SDL_RECTEMPTY(B)) {  /* Special cases for empty rects */
+        result->w = 0;
+        result->h = 0;
+        return SDL_FALSE;
+    }
+
+    /* Horizontal intersection */
+    Amin = A->x;
+    Amax = Amin + A->w;
+    Bmin = B->x;
+    Bmax = Bmin + B->w;
+    if (Bmin > Amin) {
+        Amin = Bmin;
+    }
+    result->x = Amin;
+    if (Bmax < Amax) {
+        Amax = Bmax;
+    }
+    result->w = Amax - Amin;
+
+    /* Vertical intersection */
+    Amin = A->y;
+    Amax = Amin + A->h;
+    Bmin = B->y;
+    Bmax = Bmin + B->h;
+    if (Bmin > Amin) {
+        Amin = Bmin;
+    }
+    result->y = Amin;
+    if (Bmax < Amax) {
+        Amax = Bmax;
+    }
+    result->h = Amax - Amin;
+
+    return !SDL_RECTEMPTY(result);
+}
+
+void
+SDL_UNIONRECT(const RECTTYPE * A, const RECTTYPE * B, RECTTYPE * result)
+{
+    SCALARTYPE Amin, Amax, Bmin, Bmax;
+
+    if (!A) {
+        SDL_InvalidParamError("A");
+        return;
+    } else if (!B) {
+        SDL_InvalidParamError("B");
+        return;
+    } else if (!result) {
+        SDL_InvalidParamError("result");
+        return;
+    } else if (SDL_RECTEMPTY(A)) {  /* Special cases for empty Rects */
+        if (SDL_RECTEMPTY(B)) {  /* A and B empty */
+            SDL_zerop(result);
+        } else {  /* A empty, B not empty */
+            *result = *B;
+        }
+        return;
+    } else if (SDL_RECTEMPTY(B)) {  /* A not empty, B empty */
+       *result = *A;
+       return;
+    }
+
+    /* Horizontal union */
+    Amin = A->x;
+    Amax = Amin + A->w;
+    Bmin = B->x;
+    Bmax = Bmin + B->w;
+    if (Bmin < Amin) {
+        Amin = Bmin;
+    }
+    result->x = Amin;
+    if (Bmax > Amax) {
+        Amax = Bmax;
+    }
+    result->w = Amax - Amin;
+
+    /* Vertical union */
+    Amin = A->y;
+    Amax = Amin + A->h;
+    Bmin = B->y;
+    Bmax = Bmin + B->h;
+    if (Bmin < Amin) {
+        Amin = Bmin;
+    }
+    result->y = Amin;
+    if (Bmax > Amax) {
+        Amax = Bmax;
+    }
+    result->h = Amax - Amin;
+}
+
+SDL_bool SDL_ENCLOSEPOINTS(const POINTTYPE * points, int count, const RECTTYPE * clip,
+                  RECTTYPE * result)
+{
+    SCALARTYPE minx = 0;
+    SCALARTYPE miny = 0;
+    SCALARTYPE maxx = 0;
+    SCALARTYPE maxy = 0;
+    SCALARTYPE x, y;
+    int i;
+
+    if (!points) {
+        SDL_InvalidParamError("points");
+        return SDL_FALSE;
+    } else if (count < 1) {
+        SDL_InvalidParamError("count");
+        return SDL_FALSE;
+    }
+
+    if (clip) {
+        SDL_bool added = SDL_FALSE;
+        const SCALARTYPE clip_minx = clip->x;
+        const SCALARTYPE clip_miny = clip->y;
+        const SCALARTYPE clip_maxx = clip->x+clip->w-1;
+        const SCALARTYPE clip_maxy = clip->y+clip->h-1;
+
+        /* Special case for empty rectangle */
+        if (SDL_RECTEMPTY(clip)) {
+            return SDL_FALSE;
+        }
+
+        for (i = 0; i < count; ++i) {
+            x = points[i].x;
+            y = points[i].y;
+
+            if (x < clip_minx || x > clip_maxx ||
+                y < clip_miny || y > clip_maxy) {
+                continue;
+            }
+            if (!added) {
+                /* Special case: if no result was requested, we are done */
+                if (result == NULL) {
+                    return SDL_TRUE;
+                }
+
+                /* First point added */
+                minx = maxx = x;
+                miny = maxy = y;
+                added = SDL_TRUE;
+                continue;
+            }
+            if (x < minx) {
+                minx = x;
+            } else if (x > maxx) {
+                maxx = x;
+            }
+            if (y < miny) {
+                miny = y;
+            } else if (y > maxy) {
+                maxy = y;
+            }
+        }
+        if (!added) {
+            return SDL_FALSE;
+        }
+    } else {
+        /* Special case: if no result was requested, we are done */
+        if (result == NULL) {
+            return SDL_TRUE;
+        }
+
+        /* No clipping, always add the first point */
+        minx = maxx = points[0].x;
+        miny = maxy = points[0].y;
+
+        for (i = 1; i < count; ++i) {
+            x = points[i].x;
+            y = points[i].y;
+
+            if (x < minx) {
+                minx = x;
+            } else if (x > maxx) {
+                maxx = x;
+            }
+            if (y < miny) {
+                miny = y;
+            } else if (y > maxy) {
+                maxy = y;
+            }
+        }
+    }
+
+    if (result) {
+        result->x = minx;
+        result->y = miny;
+        result->w = (maxx-minx)+1;
+        result->h = (maxy-miny)+1;
+    }
+    return SDL_TRUE;
+}
+
+/* Use the Cohen-Sutherland algorithm for line clipping */
+static int
+COMPUTEOUTCODE(const RECTTYPE * rect, SCALARTYPE x, SCALARTYPE y)
+{
+    int code = 0;
+    if (y < rect->y) {
+        code |= CODE_TOP;
+    } else if (y >= rect->y + rect->h) {
+        code |= CODE_BOTTOM;
+    }
+    if (x < rect->x) {
+        code |= CODE_LEFT;
+    } else if (x >= rect->x + rect->w) {
+        code |= CODE_RIGHT;
+    }
+    return code;
+}
+
+SDL_bool
+SDL_INTERSECTRECTANDLINE(const RECTTYPE * rect, SCALARTYPE *X1, SCALARTYPE *Y1, SCALARTYPE *X2,
+                         SCALARTYPE *Y2)
+{
+    SCALARTYPE x = 0;
+    SCALARTYPE y = 0;
+    SCALARTYPE x1, y1;
+    SCALARTYPE x2, y2;
+    SCALARTYPE rectx1;
+    SCALARTYPE recty1;
+    SCALARTYPE rectx2;
+    SCALARTYPE recty2;
+    int outcode1, outcode2;
+
+    if (!rect) {
+        SDL_InvalidParamError("rect");
+        return SDL_FALSE;
+    } else if (!X1) {
+        SDL_InvalidParamError("X1");
+        return SDL_FALSE;
+    } else if (!Y1) {
+        SDL_InvalidParamError("Y1");
+        return SDL_FALSE;
+    } else if (!X2) {
+        SDL_InvalidParamError("X2");
+        return SDL_FALSE;
+    } else if (!Y2) {
+        SDL_InvalidParamError("Y2");
+        return SDL_FALSE;
+    } else if (SDL_RECTEMPTY(rect)) {
+        return SDL_FALSE;  /* Special case for empty rect */
+    }
+
+    x1 = *X1;
+    y1 = *Y1;
+    x2 = *X2;
+    y2 = *Y2;
+    rectx1 = rect->x;
+    recty1 = rect->y;
+    rectx2 = rect->x + rect->w - 1;
+    recty2 = rect->y + rect->h - 1;
+
+    /* Check to see if entire line is inside rect */
+    if (x1 >= rectx1 && x1 <= rectx2 && x2 >= rectx1 && x2 <= rectx2 &&
+        y1 >= recty1 && y1 <= recty2 && y2 >= recty1 && y2 <= recty2) {
+        return SDL_TRUE;
+    }
+
+    /* Check to see if entire line is to one side of rect */
+    if ((x1 < rectx1 && x2 < rectx1) || (x1 > rectx2 && x2 > rectx2) ||
+        (y1 < recty1 && y2 < recty1) || (y1 > recty2 && y2 > recty2)) {
+        return SDL_FALSE;
+    }
+
+    if (y1 == y2) {  /* Horizontal line, easy to clip */
+        if (x1 < rectx1) {
+            *X1 = rectx1;
+        } else if (x1 > rectx2) {
+            *X1 = rectx2;
+        }
+        if (x2 < rectx1) {
+            *X2 = rectx1;
+        } else if (x2 > rectx2) {
+            *X2 = rectx2;
+        }
+        return SDL_TRUE;
+    }
+
+    if (x1 == x2) {  /* Vertical line, easy to clip */
+        if (y1 < recty1) {
+            *Y1 = recty1;
+        } else if (y1 > recty2) {
+            *Y1 = recty2;
+        }
+        if (y2 < recty1) {
+            *Y2 = recty1;
+        } else if (y2 > recty2) {
+            *Y2 = recty2;
+        }
+        return SDL_TRUE;
+    }
+
+    /* More complicated Cohen-Sutherland algorithm */
+    outcode1 = COMPUTEOUTCODE(rect, x1, y1);
+    outcode2 = COMPUTEOUTCODE(rect, x2, y2);
+    while (outcode1 || outcode2) {
+        if (outcode1 & outcode2) {
+            return SDL_FALSE;
+        }
+
+        if (outcode1) {
+            if (outcode1 & CODE_TOP) {
+                y = recty1;
+                x = x1 + ((x2 - x1) * (y - y1)) / (y2 - y1);
+            } else if (outcode1 & CODE_BOTTOM) {
+                y = recty2;
+                x = x1 + ((x2 - x1) * (y - y1)) / (y2 - y1);
+            } else if (outcode1 & CODE_LEFT) {
+                x = rectx1;
+                y = y1 + ((y2 - y1) * (x - x1)) / (x2 - x1);
+            } else if (outcode1 & CODE_RIGHT) {
+                x = rectx2;
+                y = y1 + ((y2 - y1) * (x - x1)) / (x2 - x1);
+            }
+            x1 = x;
+            y1 = y;
+            outcode1 = COMPUTEOUTCODE(rect, x, y);
+        } else {
+            if (outcode2 & CODE_TOP) {
+                y = recty1;
+                x = x1 + ((x2 - x1) * (y - y1)) / (y2 - y1);
+            } else if (outcode2 & CODE_BOTTOM) {
+                y = recty2;
+                x = x1 + ((x2 - x1) * (y - y1)) / (y2 - y1);
+            } else if (outcode2 & CODE_LEFT) {
+                /* If this assertion ever fires, here's the static analysis that warned about it:
+                   http://buildbot.libsdl.org/sdl-static-analysis/sdl-macosx-static-analysis/sdl-macosx-static-analysis-1101/report-b0d01a.html#EndPath */
+                SDL_assert(x2 != x1);  /* if equal: division by zero. */
+                x = rectx1;
+                y = y1 + ((y2 - y1) * (x - x1)) / (x2 - x1);
+            } else if (outcode2 & CODE_RIGHT) {
+                /* If this assertion ever fires, here's the static analysis that warned about it:
+                   http://buildbot.libsdl.org/sdl-static-analysis/sdl-macosx-static-analysis/sdl-macosx-static-analysis-1101/report-39b114.html#EndPath */
+                SDL_assert(x2 != x1);  /* if equal: division by zero. */
+                x = rectx2;
+                y = y1 + ((y2 - y1) * (x - x1)) / (x2 - x1);
+            }
+            x2 = x;
+            y2 = y;
+            outcode2 = COMPUTEOUTCODE(rect, x, y);
+        }
+    }
+    *X1 = x1;
+    *Y1 = y1;
+    *X2 = x2;
+    *Y2 = y2;
+    return SDL_TRUE;
+}
+
+#undef RECTTYPE
+#undef POINTTYPE
+#undef SCALARTYPE
+#undef COMPUTEOUTCODE
+#undef SDL_HASINTERSECTION
+#undef SDL_INTERSECTRECT
+#undef SDL_RECTEMPTY
+#undef SDL_UNIONRECT
+#undef SDL_ENCLOSEPOINTS
+#undef SDL_INTERSECTRECTANDLINE
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/SDL_shape.c b/Engine/lib/sdl/src/video/SDL_shape.c
index 5c174bf16..919ae9598 100644
--- a/Engine/lib/sdl/src/video/SDL_shape.c
+++ b/Engine/lib/sdl/src/video/SDL_shape.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/SDL_shape_internals.h b/Engine/lib/sdl/src/video/SDL_shape_internals.h
index a93dfa079..16d659ef1 100644
--- a/Engine/lib/sdl/src/video/SDL_shape_internals.h
+++ b/Engine/lib/sdl/src/video/SDL_shape_internals.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/SDL_stretch.c b/Engine/lib/sdl/src/video/SDL_stretch.c
index 475373166..bc7b4e551 100644
--- a/Engine/lib/sdl/src/video/SDL_stretch.c
+++ b/Engine/lib/sdl/src/video/SDL_stretch.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -20,210 +20,48 @@
 */
 #include "../SDL_internal.h"
 
-/* This a stretch blit implementation based on ideas given to me by
-   Tomasz Cejner - thanks! :)
-
-   April 27, 2000 - Sam Lantinga
-*/
-
 #include "SDL_video.h"
 #include "SDL_blit.h"
+#include "SDL_render.h"
 
-/* This isn't ready for general consumption yet - it should be folded
-   into the general blitting mechanism.
-*/
+static int SDL_LowerSoftStretchNearest(SDL_Surface *src, const SDL_Rect *srcrect, SDL_Surface *dst, const SDL_Rect *dstrect);
+static int SDL_LowerSoftStretchLinear(SDL_Surface *src, const SDL_Rect *srcrect, SDL_Surface *dst, const SDL_Rect *dstrect);
+static int SDL_UpperSoftStretch(SDL_Surface * src, const SDL_Rect * srcrect, SDL_Surface * dst, const SDL_Rect * dstrect, SDL_ScaleMode scaleMode);
 
-#if ((defined(_MSC_VER) && defined(_M_IX86))    || \
-     (defined(__WATCOMC__) && defined(__386__)) || \
-     (defined(__GNUC__) && defined(__i386__))) && SDL_ASSEMBLY_ROUTINES
-/* There's a bug with gcc 4.4.1 and -O2 where srcp doesn't get the correct
- * value after the first scanline.  FIXME? */
-/* #define USE_ASM_STRETCH */
-#endif
+int
+SDL_SoftStretch(SDL_Surface *src, const SDL_Rect *srcrect,
+                SDL_Surface *dst, const SDL_Rect *dstrect)
+{
+    return SDL_UpperSoftStretch(src, srcrect, dst, dstrect, SDL_ScaleModeNearest);
+}
 
-#ifdef USE_ASM_STRETCH
-
-#ifdef HAVE_MPROTECT
-#include <sys/types.h>
-#include <sys/mman.h>
-#endif
-#ifdef __GNUC__
-#define PAGE_ALIGNED __attribute__((__aligned__(4096)))
-#else
-#define PAGE_ALIGNED
-#endif
-
-#if defined(_M_IX86) || defined(__i386__) || defined(__386__)
-#define PREFIX16    0x66
-#define STORE_BYTE  0xAA
-#define STORE_WORD  0xAB
-#define LOAD_BYTE   0xAC
-#define LOAD_WORD   0xAD
-#define RETURN      0xC3
-#else
-#error Need assembly opcodes for this architecture
-#endif
-
-static unsigned char copy_row[4096] PAGE_ALIGNED;
+int
+SDL_SoftStretchLinear(SDL_Surface *src, const SDL_Rect *srcrect,
+                      SDL_Surface *dst, const SDL_Rect *dstrect)
+{
+    return SDL_UpperSoftStretch(src, srcrect, dst, dstrect, SDL_ScaleModeLinear);
+}
 
 static int
-generate_rowbytes(int src_w, int dst_w, int bpp)
-{
-    static struct
-    {
-        int bpp;
-        int src_w;
-        int dst_w;
-        int status;
-    } last;
-
-    int i;
-    int pos, inc;
-    unsigned char *eip, *fence;
-    unsigned char load, store;
-
-    /* See if we need to regenerate the copy buffer */
-    if ((src_w == last.src_w) && (dst_w == last.dst_w) && (bpp == last.bpp)) {
-        return (last.status);
-    }
-    last.bpp = bpp;
-    last.src_w = src_w;
-    last.dst_w = dst_w;
-    last.status = -1;
-
-    switch (bpp) {
-    case 1:
-        load = LOAD_BYTE;
-        store = STORE_BYTE;
-        break;
-    case 2:
-    case 4:
-        load = LOAD_WORD;
-        store = STORE_WORD;
-        break;
-    default:
-        return SDL_SetError("ASM stretch of %d bytes isn't supported", bpp);
-    }
-#ifdef HAVE_MPROTECT
-    /* Make the code writeable */
-    if (mprotect(copy_row, sizeof(copy_row), PROT_READ | PROT_WRITE) < 0) {
-        return SDL_SetError("Couldn't make copy buffer writeable");
-    }
-#endif
-    pos = 0x10000;
-    inc = (src_w << 16) / dst_w;
-    eip = copy_row;
-    fence = copy_row + sizeof(copy_row)-2;
-    for (i = 0; i < dst_w; ++i) {
-        while (pos >= 0x10000L) {
-            if (eip == fence) {
-                return -1;
-            }
-            if (bpp == 2) {
-                *eip++ = PREFIX16;
-            }
-            *eip++ = load;
-            pos -= 0x10000L;
-        }
-        if (eip == fence) {
-            return -1;
-        }
-        if (bpp == 2) {
-            *eip++ = PREFIX16;
-        }
-        *eip++ = store;
-        pos += inc;
-    }
-    *eip++ = RETURN;
-
-#ifdef HAVE_MPROTECT
-    /* Make the code executable but not writeable */
-    if (mprotect(copy_row, sizeof(copy_row), PROT_READ | PROT_EXEC) < 0) {
-        return SDL_SetError("Couldn't make copy buffer executable");
-    }
-#endif
-    last.status = 0;
-    return (0);
-}
-
-#endif /* USE_ASM_STRETCH */
-
-#define DEFINE_COPY_ROW(name, type)         \
-static void name(type *src, int src_w, type *dst, int dst_w)    \
-{                                           \
-    int i;                                  \
-    int pos, inc;                           \
-    type pixel = 0;                         \
-                                            \
-    pos = 0x10000;                          \
-    inc = (src_w << 16) / dst_w;            \
-    for ( i=dst_w; i>0; --i ) {             \
-        while ( pos >= 0x10000L ) {         \
-            pixel = *src++;                 \
-            pos -= 0x10000L;                \
-        }                                   \
-        *dst++ = pixel;                     \
-        pos += inc;                         \
-    }                                       \
-}
-/* *INDENT-OFF* */
-DEFINE_COPY_ROW(copy_row1, Uint8)
-DEFINE_COPY_ROW(copy_row2, Uint16)
-DEFINE_COPY_ROW(copy_row4, Uint32)
-/* *INDENT-ON* */
-
-/* The ASM code doesn't handle 24-bpp stretch blits */
-static void
-copy_row3(Uint8 * src, int src_w, Uint8 * dst, int dst_w)
-{
-    int i;
-    int pos, inc;
-    Uint8 pixel[3] = { 0, 0, 0 };
-
-    pos = 0x10000;
-    inc = (src_w << 16) / dst_w;
-    for (i = dst_w; i > 0; --i) {
-        while (pos >= 0x10000L) {
-            pixel[0] = *src++;
-            pixel[1] = *src++;
-            pixel[2] = *src++;
-            pos -= 0x10000L;
-        }
-        *dst++ = pixel[0];
-        *dst++ = pixel[1];
-        *dst++ = pixel[2];
-        pos += inc;
-    }
-}
-
-/* Perform a stretch blit between two surfaces of the same format.
-   NOTE:  This function is not safe to call from multiple threads!
-*/
-int
-SDL_SoftStretch(SDL_Surface * src, const SDL_Rect * srcrect,
-                SDL_Surface * dst, const SDL_Rect * dstrect)
+SDL_UpperSoftStretch(SDL_Surface * src, const SDL_Rect * srcrect,
+                SDL_Surface * dst, const SDL_Rect * dstrect, SDL_ScaleMode scaleMode)
 {
+    int ret;
     int src_locked;
     int dst_locked;
-    int pos, inc;
-    int dst_maxrow;
-    int src_row, dst_row;
-    Uint8 *srcp = NULL;
-    Uint8 *dstp;
     SDL_Rect full_src;
     SDL_Rect full_dst;
-#ifdef USE_ASM_STRETCH
-    SDL_bool use_asm = SDL_TRUE;
-#ifdef __GNUC__
-    int u1, u2;
-#endif
-#endif /* USE_ASM_STRETCH */
-    const int bpp = dst->format->BytesPerPixel;
 
     if (src->format->format != dst->format->format) {
         return SDL_SetError("Only works with same format surfaces");
     }
 
+    if (scaleMode != SDL_ScaleModeNearest) {
+        if (src->format->BytesPerPixel != 4 || src->format->format == SDL_PIXELFORMAT_ARGB2101010) {
+            return SDL_SetError("Wrong format");
+        }
+    }
+
     /* Verify the blit rectangles */
     if (srcrect) {
         if ((srcrect->x < 0) || (srcrect->y < 0) ||
@@ -252,6 +90,15 @@ SDL_SoftStretch(SDL_Surface * src, const SDL_Rect * srcrect,
         dstrect = &full_dst;
     }
 
+    if (dstrect->w <= 0 || dstrect->h <= 0) {
+        return 0;
+    }
+
+    if (srcrect->w > SDL_MAX_UINT16 || srcrect->h > SDL_MAX_UINT16 ||
+        dstrect->w > SDL_MAX_UINT16 || dstrect->h > SDL_MAX_UINT16) {
+        return SDL_SetError("Size too large for scaling");
+    }
+
     /* Lock the destination if it's in hardware */
     dst_locked = 0;
     if (SDL_MUSTLOCK(dst)) {
@@ -272,72 +119,10 @@ SDL_SoftStretch(SDL_Surface * src, const SDL_Rect * srcrect,
         src_locked = 1;
     }
 
-    /* Set up the data... */
-    pos = 0x10000;
-    inc = (srcrect->h << 16) / dstrect->h;
-    src_row = srcrect->y;
-    dst_row = dstrect->y;
-
-#ifdef USE_ASM_STRETCH
-    /* Write the opcodes for this stretch */
-    if ((bpp == 3) || (generate_rowbytes(srcrect->w, dstrect->w, bpp) < 0)) {
-        use_asm = SDL_FALSE;
-    }
-#endif
-
-    /* Perform the stretch blit */
-    for (dst_maxrow = dst_row + dstrect->h; dst_row < dst_maxrow; ++dst_row) {
-        dstp = (Uint8 *) dst->pixels + (dst_row * dst->pitch)
-            + (dstrect->x * bpp);
-        while (pos >= 0x10000L) {
-            srcp = (Uint8 *) src->pixels + (src_row * src->pitch)
-                + (srcrect->x * bpp);
-            ++src_row;
-            pos -= 0x10000L;
-        }
-#ifdef USE_ASM_STRETCH
-        if (use_asm) {
-#ifdef __GNUC__
-            __asm__ __volatile__("call *%4":"=&D"(u1), "=&S"(u2)
-                                 :"0"(dstp), "1"(srcp), "r"(copy_row)
-                                 :"memory");
-#elif defined(_MSC_VER) || defined(__WATCOMC__)
-            /* *INDENT-OFF* */
-            {
-                void *code = copy_row;
-                __asm {
-                    push edi
-                    push esi
-                    mov edi, dstp
-                    mov esi, srcp
-                    call dword ptr code
-                    pop esi
-                    pop edi
-                }
-            }
-            /* *INDENT-ON* */
-#else
-#error Need inline assembly for this compiler
-#endif
-        } else
-#endif
-            switch (bpp) {
-            case 1:
-                copy_row1(srcp, srcrect->w, dstp, dstrect->w);
-                break;
-            case 2:
-                copy_row2((Uint16 *) srcp, srcrect->w,
-                          (Uint16 *) dstp, dstrect->w);
-                break;
-            case 3:
-                copy_row3(srcp, srcrect->w, dstp, dstrect->w);
-                break;
-            case 4:
-                copy_row4((Uint32 *) srcp, srcrect->w,
-                          (Uint32 *) dstp, dstrect->w);
-                break;
-            }
-        pos += inc;
+    if (scaleMode == SDL_ScaleModeNearest) {
+        ret = SDL_LowerSoftStretchNearest(src, srcrect, dst, dstrect);
+    } else {
+        ret = SDL_LowerSoftStretchLinear(src, srcrect, dst, dstrect);
     }
 
     /* We need to unlock the surfaces if they're locked */
@@ -347,7 +132,852 @@ SDL_SoftStretch(SDL_Surface * src, const SDL_Rect * srcrect,
     if (src_locked) {
         SDL_UnlockSurface(src);
     }
-    return (0);
+
+    return ret;
+}
+
+/* bilinear interpolation precision must be < 8
+   Because with SSE: add-multiply: _mm_madd_epi16 works with signed int
+   so pixels 0xb1...... are negatives and false the result
+   same in NEON probably */
+#define PRECISION      7
+
+#define FIXED_POINT(i)  ((Uint32)(i)  << 16)
+#define SRC_INDEX(fp)   ((Uint32)(fp) >> 16)
+#define INTEGER(fp)     ((Uint32)(fp) >> PRECISION)
+#define FRAC(fp)        ((Uint32)(fp >> (16 - PRECISION)) & ((1<<PRECISION) - 1))
+#define FRAC_ZERO       0
+#define FRAC_ONE        (1 << PRECISION)
+#define FP_ONE          FIXED_POINT(1)
+
+#define BILINEAR___START                                                                        \
+    int i;                                                                                      \
+    int fp_sum_h, fp_step_h, left_pad_h, right_pad_h;                                           \
+    int fp_sum_w, fp_step_w, left_pad_w, right_pad_w;                                           \
+    int fp_sum_w_init, left_pad_w_init, right_pad_w_init, dst_gap, middle_init;                 \
+    get_scaler_datas(src_h, dst_h, &fp_sum_h, &fp_step_h, &left_pad_h, &right_pad_h);           \
+    get_scaler_datas(src_w, dst_w, &fp_sum_w, &fp_step_w, &left_pad_w, &right_pad_w);           \
+    fp_sum_w_init    = fp_sum_w + left_pad_w * fp_step_w;                                       \
+    left_pad_w_init  = left_pad_w;                                                              \
+    right_pad_w_init = right_pad_w;                                                             \
+    dst_gap          = dst_pitch - 4 * dst_w;                                                   \
+    middle_init      = dst_w - left_pad_w - right_pad_w;                                        \
+
+#define BILINEAR___HEIGHT                                                                       \
+    int index_h, frac_h0, frac_h1, middle;                                                      \
+    const Uint32 *src_h0, *src_h1;                                                              \
+    int no_padding, incr_h0, incr_h1;                                                           \
+                                                                                                \
+    no_padding = !(i < left_pad_h || i > dst_h - 1 - right_pad_h);                              \
+    index_h    = SRC_INDEX(fp_sum_h);                                                           \
+    frac_h0    = FRAC(fp_sum_h);                                                                \
+                                                                                                \
+    index_h = no_padding ? index_h : (i < left_pad_h ? 0 : src_h - 1);                          \
+    frac_h0 = no_padding ? frac_h0 : 0;                                                         \
+    incr_h1 = no_padding ? src_pitch : 0;                                                       \
+    incr_h0 = index_h * src_pitch;                                                              \
+                                                                                                \
+    src_h0  = (const Uint32 *)((const Uint8 *)src + incr_h0);                                   \
+    src_h1  = (const Uint32 *)((const Uint8 *)src_h0 + incr_h1);                                \
+                                                                                                \
+    fp_sum_h += fp_step_h;                                                                      \
+                                                                                                \
+    frac_h1  = FRAC_ONE - frac_h0;                                                              \
+    fp_sum_w = fp_sum_w_init;                                                                   \
+    right_pad_w = right_pad_w_init;                                                             \
+    left_pad_w  = left_pad_w_init;                                                              \
+    middle      = middle_init;                                                                  \
+
+
+
+#if defined(__clang__)
+// Remove inlining of this function
+// Compiler crash with clang 9.0.8 / android-ndk-r21d
+// Compiler crash with clang 11.0.3 / Xcode
+// OK with clang 11.0.5 / android-ndk-22
+// OK with clang 12.0.0 / Xcode
+__attribute__((noinline))
+#endif
+static void
+get_scaler_datas(int src_nb, int dst_nb, int *fp_start, int *fp_step, int *left_pad, int *right_pad)
+{
+
+    int step = FIXED_POINT(src_nb) / (dst_nb);  /* source step in fixed point */
+    int x0 = FP_ONE / 2;     /* dst first pixel center at 0.5 in fixed point */
+    int fp_sum;
+    int i;
+#if 0
+    /* scale to source coordinates */
+    x0 *= src_nb;
+    x0 /= dst_nb; /* x0 == step / 2 */
+#else
+    /* Use this code for perfect match with pixman */
+    Sint64 tmp[2];
+    tmp[0] = (Sint64)step * (x0 >> 16);
+    tmp[1] = (Sint64)step * (x0 & 0xFFFF);
+    x0 = (int) (tmp[0] + ((tmp[1] + 0x8000) >> 16)); /*  x0 == (step + 1) / 2  */
+#endif
+    /* -= 0.5, get back the pixel origin, in source coordinates  */
+    x0 -= FP_ONE / 2;
+
+    *fp_start = x0;
+    *fp_step = step;
+    *left_pad = 0;
+    *right_pad = 0;
+
+    fp_sum = x0;
+    for (i = 0; i < dst_nb; i++) {
+        if (fp_sum < 0) {
+            *left_pad += 1;
+        } else {
+            int index = SRC_INDEX(fp_sum);
+            if (index > src_nb - 2) {
+                *right_pad += 1;
+            }
+        }
+        fp_sum += step;
+    }
+//    SDL_Log("%d -> %d  x0=%d step=%d left_pad=%d right_pad=%d", src_nb, dst_nb, *fp_start, *fp_step, *left_pad, *right_pad);
+}
+
+typedef struct color_t {
+   Uint8 a;
+   Uint8 b;
+   Uint8 c;
+   Uint8 d;
+} color_t;
+
+#if 0
+static void
+printf_64(const char *str, void *var)
+{
+    uint8_t *val = (uint8_t*) var;
+    printf(" *   %s: %02x %02x %02x %02x _ %02x %02x %02x %02x\n",
+           str, val[0], val[1], val[2], val[3], val[4], val[5], val[6], val[7]);
+}
+#endif
+
+/* Interpolated == x0 + frac * (x1 - x0) == x0 * (1 - frac) + x1 * frac */
+
+static SDL_INLINE void
+INTERPOL(const Uint32 *src_x0, const Uint32 *src_x1, int frac0, int frac1, Uint32 *dst)
+{
+    const color_t *c0 = (const color_t *)src_x0;
+    const color_t *c1 = (const color_t *)src_x1;
+    color_t       *cx = (color_t *)dst;
+#if 0
+    cx->a = c0->a + INTEGER(frac0 * (c1->a - c0->a));
+    cx->b = c0->b + INTEGER(frac0 * (c1->b - c0->b));
+    cx->c = c0->c + INTEGER(frac0 * (c1->c - c0->c));
+    cx->d = c0->d + INTEGER(frac0 * (c1->d - c0->d));
+#else
+    cx->a = INTEGER(frac1 * c0->a + frac0 * c1->a);
+    cx->b = INTEGER(frac1 * c0->b + frac0 * c1->b);
+    cx->c = INTEGER(frac1 * c0->c + frac0 * c1->c);
+    cx->d = INTEGER(frac1 * c0->d + frac0 * c1->d);
+#endif
+}
+
+static SDL_INLINE void
+INTERPOL_BILINEAR(const Uint32 *s0, const Uint32 *s1, int frac_w0, int frac_h0, int frac_h1, Uint32 *dst)
+{
+    Uint32 tmp[2];
+    unsigned int frac_w1 = FRAC_ONE - frac_w0;
+
+    /* Vertical first, store to 'tmp' */
+    INTERPOL(s0,     s1,     frac_h0, frac_h1, tmp);
+    INTERPOL(s0 + 1, s1 + 1, frac_h0, frac_h1, tmp + 1);
+
+    /* Horizontal, store to 'dst' */
+    INTERPOL(tmp,   tmp + 1, frac_w0, frac_w1, dst);
+}
+
+static int
+scale_mat(const Uint32 *src, int src_w, int src_h, int src_pitch,
+        Uint32 *dst, int dst_w, int dst_h, int dst_pitch)
+{
+    BILINEAR___START
+
+    for (i = 0; i < dst_h; i++) {
+
+        BILINEAR___HEIGHT
+
+        while (left_pad_w--) {
+            INTERPOL_BILINEAR(src_h0, src_h1, FRAC_ZERO, frac_h0, frac_h1, dst);
+            dst += 1;
+        }
+
+        while (middle--) {
+            const Uint32 *s_00_01;
+            const Uint32 *s_10_11;
+            int index_w = 4 * SRC_INDEX(fp_sum_w);
+            int frac_w = FRAC(fp_sum_w);
+            fp_sum_w += fp_step_w;
+
+/*
+            x00 ... x0_ ..... x01
+            .       .         .
+            .       x         .
+            .       .         .
+            .       .         .
+            x10 ... x1_ ..... x11
+*/
+            s_00_01 = (const Uint32 *)((const Uint8 *)src_h0 + index_w);
+            s_10_11 = (const Uint32 *)((const Uint8 *)src_h1 + index_w);
+
+            INTERPOL_BILINEAR(s_00_01, s_10_11, frac_w, frac_h0, frac_h1, dst);
+
+            dst += 1;
+        }
+
+        while (right_pad_w--) {
+            int index_w = 4 * (src_w - 2);
+            const Uint32 *s_00_01 = (const Uint32 *)((const Uint8 *)src_h0 + index_w);
+            const Uint32 *s_10_11 = (const Uint32 *)((const Uint8 *)src_h1 + index_w);
+            INTERPOL_BILINEAR(s_00_01, s_10_11, FRAC_ONE, frac_h0, frac_h1, dst);
+            dst += 1;
+        }
+        dst = (Uint32 *)((Uint8 *)dst + dst_gap);
+    }
+    return 0;
+}
+
+#if defined(__SSE2__)
+#  define HAVE_SSE2_INTRINSICS 1
+#endif
+
+#if defined(__ARM_NEON)
+#  define HAVE_NEON_INTRINSICS 1
+#  define CAST_uint8x8_t  (uint8x8_t)
+#  define CAST_uint32x2_t (uint32x2_t)
+#endif
+
+#if defined(__WINRT__) || defined(_MSC_VER)
+#  if defined(HAVE_NEON_INTRINSICS)
+#    undef CAST_uint8x8_t
+#    undef CAST_uint32x2_t
+#    define CAST_uint8x8_t
+#    define CAST_uint32x2_t
+#  endif
+#endif
+
+#if defined(HAVE_SSE2_INTRINSICS)
+
+#if 0
+static void
+printf_128(const char *str, __m128i var)
+{
+    uint16_t *val = (uint16_t*) &var;
+    printf(" *   %s: %04x %04x %04x %04x _ %04x %04x %04x %04x\n",
+           str, val[0], val[1], val[2], val[3], val[4], val[5], val[6], val[7]);
+}
+#endif
+
+static SDL_INLINE int
+hasSSE2()
+{
+    static int val = -1;
+    if (val != -1) {
+        return val;
+    }
+    val = SDL_HasSSE2();
+    return val;
+}
+
+static SDL_INLINE void
+INTERPOL_BILINEAR_SSE(const Uint32 *s0, const Uint32 *s1, int frac_w, __m128i v_frac_h0, __m128i v_frac_h1, Uint32 *dst, __m128i zero)
+{
+    __m128i x_00_01, x_10_11; /* Pixels in 4*uint8 in row */
+    __m128i v_frac_w0, k0, l0, d0, e0;
+
+    int f, f2;
+    f = frac_w;
+    f2 = FRAC_ONE - frac_w;
+    v_frac_w0 = _mm_set_epi16(f, f2, f, f2, f, f2, f, f2);
+
+
+    x_00_01 = _mm_loadl_epi64((const __m128i *)s0);  /* Load x00 and x01 */
+    x_10_11 = _mm_loadl_epi64((const __m128i *)s1);
+
+    /* Interpolated == x0 + frac * (x1 - x0) == x0 * (1 - frac) + x1 * frac */
+
+    /* Interpolation vertical */
+    k0 = _mm_mullo_epi16(_mm_unpacklo_epi8(x_00_01, zero), v_frac_h1);
+    l0 = _mm_mullo_epi16(_mm_unpacklo_epi8(x_10_11, zero), v_frac_h0);
+    k0 = _mm_add_epi16(k0, l0);
+
+    /* For perfect match, clear the factionnal part eventually. */
+    /*
+    k0 = _mm_srli_epi16(k0, PRECISION);
+    k0 = _mm_slli_epi16(k0, PRECISION);
+    */
+
+    /* Interpolation horizontal */
+    l0 = _mm_unpacklo_epi64(/* unused */ l0, k0);
+    k0 = _mm_madd_epi16(_mm_unpackhi_epi16(l0, k0), v_frac_w0);
+
+    /* Store 1 pixel */
+    d0 = _mm_srli_epi32(k0, PRECISION * 2);
+    e0 = _mm_packs_epi32(d0, d0);
+    e0 = _mm_packus_epi16(e0, e0);
+    *dst = _mm_cvtsi128_si32(e0);
+}
+
+static int
+scale_mat_SSE(const Uint32 *src, int src_w, int src_h, int src_pitch, Uint32 *dst, int dst_w, int dst_h, int dst_pitch)
+{
+    BILINEAR___START
+
+    for (i = 0; i < dst_h; i++) {
+        int nb_block2;
+        __m128i v_frac_h0;
+        __m128i v_frac_h1;
+        __m128i zero;
+
+        BILINEAR___HEIGHT
+
+        nb_block2 = middle / 2;
+
+        v_frac_h0 = _mm_set_epi16(frac_h0, frac_h0, frac_h0, frac_h0, frac_h0, frac_h0, frac_h0, frac_h0);
+        v_frac_h1 = _mm_set_epi16(frac_h1, frac_h1, frac_h1, frac_h1, frac_h1, frac_h1, frac_h1, frac_h1);
+        zero = _mm_setzero_si128();
+
+        while (left_pad_w--) {
+            INTERPOL_BILINEAR_SSE(src_h0, src_h1, FRAC_ZERO, v_frac_h0, v_frac_h1, dst, zero);
+            dst += 1;
+        }
+
+        while (nb_block2--) {
+            int index_w_0, frac_w_0;
+            int index_w_1, frac_w_1;
+
+            const Uint32 *s_00_01, *s_02_03, *s_10_11, *s_12_13;
+
+            __m128i x_00_01, x_10_11, x_02_03, x_12_13;/* Pixels in 4*uint8 in row */
+            __m128i v_frac_w0, k0, l0, d0, e0;
+            __m128i v_frac_w1, k1, l1, d1, e1;
+
+            int f, f2;
+            index_w_0 = 4 * SRC_INDEX(fp_sum_w);
+            frac_w_0 = FRAC(fp_sum_w);
+            fp_sum_w += fp_step_w;
+            index_w_1 = 4 * SRC_INDEX(fp_sum_w);
+            frac_w_1 = FRAC(fp_sum_w);
+            fp_sum_w += fp_step_w;
+/*
+            x00............ x01   x02...........x03
+            .      .         .     .       .     .
+            j0     f0        j1    j2      f1    j3
+            .      .         .     .       .     .
+            .      .         .     .       .     .
+            .      .         .     .       .     .
+            x10............ x11   x12...........x13
+ */
+            s_00_01 = (const Uint32 *)((const Uint8 *)src_h0 + index_w_0);
+            s_02_03 = (const Uint32 *)((const Uint8 *)src_h0 + index_w_1);
+            s_10_11 = (const Uint32 *)((const Uint8 *)src_h1 + index_w_0);
+            s_12_13 = (const Uint32 *)((const Uint8 *)src_h1 + index_w_1);
+
+            f = frac_w_0;
+            f2 = FRAC_ONE - frac_w_0;
+            v_frac_w0 = _mm_set_epi16(f, f2, f, f2, f, f2, f, f2);
+
+            f = frac_w_1;
+            f2 = FRAC_ONE - frac_w_1;
+            v_frac_w1 = _mm_set_epi16(f, f2, f, f2, f, f2, f, f2);
+
+            x_00_01 = _mm_loadl_epi64((const __m128i *)s_00_01); /* Load x00 and x01 */
+            x_02_03 = _mm_loadl_epi64((const __m128i *)s_02_03);
+            x_10_11 = _mm_loadl_epi64((const __m128i *)s_10_11);
+            x_12_13 = _mm_loadl_epi64((const __m128i *)s_12_13);
+
+            /* Interpolation vertical */
+            k0 = _mm_mullo_epi16(_mm_unpacklo_epi8(x_00_01, zero), v_frac_h1);
+            l0 = _mm_mullo_epi16(_mm_unpacklo_epi8(x_10_11, zero), v_frac_h0);
+            k0 = _mm_add_epi16(k0, l0);
+            k1 = _mm_mullo_epi16(_mm_unpacklo_epi8(x_02_03, zero), v_frac_h1);
+            l1 = _mm_mullo_epi16(_mm_unpacklo_epi8(x_12_13, zero), v_frac_h0);
+            k1 = _mm_add_epi16(k1, l1);
+
+            /* Interpolation horizontal */
+            l0 = _mm_unpacklo_epi64(/* unused */ l0, k0);
+            k0 = _mm_madd_epi16(_mm_unpackhi_epi16(l0, k0), v_frac_w0);
+            l1 = _mm_unpacklo_epi64(/* unused */ l1, k1);
+            k1 = _mm_madd_epi16(_mm_unpackhi_epi16(l1, k1), v_frac_w1);
+
+            /* Store 1 pixel */
+            d0 = _mm_srli_epi32(k0, PRECISION * 2);
+            e0 = _mm_packs_epi32(d0, d0);
+            e0 = _mm_packus_epi16(e0, e0);
+            *dst++ = _mm_cvtsi128_si32(e0);
+
+            /* Store 1 pixel */
+            d1 = _mm_srli_epi32(k1, PRECISION * 2);
+            e1 = _mm_packs_epi32(d1, d1);
+            e1 = _mm_packus_epi16(e1, e1);
+            *dst++ = _mm_cvtsi128_si32(e1);
+        }
+
+        /* Last point */
+        if (middle & 0x1) {
+            const Uint32 *s_00_01;
+            const Uint32 *s_10_11;
+            int index_w = 4 * SRC_INDEX(fp_sum_w);
+            int frac_w = FRAC(fp_sum_w);
+            fp_sum_w += fp_step_w;
+            s_00_01 = (const Uint32 *)((const Uint8 *)src_h0 + index_w);
+            s_10_11 = (const Uint32 *)((const Uint8 *)src_h1 + index_w);
+            INTERPOL_BILINEAR_SSE(s_00_01, s_10_11, frac_w, v_frac_h0, v_frac_h1, dst, zero);
+            dst += 1;
+        }
+
+        while (right_pad_w--) {
+            int index_w = 4 * (src_w - 2);
+            const Uint32 *s_00_01 = (const Uint32 *)((const Uint8 *)src_h0 + index_w);
+            const Uint32 *s_10_11 = (const Uint32 *)((const Uint8 *)src_h1 + index_w);
+            INTERPOL_BILINEAR_SSE(s_00_01, s_10_11, FRAC_ONE, v_frac_h0, v_frac_h1, dst, zero);
+            dst += 1;
+        }
+        dst = (Uint32 *)((Uint8 *)dst + dst_gap);
+    }
+    return 0;
+}
+#endif
+
+#if defined(HAVE_NEON_INTRINSICS)
+
+static SDL_INLINE int
+hasNEON()
+{
+    static int val = -1;
+    if (val != -1) {
+        return val;
+    }
+    val = SDL_HasNEON();
+    return val;
+}
+
+static SDL_INLINE void
+INTERPOL_BILINEAR_NEON(const Uint32 *s0, const Uint32 *s1, int frac_w, uint8x8_t v_frac_h0, uint8x8_t v_frac_h1, Uint32 *dst)
+{
+    uint8x8_t x_00_01, x_10_11; /* Pixels in 4*uint8 in row */
+    uint16x8_t k0;
+    uint32x4_t l0;
+    uint16x8_t d0;
+    uint8x8_t e0;
+
+    x_00_01 = CAST_uint8x8_t vld1_u32(s0); /* Load 2 pixels */
+    x_10_11 = CAST_uint8x8_t vld1_u32(s1);
+
+    /* Interpolated == x0 + frac * (x1 - x0) == x0 * (1 - frac) + x1 * frac */
+    k0 = vmull_u8(x_00_01, v_frac_h1);                          /* k0 := x0 * (1 - frac)    */
+    k0 = vmlal_u8(k0, x_10_11, v_frac_h0);                      /* k0 += x1 * frac          */
+
+    /* k0 now contains 2 interpolated pixels { j0, j1 } */
+    l0 = vshll_n_u16(vget_low_u16(k0), PRECISION);
+    l0 = vmlsl_n_u16(l0, vget_low_u16(k0), frac_w);
+    l0 = vmlal_n_u16(l0, vget_high_u16(k0), frac_w);
+
+    /* Shift and narrow */
+    d0 = vcombine_u16(
+            /* uint16x4_t */ vshrn_n_u32(l0, 2 * PRECISION),
+            /* uint16x4_t */ vshrn_n_u32(l0, 2 * PRECISION)
+            );
+
+    /* Narrow again */
+    e0 = vmovn_u16(d0);
+
+    /* Store 1 pixel */
+    *dst = vget_lane_u32(CAST_uint32x2_t e0, 0);
+}
+
+    static int
+scale_mat_NEON(const Uint32 *src, int src_w, int src_h, int src_pitch, Uint32 *dst, int dst_w, int dst_h, int dst_pitch)
+{
+    BILINEAR___START
+
+    for (i = 0; i < dst_h; i++) {
+        int nb_block4;
+        uint8x8_t v_frac_h0, v_frac_h1;
+
+        BILINEAR___HEIGHT
+
+        nb_block4 = middle / 4;
+
+        v_frac_h0 = vmov_n_u8(frac_h0);
+        v_frac_h1 = vmov_n_u8(frac_h1);
+
+        while (left_pad_w--) {
+            INTERPOL_BILINEAR_NEON(src_h0, src_h1, FRAC_ZERO, v_frac_h0, v_frac_h1, dst);
+            dst += 1;
+        }
+
+        while (nb_block4--) {
+            int index_w_0, frac_w_0;
+            int index_w_1, frac_w_1;
+            int index_w_2, frac_w_2;
+            int index_w_3, frac_w_3;
+
+            const Uint32 *s_00_01, *s_02_03, *s_04_05, *s_06_07;
+            const Uint32 *s_10_11, *s_12_13, *s_14_15, *s_16_17;
+
+            uint8x8_t x_00_01, x_10_11, x_02_03, x_12_13;/* Pixels in 4*uint8 in row */
+            uint8x8_t x_04_05, x_14_15, x_06_07, x_16_17;
+
+            uint16x8_t k0, k1, k2, k3;
+            uint32x4_t l0, l1, l2, l3;
+            uint16x8_t d0, d1;
+            uint8x8_t e0, e1;
+            uint32x4_t f0;
+
+            index_w_0 = 4 * SRC_INDEX(fp_sum_w);
+            frac_w_0  = FRAC(fp_sum_w);
+            fp_sum_w  += fp_step_w;
+            index_w_1 = 4 * SRC_INDEX(fp_sum_w);
+            frac_w_1  = FRAC(fp_sum_w);
+            fp_sum_w  += fp_step_w;
+            index_w_2 = 4 * SRC_INDEX(fp_sum_w);
+            frac_w_2  = FRAC(fp_sum_w);
+            fp_sum_w  += fp_step_w;
+            index_w_3 = 4 * SRC_INDEX(fp_sum_w);
+            frac_w_3  = FRAC(fp_sum_w);
+            fp_sum_w  += fp_step_w;
+
+            s_00_01 = (const Uint32 *)((const Uint8 *)src_h0 + index_w_0);
+            s_02_03 = (const Uint32 *)((const Uint8 *)src_h0 + index_w_1);
+            s_04_05 = (const Uint32 *)((const Uint8 *)src_h0 + index_w_2);
+            s_06_07 = (const Uint32 *)((const Uint8 *)src_h0 + index_w_3);
+            s_10_11 = (const Uint32 *)((const Uint8 *)src_h1 + index_w_0);
+            s_12_13 = (const Uint32 *)((const Uint8 *)src_h1 + index_w_1);
+            s_14_15 = (const Uint32 *)((const Uint8 *)src_h1 + index_w_2);
+            s_16_17 = (const Uint32 *)((const Uint8 *)src_h1 + index_w_3);
+
+            /* Interpolation vertical */
+            x_00_01 = CAST_uint8x8_t vld1_u32(s_00_01); /* Load 2 pixels */
+            x_02_03 = CAST_uint8x8_t vld1_u32(s_02_03);
+            x_04_05 = CAST_uint8x8_t vld1_u32(s_04_05);
+            x_06_07 = CAST_uint8x8_t vld1_u32(s_06_07);
+            x_10_11 = CAST_uint8x8_t vld1_u32(s_10_11);
+            x_12_13 = CAST_uint8x8_t vld1_u32(s_12_13);
+            x_14_15 = CAST_uint8x8_t vld1_u32(s_14_15);
+            x_16_17 = CAST_uint8x8_t vld1_u32(s_16_17);
+
+            /* Interpolated == x0 + frac * (x1 - x0) == x0 * (1 - frac) + x1 * frac */
+            k0 = vmull_u8(x_00_01, v_frac_h1);                          /* k0 := x0 * (1 - frac)    */
+            k0 = vmlal_u8(k0, x_10_11, v_frac_h0);                      /* k0 += x1 * frac          */
+
+            k1 = vmull_u8(x_02_03, v_frac_h1);
+            k1 = vmlal_u8(k1, x_12_13, v_frac_h0);
+
+            k2 = vmull_u8(x_04_05, v_frac_h1);
+            k2 = vmlal_u8(k2, x_14_15, v_frac_h0);
+
+            k3 = vmull_u8(x_06_07, v_frac_h1);
+            k3 = vmlal_u8(k3, x_16_17, v_frac_h0);
+
+            /* k0 now contains 2 interpolated pixels { j0, j1 } */
+            /* k1 now contains 2 interpolated pixels { j2, j3 } */
+            /* k2 now contains 2 interpolated pixels { j4, j5 } */
+            /* k3 now contains 2 interpolated pixels { j6, j7 } */
+
+            l0 = vshll_n_u16(vget_low_u16(k0), PRECISION);
+            l0 = vmlsl_n_u16(l0, vget_low_u16(k0), frac_w_0);
+            l0 = vmlal_n_u16(l0, vget_high_u16(k0), frac_w_0);
+
+            l1 = vshll_n_u16(vget_low_u16(k1), PRECISION);
+            l1 = vmlsl_n_u16(l1, vget_low_u16(k1), frac_w_1);
+            l1 = vmlal_n_u16(l1, vget_high_u16(k1), frac_w_1);
+
+            l2 = vshll_n_u16(vget_low_u16(k2), PRECISION);
+            l2 = vmlsl_n_u16(l2, vget_low_u16(k2), frac_w_2);
+            l2 = vmlal_n_u16(l2, vget_high_u16(k2), frac_w_2);
+
+            l3 = vshll_n_u16(vget_low_u16(k3), PRECISION);
+            l3 = vmlsl_n_u16(l3, vget_low_u16(k3), frac_w_3);
+            l3 = vmlal_n_u16(l3, vget_high_u16(k3), frac_w_3);
+
+            /* shift and narrow */
+            d0 = vcombine_u16(
+                    /* uint16x4_t */ vshrn_n_u32(l0, 2 * PRECISION),
+                    /* uint16x4_t */ vshrn_n_u32(l1, 2 * PRECISION)
+            );
+            /* narrow again */
+            e0 = vmovn_u16(d0);
+
+            /* Shift and narrow */
+            d1 = vcombine_u16(
+                    /* uint16x4_t */ vshrn_n_u32(l2, 2 * PRECISION),
+                    /* uint16x4_t */ vshrn_n_u32(l3, 2 * PRECISION)
+            );
+            /* Narrow again */
+            e1 = vmovn_u16(d1);
+
+            f0 = vcombine_u32(CAST_uint32x2_t e0, CAST_uint32x2_t e1);
+            /* Store 4 pixels */
+            vst1q_u32(dst, f0);
+
+            dst += 4;
+        }
+
+        if (middle & 0x2) {
+            int index_w_0, frac_w_0;
+            int index_w_1, frac_w_1;
+            const Uint32 *s_00_01, *s_02_03;
+            const Uint32 *s_10_11, *s_12_13;
+            uint8x8_t x_00_01, x_10_11, x_02_03, x_12_13;/* Pixels in 4*uint8 in row */
+            uint16x8_t k0, k1;
+            uint32x4_t l0, l1;
+            uint16x8_t d0;
+            uint8x8_t e0;
+
+            index_w_0 = 4 * SRC_INDEX(fp_sum_w);
+            frac_w_0  = FRAC(fp_sum_w);
+            fp_sum_w  += fp_step_w;
+            index_w_1 = 4 * SRC_INDEX(fp_sum_w);
+            frac_w_1  = FRAC(fp_sum_w);
+            fp_sum_w  += fp_step_w;
+/*
+            x00............ x01   x02...........x03
+            .      .         .     .       .     .
+            j0   dest0       j1    j2    dest1   j3
+            .      .         .     .       .     .
+            .      .         .     .       .     .
+            .      .         .     .       .     .
+            x10............ x11   x12...........x13
+*/
+            s_00_01 = (const Uint32 *)((const Uint8 *)src_h0 + index_w_0);
+            s_02_03 = (const Uint32 *)((const Uint8 *)src_h0 + index_w_1);
+            s_10_11 = (const Uint32 *)((const Uint8 *)src_h1 + index_w_0);
+            s_12_13 = (const Uint32 *)((const Uint8 *)src_h1 + index_w_1);
+
+            /* Interpolation vertical */
+            x_00_01 = CAST_uint8x8_t vld1_u32(s_00_01);/* Load 2 pixels */
+            x_02_03 = CAST_uint8x8_t vld1_u32(s_02_03);
+            x_10_11 = CAST_uint8x8_t vld1_u32(s_10_11);
+            x_12_13 = CAST_uint8x8_t vld1_u32(s_12_13);
+
+            /* Interpolated == x0 + frac * (x1 - x0) == x0 * (1 - frac) + x1 * frac */
+            k0 = vmull_u8(x_00_01, v_frac_h1);                          /* k0 := x0 * (1 - frac)    */
+            k0 = vmlal_u8(k0, x_10_11, v_frac_h0);                      /* k0 += x1 * frac          */
+
+            k1 = vmull_u8(x_02_03, v_frac_h1);
+            k1 = vmlal_u8(k1, x_12_13, v_frac_h0);
+
+            /* k0 now contains 2 interpolated pixels { j0, j1 } */
+            /* k1 now contains 2 interpolated pixels { j2, j3 } */
+
+            l0 = vshll_n_u16(vget_low_u16(k0), PRECISION);
+            l0 = vmlsl_n_u16(l0, vget_low_u16(k0), frac_w_0);
+            l0 = vmlal_n_u16(l0, vget_high_u16(k0), frac_w_0);
+
+            l1 = vshll_n_u16(vget_low_u16(k1), PRECISION);
+            l1 = vmlsl_n_u16(l1, vget_low_u16(k1), frac_w_1);
+            l1 = vmlal_n_u16(l1, vget_high_u16(k1), frac_w_1);
+
+            /* Shift and narrow */
+
+            d0 = vcombine_u16(
+                    /* uint16x4_t */ vshrn_n_u32(l0, 2 * PRECISION),
+                    /* uint16x4_t */ vshrn_n_u32(l1, 2 * PRECISION)
+            );
+
+            /* Narrow again */
+            e0 = vmovn_u16(d0);
+
+            /* Store 2 pixels */
+            vst1_u32(dst, CAST_uint32x2_t e0);
+            dst += 2;
+        }
+
+        /* Last point */
+        if (middle & 0x1) {
+            int index_w = 4 * SRC_INDEX(fp_sum_w);
+            int frac_w = FRAC(fp_sum_w);
+            const Uint32 *s_00_01 = (const Uint32 *)((const Uint8 *)src_h0 + index_w);
+            const Uint32 *s_10_11 = (const Uint32 *)((const Uint8 *)src_h1 + index_w);
+            INTERPOL_BILINEAR_NEON(s_00_01, s_10_11, frac_w, v_frac_h0, v_frac_h1, dst);
+            dst += 1;
+        }
+
+        while (right_pad_w--) {
+            int index_w = 4 * (src_w - 2);
+            const Uint32 *s_00_01 = (const Uint32 *)((const Uint8 *)src_h0 + index_w);
+            const Uint32 *s_10_11 = (const Uint32 *)((const Uint8 *)src_h1 + index_w);
+            INTERPOL_BILINEAR_NEON(s_00_01, s_10_11, FRAC_ONE, v_frac_h0, v_frac_h1, dst);
+            dst += 1;
+        }
+
+        dst = (Uint32 *)((Uint8 *)dst + dst_gap);
+    }
+    return 0;
+}
+#endif
+
+int
+SDL_LowerSoftStretchLinear(SDL_Surface *s, const SDL_Rect *srcrect,
+                SDL_Surface *d, const SDL_Rect *dstrect)
+{
+    int ret = -1;
+    int src_w = srcrect->w;
+    int src_h = srcrect->h;
+    int dst_w = dstrect->w;
+    int dst_h = dstrect->h;
+    int src_pitch = s->pitch;
+    int dst_pitch = d->pitch;
+    Uint32 *src = (Uint32 *) ((Uint8 *)s->pixels + srcrect->x * 4 + srcrect->y * src_pitch);
+    Uint32 *dst = (Uint32 *) ((Uint8 *)d->pixels + dstrect->x * 4 + dstrect->y * dst_pitch);
+
+#if defined(HAVE_NEON_INTRINSICS)
+    if (ret == -1 && hasNEON()) {
+        ret = scale_mat_NEON(src, src_w, src_h, src_pitch, dst, dst_w, dst_h, dst_pitch);
+    }
+#endif
+
+#if defined(HAVE_SSE2_INTRINSICS)
+    if (ret == -1 && hasSSE2()) {
+        ret = scale_mat_SSE(src, src_w, src_h, src_pitch, dst, dst_w, dst_h, dst_pitch);
+    }
+#endif
+
+    if (ret == -1) {
+        ret = scale_mat(src, src_w, src_h, src_pitch, dst, dst_w, dst_h, dst_pitch);
+    }
+
+    return ret;
+}
+
+
+#define SDL_SCALE_NEAREST__START                                                        \
+    int i;                                                                              \
+    Uint32 posy, incy;                                                                  \
+    Uint32 posx, incx;                                                                  \
+    int dst_gap;                                                                        \
+    int srcy, n;                                                                        \
+    const Uint32 *src_h0;                                                               \
+    incy = (src_h << 16) / dst_h;                                                       \
+    incx = (src_w << 16) / dst_w;                                                       \
+    dst_gap   = dst_pitch - bpp * dst_w;                                                \
+    posy = incy / 2;                                                                    \
+
+#define SDL_SCALE_NEAREST__HEIGHT                                                       \
+    srcy = (posy >> 16);                                                                \
+    src_h0  = (const Uint32 *)((const Uint8 *)src_ptr + srcy * src_pitch);              \
+    posy += incy;                                                                       \
+    posx = incx / 2;                                                                    \
+    n = dst_w;
+
+
+static int
+scale_mat_nearest_1(const Uint32 *src_ptr, int src_w, int src_h, int src_pitch,
+        Uint32 *dst, int dst_w, int dst_h, int dst_pitch)
+{
+    Uint32 bpp = 1;
+    SDL_SCALE_NEAREST__START
+    for (i = 0; i < dst_h; i++) {
+        SDL_SCALE_NEAREST__HEIGHT
+        while (n--) {
+            const Uint8 *src;
+            int srcx = bpp * (posx >> 16);
+            posx += incx;
+            src = (const Uint8 *)src_h0 + srcx;
+            *(Uint8*)dst = *src;
+            dst = (Uint32 *)((Uint8*)dst + bpp);
+        }
+        dst = (Uint32 *)((Uint8 *)dst + dst_gap);
+    }
+    return 0;
+}
+
+static int
+scale_mat_nearest_2(const Uint32 *src_ptr, int src_w, int src_h, int src_pitch,
+        Uint32 *dst, int dst_w, int dst_h, int dst_pitch)
+{
+    Uint32 bpp = 2;
+    SDL_SCALE_NEAREST__START
+    for (i = 0; i < dst_h; i++) {
+        SDL_SCALE_NEAREST__HEIGHT
+        while (n--) {
+            const Uint16 *src;
+            int srcx = bpp * (posx >> 16);
+            posx += incx;
+            src = (const Uint16 *)((const Uint8 *)src_h0 + srcx);
+            *(Uint16*)dst = *src;
+            dst = (Uint32 *)((Uint8*)dst + bpp);
+        }
+        dst = (Uint32 *)((Uint8 *)dst + dst_gap);
+    }
+    return 0;
+}
+
+static int
+scale_mat_nearest_3(const Uint32 *src_ptr, int src_w, int src_h, int src_pitch,
+        Uint32 *dst, int dst_w, int dst_h, int dst_pitch)
+{
+    Uint32 bpp = 3;
+    SDL_SCALE_NEAREST__START
+    for (i = 0; i < dst_h; i++) {
+        SDL_SCALE_NEAREST__HEIGHT
+        while (n--) {
+            const Uint8 *src;
+            int srcx = bpp * (posx >> 16);
+            posx += incx;
+            src = (const Uint8 *)src_h0 + srcx;
+            ((Uint8*)dst)[0] = src[0];
+            ((Uint8*)dst)[1] = src[1];
+            ((Uint8*)dst)[2] = src[2];
+            dst = (Uint32 *)((Uint8*)dst + bpp);
+        }
+        dst = (Uint32 *)((Uint8 *)dst + dst_gap);
+    }
+    return 0;
+}
+
+static int
+scale_mat_nearest_4(const Uint32 *src_ptr, int src_w, int src_h, int src_pitch,
+        Uint32 *dst, int dst_w, int dst_h, int dst_pitch)
+{
+    Uint32 bpp = 4;
+    SDL_SCALE_NEAREST__START
+    for (i = 0; i < dst_h; i++) {
+        SDL_SCALE_NEAREST__HEIGHT
+        while (n--) {
+            const Uint32 *src;
+            int srcx = bpp * (posx >> 16);
+            posx += incx;
+            src = (const Uint32 *)((const Uint8 *)src_h0 + srcx);
+            *dst = *src;
+            dst = (Uint32 *)((Uint8*)dst + bpp);
+        }
+        dst = (Uint32 *)((Uint8 *)dst + dst_gap);
+    }
+    return 0;
+}
+
+int
+SDL_LowerSoftStretchNearest(SDL_Surface *s, const SDL_Rect *srcrect,
+                SDL_Surface *d, const SDL_Rect *dstrect)
+{
+    int src_w = srcrect->w;
+    int src_h = srcrect->h;
+    int dst_w = dstrect->w;
+    int dst_h = dstrect->h;
+    int src_pitch = s->pitch;
+    int dst_pitch = d->pitch;
+    
+    const int bpp = d->format->BytesPerPixel;
+
+    Uint32 *src = (Uint32 *) ((Uint8 *)s->pixels + srcrect->x * bpp + srcrect->y * src_pitch);
+    Uint32 *dst = (Uint32 *) ((Uint8 *)d->pixels + dstrect->x * bpp + dstrect->y * dst_pitch);
+
+    if (bpp == 4) {
+        return scale_mat_nearest_4(src, src_w, src_h, src_pitch, dst, dst_w, dst_h, dst_pitch);
+    } else if (bpp == 3) {
+        return scale_mat_nearest_3(src, src_w, src_h, src_pitch, dst, dst_w, dst_h, dst_pitch);
+    } else if (bpp == 2) {
+        return scale_mat_nearest_2(src, src_w, src_h, src_pitch, dst, dst_w, dst_h, dst_pitch);
+    } else {
+        return scale_mat_nearest_1(src, src_w, src_h, src_pitch, dst, dst_w, dst_h, dst_pitch);
+    }
 }
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/SDL_surface.c b/Engine/lib/sdl/src/video/SDL_surface.c
index ade68bf34..ec981a29c 100644
--- a/Engine/lib/sdl/src/video/SDL_surface.c
+++ b/Engine/lib/sdl/src/video/SDL_surface.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -26,6 +26,7 @@
 #include "SDL_RLEaccel_c.h"
 #include "SDL_pixels_c.h"
 #include "SDL_yuv_c.h"
+#include "../render/SDL_sysrender.h"
 
 
 /* Check to make sure we can safely check multiplication of surface w and pitch and it won't overflow size_t */
@@ -218,7 +219,7 @@ int
 SDL_SetSurfacePalette(SDL_Surface * surface, SDL_Palette * palette)
 {
     if (!surface) {
-        return SDL_SetError("SDL_SetSurfacePalette() passed a NULL surface");
+        return SDL_InvalidParamError("SDL_SetSurfacePalette(): surface");
     }
     if (SDL_SetPixelFormatPalette(surface->format, palette) < 0) {
         return -1;
@@ -325,11 +326,12 @@ SDL_GetColorKey(SDL_Surface * surface, Uint32 * key)
     return 0;
 }
 
-/* This is a fairly slow function to switch from colorkey to alpha */
+/* This is a fairly slow function to switch from colorkey to alpha 
+   NB: it doesn't handle bpp 1 or 3, because they have no alpha channel */
 static void
 SDL_ConvertColorkeyToAlpha(SDL_Surface * surface, SDL_bool ignore_alpha)
 {
-    int x, y;
+    int x, y, bpp;
 
     if (!surface) {
         return;
@@ -340,82 +342,74 @@ SDL_ConvertColorkeyToAlpha(SDL_Surface * surface, SDL_bool ignore_alpha)
         return;
     }
 
+    bpp = surface->format->BytesPerPixel;
+
     SDL_LockSurface(surface);
 
-    switch (surface->format->BytesPerPixel) {
-    case 2:
-        {
-            Uint16 *row, *spot;
-            Uint16 ckey = (Uint16) surface->map->info.colorkey;
-            Uint16 mask = (Uint16) (~surface->format->Amask);
+    if (bpp == 2) {
+        Uint16 *row, *spot;
+        Uint16 ckey = (Uint16) surface->map->info.colorkey;
+        Uint16 mask = (Uint16) (~surface->format->Amask);
 
-            /* Ignore, or not, alpha in colorkey comparison */
-            if (ignore_alpha) {
-                ckey &= mask;
-                row = (Uint16 *) surface->pixels;
-                for (y = surface->h; y--;) {
-                    spot = row;
-                    for (x = surface->w; x--;) {
-                        if ((*spot & mask) == ckey) {
-                            *spot &= mask;
-                        }
-                        ++spot;
+        /* Ignore, or not, alpha in colorkey comparison */
+        if (ignore_alpha) {
+            ckey &= mask;
+            row = (Uint16 *) surface->pixels;
+            for (y = surface->h; y--;) {
+                spot = row;
+                for (x = surface->w; x--;) {
+                    if ((*spot & mask) == ckey) {
+                        *spot &= mask;
                     }
-                    row += surface->pitch / 2;
+                    ++spot;
                 }
-            } else {
-                row = (Uint16 *) surface->pixels;
-                for (y = surface->h; y--;) {
-                    spot = row;
-                    for (x = surface->w; x--;) {
-                        if (*spot == ckey) {
-                            *spot &= mask;
-                        }
-                        ++spot;
+                row += surface->pitch / 2;
+            }
+        } else {
+            row = (Uint16 *) surface->pixels;
+            for (y = surface->h; y--;) {
+                spot = row;
+                for (x = surface->w; x--;) {
+                    if (*spot == ckey) {
+                        *spot &= mask;
                     }
-                    row += surface->pitch / 2;
+                    ++spot;
                 }
+                row += surface->pitch / 2;
             }
         }
-        break;
-    case 3:
-        /* FIXME */
-        break;
-    case 4:
-        {
-            Uint32 *row, *spot;
-            Uint32 ckey = surface->map->info.colorkey;
-            Uint32 mask = ~surface->format->Amask;
+    } else if (bpp == 4) {
+        Uint32 *row, *spot;
+        Uint32 ckey = surface->map->info.colorkey;
+        Uint32 mask = ~surface->format->Amask;
 
-            /* Ignore, or not, alpha in colorkey comparison */
-            if (ignore_alpha) {
-                ckey &= mask;
-                row = (Uint32 *) surface->pixels;
-                for (y = surface->h; y--;) {
-                    spot = row;
-                    for (x = surface->w; x--;) {
-                        if ((*spot & mask) == ckey) {
-                            *spot &= mask;
-                        }
-                        ++spot;
+        /* Ignore, or not, alpha in colorkey comparison */
+        if (ignore_alpha) {
+            ckey &= mask;
+            row = (Uint32 *) surface->pixels;
+            for (y = surface->h; y--;) {
+                spot = row;
+                for (x = surface->w; x--;) {
+                    if ((*spot & mask) == ckey) {
+                        *spot &= mask;
                     }
-                    row += surface->pitch / 4;
+                    ++spot;
                 }
-            } else {
-                row = (Uint32 *) surface->pixels;
-                for (y = surface->h; y--;) {
-                    spot = row;
-                    for (x = surface->w; x--;) {
-                        if (*spot == ckey) {
-                            *spot &= mask;
-                        }
-                        ++spot;
+                row += surface->pitch / 4;
+            }
+        } else {
+            row = (Uint32 *) surface->pixels;
+            for (y = surface->h; y--;) {
+                spot = row;
+                for (x = surface->w; x--;) {
+                    if (*spot == ckey) {
+                        *spot &= mask;
                     }
-                    row += surface->pitch / 4;
+                    ++spot;
                 }
+                row += surface->pitch / 4;
             }
         }
-        break;
     }
 
     SDL_UnlockSurface(surface);
@@ -652,7 +646,7 @@ SDL_UpperBlit(SDL_Surface * src, const SDL_Rect * srcrect,
 
     /* Make sure the surfaces aren't locked */
     if (!src || !dst) {
-        return SDL_SetError("SDL_UpperBlit: passed a NULL surface");
+        return SDL_InvalidParamError("SDL_UpperBlit(): src/dst");
     }
     if (src->locked || dst->locked) {
         return SDL_SetError("Surfaces must not be locked during blit");
@@ -745,6 +739,14 @@ SDL_UpperBlit(SDL_Surface * src, const SDL_Rect * srcrect,
 int
 SDL_UpperBlitScaled(SDL_Surface * src, const SDL_Rect * srcrect,
               SDL_Surface * dst, SDL_Rect * dstrect)
+{
+    return SDL_PrivateUpperBlitScaled(src, srcrect, dst, dstrect, SDL_ScaleModeNearest);
+}
+
+
+int
+SDL_PrivateUpperBlitScaled(SDL_Surface * src, const SDL_Rect * srcrect,
+              SDL_Surface * dst, SDL_Rect * dstrect, SDL_ScaleMode scaleMode)
 {
     double src_x0, src_y0, src_x1, src_y1;
     double dst_x0, dst_y0, dst_x1, dst_y1;
@@ -755,7 +757,7 @@ SDL_UpperBlitScaled(SDL_Surface * src, const SDL_Rect * srcrect,
 
     /* Make sure the surfaces aren't locked */
     if (!src || !dst) {
-        return SDL_SetError("SDL_UpperBlitScaled: passed a NULL surface");
+        return SDL_InvalidParamError("SDL_UpperBlitScaled(): src/dst");
     }
     if (src->locked || dst->locked) {
         return SDL_SetError("Surfaces must not be locked during blit");
@@ -788,25 +790,25 @@ SDL_UpperBlitScaled(SDL_Surface * src, const SDL_Rect * srcrect,
     if (NULL == dstrect) {
         dst_x0 = 0;
         dst_y0 = 0;
-        dst_x1 = dst_w - 1;
-        dst_y1 = dst_h - 1;
+        dst_x1 = dst_w;
+        dst_y1 = dst_h;
     } else {
         dst_x0 = dstrect->x;
         dst_y0 = dstrect->y;
-        dst_x1 = dst_x0 + dst_w - 1;
-        dst_y1 = dst_y0 + dst_h - 1;
+        dst_x1 = dst_x0 + dst_w;
+        dst_y1 = dst_y0 + dst_h;
     }
 
     if (NULL == srcrect) {
         src_x0 = 0;
         src_y0 = 0;
-        src_x1 = src_w - 1;
-        src_y1 = src_h - 1;
+        src_x1 = src_w;
+        src_y1 = src_h;
     } else {
         src_x0 = srcrect->x;
         src_y0 = srcrect->y;
-        src_x1 = src_x0 + src_w - 1;
-        src_y1 = src_y0 + src_h - 1;
+        src_x1 = src_x0 + src_w;
+        src_y1 = src_y0 + src_h;
 
         /* Clip source rectangle to the source surface */
 
@@ -815,9 +817,9 @@ SDL_UpperBlitScaled(SDL_Surface * src, const SDL_Rect * srcrect,
             src_x0 = 0;
         }
 
-        if (src_x1 >= src->w) {
-            dst_x1 -= (src_x1 - src->w + 1) * scaling_w;
-            src_x1 = src->w - 1;
+        if (src_x1 > src->w) {
+            dst_x1 -= (src_x1 - src->w) * scaling_w;
+            src_x1 = src->w;
         }
 
         if (src_y0 < 0) {
@@ -825,9 +827,9 @@ SDL_UpperBlitScaled(SDL_Surface * src, const SDL_Rect * srcrect,
             src_y0 = 0;
         }
 
-        if (src_y1 >= src->h) {
-            dst_y1 -= (src_y1 - src->h + 1) * scaling_h;
-            src_y1 = src->h - 1;
+        if (src_y1 > src->h) {
+            dst_y1 -= (src_y1 - src->h) * scaling_h;
+            src_y1 = src->h;
         }
     }
 
@@ -844,9 +846,9 @@ SDL_UpperBlitScaled(SDL_Surface * src, const SDL_Rect * srcrect,
         dst_x0 = 0;
     }
 
-    if (dst_x1 >= dst->clip_rect.w) {
-        src_x1 -= (dst_x1 - dst->clip_rect.w + 1) / scaling_w;
-        dst_x1 = dst->clip_rect.w - 1;
+    if (dst_x1 > dst->clip_rect.w) {
+        src_x1 -= (dst_x1 - dst->clip_rect.w) / scaling_w;
+        dst_x1 = dst->clip_rect.w;
     }
 
     if (dst_y0 < 0) {
@@ -854,9 +856,9 @@ SDL_UpperBlitScaled(SDL_Surface * src, const SDL_Rect * srcrect,
         dst_y0 = 0;
     }
 
-    if (dst_y1 >= dst->clip_rect.h) {
-        src_y1 -= (dst_y1 - dst->clip_rect.h + 1) / scaling_h;
-        dst_y1 = dst->clip_rect.h - 1;
+    if (dst_y1 > dst->clip_rect.h) {
+        src_y1 -= (dst_y1 - dst->clip_rect.h) / scaling_h;
+        dst_y1 = dst->clip_rect.h;
     }
 
     /* Translate back to surface coordinates */
@@ -865,23 +867,32 @@ SDL_UpperBlitScaled(SDL_Surface * src, const SDL_Rect * srcrect,
     dst_y0 += dst->clip_rect.y;
     dst_y1 += dst->clip_rect.y;
 
-    final_src.x = (int)SDL_floor(src_x0 + 0.5);
-    final_src.y = (int)SDL_floor(src_y0 + 0.5);
-    final_src.w = (int)SDL_floor(src_x1 + 1 + 0.5) - (int)SDL_floor(src_x0 + 0.5);
-    final_src.h = (int)SDL_floor(src_y1 + 1 + 0.5) - (int)SDL_floor(src_y0 + 0.5);
+    final_src.x = (int)SDL_round(src_x0);
+    final_src.y = (int)SDL_round(src_y0);
+    final_src.w = (int)SDL_round(src_x1 - src_x0);
+    final_src.h = (int)SDL_round(src_y1 - src_y0);
 
-    final_dst.x = (int)SDL_floor(dst_x0 + 0.5);
-    final_dst.y = (int)SDL_floor(dst_y0 + 0.5);
-    final_dst.w = (int)SDL_floor(dst_x1 - dst_x0 + 1.5);
-    final_dst.h = (int)SDL_floor(dst_y1 - dst_y0 + 1.5);
+    final_dst.x = (int)SDL_round(dst_x0);
+    final_dst.y = (int)SDL_round(dst_y0);
+    final_dst.w = (int)SDL_round(dst_x1 - dst_x0);
+    final_dst.h = (int)SDL_round(dst_y1 - dst_y0);
 
-    if (final_dst.w < 0)
-        final_dst.w = 0;
-    if (final_dst.h < 0)
-        final_dst.h = 0;
+    /* Clip again */
+    {
+        SDL_Rect tmp;
+        tmp.x = 0;
+        tmp.y = 0;
+        tmp.w = src->w;
+        tmp.h = src->h;
+        SDL_IntersectRect(&tmp, &final_src, &final_src);
+    }
 
-    if (dstrect)
+    /* Clip again */
+    SDL_IntersectRect(&dst->clip_rect, &final_dst, &final_dst);
+
+    if (dstrect) {
         *dstrect = final_dst;
+    }
 
     if (final_dst.w == 0 || final_dst.h == 0 ||
         final_src.w <= 0 || final_src.h <= 0) {
@@ -889,7 +900,7 @@ SDL_UpperBlitScaled(SDL_Surface * src, const SDL_Rect * srcrect,
         return 0;
     }
 
-    return SDL_LowerBlitScaled(src, &final_src, dst, &final_dst);
+    return SDL_PrivateLowerBlitScaled(src, &final_src, dst, &final_dst, scaleMode);
 }
 
 /**
@@ -899,6 +910,13 @@ SDL_UpperBlitScaled(SDL_Surface * src, const SDL_Rect * srcrect,
 int
 SDL_LowerBlitScaled(SDL_Surface * src, SDL_Rect * srcrect,
                 SDL_Surface * dst, SDL_Rect * dstrect)
+{
+    return SDL_PrivateLowerBlitScaled(src, srcrect, dst, dstrect, SDL_ScaleModeNearest);
+}
+
+int
+SDL_PrivateLowerBlitScaled(SDL_Surface * src, SDL_Rect * srcrect,
+                SDL_Surface * dst, SDL_Rect * dstrect, SDL_ScaleMode scaleMode)
 {
     static const Uint32 complex_copy_flags = (
         SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA |
@@ -906,17 +924,103 @@ SDL_LowerBlitScaled(SDL_Surface * src, SDL_Rect * srcrect,
         SDL_COPY_COLORKEY
     );
 
+    if (srcrect->w > SDL_MAX_UINT16 || srcrect->h > SDL_MAX_UINT16 ||
+        dstrect->w > SDL_MAX_UINT16 || dstrect->h > SDL_MAX_UINT16) {
+        return SDL_SetError("Size too large for scaling");
+    }
+
     if (!(src->map->info.flags & SDL_COPY_NEAREST)) {
         src->map->info.flags |= SDL_COPY_NEAREST;
         SDL_InvalidateMap(src->map);
     }
 
-    if ( !(src->map->info.flags & complex_copy_flags) &&
-         src->format->format == dst->format->format &&
-         !SDL_ISPIXELFORMAT_INDEXED(src->format->format) ) {
-        return SDL_SoftStretch( src, srcrect, dst, dstrect );
+    if (scaleMode == SDL_ScaleModeNearest) {
+        if ( !(src->map->info.flags & complex_copy_flags) &&
+                src->format->format == dst->format->format &&
+                !SDL_ISPIXELFORMAT_INDEXED(src->format->format) ) {
+            return SDL_SoftStretch( src, srcrect, dst, dstrect );
+        } else {
+            return SDL_LowerBlit( src, srcrect, dst, dstrect );
+        }
     } else {
-        return SDL_LowerBlit( src, srcrect, dst, dstrect );
+        if ( !(src->map->info.flags & complex_copy_flags) &&
+             src->format->format == dst->format->format &&
+             !SDL_ISPIXELFORMAT_INDEXED(src->format->format) &&
+             src->format->BytesPerPixel == 4 &&
+             src->format->format != SDL_PIXELFORMAT_ARGB2101010) {
+            /* fast path */
+            return SDL_SoftStretchLinear(src, srcrect, dst, dstrect);
+        } else {
+            /* Use intermediate surface(s) */
+            SDL_Surface *tmp1 = NULL;
+            int ret;
+            SDL_Rect srcrect2;
+            int is_complex_copy_flags = (src->map->info.flags & complex_copy_flags);
+
+            Uint32 flags;
+            Uint8 r, g, b;
+            Uint8 alpha;
+            SDL_BlendMode blendMode;
+
+            /* Save source infos */
+            flags = src->flags;
+            SDL_GetSurfaceColorMod(src, &r, &g, &b);
+            SDL_GetSurfaceAlphaMod(src, &alpha);
+            SDL_GetSurfaceBlendMode(src, &blendMode);
+            srcrect2.x = srcrect->x;
+            srcrect2.y = srcrect->y;
+            srcrect2.w = srcrect->w;
+            srcrect2.h = srcrect->h;
+
+            /* Change source format if not appropriate for scaling */
+            if (src->format->BytesPerPixel != 4 || src->format->format == SDL_PIXELFORMAT_ARGB2101010) {
+                SDL_Rect tmprect;
+                int fmt;
+                tmprect.x = 0;
+                tmprect.y = 0;
+                tmprect.w = src->w;
+                tmprect.h = src->h;
+                if (dst->format->BytesPerPixel == 4 && dst->format->format != SDL_PIXELFORMAT_ARGB2101010) {
+                    fmt = dst->format->format;
+                } else {
+                    fmt = SDL_PIXELFORMAT_ARGB8888;
+                }
+                tmp1 = SDL_CreateRGBSurfaceWithFormat(flags, src->w, src->h, 0, fmt);
+                SDL_LowerBlit(src, srcrect, tmp1, &tmprect);
+
+
+                srcrect2.x = 0;
+                srcrect2.y = 0;
+                SDL_SetSurfaceColorMod(tmp1, r, g, b);
+                SDL_SetSurfaceAlphaMod(tmp1, alpha);
+                SDL_SetSurfaceBlendMode(tmp1, blendMode);
+
+                src = tmp1;
+            }
+
+            /* Intermediate scaling */
+            if (is_complex_copy_flags || src->format->format != dst->format->format) {
+                SDL_Rect tmprect;
+                SDL_Surface *tmp2 = SDL_CreateRGBSurfaceWithFormat(flags, dstrect->w, dstrect->h, 0, src->format->format);
+                SDL_SoftStretchLinear(src, &srcrect2, tmp2, NULL);
+
+                SDL_SetSurfaceColorMod(tmp2, r, g, b);
+                SDL_SetSurfaceAlphaMod(tmp2, alpha);
+                SDL_SetSurfaceBlendMode(tmp2, blendMode);
+
+                tmprect.x = 0;
+                tmprect.y = 0;
+                tmprect.w = dstrect->w;
+                tmprect.h = dstrect->h;
+                ret = SDL_LowerBlit(tmp2, &tmprect, dst, dstrect);
+                SDL_FreeSurface(tmp2);
+            } else {
+                ret = SDL_SoftStretchLinear(src, &srcrect2, dst, dstrect);
+            }
+
+            SDL_FreeSurface(tmp1);
+            return ret;
+        }
     }
 }
 
@@ -988,6 +1092,7 @@ SDL_ConvertSurface(SDL_Surface * surface, const SDL_PixelFormat * format,
     int palette_ck_value = 0;
     SDL_bool palette_has_alpha = SDL_FALSE;
     Uint8 *palette_saved_alpha = NULL;
+    int palette_saved_alpha_ncolors = 0;
 
     if (!surface) {
         SDL_InvalidParamError("surface");
@@ -1069,8 +1174,9 @@ SDL_ConvertSurface(SDL_Surface * surface, const SDL_PixelFormat * format,
         /* Set opaque and backup palette alpha values */
         if (set_opaque) {
             int i;
-            palette_saved_alpha = SDL_stack_alloc(Uint8, surface->format->palette->ncolors);
-            for (i = 0; i < surface->format->palette->ncolors; i++) {
+            palette_saved_alpha_ncolors = surface->format->palette->ncolors;
+            palette_saved_alpha = SDL_stack_alloc(Uint8, palette_saved_alpha_ncolors);
+            for (i = 0; i < palette_saved_alpha_ncolors; i++) {
                 palette_saved_alpha[i] = surface->format->palette->colors[i].a;
                 surface->format->palette->colors[i].a = SDL_ALPHA_OPAQUE;
             }
@@ -1097,7 +1203,7 @@ SDL_ConvertSurface(SDL_Surface * surface, const SDL_PixelFormat * format,
     /* Restore palette alpha values */
     if (palette_saved_alpha) {
         int i;
-        for (i = 0; i < surface->format->palette->ncolors; i++) {
+        for (i = 0; i < palette_saved_alpha_ncolors; i++) {
             surface->format->palette->colors[i].a = palette_saved_alpha[i];
         }
         SDL_stack_free(palette_saved_alpha);
@@ -1275,7 +1381,12 @@ int SDL_ConvertPixels(int width, int height,
     void *nonconst_src = (void *) src;
     int ret;
 
-    /* Check to make sure we are blitting somewhere, so we don't crash */
+    if (!src) {
+        return SDL_InvalidParamError("src");
+    }
+    if (!src_pitch) {
+        return SDL_InvalidParamError("src_pitch");
+    }
     if (!dst) {
         return SDL_InvalidParamError("dst");
     }
@@ -1293,8 +1404,7 @@ int SDL_ConvertPixels(int width, int height,
     }
 #else
     if (SDL_ISPIXELFORMAT_FOURCC(src_format) || SDL_ISPIXELFORMAT_FOURCC(dst_format)) {
-        SDL_SetError("SDL not built with YUV support");
-        return -1;
+        return SDL_SetError("SDL not built with YUV support");
     }
 #endif
 
@@ -1334,6 +1444,68 @@ int SDL_ConvertPixels(int width, int height,
     return ret;
 }
 
+/*
+ * Premultiply the alpha on a block of pixels
+ *
+ * This is currently only implemented for SDL_PIXELFORMAT_ARGB8888
+ *
+ * Here are some ideas for optimization:
+ * https://github.com/Wizermil/premultiply_alpha/tree/master/premultiply_alpha
+ * https://developer.arm.com/documentation/101964/0201/Pre-multiplied-alpha-channel-data
+ */
+int SDL_PremultiplyAlpha(int width, int height,
+                         Uint32 src_format, const void * src, int src_pitch,
+                         Uint32 dst_format, void * dst, int dst_pitch)
+{
+    int c;
+    Uint32 srcpixel;
+    Uint32 srcR, srcG, srcB, srcA;
+    Uint32 dstpixel;
+    Uint32 dstR, dstG, dstB, dstA;
+
+    if (!src) {
+        return SDL_InvalidParamError("src");
+    }
+    if (!src_pitch) {
+        return SDL_InvalidParamError("src_pitch");
+    }
+    if (!dst) {
+        return SDL_InvalidParamError("dst");
+    }
+    if (!dst_pitch) {
+        return SDL_InvalidParamError("dst_pitch");
+    }
+    if (src_format != SDL_PIXELFORMAT_ARGB8888) {
+        return SDL_InvalidParamError("src_format");
+    }
+    if (dst_format != SDL_PIXELFORMAT_ARGB8888) {
+        return SDL_InvalidParamError("dst_format");
+    }
+
+    while (height--) {
+        const Uint32 *src_px = (const Uint32 *)src;
+        Uint32 *dst_px = (Uint32 *)dst;
+        for (c = width; c; --c) {
+            /* Component bytes extraction. */
+            srcpixel = *src_px++;
+            RGBA_FROM_ARGB8888(srcpixel, srcR, srcG, srcB, srcA);
+
+            /* Alpha pre-multiplication of each component. */
+            dstA = srcA;
+            dstR = (srcA * srcR) / 255;
+            dstG = (srcA * srcG) / 255;
+            dstB = (srcA * srcB) / 255;
+
+            /* ARGB8888 pixel recomposition. */
+            ARGB8888_FROM_RGBA(dstpixel, dstR, dstG, dstB, dstA);
+            *dst_px++ = dstpixel;
+        }
+        src = (const Uint8 *)src + src_pitch;
+        dst = (Uint8 *)dst + dst_pitch;
+    }
+    return 0;
+}
+
 /*
  * Free a surface created by the above function.
  */
diff --git a/Engine/lib/sdl/src/video/SDL_sysvideo.h b/Engine/lib/sdl/src/video/SDL_sysvideo.h
index c8c425b6b..e2a65045b 100644
--- a/Engine/lib/sdl/src/video/SDL_sysvideo.h
+++ b/Engine/lib/sdl/src/video/SDL_sysvideo.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -83,6 +83,7 @@ struct SDL_Window
     int max_w, max_h;
     Uint32 flags;
     Uint32 last_fullscreen_flags;
+    Uint32 display_index;
 
     /* Stored position and size for windowed mode */
     SDL_Rect windowed;
@@ -102,6 +103,8 @@ struct SDL_Window
     SDL_bool is_destroying;
     SDL_bool is_dropping;       /* drag/drop in progress, expecting SDL_SendDropComplete(). */
 
+    SDL_Rect mouse_rect;
+
     SDL_WindowShaper *shaper;
 
     SDL_HitTest hit_test;
@@ -229,15 +232,20 @@ struct SDL_VideoDevice
     void (*RestoreWindow) (_THIS, SDL_Window * window);
     void (*SetWindowBordered) (_THIS, SDL_Window * window, SDL_bool bordered);
     void (*SetWindowResizable) (_THIS, SDL_Window * window, SDL_bool resizable);
+    void (*SetWindowAlwaysOnTop) (_THIS, SDL_Window * window, SDL_bool on_top);
     void (*SetWindowFullscreen) (_THIS, SDL_Window * window, SDL_VideoDisplay * display, SDL_bool fullscreen);
     int (*SetWindowGammaRamp) (_THIS, SDL_Window * window, const Uint16 * ramp);
     int (*GetWindowGammaRamp) (_THIS, SDL_Window * window, Uint16 * ramp);
-    void (*SetWindowGrab) (_THIS, SDL_Window * window, SDL_bool grabbed);
+    void* (*GetWindowICCProfile) (_THIS, SDL_Window * window, size_t* size);
+    void (*SetWindowMouseRect)(_THIS, SDL_Window * window);
+    void (*SetWindowMouseGrab) (_THIS, SDL_Window * window, SDL_bool grabbed);
+    void (*SetWindowKeyboardGrab) (_THIS, SDL_Window * window, SDL_bool grabbed);
     void (*DestroyWindow) (_THIS, SDL_Window * window);
     int (*CreateWindowFramebuffer) (_THIS, SDL_Window * window, Uint32 * format, void ** pixels, int *pitch);
     int (*UpdateWindowFramebuffer) (_THIS, SDL_Window * window, const SDL_Rect * rects, int numrects);
     void (*DestroyWindowFramebuffer) (_THIS, SDL_Window * window);
     void (*OnWindowEnter) (_THIS, SDL_Window * window);
+    int (*FlashWindow) (_THIS, SDL_Window * window, SDL_FlashOperation operation);
 
     /* * * */
     /*
@@ -288,6 +296,8 @@ struct SDL_VideoDevice
     /*
      * Event manager functions
      */
+    int (*WaitEventTimeout) (_THIS, int timeout);
+    void (*SendWakeupEvent) (_THIS, SDL_Window *window);
     void (*PumpEvents) (_THIS);
 
     /* Suspend the screensaver */
@@ -297,6 +307,8 @@ struct SDL_VideoDevice
     void (*StartTextInput) (_THIS);
     void (*StopTextInput) (_THIS);
     void (*SetTextInputRect) (_THIS, SDL_Rect *rect);
+    void (*ClearComposition) (_THIS);
+    SDL_bool (*IsTextInputShown) (_THIS);
 
     /* Screen keyboard */
     SDL_bool (*HasScreenKeyboardSupport) (_THIS);
@@ -320,8 +332,11 @@ struct SDL_VideoDevice
 
     /* * * */
     /* Data common to all drivers */
+    SDL_bool checked_texture_framebuffer;
     SDL_bool is_dummy;
     SDL_bool suspend_screensaver;
+    SDL_Window *wakeup_window;
+    SDL_mutex *wakeup_lock; /* Initialized only if WaitEventTimeout/SendWakeupEvent are supported */
     int num_displays;
     SDL_VideoDisplay *displays;
     SDL_Window *windows;
@@ -329,6 +344,7 @@ struct SDL_VideoDevice
     Uint8 window_magic;
     Uint32 next_object_id;
     char *clipboard_text;
+    SDL_bool setting_display_mode;
 
     /* * * */
     /* Data used by the GL drivers */
@@ -427,6 +443,8 @@ extern VideoBootStrap PND_bootstrap;
 extern VideoBootStrap UIKIT_bootstrap;
 extern VideoBootStrap Android_bootstrap;
 extern VideoBootStrap PSP_bootstrap;
+extern VideoBootStrap VITA_bootstrap;
+extern VideoBootStrap RISCOS_bootstrap;
 extern VideoBootStrap RPI_bootstrap;
 extern VideoBootStrap KMSDRM_bootstrap;
 extern VideoBootStrap KMSDRM_LEGACY_bootstrap;
@@ -445,6 +463,9 @@ extern int SDL_AddBasicVideoDisplay(const SDL_DisplayMode * desktop_mode);
 extern int SDL_AddVideoDisplay(const SDL_VideoDisplay * display, SDL_bool send_event);
 extern void SDL_DelVideoDisplay(int index);
 extern SDL_bool SDL_AddDisplayMode(SDL_VideoDisplay *display, const SDL_DisplayMode * mode);
+extern void SDL_SetCurrentDisplayMode(SDL_VideoDisplay *display, const SDL_DisplayMode * mode);
+extern void SDL_SetDesktopDisplayMode(SDL_VideoDisplay *display, const SDL_DisplayMode * mode);
+extern void SDL_ResetDisplayModes(int displayIndex);
 extern int SDL_GetIndexOfDisplay(SDL_VideoDisplay *display);
 extern SDL_VideoDisplay *SDL_GetDisplay(int displayIndex);
 extern SDL_VideoDisplay *SDL_GetDisplayForWindow(SDL_Window *window);
@@ -458,6 +479,7 @@ extern SDL_bool SDL_HasWindows(void);
 
 extern void SDL_OnWindowShown(SDL_Window * window);
 extern void SDL_OnWindowHidden(SDL_Window * window);
+extern void SDL_OnWindowMoved(SDL_Window * window);
 extern void SDL_OnWindowResized(SDL_Window * window);
 extern void SDL_OnWindowMinimized(SDL_Window * window);
 extern void SDL_OnWindowRestored(SDL_Window * window);
diff --git a/Engine/lib/sdl/src/video/SDL_video.c b/Engine/lib/sdl/src/video/SDL_video.c
index a0ca32243..3be98806d 100644
--- a/Engine/lib/sdl/src/video/SDL_video.c
+++ b/Engine/lib/sdl/src/video/SDL_video.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -61,12 +61,12 @@ static VideoBootStrap *bootstrap[] = {
 #if SDL_VIDEO_DRIVER_COCOA
     &COCOA_bootstrap,
 #endif
-#if SDL_VIDEO_DRIVER_X11
-    &X11_bootstrap,
-#endif
 #if SDL_VIDEO_DRIVER_WAYLAND
     &Wayland_bootstrap,
 #endif
+#if SDL_VIDEO_DRIVER_X11
+    &X11_bootstrap,
+#endif
 #if SDL_VIDEO_DRIVER_VIVANTE
     &VIVANTE_bootstrap,
 #endif
@@ -94,9 +94,14 @@ static VideoBootStrap *bootstrap[] = {
 #if SDL_VIDEO_DRIVER_PSP
     &PSP_bootstrap,
 #endif
+#if SDL_VIDEO_DRIVER_VITA
+    &VITA_bootstrap,
+#endif
 #if SDL_VIDEO_DRIVER_KMSDRM
     &KMSDRM_bootstrap,
-    &KMSDRM_LEGACY_bootstrap,
+#endif
+#if SDL_VIDEO_DRIVER_RISCOS
+    &RISCOS_bootstrap,
 #endif
 #if SDL_VIDEO_DRIVER_RPI
     &RPI_bootstrap,
@@ -123,14 +128,11 @@ static VideoBootStrap *bootstrap[] = {
     NULL
 };
 
-static SDL_VideoDevice *_this = NULL;
-
 #define CHECK_WINDOW_MAGIC(window, retval) \
     if (!_this) { \
         SDL_UninitializedVideo(); \
         return retval; \
     } \
-    SDL_assert(window && window->magic == &_this->window_magic); \
     if (!window || window->magic != &_this->window_magic) { \
         SDL_SetError("Invalid window"); \
         return retval; \
@@ -141,8 +143,6 @@ static SDL_VideoDevice *_this = NULL;
         SDL_UninitializedVideo(); \
         return retval; \
     } \
-    SDL_assert(_this->displays != NULL); \
-    SDL_assert(displayIndex >= 0 && displayIndex < _this->num_displays); \
     if (displayIndex < 0 || displayIndex >= _this->num_displays) { \
         SDL_SetError("displayIndex must be in the range 0 - %d", \
                      _this->num_displays - 1); \
@@ -170,137 +170,58 @@ typedef struct {
     int bytes_per_pixel;
 } SDL_WindowTextureData;
 
-static SDL_bool
-ShouldUseTextureFramebuffer()
-{
-    const char *hint;
-
-    /* If there's no native framebuffer support then there's no option */
-    if (!_this->CreateWindowFramebuffer) {
-        return SDL_TRUE;
-    }
-
-    /* If this is the dummy driver there is no texture support */
-    if (_this->is_dummy) {
-        return SDL_FALSE;
-    }
-
-    /* If the user has specified a software renderer we can't use a
-       texture framebuffer, or renderer creation will go recursive.
-     */
-    hint = SDL_GetHint(SDL_HINT_RENDER_DRIVER);
-    if (hint && SDL_strcasecmp(hint, "software") == 0) {
-        return SDL_FALSE;
-    }
-
-    /* See if the user or application wants a specific behavior */
-    hint = SDL_GetHint(SDL_HINT_FRAMEBUFFER_ACCELERATION);
-    if (hint) {
-        if (*hint == '0' || SDL_strcasecmp(hint, "false") == 0) {
-            return SDL_FALSE;
-        } else {
-            return SDL_TRUE;
-        }
-    }
-
-    /* Each platform has different performance characteristics */
-#if defined(__WIN32__)
-    /* GDI BitBlt() is way faster than Direct3D dynamic textures right now.
-     */
-    return SDL_FALSE;
-
-#elif defined(__MACOSX__)
-    /* Mac OS X uses OpenGL as the native fast path (for cocoa and X11) */
-    return SDL_TRUE;
-
-#elif defined(__LINUX__)
-    /* Properly configured OpenGL drivers are faster than MIT-SHM */
-#if SDL_VIDEO_OPENGL
-    /* Ugh, find a way to cache this value! */
-    {
-        SDL_Window *window;
-        SDL_GLContext context;
-        SDL_bool hasAcceleratedOpenGL = SDL_FALSE;
-
-        window = SDL_CreateWindow("OpenGL test", -32, -32, 32, 32, SDL_WINDOW_OPENGL|SDL_WINDOW_HIDDEN);
-        if (window) {
-            context = SDL_GL_CreateContext(window);
-            if (context) {
-                const GLubyte *(APIENTRY * glGetStringFunc) (GLenum);
-                const char *vendor = NULL;
-
-                glGetStringFunc = SDL_GL_GetProcAddress("glGetString");
-                if (glGetStringFunc) {
-                    vendor = (const char *) glGetStringFunc(GL_VENDOR);
-                }
-                /* Add more vendors here at will... */
-                if (vendor &&
-                    (SDL_strstr(vendor, "ATI Technologies") ||
-                     SDL_strstr(vendor, "NVIDIA"))) {
-                    hasAcceleratedOpenGL = SDL_TRUE;
-                }
-                SDL_GL_DeleteContext(context);
-            }
-            SDL_DestroyWindow(window);
-        }
-        return hasAcceleratedOpenGL;
-    }
-#elif SDL_VIDEO_OPENGL_ES || SDL_VIDEO_OPENGL_ES2
-    /* Let's be optimistic about this! */
-    return SDL_TRUE;
-#else
-    return SDL_FALSE;
-#endif
-
-#else
-    /* Play it safe, assume that if there is a framebuffer driver that it's
-       optimized for the current platform.
-    */
-    return SDL_FALSE;
-#endif
-}
 
 static int
-SDL_CreateWindowTexture(SDL_VideoDevice *unused, SDL_Window * window, Uint32 * format, void ** pixels, int *pitch)
+SDL_CreateWindowTexture(SDL_VideoDevice *_this, SDL_Window * window, Uint32 * format, void ** pixels, int *pitch)
 {
-    SDL_WindowTextureData *data;
+    SDL_RendererInfo info;
+    SDL_WindowTextureData *data = SDL_GetWindowData(window, SDL_WINDOWTEXTUREDATA);
+    int i;
 
-    data = SDL_GetWindowData(window, SDL_WINDOWTEXTUREDATA);
     if (!data) {
         SDL_Renderer *renderer = NULL;
-        int i;
         const char *hint = SDL_GetHint(SDL_HINT_FRAMEBUFFER_ACCELERATION);
-
-        /* Check to see if there's a specific driver requested */
-        if (hint && *hint != '0' && *hint != '1' &&
+        const SDL_bool specific_accelerated_renderer = (
+            hint && *hint != '0' && *hint != '1' &&
             SDL_strcasecmp(hint, "true") != 0 &&
             SDL_strcasecmp(hint, "false") != 0 &&
-            SDL_strcasecmp(hint, "software") != 0) {
+            SDL_strcasecmp(hint, "software") != 0
+        );
+
+        /* Check to see if there's a specific driver requested */
+        if (specific_accelerated_renderer) {
             for (i = 0; i < SDL_GetNumRenderDrivers(); ++i) {
-                SDL_RendererInfo info;
                 SDL_GetRenderDriverInfo(i, &info);
                 if (SDL_strcasecmp(info.name, hint) == 0) {
                     renderer = SDL_CreateRenderer(window, i, 0);
                     break;
                 }
             }
-        }
-        
-        if (!renderer) {
+            if (!renderer || (SDL_GetRendererInfo(renderer, &info) == -1)) {
+                if (renderer) { SDL_DestroyRenderer(renderer); }
+                return SDL_SetError("Requested renderer for " SDL_HINT_FRAMEBUFFER_ACCELERATION " is not available");
+            }
+            /* if it was specifically requested, even if SDL_RENDERER_ACCELERATED isn't set, we'll accept this renderer. */
+        } else {
             for (i = 0; i < SDL_GetNumRenderDrivers(); ++i) {
-                SDL_RendererInfo info;
                 SDL_GetRenderDriverInfo(i, &info);
                 if (SDL_strcmp(info.name, "software") != 0) {
                     renderer = SDL_CreateRenderer(window, i, 0);
-                    if (renderer) {
-                        break;
+                    if (renderer && (SDL_GetRendererInfo(renderer, &info) == 0) && (info.flags & SDL_RENDERER_ACCELERATED)) {
+                        break;  /* this will work. */
+                    }
+                    if (renderer) {  /* wasn't accelerated, etc, skip it. */
+                        SDL_DestroyRenderer(renderer);
+                        renderer = NULL;
                     }
                 }
             }
+            if (!renderer) {
+                return SDL_SetError("No hardware accelerated renderers available");
+            }
         }
-        if (!renderer) {
-            return SDL_SetError("No hardware accelerated renderers available");
-        }
+
+        SDL_assert(renderer != NULL);  /* should have explicitly checked this above. */
 
         /* Create the data after we successfully create the renderer (bug #1116) */
         data = (SDL_WindowTextureData *)SDL_calloc(1, sizeof(*data));
@@ -311,6 +232,10 @@ SDL_CreateWindowTexture(SDL_VideoDevice *unused, SDL_Window * window, Uint32 * f
         SDL_SetWindowData(window, SDL_WINDOWTEXTUREDATA, data);
 
         data->renderer = renderer;
+    } else {
+        if (SDL_GetRendererInfo(data->renderer, &info) == -1) {
+            return -1;
+        }
     }
 
     /* Free any old texture and pixel data */
@@ -321,23 +246,14 @@ SDL_CreateWindowTexture(SDL_VideoDevice *unused, SDL_Window * window, Uint32 * f
     SDL_free(data->pixels);
     data->pixels = NULL;
 
-    {
-        SDL_RendererInfo info;
-        Uint32 i;
+    /* Find the first format without an alpha channel */
+    *format = info.texture_formats[0];
 
-        if (SDL_GetRendererInfo(data->renderer, &info) < 0) {
-            return -1;
-        }
-
-        /* Find the first format without an alpha channel */
-        *format = info.texture_formats[0];
-
-        for (i = 0; i < info.num_texture_formats; ++i) {
-            if (!SDL_ISPIXELFORMAT_FOURCC(info.texture_formats[i]) &&
-                    !SDL_ISPIXELFORMAT_ALPHA(info.texture_formats[i])) {
-                *format = info.texture_formats[i];
-                break;
-            }
+    for (i = 0; i < (int) info.num_texture_formats; ++i) {
+        if (!SDL_ISPIXELFORMAT_FOURCC(info.texture_formats[i]) &&
+            !SDL_ISPIXELFORMAT_ALPHA(info.texture_formats[i])) {
+            *format = info.texture_formats[i];
+            break;
         }
     }
 
@@ -353,7 +269,7 @@ SDL_CreateWindowTexture(SDL_VideoDevice *unused, SDL_Window * window, Uint32 * f
     data->pitch = (((window->w * data->bytes_per_pixel) + 3) & ~3);
 
     {
-        /* Make static analysis happy about potential malloc(0) calls. */
+        /* Make static analysis happy about potential SDL_malloc(0) calls. */
         const size_t allocsize = window->h * data->pitch;
         data->pixels = SDL_malloc((allocsize > 0) ? allocsize : 1);
         if (!data->pixels) {
@@ -370,6 +286,8 @@ SDL_CreateWindowTexture(SDL_VideoDevice *unused, SDL_Window * window, Uint32 * f
     return 0;
 }
 
+static SDL_VideoDevice *_this = NULL;
+
 static int
 SDL_UpdateWindowTexture(SDL_VideoDevice *unused, SDL_Window * window, const SDL_Rect * rects, int numrects)
 {
@@ -419,7 +337,6 @@ SDL_DestroyWindowTexture(SDL_VideoDevice *unused, SDL_Window * window)
     SDL_free(data);
 }
 
-
 static int
 cmpmodes(const void *A, const void *B)
 {
@@ -471,6 +388,10 @@ SDL_VideoInit(const char *driver_name)
     SDL_VideoDevice *video;
     int index;
     int i;
+    SDL_bool init_events = SDL_FALSE;
+    SDL_bool init_keyboard = SDL_FALSE;
+    SDL_bool init_mouse = SDL_FALSE;
+    SDL_bool init_touch = SDL_FALSE;
 
     /* Check to make sure we don't overwrite '_this' */
     if (_this != NULL) {
@@ -482,25 +403,45 @@ SDL_VideoInit(const char *driver_name)
 #endif
 
     /* Start the event loop */
-    if (SDL_InitSubSystem(SDL_INIT_EVENTS) < 0 ||
-        SDL_KeyboardInit() < 0 ||
-        SDL_MouseInit() < 0 ||
-        SDL_TouchInit() < 0) {
-        return -1;
+    if (SDL_InitSubSystem(SDL_INIT_EVENTS) < 0) {
+        goto pre_driver_error;
     }
+    init_events = SDL_TRUE;
+    if (SDL_KeyboardInit() < 0) {
+        goto pre_driver_error;
+    }
+    init_keyboard = SDL_TRUE;
+    if (SDL_MouseInit() < 0) {
+        goto pre_driver_error;
+    }
+    init_mouse = SDL_TRUE;
+    if (SDL_TouchInit() < 0) {
+        goto pre_driver_error;
+    }
+    init_touch = SDL_TRUE;
 
     /* Select the proper video driver */
-    index = 0;
+    i = index = 0;
     video = NULL;
     if (driver_name == NULL) {
         driver_name = SDL_getenv("SDL_VIDEODRIVER");
     }
-    if (driver_name != NULL) {
-        for (i = 0; bootstrap[i]; ++i) {
-            if (SDL_strncasecmp(bootstrap[i]->name, driver_name, SDL_strlen(driver_name)) == 0) {
-                video = bootstrap[i]->create(index);
-                break;
+    if (driver_name != NULL && *driver_name != 0) {
+        const char *driver_attempt = driver_name;
+        while(driver_attempt != NULL && *driver_attempt != 0 && video == NULL) {
+            const char* driver_attempt_end = SDL_strchr(driver_attempt, ',');
+            size_t driver_attempt_len = (driver_attempt_end != NULL) ? (driver_attempt_end - driver_attempt)
+                                                                     : SDL_strlen(driver_attempt);
+
+            for (i = 0; bootstrap[i]; ++i) {
+                if ((driver_attempt_len == SDL_strlen(bootstrap[i]->name)) &&
+                    (SDL_strncasecmp(bootstrap[i]->name, driver_attempt, driver_attempt_len) == 0)) {
+                    video = bootstrap[i]->create(index);
+                    break;
+                }
             }
+
+            driver_attempt = (driver_attempt_end != NULL) ? (driver_attempt_end + 1) : NULL;
         }
     } else {
         for (i = 0; bootstrap[i]; ++i) {
@@ -512,10 +453,15 @@ SDL_VideoInit(const char *driver_name)
     }
     if (video == NULL) {
         if (driver_name) {
-            return SDL_SetError("%s not available", driver_name);
+            SDL_SetError("%s not available", driver_name);
+            goto pre_driver_error;
         }
-        return SDL_SetError("No available video device");
+        SDL_SetError("No available video device");
+        goto pre_driver_error;
     }
+    
+    /* From this point on, use SDL_VideoQuit to cleanup on error, rather than
+    pre_driver_error. */
     _this = video;
     _this->name = bootstrap[i]->name;
     _this->next_object_id = 1;
@@ -541,13 +487,6 @@ SDL_VideoInit(const char *driver_name)
         return SDL_SetError("The video driver did not add any displays");
     }
 
-    /* Add the renderer framebuffer emulation if desired */
-    if (ShouldUseTextureFramebuffer()) {
-        _this->CreateWindowFramebuffer = SDL_CreateWindowTexture;
-        _this->UpdateWindowFramebuffer = SDL_UpdateWindowTexture;
-        _this->DestroyWindowFramebuffer = SDL_DestroyWindowTexture;
-    }
-
     /* Disable the screen saver by default. This is a change from <= 2.0.1,
        but most things using SDL are games or media players; you wouldn't
        want a screensaver to trigger if you're playing exclusively with a
@@ -571,6 +510,22 @@ SDL_VideoInit(const char *driver_name)
 
     /* We're ready to go! */
     return 0;
+
+pre_driver_error:
+    SDL_assert(_this == NULL);
+    if (init_touch) {
+        SDL_TouchQuit();
+    }
+    if (init_mouse) {
+        SDL_MouseQuit();
+    }
+    if (init_keyboard) {
+        SDL_KeyboardQuit();
+    }
+    if (init_events) {
+        SDL_QuitSubSystem(SDL_INIT_EVENTS);
+    }
+    return -1;
 }
 
 const char *
@@ -789,7 +744,7 @@ SDL_GetDisplayOrientation(int displayIndex)
 }
 
 SDL_bool
-SDL_AddDisplayMode(SDL_VideoDisplay * display,  const SDL_DisplayMode * mode)
+SDL_AddDisplayMode(SDL_VideoDisplay * display, const SDL_DisplayMode * mode)
 {
     SDL_DisplayMode *modes;
     int i, nmodes;
@@ -824,6 +779,18 @@ SDL_AddDisplayMode(SDL_VideoDisplay * display,  const SDL_DisplayMode * mode)
     return SDL_TRUE;
 }
 
+void
+SDL_SetCurrentDisplayMode(SDL_VideoDisplay * display, const SDL_DisplayMode * mode)
+{
+    SDL_memcpy(&display->current_mode, mode, sizeof(*mode));
+}
+
+void
+SDL_SetDesktopDisplayMode(SDL_VideoDisplay * display, const SDL_DisplayMode * mode)
+{
+    SDL_memcpy(&display->desktop_mode, mode, sizeof(*mode));
+}
+
 static int
 SDL_GetNumDisplayModesForDisplay(SDL_VideoDisplay * display)
 {
@@ -843,6 +810,25 @@ SDL_GetNumDisplayModes(int displayIndex)
     return SDL_GetNumDisplayModesForDisplay(&_this->displays[displayIndex]);
 }
 
+void
+SDL_ResetDisplayModes(int displayIndex)
+{
+    SDL_VideoDisplay *display;
+    int i;
+
+    CHECK_DISPLAY_INDEX(displayIndex,);
+
+    display = &_this->displays[displayIndex];
+    for (i = display->num_display_modes; i--;) {
+        SDL_free(display->display_modes[i].driverdata);
+        display->display_modes[i].driverdata = NULL;
+    }
+    SDL_free(display->display_modes);
+    display->display_modes = NULL;
+    display->num_display_modes = 0;
+    display->max_display_modes = 0;
+}
+
 int
 SDL_GetDisplayMode(int displayIndex, int index, SDL_DisplayMode * mode)
 {
@@ -900,7 +886,7 @@ SDL_GetClosestDisplayModeForDisplay(SDL_VideoDisplay * display,
     SDL_DisplayMode *current, *match;
 
     if (!mode || !closest) {
-        SDL_SetError("Missing desired mode or closest mode parameter");
+        SDL_InvalidParamError("mode/closest");
         return NULL;
     }
 
@@ -1014,6 +1000,7 @@ SDL_SetDisplayModeForDisplay(SDL_VideoDisplay * display, const SDL_DisplayMode *
 {
     SDL_DisplayMode display_mode;
     SDL_DisplayMode current_mode;
+    int result;
 
     if (mode) {
         display_mode = *mode;
@@ -1051,10 +1038,13 @@ SDL_SetDisplayModeForDisplay(SDL_VideoDisplay * display, const SDL_DisplayMode *
     if (!_this->SetDisplayMode) {
         return SDL_SetError("SDL video driver doesn't support changing display mode");
     }
-    if (_this->SetDisplayMode(_this, display, &display_mode) < 0) {
+    _this->setting_display_mode = SDL_TRUE;
+    result = _this->SetDisplayMode(_this, display, &display_mode);
+    _this->setting_display_mode = SDL_FALSE;
+    if (result < 0) {
         return -1;
     }
-    display->current_mode = display_mode;
+    SDL_SetCurrentDisplayMode(display, &display_mode);
     return 0;
 }
 
@@ -1151,7 +1141,16 @@ SDL_SetWindowDisplayMode(SDL_Window * window, const SDL_DisplayMode * mode)
     if (FULLSCREEN_VISIBLE(window) && (window->flags & SDL_WINDOW_FULLSCREEN_DESKTOP) != SDL_WINDOW_FULLSCREEN_DESKTOP) {
         SDL_DisplayMode fullscreen_mode;
         if (SDL_GetWindowDisplayMode(window, &fullscreen_mode) == 0) {
-            SDL_SetDisplayModeForDisplay(SDL_GetDisplayForWindow(window), &fullscreen_mode);
+            if (SDL_SetDisplayModeForDisplay(SDL_GetDisplayForWindow(window), &fullscreen_mode) == 0) {
+#ifndef ANDROID
+                /* Android may not resize the window to exactly what our fullscreen mode is, especially on
+                 * windowed Android environments like the Chromebook or Samsung DeX.  Given this, we shouldn't
+                 * use fullscreen_mode.w and fullscreen_mode.h, but rather get our current native size.  As such,
+                 * Android's SetWindowFullscreen will generate the window event for us with the proper final size.
+                 */
+                SDL_SendWindowEvent(window, SDL_WINDOWEVENT_RESIZED, fullscreen_mode.w, fullscreen_mode.h);
+#endif
+            }
         }
     }
     return 0;
@@ -1194,6 +1193,16 @@ SDL_GetWindowDisplayMode(SDL_Window * window, SDL_DisplayMode * mode)
     return 0;
 }
 
+void*
+SDL_GetWindowICCProfile(SDL_Window * window, size_t* size)
+{
+    if (!_this->GetWindowICCProfile) {
+        SDL_Unsupported();
+        return NULL;
+    }
+    return _this->GetWindowICCProfile(_this, window, size);
+}
+
 Uint32
 SDL_GetWindowPixelFormat(SDL_Window * window)
 {
@@ -1347,11 +1356,11 @@ SDL_UpdateFullscreenMode(SDL_Window * window, SDL_bool fullscreen)
                 /* Generate a mode change event here */
                 if (resized) {
 #ifndef ANDROID
-                    // Android may not resize the window to exactly what our fullscreen mode is, especially on
-                    // windowed Android environments like the Chromebook or Samsung DeX.  Given this, we shouldn't
-                    // use fullscreen_mode.w and fullscreen_mode.h, but rather get our current native size.  As such,
-                    // Android's SetWindowFullscreen will generate the window event for us with the proper final size.
-
+                    /* Android may not resize the window to exactly what our fullscreen mode is, especially on
+                     * windowed Android environments like the Chromebook or Samsung DeX.  Given this, we shouldn't
+                     * use fullscreen_mode.w and fullscreen_mode.h, but rather get our current native size.  As such,
+                     * Android's SetWindowFullscreen will generate the window event for us with the proper final size.
+                     */
                     SDL_SendWindowEvent(other, SDL_WINDOWEVENT_RESIZED,
                                         fullscreen_mode.w, fullscreen_mode.h);
 #endif
@@ -1434,9 +1443,17 @@ SDL_FinishWindowCreation(SDL_Window *window, Uint32 flags)
     if (flags & SDL_WINDOW_FULLSCREEN) {
         SDL_SetWindowFullscreen(window, flags);
     }
-    if (flags & SDL_WINDOW_INPUT_GRABBED) {
+    if (flags & SDL_WINDOW_MOUSE_GRABBED) {
+        /* We must specifically call SDL_SetWindowGrab() and not
+           SDL_SetWindowMouseGrab() here because older applications may use
+           this flag plus SDL_HINT_GRAB_KEYBOARD to indicate that they want
+           the keyboard grabbed too and SDL_SetWindowMouseGrab() won't do that.
+        */
         SDL_SetWindowGrab(window, SDL_TRUE);
     }
+    if (flags & SDL_WINDOW_KEYBOARD_GRABBED) {
+        SDL_SetWindowKeyboardGrab(window, SDL_TRUE);
+    }
     if (!(flags & SDL_WINDOW_HIDDEN)) {
         SDL_ShowWindow(window);
     }
@@ -1446,6 +1463,7 @@ SDL_Window *
 SDL_CreateWindow(const char *title, int x, int y, int w, int h, Uint32 flags)
 {
     SDL_Window *window;
+    Uint32 graphics_flags = flags & (SDL_WINDOW_OPENGL | SDL_WINDOW_METAL | SDL_WINDOW_VULKAN);
 
     if (!_this) {
         /* Initialize the video system if needed */
@@ -1473,12 +1491,20 @@ SDL_CreateWindow(const char *title, int x, int y, int w, int h, Uint32 flags)
         return NULL;
     }
 
-    /* Some platforms have OpenGL enabled by default */
-#if (SDL_VIDEO_OPENGL && __MACOSX__) || __IPHONEOS__ || __ANDROID__ || __NACL__
-    if (!_this->is_dummy && !(flags & SDL_WINDOW_VULKAN) && !(flags & SDL_WINDOW_METAL) && !SDL_IsVideoContextExternal()) {
-        flags |= SDL_WINDOW_OPENGL;
-    }
+    /* Some platforms have certain graphics backends enabled by default */
+    if (!graphics_flags && !SDL_IsVideoContextExternal()) {
+#if (SDL_VIDEO_OPENGL && __MACOSX__) || (__IPHONEOS__ && !TARGET_OS_MACCATALYST) || __ANDROID__ || __NACL__
+        if (_this->GL_CreateContext != NULL) {
+            flags |= SDL_WINDOW_OPENGL;
+        }
 #endif
+#if SDL_VIDEO_METAL && (TARGET_OS_MACCATALYST || __MACOSX__ || __IPHONEOS__)
+        if (_this->Metal_CreateView != NULL) {
+            flags |= SDL_WINDOW_METAL;
+        }
+#endif
+    }
+
     if (flags & SDL_WINDOW_OPENGL) {
         if (!_this->GL_CreateContext) {
             SDL_SetError("OpenGL support is either not configured in SDL "
@@ -1498,7 +1524,7 @@ SDL_CreateWindow(const char *title, int x, int y, int w, int h, Uint32 flags)
                          "(%s) or platform", _this->name);
             return NULL;
         }
-        if (flags & SDL_WINDOW_OPENGL) {
+        if (graphics_flags & SDL_WINDOW_OPENGL) {
             SDL_SetError("Vulkan and OpenGL not supported on same window");
             return NULL;
         }
@@ -1514,11 +1540,12 @@ SDL_CreateWindow(const char *title, int x, int y, int w, int h, Uint32 flags)
                          "(%s) or platform", _this->name);
             return NULL;
         }
-        if (flags & SDL_WINDOW_OPENGL) {
+        /* 'flags' may have default flags appended, don't check against that. */
+        if (graphics_flags & SDL_WINDOW_OPENGL) {
             SDL_SetError("Metal and OpenGL not supported on same window");
             return NULL;
         }
-        if (flags & SDL_WINDOW_VULKAN) {
+        if (graphics_flags & SDL_WINDOW_VULKAN) {
             SDL_SetError("Metal and Vulkan not supported on same window. "
                          "To use MoltenVK, set SDL_WINDOW_VULKAN only.");
             return NULL;
@@ -1573,6 +1600,22 @@ SDL_CreateWindow(const char *title, int x, int y, int w, int h, Uint32 flags)
         displayIndex = SDL_GetIndexOfDisplay(display);
         SDL_GetDisplayBounds(displayIndex, &bounds);
 
+        /* for real fullscreen we might switch the resolution, so get width and height
+         * from closest supported mode and use that instead of current resolution
+         */
+        if ((flags & SDL_WINDOW_FULLSCREEN_DESKTOP) != SDL_WINDOW_FULLSCREEN_DESKTOP
+              && (bounds.w != w || bounds.h != h)) {
+            SDL_DisplayMode fullscreen_mode, closest_mode;
+            SDL_zero(fullscreen_mode);
+            fullscreen_mode.w = w;
+            fullscreen_mode.h = h;
+            if (SDL_GetClosestDisplayModeForDisplay(display, &fullscreen_mode, &closest_mode) != NULL) {
+                bounds.w = closest_mode.w;
+                bounds.h = closest_mode.h;
+            }
+        }
+        window->fullscreen_mode.w = bounds.w;
+        window->fullscreen_mode.h = bounds.h;
         window->x = bounds.x;
         window->y = bounds.y;
         window->w = bounds.w;
@@ -1585,6 +1628,7 @@ SDL_CreateWindow(const char *title, int x, int y, int w, int h, Uint32 flags)
     window->brightness = 1.0f;
     window->next = _this->windows;
     window->is_destroying = SDL_FALSE;
+    window->display_index = SDL_GetWindowDisplayIndex(window);
 
     if (_this->windows) {
         _this->windows->prev = window;
@@ -1632,6 +1676,7 @@ SDL_Window *
 SDL_CreateWindowFrom(const void *data)
 {
     SDL_Window *window;
+    Uint32 flags = SDL_WINDOW_FOREIGN;
 
     if (!_this) {
         SDL_UninitializedVideo();
@@ -1641,6 +1686,37 @@ SDL_CreateWindowFrom(const void *data)
         SDL_Unsupported();
         return NULL;
     }
+
+    if (SDL_GetHintBoolean(SDL_HINT_VIDEO_FOREIGN_WINDOW_OPENGL, SDL_FALSE)) {
+        if (!_this->GL_CreateContext) {
+            SDL_SetError("OpenGL support is either not configured in SDL "
+                         "or not available in current SDL video driver "
+                         "(%s) or platform", _this->name);
+            return NULL;
+        }
+        if (SDL_GL_LoadLibrary(NULL) < 0) {
+            return NULL;
+        }
+        flags |= SDL_WINDOW_OPENGL;
+    }
+
+    if (SDL_GetHintBoolean(SDL_HINT_VIDEO_FOREIGN_WINDOW_VULKAN, SDL_FALSE)) {
+        if (!_this->Vulkan_CreateSurface) {
+            SDL_SetError("Vulkan support is either not configured in SDL "
+                         "or not available in current SDL video driver "
+                         "(%s) or platform", _this->name);
+            return NULL;
+        }
+        if (flags & SDL_WINDOW_OPENGL) {
+            SDL_SetError("Vulkan and OpenGL not supported on same window");
+            return NULL;
+        }
+        if (SDL_Vulkan_LoadLibrary(NULL) < 0) {
+            return NULL;
+        }
+        flags |= SDL_WINDOW_VULKAN;
+    }
+
     window = (SDL_Window *)SDL_calloc(1, sizeof(*window));
     if (!window) {
         SDL_OutOfMemory();
@@ -1648,7 +1724,7 @@ SDL_CreateWindowFrom(const void *data)
     }
     window->magic = &_this->window_magic;
     window->id = _this->next_object_id++;
-    window->flags = SDL_WINDOW_FOREIGN;
+    window->flags = flags;
     window->last_fullscreen_flags = window->flags;
     window->is_destroying = SDL_FALSE;
     window->opacity = 1.0f;
@@ -1664,6 +1740,7 @@ SDL_CreateWindowFrom(const void *data)
         return NULL;
     }
 
+    window->display_index = SDL_GetWindowDisplayIndex(window);
     PrepareDragAndDropSupport(window);
 
     return window;
@@ -1693,7 +1770,9 @@ SDL_RecreateWindow(SDL_Window * window, Uint32 flags)
     }
 
     /* Restore video mode, etc. */
-    SDL_HideWindow(window);
+    if (!(window->flags & SDL_WINDOW_FOREIGN)) {
+        SDL_HideWindow(window);
+    }
 
     /* Tear down the old native window */
     if (window->surface) {
@@ -1702,9 +1781,13 @@ SDL_RecreateWindow(SDL_Window * window, Uint32 flags)
         window->surface = NULL;
         window->surface_valid = SDL_FALSE;
     }
-    if (_this->DestroyWindowFramebuffer) {
-        _this->DestroyWindowFramebuffer(_this, window);
+
+    if (_this->checked_texture_framebuffer) { /* never checked? No framebuffer to destroy. Don't risk calling the wrong implementation. */
+        if (_this->DestroyWindowFramebuffer) {
+            _this->DestroyWindowFramebuffer(_this, window);
+        }
     }
+
     if (_this->DestroyWindow && !(flags & SDL_WINDOW_FOREIGN)) {
         _this->DestroyWindow(_this, window);
     }
@@ -1720,17 +1803,6 @@ SDL_RecreateWindow(SDL_Window * window, Uint32 flags)
         need_gl_load  = SDL_TRUE;
     }
 
-    if ((window->flags & SDL_WINDOW_METAL) != (flags & SDL_WINDOW_METAL)) {
-        if (flags & SDL_WINDOW_METAL) {
-            need_gl_load = SDL_TRUE;
-        } else {
-            need_gl_unload = SDL_TRUE;
-        }
-    } else if (window->flags & SDL_WINDOW_METAL) {
-        need_gl_unload = SDL_TRUE;
-        need_gl_load  = SDL_TRUE;
-    }
-
     if ((window->flags & SDL_WINDOW_VULKAN) != (flags & SDL_WINDOW_VULKAN)) {
         if (flags & SDL_WINDOW_VULKAN) {
             need_vulkan_load = SDL_TRUE;
@@ -1743,18 +1815,15 @@ SDL_RecreateWindow(SDL_Window * window, Uint32 flags)
     }
 
     if ((flags & SDL_WINDOW_VULKAN) && (flags & SDL_WINDOW_OPENGL)) {
-        SDL_SetError("Vulkan and OpenGL not supported on same window");
-        return -1;
+        return SDL_SetError("Vulkan and OpenGL not supported on same window");
     }
 
     if ((flags & SDL_WINDOW_METAL) && (flags & SDL_WINDOW_OPENGL)) {
-        SDL_SetError("Metal and OpenGL not supported on same window");
-        return -1;
+        return SDL_SetError("Metal and OpenGL not supported on same window");
     }
 
     if ((flags & SDL_WINDOW_METAL) && (flags & SDL_WINDOW_VULKAN)) {
-        SDL_SetError("Metal and Vulkan not supported on same window");
-        return -1;
+        return SDL_SetError("Metal and Vulkan not supported on same window");
     }
 
     if (need_gl_unload) {
@@ -1987,10 +2056,10 @@ SDL_SetWindowPosition(SDL_Window * window, int x, int y)
 
         SDL_GetDisplayBounds(displayIndex, &bounds);
         if (SDL_WINDOWPOS_ISCENTERED(x)) {
-            x = bounds.x + (bounds.w - window->w) / 2;
+            x = bounds.x + (bounds.w - window->windowed.w) / 2;
         }
         if (SDL_WINDOWPOS_ISCENTERED(y)) {
-            y = bounds.y + (bounds.h - window->h) / 2;
+            y = bounds.y + (bounds.h - window->windowed.h) / 2;
         }
     }
 
@@ -2093,6 +2162,25 @@ SDL_SetWindowResizable(SDL_Window * window, SDL_bool resizable)
     }
 }
 
+void
+SDL_SetWindowAlwaysOnTop(SDL_Window * window, SDL_bool on_top)
+{
+    CHECK_WINDOW_MAGIC(window,);
+    if (!(window->flags & SDL_WINDOW_FULLSCREEN)) {
+        const int want = (on_top != SDL_FALSE);  /* normalize the flag. */
+        const int have = ((window->flags & SDL_WINDOW_ALWAYS_ON_TOP) != 0);
+        if ((want != have) && (_this->SetWindowAlwaysOnTop)) {
+            if (want) {
+                window->flags |= SDL_WINDOW_ALWAYS_ON_TOP;
+            } else {
+                window->flags &= ~SDL_WINDOW_ALWAYS_ON_TOP;
+            }
+            
+            _this->SetWindowAlwaysOnTop(_this, window, (SDL_bool) want);
+        }
+    }
+}
+
 void
 SDL_SetWindowSize(SDL_Window * window, int w, int h)
 {
@@ -2129,12 +2217,14 @@ SDL_SetWindowSize(SDL_Window * window, int w, int h)
             SDL_UpdateFullscreenMode(window, SDL_TRUE);
         }
     } else {
+        int old_w = window->w;
+        int old_h = window->h;
         window->w = w;
         window->h = h;
         if (_this->SetWindowSize) {
             _this->SetWindowSize(_this, window);
         }
-        if (window->w == w && window->h == h) {
+        if (window->w != old_w || window->h != old_h) {
             /* We didn't get a SDL_WINDOWEVENT_RESIZED event (by design) */
             SDL_OnWindowResized(window);
         }
@@ -2395,18 +2485,63 @@ SDL_SetWindowFullscreen(SDL_Window * window, Uint32 flags)
 static SDL_Surface *
 SDL_CreateWindowFramebuffer(SDL_Window * window)
 {
-    Uint32 format;
-    void *pixels;
-    int pitch;
+    Uint32 format = 0;
+    void *pixels = NULL;
+    int pitch = 0;
     int bpp;
     Uint32 Rmask, Gmask, Bmask, Amask;
+    SDL_bool created_framebuffer = SDL_FALSE;
 
-    if (!_this->CreateWindowFramebuffer || !_this->UpdateWindowFramebuffer) {
-        return NULL;
+    /* This will switch the video backend from using a software surface to
+       using a GPU texture through the 2D render API, if we think this would
+       be more efficient. This only checks once, on demand. */
+    if (!_this->checked_texture_framebuffer) {
+        SDL_bool attempt_texture_framebuffer = SDL_TRUE;
+
+        if (_this->is_dummy) {  /* dummy driver never has GPU support, of course. */
+            attempt_texture_framebuffer = SDL_FALSE;
+        }
+
+        #if defined(__WIN32__) /* GDI BitBlt() is way faster than Direct3D dynamic textures right now. (!!! FIXME: is this still true?) */
+        else if ((_this->CreateWindowFramebuffer != NULL) && (SDL_strcmp(_this->name, "windows") == 0)) {
+            attempt_texture_framebuffer = SDL_FALSE;
+        }
+        #endif
+        #if defined(__EMSCRIPTEN__)
+        else {
+            attempt_texture_framebuffer = SDL_FALSE;
+        }
+        #endif
+
+        if (attempt_texture_framebuffer) {
+            if (SDL_CreateWindowTexture(_this, window, &format, &pixels, &pitch) == -1) {
+                /* !!! FIXME: if this failed halfway (made renderer, failed to make texture, etc),
+                   !!! FIXME:  we probably need to clean this up so it doesn't interfere with
+                   !!! FIXME:  a software fallback at the system level (can we blit to an
+                   !!! FIXME:  OpenGL window? etc). */
+            } else {
+                /* future attempts will just try to use a texture framebuffer. */
+                /* !!! FIXME:  maybe we shouldn't override these but check if we used a texture
+                   !!! FIXME:  framebuffer at the right places; is it feasible we could have an
+                   !!! FIXME:  accelerated OpenGL window and a second ends up in software? */
+                _this->CreateWindowFramebuffer = SDL_CreateWindowTexture;
+                _this->UpdateWindowFramebuffer = SDL_UpdateWindowTexture;
+                _this->DestroyWindowFramebuffer = SDL_DestroyWindowTexture;
+                created_framebuffer = SDL_TRUE;
+            }
+        }
+
+        _this->checked_texture_framebuffer = SDL_TRUE;  /* don't check this again. */
     }
 
-    if (_this->CreateWindowFramebuffer(_this, window, &format, &pixels, &pitch) < 0) {
-        return NULL;
+    if (!created_framebuffer) {
+        if (!_this->CreateWindowFramebuffer || !_this->UpdateWindowFramebuffer) {
+            return NULL;
+        }
+
+        if (_this->CreateWindowFramebuffer(_this, window, &format, &pixels, &pitch) < 0) {
+            return NULL;
+        }
     }
 
     if (window->surface) {
@@ -2464,6 +2599,8 @@ SDL_UpdateWindowSurfaceRects(SDL_Window * window, const SDL_Rect * rects,
         return SDL_SetError("Window surface is invalid, please call SDL_GetWindowSurface() to get a new surface");
     }
 
+    SDL_assert(_this->checked_texture_framebuffer); /* we should have done this before we had a valid surface. */
+
     return _this->UpdateWindowFramebuffer(_this, window, rects, numrects);
 }
 
@@ -2635,31 +2772,46 @@ SDL_GetWindowGammaRamp(SDL_Window * window, Uint16 * red,
 void
 SDL_UpdateWindowGrab(SDL_Window * window)
 {
-    SDL_Window *grabbed_window;
-    SDL_bool grabbed;
-    if ((SDL_GetMouse()->relative_mode || (window->flags & SDL_WINDOW_INPUT_GRABBED)) &&
-         (window->flags & SDL_WINDOW_INPUT_FOCUS)) {
-        grabbed = SDL_TRUE;
+    SDL_bool keyboard_grabbed, mouse_grabbed;
+
+    if (window->flags & SDL_WINDOW_INPUT_FOCUS) {
+        if (SDL_GetMouse()->relative_mode || (window->flags & SDL_WINDOW_MOUSE_GRABBED)) {
+            mouse_grabbed = SDL_TRUE;
+        } else {
+            mouse_grabbed = SDL_FALSE;
+        }
+
+        if (window->flags & SDL_WINDOW_KEYBOARD_GRABBED) {
+            keyboard_grabbed = SDL_TRUE;
+        } else {
+            keyboard_grabbed = SDL_FALSE;
+        }
     } else {
-        grabbed = SDL_FALSE;
+        mouse_grabbed = SDL_FALSE;
+        keyboard_grabbed = SDL_FALSE;
     }
 
-    grabbed_window = _this->grabbed_window;
-    if (grabbed) {
-        if (grabbed_window && (grabbed_window != window)) {
+    if (mouse_grabbed || keyboard_grabbed) {
+        if (_this->grabbed_window && (_this->grabbed_window != window)) {
             /* stealing a grab from another window! */
-            grabbed_window->flags &= ~SDL_WINDOW_INPUT_GRABBED;
-            if (_this->SetWindowGrab) {
-                _this->SetWindowGrab(_this, grabbed_window, SDL_FALSE);
+            _this->grabbed_window->flags &= ~(SDL_WINDOW_MOUSE_GRABBED | SDL_WINDOW_KEYBOARD_GRABBED);
+            if (_this->SetWindowMouseGrab) {
+                _this->SetWindowMouseGrab(_this, _this->grabbed_window, SDL_FALSE);
+            }
+            if (_this->SetWindowKeyboardGrab) {
+                _this->SetWindowKeyboardGrab(_this, _this->grabbed_window, SDL_FALSE);
             }
         }
         _this->grabbed_window = window;
-    } else if (grabbed_window == window) {
-        _this->grabbed_window = NULL;  /* ungrabbing. */
+    } else if (_this->grabbed_window == window) {
+        _this->grabbed_window = NULL;  /* ungrabbing input. */
     }
 
-    if (_this->SetWindowGrab) {
-        _this->SetWindowGrab(_this, window, grabbed);
+    if (_this->SetWindowMouseGrab) {
+        _this->SetWindowMouseGrab(_this, window, mouse_grabbed);
+    }
+    if (_this->SetWindowKeyboardGrab) {
+        _this->SetWindowKeyboardGrab(_this, window, keyboard_grabbed);
     }
 }
 
@@ -2668,30 +2820,117 @@ SDL_SetWindowGrab(SDL_Window * window, SDL_bool grabbed)
 {
     CHECK_WINDOW_MAGIC(window,);
 
-    if (!!grabbed == !!(window->flags & SDL_WINDOW_INPUT_GRABBED)) {
+    SDL_SetWindowMouseGrab(window, grabbed);
+
+    if (SDL_GetHintBoolean(SDL_HINT_GRAB_KEYBOARD, SDL_FALSE)) {
+        SDL_SetWindowKeyboardGrab(window, grabbed);
+    }
+}
+
+void
+SDL_SetWindowKeyboardGrab(SDL_Window * window, SDL_bool grabbed)
+{
+    CHECK_WINDOW_MAGIC(window,);
+
+    if (!!grabbed == !!(window->flags & SDL_WINDOW_KEYBOARD_GRABBED)) {
         return;
     }
     if (grabbed) {
-        window->flags |= SDL_WINDOW_INPUT_GRABBED;
+        window->flags |= SDL_WINDOW_KEYBOARD_GRABBED;
     } else {
-        window->flags &= ~SDL_WINDOW_INPUT_GRABBED;
+        window->flags &= ~SDL_WINDOW_KEYBOARD_GRABBED;
+    }
+    SDL_UpdateWindowGrab(window);
+}
+
+void
+SDL_SetWindowMouseGrab(SDL_Window * window, SDL_bool grabbed)
+{
+    CHECK_WINDOW_MAGIC(window,);
+
+    if (!!grabbed == !!(window->flags & SDL_WINDOW_MOUSE_GRABBED)) {
+        return;
+    }
+    if (grabbed) {
+        window->flags |= SDL_WINDOW_MOUSE_GRABBED;
+    } else {
+        window->flags &= ~SDL_WINDOW_MOUSE_GRABBED;
     }
     SDL_UpdateWindowGrab(window);
 }
 
 SDL_bool
 SDL_GetWindowGrab(SDL_Window * window)
+{
+    return (SDL_GetWindowKeyboardGrab(window) || SDL_GetWindowMouseGrab(window));
+}
+
+SDL_bool
+SDL_GetWindowKeyboardGrab(SDL_Window * window)
 {
     CHECK_WINDOW_MAGIC(window, SDL_FALSE);
-    SDL_assert(!_this->grabbed_window || ((_this->grabbed_window->flags & SDL_WINDOW_INPUT_GRABBED) != 0));
-    return window == _this->grabbed_window;
+    return window == _this->grabbed_window &&
+           ((_this->grabbed_window->flags & SDL_WINDOW_KEYBOARD_GRABBED) != 0);
+}
+
+SDL_bool
+SDL_GetWindowMouseGrab(SDL_Window * window)
+{
+    CHECK_WINDOW_MAGIC(window, SDL_FALSE);
+    return window == _this->grabbed_window &&
+           ((_this->grabbed_window->flags & SDL_WINDOW_MOUSE_GRABBED) != 0);
 }
 
 SDL_Window *
 SDL_GetGrabbedWindow(void)
 {
-    SDL_assert(!_this->grabbed_window || ((_this->grabbed_window->flags & SDL_WINDOW_INPUT_GRABBED) != 0));
-    return _this->grabbed_window;
+    if (_this->grabbed_window &&
+        (_this->grabbed_window->flags & (SDL_WINDOW_MOUSE_GRABBED|SDL_WINDOW_KEYBOARD_GRABBED)) != 0) {
+        return _this->grabbed_window;
+    } else {
+        return NULL;
+    }
+}
+
+int
+SDL_SetWindowMouseRect(SDL_Window * window, const SDL_Rect * rect)
+{
+    CHECK_WINDOW_MAGIC(window, -1);
+
+    if (rect) {
+        SDL_memcpy(&window->mouse_rect, rect, sizeof(*rect));
+    } else {
+        SDL_zero(window->mouse_rect);
+    }
+
+    if (_this->SetWindowMouseRect) {
+        _this->SetWindowMouseRect(_this, window);
+    }
+    return 0;
+}
+
+const SDL_Rect *
+SDL_GetWindowMouseRect(SDL_Window * window)
+{
+    CHECK_WINDOW_MAGIC(window, NULL);
+
+    if (SDL_RectEmpty(&window->mouse_rect)) {
+        return NULL;
+    } else {
+        return &window->mouse_rect;
+    }
+}
+
+int
+SDL_FlashWindow(SDL_Window * window, SDL_FlashOperation operation)
+{
+    CHECK_WINDOW_MAGIC(window, -1);
+
+    if (_this->FlashWindow) {
+        return _this->FlashWindow(_this, window, operation);
+    }
+
+    return SDL_Unsupported();
 }
 
 void
@@ -2709,8 +2948,28 @@ SDL_OnWindowHidden(SDL_Window * window)
 void
 SDL_OnWindowResized(SDL_Window * window)
 {
+    int display_index = SDL_GetWindowDisplayIndex(window);
     window->surface_valid = SDL_FALSE;
-    SDL_SendWindowEvent(window, SDL_WINDOWEVENT_SIZE_CHANGED, window->w, window->h);
+
+    if (!window->is_destroying) {
+        SDL_SendWindowEvent(window, SDL_WINDOWEVENT_SIZE_CHANGED, window->w, window->h);
+
+        if (display_index != window->display_index && display_index != -1) {
+            window->display_index = display_index;
+            SDL_SendWindowEvent(window, SDL_WINDOWEVENT_DISPLAY_CHANGED, window->display_index, 0);
+        }
+    }
+}
+
+void
+SDL_OnWindowMoved(SDL_Window * window)
+{
+    int display_index = SDL_GetWindowDisplayIndex(window);
+
+    if (!window->is_destroying && display_index != window->display_index && display_index != -1) {
+        window->display_index = display_index;
+        SDL_SendWindowEvent(window, SDL_WINDOWEVENT_DISPLAY_CHANGED, window->display_index, 0);
+    }
 }
 
 void
@@ -2759,7 +3018,9 @@ SDL_OnWindowFocusGained(SDL_Window * window)
 
     if (mouse && mouse->relative_mode) {
         SDL_SetMouseFocus(window);
-        SDL_WarpMouseInWindow(window, window->w/2, window->h/2);
+        if (mouse->relative_mode_warp) {
+            SDL_WarpMouseInWindow(window, window->w/2, window->h/2);
+        }
     }
 
     SDL_UpdateWindowGrab(window);
@@ -2768,6 +3029,8 @@ SDL_OnWindowFocusGained(SDL_Window * window)
 static SDL_bool
 ShouldMinimizeOnFocusLoss(SDL_Window * window)
 {
+    const char *hint;
+
     if (!(window->flags & SDL_WINDOW_FULLSCREEN) || window->is_destroying) {
         return SDL_FALSE;
     }
@@ -2783,12 +3046,21 @@ ShouldMinimizeOnFocusLoss(SDL_Window * window)
 #ifdef __ANDROID__
     {
         extern SDL_bool Android_JNI_ShouldMinimizeOnFocusLoss(void);
-        if (! Android_JNI_ShouldMinimizeOnFocusLoss()) {
+        if (!Android_JNI_ShouldMinimizeOnFocusLoss()) {
             return SDL_FALSE;
         }
     }
 #endif
 
+    /* Real fullscreen windows should minimize on focus loss so the desktop video mode is restored */
+    hint = SDL_GetHint(SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS);
+    if (!hint || !*hint || SDL_strcasecmp(hint, "auto") == 0) {
+        if ((window->flags & SDL_WINDOW_FULLSCREEN_DESKTOP) == SDL_WINDOW_FULLSCREEN_DESKTOP) {
+            return SDL_FALSE;
+        } else {
+            return SDL_TRUE;
+        }
+    }
     return SDL_GetHintBoolean(SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS, SDL_FALSE);
 }
 
@@ -2834,7 +3106,9 @@ SDL_DestroyWindow(SDL_Window * window)
     window->is_destroying = SDL_TRUE;
 
     /* Restore video mode, etc. */
-    SDL_HideWindow(window);
+    if (!(window->flags & SDL_WINDOW_FOREIGN)) {
+        SDL_HideWindow(window);
+    }
 
     /* Make sure this window no longer has focus */
     if (SDL_GetKeyboardFocus() == window) {
@@ -2857,8 +3131,10 @@ SDL_DestroyWindow(SDL_Window * window)
         window->surface = NULL;
         window->surface_valid = SDL_FALSE;
     }
-    if (_this->DestroyWindowFramebuffer) {
-        _this->DestroyWindowFramebuffer(_this, window);
+    if (_this->checked_texture_framebuffer) { /* never checked? No framebuffer to destroy. Don't risk calling the wrong implementation. */
+        if (_this->DestroyWindowFramebuffer) {
+            _this->DestroyWindowFramebuffer(_this, window);
+        }
     }
     if (_this->DestroyWindow) {
         _this->DestroyWindow(_this, window);
@@ -2945,7 +3221,7 @@ SDL_DisableScreenSaver()
 void
 SDL_VideoQuit(void)
 {
-    int i, j;
+    int i;
 
     if (!_this) {
         return;
@@ -2967,12 +3243,7 @@ SDL_VideoQuit(void)
 
     for (i = 0; i < _this->num_displays; ++i) {
         SDL_VideoDisplay *display = &_this->displays[i];
-        for (j = display->num_display_modes; j--;) {
-            SDL_free(display->display_modes[j].driverdata);
-            display->display_modes[j].driverdata = NULL;
-        }
-        SDL_free(display->display_modes);
-        display->display_modes = NULL;
+        SDL_ResetDisplayModes(i);
         SDL_free(display->desktop_mode.driverdata);
         display->desktop_mode.driverdata = NULL;
         SDL_free(display->driverdata);
@@ -3568,10 +3839,23 @@ SDL_GL_GetAttribute(SDL_GLattr attr, int *value)
     }
 
     if (attachmentattrib && isAtLeastGL3((const char *) glGetStringFunc(GL_VERSION))) {
-        glGetFramebufferAttachmentParameterivFunc = SDL_GL_GetProcAddress("glGetFramebufferAttachmentParameteriv");
+        /* glGetFramebufferAttachmentParameteriv needs to operate on the window framebuffer for this, so bind FBO 0 if necessary. */
+        GLint current_fbo = 0;
+        void (APIENTRY *glGetIntegervFunc) (GLenum pname, GLint * params) = SDL_GL_GetProcAddress("glGetIntegerv");
+        void (APIENTRY *glBindFramebufferFunc) (GLenum target, GLuint fbo) = SDL_GL_GetProcAddress("glBindFramebuffer");
+        if (glGetIntegervFunc && glBindFramebufferFunc) {
+            glGetIntegervFunc(GL_DRAW_FRAMEBUFFER_BINDING, &current_fbo);
+        }
 
+        glGetFramebufferAttachmentParameterivFunc = SDL_GL_GetProcAddress("glGetFramebufferAttachmentParameteriv");
         if (glGetFramebufferAttachmentParameterivFunc) {
+            if (glBindFramebufferFunc && (current_fbo != 0)) {
+                glBindFramebufferFunc(GL_DRAW_FRAMEBUFFER, 0);
+            }
             glGetFramebufferAttachmentParameterivFunc(GL_FRAMEBUFFER, attachment, attachmentattrib, (GLint *) value);
+            if (glBindFramebufferFunc && (current_fbo != 0)) {
+                glBindFramebufferFunc(GL_DRAW_FRAMEBUFFER, current_fbo);
+            }
         } else {
             return -1;
         }
@@ -3892,6 +4176,24 @@ SDL_StartTextInput(void)
     }
 }
 
+void
+SDL_ClearComposition(void)
+{
+    if (_this && _this->ClearComposition) {
+        _this->ClearComposition(_this);
+    }
+}
+
+SDL_bool
+SDL_IsTextInputShown(void)
+{
+    if (_this && _this->IsTextInputShown) {
+        return _this->IsTextInputShown(_this);
+    }
+
+    return SDL_FALSE;
+}
+
 SDL_bool
 SDL_IsTextInputActive(void)
 {
@@ -3960,6 +4262,9 @@ SDL_IsScreenKeyboardShown(SDL_Window *window)
 #if SDL_VIDEO_DRIVER_UIKIT
 #include "uikit/SDL_uikitmessagebox.h"
 #endif
+#if SDL_VIDEO_DRIVER_WAYLAND
+#include "wayland/SDL_waylandmessagebox.h"
+#endif
 #if SDL_VIDEO_DRIVER_X11
 #include "x11/SDL_x11messagebox.h"
 #endif
@@ -3969,8 +4274,14 @@ SDL_IsScreenKeyboardShown(SDL_Window *window)
 #if SDL_VIDEO_DRIVER_OS2
 #include "os2/SDL_os2messagebox.h"
 #endif
+#if SDL_VIDEO_DRIVER_RISCOS
+#include "riscos/SDL_riscosmessagebox.h"
+#endif
+#if SDL_VIDEO_DRIVER_VITA
+#include "vita/SDL_vitamessagebox.h"
+#endif
 
-#if SDL_VIDEO_DRIVER_WINDOWS || SDL_VIDEO_DRIVER_WINRT || SDL_VIDEO_DRIVER_COCOA || SDL_VIDEO_DRIVER_UIKIT || SDL_VIDEO_DRIVER_X11 || SDL_VIDEO_DRIVER_HAIKU || SDL_VIDEO_DRIVER_OS2
+#if SDL_VIDEO_DRIVER_WINDOWS || SDL_VIDEO_DRIVER_WINRT || SDL_VIDEO_DRIVER_COCOA || SDL_VIDEO_DRIVER_UIKIT || SDL_VIDEO_DRIVER_X11 || SDL_VIDEO_DRIVER_WAYLAND || SDL_VIDEO_DRIVER_HAIKU || SDL_VIDEO_DRIVER_OS2 || SDL_VIDEO_DRIVER_RISCOS
 static SDL_bool SDL_MessageboxValidForDriver(const SDL_MessageBoxData *messageboxdata, SDL_SYSWM_TYPE drivertype)
 {
     SDL_SysWMinfo info;
@@ -4023,6 +4334,8 @@ SDL_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid)
     if (!mbdata.message) mbdata.message = "";
     messageboxdata = &mbdata;
 
+    SDL_ClearError();
+
     if (_this && _this->ShowMessageBox) {
         retval = _this->ShowMessageBox(_this, messageboxdata, buttonid);
     }
@@ -4062,6 +4375,13 @@ SDL_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid)
         retval = 0;
     }
 #endif
+#if SDL_VIDEO_DRIVER_WAYLAND
+    if (retval == -1 &&
+        SDL_MessageboxValidForDriver(messageboxdata, SDL_SYSWM_WAYLAND) &&
+        Wayland_ShowMessageBox(messageboxdata, buttonid) == 0) {
+        retval = 0;
+    }
+#endif
 #if SDL_VIDEO_DRIVER_X11
     if (retval == -1 &&
         SDL_MessageboxValidForDriver(messageboxdata, SDL_SYSWM_X11) &&
@@ -4082,9 +4402,26 @@ SDL_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid)
         OS2_ShowMessageBox(messageboxdata, buttonid) == 0) {
         retval = 0;
     }
+#endif
+#if SDL_VIDEO_DRIVER_RISCOS
+    if (retval == -1 &&
+        SDL_MessageboxValidForDriver(messageboxdata, SDL_SYSWM_RISCOS) &&
+        RISCOS_ShowMessageBox(messageboxdata, buttonid) == 0) {
+        retval = 0;
+    }
+#endif
+#if SDL_VIDEO_DRIVER_VITA
+    if (retval == -1 &&
+        VITA_ShowMessageBox(messageboxdata, buttonid) == 0) {
+        retval = 0;
+    }
 #endif
     if (retval == -1) {
-        SDL_SetError("No message system available");
+        const char *error = SDL_GetError();
+
+        if (!*error) {
+            SDL_SetError("No message system available");
+        }
     }
 
     if (current_window) {
diff --git a/Engine/lib/sdl/src/video/SDL_vulkan_internal.h b/Engine/lib/sdl/src/video/SDL_vulkan_internal.h
index bc49ec44e..1ec1ab473 100644
--- a/Engine/lib/sdl/src/video/SDL_vulkan_internal.h
+++ b/Engine/lib/sdl/src/video/SDL_vulkan_internal.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -25,12 +25,10 @@
 
 #include "SDL_stdinc.h"
 
-#if defined(SDL_LOADSO_DISABLED)
-#undef SDL_VIDEO_VULKAN
-#define SDL_VIDEO_VULKAN 0
-#endif
-
 #if SDL_VIDEO_VULKAN
+#if SDL_LOADSO_DISABLED || SDL_LOADSO_DUMMY
+#error You should not be here.
+#endif
 
 #if SDL_VIDEO_DRIVER_ANDROID
 #define VK_USE_PLATFORM_ANDROID_KHR
diff --git a/Engine/lib/sdl/src/video/SDL_vulkan_utils.c b/Engine/lib/sdl/src/video/SDL_vulkan_utils.c
index df49da72e..33761a591 100644
--- a/Engine/lib/sdl/src/video/SDL_vulkan_utils.c
+++ b/Engine/lib/sdl/src/video/SDL_vulkan_utils.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -23,97 +23,97 @@
 #include "SDL_vulkan_internal.h"
 #include "SDL_error.h"
 
-/* !!! FIXME: this file doesn't match coding standards for SDL (brace position, etc). */
-
 #if SDL_VIDEO_VULKAN
 
 const char *SDL_Vulkan_GetResultString(VkResult result)
 {
-    switch((int)result)
-    {
-    case VK_SUCCESS:
-        return "VK_SUCCESS";
-    case VK_NOT_READY:
-        return "VK_NOT_READY";
-    case VK_TIMEOUT:
-        return "VK_TIMEOUT";
-    case VK_EVENT_SET:
-        return "VK_EVENT_SET";
-    case VK_EVENT_RESET:
-        return "VK_EVENT_RESET";
-    case VK_INCOMPLETE:
-        return "VK_INCOMPLETE";
-    case VK_ERROR_OUT_OF_HOST_MEMORY:
-        return "VK_ERROR_OUT_OF_HOST_MEMORY";
-    case VK_ERROR_OUT_OF_DEVICE_MEMORY:
-        return "VK_ERROR_OUT_OF_DEVICE_MEMORY";
-    case VK_ERROR_INITIALIZATION_FAILED:
-        return "VK_ERROR_INITIALIZATION_FAILED";
-    case VK_ERROR_DEVICE_LOST:
-        return "VK_ERROR_DEVICE_LOST";
-    case VK_ERROR_MEMORY_MAP_FAILED:
-        return "VK_ERROR_MEMORY_MAP_FAILED";
-    case VK_ERROR_LAYER_NOT_PRESENT:
-        return "VK_ERROR_LAYER_NOT_PRESENT";
-    case VK_ERROR_EXTENSION_NOT_PRESENT:
-        return "VK_ERROR_EXTENSION_NOT_PRESENT";
-    case VK_ERROR_FEATURE_NOT_PRESENT:
-        return "VK_ERROR_FEATURE_NOT_PRESENT";
-    case VK_ERROR_INCOMPATIBLE_DRIVER:
-        return "VK_ERROR_INCOMPATIBLE_DRIVER";
-    case VK_ERROR_TOO_MANY_OBJECTS:
-        return "VK_ERROR_TOO_MANY_OBJECTS";
-    case VK_ERROR_FORMAT_NOT_SUPPORTED:
-        return "VK_ERROR_FORMAT_NOT_SUPPORTED";
-    case VK_ERROR_FRAGMENTED_POOL:
-        return "VK_ERROR_FRAGMENTED_POOL";
-    case VK_ERROR_UNKNOWN:
-        return "VK_ERROR_UNKNOWN";
-    case VK_ERROR_OUT_OF_POOL_MEMORY:
-        return "VK_ERROR_OUT_OF_POOL_MEMORY";
-    case VK_ERROR_INVALID_EXTERNAL_HANDLE:
-        return "VK_ERROR_INVALID_EXTERNAL_HANDLE";
-    case VK_ERROR_FRAGMENTATION:
-        return "VK_ERROR_FRAGMENTATION";
-    case VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS:
-        return "VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS";
-    case VK_ERROR_SURFACE_LOST_KHR:
-        return "VK_ERROR_SURFACE_LOST_KHR";
-    case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR:
-        return "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR";
-    case VK_SUBOPTIMAL_KHR:
-        return "VK_SUBOPTIMAL_KHR";
-    case VK_ERROR_OUT_OF_DATE_KHR:
-        return "VK_ERROR_OUT_OF_DATE_KHR";
-    case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR:
-        return "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR";
-    case VK_ERROR_VALIDATION_FAILED_EXT:
-        return "VK_ERROR_VALIDATION_FAILED_EXT";
-    case VK_ERROR_INVALID_SHADER_NV:
-        return "VK_ERROR_INVALID_SHADER_NV";
-    case VK_ERROR_INCOMPATIBLE_VERSION_KHR:
-        return "VK_ERROR_INCOMPATIBLE_VERSION_KHR";
-    case VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT:
-        return "VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT";
-    case VK_ERROR_NOT_PERMITTED_EXT:
-        return "VK_ERROR_NOT_PERMITTED_EXT";
-    case VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT:
-        return "VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT";
-    case VK_THREAD_IDLE_KHR:
-        return "VK_THREAD_IDLE_KHR";
-    case VK_THREAD_DONE_KHR:
-        return "VK_THREAD_DONE_KHR";
-    case VK_OPERATION_DEFERRED_KHR:
-        return "VK_OPERATION_DEFERRED_KHR";
-    case VK_OPERATION_NOT_DEFERRED_KHR:
-        return "VK_OPERATION_NOT_DEFERRED_KHR";
-    case VK_PIPELINE_COMPILE_REQUIRED_EXT:
-        return "VK_PIPELINE_COMPILE_REQUIRED_EXT";
-    default:
-        break;
+    switch ((int)result) {
+        case VK_SUCCESS:
+            return "VK_SUCCESS";
+        case VK_NOT_READY:
+            return "VK_NOT_READY";
+        case VK_TIMEOUT:
+            return "VK_TIMEOUT";
+        case VK_EVENT_SET:
+            return "VK_EVENT_SET";
+        case VK_EVENT_RESET:
+            return "VK_EVENT_RESET";
+        case VK_INCOMPLETE:
+            return "VK_INCOMPLETE";
+        case VK_ERROR_OUT_OF_HOST_MEMORY:
+            return "VK_ERROR_OUT_OF_HOST_MEMORY";
+        case VK_ERROR_OUT_OF_DEVICE_MEMORY:
+            return "VK_ERROR_OUT_OF_DEVICE_MEMORY";
+        case VK_ERROR_INITIALIZATION_FAILED:
+            return "VK_ERROR_INITIALIZATION_FAILED";
+        case VK_ERROR_DEVICE_LOST:
+            return "VK_ERROR_DEVICE_LOST";
+        case VK_ERROR_MEMORY_MAP_FAILED:
+            return "VK_ERROR_MEMORY_MAP_FAILED";
+        case VK_ERROR_LAYER_NOT_PRESENT:
+            return "VK_ERROR_LAYER_NOT_PRESENT";
+        case VK_ERROR_EXTENSION_NOT_PRESENT:
+            return "VK_ERROR_EXTENSION_NOT_PRESENT";
+        case VK_ERROR_FEATURE_NOT_PRESENT:
+            return "VK_ERROR_FEATURE_NOT_PRESENT";
+        case VK_ERROR_INCOMPATIBLE_DRIVER:
+            return "VK_ERROR_INCOMPATIBLE_DRIVER";
+        case VK_ERROR_TOO_MANY_OBJECTS:
+            return "VK_ERROR_TOO_MANY_OBJECTS";
+        case VK_ERROR_FORMAT_NOT_SUPPORTED:
+            return "VK_ERROR_FORMAT_NOT_SUPPORTED";
+        case VK_ERROR_FRAGMENTED_POOL:
+            return "VK_ERROR_FRAGMENTED_POOL";
+        case VK_ERROR_UNKNOWN:
+            return "VK_ERROR_UNKNOWN";
+        case VK_ERROR_OUT_OF_POOL_MEMORY:
+            return "VK_ERROR_OUT_OF_POOL_MEMORY";
+        case VK_ERROR_INVALID_EXTERNAL_HANDLE:
+            return "VK_ERROR_INVALID_EXTERNAL_HANDLE";
+        case VK_ERROR_FRAGMENTATION:
+            return "VK_ERROR_FRAGMENTATION";
+        case VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS:
+            return "VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS";
+        case VK_ERROR_SURFACE_LOST_KHR:
+            return "VK_ERROR_SURFACE_LOST_KHR";
+        case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR:
+            return "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR";
+        case VK_SUBOPTIMAL_KHR:
+            return "VK_SUBOPTIMAL_KHR";
+        case VK_ERROR_OUT_OF_DATE_KHR:
+            return "VK_ERROR_OUT_OF_DATE_KHR";
+        case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR:
+            return "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR";
+        case VK_ERROR_VALIDATION_FAILED_EXT:
+            return "VK_ERROR_VALIDATION_FAILED_EXT";
+        case VK_ERROR_INVALID_SHADER_NV:
+            return "VK_ERROR_INVALID_SHADER_NV";
+#if VK_HEADER_VERSION >= 135 && VK_HEADER_VERSION < 162
+        case VK_ERROR_INCOMPATIBLE_VERSION_KHR:
+            return "VK_ERROR_INCOMPATIBLE_VERSION_KHR";
+#endif
+        case VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT:
+            return "VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT";
+        case VK_ERROR_NOT_PERMITTED_EXT:
+            return "VK_ERROR_NOT_PERMITTED_EXT";
+        case VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT:
+            return "VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT";
+        case VK_THREAD_IDLE_KHR:
+            return "VK_THREAD_IDLE_KHR";
+        case VK_THREAD_DONE_KHR:
+            return "VK_THREAD_DONE_KHR";
+        case VK_OPERATION_DEFERRED_KHR:
+            return "VK_OPERATION_DEFERRED_KHR";
+        case VK_OPERATION_NOT_DEFERRED_KHR:
+            return "VK_OPERATION_NOT_DEFERRED_KHR";
+        case VK_PIPELINE_COMPILE_REQUIRED_EXT:
+            return "VK_PIPELINE_COMPILE_REQUIRED_EXT";
+        default:
+            break;
     }
-    if(result < 0)
+    if (result < 0) {
         return "VK_ERROR_<Unknown>";
+    }
     return "VK_<Unknown>";
 }
 
@@ -124,11 +124,9 @@ VkExtensionProperties *SDL_Vulkan_CreateInstanceExtensionsList(
     Uint32 count = 0;
     VkResult result = vkEnumerateInstanceExtensionProperties(NULL, &count, NULL);
     VkExtensionProperties *retval;
-    if(result == VK_ERROR_INCOMPATIBLE_DRIVER)
-    {
-        /* Avoid the ERR_MAX_STRLEN limit by passing part of the message
-         * as a string argument.
-         */
+
+    if (result == VK_ERROR_INCOMPATIBLE_DRIVER) {
+        /* Avoid the ERR_MAX_STRLEN limit by passing part of the message as a string argument.  */
         SDL_SetError(
             "You probably don't have a working Vulkan driver installed. %s %s %s(%d)",
             "Getting Vulkan extensions failed:",
@@ -136,9 +134,7 @@ VkExtensionProperties *SDL_Vulkan_CreateInstanceExtensionsList(
             SDL_Vulkan_GetResultString(result),
             (int)result);
         return NULL;
-    }
-    else if(result != VK_SUCCESS)
-    {
+    } else if (result != VK_SUCCESS) {
         SDL_SetError(
             "Getting Vulkan extensions failed: vkEnumerateInstanceExtensionProperties returned "
             "%s(%d)",
@@ -146,22 +142,20 @@ VkExtensionProperties *SDL_Vulkan_CreateInstanceExtensionsList(
             (int)result);
         return NULL;
     }
-    if(count == 0)
-    {
+
+    if (count == 0) {
         retval = SDL_calloc(1, sizeof(VkExtensionProperties)); // so we can return non-null
-    }
-    else
-    {
+    } else {
         retval = SDL_calloc(count, sizeof(VkExtensionProperties));
     }
-    if(!retval)
-    {
+
+    if (!retval) {
         SDL_OutOfMemory();
         return NULL;
     }
+
     result = vkEnumerateInstanceExtensionProperties(NULL, &count, retval);
-    if(result != VK_SUCCESS)
-    {
+    if (result != VK_SUCCESS) {
         SDL_SetError(
             "Getting Vulkan extensions failed: vkEnumerateInstanceExtensionProperties returned "
             "%s(%d)",
@@ -186,6 +180,7 @@ SDL_bool SDL_Vulkan_GetInstanceExtensions_Helper(unsigned *userCount,
             SDL_SetError("Output array for SDL_Vulkan_GetInstanceExtensions needs to be at least %d big", nameCount);
             return SDL_FALSE;
         }
+
         for (i = 0; i < nameCount; i++) {
             userNames[i] = names[i];
         }
@@ -226,55 +221,47 @@ SDL_bool SDL_Vulkan_Display_CreateSurface(void *vkGetInstanceProcAddr_,
     const char *chosenDisplayId;
     int displayId = 0; /* Counting from physical device 0, display 0 */
 
-    if(!vkEnumeratePhysicalDevices ||
+    if (!vkEnumeratePhysicalDevices ||
        !vkGetPhysicalDeviceDisplayPropertiesKHR ||
        !vkGetDisplayModePropertiesKHR ||
        !vkGetPhysicalDeviceDisplayPlanePropertiesKHR ||
        !vkGetDisplayPlaneCapabilitiesKHR ||
        !vkGetDisplayPlaneSupportedDisplaysKHR ||
-       !vkCreateDisplayPlaneSurfaceKHR)
-    {
-        SDL_SetError(VK_KHR_DISPLAY_EXTENSION_NAME
-                     " extension is not enabled in the Vulkan instance.");
+       !vkCreateDisplayPlaneSurfaceKHR) {
+        SDL_SetError(VK_KHR_DISPLAY_EXTENSION_NAME " extension is not enabled in the Vulkan instance.");
         goto error;
     }
 
-    if ((chosenDisplayId = SDL_getenv("SDL_VULKAN_DISPLAY")) != NULL)
-    {
+    if ((chosenDisplayId = SDL_getenv("SDL_VULKAN_DISPLAY")) != NULL) {
         displayId = SDL_atoi(chosenDisplayId);
     }
 
     /* Enumerate physical devices */
-    result =
-        vkEnumeratePhysicalDevices(instance, &physicalDeviceCount, NULL);
-    if(result != VK_SUCCESS)
-    {
+    result = vkEnumeratePhysicalDevices(instance, &physicalDeviceCount, NULL);
+    if (result != VK_SUCCESS) {
         SDL_SetError("Could not enumerate Vulkan physical devices");
         goto error;
     }
-    if(physicalDeviceCount == 0)
-    {
+
+    if (physicalDeviceCount == 0) {
         SDL_SetError("No Vulkan physical devices");
         goto error;
     }
+
     physicalDevices = SDL_malloc(sizeof(VkPhysicalDevice) * physicalDeviceCount);
-    if(!physicalDevices)
-    {
+    if (!physicalDevices) {
         SDL_OutOfMemory();
         goto error;
     }
-    result =
-        vkEnumeratePhysicalDevices(instance, &physicalDeviceCount, physicalDevices);
-    if(result != VK_SUCCESS)
-    {
+
+    result = vkEnumeratePhysicalDevices(instance, &physicalDeviceCount, physicalDevices);
+    if (result != VK_SUCCESS) {
         SDL_SetError("Error enumerating physical devices");
         goto error;
     }
 
-    for(physicalDeviceIndex = 0; physicalDeviceIndex < physicalDeviceCount;
-        physicalDeviceIndex++)
-    {
-		VkPhysicalDevice physicalDevice = physicalDevices[physicalDeviceIndex];
+    for (physicalDeviceIndex = 0; physicalDeviceIndex < physicalDeviceCount; physicalDeviceIndex++) {
+        VkPhysicalDevice physicalDevice = physicalDevices[physicalDeviceIndex];
         uint32_t displayPropertiesCount = 0;
         VkDisplayPropertiesKHR *displayProperties = NULL;
         uint32_t displayModePropertiesCount = 0;
@@ -290,32 +277,27 @@ SDL_bool SDL_Vulkan_Display_CreateSurface(void *vkGetInstanceProcAddr_,
         VkDisplayPlaneCapabilitiesKHR planeCaps;
 
         /* Get information about the physical displays */
-        result =
-            vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayPropertiesCount, NULL);
-        if (result != VK_SUCCESS || displayPropertiesCount == 0)
-        {
+        result = vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayPropertiesCount, NULL);
+        if (result != VK_SUCCESS || displayPropertiesCount == 0) {
             /* This device has no physical device display properties, move on to next. */
             continue;
         }
         SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "vulkandisplay: Number of display properties for device %u: %u",
                 physicalDeviceIndex, displayPropertiesCount);
 
-        if ( (displayId < 0) || (((uint32_t) displayId) >= displayPropertiesCount) )
-        {
+        if (displayId < 0 || (uint32_t) displayId >= displayPropertiesCount) {
             /* Display id specified was higher than number of available displays, move to next physical device. */
             displayId -= displayPropertiesCount;
             continue;
         }
 
         displayProperties = SDL_malloc(sizeof(VkDisplayPropertiesKHR) * displayPropertiesCount);
-        if(!displayProperties)
-        {
+        if (!displayProperties) {
             SDL_OutOfMemory();
             goto error;
         }
 
-        result =
-            vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayPropertiesCount, displayProperties);
+        result = vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayPropertiesCount, displayProperties);
         if (result != VK_SUCCESS || displayPropertiesCount == 0) {
             SDL_free(displayProperties);
             SDL_SetError("Error enumerating physical device displays");
@@ -331,8 +313,7 @@ SDL_bool SDL_Vulkan_Display_CreateSurface(void *vkGetInstanceProcAddr_,
         displayProperties = NULL;
 
         /* Get display mode properties for the chosen display */
-        result =
-            vkGetDisplayModePropertiesKHR(physicalDevice, display, &displayModePropertiesCount, NULL);
+        result = vkGetDisplayModePropertiesKHR(physicalDevice, display, &displayModePropertiesCount, NULL);
         if (result != VK_SUCCESS || displayModePropertiesCount == 0)
         {
             SDL_SetError("Error enumerating display modes");
@@ -341,14 +322,12 @@ SDL_bool SDL_Vulkan_Display_CreateSurface(void *vkGetInstanceProcAddr_,
         SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "vulkandisplay: Number of display modes: %u", displayModePropertiesCount);
 
         displayModeProperties = SDL_malloc(sizeof(VkDisplayModePropertiesKHR) * displayModePropertiesCount);
-        if(!displayModeProperties)
-        {
+        if (!displayModeProperties) {
             SDL_OutOfMemory();
             goto error;
         }
 
-        result =
-            vkGetDisplayModePropertiesKHR(physicalDevice, display, &displayModePropertiesCount, displayModeProperties);
+        result = vkGetDisplayModePropertiesKHR(physicalDevice, display, &displayModePropertiesCount, displayModeProperties);
         if (result != VK_SUCCESS || displayModePropertiesCount == 0) {
             SDL_SetError("Error enumerating display modes");
             SDL_free(displayModeProperties);
@@ -356,18 +335,16 @@ SDL_bool SDL_Vulkan_Display_CreateSurface(void *vkGetInstanceProcAddr_,
         }
 
         /* Try to find a display mode that matches the native resolution */
-        for (i = 0; i < displayModePropertiesCount; ++i)
-        {
+        for (i = 0; i < displayModePropertiesCount; ++i) {
             if (displayModeProperties[i].parameters.visibleRegion.width == extent.width &&
                 displayModeProperties[i].parameters.visibleRegion.height == extent.height &&
-                displayModeProperties[i].parameters.refreshRate > refreshRate)
-            {
+                displayModeProperties[i].parameters.refreshRate > refreshRate) {
                 bestMatchIndex = i;
                 refreshRate = displayModeProperties[i].parameters.refreshRate;
             }
         }
-        if (bestMatchIndex < 0)
-        {
+
+        if (bestMatchIndex < 0) {
             SDL_SetError("Found no matching display mode");
             SDL_free(displayModeProperties);
             goto error;
@@ -384,62 +361,53 @@ SDL_bool SDL_Vulkan_Display_CreateSurface(void *vkGetInstanceProcAddr_,
         displayModeProperties = NULL;
 
         /* Try to find a plane index that supports our display */
-        result =
-            vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, &displayPlanePropertiesCount, NULL);
-        if (result != VK_SUCCESS || displayPlanePropertiesCount == 0)
-        {
+        result = vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, &displayPlanePropertiesCount, NULL);
+        if (result != VK_SUCCESS || displayPlanePropertiesCount == 0) {
             SDL_SetError("Error enumerating display planes");
             goto error;
         }
         SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "vulkandisplay: Number of display planes: %u", displayPlanePropertiesCount);
 
         displayPlaneProperties = SDL_malloc(sizeof(VkDisplayPlanePropertiesKHR) * displayPlanePropertiesCount);
-        if(!displayPlaneProperties)
-        {
+        if (!displayPlaneProperties) {
             SDL_OutOfMemory();
             goto error;
         }
 
-        result =
-            vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, &displayPlanePropertiesCount, displayPlaneProperties);
-        if (result != VK_SUCCESS || displayPlanePropertiesCount == 0)
-        {
+        result = vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, &displayPlanePropertiesCount, displayPlaneProperties);
+        if (result != VK_SUCCESS || displayPlanePropertiesCount == 0) {
             SDL_SetError("Error enumerating display plane properties");
             SDL_free(displayPlaneProperties);
             goto error;
         }
 
-        for (i = 0; i < displayPlanePropertiesCount; ++i)
-        {
+        for (i = 0; i < displayPlanePropertiesCount; ++i) {
             uint32_t planeSupportedDisplaysCount = 0;
             VkDisplayKHR *planeSupportedDisplays = NULL;
             uint32_t j;
 
             /* Check if plane is attached to a display, if not, continue. */
-            if (displayPlaneProperties[i].currentDisplay == VK_NULL_HANDLE)
+            if (displayPlaneProperties[i].currentDisplay == VK_NULL_HANDLE) {
                 continue;
+            }
 
             /* Check supported displays for this plane. */
-            result =
-                vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, i, &planeSupportedDisplaysCount, NULL);
-            if (result != VK_SUCCESS || planeSupportedDisplaysCount == 0)
-            {
+            result = vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, i, &planeSupportedDisplaysCount, NULL);
+            if (result != VK_SUCCESS || planeSupportedDisplaysCount == 0) {
                 continue;  /* No supported displays, on to next plane. */
             }
+
             SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "vulkandisplay: Number of supported displays for plane %u: %u", i, planeSupportedDisplaysCount);
 
             planeSupportedDisplays = SDL_malloc(sizeof(VkDisplayKHR) * planeSupportedDisplaysCount);
-            if(!planeSupportedDisplays)
-            {
+            if (!planeSupportedDisplays) {
                 SDL_free(displayPlaneProperties);
                 SDL_OutOfMemory();
                 goto error;
             }
 
-            result =
-                vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, i, &planeSupportedDisplaysCount, planeSupportedDisplays);
-            if (result != VK_SUCCESS || planeSupportedDisplaysCount == 0)
-            {
+            result = vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, i, &planeSupportedDisplaysCount, planeSupportedDisplays);
+            if (result != VK_SUCCESS || planeSupportedDisplaysCount == 0) {
                 SDL_SetError("Error enumerating supported displays, or no supported displays");
                 SDL_free(planeSupportedDisplays);
                 SDL_free(displayPlaneProperties);
@@ -447,20 +415,19 @@ SDL_bool SDL_Vulkan_Display_CreateSurface(void *vkGetInstanceProcAddr_,
             }
 
             for (j = 0; j < planeSupportedDisplaysCount && planeSupportedDisplays[j] != display; ++j)
-                ;
+            {
+            }
 
             SDL_free(planeSupportedDisplays);
             planeSupportedDisplays = NULL;
 
-            if (j == planeSupportedDisplaysCount)
-            {
+            if (j == planeSupportedDisplaysCount) {
                 /* This display is not supported for this plane, move on. */
                 continue;
             }
 
             result = vkGetDisplayPlaneCapabilitiesKHR(physicalDevice, createInfo.displayMode, i, &planeCaps);
-            if (result != VK_SUCCESS)
-            {
+            if (result != VK_SUCCESS) {
                 SDL_SetError("Error getting display plane capabilities");
                 SDL_free(displayPlaneProperties);
                 goto error;
@@ -468,8 +435,7 @@ SDL_bool SDL_Vulkan_Display_CreateSurface(void *vkGetInstanceProcAddr_,
 
             /* Check if plane fulfills extent requirements. */
             if (extent.width >= planeCaps.minDstExtent.width && extent.height >= planeCaps.minDstExtent.height &&
-                extent.width <= planeCaps.maxDstExtent.width && extent.height <= planeCaps.maxDstExtent.height)
-            {
+                extent.width <= planeCaps.maxDstExtent.width && extent.height <= planeCaps.maxDstExtent.height) {
                 /* If it does, choose this plane. */
                 SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "vulkandisplay: Choosing plane %d, minimum extent %dx%d maximum extent %dx%d", i,
                         planeCaps.minDstExtent.width, planeCaps.minDstExtent.height,
@@ -479,8 +445,7 @@ SDL_bool SDL_Vulkan_Display_CreateSurface(void *vkGetInstanceProcAddr_,
             }
         }
 
-        if (planeIndex < 0)
-        {
+        if (planeIndex < 0) {
             SDL_SetError("No plane supports the selected resolution");
             SDL_free(displayPlaneProperties);
             goto error;
@@ -509,8 +474,7 @@ SDL_bool SDL_Vulkan_Display_CreateSurface(void *vkGetInstanceProcAddr_,
     SDL_free(physicalDevices);
     physicalDevices = NULL;
 
-    if (physicalDeviceIndex == physicalDeviceCount)
-    {
+    if (physicalDeviceIndex == physicalDeviceCount) {
         SDL_SetError("No usable displays found or requested display out of range");
         return SDL_FALSE;
     }
@@ -519,16 +483,14 @@ SDL_bool SDL_Vulkan_Display_CreateSurface(void *vkGetInstanceProcAddr_,
     createInfo.transform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
     createInfo.globalAlpha = 1.0f;
 
-    result = vkCreateDisplayPlaneSurfaceKHR(instance, &createInfo,
-                                       NULL, surface);
-    if(result != VK_SUCCESS)
-    {
-        SDL_SetError("vkCreateDisplayPlaneSurfaceKHR failed: %s",
-                     SDL_Vulkan_GetResultString(result));
+    result = vkCreateDisplayPlaneSurfaceKHR(instance, &createInfo, NULL, surface);
+    if (result != VK_SUCCESS) {
+        SDL_SetError("vkCreateDisplayPlaneSurfaceKHR failed: %s", SDL_Vulkan_GetResultString(result));
         return SDL_FALSE;
     }
     SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "vulkandisplay: Created surface");
     return SDL_TRUE;
+
 error:
     SDL_free(physicalDevices);
     return SDL_FALSE;
diff --git a/Engine/lib/sdl/src/video/SDL_yuv.c b/Engine/lib/sdl/src/video/SDL_yuv.c
index 4b9755dbe..72ed99d18 100644
--- a/Engine/lib/sdl/src/video/SDL_yuv.c
+++ b/Engine/lib/sdl/src/video/SDL_yuv.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -1839,7 +1839,7 @@ SDL_ConvertPixels_YUV_to_YUV(int width, int height,
         return SDL_SetError("SDL_ConvertPixels_YUV_to_YUV: Unsupported YUV conversion: %s -> %s", SDL_GetPixelFormatName(src_format), SDL_GetPixelFormatName(dst_format));
     }
 #else
-	return SDL_SetError("SDL not built with YUV support");
+    return SDL_SetError("SDL not built with YUV support");
 #endif
 }
 
diff --git a/Engine/lib/sdl/src/video/SDL_yuv_c.h b/Engine/lib/sdl/src/video/SDL_yuv_c.h
index 9b43631b9..d4e2c9108 100644
--- a/Engine/lib/sdl/src/video/SDL_yuv_c.h
+++ b/Engine/lib/sdl/src/video/SDL_yuv_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/android/SDL_androidclipboard.c b/Engine/lib/sdl/src/video/android/SDL_androidclipboard.c
index 19c2262f7..42460d723 100644
--- a/Engine/lib/sdl/src/video/android/SDL_androidclipboard.c
+++ b/Engine/lib/sdl/src/video/android/SDL_androidclipboard.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/android/SDL_androidclipboard.h b/Engine/lib/sdl/src/video/android/SDL_androidclipboard.h
index 94c66742b..9e6ce60d6 100644
--- a/Engine/lib/sdl/src/video/android/SDL_androidclipboard.h
+++ b/Engine/lib/sdl/src/video/android/SDL_androidclipboard.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/android/SDL_androidevents.c b/Engine/lib/sdl/src/video/android/SDL_androidevents.c
index dfd62123d..3424a8254 100644
--- a/Engine/lib/sdl/src/video/android/SDL_androidevents.c
+++ b/Engine/lib/sdl/src/video/android/SDL_androidevents.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -48,6 +48,18 @@ static void openslES_ResumeDevices(void) {}
 static void openslES_PauseDevices(void) {}
 #endif
 
+#if !SDL_AUDIO_DISABLED && SDL_AUDIO_DRIVER_AAUDIO
+extern void aaudio_ResumeDevices(void);
+extern void aaudio_PauseDevices(void);
+SDL_bool aaudio_DetectBrokenPlayState( void );
+#else
+static void aaudio_ResumeDevices(void) {}
+static void aaudio_PauseDevices(void) {}
+static SDL_bool aaudio_DetectBrokenPlayState( void ) { return SDL_FALSE; }
+#endif
+
+
+
 /* Number of 'type' events in the event queue */
 static int
 SDL_NumberOfEvents(Uint32 type)
@@ -55,6 +67,7 @@ SDL_NumberOfEvents(Uint32 type)
     return SDL_PeepEvents(NULL, 0, SDL_PEEKEVENT, type, type);
 }
 
+#if SDL_VIDEO_OPENGL_EGL
 static void
 android_egl_context_restore(SDL_Window *window)
 {
@@ -84,7 +97,7 @@ android_egl_context_backup(SDL_Window *window)
         data->backup_done = 1;
     }
 }
-
+#endif
 
 /*
  * Android_ResumeSem and Android_PauseSem are signaled from Java_org_libsdl_app_SDLActivity_nativePause and Java_org_libsdl_app_SDLActivity_nativeResume
@@ -101,15 +114,18 @@ Android_PumpEvents_Blocking(_THIS)
     if (videodata->isPaused) {
         SDL_bool isContextExternal = SDL_IsVideoContextExternal();
 
+#if SDL_VIDEO_OPENGL_EGL
         /* Make sure this is the last thing we do before pausing */
         if (!isContextExternal) {
             SDL_LockMutex(Android_ActivityMutex);
             android_egl_context_backup(Android_Window);
             SDL_UnlockMutex(Android_ActivityMutex);
         }
+#endif
 
         ANDROIDAUDIO_PauseDevices();
         openslES_PauseDevices();
+        aaudio_PauseDevices();
 
         if (SDL_SemWait(Android_ResumeSem) == 0) {
 
@@ -122,13 +138,16 @@ Android_PumpEvents_Blocking(_THIS)
 
             ANDROIDAUDIO_ResumeDevices();
             openslES_ResumeDevices();
+            aaudio_ResumeDevices();
 
             /* Restore the GL Context from here, as this operation is thread dependent */
+#if SDL_VIDEO_OPENGL_EGL
             if (!isContextExternal && !SDL_HasEvent(SDL_QUIT)) {
                 SDL_LockMutex(Android_ActivityMutex);
                 android_egl_context_restore(Android_Window);
                 SDL_UnlockMutex(Android_ActivityMutex);
             }
+#endif
 
             /* Make sure SW Keyboard is restored when an app becomes foreground */
             if (SDL_IsTextInputActive()) {
@@ -156,6 +175,11 @@ Android_PumpEvents_Blocking(_THIS)
             }
         }
     }
+
+    if ( aaudio_DetectBrokenPlayState() ) {
+        aaudio_PauseDevices();
+        aaudio_ResumeDevices();
+    }
 }
 
 void
@@ -169,15 +193,18 @@ Android_PumpEvents_NonBlocking(_THIS)
         SDL_bool isContextExternal = SDL_IsVideoContextExternal();
         if (backup_context) {
 
+#if SDL_VIDEO_OPENGL_EGL
             if (!isContextExternal) {
                 SDL_LockMutex(Android_ActivityMutex);
                 android_egl_context_backup(Android_Window);
                 SDL_UnlockMutex(Android_ActivityMutex);
             }
+#endif
 
             if (videodata->pauseAudio) {
                 ANDROIDAUDIO_PauseDevices();
                 openslES_PauseDevices();
+                aaudio_PauseDevices();
             }
 
             backup_context = 0;
@@ -196,14 +223,17 @@ Android_PumpEvents_NonBlocking(_THIS)
             if (videodata->pauseAudio) {
                 ANDROIDAUDIO_ResumeDevices();
                 openslES_ResumeDevices();
+                aaudio_ResumeDevices();
             }
 
+#if SDL_VIDEO_OPENGL_EGL
             /* Restore the GL Context from here, as this operation is thread dependent */
             if (!isContextExternal && !SDL_HasEvent(SDL_QUIT)) {
                 SDL_LockMutex(Android_ActivityMutex);
                 android_egl_context_restore(Android_Window);
                 SDL_UnlockMutex(Android_ActivityMutex);
             }
+#endif
 
             /* Make sure SW Keyboard is restored when an app becomes foreground */
             if (SDL_IsTextInputActive()) {
@@ -232,6 +262,11 @@ Android_PumpEvents_NonBlocking(_THIS)
             }
         }
     }
+
+    if ( aaudio_DetectBrokenPlayState() ) {
+        aaudio_PauseDevices();
+        aaudio_ResumeDevices();
+    }
 }
 
 #endif /* SDL_VIDEO_DRIVER_ANDROID */
diff --git a/Engine/lib/sdl/src/video/android/SDL_androidevents.h b/Engine/lib/sdl/src/video/android/SDL_androidevents.h
index d985ea20d..db78b0041 100644
--- a/Engine/lib/sdl/src/video/android/SDL_androidevents.h
+++ b/Engine/lib/sdl/src/video/android/SDL_androidevents.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/android/SDL_androidgl.c b/Engine/lib/sdl/src/video/android/SDL_androidgl.c
index 8c020845a..fe1b17b26 100644
--- a/Engine/lib/sdl/src/video/android/SDL_androidgl.c
+++ b/Engine/lib/sdl/src/video/android/SDL_androidgl.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -20,7 +20,7 @@
 */
 #include "../../SDL_internal.h"
 
-#if SDL_VIDEO_DRIVER_ANDROID
+#if SDL_VIDEO_DRIVER_ANDROID && SDL_VIDEO_OPENGL_EGL
 
 /* Android SDL video driver implementation */
 
@@ -69,7 +69,7 @@ Android_GLES_SwapWindow(_THIS, SDL_Window * window)
 
     /* The following two calls existed in the original Java code
      * If you happen to have a device that's affected by their removal,
-     * please report to Bugzilla. -- Gabriel
+     * please report to our bug tracker. -- Gabriel
      */
 
     /*_this->egl_data->eglWaitNative(EGL_CORE_NATIVE_ENGINE);
diff --git a/Engine/lib/sdl/src/video/android/SDL_androidgl.h b/Engine/lib/sdl/src/video/android/SDL_androidgl.h
index 5cbdaba60..15225303b 100644
--- a/Engine/lib/sdl/src/video/android/SDL_androidgl.h
+++ b/Engine/lib/sdl/src/video/android/SDL_androidgl.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/android/SDL_androidkeyboard.c b/Engine/lib/sdl/src/video/android/SDL_androidkeyboard.c
index 435a8e30d..635a22ead 100644
--- a/Engine/lib/sdl/src/video/android/SDL_androidkeyboard.c
+++ b/Engine/lib/sdl/src/video/android/SDL_androidkeyboard.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/android/SDL_androidkeyboard.h b/Engine/lib/sdl/src/video/android/SDL_androidkeyboard.h
index c617d41e2..01da8ab15 100644
--- a/Engine/lib/sdl/src/video/android/SDL_androidkeyboard.h
+++ b/Engine/lib/sdl/src/video/android/SDL_androidkeyboard.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/android/SDL_androidmessagebox.c b/Engine/lib/sdl/src/video/android/SDL_androidmessagebox.c
index abc2ce9cc..dc8b8ad03 100644
--- a/Engine/lib/sdl/src/video/android/SDL_androidmessagebox.c
+++ b/Engine/lib/sdl/src/video/android/SDL_androidmessagebox.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/android/SDL_androidmessagebox.h b/Engine/lib/sdl/src/video/android/SDL_androidmessagebox.h
index d9eb98441..73b276f83 100644
--- a/Engine/lib/sdl/src/video/android/SDL_androidmessagebox.h
+++ b/Engine/lib/sdl/src/video/android/SDL_androidmessagebox.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/android/SDL_androidmouse.c b/Engine/lib/sdl/src/video/android/SDL_androidmouse.c
index 8f4986203..38953fa07 100644
--- a/Engine/lib/sdl/src/video/android/SDL_androidmouse.c
+++ b/Engine/lib/sdl/src/video/android/SDL_androidmouse.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -113,6 +113,10 @@ Android_CreateSystemCursor(SDL_SystemCursor id)
 static void
 Android_FreeCursor(SDL_Cursor * cursor)
 {
+    SDL_AndroidCursorData *data = (SDL_AndroidCursorData*) cursor->driverdata;
+    if (data->custom_cursor != 0) {
+        Android_JNI_DestroyCustomCursor(data->custom_cursor);
+    }
     SDL_free(cursor->driverdata);
     SDL_free(cursor);
 }
diff --git a/Engine/lib/sdl/src/video/android/SDL_androidmouse.h b/Engine/lib/sdl/src/video/android/SDL_androidmouse.h
index 71d4d291a..b81085999 100644
--- a/Engine/lib/sdl/src/video/android/SDL_androidmouse.h
+++ b/Engine/lib/sdl/src/video/android/SDL_androidmouse.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/android/SDL_androidtouch.c b/Engine/lib/sdl/src/video/android/SDL_androidtouch.c
index 71056e6d4..24d985b0e 100644
--- a/Engine/lib/sdl/src/video/android/SDL_androidtouch.c
+++ b/Engine/lib/sdl/src/video/android/SDL_androidtouch.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/android/SDL_androidtouch.h b/Engine/lib/sdl/src/video/android/SDL_androidtouch.h
index 50c57dea4..641276f3e 100644
--- a/Engine/lib/sdl/src/video/android/SDL_androidtouch.h
+++ b/Engine/lib/sdl/src/video/android/SDL_androidtouch.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/android/SDL_androidvideo.c b/Engine/lib/sdl/src/video/android/SDL_androidvideo.c
index 3cad3beb6..61b9a87e9 100644
--- a/Engine/lib/sdl/src/video/android/SDL_androidvideo.c
+++ b/Engine/lib/sdl/src/video/android/SDL_androidvideo.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -64,7 +64,7 @@ int Android_SurfaceWidth           = 0;
 int Android_SurfaceHeight          = 0;
 static int Android_DeviceWidth     = 0;
 static int Android_DeviceHeight    = 0;
-static Uint32 Android_ScreenFormat = SDL_PIXELFORMAT_UNKNOWN;
+static Uint32 Android_ScreenFormat = SDL_PIXELFORMAT_RGB565; /* Default SurfaceView format, in case this is queried before being filled */
 static int Android_ScreenRate      = 0;
 SDL_sem *Android_PauseSem          = NULL;
 SDL_sem *Android_ResumeSem         = NULL;
@@ -128,6 +128,7 @@ Android_CreateDevice(int devindex)
     device->free = Android_DeleteDevice;
 
     /* GL pointers */
+#if SDL_VIDEO_OPENGL_EGL
     device->GL_LoadLibrary = Android_GLES_LoadLibrary;
     device->GL_GetProcAddress = Android_GLES_GetProcAddress;
     device->GL_UnloadLibrary = Android_GLES_UnloadLibrary;
@@ -137,6 +138,7 @@ Android_CreateDevice(int devindex)
     device->GL_GetSwapInterval = Android_GLES_GetSwapInterval;
     device->GL_SwapWindow = Android_GLES_SwapWindow;
     device->GL_DeleteContext = Android_GLES_DeleteContext;
+#endif
 
 #if SDL_VIDEO_VULKAN
     device->Vulkan_LoadLibrary = Android_Vulkan_LoadLibrary;
@@ -194,7 +196,7 @@ Android_VideoInit(_THIS)
         return -1;
     }
     display = SDL_GetDisplay(display_index);
-    display->orientation = Android_JNI_GetDisplayOrientation();    
+    display->orientation = Android_JNI_GetDisplayOrientation();
 
     SDL_AddDisplayMode(&_this->displays[0], &mode);
 
@@ -222,16 +224,54 @@ Android_GetDisplayDPI(_THIS, SDL_VideoDisplay *display, float *ddpi, float *hdpi
 }
 
 void
-Android_SetScreenResolution(int surfaceWidth, int surfaceHeight, int deviceWidth, int deviceHeight, Uint32 format, float rate)
+Android_SetScreenResolution(int surfaceWidth, int surfaceHeight, int deviceWidth, int deviceHeight, float rate)
 {
     Android_SurfaceWidth  = surfaceWidth;
     Android_SurfaceHeight = surfaceHeight;
     Android_DeviceWidth   = deviceWidth;
     Android_DeviceHeight  = deviceHeight;
-    Android_ScreenFormat  = format;
     Android_ScreenRate    = (int)rate;
 }
 
+static
+Uint32 format_to_pixelFormat(int format) {
+    Uint32 pf;
+    if (format == AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM) {  /* 1 */
+        pf = SDL_PIXELFORMAT_RGBA8888;
+    } else if (format == AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM) { /* 2 */
+        pf = SDL_PIXELFORMAT_RGBX8888;
+    } else if (format == AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM) { /* 3 */
+        pf = SDL_PIXELFORMAT_RGB24;
+    } else if (format == AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM) { /* 4*/
+        pf = SDL_PIXELFORMAT_RGB565;
+    } else if (format == 5) {
+        pf = SDL_PIXELFORMAT_BGRA8888;
+    } else if (format == 6) {
+        pf = SDL_PIXELFORMAT_RGBA5551;
+    } else if (format == 7) {
+        pf = SDL_PIXELFORMAT_RGBA4444;
+    } else {
+        pf = SDL_PIXELFORMAT_UNKNOWN;
+    }
+    return pf;
+}
+
+void
+Android_SetFormat(int format_wanted, int format_got)
+{
+    Uint32 pf_wanted;
+    Uint32 pf_got;
+
+    pf_wanted = format_to_pixelFormat(format_wanted);
+    pf_got = format_to_pixelFormat(format_got);
+
+    Android_ScreenFormat = pf_got;
+
+    SDL_Log("pixel format wanted %s (%d), got %s (%d)",
+            SDL_GetPixelFormatName(pf_wanted), format_wanted,
+            SDL_GetPixelFormatName(pf_got), format_got);
+}
+
 void Android_SendResize(SDL_Window *window)
 {
     /*
diff --git a/Engine/lib/sdl/src/video/android/SDL_androidvideo.h b/Engine/lib/sdl/src/video/android/SDL_androidvideo.h
index b94e879ea..371419ba3 100644
--- a/Engine/lib/sdl/src/video/android/SDL_androidvideo.h
+++ b/Engine/lib/sdl/src/video/android/SDL_androidvideo.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -28,7 +28,8 @@
 #include "../SDL_sysvideo.h"
 
 /* Called by the JNI layer when the screen changes size or format */
-extern void Android_SetScreenResolution(int surfaceWidth, int surfaceHeight, int deviceWidth, int deviceHeight, Uint32 format, float rate);
+extern void Android_SetScreenResolution(int surfaceWidth, int surfaceHeight, int deviceWidth, int deviceHeight, float rate);
+extern void Android_SetFormat(int format_wanted, int format_got);
 extern void Android_SendResize(SDL_Window *window);
 
 /* Private display data */
diff --git a/Engine/lib/sdl/src/video/android/SDL_androidvulkan.c b/Engine/lib/sdl/src/video/android/SDL_androidvulkan.c
index 776377f19..058165f57 100644
--- a/Engine/lib/sdl/src/video/android/SDL_androidvulkan.c
+++ b/Engine/lib/sdl/src/video/android/SDL_androidvulkan.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/android/SDL_androidvulkan.h b/Engine/lib/sdl/src/video/android/SDL_androidvulkan.h
index ee18c3664..f8f23eee5 100644
--- a/Engine/lib/sdl/src/video/android/SDL_androidvulkan.h
+++ b/Engine/lib/sdl/src/video/android/SDL_androidvulkan.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/android/SDL_androidwindow.c b/Engine/lib/sdl/src/video/android/SDL_androidwindow.c
index bf4bc914a..c5f8919ea 100644
--- a/Engine/lib/sdl/src/video/android/SDL_androidwindow.c
+++ b/Engine/lib/sdl/src/video/android/SDL_androidwindow.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -81,6 +81,7 @@ Android_CreateWindow(_THIS, SDL_Window * window)
 
     /* Do not create EGLSurface for Vulkan window since it will then make the window
        incompatible with vkCreateAndroidSurfaceKHR */
+#if SDL_VIDEO_OPENGL_EGL
     if ((window->flags & SDL_WINDOW_OPENGL) != 0) {
         data->egl_surface = SDL_EGL_CreateSurface(_this, (NativeWindowType) data->native_window);
 
@@ -91,6 +92,7 @@ Android_CreateWindow(_THIS, SDL_Window * window)
             goto endfunction;
         }
     }
+#endif
 
     window->driverdata = data;
     Android_Window = window;
@@ -175,9 +177,13 @@ Android_DestroyWindow(_THIS, SDL_Window *window)
 
         if (window->driverdata) {
             SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
+
+#if SDL_VIDEO_OPENGL_EGL
             if (data->egl_surface != EGL_NO_SURFACE) {
                 SDL_EGL_DestroySurface(_this, data->egl_surface);
             }
+#endif
+
             if (data->native_window) {
                 ANativeWindow_release(data->native_window);
             }
@@ -198,7 +204,11 @@ Android_GetWindowWMInfo(_THIS, SDL_Window *window, SDL_SysWMinfo *info)
         info->version.minor == SDL_MINOR_VERSION) {
         info->subsystem = SDL_SYSWM_ANDROID;
         info->info.android.window = data->native_window;
+
+#if SDL_VIDEO_OPENGL_EGL
         info->info.android.surface = data->egl_surface;
+#endif
+
         return SDL_TRUE;
     } else {
         SDL_SetError("Application not compiled with SDL %d.%d",
diff --git a/Engine/lib/sdl/src/video/android/SDL_androidwindow.h b/Engine/lib/sdl/src/video/android/SDL_androidwindow.h
index c26a072ee..e78d5068e 100644
--- a/Engine/lib/sdl/src/video/android/SDL_androidwindow.h
+++ b/Engine/lib/sdl/src/video/android/SDL_androidwindow.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -37,8 +37,10 @@ extern SDL_Window *Android_Window;
 
 typedef struct
 {
+#if SDL_VIDEO_OPENGL_EGL
     EGLSurface egl_surface;
     EGLContext egl_context; /* We use this to preserve the context when losing focus */
+#endif
     SDL_bool   backup_done;
     ANativeWindow *native_window;
     
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoaclipboard.h b/Engine/lib/sdl/src/video/cocoa/SDL_cocoaclipboard.h
index 26e741ee8..dd5e25224 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoaclipboard.h
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoaclipboard.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoaclipboard.m b/Engine/lib/sdl/src/video/cocoa/SDL_cocoaclipboard.m
index 0ff90d0f8..1995c7289 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoaclipboard.m
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoaclipboard.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -32,10 +32,14 @@ Cocoa_SetClipboardText(_THIS, const char *text)
     SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
     NSPasteboard *pasteboard;
     NSString *format = NSPasteboardTypeString;
+    NSString *nsstr = [NSString stringWithUTF8String:text];
+    if (nsstr == nil) {
+        return SDL_SetError("Couldn't create NSString; is your string data in UTF-8 format?");
+    }
 
     pasteboard = [NSPasteboard generalPasteboard];
     data->clipboard_count = [pasteboard declareTypes:[NSArray arrayWithObject:format] owner:nil];
-    [pasteboard setString:[NSString stringWithUTF8String:text] forType:format];
+    [pasteboard setString:nsstr forType:format];
 
     return 0;
 }}
@@ -61,7 +65,7 @@ Cocoa_GetClipboardText(_THIS)
         } else {
             utf8 = [string UTF8String];
         }
-        text = SDL_strdup(utf8);
+        text = SDL_strdup(utf8 ? utf8 : "");
     } else {
         text = SDL_strdup("");
     }
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoaevents.h b/Engine/lib/sdl/src/video/cocoa/SDL_cocoaevents.h
index 7653c4550..ae49be099 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoaevents.h
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoaevents.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -25,6 +25,8 @@
 
 extern void Cocoa_RegisterApp(void);
 extern void Cocoa_PumpEvents(_THIS);
+extern int  Cocoa_WaitEventTimeout(_THIS, int timeout);
+extern void Cocoa_SendWakeupEvent(_THIS, SDL_Window *window);
 extern void Cocoa_SuspendScreenSaver(_THIS);
 
 #endif /* SDL_cocoaevents_h_ */
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoaevents.m b/Engine/lib/sdl/src/video/cocoa/SDL_cocoaevents.m
index a55e9d9d4..d077bad6e 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoaevents.m
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoaevents.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -35,6 +35,24 @@
 #ifndef NSAppKitVersionNumber10_8
 #define NSAppKitVersionNumber10_8 1187
 #endif
+#ifndef MAC_OS_X_VERSION_10_12
+#define NSEventTypeApplicationDefined NSApplicationDefined
+#endif
+
+static SDL_Window *FindSDLWindowForNSWindow(NSWindow *win)
+{
+    SDL_Window *sdlwindow = NULL;
+    SDL_VideoDevice *device = SDL_GetVideoDevice();
+    if (device && device->windows) {
+        for (sdlwindow = device->windows; sdlwindow; sdlwindow = sdlwindow->next) {
+            NSWindow *nswindow = ((SDL_WindowData *) sdlwindow->driverdata)->nswindow;
+            if (win == nswindow)
+                return sdlwindow;
+        }
+    }
+
+    return sdlwindow;
+}
 
 @interface SDLApplication : NSApplication
 
@@ -158,6 +176,13 @@ static void Cocoa_DispatchEvent(NSEvent *theEvent)
     [center removeObserver:self name:NSApplicationDidBecomeActiveNotification object:nil];
     [center removeObserver:self name:NSCurrentLocaleDidChangeNotification object:nil];
 
+    /* Remove our URL event handler only if we set it */
+    if ([NSApp delegate] == self) {
+        [[NSAppleEventManager sharedAppleEventManager]
+            removeEventHandlerForEventClass:kInternetEventClass
+                                 andEventID:kAEGetURL];
+    }
+
     [super dealloc];
 }
 
@@ -169,6 +194,10 @@ static void Cocoa_DispatchEvent(NSEvent *theEvent)
         return;
     }
 
+    /* Don't do anything if this was not an SDL window that was closed */
+    if (FindSDLWindowForNSWindow(win) == NULL)
+        return;
+
     /* HACK: Make the next window in the z-order key when the key window is
      * closed. The custom event loop and/or windowing code we have seems to
      * prevent the normal behavior: https://bugzilla.libsdl.org/show_bug.cgi?id=1825
@@ -213,6 +242,13 @@ static void Cocoa_DispatchEvent(NSEvent *theEvent)
         return;
     }
 
+    /* Don't do anything if the application already has a key window
+     * that is not an SDL window.
+     */
+    if ([NSApp keyWindow] && FindSDLWindowForNSWindow([NSApp keyWindow]) == NULL) {
+        return;
+    }
+
     SDL_VideoDevice *device = SDL_GetVideoDevice();
     if (device && device->windows) {
         SDL_Window *window = device->windows;
@@ -262,12 +298,6 @@ static void Cocoa_DispatchEvent(NSEvent *theEvent)
         [NSApp activateIgnoringOtherApps:YES];
     }
 
-    [[NSAppleEventManager sharedAppleEventManager]
-    setEventHandler:self
-        andSelector:@selector(handleURLEvent:withReplyEvent:)
-      forEventClass:kInternetEventClass
-         andEventID:kAEGetURL];
-
     /* If we call this before NSApp activation, macOS might print a complaint
      * about ApplePersistenceIgnoreState. */
     [SDLApplication registerUserDefaults];
@@ -469,6 +499,15 @@ Cocoa_RegisterApp(void)
          * termination into SDL_Quit, and we can't handle application:openFile:
          */
         if (![NSApp delegate]) {
+            /* Only register the URL event handler if we are being set as the
+             * app delegate to avoid replacing any existing event handler.
+             */
+            [[NSAppleEventManager sharedAppleEventManager]
+                setEventHandler:appDelegate
+                    andSelector:@selector(handleURLEvent:withReplyEvent:)
+                  forEventClass:kInternetEventClass
+                     andEventID:kAEGetURL];
+
             [(NSApplication *)NSApp setDelegate:appDelegate];
         } else {
             appDelegate->seenFirstActivate = YES;
@@ -476,9 +515,8 @@ Cocoa_RegisterApp(void)
     }
 }}
 
-void
-Cocoa_PumpEvents(_THIS)
-{ @autoreleasepool
+int
+Cocoa_PumpEventsUntilDate(_THIS, NSDate *expiration, bool accumulate)
 {
 #if MAC_OS_X_VERSION_MIN_REQUIRED < 1070
     /* Update activity every 30 seconds to prevent screensaver */
@@ -494,9 +532,9 @@ Cocoa_PumpEvents(_THIS)
 #endif
 
     for ( ; ; ) {
-        NSEvent *event = [NSApp nextEventMatchingMask:NSEventMaskAny untilDate:[NSDate distantPast] inMode:NSDefaultRunLoopMode dequeue:YES ];
+        NSEvent *event = [NSApp nextEventMatchingMask:NSEventMaskAny untilDate:expiration inMode:NSDefaultRunLoopMode dequeue:YES ];
         if ( event == nil ) {
-            break;
+            return 0;
         }
 
         if (!s_bShouldHandleEventsInSDLApplication) {
@@ -505,7 +543,52 @@ Cocoa_PumpEvents(_THIS)
 
         // Pass events down to SDLApplication to be handled in sendEvent:
         [NSApp sendEvent:event];
+        if ( !accumulate) {
+            break;
+        }
     }
+    return 1;
+}
+
+int
+Cocoa_WaitEventTimeout(_THIS, int timeout)
+{ @autoreleasepool
+{
+    if (timeout > 0) {
+        NSDate *limitDate = [NSDate dateWithTimeIntervalSinceNow: (double) timeout / 1000.0];
+        return Cocoa_PumpEventsUntilDate(_this, limitDate, false);
+    } else if (timeout == 0) {
+        return Cocoa_PumpEventsUntilDate(_this, [NSDate distantPast], false);
+    } else {
+        while (Cocoa_PumpEventsUntilDate(_this, [NSDate distantFuture], false) == 0) {
+        }
+    }
+    return 1;
+}}
+
+void
+Cocoa_PumpEvents(_THIS)
+{ @autoreleasepool
+{
+    Cocoa_PumpEventsUntilDate(_this, [NSDate distantPast], true);
+}}
+
+void Cocoa_SendWakeupEvent(_THIS, SDL_Window *window)
+{ @autoreleasepool
+{
+    NSWindow *nswindow = ((SDL_WindowData *) window->driverdata)->nswindow;
+
+    NSEvent* event = [NSEvent otherEventWithType: NSEventTypeApplicationDefined
+                                    location: NSMakePoint(0,0)
+                               modifierFlags: 0
+                                   timestamp: 0.0
+                                windowNumber: nswindow.windowNumber
+                                     context: nil
+                                     subtype: 0
+                                       data1: 0
+                                       data2: 0];
+
+    [NSApp postEvent: event atStart: YES];
 }}
 
 void
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoakeyboard.h b/Engine/lib/sdl/src/video/cocoa/SDL_cocoakeyboard.h
index e81f61600..9ff2affdb 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoakeyboard.h
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoakeyboard.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -31,6 +31,8 @@ extern void Cocoa_StartTextInput(_THIS);
 extern void Cocoa_StopTextInput(_THIS);
 extern void Cocoa_SetTextInputRect(_THIS, SDL_Rect *rect);
 
+extern void Cocoa_SetWindowKeyboardGrab(_THIS, SDL_Window * window, SDL_bool grabbed);
+
 #endif /* SDL_cocoakeyboard_h_ */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoakeyboard.m b/Engine/lib/sdl/src/video/cocoa/SDL_cocoakeyboard.m
index 26a18bdd0..b229ac3f6 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoakeyboard.m
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoakeyboard.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -602,6 +602,23 @@ Cocoa_QuitKeyboard(_THIS)
 {
 }
 
+typedef int CGSConnection;
+typedef enum {
+    CGSGlobalHotKeyEnable = 0,
+    CGSGlobalHotKeyDisable = 1,
+} CGSGlobalHotKeyOperatingMode;
+
+extern CGSConnection _CGSDefaultConnection(void);
+extern CGError CGSSetGlobalHotKeyOperatingMode(CGSConnection connection, CGSGlobalHotKeyOperatingMode mode);
+
+void
+Cocoa_SetWindowKeyboardGrab(_THIS, SDL_Window * window, SDL_bool grabbed)
+{
+#if SDL_MAC_NO_SANDBOX
+    CGSSetGlobalHotKeyOperatingMode(_CGSDefaultConnection(), grabbed ? CGSGlobalHotKeyDisable : CGSGlobalHotKeyEnable);
+#endif
+}
+
 #endif /* SDL_VIDEO_DRIVER_COCOA */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoamessagebox.h b/Engine/lib/sdl/src/video/cocoa/SDL_cocoamessagebox.h
index 15bcfbadf..439a68a80 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoamessagebox.h
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoamessagebox.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoamessagebox.m b/Engine/lib/sdl/src/video/cocoa/SDL_cocoamessagebox.m
index 91a5660ef..e3fc20b7e 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoamessagebox.m
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoamessagebox.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -89,10 +89,8 @@
 @end
 
 
-/* Display a Cocoa message box */
-int
-Cocoa_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid)
-{ @autoreleasepool
+static void
+Cocoa_ShowMessageBoxImpl(const SDL_MessageBoxData *messageboxdata, int *buttonid, int *returnValue)
 {
     Cocoa_RegisterApp();
 
@@ -133,11 +131,8 @@ Cocoa_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid)
 
     SDLMessageBoxPresenter* presenter = [[[SDLMessageBoxPresenter alloc] initWithParentWindow:messageboxdata->window] autorelease];
 
-    [presenter performSelectorOnMainThread:@selector(showAlert:)
-                                withObject:alert
-                             waitUntilDone:YES];
+    [presenter showAlert:alert];
 
-    int returnValue = 0;
     NSInteger clicked = presenter->clicked;
     if (clicked >= NSAlertFirstButtonReturn) {
         clicked -= NSAlertFirstButtonReturn;
@@ -145,10 +140,24 @@ Cocoa_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid)
             clicked = messageboxdata->numbuttons - 1 - clicked;
         }
         *buttonid = buttons[clicked].buttonid;
+        *returnValue = 0;
     } else {
-        returnValue = SDL_SetError("Did not get a valid `clicked button' id: %ld", (long)clicked);
+        *returnValue = SDL_SetError("Did not get a valid `clicked button' id: %ld", (long)clicked);
     }
+}
 
+/* Display a Cocoa message box */
+int
+Cocoa_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid)
+{ @autoreleasepool
+{
+    __block int returnValue = 0;
+
+    if ([NSThread isMainThread]) {
+        Cocoa_ShowMessageBoxImpl(messageboxdata, buttonid, &returnValue);
+    } else {
+        dispatch_sync(dispatch_get_main_queue(), ^{ Cocoa_ShowMessageBoxImpl(messageboxdata, buttonid, &returnValue); });
+    }
     return returnValue;
 }}
 
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoametalview.h b/Engine/lib/sdl/src/video/cocoa/SDL_cocoametalview.h
index c173a0e7d..d8948b3d6 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoametalview.h
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoametalview.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -39,7 +39,6 @@
 #import <Metal/Metal.h>
 #import <QuartzCore/CAMetalLayer.h>
 
-#define METALVIEW_TAG 255
 
 @interface SDL_cocoametalview : NSView
 
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoametalview.m b/Engine/lib/sdl/src/video/cocoa/SDL_cocoametalview.m
index a55b6337a..6e33c4899 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoametalview.m
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoametalview.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -31,6 +31,8 @@
 #if SDL_VIDEO_DRIVER_COCOA && (SDL_VIDEO_VULKAN || SDL_VIDEO_METAL)
 
 #include "SDL_events.h"
+#include "SDL_syswm.h"
+
 
 static int SDLCALL
 SDL_MetalViewEventWatch(void *userdata, SDL_Event *event)
@@ -103,7 +105,7 @@ SDL_MetalViewEventWatch(void *userdata, SDL_Event *event)
 
 - (NSInteger)tag
 {
-    return METALVIEW_TAG;
+    return SDL_METALVIEW_TAG;
 }
 
 - (void)updateDrawableSize
@@ -172,8 +174,8 @@ void
 Cocoa_Metal_GetDrawableSize(_THIS, SDL_Window * window, int * w, int * h)
 { @autoreleasepool {
     SDL_WindowData *data = (__bridge SDL_WindowData *)window->driverdata;
-    NSView *view = data->nswindow.contentView;
-    SDL_cocoametalview* metalview = [view viewWithTag:METALVIEW_TAG];
+    NSView *contentView = data->sdlContentView;
+    SDL_cocoametalview* metalview = [contentView viewWithTag:SDL_METALVIEW_TAG];
     if (metalview) {
         CAMetalLayer *layer = (CAMetalLayer*)metalview.layer;
         SDL_assert(layer != NULL);
@@ -184,7 +186,21 @@ Cocoa_Metal_GetDrawableSize(_THIS, SDL_Window * window, int * w, int * h)
             *h = layer.drawableSize.height;
         }
     } else {
-        SDL_GetWindowSize(window, w, h);
+        /* Fall back to the viewport size. */
+        NSRect viewport = [contentView bounds];
+        if (window->flags & SDL_WINDOW_ALLOW_HIGHDPI) {
+            /* This gives us the correct viewport for a Retina-enabled view, only
+             * supported on 10.7+. */
+            if ([contentView respondsToSelector:@selector(convertRectToBacking:)]) {
+                viewport = [contentView convertRectToBacking:viewport];
+            }
+        }
+        if (w) {
+            *w = viewport.size.width;
+        }
+        if (h) {
+            *h = viewport.size.height;
+        }
     }
 }}
 
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoamodes.h b/Engine/lib/sdl/src/video/cocoa/SDL_cocoamodes.h
index 836fda70a..a4176dee8 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoamodes.h
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoamodes.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoamodes.m b/Engine/lib/sdl/src/video/cocoa/SDL_cocoamodes.m
index 238be8da3..7d19030b2 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoamodes.m
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoamodes.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -40,6 +40,9 @@
 #ifndef MAC_OS_X_VERSION_10_13
 #define NSAppKitVersionNumber10_12 1504
 #endif
+#if (IOGRAPHICSTYPES_REV < 40)
+#define kDisplayModeNativeFlag 0x02000000
+#endif
 
 
 static void
@@ -162,7 +165,7 @@ GetDisplayModePixelFormat(CGDisplayModeRef vidmode)
 }
 
 static SDL_bool
-GetDisplayMode(_THIS, CGDisplayModeRef vidmode, CFArrayRef modelist, CVDisplayLinkRef link, SDL_DisplayMode *mode)
+GetDisplayMode(_THIS, CGDisplayModeRef vidmode, SDL_bool vidmodeCurrent, CFArrayRef modelist, CVDisplayLinkRef link, SDL_DisplayMode *mode)
 {
     SDL_DisplayModeData *data;
     bool usableForGUI = CGDisplayModeIsUsableForDesktopGUI(vidmode);
@@ -178,7 +181,9 @@ GetDisplayMode(_THIS, CGDisplayModeRef vidmode, CFArrayRef modelist, CVDisplayLi
         return SDL_FALSE;
     }
 
-    if (!HasValidDisplayModeFlags(vidmode)) {
+    /* Don't fail the current mode based on flags because this could prevent Cocoa_InitModes from
+     * succeeding if the current mode lacks certain flags (esp kDisplayModeSafeFlag). */
+    if (!vidmodeCurrent && !HasValidDisplayModeFlags(vidmode)) {
         return SDL_FALSE;
     }
 
@@ -375,7 +380,7 @@ Cocoa_InitModes(_THIS)
             SDL_zero(display);
             /* this returns a stddup'ed string */
             display.name = (char *)Cocoa_GetDisplayName(displays[i]);
-            if (!GetDisplayMode(_this, moderef, NULL, link, &mode)) {
+            if (!GetDisplayMode(_this, moderef, SDL_TRUE, NULL, link, &mode)) {
                 CVDisplayLinkRelease(link);
                 CGDisplayModeRelease(moderef);
                 SDL_free(display.name);
@@ -452,28 +457,68 @@ Cocoa_GetDisplayDPI(_THIS, SDL_VideoDisplay * display, float * ddpi, float * hdp
     /* we need the backingScaleFactor for Retina displays, which is only exposed through NSScreen, not CGDisplay, afaik, so find our screen... */
     CGFloat scaleFactor = 1.0f;
     NSArray *screens = [NSScreen screens];
+    NSSize displayNativeSize;
+    displayNativeSize.width = (int) CGDisplayPixelsWide(data->display);
+    displayNativeSize.height = (int) CGDisplayPixelsHigh(data->display);
+    
     for (NSScreen *screen in screens) {
         const CGDirectDisplayID dpyid = (const CGDirectDisplayID ) [[[screen deviceDescription] objectForKey:@"NSScreenNumber"] unsignedIntValue];
         if (dpyid == data->display) {
-            if ([screen respondsToSelector:@selector(backingScaleFactor)]) {  // Mac OS X 10.7 and later
+#ifdef MAC_OS_X_VERSION_10_8
+            /* Neither CGDisplayScreenSize(description's NSScreenNumber) nor [NSScreen backingScaleFactor] can calculate the correct dpi in macOS. E.g. backingScaleFactor is always 2 in all display modes for rMBP 16" */
+            if (floor(NSAppKitVersionNumber) > NSAppKitVersionNumber10_7) {
+                CFStringRef dmKeys[1] = { kCGDisplayShowDuplicateLowResolutionModes };
+                CFBooleanRef dmValues[1] = { kCFBooleanTrue };
+                CFDictionaryRef dmOptions = CFDictionaryCreate(kCFAllocatorDefault, (const void**) dmKeys, (const void**) dmValues, 1, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks );
+                CFArrayRef allDisplayModes = CGDisplayCopyAllDisplayModes(dpyid, dmOptions);
+                CFIndex n = CFArrayGetCount(allDisplayModes);
+                for(CFIndex i = 0; i < n; ++i) {
+                    CGDisplayModeRef m = (CGDisplayModeRef)CFArrayGetValueAtIndex(allDisplayModes, i);
+                    CGFloat width = CGDisplayModeGetPixelWidth(m);
+                    CGFloat height = CGDisplayModeGetPixelHeight(m);
+                    CGFloat HiDPIWidth = CGDisplayModeGetWidth(m);
+                    
+                    //Only check 1x mode
+                    if(width == HiDPIWidth) {
+                        if (CGDisplayModeGetIOFlags(m) & kDisplayModeNativeFlag) {
+                            displayNativeSize.width = width;
+                            displayNativeSize.height = height;
+                            break;
+                        }
+                        
+                        //Get the largest size even if kDisplayModeNativeFlag is not present e.g. iMac 27-Inch with 5K Retina
+                        if(width > displayNativeSize.width) {
+                            displayNativeSize.width = width;
+                            displayNativeSize.height = height;
+                        }
+                    }
+                }
+                CFRelease(allDisplayModes);
+                CFRelease(dmOptions);
+            } else
+#endif
+            if (floor(NSAppKitVersionNumber) > NSAppKitVersionNumber10_6) {
+                // fallback for 10.7
                 scaleFactor = [screen backingScaleFactor];
+                displayNativeSize.width = displayNativeSize.width * scaleFactor;
+                displayNativeSize.height = displayNativeSize.height * scaleFactor;
                 break;
             }
         }
     }
 
     const CGSize displaySize = CGDisplayScreenSize(data->display);
-    const int pixelWidth =  (int) CGDisplayPixelsWide(data->display);
-    const int pixelHeight = (int) CGDisplayPixelsHigh(data->display);
+    const int pixelWidth =  displayNativeSize.width;
+    const int pixelHeight = displayNativeSize.height;
 
     if (ddpi) {
-        *ddpi = (SDL_ComputeDiagonalDPI(pixelWidth, pixelHeight, displaySize.width / MM_IN_INCH, displaySize.height / MM_IN_INCH)) * scaleFactor;
+        *ddpi = (SDL_ComputeDiagonalDPI(pixelWidth, pixelHeight, displaySize.width / MM_IN_INCH, displaySize.height / MM_IN_INCH));
     }
     if (hdpi) {
-        *hdpi = (pixelWidth * MM_IN_INCH / displaySize.width) * scaleFactor;
+        *hdpi = (pixelWidth * MM_IN_INCH / displaySize.width);
     }
     if (vdpi) {
-        *vdpi = (pixelHeight * MM_IN_INCH / displaySize.height) * scaleFactor;
+        *vdpi = (pixelHeight * MM_IN_INCH / displaySize.height);
     }
 
     return 0;
@@ -499,7 +544,7 @@ Cocoa_GetDisplayModes(_THIS, SDL_VideoDisplay * display)
      * sure there are no duplicates so it's safe to always add the desktop mode
      * even in cases where it is in the CopyAllDisplayModes list.
      */
-    if (desktopmoderef && GetDisplayMode(_this, desktopmoderef, NULL, link, &desktopmode)) {
+    if (desktopmoderef && GetDisplayMode(_this, desktopmoderef, SDL_TRUE, NULL, link, &desktopmode)) {
         if (!SDL_AddDisplayMode(display, &desktopmode)) {
             CFRelease(((SDL_DisplayModeData*)desktopmode.driverdata)->modes);
             SDL_free(desktopmode.driverdata);
@@ -546,7 +591,7 @@ Cocoa_GetDisplayModes(_THIS, SDL_VideoDisplay * display)
             CGDisplayModeRef moderef = (CGDisplayModeRef) CFArrayGetValueAtIndex(modes, i);
             SDL_DisplayMode mode;
 
-            if (GetDisplayMode(_this, moderef, modes, link, &mode)) {
+            if (GetDisplayMode(_this, moderef, SDL_FALSE, modes, link, &mode)) {
                 if (!SDL_AddDisplayMode(display, &mode)) {
                     CFRelease(((SDL_DisplayModeData*)mode.driverdata)->modes);
                     SDL_free(mode.driverdata);
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoamouse.h b/Engine/lib/sdl/src/video/cocoa/SDL_cocoamouse.h
index cde24c8d6..44bbe8a30 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoamouse.h
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoamouse.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -40,7 +40,6 @@ typedef struct {
     /* What location we last saw the cursor move to. */
     CGFloat lastMoveX;
     CGFloat lastMoveY;
-    void *tapdata;
 } SDL_MouseData;
 
 @interface NSCursor (InvisibleCursor)
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoamouse.m b/Engine/lib/sdl/src/video/cocoa/SDL_cocoamouse.m
index 4ce2c61e9..7713fb544 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoamouse.m
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoamouse.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -24,7 +24,6 @@
 
 #include "SDL_events.h"
 #include "SDL_cocoamouse.h"
-#include "SDL_cocoamousetap.h"
 #include "SDL_cocoavideo.h"
 
 #include "../../events/SDL_mouse_c.h"
@@ -216,8 +215,8 @@ Cocoa_WarpMouseGlobal(int x, int y)
     SDL_Mouse *mouse = SDL_GetMouse();
     if (mouse->focus) {
         SDL_WindowData *data = (SDL_WindowData *) mouse->focus->driverdata;
-        if ([data->listener isMoving]) {
-            DLog("Postponing warp, window being moved.");
+        if ([data->listener isMovingOrFocusClickPending]) {
+            DLog("Postponing warp, window being moved or focused.");
             [data->listener setPendingMoveX:x Y:y];
             return 0;
         }
@@ -254,7 +253,7 @@ Cocoa_WarpMouseGlobal(int x, int y)
 static void
 Cocoa_WarpMouse(SDL_Window * window, int x, int y)
 {
-    Cocoa_WarpMouseGlobal(x + window->x, y + window->y);
+    Cocoa_WarpMouseGlobal(window->x + x, window->y + y);
 }
 
 static int
@@ -263,16 +262,16 @@ Cocoa_SetRelativeMouseMode(SDL_bool enabled)
     /* We will re-apply the relative mode when the window gets focus, if it
      * doesn't have focus right now.
      */
-    SDL_Window *window = SDL_GetMouseFocus();
+    SDL_Window *window = SDL_GetKeyboardFocus();
     if (!window) {
-      return 0;
+        return 0;
     }
 
     /* We will re-apply the relative mode when the window finishes being moved,
      * if it is being moved right now.
      */
     SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
-    if ([data->listener isMoving]) {
+    if ([data->listener isMovingOrFocusClickPending]) {
         return 0;
     }
 
@@ -348,14 +347,40 @@ Cocoa_InitMouse(_THIS)
 
     SDL_SetDefaultCursor(Cocoa_CreateDefaultCursor());
 
-    Cocoa_InitMouseEventTap(driverdata);
-
     const NSPoint location =  [NSEvent mouseLocation];
     driverdata->lastMoveX = location.x;
     driverdata->lastMoveY = location.y;
     return 0;
 }
 
+static void
+Cocoa_HandleTitleButtonEvent(_THIS, NSEvent *event)
+{
+    SDL_Window *window;
+    NSWindow *nswindow = [event window];
+
+    for (window = _this->windows; window; window = window->next) {
+        SDL_WindowData *data = (SDL_WindowData *)window->driverdata;
+        if (data && data->nswindow == nswindow) {
+            switch ([event type]) {
+            case NSEventTypeLeftMouseDown:
+            case NSEventTypeRightMouseDown:
+            case NSEventTypeOtherMouseDown:
+                [data->listener setFocusClickPending:[event buttonNumber]];
+                break;
+            case NSEventTypeLeftMouseUp:
+            case NSEventTypeRightMouseUp:
+            case NSEventTypeOtherMouseUp:
+                [data->listener clearFocusClickPending:[event buttonNumber]];
+                break;
+            default:
+                break;
+            }
+            break;
+        }
+    }
+}
+
 void
 Cocoa_HandleMouseEvent(_THIS, NSEvent *event)
 {
@@ -366,6 +391,21 @@ Cocoa_HandleMouseEvent(_THIS, NSEvent *event)
         case NSEventTypeOtherMouseDragged:
             break;
 
+        case NSEventTypeLeftMouseDown:
+        case NSEventTypeLeftMouseUp:
+        case NSEventTypeRightMouseDown:
+        case NSEventTypeRightMouseUp:
+        case NSEventTypeOtherMouseDown:
+        case NSEventTypeOtherMouseUp:
+            if ([event window]) {
+                NSRect windowRect = [[[event window] contentView] frame];
+                if (!NSMouseInRect([event locationInWindow], windowRect, NO)) {
+                    Cocoa_HandleTitleButtonEvent(_this, event);
+                    return;
+                }
+            }
+            return;
+
         default:
             /* Ignore any other events. */
             return;
@@ -433,15 +473,19 @@ Cocoa_HandleMouseWheel(SDL_Window *window, NSEvent *event)
         }
     }
 
-    if (x > 0) {
-        x = SDL_ceil(x);
-    } else if (x < 0) {
-        x = SDL_floor(x);
-    }
-    if (y > 0) {
-        y = SDL_ceil(y);
-    } else if (y < 0) {
-        y = SDL_floor(y);
+    /* For discrete scroll events from conventional mice, always send a full tick.
+       For continuous scroll events from trackpads, send fractional deltas for smoother scrolling. */
+    if (![event respondsToSelector:@selector(hasPreciseScrollingDeltas)] || ![event hasPreciseScrollingDeltas]) {
+        if (x > 0) {
+            x = SDL_ceil(x);
+        } else if (x < 0) {
+            x = SDL_floor(x);
+        }
+        if (y > 0) {
+            y = SDL_ceil(y);
+        } else if (y < 0) {
+            y = SDL_floor(y);
+        }
     }
 
     SDL_SendMouseWheel(window, mouseID, x, y, direction);
@@ -467,8 +511,6 @@ Cocoa_QuitMouse(_THIS)
     SDL_Mouse *mouse = SDL_GetMouse();
     if (mouse) {
         if (mouse->driverdata) {
-            Cocoa_QuitMouseEventTap(((SDL_MouseData*)mouse->driverdata));
-
             SDL_free(mouse->driverdata);
             mouse->driverdata = NULL;
         }
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoamousetap.m b/Engine/lib/sdl/src/video/cocoa/SDL_cocoamousetap.m
deleted file mode 100644
index 953c81a7b..000000000
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoamousetap.m
+++ /dev/null
@@ -1,286 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-#include "../../SDL_internal.h"
-
-#if SDL_VIDEO_DRIVER_COCOA
-
-#include "SDL_cocoamousetap.h"
-
-/* Event taps are forbidden in the Mac App Store, so we can only enable this
- * code if your app doesn't need to ship through the app store.
- * This code makes it so that a grabbed cursor cannot "leak" a mouse click
- * past the edge of the window if moving the cursor too fast.
- */
-#if SDL_MAC_NO_SANDBOX
-
-#include "SDL_keyboard.h"
-#include "SDL_cocoavideo.h"
-#include "../../thread/SDL_systhread.h"
-
-#include "../../events/SDL_mouse_c.h"
-
-typedef struct {
-    CFMachPortRef tap;
-    CFRunLoopRef runloop;
-    CFRunLoopSourceRef runloopSource;
-    SDL_Thread *thread;
-    SDL_sem *runloopStartedSemaphore;
-} SDL_MouseEventTapData;
-
-static const CGEventMask movementEventsMask =
-      CGEventMaskBit(kCGEventLeftMouseDragged)
-    | CGEventMaskBit(kCGEventRightMouseDragged)
-    | CGEventMaskBit(kCGEventMouseMoved);
-
-static const CGEventMask allGrabbedEventsMask =
-      CGEventMaskBit(kCGEventLeftMouseDown)    | CGEventMaskBit(kCGEventLeftMouseUp)
-    | CGEventMaskBit(kCGEventRightMouseDown)   | CGEventMaskBit(kCGEventRightMouseUp)
-    | CGEventMaskBit(kCGEventOtherMouseDown)   | CGEventMaskBit(kCGEventOtherMouseUp)
-    | CGEventMaskBit(kCGEventLeftMouseDragged) | CGEventMaskBit(kCGEventRightMouseDragged)
-    | CGEventMaskBit(kCGEventMouseMoved);
-
-static CGEventRef
-Cocoa_MouseTapCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef event, void *refcon)
-{
-    SDL_MouseEventTapData *tapdata = (SDL_MouseEventTapData*)refcon;
-    SDL_Mouse *mouse = SDL_GetMouse();
-    SDL_Window *window = SDL_GetKeyboardFocus();
-    NSWindow *nswindow;
-    NSRect windowRect;
-    CGPoint eventLocation;
-
-    switch (type) {
-        case kCGEventTapDisabledByTimeout:
-            {
-                CGEventTapEnable(tapdata->tap, true);
-                return NULL;
-            }
-        case kCGEventTapDisabledByUserInput:
-            {
-                return NULL;
-            }
-        default:
-            break;
-    }
-
-
-    if (!window || !mouse) {
-        return event;
-    }
-
-    if (mouse->relative_mode) {
-        return event;
-    }
-
-    if (!(window->flags & SDL_WINDOW_INPUT_GRABBED)) {
-        return event;
-    }
-
-    /* This is the same coordinate system as Cocoa uses. */
-    nswindow = ((SDL_WindowData *) window->driverdata)->nswindow;
-    eventLocation = CGEventGetUnflippedLocation(event);
-    windowRect = [nswindow contentRectForFrameRect:[nswindow frame]];
-
-    if (!NSMouseInRect(NSPointFromCGPoint(eventLocation), windowRect, NO)) {
-
-        /* This is in CGs global screenspace coordinate system, which has a
-         * flipped Y.
-         */
-        CGPoint newLocation = CGEventGetLocation(event);
-
-        if (eventLocation.x < NSMinX(windowRect)) {
-            newLocation.x = NSMinX(windowRect);
-        } else if (eventLocation.x >= NSMaxX(windowRect)) {
-            newLocation.x = NSMaxX(windowRect) - 1.0;
-        }
-
-        if (eventLocation.y <= NSMinY(windowRect)) {
-            newLocation.y -= (NSMinY(windowRect) - eventLocation.y + 1);
-        } else if (eventLocation.y > NSMaxY(windowRect)) {
-            newLocation.y += (eventLocation.y - NSMaxY(windowRect));
-        }
-
-        CGWarpMouseCursorPosition(newLocation);
-        CGAssociateMouseAndMouseCursorPosition(YES);
-
-        if ((CGEventMaskBit(type) & movementEventsMask) == 0) {
-            /* For click events, we just constrain the event to the window, so
-             * no other app receives the click event. We can't due the same to
-             * movement events, since they mean that our warp cursor above
-             * behaves strangely.
-             */
-            CGEventSetLocation(event, newLocation);
-        }
-    }
-
-    return event;
-}
-
-static void
-SemaphorePostCallback(CFRunLoopTimerRef timer, void *info)
-{
-    SDL_SemPost((SDL_sem*)info);
-}
-
-static int
-Cocoa_MouseTapThread(void *data)
-{
-    SDL_MouseEventTapData *tapdata = (SDL_MouseEventTapData*)data;
-
-    /* Tap was created on main thread but we own it now. */
-    CFMachPortRef eventTap = tapdata->tap;
-    if (eventTap) {
-        /* Try to create a runloop source we can schedule. */
-        CFRunLoopSourceRef runloopSource = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, eventTap, 0);
-        if  (runloopSource) {
-            tapdata->runloopSource = runloopSource;
-        } else {
-            CFRelease(eventTap);
-            SDL_SemPost(tapdata->runloopStartedSemaphore);
-            /* TODO: Both here and in the return below, set some state in
-             * tapdata to indicate that initialization failed, which we should
-             * check in InitMouseEventTap, after we move the semaphore check
-             * from Quit to Init.
-             */
-            return 1;
-        }
-    } else {
-        SDL_SemPost(tapdata->runloopStartedSemaphore);
-        return 1;
-    }
-
-    tapdata->runloop = CFRunLoopGetCurrent();
-    CFRunLoopAddSource(tapdata->runloop, tapdata->runloopSource, kCFRunLoopCommonModes);
-    CFRunLoopTimerContext context = {.info = tapdata->runloopStartedSemaphore};
-    /* We signal the runloop started semaphore *after* the run loop has started, indicating it's safe to CFRunLoopStop it. */
-    CFRunLoopTimerRef timer = CFRunLoopTimerCreate(kCFAllocatorDefault, CFAbsoluteTimeGetCurrent(), 0, 0, 0, &SemaphorePostCallback, &context);
-    CFRunLoopAddTimer(tapdata->runloop, timer, kCFRunLoopCommonModes);
-    CFRelease(timer);
-
-    /* Run the event loop to handle events in the event tap. */
-    CFRunLoopRun();
-    /* Make sure this is signaled so that SDL_QuitMouseEventTap knows it can safely SDL_WaitThread for us. */
-    if (SDL_SemValue(tapdata->runloopStartedSemaphore) < 1) {
-        SDL_SemPost(tapdata->runloopStartedSemaphore);
-    }
-    CFRunLoopRemoveSource(tapdata->runloop, tapdata->runloopSource, kCFRunLoopCommonModes);
-
-    /* Clean up. */
-    CGEventTapEnable(tapdata->tap, false);
-    CFRelease(tapdata->runloopSource);
-    CFRelease(tapdata->tap);
-    tapdata->runloopSource = NULL;
-    tapdata->tap = NULL;
-
-    return 0;
-}
-
-void
-Cocoa_InitMouseEventTap(SDL_MouseData* driverdata)
-{
-    SDL_MouseEventTapData *tapdata;
-    driverdata->tapdata = SDL_calloc(1, sizeof(SDL_MouseEventTapData));
-    tapdata = (SDL_MouseEventTapData*)driverdata->tapdata;
-
-    tapdata->runloopStartedSemaphore = SDL_CreateSemaphore(0);
-    if (tapdata->runloopStartedSemaphore) {
-        tapdata->tap = CGEventTapCreate(kCGSessionEventTap, kCGHeadInsertEventTap,
-                                        kCGEventTapOptionDefault, allGrabbedEventsMask,
-                                        &Cocoa_MouseTapCallback, tapdata);
-        if (tapdata->tap) {
-            /* Tap starts disabled, until app requests mouse grab */
-            CGEventTapEnable(tapdata->tap, false);
-            tapdata->thread = SDL_CreateThreadInternal(&Cocoa_MouseTapThread, "Event Tap Loop", 512 * 1024, tapdata);
-            if (tapdata->thread) {
-                /* Success - early out. Ownership transferred to thread. */
-                return;
-            }
-            CFRelease(tapdata->tap);
-        }
-        SDL_DestroySemaphore(tapdata->runloopStartedSemaphore);
-    }
-    SDL_free(driverdata->tapdata);
-    driverdata->tapdata = NULL;
-}
-
-void
-Cocoa_EnableMouseEventTap(SDL_MouseData *driverdata, SDL_bool enabled)
-{
-    SDL_MouseEventTapData *tapdata = (SDL_MouseEventTapData*)driverdata->tapdata;
-    if (tapdata && tapdata->tap)
-    {
-        CGEventTapEnable(tapdata->tap, !!enabled);
-    }
-}
-
-void
-Cocoa_QuitMouseEventTap(SDL_MouseData *driverdata)
-{
-    SDL_MouseEventTapData *tapdata = (SDL_MouseEventTapData*)driverdata->tapdata;
-    int status;
-
-    if (tapdata == NULL) {
-        /* event tap was already cleaned up (possibly due to CGEventTapCreate
-         * returning null.)
-         */
-        return;
-    }
-
-    /* Ensure that the runloop has been started first.
-     * TODO: Move this to InitMouseEventTap, check for error conditions that can
-     * happen in Cocoa_MouseTapThread, and fall back to the non-EventTap way of
-     * grabbing the mouse if it fails to Init.
-     */
-    status = SDL_SemWaitTimeout(tapdata->runloopStartedSemaphore, 5000);
-    if (status > -1) {
-        /* Then stop it, which will cause Cocoa_MouseTapThread to return. */
-        CFRunLoopStop(tapdata->runloop);
-        /* And then wait for Cocoa_MouseTapThread to finish cleaning up. It
-         * releases some of the pointers in tapdata. */
-        SDL_WaitThread(tapdata->thread, &status);
-    }
-
-    SDL_free(driverdata->tapdata);
-    driverdata->tapdata = NULL;
-}
-
-#else /* SDL_MAC_NO_SANDBOX */
-
-void
-Cocoa_InitMouseEventTap(SDL_MouseData *unused)
-{
-}
-
-void
-Cocoa_EnableMouseEventTap(SDL_MouseData *driverdata, SDL_bool enabled)
-{
-}
-
-void
-Cocoa_QuitMouseEventTap(SDL_MouseData *driverdata)
-{
-}
-
-#endif /* !SDL_MAC_NO_SANDBOX */
-
-#endif /* SDL_VIDEO_DRIVER_COCOA */
-
-/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoaopengl.h b/Engine/lib/sdl/src/video/cocoa/SDL_cocoaopengl.h
index bae8ce48a..9ac44ab5f 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoaopengl.h
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoaopengl.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoaopengl.m b/Engine/lib/sdl/src/video/cocoa/SDL_cocoaopengl.m
index 6fb471139..9d31b9c22 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoaopengl.m
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoaopengl.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -135,7 +135,7 @@
     if ([NSThread isMainThread]) {
         [super update];
     } else {
-        dispatch_sync(dispatch_get_main_queue(), ^{ [super update]; });
+        dispatch_async(dispatch_get_main_queue(), ^{ [super update]; });
     }
 }
 
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoaopengles.h b/Engine/lib/sdl/src/video/cocoa/SDL_cocoaopengles.h
index a079601ae..bfabb6d57 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoaopengles.h
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoaopengles.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoaopengles.m b/Engine/lib/sdl/src/video/cocoa/SDL_cocoaopengles.m
index 0f551de10..13102f8c0 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoaopengles.m
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoaopengles.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -109,7 +109,10 @@ Cocoa_GLES_SetupWindow(_THIS, SDL_Window * window)
 
 
     if (_this->egl_data == NULL) {
+        /* !!! FIXME: commenting out this assertion is (I think) incorrect; figure out why driver_loaded is wrong for ANGLE instead. --ryan. */
+        #if 0  /* When hint SDL_HINT_OPENGL_ES_DRIVER is set to "1" (e.g. for ANGLE support), _this->gl_config.driver_loaded can be 1, while the below lines function. */
         SDL_assert(!_this->gl_config.driver_loaded);
+        #endif
         if (SDL_EGL_LoadLibrary(_this, NULL, EGL_DEFAULT_DISPLAY, 0) < 0) {
             SDL_EGL_UnloadLibrary(_this);
             return -1;
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoashape.h b/Engine/lib/sdl/src/video/cocoa/SDL_cocoashape.h
index 739f76285..25c41620a 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoashape.h
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoashape.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoashape.m b/Engine/lib/sdl/src/video/cocoa/SDL_cocoashape.m
index f278c28c2..1176036ac 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoashape.m
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoashape.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoavideo.h b/Engine/lib/sdl/src/video/cocoa/SDL_cocoavideo.h
index 75b264223..af0abe5cc 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoavideo.h
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoavideo.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoavideo.m b/Engine/lib/sdl/src/video/cocoa/SDL_cocoavideo.m
index de809da73..231b2de5c 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoavideo.m
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoavideo.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -38,6 +38,9 @@ static void Cocoa_VideoQuit(_THIS);
 static void
 Cocoa_DeleteDevice(SDL_VideoDevice * device)
 {
+    if (device->wakeup_lock) {
+        SDL_DestroyMutex(device->wakeup_lock);
+    }
     SDL_free(device->driverdata);
     SDL_free(device);
 }
@@ -63,6 +66,7 @@ Cocoa_CreateDevice(int devindex)
         return NULL;
     }
     device->driverdata = data;
+    device->wakeup_lock = SDL_CreateMutex();
 
     /* Set the function pointers */
     device->VideoInit = Cocoa_VideoInit;
@@ -73,6 +77,8 @@ Cocoa_CreateDevice(int devindex)
     device->GetDisplayModes = Cocoa_GetDisplayModes;
     device->SetDisplayMode = Cocoa_SetDisplayMode;
     device->PumpEvents = Cocoa_PumpEvents;
+    device->WaitEventTimeout = Cocoa_WaitEventTimeout;
+    device->SendWakeupEvent = Cocoa_SendWakeupEvent;
     device->SuspendScreenSaver = Cocoa_SuspendScreenSaver;
 
     device->CreateSDLWindow = Cocoa_CreateWindow;
@@ -92,14 +98,19 @@ Cocoa_CreateDevice(int devindex)
     device->RestoreWindow = Cocoa_RestoreWindow;
     device->SetWindowBordered = Cocoa_SetWindowBordered;
     device->SetWindowResizable = Cocoa_SetWindowResizable;
+    device->SetWindowAlwaysOnTop = Cocoa_SetWindowAlwaysOnTop;
     device->SetWindowFullscreen = Cocoa_SetWindowFullscreen;
     device->SetWindowGammaRamp = Cocoa_SetWindowGammaRamp;
     device->GetWindowGammaRamp = Cocoa_GetWindowGammaRamp;
-    device->SetWindowGrab = Cocoa_SetWindowGrab;
+    device->GetWindowICCProfile = Cocoa_GetWindowICCProfile;
+    device->SetWindowMouseRect = Cocoa_SetWindowMouseRect;
+    device->SetWindowMouseGrab = Cocoa_SetWindowMouseGrab;
+    device->SetWindowKeyboardGrab = Cocoa_SetWindowKeyboardGrab;
     device->DestroyWindow = Cocoa_DestroyWindow;
     device->GetWindowWMInfo = Cocoa_GetWindowWMInfo;
     device->SetWindowHitTest = Cocoa_SetWindowHitTest;
     device->AcceptDragAndDrop = Cocoa_AcceptDragAndDrop;
+    device->FlashWindow = Cocoa_FlashWindow;
 
     device->shape_driver.CreateShaper = Cocoa_CreateShaper;
     device->shape_driver.SetWindowShape = Cocoa_SetWindowShape;
@@ -260,7 +271,10 @@ Cocoa_CreateImage(SDL_Surface * surface)
 
 void SDL_NSLog(const char *text)
 {
-    NSLog(@"%s", text);
+    @autoreleasepool {
+        NSString *str = [NSString stringWithUTF8String:text];
+        NSLog(@"%@", str);
+    }
 }
 
 #endif /* SDL_VIDEO_DRIVER_COCOA */
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoavulkan.h b/Engine/lib/sdl/src/video/cocoa/SDL_cocoavulkan.h
index 33dc892f5..9ddc70996 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoavulkan.h
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoavulkan.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoavulkan.m b/Engine/lib/sdl/src/video/cocoa/SDL_cocoavulkan.m
index 2af77ceb9..20c83d47d 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoavulkan.m
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoavulkan.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoawindow.h b/Engine/lib/sdl/src/video/cocoa/SDL_cocoawindow.h
index 4c0570fdf..a42d9c87b 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoawindow.h
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoawindow.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -48,6 +48,7 @@ typedef enum
     BOOL inFullscreenTransition;
     PendingWindowOperation pendingWindowOperation;
     BOOL isMoving;
+    NSInteger focusClickPending;
     int pendingWindowWarpX, pendingWindowWarpY;
     BOOL isDragAreaRunning;
 }
@@ -62,8 +63,12 @@ typedef enum
 -(void) close;
 
 -(BOOL) isMoving;
+-(BOOL) isMovingOrFocusClickPending;
+-(void) setFocusClickPending:(NSInteger) button;
+-(void) clearFocusClickPending:(NSInteger) button;
 -(void) setPendingMoveX:(int)x Y:(int)y;
 -(void) windowDidFinishMoving;
+-(void) onMovingOrFocusClickPendingStateCleared;
 
 /* Window delegate functionality */
 -(BOOL) windowShouldClose:(id) sender;
@@ -75,6 +80,7 @@ typedef enum
 -(void) windowDidBecomeKey:(NSNotification *) aNotification;
 -(void) windowDidResignKey:(NSNotification *) aNotification;
 -(void) windowDidChangeBackingProperties:(NSNotification *) aNotification;
+-(void) windowDidChangeScreenProfile:(NSNotification *) aNotification;
 -(void) windowWillEnterFullScreen:(NSNotification *) aNotification;
 -(void) windowDidEnterFullScreen:(NSNotification *) aNotification;
 -(void) windowWillExitFullScreen:(NSNotification *) aNotification;
@@ -117,6 +123,7 @@ struct SDL_WindowData
     NSMutableArray *nscontexts;
     SDL_bool created;
     SDL_bool inWindowFullscreenTransition;
+    NSInteger flash_request;
     Cocoa_WindowListener *listener;
     struct SDL_VideoData *videodata;
 #if SDL_VIDEO_OPENGL_EGL
@@ -142,14 +149,18 @@ extern void Cocoa_MinimizeWindow(_THIS, SDL_Window * window);
 extern void Cocoa_RestoreWindow(_THIS, SDL_Window * window);
 extern void Cocoa_SetWindowBordered(_THIS, SDL_Window * window, SDL_bool bordered);
 extern void Cocoa_SetWindowResizable(_THIS, SDL_Window * window, SDL_bool resizable);
+extern void Cocoa_SetWindowAlwaysOnTop(_THIS, SDL_Window * window, SDL_bool on_top);
 extern void Cocoa_SetWindowFullscreen(_THIS, SDL_Window * window, SDL_VideoDisplay * display, SDL_bool fullscreen);
 extern int Cocoa_SetWindowGammaRamp(_THIS, SDL_Window * window, const Uint16 * ramp);
+extern void* Cocoa_GetWindowICCProfile(_THIS, SDL_Window * window, size_t * size);
 extern int Cocoa_GetWindowGammaRamp(_THIS, SDL_Window * window, Uint16 * ramp);
-extern void Cocoa_SetWindowGrab(_THIS, SDL_Window * window, SDL_bool grabbed);
+extern void Cocoa_SetWindowMouseRect(_THIS, SDL_Window * window);
+extern void Cocoa_SetWindowMouseGrab(_THIS, SDL_Window * window, SDL_bool grabbed);
 extern void Cocoa_DestroyWindow(_THIS, SDL_Window * window);
 extern SDL_bool Cocoa_GetWindowWMInfo(_THIS, SDL_Window * window, struct SDL_SysWMinfo *info);
 extern int Cocoa_SetWindowHitTest(SDL_Window *window, SDL_bool enabled);
 extern void Cocoa_AcceptDragAndDrop(SDL_Window * window, SDL_bool accept);
+extern int Cocoa_FlashWindow(_THIS, SDL_Window * window, SDL_FlashOperation operation);
 
 #endif /* SDL_cocoawindow_h_ */
 
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoawindow.m b/Engine/lib/sdl/src/video/cocoa/SDL_cocoawindow.m
index e6128db4f..bca8eb4dd 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoawindow.m
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoawindow.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -38,7 +38,6 @@
 #include "SDL_cocoavideo.h"
 #include "SDL_cocoashape.h"
 #include "SDL_cocoamouse.h"
-#include "SDL_cocoamousetap.h"
 #include "SDL_cocoaopengl.h"
 #include "SDL_cocoaopengles.h"
 
@@ -56,9 +55,21 @@
 #ifndef MAC_OS_X_VERSION_10_12
 #define NSEventModifierFlagCapsLock NSAlphaShiftKeyMask
 #endif
-#ifndef NSAppKitVersionNumber10_14
-#define NSAppKitVersionNumber10_14 1671
+#ifndef NSAppKitVersionNumber10_13_2
+#define NSAppKitVersionNumber10_13_2    1561.2
 #endif
+#ifndef NSAppKitVersionNumber10_14
+#define NSAppKitVersionNumber10_14      1671
+#endif
+
+@interface NSWindow (SDL)
+#if MAC_OS_X_VERSION_MAX_ALLOWED < 101000 /* Added in the 10.10 SDK */
+@property (readonly) NSRect contentLayoutRect;
+#endif
+
+/* This is available as of 10.13.2, but isn't in public headers */
+@property (nonatomic) NSRect mouseConfinementRect;
+@end
 
 @interface SDLWindow : NSWindow <NSDraggingDestination>
 /* These are needed for borderless/fullscreen windows */
@@ -161,6 +172,16 @@
     SDL_assert([desiredType isEqualToString:NSFilenamesPboardType]);
     NSArray *array = [pasteboard propertyListForType:@"NSFilenamesPboardType"];
 
+    /* Code addon to update the mouse location */
+    NSPoint point = [sender draggingLocation];
+    SDL_Mouse *mouse = SDL_GetMouse();
+    int x = (int)point.x;
+    int y = (int)(sdlwindow->h - point.y);
+    if (x >= 0 && x < sdlwindow->w && y >= 0 && y < sdlwindow->h) {
+        SDL_SendMouseMotion(sdlwindow, mouse->mouseID, 0, x, y);
+    }
+    /* Code addon to update the mouse location */
+
     for (NSString *path in array) {
         NSURL *fileURL = [NSURL fileURLWithPath:path];
         NSNumber *isAlias = nil;
@@ -313,6 +334,119 @@ SetWindowStyle(SDL_Window * window, NSUInteger style)
     return SDL_TRUE;
 }
 
+static SDL_bool
+ShouldAdjustCoordinatesForGrab(SDL_Window * window)
+{
+    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
+
+    if (!data || [data->listener isMovingOrFocusClickPending]) {
+        return SDL_FALSE;
+    }
+
+    if (!(window->flags & SDL_WINDOW_INPUT_FOCUS)) {
+        return SDL_FALSE;
+    }
+
+    if ((window->flags & SDL_WINDOW_MOUSE_GRABBED) || (window->mouse_rect.w > 0 && window->mouse_rect.h > 0)) {
+        return SDL_TRUE;
+    }
+    return SDL_FALSE;
+}
+
+static SDL_bool
+AdjustCoordinatesForGrab(SDL_Window * window, int x, int y, CGPoint *adjusted)
+{
+    if (window->mouse_rect.w > 0 && window->mouse_rect.h > 0) {
+        SDL_Rect window_rect;
+        SDL_Rect mouse_rect;
+
+        window_rect.x = 0;
+        window_rect.y = 0;
+        window_rect.w = window->w;
+        window_rect.h = window->h;
+
+        if (SDL_IntersectRect(&window->mouse_rect, &window_rect, &mouse_rect)) {
+            int left = window->x + mouse_rect.x;
+            int right = left + mouse_rect.w - 1;
+            int top = window->y + mouse_rect.y;
+            int bottom = top + mouse_rect.h - 1;
+            if (x < left || x > right || y < top || y > bottom) {
+                adjusted->x = SDL_clamp(x, left, right);
+                adjusted->y = SDL_clamp(y, top, bottom);
+                return SDL_TRUE;
+            }
+            return SDL_FALSE;
+        }
+    }
+
+    if ((window->flags & SDL_WINDOW_MOUSE_GRABBED) != 0) {
+        int left = window->x;
+        int right = left + window->w - 1;
+        int top = window->y;
+        int bottom = top + window->h - 1;
+        if (x < left || x > right || y < top || y > bottom) {
+            adjusted->x = SDL_clamp(x, left, right);
+            adjusted->y = SDL_clamp(y, top, bottom);
+            return SDL_TRUE;
+        }
+    }
+    return SDL_FALSE;
+}
+
+static void
+Cocoa_UpdateClipCursor(SDL_Window * window)
+{
+    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
+
+    if (NSAppKitVersionNumber >= NSAppKitVersionNumber10_13_2) {
+        NSWindow *nswindow = data->nswindow;
+        SDL_Rect mouse_rect;
+
+        SDL_zero(mouse_rect);
+
+        if (ShouldAdjustCoordinatesForGrab(window)) {
+            SDL_Rect window_rect;
+
+            window_rect.x = 0;
+            window_rect.y = 0;
+            window_rect.w = window->w;
+            window_rect.h = window->h;
+
+            if (window->mouse_rect.w > 0 && window->mouse_rect.h > 0) {
+                SDL_IntersectRect(&window->mouse_rect, &window_rect, &mouse_rect);
+            }
+
+            if ((window->flags & SDL_WINDOW_MOUSE_GRABBED) != 0 &&
+                SDL_RectEmpty(&mouse_rect)) {
+                SDL_memcpy(&mouse_rect, &window_rect, sizeof(mouse_rect));
+            }
+        }
+
+        if (SDL_RectEmpty(&mouse_rect)) {
+            nswindow.mouseConfinementRect = NSZeroRect;
+        } else {
+            NSRect rect;
+            rect.origin.x = mouse_rect.x;
+            rect.origin.y = [nswindow contentLayoutRect].size.height - mouse_rect.y - mouse_rect.h;
+            rect.size.width = mouse_rect.w;
+            rect.size.height = mouse_rect.h;
+            nswindow.mouseConfinementRect = rect;
+        }
+    } else {
+        /* Move the cursor to the nearest point in the window */
+        if (ShouldAdjustCoordinatesForGrab(window)) {
+            int x, y;
+            CGPoint cgpoint;
+
+            SDL_GetGlobalMouseState(&x, &y);
+            if (AdjustCoordinatesForGrab(window, x, y, &cgpoint)) {
+                Cocoa_HandleMouseWarp(cgpoint.x, cgpoint.y);
+                CGDisplayMoveCursorToPoint(kCGDirectMainDisplay, cgpoint);
+            }
+        }
+    }
+}
+
 
 @implementation Cocoa_WindowListener
 
@@ -331,6 +465,7 @@ SetWindowStyle(SDL_Window * window, NSUInteger style)
     pendingWindowOperation = PENDING_OPERATION_NONE;
     isMoving = NO;
     isDragAreaRunning = NO;
+    pendingWindowWarpX = pendingWindowWarpY = INT_MAX;
 
     center = [NSNotificationCenter defaultCenter];
 
@@ -343,6 +478,7 @@ SetWindowStyle(SDL_Window * window, NSUInteger style)
         [center addObserver:self selector:@selector(windowDidBecomeKey:) name:NSWindowDidBecomeKeyNotification object:window];
         [center addObserver:self selector:@selector(windowDidResignKey:) name:NSWindowDidResignKeyNotification object:window];
         [center addObserver:self selector:@selector(windowDidChangeBackingProperties:) name:NSWindowDidChangeBackingPropertiesNotification object:window];
+        [center addObserver:self selector:@selector(windowDidChangeScreenProfile:) name:NSWindowDidChangeScreenProfileNotification object:window];
         [center addObserver:self selector:@selector(windowWillEnterFullScreen:) name:NSWindowWillEnterFullScreenNotification object:window];
         [center addObserver:self selector:@selector(windowDidEnterFullScreen:) name:NSWindowDidEnterFullScreenNotification object:window];
         [center addObserver:self selector:@selector(windowWillExitFullScreen:) name:NSWindowWillExitFullScreenNotification object:window];
@@ -474,6 +610,7 @@ SetWindowStyle(SDL_Window * window, NSUInteger style)
         [center removeObserver:self name:NSWindowDidBecomeKeyNotification object:window];
         [center removeObserver:self name:NSWindowDidResignKeyNotification object:window];
         [center removeObserver:self name:NSWindowDidChangeBackingPropertiesNotification object:window];
+        [center removeObserver:self name:NSWindowDidChangeScreenProfileNotification object:window];
         [center removeObserver:self name:NSWindowWillEnterFullScreenNotification object:window];
         [center removeObserver:self name:NSWindowDidEnterFullScreenNotification object:window];
         [center removeObserver:self name:NSWindowWillExitFullScreenNotification object:window];
@@ -499,6 +636,26 @@ SetWindowStyle(SDL_Window * window, NSUInteger style)
     return isMoving;
 }
 
+- (BOOL)isMovingOrFocusClickPending
+{
+    return isMoving || (focusClickPending != 0);
+}
+
+-(void) setFocusClickPending:(NSInteger) button
+{
+    focusClickPending |= (1 << button);
+}
+
+-(void) clearFocusClickPending:(NSInteger) button
+{
+    if ((focusClickPending & (1 << button)) != 0) {
+        focusClickPending &= ~(1 << button);
+        if (focusClickPending == 0) {
+            [self onMovingOrFocusClickPendingStateCleared];
+        }
+    }
+}
+
 -(void) setPendingMoveX:(int)x Y:(int)y
 {
     pendingWindowWarpX = x;
@@ -507,16 +664,39 @@ SetWindowStyle(SDL_Window * window, NSUInteger style)
 
 - (void)windowDidFinishMoving
 {
-    if ([self isMoving]) {
+    if (isMoving) {
         isMoving = NO;
+        [self onMovingOrFocusClickPendingStateCleared];
+    }
+}
 
+- (void)onMovingOrFocusClickPendingStateCleared
+{
+    if (![self isMovingOrFocusClickPending]) {
         SDL_Mouse *mouse = SDL_GetMouse();
         if (pendingWindowWarpX != INT_MAX && pendingWindowWarpY != INT_MAX) {
             mouse->WarpMouseGlobal(pendingWindowWarpX, pendingWindowWarpY);
             pendingWindowWarpX = pendingWindowWarpY = INT_MAX;
         }
         if (mouse->relative_mode && !mouse->relative_mode_warp && mouse->focus == _data->window) {
+            /* Move the cursor to the nearest point in the window */
+            {
+                int x, y;
+                CGPoint cgpoint;
+
+                SDL_GetMouseState(&x, &y);
+                cgpoint.x = _data->window->x + x;
+                cgpoint.y = _data->window->y + y;
+
+                Cocoa_HandleMouseWarp(cgpoint.x, cgpoint.y);
+
+                DLog("Returning cursor to (%g, %g)", cgpoint.x, cgpoint.y);
+                CGDisplayMoveCursorToPoint(kCGDirectMainDisplay, cgpoint);
+            }
+
             mouse->SetRelativeMouseMode(SDL_TRUE);
+        } else {
+            Cocoa_UpdateClipCursor(_data->window);
         }
     }
 }
@@ -615,6 +795,10 @@ SetWindowStyle(SDL_Window * window, NSUInteger style)
 
 - (void)windowDidMiniaturize:(NSNotification *)aNotification
 {
+    if (focusClickPending) {
+        focusClickPending = 0;
+        [self onMovingOrFocusClickPendingStateCleared];
+    }
     SDL_SendWindowEvent(_data->window, SDL_WINDOWEVENT_MINIMIZED, 0, 0);
 }
 
@@ -632,7 +816,7 @@ SetWindowStyle(SDL_Window * window, NSUInteger style)
     /* This needs to be done before restoring the relative mouse mode. */
     SDL_SetKeyboardFocus(window);
 
-    if (mouse->relative_mode && !mouse->relative_mode_warp && ![self isMoving]) {
+    if (mouse->relative_mode && !mouse->relative_mode_warp && ![self isMovingOrFocusClickPending]) {
         mouse->SetRelativeMouseMode(SDL_TRUE);
     }
 
@@ -700,6 +884,11 @@ SetWindowStyle(SDL_Window * window, NSUInteger style)
     }
 }
 
+- (void)windowDidChangeScreenProfile:(NSNotification *)aNotification
+{
+    SDL_SendWindowEvent(_data->window, SDL_WINDOWEVENT_ICCPROF_CHANGED, 0, 0);
+}
+
 - (void)windowWillEnterFullScreen:(NSNotification *)aNotification
 {
     SDL_Window *window = _data->window;
@@ -962,16 +1151,43 @@ SetWindowStyle(SDL_Window * window, NSUInteger style)
     return NO;  /* not a special area, carry on. */
 }
 
+static int
+Cocoa_SendMouseButtonClicks(SDL_Mouse * mouse, NSEvent *theEvent, SDL_Window * window, const Uint8 state, const Uint8 button)
+{
+    const SDL_MouseID mouseID = mouse->mouseID;
+    const int clicks = (int) [theEvent clickCount];
+    SDL_Window *focus = SDL_GetKeyboardFocus();
+    int rc;
+
+    // macOS will send non-left clicks to background windows without raising them, so we need to
+    //  temporarily adjust the mouse position when this happens, as `mouse` will be tracking
+    //  the position in the currently-focused window. We don't (currently) send a mousemove
+    //  event for the background window, this just makes sure the button is reported at the
+    //  correct position in its own event.
+    if ( focus && ([theEvent window] == ((SDL_WindowData *) focus->driverdata)->nswindow) ) {
+        rc = SDL_SendMouseButtonClicks(window, mouseID, state, button, clicks);
+    } else {
+        const int orig_x = mouse->x;
+        const int orig_y = mouse->y;
+        const NSPoint point = [theEvent locationInWindow];
+        mouse->x = (int) point.x;
+        mouse->y = (int) (window->h - point.y);
+        rc = SDL_SendMouseButtonClicks(window, mouseID, state, button, clicks);
+        mouse->x = orig_x;
+        mouse->y = orig_y;
+    }
+
+    return rc;
+}
+
 - (void)mouseDown:(NSEvent *)theEvent
 {
-    const SDL_Mouse *mouse = SDL_GetMouse();
+    SDL_Mouse *mouse = SDL_GetMouse();
     if (!mouse) {
         return;
     }
 
-    const SDL_MouseID mouseID = mouse->mouseID;
     int button;
-    int clicks;
 
     /* Ignore events that aren't inside the client area (i.e. title bar.) */
     if ([theEvent window]) {
@@ -1008,9 +1224,7 @@ SetWindowStyle(SDL_Window * window, NSUInteger style)
         break;
     }
 
-    clicks = (int) [theEvent clickCount];
-
-    SDL_SendMouseButtonClicks(_data->window, mouseID, SDL_PRESSED, button, clicks);
+    Cocoa_SendMouseButtonClicks(mouse, theEvent, _data->window, SDL_PRESSED, button);
 }
 
 - (void)rightMouseDown:(NSEvent *)theEvent
@@ -1025,14 +1239,12 @@ SetWindowStyle(SDL_Window * window, NSUInteger style)
 
 - (void)mouseUp:(NSEvent *)theEvent
 {
-    const SDL_Mouse *mouse = SDL_GetMouse();
+    SDL_Mouse *mouse = SDL_GetMouse();
     if (!mouse) {
         return;
     }
 
-    const SDL_MouseID mouseID = mouse->mouseID;
     int button;
-    int clicks;
 
     if ([self processHitTest:theEvent]) {
         SDL_SendWindowEvent(_data->window, SDL_WINDOWEVENT_HIT_TEST, 0, 0);
@@ -1059,9 +1271,7 @@ SetWindowStyle(SDL_Window * window, NSUInteger style)
         break;
     }
 
-    clicks = (int) [theEvent clickCount];
-
-    SDL_SendMouseButtonClicks(_data->window, mouseID, SDL_RELEASED, button, clicks);
+    Cocoa_SendMouseButtonClicks(mouse, theEvent, _data->window, SDL_RELEASED, button);
 }
 
 - (void)rightMouseUp:(NSEvent *)theEvent
@@ -1099,34 +1309,15 @@ SetWindowStyle(SDL_Window * window, NSUInteger style)
     x = (int)point.x;
     y = (int)(window->h - point.y);
 
-    if (window->flags & SDL_WINDOW_INPUT_GRABBED) {
-        if (x < 0 || x >= window->w || y < 0 || y >= window->h) {
-            if (x < 0) {
-                x = 0;
-            } else if (x >= window->w) {
-                x = window->w - 1;
-            }
-            if (y < 0) {
-                y = 0;
-            } else if (y >= window->h) {
-                y = window->h - 1;
-            }
-
-#if !SDL_MAC_NO_SANDBOX
-            CGPoint cgpoint;
-
-            /* When SDL_MAC_NO_SANDBOX is set, this is handled by
-             * SDL_cocoamousetap.m.
-             */
-
-            cgpoint.x = window->x + x;
-            cgpoint.y = window->y + y;
-
+    if (NSAppKitVersionNumber >= NSAppKitVersionNumber10_13_2) {
+        /* Mouse grab is taken care of by the confinement rect */
+    } else {
+        CGPoint cgpoint;
+        if (ShouldAdjustCoordinatesForGrab(window) &&
+            AdjustCoordinatesForGrab(window, window->x + x, window->y + y, &cgpoint)) {
+            Cocoa_HandleMouseWarp(cgpoint.x, cgpoint.y);
             CGDisplayMoveCursorToPoint(kCGDirectMainDisplay, cgpoint);
             CGAssociateMouseAndMouseCursorPosition(YES);
-
-            Cocoa_HandleMouseWarp(cgpoint.x, cgpoint.y);
-#endif
         }
     }
 
@@ -1157,7 +1348,18 @@ SetWindowStyle(SDL_Window * window, NSUInteger style)
 {
     /* probably a MacBook trackpad; make this look like a synthesized event.
        This is backwards from reality, but better matches user expectations. */
-    const BOOL istrackpad = ([theEvent subtype] == NSEventSubtypeMouseEvent);
+    BOOL istrackpad = NO;
+    @try {
+        istrackpad = ([theEvent subtype] == NSEventSubtypeMouseEvent);
+    }
+    @catch (NSException *e) {
+        /* if NSEvent type doesn't have subtype, such as NSEventTypeBeginGesture on
+         * macOS 10.5 to 10.10, then NSInternalInconsistencyException is thrown.
+         * This still prints a message to terminal so catching it's not an ideal solution.
+         *
+         * *** Assertion failure in -[NSEvent subtype]
+         */
+    }
 
     NSSet *touches = [theEvent touchesMatchingPhase:NSTouchPhaseAny inView:nil];
     const SDL_TouchID touchID = istrackpad ? SDL_MOUSE_TOUCHID : (SDL_TouchID)(intptr_t)[[touches anyObject] device];
@@ -1208,7 +1410,18 @@ SetWindowStyle(SDL_Window * window, NSUInteger style)
 
     /* probably a MacBook trackpad; make this look like a synthesized event.
        This is backwards from reality, but better matches user expectations. */
-    const BOOL istrackpad = ([theEvent subtype] == NSEventSubtypeMouseEvent);
+    BOOL istrackpad = NO;
+    @try {
+        istrackpad = ([theEvent subtype] == NSEventSubtypeMouseEvent);
+    }
+    @catch (NSException *e) {
+        /* if NSEvent type doesn't have subtype, such as NSEventTypeBeginGesture on
+         * macOS 10.5 to 10.10, then NSInternalInconsistencyException is thrown.
+         * This still prints a message to terminal so catching it's not an ideal solution.
+         *
+         * *** Assertion failure in -[NSEvent subtype]
+         */
+    }
 
     for (NSTouch *touch in touches) {
         const SDL_TouchID touchId = istrackpad ? SDL_MOUSE_TOUCHID : (SDL_TouchID)(intptr_t)[touch device];
@@ -1403,7 +1616,10 @@ SetupWindowData(_THIS, SDL_Window * window, NSWindow *nswindow, NSView *nsview,
     {
         unsigned long style = [nswindow styleMask];
 
-        if (style == NSWindowStyleMaskBorderless) {
+        /* NSWindowStyleMaskBorderless is zero, and it's possible to be
+            Resizeable _and_ borderless, so we can't do a simple bitwise AND
+            of NSWindowStyleMaskBorderless here. */
+        if ((style & ~NSWindowStyleMaskResizable) == NSWindowStyleMaskBorderless) {
             window->flags |= SDL_WINDOW_BORDERLESS;
         } else {
             window->flags &= ~SDL_WINDOW_BORDERLESS;
@@ -1804,11 +2020,33 @@ Cocoa_SetWindowResizable(_THIS, SDL_Window * window, SDL_bool resizable)
      */
     SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
     Cocoa_WindowListener *listener = data->listener;
+    NSWindow *nswindow = data->nswindow;
+    SDL_VideoData *videodata = ((SDL_WindowData *) window->driverdata)->videodata;
     if (![listener isInFullscreenSpace]) {
         SetWindowStyle(window, GetWindowStyle(window));
     }
+    if (videodata->allow_spaces) {
+        if (resizable) {
+            /* resizable windows are Spaces-friendly: they get the "go fullscreen" toggle button on their titlebar. */
+            [nswindow setCollectionBehavior:NSWindowCollectionBehaviorFullScreenPrimary];
+        } else {
+            [nswindow setCollectionBehavior:NSWindowCollectionBehaviorManaged];
+        }
+    }
 }}
 
+void
+Cocoa_SetWindowAlwaysOnTop(_THIS, SDL_Window * window, SDL_bool on_top)
+{ @autoreleasepool
+    {
+        NSWindow *nswindow = ((SDL_WindowData *) window->driverdata)->nswindow;
+        if (on_top) {
+            [nswindow setLevel:NSFloatingWindowLevel];
+        } else {
+            [nswindow setLevel:kCGNormalWindowLevel];
+        }
+    }}
+
 void
 Cocoa_SetWindowFullscreen(_THIS, SDL_Window * window, SDL_VideoDisplay * display, SDL_bool fullscreen)
 { @autoreleasepool
@@ -1923,6 +2161,42 @@ Cocoa_SetWindowGammaRamp(_THIS, SDL_Window * window, const Uint16 * ramp)
     return 0;
 }
 
+void*
+Cocoa_GetWindowICCProfile(_THIS, SDL_Window * window, size_t * size)
+{
+    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
+    NSWindow *nswindow = data->nswindow;
+    NSScreen *screen = [nswindow screen];
+    NSData* iccProfileData = nil;
+    void* retIccProfileData = NULL;
+
+    if (screen == nil) {
+        SDL_SetError("Could not get screen of window.");
+        return NULL;
+    }
+
+    if ([screen colorSpace] == nil) {
+        SDL_SetError("Could not get colorspace information of screen.");
+        return NULL;
+    }
+
+    iccProfileData = [[screen colorSpace] ICCProfileData];
+    if (iccProfileData == nil) {
+        SDL_SetError("Could not get ICC profile data.");
+        return NULL;
+    }
+
+    retIccProfileData = SDL_malloc([iccProfileData length]);
+    if (!retIccProfileData) {
+        SDL_OutOfMemory();
+        return NULL;
+    }
+
+    [iccProfileData getBytes:retIccProfileData length:[iccProfileData length]];
+    *size = [iccProfileData length];
+    return retIccProfileData;
+}
+
 int
 Cocoa_GetWindowGammaRamp(_THIS, SDL_Window * window, Uint16 * ramp)
 {
@@ -1948,30 +2222,19 @@ Cocoa_GetWindowGammaRamp(_THIS, SDL_Window * window, Uint16 * ramp)
 }
 
 void
-Cocoa_SetWindowGrab(_THIS, SDL_Window * window, SDL_bool grabbed)
+Cocoa_SetWindowMouseRect(_THIS, SDL_Window * window)
+{
+    Cocoa_UpdateClipCursor(window);
+}
+
+void
+Cocoa_SetWindowMouseGrab(_THIS, SDL_Window * window, SDL_bool grabbed)
 {
-    SDL_Mouse *mouse = SDL_GetMouse();
     SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
 
-    /* Enable or disable the event tap as necessary */
-    Cocoa_EnableMouseEventTap(mouse->driverdata, grabbed);
+    Cocoa_UpdateClipCursor(window);
 
-    /* Move the cursor to the nearest point in the window */
-    if (grabbed && data && ![data->listener isMoving]) {
-        int x, y;
-        CGPoint cgpoint;
-
-        SDL_GetMouseState(&x, &y);
-        cgpoint.x = window->x + x;
-        cgpoint.y = window->y + y;
-
-        Cocoa_HandleMouseWarp(cgpoint.x, cgpoint.y);
-
-        DLog("Returning cursor to (%g, %g)", cgpoint.x, cgpoint.y);
-        CGDisplayMoveCursorToPoint(kCGDirectMainDisplay, cgpoint);
-    }
-
-    if ( data && (window->flags & SDL_WINDOW_FULLSCREEN) ) {
+    if (data && (window->flags & SDL_WINDOW_FULLSCREEN)) {
         if (SDL_ShouldAllowTopmost() && (window->flags & SDL_WINDOW_INPUT_FOCUS)
             && ![data->listener isInFullscreenSpace]) {
             /* OpenGL is rendering to the window, so make it visible! */
@@ -2103,6 +2366,34 @@ Cocoa_AcceptDragAndDrop(SDL_Window * window, SDL_bool accept)
     }
 }
 
+int
+Cocoa_FlashWindow(_THIS, SDL_Window *window, SDL_FlashOperation operation)
+{ @autoreleasepool
+{
+    /* Note that this is app-wide and not window-specific! */
+    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
+
+    if (data->flash_request) {
+        [NSApp cancelUserAttentionRequest:data->flash_request];
+        data->flash_request = 0;
+    }
+
+    switch (operation) {
+    case SDL_FLASH_CANCEL:
+        /* Canceled above */
+        break;
+    case SDL_FLASH_BRIEFLY:
+        data->flash_request = [NSApp requestUserAttention:NSInformationalRequest];
+        break;
+    case SDL_FLASH_UNTIL_FOCUSED:
+        data->flash_request = [NSApp requestUserAttention:NSCriticalRequest];
+        break;
+    default:
+        return SDL_Unsupported();
+    }
+    return 0;
+}}
+
 int
 Cocoa_SetWindowOpacity(_THIS, SDL_Window * window, float opacity)
 {
diff --git a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_WM.c b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_WM.c
index bb9acb1f9..dc4af539f 100644
--- a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_WM.c
+++ b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_WM.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -287,9 +287,8 @@ WMPos(DFB_WindowData * p, int x, int y)
 int
 DirectFB_WM_ProcessEvent(_THIS, SDL_Window * window, DFBWindowEvent * evt)
 {
-    SDL_DFB_DEVICEDATA(_this);
     SDL_DFB_WINDOWDATA(window);
-    DFB_WindowData *gwindata = ((devdata->grabbed_window) ? (DFB_WindowData *) ((devdata->grabbed_window)->driverdata) : NULL);
+    SDL_Window *grabbed_window = SDL_GetGrabbedWindow();
     IDirectFBWindow *dfbwin = windata->dfbwin;
     DFBWindowOptions wopts;
 
@@ -324,12 +323,12 @@ DirectFB_WM_ProcessEvent(_THIS, SDL_Window * window, DFBWindowEvent * evt)
                 }
                 if (window->flags & SDL_WINDOW_MAXIMIZED)
                     return 1;
-                /* fall through */
+                SDL_FALLTHROUGH;
             default:
                 windata->wm_grab = pos;
-                if (gwindata != NULL)
-                    SDL_DFB_CHECK(gwindata->dfbwin->UngrabPointer(gwindata->dfbwin));
-                SDL_DFB_CHECK(dfbwin->GrabPointer(dfbwin));
+                if (grabbed_window != NULL)
+                    DirectFB_SetWindowMouseGrab(_this, grabbed_window, SDL_FALSE);
+                DirectFB_SetWindowMouseGrab(_this, window, SDL_TRUE);
                 windata->wm_lastx = evt->cx;
                 windata->wm_lasty = evt->cy;
             }
@@ -359,9 +358,9 @@ DirectFB_WM_ProcessEvent(_THIS, SDL_Window * window, DFBWindowEvent * evt)
                     SDL_DFB_CHECK(dfbwin->Resize(dfbwin, cw + dx, ch + dy));
                 }
             }
-            SDL_DFB_CHECK(dfbwin->UngrabPointer(dfbwin));
-            if (gwindata != NULL)
-                SDL_DFB_CHECK(gwindata->dfbwin->GrabPointer(gwindata->dfbwin));
+            DirectFB_SetWindowMouseGrab(_this, window, SDL_FALSE);
+            if (grabbed_window != NULL)
+                DirectFB_SetWindowMouseGrab(_this, grabbed_window, SDL_TRUE);
             windata->wm_grab = WM_POS_NONE;
             return 1;
         }
diff --git a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_WM.h b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_WM.h
index 965081fbe..be96ec648 100644
--- a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_WM.h
+++ b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_WM.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_dyn.c b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_dyn.c
index 94626af38..d872c29bc 100644
--- a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_dyn.c
+++ b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_dyn.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_dyn.h b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_dyn.h
index f067245cd..28882b833 100644
--- a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_dyn.h
+++ b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_dyn.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_events.c b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_events.c
index 251d6970d..e6ca47ad3 100644
--- a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_events.c
+++ b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_events.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -212,7 +212,7 @@ ProcessWindowEvent(_THIS, SDL_Window *sdlwin, DFBWindowEvent * evt)
         case DWET_MOTION:
             if (ClientXY(windata, &evt->x, &evt->y)) {
                 if (!devdata->use_linux_input) {
-                    if (!(sdlwin->flags & SDL_WINDOW_INPUT_GRABBED))
+                    if (!(sdlwin->flags & SDL_WINDOW_MOUSE_GRABBED))
                         SDL_SendMouseMotion_ex(sdlwin, devdata->mouse_id[0], 0,
                                             evt->x, evt->y, 0);
                 } else {
@@ -261,7 +261,7 @@ ProcessWindowEvent(_THIS, SDL_Window *sdlwin, DFBWindowEvent * evt)
                 SDL_SendWindowEvent(sdlwin, SDL_WINDOWEVENT_MOVED,
                                     evt->x, evt->y);
             }
-            /* fall throught */
+            SDL_FALLTHROUGH;
         case DWET_SIZE:
             /* FIXME: what about < 0 */
             evt->w -= (windata->theme.right_size + windata->theme.left_size);
@@ -312,15 +312,16 @@ ProcessInputEvent(_THIS, DFBInputEvent * ievt)
     int kbd_idx;
     Uint32 unicode;
     char text[SDL_TEXTINPUTEVENT_TEXT_SIZE];
+    SDL_Window* grabbed_window = SDL_GetGrabbedWindow();
 
     if (!devdata->use_linux_input) {
         if (ievt->type == DIET_AXISMOTION) {
-            if ((devdata->grabbed_window != NULL) && (ievt->flags & DIEF_AXISREL)) {
+            if ((grabbed_window != NULL) && (ievt->flags & DIEF_AXISREL)) {
                 if (ievt->axis == DIAI_X)
-                    SDL_SendMouseMotion_ex(devdata->grabbed_window, ievt->device_id, 1,
+                    SDL_SendMouseMotion_ex(grabbed_window, ievt->device_id, 1,
                                         ievt->axisrel, 0, 0);
                 else if (ievt->axis == DIAI_Y)
-                    SDL_SendMouseMotion_ex(devdata->grabbed_window, ievt->device_id, 1, 0,
+                    SDL_SendMouseMotion_ex(grabbed_window, ievt->device_id, 1, 0,
                                         ievt->axisrel, 0);
             }
         }
@@ -339,7 +340,7 @@ ProcessInputEvent(_THIS, DFBInputEvent * ievt)
                     SDL_Mouse *mouse = SDL_GetMouse(ievt->device_id);
                     SDL_Window *window = SDL_GetWindowFromID(mouse->focus);
 #else
-                    SDL_Window *window = devdata->grabbed_window;
+                    SDL_Window *window = grabbed_window;
 #endif
                     if (window) {
                         DFB_WindowData *windata =
@@ -359,10 +360,10 @@ ProcessInputEvent(_THIS, DFBInputEvent * ievt)
                 }
             } else if (ievt->flags & DIEF_AXISREL) {
                 if (ievt->axis == DIAI_X)
-                    SDL_SendMouseMotion_ex(devdata->grabbed_window, ievt->device_id, 1,
+                    SDL_SendMouseMotion_ex(grabbed_window, ievt->device_id, 1,
                                         ievt->axisrel, 0, 0);
                 else if (ievt->axis == DIAI_Y)
-                    SDL_SendMouseMotion_ex(devdata->grabbed_window, ievt->device_id, 1, 0,
+                    SDL_SendMouseMotion_ex(grabbed_window, ievt->device_id, 1, 0,
                                         ievt->axisrel, 0);
             }
             break;
@@ -386,19 +387,19 @@ ProcessInputEvent(_THIS, DFBInputEvent * ievt)
             break;
         case DIET_BUTTONPRESS:
             if (ievt->buttons & DIBM_LEFT)
-                SDL_SendMouseButton_ex(devdata->grabbed_window, ievt->device_id, SDL_PRESSED, 1);
+                SDL_SendMouseButton_ex(grabbed_window, ievt->device_id, SDL_PRESSED, 1);
             if (ievt->buttons & DIBM_MIDDLE)
-                SDL_SendMouseButton_ex(devdata->grabbed_window, ievt->device_id, SDL_PRESSED, 2);
+                SDL_SendMouseButton_ex(grabbed_window, ievt->device_id, SDL_PRESSED, 2);
             if (ievt->buttons & DIBM_RIGHT)
-                SDL_SendMouseButton_ex(devdata->grabbed_window, ievt->device_id, SDL_PRESSED, 3);
+                SDL_SendMouseButton_ex(grabbed_window, ievt->device_id, SDL_PRESSED, 3);
             break;
         case DIET_BUTTONRELEASE:
             if (!(ievt->buttons & DIBM_LEFT))
-                SDL_SendMouseButton_ex(devdata->grabbed_window, ievt->device_id, SDL_RELEASED, 1);
+                SDL_SendMouseButton_ex(grabbed_window, ievt->device_id, SDL_RELEASED, 1);
             if (!(ievt->buttons & DIBM_MIDDLE))
-                SDL_SendMouseButton_ex(devdata->grabbed_window, ievt->device_id, SDL_RELEASED, 2);
+                SDL_SendMouseButton_ex(grabbed_window, ievt->device_id, SDL_RELEASED, 2);
             if (!(ievt->buttons & DIBM_RIGHT))
-                SDL_SendMouseButton_ex(devdata->grabbed_window, ievt->device_id, SDL_RELEASED, 3);
+                SDL_SendMouseButton_ex(grabbed_window, ievt->device_id, SDL_RELEASED, 3);
             break;
         default:
             break;              /* please gcc */
@@ -682,7 +683,7 @@ EnumKeyboards(DFBInputDeviceID device_id,
 #endif
         devdata->keyboard[devdata->num_keyboard].id = device_id;
         devdata->keyboard[devdata->num_keyboard].is_generic = 0;
-        if (!strncmp("X11", desc.name, 3))
+        if (!SDL_strncmp("X11", desc.name, 3))
         {
             devdata->keyboard[devdata->num_keyboard].map = xfree86_scancode_table2;
             devdata->keyboard[devdata->num_keyboard].map_size = SDL_arraysize(xfree86_scancode_table2);
diff --git a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_events.h b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_events.h
index e1bddd585..276d972c6 100644
--- a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_events.h
+++ b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_events.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_modes.c b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_modes.c
index 114d95c5f..88fa0568c 100644
--- a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_modes.c
+++ b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_modes.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_modes.h b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_modes.h
index 43b07fe48..22727aa4e 100644
--- a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_modes.h
+++ b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_modes.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_mouse.c b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_mouse.c
index f86e13dc4..2457aa903 100644
--- a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_mouse.c
+++ b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_mouse.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -164,7 +164,7 @@ DirectFB_CreateCursor(SDL_Surface * surface, int hot_x, int hot_y)
 
     p = surface->pixels;
     for (i = 0; i < surface->h; i++)
-        memcpy((char *) dest + i * pitch,
+        SDL_memcpy((char *) dest + i * pitch,
                (char *) p + i * surface->pitch, 4 * surface->w);
 
     curdata->surf->Unlock(curdata->surf);
diff --git a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_mouse.h b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_mouse.h
index 43a705f41..f5c207645 100644
--- a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_mouse.h
+++ b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_mouse.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_opengl.c b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_opengl.c
index 7a841ec43..a1ab96c4a 100644
--- a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_opengl.c
+++ b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_opengl.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -47,7 +47,7 @@ struct SDL_GLDriverData
 };
 
 #define OPENGL_REQUIRS_DLOPEN
-#if defined(OPENGL_REQUIRS_DLOPEN) && defined(SDL_LOADSO_DLOPEN)
+#if defined(OPENGL_REQUIRS_DLOPEN) && defined(HAVE_DLOPEN)
 #include <dlfcn.h>
 #define GL_LoadObject(X)    dlopen(X, (RTLD_NOW|RTLD_GLOBAL))
 #define GL_LoadFunction     dlsym
diff --git a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_opengl.h b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_opengl.h
index c4e05a2f0..be02c7df1 100644
--- a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_opengl.h
+++ b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_opengl.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_render.c b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_render.c
index 45114dc11..257e95005 100644
--- a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_render.c
+++ b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_render.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -324,6 +324,22 @@ DirectFB_AcquireVidLayer(SDL_Renderer * renderer, SDL_Texture * texture)
     return 1;
 }
 
+
+/* Copy the SDL_Surface palette to the DirectFB texture palette */
+void DirectFB_SetTexturePalette(SDL_Renderer *renderer, SDL_Texture *texture, SDL_Palette *pal)
+{
+    int i;
+    DFBColor dfbpal[256];
+    DirectFB_TextureData *data = (DirectFB_TextureData *) texture->driverdata;
+    for (i = 0; i < pal->ncolors; i++) {
+            dfbpal[i].a = pal->colors[i].a;
+            dfbpal[i].r = pal->colors[i].r;
+            dfbpal[i].g = pal->colors[i].g;
+            dfbpal[i].b = pal->colors[i].b;
+    }
+    data->palette->SetEntries(data->palette, dfbpal, pal->ncolors, 0);
+}
+
 static int
 DirectFB_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
 {
@@ -615,6 +631,59 @@ DirectFB_QueueDrawPoints(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const
     return 0;
 }
 
+static int
+DirectFB_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+        const float *xy, int xy_stride, const SDL_Color *color, int color_stride, const float *uv, int uv_stride,
+        int num_vertices, const void *indices, int num_indices, int size_indices,
+        float scale_x, float scale_y)
+{
+    int i;
+    int count = indices ? num_indices : num_vertices;
+    float *verts;
+    int sz = 2 + 4 + (texture ? 2 : 0);
+
+    verts = (float *) SDL_AllocateRenderVertices(renderer, count * sz * sizeof (float), 0, &cmd->data.draw.first);
+    if (!verts) {
+        return -1;
+    }
+
+    cmd->data.draw.count = count;
+    size_indices = indices ? size_indices : 0;
+
+    for (i = 0; i < count; i++) {
+        int j;
+        float *xy_;
+        SDL_Color col_;
+        if (size_indices == 4) {
+            j = ((const Uint32 *)indices)[i];
+        } else if (size_indices == 2) {
+            j = ((const Uint16 *)indices)[i];
+        } else if (size_indices == 1) {
+            j = ((const Uint8 *)indices)[i];
+        } else {
+            j = i;
+        }
+
+        xy_ = (float *)((char*)xy + j * xy_stride);
+        col_ = *(SDL_Color *)((char*)color + j * color_stride);
+
+        *(verts++) = xy_[0] * scale_x;
+        *(verts++) = xy_[1] * scale_y;
+
+        *(verts++) = col_.r;
+        *(verts++) = col_.g;
+        *(verts++) = col_.b;
+        *(verts++) = col_.a;
+
+        if (texture) {
+            float *uv_ = (float *)((char*)uv + j * uv_stride);
+            *(verts++) = uv_[0];
+            *(verts++) = uv_[1];
+        }
+    }
+    return 0;
+}
+
 static int
 DirectFB_QueueFillRects(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FRect * rects, int count)
 {
@@ -648,15 +717,6 @@ DirectFB_QueueCopy(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture
     return 0;
 }
 
-static int
-DirectFB_QueueCopyEx(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture,
-               const SDL_Rect * srcrect, const SDL_FRect * dstrect,
-               const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip)
-{
-    return SDL_Unsupported();
-}
-
-
 static int
 DirectFB_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
 {
@@ -814,8 +874,145 @@ DirectFB_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *
                 break;
             }
 
-            case SDL_RENDERCMD_COPY_EX:
-                break;  /* unsupported */
+
+            case SDL_RENDERCMD_GEOMETRY: {
+                const float *verts = (float *) (((Uint8 *) vertices) + cmd->data.draw.first);
+                SDL_Texture *texture = cmd->data.draw.texture;
+                const size_t count = cmd->data.draw.count;
+
+                Uint8 save_r = cmd->data.draw.r;
+                Uint8 save_g = cmd->data.draw.g;
+                Uint8 save_b = cmd->data.draw.b;
+                Uint8 save_a = cmd->data.draw.a;
+
+                int j;
+                for (j = 0; j < count; j += 3)
+                {
+                    float x1, y1, r1, g1, b1, a1, u1, v1;
+                    float x2, y2, r2, g2, b2, a2, u2, v2;
+                    float x3, y3, r3, g3, b3, a3, u3, v3;
+
+                    x1 = *(verts++);
+                    y1 = *(verts++);
+                    r1 = *(verts++);
+                    g1 = *(verts++);
+                    b1 = *(verts++);
+                    a1 = *(verts++);
+                    if (texture) {
+                        u1 = *(verts++);
+                        v1 = *(verts++);
+                    }
+                    x2 = *(verts++);
+                    y2 = *(verts++);
+                    r2 = *(verts++);
+                    g2 = *(verts++);
+                    b2 = *(verts++);
+                    a2 = *(verts++);
+                    if (texture) {
+                        u2 = *(verts++);
+                        v2 = *(verts++);
+                    }
+                    x3 = *(verts++);
+                    y3 = *(verts++);
+                    r3 = *(verts++);
+                    g3 = *(verts++);
+                    b3 = *(verts++);
+                    a3 = *(verts++);
+                    if (texture) {
+                        u3 = *(verts++);
+                        v3 = *(verts++);
+                    }
+
+
+                    if (texture) {
+                        DFBVertex vertices[3];
+
+                        DirectFB_TextureData *texturedata = (DirectFB_TextureData *) texture->driverdata;
+
+                        DFBSurfaceBlittingFlags flags = 0;
+
+                        int r = (r1 + r2 + r3) / 3;
+                        int g = (g1 + g2 + g3) / 3;
+                        int b = (b1 + b2 + b3) / 3;
+                        int a = (a1 + a2 + a3) / 3;
+
+
+                        if (texturedata->isDirty) {
+                            const SDL_Rect rect = { 0, 0, texture->w, texture->h };
+                            DirectFB_UpdateTexture(renderer, texture, &rect, texturedata->pixels, texturedata->pitch);
+                        }
+
+                        if (a != 0xFF) {
+                            flags |= DSBLIT_BLEND_COLORALPHA;
+                        }
+
+                        if ((r & g & b) != 0xFF) {
+                            flags |= DSBLIT_COLORIZE;
+                        }
+
+                        destsurf->SetColor(destsurf, r, g, b, a);
+
+                        /* ???? flags |= DSBLIT_SRC_PREMULTCOLOR; */
+
+                        SetBlendMode(data, texture->blendMode, texturedata);
+
+                        destsurf->SetBlittingFlags(destsurf, data->blitFlags | flags);
+
+#if (DFB_VERSION_ATLEAST(1,2,0))
+                        destsurf->SetRenderOptions(destsurf, texturedata->render_options);
+#endif
+
+                        vertices[0].x = x1;
+                        vertices[0].y = y1;
+                        vertices[0].z = 0;
+                        vertices[0].w = 0;
+                        vertices[0].s = u1;
+                        vertices[0].t = v1;
+
+                        vertices[1].x = x2;
+                        vertices[1].y = y2;
+                        vertices[1].z = 0;
+                        vertices[1].w = 0;
+                        vertices[1].s = u2;
+                        vertices[1].t = v2;
+
+                        vertices[2].x = x3;
+                        vertices[2].y = y3;
+                        vertices[2].z = 0;
+                        vertices[2].w = 0;
+                        vertices[2].s = u3;
+                        vertices[2].t = v3;
+
+                        destsurf->TextureTriangles(destsurf, texturedata->surface, vertices, NULL, 3, DTTF_LIST);
+                    } else {
+                        DFBTriangle tris;
+                        tris.x1 = x1;
+                        tris.y1 = y1;
+                        tris.x2 = x2;
+                        tris.y2 = y2;
+                        tris.x3 = x3;
+                        tris.y3 = y3;
+
+                        cmd->data.draw.r = (r1 + r2 + r3) / 3;
+                        cmd->data.draw.g = (g1 + g2 + g3) / 3;
+                        cmd->data.draw.b = (b1 + b2 + b3) / 3;
+                        cmd->data.draw.a = (a1 + a2 + a3) / 3;
+
+                        PrepareDraw(renderer, cmd);
+
+                        destsurf->FillTriangles(destsurf, &tris, 1);
+                    }
+                }
+
+                cmd->data.draw.r = save_r;
+                cmd->data.draw.g = save_g;
+                cmd->data.draw.b = save_b;
+                cmd->data.draw.a = save_a;
+                break;
+            }
+
+            case SDL_RENDERCMD_COPY_EX: /* unused */
+                break;
 
             case SDL_RENDERCMD_NO_OP:
                 break;
@@ -984,9 +1181,9 @@ DirectFB_CreateRenderer(SDL_Window * window, Uint32 flags)
     renderer->QueueSetDrawColor = DirectFB_QueueSetViewport;  /* SetViewport and SetDrawColor are (currently) no-ops. */
     renderer->QueueDrawPoints = DirectFB_QueueDrawPoints;
     renderer->QueueDrawLines = DirectFB_QueueDrawPoints;  /* lines and points queue vertices the same way. */
+    renderer->QueueGeometry = DirectFB_QueueGeometry;
     renderer->QueueFillRects = DirectFB_QueueFillRects;
     renderer->QueueCopy = DirectFB_QueueCopy;
-    renderer->QueueCopyEx = DirectFB_QueueCopyEx;
     renderer->RunCommandQueue = DirectFB_RunCommandQueue;
     renderer->RenderPresent = DirectFB_RenderPresent;
 
diff --git a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_render.h b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_render.h
index aa0ceb47f..b8ebae2cc 100644
--- a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_render.h
+++ b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_render.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_shape.c b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_shape.c
index 153a0c8e6..da2290f6d 100644
--- a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_shape.c
+++ b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_shape.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -34,7 +34,7 @@ DirectFB_CreateShaper(SDL_Window* window) {
     SDL_ShapeData* data;
     int resized_properly;
 
-    result = malloc(sizeof(SDL_WindowShaper));
+    result = SDL_malloc(sizeof(SDL_WindowShaper));
     result->window = window;
     result->mode.mode = ShapeModeDefault;
     result->mode.parameters.binarizationCutoff = 1;
diff --git a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_shape.h b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_shape.h
index b98901be0..579e5e4b1 100644
--- a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_shape.h
+++ b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_shape.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_video.c b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_video.c
index 5ea61a102..cce1ee5fe 100644
--- a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_video.c
+++ b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_video.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -113,7 +113,8 @@ DirectFB_CreateDevice(int devindex)
     device->MaximizeWindow = DirectFB_MaximizeWindow;
     device->MinimizeWindow = DirectFB_MinimizeWindow;
     device->RestoreWindow = DirectFB_RestoreWindow;
-    device->SetWindowGrab = DirectFB_SetWindowGrab;
+    device->SetWindowMouseGrab = DirectFB_SetWindowMouseGrab;
+    device->SetWindowKeyboardGrab = DirectFB_SetWindowKeyboardGrab;
     device->DestroyWindow = DirectFB_DestroyWindow;
     device->GetWindowWMInfo = DirectFB_GetWindowWMInfo;
 
@@ -200,7 +201,7 @@ static int readBoolEnv(const char *env_name, int def_val)
 
     stemp = SDL_getenv(env_name);
     if (stemp)
-        return atoi(stemp);
+        return SDL_atoi(stemp);
     else
         return def_val;
 }
@@ -260,7 +261,6 @@ DirectFB_VideoInit(_THIS)
 
     devdata->dfb = dfb;
     devdata->firstwin = NULL;
-    devdata->grabbed_window = NULL;
 
     _this->driverdata = devdata;
 
diff --git a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_video.h b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_video.h
index 6acde7fb0..17bbdea28 100644
--- a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_video.h
+++ b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_video.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -153,10 +153,6 @@ struct _DFB_DeviceData
     int                 use_linux_input;
     int                 has_own_wm;
 
-
-    /* window grab */
-    SDL_Window          *grabbed_window;
-
     /* global events */
     IDirectFBEventBuffer *events;
 };
diff --git a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_vulkan.c b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_vulkan.c
index 3a2acae56..398ba55ba 100644
--- a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_vulkan.c
+++ b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_vulkan.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_vulkan.h b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_vulkan.h
index 2e1698035..1e6eb9641 100644
--- a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_vulkan.h
+++ b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_vulkan.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_window.c b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_window.c
index fdba402c8..7dfda6472 100644
--- a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_window.c
+++ b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_window.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -227,7 +227,7 @@ DirectFB_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon)
 
         p = surface->pixels;
         for (i = 0; i < surface->h; i++)
-            memcpy((char *) dest + i * pitch,
+            SDL_memcpy((char *) dest + i * pitch,
                    (char *) p + i * surface->pitch, 4 * surface->w);
 
         SDL_DFB_CHECK(windata->icon->Unlock(windata->icon));
@@ -383,25 +383,26 @@ DirectFB_RestoreWindow(_THIS, SDL_Window * window)
 }
 
 void
-DirectFB_SetWindowGrab(_THIS, SDL_Window * window, SDL_bool grabbed)
+DirectFB_SetWindowMouseGrab(_THIS, SDL_Window * window, SDL_bool grabbed)
 {
-    SDL_DFB_DEVICEDATA(_this);
     SDL_DFB_WINDOWDATA(window);
-    DFB_WindowData *gwindata = ((devdata->grabbed_window) ? (DFB_WindowData *) ((devdata->grabbed_window)->driverdata) : NULL);
 
-    if ((window->flags & SDL_WINDOW_INPUT_GRABBED)) {
-        if (gwindata != NULL)
-        {
-            SDL_DFB_CHECK(gwindata->dfbwin->UngrabPointer(gwindata->dfbwin));
-            SDL_DFB_CHECK(gwindata->dfbwin->UngrabKeyboard(gwindata->dfbwin));
-        }
+    if (grabbed) {
         SDL_DFB_CHECK(windata->dfbwin->GrabPointer(windata->dfbwin));
-        SDL_DFB_CHECK(windata->dfbwin->GrabKeyboard(windata->dfbwin));
-        devdata->grabbed_window = window;
     } else {
         SDL_DFB_CHECK(windata->dfbwin->UngrabPointer(windata->dfbwin));
+    }
+}
+
+void
+DirectFB_SetWindowKeyboardGrab(_THIS, SDL_Window * window, SDL_bool grabbed)
+{
+    SDL_DFB_WINDOWDATA(window);
+
+    if (grabbed) {
+        SDL_DFB_CHECK(windata->dfbwin->GrabKeyboard(windata->dfbwin));
+    } else {
         SDL_DFB_CHECK(windata->dfbwin->UngrabKeyboard(windata->dfbwin));
-        devdata->grabbed_window = NULL;
     }
 }
 
diff --git a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_window.h b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_window.h
index 1d789c718..fc0b22ccc 100644
--- a/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_window.h
+++ b/Engine/lib/sdl/src/video/directfb/SDL_DirectFB_window.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -69,7 +69,8 @@ extern void DirectFB_RaiseWindow(_THIS, SDL_Window * window);
 extern void DirectFB_MaximizeWindow(_THIS, SDL_Window * window);
 extern void DirectFB_MinimizeWindow(_THIS, SDL_Window * window);
 extern void DirectFB_RestoreWindow(_THIS, SDL_Window * window);
-extern void DirectFB_SetWindowGrab(_THIS, SDL_Window * window, SDL_bool grabbed);
+extern void DirectFB_SetWindowMouseGrab(_THIS, SDL_Window * window, SDL_bool grabbed);
+extern void DirectFB_SetWindowKeyboardGrab(_THIS, SDL_Window * window, SDL_bool grabbed);
 extern void DirectFB_DestroyWindow(_THIS, SDL_Window * window);
 extern SDL_bool DirectFB_GetWindowWMInfo(_THIS, SDL_Window * window,
                                          struct SDL_SysWMinfo *info);
diff --git a/Engine/lib/sdl/src/video/dummy/SDL_nullevents.c b/Engine/lib/sdl/src/video/dummy/SDL_nullevents.c
index 4db63b618..e58ba2978 100644
--- a/Engine/lib/sdl/src/video/dummy/SDL_nullevents.c
+++ b/Engine/lib/sdl/src/video/dummy/SDL_nullevents.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/dummy/SDL_nullevents_c.h b/Engine/lib/sdl/src/video/dummy/SDL_nullevents_c.h
index ac56d68df..54eb74c91 100644
--- a/Engine/lib/sdl/src/video/dummy/SDL_nullevents_c.h
+++ b/Engine/lib/sdl/src/video/dummy/SDL_nullevents_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/dummy/SDL_nullframebuffer.c b/Engine/lib/sdl/src/video/dummy/SDL_nullframebuffer.c
index 803f131fc..dd7cbbd16 100644
--- a/Engine/lib/sdl/src/video/dummy/SDL_nullframebuffer.c
+++ b/Engine/lib/sdl/src/video/dummy/SDL_nullframebuffer.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -33,17 +33,13 @@ int SDL_DUMMY_CreateWindowFramebuffer(_THIS, SDL_Window * window, Uint32 * forma
     SDL_Surface *surface;
     const Uint32 surface_format = SDL_PIXELFORMAT_RGB888;
     int w, h;
-    int bpp;
-    Uint32 Rmask, Gmask, Bmask, Amask;
 
     /* Free the old framebuffer surface */
-    surface = (SDL_Surface *) SDL_GetWindowData(window, DUMMY_SURFACE);
-    SDL_FreeSurface(surface);
+    SDL_DUMMY_DestroyWindowFramebuffer(_this, window);
 
     /* Create a new one */
-    SDL_PixelFormatEnumToMasks(surface_format, &bpp, &Rmask, &Gmask, &Bmask, &Amask);
     SDL_GetWindowSize(window, &w, &h);
-    surface = SDL_CreateRGBSurface(0, w, h, bpp, Rmask, Gmask, Bmask, Amask);
+    surface = SDL_CreateRGBSurfaceWithFormat(0, w, h, 0, surface_format);
     if (!surface) {
         return -1;
     }
@@ -69,7 +65,7 @@ int SDL_DUMMY_UpdateWindowFramebuffer(_THIS, SDL_Window * window, const SDL_Rect
     /* Send the data to the display */
     if (SDL_getenv("SDL_VIDEO_DUMMY_SAVE_FRAMES")) {
         char file[128];
-        SDL_snprintf(file, sizeof(file), "SDL_window%d-%8.8d.bmp",
+        SDL_snprintf(file, sizeof(file), "SDL_window%" SDL_PRIu32 "-%8.8d.bmp",
                      SDL_GetWindowID(window), ++frame_number);
         SDL_SaveBMP(surface, file);
     }
diff --git a/Engine/lib/sdl/src/video/dummy/SDL_nullframebuffer_c.h b/Engine/lib/sdl/src/video/dummy/SDL_nullframebuffer_c.h
index 5b1dea3d7..cd8158e47 100644
--- a/Engine/lib/sdl/src/video/dummy/SDL_nullframebuffer_c.h
+++ b/Engine/lib/sdl/src/video/dummy/SDL_nullframebuffer_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/dummy/SDL_nullvideo.c b/Engine/lib/sdl/src/video/dummy/SDL_nullvideo.c
index 71ae6879f..aafed848d 100644
--- a/Engine/lib/sdl/src/video/dummy/SDL_nullvideo.c
+++ b/Engine/lib/sdl/src/video/dummy/SDL_nullvideo.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -116,6 +116,7 @@ DUMMY_VideoInit(_THIS)
     SDL_DisplayMode mode;
 
     /* Use a fake 32-bpp desktop mode */
+    SDL_zero(mode);
     mode.format = SDL_PIXELFORMAT_RGB888;
     mode.w = 1024;
     mode.h = 768;
@@ -125,7 +126,6 @@ DUMMY_VideoInit(_THIS)
         return -1;
     }
 
-    SDL_zero(mode);
     SDL_AddDisplayMode(&_this->displays[0], &mode);
 
     /* We're done! */
diff --git a/Engine/lib/sdl/src/video/dummy/SDL_nullvideo.h b/Engine/lib/sdl/src/video/dummy/SDL_nullvideo.h
index e5c01d9b1..c07aaf144 100644
--- a/Engine/lib/sdl/src/video/dummy/SDL_nullvideo.h
+++ b/Engine/lib/sdl/src/video/dummy/SDL_nullvideo.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenevents.c b/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenevents.c
index c9e764e67..39578f854 100644
--- a/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenevents.c
+++ b/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenevents.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -409,7 +409,22 @@ static EM_BOOL
 Emscripten_HandleWheel(int eventType, const EmscriptenWheelEvent *wheelEvent, void *userData)
 {
     SDL_WindowData *window_data = userData;
-    SDL_SendMouseWheel(window_data->window, 0, (float)wheelEvent->deltaX, (float)-wheelEvent->deltaY, SDL_MOUSEWHEEL_NORMAL);
+
+    float deltaY = wheelEvent->deltaY;
+
+    switch (wheelEvent->deltaMode) {
+        case DOM_DELTA_PIXEL:
+            deltaY /= 100; /* 100 pixels make up a step */
+            break;
+        case DOM_DELTA_LINE:
+            deltaY /= 3; /* 3 lines make up a step */
+            break;
+        case DOM_DELTA_PAGE:
+            deltaY *= 80; /* A page makes up 80 steps */
+            break;
+    }
+
+    SDL_SendMouseWheel(window_data->window, 0, (float)wheelEvent->deltaX, -deltaY, SDL_MOUSEWHEEL_NORMAL);
     return SDL_GetEventState(SDL_MOUSEWHEEL) == SDL_ENABLE;
 }
 
@@ -478,7 +493,7 @@ static EM_BOOL
 Emscripten_HandleKey(int eventType, const EmscriptenKeyboardEvent *keyEvent, void *userData)
 {
     Uint32 scancode;
-    SDL_bool prevent_default;
+    SDL_bool prevent_default = SDL_FALSE;
     SDL_bool is_nav_key;
 
     /* .keyCode is deprecated, but still the most reliable way to get keys */
@@ -562,12 +577,10 @@ Emscripten_HandleKey(int eventType, const EmscriptenKeyboardEvent *keyEvent, voi
                         break;
                 }
             }
-            SDL_SendKeyboardKey(eventType == EMSCRIPTEN_EVENT_KEYDOWN ? SDL_PRESSED : SDL_RELEASED, scancode);
+            prevent_default = SDL_SendKeyboardKey(eventType == EMSCRIPTEN_EVENT_KEYDOWN ? SDL_PRESSED : SDL_RELEASED, scancode);
         }
     }
 
-    prevent_default = SDL_GetEventState(eventType == EMSCRIPTEN_EVENT_KEYDOWN ? SDL_KEYDOWN : SDL_KEYUP) == SDL_ENABLE;
-
     /* if TEXTINPUT events are enabled we can't prevent keydown or we won't get keypress
      * we need to ALWAYS prevent backspace and tab otherwise chrome takes action and does bad navigation UX
      */
@@ -576,7 +589,9 @@ Emscripten_HandleKey(int eventType, const EmscriptenKeyboardEvent *keyEvent, voi
                  keyEvent->keyCode == 37 /* left */ ||
                  keyEvent->keyCode == 38 /* up */ ||
                  keyEvent->keyCode == 39 /* right */ ||
-                 keyEvent->keyCode == 40 /* down */;
+                 keyEvent->keyCode == 40 /* down */ ||
+                 (keyEvent->keyCode >= 112 && keyEvent->keyCode <= 135) /* F keys*/ ||
+                 keyEvent->ctrlKey;
 
     if (eventType == EMSCRIPTEN_EVENT_KEYDOWN && SDL_GetEventState(SDL_TEXTINPUT) == SDL_ENABLE && !is_nav_key)
         prevent_default = SDL_FALSE;
@@ -605,9 +620,6 @@ Emscripten_HandleFullscreenChange(int eventType, const EmscriptenFullscreenChang
         window_data->window->flags |= window_data->requested_fullscreen_mode;
 
         window_data->requested_fullscreen_mode = 0;
-
-        if(!window_data->requested_fullscreen_mode)
-            window_data->window->flags |= SDL_WINDOW_FULLSCREEN; /*we didn't request fullscreen*/
     }
     else
     {
diff --git a/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenevents.h b/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenevents.h
index 04f038ece..cc93e1a79 100644
--- a/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenevents.h
+++ b/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenevents.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenframebuffer.c b/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenframebuffer.c
index 62193b910..d4e9cb8e8 100644
--- a/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenframebuffer.c
+++ b/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenframebuffer.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -109,6 +109,7 @@ int Emscripten_UpdateWindowFramebuffer(_THIS, SDL_Window * window, const SDL_Rec
             if (SDL2.data32Data !== data) {
                 SDL2.data32 = new Int32Array(data.buffer);
                 SDL2.data8 = new Uint8Array(data.buffer);
+                SDL2.data32Data = data;
             }
             var data32 = SDL2.data32;
             num = data32.length;
@@ -118,7 +119,7 @@ int Emscripten_UpdateWindowFramebuffer(_THIS, SDL_Window * window, const SDL_Rec
             //      }
             // the following code is faster though, because
             // .set() is almost free - easily 10x faster due to
-            // native memcpy efficiencies, and the remaining loop
+            // native SDL_memcpy efficiencies, and the remaining loop
             // just stores, not load + store, so it is faster
             data32.set(HEAP32.subarray(src, src + num));
             var data8 = SDL2.data8;
@@ -156,14 +157,6 @@ int Emscripten_UpdateWindowFramebuffer(_THIS, SDL_Window * window, const SDL_Rec
         return 0;
     }, surface->w, surface->h, surface->pixels);
 
-    /*if (SDL_getenv("SDL_VIDEO_Emscripten_SAVE_FRAMES")) {
-        static int frame_number = 0;
-        char file[128];
-        SDL_snprintf(file, sizeof(file), "SDL_window%d-%8.8d.bmp",
-                     SDL_GetWindowID(window), ++frame_number);
-        SDL_SaveBMP(surface, file);
-    }*/
-
     if (emscripten_has_asyncify() && SDL_GetHintBoolean(SDL_HINT_EMSCRIPTEN_ASYNCIFY, SDL_TRUE)) {
         /* give back control to browser for screen refresh */
         emscripten_sleep(0);
diff --git a/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenframebuffer.h b/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenframebuffer.h
index 6d413dd32..ec59281af 100644
--- a/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenframebuffer.h
+++ b/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenframebuffer.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenmouse.c b/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenmouse.c
index 8d9689612..e73072590 100644
--- a/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenmouse.c
+++ b/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenmouse.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenmouse.h b/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenmouse.h
index 0a9c0d8af..cfc36aee3 100644
--- a/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenmouse.h
+++ b/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenmouse.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenopengles.c b/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenopengles.c
index 6544bc613..a450c8c89 100644
--- a/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenopengles.c
+++ b/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenopengles.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenopengles.h b/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenopengles.h
index 8a8c5f874..081b02fef 100644
--- a/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenopengles.h
+++ b/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenopengles.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenvideo.c b/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenvideo.c
index 23cf6f43f..f6ee1e7e5 100644
--- a/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenvideo.c
+++ b/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenvideo.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -43,6 +43,7 @@ static int Emscripten_VideoInit(_THIS);
 static int Emscripten_SetDisplayMode(_THIS, SDL_VideoDisplay * display, SDL_DisplayMode * mode);
 static void Emscripten_VideoQuit(_THIS);
 static int Emscripten_GetDisplayUsableBounds(_THIS, SDL_VideoDisplay * display, SDL_Rect * rect);
+static int Emscripten_GetDisplayDPI(_THIS, SDL_VideoDisplay * display, float * ddpi, float * hdpi, float * vdpi);
 
 static int Emscripten_CreateWindow(_THIS, SDL_Window * window);
 static void Emscripten_SetWindowSize(_THIS, SDL_Window * window);
@@ -82,6 +83,7 @@ Emscripten_CreateDevice(int devindex)
     device->VideoInit = Emscripten_VideoInit;
     device->VideoQuit = Emscripten_VideoQuit;
     device->GetDisplayUsableBounds = Emscripten_GetDisplayUsableBounds;
+    device->GetDisplayDPI = Emscripten_GetDisplayDPI;
     device->SetDisplayMode = Emscripten_SetDisplayMode;
 
 
@@ -98,7 +100,7 @@ Emscripten_CreateDevice(int devindex)
     device->MaximizeWindow = Emscripten_MaximizeWindow;
     device->MinimizeWindow = Emscripten_MinimizeWindow;
     device->RestoreWindow = Emscripten_RestoreWindow;
-    device->SetWindowGrab = Emscripten_SetWindowGrab;*/
+    device->SetWindowMouseGrab = Emscripten_SetWindowMouseGrab;*/
     device->DestroyWindow = Emscripten_DestroyWindow;
     device->SetWindowFullscreen = Emscripten_SetWindowFullscreen;
 
@@ -137,14 +139,7 @@ Emscripten_VideoInit(_THIS)
 
     /* Use a fake 32-bpp desktop mode */
     mode.format = SDL_PIXELFORMAT_RGB888;
-
-    mode.w = EM_ASM_INT_V({
-        return screen.width;
-    });
-
-    mode.h = EM_ASM_INT_V({
-        return screen.height;
-    });
+    emscripten_get_screen_size(&mode.w, &mode.h);
 
     mode.refresh_rate = 0;
     mode.driverdata = NULL;
@@ -189,6 +184,27 @@ Emscripten_GetDisplayUsableBounds(_THIS, SDL_VideoDisplay * display, SDL_Rect *
     return 0;
 }
 
+static int
+Emscripten_GetDisplayDPI(_THIS, SDL_VideoDisplay * display, float * ddpi_out, float * hdpi_out, float * vdpi_out)
+{
+    const float dpi_reference = 96.0f;
+    float dpi;
+
+    dpi = (float)emscripten_get_device_pixel_ratio() * dpi_reference;
+
+    if (ddpi_out) {
+        *ddpi_out = dpi;
+    }
+    if (hdpi_out) {
+        *hdpi_out = dpi;
+    }
+    if (vdpi_out) {
+        *vdpi_out = dpi;
+    }
+
+    return 0;
+}
+
 static void
 Emscripten_PumpEvents(_THIS)
 {
@@ -359,12 +375,7 @@ Emscripten_SetWindowFullscreen(_THIS, SDL_Window * window, SDL_VideoDisplay * di
 
 static void
 Emscripten_SetWindowTitle(_THIS, SDL_Window * window) {
-    EM_ASM_INT({
-      if (typeof setWindowTitle !== 'undefined') {
-        setWindowTitle(UTF8ToString($0));
-      }
-      return 0;
-    }, window->title);
+    emscripten_set_window_title(window->title);
 }
 
 #endif /* SDL_VIDEO_DRIVER_EMSCRIPTEN */
diff --git a/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenvideo.h b/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenvideo.h
index d15800fbf..e87788d3f 100644
--- a/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenvideo.h
+++ b/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenvideo.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/haiku/SDL_BApp.h b/Engine/lib/sdl/src/video/haiku/SDL_BApp.h
new file mode 100644
index 000000000..215f83662
--- /dev/null
+++ b/Engine/lib/sdl/src/video/haiku/SDL_BApp.h
@@ -0,0 +1,431 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef SDL_BAPP_H
+#define SDL_BAPP_H
+
+#include <Path.h>
+#include <InterfaceKit.h>
+#include <LocaleRoster.h>
+#if SDL_VIDEO_OPENGL
+#include <OpenGLKit.h>
+#endif
+
+#include "../../video/haiku/SDL_bkeyboard.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../../SDL_internal.h"
+
+#include "SDL_video.h"
+
+/* Local includes */
+#include "../../events/SDL_events_c.h"
+#include "../../video/haiku/SDL_bframebuffer.h"
+
+#ifdef __cplusplus
+}
+#endif
+
+#include <vector>
+
+
+
+
+/* Forward declarations */
+class SDL_BWin;
+
+/* Message constants */
+enum ToSDL {
+    /* Intercepted by BWindow on its way to BView */
+    BAPP_MOUSE_MOVED,
+    BAPP_MOUSE_BUTTON,
+    BAPP_MOUSE_WHEEL,
+    BAPP_KEY,
+    BAPP_REPAINT,           /* from _UPDATE_ */
+    /* From BWindow */
+    BAPP_MAXIMIZE,          /* from B_ZOOM */
+    BAPP_MINIMIZE,
+    BAPP_RESTORE,           /* TODO: IMPLEMENT! */
+    BAPP_SHOW,
+    BAPP_HIDE,
+    BAPP_MOUSE_FOCUS,       /* caused by MOUSE_MOVE */
+    BAPP_KEYBOARD_FOCUS,    /* from WINDOW_ACTIVATED */
+    BAPP_WINDOW_CLOSE_REQUESTED,
+    BAPP_WINDOW_MOVED,
+    BAPP_WINDOW_RESIZED,
+    BAPP_SCREEN_CHANGED
+};
+
+
+
+/* Create a descendant of BApplication */
+class SDL_BApp : public BApplication {
+public:
+    SDL_BApp(const char* signature) :
+        BApplication(signature) {
+#if SDL_VIDEO_OPENGL
+        _current_context = NULL;
+#endif
+    }
+
+
+    virtual ~SDL_BApp() {
+    }
+
+
+	virtual void RefsReceived(BMessage* message) {
+		char filePath[512];
+		entry_ref entryRef;
+		for (int32 i = 0; message->FindRef("refs", i, &entryRef) == B_OK; i++) {
+			BPath referencePath = BPath(&entryRef);
+			SDL_SendDropFile(NULL, referencePath.Path());
+		}
+		return;
+	}
+
+        /* Event-handling functions */
+    virtual void MessageReceived(BMessage* message) {
+        /* Sort out SDL-related messages */
+        switch ( message->what ) {
+        case BAPP_MOUSE_MOVED:
+            _HandleMouseMove(message);
+            break;
+
+        case BAPP_MOUSE_BUTTON:
+            _HandleMouseButton(message);
+            break;
+
+        case BAPP_MOUSE_WHEEL:
+            _HandleMouseWheel(message);
+            break;
+
+        case BAPP_KEY:
+            _HandleKey(message);
+            break;
+
+        case BAPP_REPAINT:
+            _HandleBasicWindowEvent(message, SDL_WINDOWEVENT_EXPOSED);
+            break;
+
+        case BAPP_MAXIMIZE:
+            _HandleBasicWindowEvent(message, SDL_WINDOWEVENT_MAXIMIZED);
+            break;
+
+        case BAPP_MINIMIZE:
+            _HandleBasicWindowEvent(message, SDL_WINDOWEVENT_MINIMIZED);
+            break;
+
+        case BAPP_SHOW:
+            _HandleBasicWindowEvent(message, SDL_WINDOWEVENT_SHOWN);
+            break;
+
+        case BAPP_HIDE:
+            _HandleBasicWindowEvent(message, SDL_WINDOWEVENT_HIDDEN);
+            break;
+
+        case BAPP_MOUSE_FOCUS:
+            _HandleMouseFocus(message);
+            break;
+
+        case BAPP_KEYBOARD_FOCUS:
+            _HandleKeyboardFocus(message);
+            break;
+
+        case BAPP_WINDOW_CLOSE_REQUESTED:
+            _HandleBasicWindowEvent(message, SDL_WINDOWEVENT_CLOSE);
+            break;
+
+        case BAPP_WINDOW_MOVED:
+            _HandleWindowMoved(message);
+            break;
+
+        case BAPP_WINDOW_RESIZED:
+            _HandleWindowResized(message);
+            break;
+
+        case B_LOCALE_CHANGED:
+            SDL_SendLocaleChangedEvent();
+            break;
+
+        case BAPP_SCREEN_CHANGED:
+            /* TODO: Handle screen resize or workspace change */
+            break;
+
+        default:
+           BApplication::MessageReceived(message);
+           break;
+        }
+    }
+
+    /* Window creation/destruction methods */
+    int32 GetID(SDL_Window *win) {
+        int32 i;
+        for(i = 0; i < _GetNumWindowSlots(); ++i) {
+            if( GetSDLWindow(i) == NULL ) {
+                _SetSDLWindow(win, i);
+                return i;
+            }
+        }
+
+        /* Expand the vector if all slots are full */
+        if( i == _GetNumWindowSlots() ) {
+            _PushBackWindow(win);
+            return i;
+        }
+
+        /* TODO: error handling */
+        return 0;
+    }
+
+    /* FIXME: Bad coding practice, but I can't include SDL_BWin.h here.  Is
+       there another way to do this? */
+    void ClearID(SDL_BWin *bwin); /* Defined in SDL_BeApp.cc */
+
+
+    SDL_Window *GetSDLWindow(int32 winID) {
+        return _window_map[winID];
+    }
+
+#if SDL_VIDEO_OPENGL
+    BGLView *GetCurrentContext() {
+        return _current_context;
+    }
+    
+    void SetCurrentContext(BGLView *newContext) {
+        if(_current_context)
+            _current_context->UnlockGL();
+        _current_context = newContext;
+        if (_current_context)
+            _current_context->LockGL();
+    }
+#endif
+
+private:
+    /* Event management */
+    void _HandleBasicWindowEvent(BMessage *msg, int32 sdlEventType) {
+        SDL_Window *win;
+        int32 winID;
+        if(
+            !_GetWinID(msg, &winID)
+        ) {
+            return;
+        }
+        win = GetSDLWindow(winID);
+        SDL_SendWindowEvent(win, sdlEventType, 0, 0);
+    }
+
+    void _HandleMouseMove(BMessage *msg) {
+        SDL_Window *win;
+        int32 winID;
+        int32 x = 0, y = 0;
+        if(
+            !_GetWinID(msg, &winID) ||
+            msg->FindInt32("x", &x) != B_OK || /* x movement */
+            msg->FindInt32("y", &y) != B_OK    /* y movement */
+        ) {
+            return;
+        }
+        win = GetSDLWindow(winID);
+
+        // Simple relative mode support for mouse.
+        if (SDL_GetMouse()->relative_mode) {
+            int winWidth, winHeight, winPosX, winPosY;
+            SDL_GetWindowSize(win, &winWidth, &winHeight);
+            SDL_GetWindowPosition(win, &winPosX, &winPosY);
+            int dx = x - (winWidth / 2);
+            int dy = y - (winHeight / 2);
+            SDL_SendMouseMotion(win, 0, SDL_GetMouse()->relative_mode, dx, dy);
+            set_mouse_position((winPosX + winWidth / 2), (winPosY + winHeight / 2));
+            if (!be_app->IsCursorHidden())
+                be_app->HideCursor();
+        } else {
+            SDL_SendMouseMotion(win, 0, 0, x, y);
+            if (SDL_ShowCursor(-1) && be_app->IsCursorHidden())
+                be_app->ShowCursor();
+        }
+    }
+
+    void _HandleMouseButton(BMessage *msg) {
+        SDL_Window *win;
+        int32 winID;
+        int32 button, state;    /* left/middle/right, pressed/released */
+        if(
+            !_GetWinID(msg, &winID) ||
+            msg->FindInt32("button-id", &button) != B_OK ||
+            msg->FindInt32("button-state", &state) != B_OK
+        ) {
+            return;
+        }
+        win = GetSDLWindow(winID);
+        SDL_SendMouseButton(win, 0, state, button);
+    }
+
+    void _HandleMouseWheel(BMessage *msg) {
+        SDL_Window *win;
+        int32 winID;
+        int32 xTicks, yTicks;
+        if(
+            !_GetWinID(msg, &winID) ||
+            msg->FindInt32("xticks", &xTicks) != B_OK ||
+            msg->FindInt32("yticks", &yTicks) != B_OK
+        ) {
+            return;
+        }
+        win = GetSDLWindow(winID);
+        SDL_SendMouseWheel(win, 0, xTicks, -yTicks, SDL_MOUSEWHEEL_NORMAL);
+    }
+
+    void _HandleKey(BMessage *msg) {
+        int32 scancode, state;  /* scancode, pressed/released */
+        if(
+            msg->FindInt32("key-state", &state) != B_OK ||
+            msg->FindInt32("key-scancode", &scancode) != B_OK
+        ) {
+            return;
+        }
+
+        /* Make sure this isn't a repeated event (key pressed and held) */
+        if(state == SDL_PRESSED && HAIKU_GetKeyState(scancode) == SDL_PRESSED) {
+            return;
+        }
+        HAIKU_SetKeyState(scancode, state);
+        SDL_SendKeyboardKey(state, HAIKU_GetScancodeFromBeKey(scancode));
+
+        if (state == SDL_PRESSED && SDL_EventState(SDL_TEXTINPUT, SDL_QUERY)) {
+            const int8 *keyUtf8;
+            ssize_t count;
+            if (msg->FindData("key-utf8", B_INT8_TYPE, (const void**)&keyUtf8, &count) == B_OK) {
+                char text[SDL_TEXTINPUTEVENT_TEXT_SIZE];
+                SDL_zeroa(text);
+                SDL_memcpy(text, keyUtf8, count);
+                SDL_SendKeyboardText(text);
+            }
+        }
+    }
+
+    void _HandleMouseFocus(BMessage *msg) {
+        SDL_Window *win;
+        int32 winID;
+        bool bSetFocus; /* If false, lose focus */
+        if(
+            !_GetWinID(msg, &winID) ||
+            msg->FindBool("focusGained", &bSetFocus) != B_OK
+        ) {
+            return;
+        }
+        win = GetSDLWindow(winID);
+        if(bSetFocus) {
+            SDL_SetMouseFocus(win);
+        } else if(SDL_GetMouseFocus() == win) {
+            /* Only lose all focus if this window was the current focus */
+            SDL_SetMouseFocus(NULL);
+        }
+    }
+
+    void _HandleKeyboardFocus(BMessage *msg) {
+        SDL_Window *win;
+        int32 winID;
+        bool bSetFocus; /* If false, lose focus */
+        if(
+            !_GetWinID(msg, &winID) ||
+            msg->FindBool("focusGained", &bSetFocus) != B_OK
+        ) {
+            return;
+        }
+        win = GetSDLWindow(winID);
+        if(bSetFocus) {
+            SDL_SetKeyboardFocus(win);
+        } else if(SDL_GetKeyboardFocus() == win) {
+            /* Only lose all focus if this window was the current focus */
+            SDL_SetKeyboardFocus(NULL);
+        }
+    }
+
+    void _HandleWindowMoved(BMessage *msg) {
+        SDL_Window *win;
+        int32 winID;
+        int32 xPos, yPos;
+        /* Get the window id and new x/y position of the window */
+        if(
+            !_GetWinID(msg, &winID) ||
+            msg->FindInt32("window-x", &xPos) != B_OK ||
+            msg->FindInt32("window-y", &yPos) != B_OK
+        ) {
+            return;
+        }
+        win = GetSDLWindow(winID);
+        SDL_SendWindowEvent(win, SDL_WINDOWEVENT_MOVED, xPos, yPos);
+    }
+
+    void _HandleWindowResized(BMessage *msg) {
+        SDL_Window *win;
+        int32 winID;
+        int32 w, h;
+        /* Get the window id ]and new x/y position of the window */
+        if(
+            !_GetWinID(msg, &winID) ||
+            msg->FindInt32("window-w", &w) != B_OK ||
+            msg->FindInt32("window-h", &h) != B_OK
+        ) {
+            return;
+        }
+        win = GetSDLWindow(winID);
+        SDL_SendWindowEvent(win, SDL_WINDOWEVENT_RESIZED, w, h);
+    }
+
+    bool _GetWinID(BMessage *msg, int32 *winID) {
+        return msg->FindInt32("window-id", winID) == B_OK;
+    }
+
+
+
+    /* Vector functions: Wraps vector stuff in case we need to change
+       implementation */
+    void _SetSDLWindow(SDL_Window *win, int32 winID) {
+        _window_map[winID] = win;
+    }
+
+    int32 _GetNumWindowSlots() {
+        return _window_map.size();
+    }
+
+
+    void _PopBackWindow() {
+        _window_map.pop_back();
+    }
+
+    void _PushBackWindow(SDL_Window *win) {
+        _window_map.push_back(win);
+    }
+
+
+    /* Members */
+    std::vector<SDL_Window*> _window_map; /* Keeps track of SDL_Windows by index-id */
+
+#if SDL_VIDEO_OPENGL
+    BGLView      *_current_context;
+#endif
+};
+
+#endif
diff --git a/Engine/lib/sdl/src/video/haiku/SDL_BWin.h b/Engine/lib/sdl/src/video/haiku/SDL_BWin.h
index 34f0d5f5d..1ac517164 100644
--- a/Engine/lib/sdl/src/video/haiku/SDL_BWin.h
+++ b/Engine/lib/sdl/src/video/haiku/SDL_BWin.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -37,8 +37,8 @@ extern "C" {
 
 #include <stdio.h>
 #include <AppKit.h>
+#include <Cursor.h>
 #include <InterfaceKit.h>
-#include <game/DirectWindow.h>
 #if SDL_VIDEO_OPENGL
 #include <opengl/GLView.h>
 #endif
@@ -57,19 +57,48 @@ enum WinCommands {
     BWIN_SET_TITLE,
     BWIN_SET_BORDERED,
     BWIN_SET_RESIZABLE,
-    BWIN_FULLSCREEN
+    BWIN_FULLSCREEN,
+    BWIN_UPDATE_FRAMEBUFFER,
+    BWIN_MINIMUM_SIZE_WINDOW
 };
 
+// non-OpenGL framebuffer view
+class SDL_BView: public BView
+{
+public:
+    SDL_BView(BRect frame, const char* name, uint32 resizingMode)
+        : BView(frame, name, resizingMode, B_WILL_DRAW),
+        fBitmap(NULL)
+    {
+    }
 
-class SDL_BWin:public BDirectWindow
+    void Draw(BRect dirty)
+    {
+        if (fBitmap != NULL)
+            DrawBitmap(fBitmap, B_ORIGIN);
+    }
+
+    void SetBitmap(BBitmap *bitmap)
+    {
+        fBitmap = bitmap;
+    }
+
+private:
+    BBitmap *fBitmap;
+};
+
+class SDL_BWin: public BWindow
 {
   public:
     /* Constructor/Destructor */
     SDL_BWin(BRect bounds, window_look look, uint32 flags)
-        : BDirectWindow(bounds, "Untitled", look, B_NORMAL_WINDOW_FEEL, flags)
+        : BWindow(bounds, "Untitled", look, B_NORMAL_WINDOW_FEEL, flags)
     {
         _last_buttons = 0;
 
+        _cur_view = NULL;
+        _SDL_View = NULL;
+
 #if SDL_VIDEO_OPENGL
         _SDL_GLView = NULL;
         _gl_type = 0;
@@ -78,59 +107,88 @@ class SDL_BWin:public BDirectWindow
         _inhibit_resize = false;
         _mouse_focused = false;
         _prev_frame = NULL;
+        _fullscreen = NULL;
 
         /* Handle framebuffer stuff */
-        _connected = _connection_disabled = false;
-        _buffer_created = _buffer_dirty = false;
-        _trash_window_buffer = false;
         _buffer_locker = new BLocker();
         _bitmap = NULL;
-        _clips = NULL;
-        _num_clips = 0;
-
-#ifdef DRAWTHREAD
-        _draw_thread_id = spawn_thread(HAIKU_DrawThread, "drawing_thread",
-                            B_NORMAL_PRIORITY, (void*) this);
-        resume_thread(_draw_thread_id);
-#endif
     }
 
     virtual ~ SDL_BWin()
     {
         Lock();
-        _connection_disabled = true;
-        int32 result;
+        
+        if (_SDL_View != NULL && _SDL_View != _cur_view) {
+            delete _SDL_View;
+            _SDL_View = NULL;
+        }
 
 #if SDL_VIDEO_OPENGL
         if (_SDL_GLView) {
-            _SDL_GLView->UnlockGL();
-            RemoveChild(_SDL_GLView);   /* Why was this outside the if
-                                            statement before? */
+            if (((SDL_BApp*)be_app)->GetCurrentContext() == _SDL_GLView)
+                ((SDL_BApp*)be_app)->SetCurrentContext(NULL);
+            if (_SDL_GLView == _cur_view)
+                RemoveChild(_SDL_GLView);
+            _SDL_GLView = NULL;
+            // _SDL_GLView deleted by HAIKU_GL_DeleteContext
         }
 
 #endif
         Unlock();
-#if SDL_VIDEO_OPENGL
-        if (_SDL_GLView) {
-            delete _SDL_GLView;
-        }
-#endif
 
         delete _prev_frame;
 
         /* Clean up framebuffer stuff */
         _buffer_locker->Lock();
-#ifdef DRAWTHREAD
-        wait_for_thread(_draw_thread_id, &result);
-#endif
-        free(_clips);
         delete _buffer_locker;
     }
+    
+    void SetCurrentView(BView *view)
+    {
+        if (_cur_view != view) {
+            if (_cur_view != NULL)
+                RemoveChild(_cur_view);
+            _cur_view = view;
+            if (_cur_view != NULL)
+                AddChild(_cur_view);
+        }
+    }
 
+    void UpdateCurrentView()
+    {
+        if (_SDL_GLView != NULL) {
+            SetCurrentView(_SDL_GLView);
+        } else if (_SDL_View != NULL) {
+            SetCurrentView(_SDL_View);
+        } else {
+            SetCurrentView(NULL);
+        }
+    }
+
+    SDL_BView *CreateView() {
+        Lock();
+        if (_SDL_View == NULL) {
+            _SDL_View = new SDL_BView(Bounds(), "SDL View", B_FOLLOW_ALL_SIDES);
+            UpdateCurrentView();
+        }
+        Unlock();
+        return _SDL_View;
+    }
+
+    void RemoveView() {
+        Lock();
+        if(_SDL_View != NULL) {
+            SDL_BView *oldView = _SDL_View;
+            _SDL_View = NULL;
+            UpdateCurrentView();
+            delete oldView;
+        }
+        Unlock();
+    }
 
     /* * * * * OpenGL functionality * * * * */
 #if SDL_VIDEO_OPENGL
-    virtual BGLView *CreateGLView(Uint32 gl_flags) {
+    BGLView *CreateGLView(Uint32 gl_flags) {
         Lock();
         if (_SDL_GLView == NULL) {
             _SDL_GLView = new BGLView(Bounds(), "SDL GLView",
@@ -138,93 +196,29 @@ class SDL_BWin:public BDirectWindow
                                      (B_WILL_DRAW | B_FRAME_EVENTS),
                                      gl_flags);
             _gl_type = gl_flags;
+            UpdateCurrentView();
         }
-        AddChild(_SDL_GLView);
-        _SDL_GLView->SetEventMask(B_POINTER_EVENTS | B_KEYBOARD_EVENTS, B_NO_POINTER_HISTORY);
-        _SDL_GLView->EnableDirectMode(true);
-        _SDL_GLView->LockGL();  /* "New" GLViews are created */
         Unlock();
-        return (_SDL_GLView);
+        return _SDL_GLView;
     }
 
-    virtual void RemoveGLView() {
+    void RemoveGLView() {
         Lock();
-        if(_SDL_GLView) {
-            _SDL_GLView->UnlockGL();
-            RemoveChild(_SDL_GLView);
+        if(_SDL_GLView != NULL) {
+            if (((SDL_BApp*)be_app)->GetCurrentContext() == _SDL_GLView)
+                ((SDL_BApp*)be_app)->SetCurrentContext(NULL);
+            _SDL_GLView = NULL;
+            UpdateCurrentView();
+            // _SDL_GLView deleted by HAIKU_GL_DeleteContext
         }
         Unlock();
     }
 
-    virtual void SwapBuffers(void) {
-        _SDL_GLView->UnlockGL();
-        _SDL_GLView->LockGL();
+    void SwapBuffers(void) {
         _SDL_GLView->SwapBuffers();
     }
 #endif
 
-    /* * * * * Framebuffering* * * * */
-    virtual void DirectConnected(direct_buffer_info *info) {
-        if(!_connected && _connection_disabled) {
-            return;
-        }
-
-        /* Determine if the pixel buffer is usable after this update */
-        _trash_window_buffer =      _trash_window_buffer
-                                || ((info->buffer_state & B_BUFFER_RESIZED)
-                                || (info->buffer_state & B_BUFFER_RESET)
-                                || (info->driver_state == B_MODE_CHANGED));
-        LockBuffer();
-
-        switch(info->buffer_state & B_DIRECT_MODE_MASK) {
-        case B_DIRECT_START:
-            _connected = true;
-
-        case B_DIRECT_MODIFY:
-            if (info->clip_list_count > _num_clips)
-            {
-                if(_clips) {
-                    free(_clips);
-                    _clips = NULL;
-                }
-            }
-
-            _num_clips = info->clip_list_count;
-            if (_clips == NULL)
-                _clips = (clipping_rect *)malloc(_num_clips*sizeof(clipping_rect));
-            if(_clips) {
-                memcpy(_clips, info->clip_list,
-                    _num_clips*sizeof(clipping_rect));
-
-                _bits = (uint8*) info->bits;
-                _row_bytes = info->bytes_per_row;
-                _bounds = info->window_bounds;
-                _bytes_per_px = info->bits_per_pixel / 8;
-                _buffer_dirty = true;
-            }
-            break;
-
-        case B_DIRECT_STOP:
-            _connected = false;
-            break;
-        }
-#if SDL_VIDEO_OPENGL
-        if(_SDL_GLView) {
-            _SDL_GLView->DirectConnected(info);
-        }
-#endif
-
-
-        /* Call the base object directconnected */
-        BDirectWindow::DirectConnected(info);
-
-        UnlockBuffer();
-
-    }
-
-
-
-
     /* * * * * Event sending * * * * */
     /* Hook functions */
     virtual void FrameMoved(BPoint origin) {
@@ -235,10 +229,10 @@ class SDL_BWin:public BDirectWindow
         _PostWindowEvent(msg);
 
         /* Perform normal hook operations */
-        BDirectWindow::FrameMoved(origin);
+        BWindow::FrameMoved(origin);
     }
 
-    virtual void FrameResized(float width, float height) {
+    void FrameResized(float width, float height) {
         /* Post a message to the BApp so that it can handle the window event */
         BMessage msg(BAPP_WINDOW_RESIZED);
 
@@ -247,10 +241,10 @@ class SDL_BWin:public BDirectWindow
         _PostWindowEvent(msg);
 
         /* Perform normal hook operations */
-        BDirectWindow::FrameResized(width, height);
+        BWindow::FrameResized(width, height);
     }
 
-    virtual bool QuitRequested() {
+    bool QuitRequested() {
         BMessage msg(BAPP_WINDOW_CLOSE_REQUESTED);
         _PostWindowEvent(msg);
 
@@ -258,13 +252,13 @@ class SDL_BWin:public BDirectWindow
         return false;
     }
 
-    virtual void WindowActivated(bool active) {
+    void WindowActivated(bool active) {
         BMessage msg(BAPP_KEYBOARD_FOCUS);  /* Mouse focus sold separately */
         msg.AddBool("focusGained", active);
         _PostWindowEvent(msg);
     }
 
-    virtual void Zoom(BPoint origin,
+    void Zoom(BPoint origin,
                 float width,
                 float height) {
         BMessage msg(BAPP_MAXIMIZE);    /* Closest thing to maximization Haiku has */
@@ -275,13 +269,13 @@ class SDL_BWin:public BDirectWindow
             _prev_frame = new BRect(Frame());
 
         /* Perform normal hook operations */
-        BDirectWindow::Zoom(origin, width, height);
+        BWindow::Zoom(origin, width, height);
     }
 
     /* Member functions */
-    virtual void Show() {
+    void Show() {
         while(IsHidden()) {
-            BDirectWindow::Show();
+            BWindow::Show();
         }
         _shown = true;
 
@@ -289,25 +283,33 @@ class SDL_BWin:public BDirectWindow
         _PostWindowEvent(msg);
     }
 
-    virtual void Hide() {
-        BDirectWindow::Hide();
+    void Hide() {
+        BWindow::Hide();
         _shown = false;
 
         BMessage msg(BAPP_HIDE);
         _PostWindowEvent(msg);
     }
 
-    virtual void Minimize(bool minimize) {
-        BDirectWindow::Minimize(minimize);
+    void Minimize(bool minimize) {
+        BWindow::Minimize(minimize);
         int32 minState = (minimize ? BAPP_MINIMIZE : BAPP_RESTORE);
 
         BMessage msg(minState);
         _PostWindowEvent(msg);
     }
 
+    void ScreenChanged(BRect screenFrame, color_space depth)
+    {
+        if (_fullscreen) {
+            MoveTo(screenFrame.left, screenFrame.top);
+            ResizeTo(screenFrame.Width(), screenFrame.Height());
+        }
+    }
+
 
     /* BView message interruption */
-    virtual void DispatchMessage(BMessage * msg, BHandler * target)
+    void DispatchMessage(BMessage * msg, BHandler * target)
     {
         BPoint where;   /* Used by mouse moved */
         int32 buttons;  /* Used for mouse button events */
@@ -356,7 +358,7 @@ class SDL_BWin:public BDirectWindow
                 }
             }
             break;
-            
+
         case B_UNMAPPED_KEY_DOWN:      /* modifier keys are unmapped */
             if (msg->FindInt32("key", &key) == B_OK) {
                 _KeyEvent((SDL_Scancode)key, NULL, 0, SDL_PRESSED);
@@ -376,15 +378,15 @@ class SDL_BWin:public BDirectWindow
                - CTRL+Q to close window (and other shortcuts)
                - PrintScreen to make screenshot into /boot/home
                - etc.. */
-            /* BDirectWindow::DispatchMessage(msg, target); */
+            /* BWindow::DispatchMessage(msg, target); */
             break;
         }
 
-        BDirectWindow::DispatchMessage(msg, target);
+        BWindow::DispatchMessage(msg, target);
     }
 
     /* Handle command messages */
-    virtual void MessageReceived(BMessage* message) {
+    void MessageReceived(BMessage* message) {
         switch (message->what) {
             /* Handle commands from SDL */
             case BWIN_SET_TITLE:
@@ -396,12 +398,18 @@ class SDL_BWin:public BDirectWindow
             case BWIN_RESIZE_WINDOW:
                 _ResizeTo(message);
                 break;
-            case BWIN_SET_BORDERED:
-                _SetBordered(message);
+            case BWIN_SET_BORDERED: {
+                bool bEnabled;
+                if (message->FindBool("window-border", &bEnabled) == B_OK)
+                    _SetBordered(bEnabled);
                 break;
-            case BWIN_SET_RESIZABLE:
-                _SetResizable(message);
+            }
+            case BWIN_SET_RESIZABLE: {
+                bool bEnabled;
+                if (message->FindBool("window-resizable", &bEnabled) == B_OK)
+                    _SetResizable(bEnabled);
                 break;
+            }
             case BWIN_SHOW_WINDOW:
                 Show();
                 break;
@@ -417,12 +425,34 @@ class SDL_BWin:public BDirectWindow
             case BWIN_RESTORE_WINDOW:
                 _Restore();
                 break;
-            case BWIN_FULLSCREEN:
-                _SetFullScreen(message);
+            case BWIN_FULLSCREEN: {
+                bool fullscreen;
+                if (message->FindBool("fullscreen", &fullscreen) == B_OK)
+                    _SetFullScreen(fullscreen);
                 break;
+            }
+            case BWIN_MINIMUM_SIZE_WINDOW:
+                _SetMinimumSize(message);
+                break;
+            case BWIN_UPDATE_FRAMEBUFFER: {
+                BMessage* pendingMessage;
+                while ((pendingMessage
+                                = MessageQueue()->FindMessage(BWIN_UPDATE_FRAMEBUFFER, 0))) {
+                        MessageQueue()->RemoveMessage(pendingMessage);
+                        delete pendingMessage;
+                }
+                if (_bitmap != NULL) {
+                    if (_SDL_View != NULL && _cur_view == _SDL_View)
+                        _SDL_View->Draw(Bounds());
+                    else if (_SDL_GLView != NULL && _cur_view == _SDL_GLView) {
+                        _SDL_GLView->CopyPixelsIn(_bitmap, B_ORIGIN);
+                    }
+                }
+                break;
+            }
             default:
                 /* Perform normal message handling */
-                BDirectWindow::MessageReceived(message);
+                BWindow::MessageReceived(message);
                 break;
         }
 
@@ -433,19 +463,9 @@ class SDL_BWin:public BDirectWindow
     /* Accessor methods */
     bool IsShown() { return _shown; }
     int32 GetID() { return _id; }
-    uint32 GetRowBytes() { return _row_bytes; }
-    int32 GetFbX() { return _bounds.left; }
-    int32 GetFbY() { return _bounds.top; }
-    bool ConnectionEnabled() { return !_connection_disabled; }
-    bool Connected() { return _connected; }
-    clipping_rect *GetClips() { return _clips; }
-    int32 GetNumClips() { return _num_clips; }
-    uint8* GetBufferPx() { return _bits; }
-    int32 GetBytesPerPx() { return _bytes_per_px; }
-    bool CanTrashWindowBuffer() { return _trash_window_buffer; }
-    bool BufferExists() { return _buffer_created; }
-    bool BufferIsDirty() { return _buffer_dirty; }
     BBitmap *GetBitmap() { return _bitmap; }
+    BView *GetCurView() { return _cur_view; }
+    SDL_BView *GetView() { return _SDL_View; }
 #if SDL_VIDEO_OPENGL
     BGLView *GetGLView() { return _SDL_GLView; }
     Uint32 GetGLType() { return _gl_type; }
@@ -453,12 +473,9 @@ class SDL_BWin:public BDirectWindow
 
     /* Setter methods */
     void SetID(int32 id) { _id = id; }
-    void SetBufferExists(bool bufferExists) { _buffer_created = bufferExists; }
     void LockBuffer() { _buffer_locker->Lock(); }
     void UnlockBuffer() { _buffer_locker->Unlock(); }
-    void SetBufferDirty(bool bufferDirty) { _buffer_dirty = bufferDirty; }
-    void SetTrashBuffer(bool trash) { _trash_window_buffer = trash;     }
-    void SetBitmap(BBitmap *bitmap) { _bitmap = bitmap; }
+    void SetBitmap(BBitmap *bitmap) { _bitmap = bitmap; if (_SDL_View != NULL) _SDL_View->SetBitmap(bitmap); }
 
 
 private:
@@ -564,7 +581,10 @@ private:
         ) {
             return;
         }
-        MoveTo(x, y);
+        if (_fullscreen)
+            _non_fullscreen_frame.OffsetTo(x, y);
+        else
+            MoveTo(x, y);
     }
 
     void _ResizeTo(BMessage *msg) {
@@ -575,27 +595,48 @@ private:
         ) {
             return;
         }
-        ResizeTo(w, h);
+        if (_fullscreen) {
+            _non_fullscreen_frame.right = _non_fullscreen_frame.left + w;
+            _non_fullscreen_frame.bottom = _non_fullscreen_frame.top + h;
+        } else
+            ResizeTo(w, h);
     }
 
-    void _SetBordered(BMessage *msg) {
-        bool bEnabled;
-        if(msg->FindBool("window-border", &bEnabled) != B_OK) {
-            return;
-        }
-        SetLook(bEnabled ? B_TITLED_WINDOW_LOOK : B_NO_BORDER_WINDOW_LOOK);
+    void _SetBordered(bool bEnabled) {
+        if (_fullscreen)
+            _bordered = bEnabled;
+        else
+            SetLook(bEnabled ? B_TITLED_WINDOW_LOOK : B_NO_BORDER_WINDOW_LOOK);
     }
 
-    void _SetResizable(BMessage *msg) {
-        bool bEnabled;
-        if(msg->FindBool("window-resizable", &bEnabled) != B_OK) {
+    void _SetResizable(bool bEnabled) {
+        if (_fullscreen)
+            _resizable = bEnabled;
+        else {
+            if (bEnabled) {
+                SetFlags(Flags() & ~(B_NOT_RESIZABLE | B_NOT_ZOOMABLE));
+            } else {
+                SetFlags(Flags() | (B_NOT_RESIZABLE | B_NOT_ZOOMABLE));
+            }
+        }
+    }
+
+    void _SetMinimumSize(BMessage *msg) {
+        float maxHeight;
+        float maxWidth;
+        float _;
+        int32 minHeight;
+        int32 minWidth;
+
+        // This is a bit convoluted, we only want to set the minimum not the maximum
+        // But there is no direct call to do that, so store the maximum size beforehand
+        GetSizeLimits(&_, &maxWidth, &_, &maxHeight);
+        if (msg->FindInt32("window-w", &minWidth) != B_OK)
             return;
-        }
-        if (bEnabled) {
-            SetFlags(Flags() & ~(B_NOT_RESIZABLE | B_NOT_ZOOMABLE));
-        } else {
-            SetFlags(Flags() | (B_NOT_RESIZABLE | B_NOT_ZOOMABLE));
-        }
+        if (msg->FindInt32("window-h", &minHeight) != B_OK)
+            return;
+        SetSizeLimits((float)minWidth, maxWidth, (float)minHeight, maxHeight);
+        UpdateSizeLimits();
     }
 
     void _Restore() {
@@ -603,23 +644,42 @@ private:
             Minimize(false);
         } else if(IsHidden()) {
             Show();
+        } else if (_fullscreen) {
+
         } else if(_prev_frame != NULL) {    /* Zoomed */
             MoveTo(_prev_frame->left, _prev_frame->top);
             ResizeTo(_prev_frame->Width(), _prev_frame->Height());
         }
     }
 
-    void _SetFullScreen(BMessage *msg) {
-        bool fullscreen;
-        if(
-            msg->FindBool("fullscreen", &fullscreen) != B_OK
-        ) {
-            return;
+    void _SetFullScreen(bool fullscreen) {
+        if (fullscreen != _fullscreen) {
+            if (fullscreen) {
+                BScreen screen(this);
+                BRect screenFrame = screen.Frame();
+                printf("screen frame: "); screenFrame.PrintToStream(); printf("\n");
+                _bordered = Look() != B_NO_BORDER_WINDOW_LOOK;
+                _resizable = !(Flags() & B_NOT_RESIZABLE);
+                _non_fullscreen_frame = Frame();
+                _SetBordered(false);
+                _SetResizable(false);
+                MoveTo(screenFrame.left, screenFrame.top);
+                ResizeTo(screenFrame.Width(), screenFrame.Height());
+                _fullscreen = fullscreen;
+            } else {
+                _fullscreen = fullscreen;
+                MoveTo(_non_fullscreen_frame.left, _non_fullscreen_frame.top);
+                ResizeTo(_non_fullscreen_frame.Width(), _non_fullscreen_frame.Height());
+                _SetBordered(_bordered);
+                _SetResizable(_resizable);
+            }
         }
-        SetFullScreen(fullscreen);
     }
 
     /* Members */
+
+    BView* _cur_view;
+    SDL_BView* _SDL_View;
 #if SDL_VIDEO_OPENGL
     BGLView * _SDL_GLView;
     Uint32 _gl_type;
@@ -632,23 +692,15 @@ private:
     bool  _inhibit_resize;
 
     BRect *_prev_frame; /* Previous position and size of the window */
+    bool _fullscreen;
+    // valid only if fullscreen
+    BRect _non_fullscreen_frame;
+    bool _bordered;
+    bool _resizable;
 
     /* Framebuffer members */
-    bool            _connected,
-                    _connection_disabled,
-                    _buffer_created,
-                    _buffer_dirty,
-                    _trash_window_buffer;
-    uint8          *_bits;
-    uint32          _row_bytes;
-    clipping_rect   _bounds;
-    BLocker        *_buffer_locker;
-    clipping_rect  *_clips;
-    uint32          _num_clips;
-    int32           _bytes_per_px;
-    thread_id       _draw_thread_id;
-
-    BBitmap        *_bitmap;
+    BLocker *_buffer_locker;
+    BBitmap *_bitmap;
 };
 
 
diff --git a/Engine/lib/sdl/src/video/haiku/SDL_bclipboard.cc b/Engine/lib/sdl/src/video/haiku/SDL_bclipboard.cc
index 50dc9d6c6..37cec38d3 100644
--- a/Engine/lib/sdl/src/video/haiku/SDL_bclipboard.cc
+++ b/Engine/lib/sdl/src/video/haiku/SDL_bclipboard.cc
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/haiku/SDL_bclipboard.h b/Engine/lib/sdl/src/video/haiku/SDL_bclipboard.h
index a52758e1e..128e545f9 100644
--- a/Engine/lib/sdl/src/video/haiku/SDL_bclipboard.h
+++ b/Engine/lib/sdl/src/video/haiku/SDL_bclipboard.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/haiku/SDL_bevents.cc b/Engine/lib/sdl/src/video/haiku/SDL_bevents.cc
index 95df72c4a..460b4ff26 100644
--- a/Engine/lib/sdl/src/video/haiku/SDL_bevents.cc
+++ b/Engine/lib/sdl/src/video/haiku/SDL_bevents.cc
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/haiku/SDL_bevents.h b/Engine/lib/sdl/src/video/haiku/SDL_bevents.h
index fa9e79ad6..22e491adb 100644
--- a/Engine/lib/sdl/src/video/haiku/SDL_bevents.h
+++ b/Engine/lib/sdl/src/video/haiku/SDL_bevents.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/haiku/SDL_bframebuffer.cc b/Engine/lib/sdl/src/video/haiku/SDL_bframebuffer.cc
index b5c6acc90..971231924 100644
--- a/Engine/lib/sdl/src/video/haiku/SDL_bframebuffer.cc
+++ b/Engine/lib/sdl/src/video/haiku/SDL_bframebuffer.cc
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -35,10 +35,6 @@
 extern "C" {
 #endif
 
-#ifndef DRAWTHREAD
-static int32 HAIKU_UpdateOnce(SDL_Window *window);
-#endif
-
 static SDL_INLINE SDL_BWin *_ToBeWin(SDL_Window *window) {
     return ((SDL_BWin*)(window->driverdata));
 }
@@ -56,11 +52,11 @@ int HAIKU_CreateWindowFramebuffer(_THIS, SDL_Window * window,
         return -1;
     }
 
-    while(!bwin->Connected()) { snooze(100); }
-    
     /* Make sure we have exclusive access to frame buffer data */
     bwin->LockBuffer();
 
+    bwin->CreateView();
+
     /* format */
     display_mode bmode;
     bscreen.GetMode(&bmode);
@@ -76,7 +72,7 @@ int HAIKU_CreateWindowFramebuffer(_THIS, SDL_Window * window,
     bitmap = new BBitmap(bwin->Bounds(), (color_space)bmode.space,
             false,    /* Views not accepted */
             true);    /* Contiguous memory required */
-            
+
     if(bitmap->InitCheck() != B_OK) {
         delete bitmap;
         return SDL_SetError("Could not initialize back buffer!");
@@ -84,15 +80,13 @@ int HAIKU_CreateWindowFramebuffer(_THIS, SDL_Window * window,
 
 
     bwin->SetBitmap(bitmap);
-    
+
     /* Set the pixel pointer */
     *pixels = bitmap->Bits();
 
     /* pitch = width of window, in bytes */
     *pitch = bitmap->BytesPerRow();
 
-    bwin->SetBufferExists(true);
-    bwin->SetTrashBuffer(false);
     bwin->UnlockBuffer();
     return 0;
 }
@@ -106,150 +100,26 @@ int HAIKU_UpdateWindowFramebuffer(_THIS, SDL_Window * window,
 
     SDL_BWin *bwin = _ToBeWin(window);
 
-#ifdef DRAWTHREAD    
-    bwin->LockBuffer();
-    bwin->SetBufferDirty(true);
-    bwin->UnlockBuffer();
-#else
-    bwin->SetBufferDirty(true);
-    HAIKU_UpdateOnce(window);
-#endif
+    bwin->PostMessage(BWIN_UPDATE_FRAMEBUFFER);
 
     return 0;
 }
 
-int32 HAIKU_DrawThread(void *data) {
-    SDL_BWin *bwin = (SDL_BWin*)data;
-    
-    BScreen bscreen;
-    if(!bscreen.IsValid()) {
-        return -1;
-    }
-
-    while(bwin->ConnectionEnabled()) {
-        if( bwin->Connected() && bwin->BufferExists() && bwin->BufferIsDirty() ) {
-            bwin->LockBuffer();
-            BBitmap *bitmap = NULL;
-            bitmap = bwin->GetBitmap();
-            int32 windowPitch = bitmap->BytesPerRow();
-            int32 bufferPitch = bwin->GetRowBytes();
-            uint8 *windowpx;
-            uint8 *bufferpx;
-
-            int32 BPP = bwin->GetBytesPerPx();
-            int32 windowSub = bwin->GetFbX() * BPP +
-                          bwin->GetFbY() * windowPitch;
-            clipping_rect *clips = bwin->GetClips();
-            int32 numClips = bwin->GetNumClips();
-            int i, y;
-
-            /* Blit each clipping rectangle */
-            bscreen.WaitForRetrace();
-            for(i = 0; i < numClips; ++i) {
-                /* Get addresses of the start of each clipping rectangle */
-                int32 width = clips[i].right - clips[i].left + 1;
-                int32 height = clips[i].bottom - clips[i].top + 1;
-                bufferpx = bwin->GetBufferPx() + 
-                    clips[i].top * bufferPitch + clips[i].left * BPP;
-                windowpx = (uint8*)bitmap->Bits() + 
-                    clips[i].top * windowPitch + clips[i].left * BPP -
-                    windowSub;
-
-                /* Copy each row of pixels from the window buffer into the frame
-                   buffer */
-                for(y = 0; y < height; ++y)
-                {
-
-                    if(bwin->CanTrashWindowBuffer()) {
-                        goto escape;    /* Break out before the buffer is killed */
-                    }
-
-                    memcpy(bufferpx, windowpx, width * BPP);
-                    bufferpx += bufferPitch;
-                    windowpx += windowPitch;
-                }
-            }
-
-            bwin->SetBufferDirty(false);
-escape:
-            bwin->UnlockBuffer();
-        } else {
-            snooze(16000);
-        }
-    }
-    
-    return B_OK;
-}
-
 void HAIKU_DestroyWindowFramebuffer(_THIS, SDL_Window * window) {
     SDL_BWin *bwin = _ToBeWin(window);
-    
+
     bwin->LockBuffer();
-    
+
     /* Free and clear the window buffer */
     BBitmap *bitmap = bwin->GetBitmap();
     delete bitmap;
     bwin->SetBitmap(NULL);
-    bwin->SetBufferExists(false);
+
+    bwin->RemoveView();
+
     bwin->UnlockBuffer();
 }
 
-
-/*
- * TODO:
- * This was written to test if certain errors were caused by threading issues.
- * The specific issues have since become rare enough that they may have been
- * solved, but I doubt it- they were pretty sporadic before now.
- */
-#ifndef DRAWTHREAD
-static int32 HAIKU_UpdateOnce(SDL_Window *window) {
-    SDL_BWin *bwin = _ToBeWin(window);
-    BScreen bscreen;
-    if(!bscreen.IsValid()) {
-        return -1;
-    }
-
-    if(bwin->ConnectionEnabled() && bwin->Connected()) {
-        bwin->LockBuffer();
-        int32 windowPitch = window->surface->pitch;
-        int32 bufferPitch = bwin->GetRowBytes();
-        uint8 *windowpx;
-        uint8 *bufferpx;
-
-        int32 BPP = bwin->GetBytesPerPx();
-        uint8 *windowBaseAddress = (uint8*)window->surface->pixels;
-        int32 windowSub = bwin->GetFbX() * BPP +
-                          bwin->GetFbY() * windowPitch;
-        clipping_rect *clips = bwin->GetClips();
-        int32 numClips = bwin->GetNumClips();
-        int i, y;
-
-        /* Blit each clipping rectangle */
-        bscreen.WaitForRetrace();
-        for(i = 0; i < numClips; ++i) {
-            /* Get addresses of the start of each clipping rectangle */
-            int32 width = clips[i].right - clips[i].left + 1;
-            int32 height = clips[i].bottom - clips[i].top + 1;
-            bufferpx = bwin->GetBufferPx() + 
-                clips[i].top * bufferPitch + clips[i].left * BPP;
-            windowpx = windowBaseAddress + 
-                clips[i].top * windowPitch + clips[i].left * BPP - windowSub;
-
-            /* Copy each row of pixels from the window buffer into the frame
-               buffer */
-            for(y = 0; y < height; ++y)
-            {
-                memcpy(bufferpx, windowpx, width * BPP);
-                bufferpx += bufferPitch;
-                windowpx += windowPitch;
-            }
-        }
-        bwin->UnlockBuffer();
-    }
-    return 0;
-}
-#endif
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/Engine/lib/sdl/src/video/haiku/SDL_bframebuffer.h b/Engine/lib/sdl/src/video/haiku/SDL_bframebuffer.h
index 62665ae0f..4361a39df 100644
--- a/Engine/lib/sdl/src/video/haiku/SDL_bframebuffer.h
+++ b/Engine/lib/sdl/src/video/haiku/SDL_bframebuffer.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/haiku/SDL_bkeyboard.cc b/Engine/lib/sdl/src/video/haiku/SDL_bkeyboard.cc
index 064249fea..a4aea4d48 100644
--- a/Engine/lib/sdl/src/video/haiku/SDL_bkeyboard.cc
+++ b/Engine/lib/sdl/src/video/haiku/SDL_bkeyboard.cc
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/haiku/SDL_bkeyboard.h b/Engine/lib/sdl/src/video/haiku/SDL_bkeyboard.h
index a0ddeed67..4c2a5903a 100644
--- a/Engine/lib/sdl/src/video/haiku/SDL_bkeyboard.h
+++ b/Engine/lib/sdl/src/video/haiku/SDL_bkeyboard.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/haiku/SDL_bmessagebox.cc b/Engine/lib/sdl/src/video/haiku/SDL_bmessagebox.cc
index 781002f41..d777ed834 100644
--- a/Engine/lib/sdl/src/video/haiku/SDL_bmessagebox.cc
+++ b/Engine/lib/sdl/src/video/haiku/SDL_bmessagebox.cc
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
   Copyright (C) 2018-2019 EXL <exlmotodev@gmail.com>
 
   This software is provided 'as-is', without any express or implied
diff --git a/Engine/lib/sdl/src/video/haiku/SDL_bmessagebox.h b/Engine/lib/sdl/src/video/haiku/SDL_bmessagebox.h
index 927400e0b..ca4406ebb 100644
--- a/Engine/lib/sdl/src/video/haiku/SDL_bmessagebox.h
+++ b/Engine/lib/sdl/src/video/haiku/SDL_bmessagebox.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
   Copyright (C) 2018-2019 EXL <exlmotodev@gmail.com>
 
   This software is provided 'as-is', without any express or implied
diff --git a/Engine/lib/sdl/src/video/haiku/SDL_bmodes.cc b/Engine/lib/sdl/src/video/haiku/SDL_bmodes.cc
index bf41b1b50..0cbc56b0f 100644
--- a/Engine/lib/sdl/src/video/haiku/SDL_bmodes.cc
+++ b/Engine/lib/sdl/src/video/haiku/SDL_bmodes.cc
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -281,7 +281,7 @@ void HAIKU_GetDisplayModes(_THIS, SDL_VideoDisplay *display) {
             SDL_AddDisplayMode(display, &mode);
         }
     }
-    free(bmodes);
+    free(bmodes); /* This should not be SDL_free() */
 }
 
 
@@ -313,7 +313,7 @@ int HAIKU_SetDisplayMode(_THIS, SDL_VideoDisplay *display, SDL_DisplayMode *mode
         return SDL_SetError("Bad video mode");
     }
     
-    free(bmode_list);
+    free(bmode_list); /* This should not be SDL_free() */
     
 #if SDL_VIDEO_OPENGL
     /* FIXME: Is there some way to reboot the OpenGL context?  This doesn't
diff --git a/Engine/lib/sdl/src/video/haiku/SDL_bmodes.h b/Engine/lib/sdl/src/video/haiku/SDL_bmodes.h
index e4e60d002..56fa14488 100644
--- a/Engine/lib/sdl/src/video/haiku/SDL_bmodes.h
+++ b/Engine/lib/sdl/src/video/haiku/SDL_bmodes.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/haiku/SDL_bopengl.cc b/Engine/lib/sdl/src/video/haiku/SDL_bopengl.cc
index b19397924..0c7a704d8 100644
--- a/Engine/lib/sdl/src/video/haiku/SDL_bopengl.cc
+++ b/Engine/lib/sdl/src/video/haiku/SDL_bopengl.cc
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -84,16 +84,21 @@ void *HAIKU_GL_GetProcAddress(_THIS, const char *proc)
 }
 
 
-
-
 int HAIKU_GL_SwapWindow(_THIS, SDL_Window * window) {
     _ToBeWin(window)->SwapBuffers();
     return 0;
 }
 
 int HAIKU_GL_MakeCurrent(_THIS, SDL_Window * window, SDL_GLContext context) {
-    SDL_BWin* win = (SDL_BWin*)context;
-    _GetBeApp()->SetCurrentContext(win ? win->GetGLView() : NULL);
+    BGLView* glView = (BGLView*)context;
+    // printf("HAIKU_GL_MakeCurrent(%llx), win = %llx, thread = %d\n", (uint64)context, (uint64)window, find_thread(NULL));
+    if (glView != NULL) {
+        if ((glView->Window() == NULL) || (window == NULL) || (_ToBeWin(window)->GetGLView() != glView)) {
+            SDL_SetError("MakeCurrent failed");
+            return -1;
+        }
+    }
+    _GetBeApp()->SetCurrentContext(glView);
     return 0;
 }
 
@@ -102,6 +107,11 @@ SDL_GLContext HAIKU_GL_CreateContext(_THIS, SDL_Window * window) {
     /* FIXME: Not sure what flags should be included here; may want to have
        most of them */
     SDL_BWin *bwin = _ToBeWin(window);
+    // printf("HAIKU_GL_CreateContext, win = %llx, thread = %d\n", (uint64)window, find_thread(NULL));
+    if (bwin->GetGLView() != NULL) {
+        SDL_SetError("Context already creaded");
+        return NULL;
+    }
     Uint32 gl_flags = BGL_RGB;
     if (_this->gl_config.alpha_size) {
         gl_flags |= BGL_ALPHA;
@@ -123,13 +133,25 @@ SDL_GLContext HAIKU_GL_CreateContext(_THIS, SDL_Window * window) {
             _this->gl_config.accum_alpha_size) {
         gl_flags |= BGL_ACCUM;
     }
+#if __GNUC__ > 3
+    if (_this->gl_config.share_with_current_context) {
+        gl_flags |= BGL_SHARE_CONTEXT;
+    }
+#endif
     bwin->CreateGLView(gl_flags);
-    return (SDL_GLContext)(bwin);
+    _GetBeApp()->SetCurrentContext(bwin->GetGLView());
+    return (SDL_GLContext)(bwin->GetGLView());
 }
 
 void HAIKU_GL_DeleteContext(_THIS, SDL_GLContext context) {
-    /* Currently, automatically unlocks the view */
-    ((SDL_BWin*)context)->RemoveGLView();
+    // printf("HAIKU_GL_DeleteContext(%llx), thread = %d\n", (uint64)context, find_thread(NULL));
+    BGLView* glView = (BGLView*)context;
+    SDL_BWin *bwin = (SDL_BWin*)glView->Window();
+    if (bwin == NULL) {
+        delete glView;
+    } else {
+        bwin->RemoveGLView();
+    }
 }
 
 
diff --git a/Engine/lib/sdl/src/video/haiku/SDL_bopengl.h b/Engine/lib/sdl/src/video/haiku/SDL_bopengl.h
index 947331db8..4723ae6b5 100644
--- a/Engine/lib/sdl/src/video/haiku/SDL_bopengl.h
+++ b/Engine/lib/sdl/src/video/haiku/SDL_bopengl.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/haiku/SDL_bvideo.cc b/Engine/lib/sdl/src/video/haiku/SDL_bvideo.cc
index 817fccf43..1ac3201f2 100644
--- a/Engine/lib/sdl/src/video/haiku/SDL_bvideo.cc
+++ b/Engine/lib/sdl/src/video/haiku/SDL_bvideo.cc
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -18,11 +18,14 @@
      misrepresented as being the original software.
   3. This notice may not be removed or altered from any source distribution.
 */
+
 #include "../../SDL_internal.h"
 #include "../../main/haiku/SDL_BApp.h"
 
 #if SDL_VIDEO_DRIVER_HAIKU
 
+#include "SDL_BWin.h"
+#include <Url.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -37,7 +40,9 @@ extern "C" {
 #include "SDL_bframebuffer.h"
 #include "SDL_bevents.h"
 
-#include <Url.h>
+static SDL_INLINE SDL_BWin *_ToBeWin(SDL_Window *window) {
+    return ((SDL_BWin*)(window->driverdata));
+}
 
 /* FIXME: Undefined functions */
 //    #define HAIKU_PumpEvents NULL
@@ -88,7 +93,8 @@ HAIKU_CreateDevice(int devindex)
     device->SetWindowFullscreen = HAIKU_SetWindowFullscreen;
     device->SetWindowGammaRamp = HAIKU_SetWindowGammaRamp;
     device->GetWindowGammaRamp = HAIKU_GetWindowGammaRamp;
-    device->SetWindowGrab = HAIKU_SetWindowGrab;
+    device->SetWindowMouseGrab = HAIKU_SetWindowMouseGrab;
+    device->SetWindowMinimumSize = HAIKU_SetWindowMinimumSize;
     device->DestroyWindow = HAIKU_DestroyWindow;
     device->GetWindowWMInfo = HAIKU_GetWindowWMInfo;
     device->CreateWindowFramebuffer = HAIKU_CreateWindowFramebuffer;
@@ -135,31 +141,133 @@ void HAIKU_DeleteDevice(SDL_VideoDevice * device)
     SDL_free(device);
 }
 
-static int HAIKU_ShowCursor(SDL_Cursor *cur)
+static SDL_Cursor *
+HAIKU_CreateSystemCursor(SDL_SystemCursor id)
+{
+    SDL_Cursor *cursor;
+    BCursorID cursorId = B_CURSOR_ID_SYSTEM_DEFAULT;
+
+    switch(id)
+    {
+    default:
+        SDL_assert(0);
+        return NULL;
+    case SDL_SYSTEM_CURSOR_ARROW:     cursorId = B_CURSOR_ID_SYSTEM_DEFAULT; break;
+    case SDL_SYSTEM_CURSOR_IBEAM:     cursorId = B_CURSOR_ID_I_BEAM; break;
+    case SDL_SYSTEM_CURSOR_WAIT:      cursorId = B_CURSOR_ID_PROGRESS; break;
+    case SDL_SYSTEM_CURSOR_CROSSHAIR: cursorId = B_CURSOR_ID_CROSS_HAIR; break;
+    case SDL_SYSTEM_CURSOR_WAITARROW: cursorId = B_CURSOR_ID_PROGRESS; break;
+    case SDL_SYSTEM_CURSOR_SIZENWSE:  cursorId = B_CURSOR_ID_RESIZE_NORTH_WEST_SOUTH_EAST; break;
+    case SDL_SYSTEM_CURSOR_SIZENESW:  cursorId = B_CURSOR_ID_RESIZE_NORTH_EAST_SOUTH_WEST; break;
+    case SDL_SYSTEM_CURSOR_SIZEWE:    cursorId = B_CURSOR_ID_RESIZE_EAST_WEST; break;
+    case SDL_SYSTEM_CURSOR_SIZENS:    cursorId = B_CURSOR_ID_RESIZE_NORTH_SOUTH; break;
+    case SDL_SYSTEM_CURSOR_SIZEALL:   cursorId = B_CURSOR_ID_MOVE; break;
+    case SDL_SYSTEM_CURSOR_NO:        cursorId = B_CURSOR_ID_NOT_ALLOWED; break;
+    case SDL_SYSTEM_CURSOR_HAND:      cursorId = B_CURSOR_ID_FOLLOW_LINK; break;
+    }
+
+    cursor = (SDL_Cursor *) SDL_calloc(1, sizeof(*cursor));
+    if (cursor) {
+        cursor->driverdata = (void *)new BCursor(cursorId);
+    } else {
+        SDL_OutOfMemory();
+    }
+
+    return cursor;
+}
+
+static SDL_Cursor *
+HAIKU_CreateDefaultCursor()
+{
+    return HAIKU_CreateSystemCursor(SDL_SYSTEM_CURSOR_ARROW);
+}
+
+static void
+HAIKU_FreeCursor(SDL_Cursor * cursor)
+{
+    if (cursor->driverdata) {
+        delete (BCursor*) cursor->driverdata;
+    }
+    SDL_free(cursor);
+}
+
+static SDL_Cursor *
+HAIKU_CreateCursor(SDL_Surface * surface, int hot_x, int hot_y)
+{
+    SDL_Cursor *cursor;
+    SDL_Surface *converted;
+
+    converted = SDL_ConvertSurfaceFormat(surface, SDL_PIXELFORMAT_ARGB8888, 0);
+    if (!converted) {
+        return NULL;
+    }
+
+	BBitmap *cursorBitmap = new BBitmap(BRect(0, 0, surface->w - 1, surface->h - 1), B_RGBA32);
+	cursorBitmap->SetBits(converted->pixels, converted->h * converted->pitch, 0, B_RGBA32);
+    SDL_FreeSurface(converted);
+
+    cursor = (SDL_Cursor *) SDL_calloc(1, sizeof(*cursor));
+    if (cursor) {
+        cursor->driverdata = (void *)new BCursor(cursorBitmap, BPoint(hot_x, hot_y));
+    } else {
+        return NULL;
+    }
+
+    return cursor;
+}
+
+static int HAIKU_ShowCursor(SDL_Cursor *cursor)
 {
 	SDL_Mouse *mouse = SDL_GetMouse();
-	int show;
+
 	if (!mouse)
 		return 0;
-	show = (cur || !mouse->focus);
-	if (show) {
-		if (be_app->IsCursorHidden())
-			be_app->ShowCursor();
+
+	if (cursor) {
+		BCursor *hCursor = (BCursor*)cursor->driverdata;
+		be_app->SetCursor(hCursor);
 	} else {
-		if (!be_app->IsCursorHidden())
-			be_app->HideCursor();
+		BCursor *hCursor = new BCursor(B_CURSOR_ID_NO_CURSOR);
+		be_app->SetCursor(hCursor);
+		delete hCursor;
 	}
+
 	return 0;
 }
 
+static int
+HAIKU_SetRelativeMouseMode(SDL_bool enabled)
+{
+    SDL_Window *window = SDL_GetMouseFocus();
+    if (!window) {
+      return 0;
+    }
+
+	SDL_BWin *bewin = _ToBeWin(window);
+	BGLView *_SDL_GLView = bewin->GetGLView();
+
+	bewin->Lock();
+	if (enabled)
+		_SDL_GLView->SetEventMask(B_POINTER_EVENTS, B_NO_POINTER_HISTORY);
+	else
+		_SDL_GLView->SetEventMask(0, 0);
+	bewin->Unlock();
+
+    return 0;
+}
+
 static void HAIKU_MouseInit(_THIS)
 {
 	SDL_Mouse *mouse = SDL_GetMouse();
 	if (!mouse)
 		return;
+	mouse->CreateCursor = HAIKU_CreateCursor;
+	mouse->CreateSystemCursor = HAIKU_CreateSystemCursor;
 	mouse->ShowCursor = HAIKU_ShowCursor;
-	mouse->cur_cursor = (SDL_Cursor*)0x1;
-	mouse->def_cursor = (SDL_Cursor*)0x2;
+	mouse->FreeCursor = HAIKU_FreeCursor;
+	mouse->SetRelativeMouseMode = HAIKU_SetRelativeMouseMode;
+
+	SDL_SetDefaultCursor(HAIKU_CreateDefaultCursor());
 }
 
 int HAIKU_VideoInit(_THIS)
diff --git a/Engine/lib/sdl/src/video/haiku/SDL_bvideo.h b/Engine/lib/sdl/src/video/haiku/SDL_bvideo.h
index aa56ab22d..d0d7bfea5 100644
--- a/Engine/lib/sdl/src/video/haiku/SDL_bvideo.h
+++ b/Engine/lib/sdl/src/video/haiku/SDL_bvideo.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/haiku/SDL_bwindow.cc b/Engine/lib/sdl/src/video/haiku/SDL_bwindow.cc
index addf20604..587affad2 100644
--- a/Engine/lib/sdl/src/video/haiku/SDL_bwindow.cc
+++ b/Engine/lib/sdl/src/video/haiku/SDL_bwindow.cc
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -205,7 +205,14 @@ int HAIKU_GetWindowGammaRamp(_THIS, SDL_Window * window, Uint16 * ramp) {
 }
 
 
-void HAIKU_SetWindowGrab(_THIS, SDL_Window * window, SDL_bool grabbed) {
+void HAIKU_SetWindowMinimumSize(_THIS, SDL_Window * window){
+    BMessage msg(BWIN_MINIMUM_SIZE_WINDOW);
+    msg.AddInt32("window-w", window->w -1);
+    msg.AddInt32("window-h", window->h -1);
+    _ToBeWin(window)->PostMessage(&msg);
+}
+
+void HAIKU_SetWindowMouseGrab(_THIS, SDL_Window * window, SDL_bool grabbed) {
     /* TODO: Implement this! */
 }
 
diff --git a/Engine/lib/sdl/src/video/haiku/SDL_bwindow.h b/Engine/lib/sdl/src/video/haiku/SDL_bwindow.h
index b6b8a8ea8..58a85d872 100644
--- a/Engine/lib/sdl/src/video/haiku/SDL_bwindow.h
+++ b/Engine/lib/sdl/src/video/haiku/SDL_bwindow.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -32,6 +32,7 @@ extern void HAIKU_SetWindowTitle(_THIS, SDL_Window * window);
 extern void HAIKU_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon);
 extern void HAIKU_SetWindowPosition(_THIS, SDL_Window * window);
 extern void HAIKU_SetWindowSize(_THIS, SDL_Window * window);
+extern void HAIKU_SetWindowMinimumSize(_THIS, SDL_Window * window);
 extern void HAIKU_ShowWindow(_THIS, SDL_Window * window);
 extern void HAIKU_HideWindow(_THIS, SDL_Window * window);
 extern void HAIKU_RaiseWindow(_THIS, SDL_Window * window);
@@ -43,7 +44,7 @@ extern void HAIKU_SetWindowResizable(_THIS, SDL_Window * window, SDL_bool resiza
 extern void HAIKU_SetWindowFullscreen(_THIS, SDL_Window * window, SDL_VideoDisplay * display, SDL_bool fullscreen);
 extern int HAIKU_SetWindowGammaRamp(_THIS, SDL_Window * window, const Uint16 * ramp);
 extern int HAIKU_GetWindowGammaRamp(_THIS, SDL_Window * window, Uint16 * ramp);
-extern void HAIKU_SetWindowGrab(_THIS, SDL_Window * window, SDL_bool grabbed);
+extern void HAIKU_SetWindowMouseGrab(_THIS, SDL_Window * window, SDL_bool grabbed);
 extern void HAIKU_DestroyWindow(_THIS, SDL_Window * window);
 extern SDL_bool HAIKU_GetWindowWMInfo(_THIS, SDL_Window * window,
                                     struct SDL_SysWMinfo *info);
diff --git a/Engine/lib/sdl/src/video/khronos/EGL/egl.h b/Engine/lib/sdl/src/video/khronos/EGL/egl.h
index 93a21873c..801f540f8 100644
--- a/Engine/lib/sdl/src/video/khronos/EGL/egl.h
+++ b/Engine/lib/sdl/src/video/khronos/EGL/egl.h
@@ -6,39 +6,24 @@ extern "C" {
 #endif
 
 /*
-** Copyright (c) 2013-2017 The Khronos Group Inc.
+** Copyright 2013-2020 The Khronos Group Inc.
+** SPDX-License-Identifier: Apache-2.0
 **
-** Permission is hereby granted, free of charge, to any person obtaining a
-** copy of this software and/or associated documentation files (the
-** "Materials"), to deal in the Materials without restriction, including
-** without limitation the rights to use, copy, modify, merge, publish,
-** distribute, sublicense, and/or sell copies of the Materials, and to
-** permit persons to whom the Materials are furnished to do so, subject to
-** the following conditions:
-**
-** The above copyright notice and this permission notice shall be included
-** in all copies or substantial portions of the Materials.
-**
-** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
-*/
-/*
-** This header is generated from the Khronos OpenGL / OpenGL ES XML
-** API Registry. The current version of the Registry, generator scripts
+** This header is generated from the Khronos EGL XML API Registry.
+** The current version of the Registry, generator scripts
 ** used to make the header, and the header can be found at
 **   http://www.khronos.org/registry/egl
 **
-** Khronos $Git commit SHA1: a732b061e7 $ on $Git commit date: 2017-06-17 23:27:53 +0100 $
+** Khronos $Git commit SHA1: 9581d004ff $ on $Git commit date: 2021-04-06 15:53:59 +0200 $
 */
 
 #include <EGL/eglplatform.h>
 
-/* Generated on date 20170627 */
+#ifndef EGL_EGL_PROTOTYPES
+#define EGL_EGL_PROTOTYPES 1
+#endif
+
+/* Generated on date 20210802 */
 
 /* Generated C header for:
  * API: egl
@@ -118,6 +103,31 @@ typedef void (*__eglMustCastToProperFunctionPointerType)(void);
 #define EGL_VERSION                       0x3054
 #define EGL_WIDTH                         0x3057
 #define EGL_WINDOW_BIT                    0x0004
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLCHOOSECONFIGPROC) (EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLCOPYBUFFERSPROC) (EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target);
+typedef EGLContext (EGLAPIENTRYP PFNEGLCREATECONTEXTPROC) (EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list);
+typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATEPBUFFERSURFACEPROC) (EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list);
+typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATEPIXMAPSURFACEPROC) (EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list);
+typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATEWINDOWSURFACEPROC) (EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYCONTEXTPROC) (EGLDisplay dpy, EGLContext ctx);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYSURFACEPROC) (EGLDisplay dpy, EGLSurface surface);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETCONFIGATTRIBPROC) (EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETCONFIGSPROC) (EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config);
+typedef EGLDisplay (EGLAPIENTRYP PFNEGLGETCURRENTDISPLAYPROC) (void);
+typedef EGLSurface (EGLAPIENTRYP PFNEGLGETCURRENTSURFACEPROC) (EGLint readdraw);
+typedef EGLDisplay (EGLAPIENTRYP PFNEGLGETDISPLAYPROC) (EGLNativeDisplayType display_id);
+typedef EGLint (EGLAPIENTRYP PFNEGLGETERRORPROC) (void);
+typedef __eglMustCastToProperFunctionPointerType (EGLAPIENTRYP PFNEGLGETPROCADDRESSPROC) (const char *procname);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLINITIALIZEPROC) (EGLDisplay dpy, EGLint *major, EGLint *minor);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLMAKECURRENTPROC) (EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYCONTEXTPROC) (EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value);
+typedef const char *(EGLAPIENTRYP PFNEGLQUERYSTRINGPROC) (EGLDisplay dpy, EGLint name);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSURFACEPROC) (EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSWAPBUFFERSPROC) (EGLDisplay dpy, EGLSurface surface);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLTERMINATEPROC) (EGLDisplay dpy);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLWAITGLPROC) (void);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLWAITNATIVEPROC) (EGLint engine);
+#if EGL_EGL_PROTOTYPES
 EGLAPI EGLBoolean EGLAPIENTRY eglChooseConfig (EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config);
 EGLAPI EGLBoolean EGLAPIENTRY eglCopyBuffers (EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target);
 EGLAPI EGLContext EGLAPIENTRY eglCreateContext (EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list);
@@ -142,6 +152,7 @@ EGLAPI EGLBoolean EGLAPIENTRY eglSwapBuffers (EGLDisplay dpy, EGLSurface surface
 EGLAPI EGLBoolean EGLAPIENTRY eglTerminate (EGLDisplay dpy);
 EGLAPI EGLBoolean EGLAPIENTRY eglWaitGL (void);
 EGLAPI EGLBoolean EGLAPIENTRY eglWaitNative (EGLint engine);
+#endif
 #endif /* EGL_VERSION_1_0 */
 
 #ifndef EGL_VERSION_1_1
@@ -160,10 +171,16 @@ EGLAPI EGLBoolean EGLAPIENTRY eglWaitNative (EGLint engine);
 #define EGL_TEXTURE_RGB                   0x305D
 #define EGL_TEXTURE_RGBA                  0x305E
 #define EGL_TEXTURE_TARGET                0x3081
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLBINDTEXIMAGEPROC) (EGLDisplay dpy, EGLSurface surface, EGLint buffer);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLRELEASETEXIMAGEPROC) (EGLDisplay dpy, EGLSurface surface, EGLint buffer);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSURFACEATTRIBPROC) (EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSWAPINTERVALPROC) (EGLDisplay dpy, EGLint interval);
+#if EGL_EGL_PROTOTYPES
 EGLAPI EGLBoolean EGLAPIENTRY eglBindTexImage (EGLDisplay dpy, EGLSurface surface, EGLint buffer);
 EGLAPI EGLBoolean EGLAPIENTRY eglReleaseTexImage (EGLDisplay dpy, EGLSurface surface, EGLint buffer);
 EGLAPI EGLBoolean EGLAPIENTRY eglSurfaceAttrib (EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value);
 EGLAPI EGLBoolean EGLAPIENTRY eglSwapInterval (EGLDisplay dpy, EGLint interval);
+#endif
 #endif /* EGL_VERSION_1_1 */
 
 #ifndef EGL_VERSION_1_2
@@ -199,11 +216,18 @@ typedef void *EGLClientBuffer;
 #define EGL_SWAP_BEHAVIOR                 0x3093
 #define EGL_UNKNOWN                       EGL_CAST(EGLint,-1)
 #define EGL_VERTICAL_RESOLUTION           0x3091
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLBINDAPIPROC) (EGLenum api);
+typedef EGLenum (EGLAPIENTRYP PFNEGLQUERYAPIPROC) (void);
+typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC) (EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLRELEASETHREADPROC) (void);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLWAITCLIENTPROC) (void);
+#if EGL_EGL_PROTOTYPES
 EGLAPI EGLBoolean EGLAPIENTRY eglBindAPI (EGLenum api);
 EGLAPI EGLenum EGLAPIENTRY eglQueryAPI (void);
 EGLAPI EGLSurface EGLAPIENTRY eglCreatePbufferFromClientBuffer (EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list);
 EGLAPI EGLBoolean EGLAPIENTRY eglReleaseThread (void);
 EGLAPI EGLBoolean EGLAPIENTRY eglWaitClient (void);
+#endif
 #endif /* EGL_VERSION_1_2 */
 
 #ifndef EGL_VERSION_1_3
@@ -232,7 +256,10 @@ EGLAPI EGLBoolean EGLAPIENTRY eglWaitClient (void);
 #define EGL_OPENGL_API                    0x30A2
 #define EGL_OPENGL_BIT                    0x0008
 #define EGL_SWAP_BEHAVIOR_PRESERVED_BIT   0x0400
+typedef EGLContext (EGLAPIENTRYP PFNEGLGETCURRENTCONTEXTPROC) (void);
+#if EGL_EGL_PROTOTYPES
 EGLAPI EGLContext EGLAPIENTRY eglGetCurrentContext (void);
+#endif
 #endif /* EGL_VERSION_1_4 */
 
 #ifndef EGL_VERSION_1_5
@@ -284,6 +311,17 @@ typedef void *EGLImage;
 #define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x30B8
 #define EGL_IMAGE_PRESERVED               0x30D2
 #define EGL_NO_IMAGE                      EGL_CAST(EGLImage,0)
+typedef EGLSync (EGLAPIENTRYP PFNEGLCREATESYNCPROC) (EGLDisplay dpy, EGLenum type, const EGLAttrib *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYSYNCPROC) (EGLDisplay dpy, EGLSync sync);
+typedef EGLint (EGLAPIENTRYP PFNEGLCLIENTWAITSYNCPROC) (EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETSYNCATTRIBPROC) (EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib *value);
+typedef EGLImage (EGLAPIENTRYP PFNEGLCREATEIMAGEPROC) (EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLAttrib *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYIMAGEPROC) (EGLDisplay dpy, EGLImage image);
+typedef EGLDisplay (EGLAPIENTRYP PFNEGLGETPLATFORMDISPLAYPROC) (EGLenum platform, void *native_display, const EGLAttrib *attrib_list);
+typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATEPLATFORMWINDOWSURFACEPROC) (EGLDisplay dpy, EGLConfig config, void *native_window, const EGLAttrib *attrib_list);
+typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC) (EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLAttrib *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLWAITSYNCPROC) (EGLDisplay dpy, EGLSync sync, EGLint flags);
+#if EGL_EGL_PROTOTYPES
 EGLAPI EGLSync EGLAPIENTRY eglCreateSync (EGLDisplay dpy, EGLenum type, const EGLAttrib *attrib_list);
 EGLAPI EGLBoolean EGLAPIENTRY eglDestroySync (EGLDisplay dpy, EGLSync sync);
 EGLAPI EGLint EGLAPIENTRY eglClientWaitSync (EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout);
@@ -294,6 +332,7 @@ EGLAPI EGLDisplay EGLAPIENTRY eglGetPlatformDisplay (EGLenum platform, void *nat
 EGLAPI EGLSurface EGLAPIENTRY eglCreatePlatformWindowSurface (EGLDisplay dpy, EGLConfig config, void *native_window, const EGLAttrib *attrib_list);
 EGLAPI EGLSurface EGLAPIENTRY eglCreatePlatformPixmapSurface (EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLAttrib *attrib_list);
 EGLAPI EGLBoolean EGLAPIENTRY eglWaitSync (EGLDisplay dpy, EGLSync sync, EGLint flags);
+#endif
 #endif /* EGL_VERSION_1_5 */
 
 #ifdef __cplusplus
diff --git a/Engine/lib/sdl/src/video/khronos/EGL/eglext.h b/Engine/lib/sdl/src/video/khronos/EGL/eglext.h
index d2def032d..94dd038c9 100644
--- a/Engine/lib/sdl/src/video/khronos/EGL/eglext.h
+++ b/Engine/lib/sdl/src/video/khronos/EGL/eglext.h
@@ -6,39 +6,20 @@ extern "C" {
 #endif
 
 /*
-** Copyright (c) 2013-2017 The Khronos Group Inc.
+** Copyright 2013-2020 The Khronos Group Inc.
+** SPDX-License-Identifier: Apache-2.0
 **
-** Permission is hereby granted, free of charge, to any person obtaining a
-** copy of this software and/or associated documentation files (the
-** "Materials"), to deal in the Materials without restriction, including
-** without limitation the rights to use, copy, modify, merge, publish,
-** distribute, sublicense, and/or sell copies of the Materials, and to
-** permit persons to whom the Materials are furnished to do so, subject to
-** the following conditions:
-**
-** The above copyright notice and this permission notice shall be included
-** in all copies or substantial portions of the Materials.
-**
-** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
-*/
-/*
-** This header is generated from the Khronos OpenGL / OpenGL ES XML
-** API Registry. The current version of the Registry, generator scripts
+** This header is generated from the Khronos EGL XML API Registry.
+** The current version of the Registry, generator scripts
 ** used to make the header, and the header can be found at
 **   http://www.khronos.org/registry/egl
 **
-** Khronos $Git commit SHA1: a732b061e7 $ on $Git commit date: 2017-06-17 23:27:53 +0100 $
+** Khronos $Git commit SHA1: dc0b58dca5 $ on $Git commit date: 2021-06-25 01:58:50 +0200 $
 */
 
 #include <EGL/eglplatform.h>
 
-#define EGL_EGLEXT_VERSION 20170627
+#define EGL_EGLEXT_VERSION 20210629
 
 /* Generated C header for:
  * API: egl
@@ -443,9 +424,9 @@ EGLAPI EGLSurface EGLAPIENTRY eglCreateStreamProducerSurfaceKHR (EGLDisplay dpy,
 
 #ifndef EGL_KHR_swap_buffers_with_damage
 #define EGL_KHR_swap_buffers_with_damage 1
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLSWAPBUFFERSWITHDAMAGEKHRPROC) (EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSWAPBUFFERSWITHDAMAGEKHRPROC) (EGLDisplay dpy, EGLSurface surface, const EGLint *rects, EGLint n_rects);
 #ifdef EGL_EGLEXT_PROTOTYPES
-EGLAPI EGLBoolean EGLAPIENTRY eglSwapBuffersWithDamageKHR (EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects);
+EGLAPI EGLBoolean EGLAPIENTRY eglSwapBuffersWithDamageKHR (EGLDisplay dpy, EGLSurface surface, const EGLint *rects, EGLint n_rects);
 #endif
 #endif /* EGL_KHR_swap_buffers_with_damage */
 
@@ -462,6 +443,10 @@ EGLAPI EGLint EGLAPIENTRY eglWaitSyncKHR (EGLDisplay dpy, EGLSyncKHR sync, EGLin
 #endif
 #endif /* EGL_KHR_wait_sync */
 
+#ifndef EGL_ANDROID_GLES_layers
+#define EGL_ANDROID_GLES_layers 1
+#endif /* EGL_ANDROID_GLES_layers */
+
 #ifndef EGL_ANDROID_blob_cache
 #define EGL_ANDROID_blob_cache 1
 typedef khronos_ssize_t EGLsizeiANDROID;
@@ -495,6 +480,47 @@ EGLAPI EGLClientBuffer EGLAPIENTRY eglCreateNativeClientBufferANDROID (const EGL
 #define EGL_FRONT_BUFFER_AUTO_REFRESH_ANDROID 0x314C
 #endif /* EGL_ANDROID_front_buffer_auto_refresh */
 
+#ifndef EGL_ANDROID_get_frame_timestamps
+#define EGL_ANDROID_get_frame_timestamps 1
+typedef khronos_stime_nanoseconds_t EGLnsecsANDROID;
+#define EGL_TIMESTAMP_PENDING_ANDROID     EGL_CAST(EGLnsecsANDROID,-2)
+#define EGL_TIMESTAMP_INVALID_ANDROID     EGL_CAST(EGLnsecsANDROID,-1)
+#define EGL_TIMESTAMPS_ANDROID            0x3430
+#define EGL_COMPOSITE_DEADLINE_ANDROID    0x3431
+#define EGL_COMPOSITE_INTERVAL_ANDROID    0x3432
+#define EGL_COMPOSITE_TO_PRESENT_LATENCY_ANDROID 0x3433
+#define EGL_REQUESTED_PRESENT_TIME_ANDROID 0x3434
+#define EGL_RENDERING_COMPLETE_TIME_ANDROID 0x3435
+#define EGL_COMPOSITION_LATCH_TIME_ANDROID 0x3436
+#define EGL_FIRST_COMPOSITION_START_TIME_ANDROID 0x3437
+#define EGL_LAST_COMPOSITION_START_TIME_ANDROID 0x3438
+#define EGL_FIRST_COMPOSITION_GPU_FINISHED_TIME_ANDROID 0x3439
+#define EGL_DISPLAY_PRESENT_TIME_ANDROID  0x343A
+#define EGL_DEQUEUE_READY_TIME_ANDROID    0x343B
+#define EGL_READS_DONE_TIME_ANDROID       0x343C
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETCOMPOSITORTIMINGSUPPORTEDANDROIDPROC) (EGLDisplay dpy, EGLSurface surface, EGLint name);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETCOMPOSITORTIMINGANDROIDPROC) (EGLDisplay dpy, EGLSurface surface, EGLint numTimestamps,  const EGLint *names, EGLnsecsANDROID *values);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETNEXTFRAMEIDANDROIDPROC) (EGLDisplay dpy, EGLSurface surface, EGLuint64KHR *frameId);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETFRAMETIMESTAMPSUPPORTEDANDROIDPROC) (EGLDisplay dpy, EGLSurface surface, EGLint timestamp);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETFRAMETIMESTAMPSANDROIDPROC) (EGLDisplay dpy, EGLSurface surface, EGLuint64KHR frameId, EGLint numTimestamps,  const EGLint *timestamps, EGLnsecsANDROID *values);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglGetCompositorTimingSupportedANDROID (EGLDisplay dpy, EGLSurface surface, EGLint name);
+EGLAPI EGLBoolean EGLAPIENTRY eglGetCompositorTimingANDROID (EGLDisplay dpy, EGLSurface surface, EGLint numTimestamps,  const EGLint *names, EGLnsecsANDROID *values);
+EGLAPI EGLBoolean EGLAPIENTRY eglGetNextFrameIdANDROID (EGLDisplay dpy, EGLSurface surface, EGLuint64KHR *frameId);
+EGLAPI EGLBoolean EGLAPIENTRY eglGetFrameTimestampSupportedANDROID (EGLDisplay dpy, EGLSurface surface, EGLint timestamp);
+EGLAPI EGLBoolean EGLAPIENTRY eglGetFrameTimestampsANDROID (EGLDisplay dpy, EGLSurface surface, EGLuint64KHR frameId, EGLint numTimestamps,  const EGLint *timestamps, EGLnsecsANDROID *values);
+#endif
+#endif /* EGL_ANDROID_get_frame_timestamps */
+
+#ifndef EGL_ANDROID_get_native_client_buffer
+#define EGL_ANDROID_get_native_client_buffer 1
+struct AHardwareBuffer;
+typedef EGLClientBuffer (EGLAPIENTRYP PFNEGLGETNATIVECLIENTBUFFERANDROIDPROC) (const struct AHardwareBuffer *buffer);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLClientBuffer EGLAPIENTRY eglGetNativeClientBufferANDROID (const struct AHardwareBuffer *buffer);
+#endif
+#endif /* EGL_ANDROID_get_native_client_buffer */
+
 #ifndef EGL_ANDROID_image_native_buffer
 #define EGL_ANDROID_image_native_buffer 1
 #define EGL_NATIVE_BUFFER_ANDROID         0x3140
@@ -514,7 +540,6 @@ EGLAPI EGLint EGLAPIENTRY eglDupNativeFenceFDANDROID (EGLDisplay dpy, EGLSyncKHR
 
 #ifndef EGL_ANDROID_presentation_time
 #define EGL_ANDROID_presentation_time 1
-typedef khronos_stime_nanoseconds_t EGLnsecsANDROID;
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLPRESENTATIONTIMEANDROIDPROC) (EGLDisplay dpy, EGLSurface surface, EGLnsecsANDROID time);
 #ifdef EGL_EGLEXT_PROTOTYPES
 EGLAPI EGLBoolean EGLAPIENTRY eglPresentationTimeANDROID (EGLDisplay dpy, EGLSurface surface, EGLnsecsANDROID time);
@@ -549,11 +574,25 @@ EGLAPI EGLBoolean EGLAPIENTRY eglQuerySurfacePointerANGLE (EGLDisplay dpy, EGLSu
 #define EGL_ANGLE_surface_d3d_texture_2d_share_handle 1
 #endif /* EGL_ANGLE_surface_d3d_texture_2d_share_handle */
 
+#ifndef EGL_ANGLE_sync_control_rate
+#define EGL_ANGLE_sync_control_rate 1
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETMSCRATEANGLEPROC) (EGLDisplay dpy, EGLSurface surface, EGLint *numerator, EGLint *denominator);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglGetMscRateANGLE (EGLDisplay dpy, EGLSurface surface, EGLint *numerator, EGLint *denominator);
+#endif
+#endif /* EGL_ANGLE_sync_control_rate */
+
 #ifndef EGL_ANGLE_window_fixed_size
 #define EGL_ANGLE_window_fixed_size 1
 #define EGL_FIXED_SIZE_ANGLE              0x3201
 #endif /* EGL_ANGLE_window_fixed_size */
 
+#ifndef EGL_ARM_image_format
+#define EGL_ARM_image_format 1
+#define EGL_COLOR_COMPONENT_TYPE_UNSIGNED_INTEGER_ARM 0x3287
+#define EGL_COLOR_COMPONENT_TYPE_INTEGER_ARM 0x3288
+#endif /* EGL_ARM_image_format */
+
 #ifndef EGL_ARM_implicit_external_sync
 #define EGL_ARM_implicit_external_sync 1
 #define EGL_SYNC_PRIOR_COMMANDS_IMPLICIT_EXTERNAL_ARM 0x328A
@@ -578,6 +617,16 @@ EGLAPI EGLBoolean EGLAPIENTRY eglQuerySurfacePointerANGLE (EGLDisplay dpy, EGLSu
 #define EGL_EXT_client_extensions 1
 #endif /* EGL_EXT_client_extensions */
 
+#ifndef EGL_EXT_client_sync
+#define EGL_EXT_client_sync 1
+#define EGL_SYNC_CLIENT_EXT               0x3364
+#define EGL_SYNC_CLIENT_SIGNAL_EXT        0x3365
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLCLIENTSIGNALSYNCEXTPROC) (EGLDisplay dpy, EGLSync sync, const EGLAttrib *attrib_list);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglClientSignalSyncEXT (EGLDisplay dpy, EGLSync sync, const EGLAttrib *attrib_list);
+#endif
+#endif /* EGL_EXT_client_sync */
+
 #ifndef EGL_EXT_compositor
 #define EGL_EXT_compositor 1
 #define EGL_PRIMARY_COMPOSITOR_CONTEXT_EXT 0x3460
@@ -602,6 +651,11 @@ EGLAPI EGLBoolean EGLAPIENTRY eglCompositorSwapPolicyEXT (EGLint external_win_id
 #endif
 #endif /* EGL_EXT_compositor */
 
+#ifndef EGL_EXT_config_select_group
+#define EGL_EXT_config_select_group 1
+#define EGL_CONFIG_SELECT_GROUP_EXT       0x34C0
+#endif /* EGL_EXT_config_select_group */
+
 #ifndef EGL_EXT_create_context_robustness
 #define EGL_EXT_create_context_robustness 1
 #define EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT 0x30BF
@@ -631,8 +685,14 @@ EGLAPI EGLBoolean EGLAPIENTRY eglQueryDisplayAttribEXT (EGLDisplay dpy, EGLint a
 #ifndef EGL_EXT_device_drm
 #define EGL_EXT_device_drm 1
 #define EGL_DRM_DEVICE_FILE_EXT           0x3233
+#define EGL_DRM_MASTER_FD_EXT             0x333C
 #endif /* EGL_EXT_device_drm */
 
+#ifndef EGL_EXT_device_drm_render_node
+#define EGL_EXT_device_drm_render_node 1
+#define EGL_DRM_RENDER_NODE_FILE_EXT      0x3377
+#endif /* EGL_EXT_device_drm_render_node */
+
 #ifndef EGL_EXT_device_enumeration
 #define EGL_EXT_device_enumeration 1
 #endif /* EGL_EXT_device_enumeration */
@@ -642,10 +702,26 @@ EGLAPI EGLBoolean EGLAPIENTRY eglQueryDisplayAttribEXT (EGLDisplay dpy, EGLint a
 #define EGL_OPENWF_DEVICE_ID_EXT          0x3237
 #endif /* EGL_EXT_device_openwf */
 
+#ifndef EGL_EXT_device_persistent_id
+#define EGL_EXT_device_persistent_id 1
+#define EGL_DEVICE_UUID_EXT               0x335C
+#define EGL_DRIVER_UUID_EXT               0x335D
+#define EGL_DRIVER_NAME_EXT               0x335E
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYDEVICEBINARYEXTPROC) (EGLDeviceEXT device, EGLint name, EGLint max_size, void *value, EGLint *size);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglQueryDeviceBinaryEXT (EGLDeviceEXT device, EGLint name, EGLint max_size, void *value, EGLint *size);
+#endif
+#endif /* EGL_EXT_device_persistent_id */
+
 #ifndef EGL_EXT_device_query
 #define EGL_EXT_device_query 1
 #endif /* EGL_EXT_device_query */
 
+#ifndef EGL_EXT_device_query_name
+#define EGL_EXT_device_query_name 1
+#define EGL_RENDERER_EXT                  0x335F
+#endif /* EGL_EXT_device_query_name */
+
 #ifndef EGL_EXT_gl_colorspace_bt2020_linear
 #define EGL_EXT_gl_colorspace_bt2020_linear 1
 #define EGL_GL_COLORSPACE_BT2020_LINEAR_EXT 0x333F
@@ -666,6 +742,11 @@ EGLAPI EGLBoolean EGLAPIENTRY eglQueryDisplayAttribEXT (EGLDisplay dpy, EGLint a
 #define EGL_GL_COLORSPACE_DISPLAY_P3_LINEAR_EXT 0x3362
 #endif /* EGL_EXT_gl_colorspace_display_p3_linear */
 
+#ifndef EGL_EXT_gl_colorspace_display_p3_passthrough
+#define EGL_EXT_gl_colorspace_display_p3_passthrough 1
+#define EGL_GL_COLORSPACE_DISPLAY_P3_PASSTHROUGH_EXT 0x3490
+#endif /* EGL_EXT_gl_colorspace_display_p3_passthrough */
+
 #ifndef EGL_EXT_gl_colorspace_scrgb
 #define EGL_EXT_gl_colorspace_scrgb 1
 #define EGL_GL_COLORSPACE_SCRGB_EXT       0x3351
@@ -723,6 +804,11 @@ EGLAPI EGLBoolean EGLAPIENTRY eglQueryDmaBufModifiersEXT (EGLDisplay dpy, EGLint
 #endif
 #endif /* EGL_EXT_image_dma_buf_import_modifiers */
 
+#ifndef EGL_EXT_image_gl_colorspace
+#define EGL_EXT_image_gl_colorspace 1
+#define EGL_GL_COLORSPACE_DEFAULT_EXT     0x314D
+#endif /* EGL_EXT_image_gl_colorspace */
+
 #ifndef EGL_EXT_image_implicit_sync_control
 #define EGL_EXT_image_implicit_sync_control 1
 #define EGL_IMPORT_SYNC_TYPE_EXT          0x3470
@@ -812,6 +898,17 @@ EGLAPI EGLSurface EGLAPIENTRY eglCreatePlatformPixmapSurfaceEXT (EGLDisplay dpy,
 #define EGL_PLATFORM_X11_SCREEN_EXT       0x31D6
 #endif /* EGL_EXT_platform_x11 */
 
+#ifndef EGL_EXT_platform_xcb
+#define EGL_EXT_platform_xcb 1
+#define EGL_PLATFORM_XCB_EXT              0x31DC
+#define EGL_PLATFORM_XCB_SCREEN_EXT       0x31DE
+#endif /* EGL_EXT_platform_xcb */
+
+#ifndef EGL_EXT_present_opaque
+#define EGL_EXT_present_opaque 1
+#define EGL_PRESENT_OPAQUE_EXT            0x31DF
+#endif /* EGL_EXT_present_opaque */
+
 #ifndef EGL_EXT_protected_content
 #define EGL_EXT_protected_content 1
 #define EGL_PROTECTED_CONTENT_EXT         0x32C0
@@ -852,12 +949,20 @@ EGLAPI EGLBoolean EGLAPIENTRY eglStreamConsumerOutputEXT (EGLDisplay dpy, EGLStr
 
 #ifndef EGL_EXT_swap_buffers_with_damage
 #define EGL_EXT_swap_buffers_with_damage 1
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC) (EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC) (EGLDisplay dpy, EGLSurface surface, const EGLint *rects, EGLint n_rects);
 #ifdef EGL_EGLEXT_PROTOTYPES
-EGLAPI EGLBoolean EGLAPIENTRY eglSwapBuffersWithDamageEXT (EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects);
+EGLAPI EGLBoolean EGLAPIENTRY eglSwapBuffersWithDamageEXT (EGLDisplay dpy, EGLSurface surface, const EGLint *rects, EGLint n_rects);
 #endif
 #endif /* EGL_EXT_swap_buffers_with_damage */
 
+#ifndef EGL_EXT_sync_reuse
+#define EGL_EXT_sync_reuse 1
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLUNSIGNALSYNCEXTPROC) (EGLDisplay dpy, EGLSync sync, const EGLAttrib *attrib_list);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglUnsignalSyncEXT (EGLDisplay dpy, EGLSync sync, const EGLAttrib *attrib_list);
+#endif
+#endif /* EGL_EXT_sync_reuse */
+
 #ifndef EGL_EXT_yuv_surface
 #define EGL_EXT_yuv_surface 1
 #define EGL_YUV_ORDER_EXT                 0x3301
@@ -933,6 +1038,7 @@ EGLAPI EGLSurface EGLAPIENTRY eglCreatePixmapSurfaceHI (EGLDisplay dpy, EGLConfi
 #define EGL_DRM_BUFFER_STRIDE_MESA        0x31D4
 #define EGL_DRM_BUFFER_USE_SCANOUT_MESA   0x00000001
 #define EGL_DRM_BUFFER_USE_SHARE_MESA     0x00000002
+#define EGL_DRM_BUFFER_USE_CURSOR_MESA    0x00000004
 typedef EGLImageKHR (EGLAPIENTRYP PFNEGLCREATEDRMIMAGEMESAPROC) (EGLDisplay dpy, const EGLint *attrib_list);
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLEXPORTDRMIMAGEMESAPROC) (EGLDisplay dpy, EGLImageKHR image, EGLint *name, EGLint *handle, EGLint *stride);
 #ifdef EGL_EGLEXT_PROTOTYPES
@@ -961,6 +1067,16 @@ EGLAPI EGLBoolean EGLAPIENTRY eglExportDMABUFImageMESA (EGLDisplay dpy, EGLImage
 #define EGL_PLATFORM_SURFACELESS_MESA     0x31DD
 #endif /* EGL_MESA_platform_surfaceless */
 
+#ifndef EGL_MESA_query_driver
+#define EGL_MESA_query_driver 1
+typedef char *(EGLAPIENTRYP PFNEGLGETDISPLAYDRIVERCONFIGPROC) (EGLDisplay dpy);
+typedef const char *(EGLAPIENTRYP PFNEGLGETDISPLAYDRIVERNAMEPROC) (EGLDisplay dpy);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI char *EGLAPIENTRY eglGetDisplayDriverConfig (EGLDisplay dpy);
+EGLAPI const char *EGLAPIENTRY eglGetDisplayDriverName (EGLDisplay dpy);
+#endif
+#endif /* EGL_MESA_query_driver */
+
 #ifndef EGL_NOK_swap_region
 #define EGL_NOK_swap_region 1
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLSWAPBUFFERSREGIONNOKPROC) (EGLDisplay dpy, EGLSurface surface, EGLint numRects, const EGLint *rects);
@@ -987,6 +1103,11 @@ EGLAPI EGLBoolean EGLAPIENTRY eglSwapBuffersRegion2NOK (EGLDisplay dpy, EGLSurfa
 #define EGL_AUTO_STEREO_NV                0x3136
 #endif /* EGL_NV_3dvision_surface */
 
+#ifndef EGL_NV_context_priority_realtime
+#define EGL_NV_context_priority_realtime 1
+#define EGL_CONTEXT_PRIORITY_REALTIME_NV  0x3357
+#endif /* EGL_NV_context_priority_realtime */
+
 #ifndef EGL_NV_coverage_sample
 #define EGL_NV_coverage_sample 1
 #define EGL_COVERAGE_BUFFERS_NV           0x30E0
@@ -1044,19 +1165,42 @@ EGLAPI EGLBoolean EGLAPIENTRY eglPostSubBufferNV (EGLDisplay dpy, EGLSurface sur
 #endif
 #endif /* EGL_NV_post_sub_buffer */
 
+#ifndef EGL_NV_quadruple_buffer
+#define EGL_NV_quadruple_buffer 1
+#define EGL_QUADRUPLE_BUFFER_NV           0x3231
+#endif /* EGL_NV_quadruple_buffer */
+
 #ifndef EGL_NV_robustness_video_memory_purge
 #define EGL_NV_robustness_video_memory_purge 1
 #define EGL_GENERATE_RESET_ON_VIDEO_MEMORY_PURGE_NV 0x334C
 #endif /* EGL_NV_robustness_video_memory_purge */
 
+#ifndef EGL_NV_stream_consumer_eglimage
+#define EGL_NV_stream_consumer_eglimage 1
+#define EGL_STREAM_CONSUMER_IMAGE_NV      0x3373
+#define EGL_STREAM_IMAGE_ADD_NV           0x3374
+#define EGL_STREAM_IMAGE_REMOVE_NV        0x3375
+#define EGL_STREAM_IMAGE_AVAILABLE_NV     0x3376
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMIMAGECONSUMERCONNECTNVPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLint num_modifiers, EGLuint64KHR *modifiers, EGLAttrib *attrib_list);
+typedef EGLint (EGLAPIENTRYP PFNEGLQUERYSTREAMCONSUMEREVENTNVPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLTime timeout, EGLenum *event, EGLAttrib *aux);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMACQUIREIMAGENVPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLImage *pImage, EGLSync sync);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMRELEASEIMAGENVPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLImage image, EGLSync sync);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglStreamImageConsumerConnectNV (EGLDisplay dpy, EGLStreamKHR stream, EGLint num_modifiers, EGLuint64KHR *modifiers, EGLAttrib *attrib_list);
+EGLAPI EGLint EGLAPIENTRY eglQueryStreamConsumerEventNV (EGLDisplay dpy, EGLStreamKHR stream, EGLTime timeout, EGLenum *event, EGLAttrib *aux);
+EGLAPI EGLBoolean EGLAPIENTRY eglStreamAcquireImageNV (EGLDisplay dpy, EGLStreamKHR stream, EGLImage *pImage, EGLSync sync);
+EGLAPI EGLBoolean EGLAPIENTRY eglStreamReleaseImageNV (EGLDisplay dpy, EGLStreamKHR stream, EGLImage image, EGLSync sync);
+#endif
+#endif /* EGL_NV_stream_consumer_eglimage */
+
 #ifndef EGL_NV_stream_consumer_gltexture_yuv
 #define EGL_NV_stream_consumer_gltexture_yuv 1
 #define EGL_YUV_PLANE0_TEXTURE_UNIT_NV    0x332C
 #define EGL_YUV_PLANE1_TEXTURE_UNIT_NV    0x332D
 #define EGL_YUV_PLANE2_TEXTURE_UNIT_NV    0x332E
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALATTRIBSNVPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLAttrib *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALATTRIBSNVPROC) (EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib *attrib_list);
 #ifdef EGL_EGLEXT_PROTOTYPES
-EGLAPI EGLBoolean EGLAPIENTRY eglStreamConsumerGLTextureExternalAttribsNV (EGLDisplay dpy, EGLStreamKHR stream, EGLAttrib *attrib_list);
+EGLAPI EGLBoolean EGLAPIENTRY eglStreamConsumerGLTextureExternalAttribsNV (EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib *attrib_list);
 #endif
 #endif /* EGL_NV_stream_consumer_gltexture_yuv */
 
@@ -1085,6 +1229,12 @@ EGLAPI EGLBoolean EGLAPIENTRY eglStreamConsumerGLTextureExternalAttribsNV (EGLDi
 #define EGL_STREAM_CROSS_SYSTEM_NV        0x334F
 #endif /* EGL_NV_stream_cross_system */
 
+#ifndef EGL_NV_stream_dma
+#define EGL_NV_stream_dma 1
+#define EGL_STREAM_DMA_NV                 0x3371
+#define EGL_STREAM_DMA_SERVER_NV          0x3372
+#endif /* EGL_NV_stream_dma */
+
 #ifndef EGL_NV_stream_fifo_next
 #define EGL_NV_stream_fifo_next 1
 #define EGL_PENDING_FRAME_NV              0x3329
@@ -1096,6 +1246,14 @@ EGLAPI EGLBoolean EGLAPIENTRY eglStreamConsumerGLTextureExternalAttribsNV (EGLDi
 #define EGL_STREAM_FIFO_SYNCHRONOUS_NV    0x3336
 #endif /* EGL_NV_stream_fifo_synchronous */
 
+#ifndef EGL_NV_stream_flush
+#define EGL_NV_stream_flush 1
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMFLUSHNVPROC) (EGLDisplay dpy, EGLStreamKHR stream);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglStreamFlushNV (EGLDisplay dpy, EGLStreamKHR stream);
+#endif
+#endif /* EGL_NV_stream_flush */
+
 #ifndef EGL_NV_stream_frame_limits
 #define EGL_NV_stream_frame_limits 1
 #define EGL_PRODUCER_MAX_FRAME_HINT_NV    0x3337
@@ -1128,6 +1286,21 @@ EGLAPI EGLBoolean EGLAPIENTRY eglQueryStreamMetadataNV (EGLDisplay dpy, EGLStrea
 #endif
 #endif /* EGL_NV_stream_metadata */
 
+#ifndef EGL_NV_stream_origin
+#define EGL_NV_stream_origin 1
+#define EGL_STREAM_FRAME_ORIGIN_X_NV      0x3366
+#define EGL_STREAM_FRAME_ORIGIN_Y_NV      0x3367
+#define EGL_STREAM_FRAME_MAJOR_AXIS_NV    0x3368
+#define EGL_CONSUMER_AUTO_ORIENTATION_NV  0x3369
+#define EGL_PRODUCER_AUTO_ORIENTATION_NV  0x336A
+#define EGL_LEFT_NV                       0x336B
+#define EGL_RIGHT_NV                      0x336C
+#define EGL_TOP_NV                        0x336D
+#define EGL_BOTTOM_NV                     0x336E
+#define EGL_X_AXIS_NV                     0x336F
+#define EGL_Y_AXIS_NV                     0x3370
+#endif /* EGL_NV_stream_origin */
+
 #ifndef EGL_NV_stream_remote
 #define EGL_NV_stream_remote 1
 #define EGL_STREAM_STATE_INITIALIZING_NV  0x3240
@@ -1224,6 +1397,11 @@ EGLAPI EGLuint64NV EGLAPIENTRY eglGetSystemTimeNV (void);
 #endif /* KHRONOS_SUPPORT_INT64 */
 #endif /* EGL_NV_system_time */
 
+#ifndef EGL_NV_triple_buffer
+#define EGL_NV_triple_buffer 1
+#define EGL_TRIPLE_BUFFER_NV              0x3230
+#endif /* EGL_NV_triple_buffer */
+
 #ifndef EGL_TIZEN_image_native_buffer
 #define EGL_TIZEN_image_native_buffer 1
 #define EGL_NATIVE_BUFFER_TIZEN           0x32A0
@@ -1234,6 +1412,40 @@ EGLAPI EGLuint64NV EGLAPIENTRY eglGetSystemTimeNV (void);
 #define EGL_NATIVE_SURFACE_TIZEN          0x32A1
 #endif /* EGL_TIZEN_image_native_surface */
 
+#ifndef EGL_WL_bind_wayland_display
+#define EGL_WL_bind_wayland_display 1
+#define PFNEGLBINDWAYLANDDISPLAYWL PFNEGLBINDWAYLANDDISPLAYWLPROC
+#define PFNEGLUNBINDWAYLANDDISPLAYWL PFNEGLUNBINDWAYLANDDISPLAYWLPROC
+#define PFNEGLQUERYWAYLANDBUFFERWL PFNEGLQUERYWAYLANDBUFFERWLPROC
+struct wl_display;
+struct wl_resource;
+#define EGL_WAYLAND_BUFFER_WL             0x31D5
+#define EGL_WAYLAND_PLANE_WL              0x31D6
+#define EGL_TEXTURE_Y_U_V_WL              0x31D7
+#define EGL_TEXTURE_Y_UV_WL               0x31D8
+#define EGL_TEXTURE_Y_XUXV_WL             0x31D9
+#define EGL_TEXTURE_EXTERNAL_WL           0x31DA
+#define EGL_WAYLAND_Y_INVERTED_WL         0x31DB
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLBINDWAYLANDDISPLAYWLPROC) (EGLDisplay dpy, struct wl_display *display);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLUNBINDWAYLANDDISPLAYWLPROC) (EGLDisplay dpy, struct wl_display *display);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYWAYLANDBUFFERWLPROC) (EGLDisplay dpy, struct wl_resource *buffer, EGLint attribute, EGLint *value);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglBindWaylandDisplayWL (EGLDisplay dpy, struct wl_display *display);
+EGLAPI EGLBoolean EGLAPIENTRY eglUnbindWaylandDisplayWL (EGLDisplay dpy, struct wl_display *display);
+EGLAPI EGLBoolean EGLAPIENTRY eglQueryWaylandBufferWL (EGLDisplay dpy, struct wl_resource *buffer, EGLint attribute, EGLint *value);
+#endif
+#endif /* EGL_WL_bind_wayland_display */
+
+#ifndef EGL_WL_create_wayland_buffer_from_image
+#define EGL_WL_create_wayland_buffer_from_image 1
+#define PFNEGLCREATEWAYLANDBUFFERFROMIMAGEWL PFNEGLCREATEWAYLANDBUFFERFROMIMAGEWLPROC
+struct wl_buffer;
+typedef struct wl_buffer *(EGLAPIENTRYP PFNEGLCREATEWAYLANDBUFFERFROMIMAGEWLPROC) (EGLDisplay dpy, EGLImageKHR image);
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI struct wl_buffer *EGLAPIENTRY eglCreateWaylandBufferFromImageWL (EGLDisplay dpy, EGLImageKHR image);
+#endif
+#endif /* EGL_WL_create_wayland_buffer_from_image */
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/Engine/lib/sdl/src/video/khronos/EGL/eglplatform.h b/Engine/lib/sdl/src/video/khronos/EGL/eglplatform.h
index c77c3338d..99362a23d 100644
--- a/Engine/lib/sdl/src/video/khronos/EGL/eglplatform.h
+++ b/Engine/lib/sdl/src/video/khronos/EGL/eglplatform.h
@@ -2,36 +2,17 @@
 #define __eglplatform_h_
 
 /*
-** Copyright (c) 2007-2016 The Khronos Group Inc.
-**
-** Permission is hereby granted, free of charge, to any person obtaining a
-** copy of this software and/or associated documentation files (the
-** "Materials"), to deal in the Materials without restriction, including
-** without limitation the rights to use, copy, modify, merge, publish,
-** distribute, sublicense, and/or sell copies of the Materials, and to
-** permit persons to whom the Materials are furnished to do so, subject to
-** the following conditions:
-**
-** The above copyright notice and this permission notice shall be included
-** in all copies or substantial portions of the Materials.
-**
-** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+** Copyright 2007-2020 The Khronos Group Inc.
+** SPDX-License-Identifier: Apache-2.0
 */
 
 /* Platform-specific types and definitions for egl.h
- * $Revision: 30994 $ on $Date: 2015-04-30 13:36:48 -0700 (Thu, 30 Apr 2015) $
  *
  * Adopters may modify khrplatform.h and this file to suit their platform.
  * You are encouraged to submit all modifications to the Khronos group so that
  * they can be included in future versions of this file.  Please submit changes
- * by sending them to the public Khronos Bugzilla (http://khronos.org/bugzilla)
- * by filing a bug against product "EGL" component "Registry".
+ * by filing an issue or pull request on the public Khronos EGL Registry, at
+ * https://www.github.com/KhronosGroup/EGL-Registry/
  */
 
 #include <KHR/khrplatform.h>
@@ -67,7 +48,13 @@
  * implementations.
  */
 
-#if defined(_WIN32) || defined(__VC32__) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) /* Win32 and WinCE */
+#if defined(EGL_NO_PLATFORM_SPECIFIC_TYPES)
+
+typedef void *EGLNativeDisplayType;
+typedef void *EGLNativePixmapType;
+typedef void *EGLNativeWindowType;
+
+#elif defined(_WIN32) || defined(__VC32__) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) /* Win32 and WinCE */
 #ifndef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN 1
 #endif
@@ -77,22 +64,46 @@ typedef HDC     EGLNativeDisplayType;
 typedef HBITMAP EGLNativePixmapType;
 typedef HWND    EGLNativeWindowType;
 
-#elif defined(__APPLE__) || defined(__WINSCW__) || defined(__SYMBIAN32__)  /* Symbian */
+#elif defined(__EMSCRIPTEN__)
+
+typedef int EGLNativeDisplayType;
+typedef int EGLNativePixmapType;
+typedef int EGLNativeWindowType;
+
+#elif defined(__WINSCW__) || defined(__SYMBIAN32__)  /* Symbian */
 
 typedef int   EGLNativeDisplayType;
-typedef void *EGLNativeWindowType;
 typedef void *EGLNativePixmapType;
+typedef void *EGLNativeWindowType;
+
+#elif defined(WL_EGL_PLATFORM)
+
+typedef struct wl_display     *EGLNativeDisplayType;
+typedef struct wl_egl_pixmap  *EGLNativePixmapType;
+typedef struct wl_egl_window  *EGLNativeWindowType;
+
+#elif defined(__GBM__)
+
+typedef struct gbm_device  *EGLNativeDisplayType;
+typedef struct gbm_bo      *EGLNativePixmapType;
+typedef void               *EGLNativeWindowType;
 
 #elif defined(__ANDROID__) || defined(ANDROID)
 
 struct ANativeWindow;
 struct egl_native_pixmap_t;
 
-typedef struct ANativeWindow*           EGLNativeWindowType;
-typedef struct egl_native_pixmap_t*     EGLNativePixmapType;
 typedef void*                           EGLNativeDisplayType;
+typedef struct egl_native_pixmap_t*     EGLNativePixmapType;
+typedef struct ANativeWindow*           EGLNativeWindowType;
 
-#elif defined(__unix__)
+#elif defined(USE_OZONE)
+
+typedef intptr_t EGLNativeDisplayType;
+typedef intptr_t EGLNativePixmapType;
+typedef intptr_t EGLNativeWindowType;
+
+#elif defined(USE_X11)
 
 /* X11 (tentative)  */
 #include <X11/Xlib.h>
@@ -102,6 +113,32 @@ typedef Display *EGLNativeDisplayType;
 typedef Pixmap   EGLNativePixmapType;
 typedef Window   EGLNativeWindowType;
 
+#elif defined(__unix__)
+
+typedef void             *EGLNativeDisplayType;
+typedef khronos_uintptr_t EGLNativePixmapType;
+typedef khronos_uintptr_t EGLNativeWindowType;
+
+#elif defined(__APPLE__)
+
+typedef int   EGLNativeDisplayType;
+typedef void *EGLNativePixmapType;
+typedef void *EGLNativeWindowType;
+
+#elif defined(__HAIKU__)
+
+#include <kernel/image.h>
+
+typedef void              *EGLNativeDisplayType;
+typedef khronos_uintptr_t  EGLNativePixmapType;
+typedef khronos_uintptr_t  EGLNativeWindowType;
+
+#elif defined(__Fuchsia__)
+
+typedef void              *EGLNativeDisplayType;
+typedef khronos_uintptr_t  EGLNativePixmapType;
+typedef khronos_uintptr_t  EGLNativeWindowType;
+
 #else
 #error "Platform not recognized"
 #endif
diff --git a/Engine/lib/sdl/src/video/khronos/KHR/khrplatform.h b/Engine/lib/sdl/src/video/khronos/KHR/khrplatform.h
index 1ad3554a7..dd22d9270 100644
--- a/Engine/lib/sdl/src/video/khronos/KHR/khrplatform.h
+++ b/Engine/lib/sdl/src/video/khronos/KHR/khrplatform.h
@@ -2,7 +2,7 @@
 #define __khrplatform_h_
 
 /*
-** Copyright (c) 2008-2009 The Khronos Group Inc.
+** Copyright (c) 2008-2018 The Khronos Group Inc.
 **
 ** Permission is hereby granted, free of charge, to any person obtaining a
 ** copy of this software and/or associated documentation files (the
@@ -26,18 +26,16 @@
 
 /* Khronos platform-specific types and definitions.
  *
- * $Revision: 32517 $ on $Date: 2016-03-11 02:41:19 -0800 (Fri, 11 Mar 2016) $
+ * The master copy of khrplatform.h is maintained in the Khronos EGL
+ * Registry repository at https://github.com/KhronosGroup/EGL-Registry
+ * The last semantic modification to khrplatform.h was at commit ID:
+ *      67a3e0864c2d75ea5287b9f3d2eb74a745936692
  *
  * Adopters may modify this file to suit their platform. Adopters are
  * encouraged to submit platform specific modifications to the Khronos
  * group so that they can be included in future versions of this file.
- * Please submit changes by sending them to the public Khronos Bugzilla
- * (http://khronos.org/bugzilla) by filing a bug against product
- * "Khronos (general)" component "Registry".
- *
- * A predefined template which fills in some of the bug fields can be
- * reached using http://tinyurl.com/khrplatform-h-bugreport, but you
- * must create a Bugzilla login first.
+ * Please submit changes by filing pull requests or issues on
+ * the EGL Registry repository linked above.
  *
  *
  * See the Implementer's Guidelines for information about where this file
@@ -92,12 +90,20 @@
  *                                  int arg2) KHRONOS_APIATTRIBUTES;
  */
 
+#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC)
+#   define KHRONOS_STATIC 1
+#endif
+
 /*-------------------------------------------------------------------------
  * Definition of KHRONOS_APICALL
  *-------------------------------------------------------------------------
  * This precedes the return type of the function in the function prototype.
  */
-#if defined(_WIN32) && !defined(__SCITECH_SNAP__)
+#if defined(KHRONOS_STATIC)
+    /* If the preprocessor constant KHRONOS_STATIC is defined, make the
+     * header compatible with static linking. */
+#   define KHRONOS_APICALL
+#elif defined(_WIN32)
 #   define KHRONOS_APICALL __declspec(dllimport)
 #elif defined (__SYMBIAN32__)
 #   define KHRONOS_APICALL IMPORT_C
diff --git a/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmdyn.c b/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmdyn.c
index 38fc3ab12..bf3ff2e3e 100644
--- a/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmdyn.c
+++ b/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmdyn.c
@@ -1,7 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
-  Atomic KMSDRM backend by Manuel Alfayate Corchete <redwindwanderer@gmail.com>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -28,7 +27,6 @@
 
 #include "SDL_kmsdrmdyn.h"
 
-
 #ifdef SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC
 
 #include "SDL_name.h"
diff --git a/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmdyn.h b/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmdyn.h
index a7b825b3f..65de02e1b 100644
--- a/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmdyn.h
+++ b/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmdyn.h
@@ -1,7 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
-  Atomic KMSDRM backend by Manuel Alfayate Corchete <redwindwanderer@gmail.com>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmevents.c b/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmevents.c
index f2405d4a3..10773a760 100644
--- a/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmevents.c
+++ b/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmevents.c
@@ -1,7 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
-  Atomic KMSDRM backend by Manuel Alfayate Corchete <redwindwanderer@gmail.com>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -29,12 +28,16 @@
 
 #ifdef SDL_INPUT_LINUXEV
 #include "../../core/linux/SDL_evdev.h"
+#elif defined SDL_INPUT_WSCONS
+#include "../../core/openbsd/SDL_wscons.h"
 #endif
 
 void KMSDRM_PumpEvents(_THIS)
 {
 #ifdef SDL_INPUT_LINUXEV
     SDL_EVDEV_Poll();
+#elif defined SDL_INPUT_WSCONS
+    SDL_WSCONS_PumpEvents();
 #endif
 
 }
diff --git a/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmevents.h b/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmevents.h
index 74f90da25..c327f032f 100644
--- a/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmevents.h
+++ b/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmevents.h
@@ -1,7 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
-  Atomic KMSDRM backend by Manuel Alfayate Corchete <redwindwanderer@gmail.com>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmmouse.c b/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmmouse.c
index 26a7dad90..5722e041a 100644
--- a/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmmouse.c
+++ b/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmmouse.c
@@ -1,7 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
-  Atomic KMSDRM backend by Manuel Alfayate Corchete <redwindwanderer@gmail.com>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -27,11 +26,12 @@
 #include "SDL_kmsdrmvideo.h"
 #include "SDL_kmsdrmmouse.h"
 #include "SDL_kmsdrmdyn.h"
-#include "SDL_assert.h"
 
 #include "../../events/SDL_mouse_c.h"
 #include "../../events/default_cursor.h"
 
+#include "../SDL_pixels_c.h"
+
 static SDL_Cursor *KMSDRM_CreateDefaultCursor(void);
 static SDL_Cursor *KMSDRM_CreateCursor(SDL_Surface * surface, int hot_x, int hot_y);
 static int KMSDRM_ShowCursor(SDL_Cursor * cursor);
@@ -40,57 +40,20 @@ static void KMSDRM_FreeCursor(SDL_Cursor * cursor);
 static void KMSDRM_WarpMouse(SDL_Window * window, int x, int y);
 static int KMSDRM_WarpMouseGlobal(int x, int y);
 
-/**********************************/
-/* Atomic helper functions block. */
-/**********************************/
-
-int
-drm_atomic_movecursor(KMSDRM_CursorData *curdata, uint16_t x, uint16_t y)
-{
-    SDL_DisplayData *dispdata = (SDL_DisplayData *)SDL_GetDisplayDriverData(0);
-
-    if (!dispdata->cursor_plane) /* We can't move a non-existing cursor, but that's ok. */
-        return 0;
-
-    /* Do we have a set of changes already in the making? If not, allocate a new one. */
-    if (!dispdata->atomic_req)
-        dispdata->atomic_req = KMSDRM_drmModeAtomicAlloc();
-    
-    add_plane_property(dispdata->atomic_req,
-            dispdata->cursor_plane, "CRTC_X", x - curdata->hot_x);
-    add_plane_property(dispdata->atomic_req,
-            dispdata->cursor_plane, "CRTC_Y", y - curdata->hot_y);
-
-    return 0;
-}
-
-/***************************************/
-/* Atomic helper functions block ends. */
-/***************************************/
-
-/* Converts a pixel from straight-alpha [AA, RR, GG, BB], which the SDL cursor surface has,
-   to premultiplied-alpha [AA. AA*RR, AA*GG, AA*BB].
-   These multiplications have to be done with floats instead of uint32_t's,
-   and the resulting values have to be converted to be relative to the 0-255 interval,
-   where 255 is 1.00 and anything between 0 and 255 is 0.xx. */
-void alpha_premultiply_ARGB8888 (uint32_t *pixel) {
-
-    uint32_t A, R, G, B;
-
-    /* Component bytes extraction. */
-    A = (*pixel >> (3 << 3)) & 0xFF;
-    R = (*pixel >> (2 << 3)) & 0xFF;
-    G = (*pixel >> (1 << 3)) & 0xFF;
-    B = (*pixel >> (0 << 3)) & 0xFF;
-
-    /* Alpha pre-multiplication of each component. */
-    R = (float)A * ((float)R /255);
-    G = (float)A * ((float)G /255);
-    B = (float)A * ((float)B /255);
-
-    /* ARGB8888 pixel recomposition. */
-    (*pixel) = (((uint32_t)A << 24) | ((uint32_t)R << 16) | ((uint32_t)G << 8)) | ((uint32_t)B << 0);
-}
+/**************************************************************************************/
+/* BEFORE CODING ANYTHING MOUSE/CURSOR RELATED, REMEMBER THIS.                        */
+/* How does SDL manage cursors internally? First, mouse =! cursor. The mouse can have */
+/* many cursors in mouse->cursors.                                                    */
+/* -SDL tells us to create a cursor with KMSDRM_CreateCursor(). It can create many    */
+/*  cursosr with this, not only one.                                                  */
+/* -SDL stores those cursors in a cursors array, in mouse->cursors.                   */
+/* -Whenever it wants (or the programmer wants) takes a cursor from that array        */
+/*  and shows it on screen with KMSDRM_ShowCursor().                                  */
+/*  KMSDRM_ShowCursor() simply shows or hides the cursor it receives: it does NOT     */
+/*  mind if it's mouse->cur_cursor, etc.                                              */
+/* -If KMSDRM_ShowCursor() returns succesfully, that cursor becomes mouse->cur_cursor */
+/*  and mouse->cursor_shown is 1.                                                     */
+/**************************************************************************************/
 
 static SDL_Cursor *
 KMSDRM_CreateDefaultCursor(void)
@@ -98,208 +61,123 @@ KMSDRM_CreateDefaultCursor(void)
     return SDL_CreateCursor(default_cdata, default_cmask, DEFAULT_CWIDTH, DEFAULT_CHEIGHT, DEFAULT_CHOTX, DEFAULT_CHOTY);
 }
 
-/* This simply gets the cursor soft-buffer ready. We don't copy it to a GBO BO until ShowCursor()
-   because the cusor GBM BO (living in dispata) is destroyed and recreated when we recreate windows, etc. */
-static SDL_Cursor *
-KMSDRM_CreateCursor(SDL_Surface * surface, int hot_x, int hot_y)
+/* Given a display's driverdata, destroy the cursor BO for it.
+   To be called from KMSDRM_DestroyWindow(), as that's where we
+   destroy the driverdata for the window's display. */
+void
+KMSDRM_DestroyCursorBO (_THIS, SDL_VideoDisplay *display)
 {
-    KMSDRM_CursorData *curdata;
-    SDL_Cursor *cursor, *ret;
-
-    curdata = NULL;
-    ret = NULL;
-
-    /* All code below assumes ARGB8888 format for the cursor surface,
-       like other backends do. Also, the GBM BO pixels have to be
-       alpha-premultiplied, but the SDL surface we receive has
-       straight-alpha pixels, so we always have to convert. */ 
-    SDL_assert(surface->format->format == SDL_PIXELFORMAT_ARGB8888);
-    SDL_assert(surface->pitch == surface->w * 4);
-
-    cursor = (SDL_Cursor *) SDL_calloc(1, sizeof(*cursor));
-    if (!cursor) {
-        SDL_OutOfMemory();
-        goto cleanup;
+    SDL_DisplayData *dispdata = (SDL_DisplayData *) display->driverdata;
+   
+    /* Destroy the curso GBM BO. */
+    if (dispdata->cursor_bo) {
+        KMSDRM_gbm_bo_destroy(dispdata->cursor_bo);
+        dispdata->cursor_bo = NULL;
+        dispdata->cursor_bo_drm_fd = -1;
     }
-    curdata = (KMSDRM_CursorData *) SDL_calloc(1, sizeof(*curdata));
-    if (!curdata) {
-        SDL_OutOfMemory();
-        goto cleanup;
+}
+
+/* Given a display's driverdata, create the cursor BO for it.
+   To be called from KMSDRM_CreateWindow(), as that's where we
+   build a window and assign a display to it. */
+void
+KMSDRM_CreateCursorBO (SDL_VideoDisplay *display) {
+
+    SDL_VideoDevice *dev = SDL_GetVideoDevice();
+    SDL_VideoData *viddata = ((SDL_VideoData *)dev->driverdata);
+    SDL_DisplayData *dispdata = (SDL_DisplayData *) display->driverdata;
+
+    if (!KMSDRM_gbm_device_is_format_supported(viddata->gbm_dev,
+          GBM_FORMAT_ARGB8888,
+          GBM_BO_USE_CURSOR | GBM_BO_USE_WRITE))
+    {
+        SDL_SetError("Unsupported pixel format for cursor");
+        return;
     }
 
-    /* hox_x and hot_y are the coordinates of the "tip of the cursor" from it's base. */
-    curdata->hot_x = hot_x;
-    curdata->hot_y = hot_y;
-    curdata->w = surface->w;
-    curdata->h = surface->h;
-    curdata->buffer = NULL;
-
-    /* Configure the cursor buffer info.
-       This buffer has the original size of the cursor surface we are given. */
-    curdata->buffer_pitch = surface->pitch;
-    curdata->buffer_size = surface->pitch * surface->h;
-    curdata->buffer = (uint32_t*)SDL_malloc(curdata->buffer_size);
-
-    if (!curdata->buffer) {
-        SDL_OutOfMemory();
-        goto cleanup;
+    if (KMSDRM_drmGetCap(viddata->drm_fd,
+          DRM_CAP_CURSOR_WIDTH,  &dispdata->cursor_w) ||
+          KMSDRM_drmGetCap(viddata->drm_fd, DRM_CAP_CURSOR_HEIGHT,
+          &dispdata->cursor_h))
+    {
+        SDL_SetError("Could not get the recommended GBM cursor size");
+        return;
     }
 
-    if (SDL_MUSTLOCK(surface)) {
-        if (SDL_LockSurface(surface) < 0) {
-            /* Could not lock surface */
-            goto cleanup;
-        }
+    if (dispdata->cursor_w == 0 || dispdata->cursor_h == 0) {
+        SDL_SetError("Could not get an usable GBM cursor size");
+        return;
     }
 
-    /* Copy the surface pixels to the cursor buffer, for future use in ShowCursor() */
-    SDL_memcpy(curdata->buffer, surface->pixels, curdata->buffer_size);
+    dispdata->cursor_bo = KMSDRM_gbm_bo_create(viddata->gbm_dev,
+        dispdata->cursor_w, dispdata->cursor_h,
+        GBM_FORMAT_ARGB8888, GBM_BO_USE_CURSOR | GBM_BO_USE_WRITE | GBM_BO_USE_LINEAR);
 
-    if (SDL_MUSTLOCK(surface)) {
-        SDL_UnlockSurface(surface);
+    if (!dispdata->cursor_bo) {
+        SDL_SetError("Could not create GBM cursor BO");
+        return;
     }
 
-    cursor->driverdata = curdata;
+    dispdata->cursor_bo_drm_fd = viddata->drm_fd;
+} 
 
-    ret = cursor;
+/* Remove a cursor buffer from a display's DRM cursor BO. */
+static int
+KMSDRM_RemoveCursorFromBO(SDL_VideoDisplay *display)
+{
+    int ret = 0;
+    SDL_DisplayData *dispdata = (SDL_DisplayData *) display->driverdata;
+    SDL_VideoDevice *video_device = SDL_GetVideoDevice();
+    SDL_VideoData *viddata = ((SDL_VideoData *)video_device->driverdata);
 
-cleanup:
-    if (ret == NULL) {
-	if (curdata) {
-	    if (curdata->buffer) {
-		SDL_free(curdata->buffer);
-	    }
-	    SDL_free(curdata);
-	}
-	if (cursor) {
-	    SDL_free(cursor);
-	}
+    ret = KMSDRM_drmModeSetCursor(viddata->drm_fd,
+        dispdata->crtc->crtc_id, 0, 0, 0);
+
+    if (ret) {
+        ret = SDL_SetError("Could not hide current cursor with drmModeSetCursor().");
     }
 
     return ret;
 }
 
-/* When we create a window, we have to test if we have to show the cursor,
-   and explicily do so if necessary.
-   This is because when we destroy a window, we take the cursor away from the
-   cursor plane, and destroy the cusror GBM BO. So we have to re-show it,
-   so to say. */
-void
-KMSDRM_InitCursor()
-{
-    SDL_Mouse *mouse = NULL;
-    mouse = SDL_GetMouse();
-
-    if (!mouse) {
-        return;
-    }
-    if  (!(mouse->cur_cursor)) {
-        return;
-    }
-
-    if  (!(mouse->cursor_shown)) {
-        return;
-    }
-
-    KMSDRM_ShowCursor(mouse->cur_cursor);
-}
-
-/* Show the specified cursor, or hide if cursor is NULL.
-   cur_cursor is the current cursor, and cursor is the new cursor.
-   A cursor is displayed on a display, so we have to add a pointer to dispdata
-   to the driverdata 
- */
+/* Dump a cursor buffer to a display's DRM cursor BO.  */
 static int
-KMSDRM_ShowCursor(SDL_Cursor * cursor)
+KMSDRM_DumpCursorToBO(SDL_VideoDisplay *display, SDL_Cursor *cursor)
 {
+    SDL_DisplayData *dispdata = (SDL_DisplayData *) display->driverdata;
+    KMSDRM_CursorData *curdata = (KMSDRM_CursorData *) cursor->driverdata;
     SDL_VideoDevice *video_device = SDL_GetVideoDevice();
-    //SDL_VideoData *viddata = ((SDL_VideoData *)dev->driverdata);
-    SDL_Mouse *mouse;
-    KMSDRM_CursorData *curdata;
-    SDL_VideoDisplay *display = NULL;
-    SDL_DisplayData *dispdata = NULL;
-    KMSDRM_FBInfo *fb;
-    KMSDRM_PlaneInfo info = {0};
+    SDL_VideoData *viddata = ((SDL_VideoData *)video_device->driverdata);
 
+    uint32_t bo_handle;
     size_t bo_stride;
     size_t bufsize;
-    uint32_t *ready_buffer = NULL;
-    uint32_t pixel;
+    uint8_t *ready_buffer = NULL;
+    uint8_t *src_row;
 
-    int i,j;
+    int i;
     int ret;
 
-    mouse = SDL_GetMouse();
-    if (!mouse) {
-        return SDL_SetError("No mouse.");
-    }
-
-    if (mouse->focus) {
-        display = SDL_GetDisplayForWindow(mouse->focus);
-        if (display) {
-            dispdata = (SDL_DisplayData*) display->driverdata;
-        }
-    }
-
-    /**********************************/
-    /* if cursor == NULL, HIDE cursor */
-    /**********************************/
-    if (!cursor) {
-        /* Hide CURRENT cursor, a cursor that is already on screen
-           and SDL is stored in mouse->cur_cursor. */
-        if (mouse->cur_cursor && mouse->cur_cursor->driverdata) {
-            if (dispdata && dispdata->cursor_plane) {
-                info.plane = dispdata->cursor_plane;
-                /* The rest of the members are zeroed. */
-                drm_atomic_set_plane_props(&info);
-                if (drm_atomic_commit(display->device, SDL_TRUE))
-                    return SDL_SetError("Failed atomic commit in KMSDRM_ShowCursor.");
-                }
-                return 0;
-            }
-        return SDL_SetError("Couldn't find cursor to hide.");
-    }
-
-    /************************************************/
-    /* If cursor != NULL, DO show cursor on display */
-    /************************************************/
-    if (!display) {
-        return SDL_SetError("Could not get display for mouse.");
-    }
-    if (!dispdata) {
-        return SDL_SetError("Could not get display driverdata.");
-    }
-    if (!dispdata->cursor_plane) {
-        return SDL_SetError("Hardware cursor plane not initialized.");
-    }
-    
-    curdata = (KMSDRM_CursorData *) cursor->driverdata;
-
     if (!curdata || !dispdata->cursor_bo) {
-        return SDL_SetError("Cursor not initialized properly.");
+        return SDL_SetError("Cursor or display not initialized properly.");
     }
 
-    /* Prepare a buffer we can dump to our GBM BO (different size, alpha premultiplication...) */
+    /* Prepare a buffer we can dump to our GBM BO (different
+       size, alpha premultiplication...) */
     bo_stride = KMSDRM_gbm_bo_get_stride(dispdata->cursor_bo);
-    bufsize = bo_stride * curdata->h;
+    bufsize = bo_stride * dispdata->cursor_h;
+
+    ready_buffer = (uint8_t*)SDL_calloc(1, bufsize);
 
-    ready_buffer = (uint32_t*)SDL_malloc(bufsize);
     if (!ready_buffer) {
         ret = SDL_OutOfMemory();
         goto cleanup;
     }
 
-    /* Clean the whole buffer we are preparing. */
-    SDL_memset(ready_buffer, 0x00, bo_stride * curdata->h);
-
-    /* Copy from the cursor buffer to a buffer that we can dump to the GBM BO,
-       pre-multiplying by alpha each pixel as we go. */
+    /* Copy from the cursor buffer to a buffer that we can dump to the GBM BO. */
     for (i = 0; i < curdata->h; i++) {
-        for (j = 0; j < curdata->w; j++) {
-            pixel = ((uint32_t*)curdata->buffer)[i * curdata->w + j];
-            alpha_premultiply_ARGB8888 (&pixel);
-            SDL_memcpy(ready_buffer + (i * dispdata->cursor_w) + j, &pixel, 4);
-        }
+        src_row = &((uint8_t*)curdata->buffer)[i * curdata->w * 4];
+        SDL_memcpy(ready_buffer + (i * bo_stride), src_row, 4 * curdata->w);
     }
 
     /* Dump the cursor buffer to our GBM BO. */
@@ -308,28 +186,25 @@ KMSDRM_ShowCursor(SDL_Cursor * cursor)
         goto cleanup;
     }
 
-    /* Get the fb_id for the GBM BO so we can show it on the cursor plane. */
-    fb = KMSDRM_FBFromBO(video_device, dispdata->cursor_bo);
+    /* Put the GBM BO buffer on screen using the DRM interface. */
+    bo_handle = KMSDRM_gbm_bo_get_handle(dispdata->cursor_bo).u32;
+    if (curdata->hot_x == 0 && curdata->hot_y == 0) {
+        ret = KMSDRM_drmModeSetCursor(viddata->drm_fd, dispdata->crtc->crtc_id,
+            bo_handle, dispdata->cursor_w, dispdata->cursor_h);
+    } else {
+        ret = KMSDRM_drmModeSetCursor2(viddata->drm_fd, dispdata->crtc->crtc_id,
+            bo_handle, dispdata->cursor_w, dispdata->cursor_h, curdata->hot_x, curdata->hot_y);
+    }
 
-    /* Show the GBM BO buffer on the cursor plane. */
-    info.plane = dispdata->cursor_plane;
-    info.crtc_id = dispdata->crtc->crtc->crtc_id;
-    info.fb_id = fb->fb_id; 
-    info.src_w = curdata->w;
-    info.src_h = curdata->h;
-    info.crtc_x = mouse->x - curdata->hot_x;
-    info.crtc_y = mouse->y - curdata->hot_y;
-    info.crtc_w = curdata->w;
-    info.crtc_h = curdata->h; 
-
-    drm_atomic_set_plane_props(&info);
-
-    if (drm_atomic_commit(display->device, SDL_TRUE)) {
-        ret = SDL_SetError("Failed atomic commit in KMSDRM_ShowCursor.");
+    if (ret) {
+        ret = SDL_SetError("Failed to set DRM cursor.");
         goto cleanup;
     }
 
-    ret = 0;
+    if (ret) {
+        ret = SDL_SetError("Failed to reset cursor position.");
+        goto cleanup;
+    }
 
 cleanup:
 
@@ -339,8 +214,7 @@ cleanup:
     return ret;
 }
 
-/* We have destroyed the cursor by now, in KMSDRM_DestroyCursor.
-   This is only for freeing the SDL_cursor.*/
+/* This is only for freeing the SDL_cursor.*/
 static void
 KMSDRM_FreeCursor(SDL_Cursor * cursor)
 {
@@ -362,6 +236,133 @@ KMSDRM_FreeCursor(SDL_Cursor * cursor)
     }
 }
 
+/* This simply gets the cursor soft-buffer ready.
+   We don't copy it to a GBO BO until ShowCursor() because the cusor GBM BO (living
+   in dispata) is destroyed and recreated when we recreate windows, etc. */
+static SDL_Cursor *
+KMSDRM_CreateCursor(SDL_Surface * surface, int hot_x, int hot_y)
+{
+    KMSDRM_CursorData *curdata;
+    SDL_Cursor *cursor, *ret;
+
+    curdata = NULL;
+    ret = NULL;
+
+    cursor = (SDL_Cursor *) SDL_calloc(1, sizeof(*cursor));
+    if (!cursor) {
+        SDL_OutOfMemory();
+        goto cleanup;
+    }
+    curdata = (KMSDRM_CursorData *) SDL_calloc(1, sizeof(*curdata));
+    if (!curdata) {
+        SDL_OutOfMemory();
+        goto cleanup;
+    }
+
+    /* hox_x and hot_y are the coordinates of the "tip of the cursor" from it's base. */
+    curdata->hot_x = hot_x;
+    curdata->hot_y = hot_y;
+    curdata->w = surface->w;
+    curdata->h = surface->h;
+    curdata->buffer = NULL;
+
+    /* Configure the cursor buffer info.
+       This buffer has the original size of the cursor surface we are given. */
+    curdata->buffer_pitch = surface->w;
+    curdata->buffer_size = surface->w * surface->h * 4;
+    curdata->buffer = (uint32_t*)SDL_malloc(curdata->buffer_size);
+
+    if (!curdata->buffer) {
+        SDL_OutOfMemory();
+        goto cleanup;
+    }
+
+    /* All code below assumes ARGB8888 format for the cursor surface,
+       like other backends do. Also, the GBM BO pixels have to be
+       alpha-premultiplied, but the SDL surface we receive has
+       straight-alpha pixels, so we always have to convert. */ 
+    SDL_PremultiplyAlpha(surface->w, surface->h,
+                         surface->format->format, surface->pixels, surface->pitch,
+                         SDL_PIXELFORMAT_ARGB8888, curdata->buffer, surface->w * 4);
+
+    cursor->driverdata = curdata;
+
+    ret = cursor;
+
+cleanup:
+    if (ret == NULL) {
+        if (curdata) {
+            if (curdata->buffer) {
+                SDL_free(curdata->buffer);
+            }
+            SDL_free(curdata);
+        }
+        if (cursor) {
+            SDL_free(cursor);
+        }
+    }
+
+    return ret;
+}
+
+/* Show the specified cursor, or hide if cursor is NULL or has no focus. */
+static int
+KMSDRM_ShowCursor(SDL_Cursor * cursor)
+{
+    SDL_VideoDisplay *display;
+    SDL_Window *window;
+    SDL_Mouse *mouse;
+
+    int num_displays, i;
+    int ret = 0;
+
+    /* Get the mouse focused window, if any. */
+
+    mouse = SDL_GetMouse();
+    if (!mouse) {
+        return SDL_SetError("No mouse.");
+    }
+
+    window = mouse->focus;
+
+    if (!window || !cursor) {
+
+            /* If no window is focused by mouse or cursor is NULL,
+               since we have no window (no mouse->focus) and hence
+               we have no display, we simply hide mouse on all displays.
+               This happens on video quit, where we get here after
+               the mouse focus has been unset, yet SDL wants to
+               restore the system default cursor (makes no sense here). */
+
+            num_displays = SDL_GetNumVideoDisplays();
+
+            /* Iterate on the displays hidding the cursor. */
+            for (i = 0; i < num_displays; i++) {
+                display = SDL_GetDisplay(i);
+                ret = KMSDRM_RemoveCursorFromBO(display);
+            }
+
+    } else {
+
+        display = SDL_GetDisplayForWindow(window);
+
+        if (display) {
+
+            if (cursor) {
+                /* Dump the cursor to the display DRM cursor BO so it becomes visible
+                   on that display. */
+                ret = KMSDRM_DumpCursorToBO(display, cursor);
+
+            } else {
+                /* Hide the cursor on that display. */
+                ret = KMSDRM_RemoveCursorFromBO(display);
+            }
+         }
+    }
+
+    return ret;
+}
+
 /* Warp the mouse to (x,y) */
 static void
 KMSDRM_WarpMouse(SDL_Window * window, int x, int y)
@@ -374,42 +375,42 @@ KMSDRM_WarpMouse(SDL_Window * window, int x, int y)
 static int
 KMSDRM_WarpMouseGlobal(int x, int y)
 {
-    KMSDRM_CursorData *curdata;
     SDL_Mouse *mouse = SDL_GetMouse();
-    SDL_DisplayData *dispdata = (SDL_DisplayData *)SDL_GetDisplayDriverData(0);
 
-    if (mouse && mouse->cur_cursor && mouse->cur_cursor->driverdata) {
+    if (mouse && mouse->cur_cursor && mouse->focus) {
+
+        SDL_Window *window = mouse->focus;
+        SDL_DisplayData *dispdata = (SDL_DisplayData *) SDL_GetDisplayForWindow(window)->driverdata;
+
         /* Update internal mouse position. */
         SDL_SendMouseMotion(mouse->focus, mouse->mouseID, 0, x, y);
 
         /* And now update the cursor graphic position on screen. */
-        curdata = (KMSDRM_CursorData *) mouse->cur_cursor->driverdata;
         if (dispdata->cursor_bo) {
-            if (drm_atomic_movecursor(curdata, x, y)) {
-                return SDL_SetError("drm_atomic_movecursor() failed.");
+            int ret = 0;
+
+            ret = KMSDRM_drmModeMoveCursor(dispdata->cursor_bo_drm_fd, dispdata->crtc->crtc_id, x, y);
+
+            if (ret) {
+                SDL_SetError("drmModeMoveCursor() failed.");
             }
+
+            return ret;
+
         } else {
             return SDL_SetError("Cursor not initialized properly.");
         }
+
     } else {
         return SDL_SetError("No mouse or current cursor.");
     }
-
-    return 0;
 }
 
 void
-KMSDRM_InitMouse(_THIS)
+KMSDRM_InitMouse(_THIS, SDL_VideoDisplay *display)
 {
-    /* FIXME: Using UDEV it should be possible to scan all mice
-     * but there's no point in doing so as there's no multimice support...yet!
-     */
-
-    SDL_VideoDevice *dev = SDL_GetVideoDevice();
-    SDL_VideoData *viddata = ((SDL_VideoData *)dev->driverdata);
-    SDL_DisplayData *dispdata = (SDL_DisplayData *)SDL_GetDisplayDriverData(0);
     SDL_Mouse *mouse = SDL_GetMouse();
-    uint64_t usable_cursor_w, usable_cursor_h;
+    SDL_DisplayData *dispdata = (SDL_DisplayData *) display->driverdata;
 
     mouse->CreateCursor = KMSDRM_CreateCursor;
     mouse->ShowCursor = KMSDRM_ShowCursor;
@@ -418,96 +419,18 @@ KMSDRM_InitMouse(_THIS)
     mouse->WarpMouse = KMSDRM_WarpMouse;
     mouse->WarpMouseGlobal = KMSDRM_WarpMouseGlobal;
 
-    /***************************************************************************/
-    /* REMEMBER TO BE SURE OF UNDOING ALL THESE STEPS PROPERLY BEFORE CALLING  */
-    /* gbm_device_destroy, OR YOU WON'T BE ABLE TO CREATE A NEW ONE (ERROR -13 */
-    /* ON gbm_create_device).                                                  */
-    /***************************************************************************/
-
-    /* 1- Init cursor plane, if we haven't yet. */
-    if (!dispdata->cursor_plane) {
-        setup_plane(_this, &(dispdata->cursor_plane), DRM_PLANE_TYPE_CURSOR);
-    }
-
-    /* 2- Create the cursor GBM BO, if we haven't yet. */
-    if (!dispdata->cursor_bo) {
-
-        if (!KMSDRM_gbm_device_is_format_supported(viddata->gbm_dev, GBM_FORMAT_ARGB8888,
-                                               GBM_BO_USE_CURSOR | GBM_BO_USE_WRITE))
-        {
-            SDL_SetError("Unsupported pixel format for cursor");
-            return;
-        }
-
-	if (KMSDRM_drmGetCap(viddata->drm_fd, DRM_CAP_CURSOR_WIDTH,  &usable_cursor_w) ||
-	    KMSDRM_drmGetCap(viddata->drm_fd, DRM_CAP_CURSOR_HEIGHT, &usable_cursor_h))
-	{
-	    SDL_SetError("Could not get the recommended GBM cursor size");
-	    goto cleanup;
-	}
-
-	if (usable_cursor_w == 0 || usable_cursor_h == 0) {
-	    SDL_SetError("Could not get an usable GBM cursor size");
-	    goto cleanup;
-	}
-
-        dispdata->cursor_w = usable_cursor_w;
-        dispdata->cursor_h = usable_cursor_h;
-
-	dispdata->cursor_bo = KMSDRM_gbm_bo_create(viddata->gbm_dev,
-	    usable_cursor_w, usable_cursor_h,
-	    GBM_FORMAT_ARGB8888, GBM_BO_USE_CURSOR | GBM_BO_USE_WRITE);
-
-	if (!dispdata->cursor_bo) {
-	    SDL_SetError("Could not create GBM cursor BO");
-	    goto cleanup;
-	}
-    }
-
-    /* SDL expects to set the default cursor on screen when we init the mouse. */
-    SDL_SetDefaultCursor(KMSDRM_CreateDefaultCursor());
-
-    return;
-
-cleanup:
-    if (dispdata->cursor_bo) {
-	KMSDRM_gbm_bo_destroy(dispdata->cursor_bo);
-	dispdata->cursor_bo = NULL;
+    /* Only create the default cursor for this display if we haven't done so before,
+       we don't want several cursors to be created for the same display. */
+    if (!dispdata->default_cursor_init) {
+        SDL_SetDefaultCursor(KMSDRM_CreateDefaultCursor());
+        dispdata->default_cursor_init = SDL_TRUE;
     }
 }
 
 void
-KMSDRM_DeinitMouse(_THIS)
+KMSDRM_QuitMouse(_THIS)
 {
-    SDL_VideoDevice *video_device = SDL_GetVideoDevice();
-    SDL_DisplayData *dispdata = (SDL_DisplayData *)SDL_GetDisplayDriverData(0);
-    KMSDRM_PlaneInfo info = {0};
- 
-    /*******************************************/
-    /* UNDO WHAT WE DID IN KMSDRM_InitMouse(). */
-    /*******************************************/
-    
-    /* 1- Destroy the curso GBM BO. */
-    if (video_device && dispdata->cursor_bo) {
-	/* Unsethe the cursor BO from the cursor plane.
-	   (The other members of the plane info are zeroed). */
-	info.plane = dispdata->cursor_plane;
-	drm_atomic_set_plane_props(&info);
-	/* Wait until the cursor is unset from the cursor plane
-	   before destroying it's BO. */
-	if (drm_atomic_commit(video_device, SDL_TRUE)) {
-	    SDL_SetError("Failed atomic commit in KMSDRM_DenitMouse.");
-	}
-	/* ..and finally destroy the cursor DRM BO! */
-	KMSDRM_gbm_bo_destroy(dispdata->cursor_bo);
-	dispdata->cursor_bo = NULL;
-    }
-
-    /* 2- Free the cursor plane, on which the cursor was being shown. */
-    if (dispdata->cursor_plane) {
-        free_plane(&dispdata->cursor_plane);
-    }
-
+    /* TODO: ? */
 }
 
 /* This is called when a mouse motion event occurs */
@@ -515,22 +438,24 @@ static void
 KMSDRM_MoveCursor(SDL_Cursor * cursor)
 {
     SDL_Mouse *mouse = SDL_GetMouse();
-    KMSDRM_CursorData *curdata;
+    int ret = 0;
 
     /* We must NOT call SDL_SendMouseMotion() here or we will enter recursivity!
        That's why we move the cursor graphic ONLY. */
-    if (mouse && mouse->cur_cursor && mouse->cur_cursor->driverdata) {
-        curdata = (KMSDRM_CursorData *) mouse->cur_cursor->driverdata;
+    if (mouse && mouse->cur_cursor && mouse->focus) {
 
-        /* Some programs expect cursor movement even while they don't do SwapWindow() calls,
-           and since we ride on the atomic_commit() in SwapWindow() for cursor movement,
-           cursor won't move in these situations. We could do an atomic_commit() here
-           for each cursor movement request, but it cripples the movement to 30FPS,
-           so a future solution is needed. SDLPoP "QUIT?" menu is an example of this
-           situation. */
+        SDL_Window *window = mouse->focus;
+        SDL_DisplayData *dispdata = (SDL_DisplayData *) SDL_GetDisplayForWindow(window)->driverdata;
 
-        if (drm_atomic_movecursor(curdata, mouse->x, mouse->y)) {
-            SDL_SetError("drm_atomic_movecursor() failed.");
+        if (!dispdata->cursor_bo) {
+            SDL_SetError("Cursor not initialized properly.");
+            return;
+        }
+
+        ret = KMSDRM_drmModeMoveCursor(dispdata->cursor_bo_drm_fd, dispdata->crtc->crtc_id, mouse->x, mouse->y);
+
+        if (ret) {
+            SDL_SetError("drmModeMoveCursor() failed.");
         }
     }
 }
diff --git a/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmmouse.h b/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmmouse.h
index 8993a315d..3879f7a06 100644
--- a/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmmouse.h
+++ b/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmmouse.h
@@ -1,7 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
-  Atomic KMSDRM backend by Manuel Alfayate Corchete <redwindwanderer@gmail.com>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -30,24 +29,26 @@
 #define MAX_CURSOR_W 512
 #define MAX_CURSOR_H 512
 
-/* Driverdata with driver-side info about the cursor. */
 typedef struct _KMSDRM_CursorData
 {
-    uint16_t       hot_x, hot_y;
-    uint16_t       w, h;
+    int            hot_x, hot_y;
+    int            w, h;
 
     /* The buffer where we store the mouse bitmap ready to be used.
-       We get it ready and filled in CreateCursor(), and copy it to a GBM BO in ShowCursor().*/     
+       We get it ready and filled in CreateCursor(), and copy it
+       to a GBM BO in ShowCursor().*/     
     uint32_t *buffer;
     size_t buffer_size;
     size_t buffer_pitch;
 
 } KMSDRM_CursorData;
 
-extern void KMSDRM_InitMouse(_THIS);
-extern void KMSDRM_DeinitMouse(_THIS);
+extern void KMSDRM_InitMouse(_THIS, SDL_VideoDisplay *display);
+extern void KMSDRM_QuitMouse(_THIS);
 
-extern void KMSDRM_InitCursor();
+extern void KMSDRM_CreateCursorBO(SDL_VideoDisplay *display);
+extern void KMSDRM_DestroyCursorBO(_THIS, SDL_VideoDisplay *display);
+extern void KMSDRM_InitCursor(void);
 
 #endif /* SDL_KMSDRM_mouse_h_ */
 
diff --git a/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmopengles.c b/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmopengles.c
index c9ec554b4..25d942e09 100644
--- a/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmopengles.c
+++ b/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmopengles.c
@@ -1,7 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
-  Atomic KMSDRM backend by Manuel Alfayate Corchete <redwindwanderer@gmail.com>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -22,29 +21,19 @@
 
 #include "../../SDL_internal.h"
 
-#if SDL_VIDEO_DRIVER_KMSDRM && SDL_VIDEO_OPENGL_EGL
+#if SDL_VIDEO_DRIVER_KMSDRM
+
+#include "SDL_log.h"
 
 #include "SDL_kmsdrmvideo.h"
 #include "SDL_kmsdrmopengles.h"
 #include "SDL_kmsdrmdyn.h"
-#include "SDL_hints.h"
+#include <errno.h>
 
 #ifndef EGL_PLATFORM_GBM_MESA
 #define EGL_PLATFORM_GBM_MESA 0x31D7
 #endif
 
-#ifndef EGL_SYNC_NATIVE_FENCE_ANDROID
-#define EGL_SYNC_NATIVE_FENCE_ANDROID     0x3144
-#endif
-
-#ifndef EGL_SYNC_NATIVE_FENCE_FD_ANDROID
-#define EGL_SYNC_NATIVE_FENCE_FD_ANDROID  0x3145
-#endif
-
-#ifndef EGL_NO_NATIVE_FENCE_FD_ANDROID
-#define EGL_NO_NATIVE_FENCE_FD_ANDROID    -1
-#endif
-
 /* EGL implementation of SDL OpenGL support */
 
 void
@@ -75,13 +64,14 @@ KMSDRM_GLES_LoadLibrary(_THIS, const char *path) {
 
 void
 KMSDRM_GLES_UnloadLibrary(_THIS) {
-    /* As with KMSDRM_GLES_LoadLibrary(), we define our own unloading function so
-       we manually unload the library whenever we want. */
+    /* As with KMSDRM_GLES_LoadLibrary(), we define our own "dummy" unloading function
+       so we manually unload the library whenever we want. */
 }
 
 SDL_EGL_CreateContext_impl(KMSDRM)
 
 int KMSDRM_GLES_SetSwapInterval(_THIS, int interval) {
+
     if (!_this->egl_data) {
         return SDL_SetError("EGL not initialized");
     }
@@ -95,287 +85,122 @@ int KMSDRM_GLES_SetSwapInterval(_THIS, int interval) {
     return 0;
 }
 
-/*********************************/
-/* Atomic functions block        */
-/*********************************/
-
-#define VOID2U64(x) ((uint64_t)(unsigned long)(x))
-
-static EGLSyncKHR create_fence(int fd, _THIS)
-{
-    EGLint attrib_list[] = {
-        EGL_SYNC_NATIVE_FENCE_FD_ANDROID, fd,
-        EGL_NONE,
-    };
-
-    EGLSyncKHR fence = _this->egl_data->eglCreateSyncKHR
-        (_this->egl_data->egl_display, EGL_SYNC_NATIVE_FENCE_ANDROID, attrib_list);
-
-    assert(fence);
-    return fence;
-}
-
-/***********************************************************************************/
-/* Comments about buffer access protection mechanism (=fences) are the ones boxed. */
-/* Also, DON'T remove the asserts: if a fence-related call fails, it's better that */
-/* program exits immediately, or we could leave KMS waiting for a failed/missing   */
-/* fence forevever.                                                                */
-/***********************************************************************************/
 int
-KMSDRM_GLES_SwapWindowFenced(_THIS, SDL_Window * window)
-{
+KMSDRM_GLES_SwapWindow(_THIS, SDL_Window * window) {
     SDL_WindowData *windata = ((SDL_WindowData *) window->driverdata);
     SDL_DisplayData *dispdata = (SDL_DisplayData *) SDL_GetDisplayForWindow(window)->driverdata;
-    KMSDRM_FBInfo *fb;
-    KMSDRM_PlaneInfo info = {0};
+    SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
+    KMSDRM_FBInfo *fb_info;
+    int ret = 0;
 
-    /******************************************************************/
-    /* Create the GPU-side FENCE OBJECT. It will be inserted into the */
-    /* GL CMDSTREAM exactly at the end of the gl commands that form a */
-    /* frame.(KMS will have to wait on it before doing a pageflip.)   */
-    /******************************************************************/
-    dispdata->gpu_fence = create_fence(EGL_NO_NATIVE_FENCE_FD_ANDROID, _this);
-    assert(dispdata->gpu_fence);
+    /* Always wait for the previous issued flip before issuing a new one,
+       even if you do async flips. */
+    uint32_t flip_flags = DRM_MODE_PAGE_FLIP_EVENT;
 
-    /******************************************************************/
-    /* eglSwapBuffers flushes the fence down the GL CMDSTREAM, so we  */
-    /* know for sure it's there now.                                  */
-    /* Also it marks, at EGL level, the buffer that we want to become */
-    /* the new front buffer. (Remember that won't really happen until */
-    /* we request a pageflip at the KMS level and it completes.       */
-    /******************************************************************/
-    if (! _this->egl_data->eglSwapBuffers(_this->egl_data->egl_display, windata->egl_surface)) {
-        return SDL_EGL_SetError("Failed to swap EGL buffers", "eglSwapBuffers");
+    /* Recreate the GBM / EGL surfaces if the display mode has changed */
+    if (windata->egl_surface_dirty) {
+        KMSDRM_CreateSurfaces(_this, window);
     }
 
-    /******************************************************************/
-    /* EXPORT the GPU-side FENCE OBJECT to the fence INPUT FD, so we  */
-    /* can pass it into the kernel. Atomic ioctl will pass the        */
-    /* in-fence fd into the kernel, thus telling KMS that it has to   */
-    /* wait for GPU to finish rendering the frame (remember where we  */
-    /* put the fence in the GL CMDSTREAM) before doing the changes    */
-    /* requested in the atomic ioct (the pageflip in this case).      */
-    /* (We export the GPU-side FENCE OJECT to the fence INPUT FD now, */
-    /* not sooner, because now we are sure that the GPU-side fence is */
-    /* in the CMDSTREAM to be lifted when the CMDSTREAM to this point */
-    /* is completed).                                                 */
-    /******************************************************************/
-    dispdata->kms_in_fence_fd = _this->egl_data->eglDupNativeFenceFDANDROID (_this->egl_data->egl_display,
-        dispdata->gpu_fence);
-    
-    _this->egl_data->eglDestroySyncKHR(_this->egl_data->egl_display, dispdata->gpu_fence);
-    assert(dispdata->kms_in_fence_fd != -1);
-
-    /* Lock the buffer that is marked by eglSwapBuffers() to become the
-       next front buffer (so it can not be chosen by EGL as back buffer
-       to draw on), and get a handle to it to request the pageflip on it.
-       REMEMBER that gbm_surface_lock_front_buffer() ALWAYS has to be
-       called after eglSwapBuffers(). */
-    windata->next_bo = KMSDRM_gbm_surface_lock_front_buffer(windata->gs);
-    if (!windata->next_bo) {
-        return SDL_SetError("Failed to lock frontbuffer");
-    }
-    fb = KMSDRM_FBFromBO(_this, windata->next_bo);
-    if (!fb) {
-        return SDL_SetError("Failed to get a new framebuffer from BO");
+    /* Wait for confirmation that the next front buffer has been flipped, at which
+       point the previous front buffer can be released */
+    if (!KMSDRM_WaitPageflip(_this, windata)) {
+        SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "Wait for previous pageflip failed");
+        return 0;
     }
 
-    /* Add the pageflip to the request list. */
-    info.plane = dispdata->display_plane;
-    info.crtc_id = dispdata->crtc->crtc->crtc_id;
-    info.fb_id = fb->fb_id;
-
-    info.src_w = windata->src_w;
-    info.src_h = windata->src_h;
-    info.crtc_w = windata->output_w;
-    info.crtc_h = windata->output_h;
-    info.crtc_x = windata->output_x;
-
-    drm_atomic_set_plane_props(&info);
-
-    /*****************************************************************/
-    /* Tell the display (KMS) that it will have to wait on the fence */
-    /* for the GPU-side FENCE.                                       */
-    /*                                                               */
-    /* Since KMS is a kernel thing, we have to pass an FD into       */
-    /* the kernel, and get another FD out of the kernel.             */
-    /*                                                               */
-    /* 1) To pass the GPU-side fence into the kernel, we set the     */
-    /* INPUT FD as the IN_FENCE_FD prop of the PRIMARY PLANE.        */
-    /* This FD tells KMS (the kernel) to wait for the GPU-side fence.*/
-    /*                                                               */
-    /* 2) To get the KMS-side fence out of the kernel, we set the    */
-    /* OUTPUT FD as the OUT_FEWNCE_FD prop of the CRTC.              */
-    /* This FD will be later imported as a FENCE OBJECT which will be*/
-    /* used to tell the GPU to wait for KMS to complete the changes  */
-    /* requested in atomic_commit (the pageflip in this case).       */ 
-    /*****************************************************************/
-    if (dispdata->kms_in_fence_fd != -1)
-    {
-        add_plane_property(dispdata->atomic_req, dispdata->display_plane,
-            "IN_FENCE_FD", dispdata->kms_in_fence_fd);
-        add_crtc_property(dispdata->atomic_req, dispdata->crtc,
-            "OUT_FENCE_PTR", VOID2U64(&dispdata->kms_out_fence_fd));
-    }
-
-    /* Do we have a pending modesetting? If so, set the necessary 
-       props so it's included in the incoming atomic commit. */
-    if (dispdata->modeset_pending) {
-        uint32_t blob_id;
-        SDL_VideoData *viddata = (SDL_VideoData *)_this->driverdata;
-
-        dispdata->atomic_flags |= DRM_MODE_ATOMIC_ALLOW_MODESET;
-        add_connector_property(dispdata->atomic_req, dispdata->connector, "CRTC_ID", dispdata->crtc->crtc->crtc_id);
-        KMSDRM_drmModeCreatePropertyBlob(viddata->drm_fd, &dispdata->mode, sizeof(dispdata->mode), &blob_id);
-        add_crtc_property(dispdata->atomic_req, dispdata->crtc, "MODE_ID", blob_id);
-        add_crtc_property(dispdata->atomic_req, dispdata->crtc, "ACTIVE", 1);
-        dispdata->modeset_pending = SDL_FALSE;
-    }
-
-    /*****************************************************************/   
-    /* Issue a non-blocking atomic commit: for triple buffering,     */
-    /* this must not block so the game can start building another    */
-    /* frame, even if the just-requested pageflip hasnt't completed. */
-    /*****************************************************************/   
-    if (drm_atomic_commit(_this, SDL_FALSE)) {
-        return SDL_SetError("Failed to issue atomic commit on pageflip");
-    }
-
-    /* Release the previous front buffer so EGL can chose it as back buffer
-       and render on it again. */
+    /* Release the previous front buffer */
     if (windata->bo) {
         KMSDRM_gbm_surface_release_buffer(windata->gs, windata->bo);
+        windata->bo = NULL;
     }
 
-    /* Take note of the buffer about to become front buffer, so next
-       time we come here we can free it like we just did with the previous
-       front buffer. */
     windata->bo = windata->next_bo;
 
-    /****************************************************************/
-    /* Import the KMS-side FENCE OUTPUT FD from the kernel to the   */
-    /* KMS-side FENCE OBJECT so we can use use it to fence the GPU. */
-    /****************************************************************/
-    dispdata->kms_fence = create_fence(dispdata->kms_out_fence_fd, _this);
-    assert(dispdata->kms_fence);
-
-    /****************************************************************/
-    /* "Delete" the fence OUTPUT FD, because we already have the    */
-    /* KMS FENCE OBJECT, the fence itself is away from us, on the   */
-    /* kernel side.                                                 */
-    /****************************************************************/
-    dispdata->kms_out_fence_fd = -1;
-
-    /*****************************************************************/
-    /* Tell the GPU to wait on the fence for the KMS-side FENCE,     */
-    /* which means waiting until the requested pageflip is completed.*/
-    /*****************************************************************/
-    _this->egl_data->eglWaitSyncKHR(_this->egl_data->egl_display, dispdata->kms_fence, 0);
-
-    return 0;
-}
-
-int
-KMSDRM_GLES_SwapWindowDoubleBuffered(_THIS, SDL_Window * window)
-{
-    SDL_WindowData *windata = ((SDL_WindowData *) window->driverdata);
-    SDL_DisplayData *dispdata = (SDL_DisplayData *) SDL_GetDisplayForWindow(window)->driverdata;
-    KMSDRM_FBInfo *fb;
-    KMSDRM_PlaneInfo info = {0};
-
-    /****************************************************************************************************/
-    /* In double-buffer mode, atomic_commit will always be synchronous/blocking (ie: won't return until */
-    /* the requested changes are really done).                                                          */
-    /* Also, there's no need to fence KMS or the GPU, because we won't be entering game loop again      */
-    /* (hence not building or executing a new cmdstring) until pageflip is done, so we don't need to    */
-    /* protect the KMS/GPU access to the buffer.                                                        */
-    /****************************************************************************************************/ 
-
-    /* Mark, at EGL level, the buffer that we want to become the new front buffer.
-       However, it won't really happen until we request a pageflip at the KMS level and it completes. */
-    if (! _this->egl_data->eglSwapBuffers(_this->egl_data->egl_display, windata->egl_surface)) {
-        return SDL_EGL_SetError("Failed to swap EGL buffers", "eglSwapBuffers");
+    /* Mark a buffer to becume the next front buffer.
+       This won't happen until pagelip completes. */
+    if (!(_this->egl_data->eglSwapBuffers(_this->egl_data->egl_display,
+                                           windata->egl_surface))) {
+        SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "eglSwapBuffers failed");
+        return 0;
     }
 
-    /* Lock the buffer that is marked by eglSwapBuffers() to become the next front buffer (so it can not
-       be chosen by EGL as back buffer to draw on), and get a handle to it to request the pageflip on it. */
+    /* From the GBM surface, get the next BO to become the next front buffer,
+       and lock it so it can't be allocated as a back buffer (to prevent EGL
+       from drawing into it!) */
     windata->next_bo = KMSDRM_gbm_surface_lock_front_buffer(windata->gs);
     if (!windata->next_bo) {
-        return SDL_SetError("Failed to lock frontbuffer");
-    }
-    fb = KMSDRM_FBFromBO(_this, windata->next_bo);
-    if (!fb) {
-        return SDL_SetError("Failed to get a new framebuffer BO");
+        SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "Could not lock front buffer on GBM surface");
+        return 0;
     }
 
-    /* Add the pageflip to the request list. */
-    info.plane = dispdata->display_plane;
-    info.crtc_id = dispdata->crtc->crtc->crtc_id;
-    info.fb_id = fb->fb_id;
-
-    info.src_w = windata->src_w;
-    info.src_h = windata->src_h;
-    info.crtc_w = windata->output_w;
-    info.crtc_h = windata->output_h;
-    info.crtc_x = windata->output_x;
-
-    drm_atomic_set_plane_props(&info);
-
-    /* Do we have a pending modesetting? If so, set the necessary 
-       props so it's included in the incoming atomic commit. */
-    if (dispdata->modeset_pending) {
-        SDL_VideoData *viddata = (SDL_VideoData *)_this->driverdata;
-        uint32_t blob_id;
-        dispdata->atomic_flags |= DRM_MODE_ATOMIC_ALLOW_MODESET;
-        add_connector_property(dispdata->atomic_req, dispdata->connector, "CRTC_ID", dispdata->crtc->crtc->crtc_id);
-        KMSDRM_drmModeCreatePropertyBlob(viddata->drm_fd, &dispdata->mode, sizeof(dispdata->mode), &blob_id);
-        add_crtc_property(dispdata->atomic_req, dispdata->crtc, "MODE_ID", blob_id);
-        add_crtc_property(dispdata->atomic_req, dispdata->crtc, "ACTIVE", 1);
-        dispdata->modeset_pending = SDL_FALSE;
+    /* Get an actual usable fb for the next front buffer. */
+    fb_info = KMSDRM_FBFromBO(_this, windata->next_bo);
+    if (!fb_info) {
+        SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "Could not get a framebuffer");
+        return 0;
     }
 
-    /* Issue the one and only atomic commit where all changes will be requested!. 
-       Blocking for double buffering: won't return until completed. */
-    if (drm_atomic_commit(_this, SDL_TRUE)) {
-        return SDL_SetError("Failed to issue atomic commit");
-    }
+    if (!windata->bo) {
+        /* On the first swap, immediately present the new front buffer. Before
+           drmModePageFlip can be used the CRTC has to be configured to use
+           the current connector and mode with drmModeSetCrtc */
+        ret = KMSDRM_drmModeSetCrtc(viddata->drm_fd,
+          dispdata->crtc->crtc_id, fb_info->fb_id, 0, 0,
+          &dispdata->connector->connector_id, 1, &dispdata->mode);
 
-    /* Release last front buffer so EGL can chose it as back buffer and render on it again. */
-    if (windata->bo) {
-        KMSDRM_gbm_surface_release_buffer(windata->gs, windata->bo);
-    }
+        if (ret) {
+            SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "Could not set videomode on CRTC.");
+            return 0;
+        }
+    } else {
+        /* On subsequent swaps, queue the new front buffer to be flipped during
+           the next vertical blank
 
-    /* Take note of current front buffer, so we can free it next time we come here. */
-    windata->bo = windata->next_bo;
+           Remember: drmModePageFlip() never blocks, it just issues the flip,
+           which will be done during the next vblank, or immediately if
+           we pass the DRM_MODE_PAGE_FLIP_ASYNC flag.
+           Since calling drmModePageFlip() will return EBUSY if we call it
+           without having completed the last issued flip, we must pass the
+           DRM_MODE_PAGE_FLIP_ASYNC if we don't block on EGL (egl_swapinterval = 0).
+           That makes it flip immediately, without waiting for the next vblank
+           to do so, so even if we don't block on EGL, the flip will have completed
+           when we get here again. */
+        if (_this->egl_data->egl_swapinterval == 0 && viddata->async_pageflip_support) {
+            flip_flags |= DRM_MODE_PAGE_FLIP_ASYNC;
+        }
 
-    return 0;
-}
+        ret = KMSDRM_drmModePageFlip(viddata->drm_fd, dispdata->crtc->crtc_id,
+                 fb_info->fb_id, flip_flags, &windata->waiting_for_flip);
 
-int
-KMSDRM_GLES_SwapWindow(_THIS, SDL_Window * window)
-{
-    SDL_WindowData *windata = ((SDL_WindowData *) window->driverdata);
-
-    if (windata->swap_window == NULL) {
-        /* We want the fenced version by default, but it needs extensions. */
-        if ( (SDL_GetHintBoolean(SDL_HINT_VIDEO_DOUBLE_BUFFER, SDL_FALSE)) ||
-             (!SDL_EGL_HasExtension(_this, SDL_EGL_DISPLAY_EXTENSION, "EGL_ANDROID_native_fence_sync")) )
-        {
-            windata->swap_window = KMSDRM_GLES_SwapWindowDoubleBuffered;
+        if (ret == 0) {
+            windata->waiting_for_flip = SDL_TRUE;
         } else {
-            windata->swap_window = KMSDRM_GLES_SwapWindowFenced;
+            SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "Could not queue pageflip: %d", ret);
+        }
+
+        /* Wait immediately for vsync (as if we only had two buffers).
+           Even if we are already doing a WaitPageflip at the begining of this
+           function, this is NOT redundant because here we wait immediately
+           after submitting the image to the screen, reducing lag, and if
+           we have waited here, there won't be a pending pageflip so the
+           WaitPageflip at the beggining of this function will be a no-op.
+           Just leave it here and don't worry.
+           Run your SDL2 program with "SDL_KMSDRM_DOUBLE_BUFFER=1 <program_name>"
+           to enable this. */
+        if (windata->double_buffer) {
+            if (!KMSDRM_WaitPageflip(_this, windata)) {
+                SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "Immediate wait for previous pageflip failed");
+                return 0;
+            }
         }
     }
 
-    return windata->swap_window(_this, window);
+    return 1;
 }
 
-/***************************************/
-/* End of Atomic functions block       */
-/***************************************/
-
 SDL_EGL_MakeCurrent_impl(KMSDRM)
 
-#endif /* SDL_VIDEO_DRIVER_KMSDRM && SDL_VIDEO_OPENGL_EGL */
+#endif /* SDL_VIDEO_DRIVER_KMSDRM */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmopengles.h b/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmopengles.h
index f81b0c3dc..a762ab0f3 100644
--- a/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmopengles.h
+++ b/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmopengles.h
@@ -1,7 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
-  Atomic KMSDRM backend by Manuel Alfayate Corchete <redwindwanderer@gmail.com>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -24,7 +23,7 @@
 #ifndef SDL_kmsdrmopengles_h_
 #define SDL_kmsdrmopengles_h_
 
-#if SDL_VIDEO_DRIVER_KMSDRM && SDL_VIDEO_OPENGL_EGL
+#if SDL_VIDEO_DRIVER_KMSDRM
 
 #include "../SDL_sysvideo.h"
 #include "../SDL_egl_c.h"
@@ -42,7 +41,7 @@ extern SDL_GLContext KMSDRM_GLES_CreateContext(_THIS, SDL_Window * window);
 extern int KMSDRM_GLES_SwapWindow(_THIS, SDL_Window * window);
 extern int KMSDRM_GLES_MakeCurrent(_THIS, SDL_Window * window, SDL_GLContext context);
 
-#endif /* SDL_VIDEO_DRIVER_KMSDRM && SDL_VIDEO_OPENGL_EGL */
+#endif /* SDL_VIDEO_DRIVER_KMSDRM */
 
 #endif /* SDL_kmsdrmopengles_h_ */
 
diff --git a/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmsym.h b/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmsym.h
index b75943b75..52c78de5e 100644
--- a/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmsym.h
+++ b/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmsym.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -41,32 +41,41 @@ SDL_KMSDRM_SYM(void,drmModeFreeCrtc,(drmModeCrtcPtr ptr))
 SDL_KMSDRM_SYM(void,drmModeFreeConnector,(drmModeConnectorPtr ptr))
 SDL_KMSDRM_SYM(void,drmModeFreeEncoder,(drmModeEncoderPtr ptr))
 SDL_KMSDRM_SYM(int,drmGetCap,(int fd, uint64_t capability, uint64_t *value))
-SDL_KMSDRM_SYM(int,drmIoctl,(int fd, unsigned long request, void *arg))
+SDL_KMSDRM_SYM(int,drmSetMaster,(int fd))
+SDL_KMSDRM_SYM(int,drmAuthMagic,(int fd, drm_magic_t magic))
 SDL_KMSDRM_SYM(drmModeResPtr,drmModeGetResources,(int fd))
-
 SDL_KMSDRM_SYM(int,drmModeAddFB,(int fd, uint32_t width, uint32_t height, uint8_t depth,
-                                 uint8_t bpp, uint32_t pitch, uint32_t bo_handle,
-                                 uint32_t *buf_id))
+                         uint8_t bpp, uint32_t pitch, uint32_t bo_handle,
+                         uint32_t *buf_id))
 
 SDL_KMSDRM_SYM(int,drmModeAddFB2,(int fd, uint32_t width, uint32_t height,
-                                  uint32_t pixel_format, const uint32_t bo_handles[4],
-                                  const uint32_t pitches[4], const uint32_t offsets[4],
-                                  uint32_t *buf_id, uint32_t flags))
-
-SDL_KMSDRM_SYM(int,drmModeAddFB2WithModifiers,(int fd, uint32_t width, uint32_t height,
-                                               uint32_t pixel_format, const uint32_t bo_handles[4],
-                                               const uint32_t pitches[4], const uint32_t offsets[4],
-                                               const uint64_t modifier[4], uint32_t *buf_id,
-                                               uint32_t flags))
+                         uint32_t pixel_format, const uint32_t bo_handles[4],
+                         const uint32_t pitches[4], const uint32_t offsets[4],
+                         uint32_t *buf_id, uint32_t flags))
 
 SDL_KMSDRM_SYM(int,drmModeRmFB,(int fd, uint32_t bufferId))
 SDL_KMSDRM_SYM(drmModeFBPtr,drmModeGetFB,(int fd, uint32_t buf))
 SDL_KMSDRM_SYM(drmModeCrtcPtr,drmModeGetCrtc,(int fd, uint32_t crtcId))
+SDL_KMSDRM_SYM(int,drmModeSetCrtc,(int fd, uint32_t crtcId, uint32_t bufferId,
+                                   uint32_t x, uint32_t y, uint32_t *connectors, int count,
+                                   drmModeModeInfoPtr mode))
+SDL_KMSDRM_SYM(int,drmModeCrtcGetGamma,(int fd, uint32_t crtc_id, uint32_t size,
+                                        uint16_t *red, uint16_t *green, uint16_t *blue))
+SDL_KMSDRM_SYM(int,drmModeCrtcSetGamma,(int fd, uint32_t crtc_id, uint32_t size,
+                                        uint16_t *red, uint16_t *green, uint16_t *blue))
+SDL_KMSDRM_SYM(int,drmModeSetCursor,(int fd, uint32_t crtcId, uint32_t bo_handle,
+                                     uint32_t width, uint32_t height))
+SDL_KMSDRM_SYM(int,drmModeSetCursor2,(int fd, uint32_t crtcId, uint32_t bo_handle,
+                                      uint32_t width, uint32_t height,
+                                      int32_t hot_x, int32_t hot_y))
+SDL_KMSDRM_SYM(int,drmModeMoveCursor,(int fd, uint32_t crtcId, int x, int y))
 SDL_KMSDRM_SYM(drmModeEncoderPtr,drmModeGetEncoder,(int fd, uint32_t encoder_id))
 SDL_KMSDRM_SYM(drmModeConnectorPtr,drmModeGetConnector,(int fd, uint32_t connector_id))
+SDL_KMSDRM_SYM(int,drmHandleEvent,(int fd,drmEventContextPtr evctx))
+SDL_KMSDRM_SYM(int,drmModePageFlip,(int fd, uint32_t crtc_id, uint32_t fb_id,
+                                    uint32_t flags, void *user_data))
 
-/* Atomic functions */
-
+/* Planes stuff. */
 SDL_KMSDRM_SYM(int,drmSetClientCap,(int fd, uint64_t capability, uint64_t value))
 SDL_KMSDRM_SYM(drmModePlaneResPtr,drmModeGetPlaneResources,(int fd))
 SDL_KMSDRM_SYM(drmModePlanePtr,drmModeGetPlane,(int fd, uint32_t plane_id))
@@ -77,17 +86,15 @@ SDL_KMSDRM_SYM(void,drmModeFreeProperty,(drmModePropertyPtr ptr))
 SDL_KMSDRM_SYM(void,drmModeFreeObjectProperties,(drmModeObjectPropertiesPtr ptr))
 SDL_KMSDRM_SYM(void,drmModeFreePlane,(drmModePlanePtr ptr))
 SDL_KMSDRM_SYM(void,drmModeFreePlaneResources,(drmModePlaneResPtr ptr))
-
-SDL_KMSDRM_SYM(drmModeAtomicReqPtr,drmModeAtomicAlloc,(void))
-SDL_KMSDRM_SYM(void,drmModeAtomicFree,(drmModeAtomicReqPtr req))
-SDL_KMSDRM_SYM(int,drmModeAtomicCommit,(int fd,drmModeAtomicReqPtr req,uint32_t flags,void *user_data))
-SDL_KMSDRM_SYM(int,drmModeAtomicAddProperty,(drmModeAtomicReqPtr req,uint32_t object_id,uint32_t property_id,uint64_t value))
-SDL_KMSDRM_SYM(int,drmModeCreatePropertyBlob,(int fd,const void *data,size_t size,uint32_t *id))
-
-/* End of atomic fns */
+SDL_KMSDRM_SYM(int,drmModeSetPlane,(int fd, uint32_t plane_id, uint32_t crtc_id,
+                                    uint32_t fb_id, uint32_t flags,
+                                    int32_t crtc_x, int32_t crtc_y,
+                                    uint32_t crtc_w, uint32_t crtc_h,
+                                    uint32_t src_x, uint32_t src_y,
+                                    uint32_t src_w, uint32_t src_h))
+/* Planes stuff ends. */
 
 SDL_KMSDRM_MODULE(GBM)
-SDL_KMSDRM_SYM(int,gbm_device_get_fd,(struct gbm_device *gbm))
 SDL_KMSDRM_SYM(int,gbm_device_is_format_supported,(struct gbm_device *gbm,
                                                    uint32_t format, uint32_t usage))
 SDL_KMSDRM_SYM(void,gbm_device_destroy,(struct gbm_device *gbm))
@@ -95,11 +102,7 @@ SDL_KMSDRM_SYM(struct gbm_device *,gbm_create_device,(int fd))
 SDL_KMSDRM_SYM(unsigned int,gbm_bo_get_width,(struct gbm_bo *bo))
 SDL_KMSDRM_SYM(unsigned int,gbm_bo_get_height,(struct gbm_bo *bo))
 SDL_KMSDRM_SYM(uint32_t,gbm_bo_get_stride,(struct gbm_bo *bo))
-SDL_KMSDRM_SYM(uint32_t,gbm_bo_get_stride_for_plane,(struct gbm_bo *bo,int plane))
 SDL_KMSDRM_SYM(uint32_t,gbm_bo_get_format,(struct gbm_bo *bo))
-SDL_KMSDRM_SYM(uint32_t,gbm_bo_get_offset,(struct gbm_bo *bo, int plane))
-SDL_KMSDRM_SYM(int,gbm_bo_get_plane_count,(struct gbm_bo *bo))
-
 SDL_KMSDRM_SYM(union gbm_bo_handle,gbm_bo_get_handle,(struct gbm_bo *bo))
 SDL_KMSDRM_SYM(int,gbm_bo_write,(struct gbm_bo *bo, const void *buf, size_t count))
 SDL_KMSDRM_SYM(struct gbm_device *,gbm_bo_get_device,(struct gbm_bo *bo))
diff --git a/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmvideo.c b/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmvideo.c
index e84bd5ebc..fd3a3cd63 100644
--- a/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmvideo.c
+++ b/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmvideo.c
@@ -1,7 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
-  Atomic KMSDRM backend by Manuel Alfayate Corchete <redwindwanderer@gmail.com>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -27,12 +26,16 @@
 /* SDL internals */
 #include "../SDL_sysvideo.h"
 #include "SDL_syswm.h"
+#include "SDL_log.h"
+#include "SDL_hints.h"
 #include "../../events/SDL_events_c.h"
 #include "../../events/SDL_mouse_c.h"
 #include "../../events/SDL_keyboard_c.h"
 
 #ifdef SDL_INPUT_LINUXEV
 #include "../../core/linux/SDL_evdev.h"
+#elif defined SDL_INPUT_WSCONS
+#include "../../core/openbsd/SDL_wscons.h"
 #endif
 
 /* KMS/DRM declarations */
@@ -43,67 +46,80 @@
 #include "SDL_kmsdrmdyn.h"
 #include "SDL_kmsdrmvulkan.h"
 #include <sys/stat.h>
+#include <sys/param.h>
+#include <sys/utsname.h>
 #include <dirent.h>
-#include <errno.h>
 #include <poll.h>
+#include <errno.h>
 
-/* for older KMSDRM headers... */
-#ifndef DRM_FORMAT_MOD_VENDOR_NONE
-#define DRM_FORMAT_MOD_VENDOR_NONE 0
-#endif
-#ifndef DRM_FORMAT_MOD_LINEAR
-#define DRM_FORMAT_MOD_LINEAR fourcc_mod_code(NONE, 0)
-#endif
-
+#ifdef __OpenBSD__
+static SDL_bool openbsd69orgreater = SDL_FALSE;
+#define KMSDRM_DRI_PATH openbsd69orgreater ? "/dev/dri/" : "/dev/"
+#define KMSDRM_DRI_DEVFMT openbsd69orgreater ? "%scard%d" : "%sdrm%d"
+#define KMSDRM_DRI_DEVNAME openbsd69orgreater ? "card" : "drm"
+#define KMSDRM_DRI_DEVNAMESIZE openbsd69orgreater ? 4 : 3
+#define KMSDRM_DRI_CARDPATHFMT openbsd69orgreater ? "/dev/dri/card%d" : "/dev/drm%d"
+#else
 #define KMSDRM_DRI_PATH "/dev/dri/"
+#define KMSDRM_DRI_DEVFMT "%scard%d"
+#define KMSDRM_DRI_DEVNAME "card"
+#define KMSDRM_DRI_DEVNAMESIZE 4
+#define KMSDRM_DRI_CARDPATHFMT "/dev/dri/card%d"
+#endif
 
-static int set_client_caps (int fd)
-{
-    if (KMSDRM_drmSetClientCap(fd, DRM_CLIENT_CAP_ATOMIC, 1)) {
-         return SDL_SetError("no atomic modesetting support.");
-    }
-    if (KMSDRM_drmSetClientCap(fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1)) {
-         return SDL_SetError("no universal planes support.");
-    }
-    return 0;
-}
+#ifndef EGL_PLATFORM_GBM_MESA
+#define EGL_PLATFORM_GBM_MESA 0x31D7
+#endif
 
 static int
-check_modesetting(int devindex)
+check_modestting(int devindex)
 {
     SDL_bool available = SDL_FALSE;
     char device[512];
-    unsigned int i;
     int drm_fd;
+    int i;
 
-    SDL_snprintf(device, sizeof (device), "%scard%d", KMSDRM_DRI_PATH, devindex);
-    SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "check_modesetting: probing \"%s\"", device);
+    SDL_snprintf(device, sizeof (device), KMSDRM_DRI_DEVFMT, KMSDRM_DRI_PATH, devindex);
 
     drm_fd = open(device, O_RDWR | O_CLOEXEC);
     if (drm_fd >= 0) {
         if (SDL_KMSDRM_LoadSymbols()) {
-            drmModeRes *resources = (set_client_caps(drm_fd) < 0) ? NULL : KMSDRM_drmModeGetResources(drm_fd);
+            drmModeRes *resources = KMSDRM_drmModeGetResources(drm_fd);
             if (resources) {
-                SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "%scard%d connector, encoder and CRTC counts are: %d %d %d",
-                             KMSDRM_DRI_PATH, devindex,
-                             resources->count_connectors, resources->count_encoders, resources->count_crtcs);
+                SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO,
+                  KMSDRM_DRI_DEVFMT
+                  " connector, encoder and CRTC counts are: %d %d %d",
+                  KMSDRM_DRI_PATH, devindex,
+                  resources->count_connectors, resources->count_encoders,
+                  resources->count_crtcs);
 
-                if (resources->count_connectors > 0 && resources->count_encoders > 0 && resources->count_crtcs > 0) {
+                if (resources->count_connectors > 0
+                 && resources->count_encoders > 0
+                 && resources->count_crtcs > 0)
+                {
+                    available = SDL_FALSE;
                     for (i = 0; i < resources->count_connectors; i++) {
-                        drmModeConnector *conn = KMSDRM_drmModeGetConnector(drm_fd, resources->connectors[i]);
+                        drmModeConnector *conn = KMSDRM_drmModeGetConnector(drm_fd,
+                            resources->connectors[i]);
 
                         if (!conn) {
                             continue;
                         }
 
                         if (conn->connection == DRM_MODE_CONNECTED && conn->count_modes) {
+                            if (SDL_GetHintBoolean(SDL_HINT_KMSDRM_REQUIRE_DRM_MASTER, SDL_TRUE)) {
+                                /* Skip this device if we can't obtain DRM master */
+                                KMSDRM_drmSetMaster(drm_fd);
+                                if (KMSDRM_drmAuthMagic(drm_fd, 0) == -EACCES) {
+                                    continue;
+                                }
+                            }
+
                             available = SDL_TRUE;
+                            break;
                         }
 
                         KMSDRM_drmModeFreeConnector(conn);
-                        if (available) {
-                            break;
-                        }
                     }
                 }
                 KMSDRM_drmModeFreeResources(resources);
@@ -116,30 +132,30 @@ check_modesetting(int devindex)
     return available;
 }
 
-static unsigned int get_dricount(void)
+static int get_dricount(void)
 {
-    unsigned int devcount = 0;
+    int devcount = 0;
     struct dirent *res;
     struct stat sb;
     DIR *folder;
 
-    if (!(stat(KMSDRM_DRI_PATH, &sb) == 0 && S_ISDIR(sb.st_mode))) {
-        SDL_SetError("The path %s cannot be opened or is not available",
-        KMSDRM_DRI_PATH);
+    if (!(stat(KMSDRM_DRI_PATH, &sb) == 0
+                && S_ISDIR(sb.st_mode))) {
+        /*printf("The path %s cannot be opened or is not available\n", KMSDRM_DRI_PATH);*/
         return 0;
     }
 
     if (access(KMSDRM_DRI_PATH, F_OK) == -1) {
-        SDL_SetError("The path %s cannot be opened",
-            KMSDRM_DRI_PATH);
+        /*printf("The path %s cannot be opened\n", KMSDRM_DRI_PATH);*/
         return 0;
     }
 
     folder = opendir(KMSDRM_DRI_PATH);
     if (folder) {
         while ((res = readdir(folder))) {
-            size_t len = SDL_strlen(res->d_name);
-            if (len > 4 && SDL_strncmp(res->d_name, "card", 4) == 0) {
+            int len = SDL_strlen(res->d_name);
+            if (len > KMSDRM_DRI_DEVNAMESIZE && SDL_strncmp(res->d_name,
+                      KMSDRM_DRI_DEVNAME, KMSDRM_DRI_DEVNAMESIZE) == 0) {
                 devcount++;
             }
         }
@@ -152,11 +168,11 @@ static unsigned int get_dricount(void)
 static int
 get_driindex(void)
 {
-    const unsigned int devcount = get_dricount();
-    unsigned int i;
+    const int devcount = get_dricount();
+    int i;
 
     for (i = 0; i < devcount; i++) {
-        if (check_modesetting(i)) {
+        if (check_modestting(i)) {
             return i;
         }
     }
@@ -164,577 +180,23 @@ get_driindex(void)
     return -ENOENT;
 }
 
-#if 0
-
-/**********************/
-/* DUMB BUFFER Block. */
-/**********************/
-
-/* Create a dumb buffer, mmap the dumb buffer and fill it with pixels, */
-/* then create a KMS framebuffer wrapping the dumb buffer.             */
-static dumb_buffer *KMSDRM_CreateDumbBuffer(_THIS)
-{
-    SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
-    SDL_DisplayData *dispdata = (SDL_DisplayData *)SDL_GetDisplayDriverData(0);
-
-    struct drm_mode_create_dumb create;
-    struct drm_mode_map_dumb map;
-    struct drm_mode_destroy_dumb destroy;
-
-    dumb_buffer *ret = SDL_calloc(1, sizeof(*ret));
-    if (!ret) {
-        SDL_OutOfMemory();
-        return NULL;
-    }
-
-    /*
-     * The create ioctl uses the combination of depth and bpp to infer
-     * a format; 24/32 refers to DRM_FORMAT_XRGB8888 as defined in
-     * the drm_fourcc.h header. These arguments are the same as given
-     * to drmModeAddFB, which has since been superseded by
-     * drmModeAddFB2 as the latter takes an explicit format token.
-     *
-     * We only specify these arguments; the driver calculates the
-     * pitch (also known as stride or row length) and total buffer size
-     * for us, also returning us the GEM handle.
-     */
-    create = (struct drm_mode_create_dumb) {
-        .width = dispdata->mode.hdisplay,
-        .height = dispdata->mode.vdisplay,
-        .bpp = 32,
-    };
-
-    if (KMSDRM_drmIoctl(viddata->drm_fd, DRM_IOCTL_MODE_CREATE_DUMB, &create)) {
-        SDL_SetError("failed to create dumb buffer\n");
-        goto err;
-    }
-
-    ret->gem_handles[0] = create.handle;
-    ret->format = DRM_FORMAT_XRGB8888;
-    ret->modifier = DRM_FORMAT_MOD_LINEAR;
-    ret->width = create.width;
-    ret->height = create.height;
-    ret->pitches[0] = create.pitch;
-
-    /*
-     * In order to map the buffer, we call an ioctl specific to the buffer
-     * type, which returns us a fake offset to use with the mmap syscall.
-     * mmap itself then works as you expect.
-     *
-     * Note this means it is not possible to map arbitrary offsets of
-     * buffers without specifically requesting it from the kernel.
-     */
-    map = (struct drm_mode_map_dumb) {
-        .handle = ret->gem_handles[0],
-    };
-
-    if (KMSDRM_drmIoctl(viddata->drm_fd, DRM_IOCTL_MODE_MAP_DUMB, &map)) {
-        SDL_SetError("failed to get mmap offset for the dumb buffer.");
-        goto err_dumb;
-    }
-
-    ret->dumb.mem = mmap(NULL, create.size, PROT_WRITE, MAP_SHARED,
-                         viddata->drm_fd, map.offset);
-
-    if (ret->dumb.mem == MAP_FAILED) {
-        SDL_SetError("failed to get mmap offset for the dumb buffer.");
-        goto err_dumb;
-    }
-    ret->dumb.size = create.size;
-
-    return ret;
-
-err_dumb:
-    destroy = (struct drm_mode_destroy_dumb) { .handle = create.handle };
-    KMSDRM_drmIoctl(viddata->drm_fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy);
-err:
-    SDL_free(ret);
-    return NULL;
-}
-
-static void
-KMSDRM_DestroyDumbBuffer(_THIS, dumb_buffer **buffer)
-{
-    SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
-
-    struct drm_mode_destroy_dumb destroy = {
-        .handle = (*buffer)->gem_handles[0],
-    };
-
-    KMSDRM_drmModeRmFB(viddata->drm_fd, (*buffer)->fb_id);
-
-    munmap((*buffer)->dumb.mem, (*buffer)->dumb.size);
-    KMSDRM_drmIoctl(viddata->drm_fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy);
-    free(*buffer);
-    *buffer = NULL;
-}
-
-/* Using the CPU mapping, fill the dumb buffer with black pixels. */
-static void
-KMSDRM_FillDumbBuffer(dumb_buffer *buffer)
-{
-    unsigned int x, y;
-    for (y = 0; y < buffer->height; y++) {
-    uint32_t *pix = (uint32_t *) ((uint8_t *) buffer->dumb.mem + (y * buffer->pitches[0]));
-        for (x = 0; x < buffer->width; x++) {
-            *pix++ = (0x00000000);
-        }
-    }
-}
-
-static dumb_buffer *KMSDRM_CreateBuffer(_THIS)
-{
-    dumb_buffer *ret;
-    int err;
-
-    SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
-
-    ret = KMSDRM_CreateDumbBuffer(_this);
-
-    if (!ret)
-        return NULL;
-
-    /*
-     * Wrap our GEM buffer in a KMS framebuffer, so we can then attach it
-     * to a plane. Here's where we get out fb_id!
-     */
-    err = KMSDRM_drmModeAddFB2(viddata->drm_fd, ret->width, ret->height,
-        ret->format, ret->gem_handles, ret->pitches,
-        ret->offsets, &ret->fb_id, 0);
-
-    if (err != 0 || ret->fb_id == 0) {
-        SDL_SetError("Failed AddFB2 on dumb buffer\n");
-        goto err;
-    }
-    return ret;
-
-err:
-    KMSDRM_DestroyDumbBuffer(_this, &ret);
-    return NULL;
-}
-
-/***************************/
-/* DUMB BUFFER Block ends. */
-/***************************/
-
-#endif
-
-/*********************************/
-/* Atomic helper functions block */
-/*********************************/
-
-#define VOID2U64(x) ((uint64_t)(unsigned long)(x))
-
-int add_connector_property(drmModeAtomicReq *req, struct connector *connector,
-                                     const char *name, uint64_t value)
-{
-    unsigned int i;
-    int prop_id = 0;
-
-    for (i = 0 ; i < connector->props->count_props ; i++) {
-        if (strcmp(connector->props_info[i]->name, name) == 0) {
-            prop_id = connector->props_info[i]->prop_id;
-            break;
-        }
-    }
-
-    if (prop_id < 0) {
-        SDL_SetError("no connector property: %s", name);
-        return -EINVAL;
-    }
-
-    return KMSDRM_drmModeAtomicAddProperty(req, connector->connector->connector_id, prop_id, value);
-}
-
-int add_crtc_property(drmModeAtomicReq *req, struct crtc *crtc,
-                         const char *name, uint64_t value)
-{
-    unsigned int i;
-    int prop_id = -1;
-
-    for (i = 0 ; i < crtc->props->count_props ; i++) {
-        if (strcmp(crtc->props_info[i]->name, name) == 0) {
-            prop_id = crtc->props_info[i]->prop_id;
-            break;
-        }
-    }
-
-    if (prop_id < 0) {
-        SDL_SetError("no crtc property: %s", name);
-        return -EINVAL;
-    }
-
-    return KMSDRM_drmModeAtomicAddProperty(req, crtc->crtc->crtc_id, prop_id, value);
-}
-
-int add_plane_property(drmModeAtomicReq *req, struct plane *plane,
-                          const char *name, uint64_t value)
-{
-    unsigned int i;
-    int prop_id = -1;
-
-    for (i = 0 ; i < plane->props->count_props ; i++) {
-        if (strcmp(plane->props_info[i]->name, name) == 0) {
-            prop_id = plane->props_info[i]->prop_id;
-            break;
-        }
-    }
-
-    if (prop_id < 0) {
-        SDL_SetError("no plane property: %s", name);
-        return -EINVAL;
-    }
-
-    return KMSDRM_drmModeAtomicAddProperty(req, plane->plane->plane_id, prop_id, value);
-}
-
-#if 0
-
-void print_plane_info(_THIS, drmModePlanePtr plane)
-{
-    char *plane_type;
-    drmModeRes *resources;
-    uint32_t type = 0;
-    SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
-    int i;
-
-    drmModeObjectPropertiesPtr props = KMSDRM_drmModeObjectGetProperties(viddata->drm_fd,
-        plane->plane_id, DRM_MODE_OBJECT_PLANE);
-
-    /* Search the plane props for the plane type. */
-    for (i = 0; i < props->count_props; i++) {
-        drmModePropertyPtr p = KMSDRM_drmModeGetProperty(viddata->drm_fd, props->props[i]);
-        if ((strcmp(p->name, "type") == 0)) {
-            type = props->prop_values[i];
-        }
-
-        KMSDRM_drmModeFreeProperty(p);
-    }
-
-    switch (type) {
-        case DRM_PLANE_TYPE_OVERLAY:
-            plane_type = "overlay";
-            break;
-
-        case DRM_PLANE_TYPE_PRIMARY:
-            plane_type = "primary";
-            break;
-
-        case DRM_PLANE_TYPE_CURSOR:
-            plane_type = "cursor";
-            break;
-    }
-
-
-    /* Remember that to present a plane on screen, it has to be
-       connected to a CRTC so the CRTC scans it,
-       scales it, etc... and presents it on screen. */
-
-    /* Now we look for the CRTCs supported by the plane. */
-    resources = KMSDRM_drmModeGetResources(viddata->drm_fd);
-    if (!resources)
-        return;
-
-    printf("--PLANE ID: %d\nPLANE TYPE: %s\nCRTC READING THIS PLANE: %d\nCRTCS SUPPORTED BY THIS PLANE: ",  plane->plane_id, plane_type, plane->crtc_id);
-    for (i = 0; i < resources->count_crtcs; i++) {
-        if (plane->possible_crtcs & (1 << i)) {
-            uint32_t crtc_id = resources->crtcs[i];
-            printf ("%d", crtc_id);
-            break;
-        }
-    }
-
-    printf ("\n\n");
-}
-
-void get_planes_info(_THIS)
-{
-    drmModePlaneResPtr plane_resources;
-    uint32_t i;
-
-    SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
-    SDL_DisplayData *dispdata = (SDL_DisplayData *)SDL_GetDisplayDriverData(0);
-
-    plane_resources = KMSDRM_drmModeGetPlaneResources(viddata->drm_fd);
-    if (!plane_resources) {
-        printf("drmModeGetPlaneResources failed: %s\n", strerror(errno));
-        return;
-    }
-
-    printf("--Number of planes found: %d-- \n", plane_resources->count_planes);
-    printf("--Usable CRTC that we have chosen: %d-- \n", dispdata->crtc->crtc->crtc_id);
-
-    /* Iterate on all the available planes. */
-    for (i = 0; (i < plane_resources->count_planes); i++) {
-
-        uint32_t plane_id = plane_resources->planes[i];
-
-        drmModePlanePtr plane = KMSDRM_drmModeGetPlane(viddata->drm_fd, plane_id);
-        if (!plane) {
-            printf("drmModeGetPlane(%u) failed: %s\n", plane_id, strerror(errno));
-            continue;
-        }
-
-        /* Print plane info. */
-        print_plane_info(_this, plane);
-        KMSDRM_drmModeFreePlane(plane);
-    }
-
-    KMSDRM_drmModeFreePlaneResources(plane_resources);
-}
-
-#endif
-
-/* Get the plane_id of a plane that is of the specified plane type (primary,
-   overlay, cursor...) and can use the CRTC we have chosen previously. */
-static int get_plane_id(_THIS, uint32_t plane_type)
-{
-    drmModeRes *resources = NULL;
-    drmModePlaneResPtr plane_resources = NULL;
-    uint32_t i, j;
-    unsigned int crtc_index = 0;
-    int ret = -EINVAL;
-    int found = 0;
-
-    SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
-    SDL_DisplayData *dispdata = (SDL_DisplayData *)SDL_GetDisplayDriverData(0);
-
-    resources = KMSDRM_drmModeGetResources(viddata->drm_fd);
-
-    /* Get the crtc_index for the current CRTC.
-       It's needed to find out if a plane supports the CRTC. */
-    for (i = 0; i < resources->count_crtcs; i++) {
-        if (resources->crtcs[i] == dispdata->crtc->crtc->crtc_id) {
-            crtc_index = i;
-            break;
-        }
-    }
-
-    plane_resources = KMSDRM_drmModeGetPlaneResources(viddata->drm_fd);
-    if (!plane_resources) {
-        return SDL_SetError("drmModeGetPlaneResources failed.");
-    }
-
-    /* Iterate on all the available planes. */
-    for (i = 0; (i < plane_resources->count_planes) && !found; i++) {
-
-        uint32_t plane_id = plane_resources->planes[i];
-
-        drmModePlanePtr plane = KMSDRM_drmModeGetPlane(viddata->drm_fd, plane_id);
-        if (!plane) {
-            continue;
-        }
-
-        /* See if the current CRTC is available for this plane. */
-        if (plane->possible_crtcs & (1 << crtc_index)) {
-
-            drmModeObjectPropertiesPtr props = KMSDRM_drmModeObjectGetProperties(
-                viddata->drm_fd, plane_id, DRM_MODE_OBJECT_PLANE);
-            ret = plane_id;
-
-            /* Iterate on the plane props to find the type of the plane,
-               to see if it's of the type we want. */
-            for (j = 0; j < props->count_props; j++) {
-
-                drmModePropertyPtr p = KMSDRM_drmModeGetProperty(viddata->drm_fd,
-                    props->props[j]);
-
-                if ((strcmp(p->name, "type") == 0) && (props->prop_values[j] == plane_type)) {
-                    /* found our plane, use that: */
-                    found = 1;
-                }
-
-                KMSDRM_drmModeFreeProperty(p);
-            }
-
-            KMSDRM_drmModeFreeObjectProperties(props);
-        }
-
-        KMSDRM_drmModeFreePlane(plane);
-    }
-
-    KMSDRM_drmModeFreePlaneResources(plane_resources);
-    KMSDRM_drmModeFreeResources(resources);
-
-    return ret;
-}
-
-/* Setup a plane and it's props. */
-int
-setup_plane(_THIS, struct plane **plane, uint32_t plane_type)
-{
-    uint32_t plane_id;
-    SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
-    int ret = 0;
-
-    *plane = SDL_calloc(1, sizeof(**plane));
-    if (!(*plane)) {
-        ret = SDL_OutOfMemory();
-        goto cleanup;
-    }
-
-    /* Get plane ID. */
-    plane_id = get_plane_id(_this, plane_type);
-
-    if (!plane_id) {
-        ret = SDL_SetError("Invalid Plane ID");
-        goto cleanup;
-    }
-
-    /* Get the DRM plane itself. */
-    (*plane)->plane = KMSDRM_drmModeGetPlane(viddata->drm_fd, plane_id);
-
-    /* Get the DRM plane properties. */
-    if ((*plane)->plane) {
-        unsigned int i;
-        (*plane)->props = KMSDRM_drmModeObjectGetProperties(viddata->drm_fd,
-        (*plane)->plane->plane_id, DRM_MODE_OBJECT_PLANE);
-        (*plane)->props_info = SDL_calloc((*plane)->props->count_props,
-            sizeof(*(*plane)->props_info));
-
-        if ( !((*plane)->props_info) ) {
-            ret = SDL_OutOfMemory();
-            goto cleanup;
-        }
-
-        for (i = 0; i < (*plane)->props->count_props; i++) {
-            (*plane)->props_info[i] = KMSDRM_drmModeGetProperty(viddata->drm_fd,
-                (*plane)->props->props[i]);
-        }
-    }
-
-cleanup:
-
-    if (ret) {
-        if (*plane) {
-            SDL_free(*plane);
-            *plane = NULL;
-        }
-    }
-    return ret;
-}
-
-/* Free a plane and it's props. */
-void
-free_plane(struct plane **plane)
-{
-    if (*plane) {
-        if ((*plane)->plane) {
-            KMSDRM_drmModeFreePlane((*plane)->plane);
-            (*plane)->plane = NULL;
-        }
-        if ((*plane)->props_info) {
-            SDL_free((*plane)->props_info);
-            (*plane)->props_info = NULL;
-        }
-        SDL_free(*plane);
-        *plane = NULL;
-    }
-}
-
-/**********************************************************************************/
-/* The most important ATOMIC fn of the backend.                                   */
-/* A PLANE reads a BUFFER, and a CRTC reads a PLANE and sends it's contents       */
-/*   over to a CONNECTOR->ENCODER system (several CONNECTORS can be connected     */
-/*   to the same PLANE).                                                          */
-/*   Think of a plane as a "frame" sorrounding a picture, where the "picture"     */
-/*   is the buffer, and we move the "frame" from  a picture to another,           */
-/*   and the one that has the "frame" is the one sent over to the screen          */
-/*   via the CONNECTOR->ENCODER system.                                           */
-/*   Think of a PLANE as being "in the middle", it's the CENTRAL part             */
-/*   bewteen the CRTC and the BUFFER that is shown on screen.                     */
-/*   What we do here is connect a PLANE to a CRTC and a BUFFER.                   */
-/*   -ALWAYS set the CRTC_ID and FB_ID attribs of a plane at the same time,       */
-/*   meaning IN THE SAME atomic request.                                          */
-/*   -And NEVER destroy a GBM surface whose buffers are being read by a plane:    */
-/*   first, move the plane away from those buffers and ONLY THEN destroy the      */
-/*   buffers and/or the GBM surface containig them.                               */
-/**********************************************************************************/
-void
-drm_atomic_set_plane_props(struct KMSDRM_PlaneInfo *info)
-{
-    SDL_DisplayData *dispdata = (SDL_DisplayData *)SDL_GetDisplayDriverData(0);
-
-    /* Do we have a set of changes already in the making? If not, allocate a new one. */
-    if (!dispdata->atomic_req)
-        dispdata->atomic_req = KMSDRM_drmModeAtomicAlloc();
-
-    add_plane_property(dispdata->atomic_req, info->plane, "FB_ID", info->fb_id);
-    add_plane_property(dispdata->atomic_req, info->plane, "CRTC_ID", info->crtc_id);
-    add_plane_property(dispdata->atomic_req, info->plane, "SRC_W", info->src_w << 16);
-    add_plane_property(dispdata->atomic_req, info->plane, "SRC_H", info->src_h << 16);
-    add_plane_property(dispdata->atomic_req, info->plane, "SRC_X", info->src_x);
-    add_plane_property(dispdata->atomic_req, info->plane, "SRC_Y", info->src_y);
-    add_plane_property(dispdata->atomic_req, info->plane, "CRTC_W", info->crtc_w);
-    add_plane_property(dispdata->atomic_req, info->plane, "CRTC_H", info->crtc_h);
-    add_plane_property(dispdata->atomic_req, info->plane, "CRTC_X", info->crtc_x);
-    add_plane_property(dispdata->atomic_req, info->plane, "CRTC_Y", info->crtc_y);
-}
-
-int drm_atomic_commit(_THIS, SDL_bool blocking)
-{
-    SDL_DisplayData *dispdata = (SDL_DisplayData *)SDL_GetDisplayDriverData(0);
-    SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
-    int ret;
-
-    if (!blocking)
-        dispdata->atomic_flags |= DRM_MODE_ATOMIC_NONBLOCK;
-
-    /* Never issue a new atomic commit if previous has not yet completed, or it will error. */
-    drm_atomic_waitpending(_this);
-
-    ret = KMSDRM_drmModeAtomicCommit(viddata->drm_fd, dispdata->atomic_req, dispdata->atomic_flags, NULL);
-    if (ret) {
-        SDL_SetError("Atomic commit failed, returned %d.", ret);
-        /* Uncomment this for fast-debugging */
-#if 0
-        printf("ATOMIC COMMIT FAILED: %s.\n", strerror(errno));
-#endif
-        goto out;
-    }
-
-    if (dispdata->kms_in_fence_fd != -1) {
-        close(dispdata->kms_in_fence_fd);
-        dispdata->kms_in_fence_fd = -1;
-    }
-
-out:
-    KMSDRM_drmModeAtomicFree(dispdata->atomic_req);
-    dispdata->atomic_req = NULL;
-    dispdata->atomic_flags = 0;
-
-    return ret;
-}
-
-void
-drm_atomic_waitpending(_THIS)
-{
-    SDL_DisplayData *dispdata = (SDL_DisplayData *)SDL_GetDisplayDriverData(0);
-
-    /* Will return immediately if we have already destroyed the fence, because we NULL-ify it just after.
-       Also, will return immediately in double-buffer mode, because kms_fence will alsawys be NULL. */
-    if (dispdata->kms_fence) {
-        EGLint status;
-
-        do {
-            status = _this->egl_data->eglClientWaitSyncKHR(_this->egl_data->egl_display,
-                dispdata->kms_fence, 0, EGL_FOREVER_KHR);
-        } while (status != EGL_CONDITION_SATISFIED_KHR);
-
-        _this->egl_data->eglDestroySyncKHR(_this->egl_data->egl_display, dispdata->kms_fence);
-            dispdata->kms_fence = NULL;
-    }
-}
-
-/***************************************/
-/* End of Atomic helper functions block*/
-/***************************************/
-
 static int
 KMSDRM_Available(void)
 {
+#ifdef __OpenBSD__
+    struct utsname nameofsystem;
+    double releaseversion;
+#endif
     int ret = -ENOENT;
 
+#ifdef __OpenBSD__
+    if (!(uname(&nameofsystem) < 0)) {
+        releaseversion = SDL_atof(nameofsystem.release);
+        if (releaseversion >= 6.9) {
+            openbsd69orgreater = SDL_TRUE;
+        }
+    }
+#endif
     ret = get_driindex();
     if (ret >= 0)
         return 1;
@@ -755,36 +217,6 @@ KMSDRM_DeleteDevice(SDL_VideoDevice * device)
     SDL_KMSDRM_UnloadSymbols();
 }
 
-static int
-KMSDRM_GetDisplayDPI(_THIS, SDL_VideoDisplay * display, float * ddpi, float * hdpi, float * vdpi)
-{
-    int w, h;
-
-    uint32_t display_mm_width;
-    uint32_t display_mm_height;
-
-    SDL_DisplayData *dispdata;
-
-    dispdata = (SDL_DisplayData *)SDL_GetDisplayDriverData(0); //viddata->devindex);
-
-
-    if (!dispdata) {
-        return SDL_SetError("No available displays");
-    }
-
-    display_mm_width = dispdata->connector->connector->mmWidth;
-    display_mm_height = dispdata->connector->connector->mmHeight;
-
-    w = dispdata->mode.hdisplay;
-    h = dispdata->mode.vdisplay;
-
-    *hdpi = display_mm_width ? (((float) w) * 25.4f / display_mm_width) : 0.0f;
-    *vdpi = display_mm_height ? (((float) h) * 25.4f / display_mm_height) : 0.0f;
-    *ddpi = SDL_ComputeDiagonalDPI(w, h, ((float) display_mm_width) / 25.4f,((float) display_mm_height) / 25.4f);
-
-    return 0;
-}
-
 static SDL_VideoDevice *
 KMSDRM_CreateDevice(int devindex)
 {
@@ -800,7 +232,7 @@ KMSDRM_CreateDevice(int devindex)
     }
 
     if (devindex < 0) {
-        SDL_SetError("devindex (%d) must be between 0 and 99.", devindex);
+        SDL_SetError("devindex (%d) must be between 0 and 99.\n", devindex);
         return NULL;
     }
 
@@ -824,12 +256,11 @@ KMSDRM_CreateDevice(int devindex)
 
     device->driverdata = viddata;
 
-    /* Setup all functions that can be handled from this backend. */
+    /* Setup all functions which we can handle */
     device->VideoInit = KMSDRM_VideoInit;
     device->VideoQuit = KMSDRM_VideoQuit;
     device->GetDisplayModes = KMSDRM_GetDisplayModes;
     device->SetDisplayMode = KMSDRM_SetDisplayMode;
-    device->GetDisplayDPI = KMSDRM_GetDisplayDPI;
     device->CreateSDLWindow = KMSDRM_CreateWindow;
     device->CreateSDLWindowFrom = KMSDRM_CreateWindowFrom;
     device->SetWindowTitle = KMSDRM_SetWindowTitle;
@@ -837,17 +268,17 @@ KMSDRM_CreateDevice(int devindex)
     device->SetWindowPosition = KMSDRM_SetWindowPosition;
     device->SetWindowSize = KMSDRM_SetWindowSize;
     device->SetWindowFullscreen = KMSDRM_SetWindowFullscreen;
+    device->GetWindowGammaRamp = KMSDRM_GetWindowGammaRamp;
+    device->SetWindowGammaRamp = KMSDRM_SetWindowGammaRamp;
     device->ShowWindow = KMSDRM_ShowWindow;
     device->HideWindow = KMSDRM_HideWindow;
     device->RaiseWindow = KMSDRM_RaiseWindow;
     device->MaximizeWindow = KMSDRM_MaximizeWindow;
     device->MinimizeWindow = KMSDRM_MinimizeWindow;
     device->RestoreWindow = KMSDRM_RestoreWindow;
-    device->SetWindowGrab = KMSDRM_SetWindowGrab;
     device->DestroyWindow = KMSDRM_DestroyWindow;
     device->GetWindowWMInfo = KMSDRM_GetWindowWMInfo;
-#if SDL_VIDEO_OPENGL_EGL
-    device->GL_DefaultProfileConfig = KMSDRM_GLES_DefaultProfileConfig;
+
     device->GL_LoadLibrary = KMSDRM_GLES_LoadLibrary;
     device->GL_GetProcAddress = KMSDRM_GLES_GetProcAddress;
     device->GL_UnloadLibrary = KMSDRM_GLES_UnloadLibrary;
@@ -857,9 +288,8 @@ KMSDRM_CreateDevice(int devindex)
     device->GL_GetSwapInterval = KMSDRM_GLES_GetSwapInterval;
     device->GL_SwapWindow = KMSDRM_GLES_SwapWindow;
     device->GL_DeleteContext = KMSDRM_GLES_DeleteContext;
-#endif
-    device->PumpEvents = KMSDRM_PumpEvents;
-    device->free = KMSDRM_DeleteDevice;
+    device->GL_DefaultProfileConfig = KMSDRM_GLES_DefaultProfileConfig;
+
 #if SDL_VIDEO_VULKAN
     device->Vulkan_LoadLibrary = KMSDRM_Vulkan_LoadLibrary;
     device->Vulkan_UnloadLibrary = KMSDRM_Vulkan_UnloadLibrary;
@@ -867,6 +297,10 @@ KMSDRM_CreateDevice(int devindex)
     device->Vulkan_CreateSurface = KMSDRM_Vulkan_CreateSurface;
     device->Vulkan_GetDrawableSize = KMSDRM_Vulkan_GetDrawableSize;
 #endif
+
+    device->PumpEvents = KMSDRM_PumpEvents;
+    device->free = KMSDRM_DeleteDevice;
+
     return device;
 
 cleanup:
@@ -883,7 +317,6 @@ VideoBootStrap KMSDRM_bootstrap = {
     KMSDRM_CreateDevice
 };
 
-
 static void
 KMSDRM_FBDestroyCallback(struct gbm_bo *bo, void *data)
 {
@@ -901,11 +334,9 @@ KMSDRM_FBInfo *
 KMSDRM_FBFromBO(_THIS, struct gbm_bo *bo)
 {
     SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
-    unsigned width, height;
-    uint32_t format, strides[4] = {0}, handles[4] = {0}, offsets[4] = {0};
-    const int num_planes = KMSDRM_gbm_bo_get_plane_count(bo);
-    unsigned int i;
+    unsigned w,h;
     int ret;
+    Uint32 stride, handle;
 
     /* Check for an existing framebuffer */
     KMSDRM_FBInfo *fb_info = (KMSDRM_FBInfo *)KMSDRM_gbm_bo_get_user_data(bo);
@@ -914,9 +345,10 @@ KMSDRM_FBFromBO(_THIS, struct gbm_bo *bo)
         return fb_info;
     }
 
-    /* Create a structure that contains the info about framebuffer
-       that we need to use it. */
+    /* Create a structure that contains enough info to remove the framebuffer
+       when the backing buffer is destroyed */
     fb_info = (KMSDRM_FBInfo *)SDL_calloc(1, sizeof(KMSDRM_FBInfo));
+
     if (!fb_info) {
         SDL_OutOfMemory();
         return NULL;
@@ -924,160 +356,213 @@ KMSDRM_FBFromBO(_THIS, struct gbm_bo *bo)
 
     fb_info->drm_fd = viddata->drm_fd;
 
-    width = KMSDRM_gbm_bo_get_width(bo);
-    height = KMSDRM_gbm_bo_get_height(bo);
-    format = KMSDRM_gbm_bo_get_format(bo);
-
-    for (i = 0; i < num_planes; i++) {
-        strides[i] = KMSDRM_gbm_bo_get_stride_for_plane(bo, i);
-        handles[i] = KMSDRM_gbm_bo_get_handle(bo).u32;
-        offsets[i] = KMSDRM_gbm_bo_get_offset(bo, i);
-    }
-
-    /* Create framebuffer object for the buffer.
-       It's VERY important to note that fb_id is what we use to set the FB_ID prop
-       of a plane when using the ATOMIC interface, and we get the fb_id here. */
-    ret = KMSDRM_drmModeAddFB2(viddata->drm_fd, width, height, format,
-            handles, strides, offsets, &fb_info->fb_id, 0);
-
+    /* Create framebuffer object for the buffer */
+    w = KMSDRM_gbm_bo_get_width(bo);
+    h = KMSDRM_gbm_bo_get_height(bo);
+    stride = KMSDRM_gbm_bo_get_stride(bo);
+    handle = KMSDRM_gbm_bo_get_handle(bo).u32;
+    ret = KMSDRM_drmModeAddFB(viddata->drm_fd, w, h, 24, 32, stride, handle,
+                                  &fb_info->fb_id);
     if (ret) {
       SDL_free(fb_info);
       return NULL;
     }
 
-    /* Set the userdata pointer. This pointer is used to store custom data that we need
-       to access in the future, so we store the fb_id here for later use, because fb_id is
-       what we need to set the FB_ID property of a plane when using the ATOMIC interface. */
+    SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "New DRM FB (%u): %ux%u, stride %u from BO %p",
+                 fb_info->fb_id, w, h, stride, (void *)bo);
+
+    /* Associate our DRM framebuffer with this buffer object */
     KMSDRM_gbm_bo_set_user_data(bo, fb_info, KMSDRM_FBDestroyCallback);
 
     return fb_info;
 }
 
+static void
+KMSDRM_FlipHandler(int fd, unsigned int frame, unsigned int sec, unsigned int usec, void *data)
+{
+    *((SDL_bool *) data) = SDL_FALSE;
+}
+
+SDL_bool
+KMSDRM_WaitPageflip(_THIS, SDL_WindowData *windata) {
+
+    SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
+    drmEventContext ev = {0};
+    struct pollfd pfd = {0};
+    int ret;
+
+    ev.version = DRM_EVENT_CONTEXT_VERSION;
+    ev.page_flip_handler = KMSDRM_FlipHandler;
+
+    pfd.fd = viddata->drm_fd;
+    pfd.events = POLLIN;
+
+    /* Stay on the while loop until we get the desired event.
+       We need the while the loop because we could be in a situation where:
+       -We get and event on the FD in time, thus not on exiting on return number 1.
+       -The event is not an error, thus not exiting on return number 2.
+       -The event is of POLLIN type, but even then, if the event is not a pageflip,
+        drmHandleEvent() won't unset wait_for_pageflip, so we have to iterate
+        and go polling again.
+
+        If it wasn't for the while loop, we could erroneously exit the function
+        without the pageflip event to arrive!
+
+      For example, vblank events hit the FD and they are POLLIN events too (POLLIN
+      means "there's data to read on the FD"), but they are not the pageflip event
+      we are waiting for, so the drmEventHandle() doesn't run the flip handler, and
+      since waiting_for_flip is set on the pageflip handle, it's not set and we stay
+      on the loop, until we get the event for the pageflip, which is fine.
+    */
+    while (windata->waiting_for_flip) {
+
+        pfd.revents = 0;
+
+        /* poll() waits for events arriving on the FD, and returns < 0 if timeout passes
+           with no events or a signal occurred before any requested event (-EINTR).
+           We wait forever (timeout = -1), but even if we DO get an event, we have yet
+           to see if it's of the required type, then if it's a pageflip, etc */
+        ret = poll(&pfd, 1, -1);
+
+        if (ret < 0) {
+            if (errno == EINTR) {
+                /* poll() returning < 0 and setting errno = EINTR means there was a signal before
+                   any requested event, so we immediately poll again. */
+                continue;
+            } else {
+                /* There was another error. Don't pull again or we could get into a busy loop. */
+                SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "DRM poll error");
+                return SDL_FALSE; /* Return number 1. */
+            }
+        }
+
+        if (pfd.revents & (POLLHUP | POLLERR)) {
+            /* An event arrived on the FD in time, but it's an error. */
+            SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "DRM poll hup or error");
+            return SDL_FALSE; /* Return number 2. */
+        }
+
+        if (pfd.revents & POLLIN) {
+            /* There is data to read on the FD!
+               Is the event a pageflip? We know it is a pageflip if it matches the
+               event we are passing in &ev. If it does, drmHandleEvent() will unset
+               windata->waiting_for_flip and we will get out of the "while" loop.
+               If it's not, we keep iterating on the loop. */
+            KMSDRM_drmHandleEvent(viddata->drm_fd, &ev);
+        }
+            
+        /* If we got to this point in the loop, we may iterate or exit the loop:
+           -A legit (non-error) event arrived, and it was a POLLING event, and it was consumed
+            by drmHandleEvent().
+              -If it was a PAGEFLIP event, waiting_for_flip will be unset by drmHandleEvent()
+               and we will exit the loop.
+              -If it wasn't a PAGEFLIP, drmHandleEvent() won't unset waiting_for_flip, so we
+               iterare back to polling.
+           -A legit (non-error) event arrived, but it's not a POLLIN event, so it hasn't to be
+            consumed by drmHandleEvent(), so waiting_for_flip isn't set and we iterate back
+            to polling. */ 
+
+    }
+
+    return SDL_TRUE;
+}
+
+/* Given w, h and refresh rate, returns the closest DRM video mode
+   available on the DRM connector of the display.
+   We use the SDL mode list (which we filled in KMSDRM_GetDisplayModes)
+   because it's ordered, while the list on the connector is mostly random.*/
+static drmModeModeInfo*
+KMSDRM_GetClosestDisplayMode(SDL_VideoDisplay * display,
+uint32_t width, uint32_t height, uint32_t refresh_rate){
+
+    SDL_DisplayData *dispdata = (SDL_DisplayData *) display->driverdata;
+    drmModeConnector *connector = dispdata->connector;
+
+    SDL_DisplayMode target, closest;
+    drmModeModeInfo *drm_mode;
+
+    target.w = width;
+    target.h = height;
+    target.format = 0; /* Will use the default mode format. */
+    target.refresh_rate = refresh_rate;
+    target.driverdata = 0; /* Initialize to 0 */
+
+    if (!SDL_GetClosestDisplayMode(SDL_atoi(display->name), &target, &closest)) {
+        return NULL;
+    } else {
+        SDL_DisplayModeData *modedata = (SDL_DisplayModeData *)closest.driverdata;
+        drm_mode = &connector->modes[modedata->mode_index];
+        return drm_mode;
+    }
+}
+
 /*****************************************************************************/
 /* SDL Video and Display initialization/handling functions                   */
 /* _this is a SDL_VideoDevice *                                              */
 /*****************************************************************************/
 
-/* Deinitializes the dispdata members needed for KMSDRM operation that are
-   inoffeensive for VK compatibility. */
-void KMSDRM_DisplayDataDeinit (_THIS, SDL_DisplayData *dispdata) {
-    /* Free connector */
-    if (dispdata && dispdata->connector) {
-        if (dispdata->connector->connector) {
-            KMSDRM_drmModeFreeConnector(dispdata->connector->connector);
-            dispdata->connector->connector = NULL;
-        }
-        if (dispdata->connector->props_info) {
-            SDL_free(dispdata->connector->props_info);
-            dispdata->connector->props_info = NULL;
-        }
-        SDL_free(dispdata->connector);
-        dispdata->connector = NULL;
-    }
+/* Deinitializes the driverdata of the SDL Displays in the SDL display list. */
+static void
+KMSDRM_DeinitDisplays (_THIS) {
 
-    /* Free CRTC */
-    if (dispdata && dispdata->crtc) {
-        if (dispdata->crtc->crtc) {
-            KMSDRM_drmModeFreeCrtc(dispdata->crtc->crtc);
-            dispdata->crtc->crtc = NULL;
+    SDL_DisplayData *dispdata;
+    int num_displays, i;
+
+    num_displays = SDL_GetNumVideoDisplays();
+
+    /* Iterate on the SDL Display list. */
+    for (i = 0; i < num_displays; i++) {
+  
+        /* Get the driverdata for this display */   
+        dispdata = (SDL_DisplayData *)SDL_GetDisplayDriverData(i);
+
+        /* Free connector */
+        if (dispdata && dispdata->connector) {
+            KMSDRM_drmModeFreeConnector(dispdata->connector);
+            dispdata->connector = NULL;
         }
-        if (dispdata->crtc->props_info) {
-            SDL_free(dispdata->crtc->props_info);
-            dispdata->crtc->props_info = NULL;
+
+        /* Free CRTC */
+        if (dispdata && dispdata->crtc) {
+            KMSDRM_drmModeFreeCrtc(dispdata->crtc);
+            dispdata->crtc = NULL;
         }
-        SDL_free(dispdata->crtc);
-        dispdata->crtc = NULL;
     }
 }
 
-/* Initializes the dispdata members needed for KMSDRM operation that are
-   inoffeensive for VK compatibility, except we must leave the drm_fd
-   closed when we get to the end of this function.
-   This is to be called early, in VideoInit(), because it gets us
-   the videomode information, which SDL needs immediately after VideoInit(). */
-int KMSDRM_DisplayDataInit (_THIS, SDL_DisplayData *dispdata) {
+/* Gets a DRM connector, builds an SDL_Display with it, and adds it to the
+   list of SDL Displays in _this->displays[]  */
+static void
+KMSDRM_AddDisplay (_THIS, drmModeConnector *connector, drmModeRes *resources) {
+
     SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
-
-    drmModeRes *resources = NULL;
+    SDL_DisplayData *dispdata = NULL;
+    SDL_VideoDisplay display = {0};
+    SDL_DisplayModeData *modedata = NULL;
     drmModeEncoder *encoder = NULL;
-    drmModeConnector *connector = NULL;
     drmModeCrtc *crtc = NULL;
-
-    char devname[32];
+    int mode_index;
+    int i, j;
     int ret = 0;
-    unsigned i,j;
 
-    dispdata->atomic_flags = 0;
-    dispdata->atomic_req = NULL;
-    dispdata->kms_fence = NULL;
-    dispdata->gpu_fence = NULL;
-    dispdata->kms_out_fence_fd = -1;
-    dispdata->modeset_pending = SDL_FALSE;
-    dispdata->gbm_init = SDL_FALSE;
-
-    dispdata->display_plane = NULL;
-    dispdata->cursor_plane = NULL;
+    /* Reserve memory for the new display's driverdata. */
+    dispdata = (SDL_DisplayData *) SDL_calloc(1, sizeof(SDL_DisplayData));
+    if (!dispdata) {
+        ret = SDL_OutOfMemory();
+        goto cleanup;
+    }
 
+    /* Initialize some of the members of the new display's driverdata
+       to sane values. */
     dispdata->cursor_bo = NULL;
+    dispdata->cursor_bo_drm_fd = -1;
 
-    /* Open /dev/dri/cardNN */
-    SDL_snprintf(viddata->devpath, sizeof(viddata->devpath), "/dev/dri/card%d", viddata->devindex);
-
-    SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Opening device %s", devname);
-    viddata->drm_fd = open(viddata->devpath, O_RDWR | O_CLOEXEC);
-
-    if (viddata->drm_fd < 0) {
-        ret = SDL_SetError("Could not open %s", devname);
-        goto cleanup;
-    }
-
-    SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Opened DRM FD (%d)", viddata->drm_fd);
-
-    /********************************************/
-    /* Block for enabling ATOMIC compatibility. */
-    /********************************************/
-
-    /* Set ATOMIC & UNIVERSAL PLANES compatibility */
-    ret = set_client_caps(viddata->drm_fd);
-    if (ret) {
-        goto cleanup;
-    }
-
-    /*******************************************/
-    /* Block for getting the ATOMIC resources. */
-    /*******************************************/
-
-    /* Get all of the available connectors / devices / crtcs */
-    resources = KMSDRM_drmModeGetResources(viddata->drm_fd);
-    if (!resources) {
-        ret = SDL_SetError("drmModeGetResources(%d) failed", viddata->drm_fd);
-        goto cleanup;
-    }
-
-    /* Iterate on the available connectors to find a connected connector. */
-    for (i = 0; i < resources->count_connectors; i++) {
-        drmModeConnector *conn = KMSDRM_drmModeGetConnector(viddata->drm_fd,
-            resources->connectors[i]);
-
-        if (!conn) {
-            continue;
-        }
-
-        if (conn->connection == DRM_MODE_CONNECTED && conn->count_modes) {
-            SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Found connector %d with %d modes.",
-                         conn->connector_id, conn->count_modes);
-            connector = conn;
-
-            break;
-        }
-
-        KMSDRM_drmModeFreeConnector(conn);
-    }
-
-    if (!connector) {
-        ret = SDL_SetError("No currently active connector found.");
-        goto cleanup;
-    }
+    /* Since we create and show the default cursor on KMSDRM_InitMouse(),
+       and we call KMSDRM_InitMouse() when we create a window, we have to know
+       if the display used by the window already has a default cursor or not.
+       If we don't, new default cursors would stack up on mouse->cursors and SDL
+       would have to hide and delete them at quit, not to mention the memory leak... */
+    dispdata->default_cursor_init = SDL_FALSE;
 
     /* Try to find the connector's current encoder */
     for (i = 0; i < resources->count_encoders; i++) {
@@ -1088,7 +573,6 @@ int KMSDRM_DisplayDataInit (_THIS, SDL_DisplayData *dispdata) {
         }
 
         if (encoder->encoder_id == connector->encoder_id) {
-            SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Found encoder %d.", encoder->encoder_id);
             break;
         }
 
@@ -1099,10 +583,11 @@ int KMSDRM_DisplayDataInit (_THIS, SDL_DisplayData *dispdata) {
     if (!encoder) {
         /* No encoder was connected, find the first supported one */
         for (i = 0; i < resources->count_encoders; i++) {
-            encoder = KMSDRM_drmModeGetEncoder(viddata->drm_fd, resources->encoders[i]);
+            encoder = KMSDRM_drmModeGetEncoder(viddata->drm_fd,
+                          resources->encoders[i]);
 
             if (!encoder) {
-              continue;
+                continue;
             }
 
             for (j = 0; j < connector->count_encoders; j++) {
@@ -1112,7 +597,7 @@ int KMSDRM_DisplayDataInit (_THIS, SDL_DisplayData *dispdata) {
             }
 
             if (j != connector->count_encoders) {
-              break;
+                break;
             }
 
             KMSDRM_drmModeFreeEncoder(encoder);
@@ -1121,12 +606,10 @@ int KMSDRM_DisplayDataInit (_THIS, SDL_DisplayData *dispdata) {
     }
 
     if (!encoder) {
-        ret = SDL_SetError("No connected encoder found.");
+        ret = SDL_SetError("No connected encoder found for connector.");
         goto cleanup;
     }
 
-    SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Found encoder %d.", encoder->encoder_id);
-
     /* Try to find a CRTC connected to this encoder */
     crtc = KMSDRM_drmModeGetCrtc(viddata->drm_fd, encoder->crtc_id);
 
@@ -1143,112 +626,186 @@ int KMSDRM_DisplayDataInit (_THIS, SDL_DisplayData *dispdata) {
     }
 
     if (!crtc) {
-        ret = SDL_SetError("No CRTC found.");
+        ret = SDL_SetError("No CRTC found for connector.");
         goto cleanup;
     }
 
-    /* Figure out the default mode to be set. */
-    dispdata->mode = crtc->mode;
+    /* Find the index of the mode attached to this CRTC */
+    mode_index = -1;
 
-    /* Find the connector's preferred mode, to be used in case the current mode
-       is not valid, or if restoring the current mode fails.
-       We can always count on the preferred mode! */
     for (i = 0; i < connector->count_modes; i++) {
-        if (connector->modes[i].type & DRM_MODE_TYPE_PREFERRED) {
-            dispdata->preferred_mode = connector->modes[i];
+        drmModeModeInfo *mode = &connector->modes[i];
+
+        if (!SDL_memcmp(mode, &crtc->mode, sizeof(crtc->mode))) {
+          mode_index = i;
+          break;
         }
     }
 
-    /* If the current CRTC's mode isn't valid, select the preferred
-       mode of the connector. */
-    if (crtc->mode_valid == 0) {
-        dispdata->mode = dispdata->preferred_mode;
+    if (mode_index == -1) {
+      ret = SDL_SetError("Failed to find index of mode attached to the CRTC.");
+      goto cleanup;
     }
 
+    /*********************************************/
+    /* Create an SDL Display for this connector. */
+    /*********************************************/
+
+    /*********************************************/
+    /* Part 1: setup the SDL_Display driverdata. */
+    /*********************************************/
+
+    /* Get the mode currently setup for this display,
+       which is the mode currently setup on the CRTC
+       we found for the active connector. */
+    dispdata->mode = crtc->mode;
+    dispdata->original_mode = crtc->mode;
+    dispdata->fullscreen_mode = crtc->mode;
+
     if (dispdata->mode.hdisplay == 0 || dispdata->mode.vdisplay == 0 ) {
         ret = SDL_SetError("Couldn't get a valid connector videomode.");
         goto cleanup;
     }
 
-    /* Get CRTC properties */
-    dispdata->crtc->props = KMSDRM_drmModeObjectGetProperties(viddata->drm_fd,
-        crtc->crtc_id, DRM_MODE_OBJECT_CRTC);
+    /* Store the connector and crtc for this display. */
+    dispdata->connector = connector;
+    dispdata->crtc = crtc;
 
-    dispdata->crtc->props_info = SDL_calloc(dispdata->crtc->props->count_props,
-        sizeof(*dispdata->crtc->props_info));
+    /*****************************************/
+    /* Part 2: setup the SDL_Display itself. */
+    /*****************************************/
 
-    if (!dispdata->crtc->props_info) {
+    /* Setup the display.
+       There's no problem with it being still incomplete. */
+    modedata = SDL_calloc(1, sizeof(SDL_DisplayModeData));
+
+    if (!modedata) {
         ret = SDL_OutOfMemory();
         goto cleanup;
     }
 
-    for (i = 0; i < dispdata->crtc->props->count_props; i++) {
-        dispdata->crtc->props_info[i] = KMSDRM_drmModeGetProperty(viddata->drm_fd,
-        dispdata->crtc->props->props[i]);
-    }
+    modedata->mode_index = mode_index;
 
-    /* Get connector properties */
-    dispdata->connector->props = KMSDRM_drmModeObjectGetProperties(viddata->drm_fd,
-        connector->connector_id, DRM_MODE_OBJECT_CONNECTOR);
+    display.driverdata = dispdata;
+    display.desktop_mode.w = dispdata->mode.hdisplay;
+    display.desktop_mode.h = dispdata->mode.vdisplay;
+    display.desktop_mode.refresh_rate = dispdata->mode.vrefresh;
+    display.desktop_mode.format = SDL_PIXELFORMAT_ARGB8888;
+    display.desktop_mode.driverdata = modedata;
+    display.current_mode = display.desktop_mode;
 
-    dispdata->connector->props_info = SDL_calloc(dispdata->connector->props->count_props,
-        sizeof(*dispdata->connector->props_info));
-
-    if (!dispdata->connector->props_info) {
-        ret = SDL_OutOfMemory();
-        goto cleanup;
-    }
-
-    for (i = 0; i < dispdata->connector->props->count_props; i++) {
-        dispdata->connector->props_info[i] = KMSDRM_drmModeGetProperty(viddata->drm_fd,
-        dispdata->connector->props->props[i]);
-    }
-
-    /* Store the connector and crtc for future use. This is all we keep from this function,
-       and these are just structs, inoffensive to VK. */
-    dispdata->connector->connector = connector;
-    dispdata->crtc->crtc = crtc;
-
-    /***********************************/
-    /* Block fpr Vulkan compatibility. */
-    /***********************************/
-
-    /* THIS IS FOR VULKAN! Leave the FD closed, so VK can work.
-       Will reopen this in CreateWindow, but only if requested a non-VK window. */
-    KMSDRM_drmSetClientCap(viddata->drm_fd, DRM_CLIENT_CAP_ATOMIC, 0);
-    KMSDRM_drmSetClientCap(viddata->drm_fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 0);
-    close (viddata->drm_fd);
-    viddata->drm_fd = -1;
+    /* Add the display to the list of SDL displays. */
+    SDL_AddVideoDisplay(&display, SDL_FALSE);
 
 cleanup:
     if (encoder)
         KMSDRM_drmModeFreeEncoder(encoder);
+    if (ret) {
+        /* Error (complete) cleanup */
+        if (dispdata) {
+            if (dispdata->connector) {
+                KMSDRM_drmModeFreeConnector(dispdata->connector);
+                dispdata->connector = NULL;
+            }
+            if (dispdata->crtc) {
+                KMSDRM_drmModeFreeCrtc(dispdata->crtc);
+                dispdata->crtc = NULL;
+            }
+            SDL_free(dispdata);
+        }
+    }
+}
+
+/* Initializes the list of SDL displays: we build a new display for each
+   connecter connector we find.
+   Inoffeensive for VK compatibility, except we must leave the drm_fd
+   closed when we get to the end of this function.
+   This is to be called early, in VideoInit(), because it gets us
+   the videomode information, which SDL needs immediately after VideoInit(). */
+static int
+KMSDRM_InitDisplays (_THIS) {
+
+    SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
+    drmModeRes *resources = NULL;
+
+    uint64_t async_pageflip = 0;
+    int ret = 0;
+    int i;
+
+    /* Open /dev/dri/cardNN (/dev/drmN if on OpenBSD) */
+    SDL_snprintf(viddata->devpath, sizeof(viddata->devpath), KMSDRM_DRI_CARDPATHFMT, viddata->devindex);
+
+    SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Opening device %s", viddata->devpath);
+    viddata->drm_fd = open(viddata->devpath, O_RDWR | O_CLOEXEC);
+
+    if (viddata->drm_fd < 0) {
+        ret = SDL_SetError("Could not open %s", viddata->devpath);
+        goto cleanup;
+    }
+
+    SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Opened DRM FD (%d)", viddata->drm_fd);
+
+    /* Get all of the available connectors / devices / crtcs */
+    resources = KMSDRM_drmModeGetResources(viddata->drm_fd);
+    if (!resources) {
+        ret = SDL_SetError("drmModeGetResources(%d) failed", viddata->drm_fd);
+        goto cleanup;
+    }
+
+    /* Iterate on the available connectors. For every connected connector,
+       we create an SDL_Display and add it to the list of SDL Displays. */
+    for (i = 0; i < resources->count_connectors; i++) {
+        drmModeConnector *connector = KMSDRM_drmModeGetConnector(viddata->drm_fd,
+            resources->connectors[i]);
+
+        if (!connector) {
+            continue;
+        }
+
+        if (connector->connection == DRM_MODE_CONNECTED && connector->count_modes) {
+            /* If it's a connected connector with available videomodes, try to add
+               an SDL Display representing it. KMSDRM_AddDisplay() is purposely void,
+               so if it fails (no encoder for connector, no valid video mode for
+               connector etc...) we can keep looking for connected connectors. */
+            KMSDRM_AddDisplay(_this, connector, resources);
+        }
+        else {
+            /* If it's not, free it now. */
+            KMSDRM_drmModeFreeConnector(connector);
+        }
+    }
+
+    /* Have we added any SDL displays? */
+    if (!SDL_GetNumVideoDisplays()) {
+        ret = SDL_SetError("No connected displays found.");
+        goto cleanup;
+    }
+
+    /* Determine if video hardware supports async pageflips. */
+    ret = KMSDRM_drmGetCap(viddata->drm_fd, DRM_CAP_ASYNC_PAGE_FLIP, &async_pageflip);
+    if (ret) {
+        SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "Could not determine async page flip capability.");
+    }
+    viddata->async_pageflip_support = async_pageflip ? SDL_TRUE : SDL_FALSE;
+
+    /***********************************/
+    /* Block for Vulkan compatibility. */
+    /***********************************/
+
+    /* THIS IS FOR VULKAN! Leave the FD closed, so VK can work.
+       Will reopen this in CreateWindow, but only if requested a non-VK window. */
+    close (viddata->drm_fd);
+    viddata->drm_fd = -1;
+
+cleanup:
     if (resources)
         KMSDRM_drmModeFreeResources(resources);
     if (ret) {
-        /* Error (complete) cleanup */
-        if (dispdata->connector->connector) {
-            KMSDRM_drmModeFreeConnector(dispdata->connector->connector);
-            dispdata->connector->connector = NULL;
-        }
-        if (dispdata->crtc->props_info) {
-            SDL_free(dispdata->crtc->props_info);
-            dispdata->crtc->props_info = NULL;
-        }
-        if (dispdata->connector->props_info) {
-            SDL_free(dispdata->connector->props_info);
-            dispdata->connector->props_info = NULL;
-        }
-        if (dispdata->crtc->crtc) {
-            KMSDRM_drmModeFreeCrtc(dispdata->crtc->crtc);
-            dispdata->crtc->crtc = NULL;
-        }
         if (viddata->drm_fd >= 0) {
             close(viddata->drm_fd);
             viddata->drm_fd = -1;
         }
     }
-
     return ret;
 }
 
@@ -1260,7 +817,7 @@ cleanup:
    These things are incompatible with Vulkan, which accesses the same resources
    internally so they must be free when trying to build a Vulkan surface.
 */
-int
+static int
 KMSDRM_GBMInit (_THIS, SDL_DisplayData *dispdata)
 {
     SDL_VideoData *viddata = (SDL_VideoData *)_this->driverdata;
@@ -1268,7 +825,9 @@ KMSDRM_GBMInit (_THIS, SDL_DisplayData *dispdata)
 
     /* Reopen the FD! */
     viddata->drm_fd = open(viddata->devpath, O_RDWR | O_CLOEXEC);
-    set_client_caps(viddata->drm_fd);
+
+    /* Set the FD we just opened as current DRM master. */
+    KMSDRM_drmSetMaster(viddata->drm_fd);
 
     /* Create the GBM device. */
     viddata->gbm_dev = KMSDRM_gbm_create_device(viddata->drm_fd);
@@ -1276,30 +835,17 @@ KMSDRM_GBMInit (_THIS, SDL_DisplayData *dispdata)
         ret = SDL_SetError("Couldn't create gbm device.");
     }
 
-    /* Setup the display plane. ONLY do this after dispdata has the right
-       crtc and connector, because these are used in this function. */
-    ret = setup_plane(_this, &(dispdata->display_plane), DRM_PLANE_TYPE_PRIMARY);
-    if (ret) {
-        ret = SDL_SetError("can't find suitable display plane.");
-    }
-
-    dispdata->gbm_init = SDL_TRUE;
+    viddata->gbm_init = SDL_TRUE;
 
     return ret;
 }
 
 /* Deinit the Vulkan-incompatible KMSDRM stuff. */
-void
+static void
 KMSDRM_GBMDeinit (_THIS, SDL_DisplayData *dispdata)
 {
     SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
 
-    /* Free display plane */
-    free_plane(&dispdata->display_plane);
-
-    /* Free cursor plane (if still not freed) */
-    free_plane(&dispdata->cursor_plane);
-
     /* Destroy GBM device. GBM surface is destroyed by DestroySurfaces(),
        already called when we get here. */
     if (viddata->gbm_dev) {
@@ -1313,52 +859,57 @@ KMSDRM_GBMDeinit (_THIS, SDL_DisplayData *dispdata)
         viddata->drm_fd = -1;
     }
 
-    dispdata->gbm_init = SDL_FALSE;
+    viddata->gbm_init = SDL_FALSE;
 }
 
-/* Destroy the window surfaces and buffers. Have the PRIMARY PLANE
-   disconnected from these buffers before doing so, or have the PRIMARY PLANE
-   reading the original FB where the TTY lives, before doing this, or CRTC will
-   be disconnected by the kernel. */
-void
+static void
 KMSDRM_DestroySurfaces(_THIS, SDL_Window *window)
 {
+    SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
     SDL_WindowData *windata = (SDL_WindowData *) window->driverdata;
-    SDL_DisplayData *dispdata = (SDL_DisplayData *)SDL_GetDisplayDriverData(0);
-    KMSDRM_PlaneInfo plane_info = {0};
+    SDL_DisplayData *dispdata = (SDL_DisplayData *) SDL_GetDisplayForWindow(window)->driverdata;
+    int ret;
 
-#if SDL_VIDEO_OPENGL_EGL
-    EGLContext egl_context;
-#endif
+    /**********************************************/
+    /* Wait for last issued pageflip to complete. */
+    /**********************************************/
+    /*KMSDRM_WaitPageflip(_this, windata);*/
 
-    /********************************************************************/
-    /* BLOCK 1: protect the PRIMARY PLANE before destroying the buffers */
-    /* it's using, by making it point to the original CRTC buffer,      */
-    /* where the TTY console should be.                                 */
-    /********************************************************************/
+    /***********************************************************************/
+    /* Restore the original CRTC configuration: configue the crtc with the */
+    /* original video mode and make it point to the original TTY buffer.   */
+    /***********************************************************************/
 
-    plane_info.plane = dispdata->display_plane;
-    plane_info.crtc_id = dispdata->crtc->crtc->crtc_id;
-    plane_info.fb_id = dispdata->crtc->crtc->buffer_id;
-    plane_info.src_w = dispdata->mode.hdisplay;
-    plane_info.src_h = dispdata->mode.vdisplay;
-    plane_info.crtc_w = dispdata->mode.hdisplay;
-    plane_info.crtc_h = dispdata->mode.vdisplay;
+    ret = KMSDRM_drmModeSetCrtc(viddata->drm_fd, dispdata->crtc->crtc_id,
+            dispdata->crtc->buffer_id, 0, 0, &dispdata->connector->connector_id, 1,
+            &dispdata->original_mode);
 
-    drm_atomic_set_plane_props(&plane_info);
-
-    /* Issue blocking atomic commit. */
-    if (drm_atomic_commit(_this, SDL_TRUE)) {
-        SDL_SetError("Failed to issue atomic commit on surfaces destruction.");
+    /* If we failed to set the original mode, try to set the connector prefered mode. */
+    if (ret && (dispdata->crtc->mode_valid == 0)) {
+        ret = KMSDRM_drmModeSetCrtc(viddata->drm_fd, dispdata->crtc->crtc_id,
+                dispdata->crtc->buffer_id, 0, 0, &dispdata->connector->connector_id, 1,
+                &dispdata->original_mode);
     }
 
-    /****************************************************************************/
-    /* BLOCK 2: We can finally destroy the window GBM and EGL surfaces, and     */
-    /* GBM buffers now that the buffers are not being used by the PRIMARY PLANE */
-    /* anymore.                                                                 */
-    /****************************************************************************/
+    if(ret) {
+        SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "Could not restore CRTC");
+    }
+
+    /***************************/
+    /* Destroy the EGL surface */
+    /***************************/
+
+    SDL_EGL_MakeCurrent(_this, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+
+    if (windata->egl_surface != EGL_NO_SURFACE) {
+        SDL_EGL_DestroySurface(_this, windata->egl_surface);
+        windata->egl_surface = EGL_NO_SURFACE;
+    }
+
+    /***************************/
+    /* Destroy the GBM buffers */
+    /***************************/
 
-    /* Destroy the GBM surface and buffers. */
     if (windata->bo) {
         KMSDRM_gbm_surface_release_buffer(windata->gs, windata->bo);
         windata->bo = NULL;
@@ -1369,69 +920,99 @@ KMSDRM_DestroySurfaces(_THIS, SDL_Window *window)
         windata->next_bo = NULL;
     }
 
-    /***************************************************************************/
-    /* Destroy the EGL surface.                                                */
-    /* In this eglMakeCurrent() call, we disable the current EGL surface       */
-    /* because we're going to destroy it, but DON'T disable the EGL context,   */
-    /* because it won't be enabled again until the programs ask for a pageflip */
-    /* so we get to SwapWindow().                                              */
-    /* If we disable the context until then and a program tries to retrieve    */
-    /* the context version info before calling for a pageflip, the program     */
-    /* will get wrong info and we will be in trouble.                          */
-    /***************************************************************************/
-
-#if SDL_VIDEO_OPENGL_EGL
-    egl_context = (EGLContext)SDL_GL_GetCurrentContext();
-    SDL_EGL_MakeCurrent(_this, EGL_NO_SURFACE, egl_context);
-
-    if (windata->egl_surface != EGL_NO_SURFACE) {
-        SDL_EGL_DestroySurface(_this, windata->egl_surface);
-        windata->egl_surface = EGL_NO_SURFACE;
-    }
-#endif
+    /***************************/
+    /* Destroy the GBM surface */
+    /***************************/
 
     if (windata->gs) {
         KMSDRM_gbm_surface_destroy(windata->gs);
         windata->gs = NULL;
     }
-
 }
 
+static void
+KMSDRM_GetModeToSet(SDL_Window *window, drmModeModeInfo *out_mode) {
+    SDL_VideoDisplay *display = SDL_GetDisplayForWindow(window);
+    SDL_DisplayData *dispdata = (SDL_DisplayData *)display->driverdata;
+
+    if ((window->flags & SDL_WINDOW_FULLSCREEN) == SDL_WINDOW_FULLSCREEN) {
+        *out_mode = dispdata->fullscreen_mode;
+    } else {
+        drmModeModeInfo *mode;
+
+        mode = KMSDRM_GetClosestDisplayMode(display,
+          window->windowed.w, window->windowed.h, 0);
+
+        if (mode) {
+            *out_mode = *mode;
+        } else {
+            *out_mode = dispdata->original_mode;
+        }
+    }
+}
+
+static void
+KMSDRM_DirtySurfaces(SDL_Window *window) {
+    SDL_WindowData *windata = (SDL_WindowData *)window->driverdata;
+    drmModeModeInfo mode;
+
+    /* Can't recreate EGL surfaces right now, need to wait until SwapWindow
+       so the correct thread-local surface and context state are available */
+    windata->egl_surface_dirty = SDL_TRUE;
+
+    /* The app may be waiting for the resize event after calling SetWindowSize
+       or SetWindowFullscreen, send a fake event for now since the actual
+       recreation is deferred */
+    KMSDRM_GetModeToSet(window, &mode);
+    SDL_SendWindowEvent(window, SDL_WINDOWEVENT_RESIZED, mode.hdisplay, mode.vdisplay);
+}
+
+/* This determines the size of the fb, which comes from the GBM surface
+   that we create here. */
 int
 KMSDRM_CreateSurfaces(_THIS, SDL_Window * window)
 {
     SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
     SDL_WindowData *windata = (SDL_WindowData *)window->driverdata;
-    SDL_DisplayData *dispdata = (SDL_DisplayData *) SDL_GetDisplayForWindow(window)->driverdata;
+    SDL_VideoDisplay *display = SDL_GetDisplayForWindow(window);
+    SDL_DisplayData *dispdata = (SDL_DisplayData *)display->driverdata;
+
     uint32_t surface_fmt = GBM_FORMAT_ARGB8888;
     uint32_t surface_flags = GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING;
-    uint32_t width, height;
 
     EGLContext egl_context;
 
     int ret = 0;
 
-    if (((window->flags & SDL_WINDOW_FULLSCREEN_DESKTOP) == SDL_WINDOW_FULLSCREEN_DESKTOP) ||
-       ((window->flags & SDL_WINDOW_FULLSCREEN) == SDL_WINDOW_FULLSCREEN)) {
-
-        width = dispdata->mode.hdisplay;
-        height = dispdata->mode.vdisplay;
-    } else {
-        width = window->w;
-        height = window->h;
+    /* If the current window already has surfaces, destroy them before creating other. */
+    if (windata->gs) {
+        KMSDRM_DestroySurfaces(_this, window);
     }
 
-    if (!KMSDRM_gbm_device_is_format_supported(viddata->gbm_dev, surface_fmt, surface_flags)) {
-        SDL_LogWarn(SDL_LOG_CATEGORY_VIDEO, "GBM surface format not supported. Trying anyway.");
+    if (!KMSDRM_gbm_device_is_format_supported(viddata->gbm_dev,
+             surface_fmt, surface_flags)) {
+        SDL_LogWarn(SDL_LOG_CATEGORY_VIDEO,
+        "GBM surface format not supported. Trying anyway.");
     }
 
-    windata->gs = KMSDRM_gbm_surface_create(viddata->gbm_dev, width, height, surface_fmt, surface_flags);
+    /* The KMSDRM backend doesn't always set the mode the higher-level code in
+       SDL_video.c expects. Hulk-smash the display's current_mode to keep the
+       mode that's set in sync with what SDL_video.c thinks is set */
+    KMSDRM_GetModeToSet(window, &dispdata->mode);
+
+    display->current_mode.w = dispdata->mode.hdisplay;
+    display->current_mode.h = dispdata->mode.vdisplay;
+    display->current_mode.refresh_rate = dispdata->mode.vrefresh;
+    display->current_mode.format = SDL_PIXELFORMAT_ARGB8888;
+
+    windata->gs = KMSDRM_gbm_surface_create(viddata->gbm_dev,
+                      dispdata->mode.hdisplay, dispdata->mode.vdisplay,
+                      surface_fmt, surface_flags);
 
     if (!windata->gs) {
         return SDL_SetError("Could not create GBM surface");
     }
 
-#if SDL_VIDEO_OPENGL_EGL
     /* We can't get the EGL context yet because SDL_CreateRenderer has not been called,
        but we need an EGL surface NOW, or GL won't be able to render into any surface
        and we won't see the first frame. */
@@ -1448,7 +1029,10 @@ KMSDRM_CreateSurfaces(_THIS, SDL_Window * window)
     egl_context = (EGLContext)SDL_GL_GetCurrentContext();
     ret = SDL_EGL_MakeCurrent(_this, windata->egl_surface, egl_context);
 
-#endif
+    SDL_SendWindowEvent(window, SDL_WINDOWEVENT_RESIZED,
+                        dispdata->mode.hdisplay, dispdata->mode.vdisplay);
+
+    windata->egl_surface_dirty = SDL_FALSE;
 
 cleanup:
 
@@ -1463,12 +1047,125 @@ cleanup:
     return ret;
 }
 
+int
+KMSDRM_VideoInit(_THIS)
+{
+    int ret = 0;
+
+    SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
+    SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "KMSDRM_VideoInit()");
+
+    viddata->video_init = SDL_FALSE;
+    viddata->gbm_init = SDL_FALSE;
+
+    /* Get KMSDRM resources info and store what we need. Getting and storing
+       this info isn't a problem for VK compatibility.
+       For VK-incompatible initializations we have KMSDRM_GBMInit(), which is
+       called on window creation, and only when we know it's not a VK window. */
+    if (KMSDRM_InitDisplays(_this)) {
+        ret = SDL_SetError("error getting KMSDRM displays information");
+    }
+
+#ifdef SDL_INPUT_LINUXEV
+    SDL_EVDEV_Init();
+#elif defined(SDL_INPUT_WSCONS)
+    SDL_WSCONS_Init();
+#endif
+
+    viddata->video_init = SDL_TRUE;
+
+    return ret;
+}
+
+/* The driverdata pointers, like dispdata, viddata, windata, etc...
+   are freed by SDL internals, so not our job. */
+void
+KMSDRM_VideoQuit(_THIS)
+{
+    SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
+
+    KMSDRM_DeinitDisplays(_this);
+
+#ifdef SDL_INPUT_LINUXEV
+    SDL_EVDEV_Quit();
+#elif defined(SDL_INPUT_WSCONS)
+    SDL_WSCONS_Quit();
+#endif
+
+    /* Clear out the window list */
+    SDL_free(viddata->windows);
+    viddata->windows = NULL;
+    viddata->max_windows = 0;
+    viddata->num_windows = 0;
+    viddata->video_init = SDL_FALSE;
+}
+
+/* Read modes from the connector modes, and store them in display->display_modes. */
+void
+KMSDRM_GetDisplayModes(_THIS, SDL_VideoDisplay * display)
+{
+    SDL_DisplayData *dispdata = display->driverdata;
+    drmModeConnector *conn = dispdata->connector;
+    SDL_DisplayMode mode;
+    int i;
+
+    for (i = 0; i < conn->count_modes; i++) {
+        SDL_DisplayModeData *modedata = SDL_calloc(1, sizeof(SDL_DisplayModeData));
+
+        if (modedata) {
+            modedata->mode_index = i;
+        }
+
+        mode.w = conn->modes[i].hdisplay;
+        mode.h = conn->modes[i].vdisplay;
+        mode.refresh_rate = conn->modes[i].vrefresh;
+        mode.format = SDL_PIXELFORMAT_ARGB8888;
+        mode.driverdata = modedata;
+
+        if (!SDL_AddDisplayMode(display, &mode)) {
+            SDL_free(modedata);
+        }
+    }
+}
+
+int
+KMSDRM_SetDisplayMode(_THIS, SDL_VideoDisplay * display, SDL_DisplayMode * mode)
+{
+    /* Set the dispdata->mode to the new mode and leave actual modesetting
+       pending to be done on SwapWindow() via drmModeSetCrtc() */
+
+    SDL_VideoData *viddata = (SDL_VideoData *)_this->driverdata;
+    SDL_DisplayData *dispdata = (SDL_DisplayData *)display->driverdata;
+    SDL_DisplayModeData *modedata = (SDL_DisplayModeData *)mode->driverdata;
+    drmModeConnector *conn = dispdata->connector;
+    int i;
+
+    /* Don't do anything if we are in Vulkan mode. */
+    if (viddata->vulkan_mode) {
+        return 0;
+    }
+
+    if (!modedata) {
+        return SDL_SetError("Mode doesn't have an associated index");
+    }
+
+    /* Take note of the new mode to be set, and leave the CRTC modeset pending
+       so it's done in SwapWindow. */
+    dispdata->fullscreen_mode = conn->modes[modedata->mode_index];
+
+    for (i = 0; i < viddata->num_windows; i++) {
+        KMSDRM_DirtySurfaces(viddata->windows[i]);
+    }
+
+    return 0;
+}
+
 void
 KMSDRM_DestroyWindow(_THIS, SDL_Window *window)
 {
     SDL_WindowData *windata = (SDL_WindowData *) window->driverdata;
     SDL_DisplayData *dispdata = (SDL_DisplayData *) SDL_GetDisplayForWindow(window)->driverdata;
-    SDL_VideoData *viddata = windata->viddata;
+    SDL_VideoData *viddata;
     SDL_bool is_vulkan = window->flags & SDL_WINDOW_VULKAN; /* Is this a VK window? */
     unsigned int i, j;
 
@@ -1476,16 +1173,38 @@ KMSDRM_DestroyWindow(_THIS, SDL_Window *window)
         return;
     }
 
-    if (!is_vulkan) {
+    viddata = windata->viddata;
+
+    if ( !is_vulkan && viddata->gbm_init) {
+
+        /* Destroy cursor GBM BO of the display of this window. */
+        KMSDRM_DestroyCursorBO(_this, SDL_GetDisplayForWindow(window));
+
+        /* Destroy GBM surface and buffers. */
         KMSDRM_DestroySurfaces(_this, window);
-#if SDL_VIDEO_OPENGL_EGL
-        if (_this->egl_data) {
-            SDL_EGL_UnloadLibrary(_this);
-        }
-#endif
-        if (dispdata->gbm_init) {
-            KMSDRM_DeinitMouse(_this);
-            KMSDRM_GBMDeinit(_this, dispdata);
+
+        /* Unload library and deinit GBM, but only if this is the last window.
+           Note that this is the right comparision because num_windows could be 1
+           if there is a complete window, or 0 if we got here from SDL_CreateWindow()
+           because KMSDRM_CreateWindow() returned an error so the window wasn't
+           added to the windows list. */
+        if (viddata->num_windows <= 1) {
+
+	    /* Unload EGL/GL library and free egl_data.  */
+	    if (_this->egl_data) {
+		SDL_EGL_UnloadLibrary(_this);
+		_this->gl_config.driver_loaded = 0;
+	    }
+
+	    /* Free display plane, and destroy GBM device. */
+	    KMSDRM_GBMDeinit(_this, dispdata);
+	}
+
+    } else {
+
+        /* If we were in Vulkan mode, get out of it. */
+        if (viddata->vulkan_mode) {
+            viddata->vulkan_mode = SDL_FALSE;
         }
     }
 
@@ -1508,232 +1227,15 @@ KMSDRM_DestroyWindow(_THIS, SDL_Window *window)
     /*********************************************************************/
     /* Free the window driverdata. Bye bye, surface and buffer pointers! */
     /*********************************************************************/
+    SDL_free(window->driverdata);
     window->driverdata = NULL;
-    SDL_free(windata);
-}
-
-/*****************************************************************************/
-/* Reconfigure the window scaling parameters and re-construct it's surfaces, */
-/* without destroying the window itself.                                     */
-/* To be used by SetWindowSize() and SetWindowFullscreen().                  */
-/*****************************************************************************/
-static int
-KMSDRM_ReconfigureWindow( _THIS, SDL_Window * window) {
-    SDL_WindowData *windata = window->driverdata;
-    SDL_DisplayData *dispdata = (SDL_DisplayData *) SDL_GetDisplayForWindow(window)->driverdata;
-    SDL_bool is_vulkan = window->flags & SDL_WINDOW_VULKAN; /* Is this a VK window? */
-    float ratio;
-
-    if (((window->flags & SDL_WINDOW_FULLSCREEN_DESKTOP) == SDL_WINDOW_FULLSCREEN_DESKTOP) ||
-       ((window->flags & SDL_WINDOW_FULLSCREEN) == SDL_WINDOW_FULLSCREEN)) {
-
-        windata->src_w = dispdata->mode.hdisplay;
-        windata->src_h = dispdata->mode.vdisplay;
-        windata->output_w = dispdata->mode.hdisplay;
-        windata->output_h = dispdata->mode.vdisplay;
-        windata->output_x = 0;
-
-    } else {
-
-        /* Normal non-fullscreen windows are scaled using the CRTC,
-           so get output (CRTC) size and position, for AR correction. */
-        ratio = (float)window->w / (float)window->h;
-        windata->src_w = window->w;
-        windata->src_h = window->h;
-        windata->output_w = dispdata->mode.vdisplay * ratio;
-        windata->output_h = dispdata->mode.vdisplay;
-        windata->output_x = (dispdata->mode.hdisplay - windata->output_w) / 2;
-
-    }
-
-    if (!is_vulkan) {
-        if (KMSDRM_CreateSurfaces(_this, window)) {
-            return -1;
-        }
-    }
-    return 0;
-}
-
-int
-KMSDRM_VideoInit(_THIS)
-{
-    int ret = 0;
-
-    SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
-    SDL_DisplayData *dispdata = NULL;
-    SDL_VideoDisplay display = {0};
-
-    SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "KMSDRM_VideoInit()");
-
-    viddata->video_init = SDL_FALSE;
-
-    dispdata = (SDL_DisplayData *) SDL_calloc(1, sizeof(SDL_DisplayData));
-    if (!dispdata) {
-        return SDL_OutOfMemory();
-    }
-
-    /* Alloc memory for these. */
-    dispdata->display_plane = SDL_calloc(1, sizeof(*dispdata->display_plane));
-    dispdata->crtc = SDL_calloc(1, sizeof(*dispdata->crtc));
-    dispdata->connector = SDL_calloc(1, sizeof(*dispdata->connector));
-    if (!(dispdata->display_plane) || !(dispdata->crtc) || !(dispdata->connector)) {
-        ret = SDL_OutOfMemory();
-        goto cleanup;
-    }
-
-    /* Get KMSDRM resources info and store what we need. Getting and storing
-       this info isn't a problem for VK compatibility.
-       For VK-incompatible initializations we have KMSDRM_GBMInit(), which is
-       called on window creation, and only when we know it's not a VK window. */
-    if (KMSDRM_DisplayDataInit(_this, dispdata)) {
-        ret = SDL_SetError("error getting KMS/DRM information");
-        goto cleanup;
-    }
-
-    /* Setup the single display that's available.
-       There's no problem with it being still incomplete. */
-    display.driverdata = dispdata;
-    display.desktop_mode.w = dispdata->mode.hdisplay;
-    display.desktop_mode.h = dispdata->mode.vdisplay;
-    display.desktop_mode.refresh_rate = dispdata->mode.vrefresh;
-    display.desktop_mode.format = SDL_PIXELFORMAT_ARGB8888;
-    display.current_mode = display.desktop_mode;
-
-    /* Add the display only when it's ready, */
-    SDL_AddVideoDisplay(&display, SDL_FALSE);
-
-    /* Use this if you ever need to see info on all available planes. */
-#if 0
-    get_planes_info(_this);
-#endif
-
-#ifdef SDL_INPUT_LINUXEV
-    SDL_EVDEV_Init();
-#endif
-
-    viddata->video_init = SDL_TRUE;
-
-cleanup:
-
-    if (ret) {
-        /* Error (complete) cleanup */
-        if (dispdata->display_plane) {
-            SDL_free(dispdata->display_plane);
-        }
-        if (dispdata->crtc) {
-            SDL_free(dispdata->crtc);
-        }
-        if (dispdata->connector) {
-            SDL_free(dispdata->connector);
-        }
-
-        SDL_free(dispdata);
-    }
-
-    return ret;
-}
-
-/* The driverdata pointers, like dispdata, viddata, windata, etc...
-   are freed by SDL internals, so not our job. */
-void
-KMSDRM_VideoQuit(_THIS)
-{
-    SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
-    SDL_DisplayData *dispdata = (SDL_DisplayData *)SDL_GetDisplayDriverData(0);
-
-    KMSDRM_DisplayDataDeinit(_this, dispdata);
-
-#ifdef SDL_INPUT_LINUXEV
-    SDL_EVDEV_Quit();
-#endif
-
-    /* Clear out the window list */
-    SDL_free(viddata->windows);
-    viddata->windows = NULL;
-    viddata->max_windows = 0;
-    viddata->num_windows = 0;
-    viddata->video_init = SDL_FALSE;
-}
-
-#if 0
-void
-KMSDRM_GetDisplayModes(_THIS, SDL_VideoDisplay * display)
-{
-    /* Only one display mode available: the current one */
-    SDL_AddDisplayMode(display, &display->current_mode);
-}
-#endif
-
-/* We only change the video mode for FULLSCREEN windows
-   that are not FULLSCREEN_DESKTOP.
-   Normal non-fullscreen windows are scaled using the CRTC. */
-void
-KMSDRM_GetDisplayModes(_THIS, SDL_VideoDisplay * display)
-{
-    SDL_DisplayData *dispdata = display->driverdata;
-    drmModeConnector *conn = dispdata->connector->connector;
-    SDL_DisplayMode mode;
-    int i;
-
-    for (i = 0; i < conn->count_modes; i++) {
-        SDL_DisplayModeData *modedata = SDL_calloc(1, sizeof(SDL_DisplayModeData));
-
-        if (!modedata) {
-            SDL_OutOfMemory();
-            return;
-        }
-
-        modedata->mode_index = i;
-
-        mode.w = conn->modes[i].hdisplay;
-        mode.h = conn->modes[i].vdisplay;
-        mode.refresh_rate = conn->modes[i].vrefresh;
-        mode.format = SDL_PIXELFORMAT_ARGB8888;
-        mode.driverdata = modedata;
-
-        if (!SDL_AddDisplayMode(display, &mode)) {
-            SDL_free(modedata);
-        }
-    }
-}
-
-int
-KMSDRM_SetDisplayMode(_THIS, SDL_VideoDisplay * display, SDL_DisplayMode * mode)
-{
-    /* Set the dispdata->mode to the new mode and leave actual modesetting
-       pending to be done on SwapWindow(), to be included on next atomic
-       commit changeset. */
-
-    SDL_VideoData *viddata = (SDL_VideoData *)_this->driverdata;
-    SDL_DisplayData *dispdata = (SDL_DisplayData *)display->driverdata;
-    SDL_DisplayModeData *modedata = (SDL_DisplayModeData *)mode->driverdata;
-    drmModeConnector *conn = dispdata->connector->connector;
-    int i;
-
-    if (!modedata) {
-        return SDL_SetError("Mode doesn't have an associated index");
-    }
-
-    /* Take note of the new mode. It will be used in SwapWindow to
-       set the props needed for mode setting. */
-    dispdata->mode = conn->modes[modedata->mode_index];
-
-    dispdata->modeset_pending = SDL_TRUE;
-
-    for (i = 0; i < viddata->num_windows; i++) {
-        SDL_Window *window = viddata->windows[i];
-
-    if (KMSDRM_CreateSurfaces(_this, window)) {
-        return -1;
-    }
-
-        /* Tell app about the window resize */
-        SDL_SendWindowEvent(window, SDL_WINDOWEVENT_RESIZED, mode->w, mode->h);
-    }
-
-    return 0;
 }
 
+/**********************************************************************/
+/* We simply IGNORE if it's a fullscreen window, window->flags don't  */
+/* reflect it: if it's fullscreen, KMSDRM_SetWindwoFullscreen() will  */
+/* be called by SDL later, and we can manage it there.                */
+/**********************************************************************/ 
 int
 KMSDRM_CreateWindow(_THIS, SDL_Window * window)
 {
@@ -1742,81 +1244,93 @@ KMSDRM_CreateWindow(_THIS, SDL_Window * window)
     SDL_VideoDisplay *display = SDL_GetDisplayForWindow(window);
     SDL_DisplayData *dispdata = display->driverdata;
     SDL_bool is_vulkan = window->flags & SDL_WINDOW_VULKAN; /* Is this a VK window? */
+    SDL_bool vulkan_mode = viddata->vulkan_mode; /* Do we have any Vulkan windows? */
     NativeDisplayType egl_display;
-    float ratio;
+    drmModeModeInfo *mode;
     int ret = 0;
 
-    if ( !(dispdata->gbm_init) && (!is_vulkan)) {
-         /* Reopen FD, create gbm dev, setup display plane, etc,.
-            but only when we come here for the first time,
-            and only if it's not a VK window. */
-         if ((ret = KMSDRM_GBMInit(_this, dispdata))) {
-                 goto cleanup;
-         }
-
-#if SDL_VIDEO_OPENGL_EGL
-         /* Manually load the EGL library. KMSDRM_EGL_LoadLibrary() has already
-            been called by SDL_CreateWindow() but we don't do anything there,
-            precisely to be able to load it here.
-            If we let SDL_CreateWindow() load the lib, it will be loaded
-            before we call KMSDRM_GBMInit(), causing GLES programs to fail. */
-         if (!_this->egl_data) {
-             egl_display = (NativeDisplayType)((SDL_VideoData *)_this->driverdata)->gbm_dev;
-             if ((ret = SDL_EGL_LoadLibrary(_this, NULL, egl_display, EGL_PLATFORM_GBM_MESA))) {
-                 goto cleanup;
-             }
-         }
-#endif
-
-         /* Can't init mouse stuff sooner because cursor plane is not ready. */
-         KMSDRM_InitMouse(_this);
-
-         /* Since we take cursor buffer way from the cursor plane and
-            destroy the cursor GBM BO when we destroy a window, we must
-            also manually re-show the cursor on screen, if necessary,
-            when we create a window. */
-         KMSDRM_InitCursor();
-    }
-
     /* Allocate window internal data */
     windata = (SDL_WindowData *)SDL_calloc(1, sizeof(SDL_WindowData));
     if (!windata) {
-        ret = SDL_OutOfMemory();
-        goto cleanup;
+        return(SDL_OutOfMemory());
     }
 
-    if (((window->flags & SDL_WINDOW_FULLSCREEN_DESKTOP) == SDL_WINDOW_FULLSCREEN_DESKTOP) ||
-       ((window->flags & SDL_WINDOW_FULLSCREEN) == SDL_WINDOW_FULLSCREEN))
-    {
-        windata->src_w = dispdata->mode.hdisplay;
-        windata->src_h = dispdata->mode.vdisplay;
-        windata->output_w = dispdata->mode.hdisplay;
-        windata->output_h = dispdata->mode.vdisplay;
-        windata->output_x = 0;
-    } else {
-        /* Normal non-fullscreen windows are scaled using the CRTC,
-           so get output (CRTC) size and position, for AR correction. */
-        ratio = (float)window->w / (float)window->h;
-        windata->src_w = window->w;
-        windata->src_h = window->h;
-        windata->output_w = dispdata->mode.vdisplay * ratio;
-        windata->output_h = dispdata->mode.vdisplay;
-        windata->output_x = (dispdata->mode.hdisplay - windata->output_w) / 2;
-    }
-
-    /* Don't force fullscreen on all windows: it confuses programs that try
-       to set a window fullscreen after creating it as non-fullscreen (sm64ex) */
-    // window->flags |= SDL_WINDOW_FULLSCREEN;
-
     /* Setup driver data for this window */
     windata->viddata = viddata;
     window->driverdata = windata;
 
-    if (!is_vulkan) {
-        if ((ret = KMSDRM_CreateSurfaces(_this, window))) {
-            goto cleanup;
+    if (!is_vulkan && !vulkan_mode) { /* NON-Vulkan block. */
+
+        /* Maybe you didn't ask for an OPENGL window, but that's what you will get.
+           See following comments on why. */
+        window->flags |= SDL_WINDOW_OPENGL;
+
+        if (!(viddata->gbm_init)) {
+
+            /* After SDL_CreateWindow, most SDL2 programs will do SDL_CreateRenderer(),
+               which will in turn call GL_CreateRenderer() or GLES2_CreateRenderer().
+               In order for the GL_CreateRenderer() or GLES2_CreateRenderer() call to
+               succeed without an unnecessary window re-creation, we must: 
+               -Mark the window as being OPENGL
+               -Load the GL library (which can't be done until the GBM device has been
+                created, so we have to do it here instead of doing it on VideoInit())
+                and mark it as loaded by setting gl_config.driver_loaded to 1.
+               So if you ever see KMSDRM_CreateWindow() to be called two times in tests,
+               don't be shy to debug GL_CreateRenderer() or GLES2_CreateRenderer()
+               to find out why!
+             */
+
+            /* Reopen FD, create gbm dev, setup display plane, etc,.
+               but only when we come here for the first time,
+               and only if it's not a VK window. */
+            if ((ret = KMSDRM_GBMInit(_this, dispdata))) {
+                return (SDL_SetError("Can't init GBM on window creation."));
+            }
         }
-    }
+
+	/* Manually load the GL library. KMSDRM_EGL_LoadLibrary() has already
+	   been called by SDL_CreateWindow() but we don't do anything there,
+	   out KMSDRM_EGL_LoadLibrary() is a dummy precisely to be able to load it here.
+	   If we let SDL_CreateWindow() load the lib, it would be loaded
+	   before we call KMSDRM_GBMInit(), causing all GLES programs to fail. */
+	if (!_this->egl_data) {
+	    egl_display = (NativeDisplayType)((SDL_VideoData *)_this->driverdata)->gbm_dev;
+	    if (SDL_EGL_LoadLibrary(_this, NULL, egl_display, EGL_PLATFORM_GBM_MESA)) {
+                return (SDL_SetError("Can't load EGL/GL library on window creation."));
+	    }
+
+	    _this->gl_config.driver_loaded = 1;
+
+	}
+
+	/* Create the cursor BO for the display of this window,
+	   now that we know this is not a VK window. */
+	KMSDRM_CreateCursorBO(display);
+
+	/* Create and set the default cursor for the display
+           of this window, now that we know this is not a VK window. */
+	KMSDRM_InitMouse(_this, display);
+
+        /* The FULLSCREEN flags are cut out from window->flags at this point,
+           so we can't know if a window is fullscreen or not, hence all windows
+           are considered "windowed" at this point of their life.
+           If a window is fullscreen, SDL internals will call
+           KMSDRM_SetWindowFullscreen() to reconfigure it if necessary. */
+        mode = KMSDRM_GetClosestDisplayMode(display,
+                 window->windowed.w, window->windowed.h, 0 );
+
+        if (mode) {
+            dispdata->fullscreen_mode = *mode;
+        } else {
+            dispdata->fullscreen_mode = dispdata->original_mode;
+        }
+
+        /* Create the window surfaces with the size we have just chosen.
+           Needs the window diverdata in place. */
+        if ((ret = KMSDRM_CreateSurfaces(_this, window))) {
+            return (SDL_SetError("Can't window GBM/EGL surfaces on window creation."));
+        }
+    } /* NON-Vulkan block ends. */
 
     /* Add window to the internal list of tracked windows. Note, while it may
        seem odd to support multiple fullscreen windows, some apps create an
@@ -1828,35 +1342,65 @@ KMSDRM_CreateWindow(_THIS, SDL_Window * window)
         viddata->max_windows = new_max_windows;
 
         if (!viddata->windows) {
-            ret = SDL_OutOfMemory();
-            goto cleanup;
+            return (SDL_OutOfMemory());
         }
     }
 
     viddata->windows[viddata->num_windows++] = window;
 
-    /* Focus on the newly created window */
+    /* If we have just created a Vulkan window, establish that we are in Vulkan mode now. */
+    viddata->vulkan_mode = is_vulkan;
+
+    /* Focus on the newly created window.
+       SDL_SetMouseFocus() also takes care of calling KMSDRM_ShowCursor() if necessary. */
     SDL_SetMouseFocus(window);
     SDL_SetKeyboardFocus(window);
 
-    /***********************************************************/
-    /* Tell SDL that the mouse has entered the window using an */
-    /* artificial event: we have no windowing system to tell   */
-    /* SDL that it has happened. This makes SDL set the        */
-    /* SDL_WINDOW_MOUSE_FOCUS on this window, thus fixing      */
-    /* Scummvm sticky-on-sides software cursor.                */
-    /***********************************************************/
-    SDL_SendWindowEvent(window, SDL_WINDOWEVENT_ENTER, 0, 0);
+    /* Tell the app that the window has moved to top-left. */
+    SDL_SendWindowEvent(window, SDL_WINDOWEVENT_MOVED, 0, 0);
 
-cleanup:
-
-    if (ret) {
-        /* Allocated windata will be freed in KMSDRM_DestroyWindow */
-        KMSDRM_DestroyWindow(_this, window);
-    }
+    /* Allocated windata will be freed in KMSDRM_DestroyWindow,
+       and KMSDRM_DestroyWindow() will be called by SDL_CreateWindow()
+       if we return error on any of the previous returns of the function. */ 
     return ret;
 }
 
+int
+KMSDRM_GetWindowGammaRamp(_THIS, SDL_Window * window, Uint16 * ramp)
+{
+    SDL_WindowData *windata = (SDL_WindowData*)window->driverdata;
+    SDL_VideoData *viddata = (SDL_VideoData*)windata->viddata;
+    SDL_VideoDisplay *disp = SDL_GetDisplayForWindow(window);
+    SDL_DisplayData* dispdata = (SDL_DisplayData*)disp->driverdata;
+    if (KMSDRM_drmModeCrtcGetGamma(viddata->drm_fd, dispdata->crtc->crtc_id, 256, &ramp[0*256], &ramp[1*256], &ramp[2*256]) == -1)
+    {
+        return SDL_SetError("Failed to get gamma ramp");
+    }
+    return 0;
+}
+
+int
+KMSDRM_SetWindowGammaRamp(_THIS, SDL_Window * window, const Uint16 * ramp)
+{
+    SDL_WindowData *windata = (SDL_WindowData*)window->driverdata;
+    SDL_VideoData *viddata = (SDL_VideoData*)windata->viddata;
+    SDL_VideoDisplay *disp = SDL_GetDisplayForWindow(window);
+    SDL_DisplayData* dispdata = (SDL_DisplayData*)disp->driverdata;
+    Uint16* tempRamp = SDL_calloc(3 * sizeof(Uint16), 256);
+    if (tempRamp == NULL)
+    {
+        return SDL_OutOfMemory();
+    }
+    SDL_memcpy(tempRamp, ramp, 3 * sizeof(Uint16) * 256);
+    if (KMSDRM_drmModeCrtcSetGamma(viddata->drm_fd, dispdata->crtc->crtc_id, 256, &tempRamp[0*256], &tempRamp[1*256], &tempRamp[2*256]) == -1)
+    {
+        SDL_free(tempRamp);
+        return SDL_SetError("Failed to set gamma ramp");
+    }
+    SDL_free(tempRamp);
+    return 0;
+}
+
 int
 KMSDRM_CreateWindowFrom(_THIS, SDL_Window * window, const void *data)
 {
@@ -1875,23 +1419,23 @@ void
 KMSDRM_SetWindowPosition(_THIS, SDL_Window * window)
 {
 }
-
 void
 KMSDRM_SetWindowSize(_THIS, SDL_Window * window)
 {
-    if (KMSDRM_ReconfigureWindow(_this, window)) {
-        SDL_SetError("Can't reconfigure window on SetWindowSize.");
+    SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
+    if (!viddata->vulkan_mode) {
+        KMSDRM_DirtySurfaces(window);
     }
 }
-
 void
 KMSDRM_SetWindowFullscreen(_THIS, SDL_Window * window, SDL_VideoDisplay * display, SDL_bool fullscreen)
+
 {
-    if (KMSDRM_ReconfigureWindow(_this, window)) {
-        SDL_SetError("Can't reconfigure window on SetWindowFullscreen.");
+    SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
+    if (!viddata->vulkan_mode) {
+        KMSDRM_DirtySurfaces(window);
     }
 }
-
 void
 KMSDRM_ShowWindow(_THIS, SDL_Window * window)
 {
@@ -1915,11 +1459,6 @@ KMSDRM_MinimizeWindow(_THIS, SDL_Window * window)
 void
 KMSDRM_RestoreWindow(_THIS, SDL_Window * window)
 {
-}
-void
-KMSDRM_SetWindowGrab(_THIS, SDL_Window * window, SDL_bool grabbed)
-{
-
 }
 
 /*****************************************************************************/
@@ -1928,16 +1467,22 @@ KMSDRM_SetWindowGrab(_THIS, SDL_Window * window, SDL_bool grabbed)
 SDL_bool
 KMSDRM_GetWindowWMInfo(_THIS, SDL_Window * window, struct SDL_SysWMinfo *info)
 {
-    if (info->version.major <= SDL_MAJOR_VERSION) {
-        return SDL_TRUE;
-    } else {
-        SDL_SetError("application not compiled with SDL %d.%d\n",
-                      SDL_MAJOR_VERSION, SDL_MINOR_VERSION);
-        return SDL_FALSE;
-    }
+     SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
+     const Uint32 version = SDL_VERSIONNUM((Uint32)info->version.major,
+                                           (Uint32)info->version.minor,
+                                           (Uint32)info->version.patch);
 
-    /* Failed to get window manager information */
-    return SDL_FALSE;
+     if (version < SDL_VERSIONNUM(2, 0, 15)) {
+         SDL_SetError("Version must be 2.0.15 or newer");
+         return SDL_FALSE;
+     }
+
+     info->subsystem = SDL_SYSWM_KMSDRM;
+     info->info.kmsdrm.dev_index = viddata->devindex;
+     info->info.kmsdrm.drm_fd = viddata->drm_fd;
+     info->info.kmsdrm.gbm_dev = viddata->gbm_dev;
+
+     return SDL_TRUE;
 }
 
 #endif /* SDL_VIDEO_DRIVER_KMSDRM */
diff --git a/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmvideo.h b/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmvideo.h
index 2cf34522b..ebc863f6e 100644
--- a/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmvideo.h
+++ b/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmvideo.h
@@ -1,7 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
-  Atomic KMSDRM backend by Manuel Alfayate Corchete <redwindwanderer@gmail.com>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -31,19 +30,8 @@
 #include <unistd.h>
 #include <xf86drm.h>
 #include <xf86drmMode.h>
-
 #include <gbm.h>
-#include <assert.h>
-#if SDL_VIDEO_OPENGL_EGL
 #include <EGL/egl.h>
-#include <EGL/eglext.h>
-#endif
-
-/****************************************************************************************/
-/* Driverdata pointers are void struct* used to store backend-specific variables        */
-/* and info that supports the SDL-side structs like SDL Display Devices, SDL_Windows... */
-/* which need to be "supported" with backend-side info and mechanisms to work.          */ 
-/****************************************************************************************/
 
 typedef struct SDL_VideoData
 {
@@ -53,71 +41,48 @@ typedef struct SDL_VideoData
 
     struct gbm_device *gbm_dev;
 
-    SDL_Window **windows;
-    unsigned int max_windows;
-    unsigned int num_windows;
+    SDL_bool video_init;             /* Has VideoInit succeeded? */
+    SDL_bool vulkan_mode;            /* Are we in Vulkan mode? One VK window is enough to be. */
+    SDL_bool async_pageflip_support; /* Does the hardware support async. pageflips? */ 
 
-    SDL_bool video_init;        /* Has VideoInit succeeded? */
+    SDL_Window **windows;
+    int max_windows;
+    int num_windows;
+
+    /* Even if we have several displays, we only have to
+       open 1 FD and create 1 gbm device. */
+    SDL_bool gbm_init;
 
 } SDL_VideoData;
 
-typedef struct plane {
-    drmModePlane *plane;
-    drmModeObjectProperties *props;
-    drmModePropertyRes **props_info;
-} plane;
 
-typedef struct crtc {
-    drmModeCrtc *crtc;
-    drmModeObjectProperties *props;
-    drmModePropertyRes **props_info;
-} crtc;
+typedef struct SDL_DisplayModeData
+{
+    int mode_index;
+} SDL_DisplayModeData;
 
-typedef struct connector {
-    drmModeConnector *connector;
-    drmModeObjectProperties *props;
-    drmModePropertyRes **props_info;
-} connector;
 
-/* More general driverdata info that gives support and substance to the SDL_Display. */
 typedef struct SDL_DisplayData
 {
+    drmModeConnector *connector;
+    drmModeCrtc *crtc;
     drmModeModeInfo mode;
-    drmModeModeInfo preferred_mode;
-    uint32_t atomic_flags;
+    drmModeModeInfo original_mode;
+    drmModeModeInfo fullscreen_mode;
 
-    plane *display_plane;
-    plane *cursor_plane;
-    crtc *crtc;
-    connector *connector;
-
-    /* Central atomic request list, used for the prop
-       changeset related to pageflip in SwapWindow. */ 
-    drmModeAtomicReq *atomic_req;
-
-    int kms_in_fence_fd;
-    int kms_out_fence_fd;
-
-    EGLSyncKHR kms_fence;
-    EGLSyncKHR gpu_fence;
-
-#if SDL_VIDEO_OPENGL_EGL
-    EGLSurface old_egl_surface;
-#endif
-
-    SDL_bool modeset_pending;
-    SDL_bool gbm_init;
+    drmModeCrtc *saved_crtc;    /* CRTC to restore on quit */
 
     /* DRM & GBM cursor stuff lives here, not in an SDL_Cursor's driverdata struct,
        because setting/unsetting up these is done on window creation/destruction,
        where we may not have an SDL_Cursor at all (so no SDL_Cursor driverdata).
        There's only one cursor GBM BO because we only support one cursor. */
     struct gbm_bo *cursor_bo;
+    int cursor_bo_drm_fd;
     uint64_t cursor_w, cursor_h;
 
+    SDL_bool default_cursor_init;
 } SDL_DisplayData;
 
-/* Driverdata info that gives KMSDRM-side support and substance to the SDL_Window. */
 typedef struct SDL_WindowData
 {
     SDL_VideoData *viddata;
@@ -129,65 +94,24 @@ typedef struct SDL_WindowData
     struct gbm_bo *bo;
     struct gbm_bo *next_bo;
 
-#if SDL_VIDEO_OPENGL_EGL
+    SDL_bool waiting_for_flip;
+    SDL_bool double_buffer;
+
     EGLSurface egl_surface;
-#endif
-
-    /* For scaling and AR correction. */
-    int32_t src_w;
-    int32_t src_h;
-    int32_t output_w;
-    int32_t output_h;
-    int32_t output_x;
-
-    /* This dictates what approach we'll use for SwapBuffers. */
-    int (*swap_window)(_THIS, SDL_Window * window);
-
+    SDL_bool egl_surface_dirty;
 } SDL_WindowData;
 
-typedef struct SDL_DisplayModeData
-{
-    int mode_index;
-} SDL_DisplayModeData;
-
 typedef struct KMSDRM_FBInfo
 {
     int drm_fd;         /* DRM file desc */
     uint32_t fb_id;     /* DRM framebuffer ID */
 } KMSDRM_FBInfo;
 
-typedef struct KMSDRM_PlaneInfo
-{
-    struct plane *plane;
-    uint32_t fb_id;
-    uint32_t crtc_id;
-    int32_t src_x;
-    int32_t src_y;
-    int32_t src_w;
-    int32_t src_h;
-    int32_t crtc_x;
-    int32_t crtc_y;
-    int32_t crtc_w;
-    int32_t crtc_h;
-} KMSDRM_PlaneInfo;
-
 /* Helper functions */
-int KMSDRM_CreateEGLSurface(_THIS, SDL_Window * window);
+int KMSDRM_CreateSurfaces(_THIS, SDL_Window * window);
 KMSDRM_FBInfo *KMSDRM_FBFromBO(_THIS, struct gbm_bo *bo);
-
-/* Atomic functions that are used from SDL_kmsdrmopengles.c and SDL_kmsdrmmouse.c */
-void drm_atomic_set_plane_props(struct KMSDRM_PlaneInfo *info); 
-
-void drm_atomic_waitpending(_THIS);
-int drm_atomic_commit(_THIS, SDL_bool blocking);
-int add_plane_property(drmModeAtomicReq *req, struct plane *plane,
-                             const char *name, uint64_t value);
-int add_crtc_property(drmModeAtomicReq *req, struct crtc *crtc,
-                             const char *name, uint64_t value);
-int add_connector_property(drmModeAtomicReq *req, struct connector *connector,
-                             const char *name, uint64_t value);
-int setup_plane(_THIS, struct plane **plane, uint32_t plane_type);
-void free_plane(struct plane **plane);
+KMSDRM_FBInfo *KMSDRM_FBFromBO2(_THIS, struct gbm_bo *bo, int w, int h);
+SDL_bool KMSDRM_WaitPageflip(_THIS, SDL_WindowData *windata);
 
 /****************************************************************************/
 /* SDL_VideoDevice functions declaration                                    */
@@ -205,13 +129,14 @@ void KMSDRM_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon);
 void KMSDRM_SetWindowPosition(_THIS, SDL_Window * window);
 void KMSDRM_SetWindowSize(_THIS, SDL_Window * window);
 void KMSDRM_SetWindowFullscreen(_THIS, SDL_Window * window, SDL_VideoDisplay * _display, SDL_bool fullscreen);
+int KMSDRM_SetWindowGammaRamp(_THIS, SDL_Window * window, const Uint16 * ramp);
+int KMSDRM_GetWindowGammaRamp(_THIS, SDL_Window * window, Uint16 * ramp);
 void KMSDRM_ShowWindow(_THIS, SDL_Window * window);
 void KMSDRM_HideWindow(_THIS, SDL_Window * window);
 void KMSDRM_RaiseWindow(_THIS, SDL_Window * window);
 void KMSDRM_MaximizeWindow(_THIS, SDL_Window * window);
 void KMSDRM_MinimizeWindow(_THIS, SDL_Window * window);
 void KMSDRM_RestoreWindow(_THIS, SDL_Window * window);
-void KMSDRM_SetWindowGrab(_THIS, SDL_Window * window, SDL_bool grabbed);
 void KMSDRM_DestroyWindow(_THIS, SDL_Window * window);
 
 /* Window manager function */
diff --git a/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmvulkan.c b/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmvulkan.c
index b3160ed66..b9ab13c58 100644
--- a/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmvulkan.c
+++ b/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmvulkan.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -182,37 +182,40 @@ SDL_bool KMSDRM_Vulkan_CreateSurface(_THIS,
                                   VkInstance instance,
                                   VkSurfaceKHR *surface)
 {
-    VkPhysicalDevice gpu;
+    VkPhysicalDevice gpu = NULL;
     uint32_t gpu_count;
     uint32_t display_count;
     uint32_t mode_count;
     uint32_t plane_count;
+    uint32_t plane = UINT32_MAX;
 
     VkPhysicalDevice *physical_devices = NULL;
-    VkDisplayPropertiesKHR *displays_props = NULL;
-    VkDisplayModePropertiesKHR *modes_props = NULL;
-    VkDisplayPlanePropertiesKHR *planes_props = NULL;
+    VkPhysicalDeviceProperties *device_props = NULL;
+    VkDisplayPropertiesKHR *display_props = NULL;
+    VkDisplayModePropertiesKHR *mode_props = NULL;
+    VkDisplayPlanePropertiesKHR *plane_props = NULL;
+    VkDisplayPlaneCapabilitiesKHR plane_caps;
 
     VkDisplayModeCreateInfoKHR display_mode_create_info;
     VkDisplaySurfaceCreateInfoKHR display_plane_surface_create_info;
 
     VkExtent2D image_size;
-    VkDisplayModeKHR display_mode;
+    VkDisplayKHR display;
+    VkDisplayModeKHR display_mode = (VkDisplayModeKHR)0;
     VkDisplayModePropertiesKHR display_mode_props = {0};
+    VkDisplayModeParametersKHR new_mode_parameters = { {0, 0}, 0};
+    /* Prefer a plane that supports per-pixel alpha. */
+    VkDisplayPlaneAlphaFlagBitsKHR alpha_mode = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR;
 
     VkResult result;
     SDL_bool ret = SDL_FALSE;
+    SDL_bool valid_gpu = SDL_FALSE;
+    SDL_bool mode_found = SDL_FALSE;
+    SDL_bool plane_supports_display = SDL_FALSE;
 
-    /* We don't receive a display index in KMSDRM_CreateDevice(), only
-       a device index, which determines the GPU to use, but not the output.
-       So we simply use the first connected output (ie, the first connected
-       video output) for now.
-       In other words, change this index to select a different output. Easy! */
-    int display_index = 0;
-
-    int i;
-
-    SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
+    /* Get the display index from the display being used by the window. */
+    int display_index = SDL_atoi(SDL_GetDisplayForWindow(window)->name);
+    int i, j;
 
     /* Get the function pointers for the functions we will use. */
     PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr =
@@ -226,6 +229,10 @@ SDL_bool KMSDRM_Vulkan_CreateSurface(_THIS,
         (PFN_vkEnumeratePhysicalDevices)vkGetInstanceProcAddr(
             instance, "vkEnumeratePhysicalDevices");
 
+    PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties =
+        (PFN_vkGetPhysicalDeviceProperties)vkGetInstanceProcAddr(
+            instance, "vkGetPhysicalDeviceProperties");
+
     PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR =
         (PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)vkGetInstanceProcAddr(
             instance, "vkGetPhysicalDeviceDisplayPropertiesKHR");
@@ -238,14 +245,13 @@ SDL_bool KMSDRM_Vulkan_CreateSurface(_THIS,
         (PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)vkGetInstanceProcAddr(
             instance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR");
 
-    /*PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR =
+    PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR =
         (PFN_vkGetDisplayPlaneSupportedDisplaysKHR)vkGetInstanceProcAddr(
             instance, "vkGetDisplayPlaneSupportedDisplaysKHR");
-    
+
     PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR =
         (PFN_vkGetDisplayPlaneCapabilitiesKHR)vkGetInstanceProcAddr(
             instance, "vkGetDisplayPlaneCapabilitiesKHR");
-    */
 
     PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR =
         (PFN_vkCreateDisplayModeKHR)vkGetInstanceProcAddr(
@@ -273,6 +279,14 @@ SDL_bool KMSDRM_Vulkan_CreateSurface(_THIS,
         goto clean;
     }
 
+    /* A GPU (or physical_device, in vkcube terms) is a physical GPU.
+       A machine with more than one video output doesn't need to have more than one GPU,
+       like the Pi4 which has 1 GPU and 2 video outputs.
+       Just in case, we test that the GPU we choose is Vulkan-capable.
+       If there are new reports about VK init failures, hardcode
+       gpu = physical_devices[0], instead of probing, and go with that.
+    */
+
     /* Get the physical device count. */
     vkEnumeratePhysicalDevices(instance, &gpu_count, NULL);
 
@@ -282,14 +296,33 @@ SDL_bool KMSDRM_Vulkan_CreateSurface(_THIS,
     }
 
     /* Get the physical devices. */
-    physical_devices = malloc(sizeof(VkPhysicalDevice) * gpu_count);
+    physical_devices = SDL_malloc(sizeof(VkPhysicalDevice) * gpu_count);
+    device_props = SDL_malloc(sizeof(VkPhysicalDeviceProperties));
     vkEnumeratePhysicalDevices(instance, &gpu_count, physical_devices);
 
-    /* A GPU (or physical_device, in vkcube terms) is a GPU. A machine with more
-       than one video output doen't need to have more than one GPU, like the Pi4
-       which has 1 GPU and 2 video outputs.
-       We grab the GPU/physical_device with the index we got in KMSDR_CreateDevice(). */
-    gpu = physical_devices[viddata->devindex]; 
+    /* Iterate on the physical devices. */
+    for (i = 0; i < gpu_count; i++) {
+
+        /* Get the physical device properties. */
+        vkGetPhysicalDeviceProperties(
+            physical_devices[i],
+            device_props
+        );
+
+        /* Is this device a real GPU that supports API version 1 at least? */
+        if (device_props->apiVersion >= 1 && 
+           (device_props->deviceType == 1 || device_props->deviceType == 2))
+        {
+            gpu = physical_devices[i];
+            valid_gpu = SDL_TRUE;
+            break;
+        }
+    }
+
+    if (!valid_gpu) {
+        SDL_SetError("Vulkan can't find a valid physical device (gpu).");
+        goto clean;
+    }
 
     /* A display is a video output. 1 GPU can have N displays.
        Vulkan only counts the connected displays.
@@ -301,89 +334,175 @@ SDL_bool KMSDRM_Vulkan_CreateSurface(_THIS,
     }
 
     /* Get the props of the displays of the physical device. */
-    displays_props = (VkDisplayPropertiesKHR *) malloc(display_count * sizeof(*displays_props));
+    display_props = (VkDisplayPropertiesKHR *) SDL_malloc(display_count * sizeof(*display_props));
     vkGetPhysicalDeviceDisplayPropertiesKHR(gpu,
                                            &display_count,
-                                           displays_props);
+                                           display_props);
 
-    /* Get the videomode count for the first display. */
+    /* Get the chosen display based on the display index. */
+    display = display_props[display_index].display;
+
+    /* Get the list of the display videomodes. */
     vkGetDisplayModePropertiesKHR(gpu,
-                                 displays_props[display_index].display,
+                                 display,
                                  &mode_count, NULL);
 
     if (mode_count == 0) {
         SDL_SetError("Vulkan can't find any video modes for display %i (%s)\n", 0,
-                               displays_props[display_index].displayName);
+                               display_props[display_index].displayName);
         goto clean;
     }
 
-    /* Get the props of the videomodes for the first display. */
-    modes_props = (VkDisplayModePropertiesKHR *) malloc(mode_count * sizeof(*modes_props));
+    mode_props = (VkDisplayModePropertiesKHR *) SDL_malloc(mode_count * sizeof(*mode_props));
     vkGetDisplayModePropertiesKHR(gpu,
-                                 displays_props[display_index].display,
-                                 &mode_count, modes_props);
+                                 display,
+                                 &mode_count, mode_props);
 
-    /* Get the planes count of the physical device. */
+    /* Get a video mode equal to the window size among the predefined ones,
+       if possible.
+       REMEMBER: We have to get a small enough videomode for the window size,
+       because videomode determines how big the scanout region is and we can't
+       scanout a region bigger than the window (we would be reading past the
+       buffer, and Vulkan would give us a confusing VK_ERROR_SURFACE_LOST_KHR). */
+    for (i = 0; i < mode_count; i++) {
+        if (mode_props[i].parameters.visibleRegion.width == window->w &&
+            mode_props[i].parameters.visibleRegion.height == window->h)
+        {
+            display_mode_props = mode_props[i];
+            mode_found = SDL_TRUE;
+            break;
+        }
+    }
+
+    if (mode_found &&
+        display_mode_props.parameters.visibleRegion.width > 0 &&
+        display_mode_props.parameters.visibleRegion.height > 0 ) {
+        /* Found a suitable mode among the predefined ones. Use that. */
+        display_mode = display_mode_props.displayMode;
+    } else {
+
+        /* Couldn't find a suitable mode among the predefined ones, so try to create our own.
+           This won't work for some video chips atm (like Pi's VideoCore) so these are limited
+           to supported resolutions. Don't try to use "closest" resolutions either, because
+           those are often bigger than the window size, thus causing out-of-bunds scanout. */
+        new_mode_parameters.visibleRegion.width = window->w;
+        new_mode_parameters.visibleRegion.height = window->h;
+        /* SDL (and DRM, if we look at drmModeModeInfo vrefresh) uses plain integer Hz for
+           display mode refresh rate, but Vulkan expects higher precision. */
+        new_mode_parameters.refreshRate = window->fullscreen_mode.refresh_rate * 1000;
+
+        SDL_zero(display_mode_create_info);
+        display_mode_create_info.sType = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR;
+        display_mode_create_info.parameters = new_mode_parameters;
+        result = vkCreateDisplayModeKHR(gpu,
+                                        display,
+                                        &display_mode_create_info,
+                                        NULL, &display_mode);
+        if (result != VK_SUCCESS) {
+            SDL_SetError("Vulkan couldn't find a predefined mode for that window size and couldn't create a suitable mode.");
+            goto clean;
+        }
+    }
+
+    /* Just in case we get here without a display_mode. */
+    if (!display_mode) {
+            SDL_SetError("Vulkan couldn't get a display mode.");
+            goto clean;
+    }
+
+    /* Get the list of the physical device planes. */
     vkGetPhysicalDeviceDisplayPlanePropertiesKHR(gpu, &plane_count, NULL);
     if (plane_count == 0) {
         SDL_SetError("Vulkan can't find any planes.");
         goto clean;
     }
+    plane_props = SDL_malloc(sizeof(VkDisplayPlanePropertiesKHR) * plane_count);
+    vkGetPhysicalDeviceDisplayPlanePropertiesKHR(gpu, &plane_count, plane_props);
 
-    /* Get the props of the planes for the physical device. */
-    planes_props = malloc(sizeof(VkDisplayPlanePropertiesKHR) * plane_count);
-    vkGetPhysicalDeviceDisplayPlanePropertiesKHR(gpu, &plane_count, planes_props);
+    /* Iterate on the list of planes of the physical device
+       to find a plane that matches these criteria:
+       -It must be compatible with the chosen display + mode.
+       -It isn't currently bound to another display.
+       -It supports per-pixel alpha, if possible. */
+    for (i = 0; i < plane_count; i++) {
 
-    /* Get a video mode equal or smaller than the window size. REMEMBER:
-       We have to get a small enough videomode for the window size,
-       because videomode determines how big the scanout region is and we can't
-       scanout a region bigger than the window (we would be reading past the
-       buffer, and Vulkan would give us a confusing VK_ERROR_SURFACE_LOST_KHR). */
-    for (i = 0; i < mode_count; i++) {
-        if (modes_props[i].parameters.visibleRegion.width <= window->w &&
-            modes_props[i].parameters.visibleRegion.height <= window->h)
-        {
-            display_mode_props = modes_props[i];
+        uint32_t supported_displays_count = 0;
+        VkDisplayKHR* supported_displays;
+
+        /* See if the plane is compatible with the current display. */
+        vkGetDisplayPlaneSupportedDisplaysKHR(gpu, i, &supported_displays_count, NULL);
+        if (supported_displays_count == 0) {
+            /* This plane doesn't support any displays. Continue to the next plane. */
+            continue;
+        }
+
+        /* Get the list of displays supported by this plane. */
+        supported_displays = (VkDisplayKHR*)SDL_malloc(sizeof(VkDisplayKHR) * supported_displays_count);
+        vkGetDisplayPlaneSupportedDisplaysKHR(gpu, i,
+            &supported_displays_count, supported_displays);
+
+        /* The plane must be bound to the chosen display, or not in use.
+           If none of these is true, iterate to another plane. */
+        if (!((plane_props[i].currentDisplay == display) ||
+              (plane_props[i].currentDisplay == VK_NULL_HANDLE))) 
+            continue;
+
+        /* Iterate the list of displays supported by this plane
+           in order to find out if the chosen display is among them. */
+        plane_supports_display = SDL_FALSE;
+        for (j = 0; j < supported_displays_count; j++) {
+            if (supported_displays[j] == display) {
+                plane_supports_display = SDL_TRUE;
+                break;
+            }
+        }
+
+        /* Free the list of displays supported by this plane. */
+        if (supported_displays) {
+            SDL_free(supported_displays);
+        }
+
+        /* If the display is not supported by this plane, iterate to the next plane. */
+        if (!plane_supports_display) {
+            continue;
+        }
+
+        /* Want a plane that supports the alpha mode we have chosen. */
+        vkGetDisplayPlaneCapabilitiesKHR(gpu, display_mode, i, &plane_caps);
+        if (plane_caps.supportedAlpha == alpha_mode) {
+            /* Yep, this plane is alright. */
+            plane = i;
             break;
         }
     }
 
-    if (display_mode_props.parameters.visibleRegion.width == 0
-        || display_mode_props.parameters.visibleRegion.height == 0)
-    {
-        SDL_SetError("Vulkan can't find a proper display mode for the window size.");
-        goto clean;
-    }
-
-    /* We have the props of the display mode, but we need an actual display mode. */
-    display_mode_create_info.sType = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR;
-    display_mode_create_info.parameters = display_mode_props.parameters;
-    result = vkCreateDisplayModeKHR(gpu,
-			      displays_props[display_index].display,
-			      &display_mode_create_info,
-			      NULL, &display_mode);
-    if (result != VK_SUCCESS) {
-        SDL_SetError("Vulkan can't create the display mode.");
+    /* If we couldn't find an appropiate plane, error out. */
+    if (plane == UINT32_MAX) {
+        SDL_SetError("Vulkan couldn't find an appropiate plane.");
         goto clean;
     }
 
+    /********************************************/
     /* Let's finally create the Vulkan surface! */
+    /********************************************/
 
     image_size.width = window->w;
     image_size.height = window->h;
     
+    SDL_zero(display_plane_surface_create_info);
     display_plane_surface_create_info.sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
     display_plane_surface_create_info.displayMode = display_mode;
-    /* For now, simply use the first plane. */
-    display_plane_surface_create_info.planeIndex = 0;
+    display_plane_surface_create_info.planeIndex = plane;
     display_plane_surface_create_info.imageExtent = image_size;
+    display_plane_surface_create_info.transform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
+    display_plane_surface_create_info.alphaMode = alpha_mode;
     result = vkCreateDisplayPlaneSurfaceKHR(instance,
                                      &display_plane_surface_create_info,
                                      NULL,
                                      surface);
     if(result != VK_SUCCESS)
     {
-        SDL_SetError("vkCreateKMSDRMSurfaceKHR failed: %s",
+        SDL_SetError("vkCreateDisplayPlaneSurfaceKHR failed: %s",
             SDL_Vulkan_GetResultString(result));
         goto clean;
     }
@@ -392,13 +511,15 @@ SDL_bool KMSDRM_Vulkan_CreateSurface(_THIS,
 
 clean:
     if (physical_devices)
-        free (physical_devices);
-    if (displays_props)
-        free (displays_props);
-    if (planes_props)
-        free (planes_props);
-    if (modes_props)
-        free (modes_props);
+        SDL_free (physical_devices);
+    if (display_props)
+        SDL_free (display_props);
+    if (device_props)
+        SDL_free (device_props);
+    if (plane_props)
+        SDL_free (plane_props);
+    if (mode_props)
+        SDL_free (mode_props);
 
     return ret;
 }
diff --git a/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmvulkan.h b/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmvulkan.h
index 2ee04bb9e..92d08732c 100644
--- a/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmvulkan.h
+++ b/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmvulkan.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -26,8 +26,8 @@
 
 #include "../../SDL_internal.h"
 
-#ifndef SDL_kmsdrmvulkan_h_
-#define SDL_kmsdrmvulkan_h_
+#ifndef SDL_kmsdrm_vulkan_h_
+#define SDL_kmsdrm_vulkan_h_
 
 #include "../SDL_vulkan_internal.h"
 #include "../SDL_sysvideo.h"
@@ -48,6 +48,6 @@ SDL_bool KMSDRM_Vulkan_CreateSurface(_THIS,
 
 #endif
 
-#endif /* SDL_kmsdrmvulkan_h_ */
+#endif /* SDL_kmsdrm_vulkan_h_ */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_dyn.c b/Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_dyn.c
deleted file mode 100644
index 019c8e188..000000000
--- a/Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_dyn.c
+++ /dev/null
@@ -1,167 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "../../SDL_internal.h"
-
-#if SDL_VIDEO_DRIVER_KMSDRM
-
-#define DEBUG_DYNAMIC_KMSDRM_LEGACY 0
-
-#include "SDL_kmsdrm_legacy_dyn.h"
-
-#ifdef SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC
-
-#include "SDL_name.h"
-#include "SDL_loadso.h"
-
-typedef struct
-{
-    void *lib;
-    const char *libname;
-} kmsdrmdynlib;
-
-#ifndef SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC
-#define SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC NULL
-#endif
-#ifndef SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC_GBM
-#define SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC_GBM NULL
-#endif
-
-static kmsdrmdynlib kmsdrmlibs[] = {
-    {NULL, SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC_GBM},
-    {NULL, SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC}
-};
-
-static void *
-KMSDRM_LEGACY_GetSym(const char *fnname, int *pHasModule)
-{
-    int i;
-    void *fn = NULL;
-    for (i = 0; i < SDL_TABLESIZE(kmsdrmlibs); i++) {
-        if (kmsdrmlibs[i].lib != NULL) {
-            fn = SDL_LoadFunction(kmsdrmlibs[i].lib, fnname);
-            if (fn != NULL)
-                break;
-        }
-    }
-
-#if DEBUG_DYNAMIC_KMSDRM_LEGACY
-    if (fn != NULL)
-        SDL_Log("KMSDRM_LEGACY: Found '%s' in %s (%p)\n", fnname, kmsdrmlibs[i].libname, fn);
-    else
-        SDL_Log("KMSDRM_LEGACY: Symbol '%s' NOT FOUND!\n", fnname);
-#endif
-
-    if (fn == NULL)
-        *pHasModule = 0;  /* kill this module. */
-
-    return fn;
-}
-
-#endif /* SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC */
-
-/* Define all the function pointers and wrappers... */
-#define SDL_KMSDRM_LEGACY_MODULE(modname) int SDL_KMSDRM_LEGACY_HAVE_##modname = 0;
-#define SDL_KMSDRM_LEGACY_SYM(rc,fn,params) SDL_DYNKMSDRM_LEGACYFN_##fn KMSDRM_LEGACY_##fn = NULL;
-#define SDL_KMSDRM_LEGACY_SYM_CONST(type,name) SDL_DYNKMSDRM_LEGACYCONST_##name KMSDRM_LEGACY_##name = NULL;
-#include "SDL_kmsdrm_legacy_sym.h"
-
-static int kmsdrm_load_refcount = 0;
-
-void
-SDL_KMSDRM_LEGACY_UnloadSymbols(void)
-{
-    /* Don't actually unload if more than one module is using the libs... */
-    if (kmsdrm_load_refcount > 0) {
-        if (--kmsdrm_load_refcount == 0) {
-#ifdef SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC
-            int i;
-#endif
-
-            /* set all the function pointers to NULL. */
-#define SDL_KMSDRM_LEGACY_MODULE(modname) SDL_KMSDRM_LEGACY_HAVE_##modname = 0;
-#define SDL_KMSDRM_LEGACY_SYM(rc,fn,params) KMSDRM_LEGACY_##fn = NULL;
-#define SDL_KMSDRM_LEGACY_SYM_CONST(type,name) KMSDRM_LEGACY_##name = NULL;
-#include "SDL_kmsdrm_legacy_sym.h"
-
-
-#ifdef SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC
-            for (i = 0; i < SDL_TABLESIZE(kmsdrmlibs); i++) {
-                if (kmsdrmlibs[i].lib != NULL) {
-                    SDL_UnloadObject(kmsdrmlibs[i].lib);
-                    kmsdrmlibs[i].lib = NULL;
-                }
-            }
-#endif
-        }
-    }
-}
-
-/* returns non-zero if all needed symbols were loaded. */
-int
-SDL_KMSDRM_LEGACY_LoadSymbols(void)
-{
-    int rc = 1;                 /* always succeed if not using Dynamic KMSDRM_LEGACY stuff. */
-
-    /* deal with multiple modules needing these symbols... */
-    if (kmsdrm_load_refcount++ == 0) {
-#ifdef SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC
-        int i;
-        int *thismod = NULL;
-        for (i = 0; i < SDL_TABLESIZE(kmsdrmlibs); i++) {
-            if (kmsdrmlibs[i].libname != NULL) {
-                kmsdrmlibs[i].lib = SDL_LoadObject(kmsdrmlibs[i].libname);
-            }
-        }
-
-#define SDL_KMSDRM_LEGACY_MODULE(modname) SDL_KMSDRM_LEGACY_HAVE_##modname = 1; /* default yes */
-#include "SDL_kmsdrm_legacy_sym.h"
-
-#define SDL_KMSDRM_LEGACY_MODULE(modname) thismod = &SDL_KMSDRM_LEGACY_HAVE_##modname;
-#define SDL_KMSDRM_LEGACY_SYM(rc,fn,params) KMSDRM_LEGACY_##fn = (SDL_DYNKMSDRM_LEGACYFN_##fn) KMSDRM_LEGACY_GetSym(#fn,thismod);
-#define SDL_KMSDRM_LEGACY_SYM_CONST(type,name) KMSDRM_LEGACY_##name = *(SDL_DYNKMSDRM_LEGACYCONST_##name*) KMSDRM_LEGACY_GetSym(#name,thismod);
-#include "SDL_kmsdrm_legacy_sym.h"
-
-        if ((SDL_KMSDRM_LEGACY_HAVE_LIBDRM) && (SDL_KMSDRM_LEGACY_HAVE_GBM)) {
-            /* all required symbols loaded. */
-            SDL_ClearError();
-        } else {
-            /* in case something got loaded... */
-            SDL_KMSDRM_LEGACY_UnloadSymbols();
-            rc = 0;
-        }
-
-#else  /* no dynamic KMSDRM_LEGACY */
-
-#define SDL_KMSDRM_LEGACY_MODULE(modname) SDL_KMSDRM_LEGACY_HAVE_##modname = 1; /* default yes */
-#define SDL_KMSDRM_LEGACY_SYM(rc,fn,params) KMSDRM_LEGACY_##fn = fn;
-#define SDL_KMSDRM_LEGACY_SYM_CONST(type,name) KMSDRM_LEGACY_##name = name;
-#include "SDL_kmsdrm_legacy_sym.h"
-
-#endif
-    }
-
-    return rc;
-}
-
-#endif /* SDL_VIDEO_DRIVER_KMSDRM */
-
-/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_mouse.c b/Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_mouse.c
deleted file mode 100644
index c980ebba6..000000000
--- a/Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_mouse.c
+++ /dev/null
@@ -1,502 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "../../SDL_internal.h"
-
-#if SDL_VIDEO_DRIVER_KMSDRM
-
-#include "SDL_kmsdrm_legacy_video.h"
-#include "SDL_kmsdrm_legacy_mouse.h"
-#include "SDL_kmsdrm_legacy_dyn.h"
-
-#include "../../events/SDL_mouse_c.h"
-#include "../../events/default_cursor.h"
-
-static SDL_Cursor *KMSDRM_LEGACY_CreateDefaultCursor(void);
-static SDL_Cursor *KMSDRM_LEGACY_CreateCursor(SDL_Surface * surface, int hot_x, int hot_y);
-static int KMSDRM_LEGACY_ShowCursor(SDL_Cursor * cursor);
-static void KMSDRM_LEGACY_MoveCursor(SDL_Cursor * cursor);
-static void KMSDRM_LEGACY_FreeCursor(SDL_Cursor * cursor);
-static void KMSDRM_LEGACY_WarpMouse(SDL_Window * window, int x, int y);
-static int KMSDRM_LEGACY_WarpMouseGlobal(int x, int y);
-
-static SDL_Cursor *
-KMSDRM_LEGACY_CreateDefaultCursor(void)
-{
-    return SDL_CreateCursor(default_cdata, default_cmask, DEFAULT_CWIDTH, DEFAULT_CHEIGHT, DEFAULT_CHOTX, DEFAULT_CHOTY);
-}
-
-/* Evaluate if a given cursor size is supported or not. Notably, current Intel gfx only support 64x64 and up. */
-static SDL_bool
-KMSDRM_LEGACY_IsCursorSizeSupported (int w, int h, uint32_t bo_format) {
-
-    SDL_VideoDevice *dev = SDL_GetVideoDevice();
-    SDL_VideoData *viddata = ((SDL_VideoData *)dev->driverdata);
-    SDL_DisplayData *dispdata = (SDL_DisplayData *)SDL_GetDisplayDriverData(0);
-
-    int ret;
-    uint32_t bo_handle;
-    struct gbm_bo *bo = KMSDRM_LEGACY_gbm_bo_create(viddata->gbm, w, h, bo_format,
-                                       GBM_BO_USE_CURSOR | GBM_BO_USE_WRITE);
-
-    if (!bo) {
-        SDL_SetError("Could not create GBM cursor BO width size %dx%d for size testing", w, h);
-        goto cleanup;
-    }
-
-    bo_handle = KMSDRM_LEGACY_gbm_bo_get_handle(bo).u32;
-    ret = KMSDRM_LEGACY_drmModeSetCursor(viddata->drm_fd, dispdata->crtc_id, bo_handle, w, h);
-
-    if (ret) {
-        goto cleanup;
-    }
-    else {
-        KMSDRM_LEGACY_gbm_bo_destroy(bo);
-        return SDL_TRUE;
-    }
-
-cleanup:
-    if (bo) {
-        KMSDRM_LEGACY_gbm_bo_destroy(bo);
-    }
-    return SDL_FALSE;
-}
-
-/* Create a cursor from a surface */
-static SDL_Cursor *
-KMSDRM_LEGACY_CreateCursor(SDL_Surface * surface, int hot_x, int hot_y)
-{
-    SDL_VideoDevice *dev = SDL_GetVideoDevice();
-    SDL_VideoData *viddata = ((SDL_VideoData *)dev->driverdata);
-    SDL_PixelFormat *pixlfmt = surface->format;
-    KMSDRM_LEGACY_CursorData *curdata;
-    SDL_Cursor *cursor;
-    SDL_bool cursor_supported = SDL_FALSE;
-    int i, ret, usable_cursor_w, usable_cursor_h;
-    uint32_t bo_format, bo_stride;
-    char *buffer = NULL;
-    size_t bufsize;
-
-    switch(pixlfmt->format) {
-    case SDL_PIXELFORMAT_RGB332:
-        bo_format = GBM_FORMAT_RGB332;
-        break;
-    case SDL_PIXELFORMAT_ARGB4444:
-        bo_format = GBM_FORMAT_ARGB4444;
-        break;
-    case SDL_PIXELFORMAT_RGBA4444:
-        bo_format = GBM_FORMAT_RGBA4444;
-        break;
-    case SDL_PIXELFORMAT_ABGR4444:
-        bo_format = GBM_FORMAT_ABGR4444;
-        break;
-    case SDL_PIXELFORMAT_BGRA4444:
-        bo_format = GBM_FORMAT_BGRA4444;
-        break;
-    case SDL_PIXELFORMAT_ARGB1555:
-        bo_format = GBM_FORMAT_ARGB1555;
-        break;
-    case SDL_PIXELFORMAT_RGBA5551:
-        bo_format = GBM_FORMAT_RGBA5551;
-        break;
-    case SDL_PIXELFORMAT_ABGR1555:
-        bo_format = GBM_FORMAT_ABGR1555;
-        break;
-    case SDL_PIXELFORMAT_BGRA5551:
-        bo_format = GBM_FORMAT_BGRA5551;
-        break;
-    case SDL_PIXELFORMAT_RGB565:
-        bo_format = GBM_FORMAT_RGB565;
-        break;
-    case SDL_PIXELFORMAT_BGR565:
-        bo_format = GBM_FORMAT_BGR565;
-        break;
-    case SDL_PIXELFORMAT_RGB888:
-    case SDL_PIXELFORMAT_RGB24:
-        bo_format = GBM_FORMAT_RGB888;
-        break;
-    case SDL_PIXELFORMAT_BGR888:
-    case SDL_PIXELFORMAT_BGR24:
-        bo_format = GBM_FORMAT_BGR888;
-        break;
-    case SDL_PIXELFORMAT_RGBX8888:
-        bo_format = GBM_FORMAT_RGBX8888;
-        break;
-    case SDL_PIXELFORMAT_BGRX8888:
-        bo_format = GBM_FORMAT_BGRX8888;
-        break;
-    case SDL_PIXELFORMAT_ARGB8888:
-        bo_format = GBM_FORMAT_ARGB8888;
-        break;
-    case SDL_PIXELFORMAT_RGBA8888:
-        bo_format = GBM_FORMAT_RGBA8888;
-        break;
-    case SDL_PIXELFORMAT_ABGR8888:
-        bo_format = GBM_FORMAT_ABGR8888;
-        break;
-    case SDL_PIXELFORMAT_BGRA8888:
-        bo_format = GBM_FORMAT_BGRA8888;
-        break;
-    case SDL_PIXELFORMAT_ARGB2101010:
-        bo_format = GBM_FORMAT_ARGB2101010;
-        break;
-    default:
-        SDL_SetError("Unsupported pixel format for cursor");
-        return NULL;
-    }
-
-    if (!KMSDRM_LEGACY_gbm_device_is_format_supported(viddata->gbm, bo_format, GBM_BO_USE_CURSOR | GBM_BO_USE_WRITE)) {
-        SDL_SetError("Unsupported pixel format for cursor");
-        return NULL;
-    }
-
-    cursor = (SDL_Cursor *) SDL_calloc(1, sizeof(*cursor));
-    if (!cursor) {
-        SDL_OutOfMemory();
-        return NULL;
-    }
-    curdata = (KMSDRM_LEGACY_CursorData *) SDL_calloc(1, sizeof(*curdata));
-    if (!curdata) {
-        SDL_OutOfMemory();
-        SDL_free(cursor);
-        return NULL;
-    }
-
-    /* We have to know beforehand if a cursor with the same size as the surface is supported.
-     * If it's not, we have to find an usable cursor size and use an intermediate and clean buffer.
-     * If we can't find a cursor size supported by the hardware, we won't go on trying to 
-     * call SDL_SetCursor() later. */
-
-    usable_cursor_w = surface->w;
-    usable_cursor_h = surface->h;
-
-    while (usable_cursor_w <= MAX_CURSOR_W && usable_cursor_h <= MAX_CURSOR_H) { 
-        if (KMSDRM_LEGACY_IsCursorSizeSupported(usable_cursor_w, usable_cursor_h, bo_format)) {
-            cursor_supported = SDL_TRUE;
-            break;
-        }
-        usable_cursor_w += usable_cursor_w;
-        usable_cursor_h += usable_cursor_h;
-    }
-
-    if (!cursor_supported) {
-        SDL_SetError("Could not find a cursor size supported by the kernel driver");
-        goto cleanup;
-    }
-
-    curdata->hot_x = hot_x;
-    curdata->hot_y = hot_y;
-    curdata->w = usable_cursor_w;
-    curdata->h = usable_cursor_h;
-
-    curdata->bo = KMSDRM_LEGACY_gbm_bo_create(viddata->gbm, usable_cursor_w, usable_cursor_h, bo_format,
-                                       GBM_BO_USE_CURSOR | GBM_BO_USE_WRITE);
-
-    if (!curdata->bo) {
-        SDL_SetError("Could not create GBM cursor BO");
-        goto cleanup;
-    }
-
-    bo_stride = KMSDRM_LEGACY_gbm_bo_get_stride(curdata->bo);
-    bufsize = bo_stride * curdata->h;
-
-    if (surface->pitch != bo_stride) {
-        /* pitch doesn't match stride, must be copied to temp buffer  */
-        buffer = SDL_malloc(bufsize);
-        if (!buffer) {
-            SDL_OutOfMemory();
-            goto cleanup;
-        }
-
-        if (SDL_MUSTLOCK(surface)) {
-            if (SDL_LockSurface(surface) < 0) {
-                /* Could not lock surface */
-                goto cleanup;
-            }
-        }
-
-        /* Clean the whole temporary buffer */
-        SDL_memset(buffer, 0x00, bo_stride * curdata->h);
-
-        /* Copy to temporary buffer */
-        for (i = 0; i < surface->h; i++) {
-            SDL_memcpy(buffer + (i * bo_stride),
-                       ((char *)surface->pixels) + (i * surface->pitch),
-                       surface->w * pixlfmt->BytesPerPixel);
-        }
-
-        if (SDL_MUSTLOCK(surface)) {
-            SDL_UnlockSurface(surface);
-        }
-
-        if (KMSDRM_LEGACY_gbm_bo_write(curdata->bo, buffer, bufsize)) {
-            SDL_SetError("Could not write to GBM cursor BO");
-            goto cleanup;
-        }
-
-        /* Free temporary buffer */
-        SDL_free(buffer);
-        buffer = NULL;
-    } else {
-        /* surface matches BO format */
-        if (SDL_MUSTLOCK(surface)) {
-            if (SDL_LockSurface(surface) < 0) {
-                /* Could not lock surface */
-                goto cleanup;
-            }
-        }
-
-        ret = KMSDRM_LEGACY_gbm_bo_write(curdata->bo, surface->pixels, bufsize);
-
-        if (SDL_MUSTLOCK(surface)) {
-            SDL_UnlockSurface(surface);
-        }
-
-        if (ret) {
-            SDL_SetError("Could not write to GBM cursor BO");
-            goto cleanup;
-        }
-    }
-
-    cursor->driverdata = curdata;
-
-    return cursor;
-
-cleanup:
-    if (buffer) {
-        SDL_free(buffer);
-    }
-    if (cursor) {
-        SDL_free(cursor);
-    }
-    if (curdata) {
-        if (curdata->bo) {
-            KMSDRM_LEGACY_gbm_bo_destroy(curdata->bo);
-        }
-        SDL_free(curdata);
-    }
-    return NULL;
-}
-
-/* Show the specified cursor, or hide if cursor is NULL */
-static int
-KMSDRM_LEGACY_ShowCursor(SDL_Cursor * cursor)
-{
-    SDL_VideoDevice *dev = SDL_GetVideoDevice();
-    SDL_VideoData *viddata = ((SDL_VideoData *)dev->driverdata);
-    SDL_Mouse *mouse;
-    KMSDRM_LEGACY_CursorData *curdata;
-    SDL_VideoDisplay *display = NULL;
-    SDL_DisplayData *dispdata = NULL;
-    int ret;
-    uint32_t bo_handle;
-
-    mouse = SDL_GetMouse();
-    if (!mouse) {
-        return SDL_SetError("No mouse.");
-    }
-
-    if (mouse->focus) {
-        display = SDL_GetDisplayForWindow(mouse->focus);
-        if (display) {
-            dispdata = (SDL_DisplayData*) display->driverdata;
-        }
-    }
-
-    if (!cursor) {
-        /* Hide current cursor */
-        if (mouse->cur_cursor && mouse->cur_cursor->driverdata) {
-            curdata = (KMSDRM_LEGACY_CursorData *) mouse->cur_cursor->driverdata;
-
-            if (curdata->crtc_id != 0) {
-                ret = KMSDRM_LEGACY_drmModeSetCursor(viddata->drm_fd, curdata->crtc_id, 0, 0, 0);
-                if (ret) {
-                    SDL_SetError("Could not hide current cursor with drmModeSetCursor().");
-                    return ret;
-                }
-                /* Mark previous cursor as not-displayed */
-                curdata->crtc_id = 0;
-
-                return 0;
-            }
-        }
-        /* otherwise if possible, hide global cursor */
-        if (dispdata && dispdata->crtc_id != 0) {
-            ret = KMSDRM_LEGACY_drmModeSetCursor(viddata->drm_fd, dispdata->crtc_id, 0, 0, 0);
-            if (ret) {
-                SDL_SetError("Could not hide display's cursor with drmModeSetCursor().");
-                return ret;
-            }
-            return 0;
-        }
-
-        return SDL_SetError("Couldn't find cursor to hide.");
-    }
-    /* If cursor != NULL, show new cursor on display */
-    if (!display) {
-        return SDL_SetError("Could not get display for mouse.");
-    }
-    if (!dispdata) {
-        return SDL_SetError("Could not get display driverdata.");
-    }
-
-    curdata = (KMSDRM_LEGACY_CursorData *) cursor->driverdata;
-    if (!curdata || !curdata->bo) {
-        return SDL_SetError("Cursor not initialized properly.");
-    }
-
-    bo_handle = KMSDRM_LEGACY_gbm_bo_get_handle(curdata->bo).u32;
-    if (curdata->hot_x == 0 && curdata->hot_y == 0) {
-        ret = KMSDRM_LEGACY_drmModeSetCursor(viddata->drm_fd, dispdata->crtc_id, bo_handle,
-                                      curdata->w, curdata->h);
-    } else {
-        ret = KMSDRM_LEGACY_drmModeSetCursor2(viddata->drm_fd, dispdata->crtc_id, bo_handle,
-                                       curdata->w, curdata->h, curdata->hot_x, curdata->hot_y);
-    }
-    if (ret) {
-        SDL_SetError("drmModeSetCursor failed.");
-        return ret;
-    }
-
-    curdata->crtc_id = dispdata->crtc_id;
-
-    return 0;
-}
-
-/* Free a window manager cursor */
-static void
-KMSDRM_LEGACY_FreeCursor(SDL_Cursor * cursor)
-{
-    KMSDRM_LEGACY_CursorData *curdata;
-    int drm_fd;
-
-    if (cursor) {
-        curdata = (KMSDRM_LEGACY_CursorData *) cursor->driverdata;
-
-        if (curdata) {
-            if (curdata->bo) {
-                if (curdata->crtc_id != 0) {
-                    drm_fd = KMSDRM_LEGACY_gbm_device_get_fd(KMSDRM_LEGACY_gbm_bo_get_device(curdata->bo));
-                    /* Hide the cursor if previously shown on a CRTC */
-                    KMSDRM_LEGACY_drmModeSetCursor(drm_fd, curdata->crtc_id, 0, 0, 0);
-                    curdata->crtc_id = 0;
-                }
-                KMSDRM_LEGACY_gbm_bo_destroy(curdata->bo);
-                curdata->bo = NULL;
-            }
-            SDL_free(cursor->driverdata);
-        }
-        SDL_free(cursor);
-    }
-}
-
-/* Warp the mouse to (x,y) */
-static void
-KMSDRM_LEGACY_WarpMouse(SDL_Window * window, int x, int y)
-{
-    /* Only one global/fullscreen window is supported */
-    KMSDRM_LEGACY_WarpMouseGlobal(x, y);
-}
-
-/* Warp the mouse to (x,y) */
-static int
-KMSDRM_LEGACY_WarpMouseGlobal(int x, int y)
-{
-    KMSDRM_LEGACY_CursorData *curdata;
-    SDL_Mouse *mouse = SDL_GetMouse();
-
-    if (mouse && mouse->cur_cursor && mouse->cur_cursor->driverdata) {
-        /* Update internal mouse position. */
-        SDL_SendMouseMotion(mouse->focus, mouse->mouseID, 0, x, y);
-
-        /* And now update the cursor graphic position on screen. */
-        curdata = (KMSDRM_LEGACY_CursorData *) mouse->cur_cursor->driverdata;
-        if (curdata->bo) {
-
-            if (curdata->crtc_id != 0) {
-                int ret, drm_fd;
-                drm_fd = KMSDRM_LEGACY_gbm_device_get_fd(KMSDRM_LEGACY_gbm_bo_get_device(curdata->bo));
-                ret = KMSDRM_LEGACY_drmModeMoveCursor(drm_fd, curdata->crtc_id, x, y);
-
-                if (ret) {
-                    SDL_SetError("drmModeMoveCursor() failed.");
-                }
-
-                return ret;
-            } else {
-                return SDL_SetError("Cursor is not currently shown.");
-            }
-        } else {
-            return SDL_SetError("Cursor not initialized properly.");
-        }
-    } else {
-        return SDL_SetError("No mouse or current cursor.");
-    }
-}
-
-void
-KMSDRM_LEGACY_InitMouse(_THIS)
-{
-    /* FIXME: Using UDEV it should be possible to scan all mice
-     * but there's no point in doing so as there's no multimice support...yet!
-     */
-    SDL_Mouse *mouse = SDL_GetMouse();
-
-    mouse->CreateCursor = KMSDRM_LEGACY_CreateCursor;
-    mouse->ShowCursor = KMSDRM_LEGACY_ShowCursor;
-    mouse->MoveCursor = KMSDRM_LEGACY_MoveCursor;
-    mouse->FreeCursor = KMSDRM_LEGACY_FreeCursor;
-    mouse->WarpMouse = KMSDRM_LEGACY_WarpMouse;
-    mouse->WarpMouseGlobal = KMSDRM_LEGACY_WarpMouseGlobal;
-
-    SDL_SetDefaultCursor(KMSDRM_LEGACY_CreateDefaultCursor());
-}
-
-void
-KMSDRM_LEGACY_QuitMouse(_THIS)
-{
-    /* TODO: ? */
-}
-
-/* This is called when a mouse motion event occurs */
-static void
-KMSDRM_LEGACY_MoveCursor(SDL_Cursor * cursor)
-{
-    SDL_Mouse *mouse = SDL_GetMouse();
-    KMSDRM_LEGACY_CursorData *curdata;
-    int drm_fd, ret;
-
-    /* We must NOT call SDL_SendMouseMotion() here or we will enter recursivity!
-       That's why we move the cursor graphic ONLY. */
-    if (mouse && mouse->cur_cursor && mouse->cur_cursor->driverdata) {
-        curdata = (KMSDRM_LEGACY_CursorData *) mouse->cur_cursor->driverdata;
-        drm_fd = KMSDRM_LEGACY_gbm_device_get_fd(KMSDRM_LEGACY_gbm_bo_get_device(curdata->bo));
-        ret = KMSDRM_LEGACY_drmModeMoveCursor(drm_fd, curdata->crtc_id, mouse->x, mouse->y);
-
-        if (ret) {
-            SDL_SetError("drmModeMoveCursor() failed.");
-        }
-    }
-}
-
-#endif /* SDL_VIDEO_DRIVER_KMSDRM */
-
-/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_opengles.c b/Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_opengles.c
deleted file mode 100644
index 890801891..000000000
--- a/Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_opengles.c
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "../../SDL_internal.h"
-
-#if SDL_VIDEO_DRIVER_KMSDRM && SDL_VIDEO_OPENGL_EGL
-
-#include "SDL_log.h"
-
-#include "SDL_kmsdrm_legacy_video.h"
-#include "SDL_kmsdrm_legacy_opengles.h"
-#include "SDL_kmsdrm_legacy_dyn.h"
-
-#ifndef EGL_PLATFORM_GBM_MESA
-#define EGL_PLATFORM_GBM_MESA 0x31D7
-#endif
-
-/* EGL implementation of SDL OpenGL support */
-
-int
-KMSDRM_LEGACY_GLES_LoadLibrary(_THIS, const char *path) {
-    NativeDisplayType display = (NativeDisplayType)((SDL_VideoData *)_this->driverdata)->gbm;
-    return SDL_EGL_LoadLibrary(_this, path, display, EGL_PLATFORM_GBM_MESA);
-}
-
-SDL_EGL_CreateContext_impl(KMSDRM_LEGACY)
-
-int KMSDRM_LEGACY_GLES_SetSwapInterval(_THIS, int interval) {
-    if (!_this->egl_data) {
-        return SDL_SetError("EGL not initialized");
-    }
-
-    if (interval == 0 || interval == 1) {
-        _this->egl_data->egl_swapinterval = interval;
-    } else {
-        return SDL_SetError("Only swap intervals of 0 or 1 are supported");
-    }
-
-    return 0;
-}
-
-int
-KMSDRM_LEGACY_GLES_SwapWindow(_THIS, SDL_Window * window) {
-    SDL_WindowData *windata = ((SDL_WindowData *) window->driverdata);
-    SDL_DisplayData *dispdata = (SDL_DisplayData *) SDL_GetDisplayForWindow(window)->driverdata;
-    SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
-    KMSDRM_LEGACY_FBInfo *fb_info;
-    int ret, timeout;
-
-    /* Recreate the GBM / EGL surfaces if the display mode has changed */
-    if (windata->egl_surface_dirty) {
-        KMSDRM_LEGACY_CreateSurfaces(_this, window);
-    }
-
-    /* Wait for confirmation that the next front buffer has been flipped, at which
-       point the previous front buffer can be released */
-    timeout = 0;
-    if (_this->egl_data->egl_swapinterval == 1) {
-        timeout = -1;
-    }
-    if (!KMSDRM_LEGACY_WaitPageFlip(_this, windata, timeout)) {
-        return 0;
-    }
-
-    /* Release the previous front buffer */
-    if (windata->curr_bo) {
-        KMSDRM_LEGACY_gbm_surface_release_buffer(windata->gs, windata->curr_bo);
-        /* SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Released GBM surface %p", (void *)windata->curr_bo); */
-        windata->curr_bo = NULL;
-    }
-
-    windata->curr_bo = windata->next_bo;
-
-    /* Make the current back buffer the next front buffer */
-    if (!(_this->egl_data->eglSwapBuffers(_this->egl_data->egl_display, windata->egl_surface))) {
-        SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "eglSwapBuffers failed.");
-        return 0;
-    }
-
-    /* Lock the next front buffer so it can't be allocated as a back buffer */
-    windata->next_bo = KMSDRM_LEGACY_gbm_surface_lock_front_buffer(windata->gs);
-    if (!windata->next_bo) {
-        SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "Could not lock GBM surface front buffer");
-        return 0;
-    /* } else {
-        SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Locked GBM surface %p", (void *)windata->next_bo); */
-    }
-
-    fb_info = KMSDRM_LEGACY_FBFromBO(_this, windata->next_bo);
-    if (!fb_info) {
-        return 0;
-    }
-
-    if (!windata->curr_bo) {
-        /* On the first swap, immediately present the new front buffer. Before
-           drmModePageFlip can be used the CRTC has to be configured to use
-           the current connector and mode with drmModeSetCrtc */
-        ret = KMSDRM_LEGACY_drmModeSetCrtc(viddata->drm_fd, dispdata->crtc_id, fb_info->fb_id, 0,
-                                    0, &dispdata->conn->connector_id, 1, &dispdata->mode);
-
-        if (ret) {
-          SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "Could not configure CRTC");
-        }
-    } else {
-        /* On subsequent swaps, queue the new front buffer to be flipped during
-           the next vertical blank */
-        ret = KMSDRM_LEGACY_drmModePageFlip(viddata->drm_fd, dispdata->crtc_id, fb_info->fb_id,
-                                     DRM_MODE_PAGE_FLIP_EVENT, &windata->waiting_for_flip);
-        /* SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "drmModePageFlip(%d, %u, %u, DRM_MODE_PAGE_FLIP_EVENT, &windata->waiting_for_flip)",
-            viddata->drm_fd, displaydata->crtc_id, fb_info->fb_id); */
-
-        if (_this->egl_data->egl_swapinterval == 1) {
-            if (ret == 0) {
-                windata->waiting_for_flip = SDL_TRUE;
-            } else {
-                SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "Could not queue pageflip: %d", ret);
-            }
-        }
-
-        /* Wait immediately for vsync (as if we only had two buffers), for low input-lag scenarios.
-           Run your SDL2 program with "SDL_KMSDRM_LEGACY_DOUBLE_BUFFER=1 <program_name>" to enable this. */
-        if (_this->egl_data->egl_swapinterval == 1 && windata->double_buffer) {
-            KMSDRM_LEGACY_WaitPageFlip(_this, windata, -1);
-        }
-    }
-
-    return 0;
-}
-
-SDL_EGL_MakeCurrent_impl(KMSDRM_LEGACY)
-
-#endif /* SDL_VIDEO_DRIVER_KMSDRM && SDL_VIDEO_OPENGL_EGL */
-
-/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_opengles.h b/Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_opengles.h
deleted file mode 100644
index 5e5ba96dc..000000000
--- a/Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_opengles.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-#include "../../SDL_internal.h"
-
-#ifndef SDL_kmsdrmopengles_h_
-#define SDL_kmsdrmopengles_h_
-
-#if SDL_VIDEO_DRIVER_KMSDRM && SDL_VIDEO_OPENGL_EGL
-
-#include "../SDL_sysvideo.h"
-#include "../SDL_egl_c.h"
-
-/* OpenGLES functions */
-#define KMSDRM_LEGACY_GLES_GetAttribute SDL_EGL_GetAttribute
-#define KMSDRM_LEGACY_GLES_GetProcAddress SDL_EGL_GetProcAddress
-#define KMSDRM_LEGACY_GLES_UnloadLibrary SDL_EGL_UnloadLibrary
-#define KMSDRM_LEGACY_GLES_DeleteContext SDL_EGL_DeleteContext
-#define KMSDRM_LEGACY_GLES_GetSwapInterval SDL_EGL_GetSwapInterval
-
-extern int KMSDRM_LEGACY_GLES_SetSwapInterval(_THIS, int interval);
-extern int KMSDRM_LEGACY_GLES_LoadLibrary(_THIS, const char *path);
-extern SDL_GLContext KMSDRM_LEGACY_GLES_CreateContext(_THIS, SDL_Window * window);
-extern int KMSDRM_LEGACY_GLES_SwapWindow(_THIS, SDL_Window * window);
-extern int KMSDRM_LEGACY_GLES_MakeCurrent(_THIS, SDL_Window * window, SDL_GLContext context);
-
-#endif /* SDL_VIDEO_DRIVER_KMSDRM && SDL_VIDEO_OPENGL_EGL */
-
-#endif /* SDL_kmsdrmopengles_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_sym.h b/Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_sym.h
deleted file mode 100644
index 8c41608fc..000000000
--- a/Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_sym.h
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/* *INDENT-OFF* */
-
-#ifndef SDL_KMSDRM_LEGACY_MODULE
-#define SDL_KMSDRM_LEGACY_MODULE(modname)
-#endif
-
-#ifndef SDL_KMSDRM_LEGACY_SYM
-#define SDL_KMSDRM_LEGACY_SYM(rc,fn,params)
-#endif
-
-#ifndef SDL_KMSDRM_LEGACY_SYM_CONST
-#define SDL_KMSDRM_LEGACY_SYM_CONST(type, name)
-#endif
-
-
-SDL_KMSDRM_LEGACY_MODULE(LIBDRM)
-SDL_KMSDRM_LEGACY_SYM(void,drmModeFreeResources,(drmModeResPtr ptr))
-SDL_KMSDRM_LEGACY_SYM(void,drmModeFreeFB,(drmModeFBPtr ptr))
-SDL_KMSDRM_LEGACY_SYM(void,drmModeFreeCrtc,(drmModeCrtcPtr ptr))
-SDL_KMSDRM_LEGACY_SYM(void,drmModeFreeConnector,(drmModeConnectorPtr ptr))
-SDL_KMSDRM_LEGACY_SYM(void,drmModeFreeEncoder,(drmModeEncoderPtr ptr))
-SDL_KMSDRM_LEGACY_SYM(drmModeResPtr,drmModeGetResources,(int fd))
-SDL_KMSDRM_LEGACY_SYM(int,drmModeAddFB,(int fd, uint32_t width, uint32_t height, uint8_t depth,
-                                 uint8_t bpp, uint32_t pitch, uint32_t bo_handle,
-                                 uint32_t *buf_id))
-SDL_KMSDRM_LEGACY_SYM(int,drmModeRmFB,(int fd, uint32_t bufferId))
-SDL_KMSDRM_LEGACY_SYM(drmModeFBPtr,drmModeGetFB,(int fd, uint32_t buf))
-SDL_KMSDRM_LEGACY_SYM(drmModeCrtcPtr,drmModeGetCrtc,(int fd, uint32_t crtcId))
-SDL_KMSDRM_LEGACY_SYM(int,drmModeSetCrtc,(int fd, uint32_t crtcId, uint32_t bufferId,
-                                   uint32_t x, uint32_t y, uint32_t *connectors, int count,
-                                   drmModeModeInfoPtr mode))
-SDL_KMSDRM_LEGACY_SYM(int,drmModeSetCursor,(int fd, uint32_t crtcId, uint32_t bo_handle,
-                                     uint32_t width, uint32_t height))
-SDL_KMSDRM_LEGACY_SYM(int,drmModeSetCursor2,(int fd, uint32_t crtcId, uint32_t bo_handle,
-                                      uint32_t width, uint32_t height,
-                                      int32_t hot_x, int32_t hot_y))
-SDL_KMSDRM_LEGACY_SYM(int,drmModeMoveCursor,(int fd, uint32_t crtcId, int x, int y))
-SDL_KMSDRM_LEGACY_SYM(drmModeEncoderPtr,drmModeGetEncoder,(int fd, uint32_t encoder_id))
-SDL_KMSDRM_LEGACY_SYM(drmModeConnectorPtr,drmModeGetConnector,(int fd, uint32_t connector_id))
-SDL_KMSDRM_LEGACY_SYM(int,drmHandleEvent,(int fd,drmEventContextPtr evctx))
-SDL_KMSDRM_LEGACY_SYM(int,drmModePageFlip,(int fd, uint32_t crtc_id, uint32_t fb_id,
-                                    uint32_t flags, void *user_data))
-
-
-SDL_KMSDRM_LEGACY_MODULE(GBM)
-SDL_KMSDRM_LEGACY_SYM(int,gbm_device_get_fd,(struct gbm_device *gbm))
-SDL_KMSDRM_LEGACY_SYM(int,gbm_device_is_format_supported,(struct gbm_device *gbm,
-                                                   uint32_t format, uint32_t usage))
-SDL_KMSDRM_LEGACY_SYM(void,gbm_device_destroy,(struct gbm_device *gbm))
-SDL_KMSDRM_LEGACY_SYM(struct gbm_device *,gbm_create_device,(int fd))
-SDL_KMSDRM_LEGACY_SYM(unsigned int,gbm_bo_get_width,(struct gbm_bo *bo))
-SDL_KMSDRM_LEGACY_SYM(unsigned int,gbm_bo_get_height,(struct gbm_bo *bo))
-SDL_KMSDRM_LEGACY_SYM(uint32_t,gbm_bo_get_stride,(struct gbm_bo *bo))
-SDL_KMSDRM_LEGACY_SYM(union gbm_bo_handle,gbm_bo_get_handle,(struct gbm_bo *bo))
-SDL_KMSDRM_LEGACY_SYM(int,gbm_bo_write,(struct gbm_bo *bo, const void *buf, size_t count))
-SDL_KMSDRM_LEGACY_SYM(struct gbm_device *,gbm_bo_get_device,(struct gbm_bo *bo))
-SDL_KMSDRM_LEGACY_SYM(void,gbm_bo_set_user_data,(struct gbm_bo *bo, void *data,
-                                          void (*destroy_user_data)(struct gbm_bo *, void *)))
-SDL_KMSDRM_LEGACY_SYM(void *,gbm_bo_get_user_data,(struct gbm_bo *bo))
-SDL_KMSDRM_LEGACY_SYM(void,gbm_bo_destroy,(struct gbm_bo *bo))
-SDL_KMSDRM_LEGACY_SYM(struct gbm_bo *,gbm_bo_create,(struct gbm_device *gbm,
-                                              uint32_t width, uint32_t height,
-                                              uint32_t format, uint32_t usage))
-SDL_KMSDRM_LEGACY_SYM(struct gbm_surface *,gbm_surface_create,(struct gbm_device *gbm,
-                                                        uint32_t width, uint32_t height,
-                                                        uint32_t format, uint32_t flags))
-SDL_KMSDRM_LEGACY_SYM(void,gbm_surface_destroy,(struct gbm_surface *surf))
-SDL_KMSDRM_LEGACY_SYM(struct gbm_bo *,gbm_surface_lock_front_buffer,(struct gbm_surface *surf))
-SDL_KMSDRM_LEGACY_SYM(void,gbm_surface_release_buffer,(struct gbm_surface *surf, struct gbm_bo *bo))
-
-
-#undef SDL_KMSDRM_LEGACY_MODULE
-#undef SDL_KMSDRM_LEGACY_SYM
-#undef SDL_KMSDRM_LEGACY_SYM_CONST
-
-/* *INDENT-ON* */
-
-/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_video.c b/Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_video.c
deleted file mode 100644
index 36b1899bd..000000000
--- a/Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_video.c
+++ /dev/null
@@ -1,934 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "../../SDL_internal.h"
-
-#if SDL_VIDEO_DRIVER_KMSDRM
-
-/* SDL internals */
-#include "../SDL_sysvideo.h"
-#include "SDL_syswm.h"
-#include "SDL_log.h"
-#include "SDL_hints.h"
-#include "../../events/SDL_events_c.h"
-#include "../../events/SDL_mouse_c.h"
-#include "../../events/SDL_keyboard_c.h"
-
-#ifdef SDL_INPUT_LINUXEV
-#include "../../core/linux/SDL_evdev.h"
-#endif
-
-/* KMS/DRM declarations */
-#include "SDL_kmsdrm_legacy_video.h"
-#include "SDL_kmsdrm_legacy_events.h"
-#include "SDL_kmsdrm_legacy_opengles.h"
-#include "SDL_kmsdrm_legacy_mouse.h"
-#include "SDL_kmsdrm_legacy_dyn.h"
-#include <sys/stat.h>
-#include <dirent.h>
-#include <errno.h>
-#include <poll.h>
-
-#define KMSDRM_LEGACY_DRI_PATH "/dev/dri/"
-
-static int
-check_modestting(int devindex)
-{
-    SDL_bool available = SDL_FALSE;
-    char device[512];
-    int drm_fd;
-
-    SDL_snprintf(device, sizeof (device), "%scard%d", KMSDRM_LEGACY_DRI_PATH, devindex);
-
-    drm_fd = open(device, O_RDWR | O_CLOEXEC);
-    if (drm_fd >= 0) {
-        if (SDL_KMSDRM_LEGACY_LoadSymbols()) {
-            drmModeRes *resources = KMSDRM_LEGACY_drmModeGetResources(drm_fd);
-            if (resources) {
-                SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "%scard%d connector, encoder and CRTC counts are: %d %d %d",
-                             KMSDRM_LEGACY_DRI_PATH, devindex,
-                             resources->count_connectors, resources->count_encoders, resources->count_crtcs);
-
-                if (resources->count_connectors > 0 && resources->count_encoders > 0 && resources->count_crtcs > 0) {
-                    available = SDL_TRUE;
-                }
-                KMSDRM_LEGACY_drmModeFreeResources(resources);
-            }
-            SDL_KMSDRM_LEGACY_UnloadSymbols();
-        }
-        close(drm_fd);
-    }
-
-    return available;
-}
-
-static int get_dricount(void)
-{
-    int devcount = 0;
-    struct dirent *res;
-    struct stat sb;
-    DIR *folder;
-
-    if (!(stat(KMSDRM_LEGACY_DRI_PATH, &sb) == 0
-                && S_ISDIR(sb.st_mode))) {
-        printf("The path %s cannot be opened or is not available\n",
-               KMSDRM_LEGACY_DRI_PATH);
-        return 0;
-    }
-
-    if (access(KMSDRM_LEGACY_DRI_PATH, F_OK) == -1) {
-        printf("The path %s cannot be opened\n",
-               KMSDRM_LEGACY_DRI_PATH);
-        return 0;
-    }
-
-    folder = opendir(KMSDRM_LEGACY_DRI_PATH);
-    if (folder) {
-        while ((res = readdir(folder))) {
-            int len = SDL_strlen(res->d_name);
-            if (len > 4 && SDL_strncmp(res->d_name, "card", 4) == 0) {
-                devcount++;
-            }
-        }
-        closedir(folder);
-    }
-
-    return devcount;
-}
-
-static int
-get_driindex(void)
-{
-    const int devcount = get_dricount();
-    int i;
-
-    for (i = 0; i < devcount; i++) {
-        if (check_modestting(i)) {
-            return i;
-        }
-    }
-
-    return -ENOENT;
-}
-
-static int
-KMSDRM_LEGACY_Available(void)
-{
-    int ret = -ENOENT;
-
-    ret = get_driindex();
-    if (ret >= 0)
-        return 1;
-
-    return ret;
-}
-
-static void
-KMSDRM_LEGACY_DeleteDevice(SDL_VideoDevice * device)
-{
-    if (device->driverdata) {
-        SDL_free(device->driverdata);
-        device->driverdata = NULL;
-    }
-
-    SDL_free(device);
-
-    SDL_KMSDRM_LEGACY_UnloadSymbols();
-}
-
-static SDL_VideoDevice *
-KMSDRM_LEGACY_CreateDevice(int devindex)
-{
-    SDL_VideoDevice *device;
-    SDL_VideoData *viddata;
-
-    if (!KMSDRM_LEGACY_Available()) {
-        return NULL;
-    }
-
-    if (!devindex || (devindex > 99)) {
-        devindex = get_driindex();
-    }
-
-    if (devindex < 0) {
-        SDL_SetError("devindex (%d) must be between 0 and 99.\n", devindex);
-        return NULL;
-    }
-
-    if (!SDL_KMSDRM_LEGACY_LoadSymbols()) {
-        return NULL;
-    }
-
-    device = (SDL_VideoDevice *) SDL_calloc(1, sizeof(SDL_VideoDevice));
-    if (!device) {
-        SDL_OutOfMemory();
-        return NULL;
-    }
-
-    viddata = (SDL_VideoData *) SDL_calloc(1, sizeof(SDL_VideoData));
-    if (!viddata) {
-        SDL_OutOfMemory();
-        goto cleanup;
-    }
-    viddata->devindex = devindex;
-    viddata->drm_fd = -1;
-
-    device->driverdata = viddata;
-
-    /* Setup all functions which we can handle */
-    device->VideoInit = KMSDRM_LEGACY_VideoInit;
-    device->VideoQuit = KMSDRM_LEGACY_VideoQuit;
-    device->GetDisplayModes = KMSDRM_LEGACY_GetDisplayModes;
-    device->SetDisplayMode = KMSDRM_LEGACY_SetDisplayMode;
-    device->CreateSDLWindow = KMSDRM_LEGACY_CreateWindow;
-    device->CreateSDLWindowFrom = KMSDRM_LEGACY_CreateWindowFrom;
-    device->SetWindowTitle = KMSDRM_LEGACY_SetWindowTitle;
-    device->SetWindowIcon = KMSDRM_LEGACY_SetWindowIcon;
-    device->SetWindowPosition = KMSDRM_LEGACY_SetWindowPosition;
-    device->SetWindowSize = KMSDRM_LEGACY_SetWindowSize;
-    device->ShowWindow = KMSDRM_LEGACY_ShowWindow;
-    device->HideWindow = KMSDRM_LEGACY_HideWindow;
-    device->RaiseWindow = KMSDRM_LEGACY_RaiseWindow;
-    device->MaximizeWindow = KMSDRM_LEGACY_MaximizeWindow;
-    device->MinimizeWindow = KMSDRM_LEGACY_MinimizeWindow;
-    device->RestoreWindow = KMSDRM_LEGACY_RestoreWindow;
-    device->SetWindowGrab = KMSDRM_LEGACY_SetWindowGrab;
-    device->DestroyWindow = KMSDRM_LEGACY_DestroyWindow;
-    device->GetWindowWMInfo = KMSDRM_LEGACY_GetWindowWMInfo;
-#if SDL_VIDEO_OPENGL_EGL
-    device->GL_LoadLibrary = KMSDRM_LEGACY_GLES_LoadLibrary;
-    device->GL_GetProcAddress = KMSDRM_LEGACY_GLES_GetProcAddress;
-    device->GL_UnloadLibrary = KMSDRM_LEGACY_GLES_UnloadLibrary;
-    device->GL_CreateContext = KMSDRM_LEGACY_GLES_CreateContext;
-    device->GL_MakeCurrent = KMSDRM_LEGACY_GLES_MakeCurrent;
-    device->GL_SetSwapInterval = KMSDRM_LEGACY_GLES_SetSwapInterval;
-    device->GL_GetSwapInterval = KMSDRM_LEGACY_GLES_GetSwapInterval;
-    device->GL_SwapWindow = KMSDRM_LEGACY_GLES_SwapWindow;
-    device->GL_DeleteContext = KMSDRM_LEGACY_GLES_DeleteContext;
-#endif
-    device->PumpEvents = KMSDRM_LEGACY_PumpEvents;
-    device->free = KMSDRM_LEGACY_DeleteDevice;
-
-    return device;
-
-cleanup:
-    if (device)
-        SDL_free(device);
-    if (viddata)
-        SDL_free(viddata);
-    return NULL;
-}
-
-VideoBootStrap KMSDRM_LEGACY_bootstrap = {
-    "KMSDRM_LEGACY",
-    "KMS/DRM Video Driver",
-    KMSDRM_LEGACY_CreateDevice
-};
-
-
-static void
-KMSDRM_LEGACY_FBDestroyCallback(struct gbm_bo *bo, void *data)
-{
-    KMSDRM_LEGACY_FBInfo *fb_info = (KMSDRM_LEGACY_FBInfo *)data;
-
-    if (fb_info && fb_info->drm_fd >= 0 && fb_info->fb_id != 0) {
-        KMSDRM_LEGACY_drmModeRmFB(fb_info->drm_fd, fb_info->fb_id);
-        SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Delete DRM FB %u", fb_info->fb_id);
-    }
-
-    SDL_free(fb_info);
-}
-
-KMSDRM_LEGACY_FBInfo *
-KMSDRM_LEGACY_FBFromBO(_THIS, struct gbm_bo *bo)
-{
-    SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
-    unsigned w,h;
-    int ret;
-    Uint32 stride, handle;
-
-    /* Check for an existing framebuffer */
-    KMSDRM_LEGACY_FBInfo *fb_info = (KMSDRM_LEGACY_FBInfo *)KMSDRM_LEGACY_gbm_bo_get_user_data(bo);
-
-    if (fb_info) {
-        return fb_info;
-    }
-
-    /* Create a structure that contains enough info to remove the framebuffer
-       when the backing buffer is destroyed */
-    fb_info = (KMSDRM_LEGACY_FBInfo *)SDL_calloc(1, sizeof(KMSDRM_LEGACY_FBInfo));
-
-    if (!fb_info) {
-        SDL_OutOfMemory();
-        return NULL;
-    }
-
-    fb_info->drm_fd = viddata->drm_fd;
-
-    /* Create framebuffer object for the buffer */
-    w = KMSDRM_LEGACY_gbm_bo_get_width(bo);
-    h = KMSDRM_LEGACY_gbm_bo_get_height(bo);
-    stride = KMSDRM_LEGACY_gbm_bo_get_stride(bo);
-    handle = KMSDRM_LEGACY_gbm_bo_get_handle(bo).u32;
-    ret = KMSDRM_LEGACY_drmModeAddFB(viddata->drm_fd, w, h, 24, 32, stride, handle,
-                                  &fb_info->fb_id);
-    if (ret) {
-      SDL_free(fb_info);
-      return NULL;
-    }
-
-    SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "New DRM FB (%u): %ux%u, stride %u from BO %p",
-                 fb_info->fb_id, w, h, stride, (void *)bo);
-
-    /* Associate our DRM framebuffer with this buffer object */
-    KMSDRM_LEGACY_gbm_bo_set_user_data(bo, fb_info, KMSDRM_LEGACY_FBDestroyCallback);
-
-    return fb_info;
-}
-
-static void
-KMSDRM_LEGACY_FlipHandler(int fd, unsigned int frame, unsigned int sec, unsigned int usec, void *data)
-{
-    *((SDL_bool *) data) = SDL_FALSE;
-}
-
-SDL_bool
-KMSDRM_LEGACY_WaitPageFlip(_THIS, SDL_WindowData *windata, int timeout) {
-    SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
-    drmEventContext ev = {0};
-    struct pollfd pfd = {0};
-
-    ev.version = DRM_EVENT_CONTEXT_VERSION;
-    ev.page_flip_handler = KMSDRM_LEGACY_FlipHandler;
-
-    pfd.fd = viddata->drm_fd;
-    pfd.events = POLLIN;
-
-    while (windata->waiting_for_flip) {
-        pfd.revents = 0;
-
-        if (poll(&pfd, 1, timeout) < 0) {
-            SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "DRM poll error");
-            return SDL_FALSE;
-        }
-
-        if (pfd.revents & (POLLHUP | POLLERR)) {
-            SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "DRM poll hup or error");
-            return SDL_FALSE;
-        }
-
-        if (pfd.revents & POLLIN) {
-            /* Page flip? If so, drmHandleEvent will unset windata->waiting_for_flip */
-            KMSDRM_LEGACY_drmHandleEvent(viddata->drm_fd, &ev);
-        } else {
-            /* Timed out and page flip didn't happen */
-            SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Dropping frame while waiting_for_flip");
-            return SDL_FALSE;
-        }
-    }
-
-    return SDL_TRUE;
-}
-
-/*****************************************************************************/
-/* SDL Video and Display initialization/handling functions                   */
-/* _this is a SDL_VideoDevice *                                              */
-/*****************************************************************************/
-static void
-KMSDRM_LEGACY_DestroySurfaces(_THIS, SDL_Window * window)
-{
-    SDL_WindowData *windata = (SDL_WindowData *)window->driverdata;
-
-    KMSDRM_LEGACY_WaitPageFlip(_this, windata, -1);
-
-    if (windata->curr_bo) {
-        KMSDRM_LEGACY_gbm_surface_release_buffer(windata->gs, windata->curr_bo);
-        windata->curr_bo = NULL;
-    }
-
-    if (windata->next_bo) {
-        KMSDRM_LEGACY_gbm_surface_release_buffer(windata->gs, windata->next_bo);
-        windata->next_bo = NULL;
-    }
-
-#if SDL_VIDEO_OPENGL_EGL
-    SDL_EGL_MakeCurrent(_this, EGL_NO_SURFACE, EGL_NO_CONTEXT);
-
-    if (windata->egl_surface != EGL_NO_SURFACE) {
-        SDL_EGL_DestroySurface(_this, windata->egl_surface);
-        windata->egl_surface = EGL_NO_SURFACE;
-    }
-#endif
-
-    if (windata->gs) {
-        KMSDRM_LEGACY_gbm_surface_destroy(windata->gs);
-        windata->gs = NULL;
-    }
-}
-
-int
-KMSDRM_LEGACY_CreateSurfaces(_THIS, SDL_Window * window)
-{
-    SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
-    SDL_WindowData *windata = (SDL_WindowData *)window->driverdata;
-    SDL_DisplayData *dispdata = (SDL_DisplayData *) SDL_GetDisplayForWindow(window)->driverdata;
-    Uint32 width = dispdata->mode.hdisplay;
-    Uint32 height = dispdata->mode.vdisplay;
-    Uint32 surface_fmt = GBM_FORMAT_XRGB8888;
-    Uint32 surface_flags = GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING;
-#if SDL_VIDEO_OPENGL_EGL
-    EGLContext egl_context;
-#endif
-
-    if (!KMSDRM_LEGACY_gbm_device_is_format_supported(viddata->gbm, surface_fmt, surface_flags)) {
-        SDL_LogWarn(SDL_LOG_CATEGORY_VIDEO, "GBM surface format not supported. Trying anyway.");
-    }
-
-#if SDL_VIDEO_OPENGL_EGL
-    SDL_EGL_SetRequiredVisualId(_this, surface_fmt);
-    egl_context = (EGLContext)SDL_GL_GetCurrentContext();
-#endif
-
-    KMSDRM_LEGACY_DestroySurfaces(_this, window);
-
-    windata->gs = KMSDRM_LEGACY_gbm_surface_create(viddata->gbm, width, height, surface_fmt, surface_flags);
-
-    if (!windata->gs) {
-        return SDL_SetError("Could not create GBM surface");
-    }
-
-#if SDL_VIDEO_OPENGL_EGL
-    windata->egl_surface = SDL_EGL_CreateSurface(_this, (NativeWindowType)windata->gs);
-
-    if (windata->egl_surface == EGL_NO_SURFACE) {
-        return SDL_SetError("Could not create EGL window surface");
-    }
-
-    SDL_EGL_MakeCurrent(_this, windata->egl_surface, egl_context);
-
-    windata->egl_surface_dirty = 0;
-#endif
-
-    return 0;
-}
-
-int
-KMSDRM_LEGACY_VideoInit(_THIS)
-{
-    int i, j, ret = 0;
-    SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
-    SDL_DisplayData *dispdata = NULL;
-    drmModeRes *resources = NULL;
-    drmModeEncoder *encoder = NULL;
-    char devname[32];
-    SDL_VideoDisplay display = {0};
-
-    dispdata = (SDL_DisplayData *) SDL_calloc(1, sizeof(SDL_DisplayData));
-
-    if (!dispdata) {
-        return SDL_OutOfMemory();
-    }
-
-    SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "KMSDRM_LEGACY_VideoInit()");
-
-    /* Open /dev/dri/cardNN */
-    SDL_snprintf(devname, sizeof(devname), "/dev/dri/card%d", viddata->devindex);
-
-    SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Opening device %s", devname);
-    viddata->drm_fd = open(devname, O_RDWR | O_CLOEXEC);
-
-    if (viddata->drm_fd < 0) {
-        ret = SDL_SetError("Could not open %s", devname);
-        goto cleanup;
-    }
-
-    SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Opened DRM FD (%d)", viddata->drm_fd);
-
-    viddata->gbm = KMSDRM_LEGACY_gbm_create_device(viddata->drm_fd);
-    if (!viddata->gbm) {
-        ret = SDL_SetError("Couldn't create gbm device.");
-        goto cleanup;
-    }
-
-    /* Get all of the available connectors / devices / crtcs */
-    resources = KMSDRM_LEGACY_drmModeGetResources(viddata->drm_fd);
-    if (!resources) {
-        ret = SDL_SetError("drmModeGetResources(%d) failed", viddata->drm_fd);
-        goto cleanup;
-    }
-
-    for (i = 0; i < resources->count_connectors; i++) {
-        drmModeConnector *conn = KMSDRM_LEGACY_drmModeGetConnector(viddata->drm_fd, resources->connectors[i]);
-
-        if (!conn) {
-            continue;
-        }
-
-        if (conn->connection == DRM_MODE_CONNECTED && conn->count_modes) {
-            SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Found connector %d with %d modes.",
-                         conn->connector_id, conn->count_modes);
-            dispdata->conn = conn;
-            break;
-        }
-
-        KMSDRM_LEGACY_drmModeFreeConnector(conn);
-    }
-
-    if (!dispdata->conn) {
-        ret = SDL_SetError("No currently active connector found.");
-        goto cleanup;
-    }
-
-    /* Try to find the connector's current encoder */
-    for (i = 0; i < resources->count_encoders; i++) {
-        encoder = KMSDRM_LEGACY_drmModeGetEncoder(viddata->drm_fd, resources->encoders[i]);
-
-        if (!encoder) {
-          continue;
-        }
-
-        if (encoder->encoder_id == dispdata->conn->encoder_id) {
-            SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Found encoder %d.", encoder->encoder_id);
-            break;
-        }
-
-        KMSDRM_LEGACY_drmModeFreeEncoder(encoder);
-        encoder = NULL;
-    }
-
-    if (!encoder) {
-        /* No encoder was connected, find the first supported one */
-        for (i = 0; i < resources->count_encoders; i++) {
-            encoder = KMSDRM_LEGACY_drmModeGetEncoder(viddata->drm_fd, resources->encoders[i]);
-
-            if (!encoder) {
-              continue;
-            }
-
-            for (j = 0; j < dispdata->conn->count_encoders; j++) {
-                if (dispdata->conn->encoders[j] == encoder->encoder_id) {
-                    break;
-                }
-            }
-
-            if (j != dispdata->conn->count_encoders) {
-              break;
-            }
-
-            KMSDRM_LEGACY_drmModeFreeEncoder(encoder);
-            encoder = NULL;
-        }
-    }
-
-    if (!encoder) {
-        ret = SDL_SetError("No connected encoder found.");
-        goto cleanup;
-    }
-
-    SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Found encoder %d.", encoder->encoder_id);
-
-    /* Try to find a CRTC connected to this encoder */
-    dispdata->saved_crtc = KMSDRM_LEGACY_drmModeGetCrtc(viddata->drm_fd, encoder->crtc_id);
-
-    if (!dispdata->saved_crtc) {
-        /* No CRTC was connected, find the first CRTC that can be connected */
-        for (i = 0; i < resources->count_crtcs; i++) {
-            if (encoder->possible_crtcs & (1 << i)) {
-                encoder->crtc_id = resources->crtcs[i];
-                dispdata->saved_crtc = KMSDRM_LEGACY_drmModeGetCrtc(viddata->drm_fd, encoder->crtc_id);
-                break;
-            }
-        }
-    }
-
-    if (!dispdata->saved_crtc) {
-        ret = SDL_SetError("No CRTC found.");
-        goto cleanup;
-    }
-
-    SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Saved crtc_id %u, fb_id %u, (%u,%u), %ux%u",
-                 dispdata->saved_crtc->crtc_id, dispdata->saved_crtc->buffer_id, dispdata->saved_crtc->x,
-                 dispdata->saved_crtc->y, dispdata->saved_crtc->width, dispdata->saved_crtc->height);
-
-    dispdata->crtc_id = encoder->crtc_id;
-
-    /* Figure out the default mode to be set. If the current CRTC's mode isn't
-       valid, select the first mode supported by the connector
-
-       FIXME find first mode that specifies DRM_MODE_TYPE_PREFERRED */
-    dispdata->mode = dispdata->saved_crtc->mode;
-
-    if (dispdata->saved_crtc->mode_valid == 0) {
-        SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO,
-            "Current mode is invalid, selecting connector's mode #0.");
-        dispdata->mode = dispdata->conn->modes[0];
-    }
-
-    /* Setup the single display that's available */
-
-    display.desktop_mode.w = dispdata->mode.hdisplay;
-    display.desktop_mode.h = dispdata->mode.vdisplay;
-    display.desktop_mode.refresh_rate = dispdata->mode.vrefresh;
-#if 1
-    display.desktop_mode.format = SDL_PIXELFORMAT_ARGB8888;
-#else
-    /* FIXME */
-    drmModeFB *fb = drmModeGetFB(viddata->drm_fd, dispdata->saved_crtc->buffer_id);
-    display.desktop_mode.format = drmToSDLPixelFormat(fb->bpp, fb->depth);
-    drmModeFreeFB(fb);
-#endif
-    display.current_mode = display.desktop_mode;
-    display.driverdata = dispdata;
-    SDL_AddVideoDisplay(&display, SDL_FALSE);
-
-#ifdef SDL_INPUT_LINUXEV
-    SDL_EVDEV_Init();
-#endif
-
-    KMSDRM_LEGACY_InitMouse(_this);
-
-    return ret;
-
-cleanup:
-    if (encoder)
-        KMSDRM_LEGACY_drmModeFreeEncoder(encoder);
-    if (resources)
-        KMSDRM_LEGACY_drmModeFreeResources(resources);
-
-    if (ret != 0) {
-        /* Error (complete) cleanup */
-        if (dispdata->conn) {
-            KMSDRM_LEGACY_drmModeFreeConnector(dispdata->conn);
-            dispdata->conn = NULL;
-        }
-        if (dispdata->saved_crtc) {
-            KMSDRM_LEGACY_drmModeFreeCrtc(dispdata->saved_crtc);
-            dispdata->saved_crtc = NULL;
-        }
-        if (viddata->gbm) {
-            KMSDRM_LEGACY_gbm_device_destroy(viddata->gbm);
-            viddata->gbm = NULL;
-        }
-        if (viddata->drm_fd >= 0) {
-            close(viddata->drm_fd);
-            viddata->drm_fd = -1;
-        }
-        SDL_free(dispdata);
-    }
-    return ret;
-}
-
-void
-KMSDRM_LEGACY_VideoQuit(_THIS)
-{
-    SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
-    SDL_DisplayData *dispdata = (SDL_DisplayData *)SDL_GetDisplayDriverData(0);
-
-    SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "KMSDRM_LEGACY_VideoQuit()");
-
-    if (_this->gl_config.driver_loaded) {
-        SDL_GL_UnloadLibrary();
-    }
-
-    /* Clear out the window list */
-    SDL_free(viddata->windows);
-    viddata->windows = NULL;
-    viddata->max_windows = 0;
-    viddata->num_windows = 0;
-
-    /* Restore saved CRTC settings */
-    if (viddata->drm_fd >= 0 && dispdata && dispdata->conn && dispdata->saved_crtc) {
-        drmModeConnector *conn = dispdata->conn;
-        drmModeCrtc *crtc = dispdata->saved_crtc;
-
-        int ret = KMSDRM_LEGACY_drmModeSetCrtc(viddata->drm_fd, crtc->crtc_id, crtc->buffer_id,
-                                        crtc->x, crtc->y, &conn->connector_id, 1, &crtc->mode);
-
-        if (ret != 0) {
-            SDL_LogWarn(SDL_LOG_CATEGORY_VIDEO, "Could not restore original CRTC mode");
-        }
-    }
-    if (dispdata && dispdata->conn) {
-        KMSDRM_LEGACY_drmModeFreeConnector(dispdata->conn);
-        dispdata->conn = NULL;
-    }
-    if (dispdata && dispdata->saved_crtc) {
-        KMSDRM_LEGACY_drmModeFreeCrtc(dispdata->saved_crtc);
-        dispdata->saved_crtc = NULL;
-    }
-    if (viddata->gbm) {
-        KMSDRM_LEGACY_gbm_device_destroy(viddata->gbm);
-        viddata->gbm = NULL;
-    }
-    if (viddata->drm_fd >= 0) {
-        close(viddata->drm_fd);
-        SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Closed DRM FD %d", viddata->drm_fd);
-        viddata->drm_fd = -1;
-    }
-#ifdef SDL_INPUT_LINUXEV
-    SDL_EVDEV_Quit();
-#endif
-}
-
-void
-KMSDRM_LEGACY_GetDisplayModes(_THIS, SDL_VideoDisplay * display)
-{
-    SDL_DisplayData *dispdata = display->driverdata;
-    drmModeConnector *conn = dispdata->conn;
-    SDL_DisplayMode mode;
-    int i;
-
-    for (i = 0; i < conn->count_modes; i++) {
-        SDL_DisplayModeData *modedata = SDL_calloc(1, sizeof(SDL_DisplayModeData));
-
-        if (modedata) {
-          modedata->mode_index = i;
-        }
-
-        mode.w = conn->modes[i].hdisplay;
-        mode.h = conn->modes[i].vdisplay;
-        mode.refresh_rate = conn->modes[i].vrefresh;
-        mode.format = SDL_PIXELFORMAT_ARGB8888;
-        mode.driverdata = modedata;
-
-        if (!SDL_AddDisplayMode(display, &mode)) {
-            SDL_free(modedata);
-        }
-    }
-}
-
-int
-KMSDRM_LEGACY_SetDisplayMode(_THIS, SDL_VideoDisplay * display, SDL_DisplayMode * mode)
-{
-    SDL_VideoData *viddata = (SDL_VideoData *)_this->driverdata;
-    SDL_DisplayData *dispdata = (SDL_DisplayData *)display->driverdata;
-    SDL_DisplayModeData *modedata = (SDL_DisplayModeData *)mode->driverdata;
-    drmModeConnector *conn = dispdata->conn;
-    int i;
-
-    if (!modedata) {
-        return SDL_SetError("Mode doesn't have an associated index");
-    }
-
-    dispdata->mode = conn->modes[modedata->mode_index];
-
-    for (i = 0; i < viddata->num_windows; i++) {
-        SDL_Window *window = viddata->windows[i];
-        SDL_WindowData *windata = (SDL_WindowData *)window->driverdata;
-
-#if SDL_VIDEO_OPENGL_EGL
-        /* Can't recreate EGL surfaces right now, need to wait until SwapWindow
-           so the correct thread-local surface and context state are available */
-        windata->egl_surface_dirty = 1;
-#else
-        if (KMSDRM_LEGACY_CreateSurfaces(_this, window)) {
-            return -1;
-        }
-#endif
-
-        /* Tell app about the resize */
-        SDL_SendWindowEvent(window, SDL_WINDOWEVENT_RESIZED, mode->w, mode->h);
-    }
-
-    return 0;
-}
-
-int
-KMSDRM_LEGACY_CreateWindow(_THIS, SDL_Window * window)
-{
-    SDL_VideoData *viddata = (SDL_VideoData *)_this->driverdata;
-    SDL_WindowData *windata;
-    SDL_VideoDisplay *display;
-
-#if SDL_VIDEO_OPENGL_EGL
-    if (!_this->egl_data) {
-        if (SDL_GL_LoadLibrary(NULL) < 0) {
-            goto error;
-        }
-    }
-#endif
-
-    /* Allocate window internal data */
-    windata = (SDL_WindowData *)SDL_calloc(1, sizeof(SDL_WindowData));
-
-    if (!windata) {
-        SDL_OutOfMemory();
-        goto error;
-    }
-
-    /* Windows have one size for now */
-    display = SDL_GetDisplayForWindow(window);
-    window->w = display->desktop_mode.w;
-    window->h = display->desktop_mode.h;
-
-    /* Maybe you didn't ask for a fullscreen OpenGL window, but that's what you get */
-    window->flags |= (SDL_WINDOW_FULLSCREEN | SDL_WINDOW_OPENGL);
-
-    /* In case we want low-latency, double-buffer video, we take note here */
-    windata->double_buffer = SDL_FALSE;
-
-    if (SDL_GetHintBoolean(SDL_HINT_VIDEO_DOUBLE_BUFFER, SDL_FALSE)) {
-        windata->double_buffer = SDL_TRUE;
-    }
-
-    /* Setup driver data for this window */
-    windata->viddata = viddata;
-    window->driverdata = windata;
-
-    if (KMSDRM_LEGACY_CreateSurfaces(_this, window)) {
-      goto error;
-    }
-
-    /* Add window to the internal list of tracked windows. Note, while it may
-       seem odd to support multiple fullscreen windows, some apps create an
-       extra window as a dummy surface when working with multiple contexts */
-    if (viddata->num_windows >= viddata->max_windows) {
-        int new_max_windows = viddata->max_windows + 1;
-        viddata->windows = (SDL_Window **)SDL_realloc(viddata->windows,
-              new_max_windows * sizeof(SDL_Window *));
-        viddata->max_windows = new_max_windows;
-
-        if (!viddata->windows) {
-            SDL_OutOfMemory();
-            goto error;
-        }
-    }
-
-    viddata->windows[viddata->num_windows++] = window;
-
-    /* Focus on the newly created window */
-    SDL_SetMouseFocus(window);
-    SDL_SetKeyboardFocus(window);
-
-    return 0;
-
-error:
-    KMSDRM_LEGACY_DestroyWindow(_this, window);
-
-    return -1;
-}
-
-void
-KMSDRM_LEGACY_DestroyWindow(_THIS, SDL_Window * window)
-{
-    SDL_WindowData *windata = (SDL_WindowData *) window->driverdata;
-    SDL_VideoData *viddata;
-    int i, j;
-
-    if (!windata) {
-        return;
-    }
-
-    /* Remove from the internal window list */
-    viddata = windata->viddata;
-
-    for (i = 0; i < viddata->num_windows; i++) {
-        if (viddata->windows[i] == window) {
-            viddata->num_windows--;
-
-            for (j = i; j < viddata->num_windows; j++) {
-                viddata->windows[j] = viddata->windows[j + 1];
-            }
-
-            break;
-        }
-    }
-
-    KMSDRM_LEGACY_DestroySurfaces(_this, window);
-
-    window->driverdata = NULL;
-
-    SDL_free(windata);
-}
-
-int
-KMSDRM_LEGACY_CreateWindowFrom(_THIS, SDL_Window * window, const void *data)
-{
-    return -1;
-}
-
-void
-KMSDRM_LEGACY_SetWindowTitle(_THIS, SDL_Window * window)
-{
-}
-void
-KMSDRM_LEGACY_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon)
-{
-}
-void
-KMSDRM_LEGACY_SetWindowPosition(_THIS, SDL_Window * window)
-{
-}
-void
-KMSDRM_LEGACY_SetWindowSize(_THIS, SDL_Window * window)
-{
-}
-void
-KMSDRM_LEGACY_ShowWindow(_THIS, SDL_Window * window)
-{
-}
-void
-KMSDRM_LEGACY_HideWindow(_THIS, SDL_Window * window)
-{
-}
-void
-KMSDRM_LEGACY_RaiseWindow(_THIS, SDL_Window * window)
-{
-}
-void
-KMSDRM_LEGACY_MaximizeWindow(_THIS, SDL_Window * window)
-{
-}
-void
-KMSDRM_LEGACY_MinimizeWindow(_THIS, SDL_Window * window)
-{
-}
-void
-KMSDRM_LEGACY_RestoreWindow(_THIS, SDL_Window * window)
-{
-}
-void
-KMSDRM_LEGACY_SetWindowGrab(_THIS, SDL_Window * window, SDL_bool grabbed)
-{
-
-}
-
-/*****************************************************************************/
-/* SDL Window Manager function                                               */
-/*****************************************************************************/
-SDL_bool
-KMSDRM_LEGACY_GetWindowWMInfo(_THIS, SDL_Window * window, struct SDL_SysWMinfo *info)
-{
-    if (info->version.major <= SDL_MAJOR_VERSION) {
-        return SDL_TRUE;
-    } else {
-        SDL_SetError("application not compiled with SDL %d.%d\n",
-                     SDL_MAJOR_VERSION, SDL_MINOR_VERSION);
-        return SDL_FALSE;
-    }
-
-    /* Failed to get window manager information */
-    return SDL_FALSE;
-}
-
-#endif /* SDL_VIDEO_DRIVER_KMSDRM */
-
-/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_video.h b/Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_video.h
deleted file mode 100644
index 28e1bc4fe..000000000
--- a/Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_video.h
+++ /dev/null
@@ -1,132 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "../../SDL_internal.h"
-
-#ifndef __SDL_KMSDRM_LEGACYVIDEO_H__
-#define __SDL_KMSDRM_LEGACYVIDEO_H__
-
-#include "../SDL_sysvideo.h"
-
-#include <fcntl.h>
-#include <unistd.h>
-#include <xf86drm.h>
-#include <xf86drmMode.h>
-#include <gbm.h>
-#if SDL_VIDEO_OPENGL_EGL
-#include <EGL/egl.h>
-#endif
-
-typedef struct SDL_VideoData
-{
-    int devindex;               /* device index that was passed on creation */
-    int drm_fd;                 /* DRM file desc */
-    struct gbm_device *gbm;
-
-    SDL_Window **windows;
-    int max_windows;
-    int num_windows;
-} SDL_VideoData;
-
-
-typedef struct SDL_DisplayModeData
-{
-    int mode_index;
-} SDL_DisplayModeData;
-
-
-typedef struct SDL_DisplayData
-{
-    uint32_t crtc_id;
-    drmModeConnector *conn;
-    drmModeModeInfo mode;
-    drmModeCrtc *saved_crtc;    /* CRTC to restore on quit */
-} SDL_DisplayData;
-
-
-typedef struct SDL_WindowData
-{
-    SDL_VideoData *viddata;
-    struct gbm_surface *gs;
-    struct gbm_bo *curr_bo;
-    struct gbm_bo *next_bo;
-    struct gbm_bo *crtc_bo;
-    SDL_bool waiting_for_flip;
-    SDL_bool double_buffer;
-#if SDL_VIDEO_OPENGL_EGL
-    int egl_surface_dirty;
-    EGLSurface egl_surface;
-#endif
-} SDL_WindowData;
-
-typedef struct KMSDRM_LEGACY_FBInfo
-{
-    int drm_fd;         /* DRM file desc */
-    uint32_t fb_id;     /* DRM framebuffer ID */
-} KMSDRM_LEGACY_FBInfo;
-
-/* Helper functions */
-int KMSDRM_LEGACY_CreateSurfaces(_THIS, SDL_Window * window);
-KMSDRM_LEGACY_FBInfo *KMSDRM_LEGACY_FBFromBO(_THIS, struct gbm_bo *bo);
-SDL_bool KMSDRM_LEGACY_WaitPageFlip(_THIS, SDL_WindowData *windata, int timeout);
-
-/****************************************************************************/
-/* SDL_VideoDevice functions declaration                                    */
-/****************************************************************************/
-
-/* Display and window functions */
-int KMSDRM_LEGACY_VideoInit(_THIS);
-void KMSDRM_LEGACY_VideoQuit(_THIS);
-void KMSDRM_LEGACY_GetDisplayModes(_THIS, SDL_VideoDisplay * display);
-int KMSDRM_LEGACY_SetDisplayMode(_THIS, SDL_VideoDisplay * display, SDL_DisplayMode * mode);
-int KMSDRM_LEGACY_CreateWindow(_THIS, SDL_Window * window);
-int KMSDRM_LEGACY_CreateWindowFrom(_THIS, SDL_Window * window, const void *data);
-void KMSDRM_LEGACY_SetWindowTitle(_THIS, SDL_Window * window);
-void KMSDRM_LEGACY_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon);
-void KMSDRM_LEGACY_SetWindowPosition(_THIS, SDL_Window * window);
-void KMSDRM_LEGACY_SetWindowSize(_THIS, SDL_Window * window);
-void KMSDRM_LEGACY_ShowWindow(_THIS, SDL_Window * window);
-void KMSDRM_LEGACY_HideWindow(_THIS, SDL_Window * window);
-void KMSDRM_LEGACY_RaiseWindow(_THIS, SDL_Window * window);
-void KMSDRM_LEGACY_MaximizeWindow(_THIS, SDL_Window * window);
-void KMSDRM_LEGACY_MinimizeWindow(_THIS, SDL_Window * window);
-void KMSDRM_LEGACY_RestoreWindow(_THIS, SDL_Window * window);
-void KMSDRM_LEGACY_SetWindowGrab(_THIS, SDL_Window * window, SDL_bool grabbed);
-void KMSDRM_LEGACY_DestroyWindow(_THIS, SDL_Window * window);
-
-/* Window manager function */
-SDL_bool KMSDRM_LEGACY_GetWindowWMInfo(_THIS, SDL_Window * window,
-                             struct SDL_SysWMinfo *info);
-
-/* OpenGL/OpenGL ES functions */
-int KMSDRM_LEGACY_GLES_LoadLibrary(_THIS, const char *path);
-void *KMSDRM_LEGACY_GLES_GetProcAddress(_THIS, const char *proc);
-void KMSDRM_LEGACY_GLES_UnloadLibrary(_THIS);
-SDL_GLContext KMSDRM_LEGACY_GLES_CreateContext(_THIS, SDL_Window * window);
-int KMSDRM_LEGACY_GLES_MakeCurrent(_THIS, SDL_Window * window, SDL_GLContext context);
-int KMSDRM_LEGACY_GLES_SetSwapInterval(_THIS, int interval);
-int KMSDRM_LEGACY_GLES_GetSwapInterval(_THIS);
-int KMSDRM_LEGACY_GLES_SwapWindow(_THIS, SDL_Window * window);
-void KMSDRM_LEGACY_GLES_DeleteContext(_THIS, SDL_GLContext context);
-
-#endif /* __SDL_KMSDRM_LEGACYVIDEO_H__ */
-
-/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/nacl/SDL_naclevents.c b/Engine/lib/sdl/src/video/nacl/SDL_naclevents.c
index 44f47ec23..142d0c1f9 100644
--- a/Engine/lib/sdl/src/video/nacl/SDL_naclevents.c
+++ b/Engine/lib/sdl/src/video/nacl/SDL_naclevents.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/nacl/SDL_naclevents_c.h b/Engine/lib/sdl/src/video/nacl/SDL_naclevents_c.h
index 555f6a454..e8d44f41b 100644
--- a/Engine/lib/sdl/src/video/nacl/SDL_naclevents_c.h
+++ b/Engine/lib/sdl/src/video/nacl/SDL_naclevents_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/nacl/SDL_naclglue.c b/Engine/lib/sdl/src/video/nacl/SDL_naclglue.c
index 13618478e..ac1e16029 100644
--- a/Engine/lib/sdl/src/video/nacl/SDL_naclglue.c
+++ b/Engine/lib/sdl/src/video/nacl/SDL_naclglue.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/nacl/SDL_naclopengles.c b/Engine/lib/sdl/src/video/nacl/SDL_naclopengles.c
index 0bd9b13c2..ca5b75f99 100644
--- a/Engine/lib/sdl/src/video/nacl/SDL_naclopengles.c
+++ b/Engine/lib/sdl/src/video/nacl/SDL_naclopengles.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -27,7 +27,7 @@
 #include "SDL_video.h"
 #include "SDL_naclvideo.h"
 
-#if SDL_LOADSO_DLOPEN
+#ifdef HAVE_DLOPEN
 #include "dlfcn.h"
 #endif
 
@@ -45,7 +45,7 @@ NACL_GLES_LoadLibrary(_THIS, const char *path)
 void *
 NACL_GLES_GetProcAddress(_THIS, const char *proc)
 {
-#if SDL_LOADSO_DLOPEN
+#ifdef HAVE_DLOPEN
     return dlsym( 0 /* RTLD_DEFAULT */, proc);
 #else
     return NULL;
diff --git a/Engine/lib/sdl/src/video/nacl/SDL_naclopengles.h b/Engine/lib/sdl/src/video/nacl/SDL_naclopengles.h
index b785101e6..a3fee1f5b 100644
--- a/Engine/lib/sdl/src/video/nacl/SDL_naclopengles.h
+++ b/Engine/lib/sdl/src/video/nacl/SDL_naclopengles.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/nacl/SDL_naclvideo.c b/Engine/lib/sdl/src/video/nacl/SDL_naclvideo.c
index 74e2c294a..96901e899 100644
--- a/Engine/lib/sdl/src/video/nacl/SDL_naclvideo.c
+++ b/Engine/lib/sdl/src/video/nacl/SDL_naclvideo.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/nacl/SDL_naclvideo.h b/Engine/lib/sdl/src/video/nacl/SDL_naclvideo.h
index 613dd61a1..3b0892049 100644
--- a/Engine/lib/sdl/src/video/nacl/SDL_naclvideo.h
+++ b/Engine/lib/sdl/src/video/nacl/SDL_naclvideo.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/nacl/SDL_naclwindow.c b/Engine/lib/sdl/src/video/nacl/SDL_naclwindow.c
index 979abcd63..f0245aef2 100644
--- a/Engine/lib/sdl/src/video/nacl/SDL_naclwindow.c
+++ b/Engine/lib/sdl/src/video/nacl/SDL_naclwindow.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -35,8 +35,7 @@ NACL_CreateWindow(_THIS, SDL_Window * window)
     SDL_VideoData *driverdata = (SDL_VideoData *) _this->driverdata;
     
     if (driverdata->window) {
-        SDL_SetError("NaCl only supports one window");
-        return -1;
+        return SDL_SetError("NaCl only supports one window");
     }
     driverdata->window = window;
 
diff --git a/Engine/lib/sdl/src/video/nacl/SDL_naclwindow.h b/Engine/lib/sdl/src/video/nacl/SDL_naclwindow.h
index 5726fcab2..65757c412 100644
--- a/Engine/lib/sdl/src/video/nacl/SDL_naclwindow.h
+++ b/Engine/lib/sdl/src/video/nacl/SDL_naclwindow.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/offscreen/SDL_offscreenevents.c b/Engine/lib/sdl/src/video/offscreen/SDL_offscreenevents.c
index e24d954a4..a14e0b277 100644
--- a/Engine/lib/sdl/src/video/offscreen/SDL_offscreenevents.c
+++ b/Engine/lib/sdl/src/video/offscreen/SDL_offscreenevents.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/offscreen/SDL_offscreenevents_c.h b/Engine/lib/sdl/src/video/offscreen/SDL_offscreenevents_c.h
index 768fb24f7..3d2614952 100644
--- a/Engine/lib/sdl/src/video/offscreen/SDL_offscreenevents_c.h
+++ b/Engine/lib/sdl/src/video/offscreen/SDL_offscreenevents_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/offscreen/SDL_offscreenframebuffer.c b/Engine/lib/sdl/src/video/offscreen/SDL_offscreenframebuffer.c
index 93fa36807..3ca57e897 100644
--- a/Engine/lib/sdl/src/video/offscreen/SDL_offscreenframebuffer.c
+++ b/Engine/lib/sdl/src/video/offscreen/SDL_offscreenframebuffer.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -34,17 +34,13 @@ int SDL_OFFSCREEN_CreateWindowFramebuffer(_THIS, SDL_Window * window, Uint32 * f
     SDL_Surface *surface;
     const Uint32 surface_format = SDL_PIXELFORMAT_RGB888;
     int w, h;
-    int bpp;
-    Uint32 Rmask, Gmask, Bmask, Amask;
 
     /* Free the old framebuffer surface */
-    surface = (SDL_Surface *) SDL_GetWindowData(window, OFFSCREEN_SURFACE);
-    SDL_FreeSurface(surface);
+    SDL_OFFSCREEN_DestroyWindowFramebuffer(_this, window);
 
     /* Create a new one */
-    SDL_PixelFormatEnumToMasks(surface_format, &bpp, &Rmask, &Gmask, &Bmask, &Amask);
     SDL_GetWindowSize(window, &w, &h);
-    surface = SDL_CreateRGBSurface(0, w, h, bpp, Rmask, Gmask, Bmask, Amask);
+    surface = SDL_CreateRGBSurfaceWithFormat(0, w, h, 0, surface_format);
     if (!surface) {
         return -1;
     }
diff --git a/Engine/lib/sdl/src/video/offscreen/SDL_offscreenframebuffer_c.h b/Engine/lib/sdl/src/video/offscreen/SDL_offscreenframebuffer_c.h
index d8577c914..82ae06c92 100644
--- a/Engine/lib/sdl/src/video/offscreen/SDL_offscreenframebuffer_c.h
+++ b/Engine/lib/sdl/src/video/offscreen/SDL_offscreenframebuffer_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/offscreen/SDL_offscreenopengl.c b/Engine/lib/sdl/src/video/offscreen/SDL_offscreenopengl.c
index 92e37f2e6..87641520e 100644
--- a/Engine/lib/sdl/src/video/offscreen/SDL_offscreenopengl.c
+++ b/Engine/lib/sdl/src/video/offscreen/SDL_offscreenopengl.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -66,7 +66,13 @@ OFFSCREEN_GL_LoadLibrary(_THIS, const char* path)
         return ret;
     }
 
+    /* driver_loaded gets incremented by SDL_GL_LoadLibrary when we return,
+       but SDL_EGL_InitializeOffscreen checks that we're loaded before then,
+       so temporarily bump it since we know that LoadLibraryOnly succeeded. */
+
+    _this->gl_config.driver_loaded++;
     ret = SDL_EGL_InitializeOffscreen(_this, 0);
+    _this->gl_config.driver_loaded--;
     if (ret != 0) {
         return ret;
     }
diff --git a/Engine/lib/sdl/src/video/offscreen/SDL_offscreenopengl.h b/Engine/lib/sdl/src/video/offscreen/SDL_offscreenopengl.h
index 7dfd7f3f4..1e2df6940 100644
--- a/Engine/lib/sdl/src/video/offscreen/SDL_offscreenopengl.h
+++ b/Engine/lib/sdl/src/video/offscreen/SDL_offscreenopengl.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/offscreen/SDL_offscreenvideo.c b/Engine/lib/sdl/src/video/offscreen/SDL_offscreenvideo.c
index 35fc3e003..19c7cb5e5 100644
--- a/Engine/lib/sdl/src/video/offscreen/SDL_offscreenvideo.c
+++ b/Engine/lib/sdl/src/video/offscreen/SDL_offscreenvideo.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/offscreen/SDL_offscreenvideo.h b/Engine/lib/sdl/src/video/offscreen/SDL_offscreenvideo.h
index 843c34d43..eae512bbd 100644
--- a/Engine/lib/sdl/src/video/offscreen/SDL_offscreenvideo.h
+++ b/Engine/lib/sdl/src/video/offscreen/SDL_offscreenvideo.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/offscreen/SDL_offscreenwindow.c b/Engine/lib/sdl/src/video/offscreen/SDL_offscreenwindow.c
index 19e0097ac..6697b016a 100644
--- a/Engine/lib/sdl/src/video/offscreen/SDL_offscreenwindow.c
+++ b/Engine/lib/sdl/src/video/offscreen/SDL_offscreenwindow.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/offscreen/SDL_offscreenwindow.h b/Engine/lib/sdl/src/video/offscreen/SDL_offscreenwindow.h
index e8802c6b1..74c85d26c 100644
--- a/Engine/lib/sdl/src/video/offscreen/SDL_offscreenwindow.h
+++ b/Engine/lib/sdl/src/video/offscreen/SDL_offscreenwindow.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/os2/my_gradd.h b/Engine/lib/sdl/src/video/os2/SDL_gradd.h
similarity index 99%
rename from Engine/lib/sdl/src/video/os2/my_gradd.h
rename to Engine/lib/sdl/src/video/os2/SDL_gradd.h
index 3f0f3265d..a1369a260 100644
--- a/Engine/lib/sdl/src/video/os2/my_gradd.h
+++ b/Engine/lib/sdl/src/video/os2/SDL_gradd.h
@@ -5,8 +5,8 @@ Based on public knowledge from around the internet including pages from
 http://www.osfree.org and http://www.edm2.com
 */
 
-#ifndef my_gradd_h_
-#define my_gradd_h_
+#ifndef SDL_gradd_h_
+#define SDL_gradd_h_
 
 typedef struct _INITPROCOUT {
   ULONG     ulLength;         /*  Length of the INITPROCOUT data structure, in bytes. */
@@ -168,4 +168,4 @@ LONG GreResurrection(HDC hdc, LONG cbVmem, PULONG pReserved, PVOID pInstance, LO
 ULONG _System Gre32Entry3(ULONG, ULONG, ULONG);
 ULONG _System Gre32Entry5(ULONG, ULONG, ULONG, ULONG, ULONG);
 
-#endif /* my_gradd_h_ */
+#endif /* SDL_gradd_h_ */
diff --git a/Engine/lib/sdl/src/video/os2/SDL_os2dive.c b/Engine/lib/sdl/src/video/os2/SDL_os2dive.c
index f7d6b294e..95aae6f05 100644
--- a/Engine/lib/sdl/src/video/os2/SDL_os2dive.c
+++ b/Engine/lib/sdl/src/video/os2/SDL_os2dive.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -67,10 +67,12 @@ OS2VIDEOOUTPUT voDive = {
 
 static BOOL voQueryInfo(VIDEOOUTPUTINFO *pInfo)
 {
-    DIVE_CAPS sDiveCaps = { 0 };
-    FOURCC fccFormats[100] = { 0 };
+    DIVE_CAPS sDiveCaps;
+    FOURCC fccFormats[100];
 
     /* Query information about display hardware from DIVE. */
+    SDL_zeroa(fccFormats);
+    SDL_zero(sDiveCaps);
     sDiveCaps.pFormatData    = fccFormats;
     sDiveCaps.ulFormatLength = 100;
     sDiveCaps.ulStructLen    = sizeof(DIVE_CAPS);
@@ -172,7 +174,7 @@ static BOOL voSetVisibleRegion(PVODATA pVOData, HWND hwnd,
             /* Setup DIVE blitter. */
             SETUP_BLITTER   sSetupBlitter;
             SWP             swp;
-            POINTL          pointl = { 0 };
+            POINTL          pointl = { 0,0 };
 
             WinQueryWindowPos(hwnd, &swp);
             WinMapWindowPoints(hwnd, HWND_DESKTOP, &pointl, 1);
@@ -302,10 +304,10 @@ static BOOL voUpdate(PVODATA pVOData, HWND hwnd, SDL_Rect *pSDLRects,
             debug_os2("Not enough stack size");
             return FALSE;
         }
-        memset(pbLineMask, 0, pVOData->ulHeight);
+        SDL_memset(pbLineMask, 0, pVOData->ulHeight);
 
         for ( ; ((LONG)cSDLRects) > 0; cSDLRects--, pSDLRects++) {
-            memset(&pbLineMask[pSDLRects->y], 1, pSDLRects->h);
+            SDL_memset(&pbLineMask[pSDLRects->y], 1, pSDLRects->h);
         }
 
         ulRC = DiveBlitImageLines(pVOData->hDive, pVOData->ulDIVEBufNum,
diff --git a/Engine/lib/sdl/src/video/os2/SDL_os2messagebox.c b/Engine/lib/sdl/src/video/os2/SDL_os2messagebox.c
index e3b92672d..c904fa5cb 100644
--- a/Engine/lib/sdl/src/video/os2/SDL_os2messagebox.c
+++ b/Engine/lib/sdl/src/video/os2/SDL_os2messagebox.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -35,8 +35,8 @@
 #define IDD_PB_FIRST        1003
 
 typedef struct _MSGBOXDLGDATA {
-    USHORT       cb;
-    HWND         hwndUnder;
+    USHORT      cb;
+    HWND        hwndUnder;
 } MSGBOXDLGDATA;
 
 static VOID _wmInitDlg(HWND hwnd, MSGBOXDLGDATA *pDlgData)
@@ -57,8 +57,8 @@ static VOID _wmInitDlg(HWND hwnd, MSGBOXDLGDATA *pDlgData)
       HWND  hwnd;   /* Button window handle. */
       ULONG ulCX;   /* Button width in dialog coordinates. */
     } aButtons[32];
-    RECTL      rectlItem;
-    HAB        hab = WinQueryAnchorBlock(hwnd);
+    RECTL   rectlItem;
+    HAB     hab = WinQueryAnchorBlock(hwnd);
 
     /* --- Align the buttons to the right/bottom. --- */
 
@@ -66,10 +66,10 @@ static VOID _wmInitDlg(HWND hwnd, MSGBOXDLGDATA *pDlgData)
     hEnum = WinBeginEnumWindows(hwnd);
 
     while ((hWndNext = WinGetNextWindow(hEnum)) != NULLHANDLE) {
-        if (WinQueryClassName(hWndNext, sizeof(acBuf), acBuf) == 0)
+        if (WinQueryClassName(hWndNext, sizeof(acBuf), acBuf) == 0) {
             continue;
-
-        if (strcmp(acBuf, "#3") == 0) { /* Class name of button. */
+        }
+        if (SDL_strcmp(acBuf, "#3") == 0) { /* Class name of button. */
             if (cButtons < sizeof(aButtons) / sizeof(struct _BUTTON)) {
                 aButtons[cButtons].hwnd = hWndNext;
                 cButtons++;
@@ -92,7 +92,7 @@ static VOID _wmInitDlg(HWND hwnd, MSGBOXDLGDATA *pDlgData)
         /* Convert text size to dialog coordinates. */
         WinMapDlgPoints(hwnd, &aptText[TXTBOX_TOPRIGHT], 1, FALSE);
         /* Add vertical and horizontal space for button's frame (dialog coord.). */
-        if (aptText[TXTBOX_TOPRIGHT].x < 30) {/* Minimal button width. */
+        if (aptText[TXTBOX_TOPRIGHT].x < 30) {          /* Minimal button width. */
             aptText[TXTBOX_TOPRIGHT].x = 30;
         } else {
             aptText[TXTBOX_TOPRIGHT].x += 4;
@@ -176,7 +176,7 @@ static VOID _wmInitDlg(HWND hwnd, MSGBOXDLGDATA *pDlgData)
                     SWP_MOVE | SWP_SIZE);
 }
 
-MRESULT EXPENTRY DynDlgProc(HWND hwnd, USHORT message, MPARAM mp1, MPARAM mp2)
+static MRESULT EXPENTRY DynDlgProc(HWND hwnd, USHORT message, MPARAM mp1, MPARAM mp2)
 {
     switch (message) {
     case WM_INITDLG:
@@ -205,10 +205,10 @@ static HWND _makeDlg(const SDL_MessageBoxData *messageboxdata)
         pSDLBtnData =  (SDL_MessageBoxButtonData *)messageboxdata->buttons;
     ULONG               cSDLBtnData = messageboxdata->numbuttons;
 
-    PSZ                 pszTitle = OS2_UTF8ToSys((PSZ) messageboxdata->title);
-    ULONG               cbTitle = (pszTitle == NULL)? 0 : strlen(pszTitle);
-    PSZ                 pszText = OS2_UTF8ToSys((PSZ) messageboxdata->message);
-    ULONG               cbText = (pszText == NULL)? 0 : strlen(pszText);
+    PSZ                 pszTitle = OS2_UTF8ToSys(messageboxdata->title);
+    ULONG               cbTitle  = (pszTitle == NULL)? 1 : (SDL_strlen(pszTitle) + 1);
+    PSZ                 pszText  = OS2_UTF8ToSys(messageboxdata->message);
+    ULONG               cbText   = (pszText  == NULL)? 1 : (SDL_strlen(pszText) + 1);
 
     PDLGTEMPLATE        pTemplate;
     ULONG               cbTemplate;
@@ -218,28 +218,34 @@ static HWND _makeDlg(const SDL_MessageBoxData *messageboxdata)
     PSZ                 pszBtnText;
     ULONG               cbBtnText;
     HWND                hwnd;
+
     const SDL_MessageBoxColor* pSDLColors = (messageboxdata->colorScheme == NULL)?
                                        NULL : messageboxdata->colorScheme->colors;
     const SDL_MessageBoxColor* pSDLColor;
+
     MSGBOXDLGDATA       stDlgData;
 
     /* Build a dialog tamplate in memory */
 
-    /* Size of template (cbTemplate). */
+    /* Size of template */
     cbTemplate = sizeof(DLGTEMPLATE) + ((2 + cSDLBtnData) * sizeof(DLGTITEM)) +
                  sizeof(ULONG) +  /* First item data - frame control data. */
-                 cbTitle + 1 +    /* First item data - frame title + ZERO. */
-                 cbText + 1 +     /* Second item data - ststic text + ZERO.*/
+                 cbTitle       +  /* First item data - frame title + ZERO. */
+                 cbText        +  /* Second item data - ststic text + ZERO.*/
                  3;               /* Third item data - system icon Id.     */
+
     /* Button items datas - text for buttons. */
     for (ulIdx = 0; ulIdx < cSDLBtnData; ulIdx++) {
         pszBtnText = (PSZ)pSDLBtnData[ulIdx].text;
-        cbTemplate += (pszBtnText == NULL)? 1 : (strlen(pszBtnText) + 1);
+        cbTemplate += (pszBtnText == NULL)? 1 : (SDL_strlen(pszBtnText) + 1);
     }
+
     /* Presentation parameter space. */
-    if (pSDLColors != NULL)
-        cbTemplate += 26 /* PP for frame. */ + 26 /* PP for static text. */ +
+    if (pSDLColors != NULL) {
+        cbTemplate += 26 /* PP for frame.       */ +
+                      26 /* PP for static text. */ +
                      (48 * cSDLBtnData); /* PP for buttons. */
+    }
 
     /* Allocate memory for the dialog template. */
     pTemplate = (PDLGTEMPLATE) SDL_malloc(cbTemplate);
@@ -268,11 +274,11 @@ static HWND _makeDlg(const SDL_MessageBoxData *messageboxdata)
     pDlgItem->cchClassName = 0;
     pDlgItem->offClassName = (USHORT)WC_FRAME;
     /* Length of text. */
-    pDlgItem->cchText = cbTitle + 1; /* +1 - trailing ZERO. */
+    pDlgItem->cchText = cbTitle;
     pDlgItem->offText = pcDlgData - (PCHAR)pTemplate; /* Offset to title text.  */
     /* Copy text for the title into the dialog template. */
     if (pszTitle != NULL) {
-        strcpy(pcDlgData, pszTitle);
+        SDL_memcpy(pcDlgData, pszTitle, cbTitle);
     } else {
         *pcDlgData = '\0';
     }
@@ -322,13 +328,13 @@ static HWND _makeDlg(const SDL_MessageBoxData *messageboxdata)
     pDlgItem->cchClassName = 0;
     pDlgItem->offClassName = (USHORT)WC_STATIC;
 
-    pDlgItem->cchText = cbText + 1;
+    pDlgItem->cchText = cbText;
     pDlgItem->offText = pcDlgData - (PCHAR)pTemplate;   /* Offset to the text. */
     /* Copy message text into the dialog template. */
     if (pszText != NULL) {
-        strcpy(pcDlgData, pszText);
+        SDL_memcpy(pcDlgData, pszText, cbText);
     } else {
-      *pcDlgData = '\0';
+        *pcDlgData = '\0';
     }
     pcDlgData += pDlgItem->cchText;
 
@@ -339,7 +345,7 @@ static HWND _makeDlg(const SDL_MessageBoxData *messageboxdata)
     pDlgItem->cx = 147;
     pDlgItem->cy = 62;  /* It will be used. */
 
-    pDlgItem->id = IDD_TEXT_MESSAGE;	  /* an ID value */
+    pDlgItem->id = IDD_TEXT_MESSAGE;      /* an ID value */
     if (pSDLColors == NULL)
         pDlgItem->offPresParams = 0;
     else {
@@ -371,8 +377,8 @@ static HWND _makeDlg(const SDL_MessageBoxData *messageboxdata)
 
     pDlgItem->cchText = 3; /* 0xFF, low byte of the icon Id, high byte of icon Id. */
     pDlgItem->offText = pcDlgData - (PCHAR)pTemplate;   /* Offset to the Id. */
-    /* Write susyem icon ID into dialog template. */
-    *pcDlgData = 0xFF; /* First byte is 0xFF - next 2 bytes is system pointer Id. */
+    /* Write system icon ID into dialog template. */
+    *((PBYTE)pcDlgData) = 0xFF; /* First byte is 0xFF, next 2 are system pointer Id. */
     pcDlgData++;
     *((PUSHORT)pcDlgData) = ((messageboxdata->flags & SDL_MESSAGEBOX_ERROR) != 0)?
                               SPTR_ICONERROR :
@@ -400,13 +406,13 @@ static HWND _makeDlg(const SDL_MessageBoxData *messageboxdata)
         pDlgItem->cchClassName = 0;  /* 0 - offClassname is WC_ constant. */
         pDlgItem->offClassName = (USHORT)WC_BUTTON;
 
-        pszBtnText = OS2_UTF8ToSys((PSZ)pSDLBtnData[ulIdx].text);
-        cbBtnText = (pszBtnText == NULL)? 0 : strlen(pszBtnText);
-        pDlgItem->cchText = cbBtnText + 1;
+        pszBtnText = OS2_UTF8ToSys(pSDLBtnData[ulIdx].text);
+        cbBtnText = (pszBtnText == NULL)? 1 : (SDL_strlen(pszBtnText) + 1);
+        pDlgItem->cchText = cbBtnText;
         pDlgItem->offText = pcDlgData - (PCHAR)pTemplate; /* Offset to the text. */
         /* Copy text for the button into the dialog template. */
         if (pszBtnText != NULL) {
-            strcpy(pcDlgData, pszBtnText);
+            SDL_memcpy(pcDlgData, pszBtnText, cbBtnText);
         } else {
             *pcDlgData = '\0';
         }
@@ -430,7 +436,7 @@ static HWND _makeDlg(const SDL_MessageBoxData *messageboxdata)
 
         pDlgItem->id = IDD_PB_FIRST + ulIdx;  /* an ID value */
         if (pSDLColors == NULL)
-          pDlgItem->offPresParams = 0;
+            pDlgItem->offPresParams = 0;
         else {
             /* Presentation parameter for the button - dialog colors. */
             pDlgItem->offPresParams = pcDlgData - (PCHAR)pTemplate;
diff --git a/Engine/lib/sdl/src/video/os2/SDL_os2messagebox.h b/Engine/lib/sdl/src/video/os2/SDL_os2messagebox.h
index 9f81986d0..c3b8969df 100644
--- a/Engine/lib/sdl/src/video/os2/SDL_os2messagebox.h
+++ b/Engine/lib/sdl/src/video/os2/SDL_os2messagebox.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/os2/SDL_os2mouse.c b/Engine/lib/sdl/src/video/os2/SDL_os2mouse.c
index 3ba1c5202..dd0b7c193 100644
--- a/Engine/lib/sdl/src/video/os2/SDL_os2mouse.c
+++ b/Engine/lib/sdl/src/video/os2/SDL_os2mouse.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/os2/SDL_os2mouse.h b/Engine/lib/sdl/src/video/os2/SDL_os2mouse.h
index 30b21d66d..52f5ba3f7 100644
--- a/Engine/lib/sdl/src/video/os2/SDL_os2mouse.h
+++ b/Engine/lib/sdl/src/video/os2/SDL_os2mouse.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/os2/SDL_os2output.h b/Engine/lib/sdl/src/video/os2/SDL_os2output.h
index bc3d2a6b2..7ded650e9 100644
--- a/Engine/lib/sdl/src/video/os2/SDL_os2output.h
+++ b/Engine/lib/sdl/src/video/os2/SDL_os2output.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/os2/SDL_os2util.c b/Engine/lib/sdl/src/video/os2/SDL_os2util.c
index 6ed0bd98c..bcc6c54e8 100644
--- a/Engine/lib/sdl/src/video/os2/SDL_os2util.c
+++ b/Engine/lib/sdl/src/video/os2/SDL_os2util.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -27,8 +27,8 @@
 HPOINTER utilCreatePointer(SDL_Surface *surface, ULONG ulHotX, ULONG ulHotY)
 {
     HBITMAP             hbm;
-    BITMAPINFOHEADER2   bmih = { 0 };
-    BITMAPINFO          bmi = { 0 };
+    BITMAPINFOHEADER2   bmih;
+    BITMAPINFO          bmi;
     HPS                 hps;
     PULONG              pulBitmap;
     PULONG              pulDst, pulSrc, pulDstMask;
@@ -40,7 +40,7 @@ HPOINTER utilCreatePointer(SDL_Surface *surface, ULONG ulHotX, ULONG ulHotY)
         return NULLHANDLE;
     }
 
-    pulBitmap = SDL_malloc(surface->h * surface->w * 4 * 2);
+    pulBitmap = (PULONG) SDL_malloc(surface->h * surface->w * 2 * sizeof(ULONG));
     if (pulBitmap == NULL) {
         SDL_OutOfMemory();
         return NULLHANDLE;
@@ -72,6 +72,9 @@ HPOINTER utilCreatePointer(SDL_Surface *surface, ULONG ulHotX, ULONG ulHotY)
     }
 
     /* Create system bitmap object. */
+    SDL_zero(bmih);
+    SDL_zero(bmi);
+
     bmih.cbFix          = sizeof(BITMAPINFOHEADER2);
     bmih.cx             = surface->w;
     bmih.cy             = 2 * surface->h;
diff --git a/Engine/lib/sdl/src/video/os2/SDL_os2util.h b/Engine/lib/sdl/src/video/os2/SDL_os2util.h
index c60d9faaa..9379dec54 100644
--- a/Engine/lib/sdl/src/video/os2/SDL_os2util.h
+++ b/Engine/lib/sdl/src/video/os2/SDL_os2util.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/os2/SDL_os2video.c b/Engine/lib/sdl/src/video/os2/SDL_os2video.c
index 76a9696b0..64731d71d 100644
--- a/Engine/lib/sdl/src/video/os2/SDL_os2video.c
+++ b/Engine/lib/sdl/src/video/os2/SDL_os2video.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -133,7 +133,7 @@ static BOOL _getSDLPixelFormatData(SDL_PixelFormat *pSDLPixelFormat,
 
     default:
 /*      printf("Unknown color encoding: %.4s\n", fccColorEncoding);*/
-        memset(pSDLPixelFormat, 0, sizeof(SDL_PixelFormat));
+        SDL_memset(pSDLPixelFormat, 0, sizeof(SDL_PixelFormat));
         return FALSE;
     }
 
@@ -183,7 +183,7 @@ static VOID _mouseCheck(WINDATA *pWinData)
 {
     SDL_Mouse *pSDLMouse = SDL_GetMouse();
 
-    if ((pSDLMouse->relative_mode || (pWinData->window->flags & SDL_WINDOW_INPUT_GRABBED) != 0) &&
+    if ((pSDLMouse->relative_mode || (pWinData->window->flags & SDL_WINDOW_MOUSE_GRABBED) != 0) &&
         ((pWinData->window->flags & SDL_WINDOW_INPUT_FOCUS) != 0)) {
         /* We will make a real capture in _wmMouseButton() */
     } else {
@@ -232,7 +232,7 @@ static VOID _wmMouseMove(WINDATA *pWinData, SHORT lX, SHORT lY)
 
     if (!pSDLMouse->relative_mode || pSDLMouse->relative_mode_warp) {
         if (!pSDLMouse->relative_mode && fWinActive &&
-            ((pWinData->window->flags & SDL_WINDOW_INPUT_GRABBED) != 0) &&
+            ((pWinData->window->flags & SDL_WINDOW_MOUSE_GRABBED) != 0) &&
             (WinQueryCapture(HWND_DESKTOP) == pWinData->hwnd)) {
 
             pointl.x = lX;
@@ -281,7 +281,7 @@ static VOID _wmMouseButton(WINDATA *pWinData, ULONG ulButton, BOOL fDown)
                                       SDL_BUTTON_MIDDLE };
     SDL_Mouse *pSDLMouse = SDL_GetMouse();
 
-    if ((pSDLMouse->relative_mode || ((pWinData->window->flags & SDL_WINDOW_INPUT_GRABBED) != 0)) &&
+    if ((pSDLMouse->relative_mode || ((pWinData->window->flags & SDL_WINDOW_MOUSE_GRABBED) != 0)) &&
         ((pWinData->window->flags & SDL_WINDOW_INPUT_FOCUS) != 0) &&
         (WinQueryCapture(HWND_DESKTOP) != pWinData->hwnd)) {
         /* Mouse should be captured. */
@@ -320,17 +320,22 @@ static VOID _wmChar(WINDATA *pWinData, MPARAM mp1, MPARAM mp2)
     }
 
     if ((ulFlags & KC_CHAR) != 0) {
-        CHAR    acUTF8[4];
-        LONG    lRC = StrUTF8(1, acUTF8, sizeof(acUTF8), (PSZ)&ulCharCode, 1);
-
-        SDL_SendKeyboardText((lRC > 0)? acUTF8 : (PSZ)&ulCharCode);
+#if defined(HAVE_ICONV) && defined(HAVE_ICONV_H)
+        char *utf8 = SDL_iconv_string("UTF-8", "", (char *)&ulCharCode, 1);
+        SDL_SendKeyboardText((utf8 && *utf8) ? utf8 : (char *)&ulCharCode);
+        SDL_free(utf8);
+#else
+        char utf8[4];
+        int rc = StrUTF8(1, utf8, sizeof(utf8), (char *)&ulCharCode, 1);
+        SDL_SendKeyboardText((rc > 0) ? utf8 : (char *) &ulCharCode);
+#endif
     }
 }
 
 static VOID _wmMove(WINDATA *pWinData)
 {
     SDL_DisplayMode *pSDLDisplayMode = _getDisplayModeForSDLWindow(pWinData->window);
-    POINTL  pointl = { 0 };
+    POINTL  pointl = { 0,0 };
     RECTL   rectl;
 
     WinQueryWindowRect(pWinData->hwnd, &rectl);
@@ -389,7 +394,7 @@ static MRESULT _wmDrop(WINDATA *pWinData, PDRAGINFO pDragInfo)
 {
     ULONG       ulIdx;
     PDRAGITEM   pDragItem;
-    CHAR        acFName[_MAX_PATH];
+    CHAR        acFName[CCHMAXPATH];
     PCHAR       pcFName;
 
     if (!DrgAccessDraginfo(pDragInfo))
@@ -403,7 +408,7 @@ static MRESULT _wmDrop(WINDATA *pWinData, PDRAGINFO pDragInfo)
             pDragItem->hstrSourceName != NULLHANDLE) {
             /* Get file name from the item. */
             DrgQueryStrName(pDragItem->hstrContainerName, sizeof(acFName), acFName);
-            pcFName = strchr(acFName, '\0');
+            pcFName = SDL_strchr(acFName, '\0');
             DrgQueryStrName(pDragItem->hstrSourceName,
                             sizeof(acFName) - (pcFName - acFName), pcFName);
 
@@ -428,7 +433,7 @@ static MRESULT _wmDrop(WINDATA *pWinData, PDRAGINFO pDragInfo)
     return (MRESULT)FALSE;
 }
 
-MRESULT EXPENTRY wndFrameProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
+static MRESULT EXPENTRY wndFrameProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
 {
     HWND    hwndClient = WinQueryWindow(hwnd, QW_BOTTOM);
     WINDATA * pWinData = (WINDATA *)WinQueryWindowULong(hwndClient, 0);
@@ -535,7 +540,7 @@ MRESULT EXPENTRY wndFrameProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
     return pWinData->fnWndFrameProc(hwnd, msg, mp1, mp2);
 }
 
-MRESULT EXPENTRY wndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
+static MRESULT EXPENTRY wndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
 {
     WINDATA *pWinData = (WINDATA *)WinQueryWindowULong(hwnd, 0);
 
@@ -589,7 +594,7 @@ MRESULT EXPENTRY wndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
             WinQueryPointerPos(HWND_DESKTOP, &pointl);
             WinMapWindowPoints(HWND_DESKTOP, pWinData->hwnd, &pointl, 1);
             SDL_SendMouseMotion(pWinData->window, 0, 0,
-                                    pointl.x, pWinData->window->h - pointl.y - 1);
+                                pointl.x, pWinData->window->h - pointl.y - 1);
         } else {
             if (SDL_GetKeyboardFocus() == pWinData->window)
                 SDL_SetKeyboardFocus(NULL);
@@ -691,7 +696,7 @@ MRESULT EXPENTRY wndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
 }
 
 
-/*  SDL routnes.
+/*  SDL routines.
  *  ------------
  */
 
@@ -1147,7 +1152,7 @@ static int OS2_SetWindowHitTest(SDL_Window *window, SDL_bool enabled)
   return 0;
 }
 
-static void OS2_SetWindowGrab(_THIS, SDL_Window *window, SDL_bool grabbed)
+static void OS2_SetWindowMouseGrab(_THIS, SDL_Window *window, SDL_bool grabbed)
 {
     WINDATA *pWinData = (WINDATA *)window->driverdata;
 
@@ -1214,7 +1219,7 @@ static int OS2_SetWindowShape(SDL_WindowShaper *shaper, SDL_Surface *shape,
 {
     SDL_ShapeTree *pShapeTree;
     WINDATA       *pWinData;
-    SHAPERECTS     stShapeRects = { 0 };
+    SHAPERECTS     stShapeRects;
     HPS            hps;
 
     debug_os2("Enter");
@@ -1230,6 +1235,7 @@ static int OS2_SetWindowShape(SDL_WindowShaper *shaper, SDL_Surface *shape,
     pShapeTree = SDL_CalculateShapeTree(*shape_mode, shape);
     shaper->driverdata = pShapeTree;
 
+    SDL_zero(stShapeRects);
     stShapeRects.ulWinHeight = shaper->window->h;
     SDL_TraverseShapeTree(pShapeTree, &_combineRectRegions, &stShapeRects);
 
@@ -1343,9 +1349,9 @@ static int OS2_SetClipboardText(_THIS, const char *text)
     debug_os2("Enter");
     if (pszText == NULL)
         return -1;
-    cbText = SDL_strlen(pszText);
+    cbText = SDL_strlen(pszText) + 1;
 
-    ulRC = DosAllocSharedMem((PPVOID)&pszClipboard, 0, cbText + 1,
+    ulRC = DosAllocSharedMem((PPVOID)&pszClipboard, 0, cbText,
                               PAG_COMMIT | PAG_READ | PAG_WRITE |
                               OBJ_GIVEABLE | OBJ_GETTABLE | OBJ_TILE);
     if (ulRC != NO_ERROR) {
@@ -1354,7 +1360,7 @@ static int OS2_SetClipboardText(_THIS, const char *text)
         return -1;
     }
 
-    strcpy(pszClipboard, pszText);
+    SDL_memcpy(pszClipboard, pszText, cbText);
     SDL_free(pszText);
 
     if (!WinOpenClipbrd(pVData->hab)) {
@@ -1396,18 +1402,19 @@ static char *OS2_GetClipboardText(_THIS)
 static SDL_bool OS2_HasClipboardText(_THIS)
 {
     SDL_VideoData *pVData = (SDL_VideoData *)_this->driverdata;
-    SDL_bool   fClipboard;
+    PSZ pszClipboard;
+    SDL_bool  result;
 
     if (!WinOpenClipbrd(pVData->hab)) {
         debug_os2("WinOpenClipbrd() failed");
         return SDL_FALSE;
     }
 
-    fClipboard = ((PSZ)WinQueryClipbrdData(pVData->hab, CF_TEXT) != NULL)?
-                   SDL_TRUE : SDL_FALSE;
+    pszClipboard = (PSZ)WinQueryClipbrdData(pVData->hab, CF_TEXT);
+    result = (pszClipboard && *pszClipboard) ? SDL_TRUE : SDL_FALSE;
     WinCloseClipbrd(pVData->hab);
 
-    return fClipboard;
+    return result;
 }
 
 
@@ -1444,7 +1451,7 @@ static int OS2_VideoInit(_THIS)
         return SDL_SetError("Window class not successfully registered.");
     }
 
-    if (stricmp(_this->name, OS2DRIVER_NAME_VMAN) == 0)
+    if (SDL_strcasecmp(_this->name, OS2DRIVER_NAME_VMAN) == 0)
         pVData->pOutput = &voVMan;
     else
         pVData->pOutput = &voDive;
@@ -1562,8 +1569,14 @@ static int OS2_GetDisplayDPI(_THIS, SDL_VideoDisplay *display, float *ddpi,
 
 static void OS2_GetDisplayModes(_THIS, SDL_VideoDisplay *display)
 {
+    SDL_DisplayMode mode;
+
     debug_os2("Enter");
-    SDL_AddDisplayMode(display, &display->current_mode);
+    SDL_memcpy(&mode, &display->current_mode, sizeof(SDL_DisplayMode));
+    mode.driverdata = (MODEDATA *) SDL_malloc(sizeof(MODEDATA));
+    if (!mode.driverdata) return; /* yikes.. */
+    SDL_memcpy(mode.driverdata, display->current_mode.driverdata, sizeof(MODEDATA));
+    SDL_AddDisplayMode(display, &mode);
 }
 
 static int OS2_SetDisplayMode(_THIS, SDL_VideoDisplay *display,
@@ -1616,7 +1629,7 @@ static SDL_VideoDevice *OS2_CreateDevice(int devindex)
     device->GetWindowWMInfo = OS2_GetWindowWMInfo;
     device->OnWindowEnter = OS2_OnWindowEnter;
     device->SetWindowHitTest = OS2_SetWindowHitTest;
-    device->SetWindowGrab = OS2_SetWindowGrab;
+    device->SetWindowMouseGrab = OS2_SetWindowMouseGrab;
     device->CreateWindowFramebuffer = OS2_CreateWindowFramebuffer;
     device->UpdateWindowFramebuffer = OS2_UpdateWindowFramebuffer;
     device->DestroyWindowFramebuffer = OS2_DestroyWindowFramebuffer;
diff --git a/Engine/lib/sdl/src/video/os2/SDL_os2video.h b/Engine/lib/sdl/src/video/os2/SDL_os2video.h
index cb27ed23e..688410c68 100644
--- a/Engine/lib/sdl/src/video/os2/SDL_os2video.h
+++ b/Engine/lib/sdl/src/video/os2/SDL_os2video.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/os2/SDL_os2vman.c b/Engine/lib/sdl/src/video/os2/SDL_os2vman.c
index c55efe1eb..acb920061 100644
--- a/Engine/lib/sdl/src/video/os2/SDL_os2vman.c
+++ b/Engine/lib/sdl/src/video/os2/SDL_os2vman.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -31,7 +31,7 @@
 #include "SDL_os2output.h"
 #include "SDL_os2video.h"
 
-#include "my_gradd.h"
+#include "SDL_gradd.h"
 
 typedef struct _VODATA {
   PVOID    pBuffer;
@@ -78,7 +78,7 @@ static HMODULE  hmodVMan = NULLHANDLE;
 static FNVMIENTRY *pfnVMIEntry = NULL;
 static ULONG        ulVRAMAddress = 0;
 
-VOID APIENTRY ExitVMan(VOID)
+static VOID APIENTRY ExitVMan(VOID)
 {
     if (ulVRAMAddress != 0 && hmodVMan != NULLHANDLE) {
         pfnVMIEntry(0, VMI_CMD_TERMPROC, NULL, NULL);
@@ -91,10 +91,10 @@ VOID APIENTRY ExitVMan(VOID)
 static BOOL _vmanInit(void)
 {
     ULONG       ulRC;
-    CHAR        acBuf[255];
+    CHAR        acBuf[256];
     INITPROCOUT stInitProcOut;
 
-    if (hmodVMan != NULLHANDLE) /* Already was initialized */
+    if (hmodVMan != NULLHANDLE) /* already initialized */
         return TRUE;
 
     /* Load vman.dll */
@@ -108,8 +108,7 @@ static BOOL _vmanInit(void)
     /* Get VMIEntry */
     ulRC = DosQueryProcAddr(hmodVMan, 0L, "VMIEntry", (PFN *)&pfnVMIEntry);
     if (ulRC != NO_ERROR) {
-        debug_os2("Could not query address of pfnVMIEntry func. of VMAN.DLL, "
-                  "rc = %u", ulRC);
+        debug_os2("Could not query address of VMIEntry from VMAN.DLL (Err: %lu)", ulRC);
         DosFreeModule(hmodVMan);
         hmodVMan = NULLHANDLE;
         return FALSE;
@@ -327,9 +326,8 @@ static BOOL voUpdate(PVODATA pVOData, HWND hwnd, SDL_Rect *pSDLRects,
     PPOINTL     pptlSrcOrg;
     PBLTRECT    pbrDst;
     HWREQIN     sHWReqIn;
-    BITBLTINFO  sBitbltInfo = { 0 };
+    BITBLTINFO  sBitbltInfo;
     ULONG       ulIdx;
-/*  RECTL       rectlScreenUpdate;*/
 
     if (pVOData->pBuffer == NULL)
         return FALSE;
@@ -454,6 +452,7 @@ static BOOL voUpdate(PVODATA pVOData, HWND hwnd, SDL_Rect *pSDLRects,
         rclSrcBounds.xRight = bmiSrc.ulWidth;
         rclSrcBounds.yTop = bmiSrc.ulHeight;
 
+        SDL_zero(sBitbltInfo);
         sBitbltInfo.ulLength = sizeof(BITBLTINFO);
         sBitbltInfo.ulBltFlags = BF_DEFAULT_STATE | BF_ROP_INCL_SRC | BF_PAT_HOLLOW;
         sBitbltInfo.cBlits = cSDLRects;
diff --git a/Engine/lib/sdl/src/video/pandora/SDL_pandora.c b/Engine/lib/sdl/src/video/pandora/SDL_pandora.c
index e78c0f2e5..16349f875 100644
--- a/Engine/lib/sdl/src/video/pandora/SDL_pandora.c
+++ b/Engine/lib/sdl/src/video/pandora/SDL_pandora.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -114,7 +114,6 @@ PND_create()
     device->MaximizeWindow = PND_maximizewindow;
     device->MinimizeWindow = PND_minimizewindow;
     device->RestoreWindow = PND_restorewindow;
-    device->SetWindowGrab = PND_setwindowgrab;
     device->DestroyWindow = PND_destroywindow;
 #if 0
     device->GetWindowWMInfo = PND_getwindowwminfo;
@@ -287,10 +286,6 @@ PND_restorewindow(_THIS, SDL_Window * window)
 {
 }
 void
-PND_setwindowgrab(_THIS, SDL_Window * window, SDL_bool grabbed)
-{
-}
-void
 PND_destroywindow(_THIS, SDL_Window * window)
 {
     SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;
@@ -617,7 +612,7 @@ PND_gl_createcontext(_THIS, SDL_Window * window)
 
 #ifdef WIZ_GLES_LITE
     if( !hNativeWnd ) {
-    hNativeWnd = (NativeWindowType)malloc(16*1024);
+    hNativeWnd = (NativeWindowType)SDL_malloc(16*1024);
 
     if(!hNativeWnd)
         printf( "Error: Wiz framebuffer allocatation failed\n" );
@@ -824,7 +819,7 @@ PND_gl_deletecontext(_THIS, SDL_GLContext context)
 #ifdef WIZ_GLES_LITE
     if( hNativeWnd != 0 )
     {
-      free(hNativeWnd);
+      SDL_free(hNativeWnd);
       hNativeWnd = 0;
       printf( "SDL: Wiz framebuffer released\n" );
     }
diff --git a/Engine/lib/sdl/src/video/pandora/SDL_pandora.h b/Engine/lib/sdl/src/video/pandora/SDL_pandora.h
index 0d8569108..0954cd3af 100644
--- a/Engine/lib/sdl/src/video/pandora/SDL_pandora.h
+++ b/Engine/lib/sdl/src/video/pandora/SDL_pandora.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -77,7 +77,6 @@ void PND_raisewindow(_THIS, SDL_Window * window);
 void PND_maximizewindow(_THIS, SDL_Window * window);
 void PND_minimizewindow(_THIS, SDL_Window * window);
 void PND_restorewindow(_THIS, SDL_Window * window);
-void PND_setwindowgrab(_THIS, SDL_Window * window, SDL_bool grabbed);
 void PND_destroywindow(_THIS, SDL_Window * window);
 
 /* Window manager function */
diff --git a/Engine/lib/sdl/src/video/pandora/SDL_pandora_events.c b/Engine/lib/sdl/src/video/pandora/SDL_pandora_events.c
index 779a19940..ab077d5dd 100644
--- a/Engine/lib/sdl/src/video/pandora/SDL_pandora_events.c
+++ b/Engine/lib/sdl/src/video/pandora/SDL_pandora_events.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/pandora/SDL_pandora_events.h b/Engine/lib/sdl/src/video/pandora/SDL_pandora_events.h
index 399f69f14..8ad8e355d 100644
--- a/Engine/lib/sdl/src/video/pandora/SDL_pandora_events.h
+++ b/Engine/lib/sdl/src/video/pandora/SDL_pandora_events.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/psp/SDL_pspevents.c b/Engine/lib/sdl/src/video/psp/SDL_pspevents.c
index 37c711361..04a804770 100644
--- a/Engine/lib/sdl/src/video/psp/SDL_pspevents.c
+++ b/Engine/lib/sdl/src/video/psp/SDL_pspevents.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -34,6 +34,7 @@
 #include "SDL_keyboard.h"
 #include "../../thread/SDL_systhread.h"
 #include <psphprm.h>
+#include <pspthreadman.h>
 
 #ifdef PSPIRKEYB
 #include <pspirkeyb.h>
diff --git a/Engine/lib/sdl/src/video/psp/SDL_pspevents_c.h b/Engine/lib/sdl/src/video/psp/SDL_pspevents_c.h
index 39bd39cc5..8a55dde23 100644
--- a/Engine/lib/sdl/src/video/psp/SDL_pspevents_c.h
+++ b/Engine/lib/sdl/src/video/psp/SDL_pspevents_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/psp/SDL_pspgl.c b/Engine/lib/sdl/src/video/psp/SDL_pspgl.c
index 8a99e1d14..ca55ea251 100644
--- a/Engine/lib/sdl/src/video/psp/SDL_pspgl.c
+++ b/Engine/lib/sdl/src/video/psp/SDL_pspgl.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/psp/SDL_pspgl_c.h b/Engine/lib/sdl/src/video/psp/SDL_pspgl_c.h
index a30a9bd0d..06822f37e 100644
--- a/Engine/lib/sdl/src/video/psp/SDL_pspgl_c.h
+++ b/Engine/lib/sdl/src/video/psp/SDL_pspgl_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/psp/SDL_pspmouse.c b/Engine/lib/sdl/src/video/psp/SDL_pspmouse.c
index 61f00b1fc..926f63977 100644
--- a/Engine/lib/sdl/src/video/psp/SDL_pspmouse.c
+++ b/Engine/lib/sdl/src/video/psp/SDL_pspmouse.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/psp/SDL_pspmouse_c.h b/Engine/lib/sdl/src/video/psp/SDL_pspmouse_c.h
index e47ba252a..7ffee6f92 100644
--- a/Engine/lib/sdl/src/video/psp/SDL_pspmouse_c.h
+++ b/Engine/lib/sdl/src/video/psp/SDL_pspmouse_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/psp/SDL_pspvideo.c b/Engine/lib/sdl/src/video/psp/SDL_pspvideo.c
index fa1139ecd..a5c86ecc3 100644
--- a/Engine/lib/sdl/src/video/psp/SDL_pspvideo.c
+++ b/Engine/lib/sdl/src/video/psp/SDL_pspvideo.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -112,7 +112,6 @@ PSP_Create()
     device->MaximizeWindow = PSP_MaximizeWindow;
     device->MinimizeWindow = PSP_MinimizeWindow;
     device->RestoreWindow = PSP_RestoreWindow;
-    device->SetWindowGrab = PSP_SetWindowGrab;
     device->DestroyWindow = PSP_DestroyWindow;
 #if 0
     device->GetWindowWMInfo = PSP_GetWindowWMInfo;
@@ -159,7 +158,6 @@ PSP_VideoInit(_THIS)
     current_mode.refresh_rate = 60;
     /* 32 bpp for default */
     current_mode.format = SDL_PIXELFORMAT_ABGR8888;
-
     current_mode.driverdata = NULL;
 
     SDL_zero(display);
@@ -167,8 +165,15 @@ PSP_VideoInit(_THIS)
     display.current_mode = current_mode;
     display.driverdata = NULL;
 
-    SDL_AddVideoDisplay(&display, SDL_FALSE);
+    SDL_AddDisplayMode(&display, &current_mode);
 
+    /* 16 bpp secondary mode */
+    current_mode.format = SDL_PIXELFORMAT_BGR565;
+    display.desktop_mode = current_mode;
+    display.current_mode = current_mode;
+    SDL_AddDisplayMode(&display, &current_mode);
+
+    SDL_AddVideoDisplay(&display, SDL_FALSE);
     return 1;
 }
 
@@ -215,6 +220,7 @@ PSP_CreateWindow(_THIS, SDL_Window * window)
     /* Setup driver data for this window */
     window->driverdata = wdata;
 
+    SDL_SetKeyboardFocus(window);
 
     /* Window has been successfully created */
     return 0;
@@ -265,11 +271,6 @@ PSP_MinimizeWindow(_THIS, SDL_Window * window)
 void
 PSP_RestoreWindow(_THIS, SDL_Window * window)
 {
-}
-void
-PSP_SetWindowGrab(_THIS, SDL_Window * window, SDL_bool grabbed)
-{
-
 }
 void
 PSP_DestroyWindow(_THIS, SDL_Window * window)
diff --git a/Engine/lib/sdl/src/video/psp/SDL_pspvideo.h b/Engine/lib/sdl/src/video/psp/SDL_pspvideo.h
index 484df87d3..e046c891e 100644
--- a/Engine/lib/sdl/src/video/psp/SDL_pspvideo.h
+++ b/Engine/lib/sdl/src/video/psp/SDL_pspvideo.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -73,7 +73,6 @@ void PSP_RaiseWindow(_THIS, SDL_Window * window);
 void PSP_MaximizeWindow(_THIS, SDL_Window * window);
 void PSP_MinimizeWindow(_THIS, SDL_Window * window);
 void PSP_RestoreWindow(_THIS, SDL_Window * window);
-void PSP_SetWindowGrab(_THIS, SDL_Window * window, SDL_bool grabbed);
 void PSP_DestroyWindow(_THIS, SDL_Window * window);
 
 /* Window manager function */
diff --git a/Engine/lib/sdl/src/video/qnx/gl.c b/Engine/lib/sdl/src/video/qnx/gl.c
index 19e1bd4f7..1862ab425 100644
--- a/Engine/lib/sdl/src/video/qnx/gl.c
+++ b/Engine/lib/sdl/src/video/qnx/gl.c
@@ -85,7 +85,7 @@ glGetConfig(EGLConfig *pconf, int *pformat)
     }
 
     // Allocate enough memory for all configurations.
-    egl_configs = malloc(egl_num_configs * sizeof(*egl_configs));
+    egl_configs = SDL_malloc(egl_num_configs * sizeof(*egl_configs));
     if (egl_configs == NULL) {
         return -1;
     }
@@ -94,7 +94,7 @@ glGetConfig(EGLConfig *pconf, int *pformat)
     rc = eglGetConfigs(egl_disp, egl_configs, egl_num_configs,
                        &egl_num_configs);
     if (rc != EGL_TRUE) {
-        free(egl_configs);
+        SDL_free(egl_configs);
         return -1;
     }
 
@@ -119,7 +119,7 @@ glGetConfig(EGLConfig *pconf, int *pformat)
         break;
     }
 
-    free(egl_configs);
+    SDL_free(egl_configs);
     *pconf = egl_conf;
     *pformat = chooseFormat(egl_conf);
 
diff --git a/Engine/lib/sdl/src/video/raspberry/SDL_rpievents.c b/Engine/lib/sdl/src/video/raspberry/SDL_rpievents.c
index c2847b36d..31cd1bdc6 100644
--- a/Engine/lib/sdl/src/video/raspberry/SDL_rpievents.c
+++ b/Engine/lib/sdl/src/video/raspberry/SDL_rpievents.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/raspberry/SDL_rpievents_c.h b/Engine/lib/sdl/src/video/raspberry/SDL_rpievents_c.h
index 20e04e91c..9bec91529 100644
--- a/Engine/lib/sdl/src/video/raspberry/SDL_rpievents_c.h
+++ b/Engine/lib/sdl/src/video/raspberry/SDL_rpievents_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/raspberry/SDL_rpimouse.c b/Engine/lib/sdl/src/video/raspberry/SDL_rpimouse.c
index 1ed140420..7614fb8c0 100644
--- a/Engine/lib/sdl/src/video/raspberry/SDL_rpimouse.c
+++ b/Engine/lib/sdl/src/video/raspberry/SDL_rpimouse.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/raspberry/SDL_rpimouse.h b/Engine/lib/sdl/src/video/raspberry/SDL_rpimouse.h
index 65c89df46..40701e126 100644
--- a/Engine/lib/sdl/src/video/raspberry/SDL_rpimouse.h
+++ b/Engine/lib/sdl/src/video/raspberry/SDL_rpimouse.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/raspberry/SDL_rpiopengles.c b/Engine/lib/sdl/src/video/raspberry/SDL_rpiopengles.c
index 921f3c77a..7b62b3e43 100644
--- a/Engine/lib/sdl/src/video/raspberry/SDL_rpiopengles.c
+++ b/Engine/lib/sdl/src/video/raspberry/SDL_rpiopengles.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/raspberry/SDL_rpiopengles.h b/Engine/lib/sdl/src/video/raspberry/SDL_rpiopengles.h
index 36f94ac25..2cdf0fdcf 100644
--- a/Engine/lib/sdl/src/video/raspberry/SDL_rpiopengles.h
+++ b/Engine/lib/sdl/src/video/raspberry/SDL_rpiopengles.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/raspberry/SDL_rpivideo.c b/Engine/lib/sdl/src/video/raspberry/SDL_rpivideo.c
index d077ecda3..1a0a4ce19 100644
--- a/Engine/lib/sdl/src/video/raspberry/SDL_rpivideo.c
+++ b/Engine/lib/sdl/src/video/raspberry/SDL_rpivideo.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -120,7 +120,6 @@ RPI_Create()
     device->MaximizeWindow = RPI_MaximizeWindow;
     device->MinimizeWindow = RPI_MinimizeWindow;
     device->RestoreWindow = RPI_RestoreWindow;
-    device->SetWindowGrab = RPI_SetWindowGrab;
     device->DestroyWindow = RPI_DestroyWindow;
 #if 0
     device->GetWindowWMInfo = RPI_GetWindowWMInfo;
@@ -420,11 +419,6 @@ RPI_MinimizeWindow(_THIS, SDL_Window * window)
 void
 RPI_RestoreWindow(_THIS, SDL_Window * window)
 {
-}
-void
-RPI_SetWindowGrab(_THIS, SDL_Window * window, SDL_bool grabbed)
-{
-
 }
 
 /*****************************************************************************/
diff --git a/Engine/lib/sdl/src/video/raspberry/SDL_rpivideo.h b/Engine/lib/sdl/src/video/raspberry/SDL_rpivideo.h
index 557201db6..2b5f40f4d 100644
--- a/Engine/lib/sdl/src/video/raspberry/SDL_rpivideo.h
+++ b/Engine/lib/sdl/src/video/raspberry/SDL_rpivideo.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -81,7 +81,6 @@ void RPI_RaiseWindow(_THIS, SDL_Window * window);
 void RPI_MaximizeWindow(_THIS, SDL_Window * window);
 void RPI_MinimizeWindow(_THIS, SDL_Window * window);
 void RPI_RestoreWindow(_THIS, SDL_Window * window);
-void RPI_SetWindowGrab(_THIS, SDL_Window * window, SDL_bool grabbed);
 void RPI_DestroyWindow(_THIS, SDL_Window * window);
 
 /* Window manager function */
diff --git a/Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_dyn.h b/Engine/lib/sdl/src/video/riscos/SDL_riscosdefs.h
similarity index 55%
rename from Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_dyn.h
rename to Engine/lib/sdl/src/video/riscos/SDL_riscosdefs.h
index 3cb67b08e..89a51f2b8 100644
--- a/Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_dyn.h
+++ b/Engine/lib/sdl/src/video/riscos/SDL_riscosdefs.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -18,36 +18,34 @@
      misrepresented as being the original software.
   3. This notice may not be removed or altered from any source distribution.
 */
-
-#ifndef SDL_kmsdrmdyn_h_
-#define SDL_kmsdrmdyn_h_
-
 #include "../../SDL_internal.h"
 
-#include <xf86drm.h>
-#include <xf86drmMode.h>
-#include <gbm.h>
+#ifndef SDL_riscosdefs_h_
+#define SDL_riscosdefs_h_
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+typedef struct sprite_area {
+    int size;  /*  +0 */
+    int count; /*  +4 */
+    int start; /*  +8 */
+    int end;   /* +12 */
+} sprite_area;
 
-int SDL_KMSDRM_LEGACY_LoadSymbols(void);
-void SDL_KMSDRM_LEGACY_UnloadSymbols(void);
+SDL_COMPILE_TIME_ASSERT(sprite_area, sizeof(sprite_area) == 16);
 
-/* Declare all the function pointers and wrappers... */
-#define SDL_KMSDRM_LEGACY_SYM(rc,fn,params) \
-    typedef rc (*SDL_DYNKMSDRM_LEGACYFN_##fn) params; \
-    extern SDL_DYNKMSDRM_LEGACYFN_##fn KMSDRM_LEGACY_##fn;
-#define SDL_KMSDRM_LEGACY_SYM_CONST(type, name) \
-    typedef type SDL_DYNKMSDRM_LEGACYCONST_##name; \
-    extern SDL_DYNKMSDRM_LEGACYCONST_##name KMSDRM_LEGACY_##name;
-#include "SDL_kmsdrm_legacy_sym.h"
+typedef struct sprite_header {
+    int next;         /*  +0 */
+    char name[12];    /*  +4 */
+    int width;        /* +16 */
+    int height;       /* +20 */
+    int first_bit;    /* +24 */
+    int last_bit;     /* +28 */
+    int image_offset; /* +32 */
+    int mask_offset;  /* +36 */
+    int mode;         /* +40 */
+} sprite_header;
 
-#ifdef __cplusplus
-}
-#endif
+SDL_COMPILE_TIME_ASSERT(sprite_header, sizeof(sprite_header) == 44);
 
-#endif /* SDL_kmsdrmdyn_h_ */
+#endif /* SDL_riscosdefs_h_ */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/riscos/SDL_riscosevents.c b/Engine/lib/sdl/src/video/riscos/SDL_riscosevents.c
new file mode 100644
index 000000000..b0a0d7509
--- /dev/null
+++ b/Engine/lib/sdl/src/video/riscos/SDL_riscosevents.c
@@ -0,0 +1,178 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if SDL_VIDEO_DRIVER_RISCOS
+
+#include "../../events/SDL_events_c.h"
+
+#include "SDL_log.h"
+#include "SDL_riscosvideo.h"
+#include "SDL_riscosevents_c.h"
+#include "scancodes_riscos.h"
+
+#include <kernel.h>
+#include <swis.h>
+
+static SDL_Scancode
+SDL_RISCOS_translate_keycode(int keycode)
+{
+    SDL_Scancode scancode = SDL_SCANCODE_UNKNOWN;
+
+    if (keycode < SDL_arraysize(riscos_scancode_table)) {
+        scancode = riscos_scancode_table[keycode];
+
+        if (scancode == SDL_SCANCODE_UNKNOWN) {
+            SDL_Log("The key you just pressed is not recognized by SDL: %d", keycode);
+        }
+    }
+
+    return scancode;
+}
+
+void
+RISCOS_PollKeyboard(_THIS)
+{
+    SDL_VideoData *driverdata = (SDL_VideoData *)_this->driverdata;
+    Uint8 key = 2;
+    int i;
+
+    /* Check for key releases */
+    for (i = 0; i < RISCOS_MAX_KEYS_PRESSED; i++) {
+        if (driverdata->key_pressed[i] != 255) {
+            if ((_kernel_osbyte(129, driverdata->key_pressed[i] ^ 0xff, 0xff) & 0xff) != 255) {
+                SDL_SendKeyboardKey(SDL_RELEASED, SDL_RISCOS_translate_keycode(driverdata->key_pressed[i]));
+                driverdata->key_pressed[i] = 255;
+            }
+        }
+    }
+
+    /* Check for key presses */
+    while (key < 0xff) {
+        key = _kernel_osbyte(121, key + 1, 0) & 0xff;
+        switch (key) {
+        case 255:
+        /* Ignore mouse keys */
+        case 9:
+        case 10:
+        case 11:
+        /* Ignore keys with multiple INKEY codes */
+        case 24:
+        case 40:
+        case 71:
+        case 87:
+            break;
+
+        default:
+            SDL_SendKeyboardKey(SDL_PRESSED, SDL_RISCOS_translate_keycode(key));
+
+            /* Record the press so we can detect release later. */
+            for (i = 0; i < RISCOS_MAX_KEYS_PRESSED; i++) {
+                if (driverdata->key_pressed[i] == key) {
+                    break;
+                }
+                if (driverdata->key_pressed[i] == 255) {
+                    driverdata->key_pressed[i] = key;
+                    break;
+                }
+            }
+        }
+    }
+}
+
+static const Uint8 mouse_button_map[] = {
+    SDL_BUTTON_RIGHT,
+    SDL_BUTTON_MIDDLE,
+    SDL_BUTTON_LEFT,
+    SDL_BUTTON_X1,
+    SDL_BUTTON_X2,
+    SDL_BUTTON_X2 + 1,
+    SDL_BUTTON_X2 + 2,
+    SDL_BUTTON_X2 + 3
+};
+
+void
+RISCOS_PollMouse(_THIS)
+{
+    SDL_VideoData *driverdata = (SDL_VideoData *)_this->driverdata;
+    SDL_Mouse *mouse = SDL_GetMouse();
+    SDL_Rect rect;
+    _kernel_swi_regs regs;
+    int i, x, y, buttons;
+
+    if (SDL_GetDisplayBounds(0, &rect) < 0) {
+        return;
+    }
+
+    _kernel_swi(OS_Mouse, &regs, &regs);
+    x = (regs.r[0] >> 1);
+    y = rect.h - (regs.r[1] >> 1);
+    buttons = regs.r[2];
+
+    if (mouse->x != x || mouse->y != y) {
+        SDL_SendMouseMotion(mouse->focus, mouse->mouseID, 0, x, y);
+    }
+
+    if (driverdata->last_mouse_buttons != buttons) {
+        for (i = 0; i < SDL_arraysize(mouse_button_map); i++) {
+            SDL_SendMouseButton(mouse->focus, mouse->mouseID, (buttons & (1 << i)) ? SDL_PRESSED : SDL_RELEASED, mouse_button_map[i]);
+        }
+        driverdata->last_mouse_buttons = buttons;
+    }
+}
+
+int
+RISCOS_InitEvents(_THIS)
+{
+    SDL_VideoData *driverdata = (SDL_VideoData *) _this->driverdata;
+    int i, status;
+
+    for (i = 0; i < RISCOS_MAX_KEYS_PRESSED; i++)
+        driverdata->key_pressed[i] = 255;
+
+    status = (_kernel_osbyte(202, 0, 255) & 0xFF);
+    SDL_ToggleModState(KMOD_NUM,    (status & (1 << 2)) == 0);
+    SDL_ToggleModState(KMOD_CAPS,   (status & (1 << 4)) == 0);
+    SDL_ToggleModState(KMOD_SCROLL, (status & (1 << 1)) != 0);
+
+    /* Disable escape. */
+    _kernel_osbyte(229, 1, 0);
+
+    return 0;
+}
+
+void
+RISCOS_PumpEvents(_THIS)
+{
+    RISCOS_PollMouse(_this);
+    RISCOS_PollKeyboard(_this);
+}
+
+void
+RISCOS_QuitEvents(_THIS)
+{
+    /* Re-enable escape. */
+    _kernel_osbyte(229, 0, 0);
+}
+
+#endif /* SDL_VIDEO_DRIVER_RISCOS */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoamousetap.h b/Engine/lib/sdl/src/video/riscos/SDL_riscosevents_c.h
similarity index 70%
rename from Engine/lib/sdl/src/video/cocoa/SDL_cocoamousetap.h
rename to Engine/lib/sdl/src/video/riscos/SDL_riscosevents_c.h
index 3a1a0721b..6b4341111 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoamousetap.h
+++ b/Engine/lib/sdl/src/video/riscos/SDL_riscosevents_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -18,17 +18,18 @@
      misrepresented as being the original software.
   3. This notice may not be removed or altered from any source distribution.
 */
+
+#ifndef SDL_riscosevents_c_h_
+#define SDL_riscosevents_c_h_
+
 #include "../../SDL_internal.h"
 
-#ifndef SDL_cocoamousetap_h_
-#define SDL_cocoamousetap_h_
+#include "SDL_riscosvideo.h"
 
-#include "SDL_cocoamouse.h"
+extern int RISCOS_InitEvents(_THIS);
+extern void RISCOS_PumpEvents(_THIS);
+extern void RISCOS_QuitEvents(_THIS);
 
-extern void Cocoa_InitMouseEventTap(SDL_MouseData *driverdata);
-extern void Cocoa_EnableMouseEventTap(SDL_MouseData *driverdata, SDL_bool enabled);
-extern void Cocoa_QuitMouseEventTap(SDL_MouseData *driverdata);
-
-#endif /* SDL_cocoamousetap_h_ */
+#endif /* SDL_riscosevents_c_h_ */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/riscos/SDL_riscosframebuffer.c b/Engine/lib/sdl/src/video/riscos/SDL_riscosframebuffer.c
new file mode 100644
index 000000000..59841992f
--- /dev/null
+++ b/Engine/lib/sdl/src/video/riscos/SDL_riscosframebuffer.c
@@ -0,0 +1,126 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if SDL_VIDEO_DRIVER_RISCOS
+
+#include "../SDL_sysvideo.h"
+#include "SDL_riscosframebuffer_c.h"
+#include "SDL_riscosvideo.h"
+#include "SDL_riscoswindow.h"
+
+#include <kernel.h>
+#include <swis.h>
+
+int RISCOS_CreateWindowFramebuffer(_THIS, SDL_Window * window, Uint32 * format, void ** pixels, int *pitch)
+{
+    SDL_WindowData *driverdata = (SDL_WindowData *) window->driverdata;
+    const char *sprite_name = "display";
+    unsigned int sprite_mode;
+    _kernel_oserror *error;
+    _kernel_swi_regs regs;
+    SDL_DisplayMode mode;
+    int size;
+
+    /* Free the old framebuffer surface */
+    RISCOS_DestroyWindowFramebuffer(_this, window);
+
+    /* Create a new one */
+    SDL_GetCurrentDisplayMode(SDL_GetWindowDisplayIndex(window), &mode);
+    if ((SDL_ISPIXELFORMAT_PACKED(mode.format) || SDL_ISPIXELFORMAT_ARRAY(mode.format))) {
+        *format = mode.format;
+        sprite_mode = (unsigned int)mode.driverdata;
+    } else {
+        *format = SDL_PIXELFORMAT_BGR888;
+        sprite_mode = (1 | (90 << 1) | (90 << 14) | (6 << 27));
+    }
+
+    /* Calculate pitch */
+    *pitch = (((window->w * SDL_BYTESPERPIXEL(*format)) + 3) & ~3);
+
+    /* Allocate the sprite area */
+    size = sizeof(sprite_area) + sizeof(sprite_header) + ((*pitch) * window->h);
+    driverdata->fb_area = SDL_malloc(size);
+    if (!driverdata->fb_area) {
+        return SDL_OutOfMemory();
+    }
+
+    driverdata->fb_area->size  = size;
+    driverdata->fb_area->count = 0;
+    driverdata->fb_area->start = 16;
+    driverdata->fb_area->end   = 16;
+
+    /* Create the actual image */
+    regs.r[0] = 256+15;
+    regs.r[1] = (int)driverdata->fb_area;
+    regs.r[2] = (int)sprite_name;
+    regs.r[3] = 0;
+    regs.r[4] = window->w;
+    regs.r[5] = window->h;
+    regs.r[6] = sprite_mode;
+    error = _kernel_swi(OS_SpriteOp, &regs, &regs);
+    if (error != NULL) {
+        SDL_free(driverdata->fb_area);
+        return SDL_SetError("Unable to create sprite: %s (%i)", error->errmess, error->errnum);
+    }
+
+    driverdata->fb_sprite = (sprite_header *)(((Uint8 *)driverdata->fb_area) + driverdata->fb_area->start);
+    *pixels = ((Uint8 *)driverdata->fb_sprite) + driverdata->fb_sprite->image_offset;
+
+    return 0;
+}
+
+int RISCOS_UpdateWindowFramebuffer(_THIS, SDL_Window * window, const SDL_Rect * rects, int numrects)
+{
+    SDL_WindowData *driverdata = (SDL_WindowData *) window->driverdata;
+    _kernel_swi_regs regs;
+    _kernel_oserror *error;
+
+    regs.r[0] = 512+52;
+    regs.r[1] = (int)driverdata->fb_area;
+    regs.r[2] = (int)driverdata->fb_sprite;
+    regs.r[3] = 0; /* window->x << 1; */
+    regs.r[4] = 0; /* window->y << 1; */
+    regs.r[5] = 0x50;
+    regs.r[6] = 0;
+    regs.r[7] = 0;
+    error = _kernel_swi(OS_SpriteOp, &regs, &regs);
+    if (error != NULL) {
+        return SDL_SetError("OS_SpriteOp 52 failed: %s (%i)", error->errmess, error->errnum);
+    }
+
+    return 0;
+}
+
+void RISCOS_DestroyWindowFramebuffer(_THIS, SDL_Window * window)
+{
+    SDL_WindowData *driverdata = (SDL_WindowData *) window->driverdata;
+
+    if (driverdata->fb_area) {
+        SDL_free(driverdata->fb_area);
+        driverdata->fb_area = NULL;
+    }
+    driverdata->fb_sprite = NULL;
+}
+
+#endif /* SDL_VIDEO_DRIVER_RISCOS */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_mouse.h b/Engine/lib/sdl/src/video/riscos/SDL_riscosframebuffer_c.h
similarity index 65%
rename from Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_mouse.h
rename to Engine/lib/sdl/src/video/riscos/SDL_riscosframebuffer_c.h
index 384196718..100461608 100644
--- a/Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_mouse.h
+++ b/Engine/lib/sdl/src/video/riscos/SDL_riscosframebuffer_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -19,27 +19,15 @@
   3. This notice may not be removed or altered from any source distribution.
 */
 
+#ifndef SDL_riscosframebuffer_c_h_
+#define SDL_riscosframebuffer_c_h_
+
 #include "../../SDL_internal.h"
 
-#ifndef SDL_KMSDRM_LEGACY_mouse_h_
-#define SDL_KMSDRM_LEGACY_mouse_h_
+extern int RISCOS_CreateWindowFramebuffer(_THIS, SDL_Window * window, Uint32 * format, void ** pixels, int *pitch);
+extern int RISCOS_UpdateWindowFramebuffer(_THIS, SDL_Window * window, const SDL_Rect * rects, int numrects);
+extern void RISCOS_DestroyWindowFramebuffer(_THIS, SDL_Window * window);
 
-#include <gbm.h>
-
-#define MAX_CURSOR_W 512
-#define MAX_CURSOR_H 512
-
-typedef struct _KMSDRM_LEGACY_CursorData
-{
-    struct gbm_bo *bo;
-    uint32_t       crtc_id;
-    int            hot_x, hot_y;
-    int            w, h;
-} KMSDRM_LEGACY_CursorData;
-
-extern void KMSDRM_LEGACY_InitMouse(_THIS);
-extern void KMSDRM_LEGACY_QuitMouse(_THIS);
-
-#endif /* SDL_KMSDRM_LEGACY_mouse_h_ */
+#endif /* SDL_riscosframebuffer_c_h_ */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/riscos/SDL_riscosmessagebox.c b/Engine/lib/sdl/src/video/riscos/SDL_riscosmessagebox.c
new file mode 100644
index 000000000..8144a9df6
--- /dev/null
+++ b/Engine/lib/sdl/src/video/riscos/SDL_riscosmessagebox.c
@@ -0,0 +1,68 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if SDL_VIDEO_DRIVER_RISCOS
+
+#include "SDL_messagebox.h"
+#include "SDL_riscosmessagebox.h"
+
+#include <kernel.h>
+#include <swis.h>
+
+int
+RISCOS_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid)
+{
+    _kernel_swi_regs regs;
+    _kernel_oserror error;
+    char buttonstring[1024];
+    int i;
+
+    error.errnum = 0;
+    SDL_strlcpy(error.errmess, messageboxdata->message, 252);
+    regs.r[0] = (unsigned int)&error;
+
+    regs.r[1] = (1 << 8) | (1 << 4);
+    if (messageboxdata->flags == SDL_MESSAGEBOX_INFORMATION)
+        regs.r[1] |= (1 << 9);
+    else if (messageboxdata->flags == SDL_MESSAGEBOX_WARNING)
+        regs.r[1] |= (2 << 9);
+    regs.r[2] = (unsigned int)messageboxdata->title;
+    regs.r[3] = 0;
+    regs.r[4] = 0;
+
+    SDL_strlcpy(buttonstring, "" , 1024);
+    for (i = 0; i < messageboxdata->numbuttons; i++) {
+        SDL_strlcat(buttonstring, messageboxdata->buttons[i].text, 1024);
+        if (i + 1 < messageboxdata->numbuttons)
+            SDL_strlcat(buttonstring, ",", 1024);
+    }
+    regs.r[5] = (unsigned int)buttonstring;
+
+    _kernel_swi(Wimp_ReportError, &regs, &regs);
+
+    *buttonid = (regs.r[1] == 0) ? -1 : messageboxdata->buttons[regs.r[1] - 3].buttonid;
+    return 0;
+}
+
+#endif /* SDL_VIDEO_DRIVER_RISCOS */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_events.h b/Engine/lib/sdl/src/video/riscos/SDL_riscosmessagebox.h
similarity index 76%
rename from Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_events.h
rename to Engine/lib/sdl/src/video/riscos/SDL_riscosmessagebox.h
index 24c23bcb6..3f6c259e8 100644
--- a/Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_events.h
+++ b/Engine/lib/sdl/src/video/riscos/SDL_riscosmessagebox.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -18,14 +18,12 @@
      misrepresented as being the original software.
   3. This notice may not be removed or altered from any source distribution.
 */
-
 #include "../../SDL_internal.h"
 
-#ifndef SDL_kmsdrmevents_h_
-#define SDL_kmsdrmevents_h_
+#if SDL_VIDEO_DRIVER_RISCOS
 
-extern void KMSDRM_LEGACY_PumpEvents(_THIS);
-extern void KMSDRM_LEGACY_EventInit(_THIS);
-extern void KMSDRM_LEGACY_EventQuit(_THIS);
+extern int RISCOS_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid);
 
-#endif /* SDL_kmsdrmevents_h_ */
+#endif /* SDL_VIDEO_DRIVER_RISCOS */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/riscos/SDL_riscosmodes.c b/Engine/lib/sdl/src/video/riscos/SDL_riscosmodes.c
new file mode 100644
index 000000000..0e87c140e
--- /dev/null
+++ b/Engine/lib/sdl/src/video/riscos/SDL_riscosmodes.c
@@ -0,0 +1,315 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if SDL_VIDEO_DRIVER_RISCOS
+
+#include "../SDL_sysvideo.h"
+
+#include "SDL_riscosvideo.h"
+#include "SDL_riscosmodes.h"
+
+#include <kernel.h>
+#include <swis.h>
+
+enum {
+    MODE_FLAG_565 = 1 << 7,
+
+    MODE_FLAG_COLOUR_SPACE = 0xF << 12,
+
+    MODE_FLAG_TBGR = 0,
+    MODE_FLAG_TRGB = 1 << 14,
+    MODE_FLAG_ABGR = 1 << 15,
+    MODE_FLAG_ARGB = MODE_FLAG_TRGB | MODE_FLAG_ABGR
+};
+
+static const struct {
+    SDL_PixelFormatEnum pixel_format;
+    int modeflags, ncolour, log2bpp;
+} mode_to_pixelformat[] = {
+    /* { SDL_PIXELFORMAT_INDEX1LSB, 0, 1, 0 }, */
+    /* { SDL_PIXELFORMAT_INDEX2LSB, 0, 3, 1 }, */
+    /* { SDL_PIXELFORMAT_INDEX4LSB, 0, 15, 2 }, */
+    /* { SDL_PIXELFORMAT_INDEX8,    MODE_FLAG_565, 255, 3 }, */
+    { SDL_PIXELFORMAT_XBGR1555,  MODE_FLAG_TBGR, 65535, 4 },
+    { SDL_PIXELFORMAT_XRGB1555,  MODE_FLAG_TRGB, 65535, 4 },
+    { SDL_PIXELFORMAT_ABGR1555,  MODE_FLAG_ABGR, 65535, 4 },
+    { SDL_PIXELFORMAT_ARGB1555,  MODE_FLAG_ARGB, 65535, 4 },
+    { SDL_PIXELFORMAT_XBGR4444,  MODE_FLAG_TBGR, 4095, 4 },
+    { SDL_PIXELFORMAT_XRGB4444,  MODE_FLAG_TRGB, 4095, 4 },
+    { SDL_PIXELFORMAT_ABGR4444,  MODE_FLAG_ABGR, 4095, 4 },
+    { SDL_PIXELFORMAT_ARGB4444,  MODE_FLAG_ARGB, 4095, 4 },
+    { SDL_PIXELFORMAT_BGR565,    MODE_FLAG_TBGR | MODE_FLAG_565, 65535, 4 },
+    { SDL_PIXELFORMAT_RGB565,    MODE_FLAG_TRGB | MODE_FLAG_565, 65535, 4 },
+    { SDL_PIXELFORMAT_BGR24,     MODE_FLAG_TBGR, 16777215, 6 },
+    { SDL_PIXELFORMAT_RGB24,     MODE_FLAG_TRGB, 16777215, 6 },
+    { SDL_PIXELFORMAT_XBGR8888,  MODE_FLAG_TBGR, -1, 5 },
+    { SDL_PIXELFORMAT_XRGB8888,  MODE_FLAG_TRGB, -1, 5 },
+    { SDL_PIXELFORMAT_ABGR8888,  MODE_FLAG_ABGR, -1, 5 },
+    { SDL_PIXELFORMAT_ARGB8888,  MODE_FLAG_ARGB, -1, 5 }
+};
+
+static SDL_PixelFormatEnum
+RISCOS_ModeToPixelFormat(int ncolour, int modeflags, int log2bpp)
+{
+    int i;
+
+    for (i = 0; i < SDL_arraysize(mode_to_pixelformat); i++) {
+        if (log2bpp == mode_to_pixelformat[i].log2bpp &&
+           (ncolour == mode_to_pixelformat[i].ncolour || ncolour == 0) &&
+           (modeflags & (MODE_FLAG_565 | MODE_FLAG_COLOUR_SPACE)) == mode_to_pixelformat[i].modeflags) {
+            return mode_to_pixelformat[i].pixel_format;
+        }
+    }
+
+    return SDL_PIXELFORMAT_UNKNOWN;
+}
+
+static size_t
+measure_mode_block(const int *block)
+{
+    size_t blockSize = ((block[0] & 0xFF) == 3) ? 7 : 5;
+    while(block[blockSize] != -1) {
+        blockSize += 2;
+    }
+    blockSize++;
+
+    return blockSize * 4;
+}
+
+static int
+read_mode_variable(int *block, int var)
+{
+    _kernel_swi_regs regs;
+    regs.r[0] = (int)block;
+    regs.r[1] = var;
+    _kernel_swi(OS_ReadModeVariable, &regs, &regs);
+    return regs.r[2];
+}
+
+static SDL_bool
+read_mode_block(int *block, SDL_DisplayMode *mode, SDL_bool extended)
+{
+    int xres, yres, ncolour, modeflags, log2bpp, rate;
+
+    if ((block[0] & 0xFF) == 1) {
+        xres = block[1];
+        yres = block[2];
+        log2bpp = block[3];
+        rate = block[4];
+        ncolour = (1 << (1 << log2bpp)) - 1;
+        modeflags = MODE_FLAG_TBGR;
+    } else if ((block[0] & 0xFF) == 3) {
+        xres = block[1];
+        yres = block[2];
+        ncolour = block[3];
+        modeflags = block[4];
+        log2bpp = block[5];
+        rate = block[6];
+    } else {
+        return SDL_FALSE;
+    }
+
+    if (extended) {
+        xres = read_mode_variable(block, 11) + 1;
+        yres = read_mode_variable(block, 12) + 1;
+        log2bpp = read_mode_variable(block, 9);
+        ncolour = read_mode_variable(block, 3);
+        modeflags = read_mode_variable(block, 0);
+    }
+
+    mode->w = xres;
+    mode->h = yres;
+    mode->format = RISCOS_ModeToPixelFormat(ncolour, modeflags, log2bpp);
+    mode->refresh_rate = rate;
+
+    return SDL_TRUE;
+}
+
+static void *
+convert_mode_block(const int *block)
+{
+    int xres, yres, log2bpp, rate, ncolour = 0, modeflags = 0;
+    size_t pos = 0;
+    int *dst;
+
+    if ((block[0] & 0xFF) == 1) {
+        xres = block[1];
+        yres = block[2];
+        log2bpp = block[3];
+        rate = block[4];
+    } else if ((block[0] & 0xFF) == 3) {
+        xres = block[1];
+        yres = block[2];
+        ncolour = block[3];
+        modeflags = block[4];
+        log2bpp = block[5];
+        rate = block[6];
+    } else {
+        return NULL;
+    }
+
+    dst = SDL_malloc(40);
+    if (!dst) {
+        return NULL;
+    }
+
+    dst[pos++] = 1;
+    dst[pos++] = xres;
+    dst[pos++] = yres;
+    dst[pos++] = log2bpp;
+    dst[pos++] = rate;
+    if (ncolour != 0) {
+        dst[pos++] = 3;
+        dst[pos++] = ncolour;
+    }
+    if (modeflags != 0) {
+        dst[pos++] = 0;
+        dst[pos++] = modeflags;
+    }
+    dst[pos++] = -1;
+
+    return dst;
+}
+
+static void *
+copy_memory(const void *src, size_t size, size_t alloc)
+{
+    void *dst = SDL_malloc(alloc);
+    if (dst) {
+        SDL_memcpy(dst, src, size);
+    }
+    return dst;
+}
+
+int
+RISCOS_InitModes(_THIS)
+{
+    SDL_DisplayMode mode;
+    int *current_mode;
+    _kernel_swi_regs regs;
+    _kernel_oserror *error;
+    size_t size;
+
+    regs.r[0] = 1;
+    error = _kernel_swi(OS_ScreenMode, &regs, &regs);
+    if (error != NULL) {
+        return SDL_SetError("Unable to retrieve the current screen mode: %s (%i)", error->errmess, error->errnum);
+    }
+
+    current_mode = (int *)regs.r[1];
+    if (!read_mode_block(current_mode, &mode, SDL_TRUE)) {
+        return SDL_SetError("Unsupported mode block format %d", current_mode[0]);
+    }
+
+    size = measure_mode_block(current_mode);
+    mode.driverdata = copy_memory(current_mode, size, size);
+    if (!mode.driverdata) {
+        return SDL_OutOfMemory();
+    }
+
+    return SDL_AddBasicVideoDisplay(&mode);
+}
+
+void
+RISCOS_GetDisplayModes(_THIS, SDL_VideoDisplay * display)
+{
+    SDL_DisplayMode mode;
+    _kernel_swi_regs regs;
+    _kernel_oserror *error;
+    void *block, *pos;
+
+    regs.r[0] = 2;
+    regs.r[2] = 0;
+    regs.r[6] = 0;
+    regs.r[7] = 0;
+    error = _kernel_swi(OS_ScreenMode, &regs, &regs);
+    if (error != NULL) {
+        SDL_SetError("Unable to enumerate screen modes: %s (%i)", error->errmess, error->errnum);
+        return;
+    }
+
+    block = SDL_malloc(-regs.r[7]);
+    if (!block) {
+        SDL_OutOfMemory();
+        return;
+    }
+
+    regs.r[6] = (int)block;
+    regs.r[7] = -regs.r[7];
+    error = _kernel_swi(OS_ScreenMode, &regs, &regs);
+    if (error != NULL) {
+        SDL_free(block);
+        SDL_SetError("Unable to enumerate screen modes: %s (%i)", error->errmess, error->errnum);
+        return;
+    }
+
+    for (pos = block; pos < (void *)regs.r[6]; pos += *((int *)pos)) {
+        if (!read_mode_block(pos + 4, &mode, SDL_FALSE)) {
+            continue;
+        }
+
+        if (mode.format == SDL_PIXELFORMAT_UNKNOWN)
+            continue;
+
+        mode.driverdata = convert_mode_block(pos + 4);
+        if (!mode.driverdata) {
+            SDL_OutOfMemory();
+            break;
+        }
+
+        if (!SDL_AddDisplayMode(display, &mode)) {
+            SDL_free(mode.driverdata);
+        }
+    }
+
+    SDL_free(block);
+}
+
+int
+RISCOS_SetDisplayMode(_THIS, SDL_VideoDisplay * display, SDL_DisplayMode * mode)
+{
+    const char disable_cursor[] = { 23, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+    _kernel_swi_regs regs;
+    _kernel_oserror *error;
+    int i;
+
+    regs.r[0] = 0;
+    regs.r[1] = (int)mode->driverdata;
+    error = _kernel_swi(OS_ScreenMode, &regs, &regs);
+    if (error != NULL) {
+        return SDL_SetError("Unable to set the current screen mode: %s (%i)", error->errmess, error->errnum);
+    }
+
+    /* Turn the text cursor off */
+    for (i = 0; i < SDL_arraysize(disable_cursor); i++) {
+        _kernel_oswrch(disable_cursor[i]);
+    }
+
+    /* Turn the mouse pointer on */
+    /* _kernel_osbyte(106, 1, 0); */
+
+    return 0;
+}
+
+#endif /* SDL_VIDEO_DRIVER_RISCOS */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/riscos/SDL_riscosmodes.h b/Engine/lib/sdl/src/video/riscos/SDL_riscosmodes.h
new file mode 100644
index 000000000..eb5347286
--- /dev/null
+++ b/Engine/lib/sdl/src/video/riscos/SDL_riscosmodes.h
@@ -0,0 +1,33 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#ifndef SDL_riscosmodes_h_
+#define SDL_riscosmodes_h_
+
+extern int RISCOS_InitModes(_THIS);
+extern void RISCOS_GetDisplayModes(_THIS, SDL_VideoDisplay * display);
+extern int RISCOS_SetDisplayMode(_THIS, SDL_VideoDisplay * display,
+                                 SDL_DisplayMode * mode);
+
+#endif /* SDL_riscosmodes_h_ */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/riscos/SDL_riscosvideo.c b/Engine/lib/sdl/src/video/riscos/SDL_riscosvideo.c
new file mode 100644
index 000000000..1d8bd3d95
--- /dev/null
+++ b/Engine/lib/sdl/src/video/riscos/SDL_riscosvideo.c
@@ -0,0 +1,124 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if SDL_VIDEO_DRIVER_RISCOS
+
+#include "SDL_video.h"
+#include "SDL_mouse.h"
+#include "../SDL_sysvideo.h"
+#include "../SDL_pixels_c.h"
+#include "../../events/SDL_events_c.h"
+
+#include "SDL_riscosvideo.h"
+#include "SDL_riscosevents_c.h"
+#include "SDL_riscosframebuffer_c.h"
+#include "SDL_riscosmodes.h"
+#include "SDL_riscoswindow.h"
+
+#define RISCOSVID_DRIVER_NAME "riscos"
+
+/* Initialization/Query functions */
+static int RISCOS_VideoInit(_THIS);
+static void RISCOS_VideoQuit(_THIS);
+
+/* RISC OS driver bootstrap functions */
+
+static void
+RISCOS_DeleteDevice(SDL_VideoDevice * device)
+{
+    SDL_free(device->driverdata);
+    SDL_free(device);
+}
+
+static SDL_VideoDevice *
+RISCOS_CreateDevice(int devindex)
+{
+    SDL_VideoDevice *device;
+    SDL_VideoData *phdata;
+
+    /* Initialize all variables that we clean on shutdown */
+    device = (SDL_VideoDevice *) SDL_calloc(1, sizeof(SDL_VideoDevice));
+    if (!device) {
+        SDL_OutOfMemory();
+        return (0);
+    }
+
+    /* Initialize internal data */
+    phdata = (SDL_VideoData *) SDL_calloc(1, sizeof(SDL_VideoData));
+    if (phdata == NULL) {
+        SDL_OutOfMemory();
+        SDL_free(device);
+        return NULL;
+    }
+
+    device->driverdata = phdata;
+
+    /* Set the function pointers */
+    device->VideoInit = RISCOS_VideoInit;
+    device->VideoQuit = RISCOS_VideoQuit;
+    device->PumpEvents = RISCOS_PumpEvents;
+
+    device->GetDisplayModes = RISCOS_GetDisplayModes;
+    device->SetDisplayMode = RISCOS_SetDisplayMode;
+
+    device->CreateSDLWindow = RISCOS_CreateWindow;
+    device->DestroyWindow = RISCOS_DestroyWindow;
+    device->GetWindowWMInfo = RISCOS_GetWindowWMInfo;
+
+    device->CreateWindowFramebuffer = RISCOS_CreateWindowFramebuffer;
+    device->UpdateWindowFramebuffer = RISCOS_UpdateWindowFramebuffer;
+    device->DestroyWindowFramebuffer = RISCOS_DestroyWindowFramebuffer;
+
+    device->free = RISCOS_DeleteDevice;
+
+    return device;
+}
+
+VideoBootStrap RISCOS_bootstrap = {
+    RISCOSVID_DRIVER_NAME, "SDL RISC OS video driver",
+    RISCOS_CreateDevice
+};
+
+static int
+RISCOS_VideoInit(_THIS)
+{
+    if (RISCOS_InitEvents(_this) < 0) {
+        return -1;
+    }
+
+    if (RISCOS_InitModes(_this) < 0) {
+        return -1;
+    }
+
+    /* We're done! */
+    return 0;
+}
+
+static void
+RISCOS_VideoQuit(_THIS)
+{
+    RISCOS_QuitEvents(_this);
+}
+
+#endif /* SDL_VIDEO_DRIVER_RISCOS */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_events.c b/Engine/lib/sdl/src/video/riscos/SDL_riscosvideo.h
similarity index 71%
rename from Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_events.c
rename to Engine/lib/sdl/src/video/riscos/SDL_riscosvideo.h
index a5c765edb..db6c86e49 100644
--- a/Engine/lib/sdl/src/video/kmsdrm_legacy/SDL_kmsdrm_legacy_events.c
+++ b/Engine/lib/sdl/src/video/riscos/SDL_riscosvideo.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -18,25 +18,21 @@
      misrepresented as being the original software.
   3. This notice may not be removed or altered from any source distribution.
 */
-
 #include "../../SDL_internal.h"
 
-#if SDL_VIDEO_DRIVER_KMSDRM
+#ifndef SDL_riscosvideo_h_
+#define SDL_riscosvideo_h_
 
-#include "SDL_kmsdrm_legacy_video.h"
-#include "SDL_kmsdrm_legacy_events.h"
+#include "../SDL_sysvideo.h"
 
-#ifdef SDL_INPUT_LINUXEV
-#include "../../core/linux/SDL_evdev.h"
-#endif
+#define RISCOS_MAX_KEYS_PRESSED 6
 
-void KMSDRM_LEGACY_PumpEvents(_THIS)
+typedef struct SDL_VideoData
 {
-#ifdef SDL_INPUT_LINUXEV
-    SDL_EVDEV_Poll();
-#endif
+    int last_mouse_buttons;
+    Uint8 key_pressed[RISCOS_MAX_KEYS_PRESSED];
+} SDL_VideoData;
 
-}
-
-#endif /* SDL_VIDEO_DRIVER_KMSDRM */
+#endif /* SDL_riscosvideo_h_ */
 
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/riscos/SDL_riscoswindow.c b/Engine/lib/sdl/src/video/riscos/SDL_riscoswindow.c
new file mode 100644
index 000000000..84e4de03e
--- /dev/null
+++ b/Engine/lib/sdl/src/video/riscos/SDL_riscoswindow.c
@@ -0,0 +1,78 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if SDL_VIDEO_DRIVER_RISCOS
+
+#include "SDL_version.h"
+#include "SDL_syswm.h"
+#include "../SDL_sysvideo.h"
+
+#include "SDL_riscosvideo.h"
+#include "SDL_riscoswindow.h"
+
+int
+RISCOS_CreateWindow(_THIS, SDL_Window * window)
+{
+    SDL_WindowData *driverdata;
+
+    driverdata = (SDL_WindowData *) SDL_calloc(1, sizeof(*driverdata));
+    if (!driverdata) {
+        return SDL_OutOfMemory();
+    }
+    driverdata->window = window;
+
+    window->flags |= SDL_WINDOW_FULLSCREEN;
+
+    /* All done! */
+    window->driverdata = driverdata;
+    return 0;
+}
+
+void
+RISCOS_DestroyWindow(_THIS, SDL_Window * window)
+{
+    SDL_WindowData *driverdata = (SDL_WindowData *) window->driverdata;
+
+    if (!driverdata)
+        return;
+
+    SDL_free(driverdata);
+    window->driverdata = NULL;
+}
+
+SDL_bool
+RISCOS_GetWindowWMInfo(_THIS, SDL_Window * window, struct SDL_SysWMinfo *info)
+{
+    if (info->version.major == SDL_MAJOR_VERSION &&
+        info->version.minor == SDL_MINOR_VERSION) {
+        info->subsystem = SDL_SYSWM_RISCOS;
+        return SDL_TRUE;
+    } else {
+        SDL_SetError("Application not compiled with SDL %d.%d",
+                     SDL_MAJOR_VERSION, SDL_MINOR_VERSION);
+        return SDL_FALSE;
+    }
+}
+
+#endif /* SDL_VIDEO_DRIVER_RISCOS */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/riscos/SDL_riscoswindow.h b/Engine/lib/sdl/src/video/riscos/SDL_riscoswindow.h
new file mode 100644
index 000000000..d713b7aeb
--- /dev/null
+++ b/Engine/lib/sdl/src/video/riscos/SDL_riscoswindow.h
@@ -0,0 +1,42 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#ifndef SDL_riscoswindow_h_
+#define SDL_riscoswindow_h_
+
+#include "SDL_riscosdefs.h"
+
+typedef struct
+{
+    SDL_Window *window;
+    sprite_area *fb_area;
+    sprite_header *fb_sprite;
+} SDL_WindowData;
+
+extern int RISCOS_CreateWindow(_THIS, SDL_Window * window);
+extern void RISCOS_DestroyWindow(_THIS, SDL_Window * window);
+extern SDL_bool RISCOS_GetWindowWMInfo(_THIS, SDL_Window * window,
+                                    struct SDL_SysWMinfo *info);
+
+#endif /* SDL_riscoswindow_h_ */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/riscos/scancodes_riscos.h b/Engine/lib/sdl/src/video/riscos/scancodes_riscos.h
new file mode 100644
index 000000000..ced6b0d1b
--- /dev/null
+++ b/Engine/lib/sdl/src/video/riscos/scancodes_riscos.h
@@ -0,0 +1,158 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_scancode.h"
+
+/* RISC OS key code to SDL_Keycode mapping table
+   Sources:
+   - https://www.riscosopen.org/wiki/documentation/show/Keyboard Scan Codes
+*/
+/* *INDENT-OFF* */
+static SDL_Scancode const riscos_scancode_table[] = {
+     /*   0 */   SDL_SCANCODE_UNKNOWN,   /* Shift */
+     /*   1 */   SDL_SCANCODE_UNKNOWN,   /* Ctrl */
+     /*   2 */   SDL_SCANCODE_UNKNOWN,   /* Alt */
+     /*   3 */   SDL_SCANCODE_LSHIFT,
+     /*   4 */   SDL_SCANCODE_LCTRL,
+     /*   5 */   SDL_SCANCODE_LALT,
+     /*   6 */   SDL_SCANCODE_RSHIFT,
+     /*   7 */   SDL_SCANCODE_RCTRL,
+     /*   8 */   SDL_SCANCODE_RALT,
+     /*   9 */   SDL_SCANCODE_UNKNOWN,   /* Left mouse */
+     /*  10 */   SDL_SCANCODE_UNKNOWN,   /* Center mouse */
+     /*  11 */   SDL_SCANCODE_UNKNOWN,   /* Right mouse */
+     /*  12 */   SDL_SCANCODE_UNKNOWN,
+     /*  13 */   SDL_SCANCODE_UNKNOWN,
+     /*  14 */   SDL_SCANCODE_UNKNOWN,
+     /*  15 */   SDL_SCANCODE_UNKNOWN,
+     /*  16 */   SDL_SCANCODE_Q,
+     /*  17 */   SDL_SCANCODE_3,
+     /*  18 */   SDL_SCANCODE_4,
+     /*  19 */   SDL_SCANCODE_5,
+     /*  20 */   SDL_SCANCODE_F4,
+     /*  21 */   SDL_SCANCODE_8,
+     /*  22 */   SDL_SCANCODE_F7,
+     /*  23 */   SDL_SCANCODE_MINUS,
+     /*  24 */   SDL_SCANCODE_6,         /* Duplicate of 52 */
+     /*  25 */   SDL_SCANCODE_LEFT,
+     /*  26 */   SDL_SCANCODE_KP_6,
+     /*  27 */   SDL_SCANCODE_KP_7,
+     /*  28 */   SDL_SCANCODE_F11,
+     /*  29 */   SDL_SCANCODE_F12,
+     /*  30 */   SDL_SCANCODE_F10,
+     /*  31 */   SDL_SCANCODE_SCROLLLOCK,
+     /*  32 */   SDL_SCANCODE_PRINTSCREEN,
+     /*  33 */   SDL_SCANCODE_W,
+     /*  34 */   SDL_SCANCODE_E,
+     /*  35 */   SDL_SCANCODE_T,
+     /*  36 */   SDL_SCANCODE_7,
+     /*  37 */   SDL_SCANCODE_I,
+     /*  38 */   SDL_SCANCODE_9,
+     /*  39 */   SDL_SCANCODE_0,
+     /*  40 */   SDL_SCANCODE_MINUS,     /* Duplicate of 23 */
+     /*  41 */   SDL_SCANCODE_DOWN,
+     /*  42 */   SDL_SCANCODE_KP_8,
+     /*  43 */   SDL_SCANCODE_KP_9,
+     /*  44 */   SDL_SCANCODE_PAUSE,
+     /*  45 */   SDL_SCANCODE_GRAVE,
+     /*  46 */   SDL_SCANCODE_CURRENCYUNIT,
+     /*  47 */   SDL_SCANCODE_BACKSPACE,
+     /*  48 */   SDL_SCANCODE_1,
+     /*  49 */   SDL_SCANCODE_2,
+     /*  50 */   SDL_SCANCODE_D,
+     /*  51 */   SDL_SCANCODE_R,
+     /*  52 */   SDL_SCANCODE_6,
+     /*  53 */   SDL_SCANCODE_U,
+     /*  54 */   SDL_SCANCODE_O,
+     /*  55 */   SDL_SCANCODE_P,
+     /*  56 */   SDL_SCANCODE_LEFTBRACKET,
+     /*  57 */   SDL_SCANCODE_UP,
+     /*  58 */   SDL_SCANCODE_KP_PLUS,
+     /*  59 */   SDL_SCANCODE_KP_MINUS,
+     /*  60 */   SDL_SCANCODE_KP_ENTER,
+     /*  61 */   SDL_SCANCODE_INSERT,
+     /*  62 */   SDL_SCANCODE_HOME,
+     /*  63 */   SDL_SCANCODE_PAGEUP,
+     /*  64 */   SDL_SCANCODE_CAPSLOCK,
+     /*  65 */   SDL_SCANCODE_A,
+     /*  66 */   SDL_SCANCODE_X,
+     /*  67 */   SDL_SCANCODE_F,
+     /*  68 */   SDL_SCANCODE_Y,
+     /*  69 */   SDL_SCANCODE_J,
+     /*  70 */   SDL_SCANCODE_K,
+     /*  71 */   SDL_SCANCODE_2,         /* Duplicate of 49 */
+     /*  72 */   SDL_SCANCODE_SEMICOLON, /* Duplicate of 87 */
+     /*  73 */   SDL_SCANCODE_RETURN,
+     /*  74 */   SDL_SCANCODE_KP_DIVIDE,
+     /*  75 */   SDL_SCANCODE_UNKNOWN,
+     /*  76 */   SDL_SCANCODE_KP_PERIOD,
+     /*  77 */   SDL_SCANCODE_NUMLOCKCLEAR,
+     /*  78 */   SDL_SCANCODE_PAGEDOWN,
+     /*  79 */   SDL_SCANCODE_APOSTROPHE,
+     /*  80 */   SDL_SCANCODE_UNKNOWN,
+     /*  81 */   SDL_SCANCODE_S,
+     /*  82 */   SDL_SCANCODE_C,
+     /*  83 */   SDL_SCANCODE_G,
+     /*  84 */   SDL_SCANCODE_H,
+     /*  85 */   SDL_SCANCODE_N,
+     /*  86 */   SDL_SCANCODE_L,
+     /*  87 */   SDL_SCANCODE_SEMICOLON,
+     /*  88 */   SDL_SCANCODE_RIGHTBRACKET,
+     /*  89 */   SDL_SCANCODE_DELETE,
+     /*  90 */   SDL_SCANCODE_KP_HASH,
+     /*  91 */   SDL_SCANCODE_KP_MULTIPLY,
+     /*  92 */   SDL_SCANCODE_UNKNOWN,
+     /*  93 */   SDL_SCANCODE_EQUALS,
+     /*  94 */   SDL_SCANCODE_NONUSBACKSLASH,
+     /*  95 */   SDL_SCANCODE_UNKNOWN,
+     /*  96 */   SDL_SCANCODE_TAB,
+     /*  97 */   SDL_SCANCODE_Z,
+     /*  98 */   SDL_SCANCODE_SPACE,
+     /*  99 */   SDL_SCANCODE_V,
+     /* 100 */   SDL_SCANCODE_B,
+     /* 101 */   SDL_SCANCODE_M,
+     /* 102 */   SDL_SCANCODE_COMMA,
+     /* 103 */   SDL_SCANCODE_PERIOD,
+     /* 104 */   SDL_SCANCODE_SLASH,
+     /* 105 */   SDL_SCANCODE_END,
+     /* 106 */   SDL_SCANCODE_KP_0,
+     /* 107 */   SDL_SCANCODE_KP_1,
+     /* 108 */   SDL_SCANCODE_KP_3,
+     /* 109 */   SDL_SCANCODE_UNKNOWN,
+     /* 110 */   SDL_SCANCODE_UNKNOWN,
+     /* 111 */   SDL_SCANCODE_UNKNOWN,
+     /* 112 */   SDL_SCANCODE_ESCAPE,
+     /* 113 */   SDL_SCANCODE_F1,
+     /* 114 */   SDL_SCANCODE_F2,
+     /* 115 */   SDL_SCANCODE_F3,
+     /* 116 */   SDL_SCANCODE_F5,
+     /* 117 */   SDL_SCANCODE_F6,
+     /* 118 */   SDL_SCANCODE_F8,
+     /* 119 */   SDL_SCANCODE_F9,
+     /* 120 */   SDL_SCANCODE_BACKSLASH,
+     /* 121 */   SDL_SCANCODE_RIGHT,
+     /* 122 */   SDL_SCANCODE_KP_4,
+     /* 123 */   SDL_SCANCODE_KP_5,
+     /* 124 */   SDL_SCANCODE_KP_2,
+     /* 125 */   SDL_SCANCODE_LGUI,
+     /* 126 */   SDL_SCANCODE_RGUI,
+     /* 127 */   SDL_SCANCODE_MENU
+};
+/* *INDENT-ON* */
diff --git a/Engine/lib/sdl/src/video/sdlgenblit.pl b/Engine/lib/sdl/src/video/sdlgenblit.pl
index 6206ec299..c2a22b049 100755
--- a/Engine/lib/sdl/src/video/sdlgenblit.pl
+++ b/Engine/lib/sdl/src/video/sdlgenblit.pl
@@ -92,7 +92,7 @@ sub open_file {
 /* DO NOT EDIT!  This file is generated by sdlgenblit.pl */
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken\@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken\@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -220,16 +220,82 @@ sub output_copycore
     my $A_is_const_FF = shift;
     my $s = "";
     my $d = "";
+    my $dst_has_alpha = ($dst =~ /A/) ? 1 : 0;
+    my $src_has_alpha = ($src =~ /A/) ? 1 : 0;
+    my $sa = "";
+    my $da = "";
 
-    # Nice and easy...
-    if ( $src eq $dst && !$modulate && !$blend ) {
-        print FILE <<__EOF__;
+    if (!$modulate && !$blend) {
+        # Nice and easy...
+        if ( $src eq $dst ) {
+            print FILE <<__EOF__;
             *dst = *src;
 __EOF__
-        return;
+            return;
+        }
+
+        # Matching color-order
+        $sa = $src;
+        $sa =~ s/[A8]//g;
+        $da = $dst;
+        $da =~ s/[A8]//g;
+        if ($sa eq $da) {
+            if ($dst_has_alpha && $src_has_alpha) {
+                $da = substr $dst, 0, 1;
+                if ($da eq "A") {
+                    # RGBA -> ARGB
+                    print FILE <<__EOF__;
+            pixel = *src;
+            pixel = (pixel >> 8) | (pixel << 24);
+            *dst = pixel;
+__EOF__
+                } else {
+                    # ARGB -> RGBA -- unused
+                    print FILE <<__EOF__;
+            pixel = *src;
+            pixel = (pixel << 8) | A;
+            *dst = pixel;
+__EOF__
+                }
+            } elsif ($dst_has_alpha) {
+                $da = substr $dst, 0, 1;
+                if ($da eq "A") {
+                    # RGB -> ARGB
+                    print FILE <<__EOF__;
+            pixel = *src;
+            pixel |= (A << 24);
+            *dst = pixel;
+__EOF__
+                } else {
+                    # RGB -> RGBA -- unused
+                    print FILE <<__EOF__;
+            pixel = *src;
+            pixel = (pixel << 8) | A;
+            *dst = pixel;
+__EOF__
+                }
+            } else {
+                $sa = substr $src, 0, 1;
+                if ($sa eq "A") {
+                    # ARGB -> RGB
+                    print FILE <<__EOF__;
+            pixel = *src;
+            pixel &= 0xFFFFFF;
+            *dst = pixel;
+__EOF__
+                } else {
+                    # RGBA -> RGB
+                    print FILE <<__EOF__;
+            pixel = *src;
+            pixel >>= 8;
+            *dst = pixel;
+__EOF__
+                }
+            }
+            return;
+        }
     }
 
-    my $dst_has_alpha = ($dst =~ /A/) ? 1 : 0;
     my $ignore_dst_alpha = !$dst_has_alpha && !$blend;
 
     if ( $blend ) {
@@ -366,6 +432,14 @@ sub output_copyfunc
     my $is_modulateA_done = 0;
     my $A_is_const_FF = 0;
 
+    my $sa = $src;
+    my $da = $dst;
+    my $matching_colors = 0;
+
+    $sa =~ s/[A8]//g;
+    $da =~ s/[A8]//g;
+    $matching_colors = (!$modulate && !$blend && ($sa eq $da)) ? 1 : 0;
+
     output_copyfuncname("static void", $src, $dst, $modulate, $blend, $scale, 1, "\n");
     print FILE <<__EOF__;
 {
@@ -424,8 +498,8 @@ __EOF__
         print FILE <<__EOF__;
     Uint32 pixel;
 __EOF__
-        if (!$ignore_dst_alpha && !$src_has_alpha) {
-            if ($modulate){
+        if ( !$ignore_dst_alpha && !$src_has_alpha ) {
+            if ( $modulate ) {
                 $is_modulateA_done = 1;
                 print FILE <<__EOF__;
     const Uint32 A = (flags & SDL_COPY_MODULATE_ALPHA) ? modulateA : 0xFF;
@@ -436,14 +510,18 @@ __EOF__
     const Uint32 A = 0xFF;
 __EOF__
             }
-            print FILE <<__EOF__;
+            if ( !$matching_colors ) {
+                print FILE <<__EOF__;
     Uint32 R, G, B;
 __EOF__
-        } elsif (!$ignore_dst_alpha) {
-            print FILE <<__EOF__;
+            }
+        } elsif ( !$ignore_dst_alpha ) {
+            if ( !$matching_colors ) {
+                print FILE <<__EOF__;
     Uint32 R, G, B, A;
 __EOF__
-        } else {
+            }
+        } elsif ( !$matching_colors ) {
             print FILE <<__EOF__;
     Uint32 R, G, B;
 __EOF__
@@ -452,37 +530,28 @@ __EOF__
     if ( $scale ) {
         print FILE <<__EOF__;
     int srcy, srcx;
-    int posy, posx;
+    Uint32 posy, posx;
     int incy, incx;
 __EOF__
 
     print FILE <<__EOF__;
 
-    srcy = 0;
-    posy = 0;
     incy = (info->src_h << 16) / info->dst_h;
     incx = (info->src_w << 16) / info->dst_w;
+    posy = incy / 2;
 
     while (info->dst_h--) {
         $format_type{$src} *src = 0;
         $format_type{$dst} *dst = ($format_type{$dst} *)info->dst;
         int n = info->dst_w;
-        srcx = -1;
-        posx = 0x10000L;
-        while (posy >= 0x10000L) {
-            ++srcy;
-            posy -= 0x10000L;
-        }
+        posx = incx / 2;
+
+        srcy = posy >> 16;
         while (n--) {
-            if (posx >= 0x10000L) {
-                while (posx >= 0x10000L) {
-                    ++srcx;
-                    posx -= 0x10000L;
-                }
-                src = ($format_type{$src} *)(info->src + (srcy * info->src_pitch) + (srcx * $format_size{$src}));
+            srcx = posx >> 16;
+            src = ($format_type{$src} *)(info->src + (srcy * info->src_pitch) + (srcx * $format_size{$src}));
 __EOF__
         print FILE <<__EOF__;
-            }
 __EOF__
         output_copycore($src, $dst, $modulate, $blend, $is_modulateA_done, $A_is_const_FF);
         print FILE <<__EOF__;
diff --git a/Engine/lib/sdl/src/video/uikit/SDL_uikitappdelegate.h b/Engine/lib/sdl/src/video/uikit/SDL_uikitappdelegate.h
index 1d19b9d10..ee2b5b6a8 100644
--- a/Engine/lib/sdl/src/video/uikit/SDL_uikitappdelegate.h
+++ b/Engine/lib/sdl/src/video/uikit/SDL_uikitappdelegate.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/uikit/SDL_uikitappdelegate.m b/Engine/lib/sdl/src/video/uikit/SDL_uikitappdelegate.m
index 4b6e16041..4c21d7336 100644
--- a/Engine/lib/sdl/src/video/uikit/SDL_uikitappdelegate.m
+++ b/Engine/lib/sdl/src/video/uikit/SDL_uikitappdelegate.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/uikit/SDL_uikitclipboard.h b/Engine/lib/sdl/src/video/uikit/SDL_uikitclipboard.h
index 4240b619a..5e6b81497 100644
--- a/Engine/lib/sdl/src/video/uikit/SDL_uikitclipboard.h
+++ b/Engine/lib/sdl/src/video/uikit/SDL_uikitclipboard.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/uikit/SDL_uikitclipboard.m b/Engine/lib/sdl/src/video/uikit/SDL_uikitclipboard.m
index df3122ebb..dde939dfb 100644
--- a/Engine/lib/sdl/src/video/uikit/SDL_uikitclipboard.m
+++ b/Engine/lib/sdl/src/video/uikit/SDL_uikitclipboard.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/uikit/SDL_uikitevents.h b/Engine/lib/sdl/src/video/uikit/SDL_uikitevents.h
index 86b12a8bf..083e431ce 100644
--- a/Engine/lib/sdl/src/video/uikit/SDL_uikitevents.h
+++ b/Engine/lib/sdl/src/video/uikit/SDL_uikitevents.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -31,6 +31,7 @@ extern void SDL_QuitGCKeyboard(void);
 
 extern void SDL_InitGCMouse(void);
 extern SDL_bool SDL_HasGCMouse(void);
+extern SDL_bool SDL_GCMouseRelativeMode(void);
 extern void SDL_QuitGCMouse(void);
 
 #endif /* SDL_uikitevents_h_ */
diff --git a/Engine/lib/sdl/src/video/uikit/SDL_uikitevents.m b/Engine/lib/sdl/src/video/uikit/SDL_uikitevents.m
index 06cb4f1aa..b7ef0bf40 100644
--- a/Engine/lib/sdl/src/video/uikit/SDL_uikitevents.m
+++ b/Engine/lib/sdl/src/video/uikit/SDL_uikitevents.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -24,9 +24,10 @@
 
 #include "../../events/SDL_events_c.h"
 
-#include "SDL_uikitvideo.h"
 #include "SDL_uikitevents.h"
 #include "SDL_uikitopengles.h"
+#include "SDL_uikitvideo.h"
+#include "SDL_uikitwindow.h"
 
 #import <Foundation/Foundation.h>
 
@@ -86,14 +87,14 @@ static id keyboard_disconnect_observer = nil;
 static void OnGCKeyboardConnected(GCKeyboard *keyboard) API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0))
 {
     keyboard_connected = SDL_TRUE;
-    keyboard.keyboardInput.keyChangedHandler = ^(GCKeyboardInput *keyboard, GCControllerButtonInput *key, GCKeyCode keyCode, BOOL pressed)
+    keyboard.keyboardInput.keyChangedHandler = ^(GCKeyboardInput *kbrd, GCControllerButtonInput *key, GCKeyCode keyCode, BOOL pressed)
     {
         SDL_SendKeyboardKey(pressed ? SDL_PRESSED : SDL_RELEASED, (SDL_Scancode)keyCode);
     };
 
-	dispatch_queue_t queue = dispatch_queue_create( "org.libsdl.input.keyboard", DISPATCH_QUEUE_SERIAL );
-	dispatch_set_target_queue( queue, dispatch_get_global_queue( DISPATCH_QUEUE_PRIORITY_HIGH, 0 ) );
-	keyboard.handlerQueue = queue;
+    dispatch_queue_t queue = dispatch_queue_create( "org.libsdl.input.keyboard", DISPATCH_QUEUE_SERIAL );
+    dispatch_set_target_queue( queue, dispatch_get_global_queue( DISPATCH_QUEUE_PRIORITY_HIGH, 0 ) );
+    keyboard.handlerQueue = queue;
 }
 
 static void OnGCKeyboardDisconnected(GCKeyboard *keyboard) API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0))
@@ -182,10 +183,22 @@ void SDL_QuitGCKeyboard(void)
 static int mice_connected = 0;
 static id mouse_connect_observer = nil;
 static id mouse_disconnect_observer = nil;
+static bool mouse_relative_mode = SDL_FALSE;
+
+static void UpdatePointerLock()
+{
+    SDL_VideoDevice *_this = SDL_GetVideoDevice();
+    SDL_Window *window;
+
+    for (window = _this->windows; window != NULL; window = window->next) {
+        UIKit_UpdatePointerLock(_this, window);
+    }
+}
 
 static int SetGCMouseRelativeMode(SDL_bool enabled)
 {
-    /* We'll always send relative motion and we can't warp, so nothing to do here */
+    mouse_relative_mode = enabled;
+    UpdatePointerLock();
     return 0;
 }
 
@@ -212,24 +225,28 @@ static void OnGCMouseConnected(GCMouse *mouse) API_AVAILABLE(macos(11.0), ios(14
     };
 
     int auxiliary_button = SDL_BUTTON_X1;
-    for (GCControllerButtonInput *button in mouse.mouseInput.auxiliaryButtons) {
-        button.pressedChangedHandler = ^(GCControllerButtonInput *button, float value, BOOL pressed)
+    for (GCControllerButtonInput *btn in mouse.mouseInput.auxiliaryButtons) {
+        btn.pressedChangedHandler = ^(GCControllerButtonInput *button, float value, BOOL pressed)
         {
             OnGCMouseButtonChanged(mouseID, auxiliary_button, pressed);
         };
         ++auxiliary_button;
     }
 
-    mouse.mouseInput.mouseMovedHandler = ^(GCMouseInput *mouse, float deltaX, float deltaY)
+    mouse.mouseInput.mouseMovedHandler = ^(GCMouseInput *mouseInput, float deltaX, float deltaY)
     {
-		SDL_SendMouseMotion(SDL_GetMouseFocus(), mouseID, SDL_TRUE, (int)deltaX, -(int)deltaY);
+        if (SDL_GCMouseRelativeMode()) {
+            SDL_SendMouseMotion(SDL_GetMouseFocus(), mouseID, 1, (int)deltaX, -(int)deltaY);
+        }
     };
 
-	dispatch_queue_t queue = dispatch_queue_create( "org.libsdl.input.mouse", DISPATCH_QUEUE_SERIAL );
-	dispatch_set_target_queue( queue, dispatch_get_global_queue( DISPATCH_QUEUE_PRIORITY_HIGH, 0 ) );
-	mouse.handlerQueue = queue;
+    dispatch_queue_t queue = dispatch_queue_create( "org.libsdl.input.mouse", DISPATCH_QUEUE_SERIAL );
+    dispatch_set_target_queue( queue, dispatch_get_global_queue( DISPATCH_QUEUE_PRIORITY_HIGH, 0 ) );
+    mouse.handlerQueue = queue;
 
     ++mice_connected;
+
+    UpdatePointerLock();
 }
 
 static void OnGCMouseDisconnected(GCMouse *mouse) API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0))
@@ -245,36 +262,46 @@ static void OnGCMouseDisconnected(GCMouse *mouse) API_AVAILABLE(macos(11.0), ios
     for (GCControllerButtonInput *button in mouse.mouseInput.auxiliaryButtons) {
         button.pressedChangedHandler = nil;
     }
+
+    UpdatePointerLock();
 }
 
 void SDL_InitGCMouse(void)
 {
-	@autoreleasepool {
-		/* There is a bug where mouse accumulates duplicate deltas over time in iOS 14.0 */
+    @autoreleasepool {
+        /* There is a bug where mouse accumulates duplicate deltas over time in iOS 14.0 */
         if (@available(iOS 14.1, tvOS 14.1, *)) {
-            NSNotificationCenter *center = [NSNotificationCenter defaultCenter];
+            /* iOS will not send the new pointer touch events if you don't have this key,
+             * and we need them to differentiate between mouse events and real touch events.
+             */
+            BOOL indirect_input_available = [[[[NSBundle mainBundle] infoDictionary] objectForKey:@"UIApplicationSupportsIndirectInputEvents"] boolValue];
+            if (indirect_input_available) {
+                NSNotificationCenter *center = [NSNotificationCenter defaultCenter];
 
-            mouse_connect_observer = [center addObserverForName:GCMouseDidConnectNotification
-                                                         object:nil
-                                                          queue:nil
-                                                     usingBlock:^(NSNotification *note) {
-                                                         GCMouse *mouse = note.object;
-                                                         OnGCMouseConnected(mouse);
-                                                     }];
+                mouse_connect_observer = [center addObserverForName:GCMouseDidConnectNotification
+                                                             object:nil
+                                                              queue:nil
+                                                         usingBlock:^(NSNotification *note) {
+                                                             GCMouse *mouse = note.object;
+                                                             OnGCMouseConnected(mouse);
+                                                         }];
 
-            mouse_disconnect_observer = [center addObserverForName:GCMouseDidDisconnectNotification
-                                                            object:nil
-                                                             queue:nil
-                                                        usingBlock:^(NSNotification *note) {
-                                                            GCMouse *mouse = note.object;
-                                                            OnGCMouseDisconnected(mouse);
-                                                       }];
+                mouse_disconnect_observer = [center addObserverForName:GCMouseDidDisconnectNotification
+                                                                object:nil
+                                                                 queue:nil
+                                                            usingBlock:^(NSNotification *note) {
+                                                                GCMouse *mouse = note.object;
+                                                                OnGCMouseDisconnected(mouse);
+                                                           }];
 
-            for (GCMouse *mouse in [GCMouse mice]) {
-                OnGCMouseConnected(mouse);
+                for (GCMouse *mouse in [GCMouse mice]) {
+                    OnGCMouseConnected(mouse);
+                }
+
+                SDL_GetMouse()->SetRelativeMouseMode = SetGCMouseRelativeMode;
+            } else {
+                NSLog(@"You need UIApplicationSupportsIndirectInputEvents in your Info.plist for mouse support");
             }
-
-            SDL_GetMouse()->SetRelativeMouseMode = SetGCMouseRelativeMode;
         }
     }
 }
@@ -284,6 +311,11 @@ SDL_bool SDL_HasGCMouse(void)
     return (mice_connected > 0);
 }
 
+SDL_bool SDL_GCMouseRelativeMode(void)
+{
+    return mouse_relative_mode;
+}
+
 void SDL_QuitGCMouse(void)
 {
     @autoreleasepool {
@@ -320,6 +352,11 @@ SDL_bool SDL_HasGCMouse(void)
     return SDL_FALSE;
 }
 
+SDL_bool SDL_GCMouseRelativeMode(void)
+{
+    return SDL_FALSE;
+}
+
 void SDL_QuitGCMouse(void)
 {
 }
diff --git a/Engine/lib/sdl/src/video/uikit/SDL_uikitmessagebox.h b/Engine/lib/sdl/src/video/uikit/SDL_uikitmessagebox.h
index 4d5fe1d44..9904ccf3b 100644
--- a/Engine/lib/sdl/src/video/uikit/SDL_uikitmessagebox.h
+++ b/Engine/lib/sdl/src/video/uikit/SDL_uikitmessagebox.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/uikit/SDL_uikitmessagebox.m b/Engine/lib/sdl/src/video/uikit/SDL_uikitmessagebox.m
index c1f78b7af..fdc20c086 100644
--- a/Engine/lib/sdl/src/video/uikit/SDL_uikitmessagebox.m
+++ b/Engine/lib/sdl/src/video/uikit/SDL_uikitmessagebox.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -86,7 +86,7 @@ UIKit_ShowMessageBoxAlertController(const SDL_MessageBoxData *messageboxdata, in
 
         action = [UIAlertAction actionWithTitle:@(sdlButton->text)
                                 style:style
-                                handler:^(UIAlertAction *action) {
+                                handler:^(UIAlertAction *alertAction) {
                                     clickedindex = (int)(sdlButton - messageboxdata->buttons);
                                 }];
         [alert addAction:action];
diff --git a/Engine/lib/sdl/src/video/uikit/SDL_uikitmetalview.h b/Engine/lib/sdl/src/video/uikit/SDL_uikitmetalview.h
index cd63e7852..91cd0b0a2 100644
--- a/Engine/lib/sdl/src/video/uikit/SDL_uikitmetalview.h
+++ b/Engine/lib/sdl/src/video/uikit/SDL_uikitmetalview.h
@@ -1,6 +1,6 @@
 /*
  Simple DirectMedia Layer
- Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+ Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
  
  This software is provided 'as-is', without any express or implied
  warranty.  In no event will the authors be held liable for any damages
@@ -38,7 +38,6 @@
 #import <Metal/Metal.h>
 #import <QuartzCore/CAMetalLayer.h>
 
-#define METALVIEW_TAG 255
 
 @interface SDL_uikitmetalview : SDL_uikitview
 
diff --git a/Engine/lib/sdl/src/video/uikit/SDL_uikitmetalview.m b/Engine/lib/sdl/src/video/uikit/SDL_uikitmetalview.m
index 78c391d91..8274eaff9 100644
--- a/Engine/lib/sdl/src/video/uikit/SDL_uikitmetalview.m
+++ b/Engine/lib/sdl/src/video/uikit/SDL_uikitmetalview.m
@@ -1,6 +1,6 @@
 /*
  Simple DirectMedia Layer
- Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+ Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
  
  This software is provided 'as-is', without any express or implied
  warranty.  In no event will the authors be held liable for any damages
@@ -30,7 +30,9 @@
 
 #if SDL_VIDEO_DRIVER_UIKIT && (SDL_VIDEO_VULKAN || SDL_VIDEO_METAL)
 
-#import "../SDL_sysvideo.h"
+#include "SDL_syswm.h"
+#include "../SDL_sysvideo.h"
+
 #import "SDL_uikitwindow.h"
 #import "SDL_uikitmetalview.h"
 
@@ -47,7 +49,7 @@
                         scale:(CGFloat)scale
 {
     if ((self = [super initWithFrame:frame])) {
-        self.tag = METALVIEW_TAG;
+        self.tag = SDL_METALVIEW_TAG;
         self.layer.contentsScale = scale;
         [self updateDrawableSize];
     }
@@ -122,7 +124,7 @@ UIKit_Metal_GetDrawableSize(_THIS, SDL_Window * window, int * w, int * h)
     @autoreleasepool {
         SDL_WindowData *data = (__bridge SDL_WindowData *)window->driverdata;
         SDL_uikitview *view = (SDL_uikitview*)data.uiwindow.rootViewController.view;
-        SDL_uikitmetalview* metalview = [view viewWithTag:METALVIEW_TAG];
+        SDL_uikitmetalview* metalview = [view viewWithTag:SDL_METALVIEW_TAG];
         if (metalview) {
             CAMetalLayer *layer = (CAMetalLayer*)metalview.layer;
             assert(layer != NULL);
diff --git a/Engine/lib/sdl/src/video/uikit/SDL_uikitmodes.h b/Engine/lib/sdl/src/video/uikit/SDL_uikitmodes.h
index 25b9eca6a..d4f3b20ef 100644
--- a/Engine/lib/sdl/src/video/uikit/SDL_uikitmodes.h
+++ b/Engine/lib/sdl/src/video/uikit/SDL_uikitmodes.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/uikit/SDL_uikitmodes.m b/Engine/lib/sdl/src/video/uikit/SDL_uikitmodes.m
index 7ad4bcb19..bfd7a649b 100644
--- a/Engine/lib/sdl/src/video/uikit/SDL_uikitmodes.m
+++ b/Engine/lib/sdl/src/video/uikit/SDL_uikitmodes.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/uikit/SDL_uikitopengles.h b/Engine/lib/sdl/src/video/uikit/SDL_uikitopengles.h
index 1d24b98bb..c2e6d571c 100644
--- a/Engine/lib/sdl/src/video/uikit/SDL_uikitopengles.h
+++ b/Engine/lib/sdl/src/video/uikit/SDL_uikitopengles.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/uikit/SDL_uikitopengles.m b/Engine/lib/sdl/src/video/uikit/SDL_uikitopengles.m
index fb0dae56f..86fefd76c 100644
--- a/Engine/lib/sdl/src/video/uikit/SDL_uikitopengles.m
+++ b/Engine/lib/sdl/src/video/uikit/SDL_uikitopengles.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -162,8 +162,8 @@ UIKit_GL_CreateContext(_THIS, SDL_Window * window)
         }
 
         if (_this->gl_config.share_with_current_context) {
-            EAGLContext *context = (__bridge EAGLContext *) SDL_GL_GetCurrentContext();
-            sharegroup = context.sharegroup;
+            EAGLContext *currContext = (__bridge EAGLContext *) SDL_GL_GetCurrentContext();
+            sharegroup = currContext.sharegroup;
         }
 
         if (window->flags & SDL_WINDOW_ALLOW_HIGHDPI) {
diff --git a/Engine/lib/sdl/src/video/uikit/SDL_uikitopenglview.h b/Engine/lib/sdl/src/video/uikit/SDL_uikitopenglview.h
index 91d6ab087..df659a1f1 100644
--- a/Engine/lib/sdl/src/video/uikit/SDL_uikitopenglview.h
+++ b/Engine/lib/sdl/src/video/uikit/SDL_uikitopenglview.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/uikit/SDL_uikitopenglview.m b/Engine/lib/sdl/src/video/uikit/SDL_uikitopenglview.m
index b59f1d68c..52158f8d7 100644
--- a/Engine/lib/sdl/src/video/uikit/SDL_uikitopenglview.m
+++ b/Engine/lib/sdl/src/video/uikit/SDL_uikitopenglview.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/uikit/SDL_uikitvideo.h b/Engine/lib/sdl/src/video/uikit/SDL_uikitvideo.h
index 9b2b7b204..b684e23a8 100644
--- a/Engine/lib/sdl/src/video/uikit/SDL_uikitvideo.h
+++ b/Engine/lib/sdl/src/video/uikit/SDL_uikitvideo.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/uikit/SDL_uikitvideo.m b/Engine/lib/sdl/src/video/uikit/SDL_uikitvideo.m
index 8adaaffae..5d2b96e38 100644
--- a/Engine/lib/sdl/src/video/uikit/SDL_uikitvideo.m
+++ b/Engine/lib/sdl/src/video/uikit/SDL_uikitvideo.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -93,6 +93,7 @@ UIKit_CreateDevice(int devindex)
         device->RaiseWindow = UIKit_RaiseWindow;
         device->SetWindowBordered = UIKit_SetWindowBordered;
         device->SetWindowFullscreen = UIKit_SetWindowFullscreen;
+        device->SetWindowMouseGrab = UIKit_SetWindowMouseGrab;
         device->DestroyWindow = UIKit_DestroyWindow;
         device->GetWindowWMInfo = UIKit_GetWindowWMInfo;
         device->GetDisplayUsableBounds = UIKit_GetDisplayUsableBounds;
@@ -159,8 +160,8 @@ UIKit_VideoInit(_THIS)
         return -1;
     }
 
-	SDL_InitGCKeyboard();
-	SDL_InitGCMouse();
+    SDL_InitGCKeyboard();
+    SDL_InitGCMouse();
 
     return 0;
 }
@@ -168,8 +169,8 @@ UIKit_VideoInit(_THIS)
 void
 UIKit_VideoQuit(_THIS)
 {
-	SDL_QuitGCKeyboard();
-	SDL_QuitGCMouse();
+    SDL_QuitGCKeyboard();
+    SDL_QuitGCMouse();
 
     UIKit_QuitModes(_this);
 }
@@ -279,7 +280,10 @@ UIKit_ForceUpdateHomeIndicator()
 #if !defined(SDL_VIDEO_DRIVER_COCOA)
 void SDL_NSLog(const char *text)
 {
-    NSLog(@"%s", text);
+    @autoreleasepool {
+        NSString *str = [NSString stringWithUTF8String:text];
+        NSLog(@"%@", str);
+    }
 }
 #endif /* SDL_VIDEO_DRIVER_COCOA */
 
diff --git a/Engine/lib/sdl/src/video/uikit/SDL_uikitview.h b/Engine/lib/sdl/src/video/uikit/SDL_uikitview.h
index 89b68c22a..dcd63c7a5 100644
--- a/Engine/lib/sdl/src/video/uikit/SDL_uikitview.h
+++ b/Engine/lib/sdl/src/video/uikit/SDL_uikitview.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/uikit/SDL_uikitview.m b/Engine/lib/sdl/src/video/uikit/SDL_uikitview.m
index cb97aed81..77d398c20 100644
--- a/Engine/lib/sdl/src/video/uikit/SDL_uikitview.m
+++ b/Engine/lib/sdl/src/video/uikit/SDL_uikitview.m
@@ -1,6 +1,6 @@
  /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -160,7 +160,7 @@ extern int SDL_AppleTVRemoteOpenedAsJoystick;
 
 #if !TARGET_OS_TV && defined(__IPHONE_13_4)
 - (UIPointerRegion *)pointerInteraction:(UIPointerInteraction *)interaction regionForRequest:(UIPointerRegionRequest *)request defaultRegion:(UIPointerRegion *)defaultRegion API_AVAILABLE(ios(13.4)){
-    if (request != nil && !SDL_HasGCMouse()) {
+    if (request != nil && !SDL_GCMouseRelativeMode()) {
         CGPoint origin = self.bounds.origin;
         CGPoint point = request.location;
 
diff --git a/Engine/lib/sdl/src/video/uikit/SDL_uikitviewcontroller.h b/Engine/lib/sdl/src/video/uikit/SDL_uikitviewcontroller.h
index 77076d707..cff5445a3 100644
--- a/Engine/lib/sdl/src/video/uikit/SDL_uikitviewcontroller.h
+++ b/Engine/lib/sdl/src/video/uikit/SDL_uikitviewcontroller.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/uikit/SDL_uikitviewcontroller.m b/Engine/lib/sdl/src/video/uikit/SDL_uikitviewcontroller.m
index d001e96f0..2ab23abd9 100644
--- a/Engine/lib/sdl/src/video/uikit/SDL_uikitviewcontroller.m
+++ b/Engine/lib/sdl/src/video/uikit/SDL_uikitviewcontroller.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -27,8 +27,9 @@
 #include "../SDL_sysvideo.h"
 #include "../../events/SDL_events_c.h"
 
-#import "SDL_uikitviewcontroller.h"
-#import "SDL_uikitmessagebox.h"
+#include "SDL_uikitviewcontroller.h"
+#include "SDL_uikitmessagebox.h"
+#include "SDL_uikitevents.h"
 #include "SDL_uikitvideo.h"
 #include "SDL_uikitmodes.h"
 #include "SDL_uikitwindow.h"
@@ -246,7 +247,13 @@ SDL_HideHomeIndicatorHintChanged(void *userdata, const char *name, const char *o
         return UIRectEdgeNone;
     }
 }
-#endif
+
+- (BOOL)prefersPointerLocked
+{
+    return SDL_GCMouseRelativeMode() ? YES : NO;
+}
+
+#endif /* !TARGET_OS_TV */
 
 /*
  ---- Keyboard related functionality below this line ----
diff --git a/Engine/lib/sdl/src/video/uikit/SDL_uikitvulkan.h b/Engine/lib/sdl/src/video/uikit/SDL_uikitvulkan.h
index eb7accbe4..cc8f777eb 100644
--- a/Engine/lib/sdl/src/video/uikit/SDL_uikitvulkan.h
+++ b/Engine/lib/sdl/src/video/uikit/SDL_uikitvulkan.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/uikit/SDL_uikitvulkan.m b/Engine/lib/sdl/src/video/uikit/SDL_uikitvulkan.m
index a3692d34e..f0f2d2b04 100644
--- a/Engine/lib/sdl/src/video/uikit/SDL_uikitvulkan.m
+++ b/Engine/lib/sdl/src/video/uikit/SDL_uikitvulkan.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/uikit/SDL_uikitwindow.h b/Engine/lib/sdl/src/video/uikit/SDL_uikitwindow.h
index dd7c38823..65dbc875b 100644
--- a/Engine/lib/sdl/src/video/uikit/SDL_uikitwindow.h
+++ b/Engine/lib/sdl/src/video/uikit/SDL_uikitwindow.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -33,6 +33,8 @@ extern void UIKit_HideWindow(_THIS, SDL_Window * window);
 extern void UIKit_RaiseWindow(_THIS, SDL_Window * window);
 extern void UIKit_SetWindowBordered(_THIS, SDL_Window * window, SDL_bool bordered);
 extern void UIKit_SetWindowFullscreen(_THIS, SDL_Window * window, SDL_VideoDisplay * display, SDL_bool fullscreen);
+extern void UIKit_SetWindowMouseGrab(_THIS, SDL_Window * window, SDL_bool grabbed);
+extern void UIKit_UpdatePointerLock(_THIS, SDL_Window * window);
 extern void UIKit_DestroyWindow(_THIS, SDL_Window * window);
 extern SDL_bool UIKit_GetWindowWMInfo(_THIS, SDL_Window * window,
                                       struct SDL_SysWMinfo * info);
diff --git a/Engine/lib/sdl/src/video/uikit/SDL_uikitwindow.m b/Engine/lib/sdl/src/video/uikit/SDL_uikitwindow.m
index 41b6e4073..6808de4eb 100644
--- a/Engine/lib/sdl/src/video/uikit/SDL_uikitwindow.m
+++ b/Engine/lib/sdl/src/video/uikit/SDL_uikitwindow.m
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -161,14 +161,14 @@ UIKit_CreateWindow(_THIS, SDL_Window *window)
     @autoreleasepool {
         SDL_VideoDisplay *display = SDL_GetDisplayForWindow(window);
         SDL_DisplayData *data = (__bridge SDL_DisplayData *) display->driverdata;
-		SDL_Window *other;
+        SDL_Window *other;
 
         /* We currently only handle a single window per display on iOS */
-		for (other = _this->windows; other; other = other->next) {
-			if (other != window && SDL_GetDisplayForWindow(other) == display) {
-				return SDL_SetError("Only one window allowed per display.");
-			}
-		}
+        for (other = _this->windows; other; other = other->next) {
+            if (other != window && SDL_GetDisplayForWindow(other) == display) {
+                return SDL_SetError("Only one window allowed per display.");
+            }
+        }
 
         /* If monitor has a resolution of 0x0 (hasn't been explicitly set by the
          * user, so it's in standby), try to force the display to a resolution
@@ -320,6 +320,28 @@ UIKit_SetWindowFullscreen(_THIS, SDL_Window * window, SDL_VideoDisplay * display
     }
 }
 
+void
+UIKit_SetWindowMouseGrab(_THIS, SDL_Window * window, SDL_bool grabbed)
+{
+    /* There really isn't a concept of window grab or cursor confinement on iOS */
+}
+
+void
+UIKit_UpdatePointerLock(_THIS, SDL_Window * window)
+{
+#if !TARGET_OS_TV
+#if defined(__IPHONE_14_0) && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_14_0
+    @autoreleasepool {
+        SDL_WindowData *data = (__bridge SDL_WindowData *) window->driverdata;
+        SDL_uikitviewcontroller *viewcontroller = data.viewcontroller;
+        if (@available(iOS 14.0, *)) {
+            [viewcontroller setNeedsUpdateOfPrefersPointerLocked];
+        }
+    }
+#endif /* defined(__IPHONE_14_0) && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_14_0 */
+#endif /* !TARGET_OS_TV */
+}
+
 void
 UIKit_DestroyWindow(_THIS, SDL_Window * window)
 {
diff --git a/Engine/lib/sdl/src/video/uikit/keyinfotable.h b/Engine/lib/sdl/src/video/uikit/keyinfotable.h
index 83be4ed6f..25df10534 100644
--- a/Engine/lib/sdl/src/video/uikit/keyinfotable.h
+++ b/Engine/lib/sdl/src/video/uikit/keyinfotable.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/vita/SDL_vitaframebuffer.c b/Engine/lib/sdl/src/video/vita/SDL_vitaframebuffer.c
new file mode 100644
index 000000000..992c7af84
--- /dev/null
+++ b/Engine/lib/sdl/src/video/vita/SDL_vitaframebuffer.c
@@ -0,0 +1,116 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if SDL_VIDEO_DRIVER_VITA
+
+#include "SDL_vitavideo.h"
+
+#include <psp2/kernel/sysmem.h>
+
+#define SCREEN_W 960
+#define SCREEN_H 544
+#define ALIGN(x, a)     (((x) + ((a) - 1)) & ~((a) - 1))
+#define DISPLAY_PIXEL_FORMAT SCE_DISPLAY_PIXELFORMAT_A8B8G8R8
+
+void *vita_gpu_alloc(SceKernelMemBlockType type, unsigned int size, SceUID *uid)
+{
+    void *mem;
+
+    if (type == SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW) {
+        size = ALIGN(size, 256*1024);
+    } else {
+        size = ALIGN(size, 4*1024);
+    }
+
+    *uid = sceKernelAllocMemBlock("gpu_mem", type, size, NULL);
+
+    if (*uid < 0)
+        return NULL;
+
+    if (sceKernelGetMemBlockBase(*uid, &mem) < 0)
+        return NULL;
+
+    return mem;
+}
+
+void vita_gpu_free(SceUID uid)
+{
+    void *mem = NULL;
+    if (sceKernelGetMemBlockBase(uid, &mem) < 0)
+        return;
+    sceKernelFreeMemBlock(uid);
+}
+
+int VITA_CreateWindowFramebuffer(_THIS, SDL_Window * window, Uint32 * format, void ** pixels, int *pitch)
+{
+    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
+    SceDisplayFrameBuf framebuf;
+
+    *format = SDL_PIXELFORMAT_ABGR8888;
+    *pitch = SCREEN_W * 4;
+
+    data->buffer = vita_gpu_alloc(
+        SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW,
+        4 * SCREEN_W * SCREEN_H,
+        &data->buffer_uid
+    );
+
+    // SDL_memset the buffer to black
+    SDL_memset(data->buffer, 0x0, SCREEN_W*SCREEN_H*4);
+
+    SDL_memset(&framebuf, 0x00, sizeof(SceDisplayFrameBuf));
+    framebuf.size        = sizeof(SceDisplayFrameBuf);
+    framebuf.base        = data->buffer;
+    framebuf.pitch       = SCREEN_W;
+    framebuf.pixelformat = DISPLAY_PIXEL_FORMAT;
+    framebuf.width       = SCREEN_W;
+    framebuf.height      = SCREEN_H;
+    sceDisplaySetFrameBuf(&framebuf, SCE_DISPLAY_SETBUF_NEXTFRAME);
+
+    *pixels = data->buffer;
+
+    return 0;
+}
+
+int VITA_UpdateWindowFramebuffer(_THIS, SDL_Window * window, const SDL_Rect * rects, int numrects)
+{
+    // do nothing
+    return 0;
+}
+
+void VITA_DestroyWindowFramebuffer(_THIS, SDL_Window * window)
+{
+    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
+
+    if (!data) {
+        /* The window wasn't fully initialized */
+        return;
+    }
+
+    vita_gpu_free(data->buffer_uid);
+    data->buffer = NULL;
+    return;
+}
+
+#endif /* SDL_VIDEO_DRIVER_VITA */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/vita/SDL_vitaframebuffer.h b/Engine/lib/sdl/src/video/vita/SDL_vitaframebuffer.h
new file mode 100644
index 000000000..f2d1e1b94
--- /dev/null
+++ b/Engine/lib/sdl/src/video/vita/SDL_vitaframebuffer.h
@@ -0,0 +1,27 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+extern int VITA_CreateWindowFramebuffer(_THIS, SDL_Window * window, Uint32 * format, void ** pixels, int *pitch);
+extern int VITA_UpdateWindowFramebuffer(_THIS, SDL_Window * window, const SDL_Rect * rects, int numrects);
+extern void VITA_DestroyWindowFramebuffer(_THIS, SDL_Window * window);
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/vita/SDL_vitagl.c b/Engine/lib/sdl/src/video/vita/SDL_vitagl.c
new file mode 100644
index 000000000..f65022865
--- /dev/null
+++ b/Engine/lib/sdl/src/video/vita/SDL_vitagl.c
@@ -0,0 +1,235 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if SDL_VIDEO_DRIVER_VITA && SDL_VIDEO_VITA_PIB
+#include <stdlib.h>
+#include <string.h>
+
+#include "SDL_error.h"
+#include "SDL_log.h"
+#include "SDL_vitavideo.h"
+#include "SDL_vitagl_c.h"
+
+/*****************************************************************************/
+/* SDL OpenGL/OpenGL ES functions                                            */
+/*****************************************************************************/
+#define EGLCHK(stmt)                            \
+    do {                                        \
+        EGLint err;                             \
+                                                \
+        stmt;                                   \
+        err = eglGetError();                    \
+        if (err != EGL_SUCCESS) {               \
+            SDL_SetError("EGL error %d", err);  \
+            return 0;                           \
+        }                                       \
+    } while (0)
+
+void 
+VITA_GL_KeyboardCallback(ScePigletPreSwapData *data)
+{
+    SceCommonDialogUpdateParam commonDialogParam;
+    SDL_zero(commonDialogParam);
+    commonDialogParam.renderTarget.colorFormat = data->colorFormat;
+    commonDialogParam.renderTarget.surfaceType = data->surfaceType;
+    commonDialogParam.renderTarget.colorSurfaceData = data->colorSurfaceData;
+    commonDialogParam.renderTarget.depthSurfaceData = data->depthSurfaceData;
+    commonDialogParam.renderTarget.width = data->width;
+    commonDialogParam.renderTarget.height = data->height;
+    commonDialogParam.renderTarget.strideInPixels = data->strideInPixels;
+    commonDialogParam.displaySyncObject = data->displaySyncObject;
+
+    sceCommonDialogUpdate(&commonDialogParam);
+}
+
+int
+VITA_GL_LoadLibrary(_THIS, const char *path)
+{
+  pibInit(PIB_SHACCCG | PIB_GET_PROC_ADDR_CORE);
+  return 0;
+}
+
+void *
+VITA_GL_GetProcAddress(_THIS, const char *proc)
+{
+    return eglGetProcAddress(proc);
+}
+
+void
+VITA_GL_UnloadLibrary(_THIS)
+{
+    eglTerminate(_this->gl_data->display);
+}
+
+static EGLint width = 960;
+static EGLint height = 544;
+
+SDL_GLContext
+VITA_GL_CreateContext(_THIS, SDL_Window * window)
+{
+
+    SDL_WindowData *wdata = (SDL_WindowData *) window->driverdata;
+
+    EGLint attribs[32];
+    EGLDisplay display;
+    EGLContext context;
+    EGLSurface surface;
+    EGLConfig config;
+    EGLint num_configs;
+    PFNEGLPIGLETVITASETPRESWAPCALLBACKSCEPROC preSwapCallback;
+    int i;
+
+    const EGLint contextAttribs[] = {
+        EGL_CONTEXT_CLIENT_VERSION, 2,
+        EGL_NONE
+    };
+
+    EGLCHK(display = eglGetDisplay(0));
+
+    EGLCHK(eglInitialize(display, NULL, NULL));
+    wdata->uses_gles = SDL_TRUE;
+    window->flags |= SDL_WINDOW_FULLSCREEN;
+
+    EGLCHK(eglBindAPI(EGL_OPENGL_ES_API));
+
+    i = 0;
+    attribs[i++] = EGL_RED_SIZE;
+    attribs[i++] = 8;
+    attribs[i++] = EGL_GREEN_SIZE;
+    attribs[i++] = 8;
+    attribs[i++] = EGL_BLUE_SIZE;
+    attribs[i++] = 8;
+    attribs[i++] = EGL_DEPTH_SIZE;
+    attribs[i++] = 0;
+    attribs[i++] = EGL_ALPHA_SIZE;
+    attribs[i++] = 8;
+    attribs[i++] = EGL_STENCIL_SIZE;
+    attribs[i++] = 0;
+
+    attribs[i++] = EGL_SURFACE_TYPE;
+    attribs[i++] = 5;
+
+    attribs[i++] = EGL_RENDERABLE_TYPE;
+    attribs[i++] = EGL_OPENGL_ES2_BIT;
+
+    attribs[i++] = EGL_CONFORMANT;
+    attribs[i++] = EGL_OPENGL_ES2_BIT;
+
+    attribs[i++] = EGL_NONE;
+
+    EGLCHK(eglChooseConfig(display, attribs, &config, 1, &num_configs));
+
+    if (num_configs == 0)
+    {
+        SDL_SetError("No valid EGL configs for requested mode");
+        return 0;
+    }
+
+
+    EGLCHK(surface = eglCreateWindowSurface(display, config, VITA_WINDOW_960X544, NULL));
+
+    EGLCHK(context = eglCreateContext(display, config, EGL_NO_CONTEXT, contextAttribs));
+
+    EGLCHK(eglMakeCurrent(display, surface, surface, context));
+
+    EGLCHK(eglQuerySurface(display, surface, EGL_WIDTH, &width));
+    EGLCHK(eglQuerySurface(display, surface, EGL_HEIGHT, &height));
+
+    _this->gl_data->display = display;
+    _this->gl_data->context = context;
+    _this->gl_data->surface = surface;
+
+    preSwapCallback = (PFNEGLPIGLETVITASETPRESWAPCALLBACKSCEPROC) eglGetProcAddress("eglPigletVitaSetPreSwapCallbackSCE");
+    preSwapCallback(VITA_GL_KeyboardCallback);
+
+    return context;
+}
+
+int
+VITA_GL_MakeCurrent(_THIS, SDL_Window * window, SDL_GLContext context)
+{
+        if (!eglMakeCurrent(_this->gl_data->display, _this->gl_data->surface,
+                          _this->gl_data->surface, _this->gl_data->context))
+        {
+            return SDL_SetError("Unable to make EGL context current");
+        }
+    return 0;
+}
+
+int
+VITA_GL_SetSwapInterval(_THIS, int interval)
+{
+    EGLBoolean status;
+    status = eglSwapInterval(_this->gl_data->display, interval);
+    if (status == EGL_TRUE) {
+        /* Return success to upper level */
+        _this->gl_data->swapinterval = interval;
+        return 0;
+    }
+    /* Failed to set swap interval */
+    return SDL_SetError("Unable to set the EGL swap interval");
+}
+
+int
+VITA_GL_GetSwapInterval(_THIS)
+{
+    return _this->gl_data->swapinterval;
+}
+
+int
+VITA_GL_SwapWindow(_THIS, SDL_Window * window)
+{
+    if (!eglSwapBuffers(_this->gl_data->display, _this->gl_data->surface)) {
+        return SDL_SetError("eglSwapBuffers() failed");
+    }
+    return 0;
+}
+
+void
+VITA_GL_DeleteContext(_THIS, SDL_GLContext context)
+{
+    SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;
+    EGLBoolean status;
+
+    if (phdata->egl_initialized != SDL_TRUE) {
+        SDL_SetError("VITA: GLES initialization failed, no OpenGL ES support");
+        return;
+    }
+
+    /* Check if OpenGL ES connection has been initialized */
+    if (_this->gl_data->display != EGL_NO_DISPLAY) {
+        if (context != EGL_NO_CONTEXT) {
+            status = eglDestroyContext(_this->gl_data->display, context);
+            if (status != EGL_TRUE) {
+                /* Error during OpenGL ES context destroying */
+                SDL_SetError("VITA: OpenGL ES context destroy error");
+                return;
+            }
+        }
+    }
+
+    return;
+}
+
+#endif /* SDL_VIDEO_DRIVER_VITA */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/vita/SDL_vitagl_c.h b/Engine/lib/sdl/src/video/vita/SDL_vitagl_c.h
new file mode 100644
index 000000000..272653d70
--- /dev/null
+++ b/Engine/lib/sdl/src/video/vita/SDL_vitagl_c.h
@@ -0,0 +1,57 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_vitagl_c_h_
+#define SDL_vitagl_c_h_
+
+
+#include <pib.h>
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+
+#include "SDL_vitavideo.h"
+
+
+typedef struct SDL_GLDriverData {
+        EGLDisplay display;
+        EGLContext context;
+        EGLSurface surface;
+    uint32_t swapinterval;
+}SDL_GLDriverData;
+
+extern void * VITA_GL_GetProcAddress(_THIS, const char *proc);
+extern int VITA_GL_MakeCurrent(_THIS,SDL_Window * window, SDL_GLContext context);
+extern void VITA_GL_SwapBuffers(_THIS);
+
+extern int VITA_GL_SwapWindow(_THIS, SDL_Window * window);
+extern SDL_GLContext VITA_GL_CreateContext(_THIS, SDL_Window * window);
+
+extern int VITA_GL_LoadLibrary(_THIS, const char *path);
+extern void VITA_GL_UnloadLibrary(_THIS);
+extern int VITA_GL_SetSwapInterval(_THIS, int interval);
+extern int VITA_GL_GetSwapInterval(_THIS);
+
+
+#endif /* SDL_vitagl_c_h_ */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/vita/SDL_vitagl_pvr.c b/Engine/lib/sdl/src/video/vita/SDL_vitagl_pvr.c
new file mode 100644
index 000000000..3b7fb7477
--- /dev/null
+++ b/Engine/lib/sdl/src/video/vita/SDL_vitagl_pvr.c
@@ -0,0 +1,103 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if SDL_VIDEO_DRIVER_VITA && SDL_VIDEO_VITA_PVR
+#include <stdlib.h>
+#include <string.h>
+#include <psp2/kernel/modulemgr.h>
+#include <gpu_es4/psp2_pvr_hint.h>
+
+#include "SDL_error.h"
+#include "SDL_log.h"
+#include "SDL_vitavideo.h"
+#include "../SDL_egl_c.h"
+#include "SDL_vitagl_pvr_c.h"
+
+#define MAX_PATH 256 // vita limits are somehow wrong
+
+int
+VITA_GL_LoadLibrary(_THIS, const char *path)
+{
+    PVRSRV_PSP2_APPHINT hint;
+    char* override = SDL_getenv("VITA_MODULE_PATH");
+    char* skip_init = SDL_getenv("VITA_PVR_SKIP_INIT");
+    char* default_path = "app0:module";
+    char target_path[MAX_PATH];
+
+    if (skip_init == NULL) // we don't care about actual value
+    {
+        if (override != NULL)
+        {
+          default_path = override;
+        }
+
+        sceKernelLoadStartModule("vs0:sys/external/libfios2.suprx", 0, NULL, 0, NULL, NULL);
+        sceKernelLoadStartModule("vs0:sys/external/libc.suprx", 0, NULL, 0, NULL, NULL);
+
+        SDL_snprintf(target_path, MAX_PATH, "%s/%s", default_path, "libgpu_es4_ext.suprx");
+        sceKernelLoadStartModule(target_path, 0, NULL, 0, NULL, NULL);
+
+        SDL_snprintf(target_path, MAX_PATH, "%s/%s", default_path, "libIMGEGL.suprx");
+        sceKernelLoadStartModule(target_path, 0, NULL, 0, NULL, NULL);
+
+        PVRSRVInitializeAppHint(&hint);
+
+        SDL_snprintf(hint.szGLES1, MAX_PATH, "%s/%s", default_path, "libGLESv1_CM.suprx");
+        SDL_snprintf(hint.szGLES2, MAX_PATH, "%s/%s", default_path, "libGLESv2.suprx");
+        SDL_snprintf(hint.szWindowSystem, MAX_PATH, "%s/%s", default_path, "libpvrPSP2_WSEGL.suprx");
+
+        PVRSRVCreateVirtualAppHint(&hint);
+    }
+
+    return SDL_EGL_LoadLibrary(_this, path, (NativeDisplayType) 0, 0);
+}
+
+SDL_GLContext
+VITA_GL_CreateContext(_THIS, SDL_Window * window)
+{
+    return SDL_EGL_CreateContext(_this, ((SDL_WindowData *) window->driverdata)->egl_surface);
+}
+
+int
+VITA_GL_MakeCurrent(_THIS, SDL_Window * window, SDL_GLContext context)
+{
+    if (window && context) {
+        return SDL_EGL_MakeCurrent(_this, ((SDL_WindowData *) window->driverdata)->egl_surface, context);
+    } else {
+        return SDL_EGL_MakeCurrent(_this, NULL, NULL);
+    }
+}
+
+int
+VITA_GL_SwapWindow(_THIS, SDL_Window * window)
+{
+    SDL_VideoData *videodata = (SDL_VideoData *)_this->driverdata;
+    if (videodata->ime_active) {
+        sceImeUpdate();
+    }
+    return SDL_EGL_SwapBuffers(_this, ((SDL_WindowData *) window->driverdata)->egl_surface);
+}
+
+
+#endif /* SDL_VIDEO_DRIVER_VITA && SDL_VIDEO_VITA_PVR */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/vita/SDL_vitagl_pvr_c.h b/Engine/lib/sdl/src/video/vita/SDL_vitagl_pvr_c.h
new file mode 100644
index 000000000..670eaebb0
--- /dev/null
+++ b/Engine/lib/sdl/src/video/vita/SDL_vitagl_pvr_c.h
@@ -0,0 +1,35 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_vitagl_c_h_
+#define SDL_vitagl_c_h_
+
+#include "SDL_vitavideo.h"
+
+extern int VITA_GL_MakeCurrent(_THIS,SDL_Window * window, SDL_GLContext context);
+extern int VITA_GL_SwapWindow(_THIS, SDL_Window * window);
+extern SDL_GLContext VITA_GL_CreateContext(_THIS, SDL_Window * window);
+extern int VITA_GL_LoadLibrary(_THIS, const char *path);
+
+
+#endif /* SDL_vitagl_c_h_ */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/vita/SDL_vitakeyboard.c b/Engine/lib/sdl/src/video/vita/SDL_vitakeyboard.c
new file mode 100644
index 000000000..409d424b1
--- /dev/null
+++ b/Engine/lib/sdl/src/video/vita/SDL_vitakeyboard.c
@@ -0,0 +1,203 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if SDL_VIDEO_DRIVER_VITA
+
+#include <psp2/kernel/processmgr.h>
+#include <psp2/ctrl.h>
+#include <psp2/hid.h>
+
+#include "SDL_events.h"
+#include "SDL_log.h"
+#include "SDL_vitavideo.h"
+#include "SDL_vitakeyboard.h"
+#include "../../events/SDL_keyboard_c.h"
+
+SceHidKeyboardReport k_reports[SCE_HID_MAX_REPORT];
+int keyboard_hid_handle = 0;
+Uint8 prev_keys[6] = {0};
+Uint8 prev_modifiers = 0;
+Uint8 locks = 0;
+Uint8 lock_key_down = 0;
+
+void 
+VITA_InitKeyboard(void)
+{
+#if defined(SDL_VIDEO_VITA_PVR)
+    sceSysmoduleLoadModule(SCE_SYSMODULE_IME); /** For PVR OSK Support **/
+#endif
+    sceHidKeyboardEnumerate(&keyboard_hid_handle, 1);
+}
+
+void 
+VITA_PollKeyboard(void)
+{
+    // We skip polling keyboard if no window is created
+    if (Vita_Window == NULL)
+        return;
+
+    if (keyboard_hid_handle > 0)
+    {
+        int numReports = sceHidKeyboardRead(keyboard_hid_handle, (SceHidKeyboardReport**)&k_reports, SCE_HID_MAX_REPORT);
+
+        if (numReports < 0) {
+            keyboard_hid_handle = 0;
+        }
+        else if (numReports) {
+            // Numlock and Capslock state changes only on a SDL_PRESSED event
+            // The k_report only reports the state of the LED
+            if (k_reports[numReports - 1].modifiers[1] & 0x1) {
+                if (!(locks & 0x1)) {
+                    SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_NUMLOCKCLEAR);
+                    locks |= 0x1;
+                }
+            }
+            else {
+                if (locks & 0x1) {
+                    SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_NUMLOCKCLEAR);
+                    SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_NUMLOCKCLEAR);
+                    SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_NUMLOCKCLEAR);
+                    locks &= ~0x1;
+                }
+            }
+
+            if (k_reports[numReports - 1].modifiers[1] & 0x2) {
+                if (!(locks & 0x2)) {
+                    SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_CAPSLOCK);
+                    locks |= 0x2;
+                }
+            }
+            else {
+                if (locks & 0x2) {
+                    SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_CAPSLOCK);
+                    SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_CAPSLOCK);
+                    SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_CAPSLOCK);
+                    locks &= ~0x2;
+                }
+            }
+
+            if (k_reports[numReports - 1].modifiers[1] & 0x4) {
+                if (!(locks & 0x4)) {
+                    SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_SCROLLLOCK);
+                    locks |= 0x4;
+                }
+            }
+            else {
+                if (locks & 0x4) {
+                    SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_SCROLLLOCK);
+                    locks &= ~0x4;
+                }
+            }
+
+            {
+                Uint8 changed_modifiers = k_reports[numReports - 1].modifiers[0] ^ prev_modifiers;
+
+                if (changed_modifiers & 0x01) {
+                    if (prev_modifiers & 0x01) {
+                        SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_LCTRL);
+                    }
+                    else {
+                        SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_LCTRL);
+                    }
+                }
+                if (changed_modifiers & 0x02) {
+                    if (prev_modifiers & 0x02) {
+                        SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_LSHIFT);
+                    }
+                else {
+                        SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_LSHIFT);
+                    }
+                }
+                if (changed_modifiers & 0x04) {
+                    if (prev_modifiers & 0x04) {
+                        SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_LALT);
+                    }
+                    else {
+                        SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_LALT);
+                    }
+                }
+                if (changed_modifiers & 0x08) {
+                    if (prev_modifiers & 0x08) {
+                        SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_LGUI);
+                    }
+                    else {
+                        SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_LGUI);
+                    }
+                }
+                if (changed_modifiers & 0x10) {
+                    if (prev_modifiers & 0x10) {
+                        SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_RCTRL);
+                    }
+                    else {
+                        SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_RCTRL);
+                    }
+            }
+                if (changed_modifiers & 0x20) {
+                    if (prev_modifiers & 0x20) {
+                        SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_RSHIFT);
+                    }
+                    else {
+                        SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_RSHIFT);
+                    }
+                }
+                if (changed_modifiers & 0x40) {
+                    if (prev_modifiers & 0x40) {
+                        SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_RALT);
+                    }
+                    else {
+                        SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_RALT);
+                    }
+                }
+                if (changed_modifiers & 0x80) {
+                    if (prev_modifiers & 0x80) {
+                        SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_RGUI);
+                    }
+                    else {
+                        SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_RGUI);
+                    }
+                }
+            }
+
+            prev_modifiers = k_reports[numReports - 1].modifiers[0];
+
+            for (int i = 0; i < 6; i++) {
+
+                int keyCode = k_reports[numReports - 1].keycodes[i];
+
+                if (keyCode != prev_keys[i]) {
+
+                    if (prev_keys[i]) {
+                        SDL_SendKeyboardKey(SDL_RELEASED, prev_keys[i]);
+                    }
+                    if (keyCode) {
+                        SDL_SendKeyboardKey(SDL_PRESSED, keyCode);
+                    }
+                    prev_keys[i] = keyCode;
+                }
+            }
+        }
+    }
+}
+
+#endif /* SDL_VIDEO_DRIVER_VITA */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/vita/SDL_vitakeyboard.h b/Engine/lib/sdl/src/video/vita/SDL_vitakeyboard.h
new file mode 100644
index 000000000..419cba7a3
--- /dev/null
+++ b/Engine/lib/sdl/src/video/vita/SDL_vitakeyboard.h
@@ -0,0 +1,33 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef _SDL_vitakeyboard_h
+#define _SDL_vitakeyboard_h
+
+#include "../../SDL_internal.h"
+
+/* Keyboard functions */
+extern void VITA_InitKeyboard(void);
+extern void VITA_PollKeyboard(void);
+
+#endif /* _SDL_vitakeyboard_h */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/vita/SDL_vitamessagebox.c b/Engine/lib/sdl/src/video/vita/SDL_vitamessagebox.c
new file mode 100644
index 000000000..492113986
--- /dev/null
+++ b/Engine/lib/sdl/src/video/vita/SDL_vitamessagebox.c
@@ -0,0 +1,150 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if SDL_VIDEO_DRIVER_VITA
+
+#include "SDL_vitavideo.h"
+#include "SDL_vitamessagebox.h"
+#include <psp2/message_dialog.h>
+
+#if SDL_VIDEO_RENDER_VITA_GXM
+#include "../../render/vitagxm/SDL_render_vita_gxm_tools.h"
+#endif /* SDL_VIDEO_RENDER_VITA_GXM */
+
+int VITA_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid)
+{
+#if SDL_VIDEO_RENDER_VITA_GXM
+    SceMsgDialogParam param;
+    SceMsgDialogUserMessageParam msgParam;
+    SceMsgDialogButtonsParam buttonParam;
+    SceDisplayFrameBuf dispparam;
+    char message[512];
+
+    SceMsgDialogResult dialog_result;
+    SceCommonDialogErrorCode init_result;
+    SDL_bool setup_minimal_gxm = SDL_FALSE;
+
+    if (messageboxdata->numbuttons > 3)
+    {
+        return -1;
+    }
+
+    SDL_zero(param);
+    sceMsgDialogParamInit(&param);
+    param.mode = SCE_MSG_DIALOG_MODE_USER_MSG;
+
+    SDL_zero(msgParam);
+    SDL_snprintf(message, sizeof(message), "%s\r\n\r\n%s", messageboxdata->title, messageboxdata->message);
+
+    msgParam.msg = (const SceChar8*)message;
+    SDL_zero(buttonParam);
+
+    if (messageboxdata->numbuttons == 3)
+    {
+        msgParam.buttonType = SCE_MSG_DIALOG_BUTTON_TYPE_3BUTTONS;
+        msgParam.buttonParam = &buttonParam;
+        buttonParam.msg1 = messageboxdata->buttons[0].text;
+        buttonParam.msg2 = messageboxdata->buttons[1].text;
+        buttonParam.msg3 = messageboxdata->buttons[2].text;
+    }
+    else if (messageboxdata->numbuttons == 2)
+    {
+        msgParam.buttonType = SCE_MSG_DIALOG_BUTTON_TYPE_YESNO;
+    }
+    else if (messageboxdata->numbuttons == 1)
+    {
+        msgParam.buttonType = SCE_MSG_DIALOG_BUTTON_TYPE_OK;
+    }
+    param.userMsgParam = &msgParam;
+
+    dispparam.size = sizeof(dispparam);
+
+    init_result = sceMsgDialogInit(&param);
+
+    // Setup display if it hasn't been initialized before
+    if (init_result == SCE_COMMON_DIALOG_ERROR_GXM_IS_UNINITIALIZED)
+    {
+        gxm_minimal_init_for_common_dialog();
+        init_result = sceMsgDialogInit(&param);
+        setup_minimal_gxm = SDL_TRUE;
+    }
+
+    gxm_init_for_common_dialog();
+
+    if (init_result >= 0)
+    {
+        while (sceMsgDialogGetStatus() == SCE_COMMON_DIALOG_STATUS_RUNNING)
+        {
+            gxm_swap_for_common_dialog();
+        }
+        SDL_zero(dialog_result);
+        sceMsgDialogGetResult(&dialog_result);
+
+        if (dialog_result.buttonId == SCE_MSG_DIALOG_BUTTON_ID_BUTTON1)
+        {
+            *buttonid = messageboxdata->buttons[0].buttonid;
+        }
+        else if (dialog_result.buttonId == SCE_MSG_DIALOG_BUTTON_ID_BUTTON2)
+        {
+            *buttonid = messageboxdata->buttons[1].buttonid;
+        }
+        else if (dialog_result.buttonId == SCE_MSG_DIALOG_BUTTON_ID_BUTTON3)
+        {
+            *buttonid = messageboxdata->buttons[2].buttonid;
+        }
+        else if (dialog_result.buttonId == SCE_MSG_DIALOG_BUTTON_ID_YES)
+        {
+            *buttonid = messageboxdata->buttons[0].buttonid;
+        }
+        else if (dialog_result.buttonId == SCE_MSG_DIALOG_BUTTON_ID_NO)
+        {
+            *buttonid = messageboxdata->buttons[1].buttonid;
+        }
+        else if (dialog_result.buttonId == SCE_MSG_DIALOG_BUTTON_ID_OK)
+        {
+            *buttonid = messageboxdata->buttons[0].buttonid;
+        }
+        sceMsgDialogTerm();
+    }
+    else
+    {
+        return -1;
+    }
+
+    gxm_term_for_common_dialog();
+
+    if (setup_minimal_gxm)
+    {
+        gxm_minimal_term_for_common_dialog();
+    }
+
+    return 0;
+#else
+    (void)messageboxdata;
+    (void)buttonid;
+    return -1;
+#endif
+}
+
+#endif /* SDL_VIDEO_DRIVER_VITA */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/vita/SDL_vitamessagebox.h b/Engine/lib/sdl/src/video/vita/SDL_vitamessagebox.h
new file mode 100644
index 000000000..445636010
--- /dev/null
+++ b/Engine/lib/sdl/src/video/vita/SDL_vitamessagebox.h
@@ -0,0 +1,33 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_vitamessagebox_h_
+#define SDL_vitamessagebox_h_
+
+#if SDL_VIDEO_DRIVER_VITA
+
+extern int VITA_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid);
+
+#endif /* SDL_VIDEO_DRIVER_VITA */
+
+#endif /* SDL_vitamessagebox_h_ */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/vita/SDL_vitamouse.c b/Engine/lib/sdl/src/video/vita/SDL_vitamouse.c
new file mode 100644
index 000000000..398a19483
--- /dev/null
+++ b/Engine/lib/sdl/src/video/vita/SDL_vitamouse.c
@@ -0,0 +1,94 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if SDL_VIDEO_DRIVER_VITA
+
+#include <psp2/kernel/processmgr.h>
+#include <psp2/ctrl.h>
+#include <psp2/hid.h>
+
+#include "SDL_events.h"
+#include "SDL_log.h"
+#include "SDL_mouse.h"
+#include "SDL_vitavideo.h"
+#include "SDL_vitamouse_c.h"
+#include "../../events/SDL_mouse_c.h"
+
+SceHidMouseReport m_reports[SCE_HID_MAX_REPORT];
+int mouse_hid_handle = 0;
+Uint8 prev_buttons = 0;
+
+void 
+VITA_InitMouse(void)
+{
+    sceHidMouseEnumerate(&mouse_hid_handle, 1);
+}
+
+void 
+VITA_PollMouse(void)
+{
+    // We skip polling mouse if no window is created
+    if (Vita_Window == NULL)
+        return;
+
+    if (mouse_hid_handle > 0)
+    {
+        int numReports = sceHidMouseRead(mouse_hid_handle, (SceHidMouseReport**)&m_reports, SCE_HID_MAX_REPORT);
+        if (numReports > 0)
+        {
+            for (int i = 0; i <= numReports - 1; i++)
+            {
+                Uint8 changed_buttons = m_reports[i].buttons ^ prev_buttons;
+
+                if (changed_buttons & 0x1) {
+                    if (prev_buttons & 0x1)
+                        SDL_SendMouseButton(Vita_Window, 0, SDL_RELEASED, SDL_BUTTON_LEFT);
+                    else
+                        SDL_SendMouseButton(Vita_Window, 0, SDL_PRESSED, SDL_BUTTON_LEFT);
+                }
+                if (changed_buttons & 0x2) {
+                    if (prev_buttons & 0x2)
+                        SDL_SendMouseButton(Vita_Window, 0, SDL_RELEASED, SDL_BUTTON_RIGHT);
+                    else
+                        SDL_SendMouseButton(Vita_Window, 0, SDL_PRESSED, SDL_BUTTON_RIGHT);
+                }
+                if (changed_buttons & 0x4) {
+                    if (prev_buttons & 0x4)
+                        SDL_SendMouseButton(Vita_Window, 0, SDL_RELEASED, SDL_BUTTON_MIDDLE);
+                    else
+                        SDL_SendMouseButton(Vita_Window, 0, SDL_PRESSED, SDL_BUTTON_MIDDLE);
+                }
+
+                prev_buttons = m_reports[i].buttons;
+
+                if (m_reports[i].rel_x || m_reports[i].rel_y)
+                {
+                    SDL_SendMouseMotion(Vita_Window, 0, 1, m_reports[i].rel_x, m_reports[i].rel_y);
+                }
+            }
+        }
+    }
+}
+
+#endif /* SDL_VIDEO_DRIVER_VITA */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/vita/SDL_vitamouse_c.h b/Engine/lib/sdl/src/video/vita/SDL_vitamouse_c.h
new file mode 100644
index 000000000..3549da102
--- /dev/null
+++ b/Engine/lib/sdl/src/video/vita/SDL_vitamouse_c.h
@@ -0,0 +1,33 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef _SDL_vitamouse_h
+#define _SDL_vitamouse_h
+
+#include "../../SDL_internal.h"
+
+/* mouse functions */
+extern void VITA_InitMouse(void);
+extern void VITA_PollMouse(void);
+
+#endif /* _SDL_vitamouse_h */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/vita/SDL_vitatouch.c b/Engine/lib/sdl/src/video/vita/SDL_vitatouch.c
new file mode 100644
index 000000000..43a3ecbd2
--- /dev/null
+++ b/Engine/lib/sdl/src/video/vita/SDL_vitatouch.c
@@ -0,0 +1,194 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if SDL_VIDEO_DRIVER_VITA
+
+#include <psp2/kernel/processmgr.h>
+#include <psp2/touch.h>
+
+#include "SDL_events.h"
+#include "SDL_log.h"
+#include "SDL_vitavideo.h"
+#include "SDL_vitatouch.h"
+#include "../../events/SDL_mouse_c.h"
+#include "../../events/SDL_touch_c.h"
+
+SceTouchData touch_old[SCE_TOUCH_PORT_MAX_NUM];
+SceTouchData touch[SCE_TOUCH_PORT_MAX_NUM];
+
+SDL_FRect area_info[SCE_TOUCH_PORT_MAX_NUM];
+
+struct{
+    float min;
+    float range;
+} force_info[SCE_TOUCH_PORT_MAX_NUM];
+
+char* disableFrontPoll = NULL;
+char* disableBackPoll = NULL;
+
+void 
+VITA_InitTouch(void)
+{
+    disableFrontPoll = SDL_getenv("VITA_DISABLE_TOUCH_FRONT");
+    disableBackPoll = SDL_getenv("VITA_DISABLE_TOUCH_BACK");
+
+    sceTouchSetSamplingState(SCE_TOUCH_PORT_FRONT, SCE_TOUCH_SAMPLING_STATE_START);
+    sceTouchSetSamplingState(SCE_TOUCH_PORT_BACK, SCE_TOUCH_SAMPLING_STATE_START);
+    sceTouchEnableTouchForce(SCE_TOUCH_PORT_FRONT);
+    sceTouchEnableTouchForce(SCE_TOUCH_PORT_BACK);
+
+    for(int port = 0; port < SCE_TOUCH_PORT_MAX_NUM; port++) {
+        SceTouchPanelInfo panelinfo;
+        sceTouchGetPanelInfo(port, &panelinfo);
+
+        area_info[port].x  = (float)panelinfo.minAaX;
+        area_info[port].y  = (float)panelinfo.minAaY;
+        area_info[port].w  = (float)(panelinfo.maxAaX - panelinfo.minAaX);
+        area_info[port].h  = (float)(panelinfo.maxAaY - panelinfo.minAaY);
+
+        force_info[port].min = (float)panelinfo.minForce;
+        force_info[port].range = (float)(panelinfo.maxForce - panelinfo.minForce);
+    }
+
+    // Support passing both front and back touch devices in events
+    SDL_AddTouch((SDL_TouchID)0, SDL_TOUCH_DEVICE_DIRECT, "Front");
+    SDL_AddTouch((SDL_TouchID)1, SDL_TOUCH_DEVICE_INDIRECT_ABSOLUTE,  "Back");
+}
+
+void 
+VITA_QuitTouch(void){
+    sceTouchDisableTouchForce(SCE_TOUCH_PORT_FRONT);
+    sceTouchDisableTouchForce(SCE_TOUCH_PORT_BACK);
+}
+
+void 
+VITA_PollTouch(void)
+{
+    SDL_FingerID finger_id = 0;
+    int port;
+
+    // We skip polling touch if no window is created
+    if (Vita_Window == NULL)
+        return;
+
+    SDL_memcpy(touch_old, touch, sizeof(touch_old));
+
+    for(port = 0; port < SCE_TOUCH_PORT_MAX_NUM; port++) {
+        /** Skip polling of Touch Device if environment variable is set **/
+        if (((port == 0) && disableFrontPoll) || ((port == 1) && disableBackPoll)) {
+            continue;
+        }
+        sceTouchPeek(port, &touch[port], 1);
+        if (touch[port].reportNum > 0) {
+            for (int i = 0; i < touch[port].reportNum; i++)
+            {
+                // adjust coordinates and forces to return normalized values
+                // for the front, screen area is used as a reference (for direct touch)
+                // e.g. touch_x = 1.0 corresponds to screen_x = 960
+                // for the back panel, the active touch area is used as reference
+                float x = 0;
+                float y = 0;
+                float force = (touch[port].report[i].force - force_info[port].min) / force_info[port].range;
+                int finger_down = 0;
+
+                if (touch_old[port].reportNum > 0) {
+                    for (int j = 0; j < touch_old[port].reportNum; j++) {
+                        if (touch[port].report[i].id == touch_old[port].report[j].id ) {
+                            finger_down = 1;
+                        }
+                    }
+                }
+                
+                VITA_ConvertTouchXYToSDLXY(&x, &y, touch[port].report[i].x, touch[port].report[i].y, port);
+                finger_id = (SDL_FingerID) touch[port].report[i].id;
+
+                // Skip if finger was already previously down
+                if(!finger_down) {
+                    // Send an initial touch
+                    SDL_SendTouch((SDL_TouchID)port,
+                        finger_id,
+                        Vita_Window,
+                        SDL_TRUE,
+                        x,
+                        y,
+                        force);
+                }
+
+                // Always send the motion
+                SDL_SendTouchMotion((SDL_TouchID)port,
+                    finger_id,
+                    Vita_Window,
+                    x,
+                    y,
+                    force);
+            }
+        }
+
+        // some fingers might have been let go
+        if (touch_old[port].reportNum > 0) {
+            for (int i = 0; i < touch_old[port].reportNum; i++) {
+                int finger_up = 1;
+                if (touch[port].reportNum > 0) {
+                    for (int j = 0; j < touch[port].reportNum; j++) {
+                        if (touch[port].report[j].id == touch_old[port].report[i].id ) {
+                            finger_up = 0;
+                        }
+                    }
+                }
+                if (finger_up == 1) {
+                    float x = 0;
+                    float y = 0;
+                    float force = (touch_old[port].report[i].force - force_info[port].min) / force_info[port].range;
+                    VITA_ConvertTouchXYToSDLXY(&x, &y, touch_old[port].report[i].x, touch_old[port].report[i].y, port);
+                    finger_id = (SDL_FingerID) touch_old[port].report[i].id;
+                    // Finger released from screen
+                    SDL_SendTouch((SDL_TouchID)port,
+                        finger_id,
+                        Vita_Window,
+                        SDL_FALSE,
+                        x,
+                        y,
+                        force);
+                }
+            }
+        }
+    }
+}
+
+void VITA_ConvertTouchXYToSDLXY(float *sdl_x, float *sdl_y, int vita_x, int vita_y, int port) {
+    float x = (vita_x - area_info[port].x) / area_info[port].w;
+    float y = (vita_y - area_info[port].y) / area_info[port].h;
+
+    x = SDL_max(x, 0.0);
+    x = SDL_min(x, 1.0);
+
+    y = SDL_max(y, 0.0);
+    y = SDL_min(y, 1.0);
+
+    *sdl_x = x;
+    *sdl_y = y;
+}
+
+
+#endif /* SDL_VIDEO_DRIVER_VITA */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/vita/SDL_vitatouch.h b/Engine/lib/sdl/src/video/vita/SDL_vitatouch.h
new file mode 100644
index 000000000..02f31bc42
--- /dev/null
+++ b/Engine/lib/sdl/src/video/vita/SDL_vitatouch.h
@@ -0,0 +1,35 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef _SDL_vitatouch_h
+#define _SDL_vitatouch_h
+
+#include "../../SDL_internal.h"
+
+/* Touch functions */
+extern void VITA_InitTouch(void);
+extern void VITA_QuitTouch(void);
+extern void VITA_PollTouch(void);
+void VITA_ConvertTouchXYToSDLXY(float *sdl_x, float *sdl_y, int vita_x, int vita_y, int port);
+
+#endif /* _SDL_vitatouch_h */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/vita/SDL_vitavideo.c b/Engine/lib/sdl/src/video/vita/SDL_vitavideo.c
new file mode 100644
index 000000000..778a87073
--- /dev/null
+++ b/Engine/lib/sdl/src/video/vita/SDL_vitavideo.c
@@ -0,0 +1,601 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "../../SDL_internal.h"
+
+#if SDL_VIDEO_DRIVER_VITA
+
+/* SDL internals */
+#include "../SDL_sysvideo.h"
+#include "SDL_version.h"
+#include "SDL_syswm.h"
+#include "SDL_loadso.h"
+#include "SDL_events.h"
+#include "../../events/SDL_mouse_c.h"
+#include "../../events/SDL_keyboard_c.h"
+
+/* VITA declarations */
+#include <psp2/kernel/processmgr.h>
+#include "SDL_vitavideo.h"
+#include "SDL_vitatouch.h"
+#include "SDL_vitakeyboard.h"
+#include "SDL_vitamouse_c.h"
+#include "SDL_vitaframebuffer.h"
+
+#if defined(SDL_VIDEO_VITA_PIB)
+  #include "SDL_vitagl_c.h"
+#elif defined(SDL_VIDEO_VITA_PVR)
+  #include "SDL_vitagl_pvr_c.h"
+  #include "../SDL_egl_c.h"
+  #define VITA_GL_GetProcAddress SDL_EGL_GetProcAddress
+  #define VITA_GL_UnloadLibrary SDL_EGL_UnloadLibrary
+  #define VITA_GL_SetSwapInterval SDL_EGL_SetSwapInterval
+  #define VITA_GL_GetSwapInterval SDL_EGL_GetSwapInterval
+  #define VITA_GL_DeleteContext SDL_EGL_DeleteContext
+#endif
+
+SDL_Window *Vita_Window;
+
+static void
+VITA_Destroy(SDL_VideoDevice * device)
+{
+/*    SDL_VideoData *phdata = (SDL_VideoData *) device->driverdata; */
+
+    SDL_free(device->driverdata);
+    SDL_free(device);
+//    if (device->driverdata != NULL) {
+//        device->driverdata = NULL;
+//    }
+}
+
+static SDL_VideoDevice *
+VITA_Create()
+{
+    SDL_VideoDevice *device;
+    SDL_VideoData *phdata;
+#if SDL_VIDEO_VITA_PIB
+    SDL_GLDriverData *gldata;
+#endif
+    /* Initialize SDL_VideoDevice structure */
+    device = (SDL_VideoDevice *) SDL_calloc(1, sizeof(SDL_VideoDevice));
+    if (device == NULL) {
+        SDL_OutOfMemory();
+        return NULL;
+    }
+
+    /* Initialize internal VITA specific data */
+    phdata = (SDL_VideoData *) SDL_calloc(1, sizeof(SDL_VideoData));
+    if (phdata == NULL) {
+        SDL_OutOfMemory();
+        SDL_free(device);
+        return NULL;
+    }
+#if SDL_VIDEO_VITA_PIB
+
+    gldata = (SDL_GLDriverData *) SDL_calloc(1, sizeof(SDL_GLDriverData));
+    if (gldata == NULL) {
+        SDL_OutOfMemory();
+        SDL_free(device);
+        SDL_free(phdata);
+        return NULL;
+    }
+    device->gl_data = gldata;
+    phdata->egl_initialized = SDL_TRUE;
+#endif
+    phdata->ime_active = SDL_FALSE;
+
+    device->driverdata = phdata;
+
+    /* Setup amount of available displays and current display */
+    device->num_displays = 0;
+
+    /* Set device free function */
+    device->free = VITA_Destroy;
+
+    /* Setup all functions which we can handle */
+    device->VideoInit = VITA_VideoInit;
+    device->VideoQuit = VITA_VideoQuit;
+    device->GetDisplayModes = VITA_GetDisplayModes;
+    device->SetDisplayMode = VITA_SetDisplayMode;
+    device->CreateSDLWindow = VITA_CreateWindow;
+    device->CreateSDLWindowFrom = VITA_CreateWindowFrom;
+    device->SetWindowTitle = VITA_SetWindowTitle;
+    device->SetWindowIcon = VITA_SetWindowIcon;
+    device->SetWindowPosition = VITA_SetWindowPosition;
+    device->SetWindowSize = VITA_SetWindowSize;
+    device->ShowWindow = VITA_ShowWindow;
+    device->HideWindow = VITA_HideWindow;
+    device->RaiseWindow = VITA_RaiseWindow;
+    device->MaximizeWindow = VITA_MaximizeWindow;
+    device->MinimizeWindow = VITA_MinimizeWindow;
+    device->RestoreWindow = VITA_RestoreWindow;
+    device->SetWindowMouseGrab = VITA_SetWindowGrab;
+    device->SetWindowKeyboardGrab = VITA_SetWindowGrab;
+    device->DestroyWindow = VITA_DestroyWindow;
+    device->GetWindowWMInfo = VITA_GetWindowWMInfo;
+
+/*
+    // Disabled, causes issues on high-framerate updates. SDL still emulates this.
+    device->CreateWindowFramebuffer = VITA_CreateWindowFramebuffer;
+    device->UpdateWindowFramebuffer = VITA_UpdateWindowFramebuffer;
+    device->DestroyWindowFramebuffer = VITA_DestroyWindowFramebuffer;
+*/
+
+#if defined(SDL_VIDEO_VITA_PIB) || defined(SDL_VIDEO_VITA_PVR)
+    device->GL_LoadLibrary = VITA_GL_LoadLibrary;
+    device->GL_GetProcAddress = VITA_GL_GetProcAddress;
+    device->GL_UnloadLibrary = VITA_GL_UnloadLibrary;
+    device->GL_CreateContext = VITA_GL_CreateContext;
+    device->GL_MakeCurrent = VITA_GL_MakeCurrent;
+    device->GL_SetSwapInterval = VITA_GL_SetSwapInterval;
+    device->GL_GetSwapInterval = VITA_GL_GetSwapInterval;
+    device->GL_SwapWindow = VITA_GL_SwapWindow;
+    device->GL_DeleteContext = VITA_GL_DeleteContext;
+#endif
+
+    device->HasScreenKeyboardSupport = VITA_HasScreenKeyboardSupport;
+    device->ShowScreenKeyboard = VITA_ShowScreenKeyboard;
+    device->HideScreenKeyboard = VITA_HideScreenKeyboard;
+    device->IsScreenKeyboardShown = VITA_IsScreenKeyboardShown;
+
+    device->PumpEvents = VITA_PumpEvents;
+
+    return device;
+}
+
+VideoBootStrap VITA_bootstrap = {
+    "VITA",
+    "VITA Video Driver",
+    VITA_Create
+};
+
+/*****************************************************************************/
+/* SDL Video and Display initialization/handling functions                   */
+/*****************************************************************************/
+int
+VITA_VideoInit(_THIS)
+{
+    SDL_VideoDisplay display;
+    SDL_DisplayMode current_mode;
+#if defined(SDL_VIDEO_VITA_PVR)
+    char* res = SDL_getenv("VITA_RESOLUTION");
+#endif
+    SDL_zero(current_mode);
+
+#if defined(SDL_VIDEO_VITA_PVR)
+    if (res) {
+        /* 1088i for PSTV (Or Sharpscale) */
+        if (!SDL_strncmp(res, "1080", 4)) {
+            current_mode.w = 1920;
+            current_mode.h = 1088;
+        }
+        /* 725p for PSTV (Or Sharpscale) */
+        else if (!SDL_strncmp(res, "720", 3)) {
+            current_mode.w = 1280;
+            current_mode.h = 725;
+        }
+    }
+    /* 544p */
+    else {
+#endif
+        current_mode.w = 960;
+        current_mode.h = 544;
+#if defined(SDL_VIDEO_VITA_PVR)
+    }
+#endif
+
+    current_mode.refresh_rate = 60;
+    /* 32 bpp for default */
+    current_mode.format = SDL_PIXELFORMAT_ABGR8888;
+
+    current_mode.driverdata = NULL;
+
+    SDL_zero(display);
+    display.desktop_mode = current_mode;
+    display.current_mode = current_mode;
+    display.driverdata = NULL;
+
+    SDL_AddVideoDisplay(&display, SDL_FALSE);
+    VITA_InitTouch();
+    VITA_InitKeyboard();
+    VITA_InitMouse();
+
+    return 1;
+}
+
+void
+VITA_VideoQuit(_THIS)
+{
+    VITA_QuitTouch();
+}
+
+void
+VITA_GetDisplayModes(_THIS, SDL_VideoDisplay * display)
+{
+    SDL_AddDisplayMode(display, &display->current_mode);
+}
+
+int
+VITA_SetDisplayMode(_THIS, SDL_VideoDisplay * display, SDL_DisplayMode * mode)
+{
+    return 0;
+}
+
+int
+VITA_CreateWindow(_THIS, SDL_Window * window)
+{
+    SDL_WindowData *wdata;
+#if defined(SDL_VIDEO_VITA_PVR)
+    Psp2NativeWindow win;
+#endif
+
+    /* Allocate window internal data */
+    wdata = (SDL_WindowData *) SDL_calloc(1, sizeof(SDL_WindowData));
+    if (wdata == NULL) {
+        return SDL_OutOfMemory();
+    }
+
+    /* Setup driver data for this window */
+    window->driverdata = wdata;
+
+    // Vita can only have one window
+    if (Vita_Window != NULL)
+    {
+        return SDL_SetError("Only one window supported");
+    }
+
+    Vita_Window = window;
+
+#if defined(SDL_VIDEO_VITA_PVR)
+    win.type = PSP2_DRAWABLE_TYPE_WINDOW;
+    win.numFlipBuffers = 2;
+    win.flipChainThrdAffinity = 0x20000;
+
+    /* 1088i for PSTV (Or Sharpscale) */
+    if (window->w == 1920) {
+        win.windowSize = PSP2_WINDOW_1920X1088;
+    }
+    /* 725p for PSTV (Or Sharpscale) */
+    else if (window->w == 1280) {
+        win.windowSize = PSP2_WINDOW_1280X725;
+    }
+    /* 544p */
+    else {
+        win.windowSize = PSP2_WINDOW_960X544;
+    }
+    if ((window->flags & SDL_WINDOW_OPENGL) != 0) {
+      wdata->egl_surface = SDL_EGL_CreateSurface(_this, &win);
+
+      if (wdata->egl_surface == EGL_NO_SURFACE) {
+          return SDL_SetError("Could not create GLES window surface");
+      }
+    }
+#endif
+
+    // fix input, we need to find a better way
+    SDL_SetKeyboardFocus(window);
+
+    /* Window has been successfully created */
+    return 0;
+}
+
+int
+VITA_CreateWindowFrom(_THIS, SDL_Window * window, const void *data)
+{
+    return -1;
+}
+
+void
+VITA_SetWindowTitle(_THIS, SDL_Window * window)
+{
+}
+void
+VITA_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon)
+{
+}
+void
+VITA_SetWindowPosition(_THIS, SDL_Window * window)
+{
+}
+void
+VITA_SetWindowSize(_THIS, SDL_Window * window)
+{
+}
+void
+VITA_ShowWindow(_THIS, SDL_Window * window)
+{
+}
+void
+VITA_HideWindow(_THIS, SDL_Window * window)
+{
+}
+void
+VITA_RaiseWindow(_THIS, SDL_Window * window)
+{
+}
+void
+VITA_MaximizeWindow(_THIS, SDL_Window * window)
+{
+}
+void
+VITA_MinimizeWindow(_THIS, SDL_Window * window)
+{
+}
+void
+VITA_RestoreWindow(_THIS, SDL_Window * window)
+{
+}
+void
+VITA_SetWindowGrab(_THIS, SDL_Window * window, SDL_bool grabbed)
+{
+}
+
+void
+VITA_DestroyWindow(_THIS, SDL_Window * window)
+{
+//    SDL_VideoData *videodata = (SDL_VideoData *)_this->driverdata;
+    SDL_WindowData *data;
+
+    data = window->driverdata;
+    if (data) {
+        // TODO: should we destroy egl context? No one sane should recreate ogl window as non-ogl
+        SDL_free(data);
+    }
+
+    window->driverdata = NULL;
+    Vita_Window = NULL;
+}
+
+/*****************************************************************************/
+/* SDL Window Manager function                                               */
+/*****************************************************************************/
+SDL_bool
+VITA_GetWindowWMInfo(_THIS, SDL_Window * window, struct SDL_SysWMinfo *info)
+{
+    if (info->version.major <= SDL_MAJOR_VERSION) {
+        return SDL_TRUE;
+    } else {
+        SDL_SetError("application not compiled with SDL %d.%d\n",
+                     SDL_MAJOR_VERSION, SDL_MINOR_VERSION);
+        return SDL_FALSE;
+    }
+
+    /* Failed to get window manager information */
+    return SDL_FALSE;
+}
+
+SDL_bool VITA_HasScreenKeyboardSupport(_THIS)
+{
+    return SDL_TRUE;
+}
+
+#if !defined(SCE_IME_LANGUAGE_ENGLISH_US)
+#define SCE_IME_LANGUAGE_ENGLISH_US SCE_IME_LANGUAGE_ENGLISH
+#endif
+
+static void utf16_to_utf8(const uint16_t *src, uint8_t *dst) {
+  int i;
+  for (i = 0; src[i]; i++) {
+    if ((src[i] & 0xFF80) == 0) {
+      *(dst++) = src[i] & 0xFF;
+    } else if((src[i] & 0xF800) == 0) {
+      *(dst++) = ((src[i] >> 6) & 0xFF) | 0xC0;
+      *(dst++) = (src[i] & 0x3F) | 0x80;
+    } else if((src[i] & 0xFC00) == 0xD800 && (src[i + 1] & 0xFC00) == 0xDC00) {
+      *(dst++) = (((src[i] + 64) >> 8) & 0x3) | 0xF0;
+      *(dst++) = (((src[i] >> 2) + 16) & 0x3F) | 0x80;
+      *(dst++) = ((src[i] >> 4) & 0x30) | 0x80 | ((src[i + 1] << 2) & 0xF);
+      *(dst++) = (src[i + 1] & 0x3F) | 0x80;
+      i += 1;
+    } else {
+      *(dst++) = ((src[i] >> 12) & 0xF) | 0xE0;
+      *(dst++) = ((src[i] >> 6) & 0x3F) | 0x80;
+      *(dst++) = (src[i] & 0x3F) | 0x80;
+    }
+  }
+
+  *dst = '\0';
+}
+
+#if defined (SDL_VIDEO_VITA_PVR)
+SceWChar16 libime_out[SCE_IME_MAX_PREEDIT_LENGTH + SCE_IME_MAX_TEXT_LENGTH + 1];
+char libime_initval[8] = { 1 };
+SceImeCaret caret_rev;
+
+void VITA_ImeEventHandler(void *arg, const SceImeEventData *e)
+{
+    SDL_VideoData *videodata = (SDL_VideoData *)arg;
+    SDL_Scancode scancode;
+    uint8_t utf8_buffer[SCE_IME_MAX_TEXT_LENGTH];
+    switch (e->id) {
+    case SCE_IME_EVENT_UPDATE_TEXT:
+        if (e->param.text.caretIndex == 0) {
+            SDL_SendKeyboardKeyAutoRelease(SDL_SCANCODE_BACKSPACE);
+            sceImeSetText((SceWChar16 *)libime_initval, 4);
+        }
+        else {
+            scancode = SDL_GetScancodeFromKey(*(SceWChar16 *)&libime_out[1]);
+            if (scancode == SDL_SCANCODE_SPACE) {
+                SDL_SendKeyboardKeyAutoRelease(SDL_SCANCODE_SPACE);
+            }
+            else {
+                utf16_to_utf8((SceWChar16 *)&libime_out[1], utf8_buffer);
+                SDL_SendKeyboardText((const char*)utf8_buffer);
+            }
+            SDL_memset(&caret_rev, 0, sizeof(SceImeCaret));
+            SDL_memset(libime_out, 0, ((SCE_IME_MAX_PREEDIT_LENGTH + SCE_IME_MAX_TEXT_LENGTH + 1) * sizeof(SceWChar16)));
+            caret_rev.index = 1;
+            sceImeSetCaret(&caret_rev);
+            sceImeSetText((SceWChar16 *)libime_initval, 4);
+        }
+        break;
+    case SCE_IME_EVENT_PRESS_ENTER:
+        SDL_SendKeyboardKeyAutoRelease(SDL_SCANCODE_RETURN);
+    case SCE_IME_EVENT_PRESS_CLOSE:
+        sceImeClose();
+        videodata->ime_active = SDL_FALSE;
+        break;
+    }
+}
+#endif
+
+void VITA_ShowScreenKeyboard(_THIS, SDL_Window *window)
+{
+    SDL_VideoData *videodata = (SDL_VideoData *)_this->driverdata;
+    SceInt32 res;
+
+#if defined(SDL_VIDEO_VITA_PVR)
+
+    SceUInt32 libime_work[SCE_IME_WORK_BUFFER_SIZE / sizeof(SceInt32)];
+    SceImeParam param;
+
+    sceImeParamInit(&param);
+
+    SDL_memset(libime_out, 0, ((SCE_IME_MAX_PREEDIT_LENGTH + SCE_IME_MAX_TEXT_LENGTH + 1) * sizeof(SceWChar16)));
+
+    param.supportedLanguages = SCE_IME_LANGUAGE_ENGLISH_US;
+    param.languagesForced = SCE_FALSE;
+    param.type = SCE_IME_TYPE_DEFAULT;
+    param.option = SCE_IME_OPTION_NO_ASSISTANCE;
+    param.inputTextBuffer = libime_out;
+    param.maxTextLength = SCE_IME_MAX_TEXT_LENGTH;
+    param.handler = VITA_ImeEventHandler;
+    param.filter = NULL;
+    param.initialText = (SceWChar16 *)libime_initval;
+    param.arg = videodata;
+    param.work = libime_work;
+
+    res = sceImeOpen(&param);
+    if (res < 0) {
+        SDL_SetError("Failed to init IME");
+        return;
+    }
+
+#else
+    SceWChar16 *title = u"";
+    SceWChar16 *text = u"";
+
+    SceImeDialogParam param;
+    sceImeDialogParamInit(&param);
+
+    param.supportedLanguages = 0;
+    param.languagesForced = SCE_FALSE;
+    param.type = SCE_IME_TYPE_DEFAULT;
+    param.option = 0;
+    param.textBoxMode = SCE_IME_DIALOG_TEXTBOX_MODE_WITH_CLEAR;
+    param.maxTextLength = SCE_IME_DIALOG_MAX_TEXT_LENGTH;
+
+    param.title = title;
+    param.initialText = text;
+    param.inputTextBuffer = videodata->ime_buffer;
+
+    res = sceImeDialogInit(&param);
+    if (res < 0) {
+        SDL_SetError("Failed to init IME dialog");
+        return;
+    }
+
+#endif
+
+    videodata->ime_active = SDL_TRUE;
+}
+
+void VITA_HideScreenKeyboard(_THIS, SDL_Window *window)
+{
+#if !defined(SDL_VIDEO_VITA_PVR)
+    SDL_VideoData *videodata = (SDL_VideoData *)_this->driverdata;
+
+    SceCommonDialogStatus dialogStatus = sceImeDialogGetStatus();
+
+    switch (dialogStatus) {
+        default:
+        case SCE_COMMON_DIALOG_STATUS_NONE:
+        case SCE_COMMON_DIALOG_STATUS_RUNNING:
+                break;
+        case SCE_COMMON_DIALOG_STATUS_FINISHED:
+                sceImeDialogTerm();
+                break;
+    }
+
+    videodata->ime_active = SDL_FALSE;
+#endif
+}
+
+SDL_bool VITA_IsScreenKeyboardShown(_THIS, SDL_Window *window)
+{
+#if defined(SDL_VIDEO_VITA_PVR)
+    SDL_VideoData *videodata = (SDL_VideoData *)_this->driverdata;
+    return videodata->ime_active;
+#else
+    SceCommonDialogStatus dialogStatus = sceImeDialogGetStatus();
+    return (dialogStatus == SCE_COMMON_DIALOG_STATUS_RUNNING);
+#endif
+}
+
+void VITA_PumpEvents(_THIS)
+{
+#if !defined(SDL_VIDEO_VITA_PVR)
+    SDL_VideoData *videodata = (SDL_VideoData *)_this->driverdata;
+#endif
+
+    if (_this->suspend_screensaver) {
+        // cancel all idle timers to prevent vita going to sleep
+        sceKernelPowerTick(SCE_KERNEL_POWER_TICK_DEFAULT);
+    }
+
+    VITA_PollTouch();
+    VITA_PollKeyboard();
+    VITA_PollMouse();
+
+#if !defined(SDL_VIDEO_VITA_PVR)
+    if (videodata->ime_active == SDL_TRUE) {
+        // update IME status. Terminate, if finished
+        SceCommonDialogStatus dialogStatus = sceImeDialogGetStatus();
+         if (dialogStatus == SCE_COMMON_DIALOG_STATUS_FINISHED) {
+            uint8_t utf8_buffer[SCE_IME_DIALOG_MAX_TEXT_LENGTH];
+
+            SceImeDialogResult result;
+            SDL_memset(&result, 0, sizeof(SceImeDialogResult));
+            sceImeDialogGetResult(&result);
+
+            // Convert UTF16 to UTF8
+            utf16_to_utf8(videodata->ime_buffer, utf8_buffer);
+
+            // Send SDL event
+            SDL_SendKeyboardText((const char*)utf8_buffer);
+
+            // Send enter key only on enter
+            if (result.button == SCE_IME_DIALOG_BUTTON_ENTER)
+                SDL_SendKeyboardKeyAutoRelease(SDL_SCANCODE_RETURN);
+
+            sceImeDialogTerm();
+
+            videodata->ime_active = SDL_FALSE;
+        }
+
+    }
+#endif
+}
+
+#endif /* SDL_VIDEO_DRIVER_VITA */
+
+/* vi: set ts=4 sw=4 expandtab: */
+
diff --git a/Engine/lib/sdl/src/video/vita/SDL_vitavideo.h b/Engine/lib/sdl/src/video/vita/SDL_vitavideo.h
new file mode 100644
index 000000000..04488dde3
--- /dev/null
+++ b/Engine/lib/sdl/src/video/vita/SDL_vitavideo.h
@@ -0,0 +1,115 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef _SDL_vitavideo_h
+#define _SDL_vitavideo_h
+
+#include "../../SDL_internal.h"
+#include "../SDL_sysvideo.h"
+#include "../SDL_egl_c.h"
+
+#include <psp2/types.h>
+#include <psp2/display.h>
+#include <psp2/ime_dialog.h>
+#include <psp2/sysmodule.h>
+
+typedef struct SDL_VideoData
+{
+    SDL_bool egl_initialized;   /* OpenGL device initialization status */
+    uint32_t egl_refcount;      /* OpenGL reference count              */
+
+    SceWChar16 ime_buffer[SCE_IME_DIALOG_MAX_TEXT_LENGTH];
+    SDL_bool ime_active;
+} SDL_VideoData;
+
+
+typedef struct SDL_DisplayData
+{
+
+} SDL_DisplayData;
+
+
+typedef struct SDL_WindowData
+{
+    SDL_bool uses_gles;
+    SceUID buffer_uid;
+    void* buffer;
+#if defined(SDL_VIDEO_VITA_PVR)
+    EGLSurface egl_surface;
+    EGLContext egl_context;
+#endif
+} SDL_WindowData;
+
+extern SDL_Window * Vita_Window;
+
+
+/****************************************************************************/
+/* SDL_VideoDevice functions declaration                                    */
+/****************************************************************************/
+
+/* Display and window functions */
+int VITA_VideoInit(_THIS);
+void VITA_VideoQuit(_THIS);
+void VITA_GetDisplayModes(_THIS, SDL_VideoDisplay * display);
+int VITA_SetDisplayMode(_THIS, SDL_VideoDisplay * display, SDL_DisplayMode * mode);
+int VITA_CreateWindow(_THIS, SDL_Window * window);
+int VITA_CreateWindowFrom(_THIS, SDL_Window * window, const void *data);
+void VITA_SetWindowTitle(_THIS, SDL_Window * window);
+void VITA_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon);
+void VITA_SetWindowPosition(_THIS, SDL_Window * window);
+void VITA_SetWindowSize(_THIS, SDL_Window * window);
+void VITA_ShowWindow(_THIS, SDL_Window * window);
+void VITA_HideWindow(_THIS, SDL_Window * window);
+void VITA_RaiseWindow(_THIS, SDL_Window * window);
+void VITA_MaximizeWindow(_THIS, SDL_Window * window);
+void VITA_MinimizeWindow(_THIS, SDL_Window * window);
+void VITA_RestoreWindow(_THIS, SDL_Window * window);
+void VITA_SetWindowGrab(_THIS, SDL_Window * window, SDL_bool grabbed);
+void VITA_DestroyWindow(_THIS, SDL_Window * window);
+
+/* Window manager function */
+SDL_bool VITA_GetWindowWMInfo(_THIS, SDL_Window * window,
+                             struct SDL_SysWMinfo *info);
+
+#if SDL_VIDEO_DRIVER_VITA
+/* OpenGL functions */
+int VITA_GL_LoadLibrary(_THIS, const char *path);
+void *VITA_GL_GetProcAddress(_THIS, const char *proc);
+void VITA_GL_UnloadLibrary(_THIS);
+SDL_GLContext VITA_GL_CreateContext(_THIS, SDL_Window * window);
+int VITA_GL_MakeCurrent(_THIS, SDL_Window * window, SDL_GLContext context);
+int VITA_GL_SetSwapInterval(_THIS, int interval);
+int VITA_GL_GetSwapInterval(_THIS);
+int VITA_GL_SwapWindow(_THIS, SDL_Window * window);
+void VITA_GL_DeleteContext(_THIS, SDL_GLContext context);
+#endif
+
+/* VITA on screen keyboard */
+SDL_bool VITA_HasScreenKeyboardSupport(_THIS);
+void VITA_ShowScreenKeyboard(_THIS, SDL_Window *window);
+void VITA_HideScreenKeyboard(_THIS, SDL_Window *window);
+SDL_bool VITA_IsScreenKeyboardShown(_THIS, SDL_Window *window);
+
+void VITA_PumpEvents(_THIS);
+
+#endif /* _SDL_pspvideo_h */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/vivante/SDL_vivanteopengles.c b/Engine/lib/sdl/src/video/vivante/SDL_vivanteopengles.c
index 308f7ee48..42888d6a8 100644
--- a/Engine/lib/sdl/src/video/vivante/SDL_vivanteopengles.c
+++ b/Engine/lib/sdl/src/video/vivante/SDL_vivanteopengles.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/vivante/SDL_vivanteopengles.h b/Engine/lib/sdl/src/video/vivante/SDL_vivanteopengles.h
index 6241eae2f..dce74ae6b 100644
--- a/Engine/lib/sdl/src/video/vivante/SDL_vivanteopengles.h
+++ b/Engine/lib/sdl/src/video/vivante/SDL_vivanteopengles.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/vivante/SDL_vivanteplatform.c b/Engine/lib/sdl/src/video/vivante/SDL_vivanteplatform.c
index f6f37cf51..36d6822b4 100644
--- a/Engine/lib/sdl/src/video/vivante/SDL_vivanteplatform.c
+++ b/Engine/lib/sdl/src/video/vivante/SDL_vivanteplatform.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/vivante/SDL_vivanteplatform.h b/Engine/lib/sdl/src/video/vivante/SDL_vivanteplatform.h
index 0f0e3f3c6..b1621d323 100644
--- a/Engine/lib/sdl/src/video/vivante/SDL_vivanteplatform.h
+++ b/Engine/lib/sdl/src/video/vivante/SDL_vivanteplatform.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/vivante/SDL_vivantevideo.c b/Engine/lib/sdl/src/video/vivante/SDL_vivantevideo.c
index bc6bb62c5..de2fdbfd1 100644
--- a/Engine/lib/sdl/src/video/vivante/SDL_vivantevideo.c
+++ b/Engine/lib/sdl/src/video/vivante/SDL_vivantevideo.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/vivante/SDL_vivantevideo.h b/Engine/lib/sdl/src/video/vivante/SDL_vivantevideo.h
index 8d59a1de3..ae4a8e142 100644
--- a/Engine/lib/sdl/src/video/vivante/SDL_vivantevideo.h
+++ b/Engine/lib/sdl/src/video/vivante/SDL_vivantevideo.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/vivante/SDL_vivantevulkan.c b/Engine/lib/sdl/src/video/vivante/SDL_vivantevulkan.c
index 7c86bc9d9..fe6a6b0ae 100644
--- a/Engine/lib/sdl/src/video/vivante/SDL_vivantevulkan.c
+++ b/Engine/lib/sdl/src/video/vivante/SDL_vivantevulkan.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/vivante/SDL_vivantevulkan.h b/Engine/lib/sdl/src/video/vivante/SDL_vivantevulkan.h
index 764ae2ec5..0be68fae7 100644
--- a/Engine/lib/sdl/src/video/vivante/SDL_vivantevulkan.h
+++ b/Engine/lib/sdl/src/video/vivante/SDL_vivantevulkan.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandclipboard.c b/Engine/lib/sdl/src/video/wayland/SDL_waylandclipboard.c
index e51f1bae4..e6315540e 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandclipboard.c
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandclipboard.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -24,32 +24,34 @@
 
 #include "SDL_waylanddatamanager.h"
 #include "SDL_waylandevents_c.h"
+#include "SDL_waylandclipboard.h"
 
 int
 Wayland_SetClipboardText(_THIS, const char *text)
 {
     SDL_VideoData *video_data = NULL;
     SDL_WaylandDataDevice *data_device = NULL;
-    
+
     int status = 0;
- 
+
     if (_this == NULL || _this->driverdata == NULL) {
         status = SDL_SetError("Video driver uninitialized");
     } else {
         video_data = _this->driverdata;
-        /* TODO: Support more than one seat */ 
-        data_device = Wayland_get_data_device(video_data->input);
-        if (text[0] != '\0') {
-            SDL_WaylandDataSource* source = Wayland_data_source_create(_this);
-            Wayland_data_source_add_data(source, TEXT_MIME, text,
-                                         strlen(text) + 1); 
+        if (video_data->input != NULL && video_data->input->data_device != NULL) {
+            data_device = video_data->input->data_device;
+            if (text[0] != '\0') {
+                SDL_WaylandDataSource* source = Wayland_data_source_create(_this);
+                Wayland_data_source_add_data(source, TEXT_MIME, text,
+                                             SDL_strlen(text) + 1);
 
-            status = Wayland_data_device_set_selection(data_device, source);
-            if (status != 0) {
-                Wayland_data_source_destroy(source);
+                status = Wayland_data_device_set_selection(data_device, source);
+                if (status != 0) {
+                    Wayland_data_source_destroy(source);
+                }
+            } else {
+                status = Wayland_data_device_clear_selection(data_device);
             }
-        } else {
-            status = Wayland_data_device_clear_selection(data_device);
         }
     }
 
@@ -66,25 +68,27 @@ Wayland_GetClipboardText(_THIS)
 
     void *buffer = NULL;
     size_t length = 0;
- 
+
     if (_this == NULL || _this->driverdata == NULL) {
         SDL_SetError("Video driver uninitialized");
     } else {
         video_data = _this->driverdata;
-        /* TODO: Support more than one seat */ 
-        data_device = Wayland_get_data_device(video_data->input);
-        if (data_device->selection_offer != NULL) {
-            buffer = Wayland_data_offer_receive(data_device->selection_offer,
-                                                &length, TEXT_MIME, SDL_TRUE);
-            if (length > 0) {
-                text = (char*) buffer;
-            } 
-        } else if (data_device->selection_source != NULL) {
-            buffer = Wayland_data_source_get_data(data_device->selection_source,
-                                                  &length, TEXT_MIME, SDL_TRUE);
-            if (length > 0) {
-                text = (char*) buffer;
-            } 
+        if (video_data->input != NULL && video_data->input->data_device != NULL) {
+            data_device = video_data->input->data_device;
+            if (data_device->selection_offer != NULL) {
+                buffer = Wayland_data_offer_receive(data_device->selection_offer,
+                                                    &length, TEXT_MIME, SDL_TRUE);
+                if (length > 0) {
+                    text = (char*) buffer;
+                }
+            }
+            if (length == 0 && data_device->selection_source != NULL) {
+                buffer = Wayland_data_source_get_data(data_device->selection_source,
+                                                      &length, TEXT_MIME, SDL_TRUE);
+                if (length > 0) {
+                    text = (char*) buffer;
+                }
+            }
         }
     }
 
@@ -101,18 +105,20 @@ Wayland_HasClipboardText(_THIS)
     SDL_VideoData *video_data = NULL;
     SDL_WaylandDataDevice *data_device = NULL;
 
-    SDL_bool result = SDL_FALSE;    
+    SDL_bool result = SDL_FALSE;
     if (_this == NULL || _this->driverdata == NULL) {
         SDL_SetError("Video driver uninitialized");
     } else {
         video_data = _this->driverdata;
-        data_device = Wayland_get_data_device(video_data->input);
-        if (data_device != NULL && Wayland_data_offer_has_mime(
-                data_device->selection_offer, TEXT_MIME)) {
-            result = SDL_TRUE;
-        } else if(data_device != NULL && Wayland_data_source_has_mime(
-                data_device->selection_source, TEXT_MIME)) {
-            result = SDL_TRUE;
+        if (video_data->input != NULL && video_data->input->data_device != NULL) {
+            data_device = video_data->input->data_device;
+            if (Wayland_data_offer_has_mime(
+                    data_device->selection_offer, TEXT_MIME)) {
+                result = SDL_TRUE;
+            } else if (Wayland_data_source_has_mime(
+                    data_device->selection_source, TEXT_MIME)) {
+                result = SDL_TRUE;
+            }
         }
     }
     return result;
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandclipboard.h b/Engine/lib/sdl/src/video/wayland/SDL_waylandclipboard.h
index d82af2324..b30e1605b 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandclipboard.h
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandclipboard.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylanddatamanager.c b/Engine/lib/sdl/src/video/wayland/SDL_waylanddatamanager.c
index af46e29bc..c8d3ec757 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylanddatamanager.c
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylanddatamanager.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -34,7 +34,10 @@
 #include "SDL_waylandvideo.h"
 #include "SDL_waylanddatamanager.h"
 
-#include "SDL_waylanddyn.h"
+/* FIXME: This is arbitrary, but we want this to be less than a frame because
+ * any longer can potentially spin an infinite loop of PumpEvents (!)
+ */
+#define PIPE_MS_TIMEOUT 10
 
 static ssize_t
 write_pipe(int fd, const void* buffer, size_t total_length, size_t *pos)
@@ -47,7 +50,7 @@ write_pipe(int fd, const void* buffer, size_t total_length, size_t *pos)
     sigset_t old_sig_set;
     struct timespec zerotime = {0};
 
-    ready = SDL_IOReady(fd, SDL_TRUE, 1 * 1000);
+    ready = SDL_IOReady(fd, SDL_IOR_WRITE, PIPE_MS_TIMEOUT);
 
     sigemptyset(&sig_set);
     sigaddset(&sig_set, SIGPIPE);  
@@ -93,7 +96,7 @@ read_pipe(int fd, void** buffer, size_t* total_length, SDL_bool null_terminate)
     ssize_t bytes_read = 0;
     size_t pos = 0;
 
-    ready = SDL_IOReady(fd, SDL_FALSE, 1 * 1000);
+    ready = SDL_IOReady(fd, SDL_IOR_READ, PIPE_MS_TIMEOUT);
   
     if (ready == 0) {
         bytes_read = SDL_SetError("Pipe timeout");
@@ -152,7 +155,7 @@ Wayland_convert_mime_type(const char *mime_type)
     size_t index = 0;
 
     for (index = 0; index < MIME_LIST_SIZE; ++index) {
-        if (strcmp(mime_conversion_list[index][0], mime_type) == 0) {
+        if (SDL_strcmp(mime_conversion_list[index][0], mime_type) == 0) {
             found = mime_conversion_list[index][1];
             break;
         }
@@ -169,7 +172,7 @@ mime_data_list_find(struct wl_list* list,
 
     SDL_MimeDataList *mime_list = NULL;
     wl_list_for_each(mime_list, list, link) { 
-        if (strcmp(mime_list->mime_type, mime_type) == 0) {
+        if (SDL_strcmp(mime_list->mime_type, mime_type) == 0) {
             found = mime_list;
             break;
         }
@@ -204,7 +207,7 @@ mime_data_list_add(struct wl_list* list,
         } else {
             WAYLAND_wl_list_insert(list, &(mime_data->link));
 
-            mime_type_length = strlen(mime_type) + 1;
+            mime_type_length = SDL_strlen(mime_type) + 1;
             mime_data->mime_type = SDL_malloc(mime_type_length);
             if (mime_data->mime_type == NULL) {
                 status = SDL_OutOfMemory();
@@ -393,8 +396,9 @@ Wayland_data_device_clear_selection(SDL_WaylandDataDevice *data_device)
 
     if (data_device == NULL || data_device->data_device == NULL) {
         status = SDL_SetError("Invalid Data Device");
-    } else if (data_device->selection_source != 0) {
+    } else if (data_device->selection_source != NULL) {
         wl_data_device_set_selection(data_device->data_device, NULL, 0);
+        Wayland_data_source_destroy(data_device->selection_source);
         data_device->selection_source = NULL;
     }
     return status;
@@ -421,7 +425,7 @@ Wayland_data_device_set_selection(SDL_WaylandDataDevice *data_device,
 
             /* TODO - Improve system for multiple mime types to same data */
             for (index = 0; index < MIME_LIST_SIZE; ++index) {
-                if (strcmp(mime_conversion_list[index][1], mime_data->mime_type) == 0) {
+                if (SDL_strcmp(mime_conversion_list[index][1], mime_data->mime_type) == 0) {
                     wl_data_source_offer(source->source,
                                          mime_conversion_list[index][0]);
                }
@@ -441,6 +445,9 @@ Wayland_data_device_set_selection(SDL_WaylandDataDevice *data_device,
                                              source->source,
                                              data_device->selection_serial); 
             }
+            if (data_device->selection_source != NULL) {
+                Wayland_data_source_destroy(data_device->selection_source);
+            }
             data_device->selection_source = source;
         }
     }
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylanddatamanager.h b/Engine/lib/sdl/src/video/wayland/SDL_waylanddatamanager.h
index ce003df83..4e85dfa31 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylanddatamanager.h
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylanddatamanager.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylanddyn.c b/Engine/lib/sdl/src/video/wayland/SDL_waylanddyn.c
index 578fad49a..034df7a8c 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylanddyn.c
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylanddyn.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -47,12 +47,16 @@ typedef struct
 #ifndef SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_XKBCOMMON
 #define SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_XKBCOMMON NULL
 #endif
+#ifndef SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_LIBDECOR
+#define SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_LIBDECOR NULL
+#endif
 
 static waylanddynlib waylandlibs[] = {
     {NULL, SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC},
     {NULL, SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_EGL},
     {NULL, SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_CURSOR},
-    {NULL, SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_XKBCOMMON}
+    {NULL, SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_XKBCOMMON},
+    {NULL, SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_LIBDECOR}
 };
 
 static void *
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylanddyn.h b/Engine/lib/sdl/src/video/wayland/SDL_waylanddyn.h
index 485a9c19f..c867ec001 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylanddyn.h
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylanddyn.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -18,13 +18,12 @@
      misrepresented as being the original software.
   3. This notice may not be removed or altered from any source distribution.
 */
-
 #ifndef SDL_waylanddyn_h_
 #define SDL_waylanddyn_h_
 
 #include "../../SDL_internal.h"
 
-/* We can't include wayland-client.h here 
+/* We can't include wayland-client.h here
  * but we need some structs from it
  */
 struct wl_interface;
@@ -34,10 +33,24 @@ struct wl_display;
 struct wl_surface;
 struct wl_shm;
 
+/* We also need some for libdecor */
+struct wl_seat;
+struct wl_output;
+struct libdecor;
+struct libdecor_frame;
+struct libdecor_state;
+struct libdecor_configuration;
+struct libdecor_interface;
+struct libdecor_frame_interface;
+enum libdecor_resize_edge;
+enum libdecor_capabilities;
+enum libdecor_window_state;
+
 #include <stdint.h>
 #include "wayland-cursor.h"
 #include "wayland-util.h"
 #include "xkbcommon/xkbcommon.h"
+#include "xkbcommon/xkbcommon-compose.h"
 
 #ifdef __cplusplus
 extern "C"
@@ -54,7 +67,6 @@ void SDL_WAYLAND_UnloadSymbols(void);
 #define SDL_WAYLAND_INTERFACE(iface) extern const struct wl_interface *WAYLAND_##iface;
 #include "SDL_waylandsym.h"
 
-
 #ifdef __cplusplus
 }
 #endif
@@ -64,7 +76,7 @@ void SDL_WAYLAND_UnloadSymbols(void);
 
 #ifdef SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC
 
-#ifdef _WAYLAND_CLIENT_H
+#if defined(_WAYLAND_CLIENT_H) || defined(WAYLAND_CLIENT_H)
 #error Do not include wayland-client ahead of SDL_waylanddyn.h in dynamic loading mode
 #endif
 
@@ -81,25 +93,69 @@ void SDL_WAYLAND_UnloadSymbols(void);
 #define wl_proxy_add_listener (*WAYLAND_wl_proxy_add_listener)
 #define wl_proxy_marshal_constructor (*WAYLAND_wl_proxy_marshal_constructor)
 #define wl_proxy_marshal_constructor_versioned (*WAYLAND_wl_proxy_marshal_constructor_versioned)
+#define wl_proxy_set_tag (*WAYLAND_wl_proxy_set_tag)
+#define wl_proxy_get_tag (*WAYLAND_wl_proxy_get_tag)
+#define wl_proxy_marshal_flags (*WAYLAND_wl_proxy_marshal_flags)
+#define wl_proxy_marshal_array_flags (*WAYLAND_wl_proxy_marshal_array_flags)
 
 #define wl_seat_interface (*WAYLAND_wl_seat_interface)
 #define wl_surface_interface (*WAYLAND_wl_surface_interface)
 #define wl_shm_pool_interface (*WAYLAND_wl_shm_pool_interface)
 #define wl_buffer_interface (*WAYLAND_wl_buffer_interface)
 #define wl_registry_interface (*WAYLAND_wl_registry_interface)
-#define wl_shell_surface_interface (*WAYLAND_wl_shell_surface_interface)
 #define wl_region_interface (*WAYLAND_wl_region_interface)
 #define wl_pointer_interface (*WAYLAND_wl_pointer_interface)
 #define wl_keyboard_interface (*WAYLAND_wl_keyboard_interface)
 #define wl_compositor_interface (*WAYLAND_wl_compositor_interface)
 #define wl_output_interface (*WAYLAND_wl_output_interface)
-#define wl_shell_interface (*WAYLAND_wl_shell_interface)
 #define wl_shm_interface (*WAYLAND_wl_shm_interface)
 #define wl_data_device_interface (*WAYLAND_wl_data_device_interface)
 #define wl_data_offer_interface (*WAYLAND_wl_data_offer_interface)
 #define wl_data_source_interface (*WAYLAND_wl_data_source_interface)
 #define wl_data_device_manager_interface (*WAYLAND_wl_data_device_manager_interface)
 
+#ifdef HAVE_LIBDECOR_H
+/* Must be included before our defines */
+#include <libdecor.h>
+
+#define libdecor_unref (*WAYLAND_libdecor_unref)
+#define libdecor_new (*WAYLAND_libdecor_new)
+#define libdecor_decorate (*WAYLAND_libdecor_decorate)
+#define libdecor_frame_unref (*WAYLAND_libdecor_frame_unref)
+#define libdecor_frame_set_title (*WAYLAND_libdecor_frame_set_title)
+#define libdecor_frame_set_app_id (*WAYLAND_libdecor_frame_set_app_id)
+#define libdecor_frame_set_max_content_size (*WAYLAND_libdecor_frame_set_max_content_size)
+#define libdecor_frame_set_min_content_size (*WAYLAND_libdecor_frame_set_min_content_size)
+#define libdecor_frame_resize (*WAYLAND_libdecor_frame_resize)
+#define libdecor_frame_move (*WAYLAND_libdecor_frame_move)
+#define libdecor_frame_commit (*WAYLAND_libdecor_frame_commit)
+#define libdecor_frame_set_minimized (*WAYLAND_libdecor_frame_set_minimized)
+#define libdecor_frame_set_maximized (*WAYLAND_libdecor_frame_set_maximized)
+#define libdecor_frame_unset_maximized (*WAYLAND_libdecor_frame_unset_maximized)
+#define libdecor_frame_set_fullscreen (*WAYLAND_libdecor_frame_set_fullscreen)
+#define libdecor_frame_unset_fullscreen (*WAYLAND_libdecor_frame_unset_fullscreen)
+#define libdecor_frame_set_capabilities (*WAYLAND_libdecor_frame_set_capabilities)
+#define libdecor_frame_unset_capabilities (*WAYLAND_libdecor_frame_unset_capabilities)
+#define libdecor_frame_has_capability (*WAYLAND_libdecor_frame_has_capability)
+#define libdecor_frame_set_visibility (*WAYLAND_libdecor_frame_set_visibility)
+#define libdecor_frame_is_visible (*WAYLAND_libdecor_frame_is_visible)
+#define libdecor_frame_is_floating (*WAYLAND_libdecor_frame_is_floating)
+#define libdecor_frame_set_parent (*WAYLAND_libdecor_frame_set_parent)
+#define libdecor_frame_get_xdg_surface (*WAYLAND_libdecor_frame_get_xdg_surface)
+#define libdecor_frame_get_xdg_toplevel (*WAYLAND_libdecor_frame_get_xdg_toplevel)
+#define libdecor_frame_map (*WAYLAND_libdecor_frame_map)
+#define libdecor_state_new (*WAYLAND_libdecor_state_new)
+#define libdecor_state_free (*WAYLAND_libdecor_state_free)
+#define libdecor_configuration_get_content_size (*WAYLAND_libdecor_configuration_get_content_size)
+#define libdecor_configuration_get_window_state (*WAYLAND_libdecor_configuration_get_window_state)
+#endif
+
+#else /* SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC */
+
+#ifdef HAVE_LIBDECOR_H
+#include <libdecor.h>
+#endif
+
 #endif /* SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC */
 
 #include "wayland-client-protocol.h"
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandevents.c b/Engine/lib/sdl/src/video/wayland/SDL_waylandevents.c
index 0d57cbfa4..55893201b 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandevents.c
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandevents.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -35,12 +35,15 @@
 #include "SDL_waylandevents_c.h"
 #include "SDL_waylandwindow.h"
 
-#include "SDL_waylanddyn.h"
-
 #include "pointer-constraints-unstable-v1-client-protocol.h"
 #include "relative-pointer-unstable-v1-client-protocol.h"
 #include "xdg-shell-client-protocol.h"
-#include "xdg-shell-unstable-v6-client-protocol.h"
+#include "keyboard-shortcuts-inhibit-unstable-v1-client-protocol.h"
+#include "text-input-unstable-v3-client-protocol.h"
+
+#ifdef HAVE_LIBDECOR_H
+#include <libdecor.h>
+#endif
 
 #ifdef SDL_INPUT_LINUXEV
 #include <linux/input.h>
@@ -55,55 +58,31 @@
 #include <sys/mman.h>
 #include <poll.h>
 #include <unistd.h>
+#include <errno.h>
 #include <xkbcommon/xkbcommon.h>
+#include <xkbcommon/xkbcommon-compose.h>
+#include "../../events/imKStoUCS.h"
 
-typedef struct {
-    // repeat_rate in range of [1, 1000]
-    int32_t repeat_rate;
-    int32_t repeat_delay;
-    SDL_bool is_initialized;
+/* Weston uses a ratio of 10 units per scroll tick */
+#define WAYLAND_WHEEL_AXIS_UNIT 10
 
-    SDL_bool is_key_down;
-    uint32_t next_repeat_ms;
-    uint32_t scancode;
-    char text[8];
-} SDL_WaylandKeyboardRepeat;
-
-struct SDL_WaylandInput {
-    SDL_VideoData *display;
-    struct wl_seat *seat;
-    struct wl_pointer *pointer;
-    struct wl_touch *touch;
-    struct wl_keyboard *keyboard;
-    SDL_WaylandDataDevice *data_device;
-    struct zwp_relative_pointer_v1 *relative_pointer;
-    struct zwp_confined_pointer_v1 *confined_pointer;
-    SDL_Window *confined_pointer_window;
-    SDL_WindowData *pointer_focus;
-    SDL_WindowData *keyboard_focus;
-
-    /* Last motion location */
-    wl_fixed_t sx_w;
-    wl_fixed_t sy_w;
-
-    double dx_frac;
-    double dy_frac;
-
-    struct {
-        struct xkb_keymap *keymap;
-        struct xkb_state *state;
-    } xkb;
-
-    /* information about axis events on current frame */
-    struct {
-        SDL_bool is_x_discrete;
-        float x;
-
-        SDL_bool is_y_discrete;
-        float y;
-    } pointer_curr_axis_info;
-
-    SDL_WaylandKeyboardRepeat keyboard_repeat;
+static const struct {
+    xkb_keysym_t keysym;
+    SDL_KeyCode keycode;
+} KeySymToSDLKeyCode[] = {
+    { XKB_KEY_Shift_L, SDLK_LSHIFT },
+    { XKB_KEY_Shift_R, SDLK_RSHIFT },
+    { XKB_KEY_Control_L, SDLK_LCTRL },
+    { XKB_KEY_Control_R, SDLK_RCTRL },
+    { XKB_KEY_Caps_Lock, SDLK_CAPSLOCK },
+    { XKB_KEY_Alt_L, SDLK_LALT },
+    { XKB_KEY_Alt_R, SDLK_RALT },
+    { XKB_KEY_Meta_L, SDLK_LGUI },
+    { XKB_KEY_Meta_R, SDLK_RGUI },
+    { XKB_KEY_Super_L, SDLK_LGUI },
+    { XKB_KEY_Super_R, SDLK_RGUI },
+    { XKB_KEY_Hyper_L, SDLK_LGUI },
+    { XKB_KEY_Hyper_R, SDLK_RGUI },
 };
 
 struct SDL_WaylandTouchPoint {
@@ -123,6 +102,19 @@ struct SDL_WaylandTouchPointList {
 
 static struct SDL_WaylandTouchPointList touch_points = {NULL, NULL};
 
+static SDL_KeyCode
+Wayland_KeySymToSDLKeyCode(xkb_keysym_t keysym)
+{
+    int i;
+
+    for (i = 0; i < SDL_arraysize(KeySymToSDLKeyCode); ++i) {
+        if (keysym == KeySymToSDLKeyCode[i].keysym) {
+            return KeySymToSDLKeyCode[i].keycode;
+        }
+    }
+    return SDLK_UNKNOWN;
+}
+
 static void
 touch_add(SDL_TouchID id, float x, float y, struct wl_surface *surface)
 {
@@ -210,14 +202,12 @@ touch_surface(SDL_TouchID id)
     return NULL;
 }
 
-/* Returns the time till next repeat, or 0 if no key is down. */
-static void
-keyboard_repeat_handle(SDL_WaylandKeyboardRepeat* repeat_info, uint32_t now)
+/* Returns SDL_TRUE if a key repeat event was due */
+static SDL_bool
+keyboard_repeat_handle(SDL_WaylandKeyboardRepeat* repeat_info, uint32_t elapsed)
 {
-    if (!repeat_info->is_key_down || !repeat_info->is_initialized) {
-        return;
-    }
-    while (repeat_info->next_repeat_ms <= now) {
+    SDL_bool ret = SDL_FALSE;
+    while ((elapsed - repeat_info->next_repeat_ms) < 0x80000000U) {
         if (repeat_info->scancode != SDL_SCANCODE_UNKNOWN) {
             SDL_SendKeyboardKey(SDL_PRESSED, repeat_info->scancode);
         }
@@ -225,7 +215,9 @@ keyboard_repeat_handle(SDL_WaylandKeyboardRepeat* repeat_info, uint32_t now)
             SDL_SendKeyboardText(repeat_info->text);
         }
         repeat_info->next_repeat_ms += 1000 / repeat_info->repeat_rate;
+        ret = SDL_TRUE;
     }
+    return ret;
 }
 
 static void
@@ -237,21 +229,111 @@ keyboard_repeat_clear(SDL_WaylandKeyboardRepeat* repeat_info) {
 }
 
 static void
-keyboard_repeat_set(SDL_WaylandKeyboardRepeat* repeat_info,
+keyboard_repeat_set(SDL_WaylandKeyboardRepeat* repeat_info, uint32_t wl_press_time,
                     uint32_t scancode, SDL_bool has_text, char text[8]) {
-    if (!repeat_info->is_initialized) {
+    if (!repeat_info->is_initialized || !repeat_info->repeat_rate) {
         return;
     }
     repeat_info->is_key_down = SDL_TRUE;
-    repeat_info->next_repeat_ms = SDL_GetTicks() + repeat_info->repeat_delay;
+    repeat_info->wl_press_time = wl_press_time;
+    repeat_info->sdl_press_time = SDL_GetTicks();
+    repeat_info->next_repeat_ms = repeat_info->repeat_delay;
     repeat_info->scancode = scancode;
     if (has_text) {
-        memcpy(repeat_info->text, text, 8);
+        SDL_memcpy(repeat_info->text, text, 8);
     } else {
         repeat_info->text[0] = '\0';
     }
 }
 
+static SDL_bool keyboard_repeat_is_set(SDL_WaylandKeyboardRepeat* repeat_info) {
+    return repeat_info->is_initialized && repeat_info->is_key_down;
+}
+
+void
+Wayland_SendWakeupEvent(_THIS, SDL_Window *window)
+{
+    SDL_VideoData *d = _this->driverdata;
+
+    /* TODO: Maybe use a pipe to avoid the compositor roundtrip? */
+    wl_display_sync(d->display);
+    WAYLAND_wl_display_flush(d->display);
+}
+
+int
+Wayland_WaitEventTimeout(_THIS, int timeout)
+{
+    SDL_VideoData *d = _this->driverdata;
+    struct SDL_WaylandInput *input = d->input;
+    SDL_bool key_repeat_active = SDL_FALSE;
+
+    WAYLAND_wl_display_flush(d->display);
+
+#ifdef SDL_USE_IME
+    if (d->text_input_manager == NULL && SDL_GetEventState(SDL_TEXTINPUT) == SDL_ENABLE) {
+        SDL_IME_PumpEvents();
+    }
+#endif
+
+    /* If key repeat is active, we'll need to cap our maximum wait time to handle repeats */
+    if (input && keyboard_repeat_is_set(&input->keyboard_repeat)) {
+        uint32_t elapsed = SDL_GetTicks() - input->keyboard_repeat.sdl_press_time;
+        if (keyboard_repeat_handle(&input->keyboard_repeat, elapsed)) {
+            /* A repeat key event was already due */
+            return 1;
+        } else {
+            uint32_t next_repeat_wait_time = (input->keyboard_repeat.next_repeat_ms - elapsed) + 1;
+            if (timeout >= 0) {
+                timeout = SDL_min(timeout, next_repeat_wait_time);
+            } else {
+                timeout = next_repeat_wait_time;
+            }
+            key_repeat_active = SDL_TRUE;
+        }
+    }
+
+    /* wl_display_prepare_read() will return -1 if the default queue is not empty.
+     * If the default queue is empty, it will prepare us for our SDL_IOReady() call. */
+    if (WAYLAND_wl_display_prepare_read(d->display) == 0) {
+        /* Use SDL_IOR_NO_RETRY to ensure SIGINT will break us out of our wait */
+        int err = SDL_IOReady(WAYLAND_wl_display_get_fd(d->display), SDL_IOR_READ | SDL_IOR_NO_RETRY, timeout);
+        if (err > 0) {
+            /* There are new events available to read */
+            WAYLAND_wl_display_read_events(d->display);
+            WAYLAND_wl_display_dispatch_pending(d->display);
+            return 1;
+        } else if (err == 0) {
+            /* No events available within the timeout */
+            WAYLAND_wl_display_cancel_read(d->display);
+
+            /* If key repeat is active, we might have woken up to generate a key event */
+            if (key_repeat_active) {
+                uint32_t elapsed = SDL_GetTicks() - input->keyboard_repeat.sdl_press_time;
+                if (keyboard_repeat_handle(&input->keyboard_repeat, elapsed)) {
+                    return 1;
+                }
+            }
+
+            return 0;
+        } else {
+            /* Error returned from poll()/select() */
+            WAYLAND_wl_display_cancel_read(d->display);
+
+            if (errno == EINTR) {
+                /* If the wait was interrupted by a signal, we may have generated a
+                 * SDL_QUIT event. Let the caller know to call SDL_PumpEvents(). */
+                return 1;
+            } else {
+                return err;
+            }
+        }
+    } else {
+        /* We already had pending events */
+        WAYLAND_wl_display_dispatch_pending(d->display);
+        return 1;
+    }
+}
+
 void
 Wayland_PumpEvents(_THIS)
 {
@@ -261,16 +343,30 @@ Wayland_PumpEvents(_THIS)
 
     WAYLAND_wl_display_flush(d->display);
 
-    if (input) {
-        uint32_t now = SDL_GetTicks();
-        keyboard_repeat_handle(&input->keyboard_repeat, now);
+#ifdef SDL_USE_IME
+    if (d->text_input_manager == NULL && SDL_GetEventState(SDL_TEXTINPUT) == SDL_ENABLE) {
+        SDL_IME_PumpEvents();
+    }
+#endif
+
+    /* wl_display_prepare_read() will return -1 if the default queue is not empty.
+     * If the default queue is empty, it will prepare us for our SDL_IOReady() call. */
+    if (WAYLAND_wl_display_prepare_read(d->display) == 0) {
+        if (SDL_IOReady(WAYLAND_wl_display_get_fd(d->display), SDL_IOR_READ, 0) > 0) {
+            WAYLAND_wl_display_read_events(d->display);
+        } else {
+            WAYLAND_wl_display_cancel_read(d->display);
+        }
     }
 
-    if (SDL_IOReady(WAYLAND_wl_display_get_fd(d->display), SDL_FALSE, 0)) {
-        err = WAYLAND_wl_display_dispatch(d->display);
-    } else {
-        err = WAYLAND_wl_display_dispatch_pending(d->display);
+    /* Dispatch any pre-existing pending events or new events we may have read */
+    err = WAYLAND_wl_display_dispatch_pending(d->display);
+
+    if (input && keyboard_repeat_is_set(&input->keyboard_repeat)) {
+        uint32_t elapsed = SDL_GetTicks() - input->keyboard_repeat.sdl_press_time;
+        keyboard_repeat_handle(&input->keyboard_repeat, elapsed);
     }
+
     if (err == -1 && !d->display_disconnected) {
         /* Something has failed with the Wayland connection -- for example,
          * the compositor may have shut down and closed its end of the socket,
@@ -310,6 +406,11 @@ pointer_handle_enter(void *data, struct wl_pointer *pointer,
         return;
     }
 
+    /* check that this surface belongs to one of the SDL windows */
+    if (!SDL_WAYLAND_own_surface(surface)) {
+        return;
+    }
+
     /* This handler will be called twice in Wayland 1.4
      * Once for the window surface which has valid user data
      * and again for the mouse cursor surface which does not have valid user data
@@ -320,11 +421,16 @@ pointer_handle_enter(void *data, struct wl_pointer *pointer,
 
     if (window) {
         input->pointer_focus = window;
+        input->pointer_enter_serial = serial;
         SDL_SetMouseFocus(window->sdlwindow);
         /* In the case of e.g. a pointer confine warp, we may receive an enter
          * event with no following motion event, but with the new coordinates
          * as part of the enter event. */
         pointer_handle_motion(data, pointer, serial, sx_w, sy_w);
+        /* If the cursor was changed while our window didn't have pointer
+         * focus, we might need to trigger another call to
+         * wl_pointer_set_cursor() for the new cursor to be displayed. */
+        SDL_SetCursor(NULL);
     }
 }
 
@@ -334,6 +440,10 @@ pointer_handle_leave(void *data, struct wl_pointer *pointer,
 {
     struct SDL_WaylandInput *input = data;
 
+    if (!surface || !SDL_WAYLAND_own_surface(surface)) {
+        return;
+    }
+
     if (input->pointer_focus) {
         SDL_SetMouseFocus(NULL);
         input->pointer_focus = NULL;
@@ -350,25 +460,33 @@ ProcessHitTest(struct SDL_WaylandInput *input, uint32_t serial)
         const SDL_Point point = { wl_fixed_to_int(input->sx_w), wl_fixed_to_int(input->sy_w) };
         const SDL_HitTestResult rc = window->hit_test(window, &point, window->hit_test_data);
 
-        static const uint32_t directions_wl[] = {
-            WL_SHELL_SURFACE_RESIZE_TOP_LEFT, WL_SHELL_SURFACE_RESIZE_TOP,
-            WL_SHELL_SURFACE_RESIZE_TOP_RIGHT, WL_SHELL_SURFACE_RESIZE_RIGHT,
-            WL_SHELL_SURFACE_RESIZE_BOTTOM_RIGHT, WL_SHELL_SURFACE_RESIZE_BOTTOM,
-            WL_SHELL_SURFACE_RESIZE_BOTTOM_LEFT, WL_SHELL_SURFACE_RESIZE_LEFT
+        static const uint32_t directions[] = {
+            XDG_TOPLEVEL_RESIZE_EDGE_TOP_LEFT, XDG_TOPLEVEL_RESIZE_EDGE_TOP,
+            XDG_TOPLEVEL_RESIZE_EDGE_TOP_RIGHT, XDG_TOPLEVEL_RESIZE_EDGE_RIGHT,
+            XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_RIGHT, XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM,
+            XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_LEFT, XDG_TOPLEVEL_RESIZE_EDGE_LEFT
         };
 
-        /* the names are different (ZXDG_TOPLEVEL_V6_RESIZE_EDGE_* vs
-           WL_SHELL_SURFACE_RESIZE_*), but the values are the same. */
-        const uint32_t *directions_zxdg = directions_wl;
+#ifdef HAVE_LIBDECOR_H
+        /* ditto for libdecor. */
+        const uint32_t *directions_libdecor = directions;
+#endif
 
         switch (rc) {
             case SDL_HITTEST_DRAGGABLE:
+#ifdef HAVE_LIBDECOR_H
+                if (input->display->shell.libdecor) {
+                    if (window_data->shell_surface.libdecor.frame) {
+                        libdecor_frame_move(window_data->shell_surface.libdecor.frame, input->seat, serial);
+                    }
+                } else
+#endif
                 if (input->display->shell.xdg) {
-                    xdg_toplevel_move(window_data->shell_surface.xdg.roleobj.toplevel, input->seat, serial);
-                } else if (input->display->shell.zxdg) {
-                    zxdg_toplevel_v6_move(window_data->shell_surface.zxdg.roleobj.toplevel, input->seat, serial);
-                } else {
-                    wl_shell_surface_move(window_data->shell_surface.wl, input->seat, serial);
+                    if (window_data->shell_surface.xdg.roleobj.toplevel) {
+                        xdg_toplevel_move(window_data->shell_surface.xdg.roleobj.toplevel,
+                                          input->seat,
+                                          serial);
+                    }
                 }
                 return SDL_TRUE;
 
@@ -380,12 +498,20 @@ ProcessHitTest(struct SDL_WaylandInput *input, uint32_t serial)
             case SDL_HITTEST_RESIZE_BOTTOM:
             case SDL_HITTEST_RESIZE_BOTTOMLEFT:
             case SDL_HITTEST_RESIZE_LEFT:
+#ifdef HAVE_LIBDECOR_H
+                if (input->display->shell.libdecor) {
+                    if (window_data->shell_surface.libdecor.frame) {
+                        libdecor_frame_resize(window_data->shell_surface.libdecor.frame, input->seat, serial, directions_libdecor[rc - SDL_HITTEST_RESIZE_TOPLEFT]);
+                    }
+                } else
+#endif
                 if (input->display->shell.xdg) {
-                    xdg_toplevel_resize(window_data->shell_surface.xdg.roleobj.toplevel, input->seat, serial, directions_zxdg[rc - SDL_HITTEST_RESIZE_TOPLEFT]);
-                } else if (input->display->shell.zxdg) {
-                    zxdg_toplevel_v6_resize(window_data->shell_surface.zxdg.roleobj.toplevel, input->seat, serial, directions_zxdg[rc - SDL_HITTEST_RESIZE_TOPLEFT]);
-                } else {
-                    wl_shell_surface_resize(window_data->shell_surface.wl, input->seat, serial, directions_wl[rc - SDL_HITTEST_RESIZE_TOPLEFT]);
+                    if (window_data->shell_surface.xdg.roleobj.toplevel) {
+                        xdg_toplevel_resize(window_data->shell_surface.xdg.roleobj.toplevel,
+                                            input->seat,
+                                            serial,
+                                            directions[rc - SDL_HITTEST_RESIZE_TOPLEFT]);
+                    }
                 }
                 return SDL_TRUE;
 
@@ -459,13 +585,16 @@ pointer_handle_axis_common_v1(struct SDL_WaylandInput *input,
                 y = 0 - (float)wl_fixed_to_double(value);
                 break;
             case WL_POINTER_AXIS_HORIZONTAL_SCROLL:
-                x = 0 - (float)wl_fixed_to_double(value);
+                x = (float)wl_fixed_to_double(value);
                 y = 0;
                 break;
             default:
                 return;
         }
 
+        x /= WAYLAND_WHEEL_AXIS_UNIT;
+        y /= WAYLAND_WHEEL_AXIS_UNIT;
+
         SDL_SendMouseWheel(window->sdlwindow, 0, x, y, SDL_MOUSEWHEEL_NORMAL);
     }
 }
@@ -500,7 +629,7 @@ pointer_handle_axis_common(struct SDL_WaylandInput *input, SDL_bool discrete,
                      * processed a discrete axis event before so we ignore it */
                     break;
                 }
-                input->pointer_curr_axis_info.x = 0 - (float)wl_fixed_to_double(value);
+                input->pointer_curr_axis_info.x = (float)wl_fixed_to_double(value);
                 break;
         }
     }
@@ -523,10 +652,20 @@ pointer_handle_frame(void *data, struct wl_pointer *pointer)
 {
     struct SDL_WaylandInput *input = data;
     SDL_WindowData *window = input->pointer_focus;
-    float x = input->pointer_curr_axis_info.x, y = input->pointer_curr_axis_info.y;
+    float x, y;
+
+    if (input->pointer_curr_axis_info.is_x_discrete)
+        x = input->pointer_curr_axis_info.x;
+    else
+        x = input->pointer_curr_axis_info.x / WAYLAND_WHEEL_AXIS_UNIT;
+
+    if (input->pointer_curr_axis_info.is_y_discrete)
+        y = input->pointer_curr_axis_info.y;
+    else
+        y = input->pointer_curr_axis_info.y / WAYLAND_WHEEL_AXIS_UNIT;
 
     /* clear pointer_curr_axis_info for next frame */
-    memset(&input->pointer_curr_axis_info, 0, sizeof input->pointer_curr_axis_info);
+    SDL_memset(&input->pointer_curr_axis_info, 0, sizeof input->pointer_curr_axis_info);
 
     if(x == 0.0f && y == 0.0f)
         return;
@@ -583,7 +722,7 @@ touch_handler_down(void *data, struct wl_touch *touch, unsigned int serial,
 
     touch_add(id, x, y, surface);
 
-    SDL_SendTouch(1, (SDL_FingerID)id, window_data->sdlwindow, SDL_TRUE, x, y, 1.0f);
+    SDL_SendTouch((SDL_TouchID)(intptr_t)touch, (SDL_FingerID)id, window_data->sdlwindow, SDL_TRUE, x, y, 1.0f);
 }
 
 static void
@@ -601,7 +740,7 @@ touch_handler_up(void *data, struct wl_touch *touch, unsigned int serial,
         window = window_data->sdlwindow;
     }
 
-    SDL_SendTouch(1, (SDL_FingerID)id, window, SDL_FALSE, x, y, 0.0f);
+    SDL_SendTouch((SDL_TouchID)(intptr_t)touch, (SDL_FingerID)id, window, SDL_FALSE, x, y, 0.0f);
 }
 
 static void
@@ -615,7 +754,7 @@ touch_handler_motion(void *data, struct wl_touch *touch, unsigned int timestamp,
     const float y = dbly / window_data->sdlwindow->h;
 
     touch_update(id, x, y);
-    SDL_SendTouchMotion(1, (SDL_FingerID)id, window_data->sdlwindow, x, y, 1.0f);
+    SDL_SendTouchMotion((SDL_TouchID)(intptr_t)touch, (SDL_FingerID)id, window_data->sdlwindow, x, y, 1.0f);
 }
 
 static void
@@ -646,6 +785,7 @@ keyboard_handle_keymap(void *data, struct wl_keyboard *keyboard,
 {
     struct SDL_WaylandInput *input = data;
     char *map_str;
+    const char *locale;
 
     if (!data) {
         close(fd);
@@ -682,6 +822,30 @@ keyboard_handle_keymap(void *data, struct wl_keyboard *keyboard,
         input->xkb.keymap = NULL;
         return;
     }
+
+    /*
+     * See https://blogs.s-osg.org/compose-key-support-weston/
+     * for further explanation on dead keys in Wayland.
+     */
+
+    /* Look up the preferred locale, falling back to "C" as default */
+    if (!(locale = SDL_getenv("LC_ALL")))
+        if (!(locale = SDL_getenv("LC_CTYPE")))
+            if (!(locale = SDL_getenv("LANG")))
+                locale = "C";
+    /* Set up XKB compose table */
+    input->xkb.compose_table = WAYLAND_xkb_compose_table_new_from_locale(input->display->xkb_context,
+                                              locale, XKB_COMPOSE_COMPILE_NO_FLAGS);
+    if (input->xkb.compose_table) {
+        /* Set up XKB compose state */
+        input->xkb.compose_state = WAYLAND_xkb_compose_state_new(input->xkb.compose_table,
+                                              XKB_COMPOSE_STATE_NO_FLAGS);
+        if (!input->xkb.compose_state) {
+            fprintf(stderr, "could not create XKB compose state\n");
+            WAYLAND_xkb_compose_table_unref(input->xkb.compose_table);
+            input->xkb.compose_table = NULL;
+        }
+    }
 }
 
 static void
@@ -697,6 +861,10 @@ keyboard_handle_enter(void *data, struct wl_keyboard *keyboard,
         return;
     }
 
+    if (!SDL_WAYLAND_own_surface(surface)) {
+        return;
+    }
+
     window = wl_surface_get_user_data(surface);
 
     if (window) {
@@ -704,20 +872,42 @@ keyboard_handle_enter(void *data, struct wl_keyboard *keyboard,
         window->keyboard_device = input;
         SDL_SetKeyboardFocus(window->sdlwindow);
     }
+#ifdef SDL_USE_IME
+    if (!input->text_input) {
+        SDL_IME_SetFocus(SDL_TRUE);
+    }
+#endif
 }
 
 static void
 keyboard_handle_leave(void *data, struct wl_keyboard *keyboard,
                       uint32_t serial, struct wl_surface *surface)
 {
+    struct SDL_WaylandInput *input = data;
+
+    if (!surface || !SDL_WAYLAND_own_surface(surface)) {
+        return;
+    }
+
+    /* Stop key repeat before clearing keyboard focus */
+    keyboard_repeat_clear(&input->keyboard_repeat);
+
+    /* This will release any keys still pressed */
     SDL_SetKeyboardFocus(NULL);
+
+#ifdef SDL_USE_IME
+    if (!input->text_input) {
+        SDL_IME_SetFocus(SDL_FALSE);
+    }
+#endif
 }
 
 static SDL_bool
-keyboard_input_get_text(char text[8], const struct SDL_WaylandInput *input, uint32_t key)
+keyboard_input_get_text(char text[8], const struct SDL_WaylandInput *input, uint32_t key, SDL_bool *handled_by_ime)
 {
     SDL_WindowData *window = input->keyboard_focus;
     const xkb_keysym_t *syms;
+    xkb_keysym_t sym;
 
     if (!window || window->keyboard_device != input || !input->xkb.state) {
         return SDL_FALSE;
@@ -727,8 +917,33 @@ keyboard_input_get_text(char text[8], const struct SDL_WaylandInput *input, uint
     if (WAYLAND_xkb_state_key_get_syms(input->xkb.state, key + 8, &syms) != 1) {
         return SDL_FALSE;
     }
+    sym = syms[0];
 
-    return WAYLAND_xkb_keysym_to_utf8(syms[0], text, 8) > 0;
+#ifdef SDL_USE_IME
+    if (SDL_IME_ProcessKeyEvent(sym, key + 8)) {
+        *handled_by_ime = SDL_TRUE;
+        return SDL_TRUE;
+    }
+#endif
+
+    if (input->xkb.compose_state && WAYLAND_xkb_compose_state_feed(input->xkb.compose_state, sym) == XKB_COMPOSE_FEED_ACCEPTED) {
+        switch(WAYLAND_xkb_compose_state_get_status(input->xkb.compose_state)) {
+            case XKB_COMPOSE_COMPOSING:
+                *handled_by_ime = SDL_TRUE;
+                return SDL_TRUE;
+            case XKB_COMPOSE_CANCELLED:
+            default:
+                sym = XKB_KEY_NoSymbol;
+                break;
+            case XKB_COMPOSE_NOTHING:
+                break;
+            case XKB_COMPOSE_COMPOSED:
+                sym = WAYLAND_xkb_compose_state_get_one_sym(input->xkb.compose_state);
+                break;
+        }
+    }
+
+    return WAYLAND_xkb_keysym_to_utf8(sym, text, 8) > 0;
 }
 
 static void
@@ -740,8 +955,23 @@ keyboard_handle_key(void *data, struct wl_keyboard *keyboard,
     enum wl_keyboard_key_state state = state_w;
     uint32_t scancode = SDL_SCANCODE_UNKNOWN;
     char text[8];
+    SDL_bool has_text = SDL_FALSE;
+    SDL_bool handled_by_ime = SDL_FALSE;
 
-    if (key < SDL_arraysize(xfree86_scancode_table2)) {
+    if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
+        has_text = keyboard_input_get_text(text, input, key, &handled_by_ime);
+    } else {
+        if (keyboard_repeat_is_set(&input->keyboard_repeat)) {
+            // Send any due key repeat events before stopping the repeat and generating the key up event
+            // Compute time based on the Wayland time, as it reports when the release event happened
+            // Using SDL_GetTicks would be wrong, as it would report when the release event is processed,
+            // which may be off if the application hasn't pumped events for a while
+            keyboard_repeat_handle(&input->keyboard_repeat, time - input->keyboard_repeat.wl_press_time);
+            keyboard_repeat_clear(&input->keyboard_repeat);
+        }
+    }
+
+    if (!handled_by_ime && key < SDL_arraysize(xfree86_scancode_table2)) {
         scancode = xfree86_scancode_table2[key];
 
         if (scancode != SDL_SCANCODE_UNKNOWN) {
@@ -751,14 +981,68 @@ keyboard_handle_key(void *data, struct wl_keyboard *keyboard,
     }
 
     if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
-        SDL_bool has_text = keyboard_input_get_text(text, input, key);
-        if (has_text) {
+        if (has_text && !(SDL_GetModState() & KMOD_CTRL)) {
             Wayland_data_device_set_serial(input->data_device, serial);
-            SDL_SendKeyboardText(text);
+            if (!handled_by_ime) {
+                SDL_SendKeyboardText(text);
+            }
+        }
+        if (input->xkb.keymap && WAYLAND_xkb_keymap_key_repeats(input->xkb.keymap, key + 8)) {
+            keyboard_repeat_set(&input->keyboard_repeat, time, scancode, has_text, text);
+        }
+    }
+}
+
+typedef struct Wayland_Keymap
+{
+    xkb_layout_index_t layout;
+    SDL_Keycode keymap[SDL_NUM_SCANCODES];
+} Wayland_Keymap;
+
+static void
+Wayland_keymap_iter(struct xkb_keymap *keymap, xkb_keycode_t key, void *data)
+{
+    const xkb_keysym_t *syms;
+    Wayland_Keymap *sdlKeymap = (Wayland_Keymap *)data;
+
+    if ((key - 8) < SDL_arraysize(xfree86_scancode_table2)) {
+        SDL_Scancode scancode = xfree86_scancode_table2[key - 8];
+        if (scancode == SDL_SCANCODE_UNKNOWN) {
+            return;
+        }
+
+        if (WAYLAND_xkb_keymap_key_get_syms_by_level(keymap, key, sdlKeymap->layout, 0, &syms) > 0) {
+            uint32_t keycode = SDL_KeySymToUcs4(syms[0]);
+
+            if (!keycode) {
+                keycode = Wayland_KeySymToSDLKeyCode(syms[0]);
+            }
+
+            if (keycode) {
+                sdlKeymap->keymap[scancode] = keycode;
+            } else {
+                switch (scancode) {
+                    case SDL_SCANCODE_RETURN:
+                        sdlKeymap->keymap[scancode] = SDLK_RETURN;
+                        break;
+                    case SDL_SCANCODE_ESCAPE:
+                        sdlKeymap->keymap[scancode] = SDLK_ESCAPE;
+                        break;
+                    case SDL_SCANCODE_BACKSPACE:
+                        sdlKeymap->keymap[scancode] = SDLK_BACKSPACE;
+                        break;
+                    case SDL_SCANCODE_TAB:
+                        sdlKeymap->keymap[scancode] = SDLK_TAB;
+                        break;
+                    case SDL_SCANCODE_DELETE:
+                        sdlKeymap->keymap[scancode] = SDLK_DELETE;
+                        break;
+                    default:
+                        sdlKeymap->keymap[scancode] = SDL_SCANCODE_TO_KEYCODE(scancode);
+                        break;
+                }
+            }
         }
-        keyboard_repeat_set(&input->keyboard_repeat, scancode, has_text, text);
-    } else {
-        keyboard_repeat_clear(&input->keyboard_repeat);
     }
 }
 
@@ -769,9 +1053,18 @@ keyboard_handle_modifiers(void *data, struct wl_keyboard *keyboard,
                           uint32_t group)
 {
     struct SDL_WaylandInput *input = data;
+    Wayland_Keymap keymap;
 
     WAYLAND_xkb_state_update_mask(input->xkb.state, mods_depressed, mods_latched,
                           mods_locked, 0, 0, group);
+
+    keymap.layout = group;
+    SDL_GetDefaultKeymap(keymap.keymap);
+    WAYLAND_xkb_keymap_key_for_each(input->xkb.keymap,
+                                    Wayland_keymap_iter,
+                                    &keymap);
+    SDL_SetKeymap(0, keymap.keymap, SDL_NUM_SCANCODES);
+    SDL_SendKeymapChangedEvent();
 }
 
 static void
@@ -779,7 +1072,7 @@ keyboard_handle_repeat_info(void *data, struct wl_keyboard *wl_keyboard,
                             int32_t rate, int32_t delay)
 {
     struct SDL_WaylandInput *input = data;
-    input->keyboard_repeat.repeat_rate = SDL_max(0, SDL_min(rate, 1000));
+    input->keyboard_repeat.repeat_rate = SDL_clamp(rate, 0, 1000);
     input->keyboard_repeat.repeat_delay = delay;
     input->keyboard_repeat.is_initialized = SDL_TRUE;
 }
@@ -801,7 +1094,7 @@ seat_handle_capabilities(void *data, struct wl_seat *seat,
 
     if ((caps & WL_SEAT_CAPABILITY_POINTER) && !input->pointer) {
         input->pointer = wl_seat_get_pointer(seat);
-        memset(&input->pointer_curr_axis_info, 0, sizeof input->pointer_curr_axis_info);
+        SDL_memset(&input->pointer_curr_axis_info, 0, sizeof input->pointer_curr_axis_info);
         input->display->pointer = input->pointer;
         wl_pointer_set_user_data(input->pointer, input);
         wl_pointer_add_listener(input->pointer, &pointer_listener,
@@ -813,13 +1106,13 @@ seat_handle_capabilities(void *data, struct wl_seat *seat,
     }
 
     if ((caps & WL_SEAT_CAPABILITY_TOUCH) && !input->touch) {
-        SDL_AddTouch(1, SDL_TOUCH_DEVICE_DIRECT, "wayland_touch");
         input->touch = wl_seat_get_touch(seat);
+        SDL_AddTouch((SDL_TouchID)(intptr_t)input->touch, SDL_TOUCH_DEVICE_DIRECT, "wayland_touch");
         wl_touch_set_user_data(input->touch, input);
         wl_touch_add_listener(input->touch, &touch_listener,
                                  input);
     } else if (!(caps & WL_SEAT_CAPABILITY_TOUCH) && input->touch) {
-        SDL_DelTouch(1);
+        SDL_DelTouch((SDL_TouchID)(intptr_t)input->touch);
         wl_touch_destroy(input->touch);
         input->touch = NULL;
     }
@@ -1021,36 +1314,145 @@ data_device_handle_motion(void *data, struct wl_data_device *wl_data_device,
 {
 }
 
+/* Decodes URI escape sequences in string buf of len bytes
+   (excluding the terminating NULL byte) in-place. Since
+   URI-encoded characters take three times the space of
+   normal characters, this should not be an issue.
+
+   Returns the number of decoded bytes that wound up in
+   the buffer, excluding the terminating NULL byte.
+
+   The buffer is guaranteed to be NULL-terminated but
+   may contain embedded NULL bytes.
+
+   On error, -1 is returned.
+
+   FIXME: This was shamelessly copied from SDL_x11events.c
+ */
+static int Wayland_URIDecode(char *buf, int len) {
+    int ri, wi, di;
+    char decode = '\0';
+    if (buf == NULL || len < 0) {
+        errno = EINVAL;
+        return -1;
+    }
+    if (len == 0) {
+        len = SDL_strlen(buf);
+    }
+    for (ri = 0, wi = 0, di = 0; ri < len && wi < len; ri += 1) {
+        if (di == 0) {
+            /* start decoding */
+            if (buf[ri] == '%') {
+                decode = '\0';
+                di += 1;
+                continue;
+            }
+            /* normal write */
+            buf[wi] = buf[ri];
+            wi += 1;
+            continue;
+        } else if (di == 1 || di == 2) {
+            char off = '\0';
+            char isa = buf[ri] >= 'a' && buf[ri] <= 'f';
+            char isA = buf[ri] >= 'A' && buf[ri] <= 'F';
+            char isn = buf[ri] >= '0' && buf[ri] <= '9';
+            if (!(isa || isA || isn)) {
+                /* not a hexadecimal */
+                int sri;
+                for (sri = ri - di; sri <= ri; sri += 1) {
+                    buf[wi] = buf[sri];
+                    wi += 1;
+                }
+                di = 0;
+                continue;
+            }
+            /* itsy bitsy magicsy */
+            if (isn) {
+                off = 0 - '0';
+            } else if (isa) {
+                off = 10 - 'a';
+            } else if (isA) {
+                off = 10 - 'A';
+            }
+            decode |= (buf[ri] + off) << (2 - di) * 4;
+            if (di == 2) {
+                buf[wi] = decode;
+                wi += 1;
+                di = 0;
+            } else {
+                di += 1;
+            }
+            continue;
+        }
+    }
+    buf[wi] = '\0';
+    return wi;
+}
+
+/* Convert URI to local filename
+   return filename if possible, else NULL
+
+   FIXME: This was shamelessly copied from SDL_x11events.c
+*/
+static char* Wayland_URIToLocal(char* uri) {
+    char *file = NULL;
+    SDL_bool local;
+
+    if (SDL_memcmp(uri,"file:/",6) == 0) uri += 6;      /* local file? */
+    else if (SDL_strstr(uri,":/") != NULL) return file; /* wrong scheme */
+
+    local = uri[0] != '/' || (uri[0] != '\0' && uri[1] == '/');
+
+    /* got a hostname? */
+    if (!local && uri[0] == '/' && uri[2] != '/') {
+      char* hostname_end = SDL_strchr(uri+1, '/');
+      if (hostname_end != NULL) {
+          char hostname[ 257 ];
+          if (gethostname(hostname, 255) == 0) {
+            hostname[ 256 ] = '\0';
+            if (SDL_memcmp(uri+1, hostname, hostname_end - (uri+1)) == 0) {
+                uri = hostname_end + 1;
+                local = SDL_TRUE;
+            }
+          }
+      }
+    }
+    if (local) {
+      file = uri;
+      /* Convert URI escape sequences to real characters */
+      Wayland_URIDecode(file, 0);
+      if (uri[1] == '/') {
+          file++;
+      } else {
+          file--;
+      }
+    }
+    return file;
+}
+
 static void
 data_device_handle_drop(void *data, struct wl_data_device *wl_data_device)
 {
     SDL_WaylandDataDevice *data_device = data;
-    void *buffer = NULL;
-    size_t length = 0;
-
-    const char *current_uri = NULL;
-    const char *last_char = NULL;
-    char *current_char = NULL;
 
     if (data_device->drag_offer != NULL) {
         /* TODO: SDL Support more mime types */
-        buffer = Wayland_data_offer_receive(data_device->drag_offer,
-                                            &length, FILE_MIME, SDL_FALSE);
-
-        /* uri-list */
-        current_uri = (const char *)buffer;
-        last_char = (const char *)buffer + length;
-        for (current_char = buffer; current_char < last_char; ++current_char) {
-            if (*current_char == '\n' || *current_char == 0) {
-                if (*current_uri != 0 && *current_uri != '#') {
-                    *current_char = 0;
-                    SDL_SendDropFile(NULL, current_uri);
+        size_t length;
+        void *buffer = Wayland_data_offer_receive(data_device->drag_offer,
+                                                  &length, FILE_MIME, SDL_FALSE);
+        if (buffer) {
+            char *saveptr = NULL;
+            char *token = SDL_strtokr((char *) buffer, "\r\n", &saveptr);
+            while (token != NULL) {
+                char *fn = Wayland_URIToLocal(token);
+                if (fn) {
+                    SDL_SendDropFile(NULL, fn); /* FIXME: Window? */
                 }
-                current_uri = (const char *)current_char + 1;
+                token = SDL_strtokr(NULL, "\r\n", &saveptr);
             }
+            SDL_SendDropComplete(NULL); /* FIXME: Window? */
+            SDL_free(buffer);
         }
-
-        SDL_free(buffer);
     }
 }
 
@@ -1082,11 +1484,172 @@ static const struct wl_data_device_listener data_device_listener = {
     data_device_handle_selection
 };
 
+static void
+text_input_enter(void *data,
+                 struct zwp_text_input_v3 *zwp_text_input_v3,
+                 struct wl_surface *surface)
+{
+    /* No-op */
+}
+
+static void
+text_input_leave(void *data,
+                 struct zwp_text_input_v3 *zwp_text_input_v3,
+                 struct wl_surface *surface)
+{
+    /* No-op */
+}
+
+static void
+text_input_preedit_string(void *data,
+                          struct zwp_text_input_v3 *zwp_text_input_v3,
+                          const char *text,
+                          int32_t cursor_begin,
+                          int32_t cursor_end)
+{
+    SDL_WaylandTextInput *text_input = data;
+    char buf[SDL_TEXTEDITINGEVENT_TEXT_SIZE];
+    text_input->has_preedit = SDL_TRUE;
+    if (text) {
+        size_t text_bytes = SDL_strlen(text), i = 0;
+        size_t cursor = 0;
+
+        do {
+            const size_t sz = SDL_utf8strlcpy(buf, text+i, sizeof(buf));
+            const size_t chars = SDL_utf8strlen(buf);
+
+            SDL_SendEditingText(buf, cursor, chars);
+
+            i += sz;
+            cursor += chars;
+        } while (i < text_bytes);
+    } else {
+        buf[0] = '\0';
+        SDL_SendEditingText(buf, 0, 0);
+    }
+}
+
+static void
+text_input_commit_string(void *data,
+                         struct zwp_text_input_v3 *zwp_text_input_v3,
+                         const char *text)
+{
+    if (text && *text) {
+        char buf[SDL_TEXTINPUTEVENT_TEXT_SIZE];
+        size_t text_bytes = SDL_strlen(text), i = 0;
+
+        while (i < text_bytes) {
+            size_t sz = SDL_utf8strlcpy(buf, text+i, sizeof(buf));
+            SDL_SendKeyboardText(buf);
+
+            i += sz;
+        }
+    }
+}
+
+static void
+text_input_delete_surrounding_text(void *data,
+                                   struct zwp_text_input_v3 *zwp_text_input_v3,
+                                   uint32_t before_length,
+                                   uint32_t after_length)
+{
+    /* FIXME: Do we care about this event? */
+}
+
+static void
+text_input_done(void *data,
+                struct zwp_text_input_v3 *zwp_text_input_v3,
+                uint32_t serial)
+{
+    SDL_WaylandTextInput *text_input = data;
+    if (!text_input->has_preedit) {
+        SDL_SendEditingText("", 0, 0);
+    }
+    text_input->has_preedit = SDL_FALSE;
+}
+
+static const struct zwp_text_input_v3_listener text_input_listener = {
+    text_input_enter,
+    text_input_leave,
+    text_input_preedit_string,
+    text_input_commit_string,
+    text_input_delete_surrounding_text,
+    text_input_done
+};
+
+static void
+Wayland_create_data_device(SDL_VideoData *d)
+{
+    SDL_WaylandDataDevice *data_device = NULL;
+
+    data_device = SDL_calloc(1, sizeof *data_device);
+    if (data_device == NULL) {
+        return;
+    }
+
+    data_device->data_device = wl_data_device_manager_get_data_device(
+        d->data_device_manager, d->input->seat
+    );
+    data_device->video_data = d;
+
+    if (data_device->data_device == NULL) {
+        SDL_free(data_device);
+    } else {
+        wl_data_device_set_user_data(data_device->data_device, data_device);
+        wl_data_device_add_listener(data_device->data_device,
+                                    &data_device_listener, data_device);
+        d->input->data_device = data_device;
+    }
+}
+
+static void
+Wayland_create_text_input(SDL_VideoData *d)
+{
+    SDL_WaylandTextInput *text_input = NULL;
+
+    text_input = SDL_calloc(1, sizeof *text_input);
+    if (text_input == NULL) {
+        return;
+    }
+
+    text_input->text_input = zwp_text_input_manager_v3_get_text_input(
+        d->text_input_manager, d->input->seat
+    );
+
+    if (text_input->text_input == NULL) {
+        SDL_free(text_input);
+    } else {
+        zwp_text_input_v3_set_user_data(text_input->text_input, text_input);
+        zwp_text_input_v3_add_listener(text_input->text_input,
+                                       &text_input_listener, text_input);
+        d->input->text_input = text_input;
+    }
+}
+
+void
+Wayland_add_data_device_manager(SDL_VideoData *d, uint32_t id, uint32_t version)
+{
+    d->data_device_manager = wl_registry_bind(d->registry, id, &wl_data_device_manager_interface, SDL_min(3, version));
+
+    if (d->input != NULL) {
+        Wayland_create_data_device(d);
+    }
+}
+
+void
+Wayland_add_text_input_manager(SDL_VideoData *d, uint32_t id, uint32_t version)
+{
+    d->text_input_manager = wl_registry_bind(d->registry, id, &zwp_text_input_manager_v3_interface, 1);
+
+    if (d->input != NULL) {
+        Wayland_create_text_input(d);
+    }
+}
+
 void
 Wayland_display_add_input(SDL_VideoData *d, uint32_t id, uint32_t version)
 {
     struct SDL_WaylandInput *input;
-    SDL_WaylandDataDevice *data_device = NULL;
 
     input = SDL_calloc(1, sizeof *input);
     if (input == NULL)
@@ -1099,24 +1662,10 @@ Wayland_display_add_input(SDL_VideoData *d, uint32_t id, uint32_t version)
     d->input = input;
 
     if (d->data_device_manager != NULL) {
-        data_device = SDL_calloc(1, sizeof *data_device);
-        if (data_device == NULL) {
-            return;
-        }
-
-        data_device->data_device = wl_data_device_manager_get_data_device(
-            d->data_device_manager, input->seat
-        );
-        data_device->video_data = d;
-
-        if (data_device->data_device == NULL) {
-            SDL_free(data_device);
-        } else {
-            wl_data_device_set_user_data(data_device->data_device, data_device);
-            wl_data_device_add_listener(data_device->data_device,
-                                        &data_device_listener, data_device);
-            input->data_device = data_device;
-        }
+        Wayland_create_data_device(d);
+    }
+    if (d->text_input_manager != NULL) {
+        Wayland_create_text_input(d);
     }
 
     wl_seat_add_listener(input->seat, &seat_listener, input);
@@ -1146,6 +1695,11 @@ void Wayland_display_destroy_input(SDL_VideoData *d)
         SDL_free(input->data_device);
     }
 
+    if (input->text_input != NULL) {
+        zwp_text_input_v3_destroy(input->text_input->text_input);
+        SDL_free(input->text_input);
+    }
+
     if (input->keyboard)
         wl_keyboard_destroy(input->keyboard);
 
@@ -1160,6 +1714,12 @@ void Wayland_display_destroy_input(SDL_VideoData *d)
     if (input->seat)
         wl_seat_destroy(input->seat);
 
+    if (input->xkb.compose_state)
+        WAYLAND_xkb_compose_state_unref(input->xkb.compose_state);
+
+    if (input->xkb.compose_table)
+        WAYLAND_xkb_compose_table_unref(input->xkb.compose_table);
+
     if (input->xkb.state)
         WAYLAND_xkb_state_unref(input->xkb.state);
 
@@ -1170,15 +1730,6 @@ void Wayland_display_destroy_input(SDL_VideoData *d)
     d->input = NULL;
 }
 
-SDL_WaylandDataDevice* Wayland_get_data_device(struct SDL_WaylandInput *input)
-{
-    if (input == NULL) {
-        return NULL;
-    }
-
-    return input->data_device;
-}
-
 /* !!! FIXME: just merge these into display_handle_global(). */
 void Wayland_display_add_relative_pointer_manager(SDL_VideoData *d, uint32_t id)
 {
@@ -1284,11 +1835,12 @@ lock_pointer_to_window(SDL_Window *window,
     w->locked_pointer = locked_pointer;
 }
 
-static void pointer_confine_destroy(struct SDL_WaylandInput *input)
+static void pointer_confine_destroy(SDL_Window *window)
 {
-    if (input->confined_pointer) {
-        zwp_confined_pointer_v1_destroy(input->confined_pointer);
-        input->confined_pointer = NULL;
+    SDL_WindowData *w = window->driverdata;
+    if (w->confined_pointer) {
+        zwp_confined_pointer_v1_destroy(w->confined_pointer);
+        w->confined_pointer = NULL;
     }
 }
 
@@ -1310,7 +1862,8 @@ int Wayland_input_lock_pointer(struct SDL_WaylandInput *input)
 
     /* If we have a pointer confine active, we must destroy it here because
      * creating a locked pointer otherwise would be a protocol error. */
-    pointer_confine_destroy(input);
+    for (window = vd->windows; window; window = window->next)
+        pointer_confine_destroy(window);
 
     if (!input->relative_pointer) {
         relative_pointer =
@@ -1350,8 +1903,8 @@ int Wayland_input_unlock_pointer(struct SDL_WaylandInput *input)
 
     d->relative_mouse_mode = 0;
 
-    if (input->confined_pointer_window)
-        Wayland_input_confine_pointer(input->confined_pointer_window, input);
+    for (window = vd->windows; window; window = window->next)
+        Wayland_input_confine_pointer(input, window);
 
     return 0;
 }
@@ -1373,11 +1926,12 @@ static const struct zwp_confined_pointer_v1_listener confined_pointer_listener =
     confined_pointer_unconfined,
 };
 
-int Wayland_input_confine_pointer(SDL_Window *window, struct SDL_WaylandInput *input)
+int Wayland_input_confine_pointer(struct SDL_WaylandInput *input, SDL_Window *window)
 {
     SDL_WindowData *w = window->driverdata;
     SDL_VideoData *d = input->display;
     struct zwp_confined_pointer_v1 *confined_pointer;
+    struct wl_region *confine_rect;
 
     if (!d->pointer_constraints)
         return -1;
@@ -1387,34 +1941,76 @@ int Wayland_input_confine_pointer(SDL_Window *window, struct SDL_WaylandInput *i
 
     /* A confine may already be active, in which case we should destroy it and
      * create a new one. */
-    if (input->confined_pointer)
-        Wayland_input_unconfine_pointer(input);
-
-    input->confined_pointer_window = window;
+    pointer_confine_destroy(window);
 
     /* We cannot create a confine if the pointer is already locked. Defer until
      * the pointer is unlocked. */
     if (d->relative_mouse_mode)
         return 0;
 
+    if (SDL_RectEmpty(&window->mouse_rect)) {
+        confine_rect = NULL;
+    } else {
+        confine_rect = wl_compositor_create_region(d->compositor);
+        wl_region_add(confine_rect,
+                      window->mouse_rect.x,
+                      window->mouse_rect.y,
+                      window->mouse_rect.w,
+                      window->mouse_rect.h);
+    }
+
     confined_pointer =
         zwp_pointer_constraints_v1_confine_pointer(d->pointer_constraints,
                                                    w->surface,
                                                    input->pointer,
-                                                   NULL,
+                                                   confine_rect,
                                                    ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_PERSISTENT);
     zwp_confined_pointer_v1_add_listener(confined_pointer,
                                          &confined_pointer_listener,
                                          window);
 
-    input->confined_pointer = confined_pointer;
+    if (confine_rect != NULL) {
+        wl_region_destroy(confine_rect);
+    }
+
+    w->confined_pointer = confined_pointer;
     return 0;
 }
 
-int Wayland_input_unconfine_pointer(struct SDL_WaylandInput *input)
+int Wayland_input_unconfine_pointer(struct SDL_WaylandInput *input, SDL_Window *window)
 {
-    pointer_confine_destroy(input);
-    input->confined_pointer_window = NULL;
+    pointer_confine_destroy(window);
+    return 0;
+}
+
+int Wayland_input_grab_keyboard(SDL_Window *window, struct SDL_WaylandInput *input)
+{
+    SDL_WindowData *w = window->driverdata;
+    SDL_VideoData *d = input->display;
+
+    if (!d->key_inhibitor_manager)
+        return -1;
+
+    if (w->key_inhibitor)
+        return 0;
+
+    w->key_inhibitor =
+        zwp_keyboard_shortcuts_inhibit_manager_v1_inhibit_shortcuts(d->key_inhibitor_manager,
+                                                                    w->surface,
+                                                                    input->seat);
+
+    return 0;
+}
+
+int Wayland_input_ungrab_keyboard(SDL_Window *window)
+{
+    SDL_WindowData *w = window->driverdata;
+
+    if (w->key_inhibitor) {
+        zwp_keyboard_shortcuts_inhibitor_v1_destroy(w->key_inhibitor);
+        w->key_inhibitor = NULL;
+    }
+
     return 0;
 }
 
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandevents_c.h b/Engine/lib/sdl/src/video/wayland/SDL_waylandevents_c.h
index 96aaa397f..24256a7d0 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandevents_c.h
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandevents_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -27,28 +27,86 @@
 #include "SDL_waylandvideo.h"
 #include "SDL_waylandwindow.h"
 #include "SDL_waylanddatamanager.h"
+#include "SDL_waylandkeyboard.h"
 
-struct SDL_WaylandInput;
+typedef struct {
+    // repeat_rate in range of [1, 1000]
+    int32_t repeat_rate;
+    int32_t repeat_delay;
+    SDL_bool is_initialized;
+
+    SDL_bool is_key_down;
+    uint32_t wl_press_time; // Key press time as reported by the Wayland API
+    uint32_t sdl_press_time; // Key press time expressed in SDL ticks
+    uint32_t next_repeat_ms;
+    uint32_t scancode;
+    char text[8];
+} SDL_WaylandKeyboardRepeat;
+
+struct SDL_WaylandInput {
+    SDL_VideoData *display;
+    struct wl_seat *seat;
+    struct wl_pointer *pointer;
+    struct wl_touch *touch;
+    struct wl_keyboard *keyboard;
+    SDL_WaylandDataDevice *data_device;
+    SDL_WaylandTextInput *text_input;
+    struct zwp_relative_pointer_v1 *relative_pointer;
+    SDL_WindowData *pointer_focus;
+    SDL_WindowData *keyboard_focus;
+    uint32_t pointer_enter_serial;
+
+    /* Last motion location */
+    wl_fixed_t sx_w;
+    wl_fixed_t sy_w;
+
+    double dx_frac;
+    double dy_frac;
+
+    struct {
+        struct xkb_keymap *keymap;
+        struct xkb_state *state;
+        struct xkb_compose_table *compose_table;
+        struct xkb_compose_state *compose_state;
+    } xkb;
+
+    /* information about axis events on current frame */
+    struct {
+        SDL_bool is_x_discrete;
+        float x;
+
+        SDL_bool is_y_discrete;
+        float y;
+    } pointer_curr_axis_info;
+
+    SDL_WaylandKeyboardRepeat keyboard_repeat;
+};
 
 extern void Wayland_PumpEvents(_THIS);
+extern void Wayland_SendWakeupEvent(_THIS, SDL_Window *window);
+extern int Wayland_WaitEventTimeout(_THIS, int timeout);
+
+extern void Wayland_add_data_device_manager(SDL_VideoData *d, uint32_t id, uint32_t version);
+extern void Wayland_add_text_input_manager(SDL_VideoData *d, uint32_t id, uint32_t version);
 
 extern void Wayland_display_add_input(SDL_VideoData *d, uint32_t id, uint32_t version);
 extern void Wayland_display_destroy_input(SDL_VideoData *d);
 
-extern SDL_WaylandDataDevice* Wayland_get_data_device(struct SDL_WaylandInput *input);
-
 extern void Wayland_display_add_pointer_constraints(SDL_VideoData *d, uint32_t id);
 extern void Wayland_display_destroy_pointer_constraints(SDL_VideoData *d);
 
 extern int Wayland_input_lock_pointer(struct SDL_WaylandInput *input);
 extern int Wayland_input_unlock_pointer(struct SDL_WaylandInput *input);
 
-extern int Wayland_input_confine_pointer(SDL_Window *window, struct SDL_WaylandInput *input);
-extern int Wayland_input_unconfine_pointer(struct SDL_WaylandInput *input);
+extern int Wayland_input_confine_pointer(struct SDL_WaylandInput *input, SDL_Window *window);
+extern int Wayland_input_unconfine_pointer(struct SDL_WaylandInput *input, SDL_Window *window);
 
 extern void Wayland_display_add_relative_pointer_manager(SDL_VideoData *d, uint32_t id);
 extern void Wayland_display_destroy_relative_pointer_manager(SDL_VideoData *d);
 
+extern int Wayland_input_grab_keyboard(SDL_Window *window, struct SDL_WaylandInput *input);
+extern int Wayland_input_ungrab_keyboard(SDL_Window *window);
+
 #endif /* SDL_waylandevents_h_ */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandkeyboard.c b/Engine/lib/sdl/src/video/wayland/SDL_waylandkeyboard.c
new file mode 100644
index 000000000..ad91ca5c4
--- /dev/null
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandkeyboard.c
@@ -0,0 +1,154 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if SDL_VIDEO_DRIVER_WAYLAND
+
+#include "../SDL_sysvideo.h"
+#include "SDL_waylandvideo.h"
+#include "SDL_waylandevents_c.h"
+#include "text-input-unstable-v3-client-protocol.h"
+
+int
+Wayland_InitKeyboard(_THIS)
+{
+#ifdef SDL_USE_IME
+    SDL_VideoData *driverdata = _this->driverdata;
+    if (driverdata->text_input_manager == NULL) {
+        SDL_IME_Init();
+    }
+#endif
+
+    return 0;
+}
+
+void
+Wayland_QuitKeyboard(_THIS)
+{
+#ifdef SDL_USE_IME
+    SDL_VideoData *driverdata = _this->driverdata;
+    if (driverdata->text_input_manager == NULL) {
+        SDL_IME_Quit();
+    }
+#endif
+}
+
+void
+Wayland_StartTextInput(_THIS)
+{
+    SDL_VideoData *driverdata = _this->driverdata;
+
+    if (driverdata->text_input_manager) {
+        struct SDL_WaylandInput *input = driverdata->input;
+        if (input != NULL && input->text_input) {
+            const SDL_Rect *rect = &input->text_input->cursor_rect;
+
+            /* For some reason this has to be done twice, it appears to be a
+             * bug in mutter? Maybe?
+             * -flibit
+             */
+            zwp_text_input_v3_enable(input->text_input->text_input);
+            zwp_text_input_v3_commit(input->text_input->text_input);
+            zwp_text_input_v3_enable(input->text_input->text_input);
+            zwp_text_input_v3_commit(input->text_input->text_input);
+
+            /* Now that it's enabled, set the input properties */
+            zwp_text_input_v3_set_content_type(input->text_input->text_input,
+                                               ZWP_TEXT_INPUT_V3_CONTENT_HINT_NONE,
+                                               ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_NORMAL);
+            if (!SDL_RectEmpty(rect)) {
+                /* This gets reset on enable so we have to cache it */
+                zwp_text_input_v3_set_cursor_rectangle(input->text_input->text_input,
+                                                       rect->x,
+                                                       rect->y,
+                                                       rect->w,
+                                                       rect->h);
+            }
+            zwp_text_input_v3_commit(input->text_input->text_input);
+        }
+    }
+}
+
+void
+Wayland_StopTextInput(_THIS)
+{
+    SDL_VideoData *driverdata = _this->driverdata;
+
+    if (driverdata->text_input_manager) {
+        struct SDL_WaylandInput *input = driverdata->input;
+        if (input != NULL && input->text_input) {
+            zwp_text_input_v3_disable(input->text_input->text_input);
+            zwp_text_input_v3_commit(input->text_input->text_input);
+        }
+    }
+
+#ifdef SDL_USE_IME
+    else {
+        SDL_IME_Reset();
+    }
+#endif
+}
+
+void
+Wayland_SetTextInputRect(_THIS, SDL_Rect *rect)
+{
+    SDL_VideoData *driverdata = _this->driverdata;
+
+    if (!rect) {
+        SDL_InvalidParamError("rect");
+        return;
+    }
+
+    if (driverdata->text_input_manager) {
+        struct SDL_WaylandInput *input = driverdata->input;
+        if (input != NULL && input->text_input) {
+            SDL_memcpy(&input->text_input->cursor_rect, rect, sizeof(SDL_Rect));
+            zwp_text_input_v3_set_cursor_rectangle(input->text_input->text_input,
+                                                   rect->x,
+                                                   rect->y,
+                                                   rect->w,
+                                                   rect->h);
+            zwp_text_input_v3_commit(input->text_input->text_input);
+        }
+    }
+
+#ifdef SDL_USE_IME
+    else {
+        SDL_IME_UpdateTextRect(rect);
+    }
+#endif
+}
+
+SDL_bool
+Wayland_HasScreenKeyboardSupport(_THIS)
+{
+    /* In reality we just want to return true when the screen keyboard is the
+     * _only_ way to get text input. So, in addition to checking for the text
+     * input protocol, make sure we don't have any physical keyboards either.
+     */
+    SDL_VideoData *driverdata = _this->driverdata;
+    return (driverdata->input->keyboard == NULL &&
+            driverdata->text_input_manager != NULL);
+}
+
+#endif /* SDL_VIDEO_DRIVER_WAYLAND */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandkeyboard.h b/Engine/lib/sdl/src/video/wayland/SDL_waylandkeyboard.h
new file mode 100644
index 000000000..604e0f37f
--- /dev/null
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandkeyboard.h
@@ -0,0 +1,42 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#ifndef SDL_waylandkeyboard_h_
+#define SDL_waylandkeyboard_h_
+
+typedef struct SDL_WaylandTextInput
+{
+    struct zwp_text_input_v3 *text_input;
+    SDL_Rect cursor_rect;
+    SDL_bool has_preedit;
+} SDL_WaylandTextInput;
+
+extern int Wayland_InitKeyboard(_THIS);
+extern void Wayland_QuitKeyboard(_THIS);
+extern void Wayland_StartTextInput(_THIS);
+extern void Wayland_StopTextInput(_THIS);
+extern void Wayland_SetTextInputRect(_THIS, SDL_Rect *rect);
+extern SDL_bool Wayland_HasScreenKeyboardSupport(_THIS);
+
+#endif /* SDL_waylandkeyboard_h_ */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandmessagebox.c b/Engine/lib/sdl/src/video/wayland/SDL_waylandmessagebox.c
new file mode 100644
index 000000000..e81f0e64c
--- /dev/null
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandmessagebox.c
@@ -0,0 +1,195 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "../../SDL_internal.h"
+
+#if SDL_VIDEO_DRIVER_WAYLAND
+
+#include "SDL.h"
+#include <stdlib.h> /* fgets */
+#include <stdio.h> /* FILE, STDOUT_FILENO, fdopen, fclose */
+#include <unistd.h> /* pid_t, pipe, fork, close, dup2, execvp, _exit */
+#include <sys/wait.h> /* waitpid, WIFEXITED, WEXITSTATUS */
+#include <string.h> /* strerr */
+#include <errno.h>
+
+#include "SDL_waylandmessagebox.h"
+
+#define MAX_BUTTONS             8       /* Maximum number of buttons supported */
+
+int
+Wayland_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid)
+{
+    int fd_pipe[2]; /* fd_pipe[0]: read end of pipe, fd_pipe[1]: write end of pipe */
+    pid_t pid1;
+
+    if (messageboxdata->numbuttons > MAX_BUTTONS) {
+        return SDL_SetError("Too many buttons (%d max allowed)", MAX_BUTTONS);
+    }
+
+    if (pipe(fd_pipe) != 0) { /* create a pipe */
+        return SDL_SetError("pipe() failed: %s", strerror(errno));
+    }
+
+    pid1 = fork();
+    if (pid1 == 0) {  /* child process */
+        int argc = 5, i;
+        const char* argv[5 + 2/* icon name */ + 2/* title */ + 2/* message */ + 2*MAX_BUTTONS + 1/* NULL */] = {
+            "zenity", "--question", "--switch", "--no-wrap", "--no-markup"
+        };
+
+        close(fd_pipe[0]); /* no reading from pipe */
+        /* write stdout in pipe */
+        if (dup2(fd_pipe[1], STDOUT_FILENO) == -1) {
+            _exit(128);
+        }
+
+        argv[argc++] = "--icon-name";
+        switch (messageboxdata->flags) {
+        case SDL_MESSAGEBOX_ERROR:
+            argv[argc++] = "dialog-error";
+            break;
+        case SDL_MESSAGEBOX_WARNING:
+            argv[argc++] = "dialog-warning";
+            break;
+        case SDL_MESSAGEBOX_INFORMATION:
+        default:
+            argv[argc++] = "dialog-information";
+            break;
+        }
+
+        if (messageboxdata->title && messageboxdata->title[0]) {
+            argv[argc++] = "--title";
+            argv[argc++] = messageboxdata->title;
+        } else {
+            argv[argc++] = "--title=\"\"";
+        }
+
+        if (messageboxdata->message && messageboxdata->message[0]) {
+            argv[argc++] = "--text";
+            argv[argc++] = messageboxdata->message;
+        } else {
+            argv[argc++] = "--text=\"\"";
+        }
+
+        for (i = 0; i < messageboxdata->numbuttons; ++i) {
+            if (messageboxdata->buttons[i].text && messageboxdata->buttons[i].text[0]) {
+                argv[argc++] = "--extra-button";
+                argv[argc++] = messageboxdata->buttons[i].text;
+            } else {
+                argv[argc++] = "--extra-button=\"\"";
+            }
+        }
+        argv[argc] = NULL;
+
+        /* const casting argv is fine:
+         * https://pubs.opengroup.org/onlinepubs/9699919799/functions/fexecve.html -> rational
+         */
+        execvp("zenity", (char **)argv);
+        _exit(129);
+    } else if (pid1 < 0) {
+        close(fd_pipe[0]);
+        close(fd_pipe[1]);
+        return SDL_SetError("fork() failed: %s", strerror(errno));
+    } else {
+        int status;
+        if (waitpid(pid1, &status, 0) == pid1) {
+            if (WIFEXITED(status)) {
+                if (WEXITSTATUS(status) < 128) {
+                    int i;
+                    size_t output_len = 1;
+                    char* output = NULL;
+                    char* tmp = NULL;
+                    FILE* stdout = NULL;
+
+                    close(fd_pipe[1]); /* no writing to pipe */
+                    /* At this point, if no button ID is needed, we can just bail as soon as the
+                     * process has completed.
+                     */
+                    if (buttonid == NULL) {
+                        close(fd_pipe[0]);
+                        return 0;
+                    }
+                    *buttonid = -1;
+
+                    /* find button with longest text */
+                    for (i = 0; i < messageboxdata->numbuttons; ++i) {
+                        if (messageboxdata->buttons[i].text != NULL) {
+                            const size_t button_len = SDL_strlen(messageboxdata->buttons[i].text);
+                            if (button_len > output_len) {
+                                output_len = button_len;
+                            }
+                        }
+                    }
+                    output = SDL_malloc(output_len + 1);
+                    if (!output) {
+                        close(fd_pipe[0]);
+                        return SDL_OutOfMemory();
+                    }
+                    output[0] = '\0';
+
+                    stdout = fdopen(fd_pipe[0], "r");
+                    if (!stdout) {
+                        SDL_free(output);
+                        close(fd_pipe[0]);
+                        return SDL_SetError("Couldn't open pipe for reading: %s", strerror(errno));
+                    }
+                    tmp = fgets(output, output_len + 1, stdout);
+                    fclose(stdout);
+
+                    if ((tmp == NULL) || (*tmp == '\0') || (*tmp == '\n')) {
+                        SDL_free(output);
+                        return 0; /* User simply closed the dialog */
+                    }
+
+                    /* It likes to add a newline... */
+                    tmp = SDL_strrchr(output, '\n');
+                    if (tmp != NULL) {
+                        *tmp = '\0';
+                    }
+
+                    /* Check which button got pressed */
+                    for (i = 0; i < messageboxdata->numbuttons; i += 1) {
+                        if (messageboxdata->buttons[i].text != NULL) {
+                            if (SDL_strcmp(output, messageboxdata->buttons[i].text) == 0) {
+                                *buttonid = messageboxdata->buttons[i].buttonid;
+                                break;
+                            }
+                        }
+                    }
+
+                    SDL_free(output);
+                    return 0;  /* success! */
+                } else {
+                    return SDL_SetError("zenity reported error or failed to launch: %d", WEXITSTATUS(status));
+                }
+            } else {
+                return SDL_SetError("zenity failed for some reason");
+            }
+        } else {
+            return SDL_SetError("Waiting on zenity failed: %s", strerror(errno));
+        }
+    }
+}
+
+#endif /* SDL_VIDEO_DRIVER_WAYLAND */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandmessagebox.h b/Engine/lib/sdl/src/video/wayland/SDL_waylandmessagebox.h
new file mode 100644
index 000000000..7404520a7
--- /dev/null
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandmessagebox.h
@@ -0,0 +1,33 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_waylandmessagebox_h_
+#define SDL_waylandmessagebox_h_
+
+#if SDL_VIDEO_DRIVER_WAYLAND
+
+extern int Wayland_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid);
+
+#endif /* SDL_VIDEO_DRIVER_WAYLAND */
+
+#endif /* SDL_waylandmessagebox_h_ */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandmouse.c b/Engine/lib/sdl/src/video/wayland/SDL_waylandmouse.c
index 560f98e60..4545c663d 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandmouse.c
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandmouse.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -27,7 +27,6 @@
 #include <sys/mman.h>
 #include <fcntl.h>
 #include <unistd.h>
-#include <stdlib.h>
 #include <limits.h>
 
 #include "../SDL_sysvideo.h"
@@ -35,11 +34,11 @@
 #include "SDL_mouse.h"
 #include "../../events/SDL_mouse_c.h"
 #include "SDL_waylandvideo.h"
+#include "../SDL_pixels_c.h"
 #include "SDL_waylandevents_c.h"
 
-#include "SDL_waylanddyn.h"
 #include "wayland-cursor.h"
-
+#include "SDL_waylandmouse.h"
 
 
 typedef struct {
@@ -49,11 +48,120 @@ typedef struct {
     int                hot_x, hot_y;
     int                w, h;
 
-    /* Either a preloaded cursor, or one we created ourselves */
-    struct wl_cursor   *cursor;
+    /* shm_data is non-NULL for custom cursors.
+     * When shm_data is NULL, system_cursor must be valid
+     */
+    SDL_SystemCursor    system_cursor;
     void               *shm_data;
 } Wayland_CursorData;
 
+static SDL_bool
+wayland_get_system_cursor(SDL_VideoData *vdata, Wayland_CursorData *cdata, float *scale)
+{
+    struct wl_cursor_theme *theme = NULL;
+    struct wl_cursor *cursor;
+
+    char *xcursor_size;
+    int size = 0;
+
+    SDL_Window *focus;
+    SDL_WindowData *focusdata;
+    int i;
+
+    /* FIXME: We need to be able to query the cursor size from the desktop at
+     * some point! For a while this was 32, but when testing on real desktops it
+     * seems like most of them default to 24. We'll need a protocol to get this
+     * for real, but for now this is a pretty safe bet.
+     * -flibit
+     */
+    xcursor_size = SDL_getenv("XCURSOR_SIZE");
+    if (xcursor_size != NULL) {
+        size = SDL_atoi(xcursor_size);
+    }
+    if (size <= 0) {
+        size = 24;
+    }
+
+    /* First, find the appropriate theme based on the current scale... */
+    focus = SDL_GetMouse()->focus;
+    if (focus == NULL) {
+        /* Nothing to see here, bail. */
+        return SDL_FALSE;
+    }
+    focusdata = focus->driverdata;
+    *scale = focusdata->scale_factor;
+    size *= focusdata->scale_factor;
+    for (i = 0; i < vdata->num_cursor_themes; i += 1) {
+        if (vdata->cursor_themes[i].size == size) {
+            theme = vdata->cursor_themes[i].theme;
+            break;
+        }
+    }
+    if (theme == NULL) {
+        vdata->cursor_themes = SDL_realloc(vdata->cursor_themes,
+                                           sizeof(SDL_WaylandCursorTheme) * (vdata->num_cursor_themes + 1));
+        if (vdata->cursor_themes == NULL) {
+            SDL_OutOfMemory();
+            return SDL_FALSE;
+        }
+        theme = WAYLAND_wl_cursor_theme_load(SDL_getenv("XCURSOR_THEME"), size, vdata->shm);
+        vdata->cursor_themes[vdata->num_cursor_themes].size = size;
+        vdata->cursor_themes[vdata->num_cursor_themes++].theme = theme;
+    }
+
+    /* Next, find the cursor from the theme... */
+    switch(cdata->system_cursor)
+    {
+    case SDL_SYSTEM_CURSOR_ARROW:
+        cursor = WAYLAND_wl_cursor_theme_get_cursor(theme, "left_ptr");
+        break;
+    case SDL_SYSTEM_CURSOR_IBEAM:
+        cursor = WAYLAND_wl_cursor_theme_get_cursor(theme, "xterm");
+        break;
+    case SDL_SYSTEM_CURSOR_WAIT:
+        cursor = WAYLAND_wl_cursor_theme_get_cursor(theme, "watch");
+        break;
+    case SDL_SYSTEM_CURSOR_CROSSHAIR:
+        cursor = WAYLAND_wl_cursor_theme_get_cursor(theme, "hand1");
+        break;
+    case SDL_SYSTEM_CURSOR_WAITARROW:
+        cursor = WAYLAND_wl_cursor_theme_get_cursor(theme, "watch");
+        break;
+    case SDL_SYSTEM_CURSOR_SIZENWSE:
+        cursor = WAYLAND_wl_cursor_theme_get_cursor(theme, "hand1");
+        break;
+    case SDL_SYSTEM_CURSOR_SIZENESW:
+        cursor = WAYLAND_wl_cursor_theme_get_cursor(theme, "hand1");
+        break;
+    case SDL_SYSTEM_CURSOR_SIZEWE:
+        cursor = WAYLAND_wl_cursor_theme_get_cursor(theme, "hand1");
+        break;
+    case SDL_SYSTEM_CURSOR_SIZENS:
+        cursor = WAYLAND_wl_cursor_theme_get_cursor(theme, "hand1");
+        break;
+    case SDL_SYSTEM_CURSOR_SIZEALL:
+        cursor = WAYLAND_wl_cursor_theme_get_cursor(theme, "hand1");
+        break;
+    case SDL_SYSTEM_CURSOR_NO:
+        cursor = WAYLAND_wl_cursor_theme_get_cursor(theme, "xterm");
+        break;
+    case SDL_SYSTEM_CURSOR_HAND:
+        cursor = WAYLAND_wl_cursor_theme_get_cursor(theme, "hand1");
+        break;
+    default:
+        SDL_assert(0);
+        return SDL_FALSE;
+    }
+
+    /* ... Set the cursor data, finally. */
+    cdata->buffer = WAYLAND_wl_cursor_image_get_buffer(cursor->images[0]);
+    cdata->hot_x = cursor->images[0]->hotspot_x;
+    cdata->hot_y = cursor->images[0]->hotspot_y;
+    cdata->w = cursor->images[0]->width;
+    cdata->h = cursor->images[0]->height;
+    return SDL_TRUE;
+}
+
 static int
 wayland_create_tmp_file(off_t size)
 {
@@ -148,36 +256,33 @@ Wayland_CreateCursor(SDL_Surface *surface, int hot_x, int hot_y)
 {
     SDL_Cursor *cursor;
 
-    cursor = calloc(1, sizeof (*cursor));
+    cursor = SDL_calloc(1, sizeof (*cursor));
     if (cursor) {
         SDL_VideoDevice *vd = SDL_GetVideoDevice ();
         SDL_VideoData *wd = (SDL_VideoData *) vd->driverdata;
-        Wayland_CursorData *data = calloc (1, sizeof (Wayland_CursorData));
+        Wayland_CursorData *data = SDL_calloc (1, sizeof (Wayland_CursorData));
         if (!data) {
             SDL_OutOfMemory();
-            free(cursor);
+            SDL_free(cursor);
             return NULL;
         }
         cursor->driverdata = (void *) data;
 
-        /* Assume ARGB8888 */
-        SDL_assert(surface->format->format == SDL_PIXELFORMAT_ARGB8888);
-        SDL_assert(surface->pitch == surface->w * 4);
-
         /* Allocate shared memory buffer for this cursor */
         if (create_buffer_from_shm (data,
                                     surface->w,
                                     surface->h,
                                     WL_SHM_FORMAT_ARGB8888) < 0)
         {
-            free (cursor->driverdata);
-            free (cursor);
+            SDL_free (cursor->driverdata);
+            SDL_free (cursor);
             return NULL;
         }
 
-        SDL_memcpy(data->shm_data,
-                   surface->pixels,
-                   surface->h * surface->pitch);
+        /* Wayland requires premultiplied alpha for its surfaces. */
+        SDL_PremultiplyAlpha(surface->w, surface->h,
+                             surface->format->format, surface->pixels, surface->pitch,
+                             SDL_PIXELFORMAT_ARGB8888, data->shm_data, surface->w * 4);
 
         data->surface = wl_compositor_create_surface(wd->compositor);
         wl_surface_set_user_data(data->surface, NULL);
@@ -194,30 +299,30 @@ Wayland_CreateCursor(SDL_Surface *surface, int hot_x, int hot_y)
 }
 
 static SDL_Cursor *
-CreateCursorFromWlCursor(SDL_VideoData *d, struct wl_cursor *wlcursor)
+Wayland_CreateSystemCursor(SDL_SystemCursor id)
 {
+    SDL_VideoData *data = SDL_GetVideoDevice()->driverdata;
     SDL_Cursor *cursor;
 
-    cursor = calloc(1, sizeof (*cursor));
+    cursor = SDL_calloc(1, sizeof (*cursor));
     if (cursor) {
-        Wayland_CursorData *data = calloc (1, sizeof (Wayland_CursorData));
-        if (!data) {
+        Wayland_CursorData *cdata = SDL_calloc (1, sizeof (Wayland_CursorData));
+        if (!cdata) {
             SDL_OutOfMemory();
-            free(cursor);
+            SDL_free(cursor);
             return NULL;
         }
-        cursor->driverdata = (void *) data;
+        cursor->driverdata = (void *) cdata;
 
-        data->buffer = WAYLAND_wl_cursor_image_get_buffer(wlcursor->images[0]);
-        data->surface = wl_compositor_create_surface(d->compositor);
-        wl_surface_set_user_data(data->surface, NULL);
-        data->hot_x = wlcursor->images[0]->hotspot_x;
-        data->hot_y = wlcursor->images[0]->hotspot_y;
-        data->w = wlcursor->images[0]->width;
-        data->h = wlcursor->images[0]->height;
-        data->cursor= wlcursor;
+        cdata->surface = wl_compositor_create_surface(data->compositor);
+        wl_surface_set_user_data(cdata->surface, NULL);
+
+        /* Note that we can't actually set any other cursor properties, as this
+         * is output-specific. See wayland_get_system_cursor for the rest!
+         */
+        cdata->system_cursor = id;
     } else {
-        SDL_OutOfMemory ();
+        SDL_OutOfMemory();
     }
 
     return cursor;
@@ -226,66 +331,7 @@ CreateCursorFromWlCursor(SDL_VideoData *d, struct wl_cursor *wlcursor)
 static SDL_Cursor *
 Wayland_CreateDefaultCursor()
 {
-    SDL_VideoDevice *device = SDL_GetVideoDevice();
-    SDL_VideoData *data = device->driverdata;
-
-    return CreateCursorFromWlCursor (data,
-                                     WAYLAND_wl_cursor_theme_get_cursor(data->cursor_theme,
-                                                                "left_ptr"));
-}
-
-static SDL_Cursor *
-Wayland_CreateSystemCursor(SDL_SystemCursor id)
-{
-    SDL_VideoDevice *vd = SDL_GetVideoDevice();
-    SDL_VideoData *d = vd->driverdata;
-
-    struct wl_cursor *cursor = NULL;
-
-    switch(id)
-    {
-    default:
-        SDL_assert(0);
-        return NULL;
-    case SDL_SYSTEM_CURSOR_ARROW:
-        cursor = WAYLAND_wl_cursor_theme_get_cursor(d->cursor_theme, "left_ptr");
-        break;
-    case SDL_SYSTEM_CURSOR_IBEAM:
-        cursor = WAYLAND_wl_cursor_theme_get_cursor(d->cursor_theme, "xterm");
-        break;
-    case SDL_SYSTEM_CURSOR_WAIT:
-        cursor = WAYLAND_wl_cursor_theme_get_cursor(d->cursor_theme, "watch");
-        break;
-    case SDL_SYSTEM_CURSOR_CROSSHAIR:
-        cursor = WAYLAND_wl_cursor_theme_get_cursor(d->cursor_theme, "hand1");
-        break;
-    case SDL_SYSTEM_CURSOR_WAITARROW:
-        cursor = WAYLAND_wl_cursor_theme_get_cursor(d->cursor_theme, "watch");
-        break;
-    case SDL_SYSTEM_CURSOR_SIZENWSE:
-        cursor = WAYLAND_wl_cursor_theme_get_cursor(d->cursor_theme, "hand1");
-        break;
-    case SDL_SYSTEM_CURSOR_SIZENESW:
-        cursor = WAYLAND_wl_cursor_theme_get_cursor(d->cursor_theme, "hand1");
-        break;
-    case SDL_SYSTEM_CURSOR_SIZEWE:
-        cursor = WAYLAND_wl_cursor_theme_get_cursor(d->cursor_theme, "hand1");
-        break;
-    case SDL_SYSTEM_CURSOR_SIZENS:
-        cursor = WAYLAND_wl_cursor_theme_get_cursor(d->cursor_theme, "hand1");
-        break;
-    case SDL_SYSTEM_CURSOR_SIZEALL:
-        cursor = WAYLAND_wl_cursor_theme_get_cursor(d->cursor_theme, "hand1");
-        break;
-    case SDL_SYSTEM_CURSOR_NO:
-        cursor = WAYLAND_wl_cursor_theme_get_cursor(d->cursor_theme, "xterm");
-        break;
-    case SDL_SYSTEM_CURSOR_HAND:
-        cursor = WAYLAND_wl_cursor_theme_get_cursor(d->cursor_theme, "hand1");
-        break;
-    }
-
-    return CreateCursorFromWlCursor(d, cursor);
+    return Wayland_CreateSystemCursor(SDL_SYSTEM_CURSOR_ARROW);
 }
 
 static void
@@ -302,14 +348,14 @@ Wayland_FreeCursor(SDL_Cursor *cursor)
     if (!d)
         return;
 
-    if (d->buffer && !d->cursor)
+    if (d->buffer && d->shm_data)
         wl_buffer_destroy(d->buffer);
 
     if (d->surface)
         wl_surface_destroy(d->surface);
 
     /* Not sure what's meant to happen to shm_data */
-    free (cursor->driverdata);
+    SDL_free(cursor->driverdata);
     SDL_free(cursor);
 }
 
@@ -318,8 +364,9 @@ Wayland_ShowCursor(SDL_Cursor *cursor)
 {
     SDL_VideoDevice *vd = SDL_GetVideoDevice();
     SDL_VideoData *d = vd->driverdata;
-
+    struct SDL_WaylandInput *input = d->input;
     struct wl_pointer *pointer = d->pointer;
+    float scale = 1.0f;
 
     if (!pointer)
         return -1;
@@ -328,20 +375,26 @@ Wayland_ShowCursor(SDL_Cursor *cursor)
     {
         Wayland_CursorData *data = cursor->driverdata;
 
-        wl_pointer_set_cursor (pointer, 0,
-                               data->surface,
-                               data->hot_x,
-                               data->hot_y);
+        /* TODO: High-DPI custom cursors? -flibit */
+        if (data->shm_data == NULL) {
+            if (!wayland_get_system_cursor(d, data, &scale)) {
+                return -1;
+            }
+        }
+
+        wl_surface_set_buffer_scale(data->surface, scale);
+        wl_pointer_set_cursor(pointer,
+                              input->pointer_enter_serial,
+                              data->surface,
+                              data->hot_x / scale,
+                              data->hot_y / scale);
         wl_surface_attach(data->surface, data->buffer, 0, 0);
         wl_surface_damage(data->surface, 0, 0, data->w, data->h);
         wl_surface_commit(data->surface);
     }
     else
     {
-        wl_pointer_set_cursor (pointer, 0,
-                               NULL,
-                               0,
-                               0);
+        wl_pointer_set_cursor(pointer, input->pointer_enter_serial, NULL, 0, 0);
     }
     
     return 0;
@@ -388,10 +441,15 @@ Wayland_InitMouse(void)
 }
 
 void
-Wayland_FiniMouse(void)
+Wayland_FiniMouse(SDL_VideoData *data)
 {
-    /* This effectively assumes that nobody else
-     * touches SDL_Mouse which is effectively
-     * a singleton */
+    int i;
+    for (i = 0; i < data->num_cursor_themes; i += 1) {
+        WAYLAND_wl_cursor_theme_destroy(data->cursor_themes[i].theme);
+    }
+    SDL_free(data->cursor_themes);
 }
+
 #endif  /* SDL_VIDEO_DRIVER_WAYLAND */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandmouse.h b/Engine/lib/sdl/src/video/wayland/SDL_waylandmouse.h
index 95ff7195a..76b58b5c2 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandmouse.h
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandmouse.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -26,6 +26,6 @@
 #if SDL_VIDEO_DRIVER_WAYLAND
 
 extern void Wayland_InitMouse(void);
-extern void Wayland_FiniMouse(void);
+extern void Wayland_FiniMouse(SDL_VideoData *data);
 
 #endif
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandopengles.c b/Engine/lib/sdl/src/video/wayland/SDL_waylandopengles.c
index b5771e0b8..6b10cbee7 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandopengles.c
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandopengles.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -22,16 +22,16 @@
 
 #if SDL_VIDEO_DRIVER_WAYLAND && SDL_VIDEO_OPENGL_EGL
 
+#include "SDL_timer.h"
+#include "../../core/unix/SDL_poll.h"
 #include "../SDL_sysvideo.h"
 #include "../../events/SDL_windowevents_c.h"
 #include "SDL_waylandvideo.h"
 #include "SDL_waylandopengles.h"
 #include "SDL_waylandwindow.h"
 #include "SDL_waylandevents_c.h"
-#include "SDL_waylanddyn.h"
 
 #include "xdg-shell-client-protocol.h"
-#include "xdg-shell-unstable-v6-client-protocol.h"
 
 /* EGL implementation of SDL OpenGL ES support */
 
@@ -39,12 +39,12 @@ int
 Wayland_GLES_LoadLibrary(_THIS, const char *path) {
     int ret;
     SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
-    
+
     ret = SDL_EGL_LoadLibrary(_this, path, (NativeDisplayType) data->display, 0);
 
     Wayland_PumpEvents(_this);
     WAYLAND_wl_display_flush(data->display);
-    
+
     return ret;
 }
 
@@ -55,21 +55,123 @@ Wayland_GLES_CreateContext(_THIS, SDL_Window * window)
     SDL_GLContext context;
     context = SDL_EGL_CreateContext(_this, ((SDL_WindowData *) window->driverdata)->egl_surface);
     WAYLAND_wl_display_flush( ((SDL_VideoData*)_this->driverdata)->display );
-    
+
     return context;
 }
 
+/* Wayland wants to tell you when to provide new frames, and if you have a non-zero
+   swap interval, Mesa will block until a callback tells it to do so. On some
+   compositors, they might decide that a minimized window _never_ gets a callback,
+   which causes apps to hang during swapping forever. So we always set the official
+   eglSwapInterval to zero to avoid blocking inside EGL, and manage this ourselves.
+   If a swap blocks for too long waiting on a callback, we just go on, under the
+   assumption the frame will be wasted, but this is better than freezing the app.
+   I frown upon platforms that dictate this sort of control inversion (the callback
+   is intended for _rendering_, not stalling until vsync), but we can work around
+   this for now.  --ryan. */
+/* Addendum: several recent APIs demand this sort of control inversion: Emscripten,
+   libretro, Wayland, probably others...it feels like we're eventually going to have
+   to give in with a future SDL API revision, since we can bend the other APIs to
+   this style, but this style is much harder to bend the other way.  :/ */
+int
+Wayland_GLES_SetSwapInterval(_THIS, int interval)
+{
+    if (!_this->egl_data) {
+        return SDL_SetError("EGL not initialized");
+    }
+    
+    /* technically, this is _all_ adaptive vsync (-1), because we can't
+       actually wait for the _next_ vsync if you set 1, but things that
+       request 1 probably won't care _that_ much. I hope. No matter what
+       you do, though, you never see tearing on Wayland. */
+    if (interval > 1) {
+        interval = 1;
+    } else if (interval < -1) {
+        interval = -1;
+    }
+
+    /* !!! FIXME: technically, this should be per-context, right? */
+    _this->egl_data->egl_swapinterval = interval;
+    _this->egl_data->eglSwapInterval(_this->egl_data->egl_display, 0);
+    return 0;
+}
+
+int
+Wayland_GLES_GetSwapInterval(_THIS)
+{
+    if (!_this->egl_data) {
+        SDL_SetError("EGL not initialized");
+        return 0;
+    }
+
+    return _this->egl_data->egl_swapinterval;
+}
+
 int
 Wayland_GLES_SwapWindow(_THIS, SDL_Window *window)
 {
     SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
+    const int swap_interval = _this->egl_data->egl_swapinterval;
 
-    if (SDL_EGL_SwapBuffers(_this, data->egl_surface) < 0) {
-        return -1;
+    /* For windows that we know are hidden, skip swaps entirely, if we don't do
+     * this compositors will intentionally stall us indefinitely and there's no
+     * way for an end user to show the window, unlike other situations (i.e.
+     * the window is minimized, behind another window, etc.).
+     *
+     * FIXME: Request EGL_WAYLAND_swap_buffers_with_timeout.
+     * -flibit
+     */
+    if (window->flags & SDL_WINDOW_HIDDEN) {
+        return 0;
     }
 
-    // Wayland-EGL forbids drawing calls in-between SwapBuffers and wl_egl_window_resize
-    Wayland_HandlePendingResize(window);
+    /* Control swap interval ourselves. See comments on Wayland_GLES_SetSwapInterval */
+    if (swap_interval != 0) {
+        SDL_VideoData *videodata = (SDL_VideoData *)_this->driverdata;
+        struct wl_display *display = videodata->display;
+        SDL_VideoDisplay *sdldisplay = SDL_GetDisplayForWindow(window);
+        /* ~10 frames (or 1 sec), so we'll progress even if throttled to zero. */
+        const Uint32 max_wait = SDL_GetTicks() + (sdldisplay->current_mode.refresh_rate ?
+                                                  (10000 / sdldisplay->current_mode.refresh_rate) : 1000);
+        while (SDL_AtomicGet(&data->swap_interval_ready) == 0) {
+            Uint32 now;
+
+            WAYLAND_wl_display_flush(display);
+
+            /* wl_display_prepare_read_queue() will return -1 if the event queue is not empty.
+             * If the event queue is empty, it will prepare us for our SDL_IOReady() call. */
+            if (WAYLAND_wl_display_prepare_read_queue(display, data->frame_event_queue) != 0) {
+                /* We have some pending events. Check if the frame callback happened. */
+                WAYLAND_wl_display_dispatch_queue_pending(display, data->frame_event_queue);
+                continue;
+            }
+
+            /* Beyond this point, we must either call wl_display_cancel_read() or wl_display_read_events() */
+
+            now = SDL_GetTicks();
+            if (SDL_TICKS_PASSED(now, max_wait)) {
+                /* Timeout expired. Cancel the read. */
+                WAYLAND_wl_display_cancel_read(display);
+                break;
+            }
+
+            if (SDL_IOReady(WAYLAND_wl_display_get_fd(display), SDL_IOR_READ, max_wait - now) <= 0) {
+                /* Error or timeout expired without any events for us. Cancel the read. */
+                WAYLAND_wl_display_cancel_read(display);
+                break;
+            }
+
+            /* We have events. Read and dispatch them. */
+            WAYLAND_wl_display_read_events(display);
+            WAYLAND_wl_display_dispatch_queue_pending(display, data->frame_event_queue);
+        }
+        SDL_AtomicSet(&data->swap_interval_ready, 0);
+    }
+
+    /* Feed the frame to Wayland. This will set it so the wl_surface_frame callback can fire again. */
+    if (!_this->egl_data->eglSwapBuffers(_this->egl_data->egl_display, data->egl_surface)) {
+        return SDL_EGL_SetError("unable to show color buffer in an OS-native window", "eglSwapBuffers");
+    }
 
     WAYLAND_wl_display_flush( data->waylandData->display );
 
@@ -80,16 +182,18 @@ int
 Wayland_GLES_MakeCurrent(_THIS, SDL_Window * window, SDL_GLContext context)
 {
     int ret;
-    
+
     if (window && context) {
         ret = SDL_EGL_MakeCurrent(_this, ((SDL_WindowData *) window->driverdata)->egl_surface, context);
     }
     else {
         ret = SDL_EGL_MakeCurrent(_this, NULL, NULL);
     }
-    
+
     WAYLAND_wl_display_flush( ((SDL_VideoData*)_this->driverdata)->display );
-    
+
+    _this->egl_data->eglSwapInterval(_this->egl_data->egl_display, 0);  /* see comments on Wayland_GLES_SetSwapInterval. */
+
     return ret;
 }
 
@@ -110,7 +214,7 @@ Wayland_GLES_GetDrawableSize(_THIS, SDL_Window * window, int * w, int * h)
     }
 }
 
-void 
+void
 Wayland_GLES_DeleteContext(_THIS, SDL_GLContext context)
 {
     SDL_EGL_DeleteContext(_this, context);
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandopengles.h b/Engine/lib/sdl/src/video/wayland/SDL_waylandopengles.h
index 23039c340..1abd813df 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandopengles.h
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandopengles.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -35,11 +35,11 @@ typedef struct SDL_PrivateGLESData
 #define Wayland_GLES_GetAttribute SDL_EGL_GetAttribute
 #define Wayland_GLES_GetProcAddress SDL_EGL_GetProcAddress
 #define Wayland_GLES_UnloadLibrary SDL_EGL_UnloadLibrary
-#define Wayland_GLES_SetSwapInterval SDL_EGL_SetSwapInterval
-#define Wayland_GLES_GetSwapInterval SDL_EGL_GetSwapInterval
 
 extern int Wayland_GLES_LoadLibrary(_THIS, const char *path);
 extern SDL_GLContext Wayland_GLES_CreateContext(_THIS, SDL_Window * window);
+extern int Wayland_GLES_SetSwapInterval(_THIS, int interval);
+extern int Wayland_GLES_GetSwapInterval(_THIS);
 extern int Wayland_GLES_SwapWindow(_THIS, SDL_Window * window);
 extern int Wayland_GLES_MakeCurrent(_THIS, SDL_Window * window, SDL_GLContext context);
 extern void Wayland_GLES_GetDrawableSize(_THIS, SDL_Window * window, int * w, int * h);
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandsym.h b/Engine/lib/sdl/src/video/wayland/SDL_waylandsym.h
index c4c189d3c..fa29bedb1 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandsym.h
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandsym.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -33,6 +33,8 @@
 #define SDL_WAYLAND_INTERFACE(iface)
 #endif
 
+#include <stdbool.h>
+
 SDL_WAYLAND_MODULE(WAYLAND_CLIENT)
 SDL_WAYLAND_SYM(void, wl_proxy_marshal, (struct wl_proxy *, uint32_t, ...))
 SDL_WAYLAND_SYM(struct wl_proxy *, wl_proxy_create, (struct wl_proxy *, const struct wl_interface *))
@@ -44,6 +46,8 @@ SDL_WAYLAND_SYM(uint32_t, wl_proxy_get_version, (struct wl_proxy *))
 SDL_WAYLAND_SYM(uint32_t, wl_proxy_get_id, (struct wl_proxy *))
 SDL_WAYLAND_SYM(const char *, wl_proxy_get_class, (struct wl_proxy *))
 SDL_WAYLAND_SYM(void, wl_proxy_set_queue, (struct wl_proxy *, struct wl_event_queue *))
+SDL_WAYLAND_SYM(void *, wl_proxy_create_wrapper, (void *))
+SDL_WAYLAND_SYM(void, wl_proxy_wrapper_destroy, (void *))
 SDL_WAYLAND_SYM(struct wl_display *, wl_display_connect, (const char *))
 SDL_WAYLAND_SYM(struct wl_display *, wl_display_connect_to_fd, (int))
 SDL_WAYLAND_SYM(void, wl_display_disconnect, (struct wl_display *))
@@ -52,10 +56,15 @@ SDL_WAYLAND_SYM(int, wl_display_dispatch, (struct wl_display *))
 SDL_WAYLAND_SYM(int, wl_display_dispatch_queue, (struct wl_display *, struct wl_event_queue *))
 SDL_WAYLAND_SYM(int, wl_display_dispatch_queue_pending, (struct wl_display *, struct wl_event_queue *))
 SDL_WAYLAND_SYM(int, wl_display_dispatch_pending, (struct wl_display *))
+SDL_WAYLAND_SYM(int, wl_display_prepare_read, (struct wl_display *))
+SDL_WAYLAND_SYM(int, wl_display_prepare_read_queue, (struct wl_display *, struct wl_event_queue *))
+SDL_WAYLAND_SYM(int, wl_display_read_events, (struct wl_display *))
+SDL_WAYLAND_SYM(void, wl_display_cancel_read, (struct wl_display *))
 SDL_WAYLAND_SYM(int, wl_display_get_error, (struct wl_display *))
 SDL_WAYLAND_SYM(int, wl_display_flush, (struct wl_display *))
 SDL_WAYLAND_SYM(int, wl_display_roundtrip, (struct wl_display *))
 SDL_WAYLAND_SYM(struct wl_event_queue *, wl_display_create_queue, (struct wl_display *))
+SDL_WAYLAND_SYM(void, wl_event_queue_destroy, (struct wl_event_queue *))
 SDL_WAYLAND_SYM(void, wl_log_set_handler_client, (wl_log_func_t))
 SDL_WAYLAND_SYM(void, wl_list_init, (struct wl_list *))
 SDL_WAYLAND_SYM(void, wl_list_insert, (struct wl_list *, struct wl_list *) )
@@ -71,18 +80,24 @@ SDL_WAYLAND_SYM(struct wl_proxy *, wl_proxy_marshal_constructor, (struct wl_prox
 SDL_WAYLAND_MODULE(WAYLAND_CLIENT_1_10)
 SDL_WAYLAND_SYM(struct wl_proxy *, wl_proxy_marshal_constructor_versioned, (struct wl_proxy *proxy, uint32_t opcode, const struct wl_interface *interface, uint32_t version, ...))
 
+SDL_WAYLAND_MODULE(WAYLAND_CLIENT_1_18)
+SDL_WAYLAND_SYM(void, wl_proxy_set_tag, (struct wl_proxy *, const char * const *))
+SDL_WAYLAND_SYM(const char * const *, wl_proxy_get_tag, (struct wl_proxy *))
+
+SDL_WAYLAND_MODULE(WAYLAND_CLIENT_1_20)
+SDL_WAYLAND_SYM(struct wl_proxy*, wl_proxy_marshal_flags, (struct wl_proxy *proxy, uint32_t opcode, const struct wl_interface *interfac, uint32_t version, uint32_t flags, ...))
+SDL_WAYLAND_SYM(struct wl_proxy*, wl_proxy_marshal_array_flags, (struct wl_proxy *proxy, uint32_t opcode, const struct wl_interface *interface, uint32_t version,  uint32_t flags, union wl_argument *args))
+
 SDL_WAYLAND_INTERFACE(wl_seat_interface)
 SDL_WAYLAND_INTERFACE(wl_surface_interface)
 SDL_WAYLAND_INTERFACE(wl_shm_pool_interface)
 SDL_WAYLAND_INTERFACE(wl_buffer_interface)
 SDL_WAYLAND_INTERFACE(wl_registry_interface)
-SDL_WAYLAND_INTERFACE(wl_shell_surface_interface)
 SDL_WAYLAND_INTERFACE(wl_region_interface)
 SDL_WAYLAND_INTERFACE(wl_pointer_interface)
 SDL_WAYLAND_INTERFACE(wl_keyboard_interface)
 SDL_WAYLAND_INTERFACE(wl_compositor_interface)
 SDL_WAYLAND_INTERFACE(wl_output_interface)
-SDL_WAYLAND_INTERFACE(wl_shell_interface)
 SDL_WAYLAND_INTERFACE(wl_shm_interface)
 SDL_WAYLAND_INTERFACE(wl_data_device_interface)
 SDL_WAYLAND_INTERFACE(wl_data_source_interface)
@@ -107,6 +122,7 @@ SDL_WAYLAND_SYM(int, xkb_state_key_get_syms, (struct xkb_state *, xkb_keycode_t,
 SDL_WAYLAND_SYM(int, xkb_keysym_to_utf8, (xkb_keysym_t, char *, size_t) )
 SDL_WAYLAND_SYM(struct xkb_keymap *, xkb_keymap_new_from_string, (struct xkb_context *, const char *, enum xkb_keymap_format, enum xkb_keymap_compile_flags))
 SDL_WAYLAND_SYM(struct xkb_state *, xkb_state_new, (struct xkb_keymap *) )
+SDL_WAYLAND_SYM(int, xkb_keymap_key_repeats, (struct xkb_keymap *keymap, xkb_keycode_t key) );
 SDL_WAYLAND_SYM(void, xkb_keymap_unref, (struct xkb_keymap *) )
 SDL_WAYLAND_SYM(void, xkb_state_unref, (struct xkb_state *) )
 SDL_WAYLAND_SYM(void, xkb_context_unref, (struct xkb_context *) )
@@ -118,6 +134,77 @@ SDL_WAYLAND_SYM(enum xkb_state_component, xkb_state_update_mask, (struct xkb_sta
                       xkb_layout_index_t depressed_layout,\
                       xkb_layout_index_t latched_layout,\
                       xkb_layout_index_t locked_layout) )
+SDL_WAYLAND_SYM(struct xkb_compose_table *, xkb_compose_table_new_from_locale, (struct xkb_context *,\
+                      const char *locale, enum xkb_compose_compile_flags) )
+SDL_WAYLAND_SYM(void, xkb_compose_table_unref, (struct xkb_compose_table *) )
+SDL_WAYLAND_SYM(struct xkb_compose_state *, xkb_compose_state_new, (struct xkb_compose_table *, enum xkb_compose_state_flags) )
+SDL_WAYLAND_SYM(void, xkb_compose_state_unref, (struct xkb_compose_state *) )
+SDL_WAYLAND_SYM(enum xkb_compose_feed_result, xkb_compose_state_feed, (struct xkb_compose_state *, xkb_keysym_t) )
+SDL_WAYLAND_SYM(enum xkb_compose_status, xkb_compose_state_get_status, (struct xkb_compose_state *) )
+SDL_WAYLAND_SYM(xkb_keysym_t, xkb_compose_state_get_one_sym, (struct xkb_compose_state *) )
+SDL_WAYLAND_SYM(void, xkb_keymap_key_for_each, (struct xkb_keymap *, xkb_keymap_key_iter_t, void*) )
+SDL_WAYLAND_SYM(int, xkb_keymap_key_get_syms_by_level, (struct xkb_keymap *,
+                                                        xkb_keycode_t,
+                                                        xkb_layout_index_t,
+                                                        xkb_layout_index_t,
+                                                        const xkb_keysym_t **) )
+SDL_WAYLAND_SYM(uint32_t, xkb_keysym_to_utf32, (xkb_keysym_t) )
+
+#ifdef HAVE_LIBDECOR_H
+SDL_WAYLAND_MODULE(WAYLAND_LIBDECOR)
+SDL_WAYLAND_SYM(void, libdecor_unref, (struct libdecor *))
+SDL_WAYLAND_SYM(struct libdecor *, libdecor_new, (struct wl_display *, struct libdecor_interface *))
+SDL_WAYLAND_SYM(struct libdecor_frame *, libdecor_decorate, (struct libdecor *,\
+                                                             struct wl_surface *,\
+                                                             struct libdecor_frame_interface *,\
+                                                             void *))
+SDL_WAYLAND_SYM(void, libdecor_frame_unref, (struct libdecor_frame *))
+SDL_WAYLAND_SYM(void, libdecor_frame_set_title, (struct libdecor_frame *, const char *))
+SDL_WAYLAND_SYM(void, libdecor_frame_set_app_id, (struct libdecor_frame *, const char *))
+SDL_WAYLAND_SYM(void, libdecor_frame_set_max_content_size, (struct libdecor_frame *frame,\
+                                                            int content_width,\
+                                                            int content_height))
+SDL_WAYLAND_SYM(void, libdecor_frame_set_min_content_size, (struct libdecor_frame *frame,\
+                                                            int content_width,\
+                                                            int content_height))
+SDL_WAYLAND_SYM(void, libdecor_frame_resize, (struct libdecor_frame *,\
+                                              struct wl_seat *,\
+                                              uint32_t,\
+                                              enum libdecor_resize_edge))
+SDL_WAYLAND_SYM(void, libdecor_frame_move, (struct libdecor_frame *,\
+                                            struct wl_seat *,\
+                                            uint32_t))
+SDL_WAYLAND_SYM(void, libdecor_frame_commit, (struct libdecor_frame *,\
+                                              struct libdecor_state *,\
+                                              struct libdecor_configuration *))
+SDL_WAYLAND_SYM(void, libdecor_frame_set_minimized, (struct libdecor_frame *))
+SDL_WAYLAND_SYM(void, libdecor_frame_set_maximized, (struct libdecor_frame *))
+SDL_WAYLAND_SYM(void, libdecor_frame_unset_maximized, (struct libdecor_frame *))
+SDL_WAYLAND_SYM(void, libdecor_frame_set_fullscreen, (struct libdecor_frame *, struct wl_output *))
+SDL_WAYLAND_SYM(void, libdecor_frame_unset_fullscreen, (struct libdecor_frame *))
+SDL_WAYLAND_SYM(void, libdecor_frame_set_capabilities, (struct libdecor_frame *, \
+                                                        enum libdecor_capabilities))
+SDL_WAYLAND_SYM(void, libdecor_frame_unset_capabilities, (struct libdecor_frame *, \
+                                                          enum libdecor_capabilities))
+SDL_WAYLAND_SYM(bool, libdecor_frame_has_capability, (struct libdecor_frame *, \
+                                                      enum libdecor_capabilities))
+SDL_WAYLAND_SYM(void, libdecor_frame_set_visibility, (struct libdecor_frame *, bool))
+SDL_WAYLAND_SYM(bool, libdecor_frame_is_visible, (struct libdecor_frame *))
+SDL_WAYLAND_SYM(bool, libdecor_frame_is_floating, (struct libdecor_frame *))
+SDL_WAYLAND_SYM(void, libdecor_frame_set_parent, (struct libdecor_frame *,\
+                                                  struct libdecor_frame *))
+SDL_WAYLAND_SYM(struct xdg_surface *, libdecor_frame_get_xdg_surface, (struct libdecor_frame *))
+SDL_WAYLAND_SYM(struct xdg_toplevel *, libdecor_frame_get_xdg_toplevel, (struct libdecor_frame *))
+SDL_WAYLAND_SYM(void, libdecor_frame_map, (struct libdecor_frame *))
+SDL_WAYLAND_SYM(struct libdecor_state *, libdecor_state_new, (int, int))
+SDL_WAYLAND_SYM(void, libdecor_state_free, (struct libdecor_state *))
+SDL_WAYLAND_SYM(bool, libdecor_configuration_get_content_size, (struct libdecor_configuration *,\
+                                                                struct libdecor_frame *,\
+                                                                int *,\
+                                                                int *))
+SDL_WAYLAND_SYM(bool, libdecor_configuration_get_window_state, (struct libdecor_configuration *,\
+                                                                enum libdecor_window_state *))
+#endif
 
 #undef SDL_WAYLAND_MODULE
 #undef SDL_WAYLAND_SYM
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandtouch.c b/Engine/lib/sdl/src/video/wayland/SDL_waylandtouch.c
index cfb95d2e9..b3879f176 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandtouch.c
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandtouch.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -73,8 +73,8 @@ touch_handle_touch(void *data,
      **/
 
     float FIXED_TO_FLOAT = 1. / 10000.;
-    float xf = FIXED_TO_FLOAT * x;
-    float yf = FIXED_TO_FLOAT * y;
+    float xf = FIXED_TO_FLOAT * normalized_x;
+    float yf = FIXED_TO_FLOAT * normalized_y;
 
     float PRESSURE_TO_FLOAT = 1. / 255.;
     float pressuref = PRESSURE_TO_FLOAT * pressure;
@@ -160,7 +160,7 @@ static const struct wl_message qt_touch_extension_events[] = {
     { "configure", "u", qt_touch_extension_types + 0 },
 };
 
-WL_EXPORT const struct wl_interface qt_touch_extension_interface = {
+const struct wl_interface qt_touch_extension_interface = {
     "qt_touch_extension", 1,
     1, qt_touch_extension_requests,
     2, qt_touch_extension_events,
@@ -183,7 +183,7 @@ static const struct wl_message qt_windowmanager_events[] = {
     { "quit", "", qt_windowmanager_types + 0 },
 };
 
-WL_EXPORT const struct wl_interface qt_windowmanager_interface = {
+const struct wl_interface qt_windowmanager_interface = {
     "qt_windowmanager", 1,
     1, qt_windowmanager_requests,
     2, qt_windowmanager_events,
@@ -214,7 +214,7 @@ static const struct wl_message qt_surface_extension_requests[] = {
     { "get_extended_surface", "no", qt_surface_extension_types + 2 },
 };
 
-WL_EXPORT const struct wl_interface qt_surface_extension_interface = {
+const struct wl_interface qt_surface_extension_interface = {
     "qt_surface_extension", 1,
     1, qt_surface_extension_requests,
     0, NULL,
@@ -232,7 +232,7 @@ static const struct wl_message qt_extended_surface_events[] = {
     { "close", "", qt_surface_extension_types + 0 },
 };
 
-WL_EXPORT const struct wl_interface qt_extended_surface_interface = {
+const struct wl_interface qt_extended_surface_interface = {
     "qt_extended_surface", 1,
     3, qt_extended_surface_requests,
     3, qt_extended_surface_events,
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandtouch.h b/Engine/lib/sdl/src/video/wayland/SDL_waylandtouch.h
index 0980ae0d9..e4436f9f4 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandtouch.h
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandtouch.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -30,7 +30,6 @@
 #include <stdint.h>
 #include <stddef.h>
 #include "wayland-util.h"
-#include "SDL_waylanddyn.h"
 
 
 void Wayland_touch_create(SDL_VideoData *data, uint32_t id);
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandvideo.c b/Engine/lib/sdl/src/video/wayland/SDL_waylandvideo.c
index 469bb7364..61940cca4 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandvideo.c
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandvideo.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -33,22 +33,29 @@
 #include "SDL_waylandwindow.h"
 #include "SDL_waylandopengles.h"
 #include "SDL_waylandmouse.h"
+#include "SDL_waylandkeyboard.h"
 #include "SDL_waylandtouch.h"
 #include "SDL_waylandclipboard.h"
 #include "SDL_waylandvulkan.h"
+#include "SDL_hints.h"
 
 #include <sys/types.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <xkbcommon/xkbcommon.h>
 
-#include "SDL_waylanddyn.h"
 #include <wayland-util.h>
 
 #include "xdg-shell-client-protocol.h"
-#include "xdg-shell-unstable-v6-client-protocol.h"
 #include "xdg-decoration-unstable-v1-client-protocol.h"
-#include "org-kde-kwin-server-decoration-manager-client-protocol.h"
+#include "keyboard-shortcuts-inhibit-unstable-v1-client-protocol.h"
+#include "idle-inhibit-unstable-v1-client-protocol.h"
+#include "xdg-activation-v1-client-protocol.h"
+#include "text-input-unstable-v3-client-protocol.h"
+
+#ifdef HAVE_LIBDECOR_H
+#include <libdecor.h>
+#endif
 
 #define WAYLANDVID_DRIVER_NAME "wayland"
 
@@ -56,10 +63,11 @@
 static int
 Wayland_VideoInit(_THIS);
 
-static void
-Wayland_GetDisplayModes(_THIS, SDL_VideoDisplay *sdl_display);
 static int
-Wayland_SetDisplayMode(_THIS, SDL_VideoDisplay *display, SDL_DisplayMode *mode);
+Wayland_GetDisplayBounds(_THIS, SDL_VideoDisplay *display, SDL_Rect *rect);
+
+static int
+Wayland_GetDisplayDPI(_THIS, SDL_VideoDisplay * sdl_display, float * ddpi, float * hdpi, float * vdpi);
 
 static void
 Wayland_VideoQuit(_THIS);
@@ -120,6 +128,39 @@ get_classname()
     return SDL_strdup("SDL_App");
 }
 
+static const char *SDL_WAYLAND_surface_tag = "sdl-window";
+static const char *SDL_WAYLAND_output_tag = "sdl-output";
+
+void SDL_WAYLAND_register_surface(struct wl_surface *surface)
+{
+    if (SDL_WAYLAND_HAVE_WAYLAND_CLIENT_1_18) {
+        wl_proxy_set_tag((struct wl_proxy *)surface, &SDL_WAYLAND_surface_tag);
+    }
+}
+
+void SDL_WAYLAND_register_output(struct wl_output *output)
+{
+    if (SDL_WAYLAND_HAVE_WAYLAND_CLIENT_1_18) {
+        wl_proxy_set_tag((struct wl_proxy *)output, &SDL_WAYLAND_output_tag);
+    }
+}
+
+SDL_bool SDL_WAYLAND_own_surface(struct wl_surface *surface)
+{
+    if (SDL_WAYLAND_HAVE_WAYLAND_CLIENT_1_18) {
+        return wl_proxy_get_tag((struct wl_proxy *) surface) == &SDL_WAYLAND_surface_tag;
+    }
+    return SDL_TRUE; /* For older clients we have to assume this is us... */
+}
+
+SDL_bool SDL_WAYLAND_own_output(struct wl_output *output)
+{
+    if (SDL_WAYLAND_HAVE_WAYLAND_CLIENT_1_18) {
+        return wl_proxy_get_tag((struct wl_proxy *) output) == &SDL_WAYLAND_output_tag;
+    }
+    return SDL_TRUE; /* For older clients we have to assume this is us... */
+}
+
 static void
 Wayland_DeleteDevice(SDL_VideoDevice *device)
 {
@@ -128,6 +169,9 @@ Wayland_DeleteDevice(SDL_VideoDevice *device)
         WAYLAND_wl_display_flush(data->display);
         WAYLAND_wl_display_disconnect(data->display);
     }
+    if (device->wakeup_lock) {
+        SDL_DestroyMutex(device->wakeup_lock);
+    }
     SDL_free(data);
     SDL_free(device);
     SDL_WAYLAND_UnloadSymbols();
@@ -158,6 +202,7 @@ Wayland_CreateDevice(int devindex)
         return NULL;
     }
 
+    data->initializing = SDL_TRUE;
     data->display = display;
 
     /* Initialize all variables that we clean on shutdown */
@@ -171,16 +216,21 @@ Wayland_CreateDevice(int devindex)
     }
 
     device->driverdata = data;
+    device->wakeup_lock = SDL_CreateMutex();
 
     /* Set the function pointers */
     device->VideoInit = Wayland_VideoInit;
     device->VideoQuit = Wayland_VideoQuit;
-    device->SetDisplayMode = Wayland_SetDisplayMode;
-    device->GetDisplayModes = Wayland_GetDisplayModes;
+    device->GetDisplayBounds = Wayland_GetDisplayBounds;
+    device->GetDisplayDPI = Wayland_GetDisplayDPI;
     device->GetWindowWMInfo = Wayland_GetWindowWMInfo;
+    device->SuspendScreenSaver = Wayland_SuspendScreenSaver;
 
     device->PumpEvents = Wayland_PumpEvents;
+    device->WaitEventTimeout = Wayland_WaitEventTimeout;
+    device->SendWakeupEvent = Wayland_SendWakeupEvent;
 
+#if SDL_VIDEO_OPENGL_EGL
     device->GL_SwapWindow = Wayland_GLES_SwapWindow;
     device->GL_GetSwapInterval = Wayland_GLES_GetSwapInterval;
     device->GL_SetSwapInterval = Wayland_GLES_SetSwapInterval;
@@ -191,22 +241,37 @@ Wayland_CreateDevice(int devindex)
     device->GL_UnloadLibrary = Wayland_GLES_UnloadLibrary;
     device->GL_GetProcAddress = Wayland_GLES_GetProcAddress;
     device->GL_DeleteContext = Wayland_GLES_DeleteContext;
+#endif
 
     device->CreateSDLWindow = Wayland_CreateWindow;
     device->ShowWindow = Wayland_ShowWindow;
+    device->HideWindow = Wayland_HideWindow;
+    device->RaiseWindow = Wayland_RaiseWindow;
     device->SetWindowFullscreen = Wayland_SetWindowFullscreen;
     device->MaximizeWindow = Wayland_MaximizeWindow;
-    device->SetWindowGrab = Wayland_SetWindowGrab;
+    device->MinimizeWindow = Wayland_MinimizeWindow;
+    device->SetWindowMouseRect = Wayland_SetWindowMouseRect;
+    device->SetWindowMouseGrab = Wayland_SetWindowMouseGrab;
+    device->SetWindowKeyboardGrab = Wayland_SetWindowKeyboardGrab;
     device->RestoreWindow = Wayland_RestoreWindow;
     device->SetWindowBordered = Wayland_SetWindowBordered;
+    device->SetWindowResizable = Wayland_SetWindowResizable;
     device->SetWindowSize = Wayland_SetWindowSize;
+    device->SetWindowMinimumSize = Wayland_SetWindowMinimumSize;
+    device->SetWindowMaximumSize = Wayland_SetWindowMaximumSize;
+    device->SetWindowModalFor = Wayland_SetWindowModalFor;
     device->SetWindowTitle = Wayland_SetWindowTitle;
     device->DestroyWindow = Wayland_DestroyWindow;
     device->SetWindowHitTest = Wayland_SetWindowHitTest;
+    device->FlashWindow = Wayland_FlashWindow;
+    device->HasScreenKeyboardSupport = Wayland_HasScreenKeyboardSupport;
 
     device->SetClipboardText = Wayland_SetClipboardText;
     device->GetClipboardText = Wayland_GetClipboardText;
     device->HasClipboardText = Wayland_HasClipboardText;
+    device->StartTextInput = Wayland_StartTextInput;
+    device->StopTextInput = Wayland_StopTextInput;
+    device->SetTextInputRect = Wayland_SetTextInputRect;
 
 #if SDL_VIDEO_VULKAN
     device->Vulkan_LoadLibrary = Wayland_Vulkan_LoadLibrary;
@@ -238,9 +303,61 @@ display_handle_geometry(void *data,
                         int transform)
 
 {
-    SDL_VideoDisplay *display = data;
+    SDL_WaylandOutputData *driverdata = data;
+    SDL_VideoDisplay *display;
+    int i;
 
-    display->name = SDL_strdup(model);
+    if (driverdata->done) {
+        /* Clear the wl_output ref so Reset doesn't free it */
+        display = SDL_GetDisplay(driverdata->index);
+        for (i = 0; i < display->num_display_modes; i += 1) {
+            display->display_modes[i].driverdata = NULL;
+        }
+
+        /* Okay, now it's safe to reset */
+        SDL_ResetDisplayModes(driverdata->index);
+
+        /* The display has officially started over. */
+        driverdata->done = SDL_FALSE;
+    }
+
+    driverdata->x = x;
+    driverdata->y = y;
+    driverdata->physical_width = physical_width;
+    driverdata->physical_height = physical_height;
+    if (driverdata->index == -1) {
+        driverdata->placeholder.name = SDL_strdup(model);
+    }
+
+    driverdata->transform = transform;
+    #define TF_CASE(in, out) \
+        case WL_OUTPUT_TRANSFORM_##in: \
+            driverdata->orientation = SDL_ORIENTATION_##out; \
+            break;
+    if (driverdata->physical_width >= driverdata->physical_height) {
+        switch (transform) {
+            TF_CASE(NORMAL, LANDSCAPE)
+            TF_CASE(90, PORTRAIT)
+            TF_CASE(180, LANDSCAPE_FLIPPED)
+            TF_CASE(270, PORTRAIT_FLIPPED)
+            TF_CASE(FLIPPED, LANDSCAPE_FLIPPED)
+            TF_CASE(FLIPPED_90, PORTRAIT_FLIPPED)
+            TF_CASE(FLIPPED_180, LANDSCAPE)
+            TF_CASE(FLIPPED_270, PORTRAIT)
+        }
+    } else {
+        switch (transform) {
+            TF_CASE(NORMAL, PORTRAIT)
+            TF_CASE(90, LANDSCAPE)
+            TF_CASE(180, PORTRAIT_FLIPPED)
+            TF_CASE(270, LANDSCAPE_FLIPPED)
+            TF_CASE(FLIPPED, PORTRAIT_FLIPPED)
+            TF_CASE(FLIPPED_90, LANDSCAPE_FLIPPED)
+            TF_CASE(FLIPPED_180, PORTRAIT)
+            TF_CASE(FLIPPED_270, LANDSCAPE)
+        }
+    }
+    #undef TF_CASE
 }
 
 static void
@@ -251,20 +368,37 @@ display_handle_mode(void *data,
                     int height,
                     int refresh)
 {
+    SDL_WaylandOutputData* driverdata = data;
     SDL_DisplayMode mode;
-    SDL_VideoDisplay *display = data;
-
-    SDL_zero(mode);
-    mode.format = SDL_PIXELFORMAT_RGB888;
-    mode.w = width;
-    mode.h = height;
-    mode.refresh_rate = refresh / 1000; // mHz to Hz
-    mode.driverdata = ((SDL_WaylandOutputData*)display->driverdata)->output;
-    SDL_AddDisplayMode(display, &mode);
 
     if (flags & WL_OUTPUT_MODE_CURRENT) {
-        display->current_mode = mode;
-        display->desktop_mode = mode;
+        /* Don't rotate this yet, handle_done will do it later */
+        driverdata->width = width;
+        driverdata->height = height;
+        driverdata->refresh = refresh;
+    }
+
+    /* Note that the width/height are NOT multiplied by scale_factor!
+     * This is intentional and is designed to get the unscaled modes, which is
+     * important for high-DPI games intending to use the display mode as the
+     * target drawable size. The scaled desktop mode will be added at the end
+     * when display_handle_done is called (see below).
+     */
+    SDL_zero(mode);
+    mode.format = SDL_PIXELFORMAT_RGB888;
+    if (driverdata->transform & WL_OUTPUT_TRANSFORM_90) {
+        mode.w = height;
+        mode.h = width;
+    } else {
+        mode.w = width;
+        mode.h = height;
+    }
+    mode.refresh_rate = (int)SDL_round(refresh / 1000.0); /* mHz to Hz */
+    mode.driverdata = driverdata->output;
+    if (driverdata->index > -1) {
+        SDL_AddDisplayMode(SDL_GetDisplay(driverdata->index), &mode);
+    } else {
+        SDL_AddDisplayMode(&driverdata->placeholder, &mode);
     }
 }
 
@@ -272,12 +406,70 @@ static void
 display_handle_done(void *data,
                     struct wl_output *output)
 {
-    /* !!! FIXME: this will fail on any further property changes! */
-    SDL_VideoDisplay *display = data;
-    SDL_AddVideoDisplay(display, SDL_FALSE);
-    wl_output_set_user_data(output, display->driverdata);
-    SDL_free(display->name);
-    SDL_free(display);
+    SDL_WaylandOutputData* driverdata = data;
+    SDL_DisplayMode mode;
+    SDL_VideoDisplay *dpy;
+
+    if (driverdata->done)
+        return;
+
+    driverdata->done = SDL_TRUE;
+
+    SDL_zero(mode);
+    mode.format = SDL_PIXELFORMAT_RGB888;
+    if (driverdata->transform & WL_OUTPUT_TRANSFORM_90) {
+        mode.w = driverdata->height / driverdata->scale_factor;
+        mode.h = driverdata->width / driverdata->scale_factor;
+
+        driverdata->hdpi = driverdata->physical_height ?
+            (((float) driverdata->height) * 25.4f / driverdata->physical_height) :
+            0.0f;
+        driverdata->vdpi = driverdata->physical_width ?
+            (((float) driverdata->width) * 25.4f / driverdata->physical_width) :
+            0.0f;
+        driverdata->ddpi = SDL_ComputeDiagonalDPI(driverdata->height,
+                                                  driverdata->width,
+                                                  ((float) driverdata->physical_height) / 25.4f,
+                                                  ((float) driverdata->physical_width) / 25.4f);
+    } else {
+        mode.w = driverdata->width / driverdata->scale_factor;
+        mode.h = driverdata->height / driverdata->scale_factor;
+
+        driverdata->hdpi = driverdata->physical_width ?
+            (((float) driverdata->width) * 25.4f / driverdata->physical_width) :
+            0.0f;
+        driverdata->vdpi = driverdata->physical_height ?
+            (((float) driverdata->height) * 25.4f / driverdata->physical_height) :
+            0.0f;
+        driverdata->ddpi = SDL_ComputeDiagonalDPI(driverdata->width,
+                                                  driverdata->height,
+                                                  ((float) driverdata->physical_width) / 25.4f,
+                                                  ((float) driverdata->physical_height) / 25.4f);
+    }
+    mode.refresh_rate = (int)SDL_round(driverdata->refresh / 1000.0); /* mHz to Hz */
+    mode.driverdata = driverdata->output;
+
+    if (driverdata->index > -1) {
+        dpy = SDL_GetDisplay(driverdata->index);
+    } else {
+        dpy = &driverdata->placeholder;
+    }
+
+    SDL_AddDisplayMode(dpy, &mode);
+    SDL_SetCurrentDisplayMode(dpy, &mode);
+    SDL_SetDesktopDisplayMode(dpy, &mode);
+
+    if (driverdata->index == -1) {
+        /* First time getting display info, create the VideoDisplay */
+        SDL_bool send_event = driverdata->videodata->initializing ? SDL_FALSE : SDL_TRUE;
+        driverdata->placeholder.orientation = driverdata->orientation;
+        driverdata->placeholder.driverdata = driverdata;
+        driverdata->index = SDL_AddVideoDisplay(&driverdata->placeholder, send_event);
+        SDL_free(driverdata->placeholder.name);
+        SDL_zero(driverdata->placeholder);
+    } else {
+        SDL_SendDisplayEvent(dpy, SDL_DISPLAYEVENT_ORIENTATION, driverdata->orientation);
+    }
 }
 
 static void
@@ -285,8 +477,8 @@ display_handle_scale(void *data,
                      struct wl_output *output,
                      int32_t factor)
 {
-    SDL_VideoDisplay *display = data;
-    ((SDL_WaylandOutputData*)display->driverdata)->scale_factor = factor;
+    SDL_WaylandOutputData *driverdata = data;
+    driverdata->scale_factor = factor;
 }
 
 static const struct wl_output_listener output_listener = {
@@ -301,25 +493,51 @@ Wayland_add_display(SDL_VideoData *d, uint32_t id)
 {
     struct wl_output *output;
     SDL_WaylandOutputData *data;
-    SDL_VideoDisplay *display = SDL_malloc(sizeof *display);
-    if (!display) {
-        SDL_OutOfMemory();
-        return;
-    }
-    SDL_zero(*display);
 
     output = wl_registry_bind(d->registry, id, &wl_output_interface, 2);
     if (!output) {
         SDL_SetError("Failed to retrieve output.");
-        SDL_free(display);
         return;
     }
     data = SDL_malloc(sizeof *data);
+    SDL_zerop(data);
+    data->videodata = d;
     data->output = output;
+    data->registry_id = id;
     data->scale_factor = 1.0;
-    display->driverdata = data;
+    data->index = -1;
 
-    wl_output_add_listener(output, &output_listener, display);
+    wl_output_add_listener(output, &output_listener, data);
+    SDL_WAYLAND_register_output(output);
+}
+
+static void
+Wayland_free_display(uint32_t id)
+{
+    int num_displays = SDL_GetNumVideoDisplays();
+    SDL_VideoDisplay *display;
+    SDL_WaylandOutputData *data;
+    int i;
+
+    for (i = 0; i < num_displays; i += 1) {
+        display = SDL_GetDisplay(i);
+        data = (SDL_WaylandOutputData *) display->driverdata;
+        if (data->registry_id == id) {
+            SDL_DelVideoDisplay(i);
+            wl_output_destroy(data->output);
+            SDL_free(data);
+
+            /* Update the index for all remaining displays */
+            num_displays -= 1;
+            for (; i < num_displays; i += 1) {
+                display = SDL_GetDisplay(i);
+                data = (SDL_WaylandOutputData *) display->driverdata;
+                data->index -= 1;
+            }
+
+            return;
+        }
+    }
 }
 
 #ifdef SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH
@@ -341,18 +559,6 @@ static const struct qt_windowmanager_listener windowmanager_listener = {
 };
 #endif /* SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH */
 
-
-static void
-handle_ping_zxdg_shell(void *data, struct zxdg_shell_v6 *zxdg, uint32_t serial)
-{
-    zxdg_shell_v6_pong(zxdg, serial);
-}
-
-static const struct zxdg_shell_v6_listener shell_listener_zxdg = {
-    handle_ping_zxdg_shell
-};
-
-
 static void
 handle_ping_xdg_wm_base(void *data, struct xdg_wm_base *xdg, uint32_t serial)
 {
@@ -364,6 +570,21 @@ static const struct xdg_wm_base_listener shell_listener_xdg = {
 };
 
 
+#ifdef HAVE_LIBDECOR_H
+static void
+libdecor_error(struct libdecor *context,
+               enum libdecor_error error,
+               const char *message)
+{
+    SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "libdecor error (%d): %s\n", error, message);
+}
+
+static struct libdecor_interface libdecor_interface = {
+    libdecor_error,
+};
+#endif
+
+
 static void
 display_handle_global(void *data, struct wl_registry *registry, uint32_t id,
                       const char *interface, uint32_t version)
@@ -372,41 +593,41 @@ display_handle_global(void *data, struct wl_registry *registry, uint32_t id,
 
     /*printf("WAYLAND INTERFACE: %s\n", interface);*/
 
-    if (strcmp(interface, "wl_compositor") == 0) {
+    if (SDL_strcmp(interface, "wl_compositor") == 0) {
         d->compositor = wl_registry_bind(d->registry, id, &wl_compositor_interface, SDL_min(3, version));
-    } else if (strcmp(interface, "wl_output") == 0) {
+    } else if (SDL_strcmp(interface, "wl_output") == 0) {
         Wayland_add_display(d, id);
-    } else if (strcmp(interface, "wl_seat") == 0) {
+    } else if (SDL_strcmp(interface, "wl_seat") == 0) {
         Wayland_display_add_input(d, id, version);
-    } else if (strcmp(interface, "xdg_wm_base") == 0) {
+    } else if (SDL_strcmp(interface, "xdg_wm_base") == 0) {
         d->shell.xdg = wl_registry_bind(d->registry, id, &xdg_wm_base_interface, 1);
         xdg_wm_base_add_listener(d->shell.xdg, &shell_listener_xdg, NULL);
-    } else if (strcmp(interface, "zxdg_shell_v6") == 0) {
-        d->shell.zxdg = wl_registry_bind(d->registry, id, &zxdg_shell_v6_interface, 1);
-        zxdg_shell_v6_add_listener(d->shell.zxdg, &shell_listener_zxdg, NULL);
-    } else if (strcmp(interface, "wl_shell") == 0) {
-        d->shell.wl = wl_registry_bind(d->registry, id, &wl_shell_interface, 1);
-    } else if (strcmp(interface, "wl_shm") == 0) {
+    } else if (SDL_strcmp(interface, "wl_shm") == 0) {
         d->shm = wl_registry_bind(registry, id, &wl_shm_interface, 1);
-        d->cursor_theme = WAYLAND_wl_cursor_theme_load(NULL, 32, d->shm);
-    } else if (strcmp(interface, "zwp_relative_pointer_manager_v1") == 0) {
+    } else if (SDL_strcmp(interface, "zwp_relative_pointer_manager_v1") == 0) {
         Wayland_display_add_relative_pointer_manager(d, id);
-    } else if (strcmp(interface, "zwp_pointer_constraints_v1") == 0) {
+    } else if (SDL_strcmp(interface, "zwp_pointer_constraints_v1") == 0) {
         Wayland_display_add_pointer_constraints(d, id);
-    } else if (strcmp(interface, "wl_data_device_manager") == 0) {
-        d->data_device_manager = wl_registry_bind(d->registry, id, &wl_data_device_manager_interface, SDL_min(3, version));
-    } else if (strcmp(interface, "zxdg_decoration_manager_v1") == 0) {
+    } else if (SDL_strcmp(interface, "zwp_keyboard_shortcuts_inhibit_manager_v1") == 0) {
+        d->key_inhibitor_manager = wl_registry_bind(d->registry, id, &zwp_keyboard_shortcuts_inhibit_manager_v1_interface, 1);
+    } else if (SDL_strcmp(interface, "zwp_idle_inhibit_manager_v1") == 0) {
+        d->idle_inhibit_manager = wl_registry_bind(d->registry, id, &zwp_idle_inhibit_manager_v1_interface, 1);
+    } else if (SDL_strcmp(interface, "xdg_activation_v1") == 0) {
+        d->activation_manager = wl_registry_bind(d->registry, id, &xdg_activation_v1_interface, 1);
+    } else if (SDL_strcmp(interface, "zwp_text_input_manager_v3") == 0) {
+        Wayland_add_text_input_manager(d, id, version);
+    } else if (SDL_strcmp(interface, "wl_data_device_manager") == 0) {
+        Wayland_add_data_device_manager(d, id, version);
+    } else if (SDL_strcmp(interface, "zxdg_decoration_manager_v1") == 0) {
         d->decoration_manager = wl_registry_bind(d->registry, id, &zxdg_decoration_manager_v1_interface, 1);
-    } else if (strcmp(interface, "org_kde_kwin_server_decoration_manager") == 0) {
-        d->kwin_server_decoration_manager = wl_registry_bind(d->registry, id, &org_kde_kwin_server_decoration_manager_interface, 1);
 
 #ifdef SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH
-    } else if (strcmp(interface, "qt_touch_extension") == 0) {
+    } else if (SDL_strcmp(interface, "qt_touch_extension") == 0) {
         Wayland_touch_create(d, id);
-    } else if (strcmp(interface, "qt_surface_extension") == 0) {
+    } else if (SDL_strcmp(interface, "qt_surface_extension") == 0) {
         d->surface_extension = wl_registry_bind(registry, id,
                 &qt_surface_extension_interface, 1);
-    } else if (strcmp(interface, "qt_windowmanager") == 0) {
+    } else if (SDL_strcmp(interface, "qt_windowmanager") == 0) {
         d->windowmanager = wl_registry_bind(registry, id,
                 &qt_windowmanager_interface, 1);
         qt_windowmanager_add_listener(d->windowmanager, &windowmanager_listener, d);
@@ -415,7 +636,11 @@ display_handle_global(void *data, struct wl_registry *registry, uint32_t id,
 }
 
 static void
-display_remove_global(void *data, struct wl_registry *registry, uint32_t id) {}
+display_remove_global(void *data, struct wl_registry *registry, uint32_t id)
+{
+    /* We don't get an interface, just an ID, so assume it's a wl_output :shrug: */
+    Wayland_free_display(id);
+}
 
 static const struct wl_registry_listener registry_listener = {
     display_handle_global,
@@ -442,6 +667,19 @@ Wayland_VideoInit(_THIS)
     // First roundtrip to receive all registry objects.
     WAYLAND_wl_display_roundtrip(data->display);
 
+#ifdef HAVE_LIBDECOR_H
+    /* Don't have server-side decorations? Try client-side instead. */
+    if (!data->decoration_manager && SDL_WAYLAND_HAVE_WAYLAND_LIBDECOR && SDL_GetHintBoolean(SDL_HINT_VIDEO_WAYLAND_ALLOW_LIBDECOR, SDL_TRUE)) {
+        data->shell.libdecor = libdecor_new(data->display, &libdecor_interface);
+
+        /* If libdecor works, we don't need xdg-shell anymore. */
+        if (data->shell.libdecor && data->shell.xdg) {
+            xdg_wm_base_destroy(data->shell.xdg);
+            data->shell.xdg = NULL;
+        }
+    }
+#endif
+
     // Second roundtrip to receive all output events.
     WAYLAND_wl_display_roundtrip(data->display);
 
@@ -452,20 +690,40 @@ Wayland_VideoInit(_THIS)
 
     WAYLAND_wl_display_flush(data->display);
 
+    Wayland_InitKeyboard(_this);
+
+    data->initializing = SDL_FALSE;
+
     return 0;
 }
 
-static void
-Wayland_GetDisplayModes(_THIS, SDL_VideoDisplay *sdl_display)
+static int
+Wayland_GetDisplayBounds(_THIS, SDL_VideoDisplay *display, SDL_Rect *rect)
 {
-    // Nothing to do here, everything was already done in the wl_output
-    // callbacks.
+    SDL_WaylandOutputData *driverdata = (SDL_WaylandOutputData *)display->driverdata;
+    rect->x = driverdata->x;
+    rect->y = driverdata->y;
+    rect->w = display->current_mode.w;
+    rect->h = display->current_mode.h;
+    return 0;
 }
 
 static int
-Wayland_SetDisplayMode(_THIS, SDL_VideoDisplay *display, SDL_DisplayMode *mode)
+Wayland_GetDisplayDPI(_THIS, SDL_VideoDisplay * sdl_display, float * ddpi, float * hdpi, float * vdpi)
 {
-    return SDL_Unsupported();
+    SDL_WaylandOutputData *driverdata = (SDL_WaylandOutputData *)sdl_display->driverdata;
+
+    if (ddpi) {
+        *ddpi = driverdata->ddpi;
+    }
+    if (hdpi) {
+        *hdpi = driverdata->hdpi;
+    }
+    if (vdpi) {
+        *vdpi = driverdata->vdpi;
+    }
+
+    return driverdata->ddpi != 0.0f ? 0 : SDL_SetError("Couldn't get DPI");
 }
 
 void
@@ -474,7 +732,7 @@ Wayland_VideoQuit(_THIS)
     SDL_VideoData *data = _this->driverdata;
     int i, j;
 
-    Wayland_FiniMouse ();
+    Wayland_FiniMouse(data);
 
     for (i = 0; i < _this->num_displays; ++i) {
         SDL_VideoDisplay *display = &_this->displays[i];
@@ -493,6 +751,20 @@ Wayland_VideoQuit(_THIS)
     Wayland_display_destroy_pointer_constraints(data);
     Wayland_display_destroy_relative_pointer_manager(data);
 
+    if (data->activation_manager)
+        xdg_activation_v1_destroy(data->activation_manager);
+
+    if (data->idle_inhibit_manager)
+        zwp_idle_inhibit_manager_v1_destroy(data->idle_inhibit_manager);
+
+    if (data->key_inhibitor_manager)
+        zwp_keyboard_shortcuts_inhibit_manager_v1_destroy(data->key_inhibitor_manager);
+
+    Wayland_QuitKeyboard(_this);
+
+    if (data->text_input_manager)
+        zwp_text_input_manager_v3_destroy(data->text_input_manager);
+
     if (data->xkb_context) {
         WAYLAND_xkb_context_unref(data->xkb_context);
         data->xkb_context = NULL;
@@ -507,20 +779,24 @@ Wayland_VideoQuit(_THIS)
     Wayland_touch_destroy(data);
 #endif /* SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH */
 
+    if (data->data_device_manager)
+        wl_data_device_manager_destroy(data->data_device_manager);
+
     if (data->shm)
         wl_shm_destroy(data->shm);
 
-    if (data->cursor_theme)
-        WAYLAND_wl_cursor_theme_destroy(data->cursor_theme);
-
-    if (data->shell.wl)
-        wl_shell_destroy(data->shell.wl);
-
     if (data->shell.xdg)
         xdg_wm_base_destroy(data->shell.xdg);
 
-    if (data->shell.zxdg)
-        zxdg_shell_v6_destroy(data->shell.zxdg);
+    if (data->decoration_manager)
+        zxdg_decoration_manager_v1_destroy(data->decoration_manager);
+
+#ifdef HAVE_LIBDECOR_H
+    if (data->shell.libdecor) {
+        libdecor_unref(data->shell.libdecor);
+        data->shell.libdecor = NULL;
+    }
+#endif
 
     if (data->compositor)
         wl_compositor_destroy(data->compositor);
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandvideo.h b/Engine/lib/sdl/src/video/wayland/SDL_waylandvideo.h
index 2c481d85e..31168a9d5 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandvideo.h
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandvideo.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -20,23 +20,18 @@
 */
 
 #include "../../SDL_internal.h"
+#include "SDL_stdinc.h"
 
 #ifndef SDL_waylandvideo_h_
 #define SDL_waylandvideo_h_
 
-
-/*
-!!! FIXME: xdg_wm_base is the stable replacement for zxdg_shell_v6. While it's
-!!! FIXME:  harmless to leave it here, consider deleting the obsolete codepath
-!!! FIXME:  soon, since Wayland (with xdg_wm_base) will probably be mainline
-!!! FIXME:  by the time people are relying on this SDL target. It's available
-!!! FIXME:  in Ubuntu 18.04 (and other distros).
-*/
-
-#define MESA_EGL_NO_X11_HEADERS
 #include <EGL/egl.h>
 #include "wayland-util.h"
 
+#include "../SDL_sysvideo.h"
+#include "../../core/linux/SDL_dbus.h"
+#include "../../core/linux/SDL_ime.h"
+
 struct xkb_context;
 struct SDL_WaylandInput;
 
@@ -47,23 +42,34 @@ struct qt_windowmanager;
 #endif /* SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH */
 
 typedef struct {
+    struct wl_cursor_theme *theme;
+    int size;
+} SDL_WaylandCursorTheme;
+
+typedef struct {
+    SDL_bool initializing;
     struct wl_display *display;
     int display_disconnected;
     struct wl_registry *registry;
     struct wl_compositor *compositor;
     struct wl_shm *shm;
-    struct wl_cursor_theme *cursor_theme;
+    SDL_WaylandCursorTheme *cursor_themes;
+    int num_cursor_themes;
     struct wl_pointer *pointer;
     struct {
         struct xdg_wm_base *xdg;
-        struct zxdg_shell_v6 *zxdg;
-        struct wl_shell *wl;
+#ifdef HAVE_LIBDECOR_H
+        struct libdecor *libdecor;
+#endif
     } shell;
     struct zwp_relative_pointer_manager_v1 *relative_pointer_manager;
     struct zwp_pointer_constraints_v1 *pointer_constraints;
     struct wl_data_device_manager *data_device_manager;
     struct zxdg_decoration_manager_v1 *decoration_manager;
-    struct org_kde_kwin_server_decoration_manager *kwin_server_decoration_manager;
+    struct zwp_keyboard_shortcuts_inhibit_manager_v1 *key_inhibitor_manager;
+    struct zwp_idle_inhibit_manager_v1 *idle_inhibit_manager;
+    struct xdg_activation_v1 *activation_manager;
+    struct zwp_text_input_manager_v3 *text_input_manager;
 
     EGLDisplay edpy;
     EGLContext context;
@@ -84,10 +90,27 @@ typedef struct {
 } SDL_VideoData;
 
 typedef struct {
+    SDL_VideoData *videodata;
     struct wl_output *output;
+    uint32_t registry_id;
     float scale_factor;
+    int x, y, width, height, refresh, transform;
+    SDL_DisplayOrientation orientation;
+    int physical_width, physical_height;
+    float ddpi, hdpi, vdpi;
+    int index;
+    SDL_VideoDisplay placeholder;
+    SDL_bool done;
 } SDL_WaylandOutputData;
 
+/* Needed here to get wl_surface declaration, fixes GitHub#4594 */
+#include "SDL_waylanddyn.h"
+
+extern void SDL_WAYLAND_register_surface(struct wl_surface *surface);
+extern void SDL_WAYLAND_register_output(struct wl_output *output);
+extern SDL_bool SDL_WAYLAND_own_surface(struct wl_surface *surface);
+extern SDL_bool SDL_WAYLAND_own_output(struct wl_output *output);
+
 #endif /* SDL_waylandvideo_h_ */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandvulkan.c b/Engine/lib/sdl/src/video/wayland/SDL_waylandvulkan.c
index a67058fef..eb4435131 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandvulkan.c
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandvulkan.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandvulkan.h b/Engine/lib/sdl/src/video/wayland/SDL_waylandvulkan.h
index 224fa07da..c2b4c4f01 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandvulkan.h
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandvulkan.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandwindow.c b/Engine/lib/sdl/src/video/wayland/SDL_waylandwindow.c
index 787c61494..635546af4 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandwindow.c
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandwindow.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -21,7 +21,7 @@
 
 #include "../../SDL_internal.h"
 
-#if SDL_VIDEO_DRIVER_WAYLAND && SDL_VIDEO_OPENGL_EGL
+#if SDL_VIDEO_DRIVER_WAYLAND
 
 #include "../SDL_sysvideo.h"
 #include "../../events/SDL_windowevents_c.h"
@@ -30,235 +30,155 @@
 #include "SDL_waylandwindow.h"
 #include "SDL_waylandvideo.h"
 #include "SDL_waylandtouch.h"
-#include "SDL_waylanddyn.h"
 #include "SDL_hints.h"
 
 #include "xdg-shell-client-protocol.h"
-#include "xdg-shell-unstable-v6-client-protocol.h"
 #include "xdg-decoration-unstable-v1-client-protocol.h"
-#include "org-kde-kwin-server-decoration-manager-client-protocol.h"
+#include "idle-inhibit-unstable-v1-client-protocol.h"
+#include "xdg-activation-v1-client-protocol.h"
 
-static float get_window_scale_factor(SDL_Window *window) {
-      return ((SDL_WindowData*)window->driverdata)->scale_factor;
-}
-
-/* On modern desktops, we probably will use the xdg-shell protocol instead
-   of wl_shell, but wl_shell might be useful on older Wayland installs that
-   don't have the newer protocol, or embedded things that don't have a full
-   window manager. */
+#ifdef HAVE_LIBDECOR_H
+#include <libdecor.h>
+#endif
 
 static void
-handle_ping_wl_shell_surface(void *data, struct wl_shell_surface *shell_surface,
-            uint32_t serial)
+SetMinMaxDimensions(SDL_Window *window, SDL_bool commit)
 {
-    wl_shell_surface_pong(shell_surface, serial);
-}
+    SDL_WindowData *wind = window->driverdata;
+    SDL_VideoData *viddata = wind->waylandData;
+    int min_width, min_height, max_width, max_height;
 
-static void
-handle_configure_wl_shell_surface(void *data, struct wl_shell_surface *shell_surface,
-                 uint32_t edges, int32_t width, int32_t height)
-{
-    SDL_WindowData *wind = (SDL_WindowData *)data;
-    SDL_Window *window = wind->sdlwindow;
-
-    /* wl_shell_surface spec states that this is a suggestion.
-       Ignore if less than or greater than max/min size. */
-
-    if (width == 0 || height == 0) {
-        return;
-    }
-
-    if (!(window->flags & SDL_WINDOW_FULLSCREEN)) {
-        if ((window->flags & SDL_WINDOW_RESIZABLE)) {
-            if (window->max_w > 0) {
-                width = SDL_min(width, window->max_w);
-            }
-            width = SDL_max(width, window->min_w);
-
-            if (window->max_h > 0) {
-                height = SDL_min(height, window->max_h);
-            }
-            height = SDL_max(height, window->min_h);
-        } else {
-            return;
-        }
-    }
-
-    wind->resize.width = width;
-    wind->resize.height = height;
-    wind->resize.pending = SDL_TRUE;
-
-    if (!(window->flags & SDL_WINDOW_OPENGL)) {
-        Wayland_HandlePendingResize(window);  /* OpenGL windows handle this in SwapWindow */
-    }
-}
-
-static void
-handle_popup_done_wl_shell_surface(void *data, struct wl_shell_surface *shell_surface)
-{
-}
-
-static const struct wl_shell_surface_listener shell_surface_listener_wl = {
-    handle_ping_wl_shell_surface,
-    handle_configure_wl_shell_surface,
-    handle_popup_done_wl_shell_surface
-};
-
-
-
-
-static void
-handle_configure_zxdg_shell_surface(void *data, struct zxdg_surface_v6 *zxdg, uint32_t serial)
-{
-    SDL_WindowData *wind = (SDL_WindowData *)data;
-    SDL_Window *window = wind->sdlwindow;
-    struct wl_region *region;
-
-    if (!wind->shell_surface.zxdg.initial_configure_seen) {
-        window->w = 0;
-        window->h = 0;
-        SDL_SendWindowEvent(window, SDL_WINDOWEVENT_RESIZED, wind->resize.width, wind->resize.height);
-        window->w = wind->resize.width;
-        window->h = wind->resize.height;
-
-        wl_surface_set_buffer_scale(wind->surface, get_window_scale_factor(window));
-        if (wind->egl_window) {
-            WAYLAND_wl_egl_window_resize(wind->egl_window, window->w * get_window_scale_factor(window), window->h * get_window_scale_factor(window), 0, 0);
-        }
-
-        zxdg_surface_v6_ack_configure(zxdg, serial);
-
-        region = wl_compositor_create_region(wind->waylandData->compositor);
-        wl_region_add(region, 0, 0, window->w, window->h);
-        wl_surface_set_opaque_region(wind->surface, region);
-        wl_region_destroy(region);
-
-        wind->shell_surface.zxdg.initial_configure_seen = SDL_TRUE;
+    if (window->flags & SDL_WINDOW_FULLSCREEN) {
+        min_width = 0;
+        min_height = 0;
+        max_width = 0;
+        max_height = 0;
+    } else if (window->flags & SDL_WINDOW_RESIZABLE) {
+        min_width = window->min_w;
+        min_height = window->min_h;
+        max_width = window->max_w;
+        max_height = window->max_h;
     } else {
-        wind->resize.pending = SDL_TRUE;
-        wind->resize.configure = SDL_TRUE;
-        wind->resize.serial = serial;
-        if (!(window->flags & SDL_WINDOW_OPENGL)) {
-            Wayland_HandlePendingResize(window);  /* OpenGL windows handle this in SwapWindow */
+        min_width = window->windowed.w;
+        min_height = window->windowed.h;
+        max_width = window->windowed.w;
+        max_height = window->windowed.h;
+    }
+
+#ifdef HAVE_LIBDECOR_H
+    if (viddata->shell.libdecor) {
+        if (wind->shell_surface.libdecor.frame == NULL) {
+            return; /* Can't do anything yet, wait for ShowWindow */
+        }
+        libdecor_frame_set_min_content_size(wind->shell_surface.libdecor.frame,
+                                            min_width,
+                                            min_height);
+        libdecor_frame_set_max_content_size(wind->shell_surface.libdecor.frame,
+                                            max_width,
+                                            max_height);
+    } else
+#endif
+    if (viddata->shell.xdg) {
+        if (wind->shell_surface.xdg.roleobj.toplevel == NULL) {
+            return; /* Can't do anything yet, wait for ShowWindow */
+        }
+        xdg_toplevel_set_min_size(wind->shell_surface.xdg.roleobj.toplevel,
+                                  min_width,
+                                  min_height);
+        xdg_toplevel_set_max_size(wind->shell_surface.xdg.roleobj.toplevel,
+                                  max_width,
+                                  max_height);
+        if (commit) {
+            wl_surface_commit(wind->surface);
         }
     }
 }
 
-static const struct zxdg_surface_v6_listener shell_surface_listener_zxdg = {
-    handle_configure_zxdg_shell_surface
-};
-
-
 static void
-handle_configure_zxdg_toplevel(void *data,
-              struct zxdg_toplevel_v6 *zxdg_toplevel_v6,
-              int32_t width,
-              int32_t height,
-              struct wl_array *states)
+SetFullscreen(SDL_Window *window, struct wl_output *output, SDL_bool commit)
 {
-    SDL_WindowData *wind = (SDL_WindowData *)data;
-    SDL_Window *window = wind->sdlwindow;
+    SDL_WindowData *wind = window->driverdata;
+    SDL_VideoData *viddata = wind->waylandData;
 
-    enum zxdg_toplevel_v6_state *state;
-    SDL_bool fullscreen = SDL_FALSE;
-    wl_array_for_each(state, states) {
-        if (*state == ZXDG_TOPLEVEL_V6_STATE_FULLSCREEN) {
-            fullscreen = SDL_TRUE;
+    /* The desktop may try to enforce min/max sizes here, so turn them off for
+     * fullscreen and on (if applicable) for windowed
+     */
+    SetMinMaxDimensions(window, SDL_FALSE);
+
+#ifdef HAVE_LIBDECOR_H
+    if (viddata->shell.libdecor) {
+        if (wind->shell_surface.libdecor.frame == NULL) {
+            return; /* Can't do anything yet, wait for ShowWindow */
         }
-    }
-
-    if (!fullscreen) {
-        if (width == 0 || height == 0) {
-            width = window->windowed.w;
-            height = window->windowed.h;
-        }
-
-        /* zxdg_toplevel spec states that this is a suggestion.
-           Ignore if less than or greater than max/min size. */
-
-        if ((window->flags & SDL_WINDOW_RESIZABLE)) {
-            if (window->max_w > 0) {
-                width = SDL_min(width, window->max_w);
+        if (output) {
+            if (!(window->flags & SDL_WINDOW_RESIZABLE)) {
+                /* ensure that window is resizable before going into fullscreen */
+                libdecor_frame_set_capabilities(wind->shell_surface.libdecor.frame, LIBDECOR_ACTION_RESIZE);
+                wl_surface_commit(wind->surface);
             }
-            width = SDL_max(width, window->min_w);
-
-            if (window->max_h > 0) {
-                height = SDL_min(height, window->max_h);
-            }
-            height = SDL_max(height, window->min_h);
+            libdecor_frame_set_fullscreen(wind->shell_surface.libdecor.frame, output);
         } else {
-            wind->resize.width = window->w;
-            wind->resize.height = window->h;
-            return;
+            libdecor_frame_unset_fullscreen(wind->shell_surface.libdecor.frame);
+            if (!(window->flags & SDL_WINDOW_RESIZABLE)) {
+                /* restore previous RESIZE capability */
+                libdecor_frame_unset_capabilities(wind->shell_surface.libdecor.frame, LIBDECOR_ACTION_RESIZE);
+                wl_surface_commit(wind->surface);
+            }
+        }
+    } else
+#endif
+    if (viddata->shell.xdg) {
+        if (wind->shell_surface.xdg.roleobj.toplevel == NULL) {
+            return; /* Can't do anything yet, wait for ShowWindow */
+        }
+        if (output) {
+            xdg_toplevel_set_fullscreen(wind->shell_surface.xdg.roleobj.toplevel, output);
+        } else {
+            xdg_toplevel_unset_fullscreen(wind->shell_surface.xdg.roleobj.toplevel);
+        }
+        if (commit) {
+            wl_surface_commit(wind->surface);
         }
     }
-
-    if (width == 0 || height == 0) {
-        wind->resize.width = window->w;
-        wind->resize.height = window->h;
-        return;
-    }
-
-    wind->resize.width = width;
-    wind->resize.height = height;
 }
 
+static const struct wl_callback_listener surface_frame_listener;
+
 static void
-handle_close_zxdg_toplevel(void *data, struct zxdg_toplevel_v6 *zxdg_toplevel_v6)
+handle_surface_frame_done(void *data, struct wl_callback *cb, uint32_t time)
 {
-    SDL_WindowData *window = (SDL_WindowData *)data;
-    SDL_SendWindowEvent(window->sdlwindow, SDL_WINDOWEVENT_CLOSE, 0, 0);
+    SDL_WindowData *wind = (SDL_WindowData *) data;
+    SDL_AtomicSet(&wind->swap_interval_ready, 1);  /* mark window as ready to present again. */
+
+    /* reset this callback to fire again once a new frame was presented and compositor wants the next one. */
+    wind->frame_callback = wl_surface_frame(wind->frame_surface_wrapper);
+    wl_callback_destroy(cb);
+    wl_callback_add_listener(wind->frame_callback, &surface_frame_listener, data);
 }
 
-static const struct zxdg_toplevel_v6_listener toplevel_listener_zxdg = {
-    handle_configure_zxdg_toplevel,
-    handle_close_zxdg_toplevel
+static const struct wl_callback_listener surface_frame_listener = {
+    handle_surface_frame_done
 };
 
 
+static void Wayland_HandleResize(SDL_Window *window, int width, int height, float scale);
 
 static void
 handle_configure_xdg_shell_surface(void *data, struct xdg_surface *xdg, uint32_t serial)
 {
     SDL_WindowData *wind = (SDL_WindowData *)data;
     SDL_Window *window = wind->sdlwindow;
-    struct wl_region *region;
 
-    if (!wind->shell_surface.xdg.initial_configure_seen) {
-        window->w = 0;
-        window->h = 0;
-        SDL_SendWindowEvent(window, SDL_WINDOWEVENT_RESIZED, wind->resize.width, wind->resize.height);
-        window->w = wind->resize.width;
-        window->h = wind->resize.height;
+    Wayland_HandleResize(window, window->w, window->h, wind->scale_factor);
+    xdg_surface_ack_configure(xdg, serial);
 
-        wl_surface_set_buffer_scale(wind->surface, get_window_scale_factor(window));
-        if (wind->egl_window) {
-            WAYLAND_wl_egl_window_resize(wind->egl_window, window->w * get_window_scale_factor(window), window->h * get_window_scale_factor(window), 0, 0);
-        }
-
-        xdg_surface_ack_configure(xdg, serial);
-
-        region = wl_compositor_create_region(wind->waylandData->compositor);
-        wl_region_add(region, 0, 0, window->w, window->h);
-        wl_surface_set_opaque_region(wind->surface, region);
-        wl_region_destroy(region);
-
-        wind->shell_surface.xdg.initial_configure_seen = SDL_TRUE;
-    } else {
-        wind->resize.pending = SDL_TRUE;
-        wind->resize.configure = SDL_TRUE;
-        wind->resize.serial = serial;
-        if (!(window->flags & SDL_WINDOW_OPENGL)) {
-            Wayland_HandlePendingResize(window);  /* OpenGL windows handle this in SwapWindow */
-        }
-    }
+    wind->shell_surface.xdg.initial_configure_seen = SDL_TRUE;
 }
 
 static const struct xdg_surface_listener shell_surface_listener_xdg = {
     handle_configure_xdg_shell_surface
 };
 
-
 static void
 handle_configure_xdg_toplevel(void *data,
               struct xdg_toplevel *xdg_toplevel,
@@ -268,19 +188,68 @@ handle_configure_xdg_toplevel(void *data,
 {
     SDL_WindowData *wind = (SDL_WindowData *)data;
     SDL_Window *window = wind->sdlwindow;
+    SDL_WaylandOutputData *driverdata;
 
     enum xdg_toplevel_state *state;
     SDL_bool fullscreen = SDL_FALSE;
+    SDL_bool maximized = SDL_FALSE;
+    SDL_bool floating = SDL_TRUE;
     wl_array_for_each(state, states) {
-        if (*state == XDG_TOPLEVEL_STATE_FULLSCREEN) {
+        switch (*state) {
+        case XDG_TOPLEVEL_STATE_FULLSCREEN:
             fullscreen = SDL_TRUE;
+            floating = SDL_FALSE;
+            break;
+        case XDG_TOPLEVEL_STATE_MAXIMIZED:
+            maximized = SDL_TRUE;
+            floating = SDL_FALSE;
+            break;
+        case XDG_TOPLEVEL_STATE_TILED_LEFT:
+        case XDG_TOPLEVEL_STATE_TILED_RIGHT:
+        case XDG_TOPLEVEL_STATE_TILED_TOP:
+        case XDG_TOPLEVEL_STATE_TILED_BOTTOM:
+            floating = SDL_FALSE;
+            break;
+        default:
+            break;
         }
-     }
+    }
+
+    driverdata = (SDL_WaylandOutputData *) SDL_GetDisplayForWindow(window)->driverdata;
 
     if (!fullscreen) {
+        if (window->flags & SDL_WINDOW_FULLSCREEN) {
+            /* We might need to re-enter fullscreen after being restored from minimized */
+            SetFullscreen(window, driverdata->output, SDL_FALSE);
+
+            /* Foolishly do what the compositor says here. If it's wrong, don't
+             * blame us, we were explicitly instructed to do this.
+             *
+             * UPDATE: Nope, we can't actually do that, the compositor may give
+             * us a completely stateless, sizeless configure, with which we have
+             * to enforce our own state anyway.
+             */
+            if (width != 0 && height != 0 && (window->w != width || window->h != height)) {
+                window->w = width;
+                window->h = height;
+                wind->needs_resize_event = SDL_TRUE;
+            }
+
+            /* This part is good though. */
+            if ((window->flags & SDL_WINDOW_ALLOW_HIGHDPI) && wind->scale_factor != driverdata->scale_factor) {
+                wind->scale_factor = driverdata->scale_factor;
+                wind->needs_resize_event = SDL_TRUE;
+            }
+
+            return;
+        }
+
         if (width == 0 || height == 0) {
-            width = window->windowed.w;
-            height = window->windowed.h;
+            /* This usually happens when we're being restored from a
+             * non-floating state, so use the cached floating size here.
+             */
+            width = wind->floating_width;
+            height = wind->floating_height;
         }
 
         /* xdg_toplevel spec states that this is a suggestion.
@@ -296,21 +265,56 @@ handle_configure_xdg_toplevel(void *data,
                 height = SDL_min(height, window->max_h);
             }
             height = SDL_max(height, window->min_h);
-        } else {
-            wind->resize.width = window->w;
-            wind->resize.height = window->h;
-            return;
+        } else if (floating) {
+            /* If we're a fixed-size window, we know our size for sure.
+             * Always assume the configure is wrong.
+             */
+            width = window->windowed.w;
+            height = window->windowed.h;
+        }
+
+        /* Always send a maximized/restore event; if the event is redundant it will
+         * automatically be discarded (see src/events/SDL_windowevents.c)
+         *
+         * No, we do not get minimize events from xdg-shell.
+         */
+        SDL_SendWindowEvent(window,
+                            maximized ?
+                                SDL_WINDOWEVENT_MAXIMIZED :
+                                SDL_WINDOWEVENT_RESTORED,
+                            0, 0);
+
+        /* Store current floating dimensions for restoring */
+        if (floating) {
+            wind->floating_width = width;
+            wind->floating_height = height;
+        }
+
+        /* Store this now so the xdg_surface configure knows what to resize to */
+        if (window->w != width || window->h != height) {
+            window->w = width;
+            window->h = height;
+            wind->needs_resize_event = SDL_TRUE;
+        }
+    } else {
+        /* For fullscreen, foolishly do what the compositor says. If it's wrong,
+         * don't blame us, we were explicitly instructed to do this.
+         *
+         * UPDATE: Nope, sure enough a compositor sends 0,0. This is a known bug:
+         * https://bugs.kde.org/show_bug.cgi?id=444962
+         */
+        if (width != 0 && height != 0 && (window->w != width || window->h != height)) {
+            window->w = width;
+            window->h = height;
+            wind->needs_resize_event = SDL_TRUE;
+        }
+
+        /* This part is good though. */
+        if ((window->flags & SDL_WINDOW_ALLOW_HIGHDPI) && wind->scale_factor != driverdata->scale_factor) {
+            wind->scale_factor = driverdata->scale_factor;
+            wind->needs_resize_event = SDL_TRUE;
         }
     }
-
-    if (width == 0 || height == 0) {
-        wind->resize.width = window->w;
-        wind->resize.height = window->h;
-        return;
-    }
-
-    wind->resize.width = width;
-    wind->resize.height = height;
 }
 
 static void
@@ -325,8 +329,155 @@ static const struct xdg_toplevel_listener toplevel_listener_xdg = {
     handle_close_xdg_toplevel
 };
 
+#ifdef HAVE_LIBDECOR_H
+static void
+decoration_frame_configure(struct libdecor_frame *frame,
+                           struct libdecor_configuration *configuration,
+                           void *user_data)
+{
+    SDL_WindowData *wind = (SDL_WindowData *)user_data;
+    SDL_Window *window = wind->sdlwindow;
+    SDL_WaylandOutputData *driverdata;
+    struct libdecor_state *state;
 
+    enum libdecor_window_state window_state;
+    int width, height;
+    float scale_factor = wind->scale_factor;
 
+    SDL_bool focused = SDL_FALSE;
+    SDL_bool fullscreen = SDL_FALSE;
+    SDL_bool maximized = SDL_FALSE;
+    SDL_bool tiled = SDL_FALSE;
+    SDL_bool floating;
+
+    static const enum libdecor_window_state tiled_states = (
+        LIBDECOR_WINDOW_STATE_TILED_LEFT | LIBDECOR_WINDOW_STATE_TILED_RIGHT |
+        LIBDECOR_WINDOW_STATE_TILED_TOP | LIBDECOR_WINDOW_STATE_TILED_BOTTOM
+    );
+
+    /* Window State */
+    if (libdecor_configuration_get_window_state(configuration, &window_state)) {
+        fullscreen = (window_state & LIBDECOR_WINDOW_STATE_FULLSCREEN) != 0;
+        maximized = (window_state & LIBDECOR_WINDOW_STATE_MAXIMIZED) != 0;
+        focused = (window_state & LIBDECOR_WINDOW_STATE_ACTIVE) != 0;
+        tiled = (window_state & tiled_states) != 0;
+    }
+    floating = !(fullscreen || maximized || tiled);
+
+    driverdata = (SDL_WaylandOutputData *) SDL_GetDisplayForWindow(window)->driverdata;
+
+    if (!fullscreen) {
+        if (window->flags & SDL_WINDOW_FULLSCREEN) {
+            /* We might need to re-enter fullscreen after being restored from minimized */
+            SetFullscreen(window, driverdata->output, SDL_FALSE);
+            fullscreen = SDL_TRUE;
+            floating = SDL_FALSE;
+        }
+
+        /* Always send a maximized/restore event; if the event is redundant it will
+         * automatically be discarded (see src/events/SDL_windowevents.c)
+         *
+         * No, we do not get minimize events from libdecor.
+         */
+        if (!fullscreen) {
+            SDL_SendWindowEvent(window,
+                                maximized ?
+                                    SDL_WINDOWEVENT_MAXIMIZED :
+                                    SDL_WINDOWEVENT_RESTORED,
+                                0, 0);
+        }
+    }
+
+    /* Similar to maximized/restore events above, send focus events too! */
+    SDL_SendWindowEvent(window,
+                        focused ?
+                            SDL_WINDOWEVENT_FOCUS_GAINED :
+                            SDL_WINDOWEVENT_FOCUS_LOST,
+                        0, 0);
+
+    /* For fullscreen or fixed-size windows we know our size.
+     * Always assume the configure is wrong.
+     */
+    if (fullscreen) {
+        /* FIXME: We have been explicitly told to respect the fullscreen size
+         * parameters here, even though they are known to be wrong on GNOME at
+         * bare minimum. If this is wrong, don't blame us, we were explicitly
+         * told to do this.
+         */
+        if (!libdecor_configuration_get_content_size(configuration, frame,
+                                                     &width, &height)) {
+            width = window->w;
+            height = window->h;
+        }
+
+        /* This part is good though. */
+        if (window->flags & SDL_WINDOW_ALLOW_HIGHDPI) {
+            scale_factor = driverdata->scale_factor;
+        }
+    } else if (!(window->flags & SDL_WINDOW_RESIZABLE) || (floating && wind->floating_resize_pending)) {
+        width = window->windowed.w;
+        height = window->windowed.h;
+        wind->floating_resize_pending = SDL_FALSE;
+    } else {
+        /* This will never set 0 for width/height unless the function returns false */
+        if (!libdecor_configuration_get_content_size(configuration, frame, &width, &height)) {
+            if (floating) {
+                /* This usually happens when we're being restored from a
+                 * non-floating state, so use the cached floating size here.
+                 */
+                width = wind->floating_width;
+                height = wind->floating_height;
+            } else {
+                width = window->w;
+                height = window->h;
+            }
+        }
+    }
+
+    /* Store current floating dimensions for restoring */
+    if (floating) {
+        wind->floating_width = width;
+        wind->floating_height = height;
+    }
+
+    /* Do the resize on the SDL side (this will set window->w/h)... */
+    Wayland_HandleResize(window, width, height, scale_factor);
+    wind->shell_surface.libdecor.initial_configure_seen = SDL_TRUE;
+
+    /* ... then commit the changes on the libdecor side. */
+    state = libdecor_state_new(width, height);
+    libdecor_frame_commit(frame, state, configuration);
+    libdecor_state_free(state);
+
+    /* Update the resize capability. Since this will change the capabilities and
+     * commit a new frame state with the last known content dimension, this has
+     * to be called after the new state has been commited and the new content
+     * dimensions were updated.
+     */
+    Wayland_SetWindowResizable(SDL_GetVideoDevice(), window,
+                               window->flags & SDL_WINDOW_RESIZABLE);
+}
+
+static void
+decoration_frame_close(struct libdecor_frame *frame, void *user_data)
+{
+    SDL_SendWindowEvent(((SDL_WindowData *)user_data)->sdlwindow, SDL_WINDOWEVENT_CLOSE, 0, 0);
+}
+
+static void
+decoration_frame_commit(struct libdecor_frame *frame, void *user_data)
+{
+    SDL_WindowData *wind = user_data;
+
+    SDL_SendWindowEvent(wind->sdlwindow, SDL_WINDOWEVENT_EXPOSED, 0, 0);
+}
+
+static struct libdecor_frame_interface libdecor_frame_interface = {
+    decoration_frame_configure,
+    decoration_frame_close,
+    decoration_frame_commit,
+};
+#endif
 
 #ifdef SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH
 static void
@@ -357,63 +508,100 @@ static const struct qt_extended_surface_listener extended_surface_listener = {
 #endif /* SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH */
 
 static void
-update_scale_factor(SDL_WindowData *window) {
-   float old_factor = window->scale_factor, new_factor = 0.0;
-   int i;
+update_scale_factor(SDL_WindowData *window)
+{
+    float old_factor = window->scale_factor;
+    float new_factor;
+    int i;
 
-   if (!(window->sdlwindow->flags & SDL_WINDOW_ALLOW_HIGHDPI)) {
-       return;
-   }
+    if (!(window->sdlwindow->flags & SDL_WINDOW_ALLOW_HIGHDPI)) {
+        /* Scale will always be 1, just ignore this */
+        return;
+    }
 
-   if (!window->num_outputs) {
-       new_factor = old_factor;
-   }
+    if (FULLSCREEN_VISIBLE(window->sdlwindow)) {
+        /* For fullscreen, use the active display's scale factor */
+        SDL_VideoDisplay *display = SDL_GetDisplayForWindow(window->sdlwindow);
+        SDL_WaylandOutputData* driverdata = display->driverdata;
+        new_factor = driverdata->scale_factor;
+    } else if (window->num_outputs == 0) {
+        /* No monitor (somehow)? Just fall back. */
+        new_factor = old_factor;
+    } else {
+        /* Check every display's factor, use the highest */
+        new_factor = 0.0f;
+        for (i = 0; i < window->num_outputs; i++) {
+            SDL_WaylandOutputData* driverdata = window->outputs[i];
+            if (driverdata->scale_factor > new_factor) {
+                new_factor = driverdata->scale_factor;
+            }
+        }
+    }
 
-   if (FULLSCREEN_VISIBLE(window->sdlwindow) && window->sdlwindow->fullscreen_mode.driverdata) {
-       new_factor = ((SDL_WaylandOutputData*)(wl_output_get_user_data(window->sdlwindow->fullscreen_mode.driverdata)))->scale_factor;
-   }
+    if (new_factor != old_factor) {
+        Wayland_HandleResize(window->sdlwindow, window->sdlwindow->w, window->sdlwindow->h, new_factor);
+    }
+}
 
-   for (i = 0; i < window->num_outputs; i++) {
-       float factor = ((SDL_WaylandOutputData*)(wl_output_get_user_data(window->outputs[i])))->scale_factor;
-       if (factor > new_factor) {
-           new_factor = factor;
-       }
-   }
-
-   if (new_factor != old_factor) {
-       /* force the resize event to trigger, as the logical size didn't change */
-       window->resize.width = window->sdlwindow->w;
-       window->resize.height = window->sdlwindow->h;
-       window->resize.scale_factor = new_factor;
-       window->resize.pending = SDL_TRUE;
-       if (!(window->sdlwindow->flags & SDL_WINDOW_OPENGL)) {
-           Wayland_HandlePendingResize(window->sdlwindow);  /* OpenGL windows handle this in SwapWindow */
-       }
-   }
+/* While we can't get window position from the compositor, we do at least know
+ * what monitor we're on, so let's send move events that put the window at the
+ * center of the whatever display the wl_surface_listener events give us.
+ */
+static void
+Wayland_move_window(SDL_Window *window,
+                    SDL_WaylandOutputData *driverdata)
+{
+    int i, numdisplays = SDL_GetNumVideoDisplays();
+    for (i = 0; i < numdisplays; i += 1) {
+        if (SDL_GetDisplay(i)->driverdata == driverdata) {
+            SDL_SendWindowEvent(window, SDL_WINDOWEVENT_MOVED,
+                                SDL_WINDOWPOS_CENTERED_DISPLAY(i),
+                                SDL_WINDOWPOS_CENTERED_DISPLAY(i));
+            break;
+        }
+    }
 }
 
 static void
 handle_surface_enter(void *data, struct wl_surface *surface,
-        struct wl_output *output) {
+                     struct wl_output *output)
+{
     SDL_WindowData *window = data;
+    SDL_WaylandOutputData *driverdata = wl_output_get_user_data(output);
 
-    window->outputs = SDL_realloc(window->outputs, (window->num_outputs + 1) * sizeof *window->outputs);
-    window->outputs[window->num_outputs++] = output;
+    if (!SDL_WAYLAND_own_output(output) || !SDL_WAYLAND_own_surface(surface)) {
+        return;
+    }
+
+    window->outputs = SDL_realloc(window->outputs,
+                                  sizeof(SDL_WaylandOutputData*) * (window->num_outputs + 1));
+    window->outputs[window->num_outputs++] = driverdata;
     update_scale_factor(window);
+
+    Wayland_move_window(window->sdlwindow, driverdata);
 }
 
 static void
 handle_surface_leave(void *data, struct wl_surface *surface,
-        struct wl_output *output) {
+                     struct wl_output *output)
+{
     SDL_WindowData *window = data;
-    int i;
+    int i, send_move_event = 0;
+    SDL_WaylandOutputData *driverdata = wl_output_get_user_data(output);
+
+    if (!SDL_WAYLAND_own_output(output) || !SDL_WAYLAND_own_surface(surface)) {
+        return;
+    }
 
     for (i = 0; i < window->num_outputs; i++) {
-        if (window->outputs[i] == output) {  /* remove this one */
+        if (window->outputs[i] == driverdata) {  /* remove this one */
             if (i == (window->num_outputs-1)) {
                 window->outputs[i] = NULL;
+                send_move_event = 1;
             } else {
-                SDL_memmove(&window->outputs[i], &window->outputs[i+1], sizeof (output) * ((window->num_outputs - i) - 1));
+                SDL_memmove(&window->outputs[i],
+                            &window->outputs[i + 1],
+                            sizeof(SDL_WaylandOutputData*) * ((window->num_outputs - i) - 1));
             }
             window->num_outputs--;
             i--;
@@ -421,8 +609,11 @@ handle_surface_leave(void *data, struct wl_surface *surface,
     }
 
     if (window->num_outputs == 0) {
-       SDL_free(window->outputs);
-       window->outputs = NULL;
+        SDL_free(window->outputs);
+        window->outputs = NULL;
+    } else if (send_move_event) {
+        Wayland_move_window(window->sdlwindow,
+                            window->outputs[window->num_outputs - 1]);
     }
 
     update_scale_factor(window);
@@ -436,10 +627,11 @@ static const struct wl_surface_listener surface_listener = {
 SDL_bool
 Wayland_GetWindowWMInfo(_THIS, SDL_Window * window, SDL_SysWMinfo * info)
 {
+    SDL_VideoData *viddata = (SDL_VideoData *) _this->driverdata;
     SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
-    const Uint32 version = ((((Uint32) info->version.major) * 1000000) +
-                            (((Uint32) info->version.minor) * 10000) +
-                            (((Uint32) info->version.patch)));
+    const Uint32 version = SDL_VERSIONNUM((Uint32)info->version.major,
+                                          (Uint32)info->version.minor,
+                                          (Uint32)info->version.patch);
 
     /* Before 2.0.6, it was possible to build an SDL with Wayland support
        (SDL_SysWMinfo will be large enough to hold Wayland info), but build
@@ -451,7 +643,7 @@ Wayland_GetWindowWMInfo(_THIS, SDL_Window * window, SDL_SysWMinfo * info)
        just return an error for older apps using this function. Those apps
        will need to be recompiled against newer headers or not use Wayland,
        maybe by forcing SDL_VIDEODRIVER=x11. */
-    if (version < 2000006) {
+    if (version < SDL_VERSIONNUM(2, 0, 6)) {
         info->subsystem = SDL_SYSWM_UNKNOWN;
         SDL_SetError("Version must be 2.0.6 or newer");
         return SDL_FALSE;
@@ -459,7 +651,34 @@ Wayland_GetWindowWMInfo(_THIS, SDL_Window * window, SDL_SysWMinfo * info)
 
     info->info.wl.display = data->waylandData->display;
     info->info.wl.surface = data->surface;
-    info->info.wl.shell_surface = data->shell_surface.wl;
+
+    if (version >= SDL_VERSIONNUM(2, 0, 15)) {
+        info->info.wl.egl_window = data->egl_window;
+
+#ifdef HAVE_LIBDECOR_H
+        if (viddata->shell.libdecor && data->shell_surface.libdecor.frame != NULL) {
+            info->info.wl.xdg_surface = libdecor_frame_get_xdg_surface(data->shell_surface.libdecor.frame);
+            if (version >= SDL_VERSIONNUM(2, 0, 17)) {
+                info->info.wl.xdg_toplevel = libdecor_frame_get_xdg_toplevel(data->shell_surface.libdecor.frame);
+            }
+        } else
+#endif
+        if (viddata->shell.xdg && data->shell_surface.xdg.surface != NULL) {
+            info->info.wl.xdg_surface = data->shell_surface.xdg.surface;
+            if (version >= SDL_VERSIONNUM(2, 0, 17)) {
+                info->info.wl.xdg_toplevel = data->shell_surface.xdg.roleobj.toplevel;
+            }
+        } else {
+            info->info.wl.xdg_surface = NULL;
+            if (version >= SDL_VERSIONNUM(2, 0, 17)) {
+                info->info.wl.xdg_toplevel = NULL;
+            }
+        }
+    }
+
+    /* Deprecated in 2.0.16 */
+    info->info.wl.shell_surface = NULL;
+
     info->subsystem = SDL_SYSWM_WAYLAND;
 
     return SDL_TRUE;
@@ -471,41 +690,286 @@ Wayland_SetWindowHitTest(SDL_Window *window, SDL_bool enabled)
     return 0;  /* just succeed, the real work is done elsewhere. */
 }
 
-static void
-SetFullscreen(_THIS, SDL_Window * window, struct wl_output *output)
+int
+Wayland_SetWindowModalFor(_THIS, SDL_Window *modal_window, SDL_Window *parent_window)
 {
-    const SDL_VideoData *viddata = (const SDL_VideoData *) _this->driverdata;
-    SDL_WindowData *wind = window->driverdata;
+    SDL_VideoData *viddata = (SDL_VideoData *) _this->driverdata;
+    SDL_WindowData *modal_data = modal_window->driverdata;
+    SDL_WindowData *parent_data = parent_window->driverdata;
 
+#ifdef HAVE_LIBDECOR_H
+    if (viddata->shell.libdecor) {
+        if (modal_data->shell_surface.libdecor.frame == NULL) {
+            return SDL_SetError("Modal window was hidden");
+        }
+        if (parent_data->shell_surface.libdecor.frame == NULL) {
+            return SDL_SetError("Parent window was hidden");
+        }
+        libdecor_frame_set_parent(modal_data->shell_surface.libdecor.frame,
+                                  parent_data->shell_surface.libdecor.frame);
+    } else
+#endif
     if (viddata->shell.xdg) {
-        if (output) {
-            xdg_toplevel_set_fullscreen(wind->shell_surface.xdg.roleobj.toplevel, output);
-        } else {
-            xdg_toplevel_unset_fullscreen(wind->shell_surface.xdg.roleobj.toplevel);
+        if (modal_data->shell_surface.xdg.roleobj.toplevel == NULL) {
+            return SDL_SetError("Modal window was hidden");
         }
-    } else if (viddata->shell.zxdg) {
-        if (output) {
-            zxdg_toplevel_v6_set_fullscreen(wind->shell_surface.zxdg.roleobj.toplevel, output);
-        } else {
-            zxdg_toplevel_v6_unset_fullscreen(wind->shell_surface.zxdg.roleobj.toplevel);
+        if (parent_data->shell_surface.xdg.roleobj.toplevel == NULL) {
+            return SDL_SetError("Parent window was hidden");
         }
+        xdg_toplevel_set_parent(modal_data->shell_surface.xdg.roleobj.toplevel,
+                                parent_data->shell_surface.xdg.roleobj.toplevel);
     } else {
-        if (output) {
-            wl_shell_surface_set_fullscreen(wind->shell_surface.wl,
-                                            WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT,
-                                            0, output);
-        } else {
-            wl_shell_surface_set_toplevel(wind->shell_surface.wl);
-        }
+        return SDL_Unsupported();
     }
 
-    WAYLAND_wl_display_flush( ((SDL_VideoData*)_this->driverdata)->display );
+    WAYLAND_wl_display_flush(viddata->display);
+    return 0;
 }
 
 void Wayland_ShowWindow(_THIS, SDL_Window *window)
 {
-    struct wl_output *output = (struct wl_output *) window->fullscreen_mode.driverdata;
-    SetFullscreen(_this, window, (window->flags & SDL_WINDOW_FULLSCREEN) ? output : NULL);
+    SDL_VideoData *c = _this->driverdata;
+    SDL_WindowData *data = window->driverdata;
+
+    /* Create the shell surface and map the toplevel */
+#ifdef HAVE_LIBDECOR_H
+    if (c->shell.libdecor) {
+        data->shell_surface.libdecor.frame = libdecor_decorate(c->shell.libdecor,
+                                                               data->surface,
+                                                               &libdecor_frame_interface,
+                                                               data);
+        if (data->shell_surface.libdecor.frame == NULL) {
+            SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "Failed to create libdecor frame!");
+        } else {
+            libdecor_frame_set_app_id(data->shell_surface.libdecor.frame, c->classname);
+            libdecor_frame_map(data->shell_surface.libdecor.frame);
+        }
+    } else
+#endif
+    if (c->shell.xdg) {
+        data->shell_surface.xdg.surface = xdg_wm_base_get_xdg_surface(c->shell.xdg, data->surface);
+        xdg_surface_set_user_data(data->shell_surface.xdg.surface, data);
+        xdg_surface_add_listener(data->shell_surface.xdg.surface, &shell_surface_listener_xdg, data);
+
+        /* !!! FIXME: add popup role */
+        data->shell_surface.xdg.roleobj.toplevel = xdg_surface_get_toplevel(data->shell_surface.xdg.surface);
+        xdg_toplevel_set_app_id(data->shell_surface.xdg.roleobj.toplevel, c->classname);
+        xdg_toplevel_add_listener(data->shell_surface.xdg.roleobj.toplevel, &toplevel_listener_xdg, data);
+    }
+
+    /* Restore state that was set prior to this call */
+    Wayland_SetWindowTitle(_this, window);
+    if (window->flags & SDL_WINDOW_MAXIMIZED) {
+        Wayland_MaximizeWindow(_this, window);
+    }
+    if (window->flags & SDL_WINDOW_MINIMIZED) {
+        Wayland_MinimizeWindow(_this, window);
+    }
+
+    /* We have to wait until the surface gets a "configure" event, or use of
+     * this surface will fail. This is a new rule for xdg_shell.
+     */
+#ifdef HAVE_LIBDECOR_H
+    if (c->shell.libdecor) {
+        if (data->shell_surface.libdecor.frame) {
+            while (!data->shell_surface.libdecor.initial_configure_seen) {
+                WAYLAND_wl_display_flush(c->display);
+                WAYLAND_wl_display_dispatch(c->display);
+            }
+        }
+    } else
+#endif
+    if (c->shell.xdg) {
+        /* Unlike libdecor we need to call this explicitly to prevent a deadlock.
+         * libdecor will call this as part of their configure event!
+         * -flibit
+         */
+        SDL_WaylandOutputData *odata = SDL_GetDisplayForWindow(window)->driverdata;
+        SetFullscreen(window, (window->flags & SDL_WINDOW_FULLSCREEN) ? odata->output : NULL, SDL_TRUE);
+        if (data->shell_surface.xdg.surface) {
+            while (!data->shell_surface.xdg.initial_configure_seen) {
+                WAYLAND_wl_display_flush(c->display);
+                WAYLAND_wl_display_dispatch(c->display);
+            }
+        }
+
+        /* Create the window decorations */
+        if (data->shell_surface.xdg.roleobj.toplevel && c->decoration_manager) {
+            data->server_decoration = zxdg_decoration_manager_v1_get_toplevel_decoration(c->decoration_manager, data->shell_surface.xdg.roleobj.toplevel);
+        }
+    } else {
+        /* Nothing to see here, just commit. */
+        wl_surface_commit(data->surface);
+    }
+
+    /* Unlike the rest of window state we have to set this _after_ flushing the
+     * display, because we need to create the decorations before possibly hiding
+     * them immediately afterward.
+     */
+#ifdef HAVE_LIBDECOR_H
+    if (c->shell.libdecor) {
+        /* ... but don't call it redundantly for libdecor, the decorator
+         * may not interpret a redundant call nicely and cause weird stuff to happen
+         */
+        if (window->flags & SDL_WINDOW_BORDERLESS) {
+            Wayland_SetWindowBordered(_this, window, SDL_FALSE);
+        }
+    } else
+#endif
+    {
+        Wayland_SetWindowBordered(_this, window, !(window->flags & SDL_WINDOW_BORDERLESS));
+    }
+
+    /* We're finally done putting the window together, raise if possible */
+    if (c->activation_manager) {
+        /* Note that we don't check for empty strings, as that is still
+         * considered a valid activation token!
+         */
+        const char *activation_token = SDL_getenv("XDG_ACTIVATION_TOKEN");
+        if (activation_token) {
+            xdg_activation_v1_activate(c->activation_manager,
+                                       activation_token,
+                                       data->surface);
+
+            /* Clear this variable, per the protocol's request */
+            unsetenv("XDG_ACTIVATION_TOKEN");
+        }
+    }
+}
+
+void Wayland_HideWindow(_THIS, SDL_Window *window)
+{
+    SDL_VideoData *data = _this->driverdata;
+    SDL_WindowData *wind = window->driverdata;
+
+    if (wind->server_decoration) {
+       zxdg_toplevel_decoration_v1_destroy(wind->server_decoration);
+       wind->server_decoration = NULL;
+    }
+
+#ifdef HAVE_LIBDECOR_H
+    if (data->shell.libdecor) {
+        if (wind->shell_surface.libdecor.frame) {
+            libdecor_frame_unref(wind->shell_surface.libdecor.frame);
+            wind->shell_surface.libdecor.frame = NULL;
+        }
+    } else
+#endif
+    if (data->shell.xdg) {
+        if (wind->shell_surface.xdg.roleobj.toplevel) {
+            xdg_toplevel_destroy(wind->shell_surface.xdg.roleobj.toplevel);
+            wind->shell_surface.xdg.roleobj.toplevel = NULL;
+        }
+        if (wind->shell_surface.xdg.surface) {
+            xdg_surface_destroy(wind->shell_surface.xdg.surface);
+            wind->shell_surface.xdg.surface = NULL;
+        }
+    }
+
+    /* Be sure to detach after this is done, otherwise ShowWindow crashes! */
+    wl_surface_attach(wind->surface, NULL, 0, 0);
+    wl_surface_commit(wind->surface);
+}
+
+static void
+handle_xdg_activation_done(void *data,
+                           struct xdg_activation_token_v1 *xdg_activation_token_v1,
+                           const char *token)
+{
+    SDL_WindowData *window = data;
+    if (xdg_activation_token_v1 == window->activation_token) {
+        xdg_activation_v1_activate(window->waylandData->activation_manager,
+                                   token,
+                                   window->surface);
+        xdg_activation_token_v1_destroy(window->activation_token);
+        window->activation_token = NULL;
+    }
+}
+
+static const struct xdg_activation_token_v1_listener activation_listener_xdg = {
+    handle_xdg_activation_done
+};
+
+/* The xdg-activation protocol considers "activation" to be one of two things:
+ *
+ * 1: Raising a window to the top and flashing the titlebar
+ * 2: Flashing the titlebar while keeping the window where it is
+ *
+ * As you might expect from Wayland, the general policy is to go with #2 unless
+ * the client can prove to the compositor beyond a reasonable doubt that raising
+ * the window will not be malicuous behavior.
+ *
+ * For SDL this means RaiseWindow and FlashWindow both use the same protocol,
+ * but in different ways: RaiseWindow will provide as _much_ information as
+ * possible while FlashWindow will provide as _little_ information as possible,
+ * to nudge the compositor into doing what we want.
+ *
+ * This isn't _strictly_ what the protocol says will happen, but this is what
+ * current implementations are doing (as of writing, YMMV in the far distant
+ * future).
+ *
+ * -flibit
+ */
+static void
+Wayland_activate_window(SDL_VideoData *data, SDL_WindowData *wind,
+                        struct wl_surface *surface,
+                        uint32_t serial, struct wl_seat *seat)
+{
+    if (data->activation_manager) {
+        if (wind->activation_token != NULL) {
+            /* We're about to overwrite this with a new request */
+            xdg_activation_token_v1_destroy(wind->activation_token);
+        }
+
+        wind->activation_token = xdg_activation_v1_get_activation_token(data->activation_manager);
+        xdg_activation_token_v1_add_listener(wind->activation_token,
+                                             &activation_listener_xdg,
+                                             wind);
+
+        /* Note that we are not setting the app_id or serial here.
+         *
+         * Hypothetically we could set the app_id from data->classname, but
+         * that part of the API is for _external_ programs, not ourselves.
+         *
+         * -flibit
+         */
+        if (surface != NULL) {
+            xdg_activation_token_v1_set_surface(wind->activation_token, surface);
+        }
+        if (seat != NULL) {
+            xdg_activation_token_v1_set_serial(wind->activation_token, serial, seat);
+        }
+        xdg_activation_token_v1_commit(wind->activation_token);
+    }
+}
+
+void
+Wayland_RaiseWindow(_THIS, SDL_Window *window)
+{
+    SDL_WindowData *wind = window->driverdata;
+
+    /* FIXME: This Raise event is arbitrary and doesn't come from an event, so
+     * it's actually very likely that this token will be ignored! Maybe add
+     * support for passing serials (and the associated seat) so this can have
+     * a better chance of actually raising the window.
+     * -flibit
+     */
+    Wayland_activate_window(_this->driverdata,
+                            wind,
+                            wind->surface,
+                            0,
+                            NULL);
+}
+
+int
+Wayland_FlashWindow(_THIS, SDL_Window *window, SDL_FlashOperation operation)
+{
+    Wayland_activate_window(_this->driverdata,
+                            window->driverdata,
+                            NULL,
+                            0,
+                            NULL);
+    return 0;
 }
 
 #ifdef SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH
@@ -514,49 +978,67 @@ QtExtendedSurface_OnHintChanged(void *userdata, const char *name,
         const char *oldValue, const char *newValue)
 {
     struct qt_extended_surface *qt_extended_surface = userdata;
+    int i;
+
+    static struct {
+        const char *name;
+        int32_t value;
+    } orientations[] = {
+        { "portrait", QT_EXTENDED_SURFACE_ORIENTATION_PRIMARYORIENTATION },
+        { "landscape", QT_EXTENDED_SURFACE_ORIENTATION_LANDSCAPEORIENTATION },
+        { "inverted-portrait", QT_EXTENDED_SURFACE_ORIENTATION_INVERTEDPORTRAITORIENTATION },
+        { "inverted-landscape", QT_EXTENDED_SURFACE_ORIENTATION_INVERTEDLANDSCAPEORIENTATION }
+    };
 
     if (name == NULL) {
         return;
     }
 
-    if (strcmp(name, SDL_HINT_QTWAYLAND_CONTENT_ORIENTATION) == 0) {
+    if (SDL_strcmp(name, SDL_HINT_QTWAYLAND_CONTENT_ORIENTATION) == 0) {
         int32_t orientation = QT_EXTENDED_SURFACE_ORIENTATION_PRIMARYORIENTATION;
 
         if (newValue != NULL) {
-            if (strcmp(newValue, "portrait") == 0) {
-                orientation = QT_EXTENDED_SURFACE_ORIENTATION_PORTRAITORIENTATION;
-            } else if (strcmp(newValue, "landscape") == 0) {
-                orientation = QT_EXTENDED_SURFACE_ORIENTATION_LANDSCAPEORIENTATION;
-            } else if (strcmp(newValue, "inverted-portrait") == 0) {
-                orientation = QT_EXTENDED_SURFACE_ORIENTATION_INVERTEDPORTRAITORIENTATION;
-            } else if (strcmp(newValue, "inverted-landscape") == 0) {
-                orientation = QT_EXTENDED_SURFACE_ORIENTATION_INVERTEDLANDSCAPEORIENTATION;
+            const char *value_attempt = newValue;
+            while (value_attempt != NULL && *value_attempt != 0) {
+                const char *value_attempt_end = SDL_strchr(value_attempt, ',');
+                size_t value_attempt_len = (value_attempt_end != NULL) ? (value_attempt_end - value_attempt)
+                                                                       : SDL_strlen(value_attempt);
+
+                for (i = 0; i < SDL_arraysize(orientations); i += 1) {
+                    if ((value_attempt_len == SDL_strlen(orientations[i].name)) &&
+                        (SDL_strncasecmp(orientations[i].name, value_attempt, value_attempt_len) == 0)) {
+                        orientation |= orientations[i].value;
+                        break;
+                    }
+                }
+
+                value_attempt = (value_attempt_end != NULL) ? (value_attempt_end + 1) : NULL;
             }
         }
 
         qt_extended_surface_set_content_orientation(qt_extended_surface, orientation);
-    } else if (strcmp(name, SDL_HINT_QTWAYLAND_WINDOW_FLAGS) == 0) {
+    } else if (SDL_strcmp(name, SDL_HINT_QTWAYLAND_WINDOW_FLAGS) == 0) {
         uint32_t flags = 0;
 
         if (newValue != NULL) {
-            char *tmp = strdup(newValue);
+            char *tmp = SDL_strdup(newValue);
             char *saveptr = NULL;
 
-            char *flag = strtok_r(tmp, " ", &saveptr);
+            char *flag = SDL_strtokr(tmp, " ", &saveptr);
             while (flag) {
-                if (strcmp(flag, "OverridesSystemGestures") == 0) {
+                if (SDL_strcmp(flag, "OverridesSystemGestures") == 0) {
                     flags |= QT_EXTENDED_SURFACE_WINDOWFLAG_OVERRIDESSYSTEMGESTURES;
-                } else if (strcmp(flag, "StaysOnTop") == 0) {
+                } else if (SDL_strcmp(flag, "StaysOnTop") == 0) {
                     flags |= QT_EXTENDED_SURFACE_WINDOWFLAG_STAYSONTOP;
-                } else if (strcmp(flag, "BypassWindowManager") == 0) {
+                } else if (SDL_strcmp(flag, "BypassWindowManager") == 0) {
                     // See https://github.com/qtproject/qtwayland/commit/fb4267103d
                     flags |= 4 /* QT_EXTENDED_SURFACE_WINDOWFLAG_BYPASSWINDOWMANAGER */;
                 }
 
-                flag = strtok_r(NULL, " ", &saveptr);
+                flag = SDL_strtokr(NULL, " ", &saveptr);
             }
 
-            free(tmp);
+            SDL_free(tmp);
         }
 
         qt_extended_surface_set_window_flags(qt_extended_surface, flags);
@@ -579,22 +1061,40 @@ Wayland_SetWindowFullscreen(_THIS, SDL_Window * window,
                             SDL_VideoDisplay * _display, SDL_bool fullscreen)
 {
     struct wl_output *output = ((SDL_WaylandOutputData*) _display->driverdata)->output;
-    SetFullscreen(_this, window, fullscreen ? output : NULL);
+    SDL_VideoData *viddata = (SDL_VideoData *) _this->driverdata;
+    SetFullscreen(window, fullscreen ? output : NULL, SDL_TRUE);
+
+    WAYLAND_wl_display_flush(viddata->display);
 }
 
 void
 Wayland_RestoreWindow(_THIS, SDL_Window * window)
 {
     SDL_WindowData *wind = window->driverdata;
-    const SDL_VideoData *viddata = (const SDL_VideoData *) _this->driverdata;
+    SDL_VideoData *viddata = (SDL_VideoData *) _this->driverdata;
 
+    /* Set this flag now even if we never actually maximized, eventually
+     * ShowWindow will take care of it along with the other window state.
+     */
+    window->flags &= ~SDL_WINDOW_MAXIMIZED;
+
+#ifdef HAVE_LIBDECOR_H
+    if (viddata->shell.libdecor) {
+        if (wind->shell_surface.libdecor.frame == NULL) {
+            return; /* Can't do anything yet, wait for ShowWindow */
+        }
+        libdecor_frame_unset_maximized(wind->shell_surface.libdecor.frame);
+    } else
+#endif
+    /* Note that xdg-shell does NOT provide a way to unset minimize! */
     if (viddata->shell.xdg) {
-    } else if (viddata->shell.zxdg) {
-    } else {
-        wl_shell_surface_set_toplevel(wind->shell_surface.wl);
+        if (wind->shell_surface.xdg.roleobj.toplevel == NULL) {
+            return; /* Can't do anything yet, wait for ShowWindow */
+        }
+        xdg_toplevel_unset_maximized(wind->shell_surface.xdg.roleobj.toplevel);
     }
 
-    WAYLAND_wl_display_flush( ((SDL_VideoData*)_this->driverdata)->display );
+    WAYLAND_wl_display_flush( viddata->display );
 }
 
 void
@@ -602,12 +1102,39 @@ Wayland_SetWindowBordered(_THIS, SDL_Window * window, SDL_bool bordered)
 {
     SDL_WindowData *wind = window->driverdata;
     const SDL_VideoData *viddata = (const SDL_VideoData *) _this->driverdata;
+#ifdef HAVE_LIBDECOR_H
+    if (viddata->shell.libdecor) {
+        if (wind->shell_surface.libdecor.frame) {
+            libdecor_frame_set_visibility(wind->shell_surface.libdecor.frame, bordered);
+        }
+    } else
+#endif
     if ((viddata->decoration_manager) && (wind->server_decoration)) {
         const enum zxdg_toplevel_decoration_v1_mode mode = bordered ? ZXDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE : ZXDG_TOPLEVEL_DECORATION_V1_MODE_CLIENT_SIDE;
         zxdg_toplevel_decoration_v1_set_mode(wind->server_decoration, mode);
-    } else if ((viddata->kwin_server_decoration_manager) && (wind->kwin_server_decoration)) {
-        const enum org_kde_kwin_server_decoration_manager_mode mode = bordered ? ORG_KDE_KWIN_SERVER_DECORATION_MANAGER_MODE_SERVER : ORG_KDE_KWIN_SERVER_DECORATION_MANAGER_MODE_NONE;
-        org_kde_kwin_server_decoration_request_mode(wind->kwin_server_decoration, mode);
+    }
+}
+
+void
+Wayland_SetWindowResizable(_THIS, SDL_Window * window, SDL_bool resizable)
+{
+#ifdef HAVE_LIBDECOR_H
+    SDL_VideoData *data = _this->driverdata;
+    const SDL_WindowData *wind = window->driverdata;
+
+    if (data->shell.libdecor) {
+        if (wind->shell_surface.libdecor.frame == NULL) {
+            return; /* Can't do anything yet, wait for ShowWindow */
+        }
+        if (resizable) {
+            libdecor_frame_set_capabilities(wind->shell_surface.libdecor.frame, LIBDECOR_ACTION_RESIZE);
+        } else {
+            libdecor_frame_unset_capabilities(wind->shell_surface.libdecor.frame, LIBDECOR_ACTION_RESIZE);
+        }
+    } else
+#endif
+    {
+        SetMinMaxDimensions(window, SDL_TRUE);
     }
 }
 
@@ -617,26 +1144,99 @@ Wayland_MaximizeWindow(_THIS, SDL_Window * window)
     SDL_WindowData *wind = window->driverdata;
     SDL_VideoData *viddata = (SDL_VideoData *) _this->driverdata;
 
-    if (viddata->shell.xdg) {
-        xdg_toplevel_set_maximized(wind->shell_surface.xdg.roleobj.toplevel);
-    } else if (viddata->shell.zxdg) {
-        zxdg_toplevel_v6_set_maximized(wind->shell_surface.zxdg.roleobj.toplevel);
-    } else {
-        wl_shell_surface_set_maximized(wind->shell_surface.wl, NULL);
+    if (!(window->flags & SDL_WINDOW_RESIZABLE)) {
+        return;
     }
 
-    WAYLAND_wl_display_flush( viddata->display );
+    /* Set this flag now even if we don't actually maximize yet, eventually
+     * ShowWindow will take care of it along with the other window state.
+     */
+    window->flags |= SDL_WINDOW_MAXIMIZED;
+
+#ifdef HAVE_LIBDECOR_H
+    if (viddata->shell.libdecor) {
+        if (wind->shell_surface.libdecor.frame == NULL) {
+            return; /* Can't do anything yet, wait for ShowWindow */
+        }
+        libdecor_frame_set_maximized(wind->shell_surface.libdecor.frame);
+    } else
+#endif
+    if (viddata->shell.xdg) {
+        if (wind->shell_surface.xdg.roleobj.toplevel == NULL) {
+            return; /* Can't do anything yet, wait for ShowWindow */
+        }
+        xdg_toplevel_set_maximized(wind->shell_surface.xdg.roleobj.toplevel);
+    }
+
+    WAYLAND_wl_display_flush(viddata->display);
 }
 
 void
-Wayland_SetWindowGrab(_THIS, SDL_Window *window, SDL_bool grabbed)
+Wayland_MinimizeWindow(_THIS, SDL_Window * window)
+{
+    SDL_WindowData *wind = window->driverdata;
+    SDL_VideoData *viddata = (SDL_VideoData *) _this->driverdata;
+
+#ifdef HAVE_LIBDECOR_H
+    if (viddata->shell.libdecor) {
+        if (wind->shell_surface.libdecor.frame == NULL) {
+            return; /* Can't do anything yet, wait for ShowWindow */
+        }
+        libdecor_frame_set_minimized(wind->shell_surface.libdecor.frame);
+    } else
+#endif
+    if (viddata->shell.xdg) {
+        if (wind->shell_surface.xdg.roleobj.toplevel == NULL) {
+            return; /* Can't do anything yet, wait for ShowWindow */
+        }
+        xdg_toplevel_set_minimized(wind->shell_surface.xdg.roleobj.toplevel);
+    }
+
+    WAYLAND_wl_display_flush(viddata->display);
+}
+
+void
+Wayland_SetWindowMouseRect(_THIS, SDL_Window *window)
 {
     SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
 
-    if (grabbed)
-        Wayland_input_confine_pointer(window, data->input);
-    else
-        Wayland_input_unconfine_pointer(data->input);
+    /* This may look suspiciously like SetWindowGrab, despite SetMouseRect not
+     * implicitly doing a grab. And you're right! Wayland doesn't let us mess
+     * around with mouse focus whatsoever, so it just happens to be that the
+     * work that we can do in these two functions ends up being the same.
+     *
+     * Just know that this call lets you confine with a rect, SetWindowGrab
+     * lets you confine without a rect.
+     */
+    if (SDL_RectEmpty(&window->mouse_rect) && !(window->flags & SDL_WINDOW_MOUSE_GRABBED)) {
+        Wayland_input_unconfine_pointer(data->input, window);
+    } else {
+        Wayland_input_confine_pointer(data->input, window);
+    }
+}
+
+void
+Wayland_SetWindowMouseGrab(_THIS, SDL_Window *window, SDL_bool grabbed)
+{
+    SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
+
+    if (grabbed) {
+        Wayland_input_confine_pointer(data->input, window);
+    } else if (SDL_RectEmpty(&window->mouse_rect)) {
+        Wayland_input_unconfine_pointer(data->input, window);
+    }
+}
+
+void
+Wayland_SetWindowKeyboardGrab(_THIS, SDL_Window *window, SDL_bool grabbed)
+{
+    SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
+
+    if (grabbed) {
+        Wayland_input_grab_keyboard(window, data->input);
+    } else {
+        Wayland_input_ungrab_keyboard(window);
+    }
 }
 
 int Wayland_CreateWindow(_THIS, SDL_Window *window)
@@ -681,33 +1281,29 @@ int Wayland_CreateWindow(_THIS, SDL_Window *window)
         }
     }
 
-    data->resize.pending = SDL_FALSE;
-    data->resize.width = window->w;
-    data->resize.height = window->h;
-    data->resize.scale_factor = data->scale_factor;
-
     data->outputs = NULL;
     data->num_outputs = 0;
 
+    data->floating_width = window->windowed.w;
+    data->floating_height = window->windowed.h;
+
     data->surface =
         wl_compositor_create_surface(c->compositor);
     wl_surface_add_listener(data->surface, &surface_listener, data);
 
-    if (c->shell.xdg) {
-        data->shell_surface.xdg.surface = xdg_wm_base_get_xdg_surface(c->shell.xdg, data->surface);
-        /* !!! FIXME: add popup role */
-        data->shell_surface.xdg.roleobj.toplevel = xdg_surface_get_toplevel(data->shell_surface.xdg.surface);
-        xdg_toplevel_add_listener(data->shell_surface.xdg.roleobj.toplevel, &toplevel_listener_xdg, data);
-        xdg_toplevel_set_app_id(data->shell_surface.xdg.roleobj.toplevel, c->classname);
-    } else if (c->shell.zxdg) {
-        data->shell_surface.zxdg.surface = zxdg_shell_v6_get_xdg_surface(c->shell.zxdg, data->surface);
-        /* !!! FIXME: add popup role */
-        data->shell_surface.zxdg.roleobj.toplevel = zxdg_surface_v6_get_toplevel(data->shell_surface.zxdg.surface);
-        zxdg_toplevel_v6_add_listener(data->shell_surface.zxdg.roleobj.toplevel, &toplevel_listener_zxdg, data);
-        zxdg_toplevel_v6_set_app_id(data->shell_surface.zxdg.roleobj.toplevel, c->classname);
-    } else {
-        data->shell_surface.wl = wl_shell_get_shell_surface(c->shell.wl, data->surface);
-        wl_shell_surface_set_class(data->shell_surface.wl, c->classname);
+    SDL_WAYLAND_register_surface(data->surface);
+
+    /* Fire a callback when the compositor wants a new frame rendered.
+     * Right now this only matters for OpenGL; we use this callback to add a
+     * wait timeout that avoids getting deadlocked by the compositor when the
+     * window isn't visible.
+     */
+    if (window->flags & SDL_WINDOW_OPENGL) {
+        data->frame_event_queue = WAYLAND_wl_display_create_queue(data->waylandData->display);
+        data->frame_surface_wrapper = WAYLAND_wl_proxy_create_wrapper(data->surface);
+        WAYLAND_wl_proxy_set_queue((struct wl_proxy *)data->frame_surface_wrapper, data->frame_event_queue);
+        data->frame_callback = wl_surface_frame(data->frame_surface_wrapper);
+        wl_callback_add_listener(data->frame_callback, &surface_frame_listener, data);
     }
 
 #ifdef SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH
@@ -724,29 +1320,14 @@ int Wayland_CreateWindow(_THIS, SDL_Window *window)
         data->egl_window = WAYLAND_wl_egl_window_create(data->surface,
                                             window->w * data->scale_factor, window->h * data->scale_factor);
 
+#if SDL_VIDEO_OPENGL_EGL
         /* Create the GLES window surface */
         data->egl_surface = SDL_EGL_CreateSurface(_this, (NativeWindowType) data->egl_window);
-    
+
         if (data->egl_surface == EGL_NO_SURFACE) {
             return SDL_SetError("failed to create an EGL window surface");
         }
-    }
-
-    if (c->shell.xdg) {
-        if (data->shell_surface.xdg.surface) {
-            xdg_surface_set_user_data(data->shell_surface.xdg.surface, data);
-            xdg_surface_add_listener(data->shell_surface.xdg.surface, &shell_surface_listener_xdg, data);
-        }
-    } else if (c->shell.zxdg) {
-        if (data->shell_surface.zxdg.surface) {
-            zxdg_surface_v6_set_user_data(data->shell_surface.zxdg.surface, data);
-            zxdg_surface_v6_add_listener(data->shell_surface.zxdg.surface, &shell_surface_listener_zxdg, data);
-        }
-    } else {
-        if (data->shell_surface.wl) {
-            wl_shell_surface_set_user_data(data->shell_surface.wl, data);
-            wl_shell_surface_add_listener(data->shell_surface.wl, &shell_surface_listener_wl, data);
-        }
+#endif
     }
 
 #ifdef SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH
@@ -757,22 +1338,6 @@ int Wayland_CreateWindow(_THIS, SDL_Window *window)
     }
 #endif /* SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH */
 
-    if (c->decoration_manager && c->shell.xdg && data->shell_surface.xdg.surface) {
-        data->server_decoration = zxdg_decoration_manager_v1_get_toplevel_decoration(c->decoration_manager, data->shell_surface.xdg.roleobj.toplevel);
-        if (data->server_decoration) {
-            const SDL_bool bordered = (window->flags & SDL_WINDOW_BORDERLESS) == 0;
-            const enum zxdg_toplevel_decoration_v1_mode mode = bordered ? ZXDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE : ZXDG_TOPLEVEL_DECORATION_V1_MODE_CLIENT_SIDE;
-            zxdg_toplevel_decoration_v1_set_mode(data->server_decoration, mode);
-        }
-    } else if (c->kwin_server_decoration_manager) {
-        data->kwin_server_decoration = org_kde_kwin_server_decoration_manager_create(c->kwin_server_decoration_manager, data->surface);
-        if (data->kwin_server_decoration) {
-            const SDL_bool bordered = (window->flags & SDL_WINDOW_BORDERLESS) == 0;
-            const enum org_kde_kwin_server_decoration_manager_mode mode = bordered ? ORG_KDE_KWIN_SERVER_DECORATION_MANAGER_MODE_SERVER : ORG_KDE_KWIN_SERVER_DECORATION_MANAGER_MODE_NONE;
-            org_kde_kwin_server_decoration_request_mode(data->kwin_server_decoration, mode);
-        }
-    }
-
     region = wl_compositor_create_region(c->compositor);
     wl_region_add(region, 0, 0, window->w, window->h);
     wl_surface_set_opaque_region(data->surface, region);
@@ -782,67 +1347,68 @@ int Wayland_CreateWindow(_THIS, SDL_Window *window)
         Wayland_input_lock_pointer(c->input);
     }
 
-    wl_surface_commit(data->surface);
+    /* Moved this call to ShowWindow: wl_surface_commit(data->surface); */
     WAYLAND_wl_display_flush(c->display);
 
-    /* we have to wait until the surface gets a "configure" event, or
-       use of this surface will fail. This is a new rule for xdg_shell. */
-    if (c->shell.xdg) {
-        if (data->shell_surface.xdg.surface) {
-            while (!data->shell_surface.xdg.initial_configure_seen) {
-                WAYLAND_wl_display_flush(c->display);
-                WAYLAND_wl_display_dispatch(c->display);
-            }
-        }
-    } else if (c->shell.zxdg) {
-        if (data->shell_surface.zxdg.surface) {
-            while (!data->shell_surface.zxdg.initial_configure_seen) {
-                WAYLAND_wl_display_flush(c->display);
-                WAYLAND_wl_display_dispatch(c->display);
-            }
-        }
-    }
+    /* We may need to create an idle inhibitor for this new window */
+    Wayland_SuspendScreenSaver(_this);
 
     return 0;
 }
 
 
-void
-Wayland_HandlePendingResize(SDL_Window *window)
+static void
+Wayland_HandleResize(SDL_Window *window, int width, int height, float scale)
 {
     SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
+    SDL_VideoData *viddata = data->waylandData;
+    struct wl_region *region;
 
-    if (data->resize.pending) {
-        struct wl_region *region;
-        if (data->scale_factor != data->resize.scale_factor) {
-            window->w = 0;
-            window->h = 0;
-        }
-        SDL_SendWindowEvent(window, SDL_WINDOWEVENT_RESIZED, data->resize.width, data->resize.height);
-        window->w = data->resize.width;
-        window->h = data->resize.height;
-        data->scale_factor = data->resize.scale_factor;
-        wl_surface_set_buffer_scale(data->surface, data->scale_factor);
-        if (data->egl_window) {
-            WAYLAND_wl_egl_window_resize(data->egl_window, window->w * data->scale_factor, window->h * data->scale_factor, 0, 0);
-        }
-
-        if (data->resize.configure) {
-           if (data->waylandData->shell.xdg) {
-              xdg_surface_ack_configure(data->shell_surface.xdg.surface, data->resize.serial);
-           } else if (data->waylandData->shell.zxdg) {
-              zxdg_surface_v6_ack_configure(data->shell_surface.zxdg.surface, data->resize.serial);
-           }
-           data->resize.configure = SDL_FALSE;
-        }
-
-        region = wl_compositor_create_region(data->waylandData->compositor);
-        wl_region_add(region, 0, 0, window->w, window->h);
-        wl_surface_set_opaque_region(data->surface, region);
-        wl_region_destroy(region);
-
-        data->resize.pending = SDL_FALSE;
+    if (data->needs_resize_event || window->w != width || window->h != height || data->scale_factor != scale) {
+        /* We may have already updated window w/h (or only adjusted scale factor),
+         * so we must override the deduplication logic in the video core */
+        window->w = 0;
+        window->h = 0;
+        SDL_SendWindowEvent(window, SDL_WINDOWEVENT_RESIZED, width, height);
+        window->w = width;
+        window->h = height;
+        data->needs_resize_event = SDL_FALSE;
     }
+
+    wl_surface_set_buffer_scale(data->surface, data->scale_factor);
+
+    if (data->egl_window) {
+        WAYLAND_wl_egl_window_resize(data->egl_window,
+                                        window->w * data->scale_factor,
+                                        window->h * data->scale_factor,
+                                        0, 0);
+    }
+
+    region = wl_compositor_create_region(data->waylandData->compositor);
+    wl_region_add(region, 0, 0, window->w, window->h);
+    wl_surface_set_opaque_region(data->surface, region);
+    wl_region_destroy(region);
+
+    /* XXX: This workarounds issues with commiting buffers with old size after
+     * already acknowledging the new size, which can cause protocol violations.
+     * It doesn't fix the first frames after resize being glitched visually,
+     * but at least lets us not be terminated by the compositor.
+     * Can be removed once SDL's resize logic becomes compliant. */
+    if (viddata->shell.xdg && data->shell_surface.xdg.surface) {
+       xdg_surface_set_window_geometry(data->shell_surface.xdg.surface, 0, 0, window->w, window->h);
+    }
+}
+
+void
+Wayland_SetWindowMinimumSize(_THIS, SDL_Window * window)
+{
+    SetMinMaxDimensions(window, SDL_TRUE);
+}
+
+void
+Wayland_SetWindowMaximumSize(_THIS, SDL_Window * window)
+{
+    SetMinMaxDimensions(window, SDL_TRUE);
 }
 
 void Wayland_SetWindowSize(_THIS, SDL_Window * window)
@@ -850,35 +1416,114 @@ void Wayland_SetWindowSize(_THIS, SDL_Window * window)
     SDL_VideoData *data = _this->driverdata;
     SDL_WindowData *wind = window->driverdata;
     struct wl_region *region;
+#ifdef HAVE_LIBDECOR_H
+    struct libdecor_state *state;
+#endif
 
-    wl_surface_set_buffer_scale(wind->surface, get_window_scale_factor(window));
+#ifdef HAVE_LIBDECOR_H
+    /* we must not resize the window while we have a static (non-floating) size */
+    if (data->shell.libdecor &&
+        wind->shell_surface.libdecor.frame &&
+        !libdecor_frame_is_floating(wind->shell_surface.libdecor.frame)) {
+            /* Commit the resize when we re-enter floating state */
+            wind->floating_resize_pending = SDL_TRUE;
+            return;
+    }
+#endif
+
+    wl_surface_set_buffer_scale(wind->surface, wind->scale_factor);
 
     if (wind->egl_window) {
-        WAYLAND_wl_egl_window_resize(wind->egl_window, window->w * get_window_scale_factor(window), window->h * get_window_scale_factor(window), 0, 0);
+        WAYLAND_wl_egl_window_resize(wind->egl_window,
+                                     window->w * wind->scale_factor,
+                                     window->h * wind->scale_factor,
+                                     0, 0);
     }
 
+#ifdef HAVE_LIBDECOR_H
+    if (data->shell.libdecor && wind->shell_surface.libdecor.frame) {
+        state = libdecor_state_new(window->w, window->h);
+        libdecor_frame_commit(wind->shell_surface.libdecor.frame, state, NULL);
+        libdecor_state_free(state);
+    }
+#endif
+
+    /* windowed is unconditionally set, so we can trust it here */
+    wind->floating_width = window->windowed.w;
+    wind->floating_height = window->windowed.h;
+
     region = wl_compositor_create_region(data->compositor);
     wl_region_add(region, 0, 0, window->w, window->h);
     wl_surface_set_opaque_region(wind->surface, region);
     wl_region_destroy(region);
+
+    /* Update the geometry which may have been set by a hack in Wayland_HandleResize */
+    if (data->shell.xdg && wind->shell_surface.xdg.surface) {
+       xdg_surface_set_window_geometry(wind->shell_surface.xdg.surface, 0, 0, window->w, window->h);
+    }
 }
 
 void Wayland_SetWindowTitle(_THIS, SDL_Window * window)
 {
     SDL_WindowData *wind = window->driverdata;
-    SDL_VideoData *viddata = (SDL_VideoData *) _this->driverdata;
-    
+    SDL_VideoData *viddata = _this->driverdata;
+
     if (window->title != NULL) {
+#ifdef HAVE_LIBDECOR_H
+        if (viddata->shell.libdecor) {
+            if (wind->shell_surface.libdecor.frame == NULL) {
+                return; /* Can't do anything yet, wait for ShowWindow */
+            }
+            libdecor_frame_set_title(wind->shell_surface.libdecor.frame, window->title);
+        } else
+#endif
         if (viddata->shell.xdg) {
+            if (wind->shell_surface.xdg.roleobj.toplevel == NULL) {
+                return; /* Can't do anything yet, wait for ShowWindow */
+            }
             xdg_toplevel_set_title(wind->shell_surface.xdg.roleobj.toplevel, window->title);
-        } else if (viddata->shell.zxdg) {
-            zxdg_toplevel_v6_set_title(wind->shell_surface.zxdg.roleobj.toplevel, window->title);
-        } else {
-            wl_shell_surface_set_title(wind->shell_surface.wl, window->title);
         }
     }
 
-    WAYLAND_wl_display_flush( ((SDL_VideoData*)_this->driverdata)->display );
+    WAYLAND_wl_display_flush(viddata->display);
+}
+
+void
+Wayland_SuspendScreenSaver(_THIS)
+{
+    SDL_VideoData *data = (SDL_VideoData *)_this->driverdata;
+
+#if SDL_USE_LIBDBUS
+    if (SDL_DBus_ScreensaverInhibit(_this->suspend_screensaver)) {
+        return;
+    }
+#endif
+
+    /* The idle_inhibit_unstable_v1 protocol suspends the screensaver
+       on a per wl_surface basis, but SDL assumes that suspending
+       the screensaver can be done independently of any window.
+
+       To reconcile these differences, we propagate the idle inhibit
+       state to each window. If there is no window active, we will
+       be able to inhibit idle once the first window is created.
+    */
+    if (data->idle_inhibit_manager) {
+        SDL_Window *window = _this->windows;
+        while (window) {
+            SDL_WindowData *win_data = window->driverdata;
+
+            if (_this->suspend_screensaver && !win_data->idle_inhibitor) {
+                win_data->idle_inhibitor =
+                    zwp_idle_inhibit_manager_v1_create_inhibitor(data->idle_inhibit_manager,
+                                                                 win_data->surface);
+            } else if (!_this->suspend_screensaver && win_data->idle_inhibitor) {
+                zwp_idle_inhibitor_v1_destroy(win_data->idle_inhibitor);
+                win_data->idle_inhibitor = NULL;
+            }
+
+            window = window->next;
+        }
+    }
 }
 
 void Wayland_DestroyWindow(_THIS, SDL_Window *window)
@@ -887,39 +1532,29 @@ void Wayland_DestroyWindow(_THIS, SDL_Window *window)
     SDL_WindowData *wind = window->driverdata;
 
     if (data) {
+#if SDL_VIDEO_OPENGL_EGL
         if (wind->egl_surface) {
             SDL_EGL_DestroySurface(_this, wind->egl_surface);
         }
+#endif
         if (wind->egl_window) {
             WAYLAND_wl_egl_window_destroy(wind->egl_window);
         }
 
-        if (wind->server_decoration) {
-           zxdg_toplevel_decoration_v1_destroy(wind->server_decoration);
+        if (wind->idle_inhibitor) {
+            zwp_idle_inhibitor_v1_destroy(wind->idle_inhibitor);
         }
 
-        if (wind->kwin_server_decoration) {
-            org_kde_kwin_server_decoration_release(wind->kwin_server_decoration);
+        if (wind->activation_token) {
+            xdg_activation_token_v1_destroy(wind->activation_token);
         }
 
-        if (data->shell.xdg) {
-            if (wind->shell_surface.xdg.roleobj.toplevel) {
-                xdg_toplevel_destroy(wind->shell_surface.xdg.roleobj.toplevel);
-            }
-            if (wind->shell_surface.zxdg.surface) {
-                xdg_surface_destroy(wind->shell_surface.xdg.surface);
-            }
-        } else if (data->shell.zxdg) {
-            if (wind->shell_surface.zxdg.roleobj.toplevel) {
-                zxdg_toplevel_v6_destroy(wind->shell_surface.zxdg.roleobj.toplevel);
-            }
-            if (wind->shell_surface.zxdg.surface) {
-                zxdg_surface_v6_destroy(wind->shell_surface.zxdg.surface);
-            }
-        } else {
-            if (wind->shell_surface.wl) {
-                wl_shell_surface_destroy(wind->shell_surface.wl);
-            }
+        SDL_free(wind->outputs);
+
+        if (wind->frame_callback) {
+            WAYLAND_wl_event_queue_destroy(wind->frame_event_queue);
+            WAYLAND_wl_proxy_wrapper_destroy(wind->frame_surface_wrapper);
+            wl_callback_destroy(wind->frame_callback);
         }
 
 #ifdef SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH
@@ -937,6 +1572,6 @@ void Wayland_DestroyWindow(_THIS, SDL_Window *window)
     window->driverdata = NULL;
 }
 
-#endif /* SDL_VIDEO_DRIVER_WAYLAND && SDL_VIDEO_OPENGL_EGL */
+#endif /* SDL_VIDEO_DRIVER_WAYLAND */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandwindow.h b/Engine/lib/sdl/src/video/wayland/SDL_waylandwindow.h
index 93ba121b8..90e4d8cf6 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandwindow.h
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandwindow.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -32,15 +32,6 @@
 
 struct SDL_WaylandInput;
 
-typedef struct {
-    struct zxdg_surface_v6 *surface;
-    union {
-        struct zxdg_toplevel_v6 *toplevel;
-        struct zxdg_popup_v6 *popup;
-    } roleobj;
-    SDL_bool initial_configure_seen;
-} SDL_zxdg_shell_surface;
-
 typedef struct {
     struct xdg_surface *surface;
     union {
@@ -50,57 +41,82 @@ typedef struct {
     SDL_bool initial_configure_seen;
 } SDL_xdg_shell_surface;
 
+#ifdef HAVE_LIBDECOR_H
+typedef struct {
+    struct libdecor_frame *frame;
+    SDL_bool initial_configure_seen;
+} SDL_libdecor_surface;
+#endif
+
 typedef struct {
     SDL_Window *sdlwindow;
     SDL_VideoData *waylandData;
     struct wl_surface *surface;
+    struct wl_callback *frame_callback;
+    struct wl_event_queue *frame_event_queue;
+    struct wl_surface *frame_surface_wrapper;
     union {
+#ifdef HAVE_LIBDECOR_H
+        SDL_libdecor_surface libdecor;
+#endif
         SDL_xdg_shell_surface xdg;
-        SDL_zxdg_shell_surface zxdg;
-        struct wl_shell_surface *wl;
     } shell_surface;
     struct wl_egl_window *egl_window;
     struct SDL_WaylandInput *keyboard_device;
+#if SDL_VIDEO_OPENGL_EGL
     EGLSurface egl_surface;
+#endif
     struct zwp_locked_pointer_v1 *locked_pointer;
+    struct zwp_confined_pointer_v1 *confined_pointer;
     struct zxdg_toplevel_decoration_v1 *server_decoration;
-    struct org_kde_kwin_server_decoration *kwin_server_decoration;
+    struct zwp_keyboard_shortcuts_inhibitor_v1 *key_inhibitor;
+    struct zwp_idle_inhibitor_v1 *idle_inhibitor;
+    struct xdg_activation_token_v1 *activation_token;
+
+    /* floating dimensions for restoring from maximized and fullscreen */
+    int floating_width, floating_height;
+
+    SDL_atomic_t swap_interval_ready;
 
 #ifdef SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH
     struct qt_extended_surface *extended_surface;
 #endif /* SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH */
 
-    struct {
-        SDL_bool pending, configure;
-        uint32_t serial;
-        int width, height;
-        float scale_factor;
-    } resize;
-
-    struct wl_output **outputs;
+    SDL_WaylandOutputData **outputs;
     int num_outputs;
 
     float scale_factor;
+    SDL_bool needs_resize_event;
+    SDL_bool floating_resize_pending;
 } SDL_WindowData;
 
 extern void Wayland_ShowWindow(_THIS, SDL_Window *window);
+extern void Wayland_HideWindow(_THIS, SDL_Window *window);
+extern void Wayland_RaiseWindow(_THIS, SDL_Window *window);
 extern void Wayland_SetWindowFullscreen(_THIS, SDL_Window * window,
                                         SDL_VideoDisplay * _display,
                                         SDL_bool fullscreen);
 extern void Wayland_MaximizeWindow(_THIS, SDL_Window * window);
-extern void Wayland_SetWindowGrab(_THIS, SDL_Window * window, SDL_bool grabbed);
+extern void Wayland_MinimizeWindow(_THIS, SDL_Window * window);
+extern void Wayland_SetWindowMouseRect(_THIS, SDL_Window * window);
+extern void Wayland_SetWindowMouseGrab(_THIS, SDL_Window * window, SDL_bool grabbed);
+extern void Wayland_SetWindowKeyboardGrab(_THIS, SDL_Window *window, SDL_bool grabbed);
 extern void Wayland_RestoreWindow(_THIS, SDL_Window * window);
 extern void Wayland_SetWindowBordered(_THIS, SDL_Window * window, SDL_bool bordered);
+extern void Wayland_SetWindowResizable(_THIS, SDL_Window * window, SDL_bool resizable);
 extern int Wayland_CreateWindow(_THIS, SDL_Window *window);
 extern void Wayland_SetWindowSize(_THIS, SDL_Window * window);
+extern void Wayland_SetWindowMinimumSize(_THIS, SDL_Window * window);
+extern void Wayland_SetWindowMaximumSize(_THIS, SDL_Window * window);
+extern int Wayland_SetWindowModalFor(_THIS, SDL_Window * modal_window, SDL_Window * parent_window);
 extern void Wayland_SetWindowTitle(_THIS, SDL_Window * window);
 extern void Wayland_DestroyWindow(_THIS, SDL_Window *window);
+extern void Wayland_SuspendScreenSaver(_THIS);
 
 extern SDL_bool
 Wayland_GetWindowWMInfo(_THIS, SDL_Window * window, SDL_SysWMinfo * info);
 extern int Wayland_SetWindowHitTest(SDL_Window *window, SDL_bool enabled);
-
-extern void Wayland_HandlePendingResize(SDL_Window *window);
+extern int Wayland_FlashWindow(_THIS, SDL_Window * window, SDL_FlashOperation operation);
 
 #endif /* SDL_waylandwindow_h_ */
 
diff --git a/Engine/lib/sdl/src/video/windows/SDL_msctf.h b/Engine/lib/sdl/src/video/windows/SDL_msctf.h
index 1397e5977..9fa80785d 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_msctf.h
+++ b/Engine/lib/sdl/src/video/windows/SDL_msctf.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/windows/SDL_vkeys.h b/Engine/lib/sdl/src/video/windows/SDL_vkeys.h
index 55b51cad4..3b0c41929 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_vkeys.h
+++ b/Engine/lib/sdl/src/video/windows/SDL_vkeys.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowsclipboard.c b/Engine/lib/sdl/src/video/windows/SDL_windowsclipboard.c
index 1ac477fff..09f33e25b 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowsclipboard.c
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowsclipboard.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowsclipboard.h b/Engine/lib/sdl/src/video/windows/SDL_windowsclipboard.h
index 18642da87..5cdcdfcab 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowsclipboard.h
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowsclipboard.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowsevents.c b/Engine/lib/sdl/src/video/windows/SDL_windowsevents.c
index 041d055ab..0619f67dd 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowsevents.c
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowsevents.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -40,6 +40,11 @@
 /* For GET_X_LPARAM, GET_Y_LPARAM. */
 #include <windowsx.h>
 
+/* For WM_TABLET_QUERYSYSTEMGESTURESTATUS et. al. */
+#if HAVE_TPCSHRD_H
+#include <tpcshrd.h>
+#endif /* HAVE_TPCSHRD_H */
+
 /* #define WMMSG_DEBUG */
 #ifdef WMMSG_DEBUG
 #include <stdio.h>
@@ -81,6 +86,16 @@
 #define WM_UNICHAR 0x0109
 #endif
 
+#ifndef IS_HIGH_SURROGATE
+#define IS_HIGH_SURROGATE(x)   (((x) >= 0xd800) && ((x) <= 0xdbff))
+#endif
+#ifndef IS_LOW_SURROGATE
+#define IS_LOW_SURROGATE(x)    (((x) >= 0xdc00) && ((x) <= 0xdfff))
+#endif
+#ifndef IS_SURROGATE_PAIR
+#define IS_SURROGATE_PAIR(h,l) (IS_HIGH_SURROGATE(h) && IS_LOW_SURROGATE(l))
+#endif
+
 static SDL_Scancode
 VKeytoScancodeFallback(WPARAM vkey)
 {
@@ -294,31 +309,34 @@ WIN_CheckWParamMouseButtons(WPARAM wParam, SDL_WindowData *data, SDL_MouseID mou
 }
 
 static void
-WIN_CheckRawMouseButtons(ULONG rawButtons, SDL_WindowData *data)
+WIN_CheckRawMouseButtons(ULONG rawButtons, SDL_WindowData *data, SDL_MouseID mouseID)
 {
+    // Add a flag to distinguish raw mouse buttons from wParam above
+    rawButtons |= 0x8000000;
+
     if (rawButtons != data->mouse_button_flags) {
         Uint32 mouseFlags = SDL_GetMouseState(NULL, NULL);
         SDL_bool swapButtons = GetSystemMetrics(SM_SWAPBUTTON) != 0;
         if ((rawButtons & RI_MOUSE_BUTTON_1_DOWN))
-            WIN_CheckWParamMouseButton((rawButtons & RI_MOUSE_BUTTON_1_DOWN), mouseFlags, swapButtons, data, SDL_BUTTON_LEFT, 0);
+            WIN_CheckWParamMouseButton((rawButtons & RI_MOUSE_BUTTON_1_DOWN), mouseFlags, swapButtons, data, SDL_BUTTON_LEFT, mouseID);
         if ((rawButtons & RI_MOUSE_BUTTON_1_UP))
-            WIN_CheckWParamMouseButton(!(rawButtons & RI_MOUSE_BUTTON_1_UP), mouseFlags, swapButtons, data, SDL_BUTTON_LEFT, 0);
+            WIN_CheckWParamMouseButton(!(rawButtons & RI_MOUSE_BUTTON_1_UP), mouseFlags, swapButtons, data, SDL_BUTTON_LEFT, mouseID);
         if ((rawButtons & RI_MOUSE_BUTTON_2_DOWN))
-            WIN_CheckWParamMouseButton((rawButtons & RI_MOUSE_BUTTON_2_DOWN), mouseFlags, swapButtons, data, SDL_BUTTON_RIGHT, 0);
+            WIN_CheckWParamMouseButton((rawButtons & RI_MOUSE_BUTTON_2_DOWN), mouseFlags, swapButtons, data, SDL_BUTTON_RIGHT, mouseID);
         if ((rawButtons & RI_MOUSE_BUTTON_2_UP))
-            WIN_CheckWParamMouseButton(!(rawButtons & RI_MOUSE_BUTTON_2_UP), mouseFlags, swapButtons, data, SDL_BUTTON_RIGHT, 0);
+            WIN_CheckWParamMouseButton(!(rawButtons & RI_MOUSE_BUTTON_2_UP), mouseFlags, swapButtons, data, SDL_BUTTON_RIGHT, mouseID);
         if ((rawButtons & RI_MOUSE_BUTTON_3_DOWN))
-            WIN_CheckWParamMouseButton((rawButtons & RI_MOUSE_BUTTON_3_DOWN), mouseFlags, swapButtons, data, SDL_BUTTON_MIDDLE, 0);
+            WIN_CheckWParamMouseButton((rawButtons & RI_MOUSE_BUTTON_3_DOWN), mouseFlags, swapButtons, data, SDL_BUTTON_MIDDLE, mouseID);
         if ((rawButtons & RI_MOUSE_BUTTON_3_UP))
-            WIN_CheckWParamMouseButton(!(rawButtons & RI_MOUSE_BUTTON_3_UP), mouseFlags, swapButtons, data, SDL_BUTTON_MIDDLE, 0);
+            WIN_CheckWParamMouseButton(!(rawButtons & RI_MOUSE_BUTTON_3_UP), mouseFlags, swapButtons, data, SDL_BUTTON_MIDDLE, mouseID);
         if ((rawButtons & RI_MOUSE_BUTTON_4_DOWN))
-            WIN_CheckWParamMouseButton((rawButtons & RI_MOUSE_BUTTON_4_DOWN), mouseFlags, swapButtons, data, SDL_BUTTON_X1, 0);
+            WIN_CheckWParamMouseButton((rawButtons & RI_MOUSE_BUTTON_4_DOWN), mouseFlags, swapButtons, data, SDL_BUTTON_X1, mouseID);
         if ((rawButtons & RI_MOUSE_BUTTON_4_UP))
-            WIN_CheckWParamMouseButton(!(rawButtons & RI_MOUSE_BUTTON_4_UP), mouseFlags, swapButtons, data, SDL_BUTTON_X1, 0);
+            WIN_CheckWParamMouseButton(!(rawButtons & RI_MOUSE_BUTTON_4_UP), mouseFlags, swapButtons, data, SDL_BUTTON_X1, mouseID);
         if ((rawButtons & RI_MOUSE_BUTTON_5_DOWN))
-            WIN_CheckWParamMouseButton((rawButtons & RI_MOUSE_BUTTON_5_DOWN), mouseFlags, swapButtons, data, SDL_BUTTON_X2, 0);
+            WIN_CheckWParamMouseButton((rawButtons & RI_MOUSE_BUTTON_5_DOWN), mouseFlags, swapButtons, data, SDL_BUTTON_X2, mouseID);
         if ((rawButtons & RI_MOUSE_BUTTON_5_UP))
-            WIN_CheckWParamMouseButton(!(rawButtons & RI_MOUSE_BUTTON_5_UP), mouseFlags, swapButtons, data, SDL_BUTTON_X2, 0);
+            WIN_CheckWParamMouseButton(!(rawButtons & RI_MOUSE_BUTTON_5_UP), mouseFlags, swapButtons, data, SDL_BUTTON_X2, mouseID);
         data->mouse_button_flags = rawButtons;
     }
 }
@@ -356,7 +374,77 @@ WIN_CheckAsyncMouseRelease(SDL_WindowData *data)
     if (!(keyState & 0x8000)) {
         WIN_CheckWParamMouseButton(SDL_FALSE, mouseFlags, swapButtons, data, SDL_BUTTON_X2, 0);
     }
-    data->mouse_button_flags = 0;
+    data->mouse_button_flags = (WPARAM)-1;
+}
+
+static void
+WIN_UpdateFocus(SDL_Window *window)
+{
+    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
+    HWND hwnd = data->hwnd;
+    SDL_bool had_focus = (SDL_GetKeyboardFocus() == window) ? SDL_TRUE : SDL_FALSE;
+    SDL_bool has_focus = (GetForegroundWindow() == hwnd) ? SDL_TRUE : SDL_FALSE;
+
+    if (had_focus == has_focus) {
+        return;
+    }
+
+    if (has_focus) {
+        POINT cursorPos;
+
+        SDL_bool swapButtons = GetSystemMetrics(SM_SWAPBUTTON) != 0;
+        if (GetAsyncKeyState(VK_LBUTTON)) {
+            data->focus_click_pending |= !swapButtons ? SDL_BUTTON_LMASK : SDL_BUTTON_RMASK;
+        }
+        if (GetAsyncKeyState(VK_RBUTTON)) {
+            data->focus_click_pending |= !swapButtons ? SDL_BUTTON_RMASK : SDL_BUTTON_LMASK;
+        }
+        if (GetAsyncKeyState(VK_MBUTTON)) {
+            data->focus_click_pending |= SDL_BUTTON_MMASK;
+        }
+        if (GetAsyncKeyState(VK_XBUTTON1)) {
+            data->focus_click_pending |= SDL_BUTTON_X1MASK;
+        }
+        if (GetAsyncKeyState(VK_XBUTTON2)) {
+            data->focus_click_pending |= SDL_BUTTON_X2MASK;
+        }
+
+        SDL_SetKeyboardFocus(window);
+
+        /* In relative mode we are guaranteed to have mouse focus if we have keyboard focus */
+        if (!SDL_GetMouse()->relative_mode) {
+            GetCursorPos(&cursorPos);
+            ScreenToClient(hwnd, &cursorPos);
+            SDL_SendMouseMotion(window, 0, 0, cursorPos.x, cursorPos.y);
+        }
+
+        WIN_CheckAsyncMouseRelease(data);
+        WIN_UpdateClipCursor(window);
+
+        /*
+         * FIXME: Update keyboard state
+         */
+        WIN_CheckClipboardUpdate(data->videodata);
+
+        SDL_ToggleModState(KMOD_CAPS, (GetKeyState(VK_CAPITAL) & 0x0001) != 0);
+        SDL_ToggleModState(KMOD_NUM, (GetKeyState(VK_NUMLOCK) & 0x0001) != 0);
+        SDL_ToggleModState(KMOD_SCROLL, (GetKeyState(VK_SCROLL) & 0x0001) != 0);
+
+    } else {
+        RECT rect;
+
+        data->in_window_deactivation = SDL_TRUE;
+
+        SDL_SetKeyboardFocus(NULL);
+        WIN_ResetDeadKeys();
+
+        if (GetClipCursor(&rect) && SDL_memcmp(&rect, &data->cursor_clipped_rect, sizeof(rect)) == 0) {
+            ClipCursor(NULL);
+            SDL_zero(data->cursor_clipped_rect);
+        }
+
+        data->in_window_deactivation = SDL_FALSE;
+    }
 }
 
 static BOOL
@@ -386,17 +474,20 @@ WIN_ConvertUTF32toUTF8(UINT32 codepoint, char * text)
     return SDL_TRUE;
 }
 
+static BOOL
+WIN_ConvertUTF16toUTF8(UINT32 high_surrogate, UINT32 low_surrogate, char * text)
+{
+    const UINT32 SURROGATE_OFFSET = 0x10000 - (0xD800 << 10) - 0xDC00;
+    const UINT32 codepoint = (high_surrogate << 10) + low_surrogate + SURROGATE_OFFSET;
+    return WIN_ConvertUTF32toUTF8(codepoint, text);
+}
+
 static SDL_bool
 ShouldGenerateWindowCloseOnAltF4(void)
 {
     return !SDL_GetHintBoolean(SDL_HINT_WINDOWS_NO_CLOSE_ON_ALT_F4, SDL_FALSE);
 }
 
-/* Win10 "Fall Creators Update" introduced the bug that SetCursorPos() (as used by SDL_WarpMouseInWindow())
-   doesn't reliably generate WM_MOUSEMOVE events anymore (see #3931) which breaks relative mouse mode via warping.
-   This is used to implement a workaround.. */
-static SDL_bool isWin10FCUorNewer = SDL_FALSE;
-
 /* We want to generate mouse events from mouse and pen, and touch events from touchscreens */
 #define MI_WP_SIGNATURE         0xFF515700
 #define MI_WP_SIGNATURE_MASK    0xFFFFFF00
@@ -428,6 +519,109 @@ static SDL_MOUSE_EVENT_SOURCE GetMouseMessageSource()
     return SDL_MOUSE_EVENT_SOURCE_MOUSE;
 }
 
+static SDL_WindowData *
+WIN_GetWindowDataFromHWND(HWND hwnd)
+{
+    SDL_VideoDevice *_this = SDL_GetVideoDevice();
+    SDL_Window *window;
+
+    if (_this) {
+        for (window = _this->windows; window; window = window->next) {
+            SDL_WindowData *data = (SDL_WindowData *)window->driverdata;
+            if (data && data->hwnd == hwnd) {
+                return data;
+            }
+        }
+    }
+    return NULL;
+}
+
+LRESULT CALLBACK
+WIN_KeyboardHookProc(int nCode, WPARAM wParam, LPARAM lParam)
+{
+    KBDLLHOOKSTRUCT* hookData = (KBDLLHOOKSTRUCT*)lParam;
+    SDL_VideoData* data = SDL_GetVideoDevice()->driverdata;
+    SDL_Scancode scanCode;
+
+    if (nCode < 0 || nCode != HC_ACTION) {
+        return CallNextHookEx(NULL, nCode, wParam, lParam);
+    }
+
+    switch (hookData->vkCode) {
+    case VK_LWIN:
+        scanCode = SDL_SCANCODE_LGUI;
+        break;
+    case VK_RWIN:
+        scanCode = SDL_SCANCODE_RGUI;
+        break;
+    case VK_LMENU:
+        scanCode = SDL_SCANCODE_LALT;
+        break;
+    case VK_RMENU:
+        scanCode = SDL_SCANCODE_RALT;
+        break;
+    case VK_LCONTROL:
+        scanCode = SDL_SCANCODE_LCTRL;
+        break;
+    case VK_RCONTROL:
+        scanCode = SDL_SCANCODE_RCTRL;
+        break;
+
+    /* These are required to intercept Alt+Tab and Alt+Esc on Windows 7 */
+    case VK_TAB:
+        scanCode = SDL_SCANCODE_TAB;
+        break;
+    case VK_ESCAPE:
+        scanCode = SDL_SCANCODE_ESCAPE;
+        break;
+
+    default:
+        return CallNextHookEx(NULL, nCode, wParam, lParam);
+    }
+
+    if (wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN) {
+        SDL_SendKeyboardKey(SDL_PRESSED, scanCode);
+    } else {
+        SDL_SendKeyboardKey(SDL_RELEASED, scanCode);
+
+        /* If the key was down prior to our hook being installed, allow the
+           key up message to pass normally the first time. This ensures other
+           windows have a consistent view of the key state, and avoids keys
+           being stuck down in those windows if they are down when the grab
+           happens and raised while grabbed. */
+        if (hookData->vkCode <= 0xFF && data->pre_hook_key_state[hookData->vkCode]) {
+            data->pre_hook_key_state[hookData->vkCode] = 0;
+            return CallNextHookEx(NULL, nCode, wParam, lParam);
+        }
+    }
+
+    return 1;
+}
+
+static void WIN_CheckICMProfileChanged(SDL_Window* window)
+{
+    SDL_VideoDisplay* display = SDL_GetDisplayForWindow(window);
+    SDL_DisplayData* data = (SDL_DisplayData*)display->driverdata;
+    static WCHAR currentIcmFileName[MAX_PATH] = { '\0' };
+    WCHAR icmFileName[MAX_PATH];
+    HDC hdc;
+    SDL_bool succeeded;
+    DWORD fileNameSize = MAX_PATH;
+
+    hdc = CreateDCW(data->DeviceName, NULL, NULL, NULL);
+    if (hdc) {
+        succeeded = GetICMProfileW(hdc, &fileNameSize, icmFileName);
+        DeleteDC(hdc);
+        if (succeeded) {
+            
+            if (SDL_wcsncmp(currentIcmFileName, icmFileName, fileNameSize)) {
+                SDL_wcslcpy(currentIcmFileName, icmFileName, fileNameSize);
+                SDL_SendWindowEvent(window, SDL_WINDOWEVENT_ICCPROF_CHANGED, 0, 0);
+            }
+        }
+    }
+}
+
 LRESULT CALLBACK
 WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 {
@@ -448,7 +642,11 @@ WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
     }
 
     /* Get the window data for the window */
-    data = (SDL_WindowData *) GetProp(hwnd, TEXT("SDL_WindowData"));
+    data = WIN_GetWindowDataFromHWND(hwnd);
+    if (!data) {
+        /* Fallback */
+        data = (SDL_WindowData *) GetProp(hwnd, TEXT("SDL_WindowData"));
+    }
     if (!data) {
         return CallWindowProc(DefWindowProc, hwnd, msg, wParam, lParam);
     }
@@ -484,77 +682,29 @@ WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
         {
             /* Don't immediately clip the cursor in case we're clicking minimize/maximize buttons */
             data->skip_update_clipcursor = SDL_TRUE;
+
+            /* Update the focus here, since it's possible to get WM_ACTIVATE and WM_SETFOCUS without
+               actually being the foreground window, but this appears to get called in all cases where
+               the global foreground window changes to and from this window. */
+            WIN_UpdateFocus(data->window);
+            WIN_CheckICMProfileChanged(data->window);
         }
         break;
 
     case WM_ACTIVATE:
         {
-            POINT cursorPos;
-            BOOL minimized;
-
-            minimized = HIWORD(wParam);
-            if (!minimized && (LOWORD(wParam) != WA_INACTIVE)) {
-                /* Don't mark the window as shown if it's activated before being shown */
-                if (!IsWindowVisible(hwnd)) {
-                    break;
-                }
-                if (LOWORD(wParam) == WA_CLICKACTIVE) {
-                    SDL_bool swapButtons = GetSystemMetrics(SM_SWAPBUTTON) != 0;
-                    if (GetAsyncKeyState(VK_LBUTTON)) {
-                        data->focus_click_pending |= !swapButtons ? SDL_BUTTON_LMASK : SDL_BUTTON_RMASK;
-                    }
-                    if (GetAsyncKeyState(VK_RBUTTON)) {
-                        data->focus_click_pending |= !swapButtons ? SDL_BUTTON_RMASK : SDL_BUTTON_LMASK;
-                    }
-                    if (GetAsyncKeyState(VK_MBUTTON)) {
-                        data->focus_click_pending |= SDL_BUTTON_MMASK;
-                    }
-                    if (GetAsyncKeyState(VK_XBUTTON1)) {
-                        data->focus_click_pending |= SDL_BUTTON_X1MASK;
-                    }
-                    if (GetAsyncKeyState(VK_XBUTTON2)) {
-                        data->focus_click_pending |= SDL_BUTTON_X2MASK;
-                    }
-                }
-
-                SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_SHOWN, 0, 0);
-                if (SDL_GetKeyboardFocus() != data->window) {
-                    SDL_SetKeyboardFocus(data->window);
-                }
-
-                GetCursorPos(&cursorPos);
-                ScreenToClient(hwnd, &cursorPos);
-                SDL_SendMouseMotion(data->window, 0, 0, cursorPos.x, cursorPos.y);
-
-                WIN_CheckAsyncMouseRelease(data);
-                WIN_UpdateClipCursor(data->window);
-
-                /*
-                 * FIXME: Update keyboard state
-                 */
-                WIN_CheckClipboardUpdate(data->videodata);
-
-                SDL_ToggleModState(KMOD_CAPS, (GetKeyState(VK_CAPITAL) & 0x0001) != 0);
-                SDL_ToggleModState(KMOD_NUM, (GetKeyState(VK_NUMLOCK) & 0x0001) != 0);
-            } else {
-                RECT rect;
-
-                data->in_window_deactivation = SDL_TRUE;
-
-                if (SDL_GetKeyboardFocus() == data->window) {
-                    SDL_SetKeyboardFocus(NULL);
-                    WIN_ResetDeadKeys();
-                }
-
-                if (GetClipCursor(&rect) && SDL_memcmp(&rect, &data->cursor_clipped_rect, sizeof(rect)) == 0) {
-                    ClipCursor(NULL);
-                    SDL_zero(data->cursor_clipped_rect);
-                }
-
-                data->in_window_deactivation = SDL_FALSE;
-            }
+            /* Update the focus in case we changed focus to a child window and then away from the application */
+            WIN_UpdateFocus(data->window);
+        }
+        break;
+
+    case WM_SETFOCUS:
+    case WM_KILLFOCUS:
+    case WM_ENTERIDLE:
+        {
+            /* Update the focus in case it's changing between top-level windows in the same application */
+            WIN_UpdateFocus(data->window);
         }
-        returnCode = 0;
         break;
 
     case WM_POINTERUPDATE:
@@ -566,29 +716,29 @@ WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
     case WM_MOUSEMOVE:
         {
             SDL_Mouse *mouse = SDL_GetMouse();
+
+            if (!data->mouse_tracked) {
+                TRACKMOUSEEVENT trackMouseEvent;
+
+                trackMouseEvent.cbSize = sizeof(TRACKMOUSEEVENT);
+                trackMouseEvent.dwFlags = TME_LEAVE;
+                trackMouseEvent.hwndTrack = data->hwnd;
+
+                if (TrackMouseEvent(&trackMouseEvent)) {
+                    data->mouse_tracked = SDL_TRUE;
+                }
+            }
+
             if (!mouse->relative_mode || mouse->relative_mode_warp) {
                 /* Only generate mouse events for real mouse */
                 if (GetMouseMessageSource() != SDL_MOUSE_EVENT_SOURCE_TOUCH &&
                     lParam != data->last_pointer_update) {
                     SDL_SendMouseMotion(data->window, 0, 0, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
-                    if (isWin10FCUorNewer && mouse->relative_mode_warp) {
-                        /* To work around #3931, Win10 bug introduced in Fall Creators Update, where
-                           SetCursorPos() (SDL_WarpMouseInWindow()) doesn't reliably generate mouse events anymore,
-                           after each windows mouse event generate a fake event for the middle of the window
-                           if relative_mode_warp is used */
-                        int center_x = 0, center_y = 0;
-                        SDL_GetWindowSize(data->window, &center_x, &center_y);
-                        center_x /= 2;
-                        center_y /= 2;
-                        SDL_SendMouseMotion(data->window, 0, 0, center_x, center_y);
-                    }
                 }
-            } else {
-                /* We still need to update focus */
-                SDL_SetMouseFocus(data->window);
             }
         }
-        /* don't break here, fall through to check the wParam like the button presses */
+        break;
+
     case WM_LBUTTONUP:
     case WM_RBUTTONUP:
     case WM_MBUTTONUP:
@@ -618,73 +768,109 @@ WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
             HRAWINPUT hRawInput = (HRAWINPUT)lParam;
             RAWINPUT inp;
             UINT size = sizeof(inp);
-            const SDL_bool isRelative = mouse->relative_mode || mouse->relative_mode_warp;
-            const SDL_bool isCapture = ((data->window->flags & SDL_WINDOW_MOUSE_CAPTURE) != 0);
 
-            if (!isRelative || mouse->focus != data->window) {
-                if (!isCapture) {
-                    break;
-                }
+            /* We only use raw mouse input in relative mode */
+            if (!mouse->relative_mode || mouse->relative_mode_warp) {
+                break;
+            }
+
+            /* Relative mouse motion is delivered to the window with keyboard focus */
+            if (data->window != SDL_GetKeyboardFocus()) {
+                break;
             }
 
             GetRawInputData(hRawInput, RID_INPUT, &inp, &size, sizeof(RAWINPUTHEADER));
 
             /* Mouse data (ignoring synthetic mouse events generated for touchscreens) */
             if (inp.header.dwType == RIM_TYPEMOUSE) {
-                if (GetMouseMessageSource() == SDL_MOUSE_EVENT_SOURCE_TOUCH ||
-                    (GetMessageExtraInfo() & 0x82) == 0x82) {
+                SDL_MouseID mouseID;
+                RAWMOUSE* rawmouse;
+                if (SDL_GetNumTouchDevices() > 0 &&
+                    (GetMouseMessageSource() == SDL_MOUSE_EVENT_SOURCE_TOUCH || (GetMessageExtraInfo() & 0x82) == 0x82)) {
                     break;
                 }
-                if (isRelative) {
-                    RAWMOUSE* rawmouse = &inp.data.mouse;
+                /* We do all of our mouse state checking against mouse ID 0
+                 * We would only use the actual hDevice if we were tracking
+                 * all mouse motion independently, and never using mouse ID 0.
+                 */
+                mouseID = 0; /* (SDL_MouseID)(uintptr_t)inp.header.hDevice; */
+                rawmouse = &inp.data.mouse;
 
-                    if ((rawmouse->usFlags & 0x01) == MOUSE_MOVE_RELATIVE) {
-                        SDL_SendMouseMotion(data->window, 0, 1, (int)rawmouse->lLastX, (int)rawmouse->lLastY);
-                    } else if (rawmouse->lLastX || rawmouse->lLastY) {
-                        /* synthesize relative moves from the abs position */
-                        static SDL_Point lastMousePoint;
-                        SDL_bool virtual_desktop = (rawmouse->usFlags & MOUSE_VIRTUAL_DESKTOP) ? SDL_TRUE : SDL_FALSE;
-                        int w = GetSystemMetrics(virtual_desktop ? SM_CXVIRTUALSCREEN : SM_CXSCREEN);
-                        int h = GetSystemMetrics(virtual_desktop ? SM_CYVIRTUALSCREEN : SM_CYSCREEN);
-                        int x = (int)(((float)rawmouse->lLastX / 65535.0f) * w);
-                        int y = (int)(((float)rawmouse->lLastY / 65535.0f) * h);
+                if ((rawmouse->usFlags & 0x01) == MOUSE_MOVE_RELATIVE) {
+                    SDL_SendMouseMotion(data->window, mouseID, 1, (int)rawmouse->lLastX, (int)rawmouse->lLastY);
+                } else if (rawmouse->lLastX || rawmouse->lLastY) {
+                    /* This is absolute motion, either using a tablet or mouse over RDP
 
-                        if (lastMousePoint.x == 0 && lastMousePoint.y == 0) {
-                            lastMousePoint.x = x;
-                            lastMousePoint.y = y;
+                       Notes on how RDP appears to work, as of Windows 10 2004:
+                        - SetCursorPos() calls are cached, with multiple calls coalesced into a single call that's sent to the RDP client. If the last call to SetCursorPos() has the same value as the last one that was sent to the client, it appears to be ignored and not sent. This means that we need to jitter the SetCursorPos() position slightly in order for the recentering to work correctly.
+                        - User mouse motion is coalesced with SetCursorPos(), so the WM_INPUT positions we see will not necessarily match the positon we requested with SetCursorPos().
+                        - SetCursorPos() outside of the bounds of the focus window appears not to do anything.
+                        - SetCursorPos() while the cursor is NULL doesn't do anything
+
+                       We handle this by creating a safe area within the application window, and when the mouse leaves that safe area, we warp back to the opposite side. Any single motion > 50% of the safe area is assumed to be a warp and ignored.
+                    */
+                    SDL_bool remote_desktop = GetSystemMetrics(SM_REMOTESESSION) ? SDL_TRUE : SDL_FALSE;
+                    SDL_bool virtual_desktop = (rawmouse->usFlags & MOUSE_VIRTUAL_DESKTOP) ? SDL_TRUE : SDL_FALSE;
+                    SDL_bool normalized_coordinates = ((rawmouse->usFlags & 0x40) == 0) ? SDL_TRUE : SDL_FALSE;
+                    int w = GetSystemMetrics(virtual_desktop ? SM_CXVIRTUALSCREEN : SM_CXSCREEN);
+                    int h = GetSystemMetrics(virtual_desktop ? SM_CYVIRTUALSCREEN : SM_CYSCREEN);
+                    int x = normalized_coordinates ? (int)(((float)rawmouse->lLastX / 65535.0f) * w) : (int)rawmouse->lLastX;
+                    int y = normalized_coordinates ? (int)(((float)rawmouse->lLastY / 65535.0f) * h) : (int)rawmouse->lLastY;
+                    int relX, relY;
+
+                    /* Calculate relative motion */
+                    if (data->last_raw_mouse_position.x == 0 && data->last_raw_mouse_position.y == 0) {
+                        data->last_raw_mouse_position.x = x;
+                        data->last_raw_mouse_position.y = y;
+                    }
+                    relX = (int)(x - data->last_raw_mouse_position.x);
+                    relY = (int)(y - data->last_raw_mouse_position.y);
+
+                    if (remote_desktop) {
+                        if (!data->in_title_click && !data->focus_click_pending) {
+                            static int wobble;
+                            float floatX = (float)x / w;
+                            float floatY = (float)y / h;
+
+                            /* See if the mouse is at the edge of the screen, or in the RDP title bar area */
+                            if (floatX <= 0.01f || floatX >= 0.99f || floatY <= 0.01f || floatY >= 0.99f || y < 32) {
+                                /* Wobble the cursor position so it's not ignored if the last warp didn't have any effect */
+                                RECT rect = data->cursor_clipped_rect;
+                                int warpX = rect.left + ((rect.right - rect.left) / 2) + wobble;
+                                int warpY = rect.top + ((rect.bottom - rect.top) / 2);
+
+                                WIN_SetCursorPos(warpX, warpY);
+
+                                ++wobble;
+                                if (wobble > 1) {
+                                    wobble = -1;
+                                }
+                            } else {
+                                /* Send relative motion if we didn't warp last frame (had good position data)
+                                   We also sometimes get large deltas due to coalesced mouse motion and warping,
+                                   so ignore those.
+                                 */
+                                const int MAX_RELATIVE_MOTION = (h / 6);
+                                if (SDL_abs(relX) < MAX_RELATIVE_MOTION &&
+                                    SDL_abs(relY) < MAX_RELATIVE_MOTION) {
+                                    SDL_SendMouseMotion(data->window, mouseID, 1, relX, relY);
+                                }
+                            }
+                        }
+                    } else {
+                        const int MAXIMUM_TABLET_RELATIVE_MOTION = 32;
+                        if (SDL_abs(relX) > MAXIMUM_TABLET_RELATIVE_MOTION ||
+                            SDL_abs(relY) > MAXIMUM_TABLET_RELATIVE_MOTION) {
+                            /* Ignore this motion, probably a pen lift and drop */
+                        } else {
+                            SDL_SendMouseMotion(data->window, mouseID, 1, relX, relY);
                         }
-
-                        SDL_SendMouseMotion(data->window, 0, 1, (int)(x-lastMousePoint.x), (int)(y-lastMousePoint.y));
-
-                        lastMousePoint.x = x;
-                        lastMousePoint.y = y;
                     }
-                    WIN_CheckRawMouseButtons(rawmouse->usButtonFlags, data);
-                } else if (isCapture) {
-                    /* we check for where Windows thinks the system cursor lives in this case, so we don't really lose mouse accel, etc. */
-                    POINT pt;
-                    RECT hwndRect;
-                    HWND currentHnd;
 
-                    GetCursorPos(&pt);
-                    currentHnd = WindowFromPoint(pt);
-                    ScreenToClient(hwnd, &pt);
-                    GetClientRect(hwnd, &hwndRect);
-
-                    /* if in the window, WM_MOUSEMOVE, etc, will cover it. */
-                    if(currentHnd != hwnd || pt.x < 0 || pt.y < 0 || pt.x > hwndRect.right || pt.y > hwndRect.right) {
-                        SDL_bool swapButtons = GetSystemMetrics(SM_SWAPBUTTON) != 0;
-
-                        SDL_SendMouseMotion(data->window, 0, 0, (int)pt.x, (int)pt.y);
-                        SDL_SendMouseButton(data->window, 0, GetAsyncKeyState(VK_LBUTTON) & 0x8000 ? SDL_PRESSED : SDL_RELEASED, !swapButtons ? SDL_BUTTON_LEFT : SDL_BUTTON_RIGHT);
-                        SDL_SendMouseButton(data->window, 0, GetAsyncKeyState(VK_RBUTTON) & 0x8000 ? SDL_PRESSED : SDL_RELEASED, !swapButtons ? SDL_BUTTON_RIGHT : SDL_BUTTON_LEFT);
-                        SDL_SendMouseButton(data->window, 0, GetAsyncKeyState(VK_MBUTTON) & 0x8000 ? SDL_PRESSED : SDL_RELEASED, SDL_BUTTON_MIDDLE);
-                        SDL_SendMouseButton(data->window, 0, GetAsyncKeyState(VK_XBUTTON1) & 0x8000 ? SDL_PRESSED : SDL_RELEASED, SDL_BUTTON_X1);
-                        SDL_SendMouseButton(data->window, 0, GetAsyncKeyState(VK_XBUTTON2) & 0x8000 ? SDL_PRESSED : SDL_RELEASED, SDL_BUTTON_X2);
-                    }
-                } else {
-                    SDL_assert(0 && "Shouldn't happen");
+                    data->last_raw_mouse_position.x = x;
+                    data->last_raw_mouse_position.y = y;
                 }
+                WIN_CheckRawMouseButtons(rawmouse->usButtonFlags, data, mouseID);
             }
         }
         break;
@@ -701,10 +887,9 @@ WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
         }
         break;
 
-#ifdef WM_MOUSELEAVE
     case WM_MOUSELEAVE:
-        if (SDL_GetMouseFocus() == data->window && !SDL_GetMouse()->relative_mode && !(data->window->flags & SDL_WINDOW_MOUSE_CAPTURE)) {
-            if (!IsIconic(hwnd)) {
+        if (!(data->window->flags & SDL_WINDOW_MOUSE_CAPTURE)) {
+            if (SDL_GetMouseFocus() == data->window && !SDL_GetMouse()->relative_mode && !IsIconic(hwnd)) {
                 SDL_Mouse *mouse;
                 POINT cursorPos;
                 GetCursorPos(&cursorPos);
@@ -721,11 +906,16 @@ WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
                     }
                }
             }
+
+            /* When WM_MOUSELEAVE is fired we can be assured that the cursor has left the window */
             SDL_SetMouseFocus(NULL);
         }
+
+        /* Once we get WM_MOUSELEAVE we're guaranteed that the window is no longer tracked */
+        data->mouse_tracked = SDL_FALSE;
+
         returnCode = 0;
         break;
-#endif /* WM_MOUSELEAVE */
 
     case WM_KEYDOWN:
     case WM_SYSKEYDOWN:
@@ -769,11 +959,36 @@ WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
     case WM_UNICHAR:
         if (wParam == UNICODE_NOCHAR) {
             returnCode = 1;
-            break;
+        } else {
+            char text[5];
+            if (WIN_ConvertUTF32toUTF8((UINT32)wParam, text)) {
+                SDL_SendKeyboardText(text);
+            }
+            returnCode = 0;
         }
-        /* otherwise fall through to below */
+        break;
+
     case WM_CHAR:
-        {
+        /* When a user enters a Unicode code point defined in the Basic Multilingual Plane, Windows sends a WM_CHAR
+           message with the code point encoded as UTF-16. When a user enters a Unicode code point from a Supplementary
+           Plane, Windows sends the code point in two separate WM_CHAR messages: The first message includes the UTF-16
+           High Surrogate and the second the UTF-16 Low Surrogate. The High and Low Surrogates cannot be individually
+           converted to valid UTF-8, therefore, we must save the High Surrogate from the first WM_CHAR message and
+           concatenate it with the Low Surrogate from the second WM_CHAR message. At that point, we have a valid
+           UTF-16 surrogate pair ready to re-encode as UTF-8. */
+        if (IS_HIGH_SURROGATE(wParam)) {
+            data->high_surrogate = (WCHAR)wParam;
+        } else if (IS_SURROGATE_PAIR(data->high_surrogate, wParam)) {
+            /* The code point is in a Supplementary Plane.
+               Here wParam is the Low Surrogate. */
+            char text[5];
+            if (WIN_ConvertUTF16toUTF8((UINT32)data->high_surrogate, (UINT32)wParam, text)) {
+                SDL_SendKeyboardText(text);
+            }
+            data->high_surrogate = 0;
+        } else {
+            /* The code point is in the Basic Multilingual Plane.
+               It's numerically equal to UTF-32. */
             char text[5];
             if (WIN_ConvertUTF32toUTF8((UINT32)wParam, text)) {
                 SDL_SendKeyboardText(text);
@@ -870,6 +1085,14 @@ WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
             /* Fix our size to the current size */
             info = (MINMAXINFO *) lParam;
             if (SDL_GetWindowFlags(data->window) & SDL_WINDOW_RESIZABLE) {
+                if (SDL_GetWindowFlags(data->window) & SDL_WINDOW_BORDERLESS) {
+                    int screenW = GetSystemMetrics(SM_CXSCREEN);
+                    int screenH = GetSystemMetrics(SM_CYSCREEN);
+                    info->ptMaxSize.x = SDL_max(w, screenW);
+                    info->ptMaxSize.y = SDL_max(h, screenH);
+                    info->ptMaxPosition.x = SDL_min(0, ((screenW - w) / 2));
+                    info->ptMaxPosition.y = SDL_min(0, ((screenH - h) / 2));
+                }
                 info->ptMinTrackSize.x = w + min_w;
                 info->ptMinTrackSize.y = h + min_h;
                 if (constrain_max_size) {
@@ -926,6 +1149,8 @@ WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 
             /* Forces a WM_PAINT event */
             InvalidateRect(hwnd, NULL, FALSE);
+
+            WIN_CheckICMProfileChanged(data->window);
         }
         break;
 
@@ -942,10 +1167,12 @@ WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
                 SDL_SendWindowEvent(data->window,
                     SDL_WINDOWEVENT_MINIMIZED, 0, 0);
                 break;
-            default:
+            case SIZE_RESTORED:
                 SDL_SendWindowEvent(data->window,
                     SDL_WINDOWEVENT_RESTORED, 0, 0);
                 break;
+            default:
+                break;
             }
         }
         break;
@@ -1065,6 +1292,25 @@ WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
         }
         break;
 
+#if HAVE_TPCSHRD_H
+
+    case WM_TABLET_QUERYSYSTEMGESTURESTATUS:
+        /* See https://msdn.microsoft.com/en-us/library/windows/desktop/bb969148(v=vs.85).aspx .
+         * If we're handling our own touches, we don't want any gestures.
+         * Not all of these settings are documented.
+         * The use of the undocumented ones was suggested by https://github.com/bjarkeck/GCGJ/blob/master/Monogame/Windows/WinFormsGameForm.cs . */
+        return TABLET_DISABLE_PRESSANDHOLD |    /*  disables press and hold (right-click) gesture */
+            TABLET_DISABLE_PENTAPFEEDBACK |     /*  disables UI feedback on pen up (waves) */
+            TABLET_DISABLE_PENBARRELFEEDBACK |  /*  disables UI feedback on pen button down (circle) */
+            TABLET_DISABLE_TOUCHUIFORCEON |
+            TABLET_DISABLE_TOUCHUIFORCEOFF |
+            TABLET_DISABLE_TOUCHSWITCH |
+            TABLET_DISABLE_FLICKS |             /*  disables pen flicks (back, forward, drag down, drag up) */
+            TABLET_DISABLE_SMOOTHSCROLLING |
+            TABLET_DISABLE_FLICKFALLBACKKEYS;
+
+#endif /* HAVE_TPCSHRD_H */
+
     case WM_DROPFILES:
         {
             UINT i;
@@ -1175,6 +1421,31 @@ static void WIN_UpdateClipCursorForWindows()
     }
 }
 
+static void WIN_UpdateMouseCapture()
+{
+    SDL_Window* focusWindow = SDL_GetKeyboardFocus();
+
+    if (focusWindow && (focusWindow->flags & SDL_WINDOW_MOUSE_CAPTURE)) {
+        SDL_WindowData *data = (SDL_WindowData *) focusWindow->driverdata;
+
+        if (!data->mouse_tracked) {
+            POINT pt;
+
+            if (GetCursorPos(&pt) && ScreenToClient(data->hwnd, &pt)) {
+                SDL_bool swapButtons = GetSystemMetrics(SM_SWAPBUTTON) != 0;
+                SDL_MouseID mouseID = SDL_GetMouse()->mouseID;
+
+                SDL_SendMouseMotion(data->window, mouseID, 0, (int)pt.x, (int)pt.y);
+                SDL_SendMouseButton(data->window, mouseID, GetAsyncKeyState(VK_LBUTTON) & 0x8000 ? SDL_PRESSED : SDL_RELEASED, !swapButtons ? SDL_BUTTON_LEFT : SDL_BUTTON_RIGHT);
+                SDL_SendMouseButton(data->window, mouseID, GetAsyncKeyState(VK_RBUTTON) & 0x8000 ? SDL_PRESSED : SDL_RELEASED, !swapButtons ? SDL_BUTTON_RIGHT : SDL_BUTTON_LEFT);
+                SDL_SendMouseButton(data->window, mouseID, GetAsyncKeyState(VK_MBUTTON) & 0x8000 ? SDL_PRESSED : SDL_RELEASED, SDL_BUTTON_MIDDLE);
+                SDL_SendMouseButton(data->window, mouseID, GetAsyncKeyState(VK_XBUTTON1) & 0x8000 ? SDL_PRESSED : SDL_RELEASED, SDL_BUTTON_X1);
+                SDL_SendMouseButton(data->window, mouseID, GetAsyncKeyState(VK_XBUTTON2) & 0x8000 ? SDL_PRESSED : SDL_RELEASED, SDL_BUTTON_X2);
+            }
+        }
+    }
+}
+
 /* A message hook called before TranslateMessage() */
 static SDL_WindowsMessageHook g_WindowsMessageHook = NULL;
 static void *g_WindowsMessageHookData = NULL;
@@ -1185,13 +1456,57 @@ void SDL_SetWindowsMessageHook(SDL_WindowsMessageHook callback, void *userdata)
     g_WindowsMessageHookData = userdata;
 }
 
+int
+WIN_WaitEventTimeout(_THIS, int timeout)
+{
+    MSG msg;
+    if (g_WindowsEnableMessageLoop) {
+        BOOL message_result;
+        UINT_PTR timer_id = 0;
+        if (timeout > 0) {
+            timer_id = SetTimer(NULL, 0, timeout, NULL);
+            message_result = GetMessage(&msg, 0, 0, 0);
+            KillTimer(NULL, timer_id);
+        } else if (timeout == 0) {
+            message_result = PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);
+        } else {
+            message_result = GetMessage(&msg, 0, 0, 0);
+        }
+        if (message_result) {
+            if (msg.message == WM_TIMER && msg.hwnd == NULL && msg.wParam == timer_id) {
+                return 0;
+            }
+            if (g_WindowsMessageHook) {
+                g_WindowsMessageHook(g_WindowsMessageHookData, msg.hwnd, msg.message, msg.wParam, msg.lParam);
+            }
+            /* Always translate the message in case it's a non-SDL window (e.g. with Qt integration) */
+            TranslateMessage(&msg);
+            DispatchMessage(&msg);
+            return 1;
+        } else {
+            return 0;
+        }
+    } else {
+        /* Fail the wait so the caller falls back to polling */
+        return -1;
+    }
+}
+
+void
+WIN_SendWakeupEvent(_THIS, SDL_Window *window)
+{
+    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
+    PostMessage(data->hwnd, data->videodata->_SDL_WAKEUP, 0, 0);
+}
+
 void
 WIN_PumpEvents(_THIS)
 {
     const Uint8 *keystate;
     MSG msg;
-    DWORD start_ticks = GetTickCount();
+    DWORD end_ticks = GetTickCount() + 1;
     int new_messages = 0;
+    SDL_Window *focusWindow;
 
     if (g_WindowsEnableMessageLoop) {
         while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
@@ -1199,12 +1514,22 @@ WIN_PumpEvents(_THIS)
                 g_WindowsMessageHook(g_WindowsMessageHookData, msg.hwnd, msg.message, msg.wParam, msg.lParam);
             }
 
+            /* Don't dispatch any mouse motion queued prior to or including the last mouse warp */
+            if (msg.message == WM_MOUSEMOVE && SDL_last_warp_time) {
+                if (!SDL_TICKS_PASSED(msg.time, (SDL_last_warp_time + 1))) {
+                    continue;
+                }
+
+                /* This mouse message happened after the warp */
+                SDL_last_warp_time = 0;
+            }
+
             /* Always translate the message in case it's a non-SDL window (e.g. with Qt integration) */
             TranslateMessage(&msg);
             DispatchMessage(&msg);
 
             /* Make sure we don't busy loop here forever if there are lots of events coming in */
-            if (SDL_TICKS_PASSED(msg.time, start_ticks)) {
+            if (SDL_TICKS_PASSED(msg.time, end_ticks)) {
                 /* We might get a few new messages generated by the Steam overlay or other application hooks
                    In this case those messages will be processed before any pending input, so we want to continue after those messages.
                    (thanks to Peter Deayton for his investigation here)
@@ -1230,55 +1555,43 @@ WIN_PumpEvents(_THIS)
         SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_RSHIFT);
     }
 
-    /* Update the clipping rect in case someone else has stolen it */
-    WIN_UpdateClipCursorForWindows();
-}
-
-/* to work around #3931, a bug introduced in Win10 Fall Creators Update (build nr. 16299)
-   we need to detect the windows version. this struct and the function below does that.
-   usually this struct and the corresponding function (RtlGetVersion) are in <Ntddk.h>
-   but here we just load it dynamically */
-struct SDL_WIN_OSVERSIONINFOW {
-    ULONG dwOSVersionInfoSize;
-    ULONG dwMajorVersion;
-    ULONG dwMinorVersion;
-    ULONG dwBuildNumber;
-    ULONG dwPlatformId;
-    WCHAR szCSDVersion[128];
-};
-
-static SDL_bool
-IsWin10FCUorNewer(void)
-{
-    HMODULE handle = GetModuleHandleW(L"ntdll.dll");
-    if (handle) {
-        typedef LONG(WINAPI* RtlGetVersionPtr)(struct SDL_WIN_OSVERSIONINFOW*);
-        RtlGetVersionPtr getVersionPtr = (RtlGetVersionPtr)GetProcAddress(handle, "RtlGetVersion");
-        if (getVersionPtr != NULL) {
-            struct SDL_WIN_OSVERSIONINFOW info;
-            SDL_zero(info);
-            info.dwOSVersionInfoSize = sizeof(info);
-            if (getVersionPtr(&info) == 0) { /* STATUS_SUCCESS == 0 */
-                if ((info.dwMajorVersion == 10 && info.dwMinorVersion == 0 && info.dwBuildNumber >= 16299) ||
-                    (info.dwMajorVersion == 10 && info.dwMinorVersion > 0) ||
-                    (info.dwMajorVersion > 10))
-                {
-                    return SDL_TRUE;
-                }
-            }
+    /* The Windows key state gets lost when using Windows+Space or Windows+G shortcuts and
+       not grabbing the keyboard. Note: If we *are* grabbing the keyboard, GetKeyState()
+       will return inaccurate results for VK_LWIN and VK_RWIN but we don't need it anyway. */
+    focusWindow = SDL_GetKeyboardFocus();
+    if (!focusWindow || !(focusWindow->flags & SDL_WINDOW_KEYBOARD_GRABBED)) {
+        if ((keystate[SDL_SCANCODE_LGUI] == SDL_PRESSED) && !(GetKeyState(VK_LWIN) & 0x8000)) {
+            SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_LGUI);
+        }
+        if ((keystate[SDL_SCANCODE_RGUI] == SDL_PRESSED) && !(GetKeyState(VK_RWIN) & 0x8000)) {
+            SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_RGUI);
         }
     }
-    return SDL_FALSE;
+
+    /* Update the clipping rect in case someone else has stolen it */
+    WIN_UpdateClipCursorForWindows();
+
+    /* Update mouse capture */
+    WIN_UpdateMouseCapture();
 }
 
+
 static int app_registered = 0;
 LPTSTR SDL_Appname = NULL;
 Uint32 SDL_Appstyle = 0;
 HINSTANCE SDL_Instance = NULL;
 
+static void WIN_CleanRegisterApp(WNDCLASSEX wcex)
+{
+    if (wcex.hIcon) DestroyIcon(wcex.hIcon);
+    if (wcex.hIconSm) DestroyIcon(wcex.hIconSm);
+    SDL_free(SDL_Appname);
+    SDL_Appname = NULL;
+}
+
 /* Register the class for this application */
 int
-SDL_RegisterApp(char *name, Uint32 style, void *hInst)
+SDL_RegisterApp(const char *name, Uint32 style, void *hInst)
 {
     const char *hint;
     WNDCLASSEX wcex;
@@ -1289,19 +1602,16 @@ SDL_RegisterApp(char *name, Uint32 style, void *hInst)
         ++app_registered;
         return (0);
     }
-    if (!name && !SDL_Appname) {
+    SDL_assert(SDL_Appname == NULL);
+    if (!name) {
         name = "SDL_app";
 #if defined(CS_BYTEALIGNCLIENT) || defined(CS_OWNDC)
-        SDL_Appstyle = (CS_BYTEALIGNCLIENT | CS_OWNDC);
+        style = (CS_BYTEALIGNCLIENT | CS_OWNDC);
 #endif
-        SDL_Instance = hInst ? hInst : GetModuleHandle(NULL);
-    }
-
-    if (name) {
-        SDL_Appname = WIN_UTF8ToString(name);
-        SDL_Appstyle = style;
-        SDL_Instance = hInst ? hInst : GetModuleHandle(NULL);
     }
+    SDL_Appname = WIN_UTF8ToString(name);
+    SDL_Appstyle = style;
+    SDL_Instance = hInst ? hInst : GetModuleHandle(NULL);
 
     /* Register the application class */
     wcex.cbSize         = sizeof(WNDCLASSEX);
@@ -1332,11 +1642,10 @@ SDL_RegisterApp(char *name, Uint32 style, void *hInst)
     }
 
     if (!RegisterClassEx(&wcex)) {
+        WIN_CleanRegisterApp(wcex);
         return SDL_SetError("Couldn't register application class");
     }
 
-    isWin10FCUorNewer = IsWin10FCUorNewer();
-
     app_registered = 1;
     return 0;
 }
@@ -1353,14 +1662,14 @@ SDL_UnregisterApp()
     }
     --app_registered;
     if (app_registered == 0) {
+        /* Ensure the icons are initialized. */
+        wcex.hIcon = NULL;
+        wcex.hIconSm = NULL;
         /* Check for any registered window classes. */
         if (GetClassInfoEx(SDL_Instance, SDL_Appname, &wcex)) {
             UnregisterClass(SDL_Appname, SDL_Instance);
-            if (wcex.hIcon) DestroyIcon(wcex.hIcon);
-            if (wcex.hIconSm) DestroyIcon(wcex.hIconSm);
         }
-        SDL_free(SDL_Appname);
-        SDL_Appname = NULL;
+        WIN_CleanRegisterApp(wcex);
     }
 }
 
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowsevents.h b/Engine/lib/sdl/src/video/windows/SDL_windowsevents.h
index 80d429fca..be7f21ff2 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowsevents.h
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowsevents.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -27,9 +27,12 @@ extern LPTSTR SDL_Appname;
 extern Uint32 SDL_Appstyle;
 extern HINSTANCE SDL_Instance;
 
+extern LRESULT CALLBACK WIN_KeyboardHookProc(int nCode, WPARAM wParam, LPARAM lParam);
 extern LRESULT CALLBACK WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam,
                                        LPARAM lParam);
 extern void WIN_PumpEvents(_THIS);
+extern void WIN_SendWakeupEvent(_THIS, SDL_Window *window);
+extern int  WIN_WaitEventTimeout(_THIS, int timeout);
 
 #endif /* SDL_windowsevents_h_ */
 
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowsframebuffer.c b/Engine/lib/sdl/src/video/windows/SDL_windowsframebuffer.c
index 2ad2eddee..f41f9c09c 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowsframebuffer.c
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowsframebuffer.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowsframebuffer.h b/Engine/lib/sdl/src/video/windows/SDL_windowsframebuffer.h
index 9a9e243be..04fc3d130 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowsframebuffer.h
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowsframebuffer.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowskeyboard.c b/Engine/lib/sdl/src/video/windows/SDL_windowskeyboard.c
index 5e1ec46da..b9874a543 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowskeyboard.c
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowskeyboard.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -23,6 +23,7 @@
 #if SDL_VIDEO_DRIVER_WINDOWS
 
 #include "SDL_windowsvideo.h"
+#include "SDL_hints.h"
 
 #include "../../events/SDL_keyboard_c.h"
 #include "../../events/scancodes_windows.h"
@@ -35,6 +36,8 @@ static void IME_Init(SDL_VideoData *videodata, HWND hwnd);
 static void IME_Enable(SDL_VideoData *videodata, HWND hwnd);
 static void IME_Disable(SDL_VideoData *videodata, HWND hwnd);
 static void IME_Quit(SDL_VideoData *videodata);
+static void IME_ClearComposition(SDL_VideoData *videodata);
+static SDL_bool IME_IsTextInputShown(SDL_VideoData* videodata);
 #endif /* !SDL_DISABLE_WINDOWS_IME */
 
 #ifndef MAPVK_VK_TO_VSC
@@ -61,12 +64,14 @@ WIN_InitKeyboard(_THIS)
     data->ime_hwnd_main = 0;
     data->ime_hwnd_current = 0;
     data->ime_himc = 0;
+    data->ime_composition_length = 32 * sizeof(WCHAR);
+    data->ime_composition = (WCHAR*)SDL_malloc(data->ime_composition_length);
     data->ime_composition[0] = 0;
     data->ime_readingstring[0] = 0;
     data->ime_cursor = 0;
 
     data->ime_candlist = SDL_FALSE;
-    SDL_memset(data->ime_candidates, 0, sizeof(data->ime_candidates));
+    data->ime_candidates = NULL;
     data->ime_candcount = 0;
     data->ime_candref = 0;
     data->ime_candsel = 0;
@@ -106,6 +111,7 @@ WIN_InitKeyboard(_THIS)
     /* Are system caps/num/scroll lock active? Set our state to match. */
     SDL_ToggleModState(KMOD_CAPS, (GetKeyState(VK_CAPITAL) & 0x0001) != 0);
     SDL_ToggleModState(KMOD_NUM, (GetKeyState(VK_NUMLOCK) & 0x0001) != 0);
+    SDL_ToggleModState(KMOD_SCROLL, (GetKeyState(VK_SCROLL) & 0x0001) != 0);
 }
 
 void
@@ -244,17 +250,43 @@ WIN_SetTextInputRect(_THIS, SDL_Rect *rect)
     himc = ImmGetContext(videodata->ime_hwnd_current);
     if (himc)
     {
-        COMPOSITIONFORM cf;
-        cf.ptCurrentPos.x = videodata->ime_rect.x;
-        cf.ptCurrentPos.y = videodata->ime_rect.y;
-        cf.dwStyle = CFS_FORCE_POSITION;
-        ImmSetCompositionWindow(himc, &cf);
+        COMPOSITIONFORM cof;
+        CANDIDATEFORM caf;
+
+        cof.dwStyle = CFS_RECT;
+        cof.ptCurrentPos.x = videodata->ime_rect.x;
+        cof.ptCurrentPos.y = videodata->ime_rect.y;
+        cof.rcArea.left = videodata->ime_rect.x;
+        cof.rcArea.right = videodata->ime_rect.x + videodata->ime_rect.w;
+        cof.rcArea.top = videodata->ime_rect.y;
+        cof.rcArea.bottom = videodata->ime_rect.y + videodata->ime_rect.h;
+        ImmSetCompositionWindow(himc, &cof);
+
+        caf.dwIndex = 0;
+        caf.dwStyle = CFS_EXCLUDE;
+        caf.ptCurrentPos.x = videodata->ime_rect.x;
+        caf.ptCurrentPos.y = videodata->ime_rect.y;
+        caf.rcArea.left = videodata->ime_rect.x;
+        caf.rcArea.right = videodata->ime_rect.x + videodata->ime_rect.w;
+        caf.rcArea.top = videodata->ime_rect.y;
+        caf.rcArea.bottom = videodata->ime_rect.y + videodata->ime_rect.h;
+        ImmSetCandidateWindow(himc, &caf);
+
         ImmReleaseContext(videodata->ime_hwnd_current, himc);
     }
 }
 
+
 #ifdef SDL_DISABLE_WINDOWS_IME
 
+void WIN_ClearComposition(_THIS)
+{
+}
+
+SDL_bool WIN_IsTextInputShown(_THIS)
+{
+    return SDL_FALSE;
+}
 
 SDL_bool
 IME_HandleMessage(HWND hwnd, UINT msg, WPARAM wParam, LPARAM *lParam, SDL_VideoData *videodata)
@@ -324,6 +356,7 @@ DEFINE_GUID(IID_ITfThreadMgrEx,                                0x3E90ADE3,0x7594
 #define SUBLANG() SUBLANGID(LANG())
 
 static void IME_UpdateInputLocale(SDL_VideoData *videodata);
+static int IME_ShowCandidateList(SDL_VideoData *videodata);
 static void IME_ClearComposition(SDL_VideoData *videodata);
 static void IME_SetWindow(SDL_VideoData* videodata, HWND hwnd);
 static void IME_SetupAPI(SDL_VideoData *videodata);
@@ -336,6 +369,12 @@ static void UILess_ReleaseSinks(SDL_VideoData *videodata);
 static void UILess_EnableUIUpdates(SDL_VideoData *videodata);
 static void UILess_DisableUIUpdates(SDL_VideoData *videodata);
 
+static SDL_bool
+WIN_ShouldShowNativeUI()
+{
+    return SDL_GetHintBoolean(SDL_HINT_IME_SHOW_UI, SDL_FALSE);
+}
+
 static void
 IME_Init(SDL_VideoData *videodata, HWND hwnd)
 {
@@ -370,7 +409,10 @@ IME_Init(SDL_VideoData *videodata, HWND hwnd)
     videodata->ime_available = SDL_TRUE;
     IME_UpdateInputLocale(videodata);
     IME_SetupAPI(videodata);
-    videodata->ime_uiless = UILess_SetupSinks(videodata);
+    if (WIN_ShouldShowNativeUI())
+        videodata->ime_uiless = SDL_FALSE;
+    else
+        videodata->ime_uiless = UILess_SetupSinks(videodata);
     IME_UpdateInputLocale(videodata);
     IME_Disable(videodata, hwnd);
 }
@@ -559,16 +601,16 @@ IME_GetId(SDL_VideoData *videodata, UINT uIndex)
     char szTemp[256];
     HKL hkl = 0;
     DWORD dwLang = 0;
-    if (uIndex >= sizeof(dwRet) / sizeof(dwRet[0]))
-        return 0;
+    SDL_assert(uIndex < sizeof(dwRet) / sizeof(dwRet[0]));
 
     hkl = videodata->ime_hkl;
     if (hklprev == hkl)
         return dwRet[uIndex];
-
     hklprev = hkl;
+
+    SDL_assert(uIndex == 0);
     dwLang = ((DWORD_PTR)hkl & 0xffff);
-    if (videodata->ime_uiless && LANG() == LANG_CHT) {
+    if (videodata->ime_uiless && dwLang == LANG_CHT) {
         dwRet[0] = IMEID_CHT_VER_VISTA;
         dwRet[1] = 0;
         return dwRet[0];
@@ -579,11 +621,11 @@ IME_GetId(SDL_VideoData *videodata, UINT uIndex)
         && hkl != CHT_HKL_HK_CANTONESE
         && hkl != CHS_HKL) {
         dwRet[0] = dwRet[1] = 0;
-        return dwRet[uIndex];
+        return dwRet[0];
     }
     if (ImmGetIMEFileNameA(hkl, szTemp, sizeof(szTemp) - 1) <= 0) {
         dwRet[0] = dwRet[1] = 0;
-        return dwRet[uIndex];
+        return dwRet[0];
     }
     if (!videodata->GetReadingString) {
         #define LCID_INVARIANT MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT)
@@ -593,7 +635,7 @@ IME_GetId(SDL_VideoData *videodata, UINT uIndex)
             && CompareStringA(LCID_INVARIANT, NORM_IGNORECASE, szTemp, -1, CHS_IMEFILENAME1, -1) != 2
             && CompareStringA(LCID_INVARIANT, NORM_IGNORECASE, szTemp, -1, CHS_IMEFILENAME2, -1) != 2) {
             dwRet[0] = dwRet[1] = 0;
-            return dwRet[uIndex];
+            return dwRet[0];
         }
         #undef LCID_INVARIANT
         dwVerSize = GetFileVersionInfoSizeA(szTemp, &dwVerHandle);
@@ -632,7 +674,7 @@ IME_GetId(SDL_VideoData *videodata, UINT uIndex)
         }
     }
     dwRet[0] = dwRet[1] = 0;
-    return dwRet[uIndex];
+    return dwRet[0];
 }
 
 static void
@@ -684,26 +726,13 @@ IME_SetWindow(SDL_VideoData* videodata, HWND hwnd)
 static void
 IME_UpdateInputLocale(SDL_VideoData *videodata)
 {
-    static HKL hklprev = 0;
-    videodata->ime_hkl = GetKeyboardLayout(0);
-    if (hklprev == videodata->ime_hkl)
+    HKL hklnext = GetKeyboardLayout(0);
+
+    if (hklnext == videodata->ime_hkl)
         return;
 
-    hklprev = videodata->ime_hkl;
-    switch (PRIMLANG()) {
-    case LANG_CHINESE:
-        videodata->ime_candvertical = SDL_TRUE;
-        if (SUBLANG() == SUBLANG_CHINESE_SIMPLIFIED)
-            videodata->ime_candvertical = SDL_FALSE;
-
-        break;
-    case LANG_JAPANESE:
-        videodata->ime_candvertical = SDL_TRUE;
-        break;
-    case LANG_KOREAN:
-        videodata->ime_candvertical = SDL_FALSE;
-        break;
-    }
+    videodata->ime_hkl = hklnext;
+    videodata->ime_candvertical = (PRIMLANG() == LANG_KOREAN || LANG() == LANG_CHS) ? SDL_FALSE : SDL_TRUE;
 }
 
 static void
@@ -726,30 +755,96 @@ IME_ClearComposition(SDL_VideoData *videodata)
     SDL_SendEditingText("", 0, 0);
 }
 
+static SDL_bool
+IME_IsTextInputShown(SDL_VideoData* videodata)
+{
+    if (!videodata->ime_initialized || !videodata->ime_available || !videodata->ime_enabled)
+        return SDL_FALSE;
+
+    return videodata->ime_uicontext != 0 ? SDL_TRUE : SDL_FALSE;
+}
+
 static void
 IME_GetCompositionString(SDL_VideoData *videodata, HIMC himc, DWORD string)
 {
-    LONG length = ImmGetCompositionStringW(himc, string, videodata->ime_composition, sizeof(videodata->ime_composition) - sizeof(videodata->ime_composition[0]));
+    LONG length;
+    DWORD dwLang = ((DWORD_PTR)videodata->ime_hkl & 0xffff);
+
+    length = ImmGetCompositionStringW(himc, string, NULL, 0);
+    if (length > 0 && videodata->ime_composition_length < length) {
+        if (videodata->ime_composition != NULL)
+            SDL_free(videodata->ime_composition);
+
+        videodata->ime_composition = (WCHAR*)SDL_malloc(length + sizeof(WCHAR));
+        videodata->ime_composition_length = length;
+    }
+
+    length = ImmGetCompositionStringW(
+        himc,
+        string,
+        videodata->ime_composition,
+        videodata->ime_composition_length
+    );
+
     if (length < 0)
         length = 0;
 
-    length /= sizeof(videodata->ime_composition[0]);
+    length /= sizeof(WCHAR);
     videodata->ime_cursor = LOWORD(ImmGetCompositionStringW(himc, GCS_CURSORPOS, 0, 0));
-    if (videodata->ime_cursor < SDL_arraysize(videodata->ime_composition) && videodata->ime_composition[videodata->ime_cursor] == 0x3000) {
+    if ((dwLang == LANG_CHT || dwLang == LANG_CHS) &&
+        videodata->ime_cursor > 0 &&
+        videodata->ime_cursor < (int)(videodata->ime_composition_length / sizeof(WCHAR)) &&
+        (videodata->ime_composition[0] == 0x3000 || videodata->ime_composition[0] == 0x0020)) {
+        // Traditional Chinese IMEs add a placeholder U+3000
+        // Simplified Chinese IMEs seem to add a placeholder U+0020 sometimes
         int i;
         for (i = videodata->ime_cursor + 1; i < length; ++i)
             videodata->ime_composition[i - 1] = videodata->ime_composition[i];
 
         --length;
     }
+
     videodata->ime_composition[length] = 0;
+
+    // Get the correct caret position if we've selected a candidate from the candidate window
+    if (videodata->ime_cursor == 0 && length > 0) {
+        Sint32 start = 0;
+        Sint32 end = 0;
+
+        length = ImmGetCompositionStringW(himc, GCS_COMPATTR, NULL, 0);
+        if (length > 0) {
+            Uint8* attributes = (Uint8*)SDL_malloc(length);
+            ImmGetCompositionString(himc, GCS_COMPATTR, attributes, length);
+
+            for (start = 0; start < length; ++start) {
+                if (attributes[start] == ATTR_TARGET_CONVERTED ||
+                    attributes[start] == ATTR_TARGET_NOTCONVERTED)
+                    break;
+            }
+
+            for (end = start; end < length; ++end) {
+                if (attributes[end] != ATTR_TARGET_CONVERTED &&
+                    attributes[end] != ATTR_TARGET_NOTCONVERTED)
+                    break;
+            }
+
+            if (start == length) {
+                start = 0;
+                end = length;
+            }
+
+            SDL_free(attributes);
+        }
+
+        videodata->ime_cursor = end;
+    }
 }
 
 static void
 IME_SendInputEvent(SDL_VideoData *videodata)
 {
     char *s = 0;
-    s = WIN_StringToUTF8(videodata->ime_composition);
+    s = WIN_StringToUTF8W(videodata->ime_composition);
     SDL_SendKeyboardText(s);
     SDL_free(s);
 
@@ -761,48 +856,66 @@ IME_SendInputEvent(SDL_VideoData *videodata)
 static void
 IME_SendEditingEvent(SDL_VideoData *videodata)
 {
-    char *s = 0;
-    WCHAR buffer[SDL_TEXTEDITINGEVENT_TEXT_SIZE];
-    const size_t size = SDL_arraysize(buffer);
-    buffer[0] = 0;
+    char *s = NULL;
+    WCHAR *buffer = NULL;
+    size_t size = videodata->ime_composition_length;
     if (videodata->ime_readingstring[0]) {
         size_t len = SDL_min(SDL_wcslen(videodata->ime_composition), (size_t)videodata->ime_cursor);
+
+        size += sizeof(videodata->ime_readingstring);
+        buffer = (WCHAR*)SDL_malloc(size);
+        buffer[0] = 0;
+
         SDL_wcslcpy(buffer, videodata->ime_composition, len + 1);
         SDL_wcslcat(buffer, videodata->ime_readingstring, size);
         SDL_wcslcat(buffer, &videodata->ime_composition[len], size);
     }
     else {
+        buffer = (WCHAR*)SDL_malloc(size);
+        buffer[0] = 0;
         SDL_wcslcpy(buffer, videodata->ime_composition, size);
     }
-    s = WIN_StringToUTF8(buffer);
+
+    s = WIN_StringToUTF8W(buffer);
     SDL_SendEditingText(s, videodata->ime_cursor + (int)SDL_wcslen(videodata->ime_readingstring), 0);
     SDL_free(s);
+    SDL_free(buffer);
 }
 
 static void
 IME_AddCandidate(SDL_VideoData *videodata, UINT i, LPCWSTR candidate)
 {
-    LPWSTR dst = videodata->ime_candidates[i];
+    LPWSTR dst = &videodata->ime_candidates[i * MAX_CANDLENGTH];
+    LPWSTR end = &dst[MAX_CANDLENGTH - 1];
+    SDL_COMPILE_TIME_ASSERT(IME_CANDIDATE_INDEXING_REQUIRES, MAX_CANDLIST == 10);
     *dst++ = (WCHAR)(TEXT('0') + ((i + videodata->ime_candlistindexbase) % 10));
     if (videodata->ime_candvertical)
         *dst++ = TEXT(' ');
 
-    while (*candidate && (SDL_arraysize(videodata->ime_candidates[i]) > (dst - videodata->ime_candidates[i])))
+    while (*candidate && dst < end)
         *dst++ = *candidate++;
 
     *dst = (WCHAR)'\0';
 }
 
 static void
-IME_GetCandidateList(HIMC himc, SDL_VideoData *videodata)
+IME_GetCandidateList(HWND hwnd, SDL_VideoData *videodata)
 {
-    LPCANDIDATELIST cand_list = 0;
-    DWORD size = ImmGetCandidateListW(himc, 0, 0, 0);
-    if (size) {
+    HIMC himc;
+    DWORD size;
+    LPCANDIDATELIST cand_list;
+
+    if (IME_ShowCandidateList(videodata) < 0)
+        return;
+    himc = ImmGetContext(hwnd);
+    if (!himc)
+        return;
+    size = ImmGetCandidateListW(himc, 0, 0, 0);
+    if (size != 0) {
         cand_list = (LPCANDIDATELIST)SDL_malloc(size);
-        if (cand_list) {
+        if (cand_list != NULL) {
             size = ImmGetCandidateListW(himc, 0, cand_list, size);
-            if (size) {
+            if (size != 0) {
                 UINT i, j;
                 UINT page_start = 0;
                 videodata->ime_candsel = cand_list->dwSelection;
@@ -827,34 +940,44 @@ IME_GetCandidateList(HIMC himc, SDL_VideoData *videodata)
                     }
                     videodata->ime_candpgsize = i - page_start;
                 } else {
-                    videodata->ime_candpgsize = SDL_min(cand_list->dwPageSize, MAX_CANDLIST);
-                    if (videodata->ime_candpgsize > 0) {
-                        page_start = (cand_list->dwSelection / videodata->ime_candpgsize) * videodata->ime_candpgsize;
-                    } else {
-                        page_start = 0;
-                    }
+                    videodata->ime_candpgsize = SDL_min(cand_list->dwPageSize == 0 ? MAX_CANDLIST : cand_list->dwPageSize, MAX_CANDLIST);
+                    page_start = (cand_list->dwSelection / videodata->ime_candpgsize) * videodata->ime_candpgsize;
                 }
-                SDL_memset(&videodata->ime_candidates, 0, sizeof(videodata->ime_candidates));
-                for (i = page_start, j = 0; (DWORD)i < cand_list->dwCount && j < (int)videodata->ime_candpgsize; i++, j++) {
+                for (i = page_start, j = 0; (DWORD)i < cand_list->dwCount && j < videodata->ime_candpgsize; i++, j++) {
                     LPCWSTR candidate = (LPCWSTR)((DWORD_PTR)cand_list + cand_list->dwOffset[i]);
                     IME_AddCandidate(videodata, j, candidate);
                 }
-                if (PRIMLANG() == LANG_KOREAN || (PRIMLANG() == LANG_CHT && !IME_GetId(videodata, 0)))
-                    videodata->ime_candsel = -1;
+                // TODO: why was this necessary? check ime_candvertical instead? PRIMLANG() never equals LANG_CHT !
+                //if (PRIMLANG() == LANG_KOREAN || (PRIMLANG() == LANG_CHT && !IME_GetId(videodata, 0)))
+                //    videodata->ime_candsel = -1;
 
             }
             SDL_free(cand_list);
         }
     }
+    ImmReleaseContext(hwnd, himc);
 }
 
-static void
+static int
 IME_ShowCandidateList(SDL_VideoData *videodata)
 {
+    void *candidates;
+
+    videodata->ime_candcount = 0;
+    candidates = SDL_realloc(videodata->ime_candidates, MAX_CANDSIZE);
+    if (candidates != NULL)
+        videodata->ime_candidates = (WCHAR *)candidates;
+
+    if (videodata->ime_candidates == NULL)
+        return -1;
+
+    SDL_memset(videodata->ime_candidates, 0, MAX_CANDSIZE);
+
     videodata->ime_dirty = SDL_TRUE;
     videodata->ime_candlist = SDL_TRUE;
     IME_DestroyTextures(videodata);
     IME_SendEditingEvent(videodata);
+    return 0;
 }
 
 static void
@@ -875,20 +998,34 @@ IME_HandleMessage(HWND hwnd, UINT msg, WPARAM wParam, LPARAM *lParam, SDL_VideoD
         return SDL_FALSE;
 
     switch (msg) {
+    case WM_KEYDOWN:
+        if (wParam == VK_PROCESSKEY)
+        {
+            videodata->ime_uicontext = 1;
+            trap = SDL_TRUE;
+        }
+        else
+            videodata->ime_uicontext = 0;
+        break;
     case WM_INPUTLANGCHANGE:
         IME_InputLangChanged(videodata);
         break;
     case WM_IME_SETCONTEXT:
-        *lParam = 0;
+        if (videodata->ime_uiless) {
+            *lParam = 0;
+        }
         break;
-    case WM_IME_STARTCOMPOSITION:
+    case WM_IME_STARTCOMPOSITION: 
+        videodata->ime_suppress_endcomposition_event = SDL_FALSE;
         trap = SDL_TRUE;
         break;
     case WM_IME_COMPOSITION:
         trap = SDL_TRUE;
         himc = ImmGetContext(hwnd);
         if (*lParam & GCS_RESULTSTR) {
+            videodata->ime_suppress_endcomposition_event = SDL_TRUE;
             IME_GetCompositionString(videodata, himc, GCS_RESULTSTR);
+            SDL_SendEditingText("", 0, 0);
             IME_SendInputEvent(videodata);
         }
         if (*lParam & GCS_COMPSTR) {
@@ -901,10 +1038,13 @@ IME_HandleMessage(HWND hwnd, UINT msg, WPARAM wParam, LPARAM *lParam, SDL_VideoD
         ImmReleaseContext(hwnd, himc);
         break;
     case WM_IME_ENDCOMPOSITION:
+        videodata->ime_uicontext = 0;
         videodata->ime_composition[0] = 0;
         videodata->ime_readingstring[0] = 0;
         videodata->ime_cursor = 0;
-        SDL_SendEditingText("", 0, 0);
+        if (videodata->ime_suppress_endcomposition_event == SDL_FALSE)
+            SDL_SendEditingText("", 0, 0);
+        videodata->ime_suppress_endcomposition_event = SDL_FALSE;
         break;
     case WM_IME_NOTIFY:
         switch (wParam) {
@@ -918,16 +1058,12 @@ IME_HandleMessage(HWND hwnd, UINT msg, WPARAM wParam, LPARAM *lParam, SDL_VideoD
                 break;
 
             trap = SDL_TRUE;
-            IME_ShowCandidateList(videodata);
-            himc = ImmGetContext(hwnd);
-            if (!himc)
-                break;
-
-            IME_GetCandidateList(himc, videodata);
-            ImmReleaseContext(hwnd, himc);
+            videodata->ime_uicontext = 1;
+            IME_GetCandidateList(hwnd, videodata);
             break;
         case IMN_CLOSECANDIDATE:
             trap = SDL_TRUE;
+            videodata->ime_uicontext = 0;
             IME_HideCandidateList(videodata);
             break;
         case IMN_PRIVATE:
@@ -974,7 +1110,8 @@ IME_CloseCandidateList(SDL_VideoData *videodata)
 {
     IME_HideCandidateList(videodata);
     videodata->ime_candcount = 0;
-    SDL_memset(videodata->ime_candidates, 0, sizeof(videodata->ime_candidates));
+    SDL_free(videodata->ime_candidates);
+    videodata->ime_candidates = NULL;
 }
 
 static void
@@ -987,13 +1124,16 @@ UILess_GetCandidateList(SDL_VideoData *videodata, ITfCandidateListUIElement *pca
     DWORD pgstart = 0;
     DWORD pgsize = 0;
     UINT i, j;
+
+    if (IME_ShowCandidateList(videodata) < 0)
+        return;
+
     pcandlist->lpVtbl->GetSelection(pcandlist, &selection);
     pcandlist->lpVtbl->GetCount(pcandlist, &count);
     pcandlist->lpVtbl->GetCurrentPage(pcandlist, &page);
 
     videodata->ime_candsel = selection;
     videodata->ime_candcount = count;
-    IME_ShowCandidateList(videodata);
 
     pcandlist->lpVtbl->GetPageIndex(pcandlist, 0, 0, &pgcount);
     if (pgcount > 0) {
@@ -1011,8 +1151,6 @@ UILess_GetCandidateList(SDL_VideoData *videodata, ITfCandidateListUIElement *pca
     }
     videodata->ime_candpgsize = SDL_min(pgsize, MAX_CANDLIST);
     videodata->ime_candsel = videodata->ime_candsel - pgstart;
-
-    SDL_memset(videodata->ime_candidates, 0, sizeof(videodata->ime_candidates));
     for (i = pgstart, j = 0; (DWORD)i < count && j < videodata->ime_candpgsize; i++, j++) {
         BSTR bstr;
         if (SUCCEEDED(pcandlist->lpVtbl->GetString(pcandlist, i, &bstr))) {
@@ -1022,8 +1160,9 @@ UILess_GetCandidateList(SDL_VideoData *videodata, ITfCandidateListUIElement *pca
             }
         }
     }
-    if (PRIMLANG() == LANG_KOREAN)
-        videodata->ime_candsel = -1;
+    // TODO: why was this necessary? check ime_candvertical instead?
+    //if (PRIMLANG() == LANG_KOREAN)
+    //    videodata->ime_candsel = -1;
 }
 
 STDMETHODIMP_(ULONG) TSFSink_AddRef(TSFSink *sink)
@@ -1440,7 +1579,7 @@ IME_RenderCandidateList(SDL_VideoData *videodata, HDC hdc)
     SelectObject(hdc, font);
 
     for (i = 0; i < candcount; ++i) {
-        const WCHAR *s = videodata->ime_candidates[i];
+        const WCHAR *s = &videodata->ime_candidates[i * MAX_CANDLENGTH];
         if (!*s)
             break;
 
@@ -1502,7 +1641,7 @@ IME_RenderCandidateList(SDL_VideoData *videodata, HDC hdc)
     SetBkMode(hdc, TRANSPARENT);
 
     for (i = 0; i < candcount; ++i) {
-        const WCHAR *s = videodata->ime_candidates[i];
+        const WCHAR *s = &videodata->ime_candidates[i * MAX_CANDLENGTH];
         int left, top, right, bottom;
         if (!*s)
             break;
@@ -1572,6 +1711,18 @@ void IME_Present(SDL_VideoData *videodata)
     /* FIXME: Need to show the IME bitmap */
 }
 
+SDL_bool WIN_IsTextInputShown(_THIS)
+{
+    SDL_VideoData* videodata = (SDL_VideoData*)_this->driverdata;
+    return IME_IsTextInputShown(videodata);
+}
+
+void WIN_ClearComposition(_THIS)
+{
+    SDL_VideoData *videodata = (SDL_VideoData *)_this->driverdata;
+    IME_ClearComposition(videodata);
+}
+
 #endif /* SDL_DISABLE_WINDOWS_IME */
 
 #endif /* SDL_VIDEO_DRIVER_WINDOWS */
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowskeyboard.h b/Engine/lib/sdl/src/video/windows/SDL_windowskeyboard.h
index ec20f9a58..97382c7bd 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowskeyboard.h
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowskeyboard.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -32,6 +32,8 @@ extern void WIN_ResetDeadKeys(void);
 extern void WIN_StartTextInput(_THIS);
 extern void WIN_StopTextInput(_THIS);
 extern void WIN_SetTextInputRect(_THIS, SDL_Rect *rect);
+extern void WIN_ClearComposition(_THIS);
+extern SDL_bool WIN_IsTextInputShown(_THIS);
 
 extern SDL_bool IME_HandleMessage(HWND hwnd, UINT msg, WPARAM wParam, LPARAM *lParam, struct SDL_VideoData *videodata);
 
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowsmessagebox.c b/Engine/lib/sdl/src/video/windows/SDL_windowsmessagebox.c
index 3382a2de8..812f4536f 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowsmessagebox.c
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowsmessagebox.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -117,7 +117,7 @@ static SDL_bool GetButtonIndex(const SDL_MessageBoxData *messageboxdata, Uint32
     return SDL_FALSE;
 }
 
-static INT_PTR MessageBoxDialogProc(HWND hDlg, UINT iMessage, WPARAM wParam, LPARAM lParam)
+static INT_PTR CALLBACK MessageBoxDialogProc(HWND hDlg, UINT iMessage, WPARAM wParam, LPARAM lParam)
 {
     const SDL_MessageBoxData *messageboxdata;
     size_t buttonindex;
@@ -260,7 +260,7 @@ static SDL_bool AddDialogString(WIN_DialogData *dialog, const char *string)
         string = "";
     }
 
-    wstring = WIN_UTF8ToString(string);
+    wstring = WIN_UTF8ToStringW(string);
     if (!wstring) {
         return SDL_FALSE;
     }
@@ -645,9 +645,9 @@ WIN_ShowOldMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid)
     }
 
     /* Measure the *pixel* size of the string. */
-    wmessage = WIN_UTF8ToString(messageboxdata->message);
+    wmessage = WIN_UTF8ToStringW(messageboxdata->message);
     SDL_zero(TextSize);
-    DrawText(FontDC, wmessage, -1, &TextSize, DT_CALCRECT | DT_LEFT | DT_NOPREFIX | DT_EDITCONTROL);
+    DrawTextW(FontDC, wmessage, -1, &TextSize, DT_CALCRECT | DT_LEFT | DT_NOPREFIX | DT_EDITCONTROL);
 
     /* Add margins and some padding for hangs, etc. */
     TextSize.left += TextMargin;
@@ -742,7 +742,7 @@ WIN_ShowOldMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid)
         ParentWindow = ((SDL_WindowData*)messageboxdata->window->driverdata)->hwnd;
     }
 
-    result = DialogBoxIndirectParam(NULL, (DLGTEMPLATE*)dialog->lpDialog, ParentWindow, (DLGPROC)MessageBoxDialogProc, (LPARAM)messageboxdata);
+    result = DialogBoxIndirectParam(NULL, (DLGTEMPLATE*)dialog->lpDialog, ParentWindow, MessageBoxDialogProc, (LPARAM)messageboxdata);
     if (result >= IDBUTTONINDEX0 && result - IDBUTTONINDEX0 < messageboxdata->numbuttons) {
         *buttonid = messageboxdata->buttons[result - IDBUTTONINDEX0].buttonid;
         retval = 0;
@@ -798,7 +798,7 @@ WIN_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid)
     }
 
     /* If we cannot load comctl32.dll use the old messagebox! */
-    hComctl32 = LoadLibrary(TEXT("Comctl32.dll"));
+    hComctl32 = LoadLibrary(TEXT("comctl32.dll"));
     if (hComctl32 == NULL) {
         return WIN_ShowOldMessageBox(messageboxdata, buttonid);
     }
@@ -822,8 +822,8 @@ WIN_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid)
         ParentWindow = ((SDL_WindowData *) messageboxdata->window->driverdata)->hwnd;
     }
 
-    wmessage = WIN_UTF8ToString(messageboxdata->message);
-    wtitle = WIN_UTF8ToString(messageboxdata->title);
+    wmessage = WIN_UTF8ToStringW(messageboxdata->message);
+    wtitle = WIN_UTF8ToStringW(messageboxdata->title);
 
     SDL_zero(TaskConfig);
     TaskConfig.cbSize = sizeof (TASKDIALOGCONFIG);
@@ -872,7 +872,7 @@ WIN_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid)
             SDL_free(pButtons);
             return -1;
         }
-        pButton->pszButtonText = WIN_UTF8ToString(buttontext);
+        pButton->pszButtonText = WIN_UTF8ToStringW(buttontext);
         if (messageboxdata->buttons[i].flags & SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT) {
             TaskConfig.nDefaultButton = pButton->nButtonID;
         }
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowsmessagebox.h b/Engine/lib/sdl/src/video/windows/SDL_windowsmessagebox.h
index 9f1ea00b5..1ffc506e4 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowsmessagebox.h
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowsmessagebox.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowsmodes.c b/Engine/lib/sdl/src/video/windows/SDL_windowsmodes.c
index d3af5b1e1..9080cc895 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowsmodes.c
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowsmodes.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -23,6 +23,7 @@
 #if SDL_VIDEO_DRIVER_WINDOWS
 
 #include "SDL_windowsvideo.h"
+#include "../../events/SDL_displayevents_c.h"
 
 /* Windows CE compatibility */
 #ifndef CDS_FULLSCREEN
@@ -32,7 +33,7 @@
 /* #define DEBUG_MODES */
 
 static void
-WIN_UpdateDisplayMode(_THIS, LPCTSTR deviceName, DWORD index, SDL_DisplayMode * mode)
+WIN_UpdateDisplayMode(_THIS, LPCWSTR deviceName, DWORD index, SDL_DisplayMode * mode)
 {
     SDL_DisplayModeData *data = (SDL_DisplayModeData *) mode->driverdata;
     HDC hdc;
@@ -108,15 +109,57 @@ WIN_UpdateDisplayMode(_THIS, LPCTSTR deviceName, DWORD index, SDL_DisplayMode *
     }
 }
 
+static SDL_DisplayOrientation
+WIN_GetDisplayOrientation(DEVMODE *mode)
+{
+    int width = mode->dmPelsWidth;
+    int height = mode->dmPelsHeight;
+
+    /* Use unrotated width/height to guess orientation */
+    if (mode->dmDisplayOrientation == DMDO_90 || mode->dmDisplayOrientation == DMDO_270) {
+        int temp = width;
+        width = height;
+        height = temp;
+    }
+
+    if (width >= height) {
+        switch (mode->dmDisplayOrientation) {
+        case DMDO_DEFAULT:
+            return SDL_ORIENTATION_LANDSCAPE;
+        case DMDO_90:
+            return SDL_ORIENTATION_PORTRAIT;
+        case DMDO_180:
+            return SDL_ORIENTATION_LANDSCAPE_FLIPPED;
+        case DMDO_270:
+            return SDL_ORIENTATION_PORTRAIT_FLIPPED;
+        default:
+            return SDL_ORIENTATION_UNKNOWN;
+        }
+    } else {
+        switch (mode->dmDisplayOrientation) {
+        case DMDO_DEFAULT:
+            return SDL_ORIENTATION_PORTRAIT;
+        case DMDO_90:
+            return SDL_ORIENTATION_LANDSCAPE_FLIPPED;
+        case DMDO_180:
+            return SDL_ORIENTATION_PORTRAIT_FLIPPED;
+        case DMDO_270:
+            return SDL_ORIENTATION_LANDSCAPE;
+        default:
+            return SDL_ORIENTATION_UNKNOWN;
+        }
+    }
+}
+
 static SDL_bool
-WIN_GetDisplayMode(_THIS, LPCTSTR deviceName, DWORD index, SDL_DisplayMode * mode)
+WIN_GetDisplayMode(_THIS, LPCWSTR deviceName, DWORD index, SDL_DisplayMode * mode, SDL_DisplayOrientation *orientation)
 {
     SDL_DisplayModeData *data;
     DEVMODE devmode;
 
     devmode.dmSize = sizeof(devmode);
     devmode.dmDriverExtra = 0;
-    if (!EnumDisplaySettings(deviceName, index, &devmode)) {
+    if (!EnumDisplaySettingsW(deviceName, index, &devmode)) {
         return SDL_FALSE;
     }
 
@@ -135,6 +178,11 @@ WIN_GetDisplayMode(_THIS, LPCTSTR deviceName, DWORD index, SDL_DisplayMode * mod
 
     /* Fill in the mode information */
     WIN_UpdateDisplayMode(_this, deviceName, index, mode);
+
+    if (orientation) {
+        *orientation = WIN_GetDisplayOrientation(&devmode);
+    }
+
     return SDL_TRUE;
 }
 
@@ -145,13 +193,14 @@ WIN_AddDisplay(_THIS, HMONITOR hMonitor, const MONITORINFOEXW *info, SDL_bool se
     SDL_VideoDisplay display;
     SDL_DisplayData *displaydata;
     SDL_DisplayMode mode;
-    DISPLAY_DEVICE device;
+    SDL_DisplayOrientation orientation;
+    DISPLAY_DEVICEW device;
 
 #ifdef DEBUG_MODES
-    SDL_Log("Display: %s\n", WIN_StringToUTF8(info->szDevice));
+    SDL_Log("Display: %s\n", WIN_StringToUTF8W(info->szDevice));
 #endif
 
-    if (!WIN_GetDisplayMode(_this, info->szDevice, ENUM_CURRENT_SETTINGS, &mode)) {
+    if (!WIN_GetDisplayMode(_this, info->szDevice, ENUM_CURRENT_SETTINGS, &mode, &orientation)) {
         return SDL_FALSE;
     }
 
@@ -163,6 +212,13 @@ WIN_AddDisplay(_THIS, HMONITOR hMonitor, const MONITORINFOEXW *info, SDL_bool se
         if (SDL_wcscmp(driverdata->DeviceName, info->szDevice) == 0) {
             driverdata->MonitorHandle = hMonitor;
             driverdata->IsValid = SDL_TRUE;
+
+            if (!_this->setting_display_mode) {
+                SDL_ResetDisplayModes(i);
+                SDL_SetCurrentDisplayMode(&_this->displays[i], &mode);
+                SDL_SetDesktopDisplayMode(&_this->displays[i], &mode);
+                SDL_SendDisplayEvent(&_this->displays[i], SDL_DISPLAYEVENT_ORIENTATION, orientation);
+            }
             return SDL_FALSE;
         }
     }
@@ -178,11 +234,12 @@ WIN_AddDisplay(_THIS, HMONITOR hMonitor, const MONITORINFOEXW *info, SDL_bool se
 
     SDL_zero(display);
     device.cb = sizeof(device);
-    if (EnumDisplayDevices(info->szDevice, 0, &device, 0)) {
-        display.name = WIN_StringToUTF8(device.DeviceString);
+    if (EnumDisplayDevicesW(info->szDevice, 0, &device, 0)) {
+        display.name = WIN_StringToUTF8W(device.DeviceString);
     }
     display.desktop_mode = mode;
     display.current_mode = mode;
+    display.orientation = orientation;
     display.driverdata = displaydata;
     SDL_AddVideoDisplay(&display, send_event);
     SDL_free(display.name);
@@ -356,8 +413,8 @@ WIN_GetDisplayModes(_THIS, SDL_VideoDisplay * display)
     DWORD i;
     SDL_DisplayMode mode;
 
-    for (i = 0;; ++i) {
-        if (!WIN_GetDisplayMode(_this, data->DeviceName, i, &mode)) {
+    for (i = 0; ; ++i) {
+        if (!WIN_GetDisplayMode(_this, data->DeviceName, i, &mode, NULL)) {
             break;
         }
         if (SDL_ISPIXELFORMAT_INDEXED(mode.format)) {
@@ -383,9 +440,9 @@ WIN_SetDisplayMode(_THIS, SDL_VideoDisplay * display, SDL_DisplayMode * mode)
     LONG status;
 
     if (mode->driverdata == display->desktop_mode.driverdata) {
-        status = ChangeDisplaySettingsEx(displaydata->DeviceName, NULL, NULL, CDS_FULLSCREEN, NULL);
+        status = ChangeDisplaySettingsExW(displaydata->DeviceName, NULL, NULL, CDS_FULLSCREEN, NULL);
     } else {
-        status = ChangeDisplaySettingsEx(displaydata->DeviceName, &data->DeviceMode, NULL, CDS_FULLSCREEN, NULL);
+        status = ChangeDisplaySettingsExW(displaydata->DeviceName, &data->DeviceMode, NULL, CDS_FULLSCREEN, NULL);
     }
     if (status != DISP_CHANGE_SUCCESSFUL) {
         const char *reason = "Unknown reason";
@@ -405,7 +462,7 @@ WIN_SetDisplayMode(_THIS, SDL_VideoDisplay * display, SDL_DisplayMode * mode)
         }
         return SDL_SetError("ChangeDisplaySettingsEx() failed: %s", reason);
     }
-    EnumDisplaySettings(displaydata->DeviceName, ENUM_CURRENT_SETTINGS, &data->DeviceMode);
+    EnumDisplaySettingsW(displaydata->DeviceName, ENUM_CURRENT_SETTINGS, &data->DeviceMode);
     WIN_UpdateDisplayMode(_this, displaydata->DeviceName, ENUM_CURRENT_SETTINGS, mode);
     return 0;
 }
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowsmodes.h b/Engine/lib/sdl/src/video/windows/SDL_windowsmodes.h
index 431724221..0f2cdf489 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowsmodes.h
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowsmodes.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowsmouse.c b/Engine/lib/sdl/src/video/windows/SDL_windowsmouse.c
index 826cbb2cf..bc4ba6326 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowsmouse.c
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowsmouse.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -27,11 +27,13 @@
 #include "../../events/SDL_mouse_c.h"
 
 
+DWORD SDL_last_warp_time = 0;
 HCURSOR SDL_cursor = NULL;
+static SDL_Cursor *SDL_blank_cursor = NULL;
 
 static int rawInputEnableCount = 0;
 
-static int 
+static int
 ToggleRawInput(SDL_bool enabled)
 {
     RAWINPUTDEVICE rawMouse = { 0x01, 0x02, 0, NULL }; /* Mouse: UsagePage = 1, Usage = 2 */
@@ -57,6 +59,9 @@ ToggleRawInput(SDL_bool enabled)
 
     /* (Un)register raw input for mice */
     if (RegisterRawInputDevices(&rawMouse, 1, sizeof(RAWINPUTDEVICE)) == FALSE) {
+        /* Reset the enable count, otherwise subsequent enable calls will
+           believe raw input is enabled */
+        rawInputEnableCount = 0;
 
         /* Only return an error when registering. If we unregister and fail,
            then it's probably that we unregistered twice. That's OK. */
@@ -91,6 +96,7 @@ WIN_CreateCursor(SDL_Surface * surface, int hot_x, int hot_y)
     const size_t pad = (sizeof (size_t) * 8);  /* 32 or 64, or whatever. */
     SDL_Cursor *cursor;
     HICON hicon;
+    HICON hcursor;
     HDC hdc;
     BITMAPV4HEADER bmh;
     LPVOID pixels;
@@ -145,17 +151,39 @@ WIN_CreateCursor(SDL_Surface * surface, int hot_x, int hot_y)
         return NULL;
     }
 
+    /* The cursor returned by CreateIconIndirect does not respect system cursor size
+        preference, use CopyImage to duplicate the cursor with desired sizes */
+    hcursor = CopyImage(hicon, IMAGE_CURSOR, surface->w, surface->h, 0);
+    DestroyIcon(hicon);
+
+    if (!hcursor) {
+        WIN_SetError("CopyImage()");
+        return NULL;
+    }
+
     cursor = SDL_calloc(1, sizeof(*cursor));
     if (cursor) {
-        cursor->driverdata = hicon;
+        cursor->driverdata = hcursor;
     } else {
-        DestroyIcon(hicon);
+        DestroyIcon(hcursor);
         SDL_OutOfMemory();
     }
 
     return cursor;
 }
 
+static SDL_Cursor *
+WIN_CreateBlankCursor()
+{
+    SDL_Cursor *cursor = NULL;
+    SDL_Surface *surface = SDL_CreateRGBSurfaceWithFormat(0, 32, 32, 32, SDL_PIXELFORMAT_ARGB8888);
+    if (surface) {
+        cursor = WIN_CreateCursor(surface, 0, 0);
+        SDL_FreeSurface(surface);
+    }
+    return cursor;
+}
+
 static SDL_Cursor *
 WIN_CreateSystemCursor(SDL_SystemCursor id)
 {
@@ -207,6 +235,9 @@ WIN_FreeCursor(SDL_Cursor * cursor)
 static int
 WIN_ShowCursor(SDL_Cursor * cursor)
 {
+    if (!cursor) {
+        cursor = SDL_blank_cursor;
+    }
     if (cursor) {
         SDL_cursor = (HCURSOR)cursor->driverdata;
     } else {
@@ -218,6 +249,21 @@ WIN_ShowCursor(SDL_Cursor * cursor)
     return 0;
 }
 
+void
+WIN_SetCursorPos(int x, int y)
+{
+    /* We need to jitter the value because otherwise Windows will occasionally inexplicably ignore the SetCursorPos() or SendInput() */
+    SetCursorPos(x, y);
+    SetCursorPos(x+1, y);
+    SetCursorPos(x, y);
+
+    /* Flush any mouse motion prior to or associated with this warp */
+    SDL_last_warp_time = GetTickCount();
+    if (!SDL_last_warp_time) {
+        SDL_last_warp_time = 1;
+    }
+}
+
 static void
 WIN_WarpMouse(SDL_Window * window, int x, int y)
 {
@@ -233,7 +279,10 @@ WIN_WarpMouse(SDL_Window * window, int x, int y)
     pt.x = x;
     pt.y = y;
     ClientToScreen(hwnd, &pt);
-    SetCursorPos(pt.x, pt.y);
+    WIN_SetCursorPos(pt.x, pt.y);
+
+    /* Send the exact mouse motion associated with this warp */
+    SDL_SendMouseMotion(window, SDL_GetMouse()->mouseID, 0, x, y);
 }
 
 static int
@@ -256,18 +305,22 @@ WIN_SetRelativeMouseMode(SDL_bool enabled)
 static int
 WIN_CaptureMouse(SDL_Window *window)
 {
-    if (!window) {
-        SDL_Window *focusWin = SDL_GetKeyboardFocus();
-        if (focusWin) {
-            WIN_OnWindowEnter(SDL_GetVideoDevice(), focusWin);  /* make sure WM_MOUSELEAVE messages are (re)enabled. */
+    if (window) {
+        SDL_WindowData *data = (SDL_WindowData *)window->driverdata;
+        SetCapture(data->hwnd);
+    } else {
+        SDL_Window *focus_window = SDL_GetMouseFocus();
+       
+        if (focus_window) {
+            SDL_WindowData *data = (SDL_WindowData *)focus_window->driverdata;
+            if (!data->mouse_tracked) {
+                SDL_SetMouseFocus(NULL);
+            }
         }
+        ReleaseCapture();
     }
 
-    /* While we were thinking of SetCapture() when designing this API in SDL,
-       we didn't count on the fact that SetCapture() only tracks while the
-       left mouse button is held down! Instead, we listen for raw mouse input
-       and manually query the mouse when it leaves the window. :/ */
-    return ToggleRawInput(window != NULL);
+    return 0;
 }
 
 static Uint32
@@ -306,6 +359,8 @@ WIN_InitMouse(_THIS)
     mouse->GetGlobalMouseState = WIN_GetGlobalMouseState;
 
     SDL_SetDefaultCursor(WIN_CreateDefaultCursor());
+
+    SDL_blank_cursor = WIN_CreateBlankCursor();
 }
 
 void
@@ -315,6 +370,11 @@ WIN_QuitMouse(_THIS)
         rawInputEnableCount = 1;
         ToggleRawInput(SDL_FALSE);
     }
+
+    if (SDL_blank_cursor) {
+        WIN_FreeCursor(SDL_blank_cursor);
+        SDL_blank_cursor = NULL;
+    }
 }
 
 #endif /* SDL_VIDEO_DRIVER_WINDOWS */
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowsmouse.h b/Engine/lib/sdl/src/video/windows/SDL_windowsmouse.h
index 72122103d..fd1a8a323 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowsmouse.h
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowsmouse.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -23,10 +23,12 @@
 #ifndef SDL_windowsmouse_h_
 #define SDL_windowsmouse_h_
 
+extern DWORD SDL_last_warp_time;
 extern HCURSOR SDL_cursor;
 
 extern void WIN_InitMouse(_THIS);
 extern void WIN_QuitMouse(_THIS);
+extern void WIN_SetCursorPos(int x, int y);
 
 #endif /* SDL_windowsmouse_h_ */
 
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowsopengl.c b/Engine/lib/sdl/src/video/windows/SDL_windowsopengl.c
index e0a4ba7d0..0c99ca9a6 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowsopengl.c
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowsopengl.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowsopengl.h b/Engine/lib/sdl/src/video/windows/SDL_windowsopengl.h
index 003f1f6e7..2dec0023a 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowsopengl.h
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowsopengl.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowsopengles.c b/Engine/lib/sdl/src/video/windows/SDL_windowsopengles.c
index 5ee46d83c..eedc0e6ab 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowsopengles.c
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowsopengles.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -108,7 +108,10 @@ WIN_GLES_SetupWindow(_THIS, SDL_Window * window)
     SDL_GLContext current_ctx = SDL_GL_GetCurrentContext();
 
     if (_this->egl_data == NULL) {
+        /* !!! FIXME: commenting out this assertion is (I think) incorrect; figure out why driver_loaded is wrong for ANGLE instead. --ryan. */
+        #if 0  /* When hint SDL_HINT_OPENGL_ES_DRIVER is set to "1" (e.g. for ANGLE support), _this->gl_config.driver_loaded can be 1, while the below lines function. */
         SDL_assert(!_this->gl_config.driver_loaded);
+        #endif
         if (SDL_EGL_LoadLibrary(_this, NULL, EGL_DEFAULT_DISPLAY, 0) < 0) {
             SDL_EGL_UnloadLibrary(_this);
             return -1;
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowsopengles.h b/Engine/lib/sdl/src/video/windows/SDL_windowsopengles.h
index 6ac5f7b63..b21c56f4f 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowsopengles.h
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowsopengles.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowsshape.c b/Engine/lib/sdl/src/video/windows/SDL_windowsshape.c
index 953cb2478..7af545d94 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowsshape.c
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowsshape.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowsshape.h b/Engine/lib/sdl/src/video/windows/SDL_windowsshape.h
index a5c786e8a..982807357 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowsshape.h
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowsshape.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowstaskdialog.h b/Engine/lib/sdl/src/video/windows/SDL_windowstaskdialog.h
index 707d54db2..cd13d12d0 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowstaskdialog.h
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowstaskdialog.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowsvideo.c b/Engine/lib/sdl/src/video/windows/SDL_windowsvideo.c
index 3aa93d3e2..4bd2a9831 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowsvideo.c
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowsvideo.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -87,7 +87,9 @@ WIN_DeleteDevice(SDL_VideoDevice * device)
     if (data->shcoreDLL) {
         SDL_UnloadObject(data->shcoreDLL);
     }
-
+    if (device->wakeup_lock) {
+        SDL_DestroyMutex(device->wakeup_lock);
+    }
     SDL_free(device->driverdata);
     SDL_free(device);
 }
@@ -113,6 +115,7 @@ WIN_CreateDevice(int devindex)
         return NULL;
     }
     device->driverdata = data;
+    device->wakeup_lock = SDL_CreateMutex();
 
     data->userDLL = SDL_LoadObject("USER32.DLL");
     if (data->userDLL) {
@@ -139,6 +142,8 @@ WIN_CreateDevice(int devindex)
     device->GetDisplayModes = WIN_GetDisplayModes;
     device->SetDisplayMode = WIN_SetDisplayMode;
     device->PumpEvents = WIN_PumpEvents;
+    device->WaitEventTimeout = WIN_WaitEventTimeout;
+    device->SendWakeupEvent = WIN_SendWakeupEvent;
     device->SuspendScreenSaver = WIN_SuspendScreenSaver;
 
     device->CreateSDLWindow = WIN_CreateWindow;
@@ -157,10 +162,14 @@ WIN_CreateDevice(int devindex)
     device->RestoreWindow = WIN_RestoreWindow;
     device->SetWindowBordered = WIN_SetWindowBordered;
     device->SetWindowResizable = WIN_SetWindowResizable;
+    device->SetWindowAlwaysOnTop = WIN_SetWindowAlwaysOnTop;
     device->SetWindowFullscreen = WIN_SetWindowFullscreen;
     device->SetWindowGammaRamp = WIN_SetWindowGammaRamp;
+    device->GetWindowICCProfile = WIN_GetWindowICCProfile;
     device->GetWindowGammaRamp = WIN_GetWindowGammaRamp;
-    device->SetWindowGrab = WIN_SetWindowGrab;
+    device->SetWindowMouseRect = WIN_SetWindowMouseRect;
+    device->SetWindowMouseGrab = WIN_SetWindowMouseGrab;
+    device->SetWindowKeyboardGrab = WIN_SetWindowKeyboardGrab;
     device->DestroyWindow = WIN_DestroyWindow;
     device->GetWindowWMInfo = WIN_GetWindowWMInfo;
     device->CreateWindowFramebuffer = WIN_CreateWindowFramebuffer;
@@ -169,6 +178,7 @@ WIN_CreateDevice(int devindex)
     device->OnWindowEnter = WIN_OnWindowEnter;
     device->SetWindowHitTest = WIN_SetWindowHitTest;
     device->AcceptDragAndDrop = WIN_AcceptDragAndDrop;
+    device->FlashWindow = WIN_FlashWindow;
 
     device->shape_driver.CreateShaper = Win32_CreateShaper;
     device->shape_driver.SetWindowShape = Win32_SetWindowShape;
@@ -184,7 +194,7 @@ WIN_CreateDevice(int devindex)
     device->GL_GetSwapInterval = WIN_GL_GetSwapInterval;
     device->GL_SwapWindow = WIN_GL_SwapWindow;
     device->GL_DeleteContext = WIN_GL_DeleteContext;
-#elif SDL_VIDEO_OPENGL_EGL        
+#elif SDL_VIDEO_OPENGL_EGL
     /* Use EGL based functions */
     device->GL_LoadLibrary = WIN_GLES_LoadLibrary;
     device->GL_GetProcAddress = WIN_GLES_GetProcAddress;
@@ -206,6 +216,8 @@ WIN_CreateDevice(int devindex)
     device->StartTextInput = WIN_StartTextInput;
     device->StopTextInput = WIN_StopTextInput;
     device->SetTextInputRect = WIN_SetTextInputRect;
+    device->ClearComposition = WIN_ClearComposition;
+    device->IsTextInputShown = WIN_IsTextInputShown;
 
     device->SetClipboardText = WIN_SetClipboardText;
     device->GetClipboardText = WIN_GetClipboardText;
@@ -224,6 +236,8 @@ VideoBootStrap WINDOWS_bootstrap = {
 int
 WIN_VideoInit(_THIS)
 {
+    SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
+
     if (WIN_InitModes(_this) < 0) {
         return -1;
     }
@@ -234,6 +248,8 @@ WIN_VideoInit(_THIS)
     SDL_AddHintCallback(SDL_HINT_WINDOWS_ENABLE_MESSAGELOOP, UpdateWindowsEnableMessageLoop, NULL);
     SDL_AddHintCallback(SDL_HINT_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN, UpdateWindowFrameUsableWhileCursorHidden, NULL);
 
+    data->_SDL_WAKEUP = RegisterWindowMessageA("_SDL_WAKEUP");
+
     return 0;
 }
 
@@ -249,7 +265,7 @@ WIN_VideoQuit(_THIS)
 #define D3D_DEBUG_INFO
 #include <d3d9.h>
 
-SDL_bool 
+SDL_bool
 D3D_LoadDLL(void **pD3DDLL, IDirect3D9 **pDirect3D9Interface)
 {
     *pD3DDLL = SDL_LoadObject("D3D9.DLL");
@@ -257,24 +273,24 @@ D3D_LoadDLL(void **pD3DDLL, IDirect3D9 **pDirect3D9Interface)
         typedef IDirect3D9 *(WINAPI *Direct3DCreate9_t) (UINT SDKVersion);
         Direct3DCreate9_t Direct3DCreate9Func;
 
-#ifdef USE_D3D9EX
-        typedef HRESULT (WINAPI *Direct3DCreate9Ex_t)(UINT SDKVersion, IDirect3D9Ex **ppD3D);
-        Direct3DCreate9Ex_t Direct3DCreate9ExFunc;
+        if (SDL_GetHintBoolean(SDL_HINT_WINDOWS_USE_D3D9EX, SDL_FALSE)) {
+            typedef HRESULT(WINAPI* Direct3DCreate9Ex_t)(UINT SDKVersion, IDirect3D9Ex** ppD3D);
+            Direct3DCreate9Ex_t Direct3DCreate9ExFunc;
 
-        Direct3DCreate9ExFunc = (Direct3DCreate9Ex_t)SDL_LoadFunction(*pD3DDLL, "Direct3DCreate9Ex");
-        if (Direct3DCreate9ExFunc) {
-            IDirect3D9Ex *pDirect3D9ExInterface;
-            HRESULT hr = Direct3DCreate9ExFunc(D3D_SDK_VERSION, &pDirect3D9ExInterface);
-            if (SUCCEEDED(hr)) {
-                const GUID IDirect3D9_GUID = { 0x81bdcbca, 0x64d4, 0x426d, { 0xae, 0x8d, 0xad, 0x1, 0x47, 0xf4, 0x27, 0x5c } };
-                hr = IDirect3D9Ex_QueryInterface(pDirect3D9ExInterface, &IDirect3D9_GUID, (void**)pDirect3D9Interface);
-                IDirect3D9Ex_Release(pDirect3D9ExInterface);
+            Direct3DCreate9ExFunc = (Direct3DCreate9Ex_t)SDL_LoadFunction(*pD3DDLL, "Direct3DCreate9Ex");
+            if (Direct3DCreate9ExFunc) {
+                IDirect3D9Ex* pDirect3D9ExInterface;
+                HRESULT hr = Direct3DCreate9ExFunc(D3D_SDK_VERSION, &pDirect3D9ExInterface);
                 if (SUCCEEDED(hr)) {
-                    return SDL_TRUE;
+                    const GUID IDirect3D9_GUID = { 0x81bdcbca, 0x64d4, 0x426d, { 0xae, 0x8d, 0xad, 0x1, 0x47, 0xf4, 0x27, 0x5c } };
+                    hr = IDirect3D9Ex_QueryInterface(pDirect3D9ExInterface, &IDirect3D9_GUID, (void**)pDirect3D9Interface);
+                    IDirect3D9Ex_Release(pDirect3D9ExInterface);
+                    if (SUCCEEDED(hr)) {
+                        return SDL_TRUE;
+                    }
                 }
             }
         }
-#endif /* USE_D3D9EX */
 
         Direct3DCreate9Func = (Direct3DCreate9_t)SDL_LoadFunction(*pD3DDLL, "Direct3DCreate9");
         if (Direct3DCreate9Func) {
@@ -308,7 +324,7 @@ SDL_Direct3D9GetAdapterIndex(int displayIndex)
             SDL_SetError("Invalid display index");
             adapterIndex = -1; /* make sure we return something invalid */
         } else {
-            char *displayName = WIN_StringToUTF8(pData->DeviceName);
+            char *displayName = WIN_StringToUTF8W(pData->DeviceName);
             unsigned int count = IDirect3D9_GetAdapterCount(pD3D);
             unsigned int i;
             for (i=0; i<count; i++) {
@@ -407,14 +423,14 @@ SDL_DXGIGetOutputInfo(int displayIndex, int *adapterIndex, int *outputIndex)
         return SDL_FALSE;
     }
 
-    displayName = WIN_StringToUTF8(pData->DeviceName);
+    displayName = WIN_StringToUTF8W(pData->DeviceName);
     nAdapter = 0;
     while (*adapterIndex == -1 && SUCCEEDED(IDXGIFactory_EnumAdapters(pDXGIFactory, nAdapter, &pDXGIAdapter))) {
         nOutput = 0;
         while (*adapterIndex == -1 && SUCCEEDED(IDXGIAdapter_EnumOutputs(pDXGIAdapter, nOutput, &pDXGIOutput))) {
             DXGI_OUTPUT_DESC outputDesc;
             if (SUCCEEDED(IDXGIOutput_GetDesc(pDXGIOutput, &outputDesc))) {
-                char *outputName = WIN_StringToUTF8(outputDesc.DeviceName);
+                char *outputName = WIN_StringToUTF8W(outputDesc.DeviceName);
                 if (SDL_strcmp(outputName, displayName) == 0) {
                     *adapterIndex = nAdapter;
                     *outputIndex = nOutput;
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowsvideo.h b/Engine/lib/sdl/src/video/windows/SDL_windowsvideo.h
index c701bf56c..d4208c405 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowsvideo.h
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowsvideo.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -37,6 +37,7 @@
 
 #define MAX_CANDLIST    10
 #define MAX_CANDLENGTH  256
+#define MAX_CANDSIZE    (sizeof(WCHAR) * MAX_CANDLIST * MAX_CANDLENGTH)
 
 #include "SDL_windowsclipboard.h"
 #include "SDL_windowsevents.h"
@@ -85,6 +86,8 @@ typedef enum MONITOR_DPI_TYPE {
     MDT_DEFAULT = MDT_EFFECTIVE_DPI
 } MONITOR_DPI_TYPE;
 
+#else
+#include <shellscalingapi.h>
 #endif /* WINVER < 0x0603 */
 
 typedef BOOL  (*PFNSHFullScreen)(HWND, DWORD);
@@ -148,14 +151,16 @@ typedef struct SDL_VideoData
     SDL_bool ime_available;
     HWND ime_hwnd_main;
     HWND ime_hwnd_current;
+    SDL_bool ime_suppress_endcomposition_event;
     HIMC ime_himc;
 
-    WCHAR ime_composition[SDL_TEXTEDITINGEVENT_TEXT_SIZE];
+    WCHAR* ime_composition;
+    int ime_composition_length;
     WCHAR ime_readingstring[16];
     int ime_cursor;
 
     SDL_bool ime_candlist;
-    WCHAR ime_candidates[MAX_CANDLIST][MAX_CANDLENGTH];
+    WCHAR* ime_candidates;
     DWORD ime_candcount;
     DWORD ime_candref;
     DWORD ime_candsel;
@@ -186,6 +191,10 @@ typedef struct SDL_VideoData
     DWORD ime_convmodesinkcookie;
     TSFSink *ime_uielemsink;
     TSFSink *ime_ippasink;
+    LONG ime_uicontext;
+
+    BYTE pre_hook_key_state[256];
+    UINT _SDL_WAKEUP;
 } SDL_VideoData;
 
 extern SDL_bool g_WindowsEnableMessageLoop;
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowsvulkan.c b/Engine/lib/sdl/src/video/windows/SDL_windowsvulkan.c
index 803f8db82..2a66f4398 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowsvulkan.c
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowsvulkan.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowsvulkan.h b/Engine/lib/sdl/src/video/windows/SDL_windowsvulkan.h
index edf02b8d6..eda37d362 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowsvulkan.h
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowsvulkan.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowswindow.c b/Engine/lib/sdl/src/video/windows/SDL_windowswindow.c
index 61f12eda2..890d790ea 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowswindow.c
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowswindow.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -28,6 +28,7 @@
 #include "../SDL_pixels_c.h"
 #include "../../events/SDL_keyboard_c.h"
 #include "../../events/SDL_mouse_c.h"
+#include "../../SDL_hints_c.h"
 
 #include "SDL_windowsvideo.h"
 #include "SDL_windowswindow.h"
@@ -47,20 +48,21 @@
 
 /* Fake window to help with DirectInput events. */
 HWND SDL_HelperWindow = NULL;
-static WCHAR *SDL_HelperWindowClassName = TEXT("SDLHelperWindowInputCatcher");
-static WCHAR *SDL_HelperWindowName = TEXT("SDLHelperWindowInputMsgWindow");
+static const TCHAR *SDL_HelperWindowClassName = TEXT("SDLHelperWindowInputCatcher");
+static const TCHAR *SDL_HelperWindowName = TEXT("SDLHelperWindowInputMsgWindow");
 static ATOM SDL_HelperWindowClass = 0;
 
-/* For borderless Windows, still want the following flags:
+/* For borderless Windows, still want the following flag:
+   - WS_MINIMIZEBOX: window will respond to Windows minimize commands sent to all windows, such as windows key + m, shaking title bar, etc.
+   Additionally, non-fullscreen windows can add:
    - WS_CAPTION: this seems to enable the Windows minimize animation
    - WS_SYSMENU: enables system context menu on task bar
-   - WS_MINIMIZEBOX: window will respond to Windows minimize commands sent to all windows, such as windows key + m, shaking title bar, etc.
    This will also cause the task bar to overlap the window and other windowed behaviors, so only use this for windows that shouldn't appear to be fullscreen
  */
 
 #define STYLE_BASIC         (WS_CLIPSIBLINGS | WS_CLIPCHILDREN)
-#define STYLE_FULLSCREEN    (WS_POPUP)
-#define STYLE_BORDERLESS    (WS_POPUP)
+#define STYLE_FULLSCREEN    (WS_POPUP | WS_MINIMIZEBOX)
+#define STYLE_BORDERLESS    (WS_POPUP | WS_MINIMIZEBOX)
 #define STYLE_BORDERLESS_WINDOWED (WS_POPUP | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX)
 #define STYLE_NORMAL        (WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX)
 #define STYLE_RESIZABLE     (WS_THICKFRAME | WS_MAXIMIZEBOX)
@@ -162,13 +164,20 @@ WIN_SetWindowPositionInternal(_THIS, SDL_Window * window, UINT flags)
         top = HWND_NOTOPMOST;
     }
 
-    WIN_AdjustWindowRect(window, &x, &y, &w, &h, SDL_TRUE);    
+    WIN_AdjustWindowRect(window, &x, &y, &w, &h, SDL_TRUE);
 
     data->expected_resize = SDL_TRUE;
     SetWindowPos(hwnd, top, x, y, w, h, flags);
     data->expected_resize = SDL_FALSE;
 }
 
+static void SDLCALL
+WIN_MouseRelativeModeCenterChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
+{
+    SDL_WindowData *data = (SDL_WindowData *)userdata;
+    data->mouse_relative_mode_center = SDL_GetStringBoolean(hint, SDL_TRUE);
+}
+
 static int
 SetupWindowData(_THIS, SDL_Window * window, HWND hwnd, HWND parent, SDL_bool created)
 {
@@ -186,11 +195,14 @@ SetupWindowData(_THIS, SDL_Window * window, HWND hwnd, HWND parent, SDL_bool cre
     data->hdc = GetDC(hwnd);
     data->hinstance = (HINSTANCE) GetWindowLongPtr(hwnd, GWLP_HINSTANCE);
     data->created = created;
-    data->mouse_button_flags = 0;
+    data->high_surrogate = 0;
+    data->mouse_button_flags = (WPARAM)-1;
     data->last_pointer_update = (LPARAM)-1;
     data->videodata = videodata;
     data->initializing = SDL_TRUE;
 
+    SDL_AddHintCallback(SDL_HINT_MOUSE_RELATIVE_MODE_CENTER, WIN_MouseRelativeModeCenterChanged, data);
+
     window->driverdata = data;
 
     /* Associate the data with the window */
@@ -280,15 +292,8 @@ SetupWindowData(_THIS, SDL_Window * window, HWND hwnd, HWND parent, SDL_bool cre
     }
     if (GetFocus() == hwnd) {
         window->flags |= SDL_WINDOW_INPUT_FOCUS;
-        SDL_SetKeyboardFocus(data->window);
-
-        if (window->flags & SDL_WINDOW_INPUT_GRABBED) {
-            RECT rect;
-            GetClientRect(hwnd, &rect);
-            ClientToScreen(hwnd, (LPPOINT) & rect);
-            ClientToScreen(hwnd, (LPPOINT) & rect + 1);
-            ClipCursor(&rect);
-        }
+        SDL_SetKeyboardFocus(window);
+        WIN_UpdateClipCursor(window);
     }
 
     /* Enable multi-touch */
@@ -302,7 +307,39 @@ SetupWindowData(_THIS, SDL_Window * window, HWND hwnd, HWND parent, SDL_bool cre
     return 0;
 }
 
+static void CleanupWindowData(_THIS, SDL_Window * window)
+{
+    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
 
+    if (data) {
+        SDL_DelHintCallback(SDL_HINT_MOUSE_RELATIVE_MODE_CENTER, WIN_MouseRelativeModeCenterChanged, data);
+
+        if (data->keyboard_hook) {
+            UnhookWindowsHookEx(data->keyboard_hook);
+        }
+        ReleaseDC(data->hwnd, data->hdc);
+        RemoveProp(data->hwnd, TEXT("SDL_WindowData"));
+        if (data->created) {
+            DestroyWindow(data->hwnd);
+            if (data->parent) {
+                DestroyWindow(data->parent);
+            }
+        } else {
+            /* Restore any original event handler... */
+            if (data->wndproc != NULL) {
+#ifdef GWLP_WNDPROC
+                SetWindowLongPtr(data->hwnd, GWLP_WNDPROC,
+                                 (LONG_PTR) data->wndproc);
+#else
+                SetWindowLong(data->hwnd, GWL_WNDPROC,
+                              (LONG_PTR) data->wndproc);
+#endif
+            }
+        }
+        SDL_free(data);
+    }
+    window->driverdata = NULL;
+}
 
 int
 WIN_CreateWindow(_THIS, SDL_Window * window)
@@ -364,7 +401,7 @@ WIN_CreateWindow(_THIS, SDL_Window * window)
         return 0;
 #else
         return SDL_SetError("Could not create GLES window surface (EGL support not configured)");
-#endif /* SDL_VIDEO_OPENGL_EGL */ 
+#endif /* SDL_VIDEO_OPENGL_EGL */
     }
 #endif /* SDL_VIDEO_OPENGL_ES2 */
 
@@ -427,6 +464,9 @@ WIN_CreateWindowFrom(_THIS, SDL_Window * window, const void *data)
                     }
                 }
             }
+        } else if (window->flags & SDL_WINDOW_OPENGL) {
+            /* Try to set up the pixel format, if it hasn't been set by the application */
+            WIN_GL_SetupWindow(_this, window);
         }
     }
 #endif
@@ -448,39 +488,40 @@ WIN_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon)
     HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;
     HICON hicon = NULL;
     BYTE *icon_bmp;
-    int icon_len, mask_len, y;
-    SDL_RWops *dst;
+    int icon_len, mask_len, row_len, y;
+    BITMAPINFOHEADER *bmi;
+    Uint8 *dst;
     SDL_bool isstack;
 
     /* Create temporary buffer for ICONIMAGE structure */
+    SDL_COMPILE_TIME_ASSERT(WIN_SetWindowIcon_uses_BITMAPINFOHEADER_to_prepare_an_ICONIMAGE, sizeof(BITMAPINFOHEADER) == 40);
     mask_len = (icon->h * (icon->w + 7)/8);
-    icon_len = 40 + icon->h * icon->w * sizeof(Uint32) + mask_len;
+    icon_len = sizeof(BITMAPINFOHEADER) + icon->h * icon->w * sizeof(Uint32) + mask_len;
     icon_bmp = SDL_small_alloc(BYTE, icon_len, &isstack);
-    dst = SDL_RWFromMem(icon_bmp, icon_len);
-    if (!dst) {
-        SDL_small_free(icon_bmp, isstack);
-        return;
-    }
 
     /* Write the BITMAPINFO header */
-    SDL_WriteLE32(dst, 40);
-    SDL_WriteLE32(dst, icon->w);
-    SDL_WriteLE32(dst, icon->h * 2);
-    SDL_WriteLE16(dst, 1);
-    SDL_WriteLE16(dst, 32);
-    SDL_WriteLE32(dst, BI_RGB);
-    SDL_WriteLE32(dst, icon->h * icon->w * sizeof(Uint32));
-    SDL_WriteLE32(dst, 0);
-    SDL_WriteLE32(dst, 0);
-    SDL_WriteLE32(dst, 0);
-    SDL_WriteLE32(dst, 0);
+    bmi = (BITMAPINFOHEADER *)icon_bmp;
+    bmi->biSize = SDL_SwapLE32(sizeof(BITMAPINFOHEADER));
+    bmi->biWidth = SDL_SwapLE32(icon->w);
+    bmi->biHeight = SDL_SwapLE32(icon->h * 2);
+    bmi->biPlanes = SDL_SwapLE16(1);
+    bmi->biBitCount = SDL_SwapLE16(32);
+    bmi->biCompression = SDL_SwapLE32(BI_RGB);
+    bmi->biSizeImage = SDL_SwapLE32(icon->h * icon->w * sizeof(Uint32));
+    bmi->biXPelsPerMeter = SDL_SwapLE32(0);
+    bmi->biYPelsPerMeter = SDL_SwapLE32(0);
+    bmi->biClrUsed = SDL_SwapLE32(0);
+    bmi->biClrImportant = SDL_SwapLE32(0);
 
     /* Write the pixels upside down into the bitmap buffer */
     SDL_assert(icon->format->format == SDL_PIXELFORMAT_ARGB8888);
+    dst = &icon_bmp[sizeof(BITMAPINFOHEADER)];
+    row_len = icon->w * sizeof(Uint32);
     y = icon->h;
     while (y--) {
         Uint8 *src = (Uint8 *) icon->pixels + y * icon->pitch;
-        SDL_RWwrite(dst, src, icon->w * sizeof(Uint32), 1);
+        SDL_memcpy(dst, src, row_len);
+        dst += row_len;
     }
 
     /* Write the mask */
@@ -488,7 +529,6 @@ WIN_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon)
 
     hicon = CreateIconFromResource(icon_bmp, icon_len, TRUE, 0x00030000);
 
-    SDL_RWclose(dst);
     SDL_small_free(icon_bmp, isstack);
 
     /* Set the icon for the window */
@@ -559,9 +599,9 @@ WIN_ShowWindow(_THIS, SDL_Window * window)
     DWORD style;
     HWND hwnd;
     int nCmdShow;
-    
+
     hwnd = ((SDL_WindowData *)window->driverdata)->hwnd;
-    nCmdShow = SW_SHOW;
+    nCmdShow = SDL_GetHintBoolean(SDL_HINT_WINDOW_NO_ACTIVATION_WHEN_SHOWN, SDL_FALSE) ? SW_SHOWNA : SW_SHOW;
     style = GetWindowLong(hwnd, GWL_EXSTYLE);
     if (style & WS_EX_NOACTIVATE) {
         nCmdShow = SW_SHOWNOACTIVATE;
@@ -579,8 +619,38 @@ WIN_HideWindow(_THIS, SDL_Window * window)
 void
 WIN_RaiseWindow(_THIS, SDL_Window * window)
 {
+    /* If desired, raise the window more forcefully.
+     * Technique taken from http://stackoverflow.com/questions/916259/ .
+     * Specifically, http://stackoverflow.com/a/34414846 .
+     *
+     * The issue is that Microsoft has gone through a lot of trouble to make it
+     * nearly impossible to programmatically move a window to the foreground,
+     * for "security" reasons. Apparently, the following song-and-dance gets
+     * around their objections. */
+    SDL_bool bForce = SDL_GetHintBoolean(SDL_HINT_FORCE_RAISEWINDOW, SDL_FALSE);
+
+    HWND hCurWnd = NULL;
+    DWORD dwMyID = 0u;
+    DWORD dwCurID = 0u;
+
     HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;
+    if(bForce)
+    {
+        hCurWnd = GetForegroundWindow();
+        dwMyID = GetCurrentThreadId();
+        dwCurID = GetWindowThreadProcessId(hCurWnd, NULL);
+        ShowWindow(hwnd, SW_RESTORE);
+        AttachThreadInput(dwCurID, dwMyID, TRUE);
+        SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE);
+        SetWindowPos(hwnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE);
+    }
     SetForegroundWindow(hwnd);
+    if (bForce)
+    {
+        AttachThreadInput(dwCurID, dwMyID, FALSE);
+        SetFocus(hwnd);
+        SetActiveWindow(hwnd);
+    }
 }
 
 void
@@ -631,6 +701,18 @@ WIN_SetWindowResizable(_THIS, SDL_Window * window, SDL_bool resizable)
     SetWindowLong(hwnd, GWL_STYLE, style);
 }
 
+void
+WIN_SetWindowAlwaysOnTop(_THIS, SDL_Window * window, SDL_bool on_top)
+{
+    SDL_WindowData *data = (SDL_WindowData *)window->driverdata;
+    HWND hwnd = data->hwnd;
+    if (on_top) {
+        SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
+    } else {
+        SetWindowPos(hwnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
+    }
+}
+
 void
 WIN_RestoreWindow(_THIS, SDL_Window * window)
 {
@@ -708,7 +790,7 @@ WIN_SetWindowGammaRamp(_THIS, SDL_Window * window, const Uint16 * ramp)
     HDC hdc;
     BOOL succeeded = FALSE;
 
-    hdc = CreateDC(data->DeviceName, NULL, NULL, NULL);
+    hdc = CreateDCW(data->DeviceName, NULL, NULL, NULL);
     if (hdc) {
         succeeded = SetDeviceGammaRamp(hdc, (LPVOID)ramp);
         if (!succeeded) {
@@ -719,6 +801,32 @@ WIN_SetWindowGammaRamp(_THIS, SDL_Window * window, const Uint16 * ramp)
     return succeeded ? 0 : -1;
 }
 
+void*
+WIN_GetWindowICCProfile(_THIS, SDL_Window * window, size_t * size)
+{
+    SDL_VideoDisplay* display = SDL_GetDisplayForWindow(window);
+    SDL_DisplayData* data = (SDL_DisplayData*)display->driverdata;
+    HDC hdc;
+    BOOL succeeded = FALSE;
+    WCHAR filename[MAX_PATH];
+    DWORD fileNameSize = MAX_PATH;
+    void* iccProfileData = NULL;
+
+    hdc = CreateDCW(data->DeviceName, NULL, NULL, NULL);
+    if (hdc) {
+        succeeded = GetICMProfileW(hdc, &fileNameSize, filename);
+        DeleteDC(hdc);
+    }
+
+    if (succeeded) {
+        iccProfileData = SDL_LoadFile(WIN_StringToUTF8(filename), size);
+        if (!iccProfileData)
+            SDL_SetError("Could not open ICC profile");
+    }
+
+    return iccProfileData;
+}
+
 int
 WIN_GetWindowGammaRamp(_THIS, SDL_Window * window, Uint16 * ramp)
 {
@@ -727,7 +835,7 @@ WIN_GetWindowGammaRamp(_THIS, SDL_Window * window, Uint16 * ramp)
     HDC hdc;
     BOOL succeeded = FALSE;
 
-    hdc = CreateDC(data->DeviceName, NULL, NULL, NULL);
+    hdc = CreateDCW(data->DeviceName, NULL, NULL, NULL);
     if (hdc) {
         succeeded = GetDeviceGammaRamp(hdc, (LPVOID)ramp);
         if (!succeeded) {
@@ -738,49 +846,76 @@ WIN_GetWindowGammaRamp(_THIS, SDL_Window * window, Uint16 * ramp)
     return succeeded ? 0 : -1;
 }
 
+static void WIN_GrabKeyboard(SDL_Window *window)
+{
+    SDL_WindowData *data = (SDL_WindowData *)window->driverdata;
+    HMODULE module;
+
+    if (data->keyboard_hook) {
+        return;
+    }
+
+    /* SetWindowsHookEx() needs to know which module contains the hook we
+       want to install. This is complicated by the fact that SDL can be
+       linked statically or dynamically. Fortunately XP and later provide
+       this nice API that will go through the loaded modules and find the
+       one containing our code.
+    */
+    if (!GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT | GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
+                           (LPTSTR)WIN_KeyboardHookProc,
+                           &module)) {
+        return;
+    }
+
+    /* Capture a snapshot of the current keyboard state before the hook */
+    if (!GetKeyboardState(data->videodata->pre_hook_key_state)) {
+        return;
+    }
+
+    /* To grab the keyboard, we have to install a low-level keyboard hook to
+       intercept keys that would normally be captured by the OS. Intercepting
+       all key events on the system is rather invasive, but it's what Microsoft
+       actually documents that you do to capture these.
+    */
+    data->keyboard_hook = SetWindowsHookEx(WH_KEYBOARD_LL, WIN_KeyboardHookProc, module, 0);
+}
+
+void WIN_UngrabKeyboard(SDL_Window *window)
+{
+    SDL_WindowData *data = (SDL_WindowData *)window->driverdata;
+
+    if (data->keyboard_hook) {
+        UnhookWindowsHookEx(data->keyboard_hook);
+        data->keyboard_hook = NULL;
+    }
+}
+
 void
-WIN_SetWindowGrab(_THIS, SDL_Window * window, SDL_bool grabbed)
+WIN_SetWindowMouseRect(_THIS, SDL_Window * window)
 {
     WIN_UpdateClipCursor(window);
+}
 
-    if (window->flags & SDL_WINDOW_FULLSCREEN) {
-        UINT flags = SWP_NOCOPYBITS | SWP_NOMOVE | SWP_NOSIZE;
+void
+WIN_SetWindowMouseGrab(_THIS, SDL_Window * window, SDL_bool grabbed)
+{
+    WIN_UpdateClipCursor(window);
+}
 
-        if (!(window->flags & SDL_WINDOW_SHOWN)) {
-            flags |= SWP_NOACTIVATE;
-        }
-        WIN_SetWindowPositionInternal(_this, window, flags);
+void
+WIN_SetWindowKeyboardGrab(_THIS, SDL_Window * window, SDL_bool grabbed)
+{
+    if (grabbed) {
+        WIN_GrabKeyboard(window);
+    } else {
+        WIN_UngrabKeyboard(window);
     }
 }
 
 void
 WIN_DestroyWindow(_THIS, SDL_Window * window)
 {
-    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
-
-    if (data) {
-        ReleaseDC(data->hwnd, data->hdc);
-        RemoveProp(data->hwnd, TEXT("SDL_WindowData"));
-        if (data->created) {
-            DestroyWindow(data->hwnd);
-            if (data->parent) {
-                DestroyWindow(data->parent);
-            }
-        } else {
-            /* Restore any original event handler... */
-            if (data->wndproc != NULL) {
-#ifdef GWLP_WNDPROC
-                SetWindowLongPtr(data->hwnd, GWLP_WNDPROC,
-                                 (LONG_PTR) data->wndproc);
-#else
-                SetWindowLong(data->hwnd, GWL_WNDPROC,
-                              (LONG_PTR) data->wndproc);
-#endif
-            }
-        }
-        SDL_free(data);
-    }
-    window->driverdata = NULL;
+    CleanupWindowData(_this, window);
 }
 
 SDL_bool
@@ -826,7 +961,7 @@ SDL_HelperWindowCreate(void)
     /* Create the class. */
     SDL_zero(wce);
     wce.lpfnWndProc = DefWindowProc;
-    wce.lpszClassName = (LPCWSTR) SDL_HelperWindowClassName;
+    wce.lpszClassName = SDL_HelperWindowClassName;
     wce.hInstance = hInstance;
 
     /* Register the class. */
@@ -890,18 +1025,6 @@ void WIN_OnWindowEnter(_THIS, SDL_Window * window)
     if (window->flags & SDL_WINDOW_ALWAYS_ON_TOP) {
         WIN_SetWindowPositionInternal(_this, window, SWP_NOCOPYBITS | SWP_NOSIZE | SWP_NOACTIVATE);
     }
-
-#ifdef WM_MOUSELEAVE
-    {
-        TRACKMOUSEEVENT trackMouseEvent;
-
-        trackMouseEvent.cbSize = sizeof(TRACKMOUSEEVENT);
-        trackMouseEvent.dwFlags = TME_LEAVE;
-        trackMouseEvent.hwndTrack = data->hwnd;
-
-        TrackMouseEvent(&trackMouseEvent);
-    }
-#endif /* WM_MOUSELEAVE */
 }
 
 void
@@ -921,9 +1044,10 @@ WIN_UpdateClipCursor(SDL_Window *window)
         return;
     }
 
-    if ((mouse->relative_mode || (window->flags & SDL_WINDOW_INPUT_GRABBED)) &&
+    if ((mouse->relative_mode || (window->flags & SDL_WINDOW_MOUSE_GRABBED) ||
+         (window->mouse_rect.w > 0 && window->mouse_rect.h > 0)) &&
         (window->flags & SDL_WINDOW_INPUT_FOCUS)) {
-        if (mouse->relative_mode && !mouse->relative_mode_warp) {
+        if (mouse->relative_mode && !mouse->relative_mode_warp && data->mouse_relative_mode_center) {
             if (GetWindowRect(data->hwnd, &rect)) {
                 LONG cx, cy;
 
@@ -943,12 +1067,32 @@ WIN_UpdateClipCursor(SDL_Window *window)
                 }
             }
         } else {
-            if (GetClientRect(data->hwnd, &rect) && !IsRectEmpty(&rect)) {
+            if (GetClientRect(data->hwnd, &rect)) {
                 ClientToScreen(data->hwnd, (LPPOINT) & rect);
                 ClientToScreen(data->hwnd, (LPPOINT) & rect + 1);
+                if (window->mouse_rect.w > 0 && window->mouse_rect.h > 0) {
+                    RECT mouse_rect, intersection;
+
+                    mouse_rect.left = rect.left + window->mouse_rect.x;
+                    mouse_rect.top = rect.top + window->mouse_rect.y;
+                    mouse_rect.right = mouse_rect.left + window->mouse_rect.w - 1;
+                    mouse_rect.bottom = mouse_rect.top + window->mouse_rect.h - 1;
+                    if (IntersectRect(&intersection, &rect, &mouse_rect)) {
+                        SDL_memcpy(&rect, &intersection, sizeof(rect));
+                    } else if ((window->flags & SDL_WINDOW_MOUSE_GRABBED) != 0) {
+                        /* Mouse rect was invalid, just do the normal grab */
+                    } else {
+                        SDL_zero(rect);
+                    }
+                }
                 if (SDL_memcmp(&rect, &clipped_rect, sizeof(rect)) != 0) {
-                    if (ClipCursor(&rect)) {
-                        data->cursor_clipped_rect = rect;
+                    if (!IsRectEmpty(&rect)) {
+                        if (ClipCursor(&rect)) {
+                            data->cursor_clipped_rect = rect;
+                        }
+                    } else {
+                        ClipCursor(NULL);
+                        SDL_zero(data->cursor_clipped_rect);
                     }
                 }
             }
@@ -1015,6 +1159,34 @@ WIN_AcceptDragAndDrop(SDL_Window * window, SDL_bool accept)
     DragAcceptFiles(data->hwnd, accept ? TRUE : FALSE);
 }
 
+int
+WIN_FlashWindow(_THIS, SDL_Window * window, SDL_FlashOperation operation)
+{
+    FLASHWINFO desc;
+
+    SDL_zero(desc);
+    desc.cbSize = sizeof(desc);
+    desc.hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;
+    switch (operation) {
+    case SDL_FLASH_CANCEL:
+        desc.dwFlags = FLASHW_STOP;
+        break;
+    case SDL_FLASH_BRIEFLY:
+        desc.dwFlags = FLASHW_TRAY;
+        desc.uCount = 1;
+        break;
+    case SDL_FLASH_UNTIL_FOCUSED:
+        desc.dwFlags = (FLASHW_TRAY | FLASHW_TIMERNOFG);
+        break;
+    default:
+        return SDL_Unsupported();
+    }
+
+    FlashWindowEx(&desc);
+
+    return 0;
+}
+
 #endif /* SDL_VIDEO_DRIVER_WINDOWS */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowswindow.h b/Engine/lib/sdl/src/video/windows/SDL_windowswindow.h
index cfbf12050..659366a9f 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowswindow.h
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowswindow.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -37,9 +37,11 @@ typedef struct
     HINSTANCE hinstance;
     HBITMAP hbm;
     WNDPROC wndproc;
+    HHOOK keyboard_hook;
     SDL_bool created;
     WPARAM mouse_button_flags;
     LPARAM last_pointer_update;
+    WCHAR high_surrogate;
     SDL_bool initializing;
     SDL_bool expected_resize;
     SDL_bool in_border_change;
@@ -47,9 +49,12 @@ typedef struct
     Uint8 focus_click_pending;
     SDL_bool skip_update_clipcursor;
     Uint32 last_updated_clipcursor;
+    SDL_bool mouse_relative_mode_center;
     SDL_bool windowed_mode_was_maximized;
     SDL_bool in_window_deactivation;
     RECT cursor_clipped_rect;
+    SDL_Point last_raw_mouse_position;
+    SDL_bool mouse_tracked;
     struct SDL_VideoData *videodata;
 #if SDL_VIDEO_OPENGL_EGL  
     EGLSurface egl_surface;
@@ -72,10 +77,14 @@ extern void WIN_MinimizeWindow(_THIS, SDL_Window * window);
 extern void WIN_RestoreWindow(_THIS, SDL_Window * window);
 extern void WIN_SetWindowBordered(_THIS, SDL_Window * window, SDL_bool bordered);
 extern void WIN_SetWindowResizable(_THIS, SDL_Window * window, SDL_bool resizable);
+extern void WIN_SetWindowAlwaysOnTop(_THIS, SDL_Window * window, SDL_bool on_top);
 extern void WIN_SetWindowFullscreen(_THIS, SDL_Window * window, SDL_VideoDisplay * display, SDL_bool fullscreen);
 extern int WIN_SetWindowGammaRamp(_THIS, SDL_Window * window, const Uint16 * ramp);
+extern void* WIN_GetWindowICCProfile(_THIS, SDL_Window * window, size_t * size);
 extern int WIN_GetWindowGammaRamp(_THIS, SDL_Window * window, Uint16 * ramp);
-extern void WIN_SetWindowGrab(_THIS, SDL_Window * window, SDL_bool grabbed);
+extern void WIN_SetWindowMouseRect(_THIS, SDL_Window * window);
+extern void WIN_SetWindowMouseGrab(_THIS, SDL_Window * window, SDL_bool grabbed);
+extern void WIN_SetWindowKeyboardGrab(_THIS, SDL_Window * window, SDL_bool grabbed);
 extern void WIN_DestroyWindow(_THIS, SDL_Window * window);
 extern SDL_bool WIN_GetWindowWMInfo(_THIS, SDL_Window * window,
                                     struct SDL_SysWMinfo *info);
@@ -83,6 +92,7 @@ extern void WIN_OnWindowEnter(_THIS, SDL_Window * window);
 extern void WIN_UpdateClipCursor(SDL_Window *window);
 extern int WIN_SetWindowHitTest(SDL_Window *window, SDL_bool enabled);
 extern void WIN_AcceptDragAndDrop(SDL_Window * window, SDL_bool accept);
+extern int WIN_FlashWindow(_THIS, SDL_Window * window, SDL_FlashOperation operation);
 
 #endif /* SDL_windowswindow_h_ */
 
diff --git a/Engine/lib/sdl/src/video/windows/wmmsg.h b/Engine/lib/sdl/src/video/windows/wmmsg.h
index 37ad7be13..bd416eb80 100644
--- a/Engine/lib/sdl/src/video/windows/wmmsg.h
+++ b/Engine/lib/sdl/src/video/windows/wmmsg.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -21,7 +21,7 @@
 
 #define MAX_WMMSG   (sizeof(wmtab)/sizeof(wmtab[0]))
 
-char *wmtab[] = {
+const char *wmtab[] = {
     "WM_NULL",
     "WM_CREATE",
     "WM_DESTROY",
diff --git a/Engine/lib/sdl/src/video/winrt/SDL_winrtevents.cpp b/Engine/lib/sdl/src/video/winrt/SDL_winrtevents.cpp
index b887547d5..646bde773 100644
--- a/Engine/lib/sdl/src/video/winrt/SDL_winrtevents.cpp
+++ b/Engine/lib/sdl/src/video/winrt/SDL_winrtevents.cpp
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/winrt/SDL_winrtevents_c.h b/Engine/lib/sdl/src/video/winrt/SDL_winrtevents_c.h
index 6f2bcedbf..112318024 100644
--- a/Engine/lib/sdl/src/video/winrt/SDL_winrtevents_c.h
+++ b/Engine/lib/sdl/src/video/winrt/SDL_winrtevents_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -53,7 +53,7 @@ typedef enum {
 extern Windows::Foundation::Point WINRT_TransformCursorPosition(SDL_Window * window,
                                                                 Windows::Foundation::Point rawPosition,
                                                                 WINRT_CursorNormalizationType normalization);
-extern Uint8 WINRT_GetSDLButtonForPointerPoint(Windows::UI::Input::PointerPoint ^pt);
+extern SDL_bool WINRT_GetSDLButtonForPointerPoint(Windows::UI::Input::PointerPoint ^pt, Uint8 *button, Uint8 *pressed);
 extern void WINRT_ProcessPointerPressedEvent(SDL_Window *window, Windows::UI::Input::PointerPoint ^pointerPoint);
 extern void WINRT_ProcessPointerMovedEvent(SDL_Window *window, Windows::UI::Input::PointerPoint ^pointerPoint);
 extern void WINRT_ProcessPointerReleasedEvent(SDL_Window *window, Windows::UI::Input::PointerPoint ^pointerPoint);
diff --git a/Engine/lib/sdl/src/video/winrt/SDL_winrtgamebar.cpp b/Engine/lib/sdl/src/video/winrt/SDL_winrtgamebar.cpp
index 8fe513ec2..2b1235721 100644
--- a/Engine/lib/sdl/src/video/winrt/SDL_winrtgamebar.cpp
+++ b/Engine/lib/sdl/src/video/winrt/SDL_winrtgamebar.cpp
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -89,7 +89,7 @@ WINRT_GetGameBar()
     IGameBarStatics_ *pGameBar = NULL;
     HRESULT hr;
 
-    hr = ::WindowsCreateString(wClassName, (UINT32)wcslen(wClassName), &hClassName);
+    hr = ::WindowsCreateString(wClassName, (UINT32)SDL_wcslen(wClassName), &hClassName);
     if (FAILED(hr)) {
         goto done;
     }
diff --git a/Engine/lib/sdl/src/video/winrt/SDL_winrtgamebar_cpp.h b/Engine/lib/sdl/src/video/winrt/SDL_winrtgamebar_cpp.h
index f9b474b08..a77758791 100644
--- a/Engine/lib/sdl/src/video/winrt/SDL_winrtgamebar_cpp.h
+++ b/Engine/lib/sdl/src/video/winrt/SDL_winrtgamebar_cpp.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/winrt/SDL_winrtkeyboard.cpp b/Engine/lib/sdl/src/video/winrt/SDL_winrtkeyboard.cpp
index 659541f6d..40681cb8a 100644
--- a/Engine/lib/sdl/src/video/winrt/SDL_winrtkeyboard.cpp
+++ b/Engine/lib/sdl/src/video/winrt/SDL_winrtkeyboard.cpp
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/winrt/SDL_winrtmessagebox.cpp b/Engine/lib/sdl/src/video/winrt/SDL_winrtmessagebox.cpp
index 7f765e9cb..f74a7f483 100644
--- a/Engine/lib/sdl/src/video/winrt/SDL_winrtmessagebox.cpp
+++ b/Engine/lib/sdl/src/video/winrt/SDL_winrtmessagebox.cpp
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/winrt/SDL_winrtmessagebox.h b/Engine/lib/sdl/src/video/winrt/SDL_winrtmessagebox.h
index 8ece578b9..7d1429dbc 100644
--- a/Engine/lib/sdl/src/video/winrt/SDL_winrtmessagebox.h
+++ b/Engine/lib/sdl/src/video/winrt/SDL_winrtmessagebox.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/winrt/SDL_winrtmouse.cpp b/Engine/lib/sdl/src/video/winrt/SDL_winrtmouse.cpp
index 7dd5eff52..8c32e5fcf 100644
--- a/Engine/lib/sdl/src/video/winrt/SDL_winrtmouse.cpp
+++ b/Engine/lib/sdl/src/video/winrt/SDL_winrtmouse.cpp
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/winrt/SDL_winrtmouse_c.h b/Engine/lib/sdl/src/video/winrt/SDL_winrtmouse_c.h
index 39dfba64d..f5008962a 100644
--- a/Engine/lib/sdl/src/video/winrt/SDL_winrtmouse_c.h
+++ b/Engine/lib/sdl/src/video/winrt/SDL_winrtmouse_c.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/winrt/SDL_winrtopengles.cpp b/Engine/lib/sdl/src/video/winrt/SDL_winrtopengles.cpp
index adb620801..9e3c1772b 100644
--- a/Engine/lib/sdl/src/video/winrt/SDL_winrtopengles.cpp
+++ b/Engine/lib/sdl/src/video/winrt/SDL_winrtopengles.cpp
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/winrt/SDL_winrtopengles.h b/Engine/lib/sdl/src/video/winrt/SDL_winrtopengles.h
index 5e142b1df..c702c8b69 100644
--- a/Engine/lib/sdl/src/video/winrt/SDL_winrtopengles.h
+++ b/Engine/lib/sdl/src/video/winrt/SDL_winrtopengles.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/winrt/SDL_winrtpointerinput.cpp b/Engine/lib/sdl/src/video/winrt/SDL_winrtpointerinput.cpp
index 9b36aaaad..51cc93727 100644
--- a/Engine/lib/sdl/src/video/winrt/SDL_winrtpointerinput.cpp
+++ b/Engine/lib/sdl/src/video/winrt/SDL_winrtpointerinput.cpp
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -116,52 +116,55 @@ WINRT_TransformCursorPosition(SDL_Window * window,
     return outputPosition;
 }
 
-static inline int
-_lround(float arg)
-{
-    if (arg >= 0.0f) {
-        return (int)floor(arg + 0.5f);
-    } else {
-        return (int)ceil(arg - 0.5f);
-    }
-}
-
-Uint8
-WINRT_GetSDLButtonForPointerPoint(Windows::UI::Input::PointerPoint ^pt)
+SDL_bool
+WINRT_GetSDLButtonForPointerPoint(Windows::UI::Input::PointerPoint ^pt, Uint8 *button, Uint8 *pressed)
 {
     using namespace Windows::UI::Input;
 
 #if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP
-    return SDL_BUTTON_LEFT;
+    *button = SDL_BUTTON_LEFT;
+    return SDL_TRUE;
 #else
     switch (pt->Properties->PointerUpdateKind)
     {
         case PointerUpdateKind::LeftButtonPressed:
         case PointerUpdateKind::LeftButtonReleased:
-            return SDL_BUTTON_LEFT;
+            *button = SDL_BUTTON_LEFT;
+            *pressed = (pt->Properties->PointerUpdateKind == PointerUpdateKind::LeftButtonPressed);
+            return SDL_TRUE;
 
         case PointerUpdateKind::RightButtonPressed:
         case PointerUpdateKind::RightButtonReleased:
-            return SDL_BUTTON_RIGHT;
+            *button = SDL_BUTTON_RIGHT;
+            *pressed = (pt->Properties->PointerUpdateKind == PointerUpdateKind::RightButtonPressed);
+            return SDL_TRUE;
 
         case PointerUpdateKind::MiddleButtonPressed:
         case PointerUpdateKind::MiddleButtonReleased:
-            return SDL_BUTTON_MIDDLE;
+            *button = SDL_BUTTON_MIDDLE;
+            *pressed = (pt->Properties->PointerUpdateKind == PointerUpdateKind::MiddleButtonPressed);
+            return SDL_TRUE;
 
         case PointerUpdateKind::XButton1Pressed:
         case PointerUpdateKind::XButton1Released:
-            return SDL_BUTTON_X1;
+            *button = SDL_BUTTON_X1;
+            *pressed = (pt->Properties->PointerUpdateKind == PointerUpdateKind::XButton1Pressed);
+            return SDL_TRUE;
 
         case PointerUpdateKind::XButton2Pressed:
         case PointerUpdateKind::XButton2Released:
-            return SDL_BUTTON_X2;
+            *button = SDL_BUTTON_X2;
+            *pressed = (pt->Properties->PointerUpdateKind == PointerUpdateKind::XButton2Pressed);
+            return SDL_TRUE;
 
         default:
             break;
     }
 #endif
 
-    return 0;
+    *button = 0;
+    *pressed = 0;
+    return SDL_FALSE;
 }
 
 //const char *
@@ -221,9 +224,10 @@ void WINRT_ProcessPointerPressedEvent(SDL_Window *window, Windows::UI::Input::Po
         return;
     }
 
-    Uint8 button = WINRT_GetSDLButtonForPointerPoint(pointerPoint);
-
     if ( ! WINRT_IsTouchEvent(pointerPoint)) {
+        Uint8 button, pressed;
+        WINRT_GetSDLButtonForPointerPoint(pointerPoint, &button, &pressed);
+        SDL_assert(pressed == 1);
         SDL_SendMouseButton(window, 0, SDL_PRESSED, button);
     } else {
         Windows::Foundation::Point normalizedPoint = WINRT_TransformCursorPosition(window, pointerPoint->Position, NormalizeZeroToOne);
@@ -251,6 +255,12 @@ WINRT_ProcessPointerMovedEvent(SDL_Window *window, Windows::UI::Input::PointerPo
     Windows::Foundation::Point windowPoint = WINRT_TransformCursorPosition(window, pointerPoint->Position, TransformToSDLWindowSize);
 
     if ( ! WINRT_IsTouchEvent(pointerPoint)) {
+        /* For some odd reason Moved events are used for multiple mouse buttons */
+        Uint8 button, pressed;
+        if (WINRT_GetSDLButtonForPointerPoint(pointerPoint, &button, &pressed)) {
+            SDL_SendMouseButton(window, 0, pressed, button);
+        }
+
         SDL_SendMouseMotion(window, 0, 0, (int)windowPoint.X, (int)windowPoint.Y);
     } else {
         SDL_SendTouchMotion(
@@ -269,9 +279,10 @@ void WINRT_ProcessPointerReleasedEvent(SDL_Window *window, Windows::UI::Input::P
         return;
     }
 
-    Uint8 button = WINRT_GetSDLButtonForPointerPoint(pointerPoint);
-
     if (!WINRT_IsTouchEvent(pointerPoint)) {
+        Uint8 button, pressed;
+        WINRT_GetSDLButtonForPointerPoint(pointerPoint, &button, &pressed);
+        SDL_assert(pressed == 0);
         SDL_SendMouseButton(window, 0, SDL_RELEASED, button);
     } else {
         Windows::Foundation::Point normalizedPoint = WINRT_TransformCursorPosition(window, pointerPoint->Position, NormalizeZeroToOne);
@@ -389,8 +400,8 @@ WINRT_ProcessMouseMovedEvent(SDL_Window * window, Windows::Devices::Input::Mouse
         window,
         0,
         1,
-        _lround(mouseDeltaInSDLWindowCoords.X),
-        _lround(mouseDeltaInSDLWindowCoords.Y));
+        SDL_lroundf(mouseDeltaInSDLWindowCoords.X),
+        SDL_lroundf(mouseDeltaInSDLWindowCoords.Y));
 }
 
 #endif // SDL_VIDEO_DRIVER_WINRT
diff --git a/Engine/lib/sdl/src/video/winrt/SDL_winrtvideo.cpp b/Engine/lib/sdl/src/video/winrt/SDL_winrtvideo.cpp
index 99a52f39d..6ed5918e7 100644
--- a/Engine/lib/sdl/src/video/winrt/SDL_winrtvideo.cpp
+++ b/Engine/lib/sdl/src/video/winrt/SDL_winrtvideo.cpp
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -28,6 +28,12 @@
    was based off of SDL's "dummy" video driver.
  */
 
+/* Standard C++11 includes */
+#include <functional>
+#include <string>
+#include <sstream>
+using namespace std;
+
 /* Windows includes */
 #include <agile.h>
 #include <windows.graphics.display.h>
@@ -42,8 +48,8 @@ using namespace Windows::UI::ViewManagement;
 
 
 /* [re]declare Windows GUIDs locally, to limit the amount of external lib(s) SDL has to link to */
-static const GUID IID_IDisplayRequest   = { 0xe5732044, 0xf49f, 0x4b60, { 0x8d, 0xd4, 0x5e, 0x7e, 0x3a, 0x63, 0x2a, 0xc0 } };
-static const GUID IID_IDXGIFactory2     = { 0x50c83a1c, 0xe072, 0x4c48, { 0x87, 0xb0, 0x36, 0x30, 0xfa, 0x36, 0xa6, 0xd0 } };
+static const GUID SDL_IID_IDisplayRequest   = { 0xe5732044, 0xf49f, 0x4b60, { 0x8d, 0xd4, 0x5e, 0x7e, 0x3a, 0x63, 0x2a, 0xc0 } };
+static const GUID SDL_IID_IDXGIFactory2     = { 0x50c83a1c, 0xe072, 0x4c48, { 0x87, 0xb0, 0x36, 0x30, 0xfa, 0x36, 0xa6, 0xd0 } };
 
 
 /* SDL includes */
@@ -67,6 +73,7 @@ extern "C" {
 #include "SDL_winrtmouse_c.h"
 #include "SDL_main.h"
 #include "SDL_system.h"
+#include "SDL_hints.h"
 
 
 /* Initialization/Query functions */
@@ -171,6 +178,68 @@ VideoBootStrap WINRT_bootstrap = {
     WINRT_CreateDevice
 };
 
+static void SDLCALL
+WINRT_SetDisplayOrientationsPreference(void *userdata, const char *name, const char *oldValue, const char *newValue)
+{
+    SDL_assert(SDL_strcmp(name, SDL_HINT_ORIENTATIONS) == 0);
+
+    /* HACK: prevent SDL from altering an app's .appxmanifest-set orientation
+     * from being changed on startup, by detecting when SDL_HINT_ORIENTATIONS
+     * is getting registered.
+     *
+     * TODO, WinRT: consider reading in an app's .appxmanifest file, and apply its orientation when 'newValue == NULL'.
+     */
+    if ((oldValue == NULL) && (newValue == NULL)) {
+        return;
+    }
+
+    // Start with no orientation flags, then add each in as they're parsed
+    // from newValue.
+    unsigned int orientationFlags = 0;
+    if (newValue) {
+        std::istringstream tokenizer(newValue);
+        while (!tokenizer.eof()) {
+            std::string orientationName;
+            std::getline(tokenizer, orientationName, ' ');
+            if (orientationName == "LandscapeLeft") {
+                orientationFlags |= (unsigned int) DisplayOrientations::LandscapeFlipped;
+            } else if (orientationName == "LandscapeRight") {
+                orientationFlags |= (unsigned int) DisplayOrientations::Landscape;
+            } else if (orientationName == "Portrait") {
+                orientationFlags |= (unsigned int) DisplayOrientations::Portrait;
+            } else if (orientationName == "PortraitUpsideDown") {
+                orientationFlags |= (unsigned int) DisplayOrientations::PortraitFlipped;
+            }
+        }
+    }
+
+    // If no valid orientation flags were specified, use a reasonable set of defaults:
+    if (!orientationFlags) {
+        // TODO, WinRT: consider seeing if an app's default orientation flags can be found out via some API call(s).
+        orientationFlags = (unsigned int) ( \
+            DisplayOrientations::Landscape |
+            DisplayOrientations::LandscapeFlipped |
+            DisplayOrientations::Portrait |
+            DisplayOrientations::PortraitFlipped);
+    }
+
+    // Set the orientation/rotation preferences.  Please note that this does
+    // not constitute a 100%-certain lock of a given set of possible
+    // orientations.  According to Microsoft's documentation on WinRT [1]
+    // when a device is not capable of being rotated, Windows may ignore
+    // the orientation preferences, and stick to what the device is capable of
+    // displaying.
+    //
+    // [1] Documentation on the 'InitialRotationPreference' setting for a
+    // Windows app's manifest file describes how some orientation/rotation
+    // preferences may be ignored.  See
+    // http://msdn.microsoft.com/en-us/library/windows/apps/hh700343.aspx
+    // for details.  Microsoft's "Display orientation sample" also gives an
+    // outline of how Windows treats device rotation
+    // (http://code.msdn.microsoft.com/Display-Orientation-Sample-19a58e93).
+    WINRT_DISPLAY_PROPERTY(AutoRotationPreferences) = (DisplayOrientations) orientationFlags;
+}
+
 int
 WINRT_VideoInit(_THIS)
 {
@@ -178,6 +247,11 @@ WINRT_VideoInit(_THIS)
     if (WINRT_InitModes(_this) < 0) {
         return -1;
     }
+
+    // Register the hint, SDL_HINT_ORIENTATIONS, with SDL.
+    // TODO, WinRT: see if an app's default orientation can be found out via WinRT API(s), then set the initial value of SDL_HINT_ORIENTATIONS accordingly.
+    SDL_AddHintCallback(SDL_HINT_ORIENTATIONS, WINRT_SetDisplayOrientationsPreference, NULL);
+
     WINRT_InitMouse(_this);
     WINRT_InitTouch(_this);
     WINRT_InitGameBar(_this);
@@ -402,10 +476,9 @@ WINRT_InitModes(_THIS)
     HRESULT hr;
     IDXGIFactory2 * dxgiFactory2 = NULL;
 
-    hr = CreateDXGIFactory1(IID_IDXGIFactory2, (void **)&dxgiFactory2);
+    hr = CreateDXGIFactory1(SDL_IID_IDXGIFactory2, (void **)&dxgiFactory2);
     if (FAILED(hr)) {
-        WIN_SetErrorFromHRESULT(__FUNCTION__ ", CreateDXGIFactory1() failed", hr);
-        return -1;
+        return WIN_SetErrorFromHRESULT(__FUNCTION__ ", CreateDXGIFactory1() failed", hr);
     }
 
     for (int adapterIndex = 0; ; ++adapterIndex) {
@@ -556,14 +629,12 @@ WINRT_CreateWindow(_THIS, SDL_Window * window)
     // Make sure that only one window gets created, at least until multimonitor
     // support is added.
     if (WINRT_GlobalSDLWindow != NULL) {
-        SDL_SetError("WinRT only supports one window");
-        return -1;
+        return SDL_SetError("WinRT only supports one window");
     }
 
     SDL_WindowData *data = new SDL_WindowData;  /* use 'new' here as SDL_WindowData may use WinRT/C++ types */
     if (!data) {
-        SDL_OutOfMemory();
-        return -1;
+        return SDL_OutOfMemory();
     }
     window->driverdata = data;
     data->sdlWindow = window;
@@ -599,9 +670,8 @@ WINRT_CreateWindow(_THIS, SDL_Window * window)
          * be passed into eglCreateWindowSurface.
          */
         if (SDL_EGL_ChooseConfig(_this) != 0) {
-            char buf[512];
-            SDL_snprintf(buf, sizeof(buf), "SDL_EGL_ChooseConfig failed: %s", SDL_GetError());
-            return SDL_SetError("%s", buf);
+            /* SDL_EGL_ChooseConfig failed, SDL_GetError() should have info */
+            return -1; 
         }
 
         if (video_data->winrtEglWindow) {   /* ... is the 'old' version of ANGLE/WinRT being used? */
@@ -624,7 +694,7 @@ WINRT_CreateWindow(_THIS, SDL_Window * window)
             data->egl_surface = _this->egl_data->eglCreateWindowSurface(
                 _this->egl_data->egl_display,
                 _this->egl_data->egl_config,
-                coreWindowAsIInspectable,
+                (NativeWindowType)coreWindowAsIInspectable,
                 NULL);
             if (data->egl_surface == NULL) {
                 return SDL_EGL_SetError("unable to create EGL native-window surface", "eglCreateWindowSurface");
@@ -782,7 +852,7 @@ WINRT_CreateDisplayRequest(_THIS)
     ABI::Windows::System::Display::IDisplayRequest * pDisplayRequest = nullptr;
     HRESULT hr;
 
-    hr = ::WindowsCreateString(wClassName, (UINT32)wcslen(wClassName), &hClassName);
+    hr = ::WindowsCreateString(wClassName, (UINT32)SDL_wcslen(wClassName), &hClassName);
     if (FAILED(hr)) {
         goto done;
     }
@@ -797,7 +867,7 @@ WINRT_CreateDisplayRequest(_THIS)
         goto done;
     }
 
-    hr = pDisplayRequestRaw->QueryInterface(IID_IDisplayRequest, (void **) &pDisplayRequest);
+    hr = pDisplayRequestRaw->QueryInterface(SDL_IID_IDisplayRequest, (void **) &pDisplayRequest);
     if (FAILED(hr)) {
         goto done;
     }
diff --git a/Engine/lib/sdl/src/video/winrt/SDL_winrtvideo_cpp.h b/Engine/lib/sdl/src/video/winrt/SDL_winrtvideo_cpp.h
index c167b88a0..8e6d63bdc 100644
--- a/Engine/lib/sdl/src/video/winrt/SDL_winrtvideo_cpp.h
+++ b/Engine/lib/sdl/src/video/winrt/SDL_winrtvideo_cpp.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11clipboard.c b/Engine/lib/sdl/src/video/x11/SDL_x11clipboard.c
index d1469c020..37a17f407 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11clipboard.c
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11clipboard.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -27,14 +27,7 @@
 #include "SDL_events.h"
 #include "SDL_x11video.h"
 #include "SDL_timer.h"
-
-
-/* If you don't support UTF-8, you might use XA_STRING here */
-#ifdef X_HAVE_UTF8_STRING
-#define TEXT_FORMAT X11_XInternAtom(display, "UTF8_STRING", False)
-#else
-#define TEXT_FORMAT XA_STRING
-#endif
+#include "SDL_x11clipboard.h"
 
 /* Get any application owned window handle for clipboard association */
 static Window
@@ -59,19 +52,77 @@ GetWindow(_THIS)
     return data->clipboard_window;
 }
 
+
 /* We use our own cut-buffer for intermediate storage instead of  
    XA_CUT_BUFFER0 because their use isn't really defined for holding UTF8. */ 
 Atom
-X11_GetSDLCutBufferClipboardType(Display *display)
+X11_GetSDLCutBufferClipboardType(Display *display, enum ESDLX11ClipboardMimeType mime_type)
 {
-    return X11_XInternAtom(display, "SDL_CUTBUFFER", False);
+    switch (mime_type) {
+        case SDL_X11_CLIPBOARD_MIME_TYPE_STRING:
+        case SDL_X11_CLIPBOARD_MIME_TYPE_TEXT_PLAIN:
+        #ifdef X_HAVE_UTF8_STRING
+        case SDL_X11_CLIPBOARD_MIME_TYPE_TEXT_PLAIN_UTF8:
+        #endif
+        case SDL_X11_CLIPBOARD_MIME_TYPE_TEXT:
+            return X11_XInternAtom(display, "SDL_CUTBUFFER", False);
+        default:
+            SDL_SetError("Can't find mime_type.");
+            return XA_STRING;
+    }
 }
 
+Atom
+X11_GetSDLCutBufferClipboardExternalFormat(Display *display, enum ESDLX11ClipboardMimeType mime_type)
+{
+    switch (mime_type) {
+        case SDL_X11_CLIPBOARD_MIME_TYPE_STRING:
+            /* If you don't support UTF-8, you might use XA_STRING here */
+            #ifdef X_HAVE_UTF8_STRING
+            return X11_XInternAtom(display, "UTF8_STRING", False);
+            #else
+            return  XA_STRING;
+            #endif
+        case SDL_X11_CLIPBOARD_MIME_TYPE_TEXT_PLAIN:
+            return X11_XInternAtom(display, "text/plain", False);
+        #ifdef X_HAVE_UTF8_STRING
+        case SDL_X11_CLIPBOARD_MIME_TYPE_TEXT_PLAIN_UTF8:
+            return X11_XInternAtom(display, "text/plain;charset=utf-8", False);
+        #endif
+        case SDL_X11_CLIPBOARD_MIME_TYPE_TEXT:
+            return X11_XInternAtom(display, "TEXT", False);
+        default:
+            SDL_SetError("Can't find mime_type.");
+            return XA_STRING;
+    }
+}
+Atom
+X11_GetSDLCutBufferClipboardInternalFormat(Display *display, enum ESDLX11ClipboardMimeType mime_type)
+{
+    switch (mime_type) {
+        case SDL_X11_CLIPBOARD_MIME_TYPE_STRING:
+        case SDL_X11_CLIPBOARD_MIME_TYPE_TEXT_PLAIN:
+        #ifdef X_HAVE_UTF8_STRING
+        case SDL_X11_CLIPBOARD_MIME_TYPE_TEXT_PLAIN_UTF8:
+        #endif
+        case SDL_X11_CLIPBOARD_MIME_TYPE_TEXT:
+            /* If you don't support UTF-8, you might use XA_STRING here */
+            #ifdef X_HAVE_UTF8_STRING
+            return X11_XInternAtom(display, "UTF8_STRING", False);
+            #else
+            return  XA_STRING;
+            #endif
+        default:
+            SDL_SetError("Can't find mime_type.");
+            return XA_STRING;
+    }
+}
+
+
 int
 X11_SetClipboardText(_THIS, const char *text)
 {
     Display *display = ((SDL_VideoData *) _this->driverdata)->display;
-    Atom format;
     Window window;
     Atom XA_CLIPBOARD = X11_XInternAtom(display, "CLIPBOARD", 0);
 
@@ -82,9 +133,8 @@ X11_SetClipboardText(_THIS, const char *text)
     }
 
     /* Save the selection on the root window */
-    format = TEXT_FORMAT;
     X11_XChangeProperty(display, DefaultRootWindow(display),
-        X11_GetSDLCutBufferClipboardType(display), format, 8, PropModeReplace,
+        X11_GetSDLCutBufferClipboardType(display, SDL_X11_CLIPBOARD_MIME_TYPE_STRING), X11_GetSDLCutBufferClipboardInternalFormat(display, SDL_X11_CLIPBOARD_MIME_TYPE_STRING), 8, PropModeReplace,
         (const unsigned char *)text, SDL_strlen(text));
 
     if (XA_CLIPBOARD != None &&
@@ -125,7 +175,7 @@ X11_GetClipboardText(_THIS)
 
     /* Get the window that holds the selection */
     window = GetWindow(_this);
-    format = TEXT_FORMAT;
+    format = X11_GetSDLCutBufferClipboardInternalFormat(display, SDL_X11_CLIPBOARD_MIME_TYPE_STRING);
     owner = X11_XGetSelectionOwner(display, XA_CLIPBOARD);
     if (owner == None) {
         /* Fall back to ancient X10 cut-buffers which do not support UTF8 strings*/
@@ -134,7 +184,7 @@ X11_GetClipboardText(_THIS)
         format = XA_STRING;
     } else if (owner == window) {
         owner = DefaultRootWindow(display);
-        selection = X11_GetSDLCutBufferClipboardType(display);
+        selection = X11_GetSDLCutBufferClipboardType(display, SDL_X11_CLIPBOARD_MIME_TYPE_STRING);
     } else {
         /* Request that the selection owner copy the data to our window */
         owner = window;
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11clipboard.h b/Engine/lib/sdl/src/video/x11/SDL_x11clipboard.h
index 87fb827da..ec98445c4 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11clipboard.h
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11clipboard.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -23,10 +23,22 @@
 #ifndef SDL_x11clipboard_h_
 #define SDL_x11clipboard_h_
 
+enum ESDLX11ClipboardMimeType {
+    SDL_X11_CLIPBOARD_MIME_TYPE_STRING,
+    SDL_X11_CLIPBOARD_MIME_TYPE_TEXT_PLAIN,
+    #ifdef X_HAVE_UTF8_STRING
+    SDL_X11_CLIPBOARD_MIME_TYPE_TEXT_PLAIN_UTF8,
+    #endif
+    SDL_X11_CLIPBOARD_MIME_TYPE_TEXT,
+    SDL_X11_CLIPBOARD_MIME_TYPE_MAX
+};
+
 extern int X11_SetClipboardText(_THIS, const char *text);
 extern char *X11_GetClipboardText(_THIS);
 extern SDL_bool X11_HasClipboardText(_THIS);
-extern Atom X11_GetSDLCutBufferClipboardType(Display *display);
+extern Atom X11_GetSDLCutBufferClipboardType(Display *display, enum ESDLX11ClipboardMimeType mime_type);
+extern Atom X11_GetSDLCutBufferClipboardExternalFormat(Display *display, enum ESDLX11ClipboardMimeType mime_type);
+extern Atom X11_GetSDLCutBufferClipboardInternalFormat(Display *display, enum ESDLX11ClipboardMimeType mime_type);
 
 #endif /* SDL_x11clipboard_h_ */
 
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11dyn.c b/Engine/lib/sdl/src/video/x11/SDL_x11dyn.c
index 777f4bf30..29a8186fa 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11dyn.c
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11dyn.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -53,6 +53,9 @@ typedef struct
 #ifndef SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT2
 #define SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT2 NULL
 #endif
+#ifndef SDL_VIDEO_DRIVER_X11_DYNAMIC_XFIXES
+#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XFIXES NULL
+#endif
 #ifndef SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR
 #define SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR NULL
 #endif
@@ -69,6 +72,7 @@ static x11dynlib x11libs[] = {
     {NULL, SDL_VIDEO_DRIVER_X11_DYNAMIC_XCURSOR},
     {NULL, SDL_VIDEO_DRIVER_X11_DYNAMIC_XINERAMA},
     {NULL, SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT2},
+    {NULL, SDL_VIDEO_DRIVER_X11_DYNAMIC_XFIXES},
     {NULL, SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR},
     {NULL, SDL_VIDEO_DRIVER_X11_DYNAMIC_XSS},
     {NULL, SDL_VIDEO_DRIVER_X11_DYNAMIC_XVIDMODE}
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11dyn.h b/Engine/lib/sdl/src/video/x11/SDL_x11dyn.h
index ecdf76408..c2678bfed 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11dyn.h
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11dyn.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -39,7 +39,6 @@
 
 #include <X11/Xproto.h>
 #include <X11/extensions/Xext.h>
-#include <X11/extensions/extutil.h>
 
 #ifndef NO_SHARED_MEMORY
 #include <sys/ipc.h>
@@ -59,6 +58,9 @@
 #if SDL_VIDEO_DRIVER_X11_XINPUT2
 #include <X11/extensions/XInput2.h>
 #endif
+#if SDL_VIDEO_DRIVER_X11_XFIXES
+#include <X11/extensions/Xfixes.h>
+#endif
 #if SDL_VIDEO_DRIVER_X11_XRANDR
 #include <X11/extensions/Xrandr.h>
 #endif
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11events.c b/Engine/lib/sdl/src/video/x11/SDL_x11events.c
index ea7292740..c1260215d 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11events.c
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11events.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -31,6 +31,7 @@
 #include "SDL_x11video.h"
 #include "SDL_x11touch.h"
 #include "SDL_x11xinput2.h"
+#include "SDL_x11xfixes.h"
 #include "../../core/unix/SDL_poll.h"
 #include "../../events/SDL_events_c.h"
 #include "../../events/SDL_mouse_c.h"
@@ -269,19 +270,19 @@ static char* X11_URIToLocal(char* uri) {
     char *file = NULL;
     SDL_bool local;
 
-    if (memcmp(uri,"file:/",6) == 0) uri += 6;      /* local file? */
-    else if (strstr(uri,":/") != NULL) return file; /* wrong scheme */
+    if (SDL_memcmp(uri,"file:/",6) == 0) uri += 6;      /* local file? */
+    else if (SDL_strstr(uri,":/") != NULL) return file; /* wrong scheme */
 
     local = uri[0] != '/' || (uri[0] != '\0' && uri[1] == '/');
 
     /* got a hostname? */
     if (!local && uri[0] == '/' && uri[2] != '/') {
-      char* hostname_end = strchr(uri+1, '/');
+      char* hostname_end = SDL_strchr(uri+1, '/');
       if (hostname_end != NULL) {
           char hostname[ 257 ];
           if (gethostname(hostname, 255) == 0) {
             hostname[ 256 ] = '\0';
-            if (memcmp(uri+1, hostname, hostname_end - (uri+1)) == 0) {
+            if (SDL_memcmp(uri+1, hostname, hostname_end - (uri+1)) == 0) {
                 uri = hostname_end + 1;
                 local = SDL_TRUE;
             }
@@ -353,6 +354,32 @@ X11_GetNumLockModifierMask(_THIS)
     return num_mask;
 }
 
+static unsigned
+X11_GetScrollLockModifierMask(_THIS)
+{
+    SDL_VideoData *viddata = (SDL_VideoData *) _this->driverdata;
+    Display *display = viddata->display;
+    unsigned num_mask = 0;
+    int i, j;
+    XModifierKeymap *xmods;
+    unsigned n;
+
+    xmods = X11_XGetModifierMapping(display);
+    n = xmods->max_keypermod;
+    for(i = 3; i < 8; i++) {
+        for(j = 0; j < n; j++) {
+            KeyCode kc = xmods->modifiermap[i * n + j];
+            if (viddata->key_layout[kc] == SDL_SCANCODE_SCROLLLOCK) {
+                num_mask = 1 << i;
+                break;
+            }
+        }
+    }
+    X11_XFreeModifiermap(xmods);
+
+    return num_mask;
+}
+
 static void
 X11_ReconcileKeyboardState(_THIS)
 {
@@ -371,6 +398,7 @@ X11_ReconcileKeyboardState(_THIS)
     if (X11_XQueryPointer(display, DefaultRootWindow(display), &junk_window, &junk_window, &x, &y, &x, &y, &mask)) {
         SDL_ToggleModState(KMOD_CAPS, (mask & LockMask) != 0);
         SDL_ToggleModState(KMOD_NUM, (mask & X11_GetNumLockModifierMask(_this)) != 0);
+        SDL_ToggleModState(KMOD_SCROLL, (mask & X11_GetScrollLockModifierMask(_this)) != 0);
     }
 
     keyboardState = SDL_GetKeyboardState(0);
@@ -404,6 +432,9 @@ X11_DispatchFocusIn(_THIS, SDL_WindowData *data)
 #ifdef SDL_USE_IME
     SDL_IME_SetFocus(SDL_TRUE);
 #endif
+    if (data->flashing_window) {
+        X11_FlashWindow(_this, data->window, SDL_FLASH_CANCEL);
+    }
 }
 
 static void
@@ -559,6 +590,7 @@ X11_UpdateUserTime(SDL_WindowData *data, const unsigned long latest)
 static void
 X11_HandleClipboardEvent(_THIS, const XEvent *xevent)
 {
+    int i;
     SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;
     Display *display = videodata->display;
 
@@ -570,10 +602,12 @@ X11_HandleClipboardEvent(_THIS, const XEvent *xevent)
         case SelectionRequest: {
             const XSelectionRequestEvent *req = &xevent->xselectionrequest;
             XEvent sevent;
-            int seln_format;
+            int seln_format, mime_formats;
             unsigned long nbytes;
             unsigned long overflow;
-            unsigned char *seln_data;
+            unsigned char *seln_data;            
+            Atom supportedFormats[SDL_X11_CLIPBOARD_MIME_TYPE_MAX+1];
+            Atom XA_TARGETS = X11_XInternAtom(display, "TARGETS", 0);
 
 #ifdef DEBUG_XEVENTS
             printf("window CLIPBOARD: SelectionRequest (requestor = %ld, target = %ld)\n",
@@ -591,27 +625,38 @@ X11_HandleClipboardEvent(_THIS, const XEvent *xevent)
             /* !!! FIXME: We were probably storing this on the root window
                because an SDL window might go away...? but we don't have to do
                this now (or ever, really). */
-            if (X11_XGetWindowProperty(display, DefaultRootWindow(display),
-                    X11_GetSDLCutBufferClipboardType(display), 0, INT_MAX/4, False, req->target,
-                    &sevent.xselection.target, &seln_format, &nbytes,
-                    &overflow, &seln_data) == Success) {
-                /* !!! FIXME: cache atoms */
-                Atom XA_TARGETS = X11_XInternAtom(display, "TARGETS", 0);
-                if (sevent.xselection.target == req->target) {
-                    X11_XChangeProperty(display, req->requestor, req->property,
-                        sevent.xselection.target, seln_format, PropModeReplace,
-                        seln_data, nbytes);
-                    sevent.xselection.property = req->property;
-                } else if (XA_TARGETS == req->target) {
-                    Atom SupportedFormats[] = { XA_TARGETS, sevent.xselection.target };
-                    X11_XChangeProperty(display, req->requestor, req->property,
-                        XA_ATOM, 32, PropModeReplace,
-                        (unsigned char*)SupportedFormats,
-                        SDL_arraysize(SupportedFormats));
-                    sevent.xselection.property = req->property;
-                    sevent.xselection.target = XA_TARGETS;
+            
+            if (req->target == XA_TARGETS) {
+                supportedFormats[0] = XA_TARGETS;
+                mime_formats = 1;
+                for (i = 0; i < SDL_X11_CLIPBOARD_MIME_TYPE_MAX; ++i) 
+                    supportedFormats[mime_formats++] = X11_GetSDLCutBufferClipboardExternalFormat(display, i);
+                X11_XChangeProperty(display, req->requestor, req->property,
+                    XA_ATOM, 32, PropModeReplace,
+                    (unsigned char*)supportedFormats,
+                    mime_formats);
+                sevent.xselection.property = req->property;
+                sevent.xselection.target = XA_TARGETS;
+            } else {
+                for (i = 0; i < SDL_X11_CLIPBOARD_MIME_TYPE_MAX; ++i) {
+                    if (X11_GetSDLCutBufferClipboardExternalFormat(display, i) != req->target)
+                        continue;
+                    if (X11_XGetWindowProperty(display, DefaultRootWindow(display),
+                        X11_GetSDLCutBufferClipboardType(display, i), 0, INT_MAX/4, False, X11_GetSDLCutBufferClipboardInternalFormat(display, i),
+                        &sevent.xselection.target, &seln_format, &nbytes,
+                        &overflow, &seln_data) == Success) {
+                            if (seln_format != None) {
+                                X11_XChangeProperty(display, req->requestor, req->property,
+                                    sevent.xselection.target, seln_format, PropModeReplace,
+                                    seln_data, nbytes);
+                                sevent.xselection.property = req->property;
+                                X11_XFree(seln_data);
+                                break;
+                            } else {
+                                X11_XFree(seln_data);
+                            }
+                    }
                 }
-                X11_XFree(seln_data);
             }
             X11_XSendEvent(display, req->requestor, False, 0, &sevent);
             X11_XSync(display, False);
@@ -670,40 +715,35 @@ isReparentNotify(Display *display, XEvent *ev, XPointer arg)
 }
 
 static void
-X11_DispatchEvent(_THIS)
+X11_DispatchEvent(_THIS, XEvent *xevent)
 {
     SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;
+    XkbEvent* xkbEvent = (XkbEvent*) xevent;
     Display *display;
     SDL_WindowData *data;
-    XEvent xevent;
     int orig_event_type;
     KeyCode orig_keycode;
     XClientMessageEvent m;
     int i;
 
-    if (!videodata) {
-        return;
-    }
+    SDL_assert(videodata != NULL);
     display = videodata->display;
 
-    SDL_zero(xevent);           /* valgrind fix. --ryan. */
-    X11_XNextEvent(display, &xevent);
-
     /* Save the original keycode for dead keys, which are filtered out by
        the XFilterEvent() call below.
     */
-    orig_event_type = xevent.type;
+    orig_event_type = xevent->type;
     if (orig_event_type == KeyPress || orig_event_type == KeyRelease) {
-        orig_keycode = xevent.xkey.keycode;
+        orig_keycode = xevent->xkey.keycode;
     } else {
         orig_keycode = 0;
     }
 
     /* filter events catchs XIM events and sends them to the correct handler */
-    if (X11_XFilterEvent(&xevent, None) == True) {
+    if (X11_XFilterEvent(xevent, None) == True) {
 #if 0
         printf("Filtered event type = %d display = %d window = %d\n",
-               xevent.type, xevent.xany.display, xevent.xany.window);
+               xevent->type, xevent->xany.display, xevent->xany.window);
 #endif
         /* Make sure dead key press/release events are sent */
         /* But only if we're using one of the DBus IMEs, otherwise
@@ -712,7 +752,7 @@ X11_DispatchEvent(_THIS)
 #if defined(HAVE_IBUS_IBUS_H) || defined(HAVE_FCITX)
             SDL_Scancode scancode = videodata->key_layout[orig_keycode];
             videodata->filter_code = orig_keycode;
-            videodata->filter_time = xevent.xkey.time;
+            videodata->filter_time = xevent->xkey.time;
 
             if (orig_event_type == KeyPress) {
                 SDL_SendKeyboardKey(SDL_PRESSED, scancode);
@@ -725,8 +765,8 @@ X11_DispatchEvent(_THIS)
     }
 
 #if SDL_VIDEO_DRIVER_X11_SUPPORTS_GENERIC_EVENTS
-    if(xevent.type == GenericEvent) {
-        X11_HandleGenericEvent(videodata, &xevent);
+    if(xevent->type == GenericEvent) {
+        X11_HandleGenericEvent(videodata, xevent);
         return;
     }
 #endif
@@ -737,18 +777,18 @@ X11_DispatchEvent(_THIS)
 
         SDL_VERSION(&wmmsg.version);
         wmmsg.subsystem = SDL_SYSWM_X11;
-        wmmsg.msg.x11.event = xevent;
+        wmmsg.msg.x11.event = *xevent;
         SDL_SendSysWMEvent(&wmmsg);
     }
 
 #if 0
     printf("type = %d display = %d window = %d\n",
-           xevent.type, xevent.xany.display, xevent.xany.window);
+           xevent->type, xevent->xany.display, xevent->xany.window);
 #endif
 
     if ((videodata->clipboard_window != None) &&
-        (videodata->clipboard_window == xevent.xany.window)) {
-        X11_HandleClipboardEvent(_this, &xevent);
+        (videodata->clipboard_window == xevent->xany.window)) {
+        X11_HandleClipboardEvent(_this, xevent);
         return;
     }
 
@@ -756,7 +796,7 @@ X11_DispatchEvent(_THIS)
     if (videodata && videodata->windowlist) {
         for (i = 0; i < videodata->numwindows; ++i) {
             if ((videodata->windowlist[i] != NULL) &&
-                (videodata->windowlist[i]->xwindow == xevent.xany.window)) {
+                (videodata->windowlist[i]->xwindow == xevent->xany.window)) {
                 data = videodata->windowlist[i];
                 break;
             }
@@ -764,71 +804,117 @@ X11_DispatchEvent(_THIS)
     }
     if (!data) {
         /* The window for KeymapNotify, etc events is 0 */
-        if (xevent.type == KeymapNotify) {
+        if (xevent->type == KeymapNotify) {
             if (SDL_GetKeyboardFocus() != NULL) {
                 X11_ReconcileKeyboardState(_this);
             }
-        } else if (xevent.type == MappingNotify) {
+        } else if (xevent->type == MappingNotify ||
+                   (xevent->type == videodata->xkb_event && xkbEvent->any.xkb_type == XkbStateNotify)) {
             /* Has the keyboard layout changed? */
-            const int request = xevent.xmapping.request;
+            const int request = xevent->xmapping.request;
 
 #ifdef DEBUG_XEVENTS
             printf("window %p: MappingNotify!\n", data);
 #endif
             if ((request == MappingKeyboard) || (request == MappingModifier)) {
-                X11_XRefreshKeyboardMapping(&xevent.xmapping);
+                X11_XRefreshKeyboardMapping(&xevent->xmapping);
             }
 
             X11_UpdateKeymap(_this);
             SDL_SendKeymapChangedEvent();
+        } else if (xevent->type == PropertyNotify && videodata && videodata->windowlist) {
+            char* name_of_atom = X11_XGetAtomName(display, xevent->xproperty.atom);
+
+            if (SDL_strncmp(name_of_atom, "_ICC_PROFILE", sizeof("_ICC_PROFILE") - 1) == 0) {
+                XWindowAttributes attrib;
+                int screennum;
+                for (i = 0; i < videodata->numwindows; ++i) {
+                    if (videodata->windowlist[i] != NULL) {
+                        data = videodata->windowlist[i];
+                        X11_XGetWindowAttributes(display, data->xwindow, &attrib);
+                        screennum = X11_XScreenNumberOfScreen(attrib.screen);
+                        if (screennum == 0 && SDL_strcmp(name_of_atom, "_ICC_PROFILE") == 0) {
+                            SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_ICCPROF_CHANGED, 0, 0);
+                        } else if (SDL_strncmp(name_of_atom, "_ICC_PROFILE_", sizeof("_ICC_PROFILE_") - 1) == 0 && SDL_strlen(name_of_atom) > sizeof("_ICC_PROFILE_") - 1) {
+                            int iccscreennum = SDL_atoi(&name_of_atom[sizeof("_ICC_PROFILE_") - 1]);
+
+                            if (screennum == iccscreennum) {
+                                SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_ICCPROF_CHANGED, 0, 0);
+                            }
+                        }
+                    }
+                }
+            }
+
+            if (name_of_atom) X11_XFree(name_of_atom);
         }
         return;
     }
 
-    switch (xevent.type) {
+    switch (xevent->type) {
 
         /* Gaining mouse coverage? */
     case EnterNotify:{
             SDL_Mouse *mouse = SDL_GetMouse();
 #ifdef DEBUG_XEVENTS
             printf("window %p: EnterNotify! (%d,%d,%d)\n", data,
-                   xevent.xcrossing.x,
-                   xevent.xcrossing.y,
-                   xevent.xcrossing.mode);
-            if (xevent.xcrossing.mode == NotifyGrab)
+                   xevent->xcrossing.x,
+                   xevent->xcrossing.y,
+                   xevent->xcrossing.mode);
+            if (xevent->xcrossing.mode == NotifyGrab)
                 printf("Mode: NotifyGrab\n");
-            if (xevent.xcrossing.mode == NotifyUngrab)
+            if (xevent->xcrossing.mode == NotifyUngrab)
                 printf("Mode: NotifyUngrab\n");
 #endif
             SDL_SetMouseFocus(data->window);
 
-            mouse->last_x = xevent.xcrossing.x;
-            mouse->last_y = xevent.xcrossing.y;
+            mouse->last_x = xevent->xcrossing.x;
+            mouse->last_y = xevent->xcrossing.y;
+
+#if SDL_VIDEO_DRIVER_X11_XFIXES
+            {
+                /* Only create the barriers if we have input focus */
+                SDL_WindowData* windowdata = (SDL_WindowData *) data->window->driverdata;
+                if ((data->pointer_barrier_active == SDL_TRUE) && windowdata->window->flags & SDL_WINDOW_INPUT_FOCUS) {
+                    X11_ConfineCursorWithFlags(_this, windowdata->window, &windowdata->barrier_rect, X11_BARRIER_HANDLED_BY_EVENT);
+                }
+            }
+#endif
 
             if (!mouse->relative_mode) {
-                SDL_SendMouseMotion(data->window, 0, 0, xevent.xcrossing.x, xevent.xcrossing.y);
+                SDL_SendMouseMotion(data->window, 0, 0, xevent->xcrossing.x, xevent->xcrossing.y);
             }
+
+            /* We ungrab in LeaveNotify, so we may need to grab again here */
+            SDL_UpdateWindowGrab(data->window);
         }
         break;
         /* Losing mouse coverage? */
     case LeaveNotify:{
 #ifdef DEBUG_XEVENTS
             printf("window %p: LeaveNotify! (%d,%d,%d)\n", data,
-                   xevent.xcrossing.x,
-                   xevent.xcrossing.y,
-                   xevent.xcrossing.mode);
-            if (xevent.xcrossing.mode == NotifyGrab)
+                   xevent->xcrossing.x,
+                   xevent->xcrossing.y,
+                   xevent->xcrossing.mode);
+            if (xevent->xcrossing.mode == NotifyGrab)
                 printf("Mode: NotifyGrab\n");
-            if (xevent.xcrossing.mode == NotifyUngrab)
+            if (xevent->xcrossing.mode == NotifyUngrab)
                 printf("Mode: NotifyUngrab\n");
 #endif
             if (!SDL_GetMouse()->relative_mode) {
-                SDL_SendMouseMotion(data->window, 0, 0, xevent.xcrossing.x, xevent.xcrossing.y);
+                SDL_SendMouseMotion(data->window, 0, 0, xevent->xcrossing.x, xevent->xcrossing.y);
             }
 
-            if (xevent.xcrossing.mode != NotifyGrab &&
-                xevent.xcrossing.mode != NotifyUngrab &&
-                xevent.xcrossing.detail != NotifyInferior) {
+            if (xevent->xcrossing.mode != NotifyGrab &&
+                xevent->xcrossing.mode != NotifyUngrab &&
+                xevent->xcrossing.detail != NotifyInferior) {
+                
+                /* In order for interaction with the window decorations and menu to work properly
+                   on Mutter, we need to ungrab the keyboard when the the mouse leaves. */
+                if (!(data->window->flags & SDL_WINDOW_FULLSCREEN)) {
+                    X11_SetWindowKeyboardGrab(_this, data->window, SDL_FALSE);
+                }
+
                 SDL_SetMouseFocus(NULL);
             }
         }
@@ -836,7 +922,7 @@ X11_DispatchEvent(_THIS)
 
         /* Gaining input focus? */
     case FocusIn:{
-            if (xevent.xfocus.mode == NotifyGrab || xevent.xfocus.mode == NotifyUngrab) {
+            if (xevent->xfocus.mode == NotifyGrab || xevent->xfocus.mode == NotifyUngrab) {
                 /* Someone is handling a global hotkey, ignore it */
 #ifdef DEBUG_XEVENTS
                 printf("window %p: FocusIn (NotifyGrab/NotifyUngrab, ignoring)\n", data);
@@ -844,7 +930,7 @@ X11_DispatchEvent(_THIS)
                 break;
             }
 
-            if (xevent.xfocus.detail == NotifyInferior || xevent.xfocus.detail == NotifyPointer) {
+            if (xevent->xfocus.detail == NotifyInferior || xevent->xfocus.detail == NotifyPointer) {
 #ifdef DEBUG_XEVENTS
                 printf("window %p: FocusIn (NotifyInferior/NotifyPointer, ignoring)\n", data);
 #endif
@@ -870,14 +956,14 @@ X11_DispatchEvent(_THIS)
 
         /* Losing input focus? */
     case FocusOut:{
-            if (xevent.xfocus.mode == NotifyGrab || xevent.xfocus.mode == NotifyUngrab) {
+            if (xevent->xfocus.mode == NotifyGrab || xevent->xfocus.mode == NotifyUngrab) {
                 /* Someone is handling a global hotkey, ignore it */
 #ifdef DEBUG_XEVENTS
                 printf("window %p: FocusOut (NotifyGrab/NotifyUngrab, ignoring)\n", data);
 #endif
                 break;
             }
-            if (xevent.xfocus.detail == NotifyInferior || xevent.xfocus.detail == NotifyPointer) {
+            if (xevent->xfocus.detail == NotifyInferior || xevent->xfocus.detail == NotifyPointer) {
                 /* We still have focus if a child gets focus. We also don't
                    care about the position of the pointer when the keyboard
                    focus changed. */
@@ -900,25 +986,32 @@ X11_DispatchEvent(_THIS)
                 data->pending_focus = PENDING_FOCUS_OUT;
                 data->pending_focus_time = SDL_GetTicks() + PENDING_FOCUS_TIME;
             }
+
+#if SDL_VIDEO_DRIVER_X11_XFIXES
+            /* Disable confinement if it is activated. */
+            if (data->pointer_barrier_active == SDL_TRUE) {
+                X11_ConfineCursorWithFlags(_this, data->window, NULL, X11_BARRIER_HANDLED_BY_EVENT);
+            }
+#endif /* SDL_VIDEO_DRIVER_X11_XFIXES */
         }
         break;
 
         /* Key press? */
     case KeyPress:{
-            KeyCode keycode = xevent.xkey.keycode;
+            KeyCode keycode = xevent->xkey.keycode;
             KeySym keysym = NoSymbol;
             char text[SDL_TEXTINPUTEVENT_TEXT_SIZE];
             Status status = 0;
             SDL_bool handled_by_ime = SDL_FALSE;
 
 #ifdef DEBUG_XEVENTS
-            printf("window %p: KeyPress (X11 keycode = 0x%X)\n", data, xevent.xkey.keycode);
+            printf("window %p: KeyPress (X11 keycode = 0x%X)\n", data, xevent->xkey.keycode);
 #endif
 #if 1
             if (videodata->key_layout[keycode] == SDL_SCANCODE_UNKNOWN && keycode) {
                 int min_keycode, max_keycode;
                 X11_XDisplayKeycodes(display, &min_keycode, &max_keycode);
-                keysym = X11_KeyCodeToSym(_this, keycode, xevent.xkey.state >> 13);
+                keysym = X11_KeyCodeToSym(_this, keycode, xevent->xkey.state >> 13);
                 fprintf(stderr,
                         "The key you just pressed is not recognized by SDL. To help get this fixed, please report this to the SDL forums/mailing list <https://discourse.libsdl.org/> X11 KeyCode %d (%d), X11 KeySym 0x%lX (%s).\n",
                         keycode, keycode - min_keycode, keysym,
@@ -929,13 +1022,13 @@ X11_DispatchEvent(_THIS)
             SDL_zeroa(text);
 #ifdef X_HAVE_UTF8_STRING
             if (data->ic) {
-                X11_Xutf8LookupString(data->ic, &xevent.xkey, text, sizeof(text),
+                X11_Xutf8LookupString(data->ic, &xevent->xkey, text, sizeof(text),
                                   &keysym, &status);
             } else {
-                X11_XLookupString(&xevent.xkey, text, sizeof(text), &keysym, NULL);
+                X11_XLookupString(&xevent->xkey, text, sizeof(text), &keysym, NULL);
             }
 #else
-            X11_XLookupString(&xevent.xkey, text, sizeof(text), &keysym, NULL);
+            X11_XLookupString(&xevent->xkey, text, sizeof(text), &keysym, NULL);
 #endif
 
 #ifdef SDL_USE_IME
@@ -945,7 +1038,7 @@ X11_DispatchEvent(_THIS)
 #endif
             if (!handled_by_ime) {
                 /* Don't send the key if it looks like a duplicate of a filtered key sent by an IME */
-                if (xevent.xkey.keycode != videodata->filter_code || xevent.xkey.time != videodata->filter_time) {
+                if (xevent->xkey.keycode != videodata->filter_code || xevent->xkey.time != videodata->filter_time) {
                     SDL_SendKeyboardKey(SDL_PRESSED, videodata->key_layout[keycode]);
                 }
                 if(*text) {
@@ -953,18 +1046,18 @@ X11_DispatchEvent(_THIS)
                 }
             }
 
-            X11_UpdateUserTime(data, xevent.xkey.time);
+            X11_UpdateUserTime(data, xevent->xkey.time);
         }
         break;
 
         /* Key release? */
     case KeyRelease:{
-            KeyCode keycode = xevent.xkey.keycode;
+            KeyCode keycode = xevent->xkey.keycode;
 
 #ifdef DEBUG_XEVENTS
-            printf("window %p: KeyRelease (X11 keycode = 0x%X)\n", data, xevent.xkey.keycode);
+            printf("window %p: KeyRelease (X11 keycode = 0x%X)\n", data, xevent->xkey.keycode);
 #endif
-            if (X11_KeyRepeat(display, &xevent)) {
+            if (X11_KeyRepeat(display, xevent)) {
                 /* We're about to get a repeated key down, ignore the key up */
                 break;
             }
@@ -980,11 +1073,18 @@ X11_DispatchEvent(_THIS)
             printf("window %p: UnmapNotify!\n", data);
 #endif
 
-            if (X11_XCheckIfEvent(display, &ev, &isReparentNotify, (XPointer)&xevent.xunmap)) {
-                X11_XCheckIfEvent(display, &ev, &isMapNotify, (XPointer)&xevent.xunmap);
+            if (X11_XCheckIfEvent(display, &ev, &isReparentNotify, (XPointer)&xevent->xunmap)) {
+                X11_XCheckIfEvent(display, &ev, &isMapNotify, (XPointer)&xevent->xunmap);
             } else {
                 X11_DispatchUnmapNotify(data);
             }
+
+#if SDL_VIDEO_DRIVER_X11_XFIXES
+            /* Disable confinement if the window gets hidden. */
+            if (data->pointer_barrier_active == SDL_TRUE) {
+                X11_ConfineCursorWithFlags(_this, data->window, NULL, X11_BARRIER_HANDLED_BY_EVENT);
+            }
+#endif /* SDL_VIDEO_DRIVER_X11_XFIXES */
         }
         break;
 
@@ -994,6 +1094,13 @@ X11_DispatchEvent(_THIS)
             printf("window %p: MapNotify!\n", data);
 #endif
             X11_DispatchMapNotify(data);
+
+#if SDL_VIDEO_DRIVER_X11_XFIXES
+            /* Enable confinement if it was activated. */
+            if (data->pointer_barrier_active == SDL_TRUE) {
+                X11_ConfineCursorWithFlags(_this, data->window, &data->barrier_rect, X11_BARRIER_HANDLED_BY_EVENT);
+            }
+#endif /* SDL_VIDEO_DRIVER_X11_XFIXES */
         }
         break;
 
@@ -1001,27 +1108,27 @@ X11_DispatchEvent(_THIS)
     case ConfigureNotify:{
 #ifdef DEBUG_XEVENTS
             printf("window %p: ConfigureNotify! (position: %d,%d, size: %dx%d)\n", data,
-                   xevent.xconfigure.x, xevent.xconfigure.y,
-                   xevent.xconfigure.width, xevent.xconfigure.height);
+                   xevent->xconfigure.x, xevent->xconfigure.y,
+                   xevent->xconfigure.width, xevent->xconfigure.height);
 #endif
             /* Real configure notify events are relative to the parent, synthetic events are absolute. */
-            if (!xevent.xconfigure.send_event) {
+            if (!xevent->xconfigure.send_event) {
                 unsigned int NumChildren;
                 Window ChildReturn, Root, Parent;
                 Window * Children;
                 /* Translate these coodinates back to relative to root */
-                X11_XQueryTree(data->videodata->display, xevent.xconfigure.window, &Root, &Parent, &Children, &NumChildren);
-                X11_XTranslateCoordinates(xevent.xconfigure.display,
-                                        Parent, DefaultRootWindow(xevent.xconfigure.display),
-                                        xevent.xconfigure.x, xevent.xconfigure.y,
-                                        &xevent.xconfigure.x, &xevent.xconfigure.y,
+                X11_XQueryTree(data->videodata->display, xevent->xconfigure.window, &Root, &Parent, &Children, &NumChildren);
+                X11_XTranslateCoordinates(xevent->xconfigure.display,
+                                        Parent, DefaultRootWindow(xevent->xconfigure.display),
+                                        xevent->xconfigure.x, xevent->xconfigure.y,
+                                        &xevent->xconfigure.x, &xevent->xconfigure.y,
                                         &ChildReturn);
             }
                 
-            if (xevent.xconfigure.x != data->last_xconfigure.x ||
-                xevent.xconfigure.y != data->last_xconfigure.y) {
+            if (xevent->xconfigure.x != data->last_xconfigure.x ||
+                xevent->xconfigure.y != data->last_xconfigure.y) {
                 SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_MOVED,
-                                    xevent.xconfigure.x, xevent.xconfigure.y);
+                                    xevent->xconfigure.x, xevent->xconfigure.y);
 #ifdef SDL_USE_IME
                 if(SDL_GetEventState(SDL_TEXTINPUT) == SDL_ENABLE){
                     /* Update IME candidate list position */
@@ -1029,13 +1136,13 @@ X11_DispatchEvent(_THIS)
                 }
 #endif
             }
-            if (xevent.xconfigure.width != data->last_xconfigure.width ||
-                xevent.xconfigure.height != data->last_xconfigure.height) {
+            if (xevent->xconfigure.width != data->last_xconfigure.width ||
+                xevent->xconfigure.height != data->last_xconfigure.height) {
                 SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_RESIZED,
-                                    xevent.xconfigure.width,
-                                    xevent.xconfigure.height);
+                                    xevent->xconfigure.width,
+                                    xevent->xconfigure.height);
             }
-            data->last_xconfigure = xevent.xconfigure;
+            data->last_xconfigure = xevent->xconfigure;
         }
         break;
 
@@ -1044,11 +1151,11 @@ X11_DispatchEvent(_THIS)
 
             static int xdnd_version=0;
 
-            if (xevent.xclient.message_type == videodata->XdndEnter) {
+            if (xevent->xclient.message_type == videodata->XdndEnter) {
 
-                SDL_bool use_list = xevent.xclient.data.l[1] & 1;
-                data->xdnd_source = xevent.xclient.data.l[0];
-                xdnd_version = (xevent.xclient.data.l[1] >> 24);
+                SDL_bool use_list = xevent->xclient.data.l[1] & 1;
+                data->xdnd_source = xevent->xclient.data.l[0];
+                xdnd_version = (xevent->xclient.data.l[1] >> 24);
 #ifdef DEBUG_XEVENTS
                 printf("XID of source window : %ld\n", data->xdnd_source);
                 printf("Protocol version to use : %d\n", xdnd_version);
@@ -1064,25 +1171,25 @@ X11_DispatchEvent(_THIS)
                     X11_XFree(p.data);
                 } else {
                     /* pick from list of three */
-                    data->xdnd_req = X11_PickTargetFromAtoms(display, xevent.xclient.data.l[2], xevent.xclient.data.l[3], xevent.xclient.data.l[4]);
+                    data->xdnd_req = X11_PickTargetFromAtoms(display, xevent->xclient.data.l[2], xevent->xclient.data.l[3], xevent->xclient.data.l[4]);
                 }
             }
-            else if (xevent.xclient.message_type == videodata->XdndPosition) {
+            else if (xevent->xclient.message_type == videodata->XdndPosition) {
 
 #ifdef DEBUG_XEVENTS
                 Atom act= videodata->XdndActionCopy;
                 if(xdnd_version >= 2) {
-                    act = xevent.xclient.data.l[4];
+                    act = xevent->xclient.data.l[4];
                 }
                 printf("Action requested by user is : %s\n", X11_XGetAtomName(display , act));
 #endif
 
 
                 /* reply with status */
-                memset(&m, 0, sizeof(XClientMessageEvent));
+                SDL_memset(&m, 0, sizeof(XClientMessageEvent));
                 m.type = ClientMessage;
-                m.display = xevent.xclient.display;
-                m.window = xevent.xclient.data.l[0];
+                m.display = xevent->xclient.display;
+                m.window = xevent->xclient.data.l[0];
                 m.message_type = videodata->XdndStatus;
                 m.format=32;
                 m.data.l[0] = data->xwindow;
@@ -1091,47 +1198,47 @@ X11_DispatchEvent(_THIS)
                 m.data.l[3] = 0;
                 m.data.l[4] = videodata->XdndActionCopy; /* we only accept copying anyway */
 
-                X11_XSendEvent(display, xevent.xclient.data.l[0], False, NoEventMask, (XEvent*)&m);
+                X11_XSendEvent(display, xevent->xclient.data.l[0], False, NoEventMask, (XEvent*)&m);
                 X11_XFlush(display);
             }
-            else if(xevent.xclient.message_type == videodata->XdndDrop) {
+            else if(xevent->xclient.message_type == videodata->XdndDrop) {
                 if (data->xdnd_req == None) {
                     /* say again - not interested! */
-                    memset(&m, 0, sizeof(XClientMessageEvent));
+                    SDL_memset(&m, 0, sizeof(XClientMessageEvent));
                     m.type = ClientMessage;
-                    m.display = xevent.xclient.display;
-                    m.window = xevent.xclient.data.l[0];
+                    m.display = xevent->xclient.display;
+                    m.window = xevent->xclient.data.l[0];
                     m.message_type = videodata->XdndFinished;
                     m.format=32;
                     m.data.l[0] = data->xwindow;
                     m.data.l[1] = 0;
                     m.data.l[2] = None; /* fail! */
-                    X11_XSendEvent(display, xevent.xclient.data.l[0], False, NoEventMask, (XEvent*)&m);
+                    X11_XSendEvent(display, xevent->xclient.data.l[0], False, NoEventMask, (XEvent*)&m);
                 } else {
                     /* convert */
                     if(xdnd_version >= 1) {
-                        X11_XConvertSelection(display, videodata->XdndSelection, data->xdnd_req, videodata->PRIMARY, data->xwindow, xevent.xclient.data.l[2]);
+                        X11_XConvertSelection(display, videodata->XdndSelection, data->xdnd_req, videodata->PRIMARY, data->xwindow, xevent->xclient.data.l[2]);
                     } else {
                         X11_XConvertSelection(display, videodata->XdndSelection, data->xdnd_req, videodata->PRIMARY, data->xwindow, CurrentTime);
                     }
                 }
             }
-            else if ((xevent.xclient.message_type == videodata->WM_PROTOCOLS) &&
-                (xevent.xclient.format == 32) &&
-                (xevent.xclient.data.l[0] == videodata->_NET_WM_PING)) {
+            else if ((xevent->xclient.message_type == videodata->WM_PROTOCOLS) &&
+                (xevent->xclient.format == 32) &&
+                (xevent->xclient.data.l[0] == videodata->_NET_WM_PING)) {
                 Window root = DefaultRootWindow(display);
 
 #ifdef DEBUG_XEVENTS
                 printf("window %p: _NET_WM_PING\n", data);
 #endif
-                xevent.xclient.window = root;
-                X11_XSendEvent(display, root, False, SubstructureRedirectMask | SubstructureNotifyMask, &xevent);
+                xevent->xclient.window = root;
+                X11_XSendEvent(display, root, False, SubstructureRedirectMask | SubstructureNotifyMask, xevent);
                 break;
             }
 
-            else if ((xevent.xclient.message_type == videodata->WM_PROTOCOLS) &&
-                (xevent.xclient.format == 32) &&
-                (xevent.xclient.data.l[0] == videodata->WM_DELETE_WINDOW)) {
+            else if ((xevent->xclient.message_type == videodata->WM_PROTOCOLS) &&
+                (xevent->xclient.format == 32) &&
+                (xevent->xclient.data.l[0] == videodata->WM_DELETE_WINDOW)) {
 
 #ifdef DEBUG_XEVENTS
                 printf("window %p: WM_DELETE_WINDOW\n", data);
@@ -1139,9 +1246,9 @@ X11_DispatchEvent(_THIS)
                 SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_CLOSE, 0, 0);
                 break;
             }
-            else if ((xevent.xclient.message_type == videodata->WM_PROTOCOLS) &&
-                (xevent.xclient.format == 32) &&
-                (xevent.xclient.data.l[0] == videodata->WM_TAKE_FOCUS)) {
+            else if ((xevent->xclient.message_type == videodata->WM_PROTOCOLS) &&
+                (xevent->xclient.format == 32) &&
+                (xevent->xclient.data.l[0] == videodata->WM_TAKE_FOCUS)) {
 
 #ifdef DEBUG_XEVENTS
                 printf("window %p: WM_TAKE_FOCUS\n", data);
@@ -1155,7 +1262,7 @@ X11_DispatchEvent(_THIS)
         /* Do we need to refresh ourselves? */
     case Expose:{
 #ifdef DEBUG_XEVENTS
-            printf("window %p: Expose (count = %d)\n", data, xevent.xexpose.count);
+            printf("window %p: Expose (count = %d)\n", data, xevent->xexpose.count);
 #endif
             SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_EXPOSED, 0, 0);
         }
@@ -1165,10 +1272,10 @@ X11_DispatchEvent(_THIS)
             SDL_Mouse *mouse = SDL_GetMouse();
             if(!mouse->relative_mode || mouse->relative_mode_warp) {
 #ifdef DEBUG_MOTION
-                printf("window %p: X11 motion: %d,%d\n", data, xevent.xmotion.x, xevent.xmotion.y);
+                printf("window %p: X11 motion: %d,%d\n", data, xevent->xmotion.x, xevent->xmotion.y);
 #endif
 
-                SDL_SendMouseMotion(data->window, 0, 0, xevent.xmotion.x, xevent.xmotion.y);
+                SDL_SendMouseMotion(data->window, 0, 0, xevent->xmotion.x, xevent->xmotion.y);
             }
         }
         break;
@@ -1176,15 +1283,15 @@ X11_DispatchEvent(_THIS)
     case ButtonPress:{
             int xticks = 0, yticks = 0;
 #ifdef DEBUG_XEVENTS
-            printf("window %p: ButtonPress (X11 button = %d)\n", data, xevent.xbutton.button);
+            printf("window %p: ButtonPress (X11 button = %d)\n", data, xevent->xbutton.button);
 #endif
-            if (X11_IsWheelEvent(display,&xevent,&xticks, &yticks)) {
-                SDL_SendMouseWheel(data->window, 0, (float) xticks, (float) yticks, SDL_MOUSEWHEEL_NORMAL);
+            if (X11_IsWheelEvent(display,xevent,&xticks, &yticks)) {
+                SDL_SendMouseWheel(data->window, 0, (float) -xticks, (float) yticks, SDL_MOUSEWHEEL_NORMAL);
             } else {
                 SDL_bool ignore_click = SDL_FALSE;
-                int button = xevent.xbutton.button;
+                int button = xevent->xbutton.button;
                 if(button == Button1) {
-                    if (ProcessHitTest(_this, data, &xevent)) {
+                    if (ProcessHitTest(_this, data, xevent)) {
                         SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_HIT_TEST, 0, 0);
                         break;  /* don't pass this event on to app. */
                     }
@@ -1205,18 +1312,18 @@ X11_DispatchEvent(_THIS)
                     SDL_SendMouseButton(data->window, 0, SDL_PRESSED, button);
                 }
             }
-            X11_UpdateUserTime(data, xevent.xbutton.time);
+            X11_UpdateUserTime(data, xevent->xbutton.time);
         }
         break;
 
     case ButtonRelease:{
-            int button = xevent.xbutton.button;
+            int button = xevent->xbutton.button;
             /* The X server sends a Release event for each Press for wheels. Ignore them. */
             int xticks = 0, yticks = 0;
 #ifdef DEBUG_XEVENTS
-            printf("window %p: ButtonRelease (X11 button = %d)\n", data, xevent.xbutton.button);
+            printf("window %p: ButtonRelease (X11 button = %d)\n", data, xevent->xbutton.button);
 #endif
-            if (!X11_IsWheelEvent(display, &xevent, &xticks, &yticks)) {
+            if (!X11_IsWheelEvent(display, xevent, &xticks, &yticks)) {
                 if (button > 7) {
                     /* see explanation at case ButtonPress */
                     button -= (8-SDL_BUTTON_X1);
@@ -1233,13 +1340,13 @@ X11_DispatchEvent(_THIS)
             Atom real_type;
             unsigned long items_read, items_left;
 
-            char *name = X11_XGetAtomName(display, xevent.xproperty.atom);
+            char *name = X11_XGetAtomName(display, xevent->xproperty.atom);
             if (name) {
-                printf("window %p: PropertyNotify: %s %s time=%lu\n", data, name, (xevent.xproperty.state == PropertyDelete) ? "deleted" : "changed", xevent.xproperty.time);
+                printf("window %p: PropertyNotify: %s %s time=%lu\n", data, name, (xevent->xproperty.state == PropertyDelete) ? "deleted" : "changed", xevent->xproperty.time);
                 X11_XFree(name);
             }
 
-            status = X11_XGetWindowProperty(display, data->xwindow, xevent.xproperty.atom, 0L, 8192L, False, AnyPropertyType, &real_type, &real_format, &items_read, &items_left, &propdata);
+            status = X11_XGetWindowProperty(display, data->xwindow, xevent->xproperty.atom, 0L, 8192L, False, AnyPropertyType, &real_type, &real_format, &items_read, &items_left, &propdata);
             if (status == Success && items_read > 0) {
                 if (real_type == XA_INTEGER) {
                     int *values = (int *)propdata;
@@ -1311,16 +1418,16 @@ X11_DispatchEvent(_THIS)
                 set _NET_WM_USER_TIME here, though. That's only for legit
                 user interaction with the window. */
             if (!data->user_time) {
-                data->user_time = xevent.xproperty.time;
+                data->user_time = xevent->xproperty.time;
             }
 
-            if (xevent.xproperty.atom == data->videodata->_NET_WM_STATE) {
+            if (xevent->xproperty.atom == data->videodata->_NET_WM_STATE) {
                 /* Get the new state from the window manager.
                    Compositing window managers can alter visibility of windows
                    without ever mapping / unmapping them, so we handle that here,
                    because they use the NETWM protocol to notify us of changes.
                  */
-                const Uint32 flags = X11_GetNetWMState(_this, xevent.xproperty.window);
+                const Uint32 flags = X11_GetNetWMState(_this, xevent->xproperty.window);
                 const Uint32 changed = flags ^ data->window->flags;
 
                 if ((changed & SDL_WINDOW_HIDDEN) || (changed & SDL_WINDOW_FULLSCREEN)) {
@@ -1338,7 +1445,7 @@ X11_DispatchEvent(_THIS)
                         SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_RESTORED, 0, 0);
                     }
                 }
-            } else if (xevent.xproperty.atom == videodata->XKLAVIER_STATE) {
+            } else if (xevent->xproperty.atom == videodata->XKLAVIER_STATE) {
                 /* Hack for Ubuntu 12.04 (etc) that doesn't send MappingNotify
                    events when the keyboard layout changes (for example,
                    changing from English to French on the menubar's keyboard
@@ -1347,7 +1454,7 @@ X11_DispatchEvent(_THIS)
                    right approach, but it seems to work. */
                 X11_UpdateKeymap(_this);
                 SDL_SendKeymapChangedEvent();
-            } else if (xevent.xproperty.atom == videodata->_NET_FRAME_EXTENTS) {
+            } else if (xevent->xproperty.atom == videodata->_NET_FRAME_EXTENTS) {
                 Atom type;
                 int format;
                 unsigned long nitems, bytes_after;
@@ -1370,10 +1477,10 @@ X11_DispatchEvent(_THIS)
         break;
 
     case SelectionNotify: {
-            Atom target = xevent.xselection.target;
+            Atom target = xevent->xselection.target;
 #ifdef DEBUG_XEVENTS
             printf("window %p: SelectionNotify (requestor = %ld, target = %ld)\n", data,
-                xevent.xselection.requestor, xevent.xselection.target);
+                xevent->xselection.requestor, xevent->xselection.target);
 #endif
             if (target == data->xdnd_req) {
                 /* read data */
@@ -1421,7 +1528,7 @@ X11_DispatchEvent(_THIS)
 
     default:{
 #ifdef DEBUG_XEVENTS
-            printf("window %p: Unhandled event %d\n", data, xevent.type);
+            printf("window %p: Unhandled event %d\n", data, xevent->type);
 #endif
         }
         break;
@@ -1451,29 +1558,101 @@ X11_HandleFocusChanges(_THIS)
         }
     }
 }
-/* Ack!  X11_XPending() actually performs a blocking read if no events available */
-static int
-X11_Pending(Display * display)
+
+static Bool
+isAnyEvent(Display *display, XEvent *ev, XPointer arg)
 {
-    /* Flush the display connection and look to see if events are queued */
+    return True;
+}
+
+static SDL_bool
+X11_PollEvent(Display *display, XEvent *event)
+{
+    if (!X11_XCheckIfEvent(display, event, isAnyEvent, NULL)) {
+        return SDL_FALSE;
+    }
+
+    return SDL_TRUE;
+}
+
+void
+X11_SendWakeupEvent(_THIS, SDL_Window *window)
+{
+    SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
+    Display *req_display = data->request_display;
+    Window xwindow = ((SDL_WindowData *) window->driverdata)->xwindow;
+    XClientMessageEvent event;
+
+    SDL_memset(&event, 0, sizeof(XClientMessageEvent));
+    event.type = ClientMessage;
+    event.display = req_display;
+    event.send_event = True;
+    event.message_type = data->_SDL_WAKEUP;
+    event.format = 8;
+
+    X11_XSendEvent(req_display, xwindow, False, NoEventMask, (XEvent *) &event);
+    /* XSendEvent returns a status and it could be BadValue or BadWindow. If an
+      error happens it is an SDL's internal error and there is nothing we can do here. */
+    X11_XFlush(req_display);
+}
+
+int
+X11_WaitEventTimeout(_THIS, int timeout)
+{
+    SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;
+    Display *display;
+    XEvent xevent;
+    display = videodata->display;
+
+    SDL_zero(xevent);
+
+    /* Flush and poll to grab any events already read and queued */
     X11_XFlush(display);
-    if (X11_XEventsQueued(display, QueuedAlready)) {
-        return (1);
+    if (X11_PollEvent(display, &xevent)) {
+        /* Fall through */
+    } else if (timeout == 0) {
+        return 0;
+    } else {
+        /* Use SDL_IOR_NO_RETRY to ensure SIGINT will break us out of our wait */
+        int err = SDL_IOReady(ConnectionNumber(display), SDL_IOR_READ | SDL_IOR_NO_RETRY, timeout);
+        if (err > 0) {
+            if (!X11_PollEvent(display, &xevent)) {
+                /* Someone may have beat us to reading the fd. Return 1 here to
+                 * trigger the normal spurious wakeup logic in the event core. */
+                return 1;
+            }
+        } else if (err == 0) {
+            /* Timeout */
+            return 0;
+        } else {
+            /* Error returned from poll()/select() */
+
+            if (errno == EINTR) {
+                /* If the wait was interrupted by a signal, we may have generated a
+                 * SDL_QUIT event. Let the caller know to call SDL_PumpEvents(). */
+                return 1;
+            } else {
+                return err;
+            }
+        }
     }
 
-    /* More drastic measures are required -- see if X is ready to talk */
-    if (SDL_IOReady(ConnectionNumber(display), SDL_FALSE, 0)) {
-        return (X11_XPending(display));
-    }
+    X11_DispatchEvent(_this, &xevent);
 
-    /* Oh well, nothing is ready .. */
-    return (0);
+#ifdef SDL_USE_IME
+    if(SDL_GetEventState(SDL_TEXTINPUT) == SDL_ENABLE){
+        SDL_IME_PumpEvents();
+    }
+#endif
+    return 1;
 }
 
 void
 X11_PumpEvents(_THIS)
 {
     SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
+    XEvent xevent;
+    int i;
 
     if (data->last_mode_change_deadline) {
         if (SDL_TICKS_PASSED(SDL_GetTicks(), data->last_mode_change_deadline)) {
@@ -1496,9 +1675,11 @@ X11_PumpEvents(_THIS)
         }
     }
 
+    SDL_zero(xevent);
+
     /* Keep processing pending events */
-    while (X11_Pending(data->display)) {
-        X11_DispatchEvent(_this);
+    while (X11_PollEvent(data->display, &xevent)) {
+        X11_DispatchEvent(_this, &xevent);
     }
 
 #ifdef SDL_USE_IME
@@ -1509,6 +1690,15 @@ X11_PumpEvents(_THIS)
 
     /* FIXME: Only need to do this when there are pending focus changes */
     X11_HandleFocusChanges(_this);
+
+    /* FIXME: Only need to do this when there are flashing windows */
+    for (i = 0; i < data->numwindows; ++i) {
+        if (data->windowlist[i] != NULL &&
+            data->windowlist[i]->flash_cancel_time &&
+            SDL_TICKS_PASSED(SDL_GetTicks(), data->windowlist[i]->flash_cancel_time)) {
+            X11_FlashWindow(_this, data->windowlist[i]->window, SDL_FLASH_CANCEL);
+        }
+    }
 }
 
 
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11events.h b/Engine/lib/sdl/src/video/x11/SDL_x11events.h
index df0782cb5..fc8a57ae2 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11events.h
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11events.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -24,6 +24,8 @@
 #define SDL_x11events_h_
 
 extern void X11_PumpEvents(_THIS);
+extern int  X11_WaitEventTimeout(_THIS, int timeout);
+extern void X11_SendWakeupEvent(_THIS, SDL_Window *window);
 extern void X11_SuspendScreenSaver(_THIS);
 
 #endif /* SDL_x11events_h_ */
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11framebuffer.c b/Engine/lib/sdl/src/video/x11/SDL_x11framebuffer.c
index 53e7ab00c..123ad8ffb 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11framebuffer.c
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11framebuffer.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -115,6 +115,7 @@ X11_CreateWindowFramebuffer(_THIS, SDL_Window * window, Uint32 * format,
                 shmdt(shminfo->shmaddr);
             } else {
                 /* Done! */
+                data->ximage->byte_order = (SDL_BYTEORDER == SDL_BIG_ENDIAN) ? MSBFirst : LSBFirst;
                 data->use_mitshm = SDL_TRUE;
                 *pixels = shminfo->shmaddr;
                 return 0;
@@ -135,6 +136,7 @@ X11_CreateWindowFramebuffer(_THIS, SDL_Window * window, Uint32 * format,
         SDL_free(*pixels);
         return SDL_SetError("Couldn't create XImage");
     }
+    data->ximage->byte_order = (SDL_BYTEORDER == SDL_BIG_ENDIAN) ? MSBFirst : LSBFirst;
     return 0;
 }
 
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11framebuffer.h b/Engine/lib/sdl/src/video/x11/SDL_x11framebuffer.h
index c26b4d9e2..63e73604a 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11framebuffer.h
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11framebuffer.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11keyboard.c b/Engine/lib/sdl/src/video/x11/SDL_x11keyboard.c
index ce53e52f2..c82570c62 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11keyboard.c
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11keyboard.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -31,7 +31,7 @@
 #include <X11/keysym.h>
 #include <X11/XKBlib.h>
 
-#include "imKStoUCS.h"
+#include "../../events/imKStoUCS.h"
 
 #ifdef X_HAVE_UTF8_STRING
 #include <locale.h>
@@ -205,7 +205,7 @@ X11_KeyCodeToUcs4(_THIS, KeyCode keycode, unsigned char group)
         return 0;
     }
 
-    return X11_KeySymToUcs4(keysym);
+    return SDL_KeySymToUcs4(keysym);
 }
 
 KeySym
@@ -267,7 +267,9 @@ X11_InitKeyboard(_THIS)
     int best_index;
     int distance;
     Bool xkb_repeat = 0;
-    XKeyboardState values = { .global_auto_repeat = AutoRepeatModeOff };
+    XKeyboardState values;
+    SDL_zero(values);
+    values.global_auto_repeat = AutoRepeatModeOff;
     
     X11_XGetKeyboardControl(data->display, &values);
     if (values.global_auto_repeat != AutoRepeatModeOn)
@@ -278,7 +280,7 @@ X11_InitKeyboard(_THIS)
         int xkb_major = XkbMajorVersion;
         int xkb_minor = XkbMinorVersion;
 
-        if (X11_XkbQueryExtension(data->display, NULL, NULL, NULL, &xkb_major, &xkb_minor)) {
+        if (X11_XkbQueryExtension(data->display, NULL, &data->xkb_event, NULL, &xkb_major, &xkb_minor)) {
             data->xkb = X11_XkbGetMap(data->display, XkbAllClientInfoMask, XkbUseCoreKbd);
         }
 
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11keyboard.h b/Engine/lib/sdl/src/video/x11/SDL_x11keyboard.h
index a89437541..dacaf7e18 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11keyboard.h
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11keyboard.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11messagebox.c b/Engine/lib/sdl/src/video/x11/SDL_x11messagebox.c
index d7a829b09..aafccca9b 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11messagebox.c
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11messagebox.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -334,10 +334,10 @@ X11_MessageBoxInitPositions( SDL_MessageBoxDataX11 *data )
 
         /* Location for first button. */
         if ( messageboxdata->flags & SDL_MESSAGEBOX_BUTTONS_RIGHT_TO_LEFT ) {
-			x = data->dialog_width - ( data->dialog_width - width_of_buttons ) / 2 - ( button_width + button_spacing );
-		} else {
-			x = ( data->dialog_width - width_of_buttons ) / 2;
-		}
+            x = data->dialog_width - ( data->dialog_width - width_of_buttons ) / 2 - ( button_width + button_spacing );
+        } else {
+            x = ( data->dialog_width - width_of_buttons ) / 2;
+        }
         y = ybuttons + ( data->dialog_height - ybuttons - button_height ) / 2;
 
         for ( i = 0; i < data->numbuttons; i++ ) {
@@ -352,11 +352,11 @@ X11_MessageBoxInitPositions( SDL_MessageBoxDataX11 *data )
             data->buttonpos[ i ].y = y + ( button_height - button_text_height - 1 ) / 2 + button_text_height;
 
             /* Scoot over for next button. */
-			if ( messageboxdata->flags & SDL_MESSAGEBOX_BUTTONS_RIGHT_TO_LEFT ) {
-				x -= button_width + button_spacing;
-			} else {
-				x += button_width + button_spacing;
-			}
+            if ( messageboxdata->flags & SDL_MESSAGEBOX_BUTTONS_RIGHT_TO_LEFT ) {
+                x -= button_width + button_spacing;
+            } else {
+                x += button_width + button_spacing;
+            }
         }
     }
 
@@ -404,11 +404,10 @@ X11_MessageBoxCreateWindow( SDL_MessageBoxDataX11 *data )
     int x, y;
     XSizeHints *sizehints;
     XSetWindowAttributes wnd_attr;
-    Atom _NET_WM_WINDOW_TYPE, _NET_WM_WINDOW_TYPE_DIALOG, _NET_WM_NAME;
+    Atom _NET_WM_WINDOW_TYPE, _NET_WM_WINDOW_TYPE_DIALOG;
     Display *display = data->display;
     SDL_WindowData *windowdata = NULL;
     const SDL_MessageBoxData *messageboxdata = data->messageboxdata;
-    char *title_locale = NULL;
 
     if ( messageboxdata->window ) {
         SDL_DisplayData *displaydata =
@@ -452,32 +451,7 @@ X11_MessageBoxCreateWindow( SDL_MessageBoxDataX11 *data )
         X11_XSetTransientForHint( display, data->window, windowdata->xwindow );
     }
 
-    X11_XStoreName( display, data->window, messageboxdata->title );
-    _NET_WM_NAME = X11_XInternAtom(display, "_NET_WM_NAME", False);
-
-    title_locale = SDL_iconv_utf8_locale(messageboxdata->title);
-    if (title_locale) {
-        XTextProperty titleprop;
-        Status status = X11_XStringListToTextProperty(&title_locale, 1, &titleprop);
-        SDL_free(title_locale);
-        if (status) {
-            X11_XSetTextProperty(display, data->window, &titleprop, XA_WM_NAME);
-            X11_XFree(titleprop.value);
-        }
-    }
-
-#ifdef X_HAVE_UTF8_STRING
-    if (SDL_X11_HAVE_UTF8) {
-        XTextProperty titleprop;
-        Status status = X11_Xutf8TextListToTextProperty(display, (char **) &messageboxdata->title, 1,
-                                            XUTF8StringStyle, &titleprop);
-        if (status == Success) {
-            X11_XSetTextProperty(display, data->window, &titleprop,
-                                 _NET_WM_NAME);
-            X11_XFree(titleprop.value);
-        }
-    }
-#endif
+    SDL_X11_SetWindowTitle(display, data->window, (char*)messageboxdata->title);
 
     /* Let the window manager know this is a dialog box */
     _NET_WM_WINDOW_TYPE = X11_XInternAtom(display, "_NET_WM_WINDOW_TYPE", False);
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11messagebox.h b/Engine/lib/sdl/src/video/x11/SDL_x11messagebox.h
index 1fd91e44f..bb85a6525 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11messagebox.h
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11messagebox.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11modes.c b/Engine/lib/sdl/src/video/x11/SDL_x11modes.c
index 79ad2472c..c1efe243c 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11modes.c
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11modes.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -257,7 +257,7 @@ static int
 CalculateXRandRRefreshRate(const XRRModeInfo *info)
 {
     return (info->hTotal && info->vTotal) ?
-        round(((double)info->dotClock / (double)(info->hTotal * info->vTotal))) : 0;
+        SDL_round(((double)info->dotClock / (double)(info->hTotal * info->vTotal))) : 0;
 }
 
 static SDL_bool
@@ -322,7 +322,7 @@ SetXRandRDisplayName(Display *dpy, Atom EDID, char *name, const size_t namelen,
                     dump_monitor_info(info);
 #endif
                     SDL_strlcpy(name, info->dsc_product_name, namelen);
-                    free(info);
+                    SDL_free(info);
                 }
                 X11_XFree(prop);
             }
@@ -345,6 +345,29 @@ SetXRandRDisplayName(Display *dpy, Atom EDID, char *name, const size_t namelen,
 #endif
 }
 
+static int
+GetXftDPI(Display* dpy)
+{
+    char* xdefault_resource;
+    int xft_dpi, err;
+
+    xdefault_resource = X11_XGetDefault(dpy, "Xft", "dpi");
+
+    if(!xdefault_resource) {
+        return 0;
+    }
+
+    /*
+     * It's possible for SDL_atoi to call SDL_strtol, if it fails due to a
+     * overflow or an underflow, it will return LONG_MAX or LONG_MIN and set
+     * errno to ERANGE. So we need to check for this so we dont get crazy dpi
+     * values
+     */
+    xft_dpi = SDL_atoi(xdefault_resource);
+    err = errno;
+
+    return err == ERANGE ? 0 : xft_dpi;
+}
 
 static int
 X11_InitModes_XRandR(_THIS)
@@ -417,6 +440,7 @@ X11_InitModes_XRandR(_THIS)
                 RRMode modeID;
                 RRCrtc output_crtc;
                 XRRCrtcInfo *crtc;
+                int xft_dpi = 0;
 
                 /* The primary output _should_ always be sorted first, but just in case... */
                 if ((looking_for_primary && (res->outputs[output] != primary)) ||
@@ -471,6 +495,14 @@ X11_InitModes_XRandR(_THIS)
                 displaydata->hdpi = display_mm_width ? (((float) mode.w) * 25.4f / display_mm_width) : 0.0f;
                 displaydata->vdpi = display_mm_height ? (((float) mode.h) * 25.4f / display_mm_height) : 0.0f;
                 displaydata->ddpi = SDL_ComputeDiagonalDPI(mode.w, mode.h, ((float) display_mm_width) / 25.4f,((float) display_mm_height) / 25.4f);
+
+                /* if xft dpi is available we will use this over xrandr */
+                xft_dpi = GetXftDPI(dpy);
+                if(xft_dpi > 0) {
+                    displaydata->hdpi = (float)xft_dpi;
+                    displaydata->vdpi = (float)xft_dpi;
+                }
+
                 displaydata->scanline_pad = scanline_pad;
                 displaydata->x = display_x;
                 displaydata->y = display_y;
@@ -817,6 +849,16 @@ X11_InitModes(_THIS)
     if (_this->num_displays == 0) {
         return SDL_SetError("No available displays");
     }
+
+#if SDL_VIDEO_DRIVER_X11_XVIDMODE
+    if (use_vidmode) {  /* we intend to remove support for XVidMode soon. */
+        SDL_LogWarn(SDL_LOG_CATEGORY_VIDEO, "SDL is using XVidMode to manage your displays!");
+        SDL_LogWarn(SDL_LOG_CATEGORY_VIDEO, "This almost always means either SDL was misbuilt");
+        SDL_LogWarn(SDL_LOG_CATEGORY_VIDEO, "or your X server is insufficient. Please check your setup!");
+        SDL_LogWarn(SDL_LOG_CATEGORY_VIDEO, "Fullscreen and/or multiple displays will not work well.");
+    }
+#endif
+
     return 0;
 }
 
@@ -963,6 +1005,15 @@ X11_GetDisplayModes(_THIS, SDL_VideoDisplay * sdl_display)
     }
 }
 
+/* This catches an error from XRRSetScreenSize, as a workaround for now. */
+/* !!! FIXME: remove this later when we have a better solution. */
+static int (*PreXRRSetScreenSizeErrorHandler)(Display *, XErrorEvent *) = NULL;
+static int
+SDL_XRRSetScreenSizeErrHandler(Display *d, XErrorEvent *e)
+{
+    return (e->error_code == BadMatch) ? 0 : PreXRRSetScreenSizeErrorHandler(d, e);
+}
+
 int
 X11_SetDisplayMode(_THIS, SDL_VideoDisplay * sdl_display, SDL_DisplayMode * mode)
 {
@@ -970,6 +1021,7 @@ X11_SetDisplayMode(_THIS, SDL_VideoDisplay * sdl_display, SDL_DisplayMode * mode
     Display *display = viddata->display;
     SDL_DisplayData *data = (SDL_DisplayData *) sdl_display->driverdata;
     SDL_DisplayModeData *modedata = (SDL_DisplayModeData *)mode->driverdata;
+    int mm_width, mm_height;
 
     viddata->last_mode_change_deadline = SDL_GetTicks() + (PENDING_FOCUS_TIME * 2);
 
@@ -998,10 +1050,45 @@ X11_SetDisplayMode(_THIS, SDL_VideoDisplay * sdl_display, SDL_DisplayMode * mode
             return SDL_SetError("Couldn't get XRandR crtc info");
         }
 
+        if (crtc->mode == modedata->xrandr_mode) {
+#ifdef X11MODES_DEBUG
+            printf("already in desired mode 0x%lx (%ux%u), nothing to do\n",
+                   crtc->mode, crtc->width, crtc->height);
+#endif
+            status = Success;
+            goto freeInfo;
+        }
+
+        X11_XGrabServer(display);
+        status = X11_XRRSetCrtcConfig(display, res, output_info->crtc, CurrentTime,
+          0, 0, None, crtc->rotation, NULL, 0);
+        if (status != Success) {
+            goto ungrabServer;
+        }
+
+        mm_width = mode->w * DisplayWidthMM(display, data->screen) / DisplayWidth(display, data->screen);
+        mm_height = mode->h * DisplayHeightMM(display, data->screen) / DisplayHeight(display, data->screen);
+
+        /* !!! FIXME: this can get into a problem scenario when a window is
+           bigger than a physical monitor in a configuration where one screen
+           spans multiple physical monitors. A detailed reproduction case is
+           discussed at https://github.com/libsdl-org/SDL/issues/4561 ...
+           for now we cheat and just catch the X11 error and carry on, which
+           is likely to cause subtle issues but is better than outright
+           crashing */
+        X11_XSync(display, False);
+        PreXRRSetScreenSizeErrorHandler = X11_XSetErrorHandler(SDL_XRRSetScreenSizeErrHandler);
+        X11_XRRSetScreenSize(display, RootWindow(display, data->screen), mode->w, mode->h, mm_width, mm_height);
+        X11_XSync(display, False);
+        X11_XSetErrorHandler(PreXRRSetScreenSizeErrorHandler);
+
         status = X11_XRRSetCrtcConfig (display, res, output_info->crtc, CurrentTime,
           crtc->x, crtc->y, modedata->xrandr_mode, crtc->rotation,
           &data->xrandr_output, 1);
 
+ungrabServer:
+        X11_XUngrabServer(display);
+freeInfo:
         X11_XRRFreeCrtcInfo(crtc);
         X11_XRRFreeOutputInfo(output_info);
         X11_XRRFreeScreenResources(res);
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11modes.h b/Engine/lib/sdl/src/video/x11/SDL_x11modes.h
index fc5dd63f9..554868016 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11modes.h
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11modes.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11mouse.c b/Engine/lib/sdl/src/video/x11/SDL_x11mouse.c
index 3082d194d..9eb1ddd30 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11mouse.c
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11mouse.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -77,7 +77,7 @@ X11_CreateDefaultCursor()
     cursor = SDL_calloc(1, sizeof(*cursor));
     if (cursor) {
         /* None is used to indicate the default cursor */
-        cursor->driverdata = (void*)None;
+        cursor->driverdata = (void*)(uintptr_t)None;
     } else {
         SDL_OutOfMemory();
     }
@@ -195,6 +195,8 @@ X11_CreatePixmapCursor(SDL_Surface * surface, int hot_x, int hot_y)
                                  &fg, &bg, hot_x, hot_y);
     X11_XFreePixmap(display, data_pixmap);
     X11_XFreePixmap(display, mask_pixmap);
+    SDL_free(data_bits);
+    SDL_free(mask_bits);
 
     return cursor;
 }
@@ -216,7 +218,7 @@ X11_CreateCursor(SDL_Surface * surface, int hot_x, int hot_y)
         if (x11_cursor == None) {
             x11_cursor = X11_CreatePixmapCursor(surface, hot_x, hot_y);
         }
-        cursor->driverdata = (void*)x11_cursor;
+        cursor->driverdata = (void*)(uintptr_t)x11_cursor;
     } else {
         SDL_OutOfMemory();
     }
@@ -257,7 +259,7 @@ X11_CreateSystemCursor(SDL_SystemCursor id)
 
         x11_cursor = X11_XCreateFontCursor(GetDisplay(), shape);
 
-        cursor->driverdata = (void*)x11_cursor;
+        cursor->driverdata = (void*)(uintptr_t)x11_cursor;
     } else {
         SDL_OutOfMemory();
     }
@@ -292,14 +294,15 @@ X11_ShowCursor(SDL_Cursor * cursor)
         SDL_VideoDevice *video = SDL_GetVideoDevice();
         Display *display = GetDisplay();
         SDL_Window *window;
-        SDL_WindowData *data;
 
         for (window = video->windows; window; window = window->next) {
-            data = (SDL_WindowData *)window->driverdata;
-            if (x11_cursor != None) {
-                X11_XDefineCursor(display, data->xwindow, x11_cursor);
-            } else {
-                X11_XUndefineCursor(display, data->xwindow);
+            SDL_WindowData *data = (SDL_WindowData *)window->driverdata;
+            if (data) {
+                if (x11_cursor != None) {
+                    X11_XDefineCursor(display, data->xwindow, x11_cursor);
+                } else {
+                    X11_XUndefineCursor(display, data->xwindow);
+                }
             }
         }
         X11_XFlush(display);
@@ -321,7 +324,15 @@ static void
 X11_WarpMouse(SDL_Window * window, int x, int y)
 {
     SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
+
+#if SDL_VIDEO_DRIVER_X11_XFIXES
+    /* If we have no barrier, we need to warp */
+    if (data->pointer_barrier_active == SDL_FALSE) {
+        WarpMouseInternal(data->xwindow, x, y);
+    }
+#else
     WarpMouseInternal(data->xwindow, x, y);
+#endif
 }
 
 static int
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11mouse.h b/Engine/lib/sdl/src/video/x11/SDL_x11mouse.h
index b6628e1cb..e44adacb1 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11mouse.h
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11mouse.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11opengl.c b/Engine/lib/sdl/src/video/x11/SDL_x11opengl.c
index 07a71c0ba..64b06340a 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11opengl.c
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11opengl.c
@@ -1,6 +1,7 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 2021 NVIDIA Corporation
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -141,7 +142,7 @@ typedef GLXContext(*PFNGLXCREATECONTEXTATTRIBSARBPROC) (Display * dpy,
 #endif
 
 #define OPENGL_REQUIRES_DLOPEN
-#if defined(OPENGL_REQUIRES_DLOPEN) && defined(SDL_LOADSO_DLOPEN)
+#if defined(OPENGL_REQUIRES_DLOPEN) && defined(HAVE_DLOPEN)
 #include <dlfcn.h>
 #define GL_LoadObject(X)    dlopen(X, (RTLD_NOW|RTLD_GLOBAL))
 #define GL_LoadFunction     dlsym
@@ -173,7 +174,7 @@ X11_GL_LoadLibrary(_THIS, const char *path)
     }
     _this->gl_config.dll_handle = GL_LoadObject(path);
     if (!_this->gl_config.dll_handle) {
-#if defined(OPENGL_REQUIRES_DLOPEN) && defined(SDL_LOADSO_DLOPEN)
+#if defined(OPENGL_REQUIRES_DLOPEN) && defined(HAVE_DLOPEN)
         SDL_SetError("Failed loading %s: %s", path, dlerror());
 #endif
         return -1;
@@ -420,6 +421,9 @@ X11_GL_InitExtensions(_THIS)
         _this->gl_data->glXChooseFBConfig =
             (GLXFBConfig *(*)(Display *, int, const int *, int *))
                 X11_GL_GetProcAddress(_this, "glXChooseFBConfig");
+        _this->gl_data->glXGetVisualFromFBConfig =
+            (XVisualInfo *(*)(Display *, GLXFBConfig))
+                X11_GL_GetProcAddress(_this, "glXGetVisualFromFBConfig");
     }
 
     /* Check for GLX_EXT_visual_rating */
@@ -598,7 +602,7 @@ X11_GL_GetVisual(_THIS, Display * display, int screen)
 {
     /* 64 seems nice. */
     int attribs[64];
-    XVisualInfo *vinfo;
+    XVisualInfo *vinfo = NULL;
     int *pvistypeattr = NULL;
 
     if (!_this->gl_data) {
@@ -606,12 +610,33 @@ X11_GL_GetVisual(_THIS, Display * display, int screen)
         return NULL;
     }
 
-    X11_GL_GetAttributes(_this, display, screen, attribs, 64, SDL_FALSE, &pvistypeattr);
-    vinfo = _this->gl_data->glXChooseVisual(display, screen, attribs);
+    if (_this->gl_data->glXChooseFBConfig &&
+        _this->gl_data->glXGetVisualFromFBConfig) {
+        GLXFBConfig *framebuffer_config = NULL;
+        int fbcount = 0;
 
-    if (!vinfo && (pvistypeattr != NULL)) {
-        *pvistypeattr = None;
+        X11_GL_GetAttributes(_this, display, screen, attribs, 64, SDL_TRUE, &pvistypeattr);
+        framebuffer_config = _this->gl_data->glXChooseFBConfig(display, screen, attribs, &fbcount);
+        if (!framebuffer_config && (pvistypeattr != NULL)) {
+            *pvistypeattr = None;
+            framebuffer_config = _this->gl_data->glXChooseFBConfig(display, screen, attribs, &fbcount);
+        }
+
+        if (framebuffer_config) {
+            vinfo = _this->gl_data->glXGetVisualFromFBConfig(display, framebuffer_config[0]);
+        }
+
+        X11_XFree(framebuffer_config);
+    }
+
+    if (!vinfo) {
+        X11_GL_GetAttributes(_this, display, screen, attribs, 64, SDL_FALSE, &pvistypeattr);
         vinfo = _this->gl_data->glXChooseVisual(display, screen, attribs);
+
+        if (!vinfo && (pvistypeattr != NULL)) {
+            *pvistypeattr = None;
+            vinfo = _this->gl_data->glXChooseVisual(display, screen, attribs);
+        }
     }
 
     if (!vinfo) {
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11opengl.h b/Engine/lib/sdl/src/video/x11/SDL_x11opengl.h
index 3726a23c7..71e03c0c9 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11opengl.h
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11opengl.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -53,6 +53,7 @@ struct SDL_GLDriverData
     GLXContext (*glXCreateContext) (Display*,XVisualInfo*,GLXContext,Bool);
     GLXContext (*glXCreateContextAttribsARB) (Display*,GLXFBConfig,GLXContext,Bool,const int *);
     GLXFBConfig *(*glXChooseFBConfig) (Display*,int,const int *,int *);
+    XVisualInfo *(*glXGetVisualFromFBConfig) (Display*,GLXFBConfig);
     void (*glXDestroyContext) (Display*, GLXContext);
     Bool(*glXMakeCurrent) (Display*,GLXDrawable,GLXContext);
     void (*glXSwapBuffers) (Display*, GLXDrawable);
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11opengles.c b/Engine/lib/sdl/src/video/x11/SDL_x11opengles.c
index d3bdaa648..e1ec4e4d2 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11opengles.c
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11opengles.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11opengles.h b/Engine/lib/sdl/src/video/x11/SDL_x11opengles.h
index afb4edf6e..5219553ca 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11opengles.h
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11opengles.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11shape.c b/Engine/lib/sdl/src/video/x11/SDL_x11shape.c
index b55ac2c65..7d78f1127 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11shape.c
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11shape.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -35,7 +35,7 @@ X11_CreateShaper(SDL_Window* window) {
 
 #if SDL_VIDEO_DRIVER_X11_XSHAPE
     if (SDL_X11_HAVE_XSHAPE) {  /* Make sure X server supports it. */
-        result = malloc(sizeof(SDL_WindowShaper));
+        result = SDL_malloc(sizeof(SDL_WindowShaper));
         result->window = window;
         result->mode.mode = ShapeModeDefault;
         result->mode.parameters.binarizationCutoff = 1;
@@ -65,13 +65,13 @@ X11_ResizeWindowShape(SDL_Window* window) {
     if(data->bitmapsize != bitmapsize || data->bitmap == NULL) {
         data->bitmapsize = bitmapsize;
         if(data->bitmap != NULL)
-            free(data->bitmap);
-        data->bitmap = malloc(data->bitmapsize);
+            SDL_free(data->bitmap);
+        data->bitmap = SDL_malloc(data->bitmapsize);
         if(data->bitmap == NULL) {
             return SDL_SetError("Could not allocate memory for shaped-window bitmap.");
         }
     }
-    memset(data->bitmap,0,data->bitmapsize);
+    SDL_memset(data->bitmap,0,data->bitmapsize);
 
     window->shaper->userx = window->x;
     window->shaper->usery = window->y;
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11shape.h b/Engine/lib/sdl/src/video/x11/SDL_x11shape.h
index d0b26e8d4..4d54fb168 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11shape.h
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11shape.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11sym.h b/Engine/lib/sdl/src/video/x11/SDL_x11sym.h
index c7286d753..67b0a793a 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11sym.h
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11sym.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -97,7 +97,6 @@ SDL_X11_SYM(int,XMapRaised,(Display* a,Window b),(a,b),return)
 SDL_X11_SYM(Status,XMatchVisualInfo,(Display* a,int b,int c,int d,XVisualInfo* e),(a,b,c,d,e),return)
 SDL_X11_SYM(int,XMissingExtension,(Display* a,_Xconst char* b),(a,b),return)
 SDL_X11_SYM(int,XMoveWindow,(Display* a,Window b,int c,int d),(a,b,c,d),return)
-SDL_X11_SYM(int,XNextEvent,(Display* a,XEvent* b),(a,b),return)
 SDL_X11_SYM(Display*,XOpenDisplay,(_Xconst char* a),(a),return)
 SDL_X11_SYM(Status,XInitThreads,(void),(),return)
 SDL_X11_SYM(int,XPeekEvent,(Display* a,XEvent* b),(a,b),return)
@@ -109,6 +108,7 @@ SDL_X11_SYM(int,XRaiseWindow,(Display* a,Window b),(a,b),return)
 SDL_X11_SYM(int,XReparentWindow,(Display* a,Window b,Window c,int d,int e),(a,b,c,d,e),return)
 SDL_X11_SYM(int,XResetScreenSaver,(Display* a),(a),return)
 SDL_X11_SYM(int,XResizeWindow,(Display* a,Window b,unsigned int c,unsigned int d),(a,b,c,d),return)
+SDL_X11_SYM(int,XScreenNumberOfScreen,(Screen* a),(a),return)
 SDL_X11_SYM(int,XSelectInput,(Display* a,Window b,long c),(a,b,c),return)
 SDL_X11_SYM(Status,XSendEvent,(Display* a,Window b,Bool c,long d,XEvent* e),(a,b,c,d,e),return)
 SDL_X11_SYM(XErrorHandler,XSetErrorHandler,(XErrorHandler a),(a),return)
@@ -119,8 +119,9 @@ SDL_X11_SYM(int,XSetSelectionOwner,(Display* a,Atom b,Window c,Time d),(a,b,c,d)
 SDL_X11_SYM(int,XSetTransientForHint,(Display* a,Window b,Window c),(a,b,c),return)
 SDL_X11_SYM(void,XSetTextProperty,(Display* a,Window b,XTextProperty* c,Atom d),(a,b,c,d),)
 SDL_X11_SYM(int,XSetWindowBackground,(Display* a,Window b,unsigned long c),(a,b,c),return)
-SDL_X11_SYM(void,XSetWMProperties,(Display* a,Window b,XTextProperty* c,XTextProperty* d,char** e,int f,XSizeHints* g,XWMHints* h,XClassHint* i),(a,b,c,d,e,f,g,h,i),)
+SDL_X11_SYM(void,XSetWMHints,(Display* a,Window b,XWMHints* c),(a,b,c),)
 SDL_X11_SYM(void,XSetWMNormalHints,(Display* a,Window b,XSizeHints* c),(a,b,c),)
+SDL_X11_SYM(void,XSetWMProperties,(Display* a,Window b,XTextProperty* c,XTextProperty* d,char** e,int f,XSizeHints* g,XWMHints* h,XClassHint* i),(a,b,c,d,e,f,g,h,i),)
 SDL_X11_SYM(Status,XSetWMProtocols,(Display* a,Window b,Atom* c,int d),(a,b,c,d),return)
 SDL_X11_SYM(int,XStoreColors,(Display* a,Colormap b,XColor* c,int d),(a,b,c,d),return)
 SDL_X11_SYM(int,XStoreName,(Display* a,Window b,_Xconst char* c),(a,b,c),return)
@@ -138,15 +139,7 @@ SDL_X11_SYM(int,XWarpPointer,(Display* a,Window b,Window c,int d,int e,unsigned
 SDL_X11_SYM(int,XWindowEvent,(Display* a,Window b,long c,XEvent* d),(a,b,c,d),return)
 SDL_X11_SYM(Status,XWithdrawWindow,(Display* a,Window b,int c),(a,b,c),return)
 SDL_X11_SYM(VisualID,XVisualIDFromVisual,(Visual* a),(a),return)
-#if SDL_VIDEO_DRIVER_X11_CONST_PARAM_XEXTADDDISPLAY
-SDL_X11_SYM(XExtDisplayInfo*,XextAddDisplay,(XExtensionInfo* a,Display* b,_Xconst char* c,XExtensionHooks* d,int e,XPointer f),(a,b,c,d,e,f),return)
-#else
-SDL_X11_SYM(XExtDisplayInfo*,XextAddDisplay,(XExtensionInfo* a,Display* b,char* c,XExtensionHooks* d,int e,XPointer f),(a,b,c,d,e,f),return)
-#endif
-SDL_X11_SYM(XExtensionInfo*,XextCreateExtension,(void),(),return)
-SDL_X11_SYM(void,XextDestroyExtension,(XExtensionInfo* a),(a),)
-SDL_X11_SYM(XExtDisplayInfo*,XextFindDisplay,(XExtensionInfo* a,Display* b),(a,b),return)
-SDL_X11_SYM(int,XextRemoveDisplay,(XExtensionInfo* a,Display* b),(a,b),return)
+SDL_X11_SYM(char*,XGetDefault,(Display* a,_Xconst char* b, _Xconst char* c),(a,b,c),return)
 SDL_X11_SYM(Bool,XQueryExtension,(Display* a,_Xconst char* b,int* c,int* d,int* e),(a,b,c,d,e),return)
 SDL_X11_SYM(char *,XDisplayString,(Display* a),(a),return)
 SDL_X11_SYM(int,XGetErrorText,(Display* a,int b,char* c,int d),(a,b,c,d),return)
@@ -163,6 +156,16 @@ SDL_X11_SYM(SDL_X11_XESetWireToEventRetType,XESetWireToEvent,(Display* a,int b,S
 SDL_X11_SYM(SDL_X11_XESetEventToWireRetType,XESetEventToWire,(Display* a,int b,SDL_X11_XESetEventToWireRetType c),(a,b,c),return)
 SDL_X11_SYM(void,XRefreshKeyboardMapping,(XMappingEvent *a),(a),)
 SDL_X11_SYM(int,XQueryTree,(Display* a,Window b,Window* c,Window* d,Window** e,unsigned int* f),(a,b,c,d,e,f),return)
+SDL_X11_SYM(Bool,XSupportsLocale,(void),(),return)
+SDL_X11_SYM(Status,XmbTextListToTextProperty,(Display* a,char** b,int c,XICCEncodingStyle d,XTextProperty* e),(a,b,c,d,e),return)
+
+#if SDL_VIDEO_DRIVER_X11_XFIXES
+SDL_X11_MODULE(XFIXES)
+SDL_X11_SYM(PointerBarrier, XFixesCreatePointerBarrier, (Display* a, Window b, int c, int d, int e, int f, int g, int h, int *i),(a,b,c,d,e,f,g,h,i),return)
+SDL_X11_SYM(void, XFixesDestroyPointerBarrier, (Display* a, PointerBarrier b), (a,b),)
+SDL_X11_SYM(int, XIBarrierReleasePointer,(Display* a,  int b, PointerBarrier c, BarrierEventID d), (a,b,c,d), return) /* this is actually Xinput2 */
+SDL_X11_SYM(Status, XFixesQueryVersion,(Display* a, int* b, int* c), (a,b,c), return)
+#endif
 
 #if SDL_VIDEO_DRIVER_X11_SUPPORTS_GENERIC_EVENTS
 SDL_X11_SYM(Bool,XGetEventData,(Display* a,XGenericEventCookie* b),(a,b),return)
@@ -182,6 +185,7 @@ SDL_X11_SYM(XkbDescPtr,XkbGetMap,(Display* a,unsigned int b,unsigned int c),(a,b
 SDL_X11_SYM(void,XkbFreeClientMap,(XkbDescPtr a,unsigned int b, Bool c),(a,b,c),)
 SDL_X11_SYM(void,XkbFreeKeyboard,(XkbDescPtr a,unsigned int b, Bool c),(a,b,c),)
 SDL_X11_SYM(Bool,XkbSetDetectableAutoRepeat,(Display* a, Bool b, Bool* c),(a,b,c),return)
+SDL_X11_SYM(Bool,XkbSelectEvents,(Display* a, unsigned int b, unsigned int c, unsigned int d),(a,b,c,d),return)
 #endif
 
 #if NeedWidePrototypes
@@ -275,6 +279,8 @@ SDL_X11_MODULE(XINPUT2)
 SDL_X11_SYM(XIDeviceInfo*,XIQueryDevice,(Display *a,int b,int *c),(a,b,c),return)
 SDL_X11_SYM(void,XIFreeDeviceInfo,(XIDeviceInfo *a),(a),)
 SDL_X11_SYM(int,XISelectEvents,(Display *a,Window b,XIEventMask *c,int d),(a,b,c,d),return)
+SDL_X11_SYM(int,XIGrabTouchBegin,(Display *a,int b,Window c,int d,XIEventMask *e,int f,XIGrabModifiers *g),(a,b,c,d,e,f,g),return)
+SDL_X11_SYM(int,XIUngrabTouchBegin, (Display *a,int b,Window c, int d,XIGrabModifiers *e),(a, b, c, d, e),return)
 SDL_X11_SYM(Status,XIQueryVersion,(Display *a,int *b,int *c),(a,b,c),return)
 SDL_X11_SYM(XIEventMask*,XIGetSelectedEvents,(Display *a,Window b,int *c),(a,b,c),return)
 #endif
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11touch.c b/Engine/lib/sdl/src/video/x11/SDL_x11touch.c
index aef86aa96..958bee9df 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11touch.c
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11touch.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11touch.h b/Engine/lib/sdl/src/video/x11/SDL_x11touch.h
index fba3f2764..61b61a34e 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11touch.h
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11touch.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11video.c b/Engine/lib/sdl/src/video/x11/SDL_x11video.c
index 4ae9544e6..fc8c878fb 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11video.c
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11video.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -36,6 +36,7 @@
 #include "SDL_x11shape.h"
 #include "SDL_x11touch.h"
 #include "SDL_x11xinput2.h"
+#include "SDL_x11xfixes.h"
 
 #if SDL_VIDEO_OPENGL_EGL
 #include "SDL_x11opengles.h"
@@ -105,7 +106,13 @@ X11_DeleteDevice(SDL_VideoDevice * device)
         X11_XSetErrorHandler(orig_x11_errhandler);
         X11_XCloseDisplay(data->display);
     }
+    if (data->request_display) {
+        X11_XCloseDisplay(data->request_display);
+    }
     SDL_free(data->windowlist);
+    if (device->wakeup_lock) {
+        SDL_DestroyMutex(device->wakeup_lock);
+    }
     SDL_free(device->driverdata);
     SDL_free(device);
 
@@ -181,7 +188,22 @@ X11_CreateDevice(int devindex)
 
     data->global_mouse_changed = SDL_TRUE;
 
+#if SDL_VIDEO_DRIVER_X11_XFIXES
+    data->active_cursor_confined_window = NULL;
+#endif /* SDL_VIDEO_DRIVER_X11_XFIXES */
+
     data->display = x11_display;
+    data->request_display = X11_XOpenDisplay(display);
+    if (data->request_display == NULL) {
+        X11_XCloseDisplay(data->display);
+        SDL_free(device->driverdata);
+        SDL_free(device);
+        SDL_X11_UnloadSymbols();
+        return NULL;
+    }
+
+    device->wakeup_lock = SDL_CreateMutex();
+
 #ifdef X11_DEBUG
     X11_XSynchronize(data->display, True);
 #endif
@@ -198,9 +220,12 @@ X11_CreateDevice(int devindex)
     device->GetDisplayBounds = X11_GetDisplayBounds;
     device->GetDisplayUsableBounds = X11_GetDisplayUsableBounds;
     device->GetDisplayDPI = X11_GetDisplayDPI;
+    device->GetWindowICCProfile = X11_GetWindowICCProfile;
     device->SetDisplayMode = X11_SetDisplayMode;
     device->SuspendScreenSaver = X11_SuspendScreenSaver;
     device->PumpEvents = X11_PumpEvents;
+    device->WaitEventTimeout = X11_WaitEventTimeout;
+    device->SendWakeupEvent = X11_SendWakeupEvent;
 
     device->CreateSDLWindow = X11_CreateWindow;
     device->CreateSDLWindowFrom = X11_CreateWindowFrom;
@@ -222,9 +247,11 @@ X11_CreateDevice(int devindex)
     device->RestoreWindow = X11_RestoreWindow;
     device->SetWindowBordered = X11_SetWindowBordered;
     device->SetWindowResizable = X11_SetWindowResizable;
+    device->SetWindowAlwaysOnTop = X11_SetWindowAlwaysOnTop;
     device->SetWindowFullscreen = X11_SetWindowFullscreen;
     device->SetWindowGammaRamp = X11_SetWindowGammaRamp;
-    device->SetWindowGrab = X11_SetWindowGrab;
+    device->SetWindowMouseGrab = X11_SetWindowMouseGrab;
+    device->SetWindowKeyboardGrab = X11_SetWindowKeyboardGrab;
     device->DestroyWindow = X11_DestroyWindow;
     device->CreateWindowFramebuffer = X11_CreateWindowFramebuffer;
     device->UpdateWindowFramebuffer = X11_UpdateWindowFramebuffer;
@@ -232,6 +259,11 @@ X11_CreateDevice(int devindex)
     device->GetWindowWMInfo = X11_GetWindowWMInfo;
     device->SetWindowHitTest = X11_SetWindowHitTest;
     device->AcceptDragAndDrop = X11_AcceptDragAndDrop;
+    device->FlashWindow = X11_FlashWindow;
+
+#if SDL_VIDEO_DRIVER_X11_XFIXES
+    device->SetWindowMouseRect = X11_SetWindowMouseRect;
+#endif /* SDL_VIDEO_DRIVER_X11_XFIXES */
 
     device->shape_driver.CreateShaper = X11_CreateShaper;
     device->shape_driver.SetWindowShape = X11_SetWindowShape;
@@ -382,6 +414,7 @@ X11_VideoInit(_THIS)
     GET_ATOM(WM_PROTOCOLS);
     GET_ATOM(WM_DELETE_WINDOW);
     GET_ATOM(WM_TAKE_FOCUS);
+    GET_ATOM(WM_NAME);
     GET_ATOM(_NET_WM_STATE);
     GET_ATOM(_NET_WM_STATE_HIDDEN);
     GET_ATOM(_NET_WM_STATE_FOCUSED);
@@ -401,6 +434,7 @@ X11_VideoInit(_THIS)
     GET_ATOM(_NET_WM_USER_TIME);
     GET_ATOM(_NET_ACTIVE_WINDOW);
     GET_ATOM(_NET_FRAME_EXTENTS);
+    GET_ATOM(_SDL_WAKEUP);
     GET_ATOM(UTF8_STRING);
     GET_ATOM(PRIMARY);
     GET_ATOM(XdndEnter);
@@ -422,6 +456,14 @@ X11_VideoInit(_THIS)
 
     X11_InitXinput2(_this);
 
+#ifdef SDL_VIDEO_DRIVER_X11_XFIXES
+    X11_InitXfixes(_this);
+#endif /* SDL_VIDEO_DRIVER_X11_XFIXES */
+
+#ifndef X_HAVE_UTF8_STRING
+#warning X server does not support UTF8_STRING, a feature introduced in 2000! This is likely to become a hard error in a future libSDL2.
+#endif
+
     if (X11_InitKeyboard(_this) != 0) {
         return -1;
     }
@@ -429,10 +471,6 @@ X11_VideoInit(_THIS)
 
     X11_InitTouch(_this);
 
-#if SDL_USE_LIBDBUS
-    SDL_DBus_Init();
-#endif
-
     return 0;
 }
 
@@ -456,12 +494,6 @@ X11_VideoQuit(_THIS)
     X11_QuitKeyboard(_this);
     X11_QuitMouse(_this);
     X11_QuitTouch(_this);
-
-/* !!! FIXME: other subsystems use D-Bus, so we shouldn't quit it here;
-       have SDL.c do this at a higher level, or add refcounting. */
-#if SDL_USE_LIBDBUS
-    SDL_DBus_Quit();
-#endif
 }
 
 SDL_bool
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11video.h b/Engine/lib/sdl/src/video/x11/SDL_x11video.h
index 04bedfbd1..8c7eb09ec 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11video.h
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11video.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -75,6 +75,7 @@
 typedef struct SDL_VideoData
 {
     Display *display;
+    Display *request_display;
     char *classname;
     pid_t pid;
     XIM im;
@@ -84,6 +85,9 @@ typedef struct SDL_VideoData
     int windowlistlength;
     XID window_group;
     Window clipboard_window;
+#if SDL_VIDEO_DRIVER_X11_XFIXES
+    SDL_Window *active_cursor_confined_window;
+#endif /* SDL_VIDEO_DRIVER_X11_XFIXES */
 
     /* This is true for ICCCM2.0-compliant window managers */
     SDL_bool net_wm;
@@ -92,6 +96,7 @@ typedef struct SDL_VideoData
     Atom WM_PROTOCOLS;
     Atom WM_DELETE_WINDOW;
     Atom WM_TAKE_FOCUS;
+    Atom WM_NAME;
     Atom _NET_WM_STATE;
     Atom _NET_WM_STATE_HIDDEN;
     Atom _NET_WM_STATE_FOCUSED;
@@ -111,6 +116,7 @@ typedef struct SDL_VideoData
     Atom _NET_WM_USER_TIME;
     Atom _NET_ACTIVE_WINDOW;
     Atom _NET_FRAME_EXTENTS;
+    Atom _SDL_WAKEUP;
     Atom UTF8_STRING;
     Atom PRIMARY;
     Atom XdndEnter;
@@ -137,6 +143,7 @@ typedef struct SDL_VideoData
 #if SDL_VIDEO_DRIVER_X11_HAS_XKBKEYCODETOKEYSYM
     XkbDescPtr xkb;
 #endif
+    int xkb_event;
 
     KeyCode filter_code;
     Time    filter_time;
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11vulkan.c b/Engine/lib/sdl/src/video/x11/SDL_x11vulkan.c
index 286da7242..b9eb34b88 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11vulkan.c
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11vulkan.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11vulkan.h b/Engine/lib/sdl/src/video/x11/SDL_x11vulkan.h
index c74707295..e9e422b0d 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11vulkan.h
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11vulkan.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11window.c b/Engine/lib/sdl/src/video/x11/SDL_x11window.c
index ef4fd8877..a6bd91d72 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11window.c
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11window.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -32,6 +32,7 @@
 #include "SDL_x11mouse.h"
 #include "SDL_x11shape.h"
 #include "SDL_x11xinput2.h"
+#include "SDL_x11xfixes.h"
 
 #if SDL_VIDEO_OPENGL_EGL
 #include "SDL_x11opengles.h"
@@ -261,6 +262,7 @@ SetupWindowData(_THIS, SDL_Window * window, Window w, BOOL created)
     }
     data->window = window;
     data->xwindow = w;
+
 #ifdef X_HAVE_UTF8_STRING
     if (SDL_X11_HAVE_UTF8 && videodata->im) {
         data->ic =
@@ -325,7 +327,7 @@ SetupWindowData(_THIS, SDL_Window * window, Window w, BOOL created)
             SDL_SetKeyboardFocus(data->window);
         }
 
-        if (window->flags & SDL_WINDOW_INPUT_GRABBED) {
+        if (window->flags & SDL_WINDOW_MOUSE_GRABBED) {
             /* Tell x11 to clip mouse */
         }
     }
@@ -372,6 +374,7 @@ X11_CreateWindow(_THIS, SDL_Window * window)
     SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
     SDL_DisplayData *displaydata =
         (SDL_DisplayData *) SDL_GetDisplayForWindow(window)->driverdata;
+    const SDL_bool force_override_redirect = SDL_GetHintBoolean(SDL_HINT_X11_FORCE_OVERRIDE_REDIRECT, SDL_FALSE);
     SDL_WindowData *windowdata;
     Display *display = data->display;
     int screen = displaydata->screen;
@@ -389,6 +392,7 @@ X11_CreateWindow(_THIS, SDL_Window * window)
     long compositor = 1;
     Atom _NET_WM_PID;
     long fevent = 0;
+    const char *hint = NULL;
 
 #if SDL_VIDEO_OPENGL_GLX || SDL_VIDEO_OPENGL_EGL
     const char *forced_visual_id = SDL_GetHint(SDL_HINT_VIDEO_X11_WINDOW_VISUALID);
@@ -444,7 +448,8 @@ X11_CreateWindow(_THIS, SDL_Window * window)
         depth = displaydata->depth;
     }
 
-    xattr.override_redirect = ((window->flags & SDL_WINDOW_TOOLTIP) || (window->flags & SDL_WINDOW_POPUP_MENU)) ? True : False;
+    xattr.override_redirect = ((window->flags & SDL_WINDOW_TOOLTIP) || (window->flags & SDL_WINDOW_POPUP_MENU) || force_override_redirect) ? True : False;
+    xattr.backing_store = NotUseful;
     xattr.background_pixmap = None;
     xattr.border_pixel = 0;
 
@@ -531,7 +536,7 @@ X11_CreateWindow(_THIS, SDL_Window * window)
                       window->x, window->y, window->w, window->h,
                       0, depth, InputOutput, visual,
                       (CWOverrideRedirect | CWBackPixmap | CWBorderPixel |
-                       CWColormap), &xattr);
+                       CWBackingStore | CWColormap), &xattr);
     if (!w) {
         return SDL_SetError("Couldn't create window");
     }
@@ -587,6 +592,8 @@ X11_CreateWindow(_THIS, SDL_Window * window)
         wintype_name = "_NET_WM_WINDOW_TYPE_TOOLTIP";
     } else if (window->flags & SDL_WINDOW_POPUP_MENU) {
         wintype_name = "_NET_WM_WINDOW_TYPE_POPUP_MENU";
+    } else if ( ((hint = SDL_GetHint(SDL_HINT_X11_WINDOW_TYPE)) != NULL) && *hint ) {
+        wintype_name = hint;
     } else {
         wintype_name = "_NET_WM_WINDOW_TYPE_NORMAL";
         compositor = 1;  /* disable compositing for "normal" windows */
@@ -668,6 +675,11 @@ X11_CreateWindow(_THIS, SDL_Window * window)
                  PropertyChangeMask | StructureNotifyMask |
                  KeymapStateMask | fevent));
 
+    /* For _ICC_PROFILE. */
+    X11_XSelectInput(display, RootWindow(display, screen), PropertyChangeMask);
+
+    X11_XkbSelectEvents(display, XkbUseCoreKbd, XkbStateNotifyMask, XkbStateNotifyMask);
+
     X11_XFlush(display);
 
     return 0;
@@ -709,8 +721,10 @@ X11_GetWindowTitle(_THIS, Window xwindow)
                     &items_read, &items_left, &propdata);
         if (status == Success && propdata) {
             title = SDL_iconv_string("UTF-8", "", SDL_static_cast(char*, propdata), items_read+1);
+            SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Failed to convert WM_NAME title expecting UTF8! Title: %s", title);
             X11_XFree(propdata);
         } else {
+            SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Could not get any window title response from Xorg, returning empty string!");
             title = SDL_strdup("");
         }
     }
@@ -721,41 +735,11 @@ void
 X11_SetWindowTitle(_THIS, SDL_Window * window)
 {
     SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
+    Window xwindow = data->xwindow;
     Display *display = data->videodata->display;
-    XTextProperty titleprop;
-    Status status;
-    const char *title = window->title ? window->title : "";
-    char *title_locale = NULL;
+    char *title = window->title ? window->title : "";
 
-#ifdef X_HAVE_UTF8_STRING
-    Atom _NET_WM_NAME = data->videodata->_NET_WM_NAME;
-#endif
-
-    title_locale = SDL_iconv_utf8_locale(title);
-    if (!title_locale) {
-        SDL_OutOfMemory();
-        return;
-    }
-
-    status = X11_XStringListToTextProperty(&title_locale, 1, &titleprop);
-    SDL_free(title_locale);
-    if (status) {
-        X11_XSetTextProperty(display, data->xwindow, &titleprop, XA_WM_NAME);
-        X11_XFree(titleprop.value);
-    }
-#ifdef X_HAVE_UTF8_STRING
-    if (SDL_X11_HAVE_UTF8) {
-        status = X11_Xutf8TextListToTextProperty(display, (char **) &title, 1,
-                                            XUTF8StringStyle, &titleprop);
-        if (status == Success) {
-            X11_XSetTextProperty(display, data->xwindow, &titleprop,
-                                 _NET_WM_NAME);
-            X11_XFree(titleprop.value);
-        }
-    }
-#endif
-
-    X11_XFlush(display);
+    SDL_X11_SetWindowTitle(display, xwindow, title);
 }
 
 void
@@ -1107,6 +1091,36 @@ X11_SetWindowResizable(_THIS, SDL_Window * window, SDL_bool resizable)
     X11_XFlush(display);
 }
 
+void
+X11_SetWindowAlwaysOnTop(_THIS, SDL_Window * window, SDL_bool on_top)
+{
+    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
+    SDL_DisplayData *displaydata = (SDL_DisplayData *) SDL_GetDisplayForWindow(window)->driverdata;
+    Display *display = data->videodata->display;
+    Atom _NET_WM_STATE = data->videodata->_NET_WM_STATE;
+    Atom _NET_WM_STATE_ABOVE = data->videodata->_NET_WM_STATE_ABOVE;
+
+    if (X11_IsWindowMapped(_this, window)) {
+        XEvent e;
+
+        SDL_zero(e);
+        e.xany.type = ClientMessage;
+        e.xclient.message_type = _NET_WM_STATE;
+        e.xclient.format = 32;
+        e.xclient.window = data->xwindow;
+        e.xclient.data.l[0] =
+            on_top ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
+        e.xclient.data.l[1] = _NET_WM_STATE_ABOVE;
+        e.xclient.data.l[3] = 0l;
+
+        X11_XSendEvent(display, RootWindow(display, displaydata->screen), 0,
+                   SubstructureNotifyMask | SubstructureRedirectMask, &e);
+    } else {
+        X11_SetNetWMState(_this, data->xwindow, window->flags);
+    }
+    X11_XFlush(display);
+}
+
 void
 X11_ShowWindow(_THIS, SDL_Window * window)
 {
@@ -1126,6 +1140,7 @@ X11_ShowWindow(_THIS, SDL_Window * window)
 
     if (!data->videodata->net_wm) {
         /* no WM means no FocusIn event, which confuses us. Force it. */
+        X11_XSync(display, False);
         X11_XSetInputFocus(display, data->xwindow, RevertToNone, CurrentTime);
         X11_XFlush(display);
     }
@@ -1560,13 +1575,98 @@ X11_SetWindowGammaRamp(_THIS, SDL_Window * window, const Uint16 * ramp)
     return 0;
 }
 
-void
-X11_SetWindowGrab(_THIS, SDL_Window * window, SDL_bool grabbed)
+typedef struct {
+    unsigned char *data;
+    int format, count;
+    Atom type;
+} SDL_x11Prop;
+
+/* Reads property
+   Must call X11_XFree on results
+ */
+static void X11_ReadProperty(SDL_x11Prop *p, Display *disp, Window w, Atom prop)
+{
+    unsigned char *ret=NULL;
+    Atom type;
+    int fmt;
+    unsigned long count;
+    unsigned long bytes_left;
+    int bytes_fetch = 0;
+
+    do {
+        if (ret != 0) X11_XFree(ret);
+        X11_XGetWindowProperty(disp, w, prop, 0, bytes_fetch, False, AnyPropertyType, &type, &fmt, &count, &bytes_left, &ret);
+        bytes_fetch += bytes_left;
+    } while (bytes_left != 0);
+
+    p->data=ret;
+    p->format=fmt;
+    p->count=count;
+    p->type=type;
+}
+
+void*
+X11_GetWindowICCProfile(_THIS, SDL_Window * window, size_t * size)
 {
     SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
     Display *display = data->videodata->display;
+    XWindowAttributes attributes;
+    Atom icc_profile_atom;
+    char icc_atom_string[sizeof("_ICC_PROFILE_") + 12];
+    void* ret_icc_profile_data = NULL;
+    CARD8* icc_profile_data;
+    int real_format;
+    unsigned long real_nitems;
+    SDL_x11Prop atomProp;
+
+    X11_XGetWindowAttributes(display, X11_IsWindowLegacyFullscreen(_this, window) ? data->fswindow : data->xwindow, &attributes);
+    if (X11_XScreenNumberOfScreen(attributes.screen) > 0) {
+        SDL_snprintf(icc_atom_string, sizeof("_ICC_PROFILE_") + 12, "%s%d", "_ICC_PROFILE_", X11_XScreenNumberOfScreen(attributes.screen));
+    } else {
+        SDL_strlcpy(icc_atom_string, "_ICC_PROFILE", sizeof("_ICC_PROFILE"));
+    }
+    X11_XGetWindowAttributes(display, RootWindowOfScreen(attributes.screen), &attributes);
+
+    icc_profile_atom = X11_XInternAtom(display, icc_atom_string, True);
+    if (icc_profile_atom == None) {
+        SDL_SetError("Screen is not calibrated.\n");
+        return NULL;
+    }
+
+    X11_ReadProperty(&atomProp, display, RootWindowOfScreen(attributes.screen), icc_profile_atom);
+    real_format = atomProp.format;
+    real_nitems = atomProp.count;
+    icc_profile_data = atomProp.data;
+    if (real_format == None) {
+        SDL_SetError("Screen is not calibrated.\n");
+        return NULL;
+    }
+
+    ret_icc_profile_data = SDL_malloc(real_nitems);
+    if (!ret_icc_profile_data) {
+        SDL_OutOfMemory();
+        return NULL;
+    }
+
+    SDL_memcpy(ret_icc_profile_data, icc_profile_data, real_nitems);
+    *size = real_nitems;
+    X11_XFree(icc_profile_data);
+    
+    return ret_icc_profile_data;
+}
+
+void
+X11_SetWindowMouseGrab(_THIS, SDL_Window * window, SDL_bool grabbed)
+{
+    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
+    Display *display;
     SDL_bool oldstyle_fullscreen;
-    SDL_bool grab_keyboard;
+
+    if (data == NULL) {
+        return;
+    }
+
+    display = data->videodata->display;
 
     /* ICCCM2.0-compliant window managers can handle fullscreen windows
        If we're using XVidMode to change resolution we need to confine
@@ -1586,7 +1686,7 @@ X11_SetWindowGrab(_THIS, SDL_Window * window, SDL_bool grabbed)
         if (!data->videodata->broken_pointer_grab) {
             const unsigned int mask = ButtonPressMask | ButtonReleaseMask | PointerMotionMask | FocusChangeMask;
             int attempts;
-            int result;
+            int result = 0;
 
             /* Try for up to 5000ms (5s) to grab. If it still fails, stop trying. */
             for (attempts = 0; attempts < 100; attempts++) {
@@ -1604,24 +1704,46 @@ X11_SetWindowGrab(_THIS, SDL_Window * window, SDL_bool grabbed)
             }
         }
 
+        X11_Xinput2GrabTouch(_this, window);
+
         /* Raise the window if we grab the mouse */
         X11_XRaiseWindow(display, data->xwindow);
 
-        /* Now grab the keyboard */
-        if (SDL_GetHintBoolean(SDL_HINT_GRAB_KEYBOARD, SDL_FALSE)) {
-            grab_keyboard = SDL_TRUE;
-        } else {
-            /* We need to do this with the old style override_redirect
-               fullscreen window otherwise we won't get keyboard focus.
-            */
-            grab_keyboard = oldstyle_fullscreen;
-        }
-        if (grab_keyboard) {
-            X11_XGrabKeyboard(display, data->xwindow, True, GrabModeAsync,
-                          GrabModeAsync, CurrentTime);
+        /* Now grab the keyboard on old-style fullscreen */
+        if (oldstyle_fullscreen) {
+            X11_SetWindowKeyboardGrab(_this, window, SDL_TRUE);
         }
     } else {
         X11_XUngrabPointer(display, CurrentTime);
+
+        X11_Xinput2UngrabTouch(_this, window);
+    }
+    X11_XSync(display, False);
+}
+
+void
+X11_SetWindowKeyboardGrab(_THIS, SDL_Window * window, SDL_bool grabbed)
+{
+    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
+    Display *display;
+
+    if (data == NULL) {
+        return;
+    }
+
+    display = data->videodata->display;
+
+    if (grabbed) {
+        /* If the window is unmapped, XGrab calls return GrabNotViewable,
+           so when we get a MapNotify later, we'll try to update the grab as
+           appropriate. */
+        if (window->flags & SDL_WINDOW_HIDDEN) {
+            return;
+        }
+
+        X11_XGrabKeyboard(display, data->xwindow, True, GrabModeAsync,
+                          GrabModeAsync, CurrentTime);
+    } else {
         X11_XUngrabKeyboard(display, CurrentTime);
     }
     X11_XSync(display, False);
@@ -1659,6 +1781,13 @@ X11_DestroyWindow(_THIS, SDL_Window * window)
             X11_XFlush(display);
         }
         SDL_free(data);
+
+#if SDL_VIDEO_DRIVER_X11_XFIXES
+        /* If the pointer barriers are active for this, deactivate it.*/
+        if (videodata->active_cursor_confined_window == window) {
+            X11_DestroyPointerBarrier(_this, window);
+        }
+#endif /* SDL_VIDEO_DRIVER_X11_XFIXES */
     }
     window->driverdata = NULL;
 }
@@ -1712,6 +1841,87 @@ X11_AcceptDragAndDrop(SDL_Window * window, SDL_bool accept)
     }
 }
 
+int
+X11_FlashWindow(_THIS, SDL_Window * window, SDL_FlashOperation operation)
+{
+    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
+    Display *display = data->videodata->display;
+    XWMHints *wmhints;
+
+    wmhints = X11_XGetWMHints(display, data->xwindow);
+    if (!wmhints) {
+        return SDL_SetError("Couldn't get WM hints");
+    }
+
+    wmhints->flags &= ~XUrgencyHint;
+    data->flashing_window = SDL_FALSE;
+    data->flash_cancel_time = 0;
+
+    switch (operation) {
+    case SDL_FLASH_CANCEL:
+        /* Taken care of above */
+        break;
+    case SDL_FLASH_BRIEFLY:
+        if (!(window->flags & SDL_WINDOW_INPUT_FOCUS)) {
+            wmhints->flags |= XUrgencyHint;
+            data->flashing_window = SDL_TRUE;
+            /* On Ubuntu 21.04 this causes a dialog to pop up, so leave it up for a full second so users can see it */
+            data->flash_cancel_time = SDL_GetTicks() + 1000;
+            if (!data->flash_cancel_time) {
+                data->flash_cancel_time = 1;
+            }
+        }
+        break;
+    case SDL_FLASH_UNTIL_FOCUSED:
+        if (!(window->flags & SDL_WINDOW_INPUT_FOCUS)) {
+            wmhints->flags |= XUrgencyHint;
+            data->flashing_window = SDL_TRUE;
+        }
+        break;
+    default:
+        break;
+    }
+
+    X11_XSetWMHints(display, data->xwindow, wmhints);
+    X11_XFree(wmhints);
+    return 0;
+}
+
+int SDL_X11_SetWindowTitle(Display* display, Window xwindow, char* title) {
+    Atom _NET_WM_NAME = X11_XInternAtom(display, "_NET_WM_NAME", False);
+    XTextProperty titleprop;
+    int conv = X11_XmbTextListToTextProperty(display, (char**) &title, 1, XTextStyle, &titleprop);
+    Status status;
+
+    if (X11_XSupportsLocale() != True) {
+        return SDL_SetError("Current locale not supported by X server, cannot continue.");
+    }
+
+    if (conv == 0) {
+        X11_XSetTextProperty(display, xwindow, &titleprop, XA_WM_NAME);
+        X11_XFree(titleprop.value);
+    /* we know this can't be a locale error as we checked X locale validity */
+    } else if (conv < 0) {
+        return SDL_OutOfMemory();
+    } else { /* conv > 0 */
+        SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "%d characters were not convertable to the current locale!", conv);
+        return 0;
+    }
+
+#ifdef X_HAVE_UTF8_STRING
+    status = X11_Xutf8TextListToTextProperty(display, (char **) &title, 1, XUTF8StringStyle, &titleprop);
+    if (status == Success) {
+        X11_XSetTextProperty(display, xwindow, &titleprop, _NET_WM_NAME);
+        X11_XFree(titleprop.value);
+    } else {
+        return SDL_SetError("Failed to convert title to UTF8! Bad encoding, or bad Xorg encoding? Window title: «%s»", title);
+    }
+#endif
+
+    X11_XFlush(display);
+    return 0;
+}
+
 #endif /* SDL_VIDEO_DRIVER_X11 */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11window.h b/Engine/lib/sdl/src/video/x11/SDL_x11window.h
index 8178ffc14..6f1c71c67 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11window.h
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11window.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -68,9 +68,16 @@ typedef struct
     unsigned long user_time;
     Atom xdnd_req;
     Window xdnd_source;
+    SDL_bool flashing_window;
+    Uint32 flash_cancel_time;
 #if SDL_VIDEO_OPENGL_EGL  
     EGLSurface egl_surface;
 #endif
+#if SDL_VIDEO_DRIVER_X11_XFIXES
+    SDL_bool pointer_barrier_active;
+    PointerBarrier barrier[4];
+    SDL_Rect barrier_rect;
+#endif /* SDL_VIDEO_DRIVER_X11_XFIXES */
 } SDL_WindowData;
 
 extern void X11_SetNetWMState(_THIS, Window xwindow, Uint32 flags);
@@ -97,14 +104,20 @@ extern void X11_MinimizeWindow(_THIS, SDL_Window * window);
 extern void X11_RestoreWindow(_THIS, SDL_Window * window);
 extern void X11_SetWindowBordered(_THIS, SDL_Window * window, SDL_bool bordered);
 extern void X11_SetWindowResizable(_THIS, SDL_Window * window, SDL_bool resizable);
+extern void X11_SetWindowAlwaysOnTop(_THIS, SDL_Window * window, SDL_bool on_top);
 extern void X11_SetWindowFullscreen(_THIS, SDL_Window * window, SDL_VideoDisplay * display, SDL_bool fullscreen);
 extern int X11_SetWindowGammaRamp(_THIS, SDL_Window * window, const Uint16 * ramp);
-extern void X11_SetWindowGrab(_THIS, SDL_Window * window, SDL_bool grabbed);
+extern void* X11_GetWindowICCProfile(_THIS, SDL_Window * window, size_t * size);
+extern void X11_SetWindowMouseGrab(_THIS, SDL_Window * window, SDL_bool grabbed);
+extern void X11_SetWindowKeyboardGrab(_THIS, SDL_Window * window, SDL_bool grabbed);
 extern void X11_DestroyWindow(_THIS, SDL_Window * window);
 extern SDL_bool X11_GetWindowWMInfo(_THIS, SDL_Window * window,
                                     struct SDL_SysWMinfo *info);
 extern int X11_SetWindowHitTest(SDL_Window *window, SDL_bool enabled);
 extern void X11_AcceptDragAndDrop(SDL_Window * window, SDL_bool accept);
+extern int X11_FlashWindow(_THIS, SDL_Window * window, SDL_FlashOperation operation);
+
+int SDL_X11_SetWindowTitle(Display* display, Window xwindow, char* string);
 
 #endif /* SDL_x11window_h_ */
 
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11xfixes.c b/Engine/lib/sdl/src/video/x11/SDL_x11xfixes.c
new file mode 100644
index 000000000..95027d46b
--- /dev/null
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11xfixes.c
@@ -0,0 +1,206 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "../../SDL_internal.h"
+
+#if SDL_VIDEO_DRIVER_X11 && SDL_VIDEO_DRIVER_X11_XFIXES
+
+#include "SDL_x11video.h"
+#include "SDL_x11xfixes.h"
+#include "../../events/SDL_mouse_c.h"
+#include "../../events/SDL_touch_c.h"
+
+static int xfixes_initialized = 0;
+
+static int
+query_xfixes_version(Display *display, int major, int minor)
+{
+    /* We don't care if this fails, so long as it sets major/minor on it's way out the door. */
+    X11_XFixesQueryVersion(display, &major, &minor);
+    return ((major * 1000) + minor);
+}
+
+static SDL_bool
+xfixes_version_atleast(const int version, const int wantmajor, const int wantminor)
+{
+    return (version >= ((wantmajor * 1000) + wantminor));
+}
+
+void
+X11_InitXfixes(_THIS)
+{
+    SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
+
+    int version = 0;
+    int event, error;
+    int fixes_opcode;
+
+    if (!SDL_X11_HAVE_XFIXES ||
+        !X11_XQueryExtension(data->display, "XFIXES", &fixes_opcode, &event, &error)) {
+        return;
+    }
+
+    /* We need at least 5.0 for barriers. */
+    version = query_xfixes_version(data->display, 5, 0);
+    if (!xfixes_version_atleast(version, 5, 0)) {
+        return; /* X server does not support the version we want at all. */
+    }
+
+    xfixes_initialized = 1;
+}
+
+int
+X11_XfixesIsInitialized()
+{
+    return xfixes_initialized;
+}
+
+void
+X11_SetWindowMouseRect(_THIS, SDL_Window * window)
+{
+    if (SDL_RectEmpty(&window->mouse_rect)) {
+        X11_ConfineCursorWithFlags(_this, window, NULL, 0);
+    } else {
+        if (window->flags & SDL_WINDOW_INPUT_FOCUS) {
+            X11_ConfineCursorWithFlags(_this, window, &window->mouse_rect, 0);
+        } else {
+            /* Save the state for when we get focus again */
+            SDL_WindowData *wdata = (SDL_WindowData *) window->driverdata;
+
+            SDL_memcpy(&wdata->barrier_rect, &window->mouse_rect, sizeof(wdata->barrier_rect));
+
+            wdata->pointer_barrier_active = SDL_TRUE;
+        }
+    }
+}
+
+int
+X11_ConfineCursorWithFlags(_THIS, SDL_Window * window, const SDL_Rect * rect, int flags)
+{
+    /* Yaakuro: For some reason Xfixes when confining inside a rect where the
+     * edges exactly match, a rectangle the cursor 'slips' out of the barrier.
+     * To prevent that the lines for the barriers will span the whole screen.
+     */
+    SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
+    SDL_WindowData *wdata;
+
+    if (!X11_XfixesIsInitialized()) {
+        return SDL_Unsupported();
+    }
+
+    /* If there is already a set of barriers active, disable them. */
+    if (data->active_cursor_confined_window) {
+         X11_DestroyPointerBarrier(_this, data->active_cursor_confined_window);
+    }
+
+    SDL_assert(window != NULL);
+    wdata = (SDL_WindowData *) window->driverdata;
+
+    /* If user did not specify an area to confine, destroy the barrier that was/is assigned to
+     * this window it was assigned */
+    if (rect) {
+        int x1, y1, x2, y2;
+        SDL_Rect bounds;
+        SDL_GetWindowPosition(window, &bounds.x, &bounds.y);
+        SDL_GetWindowSize(window, &bounds.w, &bounds.h);
+
+        /** Negative values are not allowed. Clip values relative to the specified window. */
+        x1 = bounds.x + SDL_max(rect->x, 0);
+        y1 = bounds.y + SDL_max(rect->y, 0);
+        x2 = SDL_min(bounds.x + rect->x + rect->w, bounds.x + bounds.w);
+        y2 = SDL_min(bounds.y + rect->y + rect->h, bounds.y + bounds.h);
+
+        if ((wdata->barrier_rect.x != rect->x) ||
+            (wdata->barrier_rect.y != rect->y) ||
+            (wdata->barrier_rect.w != rect->w) ||
+            (wdata->barrier_rect.h != rect->h)) {
+            wdata->barrier_rect = *rect;
+        }
+
+        /* Use the display bounds to ensure the barriers don't have corner gaps */
+        SDL_GetDisplayBounds(SDL_GetWindowDisplayIndex(window), &bounds);
+
+        /** Create the left barrier */
+        wdata->barrier[0] = X11_XFixesCreatePointerBarrier(data->display, wdata->xwindow,
+                                             x1, bounds.y,
+                                             x1, bounds.y + bounds.h,
+                                             BarrierPositiveX,
+                                             0, NULL);
+        /** Create the right barrier */
+        wdata->barrier[1] = X11_XFixesCreatePointerBarrier(data->display, wdata->xwindow,
+                                             x2, bounds.y,
+                                             x2, bounds.y + bounds.h,
+                                             BarrierNegativeX,
+                                             0, NULL);
+        /** Create the top barrier */
+        wdata->barrier[2] = X11_XFixesCreatePointerBarrier(data->display, wdata->xwindow,
+                                             bounds.x, y1,
+                                             bounds.x + bounds.w, y1,
+                                             BarrierPositiveY,
+                                             0, NULL);
+        /** Create the bottom barrier */
+        wdata->barrier[3] = X11_XFixesCreatePointerBarrier(data->display, wdata->xwindow,
+                                             bounds.x, y2,
+                                             bounds.x + bounds.w, y2,
+                                             BarrierNegativeY,
+                                             0, NULL);
+
+        X11_XFlush(data->display);
+
+        /* Lets remember current active confined window. */
+        data->active_cursor_confined_window = window;
+
+        /* User activated the confinement for this window. We use this later to reactivate
+         * the confinement if it got deactivated by FocusOut or UnmapNotify */
+        wdata->pointer_barrier_active = SDL_TRUE;
+    } else {
+        X11_DestroyPointerBarrier(_this, window);
+
+        /* Only set barrier inactive when user specified NULL and not handled by focus out. */
+        if (flags != X11_BARRIER_HANDLED_BY_EVENT) {
+            wdata->pointer_barrier_active = SDL_FALSE;
+        }
+    }
+    return 0;
+}
+
+void
+X11_DestroyPointerBarrier(_THIS, SDL_Window * window)
+{
+    int i;
+    SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
+    if (window) {
+        SDL_WindowData *wdata = (SDL_WindowData *) window->driverdata;
+
+        for (i = 0; i < 4; i++) {
+            if (wdata->barrier[i] > 0) {
+                X11_XFixesDestroyPointerBarrier(data->display, wdata->barrier[i]);
+                wdata->barrier[i] = 0;
+            }
+        }
+        X11_XFlush(data->display);
+    }
+    data->active_cursor_confined_window = NULL;
+}
+
+#endif /* SDL_VIDEO_DRIVER_X11 && SDL_VIDEO_DRIVER_X11_XFIXES */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11xfixes.h b/Engine/lib/sdl/src/video/x11/SDL_x11xfixes.h
new file mode 100644
index 000000000..7239d3fd2
--- /dev/null
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11xfixes.h
@@ -0,0 +1,41 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "../../SDL_internal.h"
+
+#ifndef SDL_x11xfixes_h_
+#define SDL_x11xfixes_h_
+
+#if SDL_VIDEO_DRIVER_X11_XFIXES
+
+#define X11_BARRIER_HANDLED_BY_EVENT 1
+
+extern void X11_InitXfixes(_THIS);
+extern int X11_XfixesIsInitialized(void);
+extern void X11_SetWindowMouseRect(_THIS, SDL_Window * window);
+extern int X11_ConfineCursorWithFlags(_THIS, SDL_Window * window, const SDL_Rect * rect, int flags);
+extern void X11_DestroyPointerBarrier(_THIS, SDL_Window * window);
+
+#endif /* SDL_VIDEO_DRIVER_X11_XFIXES */
+
+#endif /* SDL_x11xfixes_h_ */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11xinput2.c b/Engine/lib/sdl/src/video/x11/SDL_x11xinput2.c
index 97430b480..abfbdf0e3 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11xinput2.c
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11xinput2.c
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -343,6 +343,50 @@ X11_Xinput2IsMultitouchSupported()
 #endif
 }
 
+void
+X11_Xinput2GrabTouch(_THIS, SDL_Window *window)
+{
+#if SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH
+    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
+    Display *display = data->videodata->display;
+
+    unsigned char mask[4] = { 0, 0, 0, 0 };
+    XIGrabModifiers mods;
+    XIEventMask eventmask;
+
+    mods.modifiers = XIAnyModifier;
+    mods.status = 0;
+
+    eventmask.deviceid = XIAllDevices;
+    eventmask.mask_len = sizeof(mask);
+    eventmask.mask = mask;
+
+    XISetMask(eventmask.mask, XI_TouchBegin);
+    XISetMask(eventmask.mask, XI_TouchUpdate);
+    XISetMask(eventmask.mask, XI_TouchEnd);
+    XISetMask(eventmask.mask, XI_Motion);
+
+    X11_XIGrabTouchBegin(display, XIAllDevices, data->xwindow, True, &eventmask, 1, &mods);
+#endif
+}
+
+void
+X11_Xinput2UngrabTouch(_THIS, SDL_Window *window)
+{
+#if SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH
+    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
+    Display *display = data->videodata->display;
+
+    XIGrabModifiers mods;
+
+    mods.modifiers = XIAnyModifier;
+    mods.status = 0;
+
+    X11_XIUngrabTouchBegin(display, XIAllDevices, data->xwindow, 1, &mods);
+#endif
+}
+
+
 #endif /* SDL_VIDEO_DRIVER_X11 */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11xinput2.h b/Engine/lib/sdl/src/video/x11/SDL_x11xinput2.h
index 022d81f36..679beb97b 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11xinput2.h
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11xinput2.h
@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -36,6 +36,8 @@ extern int X11_HandleXinput2Event(SDL_VideoData *videodata,XGenericEventCookie *
 extern int X11_Xinput2IsInitialized(void);
 extern int X11_Xinput2IsMultitouchSupported(void);
 extern void X11_Xinput2SelectTouch(_THIS, SDL_Window *window);
+extern void X11_Xinput2GrabTouch(_THIS, SDL_Window *window);
+extern void X11_Xinput2UngrabTouch(_THIS, SDL_Window *window);
 
 #endif /* SDL_x11xinput2_h_ */
 
diff --git a/Engine/lib/sdl/src/video/x11/edid-parse.c b/Engine/lib/sdl/src/video/x11/edid-parse.c
index e22324f2c..c717f1b1f 100644
--- a/Engine/lib/sdl/src/video/x11/edid-parse.c
+++ b/Engine/lib/sdl/src/video/x11/edid-parse.c
@@ -50,7 +50,7 @@ get_bits (int in, int begin, int end)
 static int
 decode_header (const uchar *edid)
 {
-    if (memcmp (edid, "\x00\xff\xff\xff\xff\xff\xff\x00", 8) == 0)
+    if (SDL_memcmp (edid, "\x00\xff\xff\xff\xff\xff\xff\x00", 8) == 0)
 	return TRUE;
     return FALSE;
 }
@@ -76,7 +76,7 @@ decode_vendor_and_product_identification (const uchar *edid, MonitorInfo *info)
 
     /* Serial Number */
     info->serial_number =
-	edid[0x0c] | edid[0x0d] << 8 | edid[0x0e] << 16 | edid[0x0f] << 24;
+	edid[0x0c] | edid[0x0d] << 8 | edid[0x0e] << 16 | (Uint32)edid[0x0f] << 24;
 
     /* Week and Year */
     is_model_year = FALSE;
@@ -522,7 +522,7 @@ decode_check_sum (const uchar *edid,
 MonitorInfo *
 decode_edid (const uchar *edid)
 {
-    MonitorInfo *info = calloc (1, sizeof (MonitorInfo));
+    MonitorInfo *info = SDL_calloc (1, sizeof (MonitorInfo));
 
     decode_check_sum (edid, info);
     
@@ -534,8 +534,8 @@ decode_edid (const uchar *edid)
         !decode_established_timings (edid, info) ||
         !decode_standard_timings (edid, info) ||
         !decode_descriptors (edid, info)) {
-        free(info);
-	return NULL;
+        SDL_free(info);
+        return NULL;
     }
     
     return info;
diff --git a/Engine/lib/sdl/src/video/yuv2rgb/yuv_rgb.c b/Engine/lib/sdl/src/video/yuv2rgb/yuv_rgb.c
index 6e821a8b3..7908b8c48 100644
--- a/Engine/lib/sdl/src/video/yuv2rgb/yuv_rgb.c
+++ b/Engine/lib/sdl/src/video/yuv2rgb/yuv_rgb.c
@@ -91,7 +91,7 @@ static uint8_t clampU8(int32_t v)
 	255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
 	255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255
 	};
-	return lut[(v+128*PRECISION_FACTOR)>>PRECISION];
+	return lut[((v+128*PRECISION_FACTOR)>>PRECISION)&511];
 }
 
 
diff --git a/Engine/lib/sdl/src/video/yuv2rgb/yuv_rgb_sse_func.h b/Engine/lib/sdl/src/video/yuv2rgb/yuv_rgb_sse_func.h
index f81140e18..3c5ee0db4 100644
--- a/Engine/lib/sdl/src/video/yuv2rgb/yuv_rgb_sse_func.h
+++ b/Engine/lib/sdl/src/video/yuv2rgb/yuv_rgb_sse_func.h
@@ -415,6 +415,17 @@ void SSE_FUNCTION_NAME(uint32_t width, uint32_t height,
 #error Unknown RGB pixel size
 #endif
 
+#if YUV_FORMAT == YUV_FORMAT_NV12
+	/* For NV12 formats (where U/V are interleaved)
+	 * SSE READ_UV does an invalid read access at the very last pixel.
+	 * As a workaround. Make sure not to decode the last column using assembly but with STD fallback path.
+	 * see https://github.com/libsdl-org/SDL/issues/4841
+	 */
+	const int fix_read_nv12 = ((width & 31) == 0);
+#else
+	const int fix_read_nv12 = 0;
+#endif
+
 	if (width >= 32) {
 		uint32_t xpos, ypos;
 		for(ypos=0; ypos<(height-(uv_y_sample_interval-1)); ypos+=uv_y_sample_interval)
@@ -427,7 +438,7 @@ void SSE_FUNCTION_NAME(uint32_t width, uint32_t height,
 			uint8_t *rgb_ptr1=RGB+ypos*RGB_stride,
 				*rgb_ptr2=RGB+(ypos+1)*RGB_stride;
 			
-			for(xpos=0; xpos<(width-31); xpos+=32)
+			for(xpos=0; xpos<(width-31) - fix_read_nv12; xpos+=32)
 			{
 				YUV2RGB_32
 				{
@@ -464,6 +475,9 @@ void SSE_FUNCTION_NAME(uint32_t width, uint32_t height,
 	/* Catch the right column, if needed */
 	{
 		int converted = (width & ~31);
+		if (fix_read_nv12) {
+			converted -= 32;
+		}
 		if (converted != width)
 		{
 			const uint8_t *y_ptr=Y+converted*y_pixel_stride,
diff --git a/Engine/lib/sdl/test/CMakeLists.txt b/Engine/lib/sdl/test/CMakeLists.txt
index 879800575..330af47c4 100644
--- a/Engine/lib/sdl/test/CMakeLists.txt
+++ b/Engine/lib/sdl/test/CMakeLists.txt
@@ -1,21 +1,56 @@
-cmake_minimum_required(VERSION 2.8.11)
+cmake_minimum_required(VERSION 3.0.0)
 project(SDL2 C)
 
 # Global settings for all of the test targets
 # FIXME: is this wrong?
 remove_definitions(-DUSING_GENERATED_CONFIG_H)
-link_libraries(SDL2_test SDL2-static)
 
-# FIXME: Parent directory CMakeLists.txt only sets these for mingw/cygwin,
-# but we need them for VS as well.
+if(PSP)
+    link_libraries(
+        SDL2main
+        SDL2_test
+        SDL2-static
+        GL
+        pspvram
+        pspvfpu
+        pspdisplay
+        pspgu
+        pspge
+        pspaudio
+        pspctrl
+        psphprm
+        psppower
+    )
+else()
+    link_libraries(SDL2_test SDL2-static)
+endif()
+
 if(WINDOWS)
+    # mingw32 must come before SDL2main to link successfully
+    if(MINGW OR CYGWIN)
+        link_libraries(mingw32)
+    endif()
+
+    # FIXME: Parent directory CMakeLists.txt only sets these for mingw/cygwin,
+    # but we need them for VS as well.
     link_libraries(SDL2main)
     add_definitions(-Dmain=SDL_main)
 endif()
 
+# CMake incorrectly detects opengl32.lib being present on MSVC ARM64
+if(NOT MSVC OR NOT CMAKE_GENERATOR_PLATFORM STREQUAL "ARM64")
+    find_package(OpenGL)
+endif()
+
+if (OPENGL_FOUND)
+add_definitions(-DHAVE_OPENGL)
+endif()
+
 add_executable(checkkeys checkkeys.c)
+add_executable(checkkeysthreads checkkeysthreads.c)
 add_executable(loopwave loopwave.c)
 add_executable(loopwavequeue loopwavequeue.c)
+add_executable(testsurround testsurround.c)
 add_executable(testresample testresample.c)
 add_executable(testaudioinfo testaudioinfo.c)
 
@@ -35,6 +70,7 @@ add_executable(testdropfile testdropfile.c)
 add_executable(testerror testerror.c)
 add_executable(testfile testfile.c)
 add_executable(testgamecontroller testgamecontroller.c)
+add_executable(testgeometry testgeometry.c)
 add_executable(testgesture testgesture.c)
 add_executable(testgl2 testgl2.c)
 add_executable(testgles testgles.c)
@@ -49,6 +85,7 @@ add_executable(testjoystick testjoystick.c)
 add_executable(testkeys testkeys.c)
 add_executable(testloadso testloadso.c)
 add_executable(testlock testlock.c)
+add_executable(testmouse testmouse.c)
 
 if(APPLE)
     add_executable(testnative testnative.c
@@ -88,43 +125,151 @@ add_executable(controllermap controllermap.c)
 add_executable(testvulkan testvulkan.c)
 add_executable(testoffscreen testoffscreen.c)
 
-# HACK: Dummy target to cause the resource files to be copied to the build directory.
-# Need to make it an executable so we can use the TARGET_FILE_DIR generator expression.
-# This is needed so they get copied to the correct Debug/Release subdirectory in Xcode.
-file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/resources_dummy.c "int main(int argc, const char **argv){ return 1; }\n")
-add_executable(SDL2_test_resoureces ${CMAKE_CURRENT_BINARY_DIR}/resources_dummy.c)
-
-file(GLOB RESOURCE_FILES *.bmp *.wav moose.dat utf8.txt)
-foreach(RESOURCE_FILE ${RESOURCE_FILES})
-    add_custom_command(TARGET SDL2_test_resoureces POST_BUILD COMMAND ${CMAKE_COMMAND} ARGS -E copy_if_different ${RESOURCE_FILE} $<TARGET_FILE_DIR:SDL2_test_resoureces>)
-endforeach(RESOURCE_FILE)
+if(OPENGL_FOUND)
+add_dependencies(testshader OpenGL::GL)
+add_dependencies(testgl2 OpenGL::GL)
+target_link_libraries(testshader OpenGL::GL)
+target_link_libraries(testgl2 OpenGL::GL)
+endif()
 
+file(GLOB RESOURCE_FILES *.bmp *.wav *.hex moose.dat utf8.txt)
 file(COPY ${RESOURCE_FILES} DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
+if(PSP)
+    set(NEEDS_RESOURCES
+        testscale
+        testrendercopyex
+        controllermap
+        testyuv
+        testgamecontroller
+        testshape
+        testshader
+        testspriteminimal
+        testautomation
+        testrendertarget
+        testsprite2
+        loopwave
+        loopwavequeue
+        testresample
+        testaudiohotplug
+        testmultiaudio
+        testiconv
+        testoverlay2
+        teststreaming
+        testviewport
+    )
+else()
+    set(NEEDS_RESOURCES
+        testscale
+        testrendercopyex
+        controllermap
+        testyuv
+        testgamecontroller
+        testshape
+        testshader
+        testspriteminimal
+        testautomation
+        testcustomcursor
+        testrendertarget
+        testsprite2
+        loopwave
+        loopwavequeue
+        testresample
+        testaudiohotplug
+        testmultiaudio
+        testime
+        testnative
+        testiconv
+        testoverlay2
+        teststreaming
+        testviewport
+    )
+endif()
 
-# TODO: Might be easier to make all targets depend on the resources...?
+if(PSP)
+    # Build EBOOT files if building for PSP
+    set(BUILD_EBOOT
+        ${NEEDS_RESOURCES}
+        testbounds
+        testgl2
+        testsem
+        testdisplayinfo
+        teststreaming
+        testgeometry
+        testfile
+        testdraw2
+        testviewport
+        testhittesting
+        testoverlay2
+        testver
+        testdrawchessboard
+        testsurround
+        testintersections
+        testmessage
+        testaudiocapture
+        testerror
+        testatomic
+        testjoystick
+        testiconv
+        testfilesystem
+        testplatform
+        testthread
+        testqsort
+        testaudioinfo
+        testlock
+        testtimer
+        testpower
+        testwm2
+        torturethread
+    )
+    foreach(APP IN LISTS BUILD_EBOOT)
+        create_pbp_file(
+            TARGET          ${APP}
+            TITLE           SDL-${APP}
+            ICON_PATH       NULL
+            BACKGROUND_PATH NULL
+            PREVIEW_PATH    NULL
+        )
+        add_custom_command(
+            TARGET ${APP} POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E make_directory
+            $<TARGET_FILE_DIR:${ARG_TARGET}>/sdl-${APP}
+        )
+        add_custom_command(
+            TARGET ${APP} POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E rename
+            $<TARGET_FILE_DIR:${ARG_TARGET}>/EBOOT.PBP
+            $<TARGET_FILE_DIR:${ARG_TARGET}>/sdl-${APP}/EBOOT.PBP
+        )
+        if(${BUILD_PRX})
+            add_custom_command(
+                TARGET ${APP} POST_BUILD
+                COMMAND ${CMAKE_COMMAND} -E copy
+                $<TARGET_FILE_DIR:${ARG_TARGET}>/${APP}
+                $<TARGET_FILE_DIR:${ARG_TARGET}>/sdl-${APP}/${APP}
+            )
+            add_custom_command(
+                TARGET ${APP} POST_BUILD
+                COMMAND ${CMAKE_COMMAND} -E rename
+                $<TARGET_FILE_DIR:${ARG_TARGET}>/${APP}.prx
+                $<TARGET_FILE_DIR:${ARG_TARGET}>/sdl-${APP}/${APP}.prx
+            )
+        endif()
+        add_custom_command(
+            TARGET ${APP} POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E remove
+            $<TARGET_FILE_DIR:${ARG_TARGET}>/PARAM.SFO
+        )
+    endforeach()
+endif()
 
-set(NEEDS_RESOURCES
-    testscale
-    testrendercopyex
-    controllermap
-    testyuv
-    testgamecontroller
-    testshape
-    testshader
-    testnative
-    testspriteminimal
-    testautomation
-    testcustomcursor
-    testrendertarget
-    testsprite2
-    loopwave
-    loopwavequeue
-    testresample
-    testaudiohotplug
-    testmultiaudio
-)
 foreach(APP IN LISTS NEEDS_RESOURCES)
-    add_dependencies(${APP} SDL2_test_resoureces)
+    foreach(RESOURCE_FILE ${RESOURCE_FILES})
+        if(PSP)
+            add_custom_command(TARGET ${APP} POST_BUILD COMMAND ${CMAKE_COMMAND} ARGS -E copy_if_different ${RESOURCE_FILE} $<TARGET_FILE_DIR:${APP}>/sdl-${APP})
+        else()
+            add_custom_command(TARGET ${APP} POST_BUILD COMMAND ${CMAKE_COMMAND} ARGS -E copy_if_different ${RESOURCE_FILE} $<TARGET_FILE_DIR:${APP}>)
+        endif()
+    endforeach(RESOURCE_FILE)
     if(APPLE)
         # Make sure resource files get installed into macOS/iOS .app bundles.  
         target_sources(${APP} PRIVATE "${RESOURCE_FILES}")
diff --git a/Engine/lib/sdl/test/Makefile.in b/Engine/lib/sdl/test/Makefile.in
index 8c3bbf2a1..d29dc6ecf 100644
--- a/Engine/lib/sdl/test/Makefile.in
+++ b/Engine/lib/sdl/test/Makefile.in
@@ -9,6 +9,7 @@ LIBS	= @LIBS@
 
 TARGETS = \
 	checkkeys$(EXE) \
+	checkkeysthreads$(EXE) \
 	controllermap$(EXE) \
 	loopwave$(EXE) \
 	loopwavequeue$(EXE) \
@@ -28,6 +29,7 @@ TARGETS = \
 	testfile$(EXE) \
 	testfilesystem$(EXE) \
 	testgamecontroller$(EXE) \
+	testgeometry$(EXE) \
 	testgesture$(EXE) \
 	testhaptic$(EXE) \
 	testhittesting$(EXE) \
@@ -41,6 +43,7 @@ TARGETS = \
 	testlocale$(EXE) \
 	testlock$(EXE) \
 	testmessage$(EXE) \
+	testmouse$(EXE) \
 	testmultiaudio$(EXE) \
 	testnative$(EXE) \
 	testoverlay2$(EXE) \
@@ -59,6 +62,7 @@ TARGETS = \
 	testsprite2$(EXE) \
 	testspriteminimal$(EXE) \
 	teststreaming$(EXE) \
+	testsurround$(EXE) \
 	testthread$(EXE) \
 	testtimer$(EXE) \
 	testurl$(EXE) \
@@ -69,7 +73,7 @@ TARGETS = \
 	testyuv$(EXE) \
 	torturethread$(EXE) \
 
-	
+
 @OPENGL_TARGETS@ += testgl2$(EXE) testshader$(EXE)
 @OPENGLES1_TARGETS@ += testgles$(EXE)
 @OPENGLES2_TARGETS@ += testgles2$(EXE)
@@ -83,12 +87,18 @@ Makefile: $(srcdir)/Makefile.in
 checkkeys$(EXE): $(srcdir)/checkkeys.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
 
+checkkeysthreads$(EXE): $(srcdir)/checkkeysthreads.c
+	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
+
 loopwave$(EXE): $(srcdir)/loopwave.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
 
 loopwavequeue$(EXE): $(srcdir)/loopwavequeue.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
 
+testsurround$(EXE): $(srcdir)/testsurround.c
+	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
+
 testresample$(EXE): $(srcdir)/testresample.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
 
@@ -157,7 +167,10 @@ testfile$(EXE): $(srcdir)/testfile.c
 
 testgamecontroller$(EXE): $(srcdir)/testgamecontroller.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
- 
+
+testgeometry$(EXE): $(srcdir)/testgeometry.c
+	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
+
 testgesture$(EXE): $(srcdir)/testgesture.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS) @MATHLIB@
  
@@ -170,6 +183,9 @@ testgles$(EXE): $(srcdir)/testgles.c
 testgles2$(EXE): $(srcdir)/testgles2.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS) @MATHLIB@
 
+testgles2_sdf$(EXE): $(srcdir)/testgles2_sdf.c
+	$(CC) -o $@ $^ $(CFLAGS) $(LIBS) @MATHLIB@
+
 testhaptic$(EXE): $(srcdir)/testhaptic.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
 
@@ -219,14 +235,22 @@ testnative$(EXE): $(srcdir)/testnative.c \
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS) @XLIB@
 endif
 
+ifeq (@ISOS2@,true)
+testnative$(EXE): $(srcdir)/testnative.c \
+			$(srcdir)/testnativeos2.c
+	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
+endif
+
 #there's probably a better way of doing this
 ifeq (@ISMACOSX@,false)
 ifeq (@ISWINDOWS@,false)
 ifeq (@ISUNIX@,false)
+ifeq (@ISOS2@,false)
 testnative$(EXE): ;
 endif
 endif
 endif
+endif
 
 testoverlay2$(EXE): $(srcdir)/testoverlay2.c $(srcdir)/testyuv_cvt.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
@@ -315,6 +339,8 @@ testvulkan$(EXE): $(srcdir)/testvulkan.c
 testlocale$(EXE): $(srcdir)/testlocale.c
 	$(CC) -o $@ $? $(CFLAGS) $(LIBS)
 
+testmouse$(EXE): $(srcdir)/testmouse.c
+	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
 
 
 clean:
@@ -325,26 +351,25 @@ distclean: clean
 	rm -f config.status config.cache config.log
 	rm -rf $(srcdir)/autom4te*
 
+DATA = \
+	axis.bmp \
+	button.bmp \
+	controllermap.bmp \
+	controllermap_back.bmp \
+	icon.bmp \
+	moose.dat \
+	sample.bmp \
+	sample.wav \
+	testgles2_sdf_img_normal.bmp \
+	testgles2_sdf_img_sdf.bmp \
+	testyuv.bmp \
+	unifont-13.0.06.hex \
+	$(NULL)
+
 ifneq ($(srcdir), .)
-%.bmp: $(srcdir)/%.bmp
-	cp $< $@
-
-%.wav: $(srcdir)/%.wav
-	cp $< $@
-
-%.dat: $(srcdir)/%.dat
+$(DATA) : %: $(srcdir)/% Makefile
 	cp $< $@
 endif
 
-copydatafiles: copybmpfiles copywavfiles copydatfiles
+copydatafiles: $(DATA)
 .PHONY : copydatafiles
-
-copybmpfiles: $(foreach bmp,$(wildcard $(srcdir)/*.bmp),$(notdir $(bmp)))
-.PHONY : copybmpfiles
-
-copywavfiles: $(foreach wav,$(wildcard $(srcdir)/*.wav),$(notdir $(wav)))
-.PHONY : copywavfiles
-
-copydatfiles: $(foreach dat,$(wildcard $(srcdir)/*.dat),$(notdir $(dat)))
-.PHONY : copydatfiles
-
diff --git a/Engine/lib/sdl/test/Makefile.os2 b/Engine/lib/sdl/test/Makefile.os2
index 922dffaf1..e238af4be 100644
--- a/Engine/lib/sdl/test/Makefile.os2
+++ b/Engine/lib/sdl/test/Makefile.os2
@@ -1,8 +1,20 @@
-BINPATH = .
+# Open Watcom makefile to build SDL2 tests for OS/2
+# wmake -f Makefile.os2
+
+INCPATH = -I"$(%WATCOM)/h/os2" -I"$(%WATCOM)/h" -I"../include"
+
+CFLAGS = $(INCPATH) -bt=os2 -d0 -q -bm -5s -fp5 -fpi87 -sg -oteanbmier -ei
+CFLAGS+= -wx -wcd=303
+
+LIBPATH = ..
+LIBS    = SDL2.lib SDL2test.lib
+
+#CFLAGS+= -DHAVE_SDL_TTF
+#TTFLIBS = SDL2ttf.lib
 
 TARGETS = testatomic.exe testdisplayinfo.exe testbounds.exe testdraw2.exe &
           testdrawchessboard.exe testdropfile.exe testerror.exe testfile.exe &
-          testfilesystem.exe testgamecontroller.exe testgesture.exe &
+          testfilesystem.exe testgamecontroller.exe testgeometry.exe testgesture.exe &
           testhittesting.exe testhotplug.exe testiconv.exe testime.exe testlocale.exe &
           testintersections.exe testjoystick.exe testkeys.exe testloadso.exe &
           testlock.exe testmessage.exe testoverlay2.exe testplatform.exe &
@@ -11,21 +23,13 @@ TARGETS = testatomic.exe testdisplayinfo.exe testbounds.exe testdraw2.exe &
           testshader.exe testshape.exe testsprite2.exe testspriteminimal.exe &
           teststreaming.exe testthread.exe testtimer.exe testver.exe &
           testviewport.exe testwm2.exe torturethread.exe checkkeys.exe &
+          checkkeysthreads.exe testmouse.exe &
           controllermap.exe testhaptic.exe testqsort.exe testresample.exe &
           testaudioinfo.exe testaudiocapture.exe loopwave.exe loopwavequeue.exe &
-          testyuv.exe testgl2.exe testvulkan.exe testnative.exe testautomation.exe
-
-# SDL2test.lib sources (../src/test)
-
-CSRCS = SDL_test_assert.c SDL_test_common.c SDL_test_compare.c &
-        SDL_test_crc32.c SDL_test_font.c SDL_test_fuzzer.c SDL_test_harness.c &
-        SDL_test_imageBlit.c SDL_test_imageBlitBlend.c SDL_test_imageFace.c &
-        SDL_test_imagePrimitives.c SDL_test_imagePrimitivesBlend.c &
-        SDL_test_log.c SDL_test_md5.c SDL_test_random.c SDL_test_memory.c
-TESTLIB = SDL2test.lib
+          testsurround.exe testyuv.exe testgl2.exe testvulkan.exe testnative.exe &
+          testautomation.exe
 
 # testautomation sources
-
 TASRCS = testautomation.c testautomation_audio.c testautomation_clipboard.c &
          testautomation_events.c testautomation_hints.c &
          testautomation_keyboard.c testautomation_main.c &
@@ -42,23 +46,9 @@ TAOBJS = $(TASRCS:.c=.obj)
 
 all: $(TARGETS)
 
-INCPATH = -I$(%WATCOM)/h/os2 -I$(%WATCOM)/h -I../include
-
-CFLAGS = $(INCPATH) -bt=os2 -d0 -q -bm -5s -fp5 -fpi87 -sg -oteanbmier -ei
-
-LIBPATH = ..
-LIBS    = SDL2.lib $(TESTLIB)
-
-#CFLAGS+= -DHAVE_SDL_TTF
-#LIBS_TTF = SDL2ttf.lib
-
 .c: ../src/test
 
-$(TESTLIB): $(COBJS)
-  wlib -q -b -n -c $@ $(COBJS)
-
 .obj.exe:
-  @%make $(TESTLIB)
   wlink SYS os2v2 libpath $(LIBPATH) lib {$(LIBS)} op q op el file {$<} name $@
 
 .c.obj:
@@ -66,30 +56,22 @@ $(TESTLIB): $(COBJS)
 
 # specials
 testautomation.exe: $(TAOBJS)
-  @%make $(TESTLIB)
   wlink SYS os2v2 libpath $(LIBPATH) lib {$(LIBS)} op q op el file {$<} name $@
 
 testnative.exe: testnative.obj testnativeos2.obj
-  @%make $(TESTLIB)
   wlink SYS os2v2 libpath $(LIBPATH) lib {$(LIBS)} op q op el file {$<} name $@
 
 testoverlay2.exe: testoverlay2.obj testyuv_cvt.obj
-  @%make $(TESTLIB)
   wlink SYS os2v2 libpath $(LIBPATH) lib {$(LIBS)} op q op el file {$<} name $@
 
 testyuv.exe: testyuv.obj testyuv_cvt.obj
-  @%make $(TESTLIB)
   wlink SYS os2v2 libpath $(LIBPATH) lib {$(LIBS)} op q op el file {$<} name $@
 
 testime.exe: testime.obj
-  @%make $(TESTLIB)
-  wlink SYS os2v2 libpath $(LIBPATH) lib {$(LIBS) $(LIBS_TTF)} op q op el file {$<} name $@
+  wlink SYS os2v2 libpath $(LIBPATH) lib {$(LIBS) $(TTFLIBS)} op q op el file {$<} name $@
 
 clean: .SYMBOLIC
-  @echo * Clean tests in $(BINPATH)
   @if exist *.obj rm *.obj
   @if exist *.err rm *.err
-
 distclean: .SYMBOLIC clean
   @if exist *.exe rm *.exe
-  @if exist $(TESTLIB) rm $(TESTLIB)
diff --git a/Engine/lib/sdl/test/README b/Engine/lib/sdl/test/README
index 8329cb96f..b1ee0892e 100644
--- a/Engine/lib/sdl/test/README
+++ b/Engine/lib/sdl/test/README
@@ -4,6 +4,7 @@ These are test programs for the SDL library:
 	checkkeys	Watch the key events to check the keyboard
 	loopwave	Audio test -- loop playing a WAV file
 	loopwavequeue	Audio test -- loop playing a WAV file with SDL_QueueAudio
+	testsurround	Audio test -- play test tone on each audio channel
 	testaudioinfo	Lists audio device capabilities
 	testerror	Tests multi-threaded error handling
 	testfile	Tests RWops layer
@@ -14,6 +15,7 @@ These are test programs for the SDL library:
 	testloadso	Tests the loadable library layer
 	testlocale  Test Locale API
 	testlock	Hacked up test of multi-threading and locking
+	testmouse	Tests mouse coordinates
 	testmultiaudio	Tests using several audio devices
 	testoverlay2	Tests the overlay flickering/scaling during playback.
 	testplatform	Tests types, endianness and cpu capabilities
diff --git a/Engine/lib/sdl/test/acinclude.m4 b/Engine/lib/sdl/test/acinclude.m4
index e2180a3ab..0fdf353ea 100644
--- a/Engine/lib/sdl/test/acinclude.m4
+++ b/Engine/lib/sdl/test/acinclude.m4
@@ -5,13 +5,13 @@
 # stolen from Manish Singh
 # Shamelessly stolen from Owen Taylor
 
-# serial 1
+# serial 2
 
 dnl AM_PATH_SDL2([MINIMUM-VERSION, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]]])
 dnl Test for SDL, and define SDL_CFLAGS and SDL_LIBS
 dnl
 AC_DEFUN([AM_PATH_SDL2],
-[dnl 
+[dnl
 dnl Get the cflags and libraries from the sdl2-config script
 dnl
 AC_ARG_WITH(sdl-prefix,[  --with-sdl-prefix=PFX   Prefix where SDL is installed (optional)],
@@ -80,41 +80,19 @@ dnl Now check if the installed SDL is sufficiently new. (Also sanity
 dnl checks the results of sdl2-config to some extent
 dnl
       rm -f conf.sdltest
-      AC_TRY_RUN([
+      AC_RUN_IFELSE([AC_LANG_SOURCE([[
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
 #include "SDL.h"
 
-char*
-my_strdup (char *str)
-{
-  char *new_str;
-  
-  if (str)
-    {
-      new_str = (char *)malloc ((strlen (str) + 1) * sizeof(char));
-      strcpy (new_str, str);
-    }
-  else
-    new_str = NULL;
-  
-  return new_str;
-}
-
 int main (int argc, char *argv[])
 {
   int major, minor, micro;
-  char *tmp_version;
+  FILE *fp = fopen("conf.sdltest", "w");
 
-  /* This hangs on some systems (?)
-  system ("touch conf.sdltest");
-  */
-  { FILE *fp = fopen("conf.sdltest", "a"); if ( fp ) fclose(fp); }
+  if (fp) fclose(fp);
 
-  /* HP/UX 9 (%@#!) writes to sscanf strings */
-  tmp_version = my_strdup("$min_sdl_version");
-  if (sscanf(tmp_version, "%d.%d.%d", &major, &minor, &micro) != 3) {
+  if (sscanf("$min_sdl_version", "%d.%d.%d", &major, &minor, &micro) != 3) {
      printf("%s, bad version string\n", "$min_sdl_version");
      exit(1);
    }
@@ -137,7 +115,7 @@ int main (int argc, char *argv[])
     }
 }
 
-],, no_sdl=yes,[echo $ac_n "cross compiling; assumed OK... $ac_c"])
+]])], [], [no_sdl=yes], [echo $ac_n "cross compiling; assumed OK... $ac_c"])
         CFLAGS="$ac_save_CFLAGS"
         CXXFLAGS="$ac_save_CXXFLAGS"
         LIBS="$ac_save_LIBS"
@@ -165,7 +143,7 @@ int main (int argc, char *argv[])
           CFLAGS="$CFLAGS $SDL_CFLAGS"
           CXXFLAGS="$CXXFLAGS $SDL_CFLAGS"
           LIBS="$LIBS $SDL_LIBS"
-          AC_TRY_LINK([
+          AC_LINK_IFELSE([AC_LANG_PROGRAM([[
 #include <stdio.h>
 #include "SDL.h"
 
@@ -173,7 +151,7 @@ int main(int argc, char *argv[])
 { return 0; }
 #undef  main
 #define main K_and_R_C_main
-],      [ return 0; ],
+]], [[ return 0; ]])],
         [ echo "*** The test program compiled, but did not run. This usually means"
           echo "*** that the run-time linker is not finding SDL or finding the wrong"
           echo "*** version of SDL. If it is not finding SDL, you'll need to set your"
@@ -228,7 +206,7 @@ int main(int argc, char *argv[])
 # ----------------------------------
 AC_DEFUN([PKG_PROG_PKG_CONFIG],
 [m4_pattern_forbid([^_?PKG_[A-Z_]+$])
-m4_pattern_allow([^PKG_CONFIG(_PATH)?$])
+m4_pattern_allow([^PKG_CONFIG(_PATH|_LIBDIR)?$])
 AC_ARG_VAR([PKG_CONFIG], [path to pkg-config utility])
 AC_ARG_VAR([PKG_CONFIG_PATH], [directories to add to pkg-config's search path])
 AC_ARG_VAR([PKG_CONFIG_LIBDIR], [path overriding pkg-config's built-in search path])
@@ -309,7 +287,7 @@ AC_ARG_VAR([$1][_CFLAGS], [C compiler flags for $1, overriding pkg-config])dnl
 AC_ARG_VAR([$1][_LIBS], [linker flags for $1, overriding pkg-config])dnl
 
 pkg_failed=no
-AC_MSG_CHECKING([for $1])
+AC_MSG_CHECKING([for $2])
 
 _PKG_CONFIG([$1][_CFLAGS], [cflags], [$2])
 _PKG_CONFIG([$1][_LIBS], [libs], [$2])
@@ -337,7 +315,7 @@ $$1_PKG_ERRORS
 Consider adjusting the PKG_CONFIG_PATH environment variable if you
 installed software in a non-standard prefix.
 
-_PKG_TEXT])dnl
+_PKG_TEXT])[]dnl
         ])
 elif test $pkg_failed = untried; then
      	AC_MSG_RESULT([no])
@@ -348,7 +326,7 @@ path to pkg-config.
 
 _PKG_TEXT
 
-To get pkg-config, see <http://pkg-config.freedesktop.org/>.])dnl
+To get pkg-config, see <http://pkg-config.freedesktop.org/>.])[]dnl
         ])
 else
 	$1[]_CFLAGS=$pkg_cv_[]$1[]_CFLAGS
diff --git a/Engine/lib/sdl/test/autogen.sh b/Engine/lib/sdl/test/autogen.sh
index 939f34c0f..988d41760 100755
--- a/Engine/lib/sdl/test/autogen.sh
+++ b/Engine/lib/sdl/test/autogen.sh
@@ -1,12 +1,11 @@
 #!/bin/sh
-#
-# Regenerate configuration files
+
 cp acinclude.m4 aclocal.m4
-found=false
-for autoconf in autoconf autoconf259 autoconf-2.59
-do if which $autoconf >/dev/null 2>&1; then $autoconf && found=true; break; fi
-done
-if test x$found = xfalse; then
-    echo "Couldn't find autoconf, aborting"
-    exit 1
+
+if test "$AUTOCONF"x = x; then
+  AUTOCONF=autoconf
 fi
+
+$AUTOCONF || exit 1
+rm aclocal.m4
+rm -rf autom4te.cache
diff --git a/Engine/lib/sdl/test/checkkeys.c b/Engine/lib/sdl/test/checkkeys.c
index 22abc0aa1..caec4b955 100644
--- a/Engine/lib/sdl/test/checkkeys.c
+++ b/Engine/lib/sdl/test/checkkeys.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -86,6 +86,8 @@ print_modifiers(char **text, size_t *maxlen)
         print_string(text, maxlen, " CAPS");
     if (mod & KMOD_MODE)
         print_string(text, maxlen, " MODE");
+    if (mod & KMOD_SCROLL)
+        print_string(text, maxlen, " SCROLL");
 }
 
 static void
@@ -135,9 +137,10 @@ PrintKey(SDL_Keysym * sym, SDL_bool pressed, SDL_bool repeat)
 }
 
 static void
-PrintText(char *eventtype, char *text)
+PrintText(const char *eventtype, const char *text)
 {
-    char *spot, expanded[1024];
+    const char *spot;
+    char expanded[1024];
 
     expanded[0] = '\0';
     for ( spot = text; *spot; ++spot )
@@ -199,6 +202,7 @@ int
 main(int argc, char *argv[])
 {
     SDL_Window *window;
+    SDL_Renderer *renderer;
 
     /* Enable standard application logging */
     SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
@@ -219,6 +223,12 @@ main(int argc, char *argv[])
         quit(2);
     }
 
+    /* On wayland, no window will actually show until something has
+       actually been displayed.
+    */
+    renderer = SDL_CreateRenderer(window, -1, 0);
+    SDL_RenderPresent(renderer);
+
 #if __IPHONEOS__
     /* Creating the context creates the view, which we need to show keyboard */
     SDL_GL_CreateContext(window);
diff --git a/Engine/lib/sdl/test/checkkeysthreads.c b/Engine/lib/sdl/test/checkkeysthreads.c
new file mode 100644
index 000000000..62d522609
--- /dev/null
+++ b/Engine/lib/sdl/test/checkkeysthreads.c
@@ -0,0 +1,285 @@
+/*
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely.
+*/
+
+/* Simple program:  Loop, watching keystrokes
+   Note that you need to call SDL_PollEvent() or SDL_WaitEvent() to
+   pump the event loop and catch keystrokes.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef __EMSCRIPTEN__
+#include <emscripten/emscripten.h>
+#endif
+
+#include "SDL.h"
+
+int done;
+
+/* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */
+static void
+quit(int rc)
+{
+    SDL_Quit();
+    exit(rc);
+}
+
+static void
+print_string(char **text, size_t *maxlen, const char *fmt, ...)
+{
+    int len;
+    va_list ap;
+
+    va_start(ap, fmt);
+    len = SDL_vsnprintf(*text, *maxlen, fmt, ap);
+    if (len > 0) {
+        *text += len;
+        if ( ((size_t) len) < *maxlen ) {
+            *maxlen -= (size_t) len;
+        } else {
+            *maxlen = 0;
+        }
+    }
+    va_end(ap);
+}
+
+static void
+print_modifiers(char **text, size_t *maxlen)
+{
+    int mod;
+    print_string(text, maxlen, " modifiers:");
+    mod = SDL_GetModState();
+    if (!mod) {
+        print_string(text, maxlen, " (none)");
+        return;
+    }
+    if (mod & KMOD_LSHIFT)
+        print_string(text, maxlen, " LSHIFT");
+    if (mod & KMOD_RSHIFT)
+        print_string(text, maxlen, " RSHIFT");
+    if (mod & KMOD_LCTRL)
+        print_string(text, maxlen, " LCTRL");
+    if (mod & KMOD_RCTRL)
+        print_string(text, maxlen, " RCTRL");
+    if (mod & KMOD_LALT)
+        print_string(text, maxlen, " LALT");
+    if (mod & KMOD_RALT)
+        print_string(text, maxlen, " RALT");
+    if (mod & KMOD_LGUI)
+        print_string(text, maxlen, " LGUI");
+    if (mod & KMOD_RGUI)
+        print_string(text, maxlen, " RGUI");
+    if (mod & KMOD_NUM)
+        print_string(text, maxlen, " NUM");
+    if (mod & KMOD_CAPS)
+        print_string(text, maxlen, " CAPS");
+    if (mod & KMOD_MODE)
+        print_string(text, maxlen, " MODE");
+    if (mod & KMOD_SCROLL)
+        print_string(text, maxlen, " SCROLL");
+}
+
+static void
+PrintModifierState()
+{
+    char message[512];
+    char *spot;
+    size_t left;
+
+    spot = message;
+    left = sizeof(message);
+
+    print_modifiers(&spot, &left);
+    SDL_Log("Initial state:%s\n", message);
+}
+
+static void
+PrintKey(SDL_Keysym * sym, SDL_bool pressed, SDL_bool repeat)
+{
+    char message[512];
+    char *spot;
+    size_t left;
+
+    spot = message;
+    left = sizeof(message);
+
+    /* Print the keycode, name and state */
+    if (sym->sym) {
+        print_string(&spot, &left,
+                "Key %s:  scancode %d = %s, keycode 0x%08X = %s ",
+                pressed ? "pressed " : "released",
+                sym->scancode,
+                SDL_GetScancodeName(sym->scancode),
+                sym->sym, SDL_GetKeyName(sym->sym));
+    } else {
+        print_string(&spot, &left,
+                "Unknown Key (scancode %d = %s) %s ",
+                sym->scancode,
+                SDL_GetScancodeName(sym->scancode),
+                pressed ? "pressed " : "released");
+    }
+    print_modifiers(&spot, &left);
+    if (repeat) {
+        print_string(&spot, &left, " (repeat)");
+    }
+    SDL_Log("%s\n", message);
+    fflush(stderr);
+}
+
+static void
+PrintText(const char *eventtype, const char *text)
+{
+    const char *spot;
+    char expanded[1024];
+
+    expanded[0] = '\0';
+    for ( spot = text; *spot; ++spot )
+    {
+        size_t length = SDL_strlen(expanded);
+        SDL_snprintf(expanded + length, sizeof(expanded) - length, "\\x%.2x", (unsigned char)*spot);
+    }
+    SDL_Log("%s Text (%s): \"%s%s\"\n", eventtype, expanded, *text == '"' ? "\\" : "", text);
+}
+
+void
+loop()
+{
+    SDL_Event event;
+    /* Check for events */
+    /*SDL_WaitEvent(&event); emscripten does not like waiting*/
+
+    fprintf(stderr, "starting loop\n"); fflush(stderr);
+    // while (SDL_PollEvent(&event)) {
+    while (!done && SDL_WaitEvent(&event)) {
+        fprintf(stderr, "got event type: %d\n", event.type); fflush(stderr);
+        switch (event.type) {
+        case SDL_KEYDOWN:
+        case SDL_KEYUP:
+            PrintKey(&event.key.keysym, (event.key.state == SDL_PRESSED) ? SDL_TRUE : SDL_FALSE, (event.key.repeat) ? SDL_TRUE : SDL_FALSE);
+            break;
+        case SDL_TEXTEDITING:
+            PrintText("EDIT", event.text.text);
+            break;
+        case SDL_TEXTINPUT:
+            PrintText("INPUT", event.text.text);
+            break;
+        case SDL_MOUSEBUTTONDOWN:
+            /* Left button quits the app, other buttons toggles text input */
+            fprintf(stderr, "mouse button down button: %d (LEFT=%d)\n", event.button.button, SDL_BUTTON_LEFT); fflush(stderr);
+            if (event.button.button == SDL_BUTTON_LEFT) {
+                done = 1;
+            } else {
+                if (SDL_IsTextInputActive()) {
+                    SDL_Log("Stopping text input\n");
+                    SDL_StopTextInput();
+                } else {
+                    SDL_Log("Starting text input\n");
+                    SDL_StartTextInput();
+                }
+            }
+            break;
+        case SDL_QUIT:
+            done = 1;
+            break;
+        default:
+            break;
+        }
+        fprintf(stderr, "waiting new event\n"); fflush(stderr);
+    }
+    fprintf(stderr, "exiting event loop\n"); fflush(stderr);
+#ifdef __EMSCRIPTEN__
+    if (done) {
+        emscripten_cancel_main_loop();
+    }
+#endif
+}
+
+/* Very simple thread - counts 0 to 9 delaying 50ms between increments */
+static int SDLCALL ping_thread(void *ptr)
+{
+    int cnt;
+    SDL_Event sdlevent;
+    SDL_memset(&sdlevent, 0 , sizeof(SDL_Event));
+    for (cnt = 0; cnt < 10; ++cnt) {
+        fprintf(stderr, "sending event (%d/%d) from thread.\n", cnt + 1, 10); fflush(stderr);
+        sdlevent.type = SDL_KEYDOWN;
+        sdlevent.key.keysym.sym = SDLK_1;
+        SDL_PushEvent(&sdlevent);
+        SDL_Delay(1000 + rand() % 1000);
+    }
+    return cnt;
+}
+
+int
+main(int argc, char *argv[])
+{
+    SDL_Window *window;
+    SDL_Renderer *renderer;
+    SDL_Thread *thread;
+
+    /* Enable standard application logging */
+    SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
+
+    /* Initialize SDL */
+    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't initialize SDL: %s\n", SDL_GetError());
+        return (1);
+    }
+
+    /* Set 640x480 video mode */
+    window = SDL_CreateWindow("CheckKeys Test",
+                              SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
+                              640, 480, 0);
+    if (!window) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create 640x480 window: %s\n",
+                SDL_GetError());
+        quit(2);
+    }
+
+    /* On wayland, no window will actually show until something has
+       actually been displayed.
+    */
+    renderer = SDL_CreateRenderer(window, -1, 0);
+    SDL_RenderPresent(renderer);
+
+#if __IPHONEOS__
+    /* Creating the context creates the view, which we need to show keyboard */
+    SDL_GL_CreateContext(window);
+#endif
+
+    SDL_StartTextInput();
+
+    /* Print initial modifier state */
+    SDL_PumpEvents();
+    PrintModifierState();
+
+    /* Watch keystrokes */
+    done = 0;
+
+    thread = SDL_CreateThread(ping_thread, "PingThread", (void *)NULL);
+
+#ifdef __EMSCRIPTEN__
+    emscripten_set_main_loop(loop, 0, 1);
+#else
+    while (!done) {
+        loop();
+    }
+#endif
+
+    SDL_WaitThread(thread, NULL);
+    SDL_Quit();
+    return (0);
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/test/configure b/Engine/lib/sdl/test/configure
index 4faf15c43..60344e3ec 100755
--- a/Engine/lib/sdl/test/configure
+++ b/Engine/lib/sdl/test/configure
@@ -581,9 +581,11 @@ PACKAGE_STRING=
 PACKAGE_BUGREPORT=
 PACKAGE_URL=
 
-ac_unique_file="README"
+ac_unique_file="loopwave.c"
 ac_subst_vars='LTLIBOBJS
 LIBOBJS
+LIBUNWIND_LIBS
+LIBUNWIND_CFLAGS
 SDL_TTF_LIB
 XLIB
 GLES2LIB
@@ -600,6 +602,7 @@ SDL_CFLAGS
 PKG_CONFIG_LIBDIR
 PKG_CONFIG_PATH
 PKG_CONFIG
+ISOS2
 ISUNIX
 ISWINDOWS
 ISMACOSX
@@ -681,7 +684,9 @@ PKG_CONFIG_LIBDIR
 SDL_CFLAGS
 SDL_LIBS
 XMKMF
-CPP'
+CPP
+LIBUNWIND_CFLAGS
+LIBUNWIND_LIBS'
 
 
 # Initialize some variables set by options.
@@ -1323,6 +1328,10 @@ Some influential environment variables:
   SDL_LIBS    linker flags for SDL, overriding pkg-config
   XMKMF       Path to xmkmf, Makefile generator for X Window System
   CPP         C preprocessor
+  LIBUNWIND_CFLAGS
+              C compiler flags for LIBUNWIND, overriding pkg-config
+  LIBUNWIND_LIBS
+              linker flags for LIBUNWIND, overriding pkg-config
 
 Use these variables to override the choices made by `configure' or to help
 it to find libraries and programs with nonstandard names/locations.
@@ -1442,48 +1451,6 @@ fi
 
 } # ac_fn_c_try_compile
 
-# ac_fn_c_try_run LINENO
-# ----------------------
-# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
-# that executables *can* be run.
-ac_fn_c_try_run ()
-{
-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-  if { { ac_try="$ac_link"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_link") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
-  { { case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_try") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }; }; then :
-  ac_retval=0
-else
-  $as_echo "$as_me: program exited with status $ac_status" >&5
-       $as_echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-       ac_retval=$ac_status
-fi
-  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-  as_fn_set_status $ac_retval
-
-} # ac_fn_c_try_run
-
 # ac_fn_c_try_link LINENO
 # -----------------------
 # Try to link conftest.$ac_ext, and return whether this succeeded.
@@ -1530,6 +1497,48 @@ fi
 
 } # ac_fn_c_try_link
 
+# ac_fn_c_try_run LINENO
+# ----------------------
+# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
+# that executables *can* be run.
+ac_fn_c_try_run ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
+  { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: program exited with status $ac_status" >&5
+       $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+       ac_retval=$ac_status
+fi
+  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_run
+
 # ac_fn_c_try_cpp LINENO
 # ----------------------
 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
@@ -1921,7 +1930,7 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
 
 ac_aux_dir=
-for ac_dir in $srcdir/../build-scripts; do
+for ac_dir in ../build-scripts "$srcdir"/../build-scripts; do
   if test -f "$ac_dir/install-sh"; then
     ac_aux_dir=$ac_dir
     ac_install_sh="$ac_aux_dir/install-sh -c"
@@ -1937,7 +1946,7 @@ for ac_dir in $srcdir/../build-scripts; do
   fi
 done
 if test -z "$ac_aux_dir"; then
-  as_fn_error $? "cannot find install-sh, install.sh, or shtool in $srcdir/../build-scripts" "$LINENO" 5
+  as_fn_error $? "cannot find install-sh, install.sh, or shtool in ../build-scripts \"$srcdir\"/../build-scripts" "$LINENO" 5
 fi
 
 # These three variables are undocumented and unsupported,
@@ -2897,9 +2906,10 @@ fi
 ISUNIX="false"
 ISWINDOWS="false"
 ISMACOSX="false"
+ISOS2="false"
 
 case "$host" in
-    *-*-cygwin* | *-*-mingw32*)
+    *-*-cygwin* | *-*-mingw*)
         ISWINDOWS="true"
         EXE=".exe"
         MATHLIB=""
@@ -2910,7 +2920,7 @@ case "$host" in
         MATHLIB=""
         SYS_GL_LIBS="-lGL"
         ;;
-    *-*-darwin* )
+    *-*-darwin*)
         ISMACOSX="true"
         EXE=""
         MATHLIB=""
@@ -2982,21 +2992,68 @@ fi
         MATHLIB=""
         SYS_GL_LIBS="-lGLES_CM"
         ;;
-    *-*-emscripten* )
+    *-*-emscripten*)
                 EXE=".bc"
         MATHLIB=""
         SYS_GL_LIBS=""
         ;;
-    *-*-riscos* )
+    *-*-riscos*)
         EXE=",e1f"
         MATHLIB=""
         SYS_GL_LIBS=""
         ;;
+    *-*-os2*)
+        ISOS2="true"
+        EXE=".exe"
+        MATHLIB=""
+        SYS_GL_LIBS=""
+        ;;
     *)
                 ISUNIX="true"
         EXE=""
         MATHLIB="-lm"
-        SYS_GL_LIBS="-lGL"
+                { $as_echo "$as_me:${as_lineno-$LINENO}: checking for glBegin in -lOpenGL" >&5
+$as_echo_n "checking for glBegin in -lOpenGL... " >&6; }
+if ${ac_cv_lib_OpenGL_glBegin+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lOpenGL  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char glBegin ();
+int
+main ()
+{
+return glBegin ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_OpenGL_glBegin=yes
+else
+  ac_cv_lib_OpenGL_glBegin=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_OpenGL_glBegin" >&5
+$as_echo "$ac_cv_lib_OpenGL_glBegin" >&6; }
+if test "x$ac_cv_lib_OpenGL_glBegin" = xyes; then :
+  SYS_GL_LIBS="-lOpenGL"
+else
+  SYS_GL_LIBS="-lGL"
+fi
+
         ;;
 esac
 
@@ -3005,7 +3062,8 @@ esac
 
 
 
-SDL_VERSION=2.0.0
+
+SDL_VERSION=2.0.18
 
 
 
@@ -3154,8 +3212,8 @@ fi
   if test "x$sdl_prefix$sdl_exec_prefix" = x ; then
 
 pkg_failed=no
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for SDL" >&5
-$as_echo_n "checking for SDL... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for sdl2 >= $min_sdl_version" >&5
+$as_echo_n "checking for sdl2 >= $min_sdl_version... " >&6; }
 
 if test -n "$SDL_CFLAGS"; then
     pkg_cv_SDL_CFLAGS="$SDL_CFLAGS"
@@ -3319,38 +3377,16 @@ else
 
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
 #include "SDL.h"
 
-char*
-my_strdup (char *str)
-{
-  char *new_str;
-
-  if (str)
-    {
-      new_str = (char *)malloc ((strlen (str) + 1) * sizeof(char));
-      strcpy (new_str, str);
-    }
-  else
-    new_str = NULL;
-
-  return new_str;
-}
-
 int main (int argc, char *argv[])
 {
   int major, minor, micro;
-  char *tmp_version;
+  FILE *fp = fopen("conf.sdltest", "w");
 
-  /* This hangs on some systems (?)
-  system ("touch conf.sdltest");
-  */
-  { FILE *fp = fopen("conf.sdltest", "a"); if ( fp ) fclose(fp); }
+  if (fp) fclose(fp);
 
-  /* HP/UX 9 (%@#!) writes to sscanf strings */
-  tmp_version = my_strdup("$min_sdl_version");
-  if (sscanf(tmp_version, "%d.%d.%d", &major, &minor, &micro) != 3) {
+  if (sscanf("$min_sdl_version", "%d.%d.%d", &major, &minor, &micro) != 3) {
      printf("%s, bad version string\n", "$min_sdl_version");
      exit(1);
    }
@@ -3862,15 +3898,12 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-have_opengl=yes
-
+  have_opengl=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_opengl" >&5
@@ -3891,15 +3924,12 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-have_opengles=yes
-
+  have_opengles=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_opengles" >&5
@@ -3920,15 +3950,12 @@ int
 main ()
 {
 
-
   ;
   return 0;
 }
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"; then :
-
-have_opengles2=yes
-
+  have_opengles2=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_opengles2" >&5
@@ -4010,6 +4037,79 @@ if test x$have_SDL_ttf = xyes; then
 fi
 
 
+
+pkg_failed=no
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for libunwind" >&5
+$as_echo_n "checking for libunwind... " >&6; }
+
+if test -n "$LIBUNWIND_CFLAGS"; then
+    pkg_cv_LIBUNWIND_CFLAGS="$LIBUNWIND_CFLAGS"
+ elif test -n "$PKG_CONFIG"; then
+    if test -n "$PKG_CONFIG" && \
+    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libunwind\""; } >&5
+  ($PKG_CONFIG --exists --print-errors "libunwind") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+  pkg_cv_LIBUNWIND_CFLAGS=`$PKG_CONFIG --cflags "libunwind" 2>/dev/null`
+else
+  pkg_failed=yes
+fi
+ else
+    pkg_failed=untried
+fi
+if test -n "$LIBUNWIND_LIBS"; then
+    pkg_cv_LIBUNWIND_LIBS="$LIBUNWIND_LIBS"
+ elif test -n "$PKG_CONFIG"; then
+    if test -n "$PKG_CONFIG" && \
+    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libunwind\""; } >&5
+  ($PKG_CONFIG --exists --print-errors "libunwind") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+  pkg_cv_LIBUNWIND_LIBS=`$PKG_CONFIG --libs "libunwind" 2>/dev/null`
+else
+  pkg_failed=yes
+fi
+ else
+    pkg_failed=untried
+fi
+
+
+
+if test $pkg_failed = yes; then
+   	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+
+if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
+        _pkg_short_errors_supported=yes
+else
+        _pkg_short_errors_supported=no
+fi
+        if test $_pkg_short_errors_supported = yes; then
+	        LIBUNWIND_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "libunwind" 2>&1`
+        else
+	        LIBUNWIND_PKG_ERRORS=`$PKG_CONFIG --print-errors "libunwind" 2>&1`
+        fi
+	# Put the nasty error message in config.log where it belongs
+	echo "$LIBUNWIND_PKG_ERRORS" >&5
+
+	have_libunwind=no
+elif test $pkg_failed = untried; then
+     	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+	have_libunwind=no
+else
+	LIBUNWIND_CFLAGS=$pkg_cv_LIBUNWIND_CFLAGS
+	LIBUNWIND_LIBS=$pkg_cv_LIBUNWIND_LIBS
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+	have_libunwind=yes
+fi
+if test x$have_libunwind = xyes ; then
+   LIBS="$LIBS $LIBUNWIND_LIBS"
+fi
+
 ac_config_files="$ac_config_files Makefile"
 
 cat >confcache <<\_ACEOF
diff --git a/Engine/lib/sdl/test/configure.ac b/Engine/lib/sdl/test/configure.ac
index 348606aa4..694551c61 100644
--- a/Engine/lib/sdl/test/configure.ac
+++ b/Engine/lib/sdl/test/configure.ac
@@ -1,9 +1,9 @@
 dnl Process this file with autoconf to produce a configure script.
 AC_INIT
-AC_CONFIG_SRCDIR([README])
+AC_CONFIG_SRCDIR([loopwave.c])
 
 dnl Detect the canonical build and host environments
-AC_CONFIG_AUX_DIRS($srcdir/../build-scripts)
+AC_CONFIG_AUX_DIR([../build-scripts])
 AC_CANONICAL_HOST
 
 dnl Check for tools
@@ -18,10 +18,11 @@ dnl  (Haiku, for example, sets none of these.)
 ISUNIX="false"
 ISWINDOWS="false"
 ISMACOSX="false"
+ISOS2="false"
 
 dnl Figure out which math library to use
 case "$host" in
-    *-*-cygwin* | *-*-mingw32*)
+    *-*-cygwin* | *-*-mingw*)
         ISWINDOWS="true"
         EXE=".exe"
         MATHLIB=""
@@ -32,7 +33,7 @@ case "$host" in
         MATHLIB=""
         SYS_GL_LIBS="-lGL"
         ;;
-    *-*-darwin* )
+    *-*-darwin*)
         ISMACOSX="true"
         EXE=""
         MATHLIB=""
@@ -64,23 +65,31 @@ case "$host" in
         MATHLIB=""
         SYS_GL_LIBS="-lGLES_CM"
         ;;
-    *-*-emscripten* )
+    *-*-emscripten*)
         dnl This should really be .js, but we need to specify extra flags when compiling to js
         EXE=".bc"
         MATHLIB=""
         SYS_GL_LIBS=""
         ;;
-    *-*-riscos* )
+    *-*-riscos*)
         EXE=",e1f"
         MATHLIB=""
         SYS_GL_LIBS=""
         ;;
+    *-*-os2*)
+        ISOS2="true"
+        EXE=".exe"
+        MATHLIB=""
+        SYS_GL_LIBS=""
+        ;;
     *)
         dnl Oh well, call it Unix...
         ISUNIX="true"
         EXE=""
         MATHLIB="-lm"
-        SYS_GL_LIBS="-lGL"
+        dnl Use the new libOpenGL if present.
+        AC_CHECK_LIB(OpenGL, glBegin,
+            [SYS_GL_LIBS="-lOpenGL"],[SYS_GL_LIBS="-lGL"])
         ;;
 esac
 AC_SUBST(EXE)
@@ -88,9 +97,10 @@ AC_SUBST(MATHLIB)
 AC_SUBST(ISMACOSX)
 AC_SUBST(ISWINDOWS)
 AC_SUBST(ISUNIX)
+AC_SUBST(ISOS2)
 
 dnl Check for SDL
-SDL_VERSION=2.0.0
+SDL_VERSION=2.0.18
 AM_PATH_SDL2($SDL_VERSION,
             :,
 	    AC_MSG_ERROR([*** SDL version $SDL_VERSION not found!])
@@ -122,43 +132,34 @@ fi
 dnl Check for OpenGL
 AC_MSG_CHECKING(for OpenGL support)
 have_opengl=no
-AC_TRY_COMPILE([
+AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
  #include "SDL_opengl.h"
  #ifndef SDL_VIDEO_OPENGL
  #error SDL_VIDEO_OPENGL
  #endif
-],[
-],[
-have_opengl=yes
-])
+]],[])], [have_opengl=yes],[])
 AC_MSG_RESULT($have_opengl)
 
 dnl Check for OpenGL ES
 AC_MSG_CHECKING(for OpenGL ES support)
 have_opengles=no
-AC_TRY_COMPILE([
+AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
  #include "SDL_opengles.h"
  #ifndef SDL_VIDEO_OPENGL_ES
  #error SDL_VIDEO_OPENGL_ES
  #endif
-],[
-],[
-have_opengles=yes
-])
+]],[])] ,[have_opengles=yes],[])
 AC_MSG_RESULT($have_opengles)
 
 dnl Check for OpenGL ES2
 AC_MSG_CHECKING(for OpenGL ES2 support)
 have_opengles2=no
-AC_TRY_COMPILE([
+AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
  #include "SDL_opengles2.h"
  #ifndef SDL_VIDEO_OPENGL_ES2
  #error SDL_VIDEO_OPENGL_ES2
  #endif
-],[
-],[
-have_opengles2=yes
-])
+]],[])], [have_opengles2=yes],[])
 AC_MSG_RESULT($have_opengles2)
 
 GLLIB=""
@@ -199,6 +200,16 @@ if test x$have_SDL_ttf = xyes; then
 fi
 AC_SUBST(SDL_TTF_LIB)
 
+dnl Really, SDL2_test should be linking against libunwind (if it found
+dnl libunwind.h when configured), but SDL2_test is a static library, so
+dnl there's no way for it to link against it. We could make SDL2 depend on
+dnl it, but we don't want all SDL2 build to suddenly gain an extra dependency,
+dnl so just assume that if it's here now, SDL2_test was probably built with it.
+PKG_CHECK_MODULES(LIBUNWIND, libunwind, have_libunwind=yes, have_libunwind=no)
+if test x$have_libunwind = xyes ; then
+   LIBS="$LIBS $LIBUNWIND_LIBS"
+fi
+
 dnl Finally create all the generated files
 AC_CONFIG_FILES([Makefile])
 AC_OUTPUT
diff --git a/Engine/lib/sdl/test/controllermap.c b/Engine/lib/sdl/test/controllermap.c
index 03153abcb..308ddf51a 100644
--- a/Engine/lib/sdl/test/controllermap.c
+++ b/Engine/lib/sdl/test/controllermap.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -53,7 +53,7 @@ static struct
     double angle;
     int marker;
 
-} s_arrBindingDisplay[BINDING_COUNT] = {
+} s_arrBindingDisplay[] = {
     { 387, 167, 0.0, MARKER_BUTTON }, /* SDL_CONTROLLER_BUTTON_A */
     { 431, 132, 0.0, MARKER_BUTTON }, /* SDL_CONTROLLER_BUTTON_B */
     { 342, 132, 0.0, MARKER_BUTTON }, /* SDL_CONTROLLER_BUTTON_X */
@@ -86,8 +86,9 @@ static struct
     {  91, -20, 180.0, MARKER_AXIS }, /* SDL_CONTROLLER_BINDING_AXIS_TRIGGERLEFT */
     { 375, -20, 180.0, MARKER_AXIS }, /* SDL_CONTROLLER_BINDING_AXIS_TRIGGERRIGHT */
 };
+SDL_COMPILE_TIME_ASSERT(s_arrBindingDisplay, SDL_arraysize(s_arrBindingDisplay) == BINDING_COUNT);
 
-static int s_arrBindingOrder[BINDING_COUNT] = {
+static int s_arrBindingOrder[] = {
     SDL_CONTROLLER_BUTTON_A,
     SDL_CONTROLLER_BUTTON_B,
     SDL_CONTROLLER_BUTTON_Y,
@@ -118,7 +119,9 @@ static int s_arrBindingOrder[BINDING_COUNT] = {
     SDL_CONTROLLER_BUTTON_PADDLE2,
     SDL_CONTROLLER_BUTTON_PADDLE3,
     SDL_CONTROLLER_BUTTON_PADDLE4,
+    SDL_CONTROLLER_BUTTON_TOUCHPAD,
 };
+SDL_COMPILE_TIME_ASSERT(s_arrBindingOrder, SDL_arraysize(s_arrBindingOrder) == BINDING_COUNT);
 
 typedef struct
 {
@@ -162,7 +165,9 @@ static Uint32 s_unPendingAdvanceTime;
 static SDL_bool s_bBindingComplete;
 
 static SDL_Window *window;
+static SDL_Renderer *screen;
 static SDL_bool done = SDL_FALSE;
+static SDL_bool bind_touchpad = SDL_FALSE;
 
 SDL_Texture *
 LoadTexture(SDL_Renderer *renderer, const char *file, SDL_bool transparent)
@@ -224,6 +229,19 @@ SetCurrentBinding(int iBinding)
         return;
     }
 
+    if (s_arrBindingOrder[iBinding] == -1)
+    {
+        SetCurrentBinding(iBinding + 1);
+        return;
+    }
+
+    if (s_arrBindingOrder[iBinding] == SDL_CONTROLLER_BUTTON_TOUCHPAD &&
+        !bind_touchpad)
+    {
+        SetCurrentBinding(iBinding + 1);
+        return;
+    }
+
     s_iCurrentBinding = iBinding;
 
     pBinding = &s_arrBindings[s_arrBindingOrder[s_iCurrentBinding]];
@@ -366,7 +384,6 @@ BMergeAxisBindings(int iIndex)
 static void
 WatchJoystick(SDL_Joystick * joystick)
 {
-    SDL_Renderer *screen = NULL;
     SDL_Texture *background_front, *background_back, *button, *axis, *marker;
     const char *name = NULL;
     SDL_Event event;
@@ -375,12 +392,6 @@ WatchJoystick(SDL_Joystick * joystick)
     Uint32 alpha_ticks = 0;
     SDL_JoystickID nJoystickID;
 
-    screen = SDL_CreateRenderer(window, -1, 0);
-    if (screen == NULL) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create renderer: %s\n", SDL_GetError());
-        return;
-    }
-    
     background_front = LoadTexture(screen, "controllermap.bmp", SDL_FALSE);
     background_back = LoadTexture(screen, "controllermap_back.bmp", SDL_FALSE);
     button = LoadTexture(screen, "button.bmp", SDL_TRUE);
@@ -412,10 +423,10 @@ WatchJoystick(SDL_Joystick * joystick)
     s_nNumAxes = SDL_JoystickNumAxes(joystick);
     s_arrAxisState = (AxisState *)SDL_calloc(s_nNumAxes, sizeof(*s_arrAxisState));
 
-	/* Skip any spurious events at start */
-	while (SDL_PollEvent(&event) > 0) {
-		continue;
-	}
+    /* Skip any spurious events at start */
+    while (SDL_PollEvent(&event) > 0) {
+        continue;
+    }
 
     /* Loop, getting joystick events! */
     while (!done && !s_bBindingComplete) {
@@ -559,7 +570,7 @@ WatchJoystick(SDL_Joystick * joystick)
                 if ((event.key.keysym.sym != SDLK_ESCAPE)) {
                     break;
                 }
-                /* Fall through to signal quit */
+                SDL_FALLTHROUGH;
             case SDL_QUIT:
                 done = SDL_TRUE;
                 break;
@@ -728,6 +739,10 @@ main(int argc, char *argv[])
         exit(1);
     }
 
+    if (argv[1] && SDL_strcmp(argv[1], "--bind-touchpad") == 0) {
+        bind_touchpad = SDL_TRUE;
+    }
+
     /* Create a window to display joystick axis position */
     window = SDL_CreateWindow("Game Controller Map", SDL_WINDOWPOS_CENTERED,
                               SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH,
@@ -737,7 +752,13 @@ main(int argc, char *argv[])
         return 2;
     }
 
-    while (SDL_NumJoysticks() == 0) {
+    screen = SDL_CreateRenderer(window, -1, 0);
+    if (screen == NULL) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create renderer: %s\n", SDL_GetError());
+        return 2;
+    }
+
+    while (!done && SDL_NumJoysticks() == 0) {
         SDL_Event event;
 
         while (SDL_PollEvent(&event) > 0) {
@@ -746,7 +767,7 @@ main(int argc, char *argv[])
                 if ((event.key.keysym.sym != SDLK_ESCAPE)) {
                     break;
                 }
-                /* Fall through to signal quit */
+                SDL_FALLTHROUGH;
             case SDL_QUIT:
                 done = SDL_TRUE;
                 break;
@@ -754,6 +775,7 @@ main(int argc, char *argv[])
                 break;
             }
         }
+        SDL_RenderPresent(screen);
     }
 
     /* Print information about the joysticks */
diff --git a/Engine/lib/sdl/test/loopwave.c b/Engine/lib/sdl/test/loopwave.c
index 64d2f1aaf..14ac4dbaf 100644
--- a/Engine/lib/sdl/test/loopwave.c
+++ b/Engine/lib/sdl/test/loopwave.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/loopwavequeue.c b/Engine/lib/sdl/test/loopwavequeue.c
index bb50221f0..a5d0ea3cc 100644
--- a/Engine/lib/sdl/test/loopwavequeue.c
+++ b/Engine/lib/sdl/test/loopwavequeue.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/testatomic.c b/Engine/lib/sdl/test/testatomic.c
index 0a4e62dd1..16678db5d 100644
--- a/Engine/lib/sdl/test/testatomic.c
+++ b/Engine/lib/sdl/test/testatomic.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -19,13 +19,13 @@
 */
 
 static
-char *
-tf(SDL_bool tf)
+const char *
+tf(SDL_bool _tf)
 {
-    static char *t = "TRUE";
-    static char *f = "FALSE";
+    static const char *t = "TRUE";
+    static const char *f = "FALSE";
 
-    if (tf)
+    if (_tf)
     {
        return t;
     }
@@ -353,7 +353,7 @@ static SDL_bool EnqueueEvent_LockFree(SDL_EventQueue *queue, const SDL_Event *ev
     }
 
 #ifdef TEST_SPINLOCK_FIFO
-    SDL_AtomicDecRef(&queue->rwcount);
+    (void) SDL_AtomicDecRef(&queue->rwcount);
 #endif
     return status;
 }
@@ -400,7 +400,7 @@ static SDL_bool DequeueEvent_LockFree(SDL_EventQueue *queue, SDL_Event *event)
     }
 
 #ifdef TEST_SPINLOCK_FIFO
-    SDL_AtomicDecRef(&queue->rwcount);
+    (void) SDL_AtomicDecRef(&queue->rwcount);
 #endif
     return status;
 }
@@ -473,8 +473,6 @@ static SDL_bool DequeueEvent_Mutex(SDL_EventQueue *queue, SDL_Event *event)
 
 static SDL_sem *writersDone;
 static SDL_sem *readersDone;
-static SDL_atomic_t writersRunning;
-static SDL_atomic_t readersRunning;
 
 typedef struct
 {
@@ -525,7 +523,6 @@ static int SDLCALL FIFO_Writer(void* _data)
             }
         }
     }
-    SDL_AtomicAdd(&writersRunning, -1);
     SDL_SemPost(writersDone);
     return 0;
 }
@@ -563,7 +560,6 @@ static int SDLCALL FIFO_Reader(void* _data)
             }
         }
     }
-    SDL_AtomicAdd(&readersRunning, -1);
     SDL_SemPost(readersDone);
     return 0;
 }
@@ -581,7 +577,7 @@ static int SDLCALL FIFO_Watcher(void* _data)
             SDL_Delay(0);
         }
         /* Do queue manipulation here... */
-        SDL_AtomicDecRef(&queue->watcher);
+        (void) SDL_AtomicDecRef(&queue->watcher);
         SDL_AtomicUnlock(&queue->lock);
 
         /* Wait a bit... */
@@ -627,7 +623,6 @@ static void RunFIFOTest(SDL_bool lock_free)
     /* Start the readers first */
     SDL_Log("Starting %d readers\n", NUM_READERS);
     SDL_zeroa(readerData);
-    SDL_AtomicSet(&readersRunning, NUM_READERS);
     for (i = 0; i < NUM_READERS; ++i) {
         char name[64];
         SDL_snprintf(name, sizeof (name), "FIFOReader%d", i);
@@ -639,7 +634,6 @@ static void RunFIFOTest(SDL_bool lock_free)
     /* Start up the writers */
     SDL_Log("Starting %d writers\n", NUM_WRITERS);
     SDL_zeroa(writerData);
-    SDL_AtomicSet(&writersRunning, NUM_WRITERS);
     for (i = 0; i < NUM_WRITERS; ++i) {
         char name[64];
         SDL_snprintf(name, sizeof (name), "FIFOWriter%d", i);
@@ -650,7 +644,7 @@ static void RunFIFOTest(SDL_bool lock_free)
     }
 
     /* Wait for the writers */
-    while (SDL_AtomicGet(&writersRunning) > 0) {
+    for (i = 0; i < NUM_WRITERS; ++i) {
         SDL_SemWait(writersDone);
     }
 
@@ -658,7 +652,7 @@ static void RunFIFOTest(SDL_bool lock_free)
     SDL_AtomicSet(&queue.active, 0);
 
     /* Wait for the readers */
-    while (SDL_AtomicGet(&readersRunning) > 0) {
+    for (i = 0; i < NUM_READERS; ++i) {
         SDL_SemWait(readersDone);
     }
 
diff --git a/Engine/lib/sdl/test/testaudiocapture.c b/Engine/lib/sdl/test/testaudiocapture.c
index 2dfbd02be..03d373273 100644
--- a/Engine/lib/sdl/test/testaudiocapture.c
+++ b/Engine/lib/sdl/test/testaudiocapture.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/testaudiohotplug.c b/Engine/lib/sdl/test/testaudiohotplug.c
index fe9745976..536cc4c3b 100644
--- a/Engine/lib/sdl/test/testaudiohotplug.c
+++ b/Engine/lib/sdl/test/testaudiohotplug.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/testaudioinfo.c b/Engine/lib/sdl/test/testaudioinfo.c
index 8f58498de..d22aed270 100644
--- a/Engine/lib/sdl/test/testaudioinfo.c
+++ b/Engine/lib/sdl/test/testaudioinfo.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/testautomation.c b/Engine/lib/sdl/test/testautomation.c
index ef600178c..0dc37f4a0 100644
--- a/Engine/lib/sdl/test/testautomation.c
+++ b/Engine/lib/sdl/test/testautomation.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/testautomation_audio.c b/Engine/lib/sdl/test/testautomation_audio.c
index be0f15e3d..96c174f5c 100644
--- a/Engine/lib/sdl/test/testautomation_audio.c
+++ b/Engine/lib/sdl/test/testautomation_audio.c
@@ -498,7 +498,7 @@ const int _numAudioFormats = 18;
 SDL_AudioFormat _audioFormats[] = { AUDIO_S8, AUDIO_U8, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_S16SYS, AUDIO_S16, AUDIO_U16LSB,
                 AUDIO_U16MSB, AUDIO_U16SYS, AUDIO_U16, AUDIO_S32LSB, AUDIO_S32MSB, AUDIO_S32SYS, AUDIO_S32,
                                 AUDIO_F32LSB, AUDIO_F32MSB, AUDIO_F32SYS, AUDIO_F32 };
-char *_audioFormatsVerbose[] = { "AUDIO_S8", "AUDIO_U8", "AUDIO_S16LSB", "AUDIO_S16MSB", "AUDIO_S16SYS", "AUDIO_S16", "AUDIO_U16LSB",
+const char *_audioFormatsVerbose[] = { "AUDIO_S8", "AUDIO_U8", "AUDIO_S16LSB", "AUDIO_S16MSB", "AUDIO_S16SYS", "AUDIO_S16", "AUDIO_U16LSB",
                 "AUDIO_U16MSB", "AUDIO_U16SYS", "AUDIO_U16", "AUDIO_S32LSB", "AUDIO_S32MSB", "AUDIO_S32SYS", "AUDIO_S32",
                                 "AUDIO_F32LSB", "AUDIO_F32MSB", "AUDIO_F32SYS", "AUDIO_F32" };
 const int _numAudioChannels = 4;
@@ -697,7 +697,7 @@ int audio_openCloseAndGetAudioStatus()
    SDL_AudioStatus result;
    int i;
    int count;
-   char *device;
+   const char *device;
    SDL_AudioDeviceID id;
    SDL_AudioSpec desired, obtained;
 
@@ -707,7 +707,7 @@ int audio_openCloseAndGetAudioStatus()
    if (count > 0) {
      for (i = 0; i < count; i++) {
        /* Get device name */
-       device = (char *)SDL_GetAudioDeviceName(i, 0);
+       device = SDL_GetAudioDeviceName(i, 0);
        SDLTest_AssertPass("SDL_GetAudioDeviceName(%i,0)", i);
        SDLTest_AssertCheck(device != NULL, "Validate device name is not NULL; got: %s", (device != NULL) ? device : "NULL");
        if (device == NULL) return TEST_ABORTED;
@@ -721,7 +721,7 @@ int audio_openCloseAndGetAudioStatus()
        desired.userdata=NULL;
 
        /* Open device */
-       id = SDL_OpenAudioDevice((const char *)device, 0, &desired, &obtained, SDL_AUDIO_ALLOW_ANY_CHANGE);
+       id = SDL_OpenAudioDevice(device, 0, &desired, &obtained, SDL_AUDIO_ALLOW_ANY_CHANGE);
        SDLTest_AssertPass("SDL_OpenAudioDevice('%s',...)", device);
        SDLTest_AssertCheck(id > 1, "Validate device ID; expected: >=2, got: %i", id);
        if (id > 1) {
@@ -755,7 +755,7 @@ int audio_lockUnlockOpenAudioDevice()
 {
    int i;
    int count;
-   char *device;
+   const char *device;
    SDL_AudioDeviceID id;
    SDL_AudioSpec desired, obtained;
 
@@ -765,7 +765,7 @@ int audio_lockUnlockOpenAudioDevice()
    if (count > 0) {
      for (i = 0; i < count; i++) {
        /* Get device name */
-       device = (char *)SDL_GetAudioDeviceName(i, 0);
+       device = SDL_GetAudioDeviceName(i, 0);
        SDLTest_AssertPass("SDL_GetAudioDeviceName(%i,0)", i);
        SDLTest_AssertCheck(device != NULL, "Validate device name is not NULL; got: %s", (device != NULL) ? device : "NULL");
        if (device == NULL) return TEST_ABORTED;
@@ -779,7 +779,7 @@ int audio_lockUnlockOpenAudioDevice()
        desired.userdata=NULL;
 
        /* Open device */
-       id = SDL_OpenAudioDevice((const char *)device, 0, &desired, &obtained, SDL_AUDIO_ALLOW_ANY_CHANGE);
+       id = SDL_OpenAudioDevice(device, 0, &desired, &obtained, SDL_AUDIO_ALLOW_ANY_CHANGE);
        SDLTest_AssertPass("SDL_OpenAudioDevice('%s',...)", device);
        SDLTest_AssertCheck(id > 1, "Validate device ID; expected: >=2, got: %i", id);
        if (id > 1) {
@@ -917,7 +917,7 @@ int audio_openCloseAudioDeviceConnected()
    int result = -1;
    int i;
    int count;
-   char *device;
+   const char *device;
    SDL_AudioDeviceID id;
    SDL_AudioSpec desired, obtained;
 
@@ -927,7 +927,7 @@ int audio_openCloseAudioDeviceConnected()
    if (count > 0) {
      for (i = 0; i < count; i++) {
        /* Get device name */
-       device = (char *)SDL_GetAudioDeviceName(i, 0);
+       device = SDL_GetAudioDeviceName(i, 0);
        SDLTest_AssertPass("SDL_GetAudioDeviceName(%i,0)", i);
        SDLTest_AssertCheck(device != NULL, "Validate device name is not NULL; got: %s", (device != NULL) ? device : "NULL");
        if (device == NULL) return TEST_ABORTED;
@@ -941,7 +941,7 @@ int audio_openCloseAudioDeviceConnected()
        desired.userdata=NULL;
 
        /* Open device */
-       id = SDL_OpenAudioDevice((const char *)device, 0, &desired, &obtained, SDL_AUDIO_ALLOW_ANY_CHANGE);
+       id = SDL_OpenAudioDevice(device, 0, &desired, &obtained, SDL_AUDIO_ALLOW_ANY_CHANGE);
        SDLTest_AssertPass("SDL_OpenAudioDevice('%s',...)", device);
        SDLTest_AssertCheck(id > 1, "Validate device ID; expected: >1, got: %i", id);
        if (id > 1) {
diff --git a/Engine/lib/sdl/test/testautomation_clipboard.c b/Engine/lib/sdl/test/testautomation_clipboard.c
index 417d95746..113c7dc89 100644
--- a/Engine/lib/sdl/test/testautomation_clipboard.c
+++ b/Engine/lib/sdl/test/testautomation_clipboard.c
@@ -16,13 +16,12 @@
  * \brief Check call to SDL_HasClipboardText
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_HasClipboardText
+ * http://wiki.libsdl.org/SDL_HasClipboardText
  */
 int
 clipboard_testHasClipboardText(void *arg)
 {
-    SDL_bool result;
-    result = SDL_HasClipboardText();
+    SDL_HasClipboardText();
     SDLTest_AssertPass("Call to SDL_HasClipboardText succeeded");
 
     return TEST_COMPLETED;
@@ -32,7 +31,7 @@ clipboard_testHasClipboardText(void *arg)
  * \brief Check call to SDL_GetClipboardText
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_GetClipboardText
+ * http://wiki.libsdl.org/SDL_GetClipboardText
  */
 int
 clipboard_testGetClipboardText(void *arg)
@@ -49,7 +48,7 @@ clipboard_testGetClipboardText(void *arg)
 /**
  * \brief Check call to SDL_SetClipboardText
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_SetClipboardText
+ * http://wiki.libsdl.org/SDL_SetClipboardText
  */
 int
 clipboard_testSetClipboardText(void *arg)
@@ -78,9 +77,9 @@ clipboard_testSetClipboardText(void *arg)
 /**
  * \brief End-to-end test of SDL_xyzClipboardText functions
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_HasClipboardText
- * http://wiki.libsdl.org/moin.cgi/SDL_GetClipboardText
- * http://wiki.libsdl.org/moin.cgi/SDL_SetClipboardText
+ * http://wiki.libsdl.org/SDL_HasClipboardText
+ * http://wiki.libsdl.org/SDL_GetClipboardText
+ * http://wiki.libsdl.org/SDL_SetClipboardText
  */
 int
 clipboard_testClipboardTextFunctions(void *arg)
diff --git a/Engine/lib/sdl/test/testautomation_events.c b/Engine/lib/sdl/test/testautomation_events.c
index 09004da52..20f2ea5e4 100644
--- a/Engine/lib/sdl/test/testautomation_events.c
+++ b/Engine/lib/sdl/test/testautomation_events.c
@@ -42,8 +42,8 @@ int SDLCALL _events_sampleNullEventFilter(void *userdata, SDL_Event *event)
 /**
  * @brief Test pumping and peeking events.
  *
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_PumpEvents
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_PollEvent
+ * @sa http://wiki.libsdl.org/SDL_PumpEvents
+ * @sa http://wiki.libsdl.org/SDL_PollEvent
  */
 int
 events_pushPumpAndPollUserevent(void *arg)
@@ -76,8 +76,8 @@ events_pushPumpAndPollUserevent(void *arg)
 /**
  * @brief Adds and deletes an event watch function with NULL userdata
  *
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_AddEventWatch
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_DelEventWatch
+ * @sa http://wiki.libsdl.org/SDL_AddEventWatch
+ * @sa http://wiki.libsdl.org/SDL_DelEventWatch
  *
  */
 int
@@ -126,8 +126,8 @@ events_addDelEventWatch(void *arg)
 /**
  * @brief Adds and deletes an event watch function with userdata
  *
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_AddEventWatch
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_DelEventWatch
+ * @sa http://wiki.libsdl.org/SDL_AddEventWatch
+ * @sa http://wiki.libsdl.org/SDL_DelEventWatch
  *
  */
 int
diff --git a/Engine/lib/sdl/test/testautomation_hints.c b/Engine/lib/sdl/test/testautomation_hints.c
index a6beb88d7..0d1b7b6f5 100644
--- a/Engine/lib/sdl/test/testautomation_hints.c
+++ b/Engine/lib/sdl/test/testautomation_hints.c
@@ -9,7 +9,7 @@
 
 
 const int _numHintsEnum = 25;
-char* _HintsEnum[] =
+const char* _HintsEnum[] =
   {
     SDL_HINT_ACCELEROMETER_AS_JOYSTICK,
     SDL_HINT_FRAMEBUFFER_ACCELERATION,
@@ -37,33 +37,33 @@ char* _HintsEnum[] =
     SDL_HINT_VIDEO_X11_XVIDMODE,
     SDL_HINT_XINPUT_ENABLED,
   };
-char* _HintsVerbose[] =
+const char* _HintsVerbose[] =
   {
-    "SDL_HINT_ACCELEROMETER_AS_JOYSTICK",
-    "SDL_HINT_FRAMEBUFFER_ACCELERATION",
-    "SDL_HINT_GAMECONTROLLERCONFIG",
-    "SDL_HINT_GRAB_KEYBOARD",
-    "SDL_HINT_IDLE_TIMER_DISABLED",
-    "SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS",
-    "SDL_HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK",
-    "SDL_HINT_MOUSE_RELATIVE_MODE_WARP",
-    "SDL_HINT_ORIENTATIONS",
-    "SDL_HINT_RENDER_DIRECT3D_THREADSAFE",
-    "SDL_HINT_RENDER_DRIVER",
-    "SDL_HINT_RENDER_OPENGL_SHADERS",
-    "SDL_HINT_RENDER_SCALE_QUALITY",
-    "SDL_HINT_RENDER_VSYNC",
-    "SDL_HINT_TIMER_RESOLUTION",
-    "SDL_HINT_VIDEO_ALLOW_SCREENSAVER",
-    "SDL_HINT_VIDEO_HIGHDPI_DISABLED",
-    "SDL_HINT_VIDEO_MAC_FULLSCREEN_SPACES",
-    "SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS",
-    "SDL_HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT",
-    "SDL_HINT_VIDEO_WIN_D3DCOMPILER",
-    "SDL_HINT_VIDEO_X11_XINERAMA",
-    "SDL_HINT_VIDEO_X11_XRANDR",
-    "SDL_HINT_VIDEO_X11_XVIDMODE",
-    "SDL_HINT_XINPUT_ENABLED"
+    "SDL_ACCELEROMETER_AS_JOYSTICK",
+    "SDL_FRAMEBUFFER_ACCELERATION",
+    "SDL_GAMECONTROLLERCONFIG",
+    "SDL_GRAB_KEYBOARD",
+    "SDL_IDLE_TIMER_DISABLED",
+    "SDL_JOYSTICK_ALLOW_BACKGROUND_EVENTS",
+    "SDL_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK",
+    "SDL_MOUSE_RELATIVE_MODE_WARP",
+    "SDL_ORIENTATIONS",
+    "SDL_RENDER_DIRECT3D_THREADSAFE",
+    "SDL_RENDER_DRIVER",
+    "SDL_RENDER_OPENGL_SHADERS",
+    "SDL_RENDER_SCALE_QUALITY",
+    "SDL_RENDER_VSYNC",
+    "SDL_TIMER_RESOLUTION",
+    "SDL_VIDEO_ALLOW_SCREENSAVER",
+    "SDL_VIDEO_HIGHDPI_DISABLED",
+    "SDL_VIDEO_MAC_FULLSCREEN_SPACES",
+    "SDL_VIDEO_MINIMIZE_ON_FOCUS_LOSS",
+    "SDL_VIDEO_WINDOW_SHARE_PIXEL_FORMAT",
+    "SDL_VIDEO_WIN_D3DCOMPILER",
+    "SDL_VIDEO_X11_XINERAMA",
+    "SDL_VIDEO_X11_XRANDR",
+    "SDL_VIDEO_X11_XVIDMODE",
+    "SDL_XINPUT_ENABLED"
   };
 
 
@@ -75,14 +75,14 @@ char* _HintsVerbose[] =
 int
 hints_getHint(void *arg)
 {
-  char *result1;
-  char *result2;
+  const char *result1;
+  const char *result2;
   int i;
-    
+
   for (i=0; i<_numHintsEnum; i++) {
-    result1 = (char *)SDL_GetHint((char*)_HintsEnum[i]);
+    result1 = SDL_GetHint(_HintsEnum[i]);
     SDLTest_AssertPass("Call to SDL_GetHint(%s) - using define definition", (char*)_HintsEnum[i]);
-    result2 = (char *)SDL_GetHint((char *)_HintsVerbose[i]);
+    result2 = SDL_GetHint(_HintsVerbose[i]);
     SDLTest_AssertPass("Call to SDL_GetHint(%s) - using string definition", (char*)_HintsVerbose[i]);
     SDLTest_AssertCheck(
       (result1 == NULL && result2 == NULL) || (SDL_strcmp(result1, result2) == 0),
@@ -90,7 +90,7 @@ hints_getHint(void *arg)
       (result1 == NULL) ? "null" : result1,
       (result2 == NULL) ? "null" : result2);
   }
-  
+
   return TEST_COMPLETED;
 }
 
@@ -100,48 +100,52 @@ hints_getHint(void *arg)
 int
 hints_setHint(void *arg)
 {
-  char *originalValue;
-  char *value;
-  char *testValue;
+  const char *originalValue;
+  const char *value;
+  const char *testValue;
   SDL_bool result;
   int i, j;
 
-  /* Create random values to set */                    
+  /* Create random values to set */
   value = SDLTest_RandomAsciiStringOfSize(10);
-    
+
   for (i=0; i<_numHintsEnum; i++) {
     /* Capture current value */
-    originalValue = (char *)SDL_GetHint((char*)_HintsEnum[i]);
-    SDLTest_AssertPass("Call to SDL_GetHint(%s)", (char*)_HintsEnum[i]);
-    
+    originalValue = SDL_GetHint(_HintsEnum[i]);
+    SDLTest_AssertPass("Call to SDL_GetHint(%s)", _HintsEnum[i]);
+
+    /* Copy the original value, since it will be freed when we set it again */
+    originalValue = originalValue ? SDL_strdup(originalValue) : NULL;
+
     /* Set value (twice) */
     for (j=1; j<=2; j++) {
-      result = SDL_SetHint((char*)_HintsEnum[i], value);
-      SDLTest_AssertPass("Call to SDL_SetHint(%s, %s) (iteration %i)", (char*)_HintsEnum[i], value, j);
+      result = SDL_SetHint(_HintsEnum[i], value);
+      SDLTest_AssertPass("Call to SDL_SetHint(%s, %s) (iteration %i)", _HintsEnum[i], value, j);
       SDLTest_AssertCheck(
         result == SDL_TRUE || result == SDL_FALSE, 
         "Verify valid result was returned, got: %i",
         (int)result);
-      testValue = (char *)SDL_GetHint((char*)_HintsEnum[i]);
-      SDLTest_AssertPass("Call to SDL_GetHint(%s) - using string definition", (char*)_HintsVerbose[i]);
+      testValue = SDL_GetHint(_HintsEnum[i]);
+      SDLTest_AssertPass("Call to SDL_GetHint(%s) - using string definition", _HintsVerbose[i]);
       SDLTest_AssertCheck(
         (SDL_strcmp(value, testValue) == 0),
         "Verify returned value equals set value; got: testValue='%s' value='%s",
         (testValue == NULL) ? "null" : testValue,
         value);
     }
-      
+
     /* Reset original value */
-    result = SDL_SetHint((char*)_HintsEnum[i], originalValue);
-    SDLTest_AssertPass("Call to SDL_SetHint(%s, originalValue)", (char*)_HintsEnum[i]);
+    result = SDL_SetHint(_HintsEnum[i], originalValue);
+    SDLTest_AssertPass("Call to SDL_SetHint(%s, originalValue)", _HintsEnum[i]);
     SDLTest_AssertCheck(
       result == SDL_TRUE || result == SDL_FALSE, 
       "Verify valid result was returned, got: %i",
       (int)result);
+    SDL_free((void *)originalValue);
   }
-  
-  SDL_free(value);
-  
+
+  SDL_free((void *)value);
+
   return TEST_COMPLETED;
 }
 
diff --git a/Engine/lib/sdl/test/testautomation_keyboard.c b/Engine/lib/sdl/test/testautomation_keyboard.c
index 6f25bb76c..84a763589 100644
--- a/Engine/lib/sdl/test/testautomation_keyboard.c
+++ b/Engine/lib/sdl/test/testautomation_keyboard.c
@@ -16,7 +16,7 @@
 /**
  * @brief Check call to SDL_GetKeyboardState with and without numkeys reference.
  *
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetKeyboardState
+ * @sa http://wiki.libsdl.org/SDL_GetKeyboardState
  */
 int
 keyboard_getKeyboardState(void *arg)
@@ -42,15 +42,13 @@ keyboard_getKeyboardState(void *arg)
 /**
  * @brief Check call to SDL_GetKeyboardFocus
  *
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetKeyboardFocus
+ * @sa http://wiki.libsdl.org/SDL_GetKeyboardFocus
  */
 int
 keyboard_getKeyboardFocus(void *arg)
 {
-   SDL_Window* window;
-
    /* Call, but ignore return value */
-   window = SDL_GetKeyboardFocus();
+   SDL_GetKeyboardFocus();
    SDLTest_AssertPass("Call to SDL_GetKeyboardFocus()");
 
    return TEST_COMPLETED;
@@ -59,7 +57,7 @@ keyboard_getKeyboardFocus(void *arg)
 /**
  * @brief Check call to SDL_GetKeyFromName for known, unknown and invalid name.
  *
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetKeyFromName
+ * @sa http://wiki.libsdl.org/SDL_GetKeyFromName
  */
 int
 keyboard_getKeyFromName(void *arg)
@@ -126,7 +124,7 @@ _checkInvalidScancodeError()
 /**
  * @brief Check call to SDL_GetKeyFromScancode
  *
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetKeyFromScancode
+ * @sa http://wiki.libsdl.org/SDL_GetKeyFromScancode
  */
 int
 keyboard_getKeyFromScancode(void *arg)
@@ -165,13 +163,13 @@ keyboard_getKeyFromScancode(void *arg)
 /**
  * @brief Check call to SDL_GetKeyName
  *
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetKeyName
+ * @sa http://wiki.libsdl.org/SDL_GetKeyName
  */
 int
 keyboard_getKeyName(void *arg)
 {
-   char *result;
-   char *expected;
+   const char *result;
+   const char *expected;
 
    /* Case where key has a 1 character name */
    expected = "3";
@@ -221,14 +219,14 @@ keyboard_getKeyName(void *arg)
 /**
  * @brief SDL_GetScancodeName negative cases
  *
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetScancodeName
+ * @sa http://wiki.libsdl.org/SDL_GetScancodeName
  */
 int
 keyboard_getScancodeNameNegative(void *arg)
 {
    SDL_Scancode scancode;
-   char *result;
-   char *expected = "";
+   const char *result;
+   const char *expected = "";
 
    /* Clear error message */
    SDL_ClearError();
@@ -248,14 +246,14 @@ keyboard_getScancodeNameNegative(void *arg)
 /**
  * @brief SDL_GetKeyName negative cases
  *
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetKeyName
+ * @sa http://wiki.libsdl.org/SDL_GetKeyName
  */
 int
 keyboard_getKeyNameNegative(void *arg)
 {
    SDL_Keycode keycode;
-   char *result;
-   char *expected = "";
+   const char *result;
+   const char *expected = "";
 
    /* Unknown keycode */
    keycode = SDLK_UNKNOWN;
@@ -285,8 +283,8 @@ keyboard_getKeyNameNegative(void *arg)
 /**
  * @brief Check call to SDL_GetModState and SDL_SetModState
  *
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetModState
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_SetModState
+ * @sa http://wiki.libsdl.org/SDL_GetModState
+ * @sa http://wiki.libsdl.org/SDL_SetModState
  */
 int
 keyboard_getSetModState(void *arg)
@@ -307,7 +305,7 @@ keyboard_getSetModState(void *arg)
     KMOD_NUM |
     KMOD_CAPS |
     KMOD_MODE |
-    KMOD_RESERVED;
+    KMOD_SCROLL;
 
    /* Get state, cache for later reset */
    result = SDL_GetModState();
@@ -346,8 +344,8 @@ keyboard_getSetModState(void *arg)
 /**
  * @brief Check call to SDL_StartTextInput and SDL_StopTextInput
  *
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_StartTextInput
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_StopTextInput
+ * @sa http://wiki.libsdl.org/SDL_StartTextInput
+ * @sa http://wiki.libsdl.org/SDL_StopTextInput
  */
 int
 keyboard_startStopTextInput(void *arg)
@@ -393,7 +391,7 @@ void _testSetTextInputRect(SDL_Rect refRect)
 /**
  * @brief Check call to SDL_SetTextInputRect
  *
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_SetTextInputRect
+ * @sa http://wiki.libsdl.org/SDL_SetTextInputRect
  */
 int
 keyboard_setTextInputRect(void *arg)
@@ -473,7 +471,7 @@ keyboard_setTextInputRect(void *arg)
 /**
  * @brief Check call to SDL_SetTextInputRect with invalid data
  *
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_SetTextInputRect
+ * @sa http://wiki.libsdl.org/SDL_SetTextInputRect
  */
 int
 keyboard_setTextInputRectNegative(void *arg)
@@ -511,8 +509,8 @@ keyboard_setTextInputRectNegative(void *arg)
 /**
  * @brief Check call to SDL_GetScancodeFromKey
  *
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetScancodeFromKey
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_Keycode
+ * @sa http://wiki.libsdl.org/SDL_GetScancodeFromKey
+ * @sa http://wiki.libsdl.org/SDL_Keycode
  */
 int
 keyboard_getScancodeFromKey(void *arg)
@@ -535,8 +533,8 @@ keyboard_getScancodeFromKey(void *arg)
 /**
  * @brief Check call to SDL_GetScancodeFromName
  *
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetScancodeFromName
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_Keycode
+ * @sa http://wiki.libsdl.org/SDL_GetScancodeFromName
+ * @sa http://wiki.libsdl.org/SDL_Keycode
  */
 int
 keyboard_getScancodeFromName(void *arg)
@@ -608,13 +606,13 @@ _checkInvalidNameError()
 /**
  * @brief Check call to SDL_GetScancodeFromName with invalid data
  *
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetScancodeFromName
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_Keycode
+ * @sa http://wiki.libsdl.org/SDL_GetScancodeFromName
+ * @sa http://wiki.libsdl.org/SDL_Keycode
  */
 int
 keyboard_getScancodeFromNameNegative(void *arg)
 {
-   char *name;
+   const char *name;
    SDL_Scancode scancode;
 
    /* Clear error message */
@@ -627,9 +625,9 @@ keyboard_getScancodeFromNameNegative(void *arg)
    if (name == NULL) {
       return TEST_ABORTED;
    }
-   scancode = SDL_GetScancodeFromName((const char *)name);
+   scancode = SDL_GetScancodeFromName(name);
    SDLTest_AssertPass("Call to SDL_GetScancodeFromName('%s')", name);
-   SDL_free(name);
+   SDL_free((void *)name);
    SDLTest_AssertCheck(scancode == SDL_SCANCODE_UNKNOWN, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_UNKNOWN, scancode);
    _checkInvalidNameError();
 
diff --git a/Engine/lib/sdl/test/testautomation_main.c b/Engine/lib/sdl/test/testautomation_main.c
index ae060cdd1..229f2bc55 100644
--- a/Engine/lib/sdl/test/testautomation_main.c
+++ b/Engine/lib/sdl/test/testautomation_main.c
@@ -13,8 +13,8 @@
 /* !
  * \brief Tests SDL_Init() and SDL_Quit() of Joystick and Haptic subsystems
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_Init
- * http://wiki.libsdl.org/moin.cgi/SDL_Quit
+ * http://wiki.libsdl.org/SDL_Init
+ * http://wiki.libsdl.org/SDL_Quit
  */
 static int main_testInitQuitJoystickHaptic (void *arg)
 {
@@ -41,8 +41,8 @@ static int main_testInitQuitJoystickHaptic (void *arg)
 /* !
  * \brief Tests SDL_InitSubSystem() and SDL_QuitSubSystem()
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_Init
- * http://wiki.libsdl.org/moin.cgi/SDL_Quit
+ * http://wiki.libsdl.org/SDL_Init
+ * http://wiki.libsdl.org/SDL_Quit
  */
 static int main_testInitQuitSubSystem (void *arg)
 {
diff --git a/Engine/lib/sdl/test/testautomation_mouse.c b/Engine/lib/sdl/test/testautomation_mouse.c
index ed30f2604..b99afc1ce 100644
--- a/Engine/lib/sdl/test/testautomation_mouse.c
+++ b/Engine/lib/sdl/test/testautomation_mouse.c
@@ -192,8 +192,8 @@ static SDL_Cursor *_initArrowCursor(const char *image[])
 /**
  * @brief Check call to SDL_CreateCursor and SDL_FreeCursor
  *
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_CreateCursor
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_FreeCursor
+ * @sa http://wiki.libsdl.org/SDL_CreateCursor
+ * @sa http://wiki.libsdl.org/SDL_FreeCursor
  */
 int
 mouse_createFreeCursor(void *arg)
@@ -218,8 +218,8 @@ mouse_createFreeCursor(void *arg)
 /**
  * @brief Check call to SDL_CreateColorCursor and SDL_FreeCursor
  *
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_CreateColorCursor
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_FreeCursor
+ * @sa http://wiki.libsdl.org/SDL_CreateColorCursor
+ * @sa http://wiki.libsdl.org/SDL_FreeCursor
  */
 int
 mouse_createFreeColorCursor(void *arg)
@@ -275,7 +275,7 @@ void _changeCursorVisibility(int state)
 /**
  * @brief Check call to SDL_ShowCursor
  *
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_ShowCursor
+ * @sa http://wiki.libsdl.org/SDL_ShowCursor
  */
 int
 mouse_showCursor(void *arg)
@@ -305,7 +305,7 @@ mouse_showCursor(void *arg)
 /**
  * @brief Check call to SDL_SetCursor
  *
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_SetCursor
+ * @sa http://wiki.libsdl.org/SDL_SetCursor
  */
 int
 mouse_setCursor(void *arg)
@@ -338,7 +338,7 @@ mouse_setCursor(void *arg)
 /**
  * @brief Check call to SDL_GetCursor
  *
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetCursor
+ * @sa http://wiki.libsdl.org/SDL_GetCursor
  */
 int
 mouse_getCursor(void *arg)
@@ -356,8 +356,8 @@ mouse_getCursor(void *arg)
 /**
  * @brief Check call to SDL_GetRelativeMouseMode and SDL_SetRelativeMouseMode
  *
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetRelativeMouseMode
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_SetRelativeMouseMode
+ * @sa http://wiki.libsdl.org/SDL_GetRelativeMouseMode
+ * @sa http://wiki.libsdl.org/SDL_SetRelativeMouseMode
  */
 int
 mouse_getSetRelativeMouseMode(void *arg)
@@ -440,7 +440,7 @@ void _destroyMouseSuiteTestWindow(SDL_Window *window)
 /**
  * @brief Check call to SDL_WarpMouseInWindow
  *
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_WarpMouseInWindow
+ * @sa http://wiki.libsdl.org/SDL_WarpMouseInWindow
  */
 int
 mouse_warpMouseInWindow(void *arg)
@@ -502,7 +502,7 @@ mouse_warpMouseInWindow(void *arg)
 /**
  * @brief Check call to SDL_GetMouseFocus
  *
- * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetMouseFocus
+ * @sa http://wiki.libsdl.org/SDL_GetMouseFocus
  */
 int
 mouse_getMouseFocus(void *arg)
@@ -527,6 +527,7 @@ mouse_getMouseFocus(void *arg)
     SDLTest_AssertPass("SDL_WarpMouseInWindow(...,%i,%i)", x, y);
 
     /* Pump events to update focus state */
+    SDL_Delay(100);
     SDL_PumpEvents();
     SDLTest_AssertPass("SDL_PumpEvents()");
 
diff --git a/Engine/lib/sdl/test/testautomation_pixels.c b/Engine/lib/sdl/test/testautomation_pixels.c
index b54be8699..0f6870c9a 100644
--- a/Engine/lib/sdl/test/testautomation_pixels.c
+++ b/Engine/lib/sdl/test/testautomation_pixels.c
@@ -45,7 +45,7 @@ Uint32 _RGBPixelFormats[] =
     SDL_PIXELFORMAT_BGRA8888,
     SDL_PIXELFORMAT_ARGB2101010
   };
-char* _RGBPixelFormatsVerbose[] =
+const char* _RGBPixelFormatsVerbose[] =
   {
     "SDL_PIXELFORMAT_INDEX1LSB",
     "SDL_PIXELFORMAT_INDEX1MSB",
@@ -92,7 +92,7 @@ Uint32 _nonRGBPixelFormats[] =
     SDL_PIXELFORMAT_NV12,
     SDL_PIXELFORMAT_NV21
   };
-char* _nonRGBPixelFormatsVerbose[] =
+const char* _nonRGBPixelFormatsVerbose[] =
   {
     "SDL_PIXELFORMAT_YV12",
     "SDL_PIXELFORMAT_IYUV",
@@ -110,7 +110,7 @@ Uint32 _invalidPixelFormats[] =
     0xfffffffe,
     0xffffffff
   };
-char* _invalidPixelFormatsVerbose[] =
+const char* _invalidPixelFormatsVerbose[] =
   {
     "SDL_PIXELFORMAT_UNKNOWN",
     "SDL_PIXELFORMAT_UNKNOWN"
@@ -121,8 +121,8 @@ char* _invalidPixelFormatsVerbose[] =
 /**
  * @brief Call to SDL_AllocFormat and SDL_FreeFormat
  *
- * @sa http://wiki.libsdl.org/moin.fcg/SDL_AllocFormat
- * @sa http://wiki.libsdl.org/moin.fcg/SDL_FreeFormat
+ * @sa http://wiki.libsdl.org/SDL_AllocFormat
+ * @sa http://wiki.libsdl.org/SDL_FreeFormat
  */
 int
 pixels_allocFreeFormat(void *arg)
@@ -228,7 +228,7 @@ pixels_allocFreeFormat(void *arg)
 /**
  * @brief Call to SDL_GetPixelFormatName
  *
- * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetPixelFormatName
+ * @sa http://wiki.libsdl.org/SDL_GetPixelFormatName
  */
 int
 pixels_getPixelFormatName(void *arg)
@@ -237,14 +237,14 @@ pixels_getPixelFormatName(void *arg)
   const char *error;
   int i;
   Uint32 format;
-  char* result;
+  const char *result;
 
   /* Blank/undefined format */
   format = 0;
   SDLTest_Log("RGB Format: %s (%u)", unknownFormat, format);
 
   /* Get name of format */
-  result = (char *)SDL_GetPixelFormatName(format);
+  result = SDL_GetPixelFormatName(format);
   SDLTest_AssertPass("Call to SDL_GetPixelFormatName()");
   SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
   if (result != NULL) {
@@ -259,7 +259,7 @@ pixels_getPixelFormatName(void *arg)
     SDLTest_Log("RGB Format: %s (%u)", _RGBPixelFormatsVerbose[i], format);
 
     /* Get name of format */
-    result = (char *)SDL_GetPixelFormatName(format);
+    result = SDL_GetPixelFormatName(format);
     SDLTest_AssertPass("Call to SDL_GetPixelFormatName()");
     SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
     if (result != NULL) {
@@ -275,7 +275,7 @@ pixels_getPixelFormatName(void *arg)
     SDLTest_Log("non-RGB Format: %s (%u)", _nonRGBPixelFormatsVerbose[i], format);
 
     /* Get name of format */
-    result = (char *)SDL_GetPixelFormatName(format);
+    result = SDL_GetPixelFormatName(format);
     SDLTest_AssertPass("Call to SDL_GetPixelFormatName()");
     SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
     if (result != NULL) {
@@ -292,7 +292,7 @@ pixels_getPixelFormatName(void *arg)
   SDLTest_AssertPass("Call to SDL_ClearError()");
   for (i = 0; i < _numInvalidPixelFormats; i++) {
     format = _invalidPixelFormats[i];
-    result = (char *)SDL_GetPixelFormatName(format);
+    result = SDL_GetPixelFormatName(format);
     SDLTest_AssertPass("Call to SDL_GetPixelFormatName(%u)", format);
     SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
     if (result != NULL) {
@@ -312,8 +312,8 @@ pixels_getPixelFormatName(void *arg)
 /**
  * @brief Call to SDL_AllocPalette and SDL_FreePalette
  *
- * @sa http://wiki.libsdl.org/moin.fcg/SDL_AllocPalette
- * @sa http://wiki.libsdl.org/moin.fcg/SDL_FreePalette
+ * @sa http://wiki.libsdl.org/SDL_AllocPalette
+ * @sa http://wiki.libsdl.org/SDL_FreePalette
  */
 int
 pixels_allocFreePalette(void *arg)
@@ -402,7 +402,7 @@ pixels_allocFreePalette(void *arg)
 /**
  * @brief Call to SDL_CalculateGammaRamp
  *
- * @sa http://wiki.libsdl.org/moin.fcg/SDL_CalculateGammaRamp
+ * @sa http://wiki.libsdl.org/SDL_CalculateGammaRamp
  */
 int
 pixels_calcGammaRamp(void *arg)
diff --git a/Engine/lib/sdl/test/testautomation_platform.c b/Engine/lib/sdl/test/testautomation_platform.c
index 7cc732a7b..4e28ba166 100644
--- a/Engine/lib/sdl/test/testautomation_platform.c
+++ b/Engine/lib/sdl/test/testautomation_platform.c
@@ -101,11 +101,11 @@ int platform_testEndianessAndSwap(void *arg)
 /* !
  * \brief Tests SDL_GetXYZ() functions
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_GetPlatform
- * http://wiki.libsdl.org/moin.cgi/SDL_GetCPUCount
- * http://wiki.libsdl.org/moin.cgi/SDL_GetCPUCacheLineSize
- * http://wiki.libsdl.org/moin.cgi/SDL_GetRevision
- * http://wiki.libsdl.org/moin.cgi/SDL_GetRevisionNumber
+ * http://wiki.libsdl.org/SDL_GetPlatform
+ * http://wiki.libsdl.org/SDL_GetCPUCount
+ * http://wiki.libsdl.org/SDL_GetCPUCacheLineSize
+ * http://wiki.libsdl.org/SDL_GetRevision
+ * http://wiki.libsdl.org/SDL_GetRevisionNumber
  */
 int platform_testGetFunctions (void *arg)
 {
@@ -141,60 +141,55 @@ int platform_testGetFunctions (void *arg)
    SDLTest_AssertPass("SDL_GetRevision()");
    SDLTest_AssertCheck(revision != NULL, "SDL_GetRevision() != NULL");
 
-   ret = SDL_GetRevisionNumber();
-   SDLTest_AssertPass("SDL_GetRevisionNumber()");
-
    return TEST_COMPLETED;
 }
 
 /* !
  * \brief Tests SDL_HasXYZ() functions
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_Has3DNow
- * http://wiki.libsdl.org/moin.cgi/SDL_HasAltiVec
- * http://wiki.libsdl.org/moin.cgi/SDL_HasMMX
- * http://wiki.libsdl.org/moin.cgi/SDL_HasRDTSC
- * http://wiki.libsdl.org/moin.cgi/SDL_HasSSE
- * http://wiki.libsdl.org/moin.cgi/SDL_HasSSE2
- * http://wiki.libsdl.org/moin.cgi/SDL_HasSSE3
- * http://wiki.libsdl.org/moin.cgi/SDL_HasSSE41
- * http://wiki.libsdl.org/moin.cgi/SDL_HasSSE42
- * http://wiki.libsdl.org/moin.cgi/SDL_HasAVX
+ * http://wiki.libsdl.org/SDL_Has3DNow
+ * http://wiki.libsdl.org/SDL_HasAltiVec
+ * http://wiki.libsdl.org/SDL_HasMMX
+ * http://wiki.libsdl.org/SDL_HasRDTSC
+ * http://wiki.libsdl.org/SDL_HasSSE
+ * http://wiki.libsdl.org/SDL_HasSSE2
+ * http://wiki.libsdl.org/SDL_HasSSE3
+ * http://wiki.libsdl.org/SDL_HasSSE41
+ * http://wiki.libsdl.org/SDL_HasSSE42
+ * http://wiki.libsdl.org/SDL_HasAVX
  */
 int platform_testHasFunctions (void *arg)
 {
-   int ret;
-
    /* TODO: independently determine and compare values as well */
 
-   ret = SDL_HasRDTSC();
+   SDL_HasRDTSC();
    SDLTest_AssertPass("SDL_HasRDTSC()");
 
-   ret = SDL_HasAltiVec();
+   SDL_HasAltiVec();
    SDLTest_AssertPass("SDL_HasAltiVec()");
 
-   ret = SDL_HasMMX();
+   SDL_HasMMX();
    SDLTest_AssertPass("SDL_HasMMX()");
 
-   ret = SDL_Has3DNow();
+   SDL_Has3DNow();
    SDLTest_AssertPass("SDL_Has3DNow()");
 
-   ret = SDL_HasSSE();
+   SDL_HasSSE();
    SDLTest_AssertPass("SDL_HasSSE()");
 
-   ret = SDL_HasSSE2();
+   SDL_HasSSE2();
    SDLTest_AssertPass("SDL_HasSSE2()");
 
-   ret = SDL_HasSSE3();
+   SDL_HasSSE3();
    SDLTest_AssertPass("SDL_HasSSE3()");
 
-   ret = SDL_HasSSE41();
+   SDL_HasSSE41();
    SDLTest_AssertPass("SDL_HasSSE41()");
 
-   ret = SDL_HasSSE42();
+   SDL_HasSSE42();
    SDLTest_AssertPass("SDL_HasSSE42()");
 
-   ret = SDL_HasAVX();
+   SDL_HasAVX();
    SDLTest_AssertPass("SDL_HasAVX()");
 
    return TEST_COMPLETED;
@@ -203,7 +198,7 @@ int platform_testHasFunctions (void *arg)
 /* !
  * \brief Tests SDL_GetVersion
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_GetVersion
+ * http://wiki.libsdl.org/SDL_GetVersion
  */
 int platform_testGetVersion(void *arg)
 {
@@ -273,9 +268,9 @@ int platform_testDefaultInit(void *arg)
 /* !
  * \brief Tests SDL_Get/Set/ClearError
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_GetError
- * http://wiki.libsdl.org/moin.cgi/SDL_SetError
- * http://wiki.libsdl.org/moin.cgi/SDL_ClearError
+ * http://wiki.libsdl.org/SDL_GetError
+ * http://wiki.libsdl.org/SDL_SetError
+ * http://wiki.libsdl.org/SDL_ClearError
  */
 int platform_testGetSetClearError(void *arg)
 {
@@ -327,7 +322,7 @@ int platform_testGetSetClearError(void *arg)
 /* !
  * \brief Tests SDL_SetError with empty input
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_SetError
+ * http://wiki.libsdl.org/SDL_SetError
  */
 int platform_testSetErrorEmptyInput(void *arg)
 {
@@ -365,7 +360,7 @@ int platform_testSetErrorEmptyInput(void *arg)
 /* !
  * \brief Tests SDL_SetError with invalid input
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_SetError
+ * http://wiki.libsdl.org/SDL_SetError
  */
 int platform_testSetErrorInvalidInput(void *arg)
 {
@@ -389,7 +384,7 @@ int platform_testSetErrorInvalidInput(void *arg)
    if (lastError != NULL)
    {
      len = SDL_strlen(lastError);
-     SDLTest_AssertCheck(len == 0,
+     SDLTest_AssertCheck(len == 0 || SDL_strcmp(lastError, "(null)") == 0,
              "SDL_GetError(): expected message len 0, was len: %i",
              (int) len);
    }
@@ -409,7 +404,7 @@ int platform_testSetErrorInvalidInput(void *arg)
    if (lastError != NULL)
    {
      len = SDL_strlen(lastError);
-     SDLTest_AssertCheck(len == 0,
+     SDLTest_AssertCheck(len == 0 || SDL_strcmp( lastError, "(null)" ) == 0,
              "SDL_GetError(): expected message len 0, was len: %i",
              (int) len);
    }
@@ -448,7 +443,7 @@ int platform_testSetErrorInvalidInput(void *arg)
 /* !
  * \brief Tests SDL_GetPowerInfo
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_GetPowerInfo
+ * http://wiki.libsdl.org/SDL_GetPowerInfo
  */
 int platform_testGetPowerInfo(void *arg)
 {
diff --git a/Engine/lib/sdl/test/testautomation_rect.c b/Engine/lib/sdl/test/testautomation_rect.c
index abf19f593..26f03e9bb 100644
--- a/Engine/lib/sdl/test/testautomation_rect.c
+++ b/Engine/lib/sdl/test/testautomation_rect.c
@@ -43,7 +43,7 @@ void _validateIntersectRectAndLineResults(
  * \brief Tests SDL_IntersectRectAndLine() clipping cases
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRectAndLine
+ * http://wiki.libsdl.org/SDL_IntersectRectAndLine
  */
 int
 rect_testIntersectRectAndLine (void *arg)
@@ -114,7 +114,7 @@ rect_testIntersectRectAndLine (void *arg)
  * \brief Tests SDL_IntersectRectAndLine() non-clipping case line inside
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRectAndLine
+ * http://wiki.libsdl.org/SDL_IntersectRectAndLine
  */
 int
 rect_testIntersectRectAndLineInside (void *arg)
@@ -181,7 +181,7 @@ rect_testIntersectRectAndLineInside (void *arg)
  * \brief Tests SDL_IntersectRectAndLine() non-clipping cases outside
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRectAndLine
+ * http://wiki.libsdl.org/SDL_IntersectRectAndLine
  */
 int
 rect_testIntersectRectAndLineOutside (void *arg)
@@ -236,7 +236,7 @@ rect_testIntersectRectAndLineOutside (void *arg)
  * \brief Tests SDL_IntersectRectAndLine() with empty rectangle
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRectAndLine
+ * http://wiki.libsdl.org/SDL_IntersectRectAndLine
  */
 int
 rect_testIntersectRectAndLineEmpty (void *arg)
@@ -271,7 +271,7 @@ rect_testIntersectRectAndLineEmpty (void *arg)
  * \brief Negative tests against SDL_IntersectRectAndLine() with invalid parameters
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRectAndLine
+ * http://wiki.libsdl.org/SDL_IntersectRectAndLine
  */
 int
 rect_testIntersectRectAndLineParam (void *arg)
@@ -412,7 +412,7 @@ void _validateRectEqualsResults(
  * \brief Tests SDL_IntersectRect() with B fully inside A
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRect
+ * http://wiki.libsdl.org/SDL_IntersectRect
  */
 int rect_testIntersectRectInside (void *arg)
 {
@@ -440,7 +440,7 @@ int rect_testIntersectRectInside (void *arg)
  * \brief Tests SDL_IntersectRect() with B fully outside A
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRect
+ * http://wiki.libsdl.org/SDL_IntersectRect
  */
 int rect_testIntersectRectOutside (void *arg)
 {
@@ -468,7 +468,7 @@ int rect_testIntersectRectOutside (void *arg)
  * \brief Tests SDL_IntersectRect() with B partially intersecting A
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRect
+ * http://wiki.libsdl.org/SDL_IntersectRect
  */
 int rect_testIntersectRectPartial (void *arg)
 {
@@ -557,7 +557,7 @@ int rect_testIntersectRectPartial (void *arg)
  * \brief Tests SDL_IntersectRect() with 1x1 pixel sized rectangles
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRect
+ * http://wiki.libsdl.org/SDL_IntersectRect
  */
 int rect_testIntersectRectPoint (void *arg)
 {
@@ -604,7 +604,7 @@ int rect_testIntersectRectPoint (void *arg)
  * \brief Tests SDL_IntersectRect() with empty rectangles
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRect
+ * http://wiki.libsdl.org/SDL_IntersectRect
  */
 int rect_testIntersectRectEmpty (void *arg)
 {
@@ -676,7 +676,7 @@ int rect_testIntersectRectEmpty (void *arg)
  * \brief Negative tests against SDL_IntersectRect() with invalid parameters
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRect
+ * http://wiki.libsdl.org/SDL_IntersectRect
  */
 int rect_testIntersectRectParam(void *arg)
 {
@@ -706,7 +706,7 @@ int rect_testIntersectRectParam(void *arg)
  * \brief Tests SDL_HasIntersection() with B fully inside A
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_HasIntersection
+ * http://wiki.libsdl.org/SDL_HasIntersection
  */
 int rect_testHasIntersectionInside (void *arg)
 {
@@ -733,7 +733,7 @@ int rect_testHasIntersectionInside (void *arg)
  * \brief Tests SDL_HasIntersection() with B fully outside A
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_HasIntersection
+ * http://wiki.libsdl.org/SDL_HasIntersection
  */
 int rect_testHasIntersectionOutside (void *arg)
 {
@@ -760,7 +760,7 @@ int rect_testHasIntersectionOutside (void *arg)
  * \brief Tests SDL_HasIntersection() with B partially intersecting A
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_HasIntersection
+ * http://wiki.libsdl.org/SDL_HasIntersection
  */
 int rect_testHasIntersectionPartial (void *arg)
 {
@@ -827,7 +827,7 @@ int rect_testHasIntersectionPartial (void *arg)
  * \brief Tests SDL_HasIntersection() with 1x1 pixel sized rectangles
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_HasIntersection
+ * http://wiki.libsdl.org/SDL_HasIntersection
  */
 int rect_testHasIntersectionPoint (void *arg)
 {
@@ -873,7 +873,7 @@ int rect_testHasIntersectionPoint (void *arg)
  * \brief Tests SDL_HasIntersection() with empty rectangles
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_HasIntersection
+ * http://wiki.libsdl.org/SDL_HasIntersection
  */
 int rect_testHasIntersectionEmpty (void *arg)
 {
@@ -931,7 +931,7 @@ int rect_testHasIntersectionEmpty (void *arg)
  * \brief Negative tests against SDL_HasIntersection() with invalid parameters
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_HasIntersection
+ * http://wiki.libsdl.org/SDL_HasIntersection
  */
 int rect_testHasIntersectionParam(void *arg)
 {
@@ -954,7 +954,7 @@ int rect_testHasIntersectionParam(void *arg)
  * \brief Test SDL_EnclosePoints() without clipping
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_EnclosePoints
+ * http://wiki.libsdl.org/SDL_EnclosePoints
  */
 int rect_testEnclosePoints(void *arg)
 {
@@ -1024,7 +1024,7 @@ int rect_testEnclosePoints(void *arg)
  * \brief Test SDL_EnclosePoints() with repeated input points
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_EnclosePoints
+ * http://wiki.libsdl.org/SDL_EnclosePoints
  */
 int rect_testEnclosePointsRepeatedInput(void *arg)
 {
@@ -1100,7 +1100,7 @@ int rect_testEnclosePointsRepeatedInput(void *arg)
  * \brief Test SDL_EnclosePoints() with clipping
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_EnclosePoints
+ * http://wiki.libsdl.org/SDL_EnclosePoints
  */
 int rect_testEnclosePointsWithClipping(void *arg)
 {
@@ -1199,7 +1199,7 @@ int rect_testEnclosePointsWithClipping(void *arg)
  * \brief Negative tests against SDL_EnclosePoints() with invalid parameters
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_EnclosePoints
+ * http://wiki.libsdl.org/SDL_EnclosePoints
  */
 int rect_testEnclosePointsParam(void *arg)
 {
@@ -1227,7 +1227,7 @@ int rect_testEnclosePointsParam(void *arg)
  * \brief Tests SDL_UnionRect() where rect B is outside rect A
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_UnionRect
+ * http://wiki.libsdl.org/SDL_UnionRect
  */
 int rect_testUnionRectOutside(void *arg)
 {
@@ -1298,7 +1298,7 @@ int rect_testUnionRectOutside(void *arg)
  * \brief Tests SDL_UnionRect() where rect A or rect B are empty
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_UnionRect
+ * http://wiki.libsdl.org/SDL_UnionRect
  */
 int rect_testUnionRectEmpty(void *arg)
 {
@@ -1363,7 +1363,7 @@ int rect_testUnionRectEmpty(void *arg)
  * \brief Tests SDL_UnionRect() where rect B is inside rect A
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_UnionRect
+ * http://wiki.libsdl.org/SDL_UnionRect
  */
 int rect_testUnionRectInside(void *arg)
 {
@@ -1427,7 +1427,7 @@ int rect_testUnionRectInside(void *arg)
  * \brief Negative tests against SDL_UnionRect() with invalid parameters
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_UnionRect
+ * http://wiki.libsdl.org/SDL_UnionRect
  */
 int rect_testUnionRectParam(void *arg)
 {
@@ -1455,7 +1455,7 @@ int rect_testUnionRectParam(void *arg)
  * \brief Tests SDL_RectEmpty() with various inputs
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_RectEmpty
+ * http://wiki.libsdl.org/SDL_RectEmpty
  */
 int rect_testRectEmpty(void *arg)
 {
@@ -1498,7 +1498,7 @@ int rect_testRectEmpty(void *arg)
  * \brief Negative tests against SDL_RectEmpty() with invalid parameters
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_RectEmpty
+ * http://wiki.libsdl.org/SDL_RectEmpty
  */
 int rect_testRectEmptyParam(void *arg)
 {
@@ -1515,7 +1515,7 @@ int rect_testRectEmptyParam(void *arg)
  * \brief Tests SDL_RectEquals() with various inputs
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_RectEquals
+ * http://wiki.libsdl.org/SDL_RectEquals
  */
 int rect_testRectEquals(void *arg)
 {
@@ -1545,7 +1545,7 @@ int rect_testRectEquals(void *arg)
  * \brief Negative tests against SDL_RectEquals() with invalid parameters
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_RectEquals
+ * http://wiki.libsdl.org/SDL_RectEquals
  */
 int rect_testRectEqualsParam(void *arg)
 {
@@ -1678,7 +1678,7 @@ static const SDLTest_TestCaseReference rectTest29 =
  * \brief Sequence of Rect test cases; functions that handle simple rectangles including overlaps and merges.
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/CategoryRect
+ * http://wiki.libsdl.org/CategoryRect
  */
 static const SDLTest_TestCaseReference *rectTests[] =  {
     &rectTest1, &rectTest2, &rectTest3, &rectTest4, &rectTest5, &rectTest6, &rectTest7, &rectTest8, &rectTest9, &rectTest10, &rectTest11, &rectTest12, &rectTest13, &rectTest14,
diff --git a/Engine/lib/sdl/test/testautomation_render.c b/Engine/lib/sdl/test/testautomation_render.c
index 5a1bc9b8c..0117334a2 100644
--- a/Engine/lib/sdl/test/testautomation_render.c
+++ b/Engine/lib/sdl/test/testautomation_render.c
@@ -83,7 +83,7 @@ void CleanupDestroyRenderer(void *arg)
  * @brief Tests call to SDL_GetNumRenderDrivers
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_GetNumRenderDrivers
+ * http://wiki.libsdl.org/SDL_GetNumRenderDrivers
  */
 int
 render_testGetNumRenderDrivers(void *arg)
@@ -99,9 +99,9 @@ render_testGetNumRenderDrivers(void *arg)
  * @brief Tests the SDL primitives for rendering.
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_SetRenderDrawColor
- * http://wiki.libsdl.org/moin.cgi/SDL_RenderFillRect
- * http://wiki.libsdl.org/moin.cgi/SDL_RenderDrawLine
+ * http://wiki.libsdl.org/SDL_SetRenderDrawColor
+ * http://wiki.libsdl.org/SDL_RenderFillRect
+ * http://wiki.libsdl.org/SDL_RenderDrawLine
  *
  */
 int render_testPrimitives (void *arg)
@@ -187,14 +187,14 @@ int render_testPrimitives (void *arg)
 
    ret = SDL_RenderDrawLine(renderer, 79, 59, 50, 30 );
    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderDrawLine, expected: 0, got: %i", ret);
-   
-   /* Make current */
-   SDL_RenderPresent(renderer);
-   
+
    /* See if it's the same. */
    referenceSurface = SDLTest_ImagePrimitives();
    _compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE );
 
+   /* Make current */
+   SDL_RenderPresent(renderer);
+
    /* Clean up. */
    SDL_FreeSurface(referenceSurface);
    referenceSurface = NULL;
@@ -206,9 +206,9 @@ int render_testPrimitives (void *arg)
  * @brief Tests the SDL primitives with alpha for rendering.
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_SetRenderDrawColor
- * http://wiki.libsdl.org/moin.cgi/SDL_SetRenderDrawBlendMode
- * http://wiki.libsdl.org/moin.cgi/SDL_RenderFillRect
+ * http://wiki.libsdl.org/SDL_SetRenderDrawColor
+ * http://wiki.libsdl.org/SDL_SetRenderDrawBlendMode
+ * http://wiki.libsdl.org/SDL_RenderFillRect
  */
 int render_testPrimitivesBlend (void *arg)
 {
@@ -335,13 +335,13 @@ int render_testPrimitivesBlend (void *arg)
    SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_SetRenderDrawBlendMode, expected: 0, got: %i", checkFailCount2);
    SDLTest_AssertCheck(checkFailCount3 == 0, "Validate results from calls to SDL_RenderDrawPoint, expected: 0, got: %i", checkFailCount3);
 
-   /* Make current */
-   SDL_RenderPresent(renderer);
-
    /* See if it's the same. */
    referenceSurface = SDLTest_ImagePrimitivesBlend();
    _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED );
 
+   /* Make current */
+   SDL_RenderPresent(renderer);
+
    /* Clean up. */
    SDL_FreeSurface(referenceSurface);
    referenceSurface = NULL;
@@ -355,8 +355,8 @@ int render_testPrimitivesBlend (void *arg)
  * @brief Tests some blitting routines.
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_RenderCopy
- * http://wiki.libsdl.org/moin.cgi/SDL_DestroyTexture
+ * http://wiki.libsdl.org/SDL_RenderCopy
+ * http://wiki.libsdl.org/SDL_DestroyTexture
  */
 int
 render_testBlit(void *arg)
@@ -404,13 +404,13 @@ render_testBlit(void *arg)
    }
    SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_RenderCopy, expected: 0, got: %i", checkFailCount1);
 
-   /* Make current */
-   SDL_RenderPresent(renderer);
-
    /* See if it's the same */
    referenceSurface = SDLTest_ImageBlit();
    _compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE );
 
+   /* Make current */
+   SDL_RenderPresent(renderer);
+
    /* Clean up. */
    SDL_DestroyTexture( tface );
    SDL_FreeSurface(referenceSurface);
@@ -424,9 +424,9 @@ render_testBlit(void *arg)
  * @brief Blits doing color tests.
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_SetTextureColorMod
- * http://wiki.libsdl.org/moin.cgi/SDL_RenderCopy
- * http://wiki.libsdl.org/moin.cgi/SDL_DestroyTexture
+ * http://wiki.libsdl.org/SDL_SetTextureColorMod
+ * http://wiki.libsdl.org/SDL_RenderCopy
+ * http://wiki.libsdl.org/SDL_DestroyTexture
  */
 int
 render_testBlitColor (void *arg)
@@ -478,13 +478,13 @@ render_testBlitColor (void *arg)
    SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_SetTextureColorMod, expected: 0, got: %i", checkFailCount1);
    SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_RenderCopy, expected: 0, got: %i", checkFailCount2);
 
-   /* Make current */
-   SDL_RenderPresent(renderer);
-
    /* See if it's the same. */
    referenceSurface = SDLTest_ImageBlitColor();
    _compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE );
 
+   /* Make current */
+   SDL_RenderPresent(renderer);
+
    /* Clean up. */
    SDL_DestroyTexture( tface );
    SDL_FreeSurface(referenceSurface);
@@ -498,9 +498,9 @@ render_testBlitColor (void *arg)
  * @brief Tests blitting with alpha.
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_SetTextureAlphaMod
- * http://wiki.libsdl.org/moin.cgi/SDL_RenderCopy
- * http://wiki.libsdl.org/moin.cgi/SDL_DestroyTexture
+ * http://wiki.libsdl.org/SDL_SetTextureAlphaMod
+ * http://wiki.libsdl.org/SDL_RenderCopy
+ * http://wiki.libsdl.org/SDL_DestroyTexture
  */
 int
 render_testBlitAlpha (void *arg)
@@ -555,13 +555,13 @@ render_testBlitAlpha (void *arg)
    SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_SetTextureAlphaMod, expected: 0, got: %i", checkFailCount1);
    SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_RenderCopy, expected: 0, got: %i", checkFailCount2);
 
-   /* Make current */
-   SDL_RenderPresent(renderer);
-
    /* See if it's the same. */
    referenceSurface = SDLTest_ImageBlitAlpha();
    _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED );
 
+   /* Make current */
+   SDL_RenderPresent(renderer);
+
    /* Clean up. */
    SDL_DestroyTexture( tface );
    SDL_FreeSurface(referenceSurface);
@@ -576,8 +576,8 @@ render_testBlitAlpha (void *arg)
  * @brief Tests a blend mode.
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_SetTextureBlendMode
- * http://wiki.libsdl.org/moin.cgi/SDL_RenderCopy
+ * http://wiki.libsdl.org/SDL_SetTextureBlendMode
+ * http://wiki.libsdl.org/SDL_RenderCopy
  */
 static void
 _testBlitBlendMode( SDL_Texture * tface, int mode )
@@ -626,10 +626,10 @@ _testBlitBlendMode( SDL_Texture * tface, int mode )
  * @brief Tests some more blitting routines.
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_SetTextureColorMod
- * http://wiki.libsdl.org/moin.cgi/SDL_SetTextureAlphaMod
- * http://wiki.libsdl.org/moin.cgi/SDL_SetTextureBlendMode
- * http://wiki.libsdl.org/moin.cgi/SDL_DestroyTexture
+ * http://wiki.libsdl.org/SDL_SetTextureColorMod
+ * http://wiki.libsdl.org/SDL_SetTextureAlphaMod
+ * http://wiki.libsdl.org/SDL_SetTextureBlendMode
+ * http://wiki.libsdl.org/SDL_DestroyTexture
  */
 int
 render_testBlitBlend (void *arg)
@@ -674,9 +674,10 @@ render_testBlitBlend (void *arg)
    _testBlitBlendMode( tface, SDL_BLENDMODE_NONE );
    referenceSurface = SDLTest_ImageBlitBlendNone();
 
-   /* Make current and compare */
-   SDL_RenderPresent(renderer);
+   /* Compare, then Present */
    _compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE );
+   SDL_RenderPresent(renderer);
+
    SDL_FreeSurface(referenceSurface);
    referenceSurface = NULL;
 
@@ -684,9 +685,10 @@ render_testBlitBlend (void *arg)
    _testBlitBlendMode( tface, SDL_BLENDMODE_BLEND );
    referenceSurface = SDLTest_ImageBlitBlend();
 
-   /* Make current and compare */
-   SDL_RenderPresent(renderer);
+   /* Compare, then Present */
    _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED );
+   SDL_RenderPresent(renderer);
+
    SDL_FreeSurface(referenceSurface);
    referenceSurface = NULL;
 
@@ -694,9 +696,10 @@ render_testBlitBlend (void *arg)
    _testBlitBlendMode( tface, SDL_BLENDMODE_ADD );
    referenceSurface = SDLTest_ImageBlitBlendAdd();
 
-   /* Make current and compare */
-   SDL_RenderPresent(renderer);
+   /* Compare, then Present */
    _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED );
+   SDL_RenderPresent(renderer);
+
    SDL_FreeSurface(referenceSurface);
    referenceSurface = NULL;
 
@@ -704,9 +707,10 @@ render_testBlitBlend (void *arg)
    _testBlitBlendMode( tface, SDL_BLENDMODE_MOD);
    referenceSurface = SDLTest_ImageBlitBlendMod();
 
-   /* Make current and compare */
-   SDL_RenderPresent(renderer);
+   /* Compare, then Present */
    _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED );
+   SDL_RenderPresent(renderer);
+
    SDL_FreeSurface(referenceSurface);
    referenceSurface = NULL;
 
@@ -753,12 +757,13 @@ render_testBlitBlend (void *arg)
    /* Clean up. */
    SDL_DestroyTexture( tface );
 
-   /* Make current */
-   SDL_RenderPresent(renderer);
-
    /* Check to see if final image matches. */
    referenceSurface = SDLTest_ImageBlitBlendAll();
    _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED);
+
+   /* Make current */
+   SDL_RenderPresent(renderer);
+
    SDL_FreeSurface(referenceSurface);
    referenceSurface = NULL;
 
@@ -779,8 +784,8 @@ _isSupported( int code )
  * @brief Test to see if we can vary the draw color. Helper function.
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_SetRenderDrawColor
- * http://wiki.libsdl.org/moin.cgi/SDL_GetRenderDrawColor
+ * http://wiki.libsdl.org/SDL_SetRenderDrawColor
+ * http://wiki.libsdl.org/SDL_GetRenderDrawColor
  */
 static int
 _hasDrawColor (void)
@@ -817,8 +822,8 @@ _hasDrawColor (void)
  * @brief Test to see if we can vary the blend mode. Helper function.
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_SetRenderDrawBlendMode
- * http://wiki.libsdl.org/moin.cgi/SDL_GetRenderDrawBlendMode
+ * http://wiki.libsdl.org/SDL_SetRenderDrawBlendMode
+ * http://wiki.libsdl.org/SDL_GetRenderDrawBlendMode
  */
 static int
 _hasBlendModes (void)
@@ -874,7 +879,7 @@ _hasBlendModes (void)
  * @brief Loads the test image 'Face' as texture. Helper function.
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_CreateTextureFromSurface
+ * http://wiki.libsdl.org/SDL_CreateTextureFromSurface
  */
 static SDL_Texture *
 _loadTestFace(void)
@@ -902,9 +907,9 @@ _loadTestFace(void)
  * @brief Test to see if can set texture color mode. Helper function.
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_SetTextureColorMod
- * http://wiki.libsdl.org/moin.cgi/SDL_GetTextureColorMod
- * http://wiki.libsdl.org/moin.cgi/SDL_DestroyTexture
+ * http://wiki.libsdl.org/SDL_SetTextureColorMod
+ * http://wiki.libsdl.org/SDL_GetTextureColorMod
+ * http://wiki.libsdl.org/SDL_DestroyTexture
  */
 static int
 _hasTexColor (void)
@@ -942,9 +947,9 @@ _hasTexColor (void)
  * @brief Test to see if we can vary the alpha of the texture. Helper function.
  *
  * \sa
- *  http://wiki.libsdl.org/moin.cgi/SDL_SetTextureAlphaMod
- *  http://wiki.libsdl.org/moin.cgi/SDL_GetTextureAlphaMod
- *  http://wiki.libsdl.org/moin.cgi/SDL_DestroyTexture
+ *  http://wiki.libsdl.org/SDL_SetTextureAlphaMod
+ *  http://wiki.libsdl.org/SDL_GetTextureAlphaMod
+ *  http://wiki.libsdl.org/SDL_DestroyTexture
  */
 static int
 _hasTexAlpha(void)
@@ -984,9 +989,9 @@ _hasTexAlpha(void)
  * @param s Image to compare against.
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_RenderReadPixels
- * http://wiki.libsdl.org/moin.cgi/SDL_CreateRGBSurfaceFrom
- * http://wiki.libsdl.org/moin.cgi/SDL_FreeSurface
+ * http://wiki.libsdl.org/SDL_RenderReadPixels
+ * http://wiki.libsdl.org/SDL_CreateRGBSurfaceFrom
+ * http://wiki.libsdl.org/SDL_FreeSurface
  */
 static void
 _compare(SDL_Surface *referenceSurface, int allowable_error)
@@ -1027,10 +1032,10 @@ _compare(SDL_Surface *referenceSurface, int allowable_error)
  * @brief Clears the screen. Helper function.
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_SetRenderDrawColor
- * http://wiki.libsdl.org/moin.cgi/SDL_RenderClear
- * http://wiki.libsdl.org/moin.cgi/SDL_RenderPresent
- * http://wiki.libsdl.org/moin.cgi/SDL_SetRenderDrawBlendMode
+ * http://wiki.libsdl.org/SDL_SetRenderDrawColor
+ * http://wiki.libsdl.org/SDL_RenderClear
+ * http://wiki.libsdl.org/SDL_RenderPresent
+ * http://wiki.libsdl.org/SDL_SetRenderDrawBlendMode
  */
 static int
 _clearScreen(void)
diff --git a/Engine/lib/sdl/test/testautomation_rwops.c b/Engine/lib/sdl/test/testautomation_rwops.c
index b5d5b1d32..a7d3c3272 100644
--- a/Engine/lib/sdl/test/testautomation_rwops.c
+++ b/Engine/lib/sdl/test/testautomation_rwops.c
@@ -88,8 +88,8 @@ RWopsTearDown(void *arg)
  * @brief Makes sure parameters work properly. Local helper function.
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_RWseek
- * http://wiki.libsdl.org/moin.cgi/SDL_RWread
+ * http://wiki.libsdl.org/SDL_RWseek
+ * http://wiki.libsdl.org/SDL_RWread
  */
 void
 _testGenericRWopsValidations(SDL_RWops *rw, int write)
@@ -168,7 +168,7 @@ _testGenericRWopsValidations(SDL_RWops *rw, int write)
 /* !
  * Negative test for SDL_RWFromFile parameters
  *
- * \sa http://wiki.libsdl.org/moin.cgi/SDL_RWFromFile
+ * \sa http://wiki.libsdl.org/SDL_RWFromFile
  *
  */
 int
@@ -215,8 +215,8 @@ rwops_testParamNegative (void)
 /**
  * @brief Tests opening from memory.
  *
- * \sa http://wiki.libsdl.org/moin.cgi/SDL_RWFromMem
- * \sa http://wiki.libsdl.org/moin.cgi/SDL_RWClose
+ * \sa http://wiki.libsdl.org/SDL_RWFromMem
+ * \sa http://wiki.libsdl.org/SDL_RWClose
  */
 int
 rwops_testMem (void)
@@ -255,8 +255,8 @@ rwops_testMem (void)
  * @brief Tests opening from memory.
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_RWFromConstMem
- * http://wiki.libsdl.org/moin.cgi/SDL_RWClose
+ * http://wiki.libsdl.org/SDL_RWFromConstMem
+ * http://wiki.libsdl.org/SDL_RWClose
  */
 int
 rwops_testConstMem (void)
@@ -291,8 +291,8 @@ rwops_testConstMem (void)
  * @brief Tests reading from file.
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_RWFromFile
- * http://wiki.libsdl.org/moin.cgi/SDL_RWClose
+ * http://wiki.libsdl.org/SDL_RWFromFile
+ * http://wiki.libsdl.org/SDL_RWClose
  */
 int
 rwops_testFileRead(void)
@@ -338,8 +338,8 @@ rwops_testFileRead(void)
  * @brief Tests writing from file.
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_RWFromFile
- * http://wiki.libsdl.org/moin.cgi/SDL_RWClose
+ * http://wiki.libsdl.org/SDL_RWFromFile
+ * http://wiki.libsdl.org/SDL_RWClose
  */
 int
 rwops_testFileWrite(void)
@@ -386,8 +386,8 @@ rwops_testFileWrite(void)
  * @brief Tests reading from file handle
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_RWFromFP
- * http://wiki.libsdl.org/moin.cgi/SDL_RWClose
+ * http://wiki.libsdl.org/SDL_RWFromFP
+ * http://wiki.libsdl.org/SDL_RWClose
  *
  */
 int
@@ -436,8 +436,8 @@ rwops_testFPRead(void)
  * @brief Tests writing to file handle
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_RWFromFP
- * http://wiki.libsdl.org/moin.cgi/SDL_RWClose
+ * http://wiki.libsdl.org/SDL_RWFromFP
+ * http://wiki.libsdl.org/SDL_RWClose
  *
  */
 int
@@ -484,8 +484,8 @@ rwops_testFPWrite(void)
 /**
  * @brief Tests alloc and free RW context.
  *
- * \sa http://wiki.libsdl.org/moin.cgi/SDL_AllocRW
- * \sa http://wiki.libsdl.org/moin.cgi/SDL_FreeRW
+ * \sa http://wiki.libsdl.org/SDL_AllocRW
+ * \sa http://wiki.libsdl.org/SDL_FreeRW
  */
 int
 rwops_testAllocFree (void)
@@ -511,8 +511,8 @@ rwops_testAllocFree (void)
 /**
  * @brief Compare memory and file reads
  *
- * \sa http://wiki.libsdl.org/moin.cgi/SDL_RWFromMem
- * \sa http://wiki.libsdl.org/moin.cgi/SDL_RWFromFile
+ * \sa http://wiki.libsdl.org/SDL_RWFromMem
+ * \sa http://wiki.libsdl.org/SDL_RWFromFile
  */
 int
 rwops_testCompareRWFromMemWithRWFromFile(void)
@@ -578,10 +578,10 @@ rwops_testCompareRWFromMemWithRWFromFile(void)
  * @brief Tests writing and reading from file using endian aware functions.
  *
  * \sa
- * http://wiki.libsdl.org/moin.cgi/SDL_RWFromFile
- * http://wiki.libsdl.org/moin.cgi/SDL_RWClose
- * http://wiki.libsdl.org/moin.cgi/SDL_ReadBE16
- * http://wiki.libsdl.org/moin.cgi/SDL_WriteBE16
+ * http://wiki.libsdl.org/SDL_RWFromFile
+ * http://wiki.libsdl.org/SDL_RWClose
+ * http://wiki.libsdl.org/SDL_ReadBE16
+ * http://wiki.libsdl.org/SDL_WriteBE16
  */
 int
 rwops_testFileWriteReadEndian(void)
diff --git a/Engine/lib/sdl/test/testautomation_sdltest.c b/Engine/lib/sdl/test/testautomation_sdltest.c
index 339b7c168..809664dc3 100644
--- a/Engine/lib/sdl/test/testautomation_sdltest.c
+++ b/Engine/lib/sdl/test/testautomation_sdltest.c
@@ -89,7 +89,6 @@ int
 sdltest_randomNumber(void *arg)
 {
   Sint64 result;
-  Uint64 uresult;
   double dresult;
   Uint64 umax;
   Sint64 min, max;
@@ -127,7 +126,7 @@ sdltest_randomNumber(void *arg)
   SDLTest_AssertPass("Call to SDLTest_RandomSint32");
   SDLTest_AssertCheck(result >= min && result <= max, "Verify result value, expected: [%"SDL_PRIs64",%"SDL_PRIs64"], got: %"SDL_PRIs64, min, max, result);
 
-  uresult = SDLTest_RandomUint64();
+  SDLTest_RandomUint64();
   SDLTest_AssertPass("Call to SDLTest_RandomUint64");
 
   result = SDLTest_RandomSint64();
@@ -1132,7 +1131,7 @@ sdltest_randomAsciiString(void *arg)
      SDLTest_AssertCheck(len >= 1 && len <= 255, "Validate that result length; expected: len=[1,255], got: %d", (int) len);
      nonAsciiCharacters = 0;
      for (i=0; i<len; i++) {
-       if (iscntrl(result[i])) {
+       if (SDL_iscntrl(result[i])) {
          nonAsciiCharacters++;
        }
      }
@@ -1170,7 +1169,7 @@ sdltest_randomAsciiStringWithMaximumLength(void *arg)
      SDLTest_AssertCheck(len >= 1 && len <= targetLen, "Validate that result length; expected: len=[1,%d], got: %d", (int) targetLen, (int) len);
      nonAsciiCharacters = 0;
      for (i=0; i<len; i++) {
-       if (iscntrl(result[i])) {
+       if (SDL_iscntrl(result[i])) {
          nonAsciiCharacters++;
        }
      }
@@ -1224,7 +1223,7 @@ sdltest_randomAsciiStringOfSize(void *arg)
      SDLTest_AssertCheck(len == targetLen, "Validate that result length; expected: len=%d, got: %d", (int) targetLen, (int) len);
      nonAsciiCharacters = 0;
      for (i=0; i<len; i++) {
-       if (iscntrl(result[i])) {
+       if (SDL_iscntrl(result[i])) {
          nonAsciiCharacters++;
        }
      }
diff --git a/Engine/lib/sdl/test/testautomation_stdlib.c b/Engine/lib/sdl/test/testautomation_stdlib.c
index e741d547e..bfc8ad373 100644
--- a/Engine/lib/sdl/test/testautomation_stdlib.c
+++ b/Engine/lib/sdl/test/testautomation_stdlib.c
@@ -44,6 +44,7 @@ int
 stdlib_snprintf(void *arg)
 {
   int result;
+  int predicted;
   char text[1024];
   const char *expected;
 
@@ -60,55 +61,86 @@ stdlib_snprintf(void *arg)
   SDLTest_AssertCheck(result == 3, "Check result value, expected: 3, got: %d", result);
 
   result = SDL_snprintf(NULL, 0, "%s", "foo");
+  SDLTest_AssertPass("Call to SDL_snprintf(NULL, 0, \"%%s\", \"foo\")");
   SDLTest_AssertCheck(result == 3, "Check result value, expected: 3, got: %d", result);
 
+  result = SDL_snprintf(text, 2, "%s\n", "foo");
+  expected = "f";
+  SDLTest_AssertPass("Call to SDL_snprintf(\"%%s\\n\", \"foo\") with buffer size 2");
+  SDLTest_AssertCheck(SDL_strcmp(text, expected) == 0, "Check text, expected: %s, got: %s", expected, text);
+  SDLTest_AssertCheck(result == 4, "Check result value, expected: 4, got: %d", result);
+
+  result = SDL_snprintf(text, sizeof(text), "%f", 0.0);
+  predicted = SDL_snprintf(NULL, 0, "%f", 0.0);
+  expected = "0.000000";
+  SDLTest_AssertPass("Call to SDL_snprintf(\"%%f\", 0.0)");
+  SDLTest_AssertCheck(SDL_strcmp(text, expected) == 0, "Check text, expected: %s, got: %s", expected, text);
+  SDLTest_AssertCheck(result == SDL_strlen(text), "Check result value, expected: %d, got: %d", (int) SDL_strlen(text), result);
+  SDLTest_AssertCheck(predicted == result, "Check predicted value, expected: %d, got: %d", result, predicted);
+
   result = SDL_snprintf(text, sizeof(text), "%f", 1.0);
+  predicted = SDL_snprintf(NULL, 0, "%f", 1.0);
   expected = "1.000000";
   SDLTest_AssertPass("Call to SDL_snprintf(\"%%f\", 1.0)");
   SDLTest_AssertCheck(SDL_strcmp(text, expected) == 0, "Check text, expected: %s, got: %s", expected, text);
   SDLTest_AssertCheck(result == SDL_strlen(text), "Check result value, expected: %d, got: %d", (int) SDL_strlen(text), result);
+  SDLTest_AssertCheck(predicted == result, "Check predicted value, expected: %d, got: %d", result, predicted);
 
   result = SDL_snprintf(text, sizeof(text), "%.f", 1.0);
+  predicted = SDL_snprintf(NULL, 0, "%.f", 1.0);
   expected = "1";
   SDLTest_AssertPass("Call to SDL_snprintf(\"%%.f\", 1.0)");
   SDLTest_AssertCheck(SDL_strcmp(text, expected) == 0, "Check text, expected: %s, got: %s", expected, text);
   SDLTest_AssertCheck(result == SDL_strlen(text), "Check result value, expected: %d, got: %d", (int) SDL_strlen(text), result);
+  SDLTest_AssertCheck(predicted == result, "Check predicted value, expected: %d, got: %d", result, predicted);
 
   result = SDL_snprintf(text, sizeof(text), "%#.f", 1.0);
+  predicted = SDL_snprintf(NULL, 0, "%#.f", 1.0);
   expected = "1.";
   SDLTest_AssertPass("Call to SDL_snprintf(\"%%#.f\", 1.0)");
   SDLTest_AssertCheck(SDL_strcmp(text, expected) == 0, "Check text, expected: %s, got: %s", expected, text);
   SDLTest_AssertCheck(result == SDL_strlen(text), "Check result value, expected: %d, got: %d", (int) SDL_strlen(text), result);
+  SDLTest_AssertCheck(predicted == result, "Check predicted value, expected: %d, got: %d", result, predicted);
 
   result = SDL_snprintf(text, sizeof(text), "%f", 1.0 + 1.0 / 3.0);
+  predicted = SDL_snprintf(NULL, 0, "%f", 1.0 + 1.0 / 3.0);
   expected = "1.333333";
   SDLTest_AssertPass("Call to SDL_snprintf(\"%%f\", 1.0 + 1.0 / 3.0)");
   SDLTest_AssertCheck(SDL_strcmp(text, expected) == 0, "Check text, expected: %s, got: %s", expected, text);
   SDLTest_AssertCheck(result == SDL_strlen(text), "Check result value, expected: %d, got: %d", (int) SDL_strlen(text), result);
+  SDLTest_AssertCheck(predicted == result, "Check predicted value, expected: %d, got: %d", result, predicted);
 
   result = SDL_snprintf(text, sizeof(text), "%+f", 1.0 + 1.0 / 3.0);
+  predicted = SDL_snprintf(NULL, 0, "%+f", 1.0 + 1.0 / 3.0);
   expected = "+1.333333";
   SDLTest_AssertPass("Call to SDL_snprintf(\"%%+f\", 1.0 + 1.0 / 3.0)");
   SDLTest_AssertCheck(SDL_strcmp(text, expected) == 0, "Check text, expected: %s, got: %s", expected, text);
   SDLTest_AssertCheck(result == SDL_strlen(text), "Check result value, expected: %d, got: %d", (int) SDL_strlen(text), result);
+  SDLTest_AssertCheck(predicted == result, "Check predicted value, expected: %d, got: %d", result, predicted);
 
   result = SDL_snprintf(text, sizeof(text), "%.2f", 1.0 + 1.0 / 3.0);
+  predicted = SDL_snprintf(NULL, 0, "%.2f", 1.0 + 1.0 / 3.0);
   expected = "1.33";
   SDLTest_AssertPass("Call to SDL_snprintf(\"%%.2f\", 1.0 + 1.0 / 3.0)");
   SDLTest_AssertCheck(SDL_strcmp(text, expected) == 0, "Check text, expected: %s, got: %s", expected, text);
   SDLTest_AssertCheck(result == SDL_strlen(text), "Check result value, expected: %d, got: %d", (int) SDL_strlen(text), result);
+  SDLTest_AssertCheck(predicted == result, "Check predicted value, expected: %d, got: %d", result, predicted);
 
   result = SDL_snprintf(text, sizeof(text), "%6.2f", 1.0 + 1.0 / 3.0);
+  predicted = SDL_snprintf(NULL, 0, "%6.2f", 1.0 + 1.0 / 3.0);
   expected = "  1.33";
   SDLTest_AssertPass("Call to SDL_snprintf(\"%%6.2f\", 1.0 + 1.0 / 3.0)");
   SDLTest_AssertCheck(SDL_strcmp(text, expected) == 0, "Check text, expected: '%s', got: '%s'", expected, text);
   SDLTest_AssertCheck(result == SDL_strlen(text), "Check result value, expected: %d, got: %d", (int) SDL_strlen(text), result);
+  SDLTest_AssertCheck(predicted == result, "Check predicted value, expected: %d, got: %d", result, predicted);
 
   result = SDL_snprintf(text, sizeof(text), "%06.2f", 1.0 + 1.0 / 3.0);
+  predicted = SDL_snprintf(NULL, 0, "%06.2f", 1.0 + 1.0 / 3.0);
   expected = "001.33";
   SDLTest_AssertPass("Call to SDL_snprintf(\"%%06.2f\", 1.0 + 1.0 / 3.0)");
   SDLTest_AssertCheck(SDL_strcmp(text, expected) == 0, "Check text, expected: '%s', got: '%s'", expected, text);
   SDLTest_AssertCheck(result == SDL_strlen(text), "Check result value, expected: %d, got: %d", (int) SDL_strlen(text), result);
+  SDLTest_AssertCheck(predicted == result, "Check predicted value, expected: %d, got: %d", result, predicted);
 
   result = SDL_snprintf(text, 5, "%06.2f", 1.0 + 1.0 / 3.0);
   expected = "001.";
diff --git a/Engine/lib/sdl/test/testautomation_video.c b/Engine/lib/sdl/test/testautomation_video.c
index 7b86cfba9..342848ac0 100644
--- a/Engine/lib/sdl/test/testautomation_video.c
+++ b/Engine/lib/sdl/test/testautomation_video.c
@@ -265,7 +265,7 @@ video_createWindowVariousFlags(void *arg)
   w = SDLTest_RandomIntegerInRange(320, 1024);
   h = SDLTest_RandomIntegerInRange(320, 768);
 
-  for (fVariation = 0; fVariation < 13; fVariation++) {
+  for (fVariation = 0; fVariation < 14; fVariation++) {
     switch(fVariation) {
      case 0:
       flags = SDL_WINDOW_FULLSCREEN;
@@ -299,7 +299,7 @@ video_createWindowVariousFlags(void *arg)
       flags = SDL_WINDOW_MAXIMIZED;
       break;
      case 9:
-      flags = SDL_WINDOW_INPUT_GRABBED;
+      flags = SDL_WINDOW_MOUSE_GRABBED;
       break;
      case 10:
       flags = SDL_WINDOW_INPUT_FOCUS;
@@ -310,6 +310,9 @@ video_createWindowVariousFlags(void *arg)
      case 12:
       flags = SDL_WINDOW_FOREIGN;
       break;
+     case 13:
+      flags = SDL_WINDOW_KEYBOARD_GRABBED;
+      break;
     }
 
     window = SDL_CreateWindow(title, x, y, w, h, flags);
@@ -474,7 +477,6 @@ video_getClosestDisplayModeRandomResolution(void *arg)
 {
   SDL_DisplayMode target;
   SDL_DisplayMode closest;
-  SDL_DisplayMode* dResult;
   int displayNum;
   int i;
   int variation;
@@ -497,7 +499,7 @@ video_getClosestDisplayModeRandomResolution(void *arg)
       target.driverdata = 0;
 
       /* Make call; may or may not find anything, so don't validate any further */
-      dResult = SDL_GetClosestDisplayMode(i, &target, &closest);
+      SDL_GetClosestDisplayMode(i, &target, &closest);
       SDLTest_AssertPass("Call to SDL_GetClosestDisplayMode(target=random/variation%d)", variation);
     }
   }
@@ -508,7 +510,7 @@ video_getClosestDisplayModeRandomResolution(void *arg)
 /**
  * @brief Tests call to SDL_GetWindowBrightness
  *
-* @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowBrightness
+* @sa http://wiki.libsdl.org/SDL_GetWindowBrightness
  */
 int
 video_getWindowBrightness(void *arg)
@@ -534,7 +536,7 @@ video_getWindowBrightness(void *arg)
 /**
  * @brief Tests call to SDL_GetWindowBrightness with invalid input
  *
-* @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowBrightness
+* @sa http://wiki.libsdl.org/SDL_GetWindowBrightness
  */
 int
 video_getWindowBrightnessNegative(void *arg)
@@ -563,7 +565,7 @@ video_getWindowBrightnessNegative(void *arg)
 /**
  * @brief Tests call to SDL_GetWindowDisplayMode
  *
- * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowDisplayMode
+ * @sa http://wiki.libsdl.org/SDL_GetWindowDisplayMode
  */
 int
 video_getWindowDisplayMode(void *arg)
@@ -617,7 +619,7 @@ void _checkInvalidWindowError()
 /**
  * @brief Tests call to SDL_GetWindowDisplayMode with invalid input
  *
- * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowDisplayMode
+ * @sa http://wiki.libsdl.org/SDL_GetWindowDisplayMode
  */
 int
 video_getWindowDisplayModeNegative(void *arg)
@@ -661,7 +663,7 @@ video_getWindowDisplayModeNegative(void *arg)
 /**
  * @brief Tests call to SDL_GetWindowGammaRamp
  *
- * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowGammaRamp
+ * @sa http://wiki.libsdl.org/SDL_GetWindowGammaRamp
  */
 int
 video_getWindowGammaRamp(void *arg)
@@ -722,7 +724,7 @@ video_getWindowGammaRamp(void *arg)
 /**
  * @brief Tests call to SDL_GetWindowGammaRamp with invalid input
  *
-* @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowGammaRamp
+* @sa http://wiki.libsdl.org/SDL_GetWindowGammaRamp
  */
 int
 video_getWindowGammaRampNegative(void *arg)
@@ -744,87 +746,213 @@ video_getWindowGammaRampNegative(void *arg)
   return TEST_COMPLETED;
 }
 
-/* Helper for setting and checking the window grab state */
+/* Helper for setting and checking the window mouse grab state */
 void
-_setAndCheckWindowGrabState(SDL_Window* window, SDL_bool desiredState)
+_setAndCheckWindowMouseGrabState(SDL_Window* window, SDL_bool desiredState)
 {
   SDL_bool currentState;
 
   /* Set state */
-  SDL_SetWindowGrab(window, desiredState);
-  SDLTest_AssertPass("Call to SDL_SetWindowGrab(%s)", (desiredState == SDL_FALSE) ? "SDL_FALSE" : "SDL_TRUE");
+  SDL_SetWindowMouseGrab(window, desiredState);
+  SDLTest_AssertPass("Call to SDL_SetWindowMouseGrab(%s)", (desiredState == SDL_FALSE) ? "SDL_FALSE" : "SDL_TRUE");
 
   /* Get and check state */
-  currentState = SDL_GetWindowGrab(window);
-  SDLTest_AssertPass("Call to SDL_GetWindowGrab()");
+  currentState = SDL_GetWindowMouseGrab(window);
+  SDLTest_AssertPass("Call to SDL_GetWindowMouseGrab()");
   SDLTest_AssertCheck(
       currentState == desiredState,
       "Validate returned state; expected: %s, got: %s",
       (desiredState == SDL_FALSE) ? "SDL_FALSE" : "SDL_TRUE",
       (currentState == SDL_FALSE) ? "SDL_FALSE" : "SDL_TRUE");
+
+  if (desiredState) {
+    SDLTest_AssertCheck(
+      SDL_GetGrabbedWindow() == window,
+      "Grabbed window should be to our window");
+    SDLTest_AssertCheck(
+      SDL_GetWindowGrab(window),
+      "SDL_GetWindowGrab() should return SDL_TRUE");
+    SDLTest_AssertCheck(
+      SDL_GetWindowFlags(window) & SDL_WINDOW_MOUSE_GRABBED,
+      "SDL_WINDOW_MOUSE_GRABBED should be set");
+  } else {
+    SDLTest_AssertCheck(
+      !(SDL_GetWindowFlags(window) & SDL_WINDOW_MOUSE_GRABBED),
+      "SDL_WINDOW_MOUSE_GRABBED should be unset");
+  }
+}
+
+/* Helper for setting and checking the window keyboard grab state */
+void
+_setAndCheckWindowKeyboardGrabState(SDL_Window* window, SDL_bool desiredState)
+{
+  SDL_bool currentState;
+
+  /* Set state */
+  SDL_SetWindowKeyboardGrab(window, desiredState);
+  SDLTest_AssertPass("Call to SDL_SetWindowKeyboardGrab(%s)", (desiredState == SDL_FALSE) ? "SDL_FALSE" : "SDL_TRUE");
+
+  /* Get and check state */
+  currentState = SDL_GetWindowKeyboardGrab(window);
+  SDLTest_AssertPass("Call to SDL_GetWindowKeyboardGrab()");
+  SDLTest_AssertCheck(
+      currentState == desiredState,
+      "Validate returned state; expected: %s, got: %s",
+      (desiredState == SDL_FALSE) ? "SDL_FALSE" : "SDL_TRUE",
+      (currentState == SDL_FALSE) ? "SDL_FALSE" : "SDL_TRUE");
+
+  if (desiredState) {
+    SDLTest_AssertCheck(
+      SDL_GetGrabbedWindow() == window,
+      "Grabbed window should be set to our window");
+    SDLTest_AssertCheck(
+      SDL_GetWindowGrab(window),
+      "SDL_GetWindowGrab() should return SDL_TRUE");
+    SDLTest_AssertCheck(
+      SDL_GetWindowFlags(window) & SDL_WINDOW_KEYBOARD_GRABBED,
+      "SDL_WINDOW_KEYBOARD_GRABBED should be set");
+  } else {
+    SDLTest_AssertCheck(
+      !(SDL_GetWindowFlags(window) & SDL_WINDOW_KEYBOARD_GRABBED),
+      "SDL_WINDOW_KEYBOARD_GRABBED should be unset");
+  }
 }
 
 /**
- * @brief Tests call to SDL_GetWindowGrab and SDL_SetWindowGrab
+ * @brief Tests keyboard and mouse grab support
  *
- * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowGrab
- * @sa http://wiki.libsdl.org/moin.fcg/SDL_SetWindowGrab
+ * @sa http://wiki.libsdl.org/SDL_GetWindowGrab
+ * @sa http://wiki.libsdl.org/SDL_SetWindowGrab
  */
 int
 video_getSetWindowGrab(void *arg)
 {
   const char* title = "video_getSetWindowGrab Test Window";
   SDL_Window* window;
-  SDL_bool originalState, dummyState, currentState, desiredState;
+  SDL_bool originalMouseState, originalKeyboardState;
 
   /* Call against new test window */
   window = _createVideoSuiteTestWindow(title);
   if (window == NULL) return TEST_ABORTED;
 
   /* Get state */
-  originalState = SDL_GetWindowGrab(window);
-  SDLTest_AssertPass("Call to SDL_GetWindowGrab()");
+  originalMouseState = SDL_GetWindowMouseGrab(window);
+  SDLTest_AssertPass("Call to SDL_GetWindowMouseGrab()");
+  originalKeyboardState = SDL_GetWindowKeyboardGrab(window);
+  SDLTest_AssertPass("Call to SDL_GetWindowKeyboardGrab()");
 
   /* F */
-  _setAndCheckWindowGrabState(window, SDL_FALSE);
+  _setAndCheckWindowKeyboardGrabState(window, SDL_FALSE);
+  _setAndCheckWindowMouseGrabState(window, SDL_FALSE);
+  SDLTest_AssertCheck(!SDL_GetWindowGrab(window),
+                      "SDL_GetWindowGrab should return SDL_FALSE");
+  SDLTest_AssertCheck(SDL_GetGrabbedWindow() == NULL,
+                      "Expected NULL grabbed window");
 
   /* F --> F */
-  _setAndCheckWindowGrabState(window, SDL_FALSE);
+  _setAndCheckWindowMouseGrabState(window, SDL_FALSE);
+  _setAndCheckWindowKeyboardGrabState(window, SDL_FALSE);
+  SDLTest_AssertCheck(SDL_GetGrabbedWindow() == NULL,
+                      "Expected NULL grabbed window");
 
   /* F --> T */
-  _setAndCheckWindowGrabState(window, SDL_TRUE);
+  _setAndCheckWindowMouseGrabState(window, SDL_TRUE);
+  _setAndCheckWindowKeyboardGrabState(window, SDL_TRUE);
+  SDLTest_AssertCheck(SDL_GetWindowGrab(window),
+                      "SDL_GetWindowGrab() should return SDL_TRUE");
 
   /* T --> T */
-  _setAndCheckWindowGrabState(window, SDL_TRUE);
+  _setAndCheckWindowKeyboardGrabState(window, SDL_TRUE);
+  _setAndCheckWindowMouseGrabState(window, SDL_TRUE);
+  SDLTest_AssertCheck(SDL_GetWindowGrab(window),
+                      "SDL_GetWindowGrab() should return SDL_TRUE");
 
-  /* T --> F */
-  _setAndCheckWindowGrabState(window, SDL_FALSE);
+  /* M: T --> F */
+  /* K: T --> T */
+  _setAndCheckWindowKeyboardGrabState(window, SDL_TRUE);
+  _setAndCheckWindowMouseGrabState(window, SDL_FALSE);
+  SDLTest_AssertCheck(SDL_GetWindowGrab(window),
+                      "SDL_GetWindowGrab() should return SDL_TRUE");
+
+  /* M: F --> T */
+  /* K: T --> F */
+  _setAndCheckWindowMouseGrabState(window, SDL_TRUE);
+  _setAndCheckWindowKeyboardGrabState(window, SDL_FALSE);
+  SDLTest_AssertCheck(SDL_GetWindowGrab(window),
+                      "SDL_GetWindowGrab() should return SDL_TRUE");
+
+  /* M: T --> F */
+  /* K: F --> F */
+  _setAndCheckWindowMouseGrabState(window, SDL_FALSE);
+  _setAndCheckWindowKeyboardGrabState(window, SDL_FALSE);
+  SDLTest_AssertCheck(!SDL_GetWindowGrab(window),
+                      "SDL_GetWindowGrab() should return SDL_FALSE");
+  SDLTest_AssertCheck(SDL_GetGrabbedWindow() == NULL,
+                      "Expected NULL grabbed window");
+
+  /* Using the older SDL_SetWindowGrab API should only grab mouse by default */
+  SDL_SetWindowGrab(window, SDL_TRUE);
+  SDLTest_AssertPass("Call to SDL_SetWindowGrab(SDL_TRUE)");
+  SDLTest_AssertCheck(SDL_GetWindowGrab(window),
+                      "SDL_GetWindowGrab() should return SDL_TRUE");
+  SDLTest_AssertCheck(SDL_GetWindowMouseGrab(window),
+                      "SDL_GetWindowMouseGrab() should return SDL_TRUE");
+  SDLTest_AssertCheck(!SDL_GetWindowKeyboardGrab(window),
+                      "SDL_GetWindowKeyboardGrab() should return SDL_FALSE");
+  SDL_SetWindowGrab(window, SDL_FALSE);
+  SDLTest_AssertCheck(!SDL_GetWindowGrab(window),
+                      "SDL_GetWindowGrab() should return SDL_FALSE");
+  SDLTest_AssertCheck(!SDL_GetWindowMouseGrab(window),
+                      "SDL_GetWindowMouseGrab() should return SDL_FALSE");
+  SDLTest_AssertCheck(!SDL_GetWindowKeyboardGrab(window),
+                      "SDL_GetWindowKeyboardGrab() should return SDL_FALSE");
+
+  /* Now test with SDL_HINT_GRAB_KEYBOARD set. We should get keyboard grab now. */
+  SDL_SetHint(SDL_HINT_GRAB_KEYBOARD, "1");
+  SDL_SetWindowGrab(window, SDL_TRUE);
+  SDLTest_AssertPass("Call to SDL_SetWindowGrab(SDL_TRUE)");
+  SDLTest_AssertCheck(SDL_GetWindowGrab(window),
+                      "SDL_GetWindowGrab() should return SDL_TRUE");
+  SDLTest_AssertCheck(SDL_GetWindowMouseGrab(window),
+                      "SDL_GetWindowMouseGrab() should return SDL_TRUE");
+  SDLTest_AssertCheck(SDL_GetWindowKeyboardGrab(window),
+                      "SDL_GetWindowKeyboardGrab() should return SDL_TRUE");
+  SDL_SetWindowGrab(window, SDL_FALSE);
+  SDLTest_AssertCheck(!SDL_GetWindowGrab(window),
+                      "SDL_GetWindowGrab() should return SDL_FALSE");
+  SDLTest_AssertCheck(!SDL_GetWindowMouseGrab(window),
+                      "SDL_GetWindowMouseGrab() should return SDL_FALSE");
+  SDLTest_AssertCheck(!SDL_GetWindowKeyboardGrab(window),
+                      "SDL_GetWindowKeyboardGrab() should return SDL_FALSE");
 
   /* Negative tests */
-  dummyState = SDL_GetWindowGrab(NULL);
+  SDL_GetWindowGrab(NULL);
   SDLTest_AssertPass("Call to SDL_GetWindowGrab(window=NULL)");
   _checkInvalidWindowError();
 
+  SDL_GetWindowKeyboardGrab(NULL);
+  SDLTest_AssertPass("Call to SDL_GetWindowKeyboardGrab(window=NULL)");
+  _checkInvalidWindowError();
+
   SDL_SetWindowGrab(NULL, SDL_FALSE);
   SDLTest_AssertPass("Call to SDL_SetWindowGrab(window=NULL,SDL_FALSE)");
   _checkInvalidWindowError();
 
-  SDL_SetWindowGrab(NULL, SDL_TRUE);
-  SDLTest_AssertPass("Call to SDL_SetWindowGrab(window=NULL,SDL_FALSE)");
+  SDL_SetWindowKeyboardGrab(NULL, SDL_FALSE);
+  SDLTest_AssertPass("Call to SDL_SetWindowKeyboardGrab(window=NULL,SDL_FALSE)");
   _checkInvalidWindowError();
 
-  /* State should still be F */
-  desiredState = SDL_FALSE;
-  currentState = SDL_GetWindowGrab(window);
-  SDLTest_AssertPass("Call to SDL_GetWindowGrab()");
-  SDLTest_AssertCheck(
-      currentState == desiredState,
-      "Validate returned state; expected: %s, got: %s",
-      (desiredState == SDL_FALSE) ? "SDL_FALSE" : "SDL_TRUE",
-      (currentState == SDL_FALSE) ? "SDL_FALSE" : "SDL_TRUE");
+  SDL_SetWindowGrab(NULL, SDL_TRUE);
+  SDLTest_AssertPass("Call to SDL_SetWindowGrab(window=NULL,SDL_TRUE)");
+  _checkInvalidWindowError();
+
+  SDL_SetWindowKeyboardGrab(NULL, SDL_TRUE);
+  SDLTest_AssertPass("Call to SDL_SetWindowKeyboardGrab(window=NULL,SDL_TRUE)");
+  _checkInvalidWindowError();
 
   /* Restore state */
-  _setAndCheckWindowGrabState(window, originalState);
+  _setAndCheckWindowMouseGrabState(window, originalMouseState);
+  _setAndCheckWindowKeyboardGrabState(window, originalKeyboardState);
 
   /* Clean up */
   _destroyVideoSuiteTestWindow(window);
@@ -836,8 +964,8 @@ video_getSetWindowGrab(void *arg)
 /**
  * @brief Tests call to SDL_GetWindowID and SDL_GetWindowFromID
  *
- * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowID
- * @sa http://wiki.libsdl.org/moin.fcg/SDL_SetWindowFromID
+ * @sa http://wiki.libsdl.org/SDL_GetWindowID
+ * @sa http://wiki.libsdl.org/SDL_SetWindowFromID
  */
 int
 video_getWindowId(void *arg)
@@ -892,7 +1020,7 @@ video_getWindowId(void *arg)
 /**
  * @brief Tests call to SDL_GetWindowPixelFormat
  *
- * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowPixelFormat
+ * @sa http://wiki.libsdl.org/SDL_GetWindowPixelFormat
  */
 int
 video_getWindowPixelFormat(void *arg)
@@ -926,8 +1054,8 @@ video_getWindowPixelFormat(void *arg)
 /**
  * @brief Tests call to SDL_GetWindowPosition and SDL_SetWindowPosition
  *
- * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowPosition
- * @sa http://wiki.libsdl.org/moin.fcg/SDL_SetWindowPosition
+ * @sa http://wiki.libsdl.org/SDL_GetWindowPosition
+ * @sa http://wiki.libsdl.org/SDL_SetWindowPosition
  */
 int
 video_getSetWindowPosition(void *arg)
@@ -1069,8 +1197,8 @@ void _checkInvalidParameterError()
 /**
  * @brief Tests call to SDL_GetWindowSize and SDL_SetWindowSize
  *
- * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowSize
- * @sa http://wiki.libsdl.org/moin.fcg/SDL_SetWindowSize
+ * @sa http://wiki.libsdl.org/SDL_GetWindowSize
+ * @sa http://wiki.libsdl.org/SDL_SetWindowSize
  */
 int
 video_getSetWindowSize(void *arg)
@@ -1508,8 +1636,8 @@ video_getSetWindowMaximumSize(void *arg)
 /**
  * @brief Tests call to SDL_SetWindowData and SDL_GetWindowData
  *
- * @sa http://wiki.libsdl.org/moin.fcg/SDL_SetWindowData
- * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowData
+ * @sa http://wiki.libsdl.org/SDL_SetWindowData
+ * @sa http://wiki.libsdl.org/SDL_GetWindowData
  */
 int
 video_getSetWindowData(void *arg)
diff --git a/Engine/lib/sdl/test/testbounds.c b/Engine/lib/sdl/test/testbounds.c
index e9017e5e6..23f981777 100644
--- a/Engine/lib/sdl/test/testbounds.c
+++ b/Engine/lib/sdl/test/testbounds.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/testcustomcursor.c b/Engine/lib/sdl/test/testcustomcursor.c
index 3881435ad..2feee81a2 100644
--- a/Engine/lib/sdl/test/testcustomcursor.c
+++ b/Engine/lib/sdl/test/testcustomcursor.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -128,7 +128,7 @@ init_system_cursor(const char *image[])
       }
     }
   }
-  sscanf(image[4+row], "%d,%d", &hot_x, &hot_y);
+  SDL_sscanf(image[4+row], "%d,%d", &hot_x, &hot_y);
   return SDL_CreateCursor(data, mask, 32, 32, hot_x, hot_y);
 }
 
diff --git a/Engine/lib/sdl/test/testdisplayinfo.c b/Engine/lib/sdl/test/testdisplayinfo.c
index 2a8cce1e0..297632c04 100644
--- a/Engine/lib/sdl/test/testdisplayinfo.c
+++ b/Engine/lib/sdl/test/testdisplayinfo.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/testdraw2.c b/Engine/lib/sdl/test/testdraw2.c
index 865b55fbf..0df5ba3ed 100644
--- a/Engine/lib/sdl/test/testdraw2.c
+++ b/Engine/lib/sdl/test/testdraw2.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -32,6 +32,8 @@ static int cycle_direction = 1;
 static int current_alpha = 255;
 static int current_color = 255;
 static SDL_BlendMode blendMode = SDL_BLENDMODE_NONE;
+static Uint32 next_fps_check, frames;
+static const Uint32 fps_check_delay = 5000;
 
 int done;
 
@@ -178,6 +180,7 @@ DrawRects(SDL_Renderer * renderer)
 void
 loop()
 {
+    Uint32 now;
     int i;
     SDL_Event event;
 
@@ -203,13 +206,23 @@ loop()
         emscripten_cancel_main_loop();
     }
 #endif
+    frames++;
+    now = SDL_GetTicks();
+    if (SDL_TICKS_PASSED(now, next_fps_check)) {
+        /* Print out some timing information */
+        const Uint32 then = next_fps_check - fps_check_delay;
+        const double fps = ((double) frames * 1000) / (now - then);
+        SDL_Log("%2.2f frames per second\n", fps);
+        next_fps_check = now + fps_check_delay;
+        frames = 0;
+    }
+
 }
 
 int
 main(int argc, char *argv[])
 {
     int i;
-    Uint32 then, now, frames;
 
     /* Enable standard application logging */
     SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
@@ -256,7 +269,12 @@ main(int argc, char *argv[])
             }
         }
         if (consumed < 0) {
-            static const char *options[] = { "[--blend none|blend|add|mod]", "[--cyclecolor]", "[--cyclealpha]", NULL };
+            static const char *options[] = { 
+                "[--blend none|blend|add|mod]", 
+                "[--cyclecolor]",
+                "[--cyclealpha]",
+                "[num_objects]",
+                NULL };
             SDLTest_CommonLogUsage(state, argv[0], options);
             return 1;
         }
@@ -278,27 +296,20 @@ main(int argc, char *argv[])
 
     /* Main render loop */
     frames = 0;
-    then = SDL_GetTicks();
+    next_fps_check = SDL_GetTicks() + fps_check_delay;
     done = 0;
 
 #ifdef __EMSCRIPTEN__
     emscripten_set_main_loop(loop, 0, 1);
 #else
     while (!done) {
-        ++frames;
         loop();
-        }
+    }
 #endif
 
 
     SDLTest_CommonQuit(state);
 
-    /* Print out some timing information */
-    now = SDL_GetTicks();
-    if (now > then) {
-        double fps = ((double) frames * 1000) / (now - then);
-        SDL_Log("%2.2f frames per second\n", fps);
-    }
     return 0;
 }
 
diff --git a/Engine/lib/sdl/test/testdrawchessboard.c b/Engine/lib/sdl/test/testdrawchessboard.c
index 8943e70cc..f3636f389 100644
--- a/Engine/lib/sdl/test/testdrawchessboard.c
+++ b/Engine/lib/sdl/test/testdrawchessboard.c
@@ -1,5 +1,5 @@
 /*
-   Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+   Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
    This software is provided 'as-is', without any express or implied
    warranty.  In no event will the authors be held liable for any damages
@@ -29,7 +29,7 @@ SDL_Surface *surface;
 int done;
 
 void
-DrawChessBoard(SDL_Renderer * renderer)
+DrawChessBoard()
 {
     int row = 0,column = 0,x = 0;
     SDL_Rect rect, darea;
@@ -90,7 +90,7 @@ loop()
         }
     }
 
-    DrawChessBoard(renderer);
+    DrawChessBoard();
 
     /* Got everything on rendering surface,
        now Update the drawing image on window screen */
diff --git a/Engine/lib/sdl/test/testdropfile.c b/Engine/lib/sdl/test/testdropfile.c
index 930b80f03..95212472a 100644
--- a/Engine/lib/sdl/test/testdropfile.c
+++ b/Engine/lib/sdl/test/testdropfile.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/testerror.c b/Engine/lib/sdl/test/testerror.c
index e638dd13f..e847c2824 100644
--- a/Engine/lib/sdl/test/testerror.c
+++ b/Engine/lib/sdl/test/testerror.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/testevdev.c b/Engine/lib/sdl/test/testevdev.c
index 9ed3eff34..572c60a05 100644
--- a/Engine/lib/sdl/test/testevdev.c
+++ b/Engine/lib/sdl/test/testevdev.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
   Copyright (C) 2020 Collabora Ltd.
 
   This software is provided 'as-is', without any express or implied
diff --git a/Engine/lib/sdl/test/testfile.c b/Engine/lib/sdl/test/testfile.c
index b22ffa199..25a309201 100644
--- a/Engine/lib/sdl/test/testfile.c
+++ b/Engine/lib/sdl/test/testfile.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/testfilesystem.c b/Engine/lib/sdl/test/testfilesystem.c
index c9a82d025..9862608d5 100644
--- a/Engine/lib/sdl/test/testfilesystem.c
+++ b/Engine/lib/sdl/test/testfilesystem.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/testgamecontroller.c b/Engine/lib/sdl/test/testgamecontroller.c
index 6522885cf..17fb60bd3 100644
--- a/Engine/lib/sdl/test/testgamecontroller.c
+++ b/Engine/lib/sdl/test/testgamecontroller.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -61,15 +61,16 @@ static const struct { int x; int y; double angle; } axis_positions[] = {
     {375, -20,   0.0},  /* TRIGGERRIGHT */
 };
 
-SDL_Window *window = NULL;
-SDL_Renderer *screen = NULL;
-SDL_bool retval = SDL_FALSE;
-SDL_bool done = SDL_FALSE;
-SDL_bool set_LED = SDL_FALSE;
-SDL_Texture *background_front, *background_back, *button, *axis;
-SDL_GameController *gamecontroller;
-SDL_GameController **gamecontrollers;
-int num_controllers = 0;
+static SDL_Window *window = NULL;
+static SDL_Renderer *screen = NULL;
+static SDL_bool retval = SDL_FALSE;
+static SDL_bool done = SDL_FALSE;
+static SDL_bool set_LED = SDL_FALSE;
+static int trigger_effect = 0;
+static SDL_Texture *background_front, *background_back, *button, *axis;
+static SDL_GameController *gamecontroller;
+static SDL_GameController **gamecontrollers;
+static int num_controllers = 0;
 
 static void UpdateWindowTitle()
 {
@@ -146,6 +147,7 @@ static void AddController(int device_index, SDL_bool verbose)
     controllers[num_controllers++] = controller;
     gamecontrollers = controllers;
     gamecontroller = controller;
+    trigger_effect = 0;
 
     if (verbose) {
         const char *name = SDL_GameControllerName(gamecontroller);
@@ -154,18 +156,26 @@ static void AddController(int device_index, SDL_bool verbose)
 
     if (SDL_GameControllerHasSensor(gamecontroller, SDL_SENSOR_ACCEL)) {
         if (verbose) {
-            SDL_Log("Enabling accelerometer\n");
+            SDL_Log("Enabling accelerometer at %.2f Hz\n", SDL_GameControllerGetSensorDataRate(gamecontroller, SDL_SENSOR_ACCEL));
         }
         SDL_GameControllerSetSensorEnabled(gamecontroller, SDL_SENSOR_ACCEL, SDL_TRUE);
     }
 
     if (SDL_GameControllerHasSensor(gamecontroller, SDL_SENSOR_GYRO)) {
         if (verbose) {
-            SDL_Log("Enabling gyro\n");
+            SDL_Log("Enabling gyro at %.2f Hz\n", SDL_GameControllerGetSensorDataRate(gamecontroller, SDL_SENSOR_GYRO));
         }
         SDL_GameControllerSetSensorEnabled(gamecontroller, SDL_SENSOR_GYRO, SDL_TRUE);
     }
 
+    if (SDL_GameControllerHasRumble(gamecontroller)) {
+        SDL_Log("Rumble supported");
+    }
+
+    if (SDL_GameControllerHasRumbleTriggers(gamecontroller)) {
+        SDL_Log("Trigger rumble supported");
+    }
+
     UpdateWindowTitle();
 }
 
@@ -234,17 +244,68 @@ LoadTexture(SDL_Renderer *renderer, const char *file, SDL_bool transparent)
     return texture;
 }
 
-static Uint16 ConvertAxisToRumble(Sint16 axis)
+static Uint16 ConvertAxisToRumble(Sint16 axisval)
 {
     /* Only start rumbling if the axis is past the halfway point */
     const Sint16 half_axis = (Sint16)SDL_ceil(SDL_JOYSTICK_AXIS_MAX / 2.0f);
-    if (axis > half_axis) {
-        return (Uint16)(axis - half_axis) * 4;
+    if (axisval > half_axis) {
+        return (Uint16)(axisval - half_axis) * 4;
     } else {
         return 0;
     }
 }
 
+/* PS5 trigger effect documentation:
+   https://controllers.fandom.com/wiki/Sony_DualSense#FFB_Trigger_Modes
+*/
+typedef struct
+{
+    Uint8 ucEnableBits1;                /* 0 */
+    Uint8 ucEnableBits2;                /* 1 */
+    Uint8 ucRumbleRight;                /* 2 */
+    Uint8 ucRumbleLeft;                 /* 3 */
+    Uint8 ucHeadphoneVolume;            /* 4 */
+    Uint8 ucSpeakerVolume;              /* 5 */
+    Uint8 ucMicrophoneVolume;           /* 6 */
+    Uint8 ucAudioEnableBits;            /* 7 */
+    Uint8 ucMicLightMode;               /* 8 */
+    Uint8 ucAudioMuteBits;              /* 9 */
+    Uint8 rgucRightTriggerEffect[11];   /* 10 */
+    Uint8 rgucLeftTriggerEffect[11];    /* 21 */
+    Uint8 rgucUnknown1[6];              /* 32 */
+    Uint8 ucLedFlags;                   /* 38 */
+    Uint8 rgucUnknown2[2];              /* 39 */
+    Uint8 ucLedAnim;                    /* 41 */
+    Uint8 ucLedBrightness;              /* 42 */
+    Uint8 ucPadLights;                  /* 43 */
+    Uint8 ucLedRed;                     /* 44 */
+    Uint8 ucLedGreen;                   /* 45 */
+    Uint8 ucLedBlue;                    /* 46 */
+} DS5EffectsState_t;
+
+static void CyclePS5TriggerEffect()
+{
+    DS5EffectsState_t state;
+
+    Uint8 effects[3][11] =
+    {
+        /* Clear trigger effect */
+        { 0x05, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+        /* Constant resistance across entire trigger pull */
+        { 0x01, 0, 110, 0, 0, 0, 0, 0, 0, 0, 0 },
+        /* Resistance and vibration when trigger is pulled */
+        { 0x06, 15, 63, 128, 0, 0, 0, 0, 0, 0, 0 },
+    };
+
+    trigger_effect = (trigger_effect + 1) % SDL_arraysize(effects);
+
+    SDL_zero(state);
+    state.ucEnableBits1 |= (0x04 | 0x08); /* Modify right and left trigger effect respectively */
+    SDL_memcpy(state.rgucRightTriggerEffect, effects[trigger_effect], sizeof(effects[trigger_effect]));
+    SDL_memcpy(state.rgucLeftTriggerEffect, effects[trigger_effect], sizeof(effects[trigger_effect]));
+    SDL_GameControllerSendEffect(gamecontroller, &state, sizeof(state));
+}
+
 void
 loop(void *arg)
 {
@@ -252,7 +313,11 @@ loop(void *arg)
     int i;
     SDL_bool showing_front = SDL_TRUE;
 
-    while (SDL_PollEvent(&event)) {
+    /* Update to get the current event state */
+    SDL_PumpEvents();
+
+    /* Process all currently pending events */
+    while (SDL_PeepEvents(&event, 1, SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT) == 1) {
         switch (event.type) {
         case SDL_CONTROLLERDEVICEADDED:
             SDL_Log("Game controller device %d added.\n", (int) SDL_JoystickGetDeviceInstanceID(event.cdevice.which));
@@ -267,7 +332,8 @@ loop(void *arg)
         case SDL_CONTROLLERTOUCHPADDOWN:
         case SDL_CONTROLLERTOUCHPADMOTION:
         case SDL_CONTROLLERTOUCHPADUP:
-            SDL_Log("Controller touchpad %d finger %d %s %.2f, %.2f, %.2f\n",
+            SDL_Log("Controller %d touchpad %d finger %d %s %.2f, %.2f, %.2f\n",
+                event.ctouchpad.which,
                 event.ctouchpad.touchpad,
                 event.ctouchpad.finger,
                 (event.type == SDL_CONTROLLERTOUCHPADDOWN ? "pressed at" :
@@ -278,35 +344,57 @@ loop(void *arg)
                 event.ctouchpad.pressure);
             break;
 
+#define VERBOSE_SENSORS
+#ifdef VERBOSE_SENSORS
         case SDL_CONTROLLERSENSORUPDATE:
-            SDL_Log("Controller sensor %s: %.2f, %.2f, %.2f\n",
+            SDL_Log("Controller %d sensor %s: %.2f, %.2f, %.2f\n",
+                event.csensor.which,
                 event.csensor.sensor == SDL_SENSOR_ACCEL ? "accelerometer" :
                 event.csensor.sensor == SDL_SENSOR_GYRO ? "gyro" : "unknown",
                 event.csensor.data[0],
                 event.csensor.data[1],
                 event.csensor.data[2]);
             break;
+#endif /* VERBOSE_SENSORS */
 
+#define VERBOSE_AXES
+#ifdef VERBOSE_AXES
         case SDL_CONTROLLERAXISMOTION:
             if (event.caxis.value <= (-SDL_JOYSTICK_AXIS_MAX / 2) || event.caxis.value >= (SDL_JOYSTICK_AXIS_MAX / 2)) {
                 SetController(event.caxis.which);
             }
-            SDL_Log("Controller axis %s changed to %d\n", SDL_GameControllerGetStringForAxis((SDL_GameControllerAxis)event.caxis.axis), event.caxis.value);
+            SDL_Log("Controller %d axis %s changed to %d\n", event.caxis.which, SDL_GameControllerGetStringForAxis((SDL_GameControllerAxis)event.caxis.axis), event.caxis.value);
             break;
+#endif /* VERBOSE_AXES */
 
         case SDL_CONTROLLERBUTTONDOWN:
         case SDL_CONTROLLERBUTTONUP:
             if (event.type == SDL_CONTROLLERBUTTONDOWN) {
                 SetController(event.cbutton.which);
             }
-            SDL_Log("Controller button %s %s\n", SDL_GameControllerGetStringForButton((SDL_GameControllerButton)event.cbutton.button), event.cbutton.state ? "pressed" : "released");
+            SDL_Log("Controller %d button %s %s\n", event.cbutton.which, SDL_GameControllerGetStringForButton((SDL_GameControllerButton)event.cbutton.button), event.cbutton.state ? "pressed" : "released");
+
+            /* Cycle PS5 trigger effects when the microphone button is pressed */
+            if (event.type == SDL_CONTROLLERBUTTONDOWN &&
+                event.cbutton.button == SDL_CONTROLLER_BUTTON_MISC1 &&
+                SDL_GameControllerGetType(gamecontroller) == SDL_CONTROLLER_TYPE_PS5) {
+                CyclePS5TriggerEffect();
+            }
             break;
 
         case SDL_KEYDOWN:
+            if (event.key.keysym.sym >= SDLK_0 && event.key.keysym.sym <= SDLK_9) {
+                if (gamecontroller) {
+                    int player_index = (event.key.keysym.sym - SDLK_0);
+
+                    SDL_GameControllerSetPlayerIndex(gamecontroller, player_index);
+                }
+                break;
+            }
             if (event.key.keysym.sym != SDLK_ESCAPE) {
                 break;
             }
-            /* Fall through to signal quit */
+            SDL_FALLTHROUGH;
         case SDL_QUIT:
             done = SDL_TRUE;
             break;
@@ -336,7 +424,11 @@ loop(void *arg)
             if (SDL_GameControllerGetButton(gamecontroller, (SDL_GameControllerButton)i) == SDL_PRESSED) {
                 SDL_bool on_front = (i < SDL_CONTROLLER_BUTTON_PADDLE1 || i > SDL_CONTROLLER_BUTTON_PADDLE4);
                 if (on_front == showing_front) {
-                    const SDL_Rect dst = { button_positions[i].x, button_positions[i].y, 50, 50 };
+                    SDL_Rect dst;
+                    dst.x = button_positions[i].x;
+                    dst.y = button_positions[i].y;
+                    dst.w = 50;
+                    dst.h = 50;
                     SDL_RenderCopyEx(screen, button, NULL, &dst, 0, NULL, SDL_FLIP_NONE);
                 }
             }
@@ -347,12 +439,20 @@ loop(void *arg)
                 const Sint16 deadzone = 8000;  /* !!! FIXME: real deadzone */
                 const Sint16 value = SDL_GameControllerGetAxis(gamecontroller, (SDL_GameControllerAxis)(i));
                 if (value < -deadzone) {
-                    const SDL_Rect dst = { axis_positions[i].x, axis_positions[i].y, 50, 50 };
                     const double angle = axis_positions[i].angle;
+                    SDL_Rect dst;
+                    dst.x = axis_positions[i].x;
+                    dst.y = axis_positions[i].y;
+                    dst.w = 50;
+                    dst.h = 50;
                     SDL_RenderCopyEx(screen, axis, NULL, &dst, angle, NULL, SDL_FLIP_NONE);
                 } else if (value > deadzone) {
-                    const SDL_Rect dst = { axis_positions[i].x, axis_positions[i].y, 50, 50 };
                     const double angle = axis_positions[i].angle + 180.0;
+                    SDL_Rect dst;
+                    dst.x = axis_positions[i].x;
+                    dst.y = axis_positions[i].y;
+                    dst.w = 50;
+                    dst.h = 50;
                     SDL_RenderCopyEx(screen, axis, NULL, &dst, angle, NULL, SDL_FLIP_NONE);
                 }
             }
@@ -386,23 +486,25 @@ loop(void *arg)
             }
         }
 
-        /* Update rumble based on trigger state */
-        {
-            Sint16 left = SDL_GameControllerGetAxis(gamecontroller, SDL_CONTROLLER_AXIS_TRIGGERLEFT);
-            Sint16 right = SDL_GameControllerGetAxis(gamecontroller, SDL_CONTROLLER_AXIS_TRIGGERRIGHT);
-            Uint16 low_frequency_rumble = ConvertAxisToRumble(left);
-            Uint16 high_frequency_rumble = ConvertAxisToRumble(right);
-            SDL_GameControllerRumble(gamecontroller, low_frequency_rumble, high_frequency_rumble, 250);
-        }
+        if (trigger_effect == 0) {
+            /* Update rumble based on trigger state */
+            {
+                Sint16 left = SDL_GameControllerGetAxis(gamecontroller, SDL_CONTROLLER_AXIS_TRIGGERLEFT);
+                Sint16 right = SDL_GameControllerGetAxis(gamecontroller, SDL_CONTROLLER_AXIS_TRIGGERRIGHT);
+                Uint16 low_frequency_rumble = ConvertAxisToRumble(left);
+                Uint16 high_frequency_rumble = ConvertAxisToRumble(right);
+                SDL_GameControllerRumble(gamecontroller, low_frequency_rumble, high_frequency_rumble, 250);
+            }
 
-        /* Update trigger rumble based on thumbstick state */
-        {
-            Sint16 left = SDL_GameControllerGetAxis(gamecontroller, SDL_CONTROLLER_AXIS_LEFTY);
-            Sint16 right = SDL_GameControllerGetAxis(gamecontroller, SDL_CONTROLLER_AXIS_RIGHTY);
-            Uint16 left_rumble = ConvertAxisToRumble(~left);
-            Uint16 right_rumble = ConvertAxisToRumble(~right);
+            /* Update trigger rumble based on thumbstick state */
+            {
+                Sint16 left = SDL_GameControllerGetAxis(gamecontroller, SDL_CONTROLLER_AXIS_LEFTY);
+                Sint16 right = SDL_GameControllerGetAxis(gamecontroller, SDL_CONTROLLER_AXIS_RIGHTY);
+                Uint16 left_rumble = ConvertAxisToRumble(~left);
+                Uint16 right_rumble = ConvertAxisToRumble(~right);
 
-            SDL_GameControllerRumbleTriggers(gamecontroller, left_rumble, right_rumble, 250);
+                SDL_GameControllerRumbleTriggers(gamecontroller, left_rumble, right_rumble, 250);
+            }
         }
     }
 
@@ -424,8 +526,12 @@ main(int argc, char *argv[])
     char guid[64];
 
     SDL_SetHint(SDL_HINT_ACCELEROMETER_AS_JOYSTICK, "0");
+    SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_JOY_CONS, "1");
     SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_PS4_RUMBLE, "1");
+    SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_PS5_RUMBLE, "1");
+    SDL_SetHint(SDL_HINT_JOYSTICK_ROG_CHAKRAM, "1");
     SDL_SetHint(SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS, "1");
+    SDL_SetHint(SDL_HINT_LINUX_JOYSTICK_DEADZONES, "1");
 
     /* Enable standard application logging */
     SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
@@ -435,7 +541,7 @@ main(int argc, char *argv[])
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't initialize SDL: %s\n", SDL_GetError());
         return 1;
     }
-    
+
     SDL_GameControllerAddMappingsFromFile("gamecontrollerdb.txt");
 
     /* Print information about the mappings */
@@ -463,11 +569,14 @@ main(int argc, char *argv[])
             controller_count++;
             name = SDL_GameControllerNameForIndex(i);
             switch (SDL_GameControllerTypeForIndex(i)) {
-            case SDL_CONTROLLER_TYPE_XBOX360:
-                description = "XBox 360 Controller";
+            case SDL_CONTROLLER_TYPE_AMAZON_LUNA:
+                description = "Amazon Luna Controller";
                 break;
-            case SDL_CONTROLLER_TYPE_XBOXONE:
-                description = "XBox One Controller";
+            case SDL_CONTROLLER_TYPE_GOOGLE_STADIA:
+                description = "Google Stadia Controller";
+                break;
+            case SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_PRO:
+                description = "Nintendo Switch Pro Controller";
                 break;
             case SDL_CONTROLLER_TYPE_PS3:
                 description = "PS3 Controller";
@@ -475,8 +584,14 @@ main(int argc, char *argv[])
             case SDL_CONTROLLER_TYPE_PS4:
                 description = "PS4 Controller";
                 break;
-            case SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_PRO:
-                description = "Nintendo Switch Pro Controller";
+            case SDL_CONTROLLER_TYPE_PS5:
+                description = "PS5 Controller";
+                break;
+            case SDL_CONTROLLER_TYPE_XBOX360:
+                description = "XBox 360 Controller";
+                break;
+            case SDL_CONTROLLER_TYPE_XBOXONE:
+                description = "XBox One Controller";
                 break;
             case SDL_CONTROLLER_TYPE_VIRTUAL:
                 description = "Virtual Game Controller";
@@ -554,6 +669,12 @@ main(int argc, char *argv[])
     }
 #endif
 
+    /* Reset trigger state */
+    if (trigger_effect != 0) {
+        trigger_effect = -1;
+        CyclePS5TriggerEffect();
+    }
+
     SDL_DestroyRenderer(screen);
     SDL_DestroyWindow(window);
     SDL_QuitSubSystem(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER);
diff --git a/Engine/lib/sdl/test/testgeometry.c b/Engine/lib/sdl/test/testgeometry.c
new file mode 100644
index 000000000..3a87e3d2e
--- /dev/null
+++ b/Engine/lib/sdl/test/testgeometry.c
@@ -0,0 +1,303 @@
+/*
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely.
+*/
+
+/* Simple program:  draw a RGB triangle, with texture  */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+
+#ifdef __EMSCRIPTEN__
+#include <emscripten/emscripten.h>
+#endif
+
+#include "SDL_test_common.h"
+
+static SDLTest_CommonState *state;
+static SDL_bool use_texture = SDL_FALSE;
+static SDL_Texture **sprites;
+static SDL_BlendMode blendMode = SDL_BLENDMODE_NONE;
+static double angle = 0.0;
+static int sprite_w, sprite_h;
+
+int done;
+
+/* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */
+static void
+quit(int rc)
+{
+    SDL_free(sprites);
+    SDLTest_CommonQuit(state);
+    exit(rc);
+}
+
+int
+LoadSprite(const char *file)
+{
+    int i;
+    SDL_Surface *temp;
+
+    /* Load the sprite image */
+    temp = SDL_LoadBMP(file);
+    if (temp == NULL) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't load %s: %s", file, SDL_GetError());
+        return (-1);
+    }
+    sprite_w = temp->w;
+    sprite_h = temp->h;
+
+    /* Set transparent pixel as the pixel at (0,0) */
+    if (temp->format->palette) {
+        SDL_SetColorKey(temp, 1, *(Uint8 *) temp->pixels);
+    } else {
+        switch (temp->format->BitsPerPixel) {
+        case 15:
+            SDL_SetColorKey(temp, 1, (*(Uint16 *) temp->pixels) & 0x00007FFF);
+            break;
+        case 16:
+            SDL_SetColorKey(temp, 1, *(Uint16 *) temp->pixels);
+            break;
+        case 24:
+            SDL_SetColorKey(temp, 1, (*(Uint32 *) temp->pixels) & 0x00FFFFFF);
+            break;
+        case 32:
+            SDL_SetColorKey(temp, 1, *(Uint32 *) temp->pixels);
+            break;
+        }
+    }
+
+    /* Create textures from the image */
+    for (i = 0; i < state->num_windows; ++i) {
+        SDL_Renderer *renderer = state->renderers[i];
+        sprites[i] = SDL_CreateTextureFromSurface(renderer, temp);
+        if (!sprites[i]) {
+            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create texture: %s\n", SDL_GetError());
+            SDL_FreeSurface(temp);
+            return (-1);
+        }
+        if (SDL_SetTextureBlendMode(sprites[i], blendMode) < 0) {
+            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't set blend mode: %s\n", SDL_GetError());
+            SDL_FreeSurface(temp);
+            SDL_DestroyTexture(sprites[i]);
+            return (-1);
+        }
+    }
+    SDL_FreeSurface(temp);
+
+    /* We're ready to roll. :) */
+    return (0);
+}
+
+
+void
+loop()
+{
+    int i;
+    SDL_Event event;
+
+    /* Check for events */
+    while (SDL_PollEvent(&event)) {
+
+        if (event.type == SDL_MOUSEMOTION) {
+            if (event.motion.state) {
+                int xrel, yrel;
+                int window_w, window_h;
+                SDL_Window *window = SDL_GetWindowFromID(event.motion.windowID);
+                SDL_GetWindowSize(window, &window_w, &window_h);
+                xrel = event.motion.xrel;
+                yrel = event.motion.yrel;
+                if (event.motion.y < window_h / 2) {
+                    angle += xrel;
+                } else {
+                    angle -= xrel;
+                }
+                if (event.motion.x < window_w / 2) {
+                    angle -= yrel;
+                } else {
+                    angle += yrel;
+                }
+            }
+        } else {
+            SDLTest_CommonEvent(state, &event, &done);
+        }
+    }
+
+    for (i = 0; i < state->num_windows; ++i) {
+        SDL_Renderer *renderer = state->renderers[i];
+        if (state->windows[i] == NULL)
+            continue;
+        SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);
+        SDL_RenderClear(renderer);
+
+        {
+            SDL_Rect viewport;
+            SDL_Vertex verts[3];
+            double a;
+            double d;
+            int cx, cy;
+
+            /* Query the sizes */
+            SDL_RenderGetViewport(renderer, &viewport);
+            SDL_zeroa(verts);
+            cx = viewport.x + viewport.w / 2;
+            cy = viewport.y + viewport.h / 2;
+            d = (viewport.w + viewport.h) / 5;
+
+            a = (angle * 3.1415) / 180.0; 
+            verts[0].position.x = cx + d * SDL_cos(a);
+            verts[0].position.y = cy + d * SDL_sin(a);
+            verts[0].color.r = 0xFF;
+            verts[0].color.g = 0;
+            verts[0].color.b = 0;
+            verts[0].color.a = 0xFF;
+
+            a = ((angle + 120) * 3.1415) / 180.0; 
+            verts[1].position.x = cx + d * SDL_cos(a);
+            verts[1].position.y = cy + d * SDL_sin(a);
+            verts[1].color.r = 0;
+            verts[1].color.g = 0xFF;
+            verts[1].color.b = 0;
+            verts[1].color.a = 0xFF;
+
+            a = ((angle + 240) * 3.1415) / 180.0; 
+            verts[2].position.x = cx + d * SDL_cos(a);
+            verts[2].position.y = cy + d * SDL_sin(a);
+            verts[2].color.r = 0;
+            verts[2].color.g = 0;
+            verts[2].color.b = 0xFF;
+            verts[2].color.a = 0xFF;
+
+            if (use_texture) {
+                verts[0].tex_coord.x = 0.5;
+                verts[0].tex_coord.y = 0.0;
+                verts[1].tex_coord.x = 1.0;
+                verts[1].tex_coord.y = 1.0;
+                verts[2].tex_coord.x = 0.0;
+                verts[2].tex_coord.y = 1.0;
+            }
+
+            SDL_RenderGeometry(renderer, sprites[i], verts, 3, NULL, 0);
+        }
+
+        SDL_RenderPresent(renderer);
+    }
+#ifdef __EMSCRIPTEN__
+    if (done) {
+        emscripten_cancel_main_loop();
+    }
+#endif
+}
+
+int
+main(int argc, char *argv[])
+{
+    int i;
+    const char *icon = "icon.bmp";
+    Uint32 then, now, frames;
+
+    /* Enable standard application logging */
+    SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
+
+    /* Initialize test framework */
+    state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO);
+    if (!state) {
+        return 1;
+    }
+    for (i = 1; i < argc;) {
+        int consumed;
+
+        consumed = SDLTest_CommonArg(state, i);
+        if (consumed == 0) {
+            consumed = -1;
+            if (SDL_strcasecmp(argv[i], "--blend") == 0) {
+                if (argv[i + 1]) {
+                    if (SDL_strcasecmp(argv[i + 1], "none") == 0) {
+                        blendMode = SDL_BLENDMODE_NONE;
+                        consumed = 2;
+                    } else if (SDL_strcasecmp(argv[i + 1], "blend") == 0) {
+                        blendMode = SDL_BLENDMODE_BLEND;
+                        consumed = 2;
+                    } else if (SDL_strcasecmp(argv[i + 1], "add") == 0) {
+                        blendMode = SDL_BLENDMODE_ADD;
+                        consumed = 2;
+                    } else if (SDL_strcasecmp(argv[i + 1], "mod") == 0) {
+                        blendMode = SDL_BLENDMODE_MOD;
+                        consumed = 2;
+                    }
+                }
+            } else if (SDL_strcasecmp(argv[i], "--use-texture") == 0) {
+                use_texture = SDL_TRUE;
+                consumed = 1;
+            }
+        }
+        if (consumed < 0) {
+            static const char *options[] = { "[--blend none|blend|add|mod]", "[--use-texture]", NULL };
+            SDLTest_CommonLogUsage(state, argv[0], options);
+            return 1;
+        }
+        i += consumed;
+    }
+    if (!SDLTest_CommonInit(state)) {
+        return 2;
+    }
+
+    /* Create the windows, initialize the renderers, and load the textures */
+    sprites =
+        (SDL_Texture **) SDL_malloc(state->num_windows * sizeof(*sprites));
+    if (!sprites) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Out of memory!\n");
+        quit(2);
+    }
+    /* Create the windows and initialize the renderers */
+    for (i = 0; i < state->num_windows; ++i) {
+        SDL_Renderer *renderer = state->renderers[i];
+        SDL_SetRenderDrawBlendMode(renderer, blendMode);
+        SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);
+        SDL_RenderClear(renderer);
+        sprites[i] = NULL;
+    }
+    if (use_texture) {
+        if (LoadSprite(icon) < 0) {
+            quit(2);
+        }
+    }
+
+
+    srand((unsigned int)time(NULL));
+
+    /* Main render loop */
+    frames = 0;
+    then = SDL_GetTicks();
+    done = 0;
+
+#ifdef __EMSCRIPTEN__
+    emscripten_set_main_loop(loop, 0, 1);
+#else
+    while (!done) {
+        ++frames;
+        loop();
+        }
+#endif
+
+    /* Print out some timing information */
+    now = SDL_GetTicks();
+    if (now > then) {
+        double fps = ((double) frames * 1000) / (now - then);
+        SDL_Log("%2.2f frames per second\n", fps);
+    }
+    
+    quit(0);
+
+    return 0;
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/test/testgesture.c b/Engine/lib/sdl/test/testgesture.c
index a925e0ac2..856fd6a2d 100644
--- a/Engine/lib/sdl/test/testgesture.c
+++ b/Engine/lib/sdl/test/testgesture.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -90,6 +90,7 @@ setpix(SDL_Surface *screen, float _x, float _y, unsigned int col)
     *pixmem32 = colour;
 }
 
+#if 0 /* unused */
 static void
 drawLine(SDL_Surface *screen, float x0, float y0, float x1, float y1, unsigned int col)
 {
@@ -98,6 +99,7 @@ drawLine(SDL_Surface *screen, float x0, float y0, float x1, float y1, unsigned i
         setpix(screen, x1 + t * (x0 - x1), y1 + t * (y0 - y1), col);
     }
 }
+#endif
 
 static void
 drawCircle(SDL_Surface *screen, float x, float y, float r, unsigned int c)
@@ -188,7 +190,8 @@ loop(void)
                     case SDLK_i: {
                         for (i = 0; i < SDL_GetNumTouchDevices(); ++i) {
                             const SDL_TouchID id = SDL_GetTouchDevice(i);
-                            SDL_Log("Fingers Down on device %"SDL_PRIs64": %d", id, SDL_GetNumTouchFingers(id));
+                            const char *name = SDL_GetTouchName(i);
+                            SDL_Log("Fingers Down on device %"SDL_PRIs64" (%s): %d", id, name, SDL_GetNumTouchFingers(id));
                         }
                         break;
                     }
@@ -213,7 +216,7 @@ loop(void)
 
 #if VERBOSE
             case SDL_FINGERMOTION:
-                SDL_Log("Finger: %"SDL_PRIs64",x: %f, y: %f",event.tfinger.fingerId,
+                SDL_Log("Finger: %"SDL_PRIs64", x: %f, y: %f",event.tfinger.fingerId,
                         event.tfinger.x,event.tfinger.y);
                 break;
 
diff --git a/Engine/lib/sdl/test/testgl2.c b/Engine/lib/sdl/test/testgl2.c
index 894ff80c2..6eb439cb1 100644
--- a/Engine/lib/sdl/test/testgl2.c
+++ b/Engine/lib/sdl/test/testgl2.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -238,10 +238,10 @@ main(int argc, char *argv[])
         consumed = SDLTest_CommonArg(state, i);
         if (consumed == 0) {
             if (SDL_strcasecmp(argv[i], "--fsaa") == 0 && i+1 < argc) {
-                fsaa = atoi(argv[i+1]);
+                fsaa = SDL_atoi(argv[i+1]);
                 consumed = 2;
             } else if (SDL_strcasecmp(argv[i], "--accel") == 0 && i+1 < argc) {
-                accel = atoi(argv[i+1]);
+                accel = SDL_atoi(argv[i+1]);
                 consumed = 2;
             } else {
                 consumed = -1;
diff --git a/Engine/lib/sdl/test/testgles.c b/Engine/lib/sdl/test/testgles.c
index 134b41566..cb989f44f 100644
--- a/Engine/lib/sdl/test/testgles.c
+++ b/Engine/lib/sdl/test/testgles.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/testgles2.c b/Engine/lib/sdl/test/testgles2.c
index 3946653c0..153ebe499 100644
--- a/Engine/lib/sdl/test/testgles2.c
+++ b/Engine/lib/sdl/test/testgles2.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -22,8 +22,10 @@
 
 #if defined(__IPHONEOS__) || defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__NACL__) \
     || defined(__WINDOWS__) || defined(__LINUX__)
+#ifndef HAVE_OPENGLES2
 #define HAVE_OPENGLES2
 #endif
+#endif
 
 #ifdef HAVE_OPENGLES2
 
@@ -370,6 +372,8 @@ typedef struct shader_data
 
     int angle_x, angle_y, angle_z;
 
+    GLuint position_buffer;
+    GLuint color_buffer;
 } shader_data;
 
 static void
@@ -686,8 +690,18 @@ main(int argc, char *argv[])
         GL_CHECK(ctx.glEnableVertexAttribArray(data->attr_color));
 
         /* Populate attributes for position, color and texture coordinates etc. */
-        GL_CHECK(ctx.glVertexAttribPointer(data->attr_position, 3, GL_FLOAT, GL_FALSE, 0, _vertices));
-        GL_CHECK(ctx.glVertexAttribPointer(data->attr_color, 3, GL_FLOAT, GL_FALSE, 0, _colors));
+
+        GL_CHECK(ctx.glGenBuffers(1, &data->position_buffer));
+        GL_CHECK(ctx.glBindBuffer(GL_ARRAY_BUFFER, data->position_buffer));
+        GL_CHECK(ctx.glBufferData(GL_ARRAY_BUFFER, sizeof(_vertices) * 4, _vertices, GL_STATIC_DRAW));
+        GL_CHECK(ctx.glVertexAttribPointer(data->attr_position, 3, GL_FLOAT, GL_FALSE, 0, 0));
+        GL_CHECK(ctx.glBindBuffer(GL_ARRAY_BUFFER, 0));
+
+        GL_CHECK(ctx.glGenBuffers(1, &data->color_buffer));
+        GL_CHECK(ctx.glBindBuffer(GL_ARRAY_BUFFER, data->color_buffer));
+        GL_CHECK(ctx.glBufferData(GL_ARRAY_BUFFER, sizeof(_colors) * 4, _colors, GL_STATIC_DRAW));
+        GL_CHECK(ctx.glVertexAttribPointer(data->attr_color, 3, GL_FLOAT, GL_FALSE, 0, 0));
+        GL_CHECK(ctx.glBindBuffer(GL_ARRAY_BUFFER, 0));
 
         GL_CHECK(ctx.glEnable(GL_CULL_FACE));
         GL_CHECK(ctx.glEnable(GL_DEPTH_TEST));
diff --git a/Engine/lib/sdl/test/testgles2_sdf.c b/Engine/lib/sdl/test/testgles2_sdf.c
new file mode 100644
index 000000000..a7f8016ea
--- /dev/null
+++ b/Engine/lib/sdl/test/testgles2_sdf.c
@@ -0,0 +1,805 @@
+/*
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely.
+*/
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+
+#ifdef __EMSCRIPTEN__
+#include <emscripten/emscripten.h>
+#endif
+
+#include "SDL_test_common.h"
+
+#if defined(__IPHONEOS__) || defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__NACL__) \
+    || defined(__WINDOWS__) || defined(__LINUX__)
+#define HAVE_OPENGLES2
+#endif
+
+#ifdef HAVE_OPENGLES2
+
+#include "SDL_opengles2.h"
+
+typedef struct GLES2_Context
+{
+#define SDL_PROC(ret,func,params) ret (APIENTRY *func) params;
+#include "../src/render/opengles2/SDL_gles2funcs.h"
+#undef SDL_PROC
+} GLES2_Context;
+
+
+static SDL_Surface *g_surf_sdf = NULL;
+GLenum g_texture;
+GLenum g_texture_type = GL_TEXTURE_2D;
+GLfloat g_verts[24];
+typedef enum
+{
+    GLES2_ATTRIBUTE_POSITION = 0,
+    GLES2_ATTRIBUTE_TEXCOORD = 1,
+    GLES2_ATTRIBUTE_ANGLE = 2,
+    GLES2_ATTRIBUTE_CENTER = 3,
+} GLES2_Attribute;
+
+typedef enum
+{
+    GLES2_UNIFORM_PROJECTION,
+    GLES2_UNIFORM_TEXTURE,
+    GLES2_UNIFORM_COLOR,
+} GLES2_Uniform;
+
+
+GLuint g_uniform_locations[16];
+
+
+
+static SDLTest_CommonState *state;
+static SDL_GLContext *context = NULL;
+static int depth = 16;
+static GLES2_Context ctx;
+
+static int LoadContext(GLES2_Context * data)
+{
+#if SDL_VIDEO_DRIVER_UIKIT
+#define __SDL_NOGETPROCADDR__
+#elif SDL_VIDEO_DRIVER_ANDROID
+#define __SDL_NOGETPROCADDR__
+#elif SDL_VIDEO_DRIVER_PANDORA
+#define __SDL_NOGETPROCADDR__
+#endif
+
+#if defined __SDL_NOGETPROCADDR__
+#define SDL_PROC(ret,func,params) data->func=func;
+#else
+#define SDL_PROC(ret,func,params) \
+    do { \
+        data->func = SDL_GL_GetProcAddress(#func); \
+        if ( ! data->func ) { \
+            return SDL_SetError("Couldn't load GLES2 function %s: %s", #func, SDL_GetError()); \
+        } \
+    } while ( 0 );
+#endif /* __SDL_NOGETPROCADDR__ */
+
+#include "../src/render/opengles2/SDL_gles2funcs.h"
+#undef SDL_PROC
+    return 0;
+}
+
+/* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */
+static void
+quit(int rc)
+{
+    int i;
+
+    if (context != NULL) {
+        for (i = 0; i < state->num_windows; i++) {
+            if (context[i]) {
+                SDL_GL_DeleteContext(context[i]);
+            }
+        }
+
+        SDL_free(context);
+    }
+
+    SDLTest_CommonQuit(state);
+    exit(rc);
+}
+
+#define GL_CHECK(x) \
+        x; \
+        { \
+          GLenum glError = ctx.glGetError(); \
+          if(glError != GL_NO_ERROR) { \
+            SDL_Log("glGetError() = %i (0x%.8x) at line %i\n", glError, glError, __LINE__); \
+            quit(1); \
+          } \
+        }
+
+
+/* 
+ * Create shader, load in source, compile, dump debug as necessary.
+ *
+ * shader: Pointer to return created shader ID.
+ * source: Passed-in shader source code.
+ * shader_type: Passed to GL, e.g. GL_VERTEX_SHADER.
+ */
+void 
+process_shader(GLuint *shader, const char * source, GLint shader_type)
+{
+    GLint status = GL_FALSE;
+    const char *shaders[1] = { NULL };
+    char buffer[1024];
+    GLsizei length;
+
+    /* Create shader and load into GL. */
+    *shader = GL_CHECK(ctx.glCreateShader(shader_type));
+
+    shaders[0] = source;
+
+    GL_CHECK(ctx.glShaderSource(*shader, 1, shaders, NULL));
+
+    /* Clean up shader source. */
+    shaders[0] = NULL;
+
+    /* Try compiling the shader. */
+    GL_CHECK(ctx.glCompileShader(*shader));
+    GL_CHECK(ctx.glGetShaderiv(*shader, GL_COMPILE_STATUS, &status));
+
+    /* Dump debug info (source and log) if compilation failed. */
+    if(status != GL_TRUE) {
+        ctx.glGetProgramInfoLog(*shader, sizeof(buffer), &length, &buffer[0]);
+        buffer[length] = '\0';
+        SDL_Log("Shader compilation failed: %s", buffer);fflush(stderr);
+        quit(-1);
+    }
+}
+
+/* Notes on a_angle:
+ * It is a vector containing sine and cosine for rotation matrix
+ * To get correct rotation for most cases when a_angle is disabled cosine
+ * value is decremented by 1.0 to get proper output with 0.0 which is default value
+ */
+static const Uint8 GLES2_VertexSrc_Default_[] = " \
+    uniform mat4 u_projection; \
+    attribute vec2 a_position; \
+    attribute vec2 a_texCoord; \
+    attribute vec2 a_angle; \
+    attribute vec2 a_center; \
+    varying vec2 v_texCoord; \
+    \
+    void main() \
+    { \
+        float s = a_angle[0]; \
+        float c = a_angle[1] + 1.0; \
+        mat2 rotationMatrix = mat2(c, -s, s, c); \
+        vec2 position = rotationMatrix * (a_position - a_center) + a_center; \
+        v_texCoord = a_texCoord; \
+        gl_Position = u_projection * vec4(position, 0.0, 1.0);\
+        gl_PointSize = 1.0; \
+    } \
+";
+
+static const Uint8 GLES2_FragmentSrc_TextureABGRSrc_[] = " \
+    precision mediump float; \
+    uniform sampler2D u_texture; \
+    uniform vec4 u_color; \
+    varying vec2 v_texCoord; \
+    \
+    void main() \
+    { \
+        gl_FragColor = texture2D(u_texture, v_texCoord); \
+        gl_FragColor *= u_color; \
+    } \
+";
+
+/* RGB to ABGR conversion */
+static const Uint8 GLES2_FragmentSrc_TextureABGRSrc_SDF[] = " \
+    #extension GL_OES_standard_derivatives : enable\n\
+    \
+    precision mediump float; \
+    uniform sampler2D u_texture; \
+    uniform vec4 u_color; \
+    varying vec2 v_texCoord; \
+    \
+    void main() \
+    { \
+        vec4 abgr = texture2D(u_texture, v_texCoord); \
+\
+        float sigDist = abgr.a; \
+        \
+        float w = fwidth( sigDist );\
+        float alpha = clamp(smoothstep(0.5 - w, 0.5 + w, sigDist), 0.0, 1.0); \
+\
+        gl_FragColor = vec4(abgr.rgb, abgr.a * alpha); \
+        gl_FragColor.rgb *= gl_FragColor.a; \
+        gl_FragColor *= u_color; \
+    } \
+";
+
+/* RGB to ABGR conversion DEBUG */
+static const char *GLES2_FragmentSrc_TextureABGRSrc_SDF_dbg = " \
+    #extension GL_OES_standard_derivatives : enable\n\
+    \
+    precision mediump float; \
+    uniform sampler2D u_texture; \
+    uniform vec4 u_color; \
+    varying vec2 v_texCoord; \
+    \
+    void main() \
+    { \
+        vec4 abgr = texture2D(u_texture, v_texCoord); \
+\
+        float a = abgr.a; \
+        gl_FragColor = vec4(a, a, a, 1.0); \
+    } \
+";
+
+
+static float g_val = 1.0f;
+static int   g_use_SDF = 1;
+static int   g_use_SDF_debug = 0;
+static float g_angle = 0.0f;
+static float matrix_mvp[4][4];
+
+
+
+
+typedef struct shader_data
+{
+    GLuint shader_program, shader_frag, shader_vert;
+
+    GLint attr_position;
+    GLint attr_color, attr_mvp;
+
+} shader_data;
+
+static void
+Render(unsigned int width, unsigned int height, shader_data* data)
+{
+    float *verts = g_verts;
+    ctx.glViewport(0, 0, 640, 480);
+
+    GL_CHECK(ctx.glClear(GL_COLOR_BUFFER_BIT));
+
+    GL_CHECK(ctx.glUniformMatrix4fv(g_uniform_locations[GLES2_UNIFORM_PROJECTION], 1, GL_FALSE, (const float *)matrix_mvp));
+    GL_CHECK(ctx.glUniform4f(g_uniform_locations[GLES2_UNIFORM_COLOR], 1.0f, 1.0f, 1.0f, 1.0f));
+
+    GL_CHECK(ctx.glVertexAttribPointer(GLES2_ATTRIBUTE_ANGLE,    2, GL_FLOAT, GL_FALSE, 0, (const GLvoid *) (verts + 16)));
+    GL_CHECK(ctx.glVertexAttribPointer(GLES2_ATTRIBUTE_TEXCOORD, 2, GL_FLOAT, GL_FALSE, 0, (const GLvoid *) (verts + 8)));
+    GL_CHECK(ctx.glVertexAttribPointer(GLES2_ATTRIBUTE_POSITION, 2, GL_FLOAT, GL_FALSE, 0, (const GLvoid *) verts));
+
+    GL_CHECK(ctx.glDrawArrays(GL_TRIANGLE_STRIP, 0, 4));
+}
+
+
+void renderCopy_angle(float degree_angle) 
+{
+    const float radian_angle = (float)(3.141592 * degree_angle) / 180.0;
+    const GLfloat s = (GLfloat) SDL_sin(radian_angle);
+    const GLfloat c = (GLfloat) SDL_cos(radian_angle) - 1.0f;
+    GLfloat *verts = g_verts + 16;
+    *(verts++) = s;
+    *(verts++) = c;
+    *(verts++) = s;
+    *(verts++) = c;
+    *(verts++) = s;
+    *(verts++) = c;
+    *(verts++) = s;
+    *(verts++) = c;
+}
+
+
+void renderCopy_position(SDL_Rect *srcrect, SDL_Rect *dstrect) 
+{
+    GLfloat minx, miny, maxx, maxy;
+    GLfloat minu, maxu, minv, maxv;
+    GLfloat *verts = g_verts;
+
+    minx = dstrect->x;
+    miny = dstrect->y;
+    maxx = dstrect->x + dstrect->w;
+    maxy = dstrect->y + dstrect->h;
+
+    minu = (GLfloat) srcrect->x / g_surf_sdf->w;
+    maxu = (GLfloat) (srcrect->x + srcrect->w) / g_surf_sdf->w;
+    minv = (GLfloat) srcrect->y / g_surf_sdf->h;
+    maxv = (GLfloat) (srcrect->y + srcrect->h) / g_surf_sdf->h;
+
+    *(verts++) = minx;
+    *(verts++) = miny;
+    *(verts++) = maxx;
+    *(verts++) = miny;
+    *(verts++) = minx;
+    *(verts++) = maxy;
+    *(verts++) = maxx;
+    *(verts++) = maxy;
+
+    *(verts++) = minu;
+    *(verts++) = minv;
+    *(verts++) = maxu;
+    *(verts++) = minv;
+    *(verts++) = minu;
+    *(verts++) = maxv;
+    *(verts++) = maxu;
+    *(verts++) = maxv;
+}
+
+int done;
+Uint32 frames;
+shader_data *datas;
+
+void loop()
+{
+    SDL_Event event;
+    int i;
+    int status;
+
+    /* Check for events */
+    ++frames;
+    while (SDL_PollEvent(&event) && !done) {
+        switch (event.type) {
+        case SDL_KEYDOWN:
+            {
+                const int sym = event.key.keysym.sym;
+
+                if (sym == SDLK_TAB) {
+                    SDL_Log("Tab");
+
+
+                }
+
+
+                if (sym == SDLK_LEFT)  g_val -= 0.05;
+                if (sym == SDLK_RIGHT) g_val += 0.05;
+                if (sym == SDLK_UP)    g_angle -= 1;
+                if (sym == SDLK_DOWN)  g_angle += 1;
+ 
+
+                break;
+            }
+
+        case SDL_WINDOWEVENT:
+            switch (event.window.event) {
+                case SDL_WINDOWEVENT_RESIZED:
+                    for (i = 0; i < state->num_windows; ++i) {
+                        if (event.window.windowID == SDL_GetWindowID(state->windows[i])) {
+                            int w, h;
+                            status = SDL_GL_MakeCurrent(state->windows[i], context[i]);
+                            if (status) {
+                                SDL_Log("SDL_GL_MakeCurrent(): %s\n", SDL_GetError());
+                                break;
+                            }
+                            /* Change view port to the new window dimensions */
+                            SDL_GL_GetDrawableSize(state->windows[i], &w, &h);
+                            ctx.glViewport(0, 0, w, h);
+                            state->window_w = event.window.data1;
+                            state->window_h = event.window.data2;
+                            /* Update window content */
+                            Render(event.window.data1, event.window.data2, &datas[i]);
+                            SDL_GL_SwapWindow(state->windows[i]);
+                            break;
+                        }
+                    }
+                    break;
+            }
+        }
+        SDLTest_CommonEvent(state, &event, &done);
+    }
+
+
+    matrix_mvp[3][0] = -1.0f;
+    matrix_mvp[3][3] = 1.0f;
+
+    matrix_mvp[0][0] = 2.0f / 640.0;
+    matrix_mvp[1][1] = -2.0f / 480.0;
+    matrix_mvp[3][1] = 1.0f;
+    
+    if (0)
+    {
+        float *f = (float *) matrix_mvp;
+        SDL_Log("-----------------------------------");
+        SDL_Log("[ %f, %f, %f, %f ]", *f++, *f++, *f++, *f++);
+        SDL_Log("[ %f, %f, %f, %f ]", *f++, *f++, *f++, *f++);
+        SDL_Log("[ %f, %f, %f, %f ]", *f++, *f++, *f++, *f++);
+        SDL_Log("[ %f, %f, %f, %f ]", *f++, *f++, *f++, *f++);
+        SDL_Log("-----------------------------------");
+    }
+
+    renderCopy_angle(g_angle);
+
+    {
+        int w, h;
+        SDL_Rect rs, rd;
+
+        SDL_GL_GetDrawableSize(state->windows[0], &w, &h);
+
+        rs.x = 0; rs.y = 0; rs.w = g_surf_sdf->w; rs.h = g_surf_sdf->h;
+        rd.w = g_surf_sdf->w * g_val; rd.h = g_surf_sdf->h * g_val;
+        rd.x = (w - rd.w) / 2; rd.y = (h - rd.h) / 2;
+        renderCopy_position(&rs, &rd);
+    }
+    
+
+    if (!done) {
+      for (i = 0; i < state->num_windows; ++i) {
+          status = SDL_GL_MakeCurrent(state->windows[i], context[i]);
+          if (status) {
+              SDL_Log("SDL_GL_MakeCurrent(): %s\n", SDL_GetError());
+
+              /* Continue for next window */
+              continue;
+          }
+          Render(state->window_w, state->window_h, &datas[i]);
+          SDL_GL_SwapWindow(state->windows[i]);
+      }
+    }
+#ifdef __EMSCRIPTEN__
+    else {
+        emscripten_cancel_main_loop();
+    }
+#endif
+}
+
+int
+main(int argc, char *argv[])
+{
+    int fsaa, accel;
+    int value;
+    int i;
+    SDL_DisplayMode mode;
+    Uint32 then, now;
+    int status;
+    shader_data *data;
+
+    /* Initialize parameters */
+    fsaa = 0;
+    accel = 0;
+
+    /* Initialize test framework */
+    state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO);
+    if (!state) {
+        return 1;
+    }
+    for (i = 1; i < argc;) {
+        int consumed;
+
+        consumed = SDLTest_CommonArg(state, i);
+        if (consumed == 0) {
+            if (SDL_strcasecmp(argv[i], "--fsaa") == 0) {
+                ++fsaa;
+                consumed = 1;
+            } else if (SDL_strcasecmp(argv[i], "--accel") == 0) {
+                ++accel;
+                consumed = 1;
+            } else if (SDL_strcasecmp(argv[i], "--zdepth") == 0) {
+                i++;
+                if (!argv[i]) {
+                    consumed = -1;
+                } else {
+                    depth = SDL_atoi(argv[i]);
+                    consumed = 1;
+                }
+            } else {
+                consumed = -1;
+            }
+        }
+        if (consumed < 0) {
+            static const char *options[] = { "[--fsaa]", "[--accel]", "[--zdepth %d]", NULL };
+            SDLTest_CommonLogUsage(state, argv[0], options);
+            quit(1);
+        }
+        i += consumed;
+    }
+
+    /* Set OpenGL parameters */
+    state->window_flags |= SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE;
+    state->gl_red_size = 5;
+    state->gl_green_size = 5;
+    state->gl_blue_size = 5;
+    state->gl_depth_size = depth;
+    state->gl_major_version = 2;
+    state->gl_minor_version = 0;
+    state->gl_profile_mask = SDL_GL_CONTEXT_PROFILE_ES;
+
+    if (fsaa) {
+        state->gl_multisamplebuffers=1;
+        state->gl_multisamplesamples=fsaa;
+    }
+    if (accel) {
+        state->gl_accelerated=1;
+    }
+    if (!SDLTest_CommonInit(state)) {
+        quit(2);
+        return 0;
+    }
+
+    context = (SDL_GLContext *)SDL_calloc(state->num_windows, sizeof(context));
+    if (context == NULL) {
+        SDL_Log("Out of memory!\n");
+        quit(2);
+    }
+    
+    /* Create OpenGL ES contexts */
+    for (i = 0; i < state->num_windows; i++) {
+        context[i] = SDL_GL_CreateContext(state->windows[i]);
+        if (!context[i]) {
+            SDL_Log("SDL_GL_CreateContext(): %s\n", SDL_GetError());
+            quit(2);
+        }
+    }
+
+    /* Important: call this *after* creating the context */
+    if (LoadContext(&ctx) < 0) {
+        SDL_Log("Could not load GLES2 functions\n");
+        quit(2);
+        return 0;
+    }
+
+    SDL_memset(matrix_mvp, 0, sizeof (matrix_mvp));
+    
+    {
+        SDL_Surface *tmp;
+        char *f;
+        g_use_SDF = 1;
+        g_use_SDF_debug = 0;
+
+        if (g_use_SDF) {
+            f = "testgles2_sdf_img_sdf.bmp";
+        } else {
+            f = "testgles2_sdf_img_normal.bmp";
+        }
+            
+        SDL_Log("SDF is %s", g_use_SDF ? "enabled" : "disabled");
+
+        /* Load SDF BMP image */
+#if 1
+        tmp = SDL_LoadBMP(f);
+        if  (tmp == NULL) {
+            SDL_Log("missing image file: %s", f);
+            exit(-1);
+        } else {
+            SDL_Log("Load image file: %s", f);
+        }
+
+#else
+        /* Generate SDF image using SDL_ttf */
+
+        #include "SDL_ttf.h"
+        char *font_file = "./font/DroidSansFallback.ttf";
+        char *str = "Abcde";
+        SDL_Color color = {  0, 0,0,  255};
+
+        TTF_Init();
+        TTF_Font *font = TTF_OpenFont(font_file, 72);
+
+        if (font == NULL) {
+            SDL_Log("Cannot open font %s", font_file);
+        }
+
+        TTF_SetFontSDF(font, g_use_SDF);
+        SDL_Surface *tmp = TTF_RenderUTF8_Blended(font, str, color);
+
+        SDL_Log("err: %s", SDL_GetError());
+        if (tmp == NULL) {
+            SDL_Log("can't render text");
+            return -1;
+        }
+
+        SDL_SaveBMP(tmp, f);
+
+        TTF_CloseFont(font);
+        TTF_Quit();
+#endif
+        g_surf_sdf = SDL_ConvertSurfaceFormat(tmp, SDL_PIXELFORMAT_ABGR8888, 0);
+
+        SDL_SetSurfaceBlendMode(g_surf_sdf, SDL_BLENDMODE_BLEND);
+    }
+
+
+    if (state->render_flags & SDL_RENDERER_PRESENTVSYNC) {
+        SDL_GL_SetSwapInterval(1);
+    } else {
+        SDL_GL_SetSwapInterval(0);
+    }
+
+    SDL_GetCurrentDisplayMode(0, &mode);
+    SDL_Log("Screen bpp: %d\n", SDL_BITSPERPIXEL(mode.format));
+    SDL_Log("\n");
+    SDL_Log("Vendor     : %s\n", ctx.glGetString(GL_VENDOR));
+    SDL_Log("Renderer   : %s\n", ctx.glGetString(GL_RENDERER));
+    SDL_Log("Version    : %s\n", ctx.glGetString(GL_VERSION));
+    SDL_Log("Extensions : %s\n", ctx.glGetString(GL_EXTENSIONS));
+    SDL_Log("\n");
+
+    status = SDL_GL_GetAttribute(SDL_GL_RED_SIZE, &value);
+    if (!status) {
+        SDL_Log("SDL_GL_RED_SIZE: requested %d, got %d\n", 5, value);
+    } else {
+        SDL_Log( "Failed to get SDL_GL_RED_SIZE: %s\n",
+                SDL_GetError());
+    }
+    status = SDL_GL_GetAttribute(SDL_GL_GREEN_SIZE, &value);
+    if (!status) {
+        SDL_Log("SDL_GL_GREEN_SIZE: requested %d, got %d\n", 5, value);
+    } else {
+        SDL_Log( "Failed to get SDL_GL_GREEN_SIZE: %s\n",
+                SDL_GetError());
+    }
+    status = SDL_GL_GetAttribute(SDL_GL_BLUE_SIZE, &value);
+    if (!status) {
+        SDL_Log("SDL_GL_BLUE_SIZE: requested %d, got %d\n", 5, value);
+    } else {
+        SDL_Log( "Failed to get SDL_GL_BLUE_SIZE: %s\n",
+                SDL_GetError());
+    }
+    status = SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &value);
+    if (!status) {
+        SDL_Log("SDL_GL_DEPTH_SIZE: requested %d, got %d\n", depth, value);
+    } else {
+        SDL_Log( "Failed to get SDL_GL_DEPTH_SIZE: %s\n",
+                SDL_GetError());
+    }
+    if (fsaa) {
+        status = SDL_GL_GetAttribute(SDL_GL_MULTISAMPLEBUFFERS, &value);
+        if (!status) {
+            SDL_Log("SDL_GL_MULTISAMPLEBUFFERS: requested 1, got %d\n", value);
+        } else {
+            SDL_Log( "Failed to get SDL_GL_MULTISAMPLEBUFFERS: %s\n",
+                    SDL_GetError());
+        }
+        status = SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &value);
+        if (!status) {
+            SDL_Log("SDL_GL_MULTISAMPLESAMPLES: requested %d, got %d\n", fsaa,
+                   value);
+        } else {
+            SDL_Log( "Failed to get SDL_GL_MULTISAMPLESAMPLES: %s\n",
+                    SDL_GetError());
+        }
+    }
+    if (accel) {
+        status = SDL_GL_GetAttribute(SDL_GL_ACCELERATED_VISUAL, &value);
+        if (!status) {
+            SDL_Log("SDL_GL_ACCELERATED_VISUAL: requested 1, got %d\n", value);
+        } else {
+            SDL_Log( "Failed to get SDL_GL_ACCELERATED_VISUAL: %s\n",
+                    SDL_GetError());
+        }
+    }
+
+    datas = (shader_data *)SDL_calloc(state->num_windows, sizeof(shader_data));
+
+    /* Set rendering settings for each context */
+    for (i = 0; i < state->num_windows; ++i) {
+
+        int w, h;
+        status = SDL_GL_MakeCurrent(state->windows[i], context[i]);
+        if (status) {
+            SDL_Log("SDL_GL_MakeCurrent(): %s\n", SDL_GetError());
+
+            /* Continue for next window */
+            continue;
+        }
+
+        {
+            int format = GL_RGBA;
+            int type = GL_UNSIGNED_BYTE;
+
+            GL_CHECK(ctx.glGenTextures(1, &g_texture));
+
+            ctx.glActiveTexture(GL_TEXTURE0);
+            ctx.glPixelStorei(GL_PACK_ALIGNMENT, 1);
+            ctx.glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+
+            ctx.glBindTexture(g_texture_type, g_texture);
+
+            ctx.glTexParameteri(g_texture_type, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+            ctx.glTexParameteri(g_texture_type, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+            ctx.glTexParameteri(g_texture_type, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+            ctx.glTexParameteri(g_texture_type, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+            GL_CHECK(ctx.glTexImage2D(g_texture_type, 0, format, g_surf_sdf->w, g_surf_sdf->h, 0, format, type, NULL));
+            GL_CHECK(ctx.glTexSubImage2D(g_texture_type, 0, 0 /* xoffset */, 0 /* yoffset */, g_surf_sdf->w, g_surf_sdf->h, format, type, g_surf_sdf->pixels));
+        }
+
+
+        SDL_GL_GetDrawableSize(state->windows[i], &w, &h);
+        ctx.glViewport(0, 0, w, h);
+
+        data = &datas[i];
+
+        /* Shader Initialization */
+        process_shader(&data->shader_vert, GLES2_VertexSrc_Default_, GL_VERTEX_SHADER);
+
+        if (g_use_SDF) {
+            if (g_use_SDF_debug == 0) {
+                process_shader(&data->shader_frag, GLES2_FragmentSrc_TextureABGRSrc_SDF, GL_FRAGMENT_SHADER);
+            } else {
+                process_shader(&data->shader_frag, GLES2_FragmentSrc_TextureABGRSrc_SDF_dbg, GL_FRAGMENT_SHADER);
+            }
+        } else {
+            process_shader(&data->shader_frag, GLES2_FragmentSrc_TextureABGRSrc_, GL_FRAGMENT_SHADER);
+        }
+
+        /* Create shader_program (ready to attach shaders) */
+        data->shader_program = GL_CHECK(ctx.glCreateProgram());
+
+        /* Attach shaders and link shader_program */
+        GL_CHECK(ctx.glAttachShader(data->shader_program, data->shader_vert));
+        GL_CHECK(ctx.glAttachShader(data->shader_program, data->shader_frag));
+        GL_CHECK(ctx.glLinkProgram(data->shader_program));
+
+        ctx.glBindAttribLocation(data->shader_program, GLES2_ATTRIBUTE_POSITION, "a_position");
+        ctx.glBindAttribLocation(data->shader_program, GLES2_ATTRIBUTE_TEXCOORD, "a_texCoord");
+        ctx.glBindAttribLocation(data->shader_program, GLES2_ATTRIBUTE_ANGLE, "a_angle");
+        ctx.glBindAttribLocation(data->shader_program, GLES2_ATTRIBUTE_CENTER, "a_center");
+
+        /* Predetermine locations of uniform variables */
+        g_uniform_locations[GLES2_UNIFORM_PROJECTION] = ctx.glGetUniformLocation(data->shader_program, "u_projection");
+        g_uniform_locations[GLES2_UNIFORM_TEXTURE] = ctx.glGetUniformLocation(data->shader_program, "u_texture");
+        g_uniform_locations[GLES2_UNIFORM_COLOR] = ctx.glGetUniformLocation(data->shader_program, "u_color");
+
+        GL_CHECK(ctx.glUseProgram(data->shader_program));
+
+        ctx.glEnableVertexAttribArray((GLenum) GLES2_ATTRIBUTE_ANGLE);
+        ctx.glDisableVertexAttribArray((GLenum) GLES2_ATTRIBUTE_CENTER);
+        ctx.glEnableVertexAttribArray(GLES2_ATTRIBUTE_POSITION);
+        ctx.glEnableVertexAttribArray((GLenum) GLES2_ATTRIBUTE_TEXCOORD);
+
+
+    ctx.glUniform1i(g_uniform_locations[GLES2_UNIFORM_TEXTURE], 0);  /* always texture unit 0. */
+    ctx.glActiveTexture(GL_TEXTURE0);
+    ctx.glBindTexture(g_texture_type, g_texture);
+     GL_CHECK(ctx.glClearColor(1, 1, 1, 1));
+
+    // SDL_BLENDMODE_BLEND
+    GL_CHECK(ctx.glEnable(GL_BLEND));
+    ctx.glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+    ctx.glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
+
+
+    }
+
+    /* Main render loop */
+    frames = 0;
+    then = SDL_GetTicks();
+    done = 0;
+
+#ifdef __EMSCRIPTEN__
+    emscripten_set_main_loop(loop, 0, 1);
+#else
+    while (!done) {
+        loop();
+    }
+#endif
+
+    /* Print out some timing information */
+    now = SDL_GetTicks();
+    if (now > then) {
+        SDL_Log("%2.2f frames per second\n",
+               ((double) frames * 1000) / (now - then));
+    }
+#if !defined(__ANDROID__) && !defined(__NACL__)  
+    quit(0);
+#endif    
+    return 0;
+}
+
+#else /* HAVE_OPENGLES2 */
+
+int
+main(int argc, char *argv[])
+{
+    SDL_Log("No OpenGL ES support on this system\n");
+    return 1;
+}
+
+#endif /* HAVE_OPENGLES2 */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/test/testgles2_sdf_img_normal.bmp b/Engine/lib/sdl/test/testgles2_sdf_img_normal.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..1209e1b1df7105dad9e3e401b9dd9a0d255e4162
GIT binary patch
literal 68122
zcmeHP3AA3*6@Ez&No!mPk;*euL8uZ#7ZGD9RU|bh7VSz}sZ^F4O00@`imECLMcT?L
zOCvS5B_gD0kkrr`s-iXP!lQ_>`hD@v%6aGQeeSvUp8LnDy_YZd+;jGHzW?rX&%OWu
z?ELlqeS5S~P6ECM%mEGrdbG8-^}_L*KA(=G>B%Q;ZJ++fzE9f6jTz|;TGJRX28;n?
zz!)$Fi~(c77%&Em0b{@zFb0ePW55_N28;n?z!)$Fi~(c77%&Em0b{@zFb0ePW55_N
z28;n?z!)$Fi~(c77%&Em0b{@zFb0ePW55_N28;n?;QyC_l`ys8z<A&+;9}q$;5cAU
zV0mCk$$AL9KQIAcZj*s?fgb^5f!%<$fF`6boDKuV0cQh_m*dgi7w89kmZUe583K#~
zP6f^bnDd#yi2(W99Ux!Q9~z=tm4`8cze4PWf1__H)vCFH<=}cDAmubQ680~F%{)c7
zC;ATpW&$4rQXJR!A;xb9SSziNtr6rh;AOz&P;`6|y4L{*080aP<ZCd#5qJ-X#r-eF
z9{`R9cx{HV4mu?JP_NGUvM@dZxC1E4*U#lG=>HBl24J2=!u83w_uIpZj2jr|oc$d9
zb}XN;K4>=}$nPsSm-PG?TKg{8wg>)loeqYh8Gsf$wf`mf*a;{rYrx=UAT^G!_cZKy
zFY{#|ocKDf?dw!+^Uuw{50qI$T>S9JI=>qj3265Ma-*%IQ!v(Q;d&6xgXjG0$&Dt`
zbw9>aJ{avX>x`5`2Yl?}`K;UIz5Z0-BS4B*rSGVcNo@yx?iH%UayGoqI1eY>)3`DJ
z=*Fua*M}kZ1-{Q*ZLU$8{2l{Rod2Mod(l?OY6!$Vjg-p;1xZNtaa*U&2pqLFK#CRX
zdmp}X?6<gH{RW7|sxnrlK6XU>cQfX27JN~D1xUFs8m#!wFxb7R_?2Rn?TgjNp^><}
z_q0m*zi!dywRu4jQho4#!T$}+JBr`Gqo4Ok)*jctOMyE9twvpLZ$oD@ppNia%K3{O
zIfn(npMbf*QvmnSnoVkba4qhL_;LQ{K<6spbYK#21#mB*aWooZ(q}<`Rb^Kgrri5^
zALG93QQ$scKJW|><IBx6Rv%x058f-Bu78|{{#MET2;|3hZSq|t+GpZ?_(#^n#u118
zFm?_=zI{8t{TRlU1**siF!FtcZN|MG*b7)12!;EywSjK}yk7Z??tG-w$5POL$g^>_
z{_#qTuM23hA_m3-Zveg>@6#G@7%DCNoQm!n-2WT~tQzq?0AsxGpA5_f!u`Zx^u^>l
z4EpnQZSE&liWz1aYlk0=*B>OrNU0C*CH6@0<y81SU?JeR2#?%nmz9lRKu$wn?tB5p
zb^^)>>tz>U8ZZhdlCe;5@xmkT3%uv13a?4t*Frzid8$vRS5(K(L6M(P6=B}r0l3aF
z*P{C1JxrPt`%=~<sMQi)Yf^kZyK+4*lA`+HdQpYTBVi}y#XhcU%L8R(I+Qhkybla4
z<4n+Ht;A#*4Epz*Fqd&LV`XeP^gjrMzQS|GT<zxlDfHpa7htSiwJbL<4C-qXnDoT>
z^MH%*AMYx#%`yCl68qLf=SB7L(?ma#8rNl?55HaJdKv^j+C7r%0N+11Ee9ijpTFO}
zr$%r-k7>^&E=C#m-1EN*I9vb7XORudILoAau96Se-u{_lNNzS!;*yip_XDx|;I;Q9
zDR5%nR?zc5AHU6ge5y=_qHpWBuS#`NQ;+M7AJ=blk5)&14rAY6*e>Jy=!maV%Q(uY
z%k?dslRM|Vt|>Vaj$Iu8*n$4kXW&?U{4qn~_bNFu-}VIm-1lhv8m>PB5`5HE;hL<y
z2YRxubJ%YW_@7_cE)zm~SHt&6oX3(9?K+#=U_#HpcgQ8r`EDjvw7ltOLaLL9-VZS*
z<;cF#5j!`uX~ce}Q)>9Qb0mk!8Det{;4`zvQ)-A+pvW~t^7D&SCk^TGU6GU*`_^k9
z=C+Y|JCukQs}HVgb%pzDjhB=<9viXe?<HCxCn1P7hvAtL_-!OcY6$MBwLJGub<&XD
z>hR0`x|ClN`@Tz*SpO(FzgT^&P|}yA&b4tNAn`I=G6?!&d-GO2mouFyfRsP`a_#R<
zkHo-Gl4#Gt%(Lh{Q&NDMN_W6s;_>mCenazK=y+L)H8E5!IM?dq^#Z#x!;e8(;^nmj
zC)`6xwtSz}H^DxK${ZyJelNuO&mo7vi8N34rHXd_@ml#TNNkQ<WK3{3_>#EfHM361
zI9h%1n$9J$y+faZAWvglnk%2ZS|$HPASs8O9C806#b95ma2=L>Jdo<3VLh&AZz(x)
zt?9@FZND-L{>zG1AAIkWOJaMZwF-jpy^Hjj^LJIP679E$RruC&-Vp=RJlU5jyuKtK
zccnULf!;Mrj#A#a`>K3juhmED_lqf%UJ&7g@26tId!oeCA7Vxs$GCrz;<NA0jB)rZ
zrNv1Nqj7aps)H8j4U5cEn}3de-czbPPiytTJy9<CF&t@g+$s{Jcf>AdevuRweUGH&
zp7XjJ9GPn@KQ|WRO3Oc2{}V2Wgkw+WJO|{8o$6<5LT-|ZRv$M?$`$)ghMhJKzNglN
z&nBAP4VqEr{#NC%Wn``?Q;OxOahR*WOnq=JXGi9mE2q%Uo+%^>I$C{96LhO~O@d*V
zuRD*uqvcxT^upuqRg)=c*DI1k&OPXmNSu_EV_b#Y<vuT4ADcwx`XI)*Hdn!uir<&e
z&(E=nX!UVh6=#agh3MBllR=7&>waIco#hl-aQsloVMfN-J1H^9TdHX9Z8Yw4^*^4P
zpr<zvZ7Keho=(}O_8$KHvW`4`tv>iWo?LP{97$ZTZ_R=rFDSMT7ue+-enrV)ZpI+{
zDKW@Vs%Y<_HSTluKbo4Lr*|ycQvBD^zqF^9+T?FkB!BGNEY*pir`1Q5H9>H{sOuK|
ztL46oX4KjLpkn(D`g46ZSCGP@zdM!k&-uOEx0QJ^ZmRH|x0EM2JRk!&U&()!b)p}9
zY4_#5F;-S4!a&N6*LNM!>Vw}q<Pz>rrQEqMERv~EkZjr4USynUJoel6FJ_8y2K;FA
zObv0Z;$wcQg91IRKJF;6(}uZ+m*zZ0Gl=v*rTD7*`+2QCnD^?Dd{T$_T%<ii+>_ws
z6zE7CvTvUR`y474MRLgXy9mCo*5;WyhY5<0H&Y!H=xN`RUR_|P4IhL7Y0mtPeOb*&
z=-*oL!}}BOQ*|U(AN(ClT^Rxg5(n(NIKlbu5qmz@v_g(R5N!^}WJ)0R?2sB_+en@p
zr8-gc`bT^puh<lI^PMznSK@a6B4cm-CyI|8?-yhBak`g7)#hnR?&M@-f>ZuY&j*SR
z-tYNdvuW7?0i@56eSEg6E9=97=AZqkvJ@1x>upS`6Ge~TA80x5s@SA-^WG!*P5pk0
z`xEW`$%vE$3Up%i@koJf$}oLM^XK0JteWBgI=3r6=r;!kDQRfyJKqzmoZ=v&b27#x
zj$B{FwA;{iim#d7G|P2dsQBgHnQK^8845!;PyhHX`ct0mw7TtpeVIL)mVc~1nD2I)
zVM702(DCQ&x9?7{cPfWO{P6d^Ro(|W->FCL1^xW}_QX^tf?jX*y%6!uIAvrQl>OZN
z_TVy(JYC+G_%6lw<=R!B&7J!mXlQHC!A>c1{3XU*F8=X~h)tQHqWZWW&Z_KT_}=y*
zz|Yxlr_9~WgT9`R_~QPvY1teB{QUj)YZ&WaF@Z@Dzb-~u*Ygygv(R7VvmCGZV}9QP
z>dKjL;O6Qdrx!Tped}$-cKZU`)ZwD~V7^xYtn)I$??L^!`t5&Vtn8Zq-H1Q>o(Po9
z5hiV`@t;JQ0X=^netR~?SjS~#ER?n1-1@%D_@r*^zI|3nXT0aU1^D^6_Os~cy``>f
z3<u7qf8^e6#fWolU%@>^E=j2m=6n;dW<t;vpz~|MpJ&)UJi$+>!sjr4&lURe&u3zM
zP-rNe^Y3)_1vsY<fo*^kp`ITvY~PFV0SS)C(M3Q?Z7@a^xfw=be(wA-jHT@DcZDAB
zjm|DS9)_`8qJ6fbBLTGM(uon9vO`*Z+y_S?AN<ac+zto&0la1@D*;~x&H-KoLOcKb
zPK;Ms=V8{i0nh>X{-pLJ(BZ!2NPxNWbLLue2Eh1y_Vew2hVxXp6pFrW*nR`!-0y7z
zkQWNqSbmqZ8^Ezwfza-C^nD=oQ?H7w0;A`FFpfLt=X4sd6|fvYVV<n-Ljk^*bGp*8
z?sEs+cad>8lj896l7#ntu5F<W*POK_gNl7xeH;sa+*gJ1{qv78zOX>Y*XO>9*GV1O
z1;%A!`th|kuT4HDr$`?tX=|P2pSc#@C*Fh3c7V2z!B8dH5>{^lQeI&n*Nmb(oz1h*
zW&Pz8zRQ%ZclL2C6s?|k56>xDeVl?Iyk_nJ94~c_{I255Kn~d%PIyh%$tScuutZ{9
zyZ)9bKKIz%>ruGggn9A2j<D`xdn74dtdIAkb?YP)vDNNbV+5Ny=#%n1O3<y-rPT-b
zN)+x>wY;VLq`tqxM{Z7e51kE2@v8LQ3SVVpWhl=8s>E_OufTq2XHdS2asA=3Q>F4@
z16a<F_z&Z0=YNKeH7jRPY&cTMaaLeDP|@Q(aQQ&D?x|KEmw1kQqCFnq^M}Tr)X%l?
zJfIKIgz!0LG{E;2QvB3D*4YT4tdN)EfDRxv7WKG~nF9EGO|~^37^*GHz{80^*<6_u
zpQ(-q_<Yi&@cTR|Kk_xu3p@dBiL2{9om@?=KCTo3aLpvg^8hJ7*Y^a*Cjn~#t&m;_
zvIlTAumEs*Xh+uhOyC4y5Kvdh3qP}m0DhKQ+-ER08Q2I2WqovLcA;*a^A%ytcjcVF
z_CA1laBbsWp1LaltrA{$5)b^WobY}k>FntgG9I=1;QAI5zMI(rH~<(0@ZLBS;5xXZ
zh0k+Cfc=0&fy04s0DNv42=oA&67sS=z~`A!0C{2D{y<DN$Ds6?v#%-X3&&dk<mRwW
z?2F@Ips9O4Tt{U`j7mH_+-XIAKN56aL|?B?oty`)KBndjV!jF);58{-7fsejVNy##
zfos>ZfW!r#eYhS=W9Os43DN4~h9-iUPn7|ykHyq*Z!XmU_W_qGW1B8E&)U-J<HoE}
z%vliwRv(KQ+7L~tKCVT-^z1u-v1#^})kk(pD>=0K=t|pMoQ5^>68fZf3gf$)W<9g|
z$Vz8rXI39wsXGRzVSPyF{C>S(SJSL#Rv%gEtnAF{qbqf*;8eO-gf((YSF`MARv+0Z
zt>n<^qdRTW(G}K1cwXgu-R_a}9;*+Xn^ulkeROA=-ywzd;Ge&Naen9Cq*#44$!@xD
ztB>wn^+p$Kz^@6veR+42>^)W=*(t5$(CR~`?Fw}JHQ~4UJB6mj>Z56f)BIa~$UJR>
z?)wBxlhw2LT76`vw30)sk4m&PZe;b*IK@c;tUi)xYPpitN6RS}16qBEv@G#XzGHq`
zfdBVVOFYTXK>`~KpMm>aJ_pmcDH;RDfH7bU7z4(DF<=ZB1IB<cU<?=o#(*(k3>X8(
nfH7bU7z4(DF<=ZB1IB<cU<?=o#(*(k3>X8(fH7bUkb(aJ?X9&q

literal 0
HcmV?d00001

diff --git a/Engine/lib/sdl/test/testgles2_sdf_img_sdf.bmp b/Engine/lib/sdl/test/testgles2_sdf_img_sdf.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..5f983d2d211509e9e91e4e65e173d78c1a9d64cb
GIT binary patch
literal 72202
zcmeI&2Y6If-uUsgU<sDkVi(i}G`J8OcEJK@RERBhDT+c+7+XX|L6PF1IJQ_&0Ts)j
z5G=6^qKL*8T#a2~!4gzri@K=$|9;;$_j%`;cka!E;=9k^InRD}?%Z?lJ?H$+@0>ef
zcmKokHe2a$mJ4wP-o(*Z>2GcSwhEt#P5--|!<6#xzy0mM|KquTw;eL*n3T%gVJ-r>
z2;?I0pBe!-w3VCur}Z(lZ<#jU71`g^wpV03%j?;x{dGS7jClD<Y>jo1A7LHp*2JGt
z9Csd?>y!0f=k?9qWB=DcY6<RHpOc$lOSHw-*rti!x4_0&4}Vq+TG7_p*Z`X%Q{U`o
z8*C2y@3m{edzZC1PRHxG9e-P-$HhL`uJJR6%-Ntcmsif6_juj%DE8N9ZiLOS6;k`_
zeEQw<sqr$#t6^D-<1qfVQHahciqMI=?O=agcPpwmhvvxku+8TB<aJ(ezoPE(Ssh?*
zxVDUYTX@fo*d2SL8}`HgP5kcp-C$pW7#O?Nu{?|Gz}Pz9f5#5k8TM@-bVF+2Jl+?3
z!T#+8@9|#8X`ZL=A)E>=w(mX0(s4T8E^z!^k=k}QzS}4JX1nIl)+oS+O~+ArWxfUX
z7|W$uS8F!4<@`IhK66*>3FDI5U*|I{UhS!K%=X>=Xl1mdm<Pt&_HFlI^hQa9Uexu3
zbJr2>TPtCC731kXY(6-D2f;R*>yy`cz3gAuJ%>@(1AD+VWS%;9@3)O(a3cDkANn`(
zyXQ+`jBLX^at&?^*X6Rl58NMp&Nk=-`*;8j!4WtXC!sG=`{wb<I05$maCndRI#2e|
zTyeiPPr}NoRJaBlk88+S8Y{=^xHHA2Z`1jpU317aw+noR$5DCZv#oayI%5l%m)R7@
z;+Q(Xd2~MPuXBGCj)!sSi(nr8^m}T&jP0T54xeG)&F!{uKGsBYWfd;4@80WpoQr`N
zidcjp)D3{~I}pae^}M{wCOpV_FfQiLX|T=a`s8(9-`qWCa?PnY8vCOJ=E>=B?By7a
z5x5kWHGTU1B3K{9z?eCA-C)kP#X4A;;`?A5_#AW4`8CG<QHHZ{KGORZ^zRbt?4Q?o
zt@n8Eap(=_YBy{TW1PPB?RQ%k`)+XGF&~|4$9o=perjB7dnD|W?K(%s(KUZKieYS{
z^2(T7Z!FD2^KlE9pJ8PUD%^9ogJW`R&ZEz;zs~WwxB$jwB<yRz@9FUx%(+uxe~*NH
z*%!WZ+ryaIZdmc%>RRx=elSnQU;+{muA*)foHN@#0M60cSk|&G4{%@Tj+1c?E=O~H
zvfk^w{%qJk`<ZDRS90EU;ym_&vA+<b;d5@lL`=dI+|l&uch6fN#9$c5&Vz9<|M!A(
zyb-c3?#1r0JHYun3_j2GU=EMO6}SdB;#Q>gE$H9voVR}!aNOSGIPIfjbdHaLu{B4w
zz^brp2>WgS9Y@f<Yb1!}^&I>B^tSzOpKSMPm_rv~2>Qckc+R>^^I^=bH~;LT`Pdoe
zXQq<R$!)O<9E)S}KHGC1%>(E7I^2xgFd4=v;P=#c8QVA<t9>_z+!u^P2@ZhmZH={%
zURL3Rb<W=ja4e3?_NJpU!u{0Q7w0Pm$KxJhPAqG2j`u_<9MgDA#si4zll5Nb^~S|H
z4!dU>b<Te<?_Pfs?u7R|f+sNx&tgu~r{ABz!!QQM${ZRCbJqADjs4LHn_y)`mDW_Y
zg>%&tzDowdebwih6UO>pIQ}X;h19+U{d<P<_S<V_z<VacJ{p%1a1ZPQb9P5;4Ey;H
z><9brI2@1dUyms;W{%tOr?>5Q+cj?H&RsB%ZF4wWN5(cRuRL!oC!ieWqj|YC%+sK(
z#6bZH;cv3u=nHeuvAKqBg3q$Q58*L9joC0x0lynB$78&VZ4%yl3lbQO3vnilSugB~
zZLlU%OKZN^FXK88=9bTLu3kk=glg*SgE{Fq`eA?k9jjq!%NpF+0o`#5E`_;dOkPG*
zpRD&fuXjIs6k+$gNS(2E&Tqs$Fc+T1D|i#{V*x(KCrzJze-HnJF_?u1Vg8u+mtiQ(
z2glGEn_wkmDr<3aTkMX*&=2RpdAtEWcP7k-d3YVQNbg(FzmKT1e{aESy~mt!9o&bB
zFz3$4$v6PU+kV>L<1qw|!|~h+$LBa5ujBUlsd2GwzuPC<HGXqoez=}*g5z)uVR_|w
z^X?9qhvuVsX?~igmX%>FJHdV*gF$e;Iwr^F7=wAVzi;3je26;O*MQ$WpBk^1_-+n7
zhUswp=0_YC;dJ!IuGkEzWnI1)N9%`T0(^#J`w9&aKBevj7_TcZ80Le|TMtWHHsD70
zO#3th#wiK&e<7m!WWCoJQ~PBueTGc;)Ny_eoM-dpIn0N7QI8++FZ?@$Upe<ZjFI#4
zI%dPzxxb9VIXDSD&<O=dFXqWM*aIaPfD3UICc||!8?V7RcYNRCCoDmxzWu>@`~4%l
z_H)=r^XdhdCyv?t7=pvG6T0I>oQ<(CH>YD39N!1{5{}#PXKFiWcM<h<aP2*hhcE-L
z!PsV+4`XTG+2#ZcMQ?P*x^O>oE&1J;o`4uGM+Ka3$L1JqcL99ncla5<Ayc1!=e+$k
zri<Yi>+m+*7hGGe&wFq^hQmGYKy<*G2#Wo*f4wmjj>GXdE@P6Z{oveU>TB>IY^NN@
z!ra&#OIx<$#=UVohQU}l9%E!|g7!0gnmaGzKDY*};rwN~*7L^8Iq>r%e2cKSXL^R`
zoC{<1K5W~*PDUK(z<GBsEkr(ovKj|%use+Z>9`oz!nu0__Ui-q{9h2(hvv>N;a+pt
zJ#ap%a1$=Tao8XB)Baw8N$`E<c;18UhpnNow#`#>WC31-<9QQ5BGWzg&wQ#x0x^`J
z2>B>LC%EoUf_)u_+fWJjL!a*$8({mH+R65u>&tQ5|2N>ex))bs2%IzfwjP4gngi$g
zU<||<xOcg4*TKCmtbOBa4n2)Y7>WLH-L}UXXlcpghV9S;1276xFbf|dD%aEdljQnp
z)FaavoY%KdgN0~mzNA0X_<sWTqDL_q;}F9!*azDph|8uN?~Fs?Scl_!Ov7xL8=qrY
z)=_#Nji2lDDcp+TI1!~73i~@5t~b~6$8cQf&uPhb_nR;9Pq;S2;_Mo5E-H~g3?(Q+
zJ_>OFT=!=qj>&ig&a?U9`fW+yvbpv*p6Nbo{~yK;I1fi-S8Rl!tir+8=!%nY5pIV0
z@D_eRRGZHCJor8sk24Xh+x0naX|ZqS*x_(~ufqK>USA@rFOIne55l}m!u#rx>Av4N
z?>ou4_BhiuEj?%Md<NIlBe)HhqYTDn7r2hhkB)HP=!*+*E$p-V;5+yREp5NK>&=Z1
z@Dy&vaGZ!i7zNMSZ~Ol#!g9a4b~4pF4-1f~&T|cL{wk3`3?(SSw%7;mOP&wby?Gk+
z^=FR5p1rK+8+mpu+-E9Kj#6|%0aA<Ko#!K9Und~j9B$y+H{iOh!1*{1dtpnoq^!in
zZD8D-;|t+$k}AB3=GM0JKNt5P4s){_&SO|SU8BE8)Q8;{b>1~)Uu?S)#>Kqt3*X(_
zp)K}?`EfR`#NC*Mx8dFp)yC4+{l;@Yz*D#t!_gP+qxRGOz69U1j$>)t3A^vBh-aEh
zHLwo}#884Fn4j)PWf+CqU|zVE+`pC}tj*<dzLDqG!Zs^Vj#6|%0aA;<`L;(-_`AdY
zPQfgEh^W3==QYn@GA_fZaNq5KHIZ$xAB8vwr@?*w4!B=0Kvdp0QtzJr1k95-lBh;K
z!eW}uZz+HC2Ev|`e%`&(xIBk@;d(JYj>2v*M-Ih681G4V9R8;G8tKnlUf+M?*&pC3
z7^mUzcYwbw+=u4CdgIxWHnWXS)EqX@W(_KlKnx`)g8NWkq^^7C_EW5gb)P<V<57z$
zRG=KC=z;>Im#sLlH;%_JRKRzR@16#vKR@;R7u36_O~X|f0^_g~Hbl0?ez^}FfwOQm
z9>B|p+SlyMBDh!0z%_^?31eQ5)c$63?7Pr5ov#H=>iGN|-@*K8?m3IO#`W<SCSnBo
zqdWG6u|6Ny!G7CUpWobbgZf6U^*v@kzii_1H~1cz^6WRxyI!8ctr(6=a0?!V{mu5>
zXdAZsF%~rO*nBW&enZgLY(BlG29-!4h7!2{xDWZ=eaUtI9Ne#dMmEp(cWVR8lOR@p
znj6N;IrUj#^J=VXQH2VWqZD0Gfb_BfCw4?{oQd(c5A(1PQGGV9&V#?ZZ^Q*S0efRB
zWK&k=qOH*tC&7K_W|)h$_z_`!Fa~vSZ@mj+5JwW`s4)w>H~qZtE5~b_uH)x1tI2FW
zU&Nd68s{ke{`BvzM`LI#&4r;j9K{%j(YOP)@jkN2kDs{C_TRzlaE$g#9=oqNAMe5T
z%@@aI-^}q3@Dy&va0GKbm*Y<mmQ%sl9JlSig_q#(2m3GQz<#`eI+&-yea(HE?=`4I
z0x^`JJNjb;+?UJ=$F~^GJ=1u831d4S&S?;<)Ogun<GBD{Z@+&-@cc%O&50^hpd6*>
zf&!$MH8{~8zE|!0NZbzN?z}|hj_rPg*|-CvFaSNVJzAr=vNjiV#K9N{*Mw`s`Kd!N
zu1udlQ19G63fG`(F^(k6uX<#<Fa4Z3R|jMMIPQmin2br70-x!8zJgD%1nJL7{qDTD
z{;Cl4&Hci;I2YGq23!MQA@$x&$L?Jpz&w5u=AM1Jw~5Eo@i44^9<Dj(@N?LocVXQ`
zTm<((_d;{D0h!tj&Ml$dHR||{(KI;clbU#ZAAH_i*j6@q@AGZD297C#7)o$BhQj^G
zXTJdZ5cDbR(^&Zqb3UKJLvT)mSovwZ9)NX@XEuzju`s9W;hJnjEu6;+l%o_~P=HKj
zb58DoV{jg>!%Wnmx!(X^aZNSs?*tf&Bd{|z!aB{^gnIjS6wXEhL7pw*I4owK{}SnK
z$2pg5I$zIc)crx-LasCR#@4;$YK+E6jKF1ZPA9>9c@4H5+@I<559;eM2d+(@cRKpP
zXWoV<Vct1!nVu1xYoy+_<Qg$H_VF4x)^SZdHvTu@R@@Ee@M%<IKFss!xEAhxu7TMw
zf7}~`_A-4M%h%!fC&9LS#)u{!kH^iJ2FLAM{t=m;mwK*&Ys|GuIR7z}!2QQ{e-o<k
zCcZ=Jz3Ioc_dbl3&zp?v;rs=$@-v8+xqb_bh5dGXv*AAHbL#L4e3mgcM~{U0y&*D{
zd`@=4p(umx-2>y_+<x!_*Sv*CVJt7iiP#rDGaKEwt`9E8L_ChSVIHN&EBL;Ix(_i6
zzCWB#`)-_)s75`4>%%^S{@dmxjDayb4SmrE{c#qIi*1>s@8TzfJ=gQL?_9VKx<+Ft
z!xb>TFW@soJ;OS$aXhZ28*v%V!C(w*;&X?h9GAepUWZAzA2X4Jxp^tBg!$uhzeH3Y
zoCnv2<2LVnwlO*teVUxY=MdPo`Rkb7@3R?S1J~7{5(&gm0{0*Hp}Q~#b@&}&eYNfr
z%)@jTtIJ_b&O{I^KaH3DJr@_j{4plpb0_S}Gk6xk9%5g-_YmxWwUMc`;^em2560(W
zxW_$#cMz4=e^6fs+qECIX&idB&>*fKi@WhWj7wPDJl}vf@GvSc48|yqB&t!5sApLB
z1)O(tYXZ!Z<Ioe`&=uWr0?vbblymhmzCzUVf27{MrV7rJef0T0!})T*{}xft_?~*7
z;d;Lf&U+b3;k+Ky#N*!Zd>?p?{k;s1%Qnpy^WF32ys<Ne-yy0Gi>QAEuIFn}4&%`S
zU7H-p=Mix3U9a{voBXj|=duRIB!L(XZ~C<Fu1(u-Zax=tjpH%i6XDp6gY(%72O~XR
zM{&-voQfg10AmpBMN>Gw8RKv^eAYhL8ml0zY(hmB_<Z+1<8S<4h4GAvx8roY(_uW$
zf_-a=bGhERGN!NL8$`9akotMJ594trj9nZ_RHGhI&-k7Ck1!j?&G;Kv*HTBcMH_TN
zG0c_AaR+8&0enVS8~%p+5KrTFjDYWN=jSoJjYfps@A=R1BBtRg7~4|pgB`G46Z>0)
z-LM}H#jzNGq3}Lq)E~oPzC8)wJHH~T4<A!M2kw{VnsG25ozbRAdp`HX(MZi7=kjYr
zJ->na8aVd}#9-ft!F|Z};hypXqMq|9^>c9#%n8SBe~eX8h+R3qH+rB1uC0M6$4Fd?
zi(u@mb8j{7>mjPFO{H^UoP3^fy9>s#4!(!N#_|(&=7u?P3nnb3+qlm;eiuI@ti4~T
zGY_7Ec{&p2Ng3iuq8jxGdxqz2Bk1={9A5xqW_-8AN>~|f;G9_JHD3EDYT?+U+Hj7a
zhp`-uk(i8Ga4r9iu=|%#_aUCaWH`5{!nrR*KGtZ`nos9=6Ko6jfW6QYy>U2t!8rMx
zDR>rj2y5T-#@hLK9L}w4@g(evwpaz0bzq(q!~7YGyD=9F5!FTm^);wO0x|T#CAb|=
z;{zCvu;&E*e3EN!h4=PF$x=G5>HdCvo(SW25cY=S+!VpsIs9M6ylIQBFkTnoW|%i`
zp}D=`W3G7))0dI){}f?y^ZYk>9W&uO&3Bu7b{XPGq8jyxdd_#$&&PxCIqs{zpLfAV
z2+D>W?2IFD7M$}Lun*rNsttb=z69T+_H8t#!Zr38qV9FA8hiKW8!-&dv+sc|5LQ;D
zA|G2}dlX?OxVBD%du6t{{yo>efroHC&c)H#6&oWc=GHdYALiglOvY?1K-4%JsINgK
z5{ThcT#h?oUVVb7XQa;MbzEydea`YSgl8GMW6=Xe*aT6ffXZE9-q?=`xF6=`mxvnA
z*VMnZ9MtfP=5jPxyXK|);2<1=GMKYT*ynmg_1Sg#DjtAi9fDrygmn>=wK#B3vW>wQ
zkD!gOIBu?u*SKanCg2L(hnLV?Oc!&FYqk;zxRwuxYhwdsQ}VbdAB8AJ8RAI7K757d
z`frSa{tw}}H#)=Trj{-F;{NS^J{%L_`{I2pL0CHt)YYI83B)i6<8UwL;R}S_@A*Y|
z8Ro0cSl*mF*Y`O%8Qswl>msbQreb@zj}5>mOu;OCh^Uw}QvdC8@+;2?i`|dZ)#5P(
zzdsybdahJ+t{!2}@x1k3mqZ+8C`KWSMNn4fpaYDHd(;@*jTf*GQEdeK=1i`;23Nv4
ze+6G7>fU<l&5>yskHI(;J78^OTfFukI1FdvDm;K}`%ulbNyJfxVick^Qj5QV_JHru
z3ve@>r+4rR!p7P_T@5PXI*8#6T#5T(KNlhFe$Tr%y$GMNA{ej9a30P^DVqD8z$O3n
z8^Jy1cnm`Y9)|Dy21JeN&!}@heHo7LYMg~5;T${HaU@ZVdPMc<3+m_L9*o85=!p(k
z13~e(%(gfHr(hKB#2hsDJLCth`6nL2^{~$~@H!SFoBp{+kHbJ5gzc~<vMuX!VQ2Kl
zP+W}}cpZz8O&{*zy0JJNJz*c#Kx*;#-)=Yt=fm8oLM<8*){c2q1J^+UF$~4kn1R=^
z7-9E&-hItytSIK3d&BLx6z0K!XouAhRyLqwNA$*-a6R6Kd1!7gjvDXssQZmRe1zG!
z1HOMxgE>}=GQ^QYHR=)7?&s9MfV(jUr=bVhV>JY2B@VX6e&~lwF$K?}4pD6ce*-<j
zbvM9#sf6?1fT(+o_gvhKF*pr9&>pKH+mg?PMJPcG2~?s64alYsQ@L(52B14K^`U_C
zT~La0RG<pAXhc{$_QAeXB7s;Fk3Cm|287-3dFxlCg*^X7xE8KJ8H!PeJcJeZ9Ao9$
z>yMFeO+JP95cS@U8t?L``;PYA>&?v@;cto)un!zt8RAHy8uf^3*BH&kRE)*|bVob1
zLTYKlm#*l85txKoSb%>=FptcqDpbJVd^0g0jwkBgh1Ac*RE)*|bVob1Lbhc+F5D4^
z<1Ac*nV667u)O+Ez_Yrb6y>Nu6>8Cluy$MrHK;@aF`R{KFcb6f9m4MaGtMufecw^j
z;5%k84naq>MpW6H%01wF`#f9+$K`wX8~hpl&(y}}wCx_@dhxfle;b#;zt4+NhB&OR
zMm;h;Cpfo|`ni~j(HMa4XoprvEp7PH6@4%QlQ0Vl@CW`K;%CmkjYn}Ku7R<fkM9t6
zpXV21E~a8M2B16Ip%t<%>v7?ZI2>o;8qCCee23-LhXS6}1*IrQ1*%YsMufG~KwS+g
zkw6S*;Tp`ue0+zn`~Qsdi)jC4Ov88##v$m4)`%+kRCdClD8o41jpxza-wP{hY`@a>
z`*<3Y;BPK}!<t`(D29EFBZ+F%BdR|Osh^9f7>xnwj&^8;)Y678UC{?4FbT7;0RN6)
z9+^*7sDSxWi5fH@>fVLa&&5=X#sG9jJG4T!Wj!w35haKrflAb%0n4io1w5+@N>Ppq
zRG}7)2y4ea*q2Hq5NqPG=W5V^u>1dv^NVQzWlY0(48|eoh}MWI&egWq4}EYkCgO3p
z*G9!=MUBmWJ2b8j!oTawaV-2dmO>Px3~?k;je11&$M@X}aIYAH)6fI$u^NK15(itu
zc=W@in1W~VF{0Y|iTbzTZ`2!bHD<tf{bEGj`vvv>-Fgqk;&k*x2ds{4%eq|H8ND$S
zS7QcV$6`eF;dAO=z}*;w)6fI$u^Lj#CVbf)&dV^|gvam>enD6}t`+CD5(&gG6jx&g
zUdLjD-T!BtUqt&aV;aU|Fb+XSv_^Af6E5h2qu{>}I?m~M6^jrxhK1C(RCBriDbJjX
zd*I)LgK-!-qY%X?LmWv|qaIQH{DS&<xEH>I2jU=XhcytCRXO-O4uJ2(QMeP&;ZsDl
z@dNe#&G!)e-8=ygz&L(`sC&Pn-f=jdILc6rLS!?CT=rjO9sau$dSM7Ape22HiR<r!
zaUX<(u|3vAYVq#`_c#A-_(I%*C-5Hrg|M+UP*;OWm}fDZiK`Iw^J|X7?*B8+*VBGA
zl8B=W#VAA`nk#E_K}Q(7(=i(6&>Yku>Td@35`XiW|JkVJI`{FgxcEMFk8^Hr#U<#A
z{b8OvCdXEWIFhJFJ;I*pdF#C{i8x%Nhrn^SMo?T^uCbml7GrS_Ucl#wYNLVr8dTyM
z*pBU0qaIQBenb7Mm=4!~YoRyXL-LVraV(DM5Ddn6OvB4qgs47P?{)XXzgf?~VfY8u
zMrvupmwj<EoTJ;|@AD7wJHpyYjZuQ@Vkko#NxX!w5O%-kU9Zb3>iJ*teEV@9uD~E1
zjP0=|nky@FL0cG~6LBGKhJRQ4`^9}Xto_u#b*6G%6!-Y%elt0z=G6?Cljq=Q?1oKI
zh+>o>jwGs4kFY*^{u{i8AYX@aoGD+|;k@~CD9oqvm<IE#xi-G$8vFhLCcw3LH?moa
z-*ep?@ZIKb-1AThe>eF1A*!^daszDK#QoqP48%CNAI!rSh>B5at{eNaa0GUS&ku_4
z@NIDb`r|U(foy&gr?wHSr_;E149p$(<b{ap=a<yKw+x)8sONu9y>n*V#^QAJL<g*n
zY|2JlWZVvidxrUNKg?D8-(36ixaK~Xf1}e}%lAsWhN!XpL46(O;4T<rbD|hKz+5kE
z`d-Fo97$B89#MTv&)0Lg-gUYw3J?^JJs14;HLqr(28$8Z#uwDTh<kAb%(E%TCePfL
z-o+E}@7Igr-ro)8?rKOa&g=Tv67HKj!97Pi;y|2=QMeP&;S)sl|0n8eQH2{Z498(l
z`1>v>YjMyK2V)S%;U3I`xfs<(1NFwzd`KXMez+8qF&hgI^^9O|G*&J3I`=d;kDqdl
z@iGT5hjBa*?a&I@lsqol4m~gcqhKz~g75Gp2peMqb#LGy+<^1pGvsdpf44me^W|rR
zJ?97N-om4}85iLsbj8-NkA)~k8RAHy8ubW!uIGP&?LUrN5Ioy=vd_+k>vbF0p6z;#
z*FJ`K(1@ru%va~(PB;(45sdvkj(<fq_fO?IbF>V-;6B#|n_yFHh4v`IUg!z;!DE_~
z@Yx-GVEk{#({LVtLs%b{G+pxypOY{W{b4S3fblU-o54NjNSuWPro(r$xgPd>&o`h3
zmGHh8PCyWA=f_z8g0Sb9CvV~rI6v8Xh-?1|_tvmy|3TdX%)(@hL|^O&^JFDtTejrF
zy>UE-p#l%XwbFpFKKzTi4-m}5r5vAv!Em2;@0yEG5%vtve+k!y@5Ko))<<9$6d(_U
zC`K9LNTM3`h<dhlb(jP5eKZE*Q0#`z=!7mf4DP#QaTmO&4#qmH4P)>=p2BUo80Bz(
zF^0{}qt7)L-9I0M_g#p-D8@e6y~)0Ox?XzWI1GTXIv=(<6#ZbG^LP{7qiXRJ!p7kF
zg_wu?;BSo~a1Qo>@i9)us3&a0ao&Q*kj?YWqZ(8qff$a)xwsCFeLfZ=te@@)A7U1!
zU=)m182dO8PvBkrg0N>>=QWSRak<V<fa_ulw4`jn#r{_4jWc09jjQoB&S8D<yzluJ
zVSZl;?{{vmhcPmS-y-Z8OQ=hak$K|0ZI9N-Lm|wsGQ^QYHR=)e?BKlDyowoc?k>P7
za6TQg`FSMVlbsuLdL~}OA_ULL^!YvYZ{iVnpJN|_t1u1r(fuORy}`L(sW%4C;%<1a
zYveSXh+~_a#OJ9n#@1hk3AhmzF#hI&@eAG`j@fa1gP^@kpAFRi6IHkwm%#RqLN6F6
z<K<d%4cNzf@jO08re~&}^ZDjNB@&3C1cMPrkZ<Nw>V4_Q#`0xM$F&#+`*eJop?vqb
z_rN}Wf~bA*JL=!SLoj#GgX8Uj0<@&8!Nu)yAk3+exE)X7Jw&bRpdSx&opb8=Mq(14
z#``c|(&G|*Z=lX`q~33A+!wZlB@cxtMj7Hrq8jxGo)z}_GuPOUS-2a{=Lnb=#(fCR
z#>KcA&cSSafT*$Cp7U!ze7BloKFfS|@4N%E@ezJQSpPh4zMIca;4WN)%P}0rRQAv3
zj)!Y^GHlm1@CeLrbIko>5XQl=%*AJjYX5iYT^BFFec(E{ri_bYGET<JJ~&Rt_Bh^z
za~Sn(>%680l}I3l5}0q7ViKN4bNSN9HSgjXOvMBkqoAKY*S%&8ZiTUV1K%R5kIv&u
zaO}Z*p%=%Uk&l*^&ADL@90S*;@tld*;arFHWeIg3ViqRjGC1Ga?l%j$c3#u<-ggEZ
zM-kSCB@cxtMj7Hrq8jxG>s#viuer{Ab<VukSUX17k8@)F-U9pWHRegwxP5jo_Sqay
zfw?{aC%~Ncy<wg^pAAUuPx|p6)PI5bFjpRcIXe+IHL=g0v;Pml>x{u$u)nk5S{w`4
z(<QhKPr@8@UrBE__51hKzk}H@uWZ}67$4(gygcW+b={jApW}C=J}1+$<F7#_5{RJ$
z$D$n9<3adL=PJ`Pf^&<gH>QruzBq5G{k(zi&WAB_jeLTrJ}#mDL(D?zJoeyw2dsgX
zmV9pLghNq=akv}L!~O(g$@FO+*l*|HN>t!sG?z!eaLs#o3eNio^uqyYht*-pLm`S`
z-{MH38uiH3r}T5?tJl`z1(*-Udj_UsCLV+1H9xa??zdcL{ySF3JPaqmJUJ8Y56<^o
z7(@Gz-mlc}K_AWim+>sj8T%!VJ!h<q?FTUSKfoM(4VAbS=Qi=!bFU(sF}a7l17q|!
zjEnIxPR7f)Ii5FR+rJ@o3}MF&Tvr48l0Xb4I1FVl-`or4;3NDCVb5}Hd<pyDd>Nb6
zemWn|z%kdM5n<2re5QFkp7VQSD=bZE#ZB8{KlH)Hm<VI~Hhw}_pT4K=pLhiB$x|>3
zuK6VhyDw7?lyd#<*bG6*<Dd}5F!pgIQH^?pJwMa=@3{U`n6u`j`=NR0x^SEyqXC)j
zO+Dwh>hK)y!4)_Iy>TG=;S$_}D%h6umimmaV`Kdl>hM0yZ+UG0zJPs9%{kvaj_FAR
zd(%LU$KX!Pg6r=WgtZ%-cRpSJ#>2Q6ALHa0Y{R;2ViY{jPp_{*B@&3C1l@2FE`)oM
zYu2{1nb*Z!XFSsT={j?)uDM^4+K=>O_k%hF^BCtin8zJC-T+HmHsQuDI0|ROaZkr9
zh#H@La!;9sDYzfia6IY#PyKEz9LH3Q#ULDle_&k%C69wb6r&7rBvFleq&_qC_>YJ>
z^UAz&PR#QLG$Qr>sN+RkTLbsPn=l-Gus@99kr)c!QNHJ&g>&4JHtfIa*0o}PJ&x+r
zXVm*%xfjOBycmY-F%!<CYcc8>sde_%xELSfWW4N0>NVLO`yAs{i3DOO!A|In!7vA0
z`_I62`vbChetJK>FLkepdWQK^gG}?-j`OQyY0KK&*bxWgbc}}MGZz-%cZBuLwPSv}
zma6b3qT=x*^|g2m?&0R+$>@e{uquL*$3Y>AQHD5@s75`)`V`gQuzRvO@3@@rS-1=1
za3&7NF6e**&<F0jH=q(P;S*##*V*(X^%`^D_sK)B&GX?N<vdP??=EBRb*c9)uj8n-
z)<B!)t#L>oh7uH^8%}`zy%y$>`@#aamn^UTr9a30;T^bsGtJ{BoL`o*GB>xyzBm!)
z!c7R)hwZ2LDfn)kYshP}S$|(~-OG3YSK}-kiCwWVQcE6R3Q>$Q#F0cb>JjuI)93Qe
zokrUG2+p_j?)(pfzghN!dz$mGGkU>%9)(-+2wsKnk>-AfWEx9z=X`&Ch*_8d+Z}*&
zVT|v?b9f)_3C%sPCH1x)73&7-Yfy;<VkkjTlSBBluOo0X9)$DzF@8Zy`jXAHKk-cG
zaV~;+bUmB*&SQJ5iDfMt@c?tdy>=+B!Zf^usNZkC3l`v6yn?7a|BZUbG8=c`a-4>P
zP>8jVTJref`C^nIjwGs4kFfatL0ughBCZL$H`96Nz%jmvnQ-1m!oHgiJHq(+8(|yl
zjZzp#-(i#Beq(&h6Q7r<on<-a92pnq>`M6F?2qB7fWO~gfa@-5e{4w~+#B2@zC+l3
z&Or?-kw6S3D8g3Q1Ma71U^H&S!+06XJ67%`=3g+6zB5L^_3S*_C+Bf_lsq1?9eUtY
zT!zV*1?RwhC@f~?wz*P^s9Z7b|HLD>5f|VD?1MH~38}?C6`~krh$D$=)FZ4vp8o{z
z;+tl!i+YB2?!6yi9^5-8!hOK`HxJB*Hdqywd~A>XaXik(6_^C`#JPMQU&H;Sx%RWE
zcWxHJci;oK3PaEv192(Lof&Xneh<qU7jv@?&Zoy={cNDF29-!4h7uGZAMMc<$HKa?
zxE(>PjJ<!yg*`u;^X{*X*SNc<xF_BM-{XUE1a?Oo1oOz@GM6oR!d^HIz60IY9M>CY
zKv>^hLvN!F_C4&n&#5z?ToYHqIWNIZ*bwO@j}wI`Mj7Hrq8jxGYsd4S!rwUd-Q({O
zb$xo>k6gbHZ($D1Mdx5N>~|@;!hBc@sbwR+`~%%_BF=_+G7&y!Hs+%a&hxKGZ$F#w
zjofD(+;e^2Gq@9D;5s@ON5PzNe{@YffZ1>z1aXO)v-E!0=9h53U%;C%R_WIT-_4sE
zR3d>GN>GG+tdEX30Pa6$!TtxaGWJ1VzvK9K1kY~n(`&uQaheCuVmfYyd*YdJ9`{8%
zq|YO#mZ>;4$Jq;KU_9=_JeXTi{rBDcRm3&sjQhjWm<0FCQ((?@z?w)ed7LOjG0G4}
z64j_jRDV9B{&_qK`|rB2kBjg<e!&v>j_~tmxX)Vu32N~Y9>=|?fH~<L9E1I^J=Q~}
zvI!?U<3N}vu0ij=9#ioMo<j|ci}C#$_RXCA7wnfjw!h}>Vi@N-nA5M|Sv-upaShIg
z>$oe-m7_5jBVqeq_b5{1Vmxj8XV_j47uz*1_RYL}2QT9(RKYme->|u8pw2N?B7qo6
zP=tI~+<$h!0XPoEY7}n3JqY^xCdUil_+2MKoPxgEZ_hQrHSe|F<GS}5j@xINduQMn
zbVJlUQoYn=b?$5j$JHMraXXCNdoZ?PaSQS^to~c>t-*tEPRnsD_QV#*RPs1kh+>o>
zjwGs4kFd5p{~4agUGSdA@EpuP_dD~#JpQ2R)9;?Q-s`;nemMTCa1jQ<-0X%zY>2S3
z5)~WcA8_q?pYMzda0PCH^J_ee?_9hJ`|vi5chEnN?Vq{vI$pvYxYm8&-H8gs;qy<$
zAuwmRgKO$YoQ?}|C2qwum}idHHSz|6w$tNc-|XWPn2yP)LM<8*HW%i$^InMrVkkio
z@)48*4t9XCDuuB&=Js_WoWm+Si)zeAEsRajSC2hso!88U_uL1cF&>WJc{mDPu{}1x
ziYlA&;5~2*&ck(>3Fq+}gvISg>i!i`|0#9Ohx^SH7>vWv8S5ca$>U@picy9*lBh;K
z!usO*g|NM;n1Ea0+Ij#F!S(Va%w<3Q{xGcf9<RR|m*Q;nLvQR2b2QsI*s$sPz4&yz
zC*w>EhjF+bu36Vs&^L4Z2?YJ~*#13&N*DvzkbO*GG%my$@cD<L3$}te+a7zu_WK})
zk+=#s!?@fJ<6_%EyMDT6jf-o@KHi3FPyutb7L5p-iw5dyP>BR$C_xeOky?zE`E87i
zbzgY>2)M3p!X0oQa38XLV-w7w$M)Ykukl*%@m`<dvmAdfI3FFbK2~H|mxp(Pb5e$J
zFpkgT6NJSr>UXX2eg}^CR$PL<*dKq#YRFXbI9Z5d*q1nxs75`)`r`S8m<!j2`DXr(
zfosbgHqH}afBf{j=UqcycQMYw0F<H!cEvU@MlC5`zcqG(V?G?tt9wd0Mq(`NoBP*|
zxCQC`yMc2FjK}4;2xr6n_C)lC&$pd6SQD1D(H1-7KpcfrV15}F<Kx=0?ew^~-h#N;
zN9WEySD*^DXhhgtG*DNAN+b|N35t-9^kS@x@h%AZ+Mna0xDbxp^>HnNI0bWP%sgkE
zF&YK$@m`<dxP7K^a6Z<-iY~2aU|Z}5=iIz<UfrkO#!m=~UD)|W-191Cz`gAp9F5(u
zDZ)w~6@@598RAHy8ubWk&+`j07gI4B18_Qw?YX!B=A-%Kr{6tqz1O+VABmpW6CJS`
z*1*yf_lyFxhq+>W55qC&2iHW<xAQqR5A0jezhNAo2iN#uIGz(>AB(XsTu1G&F>Eij
z_<a+&|L=|-I07f(Gz@{`x1IF3*sguEk9|;%3RIyMjR>2I2I^{1i3DOOK@swisTgDP
z!oHd#-QgbOcpdkdFo#m(WS@<h=d3#er{V;7ug~yV+rc=jjz6o|UKbpNvys4byn^QP
zI6ba^a8DiP;4X}T^I{I{fT%qpkNU!<Ys>hIBZ+F%BfYKE?+dA)i>Vlm0XPV~;aWZp
z#@adZ)9;>lt`9~x?21BciFL6&itmh#@pp8_9&l~hrhPN!$KrU{x1fKXD}}jnC|nP&
zA^YfBZ;Or4T%N4WHJih{a$R?Ydq!&8QE{;k<)}avYSD<)*ry&hP*;OWBoIRhija?}
zvKE#0wF7p>K5*Q<;68E;f;ib{k3DCddzIIEkM}y>&EPZt>|)HFBj@;Zn2&ejSuDWs
zNR3(4@ef@479PdTxCkeqE4Ice2rGG1n9s#1LmWv|qaIQ1E~I`gro#RYKzBHg=Ae1J
z7xr%Y^t<P+FNA$_Us+M{UyWz42j_Sj*rsip<GW)|*tgXFb>aJt*a7X)1_f}wqT)#P
z|0=CH<GOAObIr9Kv>g@~+b=~qDo}-5G$L#+8mOy5B@&3C1VzY4HYJaX+$$WfYpWB2
zz6No!&mQjv*N@kD?N;z!pYeZHR;J;$aQ}0Eybw3R_`Qkm5f;Dn^IvjpHSWg*7*Bs^
z7>@!(6=P6{Vw53{B&t!5^tMvJFQk4hreZV(pgY>Z_-=~Lu|?CT-#zafn`_44&nm8k
zJlOVza2;<3`<B{2<F!6qKdWPTl$Cgh?@Zeci;L~53rbOr3RIyMjYy4s>Tv^gHK;@a
zF_fSP`DkfbgB#XCrZ^chV`tsE@Y?^BVr*UK{=OKBt1t~O;R~e3EbMp**L{dtn1WF-
zuY1Bh(Hx2@))%4}Wr!n*YSbgFUC%GXTujAi3_y3ZLo4J;%OX&~<y}yUa#WxSwP-}x
zTr^NugGwY2LkWtIkH1REW1!}|zd`-G?lMfqGxz}iLRbug^9@|{1|Ej-KOe`zck`BL
zuGoh{6r&7rBvFle1np${TuA*~OvPvnKzFo5E96ScB2d8PT~La0RG<pAXhfzt@SHhN
zgGwY2LkWtIkH1ne=gocBfNS9fJcRjJjIbC6=NEF#JlqS{!WrlVW9jdf=1LwH6rvbq
zh$D$=)FWso)2D6E#Z-*O0CYz?v_h`5ECK~w-UX#7M+K@-i$-Lc1J5;}29-!4h7uGZ
zAAhA{&O2_`fNQ~gc5S?Xg$RqG=YPh#coMf^1p46snA6$({?FsOLKLG6aU@ZVdPKEv
z|K?&UMq>cFqa9iyS6UW<0xs`@Qk0_tRj5TH!seoZx*Aj>ff!0qgnay!iaBroxdvPd
zt_j!1Q+N-*AS{kwQ}-GwaV^e8DRzf{H)d1vxTp}tC_@}cRHGhYZF_zp=3**FV*t9N
z9a<q*S{8u<F7E>8upAYrLM<8*HWv-l)xbPRAchhYAs>IWV(z;JO5vJtZOnvgWg)%{
z@e${r!&HpLARK~!z<+zmrsQ!^A&OCkIFhJFJ;LTNx1I>jaxMituM5nBa#WxSwP-}x
zTr^NugGwY2LkWtIkH1<m_gw?71=oaY;|@HId3Z5|YsqzY6Ncktbi+1S71@+LE-FMZ
z$`D5q)u>0<9Ol*&!CB6wfai5VDauiSD%7G8VRO+yT@5OcKnx`)LO%X##oTudbj1lc
z4_D%L+ynof%Eb4QYw2<fhX3xq3pPf!C65aWQH(Ogkwi7>5jKap^+a%%b1C3?T~La0
zRG<pAXhhgtG*DNAN+b|N35t-9zhc>tL3hSM=!3H{627a(g&4zm-%GBgW6%}t;Qw}*
zZSmUeVY>riTdraMJ>+97is0|fIk*#}a4HVO-?1ukrDYNDe~)xOJPPOHdIbO0`xVDw
zbMZNKFXI7Bz!3C;`IPPNelGq0s;tatHpforfl~B`IUeRT>imu8d&#xrx>z4ADdzpQ
z*dP9T$R(JFhv9Ec=PArw>ioTVBQC^=*cWY(D=m+J?-JL5Yr%i(y#oFQ@!zKWy%07J
zFH!dxCgXCL7YD(7$irW?nA@A8Blf@nFfL(wQr8W;!1q#1*Aln<SFz3Aa3tK@d?&i5
z?!~kSzQ=Bcb2u2i;s4*meKuEG9)Z=l#d&mZbDtcBt1$&hgw2I@w_`lc!Ex9d?rSUI
zuU>pd`>y&swu{h#x~<{gOKW0j%Uay%vz*7{F%%=<{^%Tq8Asj4a4+?J>buE4uYp`y
zx(F0-+m1K{{ZS70tFSrnd>og-zY$!A{=V4(>mgVECjzT-Xl{maKU?{KE?=f2-zm<4
zYw9RCmxC}kg7tlI1cKk2xj7^l%TQWz?^f6q2gChs0HWrhjQUgH-_Wil*Q38Va^?Rv
z0<Nj;usi&%S&Ty>INz?nE?Ab|o7|o&DG_l0+yb58?>5&+)I2y(-LWS+!nL#ta^?R%
z0{-^f4E}B_g!2<-d+N4@^OuKQS$+}lcZYuu`!|rk#lz;n^UhOyxCZ@OAy@wMBH-^1
z*GTIK*87_@S5|BU{9PY457w==V!M!gdM*OF2;?G=i$E>{xd`MUkc&Vr0=Wp}B9Mzf
zE&{m-<RXxZKrRBg2;?G=i$E>{xd`MUkc&Vr0=Wp}B9MzfE&{m-<RXxZKrRBg2;?G=
Pi$E>{xd{CK7J>f<{G2Sw

literal 0
HcmV?d00001

diff --git a/Engine/lib/sdl/test/testhaptic.c b/Engine/lib/sdl/test/testhaptic.c
index 9613629e2..9b73ce293 100644
--- a/Engine/lib/sdl/test/testhaptic.c
+++ b/Engine/lib/sdl/test/testhaptic.c
@@ -14,10 +14,6 @@ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 /*
  * includes
  */
-#include <stdlib.h>
-#include <string.h>             /* strstr */
-#include <ctype.h>              /* isdigit */
-
 #include "SDL.h"
 
 #ifndef SDL_HAPTIC_DISABLED
@@ -29,7 +25,7 @@ static SDL_Haptic *haptic;
  * prototypes
  */
 static void abort_execution(void);
-static void HapticPrintSupported(SDL_Haptic * haptic);
+static void HapticPrintSupported(SDL_Haptic *);
 
 
 /**
@@ -55,7 +51,7 @@ main(int argc, char **argv)
     index = -1;
     if (argc > 1) {
         name = argv[1];
-        if ((strcmp(name, "--help") == 0) || (strcmp(name, "-h") == 0)) {
+        if ((SDL_strcmp(name, "--help") == 0) || (SDL_strcmp(name, "-h") == 0)) {
             SDL_Log("USAGE: %s [device]\n"
                    "If device is a two-digit number it'll use it as an index, otherwise\n"
                    "it'll use it as if it were part of the device's name.\n",
@@ -63,9 +59,9 @@ main(int argc, char **argv)
             return 0;
         }
 
-        i = strlen(name);
-        if ((i < 3) && isdigit(name[0]) && ((i == 1) || isdigit(name[1]))) {
-            index = atoi(name);
+        i = SDL_strlen(name);
+        if ((i < 3) && SDL_isdigit(name[0]) && ((i == 1) || SDL_isdigit(name[1]))) {
+            index = SDL_atoi(name);
             name = NULL;
         }
     }
@@ -82,7 +78,7 @@ main(int argc, char **argv)
         /* Try to find matching device */
         else {
             for (i = 0; i < SDL_NumHaptics(); i++) {
-                if (strstr(SDL_HapticName(i), name) != NULL)
+                if (SDL_strstr(SDL_HapticName(i), name) != NULL)
                     break;
             }
 
@@ -110,7 +106,7 @@ main(int argc, char **argv)
     SDL_ClearError();
 
     /* Create effects. */
-    memset(&efx, 0, sizeof(efx));
+    SDL_memset(&efx, 0, sizeof(efx));
     nefx = 0;
     supported = SDL_HapticQuery(haptic);
 
@@ -314,13 +310,13 @@ abort_execution(void)
  * Displays information about the haptic device.
  */
 static void
-HapticPrintSupported(SDL_Haptic * haptic)
+HapticPrintSupported(SDL_Haptic * ptr)
 {
     unsigned int supported;
 
-    supported = SDL_HapticQuery(haptic);
+    supported = SDL_HapticQuery(ptr);
     SDL_Log("   Supported effects [%d effects, %d playing]:\n",
-           SDL_HapticNumEffects(haptic), SDL_HapticNumEffectsPlaying(haptic));
+           SDL_HapticNumEffects(ptr), SDL_HapticNumEffectsPlaying(ptr));
     if (supported & SDL_HAPTIC_CONSTANT)
         SDL_Log("      constant\n");
     if (supported & SDL_HAPTIC_SINE)
diff --git a/Engine/lib/sdl/test/testhotplug.c b/Engine/lib/sdl/test/testhotplug.c
index 014c08fb3..465fb5680 100644
--- a/Engine/lib/sdl/test/testhotplug.c
+++ b/Engine/lib/sdl/test/testhotplug.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/testiconv.c b/Engine/lib/sdl/test/testiconv.c
index 41666f36e..bf9ad3b92 100644
--- a/Engine/lib/sdl/test/testiconv.c
+++ b/Engine/lib/sdl/test/testiconv.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -42,6 +42,8 @@ main(int argc, char *argv[])
         "UCS4",
         "UCS-4",
     };
+
+    const char * fname;
     char buffer[BUFSIZ];
     char *ucs4;
     char *test[2];
@@ -52,12 +54,10 @@ main(int argc, char *argv[])
     /* Enable standard application logging */
     SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
 
-    if (!argv[1]) {
-        argv[1] = "utf8.txt";
-    }
-    file = fopen(argv[1], "rb");
+    fname = (argc < 2) ? "utf8.txt" : argv[1];
+    file = fopen(fname, "rb");
     if (!file) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Unable to open %s\n", argv[1]);
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Unable to open %s\n", fname);
         return (1);
     }
 
diff --git a/Engine/lib/sdl/test/testime.c b/Engine/lib/sdl/test/testime.c
index 1a6ecde36..5541d484f 100644
--- a/Engine/lib/sdl/test/testime.c
+++ b/Engine/lib/sdl/test/testime.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -35,7 +35,7 @@
 #define DEFAULT_FONT "NoDefaultFont.ttf"
 #endif
 #else
-#define DEFAULT_FONT "unifont-9.0.02.hex"
+#define DEFAULT_FONT "unifont-13.0.06.hex"
 #endif
 #define MAX_TEXT_LENGTH 256
 
@@ -648,12 +648,12 @@ int main(int argc, char *argv[])
     }
     for (argc--, argv++; argc > 0; argc--, argv++)
     {
-        if (strcmp(argv[0], "--help") == 0) {
+        if (SDL_strcmp(argv[0], "--help") == 0) {
             usage();
             return 0;
         }
 
-        else if (strcmp(argv[0], "--font") == 0)
+        else if (SDL_strcmp(argv[0], "--font") == 0)
         {
             argc--;
             argv++;
diff --git a/Engine/lib/sdl/test/testintersections.c b/Engine/lib/sdl/test/testintersections.c
index 7e06c9ab8..ff629f526 100644
--- a/Engine/lib/sdl/test/testintersections.c
+++ b/Engine/lib/sdl/test/testintersections.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/testjoystick.c b/Engine/lib/sdl/test/testjoystick.c
index f838af740..db9a3a156 100644
--- a/Engine/lib/sdl/test/testjoystick.c
+++ b/Engine/lib/sdl/test/testjoystick.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -38,14 +38,14 @@ static SDL_Joystick *joystick = NULL;
 static SDL_bool done = SDL_FALSE;
 
 static void
-PrintJoystick(SDL_Joystick *joystick)
+PrintJoystick(SDL_Joystick *joy)
 {
     const char *type;
     char guid[64];
 
-    SDL_assert(SDL_JoystickFromInstanceID(SDL_JoystickInstanceID(joystick)) == joystick);
-    SDL_JoystickGetGUIDString(SDL_JoystickGetGUID(joystick), guid, sizeof (guid));
-    switch (SDL_JoystickGetType(joystick)) {
+    SDL_assert(SDL_JoystickFromInstanceID(SDL_JoystickInstanceID(joy)) == joy);
+    SDL_JoystickGetGUIDString(SDL_JoystickGetGUID(joy), guid, sizeof (guid));
+    switch (SDL_JoystickGetType(joy)) {
     case SDL_JOYSTICK_TYPE_GAMECONTROLLER:
         type = "Game Controller";
         break;
@@ -78,21 +78,28 @@ PrintJoystick(SDL_Joystick *joystick)
         break;
     }
     SDL_Log("Joystick\n");
-    SDL_Log("       name: %s\n", SDL_JoystickName(joystick));
-    SDL_Log("       type: %s\n", type);
-    SDL_Log("       axes: %d\n", SDL_JoystickNumAxes(joystick));
-    SDL_Log("      balls: %d\n", SDL_JoystickNumBalls(joystick));
-    SDL_Log("       hats: %d\n", SDL_JoystickNumHats(joystick));
-    SDL_Log("    buttons: %d\n", SDL_JoystickNumButtons(joystick));
-    SDL_Log("instance id: %d\n", SDL_JoystickInstanceID(joystick));
-    SDL_Log("       guid: %s\n", guid);
-    SDL_Log("    VID/PID: 0x%.4x/0x%.4x\n", SDL_JoystickGetVendor(joystick), SDL_JoystickGetProduct(joystick));
+    SDL_Log("          name: %s\n", SDL_JoystickName(joy));
+    SDL_Log("          type: %s\n", type);
+    SDL_Log("           LED: %s\n", SDL_JoystickHasLED(joy) ? "yes" : "no");
+    SDL_Log("        rumble: %s\n", SDL_JoystickHasRumble(joy) ? "yes" : "no");
+    SDL_Log("trigger rumble: %s\n", SDL_JoystickHasRumbleTriggers(joy) ? "yes" : "no");
+    SDL_Log("          axes: %d\n", SDL_JoystickNumAxes(joy));
+    SDL_Log("         balls: %d\n", SDL_JoystickNumBalls(joy));
+    SDL_Log("          hats: %d\n", SDL_JoystickNumHats(joy));
+    SDL_Log("       buttons: %d\n", SDL_JoystickNumButtons(joy));
+    SDL_Log("   instance id: %d\n", SDL_JoystickInstanceID(joy));
+    SDL_Log("          guid: %s\n", guid);
+    SDL_Log("       VID/PID: 0x%.4x/0x%.4x\n", SDL_JoystickGetVendor(joy), SDL_JoystickGetProduct(joy));
 }
 
 static void
 DrawRect(SDL_Renderer *r, const int x, const int y, const int w, const int h)
 {
-    const SDL_Rect area = { x, y, w, h };
+    SDL_Rect area;
+    area.x = x;
+    area.y = y;
+    area.w = w;
+    area.h = h;
     SDL_RenderFillRect(r, &area);
 }
 
@@ -179,7 +186,7 @@ loop(void *arg)
                 (event.key.keysym.sym != SDLK_AC_BACK)) {
                 break;
             }
-            /* Fall through to signal quit */
+            SDL_FALLTHROUGH;
         case SDL_FINGERDOWN:
         case SDL_MOUSEBUTTONDOWN:
         case SDL_QUIT:
diff --git a/Engine/lib/sdl/test/testkeys.c b/Engine/lib/sdl/test/testkeys.c
index 9d6b109a3..7561eb041 100644
--- a/Engine/lib/sdl/test/testkeys.c
+++ b/Engine/lib/sdl/test/testkeys.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/testloadso.c b/Engine/lib/sdl/test/testloadso.c
index 2a3579031..830352558 100644
--- a/Engine/lib/sdl/test/testloadso.c
+++ b/Engine/lib/sdl/test/testloadso.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -44,7 +44,7 @@ main(int argc, char *argv[])
         return 2;
     }
 
-    if (strcmp(argv[1], "--hello") == 0) {
+    if (SDL_strcmp(argv[1], "--hello") == 0) {
         hello = 1;
         libname = argv[2];
         symname = "puts";
diff --git a/Engine/lib/sdl/test/testlocale.c b/Engine/lib/sdl/test/testlocale.c
index 762e9c1bc..3a4a6f041 100644
--- a/Engine/lib/sdl/test/testlocale.c
+++ b/Engine/lib/sdl/test/testlocale.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/testlock.c b/Engine/lib/sdl/test/testlock.c
index 2d35f7231..121059608 100644
--- a/Engine/lib/sdl/test/testlock.c
+++ b/Engine/lib/sdl/test/testlock.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/testmessage.c b/Engine/lib/sdl/test/testmessage.c
index 295b24b70..5dd0155f7 100644
--- a/Engine/lib/sdl/test/testmessage.c
+++ b/Engine/lib/sdl/test/testmessage.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -61,9 +61,9 @@ button_messagebox(void *eventNumber)
     if (success == -1) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error Presenting MessageBox: %s\n", SDL_GetError());
         if (eventNumber) {
-            SDL_UserEvent event;
+            SDL_Event event;
             event.type = (intptr_t)eventNumber;
-            SDL_PushEvent((SDL_Event*)&event);
+            SDL_PushEvent(&event);
             return 1;
         } else {
             quit(2);
@@ -72,9 +72,9 @@ button_messagebox(void *eventNumber)
     SDL_Log("Pressed button: %d, %s\n", button, button == -1 ? "[closed]" : button == 1 ? "Cancel" : "OK");
 
     if (eventNumber) {
-        SDL_UserEvent event;
+        SDL_Event event;
         event.type = (intptr_t)eventNumber;
-        SDL_PushEvent((SDL_Event*)&event);
+        SDL_PushEvent(&event);
     }
 
     return 0;
@@ -189,9 +189,15 @@ main(int argc, char *argv[])
         SDL_Event event;
         SDL_Window *window = SDL_CreateWindow("Test", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 640, 480, 0);
 
+        /* On wayland, no window will actually show until something has
+           actually been displayed.
+        */
+        SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, 0);
+        SDL_RenderPresent(renderer);
+
         success = SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR,
                     "Simple MessageBox",
-                    "This is a simple error MessageBox with a parent window",
+                    "This is a simple error MessageBox with a parent window. Press a key or close the window after dismissing this messagebox.",
                     window);
         if (success == -1) {
             SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error Presenting MessageBox: %s\n", SDL_GetError());
diff --git a/Engine/lib/sdl/test/testmouse.c b/Engine/lib/sdl/test/testmouse.c
new file mode 100644
index 000000000..c73adca51
--- /dev/null
+++ b/Engine/lib/sdl/test/testmouse.c
@@ -0,0 +1,197 @@
+/*
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely.
+*/
+
+#include "SDL.h"
+
+#ifdef __EMSCRIPTEN__
+#include <emscripten/emscripten.h>
+#endif
+
+#include <stdlib.h> /* exit() */
+
+#ifdef __IPHONEOS__
+#define SCREEN_WIDTH    320
+#define SCREEN_HEIGHT   480
+#else
+#define SCREEN_WIDTH    640
+#define SCREEN_HEIGHT   480
+#endif
+
+static SDL_Window *window;
+
+typedef struct _Line {
+    struct _Line *next;
+
+    int x1, y1, x2, y2;
+    Uint8 r, g, b;
+} Line;
+
+static Line *active = NULL;
+static Line *lines = NULL;
+static int buttons = 0;
+
+static SDL_bool done = SDL_FALSE;
+
+void
+DrawLine(SDL_Renderer * renderer, Line * line)
+{
+    SDL_SetRenderDrawColor(renderer, line->r, line->g, line->b, 255);
+    SDL_RenderDrawLine(renderer, line->x1, line->y1, line->x2, line->y2);
+}
+
+void
+DrawLines(SDL_Renderer * renderer)
+{
+    Line *next = lines;
+    while (next != NULL) {
+        DrawLine(renderer, next);
+        next = next->next;
+    }
+}
+
+void
+AppendLine(Line *line)
+{
+    if (lines) {
+        Line *next = lines;
+        while (next->next != NULL) {
+            next = next->next;
+        }
+        next->next = line;
+    } else {
+        lines = line;
+    }
+}
+
+void
+loop(void *arg)
+{
+    SDL_Renderer *renderer = (SDL_Renderer *)arg;
+    SDL_Event event;
+
+    /* Check for events */
+    while (SDL_PollEvent(&event)) {
+        switch (event.type) {
+        case SDL_MOUSEMOTION:
+            if (!active)
+                break;
+
+            active->x2 = event.motion.x;
+            active->y2 = event.motion.y;
+            break;
+
+        case SDL_MOUSEBUTTONDOWN:
+            if (!active) {
+                active = SDL_calloc(1, sizeof(*active));
+                active->x1 = active->x2 = event.button.x;
+                active->y1 = active->y2 = event.button.y;
+            }
+
+            switch (event.button.button) {
+            case SDL_BUTTON_LEFT:   active->r = 255; buttons |= SDL_BUTTON_LMASK; break;
+            case SDL_BUTTON_MIDDLE: active->g = 255; buttons |= SDL_BUTTON_MMASK; break;
+            case SDL_BUTTON_RIGHT:  active->b = 255; buttons |= SDL_BUTTON_RMASK; break;
+            case SDL_BUTTON_X1:     active->r = 255; active->b = 255; buttons |= SDL_BUTTON_X1MASK; break;
+            case SDL_BUTTON_X2:     active->g = 255; active->b = 255; buttons |= SDL_BUTTON_X2MASK; break;
+            }
+            break;
+        case SDL_MOUSEBUTTONUP:
+            if (!active)
+                break;
+
+            switch (event.button.button) {
+            case SDL_BUTTON_LEFT:   buttons &= ~SDL_BUTTON_LMASK; break;
+            case SDL_BUTTON_MIDDLE: buttons &= ~SDL_BUTTON_MMASK; break;
+            case SDL_BUTTON_RIGHT:  buttons &= ~SDL_BUTTON_RMASK; break;
+            case SDL_BUTTON_X1:     buttons &= ~SDL_BUTTON_X1MASK; break;
+            case SDL_BUTTON_X2:     buttons &= ~SDL_BUTTON_X2MASK; break;
+            }
+
+            if (buttons == 0) {
+                AppendLine(active);
+                active = NULL;
+            }
+            break;
+
+        case SDL_QUIT:
+            done = SDL_TRUE;
+            break;
+
+        default:
+            break;
+        }
+    }
+
+    SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
+    SDL_RenderClear(renderer);
+
+    DrawLines(renderer);
+    if (active)
+        DrawLine(renderer, active);
+
+    SDL_RenderPresent(renderer);
+
+#ifdef __EMSCRIPTEN__
+    if (done) {
+        emscripten_cancel_main_loop();
+    }
+#endif
+}
+
+int
+main(int argc, char *argv[])
+{
+    SDL_Renderer *renderer;
+
+    /* Enable standard application logging */
+    SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
+
+    /* Initialize SDL (Note: video is required to start event loop) */
+    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't initialize SDL: %s\n", SDL_GetError());
+        exit(1);
+    }
+
+    /* Create a window to display joystick axis position */
+    window = SDL_CreateWindow("Mouse Test", SDL_WINDOWPOS_CENTERED,
+                              SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH,
+                              SCREEN_HEIGHT, 0);
+    if (window == NULL) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create window: %s\n", SDL_GetError());
+        return SDL_FALSE;
+    }
+
+    renderer = SDL_CreateRenderer(window, -1, 0);
+    if (renderer == NULL) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create renderer: %s\n", SDL_GetError());
+        SDL_DestroyWindow(window);
+        return SDL_FALSE;
+    }
+
+    /* Main render loop */
+#ifdef __EMSCRIPTEN__
+    emscripten_set_main_loop_arg(loop, renderer, 0, 1);
+#else
+    while (!done) {
+        loop(renderer);
+    }
+#endif
+
+    SDL_DestroyRenderer(renderer);
+    SDL_DestroyWindow(window);
+
+    SDL_Quit();
+
+    return 0;
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/test/testmultiaudio.c b/Engine/lib/sdl/test/testmultiaudio.c
index faf3d9da9..51a7ff03c 100644
--- a/Engine/lib/sdl/test/testmultiaudio.c
+++ b/Engine/lib/sdl/test/testmultiaudio.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -33,20 +33,20 @@ callback_data cbd[64];
 void SDLCALL
 play_through_once(void *arg, Uint8 * stream, int len)
 {
-    callback_data *cbd = (callback_data *) arg;
-    Uint8 *waveptr = sound + cbd->soundpos;
-    int waveleft = soundlen - cbd->soundpos;
+    callback_data *cbdata = (callback_data *) arg;
+    Uint8 *waveptr = sound + cbdata->soundpos;
+    int waveleft = soundlen - cbdata->soundpos;
     int cpy = len;
     if (cpy > waveleft)
         cpy = waveleft;
 
     SDL_memcpy(stream, waveptr, cpy);
     len -= cpy;
-    cbd->soundpos += cpy;
+    cbdata->soundpos += cpy;
     if (len > 0) {
         stream += cpy;
         SDL_memset(stream, spec.silence, len);
-        SDL_AtomicSet(&cbd->done, 1);
+        SDL_AtomicSet(&cbdata->done, 1);
     }
 }
 
@@ -180,13 +180,11 @@ main(int argc, char **argv)
     if (devcount < 1) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Don't see any specific audio devices!\n");
     } else {
-        if (argv[1] == NULL) {
-            argv[1] = "sample.wav";
-        }
+        const char *file = (argc < 2) ? "sample.wav" : argv[1];
 
         /* Load the wave file into memory */
-        if (SDL_LoadWAV(argv[1], &spec, &sound, &soundlen) == NULL) {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't load %s: %s\n", argv[1],
+        if (SDL_LoadWAV(file, &spec, &sound, &soundlen) == NULL) {
+            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't load %s: %s\n", file,
                     SDL_GetError());
         } else {
             test_multi_audio(devcount);
diff --git a/Engine/lib/sdl/test/testnative.c b/Engine/lib/sdl/test/testnative.c
index 675c8f41e..48f6f0ea5 100644
--- a/Engine/lib/sdl/test/testnative.c
+++ b/Engine/lib/sdl/test/testnative.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -53,7 +53,7 @@ quit(int rc)
 }
 
 SDL_Texture *
-LoadSprite(SDL_Renderer *renderer, char *file)
+LoadSprite(SDL_Renderer *renderer, const char *file)
 {
     SDL_Surface *temp;
     SDL_Texture *sprite;
diff --git a/Engine/lib/sdl/test/testnative.h b/Engine/lib/sdl/test/testnative.h
index d7b40fb3d..694f46ec8 100644
--- a/Engine/lib/sdl/test/testnative.h
+++ b/Engine/lib/sdl/test/testnative.h
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/testnativeos2.c b/Engine/lib/sdl/test/testnativeos2.c
index c84b17572..6998fa614 100644
--- a/Engine/lib/sdl/test/testnativeos2.c
+++ b/Engine/lib/sdl/test/testnativeos2.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -14,46 +14,44 @@
 
 #ifdef TEST_NATIVE_OS2
 
-#define WIN_CLIENT_CLASS         "SDL Test"
+#define WIN_CLIENT_CLASS    "SDL Test"
 
 static void *CreateWindowNative(int w, int h);
 static void DestroyWindowNative(void *window);
 
 NativeWindowFactory OS2WindowFactory = {
-  "DIVE",
-  CreateWindowNative,
-  DestroyWindowNative
+    "DIVE",
+    CreateWindowNative,
+    DestroyWindowNative
 };
 
 static void *CreateWindowNative(int w, int h)
 {
-  HWND     hwnd;
-  HWND     hwndFrame;
-  ULONG    ulFrameFlags = FCF_TASKLIST | FCF_DLGBORDER | FCF_TITLEBAR |
-                          FCF_SYSMENU | FCF_SHELLPOSITION |
-                          FCF_SIZEBORDER | FCF_MINBUTTON | FCF_MAXBUTTON;
+    HWND    hwnd, hwndFrame;
+    ULONG   ulFrameFlags = FCF_TASKLIST | FCF_DLGBORDER | FCF_TITLEBAR |
+                           FCF_SYSMENU  | FCF_SHELLPOSITION |
+                           FCF_SIZEBORDER | FCF_MINBUTTON | FCF_MAXBUTTON;
 
-  WinRegisterClass( 0, WIN_CLIENT_CLASS, WinDefWindowProc,
-                    CS_SIZEREDRAW | CS_MOVENOTIFY,
-                    sizeof(ULONG) );        // We should have minimum 4 bytes.
+    WinRegisterClass(0, WIN_CLIENT_CLASS, WinDefWindowProc,
+                     CS_SIZEREDRAW | CS_MOVENOTIFY,
+                     sizeof(ULONG)); /* We should have minimum 4 bytes. */
 
-  hwndFrame = WinCreateStdWindow( HWND_DESKTOP, 0, &ulFrameFlags,
-                              WIN_CLIENT_CLASS, "SDL Test", 0, 0, 1, &hwnd );
-  if ( hwndFrame == NULLHANDLE )
-  {
-    return 0;
-  }
+    hwndFrame = WinCreateStdWindow(HWND_DESKTOP, 0, &ulFrameFlags,
+                                   WIN_CLIENT_CLASS, "SDL Test", 0, 0, 1, &hwnd);
+    if (hwndFrame == NULLHANDLE) {
+        return NULL;
+    }
 
-  WinSetWindowPos( hwndFrame, HWND_TOP, 0, 0, w, h,
-                   SWP_ZORDER | SWP_ACTIVATE | SWP_SIZE | SWP_SHOW );
+    WinSetWindowPos(hwndFrame, HWND_TOP, 0, 0, w, h,
+                    SWP_ZORDER | SWP_ACTIVATE | SWP_SIZE | SWP_SHOW);
 
-  return (void *)hwndFrame; // We may returns client or frame window handle
-                            // for SDL_CreateWindowFrom().
+    return (void *)hwndFrame;   /* We may return client or frame window
+                                   handle for SDL_CreateWindowFrom(). */
 }
 
 static void DestroyWindowNative(void *window)
 {
-  WinDestroyWindow( (HWND)window );
+    WinDestroyWindow((HWND) window);
 }
 
 #endif /* TEST_NATIVE_OS2 */
diff --git a/Engine/lib/sdl/test/testnativew32.c b/Engine/lib/sdl/test/testnativew32.c
index 62627c851..a9bf2c779 100644
--- a/Engine/lib/sdl/test/testnativew32.c
+++ b/Engine/lib/sdl/test/testnativew32.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/testnativex11.c b/Engine/lib/sdl/test/testnativex11.c
index 2a38de2a9..f6bd0c0e4 100644
--- a/Engine/lib/sdl/test/testnativex11.c
+++ b/Engine/lib/sdl/test/testnativex11.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/testoffscreen.c b/Engine/lib/sdl/test/testoffscreen.c
index bebbe011e..3738e9603 100644
--- a/Engine/lib/sdl/test/testoffscreen.c
+++ b/Engine/lib/sdl/test/testoffscreen.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/testoverlay2.c b/Engine/lib/sdl/test/testoverlay2.c
index ac90ba8a4..8bb59a9fa 100644
--- a/Engine/lib/sdl/test/testoverlay2.c
+++ b/Engine/lib/sdl/test/testoverlay2.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -144,7 +144,6 @@ SDL_Texture *MooseTexture;
 SDL_Rect displayrect;
 int window_w;
 int window_h;
-SDL_Window *window;
 SDL_Renderer *renderer;
 int paused = 0;
 int i;
diff --git a/Engine/lib/sdl/test/testplatform.c b/Engine/lib/sdl/test/testplatform.c
index 943157748..5aa649c12 100644
--- a/Engine/lib/sdl/test/testplatform.c
+++ b/Engine/lib/sdl/test/testplatform.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -25,31 +25,31 @@ badsize(size_t sizeoftype, size_t hardcodetype)
     return sizeoftype != hardcodetype;
 }
 
+SDL_COMPILE_TIME_ASSERT(SDL_MAX_SINT8, SDL_MAX_SINT8 == 127);
+SDL_COMPILE_TIME_ASSERT(SDL_MIN_SINT8, SDL_MIN_SINT8 == -128);
+SDL_COMPILE_TIME_ASSERT(SDL_MAX_UINT8, SDL_MAX_UINT8 == 255);
+SDL_COMPILE_TIME_ASSERT(SDL_MIN_UINT8, SDL_MIN_UINT8 == 0);
+
+SDL_COMPILE_TIME_ASSERT(SDL_MAX_SINT16, SDL_MAX_SINT16 == 32767);
+SDL_COMPILE_TIME_ASSERT(SDL_MIN_SINT16, SDL_MIN_SINT16 == -32768);
+SDL_COMPILE_TIME_ASSERT(SDL_MAX_UINT16, SDL_MAX_UINT16 == 65535);
+SDL_COMPILE_TIME_ASSERT(SDL_MIN_UINT16, SDL_MIN_UINT16 == 0);
+
+SDL_COMPILE_TIME_ASSERT(SDL_MAX_SINT32, SDL_MAX_SINT32 == 2147483647);
+SDL_COMPILE_TIME_ASSERT(SDL_MIN_SINT32, SDL_MIN_SINT32 == ~0x7fffffff); /* Instead of -2147483648, which is treated as unsigned by some compilers */
+SDL_COMPILE_TIME_ASSERT(SDL_MAX_UINT32, SDL_MAX_UINT32 == 4294967295u);
+SDL_COMPILE_TIME_ASSERT(SDL_MIN_UINT32, SDL_MIN_UINT32 == 0);
+
+SDL_COMPILE_TIME_ASSERT(SDL_MAX_SINT64, SDL_MAX_SINT64 == 9223372036854775807ll);
+SDL_COMPILE_TIME_ASSERT(SDL_MIN_SINT64, SDL_MIN_SINT64 == ~0x7fffffffffffffffll); /* Instead of -9223372036854775808, which is treated as unsigned by compilers */
+SDL_COMPILE_TIME_ASSERT(SDL_MAX_UINT64, SDL_MAX_UINT64 == 18446744073709551615ull);
+SDL_COMPILE_TIME_ASSERT(SDL_MIN_UINT64, SDL_MIN_UINT64 == 0);
+
 int
 TestTypes(SDL_bool verbose)
 {
     int error = 0;
 
-	SDL_COMPILE_TIME_ASSERT(SDL_MAX_SINT8, SDL_MAX_SINT8 == 127);
-	SDL_COMPILE_TIME_ASSERT(SDL_MIN_SINT8, SDL_MIN_SINT8 == -128);
-	SDL_COMPILE_TIME_ASSERT(SDL_MAX_UINT8, SDL_MAX_UINT8 == 255);
-	SDL_COMPILE_TIME_ASSERT(SDL_MIN_UINT8, SDL_MIN_UINT8 == 0);
-
-	SDL_COMPILE_TIME_ASSERT(SDL_MAX_SINT16, SDL_MAX_SINT16 == 32767);
-	SDL_COMPILE_TIME_ASSERT(SDL_MIN_SINT16, SDL_MIN_SINT16 == -32768);
-	SDL_COMPILE_TIME_ASSERT(SDL_MAX_UINT16, SDL_MAX_UINT16 == 65535);
-	SDL_COMPILE_TIME_ASSERT(SDL_MIN_UINT16, SDL_MIN_UINT16 == 0);
-
-	SDL_COMPILE_TIME_ASSERT(SDL_MAX_SINT32, SDL_MAX_SINT32 == 2147483647);
-	SDL_COMPILE_TIME_ASSERT(SDL_MIN_SINT32, SDL_MIN_SINT32 == ~0x7fffffff); /* Instead of -2147483648, which is treated as unsigned by some compilers */
-	SDL_COMPILE_TIME_ASSERT(SDL_MAX_UINT32, SDL_MAX_UINT32 == 4294967295u);
-	SDL_COMPILE_TIME_ASSERT(SDL_MIN_UINT32, SDL_MIN_UINT32 == 0);
-
-	SDL_COMPILE_TIME_ASSERT(SDL_MAX_SINT64, SDL_MAX_SINT64 == 9223372036854775807ll);
-	SDL_COMPILE_TIME_ASSERT(SDL_MIN_SINT64, SDL_MIN_SINT64 == ~0x7fffffffffffffffll); /* Instead of -9223372036854775808, which is treated as unsigned by compilers */
-	SDL_COMPILE_TIME_ASSERT(SDL_MAX_UINT64, SDL_MAX_UINT64 == 18446744073709551615ull);
-	SDL_COMPILE_TIME_ASSERT(SDL_MIN_UINT64, SDL_MIN_UINT64 == 0);
-
     if (badsize(sizeof(Uint8), 1)) {
         if (verbose)
             SDL_Log("sizeof(Uint8) != 1, instead = %u\n",
@@ -381,6 +381,7 @@ TestCPUInfo(SDL_bool verbose)
         SDL_Log("AVX %s\n", SDL_HasAVX()? "detected" : "not detected");
         SDL_Log("AVX2 %s\n", SDL_HasAVX2()? "detected" : "not detected");
         SDL_Log("AVX-512F %s\n", SDL_HasAVX512F()? "detected" : "not detected");
+        SDL_Log("ARM SIMD %s\n", SDL_HasARMSIMD()? "detected" : "not detected");
         SDL_Log("NEON %s\n", SDL_HasNEON()? "detected" : "not detected");
         SDL_Log("System RAM %d MB\n", SDL_GetSystemRAM());
     }
diff --git a/Engine/lib/sdl/test/testpower.c b/Engine/lib/sdl/test/testpower.c
index 841d6053f..27b05ee21 100644
--- a/Engine/lib/sdl/test/testpower.c
+++ b/Engine/lib/sdl/test/testpower.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -19,7 +19,7 @@ report_power(void)
 {
     int seconds, percent;
     const SDL_PowerState state = SDL_GetPowerInfo(&seconds, &percent);
-    char *statestr = NULL;
+    const char *statestr = NULL;
 
     SDL_Log("SDL-reported power info...\n");
     switch (state) {
@@ -55,7 +55,7 @@ report_power(void)
         SDL_Log("Time left: unknown\n");
     } else {
         SDL_Log("Time left: %d minutes, %d seconds\n", (int) (seconds / 60),
-               (int) (seconds % 60));
+                (int) (seconds % 60));
     }
 }
 
diff --git a/Engine/lib/sdl/test/testqsort.c b/Engine/lib/sdl/test/testqsort.c
index 073a5c5c4..d28daebd4 100644
--- a/Engine/lib/sdl/test/testqsort.c
+++ b/Engine/lib/sdl/test/testqsort.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -54,9 +54,9 @@ main(int argc, char *argv[])
         int success;
         Uint64 seed = 0;
         if (argv[1][0] == '0' && argv[1][1] == 'x')
-            success = SDL_sscanf(argv[1] + 2, "%llx", &seed);
+            success = SDL_sscanf(argv[1] + 2, "%"SDL_PRIx64, &seed);
         else
-            success = SDL_sscanf(argv[1], "%llu", &seed);
+            success = SDL_sscanf(argv[1], "%"SDL_PRIu64, &seed);
         if (!success) {
             SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Invalid seed. Use a decimal or hexadecimal number.\n");
             return 1;
diff --git a/Engine/lib/sdl/test/testrelative.c b/Engine/lib/sdl/test/testrelative.c
index 52566f7b1..59a563eea 100644
--- a/Engine/lib/sdl/test/testrelative.c
+++ b/Engine/lib/sdl/test/testrelative.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -28,10 +28,10 @@ SDL_Rect rect;
 SDL_Event event;
 
 static void
-DrawRects(SDL_Renderer * renderer, SDL_Rect * rect)
+DrawRects(SDL_Renderer * renderer)
 {
     SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);
-    SDL_RenderFillRect(renderer, rect);
+    SDL_RenderFillRect(renderer, &rect);
 }
 
 static void
@@ -63,7 +63,7 @@ loop(){
         if (rect.x > viewport.x + viewport.w) rect.x -= viewport.w;
         if (rect.y > viewport.y + viewport.h) rect.y -= viewport.h;
 
-        DrawRects(renderer, &rect);
+        DrawRects(renderer);
 
         SDL_RenderPresent(renderer);
     }
diff --git a/Engine/lib/sdl/test/testrendercopyex.c b/Engine/lib/sdl/test/testrendercopyex.c
index 5f51bb64c..47d3ae96f 100644
--- a/Engine/lib/sdl/test/testrendercopyex.c
+++ b/Engine/lib/sdl/test/testrendercopyex.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/testrendertarget.c b/Engine/lib/sdl/test/testrendertarget.c
index 0845cbd66..3fb611270 100644
--- a/Engine/lib/sdl/test/testrendertarget.c
+++ b/Engine/lib/sdl/test/testrendertarget.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -46,7 +46,7 @@ quit(int rc)
 }
 
 SDL_Texture *
-LoadTexture(SDL_Renderer *renderer, char *file, SDL_bool transparent)
+LoadTexture(SDL_Renderer *renderer, const char *file, SDL_bool transparent)
 {
     SDL_Surface *temp;
     SDL_Texture *texture;
diff --git a/Engine/lib/sdl/test/testresample.c b/Engine/lib/sdl/test/testresample.c
index 70585f494..6f03aabd4 100644
--- a/Engine/lib/sdl/test/testresample.c
+++ b/Engine/lib/sdl/test/testresample.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/testrumble.c b/Engine/lib/sdl/test/testrumble.c
index 50c7a6544..07fc89c58 100644
--- a/Engine/lib/sdl/test/testrumble.c
+++ b/Engine/lib/sdl/test/testrumble.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -25,10 +25,6 @@ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 /*
  * includes
  */
-#include <stdlib.h>
-#include <string.h>             /* strstr */
-#include <ctype.h>              /* isdigit */
-
 #include "SDL.h"
 
 #ifndef SDL_HAPTIC_DISABLED
@@ -56,7 +52,7 @@ main(int argc, char **argv)
     if (argc > 1) {
         size_t l;
         name = argv[1];
-        if ((strcmp(name, "--help") == 0) || (strcmp(name, "-h") == 0)) {
+        if ((SDL_strcmp(name, "--help") == 0) || (SDL_strcmp(name, "-h") == 0)) {
             SDL_Log("USAGE: %s [device]\n"
                    "If device is a two-digit number it'll use it as an index, otherwise\n"
                    "it'll use it as if it were part of the device's name.\n",
@@ -83,7 +79,7 @@ main(int argc, char **argv)
         /* Try to find matching device */
         else {
             for (i = 0; i < SDL_NumHaptics(); i++) {
-                if (strstr(SDL_HapticName(i), name) != NULL)
+                if (SDL_strstr(SDL_HapticName(i), name) != NULL)
                     break;
             }
 
diff --git a/Engine/lib/sdl/test/testscale.c b/Engine/lib/sdl/test/testscale.c
index 4a603c67d..1235c811d 100644
--- a/Engine/lib/sdl/test/testscale.c
+++ b/Engine/lib/sdl/test/testscale.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -47,7 +47,7 @@ quit(int rc)
 }
 
 SDL_Texture *
-LoadTexture(SDL_Renderer *renderer, char *file, SDL_bool transparent)
+LoadTexture(SDL_Renderer *renderer, const char *file, SDL_bool transparent)
 {
     SDL_Surface *temp;
     SDL_Texture *texture;
diff --git a/Engine/lib/sdl/test/testsem.c b/Engine/lib/sdl/test/testsem.c
index 8a60ff122..eaa28642a 100644
--- a/Engine/lib/sdl/test/testsem.c
+++ b/Engine/lib/sdl/test/testsem.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -19,27 +19,21 @@
 #include "SDL.h"
 
 #define NUM_THREADS 10
+/* This value should be smaller than the maximum count of the */
+/* semaphore implementation: */
+#define NUM_OVERHEAD_OPS 10000
+#define NUM_OVERHEAD_OPS_MULT 10
 
 static SDL_sem *sem;
-int alive = 1;
+int alive;
 
-int SDLCALL
-ThreadFunc(void *data)
-{
-    int threadnum = (int) (uintptr_t) data;
-    while (alive) {
-        SDL_SemWait(sem);
-        SDL_Log("Thread number %d has got the semaphore (value = %d)!\n",
-                threadnum, SDL_SemValue(sem));
-        SDL_Delay(200);
-        SDL_SemPost(sem);
-        SDL_Log("Thread number %d has released the semaphore (value = %d)!\n",
-                threadnum, SDL_SemValue(sem));
-        SDL_Delay(1);           /* For the scheduler */
-    }
-    SDL_Log("Thread number %d exiting.\n", threadnum);
-    return 0;
-}
+typedef struct Thread_State {
+    SDL_Thread * thread;
+    int number;
+    SDL_bool flag;
+    int loop_count;
+    int content_count;
+} Thread_State;
 
 static void
 killed(int sig)
@@ -47,6 +41,60 @@ killed(int sig)
     alive = 0;
 }
 
+static int SDLCALL
+ThreadFuncRealWorld(void *data)
+{
+    Thread_State *state = (Thread_State *) data;
+    while (alive) {
+        SDL_SemWait(sem);
+        SDL_Log("Thread number %d has got the semaphore (value = %d)!\n",
+                state->number, SDL_SemValue(sem));
+        SDL_Delay(200);
+        SDL_SemPost(sem);
+        SDL_Log("Thread number %d has released the semaphore (value = %d)!\n",
+                state->number, SDL_SemValue(sem));
+        ++state->loop_count;
+        SDL_Delay(1);           /* For the scheduler */
+    }
+    SDL_Log("Thread number %d exiting.\n", state->number);
+    return 0;
+}
+
+static void
+TestRealWorld(int init_sem) {
+    Thread_State thread_states[NUM_THREADS] = { {0} };
+    int i;
+    int loop_count;
+
+    sem = SDL_CreateSemaphore(init_sem);
+
+    SDL_Log("Running %d threads, semaphore value = %d\n", NUM_THREADS,
+           init_sem);
+    alive = 1;
+    /* Create all the threads */
+    for (i = 0; i < NUM_THREADS; ++i) {
+        char name[64];
+        SDL_snprintf(name, sizeof (name), "Thread%u", (unsigned int) i);
+        thread_states[i].number = i;
+        thread_states[i].thread = SDL_CreateThread(ThreadFuncRealWorld, name, (void *) &thread_states[i]);
+    }
+
+    /* Wait 10 seconds */
+    SDL_Delay(10 * 1000);
+
+    /* Wait for all threads to finish */
+    SDL_Log("Waiting for threads to finish\n");
+    alive = 0;
+    loop_count = 0;
+    for (i = 0; i < NUM_THREADS; ++i) {
+        SDL_WaitThread(thread_states[i].thread, NULL);
+        loop_count += thread_states[i].loop_count;
+    }
+    SDL_Log("Finished waiting for threads, ran %d loops in total\n\n", loop_count);
+
+    SDL_DestroySemaphore(sem);
+}
+
 static void
 TestWaitTimeout(void)
 {
@@ -65,21 +113,137 @@ TestWaitTimeout(void)
     duration = end_ticks - start_ticks;
 
     /* Accept a little offset in the effective wait */
-    if (duration > 1900 && duration < 2050)
-        SDL_Log("Wait done.\n");
-    else
-        SDL_Log("Wait took %d milliseconds\n", duration);
+    SDL_assert(duration > 1900 && duration < 2050);
+    SDL_Log("Wait took %d milliseconds\n\n", duration);
 
     /* Check to make sure the return value indicates timed out */
     if (retval != SDL_MUTEX_TIMEDOUT)
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "SDL_SemWaitTimeout returned: %d; expected: %d\n", retval, SDL_MUTEX_TIMEDOUT);
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "SDL_SemWaitTimeout returned: %d; expected: %d\n\n", retval, SDL_MUTEX_TIMEDOUT);
+
+    SDL_DestroySemaphore(sem);
+}
+
+static void
+TestOverheadUncontended(void)
+{
+    Uint32 start_ticks;
+    Uint32 end_ticks;
+    Uint32 duration;
+    int i, j;
+
+    sem = SDL_CreateSemaphore(0);
+    SDL_Log("Doing %d uncontended Post/Wait operations on semaphore\n", NUM_OVERHEAD_OPS * NUM_OVERHEAD_OPS_MULT);
+
+    start_ticks = SDL_GetTicks();
+    for (i = 0; i < NUM_OVERHEAD_OPS_MULT; i++){
+        for (j = 0; j < NUM_OVERHEAD_OPS; j++) {
+            SDL_SemPost(sem);
+        }
+        for (j = 0; j < NUM_OVERHEAD_OPS; j++) {
+            SDL_SemWait(sem);
+        }
+    }
+    end_ticks = SDL_GetTicks();
+
+    duration = end_ticks - start_ticks;
+    SDL_Log("Took %d milliseconds\n\n", duration);
+
+    SDL_DestroySemaphore(sem);
+}
+
+static int SDLCALL
+ThreadFuncOverheadContended(void *data)
+{
+    Thread_State *state = (Thread_State *) data;
+
+    if (state->flag) {
+        while(alive) {
+            if (SDL_SemTryWait(sem) == SDL_MUTEX_TIMEDOUT) {
+                ++state->content_count;
+            }
+            ++state->loop_count;
+        }
+    } else {
+        while(alive) {
+            /* Timeout needed to allow check on alive flag */
+            if (SDL_SemWaitTimeout(sem, 50) == SDL_MUTEX_TIMEDOUT) {
+                ++state->content_count;
+            }
+            ++state->loop_count;
+        }
+    }
+    return 0;
+}
+
+static void
+TestOverheadContended(SDL_bool try_wait)
+{
+    Uint32 start_ticks;
+    Uint32 end_ticks;
+    Uint32 duration;
+    Thread_State thread_states[NUM_THREADS] = { {0} };
+    char textBuffer[1024];
+    int loop_count;
+    int content_count;
+    int i, j;
+    size_t len;
+
+    sem = SDL_CreateSemaphore(0);
+    SDL_Log("Doing %d contended %s operations on semaphore using %d threads\n",
+            NUM_OVERHEAD_OPS * NUM_OVERHEAD_OPS_MULT, try_wait ? "Post/TryWait" : "Post/WaitTimeout", NUM_THREADS);
+    alive = 1;
+    /* Create multiple threads to starve the semaphore and cause contention */
+    for (i = 0; i < NUM_THREADS; ++i) {
+        char name[64];
+        SDL_snprintf(name, sizeof (name), "Thread%u", (unsigned int) i);
+        thread_states[i].flag = try_wait;
+        thread_states[i].thread = SDL_CreateThread(ThreadFuncOverheadContended, name, (void *) &thread_states[i]);
+    }
+
+    start_ticks = SDL_GetTicks();
+    for (i = 0; i < NUM_OVERHEAD_OPS_MULT; i++) {
+        for (j = 0; j < NUM_OVERHEAD_OPS; j++) {
+            SDL_SemPost(sem);
+        }
+        /* Make sure threads consumed everything */
+        while (SDL_SemValue(sem)) { }
+    }
+    end_ticks = SDL_GetTicks();
+
+    alive = 0;
+    loop_count = 0;
+    content_count = 0;
+    for (i = 0; i < NUM_THREADS; ++i) {
+        SDL_WaitThread(thread_states[i].thread, NULL);
+        loop_count += thread_states[i].loop_count;
+        content_count += thread_states[i].content_count;
+    }
+    SDL_assert_release((loop_count - content_count) == NUM_OVERHEAD_OPS * NUM_OVERHEAD_OPS_MULT);
+
+    duration = end_ticks - start_ticks;
+    SDL_Log("Took %d milliseconds, threads %s %d out of %d times in total (%.2f%%)\n",
+            duration, try_wait ? "where contended" : "timed out", content_count,
+            loop_count, ((float)content_count * 100) / loop_count);
+    /* Print how many semaphores where consumed per thread */
+    SDL_snprintf(textBuffer, sizeof(textBuffer), "{ ");
+    for (i = 0; i < NUM_THREADS; ++i) {
+        if (i > 0) {
+            len = SDL_strlen(textBuffer);
+            SDL_snprintf(textBuffer + len, sizeof(textBuffer) - len, ", ");
+        }
+        len = SDL_strlen(textBuffer);
+        SDL_snprintf(textBuffer + len, sizeof(textBuffer) - len, "%d", thread_states[i].loop_count - thread_states[i].content_count);
+    }
+    len = SDL_strlen(textBuffer);
+    SDL_snprintf(textBuffer + len, sizeof(textBuffer) - len, " }\n");
+    SDL_Log("%s\n", textBuffer);
+
+    SDL_DestroySemaphore(sem);
 }
 
 int
 main(int argc, char **argv)
 {
-    SDL_Thread *threads[NUM_THREADS];
-    uintptr_t i;
     int init_sem;
 
     /* Enable standard application logging */
@@ -98,33 +262,19 @@ main(int argc, char **argv)
     signal(SIGTERM, killed);
     signal(SIGINT, killed);
 
-    init_sem = atoi(argv[1]);
-    sem = SDL_CreateSemaphore(init_sem);
-
-    SDL_Log("Running %d threads, semaphore value = %d\n", NUM_THREADS,
-           init_sem);
-    /* Create all the threads */
-    for (i = 0; i < NUM_THREADS; ++i) {
-        char name[64];
-        SDL_snprintf(name, sizeof (name), "Thread%u", (unsigned int) i);
-        threads[i] = SDL_CreateThread(ThreadFunc, name, (void *) i);
+    init_sem = SDL_atoi(argv[1]);
+    if (init_sem > 0) {
+        TestRealWorld(init_sem);
     }
 
-    /* Wait 10 seconds */
-    SDL_Delay(10 * 1000);
-
-    /* Wait for all threads to finish */
-    SDL_Log("Waiting for threads to finish\n");
-    alive = 0;
-    for (i = 0; i < NUM_THREADS; ++i) {
-        SDL_WaitThread(threads[i], NULL);
-    }
-    SDL_Log("Finished waiting for threads\n");
-
-    SDL_DestroySemaphore(sem);
-
     TestWaitTimeout();
 
+    TestOverheadUncontended();
+
+    TestOverheadContended(SDL_FALSE);
+
+    TestOverheadContended(SDL_TRUE);
+
     SDL_Quit();
     return (0);
 }
diff --git a/Engine/lib/sdl/test/testsensor.c b/Engine/lib/sdl/test/testsensor.c
index c29faa24f..658a65be8 100644
--- a/Engine/lib/sdl/test/testsensor.c
+++ b/Engine/lib/sdl/test/testsensor.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -95,7 +95,11 @@ main(int argc, char **argv)
 
         SDL_CreateWindow("Sensor Test", 0, 0, 0, 0, SDL_WINDOW_FULLSCREEN_DESKTOP);
         while (!done) {
-            while (SDL_PollEvent(&event) > 0) {
+            /* Update to get the current event state */
+            SDL_PumpEvents();
+
+            /* Process all currently pending events */
+            while (SDL_PeepEvents(&event, 1, SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT) == 1) {
                 switch (event.type) {
                 case SDL_SENSORUPDATE:
                     HandleSensorEvent(&event.sensor);
diff --git a/Engine/lib/sdl/test/testshader.c b/Engine/lib/sdl/test/testshader.c
index 45e74a604..2cee7d9b3 100644
--- a/Engine/lib/sdl/test/testshader.c
+++ b/Engine/lib/sdl/test/testshader.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/testshape.c b/Engine/lib/sdl/test/testshape.c
index 63288d4d9..1497528a9 100644
--- a/Engine/lib/sdl/test/testshape.c
+++ b/Engine/lib/sdl/test/testshape.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/testsprite2.c b/Engine/lib/sdl/test/testsprite2.c
index 4de0b4bae..88419ffcf 100644
--- a/Engine/lib/sdl/test/testsprite2.c
+++ b/Engine/lib/sdl/test/testsprite2.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -39,6 +39,7 @@ static int sprite_w, sprite_h;
 static SDL_BlendMode blendMode = SDL_BLENDMODE_BLEND;
 static Uint32 next_fps_check, frames;
 static const Uint32 fps_check_delay = 5000;
+static int use_rendergeometry = 0;
 
 /* Number of iterations to move sprites - used for visual tests. */
 /* -1: infinite random moves (default); >=0: enables N deterministic moves */
@@ -175,7 +176,38 @@ MoveSprites(SDL_Renderer * renderer, SDL_Texture * sprite)
     temp.y = 1;
     temp.w = sprite_w;
     temp.h = sprite_h;
-    SDL_RenderFillRect(renderer, &temp);
+    if (use_rendergeometry == 0) {
+        SDL_RenderFillRect(renderer, &temp);
+    } else {
+        /* Draw two triangles, filled, uniform */
+        SDL_Color color;
+        SDL_Vertex verts[3];
+        SDL_zeroa(verts);
+        color.r = 0xFF;
+        color.g = 0xFF;
+        color.b = 0xFF;
+        color.a = 0xFF;
+
+        verts[0].position.x = (float)temp.x;
+        verts[0].position.y = (float)temp.y;
+        verts[0].color = color;
+
+        verts[1].position.x = (float)temp.x + temp.w;
+        verts[1].position.y = (float)temp.y;
+        verts[1].color = color;
+
+        verts[2].position.x = (float)temp.x + temp.w;
+        verts[2].position.y = (float)temp.y + temp.h;
+        verts[2].color = color;
+
+        SDL_RenderGeometry(renderer, NULL, verts, 3, NULL, 0);
+
+        verts[1].position.x = (float)temp.x;
+        verts[1].position.y = (float)temp.y + temp.h;
+        verts[1].color = color;
+
+        SDL_RenderGeometry(renderer, NULL, verts, 3, NULL, 0);
+    }
     SDL_RenderCopy(renderer, sprite, NULL, &temp);
     temp.x = viewport.w-sprite_w-1;
     temp.y = 1;
@@ -220,7 +252,7 @@ MoveSprites(SDL_Renderer * renderer, SDL_Texture * sprite)
             }
 
         }
-        
+
         /* Countdown sprite-move iterations and disable color changes at iteration end - used for visual tests. */
         if (iterations > 0) {
             iterations--;
@@ -232,11 +264,160 @@ MoveSprites(SDL_Renderer * renderer, SDL_Texture * sprite)
     }
 
     /* Draw sprites */
-    for (i = 0; i < num_sprites; ++i) {
-        position = &positions[i];
+    if (use_rendergeometry == 0) {
+        for (i = 0; i < num_sprites; ++i) {
+            position = &positions[i];
 
-        /* Blit the sprite onto the screen */
-        SDL_RenderCopy(renderer, sprite, NULL, position);
+            /* Blit the sprite onto the screen */
+            SDL_RenderCopy(renderer, sprite, NULL, position);
+        }
+    } else if (use_rendergeometry == 1) {
+        /*
+         *   0--1
+         *   | /|
+         *   |/ |
+         *   3--2
+         *
+         *  Draw sprite2 as triangles that can be recombined as rect by software renderer
+         */
+        SDL_Vertex *verts = (SDL_Vertex *) SDL_malloc(num_sprites * sizeof (SDL_Vertex) * 6);
+        SDL_Vertex *verts2 = verts;
+        if (verts) {
+            SDL_Color color;
+            SDL_GetTextureColorMod(sprite, &color.r, &color.g, &color.b);
+            SDL_GetTextureAlphaMod(sprite, &color.a);
+            for (i = 0; i < num_sprites; ++i) {
+                position = &positions[i];
+                /* 0 */
+                verts->position.x = (float)position->x;
+                verts->position.y = (float)position->y;
+                verts->color = color;
+                verts->tex_coord.x = 0.0f;
+                verts->tex_coord.y = 0.0f;
+                verts++;
+                /* 1 */
+                verts->position.x = (float)position->x + position->w;
+                verts->position.y = (float)position->y;
+                verts->color = color;
+                verts->tex_coord.x = 1.0f;
+                verts->tex_coord.y = 0.0f;
+                verts++;
+                /* 2 */
+                verts->position.x = (float)position->x + position->w;
+                verts->position.y = (float)position->y + position->h;
+                verts->color = color;
+                verts->tex_coord.x = 1.0f;
+                verts->tex_coord.y = 1.0f;
+                verts++;
+                /* 0 */
+                verts->position.x = (float)position->x;
+                verts->position.y = (float)position->y;
+                verts->color = color;
+                verts->tex_coord.x = 0.0f;
+                verts->tex_coord.y = 0.0f;
+                verts++;
+                /* 2 */
+                verts->position.x = (float)position->x + position->w;
+                verts->position.y = (float)position->y + position->h;
+                verts->color = color;
+                verts->tex_coord.x = 1.0f;
+                verts->tex_coord.y = 1.0f;
+                verts++;
+                /* 3 */
+                verts->position.x = (float)position->x;
+                verts->position.y = (float)position->y + position->h;
+                verts->color = color;
+                verts->tex_coord.x = 0.0f;
+                verts->tex_coord.y = 1.0f;
+                verts++;
+            }
+
+            /* Blit sprites as triangles onto the screen */
+            SDL_RenderGeometry(renderer, sprite, verts2, num_sprites * 6, NULL, 0);
+            SDL_free(verts2);
+        }
+    } else if (use_rendergeometry == 2) {
+        /*   0-----1
+         *   |\ A /|
+         *   | \ / |
+         *   |D 2 B|
+         *   | / \ |
+         *   |/ C \|
+         *   3-----4
+         *
+         * Draw sprite2 as triangles that can *not* be recombined as rect by software renderer
+         * Use an 'indices' array
+         */
+        SDL_Vertex *verts = (SDL_Vertex *) SDL_malloc(num_sprites * sizeof (SDL_Vertex) * 5);
+        SDL_Vertex *verts2 = verts;
+        int *indices = (int *) SDL_malloc(num_sprites * sizeof (int) * 4 * 3);
+        int *indices2 = indices;
+        if (verts && indices) {
+            int pos = 0;
+            SDL_Color color;
+            SDL_GetTextureColorMod(sprite, &color.r, &color.g, &color.b);
+            SDL_GetTextureAlphaMod(sprite, &color.a);
+            for (i = 0; i < num_sprites; ++i) {
+                position = &positions[i];
+                /* 0 */
+                verts->position.x = (float)position->x;
+                verts->position.y = (float)position->y;
+                verts->color = color;
+                verts->tex_coord.x = 0.0f;
+                verts->tex_coord.y = 0.0f;
+                verts++;
+                /* 1 */
+                verts->position.x = (float)position->x + position->w;
+                verts->position.y = (float)position->y;
+                verts->color = color;
+                verts->tex_coord.x = 1.0f;
+                verts->tex_coord.y = 0.0f;
+                verts++;
+                /* 2 */
+                verts->position.x = (float)position->x + position->w / 2.0f;
+                verts->position.y = (float)position->y + position->h / 2.0f;
+                verts->color = color;
+                verts->tex_coord.x = 0.5f;
+                verts->tex_coord.y = 0.5f;
+                verts++;
+                /* 3 */
+                verts->position.x = (float)position->x;
+                verts->position.y = (float)position->y + position->h;
+                verts->color = color;
+                verts->tex_coord.x = 0.0f;
+                verts->tex_coord.y = 1.0f;
+                verts++;
+                /* 4 */
+                verts->position.x = (float)position->x + position->w;
+                verts->position.y = (float)position->y + position->h;
+                verts->color = color;
+                verts->tex_coord.x = 1.0f;
+                verts->tex_coord.y = 1.0f;
+                verts++;
+                /* A */
+                *indices++ = pos + 0;
+                *indices++ = pos + 1;
+                *indices++ = pos + 2;
+                /* B */
+                *indices++ = pos + 1;
+                *indices++ = pos + 2;
+                *indices++ = pos + 4;
+                /* C */
+                *indices++ = pos + 3;
+                *indices++ = pos + 2;
+                *indices++ = pos + 4;
+                /* D */
+                *indices++ = pos + 3;
+                *indices++ = pos + 2;
+                *indices++ = pos + 0;
+                pos += 5;
+            }
+        }
+
+        /* Blit sprites as triangles onto the screen */
+        SDL_RenderGeometry(renderer, sprite, verts2, num_sprites * 5, indices2, num_sprites * 4 * 3);
+        SDL_free(verts2);
+        SDL_free(indices2);
     }
 
     /* Update the screen! */
@@ -331,6 +512,20 @@ main(int argc, char *argv[])
             } else if (SDL_strcasecmp(argv[i], "--cyclealpha") == 0) {
                 cycle_alpha = SDL_TRUE;
                 consumed = 1;
+            } else if (SDL_strcasecmp(argv[i], "--use-rendergeometry") == 0) {
+                if (argv[i + 1]) {
+                    if (SDL_strcasecmp(argv[i + 1], "mode1") == 0) {
+                        /* Draw sprite2 as triangles that can be recombined as rect by software renderer */
+                        use_rendergeometry = 1;
+                    } else if (SDL_strcasecmp(argv[i + 1], "mode2") == 0) {
+                        /* Draw sprite2 as triangles that can *not* be recombined as rect by software renderer
+                         * Use an 'indices' array */
+                        use_rendergeometry = 2;
+                    } else {
+                        return -1;
+                    }
+                }
+                consumed = 2;
             } else if (SDL_isdigit(*argv[i])) {
                 num_sprites = SDL_atoi(argv[i]);
                 consumed = 1;
@@ -340,7 +535,15 @@ main(int argc, char *argv[])
             }
         }
         if (consumed < 0) {
-            static const char *options[] = { "[--blend none|blend|add|mod]", "[--cyclecolor]", "[--cyclealpha]", "[--iterations N]", "[num_sprites]", "[icon.bmp]", NULL };
+            static const char *options[] = {
+                "[--blend none|blend|add|mod]",
+                "[--cyclecolor]",
+                "[--cyclealpha]",
+                "[--iterations N]",
+                "[--use-rendergeometry mode1|mode2]",
+                "[num_sprites]",
+                "[icon.bmp]",
+                NULL };
             SDLTest_CommonLogUsage(state, argv[0], options);
             quit(1);
         }
@@ -374,7 +577,7 @@ main(int argc, char *argv[])
         quit(2);
     }
 
-    /* Position sprites and set their velocities using the fuzzer */ 
+    /* Position sprites and set their velocities using the fuzzer */
     if (iterations >= 0) {
         /* Deterministic seed - used for visual tests */
         seed = (Uint64)iterations;
diff --git a/Engine/lib/sdl/test/testspriteminimal.c b/Engine/lib/sdl/test/testspriteminimal.c
index 5e50baf9b..b9762cab3 100644
--- a/Engine/lib/sdl/test/testspriteminimal.c
+++ b/Engine/lib/sdl/test/testspriteminimal.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -43,7 +43,7 @@ quit(int rc)
 }
 
 int
-LoadSprite(char *file, SDL_Renderer *renderer)
+LoadSprite(const char *file)
 {
     SDL_Surface *temp;
 
@@ -92,7 +92,7 @@ LoadSprite(char *file, SDL_Renderer *renderer)
 }
 
 void
-MoveSprites(SDL_Renderer * renderer, SDL_Texture * sprite)
+MoveSprites()
 {
     int i;
     int window_w = WINDOW_WIDTH;
@@ -136,7 +136,7 @@ void loop()
             done = 1;
         }
     }
-    MoveSprites(renderer, sprite);
+    MoveSprites();
 #ifdef __EMSCRIPTEN__
     if (done) {
         emscripten_cancel_main_loop();
@@ -158,7 +158,7 @@ main(int argc, char *argv[])
         quit(2);
     }
 
-    if (LoadSprite("icon.bmp", renderer) < 0) {
+    if (LoadSprite("icon.bmp") < 0) {
         quit(2);
     }
 
diff --git a/Engine/lib/sdl/test/teststreaming.c b/Engine/lib/sdl/test/teststreaming.c
index 565d5c82e..72444f80e 100644
--- a/Engine/lib/sdl/test/teststreaming.c
+++ b/Engine/lib/sdl/test/teststreaming.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -67,7 +67,7 @@ void quit(int rc)
     exit(rc);
 }
 
-void UpdateTexture(SDL_Texture *texture, int frame)
+void UpdateTexture(SDL_Texture *texture)
 {
     SDL_Color *color;
     Uint8 *src;
@@ -110,7 +110,7 @@ loop()
     }
 
     frame = (frame + 1) % MOOSEFRAMES_COUNT;
-    UpdateTexture(MooseTexture, frame);
+    UpdateTexture(MooseTexture);
 
     SDL_RenderClear(renderer);
     SDL_RenderCopy(renderer, MooseTexture, NULL, NULL);
diff --git a/Engine/lib/sdl/test/testsurround.c b/Engine/lib/sdl/test/testsurround.c
new file mode 100644
index 000000000..168415aca
--- /dev/null
+++ b/Engine/lib/sdl/test/testsurround.c
@@ -0,0 +1,200 @@
+/*
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely.
+*/
+
+/* Program to test surround sound audio channels */
+#include "SDL_config.h"
+
+#include "SDL.h"
+
+static int total_channels;
+static int active_channel;
+
+#define SAMPLE_RATE_HZ 48000
+#define CHANNEL_TEST_TIME_SEC 5
+#define MAX_AMPLITUDE SDL_MAX_SINT16
+
+#define SINE_FREQ_HZ 500
+#define LFE_SINE_FREQ_HZ 50
+
+/* The channel layout is defined in SDL_audio.h */
+const char*
+get_channel_name(int channel_index, int channel_count)
+{
+    switch (channel_index) {
+    case 0:
+        return "Front Left";
+    case 1:
+        return "Front Right";
+    case 2:
+        switch (channel_count) {
+        case 3:
+            return "Low Frequency Effects";
+        case 4:
+            return "Back Left";
+        default:
+            return "Front Center";
+        }
+    case 3:
+        switch (channel_count) {
+        case 4:
+            return "Back Right";
+        case 5:
+            return "Back Left";
+        default:
+            return "Low Frequency Effects";
+        }
+    case 4:
+        switch (channel_count) {
+        case 5:
+            return "Back Right";
+        case 7:
+            return "Back Center";
+        case 6:
+        case 8:
+            return "Back Left";
+        }
+    case 5:
+        switch (channel_count) {
+        case 7:
+            return "Back Left";
+        case 6:
+        case 8:
+            return "Back Right";
+        }
+    case 6:
+        switch (channel_count) {
+        case 7:
+            return "Back Right";
+        case 8:
+            return "Side Left";
+        }
+    case 7:
+        return "Side Right";
+    }
+
+    return NULL;
+}
+
+SDL_bool
+is_lfe_channel(int channel_index, int channel_count)
+{
+    return (channel_count == 3 && channel_index == 2) || (channel_count >= 6 && channel_index == 3);
+}
+
+void SDLCALL
+fill_buffer(void* unused, Uint8* stream, int len)
+{
+    Sint16* buffer = (Sint16*)stream;
+    int samples = len / sizeof(Sint16);
+    static int total_samples = 0;
+    int i;
+
+    SDL_memset(stream, 0, len);
+
+    /* This can happen for a short time when switching devices */
+    if (active_channel == total_channels) {
+        return;
+    }
+
+    /* Play a sine wave on the active channel only */
+    for (i = active_channel; i < samples; i += total_channels) {
+        float time = (float)total_samples++ / SAMPLE_RATE_HZ;
+        int sine_freq = is_lfe_channel(active_channel, total_channels) ? LFE_SINE_FREQ_HZ : SINE_FREQ_HZ;
+        int amplitude;
+
+        /* Gradually ramp up and down to avoid audible pops when switching between channels */
+        if (total_samples < SAMPLE_RATE_HZ) {
+            amplitude = total_samples * MAX_AMPLITUDE / SAMPLE_RATE_HZ;
+        } else if (total_samples > (CHANNEL_TEST_TIME_SEC - 1) * SAMPLE_RATE_HZ) {
+            amplitude = (CHANNEL_TEST_TIME_SEC * SAMPLE_RATE_HZ - total_samples) * MAX_AMPLITUDE / SAMPLE_RATE_HZ;
+        } else {
+            amplitude = MAX_AMPLITUDE;
+        }
+
+        buffer[i] = (Sint16)(SDL_sin(6.283185f * sine_freq * time) * amplitude);
+
+        /* Reset our state for next callback if this channel test is finished */
+        if (total_samples == CHANNEL_TEST_TIME_SEC * SAMPLE_RATE_HZ) {
+            total_samples = 0;
+            active_channel++;
+            break;
+        }
+    }
+}
+
+int
+main(int argc, char *argv[])
+{
+    int i;
+
+    /* Enable standard application logging */
+    SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
+
+    if (SDL_Init(SDL_INIT_AUDIO) < 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't initialize SDL: %s\n", SDL_GetError());
+        return 1;
+    }
+
+    /* Show the list of available drivers */
+    SDL_Log("Available audio drivers:");
+    for (i = 0; i < SDL_GetNumAudioDrivers(); ++i) {
+        SDL_Log("%i: %s", i, SDL_GetAudioDriver(i));
+    }
+
+    SDL_Log("Using audio driver: %s\n", SDL_GetCurrentAudioDriver());
+
+    for (i = 0; i < SDL_GetNumAudioDevices(0); i++) {
+        const char *devname = SDL_GetAudioDeviceName(i, 0);
+        int j;
+        SDL_AudioSpec spec;
+        SDL_AudioDeviceID dev;
+
+        if (SDL_GetAudioDeviceSpec(i, 0, &spec) != 0) {
+            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "SDL_GetAudioSpec() failed: %s\n", SDL_GetError());
+            continue;
+        }
+
+        spec.freq = SAMPLE_RATE_HZ;
+        spec.format = AUDIO_S16SYS;
+        spec.samples = 4096;
+        spec.callback = fill_buffer;
+
+        dev = SDL_OpenAudioDevice(devname, 0, &spec, NULL, 0);
+        if (dev == 0) {
+            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "SDL_OpenAudioDevice() failed: %s\n", SDL_GetError());
+            continue;
+        }
+
+        SDL_Log("Testing audio device: %s (%d channels)\n", devname, spec.channels);
+
+        /* These are used by the fill_buffer callback */
+        total_channels = spec.channels;
+        active_channel = 0;
+
+        SDL_PauseAudioDevice(dev, 0);
+
+        for (j = 0; j < total_channels; j++) {
+            int sine_freq = is_lfe_channel(j, total_channels) ? LFE_SINE_FREQ_HZ : SINE_FREQ_HZ;
+
+            SDL_Log("Playing %d Hz test tone on channel: %s\n", sine_freq, get_channel_name(j, total_channels));
+
+            /* fill_buffer() will increment the active channel */
+            SDL_Delay(CHANNEL_TEST_TIME_SEC * 1000);
+        }
+
+        SDL_CloseAudioDevice(dev);
+    }
+
+    SDL_Quit();
+    return 0;
+}
+
diff --git a/Engine/lib/sdl/test/testthread.c b/Engine/lib/sdl/test/testthread.c
index 2c95a7379..bf201e8e4 100644
--- a/Engine/lib/sdl/test/testthread.c
+++ b/Engine/lib/sdl/test/testthread.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/testtimer.c b/Engine/lib/sdl/test/testtimer.c
index 7e49d7508..d696097c8 100644
--- a/Engine/lib/sdl/test/testtimer.c
+++ b/Engine/lib/sdl/test/testtimer.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -42,6 +42,7 @@ main(int argc, char *argv[])
 {
     int i, desired;
     SDL_TimerID t1, t2, t3;
+    Uint64 start64, now64;
     Uint32 start32, now32;
     Uint64 start, now;
 
@@ -53,10 +54,25 @@ main(int argc, char *argv[])
         return (1);
     }
 
+    /* Verify SDL_GetTicks* acts monotonically increasing, and not erratic. */
+    SDL_Log("Sanity-checking GetTicks\n");
+    for (i = 0; i < 1000; ++i) {
+        start64 = SDL_GetTicks64();
+        start32 = SDL_GetTicks();
+        SDL_Delay(1);
+        now64 = SDL_GetTicks64() - start64;
+        now32 = SDL_GetTicks() - start32;
+        if (now32 > 100 || now64 > 100) {
+            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "testtimer.c: Delta time erratic at iter %d. Delay 1ms = %d ms in ticks, %d ms in ticks64\n", i, (int)now32, (int)now64);
+            SDL_Quit();
+            return 1;
+        }
+    }
+
     /* Start the timer */
     desired = 0;
     if (argv[1]) {
-        desired = atoi(argv[1]);
+        desired = SDL_atoi(argv[1]);
     }
     if (desired == 0) {
         desired = DEFAULT_RESOLUTION;
@@ -108,12 +124,14 @@ main(int argc, char *argv[])
     SDL_Log("1 million iterations of ticktock took %f ms\n", (double)((now - start)*1000) / SDL_GetPerformanceFrequency());
 
     SDL_Log("Performance counter frequency: %"SDL_PRIu64"\n", SDL_GetPerformanceFrequency());
+    start64 = SDL_GetTicks64();
     start32 = SDL_GetTicks();
     start = SDL_GetPerformanceCounter();
     SDL_Delay(1000);
     now = SDL_GetPerformanceCounter();
+    now64 = SDL_GetTicks64();
     now32 = SDL_GetTicks();
-    SDL_Log("Delay 1 second = %d ms in ticks, %f ms according to performance counter\n", (now32-start32), (double)((now - start)*1000) / SDL_GetPerformanceFrequency());
+    SDL_Log("Delay 1 second = %d ms in ticks, %d ms in ticks64, %f ms according to performance counter\n", (int) (now32-start32), (int) (now64-start64), (double)((now - start)*1000) / SDL_GetPerformanceFrequency());
 
     SDL_Quit();
     return (0);
diff --git a/Engine/lib/sdl/test/testurl.c b/Engine/lib/sdl/test/testurl.c
index fbde1b95f..4b5a4ed29 100644
--- a/Engine/lib/sdl/test/testurl.c
+++ b/Engine/lib/sdl/test/testurl.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/testver.c b/Engine/lib/sdl/test/testver.c
index 94bceae61..cbbba7ec6 100644
--- a/Engine/lib/sdl/test/testver.c
+++ b/Engine/lib/sdl/test/testver.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -35,13 +35,13 @@ main(int argc, char *argv[])
     SDL_Log("Compiled with SDL older than 2.0\n");
 #endif
     SDL_VERSION(&compiled);
-    SDL_Log("Compiled version: %d.%d.%d.%d (%s)\n",
+    SDL_Log("Compiled version: %d.%d.%d (%s)\n",
            compiled.major, compiled.minor, compiled.patch,
-           SDL_REVISION_NUMBER, SDL_REVISION);
+           SDL_REVISION);
     SDL_GetVersion(&linked);
-    SDL_Log("Linked version: %d.%d.%d.%d (%s)\n",
+    SDL_Log("Linked version: %d.%d.%d (%s)\n",
            linked.major, linked.minor, linked.patch,
-           SDL_GetRevisionNumber(), SDL_GetRevision());
+           SDL_GetRevision());
     SDL_Quit();
     return (0);
 }
diff --git a/Engine/lib/sdl/test/testviewport.c b/Engine/lib/sdl/test/testviewport.c
index fc44fe1b6..0e39d852d 100644
--- a/Engine/lib/sdl/test/testviewport.c
+++ b/Engine/lib/sdl/test/testviewport.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -43,7 +43,7 @@ quit(int rc)
 }
 
 int
-LoadSprite(char *file, SDL_Renderer *renderer)
+LoadSprite(const char *file, SDL_Renderer *renderer)
 {
     SDL_Surface *temp;
 
@@ -92,7 +92,7 @@ LoadSprite(char *file, SDL_Renderer *renderer)
 }
 
 void
-DrawOnViewport(SDL_Renderer * renderer, SDL_Rect viewport)
+DrawOnViewport(SDL_Renderer * renderer)
 {    
     SDL_Rect rect;
 
@@ -174,7 +174,7 @@ loop()
             continue;
 
         /* Draw using viewport */
-        DrawOnViewport(state->renderers[i], viewport);
+        DrawOnViewport(state->renderers[i]);
 
         /* Update the screen! */
         if (use_target) {
diff --git a/Engine/lib/sdl/test/testvulkan.c b/Engine/lib/sdl/test/testvulkan.c
index 86e095479..3fe047f3f 100644
--- a/Engine/lib/sdl/test/testvulkan.c
+++ b/Engine/lib/sdl/test/testvulkan.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -110,70 +110,44 @@ enum {
 
 static const char *getVulkanResultString(VkResult result)
 {
-    switch((int)result)
+    switch((int) result)
     {
-    case VK_SUCCESS:
-        return "VK_SUCCESS";
-    case VK_NOT_READY:
-        return "VK_NOT_READY";
-    case VK_TIMEOUT:
-        return "VK_TIMEOUT";
-    case VK_EVENT_SET:
-        return "VK_EVENT_SET";
-    case VK_EVENT_RESET:
-        return "VK_EVENT_RESET";
-    case VK_INCOMPLETE:
-        return "VK_INCOMPLETE";
-    case VK_ERROR_OUT_OF_HOST_MEMORY:
-        return "VK_ERROR_OUT_OF_HOST_MEMORY";
-    case VK_ERROR_OUT_OF_DEVICE_MEMORY:
-        return "VK_ERROR_OUT_OF_DEVICE_MEMORY";
-    case VK_ERROR_INITIALIZATION_FAILED:
-        return "VK_ERROR_INITIALIZATION_FAILED";
-    case VK_ERROR_DEVICE_LOST:
-        return "VK_ERROR_DEVICE_LOST";
-    case VK_ERROR_MEMORY_MAP_FAILED:
-        return "VK_ERROR_MEMORY_MAP_FAILED";
-    case VK_ERROR_LAYER_NOT_PRESENT:
-        return "VK_ERROR_LAYER_NOT_PRESENT";
-    case VK_ERROR_EXTENSION_NOT_PRESENT:
-        return "VK_ERROR_EXTENSION_NOT_PRESENT";
-    case VK_ERROR_FEATURE_NOT_PRESENT:
-        return "VK_ERROR_FEATURE_NOT_PRESENT";
-    case VK_ERROR_INCOMPATIBLE_DRIVER:
-        return "VK_ERROR_INCOMPATIBLE_DRIVER";
-    case VK_ERROR_TOO_MANY_OBJECTS:
-        return "VK_ERROR_TOO_MANY_OBJECTS";
-    case VK_ERROR_FORMAT_NOT_SUPPORTED:
-        return "VK_ERROR_FORMAT_NOT_SUPPORTED";
-    case VK_ERROR_FRAGMENTED_POOL:
-        return "VK_ERROR_FRAGMENTED_POOL";
-    case VK_ERROR_SURFACE_LOST_KHR:
-        return "VK_ERROR_SURFACE_LOST_KHR";
-    case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR:
-        return "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR";
-    case VK_SUBOPTIMAL_KHR:
-        return "VK_SUBOPTIMAL_KHR";
-    case VK_ERROR_OUT_OF_DATE_KHR:
-        return "VK_ERROR_OUT_OF_DATE_KHR";
-    case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR:
-        return "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR";
-    case VK_ERROR_VALIDATION_FAILED_EXT:
-        return "VK_ERROR_VALIDATION_FAILED_EXT";
-    case VK_ERROR_OUT_OF_POOL_MEMORY_KHR:
-        return "VK_ERROR_OUT_OF_POOL_MEMORY_KHR";
-    case VK_ERROR_INVALID_SHADER_NV:
-        return "VK_ERROR_INVALID_SHADER_NV";
-    default:
-        break;
+        #define RESULT_CASE(x) case x: return #x
+        RESULT_CASE(VK_SUCCESS);
+        RESULT_CASE(VK_NOT_READY);
+        RESULT_CASE(VK_TIMEOUT);
+        RESULT_CASE(VK_EVENT_SET);
+        RESULT_CASE(VK_EVENT_RESET);
+        RESULT_CASE(VK_INCOMPLETE);
+        RESULT_CASE(VK_ERROR_OUT_OF_HOST_MEMORY);
+        RESULT_CASE(VK_ERROR_OUT_OF_DEVICE_MEMORY);
+        RESULT_CASE(VK_ERROR_INITIALIZATION_FAILED);
+        RESULT_CASE(VK_ERROR_DEVICE_LOST);
+        RESULT_CASE(VK_ERROR_MEMORY_MAP_FAILED);
+        RESULT_CASE(VK_ERROR_LAYER_NOT_PRESENT);
+        RESULT_CASE(VK_ERROR_EXTENSION_NOT_PRESENT);
+        RESULT_CASE(VK_ERROR_FEATURE_NOT_PRESENT);
+        RESULT_CASE(VK_ERROR_INCOMPATIBLE_DRIVER);
+        RESULT_CASE(VK_ERROR_TOO_MANY_OBJECTS);
+        RESULT_CASE(VK_ERROR_FORMAT_NOT_SUPPORTED);
+        RESULT_CASE(VK_ERROR_FRAGMENTED_POOL);
+        RESULT_CASE(VK_ERROR_SURFACE_LOST_KHR);
+        RESULT_CASE(VK_ERROR_NATIVE_WINDOW_IN_USE_KHR);
+        RESULT_CASE(VK_SUBOPTIMAL_KHR);
+        RESULT_CASE(VK_ERROR_OUT_OF_DATE_KHR);
+        RESULT_CASE(VK_ERROR_INCOMPATIBLE_DISPLAY_KHR);
+        RESULT_CASE(VK_ERROR_VALIDATION_FAILED_EXT);
+        RESULT_CASE(VK_ERROR_OUT_OF_POOL_MEMORY_KHR);
+        RESULT_CASE(VK_ERROR_INVALID_SHADER_NV);
+        #undef RESULT_CASE
+        default: break;
     }
-    if(result < 0)
-        return "VK_ERROR_<Unknown>";
-    return "VK_<Unknown>";
+    return (result < 0) ? "VK_ERROR_<Unknown>" : "VK_<Unknown>";
 }
 
 typedef struct VulkanContext
 {
+    SDL_Window *window;
     VkInstance instance;
     VkDevice device;
     VkSurfaceKHR surface;
@@ -202,14 +176,15 @@ typedef struct VulkanContext
 } VulkanContext;
 
 static SDLTest_CommonState *state;
-static VulkanContext vulkanContext = {0};
+static VulkanContext *vulkanContexts = NULL;  // an array of state->num_windows items
+static VulkanContext *vulkanContext = NULL;  // for the currently-rendering window
 
-static void shutdownVulkan(void);
+static void shutdownVulkan(SDL_bool doDestroySwapchain);
 
 /* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */
 static void quit(int rc)
 {
-    shutdownVulkan();
+    shutdownVulkan(SDL_TRUE);
     SDLTest_CommonQuit(state);
     exit(rc);
 }
@@ -217,8 +192,7 @@ static void quit(int rc)
 static void loadGlobalFunctions(void)
 {
     vkGetInstanceProcAddr = SDL_Vulkan_GetVkGetInstanceProcAddr();
-    if(!vkGetInstanceProcAddr)
-    {
+    if (!vkGetInstanceProcAddr) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                      "SDL_Vulkan_GetVkGetInstanceProcAddr(): %s\n",
                      SDL_GetError());
@@ -228,8 +202,7 @@ static void loadGlobalFunctions(void)
 #define VULKAN_DEVICE_FUNCTION(name)
 #define VULKAN_GLOBAL_FUNCTION(name)                                                   \
     name = (PFN_##name)vkGetInstanceProcAddr(VK_NULL_HANDLE, #name);                   \
-    if(!name)                                                                          \
-    {                                                                                  \
+    if (!name) {                                                                       \
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,                                     \
                      "vkGetInstanceProcAddr(VK_NULL_HANDLE, \"" #name "\") failed\n"); \
         quit(2);                                                                       \
@@ -247,28 +220,24 @@ static void createInstance(void)
     VkInstanceCreateInfo instanceCreateInfo = {0};
     const char **extensions = NULL;
     unsigned extensionCount = 0;
-	VkResult result;
+    VkResult result;
 
-
-	appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
+    appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
     appInfo.apiVersion = VK_API_VERSION_1_0;
     instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
     instanceCreateInfo.pApplicationInfo = &appInfo;
-    if(!SDL_Vulkan_GetInstanceExtensions(NULL, &extensionCount, NULL))
-    {
+    if (!SDL_Vulkan_GetInstanceExtensions(NULL, &extensionCount, NULL)) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                      "SDL_Vulkan_GetInstanceExtensions(): %s\n",
                      SDL_GetError());
         quit(2);
     }
-    extensions = SDL_malloc(sizeof(const char *) * extensionCount);
-    if(!extensions)
-    {
+    extensions = (const char **) SDL_malloc(sizeof(const char *) * extensionCount);
+    if (!extensions) {
         SDL_OutOfMemory();
         quit(2);
     }
-    if(!SDL_Vulkan_GetInstanceExtensions(NULL, &extensionCount, extensions))
-    {
+    if (!SDL_Vulkan_GetInstanceExtensions(NULL, &extensionCount, extensions)) {
         SDL_free((void*)extensions);
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                      "SDL_Vulkan_GetInstanceExtensions(): %s\n",
@@ -277,11 +246,10 @@ static void createInstance(void)
     }
     instanceCreateInfo.enabledExtensionCount = extensionCount;
     instanceCreateInfo.ppEnabledExtensionNames = extensions;
-    result = vkCreateInstance(&instanceCreateInfo, NULL, &vulkanContext.instance);
+    result = vkCreateInstance(&instanceCreateInfo, NULL, &vulkanContext->instance);
     SDL_free((void*)extensions);
-    if(result != VK_SUCCESS)
-    {
-        vulkanContext.instance = VK_NULL_HANDLE;
+    if (result != VK_SUCCESS) {
+        vulkanContext->instance = VK_NULL_HANDLE;
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                      "vkCreateInstance(): %s\n",
                      getVulkanResultString(result));
@@ -294,9 +262,8 @@ static void loadInstanceFunctions(void)
 #define VULKAN_DEVICE_FUNCTION(name)
 #define VULKAN_GLOBAL_FUNCTION(name)
 #define VULKAN_INSTANCE_FUNCTION(name)                                           \
-    name = (PFN_##name)vkGetInstanceProcAddr(vulkanContext.instance, #name);     \
-    if(!name)                                                                    \
-    {                                                                            \
+    name = (PFN_##name)vkGetInstanceProcAddr(vulkanContext->instance, #name);    \
+    if (!name) {                                                                 \
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,                               \
                      "vkGetInstanceProcAddr(instance, \"" #name "\") failed\n"); \
         quit(2);                                                                 \
@@ -309,13 +276,11 @@ static void loadInstanceFunctions(void)
 
 static void createSurface(void)
 {
-    if(!SDL_Vulkan_CreateSurface(state->windows[0],
-                                 vulkanContext.instance,
-                                 &vulkanContext.surface))
-    {
-        vulkanContext.surface = VK_NULL_HANDLE;
-        SDL_LogError(
-            SDL_LOG_CATEGORY_APPLICATION, "SDL_Vulkan_CreateSurface(): %s\n", SDL_GetError());
+    if (!SDL_Vulkan_CreateSurface(vulkanContext->window,
+                                 vulkanContext->instance,
+                                 &vulkanContext->surface)) {
+        vulkanContext->surface = VK_NULL_HANDLE;
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "SDL_Vulkan_CreateSurface(): %s\n", SDL_GetError());
         quit(2);
     }
 }
@@ -323,94 +288,84 @@ static void createSurface(void)
 static void findPhysicalDevice(void)
 {
     uint32_t physicalDeviceCount = 0;
-	VkPhysicalDevice *physicalDevices;
-	VkQueueFamilyProperties *queueFamiliesProperties = NULL;
+    VkPhysicalDevice *physicalDevices;
+    VkQueueFamilyProperties *queueFamiliesProperties = NULL;
     uint32_t queueFamiliesPropertiesAllocatedSize = 0;
     VkExtensionProperties *deviceExtensions = NULL;
     uint32_t deviceExtensionsAllocatedSize = 0;
-	uint32_t physicalDeviceIndex;
+    uint32_t physicalDeviceIndex;
+    VkResult result;
 
-    VkResult result =
-        vkEnumeratePhysicalDevices(vulkanContext.instance, &physicalDeviceCount, NULL);
-    if(result != VK_SUCCESS)
-    {
+    result = vkEnumeratePhysicalDevices(vulkanContext->instance, &physicalDeviceCount, NULL);
+    if (result != VK_SUCCESS) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                      "vkEnumeratePhysicalDevices(): %s\n",
                      getVulkanResultString(result));
         quit(2);
     }
-    if(physicalDeviceCount == 0)
-    {
+    if (physicalDeviceCount == 0) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                      "vkEnumeratePhysicalDevices(): no physical devices\n");
         quit(2);
     }
-    physicalDevices = SDL_malloc(sizeof(VkPhysicalDevice) * physicalDeviceCount);
-    if(!physicalDevices)
-    {
+    physicalDevices = (VkPhysicalDevice *) SDL_malloc(sizeof(VkPhysicalDevice) * physicalDeviceCount);
+    if (!physicalDevices) {
         SDL_OutOfMemory();
         quit(2);
     }
-    result =
-        vkEnumeratePhysicalDevices(vulkanContext.instance, &physicalDeviceCount, physicalDevices);
-    if(result != VK_SUCCESS)
-    {
+    result = vkEnumeratePhysicalDevices(vulkanContext->instance, &physicalDeviceCount, physicalDevices);
+    if (result != VK_SUCCESS) {
         SDL_free(physicalDevices);
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                      "vkEnumeratePhysicalDevices(): %s\n",
                      getVulkanResultString(result));
         quit(2);
     }
-    vulkanContext.physicalDevice = NULL;
-    for(physicalDeviceIndex = 0; physicalDeviceIndex < physicalDeviceCount;
-        physicalDeviceIndex++)
-    {
+    vulkanContext->physicalDevice = NULL;
+    for (physicalDeviceIndex = 0; physicalDeviceIndex < physicalDeviceCount; physicalDeviceIndex++) {
         uint32_t queueFamiliesCount = 0;
-		uint32_t queueFamilyIndex;
+        uint32_t queueFamilyIndex;
         uint32_t deviceExtensionCount = 0;
-		SDL_bool hasSwapchainExtension = SDL_FALSE;
-		uint32_t i;
+        SDL_bool hasSwapchainExtension = SDL_FALSE;
+        uint32_t i;
 
-
-		VkPhysicalDevice physicalDevice = physicalDevices[physicalDeviceIndex];
-        vkGetPhysicalDeviceProperties(physicalDevice, &vulkanContext.physicalDeviceProperties);
-        if(VK_VERSION_MAJOR(vulkanContext.physicalDeviceProperties.apiVersion) < 1)
+        VkPhysicalDevice physicalDevice = physicalDevices[physicalDeviceIndex];
+        vkGetPhysicalDeviceProperties(physicalDevice, &vulkanContext->physicalDeviceProperties);
+        if(VK_VERSION_MAJOR(vulkanContext->physicalDeviceProperties.apiVersion) < 1) {
             continue;
-        vkGetPhysicalDeviceFeatures(physicalDevice, &vulkanContext.physicalDeviceFeatures);
+        }
+        vkGetPhysicalDeviceFeatures(physicalDevice, &vulkanContext->physicalDeviceFeatures);
         vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamiliesCount, NULL);
-        if(queueFamiliesCount == 0)
+        if (queueFamiliesCount == 0) {
             continue;
-        if(queueFamiliesPropertiesAllocatedSize < queueFamiliesCount)
-        {
+        }
+        if (queueFamiliesPropertiesAllocatedSize < queueFamiliesCount) {
             SDL_free(queueFamiliesProperties);
             queueFamiliesPropertiesAllocatedSize = queueFamiliesCount;
-            queueFamiliesProperties =
-                SDL_malloc(sizeof(VkQueueFamilyProperties) * queueFamiliesPropertiesAllocatedSize);
-            if(!queueFamiliesProperties)
-            {
+            queueFamiliesProperties = (VkQueueFamilyProperties *) SDL_malloc(sizeof(VkQueueFamilyProperties) * queueFamiliesPropertiesAllocatedSize);
+            if (!queueFamiliesProperties) {
                 SDL_free(physicalDevices);
                 SDL_free(deviceExtensions);
                 SDL_OutOfMemory();
                 quit(2);
             }
         }
-        vkGetPhysicalDeviceQueueFamilyProperties(
-            physicalDevice, &queueFamiliesCount, queueFamiliesProperties);
-        vulkanContext.graphicsQueueFamilyIndex = queueFamiliesCount;
-        vulkanContext.presentQueueFamilyIndex = queueFamiliesCount;
-        for(queueFamilyIndex = 0; queueFamilyIndex < queueFamiliesCount;
-            queueFamilyIndex++)
-        {
+        vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamiliesCount, queueFamiliesProperties);
+        vulkanContext->graphicsQueueFamilyIndex = queueFamiliesCount;
+        vulkanContext->presentQueueFamilyIndex = queueFamiliesCount;
+        for (queueFamilyIndex = 0; queueFamilyIndex < queueFamiliesCount; queueFamilyIndex++) {
             VkBool32 supported = 0;
 
-			if(queueFamiliesProperties[queueFamilyIndex].queueCount == 0)
+            if (queueFamiliesProperties[queueFamilyIndex].queueCount == 0) {
                 continue;
-            if(queueFamiliesProperties[queueFamilyIndex].queueFlags & VK_QUEUE_GRAPHICS_BIT)
-                vulkanContext.graphicsQueueFamilyIndex = queueFamilyIndex;
-            result = vkGetPhysicalDeviceSurfaceSupportKHR(
-                physicalDevice, queueFamilyIndex, vulkanContext.surface, &supported);
-            if(result != VK_SUCCESS)
-            {
+            }
+
+            if (queueFamiliesProperties[queueFamilyIndex].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
+                vulkanContext->graphicsQueueFamilyIndex = queueFamilyIndex;
+            }
+
+            result = vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, vulkanContext->surface, &supported);
+            if (result != VK_SUCCESS) {
                 SDL_free(physicalDevices);
                 SDL_free(queueFamiliesProperties);
                 SDL_free(deviceExtensions);
@@ -419,20 +374,22 @@ static void findPhysicalDevice(void)
                              getVulkanResultString(result));
                 quit(2);
             }
-            if(supported)
-            {
-                vulkanContext.presentQueueFamilyIndex = queueFamilyIndex;
-                if(queueFamiliesProperties[queueFamilyIndex].queueFlags & VK_QUEUE_GRAPHICS_BIT)
+            if (supported) {
+                vulkanContext->presentQueueFamilyIndex = queueFamilyIndex;
+                if (queueFamiliesProperties[queueFamilyIndex].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
                     break; // use this queue because it can present and do graphics
+                }
             }
         }
-        if(vulkanContext.graphicsQueueFamilyIndex == queueFamiliesCount) // no good queues found
+
+        if (vulkanContext->graphicsQueueFamilyIndex == queueFamiliesCount) {  // no good queues found
             continue;
-        if(vulkanContext.presentQueueFamilyIndex == queueFamiliesCount) // no good queues found
+        }
+        if (vulkanContext->presentQueueFamilyIndex == queueFamiliesCount) {  // no good queues found
             continue;
-        result =
-            vkEnumerateDeviceExtensionProperties(physicalDevice, NULL, &deviceExtensionCount, NULL);
-        if(result != VK_SUCCESS)
+        }
+        result = vkEnumerateDeviceExtensionProperties(physicalDevice, NULL, &deviceExtensionCount, NULL);
+        if (result != VK_SUCCESS)
         {
             SDL_free(physicalDevices);
             SDL_free(queueFamiliesProperties);
@@ -442,26 +399,22 @@ static void findPhysicalDevice(void)
                          getVulkanResultString(result));
             quit(2);
         }
-        if(deviceExtensionCount == 0)
+        if (deviceExtensionCount == 0) {
             continue;
-        if(deviceExtensionsAllocatedSize < deviceExtensionCount)
-        {
+        }
+        if (deviceExtensionsAllocatedSize < deviceExtensionCount) {
             SDL_free(deviceExtensions);
             deviceExtensionsAllocatedSize = deviceExtensionCount;
-            deviceExtensions =
-                SDL_malloc(sizeof(VkExtensionProperties) * deviceExtensionsAllocatedSize);
-            if(!deviceExtensions)
-            {
+            deviceExtensions = SDL_malloc(sizeof(VkExtensionProperties) * deviceExtensionsAllocatedSize);
+            if (!deviceExtensions) {
                 SDL_free(physicalDevices);
                 SDL_free(queueFamiliesProperties);
                 SDL_OutOfMemory();
                 quit(2);
             }
         }
-        result = vkEnumerateDeviceExtensionProperties(
-            physicalDevice, NULL, &deviceExtensionCount, deviceExtensions);
-        if(result != VK_SUCCESS)
-        {
+        result = vkEnumerateDeviceExtensionProperties(physicalDevice, NULL, &deviceExtensionCount, deviceExtensions);
+        if (result != VK_SUCCESS) {
             SDL_free(physicalDevices);
             SDL_free(queueFamiliesProperties);
             SDL_free(deviceExtensions);
@@ -470,24 +423,22 @@ static void findPhysicalDevice(void)
                          getVulkanResultString(result));
             quit(2);
         }
-        for(i = 0; i < deviceExtensionCount; i++)
-        {
-            if(0 == SDL_strcmp(deviceExtensions[i].extensionName, VK_KHR_SWAPCHAIN_EXTENSION_NAME))
-            {
+        for (i = 0; i < deviceExtensionCount; i++) {
+            if(SDL_strcmp(deviceExtensions[i].extensionName, VK_KHR_SWAPCHAIN_EXTENSION_NAME) == 0) {
                 hasSwapchainExtension = SDL_TRUE;
                 break;
             }
         }
-        if(!hasSwapchainExtension)
+        if (!hasSwapchainExtension) {
             continue;
-        vulkanContext.physicalDevice = physicalDevice;
+        }
+        vulkanContext->physicalDevice = physicalDevice;
         break;
     }
     SDL_free(physicalDevices);
     SDL_free(queueFamiliesProperties);
     SDL_free(deviceExtensions);
-    if(!vulkanContext.physicalDevice)
-    {
+    if (!vulkanContext->physicalDevice) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Vulkan: no viable physical devices found");
         quit(2);
     }
@@ -495,16 +446,16 @@ static void findPhysicalDevice(void)
 
 static void createDevice(void)
 {
-    VkDeviceQueueCreateInfo deviceQueueCreateInfo[1] = {0};
+    VkDeviceQueueCreateInfo deviceQueueCreateInfo[1] = { {0} };
     static const float queuePriority[] = {1.0f};
     VkDeviceCreateInfo deviceCreateInfo = {0};
     static const char *const deviceExtensionNames[] = {
         VK_KHR_SWAPCHAIN_EXTENSION_NAME,
     };
-	VkResult result;
+    VkResult result;
 
-	deviceQueueCreateInfo->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
-    deviceQueueCreateInfo->queueFamilyIndex = vulkanContext.graphicsQueueFamilyIndex;
+    deviceQueueCreateInfo->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+    deviceQueueCreateInfo->queueFamilyIndex = vulkanContext->graphicsQueueFamilyIndex;
     deviceQueueCreateInfo->queueCount = 1;
     deviceQueueCreateInfo->pQueuePriorities = &queuePriority[0];
 
@@ -514,13 +465,10 @@ static void createDevice(void)
     deviceCreateInfo.pEnabledFeatures = NULL;
     deviceCreateInfo.enabledExtensionCount = SDL_arraysize(deviceExtensionNames);
     deviceCreateInfo.ppEnabledExtensionNames = deviceExtensionNames;
-    result = vkCreateDevice(
-        vulkanContext.physicalDevice, &deviceCreateInfo, NULL, &vulkanContext.device);
-    if(result != VK_SUCCESS)
-    {
-        vulkanContext.device = VK_NULL_HANDLE;
-        SDL_LogError(
-            SDL_LOG_CATEGORY_APPLICATION, "vkCreateDevice(): %s\n", getVulkanResultString(result));
+    result = vkCreateDevice(vulkanContext->physicalDevice, &deviceCreateInfo, NULL, &vulkanContext->device);
+    if (result != VK_SUCCESS) {
+        vulkanContext->device = VK_NULL_HANDLE;
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "vkCreateDevice(): %s\n", getVulkanResultString(result));
         quit(2);
     }
 }
@@ -528,9 +476,8 @@ static void createDevice(void)
 static void loadDeviceFunctions(void)
 {
 #define VULKAN_DEVICE_FUNCTION(name)                                         \
-    name = (PFN_##name)vkGetDeviceProcAddr(vulkanContext.device, #name);     \
-    if(!name)                                                                \
-    {                                                                        \
+    name = (PFN_##name)vkGetDeviceProcAddr(vulkanContext->device, #name);    \
+    if (!name) {                                                             \
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,                           \
                      "vkGetDeviceProcAddr(device, \"" #name "\") failed\n"); \
         quit(2);                                                             \
@@ -547,28 +494,28 @@ static void loadDeviceFunctions(void)
 
 static void getQueues(void)
 {
-    vkGetDeviceQueue(vulkanContext.device,
-                     vulkanContext.graphicsQueueFamilyIndex,
+    vkGetDeviceQueue(vulkanContext->device,
+                     vulkanContext->graphicsQueueFamilyIndex,
                      0,
-                     &vulkanContext.graphicsQueue);
-    if(vulkanContext.graphicsQueueFamilyIndex != vulkanContext.presentQueueFamilyIndex)
-        vkGetDeviceQueue(vulkanContext.device,
-                         vulkanContext.presentQueueFamilyIndex,
+                     &vulkanContext->graphicsQueue);
+    if (vulkanContext->graphicsQueueFamilyIndex != vulkanContext->presentQueueFamilyIndex) {
+        vkGetDeviceQueue(vulkanContext->device,
+                         vulkanContext->presentQueueFamilyIndex,
                          0,
-                         &vulkanContext.presentQueue);
-    else
-        vulkanContext.presentQueue = vulkanContext.graphicsQueue;
+                         &vulkanContext->presentQueue);
+    } else {
+        vulkanContext->presentQueue = vulkanContext->graphicsQueue;
+    }
 }
 
 static void createSemaphore(VkSemaphore *semaphore)
 {
-	VkResult result;
+    VkResult result;
 
     VkSemaphoreCreateInfo createInfo = {0};
     createInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
-    result = vkCreateSemaphore(vulkanContext.device, &createInfo, NULL, semaphore);
-    if(result != VK_SUCCESS)
-    {
+    result = vkCreateSemaphore(vulkanContext->device, &createInfo, NULL, semaphore);
+    if (result != VK_SUCCESS) {
         *semaphore = VK_NULL_HANDLE;
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                      "vkCreateSemaphore(): %s\n",
@@ -579,16 +526,14 @@ static void createSemaphore(VkSemaphore *semaphore)
 
 static void createSemaphores(void)
 {
-    createSemaphore(&vulkanContext.imageAvailableSemaphore);
-    createSemaphore(&vulkanContext.renderingFinishedSemaphore);
+    createSemaphore(&vulkanContext->imageAvailableSemaphore);
+    createSemaphore(&vulkanContext->renderingFinishedSemaphore);
 }
 
 static void getSurfaceCaps(void)
 {
-    VkResult result = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
-        vulkanContext.physicalDevice, vulkanContext.surface, &vulkanContext.surfaceCapabilities);
-    if(result != VK_SUCCESS)
-    {
+    VkResult result = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(vulkanContext->physicalDevice, vulkanContext->surface, &vulkanContext->surfaceCapabilities);
+    if (result != VK_SUCCESS) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                      "vkGetPhysicalDeviceSurfaceCapabilitiesKHR(): %s\n",
                      getVulkanResultString(result));
@@ -596,8 +541,7 @@ static void getSurfaceCaps(void)
     }
 
     // check surface usage
-    if(!(vulkanContext.surfaceCapabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT))
-    {
+    if (!(vulkanContext->surfaceCapabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT)) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                      "Vulkan surface doesn't support VK_IMAGE_USAGE_TRANSFER_DST_BIT\n");
         quit(2);
@@ -606,38 +550,33 @@ static void getSurfaceCaps(void)
 
 static void getSurfaceFormats(void)
 {
-    VkResult result = vkGetPhysicalDeviceSurfaceFormatsKHR(vulkanContext.physicalDevice,
-                                                           vulkanContext.surface,
-                                                           &vulkanContext.surfaceFormatsCount,
+    VkResult result = vkGetPhysicalDeviceSurfaceFormatsKHR(vulkanContext->physicalDevice,
+                                                           vulkanContext->surface,
+                                                           &vulkanContext->surfaceFormatsCount,
                                                            NULL);
-    if(result != VK_SUCCESS)
-    {
-        vulkanContext.surfaceFormatsCount = 0;
+    if (result != VK_SUCCESS) {
+        vulkanContext->surfaceFormatsCount = 0;
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                      "vkGetPhysicalDeviceSurfaceFormatsKHR(): %s\n",
                      getVulkanResultString(result));
         quit(2);
     }
-    if(vulkanContext.surfaceFormatsCount > vulkanContext.surfaceFormatsAllocatedCount)
-    {
-        vulkanContext.surfaceFormatsAllocatedCount = vulkanContext.surfaceFormatsCount;
-        SDL_free(vulkanContext.surfaceFormats);
-        vulkanContext.surfaceFormats =
-            SDL_malloc(sizeof(VkSurfaceFormatKHR) * vulkanContext.surfaceFormatsAllocatedCount);
-        if(!vulkanContext.surfaceFormats)
-        {
-            vulkanContext.surfaceFormatsCount = 0;
+    if (vulkanContext->surfaceFormatsCount > vulkanContext->surfaceFormatsAllocatedCount) {
+        vulkanContext->surfaceFormatsAllocatedCount = vulkanContext->surfaceFormatsCount;
+        SDL_free(vulkanContext->surfaceFormats);
+        vulkanContext->surfaceFormats = (VkSurfaceFormatKHR *) SDL_malloc(sizeof(VkSurfaceFormatKHR) * vulkanContext->surfaceFormatsAllocatedCount);
+        if (!vulkanContext->surfaceFormats) {
+            vulkanContext->surfaceFormatsCount = 0;
             SDL_OutOfMemory();
             quit(2);
         }
     }
-    result = vkGetPhysicalDeviceSurfaceFormatsKHR(vulkanContext.physicalDevice,
-                                                  vulkanContext.surface,
-                                                  &vulkanContext.surfaceFormatsCount,
-                                                  vulkanContext.surfaceFormats);
-    if(result != VK_SUCCESS)
-    {
-        vulkanContext.surfaceFormatsCount = 0;
+    result = vkGetPhysicalDeviceSurfaceFormatsKHR(vulkanContext->physicalDevice,
+                                                  vulkanContext->surface,
+                                                  &vulkanContext->surfaceFormatsCount,
+                                                  vulkanContext->surfaceFormats);
+    if (result != VK_SUCCESS) {
+        vulkanContext->surfaceFormatsCount = 0;
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                      "vkGetPhysicalDeviceSurfaceFormatsKHR(): %s\n",
                      getVulkanResultString(result));
@@ -647,35 +586,31 @@ static void getSurfaceFormats(void)
 
 static void getSwapchainImages(void)
 {
-	VkResult result;
+    VkResult result;
 
-    SDL_free(vulkanContext.swapchainImages);
-    vulkanContext.swapchainImages = NULL;
-    result = vkGetSwapchainImagesKHR(
-        vulkanContext.device, vulkanContext.swapchain, &vulkanContext.swapchainImageCount, NULL);
-    if(result != VK_SUCCESS)
-    {
-        vulkanContext.swapchainImageCount = 0;
+    SDL_free(vulkanContext->swapchainImages);
+    vulkanContext->swapchainImages = NULL;
+    result = vkGetSwapchainImagesKHR(vulkanContext->device, vulkanContext->swapchain, &vulkanContext->swapchainImageCount, NULL);
+    if (result != VK_SUCCESS) {
+        vulkanContext->swapchainImageCount = 0;
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                      "vkGetSwapchainImagesKHR(): %s\n",
                      getVulkanResultString(result));
         quit(2);
     }
-    vulkanContext.swapchainImages = SDL_malloc(sizeof(VkImage) * vulkanContext.swapchainImageCount);
-    if(!vulkanContext.swapchainImages)
-    {
+    vulkanContext->swapchainImages = SDL_malloc(sizeof(VkImage) * vulkanContext->swapchainImageCount);
+    if (!vulkanContext->swapchainImages) {
         SDL_OutOfMemory();
         quit(2);
     }
-    result = vkGetSwapchainImagesKHR(vulkanContext.device,
-                                     vulkanContext.swapchain,
-                                     &vulkanContext.swapchainImageCount,
-                                     vulkanContext.swapchainImages);
-    if(result != VK_SUCCESS)
-    {
-        SDL_free(vulkanContext.swapchainImages);
-        vulkanContext.swapchainImages = NULL;
-        vulkanContext.swapchainImageCount = 0;
+    result = vkGetSwapchainImagesKHR(vulkanContext->device,
+                                     vulkanContext->swapchain,
+                                     &vulkanContext->swapchainImageCount,
+                                     vulkanContext->swapchainImages);
+    if (result != VK_SUCCESS) {
+        SDL_free(vulkanContext->swapchainImages);
+        vulkanContext->swapchainImages = NULL;
+        vulkanContext->swapchainImageCount = 0;
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                      "vkGetSwapchainImagesKHR(): %s\n",
                      getVulkanResultString(result));
@@ -685,116 +620,125 @@ static void getSwapchainImages(void)
 
 static SDL_bool createSwapchain(void)
 {
-	uint32_t i;
-	int w, h;
-	VkSwapchainCreateInfoKHR createInfo = {0};
-	VkResult result;
+    uint32_t i;
+    int w, h;
+    VkSwapchainCreateInfoKHR createInfo = {0};
+    VkResult result;
 
     // pick an image count
-    vulkanContext.swapchainDesiredImageCount = vulkanContext.surfaceCapabilities.minImageCount + 1;
-    if(vulkanContext.swapchainDesiredImageCount > vulkanContext.surfaceCapabilities.maxImageCount
-       && vulkanContext.surfaceCapabilities.maxImageCount > 0)
-        vulkanContext.swapchainDesiredImageCount = vulkanContext.surfaceCapabilities.maxImageCount;
+    vulkanContext->swapchainDesiredImageCount = vulkanContext->surfaceCapabilities.minImageCount + 1;
+    if ( (vulkanContext->swapchainDesiredImageCount > vulkanContext->surfaceCapabilities.maxImageCount) &&
+         (vulkanContext->surfaceCapabilities.maxImageCount > 0) ) {
+        vulkanContext->swapchainDesiredImageCount = vulkanContext->surfaceCapabilities.maxImageCount;
+    }
 
     // pick a format
-    if(vulkanContext.surfaceFormatsCount == 1
-       && vulkanContext.surfaceFormats[0].format == VK_FORMAT_UNDEFINED)
-    {
+    if ( (vulkanContext->surfaceFormatsCount == 1) &&
+         (vulkanContext->surfaceFormats[0].format == VK_FORMAT_UNDEFINED) ) {
         // aren't any preferred formats, so we pick
-        vulkanContext.surfaceFormat.colorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
-        vulkanContext.surfaceFormat.format = VK_FORMAT_R8G8B8A8_UNORM;
-    }
-    else
-    {
-        vulkanContext.surfaceFormat = vulkanContext.surfaceFormats[0];
-        for(i = 0; i < vulkanContext.surfaceFormatsCount; i++)
-        {
-            if(vulkanContext.surfaceFormats[i].format == VK_FORMAT_R8G8B8A8_UNORM)
-            {
-                vulkanContext.surfaceFormat = vulkanContext.surfaceFormats[i];
+        vulkanContext->surfaceFormat.colorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
+        vulkanContext->surfaceFormat.format = VK_FORMAT_R8G8B8A8_UNORM;
+    } else {
+        vulkanContext->surfaceFormat = vulkanContext->surfaceFormats[0];
+        for (i = 0; i < vulkanContext->surfaceFormatsCount; i++) {
+            if(vulkanContext->surfaceFormats[i].format == VK_FORMAT_R8G8B8A8_UNORM) {
+                vulkanContext->surfaceFormat = vulkanContext->surfaceFormats[i];
                 break;
             }
         }
     }
 
     // get size
-    SDL_Vulkan_GetDrawableSize(state->windows[0], &w, &h);
-    vulkanContext.swapchainSize.width = w;
-    vulkanContext.swapchainSize.height = h;
-    if(w == 0 || h == 0)
+    SDL_Vulkan_GetDrawableSize(vulkanContext->window, &w, &h);
+
+    // Clamp the size to the allowable image extent.
+    // SDL_Vulkan_GetDrawableSize()'s result it not always in this range (bug #3287)
+    vulkanContext->swapchainSize.width = SDL_clamp((uint32_t) w,
+                                                  vulkanContext->surfaceCapabilities.minImageExtent.width,
+                                                  vulkanContext->surfaceCapabilities.maxImageExtent.width);
+
+    vulkanContext->swapchainSize.height = SDL_clamp((uint32_t) h,
+                                                   vulkanContext->surfaceCapabilities.minImageExtent.height,
+                                                   vulkanContext->surfaceCapabilities.maxImageExtent.height);
+
+    if (w == 0 || h == 0) {
         return SDL_FALSE;
+    }
+
+    getSurfaceCaps();
 
     createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
-    createInfo.surface = vulkanContext.surface;
-    createInfo.minImageCount = vulkanContext.swapchainDesiredImageCount;
-    createInfo.imageFormat = vulkanContext.surfaceFormat.format;
-    createInfo.imageColorSpace = vulkanContext.surfaceFormat.colorSpace;
-    createInfo.imageExtent = vulkanContext.swapchainSize;
+    createInfo.surface = vulkanContext->surface;
+    createInfo.minImageCount = vulkanContext->swapchainDesiredImageCount;
+    createInfo.imageFormat = vulkanContext->surfaceFormat.format;
+    createInfo.imageColorSpace = vulkanContext->surfaceFormat.colorSpace;
+    createInfo.imageExtent = vulkanContext->swapchainSize;
     createInfo.imageArrayLayers = 1;
     createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
     createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
-    createInfo.preTransform = vulkanContext.surfaceCapabilities.currentTransform;
+    createInfo.preTransform = vulkanContext->surfaceCapabilities.currentTransform;
     createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
     createInfo.presentMode = VK_PRESENT_MODE_FIFO_KHR;
     createInfo.clipped = VK_TRUE;
-    createInfo.oldSwapchain = vulkanContext.swapchain;
-    result =
-        vkCreateSwapchainKHR(vulkanContext.device, &createInfo, NULL, &vulkanContext.swapchain);
-    if(createInfo.oldSwapchain)
-        vkDestroySwapchainKHR(vulkanContext.device, createInfo.oldSwapchain, NULL);
-    if(result != VK_SUCCESS)
-    {
-        vulkanContext.swapchain = VK_NULL_HANDLE;
+    createInfo.oldSwapchain = vulkanContext->swapchain;
+    result = vkCreateSwapchainKHR(vulkanContext->device, &createInfo, NULL, &vulkanContext->swapchain);
+
+    if (createInfo.oldSwapchain) {
+        vkDestroySwapchainKHR(vulkanContext->device, createInfo.oldSwapchain, NULL);
+    }
+
+    if(result != VK_SUCCESS) {
+        vulkanContext->swapchain = VK_NULL_HANDLE;
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                      "vkCreateSwapchainKHR(): %s\n",
                      getVulkanResultString(result));
         quit(2);
     }
+
     getSwapchainImages();
     return SDL_TRUE;
 }
 
 static void destroySwapchain(void)
 {
-    if(vulkanContext.swapchain)
-        vkDestroySwapchainKHR(vulkanContext.device, vulkanContext.swapchain, NULL);
-    vulkanContext.swapchain = VK_NULL_HANDLE;
-    SDL_free(vulkanContext.swapchainImages);
-    vulkanContext.swapchainImages = NULL;
+    if (vulkanContext->swapchain) {
+        vkDestroySwapchainKHR(vulkanContext->device, vulkanContext->swapchain, NULL);
+        vulkanContext->swapchain = VK_NULL_HANDLE;
+    }
+    SDL_free(vulkanContext->swapchainImages);
+    vulkanContext->swapchainImages = NULL;
 }
 
 static void destroyCommandBuffers(void)
 {
-    if(vulkanContext.commandBuffers)
-        vkFreeCommandBuffers(vulkanContext.device,
-                             vulkanContext.commandPool,
-                             vulkanContext.swapchainImageCount,
-                             vulkanContext.commandBuffers);
-    SDL_free(vulkanContext.commandBuffers);
-    vulkanContext.commandBuffers = NULL;
+    if (vulkanContext->commandBuffers) {
+        vkFreeCommandBuffers(vulkanContext->device,
+                             vulkanContext->commandPool,
+                             vulkanContext->swapchainImageCount,
+                             vulkanContext->commandBuffers);
+        SDL_free(vulkanContext->commandBuffers);
+        vulkanContext->commandBuffers = NULL;
+    }
 }
 
 static void destroyCommandPool(void)
 {
-    if(vulkanContext.commandPool)
-        vkDestroyCommandPool(vulkanContext.device, vulkanContext.commandPool, NULL);
-    vulkanContext.commandPool = VK_NULL_HANDLE;
+    if (vulkanContext->commandPool) {
+        vkDestroyCommandPool(vulkanContext->device, vulkanContext->commandPool, NULL);
+    }
+    vulkanContext->commandPool = VK_NULL_HANDLE;
 }
 
 static void createCommandPool(void)
 {
-	VkResult result;
-
+    VkResult result;
     VkCommandPoolCreateInfo createInfo = {0};
     createInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
-    createInfo.flags =
-        VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT | VK_COMMAND_POOL_CREATE_TRANSIENT_BIT;
-    createInfo.queueFamilyIndex = vulkanContext.graphicsQueueFamilyIndex;
-    result =
-        vkCreateCommandPool(vulkanContext.device, &createInfo, NULL, &vulkanContext.commandPool);
-    if(result != VK_SUCCESS)
-    {
-        vulkanContext.commandPool = VK_NULL_HANDLE;
+    createInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT | VK_COMMAND_POOL_CREATE_TRANSIENT_BIT;
+    createInfo.queueFamilyIndex = vulkanContext->graphicsQueueFamilyIndex;
+    result = vkCreateCommandPool(vulkanContext->device, &createInfo, NULL, &vulkanContext->commandPool);
+    if (result != VK_SUCCESS) {
+        vulkanContext->commandPool = VK_NULL_HANDLE;
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                      "vkCreateCommandPool(): %s\n",
                      getVulkanResultString(result));
@@ -804,21 +748,17 @@ static void createCommandPool(void)
 
 static void createCommandBuffers(void)
 {
-	VkResult result;
-
+    VkResult result;
     VkCommandBufferAllocateInfo allocateInfo = {0};
     allocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
-    allocateInfo.commandPool = vulkanContext.commandPool;
+    allocateInfo.commandPool = vulkanContext->commandPool;
     allocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
-    allocateInfo.commandBufferCount = vulkanContext.swapchainImageCount;
-    vulkanContext.commandBuffers =
-        SDL_malloc(sizeof(VkCommandBuffer) * vulkanContext.swapchainImageCount);
-    result =
-        vkAllocateCommandBuffers(vulkanContext.device, &allocateInfo, vulkanContext.commandBuffers);
-    if(result != VK_SUCCESS)
-    {
-        SDL_free(vulkanContext.commandBuffers);
-        vulkanContext.commandBuffers = NULL;
+    allocateInfo.commandBufferCount = vulkanContext->swapchainImageCount;
+    vulkanContext->commandBuffers = (VkCommandBuffer *) SDL_malloc(sizeof(VkCommandBuffer) * vulkanContext->swapchainImageCount);
+    result = vkAllocateCommandBuffers(vulkanContext->device, &allocateInfo, vulkanContext->commandBuffers);
+    if(result != VK_SUCCESS) {
+        SDL_free(vulkanContext->commandBuffers);
+        vulkanContext->commandBuffers = NULL;
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                      "vkAllocateCommandBuffers(): %s\n",
                      getVulkanResultString(result));
@@ -828,31 +768,25 @@ static void createCommandBuffers(void)
 
 static void createFences(void)
 {
-	uint32_t i;
+    uint32_t i;
 
-    vulkanContext.fences = SDL_malloc(sizeof(VkFence) * vulkanContext.swapchainImageCount);
-    if(!vulkanContext.fences)
-    {
+    vulkanContext->fences = SDL_malloc(sizeof(VkFence) * vulkanContext->swapchainImageCount);
+    if (!vulkanContext->fences) {
         SDL_OutOfMemory();
         quit(2);
     }
-    for(i = 0; i < vulkanContext.swapchainImageCount; i++)
-    {
-		VkResult result;
-
+    for (i = 0; i < vulkanContext->swapchainImageCount; i++) {
+        VkResult result;
         VkFenceCreateInfo createInfo = {0};
         createInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
         createInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
-        result =
-            vkCreateFence(vulkanContext.device, &createInfo, NULL, &vulkanContext.fences[i]);
-        if(result != VK_SUCCESS)
-        {
-            for(; i > 0; i--)
-            {
-                vkDestroyFence(vulkanContext.device, vulkanContext.fences[i - 1], NULL);
+        result = vkCreateFence(vulkanContext->device, &createInfo, NULL, &vulkanContext->fences[i]);
+        if(result != VK_SUCCESS) {
+            for(; i > 0; i--) {
+                vkDestroyFence(vulkanContext->device, vulkanContext->fences[i - 1], NULL);
             }
-            SDL_free(vulkanContext.fences);
-            vulkanContext.fences = NULL;
+            SDL_free(vulkanContext->fences);
+            vulkanContext->fences = NULL;
             SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                          "vkCreateFence(): %s\n",
                          getVulkanResultString(result));
@@ -863,16 +797,17 @@ static void createFences(void)
 
 static void destroyFences(void)
 {
-	uint32_t i;
+    uint32_t i;
 
-    if(!vulkanContext.fences)
+    if (!vulkanContext->fences) {
         return;
-    for(i = 0; i < vulkanContext.swapchainImageCount; i++)
-    {
-        vkDestroyFence(vulkanContext.device, vulkanContext.fences[i], NULL);
     }
-    SDL_free(vulkanContext.fences);
-    vulkanContext.fences = NULL;
+
+    for (i = 0; i < vulkanContext->swapchainImageCount; i++) {
+        vkDestroyFence(vulkanContext->device, vulkanContext->fences[i], NULL);
+    }
+    SDL_free(vulkanContext->fences);
+    vulkanContext->fences = NULL;
 }
 
 static void recordPipelineImageBarrier(VkCommandBuffer commandBuffer,
@@ -910,14 +845,13 @@ static void recordPipelineImageBarrier(VkCommandBuffer commandBuffer,
 
 static void rerecordCommandBuffer(uint32_t frameIndex, const VkClearColorValue *clearColor)
 {
-    VkCommandBuffer commandBuffer = vulkanContext.commandBuffers[frameIndex];
-    VkImage image = vulkanContext.swapchainImages[frameIndex];
-	VkCommandBufferBeginInfo beginInfo = {0};
+    VkCommandBuffer commandBuffer = vulkanContext->commandBuffers[frameIndex];
+    VkImage image = vulkanContext->swapchainImages[frameIndex];
+    VkCommandBufferBeginInfo beginInfo = {0};
     VkImageSubresourceRange clearRange = {0};
 
     VkResult result = vkResetCommandBuffer(commandBuffer, 0);
-    if(result != VK_SUCCESS)
-    {
+    if(result != VK_SUCCESS) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                      "vkResetCommandBuffer(): %s\n",
                      getVulkanResultString(result));
@@ -926,8 +860,7 @@ static void rerecordCommandBuffer(uint32_t frameIndex, const VkClearColorValue *
     beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
     beginInfo.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;
     result = vkBeginCommandBuffer(commandBuffer, &beginInfo);
-    if(result != VK_SUCCESS)
-    {
+    if (result != VK_SUCCESS) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                      "vkBeginCommandBuffer(): %s\n",
                      getVulkanResultString(result));
@@ -944,8 +877,7 @@ static void rerecordCommandBuffer(uint32_t frameIndex, const VkClearColorValue *
     clearRange.levelCount = 1;
     clearRange.baseArrayLayer = 0;
     clearRange.layerCount = 1;
-    vkCmdClearColorImage(
-        commandBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, clearColor, 1, &clearRange);
+    vkCmdClearColorImage(commandBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, clearColor, 1, &clearRange);
     recordPipelineImageBarrier(commandBuffer,
                                VK_ACCESS_TRANSFER_WRITE_BIT,
                                VK_ACCESS_MEMORY_READ_BIT,
@@ -953,8 +885,7 @@ static void rerecordCommandBuffer(uint32_t frameIndex, const VkClearColorValue *
                                VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
                                image);
     result = vkEndCommandBuffer(commandBuffer);
-    if(result != VK_SUCCESS)
-    {
+    if (result != VK_SUCCESS) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                      "vkEndCommandBuffer(): %s\n",
                      getVulkanResultString(result));
@@ -964,11 +895,13 @@ static void rerecordCommandBuffer(uint32_t frameIndex, const VkClearColorValue *
 
 static void destroySwapchainAndSwapchainSpecificStuff(SDL_bool doDestroySwapchain)
 {
+    vkDeviceWaitIdle(vulkanContext->device);
     destroyFences();
     destroyCommandBuffers();
     destroyCommandPool();
-    if(doDestroySwapchain)
+    if (doDestroySwapchain) {
         destroySwapchain();
+    }
 }
 
 static SDL_bool createNewSwapchainAndSwapchainSpecificStuff(void)
@@ -976,8 +909,9 @@ static SDL_bool createNewSwapchainAndSwapchainSpecificStuff(void)
     destroySwapchainAndSwapchainSpecificStuff(SDL_FALSE);
     getSurfaceCaps();
     getSurfaceFormats();
-    if(!createSwapchain())
+    if(!createSwapchain()) {
         return SDL_FALSE;
+    }
     createCommandPool();
     createCommandBuffers();
     createFences();
@@ -986,36 +920,70 @@ static SDL_bool createNewSwapchainAndSwapchainSpecificStuff(void)
 
 static void initVulkan(void)
 {
+    int i;
+
     SDL_Vulkan_LoadLibrary(NULL);
-    SDL_memset(&vulkanContext, 0, sizeof(VulkanContext));
-    loadGlobalFunctions();
-    createInstance();
-    loadInstanceFunctions();
-    createSurface();
-    findPhysicalDevice();
-    createDevice();
-    loadDeviceFunctions();
-    getQueues();
-    createSemaphores();
-    createNewSwapchainAndSwapchainSpecificStuff();
+
+    vulkanContexts = (VulkanContext *) SDL_calloc(state->num_windows, sizeof (VulkanContext));
+    if (!vulkanContexts) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Out of memory!");
+        quit(2);
+    }
+
+    for (i = 0; i < state->num_windows; ++i) {
+        vulkanContext = &vulkanContexts[i];
+        vulkanContext->window = state->windows[i];
+        loadGlobalFunctions();
+        createInstance();
+        loadInstanceFunctions();
+        createSurface();
+        findPhysicalDevice();
+        createDevice();
+        loadDeviceFunctions();
+        getQueues();
+        createSemaphores();
+        createNewSwapchainAndSwapchainSpecificStuff();
+    }
 }
 
-static void shutdownVulkan(void)
+static void shutdownVulkan(SDL_bool doDestroySwapchain)
 {
-    if(vulkanContext.device && vkDeviceWaitIdle)
-        vkDeviceWaitIdle(vulkanContext.device);
-    destroySwapchainAndSwapchainSpecificStuff(SDL_TRUE);
-    if(vulkanContext.imageAvailableSemaphore && vkDestroySemaphore)
-        vkDestroySemaphore(vulkanContext.device, vulkanContext.imageAvailableSemaphore, NULL);
-    if(vulkanContext.renderingFinishedSemaphore && vkDestroySemaphore)
-        vkDestroySemaphore(vulkanContext.device, vulkanContext.renderingFinishedSemaphore, NULL);
-    if(vulkanContext.device && vkDestroyDevice)
-        vkDestroyDevice(vulkanContext.device, NULL);
-    if(vulkanContext.surface && vkDestroySurfaceKHR)
-        vkDestroySurfaceKHR(vulkanContext.instance, vulkanContext.surface, NULL);
-    if(vulkanContext.instance && vkDestroyInstance)
-        vkDestroyInstance(vulkanContext.instance, NULL);
-    SDL_free(vulkanContext.surfaceFormats);
+    if (vulkanContexts) {
+        int i;
+        for (i = 0; i < state->num_windows; ++i) {
+            vulkanContext = &vulkanContexts[i];
+            if (vulkanContext->device && vkDeviceWaitIdle) {
+                vkDeviceWaitIdle(vulkanContext->device);
+            }
+
+            destroySwapchainAndSwapchainSpecificStuff(doDestroySwapchain);
+
+            if (vulkanContext->imageAvailableSemaphore && vkDestroySemaphore) {
+                vkDestroySemaphore(vulkanContext->device, vulkanContext->imageAvailableSemaphore, NULL);
+            }
+
+            if (vulkanContext->renderingFinishedSemaphore && vkDestroySemaphore) {
+                vkDestroySemaphore(vulkanContext->device, vulkanContext->renderingFinishedSemaphore, NULL);
+            }
+
+            if (vulkanContext->device && vkDestroyDevice) {
+                vkDestroyDevice(vulkanContext->device, NULL);
+            }
+
+            if (vulkanContext->surface && vkDestroySurfaceKHR) {
+                vkDestroySurfaceKHR(vulkanContext->instance, vulkanContext->surface, NULL);
+            }
+
+            if (vulkanContext->instance && vkDestroyInstance) {
+                vkDestroyInstance(vulkanContext->instance, NULL);
+            }
+
+            SDL_free(vulkanContext->surfaceFormats);
+        }
+        SDL_free(vulkanContexts);
+        vulkanContexts = NULL;
+    }
+
     SDL_Vulkan_UnloadLibrary();
 }
 
@@ -1024,47 +992,42 @@ static SDL_bool render(void)
     uint32_t frameIndex;
     VkResult result;
     double currentTime;
-    VkClearColorValue clearColor = {0};
+    VkClearColorValue clearColor = { {0} };
     VkPipelineStageFlags waitDestStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
     VkSubmitInfo submitInfo = {0};
     VkPresentInfoKHR presentInfo = {0};
     int w, h;
 
-    if(!vulkanContext.swapchain)
-    {
+    if (!vulkanContext->swapchain) {
         SDL_bool retval = createNewSwapchainAndSwapchainSpecificStuff();
         if(!retval)
             SDL_Delay(100);
         return retval;
     }
-    result = vkAcquireNextImageKHR(vulkanContext.device,
-                                            vulkanContext.swapchain,
+    result = vkAcquireNextImageKHR(vulkanContext->device,
+                                            vulkanContext->swapchain,
                                             UINT64_MAX,
-                                            vulkanContext.imageAvailableSemaphore,
+                                            vulkanContext->imageAvailableSemaphore,
                                             VK_NULL_HANDLE,
                                             &frameIndex);
-    if(result == VK_ERROR_OUT_OF_DATE_KHR)
+    if (result == VK_ERROR_OUT_OF_DATE_KHR) {
         return createNewSwapchainAndSwapchainSpecificStuff();
-    if(result != VK_SUBOPTIMAL_KHR && result != VK_SUCCESS)
-    {
+    }
+
+    if ((result != VK_SUBOPTIMAL_KHR) && (result != VK_SUCCESS)) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                      "vkAcquireNextImageKHR(): %s\n",
                      getVulkanResultString(result));
         quit(2);
     }
-    result = vkWaitForFences(
-        vulkanContext.device, 1, &vulkanContext.fences[frameIndex], VK_FALSE, UINT64_MAX);
-    if(result != VK_SUCCESS)
-    {
-        SDL_LogError(
-            SDL_LOG_CATEGORY_APPLICATION, "vkWaitForFences(): %s\n", getVulkanResultString(result));
+    result = vkWaitForFences(vulkanContext->device, 1, &vulkanContext->fences[frameIndex], VK_FALSE, UINT64_MAX);
+    if (result != VK_SUCCESS) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "vkWaitForFences(): %s\n", getVulkanResultString(result));
         quit(2);
     }
-    result = vkResetFences(vulkanContext.device, 1, &vulkanContext.fences[frameIndex]);
-    if(result != VK_SUCCESS)
-    {
-        SDL_LogError(
-            SDL_LOG_CATEGORY_APPLICATION, "vkResetFences(): %s\n", getVulkanResultString(result));
+    result = vkResetFences(vulkanContext->device, 1, &vulkanContext->fences[frameIndex]);
+    if (result != VK_SUCCESS) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "vkResetFences(): %s\n", getVulkanResultString(result));
         quit(2);
     }
     currentTime = (double)SDL_GetPerformanceCounter() / SDL_GetPerformanceFrequency();
@@ -1075,49 +1038,44 @@ static SDL_bool render(void)
     rerecordCommandBuffer(frameIndex, &clearColor);
     submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
     submitInfo.waitSemaphoreCount = 1;
-    submitInfo.pWaitSemaphores = &vulkanContext.imageAvailableSemaphore;
+    submitInfo.pWaitSemaphores = &vulkanContext->imageAvailableSemaphore;
     submitInfo.pWaitDstStageMask = &waitDestStageMask;
     submitInfo.commandBufferCount = 1;
-    submitInfo.pCommandBuffers = &vulkanContext.commandBuffers[frameIndex];
+    submitInfo.pCommandBuffers = &vulkanContext->commandBuffers[frameIndex];
     submitInfo.signalSemaphoreCount = 1;
-    submitInfo.pSignalSemaphores = &vulkanContext.renderingFinishedSemaphore;
-    result = vkQueueSubmit(
-        vulkanContext.graphicsQueue, 1, &submitInfo, vulkanContext.fences[frameIndex]);
-    if(result != VK_SUCCESS)
-    {
-        SDL_LogError(
-            SDL_LOG_CATEGORY_APPLICATION, "vkQueueSubmit(): %s\n", getVulkanResultString(result));
+    submitInfo.pSignalSemaphores = &vulkanContext->renderingFinishedSemaphore;
+    result = vkQueueSubmit(vulkanContext->graphicsQueue, 1, &submitInfo, vulkanContext->fences[frameIndex]);
+
+    if (result != VK_SUCCESS) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "vkQueueSubmit(): %s\n", getVulkanResultString(result));
         quit(2);
     }
     presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
     presentInfo.waitSemaphoreCount = 1;
-    presentInfo.pWaitSemaphores = &vulkanContext.renderingFinishedSemaphore;
+    presentInfo.pWaitSemaphores = &vulkanContext->renderingFinishedSemaphore;
     presentInfo.swapchainCount = 1;
-    presentInfo.pSwapchains = &vulkanContext.swapchain;
+    presentInfo.pSwapchains = &vulkanContext->swapchain;
     presentInfo.pImageIndices = &frameIndex;
-    result = vkQueuePresentKHR(vulkanContext.presentQueue, &presentInfo);
-    if(result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR)
-    {
+    result = vkQueuePresentKHR(vulkanContext->presentQueue, &presentInfo);
+    if ((result == VK_ERROR_OUT_OF_DATE_KHR) || (result == VK_SUBOPTIMAL_KHR)) {
         return createNewSwapchainAndSwapchainSpecificStuff();
     }
-    if(result != VK_SUCCESS)
-    {
+
+    if (result != VK_SUCCESS) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                      "vkQueuePresentKHR(): %s\n",
                      getVulkanResultString(result));
         quit(2);
     }
-    SDL_Vulkan_GetDrawableSize(state->windows[0], &w, &h);
-    if(w != (int)vulkanContext.swapchainSize.width || h != (int)vulkanContext.swapchainSize.height)
-    {
+    SDL_Vulkan_GetDrawableSize(vulkanContext->window, &w, &h);
+    if(w != (int)vulkanContext->swapchainSize.width || h != (int)vulkanContext->swapchainSize.height) {
         return createNewSwapchainAndSwapchainSpecificStuff();
     }
     return SDL_TRUE;
 }
 
-int main(int argc, char *argv[])
+int main(int argc, char **argv)
 {
-    int fsaa, accel;
     int done;
     SDL_DisplayMode mode;
     SDL_Event event;
@@ -1127,20 +1085,14 @@ int main(int argc, char *argv[])
     /* Enable standard application logging */
     SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
 
-    /* Initialize parameters */
-    fsaa = 0;
-    accel = -1;
-
     /* Initialize test framework */
     state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO);
-    if(!state)
-    {
+    if(!state) {
         return 1;
     }
 
     /* Set Vulkan parameters */
     state->window_flags |= SDL_WINDOW_VULKAN;
-    state->num_windows = 1;
     state->skip_renderer = 1;
 
     if (!SDLTest_CommonDefaultArgs(state, argc, argv) || !SDLTest_CommonInit(state)) {
@@ -1162,26 +1114,38 @@ int main(int argc, char *argv[])
     frames = 0;
     then = SDL_GetTicks();
     done = 0;
-    while(!done)
-    {
+    while (!done) {
         /* Check for events */
-        ++frames;
-        while(SDL_PollEvent(&event))
-        {
+        frames++;
+        while(SDL_PollEvent(&event)) {
+            /* Need to destroy the swapchain before the window created
+             * by SDL.
+             */
+            if (event.type == SDL_WINDOWEVENT_CLOSE) {
+                destroySwapchainAndSwapchainSpecificStuff(SDL_TRUE);
+            }
             SDLTest_CommonEvent(state, &event, &done);
         }
 
-        if(!done)
-            render();
+        if (!done) {
+            int i;
+            for (i = 0; i < state->num_windows; ++i) {
+                if (state->windows[i]) {
+                    vulkanContext = &vulkanContexts[i];
+                    render();
+                }
+            }
+        }
     }
 
     /* Print out some timing information */
     now = SDL_GetTicks();
-    if(now > then)
-    {
+    if (now > then) {
         SDL_Log("%2.2f frames per second\n", ((double)frames * 1000) / (now - then));
     }
-    quit(0);
+
+    shutdownVulkan(SDL_TRUE);
+    SDLTest_CommonQuit(state);
     return 0;
 }
 
diff --git a/Engine/lib/sdl/test/testwm2.c b/Engine/lib/sdl/test/testwm2.c
index 2d3779b90..93bedf47b 100644
--- a/Engine/lib/sdl/test/testwm2.c
+++ b/Engine/lib/sdl/test/testwm2.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -18,6 +18,7 @@
 #endif
 
 #include "SDL_test_common.h"
+#include "SDL_test_font.h"
 
 static SDLTest_CommonState *state;
 int done;
@@ -38,6 +39,8 @@ static const char *cursorNames[] = {
 };
 int system_cursor = -1;
 SDL_Cursor *cursor = NULL;
+SDL_bool relative_mode = SDL_FALSE;
+int highlighted_mode = -1;
 
 /* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */
 static void
@@ -47,6 +50,99 @@ quit(int rc)
     exit(rc);
 }
 
+/* Draws the modes menu, and stores the mode index under the mouse in highlighted_mode */
+static void
+draw_modes_menu(SDL_Window *window, SDL_Renderer *renderer, SDL_Rect viewport)
+{
+    SDL_DisplayMode mode;
+    char text[1024];
+    const int lineHeight = 10;
+    const int display_index = SDL_GetWindowDisplayIndex(window);
+    const int num_modes = SDL_GetNumDisplayModes(display_index);
+    int i;
+    int column_chars = 0;
+    int text_length;
+    int x, y;
+    int table_top;
+    SDL_Point mouse_pos = { -1, -1 };
+
+    /* Get mouse position */
+    if (SDL_GetMouseFocus() == window) {
+        int window_x, window_y;
+        float logical_x, logical_y;
+
+        SDL_GetMouseState(&window_x, &window_y);
+        SDL_RenderWindowToLogical(renderer, window_x, window_y, &logical_x, &logical_y);
+
+        mouse_pos.x = (int)logical_x;
+        mouse_pos.y = (int)logical_y;
+    }
+
+    x = 0;
+    y = viewport.y;
+
+    y += lineHeight;
+
+    SDL_snprintf(text, sizeof(text), "Click on a mode to set it with SDL_SetWindowDisplayMode");
+    SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
+    SDLTest_DrawString(renderer, x, y, text);
+    y += lineHeight;
+
+    SDL_snprintf(text, sizeof(text), "Press Ctrl+Enter to toggle SDL_WINDOW_FULLSCREEN");
+    SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
+    SDLTest_DrawString(renderer, x, y, text);
+    y += lineHeight;
+
+    table_top = y;
+
+    /* Clear the cached mode under the mouse */
+    if (window == SDL_GetMouseFocus()) {
+        highlighted_mode = -1;
+    }
+
+    for (i = 0; i < num_modes; ++i) {
+        SDL_Rect cell_rect;
+
+        if (0 != SDL_GetDisplayMode(display_index, i, &mode)) {
+            return;
+        }
+
+        SDL_snprintf(text, sizeof(text), "%d: %dx%d@%dHz",
+            i, mode.w, mode.h, mode.refresh_rate);
+
+        /* Update column width */
+        text_length = (int)SDL_strlen(text);
+        column_chars = SDL_max(column_chars, text_length);
+
+        /* Check if under mouse */        
+        cell_rect.x = x;
+        cell_rect.y = y;
+        cell_rect.w = text_length * FONT_CHARACTER_SIZE;
+        cell_rect.h = lineHeight;
+
+        if (SDL_PointInRect(&mouse_pos, &cell_rect)) {
+            SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
+
+            /* Update cached mode under the mouse */
+            if (window == SDL_GetMouseFocus()) {
+                highlighted_mode = i;
+            }
+        } else {
+            SDL_SetRenderDrawColor(renderer, 170, 170, 170, 255);
+        }
+
+        SDLTest_DrawString(renderer, x, y, text);
+        y += lineHeight;
+
+        if (y + lineHeight > (viewport.y + viewport.h)) {
+            /* Advance to next column */
+            x += (column_chars + 1) * FONT_CHARACTER_SIZE;
+            y = table_top;
+            column_chars = 0;
+        }
+    }
+}
+
 void
 loop()
 {
@@ -76,6 +172,17 @@ loop()
                             SDL_GetDisplayName(SDL_GetWindowDisplayIndex(window)));
                     }
                 }
+                if (event.window.event == SDL_WINDOWEVENT_FOCUS_LOST) {
+                    relative_mode = SDL_GetRelativeMouseMode();
+                    if (relative_mode) {
+                        SDL_SetRelativeMouseMode(SDL_FALSE);
+                    }
+                }
+                if (event.window.event == SDL_WINDOWEVENT_FOCUS_GAINED) {
+                    if (relative_mode) {
+                        SDL_SetRelativeMouseMode(SDL_TRUE);
+                    }
+                }
             }
             if (event.type == SDL_KEYUP) {
                 SDL_bool updateCursor = SDL_FALSE;
@@ -100,12 +207,43 @@ loop()
                     SDL_SetCursor(cursor);
                 }
             }
+            if (event.type == SDL_MOUSEBUTTONUP) {
+                SDL_Window* window = SDL_GetMouseFocus();
+                if (highlighted_mode != -1 && window != NULL) {
+                    const int display_index = SDL_GetWindowDisplayIndex(window);
+                    SDL_DisplayMode mode;
+                    if (0 != SDL_GetDisplayMode(display_index, highlighted_mode, &mode)) {
+                        SDL_Log("Couldn't get display mode");
+                    } else {
+                        SDL_SetWindowDisplayMode(window, &mode);
+                    }
+                }
+            }
         }
 
         for (i = 0; i < state->num_windows; ++i) {
+            SDL_Window* window = state->windows[i];
             SDL_Renderer *renderer = state->renderers[i];
-            SDL_RenderClear(renderer);
-            SDL_RenderPresent(renderer);
+            if (window != NULL && renderer != NULL) {
+                int y = 0;
+                SDL_Rect viewport, menurect;
+
+                SDL_RenderGetViewport(renderer, &viewport);
+
+                SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
+                SDL_RenderClear(renderer);
+
+                SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
+                SDLTest_CommonDrawWindowInfo(renderer, state->windows[i], &y);
+
+                menurect.x = 0;
+                menurect.y = y;
+                menurect.w = viewport.w;
+                menurect.h = viewport.h - y;
+                draw_modes_menu(window, renderer, menurect);
+
+                SDL_RenderPresent(renderer);
+            }
         }
 #ifdef __EMSCRIPTEN__
     if (done) {
diff --git a/Engine/lib/sdl/test/testyuv.c b/Engine/lib/sdl/test/testyuv.c
index 0c12b8ede..9c89c3140 100644
--- a/Engine/lib/sdl/test/testyuv.c
+++ b/Engine/lib/sdl/test/testyuv.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/testyuv_cvt.c b/Engine/lib/sdl/test/testyuv_cvt.c
index 4d856cae3..ed354d8ac 100644
--- a/Engine/lib/sdl/test/testyuv_cvt.c
+++ b/Engine/lib/sdl/test/testyuv_cvt.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -31,9 +31,9 @@ static void RGBtoYUV(Uint8 * rgb, int *yuv, SDL_YUV_CONVERSION_MODE mode, int mo
         // This formula is from Microsoft's documentation:
         // https://msdn.microsoft.com/en-us/library/windows/desktop/dd206750(v=vs.85).aspx
         // L = Kr * R + Kb * B + (1 - Kr - Kb) * G
-        // Y =                   floor(2^(M-8) * (219*(L-Z)/S + 16) + 0.5);
-        // U = clip3(0, (2^M)-1, floor(2^(M-8) * (112*(B-L) / ((1-Kb)*S) + 128) + 0.5));
-        // V = clip3(0, (2^M)-1, floor(2^(M-8) * (112*(R-L) / ((1-Kr)*S) + 128) + 0.5));
+        // Y =                   SDL_floor(2^(M-8) * (219*(L-Z)/S + 16) + 0.5);
+        // U = clip3(0, (2^M)-1, SDL_floor(2^(M-8) * (112*(B-L) / ((1-Kb)*S) + 128) + 0.5));
+        // V = clip3(0, (2^M)-1, SDL_floor(2^(M-8) * (112*(R-L) / ((1-Kr)*S) + 128) + 0.5));
         float S, Z, R, G, B, L, Kr, Kb, Y, U, V;
 
         if (mode == SDL_YUV_CONVERSION_BT709) {
diff --git a/Engine/lib/sdl/test/testyuv_cvt.h b/Engine/lib/sdl/test/testyuv_cvt.h
index 3896a8dec..57ddb7648 100644
--- a/Engine/lib/sdl/test/testyuv_cvt.h
+++ b/Engine/lib/sdl/test/testyuv_cvt.h
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/torturethread.c b/Engine/lib/sdl/test/torturethread.c
index 382a2ede1..d76f07755 100644
--- a/Engine/lib/sdl/test/torturethread.c
+++ b/Engine/lib/sdl/test/torturethread.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
diff --git a/Engine/lib/sdl/test/unifont-13.0.06-license.txt b/Engine/lib/sdl/test/unifont-13.0.06-license.txt
new file mode 100644
index 000000000..94339e0f4
--- /dev/null
+++ b/Engine/lib/sdl/test/unifont-13.0.06-license.txt
@@ -0,0 +1,90 @@
+The SIL Open Font License version 1.1 is copied below, and is also
+available with a FAQ at http://scripts.sil.org/OFL.
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
diff --git a/Engine/lib/sdl/test/unifont-13.0.06.hex b/Engine/lib/sdl/test/unifont-13.0.06.hex
new file mode 100644
index 000000000..320686a0c
--- /dev/null
+++ b/Engine/lib/sdl/test/unifont-13.0.06.hex
@@ -0,0 +1,57086 @@
+0000:AAAA00018000000180004A51EA505A51C99E0001800000018000000180005555
+0001:AAAA00018000000180003993C252325F8A527193800000018000000180005555
+0002:AAAA00018000000180003BA5C124311989247125800000018000000180005555
+0003:AAAA00018000000180007BA5C1247919C1247925800000018000000180005555
+0004:AAAA000180000001800079BFC2487A49C2487989800000018000000180005555
+0005:AAAA00018000000180007A4DC2527B53C2D67A4F800000018000000180005555
+0006:AAAA000180000001800031A5CA287A31CA2849A5800000018000000180005555
+0007:AAAA000180000001800073D1CA1073D1CA1073DF800000018000000180005555
+0008:AAAA00018000000180001E3991401E3191081E71800000018000000180005555
+0009:AAAA000180000001800022F9A2203E21A2202221800000018000000180005555
+000A:AAAA000180000001800020F9A08020F9A0803E81800000018000000180005555
+000B:AAAA000180000001800022F9A220222194200821800000018000000180005555
+000C:AAAA00018000000180003EF9A0803EF9A0802081800000018000000180005555
+000D:AAAA00018000000180001EF1A08820F1A0901E89800000018000000180005555
+000E:AAAA00018000000180001E71A0881C8982883C71800000018000000180005555
+000F:AAAA00018000000180001EF9A0201C2182203CF9800000018000000180005555
+0010:AAAA0001800000018000391DA510251DA51039DD800000018000000180005555
+0011:AAAA00018000000180007189CA184A09CA08719D800000018000000180005555
+0012:AAAA00018000000180007199CA044A09CA10719D800000018000000180005555
+0013:AAAA00018000000180007199CA044A19CA047199800000018000000180005555
+0014:AAAA00018000000180007185CA0C4A15CA1C7185800000018000000180005555
+0015:AAAA00018000000180004993EA546A59DBD44A53800000018000000180005555
+0016:AAAA00018000000180003453C29A311789127113800000018000000180005555
+0017:AAAA00018000000180007BB9C1247939C1247939800000018000000180005555
+0018:AAAA00018000000180003325C4B447ADC4A434A5800000018000000180005555
+0019:AAAA00018000000180003E89A0D83EA9A0883E89800000018000000180005555
+001A:AAAA00018000000180003A5DC252325D8A52719D800000018000000180005555
+001B:AAAA000180000001800079CFC2107991C0507B8F800000018000000180005555
+001C:AAAA00018000000180001E7190801E61901010E1800000018000000180005555
+001D:AAAA00018000000180000E719080166192100EE1800000018000000180005555
+001E:AAAA00018000000180001C7192801C61941012E1800000018000000180005555
+001F:AAAA000180000001800012719280126192100CE1800000018000000180005555
+0020:00000000000000000000000000000000
+0021:00000000080808080808080008080000
+0022:00002222222200000000000000000000
+0023:000000001212127E24247E4848480000
+0024:00000000083E4948380E09493E080000
+0025:00000000314A4A340808162929460000
+0026:000000001C2222141829454246390000
+0027:00000808080800000000000000000000
+0028:00000004080810101010101008080400
+0029:00000020101008080808080810102000
+002A:00000000000008492A1C2A4908000000
+002B:0000000000000808087F080808000000
+002C:00000000000000000000000018080810
+002D:0000000000000000003C000000000000
+002E:00000000000000000000000018180000
+002F:00000000020204080810102040400000
+0030:00000000182442464A52624224180000
+0031:000000000818280808080808083E0000
+0032:000000003C4242020C102040407E0000
+0033:000000003C4242021C020242423C0000
+0034:00000000040C142444447E0404040000
+0035:000000007E4040407C020202423C0000
+0036:000000001C2040407C424242423C0000
+0037:000000007E0202040404080808080000
+0038:000000003C4242423C424242423C0000
+0039:000000003C4242423E02020204380000
+003A:00000000000018180000001818000000
+003B:00000000000018180000001808081000
+003C:00000000000204081020100804020000
+003D:000000000000007E0000007E00000000
+003E:00000000004020100804081020400000
+003F:000000003C4242020408080008080000
+0040:000000001C224A565252524E201E0000
+0041:0000000018242442427E424242420000
+0042:000000007C4242427C424242427C0000
+0043:000000003C42424040404042423C0000
+0044:00000000784442424242424244780000
+0045:000000007E4040407C404040407E0000
+0046:000000007E4040407C40404040400000
+0047:000000003C424240404E4242463A0000
+0048:00000000424242427E42424242420000
+0049:000000003E08080808080808083E0000
+004A:000000001F0404040404044444380000
+004B:00000000424448506060504844420000
+004C:000000004040404040404040407E0000
+004D:00000000424266665A5A424242420000
+004E:0000000042626252524A4A4646420000
+004F:000000003C42424242424242423C0000
+0050:000000007C4242427C40404040400000
+0051:000000003C4242424242425A663C0300
+0052:000000007C4242427C48444442420000
+0053:000000003C424240300C0242423C0000
+0054:000000007F0808080808080808080000
+0055:000000004242424242424242423C0000
+0056:00000000414141222222141408080000
+0057:00000000424242425A5A666642420000
+0058:00000000424224241818242442420000
+0059:00000000414122221408080808080000
+005A:000000007E02020408102040407E0000
+005B:0000000E080808080808080808080E00
+005C:00000000404020101008080402020000
+005D:00000070101010101010101010107000
+005E:00001824420000000000000000000000
+005F:00000000000000000000000000007F00
+0060:00201008000000000000000000000000
+0061:0000000000003C42023E4242463A0000
+0062:0000004040405C6242424242625C0000
+0063:0000000000003C4240404040423C0000
+0064:0000000202023A4642424242463A0000
+0065:0000000000003C42427E4040423C0000
+0066:0000000C1010107C1010101010100000
+0067:0000000000023A44444438203C42423C
+0068:0000004040405C624242424242420000
+0069:000000080800180808080808083E0000
+006A:0000000404000C040404040404044830
+006B:00000040404044485060504844420000
+006C:000000180808080808080808083E0000
+006D:00000000000076494949494949490000
+006E:0000000000005C624242424242420000
+006F:0000000000003C4242424242423C0000
+0070:0000000000005C6242424242625C4040
+0071:0000000000003A4642424242463A0202
+0072:0000000000005C624240404040400000
+0073:0000000000003C4240300C02423C0000
+0074:000000001010107C10101010100C0000
+0075:000000000000424242424242463A0000
+0076:00000000000042424224242418180000
+0077:00000000000041494949494949360000
+0078:00000000000042422418182442420000
+0079:0000000000004242424242261A02023C
+007A:0000000000007E0204081020407E0000
+007B:0000000C10100808102010080810100C
+007C:00000808080808080808080808080808
+007D:00000030080810100804081010080830
+007E:00000031494600000000000000000000
+007F:AAAA000180000001800073D1CA104BD1CA1073DF800000018000000180005555
+0080:AAAA0001800000018000719DCA5273D3C252425D800000018000000180005555
+0081:AAAA0001800000018000499DCA527A5DCA504991800000018000000180005555
+0082:AAAA00018000000180007393CA52739FCA127213800000018000000180005555
+0083:AAAA00018000000180004B93EA525B9FCA524B93800000018000000180005555
+0084:AAAA000180000001800074B9A6A425A5A4A474B9800000018000000180005555
+0085:AAAA00018000000180004BD1EA105BD1CA104BDF800000018000000180005555
+0086:AAAA000180000001800039CDC212319F88527393800000018000000180005555
+0087:AAAA000180000001800079CDC212799FC0527B93800000018000000180005555
+0088:AAAA00018000000180004B9DC9207919C9044939800000018000000180005555
+0089:AAAA000180000001800025DDA4843C85A4842499800000018000000180005555
+008A:AAAA000180000001800045CDC4904489A8841099800000018000000180005555
+008B:AAAA0001800000018000721DCA127213C21243DD800000018000000180005555
+008C:AAAA00018000000180007213CA127213C21243CD800000018000000180005555
+008D:AAAA00018000000180000E2189200E218A200921800000018000000180005555
+008E:AAAA000180000001800039DDC202318D8850739F800000018000000180005555
+008F:AAAA000180000001800039DDC202318D8842739D800000018000000180005555
+0090:AAAA000180000001800071CFCA104A0DCA0271DD800000018000000180005555
+0091:AAAA00018000000180007245CA4C7245C244418F800000018000000180005555
+0092:AAAA0001800000018000725DCA42724DC250419F800000018000000180005555
+0093:AAAA00018000000180003B9DC120311989047139800000018000000180005555
+0094:AAAA000180000001800039D3C212421FC21239D3800000018000000180005555
+0095:AAAA00018000000180002289B6882AA9A2D82289800000018000000180005555
+0096:AAAA00018000000180003B8DC252339F8A127213800000018000000180005555
+0097:AAAA00018000000180007B8DC2527B9FC2127A13800000018000000180005555
+0098:AAAA0001800000018000398FC250324D8A42719D800000018000000180005555
+0099:AAAA0001800000018000339BC42225A394A2639B800000018000000180005555
+009A:AAAA000180000001800039DDC20832098A0871DD800000018000000180005555
+009B:AAAA000180000001800039DDC2084189C0483B9D800000018000000180005555
+009C:AAAA00018000000180000EF990200C2182201C21800000018000000180005555
+009D:AAAA000180000001800031CFCA104991C850338F800000018000000180005555
+009E:AAAA00018000000180001C8992D81CA990881089800000018000000180005555
+009F:AAAA0001800000018000338FCA507B91CA104A0F800000018000000180005555
+00A0:00000000000000000000000000000000
+00A1:00000000080800080808080808080000
+00A2:0000000008083E494848493E08080000
+00A3:000000000E1010107C1010103E610000
+00A4:0000000000423C244242243C42000000
+00A5:00000000412214087F087F0808080000
+00A6:00000000080808080000080808080000
+00A7:000000003C42403C42423C02423C0000
+00A8:24240000000000000000000000000000
+00A9:000000003C4299A5A1A1A599423C0000
+00AA:00001C021E221E003E00000000000000
+00AB:00000000001212242448242412120000
+00AC:000000000000000000007E0202020000
+00AD:AAAA000180003A63C25433C98A48724980000001800003C18000000180005555
+00AE:000000003C42B9A5A5B9A9A5423C0000
+00AF:00007E00000000000000000000000000
+00B0:00000000182424180000000000000000
+00B1:000000000808087F080808007F000000
+00B2:0000003844041820407C000000000000
+00B3:00000038440438044438000000000000
+00B4:00040810000000000000000000000000
+00B5:00000000000042424242424266594080
+00B6:000000003F7A7A7A3A0A0A0A0A0A0A00
+00B7:00000000000000001818000000000000
+00B8:00000000000000000000000000000830
+00B9:0000001030501010107C000000000000
+00BA:00001C2222221C003E00000000000000
+00BB:00000000004848242412242448480000
+00BC:00000000226224282812162A4E420000
+00BD:000000002262242828141A22444E0000
+00BE:00000000621224186812162A4E420000
+00BF:000000001010001010204042423C0000
+00C0:300C000018242442427E424242420000
+00C1:0C30000018242442427E424242420000
+00C2:1824000018242442427E424242420000
+00C3:324C000018242442427E424242420000
+00C4:2424000018242442427E424242420000
+00C5:1824180018242442427E424242420000
+00C6:000000001F2848487F484848484F0000
+00C7:000000003C42424040404042423C0830
+00C8:300C00007E4040407C404040407E0000
+00C9:0C3000007E4040407C404040407E0000
+00CA:182400007E4040407C404040407E0000
+00CB:242400007E4040407C404040407E0000
+00CC:180600003E08080808080808083E0000
+00CD:0C3000003E08080808080808083E0000
+00CE:182400003E08080808080808083E0000
+00CF:242400003E08080808080808083E0000
+00D0:0000000078444242F242424244780000
+00D1:324C000042626252524A4A4646420000
+00D2:300C00003C42424242424242423C0000
+00D3:0C3000003C42424242424242423C0000
+00D4:182400003C42424242424242423C0000
+00D5:324C00003C42424242424242423C0000
+00D6:242400003C42424242424242423C0000
+00D7:00000000000000422418244200000000
+00D8:000000023A44464A4A525262225C4000
+00D9:300C00004242424242424242423C0000
+00DA:0C3000004242424242424242423C0000
+00DB:182400004242424242424242423C0000
+00DC:242400004242424242424242423C0000
+00DD:0C300000414122221408080808080000
+00DE:00000040407844424244784040400000
+00DF:000000003844444858444242524C0000
+00E0:0000300C00003C42023E4242463A0000
+00E1:00000C3000003C42023E4242463A0000
+00E2:0000182400003C42023E4242463A0000
+00E3:0000324C00003C42023E4242463A0000
+00E4:0000242400003C42023E4242463A0000
+00E5:0018241800003C42023E4242463A0000
+00E6:0000000000003E49093F4848493E0000
+00E7:0000000000003C4240404040423C0830
+00E8:0000300C00003C42427E4040423C0000
+00E9:00000C3000003C42427E4040423C0000
+00EA:0000182400003C42427E4040423C0000
+00EB:0000242400003C42427E4040423C0000
+00EC:0000300C0000180808080808083E0000
+00ED:00000C300000180808080808083E0000
+00EE:000018240000180808080808083E0000
+00EF:000024240000180808080808083E0000
+00F0:0000320C1422023E42424242423C0000
+00F1:0000324C00005C624242424242420000
+00F2:0000300C00003C4242424242423C0000
+00F3:00000C3000003C4242424242423C0000
+00F4:0000182400003C4242424242423C0000
+00F5:0000324C00003C4242424242423C0000
+00F6:0000242400003C4242424242423C0000
+00F7:0000000000001800007E000018000000
+00F8:0000000000023C464A4A5252623C4000
+00F9:0000300C0000424242424242463A0000
+00FA:00000C300000424242424242463A0000
+00FB:000018240000424242424242463A0000
+00FC:000024240000424242424242463A0000
+00FD:00000C3000004242424242261A02023C
+00FE:0000004040405C6242424242625C4040
+00FF:0000242400004242424242261A02023C
+0100:003C000018242442427E424242420000
+0101:0000003C00003C42023E4242463A0000
+0102:42423C0018242442427E424242420000
+0103:0042423C00003C42023E4242463A0000
+0104:0000000018242442427E424242420403
+0105:0000000000003C42023E4242463A0403
+0106:0C3000003C42424040404042423C0000
+0107:00000C3000003C4240404040423C0000
+0108:182400003C42424040404042423C0000
+0109:0000182400003C4240404040423C0000
+010A:101000003C42424040404042423C0000
+010B:0000101000003C4240404040423C0000
+010C:241800003C42424040404042423C0000
+010D:0000241800003C4240404040423C0000
+010E:48300000784442424242424244780000
+010F:2418000202023A4642424242463A0000
+0110:0000000078444242F242424244780000
+0111:000000020F023A4642424242463A0000
+0112:003C00007E4040407C404040407E0000
+0113:0000003C00003C42427E4040423C0000
+0114:42423C007E4040407C404040407E0000
+0115:000042423C003C42427E4040423C0000
+0116:101000007E4040407C404040407E0000
+0117:0000101000003C42427E4040423C0000
+0118:000000007E4040407C404040407E0806
+0119:0000000000003C42427E4040423C100C
+011A:241800007E4040407C404040407E0000
+011B:0000241800003C42427E4040423C0000
+011C:182400003C424240404E4242463A0000
+011D:0000182400023A44444438203C42423C
+011E:42423C003C424240404E4242463A0000
+011F:0042423C00023A44444438203C42423C
+0120:101000003C424240404E4242463A0000
+0121:0000101000023A44444438203C42423C
+0122:000000003C424240404E4242463A0830
+0123:00000C1000023A44444438203C42423C
+0124:18240000424242427E42424242420000
+0125:3048004040405C624242424242420000
+0126:000000004242FF42427E424242420000
+0127:00000040F0405C624242424242420000
+0128:324C00003E08080808080808083E0000
+0129:0000324C0000180808080808083E0000
+012A:003C00003E08080808080808083E0000
+012B:0000003C0000180808080808083E0000
+012C:42423C003E08080808080808083E0000
+012D:000042423C00180808080808083E0000
+012E:000000003E08080808080808083E0806
+012F:000000080800180808080808083E0806
+0130:080800003E08080808080808083E0000
+0131:000000000000180808080808083E0000
+0132:000000004242424242420202423C0000
+0133:0000222200002222222222221A02221C
+0134:0C1200001F0404040404044444380000
+0135:00000C1200000C040404040404044830
+0136:000000004244485060605048444220C0
+0137:000000404040444850605048444220C0
+0138:00000000000042444870704844420000
+0139:186000004040404040404040407E0000
+013A:0C3000180808080808080808083E0000
+013B:000000004040404040404040407E0830
+013C:000000180808080808080808083E0830
+013D:241800004040404040404040407E0000
+013E:241800180808080808080808083E0000
+013F:000000004040404044444040407E0000
+0140:000000301010101014141010107C0000
+0141:000000004040485060C04040407E0000
+0142:0000001808080A0C18280808083E0000
+0143:0C30000042626252524A4A4646420000
+0144:00000C3000005C624242424242420000
+0145:0000000042626252524A4A46464220C0
+0146:0000000000005C6242424242424220C0
+0147:2418000042626252524A4A4646420000
+0148:0000241800005C624242424242420000
+0149:0060202040005C624242424242420000
+014A:000000005C62424242424242424C0000
+014B:0000000000005C62424242424242020C
+014C:003C00003C42424242424242423C0000
+014D:0000003C00003C4242424242423C0000
+014E:42423C003C42424242424242423C0000
+014F:000042423C003C4242424242423C0000
+0150:334400003C42424242424242423C0000
+0151:0000334400003C4242424242423C0000
+0152:00000000374848484E48484848370000
+0153:0000000000003649494F484849360000
+0154:0C3000007C4242427C48444442420000
+0155:00000C3000005C624240404040400000
+0156:000000007C4242427C484444424220C0
+0157:0000000000005C6242404040404020C0
+0158:241800007C4242427C48444442420000
+0159:0000241800005C624240404040400000
+015A:0C3000003C424240300C0242423C0000
+015B:00000C3000003C4240300C42423C0000
+015C:182400003C424240300C0242423C0000
+015D:0000182400003C4240300C02423C0000
+015E:000000003C424240300C0242423C0830
+015F:0000000000003C4240300C02423C0830
+0160:241800003C424240300C0242423C0000
+0161:0000241800003C4240300C02423C0000
+0162:000000007F0808080808080808080830
+0163:000000001010107C10101010100C0830
+0164:241800007F0808080808080808080000
+0165:241800001010107C10101010100C0000
+0166:000000007F0808083E08080808080000
+0167:000000001010107C10107C10100C0000
+0168:324C00004242424242424242423C0000
+0169:0000324C0000424242424242463A0000
+016A:003C00004242424242424242423C0000
+016B:0000003C0000424242424242463A0000
+016C:42423C004242424242424242423C0000
+016D:0042423C0000424242424242463A0000
+016E:182418004242424242424242423C0000
+016F:000018241800424242424242463A0000
+0170:334400004242424242424242423C0000
+0171:000033440000424242424242463A0000
+0172:000000004242424242424242423C100C
+0173:000000000000424242424242463A0403
+0174:18240000424242425A5A666642420000
+0175:00001824000041494949494949360000
+0176:18240000414122221408080808080000
+0177:0000182400004242424242261A02023C
+0178:24240000414122221408080808080000
+0179:0C3000007E02020408102040407E0000
+017A:00000C3000007E0204081020407E0000
+017B:101000007E02020408102040407E0000
+017C:0000101000007E0204081020407E0000
+017D:241800007E02020408102040407E0000
+017E:0000241800007E0204081020407E0000
+017F:0000000C101010301010101010100000
+0180:00000040F0405C6242424242625C0000
+0181:000000007CA2A2223C222222223C0000
+0182:000000007E4040407C424242427C0000
+0183:0000007C40405C6242424242625C0000
+0184:00000000602020203C222222223C0000
+0185:000000000000602020203C22223C0000
+0186:000000003C42420202020242423C0000
+0187:000003043C4444404040404444380000
+0188:0000000003043C444040404044380000
+0189:0000000078444242F242424244780000
+018A:0000000078A4A2222222222224380000
+018B:000000007E0202023E424242423E0000
+018C:0000003E02023A4642424242463A0000
+018D:0000000000003C424242422418040438
+018E:000000007E0202023E020202027E0000
+018F:0000000018244202027E424224180000
+0190:000000003C42424038404042423C0000
+0191:000000001F1010101E10101010106000
+0192:0000000C1010107C1010101010106000
+0193:000000033C444440405C44444C340000
+0194:00000000424242242418182424180000
+0195:00000040404040724A4A4A4A4A440000
+0196:00000000380808080808080808060000
+0197:000000003E0808083E080808083E0000
+0198:00000000464A50506060504844420000
+0199:00000030484044485060504844420000
+019A:000000180808083E08080808083E0000
+019B:00000000242810304818242442420000
+019C:00000000494949494949494949370000
+019D:00000000222232322A2A26262222C000
+019E:0000000000005C624242424242420202
+019F:000000003C4242427E424242423C0000
+01A0:000000023A4444444444444444380000
+01A1:0000000000023A444444444444380000
+01A2:00000000364A4A4A4A4A4A4A4A320202
+01A3:000000000000364A4A4A4A4A4A320202
+01A4:000000003E5151111E10101010100000
+01A5:0000000000035C644444444464584040
+01A6:0000000070203C22223C282422210000
+01A7:000000003C4242020C304042423C0000
+01A8:0000000000003C42020C3040423C0000
+01A9:000000007E40201008081020407E0000
+01AA:00000020505030101010101010100C00
+01AB:000000001010107C10101010100C0418
+01AC:000000003F4848080808080808080000
+01AD:0000000C1010107C10101010100C0000
+01AE:000000007F0808080808080808080600
+01AF:00000101464444444444444444380000
+01B0:0000000001014644444444444C340000
+01B1:00000000422424424242424224180000
+01B2:000000004C4242424242424448300000
+01B3:00000000464544282810101010100000
+01B4:0000000000034444444444241C040438
+01B5:000000007E0204083C102040407E0000
+01B6:0000000000007E04083C1020407E0000
+01B7:000000007E0408101C020202463C0000
+01B8:000000007E20100838404040623C0000
+01B9:0000000000007C20100838404040423C
+01BA:0000000000003E04081C02023C40423C
+01BB:000000003C424204087E2040407E0000
+01BC:000000007E2020203C020202423C0000
+01BD:0000000000007E20203C0202423C0000
+01BE:0000000010107C101018040444380000
+01BF:0000000000005C624242444850604040
+01C0:00000010101010101010101010100000
+01C1:00000028282828282828282828280000
+01C2:000000101010107C107C101010100000
+01C3:00000000080808080808080008080000
+01C4:05020000675151515252545454670000
+01C5:00000502605057515152525454670000
+01C6:00000512101037515152525454370000
+01C7:00000000474141414141414949760000
+01C8:0000000141404341414141414179020C
+01C9:00000061212023212121212121F9020C
+01CA:000000004B4949696959594D4D4A0000
+01CB:0000000149486B69695959594949120C
+01CC:0000000101005369494949494949120C
+01CD:2418000018242442427E424242420000
+01CE:0000241800003C42023E4242463A0000
+01CF:241800003E08080808080808083E0000
+01D0:000024180000180808080808083E0000
+01D1:241800003C42424242424242423C0000
+01D2:0000241800003C4242424242423C0000
+01D3:241800004242424242424242423C0000
+01D4:000024180000424242424242463A0000
+01D5:3C0024004242424242424242423C0000
+01D6:003C00242400424242424242463A0000
+01D7:0C3000240042424242424242423C0000
+01D8:0C3000242400424242424242463A0000
+01D9:241800240042424242424242423C0000
+01DA:241800242400424242424242463A0000
+01DB:300C00240042424242424242423C0000
+01DC:300C00242400424242424242463A0000
+01DD:0000000000003C4202027E42423C0000
+01DE:3C00240018242442427E424242420000
+01DF:003C002424003C42023E4242463A0000
+01E0:3C00180018242442427E424242420000
+01E1:003C001010003C42023E4242463A0000
+01E2:003C00001F2848487F484848484F0000
+01E3:0000003C00003E49093F4848493E0000
+01E4:000000003C424240404E424F423E0000
+01E5:0000000000023A44444438203C4F423C
+01E6:241800003C424240404E4242463A0000
+01E7:0000241800023A44444438203C42423C
+01E8:24180000424448506060504844420000
+01E9:24180040404044485060504844420000
+01EA:000000003C42424242424242423C100C
+01EB:0000000000003C4242424242423C100C
+01EC:003C00003C42424242424242423C100C
+01ED:0000003C00003C4242424242423C100C
+01EE:241800007E0408101C020202463C0000
+01EF:0000241800003E0408101C020202423C
+01F0:0000120C00000C040404040404044830
+01F1:00000000675151515252545454670000
+01F2:00000000605057515152525454670000
+01F3:00000010101037515152525454370000
+01F4:0C3000003C424240404E4242463A0000
+01F5:00000C3000023A44444438203C42423C
+01F6:000000004848484A7A4A4A4A4A440000
+01F7:000000005C6242424448506040404000
+01F8:00300C0042626252524A4A4646420000
+01F9:000000300C005C624242424242420000
+01FA:0C30182418182424427E424242420000
+01FB:0C3000182418003C42023E42463A0000
+01FC:061800001F2848487F484848484F0000
+01FD:0000061800003E49093F4848493E0000
+01FE:0C3000023A44464A4A525262225C4000
+01FF:00000C3000023C464A4A5252623C4000
+0200:CC22000018242442427E424242420000
+0201:0000CC2200003C42023E4242463A0000
+0202:3C42420018242442427E424242420000
+0203:00003C4242003C42023E4242463A0000
+0204:CC2200007E4040407C404040407E0000
+0205:0000CC2200003C42427E4040423C0000
+0206:3C4242007E4040407C404040407E0000
+0207:00003C4242003C42427E4040423C0000
+0208:CC2200003E08080808080808083E0000
+0209:0000CC220000180808080808083E0000
+020A:3C4242003E08080808080808083E0000
+020B:00003C424200180808080808083E0000
+020C:CC2200003C42424242424242423C0000
+020D:0000CC2200003C4242424242423C0000
+020E:3C4242003C42424242424242423C0000
+020F:00003C4242003C4242424242423C0000
+0210:CC2200007C4242427C48444442420000
+0211:0000CC2200005C624240404040400000
+0212:3C4242007C4242427C48444442420000
+0213:00003C4242005C624240404040400000
+0214:CC2200004242424242424242423C0000
+0215:0000CC220000424242424242463A0000
+0216:3C4242004242424242424242423C0000
+0217:00003C424200424242424242463A0000
+0218:000000003C424240300C0242423C0810
+0219:0000000000003C4240300C02423C0810
+021A:000000007F0808080808080808080204
+021B:000000001010107C10101010100C2040
+021C:000000003C4242020C340202020C3000
+021D:0000000000003C4202020C3202020C30
+021E:00241800424242427E42424242420000
+021F:002418004040405C6242424242420000
+0220:000000005C6242424242424242420202
+0221:0000000202023A4642424242473B0204
+0222:0000000008244242243C4242423C0000
+0223:000000000000122224182422221C0000
+0224:000000007E02020408102040407E0204
+0225:0000000000007E0204081020407E0204
+0226:0000080018242442427E424242420000
+0227:0000000008003C42023E4242463A0000
+0228:000000007E4040407C404040407E0830
+0229:0000000000003C42427E4040423C0830
+022A:3C0024003C42424242424242423C0000
+022B:00003C0024003C4242424242423C0000
+022C:3C00324C003C424242424242423C0000
+022D:003C00324C003C4242424242423C0000
+022E:000008003C42424242424242423C0000
+022F:0000000008003C4242424242423C0000
+0230:3C0008003C42424242424242423C0000
+0231:00003C0008003C4242424242423C0000
+0232:00003E00414122221408080808080000
+0233:000000003C004242424242261A02023C
+0234:0000001808080808080808080C0C1020
+0235:0000000000005C624242424243430204
+0236:000000001010107C10101010160E0810
+0237:0000000000000C040404040404044830
+0238:00000010101054BA92929292BA540000
+0239:00000000000054BA92929292BA541010
+023A:000000021A242C4A527E624242C20000
+023B:000000023C464A4850506062427C8000
+023C:0000000002043C4A50506060427C8000
+023D:000000002020202078202020203E0000
+023E:000001027F0C0C080818182828480000
+023F:0000000000003C4240300C02423C0906
+0240:0000000000007E02040810204060100E
+0241:000000003C4242020408080808080000
+0242:0000000000003C424202040808080000
+0243:000000003C2222223C227A22223C0000
+0244:000000004444444444FE444444380000
+0245:00000000181818242424244242420000
+0246:000004047E4848507C505060607E4040
+0247:0000000000023C464A7E5060427C8000
+0248:000000001F040404041F044444380000
+0249:0000000404000C04041F040404044830
+024A:0000000038444444444444444C340403
+024B:000000000000344C444444444C340403
+024C:000000003C2222227C28242422220000
+024D:0000000000002C322270202020200000
+024E:000000004141227F1408080808080000
+024F:0000000000002222227F22120E02021C
+0250:0000000000005C6242427C40423C0000
+0251:0000000000003A46424242464A320000
+0252:0000000000004C5262424242625C0000
+0253:0000003840405C6242424242625C0000
+0254:0000000000003C4202020202423C0000
+0255:0000000000003C424040404C523C4000
+0256:000000040404344C444444444C340300
+0257:000000030404344C444444444C340000
+0258:0000000000003C42427E0202423C0000
+0259:0000000000003C4202027E42423C0000
+025A:000000000000344D1A28484848300000
+025B:0000000000003C42403C4040423C0000
+025C:0000000000003C42023C0202423C0000
+025D:000000000000344D0A30080848300000
+025E:0000000000003C42425C4242423C0000
+025F:0000000000000C0404041F0404044830
+0260:000000000003344C4444444C34044438
+0261:0000000000003A46424242463A02423C
+0262:0000000000003C4240404E42423E0000
+0263:00000000000042424224241818242418
+0264:00000000000042422424181824180000
+0265:0000000000424242424242463A020202
+0266:0000003840405C624242424242420000
+0267:0000003840405C62424242424242020C
+0268:0000000808001808083E0808083E0000
+0269:000000000000701010101010100C0000
+026A:0000000000003E0808080808083E0000
+026B:000000180808083A4C080808083E0000
+026C:00000018080838483E080808083E0000
+026D:00000018080808080808080808080600
+026E:0000003010101F1112141611117D0906
+026F:00000000000049494949494949370000
+0270:00000000000049494949494949370101
+0271:00000000000076494949494949410600
+0272:00000000000016191111111111116000
+0273:00000000000058644444444444440300
+0274:000000000000424262524A4642420000
+0275:0000000000003C42427E4242423C0000
+0276:0000000000003748484E484848370000
+0277:0000000000003E414149494949360000
+0278:0000000808083E4949494949493E0808
+0279:000000000000020202020242463A0000
+027A:000000000202020202020242463A0000
+027B:0000000000000404040404444C340300
+027C:0000000000005C624240404040404040
+027D:0000000000005C624240404040403000
+027E:0000000000003C424240404040400000
+027F:0000000000003C424202020202020202
+0280:0000000000007C42427C484442420000
+0281:000000000000424244487C42427C0000
+0282:0000000000003C4240300C02427C4030
+0283:0000000C101010101010101010106000
+0284:0000000C1010101010107C1010106000
+0285:00000000000060101010101010100C00
+0286:000000060808080808080808384E3000
+0287:00000000601010101010107C10100000
+0288:000000001010107C1010101010100E00
+0289:0000000000002222227F2222261A0000
+028A:00000000000042244242424224180000
+028B:000000000000CC424242424448300000
+028C:00000000000018182424244242420000
+028D:00000000000036494949494949410000
+028E:000000003C4040586442424242420000
+028F:00000000000041412214080808080000
+0290:0000000000007C0808101020207C0403
+0291:0000000000007E0204081026497E1000
+0292:0000000000003E0408101C020202423C
+0293:0000000000003E0408101C0202324A3C
+0294:000000003C4242020408080808080000
+0295:000000003C4242402010101010100000
+0296:000000000808080808040242423C0000
+0297:0000000000003C42404040404040423C
+0298:000000003C4242425A5A4242423C0000
+0299:0000000000007C42427C4242427C0000
+029A:0000000000003C42423A4242423C0000
+029B:0000000000003B4440404C44443C0000
+029C:0000000000002222223E222222220000
+029D:0000000404000C0404040404043E4830
+029E:00000000004222120A060A1222020202
+029F:000000000000404040404040407E0000
+02A0:000000000003344C444444444C340404
+02A1:000000003C4242020408083E08080000
+02A2:000000003C4242402010107C10100000
+02A3:0000001010103F5152525454583F0000
+02A4:0000001010103F515254565151310906
+02A5:0000001010103F5152545852553E0400
+02A6:00000000404046F948444241413E0000
+02A7:000000032424247C24242424241C0418
+02A8:00000000404046F94848484A4D3E0400
+02A9:000000003048406E515151515151020C
+02AA:000000602020262928242221217E0000
+02AB:0000006020203E2224242828307E0000
+02AC:00000049495536220049495536220000
+02AD:000000007E42424200007E4242420000
+02AE:0000000000006424242424242C140404
+02AF:0000000000006424242424242C140403
+02B0:00000040405864444444000000000000
+02B1:00000038444058644444000000000000
+02B2:00000004000404040424180000000000
+02B3:00000000005864444040000000000000
+02B4:00000000000404444C34000000000000
+02B5:00000000000404444C34030000000000
+02B6:00000044444878444478000000000000
+02B7:00000000004949553622000000000000
+02B8:000000000044444C3404380000000000
+02B9:00000000081020000000000000000000
+02BA:00000000122448000000000000000000
+02BB:00000000081010180000000000000000
+02BC:00000000180808100000000000000000
+02BD:00000000181010080000000000000000
+02BE:00000030080404083000000000000000
+02BF:0000000C102020100C00000000000000
+02C0:0000003C4202021C1010000000000000
+02C1:0000003C424040380808000000000000
+02C2:00000004081020100804000000000000
+02C3:00000020100804081020000000000000
+02C4:00000000081422410000000000000000
+02C5:00000000412214080000000000000000
+02C6:00000000182400000000000000000000
+02C7:00000000241800000000000000000000
+02C8:00000000080808000000000000000000
+02C9:000000003C0000000000000000000000
+02CA:000000000C3000000000000000000000
+02CB:00000000300C00000000000000000000
+02CC:00000000000000000000080808080000
+02CD:000000000000000000000000003C0000
+02CE:00000000000000000000000000300C00
+02CF:000000000000000000000000000C3000
+02D0:00000000000000381000001038000000
+02D1:00000000000000381000000000000000
+02D2:00000000000030080404083000000000
+02D3:0000000000000C102020100C00000000
+02D4:00000000000000101010107C00000000
+02D5:000000000000007C1010101000000000
+02D6:0000000000000010107C101000000000
+02D7:0000000000000000007C000000000000
+02D8:000042423C0000000000000000000000
+02D9:00001818000000000000000000000000
+02DA:00001824180000000000000000000000
+02DB:00000000000000000000000000000806
+02DC:0000324C000000000000000000000000
+02DD:00003344000000000000000000000000
+02DE:000000000000002060A21C0000000000
+02DF:00000000422418244200000000000000
+02E0:00000000004242241824241800000000
+02E1:00000030101010101038000000000000
+02E2:00000000003E403C027C000000000000
+02E3:00000000004224182442000000000000
+02E4:00003C40403808000000000000000000
+02E5:0000007C040404040404040404040000
+02E6:00000004047C04040404040404040000
+02E7:00000004040404047C04040404040000
+02E8:00000004040404040404047C04040000
+02E9:000000040404040404040404047C0000
+02EA:000000000000404040404C7000000000
+02EB:000000000040404C7040404000000000
+02EC:00000000000000000000004428100000
+02ED:00007E007E0000000000000000000000
+02EE:00000000662222440000000000000000
+02EF:00000000000000000000000044281000
+02F0:00000000000000000000000010284400
+02F1:00000000000000000000040810080400
+02F2:00000000000000000000100804081000
+02F3:00000000000000000000000018241800
+02F4:00000000000000300C00000000000000
+02F5:00000000000000CC2200000000000000
+02F6:00000000000000334400000000000000
+02F7:0000000000000000000000000000324C
+02F8:00000018180000001818000000000000
+02F9:00000038202020000000000000000000
+02FA:00000038080808000000000000000000
+02FB:00000000000000000000202020380000
+02FC:00000000000000000000080808380000
+02FD:0000000000000000000000000042427E
+02FE:0000000000000000000000000040407E
+02FF:000000000000000000000010207E2010
+0300:300C0000000000000000000000000000
+0301:0C300000000000000000000000000000
+0302:18240000000000000000000000000000
+0303:00324C00000000000000000000000000
+0304:00007E00000000000000000000000000
+0305:0000FF00000000000000000000000000
+0306:0042423C000000000000000000000000
+0307:00181800000000000000000000000000
+0308:00666600000000000000000000000000
+0309:18240408080000000000000000000000
+030A:18242418000000000000000000000000
+030B:33440000000000000000000000000000
+030C:00422418000000000000000000000000
+030D:00080808000000000000000000000000
+030E:00242424000000000000000000000000
+030F:CC220000000000000000000000000000
+0310:185A423C000000000000000000000000
+0311:003C4242000000000000000000000000
+0312:00081018000000000000000000000000
+0313:00180810000000000000000000000000
+0314:00181008000000000000000000000000
+0315:00030102000000000000000000000000
+0316:00000000000000000000000000100804
+0317:00000000000000000000000000081020
+0318:00000000000000000000000000083808
+0319:00000000000000000000000000101C10
+031A:001E0202000000000000000000000000
+031B:0000040A020408000000000000000000
+031C:00000000000000000000000000182018
+031D:00000000000000000000000000101038
+031E:00000000000000000000000000381010
+031F:00000000000000000000000000107C10
+0320:0000000000000000000000000000003C
+0321:0000000000000000000000000202120C
+0322:00000000000000000000000008080906
+0323:00000000000000000000000000001818
+0324:00000000000000000000000000006666
+0325:00000000000000000000000000182418
+0326:00000000000000000000000000180810
+0327:00000000000000000000000010180438
+0328:00000000000000000000000000080806
+0329:00000000000000000000000000101010
+032A:00000000000000000000000000007E42
+032B:00000000000000000000000000494936
+032C:00000000000000000000000000422418
+032D:00000000000000000000000000182442
+032E:0000000000000000000000000042423C
+032F:000000000000000000000000003C4242
+0330:0000000000000000000000000000324C
+0331:0000000000000000000000000000007E
+0332:000000000000000000000000000000FF
+0333:00000000000000000000000000FF00FF
+0334:0000000000000000324C000000000000
+0335:00000000000000003C00000000000000
+0336:0000000000000000FF00000000000000
+0337:00000000000004081020400000000000
+0338:00000202040408081010202040400000
+0339:00000000000000000000000018040418
+033A:0000000000000000000000000000427E
+033B:000000000000000000000000003C243C
+033C:000000000000000000000000006C9210
+033D:66186600000000000000000000000000
+033E:08101008100000000000000000000000
+033F:FF00FF00000000000000000000000000
+0340:00402010000000000000000000000000
+0341:00020408000000000000000000000000
+0342:00344800000000000000000000000000
+0343:00180810000000000000000000000000
+0344:10105444000000000000000000000000
+0345:0000000000000000000000001010100C
+0346:007E4200000000000000000000000000
+0347:000000000000000000000000007E007E
+0348:00000000000000000000000000002424
+0349:00000000000000000000000000001808
+034A:083A5C10000000000000000000000000
+034B:04718E20000000000000000000000000
+034C:324C324C000000000000000000000000
+034D:00000000000000000000000000227F22
+034E:00000000000000000000000000081C08
+034F:AAAA000180000001B9C24203C2E2422BB9C40001824000018420000182405555
+0350:08040204080000000000000000000000
+0351:18202018000000000000000000000000
+0352:3C425A18000000000000000000000000
+0353:00000000000000000000000000241824
+0354:00000000000000000000000810201008
+0355:00000000000000000000001008040810
+0356:00000000000000000000008040244A91
+0357:18040418000000000000000000000000
+0358:00030300000000000000000000000000
+0359:00000000000000000000000054387C38
+035A:000000000000000000000000006C926C
+035B:08103E04080000000000000000000000
+035C:00000000000000000000000000000000000000000000000000004002300C0FF0
+035D:00004002300C0FF0000000000000000000000000000000000000000000000000
+035E:000000001FF80000000000000000000000000000000000000000000000000000
+035F:0000000000000000000000000000000000000000000000000000000000001FF8
+0360:00001E0221844078000000000000000000000000000000000000000000000000
+0361:00000FF0300C4002000000000000000000000000000000000000000000000000
+0362:000000000000000000000000000000000000000000000008000C7FFE000C0008
+0363:3C44444C340000000000000000000000
+0364:384478403C0000000000000000000000
+0365:10003010380000000000000000000000
+0366:38444444380000000000000000000000
+0367:444444443C0000000000000000000000
+0368:1C2020201C0000000000000000000000
+0369:04043C243C0000000000000000000000
+036A:20203824240000000000000000000000
+036B:0000EC92920000000000000000000000
+036C:00382420200000000000000000000000
+036D:20782020180000000000000000000000
+036E:00444428100000000000000000000000
+036F:44281028440000000000000000000000
+0370:00000000404040407C40404040400000
+0371:0000000000002050501E101010100000
+0372:00000000FE9292921010101010100000
+0373:000000007C5454541010101010100000
+0374:000000000C1810200000000000000000
+0375:00000000000000000000000004081830
+0376:000000004246464A4A52526262420000
+0377:000000000000889898A8A8CACA840000
+0378:00007FFE738E6DF66DC66DF6738E7FFE7FFE61CE7DB67BCE77B677CE7FFE0000
+0379:00007FFE738E6DF66DC66DF6738E7FFE7FFE61CE7DB67BC677F677CE7FFE0000
+037A:00000000000000000000000020202018
+037B:0000000000003C4202020202423C0000
+037C:0000000000003C4240585840423C0000
+037D:0000000000003C42021A1A02423C0000
+037E:00000000000018180000001808081000
+037F:000000001F0404040404044444380000
+0380:00007FFE738E6DF66DC66DF6738E7FFE7FFE73CE6DB673B66DB673CE7FFE0000
+0381:00007FFE738E6DF66DC66DF6738E7FFE7FFE73EE6DCE73EE6DEE73C67FFE0000
+0382:00007FFE738E6DF66DC66DF6738E7FFE7FFE73866DF673866DBE73867FFE0000
+0383:00007FFE738E6DF66DC66DF6738E7FFE7FFE738E6DF673C66DF6738E7FFE0000
+0384:00040810000000000000000000000000
+0385:04085444000000000000000000000000
+0386:1020400018242442427E424242420000
+0387:00000000000000001818000000000000
+0388:102040007E4040407C404040407E0000
+0389:10204000424242427E42424242420000
+038A:102040003E08080808080808083E0000
+038B:00007FFE738E6DF66DC66DF6738E7FFE7FFE738E6DB6738E6DB6738E7FFE0000
+038C:102040003C42424242424242423C0000
+038D:00007FFE738E6DF66DC66DF6738E7FFE7FFE738E6DB673B66DB6738E7FFE0000
+038E:10204000414122221408080808080000
+038F:102040003E4141414141412214147700
+0390:040810444400301010101010100C0000
+0391:0000000018242442427E424242420000
+0392:000000007C4242427C424242427C0000
+0393:000000007E4240404040404040400000
+0394:000000000808141422222241417F0000
+0395:000000007E4040407C404040407E0000
+0396:000000007E02020408102040407E0000
+0397:00000000424242427E42424242420000
+0398:000000003C4242425A5A4242423C0000
+0399:000000003E08080808080808083E0000
+039A:00000000424448506060504844420000
+039B:00000000080814142222224141410000
+039C:00000000424266665A5A424242420000
+039D:0000000042626252524A4A4646420000
+039E:000000007E0000003C000000007E0000
+039F:000000003C42424242424242423C0000
+03A0:000000007F2222222222222222220000
+03A1:000000007C4242427C40404040400000
+03A2:00007FFE738E6DF66DC66DF6738E7FFE7FFE61866DF661866DBE6D867FFE0000
+03A3:000000007E40201008081020407E0000
+03A4:000000007F0808080808080808080000
+03A5:00000000414122221408080808080000
+03A6:000000007F083E494949493E087F0000
+03A7:00000000424224241818242442420000
+03A8:0000000049494949493E080808080000
+03A9:000000003E4141414141221414770000
+03AA:242400003E08080808080808083E0000
+03AB:24240000414122221408080808080000
+03AC:000408100000324A444444444A320000
+03AD:0004081000003E40403C4040403E0000
+03AE:0004081000005C624242424242420202
+03AF:000408100000301010101010100C0000
+03B0:040810444400424242424242423C0000
+03B1:000000000000324A444444444A320000
+03B2:00000000384444447C424242625C4040
+03B3:00000000000031490A04080810100000
+03B4:000000001C20202018244242423C0000
+03B5:0000000000003C42403C4040423C0000
+03B6:0000000020201C0810202020201C021C
+03B7:0000000000005C624242424242420202
+03B8:00000000182424427E42422424180000
+03B9:000000000000301010101010100C0000
+03BA:00000000000022242830302824220000
+03BB:00000000202010100818242442420000
+03BC:0000000000004242424266665A424040
+03BD:00000000000042424244444850600000
+03BE:0000000040403C40403C40403C02023C
+03BF:0000000000003C4242424242423C0000
+03C0:0000000000007E242424242424240000
+03C1:0000000000003C4242424242625C4040
+03C2:0000000000001E20404040201C02021C
+03C3:0000000000003F484444444444380000
+03C4:0000000000007E1010101010100C0000
+03C5:000000000000424242424242423C0000
+03C6:000000000000264949494949493E0808
+03C7:0000000000C121221214182848448483
+03C8:000000000000494949494949493E0808
+03C9:00000000000022414149494949360000
+03CA:000024240000301010101010100C0000
+03CB:000024240000424242424242423C0000
+03CC:0004081000003C4242424242423C0000
+03CD:000408100000424242424242423C0000
+03CE:00040810000022414149494949360000
+03CF:00000000424448506060504844420408
+03D0:000000001C2242447844424244380000
+03D1:000000000C1212120F226222221C0000
+03D2:000000003655141408080808081C0000
+03D3:102040003655141408080808081C0000
+03D4:003636003655141408080808081C0000
+03D5:0000000008083E4949494949493E0808
+03D6:0000000000007F224141494949360000
+03D7:00000000000082442C2C34342241011E
+03D8:000000003C42424242424242423C183C
+03D9:0000000000003C4242424242423C1818
+03DA:000000003844404040404038081C0000
+03DB:000000000000003E4040201C021C0000
+03DC:000000007E4240407840404040400000
+03DD:000000000000003C2220203820202020
+03DE:0000000060202020203E040408080000
+03DF:000000000000201010223C4408080400
+03E0:000000001C22060A12060A12020C0000
+03E1:00000000000000601018284C14240408
+03E2:0000000044929292929292926E027C80
+03E3:0000000000004492929292926E027C80
+03E4:0000000032424242463A020202020000
+03E5:000000000000122222221E0202020000
+03E6:000000004040405C624141410101621C
+03E7:0000000000083C5252220202324C0000
+03E8:000000003C42420204081020423C0000
+03E9:0000000000003C4242040830423C0000
+03EA:00000000C3A5241818242442427E8100
+03EB:000000000000245A18181824427E0000
+03EC:000000023C40405C62424242423C0000
+03ED:0000000000023C405C624242423C0000
+03EE:000000001010FE921010101010101000
+03EF:0000000000001010FE92101010101000
+03F0:00000000000082442C2C343422410000
+03F1:0000000000003C4242427C40403C0200
+03F2:0000000000003C4240404040423C0000
+03F3:0000000404000C040404040404044830
+03F4:000000003C4242427E424242423C0000
+03F5:0000000000001C2040784040201C0000
+03F6:0000000000007008043C040408700000
+03F7:00000000E040784442424242447840E0
+03F8:0000000040405C6242424242625C4040
+03F9:000000003C42424040404042423C0000
+03FA:00000000424266665A5A424242420000
+03FB:0000000000446C6C5454444445424040
+03FC:0000000000003C42424242625C40F840
+03FD:000000003C42420202020242423C0000
+03FE:000000003C42424058584042423C0000
+03FF:000000003C4242021A1A0242423C0000
+0400:00300C007E4040407C404040407E0000
+0401:242400007E4040407C404040407E0000
+0402:000000007E1010101E11111111160000
+0403:0C3000007E4040404040404040400000
+0404:000000001C2240407C404040221C0000
+0405:000000003C424240300C0242423C0000
+0406:000000003E08080808080808083E0000
+0407:242400003E08080808080808083E0000
+0408:000000000E0404040404044444380000
+0409:00000000784848484E494949498E0000
+040A:00000000484848487E494949494E0000
+040B:000000007E1010101E11111111110000
+040C:0C300000464848505060504844420000
+040D:00300C004246464A4A52526262420000
+040E:42423C00414122221414080810300000
+040F:000000004141414141414141417F0808
+0410:0000000018242442427E424242420000
+0411:000000007C4040407C424242427C0000
+0412:000000007C4242427C424242427C0000
+0413:000000007E4040404040404040400000
+0414:000000000E1212122222224242FF8181
+0415:000000007E4040407C404040407E0000
+0416:0000000049492A2A1C1C2A2A49490000
+0417:000000003C4202023C040202423C0000
+0418:000000004246464A4A52526262420000
+0419:002418004246464A4A52526262420000
+041A:00000000464848505060504844420000
+041B:000000001E1212121212122222420000
+041C:00000000424266665A5A424242420000
+041D:00000000424242427E42424242420000
+041E:000000003C42424242424242423C0000
+041F:000000007E4242424242424242420000
+0420:000000007C4242427C40404040400000
+0421:000000003C42424040404042423C0000
+0422:000000007F0808080808080808080000
+0423:00000000414122221414080810300000
+0424:000000083E49494949493E0808080000
+0425:00000000424224241818242442420000
+0426:000000004242424242424242427F0101
+0427:000000004242424242463A0202020000
+0428:000000004949494949494949497F0000
+0429:00000000929292929292929292FF0101
+042A:00000000701010101E111111111E0000
+042B:0000000042424242724A4A4A4A720000
+042C:00000000404040407C424242427C0000
+042D:00000000384402023E02020244380000
+042E:000000004C52525272525252524C0000
+042F:000000003E4242423E12222242420000
+0430:0000000000003C42023E4242463A0000
+0431:0000021C20407C4242424242423C0000
+0432:0000000000007C42427C4242427C0000
+0433:0000000000007E404040404040400000
+0434:0000000000001E1222224242427F4100
+0435:0000000000003C42427E4040423C0000
+0436:00000000000049492A1C1C2A49490000
+0437:0000000000003C42023C0402423C0000
+0438:00000000000046464A4A525262620000
+0439:00002418000046464A4A525262620000
+043A:00000000000046485060504844420000
+043B:0000000000001E121212122222420000
+043C:0000000000004266665A5A4242420000
+043D:0000000000004242427E424242420000
+043E:0000000000003C4242424242423C0000
+043F:0000000000007E424242424242420000
+0440:0000000000005C6242424242625C4040
+0441:0000000000003C4240404040423C0000
+0442:0000000000007F080808080808080000
+0443:00000000000042422424181810102060
+0444:0000000808083E4949494949493E0808
+0445:00000000000042422418182442420000
+0446:000000000000424242424242427F0101
+0447:00000000000042424242463A02020000
+0448:000000000000494949494949497F0000
+0449:00000000000092929292929292FF0101
+044A:0000000000007010101E1111111E0000
+044B:000000000000424242724A4A4A720000
+044C:0000000000004040407C4242427C0000
+044D:0000000000003844023E020244380000
+044E:0000000000004C5252725252524C0000
+044F:0000000000003E4242423E1222420000
+0450:0000300C00003C42427E4040423C0000
+0451:0000242400003C42427E4040423C0000
+0452:00000040F0405C62424242424242020C
+0453:00000C3000007E404040404040400000
+0454:0000000000001C22407C4040221C0000
+0455:0000000000003C4240300C02423C0000
+0456:000000080800180808080808083E0000
+0457:000000242400180808080808083E0000
+0458:0000000404000C040404040404044830
+0459:0000000000007848484E4949498E0000
+045A:0000000000004848487E4949494E0000
+045B:00000040F0405C624242424242420000
+045C:00000C30000046485060504844420000
+045D:0000300C000046464A4A525262620000
+045E:0042423C000042422424181810102060
+045F:000000000000222222222222223E0808
+0460:0000000049494949494949495A240000
+0461:0000000000000049494949495A240000
+0462:00000000107C10101E111111111E0000
+0463:0000000020207820203C2222223C0000
+0464:00000000464950507E50505049460000
+0465:0000000000004649507E505049460000
+0466:000000000808141422362A4949490000
+0467:00000000000008141422364949490000
+0468:000000004848545452766A4949490000
+0469:00000000000048545452764949490000
+046A:000000003E222214081C2A4949490000
+046B:0000000000003E2214083E4949490000
+046C:000000005F51514A744E555555550000
+046D:0000000000005F514A744E5555550000
+046E:000024183C4202023C040202023C4040
+046F:0000002418003C42023C0402023C4040
+0470:0000000049494949493E080808080000
+0471:000000000000000049494949493E0808
+0472:000000003C4242427E424242423C0000
+0473:0000000000003C42427E4242423C0000
+0474:00000000434444442828281010100000
+0475:00000000000046484828282810100000
+0476:66110000434444442828281010100000
+0477:00006611000046484828282810100000
+0478:00000000205059595955565454240808
+0479:00000000000029595955565454240808
+047A:000000083E49414141414141493E0800
+047B:0000000000083E4941414141493E0800
+047C:3C431804080036414149494949360000
+047D:0000003C431804080036414949360000
+047E:007F080049494949494949495A240000
+047F:000000007F080049494949495A240000
+0480:000000003C424240404040403C040404
+0481:0000000000003C42424040403C040404
+0482:000000000000120C442A111824000000
+0483:00087840000000000000000000000000
+0484:02050910000000000000000000000000
+0485:00384030000000000000000000000000
+0486:00380418000000000000000000000000
+0487:00304C83000000000000000000000000
+0488:000000000100028010102828000000004008A014000000000000101029280280
+0489:000000000080108409880C30000000000008700E1000000000000CD808881084
+048A:002418004246464A4A52526262430204
+048B:00002418000046464A4A525262630204
+048C:0000000020702020203C2222263C0000
+048D:000000000000002070203C22223C0000
+048E:000000007C424A447A40404040400000
+048F:0000000000005C624242424A645A4040
+0490:000002027E4040404040404040400000
+0491:0000000002027E404040404040400000
+0492:000000001F101010107C101010100000
+0493:0000000000001F1010107C1010100000
+0494:000000007E404040407C424242420C00
+0495:0000000000007E4040407C4242420C00
+0496:0000000049492A2A1C1C2A2A49490101
+0497:00000000000049492A1C1C2A49490101
+0498:000000003C4202023C040202423C0830
+0499:0000000000003C42023C0402423C0830
+049A:00000000464848505060504844420202
+049B:00000000000046485060504844420202
+049C:00000000434454547854545442410000
+049D:00000000000043545478545442410000
+049E:00000000237424282830282422210000
+049F:00000000000023742830282422210000
+04A0:00000000E32424282830282422210000
+04A1:000000000000E3242830282422210000
+04A2:00000000424242427E42424242430101
+04A3:0000000000004242427E424242430101
+04A4:00000000474444447C44444444440000
+04A5:0000000000004744447C444444440000
+04A6:0000000078484848484E494949490106
+04A7:000000000000784848484E4949490106
+04A8:000000204C525252525252522C180600
+04A9:000000000000204C525252522C180600
+04AA:000000003C42424040404042423C0830
+04AB:0000000000003C4242404042423C0830
+04AC:000000007F08080808080808080C0404
+04AD:0000000000007F0808080808080C0404
+04AE:00000000414122221408080808080000
+04AF:00000000000022222214140808080808
+04B0:00000000414122221408083E08080000
+04B1:0000000000002222221414083E080808
+04B2:00000000424224241818242442430101
+04B3:00000000000042422418182442430101
+04B4:00000000FA22222222222222223F0101
+04B5:000000000000FA2222222222223F0101
+04B6:000000004242424242463A0202030101
+04B7:00000000000042424242463A02030101
+04B8:000000004242424252563A1212020000
+04B9:00000000000042424252563A12020000
+04BA:000000004040405C6242424242420000
+04BB:00000000000040405C62424242420000
+04BC:000000004C5252523E101012120C0000
+04BD:0000000000004C52523E1010120C0000
+04BE:000000004C5252523E101012120C0808
+04BF:0000000000004C52523E1010120C0808
+04C0:000000003E08080808080808083E0000
+04C1:41413E0049492A2A1C1C2A2A49490000
+04C2:0022221C000049492A1C1C2A49490000
+04C3:0000000046484850607C42424242020C
+04C4:000000000000464850607C424242020C
+04C5:000000001E1212121212122222430204
+04C6:0000000000001E121212122222430204
+04C7:00000000424242427E4242424242020C
+04C8:0000000000004242427E42424242020C
+04C9:00000000424242427E42424242430204
+04CA:0000000000004242427E424242430204
+04CB:000000004242424242463A0202060404
+04CC:00000000000042424242463A02060404
+04CD:00000000424266665A5A424242430204
+04CE:0000000000004266665A5A4242430204
+04CF:000000001C08080808080808081C0000
+04D0:42423C0018242442427E424242420000
+04D1:0042423C00003C42023E4242463A0000
+04D2:2424000018242442427E424242420000
+04D3:0000242400003C42023E4242463A0000
+04D4:000000001F2848487F484848484F0000
+04D5:0000000000003E49093F4848493E0000
+04D6:42423C007E4040407C404040407E0000
+04D7:000042423C003C42427E4040423C0000
+04D8:0000000018244202027E424224180000
+04D9:0000000000003C4202027E42423C0000
+04DA:2424000018244202027E424224180000
+04DB:0000242400003C4202027E42423C0000
+04DC:2424000049492A2A1C1C2A2A49490000
+04DD:00002424000049492A1C1C2A49490000
+04DE:242400003C4202023C040202423C0000
+04DF:0000242400003C42023C0402423C0000
+04E0:000000007E0408101C020202463C0000
+04E1:0000000000003E0408101C020202423C
+04E2:003C00004246464A4A52526262420000
+04E3:0000003C000046464A4A525262620000
+04E4:242400004246464A4A52526262420000
+04E5:00002424000046464A4A525262620000
+04E6:242400003C42424242424242423C0000
+04E7:0000242400003C4242424242423C0000
+04E8:000000003C4242427E424242423C0000
+04E9:0000000000003C42427E4242423C0000
+04EA:242400003C4242427E424242423C0000
+04EB:0000242400003C42427E4242423C0000
+04EC:000024003C4202023E020202423C0000
+04ED:0000000024003C42021E0202423C0000
+04EE:003E0000414122221414080810300000
+04EF:0000003C000042422424181810102060
+04F0:24240000414122221414080810300000
+04F1:00002424000042422424181810102060
+04F2:33440000414122221414080810300000
+04F3:00003344000042422424181810102060
+04F4:242400004242424242463A0202020000
+04F5:00002424000042424242463A02020000
+04F6:000000007E4040404040404040602020
+04F7:0000000000007E404040404040602020
+04F8:2424000042424242724A4A4A4A720000
+04F9:000024240000424242724A4A4A720000
+04FA:000000001F101010107C101010180818
+04FB:0000000000001F10107C101010180818
+04FC:00000000424224241818242442420204
+04FD:00000000000042422418182442420204
+04FE:0000000042422424187E242442420000
+04FF:000000000000424224187E2442420000
+0500:0000000202023E4242424242463A0000
+0501:000000020202023A46424242463A0000
+0502:0000000404043C44444545454D360000
+0503:00000004040404344C4444454D360000
+0504:00000000384444041805050505020000
+0505:00000000000038444404180505020000
+0506:00000000384444041804040404030101
+0507:00000000000038444404180404030101
+0508:000000003C2424242425254545820000
+0509:0000000000003C242424244545820000
+050A:00000000444444447C45454545460000
+050B:0000000000004444447C444545460000
+050C:000000003C424240404E424244380000
+050D:0000000000003C4240404E42423C0000
+050E:000000007F08080808090909090E0000
+050F:0000000000007F0808080909090E0000
+0510:000000003C4240403C204040423C0000
+0511:0000000000003C42403C2040423C0000
+0512:000000001E1212121212122222420A0C
+0513:0000000000001E121212122222420A0C
+0514:0000000071514A4A44444A4A51910000
+0515:00000000000071514A44444A51910000
+0516:00000000E192949890F0888482810000
+0517:00000000000001E294989894E2818080
+0518:000000007F8888887F284848888F0000
+0519:0000000000007E89897F282849460000
+051A:000000003C4242424242425A663C0300
+051B:0000000000003A4642424242463A0202
+051C:00000000424242425A5A666642420000
+051D:00000000000041494949494949360000
+051E:000000004A444A506060504844420000
+051F:00000000000054485460504844420000
+0520:00000000705050505E51519191910502
+0521:0000000000007050505E515191910502
+0522:0000000090909090FE91919191910502
+0523:000000000000909090FE919191910502
+0524:000000007C4444444444444444460202
+0525:0000000000007C444444444444460202
+0526:000000004040405C6242424242430101
+0527:00000000000040405C62424242430101
+0528:00000000111111111F11111111115020
+0529:0000000000001111111F111111115020
+052A:00000000000000000C4614481448145027E02460245044484444FE4282008200
+052B:0000000000000000000000001C461448245027E04450444844447E4242000000
+052C:000000004C4C5454547C2424447E4242
+052D:0000000000004C5454547C2424247E42
+052E:000000001E1212121212122222430101
+052F:0000000000001E121212122222430101
+0530:00007FFE73866DBE6D866DF673867FFE7FFE63CE7DB671B67DB663CE7FFE0000
+0531:00000000444444444444444745380000
+0532:000000003C4242407C42404040400000
+0533:0000000038444444443E050404040000
+0534:00000000384444040406050404040000
+0535:0000000040407C4240404042423C0000
+0536:000000001C222222221C0408107E0200
+0537:000000004040407C42404040407C0200
+0538:000000003C42424040404040407C0200
+0539:000000003844444F5454484040400000
+053A:00000000040404043F44444444380000
+053B:0000000040405C624240404040400000
+053C:000000004040404040404040407E0200
+053D:00000000404040794949494949460000
+053E:000000007E1824424242424224180000
+053F:00000000404042424242423E02020000
+0540:00000000081010081020406018060000
+0541:000000001C222222221C245848360000
+0542:00000000384444040404040404070100
+0543:000000000464182424424242427E0000
+0544:00000000474544444444444444380000
+0545:000000001C2202427C420202221C0000
+0546:00000000403010101010101011110E00
+0547:000000403C20404042424242423C0000
+0548:000000003C4242424242424242420000
+0549:000000001C222222221C040870180600
+054A:000000003E4949494909090101010000
+054B:000000001C2222120A0C0C08107E0200
+054C:00000000384444474544444444440000
+054D:000000004242424242424242423C0000
+054E:00000000040444444444443C04070100
+054F:000000003C424240300C0242423C0000
+0550:000000003C4242404040404040400000
+0551:000000003C4242423C420202423C0000
+0552:00000000404058644444434040400000
+0553:00000000103854545454545438100000
+0554:000000000C1212121C507C1410100000
+0555:000000003C42424242424242423C0000
+0556:00000000384848380E090909493E0000
+0557:00007FFE73866DBE6D866DF673867FFE7FFE61866FF661EE7DDE61DE7FFE0000
+0558:00007FFE73866DBE6D866DF673867FFE7FFE61CE6FB661CE7DB661CE7FFE0000
+0559:10202010000000000000000000000000
+055A:20101020000000000000000000000000
+055B:08183000000000000000000000000000
+055C:0C300000000000000000000000000000
+055D:20100800000000000000000000000000
+055E:38445418000000000000000000000000
+055F:3050403C000000000000000000000000
+0560:00000000000076494949494949490000
+0561:00000000000049494949494949370000
+0562:000000000000001C224242407E404040
+0563:0000000000003844444444443F040404
+0564:00000000000058644444444444470404
+0565:00000000004040407E404242221C0000
+0566:000000000000344C444444443C040407
+0567:0000000040407C404040404040380400
+0568:0000000000005C62424242424242407E
+0569:0000000000005864444F545448404040
+056A:000000000404043F4444444444380000
+056B:0000000040405C624242424242424040
+056C:0000000000004040404040404040407C
+056D:00000000404040794949494946404040
+056E:000000007008043F4444444444380000
+056F:000000002020222222222222221E0202
+0570:000000004040405C6242424242420000
+0571:000000000810083E42424242423E0000
+0572:00000000000058644444444444440407
+0573:000000000E11107F11111111130D0000
+0574:0000000002050444444444444C340000
+0575:0000000000000C040404040404044830
+0576:000000003C42404242424242463A0000
+0577:000000003844040808101020203F0000
+0578:0000000000005C624242424242420000
+0579:000000001020100808101020203F0000
+057A:00000000000049494949494949370101
+057B:000000003844442414181820203F0000
+057C:00000000000058644444444444470000
+057D:000000000000424242424242463A0000
+057E:0000000004040444444444444C340407
+057F:0000000000004A4D4949494959290000
+0580:0000000000005C624242424242424040
+0581:0000000000003A46424242463A02423C
+0582:000000000000180808080808080E0000
+0583:0000000008084A4D4949494959290808
+0584:0000000000000C1212121C103C101018
+0585:0000000000003C4242424242423C0000
+0586:00000000384848380E090909493E0808
+0587:000000004040404444444444443B0000
+0588:0000000000000C040404041E04044830
+0589:00000000000018180000001818000000
+058A:0000000000000000000000623C000000
+058B:00007FFE73866DBE6D866DF673867FFE7FFE738E6DB6738E6DB6738E7FFE0000
+058C:00007FFE73866DBE6D866DF673867FFE7FFE73C66DBE73BE6DBE73C67FFE0000
+058D:0000000000000DC012301248298827B027C81BC8232824901890076000000000
+058E:00000000000007601890249023281BC827C827B02988124812300DC000000000
+058F:00000000384444041F041F0404040000
+0590:00007FFE73866DBE6D866DF673867FFE7FFE73CE6DB671B67DB673CE7FFE0000
+0591:00000000000000000000000000207088
+0592:00180066000000000000000000000000
+0593:0C300C300C3000000000000000000000
+0594:00180018000000000000000000000000
+0595:002C202C000000000000000000000000
+0596:00000000000000000000000000808060
+0597:081C3E1C080000000000000000000000
+0598:0024524A240000000000000000000000
+0599:00C02020000000000000000000000000
+059A:00000000000000000000000000010201
+059B:000000000000000000000000D0D010E0
+059C:000C1010000000000000000000000000
+059D:00030404000000000000000000000000
+059E:00364848000000000000000000000000
+059F:0042A542240000000000000000000000
+05A0:00020502040000000000000000000000
+05A1:00506080000000000000000000000000
+05A2:00000000000000000000000000887020
+05A3:000000000000000000000000002020E0
+05A4:00000000000000000000000000408040
+05A5:000000000000000000000000002020C0
+05A6:000000000000000000000000002424D8
+05A7:00000000000000000000006080601060
+05A8:00C02020000000000000000000000000
+05A9:0040A040200000000000000000000000
+05AA:00000000000000000000000000009060
+05AB:00102010000000000000000000000000
+05AC:0004041C000000000000000000000000
+05AD:00000000000000000000000000040403
+05AE:0048A8A8900000000000000000000000
+05AF:00182424180000000000000000000000
+05B0:00000000000000000000000000180018
+05B1:000000000000000000000000002A0012
+05B2:000000000000000000000000003A0002
+05B3:000000000000000000000000003A1012
+05B4:00000000000000000000000000001818
+05B5:00000000000000000000000000006666
+05B6:00000000000000000000000000660018
+05B7:00000000000000000000000000003C00
+05B8:000000000000000000000000003E0808
+05B9:00003030000000000000000000000000
+05BA:00006060000000000000000000000000
+05BB:00000000000000000000000000200802
+05BC:00000000000000001800000000000000
+05BD:00000000000000000000000000080808
+05BE:0000007E000000000000000000000000
+05BF:0000003C000000000000000000000000
+05C0:00000000000808080808080808080000
+05C1:00000606000000000000000000000000
+05C2:00006060000000000000000000000000
+05C3:000000000000081C080000081C080000
+05C4:18180000000000000000000000000000
+05C5:00000000000000000000000000001818
+05C6:000000000038202020202020203C0000
+05C7:000000000000000000000000003E0808
+05C8:00007FFE73866DBE6D866DF673867FFE7FFE71CE6FB66FCE6FB671CE7FFE0000
+05C9:00007FFE73866DBE6D866DF673867FFE7FFE71CE6FB66FC66FF671CE7FFE0000
+05CA:00007FFE73866DBE6D866DF673867FFE7FFE71866FB66F866FB671B67FFE0000
+05CB:00007FFE73866DBE6D866DF673867FFE7FFE718E6FB66F8E6FB6718E7FFE0000
+05CC:00007FFE73866DBE6D866DF673867FFE7FFE71C66FBE6FBE6FBE71C67FFE0000
+05CD:00007FFE73866DBE6D866DF673867FFE7FFE718E6FB66FB66FB6718E7FFE0000
+05CE:00007FFE73866DBE6D866DF673867FFE7FFE71866FBE6F8E6FBE71867FFE0000
+05CF:00007FFE73866DBE6D866DF673867FFE7FFE71866FBE6F8E6FBE71BE7FFE0000
+05D0:0000000000424222122C484442420000
+05D1:00000000007C040404040404047F0000
+05D2:000000000030080808040C1422420000
+05D3:00000000007E04040404040404040000
+05D4:00000000007E02022222222222220000
+05D5:00000000003808080808080808080000
+05D6:0000000000300C0A0808080808080000
+05D7:00000000007E22222222222222220000
+05D8:0000000000464A4242424242427E0000
+05D9:00000000003808080800000000000000
+05DA:00000000007E02020202020202020202
+05DB:00000000007E020202020202027C0000
+05DC:00000020203E02020202040408300000
+05DD:0000000000FE222222222222223E0000
+05DE:00000000004E31214141414141470000
+05DF:00000000003808080808080808080808
+05E0:00000000001C040404040404043C0000
+05E1:00000000007E42424242424244780000
+05E2:00000000001212121212121212FE0000
+05E3:00000000007E42424272020202020202
+05E4:00000000007E424242720202027E0000
+05E5:00000000002222242830202020202020
+05E6:000000000042422418080402027E0000
+05E7:00000000007E22222424282020202020
+05E8:00000000007E02020202020202020000
+05E9:000000000049494949494949497F0000
+05EA:00000000003E22222222222222620000
+05EB:00007FFE73866DBE6D866DF673867FFE7FFE618E6FB6638E6FB6618E7FFE0000
+05EC:00007FFE73866DBE6D866DF673867FFE7FFE61C66FBE63BE6FBE61C67FFE0000
+05ED:00007FFE73866DBE6D866DF673867FFE7FFE618E6FB663B66FB6618E7FFE0000
+05EE:00007FFE73866DBE6D866DF673867FFE7FFE61866FBE638E6FBE61867FFE0000
+05EF:00000000003808087711111100000000
+05F0:00000000007711111111111111110000
+05F1:00000000007711111101010101010000
+05F2:00000000007711111100000000000000
+05F3:00000204080000000000000000000000
+05F4:00001224480000000000000000000000
+05F5:00007FFE73866DBE6D866DF673867FFE7FFE61866FBE63866FF66F867FFE0000
+05F6:00007FFE73866DBE6D866DF673867FFE7FFE61CE6FBE638E6FB66FCE7FFE0000
+05F7:00007FFE73866DBE6D866DF673867FFE7FFE61866FF663EE6FDE6FDE7FFE0000
+05F8:00007FFE73866DBE6D866DF673867FFE7FFE61CE6FB663CE6FB66FCE7FFE0000
+05F9:00007FFE73866DBE6D866DF673867FFE7FFE61CE6FB663C66FF66FCE7FFE0000
+05FA:00007FFE73866DBE6D866DF673867FFE7FFE61866FB663866FB66FB67FFE0000
+05FB:00007FFE73866DBE6D866DF673867FFE7FFE618E6FB6638E6FB66F8E7FFE0000
+05FC:00007FFE73866DBE6D866DF673867FFE7FFE61C66FBE63BE6FBE6FC67FFE0000
+05FD:00007FFE73866DBE6D866DF673867FFE7FFE618E6FB663B66FB66F8E7FFE0000
+05FE:00007FFE73866DBE6D866DF673867FFE7FFE61866FBE638E6FBE6F867FFE0000
+05FF:00007FFE73866DBE6D866DF673867FFE7FFE61866FBE638E6FBE6FBE7FFE0000
+0600:5555800000018000000180000001800000018004000980083FFD80000001AAAA
+0601:55558000000180000001800000018000000180042A0DAA0C35F580000001AAAA
+0602:5555800000018000000180000001800000018E000E1987E0000180000001AAAA
+0603:555580000001800000018000001980240045814401499EF0000180000001AAAA
+0604:55558000000180000001800000018000000180000195827C0201BF000001AAAA
+0605:55558000000188041619A1E0000180000001800000018000000180000001AAAA
+0606:000000A870A810D0088008800480040002700240014001800180010001000000
+0607:00200040708010A0084008900460040002700240014001800180010001000000
+0608:000000000000000000640E9832B004500410082007C000000000000000000000
+0609:00000004042808101020204450000000
+060A:00000004042808101020214450000000
+060B:000000000600060000C0012000E0002001C01E10000800080000000000000000
+060C:00000000000000081018180000000000
+060D:00000000000000000C18204000000000
+060E:0000000000000000000000000000000000000E00110011060FF8000000000000
+060F:0000000000000600080008000600080013001480188009001600200000000000
+0610:00060939160000000000000000000000
+0611:0000003000400278038004000800000000000000000000000000000000000000
+0612:00001F880208041008E008000000000000000000000000000000000000000000
+0613:0000060809083910166000000000000000000000000000000000000000000000
+0614:0000000000081FC8002800100000000000000000000000000000000000000000
+0615:0000040005C006200FC000000000000000000000000000000000000000000000
+0616:0500050005000D0010000FE00000000000000000000000000000000000000000
+0617:0000008000000080008003000000000000000000000000000000000000000000
+0618:00001800000000000000000000000000
+0619:181C1020000000000000000000000000
+061A:00000000000000000000000000001800
+061B:00000000000000081018001800000000
+061C:AAAA000180000001B2224A37FA2A4A23CBA20001800000018000000180005555
+061D:00007FFE73CE6DBE6D8E6DB673CE7FFE7FFE7B8E73B67BB67BB6718E7FFE0000
+061E:0000000000000000000000000000000000000000000000800000014000000000
+061F:0000003E414020100808000800000000
+0620:000000000000000C5248443810281000
+0621:000000000000001C203C102000000000
+0622:00013E40080808080808080000000000
+0623:18201820080808080808080000000000
+0624:00000C100C10000C12121E0204483000
+0625:0000000008080808080808000C100C10
+0626:00000000182018200046484846423C00
+0627:00000008080808080808080000000000
+0628:000000000000000422423C0000080000
+0629:000000002400101824243C0000000000
+062A:000000001400000422423C0000000000
+062B:000010002800000422423C0000000000
+062C:00000000000000007E1020404840221C
+062D:00000000000000007E1020404040221C
+062E:00000000001000007E1020404040221C
+062F:000000000000080402427C0000000000
+0630:000000002000080402427C0000000000
+0631:00000000000000000402020204483000
+0632:00000000001000000402020204483000
+0633:00000000000000000115155E48483000
+0634:00000008001200000115155E48483000
+0635:000000000000000006194E4848300000
+0636:000000000004000006194E4848300000
+0637:000000202020202C32227C0000000000
+0638:000000202420202C32227C0000000000
+0639:000000000000001824201C204040423C
+063A:000000000800001824201C204040423C
+063B:00005004081020403C827E0000000000
+063C:00000004081020403C827E0028001000
+063D:0000000010284400044A484442423C00
+063E:0000000000005000044A484442423C00
+063F:0000000000200050044A484442423C00
+0640:00000000000000000000FF0000000000
+0641:0000000800060A0642423C0000000000
+0642:000000002400001C120A264244380000
+0643:000000020A120A2242423C0000000000
+0644:000000020202020202224242443C0000
+0645:00000000000000001C061E2020202020
+0646:00000000001000000422424244380000
+0647:000000000000101824243C0000000000
+0648:000000000000000C12121E0204483000
+0649:0000000000000000044A484442423C00
+064A:0000000000000000044A4844423C0028
+064B:0C300C30000000000000000000000000
+064C:0C0C6428700000000000000000000000
+064D:0000000000000000000008300C300000
+064E:00000C30000000000000000000000000
+064F:0C0E0810200000000000000000000000
+0650:00000000000000000000000000000C30
+0651:00000004145860000000000000000000
+0652:18242418000000000000000000000000
+0653:00013E40000000000000000000000000
+0654:18201820000000000000000000000000
+0655:00000000000000000000000018201820
+0656:0000000000000000000000000000000000000000000000000000004000200020
+0657:04081070300000000000000000000000
+0658:24241800000000000000000000000000
+0659:0000003C000000000000000000000000
+065A:00442810100000000000000000000000
+065B:00101028440000000000000000000000
+065C:00000000000000000000000018180000
+065D:30701008040000000000000000000000
+065E:24081024000000000000000000000000
+065F:00000000000000000000000006082658
+0660:00000000000010381000000000000000
+0661:00000020201010080804040400000000
+0662:00000022241810080804040400000000
+0663:00000049523C20101008080800000000
+0664:00000004081020182040423C00000000
+0665:00000018242442424242241800000000
+0666:000000403C0404020202010100000000
+0667:00000041412222141408080800000000
+0668:00000008080814142222414100000000
+0669:0000001824444C340202010100000000
+066A:00000404484810102424404000000000
+066B:00000000000000000004040438000000
+066C:00000018180810000000000000000000
+066D:000000000008087F1C36220000000000
+066E:000000000000000422423C0000000000
+066F:000000000000001C120A264244380000
+0670:10101000000000000000000000000000
+0671:040A1E20080808080808080000000000
+0672:06082658000808080808080000000000
+0673:00000000080808080808080006082658
+0674:18201820000000000000000000000000
+0675:06080608202020202020200000000000
+0676:000003040304000C12121E0204483000
+0677:000033341324400C12121E0204483000
+0678:00000000030403040046484846423C00
+0679:000020203838000422423C0000000000
+067A:000010001000000422423C0000000000
+067B:000000000000000422423C0008000800
+067C:000000001400000422423C0814080000
+067D:000028001000000422423C0000000000
+067E:000000000000000422423C0014000800
+067F:000028002800000422423C0000000000
+0680:000000000000000422423C0014001400
+0681:00000018201820007E1020404040221C
+0682:00000010001000007E1020404040221C
+0683:00000000000000007E1020405440221C
+0684:00000000000000007E1020484048221C
+0685:00000010002400007E1020404040221C
+0686:00000000000000007E2040544048221C
+0687:00000000000000007E2040544054221C
+0688:002020383800080402427C0000000000
+0689:000000000000080402427C0814080000
+068A:000000000000080402427C0008000000
+068B:002020383800080402427C0008000000
+068C:000000280000080402427C0000000000
+068D:000000000000080402427C0028000000
+068E:000010002800080402427C0000000000
+068F:000028001000080402427C0000000000
+0690:000028002800080402427C0000000000
+0691:000008080E0E00000402020204483000
+0692:00000000442810000402020204483000
+0693:000000000000000004020202044C3A04
+0694:00000000000000000402020204483200
+0695:00000000000000000804040408483502
+0696:00000000000000000402021204483200
+0697:00000000001200000402020204483000
+0698:00000008001400000402020204483000
+0699:00000012001200000402020204483000
+069A:000000000400000115155E484A300000
+069B:000000000000000115155E5055200200
+069C:000008001200000115155E5055200200
+069D:000000000000000006194E5055200000
+069E:000000080012000006194E4848300000
+069F:00000024202A202C32227C0000000000
+06A0:000010002400001824201C204040423C
+06A1:0000000000060A0642423C0000000000
+06A2:0000000000060A0642423C0008000000
+06A3:0000040000060A0642423C0008000000
+06A4:0008001200060A0642423C0000000000
+06A5:0000000000060A0642423C0024001000
+06A6:000A000A00060A0642423C0000000000
+06A7:000000000400001C120A264244380000
+06A8:000010002400001C120A264244380000
+06A9:00000004081020403C827E0000000000
+06AA:0000000000000018006001800600080007FC40023FFC00000000000000000000
+06AB:000000040C1A24403C827E0000000000
+06AC:000800020A120A2242423C0000000000
+06AD:100028020A120A2242423C0000000000
+06AE:000000020A120A2242423C0014000800
+06AF:00081024481020403C827E0000000000
+06B0:000810244C1A24403C827E0000000000
+06B1:00500618620C30403C827E0000000000
+06B2:00081024481020403C827E0028000000
+06B3:00081024481020403C827E0010001000
+06B4:4000A618620C30403C827E0000000000
+06B5:00110A040002020202224242443C0000
+06B6:000200020202020202224242443C0000
+06B7:040009000202020202224242443C0000
+06B8:00000002020202020222423C00140008
+06B9:00000000000800000422424244380008
+06BA:00000000000000000422424244380000
+06BB:000010101C1C00000422424244380000
+06BC:000000000008000004224242443C0A04
+06BD:00000010002400000422424244380000
+06BE:000000000000102C2A1A244000000000
+06BF:00000000001000007E2040544048221C
+06C0:001820182000101824243C0000000000
+06C1:000000000000000000102F4000000000
+06C2:000000001820182000102F4000000000
+06C3:000000000000280000102F4000000000
+06C4:000000000000000C12120E2252247800
+06C5:000000000000000C12121E021C483000
+06C6:000000221408000C12121E0204483000
+06C7:000018180810200C12121E0204483000
+06C8:000000080404000C12121E0204483000
+06C9:000000081422000C12121E0204483000
+06CA:000000001400000C12121E0204483000
+06CB:000008001200000C12121E0204483000
+06CC:0000000000000000044A484442423C00
+06CD:0000000000000000042A68A422221C00
+06CE:0000000044281000044A484442423C00
+06CF:000000000800000C12121E0204483000
+06D0:000000000000000C5248443800100010
+06D1:000000000000000C5248443800280010
+06D2:00000000000000000008141020407F00
+06D3:00000000003040304008141020407F00
+06D4:000000000000000000003C0000000000
+06D5:000000000000101824243C0000000000
+06D6:0208025C0FFC10001FC000000000000000000000000000000000000000000000
+06D7:024802200FE010001FC000000000000000000000000000000000000000000000
+06D8:0000004000A001E0060000000000000000000000000000000000000000000000
+06D9:0880048003000100030000000000000000000000000000000000000000000000
+06DA:1F8004000900042003C000000000000000000000000000000000000000000000
+06DB:4000A000000000000000000000000000
+06DC:0000012809F80900060000000000000000000000000000000000000000000000
+06DD:0000000001C006300BE80C181004100410040C180BE8063001C0000000000000
+06DE:0000008001401FFC1414180C11C432265225322611C4180C14141FFC01400080
+06DF:18242418000000000000000000000000
+06E0:18242424180000000000000000000000
+06E1:7E0C3000000000000000000000000000
+06E2:0180038002000200010000000000000000000000000000000000000000000000
+06E3:000000000000000000000000000000000000000000000000012809F809000600
+06E4:7C000000000000000000000000000000
+06E5:0000000000000000040A0E021C000000
+06E6:00000000000000001020407F00000000
+06E7:001020407F0000000000000000000000
+06E8:000000800420042003E000000000000000000000000000000000000000000000
+06E9:00000080014002A005500AA815542A2A15541554155415D4141417F430067FFF
+06EA:0100028004400280010000000000000000000000000000000000000000000000
+06EB:0000000000000000000000000000000000000000000001000280044002800100
+06EC:0000018001800000000000000000000000000000000000000000000000000000
+06ED:0000000000000000000000000000000000000000000000000180010001000080
+06EE:000008142200080402427C0000000000
+06EF:00000000040A11000402020204483000
+06F0:00000000000010381000000000000000
+06F1:00000020201010080804040400000000
+06F2:00000022241810080804040400000000
+06F3:00000049523C20101008080800000000
+06F4:000000182460722C2010101000000000
+06F5:00000000080814142222495563000000
+06F6:000000001C2220201806186000000000
+06F7:00000041412222141408080800000000
+06F8:00000008080814142222414100000000
+06F9:0000001824444C340202010100000000
+06FA:000008001200000115155E484A300000
+06FB:000000000004000006194E484A300000
+06FC:000000000800001824201C204840423C
+06FD:0000000000001C203C10200014141414
+06FE:00000000000000001C063E404A4A4A4A
+06FF:000000102844102C2A1A244000000000
+0700:000000000000000001000380010008201C700820010003800100000000000000
+0701:0000000000001800180000000000000000000000000000000000000000000000
+0702:0000000000000000000000000000000000001800180000000000000000000000
+0703:0000000000001800180000000000000000001800180000000000000000000000
+0704:0000000000000000000000000000000018001800000000000000000018001800
+0705:0000000000000000000000006600660000000000000000000000000000000000
+0706:0000000000000000000000006000600000000000060006000000000000000000
+0707:0000000000000000000000000600060000000000000060006000000000000000
+0708:0000000060006000000000000600060000000000000000000000000000000000
+0709:0000000000000000000000000000000000000000600060000000000006000600
+070A:0000240024007E00000000000000000018001800000000000000000018001800
+070B:00000000000000007FFE00000000018001800000000000000000000000000000
+070C:00004000200010000800040002000100008000400024001C001C003C00000000
+070D:00000180018019981998018001807FFE7FFE0180018019981998018001800000
+070E:00007FFE73866DF66DEE6DDE73DE7FFE7FFE73866DBE6D8E6DBE73867FFE0000
+070F:AAAA0001B18C3FFDB18C000180000001B32244B7A7AA14A3E4A2000180005555
+0710:0000000000070007000E003C7FF8FFC0C600C300C1C0C0F04070000000000000
+0711:02000C00780050000C0000000000000000000000000000000000000000000000
+0712:000000000000000000000C000FF007F80008600860087FF83FF0000000000000
+0713:00000600070003000180018070C07C600F3003F000F8001C0006000000000000
+0714:00000600070003000180018073C07E600F3003F000F8001C0006000000000000
+0715:0000000000003F003E000E000600060006000600260006000200000000000000
+0716:0000000000003F003E000E000600060006000600060006000200000000000000
+0717:000000000000000000001F783FFC60844082408241026106320C000000000000
+0718:0000000000000000000007800CC0186010201030101019980F98000000000000
+0719:0000000000000C000E000E000600060006000600060006000200000000000000
+071A:00000000000000000000030C030C010601020082408260843FFC1F7800000000
+071B:00000C000E00060003000100018060807FF83FFC004200420042002400180000
+071C:00000C000E00060003000100018060807FF83FFC0042005A005A002400180000
+071D:000000000000000000000000000000000000300018000C000C000C0018003000
+071E:000002000000050000001DC03FE062204224422244126412240C008000000000
+071F:00000000000000001800186018701C9804980788030C00040004000200020001
+0720:000000000E000E0006000300018000C00060303030303FF01FF0000000000000
+0721:00000000000070007E001FF803FC03040304030403FC06F80C00180010000000
+0722:00000000000000000000000000001C003E003F8007C000F00018000400020000
+0723:000000000000000000003C00667843CC4184618431881FF00FE0000000000000
+0724:000000000000000000003C00667843CC4184618431881FF00FE0018001800000
+0725:00000000000000000000000003000300018060C060607FFE3FFE000000000000
+0726:000000000000000001E002300210021801E8600C60047FFE3FFE000000000000
+0727:00000000000000000F001880108030802F00600C400CFFFCFFF8000000000000
+0728:0000000000000000001000380FFC1FFC10000C0003C0003000180038FFF00000
+0729:00000000000000000000000001F003F802080204020413FC17FC0C0000000000
+072A:0200000000003F003E000E000600060006000600060006000200000000000000
+072B:0000000000000000000006600FF00FF007E003C061867FFE3FFE000000000000
+072C:000060007000300008C005E0061006100A081108208C3F8C1F0C000000000000
+072D:000000000020006000C0018003FC03FE0002000260027FFE3FFC000000000000
+072E:00000300018019801F000C000200010060807C403FE007F8001C000600020000
+072F:0000000000003F003E000E000600060006000600460006001200000000000000
+0730:3E00240028003000200000000000000000000000000000000000000000000000
+0731:0000000000000000000000000000000000000000000004000C00140024007C00
+0732:0000000004000000000000000000000000000000000000000000000020000000
+0733:1800240024001800100020000000000000000000000000000000000000000000
+0734:0000000000000000000000000000000000000000040008001800240024001800
+0735:0000080000002000000000000000000000000000000000000000000000000000
+0736:180004000A001200000000000000000000000000000000000000000000000000
+0737:0000000000000000000000000000000000000000000000002400280010000C00
+0738:0000000000000000000000000000000000000000000000000000000000002400
+0739:0000000000000000000000000000000000000000000000000000000008002000
+073A:7C0010007C000000000000000000000000000000000000000000000000000000
+073B:00000000000000000000000000000000000000000000000000003E0008003E00
+073C:0000000000000000000000000000000000000000000000000000000000001000
+073D:0100020005000880124005200210000000000000000000000000000000000000
+073E:0000000000000000000000000000000000001080094004900220014000800100
+073F:0000000000000800000000000000000000000000000000000000000000000000
+0740:0000000000002000000000000000000000000000000000000000000000000000
+0741:0000000000001000000000000000000000000000000000000000000000000000
+0742:0000000000000000000000000000000000000000000000000000000010000000
+0743:0000100000001000000000000000000000000000000000000000000000000000
+0744:0000000000000000000000000000000000000000000000000000100000001000
+0745:0000100000002800000000000000000000000000000000000000000000000000
+0746:0000000000000000000000000000000000000000000000000000280000001000
+0747:0000000008001000200000000000000000000000000000000000000000000000
+0748:0000000000000000000000000000000000000000000000000000200010000800
+0749:012000D000E8017400BA005C002C001200000000000000000000000000000000
+074A:540010007C001000540000000000000000000000000000000000000000000000
+074B:00007FFE73866DF66DEE6DDE73DE7FFE7FFE6D8E6DB6618E7DB67D8E7FFE0000
+074C:00007FFE73866DF66DEE6DDE73DE7FFE7FFE6DC66DBE61BE7DBE7DC67FFE0000
+074D:00001818181818180C300C30042004600660066002C002C003C0018001800000
+074E:00000000000C000600E600FC003000100008000860047FFE3FFE000000000000
+074F:00000180018000C0002C00320012001C0008000860047FFE3FFE000000000000
+0750:000000000000000422423C00002A0000
+0751:000000100028000422423C0000080000
+0752:000000000000000422423C0008001400
+0753:000000000820000422423C0008001400
+0754:000000000010000422423C0000140000
+0755:000000000000000422423C0008142200
+0756:000000442810000422423C0000000000
+0757:00000000000028007E1020404040221C
+0758:00000000000000007E1024404A40221C
+0759:202028347800080402427C0010001000
+075A:000000000000080402427C0008142200
+075B:00000000000000000402021F04483000
+075C:00000000001400140115155E48483000
+075D:000000000028001824201C204040423C
+075E:000000280010001824201C204040423C
+075F:000000100010001824201C204040423C
+0760:0000000000060A0642423C000A000000
+0761:0000000000060A0642423C0004000A00
+0762:00000004881020403C827E0000000000
+0763:004000A4081020403C827E0000000000
+0764:00000004081020403C827E0008001400
+0765:00000000000800001C061E2020202020
+0766:00000000000000001C061E2028202020
+0767:00000000000020000422424244380014
+0768:20202834780020000422424244380000
+0769:00004428100020000422424244380000
+076A:000000040404041E0424444444380000
+076B:00000000100010000402020204483000
+076C:00000018201820000402020204483000
+076D:00000000040004000115155E48483000
+076E:00000000000000007E10284C4A5C221C
+076F:00000000007E10284C4A5C405440221C
+0770:00202028347800140115155E48483000
+0771:20202834780010400402020204483000
+0772:00001010141A3C007E1020404040221C
+0773:28283020282808080808080000000000
+0774:2A2A3420282808080808080000000000
+0775:00000014141810101046484846423C00
+0776:00000015151A10101046484846423C00
+0777:0000000046484846423C000816101010
+0778:000050506040404C12121E0204483000
+0779:000054546840404C12121E0204483000
+077A:00000000005050604048541020407F00
+077B:00000000005454684048541020407F00
+077C:00000000000000007E10244B4848221C
+077D:00000008161010100115155E48483000
+077E:00000000081422000115155E48483000
+077F:000028020A120A2242423C0000000000
+0780:00000000000004081060000000000000
+0781:000000000000121C1020C00000000000
+0782:0000000000002A342040800000000000
+0783:00000000000014081420C00000000000
+0784:00000000000028545438000000000000
+0785:0000000000001024381020C000000000
+0786:00000000000044485060000000000000
+0787:000000000000060A1222C20000000000
+0788:00000000000008141408106000000000
+0789:0000000000001C240810600000000000
+078A:00000000000408040804081060000000
+078B:0000000000000204021C20C000000000
+078C:0000000000000C122C4020C000000000
+078D:00000000000008103C08106000000000
+078E:00000000000000040810087000000000
+078F:0000000000002A342040403800000000
+0790:0000000000000000000000000000000030043FF8400000000000000000000000
+0791:00000000000018601860180600000000
+0792:00000000000028102840403800000000
+0793:00000000000028545438403800000000
+0794:00000000000000161A22C00000000000
+0795:00000000000408040804081260000000
+0796:00000000000004080438403800000000
+0797:0000000102040C122C4020C000000000
+0798:000000000004110C122C4020C0000000
+0799:00000000000004081064000000000000
+079A:00000000001004081060000000000000
+079B:0000000000080204021C20C000000000
+079C:0000000000080014081420C000000000
+079D:0000000000000000000000000080022030043FF8400000000000000000000000
+079E:0000000000000000000000000000000030043FF8400000800000000000000000
+079F:0000000000000000000000000000008030043FF8400000000000000000000000
+07A0:0000000000000C122C4028C000000000
+07A1:000000000004000C122C4020C0000000
+07A2:000000000000060A1222C20800000000
+07A3:00000000000400060A32C20000000000
+07A4:00000000000014000C10087000000000
+07A5:00000000000800081414081060000000
+07A6:00081020000000000000000000000000
+07A7:00122448000000000000000000000000
+07A8:00000000000000000000000000102040
+07A9:00000000000000000000000000122448
+07AA:00300810200000000000000000000000
+07AB:00661122440000000000000000000000
+07AC:00081020180000000000000000000000
+07AD:00224488660000000000000000000000
+07AE:00621428460000000000000000000000
+07AF:1C244840300000000000000000000000
+07B0:00182418000000000000000000000000
+07B1:00000000000010282810204038000000
+07B2:00007FFE73866DF66DEE6DDE73DE7FFE7FFE63866DF663866DBE63867FFE0000
+07B3:00007FFE73866DF66DEE6DDE73DE7FFE7FFE638E6DF663C66DF6638E7FFE0000
+07B4:00007FFE73866DF66DEE6DDE73DE7FFE7FFE63B66DB663866DF663F67FFE0000
+07B5:00007FFE73866DF66DEE6DDE73DE7FFE7FFE63866DBE63866DF663867FFE0000
+07B6:00007FFE73866DF66DEE6DDE73DE7FFE7FFE63CE6DBE638E6DB663CE7FFE0000
+07B7:00007FFE73866DF66DEE6DDE73DE7FFE7FFE63866DF663EE6DDE63DE7FFE0000
+07B8:00007FFE73866DF66DEE6DDE73DE7FFE7FFE63CE6DB663CE6DB663CE7FFE0000
+07B9:00007FFE73866DF66DEE6DDE73DE7FFE7FFE63CE6DB663C66DF663CE7FFE0000
+07BA:00007FFE73866DF66DEE6DDE73DE7FFE7FFE63866DB663866DB663B67FFE0000
+07BB:00007FFE73866DF66DEE6DDE73DE7FFE7FFE638E6DB6638E6DB6638E7FFE0000
+07BC:00007FFE73866DF66DEE6DDE73DE7FFE7FFE63C66DBE63BE6DBE63C67FFE0000
+07BD:00007FFE73866DF66DEE6DDE73DE7FFE7FFE638E6DB663B66DB6638E7FFE0000
+07BE:00007FFE73866DF66DEE6DDE73DE7FFE7FFE63866DBE638E6DBE63867FFE0000
+07BF:00007FFE73866DF66DEE6DDE73DE7FFE7FFE63866DBE638E6DBE63BE7FFE0000
+07C0:00000000182424424242422424180000
+07C1:000000001814121010101010107E0000
+07C2:000000002222223E2020202020200000
+07C3:000000000404040404043C04043C0000
+07C4:0000000004040404043C2020203C0000
+07C5:00000000202020203820202020200000
+07C6:00000000404040407C04040404040000
+07C7:00000000404040404244485060600000
+07C8:00000000404040407E44485060600000
+07C9:00000000384444443810101010100000
+07CA:00000000101010101010101010100000
+07CB:00000000000000001824424224180000
+07CC:00000000824428281010101010100000
+07CD:00000000000000000010282844440000
+07CE:000000000000000044444444447C0000
+07CF:00000000000000007C040404047C0000
+07D0:000000003844444438101010107C0000
+07D1:000000000010202018000000007E0000
+07D2:000000001028281E0A12020202020000
+07D3:000000003C20203C2020202020200000
+07D4:000000003C04043C0404040404040000
+07D5:00000000404040407844444444780000
+07D6:000000003E2020101008080404040000
+07D7:00000000182848080808080808080000
+07D8:00000000000000002C525252527E0000
+07D9:00000000080808083E08080808080000
+07DA:00000000242424247E242424243C0000
+07DB:00000000000000007E424242427E0000
+07DC:00000000000000007C44442828100000
+07DD:00000000040A0A0A0C78484848780000
+07DE:000000000424243C2424040404040000
+07DF:00000000304848483E08080808080000
+07E0:000000007C1010101010101010100000
+07E1:000000000000000010282844447C0000
+07E2:00000000701010384444381010100000
+07E3:000000003E2222020202020202020000
+07E4:0000000020203C242404040404040000
+07E5:000000003C0404043C242424243C0000
+07E6:00000000101010384444381010100000
+07E7:000000007C1010384444381010100000
+07E8:0000000000000000000000001070121C
+07E9:00000000000000000000000010741A1C
+07EA:000000000000000000000008083E0808
+07EB:00003C00000000000000000000000000
+07EC:122C4000000000000000000000000000
+07ED:00100000000000000000000000000000
+07EE:10284400000000000000000000000000
+07EF:08047E00000000000000000000000000
+07F0:48340200000000000000000000000000
+07F1:10207E00000000000000000000000000
+07F2:00000000000000000000000000000010
+07F3:00002400000000000000000000000000
+07F4:00000000003008081000000000000000
+07F5:00000000001020201800000000000000
+07F6:000000001C2222221E040810203E0000
+07F7:000000001C222A224155412A1C000000
+07F8:000000000000181800000000003C0000
+07F9:0000000000003C000018180018180000
+07FA:00000000000000000000000000FF0000
+07FB:00007FFE73866DF66DEE6DDE73DE7FFE7FFE618E6FB6638E6FB66F8E7FFE0000
+07FC:00007FFE73866DF66DEE6DDE73DE7FFE7FFE61C66FBE63BE6FBE6FC67FFE0000
+07FD:00000000000000000000000000007E42
+07FE:00000000000000002C5252527E107C10
+07FF:0000000040F040407844444444780000
+0800:000000000000000000000008011002A0044008240828103010200C4000000000
+0801:0000000000000000000000000380044008200FE00010001000083FF800000000
+0802:000000000000000000000000003007C00440084000200010002000C000000000
+0803:00000000000000000000000003F8042008100FF0000800080010002000000000
+0804:000000000000000000000000003007C004C00940026004900520004000000000
+0805:000000000000000000000000004007A004900900030004E00010002000000000
+0806:000000000000000000000000038004401C6013901010101010201CC000000000
+0807:000000000000000000000000002007C004C0094032600C900510022000000000
+0808:000000000000000000000200040009F0111008A004A002400140008000000000
+0809:000000000000000000000000000000F003900490049009200920092000000000
+080A:0000000000000000000008080C081FF0001000100010021007900FF000000000
+080B:00000000000000000000008000800080030004000800081018301FF000000000
+080C:00000000000000000000000008881DD81FF82008000808101E103FF000000000
+080D:00000000040004000400080008000FF0001000100010021007900FF000000000
+080E:0000000000000000060009000A0019C00078009008A01F600100020007800000
+080F:00000000000000000000000000001FE008400440028001800080000000000000
+0810:00000000000000000000000000000FF0001000100010021007900FF000000000
+0811:000000000000000000000000000003F014901C90149005201920092000000000
+0812:000000000000000000000000080007E00610091000A000400180020001800000
+0813:00000000000000000000000003C0042008100FF0000800080010002000000000
+0814:00000000000000000000000008881DD81FF82004000000000000000000000000
+0815:00000000000000000000000001000280044008240828103010200C4000000000
+0816:00000010002000280012000C0000000000000000000000000000000000000000
+0817:000000100010001200140016000C000000000000000000000000000000000000
+0818:00000FFC00000000000000000000000000000000000000000000000000000000
+0819:0080004000200040008000000000000000000000000000000000000000000000
+081A:0000071008E00000000000000000000000000000000000000000000000000000
+081B:0000071008E00000000000000000000000000000000000000000000000000000
+081C:0000440044002800280010001000000000000000000000000000000000000000
+081D:0000440028001000000000000000000000000000000000000000000000000000
+081E:0000100010001000100010001000100010000000000000000000000000000000
+081F:0000100010001000100010000000000000000000000000000000000000000000
+0820:0000100010001000000000000000000000000000000000000000000000000000
+0821:00007F8000000000000000000000000000000000000000000000000000000000
+0822:00001F0000000000000000000000000000000000000000000000000000000000
+0823:00000E0000000000000000000000000000000000000000000000000000000000
+0824:0000008000800100010002000200000000000000000000000000000000000000
+0825:0000080008001000100020002000000000000000000000000000000000000000
+0826:0000100010002800280044004400000000000000000000000000000000000000
+0827:0000100028004400000000000000000000000000000000000000000000000000
+0828:0000008001000200010000800000000000000000000000000000000000000000
+0829:000003000C0030000C0003000000000000000000000000000000000000000000
+082A:0000020004000800040002000000000000000000000000000000000000000000
+082B:0000100010002800280044007C00000000000000000000000000000000000000
+082C:000000C00120012000C000000000000000000000000000000000000000000000
+082D:0000018001800000000000000000000000000000000000000000000000000000
+082E:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE61867DBE618E6FBE61867FFE0000
+082F:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE61867DBE618E6FBE61BE7FFE0000
+0830:0000000000000000000000000180018000000000000000000000000000000000
+0831:0000000000000000018001800000000000000000018001800000000000000000
+0832:0000000000000000000000000C600C6000000000000000000000000000000000
+0833:000000000000000000003F183018100008000400020002000400000000000000
+0834:000000000000000000003F183018100008000400021802180400000000000000
+0835:000000000000000000000240000003C004000400030000C00000000000000000
+0836:00000000003000300000008000400040008001000200060007E0000000000000
+0837:00000000000000000000007E006000207F900008000400040008000000000000
+0838:000000000000000000000000000000067FE60000000000000000000000000000
+0839:000000000000000000000006000600007FE00000000600060000000000000000
+083A:0000000000000000000000067FE600000000000000067FE60000000000000000
+083B:0000000000000000000004600460040004000400046004600000000000000000
+083C:0000000000000010002000400080010002000400080010002000000000000000
+083D:0000000000000010002000400080011802180400080011982198000000000000
+083E:0000000000000000000000000180024002400180000000000000000000000000
+083F:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE63867DBE718E7DBE63BE7FFE0000
+0840:0000000000000000000000000000038004400820082004400380000000000000
+0841:0000000000000000000000840104020403F8004000203FFE0000000000000000
+0842:000000000000000000600090016001000080004000303FFC0000000000000000
+0843:00000000000000000000001400240044007C000400043FF80000000000000000
+0844:000000000000000000000000000000000000005400543FF80000000000000000
+0845:0000000000000000000000100008000403FC0000000000000000000000000000
+0846:0000000000000000008000800080008000800080008000800000000000000000
+0847:0000000000000000000000000000000003E00410040803FC0000000000000000
+0848:00000000000000E001200140014000A03FF00000000000000000000000000000
+0849:0000000000000000000000800100020003F00000000000000000000000000000
+084A:0000000000000000004010800900090004E004200440048009000E0000000000
+084B:0000000000000000000400040004000400040004000401F80000000000000000
+084C:0000000000000000000000840104020403FC004400243FC40000000000000000
+084D:00000000000000000000104008200820042004400440048009000E0000000000
+084E:000000000000000000000000000000000018008400443FF80000000000000000
+084F:0000000000000000000000400080010001F8000400043FF80000000000000000
+0850:000000000000000000C01120096008A0042004400440048009000E0000000000
+0851:0000000000000000002A102A083E0820042004400440048009000E0000000000
+0852:0000000000000000000000840104020403FC004400243FF80000000000000000
+0853:0000000000000000000000840104020403FC000400043FF80000000000000000
+0854:000000000000000000000C18122412240D580140014000800080000000000000
+0855:000000000000000000000084007C002400240FC4000000000000000000000000
+0856:000000000000000000000210042008400FF00000000000000000000000000000
+0857:00000000000000000008111020A020A01F9C008400880090012001C000000000
+0858:0000000000000000008001000200020001C002000200020001C0000000000000
+0859:0000000000000000000000000000000000000000000000000000024002400000
+085A:000000000000000000000000000000000000000000000000000003E000000000
+085B:0000000000000000000000000000000000000000000000000000008000800000
+085C:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE61C66FBE61BE7DBE61C67FFE0000
+085D:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE618E6FB661B67DB6618E7FFE0000
+085E:0000000000000180066008100990124812480990081006600180000000000000
+085F:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE61866FBE618E7DBE61BE7FFE0000
+0860:000000000000000003C004200A100610001000E00020201010100FF000000000
+0861:00000000000000001EF029082908100800081F082088407040003FF800240018
+0862:0000000000000000180026002984106A001201AC024021A010100FF000000000
+0863:0000000000000000400020001000080004000200010E00840044003800000000
+0864:000000000000000003C004200A10061000D0012000E0201010100FF000000000
+0865:000000000000000007C0082008100410001000E00020201010100FF000000000
+0866:000000000000000007F01808200803F00400040003F00008080807F000000000
+0867:0000000000000000000001000080004000400040008001000600180000000000
+0868:00000000000000000C00120022002400280030002018212421241EF800000000
+0869:00000000000000002000100008000800080008000830084808480FF800400180
+086A:0000000000000000003004480848105010201050109009080A0807F000000000
+086B:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE738E6FB6638E6DB6738E7FFE0000
+086C:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE73C66FBE63BE6DBE73C67FFE0000
+086D:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE738E6FB663B66DB6738E7FFE0000
+086E:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE73866FBE638E6DBE73867FFE0000
+086F:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE73866FBE638E6DBE73BE7FFE0000
+0870:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE61CE7DB67BB677B677CE7FFE0000
+0871:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE61EE7DCE7BEE77EE77C67FFE0000
+0872:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE61867DF67B8677BE77867FFE0000
+0873:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE618E7DF67BC677F6778E7FFE0000
+0874:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE61B67DB67B8677F677F67FFE0000
+0875:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE61867DBE7B8677F677867FFE0000
+0876:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE61CE7DBE7B8E77B677CE7FFE0000
+0877:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE61867DF67BEE77DE77DE7FFE0000
+0878:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE61CE7DB67BCE77B677CE7FFE0000
+0879:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE61CE7DB67BC677F677CE7FFE0000
+087A:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE61867DB67B8677B677B67FFE0000
+087B:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE618E7DB67B8E77B6778E7FFE0000
+087C:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE61C67DBE7BBE77BE77C67FFE0000
+087D:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE618E7DB67BB677B6778E7FFE0000
+087E:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE61867DBE7B8E77BE77867FFE0000
+087F:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE61867DBE7B8E77BE77BE7FFE0000
+0880:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE73CE6DB673B66DB673CE7FFE0000
+0881:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE73EE6DCE73EE6DEE73C67FFE0000
+0882:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE73866DF673866DBE73867FFE0000
+0883:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE738E6DF673C66DF6738E7FFE0000
+0884:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE73B66DB673866DF673F67FFE0000
+0885:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE73866DBE73866DF673867FFE0000
+0886:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE73CE6DBE738E6DB673CE7FFE0000
+0887:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE73866DF673EE6DDE73DE7FFE0000
+0888:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE73CE6DB673CE6DB673CE7FFE0000
+0889:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE73CE6DB673C66DF673CE7FFE0000
+088A:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE73866DB673866DB673B67FFE0000
+088B:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE738E6DB6738E6DB6738E7FFE0000
+088C:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE73C66DBE73BE6DBE73C67FFE0000
+088D:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE738E6DB673B66DB6738E7FFE0000
+088E:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE73866DBE738E6DBE73867FFE0000
+088F:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE73866DBE738E6DBE73BE7FFE0000
+0890:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE73CE6DB671B67DB673CE7FFE0000
+0891:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE73EE6DCE71EE7DEE73C67FFE0000
+0892:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE73866DF671867DBE73867FFE0000
+0893:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE738E6DF671C67DF6738E7FFE0000
+0894:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE73B66DB671867DF673F67FFE0000
+0895:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE73866DBE71867DF673867FFE0000
+0896:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE73CE6DBE718E7DB673CE7FFE0000
+0897:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE73866DF671EE7DDE73DE7FFE0000
+0898:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE73CE6DB671CE7DB673CE7FFE0000
+0899:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE73CE6DB671C67DF673CE7FFE0000
+089A:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE73866DB671867DB673B67FFE0000
+089B:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE738E6DB6718E7DB6738E7FFE0000
+089C:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE73C66DBE71BE7DBE73C67FFE0000
+089D:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE738E6DB671B67DB6738E7FFE0000
+089E:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE73866DBE718E7DBE73867FFE0000
+089F:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE73866DBE718E7DBE73BE7FFE0000
+08A0:000000000000000422423C0022140800
+08A1:00000C100C10000422423C0010000000
+08A2:00000000000820007E1020404840221C
+08A3:000000202228202C32227C0000000000
+08A4:0010002800060A0642423C0010000000
+08A5:000000002400001C120A264244380010
+08A6:00000004041F041F0424444448380000
+08A7:00000000080014001C061E2020202020
+08A8:0000000018201820044A4844423C0028
+08A9:0000000000001000044A4844423C0028
+08AA:00000000000000000402020234483402
+08AB:000000000000000C12120E2204483000
+08AC:000000000000000000000814146E404A
+08AD:00000000000000000000080808080800
+08AE:000000000000080402427C0028001000
+08AF:000000000000000006194E4830042008
+08B0:00000810244850403C827E0000000000
+08B1:000000000000000814141E0404040400
+08B2:00001028440010000402020204483000
+08B3:0000000000001824201C20544048423C
+08B4:000000020A120A2242423C0000080000
+08B5:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE63866DBE63866DF663867FFE0000
+08B6:000018041C10100422423C0000080000
+08B7:000018041C10100422423C0024000800
+08B8:00000000140000229D413E0000000000
+08B9:00200008044448300402020204483000
+08BA:0020000804444830044A4844423C0028
+08BB:0000000000060A06423C000000000000
+08BC:0000000000060A0642423C0000000000
+08BD:00000000000000000422424244380000
+08BE:000000442810000422423C0014000800
+08BF:004428100014000422423C0000000000
+08C0:221448405068F00422423C0000000000
+08C1:00000000442810007E2040544048221C
+08C2:00885024081020403C827E0000000000
+08C3:001000240008001824201C204040423C
+08C4:000010002400001C120A264244380000
+08C5:00000010002400007E1020404840221C
+08C6:000000000000007E204840544048221C
+08C7:4040506AF202020202224242443C0000
+08C8:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE71CE6FB66FCE6FB671CE7FFE0000
+08C9:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE71CE6FB66FC66FF671CE7FFE0000
+08CA:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE71866FB66F866FB671B67FFE0000
+08CB:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE718E6FB66F8E6FB6718E7FFE0000
+08CC:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE71C66FBE6FBE6FBE71C67FFE0000
+08CD:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE718E6FB66FB66FB6718E7FFE0000
+08CE:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE71866FBE6F8E6FBE71867FFE0000
+08CF:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE71866FBE6F8E6FBE71BE7FFE0000
+08D0:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE63CE6DB66DB66DB663CE7FFE0000
+08D1:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE63EE6DCE6DEE6DEE63C67FFE0000
+08D2:00007FFE73CE6DB66DCE6DB673CE7FFE7FFE63866DF66D866DBE63867FFE0000
+08D3:0000000000000000000000040A0E021C
+08D4:216B87A7839364000000000000000000
+08D5:0000000006194E502000000000000000
+08D6:00102820182044380000000000000000
+08D7:0024000C0A4638000000000000000000
+08D8:00200008244832040000000000000000
+08D9:00000000000000000000002008244932
+08DA:020A0B2A6D6A010A154A2EB24000000000000000000000000000000000000000
+08DB:A80508054A05A955566901800000000000000000000000000000000000000000
+08DC:0005481514C58B5575E900000000000000000000000000000000000000000000
+08DD:00C0030094004A00010249AAB6D4000000000000000000000000000000000000
+08DE:0010004000100228009811480FB0000000000000000000000000000000000000
+08DF:00400100284042A4056A22265DC2001C00000000000000000000000000000000
+08E0:0020523C000000000000000000000000
+08E1:00020515EE0000000000000000000000
+08E2:08142222414936000000000000000000
+08E3:0000000000000000000000034C304830
+08E4:0004020C100800000000000000000000
+08E5:0C0E4830000000000000000000000000
+08E6:000000000000000000000004020C1008
+08E7:00221166884400000000000000000000
+08E8:1C22225522221C000000000000000000
+08E9:00000000000000000000002211668844
+08EA:00001000000000000000000000000000
+08EB:00000420000000000000000000000000
+08EC:001A241A000000000000000000000000
+08ED:00000000000000000000000000000010
+08EE:00000000000000000000000000001040
+08EF:00000000000000000000000000344834
+08F0:06180018600000000000000000000000
+08F1:66772244880000000000000000000000
+08F2:00000000000000000000000618001860
+08F3:00040A0E021C00000000000000000000
+08F4:00344854245800000000000000000000
+08F5:200C3000000000000000000000000000
+08F6:000000000000000000000000000C3004
+08F7:20402000000000000000000000000000
+08F8:10081000000000000000000000000000
+08F9:00000000000000000000000000102010
+08FA:00000000000000000000000000100810
+08FB:48244800000000000000000000000000
+08FC:24922400000000000000000000000000
+08FD:08240800000000000000000000000000
+08FE:0C2E0810200000000000000000000000
+08FF:001C0202041800000000000000000000
+0900:01C0022004800000000000000000000000000000000000000000000000000000
+0901:0480022001C00000000000000000000000000000000000000000000000000000
+0902:0180018000000000000000000000000000000000000000000000000000000000
+0903:0000000000000000000000000003000300000000000000030003000000000000
+0904:010000FC000201CF02220012001200620412041E0212022201C2000000000000
+0905:00000000000001CF02220012001200620412041E0212022201C2000000000000
+0906:0000000000000E7F1114009400940314209420F4109411140E14000000000000
+0907:0000000000003FFF004003C00400040003C000200010019001E0004000200010
+0908:00E0011000803FFF004003C00400040003C000200010019001E0004000200010
+0909:0000000000001FFF0010000804080430020802080108011000E0000000000000
+090A:0000000000003FFF00400020102010CC08320822042204420384000000000000
+090B:0000000000007FFF00801E9821F806901888009000A000A40098000000000000
+090C:000000000000FFFF002000201C70228821082010102008200018000000000000
+090D:011000E000001FFF021002100210021002100100008000400020002000000000
+090E:040003E000101FFF021002100210021002100100008000400020002000000000
+090F:0000000000001FFF021002100210021002100100008000400020002000000000
+0910:07C0002000101FFF021002100210021002100100008000400020002000000000
+0911:011000E000000E7F1114009400940314209420F4109411140E14000000000000
+0912:080007F800040E7F1114009400940314209420F4109411140E14000000000000
+0913:07F0000800040E7F1114009400940314209420F4109411140E14000000000000
+0914:01F8000400FC0E3F1114009400940314209420F4109411140E14000000000000
+0915:000000000000FFFF008000800EB011C811880E88009000800080000000000000
+0916:000000000000FFFF0810081009D01A301A3011D00810043003D0000000000000
+0917:000000000000FFFF0210021002100A1006100210001000100010000000000000
+0918:000000000000FFFF08080608018802080408041803E800080008000000000000
+0919:000000000000FFFF008003800400041813981040084008400780000000000000
+091A:000000000000FFFF000800080FF8021802680188000800080008000000000000
+091B:000000000000FFFF004006600890085006200830084804480388001000000000
+091C:000000000000FFFF000800080878084804480388000800080008000000000000
+091D:000000000000FFFF010807080808080807F8010801080E080C08020001000000
+091E:000000000000FFFF0008000803C8132810280838082804480388000000000000
+091F:000000000000FFFF0080008003800400080008000808041003E0000000000000
+0920:000000000000FFFF0080008003E00410080808080808041003E0000000000000
+0921:000000000000FFFF002000E00100010004E004100210021001E0000000000000
+0922:000000000000FFFF0080008003800400086008900890045003E0000000000000
+0923:000000000000FFFF049004900490049003100010001000100010000000000000
+0924:000000000000FFFF0010001003F0041008100810081004100210000000000000
+0925:0000000000000C3F120811080908010802080C18082804480388000000000000
+0926:000000000000FFFF0080008003800400080008000830043003E0001000080000
+0927:0000000000000CFF1208140808080C0807080808081807E80008000000000000
+0928:000000000000FFFF0008000803F8060806080008000800080008000000000000
+0929:000000000000FFFF0008000803F80608060800080008000800C800C000000000
+092A:000000000000FFFF081008100810083004500390001000100010000000000000
+092B:000000000000FFFF104010401040107008C80748004800480050000000000000
+092C:000000000000FFFF0010001007D00C300A300950079000100010000000000000
+092D:0000000000000C7F12080E080208020807F80608000800080008000000000000
+092E:000000000000FFFF04100410041004100FF00C10001000100010000000000000
+092F:000000000000FFFF0210021002100C100810083007D000100010000000000000
+0930:000000000000FFFF020002000200060006000100008000400000000000000000
+0931:000000000000FFFF020002000200060006000100008000400600060000000000
+0932:000000000000FFFF000800080638094808880808040803080008000000000000
+0933:000000000000FFFF002000200C70128810881108128812480C30000000000000
+0934:000000000000FFFF002000200C70128810881108128812480C30018001800000
+0935:000000000000FFFF0010001007D0083008300850079000100010000000000000
+0936:000000000000FFFF0610091009100710011001100E100D100090000000000000
+0937:000000000000FFFF0C100A10091008B004500390001000100010000000000000
+0938:000000000000FFFF04100410041004100FF00C10041002100110000000000000
+0939:0000000000003FFF004003C00400040003800440044002000100008000000000
+093A:0080008000000000000000000000000000000000000000000000000000000000
+093B:000000020002000F000200020002000200020002000200020002000000000000
+093C:0000000000000000000000000000000000000000000000000000000001800180
+093D:00000000000003F004000400030000C00020002010200C400380000000000000
+093E:000000000000000F000200020002000200020002000200020002000000000000
+093F:3FC040204000F000400040004000400040004000400040004000000000000000
+0940:03FC04020002000F000200020002000200020002000200020002000000000000
+0941:00000000000000000000000000000000000000000000000000000410021001E0
+0942:000000000000000000000000000000000000000000000000000001E002100410
+0943:0000000000000000000000000000000000000000000000000000007000800070
+0944:0000000000000000000000000000000000000000000000C00100017000800078
+0945:0400022001C00000000000000000000000000000000000000000000000000000
+0946:10000F0000800080000000000000000000000000000000000000000000000000
+0947:1E00010000800000000000000000000000000000000000000000000000000000
+0948:07801F4000C00000000000000000000000000000000000000000000000000000
+0949:001100090006000F000200020002000200020002000200020002000000000000
+094A:010000FC0002000F000200020002000200020002000200020002000000000000
+094B:01F800040002000F000200020002000200020002000200020002000000000000
+094C:007C01FA0006000F000200020002000200020002000200020002000000000000
+094D:0000000000000000000000000000000000000000000000000000006000100008
+094E:000000000000F000800080008000800080008000800080008000000000000000
+094F:027C01FA0006000F000200020002000200020002000200020002000000000000
+0950:0000001800181C42223C01000100060C41124192216C22001C00000000000000
+0951:0180018000800000000000000000000000000000000000000000000000000000
+0952:0000000000000000000000000000000000000000000000000000000007E00000
+0953:0200010000800000000000000000000000000000000000000000000000000000
+0954:0040008001000000000000000000000000000000000000000000000000000000
+0955:0240018003C00000000000000000000000000000000000000000000000000000
+0956:00000000000000000000000000000000000000000000000000000810042003C0
+0957:00000000000000000000000000000000000000000000000000001248099007E0
+0958:000000000000FFFF008000800EB011C811880E8800900C800C80000000000000
+0959:000000000000FFFF0810081009D01A301A3011D00810043003D0000003000300
+095A:000000000000FFFF0210021002100A1006100210001000100190018000000000
+095B:000000000000FFFF000800080878084804480388000800080188018000000000
+095C:000000000000FFFF002000E00100010004E004100210021001E0000000C000C0
+095D:000000000000FFFF0080008003800400086008900890045003E0000001800180
+095E:000000000000FFFF104010401040107008C80748004806480650000000000000
+095F:000000000000FFFF0210021002100C100810083007D000100310030000000000
+0960:0000000000007FFF00801E8C21FC0688189800A0009800A2009C000000000000
+0961:000000000000FFFF002000201C70228821082030104008300044003800000000
+0962:00000000000000000000000000000000000000000000000000000EE011200818
+0963:0000000000000000000000000000000000000000000000080C7012941118080E
+0964:0000000000000000008000800080008000800080008000800080000000000000
+0965:0000000000000000024002400240024002400240024002400240000000000000
+0966:000000000000000003C0042008100810081008100810042003C0000000000000
+0967:000000000000000001C002200220014000800100020001000080004000000000
+0968:000000000000000003C00420001000100010032003C001000080004000200000
+0969:000000000000000003C004200020002001C000200020062007C0010000800000
+096A:0000000000000000101008200440028001000280044004400380000000000000
+096B:00000000000000000800080008C008C007800040004000200020001000100000
+096C:000000000000000003C0042004000400038004000400046003E0008001000000
+096D:000000000000000000E001100910093008D004100410022001C0000000000000
+096E:00000000000000000040008001000200040008000810042003C0000000000000
+096F:0000000000000000018002400240038001000080004000200010000000000000
+0970:000000000000000001C00220022001C000000000000000000000000000000000
+0971:0000000000000180018000000000000000000000000000000000000000000000
+0972:00420022001C01CF02220012001200620412041E0212022201C2000000000000
+0973:00000002000201CF02220012001200620412041E0212022201C2000000000000
+0974:000000020002073F088A004A004A018A104A107A084A088A070A000000000000
+0975:0120009C0072070F088A004A004A018A104A107A084A088A070A000000000000
+0976:00000000000001CF02220012001200620412041E0212022201C2000000840078
+0977:00000000000001CF02220012001200620412041E0212022201C20090026401F8
+0978:000000000000FFFF0400040004000FC00C200020002000400080000000000000
+0979:000000000000FFFF000800080878084804480388000818681868030003000000
+097A:000000000000FFFF0210021003100C900850083007D000100010000000000000
+097B:000000000000FFFF0210021002100A1006100210001000100FF0000000000000
+097C:000000000000FFFF000800080878084804480388000800080FF8000000000000
+097D:00000000000003E00410080800080008001000E0008000800080000000000000
+097E:000000000000FFFF002000E00100010004E00410021001E007F8000000000000
+097F:000000000000FFFF0010001007D00C300A300950079000100FF0000000000000
+0980:0000000000000380044008200920062000200020002000200020002400180000
+0981:0080022001C00000000000000000000000000000000000000000000000000000
+0982:0000000000000000000000020005000500020000000400020001000100000000
+0983:0000000000000000000000020005000500020000000200050005000200000000
+0984:00007FFE73CE6DB66DC66DF673CE7FFE7FFE73B66DB673866DF673F67FFE0000
+0985:0000000000003FFF000811881248122810280828082804580388000000000000
+0986:0000000000003FFF000A118A124A122A102A082A082A045A038A000000000000
+0987:020001F000083FFF000003C004200410001000600780030000C0003000000000
+0988:020001F000083FFF00000618092008E0014002400C4000200018000000000000
+0989:020001F000083FFF0040004008580868080804080408021001E0000000000000
+098A:020001F000083FFF004000400A580A680A080908050804F003E0000000000000
+098B:000000000000002F102824281A6801A80E6830380E2801A80068000000000000
+098C:00000000000003000400020001C0002007100890085004500060008000000000
+098D:00007FFE73CE6DB66DC66DF673CE7FFE7FFE738E6DB673B66DB6738E7FFE0000
+098E:00007FFE73CE6DB66DC66DF673CE7FFE7FFE73866DBE738E6DBE73867FFE0000
+098F:00000000000000E001100210121011101010101010D009300610000000000000
+0990:020001F0000800E401140214121811101010101010D009300610000000000000
+0991:00007FFE73CE6DB66DC66DF673CE7FFE7FFE73EE6DCE71EE7DEE73C67FFE0000
+0992:00007FFE73CE6DB66DC66DF673CE7FFE7FFE73866DF671867DBE73867FFE0000
+0993:00000000000000600090040804080430020802080108011000E0000000000000
+0994:000001E00010018802481028102810C808300820042004400380000000000000
+0995:000000000000FFFF00E0015002480C4810480C500240014000C0000000000000
+0996:000000000000088F074800480048018806080F0800C800280018000000000000
+0997:00000000000003CF042808180F08008800880108060800080008000000000000
+0998:000000000000FFFF0408080808080608010806080C0803E80018000000000000
+0999:00000000000004600490029001E01100113008E80808041003E0000000000000
+099A:000000000000FFFF08000C000C000B0008E00810082008C00F00000000000000
+099B:000000000000FFFF08000E0009C00920062000400F80060001C0003000000000
+099C:000000000000FFFF018011401120111808C80850085004500388000000000000
+099D:000000000000FFEF006800A80128062818280628012800B80068000000000000
+099E:0000000000000300048008B008C804880090108810C809B00680000000000000
+099F:020001F00008FFFF040004000400040004300430042004C00700000000000000
+09A0:018002000100FFFF00C000A001100910161010101010082007C0000000000000
+09A1:000000000000FFFF0040004008580868080804080408021001E0000000000000
+09A2:000000000000FFFF040004000400040004300430042004C00700000000000000
+09A3:000000000000000F03C8042808180E0806080008000800080008000000000000
+09A4:000000000000FFFF000008E009100908080804080408021001E0000000000000
+09A5:000000000000078F084808480048018806080F0800C800280018000000000000
+09A6:000000000000FFFF08000800083008D00B100C20002000200010000000000000
+09A7:000000000000020F041804680388060818080608018800680018000000000000
+09A8:000000000000FFFF00080008000803C8042808180E0806080008000000000000
+09A9:00007FFE73CE6DB66DC66DF673CE7FFE7FFE61CE6DB661C66DF66DCE7FFE0000
+09AA:00000000000007CF082818180418026807880008000800080008000000000000
+09AB:000000000000FFFF080004100228012802200C20182007A00060000000000000
+09AC:000000000000FFFF001800680188060818080608018800680018000000000000
+09AD:000000000000FFFF000001800B900A2809C804080408021001E0000000000000
+09AE:000000000000FFFF00080C080208010801080308058802680018000000000000
+09AF:000000000000FFFF080804080208010802080C08038800680018000000000000
+09B0:000000000000FFFF001800680188060818080608018800680318030000000000
+09B1:00007FFE73CE6DB66DC66DF673CE7FFE7FFE63EE6DCE63EE6DEE63C67FFE0000
+09B2:000000000000FFFF000800080638094808880808080806080008000000000000
+09B3:00007FFE73CE6DB66DC66DF673CE7FFE7FFE638E6DF663C66DF6638E7FFE0000
+09B4:00007FFE73CE6DB66DC66DF673CE7FFE7FFE63B66DB663866DF663F67FFE0000
+09B5:00007FFE73CE6DB66DC66DF673CE7FFE7FFE63866DBE63866DF663867FFE0000
+09B6:000000000000F06F0A9805080D880D8800080008000800080008000000000000
+09B7:000000000000FFFF080804080208018802680C18038800680018000000000000
+09B8:000000000000FFFF06080908008800B800480888070800080008000000000000
+09B9:000000000000FFFF000007C00E200610001000600780030000C0003000000000
+09BA:00007FFE73CE6DB66DC66DF673CE7FFE7FFE63866DB663866DB663B67FFE0000
+09BB:00007FFE73CE6DB66DC66DF673CE7FFE7FFE638E6DB6638E6DB6638E7FFE0000
+09BC:0000000000000000000000000000000000000000000000000000018001800000
+09BD:0000000000000C0003C0032003100010001000600780030000C0003000000000
+09BE:000000000000000B000600020002000200020002000200020002000000000000
+09BF:3FF040084000E000400040004000400040004000400040004000000000000000
+09C0:0FFC10020FFA0007000200020002000200020002000200020002000000000000
+09C1:000000000000000000000000000000000000000000000000000800E8011000E8
+09C2:00000000000000000000000000000000000000000000000000000060008C0073
+09C3:0000000000000000000000000000000000000000000000000004000800100008
+09C4:0000000000000000000000000000000100020004000200010004000800100008
+09C5:00007FFE73CE6DB66DC66DF673CE7FFE7FFE71866FBE6F866FF671867FFE0000
+09C6:00007FFE73CE6DB66DC66DF673CE7FFE7FFE71CE6FBE6F8E6FB671CE7FFE0000
+09C7:000000000000F0002000400040008000800080008000E0006000000000000000
+09C8:800060001000F0002000400040008000800080008000E0006000000000000000
+09C9:00007FFE73CE6DB66DC66DF673CE7FFE7FFE71CE6FB66FC66FF671CE7FFE0000
+09CA:00007FFE73CE6DB66DC66DF673CE7FFE7FFE71866FB66F866FB671B67FFE0000
+09CB:000000000000F00B2006400240028002800280028002E0026002000000000000
+09CC:010000FC0002F00B2006400240028002800280028002E0026002000000000000
+09CD:0000000000000000000000000000000000000000000000000000006000100008
+09CE:000000000000000000000380044005800400030000E000100010000000000000
+09CF:00007FFE73CE6DB66DC66DF673CE7FFE7FFE71866FBE6F8E6FBE71BE7FFE0000
+09D0:00007FFE73CE6DB66DC66DF673CE7FFE7FFE63CE6DB66DB66DB663CE7FFE0000
+09D1:00007FFE73CE6DB66DC66DF673CE7FFE7FFE63EE6DCE6DEE6DEE63C67FFE0000
+09D2:00007FFE73CE6DB66DC66DF673CE7FFE7FFE63866DF66D866DBE63867FFE0000
+09D3:00007FFE73CE6DB66DC66DF673CE7FFE7FFE638E6DF66DC66DF6638E7FFE0000
+09D4:00007FFE73CE6DB66DC66DF673CE7FFE7FFE63B66DB66D866DF663F67FFE0000
+09D5:00007FFE73CE6DB66DC66DF673CE7FFE7FFE63866DBE6D866DF663867FFE0000
+09D6:00007FFE73CE6DB66DC66DF673CE7FFE7FFE63CE6DBE6D8E6DB663CE7FFE0000
+09D7:010000FC0002000B000600020002000200020002000200020002000000000000
+09D8:00007FFE73CE6DB66DC66DF673CE7FFE7FFE63CE6DB66DCE6DB663CE7FFE0000
+09D9:00007FFE73CE6DB66DC66DF673CE7FFE7FFE63CE6DB66DC66DF663CE7FFE0000
+09DA:00007FFE73CE6DB66DC66DF673CE7FFE7FFE63866DB66D866DB663B67FFE0000
+09DB:00007FFE73CE6DB66DC66DF673CE7FFE7FFE638E6DB66D8E6DB6638E7FFE0000
+09DC:000000000000FFFF0040004008580868080804080408021001E0000000C000C0
+09DD:000000000000FFFF040004000400040004300430042004C00700006000600000
+09DE:00007FFE73CE6DB66DC66DF673CE7FFE7FFE63866DBE6D8E6DBE63867FFE0000
+09DF:000000000000FFFF080804080208010802080C08038800680318030000000000
+09E0:000000000000002F102824281A6801A806681838062801A80268040002000100
+09E1:00000000000003000400020001C0002007100890085004600090000800680098
+09E2:000000000000000000000000000000000000000000000000000800040034004C
+09E3:000000000000000000000000000000060001000300050000000800040034004C
+09E4:00007FFE73CE6DB66DC66DF673CE7FFE7FFE61B66FB663866FF661F67FFE0000
+09E5:00007FFE73CE6DB66DC66DF673CE7FFE7FFE61866FBE63866FF661867FFE0000
+09E6:000000000000000003C0042008100810081008100810042003C0000000000000
+09E7:0000000000000000080006000180006000100008000806700780000000000000
+09E8:0000000000000000030000C000200010001000600780030000C0002000100000
+09E9:000000000000000000E01110120812C811C808080808041003E0000000000000
+09EA:000000000000000003C004200420042003C0042008100810042003C000000000
+09EB:00000000000000000300048008400880088008800850042003C0000000000000
+09EC:00000000000000000040004008400858086804080408021001E0000000000000
+09ED:000000000000000007C008200820086007A00020002000200020000000000000
+09EE:00000000000000000800080008100BE00C800880088009000600000000000000
+09EF:000000000000020004000400020001C000200710089008500460000000000000
+09F0:000000000000FFFF00180068018806C818280618018800680018000000000000
+09F1:000000000000FFFF00180068018806081808060801880C680218010000000000
+09F2:0000000000000000000000000600018000400020001000000000000000000000
+09F3:00000000000006000900010003F00100016001500110012000C0000000000000
+09F4:0000000000000000000000000000001000200040018006000000000000000000
+09F5:00000000000000000000000000000000070808900CA001400380000000000000
+09F6:000000000000000800080F080C880090009001100E2008400780000000000000
+09F7:0000000000000000008000800080008000800080008000800080000000000000
+09F8:00000000000008000800081008300850089009100A100C100810001000080000
+09F9:00000000000000000000000001C00220041004100410022001C0000000000000
+09FA:0000000000000000000000080008000809900990042003C00000000000000000
+09FB:0000000000000000000000000180020002000100008000400020000000000000
+09FC:0000000000000000000000000010019001A00820044003800020001000080000
+09FD:0000000000000000000000000180024002400180000000000000000000000000
+09FE:0300008003C00020000000000000000000000000000000000000000000000000
+09FF:00007FFE73CE6DB66DC66DF673CE7FFE7FFE61866FBE638E6FBE6FBE7FFE0000
+0A00:00007FFE73866DB66D866DB673B67FFE7FFE73CE6DB66DB66DB673CE7FFE0000
+0A01:02A0022001C00000000000000000000000000000000000000000000000000000
+0A02:0180018000000000000000000000000000000000000000000000000000000000
+0A03:0000000000000000000000000002000500020000000200050002000000000000
+0A04:00007FFE73866DB66D866DB673B67FFE7FFE73B66DB66D866DF673F67FFE0000
+0A05:0000000000000000C00720041304149C386430C420C400840004000000000000
+0A06:0000000000000000C03F20241024166439A03320232002200020000000000000
+0A07:3C00420042004000FFFF44044404420441FC42004400420441F8000000000000
+0A08:0078008400840004FFFE4044404420441FC42004400420441F84000000000000
+0A09:07C0082010102008FFFF2008200820103FE010100810042003C00000081007E0
+0A0A:07C0082010102008FFFF200820103FE010100810042003C0081007E0081007E0
+0A0B:00007FFE73866DB66D866DB673B67FFE7FFE738E6DB66D8E6DB6738E7FFE0000
+0A0C:00007FFE73866DB66D866DB673B67FFE7FFE73C66DBE6DBE6DBE73C67FFE0000
+0A0D:00007FFE73866DB66D866DB673B67FFE7FFE738E6DB66DB66DB6738E7FFE0000
+0A0E:00007FFE73866DB66D866DB673B67FFE7FFE73866DBE6D8E6DBE73867FFE0000
+0A0F:00C0002000100010FFFF10101010081007F008001000080007F0000000000000
+0A10:00F0000800F4000CC01F20041304149C386430C420C400840004000400000000
+0A11:00007FFE73866DB66D866DB673B67FFE7FFE7BEE73CE7BEE7BEE71C67FFE0000
+0A12:00007FFE73866DB66D866DB673B67FFE7FFE7B8673F67B867BBE71867FFE0000
+0A13:07F0080010002000FFFF2008200820103FE010100810042003C0000000000000
+0A14:020001F000480048C01F20041304149C386430C420C400840004000400000000
+0A15:0000000000000000FFFF001000100F1010A020602060209011100E1000000000
+0A16:0000000000000000F01F101008100FF01010201010300FD00010001000000000
+0A17:0000000000000000FFFF0090009000901F902090209010900910061000000000
+0A18:0000000000000000F11F1110091009101110211011300ED00010000000000000
+0A19:0000000000000000FFFF100010001FC0002003A0044004A00310000000000000
+0A1A:0000000000000000FFFF0020002018201FE008200820042003C0000000000000
+0A1B:0000000000000000FFFF001000101FF020001FF0210821081FF0000000000000
+0A1C:0000000000000000FFFF0010001018101FF00810081008100810000000000000
+0A1D:0000000000000000FFFF0C3002400FE01010260807F001000080004000000000
+0A1E:0000000000000000FFFF201020101FF0200020001FF0040003F0000000000000
+0A1F:0000000000000000FFFF0040004001C0020004000800041003E0000000000000
+0A20:0000000000000000FFFF0100010002800440082010101010082007C000000000
+0A21:0000000000000000FFFF0008000803F0001000101F08208810700FC000000000
+0A22:0000000000000000FFFF0010001018101FF00800080009E00A10042003C00000
+0A23:0000000000000000FFFF010000C000600F5010C020001010082007C000000000
+0A24:0000000000000000FFFF0010001007A007E00030201030100C2003C000000000
+0A25:0000000000000000FFFF101008100FF0101030100C3003D00010001000000000
+0A26:0000000000000000FFFF0020002030203FE0100010000800041003E000000000
+0A27:0000000000000000FFFF08100410041008101010081006700190001000000000
+0A28:0000000000000000FFFF01000100028004400820101010100820000000000000
+0A29:00007FFE73866DB66D866DB673B67FFE7FFE61CE7DB661C66FF661CE7FFE0000
+0A2A:0000000000000000F81F08100410041008101010081006700190001000000000
+0A2B:0000000000000000FFFF001000101FF02000200021E012100C2003C000000000
+0A2C:0000000000000000FFFF0810041007F008101010081006700190001000000000
+0A2D:0000000000000000FFFF0010001003D0043003C800081010082007C000000000
+0A2E:0000000000000000F01F0810081008100FF01810181000100190019000000000
+0A2F:0000000000000000FFFF08100410041008F01090089004900390001000000000
+0A30:0000000000000000FFFF0010001007F00810081008100410021001E000000000
+0A31:00007FFE73866DB66D866DB673B67FFE7FFE63EE7DCE71EE7DEE63C67FFE0000
+0A32:0000000000000000FFFF0820082004400AA01110101008200440000000000000
+0A33:0000000000000000FFFF0820082004400AA0111010100820044C000C00000000
+0A34:00007FFE73866DB66D866DB673B67FFE7FFE63B67DB671867DF663F67FFE0000
+0A35:0000000000000000FFFF001000101FF0200030000FF0040003E0000000000000
+0A36:0000000000000000FFFF0810081008100FF01810181000100190019000000000
+0A37:00007FFE73866DB66D866DB673B67FFE7FFE63867DF671EE7DDE63DE7FFE0000
+0A38:0000000000000000FFFF0810081008100FF01810181000100010001000000000
+0A39:0000000000000000FFFF0010001007100810081008100410021001E000000000
+0A3A:00007FFE73866DB66D866DB673B67FFE7FFE63867DB671867DB663B67FFE0000
+0A3B:00007FFE73866DB66D866DB673B67FFE7FFE638E7DB6718E7DB6638E7FFE0000
+0A3C:0000000000000000000000000000000000000000000000000000000001800180
+0A3D:00007FFE73866DB66D866DB673B67FFE7FFE638E7DB671B67DB6638E7FFE0000
+0A3E:0000000000000000001F00040004000400040004000000000000000000000000
+0A3F:7800840084008400E00080008000800080008000800080008000800080000000
+0A40:0078008400840084001F00040004000400040004000400040004000400040000
+0A41:0000000000000000000000000000000000000000000000000000082007C00000
+0A42:000000000000000000000000000000000000000000000000082007C0082007C0
+0A43:00007FFE73866DB66D866DB673B67FFE7FFE6D8E6DF661C67DF67D8E7FFE0000
+0A44:00007FFE73866DB66D866DB673B67FFE7FFE6DB66DB661867DF67DF67FFE0000
+0A45:00007FFE73866DB66D866DB673B67FFE7FFE6D866DBE61867DF67D867FFE0000
+0A46:00007FFE73866DB66D866DB673B67FFE7FFE6DCE6DBE618E7DB67DCE7FFE0000
+0A47:000000E000100008000000000000000000000000000000000000000000000000
+0A48:01E0001000F80008000000000000000000000000000000000000000000000000
+0A49:00007FFE73866DB66D866DB673B67FFE7FFE6DCE6DB661C67DF67DCE7FFE0000
+0A4A:00007FFE73866DB66D866DB673B67FFE7FFE6D866DB661867DB67DB67FFE0000
+0A4B:020001F000080008000000000000000000000000000000000000000000000000
+0A4C:020001F000480048000000000000000000000000000000000000000000000000
+0A4D:0000000000000000000000000000000000000000000000000000001800040002
+0A4E:00007FFE73866DB66D866DB673B67FFE7FFE6D866DBE618E7DBE7D867FFE0000
+0A4F:00007FFE73866DB66D866DB673B67FFE7FFE6D866DBE618E7DBE7DBE7FFE0000
+0A50:00007FFE73866DB66D866DB673B67FFE7FFE61CE6FB661B67DB661CE7FFE0000
+0A51:0000000000000000000000000000000000000000000000000000080006000180
+0A52:00007FFE73866DB66D866DB673B67FFE7FFE61866FF661867DBE61867FFE0000
+0A53:00007FFE73866DB66D866DB673B67FFE7FFE618E6FF661C67DF6618E7FFE0000
+0A54:00007FFE73866DB66D866DB673B67FFE7FFE61B66FB661867DF661F67FFE0000
+0A55:00007FFE73866DB66D866DB673B67FFE7FFE61866FBE61867DF661867FFE0000
+0A56:00007FFE73866DB66D866DB673B67FFE7FFE61CE6FBE618E7DB661CE7FFE0000
+0A57:00007FFE73866DB66D866DB673B67FFE7FFE61866FF661EE7DDE61DE7FFE0000
+0A58:00007FFE73866DB66D866DB673B67FFE7FFE61CE6FB661CE7DB661CE7FFE0000
+0A59:0000000000000000F81F0810041007F008101010081006700190181018000000
+0A5A:0000000000000000FFFF009000900F9010901090109008900490031018001800
+0A5B:0000000000000000FFFF0010001018101FF00810081008100810099001800000
+0A5C:0000000000000000FFFF00200020002007E0001000101020084007C004200210
+0A5D:00007FFE73866DB66D866DB673B67FFE7FFE618E6FB661B67DB6618E7FFE0000
+0A5E:0000000000000000FFFF001000101FF02000200021E012100C2063C060000000
+0A5F:00007FFE73866DB66D866DB673B67FFE7FFE61866FBE618E7DBE61BE7FFE0000
+0A60:00007FFE73866DB66D866DB673B67FFE7FFE73CE6FB663B66DB673CE7FFE0000
+0A61:00007FFE73866DB66D866DB673B67FFE7FFE73EE6FCE63EE6DEE73C67FFE0000
+0A62:00007FFE73866DB66D866DB673B67FFE7FFE73866FF663866DBE73867FFE0000
+0A63:00007FFE73866DB66D866DB673B67FFE7FFE738E6FF663C66DF6738E7FFE0000
+0A64:00007FFE73866DB66D866DB673B67FFE7FFE73B66FB663866DF673F67FFE0000
+0A65:00007FFE73866DB66D866DB673B67FFE7FFE73866FBE63866DF673867FFE0000
+0A66:0000000000000000078008401020201020102010102008400780000000000000
+0A67:000000000000000007000880084008C007400040004000400040003000000000
+0A68:000000000000000007C000200010001000200FC0004000200010000000000000
+0A69:00000000000000000F800040002000401F800040002030403F80080004000200
+0A6A:0000000000000000044008200820044003800440082008200440038000000000
+0A6B:0000000000000000103C1020082008201020202010200CE00320002000000000
+0A6C:00E00100010000C003F004300800040003F004000800040803F0000000000000
+0A6D:000000000000000003C004200810081006100020004000800300040000000000
+0A6E:00000000000030003FF0100010001000100010000800040003F0000000000000
+0A6F:00600080008030603FF0103010001000100010000800040003F0000000000000
+0A70:03C0042002400000000000000000000000000000000000000000000000000000
+0A71:0420042003C00000000000000000000000000000000000000000000000000000
+0A72:0000000000000000FFFF10101010081007F0080010000810042003C000000000
+0A73:07E0081010082008FFFF2008200820103FE010100810042003C0000000000000
+0A74:00000000180424F8250C1D920B421482280C280228022404120809F000000000
+0A75:0000000000000000000000000000000000000000000000000200020002400180
+0A76:0000000000000000000000000100038007C00380010000000000000000000000
+0A77:00007FFE73866DB66D866DB673B67FFE7FFE61867DF67BEE77DE77DE7FFE0000
+0A78:00007FFE73866DB66D866DB673B67FFE7FFE61CE7DB67BCE77B677CE7FFE0000
+0A79:00007FFE73866DB66D866DB673B67FFE7FFE61CE7DB67BC677F677CE7FFE0000
+0A7A:00007FFE73866DB66D866DB673B67FFE7FFE61867DB67B8677B677B67FFE0000
+0A7B:00007FFE73866DB66D866DB673B67FFE7FFE618E7DB67B8E77B6778E7FFE0000
+0A7C:00007FFE73866DB66D866DB673B67FFE7FFE61C67DBE7BBE77BE77C67FFE0000
+0A7D:00007FFE73866DB66D866DB673B67FFE7FFE618E7DB67BB677B6778E7FFE0000
+0A7E:00007FFE73866DB66D866DB673B67FFE7FFE61867DBE7B8E77BE77867FFE0000
+0A7F:00007FFE73866DB66D866DB673B67FFE7FFE61867DBE7B8E77BE77BE7FFE0000
+0A80:00007FFE73866DB66D866DB673B67FFE7FFE73CE6DB673B66DB673CE7FFE0000
+0A81:02A0022001C00000000000000000000000000000000000000000000000000000
+0A82:0180018000000000000000000000000000000000000000000000000000000000
+0A83:0000000000000000000000000003000300000000000300030000000000000000
+0A84:00007FFE73866DB66D866DB673B67FFE7FFE73B66DB673866DF673F67FFE0000
+0A85:000000000000000078080408048838F810480888070A00040000000000000000
+0A86:0000000000000000F0220822092271E220A211220E2A00110000000000000000
+0A87:000000180020002003A004200420042003200420044003800000000000000000
+0A88:0000003000480048074008400840084006400840088007000000000000000000
+0A89:000003C00420081009C008200820082008C00420022001C00000000000000000
+0A8A:00000F0010802040272020902090209023101090089407080000000000000000
+0A8B:0000000000000000391005280328011803E40502094210840000000000000000
+0A8C:000000000000000000200F7010882084201810200C20001C0000000000000000
+0A8D:004000200018000078080408048838F810480888070A00040000000000000000
+0A8E:00007FFE73866DB66D866DB673B67FFE7FFE73866DBE738E6DBE73867FFE0000
+0A8F:000000600010000878080408048838F810480888070A00040000000000000000
+0A90:00E0001800F8000878080408048838F810480888070A00040000000000000000
+0A91:0010000800060000F0220822092271E220A211220E2A00110000000000000000
+0A92:00007FFE73866DB66D866DB673B67FFE7FFE73866DF671867DBE73867FFE0000
+0A93:0000001800040002F0220822092271E220A211220E2A00110000000000000000
+0A94:00380006003E0002F0220822092271E220A211220E2A00110000000000000000
+0A95:0000000000000000018002000240018001800240084007800000000000000000
+0A96:000000000000000020405040124013C00C400040005000200000000000000000
+0A97:00000000000000000C2012200120012012200C20002800100000000000000000
+0A98:0000000000000000039004100410041003100430045403880000000000000000
+0A99:000000000000000001000100026004600200210011000E000000000000000000
+0A9A:00000000000000003C10021002101C1008300450039400080000000000000000
+0A9B:00000000000000001CC021202120212018A0204020801F000000000000000000
+0A9C:00000000000000000E10112028C0488049403120012000C00000000000000000
+0A9D:00000000000000000C401240014001E012100C10001000600000000000000000
+0A9E:00000000000000000C201220012001E012200C20002800100000000000000000
+0A9F:0000000000000000380004000400180020004000440038000000000000000000
+0AA0:0000000000000000018002000200010007000880088007000000000000000000
+0AA1:000000000000000001000100020004000200210011000E000000000000000000
+0AA2:00000000000000001C0002000C0010C02120212010C00F800000000000000000
+0AA3:00000000000000004C4052404140414052404C40405040202000100008001000
+0AA4:00000000000000000040004003C0044008400840045002200000000000000000
+0AA5:00000000000000000C4012400A40044008C00740005000200000000000000000
+0AA6:0000000000000000038004000400040003000400044003800000000000000000
+0AA7:00000600080008000640084008C0074000400040005000200000000000000000
+0AA8:00000000000000000080008000801F801880008000A000400000000000000000
+0AA9:00007FFE73866DB66D866DB673B67FFE7FFE61CE6DB661C66DF66DCE7FFE0000
+0AAA:000000000000000010402840084008C007400040005000200000000000000000
+0AAB:000000000000000001800200024001800180024018401F800400020001800000
+0AAC:000000000000000008081008208820F811080E08000A00040000000000000000
+0AAD:000000000000000007080888108810F810080808040A00040000000000000000
+0AAE:00000000000000000C200220022003E000200020002800100000000000000000
+0AAF:00000000000000000C20022004200820046003A0002800100000000000000000
+0AB0:00000000000000001E00010001000E000400020001C000000000000000000000
+0AB1:00007FFE73866DB66D866DB673B67FFE7FFE63EE6DCE63EE6DEE63C67FFE0000
+0AB2:00000000000000000C80108020802780208010800CA000400000000000000000
+0AB3:0000000000000000000021802240224022401C40004000500020000000000000
+0AB4:00007FFE73866DB66D866DB673B67FFE7FFE63B66DB663866DF663F67FFE0000
+0AB5:00000000000000000000074008C0084008C00740004000500020000000000000
+0AB6:00000000000000000C20122012200C2004201820082807100000000000000000
+0AB7:00000000000000000C400A40094008C007400040005000200000000000000000
+0AB8:00000000000000003C20022003E01C2008200420032800100000000000000000
+0AB9:000000000000000021002200210020802480232010200FC00000000000000000
+0ABA:00007FFE73866DB66D866DB673B67FFE7FFE63866DB663866DB663B67FFE0000
+0ABB:00007FFE73866DB66D866DB673B67FFE7FFE638E6DB6638E6DB6638E7FFE0000
+0ABC:0000000000000000000000000000000000000000000000000000000001800180
+0ABD:0000000000000000380040004000300008000400440038000000000000000000
+0ABE:0000000000000000000400040004000400040004000500020000000000000000
+0ABF:6000900088008000800080008000800080008000A00040000000000000000000
+0AC0:0018002400240004000400040004000400040004000500020000000000000000
+0AC1:00000000000000000000000000000000000000000000000000000260011000E0
+0AC2:000000000000000000000000000000000000000000000000000001C002200190
+0AC3:000000000000000000000000000000000000000000000000000001C0020001C0
+0AC4:00000000000000000000000000000000000000000000018002000180020001C0
+0AC5:0010000800060000000000000000000000000000000000000000000000000000
+0AC6:00007FFE73866DB66D866DB673B67FFE7FFE71CE6FBE6F8E6FB671CE7FFE0000
+0AC7:0000001800040002000000000000000000000000000000000000000000000000
+0AC8:00380006003E0002000000000000000000000000000000000000000000000000
+0AC9:00200010000C0000000400040004000400040004000500020000000000000000
+0ACA:00007FFE73866DB66D866DB673B67FFE7FFE71866FB66F866FB671B67FFE0000
+0ACB:0030000800040004000400040004000400040004000500020000000000000000
+0ACC:003800040034000C000400040004000400040004000500020000000000000000
+0ACD:000000000000000000000000000000000000000000000000000001C000200010
+0ACE:00007FFE73866DB66D866DB673B67FFE7FFE71866FBE6F8E6FBE71867FFE0000
+0ACF:00007FFE73866DB66D866DB673B67FFE7FFE71866FBE6F8E6FBE71BE7FFE0000
+0AD0:00300030000000843C780200020C0C121832044C438042003C00000000000000
+0AD1:00007FFE73866DB66D866DB673B67FFE7FFE63EE6DCE6DEE6DEE63C67FFE0000
+0AD2:00007FFE73866DB66D866DB673B67FFE7FFE63866DF66D866DBE63867FFE0000
+0AD3:00007FFE73866DB66D866DB673B67FFE7FFE638E6DF66DC66DF6638E7FFE0000
+0AD4:00007FFE73866DB66D866DB673B67FFE7FFE63B66DB66D866DF663F67FFE0000
+0AD5:00007FFE73866DB66D866DB673B67FFE7FFE63866DBE6D866DF663867FFE0000
+0AD6:00007FFE73866DB66D866DB673B67FFE7FFE63CE6DBE6D8E6DB663CE7FFE0000
+0AD7:00007FFE73866DB66D866DB673B67FFE7FFE63866DF66DEE6DDE63DE7FFE0000
+0AD8:00007FFE73866DB66D866DB673B67FFE7FFE63CE6DB66DCE6DB663CE7FFE0000
+0AD9:00007FFE73866DB66D866DB673B67FFE7FFE63CE6DB66DC66DF663CE7FFE0000
+0ADA:00007FFE73866DB66D866DB673B67FFE7FFE63866DB66D866DB663B67FFE0000
+0ADB:00007FFE73866DB66D866DB673B67FFE7FFE638E6DB66D8E6DB6638E7FFE0000
+0ADC:00007FFE73866DB66D866DB673B67FFE7FFE63C66DBE6DBE6DBE63C67FFE0000
+0ADD:00007FFE73866DB66D866DB673B67FFE7FFE638E6DB66DB66DB6638E7FFE0000
+0ADE:00007FFE73866DB66D866DB673B67FFE7FFE63866DBE6D8E6DBE63867FFE0000
+0ADF:00007FFE73866DB66D866DB673B67FFE7FFE63866DBE6D8E6DBE63BE7FFE0000
+0AE0:000000000000000072200A500650023007DC0A101292210C0000000000000000
+0AE1:000000000000000000200F7010882084201810200C20001C00200020001C0000
+0AE2:0000000000000000000000000000000000000000000000000360049004200018
+0AE3:00000000000000000000000000000000000000000000036004900424001A000C
+0AE4:00007FFE73866DB66D866DB673B67FFE7FFE61B66FB663866FF661F67FFE0000
+0AE5:00007FFE73866DB66D866DB673B67FFE7FFE61866FBE63866FF661867FFE0000
+0AE6:0000000000000000078008401020201020102010102008400780000000000000
+0AE7:000000000000000007000880084008C007400040004000400040003000000000
+0AE8:000000000000000007C00020001000100C200FC00200010000C0000000000000
+0AE9:000000000000000001C000200010002003C010200810042003C0000000000000
+0AEA:00000000000000001C080210012000C000C0012002200220022001C000000000
+0AEB:000000000000000010402840084008C007400040005000200000000000000000
+0AEC:0000000000000000070008001000080007E004000800040003F0000800080070
+0AED:000000000000000003C0046008900910061020102010202010400F8000000000
+0AEE:0000000000000080010002000400080010001000100008400780000000000000
+0AEF:000000000000000008001040208021002200200010000F800000000000000000
+0AF0:0000000000000000000000000000000018002400240018000000000000000000
+0AF1:00000000000000000C000200010002001C1C0222012232223C1C080004000300
+0AF2:00007FFE73866DB66D866DB673B67FFE7FFE61866FF663866FBE6F867FFE0000
+0AF3:00007FFE73866DB66D866DB673B67FFE7FFE618E6FF663C66FF66F8E7FFE0000
+0AF4:00007FFE73866DB66D866DB673B67FFE7FFE61B66FB663866FF66FF67FFE0000
+0AF5:00007FFE73866DB66D866DB673B67FFE7FFE61866FBE63866FF66F867FFE0000
+0AF6:00007FFE73866DB66D866DB673B67FFE7FFE61CE6FBE638E6FB66FCE7FFE0000
+0AF7:00007FFE73866DB66D866DB673B67FFE7FFE61866FF663EE6FDE6FDE7FFE0000
+0AF8:00007FFE73866DB66D866DB673B67FFE7FFE61CE6FB663CE6FB66FCE7FFE0000
+0AF9:00000000000000001F82284424282430185000900510112004C0000000000000
+0AFA:00C0002000200040000000000000000000000000000000000000000000000000
+0AFB:0888088807700000000000000000000000000000000000000000000000000000
+0AFC:000C013001C00700000000000000000000000000000000000000000000000000
+0AFD:018001800C300C30000000000000000000000000000000000000000000000000
+0AFE:0180024002400180000000000000000000000000000000000000000000000000
+0AFF:0630094809480630000000000000000000000000000000000000000000000000
+0B00:00007FFE738E6DB66D8E6DB6738E7FFE7FFE73CE6DB66DB66DB673CE7FFE0000
+0B01:02A0022001C00000000000000000000000000000000000000000000000000000
+0B02:0002000500020000000000000000000000000000000000000000000000000000
+0B03:0000000000000000000000020005000500020005000500020000000000000000
+0B04:00007FFE738E6DB66D8E6DB6738E7FFE7FFE73B66DB66D866DF673F67FFE0000
+0B05:0000000000000000361049104910221004100810083007D00000000000000000
+0B06:0000000000000000361449144914221404140414023401D40000000000000000
+0B07:00000000000000000F803040402040204A20354015400A200000000000000000
+0B08:0000000000000000038004403E2040204A20354015400A200000000000000000
+0B09:00000000000000000F803040402041205220264022401C200000000000000000
+0B0A:00000000000000000F803040404041405220261022201C100000000000000000
+0B0B:000000000000000007001880208020802C40122012400C200000000000000000
+0B0C:00000000000000000000038004400180020004C0052003C00000000000000000
+0B0D:00007FFE738E6DB66D8E6DB6738E7FFE7FFE738E6DB66DB66DB6738E7FFE0000
+0B0E:00007FFE738E6DB66D8E6DB6738E7FFE7FFE73866DBE6D8E6DBE73867FFE0000
+0B0F:0000000000000000020006000A004200220012000A0006000000000000000000
+0B10:000001E00210001001200320052021E011200920052003200000000000000000
+0B11:00007FFE738E6DB66D8E6DB6738E7FFE7FFE7BEE73CE7BEE7BEE71C67FFE0000
+0B12:00007FFE738E6DB66D8E6DB6738E7FFE7FFE7B8673F67B867BBE71867FFE0000
+0B13:000000000000000004C009200820082008C00420022001C00000000000000000
+0B14:000000F00108000813102490209020F023101090089007100000000000000000
+0B15:00000000000000000FC03020401040104980364016400A400000000000000000
+0B16:000000000000000003900510093008D008100710049003100000000000000000
+0B17:0000000000000000039004500830081008100710049003100000000000000000
+0B18:00000000000000000390045008300A100C10111011300ED00000000000000000
+0B19:00000000000000000F003080407041485230260022001C000000000000000000
+0B1A:000000000000000003C004200810081008100720048003000000000000000000
+0B1B:000000000000000003C0042008100B10048017000A8005000000000000000000
+0B1C:000000000000000003C00420081008000A6004A004A003200000000000000000
+0B1D:000000000000000003A00490091010E016000900098006400000000000000000
+0B1E:00000000000000001360249020101FE01360249020101FE00000000000000000
+0B1F:0000000000000000039004500830081008000700048003000000000000000000
+0B20:0000000000000000000007000880104010401040088007000000000000000000
+0B21:000000000000000003C00C2010101050149009A0088007000000000000000000
+0B22:000000000000000003C00C2010101010141009200A8007000200010000000000
+0B23:0000000000000000039004500A3011101C10021002100C100000000000000000
+0B24:00000000000000000F803040402040205340230023001C000000000000000000
+0B25:00000000000000000610091001100E1010101010083007D00000000000000000
+0B26:00000000000000000F803040402041205300230023001D000000000000000000
+0B27:0000000000000000001004100210031004900410043003D00000000000000000
+0B28:00000000000000000F80104020202020272019400D000D000000000000000000
+0B29:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61CE7DB661C66FF661CE7FFE0000
+0B2A:000000000000000007900850103012100C100810083007D00000000000000000
+0B2B:00000000000000001CB022C841C848B03080208021801E800000000000000000
+0B2C:00000000000000000780184020202E203120110011800E800000000000000000
+0B2D:00000000000000000F803040402045205520234021401E200000000000000000
+0B2E:000000000000000007900850103012100C101010601060100010000000000000
+0B2F:000000000000000007900850103012100C101810683067D00000000000000000
+0B30:000000000000000003C00420081008100810072004A003100000000000000000
+0B31:00007FFE738E6DB66D8E6DB6738E7FFE7FFE63EE7DCE71EE7DEE63C67FFE0000
+0B32:00000000000000001FC02020401040105B1024A024A024900000000000000000
+0B33:00000000000000001FC02020401040105B202480248024800000000000000000
+0B34:00007FFE738E6DB66D8E6DB6738E7FFE7FFE63B67DB671867DF663F67FFE0000
+0B35:00000000000000000780184020202E203120150011800E800000000000000000
+0B36:0000000000000000079008500C30121010100E10091006100000000000000000
+0B37:000000000000000007900C50123013100C900850083007D00000000000000000
+0B38:00000000000000000F9010502030211026101E10019000700000000000000000
+0B39:00000000000000000F803040402041205300230023001D000800060001800000
+0B3A:00007FFE738E6DB66D8E6DB6738E7FFE7FFE63867DB671867DB663B67FFE0000
+0B3B:00007FFE738E6DB66D8E6DB6738E7FFE7FFE638E7DB6718E7DB6638E7FFE0000
+0B3C:0000000000000000000000000000000000000000000000000000000001800180
+0B3D:00000000000000000C003000400030000C003000400030000C00000000000000
+0B3E:0000000000000000000800080008000800080008000800080008000000000000
+0B3F:07F0080808080000000000000000000000000000000000000000000000000000
+0B40:0000000000000000000800180028000800080008000800080008000000000000
+0B41:000000000000000000000000000000000000000000000000002007A008C007B0
+0B42:00000000000000000000000000000000000000000000000003000400044003B0
+0B43:000000000000000000000000000000000000000000000000024004A0042003C0
+0B44:000000000000000000000000000000000000000000000400084006A0082007C0
+0B45:00007FFE738E6DB66D8E6DB6738E7FFE7FFE6D866DBE61867DF67D867FFE0000
+0B46:00007FFE738E6DB66D8E6DB6738E7FFE7FFE6DCE6DBE618E7DB67DCE7FFE0000
+0B47:00000000000000006000800080008000E0009000900090006000000000000000
+0B48:010000F8000400046000800080008000E0009000900090006000000000000000
+0B49:00007FFE738E6DB66D8E6DB6738E7FFE7FFE6DCE6DB661C67DF67DCE7FFE0000
+0B4A:00007FFE738E6DB66D8E6DB6738E7FFE7FFE6D866DB661867DB67DB67FFE0000
+0B4B:00000000000000006008800880088008E0089008900890086008000000000000
+0B4C:00000078008400046008800880088008E0089008900890086008000000000000
+0B4D:0000000000000000000000000000000000000000000000000000008000400020
+0B4E:00007FFE738E6DB66D8E6DB6738E7FFE7FFE6D866DBE618E7DBE7D867FFE0000
+0B4F:00007FFE738E6DB66D8E6DB6738E7FFE7FFE6D866DBE618E7DBE7DBE7FFE0000
+0B50:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61CE6FB661B67DB661CE7FFE0000
+0B51:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61EE6FCE61EE7DEE61C67FFE0000
+0B52:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61866FF661867DBE61867FFE0000
+0B53:00007FFE738E6DB66D8E6DB6738E7FFE7FFE618E6FF661C67DF6618E7FFE0000
+0B54:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61B66FB661867DF661F67FFE0000
+0B55:00000FF000000000000000000000000000000000000000000000000000000000
+0B56:010000F800040004000000000000000000000000000000000000000000000000
+0B57:0000007800840004000800080008000800080008000800080008000000000000
+0B58:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61CE6FB661CE7DB661CE7FFE0000
+0B59:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61CE6FB661C67DF661CE7FFE0000
+0B5A:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61866FB661867DB661B67FFE0000
+0B5B:00007FFE738E6DB66D8E6DB6738E7FFE7FFE618E6FB6618E7DB6618E7FFE0000
+0B5C:000000000000000003C00C2010101050149009A0088007000000030003000000
+0B5D:000000000000000003C00C2010101010141009200A800700020001000C000C00
+0B5E:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61866FBE618E7DBE61867FFE0000
+0B5F:000000000000000007900850103012100C1018306848679C0000000000000000
+0B60:00000000000000000780184020C020202CC0122012C00C200010000000000000
+0B61:00000000000000000000038004400180020004C0052003C00080004000200000
+0B62:00000000000000000000000000000000000000000080014001400098012400F8
+0B63:000000000000000000000000000000000000000000800140015800A4013800D0
+0B64:00007FFE738E6DB66D8E6DB6738E7FFE7FFE73B66FB663866DF673F67FFE0000
+0B65:00007FFE738E6DB66D8E6DB6738E7FFE7FFE73866FBE63866DF673867FFE0000
+0B66:0000000000000000000000000380044010101010101004400380000000000000
+0B67:000000000000000003C004200A100A1009E004000200010000C0002000000000
+0B68:000000000000000003C004200850085007900020004000800300040000000000
+0B69:00000000000000000EE011102110291025101910011001100000000000000000
+0B6A:000000000000000004080210012000C000C0012002200220022001C000000000
+0B6B:000000000000000001C012200A20064001800260045004480380000000000000
+0B6C:000000000000000003C004200310009008900720004000800300040000000000
+0B6D:000000000000000003C0042009100A900A900720004000800300040000000000
+0B6E:0000000000000FE0080008000800080008000800080008000800000000000000
+0B6F:0000000000000000072008A00860080008000800040003000000000000000000
+0B70:0000000000000000001000200C400C8041002200140008000000000000000000
+0B71:000000000000000009E0121010E0081007F00810083007D00000000000000000
+0B72:0000000000000000008000800080008000800080008000800000000000000000
+0B73:0000000000000000088008800880098006800080008000800000000000000000
+0B74:0000000000000000222022202220266019A00020002000200000000000000000
+0B75:0000000000000000002000400080010002000400080010000000000000000000
+0B76:000000000000000000201C402A802B0012000400080010000000000000000000
+0B77:0000000000000000000200040008001036204940498049000000000000000000
+0B78:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61CE7DB67BCE77B677CE7FFE0000
+0B79:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61CE7DB67BC677F677CE7FFE0000
+0B7A:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61867DB67B8677B677B67FFE0000
+0B7B:00007FFE738E6DB66D8E6DB6738E7FFE7FFE618E7DB67B8E77B6778E7FFE0000
+0B7C:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61C67DBE7BBE77BE77C67FFE0000
+0B7D:00007FFE738E6DB66D8E6DB6738E7FFE7FFE618E7DB67BB677B6778E7FFE0000
+0B7E:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61867DBE7B8E77BE77867FFE0000
+0B7F:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61867DBE7B8E77BE77BE7FFE0000
+0B80:00007FFE738E6DB66D8E6DB6738E7FFE7FFE73CE6DB673B66DB673CE7FFE0000
+0B81:00007FFE738E6DB66D8E6DB6738E7FFE7FFE73EE6DCE73EE6DEE73C67FFE0000
+0B82:0100028001000000000000000000000000000000000000000000000000000000
+0B83:0000000000000000018002400240018018182424242418180000000000000000
+0B84:00007FFE738E6DB66D8E6DB6738E7FFE7FFE73B66DB673866DF673F67FFE0000
+0B85:0000000000000000061009100990069000901FF020901F100000000000000000
+0B86:00000000000000001840244026401A4002407FE082507C500150021001E00000
+0B87:000000000F801040232024902490135008401F8022401D800000000000000000
+0B88:00000000000000001FF81080108016B016B01080108010800000000000000000
+0B89:00000000000000003C004A004900310002003C0040003FF00000000000000000
+0B8A:00000000000000007000980099F86AD00950705080007FF80000000000000000
+0B8B:00007FFE738E6DB66D8E6DB6738E7FFE7FFE738E6DB6738E6DB6738E7FFE0000
+0B8C:00007FFE738E6DB66D8E6DB6738E7FFE7FFE73C66DBE73BE6DBE73C67FFE0000
+0B8D:00007FFE738E6DB66D8E6DB6738E7FFE7FFE738E6DB673B66DB6738E7FFE0000
+0B8E:000000000000000007FC081010101C102210221022101C100000000000000000
+0B8F:000000000000000007FC081010101C102210221022101C100020004000800000
+0B90:00000000000000003EE0711049104910311000103FE040004000421042103DE0
+0B91:00007FFE738E6DB66D8E6DB6738E7FFE7FFE73EE6DCE71EE7DEE73C67FFE0000
+0B92:00000000000000001FC020204010401071D04A504A903260020011E010400F80
+0B93:00000000000000001FC020204010401071D04A504A903260020031E048403F80
+0B94:00000000000000003C0042008100817CCDA8B568B928560010008F0082007C00
+0B95:00000000000000000FE00880088008803FE0409040903F200000000000000000
+0B96:00007FFE738E6DB66D8E6DB6738E7FFE7FFE73CE6DBE718E7DB673CE7FFE0000
+0B97:00007FFE738E6DB66D8E6DB6738E7FFE7FFE73866DF671EE7DDE73DE7FFE0000
+0B98:00007FFE738E6DB66D8E6DB6738E7FFE7FFE73CE6DB671CE7DB673CE7FFE0000
+0B99:00000000000000007E1048104F1048904890411042104FF00000000000000000
+0B9A:00000000000000000FE00880088008803FE0408040803F000000000000000000
+0B9B:00007FFE738E6DB66D8E6DB6738E7FFE7FFE738E6DB6718E7DB6738E7FFE0000
+0B9C:00000000000000003EE0711049104910311000103FE0400040E0411042103C60
+0B9D:00007FFE738E6DB66D8E6DB6738E7FFE7FFE738E6DB671B67DB6738E7FFE0000
+0B9E:000000000000000027E0488090809CA0A2D0A290A2909C90801040203FC00000
+0B9F:000000000000000010001000100010001000100010001FF80000000000000000
+0BA0:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61CE6DB661B66DB66DCE7FFE0000
+0BA1:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61EE6DCE61EE6DEE6DC67FFE0000
+0BA2:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61866DF661866DBE6D867FFE0000
+0BA3:00000000000000003BBF44488AA8CAA8AAA8AAA8444800080000000000000000
+0BA4:00000000000000000FE00880088008803FE0409040903F10001000203FC04000
+0BA5:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61866DBE61866DF66D867FFE0000
+0BA6:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61CE6DBE618E6DB66DCE7FFE0000
+0BA7:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61866DF661EE6DDE6DDE7FFE0000
+0BA8:00000000000000000FE0088008800880088008E008900890001000203FC04000
+0BA9:00000000000000001EFC2110429072904A904A90311000100000000000000000
+0BAA:000000000000000010201020102010201020102010201FE00000000000000000
+0BAB:00007FFE738E6DB66D8E6DB6738E7FFE7FFE618E6DB6618E6DB66D8E7FFE0000
+0BAC:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61C66DBE61BE6DBE6DC67FFE0000
+0BAD:00007FFE738E6DB66D8E6DB6738E7FFE7FFE618E6DB661B66DB66D8E7FFE0000
+0BAE:000000000000000021C02220222022202220222022203FC00000000000000000
+0BAF:000000000000000012101210121012101210121016101BF00000000000000000
+0BB0:00000000000000000FF008400840084008400840084008400040008001000200
+0BB1:000000000000000007700888088808880888088808880888001000100FE01000
+0BB2:00000000000000001C2022104110411071104910491030E00000000000000000
+0BB3:00000000000000001CFC23104110411071104910491031100000000000000000
+0BB4:000000000000000021C02220222022202220222022203FC0020023C020801F00
+0BB5:00000000000000001C1023104090409070904890491033F00000000000000000
+0BB6:000000000000000047FC44444444444444444444444438380000000000000000
+0BB7:00000000000000001C10222841284128711049284A4833F00080010000000000
+0BB8:00000000000000001D9022484248424872484A484A4832300000000000000000
+0BB9:0000000000000000386C449282928292E292929294926792000400043FF84000
+0BBA:00007FFE738E6DB66D8E6DB6738E7FFE7FFE63866DB663866DB663B67FFE0000
+0BBB:00007FFE738E6DB66D8E6DB6738E7FFE7FFE638E6DB6638E6DB6638E7FFE0000
+0BBC:00007FFE738E6DB66D8E6DB6738E7FFE7FFE63C66DBE63BE6DBE63C67FFE0000
+0BBD:00007FFE738E6DB66D8E6DB6738E7FFE7FFE638E6DB663B66DB6638E7FFE0000
+0BBE:0000000000000000001F00120012001200120012001200120000000000000000
+0BBF:001C002200220012000200020002000200020002000200020000000000000000
+0BC0:01C0022002C00100008000000000000000000000000000000000000000000000
+0BC1:0000000000000000001E00050002000000000000000000000000000000000000
+0BC2:0000000000060009001D000B0005000100020000000000000000000000000000
+0BC3:00007FFE738E6DB66D8E6DB6738E7FFE7FFE718E6FF66FC66FF6718E7FFE0000
+0BC4:00007FFE738E6DB66D8E6DB6738E7FFE7FFE71B66FB66F866FF671F67FFE0000
+0BC5:00007FFE738E6DB66D8E6DB6738E7FFE7FFE71866FBE6F866FF671867FFE0000
+0BC6:00000000000000003000480084008400E4009400940064000000000000000000
+0BC7:000000000000000030004800B00080008000B000480030000000000000000000
+0BC8:00000000000000003D80424087408540E5409540924060000000000000000000
+0BC9:00007FFE738E6DB66D8E6DB6738E7FFE7FFE71CE6FB66FC66FF671CE7FFE0000
+0BCA:0000000000000000301F481284128412E4129412941264120000000000000000
+0BCB:0000000000000000301F4812B01280128012B012481230120000000000000000
+0BCC:0000000000000000301F482A844A84CAE4AA94AA94AA644A0000000000000000
+0BCD:0300030000000000000000000000000000000000000000000000000000000000
+0BCE:00007FFE738E6DB66D8E6DB6738E7FFE7FFE71866FBE6F8E6FBE71867FFE0000
+0BCF:00007FFE738E6DB66D8E6DB6738E7FFE7FFE71866FBE6F8E6FBE71BE7FFE0000
+0BD0:0000000000000FF0300C400280018001E01D9025942961261AA0279E20041FF8
+0BD1:00007FFE738E6DB66D8E6DB6738E7FFE7FFE63EE6DCE6DEE6DEE63C67FFE0000
+0BD2:00007FFE738E6DB66D8E6DB6738E7FFE7FFE63866DF66D866DBE63867FFE0000
+0BD3:00007FFE738E6DB66D8E6DB6738E7FFE7FFE638E6DF66DC66DF6638E7FFE0000
+0BD4:00007FFE738E6DB66D8E6DB6738E7FFE7FFE63B66DB66D866DF663F67FFE0000
+0BD5:00007FFE738E6DB66D8E6DB6738E7FFE7FFE63866DBE6D866DF663867FFE0000
+0BD6:00007FFE738E6DB66D8E6DB6738E7FFE7FFE63CE6DBE6D8E6DB663CE7FFE0000
+0BD7:0000000000000000001F002A004A00CA00AA00AA00AA004A0000000000000000
+0BD8:00007FFE738E6DB66D8E6DB6738E7FFE7FFE63CE6DB66DCE6DB663CE7FFE0000
+0BD9:00007FFE738E6DB66D8E6DB6738E7FFE7FFE63CE6DB66DC66DF663CE7FFE0000
+0BDA:00007FFE738E6DB66D8E6DB6738E7FFE7FFE63866DB66D866DB663B67FFE0000
+0BDB:00007FFE738E6DB66D8E6DB6738E7FFE7FFE638E6DB66D8E6DB6638E7FFE0000
+0BDC:00007FFE738E6DB66D8E6DB6738E7FFE7FFE63C66DBE6DBE6DBE63C67FFE0000
+0BDD:00007FFE738E6DB66D8E6DB6738E7FFE7FFE638E6DB66DB66DB6638E7FFE0000
+0BDE:00007FFE738E6DB66D8E6DB6738E7FFE7FFE63866DBE6D8E6DBE63867FFE0000
+0BDF:00007FFE738E6DB66D8E6DB6738E7FFE7FFE63866DBE6D8E6DBE63BE7FFE0000
+0BE0:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61CE6FB663B66FB661CE7FFE0000
+0BE1:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61EE6FCE63EE6FEE61C67FFE0000
+0BE2:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61866FF663866FBE61867FFE0000
+0BE3:00007FFE738E6DB66D8E6DB6738E7FFE7FFE618E6FF663C66FF6618E7FFE0000
+0BE4:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61B66FB663866FF661F67FFE0000
+0BE5:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61866FBE63866FF661867FFE0000
+0BE6:0000000000000000018002400420042004200420024001800000000000000000
+0BE7:00000000000000000FE00880088008803FE0409040903F200000000000000000
+0BE8:00000000000000001C0022004100410022003C0040003FF00000000000000000
+0BE9:00000000000000003F802200220022C023202220204023FC0000000000000000
+0BEA:00000000000000000FE40884088408843FFC408040803F000000000000000000
+0BEB:000000000000000013F82220422042204220423842244224400420081FF00000
+0BEC:00000000000000000FE00880088008803FFE40A440A43F240000000000000000
+0BED:000000000000000007FC081010101C102210221022101C100000000000000000
+0BEE:0000000000000E0011101090085006503FF0405020901F100000000000000000
+0BEF:00000000000000000FC009000900091C3FE24132412A3E120000000000000000
+0BF0:000003800040002022202220222022202220222022201DC00000000000000000
+0BF1:00000000000000001BF826202220222022202220222022200000000000000000
+0BF2:00000000000000000FE00880088008803FFC409040903F780054003400040078
+0BF3:00000000000000001C0023004080408070804880490033F00000000000000000
+0BF4:007000C800AE00C021C02220222022202220222022203FC00000000000000000
+0BF5:000000003FFC40029C3AA252A154A155B152A958AA5493D4800440083FF00000
+0BF6:000000000000000010241024102410241024102410241FE4002407FC082007C0
+0BF7:00000000000000000F801200220032604A904BC84AA8324E0000000000000000
+0BF8:00000000000000003E024105808583C5E4A2949594A5633E0008001000000000
+0BF9:0E0011003C8052F04C0047E0484048404840487048484848400820101FE00000
+0BFA:0038004400F2014B01300F8011001100110011C011201120002000401F802000
+0BFB:00007FFE738E6DB66D8E6DB6738E7FFE7FFE618E6FB6638E6FB66F8E7FFE0000
+0BFC:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61C66FBE63BE6FBE6FC67FFE0000
+0BFD:00007FFE738E6DB66D8E6DB6738E7FFE7FFE618E6FB663B66FB66F8E7FFE0000
+0BFE:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61866FBE638E6FBE6F867FFE0000
+0BFF:00007FFE738E6DB66D8E6DB6738E7FFE7FFE61866FBE638E6FBE6FBE7FFE0000
+0C00:000001800990042003C000000000000000000000000000000000000000000000
+0C01:0000000000000000000000010002000400040004000200010000000000000000
+0C02:0000000000000000000000000006000900090006000000000000000000000000
+0C03:0000000000000000000200050005000200000002000500050002000000000000
+0C04:0000018002400180000000000000000000000000000000000000000000000000
+0C05:00000000000000000C60129032482CC82008200810100FE00000000000000000
+0C06:00000000000000000C10122832282CF02010201010200FC00000000000000000
+0C07:00000000000000003B804440444000401E8021001E8000400040004000000000
+0C08:00000000000000004200240018603C9042207FE042903C600000000000000000
+0C09:00000000010001000FE0101020007FF84000406022901DE00000000000000000
+0C0A:00000000050005001F8820444008FFF88014808845403B800000000000000000
+0C0B:000000000000000064909248124822484248824892486DB00000000000000000
+0C0C:00000000000000001B0024802480011002100210022001C00000000000000000
+0C0D:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE738E6DB66DB66DB6738E7FFE0000
+0C0E:0000000000000000002000100008000800080E0813100CE00000000000000000
+0C0F:000000000000020004E008100808000800080E0813100CE00000000000000000
+0C10:00000000000000000EE011101108000800080E0813100CE00000000000000000
+0C11:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE7BEE73CE7BEE7BEE71C67FFE0000
+0C12:00000000000000000C001200120004000800100011100EE00000000000000000
+0C13:00000600090004000C001200120004000800100011100EE00000000000000000
+0C14:00003FE001503E200C001200120004000800100011100EE00000000000000000
+0C15:0000002002400180018002400200018000400020082007C00000000000000000
+0C16:00000000000000003000480034800440042034204C4037800400000000000000
+0C17:0000000000000000088005000200050005000880088008800000000000000000
+0C18:00000000000000000000040049303088004830484C9037600400000000000000
+0C19:00000000000000000C40124013F004000800100011100EE00000000000000000
+0C1A:000000000010002001C001A0001000087808090813900C600000000000000000
+0C1B:000000000010002001C001A0001000087808090813900D600100000000000000
+0C1C:00000000000000000C40132012C004000800100011100EE00000000000000000
+0C1D:00000080210012000C901248124812481248124812E80D500040000000000000
+0C1E:00000000000000001B00248024A000F000801D0022001D000100010000000000
+0C1F:000000001000100018C02420582040104010401022101DE00000000000000000
+0C20:000000000000000010400880070008801040124010400F800000000000000000
+0C21:00000020084004800F001200210040804000406022901DE00000000000000000
+0C22:00000020084004800F001200210040804000406022901FE00200000000000000
+0C23:00000000000000000C601290210820081808203822481C300000000000000000
+0C24:0008011000A000400C6012902C6820082008200810100FE00000000000000000
+0C25:000000000000000010400880070008801240104012400F800200000000000000
+0C26:000000000000000010400880070008801040104012400D800000000000000000
+0C27:000000000000000010400880070008801040104012400F800200000000000000
+0C28:008001001A001C00038000400020001018102410222011C00000000000000000
+0C29:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE61CE7DB661C66FF661CE7FFE0000
+0C2A:004000800900060000E000100008000800080E0813100CE00000000000000000
+0C2B:004000800900060000E000100008000800080E0813100DE00100000000000000
+0C2C:000000000000000030C04820081010082008210812900C600000000000000000
+0C2D:00000004000800D030E04820081010082008210812900C600100000000000000
+0C2E:00400080010006000730008800480048004838484CC833300000000000000000
+0C2F:004000800D0002000130008830484848484848484CC833300000000000000000
+0C30:000000000000000010400880070008801040104010400F800000000000000000
+0C31:00000000000000000C60129032882FC82008200810100FE00000000000000000
+0C32:000000000000000018C02420641058104010402020401F800000000000000000
+0C33:0008001001A001C00040182024102C1010200FC0090006000000000000000000
+0C34:000000000000000018C02520653058D04010421022201DC00000000000000000
+0C35:000000100020004001E001900008000800080E0813100CE00000000000000000
+0C36:00000040008001000780064000200E2011401380048003000000000000000000
+0C37:004000800900060000E000100008000800080E0813100CE00010000800040000
+0C38:004000800500020000E000100008000800080E08131010E00000000000000000
+0C39:040008005000200007F8022801100080008038804C8033000000000000000000
+0C3A:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE63867DB671867DB663B67FFE0000
+0C3B:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE638E7DB6718E7DB6638E7FFE0000
+0C3C:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE63C67DBE71BE7DBE63C67FFE0000
+0C3D:0000000000000000000007000080008003000400040003F80000000000000000
+0C3E:000000000000000000FF00050002000000000000000000000000000000000000
+0C3F:0180024001C00780000000000000000000000000000000000000000000000000
+0C40:04000980064001C0078000000000000000000000000000000000000000000000
+0C41:0000000000000000000000060001000100010001000900060000000000000000
+0C42:000000000000000000FF002500120008000400020012000C0000000000000000
+0C43:0000000000000000000000060001000100010005000B00060000000000000000
+0C44:0000000000000000001F0011000800040002000A0016000C0000000000000000
+0C45:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE6D866DBE61867DF67D867FFE0000
+0C46:0FC00020002000C0000000000000000000000000000000000000000000000000
+0C47:006000800FC0002000C000000000000000000000000000000000000000000000
+0C48:0FC00020002000C000000000000000000000000000000000000004000A000FF0
+0C49:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE6DCE6DB661C67DF67DCE7FFE0000
+0C4A:000037E008900060000000000000000000000000000000000000000000000000
+0C4B:0030004837E04850002000000000000000000000000000000000000000000000
+0C4C:00003FE004903860000000000000000000000000000000000000000000000000
+0C4D:0F0010000C0010000C0000000000000000000000000000000000000000000000
+0C4E:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE6D866DBE618E7DBE7D867FFE0000
+0C4F:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE6D866DBE618E7DBE7DBE7FFE0000
+0C50:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE61CE6FB661B67DB661CE7FFE0000
+0C51:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE61EE6FCE61EE7DEE61C67FFE0000
+0C52:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE61866FF661867DBE61867FFE0000
+0C53:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE618E6FF661C67DF6618E7FFE0000
+0C54:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE61B66FB661867DF661F67FFE0000
+0C55:0060009000480000000000000000000000000000000000000000000000000000
+0C56:000000000000000000000000000000000000000000000000000004000A000FF0
+0C57:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE61866FF661EE7DDE61DE7FFE0000
+0C58:010002807F90002001C001A0001000087808090813900C600000000000000000
+0C59:004000A01FE000000C40132012C004000800100011100EE00000000000000000
+0C5A:00000000000007C00820101010101FF01110111011100EE00000000000000000
+0C5B:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE618E6FB6618E7DB6618E7FFE0000
+0C5C:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE61C66FBE61BE7DBE61C67FFE0000
+0C5D:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE618E6FB661B67DB6618E7FFE0000
+0C5E:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE61866FBE618E7DBE61867FFE0000
+0C5F:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE61866FBE618E7DBE61BE7FFE0000
+0C60:0000000000000000493EA4952492249044908490A4905B600000000000000000
+0C61:00000000000000001B3E24A524A2011002100210022001C00000000000000000
+0C62:00000000000000000000000000000000000000000000000006C0092800280010
+0C63:0000000000000000000000000000000000000000000000001B3824B400A80040
+0C64:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE73B66FB663866DF673F67FFE0000
+0C65:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE73866FBE63866DF673867FFE0000
+0C66:0000000000000000018002400420042004200420024001800000000000000000
+0C67:000000000000000003C004200810081008100810042002400000000000000000
+0C68:0000000000000000000000E0011001480088000800103FE00000000000000000
+0C69:000000000000000001E00210021000E000100210021001E00000000000000000
+0C6A:0000000000000000042008100810042003C00420042003C00000000000000000
+0C6B:00000000000000000004030400C8003000300048008807100000000000000000
+0C6C:00000000000000003800400040003F004000400020001FF80000000000000000
+0C6D:000000000000000001C002200420004003880408041003E00000000000000000
+0C6E:000000000000000010FC2080404040404040404020801F000000000000000000
+0C6F:00000000000000001FF82000400040003F004000400038000000000000000000
+0C70:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE61CE7DB67BB677B677CE7FFE0000
+0C71:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE61EE7DCE7BEE77EE77C67FFE0000
+0C72:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE61867DF67B8677BE77867FFE0000
+0C73:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE618E7DF67BC677F6778E7FFE0000
+0C74:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE61B67DB67B8677F677F67FFE0000
+0C75:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE61867DBE7B8677F677867FFE0000
+0C76:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE61CE7DBE7B8E77B677CE7FFE0000
+0C77:000000000000000001E0021024C82528142812480990042003C0000000000000
+0C78:000000000000000003C0042004200420042003C0002000100060018000000000
+0C79:0000000000000000008000800080008000800080008000800000000000000000
+0C7A:0000000000000000022002200220022001E00020002000200000000000000000
+0C7B:0000000000000000092009200920092006E00020002000200000000000000000
+0C7C:000000000000000000000000000000000000000000001FF80000000000000000
+0C7D:000000000000000007C00020002001C002000400040003F80000000000000000
+0C7E:0000000000000700008003000400030000800300040003F80000000000000000
+0C7F:0000000000000000060009001608100810101010082007C00000000000000000
+0C80:0000000000000000000000000990042003C00000000000000000000000000000
+0C81:0990042003C00000000000000000000000000000000000000000000000000000
+0C82:0000000000000000000000000006000900090006000000000000000000000000
+0C83:0000000000000000000200050005000200000002000500050002000000000000
+0C84:0000000000000000000003F0040808C8492448242444238810100FE000000000
+0C85:00000000000000000C60129032482CE82008200810100FE00000000000000000
+0C86:00000000000000000C30124832282CF02008200810100FE00000000000000000
+0C87:00000000000000003B804440444000401E8021001E8000400040004000000000
+0C88:000000000000000002000200FE603C9042607FE042203C400000000000000000
+0C89:00000000000000004620A910A910C91089108910492030C00000000000000000
+0C8A:0000000000000000461CA922A922C9228926892A492A30C40000000000000000
+0C8B:000000000080008067909088684408440844684494A463180000000000000000
+0C8C:00000000000000001B0024802480008001000110011000E00000000000000000
+0C8D:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE738E6DB673B66DB6738E7FFE0000
+0C8E:00000000000000003E000180004000202010510842883C700000000000000000
+0C8F:000000000000200010000980064000202010510842883C700000000000000000
+0C90:00000000000000001C602290410800082008510842883C700000000000000000
+0C91:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE73EE6DCE71EE7DEE73C67FFE0000
+0C92:000000000000000030004800480010202010410842883C700000000000000000
+0C93:000000001800200030004800480010202010410842883C700000000000000000
+0C94:7FE0021002107C90312048C0480010202010410842883C700000000000000000
+0C95:0000000000C000201FC0020002001FC00880104010400F800000000000000000
+0C96:00000000000000000E2011102088208401040F0412840C780000000000000000
+0C97:000000E0001000103FE004400820082008200820082008200000000000000000
+0C98:0000000007000080FF200010020860289030622027201AC00200000000000000
+0C99:000000000000000033F04C08483011002010410842883C700000000000000000
+0C9A:000000000030000860F09080904020E0404084408A4071800000000000000000
+0C9B:000000000030000860F090809040E040804084408E4075800400000000000000
+0C9C:0000000000000000318048404F80100020404220452038C00000000000000000
+0C9D:00000E0001003E001C902248224822482248224822E81D500040000000000000
+0C9E:00000000000000001B6024902490008000801D0022001D000100010000000000
+0C9F:0000000000000000102018C0242058104010401022101DE00000000000000000
+0CA0:000000000000038000401F80070008801040124010400F800000000000000000
+0CA1:000000000000038000407FC0212040E040104210251018E00000000000000000
+0CA2:000000000000038000407FC0212040E04010421027101AE00200000000000000
+0CA3:000000000000000018E025104208400820884148415030E00000000000000000
+0CA4:0000000001C000200FC00020001010D0112008D0041003E00000000000000000
+0CA5:000000000000038000401F80070008801240104012400F800200000000000000
+0CA6:000000000000038000401F80070008801040104012400D800000000000000000
+0CA7:000000000000038000401F80070008801040104012400F800200000000000000
+0CA8:0000000000E0001007E000400020001018102410222011C00000000000000000
+0CA9:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE61CE6DB661C66DF66DCE7FFE0000
+0CAA:0000000000E000101FE00000202051105008610842883C700000000000000000
+0CAB:0000000000E000101FE00000202051105008610842883D700100000000000000
+0CAC:000000000000000030C04820081010082008210812900C600000000000000000
+0CAD:000000000070000831F04840082010102008210812900D600100000000000000
+0CAE:00000000038000403F8000004090A048A048C4488A4871B00000000000000000
+0CAF:00000000000000C0002033C048908448844884488A4871B00000000000000000
+0CB0:000000000000038000401F80070008801040104010400F800000000000000000
+0CB1:00000000000000000C60129032983FF82008210812900C600000000000000000
+0CB2:000000000000000001003080484070204020402020401F800000000000000000
+0CB3:000000000060001001E03080484070204020402020401F800900060000000000
+0CB4:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE63B66DB663866DF663F67FFE0000
+0CB5:0000000000000030000803F0202050105008610842883C700000000000000000
+0CB6:0000000001C000207FC030804840442024200420044003800000000000000000
+0CB7:0000000000C000200FC00000202051105008612842983C740000000000000000
+0CB8:00000000018000400F800000042000100E101110209020600000000000000000
+0CB9:0000000000E0001007E0008002A005D008880888049003600000000000000000
+0CBA:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE63866DB663866DB663B67FFE0000
+0CBB:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE638E6DB6638E6DB6638E7FFE0000
+0CBC:0000000000000000000000000000000000000000000000000000000002400000
+0CBD:000000000000000003800400080004000300008010800F000000000000000000
+0CBE:000000000000001C000200010001000500090009000600000000000000000000
+0CBF:00180024001C0008003000000000000000000000000000000000000000000000
+0CC0:00180024001C0008003200050005000600040004000400040002000000000000
+0CC1:0000000000000000000000040002000100010001000900060000000000000000
+0CC2:00000000000000000000000600090009000B000B000B00080008003000000000
+0CC3:000000000000000000000000000000000000000C000200010001000D000D0006
+0CC4:00000000000000000000007E0021001500160010000C00020001000D000D0006
+0CC5:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE71866FBE6F866FF671867FFE0000
+0CC6:0018002400040FF8000000000000000000000000000000000000000000000000
+0CC7:0018002400040FF8000200050005000600040004000400040002000000000000
+0CC8:0018002400040FF8000000000000000000040002000400020001000D000D0006
+0CC9:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE71CE6FB66FC66FF671CE7FFE0000
+0CCA:0018002400040FF80000000600090009000B000B000B00080008003000000000
+0CCB:0063009300120FE20001000700090009000B000B000B00080008003000000000
+0CCC:00FC001200E20001000100010001000500090009000600000000000000000000
+0CCD:00000003000400FE000500020000000000000000000000000000000000000000
+0CCE:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE71866FBE6F8E6FBE71867FFE0000
+0CCF:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE71866FBE6F8E6FBE71BE7FFE0000
+0CD0:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE63CE6DB66DB66DB663CE7FFE0000
+0CD1:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE63EE6DCE6DEE6DEE63C67FFE0000
+0CD2:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE63866DF66D866DBE63867FFE0000
+0CD3:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE638E6DF66DC66DF6638E7FFE0000
+0CD4:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE63B66DB66D866DF663F67FFE0000
+0CD5:0000000000000000000200050005000600040004000400040002000000000000
+0CD6:0000000000000000000000000000000000040002000400020001000D000D0006
+0CD7:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE63866DF66DEE6DDE63DE7FFE0000
+0CD8:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE63CE6DB66DCE6DB663CE7FFE0000
+0CD9:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE63CE6DB66DC66DF663CE7FFE0000
+0CDA:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE63866DB66D866DB663B67FFE0000
+0CDB:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE638E6DB66D8E6DB6638E7FFE0000
+0CDC:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE63C66DBE6DBE6DBE63C67FFE0000
+0CDD:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE638E6DB66DB66DB6638E7FFE0000
+0CDE:00000000000000000C60129032982C682008200811100EE00000000000000000
+0CDF:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE63866DBE6D8E6DBE63BE7FFE0000
+0CE0:00000000004000400F80620E9111711111137115999566620000000000000000
+0CE1:00000000000000001B0024802480010001400088009000600000000000000000
+0CE2:00000000000000000000000000000000000000000000000006C0092008200418
+0CE3:0000000000000000000000000000000000000000000000000D80124C1050083C
+0CE4:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE61B66FB663866FF661F67FFE0000
+0CE5:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE61866FBE63866FF661867FFE0000
+0CE6:0000000000000000018002400420042004200420024001800000000000000000
+0CE7:000000000000000003C004200810081008100810042002400000000000000000
+0CE8:000000000000000000E00110013000D000100010001007E00000000000000000
+0CE9:00000000000000000F00128012400C400E40114810900F600000000000000000
+0CEA:0000000000000000062009100E10042003C00420042003C00000000000000000
+0CEB:000000000000000000181C24232410F807E0191022101C600000000000000000
+0CEC:000000000000100008003E00490049004600400020001FF80000000000000000
+0CED:0000000000000000018002400140008007000800080007F00000000000000000
+0CEE:00000000000000000610092011201E1010101010082007C00000000000000000
+0CEF:000000000000000007FE0800100010000FC0100010000E000000000000000000
+0CF0:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE61CE6FB663B66FB66FCE7FFE0000
+0CF1:AAAA000180001FF188200441828001018280044188201FF18000000180005555
+0CF2:AAAA000180000001800000019C702289A28822899C7000018000000180005555
+0CF3:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE618E6FF663C66FF66F8E7FFE0000
+0CF4:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE61B66FB663866FF66FF67FFE0000
+0CF5:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE61866FBE63866FF66F867FFE0000
+0CF6:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE61CE6FBE638E6FB66FCE7FFE0000
+0CF7:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE61866FF663EE6FDE6FDE7FFE0000
+0CF8:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE61CE6FB663CE6FB66FCE7FFE0000
+0CF9:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE61CE6FB663C66FF66FCE7FFE0000
+0CFA:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE61866FB663866FB66FB67FFE0000
+0CFB:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE618E6FB6638E6FB66F8E7FFE0000
+0CFC:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE61C66FBE63BE6FBE6FC67FFE0000
+0CFD:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE618E6FB663B66FB66F8E7FFE0000
+0CFE:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE61866FBE638E6FBE6F867FFE0000
+0CFF:00007FFE73C66DBE6DBE6DBE73C67FFE7FFE61866FBE638E6FBE6FBE7FFE0000
+0D00:0180024002400180000000000000000000000000000000000000000000000000
+0D01:000001800990042003C000000000000000000000000000000000000000000000
+0D02:0000000000000000000000000006000900090006000000000000000000000000
+0D03:0000000000000000000200050005000200000002000500050002000000000000
+0D04:0000000000000000010009201110111011101010082007C00000000000000000
+0D05:00000000000000001E3021487C84A284BC9CA2A4A2A41C980000000000000000
+0D06:00000000000000001E32214D7C8DA295BCA5A2A5A2A51C990001003E00000000
+0D07:000000000000000018C025204210421072104A104A10321000103FE040003FE0
+0D08:000000000000000074508AA88AA88AA8CA08AA48AA30420002007C0080007C00
+0D09:00000000000000000F00128012400C4000400F8010001FC00000000000000000
+0D0A:00000000000000001C502AA82AA812A802081C4820303E000000000000000000
+0D0B:00000000000000000C6012901C701010082007C0082007C00000000000000000
+0D0C:00000000000000000C6012902128214839482548254819300000000000000000
+0D0D:00007FFE738E6DB66DB66DB6738E7FFE7FFE738E6DB66DB66DB6738E7FFE0000
+0D0E:0000000000F001087128892889285FE801280128012800C00000000000000000
+0D0F:0000000001E0021072888A888A885F9002880288028801300000000000000000
+0D10:00000000000E00117395AC55AC554AFD08150015001500080000000000000000
+0D11:00007FFE738E6DB66DB66DB6738E7FFE7FFE7BEE73CE7BEE7BEE71C67FFE0000
+0D12:0000000000000000078008401020201020103C2022101C600000000000000000
+0D13:00000000000000000E181124210420842084310428A413180000000000000000
+0D14:00000000000000001C2822544254415441046224511826000000000000000000
+0D15:00000000000000000380044004401FF02448244824481B900000000000000000
+0D16:00000000000000001E0421044084404470444844488431FC0000000000000000
+0D17:000000000000000000000000187020884104410422081C700000000000000000
+0D18:00000000000000000072008A388A448A448A2FFA008200FE0000000000000000
+0D19:000000000000000018E025104208420872704A084A0832700000000000000000
+0D1A:000000000000000000080008000806080908010802083FF80000000000000000
+0D1B:00000000000000000030004800840C84128C029404543FC80000000000000000
+0D1C:00000000000000003EE041107110491030203FF040C83F300000000000000000
+0D1D:00000000000000003C245E22A522A52299228122412400D80000000000000000
+0D1E:000000000000000018C025384254429472944A944A9432600000000000000000
+0D1F:0000000000000000000007C00800080007C00020002007C00000000000000000
+0D20:000000000000000007C008201010101010101010082007C00000000000000000
+0D21:000000000000000000000C4812442244224422441244024801B0000000000000
+0D22:00000000000000000000189024A824A824A824A8049804900360000000000000
+0D23:000000000000000019B0264842484248424872484A4832500000000000000000
+0D24:00000000000000000CF013082284244424242424224411880000000000000000
+0D25:000000000000000040F04108410841084108410841087FF80000000000000000
+0D26:000000000000000007C00820102011C010201020122009C00000000000000000
+0D27:000000000000000009201110210821082108210811100EE00000000000000000
+0D28:00000000000000000EE011102108210821082108111009200000000000000000
+0D29:00000000000000000CE013102108390825082508251019200000000000000000
+0D2A:000000000000000000080008000800083808440844082FF80000000000000000
+0D2B:000000000000000000700088008800883888448844882FF80000000000000000
+0D2C:00000000000000001988264842484248424872484A4832780000000000000000
+0D2D:000000000000000007C00820102011C0120011C010200BC00000000000000000
+0D2E:000000000000000007E0091010881088110812081C081FF80000000000000000
+0D2F:000000000000000011882A44242424242444228413080CF00000000000000000
+0D30:00000000000000000F0010C020A0211021082108209010600000000000000000
+0D31:000000000000000007C008201010101010101010101008200000000000000000
+0D32:00000000000000000C081208210821083F08200820083FF80000000000000000
+0D33:00000000000000000FC01020202038C02420182000200FC010000FF000000000
+0D34:000000000000000010E011101110092007C0010011000E000000000000000000
+0D35:00000000000000001E0821084088408840884088410823F80000000000000000
+0D36:00000000000000000870108821042104211C212412240C180000000000000000
+0D37:0000000000000000031804A804C803883888448844882FF80000000000000000
+0D38:0000000000000000361049088888888888888888889048E00000000000000000
+0D39:000000000000000000E001100208020872088A0889105F200000000000000000
+0D3A:000000000000000010001000100010001000100010001FF80100010000000000
+0D3B:0080008000800080008000000000000000000000000000000000000000000000
+0D3C:000C00120012000C000000000000000000000000000000000000000000000000
+0D3D:0000001000280028004000400040004000400040004002800280010000000000
+0D3E:0000000000000000000600090001000100010001000900060000000000000000
+0D3F:0000000600090009000100010001000100010001000100010000000000000000
+0D40:0006000900070001000100010001000100010001000100010000000000000000
+0D41:00000000000000000000000600090001000200040004000A0004000000000000
+0D42:00000000000000000000000600090001000200040004000A00150011000E0000
+0D43:0000000000000000000100020004000400040002000100010001001F0021001E
+0D44:000000000000000000010002000400040004000200010001000100DD012500FE
+0D45:00007FFE738E6DB66DB66DB6738E7FFE7FFE6D866DBE61867DF67D867FFE0000
+0D46:00000000000000007000880088008800C800A800A80048001000000000000000
+0D47:000000000000000060009000E00080008000E000900060000000000000000000
+0D48:0000000000000000D800B400B400B40090009000D800D8000000000000000000
+0D49:00007FFE738E6DB66DB66DB6738E7FFE7FFE6DCE6DB661C67DF67DCE7FFE0000
+0D4A:00000000000000007006880988018801C801A801A80948061000000000000000
+0D4B:000000000000000060069009E00180018001E001900960060000000000000000
+0D4C:0000000000000000700A881588158801C802A804A80048001000000000000000
+0D4D:001200210021001E000000000000000000000000000000000000000000000000
+0D4E:0000000000000180018000000000000000000000000000000000000000000000
+0D4F:00000000000000002660499050885C885288528852884C8820101FE000000000
+0D50:00007FFE738E6DB66DB66DB6738E7FFE7FFE61CE6FB661B67DB661CE7FFE0000
+0D51:00007FFE738E6DB66DB66DB6738E7FFE7FFE61EE6FCE61EE7DEE61C67FFE0000
+0D52:00007FFE738E6DB66DB66DB6738E7FFE7FFE61866FF661867DBE61867FFE0000
+0D53:00007FFE738E6DB66DB66DB6738E7FFE7FFE618E6FF661C67DF6618E7FFE0000
+0D54:00000000000010001600090014801280110012C01C301FF80000000000000000
+0D55:00000000001011282AA024A024A024A022A013200CC000000000000000000000
+0D56:000000001800240004E04510491039200FC0110011000E000000000000000000
+0D57:0000000000000000000A00150015000100020004000000000000000000000000
+0D58:0000000000E000100A481248224822482248224812500DA00000000000000000
+0D59:00000000000000001C0022304148414847F04900490026000000000000000000
+0D5A:00000000000000000DF01248222822282228222812480AF80000000000000000
+0D5B:00000000000000007F1042084408440844084408421041E00000000000000000
+0D5C:000000000000004011202AA02AA02AA02AA02AA02AA024401000000000000000
+0D5D:000000000000001004482AA82AA82AA82AA82AA82AA851100000000000000000
+0D5E:0000000000000000180024C042A842A84F10520052004C002000000000000000
+0D5F:00000000000000000300048009404A24AA2AAA2A492404C00000000000000000
+0D60:0000000000000000186024905868400820101FE02010249020101FE000000000
+0D61:000000000000000018C025384254429472944A944A9432640004004800300000
+0D62:0000000000000000000000000000000000000000000000001EF0393825481930
+0D63:000000000000000000000000000000000000000000001EF039382548183800F0
+0D64:00007FFE738E6DB66DB66DB6738E7FFE7FFE73B66FB663866DF673F67FFE0000
+0D65:00007FFE738E6DB66DB66DB6738E7FFE7FFE73866FBE63866DF673867FFE0000
+0D66:00000000000000000000000003C004200420042003C000000000000000000000
+0D67:000000000000000000F00108010801080108010801081FF820001F0000000000
+0D68:00000000000000001E0021004080408040804080410023F80000000000000000
+0D69:00000000000000001B00248044404440444044404440247C0000000000000000
+0D6A:000000000000000006000100010007C009201120112010C00000000000000000
+0D6B:000000000000000007E008101188124812881248124808500780000000000000
+0D6C:00000000000000001B1824A44442444244424442444224420004000800100000
+0D6D:000000000000000003C004200810100810081E0811080E080010002001C00000
+0D6E:00000000000000001E0821084088408840884088410823F80008000800700000
+0D6F:00000000000000000380008000801BE024904490449024600000000000000000
+0D70:00000000000000000000024802440244024402440244024803B002003C000000
+0D71:00000000000000000EE0111021082108210811080010022001C0000000000000
+0D72:00000000000000001B84244A442A44FE4520452044A024400000000000000000
+0D73:00000000000000000000000000000FF810001C0012000C000000000000000000
+0D74:000001C0002000100FD010202050209038902490249018600000000000000000
+0D75:000000E0001000080C6812902128214839482548254819300000000000000000
+0D76:000000000000000000F001480228022872288A488B885FF80000000000000000
+0D77:0000000000000000033004CA048A049C64A894A894A89E904000000000000000
+0D78:000000000000000008BE554955455545554555455549A25F0000000000000000
+0D79:00000000000000001B802440442044FE4520452044A024400000000000000000
+0D7A:00000030004800041B742488449844A864A854A854A824900000000000000000
+0D7B:000000E0001000080C6812902128214821482148114809300000000000000000
+0D7C:000000C00020001007D008201050109010901090089004600000000000000000
+0D7D:000000E0001000081CE823104528494849484948494826300000000000000000
+0D7E:000000E00010000800681090212821482148214812480C300000000000000000
+0D7F:0000038004400020072008A008A03FF848A448A4489837000000000000000000
+0D80:00007FFE738E6DB66DB66DB6738E7FFE7FFE73CE6DB673B66DB673CE7FFE0000
+0D81:09900990042003C0000000000000000000000000000000000000000000000000
+0D82:0000000000000000000000000006000900090006000000000000000000000000
+0D83:0000000000000000000600090009000600000006000900090006000000000000
+0D84:00007FFE738E6DB66DB66DB6738E7FFE7FFE73B66DB673866DF673F67FFE0000
+0D85:0000000000000000031804A800680FF010201020082007E00020002000200020
+0D86:000000000000000018D8256403427F828102810241243F180100010001000100
+0D87:00000000000000000C4012A001BE3FC24084408420841F840084008400840083
+0D88:00000000000000000C4012A001BE3FC44088409E20821F840084008400840083
+0D89:000000000000000007C008201110129011100E60001000E00000000000000000
+0D8A:0800150009200250042007000880104010401040088007000000000000000000
+0D8B:00000000000000000180024000200FE01000101010200FC00000000000000000
+0D8C:0000000000000000062C092A00923F824012404C40803F000000000000000000
+0D8D:0000000000000000618092400A267BE9802184278A4971868001000000000000
+0D8E:00000000000000004200A500149277AD8089889B952D62120000000000000000
+0D8F:00000000000000001C382A5442424E72500A481227E410080FF0000000000000
+0D90:000000000000000071C0AAA08A36BBB5A0A9A0A19F2940463F80000000000000
+0D91:03800480038000800C8002403E2010202020202010400F800000000000000000
+0D92:03B804A403B800A00CA002603E2010202020202010400F800000000000000000
+0D93:001C0024001C00040064701289F18481B301B9018882707C0000000000000000
+0D94:0000000000003FE0401001C861A450244FC4400421081EF00000000000000000
+0D95:00007FC020203FF0401001C861A450244FC4400421081EF00000000000000000
+0D96:0000000000007F0080800E400D6CC16ABE5280428892770C0007000000000000
+0D97:00007FFE738E6DB66DB66DB6738E7FFE7FFE73866DF671EE7DDE73DE7FFE0000
+0D98:00007FFE738E6DB66DB66DB6738E7FFE7FFE73CE6DB671CE7DB673CE7FFE0000
+0D99:00007FFE738E6DB66DB66DB6738E7FFE7FFE73CE6DB671C67DF673CE7FFE0000
+0D9A:0000000000000000600093E08C100FC8102820284448BB900000000000000000
+0D9B:00000000000000001FE020100F081088204820482C901CE00100000000000000
+0D9C:000000000000000000000000278048408E208220444038800000000000000000
+0D9D:00000000000000003080494005407D8010402020272018C00000000000000000
+0D9E:000000003F8040401C201A1002103E104010401022201DC00000000000000000
+0D9F:00000000000000001C382A4442424E725012482227C41F880000000000000000
+0DA0:000000001F0020800C4002203E2010202020202010400F800000000000000000
+0DA1:00000020004000800CB002C83E78104C2032200210040FF80000000000000000
+0DA2:00000008001000200C2002703EA810A82070202010400F800000000000000000
+0DA3:0000000000000070E088900427C2782286428182C992B66C0000000000000000
+0DA4:000000000000000039F056288404987CA680C180C944B638000800100010000C
+0DA5:000000000000000038385454848299BEA1E0C240C44C38340004000800080006
+0DA6:00000004000800101D902A3842544C545038601060201FC00000000000000000
+0DA7:00000000000000001F80204000201C202020202010400F800000000000000000
+0DA8:01C0024001C0004000400020001020104010401022201DC00000000000000000
+0DA9:000000001FC020200C1002083E0810082008200811100EE00000000000000000
+0DAA:01C0024001C00040184004207C1020104010401022201DC00000000000000000
+0DAB:0000000000F801001E002600390C355239B24152820CFC000000000000000000
+0DAC:000000001FC0202007100A88108813081408180811100EE00000000000000000
+0DAD:0000000000000000600093E08C100FC8102820284048BF900000000000000000
+0DAE:01C0024001C0004010402020401040104010401020201FC00000000000000000
+0DAF:0000000000000000000000C00120002007E00400043003D00010002000200018
+0DB0:000000000FC01020201000080C0810082008200811100EE00000000000000000
+0DB1:00000000000000E0611092088C040F04108420844124BE180000000000000000
+0DB2:00007FFE738E6DB66DB66DB6738E7FFE7FFE63866DF663866DBE63867FFE0000
+0DB3:00000000000000000380054008200BE00C000C00022001C00040008000800060
+0DB4:000000000000000000000610012803680C1810040C1803E00000000000000000
+0DB5:000000E0012000E000200620011003080C0810040C1803E00000000000000000
+0DB6:00000000000000001FE020100F081088204820482C901C600000000000000000
+0DB7:00000000000000003070488805047DC41044208421081E100000000000000000
+0DB8:0000000000001FE0201001C81A281AA8162813C8081007E00000000000000000
+0DB9:0000000000001FE0201001C81B281BE817E81008099006600000000000000000
+0DBA:000000000000000000000080014001C01040202022201DC00000000000000000
+0DBB:0000010001000200040007000880104010401040088007000000000000000000
+0DBC:00007FFE738E6DB66DB66DB6738E7FFE7FFE63C66DBE63BE6DBE63C67FFE0000
+0DBD:00000000000000000F801040272022482188201010200FC00000000000000000
+0DBE:00007FFE738E6DB66DB66DB6738E7FFE7FFE63866DBE638E6DBE63867FFE0000
+0DBF:00007FFE738E6DB66DB66DB6738E7FFE7FFE63866DBE638E6DBE63BE7FFE0000
+0DC0:00000000000000001FC02020461041100F101010082007C00000000000000000
+0DC1:00000000000000000000000027C048208E10825044A038400000000000000000
+0DC2:0000000000000C4002A00EE0102023502490231010200FC00000000000000000
+0DC3:00000000000000003080494005407D801040202022201DC00000000000000000
+0DC4:00000000000000003070488805041DC41044208421081E100000000000000000
+0DC5:000000000000000006C0092008201FE0180A17F210040FF80000000000000000
+0DC6:0000000000000000000000000EE011102008200810100C600000000000000000
+0DC7:00007FFE738E6DB66DB66DB6738E7FFE7FFE71866FF66FEE6FDE71DE7FFE0000
+0DC8:00007FFE738E6DB66DB66DB6738E7FFE7FFE71CE6FB66FCE6FB671CE7FFE0000
+0DC9:00007FFE738E6DB66DB66DB6738E7FFE7FFE71CE6FB66FC66FF671CE7FFE0000
+0DCA:000E0009000E0008000800080008000000000000000000000000000000000000
+0DCB:00007FFE738E6DB66DB66DB6738E7FFE7FFE718E6FB66F8E6FB6718E7FFE0000
+0DCC:00007FFE738E6DB66DB66DB6738E7FFE7FFE71C66FBE6FBE6FBE71C67FFE0000
+0DCD:00007FFE738E6DB66DB66DB6738E7FFE7FFE718E6FB66FB66FB6718E7FFE0000
+0DCE:00007FFE738E6DB66DB66DB6738E7FFE7FFE71866FBE6F8E6FBE71867FFE0000
+0DCF:0000000000000000000000000006000900010001000900060000000000000000
+0DD0:0000000000000000003E00020004000400040004000400040004000300000000
+0DD1:000000000000000000000000000E000200040002000400040004000300000000
+0DD2:07F0080808080410000000000000000000000000000000000000000000000000
+0DD3:07F0084808480430000000000000000000000000000000000000000000000000
+0DD4:00000000000000000000000000000000000000000000000000000C1010100FF0
+0DD5:00007FFE738E6DB66DB66DB6738E7FFE7FFE63866DBE6D866DF663867FFE0000
+0DD6:00000000000000000000000000000000000000000000000000000C1010D00F30
+0DD7:00007FFE738E6DB66DB66DB6738E7FFE7FFE63866DF66DEE6DDE63DE7FFE0000
+0DD8:0000000000000000000000000006000900010007000900060001000000000000
+0DD9:00000000000000004000A000900090008000E000E000E0000000000000000000
+0DDA:000E0009000E00084008A008900890008000E000E000E0000000000000000000
+0DDB:00000000000000004800B400900090009000FC00FC00FC000000000000000000
+0DDC:00000000000000004000A000900690098001E001E009E0060000000000000000
+0DDD:000E0009000E00084008A008900E90098001E001E009E0060000000000000000
+0DDE:00000000000000004004A008900A900D8001E001E009E0060000000000000000
+0DDF:000000000000000000040008000A000D00010001000900060000000000000000
+0DE0:00007FFE738E6DB66DB66DB6738E7FFE7FFE61CE6FB663B66FB661CE7FFE0000
+0DE1:00007FFE738E6DB66DB66DB6738E7FFE7FFE61EE6FCE63EE6FEE61C67FFE0000
+0DE2:00007FFE738E6DB66DB66DB6738E7FFE7FFE61866FF663866FBE61867FFE0000
+0DE3:00007FFE738E6DB66DB66DB6738E7FFE7FFE618E6FF663C66FF6618E7FFE0000
+0DE4:00007FFE738E6DB66DB66DB6738E7FFE7FFE61B66FB663866FF661F67FFE0000
+0DE5:00007FFE738E6DB66DB66DB6738E7FFE7FFE61866FBE63866FF661867FFE0000
+0DE6:0000000007000880108010800FE00090009001E0008000800080008000800080
+0DE7:00000000000000001FC02020479049504950465020901F100000000000000000
+0DE8:00000000000000001F8C20524F2252A252A24CA221241E280000000000000000
+0DE9:00000000000000003E2C41529C92AA92AA92929244A238AC0000000000000000
+0DEA:0008001008201C702AA83298044018302008200810100FE00000000000000000
+0DEB:0000010003800540064000800300040004100260018000800080007000000000
+0DEC:0000000000000000000000000EE011102C7C228A12920C600000000000000000
+0DED:00000000000000000FE0102012400C4000400080008000840084007800000000
+0DEE:0000004000800100020004C00920121010101010082007C00000000000000000
+0DEF:07E00890086004001F8C20524F2252A252A24CA221241E280000000000000000
+0DF0:00007FFE738E6DB66DB66DB6738E7FFE7FFE61CE6FB663B66FB66FCE7FFE0000
+0DF1:00007FFE738E6DB66DB66DB6738E7FFE7FFE61EE6FCE63EE6FEE6FC67FFE0000
+0DF2:0000000000000000000000000012002D0009001B002D00120000000000000000
+0DF3:000000000000000000040008000A000D00010005000B00060000000000000000
+0DF4:0000000000000000000000000AA04AA4555425485014C0060000000000000000
+0DF5:00007FFE738E6DB66DB66DB6738E7FFE7FFE61866FBE63866FF66F867FFE0000
+0DF6:00007FFE738E6DB66DB66DB6738E7FFE7FFE61CE6FBE638E6FB66FCE7FFE0000
+0DF7:00007FFE738E6DB66DB66DB6738E7FFE7FFE61866FF663EE6FDE6FDE7FFE0000
+0DF8:00007FFE738E6DB66DB66DB6738E7FFE7FFE61CE6FB663CE6FB66FCE7FFE0000
+0DF9:00007FFE738E6DB66DB66DB6738E7FFE7FFE61CE6FB663C66FF66FCE7FFE0000
+0DFA:00007FFE738E6DB66DB66DB6738E7FFE7FFE61866FB663866FB66FB67FFE0000
+0DFB:00007FFE738E6DB66DB66DB6738E7FFE7FFE618E6FB6638E6FB66F8E7FFE0000
+0DFC:00007FFE738E6DB66DB66DB6738E7FFE7FFE61C66FBE63BE6FBE6FC67FFE0000
+0DFD:00007FFE738E6DB66DB66DB6738E7FFE7FFE618E6FB663B66FB66F8E7FFE0000
+0DFE:00007FFE738E6DB66DB66DB6738E7FFE7FFE61866FBE638E6FBE6F867FFE0000
+0DFF:00007FFE738E6DB66DB66DB6738E7FFE7FFE61866FBE638E6FBE6FBE7FFE0000
+0E00:00007FFE73866DBE6D8E6DBE73867FFE7FFE73CE6DB66DB66DB673CE7FFE0000
+0E01:0000000000003C426222222222220000
+0E02:00000000000064642444444444380000
+0E03:000000000000527212222222221C0000
+0E04:0000000000003C42425A7A6242420000
+0E05:000000000000344A425A7A6242420000
+0E06:000000000000527212222222726C0000
+0E07:0000000000000C0C04044424140C0000
+0E08:0000000000003C42021A1A0A0A0C0000
+0E09:0000000000003844046464242E360000
+0E0A:000000000002323412222222221C0000
+0E0B:000000000002527412222222221C0000
+0E0C:0000000000003945254545456F6D0000
+0E0D:000000000000324A2A4A4A4A6E620E00
+0E0E:0000000000003C4262222222667A1600
+0E0F:0000000000003C42622222226A6E1A00
+0E10:0000000000001E201C021A1A06022A16
+0E11:000000000000547A1222222222220000
+0E12:0000000000002955457575556F4D0000
+0E13:000000000000324A2A4A4A4A6F6B0000
+0E14:0000000000003C42425A5A4A72420000
+0E15:000000000000344A425A5A4A72420000
+0E16:0000000000003C426222222232320000
+0E17:000000000000646A3222222222220000
+0E18:0000000000003C407824242424180000
+0E19:0000000000006464244444444E360000
+0E1A:000000000000323212222222221C0000
+0E1B:000000000002023232122222221C0000
+0E1C:00000000000069694949494949360000
+0E1D:00000000000101696949494949360000
+0E1E:00000000000069692949494949360000
+0E1F:00000000000101696929494949360000
+0E20:0000000000003C426222222262620000
+0E21:000000000000626222222222726C0000
+0E22:000000000000626242324242423C0000
+0E23:0000000000003C40780404040C0C0000
+0E24:0000000000003C426222222232320200
+0E25:0000000000003C42021A262232320000
+0E26:0000000000003C426222222262620200
+0E27:0000000000003844040404040C0C0000
+0E28:000000000002023C425A7A6242420000
+0E29:0000000000006262222A2F22221C0000
+0E2A:0000000000033C42021A262232320000
+0E2B:0000000000006666242A322222220000
+0E2C:000000000001016A6929494949360000
+0E2D:0000000000003C4202626242427E0000
+0E2E:0000000000033C7A02626242427E0000
+0E2F:0000000000006C740404040404040000
+0E30:00000000000000343800343800000000
+0E31:000000313E0000000000000000000000
+0E32:00000000000038440404040404040000
+0E33:0000006060001C220202020202020000
+0E34:0000003C420000000000000000000000
+0E35:0000003A460000000000000000000000
+0E36:0000003E460000000000000000000000
+0E37:0000003A4E0000000000000000000000
+0E38:00000000000000000000000000000602
+0E39:00000000000000000000000000001A0E
+0E3A:00000000000000000000000000000C0C
+0E3B:00007FFE73866DBE6D8E6DBE73867FFE7FFE638E7DB6718E7DB6638E7FFE0000
+0E3C:00007FFE73866DBE6D8E6DBE73867FFE7FFE63C67DBE71BE7DBE63C67FFE0000
+0E3D:00007FFE73866DBE6D8E6DBE73867FFE7FFE638E7DB671B67DB6638E7FFE0000
+0E3E:00007FFE73866DBE6D8E6DBE73867FFE7FFE63867DBE718E7DBE63867FFE0000
+0E3F:00000000087C2A2A2A3C2A2A2A7C0800
+0E40:00000000000010101010101018180000
+0E41:00000000000024242424242436360000
+0E42:0000003E417C04040404040406060000
+0E43:00000038445434040404040406060000
+0E44:0000006C140404040404040406060000
+0E45:00000000000038440404040404040404
+0E46:0000000000006C720202020202020408
+0E47:023C40546C0000000000000000000000
+0E48:04040400000000000000000000000000
+0E49:18091E00000000000000000000000000
+0E4A:28556600000000000000000000000000
+0E4B:040E0400000000000000000000000000
+0E4C:010E0C00000000000000000000000000
+0E4D:00060600000000000000000000000000
+0E4E:030406080C0000000000000000000000
+0E4F:00000000000000003C425A5A423C0000
+0E50:000000000000003C42424242423C0000
+0E51:000000000000003C42425A3A023C0000
+0E52:000000000040404A56525A5A423C0000
+0E53:00000000000000344A4A4A4272720000
+0E54:000000000002023C40404C4C483E0000
+0E55:00000000001A163C40404C4C483E0000
+0E56:000000000000402C12020232323C0000
+0E57:000000000002022A5A4A4A4A6A6C0000
+0E58:000000000000033C40404656526E0000
+0E59:000000000002021A3450484864640000
+0E5A:0000000000006D750505050505050000
+0E5B:0000000000000000000000001800240040004000400242A22552180C00000000
+0E5C:00007FFE73866DBE6D8E6DBE73867FFE7FFE61C66FBE61BE7DBE61C67FFE0000
+0E5D:00007FFE73866DBE6D8E6DBE73867FFE7FFE618E6FB661B67DB6618E7FFE0000
+0E5E:00007FFE73866DBE6D8E6DBE73867FFE7FFE61866FBE618E7DBE61867FFE0000
+0E5F:00007FFE73866DBE6D8E6DBE73867FFE7FFE61866FBE618E7DBE61BE7FFE0000
+0E60:00007FFE73866DBE6D8E6DBE73867FFE7FFE73CE6FB663B66DB673CE7FFE0000
+0E61:00007FFE73866DBE6D8E6DBE73867FFE7FFE73EE6FCE63EE6DEE73C67FFE0000
+0E62:00007FFE73866DBE6D8E6DBE73867FFE7FFE73866FF663866DBE73867FFE0000
+0E63:00007FFE73866DBE6D8E6DBE73867FFE7FFE738E6FF663C66DF6738E7FFE0000
+0E64:00007FFE73866DBE6D8E6DBE73867FFE7FFE73B66FB663866DF673F67FFE0000
+0E65:00007FFE73866DBE6D8E6DBE73867FFE7FFE73866FBE63866DF673867FFE0000
+0E66:00007FFE73866DBE6D8E6DBE73867FFE7FFE73CE6FBE638E6DB673CE7FFE0000
+0E67:00007FFE73866DBE6D8E6DBE73867FFE7FFE73866FF663EE6DDE73DE7FFE0000
+0E68:00007FFE73866DBE6D8E6DBE73867FFE7FFE73CE6FB663CE6DB673CE7FFE0000
+0E69:00007FFE73866DBE6D8E6DBE73867FFE7FFE73CE6FB663C66DF673CE7FFE0000
+0E6A:00007FFE73866DBE6D8E6DBE73867FFE7FFE73866FB663866DB673B67FFE0000
+0E6B:00007FFE73866DBE6D8E6DBE73867FFE7FFE738E6FB6638E6DB6738E7FFE0000
+0E6C:00007FFE73866DBE6D8E6DBE73867FFE7FFE73C66FBE63BE6DBE73C67FFE0000
+0E6D:00007FFE73866DBE6D8E6DBE73867FFE7FFE738E6FB663B66DB6738E7FFE0000
+0E6E:00007FFE73866DBE6D8E6DBE73867FFE7FFE73866FBE638E6DBE73867FFE0000
+0E6F:00007FFE73866DBE6D8E6DBE73867FFE7FFE73866FBE638E6DBE73BE7FFE0000
+0E70:00007FFE73866DBE6D8E6DBE73867FFE7FFE61CE7DB67BB677B677CE7FFE0000
+0E71:00007FFE73866DBE6D8E6DBE73867FFE7FFE61EE7DCE7BEE77EE77C67FFE0000
+0E72:00007FFE73866DBE6D8E6DBE73867FFE7FFE61867DF67B8677BE77867FFE0000
+0E73:00007FFE73866DBE6D8E6DBE73867FFE7FFE618E7DF67BC677F6778E7FFE0000
+0E74:00007FFE73866DBE6D8E6DBE73867FFE7FFE61B67DB67B8677F677F67FFE0000
+0E75:00007FFE73866DBE6D8E6DBE73867FFE7FFE61867DBE7B8677F677867FFE0000
+0E76:00007FFE73866DBE6D8E6DBE73867FFE7FFE61CE7DBE7B8E77B677CE7FFE0000
+0E77:00007FFE73866DBE6D8E6DBE73867FFE7FFE61867DF67BEE77DE77DE7FFE0000
+0E78:00007FFE73866DBE6D8E6DBE73867FFE7FFE61CE7DB67BCE77B677CE7FFE0000
+0E79:00007FFE73866DBE6D8E6DBE73867FFE7FFE61CE7DB67BC677F677CE7FFE0000
+0E7A:00007FFE73866DBE6D8E6DBE73867FFE7FFE61867DB67B8677B677B67FFE0000
+0E7B:00007FFE73866DBE6D8E6DBE73867FFE7FFE618E7DB67B8E77B6778E7FFE0000
+0E7C:00007FFE73866DBE6D8E6DBE73867FFE7FFE61C67DBE7BBE77BE77C67FFE0000
+0E7D:00007FFE73866DBE6D8E6DBE73867FFE7FFE618E7DB67BB677B6778E7FFE0000
+0E7E:00007FFE73866DBE6D8E6DBE73867FFE7FFE61867DBE7B8E77BE77867FFE0000
+0E7F:00007FFE73866DBE6D8E6DBE73867FFE7FFE61867DBE7B8E77BE77BE7FFE0000
+0E80:00007FFE73866DBE6D8E6DBE73867FFE7FFE73CE6DB673B66DB673CE7FFE0000
+0E81:0000000000005C222222222222620000
+0E82:0000000000003C420418204C52220000
+0E83:00007FFE73866DBE6D8E6DBE73867FFE7FFE738E6DF673C66DF6738E7FFE0000
+0E84:0000000000003C424232424242320000
+0E85:00007FFE73866DBE6D8E6DBE73867FFE7FFE73866DBE73866DF673867FFE0000
+0E86:00000000000052AA8A12224A4A340000
+0E87:000000000000182C1404040404040438
+0E88:0000000000003C42021A260202020000
+0E89:0000000000003C4202622222225C0000
+0E8A:0000000000003C42640810204C720202
+0E8B:00007FFE73866DBE6D8E6DBE73867FFE7FFE738E6DB6738E6DB6738E7FFE0000
+0E8C:000000000000344A620418204C720202
+0E8D:000000000000324242324242423C0000
+0E8E:000000000000629292529292925C0000
+0E8F:0000000000003242423242425A240000
+0E90:0000000000003C424242422252220202
+0E91:000000000000A4EAAA2A4A4A4A320000
+0E92:00000000000052AAAA8A8A8A8A540000
+0E93:000000000000344A4A4A4A4A4A2A0000
+0E94:0000000000003C424242424252220000
+0E95:000000000000245A4242424242220000
+0E96:0000000000005C222222222222320202
+0E97:0000000000008C525252525252220000
+0E98:0000000000003E407C0262425A240000
+0E99:000000000000225222222222225C0000
+0E9A:000000000000225222424242423C0000
+0E9B:000002020202225222424242423C0000
+0E9C:000000000001668682828292926C0000
+0E9D:000002020202628282828292926C0000
+0E9E:00000000000042A242828292926C0000
+0E9F:00000202020242A242828292926C0000
+0EA0:0000000000006C925212121212320000
+0EA1:000000000000222222222222225C0000
+0EA2:000002020202324242224242423C0000
+0EA3:0000000000003C42403C0262423C0000
+0EA4:00007FFE73866DBE6D8E6DBE73867FFE7FFE61B66DB661866DF66DF67FFE0000
+0EA5:0000000000003C42020202324A240000
+0EA6:00007FFE73866DBE6D8E6DBE73867FFE7FFE61CE6DBE618E6DB66DCE7FFE0000
+0EA7:0000000000003C4202020242423C0000
+0EA8:00000000000038555E44344444340000
+0EA9:00000000000024542444555E44380000
+0EAA:0000000000003A44467A02324A440000
+0EAB:00000000000096494949494949310000
+0EAC:000000000000324C403C424252340000
+0EAD:0000000000003C4242463A0244380000
+0EAE:000000000000324C403C0262423C0000
+0EAF:00000000000022261A02040408081010
+0EB0:00000000000022523C0022523C000000
+0EB1:000000627C0000000000000000000000
+0EB2:00000000000018241404040404040000
+0EB3:000040A040000C120A02020202020000
+0EB4:00000038440000000000000000000000
+0EB5:0000003C460000000000000000000000
+0EB6:00000038540000000000000000000000
+0EB7:0000003C560000000000000000000000
+0EB8:00000000000000000000000000001808
+0EB9:00000000000000000000000000001A0C
+0EBA:00000000000000000000000000000010
+0EBB:0000007C620000000000000000000000
+0EBC:0000000000000000000000000000324C
+0EBD:0000000000003A241804040404644438
+0EBE:00007FFE73866DBE6D8E6DBE73867FFE7FFE63866DBE638E6DBE63867FFE0000
+0EBF:00007FFE73866DBE6D8E6DBE73867FFE7FFE63866DBE638E6DBE63BE7FFE0000
+0EC0:0000000000000C101010101018180000
+0EC1:000000000000668888888888CCCC0000
+0EC2:0000304C221804040404040406060000
+0EC3:00003844543404040404040406060000
+0EC4:0000804C340404040404040406060000
+0EC5:00007FFE73866DBE6D8E6DBE73867FFE7FFE71866FBE6F866FF671867FFE0000
+0EC6:0000000000006C525222020202020408
+0EC7:00007FFE73866DBE6D8E6DBE73867FFE7FFE71866FF66FEE6FDE71DE7FFE0000
+0EC8:10101000000000000000000000000000
+0EC9:32143800000000000000000000000000
+0ECA:29560000000000000000000000000000
+0ECB:081C0800000000000000000000000000
+0ECC:021C1800000000000000000000000000
+0ECD:00000814080000000000000000000000
+0ECE:00007FFE73866DBE6D8E6DBE73867FFE7FFE71866FBE6F8E6FBE71867FFE0000
+0ECF:00007FFE73866DBE6D8E6DBE73867FFE7FFE71866FBE6F8E6FBE71BE7FFE0000
+0ED0:0000000000003C4242424242423C0000
+0ED1:0000000000003C42425A3A0204380000
+0ED2:000004040408102040404046423C0000
+0ED3:00001028140A442222222222225C0000
+0ED4:000002020408102040404C4C483E0000
+0ED5:0000020A1408102040404C4C483E0000
+0ED6:00001028140A244242425252522C0000
+0ED7:0000000000005C222222222222620202
+0ED8:0000000000002C52524242260A142C30
+0ED9:000000000000324A4A4A4A4A4A240000
+0EDA:00007FFE73866DBE6D8E6DBE73867FFE7FFE63866DB66D866DB663B67FFE0000
+0EDB:00007FFE73866DBE6D8E6DBE73867FFE7FFE638E6DB66D8E6DB6638E7FFE0000
+0EDC:00000000000099555555555555260000
+0EDD:0000000000009955555555555D2E0000
+0EDE:000000000000B8444444555E44C40000
+0EDF:00000000000064848464959E84780000
+0EE0:00007FFE73866DBE6D8E6DBE73867FFE7FFE61CE6FB663B66FB661CE7FFE0000
+0EE1:00007FFE73866DBE6D8E6DBE73867FFE7FFE61EE6FCE63EE6FEE61C67FFE0000
+0EE2:00007FFE73866DBE6D8E6DBE73867FFE7FFE61866FF663866FBE61867FFE0000
+0EE3:00007FFE73866DBE6D8E6DBE73867FFE7FFE618E6FF663C66FF6618E7FFE0000
+0EE4:00007FFE73866DBE6D8E6DBE73867FFE7FFE61B66FB663866FF661F67FFE0000
+0EE5:00007FFE73866DBE6D8E6DBE73867FFE7FFE61866FBE63866FF661867FFE0000
+0EE6:00007FFE73866DBE6D8E6DBE73867FFE7FFE61CE6FBE638E6FB661CE7FFE0000
+0EE7:00007FFE73866DBE6D8E6DBE73867FFE7FFE61866FF663EE6FDE61DE7FFE0000
+0EE8:00007FFE73866DBE6D8E6DBE73867FFE7FFE61CE6FB663CE6FB661CE7FFE0000
+0EE9:00007FFE73866DBE6D8E6DBE73867FFE7FFE61CE6FB663C66FF661CE7FFE0000
+0EEA:00007FFE73866DBE6D8E6DBE73867FFE7FFE61866FB663866FB661B67FFE0000
+0EEB:00007FFE73866DBE6D8E6DBE73867FFE7FFE618E6FB6638E6FB6618E7FFE0000
+0EEC:00007FFE73866DBE6D8E6DBE73867FFE7FFE61C66FBE63BE6FBE61C67FFE0000
+0EED:00007FFE73866DBE6D8E6DBE73867FFE7FFE618E6FB663B66FB6618E7FFE0000
+0EEE:00007FFE73866DBE6D8E6DBE73867FFE7FFE61866FBE638E6FBE61867FFE0000
+0EEF:00007FFE73866DBE6D8E6DBE73867FFE7FFE61866FBE638E6FBE61BE7FFE0000
+0EF0:00007FFE73866DBE6D8E6DBE73867FFE7FFE61CE6FB663B66FB66FCE7FFE0000
+0EF1:00007FFE73866DBE6D8E6DBE73867FFE7FFE61EE6FCE63EE6FEE6FC67FFE0000
+0EF2:00007FFE73866DBE6D8E6DBE73867FFE7FFE61866FF663866FBE6F867FFE0000
+0EF3:00007FFE73866DBE6D8E6DBE73867FFE7FFE618E6FF663C66FF66F8E7FFE0000
+0EF4:00007FFE73866DBE6D8E6DBE73867FFE7FFE61B66FB663866FF66FF67FFE0000
+0EF5:00007FFE73866DBE6D8E6DBE73867FFE7FFE61866FBE63866FF66F867FFE0000
+0EF6:00007FFE73866DBE6D8E6DBE73867FFE7FFE61CE6FBE638E6FB66FCE7FFE0000
+0EF7:00007FFE73866DBE6D8E6DBE73867FFE7FFE61866FF663EE6FDE6FDE7FFE0000
+0EF8:00007FFE73866DBE6D8E6DBE73867FFE7FFE61CE6FB663CE6FB66FCE7FFE0000
+0EF9:00007FFE73866DBE6D8E6DBE73867FFE7FFE61CE6FB663C66FF66FCE7FFE0000
+0EFA:00007FFE73866DBE6D8E6DBE73867FFE7FFE61866FB663866FB66FB67FFE0000
+0EFB:00007FFE73866DBE6D8E6DBE73867FFE7FFE618E6FB6638E6FB66F8E7FFE0000
+0EFC:00007FFE73866DBE6D8E6DBE73867FFE7FFE61C66FBE63BE6FBE6FC67FFE0000
+0EFD:00007FFE73866DBE6D8E6DBE73867FFE7FFE618E6FB663B66FB66F8E7FFE0000
+0EFE:00007FFE73866DBE6D8E6DBE73867FFE7FFE61866FBE638E6FBE6F867FFE0000
+0EFF:00007FFE73866DBE6D8E6DBE73867FFE7FFE61866FBE638E6FBE6FBE7FFE0000
+0F00:18671C5D4955534B3901000000000000
+0F01:0000005C4854524A3901000000000000
+0F02:1000100018004430BA487C487830840088309C48224802300600610012000C00
+0F03:1000100018004430BA487C487830840088789C00223002480648613012000C00
+0F04:0000000006C1314E310E000000000000
+0F05:000000000C02621C621C000000000000
+0F06:0000000006C1314E310E000C04040404
+0F07:000000000815C4390000000000000000
+0F08:0000324C006C10381010101010100000
+0F09:0000001E2101020E110E110100000000
+0F0A:000F304E5141424E514E5140310F0000
+0F0B:00000018180000000000000000000000
+0F0C:00000018180000000000000000000000
+0F0D:00000018180808080808080808080000
+0F0E:00000036361212121212121212120000
+0F0F:00000018180018080808080808080000
+0F10:00000018001800180808080808080000
+0F11:00000066001800180808080808080000
+0F12:0814493E0077001A2C08080808080800
+0F13:00000000180018A5A518001800000000
+0F14:00000018242418003C00182424180000
+0F15:00FFE781A581FFB18DE3130905030301
+0F16:00027F827F8260027FFE7FFE01827F827F8200027FFE00827FFE40027FFE0002
+0F17:001100890449224A1252129413FC57145814582457C4500837F0180010000000
+0F18:0000000000000000000200010019002500260018019002600240018009000600
+0F19:00000000000000000018080808080800
+0F1A:00000000000018242418000000000000
+0F1B:00000000000022555522000000000000
+0F1C:00000000081414082255552200000000
+0F1D:00000000000000140814000000000000
+0F1E:00000000000000552255000000000000
+0F1F:00000000000000255225000000000000
+0F20:0000000E112121221C00000000000000
+0F21:000000060B1101020408000000000000
+0F22:0000001E2101020E1101000000000000
+0F23:0000001E21020E01021E210000000000
+0F24:00000000122C40417E00000000000000
+0F25:0000002244443C040201000000000000
+0F26:0000004044282711110E000000000000
+0F27:0000000101314A123C00000000000000
+0F28:00000008102070080402010100000000
+0F29:0000001C2224494E4040000000000000
+0F2A:0000000C16220F740810000000000000
+0F2B:0000003C420F741C2202000000000000
+0F2C:0000003C42041F72043C420000000000
+0F2D:00000000122C46497E20400000000000
+0F2E:000000224E553C440201000000000000
+0F2F:00000040452A2719112E400000000000
+0F30:0000000101314F723C00000000000000
+0F31:000000081020720D3442010100000000
+0F32:0000031D2A34694E4040000000000000
+0F33:0000001D22464A543840000000000000
+0F34:00000000181800101C04101C04000000
+0F35:00000000000000000000000010552A1C
+0F36:00000000181800666600181800000000
+0F37:00000000000000000000000018242418
+0F38:334A525C000000000000000000000000
+0F39:07040200000000000000000000000000
+0F3A:000000000000008009401490C428389001400080000000000000000000000000
+0F3B:0000000000000200052012502846123805000200000000000000000000000000
+0F3C:00000202040808182020202020204000
+0F3D:000020201008080C0202020202020100
+0F3E:00000000000000000C02020202020201
+0F3F:00000000000000003040404040404080
+0F40:0000003F156505010101000000000000
+0F41:0000003F494D4B414100000000000000
+0F42:0000003F496959090101000000000000
+0F43:0000003F496959091F204E3111010000
+0F44:0000001E204078440201000000000000
+0F45:0000003E08084E31110E000000000000
+0F46:0000003E08083E494936000000000000
+0F47:0000001E203C407C4201000000000000
+0F48:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE6DCE6DB661CE7DB67DCE7FFE0000
+0F49:00000038444E11110101020000000000
+0F4A:0000007F013D43414040000000000000
+0F4B:0000003F213A2C222F30200000000000
+0F4C:0000003C02011F214040400000000000
+0F4D:0000003C02011F205E604E3111010000
+0F4E:0000003F081C12322C20200000000000
+0F4F:0000007F405E61410101000000000000
+0F50:0000003F21170D113D03010000000000
+0F51:0000001E20407C420101010000000000
+0F52:0000001E20407C421F204E3111010000
+0F53:0000003F040E12130D01010000000000
+0F54:0000003321417D430101000000000000
+0F55:0000003323457D430101000000000000
+0F56:0000001F21417D430101000000000000
+0F57:0000001F21417D431F204E3111010000
+0F58:0000007D09314D4B3101000000000000
+0F59:0001013E08084E31110E000000000000
+0F5A:0001013E08083E494936000000000000
+0F5B:0001011E2038407C4201000000000000
+0F5C:0001011E2038407C421F204E31110100
+0F5D:00000031494F09111D13010000000000
+0F5E:0000001C224C52534D21010000000000
+0F5F:0000003F011F013D0301000000000000
+0F60:000000384444481C0201000000000000
+0F61:0000006B494949350301000000000000
+0F62:0000003E081C02010100000000000000
+0F63:0000003945490D030100000000000000
+0F64:0000000F11114F311101010000000000
+0F65:0000003C22223D232220200000000000
+0F66:0000007B112965030100000000000000
+0F67:0000001E204E31110101000000000000
+0F68:0000005D4955534B3101000000000000
+0F69:0000003F156505013925243D22242000
+0F6A:0000007C083844020202000000000000
+0F6B:0000007E545350404040000000000000
+0F6C:0000001F080E11202020000000000000
+0F6D:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE738E6FB663B66DB6738E7FFE0000
+0F6E:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE73866FBE638E6DBE73867FFE0000
+0F6F:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE73866FBE638E6DBE73BE7FFE0000
+0F70:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE61CE7DB67BB677B677CE7FFE0000
+0F71:00000000000000000000182804000000
+0F72:70480400000000000000000000000000
+0F73:7048040000000000003F4242041C2202
+0F74:0000000000000000000000000040241C
+0F75:00000000000000003E4242040C42221C
+0F76:704804000000000000720A0602000000
+0F77:70480400000000027A063F42041C2200
+0F78:70480400000000000000000022525E02
+0F79:70480400000000325E023F42041C2200
+0F7A:E0180400000000000000000000000000
+0F7B:CC220000000000000000000000000000
+0F7C:CF281000000000000000000000000000
+0F7D:45EE1000000000000000000000000000
+0F7E:10281000000000000000000000000000
+0F7F:00000018242418001824241800000000
+0F80:1C244000000000000000000000000000
+0F81:1C24400000000000003F4242041C2202
+0F82:08080C225D3F00000000000000000000
+0F83:0814493E000000000000000000000000
+0F84:00000000000000000004060203010101
+0F85:0000000000384444081C12120A020201
+0F86:10101024180000000000000000000000
+0F87:10101010101000000000000000000000
+0F88:00003F800A0004000A003F800000000000000000000000000000000000000000
+0F89:00364900000000000000000000000000
+0F8A:0000000000000000EEAAAAAABA000000
+0F8B:000000000000000001023A4A4A2E0000
+0F8C:00493600000000000000000000000000
+0F8D:0000000000000000007F22140814227F
+0F8E:00000000000000000000000000364900
+0F8F:00000000000000000000000000493600
+0F90:000000000000003F1525010000000000
+0F91:00000000000000003F494D4B41000000
+0F92:000000000000003F4979090000000000
+0F93:000000000000003F4979011E204E3111
+0F94:00000000000000001E207C4201000000
+0F95:00000000000000003E084E310E000000
+0F96:00000000000000003E083E4936000000
+0F97:00000000000000001E2038407E410000
+0F98:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE73CE6DB671CE7DB673CE7FFE0000
+0F99:000000000000000038440E1101020000
+0F9A:00000000000000007F013D4341400000
+0F9B:00000000000000007E4478447E400000
+0F9C:00000000000000003C021F2140400000
+0F9D:00000000000000003C021F207E510100
+0F9E:0000000000001E081C324C4000000000
+0F9F:00000000000000007F405E6141010000
+0FA0:00000000000000003F110F113F010000
+0FA1:00000000000000001E207C4201010000
+0FA2:00000000000000001E207C421F204E31
+0FA3:0000000000003C081C26190100000000
+0FA4:0000000000000033217D030100000000
+0FA5:0000000000000027497D030100000000
+0FA6:000000000000001F217D030100000000
+0FA7:000000000000001F217D031F204E3111
+0FA8:0000000000000079314D330100000000
+0FA9:00000000003C0A094C32120C00000000
+0FAA:00000000000000003E093E4949360000
+0FAB:00000000001C2239417C420000000000
+0FAC:00000000001C2239417C421E204E3111
+0FAD:00000000000000000000000001030503
+0FAE:00000000000000001C224C534D210100
+0FAF:00000000000000003F011F013F010000
+0FB0:00000000000000003844481C02010000
+0FB1:0000000000000000010101121C090600
+0FB2:00000000000000000101013945030100
+0FB3:00000000000000003945491D03010000
+0FB4:000000000000000007092F1109010100
+0FB5:000000000000000038243D2224202000
+0FB6:00000000000000007B29456301000000
+0FB7:00000000000000001E204E3111010000
+0FB8:00000000000000005D49555331010000
+0FB9:000000000000003F15650539243D2220
+0FBA:000000000000000031494F091D030100
+0FBB:00000000000000006B49493503010000
+0FBC:00000000000000003E081C0201010000
+0FBD:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE638E6DB663B66DB6638E7FFE0000
+0FBE:00000000004122140814224100000000
+0FBF:00000000004922144914224900000000
+0FC0:00000000001C224141221C0000000000
+0FC1:000000000000001C22221C0000000000
+0FC2:000000001C021A242458403800000000
+0FC3:000000001C224955492A1C0000000000
+0FC4:0000006B14081C2222223E417F000000
+0FC5:0D600280010003800C601930145022882108155011100D600380010002800D60
+0FC6:00000000000000000000000000000000000045442AA82AA812900FE015502548
+0FC7:0D600280010003808C6299325454A28AA10A555491128D620380010002800D60
+0FC8:00000D60028001003FF824481290129009200920044004400280028001000000
+0FC9:0000000003800440092014501390282827C8200820081010183007C000000000
+0FCA:000007C008203018200840049E06A126C106C90AC0F2400420083018082007C0
+0FCB:000007C0082030183C0C424C810A911281E281028202424422083218092007C0
+0FCC:000007C00820303821287C2482428182892283028482487C29083818082007C0
+0FCD:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE718E6FB66FB66FB6718E7FFE0000
+0FCE:00000000000000522552000000000000
+0FCF:00000000001408140055225500000000
+0FD0:000000001F00208040440F381080008001000700088000000000000000000000
+0FD1:003C4202041C221C2218240408040200
+0FD2:000000007C38100000007C3810000000
+0FD3:0000000006C1310E0000000000000000
+0FD4:000000000C02621C0000000000000000
+0FD5:0000000041FC410041004100410041007FFC010401040104010401047F040000
+0FD6:000000007F04010401040104010401047FFC4100410041004100410041FC0000
+0FD7:0000000041FC410041004920410041007FFC010401040924010401047F040000
+0FD8:000000007F04010401040924010401047FFC4100410049204100410041FC0000
+0FD9:0000000000004000600040000000100218061002000002100738000000000000
+0FDA:0000000000000002000600020000400860184008000008401CE0000000000000
+0FDB:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE638E6DB66D8E6DB6638E7FFE0000
+0FDC:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE63C66DBE6DBE6DBE63C67FFE0000
+0FDD:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE638E6DB66DB66DB6638E7FFE0000
+0FDE:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE63866DBE6D8E6DBE63867FFE0000
+0FDF:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE63866DBE6D8E6DBE63BE7FFE0000
+0FE0:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE61CE6FB663B66FB661CE7FFE0000
+0FE1:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE61EE6FCE63EE6FEE61C67FFE0000
+0FE2:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE61866FF663866FBE61867FFE0000
+0FE3:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE618E6FF663C66FF6618E7FFE0000
+0FE4:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE61B66FB663866FF661F67FFE0000
+0FE5:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE61866FBE63866FF661867FFE0000
+0FE6:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE61CE6FBE638E6FB661CE7FFE0000
+0FE7:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE61866FF663EE6FDE61DE7FFE0000
+0FE8:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE61CE6FB663CE6FB661CE7FFE0000
+0FE9:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE61CE6FB663C66FF661CE7FFE0000
+0FEA:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE61866FB663866FB661B67FFE0000
+0FEB:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE618E6FB6638E6FB6618E7FFE0000
+0FEC:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE61C66FBE63BE6FBE61C67FFE0000
+0FED:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE618E6FB663B66FB6618E7FFE0000
+0FEE:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE61866FBE638E6FBE61867FFE0000
+0FEF:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE61866FBE638E6FBE61BE7FFE0000
+0FF0:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE61CE6FB663B66FB66FCE7FFE0000
+0FF1:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE61EE6FCE63EE6FEE6FC67FFE0000
+0FF2:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE61866FF663866FBE6F867FFE0000
+0FF3:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE618E6FF663C66FF66F8E7FFE0000
+0FF4:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE61B66FB663866FF66FF67FFE0000
+0FF5:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE61866FBE63866FF66F867FFE0000
+0FF6:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE61CE6FBE638E6FB66FCE7FFE0000
+0FF7:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE61866FF663EE6FDE6FDE7FFE0000
+0FF8:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE61CE6FB663CE6FB66FCE7FFE0000
+0FF9:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE61CE6FB663C66FF66FCE7FFE0000
+0FFA:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE61866FB663866FB66FB67FFE0000
+0FFB:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE618E6FB6638E6FB66F8E7FFE0000
+0FFC:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE61C66FBE63BE6FBE6FC67FFE0000
+0FFD:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE618E6FB663B66FB66F8E7FFE0000
+0FFE:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE61866FBE638E6FBE6F867FFE0000
+0FFF:00007FFE73866DBE6D8E6DBE73BE7FFE7FFE61866FBE638E6FBE6FBE7FFE0000
+1000:00000000000000000000018C02520421042104210242000C0000000000000000
+1001:0000000000000000000000780084000201F2010A008400780000000000000000
+1002:0000000000000000000000780084010201020102008400480000000000000000
+1003:00000000000000000000060C01420221042104210252018C0000000000000000
+1004:0000000000000000000000780084010001000100008400780000000000000000
+1005:0000000000000000000000780084014201420142008400780000000000000000
+1006:00000000000000000000018C02520021002103A10252018C0000000000000000
+1007:0000000000000000000000F001080214020A0200010800F00000000000000000
+1008:0000000000000000000000710089014501450145008900790009000900050002
+1009:0000000000000000000000E00110000800080008011001E001000101010100FE
+100A:00000000000000000000018C02420021002100210252038C02000201020101FE
+100B:0000000000000000000000780084010001000084007C000400F800800078000E
+100C:00000000000000000000007800840100010001000084007C000400C4010400F8
+100D:000000000000000000000078008400020002008400F80080007C000400040006
+100E:0000000000000000000001880044008201020102008400780000000000000000
+100F:0000000000000000000003760489045104510451028A00F80000000000000000
+1010:00000000000000000000018C02520421042104210242018C0000000000000000
+1011:00000000000000000000018C02520421042104210252018C0000000000000000
+1012:0000000000000000000000F00108000800300008010800F00000000000000000
+1013:000000000000000000000078008401020102017A008400780000000000000000
+1014:00000000000000000000001C00200020001C00C2012200FC0020002000000000
+1015:0000000000000000000000480084010201020102008400780000000000000000
+1016:000000000000000000000058009401120112010A008400780000000000000000
+1017:0000000000000000000000000084017A01020102008400780000000000000000
+1018:00000000000000000000018C02520021002100210242018C0000000000000000
+1019:000000000000000000000048008401020102017A008400780000000000000000
+101A:00000000000000000000000C02420421042104210252018C0000000000000000
+101B:0000000000000000000000F00108020403C40224011400F40004000400040007
+101C:00000000000000000000018C02420421042104210212018C0000000000000000
+101D:0000000000000000000000780084010201020102008400780000000000000000
+101E:00000000000000000000018C02420021002100210252018C0000000000000000
+101F:00000000000000000000000C02520421042104210242018C0000000000000000
+1020:0000000000000000000000780084010001000084007C000400F8008000840078
+1021:00000000000000000000019C0262004300850049024A018C0000000000000000
+1022:00000000000000000000018C02520421042102210142060C0000000000000000
+1023:00000000000000000000018C02520421042104210202000001DC022202240107
+1024:000600090008000400020199026504250425042502450005000507E5080507F9
+1025:0000000000000000000000F00108000400040004010801F001000100010400F8
+1026:0070008800A800D80070000000F8010800040004010801F001000100010400F8
+1027:0000000000000000000000780084017801000178008400780000000000000000
+1028:0000000000000000007800840132014A010A0112010C01000102010200840078
+1029:3FFE4001400140004000471C488240414041404148A3471D4001400140013FFE
+102A:07C608290828080408000B36288948898889B889D89A6B6808080808080807F0
+102B:0F00108010800080008000800080008000800080008000800000000000000000
+102C:0000000000000000000003E00410000800080008001001E00000000000000000
+102D:0030004800480030000000000000000000000000000000000000000000000000
+102E:0070008800A80088007000000000000000000000000000000000000000000000
+102F:0000000000000000000002000200020002000200020002000200020002000380
+1030:00000000000000000000050005000500050005000500050005000500050005C0
+1031:0000000000000000000000003000400040007000500030000000000000000000
+1032:0100008000400020000000000000000000000000000000000000000000000000
+1033:007000A800D800A8007000000000000000000000000000000000000000000000
+1034:0008001000200040000000000000000000000000000000000000000000000000
+1035:0070008000B800C8007000000000000000000000000000000000000000000000
+1036:0000000200050002000000000000000000000000000000000000000000000000
+1037:0000000000000000000000000000000000000000000000000000001000280010
+1038:0000000000000000000001000280010000000100028001000000000000000000
+1039:0000000000000000000000000000000000000000000000000000002000700020
+103A:000C001200100008000000000000000000000000000000000000000000000000
+103B:0000000000000000000004000400040004000400040084008400840064001C00
+103C:07FC0802080208000800080008000800080008000800080008000800080407F8
+103D:000000000000000000000000000000000000000000000000000800140022001C
+103E:0000000000000000000000000000000000000000000000200020002000600000
+103F:000000000000000000000124029200490049004902DA01240000000000000000
+1040:0000000000000000000003600410080808080808041003600000000000000000
+1041:0000000000000000000003C00420001000100010042003C00000000000000000
+1042:0000000000000000000000200020002000200020002000200020002008400780
+1043:0000000000000000000003C00420001000100010042003C00100008000400020
+1044:0000000000000000000003C00420080008000800042003C00080010002000400
+1045:0000000000000000000007C00A200A10041000100010001000100010042003C0
+1046:000001E002100400040004600480048004700410021001E00000000000000000
+1047:0000000000000000000007800840002000200020004000800100020002000180
+1048:0000000000000000000003C004200A1009100910052003000000000000000000
+1049:0000000000000000000001E002100410047004800480046004000400021001E0
+104A:0000000000000000000000800080008000800080008000800000000000000000
+104B:0000000000000000000002400240024002400240024002400000000000000000
+104C:0180024002000100000003C0042000100010042007C0040003E00020042003C0
+104D:000000180024002000100788084810281E28112808A807A800280628080807F0
+104E:00000000000000000000007800840100010001000084007C0004000400040004
+104F:001800240020001000080F6410942F1420142F1410940F140000000000000000
+1050:0000000000000000000000780084010201320102008400480000000000000000
+1051:0000000000000000000000480084010201320102008400780000000000000000
+1052:0000000000000000000000060088010401020102008400780000000000000000
+1053:0000000000000000000001860048008401020102008400780000000000000000
+1054:00000000000000000000007800840142013E0100008400780000000000000000
+1055:00000000000000000000007800840142013E01000092006C0000000000000000
+1056:0000000000000000000000600080004000200020084007800000000000000000
+1057:0000000000000000000000300040002000100010092006C00000000000000000
+1058:0000000000000000000000000000000000000000000000000030005000640038
+1059:000000000000000000000000000000000000000000000000006000A000CA0074
+105A:0000000000000000000000780084010001000084007800200050001000200010
+105B:0000000000000000000000E20112022A02160202011200F200120012000A0004
+105C:00000000000000000000007800840132014A0132008400780000000000000000
+105D:000000000000000000000048008401020102017A0086007A000200C2010200FC
+105E:0000000000000000000000000000000000000000000000000010003800540030
+105F:0000000000000000000000000000000000000000000000000010003000440038
+1060:0000000000000000000000000000000000000000000000000010002000400078
+1061:0000000000000000000000780084010201E20112008A007A0002000A000A001A
+1062:0000000000000000000003800080008000800080008000800000000000000000
+1063:0000000000000000000003800440002000200020044007800400040004000400
+1064:0000000000000000000007000100010001000100010001C00000000000000000
+1065:0000000000000000000000780084000200020002008400780000000000000000
+1066:0000000000000000000000480084010201020102008400780000001000100030
+1067:0000000000000000000000800080008001800280028001000000000000000000
+1068:0000010002800100000000800080008000800080008003800000000000000000
+1069:0000000000000000000001800240004001800200024001800000000000000000
+106A:0000000000000000000000800080008000800080028001000000000000000000
+106B:0000000000000000000001000280008000800080008000800000000000000000
+106C:0000000000000000000001000100010001000100014000800000000000000000
+106D:0000000000000000000001800240020001800040024001800000000000000000
+106E:0000000000000000000001B60249022902290249015200000000000000000000
+106F:00000000000000000000000C02520421042104210242018C0000000800080018
+1070:00000000000000000000060C01420221042104210252018C0000000800080018
+1071:0000008801540088000000000000000000000000000000000000000000000000
+1072:0030004800400030000000000000000000000000000000000000000000000000
+1073:0020005000880104000000000000000000000000000000000000000000000000
+1074:0000004800480030000000000000000000000000000000000000000000000000
+1075:0000000000000000000000780084010201020082004401880000000000000000
+1076:00000000000000000000013801440082000200FA008400780000000000000000
+1077:0000000000000000000000780084010A010A008A004401800000000000000000
+1078:00000000000000000000018C02520421042104210212018C0000000000000000
+1079:00000000000000000000018C02520621052104A10292018C0000000000000000
+107A:00000000000000000000018C0242042104210421023201AC0020002000200038
+107B:00000000000000000000018C0252042304250429024A018C0000000000000000
+107C:00000000000000000000018C02520020002001FC0252018C0000000000000000
+107D:00000000000000000000060C015202200420042E0252018C0000000000000000
+107E:00000000000000000000060C015202200420042E0252018C0000000800080018
+107F:00000000000000000000006800A4012201220142008400780000000000000000
+1080:00000000000000000000018C02420021002103A10252018C0000000000000000
+1081:000000000000000000000078008401020102012200A4006000200020002000E0
+1082:0000000000000000000000000000000000000000000000000020004000480030
+1083:00000000000000000000070001000100010001000100010001000100010001C0
+1084:0000000000000000000030004800400030004000480030000000000000000000
+1085:0070008800400088007000000000000000000000000000000000000000000000
+1086:0020005000300010002000000000000000000000000000000000000000000000
+1087:0000000000000000000000000000000000000100028001800080010000000000
+1088:0000000000000000000001000280010000000100028001800080010000000000
+1089:0000000000000000000000000000000000000100028001000000000000000000
+108A:0000000000000000000002000540038000000200054003800000000000000000
+108B:0000000000000000000000000000010002800100000000000000000000000000
+108C:0000000000000000000000000000022005500220000000000000000000000000
+108D:000000000000000000000000000000000000000000000000000001FE00000000
+108E:0000000000000000000000780084017A01020102008400780000000000000000
+108F:0000000000000000000001000280010000000100028003000200010000000000
+1090:0000000000000000000003C00420042004200420042003C00000000000000000
+1091:0000000000000000000003000500010001000100014001800000000000000000
+1092:0000000000000000000005C00620002000400080010001000000000000000000
+1093:0000000000000000008000800100010002000380044004400000000000000000
+1094:000000000000000000800080018001800280028004A004C00000000000000000
+1095:0000000000000000000000400040004007E00840084007800000000000000000
+1096:0000000000000000000007800840084007E00040004000400000000000000000
+1097:0000000000000000000007C00040008001000200040007C00000000000000000
+1098:0000000000000000000004200420024003C00420042003C00000000000000000
+1099:0000000000000000000003C00420042003C00240042004200000000000000000
+109A:0000000000000000000001000280010000000000000000000000000000000000
+109B:0000010002800180008001000000000000000000000000000000000000000000
+109C:0000000000000000000003800540020000000380054002000000000000000000
+109D:0000001C00220002000200020000000000000000000000000000000000000000
+109E:00000100028001000000070001000100010001000100010001000100010001C0
+109F:001800240020001000080F041084204420442044104400440044004400440038
+10A0:00000080FE22408080808082463A0000
+10A1:000000006888888898680808080E0200
+10A2:00000000F888880808080808080E0200
+10A3:0000000080FE12103844828244380000
+10A4:000000007C4444040404040404040000
+10A5:00000000F88888080E0A080808080000
+10A6:0000000080E02020202C322222221C00
+10A7:00000000305090909E92909050300000
+10A8:000000407C0404040404040404040000
+10A9:000000004040586444444C3404040000
+10AA:0000000000E0A020202C322222221C00
+10AB:00000080F80808087E8A8A8888700000
+10AC:000000047C4040407C44444444440000
+10AD:00000000708888888888888A8A740000
+10AE:00000080E222222222222222221C0000
+10AF:000000407A122222261A020202020000
+10B0:000000001010141A1292909090600000
+10B1:00000000404040404844444444380000
+10B2:000000007C4242427C404040407E0200
+10B3:00000000708888888888888C8A720000
+10B4:000000007C9292927C10101010100000
+10B5:00000000101010507C14101010100000
+10B6:000000003C4242424242424242420000
+10B7:000000002444444444444C3404040000
+10B8:00000000344444444C34044444380000
+10B9:00000000404040407C44444444440000
+10BA:000000001C22424040404042221C0408
+10BB:00000000080808083E4A4A4848300000
+10BC:000000007C4242427C40407844484040
+10BD:0000000000003844442010080442423C
+10BE:0000000044444444447C4040407C0400
+10BF:00000080FE2222141408141422224080
+10C0:00000000F090901010101212120C0000
+10C1:00000000404078444640404040400000
+10C2:00000040784402020202024244380000
+10C3:00000000344444444C34040404040000
+10C4:00000000828282824428101010100000
+10C5:000000001C12121C107C949690600000
+10C6:00007FFE7BCE73B67BB67BB671CE7FFE7FFE71CE6FBE6F8E6FB671CE7FFE0000
+10C7:0000000000001C22220408102042423C
+10C8:00007FFE7BCE73B67BB67BB671CE7FFE7FFE71CE6FB66FCE6FB671CE7FFE0000
+10C9:00007FFE7BCE73B67BB67BB671CE7FFE7FFE71CE6FB66FC66FF671CE7FFE0000
+10CA:00007FFE7BCE73B67BB67BB671CE7FFE7FFE71866FB66F866FB671B67FFE0000
+10CB:00007FFE7BCE73B67BB67BB671CE7FFE7FFE718E6FB66F8E6FB6718E7FFE0000
+10CC:00007FFE7BCE73B67BB67BB671CE7FFE7FFE71C66FBE6FBE6FBE71C67FFE0000
+10CD:000000007C04040810102020407C0000
+10CE:00007FFE7BCE73B67BB67BB671CE7FFE7FFE71866FBE6F8E6FBE71867FFE0000
+10CF:00007FFE7BCE73B67BB67BB671CE7FFE7FFE71866FBE6F8E6FBE71BE7FFE0000
+10D0:0000000000000010100C0202423C0000
+10D1:00000000203010103C424242423C0000
+10D2:000000000030484808083C424242423C
+10D3:000000000000002C525252524C201C02
+10D4:000000003C424202020202020242423C
+10D5:0000000000003C4242021C020242423C
+10D6:0000000020505054381C1212120C0000
+10D7:00000000000000344A4A4A4A4A320000
+10D8:000000000000003C4242424242240000
+10D9:0000000000000C0202021C020242423C
+10DA:000000000000002A5555554142403E01
+10DB:000000003C424202023E4242423C0000
+10DC:00000000023C4040407C4242423C0000
+10DD:00000000000000285454545444240000
+10DE:0000000020180402021C0242423C0000
+10DF:00000000000000060A5252220222221C
+10E0:00000000043840685454545444240000
+10E1:00000000404040485048444444380000
+10E2:000000001824243C66665A424242423C
+10E3:000000000000006C121202020222221C
+10E4:00000000000000344A4A4A4A3402021C
+10E5:00000000040C0404041C240404044438
+10E6:00000000000000285454544448403804
+10E7:0000000000000022424242261A42423C
+10E8:0000000028545404041C242424180000
+10E9:00000000384478405C62424242420000
+10EA:0000000000004C4242425C424242423C
+10EB:0000000004020202023E4242423C0000
+10EC:0000000028545440407C444428281010
+10ED:00000000081828080819261D04044438
+10EE:00000000404040485078444444380000
+10EF:00000000000000004224181824422040
+10F0:0000100C02120C02120C0242423C0000
+10F1:0000504C42524C42524C4242423C0000
+10F2:0000000000003C4242424224187E0000
+10F3:0000000000003E0204081C020242423C
+10F4:0000000008100C0202021C020242423C
+10F5:00000000003844443E043E4444380000
+10F6:00000000201010103854543810101008
+10F7:0000000000003C42420408102042423C
+10F8:0000000000000044424242645842423C
+10F9:00000000003C424242423C101012120C
+10FA:0000000000003C4242300C1C22400000
+10FB:00000000000060600006060060600000
+10FC:0000021C20203C22221C000000000000
+10FD:0000000000003C42422010080442423C
+10FE:00000000000000C0221C2222221C0000
+10FF:0000000000000000001C2222221C0000
+1100:000000007F800080008000800080010001000200040018006000000000000000
+1101:0000000000007B80088008800880088011001100220044000800000000000000
+1102:000020002000200020003F800000000000000000000000000000000000000000
+1103:00003F802000200020003F800000000000000000000000000000000000000000
+1104:00003B802200220022003B800000000000000000000000000000000000000000
+1105:000000003F8000803F8020003F80000000000000000000000000000000000000
+1106:00003F802080208020803F800000000000000000000000000000000000000000
+1107:0000208020803F8020803F800000000000000000000000000000000000000000
+1108:00002A802A803B802A803B800000000000000000000000000000000000000000
+1109:00000400040004000A0011000000000000000000000000000000000000000000
+110A:00001100110011002A8044400000000000000000000000000000000000000000
+110B:00000E001100110011000E000000000000000000000000000000000000000000
+110C:00003F80010002000D0030800000000000000000000000000000000000000000
+110D:000000003BC00880150022800440000000000000000000000000000000000000
+110E:0E0000003F8002000D0030800000000000000000000000000000000000000000
+110F:00003F8000803F80008000800000000000000000000000000000000000000000
+1110:00003F8020003F8020003F800000000000000000000000000000000000000000
+1111:00007F801200120012007F800000000000000000000000000000000000000000
+1112:00000E0000003F8000001F002080208020801F00000000000000000000000000
+1113:000021FC2004200420043F840000000000000000000000000000000000000000
+1114:000020402040204020403E7C0000000000000000000000000000000000000000
+1115:0000207C2040204020403E7C0000000000000000000000000000000000000000
+1116:000020442044207C20443E7C0000000000000000000000000000000000000000
+1117:00003E7C2004200420043E040000000000000000000000000000000000000000
+1118:000000003E4002403E4020403E7C000000000000000000000000000000000000
+1119:000000003E7C02043E7C20403E7C000000000000000000000000000000000000
+111A:000000003E3002FC3E3020483E30000000000000000000000000000000000000
+111B:000000001FF800081FF810001FF803C00420042003C000000000000000000000
+111C:00003E442244227C22443E7C0000000000000000000000000000000000000000
+111D:00001FFC1004100410041FFC00000000000003E004100410041003E000000000
+111E:0000227C22043E0422043E040000000000000000000000000000000000000000
+111F:0000224022403E4022403E7C0000000000000000000000000000000000000000
+1120:0000227C22403E4022403E7C0000000000000000000000000000000000000000
+1121:0000221022103E1022283E440000000000000000000000000000000000000000
+1122:0000489E4882788249427A220000000000000000000000000000000000000000
+1123:0000488E4888788849487A2E0000000000000000000000000000000000000000
+1124:000049244924793C4AA47C7C0000000000000000000000000000000000000000
+1125:000048884888788849547A220000000000000000000000000000000000000000
+1126:0000493E490479084A947C620000000000000000000000000000000000000000
+1127:0000227C22083E1022283E440000000000000000000000000000000000000000
+1128:00382200227C3E1022283E440000000000000000000000000000000000000000
+1129:0000227C22403E7C22403E7C0000000000000000000000000000000000000000
+112A:0000227C22283E2822283E7C0000000000000000000000000000000000000000
+112B:000008080FF808080FF801C0022001C000000000000000000000000000000000
+112C:000022443E7C22443E7C03C0042003C000000000000000000000000000000000
+112D:0000047C040404040A0411040000000000000000000000000000000000000000
+112E:00000440044004400A40117C0000000000000000000000000000000000000000
+112F:0000047C044004400A40117C0000000000000000000000000000000000000000
+1130:0000047C0404047C0A40117C0000000000000000000000000000000000000000
+1131:0000047C044404440A44117C0000000000000000000000000000000000000000
+1132:000004440444047C0A44117C0000000000000000000000000000000000000000
+1133:0000112E112211E2292245E20000000000000000000000000000000000000000
+1134:0000088808880888155422220000000000000000000000000000000000000000
+1135:00000438044404440A4411380000000000000000000000000000000000000000
+1136:0000047C040804100A2811440000000000000000000000000000000000000000
+1137:00380400047C04100A2811440000000000000000000000000000000000000000
+1138:0000047C0404047C0A0411040000000000000000000000000000000000000000
+1139:0000047C0440047C0A40117C0000000000000000000000000000000000000000
+113A:0000047C042804280A28117C0000000000000000000000000000000000000000
+113B:0000043004FC04300A4811300000000000000000000000000000000000000000
+113C:0000004000400180068018400000000000000000000000000000000000000000
+113D:00000120012002A0045019880000000000000000000000000000000000000000
+113E:0000008000800100068018400000000000000000000000000000000000000000
+113F:00000480048005400A30118C0000000000000000000000000000000000000000
+1140:000002000500088010403FE00000000000000000000000000000000000000000
+1141:00000E7C1104110411040E040000000000000000000000000000000000000000
+1142:00000E3C1120112011200E3C0000000000000000000000000000000000000000
+1143:00000E3E1122112211220E3E0000000000000000000000000000000000000000
+1144:00000E241124113C11240E3C0000000000000000000000000000000000000000
+1145:00000E081108110811140E220000000000000000000000000000000000000000
+1146:0000382044504488450439FC0000000000000000000000000000000000000000
+1147:00000E381144114411440E380000000000000000000000000000000000000000
+1148:00000E7C1108111011280E440000000000000000000000000000000000000000
+1149:00380E00117C111011280E440000000000000000000000000000000000000000
+114A:00000E3C1120113C11200E3C0000000000000000000000000000000000000000
+114B:00000E7C1128112811280E7C0000000000000000000000000000000000000000
+114C:00000E001100110011000E000000000000000000000000000000000000000000
+114D:00003E3804440844144422380000000000000000000000000000000000000000
+114E:00003FE000C003800C4030200000000000000000000000000000000000000000
+114F:000000001FF0012002A00C503188000000000000000000000000000000000000
+1150:00001FF0006001C0062018100000000000000000000000000000000000000000
+1151:000000003FE0084014A02310018C000000000000000000000000000000000000
+1152:1C00007C3E04087C140422040000000000000000000000000000000000000000
+1153:180000303EFC0830144822300000000000000000000000000000000000000000
+1154:078000001FC00180064038200000000000000000000000000000000000000000
+1155:0E0000003F0002000D8030700000000000000000000000000000000000000000
+1156:00003E441444147C14443E7C0000000000000000000000000000000000000000
+1157:00001FF804201FF803C0042003C0000000000000000000000000000000000000
+1158:000018307EFC1C70228822881C70000000000000000000000000000000000000
+1159:1FF0010007C00820082007C00000000000000000000000000000000000000000
+115A:00003E7C024002400240027C0000000000000000000000000000000000000000
+115B:000010101010101010281F440000000000000000000000000000000000000000
+115C:0000107C1008101010281F440000000000000000000000000000000000000000
+115D:0000107011FC107010881E700000000000000000000000000000000000000000
+115E:000000003E7C2004207C20403E7C000000000000000000000000000000000000
+115F:AAAA000180002239A2403E41A2402239800003E1820003818200020180005555
+1160:AAAA000180002279A2103E11A2502221800003E1820003818200020180005555
+1161:0000001000100010001E00100010001000000000000000000000000000000000
+1162:0000001200120012001E00120012001200000000000000000000000000000000
+1163:0000001000100010001E0010001E001000000000000000000000000000000000
+1164:0000001200120012001E0012001E001200000000000000000000000000000000
+1165:0000001000100010007000100010001000000000000000000000000000000000
+1166:0000001200120012007200120012001200000000000000000000000000000000
+1167:0000001000100010007000100070001000000000000000000000000000000000
+1168:0000001200120012007200120072001200000000000000000000000000000000
+1169:000000000000000000000000000000000000008000803FFE0000000000000000
+116A:0000001000100010001E041004103FF000000000000000000000000000000000
+116B:0000001200120012001E041204123FF200000000000000000000000000000000
+116C:00000010001000100010041004103FF000000000000000000000000000000000
+116D:00000000000000000000024002403FFE00000000000000000000000000000000
+116E:00000000000000000000000000003FFE00800080000000000000000000000000
+116F:00000010001000100010001000103F90041004F0041000000000000000000000
+1170:00000012001200120012001200123F92041204F2041200000000000000000000
+1171:00000010001000100010001000103FF004100410041000000000000000000000
+1172:00000000000000000000000000003FFE02200220000000000000000000000000
+1173:00000000000000000000000000003FFE00000000000000000000000000000000
+1174:000000100010001000100010001000100010001000103FF00010001000000000
+1175:0000001000100010001000100010001000000000000000000000000000000000
+1176:00000000000000000000002000200020003800A000A03FF80000000000000000
+1177:0000001000100010001C001000103FFE00800080000000000000000000000000
+1178:000000000000000000080008000E0008000E008800883FFE0000000000000000
+1179:00080008000E0008000E024802483FFE00000000000000000000000000000000
+117A:000000000000000800080008003800080008008800883FFE0000000000000000
+117B:00000000000400040004001C0004000400043FFE008000800000000000000000
+117C:00200020002000E000200020002000203FF00000000000000000000000000000
+117D:000000000000000000080008003800080038008800883FFE0000000000000000
+117E:00080008000800380008003800083FFE00800080000000000000000000000000
+117F:00000000000200020002000200023FFE0082008E000200000000000000000000
+1180:000000000000001200120012007200120012011201123FF20012000000000000
+1181:000000000000001200120012007200120012017201123FF20012000000000000
+1182:000000000000000000000000000000803FFE00803FFE00000000000000000000
+1183:000000000000000000000000008000803FFE00003FFE00800080000000000000
+1184:0000000000100010001E091009103FFE00100000000000000000000000000000
+1185:000000A400A400A404BC04A404FC3FA400000000000000000000000000000000
+1186:00020002000E0002000E048204823FFE00020000000000000000000000000000
+1187:0000000000000000000002203FFE00803FFE0000000000000000000000000000
+1188:00000000000200020002024202423FFE00020000000000000000000000000000
+1189:00000000000000000008000800083FFE02080208000800000000000000000000
+118A:00000000000000000012001200123FFE02120212001200000000000000000000
+118B:000000080008000800081FC80208027802083FFE000000000000000000000000
+118C:0000000A000A000A000A000A000A3FEA020A023A000A003A000A000000000000
+118D:00000000000000000000000000003FFE00803FFE008000000000000000000000
+118E:00000008000800080008000800083FFE02480248000800000000000000000000
+118F:00000001000100010001000100013FFF0221022F000100000000000000000000
+1190:00000000000A000A000A000A000A3FFA048A04BA000A00000000000000000000
+1191:00000000000200020002000200023FFE0242024E0002000E0002000000000000
+1192:00000000000A000A000A000A000A3FFA048A04BA000A003A000A000000000000
+1193:00000000000000000000000000003FFE02203FFE008000000000000000000000
+1194:00000000000100010001000100013FFF02210221000100000000000000000000
+1195:00000000000000000000000000003FFE00003FFE008000000000000000000000
+1196:00000000000000000000000000003FFE00003FFE000000000000000000000000
+1197:00040004000400040004000400040FFC00043FFE008000000000000000000000
+1198:0000004800480048004E00480048004800000000000000000000000000000000
+1199:000000480048004E0048004E0048004800000000000000000000000000000000
+119A:000000000000000400040004000400040004008400843FFE0000000000000000
+119B:00040004000400040004000400043FFE00800080000000000000000000000000
+119C:00000004000400040004000400043FFE00000000000000000000000000000000
+119D:00000020002000200020002000200020000000C0002000100000000000000000
+119E:00000000000000000000000000000000000000C0002000100000000000000000
+119F:000000100010001000700C100210011000000000000000000000000000000000
+11A0:000000000000000000000060001000083FFE0080008000000000000000000000
+11A1:0000001000100010001018100410021000000000000000000000000000000000
+11A2:0000000000000000000018600410020800000000000000000000000000000000
+11A3:000000000000000000000020002000200038002000203FF80000000000000000
+11A4:000000000000000000080008000E0008000E000800083FFE0080008000000000
+11A5:000000000000000000280028002E00E8002800EE002800280028000000000000
+11A6:0000000000100010001E011001103FFE00100000000000000000000000000000
+11A7:0000002400240024003C042404FC3F2400000000000000000000000000000000
+11A8:00000000000000000000000000000000000007F0001000100010001000000000
+11A9:0000000000000000000000000000000000000F78010801080108010800000000
+11AA:0000000000000000000000000000000000000F10011001100128014400000000
+11AB:000000000000000000000000000000000000040004000400040007F000000000
+11AC:00000000000000000000000000000000000008F80820082008500F8800000000
+11AD:000000000000000000000000000000000000083008FC083008480F3000000000
+11AE:00000000000000000000000000000000000007F004000400040007F000000000
+11AF:00000000000000000000000000000000000007F0001007F0040007F000000000
+11B0:0000000000000000000000000000000000000F7801080F0808080F0800000000
+11B1:0000000000000000000000000000000000001EF002901E9010901EF000000000
+11B2:0000000000000000000000000000000000001E9002901EF010901EF000000000
+11B3:0000000000000000000000000000000000001E2002201E2010501E8800000000
+11B4:0000000000000000000000000000000000001EF002801EF010801EF000000000
+11B5:0000000000000000000000000000000000001EF802501E5010501EF800000000
+11B6:0000000000000000000000000000000000001E6003F81E6010901E6000000000
+11B7:00000000000000000000000000000000000007F004100410041007F000000000
+11B8:0000000000000000000000000000000000000410041007F0041007F000000000
+11B9:000000000000000000000000000000000000122012201E2012501E8800000000
+11BA:0000000000000000000000000000000000000040004000C003201C1000000000
+11BB:0000000000000000000000000000000000000120012003A00C50318800000000
+11BC:00000000000000000000000000000000000001C002200220022001C000000000
+11BD:00000000000000000000000000000000000007F0008000800140022000000000
+11BE:00000000000000000000000000000000000001E0000007F8004003A00C180000
+11BF:00000000000000000000000000000000000007F0001007F00010001000000000
+11C0:00000000000000000000000000000000000007F0040007F0040007F000000000
+11C1:0000000000000000000000000000000000000FF00240024002400FF000000000
+11C2:000000000000000000000000000001C0000007F0000001C0022001C000000000
+11C3:0000000000000000000000000000000000007E7C0204027C0240027C00000000
+11C4:00000000000000000000000000000000789E0882088209420A22000000000000
+11C5:00000000000000000000000000000000000021FC2004200420043F8400000000
+11C6:000000000000000000000000000000000000207C2040204020403E7C00000000
+11C7:00000000000000000000000000000000000020202020202020503E8800000000
+11C8:00000000000000000000000000000000000040104028404440827CFE00000000
+11C9:000000000000000000000000000000000000207C2040207C20403E7C00000000
+11CA:0000000000000000000000000000000000003E7C2004200420043E0400000000
+11CB:0000000000000000000000000000000000003E7C2004207C20403E7C00000000
+11CC:0000000000000000000000000000000000007BC408447844404A785100000000
+11CD:0000000000000000000000000000000000003E4002403E4020403E7C00000000
+11CE:0000000000000000000000000000000000003E7C02403E4020403E7C00000000
+11CF:000000000000000000000000000000000000F78C143FF40C8412F78C00000000
+11D0:0000000000000000000000000000000000003E7C02043E7C20403E7C00000000
+11D1:0000000000000000000000000000000000007BDE0A427A4242427BC200000000
+11D2:0000000000000000000000000000000000007BC40A447A44424A7BD100000000
+11D3:0000000000000000000000000000000000007A440A447BC4424A7BD100000000
+11D4:000000000000000000000000000000000000F48C14BFF78C8492F78C00000000
+11D5:0000000000000000000000000000004800783E4802783E3020483E3000000000
+11D6:00000000000000000000000000000000000078880888788841547A2200000000
+11D7:0000000000000000000000000000000000003C2004503C8821043DFC00000000
+11D8:0000000000000000000000000000000000003E7C02043E7C20043E0400000000
+11D9:0000000000000000000000000000000000003E3802FE3E3820443E3800000000
+11DA:0000000000000000000000000000000000003E7C2204220422043E0400000000
+11DB:0000000000000000000000000000000000003E7C2204227C22403E7C00000000
+11DC:0000000000000000000000000000000000003E442244227C22443E7C00000000
+11DD:0000000000000000000000000000000000001F101110111011281F4400000000
+11DE:0000000000000000000000000000000000007C444444444444AA7D1100000000
+11DF:0000000000000000000000000000000000003E102228224422823EFE00000000
+11E0:0000000000000000000000000000000000383E0022FE220822343EC200000000
+11E1:0000000000000000000000000000000000003E3822FE223822443E3800000000
+11E2:00000000000000000000000000000FE008200FE0000003800440038000000000
+11E3:000000000000000000000000000000000000227C22043E7C22403E7C00000000
+11E4:000000000000000000000000000000000000227C22283E2822283E7C00000000
+11E5:000000000000000000000000000000000000223822FE3E3822443E3800000000
+11E6:0000000000000000000000000000041007F0041007F001C0022001C000000000
+11E7:00000000000000000000000000000000000004F8040804080A08110800000000
+11E8:000000000000000000000000000000000000047C044004400A40117C00000000
+11E9:00000000000000000000000000000000000008F8080808F8148022F800000000
+11EA:00000000000000000000000000000000000004440444047C0A44117C00000000
+11EB:00000000000000000000000000000000000001000280044008201FF000000000
+11EC:0000000000000000000000000000000000000E7C1104110411040E0400000000
+11ED:00000000000000000000000000000000000039DC444444444444384400000000
+11EE:0000000000000000000000000000000000001C382244224422441C3800000000
+11EF:0000000000000000000000000000000000001C7C2204227C22041C0400000000
+11F0:0000000000000000000000000000010001000380044004400440038000000000
+11F1:0000000000000000000000000000000000001C202220222022501C8800000000
+11F2:000000000000000000000000000000000000382044504488450439FC00000000
+11F3:0000000000000000000000000000000000003E441444147C14443E7C00000000
+11F4:000000000000000000000000000000000FF002400FF003C0042003C000000000
+11F5:0000000000000000000000000000000000001C407F401C4022401C7C00000000
+11F6:0000000000000000000000000000000000001C7C7F041C7C22401C7C00000000
+11F7:0000000000000000000000000000000000001C7C7F441C4422441C7C00000000
+11F8:0000000000000000000000000000000000001C447F441C7C22441C7C00000000
+11F9:00000000000000000000000000000000000003800FE003800440038000000000
+11FA:0000000000000000000000000000000000003E40024002400240027C00000000
+11FB:0000000000000000000000000000000000003E440244027C0244027C00000000
+11FC:0000000000000000000000000000000000383E0002FE0208023402C200000000
+11FD:0000000000000000000000000000000000003E7C0204027C0204020400000000
+11FE:0000000000000000000000000000000000003E3802FE02380244023800000000
+11FF:00000000000000000000000000000000000020402040204020403E7C00000000
+1200:00000000000001C030C030C030C030C030C030C0318031801F000E0000000000
+1201:00000000000001C030C030C030C030FC30CC30C0318031801F000E0000000000
+1202:0000000006600C600C600C600C6007C003C000C001800300033003F000000000
+1203:0000000006600C600C600C600C6007C003C000C0018003000300030000000000
+1204:0000000006600C600C600C600C6007C003C000C001C00340032003E000000000
+1205:000000000000187018301C300E3006300C300C300C300C6007E003C000000000
+1206:00000000000000F030C830D830E030C030C030C0318031801F000E0000000000
+1207:000000000000003C0C320C360C386C307C306C300C600C6007C0038000000000
+1208:00000000030003000300078007C00CE00C600C600C600C600C600C6000000000
+1209:000000000C000C000C001E001F0033803180318031F831983180318000000000
+120A:000000000C000C000C001E001F0033803180318031803180319831F800000000
+120B:00000000030003000300078007C00CE00C600C600C6000600060006000000000
+120C:000000000C000C000C001E001F00338031803180318031F0319831F000000000
+120D:00000000030003000300078007C00CE00C60186018601E601B601E6000000000
+120E:000000000C000C000C001E001F003380318031F831AC31B83180318000000000
+120F:00000000030003000300078007C00CE00C600C600C6000600060006003FC070E
+1210:000000000180018001800180018007E00DB00DB0199819981998199800000000
+1211:00000000060006000600060006001F8036C036C0667E66666660666000000000
+1212:00000000060006000600060006001F8036C036C0666066606666667E00000000
+1213:000000000180018001800180018007E00DB00DB0199800180018001800000000
+1214:00000000060006000600060006001F8036C036C066406678664C667800000000
+1215:000000000600060006000780018007E00DB00DB0199819981998199800000000
+1216:000000000180018001800180018007E00DB00DB0199818001800180000000000
+1217:0000030003000300030003000FC01B601B60333000300030003001FE03870000
+1218:000000000000000000000FFC1FFC112431642344264C3C783C70000000000000
+1219:000000000000000000003FF07FF04490C59E8D129932F1E0F1C0000000000000
+121A:000000001FF83FF86288428845087DF838F80010001000200026003E00000000
+121B:000000000FFC1FFC3144214422843EFC1C7C0008000800100010001000000000
+121C:000000001FF83FF86288428845087DF838F800100010003C0026003C00000000
+121D:000000001FF01FF832882288228822F83E701E00020006000C00180000000000
+121E:000000001FF01FF832882288228822F83E701E00020002000200030000000000
+121F:000000001FF83FF86288428845087DF838F80010001000300020002001F8030C
+1220:00000000000000000998199819981998199819B019F00D800780000000000000
+1221:000000000000000026C066C066FC66CC66C066C067C036001E00000000000000
+1222:000000006640666066606660666076E03FE00060006000600066007E00000000
+1223:00000000199019981998199819981DB80FF80018001800180018001800000000
+1224:00000000332033303330333033303B701FF00030003000380064007800000000
+1225:00000000199019981998199819981DB81FF01C00180018001800180000000000
+1226:00000000199819981998199819981DB80FF00380030007000E000C0000000000
+1227:00006640666066606660666076E03FE00060006000600060006003FC070E0000
+1228:00000000018001800180030007000E001C00180018001C600FE007E000000000
+1229:000000000300030007000E001C001800300038001FF00FF00180018000000000
+122A:00000000018001800180030007000E001C00186018701C300FE007C000000000
+122B:0000000003000300030006000E001C003800307830F839981F800F0000000000
+122C:00000000018001800180030007000E001C00180018001CF00F9807F000000000
+122D:00000000000007E00FE018601800180018001800180018601FE00FC000000000
+122E:00000000000007F00F9818F01800180018001800180018601FE00FC000000000
+122F:0000000030301CE00300030006000E001C003800307830F839981F800F000000
+1230:0000000001000100038007C00C600C600C600C600C600C600C600C6000000000
+1231:00000000040004000E001F0031803180318031F8319831803180318000000000
+1232:00000000040004000E001F00318031803180318031803180319831F800000000
+1233:0000000001000100038007C00C600C600C600C600C6000600060006000000000
+1234:000000000200020007000F8018C018C018C018C018E018D018C818F800000000
+1235:0000000000000300018001C003E0063006300630063006300630063000000000
+1236:0000000001000100038007C00C600C600C600C600C600C000C000C0000000000
+1237:0000000001000100038007C00C600C600C600C600C6000600060006001F8030C
+1238:0000000030601FC0020007000F8018C018C018C018C018C018C018C000000000
+1239:0000000030601FC0020007000F8018C018C018FC18CC18CC18C018C000000000
+123A:0000000030601FC0020007000F8018C018C018C018C018C018CC18FC00000000
+123B:0000000018300FE00100038007C00C600C600C600C6000600060006000000000
+123C:0000000030601FC0020007000F8018C018C018C018C018F818CC18F800000000
+123D:0000000018600FC0018001C003E0033006300630063006300630063000000000
+123E:0000000018300FE00100038007C00C600C600C600C600C000C000C0000000000
+123F:0000000030601FC0020007000F8018C018C018C018C018C000C000C003F00618
+1240:0000000001800180018003F00D98199819B00FC0018001800180018000000000
+1241:0000000003000300030007E01B30333033601F80030003F00330030000000000
+1242:0000000003000300030007E01B30333033601F8003000300033003F000000000
+1243:0000000001800180018003F00D98199819B00FC00180030006000C0000000000
+1244:0000000003000300030007E01B30333033601F80030003E0033003E000000000
+1245:00000000060006000780018003F00D98199819B00FC001800180018000000000
+1246:0000000001C0026002C0030007E01B30333033601F8003000300030000000000
+1247:0000000001C0026002C0030007E01B30333033601F80030033003F0030000000
+1248:0000000001800180018003F00D98199819B00FC001F801AC01B8018000000000
+1249:00007FFE7B8673F67B867BBE71867FFE7FFE6DCE6DB661C67DF67DCE7FFE0000
+124A:000000000600060006000FC0366C666C66FC3F07060306000600060000000000
+124B:0000000001800180018003F00D98199819B00FC0018001800180018007E00C30
+124C:0000000001800180018003F00D98199819B00FC00180018001F0019807F00C00
+124D:000000000600061806180FFE3666666066C03F00060006000600060000000000
+124E:00007FFE7B8673F67B867BBE71867FFE7FFE6D866DBE618E7DBE7D867FFE0000
+124F:00007FFE7B8673F67B867BBE71867FFE7FFE6D866DBE618E7DBE7DBE7FFE0000
+1250:000000000C3007E00180018003F00D98199819B00FC001800180018000000000
+1251:0000000018600FC00300030007E01B30333033601F80030003F0033000000000
+1252:0000000018600FC00300030007E01B30333033601F800300033003F000000000
+1253:000000000C3007E00180018003F00D98199819B00FC001800300060000000000
+1254:0000000018600FC0030007E01B30333033601F80030003E0033003E000000000
+1255:0000000030C01F8006000780018003F00D98199819B00FC00180018000000000
+1256:000000000C1807F001200160018003F00D98199819B00FC00180018000000000
+1257:00007FFE7B8673F67B867BBE71867FFE7FFE61866FF661EE7DDE61DE7FFE0000
+1258:0000000018600FC0030007E01B30333033601F8003F003580370030000000000
+1259:00007FFE7B8673F67B867BBE71867FFE7FFE61CE6FB661C67DF661CE7FFE0000
+125A:0000000030C01F80060006000FC0366C666C66FC3F0706030600060000000000
+125B:000000000C3007E00180018003F00D98199819B00FC001800180018007E00C30
+125C:000000000C3007E00180018003F00D98199819B00FC0018001F0019807F00C00
+125D:0000000030C01F80061806180FFE3666666066C03F0006000600060000000000
+125E:00007FFE7B8673F67B867BBE71867FFE7FFE61866FBE618E7DBE61867FFE0000
+125F:00007FFE7B8673F67B867BBE71867FFE7FFE61866FBE618E7DBE61BE7FFE0000
+1260:000000000000038007C00C600C600C600C600C600C600C600C600C6000000000
+1261:0000000000000E001F0031803180318031F83198319831803180318000000000
+1262:0000000000000E001F003180318031803180318031803180319831F800000000
+1263:000000000000038007C00C600C600C600C600C60006000600060006000000000
+1264:00000000000007000F8018C018C018C018C018C018C018F818CC18F800000000
+1265:00000000000000E001F00318031803183F183318331803180318031800000000
+1266:000000000000038007C00C600C600C600C600C600C000C000C000C0000000000
+1267:000000000000038007C00C600C600C600C600C60006000600060006001F8030C
+1268:0000000030601FC0000007000F8018C018C018C018C018C018C018C000000000
+1269:0000000030601FC0000007000F8018C018C018FC18CC18CC18C018C000000000
+126A:0000000030601FC0000007000F8018C018C018C018C018C018CC18FC00000000
+126B:0000000030601FC0000007000F8018C018C018C018C018C000C000C000000000
+126C:0000000060C03F8000000E001F00318031803180318031F0319831F000000000
+126D:000000000C1807F0000001C003E0063006307E30663066300630063000000000
+126E:0000000030601FC0000007000F8018C018C018C018C018C01800180000000000
+126F:0000000030601FC0000007000F8018C018C018C018C018C000C000C003F00618
+1270:0000000007000300030003003FF07FF863180300030003000300030000000000
+1271:0000000007000300030003003FF07FF86318030003F003300300030000000000
+1272:0000000007000300030003003FF07FF86318030003000300033003F000000000
+1273:0000000007000300030003003FF07FF863180300030007000E001C0000000000
+1274:0000000007000300030003003FF07FF863180300030003E0033003E000000000
+1275:00000000060007000380018001801FF83FFC318C018001800180018000000000
+1276:0000000003E00320016001801FF83FFC318C0180018001800180018000000000
+1277:0000000003800180018001801FF83FFC318C0180018001800180018007E00C30
+1278:0000000018181FF83FFC318C01801FF83FFC318C018001800180018000000000
+1279:0000000018181FF83FFC318C01801FF83FFC318C018001F80198018000000000
+127A:0000000018181FF83FFC318C01801FF83FFC318C01800180019801F800000000
+127B:0000000030303FF07FF8631803003FF07FF86318030007000E001C0000000000
+127C:0000000030303FF07FF8631803003FF07FF86318030003E0033003E000000000
+127D:0000000030C03FC07FE06660070001801FF83FFC318C01800180018000000000
+127E:000000000C301FF81A58024001801FF83FFC318C018001800180018000000000
+127F:0000000018181FF83FFC318C01801FF83FFC318C018001800180018007E00C30
+1280:000000000180018001801F8019E0006000600060006000600060006000000000
+1281:000000000300030003003F0033C000C000C000FC00CC00C000C000C000000000
+1282:000000000300030003003F0033C000C000C000C000C000C000CC00FC00000000
+1283:0000000000C000C000C00FC00CF000300030003000E001800300030000000000
+1284:000000000300030003003F0033C000C000C000C000C000F800CC00F800000000
+1285:0000000000C000C000C003C006F00C300C300030003000300030003000000000
+1286:0000000001F803E406383E003600060007E003E0006000600060006000000000
+1287:0000000001F803E406383E003600060007E003E000600060066007E006000000
+1288:000000000600060006007E006780018001F801AC01B801800180018000000000
+1289:00007FFE7B8673F67B867BBE71867FFE7FFE73CE6DB673C66DF673CE7FFE0000
+128A:000000000600060006007E0067800198019801F8018E01860180018000000000
+128B:000000000180018001801F8019E0006000600060006000600060006001F8030C
+128C:000000000300030003003F0033C000C000C000C000C000C000F800CC03F80600
+128D:000000000600060006007E3067B001FC018C0180018001800180018000000000
+128E:00007FFE7B8673F67B867BBE71867FFE7FFE73866DBE738E6DBE73867FFE0000
+128F:00007FFE7B8673F67B867BBE71867FFE7FFE73866DBE738E6DBE73BE7FFE0000
+1290:00000000060006000600078001C0018001800180030003000300030000000000
+1291:00000000060006000600078001C00180018001F0033003000300030000000000
+1292:000000000C000C000C000F00038003000300030006000600066007E000000000
+1293:0000000007C00FE01860300038001F0003800180010003000300030000000000
+1294:00000000060006000600078001C001800180018003C00320036003C000000000
+1295:000000003FC03F803180030007C000C0018003000300060006000C0000000000
+1296:0000000007F00FC81858303038001F0003800180010003000300030000000000
+1297:00000000000007C00FE01860300038001F00038001800100030003000FC01860
+1298:000000000C301FF81188018001E000700060006000C000C000C000C000000000
+1299:0000000018603FF02310030003C000E000C000F8019801800180018000000000
+129A:0000000018603FF02310030003C000E000C000C001800180019801F800000000
+129B:00000C301FF8118807C00FE01860300038001F00038001800300030000000000
+129C:0000000018603FF02310030003C000E000C000C001E0019001B001E000000000
+129D:000030C07FE046201FC03F803180030007C000C0018003000300030000000000
+129E:00000C601FF0111007F00FC81858303038001F00038001800300030000000000
+129F:00000C301FF8118807C00FE01860300038001F0003800180030003000FC01860
+12A0:0000000006000600060007800180038003C006E00E600C600C600C6000000000
+12A1:000000001800180018001E0006000E000F001B8039F831983180318000000000
+12A2:000000001800180018001E0006000E000F001B8039803180319831F800000000
+12A3:000000000600060006000780018003C006E00C600C600C600060006000000000
+12A4:000000001800180018001E0006000E000F001B80398031F0319831F000000000
+12A5:000000000C000C000E0006000300038007C00EE00C600C600C600C6000000000
+12A6:000000000600060006000780018003C006E00C600C600C600C000C0000000000
+12A7:000018C01FC03660060007800180038003C006E00E600C600C600C6000000000
+12A8:000000000000180019C01FE01E30063006300630063006300630063000000000
+12A9:000000000000600067007F8078C018C018C018FC18CC18C018C018C000000000
+12AA:000000000000600067007F8078C018C018C018C018C018C018CC18FC00000000
+12AB:000000000000180019C01FE01E30063006300630063000300030003000000000
+12AC:000000000000600067007F8078C018C018C018C018C018F818CC18F800000000
+12AD:000000000000180019C01BE01E300C300E300630063006300630063000000000
+12AE:000000000000180019C01FE01E30063006300630063006000600060000000000
+12AF:0000000000000C000CE00FF00F18031833183F18331803000300030000000000
+12B0:000000000000600066007F007980198019F819AC19B819801980198000000000
+12B1:00007FFE7B8673F67B867BBE71867FFE7FFE63EE6DCE63EE6DEE63C67FFE0000
+12B2:000000000000600066007F0079801998199819F8198E19861980198000000000
+12B3:000000000000180019C01FE01E30063006300630063000300030003000FC0186
+12B4:000000000000600067007F8078C018C018C018C018C000C000F800CC03F80600
+12B5:000000000000600066307F3079FC198C19801980198019801980198000000000
+12B6:00007FFE7B8673F67B867BBE71867FFE7FFE63CE6DBE638E6DB663CE7FFE0000
+12B7:00007FFE7B8673F67B867BBE71867FFE7FFE63866DF663EE6DDE63DE7FFE0000
+12B8:0000000061803F000C000DC00FE0063006300630063006300630063000000000
+12B9:00000000C3007E0018001B801FC00C600C600C7E0C660C600C600C6000000000
+12BA:00000000C3007E0018001B801FC00C600C600C600C600C600C660C7E00000000
+12BB:0000000061803F000C000DC00FE0063006300630063000300030003000000000
+12BC:0000000061803F000C000DC00FE00630063006300630063E0633063E00000000
+12BD:0000000061803F000C000EE00FF0031803980198019801980198019800000000
+12BE:0000000061803F000C000DC00FE0063006300630063006000600060000000000
+12BF:00007FFE7B8673F67B867BBE71867FFE7FFE63866DBE638E6DBE63BE7FFE0000
+12C0:00000000C3007E0018001B801FC00C600C7E0C6B0C6E0C600C600C6000000000
+12C1:00007FFE7B8673F67B867BBE71867FFE7FFE71EE6FCE6FEE6FEE71C67FFE0000
+12C2:00000000C3007E0018001B001F800CCC0CCC0CFC0CC70CC30CC00CC000000000
+12C3:0000000061803F000C000DC00FE0067006300630063000300030003000FC0186
+12C4:0000000061803F000C000DC00FE006700630063006300030003E003300FE0180
+12C5:00000000C3007E00180C1B8C1FFF0C630C600C600C600C600C600C6000000000
+12C6:00007FFE7B8673F67B867BBE71867FFE7FFE71CE6FBE6F8E6FB671CE7FFE0000
+12C7:00007FFE7B8673F67B867BBE71867FFE7FFE71866FF66FEE6FDE71DE7FFE0000
+12C8:000000000000000000000FF01DB831983198331833303B701FC0000000000000
+12C9:000000000000000000003FC076E0C660C660CC60CCE0EDC67FFC000C00000000
+12CA:000000000FF01DB83198319833183BB01FE0030003000700066007E000000000
+12CB:000000000FF01DB83198319833183BB01FE00300030003000300070000000000
+12CC:000000000FF01DB83198319833183BB01FE0030003000780066007C000000000
+12CD:000000000000000000003FC076E0C660C67ECC66CCC2EDC07F00000000000000
+12CE:000000000FF01DB83198319833183BB01FE0030006000C001800180000000000
+12CF:0000000003FC076E6C667C666CC60EEC07F800C0018003000600060000000000
+12D0:00000000000001E006300C300C300C300C300C300C300C3007F0060000000000
+12D1:000000000000078018C030C030C030C030C030FC30CC30C01FC0180000000000
+12D2:0000000000001F0031806180618061803FC000C000C00180019801F800000000
+12D3:00000000000007C00C601860186018600FF00030003000300060006000000000
+12D4:0000000000001F0031806180618061803FC000C000C001F0019801F000000000
+12D5:000001800180018007E00E300C300C300C300C300C300C3007F0060000000000
+12D6:0000000003C006600C300C300C300E7007E003C007000C000C000C0000000000
+12D7:00007FFE7B8673F67B867BBE71867FFE7FFE63866DF66DEE6DDE63DE7FFE0000
+12D8:000000000C600C600C600C600C600FE00FE00C600C600C600C600C6000000000
+12D9:00000000318031803180318031803F803F8031F8319831983180318000000000
+12DA:00000000318031803180318031803F803F80318031803180319831F800000000
+12DB:000000000C600C600C600C600FE00FE00C600C600C6000600060006000000000
+12DC:0000000018C018C018C018C018C01FC01FC018C018C018F818CC18F800000000
+12DD:000000001C30363036300630063007F007F00630063006300630063000000000
+12DE:000000000C600C600C600C600FE00FE00C600C600C600C000C000C0000000000
+12DF:000000000C600C600C600C600FE00FE00C600C600C6000600060006001F8030C
+12E0:000000001C38366C366C0660066007E007E00660066006600660066000000000
+12E1:0000000038706CD86CD80CC00CC00FC00FC00CFC0CCC0CCC0CC00CC000000000
+12E2:0000000038706CD86CD80CC00CC00FC00FC00CC00CC00CC00CCC0CFC00000000
+12E3:000000001C38366C366C066007E007E006600660066000600060006000000000
+12E4:0000000038706CD86CD80CC00CC00FC00FC00CC00CC00CF80CCC0CF800000000
+12E5:000061803F000C001C38366C366C066007E007E0066006600660066000000000
+12E6:000000001C38366C366C066007E007E006600660066006000600060000000000
+12E7:000000001C38366C366C066007E007E006600660066000600060006001F8030C
+12E8:00000000038006C00C600C600C600C600EC00780030003000300030000000000
+12E9:00000000038006C00C600C600C600C600EC00780030003F00330030000000000
+12EA:0000000007000D8018C018C018C018C01D800F00066007F80618060000000000
+12EB:0000000001C00360063006300630066007C0038001C0006001C0038000000000
+12EC:0000000007000D8018C018C018C018C01D800F0006F0079806F0060000000000
+12ED:00000000000007800CC018C018C018C00D800F30073003E03E00700060000000
+12EE:000000000E001B00318031F8319831803B001E000C000C000C000C0000000000
+12EF:00000000038006C00C600C7E0C660C606EC07F80630003000300030000000000
+12F0:00000000038007C00C400C400CC00F8006000300030001801FF8181800000000
+12F1:0000000007000F80188019801F000C0006001FC030C030FC018C018000000000
+12F2:0000000007000F80188019801F000C0006001FC030C030C0019801F800000000
+12F3:0000000001C003E00620066007C0030001800FF00C300C300030003000000000
+12F4:0000000007000F801880188019801F000C000600060003F03F9830F000000000
+12F5:0000000007000F8018F8189819801F000C000600060003003FF0303000000000
+12F6:0000000001C003E00620066007C0038007F00C30180018001800180000000000
+12F7:0000000001C003E00620066007C0030001800FF00C300C300030003000FC0186
+12F8:0000000001000100038007C00C400CC00F800600030001800FF00C3000000000
+12F9:000000000200020007000F80188019801F000C001FC030FC318C018000000000
+12FA:000000000200020007000F80188019801F000C001FC030C0319801F800000000
+12FB:0000000001000100038007C00C400CC00F8006001FE018600060006000000000
+12FC:00000000040004000E001F00310033003E0018000C0006F03F9830F000000000
+12FD:000000000200020007000F8018F819981F000C00060003001FE0186000000000
+12FE:0000000001000100038007C00C400CC00F8007F00C3018001800180000000000
+12FF:0080008001C003E00620066007C0030001800FF00C300C300030003000FC0186
+1300:000030301FE0030007800CC00C400CC007800600070003001FE0186000000000
+1301:000060603FC006000F00198019800F0006001FC030C030FC018C018000000000
+1302:000060603FC006000F00198019800F0006001FC030C030C0019801F800000000
+1303:000030301FE0030007800CC00CC0078003001FE0186018600060006000000000
+1304:000060603FC006000F001980188019800F000C000E0007F03F9830F000000000
+1305:000030301FE0030007800CC00C7C0CCC07800600070003001FE0186000000000
+1306:000030301FE0030007800CC00CC0078007F00C30180018001800180000000000
+1307:000030301FE0030007800CC00CC0078003001FE0186018600060006003FC070E
+1308:0000000000000F8018C018C000C000C000C00180018001800180018000000000
+1309:0000000000001F003180318001800180018003F8031803000300030000000000
+130A:0000000000000F8018C018C000C000C000C0018001800180019801F800000000
+130B:00000000000007800FE00C6000600060006000C001C007800E000C0000000000
+130C:0000000000000F8018C018C000C000C000C00180018001F0019801F000000000
+130D:0000000000000FE019B00F300030003000600060006000600060006000000000
+130E:0000000001000100010007C00C600C600060004000C000C000C000C000000000
+130F:0000000001000100010007C00C600C600060004000C000C00CC00FC00C000000
+1310:0000000000001F00318031800180018001F803AC033803000300030000000000
+1311:00007FFE7B8E73F67BC67BF6718E7FFE7FFE7BEE73CE7BEE7BEE71C67FFE0000
+1312:0000000000001F0031803180018001B001B003F0031C030C0300030000000000
+1313:00000000000007800CC00CC000C007E006600060006000600060006000000000
+1314:0000000000000F8018C018C000C000C000C001800180018001F0019807F00C00
+1315:0000000000001F0031B031B001FC018C01800380030003000300030000000000
+1316:00007FFE7B8E73F67BC67BF6718E7FFE7FFE7BCE73BE7B8E7BB671CE7FFE0000
+1317:00007FFE7B8E73F67BC67BF6718E7FFE7FFE7B8673F67BEE7BDE71DE7FFE0000
+1318:000000000C3007E0000007C00C600C600060004000C000C000C000C000000000
+1319:0000000030C01F8000001F00318031800180018003F803180300030000000000
+131A:0000000018600FC000000F8018C018C000C0008001800180019801F800000000
+131B:000000000C3007E0000003C007F004300030003000E003C007000E0000000000
+131C:0000000018600FC000000F8018C018C000C00080018001F0019801F000000000
+131D:0000000018600FC000000FE019B00F3000300020006000600060006000000000
+131E:000000000C6007C0010007C00C600C600060004000C000C000C000C000000000
+131F:0000000018600FC002000F8018C018C000C000800180018001800FF00C300000
+1320:000000000000000007C00D600D60193019301930193019301930193000000000
+1321:00000000000000001F003580358064C064C064FC64CC64C064C064C000000000
+1322:00000000000000001F003580358064C064C064C064C064C064CC64FC00000000
+1323:00000000000007C00D600D601930193019301930003000300030003000000000
+1324:0000000000001F003580358064C064C064C064C064C064F864CC64F800000000
+1325:0000000000000FE01FF013303318339831980180018001800180018000000000
+1326:00000000000007C00D600D601930193019301930180018001800180000000000
+1327:00000000000007C00D600D601930193019301930003000300030003000FC0186
+1328:00000000000000001F803FC06260C230C230C230F338DAB6CAB2FBBE00000000
+1329:00000000000000001F803FC06260C230C23FC233F338DAB4CAB2FBBE00000000
+132A:00000000000000001F803FC06260C230C230C230F330DAB0CAB3FBBF00000000
+132B:000000000FE01FF0311861187198695865587DD8001800340032003E00000000
+132C:00000000000000001F803FC06260C23FC239C237F330DABCCAB2FBBE00000000
+132D:0000000000001FC07FE0C630E6389724F33C030003800340032003E000000000
+132E:000000000FE01FF01A183218231862946252639C7000680064007C0000000000
+132F:0000000000000FE01FF0311861187198695865587DD800180030003000FC0186
+1330:0000000001800180018003C00660066003C007E00E700C300C300C3000000000
+1331:000000000600060006000F00198019800F001F8039C030FC30CC30C000000000
+1332:000000000600060006000F00198019800F001F8039C030C030CC30FC00000000
+1333:0000000001800180018003C0066003C007E00E700C700C300030003000000000
+1334:000000000600060006000F00198019800F001F8039C030F830CC30F800000000
+1335:000000000600060006000F0019F819980F001F8039C030C030C030C000000000
+1336:0000000001800180018003C0066003C007E00E700C300C300C000C0000000000
+1337:0000000003000300030007800CC007800FC01CC018E018600060006001F8030C
+1338:0000000000000000018003C00660066003C007E00E700C300C300C3000000000
+1339:000000000000000006000F00198019800F001F8039C030FC30CC30C000000000
+133A:000000000000000006000F00198019800F001F8039C030C030CC30FC00000000
+133B:000000000000030007800CC00CC007800FC01CC018E018600060006000000000
+133C:000000000000000006000F00198019800F001F8039C030F030D830F000000000
+133D:000000000000000006000F0019F819980F001F8039C030C030C030C000000000
+133E:000000000000030007800CC00CC007800FC01CE0186018601800180000000000
+133F:000000000000030007800CC00CC007800FC01CC018E018600060006001F8030C
+1340:00000000000001E006300C300C300C300FF00C300C300C3007F0060000000000
+1341:000000000000078018C030C030C030C03FC030FC30CC30C01FC0180000000000
+1342:000000007E00C300C300FF00C300C3007F00030003000300033003F000000000
+1343:00007EC3C3FFC3C37F03030303030000
+1344:000000007E00C300C300FF00C300C3007F000300030003E0033003E000000000
+1345:000001800180018007E00E300C300C300FF00C300C300C3007F0060000000000
+1346:0000000003C006600C300FF00C300E7007E003C007000C000C000C0000000000
+1347:0000000001E0033036183FF83618073803F001E0038006000600060000000000
+1348:00000000000000C0004000C00180030006000F00198018880FF803E800000000
+1349:000000000000000000800180030006000C001F00191019F01FC0030006000600
+134A:000000000000018000800180030006000C001E30331031301FE00F8000000000
+134B:000000000000000002000300060004000C001C00360033201FF0031003000300
+134C:00000000018000800180030006000C001E00330031301FE807C8007000000000
+134D:00000000000000000F8019C010C0300030003E0033C037401B00030003000300
+134E:00000000000007E00F9018F03000300030003C003A0031301B600FE000000000
+134F:00000000000002000300060004000C001C00360033201FF0031003000FC01860
+1350:000000000C300FF01FF819980180018001800180018001800180018000000000
+1351:000000000C300FF01FF8199801800180018001F8019801800180018000000000
+1352:000000000C300FF01FF81998018001800180018001800180019801F800000000
+1353:000000000C300FF01FF819980180018001800180030006000C00080000000000
+1354:000000000C300FF01FF819980180018001800180018001F0019801F000000000
+1355:000000000C300FF01FF81998018001E000600060006000600060006000000000
+1356:000000000C300FF01FF819980180018003000300060006000600060000000000
+1357:000000000C300FF01FF81998018001800180018001800180018001800FF01C38
+1358:000018180FF0018001800180030007000E001C00186018701C300FE007C00000
+1359:1C1C07F001C00FFC1FFC3144214422843EFC1C7C000800080010001000100000
+135A:000018180FF0018000800180030006000C001E30331031301FE00F8000000000
+135B:00007FFE7B8E73F67BC67BF6718E7FFE7FFE618E6FB6618E7DB6618E7FFE0000
+135C:00007FFE7B8E73F67BC67BF6718E7FFE7FFE61C66FBE61BE7DBE61C67FFE0000
+135D:1998199800000000000000000000000000000000000000000000000000000000
+135E:0180018000000000000000000000000000000000000000000000000000000000
+135F:0C300C3000000000000000000000000000000000000000000000000000000000
+1360:0000000000000180099004200240199819980240042009900180000000000000
+1361:00000000000303000003030000000000
+1362:0000000000000000000006600660000000000660066000000000000000000000
+1363:000000000000000007E000000180018000000180018000000000000000000000
+1364:000000000000000007E0000001800180000001800180000007E0000000000000
+1365:00000000000000000600060000001F8000000600060000000000000000000000
+1366:000000000000000006000600000003C000000600060000000000000000000000
+1367:0000000000000180018000000000018001800000000001800180000000000000
+1368:000000000000018001800C300C30018001800C300C3001800180000000000000
+1369:0000000018300FE0000001800180030007C00C600C6007C000000FE018300000
+136A:000000000C1807F0000001C00360066007C0060007C0036001C007F00C180000
+136B:0000000000000C3007E0000007E006600600060006000600000007E00C300000
+136C:0000000000000C3007E0000003C0066006600660066003C0000007E00C300000
+136D:0000000018300FE000000300030007E00E600C000C6007E000000FE018300000
+136E:000018300FE0000007800FC00CC000C0018001C0036003C000000FE018300000
+136F:000018300FE0000007800FC00CC000C001800100032003E000000FE018300000
+1370:0000000018180FF000000FF00DB00180018001800FF00C3000000FF018180000
+1371:000000000C3007E0000000000660066007E0066006400380000007E00C300000
+1372:0000000000000C3007E00000018001800180018001800180000007E00C300000
+1373:00000000000018180FF0000007E005A0018003C00660066000000FF018180000
+1374:00000000000018180FF0000005E00DB00DB00DB00DB0073000000FF018180000
+1375:0000000018180FF000000DB00DB00DB007F000300030003000000FF018180000
+1376:000000000C3007E0000003E0066003E0006000C000C000C0000007E00C300000
+1377:0000000018180FF000000FF00DB0018001C000C00FF00C3000000FF018180000
+1378:0000000000000C3007E0000003E006B006E00600066003E0000007E00C300000
+1379:00000000000030181FF000001FF016D006C006C006C006C000001FF030180000
+137A:000018300FE0000007C006C0018001C000C001800180018000000FE018300000
+137B:000000000C3007E0000003C0066007C00600030003000300000007E00C300000
+137C:00000000300C1FF800001E7833CC3EF830C018601860186000001FF8300C0000
+137D:00007FFE7B8E73F67BC67BF6718E7FFE7FFE618E7DB67BB677B6778E7FFE0000
+137E:00007FFE7B8E73F67BC67BF6718E7FFE7FFE61867DBE7B8E77BE77867FFE0000
+137F:00007FFE7B8E73F67BC67BF6718E7FFE7FFE61867DBE7B8E77BE77BE7FFE0000
+1380:000000000000000000003FF07FF04490C59F8D159937F1E0F1C0000000000000
+1381:000000003FE07FE0C52C853C8A2FFBE371E0004000400080009800F800000000
+1382:000000001FF83FF86288428845087DF838F800100010003C002403FC03000000
+1383:000000003FE07FE0C53E852A8A2EFBE071E01000100030002000200000000000
+1384:00000000000000000E001F003180318031F831A831B831803180318000000000
+1385:00000000000000000E001F0031B031B031FC318C318031803180318000000000
+1386:00000000000000000E001F003180318031803180318031E031A031E006000600
+1387:0000000000000000038007C00C600C607C7E6C6A0C6E0C600C600C6000000000
+1388:00000000000000C0004000FC0194031C06000F0019B018F00F30000000000000
+1389:000000000000018000B001F0033C060C0C001E00336031E01E60000000000000
+138A:00000000000003000100030006000C001E0011F813A80F3806000C0008000C00
+138B:00000000000000000F8019C010C0300037F03350337033001FE0036003000300
+138C:000000000C300FF01FF819980180018001F801AC01B801800180018000000000
+138D:0000000018601FE03FF0333003000300036003E0031803180300030000000000
+138E:000000000C300FF01FF819980180018001800180018001F001980FF00C000C00
+138F:0000000018601FE03FF033300300030001F801AC01B801800180018000000000
+1390:00000000000000000000000018180000
+1391:000000000000000000000024243C0000
+1392:00001818000000181800000018180000
+1393:00000000000000181800000018180000
+1394:00000000000000000000003C24240000
+1395:00000000000000000000000000000000001800180018003807F0780000000000
+1396:00000000000000000606060E1C600000
+1397:00000000000000000000000000000000000000000000000000007FFE00000000
+1398:00000000000000000000000000000000000000000000480048007FFE00000000
+1399:0000000000606060667E666060600000
+139A:00007FFE7B8E73F67BC67BF6718E7FFE7FFE73866DB671867DB673B67FFE0000
+139B:00007FFE7B8E73F67BC67BF6718E7FFE7FFE738E6DB6718E7DB6738E7FFE0000
+139C:00007FFE7B8E73F67BC67BF6718E7FFE7FFE73C66DBE71BE7DBE73C67FFE0000
+139D:00007FFE7B8E73F67BC67BF6718E7FFE7FFE738E6DB671B67DB6738E7FFE0000
+139E:00007FFE7B8E73F67BC67BF6718E7FFE7FFE73866DBE718E7DBE73867FFE0000
+139F:00007FFE7B8E73F67BC67BF6718E7FFE7FFE73866DBE718E7DBE73BE7FFE0000
+13A0:00000000784442424242424244780000
+13A1:00000000784442424478504844430000
+13A2:000000007F0808080808080808080000
+13A3:000000001C0814122151515155260000
+13A4:000000003048484B494E484848300000
+13A5:00000000080800080808080808080000
+13A6:000000003C424240207F0442423C0000
+13A7:000000001C02225252526242423C0000
+13A8:0000000040404C547640404040400000
+13A9:000000004242424242261A02023C0000
+13AA:0000000018242442427E424242420000
+13AB:00000000040404040404044444380000
+13AC:000000007E4040407C404040407E0000
+13AD:0000000008080848A8BB490A0A0C0000
+13AE:000000003C420202427C404040400000
+13AF:000000001C222222223E2222AACC0000
+13B0:00000000202020203E20202020200000
+13B1:000000007E4240404040404040400000
+13B2:00000000304848484830B7B2B4480000
+13B3:00000000424242425A5A666642420000
+13B4:00000000060909083844444444380000
+13B5:000000003C4242524C40404040400000
+13B6:000000001E204040484C4A4244380000
+13B7:00000000424266665A5A424242420000
+13B8:000000003844020202721E0202020000
+13B9:00000000180A15203C525212120C0000
+13BA:00000000324A4A4A4E4A4A4A4A320000
+13BB:00000000424242427E42424242420000
+13BC:000000003810384402020242423C0000
+13BD:000000004742424242261A02E2443800
+13BE:000000003C424242427E4242423C0000
+13BF:000000004040F0404040404E443C0418
+13C0:0000000078848480809E848484780000
+13C1:000000000C121212122222A2A2420000
+13C2:00000000404040405C62424242420000
+13C3:000000007E02020408102040407E0000
+13C4:000000003844E404E4443C0404040000
+13C5:00000000304848484A4D494848300000
+13C6:00000000FE1010101010101010FE0000
+13C7:000000000C1202424A4A4A4A4A340000
+13C8:00000000661919292A48484848300000
+13C9:00000000F1A122222224242428100000
+13CA:000000001C2222029AA2A2A2A25C0000
+13CB:000000003C4240403C404442423C0000
+13CC:0000000042424242427E4242423C0000
+13CD:000000001C22222202021AD2B26C0000
+13CE:00000000040C142444447E0404040000
+13CF:0000000040404040407C4242427C0000
+13D0:00000000080808080B5D680808080000
+13D1:00000000649AE2448098848484780000
+13D2:00000000784442424458484442420000
+13D3:000000002020202020202022221C0000
+13D4:00000000AAAAAA92B2B2CACA86820000
+13D5:000000003C424740201F0442423C0000
+13D6:00000000F090101010101211110E0000
+13D7:000000000202020202060A1222420000
+13D8:000000007E02020202060A1222420000
+13D9:00000000828282444444282810100000
+13DA:000000003C424240300C0242423C0000
+13DB:00000000364942605048484848300000
+13DC:00000000182424182422555555220000
+13DD:000000001C22424040404040407E0000
+13DE:000000004040404040404040407E0000
+13DF:000000003C42424040404042423C0000
+13E0:000000000444A4A47E24242424180000
+13E1:000000006699999A2844444444380000
+13E2:000000007C4242427C40404040400000
+13E3:000000003C42474040424242423C0000
+13E4:00000000F19112121414141818100000
+13E5:00000040404040434D74444444440000
+13E6:00000000424448506060504844420000
+13E7:00000000020202021E224242221C0000
+13E8:0000000030484A454040454A48300000
+13E9:000000003844444440404E44443B0000
+13EA:00000000225555535131199995620000
+13EB:000000003C424272525E4242423C0000
+13EC:000000003249494971414141221C0000
+13ED:000000000C1212120A06024244380000
+13EE:000000003C424040407C4242423C0000
+13EF:000000001E210101015D494949360000
+13F0:000000001C2222223C222262322C4000
+13F1:000000000E040E1111212129A9660000
+13F2:000000003C424240405C624242420000
+13F3:0000000030484A4540404E44443C0000
+13F4:000000007C4242427C424242427C0000
+13F5:000000000810102020404E4444380000
+13F6:00007FFE7B8E73F67BC67BF6718E7FFE7FFE61CE6FBE638E6FB66FCE7FFE0000
+13F7:00007FFE7B8E73F67BC67BF6718E7FFE7FFE61866FF663EE6FDE6FDE7FFE0000
+13F8:0000000000001C22223C2262322C4000
+13F9:0000000000000E040E111121A9660000
+13FA:0000000000003C4240405C6242420000
+13FB:000000000000304A4540404E443C0000
+13FC:0000000000007C42427C4242427C0000
+13FD:000000000000102020404E4444380000
+13FE:00007FFE7B8E73F67BC67BF6718E7FFE7FFE61866FBE638E6FBE6F867FFE0000
+13FF:00007FFE7B8E73F67BC67BF6718E7FFE7FFE61866FBE638E6FBE6FBE7FFE0000
+1400:000000000000007E0000007E00000000
+1401:0000000000000000000000007FFE400220041008081004200240018000000000
+1402:00000180024002400180000001800240042008101008200440027FFE00000000
+1403:00000000000000000000000001800240042008101008200440027FFE00000000
+1404:00000000000001800180000001800240042008101008200440027FFE00000000
+1405:0000000000000C000A00090008800840082008200840088009000A000C000000
+1406:0C000C0000000C000A00090008800840082008200840088009000A000C000000
+1407:0CC00CC000000C000A00090008800840082008200840088009000A000C000000
+1408:0000000000000C000A00090008800A400A200A200A40088009000A000C000000
+1409:0000000000000C000A000900088008400B200B200840088009000A000C000000
+140A:000000000000006000A00120022004200820082004200220012000A000600000
+140B:006000600000006000A00120022004200820082004200220012000A000600000
+140C:0000000000000000000000007FFE400220041008081064206240018000000000
+140D:0000000000000000000000007FFE400220041008081004260246018000000000
+140E:00000000000000000000000001806240642008101008200440027FFE00000000
+140F:00000000000000000000000001800246042608101008200440027FFE00000000
+1410:00000000000001800180000001806240642008101008200440027FFE00000000
+1411:00000000000001800180000001800246042608101008200440027FFE00000000
+1412:0000000000000C000A00090008800840682068200840088009000A000C000000
+1413:0000000000000C000A00090008800840082C082C0840088009000A000C000000
+1414:0C000C0000000C000A00090008800840682068200840088009000A000C000000
+1415:0C000C0000000C000A00090008800840082C082C0840088009000A000C000000
+1416:0000018001800C000A30093008800840082008200840088009000A000C000000
+1417:000000000000006000A00120022004206820682004200220012000A000600000
+1418:000000000000006000A0012002200420082C082C04200220012000A000600000
+1419:006000600000006000A00120022004206820682004200220012000A000600000
+141A:006000600000006000A0012002200420082C082C04200220012000A000600000
+141B:000003000300006018A01920022004200820082004200220012000A000600000
+141C:000000000000000011101110111011100EE00000000000000000000000000000
+141D:0000003000480048003006000900090006000000000000000000000000000000
+141E:00000010102828447C00000000000000
+141F:00000000040810204000000000000000
+1420:00000000402010080400000000000000
+1421:00000000444444443800000000000000
+1422:00000000384444444400000000000000
+1423:00000000780404047800000000000000
+1424:00000000384444443800000000000000
+1425:00000000091224489000000000000000
+1426:00000000242424240000000000000000
+1427:00000000000000001818000000000000
+1428:0000000000007C000000000000000000
+1429:0000000010107C101000000000000000
+142A:000000007C1010101000000000000000
+142B:0000000000000000000800080004FFF480124022204010800900060000000000
+142C:00000000000000000010001000080308048408441020201040087FF800000000
+142D:0000000000001820142012101110108810481040108011001200140018000000
+142E:00000000000001A002A004900890108820882080108008800480028001800000
+142F:0000000000000000000000000000400220041008081004200240018000000000
+1430:0000018002400240018000000180024004200810100820044002000000000000
+1431:0000000000000000000000000180024004200810100820044002000000000000
+1432:0000000000000180018000000180024004200810100820044002000000000000
+1433:00000040201008040202040810204000
+1434:60600040201008040202040810204000
+1435:66660040201008040202040810204000
+1436:00000040201008242222240810204000
+1437:00000040201008043232040810204000
+1438:00000002040810204040201008040200
+1439:06060002040810204040201008040200
+143A:0000000000000000000000000000400220041008081064206240018000000000
+143B:0000000000000000000000000000400220041008081004260246018000000000
+143C:0000000000000000000000000000018062406420081010082004400200000000
+143D:0000000000000000000000000000018002460426081010082004400200000000
+143E:0000000000000000018001800000018062406420081010082004400200000000
+143F:0000000000000000018001800000018002460426081010082004400200000000
+1440:000000000000010000800040002000100C080C08001000200040008001000000
+1441:00000000000004000200010000800040002C002C004000800100020004000000
+1442:018001800000010000800040002000100C080C08001000200040008001000000
+1443:06000600000004000200010000800040002C002C004000800100020004000000
+1444:000000000000001000200040008001001A001A00010000800040002000100000
+1445:00000000000000200040008001000200040C040C020001000080004000200000
+1446:003000300000001000200040008001001A001A00010000800040002000100000
+1447:00600060000000200040008001000200040C040C020001000080004000200000
+1448:00000180018000200C400C800100020004000400020001000080004000200000
+1449:00000000040810201008040000000000
+144A:00000000101010101000000000000000
+144B:00000000202038242400000000000000
+144C:000000000000000000001008100810081008100810081008081007E000000000
+144D:0180024002400180000007E00810100810081008100810081008100800000000
+144E:0000000000000000000007E00810100810081008100810081008100800000000
+144F:0000000001800180000007E00810100810081008100810081008100800000000
+1450:00000000000000000FE0001000080008000800080008000800100FE000000000
+1451:00000300030000000FE0001000080008000800080008000800100FE000000000
+1452:00000CC00CC000000FE0001000080008000800080008000800100FE000000000
+1453:00000000000000000FE0001000080088008800880088000800100FE000000000
+1454:00000000000000000FE0001000080008018801880008000800100FE000000000
+1455:000000000000000003F80400080008000800080008000800040003F800000000
+1456:000000600060000003F80400080008000800080008000800040003F800000000
+1457:000000000000000000000804080408046804680408040804040803F000000000
+1458:00000000000000000000402040204020402C402C4020402020401F8000000000
+1459:0000000000000000000003F00408080408046804680408040804080400000000
+145A:000000000000000000001F80204040204020402C402C40204020402000000000
+145B:0000000000C000C0000003F00408080408046804680408040804080400000000
+145C:000000000600060000001F80204040204020402C402C40204020402000000000
+145D:0000000000000000000007F00008000400046004600400040004000807F00000
+145E:000000000000000000003F80004000200020002C002C0020002000403F800000
+145F:0000000001800180000007F00008000400043004300400040004000807F00000
+1460:000000000C000C0000003F80004000200020002C002C0020002000403F800000
+1461:0000000000000000000001FC0200040004003400340004000400020001FC0000
+1462:000000000000000000000FE0100020002000201820182000200010000FE00000
+1463:0000000000600060000003F80400080008006800680008000800040003F80000
+1464:000000000300030000001FC0200040004000401840184000400020001FC00000
+1465:0000000000000000000003F80400680068000800080068006800040003F80000
+1466:000000003C4040403C00000000000000
+1467:00000000000000000000201420142014201420102010201010200FC000000000
+1468:000000000000000000000FC41024201420142010201020102010201000000000
+1469:00000000000000003F88004800280028002000200020002000403F8000000000
+146A:00000000000000000FE8100820082008200020002000200010000FE000000000
+146B:0000000000384444443C040404040000
+146C:18242418003844444478404040400000
+146D:00000000003844444478404040400000
+146E:00003030003844444478404040400000
+146F:0000000000040404043C444444380000
+1470:00000C0C00040404043C444444380000
+1471:0000363600040404043C444444380000
+1472:00000000004040404078444444380000
+1473:00006060004040404078444444380000
+1474:00000000001C2222221E026262020000
+1475:000000000070888888780B0B08080000
+1476:00000000000E1111111ED0D010100000
+1477:000000000070888888F0868680800000
+1478:00000C0C000E1111111ED0D010100000
+1479:000060600070888888F0868680800000
+147A:0000000000010161610F1111110E0000
+147B:000000000008080B0B78888888700000
+147C:0000030300010161610F1111110E0000
+147D:000018180008080B0B78888888700000
+147E:0000000000101010D0DE1111110E0000
+147F:000000000080808686F0888888700000
+1480:0000181800101010D0DE1111110E0000
+1481:0000C0C00080808686F0888888700000
+1482:00000000001010D0D01ED1D1110E0000
+1483:00000000202020382424180000000000
+1484:000000000404041C2424180000000000
+1485:0000000000728A8A8A78080808080000
+1486:0000000000728A8A8AF0808080800000
+1487:00000000000A0A0A0A78888888700000
+1488:00000000004242424278444444380000
+1489:00000000003844444404040404040000
+148A:30484830003844444440404040400000
+148B:00000000003844444440404040400000
+148C:00003030003844444440404040400000
+148D:00000000000404040404444444380000
+148E:00000C0C000404040404444444380000
+148F:00003636000404040404444444380000
+1490:00000000004040404040444444380000
+1491:00006060004040404040444444380000
+1492:00000000001C22222202C2C202020000
+1493:00000000007088888B0B080808080000
+1494:00000000000E1111D1D0101010100000
+1495:00000000007088888880868680800000
+1496:00000C0C000E1111D1D0101010100000
+1497:000060600070888888808C8C80800000
+1498:00000000000202C2C2022222221C0000
+1499:00000000000808080B0B888888700000
+149A:00000606000202C2C2022222221C0000
+149B:000018180008080B0B08888888700000
+149C:0000000000101010D0D01111110E0000
+149D:00000080808080868680888888700000
+149E:0000181800101010D0D01111110E0000
+149F:0000C0C0008080868680888888700000
+14A0:0000000000101010D0D011D1D10E0000
+14A1:00000000202020202424180000000000
+14A2:00000000040404042424180000000000
+14A3:00000000007C04040404040404040000
+14A4:30484830007C40404040404040400000
+14A5:00000000007C40404040404040400000
+14A6:00003030007C40404040404040400000
+14A7:000000000004040404040404047C0000
+14A8:00000C0C0004040404040404047C0000
+14A9:000036360004040404040404047C0000
+14AA:000000000040404040404040407C0000
+14AB:000060600040404040404040407C0000
+14AC:00000000001F01016161010101010000
+14AD:0000000000F808080B0B080808080000
+14AE:00000000001F1010D0D0101010100000
+14AF:0000000000F880808686808080800000
+14B0:00000C0C001F1010D0D0101010100000
+14B1:00003030007C40404646404040400000
+14B2:000000000001010161610101011F0000
+14B3:00000000000808080B0B080808F80000
+14B4:0000060600020202C2C20202023E0000
+14B5:00001818000808080B0B080808F80000
+14B6:0000000000101010D0D01010101F0000
+14B7:00000000008080808686808080F80000
+14B8:0000181800101010D0D01010101F0000
+14B9:000060600040404046464040407C0000
+14BA:00000000001010D0D010D0D0101F0000
+14BB:0000000020202020203C000000000000
+14BC:000000001C20201C0000000000000000
+14BD:0000000004040404043C000000000000
+14BE:00000000182408103C00000000000000
+14BF:000000003C42020204081020407E0000
+14C0:0000000000000000000000000000000000001FE001100110011000E000000000
+14C1:0000000000000000030004800480030000000FF01100110011000E0000000000
+14C2:0000000000000000000000000000000000000FF01100110011000E0000000000
+14C3:0000000000000000000000000300030000000FF01100110011000E0000000000
+14C4:00000000000000000000000000000000000000E00110011001101FE000000000
+14C5:00000000000000000000000000C000C0000000E00110011001101FE000000000
+14C6:00000000000000000000000006600660000000E00110011001101FE000000000
+14C7:0000000000000000000000000000000000000E001100110011000FF000000000
+14C8:000000000000000000000000030003000000070008800880088007F800000000
+14C9:00000000000000000000000000000000000007F8304430440044003800000000
+14CA:0000000000000000000000000000000000003FC0022C022C022001C000000000
+14CB:000000000000000000000000000000000000038004403440344003FC00000000
+14CC:0000000000000000000000000000000000000E301130110011000FF000000000
+14CD:000000000000000000000000030003000000038004403440344003FC00000000
+14CE:0000000000000000000000000C000C0000000E301130110011000FF000000000
+14CF:0000000000000000000000001980198000000E001100110011000FF000000000
+14D0:000000003048483F0000000000000000
+14D1:000000002222221C0000000000000000
+14D2:000000000609097E0000000000000000
+14D3:0000000000000000000000000000000000001FE000100010001000E000000000
+14D4:0000000000000000060009000900060000000FF01000100010000E0000000000
+14D5:0000000000000000000000000000000000000FF01000100010000E0000000000
+14D6:0000000000000000000000000600060000000FF01000100010000E0000000000
+14D7:00000000000000000000000000000000000000E00010001000101FE000000000
+14D8:00000000000000000000000000C000C0000000E00010001000101FE000000000
+14D9:00000000000000000000000003300330000000E00010001000101FE000000000
+14DA:0000000000000000000000000000000000000E001000100010000FF000000000
+14DB:000000000000000000000000030003000000070008000800080007F800000000
+14DC:00000000000000000000000000000000000007F8300430040004003800000000
+14DD:0000000000000000000000000000000000003FC0002C002C002001C000000000
+14DE:00000000000000000000000000000000000003FC340034000400038000000000
+14DF:0000000000000000000000000000000000001FE0200C200C20001C0000000000
+14E0:00000000000000000000000001800180000003FC340034000400038000000000
+14E1:0000000000000000000000000C000C0000001FE0200C200C20001C0000000000
+14E2:00000000000000000000000000000000000018E01810001000101FE000000000
+14E3:00000000000000000000000000000000000001C0002C002C00203FC000000000
+14E4:00000000000000000000000000600060000018E01810001000101FE000000000
+14E5:00000000000000000000000000C000C0000001C0002C002C00203FC000000000
+14E6:000000000000000000000000000000000000038034003400040003FC00000000
+14E7:000000000000000000000000000000000000071808180800080007F800000000
+14E8:000000000000000000000000030003000000038034003400040003FC00000000
+14E9:0000000000000000000000000C000C0000000E301030100010000FF000000000
+14EA:000000006080807E0000000000000000
+14EB:000000000C300C300C00000000000000
+14EC:000000061860300C020C306018060000
+14ED:0000000040404040201C040404040000
+14EE:0C12120C000404040870404040400000
+14EF:00000000040404040870404040400000
+14F0:000C0C00040404040408704040400000
+14F1:000000000404041C2040404040400000
+14F2:000C0C000404041C2040404040400000
+14F3:006666000404041C2040404040400000
+14F4:00000000404040700804040404040000
+14F5:00606000404040700804040404040000
+14F6:00000000202020202010CEC202020000
+14F7:00000000808080868640380808080000
+14F8:00000000020202C2C204382020200000
+14F9:00000000080808080810E68680800000
+14FA:00060600020202C2C204382020200000
+14FB:00181800080808080810E68680800000
+14FC:000000000262620E1020202020200000
+14FD:000000000404041C2046464040400000
+14FE:000606000262620E1020202020200000
+14FF:000C0C000404041C2046464040400000
+1500:000000004040407008C4C40404040000
+1501:00000000808086E61008080808080000
+1502:006060004040407008C4C40404040000
+1503:00C0C000808086E61008080808080000
+1504:0000000010D0D01C02C1C10101010000
+1505:00000000202030080808000000000000
+1506:00000000182010083000000000000000
+1507:00000000080818202020000000000000
+1508:000000002020201C0000000000000000
+1509:00000000202038041C24180000000000
+150A:0000000004041C203824180000000000
+150B:00303000202030080808001818000000
+150C:000018001800000410081010182004400480048000400C200C10000800040000
+150D:000060006000000040FE4100620012001200120002003200310000FE00000000
+150E:00000000180018000000108010801880048004F0048800880C880C7000000000
+150F:0000000018001800000010801080188004800480048800880C880C7000000000
+1510:000000000000000000000E00110011001100010001100110011000E000000000
+1511:0000000000000000000000E001100110011001001100110011000E0000000000
+1512:0000000000C000C0000000E001100110011001001100110011000E0000000000
+1513:0000000000000000000000000000000000000C601210111010900C6000000000
+1514:0000000000000000000001800180000000000C601210111010900C6000000000
+1515:0000000000000000000000000000000000000C601090111012100C6000000000
+1516:0000000000000000000001800180000000000C601090111012100C6000000000
+1517:0000000000000000000007000880088008800080308830880088007000000000
+1518:000000000000000000001C00220022182218020002200220022001C000000000
+1519:0000000000000000000000700088308830880080088008800880070000000000
+151A:0000000000000000000001C002200220022002002218221822001C0000000000
+151B:0000000000600060000000700088308830880080088008800880070000000000
+151C:0000000001800180000001C002200220022002002218221822001C0000000000
+151D:0000000000000000000000000000000000003318348404440424031800000000
+151E:00000000000000000000000000000000000018CC242C2220212018C000000000
+151F:0000000000000000000000C000C0000000003318348404440424031800000000
+1520:00000000000000000000030003000000000018CC242C2220212018C000000000
+1521:0000000000000000000000000000000000003318348404440424031800000000
+1522:00000000000000000000000000000000000018CC212C2220242018C000000000
+1523:0000000000000000000000C000C0000000003318342404440484031800000000
+1524:0000000000000000000003000300000000000C661096111012100C6000000000
+1525:00000000485424000000000000000000
+1526:00000000040810207C04040404040000
+1527:18242418402010087C40404040400000
+1528:00000000402010087C40404040400000
+1529:00606000402010087C40404040400000
+152A:0000000004040404047C201008040000
+152B:000C0C0004040404047C201008040000
+152C:0066660004040404047C201008040000
+152D:0000000040404040407C081020400000
+152E:0060600040404040407C081020400000
+152F:000000000204C8D03E02020202020000
+1530:0000000008102343F808080808080000
+1531:00000000100804C2DF10101010100000
+1532:0000000080402616F880808080800000
+1533:00181800100804C2DF10101010100000
+1534:00C0C00080402616F880808080800000
+1535:0000000002020202023ED0C804020000
+1536:000000000808080808FB432010080000
+1537:0006060002020202023ED0C804020000
+1538:001818000808080808FB432010080000
+1539:000000001010101010DFC20408100000
+153A:000000008080808080F8162640800000
+153B:001818001010101010DFC20408100000
+153C:00C0C0008080808080F8162640800000
+153D:000000001010D0D0101FC2C408100000
+153E:0000000020203C081020000000000000
+153F:00000000282854540000000000000000
+1540:0000000010107C101000000000000000
+1541:00000000000044281028440000000000
+1542:0000000000000000000000000000000010F010801080108010800F0000000000
+1543:000000000000000000000000000000001E10021002100210021001E000000000
+1544:0000000000000000000000000000000001E002100210021002101E1000000000
+1545:000000000000060009000900060000000F00108010801080108010F000000000
+1546:000000000000000000000000000000000F00108010801080108010F000000000
+1547:000000000000000000000600060000000F00108010801080108010F000000000
+1548:00000000007C020202027C4040400000
+1549:00003030007C020202027C4040400000
+154A:00000000004040407C020202027C0000
+154B:00000000003E404040403E0202020000
+154C:00001818003E404040403E0202020000
+154D:00000000000202023E404040403E0000
+154E:00000C0C001F202020201FC1C1010000
+154F:00003030007C808083837C0404040000
+1550:00000000182020180808000000000000
+1551:00000000300C300C3000000000000000
+1552:0000006018060C3040300C0618600000
+1553:0000000000000000000000001800240224041808081004200240018000000000
+1554:0000000001800240024001800000018002400420081018082404240218000000
+1555:0000000000000000000000000000018002400420081018082404240218000000
+1556:0000000000000000018001800000018002400420081018082404240218000000
+1557:0000000000000000060009000980064000200010001000200040008001000200
+1558:0000060006000000060009000980064000200010001000200040008001000200
+1559:0000000000000000006000900190026004000800080004000200010000800040
+155A:0000006000600000006000900190026004000800080004000200010000800040
+155B:0000001800180000001800240064009801003200320001000080004000200010
+155C:0000018001800000018002400640098010002018201810000800040002000100
+155D:0000000C122C40201008000000000000
+155E:000000000000000000000C08120812081C08100810081008081007E000000000
+155F:000000000000000000001030104810481038100810081008081007E000000000
+1560:0000000000000000000007E008101008100810081C08120812080C0800000000
+1561:0000000000000000000007E00810100810081008103810481048103000000000
+1562:0000000001800180000007E008101008100810081C08120812080C0800000000
+1563:0000000001800180000007E00810100810081008103810481048103000000000
+1564:000000000000000007E0091009080608000800080008000800100FE000000000
+1565:000001800180000007E0091009080608000800080008000800100FE000000000
+1566:000000000000000003F00448084808300800080008000800040003F800000000
+1567:000000C000C0000003F00448084808300800080008000800040003F800000000
+1568:000000600060000001F80224042404183400340004000400020001FC00000000
+1569:00000300030000000FC01120212020C0200C200C2000200010000FE000000000
+156A:000000001C2A2A24201E000000000000
+156B:000000000000000000001110111011101110111010101010082007C000000000
+156C:0000000000000000000007C00820101010101110111011101110111000000000
+156D:000000000000000000001FC00020001000101F100010001000201FC000000000
+156E:0000000000000000000003F804000800080008F808000800040003F800000000
+156F:000000000000000008102A541C3808101C382A54081000000000000000000000
+1570:000000000000000000001450145014501450139010101010082007C000000000
+1571:0000000000000000000007C00820101010101390145014501450145000000000
+1572:000000000000000000001FC000201E100110011001101E1000201FC000000000
+1573:0000000000000000000003F8040008780880088008800878040003F800000000
+1574:000000000000000000000E001100110011000F00012001400180010000000000
+1575:0000000000000000000001C002200220022003C012000A000600020000000000
+1576:0000000001800180000001C002200220022003C012000A000600020000000000
+1577:0000000000000000000001000180014001200F001100110011000E0000000000
+1578:0000000003000300000001000180014001200F001100110011000E0000000000
+1579:00000000000000000000020006000A00120003C002200220022001C000000000
+157A:00000000030003000000020006000A00120003C002200220022001C000000000
+157B:000000001030501C12120C0000000000
+157C:0000000000424242427E424242420000
+157D:00000000442810284400000000000000
+157E:003000480048003000001C70208820881C8804F0048000800080008000000000
+157F:000000000000000000001C70208820881C8804F0048000800080008000000000
+1580:000000000060006000001C70208820881C8804F0048000800080008000000000
+1581:000000000000000000001C08200820081C080478048800880088007000000000
+1582:000000000018001800001C08200820081C080478048800880088007000000000
+1583:000000000000000000001C80208020801C8004F0048800880088007000000000
+1584:0000000000C000C000001C80208020801C8004F0048800880088007000000000
+1585:0000000000000000000006400840087006480248023000000000000000000000
+1586:00000000000E1111110F050509090000
+1587:00000000000E1111111E141412120000
+1588:0000000000090905050F1111110E0000
+1589:0000000000121214141E1111110E0000
+158A:000000000000000000000E001100110011000100012001400180010000000000
+158B:0000000000000000000001C0022002200220020012000A000600020000000000
+158C:00000000000000000000010001800140012001001100110011000E0000000000
+158D:00000000000000000000020006000A001200020002200220022001C000000000
+158E:000C00120012000C0000301C482248223C2204A004A003200020002000000000
+158F:00000000000000000000301C482248223C2204A004A003200020002000000000
+1590:00000000001800180000301C482248223C2204A004A003200020002000000000
+1591:000000000000000000003002480248023C02048204A203220022001C00000000
+1592:000000000006000600003002480248023C02048204A203220022001C00000000
+1593:000000000000000000003020482048203C2004A004A203220022001C00000000
+1594:000000000030003000003020482048203C2004A004A203220022001C00000000
+1595:0000000000000000000006000900090007800090009000600000000000000000
+1596:0000000000000000000031804A404A403FE00024002400180000000000000000
+1597:00000000003C424A4A32020202020000
+1598:00000000003C4252524C404040400000
+1599:000000000002020202324A4A423C0000
+159A:0000000000404040404C5252423C0000
+159B:00000000000000000000000000001FE000001FE001100110011000E000000000
+159C:00000000000000000000000000000FF000000FF01100110011000E0000000000
+159D:00000000000000000000000000001FE0000000E00110011001101FE000000000
+159E:00000000000000000000000000001FE000000E001100110011000FF000000000
+159F:0000003F003048483F00000000000000
+15A0:0000000000000000000000000080004000200FF01000100010000E0000000000
+15A1:0000000000000180018000000080004000200FF01000100010000E0000000000
+15A2:00000000000000000000000000E00010001000101FE008000400020000000000
+15A3:00000000000000C000C0000000E00010001000101FE008000400020000000000
+15A4:0000000000000000000000000E001000100010000FF000200040008000000000
+15A5:0000000000000600060000000E001000100010000FF000200040008000000000
+15A6:000000003040403C0810000000000000
+15A7:00000000040810207C043E0404040000
+15A8:00000000201008043E207C2020200000
+15A9:00606000201008043E207C2020200000
+15AA:000000000404043E047C201008040000
+15AB:000C0C000404043E047C201008040000
+15AC:000000002020207C203E040810200000
+15AD:003030002020207C203E040810200000
+15AE:000000002078203C0810200000000000
+15AF:0000000000808080BCC28282C2BC0000
+15B0:0000000000BCFEFEFEFEBC8080800000
+15B1:00000000000202027AFEFEFEFE7A0000
+15B2:0000000000808080BCFEFEFEFEBC0000
+15B3:00000000007AFEFEFEFE7A0202020000
+15B4:00000000007C4040407C404040400000
+15B5:0000000000040404047C0404047C0000
+15B6:0000000000404040407C4040407C0000
+15B7:00000000007C0404047C040404040000
+15B8:000000000000000000000E100A100A1009E00800080008000800080000000000
+15B9:0000000000000000000000100010001000100010079008500850087000000000
+15BA:000000000000000000000800080008000800080009E00A100A100E1000000000
+15BB:0000000000000000000008700850085007900010001000100010001000000000
+15BC:000000000000000000000C100A20094008800800080008000800080000000000
+15BD:0000000000000000000000100010001000100010011002900450083000000000
+15BE:0000000000000000000008000800080008000800088009400A200C1000000000
+15BF:0000000000000000000008300450029001100010001000100010001000000000
+15C0:0000000000000000000000100010001007100890089000500050003000000000
+15C1:0000000000000000000008000800080008E0091009100A000A000C0000000000
+15C2:0000000000000000000000300050005008900890071000100010001000000000
+15C3:000000000000000000000C000A000A000910091008E008000800080000000000
+15C4:00000000000000000000000000004002200410080FF004200240018000000000
+15C5:00000000000000000000000000000180024004200FF010082004400200000000
+15C6:0000000008000400020001000180014001200120014001800100020004000800
+15C7:0000000008000400020001000180054005200520054001800100020004000800
+15C8:000000000800040002000100018001400D200D20014001800100020004000800
+15C9:00000000004000800100020006000A00120012000A0006000200010000800040
+15CA:000000000000000000000000000040023FFC1008081004200240018000000000
+15CB:0000000000000000000000000000018002400420081010083FFC400200000000
+15CC:0000000008000400060005000480044004200420044004800500060004000800
+15CD:0000000008000400060005000480054005200520054004800500060004000800
+15CE:0000000008000400060005000480044005A005A0044004800500060004000800
+15CF:0000000000400080018002800480088010801080088004800280018000800040
+15D0:0000000000000000000000000000410421081110092005400380010000000000
+15D1:0000000000000000000000000000010003800540092011102108410400000000
+15D2:0000000004000200010000800040002007F00020004000800100020004000000
+15D3:000000000400020001000080044004200FF00420044000800100020004000000
+15D4:000000000400020001000080004006200FF00620004000800100020004000000
+15D5:000000000020004000800100020004000FE00400020001000080004000200000
+15D6:0000000000000000000000000000410421081FF0092005400380010000000000
+15D7:000000000000000000000000000001000380054009201FF02108410400000000
+15D8:0000000004000200010001800140012007F00120014001800100020004000000
+15D9:000000000400020001000180054005200FF00520054001800100020004000000
+15DA:00000000040002000100018001400D201FF00D20014001800100020004000000
+15DB:0000000000100020004000C00140024007F00240014000C00040002000100000
+15DC:000000000000000000001FF8100810081008100810081008081007E000000000
+15DD:0000000000000000000007E008101008100810081008100810081FF800000000
+15DE:00000000000000001FC0102010101010101010101010101010201FC000000000
+15DF:00000000000000001FC0102010101110111011101110101010201FC000000000
+15E0:00000000000000001FC0102010101010131013101010101010201FC000000000
+15E1:000000000000000007F00810101010101010101010101010081007F000000000
+15E2:000000000000000000001818142812481188100810081008081007E000000000
+15E3:0000000000000000000007E00810100810081008118812481428181800000000
+15E4:00000000000000001FE0101008080408020802080408080810101FE000000000
+15E5:00000000000000001FE0101008080448024802480448080810101FE000000000
+15E6:00000000000000001FE010100808040802C802C80408080810101FE000000000
+15E7:000000000000000007F80808101010201040104010201010080807F800000000
+15E8:0000000000000000000010081008100810081FF810081008081007E000000000
+15E9:0000000000000000000007E00810100810081FF8100810081008100800000000
+15EA:00000000000000001FC0042004100410041004100410041004201FC000000000
+15EB:00000000000000001FC0042004100490049004900490041004201FC000000000
+15EC:00000000000000001FC0042004100410059005900410041004201FC000000000
+15ED:000000000000000007F00840104010401040104010401040084007F000000000
+15EE:00000000101010107C00000000000000
+15EF:00000000000000000000410441044104410441044104410422881C7000000000
+15F0:000000000000000000001C702288410441044104410441044104410400000000
+15F1:000000000000000000000FE00010001000100FE00010001000100FE000000000
+15F2:000000000000000000000FE00010001002100FE00210001000100FE000000000
+15F3:000000000000000000000FE00010001006100FE00610001000100FE000000000
+15F4:0000000000000000000007F008000800080007F008000800080007F000000000
+15F5:000000000000000000007FFC41044104410441044104410422881C7000000000
+15F6:000000000000000000001C7022884104410441044104410441047FFC00000000
+15F7:000000000000000000000FE00810081008100FE00810081008100FE000000000
+15F8:000000000000000000000FE00810081008900FE00890081008100FE000000000
+15F9:000000000000000000000FE00810081009900FE00990081008100FE000000000
+15FA:0000000000000000000007F008100810081007F008100810081007F000000000
+15FB:00000000000000000000610C593447C4410441044104410422881C7000000000
+15FC:000000000000000000001C702288410441044104410447C45934610C00000000
+15FD:000000000000000000000FE00810041002100FE00210041008100FE000000000
+15FE:000000000000000000000FE00810041002500FE00250041008100FE000000000
+15FF:000000000000000000000FE00810041002D00FE002D0041008100FE000000000
+1600:0000000000000000000007F008100820084007F008400820081007F000000000
+1601:00000000442810000000000000000000
+1602:00000000004040404040444444380000
+1603:00000000003844444404040404040000
+1604:0000000000000000000000000000000000000FF0000800080008007000000000
+1605:0000000000000000000000000000000000000FF0000800480048000800700000
+1606:0000000000000000000000000000000000000FF0000800680068000800700000
+1607:000000000000000000000000000000000000070008000800080007F800000000
+1608:00000000000000000000400040004100410041044104410422881C7000000000
+1609:000000000000000000001C702288410441044104010401040004000400000000
+160A:000000000000000000001FE000100010001007E000100010001001E000000000
+160B:000000000000000000001FE000100410041007E004100410001001E000000000
+160C:000000000000000000001FE000100010031007E003100010001001E000000000
+160D:000000000000000000000F001000100010000FC01000100010000FF000000000
+160E:000000000000000000001070108810881088104810081008081007E000000000
+160F:0000000000000000000007E008101008100812081108110811080E0800000000
+1610:00000000000000000FE00010000800080008070808880808081007E000000000
+1611:00000000000000000FE00010000800080088078808880808081007E000000000
+1612:00000000000000000FE0001000080008018807C809880808081007E000000000
+1613:000000000000000003F00408080808880870080008000800040003F800000000
+1614:000000000000000007F8003000C00100020004E005100410022001C000000000
+1615:00000000000000000FF00600018000400020039004500410022001C000000000
+1616:000000000000000001C0022004100450039000200040018006000FF000000000
+1617:00000000000000000000000010E0111012481488148818901860100000000000
+1618:00000000000000000000000021E02210244828C829483108311020E000000000
+1619:00000000000000000000000021F02208246428F429643104310820F000000000
+161A:000000000000000000000000100018601890148814881248111010E000000000
+161B:0000000000000000000000000008061809181128112812480888070800000000
+161C:000000000000100008780580020002000400047004880408020801F000000000
+161D:00000000000000000F801040102011200E2000200040004001A01E1000080000
+161E:000000000000200011F00A08040404C40904090808F010001000100000000000
+161F:000000000000200011F00A08044404C40944090808F010001000100000000000
+1620:000000000000200011F00A08046404E40964090808F010001000100000000000
+1621:000000000000000000000E081108110811081210101008600790000800040000
+1622:000000000000000000000000000000003C04040404040404020801F000000000
+1623:000000000000000000000000000000000F801040202020202020203C00000000
+1624:0000000000000400040004000780004000200020002000200040078000000000
+1625:0000000000000400040004000780004001200120012001200040078000000000
+1626:0000000000000400040004000780004000200320032000200040078000000000
+1627:00000000000000200020002001E002000400040004000400020001E000000000
+1628:000000000000000000000000000020003C04240404040404020801F000000000
+1629:000000000000000000000000000000000F801040202020202024203C00040000
+162A:0000000000000E00040004000780004000200020002000200040078000000000
+162B:0000000000000E00040004000780004001200120012001200040078000000000
+162C:0000000000000E00040004000780004000200320032000200040078000000000
+162D:00000000000000E00040004003C004000800080008000800040003C000000000
+162E:000000000000000000001E78042008101008100810081008081007E000000000
+162F:0000000000000000000007E008101008100810081008081004201E7800000000
+1630:000000000000080008000FE00010000800080008000800100FE0080008000000
+1631:000000000000080008000FE00010008800880088008800100FE0080008000000
+1632:000000000000080008000FE00010000801880188000800100FE0080008000000
+1633:0000000000000008000803F804000800080008000800040003F8000800080000
+1634:00000000000000000000000000000002701E101210101010082007C000000000
+1635:0000000000000000000000000000000003E00410080808084808780E40000000
+1636:000000001C00080008000FE00010000800080008000800100FE0080008000000
+1637:000000001C00080008000FE00010008800880088008800100FE0080008000000
+1638:000000001C00080008000FE00010000801880188000800100FE0080008000000
+1639:0000000000380010001007F008001000100010001000080007F0001000100000
+163A:000000000000000000000002610E210A210821082108210821081EF000000000
+163B:0000000000000000000000000F78108410841084108410845084708640000000
+163C:0000000000001C0008000FE00010001000100FE00010001000100FE008000000
+163D:0000000000001C0008000FE00010001008100FE00810001000100FE008000000
+163E:0000000000001C0008000FE0001000100C100FE00C10001000100FE008000000
+163F:000000000000007000200FE01000100010000FE01000100010000FE000200000
+1640:000000000000000000001818042004200810100810081008081007E000000000
+1641:0000000000000000000007E00810100810081008081004200420181800000000
+1642:000000000000000023E02410180800080008000800081808241023E000000000
+1643:000000000000000023E02410180800880088008800881808241023E000000000
+1644:000000000000000023E02410180800080188018800081808241023E000000000
+1645:00000000000000000F88104820302000200020002000203010480F8800000000
+1646:000000007C0810207C00000000000000
+1647:000010107C0810207C10100000000000
+1648:00000000000000000000339809200920101020082008200810100FE000000000
+1649:000000000000000000000FE01010200820082008101009200920339800000000
+164A:00000000000023E024101808000820083808200800081808241023E000000000
+164B:00000000000023E024101808008820883888208800881808241023E000000000
+164C:00000000000023E024101808000820C839E820C800081808241023E000000000
+164D:0000000000000F881048203020002008203820082000203010480F8800000000
+164E:00000000000000000000000021081110111021082108210821081EF000000000
+164F:0000000000000000000000001EF0210821082108210811101110210800000000
+1650:00000000000009E006100010001000100FE0001000100010061009E000000000
+1651:00000000000009E006100010001002100FE0021000100010061009E000000000
+1652:00000000000009E006100010001003100FE0031000100010061009E000000000
+1653:0000000000000790086008000800080007F00800080008000860079000000000
+1654:000000000000000000000000210811101FF021082108210821081EF000000000
+1655:0000000000000000000000001EF021082108210821081FF01110210800000000
+1656:00000000000013E00C100408040804081FF00408040804080C1013E000000000
+1657:00000000000013E00C100408048804881FF00488048804080C1013E000000000
+1658:00000000000013E00C100408040804C81FF004C8040804080C1013E000000000
+1659:00000000000007C808301020102010200FF8102010201020083007C800000000
+165A:000010103C4038047810100000000000
+165B:000000000000000000000000238811101FF021082108210821081EF000000000
+165C:0000000000000000000000001EF021082108210821081FF01110238800000000
+165D:00000000000013E00C100408040814081FF01408040804080C1013E000000000
+165E:00000000000013E00C100408048814881FF01488048804080C1013E000000000
+165F:00000000000013E00C100408040814C81FF014C8040804080C1013E000000000
+1660:00000000000013E00C100408040814081FF01408040804080C1013E000000000
+1661:00000000000000000000000023881110111021082108210821081EF000000000
+1662:0000000000000000000000001EF0210821082108210811101110238800000000
+1663:00000000000009E006100010001008100FE0081000100010061009E000000000
+1664:00000000000009E00610001000100A100FE00A1000100010061009E000000000
+1665:00000000000009E00610001000100B100FE00B1000100010061009E000000000
+1666:0000000000000790086008000800081007F00810080008000860079000000000
+1667:00000000000000000000000023881110193025482388210821081EF000000000
+1668:0000000000000000000000001EF0210821082388254819301110238800000000
+1669:00000000000027E018100808040822083FF0220804080808181027E000000000
+166A:00000000000027E018100808044822483FF0224804480808181027E000000000
+166B:00000000000027E018100808040822683FF0226804080808181027E000000000
+166C:0000000000000FC810302020204020881FF820882040202010300FC800000000
+166D:00000000424224241818242442420000
+166E:00000000000000000044281028440000
+166F:000000000000000000001C70208820881C880478040800080008000800000000
+1670:00000000000000000000301C482248223C220482048203020002000200000000
+1671:00000000000000000000281C542254223E2202A002A001200020002000000000
+1672:00000000001800180000281C542254223E2202A002A001200020002000000000
+1673:000000000000000000002802540254023E02028202A201220022001C00000000
+1674:000000000006000600002802540254023E02028202A201220022001C00000000
+1675:000000000000000000002820542054203E2002A002A201220022001C00000000
+1676:000000000030003000002820542054203E2002A002A201220022001C00000000
+1677:0000000008102646F8087C0808080000
+1678:00000000402313087C40F84040400000
+1679:00606000402313087C40F84040400000
+167A:000000000808087C08F8462610080000
+167B:001818000808087C08F8462610080000
+167C:00000000404040F8407C0B1320400000
+167D:00606000404040F8407C0B1320400000
+167E:000000107C107C100000000000000000
+167F:000000007C007C000000000000000000
+1680:0000000000000000000000000000FFFF00000000000000000000000000000000
+1681:0000000000000000000000000000FFFF01000100010001000100010000000000
+1682:0000000000000000000000000000FFFF02800280028002800280028000000000
+1683:0000000000000000000000000000FFFF05400540054005400540054000000000
+1684:0000000000000000000000000000FFFF0AA00AA00AA00AA00AA00AA000000000
+1685:0000000000000000000000000000FFFF15501550155015501550155000000000
+1686:0000010001000100010001000100FFFF00000000000000000000000000000000
+1687:0000028002800280028002800280FFFF00000000000000000000000000000000
+1688:0000054005400540054005400540FFFF00000000000000000000000000000000
+1689:00000AA00AA00AA00AA00AA00AA0FFFF00000000000000000000000000000000
+168A:0000155015501550155015501550FFFF00000000000000000000000000000000
+168B:0000000000400040008000800100FFFF01000200020004000400000000000000
+168C:0000000000A000A0014001400280FFFF0280050005000A000A00000000000000
+168D:000000000150015002A002A00540FFFF05400A800A8015001500000000000000
+168E:0000000002A802A8055005500AA0FFFF0AA0154015402A802A80000000000000
+168F:00000000055405540AA80AA81550FFFF15502AA02AA055405540000000000000
+1690:0000000000000000000001000100FFFF01000100000000000000000000000000
+1691:0000000000000000000002800280FFFF02800280000000000000000000000000
+1692:0000000000000000000005400540FFFF05400540000000000000000000000000
+1693:000000000000000000000AA00AA0FFFF0AA00AA0000000000000000000000000
+1694:0000000000000000000015501550FFFF15501550000000000000000000000000
+1695:0000000004400440028002800100FFFF01000280028004400440000000000000
+1696:0000010001000280028004400440FFFF04400440028002800100010000000000
+1697:0000000000000000000000000000FFFF0800080009C0084008400FC000000000
+1698:0000000000000000000000000000FFFF1290092006C006C00920129024480000
+1699:05500FF805500FF805500FF80550FFFF00000000000000000000000000000000
+169A:0000000000000000000000000000FFFF00000FF0000000000000000000000000
+169B:000000002000100008000400020001FF02000400080010002000000000000000
+169C:0000000000040008001000200040FF8000400020001000080004000000000000
+169D:00007FFE7BCE73BE7B8E7BB671CE7FFE7FFE738E6DB671B67DB6738E7FFE0000
+169E:00007FFE7BCE73BE7B8E7BB671CE7FFE7FFE73866DBE718E7DBE73867FFE0000
+169F:00007FFE7BCE73BE7B8E7BB671CE7FFE7FFE73866DBE718E7DBE73BE7FFE0000
+16A0:0092A4C890A0C0808080808080808000
+16A1:00AA94A8D0A0C0808080808080808000
+16A2:0080C0A0908884848484848484848400
+16A3:0080C0A0908884829292929292929200
+16A4:0080C0A090888484B4B4848484848400
+16A5:0080C0A0908884C2A292929292929200
+16A6:00808080C0A090888890A0C080808000
+16A7:00808080C0A090A8A890A0C080808000
+16A8:0080C0A090C8A0908880808080808000
+16A9:0080C2A498C2A4988080808080808000
+16AA:0080C2A498C0A0908080808080808000
+16AB:0080C0A090C8A0908880808080808000
+16AC:00101090503090583412181412101000
+16AD:00101010101018141218141210101000
+16AE:00080808080818284818284808080808
+16AF:00101012141812345890305090101000
+16B0:00101012141810305090305090101000
+16B1:0080C0A09088848890A0A09088848200
+16B2:00000004081020402010080400000000
+16B3:008080808080808080C0A09088848200
+16B4:0082848890A0C0808080808080808000
+16B5:00B2B48890A0C0808080808080808000
+16B6:0042444850E0E0E04040404040404000
+16B7:00828244442828101028284444828200
+16B8:00828244442828545428284444828200
+16B9:0080C0A0908890A0C080808080808000
+16BA:008282828282E2928E82828282828200
+16BB:0082828282E2928EE2928E8282828200
+16BC:00101010925438103854921010101000
+16BD:00101010101038383810101010101000
+16BE:00101010905030101814121010101000
+16BF:00202020202030282422202020202000
+16C0:00101010905038383814121010101000
+16C1:00101010101010101010101010101000
+16C2:00101010101038383810101010101000
+16C3:00000010204088442204081000000000
+16C4:00101010103854929254381010101000
+16C5:00101010121418103050901010101000
+16C6:00080808080808182848880808080800
+16C7:00101814121010101010109050301000
+16C8:0082C4A89080808080808090A8C48200
+16C9:00929254543838101010101010101000
+16CA:00081020402010081020402010080000
+16CB:0040404040444C546444040404040400
+16CC:00101010101010100000000000000000
+16CD:00101010101038383800000000000000
+16CE:00101010109254381000000000000000
+16CF:00103854921010101010101010101000
+16D0:00081828488808080808080808080800
+16D1:000818284888081C1C1C080808080800
+16D2:00605048444850606050484448506000
+16D3:00404044485064485060404040404000
+16D4:00C0A090A890A0C0C0A090A890A0C000
+16D5:0082848890A0C08080C0A09088848200
+16D6:0082C6C6AAAA92928282828282828200
+16D7:0082C6AA92AAC6828282828282828200
+16D8:00929254543838101010101010101000
+16D9:00383838101010101010101010101000
+16DA:00406050484442404040404040404000
+16DB:00406050484442E0E0E0404040404000
+16DC:00000000102844828244281000000000
+16DD:00824428102844828244281028448200
+16DE:0082C6C6AAAA92929292AAAAC6C68200
+16DF:00001028448282442810284482000000
+16E0:0000820847102AA0124002000200020002000200020002000200020002000000
+16E1:00101010925438103854921010101000
+16E2:00000208031002A0024002000200020002000200020012002A00460082000000
+16E3:00101010101010101038385454929200
+16E4:00929254543838545438385454929200
+16E5:0082C6AA92AAC68282C6AA92AAC68200
+16E6:00101010101010101038385454929200
+16E7:00000000000000001010101010101000
+16E8:00103854921010101010109254381000
+16E9:00040C14244424140C04040404040400
+16EA:004040E040444C546444040E04040400
+16EB:00000000000038383800000000000000
+16EC:00007070700000000000707070000000
+16ED:000000383810D6FED610383800000000
+16EE:00101814121010305090101010101000
+16EF:00925454383810101010383854549200
+16F0:00101010385492929292925438101000
+16F1:00404040404040404854644442424200
+16F2:000808080888C8A89888808080808000
+16F3:00081C2A492A1C080808080808080800
+16F4:0040404044464C5464C4440404040400
+16F5:00081020100810201008102010080000
+16F6:00808040402224181028488404020200
+16F7:00404040407048444242424242424200
+16F8:00080808080808080808142222414100
+16F9:00007FFE7BCE73BE7B8E7BB671CE7FFE7FFE61CE6FB663C66FF66FCE7FFE0000
+16FA:00007FFE7BCE73BE7B8E7BB671CE7FFE7FFE61866FB663866FB66FB67FFE0000
+16FB:00007FFE7BCE73BE7B8E7BB671CE7FFE7FFE618E6FB6638E6FB66F8E7FFE0000
+16FC:00007FFE7BCE73BE7B8E7BB671CE7FFE7FFE61C66FBE63BE6FBE6FC67FFE0000
+16FD:00007FFE7BCE73BE7B8E7BB671CE7FFE7FFE618E6FB663B66FB66F8E7FFE0000
+16FE:00007FFE7BCE73BE7B8E7BB671CE7FFE7FFE61866FBE638E6FBE6F867FFE0000
+16FF:00007FFE7BCE73BE7B8E7BB671CE7FFE7FFE61866FBE638E6FBE6FBE7FFE0000
+1700:00000000000000006004100A7808081008100820084008800700000000000000
+1701:0000000000000000400030000FFC04020A8073400222001C0000000000000000
+1702:000000000000000003E0041000100020005000100010082007C0000000000000
+1703:0000000000000000400020021FFC0100010043FC3C0200020004000000000000
+1704:00000000000000001F6020900090011002900090009001103E0C000000000000
+1705:0000000000000000000000004E0C511221E201023E0C40000000000000000000
+1706:0000000000000000401C4022404220801F000800100010000000000000000000
+1707:000000000000000040FC43022C02303010480F80000000000000000000000000
+1708:000000000000000007C009201110121001000080010002000100000000000000
+1709:0000000000000000780C08120812101010182024204010800F00000000000000
+170A:00000000000000000FC010202010400840084008410822901C60000000000000
+170B:00000000000000000006000870080BD00C300820084008800700000000000000
+170C:00000000000000000004000A300A481C08100820084008800700000000000000
+170D:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE738E6DB66DB66DB6738E7FFE0000
+170E:0000000000000000407C43823C82010000800100010000800300000000000000
+170F:000000000000000001C00220041000080008010803080C900060000000000000
+1710:0000000000000000000C001238220824084A0442048202840318000000000000
+1711:0000000000000000001C106221822602180C0000000000000000000000000000
+1712:0000000C000C0000000000000000000000000000000000000000000000000000
+1713:0000000000000000000000000000000000000000000000000000001800180000
+1714:0000000000000000000000000000000000000000000000000000010003800100
+1715:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE7B8673BE7B867BF671867FFE0000
+1716:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE7BCE73BE7B8E7BB671CE7FFE0000
+1717:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE7B8673F67BEE7BDE71DE7FFE0000
+1718:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE7BCE73B67BCE7BB671CE7FFE0000
+1719:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE7BCE73B67BC67BF671CE7FFE0000
+171A:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE7B8673B67B867BB671B67FFE0000
+171B:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE7B8E73B67B8E7BB6718E7FFE0000
+171C:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE7BC673BE7BBE7BBE71C67FFE0000
+171D:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE7B8E73B67BB67BB6718E7FFE0000
+171E:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE7B8673BE7B8E7BBE71867FFE0000
+171F:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE7B8673BE7B8E7BBE71BE7FFE0000
+1720:000000000000000000040008181068200840088009000A000C00000000000000
+1721:000000000000000000040008181068200848089009200A000C00000000000000
+1722:000000000000000007E000400080010007F00020004000800100000000000000
+1723:000000000000000010E011100A10062005C00800080008000000000000000000
+1724:0000000000000000101010301050109011101210141018101010000000000000
+1725:0000000000000000101010201040108011401220140018001000000000000000
+1726:00000000000000001080118811881290129014A014A018C01080000000000000
+1727:00000000000000000808081008200040388009000A000C000800000000000000
+1728:000000000000000047183AE80208020802080208020802080208000000000000
+1729:0000000000000000000478080808081008180824084008800700000000000000
+172A:00000000000000003FC000400080008001000100020002000200000000000000
+172B:00000000000000000C0436080508089008500820085008880F00000000000000
+172C:00000000000000001008281848280848088809080A080C080808000000000000
+172D:000000000000000000000000000000001FF80000000000000000000000000000
+172E:0000000000000000210023002300250025002960299031102020000000000000
+172F:0000000000000000304048C208A4091811001200120014001800000000000000
+1730:000000000000000000200060186068A008A00924094C0A740C02000000000000
+1731:0000000000000000100808100820084008800900120014001800000000000000
+1732:00000000003C0000000000000000000000000000000000000000000000000000
+1733:0000000000000000000000000000000000000000000000000000000000780000
+1734:0000000000020002000200020002000200020002000200040004000800301FC0
+1735:0000000000000000004000800080010001000200020004000400000000000000
+1736:0000000000000000010802100210042004200840084010801080000000000000
+1737:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE63867DF671EE7DDE63DE7FFE0000
+1738:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE63CE7DB671CE7DB663CE7FFE0000
+1739:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE63CE7DB671C67DF663CE7FFE0000
+173A:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE63867DB671867DB663B67FFE0000
+173B:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE638E7DB6718E7DB6638E7FFE0000
+173C:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE63C67DBE71BE7DBE63C67FFE0000
+173D:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE638E7DB671B67DB6638E7FFE0000
+173E:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE63867DBE718E7DBE63867FFE0000
+173F:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE63867DBE718E7DBE63BE7FFE0000
+1740:000000080008001038103820082008400FC00F80000000000000000000000000
+1741:000000080008001038103820082008400FC00F8000001F001F00000000000000
+1742:00000000000000000F800F80008000F001E00040004000800080000000000000
+1743:000000000000000003F003F0000000000000000000001F801F80000000000000
+1744:000000000000000002000200040007F007F00010002000200040000000000000
+1745:000000000000000007F007F000200020007C007C00801F801F80000000000000
+1746:000000000000000011E211E2112222442244224444887CF87CF8000000000000
+1747:00000000000000000108010801083E103E100210042007E007E0000000000000
+1748:000000000000000007F807F80040008000800080010001000100000000000000
+1749:00000000000000003C3C3C3C042008400840084010801F801F80000000000000
+174A:000000000000000000000FE00FE000200020004000400FC00FC0000000000000
+174B:00000000000800080010041007F007F00820082008201FE01FC0000000000000
+174C:00000000000000003E7C3E7C024404880488048809100F100F10000000000000
+174D:00000000000000000000000000001FF81FF80000000000000000000000000000
+174E:000000000000000001F001F00110221022203FE03FE004000400080008000000
+174F:000000000400040008F808F80888110810101FF01FF000000000000000000000
+1750:000000003E003E000200040007C007C00040008000F800F80008001000100020
+1751:000000000000000002000200020004000400040008000FE00FE0000000000000
+1752:0000007C007C0000000000000000000000000000000000000000000000000000
+1753:000000000000000000000000000000000000000000000000000000F800F80000
+1754:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE61B66FB661867DF661F67FFE0000
+1755:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE61866FBE61867DF661867FFE0000
+1756:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE61CE6FBE618E7DB661CE7FFE0000
+1757:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE61866FF661EE7DDE61DE7FFE0000
+1758:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE61CE6FB661CE7DB661CE7FFE0000
+1759:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE61CE6FB661C67DF661CE7FFE0000
+175A:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE61866FB661867DB661B67FFE0000
+175B:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE618E6FB6618E7DB6618E7FFE0000
+175C:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE61C66FBE61BE7DBE61C67FFE0000
+175D:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE618E6FB661B67DB6618E7FFE0000
+175E:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE61866FBE618E7DBE61867FFE0000
+175F:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE61866FBE618E7DBE61BE7FFE0000
+1760:00000000000000000004000A3008481008100820084008801700200020001000
+1761:0000000000000010002600483008481008100820084008800700000000000000
+1762:00000000100810201008102010081000
+1763:0000000000000000301808200440028001000280044008201018000000000000
+1764:0000000000000FE0311840840100020001000080010002000100008001000000
+1765:000000000000000000000000401C20221FC22004400000000000000000000000
+1766:0000000000000000400020004000803840443F84400880004000200040000000
+1767:0000000000E00100020604083408481008100820084008800700000000000000
+1768:0000000000000FE0311841040100010001000100010001000100010001000000
+1769:0000000000000000000600083008481008100828084408820700000000000000
+176A:00000000000007F0080810042004200420042004200810100FE0000000000000
+176B:00000000000000000006000833C84C3008100820084008800700000000000000
+176C:0000000000000000000C00123012482408200840084008800700000000000000
+176D:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE738E6FB663B66DB6738E7FFE0000
+176E:0000000000000000000E00103010482008200854085A08AC0716000800000000
+176F:000000000000000003C00C20102020004000400041FC46023802000000000000
+1770:0000000000000000002000503050489008A009180910090C0608000000000000
+1771:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE61EE7DCE7BEE77EE77C67FFE0000
+1772:0000000800040008000000000000000000000000000000000000000000000000
+1773:0000000000000000000000000000000000000000000000000010000800100000
+1774:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE61B67DB67B8677F677F67FFE0000
+1775:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE61867DBE7B8677F677867FFE0000
+1776:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE61CE7DBE7B8E77B677CE7FFE0000
+1777:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE61867DF67BEE77DE77DE7FFE0000
+1778:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE61CE7DB67BCE77B677CE7FFE0000
+1779:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE61CE7DB67BC677F677CE7FFE0000
+177A:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE61867DB67B8677B677B67FFE0000
+177B:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE618E7DB67B8E77B6778E7FFE0000
+177C:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE61C67DBE7BBE77BE77C67FFE0000
+177D:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE618E7DB67BB677B6778E7FFE0000
+177E:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE61867DBE7B8E77BE77867FFE0000
+177F:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE61867DBE7B8E77BE77BE7FFE0000
+1780:00000000000000000760089004000FF008100810081008100810000000000000
+1781:0000000000000000038004400420022000400380042004400380000000000000
+1782:00000000000000000760089004000FF00810081009900A900C10000000000000
+1783:000000000000000019982A202B300910091009100910091006E0000000000000
+1784:0000000004000200028003400180004006200A200AA003600220000000000000
+1785:00000000000000000EC011201000183008500850083008100FF0000000000000
+1786:0000000000000000076008901000087008901E702910291010E0000000000000
+1787:00000000000000200310049008600C0004400440054006C00440000000000000
+1788:00000000000000001C66228822CC2244224432442A442A4431B8000000000000
+1789:00000000000000000DB8124410441044104418441444144418440010070808F0
+178A:00000000038000400320042003C000000220022002A003600220000000000000
+178B:00000010002800080C18142014300410041004100410041003E0000000000000
+178C:00000000000000000EE011101010082000C003100C3010300FD0000000000000
+178D:00000000000000001B062488208C2084208431C42AA42AA43198000000000000
+178E:00000000000000001C38224422642224222432242AA42B643224000000000000
+178F:00000000000000000760089004000FE008200C200A200A200C20000000000000
+1790:0000000000200010031004E008000C6004A004A00460042007E0000000000000
+1791:000000000000000003F8040408080860049003E0008008800F80000000000000
+1792:00000000000000000EC01120100018300850085009300A900C70000000000000
+1793:000000000000000001C002200440040003C00040054006C00440000000000000
+1794:0000000000000000061808200C300410041004100410041003E0000000000000
+1795:000000000020031004900860080008300850085009300A900C70000000000000
+1796:0000000000000000077008880808080808080C080A080A080C08000000000000
+1797:0000000000000000076008900400000003F002100A1012100E10000000000000
+1798:00000000000000000C3010401860082008200FE00820082007C0000000000000
+1799:000000000000000008CC15101598188810881088108810881F70000000000000
+179A:000000000000000000C001000180008000800080028004800300000000000000
+179B:00000000000000000F0C10901098108810881888148814881870000000000000
+179C:0000004000A0002000E001200180008000800080028004800300000000000000
+179D:00000000000000000760089004000FE0082008A80A700D200C20000000000000
+179E:00000000000000000C3010401860082008A808700820082007C0000000000000
+179F:00000000000000000C18102018300F10111019101510151018E0000000000000
+17A0:00000000000000000C78108418C4084408440844084408440784000000000000
+17A1:00000000000000001FC62028404C430424841F0444047C0401C40254016C0044
+17A2:0000000000000000061808200C30041007F00410145024901C70000000000000
+17A3:0000000000000000061808200C30041007F00410145024901C70000000000000
+17A4:00000000000000000C78108418C408440FC4084429444A4439C4000000000000
+17A5:000000000020031004900260000007F004100610051005100610000000000000
+17A6:00000004000A0002000E00121F9810881C8812881C8800081F881888148818F8
+17A7:0000000000000000038004400420022000400390043004500390000000000000
+17A8:000000000000000007600890040003C0042000400390043003D0000000000000
+17A9:00000000000000000E0011001080089001100E5010D011500E50000000000000
+17AA:010000800040074008C00640010003C0042000400390043003D0000000000000
+17AB:0000000000000000061808200C300410041004100410041003E00030070808F0
+17AC:0000000000000000061808200C300410041004100410041003E00030070808F6
+17AD:0000000000000000077008880808080808080C080A080A080C080060071008E0
+17AE:0000000000000000077008880808080808080C080A080A080C080060071008EC
+17AF:0000000000000000030001000170019000100710095005B00110000000000000
+17B0:000000000000000007700888080808080C080A080A080C08000003F804900360
+17B1:000000000000038004400620010003C0042000400390043003D0000000000000
+17B2:000000000000001007E0080008E00910091008200810081007E0000000000000
+17B3:000000000000038804500620010003C0042000400390043003D0000000000000
+17B4:AAAA0001A5442945B1282929A510000180000871948822A9BE98227980045555
+17B5:AAAA0001A5442945B1282929A51000018000081194282245BE7C224580005555
+17B6:000000000000001E002200020002000200020002000200020002000000000000
+17B7:00000380044003F8000000000000000000000000000000000000000000000000
+17B8:00000390045003F0000000000000000000000000000000000000000000000000
+17B9:00000390046803F8000000000000000000000000000000000000000000000000
+17BA:005003D0047003F8000000000000000000000000000000000000000000000000
+17BB:00000000000000000000000000010101
+17BC:00000000000000000000000000000000000000000000000000000240024003C0
+17BD:0000000000000000000000000000000000000000000000000000022002A00360
+17BE:00000390045003F0C000A000800080008000C000A000A000C000000000000000
+17BF:005003D0047003FEC001A001800180018001C001A001A001C0011007080107FE
+17C0:001800080010003EC001A001800180018001C001A001A001C0011007080107FE
+17C1:0000000000000000C000A000800080008000C000A000A000C000000000000000
+17C2:1800880070000000C000A000800080008000C000A000A000C000000000000000
+17C3:9800640044001800C000A000800080008000C000A000A000C000000000000000
+17C4:000000000000001EC022A002800280028002C002A002A002C002000000000000
+17C5:000400020002001EC022A002800280028002C002A002A002C002000000000000
+17C6:0180024001800000000000000000000000000000000000000000000000000000
+17C7:0000000000000000000200050005000200000002000500050002000000000000
+17C8:0000000000000000000000000000000200000002000000000000000000000000
+17C9:0000014001400140000000000000000000000000000000000000000000000000
+17CA:0760089004000000000000000000000000000000000000000000000000000000
+17CB:00010101000000000000000000000000
+17CC:0388045002200400000000000000000000000000000000000000000000000000
+17CD:03880450022001A0000000000000000000000000000000000000000000000000
+17CE:008003E000800080000000000000000000000000000000000000000000000000
+17CF:01E6021C02A00360000000000000000000000000000000000000000000000000
+17D0:000C004400380000000000000000000000000000000000000000000000000000
+17D1:00000FF000000000000000000000000000000000000000000000000000000000
+17D2:0000000000000000000000000000000000000000000000000100038001000000
+17D3:0380044003800000000000000000000000000000000000000000000000000000
+17D4:00000000000000000180098012800C8000800080008000800080000000000000
+17D5:0000000000000000068026804A80328002800280028002800280000000000000
+17D6:00000000304830007800304830000000
+17D7:00000000000000001EF0210838082408380800080008200820081FF000000000
+17D8:0000000000000000331BB4AB54A5149114911651155115511631000000000000
+17D9:00000000000000000380044009200AA00AA00AA0092004400380000000000000
+17DA:00000000000000000000000071008A88AA959252445038200000000000000000
+17DB:000000000000000000C001000180008003E00080028004800300000000000000
+17DC:00000000001C22201C02122418000000
+17DD:000003C004200810000000000000000000000000000000000000000000000000
+17DE:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE63866DBE6D8E6DBE63867FFE0000
+17DF:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE63866DBE6D8E6DBE63BE7FFE0000
+17E0:000000000000000007C0082008200820082008200820082007C0000000000000
+17E1:000000000000000007C00820091006100010001000100E1011E0000000000000
+17E2:0000200020002000277028882C082A082A082C08200820081FF0000000000000
+17E3:00000000000000001EF021082108210821083108290829083108000000000000
+17E4:0000000000000004000803E8041808C0092008800840082007E0000000000000
+17E5:00000600091009200A2007E0040008C0092008800840082007E0000000000000
+17E6:0000000000000000180008000BE00C10001006100910082007C0000000000000
+17E7:00000002000400041DC422242024202420243024282428243018000000000000
+17E8:00000008001007D0083010001030105010901050101013D00C30000000000000
+17E9:000000000000000000080F1010D0103008001F00208024401830000000000000
+17EA:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE61866FB663866FB661B67FFE0000
+17EB:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE618E6FB6638E6FB6618E7FFE0000
+17EC:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE61C66FBE63BE6FBE61C67FFE0000
+17ED:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE618E6FB663B66FB6618E7FFE0000
+17EE:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE61866FBE638E6FBE61867FFE0000
+17EF:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE61866FBE638E6FBE61BE7FFE0000
+17F0:00000000000000003048484830000000
+17F1:00000000000000001028284444000000
+17F2:00000000000000002020202020000000
+17F3:00000000000000000000245A89000000
+17F4:00000000000000004444282810000000
+17F5:00000000000000442810282810000000
+17F6:00000000000000002010100808000000
+17F7:00000000000000000000225488000000
+17F8:00000000000000000810102020000000
+17F9:00000000000000182040780418000000
+17FA:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE61866FB663866FB66FB67FFE0000
+17FB:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE618E6FB6638E6FB66F8E7FFE0000
+17FC:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE61C66FBE63BE6FBE6FC67FFE0000
+17FD:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE618E6FB663B66FB66F8E7FFE0000
+17FE:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE61866FBE638E6FBE6F867FFE0000
+17FF:00007FFE7B8673F67BEE7BDE71DE7FFE7FFE61866FBE638E6FBE6FBE7FFE0000
+1800:0000000003800440042004200420032000200040008001000200020002000000
+1801:0000000000000000000000000000666666660000000000000000000000000000
+1802:000000000000000000000080008001C003E001C0008000800000000000000000
+1803:00000000000000000000081008101C383E7C1C38081008100000000000000000
+1804:0000000000000000018001800000000000000000018001800000000000000000
+1805:00000080008001C003E011C81088389C7C3E389C108811C803E001C000800080
+1806:000000000000000000000000000007E007E00000000000000000000000000000
+1807:000000000000000000000000000007E007E00180018000800000000000000000
+1808:0000000000000400020001000180018001800180010002000400000000000000
+1809:0000000000001040082004100618061806180618041008201040000000000000
+180A:0000000000000000000000000000038003800000000000000000000000000000
+180B:AAAA0001BC442045B8282029A010000180001C11A03018118410387D80005555
+180C:AAAA0001BC442045B8282029A010000180001C79A00418398440387D80005555
+180D:AAAA0001BC442045B8282029A010000180001C79A00418398404387980005555
+180E:AAAA0001A2443645AA282229A2100001800001E1820001C1802003C180005555
+180F:00007FFE7BCE73B67BCE7BB671CE7FFE7FFE73866DBE6D8E6DBE73BE7FFE0000
+1810:0000000003C0042004200810081008100810081008100420042003C000000000
+1811:0000000003C0042004200810081008100410041000100820042003C000000000
+1812:0000000003C00420042008100810081008100812081204240438020000000000
+1813:00000000034004A004A008900890089008900812081204240438020000000000
+1814:0000000003C0042000200210041004100810081008100420042003C000000000
+1815:0000000000000020002000500050004808480844084404420482030000000000
+1816:0000000003C0040004000880088008E00890089008100420042003C000000000
+1817:0000000007E00810031004880488088808880888088804900490006000000000
+1818:000000000000004000400080008001000100021002100420042007C000000000
+1819:0000000003C0042004200820084008400860080008000420042003C000000000
+181A:00007FFE7BCE73B67BCE7BB671CE7FFE7FFE7B8673B67B867BB671B67FFE0000
+181B:00007FFE7BCE73B67BCE7BB671CE7FFE7FFE7B8E73B67B8E7BB6718E7FFE0000
+181C:00007FFE7BCE73B67BCE7BB671CE7FFE7FFE7BC673BE7BBE7BBE71C67FFE0000
+181D:00007FFE7BCE73B67BCE7BB671CE7FFE7FFE7B8E73B67BB67BB6718E7FFE0000
+181E:00007FFE7BCE73B67BCE7BB671CE7FFE7FFE7B8673BE7B8E7BBE71867FFE0000
+181F:00007FFE7BCE73B67BCE7BB671CE7FFE7FFE7B8673BE7B8E7BBE71BE7FFE0000
+1820:00000000000030205010101010101E201E2012201240114000C0000000000000
+1821:00000000000030005000100010001F801FC01040104010400040018001000000
+1822:00000000000031C05220122012201E001E001200120011000080004000000000
+1823:00000000000030005000100010001FE01FE011201120112000C0000000000000
+1824:00000000000030005000100010001FF81FF811201120112000C0000000000000
+1825:00000000000030005000100010001FFC1FFE11261122112200C0000000000000
+1826:00000000000030005000100010001FFE1FFE11281124112200C0000000000000
+1827:00000000000030005000100010001FFC1FFE11061102112200C0000000000000
+1828:00000000000030005000100010001C001C001000100010000000100010000000
+1829:00000000007000880108010801081F001F001900110010800040000000000000
+182A:0000000000000F801040104010401E401E401200120012000C00000000000000
+182B:0000000000000F801040104010401E401E400240020002001E001C0000000000
+182C:00000000000003800440044004401FF01FF00440024006400040000000000000
+182D:00000000000003800440044004401FF01FF00440024006400040060000000600
+182E:00000400040018001000300050001C001C001000100010000000000000000000
+182F:00004000400030001000300050001C001C001000100010000000000000000000
+1830:0000000000000C00140014005400270007000400040004000000000000000000
+1831:00001B001B0000000C0014001400570027000400040004000000000000000000
+1832:0000000000000000100028004400878047802E00140004000000000000000000
+1833:00000000000000001000100010001FC01FC01000120015000900060000000000
+1834:00000000000000000000000000001FF01FF00040004003C007C0040000000000
+1835:00000000000000000000000000001F001F001000100008000800040004000000
+1836:00000000000000000000000000001F001F001000100008000400080000000000
+1837:00000000000000000000000000001F001F001000100008000800140024000000
+1838:00000000000000000000000000001F001F001000100012000C00000000000000
+1839:0000000000000F801040104010401E401E401200120012000C00100010000000
+183A:0000000000000F00108010801080108010801000100018001400140000000000
+183B:0000000000000F001080108010801C801C801000100018001400140000000000
+183C:00000000000000000000000000001FF01FF00100010001C007200EC000000000
+183D:00000000000000000000000000001FF01FF001000100010007200EC000000000
+183E:00000000000030005000100010001E781E781240124012200140008000000000
+183F:000000001800240044004C005400470047004400440050004800300000000000
+1840:00000000400030001000300050001E781E781240124012200140008000000000
+1841:000000000000000000000000000013C013C01200120011000A00040000000000
+1842:00000000000000000000000000001FFC1FFC1290129012900C60000000000000
+1843:00000000000000001000100010001C001C000000000000000000000000000000
+1844:00000000000030005000100010001FC01FC01200120012001180000000000000
+1845:00000000030032805240124012201E201E201220124012400000000000000000
+1846:00000000000030005000100010001FC01FC012401240124011C0000000000000
+1847:00000000000031E05210120812081FC81FC81240124012401180008000600000
+1848:00000000000030005100108010801FC01FC012401240124011C0000000000000
+1849:00000000000031E05210120812081FC81FC81240124012401180000000000000
+184A:00000000000000000000000000001FF81FFC1A04120412040188003000200000
+184B:00000000000000000000000000001FC01FE01220122012200C40018001000000
+184C:00000000000011801240142014207C207C201400140012001E00000000000000
+184D:00000000000030005000100010001FC01FC01B00120012000000120012000000
+184E:00000000000030005000100010001FC01FC01B00120000000C0012000C000000
+184F:0000000001800880148013001100310031000900050003000000000000000000
+1850:00000000000000000C00120012001380138012000A0006000000000000000000
+1851:00000000000000000000000000001F001F00140012000A000C00000000000000
+1852:00000000000000000000000000001FC01FC00100010001000E0012000C000000
+1853:00000000000000000000000000001FC01FC00100010001000600080007000000
+1854:00000000000000000000000000001FC01FC00100010001000600080000000000
+1855:00000000000000000000000000001E001E001000100008000800000000000000
+1856:00000000000000000000000000001F801F80100010000E000900060000000000
+1857:0000070008800840084008400800080008000800040002000600000000000000
+1858:000007000880084008400840080018001800080004000A000000000000000000
+1859:00000000000000000000000000001E781E7C1A4C124412240140008000000000
+185A:00000000070008801040104010401E701E701240124012400C80010003C00000
+185B:00000000000002001E00120012001F801F8010001000100012000C0000000000
+185C:00000000000000000000000000001FC01FC001000F000F000900030004000000
+185D:000000800040108011000100020012001200120012000A000A00060000000000
+185E:00000000000000000000000000001FC01FC01A00120011000100008000000000
+185F:00000000000000002200140008003F803F801800100010000000000000000000
+1860:00000000008031005100100010001FC01FC01240124012401180000000000000
+1861:00000000000000000000000000001FF01FF01280124012200C00000000000000
+1862:00000000000000000000000000001FF01FF01B10121012100020004000400000
+1863:000001000080010001000200020012001200120012400A800600004000800000
+1864:00000000031004A0048008400840387038700840084004801C80000000000000
+1865:00000060039004E0048008400840387838780840084004801C80000000000000
+1866:0000000000000D801240124010401E401E401200120012000C00000000000000
+1867:000000000000030005001500090001C001C00100110009000500000000000000
+1868:0000000001C002200420022001200FF80FF80020002000200000000000000000
+1869:0000000000000100120028004400878047802E00140004000000000000000000
+186A:00000000000000000000000000003F003F001000080004000400040018000000
+186B:000000000C00120002000100010001F801F80100010000800090006000000000
+186C:00000100020000000E0011001080108010801000180014001400000000000000
+186D:000006000900060000000E001100108010801000180014001400000000000000
+186E:0000040004001F0004000C001400178057802400040004000000000000000000
+186F:000000001F00040004000C001400178057802400040004000000000000000000
+1870:00000000000010001000100010001C001C001000100010001000000000000000
+1871:00000000000006000900060000001FC01FC00100010001000600080000000000
+1872:0000000000000C0012000C0000003F003F001000080004000400040018000000
+1873:00000000000000000000000000001FE01FE01100110008800880044004400000
+1874:00000008000400080010001000201F201F201920112010A000A0006001080210
+1875:00000000000000000000000000001F001F801180108008801400140000000000
+1876:000000000C0012000200010001003FF83FF80100010000800090006000000000
+1877:00000000000006000900060000001F801F801000100008000800000000000000
+1878:0000000000000D800D80000000001FC01FC00100010001000600080000000000
+1879:00007FFE7BCE73B67BCE7BB671CE7FFE7FFE61CE7DB67BC677F677CE7FFE0000
+187A:00007FFE7BCE73B67BCE7BB671CE7FFE7FFE61867DB67B8677B677B67FFE0000
+187B:00007FFE7BCE73B67BCE7BB671CE7FFE7FFE618E7DB67B8E77B6778E7FFE0000
+187C:00007FFE7BCE73B67BCE7BB671CE7FFE7FFE61C67DBE7BBE77BE77C67FFE0000
+187D:00007FFE7BCE73B67BCE7BB671CE7FFE7FFE618E7DB67BB677B6778E7FFE0000
+187E:00007FFE7BCE73B67BCE7BB671CE7FFE7FFE61867DBE7B8E77BE77867FFE0000
+187F:00007FFE7BCE73B67BCE7BB671CE7FFE7FFE61867DBE7B8E77BE77BE7FFE0000
+1880:000000000000020001000C8012C012C012C012C00C8001000200000000000000
+1881:0000000000000000000000000CC0132013200CC0000000000000000000000000
+1882:0000000000000000104018C0154012401240154018C010400000000000000000
+1883:0000000000000E0011000100010002001C0002000100010011000E0000000000
+1884:0000000000000E001100100010000800070008001000100011000E0000000000
+1885:000000000000000000000C62129421082108252818C800000000000000000000
+1886:000000040EE811101550089000040EE811101550089000040EE8111015500890
+1887:00000000000030005000100010001FF81FFC1004100810101000000000000000
+1888:0000000000C031205220140014001C001C001400140012401180000000000000
+1889:000000000600090008801080108010F010F01000100008000800040000000000
+188A:00000000000030005180124012201E201E001200120012000100100020000000
+188B:00000000000000000000000000001FF01FF00100010007C00820082000C00000
+188C:00000000000000000000000000003F003F000800040012000A00060000000000
+188D:00000000000000000000000000001FFC1FFC131012A012400C00000000000000
+188E:00000000000000000000000000001FF01FF01000118009400940060000000000
+188F:00000000000000000000000000001FF01FF01000100008000E00060000000000
+1890:00000000000000000000000000001FC01FC01400120009000900060000000000
+1891:00000000000000000000000000001F801F801000120009000A00040000000000
+1892:00000000060009000880104010401F401F000100010009000600000000000000
+1893:00000000060009000880104010401F401F00010001000E00100012000C000000
+1894:0000070008800840084008401040107010701040104008000000028002800000
+1895:0000070008800840084008400840087008700840084008000880070000000000
+1896:000000000000000000000000000007C007C00040004003800040018000000000
+1897:0000000000000700088008400840084008000800088008800700000000000000
+1898:00000000000000000000000000001FC01FC0140012000B800C00000000000000
+1899:00000000000000000F001080108013E017E01480148013000800078000000000
+189A:000000480054064809000880088078FE78FE0880088008003800000000000000
+189B:00000000000030005000100010001FC01FC01000130014801300000000000000
+189C:00000E0011000E001F000C000C00178017805400240004000000000000000000
+189D:00000000000000601E900C600C0017F817F85400240004000000000000000000
+189E:00000000100011800A400980040007F807F80400020002000100010000000000
+189F:00000000000004400AA0044000001FF81FF81000080008000400040000000000
+18A0:00000000000001000200020000001F801F801400120009000A00040000000000
+18A1:00000000024002A012402800440087F047F02E00140004000000000000000000
+18A2:000000000000030005001500090001C001C00100010000000000050005000000
+18A3:000000001000100008000800040007F807F80400020002000100010000000000
+18A4:000003000480030000000300050015C009C00100110009000500000000000000
+18A5:000003000480030000000300050015C009C00100010001000100000000000000
+18A6:00000000000000000000000000001F001F0011000A0004000000000000000000
+18A7:00000000000000000000000000001780178012000A000900050005000E000000
+18A8:0000000000300E481130108010801EFC1EFC1200120012000C00000000000000
+18A9:0000000000000000000000000000000000000000000000000000600010000800
+18AA:00004000400033001480330050001FC01FC01000100010001000000000000000
+18AB:00007FFE7BCE73B67BCE7BB671CE7FFE7FFE618E6DB6618E6DB66D8E7FFE0000
+18AC:00007FFE7BCE73B67BCE7BB671CE7FFE7FFE61C66DBE61BE6DBE6DC67FFE0000
+18AD:00007FFE7BCE73B67BCE7BB671CE7FFE7FFE618E6DB661B66DB66D8E7FFE0000
+18AE:00007FFE7BCE73B67BCE7BB671CE7FFE7FFE61866DBE618E6DBE6D867FFE0000
+18AF:00007FFE7BCE73B67BCE7BB671CE7FFE7FFE61866DBE618E6DBE6DBE7FFE0000
+18B0:0300048004801B00140012001100108010401040108011001200140018000000
+18B1:06000900090006C0014002400440084010401040084004400240014000C00000
+18B2:18C024C0240018C0014002400440084010401040084004400240014000C00000
+18B3:01800240024001B0005000900110021064106410021001100090005000300000
+18B4:18242458201008040202040810204000
+18B5:1824241A040810204040201008040200
+18B6:18242458201008046262040810204000
+18B7:024002400180000007F00800100010001000100010001000080007F000000000
+18B8:30484830004040404078444444380000
+18B9:0C12120C00101010D0DE1111110E0000
+18BA:304848300040404040404040407C0000
+18BB:000000000000000000C00120012000C0000000E00110011001101FE000000000
+18BC:0000000000000000060009000900060000000E001100110011000FF000000000
+18BD:0000000000000000060009000900060000000E001000100010000FF000000000
+18BE:18242418000404041C20404040400000
+18BF:30484830004040407008040404040000
+18C0:0000000000000180024002400180000000000C601210111010900C6000000000
+18C1:0000000000000180024002400180000000000C601090111012100C6000000000
+18C2:0000000000000060009000900060000000000318348434440424031800000000
+18C3:182424180008080808F8402010080000
+18C4:6090906000404040407C081020400000
+18C5:18242418003E404040403E0202020000
+18C6:00000000000000000000000000000000000003FC344034400440038000000000
+18C7:0000000000000000000000000000000000001FE0220C220C22001C0000000000
+18C8:00000000000000000000000001800180000003FC344034400440038000000000
+18C9:0000000000000000000000000C000C0000001FE0220C220C22001C0000000000
+18CA:000000000000000000000000000000000000003830443044004407F800000000
+18CB:00000000000000000000000000000000000001C0022C022C02203FC000000000
+18CC:000000000000000000000000003000300000003830443044004407F800000000
+18CD:00000000000000000000000001800180000001C0022C022C02203FC000000000
+18CE:000000000000000000000000000000001E04020462046204010800F000000000
+18CF:0000000000000000000000000000000003C00420681068100810081E00000000
+18D0:0000000000000000000001800180000003C00420681068100810081E00000000
+18D1:000000000000000003C00020001000101810182003C002000200020000000000
+18D2:000001800180000003C00020001000101810182003C002000200020000000000
+18D3:000000000000000000F00100020002001A00190000F000100010001000000000
+18D4:00000010102828444400000000000000
+18D5:00000000384444444400000000000000
+18D6:00000000304848704040000000000000
+18D7:00000000304848404040000000000000
+18D8:00000000784040404040000000000000
+18D9:000000003E4848300000000000000000
+18DA:00000000080808106040400000000000
+18DB:0000000062928C000000000000000000
+18DC:00000008C8D414223E00000000000000
+18DD:0000002026565088F800000000000000
+18DE:18242418000000000000000000000000
+18DF:00181800000000000000000000000000
+18E0:000000000000000000000000000000007816081608100810042003C000000000
+18E1:0000060006000000040004000400078000400020002000200040078000000000
+18E2:000000600060000000200020002001E00200040004000400020001E000000000
+18E3:000000000000000000000E201120112C112C1220102010200840078000000000
+18E4:0000000000000000000000000FC01020202C222C21C0200010000FE000000000
+18E5:0000000000000000000022202220222C222C22202020202010400F8000000000
+18E6:000000000600060000001FC00020001000101F100010001000201FC000000000
+18E7:0000000000C000C0000007F008001000100011F010001000080007F000000000
+18E8:000000000000000000000E001100110011000F30053005000900090000000000
+18E9:0000060600090905050F1111110E0000
+18EA:000000000000000000000F001080128012800C98009800800080008000000000
+18EB:000006060002020202324A4A423C0000
+18EC:0000000000300030000000300050005008900890071000100010001000000000
+18ED:00000000000000000000000042104210421642164210421042103DE000000000
+18EE:000000000300030000000FE00010001000100FE00010001000100FE000000000
+18EF:0000000000C000C0000007F008000800080007F008000800080007F000000000
+18F0:000000000000000000001FC020002000200C1FCC2000200020001FC000000000
+18F1:00000180018000000FF00600018000400020039004500410022001C000000000
+18F2:00000000000000000000000000201860246C44AC44A0492022201C2000000000
+18F3:00000030101010103800000000000000
+18F4:00000000586440404000000000000000
+18F5:000000003C4038047800000000000000
+18F6:00007FFE7BCE73B67BCE7BB671CE7FFE7FFE61CE6FBE638E6FB66FCE7FFE0000
+18F7:00007FFE7BCE73B67BCE7BB671CE7FFE7FFE61866FF663EE6FDE6FDE7FFE0000
+18F8:00007FFE7BCE73B67BCE7BB671CE7FFE7FFE61CE6FB663CE6FB66FCE7FFE0000
+18F9:00007FFE7BCE73B67BCE7BB671CE7FFE7FFE61CE6FB663C66FF66FCE7FFE0000
+18FA:00007FFE7BCE73B67BCE7BB671CE7FFE7FFE61866FB663866FB66FB67FFE0000
+18FB:00007FFE7BCE73B67BCE7BB671CE7FFE7FFE618E6FB6638E6FB66F8E7FFE0000
+18FC:00007FFE7BCE73B67BCE7BB671CE7FFE7FFE61C66FBE63BE6FBE6FC67FFE0000
+18FD:00007FFE7BCE73B67BCE7BB671CE7FFE7FFE618E6FB663B66FB66F8E7FFE0000
+18FE:00007FFE7BCE73B67BCE7BB671CE7FFE7FFE61866FBE638E6FBE6F867FFE0000
+18FF:00007FFE7BCE73B67BCE7BB671CE7FFE7FFE61866FBE638E6FBE6FBE7FFE0000
+1900:000000000000FF801080208040807C800880108020804E807180000000000000
+1901:0000000000003E00020002000400040008000800100010001F00000000000000
+1902:0000000000003F8042008400840084008400840084004A403180000000000000
+1903:0000000000007880090012002400780014002200220022001C00000000000000
+1904:000000000000FF80208020802080208011800E80008000800080000000000000
+1905:0000000000005E004480494050805C0042004100210022001C00000000000000
+1906:0000000000007080088004800280028002802280528054803880000000000000
+1907:0000000000007F8008001000200078004E004000408021001E00000000000000
+1908:0000000000007F80008078800480048078800080008000800080000000000000
+1909:0000000000001F002000200020001F0020002000200020001F00020004000800
+190A:0000000000007F800400040034004C0046004940308001400240000000000000
+190B:0000000000001F00208040800100060001000080408020801F00000000000000
+190C:0000000000007C0004000400040004003F804440444044403880000000000000
+190D:00000000000060C01F0004000400070000800040404020801F00000000000000
+190E:0000000000007C80188020802080188020802080208011000E00000000000000
+190F:0000000000007C0004000400080008001E001000200020003E00000000000000
+1910:0000000000002200410041008080808080808080490049003600000000000000
+1911:0000000000000000770088800880088008800880888088807700000000000000
+1912:00000000000060C01F00040004001C0020004180424022801F00000000000000
+1913:0000000000003880448044804880508051802E80008000800080000000000000
+1914:0000000000007F80088008801080108020804080788006800180000000000000
+1915:0000000000007E00040008001C00020032004A003C0008000000000000000000
+1916:0000000000007C00040004000800080018001800240022004100000000000000
+1917:00000000000031802E80208010800E8000800080008000800080000000000000
+1918:0000000000001080308050809080108009800680008000800080000000000000
+1919:00000000000043C0420042004200420042004200420042003C00000000000000
+191A:0000000000001D002300210021002100210023001D0001000100000000000000
+191B:0000000000003F80448044804480448044803880008000800080000000000000
+191C:0000000000001F002100420044004F0040804000200010800F00000000000000
+191D:0000000000007F80100010001E00110011000100010001000100000000000000
+191E:0000000000007F80100010001F00010001001100290025001E00010000000000
+191F:00007FFE7BCE73B67BC67BF671CE7FFE7FFE7B8673BE7B8E7BBE71BE7FFE0000
+1920:300048003F800000000000000000000000000000000000000000000000000000
+1921:0000003C00420004000700000000000000000000000000000000000000000000
+1922:000000000000000000000000000000000000000000000000000030804B003C00
+1923:000000000000000800140014000C000400040008000800100010000000000000
+1924:0000000000000012002D002D001B000900090012001200240024000000000000
+1925:300048003F80000800140014000C000400040008000800100010000000000000
+1926:300048003F800012002D002D001B000900090012001200240024000000000000
+1927:6000180006000000000000000000000000000000000000000000000000000000
+1928:008031000A000400000000000000000000000000000000000000000000000000
+1929:0000000000000000000000000000000000000000000100220052000C00000000
+192A:0000000000000000000000000000000000000000000000000000004000A00110
+192B:00000000000000000000000000000072000A00320046003A0002000000000000
+192C:00007FFE7BCE73B67BC67BF671CE7FFE7FFE61C67DBE61BE6FBE61C67FFE0000
+192D:00007FFE7BCE73B67BC67BF671CE7FFE7FFE618E7DB661B66FB6618E7FFE0000
+192E:00007FFE7BCE73B67BC67BF671CE7FFE7FFE61867DBE618E6FBE61867FFE0000
+192F:00007FFE7BCE73B67BC67BF671CE7FFE7FFE61867DBE618E6FBE61BE7FFE0000
+1930:000000000000003E001000200022001C00000000000000000000000000000000
+1931:000000000000000000000000000000000000000C00120012000C000000000000
+1932:00000000000000000000000000000000000000000000000000000C0012000C00
+1933:0000000000000000000000000000000000000000000000000000003800440000
+1934:0000000000000080004000400044002A002A001C000000000000000000000000
+1935:0000000000000042002200220026001A00020000000000000000000000000000
+1936:0000000000000044002A002A001C000800080008000800080008000000000000
+1937:0000000000000000000000000000000000000000000000000020001000080000
+1938:0000000000000024002400240018000000000000000000000000000000000000
+1939:0000000000000000000000000000000000000000000000000010002000400000
+193A:0280000000000000000000000000000000000000000000000000000000000000
+193B:000000000000000000000000000000000000000000000000000000007F800000
+193C:00007FFE7BCE73B67BC67BF671CE7FFE7FFE63C67DBE71BE7DBE63C67FFE0000
+193D:00007FFE7BCE73B67BC67BF671CE7FFE7FFE638E7DB671B67DB6638E7FFE0000
+193E:00007FFE7BCE73B67BC67BF671CE7FFE7FFE63867DBE718E7DBE63867FFE0000
+193F:00007FFE7BCE73B67BC67BF671CE7FFE7FFE63867DBE718E7DBE63BE7FFE0000
+1940:00000000000002000400080008000830084808480428021001E0000000000000
+1941:00007FFE7BCE73B67BC67BF671CE7FFE7FFE6DEE6DCE61EE7DEE7DC67FFE0000
+1942:00007FFE7BCE73B67BC67BF671CE7FFE7FFE6D866DF661867DBE7D867FFE0000
+1943:00007FFE7BCE73B67BC67BF671CE7FFE7FFE6D8E6DF661C67DF67D8E7FFE0000
+1944:0000000000000180024002400140004000400040004000000040000000000000
+1945:0000000000000460029001200100010001000100010000000100000000000000
+1946:0000000000000380044008200820082008200820082004400380000000000000
+1947:00000000000008000800080008000860089008900850042003C0000000000000
+1948:0000000000000100028002800440044008200820101010101010000000000000
+1949:00000000000007800840080004000380004000200020042003C0000000000000
+194A:0000000000001830044002800280010002800280044008203018000000000000
+194B:00000000000003C004A008A0084008000800084008A004A003C0000000000000
+194C:000000000000038004400820080008000800084008A004A003C0008000400020
+194D:0000000000000C4010A011000900060003000480044004400380000000000000
+194E:0000000000001010101010100820082004400440028002800100000000000000
+194F:0000000000001FE012200A200640024000800080010002000400000000000000
+1950:00000000000048542404040404000000
+1951:000000000000485424041C241C000000
+1952:00000000000058644444444444000000
+1953:000000000000A0561A1212161A000000
+1954:000000000000A052121212161A000000
+1955:0000000000004242424242562A000000
+1956:000000000000B6DA929292B2D2000000
+1957:000000000000B6DA929292B6DA000000
+1958:0000000000000202020242562A000000
+1959:00000000000044444444444C34000000
+195A:000000000000969A929292B6DA000000
+195B:00000000000044447C44444C34000000
+195C:000000000000969A929292B6DA020408
+195D:00000000000058644444444C34000000
+195E:000000000000B6DA929292B2D2102040
+195F:000000000000B65A1212121212102040
+1960:000000000000485424041C241C040810
+1961:000000000000A052121212161A020408
+1962:000000000000464A4A52526242000000
+1963:00000010101010101010101010000000
+1964:0000003C2424243C242424342C000000
+1965:0000003C242424242424242424000000
+1966:0000003C24242424242424242404041C
+1967:0000002020202020202020203C003C00
+1968:0000002020202020202020203C000000
+1969:0000002424242424242424243C000000
+196A:0000003C2424243C242424342C202038
+196B:0000003C242424242424242424202038
+196C:0000003C202020202020202020000000
+196D:000000000000A052121212161A102040
+196E:00007FFE7BCE73B67BC67BF671CE7FFE7FFE73866FBE638E6DBE73867FFE0000
+196F:00007FFE7BCE73B67BC67BF671CE7FFE7FFE73866FBE638E6DBE73BE7FFE0000
+1970:000000000000F8484848484A84000000
+1971:0000000000001824447C404438000000
+1972:0000000000001C244444444C34000000
+1973:00000000000040242A2A26221C000000
+1974:00000000000018244040404438000000
+1975:00007FFE7BCE73B67BC67BF671CE7FFE7FFE61867DBE7B8677F677867FFE0000
+1976:00007FFE7BCE73B67BC67BF671CE7FFE7FFE61CE7DBE7B8E77B677CE7FFE0000
+1977:00007FFE7BCE73B67BC67BF671CE7FFE7FFE61867DF67BEE77DE77DE7FFE0000
+1978:00007FFE7BCE73B67BC67BF671CE7FFE7FFE61CE7DB67BCE77B677CE7FFE0000
+1979:00007FFE7BCE73B67BC67BF671CE7FFE7FFE61CE7DB67BC677F677CE7FFE0000
+197A:00007FFE7BCE73B67BC67BF671CE7FFE7FFE61867DB67B8677B677B67FFE0000
+197B:00007FFE7BCE73B67BC67BF671CE7FFE7FFE618E7DB67B8E77B6778E7FFE0000
+197C:00007FFE7BCE73B67BC67BF671CE7FFE7FFE61C67DBE7BBE77BE77C67FFE0000
+197D:00007FFE7BCE73B67BC67BF671CE7FFE7FFE618E7DB67BB677B6778E7FFE0000
+197E:00007FFE7BCE73B67BC67BF671CE7FFE7FFE61867DBE7B8E77BE77867FFE0000
+197F:00007FFE7BCE73B67BC67BF671CE7FFE7FFE61867DBE7B8E77BE77BE7FFE0000
+1980:00000000000000001C70228801040104010422081C3000080004008400780000
+1981:00000180024000001C70228801040104010422081C3000080004008400780000
+1982:00000000000000000E38114420822002200210040E3800000000000000000000
+1983:00000000384402021A241A0202423C00
+1984:00000000000000000E3810442082208211040E38000000F8010400E4021401F8
+1985:000000000000000003C004200810081008100420024000000000000000000000
+1986:03C00420081008000BC00C200810081008100420024000000000000000000000
+1987:000000000000000003C004200810081008100B100C9000100010042003C00000
+1988:000000000000000007C00820081006100810082007C000000000000000000000
+1989:00000000000000001C70220801040104010422881C7000000000000000000000
+198A:00300048004000400E40114010400C40104010800F0000000000000000000000
+198B:000000000000000003C004200810081008100420024000200010041003E00000
+198C:03C00420081008000BC00C200810081008100420024000200010041003E00000
+198D:00000000000000000E38100420022002208211440E3800000000000000000000
+198E:00000000000000000E38114420822082208211040E3800000000000000000000
+198F:000000003C4241314145390101221C00
+1990:00000000000000000E38104420822082208211040E38002000300208010800F0
+1991:1E2140404E51414641211E0000000000
+1992:000000000000000007F008081004100410840888077000000000000000000000
+1993:000000000000000007C00820080008000800080007C000200010082007C00000
+1994:0018002400200020062008201020102010200840078000000000000000000000
+1995:00000000000000001C70228820881850202020521F8C00000000000000000000
+1996:00000000000000000E38104420822082208211040E38002001E00204020801F0
+1997:00000000000000000E3811442082200210060E3A000203E2041205E2040403F8
+1998:00000000000000001C70228801040104010422081C7000000000000000000000
+1999:000000000000000002400420081008100BD0042003D000100010041003E00000
+199A:3E403F013945413141423C0000000000
+199B:00000000000000000E38104420822082208211040E38000003E00410041003E0
+199C:00000000000000000E38104420822082208211040E3800080308048804480230
+199D:0F001080204020002E38314420822002200210040E3800000000000000000000
+199E:000000001C22414141221C0000000000
+199F:00000000000000000E38110420822082208210440E3800000000000000000000
+19A0:00000000000000000E38104420822082208211040E3800000000000000000000
+19A1:00000000384402020204180402423C00
+19A2:000000000000000002400420081008100810042003C000000000000000000000
+19A3:00000000384442221151210202040000
+19A4:00182400384402020204180402423C00
+19A5:000001800240000002400420081008100810042003C000000000000000000000
+19A6:00000000000000000E38114420822002200210040E38000003E00410041003E0
+19A7:00000000384402023A443A003C42423C
+19A8:000000000000000003C0042008100810081004200240000003C00420042003C0
+19A9:03C00420081008000BC00C2008100810081004200240000003C00420042003C0
+19AA:00000000000000001C70220801040104010422881C70000007C00820082007C0
+19AB:03C00420081008000BC00C200810081008100420024000200390046004400380
+19AC:00007FFE7BCE73B67BC67BF671CE7FFE7FFE61C66DBE61BE6DBE6DC67FFE0000
+19AD:00007FFE7BCE73B67BC67BF671CE7FFE7FFE618E6DB661B66DB66D8E7FFE0000
+19AE:00007FFE7BCE73B67BC67BF671CE7FFE7FFE61866DBE618E6DBE6D867FFE0000
+19AF:00007FFE7BCE73B67BC67BF671CE7FFE7FFE61866DBE618E6DBE6DBE7FFE0000
+19B0:00000000304926003049260000000000
+19B1:00000000384402020244380000000000
+19B2:1C224141415D634141221C0000000000
+19B3:00000000384402020244784040423C00
+19B4:00000000000000001040104010401040104008C0074000400040004800300000
+19B5:000000000000000003C004200810081008100420023000000000000000000000
+19B6:00000000000000001C1C22224141414141412222131300000000000000000000
+19B7:384440201820404040221C0000000000
+19B8:000000001C2222140814630000000000
+19B9:1C2A4949495D634141221C0000000000
+19BA:3C4202021E22404040221C0000000000
+19BB:00000000000000000F08108800480048004810C80F4800480048004800300000
+19BC:07000880104010401048174818C81048104808C8074800480048004800300000
+19BD:000000000000000007840844102410241024086407A400240024002400180000
+19BE:00180024002000201C2022202220142008201440638000000000000000000000
+19BF:07000A80124012401248174818C81048104808C8074800480048004800300000
+19C0:07000880104010401048174818C81048104808C8074800480048004800300000
+19C1:000000001C22414141231D010D120C00
+19C2:000000000000000003C004200810081008100B100C90001000D0012000C00000
+19C3:000000000000000007C00820080008000800080007C000200610092007C00000
+19C4:000000000000000002400420081008100BD0042003D000100310049003E00000
+19C5:00000000000000000E38114420822002200210060E3A0002001A002400180000
+19C6:000000003844020202041804324A3C00
+19C7:000000000000000002400420081008100810043003D0001000D0012000C00000
+19C8:000000001C20405C62221C0000000000
+19C9:000000001C22625C40201C0000000000
+19CA:00007FFE7BCE73B67BC67BF671CE7FFE7FFE71866FB66F866FB671B67FFE0000
+19CB:00007FFE7BCE73B67BC67BF671CE7FFE7FFE718E6FB66F8E6FB6718E7FFE0000
+19CC:00007FFE7BCE73B67BC67BF671CE7FFE7FFE71C66FBE6FBE6FBE71C67FFE0000
+19CD:00007FFE7BCE73B67BC67BF671CE7FFE7FFE718E6FB66FB66FB6718E7FFE0000
+19CE:00007FFE7BCE73B67BC67BF671CE7FFE7FFE71866FBE6F8E6FBE71867FFE0000
+19CF:00007FFE7BCE73B67BC67BF671CE7FFE7FFE71866FBE6F8E6FBE71BE7FFE0000
+19D0:000000001C22414141221C0000000000
+19D1:00000000384402020244380000000000
+19D2:000000000E0202020202020202443800
+19D3:000000003C42010101423C1008040200
+19D4:000000001E21404040211E0408102000
+19D5:00000000000000000E38114420842004200410040C0400040024002400180000
+19D6:003C4240444A484442221C0000000000
+19D7:00000000000000001C7022884108400840082008180800080009000900060000
+19D8:00000000182424244242810000000000
+19D9:000000001C2241414946404040423C00
+19DA:000000000008000803D00420080008000800042003C000000000000000000000
+19DB:00007FFE7BCE73B67BC67BF671CE7FFE7FFE638E6DB66D8E6DB6638E7FFE0000
+19DC:00007FFE7BCE73B67BC67BF671CE7FFE7FFE63C66DBE6DBE6DBE63C67FFE0000
+19DD:00007FFE7BCE73B67BC67BF671CE7FFE7FFE638E6DB66DB66DB6638E7FFE0000
+19DE:0000000C001200100C10121021102110211010900C6000000000000000000000
+19DF:0000000C001200100C10121021102110211010900C60000007C00820082007C0
+19E0:0000000001C0022002200220022001C0000803F8040008E0092008A00A200DE0
+19E1:000003800440054002400040044003800000024004C003400040004000400000
+19E2:00001000136014901410131010100FE00000024004C003400040004000400000
+19E3:000000000EE0111011101910151019100000024004C003400040004000400000
+19E4:00000200040009000A800A00090007800000024004C003400040004000400000
+19E5:04800B80040009000A800A00090007800000024004C003400040004000400000
+19E6:040005800640004002400540044003800000024004C003400040004000400000
+19E7:0000001006C8092808280C280A280C100000024004C003400040004000400000
+19E8:002003E0040008E0092008A00A200DC00000024004C003400040004000400000
+19E9:00000040004003C004000300044003800000024004C003400040004000400000
+19EA:00001C3822442A441244024422441C380000024004C003400040004000400000
+19EB:00001C3822442A541224020422441C380000024004C003400040004000400000
+19EC:00003900452C555225420522450238FC0000024004C003400040004000400000
+19ED:000038EC4512551225120592455239920000024004C003400040004000400000
+19EE:00001C1022202A481254025022481C3C0000024004C003400040004000400000
+19EF:00241C5C22202A481254025022481C3C0000024004C003400040004000400000
+19F0:002003E0040008E0092008A00A200DC0002003E0040008E0092008A00A200DC0
+19F1:0000048009800680008000800080000003800440054002400040044003800000
+19F2:000004800980068000800080008000001000136014901410131010100FE00000
+19F3:0000048009800680008000800080000000000EE0111011101910151019100000
+19F4:000004800980068000800080008000000200040009000A800A00090007800000
+19F5:000004800980068000800080008004200BE0040009000A800A00090007800000
+19F6:0000048009800680008000800080040005800640004002400540044003800000
+19F7:00000480098006800080008000800000001006C8092808280C280A280C100000
+19F8:0000048009800680008000800080002003E0040008E0092008A00A200DC00000
+19F9:000004800980068000800080008000000040004003C004000300044003800000
+19FA:000004800980068000800080008000001C3822442A441244024422441C380000
+19FB:000004800980068000800080008000001C3822442A541224020422441C380000
+19FC:000004800980068000800080008000003900452C555225420522450238FC0000
+19FD:0000048009800680008000800080000038EC4512551225120592455239920000
+19FE:000004800980068000800080008000001C1022202A481254025022481C3C0000
+19FF:000004800980068000800080008000241C5C22202A481254025022481C3C0000
+1A00:0000000000000000000000000000000000800110022004400880010000000000
+1A01:0000000000000000000000000000000001200120029002900460056000000000
+1A02:0000000000000000000000000000000002000100008000C00120021000000000
+1A03:00000000000000000000000000000000004000A0011002880440082000000000
+1A04:0000000000000000000000000000000001200120029002900460046000000000
+1A05:0000000000000000000000000100028004400220010001800240042000000000
+1A06:0000000000000000000000000000000004400440028002800100010000000000
+1A07:00000000000000000000000000000000084004200210031004A0084000000000
+1A08:0000000000000000000000000000000000800080014001400220022000000000
+1A09:0000000000000000000000000000000005400440028002800100010000000000
+1A0A:000000000000000000000000000000000080008001400140022002A000000000
+1A0B:0000000000000000000000000000002001100290028804480450092002800000
+1A0C:00000000000000000000000000000000012001200290021004A0044000000000
+1A0D:00000000000000000000000000000000004000A00110031004A0084000000000
+1A0E:0000000000000000000000000000000002200220055004900808094800800000
+1A0F:0000000000000000000000000000000002200220055004900948094800000000
+1A10:00000000000000000000000000000000042004200A500A50118815A800000000
+1A11:0000000000000000000000000000000001800240042001800240042000000000
+1A12:00000000000000000000000000000000042004200A500A101148118800000000
+1A13:00000000000000000000000000000000042004200A500A501188118800000000
+1A14:000000000000000000000000000000000180066008100408033000C000000000
+1A15:00000000000000000000000000000000042004200A500A50118811A800000000
+1A16:0000000000000000000000000000000004200A50118811880A50042000000000
+1A17:0000000000000000000008000000000000000000000000000000000000000000
+1A18:0000000000000000000000000000000000000000000000000000000000000010
+1A19:0000000000000000000000000000000000004000800080004000200000000000
+1A1A:0000000000000000000000000000000000000006000200020001000100000000
+1A1B:0000000010000800040008000000000000000000000000000000000000000000
+1A1C:00007FFE7B8673B67B867BB671B67FFE7FFE7BC673BE7BBE7BBE71C67FFE0000
+1A1D:00007FFE7B8673B67B867BB671B67FFE7FFE7B8E73B67BB67BB6718E7FFE0000
+1A1E:0000000000000000000030003000000000000180018000000000000C000C0000
+1A1F:0000000000000000000000000000100010003800440000004400380010001000
+1A20:0000000000000000000003700488084408440844048800300000000000000000
+1A21:0000000000000000000003C00420001003D00430043003C80000000000000000
+1A22:03E0040004000400040005C00620001003D00430043003C80000000000000000
+1A23:0000000000000000000001E00210040804080408021001200000000000000000
+1A24:03C0040004000400040005E00610040804080408021001200000000000000000
+1A25:0000000000000000000005000AA800A40124022402A401580000000000000000
+1A26:0000000000000000000001E0021004080208040804C803280000000000000000
+1A27:0000000000000000000001C00220011000900110022001C00000000000000000
+1A28:0000000000800080004003300488004400440044048803700000000000000000
+1A29:0000000000000000000000F00108020802100208010800C80000000000000000
+1A2A:03E0040004000400040005E00610041004200410021001900000000000000000
+1A2B:0000000000800080004003300488044402440444048803700000000000000000
+1A2C:00000000000000000000033004880044004400440488077004000404040403F8
+1A2D:0000000000000000000002200510040802080408049003600000000000000000
+1A2E:0000000000000000000002200510040802080408041803E8000803C8041003E0
+1A2F:0000000000000000000001C0022000100010002000C001300008000000000000
+1A30:0000000000000000000002800550004800880108015000A00000000000000000
+1A31:00000000000000000000011002A804A404A404A4024801100000000000000000
+1A32:0000000000000000000003700488084408440844048803300000000000000000
+1A33:0000000000000000000003E0041002080148022804A803480000000000000000
+1A34:0000000000000000000002700488041004200410020801F00000000000000000
+1A35:0000000000000000000001E0021004080408040802D001200000000000000000
+1A36:0000000000000000000001C0022004000400040002E001100008000000000000
+1A37:0000000000000000000001200210040804080408021001E00000000000000000
+1A38:0000000600080010001000100210041004100410022001C00000000000000000
+1A39:0000000000000000000002100528042802280428049003680000000000000000
+1A3A:03F004080400040003F800080208040802080408029001600000000000000000
+1A3B:00000000000000000000012002D0040804080408021001200000000000000000
+1A3C:03E00400040004000400052006D0040804080408021001200000000000000000
+1A3D:0000000000000000000003700488004400440044048803300000000000000000
+1A3E:00000000000000000000012002100408040804E8021001E80004000000000000
+1A3F:0000000000000000000000300488084408440844048803700000000000000000
+1A40:0006000800080008000803880408040803080408041003E00000000000000000
+1A41:0000000000000000000003800440022001100490044803880000000000000000
+1A42:0000000000000000000002200550048802080008000803E80418048803F40020
+1A43:0000000000000000000003300488088408840844044803300000000000000000
+1A44:0000000000000000000003C004200010001003E0001003D00430049003E80020
+1A45:0000000000000000000001E00210040804080408021001E00000000000000000
+1A46:0000000000000000000401E8021004E804080408021001200000000000000000
+1A47:0000000000000000000003300488004400440054048803740000000000000000
+1A48:0000000000000000000003300488004400440044048803700000000000000000
+1A49:0000000000000000000003300448084408840884048803300000000000000000
+1A4A:0000000000000000000001E0021004080208040804C8032802000270020801F0
+1A4B:0000000000000000000003700488004400440044048803300008000400000000
+1A4C:00000000000000000000033004480844088408840488033000100190021001E0
+1A4D:00000000000000000000033004C8040804080210000003E0041004C805480208
+1A4E:00FC0102010000FE0002033204CA040A040A0212000203E2041204CA054A020C
+1A4F:0000000000000000000001E00210000800080408061005E004000400021001E0
+1A50:03C0040004000400040005E00610000800080408061005E004000400021001E0
+1A51:0000000000000000000001E00210040804080408041004E004000400021001E0
+1A52:0800100010001000100013701488104410441044148813301008100410000800
+1A53:0006000800080008000803080488088808880848044803300000000000000000
+1A54:000000000000000000000248052400920092009205B402480000000000000000
+1A55:0800100010001000100010001000100010001000100010001000100010000800
+1A56:00000000000000000000000000000000000000000000000000000C8012400980
+1A57:000000000000000600010001000100010001000100010001000100650092004D
+1A58:000C0010000C0010000C00000000000000000000000000000000000000000000
+1A59:01E0021002D00150000000000000000000000000000000000000000000000000
+1A5A:00A00150011000A0000000000000000000000000000000000000000000000000
+1A5B:00000000000000000000000000000000000000000000000000400F4010400F80
+1A5C:0000000000000000000000000000000000000000000000000000094008C007A0
+1A5D:0000000000000000000000000000000000000000000000000000084008400780
+1A5E:00000000000000000000000000000000000000000000000000000C8002400D80
+1A5F:00007FFE7B8673B67B867BB671B67FFE7FFE61866FBE618E7DBE61BE7FFE0000
+1A60:00000000000000000000000000000000000000000000000000000008001C0008
+1A61:0000000000000000000000000003000000000000000300000000000000000000
+1A62:0000001000200040000000000000000000000000000000000000000000000000
+1A63:0000000000000000000000020001000100010001000100020000000000000000
+1A64:00000000000E0011001100010001000100010001000100010000000000000000
+1A65:01E0021002100120000000000000000000000000000000000000000000000000
+1A66:01E0021002200110000000000000000000000000000000000000000000000000
+1A67:01F0020802480110000000000000000000000000000000000000000000000000
+1A68:03B0044804480290000000000000000000000000000000000000000000000000
+1A69:0000000000000000000000000000000000000000000000000010001000180000
+1A6A:00000000000000000000000000000000000000000000000000280028002C0000
+1A6B:0000000000780064000200000000000000000000000000000000000000000000
+1A6C:0000000000000000000000000000000000000000000000000000002000480036
+1A6D:0000000100010001000100010001000100010001000100010005000900090006
+1A6E:0000000000000000000040008000800080008000800040000000000000000000
+1A6F:000000000000000000005000A000A000A000A000A00050000000000000000000
+1A70:0000400080008000800040008000800080008000800040000000000000000000
+1A71:0000000080004000200060008000800080008000800040000000000000000000
+1A72:00004000A0002000200060008000800080008000800040000000000000000000
+1A73:0040004000A00318000000000000000000000000000000000000000000000000
+1A74:0200050002000000000000000000000000000000000000000000000000000000
+1A75:0000080008000800000000000000000000000000000000000000000000000000
+1A76:0000020014000800000000000000000000000000000000000000000000000000
+1A77:0000001000280044000000000000000000000000000000000000000000000000
+1A78:0002000200020012000C00000000000000000000000000000000000000000000
+1A79:0018000400180010000C00000000000000000000000000000000000000000000
+1A7A:00700048012400E4000000000000000000000000000000000000000000000000
+1A7B:000C001600140014000000000000000000000000000000000000000000000000
+1A7C:00340048012000C0000000000000000000000000000000000000000000000000
+1A7D:00007FFE7B8673B67B867BB671B67FFE7FFE618E7DB67BB677B6778E7FFE0000
+1A7E:00007FFE7B8673B67B867BB671B67FFE7FFE61867DBE7B8E77BE77867FFE0000
+1A7F:0000000000000000000000000000000000000000000000000600090009000600
+1A80:0000000000000000000001C00220041004100410022001C00000000000000000
+1A81:0000000000000000000003800440002000200020044003800000000000000000
+1A82:00000000000000000000001000100010001000100010001004100410022001C0
+1A83:0000000000000000038004400020002000200440038002000100010000800040
+1A84:000000000000000001C00220040004000400022001C000400080008001000200
+1A85:0000000000000000000001C002200410071004900310001004100410022001C0
+1A86:01C00220041004000460049004E0048004700410022001C00000000000000000
+1A87:0000000000000000000003800440044004400440044002400040004000400030
+1A88:0000000000000000000001C00220041004100510029001200000000000000000
+1A89:000000000000000001C0022004100470048004E00490046004000410022001C0
+1A8A:00007FFE7B8673B67B867BB671B67FFE7FFE73866DB673866DB673B67FFE0000
+1A8B:00007FFE7B8673B67B867BB671B67FFE7FFE738E6DB6738E6DB6738E7FFE0000
+1A8C:00007FFE7B8673B67B867BB671B67FFE7FFE73C66DBE73BE6DBE73C67FFE0000
+1A8D:00007FFE7B8673B67B867BB671B67FFE7FFE738E6DB673B66DB6738E7FFE0000
+1A8E:00007FFE7B8673B67B867BB671B67FFE7FFE73866DBE738E6DBE73867FFE0000
+1A8F:00007FFE7B8673B67B867BB671B67FFE7FFE73866DBE738E6DBE73BE7FFE0000
+1A90:0000000000000000000001C00220041004100410022001C00000000000000000
+1A91:0000000000000000002001A00260040004000500028001000000000000000000
+1A92:01C0022004100410041004000400040004000600050002000000000000000000
+1A93:000000000100010000801C70220801040104010422881C700000000000000000
+1A94:0000000000000000000002600490042004400420021003E0020002E0021001E0
+1A95:0020002000400180020004600490042004400420021003E00000000000000000
+1A96:0010002000200020002002200520042002200420052002C00000000000000000
+1A97:0000000000000000000002400520041002100410052002C00000000000000000
+1A98:0000000000000000000018C02520421040102060004003F8044409F20A490431
+1A99:000000000000000000000E181104208220822882144408380000000000000000
+1A9A:00007FFE7B8673B67B867BB671B67FFE7FFE73866DB671867DB673B67FFE0000
+1A9B:00007FFE7B8673B67B867BB671B67FFE7FFE738E6DB6718E7DB6738E7FFE0000
+1A9C:00007FFE7B8673B67B867BB671B67FFE7FFE73C66DBE71BE7DBE73C67FFE0000
+1A9D:00007FFE7B8673B67B867BB671B67FFE7FFE738E6DB671B67DB6738E7FFE0000
+1A9E:00007FFE7B8673B67B867BB671B67FFE7FFE73866DBE718E7DBE73867FFE0000
+1A9F:00007FFE7B8673B67B867BB671B67FFE7FFE73866DBE718E7DBE73BE7FFE0000
+1AA0:0000000003E004900888108410841FFC108410840888049003E0000000000000
+1AA1:00000000038004800880108010801FFC108410840888049003E0000000000000
+1AA2:0012004C003800D000201CC0222001100110011022201DC00000000000000000
+1AA3:000000000080014001C002200C9815540C98022001C001400080000000000000
+1AA4:0000000000000FE0101027C8282829C8281027E0100C0FF00000000000000000
+1AA5:000003E00220094815540AA865535A2D44115A2D65530AA815540948022003E0
+1AA6:000001C00220041004100190026002000260019004100410022001C000000000
+1AA7:000000000000000003B004480A48040800080010006001800200040004000400
+1AA8:0000000000000000000002000200020002000200020002000000000000000000
+1AA9:0000000000000000000009000900090009000900090009000000000000000000
+1AAA:0000000000000000000004000800090007000100010001000000000000000000
+1AAB:000000000000000000000880108012800E800280028002800000000000000000
+1AAC:000000380004000401C4022800300E201140018011000E000000000000000000
+1AAD:00000000000000000000010002800500044002200410041004100410022001C0
+1AAE:00007FFE7B8673B67B867BB671B67FFE7FFE61866DBE618E6DBE6D867FFE0000
+1AAF:00007FFE7B8673B67B867BB671B67FFE7FFE61866DBE618E6DBE6DBE7FFE0000
+1AB0:00142A49000000000000000000000000
+1AB1:00081455080000000000000000000000
+1AB2:00364936000000000000000000000000
+1AB3:00082A1C080000000000000000000000
+1AB4:00000822000000000000000000000000
+1AB5:00000000000000000000000000552255
+1AB6:00000000000000000000000000002A55
+1AB7:00000000000000000000000000080804
+1AB8:00000000000000000000000000242412
+1AB9:00000000000000000000000000204080
+1ABA:0000000000000000000000000020C0C0
+1ABB:00004281814200000000000000000000
+1ABC:0024C3C3C3C324000000000000000000
+1ABD:00000000000000000000000042818142
+1ABE:00000000000000000000428181420000
+1ABF:00000000000000000000000000005428
+1AC0:00000000000000000000000000002854
+1AC1:00007FFE7B8673B67B867BB671B67FFE7FFE71EE6FCE6FEE6FEE71C67FFE0000
+1AC2:00007FFE7B8673B67B867BB671B67FFE7FFE71866FF66F866FBE71867FFE0000
+1AC3:00007FFE7B8673B67B867BB671B67FFE7FFE718E6FF66FC66FF6718E7FFE0000
+1AC4:00007FFE7B8673B67B867BB671B67FFE7FFE71B66FB66F866FF671F67FFE0000
+1AC5:00007FFE7B8673B67B867BB671B67FFE7FFE71866FBE6F866FF671867FFE0000
+1AC6:00007FFE7B8673B67B867BB671B67FFE7FFE71CE6FBE6F8E6FB671CE7FFE0000
+1AC7:00007FFE7B8673B67B867BB671B67FFE7FFE71866FF66FEE6FDE71DE7FFE0000
+1AC8:00007FFE7B8673B67B867BB671B67FFE7FFE71CE6FB66FCE6FB671CE7FFE0000
+1AC9:00007FFE7B8673B67B867BB671B67FFE7FFE71CE6FB66FC66FF671CE7FFE0000
+1ACA:00007FFE7B8673B67B867BB671B67FFE7FFE71866FB66F866FB671B67FFE0000
+1ACB:00007FFE7B8673B67B867BB671B67FFE7FFE718E6FB66F8E6FB6718E7FFE0000
+1ACC:00007FFE7B8673B67B867BB671B67FFE7FFE71C66FBE6FBE6FBE71C67FFE0000
+1ACD:00007FFE7B8673B67B867BB671B67FFE7FFE718E6FB66FB66FB6718E7FFE0000
+1ACE:00007FFE7B8673B67B867BB671B67FFE7FFE71866FBE6F8E6FBE71867FFE0000
+1ACF:00007FFE7B8673B67B867BB671B67FFE7FFE71866FBE6F8E6FBE71BE7FFE0000
+1AD0:00007FFE7B8673B67B867BB671B67FFE7FFE63CE6DB66DB66DB663CE7FFE0000
+1AD1:00007FFE7B8673B67B867BB671B67FFE7FFE63EE6DCE6DEE6DEE63C67FFE0000
+1AD2:00007FFE7B8673B67B867BB671B67FFE7FFE63866DF66D866DBE63867FFE0000
+1AD3:00007FFE7B8673B67B867BB671B67FFE7FFE638E6DF66DC66DF6638E7FFE0000
+1AD4:00007FFE7B8673B67B867BB671B67FFE7FFE63B66DB66D866DF663F67FFE0000
+1AD5:00007FFE7B8673B67B867BB671B67FFE7FFE63866DBE6D866DF663867FFE0000
+1AD6:00007FFE7B8673B67B867BB671B67FFE7FFE63CE6DBE6D8E6DB663CE7FFE0000
+1AD7:00007FFE7B8673B67B867BB671B67FFE7FFE63866DF66DEE6DDE63DE7FFE0000
+1AD8:00007FFE7B8673B67B867BB671B67FFE7FFE63CE6DB66DCE6DB663CE7FFE0000
+1AD9:00007FFE7B8673B67B867BB671B67FFE7FFE63CE6DB66DC66DF663CE7FFE0000
+1ADA:00007FFE7B8673B67B867BB671B67FFE7FFE63866DB66D866DB663B67FFE0000
+1ADB:00007FFE7B8673B67B867BB671B67FFE7FFE638E6DB66D8E6DB6638E7FFE0000
+1ADC:00007FFE7B8673B67B867BB671B67FFE7FFE63C66DBE6DBE6DBE63C67FFE0000
+1ADD:00007FFE7B8673B67B867BB671B67FFE7FFE638E6DB66DB66DB6638E7FFE0000
+1ADE:00007FFE7B8673B67B867BB671B67FFE7FFE63866DBE6D8E6DBE63867FFE0000
+1ADF:00007FFE7B8673B67B867BB671B67FFE7FFE63866DBE6D8E6DBE63BE7FFE0000
+1AE0:00007FFE7B8673B67B867BB671B67FFE7FFE61CE6FB663B66FB661CE7FFE0000
+1AE1:00007FFE7B8673B67B867BB671B67FFE7FFE61EE6FCE63EE6FEE61C67FFE0000
+1AE2:00007FFE7B8673B67B867BB671B67FFE7FFE61866FF663866FBE61867FFE0000
+1AE3:00007FFE7B8673B67B867BB671B67FFE7FFE618E6FF663C66FF6618E7FFE0000
+1AE4:00007FFE7B8673B67B867BB671B67FFE7FFE61B66FB663866FF661F67FFE0000
+1AE5:00007FFE7B8673B67B867BB671B67FFE7FFE61866FBE63866FF661867FFE0000
+1AE6:00007FFE7B8673B67B867BB671B67FFE7FFE61CE6FBE638E6FB661CE7FFE0000
+1AE7:00007FFE7B8673B67B867BB671B67FFE7FFE61866FF663EE6FDE61DE7FFE0000
+1AE8:00007FFE7B8673B67B867BB671B67FFE7FFE61CE6FB663CE6FB661CE7FFE0000
+1AE9:00007FFE7B8673B67B867BB671B67FFE7FFE61CE6FB663C66FF661CE7FFE0000
+1AEA:00007FFE7B8673B67B867BB671B67FFE7FFE61866FB663866FB661B67FFE0000
+1AEB:00007FFE7B8673B67B867BB671B67FFE7FFE618E6FB6638E6FB6618E7FFE0000
+1AEC:00007FFE7B8673B67B867BB671B67FFE7FFE61C66FBE63BE6FBE61C67FFE0000
+1AED:00007FFE7B8673B67B867BB671B67FFE7FFE618E6FB663B66FB6618E7FFE0000
+1AEE:00007FFE7B8673B67B867BB671B67FFE7FFE61866FBE638E6FBE61867FFE0000
+1AEF:00007FFE7B8673B67B867BB671B67FFE7FFE61866FBE638E6FBE61BE7FFE0000
+1AF0:00007FFE7B8673B67B867BB671B67FFE7FFE61CE6FB663B66FB66FCE7FFE0000
+1AF1:00007FFE7B8673B67B867BB671B67FFE7FFE61EE6FCE63EE6FEE6FC67FFE0000
+1AF2:00007FFE7B8673B67B867BB671B67FFE7FFE61866FF663866FBE6F867FFE0000
+1AF3:00007FFE7B8673B67B867BB671B67FFE7FFE618E6FF663C66FF66F8E7FFE0000
+1AF4:00007FFE7B8673B67B867BB671B67FFE7FFE61B66FB663866FF66FF67FFE0000
+1AF5:00007FFE7B8673B67B867BB671B67FFE7FFE61866FBE63866FF66F867FFE0000
+1AF6:00007FFE7B8673B67B867BB671B67FFE7FFE61CE6FBE638E6FB66FCE7FFE0000
+1AF7:00007FFE7B8673B67B867BB671B67FFE7FFE61866FF663EE6FDE6FDE7FFE0000
+1AF8:00007FFE7B8673B67B867BB671B67FFE7FFE61CE6FB663CE6FB66FCE7FFE0000
+1AF9:00007FFE7B8673B67B867BB671B67FFE7FFE61CE6FB663C66FF66FCE7FFE0000
+1AFA:00007FFE7B8673B67B867BB671B67FFE7FFE61866FB663866FB66FB67FFE0000
+1AFB:00007FFE7B8673B67B867BB671B67FFE7FFE618E6FB6638E6FB66F8E7FFE0000
+1AFC:00007FFE7B8673B67B867BB671B67FFE7FFE61C66FBE63BE6FBE6FC67FFE0000
+1AFD:00007FFE7B8673B67B867BB671B67FFE7FFE618E6FB663B66FB66F8E7FFE0000
+1AFE:00007FFE7B8673B67B867BB671B67FFE7FFE61866FBE638E6FBE6F867FFE0000
+1AFF:00007FFE7B8673B67B867BB671B67FFE7FFE61866FBE638E6FBE6FBE7FFE0000
+1B00:0FE0111012900920000000000000000000000000000000000000000000000000
+1B01:01000AA00AA007C0000000000000000000000000000000000000000000000000
+1B02:0100028000400020000000000000000000000000000000000000000000000000
+1B03:00000200010000F0000000000000000000000000000000000000000000000000
+1B04:0000000000000000000200050001000200010001000100010001000000000000
+1B05:000000000000000000000E70112824A42A2422FC24A412240CC4000000000000
+1B06:00000000000000000000380044389244A8828882928249443628000000000000
+1B07:000000000000000011B02A480A080A0804C8010000C0022001C0000000000000
+1B08:000000000000000046CCA9222821282113260400030008800700000000000000
+1B09:00000000000000000B800440004000800300040009C00A200410000000000000
+1B0A:0000000000000000173008880084010406180800138014400820000000000000
+1B0B:000000000000000008101428042803C801800200018004400380000000000000
+1B0C:00000000000000004098A14421421E420C0C10000C0022001C00000000000000
+1B0D:000000000000000011B02A480A0A0A7C04880110009000600040000000000000
+1B0E:000000000000000046C0A920282E29F112210442024901890106000000000000
+1B0F:000000000000000003800C001000138014400C20000000000000000000000000
+1B10:000000000000000046C5A92B282E282210420782080210C20F3C000000000000
+1B11:000000000000000046C0A9202820282010400780080011C00E20000000000000
+1B12:000000000000000046CCA9222821282110460780080011C00E20000000000000
+1B13:000000000000000023CC542A142A3F2A54AA2312000000000000000000000000
+1B14:000000000000000023C0542014203F2054A0231C000200000000000000000000
+1B15:0000000000000000239854541454145412940EE4000000000000000000000000
+1B16:00000000000000002338551415141514155408A4000000000000000000000000
+1B17:0000000000000000236054901410141014100C10000000000000000000000000
+1B18:00000000000000000870144804280E28152808C8000000000000000000000000
+1B19:00000000000000003C30422842284A284A2831C8000000000000000000000000
+1B1A:000000000000000011E02A100A100A600A100608000800000000000000000000
+1B1B:0000000C0012000F46C2A9222822282210420782080210C20F3C000000000000
+1B1C:000000000000000046C6A9292829282928291832000000000000000000000000
+1B1D:0000000000000000236054901010381054104800210022001C00000000000000
+1B1E:0000000000000000236054901010111011100E00000000000000000000000000
+1B1F:0000000000000000203050281028102813280CC8000000000000000000000000
+1B20:0000000000000000101028100810081009900660000000000000000000000000
+1B21:00000000000000009CE2A3154015001500150019000000000000000000000000
+1B22:000000000000000023CC542A172A10AA10AA0F12000000000000000000000000
+1B23:000000000000000011E0289008500A5009500790010000000000000000000000
+1B24:000000000000000008701488048809C812A80C48000000000000000000000000
+1B25:0000000000000000107828240814081409940664000000000000000000000000
+1B26:000000000000000008F0150805080FC8152808C8000000000000000000000000
+1B27:0000000000000000106028500850085008500790000000000000000000000000
+1B28:00000000000000001088295008E0084008400780000000000000000000000000
+1B29:000000000000000046CCA92A282A282A282A1832000000000000000000000000
+1B2A:000000000000000020F05108090803C8152808C8000000000000000000000000
+1B2B:00000000000000001FB024282428032804280448038800000000000000000000
+1B2C:0000000000000000200850141114111412940C64000000000000000000000000
+1B2D:000000000000000010E029100510051005100610000000000000000000000000
+1B2E:0000000000000000460CA90A290A290A290A10F2000000000000000000000000
+1B2F:000000000000000008F0144804280428042803C8000000000000000000000000
+1B30:000000000000000047E6A9152A95289524A51C39000000000000000000000000
+1B31:0000000000000000206050501250155011500FD0010000000000000000000000
+1B32:00000000000000001060285008501C502A501190000000000000000000000000
+1B33:000000000000000040CCA12A212A212A212A1E12000000000000000000000000
+1B34:0000010000000440000000000000000000000000000000000000000000000000
+1B35:0000000000000000000C00020001000100090006000000000000000000000000
+1B36:03C014200C200240000000000000000000000000000000000000000000000000
+1B37:03C015200EA00460000000000000000000000000000000000000000000000000
+1B38:000000000000000000000000000000010003000300030005000900110012000C
+1B39:0000000000000000000000000000000100020004000400020001000100020004
+1B3A:000000000000000000000000000000000000002000100410099008A007C00080
+1B3B:0000000000000000000C0002000100010009002600100410099008A007C00080
+1B3C:00E0012012400A80000000000000000000000000000000002308548814880870
+1B3D:00E0012012400A80000C00020001000100090006000000002308548814880870
+1B3E:0000000000000000300048000800100010002000200020001000000000000000
+1B3F:38004000300008003000B000C800900010002000200020001000000000000000
+1B40:0000000000000000300C48020801100110092006200020001000000000000000
+1B41:3800400030000800300CB002C801900110092006200020001000000000000000
+1B42:00E0012012400A80000000000000000000000000000000000000000000000000
+1B43:00E0012012400A80000C00020001000100090006000000000000000000000000
+1B44:000E001100110001000200020002000200020002000200010001000000000000
+1B45:000000000000000023CC542A1C2A3F2A5CAA2B12080008800700000000000000
+1B46:00000000000000004716A8AD28AD7CADAAAD4444000000000000000000000000
+1B47:000000000000000023CC542A172A10AA14AA0F12040004400380000000000000
+1B48:00000000000000000830142804280528052803C80100011000E0000000000000
+1B49:000000000000000008F0144804280528052803C80100011000E0000000000000
+1B4A:00000000000000001060285008501D502B5011900100011000E0000000000000
+1B4B:00000000000000004302A2A522A572B5AAB544B5004D00000000000000000000
+1B4C:00007FFE7B8E73B67B8E7BB6718E7FFE7FFE6DC66DBE61BE7DBE7DC67FFE0000
+1B4D:00007FFE7B8E73B67B8E7BB6718E7FFE7FFE6D8E6DB661B67DB67D8E7FFE0000
+1B4E:00007FFE7B8E73B67B8E7BB6718E7FFE7FFE6D866DBE618E7DBE7D867FFE0000
+1B4F:00007FFE7B8E73B67B8E7BB6718E7FFE7FFE6D866DBE618E7DBE7DBE7FFE0000
+1B50:0000000000000000018002400240018000000000000000000000000000000000
+1B51:00000004000A0007236254921412141214140C38000000000000000000000000
+1B52:000000000000000011B02A480A0A0A7C04880110009000600040000000000000
+1B53:000000000000000046C0A9202820282010400780080011C00E20000000000000
+1B54:0000000000000000000000000B00088009000880048003000000000000000000
+1B55:0000000000000000078008400B2008A0092008A004A003200020002000100000
+1B56:000000000000000003800C001000138014400C20000000000000000000000000
+1B57:00000000000000004622A95429382910291018E0000000000000000000000000
+1B58:00000000000000001088295008E0084008400780000000000000000000000000
+1B59:0000000000000000202250541138111012900C60000000000000000000000000
+1B5A:00000000000000000C3012481248924892486189000900060000000000000000
+1B5B:000000000000000046CCA92A282A282A282A180A023F124A118A100A118A0E72
+1B5C:0000000000000000018002400240018000000000000000000000000000000000
+1B5D:0000000000000000031004A003C00000031004A003C000000000000000000000
+1B5E:0000000000000000020005000080008000400040002000200020000000000000
+1B5F:0000000000000000104028A00410041002080208010401040104000000000000
+1B60:0000000000000000018000400180044003800000000000000000000000000000
+1B61:0000000000000000000C00020001000100090006000000000000000000000000
+1B62:0000000000000000058006400440008000800100010001000080000000000000
+1B63:0000000000000000004000C000C000C001400240044004800300000000000000
+1B64:0000000000000000000002000500008000800040004000000000000000000000
+1B65:00000000000000000000000002000200010000F0000000000000000000000000
+1B66:00000000000000000000000003C014200C200240000000000000000000000000
+1B67:0000000000000000000000000070009009200540000000000000000000000000
+1B68:0000000000000000080010002000200010000800080010002000000000000000
+1B69:000000000000000046CCA92A282A282A104A078A080A118A0E72000000000000
+1B6A:0000000000000000080014000400080004000400040008000800080004000400
+1B6B:0080010000800000000000000000000000000000000000000000000000000000
+1B6C:0000000000000000000000000000000000000000000000000000008001000080
+1B6D:0300010007C00100010000000000000000000000000000000000000000000000
+1B6E:000003C000000000000000000000000000000000000000000000000000000000
+1B6F:0100028004400000000000000000000000000000000000000000000000000000
+1B70:070001000FE00380054000000000000000000000000000000000000000000000
+1B71:07F0014002200410000000000000000000000000000000000000000000000000
+1B72:0440028001000000000000000000000000000000000000000000000000000000
+1B73:0380044005400440038000000000000000000000000000000000000000000000
+1B74:0000000000000000000010002800280044004400000000000000000000000000
+1B75:0000000000000000000030004800480048003000000000000000000000000000
+1B76:0000000000000000000090006800280054004400000000000000000000000000
+1B77:00000000000000000000B8004400640054003800000000000000000000000000
+1B78:0000000000000000000000000000000078000000000000000000000000000000
+1B79:0000000000000000000010001000200020004000780000000000000000000000
+1B7A:0000000000000000000000004000200078001000080000000000000000000000
+1B7B:00000000000000000000900050002000300048007C0000000000000000000000
+1B7C:0000000000000000000000000000300030000000000000000000000000000000
+1B7D:00007FFE7B8E73B67B8E7BB6718E7FFE7FFE618E7DB67BB677B6778E7FFE0000
+1B7E:00007FFE7B8E73B67B8E7BB6718E7FFE7FFE61867DBE7B8E77BE77867FFE0000
+1B7F:00007FFE7B8E73B67B8E7BB6718E7FFE7FFE61867DBE7B8E77BE77BE7FFE0000
+1B80:0020005000200000000000000000000000000000000000000000000000000000
+1B81:0022005400080000000000000000000000000000000000000000000000000000
+1B82:0000000000000000000000000000000000040012000A00080000000000000000
+1B83:000000000000000005F00820084008E00810042003C000000000000000000000
+1B84:000000000000000000C00100010002000200042007E000000000000000000000
+1B85:000000000000000007000100010002300240042007E000000000000000000000
+1B86:00000000000000000BE0104010F011C810200840078000000000000000000000
+1B87:000000000000000007000500030002000220045007D000000000000000000000
+1B88:000000000000000000F00100010008F00810042003C000000000000000000000
+1B89:00000000000000500420080008F008200870041003E000000000000000000000
+1B8A:0000000000000000077001100110022002200440044000000000000000000000
+1B8B:000000000000000001F802480248049004900920092000000000000000000000
+1B8C:000000000000000007000100010002700210042007E000000000000000000000
+1B8D:000000000000000007000100010002400220041007F000000000000000000000
+1B8E:0000000000000000070401080108021006100B2004E000000000000000000000
+1B8F:00000000000000000180020002000400052009900F4800000000000000000000
+1B90:00000000000000000700010001000200024004A007A000000000000000000000
+1B91:00000000000000000E3E0242020204C404A409280F1800000000000000000000
+1B92:0000000000000000002000400C700490049009200F2000000000000000000000
+1B93:000000000000000001C002000200044004A008900F8800000000000000000000
+1B94:00000000000000000F000100010002000200040007E000000000000000000000
+1B95:000000000000000007700110011002200220044007C000000000000000000000
+1B96:000000000000000007080110011002200220044007C000000000000000000000
+1B97:000000000000000000880110011002200220044007C000000000000000000000
+1B98:0000000000000000019F022102010462045208940F8C00000000000000000000
+1B99:000000000000000007F000100E1002200220044007C000000000000000000000
+1B9A:0000000000000000002000400C4404A404A809280F1000000000000000000000
+1B9B:000000000000000003E0000007C0004003E00080008000000000000000000000
+1B9C:000000000000000001C20244024404880488091009F000000000000000000000
+1B9D:00000000000000000180020002000470041008200FE000000000000000000000
+1B9E:00000000000000000F780108010807BC02100420042000000000000000000000
+1B9F:000000000000000007F00110011007E002200440044000000000000000000000
+1BA0:0000000000000000003C00240E24024802480490079000000000000000000000
+1BA1:00000000000000000000000000000000000700050008000800100010041007E0
+1BA2:000000000000000000000000000000000000000000000000000004100A0801F0
+1BA3:0000000000000000000000000000000000000000000000000C00140016000000
+1BA4:0700010006000000000000000000000000000000000000000000000000000000
+1BA5:00000000000000000000000000000000000000000000000001C0004000800000
+1BA6:000000000000000000000000E000200070008000E00000000000000000000000
+1BA7:0000000000000000000000000000000700010002001C00070000000000000000
+1BA8:11000A0004000000000000000000000000000000000000000000000000000000
+1BA9:29001A0004000000000000000000000000000000000000000000000000000000
+1BAA:00000000000000000000001F0001000200040007000100020004000400040003
+1BAB:0000000000000000000000000000000000000000000000000100038001000000
+1BAC:0000000000000000000000000000000000000000000000001A0022001C000000
+1BAD:0000000000000000000000000000000000000000000000001B0009000D800000
+1BAE:00000000000000000FDF0251025104920492091409F400000000000000000000
+1BAF:00000000000000000FC8024802490FC904D50955097200000000000000000000
+1BB0:000000000000000003C00420081008100810042003C000000000000000000000
+1BB1:000000000000000007E00910010002700210042007E000000000000000000000
+1BB2:000000000000000007000900010002000390042007E000000000000000000000
+1BB3:000000000000000007000900010002300240042007E000000000000000000000
+1BB4:000000000000000001C00240005003E004800100010000000000000000000000
+1BB5:000000000000000006C00AA002800440044008200FE000000000000000000000
+1BB6:000000000000000000C00120010002300240042007E000000000000000000000
+1BB7:0000000000000000038C0490049009200920124033C000000000000000000000
+1BB8:00000000000000001C1824240420084018402C80138000000000000000000000
+1BB9:000000000000000003C00520010002300240042007E000000000000000000000
+1BBA:0000000000000000000007E00020002007C00040008000800100010002000200
+1BBB:000000000000000007700110011002200220044007C0000007C0000000000000
+1BBC:00000000000000000C0E100210022304228444887C49001100720092006C0000
+1BBD:00000000000000000F3E112219260240024002400FF800000000000000000000
+1BBE:00000000000000001F7C010419640A28124804101FFC00000000000000000000
+1BBF:00000000000000000FE000200F2000400E4000800C8000000000000000000000
+1BC0:000000000000000000000000000001C04220242018E000000000000000000000
+1BC1:000000000000000000000000000001C04220240018E000000000000000000000
+1BC2:0000000000000000000000003B80444008401080210000000000000000000000
+1BC3:000000000000000000000E0031804040000000000CC000000000000000000000
+1BC4:000000000000000000000E003180404008801100220000000000000000000000
+1BC5:000000000000000000000E003180404044404A40318000000000000000000000
+1BC6:000000000000000000001F8020404020402020401F8000000000000000000000
+1BC7:000000000000000000000000000000007FC00000000000000000000000000000
+1BC8:0000000000000000000000000000038044403800000000000000000000000000
+1BC9:00000000000000007E00000007C008201010082007C000000000000000000000
+1BCA:00000000000000007E0000001CE0030004800840078000000000000000000000
+1BCB:0000000000000000000000000E0031804040404071C000000000000000000000
+1BCC:0000000000000000000000000E0031804040000071C000000000000000000000
+1BCD:0000000000000000000000001F00100010000F00008000800000000000000000
+1BCE:0000000000000000000000000E00318040400080010000000000000000000000
+1BCF:0000000000000000000000000E0031804040000001C000000000000000000000
+1BD0:00000000000000000000000001800600180060E00C0003000000000000000000
+1BD1:00000000000000000000000001800600180060000C0003000000000000000000
+1BD2:000000000000000000000E00318040401F002080404000800000000000000000
+1BD3:0000000000000000000000007C0000007FC0000001C000000000000000000000
+1BD4:0000000000000000000000007CE01100120013000CC000000000000000000000
+1BD5:00000000000000000000380044C003000C003000060001800000000000000000
+1BD6:000000000000000000003FC0108009000600090030C000000000000000000000
+1BD7:000000000000000000000000000071802240244019C000000000000000000000
+1BD8:0000000000000000000000003BC0442008000C00030000000000000000000000
+1BD9:0000000000000000000000000E003180404000000E0000000000000000000000
+1BDA:0000000000000000000000000E00318048400400020000000000000000000000
+1BDB:0000000000000000000000000000718022402440180000000000000000000000
+1BDC:000000000000000000000000380044C0112012200C0000000000000000000000
+1BDD:0000000000000000000001800600180060001800060001800000000000000000
+1BDE:000000000000000000000000070018C020201000080000000000000000000000
+1BDF:0000000000000000000000000E00318040400000700000000000000000000000
+1BE0:000000000000000000000780184020004C006300180000000000000000000000
+1BE1:00000000000000000000000030004A004D2048C0300000000000000000000000
+1BE2:00000000000000000000000030000C00030000C0060018000000000000000000
+1BE3:000000000000000000001F8020404620462020401F8000000000000000000000
+1BE4:000000000000000000000E00318040400E00110000000E000000000000000000
+1BE5:000000000000000000000E00000011000E00404031800E000000000000000000
+1BE6:0700000007000000000000000000000000000000000000000000000000000000
+1BE7:0000000000000000000000000008000400020004000800000000000000000000
+1BE8:0040002000100020004000000000000000000000000000000000000000000000
+1BE9:0000000070000000000000000000000000000000000000000000000000000000
+1BEA:000000000000000000000000000C001200120012000C00000000000000000000
+1BEB:00000000000000000000000000000000000C0000000C00000000000000000000
+1BEC:0000000000000000000000000011000A0004000A001100000000000000000000
+1BED:0040002007100020004000000000000000000000000000000000000000000000
+1BEE:0000000000000000000000000000000000000000002000100008001000200000
+1BEF:0000000002000400080000000000000000000000000000000000000000000000
+1BF0:0000000000070000000000000000000000000000000000000000000000000000
+1BF1:0007000000070000000000000000000000000000000000000000000000000000
+1BF2:0000000000000000000000000000000000080004000200000000000000000000
+1BF3:00000000000000000000000000000000000E0000000000000000000000000000
+1BF4:00007FFE7B8E73B67B8E7BB6718E7FFE7FFE61B66FB663866FF66FF67FFE0000
+1BF5:00007FFE7B8E73B67B8E7BB6718E7FFE7FFE61866FBE63866FF66F867FFE0000
+1BF6:00007FFE7B8E73B67B8E7BB6718E7FFE7FFE61CE6FBE638E6FB66FCE7FFE0000
+1BF7:00007FFE7B8E73B67B8E7BB6718E7FFE7FFE61866FF663EE6FDE6FDE7FFE0000
+1BF8:00007FFE7B8E73B67B8E7BB6718E7FFE7FFE61CE6FB663CE6FB66FCE7FFE0000
+1BF9:00007FFE7B8E73B67B8E7BB6718E7FFE7FFE61CE6FB663C66FF66FCE7FFE0000
+1BFA:00007FFE7B8E73B67B8E7BB6718E7FFE7FFE61866FB663866FB66FB67FFE0000
+1BFB:00007FFE7B8E73B67B8E7BB6718E7FFE7FFE618E6FB6638E6FB66F8E7FFE0000
+1BFC:0000101020082388145008201450228821082288145008201450238820081010
+1BFD:00000000000001000280028004401AB021081AB0044002800280010000000000
+1BFE:0000000000000000111022202220222011100888088808881110000000000000
+1BFF:00000000000000000E0001000080008000800080008001000E00000000000000
+1C00:00000000000000000000000003E0040004000FE00400040007C0000000000000
+1C01:0000000000000000000000000FC0040005800640084000800100000000000000
+1C02:00000000000000000000000002600480088008400820042003C0000000000000
+1C03:000000000000000000000000040008401240122011200B400480000000000000
+1C04:0000000000000000000000000400084012403FF011200B400480000000000000
+1C05:000000000000000000000000080007C000800080010001000100000000000000
+1C06:0000000000000000000000000180024002401C20024002400180000000000000
+1C07:0000000000000000000000000060008007800980024004200FE0000000000000
+1C08:0000000000000000000000000360048009400940088004000200000000000000
+1C09:000000000000000000000000082007C00200052008C004000200000000000000
+1C0A:0000000000000000000000000200010004800A40098004000200000000000000
+1C0B:0000000000000000000000000800080005C0022005C008000800000000000000
+1C0C:000000000000000000000000010012400F8002000F8012400100000000000000
+1C0D:00000000000000000000000001800240044008200920092008C0000000000000
+1C0E:0000000000000000000000000FC000800080004000400C401380000000000000
+1C0F:000000000000000000000000062009C0080004000FE000000000000000000000
+1C10:0000000000000000000000001FE008401040102008200E2011C0000000000000
+1C11:0000000000000000000000000FC0100010001FC010800C401380000000000000
+1C12:00000000000000000000000004200A5012501130111008A004C0000000000000
+1C13:0000000000000000000000000300048008400820082004400380000000000000
+1C14:000000000000000000000000024005A008900810081004200240000000000000
+1C15:0000000000000000000000001FC0018002000F80124002400180000000000000
+1C16:0000000000000000000000000FE00100008007E0088009000600000000000000
+1C17:0000000000000000000000000FF00420084008400820042003C0000000000000
+1C18:0000000000000000000000000400088011401540148013600C00000000000000
+1C19:0000000000000000000000000240048004E007801C8002400120000000000000
+1C1A:0000000000000000000000000300040008800700084008800700000000000000
+1C1B:00000000000000000000000010400F8008000400040008001000000000000000
+1C1C:00000000000000000000000004400A2012101110111008A004C0000000000000
+1C1D:0000000000000000000000000030084004400FE0044004400380000000000000
+1C1E:0000000000000000000000001040088005000200050008801040000000000000
+1C1F:0000000000000000000000000300048008400FE0082004400380000000000000
+1C20:0000000000000000000000000400084011401540148013000C00000000000000
+1C21:00000000000000000000000004000800094009400A80042003C0000000000000
+1C22:0000000000000000000000000DD0122015501550122008000400000000000000
+1C23:00000000000000000000000007C009200140038004A0044003A0000000000000
+1C24:0000000000000000000000000000000000000002000A000A0004000000000000
+1C25:0000000000000000000000000010000800080008000800080010000000000000
+1C26:0000000000000000000000000001000200020002000200020001000000000000
+1C27:000000004000A000800040004000400040004000400040004000C00000000000
+1C28:0000000000000000000000002000400040004000400040002000000000000000
+1C29:00000000000000003FC040004000400040004000400040002000000000000000
+1C2A:000000000000000000000000000200010001000100010001000100010012000C
+1C2B:000000000000000000000006000100020001000100010001000100010012000C
+1C2C:0000000000000000000000000000000000000000000000000000020004000F00
+1C2D:0000010002000300000000000000000000000000000000000000000000000000
+1C2E:0000000002800000000000000000000000000000000000000000000000000000
+1C2F:0000010004400000000000000000000000000000000000000000000000000000
+1C30:000003C0042000C0000000000000000000000000000000000000000000000000
+1C31:0000010002800100000000000000000000000000000000000000000000000000
+1C32:0000032004C00000000000000000000000000000000000000000000000000000
+1C33:0000000007C00000000000000000000000000000000000000000000000000000
+1C34:00000000000000000000000080004000A000A000A00040008000000000000000
+1C35:0000000000000000000000000000000040008000800040000000000000000000
+1C36:0FE0100000000000000000000000000000000000000000000000000000000000
+1C37:0000000000000000000000000000000000000000000000000000000000400000
+1C38:00007FFE7BC673BE7BBE7BBE71C67FFE7FFE63CE7DB671CE7DB663CE7FFE0000
+1C39:00007FFE7BC673BE7BBE7BBE71C67FFE7FFE63CE7DB671C67DF663CE7FFE0000
+1C3A:00007FFE7BC673BE7BBE7BBE71C67FFE7FFE63867DB671867DB663B67FFE0000
+1C3B:0000000000000000000000000000008000800080008000800080000000000000
+1C3C:0000000000000000000000000000024002400240024002400240000000000000
+1C3D:0000000000000000000000000000000002200140008001400220000000000000
+1C3E:0000000000000000000000000000000002200140049001400220000000000000
+1C3F:0000000000000000000000001088091004A0042004A009101088000000000000
+1C40:0000000000000000000000000000038004400440044003800000000000000000
+1C41:0000000000000000000000000100028002C00140004000800100000000000000
+1C42:00000000000000000000000007C0082000C003000400030000C0000000000000
+1C43:0000000000000000000000000F80104007E00810002007C00020000000000000
+1C44:000000000000000000000000022005C004000800083007C00000000000000000
+1C45:00000000000000000000000008100420046004A0052006200810000000000000
+1C46:00000000000000000000000000200050008000400820061001E0000000000000
+1C47:0000000000000000000000000080044002400240014001800200000000000000
+1C48:0000000000000000000000000180024002000400040003800060000000000000
+1C49:0000000000000000000000000180024002800260020002000100000000000000
+1C4A:00007FFE7BC673BE7BBE7BBE71C67FFE7FFE6D866DB661867DB67DB67FFE0000
+1C4B:00007FFE7BC673BE7BBE7BBE71C67FFE7FFE6D8E6DB6618E7DB67D8E7FFE0000
+1C4C:00007FFE7BC673BE7BBE7BBE71C67FFE7FFE6DC66DBE61BE7DBE7DC67FFE0000
+1C4D:0000000000000000000000001F80008003E00080008000800100000000000000
+1C4E:0000000000000000000000001F80008003E0008003E000800100000000000000
+1C4F:0000000000000000000000000D2013E00120012001200F201040000000000000
+1C50:00000038444444444444444444380000
+1C51:00000062524A464040404020100E0000
+1C52:00000018242414081020424224180000
+1C53:000000324A4A3E1020204040300C0000
+1C54:0000001E2040404060524E4224180000
+1C55:00000010204648505048464224180000
+1C56:0000005C22524C4040404020100C0000
+1C57:0000000C523204081020424224180000
+1C58:000000344A5A64404040404224180000
+1C59:0000001C204040404C52524A24180000
+1C5A:0000001C22660A1222424242221C0000
+1C5B:0000003C4242424242424242423C0000
+1C5C:0000001C2240404E50504E4224180000
+1C5D:0000001C2244481026104844221C0000
+1C5E:00000048546242424242625448400000
+1C5F:000000245ADA1232525292A2A4480000
+1C60:00000040485462424242422214080000
+1C61:00000048444242424242426254480000
+1C62:0000001222424242424242462A120000
+1C63:00000064928A0A0A12E2824224180000
+1C64:0000003844060A0A1212222242420000
+1C65:000000424244444848505060221C0000
+1C66:000000444482828282828292AA440000
+1C67:00000010284442424242462A12020000
+1C68:0000007804024222120A0622528C0000
+1C69:00000040485462420202422214080000
+1C6A:0000003844444444444444BA827C0000
+1C6B:00000010284482925410704044380000
+1C6C:00000044AA9282828282828244440000
+1C6D:000000304884848C90A0A0A2924C0000
+1C6E:000000384404080810102020423C0000
+1C6F:0000003C62A4A42424242525463C0000
+1C70:00000058949292929292929252340000
+1C71:0000003CC644444848505060221C0000
+1C72:0000003844060A0A12122222C37E0000
+1C73:0000001824420E1212120E4224180000
+1C74:00000048546242424242424244480000
+1C75:00000034529292929292929294580000
+1C76:000000629288080A12E2824224180000
+1C77:000000182422124E82828292AA440000
+1C78:00000000181800000000000000000000
+1C79:00000000000000000000001818000000
+1C7A:00000000181800000000001818000000
+1C7B:00000000000060920C00000000000000
+1C7C:00000000000000380000000000000000
+1C7D:000000304844241C0404044428100000
+1C7E:00000000001010101010101000000000
+1C7F:00000000002424242424242400000000
+1C80:00000000001C2A4A4440444A2A1C0000
+1C81:0000000000001E1222222222227F4141
+1C82:00000000000038444444444444380000
+1C83:0000000000001C2240404040221C0000
+1C84:00000000324E02020202020202020000
+1C85:0000000000007F494949494949490000
+1C86:000000007010101010101C12121C0000
+1C87:0000202078202020203C2222223C0000
+1C88:000000444A2A28103844444444380000
+1C89:00007FFE7BC673BE7BBE7BBE71C67FFE7FFE73CE6DB673C66DF673CE7FFE0000
+1C8A:00007FFE7BC673BE7BBE7BBE71C67FFE7FFE73866DB673866DB673B67FFE0000
+1C8B:00007FFE7BC673BE7BBE7BBE71C67FFE7FFE738E6DB6738E6DB6738E7FFE0000
+1C8C:00007FFE7BC673BE7BBE7BBE71C67FFE7FFE73C66DBE73BE6DBE73C67FFE0000
+1C8D:00007FFE7BC673BE7BBE7BBE71C67FFE7FFE738E6DB673B66DB6738E7FFE0000
+1C8E:00007FFE7BC673BE7BBE7BBE71C67FFE7FFE73866DBE738E6DBE73867FFE0000
+1C8F:00007FFE7BC673BE7BBE7BBE71C67FFE7FFE73866DBE738E6DBE73BE7FFE0000
+1C90:000000002020101008040242423C0000
+1C91:000000002038080834424242423C0000
+1C92:000000304848080834424242423C0000
+1C93:000000002C525252524C40201C620000
+1C94:000000003C42420202022242423C0000
+1C95:000000003C4242021C020242423C0000
+1C96:0000000020505054381C1212120C0000
+1C97:00000000344A4A4A4A4A4A4A4A320000
+1C98:000000003C4242424242424242240000
+1C99:000000000C0202021C020242423C0000
+1C9A:000000002A555555414142201E610000
+1C9B:000000003C424202023E4242423C0000
+1C9C:00000000023C4040407C4242423C0000
+1C9D:00000000285454545444444444240000
+1C9E:0000000020180402021C0242423C0000
+1C9F:00000000060A525222021222221C0000
+1CA0:00000000043840685454545444240000
+1CA1:00000000404040485048444444380000
+1CA2:000000001824243C66665A42423C0000
+1CA3:000000006C12120202020222221C0000
+1CA4:00000000344A4A4A4A340212221C0000
+1CA5:00000000040C04041C24040444380000
+1CA6:000000002C525252424440201C620000
+1CA7:00000000224242261A022242423C0000
+1CA8:0000000028545404041C242424180000
+1CA9:00000000384478405C62424242420000
+1CAA:000000004C4242425C424242423C0000
+1CAB:0000000004020202023E4242423C0000
+1CAC:0000000028545454407C442828100000
+1CAD:000000000818280819261D0444380000
+1CAE:00000000404040485078444444380000
+1CAF:00000000CCA2A2241418304A2AC40000
+1CB0:0000100C02120C02120C0242423C0000
+1CB1:00000000C8A6A1A9A6C1928C44380000
+1CB2:000000003C4242424224241824420000
+1CB3:000000003E0204081C020242423C0000
+1CB4:0000000008100C02021C0242423C0000
+1CB5:000000003844443E043E444444380000
+1CB6:00000000101010385454381010100000
+1CB7:000000003C42420408102042423C0000
+1CB8:000000004442424264584044423C0000
+1CB9:000000003C424242423C1012120C0000
+1CBA:000000003C42424040300C1C22400000
+1CBB:00007FFE7BC673BE7BBE7BBE71C67FFE7FFE638E6DB6638E6DB6638E7FFE0000
+1CBC:00007FFE7BC673BE7BBE7BBE71C67FFE7FFE63C66DBE63BE6DBE63C67FFE0000
+1CBD:000000003C42422010080442423C0000
+1CBE:000000004224182424424242423C0000
+1CBF:000000003C42424242424242423C0000
+1CC0:00000000028001000380044029281AB029280440038001000280000000000000
+1CC1:000000000000000001C00220055004900550022001C000000000000000000000
+1CC2:000000000000000001C0022005D0041005D0022001C000000000000000000000
+1CC3:000000000000000001C00220041004100410022001C000000000000000000000
+1CC4:00000000000000001BBB200823CB481055969420F2AC002001C8024801B00000
+1CC5:00000000000000001CF8040004F0080009E0100013C000000000000000000000
+1CC6:00000000000000000EFF100010FE2200253C44807C5800000000000000000000
+1CC7:0000000000000000667D0884C8051188914B2250BE3600000000000000000000
+1CC8:00007FFE7BC673BE7BBE7BBE71C67FFE7FFE71CE6FB66FCE6FB671CE7FFE0000
+1CC9:00007FFE7BC673BE7BBE7BBE71C67FFE7FFE71CE6FB66FC66FF671CE7FFE0000
+1CCA:00007FFE7BC673BE7BBE7BBE71C67FFE7FFE71866FB66F866FB671B67FFE0000
+1CCB:00007FFE7BC673BE7BBE7BBE71C67FFE7FFE718E6FB66F8E6FB6718E7FFE0000
+1CCC:00007FFE7BC673BE7BBE7BBE71C67FFE7FFE71C66FBE6FBE6FBE71C67FFE0000
+1CCD:00007FFE7BC673BE7BBE7BBE71C67FFE7FFE718E6FB66FB66FB6718E7FFE0000
+1CCE:00007FFE7BC673BE7BBE7BBE71C67FFE7FFE71866FBE6F8E6FBE71867FFE0000
+1CCF:00007FFE7BC673BE7BBE7BBE71C67FFE7FFE71866FBE6F8E6FBE71BE7FFE0000
+1CD0:0080014002200000000000000000000000000000000000000000000000000000
+1CD1:008001C002A00000000000000000000000000000000000000000000000000000
+1CD2:000003E000000000000000000000000000000000000000000000000000000000
+1CD3:0000012002400480000000000000000000000000000000000000000000000000
+1CD4:0000000000000000000000000000003800000000000000000000000000000000
+1CD5:0000000000000000000000000000000000000000000000000000089004900360
+1CD6:00000000000000000000000000000000000000000000000000000000040007E0
+1CD7:00000000000000000000000000000000000000000000000000000300040003E0
+1CD8:00000000000000000000000000000000000000000000000000000420022001C0
+1CD9:0000000000000000000000000000000000000000000000000000008001400220
+1CDA:0140014001400000000000000000000000000000000000000000000000000000
+1CDB:02A002A002A00000000000000000000000000000000000000000000000000000
+1CDC:0000000000000000000000000000000000000000000000000000008000800080
+1CDD:0000000000000000000000000000000000000000000000000000000000800000
+1CDE:0000000000000000000000000000000000000000000000000000000001200000
+1CDF:0000000000000000000000000000000000000000000000000000000004900000
+1CE0:007C008000600000000000000000000000000000000000000000000000000000
+1CE1:000C0012001100100010001000100010001000100010001000100010001000F0
+1CE2:0000000000000000000000000240000007E00000024000000000000000000000
+1CE3:0000000000000000002000100008000800700000000000000000000000000000
+1CE4:000000000000000004000800100010000E000000000000000000000000000000
+1CE5:000000000000000000000000000000000E001000100008000400000000000000
+1CE6:0000000000000000000000000000000000700008000800100020000000000000
+1CE7:0000000000180024002000100008000800700000000000000000000000000000
+1CE8:000000000000000000000000000000000E001000100008000400240018000000
+1CE9:00000000000000000C6012902C682008200820081010082007C0000000000000
+1CEA:00000000000004400AA00AA004400820101010101010082007C0000000000000
+1CEB:00000000000004600A900A7004100810101010101010082007C0000000000000
+1CEC:00000000000004000A200A500450083010181014102408480780000000000000
+1CED:0000000000000000000000000000000000000000000000000100008000400020
+1CEE:0000000000000780080008000800072004000400044003800000000000000000
+1CEF:000000000000078008400900040003C004000500048003000000000000000000
+1CF0:0000018002400200011001800240042004200420024001800000000000000000
+1CF1:0000000000000000020004000840080007E00010021000200040000000000000
+1CF2:00000000000000000810042003C00000000003C0042008100000000000000000
+1CF3:0000000000000000081004200240024002400240042008100000000000000000
+1CF4:0000108008800700000000000000000000000000000000000000000000000000
+1CF5:AAAA000180000001901008218440028181000281844008219010000180005555
+1CF6:AAAA000180000001800000018000111191100EE1800000018000000180005555
+1CF7:0003000400080008000800080008000800080008000800080010001000100000
+1CF8:0000030004800480030000000000000000000000000000000000000000000000
+1CF9:0000183024482448183000000000000000000000000000000000000000000000
+1CFA:00000000000000000C6012901C700FE000000C6012901C700FE0000000000000
+1CFB:00007FFE7BC673BE7BBE7BBE71C67FFE7FFE618E6FB6638E6FB66F8E7FFE0000
+1CFC:00007FFE7BC673BE7BBE7BBE71C67FFE7FFE61C66FBE63BE6FBE6FC67FFE0000
+1CFD:00007FFE7BC673BE7BBE7BBE71C67FFE7FFE618E6FB663B66FB66F8E7FFE0000
+1CFE:00007FFE7BC673BE7BBE7BBE71C67FFE7FFE61866FBE638E6FBE6F867FFE0000
+1CFF:00007FFE7BC673BE7BBE7BBE71C67FFE7FFE61866FBE638E6FBE6FBE7FFE0000
+1D00:000000000000102844447C4444440000
+1D01:0000000000001E28487E4848484E0000
+1D02:0000000000003E4909097E48493E0000
+1D03:000000000000784448FE484444780000
+1D04:0000000000003C4240404040423C0000
+1D05:00000000000078444444444444780000
+1D06:000000000000784444E4444444780000
+1D07:0000000000007C4040784040407C0000
+1D08:0000000000003C4202021C02423C0000
+1D09:0000000000007C101010101018001010
+1D0A:0000000000001F040404040444380000
+1D0B:00000000000022242830302824220000
+1D0C:000000000000202028302060203E0000
+1D0D:000000000000222236362A2A22220000
+1D0E:000000000000444C4C54546464440000
+1D0F:0000000000003C4242424242423C0000
+1D10:0000000000003C4202020202423C0000
+1D11:00000000000000003E414141413E0000
+1D12:00000000000000003E41414141220000
+1D13:00000000000000203E514949453E0200
+1D14:00000000000036490909794949360000
+1D15:00000000000044444438444444380000
+1D16:0000000000003C424242000000000000
+1D17:000000000000000000004242423C0000
+1D18:0000000000007C42427C404040400000
+1D19:0000000000003E42423E122242420000
+1D1A:000000000000424222123E42423E0000
+1D1B:0000000000007F080808080808080000
+1D1C:000000000000424242424242423C0000
+1D1D:00000000000000007F020101017E0000
+1D1E:00000000000000001F420101411E0000
+1D1F:000000000000007F01017E01017E0000
+1D20:00000000000041412222141408080000
+1D21:00000000000042425A5A666642420000
+1D22:0000000000007E0204081020407E0000
+1D23:0000000000007E04081C0202423C0000
+1D24:000000003C4242021C384040423C0000
+1D25:0000000000387CFEFE7C3810926C0000
+1D26:0000000000007E404040404040400000
+1D27:00000000000008081414222241410000
+1D28:0000000000007F222222222222220000
+1D29:0000000000007C42427C404040400000
+1D2A:000000000000494949493E0808080000
+1D2B:0000000000001E121212121222620000
+1D2C:000000102844447C4444000000000000
+1D2D:0000001E28487E48484E000000000000
+1D2E:00000078444478444478000000000000
+1D2F:000000784448FE484478000000000000
+1D30:00000078444444444478000000000000
+1D31:0000007C40407840407C000000000000
+1D32:0000007C04043C04047C000000000000
+1D33:0000003C40404E42463A000000000000
+1D34:0000004242427E424242000000000000
+1D35:0000007C10101010107C000000000000
+1D36:0000001F040404044438000000000000
+1D37:00000022242830282422000000000000
+1D38:0000002020202020203E000000000000
+1D39:0000002236362A222222000000000000
+1D3A:000000446464544C4C44000000000000
+1D3B:000000444C4C54646444000000000000
+1D3C:0000003C42424242423C000000000000
+1D3D:00000044443844444438000000000000
+1D3E:0000007C42427C404040000000000000
+1D3F:0000007C42427C484442000000000000
+1D40:0000007F080808080808000000000000
+1D41:0000004242424242423C000000000000
+1D42:000000444444546C6C44000000000000
+1D43:000000000038043C443C000000000000
+1D44:00000000007844784038000000000000
+1D45:00000000003A4642463A000000000000
+1D46:00000000007C12FC907C000000000000
+1D47:00000040404078444478000000000000
+1D48:0000000404043C44443C000000000000
+1D49:000000000038447C4038000000000000
+1D4A:000000000038047C4438000000000000
+1D4B:00000000003C4038403C000000000000
+1D4C:00000000007804380478000000000000
+1D4D:00000000003A44443C04380000000000
+1D4E:00000000007C10101018001000000000
+1D4F:00000040404850605048000000000000
+1D50:00000000007649494949000000000000
+1D51:00000000005C6242424A040000000000
+1D52:00000000003844444438000000000000
+1D53:00000000003844044438000000000000
+1D54:00000000003844440000000000000000
+1D55:00000000000000444438000000000000
+1D56:00000000007844444478404000000000
+1D57:00000010107C1010100C000000000000
+1D58:00000000004444444C34000000000000
+1D59:00000000007C08040478000000000000
+1D5A:00000000004949494937000000000000
+1D5B:00000000004444282810000000000000
+1D5C:000000387CFEFE7C38926C0000000000
+1D5D:0000003844447C42625C400000000000
+1D5E:00000000002252140810200000000000
+1D5F:00000038404038444438000000000000
+1D60:0000000000264949493E080800000000
+1D61:00000000006112141830488600000000
+1D62:00000000000000001000301010107C00
+1D63:00000000000000000000586440404000
+1D64:000000000000000000004444444C3400
+1D65:00000000000000000000444428281000
+1D66:00000000000000003844447C42625C40
+1D67:0000000000000000000022520C102020
+1D68:00000000000000000000384478403008
+1D69:00000000000000000000264949493E08
+1D6A:00000000000000000000611214183048
+1D6B:0000000000008E89898F8888996E0000
+1D6C:000000202870AC3222222222322C0000
+1D6D:000000050E14344C444444444C340000
+1D6E:0000000C1010107C1010143850100000
+1D6F:0000000000007C4A4A4A7BCE4A4A0000
+1D70:0000000000002C322222336E22220000
+1D71:0000000000002C3222336E22322C2020
+1D72:0000000000002C3220203966A0200000
+1D73:0000000000000E111110395610100000
+1D74:0000000000003C424033CC02423C0000
+1D75:0000000010107C1010325C10100C0000
+1D76:0000000000007E04086A9C10207E0000
+1D77:00000000003C42423C041C2222225C40
+1D78:00004242427E42424242000000000000
+1D79:0000000000007E04081010083C42423C
+1D7A:000000000000004810501060105C7CE2114212421442184210422C4200000000
+1D7B:0000000000007C10107C1010107C0000
+1D7C:0000000000007010107C1010100C0000
+1D7D:0000000000002C3222227F22322C2020
+1D7E:0000000000002222227F2222221C0000
+1D7F:0000000000004224FF42424224180000
+1D80:0000004040405C6242424242635D0106
+1D81:0000000202023A4642424242463B0106
+1D82:0000000C1010107C1010101018180830
+1D83:0000000000003A44444444473D05857A
+1D84:0000004040404448506050484642020C
+1D85:000000180808080808080808083E020C
+1D86:000000000000744A4A4A4A4A4B4B0106
+1D87:0000000000005C624242424243430106
+1D88:000000000000586444444444665A424C
+1D89:0000000000002C322220202030301060
+1D8A:0000000000003C4240300C02433D0106
+1D8B:0000000C101010101010101E1212620C
+1D8C:0000000000004242422424261A1A020C
+1D8D:0000000000004444281010284646020C
+1D8E:0000000000007E0204081020407E020C
+1D8F:0000000000003844043C44444E320203
+1D90:000000000000344C444444444C360203
+1D91:000003040404344C44444444443C0403
+1D92:0000000000003C42427E4040423C0403
+1D93:0000000000003C42403C4040423C0403
+1D94:0000000000003C42023C0202427C4030
+1D95:00000000000070880808FE8A8A720203
+1D96:000000080800180808080808083C0403
+1D97:0000000000003C4202020202427C4030
+1D98:0000000C101010101010101010604030
+1D99:0000000000004444444444444C360203
+1D9A:0000000000007E0408101C02023C2018
+1D9B:00000000005C6242625C000000000000
+1D9C:00000000003840404038000000000000
+1D9D:00000000003840586438400000000000
+1D9E:0000641828043C444438000000000000
+1D9F:00000000007804380478000000000000
+1DA0:0000000C10107C101010000000000000
+1DA1:000000080808083E0848300000000000
+1DA2:00000000003A4642463A023C00000000
+1DA3:0000004444444C340404000000000000
+1DA4:0000001000301038107C000000000000
+1DA5:0000000000301010100C000000000000
+1DA6:0000007C10101010107C000000000000
+1DA7:0000007C10107C10107C000000000000
+1DA8:000000080018080808384C3200000000
+1DA9:00000070101010101010100C00000000
+1DAA:00000070101010101818083000000000
+1DAB:0000002020202020203E000000000000
+1DAC:00000000007649494949010600000000
+1DAD:00000000004949494937010100000000
+1DAE:00000000002C32222222204000000000
+1DAF:00000000005864444444040200000000
+1DB0:0000002232322A262622000000000000
+1DB1:000000000038447C4438000000000000
+1DB2:00000000103854545438100000000000
+1DB3:00000000003840380478403000000000
+1DB4:0000000C101010101010600000000000
+1DB5:00000010107C1010100E020C00000000
+1DB6:000000000022227F261A000000000000
+1DB7:00000042244242422418000000000000
+1DB8:0000002222222222221C000000000000
+1DB9:0000000000CC44444830000000000000
+1DBA:00000010282828444444000000000000
+1DBB:00000000007C0810207C000000000000
+1DBC:0000007C04081020447C040300000000
+1DBD:0000007E02041826497E080800000000
+1DBE:00000000007E0408103C027C00000000
+1DBF:0000001824427E422418000000000000
+1DC0:24100824000000000000000000000000
+1DC1:24081024000000000000000000000000
+1DC2:00000000000000000000000070381C0E
+1DC3:00022418000000000000000000000000
+1DC4:00020478000000000000000000000000
+1DC5:0040201E000000000000000000000000
+1DC6:00780402000000000000000000000000
+1DC7:003C4080000000000000000000000000
+1DC8:00885422000000000000000000000000
+1DC9:00225488000000000000000000000000
+1DCA:0000000000000000000000002C302020
+1DCB:008E7000000000000000000000000000
+1DCC:00E21C00000000000000000000000000
+1DCD:0000018006600810000000000000000000000000000000000000000000000000
+1DCE:00300808100000000000000000000000
+1DCF:00000000000000000000001020380810
+1DD0:0000000000000000000000000000113F
+1DD1:0064924C000000000000000000000000
+1DD2:00182414040810000000000000000000
+1DD3:00926C00000000000000000000000000
+1DD4:EC127C906E0000000000000000000000
+1DD5:EC1272926C0000000000000000000000
+1DD6:E1117A9A640000000000000000000000
+1DD7:1C2020201C0810000000000000000000
+1DD8:30081C24180000000000000000000000
+1DD9:2810281C241800000000000000000000
+1DDA:1C241C04380000000000000000000000
+1DDB:1C202C24180000000000000000000000
+1DDC:20242834240000000000000000000000
+1DDD:180808081C0000000000000000000000
+1DDE:202020203C0000000000000000000000
+1DDF:446C5444440000000000000000000000
+1DE0:58644444000000000000000000000000
+1DE1:4464544C440000000000000000000000
+1DE2:38243828240000000000000000000000
+1DE3:18240408040200000000000000000000
+1DE4:1C201804380000000000000000000000
+1DE5:18242060202000000000000000000000
+1DE6:3C0418203C0000000000000000000000
+1DE7:001C24241C0000000000000000000000
+1DE8:101C121C000000000000000000000000
+1DE9:18242824380000000000000000000000
+1DEA:38043C24180000000000000000000000
+1DEB:0C103810100000000000000000000000
+1DEC:10381038100000000000000000000000
+1DED:00182424588000000000000000000000
+1DEE:38243820000000000000000000000000
+1DEF:0C101010600000000000000000000000
+1DF0:0024245C800000000000000000000000
+1DF1:00925428000000000000000000000000
+1DF2:14001C241C0000000000000000000000
+1DF3:28001824180000000000000000000000
+1DF4:28002828380000000000000000000000
+1DF5:0010107C000000000000000000000000
+1DF6:0012120C000000000000000000000000
+1DF7:00484830000000000000000000000000
+1DF8:00303000000000000000000000000000
+1DF9:0000000000000000000000000000827C
+1DFA:00007FFE7B8E73B67BB67BB6718E7FFE7FFE61866FB663866FB66FB67FFE0000
+1DFB:49499292000000000000000000000000
+1DFC:000000000000000000000000000000000000000000000000000007E018182004
+1DFD:0000000000000000000000324C00324C
+1DFE:08102010080000000000000000000000
+1DFF:000000000000000000000000004A2440
+1E00:0000000018242442427E424242182418
+1E01:0000000000003C42023E42463A182418
+1E02:001000007C4242427C424242427C0000
+1E03:0000004840405C6242424242625C0000
+1E04:000000007C4242427C424242427C0010
+1E05:0000004040405C6242424242625C0008
+1E06:000000007C4242427C424242427C003C
+1E07:0000004040405C6242424242625C003C
+1E08:081020003C42424040404042423C0830
+1E09:0000081020003C4240404040423C0830
+1E0A:00100000784442424242424244780000
+1E0B:0000001202023A4642424242463A0000
+1E0C:00000000784442424242424244780010
+1E0D:0000000202023A4642424242463A0010
+1E0E:0000000078444242424242424478003C
+1E0F:0000000202023A4642424242463A003C
+1E10:00000000784442424242424244781020
+1E11:0000000202023A4642424242463A0810
+1E12:00000000784442424242424244783048
+1E13:0000000202023A4642424242463A1824
+1E14:10083C007E4040407C404040407E0000
+1E15:201008003C003C42427E4040423C0000
+1E16:08103C007E4040407C404040407E0000
+1E17:081020003C003C42427E4040423C0000
+1E18:000000007E4040407C404040407E1824
+1E19:0000000000003C42427E4040423C1824
+1E1A:000000007E4040407C404040407E324C
+1E1B:0000000000003C42427E4040423C324C
+1E1C:00221C007E4040407C404040407E0418
+1E1D:0000221C00003C42427E4040423C0830
+1E1E:001000007E4040407C40404040400000
+1E1F:0800000C1010107C1010101010100000
+1E20:00003C003C424240404E4242463A0000
+1E21:0000000078023A44444438203C42423C
+1E22:00001000444444447C44444444440000
+1E23:0000004840405C624242424242420000
+1E24:00000000444444447C44444444440010
+1E25:0000004040405C624242424242420008
+1E26:00240000424242427E42424242420000
+1E27:2400004040405C624242424242420000
+1E28:00000000424242427E42424262621060
+1E29:0000004040405C624242424262621060
+1E2A:0000000082828282FE82828282822838
+1E2B:0000004040404E51614141414141141C
+1E2C:000000003E08080808080808083E324C
+1E2D:000000080800180808080808083E324C
+1E2E:04082A003E08080808080808083E0000
+1E2F:000204082200180808080808083E0000
+1E30:00040810424448506060504844420000
+1E31:00020448404044485060504844420000
+1E32:00000000424448506060504844420010
+1E33:00000040404044485060504844420010
+1E34:0000000042444850606050484442003C
+1E35:0000004040404448506050484442003C
+1E36:000000004040404040404040407E0010
+1E37:000000180808080808080808083E0008
+1E38:00003C004040404040404040407E0010
+1E39:003C00180808080808080808083E0008
+1E3A:000000004040404040404040407E003C
+1E3B:000000180808080808080808083E001C
+1E3C:000000004040404040404040407E1824
+1E3D:000000180808080808080808083E1824
+1E3E:00040810424266665A5A424242420000
+1E3F:00000408100076494949494949490000
+1E40:00001000424266665A5A424242420000
+1E41:00000008000076494949494949490000
+1E42:00000000424266665A5A424242420008
+1E43:00000000000076494949494949490008
+1E44:0000080042626252524A4A4646420000
+1E45:0000000800005C624242424242420000
+1E46:0000000042626252524A4A4646420008
+1E47:0000000000005C624242424242420008
+1E48:0000000042626252524A4A464642003C
+1E49:0000000000005C62424242424242003C
+1E4A:0000000042626252524A4A4646421824
+1E4B:0000000000005C624242424242421824
+1E4C:0408324C3C42424242424242423C0000
+1E4D:020408324C003C4242424242423C0000
+1E4E:2400324C3C42424242424242423C0000
+1E4F:002400324C003C4242424242423C0000
+1E50:10083C003C42424242424242423C0000
+1E51:201008003C003C4242424242423C0000
+1E52:08103C003C42424242424242423C0000
+1E53:081020003C003C4242424242423C0000
+1E54:000408107C4242427C40404040400000
+1E55:0000040810005C6242424242625C4040
+1E56:001000007C4242427C40404040400000
+1E57:0000000800005C6242424242625C4040
+1E58:001000007C4242427C48444442420000
+1E59:0000001000005C624240404040400000
+1E5A:000000007C4242427C48444442420008
+1E5B:0000000000005C624240404040400800
+1E5C:00003C007C4242427C48444442420008
+1E5D:000000003C005C624240404040400800
+1E5E:000000007C4242427C4844444242003C
+1E5F:0000000000005C62424040404040003C
+1E60:001000003C424240300C0242423C0000
+1E61:0000001000003C4240300C02423C0000
+1E62:000000003C424240300C0242423C0008
+1E63:0000000000003C4240300C02423C0008
+1E64:240810003C424240300C0242423C0000
+1E65:0020081020003C4240300C02423C0000
+1E66:082214083C424240300C0242423C0000
+1E67:0008002214083C4240300C02423C0000
+1E68:000800003C424240300C0242423C0008
+1E69:0000000800003C4240300C02423C0008
+1E6A:000800007F0808080808080808080000
+1E6B:001000001010107C10101010100C0000
+1E6C:000000007F0808080808080808080008
+1E6D:000000001010107C10101010100C0010
+1E6E:000000007F080808080808080808003E
+1E6F:000000001010107C10101010100C003C
+1E70:000000007F0808080808080800081422
+1E71:000000001010107C10101010120C1422
+1E72:000000004242424242424242423C0024
+1E73:000000000000424242424242463A0028
+1E74:000000004242424242424242423C324C
+1E75:000000000000424242424242463A324C
+1E76:000000004242424242424242423C1422
+1E77:000000000000424242424242463A1422
+1E78:0408324C0042424242424242423C0000
+1E79:020408324C00424242424242463A0000
+1E7A:24003C004242424242424242423C0000
+1E7B:000024003C00424242424242463A0000
+1E7C:0000324C004141222222141408080000
+1E7D:0000324C000042424224242418180000
+1E7E:00000000414141222222141408080008
+1E7F:00000000000044444428282810100010
+1E80:00201008424242425A5A666642420000
+1E81:00001008040041494949494949360000
+1E82:00040810424242425A5A666642420000
+1E83:00000408100041494949494949360000
+1E84:00240000424242425A5A666642420000
+1E85:00000022000041494949494949360000
+1E86:001000004444444454546C6C44440000
+1E87:00000008000041494949494949360000
+1E88:000000004444444454546C6C44440010
+1E89:00000000000041494949494949360008
+1E8A:00100000444428281010282844440000
+1E8B:00000010000044442810102844440000
+1E8C:00240000424224241818242442420000
+1E8D:00000024000042422418182442420000
+1E8E:00080000414122221408080808080000
+1E8F:0000000800004242424242261A02023C
+1E90:182400007E02020408102040407E0000
+1E91:0000182400007E0204081020407E0000
+1E92:000000007E02020408102040407E0008
+1E93:0000000000007E0204081020407E0008
+1E94:000000007E02020408102040407E003C
+1E95:0000000000007E0204081020407E003C
+1E96:0000004040405C62424242424242003C
+1E97:000044001010107C10101010100C0000
+1E98:00081408000041494949494949360000
+1E99:0008140800004242424242261A02023C
+1E9A:0002010102003C42023E4242463A0000
+1E9B:0010000C101010301010101010100000
+1E9C:0000000C101010341830501010100000
+1E9D:0000000C107C10301010101010100000
+1E9E:0000003E424444484C424242524C0000
+1E9F:000000001C20202018244242423C0000
+1EA0:0000000010282844447C444444440010
+1EA1:0000000000003C42023E4242463A0010
+1EA2:4020204018242442427E424242420000
+1EA3:0008040408003C42023E4242463A0000
+1EA4:0214284410282844447C444444440000
+1EA5:0002142844003C42023E4242463A0000
+1EA6:4028142208141422223E222222220000
+1EA7:0040281422003C42023E4242463A0000
+1EA8:0402142854282844447C444444440000
+1EA9:02010A1422003C42023E4242463A0000
+1EAA:192608142208141422223E2222220000
+1EAB:1926081422003C42023E4242463A0000
+1EAC:0008142208141422223E222222220008
+1EAD:0000182400003C42023E4242463A0008
+1EAE:0810443810282844447C444444440000
+1EAF:0408104438003C42023E4242463A0000
+1EB0:2010443810282844447C444444440000
+1EB1:201008221C003C42023E4242463A0000
+1EB2:1008B27C10282844447C444444440000
+1EB3:0808104438003C42023E4242463A0000
+1EB4:324C827C10282844447C444444440000
+1EB5:324C00423C003C42023E4242463A0000
+1EB6:0000443810282844447C444444440010
+1EB7:0000002418003C42023E4242463A0010
+1EB8:000000007E4040407C404040407E0010
+1EB9:0000000000003C42427E4040423C0010
+1EBA:100808107E4040407C404040407E0000
+1EBB:1008081000003C42427E4040423C0000
+1EBC:00324C007E4040407C404040407E0000
+1EBD:000000324C003C42427E4040423C0000
+1EBE:021428447E4040407C404040407E0000
+1EBF:0002142844003C42427E4040423C0000
+1EC0:402814227E4040407C404040407E0000
+1EC1:0040281422003C42427E4040423C0000
+1EC2:04122A447E4040407C404040407E0000
+1EC3:0402122C44003C42427E4040423C0000
+1EC4:324C1028447E40407C404040407E0000
+1EC5:324C102844003C42427E4040423C0000
+1EC6:001824007E4040407C404040407E0008
+1EC7:0000182400003C42427E4040423C0008
+1EC8:080404083E08080808080808083E0000
+1EC9:001008081000180808080808083E0000
+1ECA:000000003E08080808080808083E0008
+1ECB:000000080800180808080808083E0008
+1ECC:000000003C42424242424242423C0008
+1ECD:0000000000003C4242424242423C0008
+1ECE:100808103C42424242424242423C0000
+1ECF:0010080810003C4242424242423C0000
+1ED0:021428443C42424242424242423C0000
+1ED1:0002142844003C4242424242423C0000
+1ED2:402814223C42424242424242423C0000
+1ED3:0040281422003C4242424242423C0000
+1ED4:04122A443C42424242424242423C0000
+1ED5:0402122C44003C4242424242423C0000
+1ED6:324C1028443C424242424242423C0000
+1ED7:324C102844003C4242424242423C0000
+1ED8:001824003C42424242424242423C0008
+1ED9:0000182400003C4242424242423C0008
+1EDA:08102201394644444444444444380000
+1EDB:00000810220139464444444444380000
+1EDC:20100A01394644444444444444380000
+1EDD:000020100A0139464444444444380000
+1EDE:10080A11394644444444444444380000
+1EDF:00100808120139464444444444380000
+1EE0:00324C02394546444444444444380000
+1EE1:00324C00020139464444444444380000
+1EE2:00000201394644444444444444380010
+1EE3:00000000020139464444444444380010
+1EE4:000000004242424242424242423C0008
+1EE5:000000000000424242424242463A0008
+1EE6:100808104242424242424242423C0000
+1EE7:001008081000424242424242463A0000
+1EE8:04081201454644444444444444380000
+1EE9:0000040812014546444444444C340000
+1EEA:40201201454644444444444444380000
+1EEB:0000402012014546444444444C340000
+1EEC:10080A11454644444444444444380000
+1EED:0010080812014546444444444C340000
+1EEE:324C0201454644444444444444380000
+1EEF:00324C0002014546444444444C340000
+1EF0:00000201454644444444444444380010
+1EF1:0000000002014546444444444C340010
+1EF2:20100800414122221408080808080000
+1EF3:0020100800004242424242261A02023C
+1EF4:00000000414122221408080808080008
+1EF5:0000000000004242424242261A023C08
+1EF6:08040408414122221408080808080000
+1EF7:0010080810004242424242261A02023C
+1EF8:00324C00414122221408080808080000
+1EF9:0000324C00004242424242261A02023C
+1EFA:000000F0505050505050505050FE0000
+1EFB:0000006C2424247E2424242424FF0000
+1EFC:000000000408101020244242423C0000
+1EFD:00000000000008102020484444380000
+1EFE:00000000424222141408080808384830
+1EFF:00000000000042422214140808384830
+1F00:000030102000324A444444444A320000
+1F01:000030201000324A444444444A320000
+1F02:000068284400324A444444444A320000
+1F03:000068482400324A444444444A320000
+1F04:000064284800324A444444444A320000
+1F05:000064482800324A444444444A320000
+1F06:64980030102000324A4444444A320000
+1F07:64980030201000324A4444444A320000
+1F08:C040800018242442427E424242420000
+1F09:C080400018242442427E424242420000
+1F0A:D050880018242442427E424242420000
+1F0B:D090480018242442427E424242420000
+1F0C:C850900018242442427E424242420000
+1F0D:C890500018242442427E424242420000
+1F0E:6498602040182424427E424242420000
+1F0F:6498604020182424427E424242420000
+1F10:0000180810003C42403C4040423C0000
+1F11:0000181008003C42403C4040423C0000
+1F12:0000341422003C42403C4040423C0000
+1F13:0000342412003C42403C4040423C0000
+1F14:0000321424003C42403C4040423C0000
+1F15:0000322414003C42403C4040423C0000
+1F16:00007FFE7B8673BE7B8E7BBE71BE7FFE7FFE7BCE73BE7B8E7BB671CE7FFE0000
+1F17:00007FFE7B8673BE7B8E7BBE71BE7FFE7FFE7B8673F67BEE7BDE71DE7FFE0000
+1F18:C04080007E4040407C404040407E0000
+1F19:C08040007E4040407C404040407E0000
+1F1A:D05088007E4040407C404040407E0000
+1F1B:D09048007E4040407C404040407E0000
+1F1C:C85090007E4040407C404040407E0000
+1F1D:C89050007E4040407C404040407E0000
+1F1E:00007FFE7B8673BE7B8E7BBE71BE7FFE7FFE7B8673BE7B8E7BBE71867FFE0000
+1F1F:00007FFE7B8673BE7B8E7BBE71BE7FFE7FFE7B8673BE7B8E7BBE71BE7FFE0000
+1F20:0000180810005C624242424242420202
+1F21:0000181008005C624242424242420202
+1F22:0000341422005C624242424242420202
+1F23:0000342412005C624242424242420202
+1F24:0000321424005C624242424242420202
+1F25:0000322414005C624242424242420202
+1F26:324C00180810005C6242424242420202
+1F27:324C00181008005C6242424242420202
+1F28:C0408000424242427E42424242420000
+1F29:C0804000424242427E42424242420000
+1F2A:D0508800424242427E42424242420000
+1F2B:D0904800424242427E42424242420000
+1F2C:C8509000424242427E42424242420000
+1F2D:C8905000424242427E42424242420000
+1F2E:64986020404242427E42424242420000
+1F2F:64986040204242427E42424242420000
+1F30:000018081000301010101010100C0000
+1F31:000018100800301010101010100C0000
+1F32:000068284400301010101010100C0000
+1F33:000068482400301010101010100C0000
+1F34:000064284800301010101010100C0000
+1F35:000064482800301010101010100C0000
+1F36:324C00180810003010101010100C0000
+1F37:324C00181008003010101010100C0000
+1F38:C04080003E08080808080808083E0000
+1F39:C08060003E08080808080808083E0000
+1F3A:D05088003E08080808080808083E0000
+1F3B:D09048003E08080808080808083E0000
+1F3C:C85090003E08080808080808083E0000
+1F3D:C89050003E08080808080808083E0000
+1F3E:64986020403E080808080808083E0000
+1F3F:64986040203E080808080808083E0000
+1F40:0000180810003C4242424242423C0000
+1F41:0000181008003C4242424242423C0000
+1F42:0000341422003C4242424242423C0000
+1F43:0000342412003C4242424242423C0000
+1F44:0000321424003C4242424242423C0000
+1F45:0000322414003C4242424242423C0000
+1F46:00007FFE7B8673BE7B8E7BBE71BE7FFE7FFE6DCE6DBE618E7DB67DCE7FFE0000
+1F47:00007FFE7B8673BE7B8E7BBE71BE7FFE7FFE6D866DF661EE7DDE7DDE7FFE0000
+1F48:C04080003C42424242424242423C0000
+1F49:C08040003C42424242424242423C0000
+1F4A:D05088003C42424242424242423C0000
+1F4B:D09048003C42424242424242423C0000
+1F4C:C85090003C42424242424242423C0000
+1F4D:C89050003C42424242424242423C0000
+1F4E:00007FFE7B8673BE7B8E7BBE71BE7FFE7FFE6D866DBE618E7DBE7D867FFE0000
+1F4F:00007FFE7B8673BE7B8E7BBE71BE7FFE7FFE6D866DBE618E7DBE7DBE7FFE0000
+1F50:000018081000424242424242423C0000
+1F51:000018100800424242424242423C0000
+1F52:000034142200424242424242423C0000
+1F53:000034241200424242424242423C0000
+1F54:000032142400424242424242423C0000
+1F55:000032241400424242424242423C0000
+1F56:324C00180810424242424242423C0000
+1F57:324C00181008424242424242423C0000
+1F58:00007FFE7B8673BE7B8E7BBE71BE7FFE7FFE61CE6FB661CE7DB661CE7FFE0000
+1F59:C0804000414122221408080808080000
+1F5A:00007FFE7B8673BE7B8E7BBE71BE7FFE7FFE61866FB661867DB661B67FFE0000
+1F5B:D0904800414122221408080808080000
+1F5C:00007FFE7B8673BE7B8E7BBE71BE7FFE7FFE61C66FBE61BE7DBE61C67FFE0000
+1F5D:C8905000414122221408080808080000
+1F5E:00007FFE7B8673BE7B8E7BBE71BE7FFE7FFE61866FBE618E7DBE61867FFE0000
+1F5F:64986040204122221408080808080000
+1F60:00000C04080022414149494949360000
+1F61:00000C08040022414149494949360000
+1F62:00003414220022414149494949360000
+1F63:00003424120022414149494949360000
+1F64:00003214240022414149494949360000
+1F65:00003224140022414149494949360000
+1F66:324C0018081000224149494949360000
+1F67:324C0018100800224149494949360000
+1F68:C04080003E4141414141221414770000
+1F69:C08040003E4141414141221414770000
+1F6A:D05088003E4141414141221414770000
+1F6B:D09048003E4141414141221414770000
+1F6C:C85090003E4141414141221414770000
+1F6D:C89050003E4141414141221414770000
+1F6E:324C1808101C22414141221414770000
+1F6F:324C1810081C23414141221414770000
+1F70:000020201000324A444444444A320000
+1F71:000010202000324A444444444A320000
+1F72:0000101008003C42403C4040423C0000
+1F73:0000081010003C42403C4040423C0000
+1F74:0000101008005C624242424242420202
+1F75:0000081010005C624242424242420202
+1F76:000010100800301010101010100C0000
+1F77:000008101000301010101010100C0000
+1F78:0000101008003C4242424242423C0000
+1F79:0000081010003C4242424242423C0000
+1F7A:000010100800424242424242423C0000
+1F7B:000008101000424242424242423C0000
+1F7C:00001010080022414149494949360000
+1F7D:00000408080022414149494949360000
+1F7E:00007FFE7B8673BE7B8E7BBE71BE7FFE7FFE61867DBE7B8E77BE77867FFE0000
+1F7F:00007FFE7B8673BE7B8E7BBE71BE7FFE7FFE61867DBE7B8E77BE77BE7FFE0000
+1F80:000030102000324A444444444A322030
+1F81:000030201000324A444444444A322030
+1F82:000068284400324A444444444A322030
+1F83:000068482400324A444444444A322030
+1F84:000064284800324A444444444A322030
+1F85:000064482800324A444444444A322030
+1F86:324C0030102000324A4444444A322030
+1F87:324C0030201000324A4444444A322030
+1F88:C040800018242442427E42424242100C
+1F89:C080400018242442427E42424242100C
+1F8A:D050880018242442427E42424242100C
+1F8B:D090480018242442427E42424242100C
+1F8C:C850900018242442427E42424242100C
+1F8D:C890500018242442427E42424242100C
+1F8E:6498602040182424427E42424242100C
+1F8F:6498604020182424427E42424242100C
+1F90:0000180810005C624242424242422232
+1F91:0000181008005C624242424242422232
+1F92:0000341422005C624242424242422232
+1F93:0000342412005C624242424242422232
+1F94:0000321424005C624242424242422232
+1F95:0000322414005C624242424242422232
+1F96:324C00180810005C6242424242422232
+1F97:324C00181008005C6242424242422232
+1F98:C0408000424242427E42424242422018
+1F99:C0804000424242427E42424242422018
+1F9A:D0508800424242427E42424242422018
+1F9B:D0904800424242427E42424242422018
+1F9C:C8509000424242427E42424242422018
+1F9D:C8905000424242427E42424242422018
+1F9E:64986020404242427E42424242422018
+1F9F:64986040204242427E42424242422018
+1FA0:0000180810002241414949494936080C
+1FA1:0000181008002241414949494936080C
+1FA2:0000341422002241414949494936080C
+1FA3:0000342412002241414949494936080C
+1FA4:0000321424002241414949494936080C
+1FA5:0000322414002241414949494936080C
+1FA6:324C001808100022414949494936080C
+1FA7:324C001810080022414949494936080C
+1FA8:C04080003E4141414141221414770806
+1FA9:C08040003E4141414141221414770806
+1FAA:D05088003E4141414141221414770806
+1FAB:D09048003E4141414141221414770806
+1FAC:C85090003E4141414141221414770806
+1FAD:C89050003E4141414141221414770806
+1FAE:64986020401C22414141221414770806
+1FAF:64986040201C22414141221414770806
+1FB0:000044443800324A444444444A320000
+1FB1:000000007C00324A444444444A320000
+1FB2:000020201000324A444444444A322030
+1FB3:000000000000324A444444444A322030
+1FB4:000010202000324A444444444A322030
+1FB5:00007FFE7B8673BE7B8E7BBE71BE7FFE7FFE63866DBE63866DF663867FFE0000
+1FB6:000000324C00324A444444444A320000
+1FB7:000000324C00324A444444444A322030
+1FB8:42423C0018242442427E424242420000
+1FB9:003C000018242442427E424242420000
+1FBA:8080400018242442427E424242420000
+1FBB:4080800018242442427E424242420000
+1FBC:0000000018242442427E42424242100C
+1FBD:00000000180810000000000000000000
+1FBE:00000000000000000000202020180000
+1FBF:18081000000000000000000000000000
+1FC0:324C0000000000000000000000000000
+1FC1:324C0066000000000000000000000000
+1FC2:0000101008005C624242424242422232
+1FC3:0000000000005C624242424242422232
+1FC4:0000081010005C624242424242422232
+1FC5:00007FFE7B8673BE7B8E7BBE71BE7FFE7FFE71866FBE6F866FF671867FFE0000
+1FC6:000000324C005C624242424242420202
+1FC7:000000324C005C624242424242422232
+1FC8:808040007E4040407C404040407E0000
+1FC9:408080007E4040407C404040407E0000
+1FCA:80804000424242427E42424242420000
+1FCB:40808000424242427E42424242420000
+1FCC:00000000424242427E4242424242100C
+1FCD:68284400000000000000000000000000
+1FCE:64284800000000000000000000000000
+1FCF:324C0018081000000000000000000000
+1FD0:000044443800301010101010100C0000
+1FD1:000000003C00301010101010100C0000
+1FD2:101008006600301010101010100C0000
+1FD3:081010006600301010101010100C0000
+1FD4:00007FFE7B8673BE7B8E7BBE71BE7FFE7FFE63B66DB66D866DF663F67FFE0000
+1FD5:00007FFE7B8673BE7B8E7BBE71BE7FFE7FFE63866DBE6D866DF663867FFE0000
+1FD6:000000324C00301010101010100C0000
+1FD7:00324C006600301010101010100C0000
+1FD8:22221C003E08080808080808083E0000
+1FD9:003E00003E08080808080808083E0000
+1FDA:808040003E08080808080808083E0000
+1FDB:408080003E08080808080808083E0000
+1FDC:00007FFE7B8673BE7B8E7BBE71BE7FFE7FFE63C66DBE6DBE6DBE63C67FFE0000
+1FDD:68482400000000000000000000000000
+1FDE:64482800000000000000000000000000
+1FDF:324C0018100800000000000000000000
+1FE0:000042423C00424242424242423C0000
+1FE1:0000003C0000424242424242423C0000
+1FE2:101008006600424242424242423C0000
+1FE3:081010006600424242424242423C0000
+1FE4:0000180810003C4242424242625C4040
+1FE5:0000181008003C4242424242625C4040
+1FE6:000000324C00424242424242423C0000
+1FE7:00324C006600424242424242423C0000
+1FE8:22221C00414122221408080808080000
+1FE9:00003E00414122221408080808080000
+1FEA:80804000414122221408080808080000
+1FEB:40808000414122221408080808080000
+1FEC:C08040007C4242427C40404040400000
+1FED:10100800660000000000000000000000
+1FEE:08101000660000000000000000000000
+1FEF:10100800000000000000000000000000
+1FF0:00007FFE7B8673BE7B8E7BBE71BE7FFE7FFE61CE6FB663B66FB66FCE7FFE0000
+1FF1:00007FFE7B8673BE7B8E7BBE71BE7FFE7FFE61EE6FCE63EE6FEE6FC67FFE0000
+1FF2:0000101008002241414949494936080C
+1FF3:0000000000002241414949494936080C
+1FF4:0000040808002241414949494936080C
+1FF5:00007FFE7B8673BE7B8E7BBE71BE7FFE7FFE61866FBE63866FF66F867FFE0000
+1FF6:000000324C0022414149494949360000
+1FF7:000000324C002241414949494936080C
+1FF8:808040003C42424242424242423C0000
+1FF9:408080003C42424242424242423C0000
+1FFA:808040003E4141414141221414770000
+1FFB:408080003E4141414141221414770000
+1FFC:000000003E4141414141221414770806
+1FFD:08101000000000000000000000000000
+1FFE:18100800000000000000000000000000
+1FFF:00007FFE7B8673BE7B8E7BBE71BE7FFE7FFE61866FBE638E6FBE6FBE7FFE0000
+2000:00000000000000000000000000000000
+2001:00000000000000000000000000000000
+2002:00000000000000000000000000000000
+2003:00000000000000000000000000000000
+2004:00000000000000000000000000000000
+2005:00000000000000000000000000000000
+2006:00000000000000000000000000000000
+2007:00000000000000000000000000000000
+2008:00000000000000000000000000000000
+2009:00000000000000000000000000000000
+200A:00000000000000000000000000000000
+200B:AAAA00019E44024584540855906C1E4580000E3990240C3982201C2180005555
+200C:AAAA00019E44024584540855906C1E45800012099A0816499248123180005555
+200D:AAAA00019E44024584540855906C1E4580000041804002418240018180005555
+200E:AAAA000180000001C72244B7C72A4523F4A20001800000018000000180005555
+200F:AAAA000180000001F2224A37F22A5223CBA20001800000018000000180005555
+2010:0000000000000000003C000000000000
+2011:0000000000000000003C000000000000
+2012:0000000000000000007E000000000000
+2013:0000000000000000007E000000000000
+2014:000000000000000000FF000000000000
+2015:000000000000000000FF000000000000
+2016:00000014141414141414141414141400
+2017:00000000000000000000000000FF00FF
+2018:00000810101800000000000000000000
+2019:00001808081000000000000000000000
+201A:00000000000000000000000018080810
+201B:00001810100800000000000000000000
+201C:00002244446600000000000000000000
+201D:00006622224400000000000000000000
+201E:00000000000000000000000066222244
+201F:00006644442200000000000000000000
+2020:0000081C082A7F2A081C080808080000
+2021:00081C082A7F2A08082A7F2A081C0800
+2022:00000000000000387C7C7C3800000000
+2023:0000000000002030383C383020000000
+2024:00000000000000000000000018180000
+2025:00000000000000000000000036360000
+2026:00000000000000000000000049490000
+2027:00000000000000000018180000000000
+2028:AAAA00018000020182000201820003C180003BDDC21233DD8A1073D180005555
+2029:AAAA000180000381824003818200020180003BDDC21233DD8A1073D180005555
+202A:AAAA000180000001C39E4251C39E4291FA5E0001800000018000000180005555
+202B:AAAA000180000001F21E4A11F21E5211CBDE0001800000018000000180005555
+202C:AAAA000180000001F39E4A51F25E4251C3900001800000018000000180005555
+202D:AAAA000180000001C38C4253C3924293FA4C0001800000018000000180005555
+202E:AAAA000180000001F20C4A13F2125213CBCC0001800000018000000180005555
+202F:00000000000000000000000000000000
+2030:0000000042A4A44810102A55558A0000
+2031:0000000040A0A04C30C02A55552A0000
+2032:000000000C1810200000000000000000
+2033:00000000336644880000000000000000
+2034:000000003F7E54A80000000000000000
+2035:00000000301808040000000000000000
+2036:00000000CC6622110000000000000000
+2037:00000000FC7E2A150000000000000000
+2038:00000000000000000000000000102844
+2039:00000000000404080810080804040000
+203A:00000000202010100808101020200000
+203B:00000000004922144914224900000000
+203C:00000000242424242424240024240000
+203D:000000003C4A4A0A0C08080008080000
+203E:7E000000000000000000000000000000
+203F:0000000000000000000000000000423C
+2040:3C420000000000000000000000000000
+2041:00000000000000000000020408102844
+2042:000000000000081C0800227722000000
+2043:00000000000000003C3C000000000000
+2044:00000000020204080810102040400000
+2045:0000000E080808080E08080808080E00
+2046:00000070101010107010101010107000
+2047:000000EE111122CC8888880000880000
+2048:000000720A0A12624242420000420000
+2049:0000005C424244585050500000500000
+204A:0000000000007E020202020404040404
+204B:00000000FC5E5E5E5C50505050505000
+204C:000000001E3A3A3A1E00000000000000
+204D:00000000785C5C5C7800000000000000
+204E:0000000000000008492A1C2A49080000
+204F:00000000000018180000001810100800
+2050:0000003C424200000042423C00000000
+2051:0008492A1C2A49080008492A1C2A4908
+2052:00000000626204080810102046460000
+2053:000000000000000000718E0000000000
+2054:00000000000000000000000000003C42
+2055:00000000925438FE3854920000000000
+2056:00000000000006060060600006060000
+2057:0000000000000000333366664444888800000000000000000000000000000000
+2058:00000000000018180066660018180000
+2059:00000000000066660018180066660000
+205A:00000000181800000000000018180000
+205B:00000018180000006666000000181800
+205C:00000000000054107C10540000000000
+205D:00000000181800001818000018180000
+205E:00000000100000100000100000100000
+205F:00000000000000000000000000000000
+2060:AAAA00018000000180000001A2082209AA083689A27000018000000180005555
+2061:AAAA00018C001001908810899104110591047D05910411059088608980005555
+2062:AAAA000180000001800000018000042182400181824004218000000180005555
+2063:AAAA000180000001800000018000000180000001800018018800080190005555
+2064:AAAA00018000000180000101810001018FE00101810001018100000180005555
+2065:00007FFE61CE7DB661B66FB661CE7FFE7FFE73866FBE63866DF673867FFE0000
+2066:AAAA000180000001A39C2249A3882289BA5C0001800000018000000180005555
+2067:AAAA000180000001B91C2509B9082909A5DC0001800000018000000180005555
+2068:AAAA000180000001B9DC2209B9882049A39C0001800000018000000180005555
+2069:AAAA000180000001F39C4A49F2484249C39C0001800000018000000180005555
+206A:AAAA0001800007C181000101810007C180001E79A0801C7182083CF180005555
+206B:AAAA000180000381844007C18440044180001E79A0801C7182083CF180005555
+206C:AAAA0001800003E180800081808003E1800039F6C5087DE7C501450F80005555
+206D:AAAA0001800001C1822003E182200221800039F6C5087DE7C501450F80005555
+206E:AAAA000180002271B2882AF9A688228980003C79A2802271A2083CF180005555
+206F:AAAA000180002271B2882A89A688227180003C79A2802271A2083CF180005555
+2070:00000018244242422418000000000000
+2071:0000001000301010107C000000000000
+2072:00007FFE61CE7DB661B66FB661CE7FFE7FFE61867DF67B8677BE77867FFE0000
+2073:00007FFE61CE7DB661B66FB661CE7FFE7FFE618E7DF67BC677F6778E7FFE0000
+2074:0000000C1424447E0404000000000000
+2075:0000007C404078040478000000000000
+2076:00000018204078444438000000000000
+2077:0000007C040808101010000000000000
+2078:00000038444438444438000000000000
+2079:0000003844443C040830000000000000
+207A:0000000010107C101000000000000000
+207B:0000000000007C000000000000000000
+207C:00000000007C00007C00000000000000
+207D:00000408101010101008040000000000
+207E:00002010080808080810200000000000
+207F:00000000005864444444000000000000
+2080:00000000000000001824424242241800
+2081:00000000000000001030501010107C00
+2082:00000000000000003844041820407C00
+2083:00000000000000003844043804443800
+2084:00000000000000000C1424447E040400
+2085:00000000000000007C40407804047800
+2086:00000000000000001820407844443800
+2087:00000000000000007C04080810101000
+2088:00000000000000003844443844443800
+2089:00000000000000003844443C04083000
+208A:0000000000000000000010107C101000
+208B:0000000000000000000000007C000000
+208C:00000000000000000000007C00007C00
+208D:00000000000000040810101010100804
+208E:00000000000000201008080808081020
+208F:00007FFE61CE7DB661B66FB661CE7FFE7FFE73866DBE738E6DBE73BE7FFE0000
+2090:0000000000000000000038043C443C00
+2091:0000000000000000000038447C403C00
+2092:00000000000000000000384444443800
+2093:00000000000000000000442810284400
+2094:0000000000000000000078047C443800
+2095:00000000000000004040586444444400
+2096:00000000000000002020242830282400
+2097:00000000000000003010101010107C00
+2098:00000000000000000000764949494900
+2099:00000000000000000000586444444400
+209A:00000000000000000000586464584040
+209B:000000000000000000003C4038047800
+209C:000000000000000010107C1010100C00
+209D:00007FFE61CE7DB661B66FB661CE7FFE7FFE738E6DB671B67DB6738E7FFE0000
+209E:00007FFE61CE7DB661B66FB661CE7FFE7FFE73866DBE718E7DBE73867FFE0000
+209F:00007FFE61CE7DB661B66FB661CE7FFE7FFE73866DBE718E7DBE73BE7FFE0000
+20A0:000000003C40405E50503C10101E0000
+20A1:000000000A3E4A54546868725C100000
+20A2:000000001C22424056585050321C0000
+20A3:000000003F2020203E2020FC20200000
+20A4:000000000E10107E107E10103E610000
+20A5:000000000101764D4D49495969690000
+20A6:000000002222327F2A7F262622220000
+20A7:0000000068585F5C6C4A4949494E0000
+20A8:0000000070484B4C74545249494E0000
+20A9:0000002222227F2A7F36362222000000
+20AA:000000000000F28AAAAAAAAAA2BC0000
+20AB:000000020F023A4642424242463A007E
+20AC:000000000C12207C207C2020120C0000
+20AD:000000004244485060FE504844420000
+20AE:000000007F08080E380E380808080000
+20AF:0000000070484848484E4D4D4E740404
+20B0:00000000384444442818546462420408
+20B1:00007C42FF42FF427C40404040400000
+20B2:000010103C52525050565252563A1010
+20B3:00000000182424FF42FF424242420000
+20B4:000000003C420202FF30FF40423C0000
+20B5:000010103C52525050505052523C1010
+20B6:000000002828287E2828282829260000
+20B7:000000003C424220180452AAAAFCA8A8
+20B8:000000000000FE00FE10101010100000
+20B9:0000000000000FF0018000400FF0004000800F00040002000100008000400000
+20BA:0000002020283060A83062A224380000
+20BB:0000000040A0FC224254E84044380000
+20BC:00000000000000101038545454540000
+20BD:000000003C2222227C207C2020200000
+20BE:0000287CAAAAAA808080804020FE0000
+20BF:00002828FC4242427C42424242FC2828
+20C0:00007FFE61CE7DB661B66FB661CE7FFE7FFE71CE6FB66FB66FB671CE7FFE0000
+20C1:00007FFE61CE7DB661B66FB661CE7FFE7FFE71EE6FCE6FEE6FEE71C67FFE0000
+20C2:00007FFE61CE7DB661B66FB661CE7FFE7FFE71866FF66F866FBE71867FFE0000
+20C3:00007FFE61CE7DB661B66FB661CE7FFE7FFE718E6FF66FC66FF6718E7FFE0000
+20C4:00007FFE61CE7DB661B66FB661CE7FFE7FFE71B66FB66F866FF671F67FFE0000
+20C5:00007FFE61CE7DB661B66FB661CE7FFE7FFE71866FBE6F866FF671867FFE0000
+20C6:00007FFE61CE7DB661B66FB661CE7FFE7FFE71CE6FBE6F8E6FB671CE7FFE0000
+20C7:00007FFE61CE7DB661B66FB661CE7FFE7FFE71866FF66FEE6FDE71DE7FFE0000
+20C8:00007FFE61CE7DB661B66FB661CE7FFE7FFE71CE6FB66FCE6FB671CE7FFE0000
+20C9:00007FFE61CE7DB661B66FB661CE7FFE7FFE71CE6FB66FC66FF671CE7FFE0000
+20CA:00007FFE61CE7DB661B66FB661CE7FFE7FFE71866FB66F866FB671B67FFE0000
+20CB:00007FFE61CE7DB661B66FB661CE7FFE7FFE718E6FB66F8E6FB6718E7FFE0000
+20CC:00007FFE61CE7DB661B66FB661CE7FFE7FFE71C66FBE6FBE6FBE71C67FFE0000
+20CD:00007FFE61CE7DB661B66FB661CE7FFE7FFE718E6FB66FB66FB6718E7FFE0000
+20CE:00007FFE61CE7DB661B66FB661CE7FFE7FFE71866FBE6F8E6FBE71867FFE0000
+20CF:00007FFE61CE7DB661B66FB661CE7FFE7FFE71866FBE6F8E6FBE71BE7FFE0000
+20D0:0010207E000000000000000000000000
+20D1:0008047E000000000000000000000000
+20D2:00000000101010101010101010100000
+20D3:00000000001010101010101000000000
+20D4:004C5260780000000000000000000000
+20D5:00324A061E0000000000000000000000
+20D6:10207E20100000000000000000000000
+20D7:08047E04080000000000000000000000
+20D8:00000000000000182424180000000000
+20D9:00000000000000383424180000000000
+20DA:000000000000001C2C24180000000000
+20DB:00002A2A000000000000000000000000
+20DC:00005555000000000000000000000000
+20DD:000003800C60301820084004400480028002800240044004200830180C600380
+20DE:00007FFE4002400240024002400240024002400240024002400240027FFE0000
+20DF:0000010002800440082010102008400480024004200810100820044002800100
+20E0:000003800C603018300858044C0486028302818240C44064203830180C600380
+20E1:2442FF42240000000000000000000000
+20E2:0000000000003FFC4002400240024002400240024002400240023FFC7FFE0000
+20E3:00003FFC60065FFA500A500A500A500A500A500A500A500A5FFA60063FFC0000
+20E4:008001C00140036002200410041008080808180C10041004200220023FFE0000
+20E5:00002020201010101010080808080000
+20E6:00002828282828282828282828280000
+20E7:00001FFF00010001000100010001000100010001000100010001000100010000
+20E8:00000000000000000000000000000054
+20E9:00FF8100000000000000000000000000
+20EA:000000000000000000000000040008001FFC0800040000000000000000000000
+20EB:00000A0A0A1414141414282828280000
+20EC:000000000000000000000000007E0408
+20ED:000000000000000000000000007E2010
+20EE:000000000000000000000010207E2010
+20EF:000000000000000000000008047E0408
+20F0:24187E18240000000000000000000000
+20F1:00007FFE61CE7DB661B66FB661CE7FFE7FFE61EE6FCE63EE6FEE6FC67FFE0000
+20F2:00007FFE61CE7DB661B66FB661CE7FFE7FFE61866FF663866FBE6F867FFE0000
+20F3:00007FFE61CE7DB661B66FB661CE7FFE7FFE618E6FF663C66FF66F8E7FFE0000
+20F4:00007FFE61CE7DB661B66FB661CE7FFE7FFE61B66FB663866FF66FF67FFE0000
+20F5:00007FFE61CE7DB661B66FB661CE7FFE7FFE61866FBE63866FF66F867FFE0000
+20F6:00007FFE61CE7DB661B66FB661CE7FFE7FFE61CE6FBE638E6FB66FCE7FFE0000
+20F7:00007FFE61CE7DB661B66FB661CE7FFE7FFE61866FF663EE6FDE6FDE7FFE0000
+20F8:00007FFE61CE7DB661B66FB661CE7FFE7FFE61CE6FB663CE6FB66FCE7FFE0000
+20F9:00007FFE61CE7DB661B66FB661CE7FFE7FFE61CE6FB663C66FF66FCE7FFE0000
+20FA:00007FFE61CE7DB661B66FB661CE7FFE7FFE61866FB663866FB66FB67FFE0000
+20FB:00007FFE61CE7DB661B66FB661CE7FFE7FFE618E6FB6638E6FB66F8E7FFE0000
+20FC:00007FFE61CE7DB661B66FB661CE7FFE7FFE61C66FBE63BE6FBE6FC67FFE0000
+20FD:00007FFE61CE7DB661B66FB661CE7FFE7FFE618E6FB663B66FB66F8E7FFE0000
+20FE:00007FFE61CE7DB661B66FB661CE7FFE7FFE61866FBE638E6FBE6F867FFE0000
+20FF:00007FFE61CE7DB661B66FB661CE7FFE7FFE61866FBE638E6FBE6FBE7FFE0000
+2100:00000000003051523408132444030000
+2101:0000000000305152340B142241060000
+2102:000000001E31505050505050311E0000
+2103:40A0A0403C42424040404042423C0000
+2104:0000000010103C505050503C101E0000
+2105:00000000003041423408162949060000
+2106:00000000003041423408102949060000
+2107:000000003E42404038404042423C0000
+2108:000000007C4202121E120202423C0000
+2109:40A0A0407E4040407C40404040400000
+210A:0000000000003A4642423E023F423C00
+210B:00000000127596141C34549494630000
+210C:000018B66068743666666666E6063408
+210D:00000000715151515F51515151710000
+210E:00000000000000400080008000F0018801080108021002100210042000000000
+210F:000000000000005000E0038004F0018801080108021002100210042000000000
+2110:000000000C14240404060C1424283000
+2111:00000000397FC68066086CA6663C0000
+2112:0000000C12123C101010107099660000
+2113:000000182424242830602020221C0000
+2114:000000004848FE484A4D494949360000
+2115:00000000715159595555535351710000
+2116:00000000929595D2D0B7B09090900000
+2117:000000003C42B9A5A5B9A1A1423C0000
+2118:000000000000204C5222222A54505020
+2119:000000007C525252525C505050700000
+211A:000000001C32515151515151361E0100
+211B:000000402E113151515E545252210000
+211C:00000000446EB233363C3636A2C30000
+211D:000000007E515151515E585452710000
+211E:000000007C4242427C504A444A500000
+211F:000038087C4A4A4A7C6858484C4A0800
+2120:00000000719B5531D100000000000000
+2121:00000000FE525A525F00000000000000
+2122:00000000F15B55515100000000000000
+2123:0000300C85894A525424287850800000
+2124:000000007E0A0A1214242848507E0000
+2125:000000003C08103E0408180402423C00
+2126:000000003E4141414141221414770000
+2127:000000007714142241414141413E0000
+2128:000000003C464606081E020666A6663C
+2129:000000000000300808080808080C0000
+212A:00000000424448506060504844420000
+212B:1824180018242442427E424242420000
+212C:000000002E5151515E515151512E0000
+212D:000000001624686866666468221C0000
+212E:0000000000000000000007E00810181818181FF818001800081007E000000000
+212F:00000000000000182448704044380000
+2130:000000000E1220201C204044423C0000
+2131:000000003C42020404083E1020200000
+2132:0000000002020202023E0202027E0000
+2133:0000000063362A2A2A2A2A6AAA490000
+2134:0000000000001824534E424224180000
+2135:00000000000044462214286472620000
+2136:0000000000103E02020202023F7E0000
+2137:0000000000403C1E0202020E32320000
+2138:0000000000403E1F0202020203020000
+2139:0000000018180038181818187E000000
+213A:000000000000000000000000000000081FE820302050205020301FE000000000
+213B:00000000000000007C004000400040007222451448884F88489448A200000000
+213C:0000000000000000000000001FF80A500A500A500A500A480A240E1C00000000
+213D:0000000000000000000000000C040A08091004A0024002400480090012001C00
+213E:000000007F5553515050505050700000
+213F:00000000000000003FF8145014501450145014501450145014501C7000000000
+2140:00000000000000001FF81228091804880240024004800908121814281FF80000
+2141:000000005C62424272020202423C0000
+2142:000000007E0202020202020202020000
+2143:000000000202020202020202027E0000
+2144:00000000080808080814222241410000
+2145:000000000000000007E00530052809280A280A481250145014601FC000000000
+2146:0000000000000000003800280028004807D00A50129014A014A00FE000000000
+2147:00000000000000000000000003E00510091013F01400140014200FC000000000
+2148:00000000000000200040000000E00140014001400280028002800FE000000000
+2149:000000000000000800100000003800500050005000A000A000A000A008C00700
+214A:000010107C525252525C1010101E0000
+214B:000000004E3121514A0C1422221C0000
+214C:000000000000000034C04D20252005201FF825241FC405080500020000000000
+214D:0000000042A2E4A80813142241460000
+214E:000000000000000404043C04047C0000
+214F:0000000000000000000000000000000011102AA82AA82AA811106EEC00000000
+2150:0000000022622428281E122244440400
+2151:0000000022622428281E1A2E424C0000
+2152:0000000042C24448502255B595120000
+2153:0000000022622428281C1224424C0000
+2154:0000000062122448781C1224424C0000
+2155:0000000022622428281E182C424C0000
+2156:0000000062122448781E182C424C0000
+2157:0000000062122418681E182C424C0000
+2158:000000002262F428281E182C424C0000
+2159:00000000226224282816182E4A4E0000
+215A:00000000724264186816182E4A4E0000
+215B:000000002262242828141A244A4E0000
+215C:000000006212241868141A244A4E0000
+215D:000000007242641868141A244A4E0000
+215E:000000007212244848141A244A4E0000
+215F:00000000226224282810102040400000
+2160:000000001C08080808080808081C0000
+2161:000000007E24242424242424247E0000
+2162:000000007F2A2A2A2A2A2A2A2A7F0000
+2163:000000007F29292929292626267F0000
+2164:000000007F22222214141408083E0000
+2165:00000000FF4A4A4A4A4A3232327F0000
+2166:00000000FF55555555252525257F0000
+2167:00000000FFB5B5B5B555555555FF0000
+2168:000000007F2A2A2A24242A2A2A7F0000
+2169:000000007F22221408081422227F0000
+216A:000000007F2A2A2A12122A2A2A7F0000
+216B:000000007F55555525255555557F0000
+216C:000000007020202020202020227E0000
+216D:000000001A26404040404040221C0000
+216E:00000000782422222222222224780000
+216F:0000000063223636362A2A2A2A7F0000
+2170:000000000808000818080808081C0000
+2171:00000000242400246C242424247E0000
+2172:000000002A2A002A7E2A2A2A2A7F0000
+2173:000000002020003B69292926267F0000
+2174:000000000000007722222214083E0000
+2175:000000000202005A4E4A4A32327F0000
+2176:00000000050500555F555525257F0000
+2177:00000000151500B5BFB5555555FF0000
+2178:000000002020002A6A24242A2A7F0000
+2179:00000000000000772214081422770000
+217A:000000000202002A2E12122A2A7F0000
+217B:00000000050500555F252555557F0000
+217C:000000000818080808080808081C0000
+217D:000000000000001A26404040221C0000
+217E:000000000206021A26424242261B0000
+217F:000000000000742A2A2A2A2A2A7F0000
+2180:000000003E49494949494949493E0000
+2181:000000007824322A2A2A2A3224780000
+2182:000000000000000007C00920139015501550155015501390092007C000000000
+2183:000000003C42420202020242423C0000
+2184:0000000000003C4202020202423C0000
+2185:000000003A46808080808080463A0202
+2186:00000000101010101010925438100000
+2187:000000F8467149655565497146F80000
+2188:0000000000000FE0311847C44924539455545394492447C431180FE000000000
+2189:0000000022525458281C1224424C0000
+218A:000000007E02020408304042423C0000
+218B:000000003C42424040384042423C0000
+218C:00007FFE61EE7DCE61EE6FEE61C67FFE7FFE73C66DBE73BE6DBE73C67FFE0000
+218D:00007FFE61EE7DCE61EE6FEE61C67FFE7FFE738E6DB673B66DB6738E7FFE0000
+218E:00007FFE61EE7DCE61EE6FEE61C67FFE7FFE73866DBE738E6DBE73867FFE0000
+218F:00007FFE61EE7DCE61EE6FEE61C67FFE7FFE73866DBE738E6DBE73BE7FFE0000
+2190:0000000000000010207F201000000000
+2191:0000081C2A0808080808080808080808
+2192:000000000000000804FE040800000000
+2193:08080808080808080808082A1C080000
+2194:000000000000002442FF422400000000
+2195:0000081C2A0808080808082A1C080000
+2196:00000000007860504804020000000000
+2197:00000000001E060A1220400000000000
+2198:00000000004020120A061E0000000000
+2199:00000000000002044850607800000000
+219A:0000000000040414247F241404040000
+219B:000000000020202824FE242820200000
+219C:0000000000000000000000003800301C28220441038000000000000000000000
+219D:000000000000000000000000001C380C4414822001C000000000000000000000
+219E:000000000000002448FF482400000000
+219F:0000081C2A081C2A0808080808080808
+21A0:000000000000002412FF122400000000
+21A1:0808080808080808082A1C082A1C0800
+21A2:0000000000000011227C221100000000
+21A3:0000000000000088443E448800000000
+21A4:0000000000000012227E221200000000
+21A5:0000081C2A08080808080808083E0000
+21A6:0000000000000048447E444800000000
+21A7:00003E08080808080808082A1C080000
+21A8:0000081C2A08080808082A1C083E0000
+21A9:0000000000000211217E201000000000
+21AA:0000000000002044423F020400000000
+21AB:0000000000000215257E241400000000
+21AC:0000000000002054523F121400000000
+21AD:00000000000000245AE7422400000000
+21AE:000000000008082C4AFF4A2C08080000
+21AF:00004040404858684808082A1C080000
+21B0:00000000000000102078241404040404
+21B1:0000000000000008041E242820202020
+21B2:04040404040404142478201000000000
+21B3:2020202020202028241E040800000000
+21B4:000000000000000000FC04150E040000
+21B5:0404040404040414247C201000000000
+21B6:0000000000001E21A971200000000000
+21B7:0000000000007884958E040000000000
+21B8:0000007E007860504804020000000000
+21B9:00000050607E6050000A067E060A0000
+21BA:000000000000002E4C4A42423C000000
+21BB:0000000000000074325242423C000000
+21BC:0000000000000010207F000000000000
+21BD:0000000000000000007F201000000000
+21BE:0000080C0A0808080808080808080808
+21BF:00000818280808080808080808080808
+21C0:000000000000000804FE000000000000
+21C1:000000000000000000FE040800000000
+21C2:08080808080808080808080A0C080000
+21C3:08080808080808080808082818080000
+21C4:00000008047E04080010207E20100000
+21C5:00002474AC242424242424352E240000
+21C6:00000010207E20100008047E04080000
+21C7:00000010207E20100010207E20100000
+21C8:0000247EA52424242424242424240000
+21C9:00000008047E04080008047E04080000
+21CA:0000242424242424242424A57E240000
+21CB:00000000000010207E007E0408000000
+21CC:00000000000008047E007E2010000000
+21CD:00000000000808287E887E2808080000
+21CE:000000000008082C7E897E2C08080000
+21CF:00000000001010147E117E1410100000
+21D0:00000000000000103E403E1000000000
+21D1:00000814361414141414141414140000
+21D2:00000000000000087C027C0800000000
+21D3:00001414141414141414143614080000
+21D4:00000000000000247E817E2400000000
+21D5:00000814361414141414143614080000
+21D6:0000000000785068540A040000000000
+21D7:00000000001E0A162A50200000000000
+21D8:000000000020502A160A1E0000000000
+21D9:0000000000040A546850780000000000
+21DA:000000000000103E40FE403E10000000
+21DB:000000000000087C027F027C08000000
+21DC:000000000000002042F5482000000000
+21DD:000000000000000442AF120400000000
+21DE:0000081C2A0808083E083E0808080808
+21DF:08080808083E083E0808082A1C080000
+21E0:00000000000000102077201000000000
+21E1:0000081C2A0808000808080800080808
+21E2:000000000000000402EF020400000000
+21E3:08080800080808080008082A1C080000
+21E4:0000000000000050607F605000000000
+21E5:000000000000000A06FE060A00000000
+21E6:00000000000010305F815F3010000000
+21E7:000008142277141414141414141C0000
+21E8:000000000000080CFA81FA0C08000000
+21E9:00001C14141414141414772214080000
+21EA:0000081422771414141C001C141C0000
+21EB:000008142263222222222263417F0000
+21EC:000008143E63222222222263417F0000
+21ED:0000081C2A6B2A2A2A2A2A6B497F0000
+21EE:0008142A7722632222222222223E0000
+21EF:0008142A7722632222222263417F0000
+21F0:000000000000086C7A417A6C08000000
+21F1:00000000007F405C5854424140400000
+21F2:000000000001014121150D1D017F0000
+21F3:00000814361414141414143614080000
+21F4:000000000000000000000000000007080884FFFE088407080000000000000000
+21F5:0000242E35242424242424AC74240000
+21F6:0000000402FF020402FF020402FF0204
+21F7:000000000000002444FF442400000000
+21F8:000000000000002422FF222400000000
+21F9:0000000000000000000000000000092011103FF8111009200000000000000000
+21FA:0000000000000000000000000000114021407FFF214011400000000000000000
+21FB:000000000000000000000000000002880284FFFE028402880000000000000000
+21FC:0000000000000000000000000000129022887FFC228812900000000000000000
+21FD:000000000000002060BF602000000000
+21FE:000000000000000406FD060400000000
+21FF:0000000000000000000000000000081018182FF4181808100000000000000000
+2200:0000000041413E222214141408080000
+2201:00000000182424202020202424180000
+2202:000000001C2202021E22424444380000
+2203:000000007E0202027E020202027E0000
+2204:000004047E0A0A127E122222227E4040
+2205:000000000000001D22454951225C0000
+2206:000000000808141414222222417F0000
+2207:000000007F4122222214141408080000
+2208:000000000000003E40407E40403E0000
+2209:000000000004043E48487E50503E2020
+220A:0000000000000000003E407E403E0000
+220B:000000000000007C02027E02027C0000
+220C:000000000004047C0A0A7E12127C2020
+220D:0000000000000000007C027E027C0000
+220E:000000007E7E7E7E7E7E7E7E7E7E0000
+220F:000000007F2222222222222222227700
+2210:00000000772222222222222222227F00
+2211:000000007E4220100804081020427E00
+2212:0000000000000000007E000000000000
+2213:000000007F000808087F080808000000
+2214:0000081C08000808087F080808000000
+2215:00000000020404080810102020400000
+2216:00000000402020101008080404020000
+2217:000000000000082A1C081C2A08000000
+2218:00000000000000001824241800000000
+2219:0000000000000000183C3C1800000000
+221A:00000704040404047414140C0C040400
+221B:00006714641464047414140C0C040400
+221C:00005754741414047414140C0C040400
+221D:00000000000000364848360000000000
+221E:00000000000000364949360000000000
+221F:000000000000004040404040407E0000
+2220:000000000000000002040810207E0000
+2221:000000000000000002140814247E0400
+2222:000000000000000A0C1464140C0A0000
+2223:00000000181818181818181818180000
+2224:0000000018181A1C1818385818180000
+2225:00000000242424242424242424240000
+2226:00000000242426242C34246424240000
+2227:00000000000008081414222241410000
+2228:00000000000041412222141408080000
+2229:0000000000003C424242424242420000
+222A:000000000000424242424242423C0000
+222B:00060A08080808080808080808283000
+222C:000A1514141414141414141414546800
+222D:00152A2A2A2A2A2A2A2A2A2A2AAAD400
+222E:00060A0808081C2A2A1C080808283000
+222F:000A151414143E55553E141414546800
+2230:00152A2A2A7EABABAB7E2A2A2AAAD400
+2231:00060A0808081D2B2F08080808283000
+2232:00060A0808081D2B2F2A1C0808283000
+2233:00060A0808085C6A7A2A1C0808283000
+2234:00000000000018180000006666000000
+2235:00000000000066660000001818000000
+2236:00000000000018180000001818000000
+2237:00000000000066660000006666000000
+2238:0000000000001818007E000000000000
+2239:00000000000006060078000606000000
+223A:0000000000006666007E006666000000
+223B:0000000000181800324C001818000000
+223C:0000000000000000324C000000000000
+223D:00000000000000004C32000000000000
+223E:00000000000000003249260000000000
+223F:00000000000000304849090600000000
+2240:00000000001008080810101008000000
+2241:0000000000000404083A541020200000
+2242:00000000000000007E0000324C000000
+2243:00000000000000324C00007E00000000
+2244:000000040408083A5410107E20204040
+2245:00000000324C00007E00007E00000000
+2246:00000000324C02047E08107E20400000
+2247:000004043A4C08107E10207E20404000
+2248:00000000000000324C00324C00000000
+2249:000000000004043A4C103A5420200000
+224A:0000000000324C00324C007E00000000
+224B:0000000000324C00324C00324C000000
+224C:000000004C3200007E00007E00000000
+224D:000000000000423C00003C4200000000
+224E:00000000000018660000661800000000
+224F:00000000000000186600007E00000000
+2250:00000000181800007E00007E00000000
+2251:0000001818007E00007E001818000000
+2252:0000006060007E00007E000606000000
+2253:0000000606007E00007E006060000000
+2254:000000000000005E00005E0000000000
+2255:000000000000007A00007A0000000000
+2256:000000000000007E24247E0000000000
+2257:00000018242418007E00007E00000000
+2258:000000003C4200007E00007E00000000
+2259:00000018244200007E00007E00000000
+225A:00000042241800007E00007E00000000
+225B:0000083E1C1400007E00007E00000000
+225C:00000814223E00007E00007E00000000
+225D:0000121476547400007E00007E000000
+225E:00000068545454007E00007E00000000
+225F:0030480810100010007E00007E000000
+2260:00000000000002047E08107E20400000
+2261:000000000000007E007E007E00000000
+2262:000000000002047E087E107E20400000
+2263:0000000000007E007E007E007E000000
+2264:0000000000000618601806007E000000
+2265:0000000000006018061860007E000000
+2266:0000000618601806007E00007E000000
+2267:0000006018061860007E00007E000000
+2268:0000000618601806047E08107E204000
+2269:0000006018061862047E08107E204000
+226A:00000000000912244890482412090000
+226B:00000000009048241209122448900000
+226C:00000000241818242424241818240000
+226D:000000020204857E08107EA120404000
+226E:00000008080C18103050303018242000
+226F:00000000084828101814181020602020
+2270:0000000002020E1468181E107E202000
+2271:0000000008087018162870207E404000
+2272:000000000000061860180600324C0000
+2273:000000000000601806186000324C0000
+2274:0000000004040E1868181E103A642020
+2275:000000000808781816187010326C2020
+2276:00000000061860180660180618600000
+2277:00000000601806186006186018060000
+2278:000002020E1468181E70282E50608080
+2279:00000404681816187016386038264040
+227A:00000000000202041860180402020000
+227B:00000000004040201806182040400000
+227C:0000000000020204186018641A040200
+227D:00000000004040201806182658204000
+227E:000000000002020418601804669A0000
+227F:00000000004040201806182059660000
+2280:0000000004060A0C0870181422220000
+2281:0000000004444828180E183050602000
+2282:0000000000003E404040403E00000000
+2283:0000000000007C020202027C00000000
+2284:0000000004043E485050603E40400000
+2285:0000000002027C0A0A12127C20200000
+2286:0000000000003E404040403E007E0000
+2287:0000000000007C020202027C007E0000
+2288:0000000004043E484850503E207E4000
+2289:0000000002027C0A0A12127C207E4000
+228A:0000000000003E404040403E047E1000
+228B:0000000000007C020202027C087E2000
+228C:000000004242424A527E524A423C0000
+228D:0000000042424242425A5A42423C0000
+228E:0000000042424252527A5252423C0000
+228F:0000000000007E404040407E00000000
+2290:0000000000007E020202027E00000000
+2291:0000000000007E404040407E007E0000
+2292:0000000000007E020202027E007E0000
+2293:0000000000007E424242424200000000
+2294:00000000000042424242427E00000000
+2295:0000000000001C2A497F492A1C000000
+2296:0000000000001C22417F41221C000000
+2297:0000000000001C22554955221C000000
+2298:0000000000001C22454951221C000000
+2299:0000000000001C22414941221C000000
+229A:0000000000001C22495549221C000000
+229B:0000000000001C22495D49221C000000
+229C:0000000000001C225D415D221C000000
+229D:0000000000001C22415D41221C000000
+229E:0000000000007F49497F49497F000000
+229F:0000000000007F41417F41417F000000
+22A0:0000000000007F63554955637F000000
+22A1:0000000000007F41414941417F000000
+22A2:0000000000004040407E404040000000
+22A3:0000000000000202027E020202000000
+22A4:0000000000007F080808080808000000
+22A5:0000000000000808080808087F000000
+22A6:0000000000202020203C202020200000
+22A7:00000000002020203C203C2020200000
+22A8:00000000004040407E407E4040400000
+22A9:0000000000505050505E505050500000
+22AA:00000000005454545457545454540000
+22AB:00000000005050505E505E5050500000
+22AC:0000000000404048487E484840400000
+22AD:00000000004048487E487E4848400000
+22AE:0000000000505054545E545450500000
+22AF:00000000005054545E545E5454500000
+22B0:00000000000C020418601804020C0000
+22B1:00000000003040201806182040300000
+22B2:00000000000000061A621A0600000000
+22B3:00000000000000605846586000000000
+22B4:00000000000000061A621A06007E0000
+22B5:000000000000006058465860007E0000
+22B6:0000000000000000000000000000300C481E4FFE481E300C0000000000000000
+22B7:0000000000000000000000000000300C78127FF27812300C0000000000000000
+22B8:0000000000000000000000000000003800443FC4004400380000000000000000
+22B9:00000000000008080063000808000000
+22BA:000000003E0808080808080808080000
+22BB:000000000000002222141408003E0000
+22BC:0000000000003E000814142222000000
+22BD:0000000000003E002222141408000000
+22BE:000000000000004040407848487E0000
+22BF:000000000000000002060A12227E0000
+22C0:00000000081414142222224141410000
+22C1:00000000414141222222141414080000
+22C2:000000003C4242424242424242420000
+22C3:000000004242424242424242423C0000
+22C4:00000000000000081422140800000000
+22C5:00000000000000001818000000000000
+22C6:00000000000000083E1C140000000000
+22C7:0000000000001842247E244218000000
+22C8:00000000000041635549556341000000
+22C9:00000000000041625448546241000000
+22CA:00000000000041231509152341000000
+22CB:00000000000000201008142200000000
+22CC:00000000000000020408142200000000
+22CD:00000000000000004C3200007E000000
+22CE:00000000000041222214141408000000
+22CF:00000000000008141414222241000000
+22D0:0000000000003E404E50504E403E0000
+22D1:0000000000007C02720A0A72027C0000
+22D2:0000000000003E414955555555550000
+22D3:000000000000555555555549413E0000
+22D4:000000000808081C2A2A2A2A2A2A0000
+22D5:00000000242424247E24247E24240000
+22D6:00000000000204081022100804020000
+22D7:00000000004020100844081020400000
+22D8:0000000000000000000002220444088811102220111008880444022200000000
+22D9:0000000000000000000044402220111008880444088811102220444000000000
+22DA:00000618601806007E00601806186000
+22DB:00006018061860007E00061860180600
+22DC:0000000000007E000618601806000000
+22DD:0000000000007E006018061860000000
+22DE:0000000002041A641860180402020000
+22DF:00000000402058261806182040400000
+22E0:0000000414162ACC1868181412222020
+22E1:000000020A4A442B1816183060602020
+22E2:0000000202047E484850507E207E4000
+22E3:0000000202047E0A0A12127E207E4000
+22E4:0000000000007E404040407E087E2000
+22E5:0000000000007E020202027E087E2000
+22E6:00000000000618601806043A5C204000
+22E7:00000000006018061862043A5C204000
+22E8:00000002020418601804063A5C204000
+22E9:00004040201806182042443A5C204000
+22EA:000000000002020E166A1A1E10202000
+22EB:00000000000404685C56687020404000
+22EC:000000000002020E166A1A1E107E2000
+22ED:00000000000404685C566870207E4000
+22EE:00000000181800001818000018180000
+22EF:0000000000000000DBDB000000000000
+22F0:000000000303000018180000C0C00000
+22F1:00000000C0C000001818000003030000
+22F2:0000000000000000000007F00800100010007FF010001000080007F000000000
+22F3:0000000000000000000007F00800100010101FF010101000080007F000000000
+22F4:0000000000003E40427E42403E000000
+22F5:0000000001800180000007F00800100010001FF010001000080007F000000000
+22F6:0000000000001FF0000007F00800100010001FF010001000080007F000000000
+22F7:000000007E003E40407E40403E000000
+22F8:0000000000003E40407E40403E007E00
+22F9:000000000000000000001FC0200040007FC040007FC0400020001FC000000000
+22FA:000000000000000000003F800040002000203FF80020002000403F8000000000
+22FB:000000000000000000003F800040002020203FE02020002000403F8000000000
+22FC:0000000000007C02427E42027C000000
+22FD:0000000000003FE000003F800040002000203FE00020002000403F8000000000
+22FE:000000007E007C02027E02027C000000
+22FF:000000000000000000001FF81000100010001FF81000100010001FF800000000
+2300:0000000000000000000807D0082010501090111012101410082017C020000000
+2301:00000000000000009058341200000000
+2302:000000000000182442424242427E0000
+2303:00000000081422000000000000000000
+2304:00000000000000000000002214080000
+2305:000000003E0008142200000000000000
+2306:000000003E003E000814220000000000
+2307:00000010080408100804081008040000
+2308:00001E10101010101010101010100000
+2309:00007808080808080808080808080000
+230A:000010101010101010101010101E0000
+230B:00000808080808080808080808780000
+230C:00000000000000000007080808000000
+230D:00000000000000000070080808000000
+230E:00000000000008080807000000000000
+230F:00000000000008080870000000000000
+2310:000000000000000000007E4040400000
+2311:000000000000413E2222223E41000000
+2312:000000000000000000001C2241410000
+2313:000000000000000000001C22417F0000
+2314:00000000000000001C22412214080000
+2315:000000000000001C22414141225C8000
+2316:00000080008003E004900888108410047E3F100410840888049003E000800080
+2317:00000000002424FF2424FF2424000000
+2318:00000000000022553E143E5522000000
+2319:0000000000004040407E000000000000
+231A:0000282828283854929B824438282828
+231B:000000007E242424181824243C7E0000
+231C:00784040400000000000000000000000
+231D:001E0202020000000000000000000000
+231E:00000000000000000000004040407800
+231F:00000000000000000000000202021E00
+2320:00000000060A08080808080808080808
+2321:08080808080808080808283000000000
+2322:0000000000000000003C420000000000
+2323:0000000000000000423C000000000000
+2324:00000000000000007708142200000000
+2325:00000000000000006710080700000000
+2326:00000000000000FCAA91AAFC00000000
+2327:000000000000007F5549557F00000000
+2328:000000000000007E7E7E003C00000000
+2329:0000000800080010001000200020004000800040002000200010001000080008
+232A:0000200020001000100008000800040002000400080008001000100020002000
+232B:000000000000003F5589553F00000000
+232C:00000000008001400220049008480A280A080A28084804900220014000800000
+232D:00000000000000000081010201C40224041804100C10122011C0204040800000
+232E:000000000000000003C004200810100810FE110812080A1004202BC030003800
+232F:0000000000000000000000000FF0000000007FFE000000000FF0000000000000
+2330:000004020C061E0F080410081008201020104020402080408040FFC000000000
+2331:0000000000001F00248044408420842487FF84248420444024801F0000000000
+2332:000000000000000000003C0023802070200C7FFE200C207023803C0000000000
+2333:0000000000000000000000000000000060005C0043804070400C7FFE00000000
+2334:00000000000000000000000040024002400240024002400240027FFE00000000
+2335:0000000000000000000000004001200210040808041002200140008000000000
+2336:000000007F08080808080808087F0000
+2337:000000003E22222222222222223E0000
+2338:0000007F4141417F41417F41417F0000
+2339:0000007F414949417F414949417F0000
+233A:0000007F4149556341635549417F0000
+233B:0000007F4141414955554941417F0000
+233C:0000007F41415D634141635D417F0000
+233D:00000008081C2A4949492A1C08080000
+233E:00000000001C22495549221C00000000
+233F:000000000204040808FF102020400000
+2340:000000004020201010FF080404020000
+2341:0000007F4143454549515161417F0000
+2342:0000007F4161515149454543417F0000
+2343:0000007F4141475961594741417F0000
+2344:0000007F4141714D434D7141417F0000
+2345:00000008080808287F28080808080000
+2346:000000080808080A7F0A080808080000
+2347:0000007F414149517F514941417F0000
+2348:0000007F414149457F454941417F0000
+2349:000000000000005C22514945221D0000
+234A:00000000080808080808087F007F0000
+234B:000000000808081C1C2A2A3E08080000
+234C:00007F414141416363555549417F0000
+234D:00007F41414949555563637F417F0000
+234E:000000000808081C2A2A1C08087F0000
+234F:00000000081C2A087F08080808080000
+2350:00007F495D6B494949494949497F0000
+2351:000000003E003E080808080808080000
+2352:0000000008083E2A2A1C1C0808080000
+2353:00007F414955556363414141417F0000
+2354:00007F41417F636355554949417F0000
+2355:000000007F08081C2A2A1C0808080000
+2356:0000000808080808087F082A1C080000
+2357:00007F494949494949496B5D497F0000
+2358:000000000808080000000000003E0000
+2359:00000000000808141422223E003E0000
+235A:000000000008142241221408003E0000
+235B:000000000000001824241800003E0000
+235C:00000000001C22414141221C007F0000
+235D:000000001C2249554941414141410000
+235E:00007F414949494141414141417F0000
+235F:000000001C22497F5D55221C00000000
+2360:00007F414149494141494941417F0000
+2361:002424007F0808080808080808080000
+2362:00242400003E22221414080800000000
+2363:0024240000083E1C1400000000000000
+2364:00242400000000182424180000000000
+2365:002424000000001C22414141221C0000
+2366:00000000494949494949492A1C080000
+2367:00000008081F28484848281F08080000
+2368:00242400000000324C00000000000000
+2369:00242400402010080402040810204000
+236A:000000003C0000180808100000000000
+236B:00000000003E22221414394E00000000
+236C:000000001C222222336E2222221C0000
+236D:0000000008080808083A4C0808080000
+236E:000000001818000018080810003E0000
+236F:00007F4143457F497F516141417F0000
+2370:00007F414955554549494149417F0000
+2371:00000000324C00222214140800000000
+2372:0000000000324C000814142222000000
+2373:00000000000000180808080808060000
+2374:0000000000003C4242424242625C4040
+2375:00000000000014224949494949360000
+2376:0000000000324A4444444A32007E0000
+2377:00000000003E40407C40403E007E0000
+2378:000000000018080808080806001E0000
+2379:000000000022414949494936007F0000
+237A:000000000000324A444444444A320000
+237B:000000000000000200040008001001FC00400080410022001400080000000000
+237C:000000000A000C00080018002800180008000C000A000C004FFE500060007800
+237D:0000000000000000000000000000000000000000783C082008200FE000000000
+237E:000000000000000003C004200810100810081FF80420042004201C3800000000
+237F:000008080808081C3E1C080808080000
+2380:00000038043C44443A00824428100000
+2381:000000000000000000000000380004003C00440044003A5400007FFC00000000
+2382:000000000000000000000000387004083C78448844883A7400007EFC00000000
+2383:0000000000000000400420081390004073DC0440145023A84004000000000000
+2384:0000000000000000000000003FF02108220422042204220421083FF000000000
+2385:0000000000000000010001001D701110111011101110111011101D7001000100
+2386:00000100028004400820121003087E8440427E84030812100820044002800100
+2387:00000000000000000000000000000020003000E801300220040078FE00000000
+2388:00000100010023881D701930155023882388155019301D702388010001000000
+2389:000000000F8030604010401080088008F078888888884510451032600F800000
+238A:000000000F80306040107FF0A02890489048888888884510451032600F800000
+238B:0000000001807C6048105010680844080208810880884050401030600F800000
+238C:000000000000000007E0081010087C0828081008381C44224422381C00000000
+238D:000000000000000007E0042004200420042004200420042004203C3C00000000
+238E:000000000000000001FC021004200420042004200420042008403F8000000000
+238F:000000000000000000001FF00280044008201010082004400280010000000000
+2390:00000000000000000000010002800440082010100820044002801FF000000000
+2391:000000000000000000001FF00280044008201FF0082004400280010000000000
+2392:0000000000000000000001000280044008201FF00820044002801FF000000000
+2393:000000000000000000000000000000007FFC0000739C00000000000000000000
+2394:0000000000000000000007E0081010082004400220041008081007E000000000
+2395:00007F414141414141414141417F0000
+2396:0000000000007C7C7878707060604000
+2397:00006DB040104FFC48044A044E044BE450244BE44E047A0408040FFC00000000
+2398:00007FF040104EDC4804490449845F4050245F444980790408040CDC00000000
+2399:000001E0032005200F20082038384824882288228FE2800240043FF800000000
+239A:000000000000000000001FF020284244449449245244448428081FF000000000
+239B:000E1830303030303030303030303030
+239C:30303030303030303030303030303030
+239D:3030303030303030303030303030180E
+239E:0070180C0C0C0C0C0C0C0C0C0C0C0C0C
+239F:0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C
+23A0:0C0C0C0C0C0C0C0C0C0C0C0C0C0C1870
+23A1:003E3030303030303030303030303030
+23A2:30303030303030303030303030303030
+23A3:3030303030303030303030303030303E
+23A4:007C0C0C0C0C0C0C0C0C0C0C0C0C0C0C
+23A5:0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C
+23A6:0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C7C
+23A7:00060C18181818181818181818181818
+23A8:18181818181810204020101818181818
+23A9:18181818181818181818181818180C06
+23AA:18181818181818181818181818181818
+23AB:00603018181818181818181818181818
+23AC:18181818181808040204081818181818
+23AD:18181818181818181818181818183060
+23AE:08080808080808080808080808080808
+23AF:000000000000000000FF000000000000
+23B0:060C1818181818181818181818183060
+23B1:60301818181818181818181818180C06
+23B2:00000000000000007FFE300E3006180218000C000C0006000600030003000180
+23B3:018003000300060006000C000C00180018023006300E7FFE0000000000000000
+23B4:00000000000000007FFE40024002000000000000000000000000000000000000
+23B5:0000000000000000000000000000000000000000000000000000400240027FFE
+23B6:000000000000000000000000400240027FFE00007FFE40024002000000000000
+23B7:08080808080808086828281818080800
+23B8:80808080808080808080808080808080
+23B9:01010101010101010101010101010101
+23BA:FF000000000000000000000000000000
+23BB:00000000FF0000000000000000000000
+23BC:0000000000000000000000FF00000000
+23BD:000000000000000000000000000000FF
+23BE:003F2020202020202020202020202000
+23BF:00202020202020202020202020203F00
+23C0:00000100010003800D601110111021082108111011100D600380010001000000
+23C1:0000FFFF010003800D601110111021082108111011100D600380010001000000
+23C2:00000100010003800D601110111021082108111011100D6003800100FFFF0000
+23C3:0000010001000380038005400540092009201110111021083FF8010001000000
+23C4:0000FFFF01000380038005400540092009201110111021083FF8010001000000
+23C5:0000010001000380038005400540092009201110111021083FF80100FFFF0000
+23C6:0000010001000100010001001D00230001880170010001000100010001000000
+23C7:0000FFFF01000100010001001D00230001880170010001000100010001000000
+23C8:0000010001000100010001001D002300018801700100010001000100FFFF0000
+23C9:0000FFFF01000100010001000100010001000100010001000100010001000000
+23CA:00000100010001000100010001000100010001000100010001000100FFFF0000
+23CB:00FC0404040404040404040404040400
+23CC:0004040404040404040404040404FC00
+23CD:00000080793C42044404400440044004400440044004400440047FFC00000000
+23CE:00000000003E00220022002204220C42178220024004200817F00C0004000000
+23CF:00000000000010387CFE00FEFEFE0000
+23D0:08080808080808080808080808080808
+23D1:00000000000000008244380000000000
+23D2:000000000000FE008244380000000000
+23D3:000000000000000082443800FE000000
+23D4:000000000000000000000000FFFE000082824444383800000000000000000000
+23D5:000000000000000000000000000000008282444438380000FFFE000000000000
+23D6:00000000000000000000000000000000418222441C3800000000000000000000
+23D7:0000000000000000000200020002000200027FFE000000000000000000000000
+23D8:0000000000000000400240024002400240027FFE000000000000000000000000
+23D9:0000000000000000410241024102410241027FFE000000000000000000000000
+23DA:08080808080808080808087F001C0008
+23DB:0000000000000000000000001FF810081008FFFF100810081FF8000000000000
+23DC:000000000000000000000000000000000000000007E0381C4002800100000000
+23DD:0000000080014002381C07E00000000000000000000000000000000000000000
+23DE:000000000000000000000000000000000000010002803C784004800200000000
+23DF:00000000800240043C7802800100000000000000000000000000000000000000
+23E0:00000000000000000000000000000000000000000FF010082004400200000000
+23E1:000000004002200410080FF00000000000000000000000000000000000000000
+23E2:000000000000000000007FC040204020401040104008400840047FFC00000000
+23E3:00000000008001400220041009C80A280A280A2809C804100220014000800000
+23E4:0000000000000000000000000000000000007FFE000000000000000000000000
+23E5:000000000000000000000000000000000FFC10081008201020107FE000000000
+23E6:0000000000000000000000001800240042007FFC008400480030000000000000
+23E7:000000002400240022002206A91871A021C003E001C002A00410080810040000
+23E8:0000000000000000246A2A2A2A240000
+23E9:00000000000000000000208030C038E03CF03EF83CF038E030C0208000000000
+23EA:00000000000000000000020806180E381E783EF81E780E380618020800000000
+23EB:00000000000000000100038007C00FE01FF000000100038007C00FE01FF00000
+23EC:00000000000000001FF00FE007C00380010000001FF00FE007C0038001000000
+23ED:000000000000000000004104618471C479E47DF479E471C46184410400000000
+23EE:000000000000000000004104430C471C4F3C5F7C4F3C471C430C410400000000
+23EF:00000000000000000000104818481C481E481F481E481C481848104800000000
+23F0:00000100193037D82828111021082108210822082408101008200FE01C700000
+23F1:00000300030007D808381110210821082108200820081010082007C000000000
+23F2:00000000000007C008201010240822082108200820081010082007C000000000
+23F3:000000007FFC1010101012900D6006C0028006C0082011101AB015507FFC0000
+23F4:0000000000000000004000C001C003C007C00FC007C003C001C000C000400000
+23F5:000000000000000008000C000E000F000F800FC00F800F000E000C0008000000
+23F6:0000000000000000000000000100038007C00FE01FF03FF80000000000000000
+23F7:0000000000000000000000003FF81FF00FE007C0038001000000000000000000
+23F8:0000000000000660066006600660066006600660066006600660066000000000
+23F9:00000000000000001FF81FF81FF81FF81FF81FF81FF81FF81FF81FF800000000
+23FA:000000000000000007E00FF01FF81FF81FF81FF81FF81FF80FF007E000000000
+23FB:01800180018001801998399C318C718E61866186700E300C381C1FF80FF003C0
+23FC:000007E01FF83C3C781E718E61866186618661866186718E381C1FF80FF003C0
+23FD:018003C003C003C003C003C003C003C003C003C003C003C003C003C003C00180
+23FE:0400080018003800380078007800780078007C003C003E001F000F8007E001F0
+23FF:000000000000001C007801940624182260221822062401940078001C00000000
+2400:000000000000000000004A506A505A50499E0000000000000000000000000000
+2401:0000000000000000000039924252325E0A527192000000000000000000000000
+2402:000000000000000000003BA44124311809247124000000000000000000000000
+2403:000000000000000000007BA44124791841247924000000000000000000000000
+2404:0000000000000000000079BE42487A4842487988000000000000000000000000
+2405:000000000000000000007A4C42527B5242D67A4E000000000000000000000000
+2406:0000000000000000000031A44A287A304A2849A4000000000000000000000000
+2407:0000000000000000000073D04A1073D04A1073DE000000000000000000000000
+2408:000000000000000000001E3811401E3011081E70000000000000000000000000
+2409:0000000000000000000022F822203E2022202220000000000000000000000000
+240A:0000000000000000000020F8208020F820803E80000000000000000000000000
+240B:0000000000000000000022F82220222014200820000000000000000000000000
+240C:000000000000000000003EF820803EF820802080000000000000000000000000
+240D:000000000000000000001EF0208820F020901E88000000000000000000000000
+240E:000000000000000000001E7020881C8802883C70000000000000000000000000
+240F:000000000000000000001EF820201C2002203CF8000000000000000000000000
+2410:00000000000000000000391C2510251C251039DC000000000000000000000000
+2411:0000000000000000000071884A184A084A08719C000000000000000000000000
+2412:0000000000000000000071984A044A084A10719C000000000000000000000000
+2413:0000000000000000000071984A044A184A047198000000000000000000000000
+2414:0000000000000000000071844A0C4A144A1C7184000000000000000000000000
+2415:0000000000000000000049926A546A585BD44A52000000000000000000000000
+2416:000000000000000000003452429A311609127112000000000000000000000000
+2417:000000000000000000007BB84124793841247938000000000000000000000000
+2418:00000000000000000000332444B447AC44A434A4000000000000000000000000
+2419:000000000000000000003E8820D83EA820883E88000000000000000000000000
+241A:000000000000000000003A5C4252325C0A52719C000000000000000000000000
+241B:0000000000000000000079CE4210799040507B8E000000000000000000000000
+241C:000000000000000000001E7010801E60101010E0000000000000000000000000
+241D:000000000000000000000E701080166012100EE0000000000000000000000000
+241E:000000000000000000001C7012801C60141012E0000000000000000000000000
+241F:0000000000000000000012701280126012100CE0000000000000000000000000
+2420:000000000000000000003B80424033800A007200000000000000000000000000
+2421:0000000000000000000073D04A104BD04A1073DE000000000000000000000000
+2422:00000000141810305C121212121C0000
+2423:000000000000000000000000427E0000
+2424:0000000048685848001010101E000000
+2425:0000000000010A152A54284000000000
+2426:000000003C4242402010100010100000
+2427:00007FFE61B67DB661866FF661F67FFE7FFE61867DF661EE6FDE61DE7FFE0000
+2428:00007FFE61B67DB661866FF661F67FFE7FFE61CE7DB661CE6FB661CE7FFE0000
+2429:00007FFE61B67DB661866FF661F67FFE7FFE61CE7DB661C66FF661CE7FFE0000
+242A:00007FFE61B67DB661866FF661F67FFE7FFE61867DB661866FB661B67FFE0000
+242B:00007FFE61B67DB661866FF661F67FFE7FFE618E7DB6618E6FB6618E7FFE0000
+242C:00007FFE61B67DB661866FF661F67FFE7FFE61C67DBE61BE6FBE61C67FFE0000
+242D:00007FFE61B67DB661866FF661F67FFE7FFE618E7DB661B66FB6618E7FFE0000
+242E:00007FFE61B67DB661866FF661F67FFE7FFE61867DBE618E6FBE61867FFE0000
+242F:00007FFE61B67DB661866FF661F67FFE7FFE61867DBE618E6FBE61BE7FFE0000
+2430:00007FFE61B67DB661866FF661F67FFE7FFE63CE7DB671B67DB663CE7FFE0000
+2431:00007FFE61B67DB661866FF661F67FFE7FFE63EE7DCE71EE7DEE63C67FFE0000
+2432:00007FFE61B67DB661866FF661F67FFE7FFE63867DF671867DBE63867FFE0000
+2433:00007FFE61B67DB661866FF661F67FFE7FFE638E7DF671C67DF6638E7FFE0000
+2434:00007FFE61B67DB661866FF661F67FFE7FFE63B67DB671867DF663F67FFE0000
+2435:00007FFE61B67DB661866FF661F67FFE7FFE63867DBE71867DF663867FFE0000
+2436:00007FFE61B67DB661866FF661F67FFE7FFE63CE7DBE718E7DB663CE7FFE0000
+2437:00007FFE61B67DB661866FF661F67FFE7FFE63867DF671EE7DDE63DE7FFE0000
+2438:00007FFE61B67DB661866FF661F67FFE7FFE63CE7DB671CE7DB663CE7FFE0000
+2439:00007FFE61B67DB661866FF661F67FFE7FFE63CE7DB671C67DF663CE7FFE0000
+243A:00007FFE61B67DB661866FF661F67FFE7FFE63867DB671867DB663B67FFE0000
+243B:00007FFE61B67DB661866FF661F67FFE7FFE638E7DB6718E7DB6638E7FFE0000
+243C:00007FFE61B67DB661866FF661F67FFE7FFE63C67DBE71BE7DBE63C67FFE0000
+243D:00007FFE61B67DB661866FF661F67FFE7FFE638E7DB671B67DB6638E7FFE0000
+243E:00007FFE61B67DB661866FF661F67FFE7FFE63867DBE718E7DBE63867FFE0000
+243F:00007FFE61B67DB661866FF661F67FFE7FFE63867DBE718E7DBE63BE7FFE0000
+2440:000000000E0A0A0A0808282828380000
+2441:0000000002020202023E222222220000
+2442:0000000022222222223E080808080000
+2443:0000000008080808083E222222220000
+2444:000000003E2A2A2A08082A2A2A3E0000
+2445:0000000022362A362200000000000000
+2446:00000000000E6E6E60606E6E0E000000
+2447:000000000303031B1818D8C0C0C00000
+2448:00000000075757505050505050500000
+2449:00000000006D6D6D6D6D6D6D6D6D0000
+244A:00000000A0A050282814140A05050000
+244B:00007FFE61B67DB661866FF661F67FFE7FFE6D8E6DB6618E7DB67D8E7FFE0000
+244C:00007FFE61B67DB661866FF661F67FFE7FFE6DC66DBE61BE7DBE7DC67FFE0000
+244D:00007FFE61B67DB661866FF661F67FFE7FFE6D8E6DB661B67DB67D8E7FFE0000
+244E:00007FFE61B67DB661866FF661F67FFE7FFE6D866DBE618E7DBE7D867FFE0000
+244F:00007FFE61B67DB661866FF661F67FFE7FFE6D866DBE618E7DBE7DBE7FFE0000
+2450:00007FFE61B67DB661866FF661F67FFE7FFE61CE6FB661B67DB661CE7FFE0000
+2451:00007FFE61B67DB661866FF661F67FFE7FFE61EE6FCE61EE7DEE61C67FFE0000
+2452:00007FFE61B67DB661866FF661F67FFE7FFE61866FF661867DBE61867FFE0000
+2453:00007FFE61B67DB661866FF661F67FFE7FFE618E6FF661C67DF6618E7FFE0000
+2454:00007FFE61B67DB661866FF661F67FFE7FFE61B66FB661867DF661F67FFE0000
+2455:00007FFE61B67DB661866FF661F67FFE7FFE61866FBE61867DF661867FFE0000
+2456:00007FFE61B67DB661866FF661F67FFE7FFE61CE6FBE618E7DB661CE7FFE0000
+2457:00007FFE61B67DB661866FF661F67FFE7FFE61866FF661EE7DDE61DE7FFE0000
+2458:00007FFE61B67DB661866FF661F67FFE7FFE61CE6FB661CE7DB661CE7FFE0000
+2459:00007FFE61B67DB661866FF661F67FFE7FFE61CE6FB661C67DF661CE7FFE0000
+245A:00007FFE61B67DB661866FF661F67FFE7FFE61866FB661867DB661B67FFE0000
+245B:00007FFE61B67DB661866FF661F67FFE7FFE618E6FB6618E7DB6618E7FFE0000
+245C:00007FFE61B67DB661866FF661F67FFE7FFE61C66FBE61BE7DBE61C67FFE0000
+245D:00007FFE61B67DB661866FF661F67FFE7FFE618E6FB661B67DB6618E7FFE0000
+245E:00007FFE61B67DB661866FF661F67FFE7FFE61866FBE618E7DBE61867FFE0000
+245F:00007FFE61B67DB661866FF661F67FFE7FFE61866FBE618E7DBE61BE7FFE0000
+2460:07C0183020084104430485028102810281028102410447C42008183007C00000
+2461:07C0183020084384444484428042808281028202440447C42008183007C00000
+2462:07C0183020084384444484428042818280428442444443842008183007C00000
+2463:07C018302008408441848282848288828FC28082408440842008183007C00000
+2464:07C01830200847C4440484028402878280428042444443842008183007C00000
+2465:07C0183020084184420484028402878284428442444443842008183007C00000
+2466:07C01830200847C4404480428082808280828102410441042008183007C00000
+2467:07C0183020084384444484428442838284428442444443842008183007C00000
+2468:07C018302008438444448442844283C280428042408443042008183007C00000
+2469:07C018302008400444648C9294928492849284925F6440042008183007C00000
+246A:07C018302008400444448CC295428442844284425FF440042008183007C00000
+246B:07C018302008400444648C9294128422844284825FF440042008183007C00000
+246C:07C018302008400444648C9294128422841284925F6440042008183007C00000
+246D:07C018302008400444148C329452849284FA84125F1440042008183007C00000
+246E:07C018302008400444F48C82948284E2841284925F6440042008183007C00000
+246F:07C018302008400444748C82948284E2849284925F6440042008183007C00000
+2470:07C018302008400444F48C1294128422842284425F4440042008183007C00000
+2471:07C018302008400444648C9294928462849284925F6440042008183007C00000
+2472:07C018302008400444648C9294928472841284125F6440042008183007C00000
+2473:07C01830200840044C64929282928492889290925E6440042008183007C00000
+2474:00000000100820842184428240824082408240824082208423E4100800000000
+2475:00000000100823C424244422402240C2410242024402240427E4100800000000
+2476:00000000100823C424244422402241C2402240224422242423C4100800000000
+2477:000000001008204420C4414242424442444247E2404220442044100800000000
+2478:00000000100827E424044402440247C2402240224022242423C4100800000000
+2479:00000000100821C422044402440247C2442244224422242423C4100800000000
+247A:00000000100827E4202440224042404240424082408220842084100800000000
+247B:00000000100823C424244422442243C2442244224422242423C4100800000000
+247C:00000000100823C424244422442243E240224022402220442384100800000000
+247D:00000000400288319849A885888588858885888588858849BE31400200000000
+247E:00000000400288119831A851881188118811881188118811BE7D400200000000
+247F:00000000400288799885A885880588198821884188818881BEFD400200000000
+2480:00000000400288799885A885880588398805880588858885BE79400200000000
+2481:00000000400288099819A82988498889888988FD88098809BE09400200000000
+2482:00000000400288FD9881A881888188F98805880588058885BE79400200000000
+2483:00000000400288399841A881888188F98885888588858885BE79400200000000
+2484:00000000400289F99809A809881188118811882188218821BE21400200000000
+2485:00000000400288799885A885888588798885888588858885BE79400200000000
+2486:00000000400288799885A8858885887D8805880588058809BE71400200000000
+2487:0000000040029C31A249A2858285848588859085A085A049BE31400200000000
+2488:000000000000000001000300050001000100010001000100010007D000000000
+2489:00000000000000000780084008400040018002000400080008000FD000000000
+248A:0000000000000000078008400840004003800040004008400840079000000000
+248B:00000000000000000080018002800480088008800FC000800080009000000000
+248C:00000000000000000FC00800080008000F800040004000400840079000000000
+248D:000000000000000003800400080008000F800840084008400840079000000000
+248E:00000000000000000FC000400040008000800080010001000100011000000000
+248F:0000000000000000078008400840084007800840084008400840079000000000
+2490:0000000000000000078008400840084007C00040004000400080071000000000
+2491:00000000000000001060309051081108110811081108110810907C6200000000
+2492:00000000000000001020306050A01020102010201020102010207CFA00000000
+2493:000000000000000010F0310851081008103010401080110011007DFA00000000
+2494:000000000000000010F0310851081008107010081008110811087CF200000000
+2495:000000000000000010103030505010901110111011F8101010107C1200000000
+2496:000000000000000011F831005100110011F010081008100811087CF200000000
+2497:0000000000000000107030805100110011F011081108110811087CF200000000
+2498:000000000000000011F8300850081010101010101020102010207C2200000000
+2499:000000000000000010F031085108110810F011081108110811087CF200000000
+249A:000000000000000010F031085108110810F810081008100810107CE200000000
+249B:00000000000000003C304248428402840C8410842084408440487E3100000000
+249C:00000000000010082004200443C24422402243E244224422246423A410080000
+249D:00000000000014082404240445C246224422442244224422262425C410080000
+249E:00000000000010082004200443C244224402440244024402242423C410080000
+249F:00000000000010282024202443A244624422442244224422246423A410080000
+24A0:00000000000010082004200443C24422442247E244024402242423C410080000
+24A1:00000000000010C821042104410247C241024102410241022104210410080000
+24A2:00000000000010082004202443A24442444244424382420223C42424142803C0
+24A3:00000000000014082404240445C2462244224422442244222424242410080000
+24A4:000000000000111021082008430441044104410441044104210827C810100000
+24A5:00000000000010502048200840C4404440444044404440442048204814900300
+24A6:0000000000001408240424044442448245024602450244822444242410080000
+24A7:000000000000131021082108410441044104410441044104210827C810100000
+24A8:0000000000001004200220024761449144914491449144912492249210040000
+24A9:00000000000010082004200445C2462244224422442244222424242410080000
+24AA:00000000000010082004200443C244224422442244224422242423C410080000
+24AB:00000000000010082004200445C246224422442244224422262425C414080400
+24AC:00000000000010082004200443A244624422442244224422246423A410280020
+24AD:00000000000010082004200445C2462244224402440244022404240410080000
+24AE:00000000000010082004200443C244224402430240C24022242423C410080000
+24AF:00000000000010082104210447C241024102410241024102210420C410080000
+24B0:000000000000100820042004442244224422442244224422246423A410080000
+24B1:0000000000001008200420044422442244224242424242422184218410080000
+24B2:0000000000001004200220024411449144914491449144912492236210040000
+24B3:0000000000001008200420044422442242424182418242422424242410080000
+24B4:00000000000010082004200444224422442244224422426221A42024102803C0
+24B5:00000000000010082004200447E240224042408241024202240427E410080000
+24B6:07C0183020084104428482828442844287C28442444444442008183007C00000
+24B7:07C0183020084784444484428442878284428442444447842008183007C00000
+24B8:07C0183020084384444484428402840284028442444443842008183007C00000
+24B9:07C0183020084704448484428442844284428442448447042008183007C00000
+24BA:07C01830200847C4440484028402878284028402440447C42008183007C00000
+24BB:07C01830200847C4440484028402878284028402440444042008183007C00000
+24BC:07C018302008438444448442840285C28442844244C443442008183007C00000
+24BD:07C018302008444444448442844287C284428442444444442008183007C00000
+24BE:07C01830200847C4410481028102810281028102410447C42008183007C00000
+24BF:07C01830200843E4408480828082808280828482448443042008183007C00000
+24C0:07C0183020084444444484828502860285028482444444442008183007C00000
+24C1:07C0183020084404440484028402840284028402440447C42008183007C00000
+24C2:07C0183020084444444486C286C2854285428442444444442008183007C00000
+24C3:07C01830200840044444864286428542854284C244C444442008183007C00000
+24C4:07C0183020084384444484428442844284428442444443842008183007C00000
+24C5:07C0183020084784444484428442878284028402440444042008183007C00000
+24C6:07C018302008438444448442844284428442854246C443842068183007C00000
+24C7:07C0183020084784444484428442878285028482448444442008183007C00000
+24C8:07C0183020084384444484428402838280428442444443842008183007C00000
+24C9:07C0183020084FE4410481028102810281028102410441042008183007C00000
+24CA:07C0183020084444444484428442844284428442444443842008183007C00000
+24CB:07C0183020084824482484428442844282828282410441042008183007C00000
+24CC:07C0183020084444444484428542854286C286C2444444442008183007C00000
+24CD:07C0183020084444444482828282810282828282444444442008183007C00000
+24CE:07C0183020084824482484428442828281028102410441042008183007C00000
+24CF:07C01830200847C4404480428082810282028402440447C42008183007C00000
+24D0:07C018302008400443848442804283C2844284C2434440042008183007C00000
+24D1:07C0183024084404440485828642844284428442464445842008183007C00000
+24D2:07C0183020084004438484428402840284028442438440042008183007C00000
+24D3:07C01830204840444044834284C284428442844244C443442008183007C00000
+24D4:07C018302008400443848442844287C284028442438440042008183007C00000
+24D5:07C01830200840C441048102810287C281028102410441042108183007C00000
+24D6:07C0183020084044434484828482830282028382444444442388183007C00000
+24D7:07C0183024084404440485828642844284428442444444442008183007C00000
+24D8:07C0183021084104400483028102810281028102410447C42008183007C00000
+24D9:07C0183020484044400480C28042804280428042404444842308183007C00000
+24DA:07C0183020084404440484828502860286028502448444442008183007C00000
+24DB:07C0183020084304410481028102810281028102410447C42008183007C00000
+24DC:07C01830200840044EC489228922892289228922492440042008183007C00000
+24DD:07C0183020084004458486428442844284428442444440042008183007C00000
+24DE:07C0183020084004438484428442844284428442438440042008183007C00000
+24DF:07C0183020084004458486428442844284428642458444042408183007C00000
+24E0:07C0183020084004434484C2844284428442844244C443442048183007C00000
+24E1:07C0183020084004458486428442840284028402440440042008183007C00000
+24E2:07C0183020084004438484428402838280428442438440042008183007C00000
+24E3:07C0183020084104410487C28102810281028102410440C42008183007C00000
+24E4:07C01830200840044444844284428442844284C2434440042008183007C00000
+24E5:07C0183020084004444484428282828282828102410440042008183007C00000
+24E6:07C018302008400448248922892289228922892246C440042008183007C00000
+24E7:07C0183020084004444484428282810282828442444440042008183007C00000
+24E8:07C0183020084004444484428442844282C28142404440442388183007C00000
+24E9:07C018302008400447C48042808281028202840247C440042008183007C00000
+24EA:07C0183020084104428484428442844284428442428441042008183007C00000
+24EB:07C01FF03FF87FFC7BBCF33EEABEFBBEFBBEFBBE600C7FFC3FF81FF007C00000
+24EC:07C01FF03FF87FFC7B9CF36EEBEEFBDEFBBEFB7E600C7FFC3FF81FF007C00000
+24ED:07C01FF03FF87FFC7B9CF36EEBEEFBDEFBEEFB6E609C7FFC3FF81FF007C00000
+24EE:07C01FF03FF87FFC7BECF3CEEBAEFB6EFB06FBEE60EC7FFC3FF81FF007C00000
+24EF:07C01FF03FF87FFC7B0CF37EEB7EFB1EFBEEFB6E609C7FFC3FF81FF007C00000
+24F0:000007C01FF03FF83B88737C6B7C7B1C7B6C7B6C20983FF81FF007C000000000
+24F1:000007C01FF03FF83B0873EC6BEC7BDC7BDC7BBC20B83FF81FF007C000000000
+24F2:000007C01FF03FF83B98736C6B6C7B9C7B6C7B6C20983FF81FF007C000000000
+24F3:07C01FF03FF87FFC7B9CF36EEB6EFB8EFBEEFBEE609C7FFC3FF81FF007C00000
+24F4:07C01FF03FF87FFC739CED6EFD6EFB6EF76EEF6E619C7FFC3FF81FF007C00000
+24F5:07E0181823C44C32500A9089A185A085A08591C9500A4C3223C4181807E00000
+24F6:07E0181823C44C32500A9189A045A085A10591C9500A4C3223C4181807E00000
+24F7:07E0181823C44C32500A9189A045A185A0459189500A4C3223C4181807E00000
+24F8:07E0181823C44C32500A9289A285A3C5A0859089500A4C3223C4181807E00000
+24F9:07E0181823C44C32500A91C9A105A185A0459189500A4C3223C4181807E00000
+24FA:07E0181823C44C32500A9189A205A385A2459189500A4C3223C4181807E00000
+24FB:07E0181823C44C32500A91C9A045A045A0859089500A4C3223C4181807E00000
+24FC:07E0181823C44C32500A9189A245A185A2459189500A4C3223C4181807E00000
+24FD:07E0181823C44C32500A9189A245A1C5A0459189500A4C3223C4181807E00000
+24FE:07E0181823C44C32500A9269A695A295A2959769500A4C3223C4181807E00000
+24FF:07C01FF03FF87EFC7D7CFBBEFBBEFBBEFBBEFBBE7D7C7EFC3FF81FF007C00000
+2500:00000000000000FF0000000000000000
+2501:00000000000000FFFF00000000000000
+2502:08080808080808080808080808080808
+2503:18181818181818181818181818181818
+2504:00000000000000DB0000000000000000
+2505:00000000000000DBDB00000000000000
+2506:08080808000008080808000008080808
+2507:18181818000018181818000018181818
+2508:00000000000000AA0000000000000000
+2509:00000000000000AAAA00000000000000
+250A:08080800080808000808080008080800
+250B:18181800181818001818180018181800
+250C:000000000000000F0808080808080808
+250D:000000000000000F0F08080808080808
+250E:000000000000001F1818181818181818
+250F:000000000000001F1F18181818181818
+2510:00000000000000F80808080808080808
+2511:00000000000000F8F808080808080808
+2512:00000000000000F81818181818181818
+2513:00000000000000F8F818181818181818
+2514:080808080808080F0000000000000000
+2515:080808080808080F0F00000000000000
+2516:181818181818181F0000000000000000
+2517:181818181818181F1F00000000000000
+2518:08080808080808F80000000000000000
+2519:08080808080808F8F800000000000000
+251A:18181818181818F80000000000000000
+251B:18181818181818F8F800000000000000
+251C:080808080808080F0808080808080808
+251D:080808080808080F0F08080808080808
+251E:181818181818181F0808080808080808
+251F:080808080808081F1818181818181818
+2520:181818181818181F1818181818181818
+2521:181818181818181F1F08080808080808
+2522:080808080808081F1F18181818181818
+2523:181818181818181F1F18181818181818
+2524:08080808080808F80808080808080808
+2525:08080808080808F8F808080808080808
+2526:18181818181818F80808080808080808
+2527:08080808080808F81818181818181818
+2528:18181818181818F81818181818181818
+2529:18181818181818F8F808080808080808
+252A:08080808080808F8F818181818181818
+252B:18181818181818F8F818181818181818
+252C:00000000000000FF0808080808080808
+252D:00000000000000FFF808080808080808
+252E:00000000000000FF0F08080808080808
+252F:00000000000000FFFF08080808080808
+2530:00000000000000FF1818181818181818
+2531:00000000000000FFF818181818181818
+2532:00000000000000FF1F18181818181818
+2533:00000000000000FFFF18181818181818
+2534:08080808080808FF0000000000000000
+2535:08080808080808FFF800000000000000
+2536:08080808080808FF0F00000000000000
+2537:08080808080808FFFF00000000000000
+2538:18181818181818FF0000000000000000
+2539:18181818181818FFF800000000000000
+253A:18181818181818FF1F00000000000000
+253B:18181818181818FFFF00000000000000
+253C:08080808080808FF0808080808080808
+253D:08080808080808FFF808080808080808
+253E:08080808080808FF0F08080808080808
+253F:08080808080808FFFF08080808080808
+2540:18181818181818FF0808080808080808
+2541:08080808080808FF1818181818181818
+2542:18181818181818FF1818181818181818
+2543:18181818181818FFF808080808080808
+2544:18181818181818FF1F08080808080808
+2545:08080808080808FFF818181818181818
+2546:08080808080808FF1F18181818181818
+2547:18181818181818FFFF08080808080808
+2548:08080808080808FFFF18181818181818
+2549:18181818181818FFF818181818181818
+254A:18181818181818FF1F18181818181818
+254B:18181818181818FFFF18181818181818
+254C:00000000000000EE0000000000000000
+254D:00000000000000EEEE00000000000000
+254E:08080808080800000808080808080000
+254F:18181818181800001818181818180000
+2550:000000000000FF00FF00000000000000
+2551:14141414141414141414141414141414
+2552:0000000000000F080F08080808080808
+2553:000000000000001F1414141414141414
+2554:0000000000001F101714141414141414
+2555:000000000000F808F808080808080808
+2556:00000000000000FC1414141414141414
+2557:000000000000FC04F414141414141414
+2558:0808080808080F080F00000000000000
+2559:141414141414141F0000000000000000
+255A:14141414141417101F00000000000000
+255B:080808080808F808F800000000000000
+255C:14141414141414FC0000000000000000
+255D:141414141414F404FC00000000000000
+255E:0808080808080F080F08080808080808
+255F:14141414141414171414141414141414
+2560:14141414141417101714141414141414
+2561:080808080808F808F808080808080808
+2562:14141414141414F41414141414141414
+2563:141414141414F404F414141414141414
+2564:000000000000FF00FF08080808080808
+2565:00000000000000FF1414141414141414
+2566:000000000000FF00F714141414141414
+2567:080808080808FF00FF00000000000000
+2568:14141414141414FF0000000000000000
+2569:141414141414F700FF00000000000000
+256A:080808080808FF08FF08080808080808
+256B:14141414141414FF1414141414141414
+256C:141414141414F700F714141414141414
+256D:00000000000000030408080808080808
+256E:00000000000000E01008080808080808
+256F:08080808080810E00000000000000000
+2570:08080808080804030000000000000000
+2571:01010202040408081010202040408080
+2572:80804040202010100808040402020101
+2573:81814242242418181818242442428181
+2574:00000000000000F00000000000000000
+2575:08080808080808080000000000000000
+2576:000000000000000F0000000000000000
+2577:00000000000000000808080808080808
+2578:00000000000000F0F000000000000000
+2579:18181818181818180000000000000000
+257A:000000000000000F0F00000000000000
+257B:00000000000000001818181818181818
+257C:00000000000000FF0F00000000000000
+257D:08080808080808081818181818181818
+257E:00000000000000FFF000000000000000
+257F:18181818181818180808080808080808
+2580:FFFFFFFFFFFFFFFF0000000000000000
+2581:0000000000000000000000000000FFFF
+2582:000000000000000000000000FFFFFFFF
+2583:00000000000000000000FFFFFFFFFFFF
+2584:0000000000000000FFFFFFFFFFFFFFFF
+2585:000000000000FFFFFFFFFFFFFFFFFFFF
+2586:00000000FFFFFFFFFFFFFFFFFFFFFFFF
+2587:0000FFFFFFFFFFFFFFFFFFFFFFFFFFFF
+2588:FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
+2589:FEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFE
+258A:FCFCFCFCFCFCFCFCFCFCFCFCFCFCFCFC
+258B:F8F8F8F8F8F8F8F8F8F8F8F8F8F8F8F8
+258C:F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0
+258D:E0E0E0E0E0E0E0E0E0E0E0E0E0E0E0E0
+258E:C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0
+258F:80808080808080808080808080808080
+2590:0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F
+2591:88228822882288228822882288228822
+2592:AA55AA55AA55AA55AA55AA55AA55AA55
+2593:EEBBEEBBEEBBEEBBEEBBEEBBEEBBEEBB
+2594:FFFF0000000000000000000000000000
+2595:01010101010101010101010101010101
+2596:0000000000000000F0F0F0F0F0F0F0F0
+2597:00000000000000000F0F0F0F0F0F0F0F
+2598:F0F0F0F0F0F0F0F00000000000000000
+2599:F0F0F0F0F0F0F0F0FFFFFFFFFFFFFFFF
+259A:F0F0F0F0F0F0F0F00F0F0F0F0F0F0F0F
+259B:FFFFFFFFFFFFFFFFF0F0F0F0F0F0F0F0
+259C:FFFFFFFFFFFFFFFF0F0F0F0F0F0F0F0F
+259D:0F0F0F0F0F0F0F0F0000000000000000
+259E:0F0F0F0F0F0F0F0FF0F0F0F0F0F0F0F0
+259F:0F0F0F0F0F0F0F0FFFFFFFFFFFFFFFFF
+25A0:000000000000007F7F7F7F7F7F7F0000
+25A1:0000000000007F41414141417F000000
+25A2:0000000000003E41414141413E000000
+25A3:0000000000007F415D5D5D417F000000
+25A4:0000000000007F417F417F417F000000
+25A5:0000000000007F55555555557F000000
+25A6:0000000000007F557F557F557F000000
+25A7:0000000000007F53496553497F000000
+25A8:0000000000007F65495365497F000000
+25A9:0000000000007F556B556B557F000000
+25AA:00000000000000003C3C3C3C00000000
+25AB:0000000000003C24243C000000000000
+25AC:0000000000007F7F7F7F000000000000
+25AD:0000000000007F41417F000000000000
+25AE:00000000003C3C3C3C3C3C3C00000000
+25AF:00000000003C24242424243C00000000
+25B0:000000000000003F7EFC000000000000
+25B1:000000000000003F42FC000000000000
+25B2:000000000018183C3C7E7E0000000000
+25B3:000000000018182424427E0000000000
+25B4:0000000000000000183C7E0000000000
+25B5:000000000000000018247E0000000000
+25B6:00000000000060787E7E786000000000
+25B7:00000000000060584646586000000000
+25B8:00000000000000303C3C300000000000
+25B9:00000000000000302C2C300000000000
+25BA:0000000000000060787E786000000000
+25BB:00000000000000605846586000000000
+25BC:00000000007E7E3C3C18180000000000
+25BD:00000000007E42242418180000000000
+25BE:00000000000000007E3C180000000000
+25BF:00000000000000007E24180000000000
+25C0:000000000000061E7E7E1E0600000000
+25C1:000000000000061A62621A0600000000
+25C2:000000000000000C3C3C0C0000000000
+25C3:000000000000000C34340C0000000000
+25C4:00000000000000061E7E1E0600000000
+25C5:00000000000000061A621A0600000000
+25C6:0000000000081C3E7F3E1C0800000000
+25C7:00000000000814224122140800000000
+25C8:000000000008142A5D2A140800000000
+25C9:00000000001C22595D4D221C00000000
+25CA:00000018182424424224241818000000
+25CB:00000000001C22414141221C00000000
+25CC:00000000001400410041001400000000
+25CD:00000000001C36555555361C00000000
+25CE:00000000001C22495549221C00000000
+25CF:00000000001C3E7F7F7F3E1C00000000
+25D0:00000000001C32717171321C00000000
+25D1:00000000001C26474747261C00000000
+25D2:00000000001C2241417F3E1C00000000
+25D3:00000000001C3E7F4141221C00000000
+25D4:00000000001C2E4F4F41221C00000000
+25D5:00000000001C2647477F3E1C00000000
+25D6:00000000001838787878381800000000
+25D7:00000000000C0E0F0F0F0E0C00000000
+25D8:FFFFFFFFFFFFE7C3C3E7FFFFFFFFFFFF
+25D9:FFFFFFFFFFE7DBBDBDDBE7FFFFFFFFFF
+25DA:FFFFFFFFFFE7DBBD0000000000000000
+25DB:0000000000000000BDDBE7FFFFFFFFFF
+25DC:00000000001820404000000000000000
+25DD:00000000000C02010100000000000000
+25DE:00000000000000000101020C00000000
+25DF:00000000000000004040201800000000
+25E0:00000000001C22414100000000000000
+25E1:00000000000000004141221C00000000
+25E2:0101030307070F0F1F1F3F3F7F7FFFFF
+25E3:8080C0C0E0E0F0F0F8F8FCFCFEFEFFFF
+25E4:FFFFFEFEFCFCF8F8F0F0E0E0C0C08080
+25E5:FFFF7F7F3F3F1F1F0F0F070703030101
+25E6:00000000000000384444443800000000
+25E7:00000000007E727272727E0000000000
+25E8:00000000007E4E4E4E4E7E0000000000
+25E9:00000000007E7A7262427E0000000000
+25EA:00000000007E42464E5E7E0000000000
+25EB:00000000007F494949497F0000000000
+25EC:0000000000081414222A417F00000000
+25ED:00000000000018183434727E00000000
+25EE:000000000018182C2C4E4E7E00000000
+25EF:0000000001C00630080810041004200220022002100410040808063001C00000
+25F0:00000000000000007E527242427E0000
+25F1:00000000000000007E424272527E0000
+25F2:00000000000000007E42424E4A7E0000
+25F3:00000000000000007E4A4E42427E0000
+25F4:0000000000003C5291F18181423C0000
+25F5:0000000000003C428181F191523C0000
+25F6:0000000000003C4281818F894A3C0000
+25F7:0000000000003C4A898F8181423C0000
+25F8:00007E44485060400000000000000000
+25F9:00007E22120A06020000000000000000
+25FA:00000000000000000040605048447E00
+25FB:0000000000000000007E424242427E00
+25FC:00000000000000007E7E7E7E7E7E0000
+25FD:000000000000000000003C24243C0000
+25FE:00000000000000007C7C7C7C7C000000
+25FF:00000000000000000002060A12227E00
+2600:0000084922001C3E3E1C002249080000
+2601:000000002076FF7E0000000000000000
+2602:000000001C3E7F080808081000000000
+2603:8BC803C02FF104248A5028120A504994042147E008101088781E1088081007E0
+2604:00000022222424282902304848300000
+2605:000000000008087F1C36220000000000
+2606:00000000080877222A36220000000000
+2607:00000000000204081020100A060E0000
+2608:0000000000007E424448504A464E0000
+2609:0000000000003C4281999981423C0000
+260A:00000000000018242466A54200000000
+260B:00000000000042A56624241800000000
+260C:00000000000004083048483000000000
+260D:00000000000609090608304848300000
+260E:000000000000003E63002A637F000000
+260F:0000000000003E415D3E49417F000000
+2610:000000003FF820082008200820082008200820082008200820083FF800000000
+2611:000000003FF8200820082038286828C829882B082E082C0820083FF800000000
+2612:000000003FFC200420042C34266423C4218423C426642C3420043FFC00000000
+2613:00000000222214140808141422220000
+2614:055004411C3E7F080808081000000000
+2615:000009201240124009200920124000001FC83FF42FD4201420381FC000000000
+2616:00000100028004400820101020082008200820082008200820083FF800000000
+2617:00000100038007C00FE01FF03FF83FF83FF83FF83FF83FF83FF83FF800000000
+2618:00000000028007C007C03398793C3FF8793C3118020002000200040008000000
+2619:00000000000401C823E847E84FE87FD83FDC0FE407E403E401C4000800000000
+261A:00000000000000007E1F1F0E00000000
+261B:00000000000000003F7C7C3800000000
+261C:00000000000000007E11190E00000000
+261D:000000000004041C3424241800000000
+261E:00000000000000003F444C3800000000
+261F:00000000000000182424341C04040000
+2620:0000E7A57E81A5A5815A5A42BDE70000
+2621:000000003804040808101020201C0000
+2622:07E0181824245C3A5C3ABE7DBE7DBE7D8181818183C143C247E223C4181807E0
+2623:00000000044008201010101013900C603EF84444854283820280044018300000
+2624:0000030001007FFC23881FF001000D6011100FE0092007C00540038005400100
+2625:0000000000001C2214083E0808080000
+2626:0000000000103810FE1010701C100000
+2627:000000001C12121C1054381038540000
+2628:0000000000103810FE10101010100000
+2629:000000000000001C08497F49081C0000
+262A:000000001E2140C2C7C240211E000000
+262B:000000000000054006C0000015502928292829282548139007C0010000000000
+262C:000000000000008002A0049009C81AAC1AAC19CC1C9C1BEC11C402A000800000
+262D:0000000000000C0239790D3E63C10000
+262E:0000000000003E4949495D6B493E0000
+262F:07E018182004400240029C31BE31FF03E783E7C7FFFF7FFE7FFE3FFC1FF807E0
+2630:00000000000000007FFC7FFC000000007FFC7FFC000000007FFC7FFC00000000
+2631:00000000000000007C7C7C7C000000007FFC7FFC000000007FFC7FFC00000000
+2632:00000000000000007FFC7FFC000000007C7C7C7C000000007FFC7FFC00000000
+2633:00000000000000007C7C7C7C000000007C7C7C7C000000007FFC7FFC00000000
+2634:00000000000000007FFC7FFC000000007FFC7FFC000000007C7C7C7C00000000
+2635:00000000000000007C7C7C7C000000007FFC7FFC000000007C7C7C7C00000000
+2636:00000000000000007FFC7FFC000000007C7C7C7C000000007C7C7C7C00000000
+2637:00000000000000007C7C7C7C000000007C7C7C7C000000007C7C7C7C00000000
+2638:00000000000000493E3E773E3E490000
+2639:0000003C4281A58199A581423C000000
+263A:000000003C4281A581A599423C000000
+263B:000000003C7EFFDBFFDBE77E3C000000
+263C:0000000000492A1C771C2A4900000000
+263D:00000000380C0605050505060C380000
+263E:000000000E18305050505030180E0000
+263F:00000022221C2222221C083E08080000
+2640:00000000001C2222221C083E08080000
+2641:00000008083E08081C2222221C000000
+2642:00000000000703053844444438000000
+2643:000000000202023A46060A7E02020000
+2644:00000000202070202C32222424240000
+2645:00000000006B2A3E2A6B081C141C0000
+2646:000000000859CB4949493E083E080800
+2647:000000007C4242427C404040407E0000
+2648:00000000225514140808080808080000
+2649:0000000000000041221C2222221C0000
+264A:00000000413E1414141414143E410000
+264B:0000000000003E4948300609493E0000
+264C:00000000001C22221274949465020000
+264D:00000000547C555755555555067C0000
+264E:000000000000001C222277007F000000
+264F:00000000547C54545454545455030000
+2650:000000000000000F0345291028440000
+2651:00000000314E8408103C62A2A21C0000
+2652:0000000000002A5400002A5400000000
+2653:0000000000424224247E242442420000
+2654:000000081C08775D49492A7F417F0000
+2655:000000000808492A2A5D2A3E223E0000
+2656:0000000000557F4141222241417F0000
+2657:000000000814222222221477417F0000
+2658:000000021E2242423A122242427E0000
+2659:000000000000182424182424427E0000
+265A:000000081C08775D49492A7F7F7F0000
+265B:000000000808492A2A5D2A3E3E3E0000
+265C:0000000000557F7F7F3E3E7F7F7F0000
+265D:00000000081C3622363E1C7F7F7F0000
+265E:000000021E367E7E3E1E3E7E7E7E0000
+265F:000000000000183C3C183C3C7E7E0000
+2660:0000000008081C3E7F7F7F3E081C0000
+2661:00000000003649414141221408080000
+2662:00000000080814142222141408080000
+2663:000000001C1C1C087F7F6B08081C0000
+2664:00000000080814224141413E081C0000
+2665:0000000000367F7F7F7F3E1C08080000
+2666:0000000008081C1C3E3E1C1C08080000
+2667:000000001C141C08775D6B08081C0000
+2668:000000085192929249494952817E0000
+2669:00000000080808080808083878700000
+266A:00000000080C0A0A0808083878700000
+266B:0000001C171111111171F1E70F0E0000
+266C:0000001C17111D171171F1E70F0E0000
+266D:000040404040405C6646444850600000
+266E:00000040404E7E72424E7E7202020000
+266F:00000424263E7C6424263E7C64242000
+2670:00000000140808493E49080808140000
+2671:000000001C14086B5D6B080814080000
+2672:03C005200A9812480AD004303004480A8C115009A005AE26525852861E5C0020
+2673:0380044004400820002839181B382900210843844004802280427EFC00400020
+2674:038004400440082000283B1818B82900220843844004802280427EFC00400020
+2675:038004400440082000283B1818B82B00208843044004802280427EFC00400020
+2676:038004400440082000283A981AB82B80208840844004802280427EFC00400020
+2677:038004400440082000283B981A382B00208843044004802280427EFC00400020
+2678:0380044004400820002839981A382B80224841844004802280427EFC00400020
+2679:038004400440082000283B9818B82900210841044004802280427EFC00400020
+267A:03800440044008200028381818382800200840044004802280427EFC00400020
+267B:03C005E00EF81E780EF004303004780EFC1F700FE007EE265E785EFE1E7C0020
+267C:07E01FF83E7C7DBE7BDEFF8FF7DFE7FFF3EFF7EFEFF76FB6710E3FBC1FF807E0
+267D:07E018182184424244228071882198018C1188119009504A4EF22044181807E0
+267E:00000000000003800C601010200826C84924492426C8200810100C6003800000
+267F:0000000000000600060004000780040017E0202020102050108C0F0000000000
+2680:00000000000000001FF010101010101011101010101010101FF0000000000000
+2681:00000000000000001FF010101010141010101050101010101FF0000000000000
+2682:00000000000000001FF010101410101011101010105010101FF0000000000000
+2683:00000000000000001FF010101450101010101010145010101FF0000000000000
+2684:00000000000000001FF010101450101011101010145010101FF0000000000000
+2685:00000000000000001FF010101450101014501010145010101FF0000000000000
+2686:00000000000003C0042008101008200420642064200410080810042003C00000
+2687:00000000000003C0042008101008200426642664200410080810042003C00000
+2688:00000000000003C007E00FF01FF83FFC3F9C3F9C3FFC1FF80FF007E003C00000
+2689:00000000000003C007E00FF01FF83FFC399C399C3FFC1FF80FF007E003C00000
+268A:000000000000000000000000000000007FFC7FFC000000000000000000000000
+268B:000000000000000000000000000000007C7C7C7C000000000000000000000000
+268C:0000000000000000000000007FFC7FFC000000007FFC7FFC0000000000000000
+268D:0000000000000000000000007C7C7C7C000000007FFC7FFC0000000000000000
+268E:0000000000000000000000007FFC7FFC000000007C7C7C7C0000000000000000
+268F:0000000000000000000000007C7C7C7C000000007C7C7C7C0000000000000000
+2690:000000704E4242724E40404040400000
+2691:000000707E7E7E7E4E40404040400000
+2692:000008325C7C3E7E7C1FF8277443228101000280044008201010200840040000
+2693:000000000380044004400380010007C001002108711C210811100FE000000000
+2694:0000400420081010082004400280010002800440282810102828400400000000
+2695:0000010001000FF0113011000FC00120012007C0090007800140038001000000
+2696:000000000000010011107FFC39385454545492929292FEFE7C7C383800000000
+2697:000000000000000003E007F00BF80BF811F010E0100001F00248044400000000
+2698:0000000003800440044004400380010039383D781D700D600380010001000000
+2699:000000000100210817D0082010101010711C10101010082017D0210801000000
+269A:00000100028039387FFCFD7E0540038001000100010001000100010000000000
+269B:018002400240742E8E7185A14E7235AC35AC4E7285A18E71742E024002400180
+269C:01000280044034584C648442B29ACAA61AB010101BB00AA03AB826C819300100
+269D:010002800440044008006BFC8802882260241810065000882108264818300000
+269E:30000C00030000C00030000C00003FFC0000000C003000C003000C0030000000
+269F:000C003000C003000C00300000003FFC000030000C00030000C00030000C0000
+26A0:000001000280028004400440092009201110111021082008410440047FFC0000
+26A1:0000000002040810207E040810204000
+26A2:000000000000000000000EE011102288228811100EE004400EE0044000000000
+26A3:00000000000001C000C001400E38111823A825401A200C200440038000000000
+26A4:000000380018002801C0022007100A90116010C0088007000200070002000000
+26A5:0000000000000000007000300050038004400820082004400380010003800100
+26A6:00000000000000000038001800A800400EA011002080208011000E0000000000
+26A7:000000000000E00EC006A80A10102BA004400820082004400380010003800100
+26A8:00001038541038103844828244380000
+26A9:000000000000000000000000000000001C002208414441FE414422081C000000
+26AA:00000000000000003844828282443800
+26AB:0000000000000000387CFEFEFE7C3800
+26AC:0000000000000000001C2222221C0000
+26AD:000000000000000000000000000000000EE011102288228811100EE000000000
+26AE:0000000000000000000000000000000000800EB811C411C411C40EB800800000
+26AF:0000000000000000000000000000000000003838444447C44444383800000000
+26B0:000000000C0013C0203E4002400240024002603E53C22E3E1BC00C0000000000
+26B1:000007C002800FE010102008200810101010101008200820082007C000000000
+26B2:00000000001C2222221C080808080000
+26B3:0000000000384402020418107C100000
+26B4:0000000010284482442810107C100000
+26B5:00000000925438FE385492107C100000
+26B6:0000000000000100010001000100393804400280793C04400280010000000000
+26B7:00000012141814121038444444380000
+26B8:000000001C38707070381C083E080000
+26B9:000000000000422418FF182442000000
+26BA:00000000000044444428282810FE0000
+26BB:000000000000FE102828284444440000
+26BC:0000000000007E4242424A7E207E0000
+26BD:0000000001C007300F38173C100421C223E239CE1C1C180C09C807F001C00000
+26BE:0000000001C006300C1812241004214220022142100412240C18063001C00000
+26BF:000000007FFC4004438444444444438441044104410441C4410440047FFC0000
+26C0:0000000000000000000007E0181821842184381C2FF42A541A5807E000000000
+26C1:0000000007E0181821842184381C2FF42A543A5C2FF42A541A5807E000000000
+26C2:00000000000000000FF0381C67E65E7A5E7A47E2500A55AA65A6381C0FF00000
+26C3:00000FF0381C67E65E7A5E7A47E2500A55AA45A2500A55AA65A6381C0FF00000
+26C4:03C003C00FF004200A5008100A500990042007E008101088781E1088081007E0
+26C5:00000000000001200148001000C0072C09A010602010201010600F8000000000
+26C6:0000222244440088100022224444008810002222444400801012222444480000
+26C7:8BC803C02FF107E48DB02FF20DB04E7407E147E00FF01F787FFE1F780FF007E0
+26C8:0000072008CC10B22102208211040A1807E02000444000801010222044400000
+26C9:00003FF820082008200820082008200820081010082004400280010000000000
+26CA:00003FF83FF83FF83FF83FF83FF83FF83FF83FF81FF00FE00380010000000000
+26CB:0000000000007FF04510489050506030401060305050489045107FF000000000
+26CC:0000000000000000202010400880040002000100088010402020000000000000
+26CD:00003C00420042008100FF00FF00FF0042004200004000A00110020804040FFE
+26CE:000000000000000000000440044004501E48254824F014400440066000000000
+26CF:000040C027001C001C003E003300218040C0406000300018000C000600000000
+26D0:000000E0031005C803F804E8003000401C00218022001AC002203C2000000000
+26D1:0000000007001DC038E07DF0FFF84010401040102020202018C0070000000000
+26D2:00000000070018C020205050489081088208840848905050202018C007000000
+26D3:000022102A381C5408441C442A54223822102A381C5408441C442A5422380010
+26D4:00000000000007001FC03FE07FF07FF0C018C0187FF07FF03FE01FC007000000
+26D5:000000000C301E302D300C3008E00BC00A000BC008E00C300CB40C780C300000
+26D6:00000000018003C007E00BD011D82ADC7BDE3B541B880FD007E003C001800000
+26D7:0000018002400420081014282E245522842144AA247410280810042002400180
+26D8:0000000007FC07FC07FC0FFC1FFC3FFC3FFC3FFC3FFC3FFC3FFC3FFC00000000
+26D9:00000000180619061906190630066106C106C106C006C106C106C10600000000
+26DA:00000000781E781E700E600600000000000000006006700E781E781E00000000
+26DB:00000000000000001FF018300C600C6006C007C0038003800100010000000000
+26DC:00000000180318431843184330036043C043C043C403C443C443C44300000000
+26DD:0000000000003FF83018282824482288210822882448282830183FF800000000
+26DE:00000000FDF8F8F8E038D018C818840802008108C098C058E038F8F8FDF80000
+26DF:000000007FF07FF07FFC7FF27FF27FFE7FFE7FFE6FF657EA381C100800000000
+26E0:00007FFE3E021C42084200020042004200020042004200020042004200020000
+26E1:0000400060007000780070006000400040804040422046104E085E047FFE0000
+26E2:00000010387C10107C82BABA827C0000
+26E3:00000100193019300100010003800C60082010101010101008200C6003800000
+26E4:0000010001000280028002807FFC244814500C600AA0092016D0183020080000
+26E5:0000010001000280028000807F5C2048141008600A00092014D0183020080000
+26E6:00000100010002800280020075FC240810500C2000A009201650183020080000
+26E7:00002008183016D009200AA00C60145024487FFC028002800280010001000000
+26E8:0000000000003FF02010231023102FD02FD023102310201030300CC003000000
+26E9:00000000FFFE1010101010101FF0101010101010101010101010101000000000
+26EA:0100010007C001000100038007C01FF07C7C3838339837D837D837D800000000
+26EB:0000000000000F80088078F04010401040104010401040104010401000000000
+26EC:000000000000000000000180018000000000000000000C300C30000000000000
+26ED:000000000000010011100BA0044008203838082004400BA01110010000000000
+26EE:000000000000010011100BA004440824783C482044400BA01110010000000000
+26EF:000000000000010011100BA004400BA03BB80BA004400BA01110010000000000
+26F0:00000000000000000100028004600410081813F83FFC3FFC7FFE7FFE00000000
+26F1:000007E01818282447E2791E41020200020002000400040004007FFE7FFE0000
+26F2:00001450228842844004438447C407C000007FFC3FF80FE00FE01FF03FF80000
+26F3:0000018001E001F8010001000100010001003D787D7CFC7E7EFC3FF807C00000
+26F4:0000000003000300030007E00A5012482248FFFC3FF81FF80FF0000000000000
+26F5:000001000180014005400D20152025104510FDF80100FFFC3FF81FF80FF00000
+26F6:0000381C400240024002000000000000000000000000400240024002381C0000
+26F7:0000000038003800380006000E207FF01C201C0C0E300FC003001C0000000000
+26F8:0000000000000000000000F000F000F000F01FF03FF03FE008403FF800000000
+26F9:0000038003800380000003FC07800B80138C238C038006C006C00C600C60783C
+26FA:0000060005000E800E400E201F101F081F043F823F84318871C871D071E00000
+26FB:0000000007C01830200830180820044004400440082030182008183007C00000
+26FC:00000000010001000100010007C00000000010101010101010107C7C00000000
+26FD:000000000F801FD8104410421FF21FCA1FCA1FCA1FCA1FC41FC07FF000000000
+26FE:00007FFE7FFE7006701A701A701A7006780E7C1E4FF247E26006781E7FFE0000
+26FF:000000007FFC400440047FFC7FFC400440047FFC400040004000400040000000
+2700:0000000038047C1E6C3C7F783FF003E03FF07F786C3C7C1E3804000000000000
+2701:000038007C006C007C003C000E007FFCFFFED9C0F8E070000000000000000000
+2702:0000000038067C1C6C387F703FE003C03FE07F706C387C1C3806000000000000
+2703:00000000000000007000F8E0D9C0FFFE7FFC0E003C007C006C007C0038000000
+2704:00000000700C8832AE4481887910062078508188AE448832700C000000000000
+2705:00000000000000000004000A001200242048509051202A40248011000E000000
+2706:07C01830200841C447E48FF28F729E629C029F024F0446042008183007C00000
+2707:07C01930238843844104838287C287C287C28BA25C7458342008183007C00000
+2708:000008000F00060007C0C380E3C07FFE7FFEE3C0C38007C006000F0008000000
+2709:00000000000000007FFE6006500A499247E247E24992500A60067FFE00000000
+270A:000000000000000003600C90149035F8550454E454C43704280810100FE00000
+270B:00000A801540154035405540554C5552402240044008201010100FE000000000
+270C:18302448228812901110092008207CFC92829272922292427C0420081FF00000
+270D:00000008001C003803F70CF511CD238547056FE512052FFD7005600700000000
+270E:000000001800260055004A80714028A014500A28052802C8011800F800000000
+270F:00000000000000003FF050288FF4A8168FF450283FF000000000000000000000
+2710:0000000000F8011802C805280A28145028A071404A8055002600180000000000
+2711:000000000000000000F07908866C80FE866C790800F000000000000000000000
+2712:000000000000000000E079F0FF38FF0EFF3879F000E000000000000000000000
+2713:0000000000000000000000040008001040204040208021001200140008000000
+2714:00000000000000000004000E401CE038E07070E071C03B803F001E000C000000
+2715:00000000101038381C700EE007C0038007C00EE01C7038381010000000000000
+2716:101038387C7CFEFE7FFC3FF81FF00FE01FF03FF87FFCFEFE7C7C383810100000
+2717:00006018306031C01B000E000E001B00198030C0306060306018200000000000
+2718:00006018707031E03B801F000E001F001B8039C030E070706038601020000000
+2719:07C00440054005400540FD7E8102BFFA8102FD7E054005400540044007C00000
+271A:07C007C007C007C007C0FFFEFFFEFFFEFFFEFFFE07C007C007C007C007C00000
+271B:038003800380038003800380FC7EFC7EFC7E0380038003800380038003800000
+271C:07C007C007C007C007C0F83EF83EF83EF83EF83E07C007C007C007C007C00000
+271D:000000000380038003801FF01FF01FF003800380038003800380000000000000
+271E:078004C004C004C07CF8400C400C7CFC3CFC04C004C004C004C007C003C00000
+271F:00000FE008207BBC43845FF45FF45FF443847BBC0BA00BA00BA008200FE00000
+2720:00000FF803E021C221C231C63FFE3FFE3FFE31C621C221C203E00FF800000000
+2721:000000000100028004407FFC244818300820183024487FFC0440028001000000
+2722:038007C007C003800380610CF93EFFFEF93E610C0380038007C007C003800000
+2723:038007C007C007C00380711CF93EFFFEF93E711C038007C007C007C003800000
+2724:07C00FE00FE007C0638CF39EFFFEFFFEFFFEF39E638C07C00FE00FE007C00000
+2725:0100038007C007C00100310C710EFFFF710E310C010007C007C0038001000000
+2726:01000380038007C007C01FF07FFCFFFE7FFC1FF007C007C00380038001000000
+2727:010002800280044004401830600C8002600C1830044004400280028001000000
+2728:0000040004000A00110060C011100A10042804C6002800100110028001000000
+2729:0000010002800280FC7E4004383808201010111026C828283018000000000000
+272A:07C01FF03EF87EFC7C7CC006F01EF83EF01EF11E67CC6FEC3FF81FF007C00000
+272B:0000010003800380FFFE7C7C383808201C701FF03EF838383018000000000000
+272C:0000010002800280FC7E438427C817D01390101027C828283018000000000000
+272D:0000010002801C70E10E4FE4238817D01450111022882C683018000000000000
+272E:0000010002801D70E38E5FF42FE817D016D0155022882C683018000000000000
+272F:00000100038005C0F9FE5D8C27B813F00FD01D9019D032E82C78301800000000
+2730:00000100028002C0FC7E4007383E083C1010111827C82F2C3C1C180C00000000
+2731:00000380038003804384F39E3FFC0FF03FFCF39E438403800380038000000000
+2732:00000380038003804384F39E3C7C08303C7CF39E438403800380038000000000
+2733:01000100210811100D600FE007C0FFFE07C00FE00D6011102108010001000000
+2734:0100010021081BB01FF00FE01FE0FFFE1FF00FE01FF01BB02108010001000000
+2735:010002803CF82CC8269832B87D4C83864D7C3A9832C826683E78028001000000
+2736:000001000100010043843BB81FF00FE01FF03BB8438401000100010000000000
+2737:082008200C6006C0E6CE3BB81FF007C01FF03BB8E6CE06C00C60082008200000
+2738:08200C600EE00FE0FFFE7FFC3FF81FF03FF87FFCFFFE0FE00EE00C6008200000
+2739:010019300FE04FE47FFC3FF83FF8FFFE3FF83FF87FFC4FE40FE0193001000000
+273A:0920492425481550CBA637D80FE0FFFE0FE037D8CBA615502548492409200000
+273B:0100038003800380E10E711C0D6003800D60711CE10E03800380038001000000
+273C:038007C007C0638CF11EF39E3C7808203C78F39EF11E638C07C007C003800000
+273D:038007C007C0638CF39EF11E3D7807C03D78F11EF39E638C07C007C003800000
+273E:038004400440745CFC7EFEFE7FFC2108438487C28FE277DC07C007C003800000
+273F:038007C00FE077DCFFFEFC7EF01E701C18303EF87FFC7EFC7EFC3C7800000000
+2740:038004400920793C8542B39A8FE26FEC17D027C84924529442843C7800000000
+2741:03803C78454451144D646FEC86C2BC7A86C26FEC4D64511445443C7803800000
+2742:07C01EF03EF85C7467CCFC7EE82E8822E82EFC7E67CC5C743EF81EF007C00000
+2743:038004C004C074DCBCE69F9E4F3C3FF87264E672CE7A765C0640064003800000
+2744:0000010005400380C92631184D6403804D643118C92603800540010000000000
+2745:0000010005400BA0C92631184D6483824D643118C9260BA00540010000000000
+2746:09200D6007C01390C9263118ED6E0380ED6E3118C926111007C00D6009200000
+2747:000003C023C413C8099005A0700E7DBE7DBE700E05A0099013C823C403C00000
+2748:07C047C427C813900BA0E00EFBBEFBBEFBBEE00E0BA0139027C847C407C00000
+2749:038007C007C077DCFBBEF93E7D7C07C07D7CF93EFBBE77DC07C007C003800000
+274A:010003803398311809200540638CFFFE638C0540092031183398038001000000
+274B:0100038033983BB8193007C077DCFFFE77DC07C019303BB83398038001000000
+274C:0000000018303C781EF00FE007C007C00FE01EF03C7838381010000000000000
+274D:0000000003C00C301008100C2004200620062006100E100C0C3C03F801E00000
+274E:00007FFC6FEC47C4638C711C783C7C7C783C711C638C47C46FEC7FFC00000000
+274F:00001FF81008100E100E100E100E100E100E100E1FFE07FE07FE000000000000
+2750:000007FE07FE1FFE100E100E100E100E100E100E100E10081FF8000000000000
+2751:00001FF8100C100E100E100E100E100E100E100E1FFE0FFE07FE000000000000
+2752:000007FE0FFE1FFE100E100E100E100E100E100E100E100C1FF8000000000000
+2753:000003800FE01E70183018F001E0038003000300030000000300078007800300
+2754:07C0082013901450085000900120024002800280038000000380044004400380
+2755:038006C00C6008200C60044006C0028002800380000003800440044003800000
+2756:00000100038007C00380111038387C7C38381110038007C00380010000000000
+2757:018003C003C003C003C003C003C0018001800180018000000180018000000000
+2758:0180018001800180018001800180018001800180018001800180018001800000
+2759:03C003C003C003C003C003C003C003C003C003C003C003C003C003C003C00000
+275A:0FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00000
+275B:01C007000C000F800FC00FE00FE00FE007C00380000000000000000000000000
+275C:038007C00FE00FE00FE007E003E0006001C00700000000000000000000000000
+275D:1C1C7070C0C0F8F8FCFCFEFEFEFEFEFE7C7C3838000000000000000000000000
+275E:38387C7CFEFEFEFEFEFE7E7E3E3E06061C1C7070000000000000000000000000
+275F:000000000000000007000F801FC01FC01FC00FC007C000C003800E0000000000
+2760:000000000000000038387C7CFEFEFEFEFEFE7E7E3E3E06061C1C707000000000
+2761:0000001000100FFE3FF87E107E103F100FF0001030307820786031C01F000000
+2762:03800FE01FF01FF01FF00FE00380010001000000038007C007C007C003800000
+2763:00000EE01FF01FF01FF00FE0038001000000038007C007C007C0038000000000
+2764:000000003C787EFCFFFEFFFEFFFE7FFC7FFC3FF81FF00FE007C0038001000000
+2765:1C003F007F807FC07FE07FF03FF81FFC3FF87FF07FE07FC07F803F001C000000
+2766:000000001F0421F801800E701FF81FF81FF80FF007E003C00180019000E00000
+2767:000000002000138017C417E217F21BFE3BFC27F027E027C02380100000000000
+2768:00000002040C1818181818180C040200
+2769:0000002010180C0C0C0C0C0C18102000
+276A:000000060C1C3838383838381C0C0600
+276B:00000030181C0E0E0E0E0E0E1C183000
+276C:000000060C0C1818303018180C0C0600
+276D:0000003018180C0C06060C0C18183000
+276E:000000070E0E1C1C38381C1C0E0E0700
+276F:0000007038381C1C0E0E1C1C38387000
+2770:0000000F1E1E3C3C78783C3C1E1E0F00
+2771:000000F078783C3C1E1E3C3C7878F000
+2772:00000004081010101010101010080400
+2773:00000020100808080808080808102000
+2774:0000001E38303018187018183030381E
+2775:000000781C0C0C18180E18180C0C1C78
+2776:07C01FF03FF87EFC7CFCFAFEFEFEFEFEFEFEFEFE7EFC783C3FF81FF007C00000
+2777:07C01FF03FF87C7C7BBCFBBEFFBEFF7EFEFEFDFE7BFC783C3FF81FF007C00000
+2778:07C01FF03FF87C7C7BBCFBBEFFBEFE7EFFBEFBBE7BBC7C7C3FF81FF007C00000
+2779:07C01FF03FF87F7C7E7CFD7EFB7EF77EF03EFF7E7F7C7F7C3FF81FF007C00000
+277A:07C01FF03FF8783C7BFCFBFEFBFEF87EFFBEFFBE7BBC7C7C3FF81FF007C00000
+277B:07C01FF03FF87E7C7DFCFBFEFBFEF87EFBBEFBBE7BBC7C7C3FF81FF007C00000
+277C:07C01FF03FF8783C7FBCFFBEFF7EFF7EFF7EFEFE7EFC7EFC3FF81FF007C00000
+277D:07C01FF03FF87C7C7BBCFBBEFBBEFC7EFBBEFBBE7BBC7C7C3FF81FF007C00000
+277E:07C01FF03FF87C7C7BBCFBBEFBBEFC3EFFBEFFBE7F7C7CFC3FF81FF007C00000
+277F:07C01FF03FF87FFC7B9CF36EEB6EFB6EFB6EFB6E609C7FFC3FF81FF007C00000
+2780:07C0183020084084418483828182818281828182418441842008183007C00000
+2781:07C01830200847C44FE48C62806281C287028C024FE44FE42008183007C00000
+2782:07C01830200847C44FE48C62806281C280628C624FE447C42008183007C00000
+2783:07C01830200840E441E4836286628C629FF29FF2406440642008183007C00000
+2784:07C0183020084FE44FE48C028FC28FE280628C624FE447C42008183007C00000
+2785:07C01830200847C44FE48C028FC28FE28C628C624FE447C42008183007C00000
+2786:07C0183020084FE44FE48062806280C283828602460446042008183007C00000
+2787:07C01830200847C44FE48C628C6287C28C628C624FE447C42008183007C00000
+2788:07C01830200847C44FE48C628C628FE287E280624FE447C42008183007C00000
+2789:07C01830200844E44DF49DB28DB28DB28DB28DB24DF44CE42008183007C00000
+278A:07C01FF03FF87F7C7E7CFC7EFE7EFE7EFE7EFE7E7E7C7E7C3FF81FF007C00000
+278B:07C01FF03FF8783C701CF39EFF9EFE3EF8FEF3FE701C701C3FF81FF007C00000
+278C:07C01FF03FF8783C701CF39EFF9EFE3EFF9EF39E701C783C3FF81FF007C00000
+278D:07C01FF03FF87F1C7E1CFC9EF99EF39EE00EE00E7F9C7F9C3FF81FF007C00000
+278E:07C01FF03FF8701C701CF3FEF03EF01EFF9EF39E701C783C3FF81FF007C00000
+278F:07C01FF03FF8783C701CF3FEF03EF01EF39EF39E701C783C3FF81FF007C00000
+2790:07C01FF03FF8701C701CFF9EFF9EFF3EFC7EF9FE79FC79FC3FF81FF007C00000
+2791:07C01FF03FF8783C701CF39EF39EF83EF39EF39E701C783C3FF81FF007C00000
+2792:07C01FF03FF8783C701CF39EF39EF01EF81EFF9E701C783C3FF81FF007C00000
+2793:07C01FF03FF87B1C720CE24EF24EF24EF24EF24E720C731C3FF81FF007C00000
+2794:00001F800FC007E003F0FFF8FFFCFFFEFFFCFFF803F007E00FC01F8000000000
+2795:0000000003800380038003803FF83FF83FF80380038003800380000000000000
+2796:0000000000000000000000007FFC7FFC7FFC0000000000000000000000000000
+2797:0000000003800380038000007FFC7FFC7FFC0000038003800380000000000000
+2798:0000000008001C003E001E000F20032000E000F003F000700008000000000000
+2799:00000000000001000180E0C0FCF0FFFEFCF0E0C0018001000000000000000000
+279A:0000000000000008007003F000F000E003200F201E003E001C00080000000000
+279B:0000000000000200010001C000F0FFFE00F001C0010002000000000000000000
+279C:000000C001E001F000F87FFCFFFEFFFEFFFE7FFC00F801F001E000C000000000
+279D:000000000010001000180018FFFCFFFEFFFC0018001800100010000000000000
+279E:00000010001000180018FFFCFFFCFFFEFFFCFFFC001800180010001000000000
+279F:000000000000002000300038AAFCAAFEAAFC0038003000200000000000000000
+27A0:00000000000000200030AAF8AAFCAAFEAAFCAAF8003000200000000000000000
+27A1:000000000000002000300038FFFCFFFEFFFC0038003000200000000000000000
+27A2:400070002C00230010C01030080C07FE0FFC1FF01FC03F003C00700040000000
+27A3:400070003C003F001FC01FF00FFC07FE080C103010C023002C00700040000000
+27A4:400070003C003F001FC01FF00FFC07FE0FFC1FF01FC03F003C00700040000000
+27A5:00000000000080008010C0187FFC7FFE3FFC0018001000000000000000000000
+27A6:0000000000000000001000183FFC7FFE7FFCC018801080000000000000000000
+27A7:00000080008000C007C007E007E007F007E007E007C000C00080008000000000
+27A8:00000000000000400040FFE0FFF0FFFEFFF0FFE0004000400000000000000000
+27A9:000000000000006000707FD8400C4006400C7FD8007000600000000000000000
+27AA:000000000000006000707FE86004600260047FE8007000600000000000000000
+27AB:0000000000080018002400443F8240028006FF1EFE7C05F00FC00F000C000000
+27AC:00000C000F000FC005F0FE7CFF1E800640023F82004400240018000800000000
+27AD:00000000008000C0FFA0801080088004800E801CFFB87FF000E0004000000000
+27AE:0000004000E07FF0FFB8801C800E800480088010FFA000C00080000000000000
+27AF:00000000004000600050FFC8400440024007FFCE7FDC00780070002000000000
+27B0:0000000000631C2222221C0000000000
+27B1:00000020007000787FDCFFCE400740024004FFC8005000600040000000000000
+27B2:07C01FF03F787F3C7F1C000E000600020006000E7F1C7F3C3F781FF007C00000
+27B3:0000000000000000FE004908248C1FFE248C4908FE0000000000000000000000
+27B4:000000000400060007003F001F000F08008800580038007801F8000000000000
+27B5:000000000000000000007C083E0C1FFE3E0C7C08000000000000000000000000
+27B6:00000000000001F800780038005800880F081F003F0007000600040000000000
+27B7:0000000002000300038003803F881F880FD800F8007800F803F8000000000000
+27B8:0000000000000020FC107E183FFC1FFE3FFC7E18FC1000200000000000000000
+27B9:00000000000003F800F8007800F80FD81F883F88038003800300020000000000
+27BA:00000000006000F000F07838FF0CFFFEFF0C783800F000F00060000000000000
+27BB:000000000000004060E078F0FC78FFFEFC7878F060E000400000000000000000
+27BC:0000000000000000F8107C183E1C1FFE3E1C7C18F81000000000000000000000
+27BD:000000000000F860FC707E787FFC3FFE7FFC7E78FC70F8600000000000000000
+27BE:000000000000022001100088FFC40002FFC40088011002200000000000000000
+27BF:00000000000000000000E3C71C382244224422441C3800000000000000000000
+27C0:000000000000000040444850607E0000
+27C1:000000000100028002800440044009200AA01290145027C820083FF800000000
+27C2:000000000000000010101010107C0000
+27C3:0000000000000000000007F808001030104810481030080007F8000000000000
+27C4:000000000000000000001FE000100C08120812080C0800101FE0000000000000
+27C5:000000001C22220404080810100E0000
+27C6:000000001C2222101008080404380000
+27C7:00000000000041412A22141408080000
+27C8:0000000000000000000040FE41002200220012001200090008FE000000000000
+27C9:000000000000000000007F020082004400440048004800907F10000000000000
+27CA:00000000101010103810101010100000
+27CB:0000000000000000000000100020004000800100020004000800000000000000
+27CC:000000003FFC2000100010000800080008000800080008001000100020002000
+27CD:0000000000000000000008000400020001000080004000200010000000000000
+27CE:0000000000001FFC1004108410841144114412241224141414141FFC00000000
+27CF:0000000000001FFC1414141412241224114411441084108410041FFC00000000
+27D0:0000000000000000000000800140022004100888041002200140008000000000
+27D1:00000000000008081414222A41410000
+27D2:000000000000000011101110111011101110111011101110092007C000000000
+27D3:000000000000000002021202027E0000
+27D4:00000000000000007E40404840400000
+27D5:000000000000000038040C0C0A14092408C408C409240A140C0C380400000000
+27D6:0000000000000000201C30302850249023102310249028503030201C00000000
+27D7:0000000000000000700E18181428124811881188124814281818700E00000000
+27D8:00000000010001000100010001000100010001000100010001001FF000000000
+27D9:000000001FF00100010001000100010001000100010001000100010000000000
+27DA:00000000000000000000028002807EFC02807EFC028002800000000000000000
+27DB:000000000000000000000280028002807EFC0280028002800000000000000000
+27DC:00000000000000000000000000001C00220023FC22001C000000000000000000
+27DD:0000000000000000000000004000400040007FFE400040004000000000000000
+27DE:0000000000000000000000000002000200027FFE000200020002000000000000
+27DF:000000003844443810101010107C0000
+27E0:0000001028284444FE44442828100000
+27E1:0000010002800280044008203018400430180820044002800280010000000000
+27E2:000000800140014002200410180CE002180C0410022001400140008000000000
+27E3:0000010002800280044008203018400730180820044002800280010000000000
+27E4:00001FFE10021002100210021002F002100210021002100210021FFE00000000
+27E5:00007FF840084008400840084008400F400840084008400840087FF800000000
+27E6:003E28282828282828282828283E0000
+27E7:007C14141414141414141414147C0000
+27E8:00000408081010202010100808040000
+27E9:00002010100808040408081010200000
+27EA:00000A141428285050282814140A0000
+27EB:000050282814140A0A14142828500000
+27EC:00000002040C1414141414140C040200
+27ED:00000040203028282828282830204000
+27EE:00000002040808080808080808040200
+27EF:00000040201010101010101010204000
+27F0:000000000100028006C00AA01AB02AA80AA00AA00AA00AA00AA00AA000000000
+27F1:000000000AA00AA00AA00AA00AA00AA02AA81AB00AA006C00280010000000000
+27F2:000000000000000001E00210040808042A041C0408040008021001E000000000
+27F3:0000000000000000078008401020201020542038201010000840078000000000
+27F4:0000000000000000038005480924FFFE09240548038000000000000000000000
+27F5:00000000000000000000100020007FFF20001000000000000000000000000000
+27F6:0000000000000000000000080004FFFE00040008000000000000000000000000
+27F7:00000000000000000000100820047FFE20041008000000000000000000000000
+27F8:0000000000000000100020007FFE80007FFE2000100000000000000000000000
+27F9:000000000000000000100008FFFC0002FFFC0008001000000000000000000000
+27FA:0000000000000000081010083FFC40023FFC1008081000000000000000000000
+27FB:00000000000000000000100220027FFE20021002000000000000000000000000
+27FC:00000000000000000000400840047FFE40044008000000000000000000000000
+27FD:0000000000000000080210023FFE40023FFE1002080200000000000000000000
+27FE:0000000000000000401040087FFC40027FFC4008401000000000000000000000
+27FF:0000000000000000000000082224D55E08840008000000000000000000000000
+2800:00000022000022000022000022000000
+2801:00000032300022000022000022000000
+2802:00000022000032300022000022000000
+2803:00000032300032300022000022000000
+2804:00000022000022000032300022000000
+2805:00000032300022000032300022000000
+2806:00000022000032300032300022000000
+2807:00000032300032300032300022000000
+2808:00000026060022000022000022000000
+2809:00000036360022000022000022000000
+280A:00000026060032300022000022000000
+280B:00000036360032300022000022000000
+280C:00000026060022000032300022000000
+280D:00000036360022000032300022000000
+280E:00000026060032300032300022000000
+280F:00000036360032300032300022000000
+2810:00000022000026060022000022000000
+2811:00000032300026060022000022000000
+2812:00000022000036360022000022000000
+2813:00000032300036360022000022000000
+2814:00000022000026060032300022000000
+2815:00000032300026060032300022000000
+2816:00000022000036360032300022000000
+2817:00000032300036360032300022000000
+2818:00000026060026060022000022000000
+2819:00000036360026060022000022000000
+281A:00000026060036360022000022000000
+281B:00000036360036360022000022000000
+281C:00000026060026060032300022000000
+281D:00000036360026060032300022000000
+281E:00000026060036360032300022000000
+281F:00000036360036360032300022000000
+2820:00000022000022000026060022000000
+2821:00000032300022000026060022000000
+2822:00000022000032300026060022000000
+2823:00000032300032300026060022000000
+2824:00000022000022000036360022000000
+2825:00000032300022000036360022000000
+2826:00000022000032300036360022000000
+2827:00000032300032300036360022000000
+2828:00000026060022000026060022000000
+2829:00000036360022000026060022000000
+282A:00000026060032300026060022000000
+282B:00000036360032300026060022000000
+282C:00000026060022000036360022000000
+282D:00000036360022000036360022000000
+282E:00000026060032300036360022000000
+282F:00000036360032300036360022000000
+2830:00000022000026060026060022000000
+2831:00000032300026060026060022000000
+2832:00000022000036360026060022000000
+2833:00000032300036360026060022000000
+2834:00000022000026060036360022000000
+2835:00000032300026060036360022000000
+2836:00000022000036360036360022000000
+2837:00000032300036360036360022000000
+2838:00000026060026060026060022000000
+2839:00000036360026060026060022000000
+283A:00000026060036360026060022000000
+283B:00000036360036360026060022000000
+283C:00000026060026060036360022000000
+283D:00000036360026060036360022000000
+283E:00000026060036360036360022000000
+283F:00000036360036360036360022000000
+2840:00000022000022000022000032300000
+2841:00000032300022000022000032300000
+2842:00000022000032300022000032300000
+2843:00000032300032300022000032300000
+2844:00000022000022000032300032300000
+2845:00000032300022000032300032300000
+2846:00000022000032300032300032300000
+2847:00000032300032300032300032300000
+2848:00000026060022000022000032300000
+2849:00000036360022000022000032300000
+284A:00000026060032300022000032300000
+284B:00000036360032300022000032300000
+284C:00000026060022000032300032300000
+284D:00000036360022000032300032300000
+284E:00000026060032300032300032300000
+284F:00000036360032300032300032300000
+2850:00000022000026060022000032300000
+2851:00000032300026060022000032300000
+2852:00000022000036360022000032300000
+2853:00000032300036360022000032300000
+2854:00000022000026060032300032300000
+2855:00000032300026060032300032300000
+2856:00000022000036360032300032300000
+2857:00000032300036360032300032300000
+2858:00000026060026060022000032300000
+2859:00000036360026060022000032300000
+285A:00000026060036360022000032300000
+285B:00000036360036360022000032300000
+285C:00000026060026060032300032300000
+285D:00000036360026060032300032300000
+285E:00000026060036360032300032300000
+285F:00000036360036360032300032300000
+2860:00000022000022000026060032300000
+2861:00000032300022000026060032300000
+2862:00000022000032300026060032300000
+2863:00000032300032300026060032300000
+2864:00000022000022000036360032300000
+2865:00000032300022000036360032300000
+2866:00000022000032300036360032300000
+2867:00000032300032300036360032300000
+2868:00000026060022000026060032300000
+2869:00000036360022000026060032300000
+286A:00000026060032300026060032300000
+286B:00000036360032300026060032300000
+286C:00000026060022000036360032300000
+286D:00000036360022000036360032300000
+286E:00000026060032300036360032300000
+286F:00000036360032300036360032300000
+2870:00000022000026060026060032300000
+2871:00000032300026060026060032300000
+2872:00000022000036360026060032300000
+2873:00000032300036360026060032300000
+2874:00000022000026060036360032300000
+2875:00000032300026060036360032300000
+2876:00000022000036360036360032300000
+2877:00000032300036360036360032300000
+2878:00000026060026060026060032300000
+2879:00000036360026060026060032300000
+287A:00000026060036360026060032300000
+287B:00000036360036360026060032300000
+287C:00000026060026060036360032300000
+287D:00000036360026060036360032300000
+287E:00000026060036360036360032300000
+287F:00000036360036360036360032300000
+2880:00000022000022000022000026060000
+2881:00000032300022000022000026060000
+2882:00000022000032300022000026060000
+2883:00000032300032300022000026060000
+2884:00000022000022000032300026060000
+2885:00000032300022000032300026060000
+2886:00000022000032300032300026060000
+2887:00000032300032300032300026060000
+2888:00000026060022000022000026060000
+2889:00000036360022000022000026060000
+288A:00000026060032300022000026060000
+288B:00000036360032300022000026060000
+288C:00000026060022000032300026060000
+288D:00000036360022000032300026060000
+288E:00000026060032300032300026060000
+288F:00000036360032300032300026060000
+2890:00000022000026060022000026060000
+2891:00000032300026060022000026060000
+2892:00000022000036360022000026060000
+2893:00000032300036360022000026060000
+2894:00000022000026060032300026060000
+2895:00000032300026060032300026060000
+2896:00000022000036360032300026060000
+2897:00000032300036360032300026060000
+2898:00000026060026060022000026060000
+2899:00000036360026060022000026060000
+289A:00000026060036360022000026060000
+289B:00000036360036360022000026060000
+289C:00000026060026060032300026060000
+289D:00000036360026060032300026060000
+289E:00000026060036360032300026060000
+289F:00000036360036360032300026060000
+28A0:00000022000022000026060026060000
+28A1:00000032300022000026060026060000
+28A2:00000022000032300026060026060000
+28A3:00000032300032300026060026060000
+28A4:00000022000022000036360026060000
+28A5:00000032300022000036360026060000
+28A6:00000022000032300036360026060000
+28A7:00000032300032300036360026060000
+28A8:00000026060022000026060026060000
+28A9:00000036360022000026060026060000
+28AA:00000026060032300026060026060000
+28AB:00000036360032300026060026060000
+28AC:00000026060022000036360026060000
+28AD:00000036360022000036360026060000
+28AE:00000026060032300036360026060000
+28AF:00000036360032300036360026060000
+28B0:00000022000026060026060026060000
+28B1:00000032300026060026060026060000
+28B2:00000022000036360026060026060000
+28B3:00000032300036360026060026060000
+28B4:00000022000026060036360026060000
+28B5:00000032300026060036360026060000
+28B6:00000022000036360036360026060000
+28B7:00000032300036360036360026060000
+28B8:00000026060026060026060026060000
+28B9:00000036360026060026060026060000
+28BA:00000026060036360026060026060000
+28BB:00000036360036360026060026060000
+28BC:00000026060026060036360026060000
+28BD:00000036360026060036360026060000
+28BE:00000026060036360036360026060000
+28BF:00000036360036360036360026060000
+28C0:00000022000022000022000036360000
+28C1:00000032300022000022000036360000
+28C2:00000022000032300022000036360000
+28C3:00000032300032300022000036360000
+28C4:00000022000022000032300036360000
+28C5:00000032300022000032300036360000
+28C6:00000022000032300032300036360000
+28C7:00000032300032300032300036360000
+28C8:00000026060022000022000036360000
+28C9:00000036360022000022000036360000
+28CA:00000026060032300022000036360000
+28CB:00000036360032300022000036360000
+28CC:00000026060022000032300036360000
+28CD:00000036360022000032300036360000
+28CE:00000026060032300032300036360000
+28CF:00000036360032300032300036360000
+28D0:00000022000026060022000036360000
+28D1:00000032300026060022000036360000
+28D2:00000022000036360022000036360000
+28D3:00000032300036360022000036360000
+28D4:00000022000026060032300036360000
+28D5:00000032300026060032300036360000
+28D6:00000022000036360032300036360000
+28D7:00000032300036360032300036360000
+28D8:00000026060026060022000036360000
+28D9:00000036360026060022000036360000
+28DA:00000026060036360022000036360000
+28DB:00000036360036360022000036360000
+28DC:00000026060026060032300036360000
+28DD:00000036360026060032300036360000
+28DE:00000026060036360032300036360000
+28DF:00000036360036360032300036360000
+28E0:00000022000022000026060036360000
+28E1:00000032300022000026060036360000
+28E2:00000022000032300026060036360000
+28E3:00000032300032300026060036360000
+28E4:00000022000022000036360036360000
+28E5:00000032300022000036360036360000
+28E6:00000022000032300036360036360000
+28E7:00000032300032300036360036360000
+28E8:00000026060022000026060036360000
+28E9:00000036360022000026060036360000
+28EA:00000026060032300026060036360000
+28EB:00000036360032300026060036360000
+28EC:00000026060022000036360036360000
+28ED:00000036360022000036360036360000
+28EE:00000026060032300036360036360000
+28EF:00000036360032300036360036360000
+28F0:00000022000026060026060036360000
+28F1:00000032300026060026060036360000
+28F2:00000022000036360026060036360000
+28F3:00000032300036360026060036360000
+28F4:00000022000026060036360036360000
+28F5:00000032300026060036360036360000
+28F6:00000022000036360036360036360000
+28F7:00000032300036360036360036360000
+28F8:00000026060026060026060036360000
+28F9:00000036360026060026060036360000
+28FA:00000026060036360026060036360000
+28FB:00000036360036360026060036360000
+28FC:00000026060026060036360036360000
+28FD:00000036360026060036360036360000
+28FE:00000026060036360036360036360000
+28FF:00000036360036360036360036360000
+2900:0000000000000000000002280214FFFE02140228000000000000000000000000
+2901:0000000000000000000005280514FFFE05140528000000000000000000000000
+2902:0000000000000000088010803FFF40803FFF1080088000000000000000000000
+2903:000000000000000001100108FFFC0102FFFC0108011000000000000000000000
+2904:0000000000000000049008881FFC20821FFC0888049000000000000000000000
+2905:00000000000000000000402840147FFE40144028000000000000000000000000
+2906:0000000000000000080010023FFE40023FFE1002080000000000000000000000
+2907:0000000000000000001040087FFC40027FFC4008001000000000000000000000
+2908:080808080808083E0808082A1C080000
+2909:0000081C2A08083E0808080808080808
+290A:000000000100038005400D601550054005400540054005400540054000000000
+290B:00000000054005400540054005400540054015500D6005400380010000000000
+290C:00000000000000000000100020007F7F20001000000000000000000000000000
+290D:0000000000000000000000080004FEFE00040008000000000000000000000000
+290E:00000000000000000000100020007DEF20001000000000000000000000000000
+290F:0000000000000000000000080004F7BE00040008000000000000000000000000
+2910:00000000000000000000402820141B7E20144028000000000000000000000000
+2911:0000000000000000000000080004AAAE00040008000000000000000000000000
+2912:00007F1C2A0808080808080808080808
+2913:08080808080808080808082A1C7F0000
+2914:00000000000000000000410821041FFE21044108000000000000000000000000
+2915:00000000000000000000428822841FFE22844288000000000000000000000000
+2916:00000000000000000000402820141FFE20144028000000000000000000000000
+2917:00000000000000000000412821141FFE21144128000000000000000000000000
+2918:00000000000000000000452825141FFE25144528000000000000000000000000
+2919:00000000000000000000000200047FF800040002000000000000000000000000
+291A:00000000000000000000400020001FFE20004000000000000000000000000000
+291B:00000000000000000000001200247FF800240012000000000000000000000000
+291C:00000000000000000000480024001FFE24004800000000000000000000000000
+291D:0000000000000000000011003A007FFF3A001100000000000000000000000000
+291E:000000000000000000000044002E7FFF002E0044000000000000000000000000
+291F:0000000000000000000011023A027FFE3A021102000000000000000000000000
+2920:000000000000000000004088405C7FFE405C4088000000000000000000000000
+2921:00003C00300028002400020001000080004000200012000A0006001E00000000
+2922:0000001E0006000A0012002000400080010002002400280030003C0000000000
+2923:00003C0030002800240002000100008000400020001000080024001800000000
+2924:0000007800180028004800800100020004000800100020004800300000000000
+2925:0000300048002000100008000400020001000080004800280018007800000000
+2926:0000003000480010002000400080010002000400480050006000780000000000
+2927:0000781E6006500A481204200240018001800240042008101008200400000000
+2928:0000001E2006100A08120420024001800180024004200812100A2006001E0000
+2929:00002004100808100420024001800180024004204812500A6006781E00000000
+292A:0000780060045008481004200240018001800240042048105008600478000000
+292B:0000000020041008081004200040008001000200042008101008200400000000
+292C:0000000020041008081004200200010000800040042008101008200400000000
+292D:0000001E2006100A08120420020001000080004004200812100A2006001E0000
+292E:0000001E2006100A08120420004000800100020004200812100A2006001E0000
+292F:0000001E2006100A081204200200010000800040042008101008200400000000
+2930:00002004100808100420004000800100020004200812100A2006001E00000000
+2931:0000781E6006500A481204200040008001000200042008101008200400000000
+2932:0000781E6006500A481204200200010000800040042008101008200400000000
+2933:000000000000000000003C08420481FE00040008000000000000000000000000
+2934:0000001000380054001000100020FFC000000000000000000000000000000000
+2935:00000000FFC00020001000100010005400380010000000000000000000000000
+2936:00080008000800080008040808101FE008000400000000000000000000000000
+2937:100010001000100010001020081007F800100020000000000000000000000000
+2938:000020100808040404042828303C0000
+2939:0000040810102020202014140C3C0000
+293A:00000000000000000000000023C02C3030083C04000000000000000000000000
+293B:000000000000000000000000203C100C0C3403C4000000000000000000000000
+293C:00000000000000000000000003C40C34100C203C070000000000000000000000
+293D:00000000000000000000000023C02C3030083C4400E000400000000000000000
+293E:00000000000000100008000400043C0430082C3023C000000000000000000000
+293F:0000000000000800100020002000203C100C0C3403C400000000000000000000
+2940:000000000080010003800D601090101020082008101010100C60038000000000
+2941:000000000200010003800D601210101020082008101010100C60038000000000
+2942:000000000000000800047FFE00040008100020007E0020001000000000000000
+2943:000000000000100020007FFE2000100000080004007E00040008000000000000
+2944:00000000000000080004007E00040008100020007FFE20001000000000000000
+2945:0000000000000000000000080004FFFE00040008080008003E00080008000000
+2946:0000000000000000000020004000FFFF400020000020002000F8002000200000
+2947:0000000000000000001011080A04FFFE0A041108001000000000000000000000
+2948:0000000000000000101023884444FFFE44442388101000000000000000000000
+2949:00001038543854101010384444380000
+294A:00000000000000000000100020007FFE00040008000000000000000000000000
+294B:00000000000000000000000800047FFE20001000000000000000000000000000
+294C:00001018141010101010105030100000
+294D:00001030501010101010101418100000
+294E:00000000000000000000100820047FFE00000000000000000000000000000000
+294F:00002030282020202020202830200000
+2950:00000000000000000000000000007FFE20041008000000000000000000000000
+2951:00000818280808080808082818080000
+2952:00000000000000000000480050007FFF40004000000000000000000000000000
+2953:000000000000000000000012000AFFFE00020002000000000000000000000000
+2954:00003E080C0A08080808080808080808
+2955:000008080808080808080A0C083E0000
+2956:00000000000000000000400040007FFF50004800000000000000000000000000
+2957:0000000000000000000000020002FFFE000A0012000000000000000000000000
+2958:00003E08182808080808080808080808
+2959:000008080808080808082818083E0000
+295A:00000000000000000000080210023FFE00020002000000000000000000000000
+295B:00000000000000000000401040087FFC40004000000000000000000000000000
+295C:000010181410101010101010107C0000
+295D:00007C10101010101010101418100000
+295E:00000000000000000000000200023FFE10020802000000000000000000000000
+295F:00000000000000000000400040007FFC40084010000000000000000000000000
+2960:000010305010101010101010107C0000
+2961:00007C10101010101010105030100000
+2962:000000000000100020007FFE0000000000007FFE200010000000000000000000
+2963:00000000022006300A2802200220022002200220022002200220022000000000
+2964:000000000000000800047FFE0000000000007FFE000400080000000000000000
+2965:000000000220022002200220022002200220022002200A280630022000000000
+2966:000000000000100020007FFE0000000800047FFE000000000000000000000000
+2967:000000000000000000007FFE2000100000007FFE000400080000000000000000
+2968:000000000000000800047FFE0000100020007FFE000000000000000000000000
+2969:000000000000000000007FFE0004000800007FFE200010000000000000000000
+296A:0000000000000000100020007FFE00007FFE0000000000000000000000000000
+296B:0000000000000000000000007FFE00007FFE2000100000000000000000000000
+296C:0000000000000000000800047FFE00007FFE0000000000000000000000000000
+296D:0000000000000000000000007FFE00007FFE0004000800000000000000000000
+296E:00000000022006200A2002200220022002200220022002280230022000000000
+296F:000000000220023002280220022002200220022002200A200620022000000000
+2970:000000000000000000007FFC000200027FFC0000000000000000000000000000
+2971:0000000000001F8000001F880004FFFE00040008000000000000000000000000
+2972:0000000000003800444003880004FFFE00040008000000000000000000000000
+2973:00000000000000000000100020007FFF200011C00222001C0000000000000000
+2974:0000000000000000000000080004FFFE00043808444003800000000000000000
+2975:0000000000000000000000080004FFFE38044448038038004440038000000000
+2976:0000000000180060018006000800060001800060021804000FF8040002000000
+2977:00000000000000060018106021807FF021801060001800060000000000000000
+2978:000000000C00030000C000300008003000C003000C2000100FF8001000200000
+2979:0000000003F80400080008000800040003F80000002000100FF8001000200000
+297A:00000000000000000000000001FE120024007FFE2400120001FE000000000000
+297B:000000000FE0001000080008000800100FE00000020004000FF8040002000000
+297C:0000000000204040201F204040200000
+297D:0000000000020101027C020101020000
+297E:000000000000000000000C601290010001000100010001000100000000000000
+297F:00000000000000000000000001000100010001000100010012900C6000000000
+2980:0000002A2A2A2A2A2A2A2A2A2A2A2A00
+2981:000000000000183C7E7E3C1800000000
+2982:00000000182424180000182424180000
+2983:00001E24241414244424141424241E00
+2984:00007824242828242224282824247800
+2985:0000000C181828282828282818180C00
+2986:00000030181814141414141418183000
+2987:0000000C141424242424242414140C00
+2988:00000030282824242424242428283000
+2989:000000040C0C1414242414140C0C0400
+298A:00000020303028282424282830302000
+298B:0000000E0808080808080808080E000E
+298C:00000070101010101010101010700070
+298D:0000001E181412101010101010101E00
+298E:00000078080808080808084828187800
+298F:0000001E101010101010101214181E00
+2990:00000078182848080808080808087800
+2991:00000004080810102626101008080400
+2992:00000020101008086464080810102000
+2993:0000000000000040008C00F0018003000D0011000D000300018000F0008C0040
+2994:00000000000001001880078000C00060005800440058006000C0078018800100
+2995:00000000000000A019400740038002E0029802840298026001C0074018A00000
+2996:0000000000000280014C017000E003A00CA010A00CA0032001C00170028C0000
+2997:0000000C183838383838383838180C00
+2998:00000030181C1C1C1C1C1C1C1C183000
+2999:00000000080000080000080000080000
+299A:00201008102010081020100810201008
+299B:000000000000000040281028247E2000
+299C:000000000000004040404070507E0000
+299D:000000000000404040784454447F0000
+299E:0000000000000000001000200040009C012002180404083810003FFE00000000
+299F:000000000000000000000618207E0000
+29A0:00000000000000503028262830500000
+29A1:0000000000000000413E631408080000
+29A2:00000000000000007E20100804020000
+29A3:000000000000000040201008047E0000
+29A4:000000000000000002040810207E007E
+29A5:000000000000000040201008047E007E
+29A6:000000000000000000000040201E0000
+29A7:00000000000000000000001E20400000
+29A8:00000000000000780018012800C800C0012002200410081010103FFE00100000
+29A9:0000000000000F000C000A4009800180024002200410040804043FFE04000000
+29AA:00000000000000103FFE1010081004100220012000C000C80128001800780000
+29AB:00000000000004003FFE04040408041002200240018009800A400C000F000000
+29AC:00000000000010001000103C3E0C119410641060109011001200140018001000
+29AD:000000000000000800083C08307C298826080608090800880048002800180008
+29AE:0000000000001000180014001200110010901060106411943E0C103C10001000
+29AF:000000000000000800180028004800880908060826082988307C3C0800080008
+29B0:0000000000000000000017C0082014101210111010901050082007D000000000
+29B1:00000000000007C0000007D0082010501090111012101410082017C000000000
+29B2:0000010002800100000007D0082010501090111012101410082017C000000000
+29B3:010000800FC00080010007D0082010501090111012101410082017C000000000
+29B4:020004000FC00400020007D0082010501090111012101410082017C000000000
+29B5:0000000000000000000007C00820101010103FF810101010082007C000000000
+29B6:0000000000000000000007C0092011101110111011101110092007C000000000
+29B7:0000000000000000000007C0082012901290129012901290082007C000000000
+29B8:0000000000000000000007C0082014101210111010901050082007C000000000
+29B9:0000000000000000000007C00820111011101110111017D0082007C000000000
+29BA:0000000000000000000007C00920111011101FF010101010082007C000000000
+29BB:0000000000000000000017D0082014501290111012901450082017D000000000
+29BC:00000000000003E004100808122410441084110412240808041003E000000000
+29BD:0000010003800540010007C0092011101110111011101110092007C001000000
+29BE:00000000000003E0041009C81224141414141414122409C8041003E000000000
+29BF:00000000000003E0041009C813E417F417F417F413E409C8041003E000000000
+29C0:00000000000003E00410080810C413041404130410C40808041003E000000000
+29C1:00000000000003E004100808118410641014106411840808041003E000000000
+29C2:000000000000000000001F0020804040404840544048404020801F0000000000
+29C3:000000000000000000000F8010402020203C2020203C202010400F8000000000
+29C4:0000000000001FFC100C101410241044108411041204140418041FFC00000000
+29C5:0000000000001FFC18041404120411041084104410241014100C1FFC00000000
+29C6:0000000000001FFC10041084149412A411C412A41494108410041FFC00000000
+29C7:0000000000001FFC1004100411C412241224122411C4100410041FFC00000000
+29C8:0000000000001FFC1004100413E412241224122413E4100410041FFC00000000
+29C9:000000003FC020402040204023FC224422443FC402040204020403FC00000000
+29CA:000001000000010002800280044004400820082010101010200820087FFC0000
+29CB:00000000010002800280044004400820082010101010200820087FFC00007FFC
+29CC:0000008001400140022002200410041009C80A0811841044238220027FFF0000
+29CD:0000000001000280028004400440082008201010101020082008FFFE00000000
+29CE:1800160011801060101010601180163018D003100C1010100C10031000D00030
+29CF:00000000000000000000006801A80628182820281828062801A8006800000000
+29D0:000000000000000000002C002B0028C028302808283028C02B002C0000000000
+29D1:00000000000041637579756341000000
+29D2:0000000000004163574F576341000000
+29D3:0000000000004163777F776341000000
+29D4:00000000000041627478746241000000
+29D5:0000000000004123170F172341000000
+29D6:00000000000000FE4428102844FE0000
+29D7:00000000000000FE7C3810387CFE0000
+29D8:00002010081020100810201008102000
+29D9:00000810201008102010081020100800
+29DA:0000000004400220011002200440022001100220044002200110022004400000
+29DB:0000000001100220044002200110022004400220011002200440022001100000
+29DC:00000000000000304949360000000000
+29DD:00000000001C22364949360000000000
+29DE:000000000000082A5D5D2A0800000000
+29DF:0000000000000000000000000000300C48124FF24812300C0000000000000000
+29E0:000000003FF83FFC3004300430043004300430043004300430043FFC00000000
+29E1:0000000000000000061A627E007E0000
+29E2:00000000000000000000000000000000210821082108210821083FF800000000
+29E3:00000000000000120024004800907FFE02407FFE090012002400480000000000
+29E4:00000000064009920024004800907FFE02407FFE090012002400480000000000
+29E5:00000000000000000012002400487FFE01207FFE04807FFE1200240048000000
+29E6:0000000000000000400240027FFE400240027FFE400240020000000000000000
+29E7:0000000000000000010001001FF0010001001FF0010001000000000000000000
+29E8:0000000000007FFC3F083F081F101F100F200F20074007400380038001000000
+29E9:0000000000007FFC21F821F811F011F009E009E005C005C00380038001000000
+29EA:0000000000000100038007C00FE01FF00FE007C0038001000540038001000000
+29EB:00001038387C7CFE7C7C383810000000
+29EC:000000000000000001C00220041004100410022001C0008002A001C000800000
+29ED:000000000000000001C003E007F007F007F003E001C0008002A001C000800000
+29EE:0000007C10FE8282828282FE107C0000
+29EF:0000007C10FEFEFEFEFEFEFE107C0000
+29F0:0000007C1010284482442810107C0000
+29F1:0000007C1010387CFE7C3810107C0000
+29F2:0000007C1038448282824438107C0000
+29F3:0000007C10387CFEFEFE7C38107C0000
+29F4:00000000000000000000400800041FFE00044008000000000000000000000000
+29F5:00000000404020201010080804040000
+29F6:00007800040408081010202040400000
+29F7:000000404020207C1008080404000000
+29F8:01010202040408081010202040400000
+29F9:80804040202010100808040402020000
+29FA:00000000002828FE2828000000000000
+29FB:00000000005454FE5454000000000000
+29FC:00000202041860806018040202000000
+29FD:0000808040300C020C30408080000000
+29FE:00000000000007C007C00380610C793C7FFC793C610C0380038007C007C00000
+29FF:00000000000000000000600C783C7FFC783C600C000000000000000000000000
+2A00:00000000000003E004100808100410041084100410040808041003E000000000
+2A01:00000000000003E004900888108410841FFC108410840888049003E000000000
+2A02:00000000000003E004100C18122411441084114412240C18041003E000000000
+2A03:0000000000001020102010201020102013201320102010200840078000000000
+2A04:00000000000010101010101010101110111017D011101110082007C000000000
+2A05:0000000000001FF0101010101010101010101010101010101010101000000000
+2A06:00000000000010101010101010101010101010101010101010101FF000000000
+2A07:000000000000024005A005A00990099012481248242424244812481200000000
+2A08:0000000000004812481224242424124812480990099005A005A0024000000000
+2A09:0000000000002008101008200440028001000280044008201010200800000000
+2A0A:00000000000000001FF010100B0004800A400A4004800B0010101FF000000000
+2A0B:00060A087E4A28180818284A7E082830
+2A0C:0000092416DA12481248124812481248124812481248124812485B6824900000
+2A0D:00060A08080808083E08080808283000
+2A0E:00060A080808083E083E080808283000
+2A0F:00060A0808080A0C0818280808283000
+2A10:00060A0808081C2A281C080808283000
+2A11:00060A08080808082F2B1D0808283000
+2A12:00060A0808080E020A020E0808283000
+2A13:00060A0808080C020A020C0808283000
+2A14:000C141010101E1105111E1010506000
+2A15:00060A0808081C222A221C0808283000
+2A16:00060A0808083E2A2A2A3E0808283000
+2A17:00060A08082848FE492A080808283000
+2A18:00060A0808492A1C081C2A4908283000
+2A19:00060A0808081C2A2A2A2A0808283000
+2A1A:00060A0808082A2A2A2A1C0808283000
+2A1B:00060A0808080808080808082830003E
+2A1C:3E00060A080808080808080808283000
+2A1D:0000000000000000100818181428124811881188124814281818100800000000
+2A1E:0000000002060A122222120A06020000
+2A1F:000000000018242418001824241C0418
+2A20:0000000000001100088004400220011000880110022004400880110000000000
+2A21:20302824202020202020202020200000
+2A22:0000081408000808087F080808000000
+2A23:0000081422000808087F080808000000
+2A24:000000324C000808087F080808000000
+2A25:0000000000000808087F080808000800
+2A26:0000000000000808087F08080800324C
+2A27:000000000000101010FE101611020407
+2A28:0000000000000808087F081C3E080000
+2A29:0000000018080810007E000000000000
+2A2A:0000000000000000007E000800000000
+2A2B:0000000000000040007E000200000000
+2A2C:0000000000000002007E004000000000
+2A2D:00000000000000000180060008800880108017F0108008800880060001800000
+2A2E:0000000000000000018000600110011001080FE8010801100110006001800000
+2A2F:00000000000000221408142200000000
+2A30:00000000181800422418244200000000
+2A31:000000000000004224182442007E0000
+2A32:0000000000000042241824427E000000
+2A33:0000000000000000000002200140088805500220055008880140022000000000
+2A34:00000000000000000180060008000A10112010C011200A100800060001800000
+2A35:0000000000000000018000600010085004880308048808500010006001800000
+2A36:000001800240000003C00C3010081428224421842244142810080C3003C00000
+2A37:000007E0181823C44C32500A9429A245A185A2459429500A4C3223C4181807E0
+2A38:0000000000000000000003E00410088808080BE808080888041003E000000000
+2A39:00000100028002800440044008200920111017D02108210840047FFC00000000
+2A3A:00000100028002800440044008200820101017D02008200840047FFC00000000
+2A3B:00000100028002800440044008200C60129011102288244840047FFC00000000
+2A3C:000000000000000002027E0000000000
+2A3D:000000000000000040407E0000000000
+2A3E:000000000008141408000814140C0418
+2A3F:000000002222222222222222227F0000
+2A40:0000000000003C42425A5A4242420000
+2A41:0000000000004141415D4141413E0000
+2A42:000000007E00424242424242423C0000
+2A43:000000007E003C424242424242420000
+2A44:0000000000003E414141414955550000
+2A45:000000000000555549414141413E0000
+2A46:00000000002424241800182424240000
+2A47:00000000001824242400242424180000
+2A48:00000024242418003C00182424240000
+2A49:00000018242424003C00242424180000
+2A4A:000000000000000000009292926C0000
+2A4B:000000000000000000006C9292920000
+2A4C:0000000000FF424242424242423C0000
+2A4D:0000000000003C424242424242FF0000
+2A4E:0000000000001FF0101017D01450145014501450145014501450145000000000
+2A4F:0000000000001450145014501450145014501450145017D010101FF000000000
+2A50:00000000000000003FFE1004100411441084155412241554108C094807F00000
+2A51:0000000000000100000001000280028004400440082008201010101000000000
+2A52:0000000000000100000010101010082008200440044002800280010000000000
+2A53:0000000000000100028002800440044008200920129012902448244800000000
+2A54:0000000000002448244812901290092008200440044002800280010000000000
+2A55:00000000000000000000024005A005A009900990124812482424242400000000
+2A56:0000000000000000000024242424124812480990099005A005A0024000000000
+2A57:0000000000000000100810101020104010801100120014001800100000000000
+2A58:00000000000000000004000C0014002400440084010402040404080400000000
+2A59:000000000000000000004004200811100AA004400AA011102008400400000000
+2A5A:0000000000000100038003800540054009200920111011102108210800000000
+2A5B:0000000000002108210811101110092009200540054003800380010000000000
+2A5C:000000000000010002800280044004403FF80820101010102008200800000000
+2A5D:000000000000200820081010101008203FF80440044002800280010000000000
+2A5E:00001FF000001FF0000001000280028004400440082008201010101000000000
+2A5F:00000000000001000280028004400440082008201010101000001FF000000000
+2A60:00000000000001000280028004400440082008201010101000001FF000001FF0
+2A61:00000000000000000000000000000000000004400280010000001FF000000000
+2A62:0000000000001FF000001FF00000101010100820082004400440028002800100
+2A63:00000000000010101010082008200440044002800280010000001FF000001FF0
+2A64:000000000000001800680188060818083FF81808060801880068001800000000
+2A65:00000000000030002C00230020C020303FF8203020C023002C00300000000000
+2A66:000000000000007F007F000800000000
+2A67:000000000008007F007F007F00000000
+2A68:00000000000000000000028002803FF802803FF802803FF80280000000000000
+2A69:00000000000000000000054005403FF805403FF805403FF80540000000000000
+2A6A:00000000000020006498000000000000
+2A6B:00000000000008006498004000000000
+2A6C:00000000000000649800FC0064980000
+2A6D:000000001000324C007E007E00000000
+2A6E:000000002A1C081C2A007F007F000000
+2A6F:00000030488400649800649800000000
+2A70:00000000649800649800FC00FC000000
+2A71:00000000007C007C0010107C10100000
+2A72:000000000010107C1010007C007C0000
+2A73:000000000000007E007E00324C000000
+2A74:00000000000000000000000000002BF8000000002BF800000000000000000000
+2A75:00000000000000000000000000007E7E0000000000007E7E0000000000000000
+2A76:00000000000000000000000000007BDE000000007BDE00000000000000000000
+2A77:00000000000024007E00007E00240000
+2A78:00000000000000000000124800003FFC00003FFC00003FFC0000000000000000
+2A79:0000000000000000003000C003000C4010A00C40030000C00030000000000000
+2A7A:000000000000000018000600018004600A100460018006001800000000000000
+2A7B:1800240008000800003008C003000C0010000C00030000C00030000000000000
+2A7C:0030004800100010180006100180006000100060018006001800000000000000
+2A7D:0000000000000000000000600180060008000600018008600600018000600000
+2A7E:000000000000000000000C00030000C0002000C003000C2000C003000C000000
+2A7F:0000000000000000000000600180060008400600018008600600018000600000
+2A80:000000000000000000000C00030000C0082000C003000C2000C003000C000000
+2A81:0000000000000000040000600180060008000600018008600600018000600000
+2A82:000000000000000000400C00030000C0002000C003000C2000C003000C000000
+2A83:0000000000000020000000600180060008000600018008600600018000600000
+2A84:000000000000080000000C00030000C0002000C003000C2000C003000C000000
+2A85:000000000000006001800600080006000180006000000000071008E0071008E0
+2A86:0000000000000C00030000C0002000C003000C00000000000E2011C00E2011C0
+2A87:00000000000000000060018006000800060001800060004000800FE002000400
+2A88:00000000000000000C00030000C0002000C003000C00004000800FE002000400
+2A89:0000006001800600080006000180006000100020075008E007100AE004000800
+2A8A:00000C00030000C0002000C003000C00002000400EA011C00E2015C008001000
+2A8B:00186080601800FC00FC006018041860
+2A8C:00601804186000FC00FC001860806018
+2A8D:000000000000006001800600080006000180006000000000071008E000000FF0
+2A8E:0000000000000C00030000C0002000C003000C00000000000E2011C000001FE0
+2A8F:00061820180600324C00601804186000
+2A90:00601804186000324C00061820180600
+2A91:000C3040300C6018041860007C007C00
+2A92:0060180418600C3040300C007C007C00
+2A93:000C3040300C40300C60180418620C30
+2A94:00300C020C30020C300618201846300C
+2A95:0000000000000000000000600180060008600180060008000600018000600000
+2A96:000000000000000000000C00030000C00C20030000C0002000C003000C000000
+2A97:0000000000000000000000600180060008600180060008400600018000600000
+2A98:000000000000000000000C00030000C00C20030000C0042000C003000C000000
+2A99:00000000000000000FE000000FE0000000600180060008000600018000600000
+2A9A:00000000000000000FE000000FE000000C00030000C0002000C003000C000000
+2A9B:0000000000600180060008600180060008600180060008000600018000600000
+2A9C:000000000C00030000C00C20030000C00C20030000C0002000C003000C000000
+2A9D:00000000000000000000071008E00000003000C003000400030000C000300000
+2A9E:0000000000000000071008E0000000000C00030000C0002000C003000C000000
+2A9F:00000000071008E00000003000C003000400030000C0003000000FF000000FF0
+2AA0:0000000008E0071000000C00030000C0002000C003000C0000000FF000000FF0
+2AA1:00000000000000000000003000C003300CC011000CC0033000C0003000000000
+2AA2:0000000000000000000018000600198006600110066019800600180000000000
+2AA3:0000000000000000018C063018C0210018C00630018C00003FFC000000000000
+2AA4:0000000000000000060C01B000E0011000E001B0060C00000000000000000000
+2AA5:0000000000000000400430180C6002800C603018400400000000000000000000
+2AA6:000000000000000000000000000000C003200C1010100C10032000C000000000
+2AA7:0000000000000000000000000000060009801060101010600980060000000000
+2AA8:0000000000000000000000C003200C1010100C10032010C00C00030000C00000
+2AA9:0000000000000000000006000980106010101060098006100060018006000000
+2AAA:00000000000000000000003000C003000C001FF00C00030000C0003000000000
+2AAB:0000000000000000000018000600018000601FF0006001800600180000000000
+2AAC:000000000000003000C003000C001FF00C00030000C0003000001FF000000000
+2AAD:00000000000018000600018000601FF0006001800600180000001FF000000000
+2AAE:000000000000000000000000038004403C7800003FF800003FF8000000000000
+2AAF:0000000000000010002000C003001C00030000C00020001000001FF000000000
+2AB0:00000000000008000400030000C0003800C003000400080000000FF800000000
+2AB1:0000000000000010002000C003001C00030000C00020005000801FF002000400
+2AB2:00000000000010000800060001800070018006000800108001001FF004000800
+2AB3:00000010002000C003001C00030000C00020001000001FF000001FF000000000
+2AB4:000010000800060001800070018006000800100000001FF000001FF000000000
+2AB5:00000010002000C003001C00030000C00020003000401FF001001FF004000800
+2AB6:000010000800060001800070018006000800104000801FF002001FF008001000
+2AB7:0010002000C003001C00030000C000200010000007900860071008E000000000
+2AB8:10000800060001800070018006000800100000000E2011C00E2011C000000000
+2AB9:0010002000C003001C00030000C0002000500040079008E0071009E002000200
+2ABA:10000800060001800070018006000800108000800F2011C00E2013C004000400
+2ABB:0000000000000042008403180C6073800C600318008400420000000000000000
+2ABC:0000000000004200210018C0063001CE063018C0210042000000000000000000
+2ABD:0000000000000000000000000FF81000200026002600200010000FF800000000
+2ABE:0000000000000000000000003FE00010000800C800C8000800103FE000000000
+2ABF:0000003E4040403E0008083E08080000
+2AC0:0000007C0202027C0010107C10100000
+2AC1:0000003E4040403E0022140814220000
+2AC2:0000007C0202027C0044281028440000
+2AC3:000000001818003E4040403E007E0000
+2AC4:000000003030007C0202027C007E0000
+2AC5:00000000003E4040403E007E007E0000
+2AC6:00000000007C0202027C007E007E0000
+2AC7:0000000000003E404040403E00324C00
+2AC8:0000000000007C020202027C00324C00
+2AC9:00000000003E4040403E00324C324C00
+2ACA:00000000007C0202027C00324C324C00
+2ACB:000000003E4040403E00047E087E1000
+2ACC:000000007C0202027C00047E087E1000
+2ACD:00000000000000007FFE400040004000400040004000400040007F0000000000
+2ACE:00000000000000007FFE0002000200020002000200020002000200FE00000000
+2ACF:00000000000000000000000007F008101010101010101010081007F000000000
+2AD0:0000000000000000000000001FC01020101010101010101010201FC000000000
+2AD1:000000000000000007F008101010101010101010081007F000001FF000000000
+2AD2:00000000000000001FC01020101010101010101010201FC000001FF000000000
+2AD3:0000003E4040403E007C0202027C0000
+2AD4:0000007C0202027C003E4040403E0000
+2AD5:0000003E4040403E003E4040403E0000
+2AD6:0000007C0202027C007C0202027C0000
+2AD7:00000000000000000000000000003E3E0140014001403E3E0000000000000000
+2AD8:00000000000000000000000000003E3E014007F001403E3E0000000000000000
+2AD9:000000000000000007C009201110111011101110111011101110111000000000
+2ADA:000000000FE0010007C009201110111011101110111011101110111000000000
+2ADB:000000000100010007C009201110111011101110111011101110111001000100
+2ADC:000000000000000001000110012001400180111013101510092017C000000000
+2ADD:000000000000000001000100010001000100111011101110092007C000000000
+2ADE:0000000000040404043C040404040000
+2ADF:000000000000000000000000000000001FF00100010001000000000000000000
+2AE0:000000000000000000000000000000000100010001001FF00000000000000000
+2AE1:000000000000010001000138014001300108017001003FF80000000000000000
+2AE2:00000000000000000000200020003FF020003FF020003FF02000200000000000
+2AE3:0000000000000000000000140014001400143FF4001400140014001400000000
+2AE4:000000000000000000000008000800081FF800081FF800080008000800000000
+2AE5:000000000000000000000014001400143FF400143FF400140014001400000000
+2AE6:0000000000000000000028002800280028003FFC280028002800280000000000
+2AE7:0000000000000000000000001FF000001FF00100010001000000000000000000
+2AE8:0000000000000000000000000100010001001FF000001FF00000000000000000
+2AE9:0000000000000100010001001FF000001FF00100010001000000000000000000
+2AEA:00000000000000001FF002800280028002800280028002800280028000000000
+2AEB:00000000000000000280028002800280028002800280028002801FF000000000
+2AEC:000000000000000000000000000000001FF800081FF800080008000000000000
+2AED:000000000000000000000000000000001FF810001FF810001000000000000000
+2AEE:000000001818583818181C1A18180000
+2AEF:00000000384444381010101010100000
+2AF0:00000000101010101010384444380000
+2AF1:000000007C1010101010384444380000
+2AF2:0000000014141414147F141414140000
+2AF3:00000000000000000240024002400240024007500AE002400240024000000000
+2AF4:0000000000000000092009200920092009200920092009200920092000000000
+2AF5:0000000000000000092009200920092009203FF8092009200920092000000000
+2AF6:00000000181800001818000018180000
+2AF7:0000000000000018006001980660199822201998066001980060001800000000
+2AF8:00000000000030000C0033000CC03330088833300CC033000C00300000000000
+2AF9:0000000000600180060008000600018008600600018008600600018000600000
+2AFA:000000000C00030000C0002000C003000C2000C003000C2000C003000C000000
+2AFB:0000000000000000024802480490049009200920124012402480248000000000
+2AFC:0000000000000000092009200920092009200920092009200920092009200000
+2AFD:0000000000000000009000900120012002400240048004800900090000000000
+2AFE:00000000003828282828282828380000
+2AFF:00000000382828282828282828283800
+2B00:00000000000001F8010800880108022804580880110022001400080000000000
+2B01:0000000000003F00210022002100288034400220011000880050002000000000
+2B02:000000000000080014002200110008800458022801080088010801F800000000
+2B03:00000000000000200050008801100220344028802100220021003F0000000000
+2B04:0000000000000000081018182FF440022FF41818081000000000000000000000
+2B05:0000000000000000080018003FFC7FFC3FFC1800080000000000000000000000
+2B06:000010387CFE38383838383838380000
+2B07:00003838383838383838FE7C38100000
+2B08:00000000000001F801F800F801F803F807D80F801F003E001C00080000000000
+2B09:0000000000003F003F003E003F003F8037C003E001F000F80070002000000000
+2B0A:00000000000008001C003E001F000F8007D803F801F800F801F801F800000000
+2B0B:0000000000000020007000F801F003E037C03F803F003E003F003F0000000000
+2B0C:0000000000000000081018183FFC7FFE3FFC1818081000000000000000000000
+2B0D:000010387CFE38383838FE7C38100000
+2B0E:0000000000000000000000000000FFF80008002A001C00080000000000000000
+2B0F:0000000000000008001C002A0008FFF800000000000000000000000000000000
+2B10:00000000000000000000000000001FFF10005400380010000000000000000000
+2B11:00000000000010003800540010001FFF00000000000000000000000000000000
+2B12:000000000000000000001FF81FF81FF81FF81FF810081008100810081FF80000
+2B13:000000000000000000001FF810081008100810081FF81FF81FF81FF81FF80000
+2B14:000000000000000000001FF81FF817F813F811F810F81078103810181FF80000
+2B15:000000000000000000001FF818081C081E081F081F881FC81FE81FF81FF80000
+2B16:000000000000000000000180034007200F101F081F080F100720034001800000
+2B17:00000000000000000000018002C004E008F010F810F808F004E002C001800000
+2B18:00000000000000000000018003C007E00FF01FF8100808100420024001800000
+2B19:00000000000000000000018002400420081010081FF80FF007E003C001800000
+2B1A:0000000000002AA80000200800002008000020080000200800002AA800000000
+2B1B:00007FFE7FFE7FFE7FFE7FFE7FFE7FFE7FFE7FFE7FFE7FFE7FFE7FFE7FFE0000
+2B1C:00007FFE4002400240024002400240024002400240024002400240027FFE0000
+2B1D:00000000000000003C3C3C3C00000000
+2B1E:00000000000000003C24243C00000000
+2B1F:000000000000018003C007E00FF01FF83FFC1FF81FF80FF00FF007E000000000
+2B20:000000000000018002400420081010082004100810080810081007E000000000
+2B21:0000000000000000010006C0183020082008200820082008183006C001000000
+2B22:0000000000000000010007C01FF03FF83FF83FF83FF83FF81FF007C001000000
+2B23:000000000000000007E00FF01FF83FFC7FFE7FFE3FFC1FF80FF007E000000000
+2B24:0000000001C007F00FF81FFC1FFC3FFE3FFE3FFE1FFC1FFC0FF807F001C00000
+2B25:0000000000000010387CFE7C38100000
+2B26:00000000000000102844824428100000
+2B27:0000001038387C7CFE7C7C3838100000
+2B28:00000010282844448244442828100000
+2B29:00000000000010387C38100000000000
+2B2A:000000000000001038387C3838100000
+2B2B:00000000000000102828442828100000
+2B2C:000000000000000000000000000000000FE07FFCFFFEFFFE7FFC0FE000000000
+2B2D:000000000000000000000000000000000FE0701C80028002701C0FE000000000
+2B2E:00183C3C3C7E7E7E7E7E3C3C3C180000
+2B2F:00182424244242424242242424180000
+2B30:0000000000000000000010E021107FFF211010E0000000000000000000000000
+2B31:2040FF40202040FF40202040FF402000
+2B32:000000000000000001C012A024907FFF249012A001C000000000000000000000
+2B33:00000000000000000000100024447AAB21101000000000000000000000000000
+2B34:00000000000000000000142028207FFF28201420000000000000000000000000
+2B35:00000000000000000000145028507FFF28501450000000000000000000000000
+2B36:00000000000000000000140228027FFE28021402000000000000000000000000
+2B37:00000000000000000000140228047ED828041402000000000000000000000000
+2B38:0000000000000000000010002000755520001000000000000000000000000000
+2B39:00000000000000000000104220447FF820441042000000000000000000000000
+2B3A:0000000000000000000010A220A47FF820A410A2000000000000000000000000
+2B3B:00000000000000000000140228047FF828041402000000000000000000000000
+2B3C:00000000000000000000144228447FF828441442000000000000000000000000
+2B3D:0000000000000000000014A228A47FF828A414A2000000000000000000000000
+2B3E:00000000000000000800108820507FFF20501088080000000000000000000000
+2B3F:00000000000000000000103C20427F8120001000000000000000000000000000
+2B40:00000000000001F8000011F820007FFF20001000000000000000000000000000
+2B41:000000000000001C022211C020007FFF20001000000000000000000000000000
+2B42:00000000000000000000100020007FFF201C122201C0001C022201C000000000
+2B43:00000000000060001800060801840FFE01840608180060000000000000000000
+2B44:000000000000000000007F80004800247FFE002400487F800000000000000000
+2B45:00000000020004000FFF10003FFF40003FFF10000FFF04000200000000000000
+2B46:0000000000400020FFF00008FFFC0002FFFC0008FFF000200040000000000000
+2B47:0000000000000380444038080004FFFE00040008000000000000000000000000
+2B48:0000000000000000000000080004FFFE03844448380003804440380000000000
+2B49:00000000000001C00222101C20007FFF20001000000000000000000000000000
+2B4A:00000000000000000000100020007FFF21C01222001C01C00222001C00000000
+2B4B:00000000000000000000100020007FFF2000101C022201C00000000000000000
+2B4C:0000000000000000000000080004FFFE00040388444038000000000000000000
+2B4D:00000000008001000200040008001FF800100020004002800300038000000000
+2B4E:000000000000001C0C14102020000000
+2B4F:00000000000000202010140C1C000000
+2B50:000001000100028002807C7C20081010082004400820111026C8383800000000
+2B51:0000000000000100038003803FF81FF00FE00FE01EF03C783018000000000000
+2B52:0000000000000100028002803C7810100820092012902C683018000000000000
+2B53:00000000008003C00FE01FF01FF81FFC1FFC1FF81FF00FE003C0008000000000
+2B54:00000000008003400C201010100810041004100810100C200340008000000000
+2B55:000007C00FE018303018600C600C600C600C600C301818300FE007C000000000
+2B56:0000000000000FE01FF0301867CC682C682C67CC30181FF00FE0000000000000
+2B57:000007C00FE018303018638C644C644C644C638C301818300FE007C000000000
+2B58:000000000000000003800FE00C601830183018300C600FE00380000000000000
+2B59:000007C00FE018303838644C628C610C628C644C383818300FE007C000000000
+2B5A:00000000000003C0042004200840095008E01040100010002000200000000000
+2B5B:0000000000000F00108010800840084000200020001000540038001000000000
+2B5C:0000000000000020007000A800200040004000400040008000800F8000000000
+2B5D:0000000000000F80008000800040004000400040002000A80070002000000000
+2B5E:0000000000000100010001000100020002000220021004780590062000000000
+2B5F:0000000000000000000000000000020002000220041004780590062000000000
+2B60:00000000000000000000100030007FFE30001000000000000000000000000000
+2B61:000000000100038007C001000100010001000100010001000100010001000100
+2B62:000000000000000000000008000C7FFE000C0008000000000000000000000000
+2B63:000000000100010001000100010001000100010001000100010007C003800100
+2B64:000000000000000000002008600CFFFE600C2008000000000000000000000000
+2B65:000000000100038007C00100010001000100010001000100010007C003800100
+2B66:00000000000000001E001C001C00120001000080004000200010000800000000
+2B67:0000000000000000007800380038004800800100020004000800100000000000
+2B68:0000000000000000100008000400020001000080004800380038007800000000
+2B69:000000000000000000080010002000400080010012001C001C001E0000000000
+2B6A:00000000000000000000100030007DB630001000000000000000000000000000
+2B6B:000000000100038007C001000100000001000100000001000100000001000100
+2B6C:000000000000000000000008000C6DBE000C0008000000000000000000000000
+2B6D:000000000100010000000100010000000100010000000100010007C003800100
+2B6E:00000000000000001C000C101408200420042004200420041008081007E00000
+2B6F:0000000000000000003808301028200420042004200420041008081007E00000
+2B70:0000000000000000000044004C005FFE4C004400000000000000000000000000
+2B71:0000000007C000000100038007C0010001000100010001000100010001000100
+2B72:00000000000000000000002200327FFA00320022000000000000000000000000
+2B73:0000000001000100010001000100010001000100010007C003800100000007C0
+2B74:00007FFE618E7DB6618E6FB6618E7FFE7FFE61B67DB67B8677F677F67FFE0000
+2B75:00007FFE618E7DB6618E6FB6618E7FFE7FFE61867DBE7B8677F677867FFE0000
+2B76:00000000000000000FC000000780070007000480004000200010000800000000
+2B77:000000000000000001F8000000F0007000700090010002000400080000000000
+2B78:0000000000000000080004000200010000900070007000F0000001F800000000
+2B79:00000000000000000008001000200040048007000700078000000FC000000000
+2B7A:00000000000000000140114031407FFE31401140014000000000000000000000
+2B7B:000000000100038007C001000100010001000FE001000FE00100010001000100
+2B7C:000000000000000002800288028C7FFE028C0288028000000000000000000000
+2B7D:0000000001000100010001000FE001000FE0010001000100010007C003800100
+2B7E:000000000000000044004C005FFE4C004400002200327FFA0032002200000000
+2B7F:0000000004F804000420047004F804200420042004201F200E20042000201F20
+2B80:000000000000100030007FFE300010000008000C7FFE000C0008000000000000
+2B81:0000000004200E201F200420042004200420042004200420042004F804700420
+2B82:0000000000000008000C7FFE000C0008100030007FFE30001000000000000000
+2B83:000000000420047004F8042004200420042004200420042004201F200E200420
+2B84:00000000100030007FFE300010000000100030007FFE30001000000000000000
+2B85:0000000008201C703EF808200820082008200820082008200820082008200820
+2B86:000000000008000C7FFE000C000800000008000C7FFE000C0008000000000000
+2B87:00000000082008200820082008200820082008200820082008203EF81C700820
+2B88:000003E007F00EF81CFC38FC30002000300038FC1CFC0EF807F003E000000000
+2B89:0000000003E007700E381C1C380E30063E3E3E3E3E3E1E3C0E38063000000000
+2B8A:000007C00FE01F703F383F1C000C0004000C3F1C3F381F700FE007C000000000
+2B8B:0000000006300E381E3C3E3E3E3E3E3E3006380E1C1C0E38077003E000000000
+2B8C:00000000080018003FF0180808040002000200020002000400080FF000000000
+2B8D:0000000000000008001C103E1008100810081008100810080810042003C00000
+2B8E:0000000007F80800100020002000200020001008080C07FE000C000800000000
+2B8F:00000000000000F0010802040402040204020402040204021F020E0004000000
+2B90:00000000000000000000001E00020004100430087FF830001000000000000000
+2B91:000000000000000000007800400020002008100C1FFE000C0008000000000000
+2B92:000000000000000000007F7E00020002020206026FFE06000200000000000000
+2B93:000000000000000000007EFE40004000404040607FF600600040000000000000
+2B94:00000000002000403EFC20442024A8007004200E0015240422043F7C02000400
+2B95:0000000000000000002000307FF87FFC7FF80030002000000000000000000000
+2B96:00007FFE618E7DB6618E6FB6618E7FFE7FFE73CE6DBE718E7DB673CE7FFE0000
+2B97:000000007FFC40044FE420082FE8111011100920092005400440028001000000
+2B98:00000004003800C803100C10302040403FE00FF003F000F80038000400000000
+2B99:00000000010002800280064006400E200E201E101F103E883C68301840040000
+2B9A:000040003800260011801060081804040FF81FE01F803E003800400000000000
+2B9B:00000000400430182C7822F811F010F008E008E004C004C00280028001000000
+2B9C:00000004003800F803F00FF03FE07FC03FE00FF003F000F80038000400000000
+2B9D:0000000001000380038007C007C00FE00FE01FF01FF03EF83C78301840040000
+2B9E:0000400038003E001F801FE00FF807FC0FF81FE01F803E003800400000000000
+2B9F:00000000400430183C783EF81FF01FF00FE00FE007C007C00380038001000000
+2BA0:00000002000200020002100230027FFE30001000000000000000000000000000
+2BA1:000040004000400040004008400C7FFE000C0008000000000000000000000000
+2BA2:00000000000000000000100030007FFE30021002000200020002000200000000
+2BA3:000000000000000000000008000C7FFE400C4008400040004000400000000000
+2BA4:0000000004000E001F0004000400040004000400040004000400040007F00000
+2BA5:00000000004000E001F00040004000400040004000400040004000401FC00000
+2BA6:0000000007F00400040004000400040004000400040004001F000E0004000000
+2BA7:000000001FC000400040004000400040004000400040004001F000E000400000
+2BA8:0000000000000002100230067FFCFFFC7FF83000100000000000000000000000
+2BA9:00000000000080008010C0187FFC7FFE3FFC0018001000000000000000000000
+2BAA:0000000000000000100030007FF8FFFC7FFC3006100200020000000000000000
+2BAB:0000000000000000001000183FFC7FFE7FFCC018801080000000000000000000
+2BAC:000000000000020007000F801FC0070007000700070007000700038000E00000
+2BAD:0000000000000100038007C00FE003800380038003800380038007001C000000
+2BAE:00000000000000E003800700070007000700070007001FC00F80070002000000
+2BAF:0000000000001C0007000380038003800380038003800FE007C0038001000000
+2BB0:000000220036002A0022002204220A2213FC20044008201013E00A0004000000
+2BB1:000044006C00540044004400442044503FC820041002080407C8005000200000
+2BB2:000004000A0013E020104008200413FC0A22042200220022002A003600220000
+2BB3:00000020005007C80804100220043FC8445044204400440054006C0044000000
+2BB4:000004000A00110020804040318011001100110011FE09040508030400FE0000
+2BB5:000000200050008801040202018C0088008800887F88209010A020C07F000000
+2BB6:000000FE03040508090411FE11001100110031804040208011000A0004000000
+2BB7:00007F0020C010A020907F88008800880088018C020201040088005000200000
+2BB8:00000100028004400FE010100C600440044007C0000007C0044007C000000000
+2BB9:0000000000007FFC4004410442844444482450144004400440047FFC00000000
+2BBA:0000000003FC0204020402043FC42244224423FC2040204020403FC000000000
+2BBB:0000000003FC03FC03FC03FC3FFC23FC23FC23FC2040204020403FC000000000
+2BBC:0000000003FC03FC03FC03FC3FFC3FFC3FFC3FFC3FC03FC03FC03FC000000000
+2BBD:000000003FFC20042004241422242144208421442224241420043FFC00000000
+2BBE:0000000007C00820101020082448428441044284244820081010082007C00000
+2BBF:0000000007C01FF038383018644C628C610C628C644C301838381FF007C00000
+2BC0:0000000000007FFC7FFC7FFC7FFC7FFC7FFC7FFC7FFC7FFC7FFC7FFC00000000
+2BC1:0000000000000100038007C00FE01FF03FF81FF00FE007C00380010000000000
+2BC2:00000000000007E00FF00FF01FF81FF83FFC3FFC1FF80FF007E003C001800000
+2BC3:0000000007C00FE01FF03FF87FFC7FFC7FFC7FFC7FFC3FF81FF00FE007C00000
+2BC4:0000038007C03FF83FF83FF87FFCFFFEFFFEFFFE7FFC3FF83FF83FF807C00380
+2BC5:0000000001000380038007C007C00FE00FE01FF01FF03FF83FF87FFC00000000
+2BC6:0000000000007FFC3FF83FF81FF01FF00FE00FE007C007C00380038001000000
+2BC7:00000008003800F803F80FF83FF87FF83FF80FF803F800F80038000800000000
+2BC8:0000400070007C007F007FC07FF07FF87FF07FC07F007C007000400000000000
+2BC9:0000404A4C58787E081C2222221C0000
+2BCA:0000000007C00FE01FF03FF83FF87FFC7FFC0000000000000000000000000000
+2BCB:000000000000000000000000000000007FFC7FFC3FF83FF81FF00FE007C00000
+2BCC:010001000380038007C00FE03FF8FFFE3FF80FE007C003800380010001000000
+2BCD:000000000000200810100C600FE007C007C007C00FE00C601010200800000000
+2BCE:0100010003800280044008203018E00E30180820044002800380010001000000
+2BCF:000000000000200810100C600BA00440044004400BA00C601010200800000000
+2BD0:00000000010001001FF01110111010107C7C1010111011101FF0010001000000
+2BD1:000000000100028004400BA01450204841842108101009200440028001000000
+2BD2:000000000000010001000FE0010001000FE0010001000FE00100010001000000
+2BD3:00000000000000000380044008202828282824481390082007C0010007C00100
+2BD4:000000001C702288210807C00100038004400820082008200440038000000000
+2BD5:00000000038004400820082008204444638C50144C6423881010082007C00000
+2BD6:00000000000007C008A0105020482028202820282048105008A007C000000000
+2BD7:0000000000000100038007C00100038004400BA0082008200440038000000000
+2BD8:00000000000000003C3C04200420042005A005A00420042004203C3C00000000
+2BD9:00000000000001800240027801C00040008000800100018002401E4001800000
+2BDA:000000001110210821082108193007C009201110092007C0092007C000000000
+2BDB:000000000000000001C00120012001C00100010007C00820082007C000000000
+2BDC:0000000000000000012001A0016001200100010007C00820082007C000000000
+2BDD:000000000000070002800140012000A000A00120014002800700010007C00100
+2BDE:0000000000000100038007C00FE01FF00FE007C003800100010007C001000100
+2BDF:0000000000000000000000000000200830182C681390082007C0010007C00100
+2BE0:000000000000380004000270028802880288047008203FF8002000F800200020
+2BE1:00000000000007C0082010102100210027C0210021001110092007C001000100
+2BE2:0000000000000100038007C0010001000100193007C0010006C0183000000000
+2BE3:00000000000007C0082010102108210827C80100010001000100010001000100
+2BE4:000000000000380004000200020002500250045008503FF80050005000500050
+2BE5:0000000000000000044004400380054007C00540038001000100010001000100
+2BE6:0000000000000100038007C00100010001000100010002800440082010103FF8
+2BE7:0000000000000000200820081110092007C00100010007C00920111020082008
+2BE8:00000040004000C000C001C01FC00FC007C003C001C003C00780060008000000
+2BE9:00000400040006000600070007F007E007C007800700078003C000C000200000
+2BEA:0000010001000380038007407F3C3F081F100F6007400F201ED0183020080000
+2BEB:0000010001000380038005C079FC21F811F00DE005C009E016F0183020080000
+2BEC:00000000020806180E381E783EF87FFE3EF81E780E3806180208000000000000
+2BED:00000100038007C00FE01FF03FF80100038007C00FE01FF03FF8010001000000
+2BEE:00000000104018601C701E781F7C7FFE1F7C1E781C7018601040000000000000
+2BEF:0000008000801FFC0FF807F003E001C000801FFC0FF807F003E001C000800000
+2BF0:0000000000003938054003800380010001000100038003800540393800000000
+2BF1:0000000000000380044008200820082004400380010007C00380010000000000
+2BF2:00000000000000001900250025001FC001000180004000200020002000000000
+2BF3:00000000000000003FF8200820082008200820083FF8010006C0183000000000
+2BF4:00000000000000007FFC410422881450082008201450228841047FFC00000000
+2BF5:0000000000000000410441042288145008200820145022884104410400000000
+2BF6:00000000000000003FF8200820082008200820083FF8010001001FF000000000
+2BF7:00000000000000001010082004400280010002800440082010103FF800000000
+2BF8:000000000000000001000100010001003FF80380054009201110210800000000
+2BF9:000000000000000000003FF800003FF800001C702288210822881C7000000000
+2BFA:00000000000000000000000000001C702288228822881C700000000000000000
+2BFB:0000000000000000000000000000701C88228AA28822701C0000000000000000
+2BFC:0000000000000380044004400440038000000380044004400440038000000000
+2BFD:0000000000000100038007C00100010001000380044004400440038000000000
+2BFE:00000000000000000000000000000020002000200020002000200FE000000000
+2BFF:000000007C7C10101C1C10107C7C0000
+2C00:00000000101010107C54541010100000
+2C01:0000000092929292FE80808080FE0000
+2C02:0000000044AA6C284444444444380000
+2C03:000000006090907020204C52928C0000
+2C04:00000000384444444444286CAA440000
+2C05:000000003844041C041C040444380000
+2C06:000000000000824428286C92926C0000
+2C07:000000003844824438FE926428100000
+2C08:000000000020508888FF8D8D55220000
+2C09:000000007C6C92927C10101010380000
+2C0A:000000007C6C92926C28444482FE0000
+2C0B:00000000FE8244285482828244380000
+2C0C:00000000626565669696969991000000
+2C0D:000000002020203C04043C2020200000
+2C0E:0000000038444444447CAAAAAA440000
+2C0F:00000000000000000FF812A412A40C98008003E0077009480948063000000000
+2C10:000000003C222222FCA0A02020200000
+2C11:000000001C221E020202021E221C0000
+2C12:000000003E2A2A2AE420202020200000
+2C13:00000000404040407C424242427C0000
+2C14:00000000384482828254284482FE0000
+2C15:00000000FEAAAAAAAAAAAAAAAA440000
+2C16:0000000048B46C242724246CB4480000
+2C17:00000000101038549292929254381010
+2C18:000000002020202020202C32528C0000
+2C19:000000007CAAAA92828292AAAA7C0000
+2C1A:000000001E1212127292929292720000
+2C1B:0000000092929292FE44828244380000
+2C1C:000000007191916A0A0A0A0404040000
+2C1D:0000000044447C92FE44828244380000
+2C1E:00000000929292929292929292FE0000
+2C1F:000000000000000003F8011000A000E01F10151008E000A0011003F800000000
+2C20:000000007E422418F898A424427E0000
+2C21:0000000010282844447C929292FE0000
+2C22:00002090786C4482828282446C3C1208
+2C23:000000007C4A4A4A4C50506060400000
+2C24:000000001C222060B8602020221C0000
+2C25:000000000C121030DCB01010120C0000
+2C26:0000000010284C92FE444444447C0000
+2C27:00000000000000001C38224402400EC003700EC00240024022441C3800000000
+2C28:0000000000000000387044883C80058006E0058004803C804488387000000000
+2C29:0000000000000000103828444C4092C0FF7038C0444082404444383800000000
+2C2A:0000000018242424FFA5242424180000
+2C2B:00000000F88850708E8A705088F80000
+2C2C:000000001C0404040404040408100000
+2C2D:0000000082C2B28AFE8AB2C282020000
+2C2E:00000000245456525252565A52520000
+2C2F:00007FFE61C67DBE61BE6FBE61C67FFE7FFE61867DBE618E6FBE61BE7FFE0000
+2C30:0000000000001010107C545410100000
+2C31:0000000000002A2A2A3E2020203E0000
+2C32:00000000000044AA6C28444444380000
+2C33:000000000000609090702C52928C0000
+2C34:00000000000038444444286CAA440000
+2C35:00000000000038441C041C0444380000
+2C36:0000000000000000C6286C92926C0000
+2C37:0000000000001C221C7F493214080000
+2C38:00000000000000205088FF8D55220000
+2C39:0000000000007C6C92927C1010380000
+2C3A:0000000000007C6C92926C4482FE0000
+2C3B:000000000000FE824428544444380000
+2C3C:000000000000444A4AACACB2A2000000
+2C3D:00000000000020203C04043C20200000
+2C3E:000000000000182424243C5A5A240000
+2C3F:0000000000000000000000001FF025481930010007C00EE012900C6000000000
+2C40:0000000000001C12127C505010100000
+2C41:0000000000001C221E02021E221C0000
+2C42:0000000000003E2A2A2A642020200000
+2C43:00000000000040404078444444780000
+2C44:00000000000038444454284482FE0000
+2C45:000000000000FEAAAAAAAAAAAA440000
+2C46:00000000000048B46C26246CB4480000
+2C47:00000000000010103854929254381010
+2C48:000000000000202020202C32528C0000
+2C49:0000000000007CAA92828292AA7C0000
+2C4A:0000000000000E0A0A3A4A4A4A3A0000
+2C4B:0000000000002A2A2A3E1422221C0000
+2C4C:00000000000062A2A274141408080000
+2C4D:000000000000447C92FE444444380000
+2C4E:000000000000545454545454547C0000
+2C4F:00000000000000000000000003F8011000E01F10151008E0011003F800000000
+2C50:0000000000003E2214784854223E0000
+2C51:000000000000001028447C9292FE0000
+2C52:000000002090786C448282446C3C1208
+2C53:00000000000078545458505060400000
+2C54:0000000000000C12305C3010120C0000
+2C55:000000000000040A186E58080A040000
+2C56:00000000000010284C92FE44447C0000
+2C57:0000000000000000000000001C3822440EC003700EC0024022441C3800000000
+2C58:0000000000000000000000001C3822441EC0037002C01E4022441C3800000000
+2C59:000000000000000000000000081C1422266049B87F601C2022221C1C00000000
+2C5A:000000000000102828FEAA2828100000
+2C5B:0000000000007848304E4A3048780000
+2C5C:0000000000001C040404040408100000
+2C5D:0000000000000262524A7E4A52620000
+2C5E:00000000000024545652565A52520000
+2C5F:00007FFE61C67DBE61BE6FBE61C67FFE7FFE61866FBE618E7DBE61BE7FFE0000
+2C60:000000002020207020702020203E0000
+2C61:000000180808081C081C0808083E0000
+2C62:000000001010101034581010101F0000
+2C63:000000003C2272223C20202020200000
+2C64:000000007C4242427C48444442425020
+2C65:0000000000003946043C54644CB40000
+2C66:000000001010117E14181030508C0000
+2C67:00000000444444447C44444444460202
+2C68:00000040404058644444444444460202
+2C69:00000000424448506060504844430101
+2C6A:00000040404044485060504844430101
+2C6B:000000007E02020408102040407E0202
+2C6C:0000000000007E0204081020407E0202
+2C6D:000000001A26424242424242261A0000
+2C6E:00000000424266665A5A424242420A04
+2C6F:00000000424242427E42422424180000
+2C70:000000004C52624242424242625C0000
+2C71:00000000000082858548484830300000
+2C72:00000000848A8A88A8A8D8D888880000
+2C73:00000000000042555554545454280000
+2C74:0000000020505262C224242418180000
+2C75:00000000202020203C20202020200000
+2C76:0000000000002020203C202020200000
+2C77:000000000000264949494949493E0808
+2C78:0000000000003844447C4045453A0000
+2C79:000000000C02020202020242463A0000
+2C7A:0000000000003E4141414955553E0000
+2C7B:0000000000003E0202021E02023E0000
+2C7C:000000000000000004000C0404041408
+2C7D:00000041412222141408000000000000
+2C7E:000000003C424040300C0202423C0906
+2C7F:000000007E020404081020204060100E
+2C80:00000000C0201010384844444A310000
+2C81:000000000000C020103844444A310000
+2C82:000000007844444878444442427C0000
+2C83:00000000000070485070484444780000
+2C84:000000007E4040404040404040400000
+2C85:0000000000007C404040404040400000
+2C86:0000000010080C0C14121212A1FF0000
+2C87:000000000000201018181414A2FE0000
+2C88:000000003C664280FE808042663C0000
+2C89:0000000000003C4280FE8080423C0000
+2C8A:000000003A4440404020100804040800
+2C8B:0000000000003A444040201804040800
+2C8C:00000080FE0202040810204040FE0200
+2C8D:000000000080FE020408102040FE0200
+2C8E:00000000424242427E42424242420000
+2C8F:0000000000004242427E424242420000
+2C90:00000000182424A4FF25242424180000
+2C91:0000000000001824A4FF252424180000
+2C92:00000000301010101010101010080000
+2C93:00000000000030101010101010080000
+2C94:000000004C4448507048444242420000
+2C95:0000000000004C444850704844420000
+2C96:0000000060101808080C142442830000
+2C97:000000000000C0201010182844860000
+2C98:000000008282C6AA9282828282820000
+2C99:000000000000446C5444444444440000
+2C9A:000000008282C2A292928A8682820000
+2C9B:00000000000044646454544C4C440000
+2C9C:00000080FF020C30F80402020C7F0100
+2C9D:000000000080FC041860F008187E0200
+2C9E:00000000386C4482828282446C380000
+2C9F:000000000000386C448282446C380000
+2CA0:00000000FF4242424242424242420000
+2CA1:0000000000007E242424242424240000
+2CA2:000000007C4242427C40404040404040
+2CA3:0000000000007C4242427C4040404040
+2CA4:000000001C36224040404022361C0000
+2CA5:0000000000001C3622404022361C0000
+2CA6:00000000FE1010101010101010100000
+2CA7:000000000000FE101010101010100000
+2CA8:00000000838244281010101010100000
+2CA9:00000000000083442810101010100000
+2CAA:00001010387C5492929292547C381010
+2CAB:000000001010387C549292547C381010
+2CAC:00000000434224181818242442420000
+2CAD:00000000000043241818242442420000
+2CAE:00001010939254381010101010101000
+2CAF:00000000101093543810101010101000
+2CB0:000000004492929292929292926C0000
+2CB1:000000000000449292929292926C0000
+2CB2:0000000000101010FE00000000000000
+2CB3:000000000000000010107C0000000000
+2CB4:00000000040810204620100804000000
+2CB5:00000000000000081020442010080000
+2CB6:0000000002FE000002FE000002FE0000
+2CB7:000000000000027E00027E00027E0000
+2CB8:0000004040201008040810207C000000
+2CB9:000000000000202010080408103C0000
+2CBA:000000000000000002FE000000000000
+2CBB:000000000000000000027E0000000000
+2CBC:00000000929292929292929292920000
+2CBD:00000000000092929292929292920000
+2CBE:0000000092929292FF92929292920000
+2CBF:000000000000929292FF929292920000
+2CC0:000000003C2222223C20FEA020202020
+2CC1:0000000000003C2222223C20FEA02020
+2CC2:54107C1044929292929292926E027C80
+2CC3:000054107C104492929292926E027C80
+2CC4:000000407E020C307804020202047800
+2CC5:0000000000407C0408103C0202423C00
+2CC6:00000000040404080808081010102020
+2CC7:00000000000004040808081010102020
+2CC8:000000003C424202047E1020423C0000
+2CC9:0000000000003C4242047E30423C0000
+2CCA:000000003C424A320204081020400000
+2CCB:0000000000003C424A32040810200000
+2CCC:0000000078C4C202047C02020202827C
+2CCD:00000000000078C4C2023C040202827C
+2CCE:000000001E1111212220204040408080
+2CCF:0000000000001E112121224040408080
+2CD0:000000004040404040404040427E0000
+2CD1:000000000000404040404040447C0000
+2CD2:000000000204081020404C52423C0000
+2CD3:000000000000040810204C52423C0000
+2CD4:000C1020180808080808080808180000
+2CD5:0000000C102018080808080808180000
+2CD6:000000002020202020202020227EA040
+2CD7:000000000000101010101010123E5020
+2CD8:00000000424242424242424242FF0000
+2CD9:000000000000242424242424247E0000
+2CDA:0000000010080C0C54321A16A3FF0000
+2CDB:00000000000010080C2C1A0E537F0000
+2CDC:003C4040386C4482828282446C380000
+2CDD:0000003C4040386C448282446C380000
+2CDE:000000007E22202020202020223E0000
+2CDF:0000000000007E2220202020243C0000
+2CE0:00000000102649516224584080800000
+2CE1:00000000000010264972245880800000
+2CE2:00000000FC203C2222223C2020202020
+2CE3:000000000000FC203C2222223C202020
+2CE4:0000000000004C44485070484442021C
+2CE5:00001E11111E1092D6BA929292921010
+2CE6:001E11111E10FE545454545454541010
+2CE7:01E00110011001E001007FFE391C6D3645228140814045226D36391C01000100
+2CE8:001E11111E107E101010101010101010
+2CE9:1E11111E101056545438383854541010
+2CEA:0000000000000000000000001FFC3636222241404140222236361C1C00000000
+2CEB:000000006C9292926C00FE0000000000
+2CEC:0000000000006C92926C00FE00000000
+2CED:00000000424242665A5A664242420000
+2CEE:0000000000004242665A5A6642420000
+2CEF:000000000C000FFC000C00000000000000000000000000000000000000000000
+2CF0:603E6000000000000000000000000000
+2CF1:067C0600000000000000000000000000
+2CF2:000810203C82424242424242423C0000
+2CF3:0000000810203C8242424242423C0000
+2CF4:00007FFE61C67DBE61BE6FBE61C67FFE7FFE61B66FB663866FF66FF67FFE0000
+2CF5:00007FFE61C67DBE61BE6FBE61C67FFE7FFE61866FBE63866FF66F867FFE0000
+2CF6:00007FFE61C67DBE61BE6FBE61C67FFE7FFE61CE6FBE638E6FB66FCE7FFE0000
+2CF7:00007FFE61C67DBE61BE6FBE61C67FFE7FFE61866FF663EE6FDE6FDE7FFE0000
+2CF8:00007FFE61C67DBE61BE6FBE61C67FFE7FFE61CE6FB663CE6FB66FCE7FFE0000
+2CF9:00000000D8D848242424241212120000
+2CFA:0000000018181020202020404C4C0000
+2CFB:00000000303010080808080464640000
+2CFC:00000000363624484848489090900000
+2CFD:00000000000000040810100804380000
+2CFE:000000000000181010D6101030000000
+2CFF:00300804000000000000000000000000
+2D00:00000000000000007E222020203E0200
+2D01:0000000000000000C444447C0402423C
+2D02:0000000000000000FC4444444442023C
+2D03:0000000000407C141038444444380000
+2D04:0000000000000000FC44444444460202
+2D05:000000000000000000000000000000003FF01110111011101110111001000080
+2D06:00000040701010101C121212121C0000
+2D07:000000000000000000000000000000001FF808880888088808880F8800000000
+2D08:00000000000000007E32220202020000
+2D09:0000000020202038242424241C040404
+2D0A:000000000000000000000000000000001FF8088808880888088808F800000000
+2D0B:000000203C0404041E24242424180000
+2D0C:000000007C4440407C44444444440000
+2D0D:00000000000000000000000000000000311011101110111011101FF800000000
+2D0E:0000000000000000B2D21212121F0000
+2D0F:0000000000000000B2D21212121F0202
+2D10:0000000000000000010001000100010011F011101110111011101F1000000000
+2D11:000000004040404048484848487C0400
+2D12:0000000000000000FC44447C4040403C
+2D13:00000000000000000008000800080008188808880888088808880FF800080008
+2D14:000000000000000000000000000000001FF808880888088808880FF800800080
+2D15:0000000010101016BAD0101010100000
+2D16:0000000000000000FC44444444460000
+2D17:0000000000000000622222223E020202
+2D18:00000000000000622222223E0202423C
+2D19:000000002020203C2424242020202020
+2D1A:0000000000000000FC44444444444038
+2D1B:000000000000000001000100010001001FF011101110111011101F1000000000
+2D1C:000000000000000000000000000000001FF80888088808880888089808000800
+2D1D:00000000000000007C24203804242418
+2D1E:000000000000000066222222223E2020
+2D1F:00000000000000C0FE22140C12214080
+2D20:000000000000000000000000000000003F10111011101110111011F800000000
+2D21:00000000404040784C40404040400000
+2D22:00000000000000004078040404780000
+2D23:00000000040404046424243C04040404
+2D24:000000000000000000006222223E0808
+2D25:000000000000000000F00110010001001FF011101110111011101F1000000000
+2D26:00007FFE618E7DB661B66FB6618E7FFE7FFE61CE7DBE618E6FB661CE7FFE0000
+2D27:00000000000000001824040830404438
+2D28:00007FFE618E7DB661B66FB6618E7FFE7FFE61CE7DB661CE6FB661CE7FFE0000
+2D29:00007FFE618E7DB661B66FB6618E7FFE7FFE61CE7DB661C66FF661CE7FFE0000
+2D2A:00007FFE618E7DB661B66FB6618E7FFE7FFE61867DB661866FB661B67FFE0000
+2D2B:00007FFE618E7DB661B66FB6618E7FFE7FFE618E7DB6618E6FB6618E7FFE0000
+2D2C:00007FFE618E7DB661B66FB6618E7FFE7FFE61C67DBE61BE6FBE61C67FFE0000
+2D2D:00000000000000003C040810203C0000
+2D2E:00007FFE618E7DB661B66FB6618E7FFE7FFE61867DBE618E6FBE61867FFE0000
+2D2F:00007FFE618E7DB661B66FB6618E7FFE7FFE61867DBE618E6FBE61BE7FFE0000
+2D30:00000000000000000000182424180000
+2D31:00000000000000384482FE8244380000
+2D32:00000000000000385492FE9254380000
+2D33:000000000000FE442810102844820000
+2D34:00000000000082442810102844FE0000
+2D35:000000000000FE442810102844FE0000
+2D36:000000000000D6D61010101010100000
+2D37:00000000000010282828284444440000
+2D38:00000000000044444428282828100000
+2D39:00000000007E404040784040407E0000
+2D3A:00000000007E0202027E0202027E0000
+2D3B:00000018242418007E00182424180000
+2D3C:000000000000EE28282838282828EE00
+2D3D:000000000000FE84889090A8C4820000
+2D3E:0000000000606000000C0C0000606000
+2D3F:00000000000082C4A890908884FE0000
+2D40:00000000000000385492929254380000
+2D41:000000000000003A448A92A244B80000
+2D42:00001818000018180000181800001818
+2D43:00000000000001020408182442810000
+2D44:0000000000001010107C444444440000
+2D45:00000000000092543810102844820000
+2D46:00000000000000006666000066660000
+2D47:000000000000FE84889090A0C0FE0000
+2D48:0000000000000000000000000000000000001998199800000000000000000000
+2D49:00000000000810201008102010080000
+2D4A:00000000007C101010101010107C0000
+2D4B:00000000000000C62810101028C60000
+2D4C:000000000000282828FE28FE28282800
+2D4D:0000000000002424242C342424242400
+2D4E:00000000007E404040404040407E0000
+2D4F:00000000000010101010101010101000
+2D50:000000000000101010FE10FE10101000
+2D51:00000000101010101010101010001010
+2D52:000000000000003C0408182424180000
+2D53:00000000182424180000182424180000
+2D54:00000000000000384482828244380000
+2D55:00000000000000384482928A443A0000
+2D56:000000000000444444447C1010100000
+2D57:00000000181800001818000018180000
+2D58:0000000000C3C3000018180000C3C300
+2D59:000000000000003844BABABA44380000
+2D5A:000000000000003A448A928244380000
+2D5B:00000000001E294640404046291E0000
+2D5C:000000000000101010107C1010101000
+2D5D:00000000000082442810102844820000
+2D5E:00000000001E294650785046291E0000
+2D5F:00000000007E4048487C4848407E0000
+2D60:000000000000102828282844447C0000
+2D61:000000000000444444444444447C0000
+2D62:00000000000000081020100810200000
+2D63:00000092925438101010385492920000
+2D64:00000000000030282420202020200000
+2D65:0000009292543810FE10385492920000
+2D66:00000000000408102040201008040000
+2D67:000000000000000000EE000000000000
+2D68:00007FFE618E7DB661B66FB6618E7FFE7FFE73CE6FB663CE6DB673CE7FFE0000
+2D69:00007FFE618E7DB661B66FB6618E7FFE7FFE73CE6FB663C66DF673CE7FFE0000
+2D6A:00007FFE618E7DB661B66FB6618E7FFE7FFE73866FB663866DB673B67FFE0000
+2D6B:00007FFE618E7DB661B66FB6618E7FFE7FFE738E6FB6638E6DB6738E7FFE0000
+2D6C:00007FFE618E7DB661B66FB6618E7FFE7FFE73C66FBE63BE6DBE73C67FFE0000
+2D6D:00007FFE618E7DB661B66FB6618E7FFE7FFE738E6FB663B66DB6738E7FFE0000
+2D6E:00007FFE618E7DB661B66FB6618E7FFE7FFE73866FBE638E6DBE73867FFE0000
+2D6F:002424243C0000000000000000000000
+2D70:00000000000002020202040408106000
+2D71:00007FFE618E7DB661B66FB6618E7FFE7FFE61EE7DCE7BEE77EE77C67FFE0000
+2D72:00007FFE618E7DB661B66FB6618E7FFE7FFE61867DF67B8677BE77867FFE0000
+2D73:00007FFE618E7DB661B66FB6618E7FFE7FFE618E7DF67BC677F6778E7FFE0000
+2D74:00007FFE618E7DB661B66FB6618E7FFE7FFE61B67DB67B8677F677F67FFE0000
+2D75:00007FFE618E7DB661B66FB6618E7FFE7FFE61867DBE7B8677F677867FFE0000
+2D76:00007FFE618E7DB661B66FB6618E7FFE7FFE61CE7DBE7B8E77B677CE7FFE0000
+2D77:00007FFE618E7DB661B66FB6618E7FFE7FFE61867DF67BEE77DE77DE7FFE0000
+2D78:00007FFE618E7DB661B66FB6618E7FFE7FFE61CE7DB67BCE77B677CE7FFE0000
+2D79:00007FFE618E7DB661B66FB6618E7FFE7FFE61CE7DB67BC677F677CE7FFE0000
+2D7A:00007FFE618E7DB661B66FB6618E7FFE7FFE61867DB67B8677B677B67FFE0000
+2D7B:00007FFE618E7DB661B66FB6618E7FFE7FFE618E7DB67B8E77B6778E7FFE0000
+2D7C:00007FFE618E7DB661B66FB6618E7FFE7FFE61C67DBE7BBE77BE77C67FFE0000
+2D7D:00007FFE618E7DB661B66FB6618E7FFE7FFE618E7DB67BB677B6778E7FFE0000
+2D7E:00007FFE618E7DB661B66FB6618E7FFE7FFE61867DBE7B8E77BE77867FFE0000
+2D7F:00000000000000000000000000041F04
+2D80:000000000600060006000F000F8019C0D8C0F8FCD8D618DC18C018C000000000
+2D81:0000000007FC0FFC18A610A611461F7C0E3C0200020036003C00340000000000
+2D82:00000000000001F803E4063C6C007C006C000C000C000C00043003F000300000
+2D83:000000000600060006000F000F8019C0D8C0F800D80018001800180000000000
+2D84:0000000060607FE006000F000F8019C0D8C0F800D80018001800180000000000
+2D85:000000000000000000000F000F8019C0D8C0F800D80018001800180000000000
+2D86:00000000038006C00C600C600C600C600EC007803FF0333003003F0030000000
+2D87:000018301FF006C00C600C600C600C600EC007803FF0333003003F0030000000
+2D88:0000000007F80FCC187818001C000C0007C000C000C00CC00FC00C0000000000
+2D89:18181FF8018007F80FCC187818000C0007C000C000C00CC00FC00C0000000000
+2D8A:0000000003000300030003C000C001C031E03F70373006300630060000000000
+2D8B:000000000000000001803180B180FF80B1803180300030003000300000000000
+2D8C:0000000001C003E036203E20364007F801980300030006000E00000000000000
+2D8D:0180018001C003E036203E20364007F801980300030006000E00000000000000
+2D8E:0C300FF0018001C033E03E20364007F801980300030006000E00000000000000
+2D8F:00000000000001F003580358364C3E4C364C064C060006000600060000000000
+2D90:00000000000001FC03CC06CC0CAA0CEE6C007F006E800C4006C0038000000000
+2D91:0000000001C003E00230033001F0006000C007F006187E186300030000000000
+2D92:000000000C300FF01FF819980180018031803F80330006000C00080000000000
+2D93:01C063C07E000C001C003300638061C060C000FC00D400DC00C000C007F80E1C
+2D94:00000000C0C0FFC00C001E003E007300636003E0037C030C0300030000000000
+2D95:0000000060607FE006000F001F00398031800180018001F001900FF00C000000
+2D96:01C063C07E000C001C003300638061D860D800FE00C600C000C000C007F80E1C
+2D97:00007FFE618E7DB661B66FB6618E7FFE7FFE73866DF671EE7DDE73DE7FFE0000
+2D98:00007FFE618E7DB661B66FB6618E7FFE7FFE73CE6DB671CE7DB673CE7FFE0000
+2D99:00007FFE618E7DB661B66FB6618E7FFE7FFE73CE6DB671C67DF673CE7FFE0000
+2D9A:00007FFE618E7DB661B66FB6618E7FFE7FFE73866DB671867DB673B67FFE0000
+2D9B:00007FFE618E7DB661B66FB6618E7FFE7FFE738E6DB6718E7DB6738E7FFE0000
+2D9C:00007FFE618E7DB661B66FB6618E7FFE7FFE73C66DBE71BE7DBE73C67FFE0000
+2D9D:00007FFE618E7DB661B66FB6618E7FFE7FFE738E6DB671B67DB6738E7FFE0000
+2D9E:00007FFE618E7DB661B66FB6618E7FFE7FFE73866DBE718E7DBE73867FFE0000
+2D9F:00007FFE618E7DB661B66FB6618E7FFE7FFE73866DBE718E7DBE73BE7FFE0000
+2DA0:000000001FF81998018003C003E0067036303E30363006300630063000000000
+2DA1:000000003FF033300300078007C00CE06C6C7C7C6C6C0C600C600C6000000000
+2DA2:000000003FF033300300078007C00CE06C607C606C600C600C6C0C7C000C0000
+2DA3:000000001FF81998018003C003E0067036303E30363000300030003000000000
+2DA4:000000003FF033300300078007C00CE06C607C606C600C7C0C640C7C00000000
+2DA5:000000007FE066600300078007C00CE06C607C606C600C600C600C6000000000
+2DA6:000000000FFC0CCC00C001E003E0073036303E30363006000600060000000000
+2DA7:00007FFE618E7DB661B66FB6618E7FFE7FFE61866DF661EE6DDE6DDE7FFE0000
+2DA8:000018181FF81998018001801FF81998018001801F8019800180000000000000
+2DA9:000018181FF81998018001801FF81998018001981FF819980180000000000000
+2DAA:000018181FF81998018001801FF81998018001801F80199801F8001800000000
+2DAB:000018181FF81998018001801FF81998018001801F8019800380070018001800
+2DAC:000018181FF81998018001801FF81998018001801FF0199001F0000000000000
+2DAD:000030303FF03330018001801FF81998018001801F8019800180000000000000
+2DAE:301830183BA006C00C600C600C600C600EC07FF8631803003F00330003000000
+2DAF:00007FFE618E7DB661B66FB6618E7FFE7FFE61866DBE618E6DBE6DBE7FFE0000
+2DB0:000000000000000000007C3E666606607FE06660066006600660000000000000
+2DB1:000000000000000000007C3E666606607FFE6666066006600660000000000000
+2DB2:000000000000000000007C3E666606607FE0666006600666067E000600000000
+2DB3:000000000000000000007C3E666606607FE06660066000600060000000000000
+2DB4:000000000000000000007C3E666606607FE06660067C0664067C000000000000
+2DB5:61807F800C000C007C3E666606607FE066600660066006600660000000000000
+2DB6:000000000000000000007C3E666606607FE06660066006000600000000000000
+2DB7:00007FFE618E7DB661B66FB6618E7FFE7FFE63866DF663EE6DDE63DE7FFE0000
+2DB8:000000000000000003E007F00C98188CF88CC88C1CCE1AAD1AAD1EEF00000000
+2DB9:000000000000000003E007F00C98188FF88BC8881CCC1AAA1AAA1EEE00000000
+2DBA:000000000000000003E007F00C98188CF88CC88C1CCC1AAC1AAC1EEF00030000
+2DBB:000000000000000003E007F00C981CCCFAACDAAC1EEC0018001C0032003E0000
+2DBC:000000000000000003F007F80C9B188EF88BC8881CCC1AAA1AAA1EEE00000000
+2DBD:000000000000000003F007F80CD81CCCFAEADA6A1E6E00500050007000000000
+2DBE:000000000000000003F007F80C9818CCF8AAC8AA1CEE1A001A001E0000000000
+2DBF:00007FFE618E7DB661B66FB6618E7FFE7FFE63866DBE638E6DBE63BE7FFE0000
+2DC0:00000C300E700180018003F00D98199819B00FC0018001800180018000000000
+2DC1:00000C300E700180018003F00D98199819B00FC0019801F80198018000000000
+2DC2:00000C300E700180018003F00D98199819B00FC001800180019801F800180000
+2DC3:000018601CE00300030007E01B30333033601F80030006000C00380038003800
+2DC4:00000C300E700180018003F00D98199819B00FC0018001F0019001F000000000
+2DC5:000030C039C00600018003F00D98199819B00FC0018001800180018000000000
+2DC6:00000C300E70018002400240018003F00D98199819B00FC00180018000000000
+2DC7:00007FFE618E7DB661B66FB6618E7FFE7FFE71866FF66FEE6FDE71DE7FFE0000
+2DC8:0000000000000D980DD80FF00E60066006600660066006600660066000000000
+2DC9:0000000000001B301BB01FE01CC00CC00CF80CD80CC00CC00CC00CC000000000
+2DCA:0000000000001B301BB01FE01CC00CC00CC00CC00CC00CC00CC00CF800180000
+2DCB:0000000000000D980DD80FF00E60066006600060006000600060006000000000
+2DCC:0000000000001B301BB01FE01CC00CC00CC00CC00CC00CF80CC80CF800000000
+2DCD:000000000000199819D81FF01860066006600660066006600660066000000000
+2DCE:0000000000000D980DD80FF00E60066006600660060006000600060000000000
+2DCF:00007FFE618E7DB661B66FB6618E7FFE7FFE71866FBE6F8E6FBE71BE7FFE0000
+2DD0:30C039C0C630FFF0C63001C003E0067006300630063006300630063000000000
+2DD1:30C039C0C630FFF0C63001C003E006700636063E063606300630063000000000
+2DD2:30C039C0C630FFF0C63001C003E0067036303E30363006300636063E00060000
+2DD3:30C039C0C630FFF0C63001C003E0067006300630003000300030003000000000
+2DD4:30C039C0C630FFF0C63001C003E00670063006300630063E0632063E00000000
+2DD5:30C039C0C630FFF0C63003C00FE0187006300630063006300630063000000000
+2DD6:30C039C0C630FFF0C63001C003E0067006300630060006000600060000000000
+2DD7:00007FFE618E7DB661B66FB6618E7FFE7FFE63866DF66DEE6DDE63DE7FFE0000
+2DD8:0000000018601CE00FC007803F8030C000C000C000C000C000C000C000000000
+2DD9:0000000030C039C01F800F007F00618001F001B0018001800180018000000000
+2DDA:0000000030C039C01F800F007F0061800180018001800180018001F000300000
+2DDB:0000000030C039C01F800F007F006180018001800180038007007C0060000000
+2DDC:0000000030C039C01F800F007F00618001800180018001F0019001F000000000
+2DDD:0000000030C039C01F800F003F0025803D800180018001800180018000000000
+2DDE:30C039C01F80060006000F007F00618001800180018001800180018000000000
+2DDF:00007FFE618E7DB661B66FB6618E7FFE7FFE63866DBE6D8E6DBE63BE7FFE0000
+2DE0:04182038241800000000000000000000
+2DE1:38243824380000000000000000000000
+2DE2:38202020200000000000000000000000
+2DE3:1C1414243E4200000000000000000000
+2DE4:54543854540000000000000000000000
+2DE5:18240824180000000000000000000000
+2DE6:24283028240000000000000000000000
+2DE7:1E121252220000000000000000000000
+2DE8:446C5444440000000000000000000000
+2DE9:24243C24240000000000000000000000
+2DEA:18242418000000000000000000000000
+2DEB:3C242424240000000000000000000000
+2DEC:38243820200000000000000000000000
+2DED:18202018000000000000000000000000
+2DEE:7C101010100000000000000000000000
+2DEF:44281028440000000000000000000000
+2DF0:242424243E0200000000000000000000
+2DF1:24241C04040000000000000000000000
+2DF2:545454547C0000000000000000000000
+2DF3:545454547E0200000000000000000000
+2DF4:18243C24180000000000000000000000
+2DF5:3F444434000000000000000000000000
+2DF6:18041C241C0000000000000000000000
+2DF7:18243C201C0000000000000000000000
+2DF8:081C081C222200000000000000000000
+2DF9:04281028281000000000000000000000
+2DFA:107C101C121C00000000000000000000
+2DFB:4C5272524C0000000000000000000000
+2DFC:4C427E524E0000000000000000000000
+2DFD:10283854540000000000000000000000
+2DFE:7C442838545400000000000000000000
+2DFF:5F514A7E555500000000000000000000
+2E00:0000003C202020202000000000000000
+2E01:0000003C202420202000000000000000
+2E02:00000004081020202020000000000000
+2E03:00000020100804040404000000000000
+2E04:00000004081020242020000000000000
+2E05:00000020100804240404000000000000
+2E06:0000007C101010101000000000000000
+2E07:0000007C101410101000000000000000
+2E08:00000038444024108848300000000000
+2E09:00000038444020108848300000000000
+2E0A:00000070880810204448300000000000
+2E0B:0000007C4444447C0000000000000000
+2E0C:00000040201008040000000000000000
+2E0D:00000004081020400000000000000000
+2E0E:000000800100038000000FE0010002807FFC028001000FE00000038001000200
+2E0F:0000000000000000000000000000000000000000000000000000000000007FFE
+2E10:0000000000000000000000000000000000000000000000007FFE100020004000
+2E11:0000000000000000000000000000000000000000000000007FFF000800040002
+2E12:00000000000000000000000000100810
+2E13:0000000000000008001000200440008001000200044008001000200000000000
+2E14:00000000000000080010002000400080010022002400280010000E0000000000
+2E15:00000000000000E0001000280048008801000200040008001000200000000000
+2E16:00000000000820100804081020080000
+2E17:00000000000000000618600618600000
+2E18:000000001010001010305052523C0000
+2E19:0000000000000A2BACAFB07EE0DC0000
+2E1A:0000000000240000007E000000000000
+2E1B:00001824241800314946000000000000
+2E1C:00000000000000000000004020100804
+2E1D:00000000000000000000000408102040
+2E1E:00000018180000314946000000000000
+2E1F:0000000000000031494600000C0C0000
+2E20:00000010101010101C10101010100000
+2E21:00000008080808083808080808080000
+2E22:0000000E080808080800000000000000
+2E23:00000070101010101000000000000000
+2E24:00000000000000000008080808080E00
+2E25:00000000000000000010101010107000
+2E26:000000000000003E4040403E00000000
+2E27:000000000000007C0202027C00000000
+2E28:00000012242448484848484824241200
+2E29:00000090484824242424242448489000
+2E2A:00000000000066660000001818000000
+2E2B:00000000000018180000006666000000
+2E2C:00000000000066660000006666000000
+2E2D:000000000000181800DBDB0018180000
+2E2E:000000003C4242402010100010100000
+2E2F:08101008081000000000000000000000
+2E30:00000000000000182424180000000000
+2E31:00000000000000183C3C180000000000
+2E32:00000000000000000000081010180000
+2E33:00000000000000000000181800000000
+2E34:00000000000000000000180808100000
+2E35:00000000081010180000001818000000
+2E36:00000818082878280818080808080000
+2E37:0000080C080A0F0A080C080808080000
+2E38:0000080808081C082A7F2A081C080000
+2E39:000000003C42403C42423C0000000000
+2E3A:0000000000000000000000000000000000003FFC000000000000000000000000
+2E3B:0000000000000000000000000000000000007FFF000000000000000000000000
+2E3C:00000000000000000000001408140000
+2E3D:00000008000800080008000800080000
+2E3E:000C1008040810080408100804180000
+2E3F:000A7F8A8AFF8A7F0A0A0A0A0A0A0000
+2E40:0000000000000000003C003C00000000
+2E41:00000000000000000000000018101008
+2E42:00000000000000000000000066444422
+2E43:0000000000000000000000000000180018001FFE000000000000000000000000
+2E44:00000008102000000000000000081020
+2E45:00000000000000001824240000000000
+2E46:00000000242418001824240000000000
+2E47:00000000000000002424180000000000
+2E48:00000000000000005444380000000000
+2E49:00000000000018080810001808081000
+2E4A:00000000020204183C3C182040400000
+2E4B:00082A7F2A08082A7F2A08082A7F2A08
+2E4C:00000000000060101060000060600000
+2E4D:000000007E4448506040404040400000
+2E4E:00000000000000046870000060600000
+2E4F:00000000006264081224081026060000
+2E50:00003FE00F8007080708071807F807F807F80718070807080F803FE000000000
+2E51:00000FF803E021C021C031C03FC03FC03FC031C021C021C003E00FF800000000
+2E52:000000007E02020202020202221C0000
+2E53:00007FFE61867DBE618E6FBE61867FFE7FFE618E6FF661C67DF6618E7FFE0000
+2E54:00007FFE61867DBE618E6FBE61867FFE7FFE61B66FB661867DF661F67FFE0000
+2E55:00007FFE61867DBE618E6FBE61867FFE7FFE61866FBE61867DF661867FFE0000
+2E56:00007FFE61867DBE618E6FBE61867FFE7FFE61CE6FBE618E7DB661CE7FFE0000
+2E57:00007FFE61867DBE618E6FBE61867FFE7FFE61866FF661EE7DDE61DE7FFE0000
+2E58:00007FFE61867DBE618E6FBE61867FFE7FFE61CE6FB661CE7DB661CE7FFE0000
+2E59:00007FFE61867DBE618E6FBE61867FFE7FFE61CE6FB661C67DF661CE7FFE0000
+2E5A:00007FFE61867DBE618E6FBE61867FFE7FFE61866FB661867DB661B67FFE0000
+2E5B:00007FFE61867DBE618E6FBE61867FFE7FFE618E6FB6618E7DB6618E7FFE0000
+2E5C:00007FFE61867DBE618E6FBE61867FFE7FFE61C66FBE61BE7DBE61C67FFE0000
+2E5D:00007FFE61867DBE618E6FBE61867FFE7FFE618E6FB661B67DB6618E7FFE0000
+2E5E:00007FFE61867DBE618E6FBE61867FFE7FFE61866FBE618E7DBE61867FFE0000
+2E5F:00007FFE61867DBE618E6FBE61867FFE7FFE61866FBE618E7DBE61BE7FFE0000
+2E60:00007FFE61867DBE618E6FBE61867FFE7FFE73CE6FB663B66DB673CE7FFE0000
+2E61:00007FFE61867DBE618E6FBE61867FFE7FFE73EE6FCE63EE6DEE73C67FFE0000
+2E62:00007FFE61867DBE618E6FBE61867FFE7FFE73866FF663866DBE73867FFE0000
+2E63:00007FFE61867DBE618E6FBE61867FFE7FFE738E6FF663C66DF6738E7FFE0000
+2E64:00007FFE61867DBE618E6FBE61867FFE7FFE73B66FB663866DF673F67FFE0000
+2E65:00007FFE61867DBE618E6FBE61867FFE7FFE73866FBE63866DF673867FFE0000
+2E66:00007FFE61867DBE618E6FBE61867FFE7FFE73CE6FBE638E6DB673CE7FFE0000
+2E67:00007FFE61867DBE618E6FBE61867FFE7FFE73866FF663EE6DDE73DE7FFE0000
+2E68:00007FFE61867DBE618E6FBE61867FFE7FFE73CE6FB663CE6DB673CE7FFE0000
+2E69:00007FFE61867DBE618E6FBE61867FFE7FFE73CE6FB663C66DF673CE7FFE0000
+2E6A:00007FFE61867DBE618E6FBE61867FFE7FFE73866FB663866DB673B67FFE0000
+2E6B:00007FFE61867DBE618E6FBE61867FFE7FFE738E6FB6638E6DB6738E7FFE0000
+2E6C:00007FFE61867DBE618E6FBE61867FFE7FFE73C66FBE63BE6DBE73C67FFE0000
+2E6D:00007FFE61867DBE618E6FBE61867FFE7FFE738E6FB663B66DB6738E7FFE0000
+2E6E:00007FFE61867DBE618E6FBE61867FFE7FFE73866FBE638E6DBE73867FFE0000
+2E6F:00007FFE61867DBE618E6FBE61867FFE7FFE73866FBE638E6DBE73BE7FFE0000
+2E70:00007FFE61867DBE618E6FBE61867FFE7FFE61CE7DB67BB677B677CE7FFE0000
+2E71:00007FFE61867DBE618E6FBE61867FFE7FFE61EE7DCE7BEE77EE77C67FFE0000
+2E72:00007FFE61867DBE618E6FBE61867FFE7FFE61867DF67B8677BE77867FFE0000
+2E73:00007FFE61867DBE618E6FBE61867FFE7FFE618E7DF67BC677F6778E7FFE0000
+2E74:00007FFE61867DBE618E6FBE61867FFE7FFE61B67DB67B8677F677F67FFE0000
+2E75:00007FFE61867DBE618E6FBE61867FFE7FFE61867DBE7B8677F677867FFE0000
+2E76:00007FFE61867DBE618E6FBE61867FFE7FFE61CE7DBE7B8E77B677CE7FFE0000
+2E77:00007FFE61867DBE618E6FBE61867FFE7FFE61867DF67BEE77DE77DE7FFE0000
+2E78:00007FFE61867DBE618E6FBE61867FFE7FFE61CE7DB67BCE77B677CE7FFE0000
+2E79:00007FFE61867DBE618E6FBE61867FFE7FFE61CE7DB67BC677F677CE7FFE0000
+2E7A:00007FFE61867DBE618E6FBE61867FFE7FFE61867DB67B8677B677B67FFE0000
+2E7B:00007FFE61867DBE618E6FBE61867FFE7FFE618E7DB67B8E77B6778E7FFE0000
+2E7C:00007FFE61867DBE618E6FBE61867FFE7FFE61C67DBE7BBE77BE77C67FFE0000
+2E7D:00007FFE61867DBE618E6FBE61867FFE7FFE618E7DB67BB677B6778E7FFE0000
+2E7E:00007FFE61867DBE618E6FBE61867FFE7FFE61867DBE7B8E77BE77867FFE0000
+2E7F:00007FFE61867DBE618E6FBE61867FFE7FFE61867DBE7B8E77BE77BE7FFE0000
+2E80:00000000000000000E000180006000101C00030000C000200000000000000000
+2E81:0000007C1F801000100010001000100010001000100020002000200040008000
+2E82:000000000000000000003FF80008000800100010002000200000000000000000
+2E83:0000100010001000100010001000100010001000100010001010101010100FF0
+2E84:00000000FFE00020002000200020002000200020002000100012000A00060002
+2E85:0040004000800100010003000500090001000100010001000100010001000100
+2E86:00000FF008100810081008100810081008100810081010101010101020504020
+2E87:00001FF01010101010101010101010101010101010102008200A200A40068002
+2E88:0400040007F00820084010002000000000000000000000000000000000000000
+2E89:0004000400040044004400440044004400440044004400440004000400140008
+2E8A:040004000400040004000400040007F004000400040004000400040004000400
+2E8B:00000000000000000000000000003FF020102010201020502020200420041FFC
+2E8C:0100111009200100000000000000000000000000000000000000000000000000
+2E8D:0208210810900820000000000000000000000000000000000000000000000000
+2E8E:000000000000FFFE0440044004400440044008400840104210422042403E8000
+2E8F:022002100408080410026422042004200420042004200420082208221022601E
+2E90:01000100010001000100FFFE024002400240044004400840084210422042C03E
+2E91:0220021004080804100267E2042004200420042004200420082208221022601E
+2E92:000000003FF020102010201020103FF02000200020002004200420041FFC0000
+2E93:00000100010002100410082010401F80010002000420081010083FFC00040004
+2E94:000004000400040007F0042008200820082008401FC00040004000407FFC0000
+2E95:00000000000000003FF8000800083FF80008000800083FF80008000000000000
+2E96:08000800080008000C004A004A00880008000800080008000800080008000800
+2E97:000000000000000000000200020002200290124812242214221042000A000400
+2E98:0100010001001FC001000100010001C007001900010001000100010005000200
+2E99:0800080008000FFC18102410442082200140008001800240042008101008E006
+2E9A:00007FFE61867DBE618E6FBE61867FFE7FFE73866DB671867DB673B67FFE0000
+2E9B:3FF002000200420042007FFC0480048004800880088010842084407C80000000
+2E9C:3FF820082FE820082FE800000000000000000000000000000000000000000000
+2E9D:00001FF01010101010101FF01010101010101FF0101010101010101010501020
+2E9E:0080008000FE088008800FF8100814102210412001400080010002000C007000
+2E9F:00001FF01010121011101110FFFE20102210211021103FFC0010001000A00040
+2EA0:000000103FF82008200820083FF8200020883FFC2080204020202010380E3004
+2EA1:200010001000800040004800080010001000E000200020002000200000000000
+2EA2:01000100010021081110092001000140052009101108E1044104010005000200
+2EA3:0000000000000000000000000000000000000000248822444244800400000000
+2EA4:0010007C0780F808210818900890000000000000000000000000000000000000
+2EA5:007C1F9011101110210821044002000000000000000000000000000000000000
+2EA6:020002000200220012000A000200020006000A00120062002200020002000200
+2EA7:010011001FF821000100FFFE0000000000000000000000000000000000000000
+2EA8:4400280010002800480088000800180028004800880008000800500020000000
+2EA9:FE0010001000100010001000FE00100010001000100016003800C00000000000
+2EAA:00000000FC0008001000100010005C0050005000500050005C00F00040000000
+2EAB:3FF82448244824483FF800000000000000000000000000000000000000000000
+2EAC:00007E0000000000FE0010001000540052005200900010001000100050002000
+2EAD:200010001000F800080010001000380054009400100010001000100010001000
+2EAE:00001040104010403EFE289049108A1000000000000000000000000000000000
+2EAF:080008001000120022007C000800100024007E00020000005200490089000000
+2EB0:10001000200024004400F800100020004000FC00400000001C00E00040000000
+2EB1:3FF8200824482288210822882448200800000000000000000000000000000000
+2EB2:3FF82448244824483FF800000000000000000000000000000000000000000000
+2EB3:00003FFC20044008044008201010000000000000000000000000000000000000
+2EB4:00007FFE4444844804400440044004400440044008400842104210422042403E
+2EB5:0000000000003FFC224422442244224422442244224422442244200400000000
+2EB6:101008203FF801001FF001000200FFFE040008001000E0000000000000000000
+2EB7:082004407FFC01001FF00100FFFE000000000000000000000000000000000000
+2EB8:0440044004407C7C044004400000FFFE010001003FF801000100010001000100
+2EB9:020002083FC802100220FFFE0080010002000C003000C0000000000000000000
+2EBA:010001003FF80108FFFE01083FF8010801000100010001000100010001000100
+2EBB:010001001FF80108FFFE01081FF80100FFFE0000000000000000000000000000
+2EBC:07F8040805080488044804680408041804280448058808880808100820284010
+2EBD:02000C00707C400440044004400440047CFC400440044004400440047CFC4004
+2EBE:08200820FFFE0820082000000000000000000000000000000000000000000000
+2EBF:08200820FEFE0820082000000000000000000000000000000000000000000000
+2EC0:0000082008200820082008200820F83E08200820082008200820082008200000
+2EC1:010001F801003FFC210421602F88210820F8200023E02220222044244824901C
+2EC2:200010000000FC00080010001000340058009400140010001000100010001000
+2EC3:7FFC044004403FF8244824483FF8000000000000000000000000000000000000
+2EC4:00000000FFFE0480048004807FFC4484448444844484489448F4500440047FFC
+2EC5:1FF01010101011101110111011101110129012900480048008823082C07E0000
+2EC6:080008001FE020204040BFF8210821083FF8210821083FF82108410841288010
+2EC7:0400040007F0082010403FF85108118812481528198812481428180810281010
+2EC8:20001000100000000000F0001000100010001000100014001800100000000000
+2EC9:1FF0101010101010111011101110111011101210028004400820101020080000
+2ECA:00007F004100410041007F004900080008004F004800480048004F00F0004000
+2ECB:0200020002007FFC04000900110021003FF801000100FFFE0100010001000100
+2ECC:20001000100000000000F000100010001000100010001000280047FE00000000
+2ECD:2000100008004000200010000000F000100010001000100010002800440083FE
+2ECE:00002000100000000000F800080010002000780008000800100010002800C7FE
+2ECF:0000003C00240028002800300028002400240024003400280020002000200020
+2ED0:100010001E00200020007C0090001000FE001000100012001400180010000000
+2ED1:0FF808000FF008000FF00800FFFE1200111010A0104012201418180610000000
+2ED2:0FF8080008000FF0080008000FF008000800FFFE0400082010103FF810080000
+2ED3:0800081008200840088009000800FFFE0A0009000880084009200A180C060800
+2ED4:200013FC10044004400440044004400440044004400440044004400440144008
+2ED5:020004001FF0101010101FF010001FF8100810081FF810001FF8100810081FF8
+2ED6:F800880090009000A000900090008800880088008800F0008000800080008000
+2ED7:7FFC0100FFFE91128D6201001D70610C00000000000000000000000000000000
+2ED8:020002007FF802003FF00200FFFC00001FE010201FE010201FE01020102010C0
+2ED9:010001000104FFFE010001103FF8010001047FFE010401040104012801100100
+2EDA:7FFC020004001FF0101011101110111011101110129002400420181060080000
+2EDB:3FF02010201028502450229022902110211022902292244A484A400680020000
+2EDC:FFC000400044004800500060005000480044002000200012000A000600020000
+2EDD:0100028004400A203118DFF610101FF010101FF0100811901060121014081804
+2EDE:080008001400120029007E00A2003E0022003E0020003E00200020003E002000
+2EDF:080008001400120029007E00A2003E0022003E002000280024002A0032002000
+2EE0:2000200020003E00440048008000100010001000100012001400180010000000
+2EE1:088808881110222011100888FFFE02001FF010101FF010101FF010101FF01010
+2EE2:7FE0002000201020102010201FFC000400040004FFE400040004002800100000
+2EE3:1FF010101F90109010907FFE40029FF410101FF010101FF01010101010501020
+2EE4:020004003FF8210821083FF8220822083FF8051009200948117C2102410280FE
+2EE5:040004000FE0102020407FF8A10821083FF8210821083FF800000000FFFE0000
+2EE6:010002001FF01010121011101150102010001FFC000400047FE4000400280010
+2EE7:0100010001FE010001003FF8200828282448228821082288244828283FF82008
+2EE8:010001007FFC010001003FF801000100FFFE08001FF02820444003801C70E00E
+2EE9:04403FF804400440FFFE01001FF0111011101FF0111011101FF0044008201010
+2EEA:1FF0101010101FF001003FF8210821083FF8210821083FF8210A0102010200FE
+2EEB:020001007FFC0820044003801C70F01E10101FF0101010101FF0101020104010
+2EEC:020001007FFC0820044003800C603018C8260820082008200820102010202020
+2EED:0100010011F811001100FFFE00002928254823883FF823882548292821083FF8
+2EEE:0100010011F8110011001100FFFE00002108210822882448282820083FF80008
+2EEF:020001007FFC10100820FFFE01001FF011101FF0111011101FF01112010200FE
+2EF0:0420041004100400FFFE048004880488049008A008C0108211822282447E8000
+2EF1:04003FF820083EF802807A800AFCFE940AD47AA402A47AD40A94FEFC0A8279FE
+2EF2:04000FC010803FF0D1101FF011101FF001003FF821083FF821083FF8010200FE
+2EF3:040004000FE0102020407FF8A10821083FF8210821083FF821080102010200FE
+2EF4:00007FFE61867DBE618E6FBE61867FFE7FFE61B66FB663866FF66FF67FFE0000
+2EF5:00007FFE61867DBE618E6FBE61867FFE7FFE61866FBE63866FF66F867FFE0000
+2EF6:00007FFE61867DBE618E6FBE61867FFE7FFE61CE6FBE638E6FB66FCE7FFE0000
+2EF7:00007FFE61867DBE618E6FBE61867FFE7FFE61866FF663EE6FDE6FDE7FFE0000
+2EF8:00007FFE61867DBE618E6FBE61867FFE7FFE61CE6FB663CE6FB66FCE7FFE0000
+2EF9:00007FFE61867DBE618E6FBE61867FFE7FFE61CE6FB663C66FF66FCE7FFE0000
+2EFA:00007FFE61867DBE618E6FBE61867FFE7FFE61866FB663866FB66FB67FFE0000
+2EFB:00007FFE61867DBE618E6FBE61867FFE7FFE618E6FB6638E6FB66F8E7FFE0000
+2EFC:00007FFE61867DBE618E6FBE61867FFE7FFE61C66FBE63BE6FBE6FC67FFE0000
+2EFD:00007FFE61867DBE618E6FBE61867FFE7FFE618E6FB663B66FB66F8E7FFE0000
+2EFE:00007FFE61867DBE618E6FBE61867FFE7FFE61866FBE638E6FBE6F867FFE0000
+2EFF:00007FFE61867DBE618E6FBE61867FFE7FFE61866FBE638E6FBE6FBE7FFE0000
+2F00:000000000000000000047FFE0000000000000000000000000000000000000000
+2F01:0100018001000100010001000100010001000100010001000100010001000000
+2F02:0000000004000200010000800040004000000000000000000000000000000000
+2F03:0200020002000200020002000200020002000200040004000800100020000000
+2F04:00403FE000400080010002000400080010002004200420061FFC000000000000
+2F05:00400040004000400040004000400040004000400040004003C0004000000000
+2F06:00101FF80000000000000000000000000000000000047FFE0000000000000000
+2F07:000000000100008000847FFE0000000000000000000000000000000000000000
+2F08:0100010001000100010001000100010001000280044008201010200E40040000
+2F09:08400C60084008400840084008400840084008401040104420444046803C0000
+2F0A:1E000100010001000100028002800440044008201010200C4006800200000000
+2F0B:00C0004000400640044004400420082008200810101010082004400680020000
+2F0C:20043FFE20042004200420042004200420042004200420042024201C20080000
+2F0D:00000000000020023FFE20044008000000000000000000000000000000000000
+2F0E:0400030001000000004000800080010001000600020002000200020000000000
+2F0F:00200FF0082008200820082008200820082008200820082210222022401E0000
+2F10:2004300620042004200420042004200420042004200420043FFC200400000000
+2F11:00043FFE01040104010401040104010402040204040404040844103860100000
+2F12:01000100010001083FFC01080108010801080208020804080888107060200000
+2F13:1000100010041FFE100420044004000400040004000400040044003800100000
+2F14:08000C00080008100820084009800A000C003800C80008040804080607FC0000
+2F15:20083FFC20002000200020002000200020002000200020083FFC200000000000
+2F16:7FFC200020002000200020002000200020002000200020083FFC000000000000
+2F17:0100010001000100010001047FFE010001000100010001000100010001000000
+2F18:0200020002000200020003800240023002180208020002000200020002000000
+2F19:042007F0042004200420042004200420042004E0044004000400040004000000
+2F1A:20043FFE20002000200020002000200020002000200020004000400080000000
+2F1B:018001000100020002000400040008200810100811FCFE044004000000000000
+2F1C:00103FF80810081004200420024002400180018002400420181E600400000000
+2F1D:10081FFC1008100810081008100810081008100810081FF81008000000000000
+2F1E:20043FFE20042004200420042004200420042004200420043FFC200400000000
+2F1F:0100018001000100010001083FFC01000100010001000100010001047FFE0000
+2F20:0100018001000100010001047FFE01000100010001000100010001083FFC0000
+2F21:0400041007F80C101220214001800E70700E0000000000000000000000000000
+2F22:0200020012100BF8041004100A200A20114021404080014006201818E0060000
+2F23:02000200020803FC040804080C10121021204120004000800100060038000000
+2F24:010001800100010001047FFE0100010001000280044008201010200E40040000
+2F25:020003000200020002047FFE042004200820082010400E8001800670780E0000
+2F26:00083FFC0010002000C0008000847FFE00800080008000800480038001000000
+2F27:00000100008020843FFE20044008000000000000000000000000000000000000
+2F28:00200020002000247FFE0020002008200420042004200020012000E000400000
+2F29:008000800080008000800C900888108410862082408200800480038001000000
+2F2A:0200020002000208FFFC020002000280028004800484088410842086C07C0000
+2F2B:10081FFC1008100810081FF81008100010001000100020002000400080000000
+2F2C:010001000100210421042104210421043FFC21040100010002000C0070000000
+2F2D:01000100010001004104410441044104410441044104410441047FFC40040000
+2F2E:0444044408880888111011102220444022201110088808880444044404440000
+2F2F:00083FFC01000100010001000100010001000100010001047FFE000000000000
+2F30:00107FF800100010001000103FF020102000200020002004200420061FFC0000
+2F31:00800080008010841FFE10841084108410841084108410BC1088008000800000
+2F32:00083FFC010001000100010001047FFE01000100010001000100010001000000
+2F33:0300020004000430082010407F80210002000420081013E87C0C200400000000
+2F34:0100008000841FFE100010001000100010001000100020002000400080000000
+2F35:08007C0008000800100024003E00040084004400280010002800C40683FC0000
+2F36:0410041004100410041004107FFE041004100410041008100810101020100000
+2F37:0120011801080100011E01E07F003080008000800040004200220012000E0000
+2F38:00103FF80010001000101FF0100010083FFC000800080008010800F000200000
+2F39:00083FFC000800080008000800081FF8000800080008000800083FF800080000
+2F3A:00C0008001000200040000C00080010002000460004000800100020004000000
+2F3B:00C000800100020004C008800100030005000900110001000100010001000000
+2F3C:0100008000C00040040004002408240424062402440084100410041803F00000
+2F3D:0200024002200200021C02E07F000218021002200140018202440C24701E0000
+2F3E:001010381FC010081FFC1008100810081FF81008100020002000400080000000
+2F3F:001000787F80010001103FF8010001047FFE0100010001000900070002000000
+2F40:0080008000847FFE008000901FF80410041002200140008001400630380E0000
+2F41:01000100010401FE010001103FF80810042004200240018001800E70700E0000
+2F42:0100008000847FFE082008200820044004400240028001800660181860060000
+2F43:002008200420022002200820042002200224003E03E07C202020002000200000
+2F44:002010701F801000100010041FFE104010401040104020402040404080400000
+2F45:0100008000847FFE02000200020803FC02080208020804080888107060200000
+2F46:00081FFC01000100010001047FFE0240024002400240044208421042603E0000
+2F47:10101FF8101010101010101010101FF0101010101010101010101FF010100000
+2F48:20083FFC20082008200820083FF820082008200820083FF82008000000000000
+2F49:08100FF80810081008100FF00810081008100FF0081008101090207040200000
+2F4A:00800080008000847FFE0080028002A004A00490089008881086608400800000
+2F4B:0800080008040FFE100821104100010001000100018002400420181860060000
+2F4C:00800080008000800080088808FC08800880088008800880088008847FFE0000
+2F4D:00047FFE02000200021003F804100C1012202120414000800100060078000000
+2F4E:042007F00420042004200820101C20001FF808100420024001800E70700C0000
+2F4F:00081FFC10881088108810887FFE11081108210822087FFE041009F030200000
+2F50:0040104010401040104C12481F501060104010401040104413443C46103C0000
+2F51:001000383FC001000100011C3FE00100010E01F07F0001020102010200FE0000
+2F52:001010381FC01080108010881FFC1080108010801080124214227812200E0000
+2F53:080008080FFC10002FF04000BFF000100010001000100012000A000600020000
+2F54:010001000100011801107D2005400580094009201110210C4906870202000000
+2F55:0080008000800080088C0888089010A020C00080018002400420181860060000
+2F56:001010381FE01120112011201120112011101110111021082108410681020000
+2F57:044004200810100C2004402004200440024002800180018002400C30300E0000
+2F58:00181810062001C002300C0C30240420044002400280018002C00C30300E0000
+2F59:0010041004100410041007F0001000103FF00410041004100410081030100000
+2F5A:104010401040104010441FFE100010201FF01020102010201020202040200000
+2F5B:00047FFE00400840084010443FFE01400240044008401040224041C000800000
+2F5C:00800080108010881FFC10802080408000847FFE008000800080008000800000
+2F5D:010001A00110011001047FFE0100010001000280044008201010200E40040000
+2F5E:0100008000847FFE01000100023005E01E4008800100021005F81E0C08040000
+2F5F:00083FFC01000100010001101FF80100012001100110010001047FFE00000000
+2F60:0008103C1FE0112011201120112011201110111011501148214843A681220000
+2F61:00047FFE04000400042007F008200A20092009201020102213227C22201E0000
+2F62:0810081008147FFE08100810081008100FF008100810081008100FF008100000
+2F63:00801080108010881FFC10802080408000901FF800800080008000847FFE0000
+2F64:10041FFE1084108410841FFC1084108410841FFC1084208420A4409C80880000
+2F65:20043FFE20842084208420843FFC208420842084208420843FFC200400000000
+2F66:00047FFE0084008800801080108810FC10801080188014802280C18080FE0000
+2F67:008008440FFE4800280028000800180068004800080010001000200040000000
+2F68:00087F1002A22244142808101008200440020000000000000000000000000000
+2F69:0100010012081FFC10081008100810081FF810081008100810081FF810080000
+2F6A:0080008010841FFE1084108810801FF812101210112020C020C043309C0E0000
+2F6B:10081FFC12481248124812481248124812481248124812487FFE000000000000
+2F6C:10101FF81010101010101FF01010101010101FF01010101010101FF010100000
+2F6D:00101FF800200340008000847FFE018802900480088010802480438001000000
+2F6E:0800080008080FFC10802080008000847FFE0080014002200410180E60040000
+2F6F:00047FFE01000100020004080FFC1408240844080408040807F8040800000000
+2F70:00101FF800000000000000047FFE00800CA00890108820844484038001000000
+2F71:0100010021043FFE210422042244222424F43F14281420042004203C20080000
+2F72:0008003C1FC00080008000847FFE008001C002A0049008881086608200800000
+2F73:0100008020823FFE200440080440044004400420082008101008200C40060000
+2F74:02000100008000883FFC000008100810042004200240024000847FFE00000000
+2F75:10001060104012441F7E289049108A1008100810081008100890087008200000
+2F76:0080108C08880C9004A000C47FFE028002C004A0089010882086408200800000
+2F77:01800100023004201FC00880012002103FFC108400800C900888108620820000
+2F78:0800080008080FFC1080208000847FFE008010841084108410841FFC10040000
+2F79:20043FFE2004211421142A942464222425242954309421042024201C20080000
+2F7A:0830042002447FFE0100010001101FF8010001047FFE01000100010001000000
+2F7B:02047FFE02042244122412240204060C1A3462C40204020412240E1C04080000
+2F7C:01000100010C3FE8011001247FFE0080010006300CC017046404040603FC0000
+2F7D:00047FFE0080008021043FFE2244224422442244224422442244225C20080000
+2F7E:01000104FFFE010001103FF801000104FFFE054005200910110C2106C1020000
+2F7F:00047FFE082008200FE00820082008200FE00824083E0FE07820002000200000
+2F80:010001081FFC01087FFE01081FF8010801003FF801047FFE0100010001000000
+2F81:0100010021043FFE210421842244243429142104218422442424281C20080000
+2F82:20083FFC2100210021083FFC2008200820083FF82108210021043FFE20000000
+2F83:0180010002081FFC100810081FF81008100810081FF8100810081FF810080000
+2F84:00047FFE01000200042008107FF82104010001083FFC0100010001047FFE0000
+2F85:02002704387E20042004200420043E7C200420042004200420043FFC20040000
+2F86:001000783F80008000847FFE0080008008880FFC0808080808080FF808080000
+2F87:10101010101012141F7E1210225052500A900AFE041008101010201040100000
+2F88:010001000A100FF809100890089008147FFE091008900890081010F020200000
+2F89:10101FF8101010101FF0101010101FF01200110C113010C01660781820060000
+2F8A:0400042007F0084010883FFC5108110811081FF810081002100210020FFE0000
+2F8B:0810081008102A542A542A542A542A542A543E7C2A5408101010201040100000
+2F8C:010001FC010001003FFE200221042110213821C02F0021022102410280FE0000
+2F8D:00800080008010881FFC1088108810881FF810880080008800847FFE30020000
+2F8E:00C00080010012081FFC124812481248124812481248124812487FFE00000000
+2F8F:180811FC200040000C040BFE1010301050109010101010101090107010200000
+2F90:0100008000847FFE0180028C04880C50146024404420049005080E0604020000
+2F91:00047FFE0220022022243FFE222422242224222423E422242004200420040000
+2F92:00201FF0102010201FE0102010201FE0102010201FE014A408843086C07C0000
+2F93:042007F0042008441FFE288448840FFC088408840FFC10841084209C40880000
+2F94:02000104FFFE000000001FF000001FF0000010101FF8101010101FF010100000
+2F95:044004200810100C218402400420181860060FF00810081008100FF008100000
+2F96:00083FFC000008100FF80810081008100FF0081004600440024002847FFE0000
+2F97:00047FFE01000200040C1A08631004A019C062A00490188E6084048003000000
+2F98:006000C00188065C1A2001C003200C60109003301C50009003101D2000C00000
+2F99:08080FFC080808080FF8080808080FF8080808080FF8080803600C1830060000
+2F9A:0080008000881FFC008000847FFE02401248124422442442444209C030800000
+2F9B:0100010001101FF8010001047FFE01000900090809FC09001500230040FE0000
+2F9C:08100FF80810081008100FF008900080088808FC088014801280218640FC0000
+2F9D:008009100FF808100FF0081008160FF408187FF000500190061018F060200000
+2F9E:010001047FFE010011081FFC11081FF811081FF8110801047FFE010001000000
+2F9F:010000883FFC08200420024002447FFE010001083FFC01000100010001000000
+2FA0:10041FFE1000101017F8100010041FFE124012481250222022904F0884060000
+2FA1:006001801E3800C01F1800601F8000801080108818FC148022804180807E0000
+2FA2:1FF0101010101FF0101000003FF8210821083FF820082004200420061FFC0000
+2FA3:00047FFE024012441FFE124412441244143C180410041FFC10041FFC10040000
+2FA4:003000F83F0001101110092009447FFE0380054009201110210E410401000000
+2FA5:10081FFC110811081FF8110811081FF81108010001083FFC010001047FFE0000
+2FA6:0080018002400420081010086FF6010001083FFC01001118091009247FFE0000
+2FA7:08100FF808000FF008000FF0080008047FFE08880850082009900E0E38040000
+2FA8:7EFC428442847EFC428442847EFC400440044004400440044024401C40080000
+2FA9:010012101FF810101FF010001FF810081FF8108800847FFE0080008000800000
+2FAA:010001103FF801107FFE01103FF0011031880990076009207118270602000000
+2FAB:0480044004440FFE0840184028484FFC084008480FFC084008440FFE08000000
+2FAC:00047FFE010021043FFE21042944252425242104294425242524211C21080000
+2FAD:0104FFFE01003FF80104FFFE00003FF82108210821083FF82008207820100000
+2FAE:0240024002447E7E0240024002483E7C0240024002447E7E0240024002400000
+2FAF:00047FFE008021043FFE2244224423C42244224423C4224422443FFC20040000
+2FB0:08200824FFFE08200FE001003FF821083FF821080100FFFE0100010001000000
+2FB1:020002201FF004247FFE00000FF008100FF000803FFC10803FFC008000800000
+2FB2:02400240024002447E7E024002403E7C024002447E7E0240024002447FFE0000
+2FB3:030001087FFC102008200440FFFE000010101FF810101FF010101FF010100000
+2FB4:00047FFE008011081FFC10081FF810081FF810081FF8100803600C1830060000
+2FB5:20083FFC204821E82F0821082FE8292829282FE82928214A21EA4F2684020000
+2FB6:3FE0002400280D30392C092209127FEE092409280930112C1112210A41060000
+2FB7:008001800240052018986FF608100FF008100FF0080809900A603C1810060000
+2FB8:083004207FFE008011101FF8101010101FF010101FF0101010101FF010100000
+2FB9:002000703F8001047FFE054009203118C8160FF808100FF008100FF008100000
+2FBA:10081FFC110011101FF811001FF8110011041FFE002409142494248440380000
+2FBB:08100FF8081009F029123FFE20044FF408100FF008100FF00810087008200000
+2FBC:010000847FFE00000FF008100FF020043FFE200427E4242427E4243C20080000
+2FBD:22003F0C200820103F2620443F8820107F26104410082210FF20414001800000
+2FBE:8002BEFA8822BEFA8822BEFA8002800280028002800280028012800E80040000
+2FBF:02102924244432A42994224424A43FFC2004103010C01700180410040FFC0000
+2FC0:00047FFE00000FF008100FF000003FFC2004244422842FF42104211C21080000
+2FC1:010012081FFC110811081FF8110811081FF81088019002A804FE1882607E0000
+2FC2:042007F0042008401FF8288848880FF8088808880FF808082444222242220000
+2FC3:01000A100FF808100FF008100FF008080FFC08000FFC29242494449400180000
+2FC4:0100010401FE01003FFC22142924244432A429942244252428943FFC20040000
+2FC5:010020843FFE222022243FFE22243FFC280428202FA4283829A25E22883E0000
+2FC6:008000847FFE08880888149423E20490190863F604200B4030C001201E100000
+2FC7:010040847FFE441044107F7E4410555455545554555455546494A49684100000
+2FC8:04247FFE042007E000047FFE01001FF811081FF811081FF810080C30700E0000
+2FC9:00701F8001087FFE010007E0191862860D60711E0D6403800560191863060000
+2FCA:10081FFC1108192815481FF8110801003FF8010001007FFE2444222242220000
+2FCB:124812480A500A507FFE108820845FFE1084118412C414A41894109C10880000
+2FCC:3FFC224422443E7C224402403E7C22443E7C22443E7C22440242024201FE0000
+2FCD:07E0042027E4242427E4242427E424243E7C02407E7E12481248224842480000
+2FCE:08200820FF2408FE7E2000247FFE424442447E48422824101E30704E21840000
+2FCF:060838FC20083EF820083FF820080940252821082948252A210A294673820000
+2FD0:01000FF008100FF008100FF008101FF811081FF811087FFE0420042038200000
+2FD1:020001047FFE02483EB0152815282534592208100FF008100FF0101060100000
+2FD2:0080089008F80880FFFE044044444AA451147FFC44444AA451147FFC40040000
+2FD3:104008447F7E2240147C7F04007C3E40227C3E40227C3E40227E2E42243E0000
+2FD4:08400FE0084010807FFC11447F7C05447F6C05547D6C05447F7E05027CFC0000
+2FD5:01800660181863C600007BDE4A527BDE00003FFC22443FFC2244225C22480000
+2FD6:00007FFE61867DBE618E6FBE61BE7FFE7FFE63CE6DBE6D8E6DB663CE7FFE0000
+2FD7:00007FFE61867DBE618E6FBE61BE7FFE7FFE63866DF66DEE6DDE63DE7FFE0000
+2FD8:00007FFE61867DBE618E6FBE61BE7FFE7FFE63CE6DB66DCE6DB663CE7FFE0000
+2FD9:00007FFE61867DBE618E6FBE61BE7FFE7FFE63CE6DB66DC66DF663CE7FFE0000
+2FDA:00007FFE61867DBE618E6FBE61BE7FFE7FFE63866DB66D866DB663B67FFE0000
+2FDB:00007FFE61867DBE618E6FBE61BE7FFE7FFE638E6DB66D8E6DB6638E7FFE0000
+2FDC:00007FFE61867DBE618E6FBE61BE7FFE7FFE63C66DBE6DBE6DBE63C67FFE0000
+2FDD:00007FFE61867DBE618E6FBE61BE7FFE7FFE638E6DB66DB66DB6638E7FFE0000
+2FDE:00007FFE61867DBE618E6FBE61BE7FFE7FFE63866DBE6D8E6DBE63867FFE0000
+2FDF:00007FFE61867DBE618E6FBE61BE7FFE7FFE63866DBE6D8E6DBE63BE7FFE0000
+2FE0:00007FFE61867DBE618E6FBE61BE7FFE7FFE61CE6FB663B66FB661CE7FFE0000
+2FE1:00007FFE61867DBE618E6FBE61BE7FFE7FFE61EE6FCE63EE6FEE61C67FFE0000
+2FE2:00007FFE61867DBE618E6FBE61BE7FFE7FFE61866FF663866FBE61867FFE0000
+2FE3:00007FFE61867DBE618E6FBE61BE7FFE7FFE618E6FF663C66FF6618E7FFE0000
+2FE4:00007FFE61867DBE618E6FBE61BE7FFE7FFE61B66FB663866FF661F67FFE0000
+2FE5:00007FFE61867DBE618E6FBE61BE7FFE7FFE61866FBE63866FF661867FFE0000
+2FE6:00007FFE61867DBE618E6FBE61BE7FFE7FFE61CE6FBE638E6FB661CE7FFE0000
+2FE7:00007FFE61867DBE618E6FBE61BE7FFE7FFE61866FF663EE6FDE61DE7FFE0000
+2FE8:00007FFE61867DBE618E6FBE61BE7FFE7FFE61CE6FB663CE6FB661CE7FFE0000
+2FE9:00007FFE61867DBE618E6FBE61BE7FFE7FFE61CE6FB663C66FF661CE7FFE0000
+2FEA:00007FFE61867DBE618E6FBE61BE7FFE7FFE61866FB663866FB661B67FFE0000
+2FEB:00007FFE61867DBE618E6FBE61BE7FFE7FFE618E6FB6638E6FB6618E7FFE0000
+2FEC:00007FFE61867DBE618E6FBE61BE7FFE7FFE61C66FBE63BE6FBE61C67FFE0000
+2FED:00007FFE61867DBE618E6FBE61BE7FFE7FFE618E6FB663B66FB6618E7FFE0000
+2FEE:00007FFE61867DBE618E6FBE61BE7FFE7FFE61866FBE638E6FBE61867FFE0000
+2FEF:00007FFE61867DBE618E6FBE61BE7FFE7FFE61866FBE638E6FBE61BE7FFE0000
+2FF0:EDB600008102810200008102810200008102810200008102810201008002B6DA
+2FF1:EDB6000080028002800200008002800236D8800280020000800280020000EDB6
+2FF2:EDB600008442844280020440844280020440844280020440844284420000EDB6
+2FF3:EDB600008002800280020000B6DA800200008002B6DA0000800280020000EDB6
+2FF4:AAAA00008002155080021010800210108002101090120000955280020000AAAA
+2FF5:DBB60000800280020D608822800208208002882288220000882288220000DBB6
+2FF6:DBB600008822882200008822882200008822800288220D60800280020000DBB6
+2FF7:DB6D000180008001056D84008001040180008401056D8000800100018000B6DB
+2FF8:DB6D0001800080010B6D8800800108018800800108018800800108018800B6DB
+2FF9:DB6D00018000800136D18010800100118010800100118010800100118010B6DB
+2FFA:DB6D08018800800108018800800108018800800108018B6C800100018000B6DB
+2FFB:0000DB60802000009B6C902400009024902400009024DB64000010041B6C0000
+2FFC:00007FFE61867DBE618E6FBE61BE7FFE7FFE61C66FBE63BE6FBE6FC67FFE0000
+2FFD:00007FFE61867DBE618E6FBE61BE7FFE7FFE618E6FB663B66FB66F8E7FFE0000
+2FFE:00007FFE61867DBE618E6FBE61BE7FFE7FFE61866FBE638E6FBE6F867FFE0000
+2FFF:00007FFE61867DBE618E6FBE61BE7FFE7FFE61866FBE638E6FBE6FBE7FFE0000
+3000:0000000000000000000000000000000000000000000000000000000000000000
+3001:000000000000000000000000000010000C000600020000000000000000000000
+3002:000000000000000000000000000000000C00120012000C000000000000000000
+3003:0000000000000240024002400480048009000900000000000000000000000000
+3004:0000060018202030412841A881448D0493044908440824101860018000000000
+3005:00000000020001000100023003C8041008201240218000800040000000000000
+3006:0000000000100008001006200940088009401220141018003000200000000000
+3007:0000078018602010400840088004800480048004400840082010186007800000
+3008:0008000800100010002000200040008000400020002000100010000800080000
+3009:1000100008000800040004000200010002000400040008000800100010000000
+300A:0048004800900090012001200240048002400120012000900090004800480000
+300B:1200120009000900048004800240012002400480048009000900120012000000
+300C:00F8008000800080008000800080008000800080008000000000000000000000
+300D:000000000000000001000100010001000100010001000100010001001F000000
+300E:01F801080178014001400140014001400140014001C000000000000000000000
+300F:0000000000000000038002800280028002800280028002801E8010801F800000
+3010:00F800F000E000E000E000C000C000C000C000C000C000E000E000F000F80000
+3011:1F000F00070007000300030003000300030003000300070007000F001F000000
+3012:00007FFE000000007FFE01000100010001000100010001000100010000000000
+3013:3FFE3FFE3FFE3FFE3FFE0000000000003FFE3FFE3FFE3FFE3FFE000000000000
+3014:0008001000200040004000400040004000400040004000400020001000080000
+3015:1000080004000200020002000200020002000200020002000400080010000000
+3016:03F8021002200240024002800280028002800280024002400220021003F80000
+3017:1FC008400440024002400140014001400140014002400240044008401FC00000
+3018:0008003000500050005000500050005000500050005000500050003000080000
+3019:10000C000A000A000A000A000A000A000A000A000A000A000A000C0010000000
+301A:00F800A000A000A000A000A000A000A000A000A000A000A000A000A000F80000
+301B:1F0005000500050005000500050005000500050005000500050005001F000000
+301C:0000000000000000000000003E004182007C0000000000000000000000000000
+301D:0090004800240000000000000000000000000000000000000000000000000000
+301E:0900120024000000000000000000000000000000000000000000000000000000
+301F:0000000000000000000000000000000000000000000000000900120024000000
+3020:00003FFC3FFC00003FFC3FFC5596D9B9A5A5A5A5599A4182242413C8081007E0
+3021:0180010001000100010001000100010001000100010001000100010000000000
+3022:006000400C400840084008400840084008400840084000400040004000000000
+3023:0008200821082108210821082108210821082108210820082008000800000000
+3024:001000101020082004400240018000C001200210040808083000000000000000
+3025:00000420043008201CC003000480084008201020102010201040084007800000
+3026:00000100008000847FFE00000000000000000000000000000000000000000000
+3027:000001000100010001003FFC0000000000003FFC000000000000000000000000
+3028:0100010001007FFE0000000000003FFC00000000000000007FFE000000000000
+3029:0800080008000FFC10102810042002200140008000C0012002100C1030000000
+302A:0000000000000000000000000000000000000000000000006000900090006000
+302B:0000600090009000600000000000000000000000000000000000000000000000
+302C:0000000600090009000600000000000000000000000000000000000000000000
+302D:0000000000000000000000000000000000000000000000000006000900090006
+302E:00000000000000000000000000000000C000C000000000000000000000000000
+302F:000000000000000000000000C000C0000000C000C00000000000000000000000
+3030:000000000000000000000000618692490C300000000000000000000000000000
+3031:0100018001000200020004000800100010000800040002000100010000800080
+3032:0100018001100208024804200820100010000800040002000100010000800080
+3033:0400060004000800080008001000100010002000200020004000400080008000
+3034:0400060004400820088008401040100010002000200020004000400080008000
+3035:8000800040002000200010001000080008000400040002000200010001000000
+3036:07C0183020085FF45FF480029FF29FF2810281028102410441042108183007C0
+3037:8282828282824444444428282828101010102828282844444444828282828282
+3038:010001000100010001000100FFFE010001000100010001000100010001000000
+3039:082008200820082008200820FFFE082008200820082008200820082008200000
+303A:10881088108810881088FFFE1088108810881088108820882088408880080000
+303B:0000000002000100008000400080010000800040002000000000000000000000
+303C:0000000000003FF82018202820482088210822082408280830083FF800000000
+303D:0000000010002860449003100010001000100010001000100008000800040000
+303E:DB6D80010E00918980710000801180211FF8808181011FF8840188000001DB6D
+303F:00FE82C6C6AAAA92AAAAC6C682FE0000
+3040:00007FFE63CE7DB671B67DB663CE7FFE7FFE6DCE6DB661B67DB67DCE7FFE0000
+3041:00000000000000000400020013800E00048007E00D10161026102A2010C00000
+3042:00000400020002C01F000480048007E00D101508220826082A10106000000000
+3043:000000000000000000000000000010401020101010300A000C00040000000000
+3044:0000000000000000400020602010200822082418140818000800000000000000
+3045:0000000000000000000002000180000013800C40004000400040008003000000
+3046:0000020001C00000000003C01C20002000200020002000400040008001000000
+3047:0000000000000000000002000180000001C00E80010002000700090010F00000
+3048:0000040003800000000011C00E800100020004000E001100210020F800000000
+3049:00000000000000000000104008300C2038000BC00C201820282018C008000000
+304A:00000000080004300508060C1C000460059006080C0834880C70040000000000
+304B:0000000008000400046047103C88089808800880108011002500220000000000
+304C:0000000808240410044047203C90088808980880108011002500220000000000
+304D:00000200010001600F80008000F01F400020002007F008100800060001C00000
+304E:00000408022402D01F00010001E03E80004000400FE0102010000C0003800000
+304F:0000008000400040008001000600080008000400020001000080004000400000
+3050:0000008000400040008801240610080008000400020001000080004000400000
+3051:00000080204010201020103C23E0202020202020202018201040104000800000
+3052:0000010840A420502040207847C0404040404040404030402080208001000000
+3053:00000000080007E00080010000000000000000002000200010100FE000000000
+3054:00000008080407F00088010000000000000000002000200010100FE000000000
+3055:000004000200013021C01E800040004007E00820100010000C0003C000000000
+3056:000004080204013021C81E800040004007E00820100010000C0003C000000000
+3057:0000000010000800080008000800080008000800080808100460038000000000
+3058:0000000010200890084008000800080008000800080808100460038000000000
+3059:00000100008040F83F800080038004C0044003C0004000800080010002000000
+305A:00000128009440F83F800080038004C0044003C0004000800080010002000000
+305B:0000000000801040084008784BC03C400840084008C00840040003E000000000
+305C:0000000800841050084808784BC03C400840084008C00840040003E000000000
+305D:0000000009C0064000800100023807C038800100020002000200010000E00000
+305E:0000000009C8066400900100023807C038800100020002000200010000E00000
+305F:000000000800048007003C0008F008180820100010001100210020F800000000
+3060:000000080824049007003C0008F008180820100010001100210020F800000000
+3061:00000800040004C047003C00080008C00B201C1010100010002000C007000000
+3062:00000800040804C447103C08080008C00B201C1010100010002000C007000000
+3063:000000000000000000000000000001C00620381000100010002000C007000000
+3064:000000000000000003E04C103008000800080008001000600380000000000000
+3065:000000080024001003E04C103008000800080008001000600380000000000000
+3066:00000000003843C03C800100010002000200020002000200010000E000000000
+3067:00000000003843C03C880124011002000200020002000200010000E000000000
+3068:000000000400020002000200027003800600080010001000080007F000000000
+3069:000000000408022402100200027003800600080010001000080007F000000000
+306A:00000400020002803F0004700818082010401040204003C00460045003800000
+306B:000000002000100010F01318202020002000200022002A0011F8100010000000
+306C:0000000001000080008013E01510190812082A084C084C685490206800000000
+306D:000010000800080008004CE03F100C1008101810181028F0591808E000000000
+306E:00000000000003C00D2011101108220822082408241028101060018000000000
+306F:0000004020201020143813E0202020202020202029E01230122811C000000000
+3070:0000008840442050287827C0404040404040404053C024602450238000000000
+3071:0000009840642064287827C0404040404040404053C024602450238000000000
+3072:00000000004004403C2008200830102810201020104010400880070000000000
+3073:00000008004404503C2808200830102810201020104010400880070000000000
+3074:00000030004804483C3008200830102810201020104010400880070000000000
+3075:00000000040003800080010002000200010002B04C88389C2480030000000000
+3076:000000000400038800A4011002000200010002B04C88389C2480030000000000
+3077:000000000400039800A4012402180200010002B04C88389C2480030000000000
+3078:0000000000000000000006000900108020400030000C00000000000000000000
+3079:0000000000000010004806200900108020400030000C00000000000000000000
+307A:0000000000300048004806300900108020400030000C00000000000000000000
+307B:00000000223011C01040103823E020202020202029E01230122811C000000000
+307C:00000000446823842090207847C040404040404053C024602450238000000000
+307D:00000018446423A42098207047C040404040404053C024602450238000000000
+307E:00000100008010F00F80008010E00F80008000800F8010E010900F0000000000
+307F:000000000880078001000100022002100FF03418442448203040008000000000
+3080:00000800040027001C3004081C0C240024002C2018100810081007E000000000
+3081:0000000001000080108013C01CA0111029082A08460844084A10306000000000
+3082:00000200010011000E000380120024201C200710041004100410022001C00000
+3083:000000000000000000000100088009E00E103C10046002000200010001000000
+3084:00000100008001C0180010F00B084C0834080270020001000100008000800000
+3085:000000000000000000000200010021E0271029103110232021C0010002000000
+3086:000000000300408021E022902488288830883488229021E00080010002000000
+3087:000000000000000002000100012001C00100010001000F0011C011200E000000
+3088:0000020001000100013001C001000100010001001F80216021101E0000000000
+3089:00000200010001C0060008000800080009E00E1008100810002000C003000000
+308A:0000100009800A400C200C200820082008200820004000400080010002000000
+308B:0000000008C0074000800100020007C00C201010201003900460044003800000
+308C:000000001000080009C00A201C206C2008201820182028204824181808000000
+308D:0000000011800E800100020004000FC00820101020100010002000C007000000
+308E:0000000000000000000008000400040006E01D1006100C100C10142004400000
+308F:000010000800080008004CE03F100C080808180818082810482018C008000000
+3090:00000000098006800100010003E00E1012082408240828C8193010E000000000
+3091:0000000009800700020007C008201020062009C0070008001CE0231040380000
+3092:00000400020012C00F00040004200F3818C02180028004800800080007E00000
+3093:000002000100010002000200040004000F000880108010882090206000000000
+3094:0000020001C80004001003C81C20002000200020002000400040008001000000
+3095:00000000000000000000040004603F1004880898108011002500220000000000
+3096:0000000000000080004008200820083811E01020102014201440084000800000
+3097:00007FFE63CE7DB671B67DB663CE7FFE7FFE73866DF671EE7DDE73DE7FFE0000
+3098:00007FFE63CE7DB671B67DB663CE7FFE7FFE73CE6DB671CE7DB673CE7FFE0000
+3099:0000000400120008000000000000000000000000000000000000000000000000
+309A:0000000600090009000600000000000000000000000000000000000000000000
+309B:0000100048002000000000000000000000000000000000000000000000000000
+309C:0000300048004800300000000000000000000000000000000000000000000000
+309D:000000000000000000000C000300008000C00100000000000000000000000000
+309E:000000000000002000900C400300008000C00100000000000000000000000000
+309F:000000000600018008000800080008000FC0102000100010002000C003000000
+30A0:000000000000000000000000000007E000000000000007E00000000000000000
+30A1:000000000000000000000000000021E01E200240018001000100020004000000
+30A2:00000000000021F01E1000200240018001000100010002000200040008000000
+30A3:0000000000000000000000200040008003801C80008000800080008000800000
+30A4:00000000002000200040008003000D0030800080008000800080008000800000
+30A5:000000000000000000000200010001E01E200820084000400080010002000000
+30A6:0000000002000100010001F03E10101010200820084000400080010002000000
+30A7:000000000000000000000000000000E00F0001000100010001E01E1000000000
+30A8:000000000000000000701F800200010001000100010003F03C08000000000000
+30A9:000000000000000000000100008010E00F800180028004800880118000800000
+30AA:0000000000800040004020781FC000C00140024004400840104000C000400000
+30AB:0000000002000100010021F01F1002100210042004200820114020C000800000
+30AC:0000000802240114011021F01F1002100210042004200820114020C000800000
+30AD:0000000004000200027003801D000100017803803C8000800040004000400000
+30AE:0000000804240214027003801D000100017803803C8000800040004000400000
+30AF:0000000004000270039002200420044008401080008001000200040008000000
+30B0:00000008082404D4075004400840088010802100010002000400080010000000
+30B1:0000000008000400040004380FC0090010802080008001000100020004000000
+30B2:0000000808240414041004380FC0090010802080008001000100020004000000
+30B3:000000000000000021F01E100010001000100020002003E01C20000000000000
+30B4:000000080024001443D03C400040004000400080008007803880000000000000
+30B5:00000000008008400440044024F81F4004400440044000800080010002000000
+30B6:0000000800A408540450044024F81F4004400440044000800080010002000000
+30B7:0000000000000C000200000018000408001000200040008013000C0000000000
+30B8:0000000000080C240214001018000408001000200040008013000C0000000000
+30B9:00000000000010E00F200040004000800080014002200C103010000000000000
+30BA:00000008002421D41E5000800080010001000280044018206020000000000000
+30BB:000000000800040004000478058826101C20044004000400020001F000000000
+30BC:000000080824041404100478058826101C20044004000400020001F800000000
+30BD:0000000000201010081004100420042000400040008000800100020004000000
+30BE:0000000800A42054105008400840084000800080010001000200040008000000
+30BF:000000000200010001F002100220052008C010400080010002000C0030000000
+30C0:000000080424021403F0042004200A4011402080010002000400180060000000
+30C1:00000000004001801E00010000F823801C800080008001000100020004000000
+30C2:00000008006401941E10010000F823801C800080008001000100020004000000
+30C3:0000000000000000000000000000044012200A20084000400080010002000000
+30C4:0000000000000410220811080910081000200020004000800100020000000000
+30C5:0000000800241094085044402440104010800080010002000400080000000000
+30C6:00000000000011E00E000000007823801C800080010001000200040008000000
+30C7:00000008002411D40E10000020F01F0000800080010001000200040008000000
+30C8:0000000008000400040004000400070004C00420040004000400040004000000
+30C9:00000020109008500840080008000E0009800840080008000800080008000000
+30CA:0000000001000080008020F81F80008000800080010001000200040008000000
+30CB:000000000000000000E01F00000000000000000001F03E080000000000000000
+30CC:00000000000010F00F10002000200E4001C000C0012002100C10300000000000
+30CD:000000000200010001E01E2000400080010003400D3031080100010001000000
+30CE:0000000000400020002000200040004000800080010002000400080010000000
+30CF:0000000000000000000008800440042008100810100820084008000000000000
+30D0:0000000000080024001408900440042008100810100820084008000000000000
+30D1:0000001800240024001808800440042008100810100820084008000000000000
+30D2:00000000000010000800080008E00F000800080008000800040003F000000000
+30D3:000000000010104808280820080008E00F00080008000800040003F000000000
+30D4:000000000030104808480830080008E00F00080008000800040003F000000000
+30D5:00000000000010F00F1000100020002000400040008001000200040000000000
+30D6:00000008002423D41C5000400080008001000100020004000800100000000000
+30D7:00000018002423E41C5800400080008001000100020004000800100000000000
+30D8:0000000000000000000002000500488030400030000C00000000000000000000
+30D9:0000000000200090005002400500488030400030000C00000000000000000000
+30DA:0000000000600090009002600500488030400030000C00000000000000000000
+30DB:0000000002000100010021F01F00010001400920091011102100030001000000
+30DC:0000000802240114011021F01F00010001400920091011102100030001000000
+30DD:0000001802240124011821F01F00010001400920091011102100030001000000
+30DE:000000000000000020F01F080010002000400C80030000800040000000000000
+30DF:000000000400030000C00020080006000180004010000C00030000C000200000
+30E0:0000000002000100010001000200020002400420043029C81E08000000000000
+30E1:000000000040002000200020062001C0004000A00090010002000C0030000000
+30E2:00000000000010E00F000200020023F81E0002000200020001F0000000000000
+30E3:0000000000000000000000000400027003901E20014001000080008000800000
+30E4:00000000080004000478038826101A2001400100010000800080008000000000
+30E5:000000000000000000000000000001C00E400040008001E01E10000000000000
+30E6:0000000000000000000011C00E4000400080008001F03E080000000000000000
+30E7:00000000000000000000000001E00E20002001E00E40004001C00E2000000000
+30E8:00000000000001F01E100010001001E00E2000200020002001E00E1000000000
+30E9:00000000000011C00E00007023901C100010002000200040008003000C000000
+30EA:0000000000400820042004200420042004200420004000400080010002000000
+30EB:0000000000000100088004800480048804880490089008A010C0208000000000
+30EC:0000000010000800080008000800080008100820084008800B000C0000000000
+30ED:000000000000000021F01E10101010100820082009E00E100800000000000000
+30EE:000000000000000000000000000010F00F100820042004400040008001000000
+30EF:00000000000021F01E1010100810082008200040004000800100020004000000
+30F0:0000000001000080008001F01E800880048005F03E8800800080008000800000
+30F1:000000000000000001E01E20024001800100010001F03E080000000000000000
+30F2:00000000000001F01E100010002001E00E200040004000800100060018000000
+30F3:00000000000000001800040802080010001000200040008013000C0000000000
+30F4:0000000804240214021043E03C20202010401040008000800100020004000000
+30F5:0000000000000000000000000200010011E00E2002200220042008C010400000
+30F6:0000000000000000000000000800040004600780088010800100020004000000
+30F7:00040012000821F01E1010100810082008200040004000800100020004000000
+30F8:0000000801040090008801F01E800880048005F03E8800800080008000800000
+30F9:000000080004001001E81E20024001800100010001F03E080000000000000000
+30FA:00040002000801F41E100010002001E00E200040004000800100060018000000
+30FB:0000000000000000000000000300078007800300000000000000000000000000
+30FC:000000000000000000000000000040F83F000000000000000000000000000000
+30FD:000000000000000000000C000300008000400020000000000000000000000000
+30FE:000000000000002000900C400300008000400020000000000000000000000000
+30FF:0000000021E01E10001000100010001000100010001000100010001000100000
+3100:00007FFE63EE7DCE71EE7DEE63C67FFE7FFE73CE6DB66DB66DB673CE7FFE0000
+3101:00007FFE63EE7DCE71EE7DEE63C67FFE7FFE73EE6DCE6DEE6DEE73C67FFE0000
+3102:00007FFE63EE7DCE71EE7DEE63C67FFE7FFE73866DF66D866DBE73867FFE0000
+3103:00007FFE63EE7DCE71EE7DEE63C67FFE7FFE738E6DF66DC66DF6738E7FFE0000
+3104:00007FFE63EE7DCE71EE7DEE63C67FFE7FFE73B66DB66D866DF673F67FFE0000
+3105:0000000002000200040008001FF0001000100020004000400280010000000000
+3106:0000000001000100020007F00010001002200140008001400620380000000000
+3107:000000003FF81008100810081008100810081008100810080008000000000000
+3108:000000001FF810001000100010001000100010000FFC00000000000000000000
+3109:000002000200040008001FF8010801080208040808101010012000C000000000
+310A:0000000000400040008000807FFE010001000220021007F00008000800000000
+310B:000000000FE000200040008001F8000800100010002002200140008000000000
+310C:0000008000800480048008800FF80088010802100210041008A0104000000000
+310D:0000020802080410041008201040208010400820041004100208020800000000
+310E:000000003FFE01000200040007F8000800080010001002200140008000000000
+310F:000000000FFE0400040004000400080008000800100010002000000000000000
+3110:000000000020082008200820082008E00F200020002000200020002000000000
+3111:00000000001000200040008003000C0002000180004000300008000400000000
+3112:000000003FFE0080008000800080008000800080008000800080000000000000
+3113:0000010001002108210821082108210821083FF80100010001007FFC00000000
+3114:000000100060008001080610002000C003400440184000400040004000400000
+3115:000000000FFC00040004040407FC040004000400040008001000000000000000
+3116:0000000000003FF8200820082208210821082088208820083FF8000800000000
+3117:000000001FFC0104010401040108010801280110010001000100000000000000
+3118:000001000100010001003FFE01000100010001F8000800100020002000400000
+3119:000000000100010001000200020004000820101020083FFC0004000000000000
+311A:0000000020101020084004800300020002000200020002000200000000000000
+311B:000000003FFE00400040004007C00800100010001008081007E0000000000000
+311C:00000080008000803FFC0080008007800800100010001008081007E000000000
+311D:0000000004100410041004107FFE0410042004200440040003F0000000000000
+311E:000000001FFC0080088011001FF8010802080210041008201020004000000000
+311F:000000000180068038800080008000400040002000100010000C000000000000
+3120:00000000008001000200041008201FC000800100061018183FE4000400000000
+3121:000000000FF8000800100420024001C000C00130020804041804200000000000
+3122:000000001FF0041004200820084010803FF80008001000200040008000000000
+3123:0000100010001000100010001FFC000400080008001000100020000000000000
+3124:0000000000800080008001001FF8028002800480048008801080207E00000000
+3125:0000000000400040008001000100020004000400080010007FFC000000000000
+3126:000000000040044004400440044004400840084008401040203E000000000000
+3127:00000000000000000000000000003FFC00000000000000000000000000000000
+3128:00000008000804100220012000C000C001200210040808041004000000000000
+3129:000000001008100810081008100810081008100810081FF80008000000000000
+312A:000000007FFE020002000200020003F00410041004100810081010A020400000
+312B:000000007FFC04400440044004400440084008400840104010402040403C0000
+312C:00000100008000001FFE10001000100010001000100010002000200040000000
+312D:000000007FFC0100010001003FF8210821082108210821082108010001000000
+312E:00000180018000003FFC0080008007800800100010001008081007E000000000
+312F:000000001FE0004000800100020007F801080108010801080150012000000000
+3130:00007FFE63EE7DCE71EE7DEE63C67FFE7FFE63CE7DB671B67DB663CE7FFE0000
+3131:00000000000020081FFC08080008000800080008000800080008000000000000
+3132:00000000000041083FFC11080108010801080108010801080000000000000000
+3133:00000000000082607F1022100210023002280248024402820301000000000000
+3134:0000000000000000000030000800080008000800080807FC0000000000000000
+3135:00000000000000000204C1FE20A02020205023881D0402020000000000000000
+3136:00000000000000400038C40223FF21002078208423841C840078000000000000
+3137:000000000000000070101FF8100010001000100010080FFC0000000000000000
+3138:000000000000000062883FFC208020802080208023841C7E0000000000000000
+3139:00000000000020101FF80810001030101FF81000100010100FF8000000000000
+313A:00000000000082047FFE22840204FF044004400443043C040000000000000000
+313B:00000000000041443FFE114401447FC42044204423C41C7E0040000000000000
+313C:00000000000042083F04028402847EFC2084208423841CFC0000000000000000
+313D:00000000000084607E1024100410FE3040284048468439020000000000000000
+313E:00000000000042C43F7E024002447F7E2040204023441C3E0000000000000000
+313F:00000000000085087EFC04000400FE8440484048464A3BFF0000000000000000
+3140:00000000000084407E38050204FFFE0040384044464438380000000000000000
+3141:00000000000038100FF80810081008100810081008100FF80800000000000000
+3142:00000000002000101010081008100FF00810081008100FF00810000000000000
+3143:00000000000802842144114411441F7C1144114411441F7C1144000000000000
+3144:00000000000004604210221022103E102228222822443E442282000000000000
+3145:0000000002000180008000800080014001400220041008083004000000000000
+3146:00000000000008400420042004200A200A5011482084C3020000000000000000
+3147:0000000000000200010007C008201010101010101010082007C0000000000000
+3148:00000000000020101FF809000100010002800440082010106008000000000000
+3149:000000000000000081047FFE242004200A50095010882104C602000000000000
+314A:00000000040003E0000020081FFC088001400220041008083004000000000000
+314B:00000000000010080FFC0408000800F83F081008000800080008000000000000
+314C:00000000000038200FF0080008200FF008000800081007F80000000000000000
+314D:00000000000020101FF80800000008100420022042483FFC1000000000000000
+314E:000000000000040003C040083FFC100003C0042008100810042003C000000000
+314F:004000300010001000100012001F001000100010001000100010001000100000
+3150:0020011800C80048004800480078004800480048004800480048004800080000
+3151:00400030001000100012001F00100012001F0010001000100010001000100000
+3152:0020011800C80048004800780048004800780048004800480048004800080000
+3153:004000300010001000100010001003F001100010001000100010001000100000
+3154:0010008C006400240024002403E4012400240024002400240024002400040000
+3155:0040003000100010001003F00110001003F00110001000100010001000100000
+3156:0010008C00640024002403E40124002403E40124002400240024002400040000
+3157:000000000000000000000000010000800080008040823FFF1000000000000000
+3158:00400030001000100010001008100412041F05F07E1020100010001000100000
+3159:0010008C00640024002408240424043C042407E47C2420240024002400040000
+315A:00200018000800080008040802080208020803F87E0820080008000800080000
+315B:000000000000000000000000004004200220022042223FFF1000000000000000
+315C:00000000000000000000000040023FFF10800080008000800080008000800000
+315D:00200018000800080008000801E87E08280809F8088808080808080800080000
+315E:002000980048004800480048004803C87C4828480BC808480848084800080000
+315F:002000180008000800080008000801E87E082408040804080408040800080000
+3160:00000000000000000000000040023FFF12200220022002200220022002200000
+3161:00000000000000000000000000000000000040023FFF10000000000000000000
+3162:0020001800080008000800080008000801F87E08200800080008000800080000
+3163:0040003000100010001000100010001000100010001000100010001000100000
+3164:AAAA00018000000180000001913C11219F381121912000018000000180005555
+3165:000000000000C1802040204020402040204023441C3E00000000000000000000
+3166:000000000000C0C4207E204020402040204023421C3F00000000000000000000
+3167:000000000000C0202010201020102010202823481C8401020000000000000000
+3168:000000000000C0102010202820282044204423821CFF00000000000000000000
+3169:00000000000088507FE808480848FC54405440623C4100000000000000000000
+316A:00000000000042C83F7C024002407F402040204023441C3E0000000000000000
+316B:00000000000088907C480A480A48FFD442544E6233C100000000000000000000
+316C:0000000084207E2004200450FC504088408847043BFE00000000000000000000
+316D:00000000000084007E00050404FEFE4040384044464438380000000000000000
+316E:000000000000000862843F442244227C2244224422443F7C2044000000000000
+316F:00000000000062203F10221022102210222822283E4422820000000000000000
+3170:00000000000062103F102228222822442244224422823FFF2000000000000000
+3171:000030081FFC1008100810081FFC1100008007E0081010081008081007E00000
+3172:00000000000004000282827F42227E024202420242027E024202000000000000
+3173:00000000040002C8827C424042407E404240424042447E3E4200000000000000
+3174:000000000000114288BF48824882798249424A427A224C120000000000000000
+3175:0000000000001132889F48904890799049504A507A524C2F0000000000000000
+3176:0000000000000800860445FE44A07C20442044507C8847060000000000000000
+3177:00000000040002C4827E424042447E7E4240424042447E3E4200000000000000
+3178:0010200810081FF8100810081FF81108008007E0081010081008081007E00000
+3179:0010248812481E78124812481E781248008007E0081010081008081007E00000
+317A:000000000000090404FE044404040A040A0411042104C0840000000000000000
+317B:00000000000008000580044006400A400A401140214440BE0000000000000000
+317C:00000000000010C4087E08400840144014402240414480BE0000000000000000
+317D:000000000004100208820842087E144214422242217E40C20000000000000000
+317E:000000000000120209FF08900810142814282244414281810000000000000000
+317F:000000000100010002800280044004400820082010103FF80000000000000000
+3180:00000000181808083C3C4242424242424242424242423C3C0000000000000000
+3181:0000030001000FE0101020082008200820082008200810100FE0000000000000
+3182:00003000120479FE84A08420842084508450848885047A020000000000000000
+3183:000030001020782084508450848884888488850485047BFE0000000000000000
+3184:000020101FF80000042042483FFC1100008007E0081010081008081007E00000
+3185:0000000020401C3881027FFF20001C382244224422441C380000000000000000
+3186:0000000040083FFC1200010007C0082008200820082007C00000000000000000
+3187:004000300010001000100912091F091009F27E1F201000100010001000100000
+3188:0020011800C800480048047802482248127813C87C4820480048004800080000
+3189:0020001800080008000802081108090809080BE87C0820080008000800080000
+318A:00200018000800080008000801E87F0829780908097809080908090800080000
+318B:0020011800C80048004800480348FC4855C8144815C814481448004800080000
+318C:002000180008000800080008000801E87F082908090809080908090800080000
+318D:0000000000000000000000000100038001000000000000000000000000000000
+318E:0020001800080008000800080008000802080708020800080008000800080000
+318F:00007FFE63EE7DCE71EE7DEE63C67FFE7FFE73866DBE738E6DBE73BE7FFE0000
+3190:0000000000800080008000800080008000800000000000000000000000000000
+3191:0000000002000200020002200240028003000000000000000000000000000000
+3192:000000000000000000003FC00000000000000000000000000000000000000000
+3193:0000000000001F800000000000003FC000000000000000000000000000000000
+3194:000000001FE000000FC0000000003FF000000000000000000000000000000000
+3195:000000003FE02520252028E020203FE000000000000000000000000000000000
+3196:000000000400040007800400040004003FC00000000000000000000000000000
+3197:0000040004003FC0244024403FC0040004000400000000000000000000000000
+3198:000000003FC00400060005000400040004000000000000000000000000000000
+3199:000000003FC022403FC022403FC0224002000200000000000000000000000000
+319A:000000003F80030004000800104020401FC00000000000000000000000000000
+319B:000000003FE002003FE02220232024A028600000000000000000000000000000
+319C:000000003FE0020002000200020002000A000400000000000000000000000000
+319D:000000001FC0020002003FE00200050008E01040000000000000000000000000
+319E:0000084009503DF00B50095009280D0830F80000000000000000000000000000
+319F:000004000400040004000A000900108020400000000000000000000000000000
+31A0:00000800080010003FF800080008000800080008000800F00110012000C00000
+31A1:000000001FF8020802080208020802100290026002001E00220022001C000000
+31A2:0000002004200420042004200420086009A00E20002001E00220022001C00000
+31A3:0000000004400440088008801100110022001100110008B808C4044404380000
+31A4:000000000800080008007FFC080408080810080008000800080007F800000000
+31A5:000000000800080008007FFC080408080810080008180824082407F800080000
+31A6:000000007FFC0200020004000800100020002020104008800500020000000000
+31A7:000000007FFC0200020004000800100020C02120114008800560020000000000
+31A8:00000000101008200820044004400280028001FC028004401830600C00000000
+31A9:00000000201010200840048003000200020002000F801200220022001C000000
+31AA:00000000000000180024004400447FF800400040000000000000000000000000
+31AB:0000000010100820082004400440028002800100028C04521822605C00400000
+31AC:0000000020003FF8210821082108210821082108210821082108000000000000
+31AD:000000007FFC0920092009200920092009200920092009201120611E00000000
+31AE:000000007FFC01001100110021003FF801080108020832084C104A1032200000
+31AF:00000000008001000200041008201FC000800118062418243FF80010000C0000
+31B0:00001830044002807FFC41044104410441044104410441044104410441040000
+31B1:000000007FFC01007FFC41044704480450045044488445044204400440040000
+31B2:000000007FFC010001000100010001000100010001000100010001007FFC0000
+31B3:000000800080008000800080008000800080008003E004800880088007000000
+31B4:0000000000000000000000000100020007E00020002000200140008000000000
+31B5:0000000000000000000000000100020007E00120022004200940008000000000
+31B6:00000000000000000000000007E00100020007C0004000400140008000000000
+31B7:000000000000000000000000000007E002000200020002000400080000000000
+31B8:000000003FF80010002000400080010002000400080010003FF8000000000000
+31B9:0000000000002000200020002000200020003FF8000000000000000000000000
+31BA:00000000000001000100010001007FFC01000100010001000000000000000000
+31BB:0000000000000000000004400440088008801100088008800440044000000000
+31BC:000000000200043008300C4002C0018001800240046008301018201800000000
+31BD:00003FF80200043008300C4002C0018001800240046008301018201800000000
+31BE:000000001010101008200820082004403FF80440024002800280018001000000
+31BF:0000000000000440044004200420041004100810080808081008200800000000
+31C0:0000000000000000002000C003001C0008000000000000000000000000000000
+31C1:0400020002000100010001000100010001000100010001000100010005000200
+31C2:1000100010001000080008000800040004000200020001000090005000200000
+31C3:000000000000000000008000400020001804060201FC00000000000000000000
+31C4:00000800080008000800080008000800080008000800080008000FF000000000
+31C5:000000003F00010001000100010001000100010001000100010001F000000000
+31C6:0000000000003FF0001000100010001000100010001000100010005000200000
+31C7:000000001FF80008000800080008001000100020002000400040008001000200
+31C8:000000007F80008000800080008000800080008000800080008200820082007C
+31C9:00002000200020002000200020003FF800080008000800080010001000A00040
+31CA:000000000F80008000800080008000800080009000A000C00080000000000000
+31CB:000000003FFC000800100020007C000400040004000800080010002000400080
+31CC:000003E000200040008000800040004000200020002000200140008000000000
+31CD:0000000000007F800080008000800080008000800040003E0000000000000000
+31CE:000000003F80008000800080008000F000100010001000100010001000100000
+31CF:0000080008000800080004000400020002000100010000800040002000140008
+31D0:00000000000000000000000000007FFE00000000000000000000000000000000
+31D1:0000010001000100010001000100010001000100010001000100010001000000
+31D2:0000000000200020004000400080010002000400000000000000000000000000
+31D3:0000004000400040004000400040004000800080010001000200040008000000
+31D4:0000000000000000040002000100008000400040000000000000000000000000
+31D5:0000000000001FF8000800080008000800080008000800080008000800000000
+31D6:0000000000007FFC000800100000000000000000000000000000000000000000
+31D7:00000000100010001000100010001000100010001000100010001FFC00000000
+31D8:0000001000100010001000100010001000100010001000103FF0001000000000
+31D9:0000040004000400040004000400040004200440048005000600040000000000
+31DA:0000008000800080008000800080008000800080008000800080028001000000
+31DB:0000004000400080008001000200040002000100008000400020000000000000
+31DC:00000040004000800080010001000200040008001FF800000000000000000000
+31DD:0000080008001400240002000200010001000080004000200010000A00040000
+31DE:00002000200020002000200020003FF800080008000800080008000800080000
+31DF:0000080008000800080008000800080008000800080008080808080807F80000
+31E0:00007FF00020004000800100020004000800100020004004400440063FFC0000
+31E1:000000003FF8001000100020007C000400040004000400040008002800100000
+31E2:0000000000100010002000200040004000800080010001002200240038000000
+31E3:0000000000001FF020084004400440044004400420081FF00000000000000000
+31E4:00007FFE63EE7DCE71EE7DEE63C67FFE7FFE61B66FB663866FF661F67FFE0000
+31E5:00007FFE63EE7DCE71EE7DEE63C67FFE7FFE61866FBE63866FF661867FFE0000
+31E6:00007FFE63EE7DCE71EE7DEE63C67FFE7FFE61CE6FBE638E6FB661CE7FFE0000
+31E7:00007FFE63EE7DCE71EE7DEE63C67FFE7FFE61866FF663EE6FDE61DE7FFE0000
+31E8:00007FFE63EE7DCE71EE7DEE63C67FFE7FFE61CE6FB663CE6FB661CE7FFE0000
+31E9:00007FFE63EE7DCE71EE7DEE63C67FFE7FFE61CE6FB663C66FF661CE7FFE0000
+31EA:00007FFE63EE7DCE71EE7DEE63C67FFE7FFE61866FB663866FB661B67FFE0000
+31EB:00007FFE63EE7DCE71EE7DEE63C67FFE7FFE618E6FB6638E6FB6618E7FFE0000
+31EC:00007FFE63EE7DCE71EE7DEE63C67FFE7FFE61C66FBE63BE6FBE61C67FFE0000
+31ED:00007FFE63EE7DCE71EE7DEE63C67FFE7FFE618E6FB663B66FB6618E7FFE0000
+31EE:00007FFE63EE7DCE71EE7DEE63C67FFE7FFE61866FBE638E6FBE61867FFE0000
+31EF:00007FFE63EE7DCE71EE7DEE63C67FFE7FFE61866FBE638E6FBE61BE7FFE0000
+31F0:00000000000000000000000040002E0032002400440008001000200040000000
+31F1:0000000000000000000000000000600010000000610012000400480030000000
+31F2:00000000000000000000000000008E00720004000400080014002200C2000000
+31F3:0000000000000000000000002000200020003000280024002000200020000000
+31F4:00000000000000000000000000008E00720004003400080014002200C2000000
+31F5:0000000000000000000000000000048002400220042008101010000000000000
+31F6:0000000000000000000000004000400040004E0070004000400040003E000000
+31F7:00000000000000000000000000008E00720004000400080010002000C0000000
+31F8:0000000000000000000000000000000000000200050008C00030000000000000
+31F9:00000000000000000000200010001E00F0001000540092001000500030000000
+31FA:000000000000000000000000020001000100010001000200022014D00F080000
+31FB:0000000000000000000000008C00700000008E00720002000400080070000000
+31FC:0000000000000000000000000000880044004400440004000400080030000000
+31FD:0000000000000000000000000240012001200120012001240224042808300000
+31FE:0000000000000000000000000000800040004000400044004800500060000000
+31FF:00000000000000000000000000F01F10101010101020102011F01E0000000000
+3200:00001818200440024FF240124012401240124012401240124002200418180000
+3201:000018182004400244024402440244024402440247FA40024002200418180000
+3202:000018182004400240024FF2480248024802480248024FF24002200418180000
+3203:00001818200440024FF2401240124FF24802480248024FFA4002200418180000
+3204:000018182004400240024FF248124812481248124FF240024002200418180000
+3205:00001818200440024812481248124FF24812481248124FF24002200418180000
+3206:0000181820044082408240824142414242224412480A40024002200418180000
+3207:000018182004400243C244224812481248124812442243C24002200418180000
+3208:00001818200440025FF241024102428242824442482250124002200418180000
+3209:00001818200443E2400240024FFA4082414242224412480A4002200418180000
+320A:00001818200440024FF2401240125FF240124012401240124012200418180000
+320B:00001818200440024FF2480248024FF24802480248024FF24002200418180000
+320C:000018182004400240024FF2400244224422424242425FFA4002200418180000
+320D:000018182004400243C240025FFA400243C244224422442243C2200418180000
+320E:00001818202440225FA240A2413E422244224822502260224022202418180000
+320F:0000181820244022502250225022503E50225FE2402240224022202418180000
+3210:00001818202440225FA250225022503E50225FA2402240224022202418180000
+3211:00001818202440225FA240A240A25FBE502250225FA240224022202418180000
+3212:000018182024402240225F225122513E51225F22402240224022202418180000
+3213:0000181820244022512251225F22513E51225F22402240224022202418180000
+3214:0000181820244022442244224A224A3E512260A2402240224022202418180000
+3215:00001818202440224E2251225122513E512251224E2240224022202418180000
+3216:00001818202440225FE242224222453E452248A2506240224022202418180000
+3217:000018182024472240225FE24222423E452248A2506240224022202418180000
+3218:00001818202440225FA240A27F22423E44224822502260224022202418180000
+3219:00001818202440225FA250225FA2503E50225FA2402260224022202418180000
+321A:00001818202440225FA2402250A2493E49224BE27C2240224022202418180000
+321B:0000181820244F2240227FE240224F3E50A250A24F2260224022202418180000
+321C:0000301840049FF2810282828C62B01A8002BFFA810281028102410431180000
+321D:00003018400499EAA44AA4DAA52A992A800A88828882BEFA8002400430180000
+321E:30184004806299FAA462A492A4929862800288FA8822BE228022400430180000
+321F:00007FFE63867DF671867DBE63867FFE7FFE7B8673BE7B8E7BBE71BE7FFE0000
+3220:0000200840048002800280028012BFFA80028002800280028002400420080000
+3221:00002008400480229FF280028002800280028012BFFA80028002400420080000
+3222:0000200840249FF28002800280428FE2800280028012BFFA8002400420080000
+3223:0000200840048002BFFAA44AA44AA44AA44AA44ABFFA80028002400420080000
+3224:0000200840249FF28202820282229FF28422842284228422BFFA400420080000
+3225:000020084004820281028012BFFA800280028442842288129012400420080000
+3226:000020084204820282028212827A8382BE02820282028222822241E420080000
+3227:0000200840848482848284828482848288428822901AA0128002400420080000
+3228:000020084204820282429FE28242824282428442844A884A903A400420080000
+3229:000020084104810281028112BFFA810281028102810281028102400420080000
+322A:0000301847F48412841287F28412841287F28412841288529022400430180000
+322B:000030184104810289128922894291028282828284428822B01A400430180000
+322C:00003018410481028112BDA285428542892289229112A50A8202400430180000
+322D:00003018410481028102BFFA8102838285428922B11A81128102400430180000
+322E:000030184104828284428822B7DA81029FF2810289228542BFFA400430180000
+322F:0000301841048102810281029FF281028102810281028102BFFA400430180000
+3230:0000301840048FE28822882288228FE28822882288228FE28822400430180000
+3231:0000301848448942BDF28A429C429BFAA842A8E289528A4A8842400430180000
+3232:000030184204BFFA840287E28C2297E2A42287E2842284228462400430180000
+3233:0000301850448842BE42844289F28C429A42A842884288428BFA400430180000
+3234:00003018440487F284228A429182810287F2BC128412841287F2400430180000
+3235:000030184844A9F2BC42A842ABFA8C229BFAA92288A2882288E2400430180000
+3236:0000301840149E1293FA9E1292329E5292929F1280129252A122400430180000
+3237:0000301851F48912BF12831285F28CA29AA2AAA288AA892A8A1A400430180000
+3238:000030185214891289229FFA910AA1029FF28112821284129862400430180000
+3239:0000301844A48492888288FA9B82A88288828842884A882A881A400430180000
+323A:000030184034BBC2A84AAA4AA952AFFAB842A8428042804281C2400430180000
+323B:00003018491484A29FFA900A87E2804280829FFA808280828382400430180000
+323C:000030185F2494229F3A91429F52940A9F8280029FF29292BFFA400430180000
+323D:000030184104818282428422889AB08284E28482848284829FFA400430180000
+323E:0000301851048BFA844A9FE28C3A87E2842287E2842287E29C3A400430180000
+323F:00003018488489F28892BE92892289228FFA8AAA8AAA8CCA8912400430180000
+3240:0000301848FC8F9292A2AA4294228BD2900AAFF284A28A92B10A400430180000
+3241:000030184444844288428FFA9842A8E288E289528A4A8C428842400430180000
+3242:00003018420484028FE2882288228FE288228FE2882288228FE2400430180000
+3243:000030185FF48202844288229FF2810281028FE281028102BFF2400430180000
+3244:00003FF84004BEFAA28ABEFAA28ABEFAA00AA7CAA44AA44AA7CAA01A40043FF8
+3245:00003FF8400484428442884293FABE4A844A884A924ABD4A90AA811240043FF8
+3246:00003FF8400482028102BFFA84428442844282828282810286C2B83A40043FF8
+3247:00003FF840049EF2A5229FE289429FE28122BFFA81229FE28102830240043FF8
+3248:0000FC7EE00EC0068872988A088808880888888A888ABE72C006E00EFC7E0000
+3249:0000FC7EE00EC0069C72A28A028802881C88A08AA08ABE72C006E00EFC7E0000
+324A:0000FC7EE00EC0069C72A28A02880C880288828AA28A9C72C006E00EFC7E0000
+324B:0000FC7EE00EC006A472A48A24883E880488848A848A8472C006E00EFC7E0000
+324C:0000FC7EE00EC006BE72A08A20881C880288828AA28A9C72C006E00EFC7E0000
+324D:0000FC7EE00EC0069C72A28A20883C882288A28AA28A9C72C006E00EFC7E0000
+324E:0000FC7EE00EC006BE72A28A028804880488888A888A8872C006E00EFC7E0000
+324F:0000FC7EE00EC0069C72A28A22881C882288A28AA28A9C72C006E00EFC7E0000
+3250:000000000000000077DE491049104910711E4110411041104110411E00000000
+3251:00001FF0200840049C22A262822282229C22A022A022BEFA400420081FF00000
+3252:00001FF0200840049C72A28A820A820A9C72A082A082BEFA400420081FF00000
+3253:00001FF0200840049C72A28A820A82329C0AA00AA08ABE72400420081FF00000
+3254:00001FF0200840049C92A292829282FA9C12A012A012BE12400420081FF00000
+3255:00001FF0200840049CFAA282828282729C0AA00AA08ABE72400420081FF00000
+3256:00001FF0200840049C72A28A828282F29C8AA08AA08ABE72400420081FF00000
+3257:00001FF0200840049CFAA28A820A82129C12A022A022BE22400420081FF00000
+3258:00001FF0200840049C72A28A828A82729C8AA08AA08ABE72400420081FF00000
+3259:00001FF0200840049C72A28A828A828A9C7AA00AA08ABE72400420081FF00000
+325A:00001FF0200840049C72A28A828A8C8A828A828AA28A9C72400420081FF00000
+325B:00001FF0200840049C22A26282228C2282228222A2229CFA400420081FF00000
+325C:00001FF0200840049C72A28A820A8C0A82728282A2829CFA400420081FF00000
+325D:00001FF0200840049C72A28A820A8C32820A820AA28A9C72400420081FF00000
+325E:00001FF0200840049C92A29282928CFA82128212A2129C12400420081FF00000
+325F:00001FF0200840049CFAA28282828C72820A820AA28A9C72400420081FF00000
+3260:00000FF01008200440025FF2401240124012401240124012200410080FF00000
+3261:00000FF01008200440024802480248024802480248024FF2200410080FF00000
+3262:00000FF0100820044FF2480248024802480248024FF24002200410080FF00000
+3263:00000FF0100820044FF2401240124FF24802480248024FFA200410080FF00000
+3264:00000FF0100820044FF2481248124812481248124FF24002200410080FF00000
+3265:00000FF0100820044812481248124FF24812481248124FF2200410080FF00000
+3266:00000FF0100820844082408241424142422242224412480A200410080FF00000
+3267:00000FF01008200443C244224812481248124812442243C2200410080FF00000
+3268:00000FF01008200440024FFA40824082414242224412480A200410080FF00000
+3269:00000FF01008200443E240024FFA4082414242224412480A200410080FF00000
+326A:00000FF0100820044FF2401240125FF24012401240124012200410080FF00000
+326B:00000FF0100820044FE2480248024FE24802480248024FF2200410080FF00000
+326C:00000FF01008200440024FF2400244224222424242425FFA200410080FF00000
+326D:00000FF01008200447E240025FFA400243C24422442243C2200410080FF00000
+326E:00000FF0102820245FA240A2413E41224222442248225022202410280FF00000
+326F:00000FF010282024502250225022503E50225FE240224022202410280FF00000
+3270:00000FF0102820245FA250225022503E50225FA240224022202410280FF00000
+3271:00000FF0102820245FA240A240A25FBE502250225FA24022202410280FF00000
+3272:00000FF01028202440225F225122513E512251225F224022202410280FF00000
+3273:00000FF010282024512251225F22513E512251225F224022202410280FF00000
+3274:00000FF010282224422244224622493E50A2602240224022202410280FF00000
+3275:00000FF0102820244E2251225122513E512251224E224022202410280FF00000
+3276:00000FF0102820245FE242224222453E48A2506260224022202410280FF00000
+3277:00000FF0102827A440225FE24222453E48A2506260224022202410280FF00000
+3278:00000FF0102820245FA240A241225E3E4422482250226022202410280FF00000
+3279:00000FF0102820245FA250225FA2503E50225FA240226022202410280FF00000
+327A:00000FF0102820245FA2402250A2493E49224BE27C224022202410280FF00000
+327B:00000FF010282F2440227FE240224F3E50A250A24F224022202410280FF00000
+327C:00000FF010082E8440BA5E8A44EA4A8A51AA40AA5E2252223EFC10080FF00000
+327D:00000FF010083F6C429A449A4A9A516A400A7F8A440A44FA200C10080FF00000
+327E:00000FE010102388444444444444438440044FE441044104210810100FE00000
+327F:00001FF020085EF48C428C80ED0E0E020D028C828C425EF420081FF000000000
+3280:00001FF020084004800280028012BFFA8002800280028002400420081FF00000
+3281:00001FF0200840249FF280028002800280028012BFFA8002400420081FF00000
+3282:00001FF0200840249FF2800280428FE280028012BFFA8002400420081FF00000
+3283:00001FF020085FF4929292929292929294F2981290129FF2501420081FF00000
+3284:00001FF0200840049FF2810281028FE282228222822282227FFC20081FF00000
+3285:00001FF0220841048002BFFA8002844284228812900AA00A400420081FF00000
+3286:00000FF0100822044202423243C25E02420242024212421221F410080FF00000
+3287:00001FF0200840848482848284428442882288229012A00A400420081FF00000
+3288:00001FF02208420482029FC28242824282428442844A884A503C20081FF00000
+3289:00000FE010102108410441045FF441044104410441044104200810100FE00000
+328A:00001FF0200847F48412841287F28412841287F284128412485430281FF00000
+328B:00001FF02008410489128922894291028282828284428822701C20081FF00000
+328C:00001FF0210841048112BDA285428542892289229112A50A420420081FF00000
+328D:00001FF0210841048102BFFA8102838285428922B11A8112410420081FF00000
+328E:00001FF02108428484428822B7DA81029FF28102892285427FFC20081FF00000
+328F:00001FF021084104810281029FF2810281028102810281027FFC20081FF00000
+3290:000007F0080817F424122412241227F224122412241227F21414080807F00000
+3291:00001FF028484944BDF28A429C429BFAA842A8E289528A4A484420081FF00000
+3292:00001FF022087FFC840287E28C2297E2A42287E284228422446420081FF00000
+3293:00001FF030484844BE42844289F28C429A42A842884288424BFC20081FF00000
+3294:00001FF0240847F484228A429182810287F2BC128412841247F420081FF00000
+3295:00001FF0284869F4BC42A842ABFA8C229BFAA92288A2882248E420081FF00000
+3296:00001FF020185E1493FA9E1292329E5292929F1280129252612420081FF00000
+3297:00001FF0200851F48912BF12831285F28CA29AA2AAAA892A4A1C20081FF00000
+3298:00001FF03218491489229FFA910AA1029FF2811282128412586420081FF00000
+3299:00001FF0248878548892BE9288A28DA29AAAAACA889289924E7420081FF00000
+329A:00000FF010083FFC49124FF249124FF241025FFA410A420A244C18380FF00000
+329B:00001FF0220842048202BFFA8442844288428E82818282625C1420081FF00000
+329C:00001FF030484BFC88A283FABA4A8BFA8AAA8AEA8A1A940263FC20081FF00000
+329D:00001FF02BF8491489F289129BFAAC8A8B528DEA892288C24F3C20081FF00000
+329E:00000FF012083CFC508A508A5E8A508A508A528A5CB25082208410080FF00000
+329F:00001FF030884844A3FA94428442884289F2B0429042904253FC20081FF00000
+32A0:00001FF8200441FABE4189F9890989F989098FF9B10981F94092230C1FF80000
+32A1:00001FF02448444488428FFA9842A8E288E289528A4A8C42484420081FF00000
+32A2:00001FF020085FFC900AA41287E2840287F280129FD2801240A420481FF00000
+32A3:00001FF02008400480029FF28102810289E2890289029FF2400420081FF00000
+32A4:00001FF0210841048102810281F2810281028102810281027FFC20081FF00000
+32A5:000007F0088810842FFA288A288A288A2FFA288A208220821084080807F00000
+32A6:00001FF020087FFC81028102818281428122812281028102410420081FF00000
+32A7:00001FF022084204BFFA8202840287F2888288829082A0824FFC20081FF00000
+32A8:00001FF021084104BFFA8202840287E28C229422A42287E2442420081FF00000
+32A9:00000FF010083FFC520253F254825FFA50825142522254123FFC10080FF00000
+32AA:00001FF0200840849FFA900AA7E280029FFA808288A28892529421081FF00000
+32AB:00000FF0191824A45FFA500A47E2404240825FFA40824082238410080FF00000
+32AC:00001FF03E486844BE7AA282BEA2A812BF0280029FF292927FFC20081FF00000
+32AD:00001FF02108418482428422889AB08284E28482848284825FFC20081FF00000
+32AE:00000FF011082BFC444A5FE24C3A47E2442247E2442247E23C3C10080FF00000
+32AF:00000FF0188829F448927E92492249224FFA4AAA4AAA4CCA291410080FF00000
+32B0:00001FF021087FFC848284F289929A52AD2288A2884288A24B1C20081FF00000
+32B1:00001FF0200840049C72A28A82828CF2828A828AA28A9C72400420081FF00000
+32B2:00001FF0200840049CFAA28A820A8C1282128222A2229C22400420081FF00000
+32B3:00001FF0200840049C72A28A828A8C72828A828AA28A9C72400420081FF00000
+32B4:00001FF0200840049C72A28A828A8C8A827A820AA28A9C72400420081FF00000
+32B5:00001FF020084004A472A48AA48ABE8A848A848A848A8472400420081FF00000
+32B6:00001FF020084004A422A462A422BE2284228422842284FA400420081FF00000
+32B7:00001FF020084004A472A48AA40ABE0A84728482848284FA400420081FF00000
+32B8:00001FF020084004A472A48AA40ABE32840A840A848A8472400420081FF00000
+32B9:00001FF020084004A492A492A492BEFA8412841284128412400420081FF00000
+32BA:00001FF020084004A4FAA482A482BE72840A840A848A8472400420081FF00000
+32BB:00001FF020084004A472A48AA482BEF2848A848A848A8472400420081FF00000
+32BC:00001FF020084004A4FAA48AA40ABE128412842284228422400420081FF00000
+32BD:00001FF020084004A472A48AA48ABE72848A848A848A8472400420081FF00000
+32BE:00001FF020084004A472A48AA48ABE8A847A840A848A8472400420081FF00000
+32BF:00001FF020084004BE72A08AA08A9C8A828A828AA28A9C72400420081FF00000
+32C0:0000107C304410441044107C104410441044107C104410441044104410947C88
+32C1:0000007C184424442444047C044408440844087C104410441044204420943C88
+32C2:0000007C184424442444047C044404441844047C044404440444244424941888
+32C3:0000007C244424442444247C244424443C44047C044404440444044404940488
+32C4:0000007C3C4420442044207C204420443844047C044404440444244424941888
+32C5:0000007C184424442444207C204420443844247C244424442444244424941888
+32C6:0000007C3C4404440444047C084408440844107C104410441044104410941088
+32C7:0000007C184424442444247C244424441844247C244424442444244424941888
+32C8:0000007C184424442444247C244424441844047C044404440444244424941888
+32C9:0000003E232264A224A224BE24A224A224A224BE24A224A224A224A224CA7344
+32CA:0000003E222266222222223E222222222222223E2222222222222222224A7744
+32CB:0000003E232264A224A220BE20A221222122213E2222222222222422244A77C4
+32CC:000000000000000042004204427442887E884288427042404278428400840078
+32CD:000000000000000000000002651A96A494A4F42484188410941C64220022001C
+32CE:0000000000000000008200823C82424442447E444028402842103C1000000000
+32CF:00000000000000004FB8422442224222422242224222422242247A3800000000
+32D0:000003800C60101020082FE840244144418441042208240810100C6003800000
+32D1:000003800C6010102048208841044304450449042108210810100C6003800000
+32D2:000003800C60111021082FE848244824402440442048208811100C6003800000
+32D3:000003800C6010102008200847C44104410441042FE8200810100C6003800000
+32D4:000003800C60101020882FE841844284448448842288218810100C6003800000
+32D5:000003800C60111021082FE841244224444448442288210810100C6003800000
+32D6:000003800C601010220823C84F04410441F44FC42048204810100C6003800000
+32D7:000003800C601010220823E842244424484440442088230810100C6003800000
+32D8:000003800C601010240827E844844884508440842108260810100C6003800000
+32D9:000003800C60101020082FE840244024404440442FE8200810100C6003800000
+32DA:000003800C601010224822484FF44244424442442088230810100C6003800000
+32DB:000003800C601010260821084C044224404440842908260810100C6003800000
+32DC:000003800C60101020082FC840444044408441842248244810100C6003800000
+32DD:000003800C60101022082FE84224424442844204220821E810100C6003800000
+32DE:000003800C6010102008282844244424404440842108260810100C6003800000
+32DF:000003800C601010220823E842244624454448C420A8230810100C6003800000
+32E0:000003800C60101020E82F8840F45F84408440842108260810100C6003800000
+32E1:000003800C6010102208292845244424404440842108260810100C6003800000
+32E2:000003800C60101027C820084FE44084408440842108260810100C6003800000
+32E3:000003800C6010102208220842044304428442442208220810100C6003800000
+32E4:000003800C60111020882FE840844084408440842108260810100C6003800000
+32E5:000003800C601010200821E84E04400440F44F042008200810100C6003800000
+32E6:000003800C60101020082FC840444644418441842248244810100C6003800000
+32E7:000003800C60101020082FC840444084410443442528210811100C6003800000
+32E8:000003800C6010102008202840244024404440842108260810100C6003800000
+32E9:000003800C6010102008228842444424582440042008200810100C6003800000
+32EA:000003800C6010102008280849844E0448044804280827C810100C6003800000
+32EB:000003800C60101020082FE840244024402440442048208811100C6003800000
+32EC:000003800C6010102008220845044884404440242008200810100C6003800000
+32ED:000003800C60111021082FE841044544492441242508230810100C6003800000
+32EE:000003800C60101020082FE840244344408440442048200810100C6003800000
+32EF:000003800C601010230820C8460441844004460421C8201810100C6003800000
+32F0:000003800C60111021082108420442044444442427E8282810100C6003800000
+32F1:000003800C6010102008202840244224414440C420A8230810100C6003800000
+32F2:000003800C6010102FC8220843C45E0442044204220821E810100C6003800000
+32F3:000003800C60121022082FE842244144410441042088208810900C6003800000
+32F4:000003800C6010102008200847E44024404440842FE8200810100C6003800000
+32F5:000003800C601010200827E8402447E44024402427E8200810100C6003800000
+32F6:000003800C60101027C820084FE44024402440442048208813100C6003800000
+32F7:000003800C6010102248224842444244424440442088230810100C6003800000
+32F8:000003800C6010102108250845044514452445442588290810100C6003800000
+32F9:000003800C6010102408240844044424444444842508260810100C6003800000
+32FA:000003800C601010200828E84F244824484449E42E08280810100C6003800000
+32FB:000003800C60101020082FE848244824402440442048208811100C6003800000
+32FC:000003800C60109020882FE8448444845FE440842088208810900C6003800000
+32FD:000003800C60101020082FE840244344408440443FF8200810100C6003800000
+32FE:000003800C60101020082FE8402447E4402440442088230810100C6003800000
+32FF:0000203050C0484E844ABBFA004AFCCA24EA255A254A244A2C4E204A20482040
+3300:7C04040A154A192411201220200000000040004000407C600050004000400000
+3301:3E0002100A500C50085408541058000000003E00027C02040218041018200000
+3302:3E0002400A200C040818086010000000013E2282528A090C0408000800100000
+3303:3E0002000A000C7C080008001000000000000800280028002A002A002C000000
+3304:02000438080018002800087C08000000010281E941240A203020C04001800000
+3305:020004400820180428180860080000000400380008003E000800080010000000
+3306:08003E002208227C021804280848000000002000100002000C00300000000000
+3307:00007CF810081010102010507C8800004022782948248BB00828102060200000
+3308:00003E000800087C080008003E00000010003E001200127C1200120024000000
+3309:04003E4004200C04141824600C00000000003E00020004000800140022000000
+330A:04003E0004000C7C140024000C000000080008001000200022003E0002000000
+330B:10043E0812101230125012102410000024002400240024000400080030000000
+330C:10383E00127C12041204120824300000002000202A202A300228042018200000
+330D:10003E7C124412441244127C24000000240024002400247C0400080030000000
+330E:4100FCBE4A2248224822483E9000000000004000200004001800600000000000
+330F:4080FA5049084802480C48309000000000007C00040004002800100008000000
+3310:20407D2010807C001000080008000000020407D2024802400240024004800000
+3311:4080FA5C2100F8002000103E100000000000000000007C000000000000000000
+3312:10003E0008003E380808047C04000000240024002400247C0400080030000000
+3313:4080FA442114F814201510151016000040807A404900A83E1800100060000000
+3314:10003E0008003E0008000400040000000000007C004400440044007C00000000
+3315:20007CF810887C88108808F80800000041327482527490141015202740410000
+3316:4002FBC22242FA54224813D410200000020002080228FB2802AA022A022C0000
+3317:10003E3E08223E220822043E040000000008F8088AA88AAC082A104861880000
+3318:408C7A40491E88020802100460080000100010002000400044007C0004000000
+3319:408C7A40491E8802080210046008000022002210420883028A8CFA300A000000
+331A:20003C2024A044A004A808A830B000004110FCAF4A4950C941494049384F0000
+331B:10001E7C124422440244047C180000000010007C00083E100038005400100000
+331C:10001E002400047C040004000800000000003E00020004000800140022000000
+331D:00003E1002500250025402543E580000080008003E0008000800100020000000
+331E:00003E000200027C020002003E00000008403EA008A02A402A00080018000000
+331F:14043E0814101430045008101010000010001E10125022500254045418580000
+3320:14003E401420140404180860100000001008E0082010FBA02022203E40020000
+3321:20901490449024900810702000C00000010281E941240A203020C04001800000
+3322:10003E4012201404101810600E0000000400380008003E000800080010000000
+3323:10003E4012201404101810600E00000010001000100018001400100010000000
+3324:40807A404900A83E180010006000000000007C00040008001000280044000000
+3325:1C2000903E400800080008001000000000200014004400240008007000000000
+3326:2100248022003000280020002000000000000010005000500054005400580000
+3327:1000100010001800140010001000000000000040002000040018006000000000
+3328:080008003E000800080010002000000000000008000800080008001000200000
+3329:040004000454045404040808103000000800080008000C000A00080008000000
+332A:0004000814101230125022100010000000002A002A0002000200040018000000
+332B:010002805280493E48008800000000004008FA084908502C40CA430838080000
+332C:010002805280493E480088000000000000005400540004000400080030000000
+332D:010004805200483E48008800000000000000402040A044A048A850A860B00000
+332E:813E9A82E28A810C80088008781000000200FA080A28132822AA522A8A2C0000
+332F:81109A9EE2928122800280047818000000001000500050005400540058000000
+3330:204026A038A02040200020001E0000000000007C0004000400040004007C0000
+3331:40404D2070804000400040003C00000000000010005000500054005400580000
+3332:00007C0004F804080430082030400000E0220029EAA42AB020A8412086200000
+3333:00003E000208021002300450181000000020002000203E300028002000200000
+3334:0100F480122A102A10022004C01800004000280488144FD41115E11507D60000
+3335:00383E00027C0204020404081830000000002000100002000C00300000000000
+3336:00402078504808880408001000600000400078044814ABD41815101560160000
+3337:0100228052800900040000000000000000000024001400140004000800300000
+3338:0100229C528009000400003E000000002000260038002000200020001E000000
+3339:0000101028500450025400540058000000002A002A0002000200040018000000
+333A:010022A052900902040C00300000000000003E00020004000800140022000000
+333B:010022805280093E040000000000000020401520448024000800700000000000
+333C:010024805200083E040000000000000010001E0012002A000600040018000000
+333D:10827D4411485498542810083008000000202020102002300C28302000200000
+333E:10407D2410945414541510153016000010001000100018001400100010000000
+333F:08003E0008002A002A0008001800000000000040002000040018006000000000
+3340:10807D5011485482540C10303000000010801240110018001400100010000000
+3341:08003E0008002A7C2A0008001800000000000800280028002A002A002C000000
+3342:08003E0008002A7C2A0008001800000000002000100002000C00300000000000
+3343:00043E0802100230145008100410000010001E7C124402440244047C18000000
+3344:00043E0802100230145008100410000000000800280028002A002A002C000000
+3345:00003E0002540254140408080430000000000000140012001200220000000000
+3346:00003E1002500250145408540458000010001E00120022000200040018000000
+3347:00007C8004400408283010C008000000000040202B9088824B8C10B0E3800000
+3348:1820043C30240844000430080C30000000003E402220220422183E6000000000
+3349:1800040030000800000030000C00000000480048004800480008001000600000
+334A:1848044830480848000830100C600000010004845214481449D5881500160000
+334B:04000400040028001000280040000000020407D2024802400240024004800000
+334C:09020BE90924512021205120824000002000208020403008283020C020000000
+334D:020002000200147C080014002000000010001010105018501454105410580000
+334E:100010003E00127C140010001000000021002480220030002800200020000000
+334F:100010003E00127C140010001000000000000800280028002A002A002C000000
+3350:007C1C040414041804103E100020000000002000100002000C00300000000000
+3351:2400240024542454040408083030000010001010105018501454105410580000
+3352:2400240024002400040008003000000000380000007C00040004000800300000
+3353:1102513551C551025500550058F000000000000000007C000000000000000000
+3354:000008002800287C2A002A002C0000000080FA44091408140815101560160000
+3355:0000200020002200240028003000000000100010002000400044007C00040000
+3356:0000408040404408483050C06000000088208E949442C400A401840688180000
+3357:00003E0022542254020404081830000010001000100018001400100010000000
+3358:001018102410241E24102410247C244424442444247C24442400245418AA00AA
+3359:001010103010101E10101010107C104410441044107C1044100010547CAA00AA
+335A:001018102410241E04100410087C084408441044107C1044200020543CAA00AA
+335B:001018102410241E04100410047C184404440444047C04442400245418AA00AA
+335C:001024102410241E24102410247C3C4404440444047C04440400045404AA00AA
+335D:00103C102010201E20102010207C384404440444047C04442400245418AA00AA
+335E:001018102410241E20102010207C384424442444247C24442400245418AA00AA
+335F:00103C100410041E04100810087C084410441044107C10441000105410AA00AA
+3360:001018102410241E24102410247C184424442444247C24442400245418AA00AA
+3361:001018102410241E24102410247C184404440444047C04442400245418AA00AA
+3362:001026106910291E29102910297C294429442944297C29442900295476AA00AA
+3363:001022106610221E22102210227C224422442244227C22442200225477AA00AA
+3364:001026106910291E21102110227C224422442444247C2444280028547FAA00AA
+3365:001026106910291E21102110217C264421442144217C21442900295476AA00AA
+3366:001029106910291E29102910297C2F4421442144217C21442100215471AA00AA
+3367:00102F106810281E28102810287C2E4421442144217C21442900295476AA00AA
+3368:001026106910291E28102810287C2E4429442944297C29442900295476AA00AA
+3369:00102F106110211E21102210227C224424442444247C24442400245474AA00AA
+336A:001026106910291E29102910297C264429442944297C29442900295476AA00AA
+336B:001026106910291E29102910297C264421442144217C21442900295476AA00AA
+336C:000863089488948F1488148824BE24A224A244A244BE44A2848084AAF3550055
+336D:000862089608920F12081208223E222222224222423E42228200822AF7550055
+336E:000863089488948F10881088213E212221224222423E42228400842AF7D50055
+336F:000863089488948F1088108820BE232220A240A240BE40A2848084AAF3550055
+3370:000864889488948F1488148824BE27A220A240A240BE40A2808080AAF0D50055
+3371:0000000043C042204220422053CC6A124A024A0E4A124A124A164A0A00000000
+3372:0000000002000200020002003A3C46424202423E4242424246463A3A00000000
+3373:000000000842144214421442224222423E422242414241424142413C00000000
+3374:00000000400040004000400071944A5A485249D04A504A504AD0715000000000
+3375:0000000000820082008200827882844484448444842884288410781000000000
+3376:0000000000000000000000005C3C6242424042404240424062425C3C40004000
+3377:0000000001000100010001001D682354415441544154415423541D5400000000
+3378:001E0002021E0210021E02003AD046A882A882A882A882A846A83AA800000000
+3379:001E0002020E0202021E02003AD046A882A882A882A882A846A83AA800000000
+337A:000000007C8410841084108410841084108410841084108410847C7800000000
+337B:0000000A0009FE091008927F524854481078FE551055109510D610B5110A0010
+337C:00001E300AEEEA4AAAFAAA4AEA4AB6CAA0EAAEDAEB4AAA4A0E4E0A4A00000000
+337D:0000000010FE10101010FE5010501050285E2850285044504450445082FE0000
+337E:000000010E81EA42AA02AA94EE55AA17AA21AA20EE6FAA290A29122F26290000
+337F:2A057F842A3F7702A23A27122AB90000104428F4441EBA2400D4FE4424447A5F
+3380:0000000000100028002800285C446244427C4244428262825C82408240004000
+3381:00000000001000280028002858446444447C4444448244824482448200000000
+3382:00000000001000280028002811441144117C12442282228222823D8240004000
+3383:00000000001000280028002868445444547C5444548254825482548200000000
+3384:00000000801080288028802884448844907CA044D08288828482828200000000
+3385:00000000407C4042404240424242447C48425042684244424242417C00000000
+3386:00000000417C4142634263425542557C49424942414241424142417C00000000
+3387:000000003C7C42424242404240424E7C424242424242424246423A7C00000000
+3388:00000000000C00040004000471E48A14801481F4821482148A3471DE00000000
+3389:00000000800C80048004800493649494A414C474A49494948CB48F5E00000000
+338A:0000000000FE0080008000805C8062F842804280428062805C80408040004000
+338B:0000000000FE00800080008058F8648044804480448044804480448000000000
+338C:00000000007E004000400040227C2240224022404440444044407B4080008000
+338D:00000000000000000000000411341148114811482230222022383DC440444038
+338E:0000000000000000000000086868549054905490546054405470548800880070
+338F:0000000040004000400040044234444848485048683044204238414400440038
+3390:000041004100410041004100413E7F0241044108411041204140417E00000000
+3391:000084408440844084408440945E97C2A444C448A44894508C608C7E00000000
+3392:00008A408A40DA40DA40AA40AA5E8BC28A448A448A488A488A508A5E00000000
+3393:0000000072408A408A408240825E83C29E448A448A488A488A507A5E00000000
+3394:00000000FC8024802480248024BE2782248424882488249024A024BE00000000
+3395:00000000000800140014002411281148114822502252226222645DD840004000
+3396:000000000008001400140024762849484948495049524962496448D800000000
+3397:0000000002080214021402243A284648424842504252426246643BD800000000
+3398:000000004008401440144024422844484848505068524462426441D800000000
+3399:000000001C0022002000200078C8213421242124212421242124212400000000
+339A:00000000000000000000000059D8652445244524452445244524452400000000
+339B:00000000000000000000000022A422DA229242924492449244927B9280008000
+339C:00000000000000000000000034682A542A542A542A542A542A542A5400000000
+339D:0000000000000000000000001C682254405440544054405422541C5400000000
+339E:0000000040004000400040004268445448545054685444544254415400000000
+339F:001E0002001E0010001E000068D054A854A854A854A854A854A854A800000000
+33A0:001E0002001E0010001E000038D044A880A880A880A880A844A838A800000000
+33A1:003C0004003C0020003C00002CC0332022202220222022202220222000000000
+33A2:001E0002801E8010801E800084D088A890A8A0A8D0A888A884A882A800000000
+33A3:001E0002000E0002001E000068D054A854A854A854A854A854A854A800000000
+33A4:001E0002000E0002001E000038D044A880A880A880A880A844A838A800000000
+33A5:003C0004001C0004003C00002CC0332022202220222022202220222000000000
+33A6:001E0002800E8002801E800084D088A890A8A0A8D0A888A884A882A800000000
+33A7:0002D004A808A810A820A840A880A978AA840280047808041084207840008000
+33A8:0010D02EA822A84EA888A88EA900AA78AC840480087810041084207840008000
+33A9:000000003E0021002100210021783E842004207C20842084208C207400000000
+33AA:0000000081C0812081208120853C89C29102A11ED12289228526831A00000000
+33AB:0000000089C08920D920D920A93CA9C28902891E892289228926891A00000000
+33AC:0000000071C0892089208120813C81C29D02891E892289228926791A00000000
+33AD:0000000000020002000200025B1A64A640A247A248A248A249A646DA00000000
+33AE:008200840084B188CA889A90AA90AAA0AAAC9DD20090010C01020212040C0800
+33AF:0090009E0092B1AECAA89AAEAAC0AAC0AA989DA400A001180104022402180400
+33B0:0000000000000000000000005C786284428042704208420462845C7840004000
+33B1:0000000000000000000000005878648444804470440844044484447800000000
+33B2:000000000000000000000000113C1142114011382204220222423DBC40004000
+33B3:0000000000000000000000006878548454805470540854045484547800000000
+33B4:0000000000820082008200825C82624442444244422862285C10401040004000
+33B5:0000000001040104010401045888648844884450445044204420442000000000
+33B6:00000000008200820082008222822244224422444428442844107B1080008000
+33B7:00000000008200820082008234822A442A442A442A282A282A102A1000000000
+33B8:000000008104810481048104850488889088A088D05088508420822000000000
+33B9:0000000082828282C682C682AA82AA4492449244822882288210821000000000
+33BA:000000000222022202220122591465144494449444B464C85848404840004000
+33BB:000000000222022202220122591465144494449444B444C84448444800000000
+33BC:000000000222022202220122251425142494249448B448C84848764880008000
+33BD:000000000222022202220122691455145494549454B454C85448544800000000
+33BE:000000008222822282228122851489149094A094D0B488C88448834800000000
+33BF:0000000083228322C722C722AA94AA949294929482B482488248824800000000
+33C0:000000004070408841044104490449045104610451044888448847DE00000000
+33C1:00000000443844446C826C82548254824482448244824444444445EF00000000
+33C2:00000000000000000000000030D048A808A838A848A848A858A82AAA00000000
+33C3:000000003C0022002200220022343C4C224421442144214C22343C0400040004
+33C4:0000000000000000000000001C382244408040804080408022441C3800000000
+33C5:0000000400040004000400043C74428C4084408440844084428C3C7400000000
+33C6:001070208840808081008A0076010A4D125222924312828C0248024E0011000E
+33C7:000000003C0042008100800080708088808880888088818842883C7200000000
+33C8:0000000004F804840484048474848CF884848482848284828C8474F800000000
+33C9:000000001E0021004100400040424042402243A44114411823081D1000100060
+33CA:0000000020002000200020002C7832842204227C22842284228C227400000000
+33CB:00000000427C42424242424242427E7C42404240424042404240424000000000
+33CC:00000000000010001000000030B810C4108410841084108410847C8400000000
+33CD:0000000041414242444448485050606060605050484844444242414100000000
+33CE:0000000045044504458C498C5154615451244924450445044504450400000000
+33CF:0000000040004020402040204278442048205020682044244224411800000000
+33D0:000000003000100010001000100010EC109210921092109210927C9200000000
+33D1:000000003000100010001000100010BC10C210821082108210827C8200000000
+33D2:000000006000200020002002271A28A428A428A428982890289CF7220022001C
+33D3:00000000300010001000100011021084104810301030104810847D0200000000
+33D4:00000000008000800080008034B82AC42A842A842A842A842AC42AB800000000
+33D5:000000000018008800880008698854885488548854885488548857FE00000000
+33D6:00000000000C000400040004D1C4AA24AA24AA24AA24AA24AA24A9DF00000000
+33D7:000000007C4242424242424242427C7E40424042404240424042404200000000
+33D8:00000000000000000000000058D064A844A844A844A878A840A844AA40004000
+33D9:00000000E72294A294B694B694AAE72A84228422842284228422842200000000
+33DA:000000007C7C42424242424242427C7C40484048404440444042404200000000
+33DB:0000000000000000000000003C2C4232402038200420022042203C2000000000
+33DC:000000001E0021004000400030820C82034400C400A840A821101E1000000000
+33DD:0000000088A088A088A088A044BC45224D224D22552222222222223C00000000
+33DE:000000022204220822102220144014B4092A0A2A042A082A102A202A40000000
+33DF:00000802140422083E102220224022B4012A022A042A082A102A202A40000000
+33E0:0000107C30441044104410441044107C10441044104410441044107C7C440044
+33E1:0000187C24442444044404440844087C08441044104410442044207C3C440044
+33E2:0000187C24442444044404440444187C04440444044404442444247C18440044
+33E3:0000247C244424442444244424443C7C04440444044404440444047C04440044
+33E4:00003C7C20442044204420442044387C04440444044404442444247C18440044
+33E5:0000187C24442444204420442044387C24442444244424442444247C18440044
+33E6:00003C7C04440444044408440844087C10441044104410441044107C10440044
+33E7:0000187C24442444244424442444187C24442444244424442444247C18440044
+33E8:0000187C24442444244424442444187C04440444044404442444247C18440044
+33E9:0000267C69442944294429442944297C29442944294429442944297C76440044
+33EA:0000227C66442244224422442244227C22442244224422442244227C77440044
+33EB:0000267C69442944214421442244227C22442444244424442844287C7F440044
+33EC:0000267C69442944214421442144267C21442144214421442944297C76440044
+33ED:0000297C694429442944294429442F7C21442144214421442144217C71440044
+33EE:00002F7C684428442844284428442E7C21442144214421442944297C76440044
+33EF:0000267C694429442844284428442E7C29442944294429442944297C76440044
+33F0:00002F7C61442144214422442244227C24442444244424442444247C74440044
+33F1:0000267C69442944294429442944267C29442944294429442944297C76440044
+33F2:0000267C69442944294429442944267C21442144214421442944297C76440044
+33F3:0000319E4A524A520A520A521252125E12522252225222524252425E79920012
+33F4:0000311E4B124912091209121112111E11122112211221124112411E7B920012
+33F5:0000319E4A524A52085208521092109E10922112211221124212421E7BD20012
+33F6:0000319E4A524A52085208521052119E10522052205220524252425E79920012
+33F7:0000325E4A524A520A520A52125213DE10522052205220524052405E78520012
+33F8:000033DE4A124A120A120A121212139E10522052205220524252425E79920012
+33F9:0000319E4A524A520A120A121212139E12522252225222524252425E79920012
+33FA:000033DE48524852085208921092109E11122112211221124112411E79120012
+33FB:0000319E4A524A520A520A521252119E12522252225222524252425E79920012
+33FC:0000319E4A524A520A520A521252119E10522052205220524252425E79920012
+33FD:0000319E4A524A520A520A520A52325E0A520A520A520A524A524A5E31920012
+33FE:0000311E4B124912091209120912311E09120912091209124912491E33920012
+33FF:00000000000600020002040234E24912481248F231122112393244D744003800
+3400:0440044004400440044004407C7C0440044004400440044004400440FFFE0000
+3401:0000FFFE010001003FF82108210821082288224824282828200820083FF82008
+3402:0100010001F83F000104010400FC100010201020163CF8E010221122161E1800
+3403:0100028004400820101020084004FFFE01000100010001000100010001000100
+3404:01000100010001003FF801002100210041007FFE010001000100010001000100
+3405:0000001000102020102008400440028001000280044008201010200840000000
+3406:001000F81F0010001FF810081FF810081FF810001FFC10042004200440288010
+3407:020002003FE00420042008223022C01E00007FF0006001800600180420041FFC
+3408:060001000280044008203018C0063FF80010006001800600180420041FFC0000
+3409:00007FFC01000100010001000100050002007FF0006001800600180420041FFC
+340A:010001000100FFFE010001003FF8000000007FF0006001800600180420041FFC
+340B:0100010001003FF801000100FFFE000000007FF0006001800600180420041FFC
+340C:080008001FFC200041008100117013901D10F11011501122110210020FFE0000
+340D:00FC7F00020821081110102000003FF80010006001800600180420041FFC0000
+340E:020001007FFC0820044003801C70E00E00003FF80010006003801C0420041FFC
+340F:00003FFC010001001FF0021004107FFE00007FF0006001800600180420041FFC
+3410:10001000FEFC22844488285010202858C58600007FF0006003801C0420041FFC
+3411:08001FF0282007C01830E18E0C40030000807FF0006001800600180420041FFC
+3412:00007FF8040808503020DFF8100810081FF800007FF0006003801C0420041FFC
+3413:0000FFFE00101F90109010901F90005000207FF0006001800600180420041FFC
+3414:02000100FFFE00001FF0101010101FF000007FF0006001800600180420041FFC
+3415:010001003FF8210821083FF8210821083FF800007FF0006003801C0420041FFC
+3416:082008200820FFA0082008207F20002000207F204120412241227F22411E0000
+3417:02083FD00220FFFE02000C703F84C80407FC00007FF0006003801C0420041FFC
+3418:010011100920FFFE054009203118C10600007FF0006001800600180420041FFC
+3419:00007FFC00001FF010101FF008200440FFFE00007FF0006003801C0420041FFC
+341A:7FFC02003FF00410FFFE00001FF010101FF000007FF0006003801C0420041FFC
+341B:0840084017FC3080510093F81508110811F800007FF0006003801C0420041FFC
+341C:1040144012401040FEF8104810489248544810483848548A928A110A52062400
+341D:11001100F9F8120819E83128D1E81008505020207FF0006003801C0420041FFC
+341E:082008207FFC08200FE008200FE00820FFFE10102FE8404483820C0810080FF8
+341F:044004407C7C04403C7804407C7C044004407FF0006001800600180420041FFC
+3420:07A0F82048A025207F20022007A2FC2244220C1E00003FF001C01E0420041FFC
+3421:200027FC204023F8FAA82AA82AA82A1828402FFC28A029122A0A480247FE8000
+3422:203C17C08244492813F8E01027FE202020A000407FF0006003801C0420041FFC
+3423:00803FFE20802FF8208027F0249027F024903FFC20802FF840604380840403FC
+3424:204023F8204021F0F91029F0291029F0291029F029102BFA28A2491247FE8000
+3425:100829C8455EB94A11CA7D4A11CA55523D6AE38400003FF001C01E0420041FFC
+3426:3BB822083BB82488FFFE10502788C1061FF0010003003FF001C01E0420041FFC
+3427:0080108008800480048000807FFC01840288049008803080C080008002800100
+3428:00007CFC0404282810100808FEFE121214141010101010101010101050502020
+3429:24242424242424247E7E242424242424FEFE2424242424242424444444448484
+342A:020001000100FFFE0000010021082108210821083FF80288044008203018C006
+342B:020001000100FFFE00000820044022882108228824482828200820083FF80008
+342C:02000100FFFE0400082010103FF810080000111011101110211021124112800E
+342D:02000100FFFE000000003FF82008200827C82448244827C8200820083FF82008
+342E:02000100FFFE1010244844441FF004401FF004407FFC04900C603518C6060400
+342F:01007FFC08201FF010101FF000001FE001007FFC09203FF8C8260FE008200FE0
+3430:080009FC0904110411043104310451049104110411041104110411FC11041000
+3431:0100010002800440082010502188C606382000C007003818006003807C000000
+3432:0840084008401040104037FE30405040904010A010A010901110110812041402
+3433:080008000BFC10901090309030905090909010901090109211121112120E1400
+3434:08800880088010FC110431043284544890281010101010201040108011001600
+3435:08000BFC08401040104030403FFE504090401040104010401040104011401080
+3436:080008000BFC120412043204320453FC92041200120012021202120211FE1000
+3437:08000FF00810101012103210321053FC90041004100417F41004100410281010
+3438:08800880088010FC1104310832405440904010A010A010901110110812041402
+3439:0900090009FC1200140031F83000500093F8100810081008100A100A10061002
+343A:1120112011202220222066206620AA2022202250225022502248228822842302
+343B:082008200820102013FE3222322252229252124A128A130212021202120A1204
+343C:080808680B88108810883088308853FE90881088108810881108110812081408
+343D:08000BF80A081208132832A832A85248924812A812A8132A140A140A18061002
+343E:080008000BF810001000300037FC5120912011201120112012221222141E1800
+343F:081008780BC01040104033F830405040904017FE104010401040104011401080
+3440:084008400840104017FE3040304050A090A010A0111011101288124814441802
+3441:084008400A4812481248324833F8504890401040144414441444144417FC1004
+3442:100017FC10402040204067FC6444A44424A42494251426042404240424142408
+3443:1220122012202420257C69246E24A2242424242429242F242144204420942108
+3444:080009F8090811481128312837FE520892481228122813FE1008100810501020
+3445:09000900090011FE1240324034405040907C1040104010401040104017FE1000
+3446:08000BFC0A0412041204320433FC5090909010901090111211121212140E1800
+3447:0880088008F811081210342033FC50049004100411FC10041004100413FC1004
+3448:08400840084017FE108031203120522093FC1020112811241222142210A01040
+3449:100017F81408240827F864886488A4E82528252826A8244A244A288A29063202
+344A:08400820082017FE109030903090529492921292149210901110111012501420
+344B:10A010A010A020A027FC64A464A4A4A424A427FC24A424A424A424A427FC2404
+344C:08000BFE0A00120013FC3220322052F892201220122013FC1200120013FE1000
+344D:1040104017FC2040204063F86040A04027FE20E0215021502248244428422040
+344E:1000124812482490249062486248A00020402444244424442444244427FC2004
+344F:084008200BFE120214143010301053FE90101110109010901010101010501020
+3450:084008400840107C1040304037FE500090401040125012481444184411401080
+3451:08400840088013FC12043204320453FC9204120413FC12041204120413FC1204
+3452:01000280044008203018CFE6010001001FF0111011101FF0028004401830E00E
+3453:082008400888110413FE3042304057FE908010FC114411441228121014681186
+3454:08000BFE0820104011FC31043104512491241124112411441050108811041204
+3455:082008200A221222122233FE3040504090FC1104128414481050102010C01700
+3456:111011101110221022FE66926692AA92229222FE229222102210221022102210
+3457:088009000BF8120813F8320833FA520A920C17F810181028104811881E281010
+3458:1014101210102FFE201062906292A2922FD2229422942288228A249A24262842
+3459:10001FFE14802490249067906490A490249027902490249224D22F92208E2080
+345A:100017DE12522252225467D46258A25422522FD22252225A2254245025502890
+345B:084008400FFE1040104037FC3444544497FC104010E0115012481C4610401040
+345C:1208121C126022402FC06240627EA2C823482E4822482248224822482A882508
+345D:100017FC1040204023F860406040A7FC211021102FFE21102110221022102410
+345E:104010401244224424A861106208AC06211021102FFE21102110221022102410
+345F:0808081C09E01100110031FE311051109110111017FE10001090110812041402
+3460:08800AFC0AA412A412A8329032A850C69020102011FC10201020102013FE1000
+3461:100017BC14A424A424A467A464A4A4A424A427A42434252824A0256026202020
+3462:09000900091E139211123112311257D291121112121A129417D0125010101010
+3463:091009100910111017BC31103110533893B81554155419921110111011101110
+3464:111011101FFE21102110600067FCA4442444244427FC24442444244427FC2404
+3465:08000BF80A0813F8120833F83100510093FC1494189411241244148411281210
+3466:084008200BFC1204120433FC32005228922413FE122012501250148815041A02
+3467:103813C0104027FC20E061506248AC4623F02020204027FC2040204021402080
+3468:08000BF80A08120813F83100310053F8944010401FFE104010A0111012081C06
+3469:08000BFE0A521252125233FE3020504090FC1104128810501020104011801600
+346A:084008200FFE11081090306031985606910811F8110811F81108110812081408
+346B:0840084008A011101288344633F0501090A01040114815041514151418F01000
+346C:12101210121022102F7E65106510A510257C29442544224422442544257C2844
+346D:100017FC1444244427FC64446444A7FC200020002FFE22082208220824082808
+346E:08000BFE0A22102013FE302031FC512491FC112411FC102013FE102010201020
+346F:08000FFE0840108013FC3204320453FC920413FC1204120413FC100011081204
+3470:090009F80A0813F0101037FE30805144966810B01128166810A4112216A01040
+3471:08000BF80890106017FC30A4312852209460104017FC10E0115012481C461040
+3472:104010401FFE2040204067FC6514A4A425F42444244425F42444244424542408
+3473:090009000BFE1442125233F230825114960813FE14421A5213F2108211141608
+3474:0BF8080809F8100813F8300037FC544493F812481258104013F8111010E0171E
+3475:0820081009FE110011203520333C51509190131015FE11101128122812441482
+3476:0900090009FC120015F8300033F8508892A811C817F8108A11CA16AA10861082
+3477:11101212145427D82010601267D2A44E244027D22454245827D024522552248E
+3478:084008400FFC104013F8320833F850009FFE100813E8122813E8100810281010
+3479:0100028004400FE03118DFF611101FF011101FF000000FE008200FE008200FE0
+347A:08A0089009FE132015FC312031FC512091FE110013FC1088109E1102120A1404
+347B:1080104017FE2402289460506524A54A28FA2300204024442444244427FC2004
+347C:10101010103C2FA42AC46AA86A90AFA82AC62A802ABC2AA42FA428A4203C2024
+347D:1040144412482FFE280263F86208A20823F82040204027FC204020402FFE2000
+347E:084008FC09081650112030C033205FFE900013FC100013FC100013FC120413FC
+347F:124814901248200023F8624863F8A24823F8204027FC20E0215022482C462040
+3480:1080104017FC211020A067FC6444A5F4244425F42514251425F4240424142408
+3481:100017FC1444244425F4644467FCA51424A425F4244427FC2444244427FC2404
+3482:090809080FFE1108104433F43048505097FE108011FC130415FC190411FC1104
+3483:08140BFE081013D0101033D0301053D0925013D0125013C8124A13CA11861242
+3484:0910091409D21250127E3550309052A89128114412441482100812A412521452
+3485:08200BFE084010F81348303033D0503C91C41048103013C410A8119016A810C6
+3486:084008A0091816E6100033F8320853F8900017BC108414A4129414A412941108
+3487:1100110013FC26A82AA862A867FCA2A822A822A82FFE200022A8225424542000
+3488:10081788108821102FDE649464A4A79424942794249424C827882C9420A420C2
+3489:08400A48095017FC140431F03110511091F0104017FC10E01150124814461040
+348A:100017BC129426B42AD464A465ACA8402108210825A8252C252825A82E7E2000
+348B:14801482149C2FD024906790649EA794249424942FD42014251428A430242044
+348C:1110155415B8291022A864446000A7FC240429E821202120212022222422281E
+348D:088009100BF8121014A437BC3080511093E01040108817FC1044124815441080
+348E:08000BF8088017FC111032083CA650A097BC10A013B810A017BC10A010A010A0
+348F:084008200FFE149213FC309033FC509097FE1108120414621010118010601010
+3490:0910091009DE12A81444310031FC520495F4111411F4111411F4111410281010
+3491:100017FE14282624257E644864C8A47E2648257E24482448257E264027FE2000
+3492:10A014A412A820A027FC611060A0A7FC204023F8204027FC215022482C462040
+3493:10101410127C201020FE60446628A2FE2210227C221022FE2210221025FE2800
+3494:100017FC14A424A427FC620063FEA4422BFA224A23FA2052207A278A22142008
+3495:1040102017FE20282224627E64C8A748217E224824C82F7E21482248247E2840
+3496:1110111017FC211023F8624863F8A24823F8204027FC2444245425F42414240C
+3497:111017FC111021F0211061F06110A7FE24022BFC211023F8204023F8204027FC
+3498:100017BC15142794248867886514A7A22080204027FC2000220821102FFE2000
+3499:11081110123E22A224BE6F22613EA20824BE2FAA20AA202A2AAA2AAE28082008
+349A:103E17C01244212823F8604067FCA00023F8200823F8200823F82544252A28FA
+349B:100017BC108424A4229464A46120A21027FC2A2023FC222023FC222023FE2200
+349C:09400A4C0A641244134C326432A453AC92A412A417FE10001110110812041404
+349D:09080FFE0908100013FC3294329453FC902813FE1220132412A81292142A18C6
+349E:08200A220BFE109011FE331035FE511091FE111011FE110013DE125212721206
+349F:104017FE100023FC224063F86240A3F8224023FC2004255420A823102D482186
+34A0:110011BC152427A824906AA86146A2A027BC20A023B820A027BC20A02FFE2000
+34A1:11821E3C10882A902522643C6788AA12223E2F8822082AAC2AAA2BCA2EA82090
+34A2:104010A0111022082DF660006EEEAAAA2EEE20002FFE29222FFE2922292A2804
+34A3:1040102017FE24A824FE6550677CA550257C2550257E254028A42A8A328A2478
+34A4:0BFC090809F8110811F8310E37F8500897FE1294139C1294139C12D617BC1084
+34A5:115013F8155427FC255467FC6554A7FC200027FC200023F8220823F821102FFE
+34A6:17FC144417FC244427FC60006FBEAAAA2FBE2AAA2FBE2040204027FC20402FFE
+34A7:141812141F90253E2AA86DE868BEAFA822282FBE2AA82AA82BA828BE2AA02920
+34A8:104015F6191229B22D5669B26912ADF620802FFE220825F4291221F0210420FC
+34A9:11F0121013E0202027FC61886650A1A8266421A022482FBE2AAA2FBE228A2FBE
+34AA:03800C603EF8E8A63EF822883EF828A03EF8100011FC5CA0515450B85D54E0B2
+34AB:00000FF8080008000FF008000800FFFE0440044004400440084408441044603C
+34AC:00007DFC002000200020FCF8282028202820282029FC28002800480247FE8000
+34AD:00003E7C22442244224422443E7C1428142814281428144A254A268A44868100
+34AE:000001FE7820004000A20334FC5828942B34285228922B502822480247FE8000
+34AF:108813FE9088540059FC10A8FCA82BFE28A828A829FC28202BFE4C2048208020
+34B0:060001000280044008203018C00600001FF0010001000100010001007FFC0000
+34B1:060001000280044008203218C20607F00810141022200140008003001C00E000
+34B2:060001000280044008203018DFF61010101010101FF01010101010101FF01010
+34B3:00007FFC4104410441045144492449245554638C410441044104410441144108
+34B4:060001000280044008203118D116111011101FF001002108210821083FF80008
+34B5:040008003FF8200820083FF8200820083FF80000000004400820101020084004
+34B6:04400440082010102108C2061FF01010101010101FF01010101010101FF01010
+34B7:00001FF0101011101110111012901450101010107FFC00000440082010102008
+34B8:0820042004407FFC020006001908629004A018C061A002980C863080C2800100
+34B9:10101010FEFE10107C7C44447C7C44447C7C44447C7C4444FEFE282844448282
+34BA:00007FFC4004482444445FF440044884488449444A2448044FF4400440144008
+34BB:7FFC40045FF440045FF400001FF010101FF010101FF010101FF004421842E03E
+34BC:08200820FFFE082008200FE001007FFC4104514449245554638C410441144108
+34BD:3FF820082FE820082FE8111009207FFC0400FFFE10102FE8C82608A0084807F8
+34BE:00003FF820082FE820082FE820401040FEFE21203CAC24F427A444AC54A2887E
+34BF:3FF820082FE820082FE808007F281424497E55C87F7E08487F7E55485D7E4340
+34C0:00007FFE40028004020002000200020002800240022002100200020002000200
+34C1:000000007FFE4002844408201010000000000000000000000000000000000000
+34C2:00007FFE400280243E2001FE00447E4414C814281410146A2586240243FE8000
+34C3:00007FFE4002900408007F1C00E03E2000203E3E01E03E22222222223E1E2200
+34C4:101022107F10421094FEF79208923610C92830A8C428192862480C4A308AC106
+34C5:0000400023FE202000200820082010201020E020202020202020202020A00040
+34C6:0040404020A020A001100A080C0611101120E140218021002104210420FC0000
+34C7:0010407827C0204000400840084017FE1040E0A020A021102110220824040802
+34C8:0000400027FE204000400880088011F81308E508290821082108210821F80108
+34C9:0010407823C02040004007FE104010402040E3F8220822082208220823F80208
+34CA:000047FC2404240405F40404140415F42514E514251425F42404240424140408
+34CB:011041102110211007FC0110111011102110EFFE200021102108220824040804
+34CC:0040404020A021100208040613F810402040E04023F820402040204027FE0000
+34CD:00804040204027FE00800110120817FC2124E1202120212022222222241E0800
+34CE:000043F8200821F800080BF8080017FC1404E3F02110211020A0204021B0060E
+34CF:000047FC240424A40514060C140415F42514E514251425F42514240424140408
+34D0:0040404023F82040004007FC111012082444E04023F820402040204027FC0000
+34D1:0040404027FC204000400FFE111010A027FCE04020402FFE2040204020400040
+34D2:2040104004780BC47044103C110012800C603118C10609901148214805000200
+34D3:004040402FFE2040004007FC151414A425F4E444244425F42444244424540408
+34D4:010842082788248807BE0488178814C824A8EFA8218822882488288822A80110
+34D5:00144012201027FE0410041017F214922492E5B426D42488254A293A2A261042
+34D6:000047FC244427FC044407FC124812482FFEE248224827FC20402FFE20400040
+34D7:010047BC21142394011407A4114C10802110E3E0204827FC2044224825440080
+34D8:00003FF820082FE8210823C824482A88210826083BE8210A2FEA414A41269FF2
+34D9:0200010001001FF040444844448442844104428444444824502440047FFC0004
+34DA:000400047F04082408240824082408240824082408240F24F004400400140008
+34DB:000001FC00447E440844084408440844084408440E84F0844104010402280410
+34DC:0800080010FC102422244224FC2404240824102424244224FE44424400940108
+34DD:22042204220422247F24222422242224FFA42224222422242204420442148208
+34DE:0800080008FC7F240824082408247F24082408240824FFA40844084408940908
+34DF:0404040404043FA424A4252424243FA420A42924252422242504488490940008
+34E0:08040804080408240FA40824082408247F24412441244124410441047F144108
+34E1:200420043F04482488240824FF24082408244924492449044F04790401140008
+34E2:100410041F042124612492240C2412242124C0A43F242124210421043F142108
+34E3:08040804140422244124BEA4002400243E2422242224222422043E0422140008
+34E4:080408040804FFA4082408247F24002400247F244124412441047F0441140008
+34E5:08044904290429242A240824FF240124012401247F24012401040104FF140108
+34E6:0004FFC40804082410247F244124412441247F2441244124410441047F144108
+34E7:0804080414042224512488A47E240224042408247F244124410441047F144108
+34E8:080408040804FFA408242A242A242A245D2488A4082414241204210441148008
+34E9:100410041F0421244224BFA424A424A43FA424A424A43FA42484448442948108
+34EA:100008007EFC422442247E24422442247E244024482444244A44524460944108
+34EB:08040804FFC41224212440A4BF241224122412247FA412241204220422144208
+34EC:080449042A047F2408241024FFA42224412480A47F241124110421044A148408
+34ED:00047F0441047F2441247F2420247FA488A448A454A440A47E84008405140208
+34EE:00043F84248424A42EA424A43FA420A42EA42AA42AA42EA42084408442948108
+34EF:2484248449049224492424A424A400247FA448A448A47FA4488448847F944088
+34F0:0004FF84080408243E24AAA4AAA4BEA4AAA4AAA4AAA4BEA480848F84F0940008
+34F1:0804140422044124BEA4002478A44AA44AA47AA44AA44AA47A8448844A945908
+34F2:080204023FC2204220523FD2201220123FD2355235525FD255425542944A10C4
+34F3:00083E0822483E4822483E480048FF48084808482F082828281058004FFE8000
+34F4:0004FF84080410247F2455245524552455244B240824FFA41404220441148088
+34F5:0004F784948494A4F7A400247F240024FFA4202440247F24010401040A140408
+34F6:20042F04F504252475242524F5242924232408240824FFA41404220441148088
+34F7:080410047F0441247F2441247F2441247F240824FFA41C242A04490488140808
+34F8:00047704550455247724142414247724412441247724142414041F04F0144008
+34F9:00047FC4440454A4652444244A24512460A4442454A4652444044A0491142088
+34FA:08040F8408047FA448A44F2478A447A4482444247FA441245A0444048A143108
+34FB:0004FF84948494A4FFA400240024FFA4082408244F24482448044F84F8140008
+34FC:08040804FF841C242B24C8A414242224492488A449242A244904888428141008
+34FD:0804490449047F2410240824FFA480A43F240024FFA408242A044904A8941008
+34FE:00027FC240427FC242124A9247124A9250524A124FD252124202BFE2820A0204
+34FF:070478040804FFA42A24492494A42224492488A449242A244904888428141008
+3500:00047F0441047F2441247F240824FFA400247F2441247F240804490488941808
+3501:050472041284512421245EA480A43F24212421243F2421241204078478142008
+3502:0404248415047FD4151424944454209420943BF44894AA8413E4208440948088
+3503:108010F825107BFC112425247DFC0102550294FE00007FF80408080810506020
+3504:00027FC20A027FC24A524A527FD2041224921512FFD20E1215022482444A0404
+3505:04023F8204827FC204923F920412555275D244527FD2445275C25542554A8444
+3506:0004F7842104A524F7A46324B5A421247FA440A440A47FA4408440847F944088
+3507:0904F6441284A12440A4F7641524152479A440248F24F1241504120455142908
+3508:22042204FF84222414241424F7A414241424772414241424F784140414141408
+3509:00027FC240427FCA400A5FCA420A5FCA524A5FCA420A7FEA62A26FA2A0AA2064
+350A:0402FFE200027FC240525F5251527FD200123F9220923F9220823F82000AFFE4
+350B:00047A0452047BA44A247B2454A478A400247F245524552455045784FC140008
+350C:FC044B8478844AA479244D24FAA40CA407A4F82428A44D241A042904C8940808
+350D:42047BC4A50410A47FA440A47FA440A47FA440A47FA42124FFC4210441148108
+350E:52107EFE28447E28A2FE3E1020103E7C22103E1000007FF80408080810506020
+350F:00027FC210023F8A508A108A1F8A000AFBEA208A79EA492ACB22492279EA4924
+3510:210221023DE2528288527FD20A127BD20A123B920A127BD20A020FC2F80A4004
+3511:0820FFFE28207DFC44887C5041FE7C2045FC7C2000007FF80408080810506020
+3512:44427FC212023FC26212BFD222123FD222123FD220127FD251426EC24A4A4EC4
+3513:04200E207820082008FC08240824FF2408240824082408440844088409280A10
+3514:100010007E7C1244124412442244227C4A4484001FF02008200820081FF00000
+3515:202020203F20402080FC7E24002400247C240424052405240344014400A80110
+3516:100010007E7C1244124412442244227C4A44840000003FF00010001000100010
+3517:1210121012107F9012FE12927F92521252127FD212521252235222A2422A8244
+3518:102010209220922092FC9224FE24102410249224922492449E44F28401280210
+3519:4220242000207E2024FC242424242424FF242424242424242444444444A88510
+351A:04200E203820082008FCFF24082408243E2422242224222422443E4422A80110
+351B:010001007FFC01001FF000001FF0101010101FF002007FF80408080810506020
+351C:02200F20F020012091FC4A240024FE24042408240F24F8444844088429281210
+351D:0010FF9008100810FF9088FE8892CC92AA92AA92DD929992889288A28AAA8144
+351E:02200F2078200820FF7C08242A242A24EBA42A242AA46B24AA44084408940908
+351F:082028203EF8482808A83E48084A0EAA7926020202007FF80408080810506020
+3520:00207E2042207E2042FC7E2420247F2489244924552441247D4401440AA80510
+3521:082010207F20552049FC552441247F2400244424772444245544664444A80110
+3522:108010F825107BFC112425247DFC0102550294FE02007FF80408080810506020
+3523:00083F8824883F8824BE3F8A000AFBEAAAAAAAAAFBEAAAAAAAB2FBF2002A0044
+3524:102008207F20412086FC782449242A24FF242A244124BE242A443E442AA83F10
+3525:0010FF10A510A510FF7E44129492F7120492F3929012F4929712F42294AAB3C4
+3526:2210FF9008107F10107EFF9222124912BE9222123E1222123E9225222A2A3144
+3527:08100F9008107F9048FE7E1248925F9255125F1255125F124012BFA22AAA7FC4
+3528:100010003FFC4524BDC405141CF464041FC410441FC410441FC4104411541088
+3529:100010003FFC22045FC482043FE4040408841FC400041FC4154415443FE80010
+352A:100010003FFC2204420483F402043FE42AA42524326425242AA43FE420280010
+352B:0400040004000400FFFE0480048004840488089008E0108210822082407E8000
+352C:203021C03E0820081FF800001FF010101FF010101FF00100FFFE010001000100
+352D:000043F84208420843F87A08420843F8400047FE40404A4052786240454008FE
+352E:51105112FA5453D870102012FBD2AA4EFA4023D2FA542258FBD0225252528ACE
+352F:00007FFC400047F044104410480C500047F044104410441047F040007FFE0000
+3530:00007FFC4220422043A044B044A844A44AA4512041204220442048207FFE0000
+3531:00007FFC400042804CB848884EB848884FF8414042204410580840007FFE0000
+3532:00007FFC422045204AA05F7869284F2849284F28482A4A2A4D4648807FFE0000
+3533:00007FFC420045384AA85F6869284F2849284F2A482A4A4A4D4648807FFE0000
+3534:00007FFC40004FF848884FF848884FF842204FF842205FFC441048087FFE0000
+3535:7FFE40005E7852485E7851444F3C42204FF8422042205FFC4220441048087FFE
+3536:7FFE44207FBC4A647F9840665F7C51105FFE51445F7C44447FFC442844447FFE
+3537:00007FFC40004FF8408040804FF8488849484A284C284808482848107FFE0000
+3538:7FFE4000403E4FC0487C48404BFE4A424A784AC44A3C520054F06494490C7FFE
+3539:104010401040104011FC1044FE44104410441084108410841104110412281410
+353A:0100010001007FFC0100110011201020FFFE102010201022100210020FFE0000
+353B:00007FFC010003000560191861040100000001000100FFFE0100010001000100
+353C:10A01090FDFE13201DFC3120D1FC112051FE210000000100FFFE010001000100
+353D:0100010001FE010001003FF82008200827C82448244827C8200820083FF82008
+353E:00003FE02020202020202020202020202140208020002004200420041FFC0000
+353F:0000FFFE10101010101010101010101010101070119016101810001000100010
+3540:010001003FF821083FF821083FF800001FF0101010101052102210020FFE0000
+3541:010032000C7C124469440844FFC410442444244448448A5411483F4011400040
+3542:00003FFE208020802140222024102908308620802FF020102020402040408080
+3543:00003FFE2000200027FC21102110211021102FFE211021102210421044108810
+3544:00003FFE200020002FFC20802100221024202FC020802100221044084FFC8404
+3545:00003FFE2000200027FC2444244427FC2444244427FC24442040404040408040
+3546:00003FFE2000204020402FFE20402040204027FC240424042404440447FC8404
+3547:00003FFE20002080204020402FFC20002408220822102110212040005FFE8000
+3548:00003FFE2080204020003FFE20802100228426882A5032202210428843068200
+3549:00003FFE208020802140222024102BE83006200027F024102410441047F08410
+354A:00003FFE2000204820442FFE204027FC244427FC244427FC2444444444548408
+354B:00003FFE2080214022202410280837F6208020802FF82080249042A05FFE8000
+354C:00003FFE200027F8240827F8240827F820002FFC20103FFE2410421042508020
+354D:00003FFE22802240224027FC24402C4037F82440244027F82440444047FC8400
+354E:00003FFE208020802FFC20803FFE220024082FFC20002FFC292449247FFE8000
+354F:00003FFE20003F8820482F282908294829282F0E20782908260843885C088808
+3550:00003FFE2100263824082738240827F8220027FC280425542554480440288010
+3551:00003FFE220422043FC422042FBE20042FA428942F942884250443845C148808
+3552:3FFE240822103FFE20802FFC20803FFE20A02F2822243FFE42285F12822A06C6
+3553:00003FFE200027FC255424E427FC204027FC20402FFE24A4285247FC40408FFE
+3554:3FFE20103F102AFE2E102AFE2EAA2AAA3EFE22003EFE2A205E144AA2BF280218
+3555:0100010002000420081010083FFC10040100010002000420081010083FFC1004
+3556:0400082010103FF80810102024487EFC02040100FFFE054009203118C1060100
+3557:41002210FF9008107F200820FFA0104010483E8442FC84040800140023FEC000
+3558:0400082010103FF80810102024487EFC010006C01830E10E0920111025080200
+3559:1080108020F04510FE2029FC4524A3243D2445FC4450A858109428924512820E
+355A:00003FF01010121011200920082044402440228001000280044008203018C006
+355B:00003FF000201E40018006601818E0043FF010100820044003800C603018C006
+355C:010001003FF8210821083FF8010001003FF010100820044003800C603018C006
+355D:010001007FFC010001001FF0101010101FF000003FF00820044003801C70E00E
+355E:00003F00217C21243F242424242424283F283528351055105528972804440482
+355F:080008000F0008FC08447F445544554455287F28551055105528512845444282
+3560:4140212003FE0A2017FCEA2023FC222023FE02003FF00820044003801C70E00E
+3561:08000F00087CFFA480A47F2414242228492816282110FE10222822283E442282
+3562:10001E00107CFF4481447E4400447E2842287E2842107E1042287E2824444282
+3563:00400840082010201010200840049FF2101010101010101010101FF010100000
+3564:01000100790049004BF04910491049104910491079104A1202120412080E1000
+3565:004000407C404440444044404440444044A044A07CA045100110020804040802
+3566:00001FF01010101010101FF0010001000100FFFE02800440082010102008C006
+3567:000001FC790449044904490449FC490449004900790049000200020004000800
+3568:000001F0791049104910491049904950495049107910491202120212040E0800
+3569:0020002078204BFE48204820482049FC4820482078204BFE0020002000200020
+356A:0040004078404BFC4A444C484840484048A048A078A0492001220222041E0800
+356B:0080004078404FFE49004900490049F849084908790849080208020804500820
+356C:002001207920491049104A484A484C444882488079104908020807FC02040000
+356D:001000787BC048404840484048404FFE484048A078A048900110010802040402
+356E:0020011079084A044A044C104910491048A048A0784048A00110020804040802
+356F:0100010001007FFC410442844444482457D444444444444447C4444440144008
+3570:0008003C79E048204820483C49E048204820483E7BE04820002200220022001E
+3571:00900088788848804FFE48A048A048A048A048A07920492201220222021E0400
+3572:00400040F040904097FE904090E090E091509150F24894440842004000400040
+3573:00000008790848884A524A524A224A224A524A927B0A4A0A020203FE00020000
+3574:000000007BFE4A024C04480049F04910491049107910491202120212040E0800
+3575:000003FE7820482048204820482049FC48204820482078204820002007FE0000
+3576:000003FC78404840484048404BF8488848884888788849080108010807FE0000
+3577:00200020784049FC490449044904490449FC4904490479044904010401FC0104
+3578:00800040784048004FFC480048084A084A08491079104910012000200FFE0000
+3579:00400048784448404BFE4880488048FC4944494479484A500220045008880306
+357A:00007CF84488448844887CF800000000FFFE080010001FF00010001000A00040
+357B:0200010000007FFC010003000D603118C10401001FF01010101010101FF01010
+357C:0100010079FE4A024A024C8A48524A224A524A8A7A024BFE0002000200140008
+357D:0008008878484A284A284A084A084A084A084A084A107A984B24022400420082
+357E:0100010009200910110821044104000000403E4422482270224022423E42223E
+357F:00701F8001000100FFFE054009203118C0061FF010101010101010101FF01010
+3580:004000407BF848484FFE48484BF8484048404BF87840484007FC004000400040
+3581:00080190786048984B04484048404FFE48804890791049200248048409FC0084
+3582:004000407BF84A484A484BF84A484A484BF848407848483000640194060C0004
+3583:0008003C7BC04A004A004BFE4A004A004A004AFC7A844A840484048408FC0084
+3584:0104012479244924492449244BB44B6C4D244924792449240124022402040404
+3585:00280024782448204BFE4A204A244A244A244BA87A284A100212042A04460882
+3586:00500050785048504BFE4A524A524A524A524BFE7A524A520252025203FE0202
+3587:000003FE7820482048404BFE4A524A524A524A527A524A5202520242020A0204
+3588:02083FD00220FFFE02000C703F84C80407FC00001FF01010101010101FF01010
+3589:002000207850488849244A224C204920493C492079204920012007FE00000000
+358A:000003FC7804480449FC480448044BFC480848084FFE79084888008800280010
+358B:0100028004401830E44E0440044004400840104000007C8844B044C47C84447C
+358C:0880088013F03090509090921112120E140000003E442258226022423E42223E
+358D:0040044002401240084009FC7E400040004000003E442258226022423E42223E
+358E:00807C8844B044C444847C7C0100028004401830E44E04400440044008401040
+358F:000001FC7904490449FC4904490449FC4820482079FC48200020002003FE0000
+3590:7CF8448844887CF800003FF002100210FFFE021004103FF0081010002000C000
+3591:0014001278104FFE48104A904A924A924FD24A947A944A88028A049A04260842
+3592:0108008878904BFC482448244BFC4A204A204BFE786248A2012A022404200020
+3593:010001F87B084C90486049984E4648404BF848407BF8484007FC004000400040
+3594:000001FC7820482048204BFE4850488849044AFA7C8848880088008800F80088
+3595:0040002079FC4800488848504BFE48204820482079FC48200020002000200020
+3596:020001003FF808200440FFFE010001003FF8010001003FF8200820083FF82008
+3597:004002487A484A484BF8484048A049104A884C4678404BF00010002000200040
+3598:000003FC7A004A004AF84A004A004BFC4AA04AA47AA84A900290048804A408C2
+3599:100010007E7C124412441244227C4A44840000003E442258226022423E42223E
+359A:0810081017FE30105210911011101050102000003E442258226022423E42223E
+359B:010001007FFC010001001FF0101010101FF000003E442258226022423E42223E
+359C:02000100FFFE00001FF0101010101FF0000000003E442258226022423E42223E
+359D:010001003FF801000100FFFE09203118C10600003E442258226022423E42223E
+359E:000001FC79044904490449FC482048204BFE4A227A524A8A030A0202020A0204
+359F:001C03E0F08492449148911097FE9402900093F8F108911000A0004001B0060E
+35A0:002000207BFE4850488849044AFA480048004BFE782049240122022200A00040
+35A1:00800040F7FE91209120923C9244966492949348F24892300220025002880306
+35A2:00800040EFFEA800A890A890AA90AA92AADCAA90EA90AA92129212D2270E0000
+35A3:0040002079FC48004908489048004BFE4800480079FC49040104010401FC0104
+35A4:000001FC780848104A224AAA4A724A224A724AAA7B264AA20242020203FE0002
+35A5:000007FCF404943495C49444944497FC944494E4F554964C0444044407FC0404
+35A6:00400040F7FC904093F8924893F8924893F89040F0E0915002480C4600400040
+35A7:001C03E07A204BFE4A204A924B0A4A0649FC4904790449FC0104010401FC0104
+35A8:000001F87808480849F8480848084BFE48204A22797448A80124022200A00040
+35A9:00000FC0F4BC94A494A497A494A494A897A894A8F49095D00EA800A800C40082
+35AA:0014001278104FFE481048104BD24A524A524A547BD4480800EA071A02260042
+35AB:0020002079FC482048204BFE488849444A4248F879884A500020005001880606
+35AC:0080031C7A044A044B9C4A044A044BFC480048007BF849080090006001980606
+35AD:000003FCF040904097FE90A09110920894469040F04892640252045201400080
+35AE:00400040F0A0911092089DF6900097FC94A494A4F7FC94A404A404A404140408
+35AF:3FF820082FE8200827C8244827C82028201000003E442258226022423E42223E
+35B0:00807C8844B044C444847C7C00003FF820082FE8200827C8244827C820282010
+35B1:0100FFFE088010F83148D328149010601198160600003FF8200820083FF82008
+35B2:10001000FE7C2244444434440844147C2244C0003E442258226022423E42223E
+35B3:1080088047FC21100A1011A070601090130800003E442258226022423E42223E
+35B4:011001107BFE49104880488049FC49544A544C9478A449240244008401280210
+35B5:000001F87908490849F8490849F8490849F8490879084FFE0000011002080404
+35B6:000007FCF0A090A097FC94A494A494A497FC9040F04097FC004000400FFE0000
+35B7:000001FC7904490449FC4904490449FC48004BFE78204920013C012002A0047E
+35B8:0040007C78404BFE4A424A784BC04A444A3C4A007AFC4A8003FE0480048008FC
+35B9:0010011079084A044DFA488849084A284C104BF87AA84AA802A802A80FFE0000
+35BA:00400040F7FC904093F8908097FC9110920895F6F110911001F00110011001F0
+35BB:000003F8F090906097FC90A49128922094609040F7FC90E0015002480C460040
+35BC:008800887BFE4888488848F84888488848F848207BFE487000A8012402220020
+35BD:000003FE7820484049FC4904490449FC490449FC7904490401FC000000880104
+35BE:00007EFC428442847EFC10100820FFFE0100210821083FF8040808003000C000
+35BF:00000FDEF4929492949497949498949497929492F49295DA0E94009000900090
+35C0:00400040E148A148A94AAA52AAD6AB5AA94AAA52ED6AAF7A094A08420FFE0002
+35C1:000003DE7A524A524BDE480049FC48004BFE4880790049FC0004000400280010
+35C2:00200020792449224A2A483048C04F0049FC490479FC490401FC010401FC0104
+35C3:000003FC7A044BFC4A204BFE4A104A8A4B0648007BFC4A0403FC020403FC0204
+35C4:000003FC7A944A944A944BFC488048404FFE488078F848880108010802280410
+35C5:0100013C79244FE44924493C49244BA44AA44ABC7AA44AA403A4004400540088
+35C6:008800887BFE488848F8482049FC4924492449FC78204BFE0020002000200020
+35C7:000003DE7A424A424A424BDE4A004A3E4BD24A127A144BD40208021402240242
+35C8:000003FC788848504BFE4A224BFE4A224BFE4A2278404BFE0042008201140208
+35C9:08007F7C08243E2408447F54088804000FE0144003801C70EFEE08200FE00820
+35CA:00003EF822882288228822883EF8000000007EFC42844284428442847EFC4284
+35CB:0080008079FC4A044C084BFE4A004A804AFC4B207A204BFE0420045008881306
+35CC:0040002079FE49024A0449FC4840488849FC4824782049FC0020002003FE0000
+35CD:003803C0F040904097FC91509248944693F89208F20893F80208020803F80208
+35CE:02000200F7BC92A492A494A495BC9840904097FCF0E091500248044408420040
+35CF:000003FE78104820486848A44B22482048004BFE78204920013C0120012007FE
+35D0:004000407BFC484048A049104A884C4648004BF87AA84AA802A802A80FFE0000
+35D1:010003BCEE10A210A23CAF90A210A23CA210AF90E27EA2100210021004100810
+35D2:00800040F7FE900093F892089208920893F890A4F12893100510094801860100
+35D3:00100420F2F89288908890F89E80928092FC9284F28492FC0284050008FE0000
+35D4:0040007C78404BFE4A424A784BC44A3C4A404A207BFE4A880250042004580986
+35D5:008800887BFE488849FC48884BFE482049FC492479FC492403FE010401140108
+35D6:003C03C078444A244928490048404B9C4A044A047B9C4A040204020403FC0204
+35D7:00407C8045FC452445247DFC212421447DFC2490251027FE4410441094100810
+35D8:002800247BFE482049FC492449FC492449FC492478084BFE0088004800480018
+35D9:0080008079FC4A44495449F4488449284A9049FC7A444D5401F4008401280210
+35DA:000007FCF0A090A097FC94A494A497FC90409040F7FC90E0015002480C460040
+35DB:02100210F3DE95289884903893C09040904097FCF04090A000A0011002080C06
+35DC:00800040F7FC9080910893F09060918497FE9002F7FC944407FC044407FC0404
+35DD:01040084788848004BFE4820482049FC482048207BFE480002A4025204520000
+35DE:000800087788527E524A544A57485D7C55545554755457540548008801140022
+35DF:2080104087FC4040104023F8E040204027FC200000007C8844B044C47C84447C
+35E0:084008407E8413FE220214FC0884148462FC00003E442258226022423E42223E
+35E1:0440FFFE0440100027F86110A13C21042214240800007C8844B044C47C84447C
+35E2:01C8070871085FE8511E57CA554A57CA554A57CA710A57CA011201D20E2A0444
+35E3:02A802A877FC52A852AA54E6580057FC5444504073F852480248024802580040
+35E4:002800243FFE2220232422242FA822182A92522A464680820FF808080FF80808
+35E5:0200011E77D2501257D4545457D8501457D25092711251DA0714011005100210
+35E6:00101F20EACEAAAAAEAAAAAAAAAAAEAAAAAAAAAAEBEAAEAC1A28024802480288
+35E7:004000207BFE4A8A49044BFE4840488849FC4824782049FC0020002003FE0000
+35E8:00007F7848485F4C64805F7844484A4851307F4C00003FF8200820083FF82008
+35E9:000003DE78424A52494A4A524842482049FC4904790449FC0104010401FC0104
+35EA:009000927AD44A9A4AD24F4E488849F0482048447BFE48220128022404A20040
+35EB:010001107BDC4A544D544A8849084AF44C0248007BFC48400150024805440080
+35EC:111009207FFE40029FF410101FF002000FE034C00700388003F81D3001C03E00
+35ED:001C01E07820492448A84BFE487048A849244A227840482402A2028A04880078
+35EE:202020103DFE4510457CA9141914117E21147D14A57C251025283E2802440482
+35EF:01081FD001207FFC02000FF03810CFF008100FF000007C8844B044C47C84447C
+35F0:01240124722454245954514A529256105A105250725C5250025002B0029E0300
+35F1:014001207BFE4E204BFC4A204BFC4A204BFE4A4078404FFE015002480C460040
+35F2:004003F878484FFE48484BF848404FFE48004BF87A484BF8024803F8000007FE
+35F3:021002107BDE4A284D4448A049104A084DF6480078004BF80208020803F80208
+35F4:079E0492F79E9492979E940294F2949294F29492F4F294920492053204020406
+35F5:02100290EA90AB3EB222A544A890B210A290AB10EA28B228052808C410440082
+35F6:002403A878924D144A084C044BBA48A848C64B807A3C4B8400A8009002A80144
+35F7:002003FE7A5249FC485049FC48504BFE480049FC790449240124005800840302
+35F8:0280048EE8E0B140A040A24EA5F4AC44B444A554E554A5740594040404140408
+35F9:0140012073FE56205BFC522053FC5220522053FE724050240522050A08F80000
+35FA:000003F8708057FC511052085CA650A057BC50A073B850A007BC00A000A000A0
+35FB:000004F8728852E850A850A85DFC55045574555475745504051405080A0011FE
+35FC:00A004A4F2A890A097FC911090A097FC904093F8F04097FC015002480C460040
+35FD:11002BDE4A5273D42A524BD27A1A12942350C24000003FF8200820083FF82008
+35FE:05100518EFA8A528A76AA2AAAFAAAAACAAACAFA8E238AFAA022A022A02260220
+35FF:0000079E7492579E5492579E540255FA541255D2755255D204120452042A0404
+3600:008003387A084BB84A084A084BF848404A4849504FFE78E0495002480C460040
+3601:000007FCF4A497FC904093F8904097FC911090A0F3F890400FFE004000400040
+3602:010800907BFE490849084A524B9C49084A524BDE784048A402AA028A04780000
+3603:008803FE788848204BFE484048F849884A8848F87840482402A2028A04880078
+3604:020002FEE2AAA2AAAFAAA2FEA620A710AAFEAA20F220A23C0224024402540288
+3605:02400240E4AEA890B300A2E0A45EAC44B5E4A444E554A4E4044404640584040C
+3606:00400FFEE040A7FCA000A3F8A208AFFEA802A7FCE110A3F8004007FC00400FFE
+3607:01100554F5B8991092A89444900097FC94449040F7FC90E0015002480C460040
+3608:0400057CF60494A89390907C941497949A5092509FDCF250955004B0089E0100
+3609:02100210F3DE95289084900097BC94A497A494A4F7A49434052806A004200020
+360A:07FC0040EFFEA842A358A040A358A080A040AFFEE000A7FC000007FC040407FC
+360B:07DE051277D2545457C8551457E2500053FC520473FC520403FC020403FC0108
+360C:020203C2E202AFEAAA2AAB8AAE4AA9CAA80AAFEAEA0AAD4A0A820DC212AA2584
+360D:0108014CE52AA548A88EA138A288A7EABC8AA7ECE48CA7E8048A07FA04260442
+360E:040002FEE202A802AB92A892AFDEAAAAABCAAAAAEB92AAD20FAA08C608820806
+360F:211017FE108003F8F20813F8120813F8120813F8280047FE00903EE422843E7C
+3610:001007C8753E57C0551457D25522550057D450547554554805480454005401A2
+3611:041004101F7CE414A414AEFEA014AE14A07CBF10E45404381654251214500820
+3612:0C3871E0102013FEFD2431FC392455FC502093FE10007C8844B044C47C84447C
+3613:07BC04A4F7BC94A497BC944495F4944495F49554F5F4955405F404E40554044C
+3614:004007FE749253FC509053FC509057FE510853FC750A51F8010801F800900108
+3615:009007FE78904BE84A884BCE4A504BD44AA24BE278004BFC0294029407FE0000
+3616:0200011EEFC4A448A29EAFD2A912AA1EAC92A91EEA12AC52089E0900120C0412
+3617:07BC04A4F7BC94A497BC94A497BC912093FE9220F7FC9A2003FC022003FE0200
+3618:210447C88812F3BC20084B92F83E0380AAAAABAA00003FF8200820083FF82008
+3619:07BC04A477BC500057FE54005590549E57D4556475D4555405D405680BC81054
+361A:0FBE08A2EFBEA8A2AFBEA802AB92A892AFDEAAAAEBCAAAAA0B920AD20FAA08C4
+361B:004000A073185DF6500053F8520853F8511057DC72844FFC045007DC045204CE
+361C:51184B947C3ED3A87C7E53A87C3E53A87EBE43A000003FF8200820083FF82008
+361D:00007FFC400440044FC44044484444844284410442844444484440047FFC4004
+361E:00007FFC4204420442045FE4422442244224442444244824494450847FFC4004
+361F:00007FFC40044444444444445FF444444444444448444844504440047FFC4004
+3620:00007FFC4004420441444144448454A45514665444444BC4500440047FFC4004
+3621:00007FFC400440045FF4511451145FF4511451145FF45114410441047FFC4004
+3622:00007FFC41044924452445445FF442844284428444944894507440047FFC4004
+3623:7FFC400447C4444447C440044FE448244FE448244FE4482448A448447FFC4004
+3624:00007FFC4144655455544774641457F44414577465544554495450147FFC4004
+3625:FFFE8002861AF8E2AA42949290E2BE4AC8FABE2288AAAB26BE628002FFFE8002
+3626:104010401040104011FCFE44104410441044108416841884E104410402280410
+3627:100011F8100810501020FC1013FE10221024102010201C20E020402000A00040
+3628:202020202020202023FEFA22222222222252224A228A3B02E2024202020A0204
+3629:10101110111011121112FD1411D811101110111011101D12E1524192010E0000
+362A:1008103C11E010201020FC3C11E010201020103E13E01C20E02240220022001E
+362B:108810881088108811FCFC881088108813FE108810881C88E088410801080208
+362C:21002100210021FCFA042484208421042144222427F43A14E004400400280010
+362D:20802080213E21022242FA4227C220822082210221423A22E7E24222000A0004
+362E:100011FC110411041104FD0411FC11241120112011101D10E208420804040802
+362F:10801080110011FE1200FC40104013FC1044104410841C84E104410402280410
+3630:10101110109010901010FD10109010901010101E13F01C10E010401000100010
+3631:10201020102011FC1124FD2411FC11241124112413FE1D04E104410401140108
+3632:200023FC2204220423FCFA402240224023F8224822483A48E488448A090A0206
+3633:044004447C48047004400C423442C43E010001003FF8010001000100FFFE0000
+3634:01000110791049104910492849247944010001003FF8010001000100FFFE0000
+3635:10401040104017FE1080FCA0112011FC1324152411241D24E134412800200020
+3636:081008101EFC221052900C9008FE10102010411001003FF801000100FFFE0000
+3637:1110111013FC11101110FC00120812081110111010A01C40E0A0411002080C06
+3638:0000FFFE104010443E484270A44018421042213EC1003FF801000100FFFE0000
+3639:0880088828902EA028C028842E84F07C010001003FF8010001000100FFFE0000
+363A:2120212821242224FA20263E2BE022242224222822283A10E212422A02460282
+363B:200023FE220222222222FA2223FE222222222252224A3A8AE302420203FE0202
+363C:1040104411F410481050FDFE1040108011FE124014801CFCE004400400280010
+363D:084008487F4408440840FFFE0040084408447F440828082A0F12F02A40460082
+363E:2040202023FE22022404F80021FC20202020202023FE3820E020402000A00040
+363F:100011FC1104110411FCFD04110411FC1020102011FC1C20E020402003FE0000
+3640:2080204027FC24042110FA082484208023F0209020903910E1124212040E0800
+3641:1080108010FE110012FCFC8410A4109413FE108411241D14E1FE400400280010
+3642:110410841088101011FCFD041104110411FC105010501C90E0924112020E0400
+3643:1010103811C011001100FDFC111011101110111013FE1C00E090410802040402
+3644:11101112111411D81110FD121152118E1120102011FC1C20E020402003FE0000
+3645:200023F8220822082208FBF82040204027FC20E021503A48E444484200400040
+3646:2040202023FE22022444F84023FE20402090209021103920E224424204FE0842
+3647:100013FE104010801144FE24106812B0113012A810681CA4E122422000A00040
+3648:20402040207C204023FCFA44227023C02244223C22003AF0E49044920912120E
+3649:10501050105011FC1154FD54115411FC115411541D54E3FE4000008801040202
+364A:200021FC210021F82100F9F821002FFE2280224822503A20E210428803060200
+364B:1088108813FE10881088FCF81088108810F810881C88E3FE4000008801040202
+364C:1020102011FC102413FEFC2411FC10201124112411741DACE124412402240424
+364D:200027BC208422942108FA9424A42840200027BC20A43AA4E128429004A80846
+364E:2014201227FE2410F41027F02492249227D225543554E488454A0A1A08261042
+364F:1100110011FE120015FCFD0411FC110411FC108010FC1D08E290406001980606
+3650:102011241124112411FCFC0013FE1020104011FC11541D54E15441540154010C
+3651:00F03F0001001FF011101FF001007FFC412441F45E14400801003FF80100FFFE
+3652:00F87E084A504A207EFC4A244A287E2000A0014001003FF801000100FFFE0000
+3653:010001003FF80100FFFE08203EF808200E2078FC01003FF801000100FFFE0000
+3654:1040104011FC108413FEFC0011FC110411FC102013FE1C20E22043FE00200020
+3655:200023FE222223FE2222FBFE200021FC210421FC210439FCE104410401140108
+3656:1004101E13E0102011FCFD24112411FC102013FE12221E2AE2FA4202020A0204
+3657:200023F82248224823F8FA48224823F8200027FE22403A44E228429003080206
+3658:200023FE2050205023FEFA52225223FE2000204027FE3888E190406000D80304
+3659:2120111097FE4128493409281132E124223A2262259E01003FF801000100FFFE
+365A:1088105013FE102011FCFC2013FE100010A010FC11201C20E3FE402000200020
+365B:1028102413FE102011FCFD2411FC112411FC11241C08E3FE4088004800480018
+365C:0100FFFE00001FF010101FF000007FFC40044FE448244FEC01003FF80100FFFE
+365D:204021FC204420942108FBDE214A214A229421FC210439FCE10441FC0104010C
+365E:1020104011FC110411FCFD0411FC110411FC102013FE1C70E0A8412402220020
+365F:2100209E23D222522252FBDE2252225223D2221E22923A52E2D24352022A0044
+3660:7F7848485F4C64805F7844484A4851307F4C000001003FF801000100FFFE0000
+3661:21242124222424242954F94A229226102A102250225C3A50E25042B0029E0300
+3662:2088208823FE20882088F8F8202023FE2222233222AA3B76E2224222022A0224
+3663:20002F3E2120213CF1202F3C282028FE28502F523154E148414801440A620440
+3664:2040207C204023FE2242FA7823C4223C220822F023243AA8E5FE442008A00040
+3665:2080204027FC2110FA482484212023F02010208821503B20E510494801860100
+3666:0808144822285C8888487F0E08F82A084908180801003FF801000100FFFE0000
+3667:200023FE205023DE2252FA5223DE205023FE222222223BFEE222422203FE0202
+3668:224822482554275C2248FD54275C22482FFE222022283A28E5144494042C0844
+3669:2040204027FC20A02514FA0827FC2A0A23F8220823F83840E248444409440080
+366A:202023FE202021FC2000FBFE220221FC200021FC210439FCE104408803FE0000
+366B:10A0109011FE132011FCFD2011FC112011FE11001C20E3FE407000A803260020
+366C:081408127F102AFE2A105D101C282A284944888201003FF801000100FFFE0000
+366D:20002FFE28002A28F9482BEE289228842AA02AA83BE8E8884894091409241242
+366E:2210221023DE22282544F8A02110220825F6200020003BF8E208420803F80208
+366F:08203E2008F87F282228496A3E2A08567E8200003FF80000FFFE082010103FF8
+3670:10001EFC22247F44A99C3F50297C3F9029FE29104510821001003FF80100FFFE
+3671:00207C3C44207DFE0122FD3841E47D1C05702A54148C01003FF801000100FFFE
+3672:2040202027FE20282224F27E24C82748217E224824C8377EE1484248047E0840
+3673:2014201227FE2410F5D0241425D4255825CA24163442E82442A2028A04780000
+3674:210021F8220827FE2288FB2423FE220022FC220022FC3A00E2FC448404FC0884
+3675:102013FE100010F81088FCF8100013FE120212FA128A1EFAE22641F8002003FE
+3676:0100FFFE10101FF00000111009207FFE40029FF410101FF001003FF80100FFFE
+3677:200023FE220223FE2202FBFE21082252239C210822523BDEE00042A402520452
+3678:212821AA216C2228FAFE264426282AFE2210227C22103AFEE210422802440282
+3679:2088208823FE208823FEFA5223FE200023FE224220F83908E290406000C00700
+367A:27FE242025FC252425FCFC2027FE250425FC250425FC3D04E5FC4488050407FE
+367B:202027FE240025FC2524F5FC252425FC242025FC242037FEE5244AFA082013FE
+367C:23F82248224823F82248FA4823F820002FBE2AAA2AAA3FBEEAAA4AAA0FBE08A2
+367D:2020202027FE202023AEF92423AE22AA23AE22AA23AE3850E050408801040602
+367E:22A0244C24A4260CF4A4264C24A42FFE280223F03020E04047FC004001400080
+367F:211027FC204023F82040F7FC200023D4211227FE23503534E78C42CA045608C2
+3680:210821EC210A27E8F52825DE272824EA240A27EA340CE7EC4A2A0BEA115607E2
+3681:101010107C7C1010FEFE4444EEEE44446464DEDE0000FEFE28282A284C4A8886
+3682:204027FC224823F8F0402FFE2AAA23B8211027FC3110EFFE412803100D480186
+3683:010001007FFC01001FF000007FFE400284442388244820083FF8082004407FFC
+3684:01007FFC01001FF000007FFE51129FF411101FF000007FFC010411F0290047FE
+3685:020007E00820144003801C70E00E1FF0010011001FF821005FF00100FFFE0000
+3686:02000100FFFE00001FF010101FF010101FF008000FF01420224041800E60701C
+3687:044022882108228824483FF81210220847E4082014402280010006C01830E00E
+3688:1010101010101E101210221022FE52108A100410041008100810101020104010
+3689:00003FF008100820083C120417E438544588068039F80610192000C003003C00
+368A:202020103C1045FE4820A824104428F84E12122224445588081010282044C182
+368B:200021FC3D2445244974A92411FC29044F74135425545574090412042214C408
+368C:200021FC3D24452449FCA924112429FC4E2013FE247054A8092412222020C020
+368D:202021FC3D2445FC4820ABFE100029FC4F0413FC250455FC090411FC2088C104
+368E:010001007FFC0280044008203018C0060000200820082008200820083FF80008
+368F:010001007FFC0280044008203018C006082008207FFC08200820102010202020
+3690:010001007FFC010002C004201810600801000100FFFE0280044008203018C006
+3691:00003FF8000800081FF8000800083FF801000100FFFE0280044008203018C006
+3692:0100010001007FFC01002120111011102928454402800280044008203018C006
+3693:010001007FFC028004400820311001007FFC0380054009203118C10601000100
+3694:020002007FFC044008203018C82604403FF801000100FFFE0100010001000100
+3695:020002007FFC044008203458C4467FF804483FF824403FFC0844105420484040
+3696:010002001FF0101010101FF0101010101FF0010001007FFC028004401830E00E
+3697:020002007FFC044008203018DFF6101010101FF010101FF010101010FFFE0000
+3698:10201020102010207DFC102010201020FDFE1020105010502888248845048202
+3699:100010007E7C124412441244227C4A4485000100FFFE0280044008203018C006
+369A:020002007FFC044008203218C7E608203440028003001FF0E81008100FF00810
+369B:020002007FFC0440082038D8CF06081007F000001FF010101FF010101FF01010
+369C:020002007FFC044008203098C0A63FF800803E8022483E5000240E54718C0604
+369D:020002007FFC044008203018C806084013F8304057FC904013F8104017FC1000
+369E:020002007FFC044008203018C82608207EFC08201C702A6848A4892208200820
+369F:08001FC020807FF0A0103FF020883CF420843D7C01007FFC028004401830E00E
+36A0:020002007FFC044008203458C2863FF801001FF001007FFC0000248822444244
+36A1:10101010FEFE101028284444FEFE040474745454545474745454040414140808
+36A2:10801080108020802FFE61086108A2082210261021A0204020A0211022082C04
+36A3:02000200FFFE08401C8003800470180862000200FFFE08201C4003800C707008
+36A4:1048104410441040FE4E23F02240224042402440142008221412220A42068002
+36A5:100011FC10201020FC202420242027FE24204820282010202820442084A00040
+36A6:100011FE10481048FC4824482448244824484848284810482888448885080208
+36A7:10201010101010FEFC8024802480248024804880288010802880450085000200
+36A8:100013F010901090FC902490249027F02490489028901092288A448A84860082
+36A9:100010FC10841084FC8425FE24842484248449FE288410842884448484940088
+36AA:1008103C11E01020FC20243C25E024202420483E2BE01020282244228422001E
+36AB:200023FC20842088F8884890489C488489444944312811282A104A2884440182
+36AC:10401040108010FCFD0426042484244424444814282410442984440484280010
+36AD:1040105010481048FC4025FE24502450245048502890109028924512850E0200
+36AE:1000100011FE1102FD02240024782448244848482848104A284A448A84860100
+36AF:200023F822082208FB284AA84AA84A488A484AA832A8132A2C0A440A88061002
+36B0:100011FE10101010FC202420246824A425224A22282010202820440083FE0000
+36B1:1008101C10E01080FC802480248024FE24884888288810882888448885FE0000
+36B2:1020102010201020FC3E24202420242025FC4904290411042904450485FC0104
+36B3:210021002100211CFBD4495449544954895449543154115429544A5C83540480
+36B4:20402040204023FEF88048A0492049FC8B244D24312411242934492880200020
+36B5:10401040107C1084FD8826502420245024884B0628601010280844C084200010
+36B6:100011F811081108FD08250825F82500250049FC290411042904450485FC0104
+36B7:2020202020502050F88849044A22482048A890A4512421223222482048A08040
+36B8:100011FC10041004FDF42404240425F42514491429F411142804440484280010
+36B9:20002080231E2252FA524A524A524A524A5292D2535A22543090489049108210
+36BA:100011FC10441048FC8E2482257A2614242048202BFE10202820442084A00040
+36BB:00003FF8210821083FF8210821083FF804000400FFFE08201C4003800C703008
+36BC:1000100011FC1124FD2425242524252425FC4924292411242924452485FC0104
+36BD:00007DFE1040108011FC10041E04E00442280210FFFE08201C4003800C707008
+36BE:100011FC11041104FD04250425FC2450245048502850109228924512820E0400
+36BF:1040104010FC1084FD0426F42494249424F448842894108828824482847E0000
+36C0:1080108010F81108FE10242025FC24042404480429FC10042804440485FC0004
+36C1:100011FC10201020FD2424A424A8242027FE4820282010202820442084200020
+36C2:1008101C11E01100FD00257C2554255425544954297C1140294046428242043E
+36C3:080008007F7C08243E2408247F4408540A880200FFFE08201C4003800C707008
+36C4:10401020102011FEFC40244024A024A225A44A982C901088288844A484C20080
+36C5:100013FE10881088FCF82488248824F824884888288E13F82808440884080008
+36C6:100011FC10441048FC5E2482248A252424204BFE2820107028A8452482220020
+36C7:10201010101011FEFD00251025102510257C4910291011102910461082FE0400
+36C8:1040104411F41048FC5025FE2440248025FE4A402C8010FC2804440484280010
+36C9:100013FE10501050FDFC25542554255425544954298C11042904450485FC0104
+36CA:100010F810881088FC8824882526262025FE4820287010A82924462284200020
+36CB:2040204020A020A0F9104A484C46484049449152524A244A3048484049408080
+36CC:2040204020902108FBFC48244920492049FC9220502027FE3020482048208020
+36CD:10201020102013FEFC2024202524252425244AAA282010502850448881040202
+36CE:100010FC10841084FC84248424FC2400240049FE290211022902450285FE0102
+36CF:1028102410241020FDFE2420252024B224B4486828A811242A22442084A00040
+36D0:100013FE10201020FDFC2524252425FC2524492429FC112028A0444080B0030E
+36D1:08000F7C28443F44612892100C683186C0000400FFFE08201C4003800C707008
+36D2:100011FE10001000FCFC24842484248424FC4800288410442848440085FE0000
+36D3:21842068203020C8FB0448404BFE48A0492093FC552421243134492848208020
+36D4:1040104010FC1088FD50242024D8272624F8482028F810202BFE442080200020
+36D5:100010F810881088FCF8240025FC25242524492429FC110029004502850200FE
+36D6:2040204020882104FBFE4802488849448A4248F8318812502820485081880606
+36D7:1020102010A810A8FCA8257426222420242049FC282010202820442083FE0000
+36D8:2020202023FE2020F8204BFE4A024C0449F89010502023FE3020482048A08040
+36D9:1040102011FC1000FC88245027FE24202420482029FC10202820442084200020
+36DA:100011F8100810D0FC2025FC2524252425FC4924292411FC292445248524010C
+36DB:1040108011F81108FDF8250825FA250A250C4BF8281810282848458886280010
+36DC:1040104024FE6488A548245024202450228C0200FFFE08201C4003800C707008
+36DD:100011FC11041104FDFC2504250425FC2504490429FC10002888448481020202
+36DE:100013FE10201020FDFC2420242027FE248848882BFE10882888450881080208
+36DF:1080108010F81108FE1025FC25242524252449242BFE10502850448881040602
+36E0:210020BE22822202FA024AFA4A8A4A8A4AFA928A528A22FA32024A024A0A8204
+36E1:1040102013FE1202FC0425F82400240027FE48902890109029124512820E0400
+36E2:201C21E020202020FBFE48A849244A2289F84888309010BE2902490282140408
+36E3:100010F810881088FCF8240025FC250425244924292411242850444880840304
+36E4:200023FE20002000FBDE4A524A524A524B5A92D65252225232524A524A5282D6
+36E5:1020102213B410A8FCA8252426A2244025FC4904290411FC2904450485FC0104
+36E6:2110211021102110F7BC51105110533853B89554555429922110511051108110
+36E7:1020112411241124FDFC2400240027FE2440488028FC11842A84448484FC0084
+36E8:21082088209023FCF84048404BF8484088404FFE30A010A0292049228222041E
+36E9:1040102013FE1080FD0427FE240225FC250449FC290411FC2904450485140108
+36EA:1020102013FE1050FC882524262225FC252449FC292411FC28224422841E0000
+36EB:100010FC10841084FCFC2484248424FC244048FE292A124A28924522844A0084
+36EC:2020202021FC2020F8204BFE488849044A22902051FC2020302048204BFE8000
+36ED:10881088108813FEFC88248827FE240025FC4904290411FC2904450485FC0104
+36EE:1040102013FE1222FCA4252824502488250448F8288810882850442080D80306
+36EF:22102210239024BCF91457D455545554555497D452A422AC22C25482547E8800
+36F0:100011FC110411FCFD1025FE2510254A2586480029FC110429FC450485FC0104
+36F1:100011FC11241124FDFC2524252425FC24004BFE292011222914454885840102
+36F2:100013FE10201040FDFC2504250425FC250449FC2904110429FC440084880104
+36F3:01007FFC082004407FFC41041FF01110115011200200FFFE08201C4003C03C38
+36F4:2092212422482124F892484048804BFE4A02928A5252222232524A8A4BFE8202
+36F5:101E13E010441124FC88242025FC2524252449FC292411242BFE450485140108
+36F6:1020112411241124FDFC2480248027FE24904910295212542AA8442888440082
+36F7:0C48704413FEFC50305058929492110E12000200FFFE08201C4003800C707008
+36F8:1020102013FE1020FC2025FC2400240025FC4904290411FC28004488845003FE
+36F9:210021FE21102210FAFE4A924E924AFE4A92929252FE229032504A204A588286
+36FA:1040102013FE1000FD04248827FE240025FC4904290411FC2904450485FC0104
+36FB:2020202023FE2050F8884B2649FC4820482093FE5000202031FC4820482083FE
+36FC:1008103C11E01020FC2027FE242024A0252C4924292411AC2924452485FC0104
+36FD:2040202023FE2202F820492448A848204BFE907050A820A831244A2248208020
+36FE:2008200C200A23FEFA084A084AE84A0A4A0A92EC52AC22A832EA4A1A4A268442
+36FF:20A820A823FE20A8F8A848004BFE4A22882049FC312411242934492880200020
+3700:21002100213C2124FBA44924493C4BA44B649524593C212431244924493C8124
+3701:1020102013FE1070FCA82524262225FC250449FC290411FC2904440083FE0000
+3702:08087E0808FEFE0808487E2808080F28F0100400FFFE08201C4003800C707008
+3703:2090208820FE2100F9004B3C4D004900493C91005100213C31244924493C8124
+3704:200027FC24042434F5C4544455F45554555495F45444245425F4549458069002
+3705:1040102013FE1040FC8825F02420244425FE480229FC112429FC452485FC0104
+3706:2010209224522254FA1048FE48104E388A544A92331012102A10450088FE0000
+3707:2020202021FC2020FBFE482049FC48208BFE4800304010242AA24A8A84880078
+3708:00207E7C14C40838FEC62A2048FCA844128C0200FFFE08201C4003800C707008
+3709:2124224822482124FBF84A084BF848004BF89248524823F832024A0249FE8000
+370A:200023FC22042204FBFC4A484A484AFC8A484A4833FE12A42AA8449084C80886
+370B:2104208420882000FBFE4800488849048A0249FC315411542954495487FE0000
+370C:10001078FE4810487C480086FE0082FC7C441044FC2824286810302848448582
+370D:1020101011FE1110FD7C251425FE2514257C4910297C114429444644827C0444
+370E:101E13E011221094FC40248825F0242024C449FE282210202BFE445084880306
+370F:100010FC10841084FCFC240025FE250225FE490229FE110229FE444884840102
+3710:1020112411241124FDFC240027FE240025FC4904290411FC2888445083FE0000
+3711:40482FFE004087FC544417FCE44427FC244420000200FFFE08201C4003C03C38
+3712:1040119C11041104FDDC2504250425FC248848882BFE10882888448885080208
+3713:1088108813FE1088FC2024502488250426FA4800280011FC2904450485FC0104
+3714:1080104013FC1108FC9027FE240025F82508490829F81090289045128212040E
+3715:2010201022FE2110F97C4854487C4B54897C491031FE111029104A90847E0000
+3716:2090209027FE2090FBFC4A944BFC4A944BFC900051F8210831F8490849F88108
+3717:2040208821FC2108FA524BFE485049884E2690C0531020643388483048C08700
+3718:1020103C102011FEFD22253825E4251C2500497C2944117C2944457C854402FE
+3719:2040202023FE2250FA504BFE4A524A528BFE4A00329212D42A98449284D2088E
+371A:2040202027FE2402F90049FE4A104E204A7C92445244227C32444A444A7C8244
+371B:21082108210827C8F11E57D2556457C0554897C8510827C82114511451248142
+371C:21082108210827D0F11E579451245FD4521493D452542248224854D454248842
+371D:2020205020882124FAFA481048204BFE485091FC5154218C310449FC490481FC
+371E:08047F7808407F40497E7F4849487F4808487F480A88FFFE08201C4003C03C38
+371F:2008238820882110F7DE529452A4539452949394529422C82388569450A480C2
+3720:1020122213FE1090FC8825FE2710251025FE4910291011FE2910451085FE0100
+3721:2124212422242424F954494A4A924E104A109250525C225032504AB04A9E8300
+3722:102011FC112413FEFD2425FC242025FC252449FC284013FE288845D08470038C
+3723:2110211421D22250FA7E4D5048904AA8492891445244248230084AA44A528452
+3724:200023FE205023FEFA524BFE480049FC490491FC510421FC30204BFE48208020
+3725:200023FE22522252FBFE480049FC490449FC910451FC210431FC488849048202
+3726:200023FC200423FCF8044BFC48004BBC492497BC500823FE3108488848A88010
+3727:200027FE24002628F54857EE5492548456A096A857E824882494551459249242
+3728:200023FE220223FEFA104A544A384A548A824A50327C12902A1045FE84100810
+3729:2040208023FE2222FAAA4A224BFE4A724AAA9202502023FE3020485048888306
+372A:08047F782240FF40087E7F482A484948A8881400FFFE08201C4003800C707008
+372B:228822A826A82BF0F01E522455D45C14541495D4555425482568555456148422
+372C:210021F8220827FEFA884B244BFE4A008AFC4A0032FC12002AFC448484FC0884
+372D:1020112410A813FEFE0224F82488248824F8480029FC112429FC452485FC0104
+372E:200823E8228823EEFA284BF44A824BE2880049FC315411542954495487FE0000
+372F:200027DE24922492F5D2555E555055D05492949257CE20002000552454928892
+3730:21242174225822DAFBFE49544ADA4BFE88A2482033FE107028A8492482220020
+3731:2042239C221023DEFA944A944C204BFC4A0493FC520423FC32044BFC49088204
+3732:20402FFE240027FCF00057FC540457FC50809C9C57D43D54355C5C965556AE22
+3733:2080204027FC2000FBF84AA84BF848404A449118524420A831904A884CA680C0
+3734:210827FE210823FCFA944BFC48004FFE4C0291F8510821F8310849F8490881F8
+3735:204027FE200023FCFA404BF84A404BF84A4093FC5004255430A84B104D488186
+3736:21F0221027FC2204FBFC4A244BB84A2249FE921057FC224433FC48D0494A863E
+3737:F7FC124817FCFC4686ECF55416EC155456EC24440200FFFE08201C4003C03C38
+3738:0820FFFE28207DFC44887C5041FE7C2045FC7C200200FFFE08201C4003C03C38
+3739:23DE225223DE2252FBDE4A524BDE489049FE911053FE251031FE491049FE8100
+373A:252827BE294827BEFB184DAA49464BFC4A0493FC520423FC32044BFC49088204
+373B:244424E42A0A2EEEF4045AEA5E0E50E05AAA9AEA504020242522550A590880F8
+373C:21FC212421FC2124FBFE4AAA4BFE4AAA4BFE900053FE228A30F84888488883FE
+373D:0888111022201110088800001FE0004000800100FFFE01000100010005000200
+373E:0020FC200450085010881104160218883088D088108810881088110851082208
+373F:0000FDF8040808501020101015FE18223024D020102010201020102050A02040
+3740:00003E7C22042A08260822102210FF7E421052104A1042107F90021014500820
+3741:10001FF820085FC890481FC810481FE800103FE000800100FFFE010005000200
+3742:0104FD0E0530092017E01120153E196431A4D724112411241124112455442284
+3743:0080FC8004F80908121011FC152419243124D1FC10501050109010925112220E
+3744:20201020FE2001FC7C2044A87CA800A87CA804A808F81E22F0221022501E2000
+3745:1000FE7810487C480048FE8682007CFC00447C4408281E28F010102850442182
+3746:0020FDFE042009FC100011FC150419FC3088D3FE100011FC1104110451FC2104
+3747:20201010FEFE00007C7C44447C7C00007C7C080810101EFEF010101050502020
+3748:210447C88812F3BC20084B92F83E0380AAAAABAA00007C7C0808FEFE10103030
+3749:0200010001007FFE400280040000000000000000000000007FFC000000000000
+374A:0200010001007FFE4002800400003FF01010082004400280010006C01830E00E
+374B:0200010001007FFE400280041FE0004000800100010001000100010005000200
+374C:0200010001007FFE4202820407E004200840104000800180024004201810600C
+374D:020001007FFE500290041FF8100020003FF800080008FFC80008000800500020
+374E:020001007FFE40028204010001007FF8003000C003000C003000480087FE0000
+374F:020001007FFE400281040280044008203458C446044004400840084010402040
+3750:0200010001007FFE40828484044008401020221042088406084010203FF01010
+3751:020001007FFE4002820401007FFC0400040007F0041008100810101020A04040
+3752:0200010001007FFE4002810401007FFC010001001FF01010101010101FF01010
+3753:020001007FFE4002810402800C603018CFE600001FF01010101010101FF01010
+3754:020001007FFE4002820401007FFC08201010244844440280010006C01830E00E
+3755:020001007FFE4202810409002828282447E400003FF00820044003801C70E00E
+3756:020001007FFE420287E41840648003200C4071F806081A10012000C007007800
+3757:020001007FFE420281041FF010101FF010101FF0110410881050122014181806
+3758:020001007FFE420281043FF800001FF000001FF000001FF0101010101FF01010
+3759:020001007FFE400280043FF801001FF001007FFC0000FFFE0000082010102008
+375A:020001007FFE4002801C7BE00840104022787A400A402BFC1000280047FE8000
+375B:020001007FFE400288040FFC1040304053F89248124812A81318120813F81208
+375C:020001007FFE444284443FF804400440FFFE00001FF010101FF010101FF01010
+375D:020001007FFE40028824082008207EFC08201C301A702A6848A4892208200820
+375E:020001007FFE400280047FFC044004403C78200820083C7804400440FFFE0000
+375F:020001007FFE4002BFFC00001FF010101FF010101FF010101FF004421842E03E
+3760:020001007FFE40029FF410101FF010101FF012100100FFFE0000082010102008
+3761:020001007FFE400280047F0022FC3E4422443E44222822282F10F22842440282
+3762:020001007FFE400280F43F0001001FF011101FF001007FFC412441F45E144008
+3763:020001007FFE400288047F7C08243E2408447F5408880200FFFE04401830E00E
+3764:01007FFE4822BFFC08203FF80820FFFE01003FF821083FF82108FFFE20082018
+3765:020001007FFE400284242420252424A83C2007FE0470FCA82524262224204420
+3766:01007FFE49029FFC31005FF091001FF011001FF810003FE0084008F810086030
+3767:01007FFE4402BFFC082007C0783811101110292845443FF801000100FFFE0000
+3768:020001007FFE41029FF401007FFC00001FF010101FF0048808503820CB180C06
+3769:01007FFE400281043FF820802FF820883FFE20882FF824C422A8449858868180
+376A:020001007FFE4002904410407C4011F8FE48444828C87C4810AAFEAA11061202
+376B:01007FFE4002810479F04A9050606198560649F04A406BF8544043F8404047FC
+376C:20201020FE20822011FC7C2010207C2011FEFE2010507C50448844887D044602
+376D:01007FFE4002900413F812085BF8560853F8914013F8144011F0104017FC1000
+376E:01007FFE400288042A003E7C49447F4400443E2800287F1008102A2849441882
+376F:020001007FFE400280741F800200FFFE082037D8C4463FF8200827C8244827D8
+3770:01007FFE42029FF41490125011301FF00100FFFE92122FE8440407E008203060
+3771:01007FFE408A8BFC488849FC495479FC08000BFEFA4248784888495088600980
+3772:01007FFE411297FC511053F852A877FC141411F0F01057FC544453F892481258
+3773:0200020002000200FFFC0200020012901248122422242212421282000A000400
+3774:00087C08000801FE0008FE082488244824482408240824282412440243FE8000
+3775:00003FF820083FF820083FF800007FFC00200020FFFE08200420042000A00040
+3776:3FF8244824483FF80000044004420842303EC0000020FFFE0820042004A00040
+3777:3FF000101FF000103FF000407DF011501C94E14C0020FFFE0820042004A00040
+3778:010011102108450408003FF8200820083FF8200820083FF8044008421042603E
+3779:01001110216843841C00E8001FE020204040BFF8210821083FF80492188AE07E
+377A:22101410FF90141014147F521552FF9215107F1414043608551094A014401580
+377B:22102210FF9022103E5408527F5249907F1008147F0408087F0808100F20F0C0
+377C:200021FC20202020FC2028202BFE282028202820282028A02842480247FE8000
+377D:2020202020202024FDA828B028B0292829242A2428A028402802480247FE8000
+377E:20402040204023FCFC80288028F8292029202A20282029FC2802480247FE8000
+377F:2020202021FC2124FD28292029F82908295029202A502A882D0A480247FE8000
+3780:20402040204023FEFC802890291229542A902C28282428442982480247FE8000
+3781:200021F8210821F8FD0829F82800291829E02904290428FC2802480247FE8000
+3782:201C21E020442124FC88282028202BFE284828C8283028682986480247FE8000
+3783:2840244842449244104029FE445082507C5044504450445244527C92448E0100
+3784:2040204023FC20A0FD102A482DF4295029F0295029F42844283E480247FE8000
+3785:200021FC212421FCFD2429FC282029FE287028A829242A202822480247FE8000
+3786:2020202021FC2050FC882BFE280829E82928292829E829282808481A480287FE
+3787:200021FC212421FCFD2429FC28002BFE29222914294829842902480247FE8000
+3788:2040202021FC2104FD0429FC290029FC2B542B542DFC29542954490E480287FE
+3789:2088205023FE2020FDFC28402BFE288029FC2A202C202BFE2802480247FE8000
+378A:1040544054407C4092FC9250FE5000507C500050FE50105254929292510E2200
+378B:00003FFC200420043FFC200020002FF82408241022202140208041404630980E
+378C:00003FFC200420043FFC200027F82010202020402FFE20402040404041408080
+378D:00003FFC200420043FFC210021002FE0212025202220232024A24422481E9000
+378E:00003FFC200420043FFC20002FF82888288828882FF8280028024802480287FE
+378F:00003FFC200420043FFC200020782780208020402FF8201020604180460099FE
+3790:00003FFC200420043FFC2000208020402FFC200024082210212040005FFE8000
+3791:00003FFC200420043FFC20002888249022A0208022A02492288A4082407E8000
+3792:00003FFC20043FFC210022002FF8280828082FF8280828084FF8480888080FF8
+3793:00003FFC20043FFC200028602F88280827F820002FF828084FF848088FF80808
+3794:00003FFC20043FFC210023F02C202240218022402CF821084690406081800E00
+3795:00003FFC20043FFC22202410280837F6241027F0241027F04410441084500420
+3796:00003FFC200420043FFC20803FFC20802FF8288828A829D022A04490588C8080
+3797:00003FFC200420043FFC209020882FFC2080288825D022A02490488C42808100
+3798:3FFC20043FFC20002FFC2100230824882D50226025E029504250444899440080
+3799:3FFC20043FFC200020F03F0021E02F0021F43F0420FC20884ED042A084981986
+379A:3FFC20043FFC2000203827C020402FFE20402140265C2444475C444487FC0404
+379B:00003FFC20043FFC2288249028E43284247C2C0034FC248444FC448484FC0484
+379C:3FFC20043FFC220C2470281030FE223824542C92342025FE444444C8843805C6
+379D:00243FFE222023A422243FA82B10529A462680421FF810081FF8100020004000
+379E:00003FFC20043FFC24482848305422A425002C103490249C44904550863E0400
+379F:3FFC20043FFC22202FF821402FF82A282DD828082FF820805FFC41408630180C
+37A0:3FFC20043FFC20802FF821402A2827F02C1837F4241027F04080488892840100
+37A1:3FFC20043FFC2000273822102F7C20002738221023BC2EC8413043108D480186
+37A2:010001002108210821082108210821083FF801000100010001000100FFFE0000
+37A3:01002108210821083FF80100054008203018DFF6021002100210041008A01040
+37A4:010001002108210821083FF800000100010001000280044008203018C0060000
+37A5:01002108210821083FF80000060001000100028002800440082010102008C006
+37A6:100010F01090109054905490549054905490549054905C9264920112010E0200
+37A7:01002108210821083FF8000000003FF004100420087C08041004200440288010
+37A8:100011FC1004100854105420542057FE5420542054205C206420002000A00040
+37A9:0100210821083FF8000000000FE0082008200A200920092210221022201E4000
+37AA:00003FF0001000101FF000100010FFFE0100010021082108210821083FF80008
+37AB:01002108210821083FF80200010001007FF8003000C003000C003000480087FE
+37AC:010001002108210821083FF8000000003FF801000100010001000100FFFE0000
+37AD:010001007FFC01000280044008203018C106010021082108210821083FF80008
+37AE:01002108210821083FF8080008001FF810082010402000400C80030000800040
+37AF:00003FF0001000103FF02000200420041FFC010001002108210821083FF80008
+37B0:10801080108011FC552056205420542057FE542054205C206420002000200020
+37B1:0100210821083FF8000000003FF82008200820083FF82008200820083FF82008
+37B2:102010201020102055FC552455245524552455FC55245C206420002000200020
+37B3:100810881048104854085488544854485408540E55F85C086408000800080008
+37B4:1004101E11F0111055105510551055FE5510551055105D08650A014A01860102
+37B5:01002108210821083FF8020001007FFC0820082004400280010006C01830E00E
+37B6:10401020102013FE54885488548854885488545054505C206450008801040602
+37B7:01002108210821083FF80100010000007FFC010001003FF801000100FFFE0000
+37B8:01002108210821083FF8000000007FFC01000300056009103108C10401000100
+37B9:1000100013FE1008540855E8552855285528552855E85D286408000800280010
+37BA:01002108210821083FF8080008001FF0210001007FFC0280044008203018C006
+37BB:0100210821083FF800001FF010101FF00000FFFE10001FF00010001000A00040
+37BC:00003FF0002000C07D040588095011202118C50602000100210821083FF80008
+37BD:2028202420242020ABFEAA20AA24AA24AA24AA28AA28BA90CB12022A00460082
+37BE:100011FC11041104550455FC550055405544554855705D4065420242023E0400
+37BF:0100210821083FF8000001003FF801000100FFFE10100820044003801C70E00E
+37C0:00701F8001000100FFFE054009203118C006010001002108210821083FF80008
+37C1:100011FE11001100557C551055105510551055FE55105D106510021002100410
+37C2:100010FC108410A454945484548457FE5504554455245D0465FE000400280010
+37C3:100011FC1004100455F45404540455F45514551455F45D146404000400280010
+37C4:108410441048100055FE5420542054FC5420542055FE5C206420002000200020
+37C5:10001088105011245554558C550455FC5400549054905C90651001120212040E
+37C6:2090209421142118AB10AD32A952A90EA920A820ABFEB820C820002000200020
+37C7:10201020112411245524552456AA54725420542055FC5C206420002003FE0000
+37C8:102810241024102055FE5420552054B254B4546854A85D246222002000A00040
+37C9:2040202023FE2202AC24A920A9FCA920AA20A820ABFEB820C820002000200020
+37CA:1008103C11C01004554454A8540055F85410542057FE5C206420002000A00040
+37CB:110410841088101055FC55045504550455FC545054505C9064920112020E0400
+37CC:10901088108013FE54A054A854B054A454A854B055245D2A6532022202DE0400
+37CD:1040102011FC1104550455FC5504550455FC552055225D146508014401820100
+37CE:2008203C23C02044AA24A928A900A840ABFEA888A908BB90C860005001880604
+37CF:10201020105010885544562254F854085410542055FC5D046504010401FC0104
+37D0:1048104811FE104854485420541055FE5480548054805C806480008000FC0000
+37D1:2020202023FE2020A820ABFEAA02AC04A9F8A810A820BBFEC820002000A00040
+37D2:0100210821083FF800003FF80408FFFE04083FF808001FF8280848088FF80808
+37D3:21842068203020C8AB04A840ABFEA8A0A920ABFCAD24B924C934012800200020
+37D4:0100210821083FF8010002800C603118CFE6004000801FF0101010101FF01010
+37D5:0100210821083FF800000020792048A04A204920483C4BE07820482000200020
+37D6:0100210821083FF800003FF801001FF001007FFC00000820FFFE082010202020
+37D7:01000100410451445554638C41047DF455545554555465944D3441047FFC0004
+37D8:100011FC112411245574552455FC55045574555455545D746504020402140408
+37D9:10881088108813FE5488548857FE540055FC550455045DFC6504010401FC0104
+37DA:10201020FDFC1020302039F85488905010201050118C0100210821083FF80008
+37DB:0100210821083FF8000010881088FBFE108810881CF8F0881088108850F82088
+37DC:0100210821083FF800407C4004FC04847D28402040A87CA404A4052428A01040
+37DD:1040102011FC100055085490540057FE5400540055FC5D046504010401FC0104
+37DE:10481044105E11E054285412546A55965448545E55E05C2464280012006A0186
+37DF:0100210821083FF8000008207FFC0820FFFE10102FC848448FC20810081007F0
+37E0:200023FE2202228AAA52ABFEAA22AA22AAAAAAAAAAAABAFACA020202020A0204
+37E1:0100210821083FF80000111009207FFC0400FFFE10102FE8C82608A0084807F8
+37E2:0100210821083FF802003FF804800840FFFE00101F90109010901F9000500020
+37E3:2104211421142114ABD2A922A92AAB48AB88AD50AD10B914C922017E01220100
+37E4:0100210821083FF800003FF000101FF00010FFFE111009A005401930E50E0200
+37E5:0100210821083FF8040008201FF00210FFFE08A03318CC4603801C3001C03E00
+37E6:010041047FFC00007FFC41043FF801001FF011101FF011101FF00100FFFE0100
+37E7:010041047FFC00003EF822883EF800003FF80000FFFE08000FF0001000A00040
+37E8:102011241124112455FC540057FE5420544055FC55545D54655401540154010C
+37E9:00207F20413E7F4448A47F24482845105328614600000100210821083FF80008
+37EA:100011FC1124112455FC5524552455FC540057FE55205D226514014801840102
+37EB:1040108011FC110455FC550455FC5420543257B454A85D286524022404A20040
+37EC:010041047FFC0500397821083D7821083FF801003FF00820044003801C70E00E
+37ED:100011FC110411FC551055FE5510554A5586540055FC5D0465FC010401FC0104
+37EE:1040102013FE12025488550456225428542457FE54205C506450008801040202
+37EF:010041047FFC020001007FFE48029FF4282007C01830E00E1FF010101FF01010
+37F0:200023FE22022000A9FCA904A9FCA904A9FCA840A820BBFEC800008801040202
+37F1:2104208420882000ABFEA820A820A9FCA820A820ABFEB800CAA4025204520000
+37F2:100011FE11101120557C5544557C5544557C551055105D546552029202500420
+37F3:200023FE20502050ABFEAA52AA52ABFEA820A820ABFEB870C8A8012406220020
+37F4:2020204023FC2224AA24ABFCAA24AA44ABFCA840A8A8B8B4C93C01220222041E
+37F5:0100210821083FF800003FF824483FF800007FFC010011F811001100FFFE0000
+37F6:010041047FFC00003FFC2080210027F0241027F0241027F0408044908A881104
+37F7:1088108813FE1088542054505488550456FA540054005DFC6504010401FC0104
+37F8:2020204021FC2104A9FCA904A9FCA840ABFEA888A924BA22CDFC002000200020
+37F9:20103F202ACE2AAAAEAAAAAAAAAAAEAAAAAAAAAAABEABEACDA28024802480288
+37FA:010041047FFC01003FF82108FFFE21083FF811101FF00400FFFE082007C07838
+37FB:08047F7808407F40497E7F4849487F4808487F4808880100210821083FF80008
+37FC:0100210821083FF8082008207F3E08443EA40824FF2810281E1022284A448482
+37FD:100013FE105011FC5554555455FC540055FC540057FE5C2064A8012402A20040
+37FE:101011FE1110117C551455FE5514557C5510557C55545D7C6554027C0254044C
+37FF:2088208823FE2088A824ABFEA850A888A904AA8AA888BBFEC888008801080208
+3800:04001FF010101FF010101FF010001FFC10001FFC4924849C0100210821083FF8
+3801:2040208821FC2108AA52ABFEA850A988AE26A8C0AB10B864CB88003000C00700
+3802:21082108210827D0A91EAF94A924AFD4AA14ABD4AA54BA48CA4804D404240842
+3803:2040202023FE2088A850ABFEAA22AAFAAA22AAFAAA8ABA8ACAFA0202020A0204
+3804:0100210821083FF800007EFC22441A3462C404001FF010101FF010101FF01010
+3805:010041047FFC020013FC240043F88A0813F8320853F8910013F8151010E0171C
+3806:200023DE22522252ABDEA800A9FCA924A9FCA924A9FCB820CBFE002000200020
+3807:0100210821083FF820501048FE4801FE7C5044507C501050545052929292310E
+3808:200023DE225223DEAA52ABDEAA02AAFAAA22AA72AA22BA22CAFA0202020A0204
+3809:102011FC1088105055FE540055FC552455FC552455FC5C2065FC002003FE0000
+380A:2040207C204023FEAA42AA78ABC4AA3CAA00AA50AA54BB54C4D8045009FE0000
+380B:21083FF800001FF010107FFC44447C7C00003FF80000FFFE10001FF800080070
+380C:0100210821083FF800202220FFBE22423E9422103E102210FFA8242842448282
+380D:010041047FFC08801FFC30805FF890801FF810801FFC11007FFC05401930E10E
+380E:20A0209021FE2320A9FCA920A9FCA920A9FEA900A820BBFEC87000A803260020
+380F:108813FE1088100055FC54A854A857FE54A854A855FC5C2063FE002000200020
+3810:010041047FFC000000701F800200FFFE082037D8C4463FF8200827C8244827D8
+3811:0100210821083FF800003FF824483FF802807EFC02803EF802807EFC02800280
+3812:20022FE222822FEAAAAAAAAAAFEAA80AABCAA80AAFEAB90AC5420522092A0304
+3813:208823FE208823FEAA02A9FCA800ABFEA840A8A2AB54B8B8CB54009203500020
+3814:0100210821083FF800403E2022FC22883E5021FE20203E2052FC52209E201220
+3815:010041047FFC004078804BF8524863F852484BF8484868B450BC41224222441E
+3816:41047FFC08207FFC01003FF80100FFFE02403C500848FFFE08507E240854198C
+3817:2040208023FE2222AAAAAA22ABFEAA72AAAAAA02A820BBFEC850008801040602
+3818:0100210821083FF80A0033B822083A38238820883AB82288FFFE082010102008
+3819:202023FE200021FCA904A9FCA800ABFEAA02A9FCA840BBA4C8D8033400D20330
+381A:2144214425542364A94EABE4A804AA2CA944ABE4A884BBE4C88400E407140008
+381B:108813FE10A8109055FE572055FC552055FC552055FE5D0063FC00880070038E
+381C:220022BE23022254A9C8A83EAA0AABCAAD28A928AFEEB928CAA80258044E0080
+381D:108811DC108813DE54885554562255FC550455FC55045DFC650401FC00880104
+381E:22204AA08ABE1FC420A46F24A0282FA82210272822442F820100210821083FF8
+381F:10501190109E13EA548A55D2568A54A45450548857265CA8647000A801240060
+3820:2040207C204023FCAA44ABF0AA44AAFCAAA8AAF8AAA8BAF8CA0005FC05540BFE
+3821:202023FE200023FCAA20ABF8AA20ABF8AA20ABFEA802BAAAC854018806A400C2
+3822:21083FF802001FF011101FF012101FF004A808BA3082C27E01007FFC0C48763E
+3823:200023FE222222CCAA44ABEEAA44AAEEAB54AA44AA10BA90CA9E049004900BFE
+3824:202023FE200021DCA954A9DCA888ABFEA888ABFEA888BBFEC894018802A400C2
+3825:27FC244427FC2444AFFCA800AFBEAAAAAFBEAAAAAFBEB840C84007FC00400FFE
+3826:20A821FC22AA23FEAAAAABFEAAAAABFEA800ABFEA800B9FCC90401FC008803FE
+3827:202023FE224823FEAA48AAECAB5AAA48AA50ABDEAA50BBDCCA5005DE04500850
+3828:2154212423DE2154ABAEAD54AFFEAC92AFFEAA44ABDEBA44CBD4020C0284034C
+3829:0080008021402220241020003FFC0000092009200920112011222122411E8000
+382A:00007FFC0100010001000100010001F8010001000100010001000100FFFE0000
+382B:00007DF01110119011521D12E20E440001003FF80100FFFE028004401830600C
+382C:00007CF81088108810881CF8E00041003FF801000100FFFE028004401830E00E
+382D:00007C7C1010101010101010FEFE000000007C7C1010101010101E10F0FE4000
+382E:220014007F7C141055103610FF9000103E10221022103E10221022103EFE2200
+382F:00001FF01010101010101FF01000100010001FF81008100810081FF810080000
+3830:10007E7C124412441244227C4A4484001FF0001000101FF01000100410040FFC
+3831:3FF000103FF020041FFC08207FFC08200FE008200FE00820FFFE082010102008
+3832:0840084008407F4249444948495049604940494049404B4208420842083E0800
+3833:060001000280044008203118C10601001FF01110111011101150112001000100
+3834:1000100011FC7C24542454A454A454A45524542454245C441044108411141208
+3835:02000100FFFE1000100010001FF8010001003FF8210821082128211001000100
+3836:1020102010407CF854885488548854885488548854885C8A108A110A11061200
+3837:100013FC10847C8854885490549C54845544554455285D281210122814441182
+3838:1020102010207C2055FC54205420542057FE542054505C501088108811041202
+3839:1020102010507C5054885504560254885488548854885C881088110811081208
+383A:1020102010207CA854A454A2552255205624542454285C081010102010C01300
+383B:020002083FD002200240FFFE010002800C801FF82888488888A8089000800080
+383C:1004100E10F07C805480548054FE54885488548854885C881088110811081208
+383D:10401040107C7C8455885650542054505488570654605C10100810C010201010
+383E:10001EF8228862A894920882307EC10001003FF8210821082128211001000100
+383F:0880088828902EA028C028842E84F17C01003FF8210821082128211001000100
+3840:0100210811080910092001007FFC410441044384454449244104410441144008
+3841:1020102013FE7C505488550456FA540057FE544054805DFC1004100410281010
+3842:00047FA410243F2451240A040C043114C1083FF8210821082128211001000100
+3843:1010111011107D285544550055FE540054A854A854A85CA810A810AA112A1206
+3844:1040104010807CFE5502560255F25512551255F255125D1211F2100210141008
+3845:10201020107C7C8455485430542054485590543E54425DA41018101010601180
+3846:1080104013FC7D005500550055F854005550555055505D50125012521452180E
+3847:100013FE11207D28552855E855285528552855E855285D2A113A13EA10261020
+3848:1080108010F87D08561055FC55245524552455FC54505C50109010921112120E
+3849:201023882088F8FEA890AB90AA24AA24AA38AB88A890B89020A420BE22822100
+384A:10401040107C7C8455085600542055CE5502550255CE5D021102110211FE1102
+384B:1020102013FE7C5054885524562255FC552455FC55245DFC10221022101E1000
+384C:100011FE11027D7A5502557A540054FC548454FC54845CFC1084108410941088
+384D:02001FF010101FF010101FF00200FFFE08203118DFF611101150112001000100
+384E:1040104810847DFE542057FE548855245642558854105C621184101810601380
+384F:204020A02110FA08ADF6A800ABC4AA54AA54ABD4AA54BA5423D42244225422C8
+3850:210820882090FBFEA800ABC4AA54AA54ABD4AA54AA54BBD422542244225422C8
+3851:0610381008527E5408901C282A284844088201003FF821082108212821100100
+3852:1008101C11F07D10551055FE5510557C5544557C55445D7C11441244127C1444
+3853:200023FE2222F820ABFEA820A9FCA924A9FCA924A9FCB82023FE202020202020
+3854:00407F40127E0C88FF4819482A504820A850118C01003FF82108212821100100
+3855:1088108813FE7C8854A8542055FC55245524552457FE5C201050108811041202
+3856:1008103C11E07C2057FE542055FC552455FC552455FC5C2011FC102013FE1000
+3857:2004201E23F0FA1EAA10AAFEAA92AA98AAF2AA8EAA80BAB822A824AA254A2A86
+3858:1088105010007DFE545055FC545457FE545455FC54505CD81154125210501050
+3859:1020104011FC7D04555455245554550455FC540055125DD4111811521192110E
+385A:1088108813FE7C8855FC548857FE542055FC552455FC5D2413FE110411141108
+385B:1088108813FE7CA8541057FE5480548054FC540054A85CA810A810AA112A1206
+385C:2100211023DCFA54AD54AA88A908AAF4AC02A800ABFCB8402150224825442080
+385D:2020247C2284F948A830A8CEAE10AA7CAA10AA7CAA10BAFE2210221025FE2800
+385E:202021FC2124FBFEA924A9FCA820A9FCA924A9FCA840BBFE208821D02070238C
+385F:2090209027FEF890ABFCAA94ABFCAA94ABFCA800A9F8B90821F8210821F82108
+3860:202027A420A8FA92A914AA08ADF4A802ABF8AA08AA08BBF8220821102FFE2000
+3861:200023FE2200FA04ABF4AA04AAEEAAA4AAA4AAECAA04BAA42244227425942008
+3862:21FC210421FCF904A9FCA800ABFEAA52ABFEA800ABFEB88020FC208421142208
+3863:102008207F3E0020223E1402FFBE88A0093E7F20493E49204D3E4A200822081E
+3864:205022522154F850ABFEA888A850ABFEA820A9FCA820BBFE20A8212426222020
+3865:203E27C02244F928ABF8A840AFFCA800ABF8A808ABF8B80823F82544252A28FA
+3866:1020101011FE7D0254FC54A8553054FC558454FC54845CFC108410FC10481084
+3867:2040202023FEFA8AA904A812ABD4A848AA8AA974AA02B9FC210421FC208823FE
+3868:2148214C22AAF808AFFEA948AB68A94AAB6AA94CAB6CB948216A239A20262042
+3869:210447C88812F3BC20084B92F83E0380AAAAABAA01003FF82108212821100100
+386A:203E27C42128FBFEAA02ABFEAAA0AAEEAAAAAAEEABA8BA4622F82548243029CE
+386B:100011FC210421FC450445FCF88009FE1222112229524502FDFA440200140008
+386C:1110212045447978111025247D7C05240110FFFE20803E88225222224A5A8586
+386D:441049245E7844104A285F7C40007FFE441049245E7844104A285F7C40007FFE
+386E:49204920AABEEBA04940AABCEB802900FFB8240825082508228A528A45868882
+386F:010000803FFE2000201020F827802080208020FE3F802080408240828082007E
+3870:010000803FFE2000200027F82080208020803FFE208020804080408082800100
+3871:010000803FFE21002100210023F0221024202820204020C0412042108C083006
+3872:010000803FFE20002090208820FE2F802080208820902060204241A24E1A8006
+3873:010000803FFE2000203C27C024402440244027FE242024202412450A46068402
+3874:010000803FFE2080204020402FFC20002408220822102110412040009FFE0000
+3875:010000803FFE20802140222024902848304627F0201020204340408080400020
+3876:010000803FFE2000200027F8240824082408240827F824084120421084080804
+3877:010000803FFE2000208020802FFC21C022A022A02490288857F4408080800080
+3878:010000803FFE2200220023FE2500290031F82100210021FC4100410081000100
+3879:010000803FFE2000200023F82208220823F82208220823F8420842088FFE0000
+387A:010000803FFE2000200027F82408240827F82408240827F8400040009FFE0000
+387B:010000803FFE20002180263C24A424A424A424A425A426B42528412042208420
+387C:010000803FFE208020802FF828882FF828882FF820842048203041D45E0C8004
+387D:010000803FFE2000204027F820483FFE204827F8204027FC40405FFE80400040
+387E:010000803FFE200027F8240827F8240827F82484248824502420451846068400
+387F:010000803FFE2208210821102FFE204024442444244427FC2084410046009800
+3880:010000803FFE204020402FFE204027FC2444245424E8215042484C4680400040
+3881:010000803FFE208021F022102D2020D023202C7C218426884050406081800E00
+3882:010000803FFE2040208027F82408240827F82400240027FC4404440487FC0404
+3883:010000803FFE2100208027F8240827F8240827F8248224442428451046088406
+3884:010000803FFE200020002FFC200023F822082208220823F82000420841109FFE
+3885:010000803FFE200027FC204023F820402FFE211021102FFE2110421042108410
+3886:010000803FFE200027FC2444244427FC2444244427FC204027FC404040408FFE
+3887:010000803FFE210020802FFC200027F8200027F8200027F82408440847F88408
+3888:010000803FFE2280224027FE24402C4037FC2440244027FC4440444087FE0400
+3889:010000803FFE2000218C2E70221022103F90261E27702A902A1252124212820E
+388A:010000803FFE20802FF82140222024103FFE201027D0245047D0401080500020
+388B:010000803FFE22202278248825502C243448259E242224642598441044608580
+388C:010000803FFE20002EFC2A082AE82CA82AA82AA82AA82AE84EA8480888280810
+388D:010000803FFE200021102FFE2110204023F8224822482FFE20A0411046089806
+388E:010000803FFE2000203827C020402FFE20402140265C2444275C444447FC8404
+388F:010000803FFE204020A023182DF62000278424A427A424A427A4448444948588
+3890:010000803FFE200023F0221023D0225022502FFC280429E4292449E448148808
+3891:00803FFE2280224027FC24402FF8344027F8244027FC248040805FFE80800080
+3892:00803FFE2040207E20402FFE28422BF8284229FE290429FC490451FC910427FE
+3893:00803FFE204027FC21102FFE200023F8220823F8220823F840404FFE80400040
+3894:010000803FFE220024482848305422A425002C103490249C44904550863E0400
+3895:010000803FFE22282224257E29482E4822FE254829482F7E42484448887E1040
+3896:010000803FFE200020782F80249022A03FFE2490280837F6449047F0849007F0
+3897:00803FFE203827C020802FFC211027F8391621F020002FFE480249F2891209F6
+3898:010000803FFE221021202FFC21202FF821283FFE21282FF820004A4849249124
+3899:00803FFE251025103FD0253C271422142F942A942F9422144FA4422483541C88
+389A:00803FFE208020F820802FFC28842BF028882BF82A482BF84A4857FC9084230C
+389B:00803FFE204020A0211022082DF6200027BC24A424A427BC411042A884440882
+389C:00803FFE22083FFE220823F8200027FC244427FC244427FC40404524850A08FA
+389D:010000803FFE24002706293832082F882ABE2F882A9C2FAA4008554895482008
+389E:00807FFE40007E7C52244A1452244FF848884FF848884FF842205FFC44108808
+389F:00000020F82008201020113C2120792009200920492031FC10002C0043FE8000
+38A0:000003FCFA040A0412F4129422947A940AF40A944A04321412082C0043FE8000
+38A1:0440247C24A83D5004287DFE24884448841808200820FFFE0820102020204020
+38A2:082049202A3E7F4841A85D2855105D28424608200820FFFE0820102020204020
+38A3:2420FF20247E7EC482287A104A287AC6040008200820FFFE0820102020204020
+38A4:084008487F4408440840FFFE104010401F401140112021222112410A4A068402
+38A5:00207F28412441245D20413E41E05D205520552055205D2441144114450C4204
+38A6:0020FF2802247A244A207A2E00F0FF2002207A204A204A107A12020A0A060402
+38A7:00007FF0001000103FF0200020003FF800080008FFE800080008000800500020
+38A8:00007DFC0420042004207C20402043FE40207C20042004200420042028201020
+38A9:00407C40048004FC05047E044004410440847C44044404040404040428281010
+38AA:0000F9FC0800080008007BFE40804080410079FC080408040804080450282010
+38AB:0020F8200820082009247924412441244124792409240924092409FC50042000
+38AC:0040F840084008400BFE7840408040904090792009200A480A440C8451FE2082
+38AD:00207C200420043E04207C20402041FC40847C88044804500420045029881606
+38AE:0080F88008FE09000A207920412C417443A47924093409280922090250FE2000
+38AF:0000FBFC0A040A040A047BFC4220422043FE7A200A200A100A120A8A53062202
+38B0:0010F810081009FE09127914411041FC414479440928092809100A2852442482
+38B1:0020F840088809040BFE780240204020412879240A240A220C22082050A02040
+38B2:00007CF804087CF840807CF804080408285010200000FFFE0000082010102008
+38B3:00807C8004FE050006007C1C41E0412041227D24052805100510054829841102
+38B4:00003FF8000800083FF8200020003FFC00043FE42AA424A42B2424A43FE80010
+38B5:0020F8200850088809047A0241FC4000400079FC090409040904090451FC2104
+38B6:0000FBFE08200820084079FC41044104410479FC090409040904090451FC2104
+38B7:00107C920492049204FE7C204020407E40827D42042404280410042028401180
+38B8:0020F7201120113E1144F744844484A48428F7281110111011281148AA844502
+38B9:00407C2005FC040004887C5043FE402040207C2005FC04200420042028201020
+38BA:0040F82009FC08000888785043FE404040407BFE088809880850083050C82304
+38BB:001CF9E0082008200BFE78A84124424240407BFE0888090808D0083050482184
+38BC:00207D2404A404A804207DFC4124412441747DAC052405240524050429141108
+38BD:0000F7EE124212421242F3CE8248824883C8F24E124212E217421042A0544048
+38BE:0000FBFE0850085009FC79544154415441FC7820082009FC0820082053FE2000
+38BF:0080F8BC0884090809FE7B204520417C4190791009FE09100928092851442182
+38C0:0020F8200BFE082009FC790441FC410441FC790409FC09040BFE088851042202
+38C1:0088F8880BFE088808887BFE408041FC43247DFC092409FC092409245124210C
+38C2:0000FBFE080009FC0904790441FC400043FE7A8A0A520BFE0A220A22522A2204
+38C3:0200F11E17C212021482F7DE805087908490F79E1482178214821482A4944588
+38C4:0200F97E08400C7C0A4478FC4140467E422078200BFE087008A8092452222020
+38C5:0000FBDE08880AA80BFE798842DA44A641F87908090809F80908090851F82108
+38C6:07FCF24817FC1C4616ECF55486EC855486ECF454140817FC104013F8A0404FFE
+38C7:08000FE010201FC000407FFC09003200CC803080CFF80888088808A808900080
+38C8:20203C3C444478780808FEFE5050A8A84848BEBE2A2A2A2A2A2A2E2E08080808
+38C9:000400047F08081008200844080408080810082208420F04F008401000600180
+38CA:040008001FF02820444003801C70E10E0600384001880610382000C007007800
+38CB:11001104110411087FD01122190215041108FFD0112211021104210821104160
+38CC:08000804080408080F900822080208047F08411041224102410441087F104160
+38CD:08000804100422084110FFA2008200047F08411041224102410441087F104160
+38CE:010002001FF010101FF010101FF001001150218846441990062018C007003800
+38CF:08000804FF84140822104122BE8222043E0822103E220802FF84080808100860
+38D0:080010047F0441087F1041227F0208040808E8902D222A024904888828101060
+38D1:02023FC222042F8822903FC222822F8422082F902A822F824A844F888A9009A0
+38D2:410022040004FF888890AAA29C828884FF8800107F2241027F0441087F104160
+38D3:08020DC228443D484490A9423242C404248815107FC20E0215042488C4500420
+38D4:0800080013FE2020482008201020302050209020102010201020102010A01040
+38D5:084008401040204048400FFE10403040504090A010A010901110110812041402
+38D6:08400840104020404BFE0840104030A050A090A0111011101288124814441802
+38D7:08400820102021FC49040904110431FC51049100110011001100120012001400
+38D8:08800880110021FC4A040C0411E431245124912411E411241004100410281010
+38D9:104010402040404097FC144424446444A44427FC244424442444244427FC2404
+38DA:08000BFC120422044AF40A04120432F452949294129412F41204120412141208
+38DB:0840084010A021104A080C0613F83000500093F8120812081208120813F81208
+38DC:100217E22242424A924A124A224A67EAA24A224A224A224A22422442244A2844
+38DD:08280824102420204BFE082011243124512493A8112811101212122A14461082
+38DE:08900890110821484A440C92110833FC509490901090109011121112120E1400
+38DF:08200820102023FE4820082011FC3000500091FC110411041104110411FC1104
+38E0:10401040207C40849588165024206450A488270624602410240820C020202010
+38E1:111011102110421092FE169226926A92A29222FE229222102210221022102210
+38E2:09080888109023FC4824082413FC3220522093FE106210A2112A122414201020
+38E3:10401040204047FE9040145022486248A55428A220A021102110220824042802
+38E4:08500848105E23E44828083210CA370650509048105E13E41028103210CA1706
+38E5:111011102110427C921016102AFE6208A20822FE220822482228220822282210
+38E6:08380BC0104020404FFC095012483486508097FC1110121011A0106010901308
+38E7:11001208244847889108124827C86008A7C8244827C8244827CA244A244A24C6
+38E8:12101210221042109F7E151025106510A57C29442544224422442544257C2844
+38E9:111011102110411097BC111021106338A3B82554255429922110211021102110
+38EA:083C0FC01244212848000BFC1080308057FE910011F812881250142018D81306
+38EB:0808083C11E020204BFE082011FC312451FC912411FC102011FC102013FE1000
+38EC:080009F81108210849F8080017FE310851F8910811F81108113E17C810081008
+38ED:08000888125222224A520A8A120233FE50889144127A10881150102010D81706
+38EE:0820082013FE202048200BFE128A325252FA9222122212FA12221222122A1204
+38EF:08000BFE120222024BFE0A101292325452FE928212FE128212FE1482148A1884
+38F0:081C09E01020212448A80BFE107030A8512492221040102412A2128A14881078
+38F1:08200BFE102021FC48200BFE100031FC510491FC110411FC110411FC10881104
+38F2:121012102A904A909FBE102420546F94A01420142F94288828882F9428942022
+38F3:1100110023FC46A89AA812A827FC62A8A2A822A82FFE200022A8225424542000
+38F4:1110111027FC411091101FFE204067FCA44427FC244427FC2000211022082404
+38F5:10101410227C401090FE1044262862FEA210227C221022FE2210221025FE2800
+38F6:10401FFE200047FC940415F4251467FCA00023F8220823F8220823F820002FFE
+38F7:1080104027FC444492A8129424746000A3F822A82FFE200027FC204021402080
+38F8:150815482DA8453E9FA8124824486ABEA30825882988237E25402920251E2200
+38F9:1040102027FE44A894FE1550277C6550A57C2550257E254028A42A8A328A2478
+38FA:0400040004000400251024882444444404000400040004000400040004000400
+38FB:1010082004400280010002800C603018C0060100088848844812481287F00000
+38FC:1000100011FC1044184455445144514491441244104410841084110412281410
+38FD:02000200FFFE042008201C4003800C7070080100088848844812481287F00000
+38FE:100013FC11041144192454A85088508890501050102010201050108811041602
+38FF:10401040108018FC550452045004910410841044104410041004100410281010
+3900:030000802140222024102808300620003FFC0100088848844812481287F00000
+3901:00003FF801000100FFFE0280044008203018C106088848844812481287F00000
+3902:00003FE0082008400C780A081210112020C043308C0E02005104511290120FF0
+3903:10401020102013FE18805480508050FC90841084108410841104110412281410
+3904:10201020102013FE1820542051FC512491241124112411341128102010201020
+3905:7FF80200420042007FFC0480088010842084C07C010008844892481287F00000
+3906:1008101C11E01100190055FC5144514491441128112811101110122812441482
+3907:1010107813C0104018405440504057FE904010A010A010901110110812041402
+3908:1000104010201010189054805080528492821282128214881088108810781000
+3909:100013FC1010191055105110521093FE10301050109011101210141010501020
+390A:1004130810D01020185054885104500090041104108810501020105011881606
+390B:101010901090188855085104520495FA10881088108810881108110812281410
+390C:10881088108810881BFE548850885088908810F8108810881088108810F81088
+390D:00007DFE1040108011FC10041E04E00440280110088848844812481287F00000
+390E:100010007E7C1244124412442244227C4A448400010008844892481287F00000
+390F:1080108010F811081B1054A0504050A093181C0610C010201010118010601010
+3910:0100010001FE010001003FF8200820083FF82008010008844892481287F00000
+3911:10201020102010201BFE54405040508090FC1184128410841084108410FC1084
+3912:10201020102013FE18505450508851249222102011FC10201020102010201020
+3913:10401040104010401BFC544050E050E091501150124815F41842104010401040
+3914:1088108810881908557E53085508914811281128110811081108110811281110
+3915:10201020112411241924552451FC502090201124112411241124112411FC1004
+3916:10401020102013FE1A0254045000500093FE1020102010201020102010A01040
+3917:010001007FFC01003FF80200FFFE082012102208C2261290124822480A000400
+3918:1080108010F811081A10542053FC50049004100411FC10041004100413FC1004
+3919:3FF8200820083FC8204820483FC8200820083FF8010008844892481287F00000
+391A:10801080113C1A0054805080517E930815081108110811081108110811281110
+391B:10801088109C1970551053105510911011FE11101110111011101110117C1100
+391C:202820242024202033FEAA20A224A224A32422A8222822102212242A24462882
+391D:10401020102013FE18405488510453FE909210901090109011121112120E1400
+391E:1040102013FE1A025400503853C090401040107C17C0104010421042103E1000
+391F:044004403FF8244824483FF8244824483FF80100088848844812481287F00000
+3920:7F84082410243F2451240A24040408043014C008010008844892481287F00000
+3921:200420042FC422143214ABD4A254A454A6542554289420942104220424142808
+3922:1040104017FE1080190055FC5304550499FC1104110411FC1104110411141108
+3923:101008207FFC08200820FFFE0820102020204120088848844812481287F00000
+3924:1020102013FE12221A2257FE5222522293FE1020112010A0104010A011181606
+3925:10401020102017FE18405484510853F090221044118816101020105011881604
+3926:204020402FFE3040A840A7FCA444A44427FC2040224021402080214022302C0E
+3927:1008101C11E01100190055FE51005100917C1144114411441144127C12441400
+3928:10881088108810881BFE548850885088908817FE100010881084110412021402
+3929:08000FF010202C4003801C70E00E1FF0101010101FF002005104511290120FF0
+392A:0000FFFE100010F83E884288A4A818941084207CC10008844892481287F00000
+392B:040004007FFC08001FF028104FF088100FF0081008500A205104511290120FF0
+392C:1020102011FC18205420502053FE90001020102011FC10201020102013FE1000
+392D:1010107813C01040184057FE50A0511092081516111011101110121012101410
+392E:2200140019FC24204C2014F82420442005FC2800110008844892481287F00000
+392F:100013FE120212521A8A5706520252FA928A128A128A12FA128A1202120A1204
+3930:0900090011FE1280348050FC9080108010FC1080108002005104511290120FF0
+3931:100013FC1000100019F855085108510891F81000110810881090100017FE1000
+3932:010001007FFC11101110292845440280044008203018C106088828A4282447E0
+3933:100013FE10101820546850A453229020100011FC110411041104110411FC1104
+3934:20002FFE248024903490AF90A490A490A49027902490249224D22F92208E2080
+3935:00407E40047E08880E881948E850082008502888130602005104511290120FF0
+3936:10901088108013FE18A054A850B050A490A810B01124112A1132122212DE1400
+3937:1040104010A011101A88544651F050109020104013F812081208120813F81208
+3938:1040104013FC18405440504057FE909012941292149219121110121014501820
+3939:105010481048184057FE504052449164116810D0115012481444104211401080
+393A:208020402FFE22003200AA00A3F8A000A2482248224822482248244A244A2806
+393B:0600387C224432642A5422442A54324804401840610008844892481287F00000
+393C:1110111011101390193C5514511457D4911411141214129417D4122410541088
+393D:1020102013FE182055FC504053FE9048108810FE110811481228140810281010
+393E:100013FE12021252188855045020502093FE1020107010A81124162210201020
+393F:1040108017FE11101A48544653F85248924813F81248124813F810421042103E
+3940:1040104013FC1040184055F8510851F8910811F8110811F81108110817FE1000
+3941:010001007FFC01001FF01290129052905FF040007FFC02005104511290120FF0
+3942:100013F8120813F81A0857F8500053FC901017FE101012101110101010501020
+3943:100013DE125212521BDE5652525253DE920212021202120212021202120A1204
+3944:1020102011FC1820542053FE50889144124210F8118812501020105011881606
+3945:101C13E010841A445548511057FE9402100013F81108111010A0104011B0160E
+3946:1040104013F81848544857FE5048904813F8144412E811501248144611401080
+3947:10501048105E13E41828543250CA570690501048105E13E41028103210CA1706
+3948:10201020FE3E9220922092FC9A84948410FC1100088848844812481287F00000
+3949:1040102011FC100019085490500053FE9000100011FC11041104110411FC1104
+394A:200027BC24A424A434A4AFBCA4A4A4A4A4A427BC24A424A424A424A42AA4314C
+394B:0840082017FE104030A451A89290148810C41082010008844892481287F00000
+394C:1100110011FC1A045484549452A4908417FC108411C412A41494108410A81010
+394D:1108110817FE1108190855F85108510891F81108110817FE1000109011081204
+394E:0C80708011FCFD24322438445444508491041228111008844892481287F00000
+394F:10901090109013FC1A945694529453FC92941294129417FE1000109011081204
+3950:010002800C603018C7C600003EF8228822883EA8009002005104511290120FF0
+3951:00007FFC02001FF010101FF010101FF010107FFE410288844892481287F00000
+3952:1008103C13C010441A2455285100502093FE107010A810A81124122214201020
+3953:1040104013FC18A05510520857FE900813C812481248124813C8100810281010
+3954:1040102013FE1880550453FE500291FC110411FC110411FC1104110411141108
+3955:01000910092012C0043019086914091012A004401830600C01004884481287F2
+3956:00907890490849086A445C524888FDF84808484048244AA24A8A4C8888781800
+3957:11FC1104110411FC1904550451FC5040902013FE108810881050102010D81706
+3958:22002200227E27123212AA52A252AFD2A2522292241225122FA224A2204A2084
+3959:1020102011FC11241924552451FC50209040102010A41282128A128A14781000
+395A:20402140265C3444AC44A75CA444A44427FC244420A020A02110220824042802
+395B:100013FC10081810542053AE52A292AA12A412A413AA103210A0104017FE1000
+395C:100013FE12221BFE562253FE500091FC110411FC110411FC1104110411141108
+395D:2000277E21243124A93CA724A424A43C242427242126217C210421042A042404
+395E:11041088100013FE184054C25122525490981138125410941112161010501020
+395F:110011F8120813F0181057FE50805144966810B01128166810A4112216A01040
+3960:100013FE10221920553C512052FE940011FC110411FC110411FC110411141108
+3961:100013FC120413FC1A00569852E05284927C122013FE127014A815241A221020
+3962:11081088109017FE1890549053FC52949294130C120413FC1204120413FC1204
+3963:020002007FFC0440092037D8C1061FF001000FE001003FF801004884481287F2
+3964:00207E20145008887F442A2249F8880828101020010008844892481287F00000
+3965:11FC1124112411FC1924552451FC5020902013FE1222122A12FA120A12021206
+3966:3FFC20802FF82080249024902AA83144222024103FFE02005104511290120FF0
+3967:100013FE1020104019FC5504510451FC910411FC1104110411FC100010881104
+3968:102010F8FC20242025FC4800282010F82820442081FC02005104511290120FF0
+3969:1040104413F41848545057FE5040908011F81308150811F81108110811F81108
+396A:1020112410A810201BFE54A851245202904017FE108811081190106011981604
+396B:1040102017FE100019F8550851F8500093FC1204120413FC1204120413FC1204
+396C:2080204027FC3208A910A7FEA402A884204027FC210021F82108220822282410
+396D:1020102013FE102019FC544053FE508891241222112410A81124122210A01040
+396E:1080108011FC1244195455F450845128929011FC1244155411F4108411281210
+396F:007C7F80110808903FF80100FFFE00003FF800081FF800083FF8020851249FE4
+3970:10A0132E122212221BAE5622522253FE902013FE110410881050102010D81306
+3971:100013FE122812281AEE5628522852EE9228122812EE12281228122813FE1000
+3972:01007FFC01001FF010101FF010101FF01010FFFE1010200801004884481287F2
+3973:200027FE2420244035FCAD04A5FCA504A5FC2524242024A829242A2230A02040
+3974:2004203E27E0343EAC20A5FEA522A53825E2251E250029782A48324A248A2906
+3975:200027FE240225FA3442ACC2A52AA46AA4B2252A246A24AA2522244227FE2402
+3976:01007FFE44429FF404403FF80440FFFE082012102108C9062828282447E40000
+3977:010000803FFE20402FFE22482248255428A223182C0620804A444A4A920A01F8
+3978:0000FDFC85248524FDFC9124912491FCFD049000902090149552B542CE488438
+3979:1010545038881104FEFA10483848548891281210010008844892481287F00000
+397A:1020102011FC1820542053FE5080910413FE100213FC12941294129417FE1000
+397B:002800243FFE20A02F2422242FA822182B1252AA4A46848201004884481287F2
+397C:200027FC20403278AA40AFFEA100A1FC220023FC200425542554280420282010
+397D:102013FE102019FC542053FE500091FC110411FC110411FC110411FC10881104
+397E:100013FE124812481BFE5648522053FE924012FC13441244127C120013FE1000
+397F:08207F20087E7E4408A4FF2810101E2822444682810008844892481287F00000
+3980:2020247C22843148A830A0CEA610A27C2210227C221022FE2210221025FE2800
+3981:004027FC104013F8024873F8124813F8104017FC284047FE01004884481287F2
+3982:111009203FFC20044FE808200FE001003FF82108211802005104511290120FF0
+3983:1040102013FC18005508509053FE922012A012FC1320122012FC1420142019FE
+3984:010000803FFE222022202F7C222027702AA83224208020484A444A1491F00000
+3985:22A822A827FC32A8AAAAA4E6A800A7FC2444204023F822482248224822582040
+3986:1040107C10401BFE5642527853C4923C120812F0132412A815FE142018A01040
+3987:1040102013FE12501A5057FE5252525293FE1200129212D41298149214D2188E
+3988:22082110200027FC3040ABF8A040A7FCA00023F822A822A822A822A82FFE2000
+3989:102013FE102019FC540053FE520291FC100011FC110411FC1104108813FE1000
+398A:108813FE1088100019FC54A850A853FE90A810A811FC102013FE102010201020
+398B:2040204027FC3110AA48A446A3F8A05027FC208023F82D0821F8210821F82108
+398C:01F03E0003F03E0003FA7E0201FE0C20703C1DE2F0221C1E01004884481287F2
+398D:100013DE125212521BDE5488505053FE90201124112411FC1024104010801100
+398E:102011FC102413FE182455FC502053FE900011FC112411FC112411FC100013FE
+398F:200027BC24A427BC3420ACA4A39CA000A11027FC211021102FFE211022082404
+3990:101417FE10101BD0541053D0501093D0125013D0125013C8124A13CA11861242
+3991:2008278820883110AFDEA494A4A4A79424942794249424C827882C9420A420C2
+3992:100013FE125212521BFE542053FE500091FC100011FC100011FC110411FC1104
+3993:1110111411D212501A7E5550509052A89128114412441482100812A412521452
+3994:3E1022143E1222103EFE00103E2822283E2822443E44228227004884481287F2
+3995:20202720253C254435A8AE10A528A546A53825102550267E2490247C241024FE
+3996:2000279E2492279E3492AF9EA442A422A40A25462542255226322402240A2404
+3997:2110211027BC3110ABB8A554A912A00023F8200027FC20402248244429422080
+3998:10207E20423E7E4442A47E241028FF2820103E284244868201004884481287F2
+3999:11FC112411FC192455FC502053FE922A12FA120A1246102010A4128A128A1478
+399A:401020082108F8BE008050142208FA3E22082A487A3C2AA82AA8528841888008
+399B:0A0033B822083BB820883AB82288FFFE082012102108C9062828282447E40000
+399C:210827FE2148222037FEAA20A3FCA220A3FC222023FE220027F8211020E02F1E
+399D:3C20D0404DFC3104C9FC150425FCCC5014502492D50E0A0001004884481287F2
+399E:01007FFC01003FF80000FFFE00023FF00100FFFE00107DFC44907D30489487F2
+399F:31FCCB242D2431FCC924152425FCCC2015FC2420D4200BFE01004884481287F2
+39A0:228422842AA426C4329EAFE4A004A454A28C2FE4210427C4210421C42E142008
+39A1:244424E428A83AAAAEEEA4A4AAAAAEEE224220402FFE20E0215022482C462040
+39A2:1108110811EE12941842540053DE525293D2125213D2121A1294135012101010
+39A3:2100479C828017C0203E6788A4882788210827C829082FE821104884481287F2
+39A4:1040FE40107C7C840028FE2082207C5000887D2644107C5445422F4AF2384000
+39A5:20402FFE284227FC3040ABF8A040A7FCA04027FC24A427FC20402524252A28FA
+39A6:2000279E2492379EAC92A79EA482A532251225B2251225F224A2252A261A2404
+39A7:2108252827BE294837BEAB18A5AAA946A3F82208220823F82208220823F82208
+39A8:27BC24A427BC24A437BCAC44A5F4A444A5F4255425F4255425F424E42554244C
+39A9:201C2EE02A542A283A7CAC10AAFEAA00AAFC2A042A7C2C0428FC2814294A2A38
+39AA:224822E8230836EAAA1CA2E8A208A2E825B428E2200023F8211020E023182C06
+39AB:252827BE294837BEAB18A5AAA946A3FC220423FC220423FC220423FC21082204
+39AC:200027FC24A424A437FCAA10A2A8A4BEAF68223C24A82FBC20282AA82ABE2020
+39AD:27FC20402FFE28423358A840A358A000AEEE2AAA2EEE20002FFE224825542FFE
+39AE:0240022003F87E00020003F83E00020002FC7F100120014001840E447034000C
+39AF:004800440040FFFE004008400844104422447F28012800120F32F04A40860302
+39B0:225022482248554088C00040FFFE00400040002400280012003200CA03060002
+39B1:004000487F4400440040FFFE0040084408447F440828082A0F12F02A40460082
+39B2:084008487F4408440840FFFE104010441F4411441128112A2112252A42468082
+39B3:084008487F4408440840FFFE0040084408447F440828082A0F12F02A40460082
+39B4:004800440040FFFE20403E404244B4440C443228C1287E124232424A7E864302
+39B5:0828482448247F20482E88F00820FFA418241C282A2829104912882A08460882
+39B6:004800440040FFFE00407F40104422447F4409283E2808120F32F04A00860302
+39B7:0028FC2404246820102EFEF092209224FE2492289228FE109212922A92468682
+39B8:082808240FA408207F2E41F07F2041247F2449280828FF900812082A08460882
+39B9:00207C2844247C2444207C3E01E0FE2440247E28AA282A104A32924A2A864502
+39BA:00287FA440245F20402E7FF055205224592450A842287F9052124A2A82460682
+39BB:0028EF242124A920652EA9F0212010247E24422842287E104212422A7E464282
+39BC:082808247F2410203E2E1070FFA02224412490A8262822103612222A3E462282
+39BD:20142012FC1023FE40107BD04A50CBD278124BD248147AAC4D4A4AAA48165822
+39BE:020001003FFC200420043FFC2080248024F027903C90249244B2440283FE0000
+39BF:020001003FFC200420043FFC208020802FF821C022A022A04490488890840080
+39C0:020001003FFC200420043FFC20002FF022102220233822884450442088D81306
+39C1:010000803FFC20043FFC208020802FFC208020803FFE2100421044088FFC0404
+39C2:020001003FFC200420043FFC200020002FFC288428842FFC488448848FFC0804
+39C3:1004100410841084FE841084108412841C8C30B4D0C410841004100450042004
+39C4:1000100011041104FD0411041104150419043104D1041104110411FC50042000
+39C5:1000100011FC1044FE441044104412441C443044D04410841084110452282410
+39C6:1020102010201020FDFC11241124152419243124D12411341128102050202020
+39C7:1000100011FC1104FD0411041104150419743104D10411041104110451142108
+39C8:100011FC10041004FC0410FC10801480190031FCD00410041004100450282010
+39C9:1100110011FC1200FC0011F8100014001BF83008D0081008100A100A50062002
+39CA:10201020102013FEFC20102011FC152419243124D12411341128102050202020
+39CB:1040104810441044FC4013FE10401440184030A0D0A010901110110852042402
+39CC:1008103C11E01020FC20103C11E014201820303ED3E01020102210225022201E
+39CD:10401020102013FEFC801080108014FC18843084D08410841104110452282410
+39CE:100011FE10081088FC881088110815FE18183028D04810881108120850282010
+39CF:200023FC22042204FA94225422242A243254E2542294230422042204A2144208
+39D0:2000200027BC20A4F8A424A422A42AA83128E1282290229024A82828A0444082
+39D1:1020112010A010A0FC2013FE1022142218423052D04A108A1082110252142408
+39D2:20402020202023FEFA022404200028903090E0902088210821082104A2044402
+39D3:1008103C13D01290FE901290129016901A903288D28812C812A414D454922800
+39D4:2028202420242020FBFE222022242A243224E228222822102212242AA4464882
+39D5:20002080231E2252FA52225222522A523252E2D2235A225420902090A1104210
+39D6:1040102011FC1104FD0411FC11001500197C3108D110112011421282527E2400
+39D7:1090109010901290FE9212D4129816901A903290D290129212D21712520E2000
+39D8:088008882E9028E428842E7CF00000E01F0001003FF801007FFC010005000200
+39D9:1000104010201028FC08108814901A9432A2D2A214C210881188128854782000
+39DA:1000100013FC1100FD0011F01110151019903250D2501210121212925312220E
+39DB:04402440247C248024902508040800E01F0001003FF801007FFC010005000200
+39DC:100013FE12101210FE1012FE129216921A923292D29A12941210121053FE2000
+39DD:100010007E7C124422442A7C440080E01F0001003FF801007FFC010005000200
+39DE:1008103C11E01020FC2011FE10401440187C30A4D0A811281110122854442082
+39DF:2200217E21402440FA402240204029403140E2402640224022402240A27E4000
+39E0:1020104010881104FBFE1002142018203128D124122412221422102050A02040
+39E1:10201010101013FEFC201042108415F818103022D0C413081010102850C42302
+39E2:200027FC24042444FC44244427FC2C443444E4A42494251426042404A7FC4404
+39E3:10201120112011FCFD201220102013FE187030A8D0A811241124122250202020
+39E4:10401020102013FEFC40108815041BFE3092D0901090109011121112520E2400
+39E5:10201120112011FCFD201220102013FE18903090D0901090111211125212240E
+39E6:20802080210021FCFA04240423E42A243224E3E42224222423E42004A0284010
+39E7:1040102013FC1040FC90110813FC100419503150D1501150125012525452280E
+39E8:1008101C11E01100FD0011FE11001500197C3144D14411441144127C52442400
+39E9:200027FC24042404F5F42444244425F43554E5542554255425742446A4464842
+39EA:1040104010FC1104FA0811FE1500197C3144D1441154114811421242523E2400
+39EB:100013FE10201020FC4011FC1154155419543154D15411541154114451142108
+39EC:00007DF0111011901D52F20E440000E01F0001003FF801007FFC010005000200
+39ED:7CFC1088109010881E84F094408800E01F0001003FF801007FFC010005000200
+39EE:10001040119C1104FD041104110415DC19043104D1041104110411FC51042000
+39EF:10401040104411F4FC48105013FE104018803184D29814E010821082507E2000
+39F0:1008103C13C01200FE201220122013FE18203020D12811241222142250A02040
+39F1:0808081C147022104110BEFC001000103E1022FE2210221022103E1022500020
+39F2:2080204027FC2404F848204020402BFC30E0E1502150224824442842A0404040
+39F3:1088FD0412FA1C48F0881128321000E01F0001003FF801007FFC010005000200
+39F4:101010D813941094FC9013FE10901494189430D8D398109010AA10CA52862102
+39F5:100013FE10101020FC6810A413221020180031FCD10411041104110451FC2104
+39F6:1040108011F81108FDF8110811FA150A190C33F8D01810281048118856282010
+39F7:100011FC10201020FC2013FE10501488190432FAD48810881088108850F82088
+39F8:1040102013FE1000FDF81108110815F8180033FCD00810301020102050A02040
+39F9:100011FC110411FCFD0411FC100015FE180833FED00811081088100850282010
+39FA:1020102213B410A8FCA8112412A2104019FC3104D10411FC1104110451FC2104
+39FB:100013FE10401080FD441224106812B0193032A8D06810A41122122050A02040
+39FC:1020102013FE1020FC2011FC102014201BFE3040D0A411A81290148850C62080
+39FD:100011FC11041124FD2411FC1124152419743154D15411741104110451FC2104
+39FE:1080108010FC1154FA5410A415241A443094D108104010A412AA128A54782000
+39FF:1088108810881088FD5412221442102018203120D13C112012A01260543E2800
+3A00:103C11E0102013FEFC2011FC14241BFE3024D1FC107010A81124162250202020
+3A01:1040104013FC1040FC4011F8110815F8190831F8D10811F81108110857FE2000
+3A02:1020102013FE1020FDFC112411FC152419FC3020D07010A81124162250202020
+3A03:1040102013FE1000FDFC110411FC140019FC3008D01013FE1020102050A02040
+3A04:200027FC24442444FDF4244424442FFC3404E5F42514251425F42404A4144808
+3A05:1088108813FE1088FCA8102011FC152419243154D14C11841104110451142108
+3A06:2110211021102110F7BC21102110233833B8E5542554299221102110A1104110
+3A07:102049FC212409F871481230144C00E01F0001003FF801007FFC010005000200
+3A08:1040102017FE1108F890106011981E063108D1F8110811F81108110852082408
+3A09:100013FC120413FCFE2013FE1210128A1B063000D3FC120413FC120453FC2204
+3A0A:1040104013FE1080FDFC122015FE100019FC3104D1FC110411FC110451142108
+3A0B:1040104413F41048F85017FE1040188031F8D308150811F81108110851F82108
+3A0C:08007F7808483E4800487F86410082FC3C4408447E2808287F10082828441182
+3A0D:08083EFE08087F4808283E0808287F1000201FC001003FF801007FFC01000300
+3A0E:100013FE10201040FDFC1154115415541954312CD02013FE1050108851042202
+3A0F:1020112411241124FDFC108014801BFE3090D1101152125412A8142858442082
+3A10:2100217C21442244F244267C2A10221032FEE2382254225422942312A2104210
+3A11:1000108812521222FE52128A120217FE18883144D27A10881150102050D82706
+3A12:1020102013FE1050FC88132611FC1420182033FED000102011FC1020502023FE
+3A13:1040102013FE1202FC8811041222112019FC3220D02017FE1020102050202020
+3A14:20142012201027FEF410241025D024123412E5D42554254825DA242AA8465082
+3A15:100013F811081110F91C12E412A41A5434A8D10013FC12941294129457FE2000
+3A16:2008200827C82210FA1E24A427D429143114E7D42114210821C82E14A4144022
+3A17:10401040107E1040FBFC100415FC180433FCD0401240127C1240154054FE2800
+3A18:1020102010A410A2FD2A10101460198036FCD08410FC108410FC108450FC2084
+3A19:101E13E011221094FC40108811F0142018C431FED022102013FE105050882306
+3A1A:1090109013FE1090FD0011FC120411E4192431E4D12411E41124100450282010
+3A1B:100013DE125213DEFA5213DE12021A223222D2221252124A128A1202520A2204
+3A1C:1040107C104013FEFA42127813C41A3C3240D22013FE12881250142054582986
+3A1D:100013FE12021202FBFE121012921A5432FED28212FE128212FE1482548A2884
+3A1E:1020102013FE1020FDFC102013FE1440188831F0D02413FE1022112452A22040
+3A1F:1020112411241124FDFC100013FE140019FC3104D10411FC1088105053FE2000
+3A20:100013FE12021000FDFC110411FC150419FC3040D02013FE1000108851042202
+3A21:200027FE240225FAFC4224C2252A2C6A34B2E52A246A24AA25222442A7FE4402
+3A22:21102212245427D8F810201227D22C4E3440E7D22454245827D02452A552448E
+3A23:2120211022082486F91023F82008280037BCE08424A4229424A42084A2944108
+3A24:200027FE24502488FDFE269024FC2C9034FCE490249024FE24802400A7FE4000
+3A25:2008210821082208F2BE24AA2F2A212A322AE4AA2FB620A220222AA2AAAA4824
+3A26:10A0109011FE1320FDFC112011FC152019FE3100D3F811081090106051982606
+3A27:10401048108411FEFC2013FE108815041BFE3524D12411FC1124112451FC2104
+3A28:104013BE12121292FE5212AA132410401BFE3222D22213FE1222122253FE2202
+3A29:1040102013FE1202FAEC122412441A4432EED22412A412A4124E1460549E2900
+3A2A:100011FC110411FCFD0411FC1020152418A83020D3FE1090109011125212240E
+3A2B:20902290229C22A0FAD02288228828803000E3F822A822A822A822A8AFFE4000
+3A2C:2040204023F82040F7FE200023F822083208E3F820A4212823102D48A1864100
+3A2D:1040102013FC1204FBFC120012F81A8832F8D20013FC132415FC1502590220FE
+3A2E:2020224024EC24A4F4A424E424A424A436E4E40C2110211021102112A212440E
+3A2F:2200211E27D22012F7D4245427D8201437D2E092211221DA27142110A5104210
+3A30:1040102013FE1088FD241242109015F818083044D0A81190128814A450C22080
+3A31:204020FC21082650F92020C023202FFE3000E3FC200023FC200023FCA20443FC
+3A32:2110211027FC2110F840202027FC2C043444E04027FC20E021502248AC464040
+3A33:1040102013FE1202FC2011FC105014881BFE3008D1E8112811E8100850282010
+3A34:2110211021102FDEF12027C0245C27C43448E7C821102FD021222122A11E4100
+3A35:1108109017FE1000FBC4125413D41A5433D4D24412CC100013FC108451142608
+3A36:1040108011FC1104FDFC110411FC150019FE3100D1FE100212AA12AA5202200C
+3A37:1088108813FE1088FCF8102011FC152419FC3020D3FE102011FC102053FE2000
+3A38:1040102013FE1242FC28129412AA14CA18F83300D02011241124112451FC2004
+3A39:108813DE108811DCFC8813DE108814001BFC3004D00411FC1004100453FC2004
+3A3A:1088108813FE1088FC8810F814201BFE3222D33212AA137612221222522A2224
+3A3B:08047F7808403E402A7E3E482A48FF4808A81FC001003FF801007FFC01000300
+3A3C:00407CF8554854307DCE54F854887CF800201FC001003FF801007FFC01000300
+3A3D:200427C420042394FA94239420142FD43554E55427D42554254427C4A4544008
+3A3E:2208211027FC2040FBF8204027FC28403020E1C02044276821502248AD464080
+3A3F:2040207C204027FEF442247825C2243E3500E53825A826AA2AA62940B2FE4400
+3A40:2040207C204027FEF442247825C224BE3480E5FC255426D424B4292EAA24504C
+3A41:1040102013FE1202FCA0109011FE15201B2031FCD12011FC1120112051FE2100
+3A42:220422042784F494290C27C425643554E7C42546257C27C425442544A44448C4
+3A43:2040202027FE2492FBFC209023FC289037FEE1082204246220102180A0604010
+3A44:10201124112411FCFC0011FC112415FC192431FCD040102412A2128A54782000
+3A45:100013FE105013DEFE52125213DE10501BFE3222D22213FE1222122253FE2202
+3A46:221421122FD22010F07E2790249024903790E12825A825682928214AA54A4286
+3A47:102011FC102413FEFC2411FC14201BFE3000D1FC112411FC112411FC500023FE
+3A48:1040102013FE128AFD0411FC14441BFE3044D1FC108011FC1284148450FC2084
+3A49:204020A0211826E6F80023F822082BF83000E7BC208424A4229424A4A2944108
+3A4A:101C13E010441124FC8811FC1154155419FC3008D7FE11081088108850282010
+3A4B:204023F8204827FEF04823F820402554375CE44427FC2444275C2554A5544844
+3A4C:109017FC109413FCFA9013FE11121BFA350ED1F8110811F8110811F850902108
+3A4D:1210121013DE1528FCA4102013FE10201BFE3222D22A127410A8112456222020
+3A4E:20082788248C278AF48827BE200827883488E7882494279424942494A49445A2
+3A4F:100011FC112411ACFD74112411FC142019FC3020D3FE100012A4125254522000
+3A50:2210221023DE2528F8C4204023FC284037FCE0102FFE201022102110A0504020
+3A51:200023F8208027FCF11022082CA620A037BCE0A023B820A027BC20A0A0A040A0
+3A52:2110211027BC2110FBB825542912280033F8E00027FC204022482444A9424080
+3A53:2C7844486C4844867D7800487C301048FCA41FC001003FF801007FFC01000300
+3A54:40004FDC48544854EFD44A944AA64FC06A9CCA944FD44814528852486454C822
+3A55:100011FC102013FEFA2211AC142019AC3050D0C8132610F8100810D050202010
+3A56:100013FE100011FCFD2411FC15241BFE3000D1FC112411FC112411FC500023FE
+3A57:244427FC212023FEF6202BFC222023FC3220E3FE220027FC2108211EA2024C1C
+3A58:1104108813FE1020FDFC102013FE145419923090D3FE109010D4138A509621A2
+3A59:2080204027FE2512FBFC211027FC291037FEE110224825F428422040A7FC4000
+3A5A:211027FC211027FCF40423F8200027FC3080E14426A8217026A82126A6A04040
+3A5B:27FC244427FCF44425F4255425F43554E5F4244C27FC241427FC2514A4B447FC
+3A5C:201027D0251027DEF45027E8250427C43000E3F822A822A822A822A8AFFE4000
+3A5D:204027FE200021F8F90821F820002FFE3402E3F82180264421B82668A1A64E60
+3A5E:2110255425B82910F2A82444200027FC3444E04027FC20E021502248AC464040
+3A5F:1040102013FE1252FDFC105011FC14501BFE3088D12412FA1020112452A22040
+3A60:2080204027FC24A0F7FC24A427FC24003524E5A8253025A4251C2800AAA45452
+3A61:200027FC2100F3F82508210821F83000EFBE2208279E24922CB22492A79E4492
+3A62:210827FE21082000FBFC229422942BFC3028E3FE2220232422A82292A42A48C6
+3A63:27BC24A42294F4A42FFE284227FC3040E3F8224823F8224823F82040A7FC4040
+3A64:214827C8210827D0F55E27E4255427D43554E11427D4220823C82254A55448A2
+3A65:2114211227D22110F1102FFE229026D23292E6D2229426D4228A22CAAF164022
+3A66:10A0109011FE1320FDFC112011FC152019FE3100D3FE1252128A137652522276
+3A67:11FC110411FC1104FDFC108811FC14881BFE3088D12412AA107010A851242060
+3A68:108813DE108811DCFC8813DE108817FC180431FCD00413FC104012A4528A247A
+3A69:2400249E25042608F45E245223D2211E3112ED5E25522592295E2920B52C4212
+3A6A:2100213E22082290F4BE2F222122223E34A2EFBE20A220222ABE2A80A8144022
+3A6B:2042239C221023DEFA94229424202BFC3204E3FC220423FC220423FCA1084204
+3A6C:210821CC210A27E8F52E25D8274824CA340AE54C276C2548254A297AA7A64042
+3A6D:22A0244C24A4260CF4A4264C24A42FFE3802E3F02020204027FC2040A1404080
+3A6E:2140226C2244236CFAA423AC22A42FFE3108E2F4244223F8204027FCA04040C0
+3A6F:221023D0241E2FE4F5542FF4254827D431B2E22027C0208827FC2044A3504488
+3A70:211027FE211023F8FA0823F820002FBC34A4E7BC20402FFE21502248AC464040
+3A71:101E13E011221094FBFE125217FE180433C4D27E13C4125413CC128452D42348
+3A72:21102FFE211027BCFCA427BC2140292033FEE22027FC2A2023FC2220A3FE4200
+3A73:2108229423DE26B4FBDE229423DE2A9433DEE21027FC210820902060A1984606
+3A74:27BC24A427BC24A4F7BC24A427BC212033FEE22027FC2A2023FC2220A3FE4200
+3A75:210821EC210A2FEAF9282BC8293E2FE83948EBE82A282B682AA82BF4AAB452A2
+3A76:221023DE25282084F7FE224827FC2C4636ECE55426EC255426EC2444A4544408
+3A77:204027FE249223FCF89023FC20902FFE3108E3FC252221F8212021FEA0024556
+3A78:11FC112411FC1124FBFE12AA17FE1AAA33FED02013FE124210F81150502023FE
+3A79:11FC112411FC1124FBFE12AA17FE1AAA33FED00013FE128A10F81088508823FE
+3A7A:00100410441044FE4410441044FC774444444444442844285510662844440182
+3A7B:201020107E1042FE84107F1040FC5E44524452445A2854285010942898441182
+3A7C:101010103E1042FEA410181010FC2444C8441F442128D2280C1008283044C182
+3A7D:10101010FE1010FE1010FE1092FC9244FE441044382854289210102810441182
+3A7E:02100F10781008FEFF102A102AFCFF442A442A44FF28082808100E2870442182
+3A7F:1020102020203F3E404480443E4402A40428082810102010212821281F440082
+3A80:00407C401040108010FE11081288FC8810881050105010201050108851042202
+3A81:081008101410141E2210521088FC084400447E44022804280410082808440082
+3A82:201020107F10801E00107E1000FC0044FC440444042805280510032801440082
+3A83:00100010FF90021E02107A104AFC4A444A444A447A284A28021002280A440482
+3A84:282028202820FE3E2A442A44FE44A8A4A828FF28291029102D284A4848848902
+3A85:7FFC01003FF82108228824482118010001FC01003FF00820044003801C70E00E
+3A86:021007107810481E481048107EFC484448444844482844284510632849440482
+3A87:0820282028203E3E4844084408447FA414281428141014102528264844848102
+3A88:08100810081E7F10081008FCFF440044084408287F28081008100F28F0444082
+3A89:082008201420223E4144BEC4004400A43E2822282210221022283E4822840102
+3A8A:00107E101210121EFF10121012FC7E44204420447E286228A21022283E442282
+3A8B:00107F1041107F1E41107F1000FC00447F4408440828FFA80810082808440882
+3A8C:0010FC100410681E1010FE1092FC9244FE4492449228FE289210922892448682
+3A8D:082008207F20083E08447F44414482A43C28042808100F107828082828441082
+3A8E:081008100810FF9E08102A102AFC2A445D4488C4082814281210212841448082
+3A8F:101020107F10491E49107F1049FC51447F4424444428FFA80410042804440482
+3A90:081004103F10211E21103F1024FC264425443F44242824284A10492891442082
+3A91:08100810FF90141E2210491088FC7F4449447F4449287F2808100A280C440882
+3A92:101067104110411E7710411041FC7F4414441444142814282510262844448082
+3A93:02100F107810081EFF9008102AFC2A44EBC42A442AA86B28AA10082808440882
+3A94:221022102210221EF790221022FC66447744AAC4AA2832282210222822442282
+3A95:081008100F9E08107F1041FC7F4441447F4449280828FF900810082808440882
+3A96:00107E1002103E1E0210FF9008FC094449442A441C282A28C910092828441082
+3A97:101008107F1E0010221014FCFF44004400443E282228221022103E2822440082
+3A98:082008201420223E4144BEC4084408A47F28492849107F100828144822844102
+3A99:00207F204920493E7F44494449447FA40828FF281C102A104928884808840902
+3A9A:242024207E20243E2444FF4400447EA4422842287E10421042287E4842840102
+3A9B:22102210FF10221E3E1022103EFC22442244FF4440285428621040287E440082
+3A9C:101092109210921EFE100010FEFC10442044FE44AA28AA28AA10AA28AA448682
+3A9D:08100810FF90081E7F1049106BFC5D4449447F4408281C282A10492888440882
+3A9E:0010FF108110BD1E8110BD1081FC00447E4442447E2842287E1042287E444282
+3A9F:10200820FF20003E3E4422443E4400A47F28412841107F10412841487F844102
+3AA0:441028100010FF1E2810FE102AFCFF442A44FE4428286C28AA10292828442882
+3AA1:101008107F10411E08103E1008FC3E4408447F4408283E28221022283E442282
+3AA2:28104B104910491E6B10491049FC7F4408447F44012832280C10122861440082
+3AA3:102008207F20003E3E4422443E4400A47F2841285D1055105D28412845444282
+3AA4:00207F2049207F3E49447F442A442AA4FFA82A282A107F100828FFA808440882
+3AA5:10101E1010107F1E51105C1072FC4E4440445F4451285F2851105F285144BF82
+3AA6:10200820FF20813E00447E4408447EA44A287E284A107E100028244842848102
+3AA7:0810141022105D1E80903E1022FC3E4400447744112855283310552811443382
+3AA8:22101410FF9E08107F1008FCFFC449442A44FFA800287F10411041287F444182
+3AA9:04083F8804887FEE04883F88043C555475D444547FD4444875C8555455548462
+3AAA:00107F101010FF9E2210411094FC1444F7C4144477281428F790142814441482
+3AAB:10101F101010FF9E80907F102AFC5544A2447F44A2A83E2822103E2822443E82
+3AAC:0010EE102210AA1E6610AA1000FC24447F44C8447E2848287E1048287F444082
+3AAD:10101F10101EFF109110FCFC9144BF44AA44BE28AA28BE1080107F285544FF82
+3AAE:00087FC80408FFEE84283588041C359400140014EEF4AAA8AAA8AAB4EEF4AAA2
+3AAF:020001007FFC0820044003801C70E10E01001FF801000100FFFE010001000100
+3AB0:020001007FFC0820044003801C70E10E1110092005407FFC054009203118C106
+3AB1:0080208010F80108FE1009FC092449242924112413FE28502850488881040202
+3AB2:00400440024012400840084001FC7E400040004000407FF80008000800080008
+3AB3:0040044002401240084009FC7E400040004000001FF02008200820081FF00000
+3AB4:00107C10009000500010FE9028502810281E29F028102A104C10481080100010
+3AB5:101010109490585010107C9010501010FE1E11F0101010102010201040108010
+3AB6:0010FE101090105020107C9044504410441E7DF04410441044107C1044100010
+3AB7:0010FE10009000507C104490445044107C1E01F04410241028100E10F0104010
+3AB8:22082248FFA8222822083E48222822283E0E22782208FF080008140822084108
+3AB9:08087F484928FFA849087F4808287F28490E7F781008FF08210872080C08F308
+3ABA:08080848FFA80828EB88AAC8EBA8AAA8EB8EAAF8EB8814081208220841088108
+3ABB:210447C88812F3BC20084B92F83E0380AAAAABAA04401240087EFFC000400040
+3ABC:00000004FF78044004407440547E544854485448744854480448048814880908
+3ABD:0000FFFE0000000C7CF04480448044807CFE4488448844887C88450801080208
+3ABE:100010041E78224062409440087E144822484148BE482248224822883E882308
+3ABF:08004904497849407F401040207E48488848494849487F480848108820884108
+3AC0:00007C0444787C4044407C40007EFE4882488248FE4882488248FE8882880108
+3AC1:11009102AABCBBA09120AAA0BBBE8024FFA492249224A1A48024FFC400440084
+3AC2:100008047F784040524052407F7E524852485E48404855485548558880880108
+3AC3:202010201020FF20202020203E202220225022502250225042884A8885040202
+3AC4:02000100FFFE100010003FF8480884087FE810081F8810882088208842A88110
+3AC5:2020102010500088FD04220220F83C00240027FE248824882488448855088A08
+3AC6:202010200050FE50208821043E22242024A824A4252425224622542088A00040
+3AC7:10100810FF2820443E822210220842204A10840800003FF80008000800080008
+3AC8:10100810FF2820443E822210220842204A1084081FF02008200820081FF00000
+3AC9:2040104010FC0104FE0821FE21003D7C254425442554254825424542553E8A00
+3ACA:2100110011FE0200FC0021FE20083C0825E825282528252825E8440854288810
+3ACB:2080108010FE0120FE2021FC21243D2425FC2524252427FE2504450455148908
+3ACC:2080108010FE0100FE00200021FE3C1024102490249C24902490449055FE8800
+3ACD:2100110011FE0200FC902090215E3D6427542554255425482548455455148922
+3ACE:2100110013FEFC0023FE222239FC282029FC292429FC292429FC48205BFE8020
+3ACF:2100110011FE0200FDFC205021FC3D54255425FC244027FE2488459054708B8C
+3AD0:00001FF0101010101FF0101010101FF00000203823C03C04200420041FFC0000
+3AD1:004000407C40444045FC444444447C4444444484448444847D04450402280410
+3AD2:00001FF0101010101FF0101010101FF008200820FFFE08200820102020204020
+3AD3:004000407C8044FE4500460044FC7C0844104420444044807D02450200FE0000
+3AD4:00001FF0101010101FF0101010101FF00200020003F8020002000200FFFE0000
+3AD5:00001FF0101010101FF0101010101FF000007FFC04400440084010422042C03E
+3AD6:0200020003F802000200FFFE000000001FF0101010101FF0101010101FF01010
+3AD7:00001FF010101FF010101FF000001FE000400180FFFE01000100010005000200
+3AD8:00007FFC010003000570190CE10201001FF0101010101FF0101010101FF01010
+3AD9:002000207C20442045FC442044207C2047FE4420445044507C88448801040202
+3ADA:08001FF82248444808881108222804101FF0101010101FD0101010101FF01010
+3ADB:000001FC7D0445044504450445FC7C5044504450445044927C924512020E0400
+3ADC:000001F8790849084908490879F8490849084908490879F84800000007FE0000
+3ADD:0008003C7BE04A204A204A204A207BFE4A204A104A104A127A0A4A8A03260212
+3ADE:002001247924492449FC482048207BFC49044888488848507820485001880606
+3ADF:000000F87C8844884488448845067E00440044FC448444847C84448400FC0084
+3AE0:002000207D2444A444A8442045FC7C204420442047FE44207C20442000200020
+3AE1:1FF010101FF010101FF008001FF02820444003801C70E30E00C00E0001800040
+3AE2:00200020782049FC4820482048207BFE482048404840488879044BFE01020000
+3AE3:1FF010101FF010101FF001003FF8210821083FF8210821083FFA0102010200FE
+3AE4:00001FF010101FF010101FF0010000801F0001047D88095011202118C5060200
+3AE5:004000407CFC45044688445044207C40448045FC468444847C84448400FC0084
+3AE6:0840084010FC10883550542094D8170614F81488148814F81488108810F81088
+3AE7:00001FF010101FF010101FF0111009200100FFFE0380054009203118C1060100
+3AE8:0040002078204BFE4A024C4478404BFE48884888490878D04820005000880304
+3AE9:010001007FFC01000820FFFE082008201FF0101010101FF0101010101FF01010
+3AEA:01007FFC01003FF80200FFFE08203018D3F61210121013F01210121013F01210
+3AEB:00001FF010101FF010101FF000007FFC044004402448144814500440FFFE0000
+3AEC:00800080790049FC4A044C047BE44A244A244BE44A247A244BE4000400280010
+3AED:00001FF010101FF010101FF001003FF80100FFFE00407FFC0840044001400080
+3AEE:088008882E9028E028842E84F07C00001FF0101010101FF0101010101FF01010
+3AEF:1FF010101FF010101FF000003FF820083FF820083FF800007FFC04401842E03E
+3AF0:008000407BF84A084A084BF84A087A084BF84A404A444A287A104A8803060200
+3AF1:00001FF010101FF010101FF001003FF80100FFFE044024484444884211402080
+3AF2:002000207BFE482048204BFE7A024C0449F8481048207BFE4820002000A00040
+3AF3:00003FFC20002FF820003FFC24482530260E20002FF828084FF848088FF80808
+3AF4:004000447BF4484848484FFE782048404BF849104A207DFE4820002000A00040
+3AF5:0090009078904F9E4890489048907B9C4890489048904F9E7890489000900090
+3AF6:000001FC780448FC480449FC78004BFE4A22482049FC79244924013401280020
+3AF7:08207FFC08200FE008200FE00820FFFE10102008DFF610101FF010101FF01010
+3AF8:00400040F7FE904093F8904897FEF04893F890409240927CF240954004FE0800
+3AF9:1FF010101FF010101FF00000061838E020803E8022FC3E902090209040908110
+3AFA:08200820082014502288492408201450228841061FF010101FF010101FF01010
+3AFB:00400040F0A0911092089DF69000F7FC94A494A497FC94A4F4A494A404140408
+3AFC:008200827A824BEA4C8A488A4FFA788A4BEA4AAA4AAA4AAA7AA24AE2008A0084
+3AFD:000001F87808480849F8480848087BFE48204A22497448A879244A2200A00040
+3AFE:0020012478A448A848204BFE4A027A024AFA4A8A4A8A4A8A7AFA4A02020A0204
+3AFF:00A00090788049FE49104B104DFC7910491049FC49104910791049FE01000100
+3B00:004000207BFE480049FC490479FC480049FC480848107BFE4820002000A00040
+3B01:00001FF010101FF010101FF0204010A0811042E8140623F8E208220823F82208
+3B02:01FC0124792449FC4924492479FC482048204BFE4A227A2A4AFA020A02020206
+3B03:3FF820083FF820083FF8100020087FFC00043FF820083FF8110822900C60F01E
+3B04:1FF010101FF010101FF000003FFC20802FF820803FFC22204A285424A4A20840
+3B05:3FF820083FF820083FF800007FFC44447FFC0000FFFE08000FF810082028C010
+3B06:000003FC7A044BFC4A204BFE4A107A8A4B0648004BFC4A047BFC4A0403FC0204
+3B07:0080008078F849084A104DFC79244924492449244BFE78504850008801040602
+3B08:000001F87908490849F84908790849F848004BFC4A947A944A94029407FE0000
+3B09:000003FE7820484049FC4954795449544954492C48207BFE4850008801040202
+3B0A:1FF010101FF010101FF000FC7F0811103FF80200FFFE080017F02220C1C00E3C
+3B0B:008000BC7884490849FE4B204D20797C4990491049FE49107928492801440182
+3B0C:1FF010101FF010101FF00100FFFE00001FF010101FF010101FF0092011102308
+3B0D:002800247BFE482049FC492479FC492449FC492448087BFE4888004800480018
+3B0E:00001FF010101FF010101FF0082012483CF0082014503EF80000248822444244
+3B0F:000003FE780049FC4904490479FC48004BFE4A8A4A527BFE4A220222022A0204
+3B10:000003FC78904A94499848904FFE780049F84908490849F87908490801F80108
+3B11:0200011EF7D2901297D4945497D8F01497D29092911291DAF714911005100210
+3B12:008800887BFE488848244BFE7850488849044A8A48887BFE4888008801080208
+3B13:000003FE785049FC4954495449FC780049FC48004BFE482078A8492402A20040
+3B14:000007BCF08494A4929494A49050F188962690C093109064F388903000C00700
+3B15:022201127914483E4F8848884908793E4B884D484908493E7908490801080108
+3B16:02100110F79E94A494D497949408F4149462980093F89208F208920803F80208
+3B17:0110011479D24A504A7E4D5048907AA8492849444A444C8278084AA402520452
+3B18:002001FC78244BFE482449FC48207AAA4BAE4A224BFE4A227BAE4AAA02AA0422
+3B19:000E03F078444A2449084BF87A084BFC4A044BFE4A027AAA4AAA050204140808
+3B1A:02080108F7C89210949E9FD49064F7949494979494949788F488949404A405C2
+3B1B:004000A0F11896E6900093F89208F3F8900097BC908494A4F29494A402940108
+3B1C:0000FEFE20204444FEFE12127C7C10101EFEE0001FF010101FF010101FF01010
+3B1D:0104008878004BFE4A224AAA4A727A224BFE480049FC490479FC490401FC0104
+3B1E:002002227BFE480049FC490449FC790449FC488049FE4A227D52490201FA0006
+3B1F:4044402440287EFEAA922AD62ABA4A924AFE9200127C2244227C4244947C0844
+3B20:02100210F3D0945E98A493D49054F05493C89048905497E2F00092A402520452
+3B21:000001FC78204BFE4A2249AC782049AC485048C84B2678F8480800D000200010
+3B22:010400887BFE482049FC48207BFE4854499248904BFE789048D4038A009601A2
+3B23:02840284FAA496C4929E97C49004F454928C97C4910497C4F10491C40E140008
+3B24:000003FE7A024BFE4A024BFE79084A524B9C49084A527BDE480002A402520452
+3B25:3FF820083FF820083FF811101FF041047FFC0200FFFE09203558DFF605400920
+3B26:008803FE78A8489049FE4B2079FC492049FC492049FE79004BFC00880070038E
+3B27:3FF820083FF820083FF811101FF00100FFFE0A203458CF8601201FF009501320
+3B28:01100110F11097BC911091109FFEF2A892A896EC9AAA92AAF2A895A804480898
+3B29:008803DE788849DC48884BDE48887BFC480449FC48044BFC78404AA4028A047A
+3B2A:0FE008200FE008200FE07C7C44447C7C4544FFFE88020FF010101FE00020FFFE
+3B2B:0440FFFE044017D2F01C17D03452D7CE0000444482221FF010101FF010101FF0
+3B2C:07BC04A4F7BC94A497BC94A497BCF12093FE922097FC9A20F3FC922003FE0200
+3B2D:001E03E0792248944BFE4A527BFE48044BC44A7E4BC47A544BCC028402D40348
+3B2E:3FF820083FF820083FF84450FE4844FE7D9010FCFE9092FCFE901090FEFE2880
+3B2F:00803FFE0800EFF8A000AFF8A808EFF8A220BD5CB7F4BC94F5DC1C9617F62CA2
+3B30:0100010001003FF8210821083FF8210821083FF801000280044008203018C006
+3B31:28503E7C4890FEFE14281528264A44861FF0101010101FF0101010101FF01010
+3B32:00887C50100011FC7C50548855047DFC555455547D5493FE600020005FFE8000
+3B33:00803C80248025FC25203E202420242027FE3C20242024202420442054208820
+3B34:00907890489048904BFC78904890489048907BFE480048904888490849049A04
+3B35:00403C20242025FE24003C882504260224883C88245024502420445054888B06
+3B36:00207920492049FC49207A2048204BFE4800780049FC49044904490449FC9904
+3B37:00007BFE4A224A224A227BFE4A224A624A727AAA4B224A224A224A024BFE9A02
+3B38:00883C8825FE248824883C502450249425943E98249024B224D24492548E8880
+3B39:00803C8024F8250826103DFC2424242425FE3C24242425FC2424442054A08840
+3B3A:0020792448A849FC48407BFE49084A244C2279FC492449244934492848209820
+3B3B:008878884BFE48A848107BFE4880488048FC780048A848A848A848AA492A9A06
+3B3C:104010407EFE108021FC3E8424FC6484BCFC2440247C3CC42528241024682D86
+3B3D:00003CF8248824F824003DDC255425DC24003DFE248024FC2404440454288810
+3B3E:7F7848485F4C64805F784A4851307F4C00001FF010101FF010101FF010101070
+3B3F:010878884BC848104BDE7A644BD448144BD47854489448E84B8848944A949922
+3B40:0110791049DE4AA84C4478004BFC48204928792849284AB44C6248204BFE9800
+3B41:1000100013F81088FC90109030A038BC54845484910411041104120412281410
+3B42:1020102010201020FC2010A830A438A455225122922210201020102010A01040
+3B43:1020102010401040FC84108431083BF855105410902010401088110413FE1102
+3B44:100013F010901090FC90109030903BF05490549090901092108A108A10861082
+3B45:1000100013FC1000FC001000300039F85400540090001000100017FE10001000
+3B46:00003FE00420047C08043014C10801007FFC01003FF8054009203118C1060100
+3B47:1040104010801088FD0413FE30023890549054909090109011121112120E1400
+3B48:10401040104013F8FC4810483048384857FE544090A010A01110111012081406
+3B49:08200820FFFE08200920010001007FFC03800540092011102108C10601000100
+3B4A:1010111011101110FD1011FE31003900550055F8910811081108120812081408
+3B4B:10201020102013FEFC201020302039FC54205420902013FE1020102010201020
+3B4C:1020102011201120FDFC112032203820542053FE902010201020102010201020
+3B4D:40802080089C17E0E08020842084207C01000100FFFE054009203118C1060100
+3B4E:100013FC12041204FE94125432243A2456545254929413041204120412141208
+3B4F:10201020102011FEFC20102030FC3820542055FE90221022102A102410201020
+3B50:020002007FFC044008203018C10601007FFC01003FF8054009203118C1060100
+3B51:10201020102011FCFC20102030203BFE547054A890A811241124122210201020
+3B52:100011F811081108FD08110831F83900550055FC910411041104110411FC1104
+3B53:1020102010401088FD0413FE30023888548853FE908810881108110812081408
+3B54:1008103C13E01020FD2410A430A8382057FE5420902010201020102010A01040
+3B55:10201020102011FCFC20102030203BFE5420544090401088110413FE11021000
+3B56:10A010A810A41124FD20133E3BE03520512051209120112011141114110C1104
+3B57:010001007FFC0380054009203118C10600003FF82448244824482448FFFE0000
+3B58:1020102010501088FD04120231FC3800540055FC910411041104110411FC1104
+3B59:10201020102011FCFC20102033FE3808540855FE900810881048100810281010
+3B5A:1080108010FE1100FE00101C31E0392055225524912811101110114811841102
+3B5B:1004101E11E01100FD0611783150395055525554914811481144125412621440
+3B5C:1028102410241020FBFE102031243924552453A8912811101212122A14461082
+3B5D:082008207EFC08201C702AA8C826020002001FE00420042008221022201E4000
+3B5E:1020102011241122FA2A101030603B805440504093FC10441084108411141208
+3B5F:044004403FF8044004400440FFFE08203118C1061FF0030005C0193061080100
+3B60:10201120112011FCFD20122030203BFE5490549090901090111211121212140E
+3B61:10201020104011FCFD0411043194395455245524915411941104110411FC1104
+3B62:200427C422842294FA942294229477D46A94A294A29422942284248424942888
+3B63:1100108010BC1204FE0412F432943A945694529492F412941204120412141208
+3B64:1020104011FC1104FD4411243124390C550055FE9002100213FA100210141008
+3B65:1040104010F81088FD1013FC3104392455245124912411241050108811041202
+3B66:1040102013FE1202FC00103833C038405440507C93C0104010421042103E1000
+3B67:020004001FF011101090FFFE101012102150402001007FFC05401930E10E0100
+3B68:200027DE20922492FC94249427D870946992A192A292229A2494289022902110
+3B69:1004101E11E01022FD1210943080380855FE5408908810481048100810281010
+3B6A:1028102413FE1020FC2011FC3124392455FC5524912411FC112411241124110C
+3B6B:1020102010A810A8FCA8117432223820542055FC902010201020102013FE1000
+3B6C:100013FE10401080FD441224306838B055305228906810A41122122010A01040
+3B6D:200223E22222222AFA2A23EA210A710A6BEAA12AA12A212A2222222224AA2844
+3B6E:2124212422482248F9242124200077FE6880A1FCA10422882450202020C02700
+3B6F:100013FE11201128FD2811E831283928552855E89128112A113A13EA10261020
+3B70:088028882EF028842E84F17C0100FFFE01003FF821082388255809201110610C
+3B71:100011FE1100117CFD541154317C39545554557C911011101110110011FE1000
+3B72:1000105010481084FD24102030503888550652F8908810881088108810F81088
+3B73:1020102211FA1024FC2413FE3010382055FC5488911012FE1410101010501020
+3B74:108012FC12A412A4FEA8129032A838C65420542091FC10201020102013FE1000
+3B75:1100110011FC1204FA0415F43154395455F45154915411F41114100410281010
+3B76:1104110417FE1104FD44102037FE3880548054FC908410841104110412141408
+3B77:11FC1124112411FCFD24112431FC3840544053FE904210821082110212141408
+3B78:1080108010F81108FA1011FC31243924552451FC90501058109410921112120E
+3B79:10101388108810FEFC90139032243A24563853889090109010A410BE12821100
+3B7A:1020102013FE1050FC881124322239FC552455FC912411FC10221022101E1000
+3B7B:1020112410A410A8FC2013FE32023A0256FA528A928A128A12FA1202120A1204
+3B7C:1020102213B410A8FCA8112432A2384055FC5504910411FC1104110411FC1104
+3B7D:1040102013FE1200FE1C12F032903A9056FE52909290129012AA12CA14A61812
+3B7E:100013FE12021202FBFE121032923A92569252FE921012921292149214FE1802
+3B7F:200023FC220423FCFA0423FC200071806E3EA422A422242225A2262A24242020
+3B80:100011FC10081010FA2212AA32723A22567252AA932612A21242120213FE1002
+3B81:11841068103010C8FB24102033FE384054FC518492FC108410FC108410941088
+3B82:1FF010101FF010101FF010101FF01010FFFE08203118C1061FF0054009201110
+3B83:101C11E010201020FBFE10A831243A42544053FE9088110810D0103010481184
+3B84:1040102013FE1080FC8011FE31423A2255FA508290F2109211121152122A1004
+3B85:010001007FFC054009203118C90608801FFC30805FF890801FF810801FFC1000
+3B86:1020102010501088FD04128A305039FC542054F8902013FE1020102010201020
+3B87:100013FC10401040FBFE10A031103A0854465040904812641252145211401080
+3B88:1020102013FE1050FC88110432FA3800540053FE902011241122122210A01040
+3B89:211021102110227CFA10269236546A1062FEA210A22822282228224422442282
+3B8A:200827C820482288F93E208827D8715C692CA12AA14821082108210825082208
+3B8B:2100211E27F22112FA1423D4225876546BD2A252A25223DA22542250225022D0
+3B8C:100017FE10401080FBFC129432943AF45694529492F412941294129413FC1204
+3B8D:0820FFFE00003E0822483E4822483E482208261801007FFC05401930E10E0100
+3B8E:100013FE10101020FC6810A433223820540051FC915411541154115417FE1000
+3B8F:2040204027FC20E0F95022482C4673F86800A000A7FC20402248244429422080
+3B90:1020102010A410A2FD2A10103860358056FC508490FC108410FC108410FC1084
+3B91:1008103C11E01020FC2013FE302038A0552C5524912411AC1124112411FC1104
+3B92:100013FE10501050FDFC11543154395455FC5420902011FC1020102013FE1000
+3B93:1100117E11101110FD90115E3B22352A512651429152110C11041104117E1100
+3B94:1008103C11E01020FBFE102031FC392455FC512491FC102011FC102013FE1000
+3B95:100013FE10201040FDFC1154315439545554552C902013FE1050108811041202
+3B96:1088108813FE1088FCF8102031FC3924552455FC902013FE1020102010201020
+3B97:00207E20145008887F442A2249F888082810102001007FFC05401930E10E0100
+3B98:2008278820882290F91E211427E471546B14A314A51425082908211425242242
+3B99:100013DE12521252FBDE100031FC380057FE5080910011FC1004100410281010
+3B9A:010001F801003FF8210822C82D28228824483FF801007FFC05401930E10E0100
+3B9B:100011FC11041104FDFC1104310439FC540053FE90201120113C112012A0147E
+3B9C:100013FE12001224FAA412A432E43A3E57E452A492A412A4132E120013FE1000
+3B9D:2000229E22522252F5522112229272526C32A3D2A25A22542250225023D02250
+3B9E:1020112010BE1042FC841310311039285544548290FC10841084108410FC1084
+3B9F:2008200827E82108F93E220823D8765C6A6CA26AA248224823C8224820082008
+3BA0:1088108813FE1088FC0013FE3A023424502053FE907010A810A8112412221020
+3BA1:080008FC2A802CF8488808F8148022FC40000100FFFE054009203118C1060100
+3BA2:108010BC10841108FDFE13203520397C5590511091FE11101128112811441182
+3BA3:00007DFC44207D2045FE7C5048525492650E0100FFFE054009203118C1060100
+3BA4:020001007FFC49241290244818306FEC082008200FE001007FFC05401930E10E
+3BA5:10401048108411FEFC2013FE3888350453FE5524912411FC1124112411FC1104
+3BA6:1020102013FE1020FBFE1242348C39F05420504493FE10221128122414A41040
+3BA7:1040108011FC1104FD0411FC310039FE550055FE900212AA12AA140210141008
+3BA8:100011FC112411FCFD2411FC38883544524250F8918812501020105011881606
+3BA9:1020104011FC1104FDFC110431FC390455FC5440902010A4128A128A14781000
+3BAA:100013B811281128FD3A11AA37263A405420502093FE107010A8112412221020
+3BAB:1040102013FE1202FC2411FC382035FC502053FE902011FC1104110411FC1104
+3BAC:1090108811041242FC8811FC3804340053DE50429252114A12521042114A1084
+3BAD:100013FC100810D0FC2013FE328A3A5256FA5222922213FE1222122213FE1202
+3BAE:108013DE108A11CAFC8A13D230A6380854F0542091FC102013FE102010A01040
+3BAF:200027FE240225FAFC4224C2252A746A6CB2A52AA46A24AA2522244227FE2402
+3BB0:1020104011FC1104FD5411243154390455FC5400911211D4111811521192110E
+3BB1:1088108813FE1088FC2010A038FC3520502053FE90501050109010921112120E
+3BB2:1080108011FC1244FD5411F438843528529051FC9244155411F4108411281210
+3BB3:2044272425282500FD7C2710251075106DFEA710A5102528252825442B442082
+3BB4:10A0112C11241124FDAC1124312439FC542055FC908810501020105010881306
+3BB5:22202120213E27A0FA40223C23A472B46AACA2A4A2FE22A424A424A429A4304C
+3BB6:2440225E22922012F7D2211E255275526D52A7DEA152211222122222242A2844
+3BB7:1050104813FC10A0FD22121E311039E0550454FC900011FC110411FC110411FC
+3BB8:1044102412281100FD7C101030103B7E551051109128112411441280147E1000
+3BB9:2008200827C82210FA1E24A427D471146914A7D4A114210821C82E1424142022
+3BBA:010001007FFC03800540092037D8C10600007BBC4AA44AA44AA44AA47BBC4AA4
+3BBB:100011FC10A41088FC50102030D83B26542051FC9124112411FC102213FE1002
+3BBC:1040102013FC1204FA0413FC32003BDC5644535492CC124412CC1554144418CC
+3BBD:2100223C27A424A4F6A425A424C27F806CBCA4A4A6A425A424942488249429A2
+3BBE:10007E7C42447E7C42447E7C484444445A94610801007FFC05401930E10E0100
+3BBF:100011FC112411FCFD2411FC30A838A857FE54A890A811FC102013FE10201020
+3BC0:22102110211027BEFA40220023BE728A6A88A2A8A2AE22A824A825A8285E3080
+3BC1:20202710257C2500FD442628250075FE6D00A500A57C264424442444247C2444
+3BC2:22A822A827FC22A8FAAA24E6280077FC6C44A040A3F822482248224822582040
+3BC3:1020102013FE1070FCAC13223850348851245222912410A81124122210A01040
+3BC4:08207EFC08701CA82B26C820087C3F8020003FFC20002FF828884FF8480287FE
+3BC5:2040202027FE2420FC4025FC252475FC6D44A5FCA45024902BFE281030102010
+3BC6:1040102013FC1000FD08109033FE3A2056A052FC9320122012FC1420142019FE
+3BC7:1050105013DE1050FDDC105033DE385054505420902011FC1020102013FE1000
+3BC8:2010201024FE2210FA1020FE209276926AFEA210A238225422922210251028FE
+3BC9:1020103E102011FEFD20113C31E2391E550455789192115412FE121014501020
+3BCA:200027FC20402278F2402FFE210071FC6A00A3FCA00425542554280420282010
+3BCB:40004CFE7010422042FC3E84108410FCFE8430FC3884548452FC904810841102
+3BCC:2000227E21102130F84A209A262C724C6A9AA22AA24A22882228251028FE2000
+3BCD:20902290229E22A2FAD423A8209470A46FFEA284A2A422942294228424942888
+3BCE:22082108210827C8F83E27882018779C682CA7AAA4C824882488278824882008
+3BCF:08007F7808483E4800863E782A483E304048808401007FFC05401930E10E0100
+3BD0:00407BFC488049F852204DFC488868F8508840F8408801007FFC05401930E10E
+3BD1:20002F3E2120213CF1202F3C282078FE6850AF52A1542148214821442A622440
+3BD2:200E27F020442224F90823FC220473FC6A04A3FCA20423FC2090211022122C0E
+3BD3:204020A0211826E6F80023F8220873F86800A7BCA08424A4229424A422942108
+3BD4:01F03E0003F03E0003FA7E0201FE0C20703C1DE2F0221C1E0100FFFE0920711C
+3BD5:22402242225C27F0FA5023D0225E73D46A54A254A7F420142294246428242044
+3BD6:1020102013FE1020FDFC1154315439FC540053FE9040102412A2128A14881078
+3BD7:200027BC24A427BCFCA427BC244474446DF4A444A4E42554264C244424542408
+3BD8:2108210827C82108F91E2392202473806808A7C8A10821082594295425242242
+3BD9:2208210827C82210F49E2FD4206477946C94A794A49427882488249424A425C2
+3BDA:1210121013DE1228FD4410A031103A0855F65000900013F81208120813F81208
+3BDB:1020102013FE1020FDFC100033FE3A52545051DC910411DC1050105013FE1000
+3BDC:1088108813FE1088FC2013FE3088388855545222902017FE1020102010201020
+3BDD:2010279024BC24A4F4C427A8211071286946A5C0A53C2524252425A42E3C2024
+3BDE:2080209E21122152FA5E2780209E71126A52A7DEA052201E2552255224122016
+3BDF:10101010FEFE3838545492823FF000101FF00010FFFE111009A005401930E30E
+3BE0:102013FE104810F0FC2013FE3242389055F85028912011FC122017FE10201020
+3BE1:10401040FEFC3884550492F42894449492F410845494388854829282507E2000
+3BE2:100013DE125213DEFE10125231CE3800548853FE9088108813FE108811041202
+3BE3:21082FFE21082090F10823FC2C8A71286A50A040A7FC20E0215022482C462040
+3BE4:101010101010FEFE1010545454545454BABA1010383854549292101010101010
+3BE5:10101010FEFE10107C7C54547C7C54547C7C1010383854549292101010101010
+3BE6:211027FC211021F0F91021F0211077FC6910A248A44623F820E0215826442040
+3BE7:2100213C211427D4F91421242FCC7100693CA524A5E4253C2724250024FE2800
+3BE8:100013FE10501050FBFE125232523BFE552450A893FE107010A8112416221020
+3BE9:00107E1022FE1C10227C7714557C2250557E08127F121C162A28492888440882
+3BEA:100011FC102013FEFA2211AC302039AC545050C8932610F8100810D010201010
+3BEB:1040107C104013FEFA42127833C43A3C560053FE924013A4125815B4145219B0
+3BEC:1010FEFE5454929200407BF8084817FE20487BF808400BF8504027FC584087FE
+3BED:1040107C104013FEFA4213F832443AFC56A852F892A812F8122015FC1444198C
+3BEE:100011FC11541154FDFC108031FE3A4255F25152915211F2104A13FA100A1004
+3BEF:108011FC12881070FBAE10F8312039FC542051FC910411FC110411FC10881104
+3BF0:11FC1154115411FCFC2013FE302039FC550455FC910411FC110411FC110417FE
+3BF1:01007FFC11101FF00100FFFE90021FF821007FFC11101FF00100FFFE0920711C
+3BF2:2110211027BC2110FBB82554291270006BF8A000A7FC20402248244429422080
+3BF3:2288228827E8FA90241E27E474546854AF54A554255427482548205422942122
+3BF4:1088108813FE1088FC2013FE3202388855245450908811FC128A108810F81088
+3BF5:211027FE211023F8F84027FC204073F86A48A3F8A24823F8204027FC20402FFE
+3BF6:1020108812521326FE52128A32223BFE54885144927A10881150102010D81706
+3BF7:212821AA216C2228FAFE264436286AFE6210A27CA21022FE2210222822442282
+3BF8:204023F8204827FEF84823F8204077FE6800A2A4A45223F822A822A82FFE2000
+3BF9:20042FE422842FE4FABE2AA42FE470046FD4A00CAFEC2104254425242924230C
+3BFA:00407E40487E7EA043107EFE48AA48AA7EFE000001007FFC05401930E10E0100
+3BFB:01007FFC11101FF00100FFFE82120D2032C00DA032900D883100FFFE0920711C
+3BFC:108813FE10881020FDFC102033FE3840548855FC900011FC1154115417FE1000
+3BFD:102017FE140213FCFE2413FC32003AFC568452FC928412FC128414FC14481884
+3BFE:202824FE222822FEF8AA20FE2EAA72FE6A00A27CA244227C2244227C250028FE
+3BFF:1124124811241000FBFC129432643A9457FC524893681248136A124A12461362
+3C00:10501190109E13EAFC8A11D2328A38A454505088932610A8107010A811241060
+3C01:200027FC2100FBF82508210871F86800AFBEA208279E24922CB22492279E2492
+3C02:202023FE2202241CFBE0212420A873FE6924A202A5FC212421FC212421FC2104
+3C03:220624382F882892FFA428BC2F8872146FBEAA8AAA882AAC2AAA2BCA22282210
+3C04:20142792249E24F0F794248A249677E26C94A492A79E20702514248A28962062
+3C05:2020201024FE2244FA2820FE209276FE6A92A2BAA2AA22BA2286250028FE2000
+3C06:01007FFC11101FF00100FFFE82823EF802807EFC028001007FFC05401930E10E
+3C07:2114211227D22110F1102FFE229076D26A92A6D2A29426D4228A22CA2F162022
+3C08:1010FEFE54549292004027FC104013F8024873F8124813F8104017FC284047FE
+3C09:201020102F7E2410F43C29102F7E72246A4AAF30A210227E23382E5424922010
+3C0A:2108210827AA212CF1082FD4201274A26948A108A7AA212C210821942E242442
+3C0B:2100213E250825D0F53E25222FE2703E6922A57EA56225A228BE210022142C22
+3C0C:11FC102013FE1222FDAC102031AC389055FE532095FC112011FC112011FE1100
+3C0D:08407F7C1440FF7C22043E7C22403E7C2242263E01007FFC05401930E10E0100
+3C0E:1020122213FE1090FDFE131035FE391055FE551091FE110013DE125212721206
+3C0F:110811EE12941020FBFE100030F8388854F8500093FE120212FA128A12FA1206
+3C10:2008273E2590255EFD64265E250075DE6D52A55EA552265E2452245624A0251E
+3C11:20202294228A247AF800228A31446A286AAAA186A0402FFE215022482C462040
+3C12:22A0244C24A4260CFCA4264C34A46FFE6802A3F0A020204027FC204021402080
+3C13:27D0251027DE2450F7E8250427C473F86A08A3F8A20823F8220823F821102208
+3C14:224822E8230826EAFA1C22E832086AE865B4A8E2A00023F8211020E023182C06
+3C15:211027FC204023F8F84027FC200073D46912A7FEA3502534238C208A22962102
+3C16:13D0129013DE1268FBC4128433F8390855F8510891F8110811F810901112160E
+3C17:201427FE249024D4FC9427FA35AA6A9661A2A3F8A20823F82040227C254028FE
+3C18:208020F8210821F0F81027FE255473BC6FCAA13EA388256A208827FE20882108
+3C19:251825142F90253EF72822682FBE7AA86FA8A23EAFA822283FE8253E28A03060
+3C1A:220C210A27C8229EF55426F4245E77D46914A7DEA554255425D4245E25502490
+3C1B:21102FFE255424E4F8A82AAA2EEE74A46AAAAEEEA2422FFE215022482C462040
+3C1C:2200221E2FC42208F79E24922792749E6F92A49EA79224922FDE2500248C2892
+3C1D:00403E402240227C2284228823203E2020202050205022502C88308821040202
+3C1E:082008200820087E49424984491049104910491049284F287948004400840102
+3C1F:202020207F20807E00427E8400100010FC100410042805280528034401440082
+3C20:102008200820FF7E004200843C10241024102410242825284648444480840102
+3C21:082008201420127E214240849210121012101210122812282228224442448282
+3C22:00207E202420247E244224842410FF1024102410242824282448244444848502
+3C23:142014201420547E55425E845410541054105410542854285D487644C4840102
+3C24:00200020FFA0027E02427A844A104A104A104A107A284A28024802440A840502
+3C25:122052205220527E5242FF845210521052105E104028402840487FC400840102
+3C26:0820082008207F7E084208840810FF901010101024284228FF48414400840102
+3C27:104010402040287C4484FE88432000207C2044504450445044887C8845040202
+3C28:002000207E20427E4242428442107E1042100010242822284248424480840102
+3C29:0820082008207F7E49424984491049107F10481008280A280F48F14440840102
+3C2A:0820082008207F7E08420884FF100010081008107F28082808480F44F0844102
+3C2B:0820282028203E7E4842088408107F1014101410142814282548264444848102
+3C2C:2020202020207F7E41428184791049104910791049284928792801440A440482
+3C2D:10401040FE40287C448482887D200020FE20205040507C500488048829041202
+3C2E:00207F204020407E5E42408440107F10501051105A2854285228914498441082
+3C2F:0020FF200020007E7E424284421042107E1000104228222824280F44F0444082
+3C30:082008207F20087E08422A842A102A105D108890082814281428224442448082
+3C31:072078200820087E7F4208847F10491049107F10492849287F28084408440882
+3C32:0420052004A0FFBE042204447550559055107310029032A8C5A808C410440082
+3C33:0040FE402840287C2884EE88832082208220EE50285028502E88F08841040202
+3C34:102008207F20007E22421484FF10001000103E102228222822483E4422840102
+3C35:1020082000207F7E004222842210551088900810FF2808280848084408840902
+3C36:222022203A204B3E4AA2AA4412502890479080103F102128212821443F442182
+3C37:00200020FFA0227E22423A844A104B904A10AA101228122822A8234442448082
+3C38:082008201420227E4142BE84081008107F10491049287F280848144422844102
+3C39:0110019001507F9E411241225D08414841485D48558855945D54415442D48462
+3C3A:002077205120513E512277444050409077104110491075284228424445444982
+3C3B:08200820FF20083E08227E4400507E90421042107E10422824280F44F0444082
+3C3C:0020FF208820887EFE428884AA10AA10DD10881094289228A128C044FF440082
+3C3D:0020FFA08020BF7EA142BF84A110BF108810FF909228B2288C289244A144FF82
+3C3E:082010207E20427E7E4242847E1010100810FF1020283E28224842444A848502
+3C3F:0E40F0402240927C448420884520F82010202450FE501050FE88288845048202
+3C40:202020207F20917E55427D8421104A10A4107F10912855287D2821444A448482
+3C41:08202A202A203E7E494249847F1000103E1000107F2808282A48494428841102
+3C42:041002103FD0221E2F9222A43FC822882F88220832482A9427144A9452548622
+3C43:082014202220497EBEC204840810FF9014107F105528632841487F4441847F02
+3C44:00207F2049206B7E5D4249847F1008107F1008100F28F0280128554454444082
+3C45:0820FFA008207F7E0042FF8480907F1000107F1041287F28412822440FC4F082
+3C46:08200F2008207F7E49424C847910471040105F1040285F2851285F448A443F82
+3C47:08207F202A202A3E5D220844FF5000907F1041105D1055285D2841447F444182
+3C48:22202220F7A0227E7742AA84225000107F100010FFA80828492888C428441082
+3C49:142055203620147EFF42228414107F1008107F100828FF281C282A4449440882
+3C4A:FF2010207E20427E7E424284FF1091104A10A5101C2820287E28A2441C44E282
+3C4B:3F9004107FD0445EB5920424358812083FC86408BF8824143F9424143FD42022
+3C4C:7F8821083F0821083F1E21D2FF240100FFC852887388528873945AD4F7A410C2
+3C4D:4848444840485E4EA0AAAEB2C0C44E4440448E84AAA4EAEA0A0AAEAAAAAA0010
+3C4E:7F2055207F202A7E49422A8461103E104410FF1049287F2849287F440044AA82
+3C4F:00001FF00000000000007FFC01000100110011F81100110011001100FFFE0000
+3C50:000000103F0800080000FFFE00000400040027002400240024002780F8004000
+3C51:0100010011F811001100FFFE020004000FF0101068200440028003001C00E000
+3C52:0100010011F811001100FFFE0000FFFE00101F90109010901F90001000500020
+3C53:08200820085048504E8849244A12481049FC4804480848884E50F02000100010
+3C54:044004441748147014421742783E020007F0081034200240008003000C007000
+3C55:100011FC100410FC50045DFC500053FE5222502051FC5D247124C13401280020
+3C56:1040102013FE100050885C88515452225000502053FE5C207020C02000200020
+3C57:1020104011FC110451FC5D0451FC510451FC502850245DFE7050C08801040202
+3C58:3FFE29142F1229102F7E20102F2829282F2829442F4429824B40447C84401FFE
+3C59:000003FEFC40204020803C80450045FC64049404080408041004200440288010
+3C5A:000000FCFC84208420843CFC44844484648494FC088408841104210442148408
+3C5B:00000000FDFE202020203C7C44444484648495480A2808101010202040408080
+3C5C:00000020FC20202020203C204520453C652095200920092012A02260443E8800
+3C5D:00100010FF902210227E3A124A124B924A12AA121212121222922322422A8044
+3C5E:00800040FC40200023FC3C0044084508650894900890089010A0202047FE8000
+3C5F:00100010FC1021FE21123D14451045FC65449544092809281110222842448482
+3C60:00200020FC20202023FE3C204420442065FC9504090409041104210441FC8104
+3C61:00200120FD2021FC21203E20442047FE6490949008900890111221124212840E
+3C62:00400020FDFC210421043DFC4504450465FC9520092209141108214441828100
+3C63:0004001EFDE0202221123C944480442065FE9444088409C81030202840C48302
+3C64:00800086F898209023D03890489E499469D49AB40A94149410942094409480A4
+3C65:00200020F9FC202020203BFE488849446A4298F8098812501020205041888606
+3C66:00200020FDFC205020883D0447FE440865E89528092809E81128200840288010
+3C67:00400020FBFE22022504390049DE4A526A529B520C9A1094111021124212840E
+3C68:00400020FBFE2202240438004BFE482068209920093C112012A02260443E8800
+3C69:00200020F9FC202020203BFE4802489468509910089013FE1028204440828302
+3C6A:000001FCFD0421FC21103DFE4510454A6586940009FC090411FC210441FC8104
+3C6B:0020FC2023FE202021FC3D2445AC4574652495FC0820087010A8212442228020
+3C6C:000003F8FA48224823F83A484A484BF868009FFE0A4012441228229043088206
+3C6D:00800338FA28222823A83A464A004A7C6BA49A240A2813A81610222842448282
+3C6E:00200020FDFC212421FC3C2047FE440065FC9504092409241124205040888304
+3C6F:00200124FD24212421FC3C0047FE440065FC9504090409FC1088205043FE8000
+3C70:0040FC2023FE224220203DFC4488445067FE9420082009FC1020202040208020
+3C71:00200040FBFC222422243BFC4A244A446BFC984008A810B4113C21224222841E
+3C72:02080108F910200027FC380049104A086C049BF80AA812A812A822A84FFE8000
+3C73:04407FFC04401FF010101FF010101FF00400FFFE10102FE8C2060FE004403F80
+3C74:002003FEF82021FC20203BFE480049FC690499FC090411FC110421FC40888104
+3C75:002001FCFC20208823FE3C8845FC450465FC950409FC090411FC208841048202
+3C76:00820082FBF4208820803BE248024BE46A289A200BE012221142207447888210
+3C77:00A00090FDFE232021FC3D2045FC452065FE950008200BFE107020A843268020
+3C78:001003C8FA7E224022623BD44A004A3E6BC89A480E7E1248124823C842488008
+3C79:000003FEFA2222CC22443BEE4A444AEE6B549A440A101290129E249044908BFE
+3C7A:0040007CF84023FC22443BF04A444AFC6AA89AF80AA812F8120025FC45548BFE
+3C7B:00401FFEE40047FC400077FC540497FC51102EAE2BFA2E4A4AEE4E4A8BFA1650
+3C7C:00003E78224822482248228622003EFC20442044202822282C10302820440182
+3C7D:0800087808487F4849480886080014FC14441444142825282610442880440182
+3C7E:100008780848FF480848108622007CFC094412442428C82814102228C0440182
+3C7F:10001078FE48104810487C86000000FCFE4482448228BA28821082288A448582
+3C80:00007F78404840485E48408640007EFC504451445A2854285210512898441182
+3C81:20001078FE48824828484486820000FC7C441044102810281E10F02840440182
+3C82:10009278524854481048FE86820082FCBA44AA44AA28AA28BA1082288A448582
+3C83:100010781E4810487E4842867E0042FC7E44004420283E28201022282C443182
+3C84:10001078FE4810487C480086FE0082FC00447C4410287C2810101E28F0444182
+3C85:20001078FE48824810487C8610007CFC1044FE4410287C28441044287C444582
+3C86:08007F7808483E4800863E782A483E30414882840C603118CFE6004006800180
+3C87:08007F7808483E4800863E782A483E3048489FF4282007C01830E18E0C400300
+3C88:08007F7808483E4800863E782A483E30404880867FF8080810303FF8D0081FF8
+3C89:1000FE7810487C480048FE8682007CFC2044CE44AA28EE28AA10EE2828444982
+3C8A:10001F381028FFA880A87F462A00557CA2247F24A2A83E2822103E2822443E82
+3C8B:080008001FE020204040BFF8200820083FF8000020843E9820E020842684387C
+3C8C:08001DF87048104810501C5C7084108410841D04F1281212100210020FFE0000
+3C8D:1010103811C0FE40107811C0FC40447C47C0284428441044183C240043FE8000
+3C8E:04080E1C70E0102010201C3C70E0102010201E3CF0E0102214221822101E0000
+3C8F:0408243C25E0242024203E3C21E020203C20243E27E02420242244224422841E
+3C90:08201C207050105010881D44722210F810081C10F0101022102210020FFE0000
+3C91:08201C207020102411A81CB070B0112811281D24F22410A0104010020FFE0000
+3C92:2008201C40E07E208220023C7AE04A204A204A3C7AE04A2202220222141E0800
+3C93:08281C24702411FE11201D2871A8115011141D34F14C1104120010020FFE0000
+3C94:1004080E7F7000102210141CFF7008100810081E7F700810081208120812080E
+3C95:04081E1CE0E022209220543C40E00420FF20043C44E0242224220422141E0800
+3C96:0804490E29702A1008107F1C417041107F10411E41707F10411241124512420E
+3C97:04081E1CE0E0022092204C3C00E0FE200420083C0EE0F82248220822281E1000
+3C98:00087E1C42E042207E20423C42E07E204220423C7EE0002224222222411E8100
+3C99:08401C2071FE104010881DFC700410A810A81CA8F12A1226100010020FFE0000
+3C9A:1020082040A824A4092A723010C0170000F03F0001F03F0001F87F02010200FE
+3C9B:20003E7C48440844FF441444227C400000F03F0001F03F0001F87F02010200FE
+3C9C:1008521C54E090202820443C82E010201020523C54E0902228222422421E8000
+3C9D:08501C4870FE119012901CFE7090109010FE1C90F09010FE108010020FFE0000
+3C9E:1004080E00707F100010221C227055108890081EFF700810081208120812080E
+3C9F:2204220E7F7022102A10081C3E702A102A102A1EFF700810141212122212400E
+3CA0:082008207E7E08C4FF281C102A2848C600F03F0001F03F0001F87F02010200FE
+3CA1:0804080E7F701C102A10491C00707E100010FF1E08704A10491289122812100E
+3CA2:1004080E7E70421042107E1C427040107F10551E55707F10D51255125512430E
+3CA3:5008961C92E09220D620923C92E0FE201020FE3C02E0642218222422C21E0000
+3CA4:1004080E7F7000103E10221CFF7022103E10189E35705210911214921812100E
+3CA5:1004080E7F7048105E104A1C7F704A105E10481E5E705210521252125E12920E
+3CA6:102010201050FE8811067C1844E07C2044387CE01020FE3C11E010221022101E
+3CA7:10003BF0E150211020A03840E1B0264E21F03950E1F0204823FA200A20021FFE
+3CA8:2408241CFEE024200020FE3C24E03C2024203C3C24E02E22F4220422041E0400
+3CA9:10003BF8E20823F822083BF8E00027BC20843CA4E29424A42296210A20021FFE
+3CAA:0A04740E157052102210211C5D7080107E10421E42707E10421224120F12F00E
+3CAB:2808AA1C6CE02820FE20443C28E0FE2010207C3C10E0FE2210222822441E8200
+3CAC:2808241C7EE0C82048207E3C48E048207E20483C48E07E224022AA22AA1E0000
+3CAD:0804290E29704A101410221C4170001022102A9EB7706210221252124512888E
+3CAE:12103A10E3DE252820843840E0A0211022E83C04E1F02110211221F220021FFE
+3CAF:00047A0E52707B904A107B1C54F0789000107F1E5570551055125792FC12000E
+3CB0:0804FF0E91704A10A5101C1C00707F105510FF9E00707F10081208122812100E
+3CB1:11243A48E12423FC22943A64E29423FC22483B68E248236A2246236220021FFE
+3CB2:7F04490E7F704910FF90AA9CFFF0AA90FF90001EFFF0A2903E1222122792F80E
+3CB3:08201C20F120912091FC9120FE20902093FE902090508A50A688D28809040202
+3CB4:20003FFC40009FF000007FF0041004107FD0445044507FD2444A040A04060402
+3CB5:20003FFC40009FF000007FF0249015107FD040507FD040527FCA404A41464082
+3CB6:20003FFC40009FF000007FF0041007F004107FD055504A5264CA4A4A55467FC2
+3CB7:20003FFC40009FF000007FF02A903B9000103F9024903F92248AFFEA04060402
+3CB8:0000200013FC1008801040204840088010801100E10022022202220221FE0000
+3CB9:000021F011101110811041104910091011101110E210221222122412240E0800
+3CBA:00402040104010408040404E48700FC010401040E040204220422042203E0000
+3CBB:0840084008401044176831703160515091501248124814441842104011401080
+3CBC:0000200812081208820841104910091010A010A0E040204020A0211022080C06
+3CBD:000023FC10841084808442844A840A8414841084E08420842104210422280410
+3CBE:020001007FFE40028104010001003D8405880950092011102108C10605000200
+3CBF:00402020102013FE820042004A000A0012001200E20022002200240024000800
+3CC0:009020881088108080BE47C04080104410442048E03020222052218A26060002
+3CC1:000023FE12001220822042204A200A2012201250E25022502488248829041202
+3CC2:0020212011201110811042484248144418822080E1102108220827FC22040000
+3CC3:0080208013F010908090411249120A4E14401040EFFE20402040204020400040
+3CC4:00802080108010FC8104410842401440104020A0E0A021102110220824040802
+3CC5:0000200017FE102080204040484008D011481244E44220402040204020400040
+3CC6:00102110109010908010421049100910101E17F0E01020102010201020100010
+3CC7:0020211011081204820444104110111010A020A0E04020A02110220824040802
+3CC8:004020401040104087FC40404950095011501150E1522252224E244020400040
+3CC9:000021FC11041104810441FC49040904110411FCE10421042204220424140808
+3CCA:00802080110011FE8210421045101110111020A0E0A0204020A0211022080406
+3CCB:0008203C13C01200820042004A000BFC12201220E2202220222022202FFE0000
+3CCC:000027FC14441444844447FC44441444144427FCE44420402040204020400040
+3CCD:00402040104017FE808040A0492009FC13241524E12421242134212820200020
+3CCE:0040204010801110820847FC40041110111027FEE11021102210221024100810
+3CCF:00402040104017FC844444444444144417FC2040E24021402080214022300C0E
+3CD0:011021101110111087D041104310139015502510E910211221122112210E0100
+3CD1:0000200013F812A882A842A84AA80AA812A812A8E2A822A822A82FFE20000000
+3CD2:00402040104017FE80A041104208142610202040E0802108220427FE22020000
+3CD3:004020401040104087FE40804880090013FC1504E90421042104210421FC0104
+3CD4:000420041784108480BE4484428412A411142114E28422842484280420140008
+3CD5:0000210810881090800043FE48000800100011FCE00020002000200023FE0000
+3CD6:00802040104017FE808040804940094413481530E92021102108214421820100
+3CD7:000023F81108115080A0404041B0160E10402040E3F820402040204027FC0000
+3CD8:00802040104017FE80804110420817FC11242120E120212022222222241E0800
+3CD9:004020801108120487FE400248000BFC120413FCE20423FC2204220422140208
+3CDA:002820241024102083FE42204A240A24132412A8E22822102212242A24460882
+3CDB:00402140165C14448444475C4444144417FC2444E0A020A02110220824040802
+3CDC:009020901090111081FE43104D10093811381154E15421922110211021100110
+3CDD:01002108111C1270821046104A10121012FE2210E210221022102210227C0200
+3CDE:011021101110121082FE469256921A92129222FEE29222102210221022100210
+3CDF:044004403FF804400440FFFE082011102928C546038005400920311005000200
+3CE0:001024101210121080FE40104610122812242244E24222822200250028FE0000
+3CE1:040842082208200800FE8E084248522812282208E20822282210250028FE0000
+3CE2:0010207813C01040804047FE48A0091012081516E11021102110221022100410
+3CE3:00402040104413F48048405047FE104010802184E29824E028822082207E0000
+3CE4:011049102510251001108FFE4110511015982554E95422102210241028101010
+3CE5:000027FC1040104083F84040404017FC11102110EFFE21102110221022100410
+3CE6:0014401220102FFE00108290429252921FD22294E2942288228A249A24260842
+3CE7:00002FFE14801490849047904490149014902790E490249224D22F92208E0080
+3CE8:012421241248124881244124400017FE108021FCE10422882450202020C00700
+3CE9:0000407C20442E44046484544454544415FE2444E7443C442044208420940108
+3CEA:000027FC1020104080D041485244144410402000E3F822082208220823F80208
+3CEB:010001087D1005A009603118C50602000C00307820083C78200820083FF82008
+3CEC:0100210011FE1200840041FE482208241120113CE1202120212022A0247E0800
+3CED:000023F812081208820843F84040104017FC20E0E15022482444284220400040
+3CEE:000023FC1204120483FC42004A200A2213B212B4E2A822A8252425242AA20040
+3CEF:0080204017FC1000811040A04FFE104010402040E7FC20402040204020400040
+3CF0:0040202013FC1040809041084BFC080411101110E7FE21102110211022100410
+3CF1:0000278014BC152485244624452414BC14A424A4E6A42524243C242424000400
+3CF2:0020482024202020082085FE4420502012202450EC502450248824C825240202
+3CF3:00402040104017FC804040404BF80A08120813F8E0A020A021222122221E0400
+3CF4:004020281088129082A442C2448A118816782000E04027FC204020402FFE0000
+3CF5:003823C0104017FC80E0415052481C4613F02020E04027FC2040204021400080
+3CF6:00E84F08222829280548800847C8508811082108E1E82F08210A210A250A0206
+3CF7:0100210011FC12A484A441244A44089411081000E3FC220423FC220423FC0204
+3CF8:0108210817FE1108810840004890089211141318E510213221522112210E0100
+3CF9:0200420022FE22100F9082104610577C16902A90EA103210221022FE22000200
+3CFA:02404240227E22800F00827842085308121026FEEA102210221022102A500420
+3CFB:01102110111017FC811041104FFE100013F82208E20823F82208220823F80208
+3CFC:00500048FFFE00403E4022243E2800120E2A70C6030A7D90096011202518C206
+3CFD:002027201120113E814047404490141014102754E15221522192211025500220
+3CFE:02082108111017FC8040404043F8104010802FFEE1202120222022222422081E
+3CFF:0040202013FC1040809041084BFC0844104017FCE0E0215022482C4620400040
+3D00:0108210817FE11088000403C4BC00820101013FCE0082010206021802240043E
+3D01:000023F8104010408FFE41104208151613F82110E11027FC2110211022100410
+3D02:0020402020202EF804A884A844F854A814A824A8E5FE26883888208820A80090
+3D03:0040202013FE1202820243FE4220122013B222B4E2A824A82524292432A20040
+3D04:000027FE14021492848A450A4402140214F22492E49224922492249227FE0402
+3D05:010001087D1005A009603118C50602003FF82448282837D8244827C820083FF8
+3D06:000023F8100811F8800843F8400017FE14422844E3F822482248224822580040
+3D07:1088108810881088D6EA52AC52A85AA856EC52AA52AA94C81088108852A82110
+3D08:0010203813C0120083FC4220422012201FFE2000E04024442444244427FC0004
+3D09:00402090110813FC8108421044A417BE10822000E3FC20002000200027FE0000
+3D0A:044422441284101487D4411445541554155427D4E15421142204220424140808
+3D0B:0040204013F8104887FE40484BF8084012481248E2E823582248224824480848
+3D0C:02104210221022100F7E851045105510157C2944E544224422442544257C0844
+3D0D:03F04010202020440E5883F04250524815E82448E4442BF43042204021400080
+3D0E:0040204017FC10A08110420845F61000100027FCE04022482244244421400080
+3D0F:0080204017FC140481104208440413F810402040E3F820402040204027FC0000
+3D10:000040FE2F1029100950895E4F52495219522F7EE902290229022F0229140008
+3D11:0040202017FE14008504448847FE142015242524E52425FC2844288031000200
+3D12:0080204017FE1090829844944114123014002110E1102FFE2110211022100410
+3D13:000023FC1244124483FC42444A440BFC10001040E0242522250A290820F80000
+3D14:0080208011F81208841043FC480409FC100413FCE00420402124252A250A08F8
+3D15:0108210817FE1108800040384BC00840104017FCE0E021502248244428420040
+3D16:0110211017FC111081F0404043F81248124823F8E0402FFE2040204020400040
+3D17:000023FE1050105083FE42524A520BFE10001040E7FE20882190206020D80304
+3D18:000027FE140215FA840245FA4402100013FC2204E3FC220423FC220423FC0204
+3D19:0008203C17C0104080404FFE40401140165C2444E444275C2444244427FC0404
+3D1A:02082110100017FE80804184424414A811302270E4A8212822242C2220A00040
+3D1B:0008200817C81210821E44A447D41114111427D4E114210821C82E1424140022
+3D1C:0080204017FC1404840447FC4400140017FC26A4EAA42BFC2AA42AA432A4020C
+3D1D:060478440844FF441C442A44C9140A880C603118C92605400920111025080200
+3D1E:0008203C13C010448224412849000A7C12441244E27C224422442244227C0244
+3D1F:000023FE120012FC828442FC4A840AFC120012FCE208221023FE241024500820
+3D20:00008FF8401000208040577A554A156A35525552D76A504A514250825FFE0002
+3D21:003823C01040104087FC41505248144613F82208E20823F82208220823F80208
+3D22:0090909048900190917C4954495403542554497CD95449104910491049100110
+3D23:002090204BFE002091FC482449FC012025FE4822D82A48544850488849040202
+3D24:021042082200227E0F9082104210571016FC2A10EA102210221022FE22000200
+3D25:04108410445404389510557C55441544357C5544D544577C5944404440540048
+3D26:0040202017FE1402800041F84908090811F81000E3FC22042204220423FC0204
+3D27:0040208013FC120483FC420443FC120413FC2000E04020242522250A28F80000
+3D28:0044272415281500857C47104510151015FE2710E5102528252825442B440082
+3D29:012422481248112483F842084BF8080013F81248E24823F82202220221FE0000
+3D2A:0040208013F8120883F842084BF80A0813F81040E7FE20E02150224824460040
+3D2B:40002FDE225282525FF4425402582FD4241247D2CC524C5A545467D044500010
+3D2C:010822081788148887BE4488478814C814A82FA8E18822882488288822A80110
+3D2D:0080204017FC140480A041104A08080013F81208E3F8220823F8220823F80208
+3D2E:000027FC1404140487FC4420452414A815FC2504E5FC250425FC290429141108
+3D2F:002027A414A814B084A247A2449E148014BE27A2E4A224BE24A228A22ABE1122
+3D30:01102212145417D88010401247D2144E144027D2E454245827D024522552048E
+3D31:0080204017FC140480A041104248104017FC2040E44422A820A0211022080C06
+3D32:0004203E17E0143E842045FE4522153815E2251EE50029782A48324A248A0906
+3D33:04484444244024FE04509F544458545214542458E45227543C9A2092212E0240
+3D34:002024A414A8152084504488450417FE142024A4E52824502488250427FE0000
+3D35:00402028109012A482C2448A41881678100023FCE2942294229422942FFE0000
+3D36:0080208017FE1522811043FC56201A2013FC2220E22023FC2220222023FE0200
+3D37:00104F9025102510077C855447545510151025A8E7282D28214A214A21860100
+3D38:000027BC14A417BC84A447BC4404144414442444E4A424942514240424140408
+3D39:0010209214521254821040FE4010163812542292E31022102210250028FE0000
+3D3A:00208820442005FC902048A848A804A825744A22D85048504888488849040202
+3D3B:00044FC42004200407BE8484448454A417942014E8842484250421C42E140008
+3D3C:0040202017FE1402810041FE421016201A7C2244E244227C22442244227C0244
+3D3D:0008403C27C02040024881504FFE515012482C46E08020442A422A1231F00000
+3D3E:010841082FC82110011E8FD44864401417942094E11421C82F08211425240242
+3D3F:0000407E2F902220027C82444244527C1244227CE2442244227C2A0024280044
+3D40:04204220223E2F4004A08420473C555015102510E5FE2510252829282B441082
+3D41:0108210817FE1148802047FE4880090813FC1004E1502150215022522252044E
+3D42:0040202013FE1200824842484BFE0A4812481248E27822002554252A2A2A1000
+3D43:0410840844081F7E95425542552015243F284430C420452247A25CA2481E0000
+3D44:00142012101217FE801043D04A500BD4101417D4E11427F8210A228A24560822
+3D45:004020A0111012488DF6402048400BF8120813F8E20823F8220823F821100208
+3D46:000840282F28293E0928894849084F7E19002900E93E29222F222922203E0022
+3D47:01A44E2422242224027E8FA44224522412242FBCE8A428A428A42FA428BC0024
+3D48:008890884888008893DE494849480148255E4A52D95248924892495E49520200
+3D49:008890884888008893DE48884888019C25DC4AAADAAA4CC84888488848880088
+3D4A:000023F8120813F8820843F850001FFE148027BCE494279424D42F88209400A2
+3D4B:000027FC14A414A487FC40004BF80A0813F81208E3F8220823F8211022080404
+3D4C:0408841C49F01110A51045FE4910197C2944497CC944497C49444A444A7C0C44
+3D4D:0000279E1492179E8492479E44421422140A2546E542255226322402240A0404
+3D4E:079E2492179E1492879E440244F2149214F22492E4F224922492253224020406
+3D4F:0110211017FC1110804047FC4110111012A82444E0402FFE2040204020400040
+3D50:40002FFE28008A2849484BEE089228842AA04AA8CBE848884894491449241242
+3D51:0200420027BC22A404A485BC480053F8120823F8E20823F8220823F821100208
+3D52:009027FC109413FC829043FE49120BFA150E11F8E10821F8210821F820900108
+3D53:008040402FFE280203F8820843F8520813F82000EFFC2240227C254024FE0800
+3D54:0040204017FC11108248444643F8105017FC2080E3F82D0821F8210821F80108
+3D55:0080211013F8121084A447BC404010A013582C46E04822642252245221400080
+3D56:0100210017DE125286924112429E14C0111023E0E04827FC2254244829440080
+3D57:43FC22400BF80A4013F82240E3FC20042554200801087D90096011202518C206
+3D58:08100A146AD42C582A544A94A950102008100A146AD42C582A544A94A9521020
+3D59:004027FC104013F8800043F8420813F811102FFEE00023F82208220823F80208
+3D5A:01102208141411A080604198464410A013182DF6E04027FC224821502FFE0000
+3D5B:011020A017FC104083F8404047FC124811502FFEE00023F82208220823F80208
+3D5C:0010241012FE1210801048FE448214AA119222BAEE9222FE22922292228A0084
+3D5D:008080405FFE0148823046905B08020627FC4524C61445EC452445E444140408
+3D5E:00C84708212A212C0FC881084388555419142122E04020242522250A290800F8
+3D5F:028842A826A82BF0001E822445D45C14141425D4E55425482568255426140422
+3D60:004047FE24022914020887FC440457FC14202524E52425FC24202924292411FC
+3D61:03F8204017FC1444835840404358120013F82408EBC8224823E82212220201FE
+3D62:000047FC20402FFE0842835840405358100027FCE444244427FC2444244407FC
+3D63:00109F1051101F3E91225F4448101F9024905490DAA850A85EA840C445440282
+3D64:000027BC108414A4829444A4404017FC10402248E248255420A0211022080C06
+3D65:0080204017FC1484805045285554199416F02000E3F822A822A822A82FFE0000
+3D66:002021FE144012FC811042FE400016FC128422FCE28422FC2284228C250008FE
+3D67:011027FE111013F8820843F84A080BF8110013FCE4442AA4220423F420140008
+3D68:00407C2045FC44887C5043FE7C20A5FC24203C2001087D90096011202518C206
+3D69:010827FE1108100084884FFE448814F8140027FCE0402FFE215022482C460040
+3D6A:0208211017FC104083F8404047FC10001440227CE08422282C20245024880106
+3D6B:01F8201017FE10A0804047BC408411CE17382108E31827FC240427FC240407FC
+3D6C:00009DF85488149014FC1D549524555416881C0015FC55549554255427FE4C00
+3D6D:0040204413F8105087FE404051FC170411FC2104E1FC20002524249228920000
+3D6E:004027FC10A013188D1643F8411011F0104023F8E24823F8204027FC20400040
+3D6F:40002FF828088BE849084BE80A282BE82A284BE8CA084BFA4A0A53FA55562032
+3D70:0140224C12641244834C42644AA40BAC12A412A4E7FE20002110210822040404
+3D71:00044FE422842FE40ABE8AA44FE4500417D4200CEFEC2104254425242924030C
+3D72:0100420027FC2AA802A88FFE42A852A81FFE2208E3BE24882AA8213E22080C08
+3D73:00404FFE280227BC04A4829444E450A013182C46E090232020C8231020600380
+3D74:000C800A57FE140895E85D48454A05EA3D2A552CD5EC554C654A49EA48161022
+3D75:07E0225C13C4125483C8426847D41064103C27C0E144226820D0214826460040
+3D76:0110411427D221100FFE829044505FF4149427F4E49427E8248A27FA24260042
+3D77:2010110810887CBE020029141108FC3E108810887D1C13081108210821084008
+3D78:004020A01110120885F4480243B812A813B82000E7FC24A427FC24A424A4040C
+3D79:0428842844FE04289500557C5544157C3544557CD510577E5910402840440082
+3D7A:0210221017DE152888C440804BFC0A2413FC1244E3FC2120222027FE20200020
+3D7B:40502E962A928A924AD64E920A922AFE2A104EFCCA444A444A285210522826C6
+3D7C:000027FC140410808338420843B8120813F82200E7FC28042554255428280010
+3D7D:03F82248124813F88248424843F810001FBE2AAAEAAA2FBE2AAA2AAA2FBE08A2
+3D7E:0200823C5FA402248FBC42245FE4003C2FA448A4CFBC48904F9848A848AA09C6
+3D7F:0080210013F8120883F8420843F8120814102FBEE8A228A22FBE28A228A20FBE
+3D80:00004EEE2A222AAA0A668EAA4A104A281A442F92EA202AC82A322AC42A1816E0
+3D81:03909C10411E15108A7E4852425C02703F52424ED2404A5C42544A5444960122
+3D82:0088908849FC008890884BFE482001FC252449FCD92449FC4800488849040202
+3D83:0080908049FE0354915449544BFE015425544954DBFE48004954492A4A2A0000
+3D84:07BC24A417BC14A487BC448444F41514162425B4E51425B4251425F424140408
+3D85:42A0244C24A4860C44A4464C04A42FFE280243F0C020404047FC404041400080
+3D86:04104210227A2F1200148F7E40084F10103C2F64E9A4293C29242F24293C0024
+3D87:42282228227C82284F2842FE0610277C2AD44A7CD254427C4200422842440282
+3D88:0110455425B8291002A884444FFE4842104023F8E248224823F8204427FC0004
+3D89:0308BC1044BE11228432492A5E22042629205F3EC4025F02447A4A02510A2084
+3D8A:00004FBE2A082A100A3E8FA248A248BE18A22FBEEA222A222A3E2A002F940022
+3D8B:050855482DA8253E0FA8824844484ABE13082588E988237E25402920251E0200
+3D8C:00449F444AAA0AEE8E444AAA4AEE0E002A284AAACBAA4EEE5A28422842480288
+3D8D:0200422227922494093E87C84548555E17C82548E57E27C820082AA82AA80008
+3D8E:01FC495425FC240001FE80005CFC448414FC2452E4CC254824642B0030FE0000
+3D8F:001C4EE02A542A280A7C8C104AFE4A001AFC2A04EA7C2C0428FC2814294A0A38
+3D90:0040202017FE14A884FE4550477C1550157C2550E57E254028A42A8A328A0478
+3D91:021082104510089E90526FA2400800083DC85548D5485DD44894489455542222
+3D92:1F3E91225F3E11229F3E500257FA148237F25482D7F2548257FA500A5AAA1014
+3D93:02109FFE4214000A07FE140895E85D4805EA3D2A15EC554CA54A09EA08161022
+3D94:000043F822A822A803F880004FBE4AAA1AAA2FBEE0402FFE20A0211022080C06
+3D95:021043DE2528288407BC84A447BC54A417BC2404E5F4251425F4251425F4040C
+3D96:088089F84A881070138E3400B5FC55AC157415FC142055FC942013FE1154122A
+3D97:20287F78AA147F7C2A543FB206001FF010101FF010101FF001843D480930730E
+3D98:021043DE2528288407FC80A047FC54A417FC2208E3F8220823F820402FFE0040
+3D99:0284AAA456D4029EA7D451245224055E298452C4F4C451BE52A05490528E0100
+3D9A:07FE209017FE149287FE428047DE12921392211EE7D2255227DE21122FD20126
+3D9B:1080888049FE3D0012A0112C9D3455AC1534155415DC5554A7FE24884D048202
+3D9C:0002BEFA628A3EFA208231C6AAAA60823FFE2AAA2AAA7FFEAAAA2AAA32CA4104
+3D9D:004090204BFE02A492BE4BE84ABE02A826BE4AA8DABE4AA04A144B524D4A0A38
+3D9E:03F8220813F8120883F840404FFE14A417BC2110E7FC21102FFE212423180D86
+3D9F:47FC244427FC84444FFE4AAA0FBE2AAA2FBE4220C7C040844FFE404245480884
+3DA0:00009EFE54AA1EAA94FE5E10547C14103FFE4128D57C551055FE511041100610
+3DA1:00003FF8210821082108292829282948310822882248244A242A482A50068002
+3DA2:01001110111022A0044008203018C20602003FE002200420042008223022C01E
+3DA3:00003FF801000100FFFE01000100000001001110111022A0044008203018C006
+3DA4:10801080108010FC550459045284944810281010101028202440448041008600
+3DA5:100011FC1020102054205820502093FE10201020102028202420442040208020
+3DA6:100011F8100810505420581053FE902210241020102028202420442040A08040
+3DA7:10201020102011FE55225922512291221152114A118A290225024502410A8104
+3DA8:00007FFC008001000300056009183104C1020100010000002488224442448004
+3DA9:10201020102011FE55225A24502090201050105010502850249044924112820E
+3DAA:00007FFC01000300056019186104000001001110111022A0044008203018C006
+3DAB:010001007FFC0100210412C80C30F00C01021110111022A0044008203018C006
+3DAC:10201020102015FE58205020502091FC107010A810A829242524422240208020
+3DAD:1010109010901110557E5A52539290921112111212522BD224624422404A8084
+3DAE:00007FFC010001003FF8210822882448200820180100111022A004401830E00E
+3DAF:10001080131E125256525A5252529252125212D2135A2A542490449041108210
+3DB0:10881088108814885BFE508850889088108810F8108828882488448840F88088
+3DB1:102010201020102055FE58205070907010A810A811242AFA2420442040208020
+3DB2:100011FC11241124552459FC51249124112411FC11242924252445244104820C
+3DB3:01003FF00110FFFE01103FF001003FF80100FFFE00000100111022A00C60701C
+3DB4:10201020107C108455485830502090481190103E104229A42418441040608180
+3DB5:0810087813C0304050409FFE10401040104017FC100000002488224442448004
+3DB6:10201020102017FE5A42544450A090A211A4129814902888248444A240C08080
+3DB7:1080108011FC15045A0451E45124912411E41124112429E42504440440288010
+3DB8:1040104011FC14445884508451289210110813DE114A294A254A4252435A84A4
+3DB9:100011FC102014205BFE50005020902213B210B410A829282524422444A28040
+3DBA:100011FC1020102054205BFE50509088110412FA148828882488448840F88088
+3DBB:08001FF0282007C01830E10E1FF001001FF001007FFC01000100488844448444
+3DBC:10201040108815045BFE5082508091FC1220102013FE28202450448841048602
+3DBD:100011FC11041504590451FC5020902013FE122212522A8A270A4202420A8204
+3DBE:00007FFC04403FF8244824483FF800007FFC010011101120228004401830E00E
+3DBF:1020102013FE102054205BFE5202940411F8101010202BFE2420442040A08040
+3DC0:08202AA42CA849201450228841047FF0041004100410FFD00412040A04060402
+3DC1:100011F8100810D0542059FC5124912411FC1124112429FC252445244124810C
+3DC2:00007E7C48047E4442287E1048287EC401001110111022A0044008203018C006
+3DC3:010011081108229004401830EFEE08000FE008000FE00800FFFE111014E0181C
+3DC4:100011FC1124152459FC5124512491FC102013FE107028A82524422240208020
+3DC5:7F00227C3E0422283E1023A8FE44020001001110111022A0044008203018C006
+3DC6:1020104011FC110455FC590051FC910411FC102010202BFE2420442040208020
+3DC7:204020403C4045FEA84010902090C89211523D5446908428282810442084C102
+3DC8:1020102013FE105054885924522291FC112411FC112429FC24224422401E8000
+3DC9:00043F84208420843FBE20042F8420243FD422142A442A845204450488941048
+3DCA:0820082008207EFC08201C301A702A6848A48922082008200000488844448444
+3DCB:102010A210A211245450588853049022102010A410A429282450448841048202
+3DCC:100011FC100414FC580451FC500093FE1222102011FC29242524453441288020
+3DCD:1020102010501488590452FA500091FC1154115411FC2954255445544104810C
+3DCE:100011FC110411FC550459FC508091FE122211221152290225FA440240148008
+3DCF:0640387C08907E1008FE1C102A10481001001110111022A0044008203018C006
+3DD0:1040119C1104110455DC5904510491FC1020102011FC28202420442043FE8000
+3DD1:010011081108229004401830E00E3FF804403FF824483FF801003FF80100FFFE
+3DD2:11FC1124112415FC5924512451FC9020102013FE12222A2A26FA420A42028206
+3DD3:1080108010FC15545AD450B4512C924410941108104028A426AA428A44788000
+3DD4:1008103C13C014445A2451285100927C12441244127C2A4426444244427C8244
+3DD5:221012101410FF92145214547F5855905510632841287F28414841447F844102
+3DD6:00007DFC444444447C44444444947C88110014FC588450849084288444FC8084
+3DD7:00002FBC28A42FA4283C2FA228A24F9E81001110111022A0044008203018C006
+3DD8:10401088110413FE540259FC5104910411FC102013FE287024A8452442228020
+3DD9:11081088109017FE580053C45254925413D4125412542BD426544244425482C8
+3DDA:1040102013FE100055FC590451FC900013FE120211FC28202420442040A08040
+3DDB:08000BF81208320853F8904017FE10E0115012481C4610400000488844448444
+3DDC:2080204027FE2090AA98B494A114A2302440204027FE204050A0491042088C06
+3DDD:1040102013FE12025488590452229028102413FE102028502450448841048202
+3DDE:200023FE220022FCAA84B2FCA284A2FC220022FC2208221053FE4C1044508820
+3DDF:10081210117C15445844507C57409140117E11421142297E25424280447E8000
+3DE0:0110092012E00C187104091012A00C60701C10103EFC4210149008FE3010C010
+3DE1:00007EFE42807EFC42847EFC42807EFE01001110111022A0044008203018C006
+3DE2:082004407FFC01003FF80200FFFE080037F0C0801FFC0100111022A00C60701C
+3DE3:1088105013FE102055FC582053FE900010A010FC1120282027FE442040208020
+3DE4:10001078FE4810487C480086FE0082FC7C44104412285428A810242844448182
+3DE5:100015F854105820902429A844B090A815285924522290A02840440081FC0000
+3DE6:0020FF2024A43CA424A83D20242024502F50F488050406020400488844448444
+3DE7:100011FE11101520597C5144517C9144117C1110111029542552429242508420
+3DE8:1020122213FE148059F852885070938E102011FC102029FC242043FE40208020
+3DE9:000027DC25042784249C2790251247CE0000010011101120228004401830E00E
+3DEA:10A0109011FE132055FC592051FC912011FE110013FC2888249E4502420A8404
+3DEB:08007F7808483E4800863E782A483E30404880840100111022A004401830E00E
+3DEC:1088108813FE1088540059FC510491FC110411FC10202BFE2450448841048202
+3DED:210013F0151000E0775C11F0104013FC284047FE0100111022A004401830E00E
+3DEE:1090109017FE109057FC5A9453FC929413FC100011F8290825F8450841F88108
+3DEF:1020102055FC584090F810402BFE4488912412227CF8102011FC1E20F0204020
+3DF0:1040102013FE140059545124515491FC102013FE12422A9226FA420A42028206
+3DF1:1010101022107F7C01103E1022103EFE22103E2022442AFE2442000024884244
+3DF2:21C8270821082FE8A91EB7CAA54AA7CA254A27CA210A27CA511249D24E2A8444
+3DF3:3FFE224824FE2D9036FC249024FC249024FE248020402248445040A083180C06
+3DF4:3FFE21042E3822102FBC27182AB432522000208024882890214042204C18B006
+3DF5:100011FC112415AC5974512451FC902011FC102013FE280026A4425244528000
+3DF6:111017FC21102FFE6100A3F826482BF8224823F8224822580000488844448444
+3DF7:100013DE125217DE5A10525251CE9000108813FE1088288827FE448841048202
+3DF8:100011FC110415FC590451FC500091FC10A813FE10A829FC242043FE40208020
+3DF9:108813FE10881020543E582051FC910411FC110411FC282027FE442040208020
+3DFA:20203E20443EA84446844228761042287E44010211101120228004401830E00E
+3DFB:1080108011FE13545554595453FE91541154115417FE28002554452A422A8000
+3DFC:0440FFFE0440044017D01012F7DC14503452D7D2100E0100111022A00C60701C
+3DFD:1088105013FE102055FC582053FE912410A813FE100029FC2504450441FC8104
+3DFE:2040207C204023FEAA42B278A3C4A23C220023FE224023A452584DB4445289B0
+3DFF:1020102010501488590452FA5000900011DC1154115429DC2488448841548222
+3E00:102013FE100014F8588850F8500093FE120212FA128A2AFA262641F8402083FE
+3E01:10501252115414505BFE5088505093FE102011FC10202BFE24A8412446228020
+3E02:011027FC1080034870B0136810A4132010402FFE4100111022A004401830E00E
+3E03:00107F1049106B1E5D1049107F7C08447F4408440F7CF0440000488844448444
+3E04:2040202023FE2088A852B7ACA2AAA2A825AC2000210421FC510449FC41048204
+3E05:2210221023DE2528A884B000A7BCA4A427A424A427A4243455284EA044208020
+3E06:112011FC122017FE580051FC510491FC105013DE105029DC245043DE40508050
+3E07:108811DC108813DE54885954522291FC110411FC110429FC250445FC40888104
+3E08:081024483F7E64C8BF7E24483F7E24483F7E20400100111022A004401830E00E
+3E09:210827C8AAAAB12CAFE8210857D44912892200000100111022A004401830E00E
+3E0A:2108210827CE2112A924B7DEA552A55E27D2211E2392255E5940491441128122
+3E0B:203C21E03D2444A8A9FE50A82124420291FC5524552459FC9124292425FC4504
+3E0C:11FC102013FE122255AC582051AC909011FE132015FC292025FC452041FE8100
+3E0D:210821EC210A27E8AD28B5DEA728A4EA240A27EA240C27EC5A2A4BEA515687E2
+3E0E:13FC110811F8150859F8510E57F8900817FE1294139C2A94279C42D647BC8084
+3E0F:00803FFE24103F7C26382D5435322F3C2120273821202F3C248849504630B80E
+3E10:2850FE4828FE399012907CFE54907C9010FE7C901090FEFE2880440024884244
+3E11:2FEC48246BAC48246BAC4AA4FFFE88227EFC2C684AA40100111022A00C60701C
+3E12:00FC7F00020821081110102000F83F0001000100FFFE0100010001003FF80000
+3E13:00FC7F0002082108111010203FF82008200820083FF82008200820083FF82008
+3E14:00F87F00211011101220FFFE040008001FF028104FF088100FF008100FF00810
+3E15:0228077E38482AFE2A482A7E2A482A7E2A40297E2922289C28624830480E8800
+3E16:000028F824884288408884F804884888288810F8188824882488408883FE0000
+3E17:084010202850448803001CE0E01E3FF820082FE8200827C8244827C820282010
+3E18:084010202850448803001CE0E01E1FF012901FF000007FFC0100010005000200
+3E19:084010202850448803001CE0E21E1FD00220FFFE03000FF03810CFF008100FF0
+3E1A:0008848844502820105028884500840800880488445028501020285044888506
+3E1B:040025FC2444244424443C4404940488FD0024FC248424842484448444FC8484
+3E1C:04202410241025FE25023E5404880504FC0024FC242024202420442045FE8400
+3E1D:044024402440247C24443E8820A021203C202450245024482488448445048602
+3E1E:041024902490249024903EFE208020803C8024F8248824882488448844888508
+3E1F:04802484249824E024823E82207E20003CFC2484248424FC2484448444FC8484
+3E20:0890489048904A9249947C98409041987A944C9248904890491249124A128C0E
+3E21:08204920492049FC49207E20402043FE787048A848A8492449244A2248208820
+3E22:0844484449FE484448447DFE404040FE79924AFE489248FE4892489248928886
+3E23:08504A52495448504BFE7C88405043FE782049FC48204BFE48A849244E228820
+3E24:409022882288FABE028053D42208FA3E23882288729C22882288448844888888
+3E25:09F04A104FFC4A044BFC7E2443B8422279FE4A104FFC4A444BFC48D0494A8E3E
+3E26:00003FF800801080108020803FFC0080108008800680018000F0008E02800100
+3E27:00007EFC0484248424FC248444847EFC0C92149214942488448884A414C20880
+3E28:08040804488448847E844884888408840E8CF89448E408840804080408040804
+3E29:080008FC482048207E204820882009FE0E20F820482008200820082008200820
+3E2A:11041124512451247D245124912411241D24F124512411241124122412041404
+3E2B:0804080E48F048807E80488088FE08880E88F888488808880888090809080A08
+3E2C:10201020502053FE7C20502091FC11241D24F124512411341128102010201020
+3E2D:1000100051FC51247D245124912411241DFCF100510011001102110210FE1000
+3E2E:10101090509050887D085104920415FA1C88F088508810881108110812281410
+3E2F:08080888484848487E084888884808480E08F80E49F808080808080808080808
+3E30:10201010501051FE7D025204908010881C90F0A050C0108210821082107E1000
+3E31:1080108050FE51007A205120912C11741BA43124D13411281122110210FE1000
+3E32:084008404840487E7EA048A08920083C0E20F8204820083E0820082008200820
+3E33:10201020505050507C885124921210101DFCF004500810881050102010101010
+3E34:0000FFFE040008001FF02810C8100FF0010011001FF821000100FFFE01000100
+3E35:10201020502053FE7C20502091FC10001C00F1FC510411041104110411FC1104
+3E36:100011FC510451247D24512491FC11241D24F154514C118C1104110411FC1104
+3E37:080008007F7C08243E2408447F540888090011001FF821000100FFFE01000100
+3E38:1008101C51E051007D0051FE910011001D7CF144514411441144127C12441400
+3E39:1004101E51E050227D125094908010081DFEF008508810481048100810281010
+3E3A:1020082040A824A4092A723010C01700010011001FF821000100FFFE01000100
+3E3B:10201040508851047DFE5002908010FC1D20F02053FE10201050108811041202
+3E3C:1040104050FC50887D50502090D813261CF8F02050F8102013FE102010201020
+3E3D:080008FC488448847EFC4884888408FC0E84F88448FC08000848084408820902
+3E3E:100013FC5044514479445284909411081A403020D0A41282128A128A14781000
+3E3F:1020102053FE50207DFC500093FE12021C04F0F050901090109011121112120E
+3E40:1020102053FE5020782053FE9202140419F83010D02013FE1020102010A01040
+3E41:1040102053FE50007C0051FC910411041DFCF020512811241222142210A01040
+3E42:00007EFC48447E4442287E1048287EC6010011001FF821000100FFFE01000100
+3E43:044004407C7C04403C7804407C7C0440054011001FF821000100FFFE01000100
+3E44:100011FC512451FC7D2451FC908811441E42F0F8518812501020105011881606
+3E45:1080108050FC51547AD450B4912C124418943108D04010A412AA128A14781000
+3E46:100013FE522250207DFE502091FC11241DFCF12451FC102013FE102010201020
+3E47:100011FC510451FC7D0451FC908011FE1E22F1225152110211FA100210141008
+3E48:082008207E7E08C4FF281C102A2848C6010011001FF821000100FFFE01000100
+3E49:100011FE511051207D7C5144917C11441D7CF110511011541152129212501420
+3E4A:1040104053FE52A27C9051FE912013201DFCF120512011FC1120112011FE1100
+3E4B:1120113C514452A87A1056A89AC612801A8832B0D28412881232120412181260
+3E4C:1040102053FC50007D08509093FE12201EA0F2FC5320122012FC1420142019FE
+3E4D:1040102053FE50887C5053FE922212FA1E22F2FA528A128A12FA1202120A1204
+3E4E:100011FC512451FC7D2451FC904010881DF0F020504413FE1022112412221060
+3E4F:1088108853FE50887CF8502091FC11241DFCF02053FE102011FC102013FE1000
+3E50:11102110CAA814443240D27C154014FE090011001FF821000100FFFE01000100
+3E51:101417FE501053D0781053D0901013D01A5033D0D25013C8124A13CA11861242
+3E52:10501252515450507BFE5088905013FE182031FCD02013FE1050108811041602
+3E53:1020102051FC50207BFE5108939C11081988363ED00013FE109010901112120E
+3E54:100013FE500051FC7D2451FC912413FE1C00F1FC512411FC112411FC100013FE
+3E55:7DFE002000FCFE8428FC288428FC4A844CFC884811841FF82100FFFE01000100
+3E56:1020112450A851FC784053FE908811041AFA3040D1A4105811B4105213901030
+3E57:102013FE502051FC7C0053FE900211FC1C20F3FE500013FE100413BE12A4138C
+3E58:100011FC502053FE7E2251AC902011AC1C00F3FE502011FC115411541154110C
+3E59:108812AA52DC54887954522293FE12021DFC3104D1FC110411FC110411FC1104
+3E5A:108812AA52DC54887954522293FE120218F83088D0F8100011FC110411FC1104
+3E5B:200027FEA040A2EEFAAAABEAAAAE2AE83BAAECE6228825F42290206021982606
+3E5C:08200A280924092408207EFE0820082008501450125012882088210442048402
+3E5D:0004441E29F0111029104910891009FE1910291049108908090A094A51862102
+3E5E:0008441C29E011002900490089FE0910191029104910891009100A1052102410
+3E5F:00404440284013F828484848884808481FFE284048A088A00910091052082406
+3E60:00204420282013FE2820492489240924192429FC4824882008220822501E2000
+3E61:00404420282013FE28404840888809081BF028204840888809040BFC51042000
+3E62:02008A005200221E57D292521252125232525252925212521452145EA9525080
+3E63:0080888050F82108531094A0104010A033185C0690C0102010101180A0604010
+3E64:00204420282011FC2820482088200BFE182028404840888809040BFE51022000
+3E65:00404420280013FE282048208820082019FC2820482088200820082053FE2000
+3E66:00008BFC508420845084910411141208340051FC9104110411041104A1FC4104
+3E67:00204420282011FC292449248924092419242BFE482088500850088851042202
+3E68:002044202820102029FC492489240924192429FC492489240924092451FC2104
+3E69:000045FC2884108828504820885008881B26282049FC88200820082053FE2000
+3E6A:000097BC54A424A454A494A414A41FFE34A454A494A414A414A415A4A8545088
+3E6B:002044202BFE102029FC482489FC092019FE2822482A88540850088851042202
+3E6C:004088405FFE2040504097FC1444144437FC50409240114010801140A2304C0E
+3E6D:0020442029FC1124292449FC8924092419FC282048248818083208CA53062002
+3E6E:000045FE28201020284049FC89040904190429FC490489040904090451FC2104
+3E6F:009044902890111029FE4B108D10093819382954495489920910091051102110
+3E70:004044442A441148295048408FFE0890189028904890889209120912520E2400
+3E71:000045FC29041104290449FC882008201920293C492089200AA00A60543E2800
+3E72:0020442229FA102428244BFE8810082019FC288849108AFE0C10081050502020
+3E73:000047FE2840104029FC488488840BFE1800280049FC89040904090451FC2104
+3E74:000045FE2820102029FC4924892409FC1924292449FC892008A0084050B0230E
+3E75:000045FE2800109229244A4889240892180029FE482088200820082053FE2000
+3E76:0000880653B8208850889108113E1388308852889288113E11001280A47E4800
+3E77:4210241418122412521010FEFF10201028107E28AA282A282A442E4408840902
+3E78:0020444029FC1104290449FC8904090419FC28504850885008920892510E2200
+3E79:0040882053FE222052FC9224122413FE3224522492FC122012501450A4884906
+3E7A:002044222BB410A828A849248AA2084019FC2904490489FC0904090451FC2104
+3E7B:001C45E0282010202BFE48A889240A4218402BFE4888890808D0083050482184
+3E7C:0080448028FE11022A424A4A895208421BFE284248E289520A4A084250542008
+3E7D:00504448285E13E42828483288CA0F0618502848485E8BE40828083250CA2706
+3E7E:0110891053D8225454529A90111012FE3C00500093F8120812081208A3F84208
+3E7F:00204420283E102029FC490489FC090419FC292448208BFE0820082050202020
+3E80:0080448028FC11542A5448A489240A4418942908484088A40AAA0A8A54782000
+3E81:009245242A4811242892484088800BFE1A022A8A4A528A220A520A8A53FE2202
+3E82:00148812501027FE5410941015D01412341255D49554154815DA142AA8465082
+3E83:008844882BFE1088290049FC89040A0419F42914491489F40914080450282010
+3E84:004044A0291012082DF648008BC40A541A542BD44A548A540BD40A44525422C8
+3E85:0080888051FC220454089BFE1200128032FC5320922013FE14201450A8885306
+3E86:02104510287E1310292849A88944080019FC2904492489240924085050882304
+3E87:001090145FD229126910A97E2B902A906A90AB982928292829242FC4A0444082
+3E88:00204524292411FC28204BFE8800082019FC2924492489FC0820082453FE2102
+3E89:10001078FE4810487C480086FE0082FC7C4400441428FE281010282844448182
+3E8A:01044488280013FE2820482089FC082018202BFE484088240AA20A8A54882078
+3E8B:0120891052082486591093F81008100037BC508494A4129414A41084A2944108
+3E8C:011088A0500027FE50A093F810A817FE30A853F890A011B012A814A6A0A040A0
+3E8D:0040882053FE2202541491E01100110031FC5110911017FE10001090A1084204
+3E8E:002097FE542025FC542497FE142415FC342055FC952415FC152419FCA924512C
+3E8F:002045FC292413FE292449FC882009FC192429FC48408BFE088809D05070238C
+3E90:012446482924100029FC492489FC092419FC28204BFE887008A8092456222020
+3E91:0040448829FC11082A524BFE885009881E2628C04B1088640B88083050C02700
+3E92:000097BC508424A4529494A410501188362650C09310106413881030A0C04700
+3E93:002047FE282011FC28204BFE880009FC190429FC490489FC090409FC50882104
+3E94:000E8BF050442224510893F8120813FC320453FE920212AA12AA1502A4144808
+3E95:007897C05248215057FC91501248140633F85248924813F812481248A3F84208
+3E96:00089788508821106FDEA49424A427946494A794249424C827882C94A0A440C2
+3E97:000047DE2A5212522BDE480089FC092419FC292449FC88200BFE082050202020
+3E98:0090448829FE11102B104DFE8910091019FE2910491089FE09000AA452522452
+3E99:0080884057FE240251F8914817FE122833FC501093F81248124812A8A1104608
+3E9A:00109410527C201050FE9044162812FE3210527C921012FE12101210A5FE4800
+3E9B:03FC8A4053F8224053F8924013FC10043554500891101FFE11101110A2104410
+3E9C:00908BFC529423FC529493FC100013FC320052F8920013FE15201514A5484986
+3E9D:001097D0551027DE545097E8150417C4300053F892A812A812A812A8AFFE4000
+3E9E:01408A4C52642244534C926412A413AC32A452A497FE100011101108A2044404
+3E9F:000097BC508424A4529494A41120121037FC5A2093FC122013FC1220A3FE4200
+3EA0:008090405FFE29126208A5842E0E2A746A54AB542AD42A542A522D54B75C4084
+3EA1:000097FE544425986488A7DE248825DC66AAA48824202520253C2920A92057FE
+3EA2:07FC904057FE24425B5C9040175C112033FC56209BFC122013FC1220A3FE4200
+3EA3:010891EC510A27E86528A5DE272824EA640AA7EA240C27EC2A2A2BEAB15647E2
+3EA4:0148894C52AA200857FE91481368114A336A514C936C1148116A139AA0264042
+3EA5:01F08A1057FC220453FC922413B8122231FE521097FC124413FC10D0A14A463E
+3EA6:00449F445AAA2AEE6E44AAAA2AEE2E006A28AAAA2BAA2EEE3A282228A2484288
+3EA7:07BC94A457BC200057FC908013F8120833F8520893F81110120817BCA4A447BC
+3EA8:00200020FC201020102010407C4010401080108810841D04E3FE410200020000
+3EA9:00040004FE841084108410847C841084108C109410E41E84F004400400040004
+3EAA:00400040FE401040104010507C4810441044104010401E40F040404000400040
+3EAB:00080008FE081088108810887C8810881088108810881E08F008400800280010
+3EAC:000001F0FD101110111011107D9011501150111011101D12E2124212040E0800
+3EAD:000001FCFC041008101010207C2013FE1020102010201C20E020402000A00040
+3EAE:000001FCFC001000100013FE10407C40108010FC100410041C04E00440280010
+3EAF:00007FFC010001003FF801000100FFFE00000100FFFE0280044008203018C006
+3EB0:000003FEFC201020102011FC7D2411241124112411241D34E128402000200020
+3EB1:100017F82110613CA10422042414280820007FFC01003FF801200110FFFE0000
+3EB2:000001F8FC481048104810487C4811F81088108810881C88E088408803FE0000
+3EB3:00200020FE20103E102010207C2011FC1084108810481E50F020405001880606
+3EB4:00200028FE241024102011FE7C2010201020105010501E50F088408801040202
+3EB5:00800080FC8010FC1104110812407C40104010A010A011101D10E20844040802
+3EB6:00080088FE481048100810887C4810481008100E11F81E08F008400800080008
+3EB7:00200028FC24102011FC10207C70107010A810A811241D24E222402000200020
+3EB8:080009F011103190515091521112120E04007FFC01003FF801200110FFFE0000
+3EB9:00200020FC401088110413FE7C021088108813FE10881C88E108410802080408
+3EBA:000001FCFD041104110411FC11047D04110411FC110411041D04E10441FC0104
+3EBB:00200020FC2013FE102010207DFC11241124112411241D34E128402000200020
+3EBC:000003FEFC221024102010207D20113C1120112011201D20E2A04260043E0800
+3EBD:000001FEFC101010102010207C6810A41122122210201C20E020400003FE0000
+3EBE:000003FCFA042204220422F4FA9422942294229422F43A94E204420402140208
+3EBF:000001FEFD1011101110117C11447D4411441144117C11101D10E11041FE0000
+3EC0:00200020FBFE2222222223FE2222FA2223FE2020212038A0E04040A001180606
+3EC1:00000000FDFC1104110411747D5411541154115411741D04E10441FC01040000
+3EC2:01040084FC88100013FE10887C881088108817FE10881C88E108410802080408
+3EC3:044004403FF824483FF824483FF800007FFC010001003FF801200110FFFE0000
+3EC4:0008003CFDC01000100013FE7C2010201120113C11201D20E2A04260043E0800
+3EC5:00200020FC5010881104120210F87C00100013FE102010401C88E10443FE0102
+3EC6:00400080F908220427FE20022000FBFC220423FC220423FC3A04E20402140208
+3EC7:00200020FC501088110412027DFC10201020102011FC1C20E020402003FE0000
+3EC8:0008001CFDE01100110011FE7D001100117C114411441D44E144427C02440400
+3EC9:00200020F920213C2120212027FEF8002020212421243A28E410402000C00700
+3ECA:00800080FCF81108121011FC11247D24112411FC105010501C90E0924112020E
+3ECB:00200020FDFE1020102011FC7D24112411FC102010701CA8E124422200200020
+3ECC:00200020FC501088110412FA7C20102013FE102011281D24E222442200A00040
+3ECD:000001FCFD04110411FC10007C0011FC1020102013FE1C20E050408801040202
+3ECE:010001007FFC0100FD7C111011107D7C11101D10E2FE4280044008203018C006
+3ECF:000001FCFC04100410FC10047C0411FC102010A410A41D28E050408801040202
+3ED0:00400040FC88110413FE100210887D44124210F8118812501C20E05041880606
+3ED1:001C00E0FC2011FE107010A87D24122210F8101010201DFEE020402000A00040
+3ED2:000003FEFA02221A22E222222222FBFE2222227222AA3B26E222422203FE0202
+3ED3:000007E0FA5E2252225223D22252FA5423D4225422483AE8E754405400620040
+3ED4:0008003CFDE0102013FE10A810A87CA813FE10A810A813FE1C20E02041FC0000
+3ED5:000003FEFA02220223FE22102292FA92229222FE22103A92E292449204FE0802
+3ED6:00400040FBF82048204827FE2048F84823F8244422E83950E248444601400080
+3ED7:044004407C7C04403C7804407C7C044004407FFC01003FF801200110FFFE0000
+3ED8:00400020FBFE2222202021FC2124F92421FC2124212439FCE124402000200020
+3ED9:00400020FBFE2080210423FEF80221FC210421FC210439FCE104410401140108
+3EDA:000003DEFA522252225223DE2252FA52225223DE22523A52E2524252055208A6
+3EDB:000001F8FD08110811F811087D0811F8108011FC12541C94E124424400940108
+3EDC:00880088F8882088215422222442F82020202120213C3920E2A04260043E0800
+3EDD:00820082FBE22082208A23EA22AAFAAA23EA208A21CA3AAAE4A24082008A0084
+3EDE:00400020FBFE2202220223FE2200FA0023FE235225523DFEE552455209520106
+3EDF:00400040FBFE208021FC222025FEF80021FC210421FC210439FCE10401140108
+3EE0:00400020FBFE220220882104FA222028202423FE20203850E050408801040202
+3EE1:00480148FD4813FE114811487D78110011FE102013FE1C70E0A8412406220020
+3EE2:02100110F91027BE2228224823AAFAAE22BA22EA22AE3AA8E4AA44A209A2101E
+3EE3:00880088FBFE208820F8208820F8F888208823FE21003948E184410001FE0000
+3EE4:00880088FBFE2088210021FC2104FA0421F42114211439F4E114400400280010
+3EE5:00880048FC5013FE105010507DFC11541154118C11041DFCE104410401FC0104
+3EE6:01FC0124FD2411FC112411247DFC1020102013FE12221E2AE2FA420A02020206
+3EE7:01040104F9DE22442554209E2104FA24242423FE207038A8E124462200200020
+3EE8:00007EFC48447E5443287E9048287EC600007FFC01003FF801200110FFFE0000
+3EE9:011000A0F80027FE20A023F8F8A827FE20A823F820A039B0E2A84CA600A000A0
+3EEA:00A00090FDFE132015FC11207DFC112011FE110013FC1C88E09E4102020A0404
+3EEB:000001FCFD2411FC112411FC7CA810A813FE10A810A81DFCE02043FE00200020
+3EEC:01FC0020FBFE222221AC2020F9AC200021FC200023FE3880E0FC400400280010
+3EED:00400020FBFE2020204822F2F924225220F8200820203BFEE020402000200020
+3EEE:01000110FBDC225425542288F90822F42402200023FC3840E150424805440080
+3EEF:0040007CF84023FE22422278FBC4223C220822F023243AA8E5FE442008A00040
+3EF0:008803DEFC8811DC108813DE7C88100013FC100410041DFCE004400403FC0004
+3EF1:0020047CFA842148203020CE2610FA7C2210227C22103AFEE210421005FE0800
+3EF2:002001FCFD2413FE112411FC7C2011FC112411FC10401DFEE08841D00070038C
+3EF3:00880088FBFE2088204220E2FB82208A208A27EA218A39CAE2AA4482008A0084
+3EF4:000001F8FD0811F8110811F87C0013FC129413FC10001DF8E090406001980606
+3EF5:03FE0202FBFE220022FC220823FEFA10223023CE22423A84E4EE47840884018C
+3EF6:010801EEFA942042202021FC2024FBFE202421FC202039FEE02043FE00200020
+3EF7:02080208EFBE420842084FBE4AAAEAAA4AAA4BAE4208671CCAAA124802080208
+3EF8:000007BCF908252827BC231825AAF946200023F822083A08E3F84208020803F8
+3EF9:FDFC104021A27C54A5B824543D92246000007FFC01003FF801200110FFFE0000
+3EFA:3FFE21042E3822102FBC27182AB4325220002FFC208027F820A040905FFE8000
+3EFB:01080088FBC8201023DE226423D4F81423D42054209438E8E388409402940122
+3EFC:000003FEFC5013FE125213FE7C0011FC110411FC11041DFCE02043FE00200020
+3EFD:00A00090FDFE132011FC11207DFC112011FE110013DE1E52E252427202020206
+3EFE:0100FFFE104824FE799010FC22907CFC089030FEC0807FFC01003FF80120FFFE
+3EFF:000003F8FAA822A823F82100FBFC248423E422A422A43BE4E09447F400140008
+3F00:00100410FA7C201020FE20442628FAFE2210227C22103AFEE210421005FE0800
+3F01:01040088FBFE202021FC2020FBFE20542192209023FE3890E0D4438A009601A2
+3F02:0A0033B822083BB820883AB82288FFFE80027FFC01003FF801200110FFFE0000
+3F03:01240248F924200023FC22942264FA9423FC224823683A48E36A424A02460362
+3F04:01240124FAAA23AE212422AAFBAE202427FE201027D43D54E7CA454A07D60022
+3F05:00200010FBFE224422FE224423FEFA1022FE229222FE3A92E2FE420002440482
+3F06:008802AAFADC24882154222227FEFC0221F82040204039F8E050404803FE0000
+3F07:00200222FBFE209021FE231025FEF91021FE211021FE21003BDEE25202720206
+3F08:000007FCF4A424A427FC221022A8F4BE2F68223C24A82FBC3028CAA80ABE0020
+3F09:0210071038102A7C2A542A542A102A282A282948294A288628404A304D0E8900
+3F0A:1008101C10E8FEA810A854A854A854A854A87CA410A410A414A2192811340224
+3F0B:1008101C10E810A8FEA810A810A810A87CA844A444A444A444A27D2845340224
+3F0C:08081C1C70E850A850A850A858A854A854A854A450A450A458A255289D340624
+3F0D:1008101C10E8FEA810A87CA810A8FEA830A838A454A454A490A2112811341224
+3F0E:0220071038102AFE2A002A442A822A282A1029282944288428404A304D0E8900
+3F0F:04081E1CE0E822A892A854A848A810A8FCA824A444A428A410A2292845348224
+3F10:0804040E7F74415441547F5440547F54555455527F52555255505594819A0312
+3F11:1008101CFEE810A8FEA892A8D6A8BAA892A8FEA410A438A454A2932811341224
+3F12:027C0744387C2A442A7C2A002AFE2A402A7E29AA295228AA28444A304D0E8900
+3F13:08881C50700053FE505051FC585457FE545455FC505050D8595456529C500450
+3F14:0008001C7CE844A87CA844A87CA800A87CA854A454A454A456A2F92801340224
+3F15:1008921C54E8FEA882A87CA844A87CA800A87CA454A47CA454A255287D344624
+3F16:11F03A10E3E0A020A7FCA188B650A9A8AE64A9A0A248AFBEBAAAAFBE3A8A0FBE
+3F17:000001FCFE801080108010F81088108811481128112811081108114A518A2106
+3F18:100011FC10801080548054F8548854885548552855285D086508014A018A0106
+3F19:100010FC1040FE40924092789248924892A892989A88948810AA10CA108A1006
+3F1A:100008FC0840FF40004000783C48244824A824982488258846AA44CA808A0006
+3F1B:00007EFC24402440244024782448FF4824A824982488248824AA24CA448A8406
+3F1C:01001FF011101110FFFE02801C70E00E00007FFC08000FE0092010A41624181C
+3F1D:10001EF8228862A894920882307EC00000007FFC08000FE0092010A41624181C
+3F1E:00007EFC084008404A402A782C480848FFA808980888088808AA08CA088A0806
+3F1F:100010FC20407E4042404278424842487EA842984288428842AA7ECA428A0006
+3F20:100008FC08407F4041408278204820483EA820982088208826AA38CA208A0006
+3F21:080028FC28403E404840887808487F4818A81C982A882A8848AA88CA088A0806
+3F22:0000FEFC904090409040BC78A448A448A4A8A498BC88908890AA90CAFE8A0006
+3F23:0000FEFC1040104020407C784448444844A87C984488448844AA7CCA448A0006
+3F24:080008007F7C08243E2408447F54088800007FFC08000FE0092010A41624181C
+3F25:100012FC7A4014401440FF78104820487EA8909820883C8804AA04CA148A0806
+3F26:00007DF01110119011521D12E20E440000007FFC08000FE0092010A41624181C
+3F27:0000FCFC044068401040FE7892489248FEA892989288FE8892AA92CA928A8606
+3F28:080008FC14402240514088787E48024804A808987E88428842AA7ECA428A0006
+3F29:0400057C04A07F2044204438742855285558564856485448655A4D6A934A0106
+3F2A:080008FC7F40084008402A782A482A485DA888980888148814AA22CA428A8006
+3F2B:00007EFC4A404A407E404A784A487E4808A8FF9818882C882AAA4ACA888A0806
+3F2C:100010FC7C4010401040FE78444828487CA810981088FE8810AA10CA108A1006
+3F2D:1020103E7C2011FC11041D04E1FC010400007FFC08000FE0092010A41624181C
+3F2E:100010FCFE4010407C401478FE4814487CA81098FC88248844AA28CA308AC806
+3F2F:0800087CFFA0082008207F3849287F2849587F4808481C482A5A496A884A0806
+3F30:0800107C7F20492049207F38492849287F5814482448FF48045A046A044A0406
+3F31:04447C5804621C42E43E00007FFC482410107FFC08000FE0092010A41624181C
+3F32:0000FEFC10402040FE40AA78AA48AA48A2A896981088FE8810AA28CA448A8206
+3F33:100010FC52405140954008783048C0487EA842987E8842887EAA42CA7E8A4206
+3F34:00007CFC544054407C40547854487C4810A8FE9892889688BEAA82CA8A8A8406
+3F35:00003EFC22203E2022383E280048FF680858084A2F4A286A284658004FFE8000
+3F36:100010FC2840444082407C780048E248AAA8AA98EA88AA88AAAAE2CAAA8AA406
+3F37:100092FC92409240FE400078FE48104820A8FE98AA88AA88AAAAAACAAA8A8606
+3F38:1000087CFFA080A0142022384928142822584148BEC82248225A226A3E4A2206
+3F39:440044FCFF4054400840FF78404840487EA800985488548855AA56CA948A0006
+3F3A:100008FC7F4048405E404A787F484A485EA848985E88528852AA52CA5E8A9206
+3F3B:11102110CAA814443240D27C154014FE08007FFC08000FE0092010A41624181C
+3F3C:0000FEFC2840FE40AA40AA78FE4800487CA80098FE88108854AA92CA508A2006
+3F3D:100010FCFE401040BA405478BA481048BAA85498BA88108828AA24CA428A8006
+3F3E:0800047C7FA0522052207FB852A852A87FD8524852485BC8525A52EA9B4A1206
+3F3F:1000087C7F202220FF2000387F2849287F5849487F4808487F5A086A0F4AF006
+3F40:2200147CFF2014207F20553863285D2841587F480848FF48145A226A414A8006
+3F41:3FFE21042E3822102FBC27182AB4325220003FFE240027F0249048524B128C0E
+3F42:0800147C22205D2080A03E3822283E280058774811485548335A556A114A3306
+3F43:0E00F0FC92405440FE403878544882487CA8549854887C8854AA54CA7C8A4406
+3F44:240CFF7024403C40247E3C482448FF482448428800007FFC08000FE011241C9C
+3F45:0A0074FC15405240224021785D4880487EA8429842887E8842AA24CA0F8AF006
+3F46:100092FC5440FE4082407C7844487C4800A87C9854887C8854AA54CA7C8A4406
+3F47:0A803138228838382288393822887FFE4002BFF408000FE0092010A41624181C
+3F48:48F8705044203DFC20247CB890A07D7E2A007FFC08000FE0092010A41624181C
+3F49:00007E40487E7E9043087EFE48AA7EFE00007FFC08000FE0092010A41624181C
+3F4A:49005D7C6120DDA043205D3841285D28B6D89C4800487F48025A346A1C4A6306
+3F4B:210447C88812F3BC20084B92F83E0380AAAAABAA00007FFC08000FE011241C9C
+3F4C:7F00087CFFA088A06B2010386F28452855586B4810487F48495A7F6A494A7F06
+3F4D:220022FC22402240FF402278224822483EA822982288228822AA3ECA228A0006
+3F4E:22102210FF1022103EFE22923E9222102228FF28402854286248404A7E8A0106
+3F4F:204010A083184DF61000E3F8220823F800001010FFFE10101FF010101FF01010
+3F50:48884850480049FEFC5049FC48544BFE485479FC485048D849547A5248500050
+3F51:4BFE48504BFE4A52FE524BFE480049FC790449FC490449FC48207BFE48200020
+3F52:00107C10549054907CFC549055107C101010FEFC12101210221022104AFE8400
+3F53:010011001FF821005FF00100FFFE081048507E7C489088107E7C08100F10F0FE
+3F54:28102810AA506C7C2850FE901010307C4A109C102C10DAFE2900C8C0283E1000
+3F55:010001003FF821083FF821083FF800007FF8000810081FFE0002000200140008
+3F56:004000407C40544055FC544454447C4454445484548454847D04450402280410
+3F57:002000207C2054205420542054207C2054505450545054887C88450402040402
+3F58:004000207C0055FC5400540054F07C9054905490549054927C924512010E0200
+3F59:004000407C805488550457FE54027C9054905490549054907D124512020E0400
+3F5A:00003FF8210821083FF8210821083FF8000011003FF841000100FFFE01000100
+3F5B:008000807D0055FC5604540455E47D245524552455E455247C04440400280010
+3F5C:10001EF8228862A894920882307EC0003FF8210821083FF8210821083FF82008
+3F5D:7F0408441E44224454440844300CC0001FF0111011101FF0111011101FF01010
+3F5E:00003EF82288228822883EF8000000003FF8210821083FF8210821083FF82008
+3F5F:0004001E7DE054225512549454807C0855FE5408548854487C48440800280010
+3F60:002000207C2057FE5420542055247D24552456AA542054507C50448801040202
+3F61:00400080F9FCA924A924A9FCF924A944A9FCA890A910FBFE8810001000100010
+3F62:00400080FBFCA910AA48AC46FBF8AA48AA48ABF8AA48FA488BF800420042003E
+3F63:00140012F810AFFEA810A810FBD2AA52AA52AA54ABD4F80888EA071A02260042
+3F64:008000807CFE5502562254AA54727C2255FE5422547254AA7D224422000A0004
+3F65:000000FC7C48543055FE545254947D105630542055FE54707CA8452402220020
+3F66:08202AA44D28145022887FFE400280043FF8210821083FF8210821083FF82008
+3F67:00840044F848ABFEA884A884F908A94AAA52AB9CA884F9088908025203DE0042
+3F68:01080088F890ABFCA840A9F8F840ABFEA880A900A9FCFA208C20082003FE0000
+3F69:00400088F9FCA908AA52ABFEF850A988AE26A8C0AB10F8648B88003000C00700
+3F6A:01040088F800ABFEAA22AAAAFA72AA22ABFEA800A9FCF90489FC010401FC0104
+3F6B:0100FFFE104824FE799010FC22907CFC089030FEC0803FF821083FF821083FF8
+3F6C:0000FEFE00007C7C444444447C7C0000FEFE92929292FEFE92929292FEFE8282
+3F6D:000001FCF820ABFEAA22A9ACF820A9ACA800ABFEA820F9FC895401540154010C
+3F6E:0FE009200FE009200FE07C7C54547C7C54547D7C11001FF821005FF00100FFFE
+3F6F:022203FEF890A9FEAB10ADFEF910A9FEA910A9FEA900FBFE8A8A037602520276
+3F70:0000777C55145514551077105550555C55507750555055505550B55089BE1300
+3F71:008000401FFE1000900852085208120832085208923813C82208200840088008
+3F72:008000401FFE1000900057FE50801100320053F8900810082008200840508020
+3F73:008000401FFE1000900057FC5040104030405FFE904010402040204041408080
+3F74:008000401FFE10009010501057FE101030105210912010A0204020A043188C06
+3F75:008000401FFE1000904050405040104037FC504090401040204020404FFE8000
+3F76:008000401FFE1000900053F850081008300853F8920012022202220241FE8000
+3F77:008000401FFE1040904050445768117031605150925012482444284241408080
+3F78:008000401FFE10009040504053FC1244344850A090A01120212022224422881E
+3F79:008000401FFE1000901C53E05200120033F85288928812502420245048889306
+3F7A:008000401FFE100097F8510851101120313C5204928812502420245048889306
+3F7B:008000401FFE1040904057FC5040104037F85208911010A0204020A043188C06
+3F7C:008000401FFE1000900457E45024102433E45204940417E42024202441448084
+3F7D:008000401FFE10409040504057FE1040304053F8920812082208220843F88208
+3F7E:008000401FFE1000904052485248124833F85048904014442444244447FC8004
+3F7F:008000401FFE1000901C53E052901290329052909290128824C824A448D49092
+3F80:010000803FFE20002080A0806FFC208020806080BFFE2100221044084FFC8404
+3F81:008000401FFE104090505048504017FC30E05160915012482444284240408040
+3F82:008000401FFE108090805110520817FC3204500093F812082208220843F88208
+3F83:008000401FFE1080904057FC54041808320052109260138022002204420481FC
+3F84:008000401FFE10009040504057FC14443444544497FC14442444244447FC8404
+3F85:008000401FFE1040905C53E05240124033FC504490C4115422482C4040408040
+3F86:008000401FFE1040904053F85248124833F8524892481FFE2208220842288210
+3F87:010000803FFE20002000A7F86408240827F86408A40827F82408440847F88408
+3F88:008000401FFE100091085108510812FE320856489A2812282208220842288210
+3F89:008000401FFE1040904050A0511012483426502093F81008211020A040408020
+3F8A:010000803FFE20402040AFFE604027FC24446454A4E8215022484C4640408040
+3F8B:008000401FFE11109110521052FE16103A385238925412542292221042108210
+3F8C:008000401FFE10009040524053FC144030405FFE91201120212022224422981E
+3F8D:008000401FFE100090005FFE5040108037FC54A494A414A424A424A444948408
+3F8E:008000401FFE1000900057BC54A414A434A454A494E414042404240447FC8404
+3F8F:008000401FFE1000904057FC504010403FFE5000904017FC204020405FFE8000
+3F90:008000401FFE100090045FC45214121437D454549A5411942084210442148C08
+3F91:008000401FFE104090A0511052081DF63000500093F812082208220843F88208
+3F92:008000401FFE11009100511E5FD2125232525452949212922112229E44528840
+3F93:008000401FFE100093F0521053F0100037F8540897F8140827F8240844288410
+3F94:008000401FFE1000900053F85208120833F8500097FC14042404240447FC8404
+3F95:008000401FFE1080904057FC520811103FFE5040904017FC2040204040408040
+3F96:008000401FFE1000900057FC544417FC344457FC904017FC204020404FFE8000
+3F97:008000401FFE1100908057F8540817F8340857F8948214442428251046088406
+3F98:008000401FFE100097FC504053F8124833F8524893F812402140208043608C1E
+3F99:008000401FFE1010972050C0513016883FFE5100924017F82A48226842508040
+3F9A:008000401FFE1120912455E85530152235A25E1E900013F8200020004FFE8000
+3F9B:008000401FFE100093F8500851F8100833F8500097FC140423F8211040E0871C
+3F9C:008000401FFE10009040504057FC1040324852489554184220A0211046089806
+3F9D:010000803FFE20803FFCA0806FF828882FF86888AFF820803FFE408040808080
+3F9E:010000803FFE20002FFCA1206FFC292429246A1CAC042FFC280448044FFC8804
+3F9F:008000401FFE10009040527C524012403FFE5040914412482410206043809C00
+3FA0:008000401FFE10009880557C52101D103110517C93101D10211021104A7E8400
+3FA1:008000401FFE1100911E57D2511211123FF251129292145A2FD4245040108010
+3FA2:008000401FFE104090405FFE504012483248555498E2115022482C4640408040
+3FA3:00803FFE20802140A2206410280837F66080A0802FF82080249042A05FFE8000
+3FA4:008000401FFE1080904057FC540411103208540493F810402040204047FC8000
+3FA5:008000401FFE1000920053BC521412143FD45014920816882A4822144A148422
+3FA6:008000401FFE1080904057FC520811103FFE500093F812082208220843F88208
+3FA7:008000401FFE100093F8524853F8124833F8504097FC10E0215022484C468040
+3FA8:010000803FFE20802FF8A140622024103FFE6010A7D0245027D0401040508020
+3FA9:008000401FFE1000903853C050401FFE31505154975811542354254C40408040
+3FAA:008000401FFE104092485454586213803FF8520893F8120823F8220843F88208
+3FAB:008000401FFE104093FC5204520413FC320053FC9354155425FC29544144810C
+3FAC:008000401FFE1000942457A854321522361E510093FC120423FC220443FC8204
+3FAD:010000803FFE20002310AE10625422543F586690A6102B282A28524442448282
+3FAE:008000401FFE1040908053F8520813F8320853F8900017FC204023FC40408FFE
+3FAF:008000401FFE100093F8524853F8124833F8500097FE12442228229043088206
+3FB0:010000803FFE2200223CA2246FA4223C22246FA4A8BC28A42FA448C440548088
+3FB1:010000803FFE20402F50A1246A1824083BF66120A1202FFC212042244424881C
+3FB2:010000803FFE22102F90A21E6FA422243FD46414A7942488248848944AA49142
+3FB3:010000803FFE288024FCA12464203850298C6100BFFE2210272040C043308C08
+3FB4:008000401FFE1040904057FC51501248344653F8920813F8220823F842088FFE
+3FB5:008000401FFE120091085FC850081788303E5788900817882488248847888488
+3FB6:00803FFE200023F8A20863C822482FFE6802B3FC220823F8220843F842088218
+3FB7:00803FFE2000203EAFC0687C28402BFE6A42AA782AC42A3C320054F06494890C
+3FB8:008000401FFE102097FE500051F8110831F8500097FE140225FA250A45FA8406
+3FB9:010000803FFE21202128A5B065242524259C6E40A04027FC20E0415042488C46
+3FBA:010000803FFE200027FCA44067F8244027F86440A7FC20042AA44AA450148008
+3FBB:008000401FFE1010972855445582167C3510551095FE15102754249245528420
+3FBC:010000803FFE200029F8A50865F821083DF86524A5182548258445044A0091FE
+3FBD:010000803FFE20402880A5F8610821082DF86500A5FC2504250445FC4A0091FE
+3FBE:008000401FFE120891105FFE512017FC31245FFE912417FC2330252859268120
+3FBF:010000803FFE22002100AFBE68A22FA428A86FA4AA2229222AAA4CA448208020
+3FC0:010000803FFE20202E2EA42464A424A424A46EAEA424242424444644588E8100
+3FC1:008000401FFE108093F8520853F8120833F8508097FC1210244829F640408040
+3FC2:008000401FFE11109550555057DE102437D45114911417D4210821084FD48022
+3FC3:008000401FFE12A892A857FC52AA14E6380057FC944413F82248224842588040
+3FC4:010000803FFE20002FDCAA146BD42D1629206FDCA9142A942C5448084FD48022
+3FC5:010000803FFE22102410A89C7090229025FE6C10B490249C24904550463E8400
+3FC6:00801FFE1000103893C0504017FC315052489486104017FC20A223144D488186
+3FC7:008000401FFE100097BC508454A4129434A4510093FC120423FC220443FC8204
+3FC8:010000803FFE22282224A57E69482E4822FE6548A9482F7E22484448487E9040
+3FC9:00803FFE204027FCA44467FC20403FFE6404A7FC240427FC240447FC42088404
+3FCA:00803FFE20002F78A2106A502F7C26306B54B28C27F8240827F8440847F88408
+3FCB:00801FFE100013F8920853F8100037BC54A497BC10401FFE215022484C468040
+3FCC:00803FFE20802140A22064103BEC20006F78A94829482F782220455048889104
+3FCD:010000803FFE2000287CAF1471242FCC2AA86FBEAAC82F882AFE4A885088A188
+3FCE:00801FFE104017FC91505FFE111037FC540497FC140417FC240427FC41108208
+3FCF:00803FFE200027F8A0886FFE210827F86310A4A02FFC304023F840404FFE8040
+3FD0:00803FFE2210223EAF4462A822103FA8625EA2222A542B082A104A605600A3FE
+3FD1:00803FFE20002FBEA492628A2492222067FEAC2037FE242027FE442047FE8400
+3FD2:00803FFE20402FFCA04067FC20003FFE6002A7F820403FFE20084F7E49488F18
+3FD3:00803FFE204027FCA2486248255428A26318ADF6211021F02240427C454088FE
+3FD4:010000803FFE200027FCA44467FC244427FC6000AFBE2AAA2FBE4AAA4FBE88A2
+3FD5:00803FFE20002F3CA9246F3C29242F3C69E4AA242C442B642A244B644A248BEC
+3FD6:00803FFE2040207CA04067FE244225F86444A4FC24A824F824A849FC495493FE
+3FD7:00803FFE20002300BCFE64103F7C2E44757CA4442E7C2A442A7C53285244A082
+3FD8:00803FFE22082AAAA248651428A22FFE6802A3F8220823F8200047FC440487FC
+3FD9:010000803FFE200023F8A2A863F820002FBE6AAAAFBE20402FFE40A043188C06
+3FDA:00803FFE20002FFEA9126FFE2228244469FEAF48227E25482F7E4048557E9540
+3FDB:00803FFE20002FBEA514671C25542FFE6920AFFC29242FFC2A244BB85222A39E
+3FDC:00803FFE210027F8A54864A827F8221067F8BD2E27F820002FFC49244FFC8924
+3FDD:040008003FF8200820083FF8200820083FF8020004000820101020087FFC2004
+3FDE:1008103C21E07C204420443C45E044207C20443E47E0442044227C224422001E
+3FDF:1020102020407CFC44844484448444847CFC44844484448444847C8444FC0084
+3FE0:1040104422447948495048404FFE48907890489048904892491279124A0E0400
+3FE1:020004001FF010101FF010101FF00000244814500C601450644808421042603E
+3FE2:00007CFC448444FC7C8444FC44847D14020808003FF820083FF820083FF82008
+3FE3:100013F822087BF84A084BF849004BFC7C444A444AA44A044BF4780448280010
+3FE4:1040104023FC784049F848804BFC49107A084DF64910491049F07910491001F0
+3FE5:1040104023FE7AA2489049FE49104B107DFE4910491049FE4910791049FE0100
+3FE6:08007F7808483E4800863E782A483E30404884861FF010101FF010101FF01010
+3FE7:102013FE202079FC48004BFE480249FC78204BFE48004BFE48047BBE4AA4038C
+3FE8:100013FE22227ACC4A444BEE4A444AEE7B544A444A104A104A5E7A504A5005FE
+3FE9:112410A823FE7A0248F848884BFE4AAA7A724BFE48204BFE48207FFE4AA40452
+3FEA:0820082008207F7849284A2848287EA84268422852584C48444A4A8A92862102
+3FEB:208020843E9820E42684387C00801FFC1084108817F01210212020C043301C0E
+3FEC:08000800087C7F5449544A5448547E54427C424052404C4044424A42923E2000
+3FED:0C107010401040FE40927E94489048FC58A448A44CA84AA84890492889440282
+3FEE:1010101010107CFE54925494549054FC54A4FEA410A810A82890252845448282
+3FEF:010006C01830EFEE00001FF010101FF001003FFC21042FE82420424041809E7C
+3FF0:201010100010FEFE00922894449082FC04A444A428A810A82890452885440282
+3FF1:100C11F0FD0011FE1D10F2101210341001003FFC21042FE82420424041809E7C
+3FF2:10101010FE1010FE28924494FE9004FC74A454A454A874A85490052815440A82
+3FF3:082A082A08547F54492A4A2A482A7E0042FE429252924CFE44924A9292FE2082
+3FF4:10101010FF1024FE429281947E9024FC3CA424A43CA824A82E90F52805440682
+3FF5:080008FE08107F2049FE4AAA48AA7EAA42A2429652104CFE44104A2892442082
+3FF6:20101010FE1000FE44922894FE90A2FC10A4FEA420A83CA82490452855448A82
+3FF7:441024102810FEFE10927C941090FEFC20A43EA448A848A88E90792821440282
+3FF8:087C0844087C7F44497C4A0048FE7EAA42FE420052FC4C4444284A1092682186
+3FF9:10101210117C7C1054FE504453287DFE4510657C591049FE5510951022FE0400
+3FFA:7F0841087F08417E7F4A224A7F48227CFFD422544954AAD41C482A8849141822
+3FFB:00001FF0010001000100FFFE0100010001003FF82448244824482448FFFE0000
+3FFC:00003FF808200820FFFE082010202020402000003FF8244824482448FFFE0000
+3FFD:0440082010102FE8C40608000FE00020014000803FF8244824482448FFFE0000
+3FFE:020001007FFE400280043FF001000100050002003FF8244824482448FFFE0000
+3FFF:00007FFC0104110011F81100290047FE80003FF82448244824482448FFFE0000
+4000:100009F841082508092811107102110210FE00003FF8244824482448FFFE0000
+4001:0200FFFE04000FF018102FF0C8100FF00810083000003FF824482448FFFE0000
+4002:01007FFC40040400FFFE08201E4003C03C3800003FF8244824482448FFFE0000
+4003:00007FFC02000D08719002A00CC071A006981A86E1003FF824482448FFFE0000
+4004:020001007FFE42028924284849940E1077F000003FF8244824482448FFFE0000
+4005:20201020FC2009FC102038205420902013FE100000003FF824482448FFFE0000
+4006:01003FF80108FFFE01083FF801007FFC0000110826D01830E00E3FF82448FFFE
+4007:1080108011FCFE20102011FC7C20452445247DFC00003FF824482448FFFE0000
+4008:7DFC44207D2045207DFE505048905512620E00003FF8244824482448FFFE0000
+4009:00701F800200FFFE082037D8C4463FF8200827C8244827D800003FF82448FFFE
+400A:27BC14A4929444A4404011B02E4EE390206023882070038000003FF82448FFFE
+400B:210021FE2220243EF82023FE22AA225223263A52E2AA43FE00003FF82448FFFE
+400C:01003FF80108FFFE01083FF801007D7C11107D7C44447C7C44447FFC2448FFFE
+400D:1040FEF82948FE3001CE7CF844207DFC44887CF81088FEF810503FF82448FFFE
+400E:000003FE7C40444044807C80450045FC7C044404440444047C04440400280010
+400F:100010001FFC200420045FE490241FE410241FE410241FE41024000400280010
+4010:00087E084210422042447E044208421042227E424204420442087E10422000C0
+4011:000001F87C8844C844A87CA8448844507C504450442044207C50448801040202
+4012:0008003C7DE0442044207C20442047FE7C204420442044207C20442000200020
+4013:004000407C40444045F87C48444844487D4844C8444844A87CAA450A02060402
+4014:000000007DFC444444447D44454445447D444644444444847C84450402280410
+4015:000403E478244824482479E4490449047A044BE4482448247824482401440084
+4016:000000007DFC442044207C20442047FE7C204420445044507C88448801040202
+4017:0040004078404BF848487848484848487BFE484048A048A07910491002080406
+4018:000003FC789048904890789048904FFE78904890489048907910491002100410
+4019:00000100797E49124912791249D24F12791249124952499279224822004A0084
+401A:1FF010101FF010101FF010101FF000000C0070FC408440844C84709440880080
+401B:01000100790049FC4AA47CA448A4492479244A444C44488479044A0404280010
+401C:080008001FF82248444808881128221004001FF010101FF010101FF010101FF0
+401D:00100110791049124912791449D84910791049104910491279524992010E0000
+401E:001001107C90449044107D10449044907C10441E47F044107C10441000100010
+401F:0090009078904BFC489478944BFC4A907A904BFE48924892791A491402100410
+4020:00007CFC4484448444847CFC4484448444847CFC4484448444847CFC44840000
+4021:002000207C204420443E7C20442044207DFC4504450445047D04450401FC0104
+4022:00400040788048FC49207A20482048207BFE4820485048507888488801040202
+4023:00000040782048284808788848904A947AA24AA24CC2488879884A8804780000
+4024:102010203F304128A224142208203020DFF010101FF010101FF010101FF01010
+4025:0008001C7DE0450045207D20452045FE7C20442044A844A47D22462200A00040
+4026:00200020782048204BFE78204820482079FC4904490449047904490401FC0104
+4027:01100110791049104BFC79104910491079104FFE4800491079084A0804040804
+4028:0008003C79E0482048207BFE48204820782049FC490449047904490401FC0104
+4029:0080008078F849084B107CA0484048A079184A064DF849087908490801F80108
+402A:00800080793C4A004C807880497E4B087D084908490849087908490801280110
+402B:0040004078A049104A087C064BF8480078004BF84A084A087A084A0803F80208
+402C:0040004078A049104A087C064BF84840784048404BF848407840484007FE0000
+402D:002000107C1045FE44207C24444444F87C124422444445887C10442800440182
+402E:008000407BFC49004900790049F8480079504950495049507A504A520452080E
+402F:004800447BFE484048407BFC4A444A447BFC4A444A444BFC7A444A4402540208
+4030:0088788449024A2248207850488849047A0249FC490449047904490401FC0104
+4031:0080008079F849104AA0784049B04E4E79F0484049F048407FFC484000400040
+4032:0100010079FC4A004DF87908494849287BFE49084A484A287BFC480800500020
+4033:002000207BFE4820482079FC4924492479FC4820487048A879244A2200200020
+4034:000003FC780049244A487C904A48492478004BFC484048407840484007FE0000
+4035:00200040788849044BFE7882488049FC7A2048204BFE48207850488801040602
+4036:008000407BF84A084A087BF84A084A087BF84A404A444A287A104A8803060200
+4037:00880088788849C8489E788A488A4BEA788A488A490A494A7BEA4912002A0044
+4038:080C08F07E8008800EFE78880888290812081FF010101FF010101FF010101FF0
+4039:0020002078204BFE482078204924492479244AAA482048507850488801040202
+403A:108020FC6910AA9028602890230C00001FF010101FF010101FF010101FF01010
+403B:0020002079FC492449FC792449FC48007BFE4880490049FC7804480400280010
+403C:000003FC7A004A004AF87A004A004BFC7AA04AA44AA84A907A904C8804A408C2
+403D:0004000E7BB8488848887928492E4BA878A84AA84AA8493E79004A80047E0800
+403E:0000FEFC104420287E10A2283EC600001FF010101FF010101FF010101FF01010
+403F:0104010EF130912097E0F120913E9164F1A4972491249124F124912405440284
+4040:1FF010101FF010101FF010101FF0080C08F07E8008800EFE7888088829081208
+4041:004000207BFE4800480079FC49044904790449FC482048A879244A2200A00040
+4042:7EFC48447E4442287E1048287EC600001FF010101FF010101FF010101FF01010
+4043:002000207BFE4820482079FC482048207BFE484048A449A87A904C8800C60080
+4044:0020002079FC482048207BFE4888485079FC482048204BFE7820482000200020
+4045:000001FC7808481048207BFE482048A0784049FC495449547954495407FE0000
+4046:004000807BFC49104A487C464BF84A487A484BF84A484A487BF848420042003E
+4047:020001007FFE4202A96C49940E1077F000001FF010101FF010101FF010101FF0
+4048:104008403E7E228823503E20205841869FF010101FF010101FF010101FF01010
+4049:104808443E7E23C022243E282212206A41869FF210101FF010101FF010101FF0
+404A:000003F87948491048A0784049B04E0E79F8490849F8490879F8490801F80108
+404B:0048014879484BFE494879484978490079FE48204BFE487078A8492406220020
+404C:000003FE7A224BFE4A227BFE480049FC790449FC490449FC7904490401140108
+404D:00140012F01097FE9410F41095D09412F41295D495549548F5DA942A08461082
+404E:004000207BFE480049FC790449FC48007BFE4A0249FC48207820482000A00040
+404F:000003FE785048504BFE7A524A524BFE780048404FFE48887990486000D80304
+4050:008800887BFE488848A8782049FC4924792449244BFE48207850488801040202
+4051:000001F8790849F8490879F848004BFE790049FC4A544C9479244A4400A80110
+4052:000001F87908490849F878004FFE490879F8490849F84908793E4FC800080008
+4053:000000887A524A224A527A8A4A024BFE788849444A7A48887950482000D80706
+4054:001E03E078444924488879FC484048407BFE488048FC494479284A1000680186
+4055:000003FC7A044BFC4A207BFE4A104A8A7B0648004BFC4A047BFC4A0403FC0204
+4056:0020012478A848204BFE78A849244A0278404BFE488849087990486001980604
+4057:002001247924492449FC78004BFE480079FC4904490449FC7888485003FE0000
+4058:0008003C7BC048044A44792849FC4A2078204BFE482049247924492401FC0004
+4059:000001FC790449FC490479FC48204BFE7A0248404BFE48887990486000980304
+405A:000001F87908490849F878004BFC4A047BFC4A044BFC4A047BFC489001080204
+405B:002000407BFC4A244A247BFC4A244A447BFC484048A848B4793C49220222041E
+405C:000001FC7D0445FC45047DFC442045247CA8442047FE44907C9045120212040E
+405D:08202AA42CA84920145022887FFE40029FF410101FF010101FF010101FF01010
+405E:082014502288082014502288FFFE08001FF028104FF088100FF008100FF00810
+405F:0108008878904BFC484079F848404BFE7880490049FC4A207C20482003FE0000
+4060:011000A078004FFE48A07BF848A84FFE78A84BF848A049B07AA84CA600A000A0
+4061:000003DE7A524BDE4A527BDE4A024A227A224A224A524A4A7A8A4A02020A0204
+4062:02100110F11097BE9240F20093BE928AF28892A892AE92A8F4A895A8085E1080
+4063:00207BFE482049FC492479FC492449FC78224BFE48084BFE7908488800280010
+4064:004000207BFE488848507BFE4A224AFA7A224AFA4A8A4A8A7AFA4A02020A0204
+4065:000003FE7A484A484BFE7A484A204BFE7A404AFC4B444A447A7C4A0003FE0000
+4066:0040007C78404BFE4A427A784BC44A3C7A004AFC4A844AFC7A844CFC048409FE
+4067:008800887BFE488848F8782049FC492479FC482049FC48207BFE485000880306
+4068:0200011EF7D2901297D4F45497D89014F7D29092911291DAF714911005100210
+4069:0040004078F849084A1079FC4924492479FC4924492449FC78004954012A022A
+406A:02000202E23CAFA0A220EFA0AABEAFA4EAA4AFA4A224AFA4E224A24402440284
+406B:000001FC792449AC4974792449FC482079FC48204BFE48007AA44A5204520000
+406C:0104008878004BFE4A227AAA4A724A227BFE480049FC490479FC490401FC0104
+406D:002800247BFE4850488879044A024998795449104BBE49107AA84AA804440882
+406E:000007BCF108952897BCF31895AA9946F00093F892089208F3F89208020803F8
+406F:004000A0F11896E69000F3F8920893F8F00097BC908494A4F29494A402940108
+4070:000000FEF0109720927CF2449244927CF244927C93C49E44F07C902800440082
+4071:0020002079FC48204BFE79084B9C490879884E3E48004BFE789048900112020E
+4072:000003FE7A524A524BFE780049FC490479FC490449FC490479FC488801040202
+4073:008800887BFE488848247BFE4850488879044A8A48884BFE7888488801080208
+4074:00400FFEF00097FC9404F5F4951497FCF00093F8920893F8F20893F800000FFE
+4075:000001FC7954495449FC78004BFE480079FC490449FC48627894498802A400C2
+4076:01080208F7C8945097DEF46497D49214F11497D4921493C8F2489454055408A2
+4077:0A803138228838382288393822887FFE40029FF410101FF010101FF010101FF0
+4078:009003FCF29493FC9294F3FC900093FCF20092F8920093FEF520951405480986
+4079:001003C87A7E4A404A627BD44A004A3E7BC84A484E7E4A487A484BC802480008
+407A:000001FC795449FC482079FC48204BFE7888485049FC48207BFE482000200020
+407B:044404E4E8A8AAAAAEEEE4A4AAAAAEEEE242A040AFFEA0E0E150A2480C460040
+407C:01FC792449AC492449FC782049FC48207BFE49544A2A482079FC482003FE0000
+407D:01240248792448004BFC7A944A644A947BFC4A484B684A487B6A4A4A02460362
+407E:010807FE790848004BFC7A944A944BFC78284BFE4A204B247AA84A92042A08C6
+407F:7F146B125D107F7E08107F100828FFA855449FF210101FF010101FF010101FF0
+4080:011007FCF04093F89040F7FC900093D4F11297FE93509534F38C908A02960102
+4081:01F00210F7FC920493FCF22493B89222F1FE921097FC9244F3FC90D0014A063E
+4082:07BC04A4F7BC94A497BCF4A497BC9120F3FE922097FC9A20F3FC922003FE0200
+4083:003C07C0F244912897FCF4A497FC9008F78894FE978894A8F798950805A80690
+4084:03DE7A524BDE4A524BDE78A049FE4B207DFC492049FE480079FC48880070078E
+4085:044404E4EA0AAEEEA404EAEAAE0EA0E0EAAAAAEAA040A7FCE444A7FC00440FFE
+4086:00407C400440287C10840884FF041A4428242824480448048804080428281010
+4087:00007CFC0424282410240824FE241AFC28442844484448448844084429FE1000
+4088:00107C10041028FE10920892FE921A9228FE289248104814881209FE28821000
+4089:0080F8BC0884510821FE1320FD20357C3190511051FE51109128112851442182
+408A:0080F8F8090853FE25121122FDFE344030A25354509853349054109253502020
+408B:100010FCFE4810307DFE44527C94111012307C2011FE50707CA8112412221020
+408C:0020F9FC0888505023FE1000FDFC352431FC512451FC502091FC102053FE2000
+408D:01FCF90409FC510421FC1088FDFC348833FE5088512452AA907010A851242060
+408E:0528FFBE094857BE231815AAFD4637FC320453FC520453FC920413FC51082204
+408F:200021FC3C445044904410441094FE88110010FC108428842484448440FC8084
+4090:2020202021247D245124912411FCFC2010201124112429242524452441FC8004
+4091:2048204820487D48514A916C1148FD48114811481148294A256A478A41068000
+4092:202020203C2053FE9020102011FCFE00100011FC110429042504450441FC8104
+4093:200021FC21047D0451FC91041104FDFC1104110411FC2850249044924112820E
+4094:2020202021FC7C20502093FE1088FC5011FC102010202BFE2420442040208020
+4095:208020FC21047DF8500893FE1040FCA21334105810942B342452449043508020
+4096:0000FFFE020002100408040408000FF81808280848088808080808080FF80808
+4097:00400040FE401044104420483E5062606240A2C0234022443E442244003C0000
+4098:000003FCFD041144112420A83C8864886450A450242024203C50248821040602
+4099:0000007CFE441048104820503E4862486244A244224422683E50224000400040
+409A:00080088FC501020105020883D0064086488A488245024503C20245020880306
+409B:000001F8FC081050102020103DFE64226424A420242024203C20242020A00040
+409C:00200020FC2013FE102020203C2065FC6420A420242027FE3C20242020200020
+409D:00500048FC481040105E21E03C4064446444A448243024223C52248A23060002
+409E:0000FFFE040008001FF02810C8100FF001000100FFFE054009203118C1060100
+409F:080008007F7C094411441144257C42000000FFFE08001FF82808C8080FF80808
+40A0:00400040FC8010FC112022203C20642067FEA420245024503C88248821040202
+40A1:0008001CFCE01080108020803C8064FE6488A488248824883C88248821FE0000
+40A2:00400040FC7C1084118822503C2064506488A706246024103C0824C020200010
+40A3:00900090F8902290229242D47A98CA904A904A904A904A927AD24712020E0000
+40A4:00880088FC881108117E23083D0865486528A528250825083D08250821280110
+40A5:000001FCFD041104110421FC3D20652065FEA520252025103D12254A21860102
+40A6:00200020FC501088110422123C2064406588A410242024443D88241020600380
+40A7:00800080FC8011FE110222043C2064206528A524262426223C22242020A00040
+40A8:0008001CFDE01100110021003DFE65106510A530251825143D12221002100410
+40A9:000001FCFD041124112421243DFC65246524A554254C258C3D04250421FC0104
+40AA:00900090FC901292119420983C9065986694A492249024903D1225122212040E
+40AB:00800080F8FC21082290406079984E26C82049FC48204A207BFE482000200020
+40AC:00007DF01110119011521D12E20E44000000FFFE08001FF82808C8080FF80808
+40AD:00400020FC2013FE100020883D0466026488A488245024503C20245020880306
+40AE:080008007F7C08243E2408447F5408880800FFFE08001FF82808C8080FF80808
+40AF:00200010FC1011FE110021103D106510657CA510251025103D10221002FE0400
+40B0:004200E2FB82208A208A408A7BEA488AC98A49CA4AAA4A827C824882008A0084
+40B1:01040084FC88101011FC21043D04650465FCA450245024903C922512220E0400
+40B2:08207E2008FCFF24102424447E5422880100FFFE08001FF82808C8080FF80808
+40B3:00200020FCA810A810A821743E2264206420A5FC242024203C20242023FE0000
+40B4:00400020FDFE1000100020FC3C00640064FCA400240024FC3C84248420FC0084
+40B5:000001FCFC20102013FE20003C0065FC6504A524252425243D54248821040602
+40B6:00880088F88821C8209E408A788A4BEAC88A488A490A494A7BEA4912002A0044
+40B7:001C01E0FC20102013FE20203CA864AA67ACA4A824AA25AA3EA6242020200020
+40B8:00140012F81027FE201040107BD2CA524A524A544BD4480878EA471A02260042
+40B9:00200040FCFE1124129820503C6067806420A42424A424A83D30245020880306
+40BA:000001FCFD24112411FC21243D2465FC6420A7FE247024A83D24222200200020
+40BB:000000FCFC8010F8108020F83C8067FE6540A524252825103D08254421820100
+40BC:00200020F85020882144422279F84808C850482048A44A827A8A4A8A04780000
+40BD:00200020FC3E102011FC21043DFC650465FCA524242027FE3C20242020200020
+40BE:00200020F82023FE2020412479244924CAAA487048A848A879244A2204200020
+40BF:00200022FBB420A820A841247AA24840C9FC4904490449FC7904490401FC0104
+40C0:00200020FBFE202021FC40247BFE4824C9FC48404BFE488479C8483000CC0302
+40C1:000001FEFC481048104821CE3D0265026502A5CE244824483C48244821FE0000
+40C2:000001FCFD04110411FC21043D0465FC6400A51225D425183D1025522192010E
+40C3:000003FEFA02228A225243FE7A424A22CBFE4A824A824A827AFA4A02020A0204
+40C4:00400020FBFE2000200041FC79044904C90449FC482048A879244A2200A00040
+40C5:01040088FC5011FC112421243DFC65246524A5FC242024203DFE242020200020
+40C6:00840084FDFE1084108420FC3C84648464FCA484248425FE3C00244820840102
+40C7:00200040FCFC108410FC20843CFC64206420A5FE252225223D2A252420200020
+40C8:01100112FDD41118115221923D2E644065FCA504250425FC3D04250421FC0104
+40C9:000001FCFD0411FC111021FE3D10654A6586A40025FC25043DFC250421FC0104
+40CA:00900090FBFC2090200041F879084908C9F84908490849F87908490807FE0000
+40CB:004000A0F910220825F640007BC44A54CA544BD44A544A547BD44A44025402C8
+40CC:000003FEFC50105011FC21543D54655465FCA420242025FC3C20242023FE0000
+40CD:01040088F80023FE204040C27922CA54489849384A5448947912461000500020
+40CE:00000040FBFE20882104464278FC4B08C8B048D04F3E48C27B24481800600780
+40CF:000001FCFD0411FC110421FC3C20652065FEA620242025FC3C20242023FE0000
+40D0:00400020FBFE2202208841047A224828C8244BFE482048507850488801040202
+40D1:0100023CF7A424A426A445A474C2DF8054BC54A456A455A474945488049409A2
+40D2:000003FEF80021FC2104410479FC4800CBFE4A8A4A524BFE7A224A22022A0204
+40D3:00880088FBFE208821FC40887BFE4820C9FC492449FC49247BFE490401140108
+40D4:00200010FDFE1102100020FC3C84648464FCA40025FE25023D02250221FE0102
+40D5:08202AA42CA84920145022887FFE40028004FFFE08001FF82808C8080FF80808
+40D6:00400080F9FC2104210441FC7900C9FE490049FE48024AAA7AAA440200140008
+40D7:000203E2F82221EA202A47FA788A4AAAC9CA488A49CA4AA27C924882028A0104
+40D8:000003DCFA9423D4225443C87A884A94CBE24800482049FC7820482003FE0000
+40D9:00400020FBFE2250225043FE7A52CA524BFE4A004A924AD47A98449204D2088E
+40DA:04200220F23E2F4024A04420773CD5505510551055FE5510752859280B441082
+40DB:00100010FAFE2110217C4054787C4B54C97C491049FE491079104A90047E0000
+40DC:00007F7848485F4C64805F7844484A4851307F4C00007FFC08001FF868080FF8
+40DD:02080248F7482290229E4FE47114D2145FD45494591451C87F08511405140222
+40DE:08407F4022F83E4800483EC804487EAA08AA290612027FFC08001FF868080FF8
+40DF:02880288F7C82290229E4FD47024D7D4545457D4545457C874485454046404C2
+40E0:02100110F11027BE2240420073BED28A528852A852AE52A874A855A8085E1080
+40E1:000003DEF88822A823FE41887ADA4CA6C9F84908490849F87908490801F80108
+40E2:02100210F51024BE282247447210D2105F1052105AA85728722853440C440082
+40E3:000E03F0F8442224210843F87A08CBFC4A044BFE4A024AAA7AAA450204140808
+40E4:004003F8F04827FE204843F87040D554575C544457FC5444775C555405540844
+40E5:002001FCFC88105013FE20003DFC652465FCA52425FC24203DFC242023FE0000
+40E6:08407F40227E3E8801483E4804507E200850288C10007FFC08001FF868080FF8
+40E7:008079F84A884870538E492049FC6A2050F84020FFFE04000FF83808CFF80808
+40E8:000003BEF8A220A220BE43887A08CA3E4A2A4BAA48AA48BE7888408A057E0202
+40E9:005001FCFD5411FC115421FC3C0065FE6500A57C250025FE3D50255421480266
+40EA:002003FEF80023FC220442F47A944BFCC80049F8490849F8790849F8000003FE
+40EB:010001F8FA0827FE228843247BFECA004AFC4A004AFC4A007AFC448404FC0884
+40EC:00400248FA4823F8208043F87A484BF8CA484BF8484848B478BC49220222041E
+40ED:00140012F7FE241025D0441475D4D55855CA54165442582472A2528A04780000
+40EE:00100410F27C201020FE40447628D2FE5210527C521052FE7210521005FE0800
+40EF:00200040F8F8228A218C40F8798C4A8AC8F848204BFE487078A8492406220020
+40F0:00800040F7FE24022A2443BC74A4DAA8551052E854045BFA70405248044400C0
+40F1:01140112F7D2211021104FFE7290D6D2529256D2529456D4728A52CA0F160022
+40F2:010003DCFA542366224047DC7A544B48CA544CA248004BFC7A944A9407FE0000
+40F3:01240248F924200023FC42947A644A94CBFC4A484B684A487B6A4A4A02460362
+40F4:04100210F07A27122014477E7008D710503C576455A4553C75245724053C0024
+40F5:004007FEF00023FC224043F87240D3F8524053FC5004555470A853100D480186
+40F6:00400020FDFE100011FC21543DFC64206522A48C252224543CC8254422520060
+40F7:00400FFEF40027FC200047FC7404D7FC50805C9C57D45D54755C5C9615562E22
+40F8:0148014CFAAA200827FE41487B68494ACB6A494C4B6C4948796A4B9A00260042
+40F9:03DE0252FBDE225223DE42227AFA4A22CAFA4AAA4AFA4AAA7AFA4A7202AA0226
+40FA:002007FEF48827DE248845DC76AAD488545057DE545055DC74505BDE08501050
+40FB:03FE0020F7FE242221AC428077DED2925392511E57D2555277DE51120FD20126
+40FC:1020082008207E200420082808241C222A224A20882008200820082008200820
+40FD:202010201020FBFE08201020102039FC54849488104810501020105011881606
+40FE:201011101110F9120912111411D83910551095101110111211521192110E1000
+40FF:202010201020F82009FC10201020382055FE9420105010501088108811041202
+4100:209010881088F88008BC13C010803888548894901060104410A41114120C1004
+4101:204811481148F948094813FE1148394855489548117811001100110011FE1000
+4102:202010201020F82009FC112411243924552495FC112411241124112411FC1104
+4103:202010201020F9FC0924112419243524512493FE102010501050108811041202
+4104:200011FC1104F9240924112411FC392455249554114C118C1104110411FC1104
+4105:0100111009203FF802007FFC082010102FE8C0063FF801001110210845040200
+4106:2008103C11E0F820082013FE10203820542095FC110411041104110411FC1104
+4107:200011FC1104F904090411FC1000380057FE9420102011FC1020102013FE1000
+4108:200013FC1000F80009F811081108390855F89400110810881090100017FE1000
+4109:201010D81394F894089013FE10903894549490D81398109010AA10CA12861102
+410A:202010201020FBFE08201020102039FC5440942010A41282128A128A14781000
+410B:2020102013FEF85008881124122239FC552495FC112411FC10221022101E1000
+410C:400023DE2042F94A1084114A225234206800ABDE205221522094214822542422
+410D:208810881088FBFE0888108817FE380055FC9504110411FC1104110411FC1104
+410E:2020102011FCF8500888110413FE380855E89528112811E81128100810281010
+410F:2088108813FEF8880800101C19E03420502093FE102010501050108811041202
+4110:1000540054FC7C8492849284FE8400FC7C800080FE80108254829282507E2000
+4111:201C13E01220FBFE0A201292130A3A0655FC9504110411FC1104110411FC1104
+4112:202010201050F8880944122211F838085450942010A41282128A128A14781000
+4113:2020104011FCF90409FC110411FC380057FE9420102011FC1020102013FE1000
+4114:2004101E13E0F82009FC1124192435FC502093FE1222122A12FA1202120A1204
+4115:2020102213B4F8A808A8112412A2384055FC9524112411FC1124112411FC1104
+4116:404020A02110FA0815F6100023C432546A54ABD42254225423D42244225422C8
+4117:405022522252FA5213DE1202220233FE6A02AA0223DE22522252225224522802
+4118:2020101011FEF884084811FE11023A24541095FE1040107C1044108410941108
+4119:200013FE1202F80009FC110411FC390455FC9440102013FE1000108811041202
+411A:4090209027FEF89013FC129423FC32946BFCA80021F8210821F8210821F82108
+411B:202011FC1124FBFE092411FC102039FC552495FC104013FE108811D01070138C
+411C:2040102013FEF80009541124195435FC502093FE1242129212FA120A12021206
+411D:2020102013FEF82009FC10401BFE348851049242159C110411DC110411FC1104
+411E:4100211023DCFA5415541288210832F46C02A80023FC20402150224825442080
+411F:01F03E0003F03E0003FA7E0201FE0C20703C1DE2F0221C1E0000FFFE11102308
+4120:202013FE1000FBFC0A0412F412943BFC540095F8110811F8110811F8100013FE
+4121:208010F81108FBFE0944119211FE3900557C9500117C1100117C1244127C1444
+4122:4080204027FCF91010A41F58255435526B58A800220823F8220823F822082408
+4123:202013FE1020F9FC080013FE12523BFE550495FC110411FC110411FC10881104
+4124:4108210827CEF912112417DE2552355E6FD2A91E2392255E2940211421122122
+4125:47FC20402FFEF84213581040235830006EEEAAAA2EEE20002FFE224825542FFE
+4126:04000EFC780408080810FF20082018201C202A202A2048208820082008A00840
+4127:04000E0079FC08440848FF480850185E1C422A422A8248828882090209140A08
+4128:08001DFCF02010201020FC20102033FE38205420542090201020102010A01040
+4129:04200E28782408240820FF2E08F018201C202A202A2048108812080A08060802
+412A:08401C40F08010FC1104FE041004310438845444544490041004100410281010
+412B:04000E0078FC08040804FF04080418FC1C842A802A80488088820882087E0800
+412C:08201C20F0201120112CFD34116433A439245534552891221122110210FE1000
+412D:08081C3CF1E010201020FC20102033FE38205420542090201020102010201020
+412E:08201C20F020102011FCFC201020382035FE5420505090501088108811041202
+412F:04000EFC784808480848FF48084819FE1C482A482A4848488848084808880908
+4130:08001DFEF00810881088FC88110831FE38185428544890881108120810281010
+4131:08401C20F02013FE1080FC80108030FC38845484548490841104110412281410
+4132:08201C20F02011FE1122FD22112231223952554A558A910211021102110A1104
+4133:08201C20F02011201120FD20113C312039205520552091201120112017FE1000
+4134:08001CFCF08410841084FCFC10843084388454FC548490841104110412141408
+4135:00701F80010001007FFC054009203118C00601001FF011001100FFFE01000100
+4136:08901C90F09013FC1094FC9413FC3A90369053FE50929092111A111412101410
+4137:08001C00F3FE10201020FC40104038FC35845284548490841084108410FC1084
+4138:08201C20F04011FC1104FD041104310439FC5504550491041104110411FC1104
+4139:00F83F0001007FFC092011102288CC643018C1E61F000100FFFE010001000100
+413A:08201C20F3FE102011FCFC2411FC312039FE5422542A90541050108811041202
+413B:08901C90F09012921194FC98109031983A94549254909090111211121212140E
+413C:08001DFEF02010201020FDFC112431243954554C558C91041104110411FC1104
+413D:08001DFCF05010501050FDFC1154315439545554555C91841104110411FC1104
+413E:08281C24F024102013FEFC2011243124392457A8552891101212122A14461082
+413F:08201C20F1FC11241124FDFC1124312439FC542054249018103210CA13061002
+4140:08021C02F3E2110A110AFDEA112A3A2A372A52AA544A904A10821102120A1404
+4141:01007FFC40040400FFFE08201E4003C03C3801E01F0001007FFC05401930610C
+4142:08801C80F0F811081310FCA0104038A03518520655F891081108110811F81108
+4143:00007DF01110119011521D12E20E440000E01F0001007FFC05401930E10E0100
+4144:08401C40F1FC10441084FC8411283210390857DE554A914A114A1252135A14A4
+4145:08201C20F1FC10201020FC2013FE30003820542055FC90201020102013FE1000
+4146:08101C10F210113E1122FC441010389034905310512891281128114410441082
+4147:00007FFC04403FF8244824483FF8000000E01F0001007FFC05401930E10E0100
+4148:0100111009203FF802007FFC082010D02F08C1061FF005400920111061080100
+4149:08001DFEF04810481048FC481248314A394A554C544890481048104813FE1000
+414A:08401C20F3FE12001200FE0C12F032203A20563E53E0922014221422181E1000
+414B:08801C80F0F811081210FDFC11243124392455FC54509050109010921112120E
+414C:08001CFCF084108410FCFC0011FE3102390255FE5502910211FE1102110A1104
+414D:08001C06F3B810881088FD08113E3B88348852885288913E11001280147E1800
+414E:081C1DE0F020102013FEFCA81124322239F85488549090BE1102110212141408
+414F:08001DFCF104110411FCFD00111831E0393855E0553C91E011221222121E1400
+4150:08001DF8F108110811F8FD08110831F83908550855F89090109011121212140E
+4151:08081C3CF3C010441224FD28110030403BFE5488510893901060105011881604
+4152:08901C90F3FE10901090FC40102033FE39005500550091001100110011F81000
+4153:12003A00E23C27D42454F854275435546D546554A74825482048205422942122
+4154:08921C92F12412481124FC921092300039FE5522552291FE1122112211FE1102
+4155:08001DFEF102110211FEFD10111031FE39105510557E914211421242127E1442
+4156:08201C20F3FE10501088FD24122231FC392455FC552491FC10221022101E1000
+4157:081C1DE0F020102013FEFCA811243A42344053FE5088910810D0103010481184
+4158:08201C20F02013FE1020FD24112431243AAA547054A890A81124122214201020
+4159:08001DFCF104110411FCFD04110431FC3800551255D49118111011521192110E
+415A:08201D24F0A8102011FCFC4013FE3888350452FA5488908810A810921082107E
+415B:08FC1C84F08410FC1084FC8410FC300039FE5502550291FE1102110211FE1102
+415C:08081C3CF1E0102013FEFCA810A830A83BFE54A850A893FE1020102011FC1000
+415D:08401C20F02013FE1202FC9411083204380055FC542090201020102017FE1000
+415E:08001DF8F10811F81108FDF8100031FC381057FE541091101090101010501020
+415F:00401848708411FE1020FBFE108831243A425588501090621184101810601380
+4160:08001DFCF104110411FCFD04110439FC340053FE50209120113C112012A0147E
+4161:08001DFEF020104011FCFD04110431FC390455FC5504910411FC100010881104
+4162:08201C20F3FE122213FEFE2213FE300039FC550455FC910411FC110411141108
+4163:08201C40F1FC110411FCFD0411FC30003BFE5420542091FC1020102013FE1000
+4164:08081C3CF1E010201020FDFE102030A0392C5524552491AC1124112411FC1104
+4165:08001DFCF10411FC1104FDFC108031FE3A2255225552910211FA100210141008
+4166:08881C88F3FE10881088FC0011FC31243924552455FC91241124112411FC1104
+4167:08401C20F3FC10001108FC9013FE300039F85508550891F81108110811F81108
+4168:081C1DE0F020102013FEFCA81124322239FC5504550491FC1104110411FC1104
+4169:08201C20F3FE102011FCFC881050302038585586540091FE110211FE10841102
+416A:08201C20F1FC112411FCFC2013FE300039FC5504552491241124105010881304
+416B:08401C20F3FE10001000FDFC110431FC390455FC542090A81124122210A01040
+416C:09041C84F088100013FEFC00108831043A0255FC555491541154115417FE1000
+416D:08201C10F1FE10841048FDFE11023224381055FE5440907C1044108410941108
+416E:08201C20F050104810A4FDFE128430FC388454FC548090FC11441144127C1044
+416F:08201C10F1FE1110117CFD1411FE3114397C5510557C914411441244127C1444
+4170:08001DFCF124112411FCFD241154318C390455FC5440902010A4128A128A1478
+4171:08201D24F124112411FCFC0013FE300039FC5504550491FC1088105013FE1000
+4172:08401C44F1F8105013FEFC4010F831823A7E540055FC910411FC110411FC1104
+4173:08801C80F1FC12441154FDF4108431283A9055FC5244955411F4108411281210
+4174:0020182073FE102013FEFA42148C31F03820544453FE90221128122414A41040
+4175:09041C84F088100013FEFC20102039FC3420542053FE900012A4125214521000
+4176:08001DFEF100117E1100FDFE1154314839645542550491FE114412241204140C
+4177:08881C88F3FE108810A8FC50108831743A22542055FC902010A8112412A21040
+4178:08881C88F3FE10881040FC2011FC3888345053FE5020902011FC102010201020
+4179:08201DFCF12413FE1124FDFC102031FC392455FC504093FE108811D01070138C
+417A:08001DFCF05011FC1154FD5411FC300039FC540057FE902010A8112412A21040
+417B:08401C20F3FE10001154FD24115439FC342053FE5242929212FA120A12021206
+417C:08001DF8F10811F81108FDF810003BFC369453FC500091F81090106011981606
+417D:08007F7808483E4800863E782A483E30404881E41F0001007FFC05401930610C
+417E:00001BDE708812A813FEF98812DA34A639F85508510891F81108110811F81108
+417F:08881FFEF088100011FCFCA810A833FE38A854A855FC902013FE102010201020
+4180:08001DFCF12411AC1174FD2411FC382035FC502053FE900012A4125214521000
+4181:08001DFCF15411FC1020FDFC102033FE3888545055FC902013FE102010201020
+4182:10203BFEE288225023FEFA5022FC32546BFE6254A2FC225022D8255426522850
+4183:211017FC004073F8120813F812082FFE400001E01F0001007FFC05401930610C
+4184:08101DFEF00011FE1102FD7A114A39FE340054FC508490FC108410FC100011FE
+4185:0A201D3EF04210941310FD28104631FC390455FC550491FC110411FC10881104
+4186:08F81C88F08810F81000FDDC1154315439DC542057FE907010A8112412221020
+4187:1000E7FC248425E42524FDE4252435E46D0465F4A50425F42414255625562832
+4188:1000E4FE228222FE2080F8AA2E9C32AA6A8062A8A2BE22C822BE2288250828FE
+4189:10003BFCE294229423FCF910225233DC681263CEA24023D2225C23D0225222CE
+418A:00941B987092118E1280F9FC112431FC392455FC508891FC108813FE10881104
+418B:108039F8E20827FE2252FBDE2050335E695267DEA152235E215027D22152233E
+418C:0394191077BE111813AAFD46102033FE380057FC500093FC100013FC120413FC
+418D:12103910E7DE2010245EFA8227DE30106FDE6450A7DE245027DE2450245224CE
+418E:1148394CE2AA200827FEF9482368314A6B6A614CA36C2148216A239A20262042
+418F:09241CA8F3FE10A81326FDFC112431FC392455FC548893FE108817FE11041202
+4190:01001FF002007FFC082037D8C1063FF811107D7C2020FEFE5454BABA10105454
+4191:020001007FFE400288241010200800007FFC0100010001000100010005000200
+4192:020001007FFE40028824121022081FE002200A200420062009221022201E4000
+4193:020001007FFE4002882411102208044008201FF004500440044008441044603C
+4194:020001007FFE48229114210801003FF82108210821083FF82108010001000100
+4195:020001007FFE4822911401003FF0011001100110FFFE0280044008203018C006
+4196:020001007FFE48229014220802007FFC0400048008801100222044108FF80408
+4197:020001007FFE48229014200800007C8844884488448844987CE8448800080008
+4198:020001007FFE4822901420081FF0111011101FF0111011101FF0111001000100
+4199:020001007FFE4822901400007FFC01000100110011F8110011001100FFFE0000
+419A:020001007FFE4822901400003FF820082FE8200827C82448244827C820082018
+419B:020001007FFE482290140000001879E048404840487E4BC0484078444844003C
+419C:020001007FFE4822941404007FFC08001FF028104FF088100FF0081008500820
+419D:020001007FFE400288241010210802003FF824482448244824482448FFFE0000
+419E:020001007FFE482290141FF010101FF010101FF0000010F01F00100410040FFC
+419F:020001007FFE4822911422880C603018CFE600001FF01010101010101FF01010
+41A0:01007FFE4822901400003FFC210021003FF8200820083FF8210021003FFC0000
+41A1:020001007FFE4822921401001FF010101FF010101FF011081090126014181806
+41A2:020001007FFE482290141040FDF810481448184833FED04010A0111052082406
+41A3:020001007FFE4822901400003FFC20002FF820003FFE2908289048604A188C06
+41A4:01007FFE4822901402001FF010101FF010121FF410187FF001900E10F0500020
+41A5:020001007FFE482290147FFC02000D08719002A00CC071A006981886E2800100
+41A6:020001007FFE482291140910092012C0043019086914091012A004401830600C
+41A7:01007FFE482290741F8001007FFC05401930E10E04007FFC08201C4003807C78
+41A8:01007FFE482290141FF010101FF010101FF000003FF801007FFC04401830E00E
+41A9:01007FFE482290141FF010101FF010101FF010101FF002007FFC04401830E00E
+41AA:1040102095FC550458501088FD04280028F828202820282029FC4800480287FE
+41AB:01007FFE4822901408001FF82A4844480A88110822A8041001004884481287F2
+41AC:01007FFE482290140FE008203FF820083FF820083FF820083FF8082010102008
+41AD:01007FFE4822901408007F7C08107F1049107F1049FE7F100810FF9008100810
+41AE:01007FFE4822901423F8100811F8800843F8500017FC2404E3F8211020E0271C
+41AF:01007FFE4822BEFC12480C3032C800003EF812480C3032C8FFFE082007C07838
+41B0:020001007FFE482290143FF8200027F0241027F020002F7829482F7820003FFC
+41B1:020001007FFE482290142040124890B04108460410402244E44820A023182C06
+41B2:01007FFE482291143FF820802FF820883FFE20882FF824C422A8449858868180
+41B3:01007FFE4822901423FC10801144066870B01128166810A4112416A0284047FE
+41B4:01007FFE48229FD410403FF051101FF011103FF821083FF821083FFA010200FE
+41B5:020001007FFE4822901408207FFC511449247FFC00001FF010101FF010101FF0
+41B6:01007FFE4822911408801FFC30805FF810801FF810801FFC1000248822444244
+41B7:01007FFE482290141FF002207FFC04887A8001003FF8282837D8244827C82018
+41B8:020001007FFE482290947EA00444282817D02008DFF610101FF0082004407FFC
+41B9:01007FFE49229FF404407FFC00001FF011101FF011101FF001003FF80100FFFE
+41BA:01007FFE4822901400F83F0011100920FFFE09203018DFF611101FF011101FF0
+41BB:020001007FFE482290147C200420FF3E22443EA422283E282390FE2842440282
+41BC:01007FFE4822901421F8110811E8012873FC120412F4129412F412142A0847FE
+41BD:01007FFE482291FC01003FFC21042FE021082FF823002C9023605CD843469CC0
+41BE:01007FFE482290143F2024203F3E21403F5024883F0800003FF824482448FFFE
+41BF:01007FFE4822905409FC490449FC490479FC090409FCF8204BFE48A849248A22
+41C0:01007FFE482290142200FF7E22243E3C08247F24493C7F240826FF7C08040804
+41C1:01007FFE4822901420443E2844FEFF1049107F7C49107F1000FE55104A908A90
+41C2:0200010001007FFC00001010082004400000FFFE010001000100010001000100
+41C3:1000080008FC7E8400840484448444FC2484288028800E82F0824082007E0000
+41C4:1040084008407EFE00800500447C44082410282028400E80F102410200FE0000
+41C5:1050084808487E40005E05E0444044442444284828300E22F052408A03060002
+41C6:1008088808487E4800080488444844482408280E29F80E08F008400800080008
+41C7:200011FC1104FD04010409FC8920892049FE4920512051101D12E14A41860102
+41C8:200011FC1084FC880050082088D88B064820482051FC50201C20E02043FE0000
+41C9:2000100013FEFC2000200840884088FC49844A84548450841C84E08440FC0084
+41CA:202010101010FDFE010009108910891049104920512851241E44E2FE44420800
+41CB:10200820087C7E840148043044284448259E282228420EA4F018401000600180
+41CC:2020112410A4FCA8002009FC8904890449FC4904510451FC1D04E10441140108
+41CD:200011FC1104FD04010409FC882088204920493C512051201EA0E260443E0800
+41CE:204810481048FDFE0048084889FE880048FC4884508450FC1C84E08440FC0084
+41CF:2040102013FEFC0001FC090489FC880049FC4808501053FE1C20E02040A00040
+41D0:2020102011FCFC2400240BFE8824882449FC4A22517450A81D24E22240A00040
+41D1:2040108011FCFD24012409FC8924894449FC4890511053FE1C10E01040100010
+41D2:7DFC44207D2045FE7C5048525492650E020001003FF8000008200440FFFE0000
+41D3:0BFE104061FC090411FC610405FC090431FCC088030401003FF808200440FFFE
+41D4:0100FFFE20003FF800003FF820083FF80200711C57D47014545C729651D6B622
+41D5:000021FC102013FEFA2201AC082089AC88004BFE502051FC1D54E1544154010C
+41D6:104010403F7E48908508080008001FF821084108020802080408180860500020
+41D7:104010403F7E2890450880000440082010102108C2060400082010103FF81008
+41D8:104010403F7E2890450880007FFC04000FF00810082010201FC00040FFFE0000
+41D9:20403F7E4890850800007F08010801083F08200840087F08010801080A080408
+41DA:104010403F7E4890850800000840084010403050504890441044104010401040
+41DB:104010401F7E28902488450881000100110011F81100110011001100FFFE0000
+41DC:204020407EFE5110880808000FFC10042108410001000280044008203018C006
+41DD:104010403F7E2890450880400420040004FEFF000210016001840E447034000C
+41DE:104010403F7E4890850810101010FFFE101010101FF01010101010101FF01010
+41DF:104010403F7E28904508902010203E2022FC4224A42414440844108421144208
+41E0:104010403F7E28904508820001007FFC010001003FF8010001000100FFFE0000
+41E1:204020407EFE51108A0801007FFE400280043FF8010001000100010005000200
+41E2:104010403F7E2890450881000100FFFE010001001FF01010101010101FF01010
+41E3:104010403F7E489085080280044009203118C106010009201110210805000200
+41E4:20403F7E489085080000FFFE010001007FFC4104428444444824400440144008
+41E5:104010403F7E4890850800007FFC01000100110011F8110011001100FFFE0000
+41E6:104010403F7E2890450881001FF0111011101110FFFE0280044008203018C006
+41E7:104010403F7E489085080000FFFE01003FF8210822882448282820083FF82008
+41E8:20403F7E4890850808001FF0282007C01830E10E1FF0010011001FF801000100
+41E9:104010403F7E4890850801003FF821083FF821083FF8010800B001C20E32700E
+41EA:104010403F7E4890850800007FFC040008201FF0011001003FF801000100FFFE
+41EB:20403F7E4890850800003FFC2080208027F82408240827F8208020803FFE0000
+41EC:104010403F7E48908508110011003FF841000100FFFE054009203118C1060100
+41ED:20403F7E48908508020002083FD00220FFFE0100061008E03F00C808080807F8
+41EE:104010403F7E489085080810087813C0304050409FFE10401040104017FC1000
+41EF:104010403F7E2890450880007FFC10101FF010101FF01010103EFFD000100010
+41F0:104010403F7E4890850800001FC000447D88055009203118C50602003FF80000
+41F1:104010403F7E4890850800003FF8220823C824482A882108228824083FF82008
+41F2:104010403F7E4890850801003FF8010011100920FFFE0280044008203018C006
+41F3:104010403F7E28904548822003F87E0003F03E0003FCFE20014000840764781C
+41F4:104010403F7E489085080000FFFE04403FF8244824482848303820083FF82008
+41F5:104010403F7E48908508200C11F01100810049FE49101110E110221022102410
+41F6:20403F7E4890850808001FF020205FF811081FF811081FF81108210821284010
+41F7:20403F7E489085083F04210421243F24082408247FA408A410A4108422944108
+41F8:104010403F7E289045089FF0101010101FF000003FF801001FF001007FFC0000
+41F9:20403F7E4890850800003FF80408FFFE04083FF808001FF8280848088FF80808
+41FA:20403F7E4890850800007FFC00001FF0101010101FF0000008200440FFFE0000
+41FB:20403F7E489085083FF820083FF8200020702F8020F02F8020F85F824082807E
+41FC:20403F7E489085081FF010101FF000003FF8210821083FF8200220021FFE0000
+41FD:104010403F7E48909508100C11F0FD00110011FE1D10F1101110121052102410
+41FE:104010403F7E4890850801007FFC00003FF800003FF800003FF820083FF82008
+41FF:20403F7E489085080100FFFE01003FF8210821083FF8238805601918E1060100
+4200:104010403F7E489085083F842A842A942A94FFD42A942A942A942A8420942188
+4201:20403F7E4890850802800C6037D8C0063FF8248824883FF82488248824A82010
+4202:104010403F7E48908508101008207FFC082008200820FFFE0820082010202020
+4203:20403F7E4890850823FC10841084808449144A0815FCE1042104210421FC2104
+4204:104010403F7E289045089FE040445194492443C445444924551442047FFC0004
+4205:104010403F7E4890852800907FFC00803E88228822503E5000240754788C2104
+4206:20403F7E4890850800803FFC200420043FFC20A020902FFC2120421044089806
+4207:20403F7E48908508010001FC01003FF820083FF820083FF80100FFFE01000100
+4208:104010403F7E489085083EFC22A422A43EA422FC22803E80228222824A7E8400
+4209:204020407EFE51108A0801003FF80820FFFE04007FFC08201C4003800C707008
+420A:20403F7E4890850801003FF80100FFFE1010220847E40820144003801C70E00E
+420B:20403F7E4890850801047D9809603118C50602001FF010101FF010101FF01010
+420C:20403F7E48908508100009F80908410821F82908090811F87108110817FE1000
+420D:20403F7E489085080080FFFE10001FF800001FF010101FF010101FF010101FF0
+420E:20403F7E4890850812207FFC122013E010001FF80100FFFE05401930E10E0100
+420F:20403F7E4890850800007FFC00001FF010101FF000003FF821083FF821083FF8
+4210:104010403F7E48909548104013FE5880549051109152125414A8102810441082
+4211:20403F7E489085081FF010101F9010907FFC40044FE4482448244FE440144008
+4212:20403F7E489085080100FFFE01003FF8244822882FE821083FF8210821282010
+4213:104010403F7E489085081FF010101FF010101FF008001FFC2104528414541FE8
+4214:20403F7E489085087CF8440844087CF8400041F87C88405040207C5040884306
+4215:20403F7E489085081FF010101FF010101FF000007FFC110011F8290047FE8000
+4216:20403F7E489085080C10709010501010FC903050381E55F05010901010101010
+4217:20403F7E4890850809100A0817FC31105208948411F813081490106011981606
+4218:20403F7E4890850808200440FFFE1020102024487CF80810102024487EFC0204
+4219:104010403F7E4890850810001008240879FE100824887E48004854084A288A10
+421A:20403F7E48908508080010103FF800081FF0101010101FF001004884481287F2
+421B:20403F7E4890850808000F7C084408447F44552855287F105510552855444382
+421C:20403F7E489085080BF8080811F8300853F8900017FC140413F8111010E0171C
+421D:20403E7E4890BFFC010411F011002FFE40009FF010101FF010101FF010101030
+421E:20403F7E4890850800807FFC00001FF010101FF000003FF820083FF820083FF8
+421F:204020407EFE511088083F0421243F2421243F24212421243F24120421144088
+4220:20403F7E4890850800FC7F00220811103FF80200FFFE04000FF0122021C0CE3C
+4221:20403F7E4890850808001FF82A4844480A88110822A8041001004884481287F2
+4222:20403E7E4890900020087FFC00043FF820083FF80100FFFE054009203118C106
+4223:104010403F7E4890850800207F20043E044427A42428242824102F28F0444082
+4224:20403F7E4890850810881088FC8813FE3088388854F854889088108810F81088
+4225:20403F7E4890850810101F1022107FBEA4923F9224923F92249224A242AA8144
+4226:20403F7E489085082448238824483FF81010220847E40820144003801C70E00E
+4227:20403E7E489080F87F00221011201FE010201FF010101FFC20042AA44AA4800C
+4228:20403F7E4890850800007DF8450849F8510849F8452445285510494841864100
+4229:20403F7E489085080804140422245D248024112409244A2427A4F80440140008
+422A:20403F7E489085087FFC00001FF010101FF000007FFC482444445FF44104410C
+422B:20403F7E489085081020102025FC7D2409241154254C7D840104550455148108
+422C:20403F7E48908508404427FE204087FC444457FC1444E7FC2444244424540408
+422D:204020407EFE51108A0804003FF821083FF821083FF8029004A808FA308AC07E
+422E:20403F7E489085082080108010FCFD0402F44894489448F410941E04F0284010
+422F:20803EFE4910BFF801001FF010101FF010101FF010101FF01010FFFE08201010
+4230:20403F7E489085081020112410A8FC2011FC11041DFCF10451FC110451142108
+4231:104010403F7E4890850800FC7F00220811100C20307820083C7820083FF82008
+4232:20403F7E4890850810783E4822482A862300FEFC22442A44222842104A2884C6
+4233:20403F7E48909FF810081FF810081FF800007EFC224412240A1412246AD40408
+4234:20403F7E48908508102008407FFC04803FF00490FFFE04903FF00CA03498C486
+4235:20403F7E4890854808203218C4460FE000207EFC224412240A1412242A544488
+4236:104010403F7E4A9085087FFE400289241290244808203FF8C82608200FE00820
+4237:20403F7E48909508108010F8FD08129030603998560651F89108110811F81108
+4238:20403F7E4890850810041F2422147F84A4A43F9424863FBC2484248442848104
+4239:20403F7E489085087FFE48028BF4108033F85208920813F81208120813F81208
+423A:20403F7E48908508104010FC24887D50082010D827067C60001054C054308008
+423B:20403F7E48908508002878244BFE482079FC492449FC792449FC49244924990C
+423C:20403F7E50908A0801007FFE42028924284849940E1077F00100210821083FF8
+423D:20403F7E4890850808207FFC08200FE001003FF821083FF801007FFC0100FFFE
+423E:20403F7E4890850810201124FCA8102031FC390455FC910411FC110411141108
+423F:20403F7E489085087FFC40041FF010101FF010101FF00100FFFE082010102008
+4240:20403F7E4890850800803FFC222022203FFC2220222023E020004A4849249124
+4241:20403F7E489085080010FF9022283E4422923E08227C2384FE08023002080204
+4242:20403E7E48909FF011101FF011101FF0040008201FC003103FF8112025104208
+4243:20403F7E489085080440247C24A83D50042804487DFE24882448244844088418
+4244:20403F7E4890850878404BF8504067FC51104A884CF4691052A0404041B04E0E
+4245:104010403F7E4890954810407C4011F8FE48444828C87C4810AAFEAA11061202
+4246:20403F7E489085081FF010101FF010101FF010001FFC10001FFC492484940008
+4247:20403F7E4890950811047FC411241F2411241F2411247FE42924308420143FC8
+4248:20403F7E4890850824207E20243EFF4400A47E2442287E2842107E2842444682
+4249:20403F7E4890850820003E1C44E87EA8AAA83EA82AA83EA82AA42B542B744612
+424A:20803EFE551088201FF00210FFFE09203FF8D1161FF011101FF001007FFC0100
+424B:20403F7E4890850811FC1124FDFC2500257C4944297C1144297C4644827C0444
+424C:20403F7E4890850878904BFC48805144566848B049284E6868A4512246A04040
+424D:20403F7E489085087C7C44447C7C44447D7C40844A244A14525441C440144008
+424E:20403F7E48908508111009203FFC20044FE808200FE001007FFC05401930610C
+424F:20403F7E4890850810001EFC22247F44A99C3F50297C3F9029FE291045108210
+4250:20403F7E489085081020FE2010207DFC54207C2054F87C881088FE8810F81088
+4251:20403F7E4890850810003FFC4AA00AA07FFC0AA00AA07FFC0000248822444244
+4252:20803EFE491080F83F0011100920FFFE09203018DFF611101FF011101FF01010
+4253:20403F7E48908508100011FC1124FDFC312439FC542053FE90A8112412221020
+4254:20403F7E5090880800900088FBFE20483C3245CE4890A88813FE10482032C1CE
+4255:20403F7E48908508082004403FF8292825483FF800001FF010101FF010101FF0
+4256:20403F7E4890850808107F1008287F4449927F08497C7F040808FFB008080804
+4257:20403F7E4890850811F81108FDF8100013FC11081DF8F10811F8110E57F82008
+4258:20403F7E489085081040102013FEFA0214FC300039FE542050A8912412A21040
+4259:20403E7E4890BFF801007FFE41029D7401001D7000003FF80000FFFE10103FF8
+425A:20403F7E489085083FF824483FF800007FFE4002BFF408000FE0112416A4181C
+425B:20403E7E489084003FF8292825482FE8254828280100FFFE02800C603018C006
+425C:20403F7E4890850820A020907DFE9120132011FCFD2011FC2920252041FE8100
+425D:20403F7E4890951808203FF801007FFC02403C500848FFFE08507E240854198C
+425E:20403F7E4890850800283FFE20202FA420282F9048AA4FC682820900282847E4
+425F:20403E7E4890812011FC1320FDF8112015F8192031F8D10013F8111050E0271E
+4260:20403F7E4890850822204AA08ABE1FC420A46F24A0282F28291029A829443082
+4261:20803EFE4910FFFE00003FF8200827C824483FF810101FF010101FF00000FFFE
+4262:20403E7E489081007FFC11102928FFFE00003FF8200827C8244827C820083FF8
+4263:20403E7E489082001CF010101EF010101FF008001FFC20044924249424944008
+4264:20403F7E4890850849202A20FF3E2A4449A41024FE282228641018282444C282
+4265:20403F7E4890854811FE1122FD7A118A155219223152D1FE104012A4528A247A
+4266:20403E7E48908FF841402FF829480FF8E1002FFC24102BE8322423E052088FFE
+4267:20403E7E4890F784428462A454A469A414242224DD2408247F244A042F94F008
+4268:20403E7E4890900008787F48224814867F0010FC694416446D281490642818C6
+4269:20403F7E48908508100013FE1200FE7C1244327C3A0056EE52AA92EE120013FE
+426A:20403F7E489085083FF821083FF821083FF80000FEFE9292FEFE9292FEFE8282
+426B:20403E7E48908640387C08947E241C442A94490802C01D30E92E054009201310
+426C:20803EFE491080803FFE20202F2831102A0A277C294A378428784F484130874C
+426D:20803EFE49109084210810843FF82448238824483FF829482528294A25263182
+426E:20403E7E4890FC7C44447C7C44447D7C44844FE459044FC449044FC449044FEC
+426F:20403E7E4890BF7C24443F2821103F2824463FF010101FF010101FF008201010
+4270:20403E7E4890BE2022103AFE2A007F2841443E8222283E2822103E2822442682
+4271:20403F7E4890A508100003FEFA000A7C12442A7C7200AAEE2AAA22EE220023FE
+4272:20403E7E48908000F7FC124817FCFC4686EC8554F6EC155416EC144454542408
+4273:20403F7E4890850820443E2844FEFF1049107F7C49107F1000FE55104A908A90
+4274:20403F7E489085087FFC00003EF822883EF804403FF80440FFFE04901C60671C
+4275:20403F7E48909FF8149012501FF00200FFFE0AA03458CFE6155007C004A00670
+4276:20403E7E4890A4483F7E64C8BF7E24483F7E24483F7E20401FF0082007C0F83E
+4277:20403F7E489085081E7812483FFC20202E20223C3FC829282F2849905F288144
+4278:204020407EFE5110880841102788F83E53942008FBBE2008739C228843888288
+4279:20403E7E4890BFF801007FFE492284143BB82AA83BB800007FFC11102928FFFE
+427A:080008004AFC2A202C200820FE2018201C202A202A2048208820082009FE0800
+427B:1004101E95F0551059101110FD1031FE3910551055109108110A114A11861102
+427C:0804080E4AF02A802C800880FEFE18881C882A882A8848888888090809080A08
+427D:10201020952454A458A81020FDFC30203820542057FE90201020102010201020
+427E:044004447C78044004421C42E43E0000111009207FFC054009203118C1060100
+427F:1008103C95E05420592410A4FCA8302039FE5420542090201020102010A01040
+4280:10201020942054205BFE1020FC20302039FC5504550491041104110411FC1104
+4281:10201120952055FC59201220FC2033FE3890549054909090111211121212140E
+4282:1020102097FE5420582011FCFD2431243924552C547090A81124162210201020
+4283:200027FC2404AC0475F42444FC4425F475546D54AD5425542574244624462842
+4284:00007DF01110119011521D12E20E4400111009207FFC054009203118C1060100
+4285:1040104094FC55045A881050FC203040388055FC568490841084108410FC1084
+4286:04003878200820083C78200820083FF80000111009207FFC054009203118C106
+4287:1028102495FE5420582011FCFD24312439FC5524552491FC112411241124110C
+4288:1080108094FE55005AFC1084FCA430943BFE54845524911411FE100410281010
+4289:1040102095FC55045A281020FC2031FC3870546854A890A41124122210201020
+428A:100011FC9504550459FC1100FD1C3170391C5570551E91F0111011121112120E
+428B:1048114895485548594811C8FC7E30483BC855485548914811481148125C1440
+428C:10201010941055FE59001148FD4A314A396C55485548914A114A126A12461400
+428D:0C8070FC1124FD2412243844548491281010111009207FFC054009203118C106
+428E:1020112494A8542059FC1040FDFE3088390456FA5488908810A810921082107E
+428F:102010A494A4552858501088FD043024382054A854A891301050108811041202
+4290:100011FC9504550459FC1104FD0431FC3800551255D49118111011521192110E
+4291:1020112494A454A8582011FCFD04310439745554555491541174110411141108
+4292:10A01090948055FE59101310FDFC3110391055FC55109110111011FE11001100
+4293:100011FC9504550459FC1104FD0431FC380057FE54209120113C112012A0147E
+4294:2088208823FEA88870A82020F9FC212471246924ABFE20202050208821042202
+4295:20102010207CAB1471FE2114FA7C2210777C6910A9FE25102210230024FE2800
+4296:2020202023FEA820702023FEFA8A225272FA6A22AA2222FA22222222222A2204
+4297:1020104095FC550459FC1104FDFC30003BFE5420542091FC1020102013FE1000
+4298:1020102095FE552259FE1122FDFE300038FC548454FC908410FC108410941088
+4299:0000FDFE204840487DFEC44844887D080008111009207FFC054009203118C106
+429A:20102220217CA9447044207CFB402140717C6944A944217C21442280247E2000
+429B:2000245C2294A91472942454F926210077DC6914AD9425542948210825142222
+429C:102013FE942055FC592411FCFD2431FC382257FE540893FE1108108810281010
+429D:101C11E09420552458A813FEFC7030A8392456225440902412A2128A14881078
+429E:2040202023FEA888705023FEFA2222FA72226AFAAA8A228A22FA2202220A2204
+429F:2088208823FEA888708820F8F82023FE72226B32AAAA237622222222222A2224
+42A0:7DFC44207D2045FE7C5048525492650E111009207FFC054009203118C1060100
+42A1:100011F8950855F8590811F8FC0033FC3A9457FC540091F81090106011981606
+42A2:0440247C24A83D5004287DFE248844488418111009207FFC054009203118C106
+42A3:1088108895FC5488588813FEFC2031FC392455FC552491FC1000108811041202
+42A4:100013FE945057FE5A5213FEFC0031FC390455FC550491FC102013FE10201020
+42A5:202021FC2024ABFE702421FCF82022AA73AE6A22ABFE222223AE22AA22AA2422
+42A6:102013FE942055FC580013FEFE0231FC380055FC550491FC1104108813FE1000
+42A7:209027FC2094ABFC729023FEF91223FA750E69F8A90821F8210821F820902108
+42A8:0100FFFE20003FF800003FF820083FF80100755C539477D4511473965556B122
+42A9:103C13E0952454A85BFE10A8FD24320239FC5524552491FC1124112411FC1104
+42AA:1088108897FE548859FC1124FDFC312439FC542057FE9222122A12FA120A1206
+42AB:200023FC2294AA9473FC2000F890279E70906890AB9C20902090279E20902090
+42AC:0DFC712411FC1124FDFC30203BFE54A851248222111009207FFC05401930E10E
+42AD:102013FE942055FC580013FEFC0231FC382057FE540093FE100413BE12A4138C
+42AE:200023DE2042AA52714A2252F890210873FE6D10A9FE211021FE211021FE2100
+42AF:1020101095FE5528597C1128FDFE3110397C5554557C9154117C120012441482
+42B0:22102110203AAB92701423BEF8082390703C6BE4AAA422BC22A423A422BC2024
+42B1:2148214C22AAA80877FE2148FB68214A736A694CAB6C2148216A239A20262042
+42B2:0010FE0828FEFE00AA44AA28FEFE108854A838BEFEC8108838BE55089108127E
+42B3:202023FE2248ABFE724822ECFB5A224872506BDEAA5023DC225025DE24502850
+42B4:1088108894EE55545A221050FC8831743A0255DC555491DC1088108811541222
+42B5:104010402040244045F8F848104820484848FC480448004A548A548A81060200
+42B6:1020102020202520452CF934116423A44924FD34052801225522550280FE0000
+42B7:080808081008120822FE7C080818101824287E28024800885208490889280010
+42B8:100011FC200024004400FBFE104020404880FCFC040400045404540480280010
+42B9:1008103C21E024204420F820102023FE4820FC20042000205420542080200020
+42BA:100011FE204024404440F87C108420844884FD0405FC00085408540881FE0000
+42BB:104010402040247E4482F884112022204820FC50045000485488548481020200
+42BC:10101010201024904490F890109E20904890FC90049000905490549083FE0000
+42BD:10201020202025FC4424F824102420244BFEFC20045000505488548881040202
+42BE:102010202020242045FEF8201070207048A8FCA8052401245622542080200020
+42BF:102010202020242045FCF820102020204BFEFC20045000505488548881040202
+42C0:010000803FFC20043FFC2080211023E02040208827FC20444250444889440080
+42C1:10401020200025FC4400F80010F020904890FC900490009254925512810E0200
+42C2:080408441028121022287C440880100424447E44022800285210492889440082
+42C3:1008103C21E024204420F83C11E020204820FC3E07E00020542254228022001E
+42C4:100011FC210425044594F954115421244924FD54055401945504550481140108
+42C5:101010102090249044FEF890111020104810FDFE041000105410541080100010
+42C6:10401020202025FC4504F904110421FC4904FD00050001005500560082000400
+42C7:100011FC210425044504F90411FC21204920FD20052001105510550882040402
+42C8:08007F7C114432280C101228634604201FC0018006103FF80108112025104208
+42C9:1040102020202BFE4A02F404100020904890FC90048801085508550482040402
+42CA:1000100021FE24104410F81010902090489EFC90049000905490549083FE0000
+42CB:100011FC210425044504F9FC1120212049FEFD20052001105512554A81860102
+42CC:100011FE210025004500F9FC110421044904FD0405FC01005500550081FE0000
+42CD:1000100021FE24084408F9E8112821284928FD2805E801285408540880280010
+42CE:1000100021FC25044504F90411FC21044904FD0405FC01045400540083FE0000
+42CF:10801080208024FE4540F9401240207C4840FC400440007C5440544080400040
+42D0:10281024202428204BFEF220122422244A24FA280A280290AB12AA2A80460082
+42D1:100011FE202024204420F9FE112221224952FD4A058A010255025502810A0104
+42D2:100011F8200824504420F81013FE206248A4FCA0052002205420542080A00040
+42D3:1080108020F825084610FC2011FC20044804FC0405FC00045404540481FC0004
+42D4:100011FE201024104420F820106820A44922FE22042000205420540083FE0000
+42D5:081813E0304057FC904013F8020004201FC0018006103FF80108112025104208
+42D6:1020102020FC242445FEF82410FC20204820FCFC0420002055FE542080200020
+42D7:100011FE212025204520F9FC110421044904FD0405FC01205520552081FE0000
+42D8:1020102023FE28204820F1FC102020204BFEF87008A800A8A924AA2284200020
+42D9:100013FE210825084508F9F81108210849F8FD080508011E57E8540880080008
+42DA:100013DE204228424A52F14A114A204248C6F94A0A520042A842A842814A0084
+42DB:10201020212424A444A8F820102023FE4870FCA804A801245524562280200020
+42DC:100008FC3E44222822103E28224644209FC0018006103FF80108112025104208
+42DD:10401024222425084508F810104020404BFEFC88050801905460545081880604
+42DE:100011FC210425044504F9AC115421544954FD5405AC01045504550481140108
+42DF:100011F82008240845F8F9001104210448FCFC40042000A4AA8AAA8A84780000
+42E0:1028102421FE24204420F9FC1124212449FCFD24052401FC552455248124010C
+42E1:10201020205028884904F2FA102020204BFEF82009280124AA22AC2280A00040
+42E2:080C08F07E8008800EFE788808882908164808801F0002103FF8010815202210
+42E3:201020103F244044BEF8221032202A44FF7E221252104A547F52029214500820
+42E4:084008407F40087C3E840884FF04104422247C240904FF8408844904A8A81010
+42E5:100011FC2124252445FCF924112421FC4820FC2005FC00205420542083FE0000
+42E6:1080108020FE250046FCF88410A4209449FEFC840524011455FE540480280010
+42E7:100011FC2104250445FCF910111021FE4910FD10057C014455445544817C0244
+42E8:1040102021FC24004508F890100023FE4800FC0005FC01045504550481FC0104
+42E9:10001040239C2A044A04F39C120422044BFCFC9004900090549055128212040E
+42EA:2000277E450445049574E554265445549554F55405741554AE04A40484140408
+42EB:1080108020F825084610F9FC1024202449FEFC24042401FC5424542080A00040
+42EC:100013FC204028404BFEF0A0111022084C46F84008480264AA52AC5281400080
+42ED:1040102023FE28804904F3FE100221FC4904FDFC050401FC5504550481140108
+42EE:10201020205024884504FA0210F820204820FDFC0420012454A454A883FE0000
+42EF:104808443E7E23C022243E282212206A444688821F0002103FF8010815202210
+42F0:1FF010101FF010101FF010101FF01010FFFE11102248CF8602201FF009481320
+42F1:1020102020202BFE4820F124112421244AAAF87008A800A8A924AA2284200020
+42F2:100011F02110291049F0F04013F822484A48FBF80A480248ABFAA8428042003E
+42F3:1050105223DC245044D2FB4E100021FC4904FDFC050401FC5504550481140108
+42F4:100010FC2048243045FEF852109421104A30FC2005FE007054A8552482220020
+42F5:100011FC210425FC4504F9FC108021FE4A22FD220552010255FA540280140008
+42F6:100013FE2020244045FCF904110421FC4904FDFC0504010455FC540080880104
+42F7:00207E20247E18A4FF2829104A2898C6044008801F0002103FF8010815202210
+42F8:1008101C21F025104510F9FE1110217C4944FD7C0544017CA944AA44827C0444
+42F9:100013FE200029FC4904F10411FC20004BFEFA220A2203FEAA22AA2283FE0202
+42FA:108811C827082908492AF12A17AC21484B08FB880D540514A914A92481240142
+42FB:1020102023FE28204820F3FE128A22524AFAFA220A2202FAAA22AA22822A0204
+42FC:100011F82088249044FCF954112421544A88FC0005FC0154A954A95483FE0000
+42FD:21042104410447C4913EE10427C440249114F11407C41104A904A1C48E140408
+42FE:1000104023FE28884904F64210FC230848B0F8D00F3E00C2AB24A81880600780
+42FF:100011FC2124292449FCF124112421FC4800FBFE09200122A914A94881840102
+4300:10C41704212429144914F784112421144B94FB460D3C0504A904A90481040104
+4301:100013FE205028504BFEF252125223FE4800FC4007FE00885590546080D80304
+4302:100013FC220422044BFCFA0013FC22404A88FBFC0A241220ADFCA420882013FE
+4303:1082108222A229CA488AF3EA122A222A4BEAFA2A0A2A03EAAA22AA2282AA0244
+4304:11FC102021FC25244554F904112C2020483CFC2005F800885450542080D80306
+4305:1020101021FE2510457CF91411FE2114497CFD10057C0144A944AA44827C0444
+4306:1020104023FC2A244A24F3FC122422444BFCF84008A800B4A93CA9228222041E
+4307:1020102023FE28204BFEF242148C21F04820F8440BFE0022A928AA2484A40040
+4308:100011FC210429FC4904F1FC100023DE4842FA52094A00C6AB5AA842814A0084
+4309:100013FE22522A524BFEF000100023FE4820F820093C0120A920A92087FE0000
+430A:1008103C23C028044A44F12811FC22204820FBFE08200124A924A92481FC0004
+430B:1088108823FE28884820F050108821044AFAFC00040001FC5504550481FC0104
+430C:100013DE20422A52494AF2521042202049FCFD04050401FC5504550481FC0104
+430D:1088108823FE248844F8F82011FC212449FCFC2005FC002055FC542083FE0000
+430E:00407CF8554854307DCE54F854887CF8044008801F0002103FF8010815202210
+430F:1040102023FE2A424828F29412AA24CA48F8FB0008200124A924A92481FC0004
+4310:100E13F020442A244908F3FC120423FC4A04FBFC0A0403FCA890A91082120C0E
+4311:100013DC22942BD44A54F3C8128822944BE2F800082001FCA820A82083FE0000
+4312:1040102023FE22504A50FBFE125222524BFEFA000A9212D4AA98A49284D2088E
+4313:20783F48404CBE802A78FF284A107F28044408801F0002103FF8010815202210
+4314:100013FE22002A7C4A44F244127C22004AEEFAAA0AAA02AAAAEEAA0083FE0000
+4315:2040202047FE44909490E49027FC449094D8F5B805B416D4A892A89090900090
+4316:10A0109021FE2B2049FCF12011FC212049FEFD00042003FE547054A883260020
+4317:2100210043FC46A89AA8E2A827FC42A892A8F2A80FFE1000AAA8A25484540000
+4318:082049202A3E7F4849485DA86B104928454608801F0002103FF8010815202210
+4319:1088108821FC24884488FBFE102021FC4924FDFC052401FC5400548881040202
+431A:100013FE205028504BFEF252125223FE4924F8A80BFE0070A8A8A92486220020
+431B:10001E0C22F05420284410F82810FF2400FE7E1200507E5400927F1242507E20
+431C:10501252215428504BFEF088105023FE4820F9FC082003FEA8A8A92486220020
+431D:2110211047BC411093B8E5542912400093F8F00007FC1040AA48A44489420080
+431E:10201020205024884504FAFA1000200049DCFD54055401DC5488548881540222
+431F:101013C8227E2A404A62F3D41200223E4BC8FA480E7E0248AA48ABC882480008
+4320:02907FD0421E5EA242885D0855485ED4846208801F0002103FF8010815202210
+4321:109013FC22942BFC4A94F3FC100023FC4800FBFC0A0403FCA908A89087FE0000
+4322:100011FC20202BFE4A22F1AC102021AC4850F8C80B2600F8A808A8D080200010
+4323:1108110821EE2A944842F01011FE210248F8FC8804F8008054FC548480FC0084
+4324:200027FC424844449FFEE44426EC455496ECF44406EC1554AEECA44484540408
+4325:103E17C0224421284BF8F84017FC20004BF8F8080BF81008ABF8A544852A08FA
+4326:100013DE20422A52494AF252109021084BFEFD1009FE0110A9FEA91081FE0100
+4327:102013FE202029FC4800F3FE100221FC4820FBFE080003FEA804ABBE82A4038C
+4328:1088108823FE28884910F1DE125225544A88F9740A0201FCA820A92482220060
+4329:110817FE210828004BFCF294129423FC4828FBFE0A200324AAA8AA92842A08C6
+432A:13DE125223DE2A524BDEF242127A228A4B12FADA0A8A02DAAA8AAAFA820A0204
+432B:13D0129023DE2A684BC4F28413F8210849F8FD0805F8010855F854908112060E
+432C:1110109023DE28104A5EF18213DE20104BDEFA500BDE0250ABDEAA50825202CE
+432D:1088108823FE28A84890F1FE112023FC4D20F9FC092001FEA900AAA482520452
+432E:11FC102023FE2A2249ACF02011AC2000489EFBF2089E01D2AABEAC92809E0092
+432F:108813FE20882BDE4A52F3DE10A0209049FEF9200BFC0520A9FCA92081FE0100
+4330:13FC110821F8290849F8F10E17F820084FFEFA940B9C0294AB9CAAD687BC0084
+4331:40807FFC48008FF8A000EFF848084FF8A100FC9C15D45C14555C5C9695D62C22
+4332:108813FE208829F04820F3FE102021FC49ACFD7405FC002055FC542083FE0154
+4333:27FC224847FC4C4696ECE55426EC455496ECF454040817FCA840A3F8805007FC
+4334:40807FFC48008FF8A000EFF848084FF8A220FD5C17F45C9455DC5C9697F62CA2
+4335:13FE120223FE2A924A54F29212FE22AA4AFEFB220AFA02AAAAFAAA2285FA0004
+4336:101010102010241045FEF810103020304050FC50409001101C10E01040500020
+4337:102010202020242045FCF924112421244124FDFC412401241D24E12441FC0104
+4338:10201020202025FC4420F84013FE20404080FDFC400400881C50E02040100010
+4339:100013FC220422044A04FAF4129422944294FA9442F402941A04E20442140208
+433A:100013FE2088248844F8F888108820F84088FC88408E03F81C08E00840080008
+433B:100013DE204220424A52F94A114A204240C6F94A425200421842E042414A0084
+433C:110410842088241045FCF9041104210441FCFC50405000901C92E112420E0400
+433D:1008103C23C020444A24F9281100202043FEF87040A800A81924E22244200020
+433E:1020102023FE20204820FBFE128A225242FAFA22422202FA1A22E222422A0204
+433F:100013FE200021FC4904F90411FC200043FEFA22422203FE1A22E22243FE0202
+4340:10901290229C22A04AD0FA88128820804000FBF842A802A81AA8E2A84FFE0000
+4341:10881448225020FC4820F850169422384250FA98423402541A90E22045FE0800
+4342:200020FC3C20502090201020FE2011FE10205420542054205C20642004A00040
+4343:000801FC7E0022081108111008001FF821000100FFFE0100210821083FF80008
+4344:202020203C205020903E1020FE20102011FC5504550455045D04650405FC0104
+4345:202020203C50505090881124FE12101011FC5404540854885C50642004100010
+4346:204020203C2051FE91021204FE00100011FE5420542054205C20642004A00040
+4347:2004201E3CE0500090101008FEFE100210045408541054205C4064A0051E0000
+4348:200021FC3C205020912410A4FEA8102013FE5420542054205C20642004200020
+4349:200020003CFC508490841084FE84108410FC5484540054485C44648404820102
+434A:204020203C2051FE90001088FF04120210885488545054505C20645004880306
+434B:2008203C3DE0502091FE10A8FEA810A811FE54A854A855FE5C20642005FC0000
+434C:204020203CFC500090881048FE5011FE1000540054FC54845C84648404FC0084
+434D:1000FE7810487C480048FE8682007CFC20443C445028FE28101054287C440182
+434E:408843FE7888A02023FE2250FBFE225223FEAA80AAFEAA80BAFECC020AAA0004
+434F:00003FF824482448244824483FF8200820082008200820082008200820282010
+4350:00007FFC444444447FFC00003FF8010001000100FFFE01000100010001000100
+4351:00003FF822282AA824482AA8312800003FF801000100FFFE0100010001000100
+4352:00007FFC444444447FFC010001007FFC03800540092011102108C10601000100
+4353:00007FFC444444447FFC00003FFC0040104020403FFE01400640184061400080
+4354:00007FFC444444447FFC020002007FFC0400048008801100222044108FF80408
+4355:00007FFC444444447FFC000000F03F00210021003FFC208020402A243114210C
+4356:00007FFC444444447FFC08001FF020105F90109010901F901050102410040FFC
+4357:00007FFC444444447FFC020001007FFC040008201FC0008003200C103FF80008
+4358:00007FFC444444447FFC01001110092005407FFC0540092011102108C1060100
+4359:00007FFC44447FFC10003FFC40009FF012101110FFFE221021103FFC00100060
+435A:00007FFC444444447FFC01001FF010101FF010101FF011081090126014181806
+435B:00007FFC444444447FFC00003FF821082FE8210827C8244827C820083FF82008
+435C:7FFC44447FFC090008801FFC108030805FF8908010801FF8108010801FFC1000
+435D:7FFC44447FFC000001047D9809603118C50602001FF010101FF010101FF01010
+435E:7FFC40044AA444444AA400500048FFFE00403E4022243E2800120E2A70C60302
+435F:7FFC44447FFC00002448238824483FF81010220847E40820144003801C70E00E
+4360:7FFC44447FFC01000080FFFE0440139014501FF001007FFC44444FE44424400C
+4361:00007FFC44447FFC00803FFE22203FFC22243FFC284028482F7048444B448C3C
+4362:00007FFC44447FFC10003FFC4AA00AA07FFC0AA00AA07FFC0000248822444244
+4363:7FFC44447FFC00003FF801007FFE41029D7400003FF821083FF821083FF82008
+4364:00007FFC44447FFC0100FFFE02887D7025484D6690101FF010101FF010102010
+4365:00007FFC44447FFC00007FFE40005F3C44107F7E4E345552609044F84480BFFE
+4366:7FFC44447FFC100008287F24147E494855C87F7E08487F7E514855485D7E4340
+4367:10881048505050007DFC5020902010FC1C20F02051FE10201020102010201020
+4368:442024202820FDFE102010207DFC11241124FD24112411342128202040208020
+4369:444024402840FE8010FE11087E8810881088FE50105010202050208841048202
+436A:442024202820FDFE102010207C2011FC1070FCA810A811242124222240208020
+436B:442024102810FDFE110212047C8010881090FCA010C0108220822082407E8000
+436C:440025FC2820FC20112410A47CA8102013FEFC20102010202020202040208020
+436D:440024FC2884FEA4109410847C8413FE1104FF441124110421FE200440288010
+436E:445024502850FD5210D410587C50105810D4FD5210501050209220924112820E
+436F:4440244028FCFD04120811FE7D00117C1144FD441154114821422242423E8400
+4370:440025FC2904FD24112411247DFC11241124FD54114C118C2104210441FC8104
+4371:442024202850FC88110412FA7C20102013FEFC20112811242222242240A08040
+4372:88004840539CFA042204239CFA04220423FCF89020902090209041124212840E
+4373:88004BDE5042F94A2084214AFA5224202000FBDE205221522094414842548422
+4374:881C49E05020F82023FE20A8F92422422040FBFE2088210820D0403040488184
+4375:4440244028F8FD08101011FC7C24102413FEFC24102411FC2024202040A08040
+4376:442024202BFEFC2011FC11247DFC112411FCFC20107010A82124262240208020
+4377:4440244029FCFC8413FE10007DFC110411FCFC2013FE1020222023FE40208020
+4378:442824242BFEFC2011FC11247DFC112411FCFD24100813FE2088204840488018
+4379:4420244029FCFD0411FC11047DFC110411FCFC28102413FE2050208841048602
+437A:8820482051FCF92421FC2020FBFE222223FEF8202040202422A2428A44788000
+437B:88004BDE5252FBDE22102252F9CE20002088FBFE2088208823FE408841048202
+437C:88004BDE5088FAA823FE2188FADA24A621F8F908210821F82108410841F88108
+437D:88004BFE5222FACC224423EEFA4422EE2354FA4422102290229E449044908BFE
+437E:00007EEE2422242224AA24662422FF222426246A24B224222422242244AA8444
+437F:00007EFC224412241A3462C4020400007FFC010001003FF801000100FFFE0000
+4380:0014EE1222122210AAFE66902292229226926A94B29422B422CA228AAA164422
+4381:100011DC10441044FF5410CC104410447C4C44D44564444444447C4445540088
+4382:0040EE4022FC2284AB0466F42294229426F46A84B294228822822282AA7E4400
+4383:100011DC10447C44555454CC7C445444544C54D4FF6444444444444455544888
+4384:0000FDDC24442444255424CC54444844804C7CD445644444444444447D544488
+4385:100011DC20447C44455444CC444444447C4C44D44564444444447C4445540088
+4386:00007EFC224412241A3462C4030402800C603218C1061FE00020064001800040
+4387:100021DC7C444444655454CC5444FC44444C64D4556454444444444455548888
+4388:0020EE2022FC22A4AAA466FC22A422A426FC6A20B22422182212226AAB864402
+4389:000CEE0A220822FEAA8866882288228A26EA6A8AB28C228C228A228AAA964522
+438A:100010EE1E22222262AA9466082214222226416ABEB22222222222223EAA2244
+438B:080028EE28223E2248AA0866FF22002200263E6A22B2222222223E2222AA0044
+438C:0000EE7C22442244AA446644227C221026106A50B25E225022502270AA9E4500
+438D:0028EC2425FE2420B4206DFC2524252425FC6D24B52425FC25242524B524490C
+438E:0000EDFE24A024A8B4A86CE824A824A824A86CE8B4A824AA24BA25EAB4264820
+438F:080008EE1422222251AA88667E2202220426086A7EB2422242227E2242AA0044
+4390:100011DCFE4410447D5444CC7C4444447C4C54D41164FE441044104411541088
+4391:0000EEFC22042204AA7C6604220422FE26106A92B254223822542292AA504420
+4392:0048EE44225E23E0AA286612226A239626486A5EB3E0222422282212AA6A4586
+4393:0010EE1022DA2254AA5466922350222026FE6A82B28222FE22822282AAFE4482
+4394:0028EC2427FE2420B5FC6D2425FC252425FC6D24B40827FE24882448B4484818
+4395:08202AA44D28145022887FFE400280043EF8020812480A28124822880A280410
+4396:440024EE2822FE2292AAD666BA229222FE26006A7CB244227C2244227CAA4444
+4397:060078EE1022FFA222AA5D6694A21C2200267F6A41B25D2255225D2241AA4344
+4398:08007F7E0912FF92095A7F360812AA92EB9688BAFFD28892EB92AA92AA9208B6
+4399:200011DCFE4482447D5454CC98447C44C44C7CD445647C4444447C4429544488
+439A:0088EDDC248825DCB4886DDC248825FC24046CFCB40425FC24202554B54A4A3A
+439B:020002083FD00220FFFE02000C703F84C80407FC00001FF0101010101FF01010
+439C:101012107E12147E1414FE1408FE100820307E22A06422B82D223022201E0000
+439D:02203FC00280FFFE02200FC03408C3F800007EFC224412240A1412246AD40408
+439E:010001081FD001207FFC02000FF03810CFF008100FF000003FF8000800080008
+439F:100013FE10201020FC4025FC2554255425544954295411542954454481140108
+43A0:200023FE20202040FDFC25542554A5546554255435442D16250A440243FE8000
+43A1:0000FFFE020004003FF82488248824A82010010011101120228004401830E00E
+43A2:104010401080FCFE11007A0010FCFC0810103820344054809102110210FE1000
+43A3:100810481128FD28112879081108FD0811083908354855949114102210421082
+43A4:100011FC1104FD0411FC79001100FDFE1102397A354A554A927A120214141008
+43A5:100010501048FC84112478201050FC8811063AF8348854889088108810F81088
+43A6:102010A410A4FD28105078881104FC24102038A834A855309050108811041202
+43A7:1040102010FCFC00108878481050FDFE1000380034FC54849084108410FC1084
+43A8:1020102013FEFC50108879241222FDFC112439FC352455FC90221022101E1000
+43A9:109210921124FE48112478921092FC0011FE3922352255FE9122112211FE1102
+43AA:100011FC1104FDFC110479FC1000FDFE10083BFE340855089088100810281010
+43AB:105011241154FD0411FC78501088FD4410783888348855509020105010881106
+43AC:100013FE1252FE5213FE78201020FDFC1020382037FE54409088110413FE1102
+43AD:101010501250FD7C1090781010FEFF00117C39443544517C5144910012FE1400
+43AE:1040102011FCFC88105079FC1104FD2411FC392435745554915411741104110C
+43AF:1088108813FEFC8810F8782011FCFD2411FC382035FC542093FE105010881306
+43B0:1142115C13F0FD501150795E13F4FC1411D43954355455D49154115411E41004
+43B1:200023FC2294FA9423FC71102252FBDC201273CE6A40A3D2225C23D0225222CE
+43B2:0000FF0024FC24043C08241024203C20244024402E80F48244820482047E0400
+43B3:0000FF7C244424443C44247C24443C442444247C2E44F4444444048404940508
+43B4:0048FF48244824483CFC244824483C4825FE24482E48F4484448048804880508
+43B5:0040FF20242824083C08244824543D52255225602E60F44444C40544063C0400
+43B6:0020FC20482049FC79244924492479FC492449244D2479FCC924082008200820
+43B7:0020FD20492049FC79204A2048207BFE487048A84CA87924C9240A2208200820
+43B8:0000FDFE4820482078FC4844484479FE480048004CFC7884C884088408FC0884
+43B9:00F83F0011100920FFFE09203118C1063FF808200FE008200FE0083EFFE00020
+43BA:0082FC824A824BEA7C8A488A4FFA788A4BEA4AAA4EAA7AAACAA20AE2088A0884
+43BB:0000FDFC492449247974492449FC7904497449544D547974C9040A040A140C08
+43BC:0000FDF84808480879F8480848087BFE48204A224D7478A8C9240A2208A00840
+43BD:001CFDE04920492079FE4910494A7986480249FC4D047904C9FC0904090409FC
+43BE:0020FC204850488879044AFA480079FC495449544DFC7954C95409540904090C
+43BF:0008FCC84B084908792A492A4BAC794849084B884D547914C914092409240942
+43C0:0082FC824BE24882788A4BEA4AAA7AAA4BEA488A4DCA7AAACCA20882088A0884
+43C1:0040FC204BFE4A42782049FC488878504BFE48204C2079FCC820082008200820
+43C2:00A0FD2C4924492479AC4924492479FC482049FC4C887850C820085008880B06
+43C3:0000FDFE4902480078FC488448FC788448FC48204C1079FEC800084808840902
+43C4:0040FC204BFE4A8A79044BFE4840788849FC48244C2079FCC82008200BFE0800
+43C5:0080FC8849EE492A7AAA49444884797A4A0048004DFE7820C8A809240AA20840
+43C6:0050FC504BFE48507BFE4A524BFE7A524BFE48004DFC7904C9FC090409FC0904
+43C7:0000FDFC485049FC7954495449FC780049FC48004FFE7820C8A809240AA20840
+43C8:0108F9085254525474BC57085110722454BE578A580870ACD56A154A14281010
+43C9:0000FDFC490449FC790449FC4888795449DC48884D5479DCC80009A809540A54
+43CA:0110FC904BDE48107A5E49824BDE78104BDE4A504FDE7A50CBDE0A500A520ACE
+43CB:01003FF80108FFFE01083FF8054009203118C10625781348A178A5441D3C0100
+43CC:084008201010200840069FF0101010101FF0101010101FF01010101010501020
+43CD:02000400082010103FF8100800001FF010101FF010101FF01010101010501020
+43CE:00003C0024F0249024903C90249024D024B03C902490249224924512550E8A00
+43CF:00003DFC2420242024203C2027FE242024203C20242024202420442054A08840
+43D0:00203C20242025FC24243C242424242427FE3C20245024502488448855048A02
+43D1:020004000FF81210692004C003000C0071003FF8228824482108228824482018
+43D2:00083C882488248824883CFE2480248024803CFC248424842484450455048A04
+43D3:00003CFC2400240034002DFE245024502C5034502450245224524492548E8900
+43D4:00003DF82448244824483C48244825F824883C88248824882488448857FE8800
+43D5:00083C3C25E0242024203C20242027FE24203C20242024202420442055FC8800
+43D6:00043DE42424242424243DE42504250425043DE4242424242424442455448884
+43D7:00803C8024FC250026003CF82400240025F83C0824082408240A440A54068802
+43D8:00003DFE2528252825283D2825282528252A3D2A254A25462580450055FE8800
+43D9:00203C20242025FE25223E242420242024503C50245024502490449255128A0E
+43DA:00203C20242024A824A43CA22522252026243C24242824082410442054C08B00
+43DB:00403C40248024FC25043E042484244424443C14242424442584440454288810
+43DC:00007BFC4884488848887890489C488449447944492849284A104A284C449982
+43DD:00203C20242025FC24203C4027FE244024803DFC240424882450442054108810
+43DE:00203C20242027FE24203C20242025FC24703CA824A825242524462254208820
+43DF:00403C202428240824083C482454255225523D602660244424C44544563C8800
+43E0:00407820482048004BFC780048084908490878904890489048A048204BFE9800
+43E1:00003CFC2400240024003DFE2420242024A83CA4252425222622442054A08840
+43E2:00103C10241024FE24923C94249024FC24A43CA424A824A82490452855448A82
+43E3:00003CF82488248824883CF82488248824883CF8248824882488448857FE8800
+43E4:00003DFC2404240425F43C04240425F425143D1425F425142404440454288810
+43E5:00203C20242025FC25243D2425FC252425243D2427FE25042504450455148908
+43E6:00083C3C25E0242024203FFE2420242024203DFC250425042504450455FC8904
+43E7:00203C20247C248425483C302420244825903C3E244225A42418441054608980
+43E8:00403C8025F8250825083D0825F8250025003D0025FC25042504450455FC8904
+43E9:00203C202450245024883D0426FA240024003CF8248824882488448854F88888
+43EA:00003DFE2488248824883CF82488248824F83C882488249E27E8440854088808
+43EB:009078904890491049FE7B104D10493849387954495449924910491049109910
+43EC:00203C202448248425FE3C122490249024FE3D10241025FE2410441054108810
+43ED:00207920492049FC49207A2048204BFE487078A848A8492449244A2248209820
+43EE:00403C4025FC244424443C842494250824003D02248424482400444854848902
+43EF:0020782048204BFE48207820482049FC4840782048A44A824A8A4A8A4C789800
+43F0:00007BFC4844494449447A84489449084A40782048A44A824A8A4A8A4C789800
+43F1:000079FC4904490449FC7900490049FE4902797A494A494A4A7A4A024C149808
+43F2:01083C88249025FC24243C2425FC252025203DFE246224A2252A462454208820
+43F3:0104790E493049204FE07920493E496449A47F24492449244924492449449B84
+43F4:00203D2424A424A824203DFC2504250425FC3D04250425FC2504450455148908
+43F5:0090788848804BFE48A078A848B048A448A878B04924492A49324A224ADE9C00
+43F6:01103D12251425D825103D122552258E25203C2025FC24202420442057FE8800
+43F7:00003DFC250425FC25043DFC2400240025FC3C20242027FE2420442054208820
+43F8:00007BFC4840484049F8788848884BFE4800780049F849084908490849F89908
+43F9:00003DFC2504250425FC3D04250425FC25043D0425FC24502490449255128A0E
+43FA:00403C4024FC248825503C2024D8272624F83C2024F8242027FE442054208820
+43FB:1020102020204420FEFC02207C20442045FE7C2044207C48448445FE54824800
+43FC:00483C44245E25E024283C12246A259624483C5E25E0242424284412546A8986
+43FD:00403C2025FC240025083C90240027FE24003C0025FC25042504450455FC8904
+43FE:00203C2025FE242024FC3C4025FE248825243E2224F8242025FE442054208820
+43FF:104008403E7E228823503E20205841869FF010101FF010101FF0101010501020
+4400:00203C2025FC245024883D0427FE240825E83D28252825E82528440854288810
+4401:00007BFE4840488049447A2448684AB049307AA8486848A449224A2048A09840
+4402:000079F84808480849F8780848084BFE48207A22497448A849244A2248A09840
+4403:00007BFE4A024A1A4AE27A224A224BFE4A227A724AAA4B264A224A224BFE9A02
+4404:00403C40247C248425083E00242025CE25023D0225CE25022502450255FE8902
+4405:00003DFC2504250425FC3D002540257C25903D1025FE25102528452855448A82
+4406:0008783C4BC048444A247928490048204BFE787048A848A849244A224C209820
+4407:00803C8024FC255426543C942524245424883C0025FC250425FC450455FC8904
+4408:004078404BFC4840484079F8490849F8490879F8490849F8490849084FFE9800
+4409:00923C922524264825243C922492240025FE3D22252225FE2522452255FE8902
+440A:00003DFC2504250425FC3D04250425FC24003D1225D42518251045525592890E
+440B:00907890490849484A447C9249084BFC4844782048A44A824A8A4A8A4C789800
+440C:044004403FF824483FF82448FFFE10102008DFF610101FF010101FF010101030
+440D:00203C2027FE242024203DFC2400240025FC3D04250425FC2400448854508BFE
+440E:000079FC4904490449FC7904490449FC48007BFE48204920493C49204AA09C7E
+440F:00203C2027FE242025FC3C4027FE248825043EFA2488248824F84488548888F8
+4410:008871C857085108512A712A57AC51485308738855545514591451245124B142
+4411:00483D48254827FE25483D482578250025FE3C2027FE247024A8452456228820
+4412:00003C4025FE248825043E4224F8270824903C7027BE244225A4441854608B80
+4413:00003DFE2410242024FC3C84248424FC24843CFC2484248424FC444854848902
+4414:00203C1025FE250225023DFE2500250025FE3DAA26AA24FE24AA44AA54AA8886
+4415:00003CF82488248824F83C0025FE248824F83C8824F82488249E47E854088808
+4416:00007BFC4A044A044BFC7A204B244AA84A207BFE4A704AA84AA84D244A229820
+4417:00203C2024FA242424283DFE2420244024FC3D442644247C24444444547C8844
+4418:001E7BE048444924488879FC484048404BFE788048FC494449284A1048689986
+4419:008878884BFE488848F8782049FC4924492479FC48204BFE4820482048209820
+441A:00007BDE4A524A524A527BD24A524A524A527BD24A1A4A944A504AB04B109810
+441B:00203C2025FE245024883D0427FE248824F83C8824F82488249E47E854088808
+441C:002078204BFE482049FC790449FC490449FC790449FC49044BFE488849049A02
+441D:00203D2424A8242025FC3D04250425FC25043DFC2504250425FC440054888904
+441E:00007BDE484248424BDE7A104A104BDE48427A52494A494A4A5248424A949908
+441F:008878884BFE488849FC78884BFE482049FC792449FC49244BFE490449149908
+4420:00883C8827FE24A824103FFE2480248024FC3C0024A824A824A844AA552A8A06
+4421:02000100FFFE02847D78255025484D6401003FF8228824482108228824482018
+4422:0080788049FC4A44495479F4488449284A9079FC4A444D5449F4488449289A10
+4423:00003CF82488248824F83C0025FC250425FC3D0425FC250425FC445054888904
+4424:00843C44244825FE24203CFC242025FE24403C8024FE25102610441055FE8800
+4425:0090788849044A424C8879FC480448004BDE78424A52494A4A524842494A9884
+4426:00203C2024FC242024203DFE2440248425FE3C0225FC25542554455457FE8800
+4427:004078204BFC480049F8790849F848004BFC7A044AF44A944AF44A044A149A08
+4428:1000FE7810487C480048FE8682007CFC00447C4444287C2844107C2844444D82
+4429:00203D242524252425FC3C0027FE240025FC3D04250425FC2488445057FE8800
+442A:00A0789049FE4B204DFC792049FC492049FE79004BFC4888489E49024A0A9C04
+442B:012479244A244C244954794A4A924E104A107A504A5C4A504A504AB04A9E9B00
+442C:009078904FFE48904BFC7A944BFC4A944BFC780049F8490849F8490849F89908
+442D:02A872A857FC52A852AA74E6580057FC5444704053F85248524852485258B040
+442E:004078204BFC4800490878904BFE4A204AA07AFC4B204A204AFC4A204C2099FE
+442F:00003DFC252425FC25243DFC2440248825F03C20244427FE2422452456228860
+4430:0120793C49444AA84A107EA84AC64ABC4AA47ABC4AA44ABC4A244A244A249A2C
+4431:004078204BFE488848507BFE4A224AFA4A227AFA4A8A4A8A4AFA4A024A0A9A04
+4432:00007BDE48424A52494A7A524842482049FC7904490449FC4904490449FC9904
+4433:00403C4024F8250826103DFC2524252425FC3D24252425FC24004554552A8A2A
+4434:7DFC44207D2045FE7C5048525492650E1FF010101FF010101FF0101010501020
+4435:00883C8825FC248824883FFE242025FC25243DFC252425FC2400448855048A02
+4436:00007BDE48884AA84BFE79884ADA4CA649F87908490849F84908490849F89908
+4437:00007BDE4A524A524BDE780049FC492449FC792449FC48204BFE482048209820
+4438:00203DFC242427FE24243DFC242027FE24003DFC252425FC252445FC54008BFE
+4439:002079FC48244BFE482479FC48204AAA4BAE7A224BFE4A224BAE4AAA4AAA9C22
+443A:00007BFE48504BFE4A527BFE480049FC490479FC490449FC48204BFE48209820
+443B:00207BFE482049FC490479FC482049FC488878504BFE482049FC482048209820
+443C:00807BDE488A49CA488A7BD248A64840488879F048244BFE482249244AA29840
+443D:008878884BFE4888488878F848204BFE4A227B324AAA4B764A224A224A2A9A24
+443E:00003DFC255425FC24203DFC242027FE24883C5025FC242027FE442054208820
+443F:004078804BFE4A224AAA7A224BFE4A724AAA7A0248204BFE4820485048889B06
+4440:00107BC84A7E4A404A627BD44A004A3E4BC87A484E7E4A484A484BC84A489808
+4441:3AB821083AB82288393822887FFE40029FF410101FF010101FF0101010501020
+4442:01407A4C4A644A444B4C7A644AA44BAC4AA47AA44FFE4800491049084A049C04
+4443:00883DFE248825FE35022CFC240025FE2C20345025AA245C25AA444855A88810
+4444:00403CF8248824F824883CF8240025FC25243DFC252425FC240047FE54888908
+4445:00887BFE488849FC4954795449FC48004BFE7A4248F848884948483048609B80
+4446:010878904BFC484049F878804BFC494849FC7B0A4DF8490849FA4934498C9902
+4447:00427B9C4A104BDE4A947A944C204BFC4A047BFC4A044BFC4A044BFC49089A04
+4448:012479744A584ADA4BFE79544ADA4BFE48A278204BFE487048A849244A229820
+4449:E040BFFEA400A7FCA000E7FCA404A7FCA040EE4EABEAAEAAAAAEAE4A2AAA7710
+444A:0010787C4A54497C491078FE48444B7C4944797C4944497C492849444A809C7E
+444B:00207BFE480049DC495479DC48884BFE48887BFE48884BFE489449884AA498C2
+444C:03DE7A524BDE4A524BDE7A224AFA4A224AFA7AAA4AFA4AAA4AFA4A724AAA9A26
+444D:03DE7A524BDE4A524BDE7A524BDE498C4A5278404FFE48884990486048D89B04
+444E:0148794C4AAA48084FFE79484B68494A4B6A794C4B6C4948496A4B9A48269842
+444F:00887BFE48884BDE4A527BDE48A0489049FE79204BFC4D2049FC492049FE9900
+4450:00407E40484048FE48807E804310421042587E5448944892491248107E500020
+4451:00287EAA486C482848FE7E44422842FE42107E7C481048FE481048287E440082
+4452:0000FE0011FC2024282444A4FEA412A4112410247C24104410441E84F1144208
+4453:08207FFC08200FE008200FE008207FFE4002BFFC08201FF001001FF001007FFC
+4454:0020402098208BFE8820882089FCD9248924892489248934F928882000200020
+4455:060038F820083EF820083FF800003FF821083FF821083FF8210A410A41068102
+4456:002040209BFE882089FC88248BFED82489FC88208920893EF9208AA0027E0400
+4457:000041F8990889F8890889F88800DBFE890089FC8A548C94F9248A4400A80110
+4458:0108408898908BFC884089F88840DBFE8880890089FC8A20FC20882003FE0000
+4459:08001CFC708410841084FDFE108410847C8445FE4484448444847C8444940088
+445A:08001CFC708410841084FCFC108410847C8444FC4484448444847C8445140208
+445B:08041C1E71F011101110FD10111011FE7D10451045104508450A7D4A45A60112
+445C:08481D48714813FE1148FD48117811007DFE442047FE447044A87D2446220020
+445D:00003EF8228822883EF80000FFFE902210203DF84420A520192011FC20204020
+445E:3FFC24902960261038882290256022102C083FFC10103EFC4210149018FEE010
+445F:0F10F020117C8944427C0044FF7C810042FE771092105A7C2F10221042FE8200
+4460:080011FC3E04220832102A202A20FE20222032202A202A20222042204AA08440
+4461:100021F87C8844C864A854A85488FC5044506450542054204450448855048A02
+4462:100020007DFC4490649054905490FC90449064905490549244924492550E8A00
+4463:080410043F082110292025442504FF08211029222542250421084110452082C0
+4464:082010203E50225032882B442A22FE20220033FC2A042A08220842104A108420
+4465:080010FC3E44224832482A502A5CFE44224432442A682AA8229042984B248442
+4466:084010403E8022FC33042A042AF4FE94229432942AF42A94220442044A288410
+4467:1088208878884908697E5B084D08F94849284928690859084908490849289910
+4468:108020807CFE450066205520552CFD7447A46524553455284522450254FE8800
+4469:081010103E10221032FE2A102A10FE10227C32442A442A44224442444A7C8444
+446A:082010203E50225032882B042AFAFE00220032F82A882A88228842884AF88488
+446B:088410483E0022FC32482A482A48FE4823FE32482A482A48224842884A888508
+446C:085010503E50235232D42A582A50FE5822D433522A502A50229242924B12860E
+446D:100021007CBE4488640856085508FD484448648857885488448844FE54808800
+446E:100020F87C884488648854885526FE2045FE6420547054A84524462254208820
+446F:110820887C9045FC6424542455FCFD20452065FE546254A2452A462454208820
+4470:081010103E90229E32902A902BFEFE00221032922A922B14220442084A3085C0
+4471:104020207BFE4A026D04590049DEFA524A524B526C9A5894491049124A129C0E
+4472:082010203E3E222032FC2A842AFCFE8422FC32A42A202BFE222042204A208420
+4473:102020207C504488650456FA5400FDFC4554655455FC5554455445545504890C
+4474:084410443EFE224432442A7C2A44FE44227C32442A442AFE220042284A448482
+4475:100021FE7D02457A6502557A5400FCFC448464FC548454FC4484448454948888
+4476:081010103EFE2210327C2A102AFEFE00227C32442A7C2A44227C42444A548448
+4477:102020107DFE4502650255FE5500FD7E4542657E5542557E45424542554A8A44
+4478:082010103EFE228232002A7C2A00FE0022FE32102A102A54225242924A508420
+4479:104020207BFE4A2268A459284850F888490448F8688858884850482048D89B06
+447A:100023FC7A044A346BC45A444BF4FB544B544BF46A445A544BF44A944C069802
+447B:1108208878884BDE6910592049DEF94249444944695E59444A444A444CD49808
+447C:104020407CFE452264AA54FA5442FC94454864FE552256AA44FA444254948908
+447D:100021FC790449FC690459FC4800FBDE48424A52694A58C64B5A4842494A9884
+447E:10A0209079FE4B2069FC592049FCF92049FE49006BF859084890486049989E06
+447F:102020107BFE4A02688058FE4910FB204D7C49446944597C49444944497C9944
+4480:1110211079DE4AA86C4458884888F9084B7E4D08694859284908490849289910
+4481:100023DE78424A52694A5A524842F82049FC4904690459FC4904490449FC9904
+4482:109022907A9E4AA26AD45BA84894F8A44FFE4A846AA45A944A944A844C949888
+4483:101020507A50497C6890581048FEFB00497C49446944597C494449004AFE9C00
+4484:100020007BFE4A0269FC580048F8F88848F8480069FC592449FC492449FC9904
+4485:102021247CA845FC644057FE5488FD0447FE650455FC550445FC450455FC8904
+4486:110820887BE849106A9E5FD44864FBD44A544BD46A545BC84A484A544A649AC2
+4487:104020207BFE4A0269FC580048F8F88848F8480069FC592449FC492449FC9904
+4488:102021FC7C20448867FE548855FCFD0445FC650455FC550445FC448855048A02
+4489:108021007BFE4D5469545BFE4954F9544BFE490469DE5A444954489E49049A04
+448A:0440244022FC2288431040FCBEA410A420A43EFC0280028002820282147E0800
+448B:1040104010FC7C88551054FC54A454A454A4FEFC1080108028822482447E8000
+448C:0020FF20817C00447E88427C7E5442547E54107C0840FF4000422442423E8100
+448D:20401040FEFC0088451028FCFEA4A2A410A4FEFC20803C8024824482547E8800
+448E:24202420FF7C24441288FE7C245442548154247C2440FF4024422442443E8400
+448F:4440244028FCFE889310D6FCBAA492A4FEA400FC7C8044807C8244827C7E4400
+4490:2220FFA0227C7F4455887F7C0054FFD480D43E7C22403E4022423E42223E3E00
+4491:00000000000000001010081008200000FFFE0000000000000000000000000000
+4492:08200820FFFE0820082000003FF8000800480188060818086008000800500020
+4493:08200820FFFE082008200000FFFE0400040008001FF000100010001000A00040
+4494:08200820FFFE0820082000400440044004200820082010101010200840048002
+4495:08200820FFFE0820092001000100010011101108210421044102810205000200
+4496:08200820FFFE0820082000007FF0041004100410FFD00412040A040604020400
+4497:04400440FFFE0440080008001FFC200040009FE0002000C003000C0410040FFC
+4498:08200820FFFE08200820040004000FF01010282044400280010006C01830E00E
+4499:08200820FFFE08200820010001000100010001F80100010001000100FFFE0000
+449A:08200820FFFE082008200100010011101108210421144120004001800E00F000
+449B:08200820FFFE0820100010FC22044204FC040804100422044104FF0441280010
+449C:08200820FFFE08200920110011001FF8210041000100FFFE0100010001000100
+449D:08200820FFFE08200008181006600180066018186C240240018006601818E006
+449E:08200820FFFE0820092001003FFC2104410802800280048008821082207E4000
+449F:08200820FFFE082000001FF01010121011101010FFFE10102010201040508020
+44A0:08200820FFFE0820092001007FFC010001003FF801000100FFFE010001000100
+44A1:08200820FFFE082000007F08010801083F08200840087F08010801080A080408
+44A2:08200820FFFE0820082000000C0070FC4084408440844C847094408800800080
+44A3:08200820FFFE082000001FF0101010107FFC101010107FFC1010101010501020
+44A4:08200820FFFE0820082000003FF82008200820083FF82008200820083FF82008
+44A5:08200820FFFE082000007FFC010001003FF82108210821082128211001000100
+44A6:08200820FFFE082001F03E00020001007FF8006001800E003000480087FE0000
+44A7:08200820FFFE0820092001003FF8010001000100FFFE0400082010103FF81008
+44A8:04400440FFFE0440080008001FF8210041000100FFFE0280044008203018C006
+44A9:08200820FFFE0820000000F01F00010001007FFC054009203118C10601000100
+44AA:0820FFFE08200400082010103FF8000808200820FFFE08200820102020204020
+44AB:08200820FFFE08200000085008481040307C57C09040102010201014100C1004
+44AC:08200820FFFE0820082000003FF800000000FFFE010011102108410485020200
+44AD:08200820FFFE082000001FF0001000107FFC00000020FFFE0820042004A00040
+44AE:08200820FFFE082000007FFE400280040FE008200A20092009221022201E4000
+44AF:08200820FFFE082000007FFE420282041FE002200C2004200A2011222022401E
+44B0:04400440FFFE044000003FFE20002FFC2080208027F8208020802FFC20003FFE
+44B1:04400440FFFE04403FF0002000C07D040588095011202118C5060200FFFE0000
+44B2:04400440FFFE04401008101CFEE0122022202220643E15E0082214222222C01E
+44B3:08200820FFFE082000000FE008201020611C0100FFFE054009203118C1060100
+44B4:08200820FFFE0820040004007FFC08001FF028104FF088100FF0081008500820
+44B5:08200820FFFE0820100011F8FC082410242025FE442024201820182024A0C240
+44B6:08200820FFFE0820092001003FF821083FF821083FF8010800B001C20E32700E
+44B7:08200820FFFE082000F01F0001000100FFFE010001001FF0101010101FF01010
+44B8:08200820FFFE0820092002003FF82448244824482448244824482448FFFE0000
+44B9:08200820FFFE0820092001007FFC01003FF80100FFFE054009203118C1060100
+44BA:08200820FFFE0A20040008201FC0008003200C103FF801081110210845040200
+44BB:04400440FFFE04400800087C080449044904497C494049404F427942003E0000
+44BC:08200820FFFE0820044004403FF82448244824483FF82448244824483FF82008
+44BD:08200820FFFE082000003FF820082AA82AA8244824482AA82AA8200820282010
+44BE:08200820FFFE08200A200100FFFE02000500090418882850C8200A180C060800
+44BF:08200820FFFE08207FFE40029FF4101010101FF0101010101FF0101010501020
+44C0:08200820FFFE0820092001007FFC010001001FF000001FF0101010101FF01010
+44C1:08200820FFFE082001003FF801000100FFFE000000207FFC0820042004A00040
+44C2:08200820FFFE08200A200100FFFE00003FF800003FF800003FF820083FF82008
+44C3:04400440FFFE04401FF010101FF000003FF8210821083FF8200220021FFE0000
+44C4:08200820FFFE08204400280C11F02900C90019FE2910491089100A1052102410
+44C5:08200820FFFE08200820200C11F01100810049FE49101110E110221022102410
+44C6:04400440FFFE04401000100C11F0FD00110011FE1D10F1101110121052102410
+44C7:08200820FFFE082001003FF801000100FFFE0440244844448842084011402080
+44C8:04400440FFFE0440100010F8208841088A06100031F850889050102010D81706
+44C9:08200820FFFE082000007E7C2444244844507F48144424444454844814400840
+44CA:0820FFFE082000007FFC020002003FF004100810FFFE00001FF0101010101FF0
+44CB:08200820FFFE08202008103C13E082204A204BFE1220E2102212228A23062202
+44CC:08200820FFFE0820092001007FFC010001003FF80000010008844892481287F0
+44CD:04400440FFFE04401FF010101FF010101FF000003FF80100FFFE010001000100
+44CE:04400440FFFE04401080108014FC55045A045084904410442804240444288010
+44CF:08200820FFFE082000007FFC010003000D603118C1041FF0101010101FF01010
+44D0:0820FFFE082001007FFC044008203118C1063FF80100111011141FF4010400FC
+44D1:08200820FFFE0820200017FC91104110411017FE2110E1102210221024100810
+44D2:04400440FFFE044010001FF820085FC8924812481FC8124812481FC800280010
+44D3:0820FFFE0A2002007FFC02003FF80400FFFE08201FFC20204420822002A00040
+44D4:08200820FFFE082001081FD00120FFFE01001FF0082030C0CFFC008002800100
+44D5:08200820FFFE082023F01000100007FC7120112012241224141C280047FE0000
+44D6:08200820FFFE0A2001007FFE40028824121022081FF004100410081010A02040
+44D7:08200820FFFE08200440082011102208C44608201FF0011008844892481287F0
+44D8:0820FFFE0820000008401F6022505448084037FEC0001FF0101010101FF01010
+44D9:0820FFFE082000701F800100FFFE010009207924092809321922E91E01000100
+44DA:04400440FFFE0440100021F84108890811F83108510891F81108110817FE1000
+44DB:08200820FFFE082000003FF820083FF820802490249027F02080488848888FF8
+44DC:08200820FFFE08202008103C13E082204A204BFE1220E2102212228A23262212
+44DD:0820FFFE082000001FE0004001807FFC0100050002003FF824482448FFFE0000
+44DE:08200820FFFE092000803FFC200420043FFC20A020902FFC2120421044089806
+44DF:08200820FFFE082000003FF8210827C821082FE8200827C8244847C840288010
+44E0:08200820FFFE082001047D9809603118C50602001FF010101FF010101FF01010
+44E1:08200820FFFE0820282020003E7C484488440844FF4408441444227C41448000
+44E2:08200820FFFE082000003FF8210821082FE8210827C8244827C820083FF82008
+44E3:08200820FFFE0820FFFE010001007FFC41045144492455546594410441144108
+44E4:04400440FFFE044008001FF822484448088811082228041001004884481287F2
+44E5:0600010006C01830E44E3FF804401FF010101FF010101FF001007FFC01000100
+44E6:08200820FFFE0820044004403FF8244824483FF824482448FFFE082010102008
+44E7:0440FFFE044000003FF0002000C0793C4904496849107928014405000200FFFE
+44E8:08200820FFFE08207FFE400288041FF821000100FFFE0100210821083FF80008
+44E9:04400440FFFE04401020102011FEFC20102031FC388454885050902010D81306
+44EA:08200820FFFE08201FF010101FF010101FF008001FF822484488090812282410
+44EB:08200820FFFE092001003FF804400820FFFE00101F9010901F90001000500020
+44EC:08200820FFFE0820010001FC01003FF820083FF820083FF80100FFFE01000100
+44ED:08200820FFFE0820010432040C243224C9240824FFA408242A244904A8941008
+44EE:08200820FFFE08203E400240147E0888FF480A48185028504820085028881104
+44EF:0820FFFE09203FF801001FF001007FFC00001FF01210FFFE20903FFC00100060
+44F0:0820FFFE082000007FFC04403FF8244824483FF8010001003FF801000100FFFE
+44F1:0820FFFE08200440274C247024422F42F03E01007FFC054009203118C1060100
+44F2:04400440FFFE044009080890100013FC3204520493FC1090109011121212140E
+44F3:04400440FFFE0440000009F8110821F8450809F8192429284910094809860900
+44F4:0820FFFE08200000FFFE02003FF8248824A821100100FFFE028004401830E00E
+44F5:08200820FFFE082000001FF0101010101FF000007EFC4284428442847EFC4284
+44F6:04400440FFFE044008080808FF8808487F4849487F481C482A48490888280810
+44F7:08200820FFFE08A02100123C94804100437E15082108E1082108210821282110
+44F8:04400440FFFE044008007EF812202420182065FC08207E201220242018206420
+44F9:08200820FFFE092002800E603118DFE610201FE010201FE01008119014601810
+44FA:0820FFFE0820101008207FFC01003FF80100FFFE01007FFC028004401830E00E
+44FB:08200820FFFE08207FFE4002BE24002001FC7E4814C81430146A2586240243FE
+44FC:0820FFFE08201088108413FEFCA424A824B424A848B228A410AA2932452282DE
+44FD:04400440FFFE0440200010FCFE0400047C0400FC7C8000807C8044827C82447E
+44FE:08200820FFFE082020401248444420140860738020000400FFFE082007C07838
+44FF:0820FFFE082000003FE0044002807FFC444442845FF441047FFC410441047FFC
+4500:0440FFFE0440103813C0204027FC6150A248244620802FFE2110232020E02718
+4501:08200820FFFE082000007FFC04403FF824483FF801007FFC05401930E10E0100
+4502:0820FFFE0A2001007FFE420281043FF808200440FFFE01003FF8010001000100
+4503:08200820FFFE0820200011F8FD08090811F83908550895F81108110817FE1000
+4504:0820FFFE082000FC7F002208111020203FF841000100FFFE0100210821083FF8
+4505:0820FFFE082000007FFC00201F2011201F200000FFFC00201F2011201F200060
+4506:08200820FFFE0820440029FC112429FC492499FC282049FC8820082053FE2000
+4507:0820FFFE08200100210821083FF800007FFC00001FF010101FF008200440FFFE
+4508:0440FFFE04403FF801007FFC00001FF010101FF010101FF010101FF008201010
+4509:08200820FFFE08200C1C71E010201020FDFE307038A854A85124922210201020
+450A:08200820FFFE08200108FC9011FC109010907C9013FE10901C90F11041100210
+450B:04400440FFFE04401020102024207CA808A4112225227E280010542054C08300
+450C:0820FFFE082002001FF010101FF010101FF002007FFC08203118CFE601000100
+450D:08200820FFFE082000001FF811001FF011001FF011001FFC0004292444940008
+450E:08200820FFFE0820204017FC104003F87248124813F8115012481444284047FE
+450F:0820FFFE08200040224013F81440004077FC100013F8120813F8280047FE0000
+4510:04400440FFFE04402120111017FC80904064539C11202110E7FC20902064239C
+4511:04400440FFFE04400808144822285D0888C808287F0E08F82A084908A8881008
+4512:08200820FFFE0820008078404BFC5108609057FE480049F86908510841F84108
+4513:0820FFFE082020001040FE4000FE7C9001107C1001FE7C10441044107C104410
+4514:0820FFFE082001003FF80440FFFE00001FF010101FF010101FF004421842E03E
+4515:04400440FFFE0440002878244BFE482079FC492449FC792449FC49244924990C
+4516:0820FFFE0820000078404BF8504067FC51104A884CF4691052A0404041B04E0E
+4517:08200820FFFE082020881050FBFE0820102039FC5420942013FE102010201020
+4518:04400440FFFE0440200020F83C88508810F8FC88108854F854885C8875FE0400
+4519:08200820FFFE08201080288044FCB90412047C841044944450041E04E0284010
+451A:0820FFFE08203FFC20002FF820003FFC24482630240E2FF848084FF888080818
+451B:08200820FFFE082023FC204021F821083DF8210821F8250829F8300020900108
+451C:04400440FFFE04400020FC2049FC7924492479FC49244D24FBFE090409140908
+451D:0440FFFE044008442F7828422F3EF40008201FC003100C083FFC010415102208
+451E:0820FFFE0A2001007FFC020044442F88111022484FE400200100FFFE01000100
+451F:0440FFFE044000200C4070FC13081090FC6030903B3E544255A4901810601380
+4520:04400440FFFE044010201124FCA8102031FC390455FC910411FC110411141108
+4521:04400440FFFE044008001FE020207FF8A1083FF821083FF80000248822444244
+4522:0820FFFE0820145022880820145022881FF00000FFFE10001FF8000800500020
+4523:0820FFFE082003043C2404247FA416242504440C11001FF82100FFFE01000100
+4524:08200820FFFE0820000013FE20207C4045FC450445047DFC450445047DFC4504
+4525:0820FFFE082001003FF00110FFFC01103FF0092025482FE82388254829284108
+4526:04400440FFFE0440110011FC1200FDF83148392857FE5148922813FC10501020
+4527:0820FFFE082003043C2404247FA416242504440C01007FFC05401930E10E0100
+4528:0820FFFE08201050104824FE45907A9010FC2490449078FC0890109020FEC080
+4529:04400440FFFE044008200820FFBE08447FA449247F281C282A10492888440882
+452A:0820FFFE082001007FFC01002928111029280100292811102AA804401830E00E
+452B:04400440FFFE044000207C2007FE182051FC5D24512C50705CA87124C2220020
+452C:0820FFFE082000003FF821083FF821083FF804403FF80440FFFE082010102008
+452D:0820FFFE09207FFC41041490142823E800003FF821083FF821083FF821082118
+452E:08200820FFFE0820220C2270FF4022403E40227E3E482248FF48224841488088
+452F:0820FFFE082000107F10141014FE7F105510557C574461447F4441447F7C4144
+4530:0820FFFE09207FFC40043FF800001FF010101FF000003FF821083FF821083FF8
+4531:08200820FFFE082011F81108FDF8100013FC11081DF8F10811F8110E57F82008
+4532:08200820FFFE082000907EA00444282817D02008DFF610101FF0082004407FFC
+4533:04400440FFFE044010281E2432FE4A20A450185010882106C000248822444244
+4534:0440FFFE044008002A003E7C49447F4400443E2800287F1008102A2849441882
+4535:0820FFFE082000007C7C44447C7C44447D7C41045FF44384454449245124410C
+4536:0820FFFE0820000011FC1104FDFC110415FC180037FED020113C112052A0247E
+4537:0820FFFE08200000FEFE10107C7C1010FEFE010006C01A30E10E1FE000400080
+4538:0440FFFE04400120FFFE02800C603018C00610281424FEFE1020285044888106
+4539:0820FFFE0820010878904BFC48805144566848B049284E6868A4512246A04040
+453A:0440FFFE04407BFC488049F8522055FC480049F8490869F8510841F841084118
+453B:0820FFFE08201040FE4000807CFE45087E8800887C500850FE20105050882306
+453C:0820FFFE082000007EFC122452A49324264C409008502E5C28502E50F1FE0000
+453D:0820FFFE082023F8120813F8820843F8510013FC2444EAA4220423F420142008
+453E:0820FFFE082023F8220823F8FA0823F8290033FC6444AAA4220423F4A0144008
+453F:0820FFFE08200440FFFE04403FF82848303827C820083FF80020FFFE08200460
+4540:04400440FFFE044008207F20083E3E4200943E1000107F1008282A2849441882
+4541:0820FFFE082004407C7C04403C7804407C7C05400100FFFE05401930E10E0100
+4542:0820FFFE082000802110120817FC000473F8120813F810C411A812902C8847FE
+4543:0820FFFE0820004078A049104BF8550651F0490049F049006FFC5100421043F8
+4544:0820FFFE082000001FC000447D88055009203518C2061FF000003FF82448FFFE
+4545:0820FFFE08200080112C1124FDAC252425FC482029F810882850442080D80306
+4546:0440FFFE044020A021102208F5F62000678474A4AFA4A4A427A4248424942588
+4547:0820FFFE092000803FFC208021002FF828882FF829082FF84254445C9842603E
+4548:0820FFFE0820004809484BFE49487978090009FEF8204BFE487048A88B260820
+4549:0820FFFE08203FF824483FF801003FF80100FFFE04403FF80100FFFE01000100
+454A:0820FFFE0920FFFE00003FF8200827C824483FF810101FF010101FF00000FFFE
+454B:0820FFFE08201040102013FE12207EFC122413FE12241EFCE22004FC048408FC
+454C:0820FFFE082000000CA0709011FE1120FB2031FC392055FC5120912011FE1100
+454D:0820FFFE0A200100FFFE04881A70EC1808063FF824482FE8345827C820282010
+454E:08200820FFFE082001FC7C0044F844887CF8440045FC7D2445FC45247DFC4504
+454F:0440FFFE0440101008203FF801007FFC02403C500848FFFE08507E240854198C
+4550:08200820FFFE082021FC1000FCF8088810F8380055FC952411FC112411FC1104
+4551:0440FFFE0440001C11E0104425247C880820102025FC7C4800C8543054688184
+4552:0820FFFE0920FFFE01003FF800001FF010101FF00820FFFE10007EF8228846F8
+4553:0820FFFE0A2001007FFE50829EFC22885450282017D82006DFF0010011102308
+4554:0820FFFE08202100411C828014402BBE7108A7C821082948250821C82E282410
+4555:0820FFFE082011F8090809F8410823FC2A940BFC100073F81090106011981606
+4556:0820FFFE0820400C2F70211002240278E3122E7E221022542A92243050008FFE
+4557:0820FFFE0A201FF010101FF010101FF000003FF821083FF82108FFFE08201020
+4558:0440FFFE0440100013FC284045F8930809F8FD0805F8090851F8200010900108
+4559:0440FFFE044008207F280824FFFE12203FA46424BFA824183F92242A3FC62082
+455A:0820FFFE08203FFC208027F0249027F020803FFC241027F0241027F022203FFC
+455B:0440FFFE044020201020FDFC002078A800A878A801747A224850488879044A02
+455C:0820FFFE08207CF824481428244801007FFC0820145022880100FFFE01000100
+455D:0820FFFE0820001E0DE07044112410A8FDFC312439FC552453FE910411141108
+455E:0820FFFE08207C7C44447C7C44447D7C47C4444447C4444447D444A44544462C
+455F:0820FFFE082000002FEC48244BA4682C4BA46AAC4BA44824FFFE101020084004
+4560:0820FFFE082000803FFE20202F2831102A0A277C294A378428784F484130874C
+4561:0820FFFE08207C7C44447C7C44447C7C47C4444447C440044FE448244FE4400C
+4562:08200820FFFE082000887C5013FE102021FC3C4067FEA480257C26103C1025FE
+4563:0820FFFE082023F8120803F8FA080BF811002BFC7444AAA42A0423F420142008
+4564:0820FFFE08207700557C774400487F5049487F4449447F540848FFC008400840
+4565:0440FFFE0440111025484924BFFA210835582928355821083558292835582118
+4566:0820FFFE082001007FFC10001FF808200FE079384FA87AA84AB8792A4AAA9C46
+4567:0440FFFE04403E2022103AFE2A007F2841443E8222283E2822103E2822442682
+4568:0440FFFE044001243CA825FC24403DFE248825443E8A24F0242445FC54A88964
+4569:0440FFFE04401000102013FE7850128A31FC3A8A54F8508890F8112412221060
+456A:04400440FFFE044023F812A893F8404043F8104027FCE11023F8204027FC2040
+456B:0820FFFE08A0111E13D25A5E53D05A52E3CE120827E44822144003801C70E00E
+456C:0820FFFE082003FEF80009FC0924F9FC812487FEF80009FC092409FC512427FE
+456D:0440FFFE0440101010547C581090FE280044549292547C5810901C28E0444182
+456E:0440FFFE0440110011FC7E441154FEE4444429F47C4410E4FF54104410541008
+456F:0820FFFE08200000FE1C28E8FEA8AAA8FEA800A87CA800A4FEA4554A92783008
+4570:0440FFFE0440101C13E0152454A85BFE5124920211FC112429FC252445FC8104
+4571:0820FFFE082000007DFE002000FC7E8442FC42847EFC428424FC0F00F0484084
+4572:0820FFFE08A03FFE20402FFE240425F4251427FC200027FC20004FFE424884C4
+4573:0820FFFE08200000F7FC124817FCFC4686EC8554F6EC155416EC144454542408
+4574:0440FFFE044000A00C9071FE112013FCFD2031FC392055FE500092A412521452
+4575:0440FFFE0450102010FCFE8410FC10847CFC008000FE7C8044FE44027D524406
+4576:0440FFFE0440209010FEFD9002FC789000FC789000FC788049FC488878704B8E
+4577:0820FFFE092000803FFE24103F7C26382D543492212027C021104FF844A48990
+4578:0440FFFE04407F1049106BFE5D107F10087C7F0008000F7CF0440044557C5544
+4579:0440FFFE044020101048FE4044FE4590AA9010FCFE9010FC5490529092FE3080
+457A:0820FFFE0820244814507FFC082004407FFC0100FFFE22003E7C23A47E180266
+457B:0440FFFE04403F7E12241B3412A43FFC22403FF822483FF828442F7848428F3E
+457C:0820FFFE08204450FE4844FE7D901290FEFE9290FE9010FEFE90289044FE8280
+457D:0820FFFE082001FC7D5445FC44807DFC124411F45D5451F450445DF4E0140008
+457E:0820FFFE082000001E7812483FFC20202E20223C3FC829282F2849905F288144
+457F:0440FFFE04504420FEFC44847CFC1084FEFC9280FEFE1080FEFE280245528206
+4580:0820FFFE08203C782448FFFE02001FF0149012501FF0082010107C7C44447C7C
+4581:2810FEFE284400287CFE54007C7C54447C7C1044FE7C9210920ABAAA8AA4851C
+4582:0820FFFE29284FD2F03C23884812FBBE0280ABAA00F03F000100FFFE01000300
+4583:0820FFFE0A207FFC08001FF068100FF04444FEFE5454FEFE20207C7CC4C47D7C
+4584:0820FFFE08204450FE4844FE7D9010FCFE9092FCFE901090FEFE288044488224
+4585:0820FFFE08203FF801007FFE492284143BB82AA83BB800007FFC11102928FFFE
+4586:0440FFFE04400020FBFE2154F9DCA888A9FCD88889FC8888FBFE898AFEA488C2
+4587:0820FFFE2A28F3BC2508739CAD6A27C80000FFFE950A6B7055047F3824823FBC
+4588:010001F801003FFE210221F02F0420FC2000241824E027042404440443FC8000
+4589:010001F801003FFE210221F02F0420FC200023F8204020402FFE404041408080
+458A:0020043E042085FE4522293829E01122111E2900297845484548824A024A0486
+458B:0410079004103F90249027103C102490239020282F282928296449A491242042
+458C:0404078404043FD4245427143C5423D420142F14291429044944498491142008
+458D:010001F801003FFE210221F02F0420FC210021FC2210251028A0404041B0860C
+458E:00407840487C504053FC624452704BC04A444A3C6A0052F0449044924912520E
+458F:010001F801003FFE210221F02F0422FC220027F82D48334822E8449E49088218
+4590:04100E1E301020FE2092209C3EF02492248E248024B824A824A8452A452A8246
+4591:08000F00087C7F4449444E44787C4944474440444E7C4A444A02520291FE2000
+4592:010001F801003FFE210221F02F0420FC20002FF8200027F0241047F042209FFC
+4593:1010101E921092FE9292929CFEF01092108E928092B892A89EA8F32A012A0246
+4594:1020103E10207DFE1122113811E0FD22111E110021784948FD48464A024A0486
+4595:08000F0008787F4849484E7878484948477840484E484AFC4A02520291FE2000
+4596:08000F00087C7F5449544E7C78544954477C40104E104A104A12520291FE2000
+4597:01FC01003FFE210221F02F0420FC20282FFE28202BA428282BAC2A944BAC9044
+4598:10401E4010787E8853105CFC70A452A44EFC40205C505458545456929492210E
+4599:3F9024183F1421123F10247C3F8020802FFC288428F02F84287C49E04924921C
+459A:10201E4010FC7E8452845CFC708052FE4E8040FE5C0254AA54AA560294142008
+459B:08100F10087C7F1049FE4EA278444978471440FE4E104A544AB2520291FE2000
+459C:1E3C10207EFE52A25CB872E44E9C40805CB8952A23465FF010101FF010101FF0
+459D:0008007C07807900010001003FF82108210821083FF82100011001F87F042004
+459E:0808080808087F0849FE4908490849087F48482808280A080F08F10840280010
+459F:02000100FFFE100010001FF8000001001FF0111011101FF0110001087FFC2004
+45A0:100011F011107D1055105510559055507D505110111015121D12E612420E0400
+45A1:100011F810487C4854485448544855F87C885088108814881C88E48843FE0000
+45A2:1020102010207CA854A454A2552255207E245024102814081E10E22040C00300
+45A3:1008101C11F07D5055505550555055507D505148114815481D44E64442420400
+45A4:100010F83E884288A4A818941084207CC1001FF0111011101FF001087FFC2004
+45A5:1FF0022001407FFC048418886280010001001FF0111011101FF001087FFC2004
+45A6:1020102011247D245524552455FC54207C205124112415241D24E52441FC0004
+45A7:1000100010FC7C845484548454FC54847C84508410FC14841E00E20041FE0000
+45A8:1000100011FE7C2054205440544054FC7C845184128414841E84E28440FC0084
+45A9:1040102010287C0854085448545455527D525160126014441CC4E544423C0000
+45AA:088008882E9028A028C028842E84F07C01001FF0111011101FF001087FFC2004
+45AB:1010105010507C885488550456FA54207C20502011FC14201E20E22040200020
+45AC:100011FC11247D24552455FC552455247D2451FC112414201C20E42040200020
+45AD:1110091009207FFC0200FFFE08203018C1061FF0111011101FF001087FFC2004
+45AE:1020102010407DFC55045504557455547D545154115415741D04E50441140108
+45AF:01003FF80100FFFE01003FF80100FFFE000001003FF821083FF801087FFC0004
+45B0:1004101E11E07D0055065578555055507D52115415481D48E544425402620440
+45B1:100011FE11007D0055FE55105510557C7D105110111015FE1D00E50041FE0000
+45B2:1080108011FC7D04560455E4552455247DE45124112415E41D04E40440280010
+45B3:1020101011FE7D025400541C54E054207C20503E11E014201E22E222401E0000
+45B4:1050105010507D5254D45458545054587CD45152105014501E92E2924112020E
+45B5:1020102010207DFC55245524552455247DFC5124102014281C24E5FE40820000
+45B6:100013FE10407C8055445624546854B07D305228106814A41D22E62040A00040
+45B7:218420682030F8C8AB04A840ABFEA8A0F920A3FC252429243934E92840200020
+45B8:02403C500848FFFE08480E5078240854198C01003FF821083FF801087FFC0004
+45B9:208820882088FB8EA888A888A800A9FCF820A02023FE28203820E82040200020
+45BA:1080108011F821082A906C60A9982E4628402BF82A482A482BF8204427FC2004
+45BB:1020101011FE7C205448548455FE54027CA850A810A814A81EA8E2AA412A0206
+45BC:21002100211EFB92A912A912A912AFD2F912A112221A2A943FD0EA5040100010
+45BD:03083C0804487F480C4816482508442805101FF0111011101FF001087FFC2004
+45BE:1020101011FE7D02560454F8540054007DFE5050105014501E92E292410E0200
+45BF:0C8070FC1124FD241224384454849128101001003FF821083FF801087FFC0004
+45C0:2020202021FCF820A820ABFEA888A944FA42A0F821882A503820E85041880606
+45C1:1020102011FC7C505488550457FE54087DE85128112815E81D28E40840280010
+45C2:10201020103C7C2055FC5524553055E07D24511C110015701D50E5524292050E
+45C3:10481044105E7DE054285412546A55967C48505E11E014241E28E212406A0186
+45C4:1050108811547C2054D85706540854F07C80508010FC14901C90E51042100010
+45C5:100010FC10807CF8548054F8548057FE7D405124112815101D08E54441820100
+45C6:1020101011FE7D02560454F8548854887CF85080108014FC1E84E28440FC0084
+45C7:1080108010FE7D02562254AA547254227DFE5022107214AA1D22E422400A0004
+45C8:1040102013FE7C805480548054FC54007CFC508410FC14841EFCE28440FC0084
+45C9:10F8108810887CF85488548854F854007DFC5104110415FC1D04E50441FC0104
+45CA:102010A210A27D2454505488570454227C2050A410A415281C50E48841040202
+45CB:1088108813FE7C88548854F8548854887CF8502013FE14701CA8E52442220020
+45CC:100011FC11047DFC550455FC542055207DFE5220102015FC1C20E42043FE0000
+45CD:0FE010201FC00040FFFE0C1073200DC072B00C8EF3003FF821083FF801047FFE
+45CE:100013FE10507C5055FC5554555455547DFC5020102015FC1C20E42043FE0000
+45CF:1040102011FE7D2254A45528545054887D0450F8108814881E50E22040D80306
+45D0:1040FEFE21203CAC24F427A444AC54A2887E01003FF821083FF801087FFC0004
+45D1:100010FC10847CFC548454FC548454207C1051FE100014841E48E20041FE0000
+45D2:210820902000FBFCA890A890A892AC92FA94A298209028903890E89047FE0000
+45D3:2080208020FCF954AAD4A8B4A92CAA44F894A108204028A43AAAEA8A44780000
+45D4:108010BC10847D0855FE57205520557C7D90511011FE15101D28E52841440182
+45D5:01007FFC50043EF84288A2AA1492187EE1001FF0111011101FF001087FFC2004
+45D6:20A820A823FEF8A8A8A8A800ABFEAA22F820A1FC212429243934E92840200020
+45D7:2210221023DEFD28A884A800ABFCA890F890A09027FE28903890E91042100410
+45D8:1020102010FC7C20542055FE544054847DFE500211FC15541D54E55443FE0000
+45D9:01007FFE44429FF404403FF80440FFFE082011102FE8C9260FE001103FF81008
+45DA:1028102413FE7C2055FC552455FC55247DFC5124100817FE1C88E44840480018
+45DB:2120213C2144FAA8AA10AEA8AAC6AABCFAA4A2BC22A42ABC3A24EA244224022C
+45DC:204023BE2212FA92AA52AAAAAB24A840FBFEA22222222BFE3A22EA2243FE0202
+45DD:20201020FDFC092411FC392455FC9020102001003FF821083FF801087FFC0004
+45DE:00003FF80100FFFE02800C603018C00610207EFC52A47EFC10201424FEFE0202
+45DF:7F7848485F4C64805F7844484A4851307F4C01003FF821083FF801087FFC0004
+45E0:20401040FEFE21003DFE242224A044BC55608A3E01003FF821083FF801047FFE
+45E1:200023FE2020F93CA920AFFEA880A8FEF900A1FE20022AAA3AAAEC0240140008
+45E2:1010105012507D7C5490541054FE57007D7C51441144157C1D44E50042FE0400
+45E3:08200820FFFE08200FE008200FE0000010207EFC52A47EFC10201424FEFE0202
+45E4:101011FE11107D7C551455FE5514557C7D10117C15541D7CE554427C0254044C
+45E5:212421242224FC24A954A94AAA92AE10FA10A250225C2A503A50EAB0429E0300
+45E6:2020247C2284F948A830A8CEAE10AA7CFA10A27C22102AFE3A10EA1045FE0800
+45E7:1020101011FE7D10557C551455FE55147D7C111015921D54E538425402920430
+45E8:1040104010F87D08561055FC552455247DFC5124112415FC1C00E554412A022A
+45E9:200C200A2008FBFEAA08AA48AA6AAA4AFBFAA24C224C2AEC3B5AEC4A44D60822
+45EA:00803FFE222022203FFC222023E020002A48312420802FF848884FF880841FFE
+45EB:1020101011FE7D485548554855FE55487D4851EC115A15681D48E54842480048
+45EC:210013F0151000E0775C11F0104013FC284047FE01003FF821083FF801047FFE
+45ED:2020202021FCF924A9FCA820ABFEAA22FBFEA020204028243AA2EA8A44780000
+45EE:2020202023FEF820AAAAA924AAAAA820FAAAA12422AA28503850E88841040602
+45EF:20282224217EF9C8A948A87EAB48A948F97EA1482148297E3940EA80447E0000
+45F0:200021FC2124FBFEA924A9FCA800A9FCF904A1FC210429FC3904E9FC40880104
+45F1:205022522154F850ABFEA888A850ABFEF820A1FC20202BFE3850E88841040602
+45F2:2020212420A8FBFEA8A8A924AA22A904F904A1DE22442D54389EE90442040404
+45F3:201023D22054F948A88AA904AAFAAC00F9FCA104210429FC3904E88847FE0000
+45F4:2110211021DEFAA8AC44A806ABB8A888F908A3BE20882A88393EEAC0443E0000
+45F5:100013FE10007DFC552455FC552457FE7C0051FC112415FC1D24E5FC400003FE
+45F6:108813FE10887DFC550455FC550455FC7C8051FE122215521D02E5FA400A0004
+45F7:1040102011FC7C88545057FE540055FC7D0451FC110415FC1C20E694428A047A
+45F8:0100FFFE104824FE799010FC22907CFC089030FEC1803FF821083FF801047FFE
+45F9:2108209023FEF908A908AA52AB9CA908FA52A3DE204028A43AAAEA8A44780000
+45FA:00187BE0104022787A400A402BFC10002FFE400010207CF854A87CF81224FEFC
+45FB:2108210821EEFA94A842A800ABDEAA52FBD2A25223D22A1A3A94EB5042100010
+45FC:201C21E02020FBFEA820A9FCA9ACA974F9FCA02021FC28203BFEE8004154022A
+45FD:10A0209045FE792013FC25207DFC012055FE81003FF821083FF801087FFC0004
+45FE:200023FE2202FBFEAA02ABFEA908AA52FB9CA10822522BDE3800EAA442520452
+45FF:2040202023FEFA22A954A94AAA3AA800F9FCA15423FE280039FCE82040A00040
+4600:08003FF020103FF020003FF820083FF80100FFFE11207CF854A87CF81224FEFC
+4601:08287F240820FFFE12203FA46424BF2824123FAA01463FF821083FF801047FFE
+4602:2088208C23EAF888A888ABFEA948AB6AF94AA36A214C2B6C394AE96A47960022
+4603:21FC212421ACF924A9FCA820A9FCA820FBFEA154222A282039FCE82043FE0000
+4604:01081FD001207FFC02000FF03810CFF008100FF010207CF854A87CF81224FEFC
+4605:20444258FF6201427E3E42007E4C42727E42423E10207CF854A87CF81224FEFC
+4606:102013FE12227DFC542054F8542055FC7C2011FC15541DFCE44042A4028A047A
+4607:01007FFC082007C01930EFEE09200FE001103FF810207CF854A87CF81224FEFC
+4608:2FE829482BE8F95EA80AABEAAAAAABEAFAAAABEA288A2BEA3AAAEBEA4A2A1276
+4609:3FF801007FFC04401930EFEE09200FE001103FF810207CF854A87CF81224FEFC
+460A:221023DE2528F884ABFCAA94AA94ABFCF828A3FE22202B243AA8EA92442A08C6
+460B:2148214C22AAF808ABFEA948AB68A94AFB6AA14A236C294C396AEB8A40160022
+460C:3FFC24202FF825203FFC220027F02A1033F03FFC10207CF854A87CF81224FEFC
+460D:0820FFFE08201FF011101FF011107FFC41245FEC10207CF854A87CF81224FEFC
+460E:244428E82E0EFCE4AA0AAEEEA8A0AAEAF800A3F820082BF83A00EBFC40040038
+460F:0800083E10227F245524552855245524552255225522553457A8FC2000200020
+4610:0800080010787F2855285528556C556A55AA552A5528552857C8FC4800980100
+4611:0830080810007F705510551A55DA555C55585558555455545794FC1200500020
+4612:0810081010207F4455FE5528554455A2553C5544554455A85790FC2800440082
+4613:08100810101E7F225524554055105566554255425566554257C2FC42007E0042
+4614:08200810107E7F425510551C552455545508553655C0553C57A4FC24003C0024
+4615:12001100211C4FC08000100023BE6288A2882288228822A824C8248828282010
+4616:10001200221C43C085001100213E6FC8A10821082548254825C8264820282010
+4617:11001540254E47C0800017C0221E6444A784210422442FE42104254429342308
+4618:21002FE0410E47C081001FE0221E6444A784210422442FE42104254429342308
+4619:110017C0224E4FE0800017C0245E67C4A10423C4250427E4210427C425542548
+461A:02000100FFFE05000C883450C530060E040001000100FFFE0100010001000100
+461B:200011F00110FD100910111011103510591095101510111211121212120E1400
+461C:202010200020FC2009FC11241124352459249524152411341128102010201020
+461D:205010480048FC40087C13C010403440584094201420102010141014100C1004
+461E:200013F80008FC0809081108110835FE58029402140213FA1002100210141008
+461F:200011FC0024FC24082411FC11203520592095FE14221022102A102410201020
+4620:204010400040FC4009FE10401040348458A494A4152811281210142810441182
+4621:2080208820B03EC020842684387C22000100FFFE05000C883450C530060E0400
+4622:204010200020F9FE090212041000340059FE9420142010201020102010A01040
+4623:209010900090F290129222D422986A90B2902A902290229223D22E12240E2000
+4624:204010500048F8400BFC104014E038E055509150124814441842104010401040
+4625:200011FC0124FD24092411FC11243524592495FC152410201020102010201020
+4626:200011FC0104FD04090411FC11003540594495481570114011421242123E1400
+4627:202010200020FDFC0924112411243524592497FE142010501050108811041202
+4628:204010200020FBFE0800108815043A0254889088105010501020105010881306
+4629:2080108001FCFD040A0411E41124352459E49524152411E41104100410281010
+462A:204010200020FBFE0840108815043BFE549290901090109011121112120E1400
+462B:080008007F7C114421441A440C7C32000100FFFE05000C883450C530060E0400
+462C:202810240024F8200BFE102011243524592497A8152811101212122A14461082
+462D:200011FE0020FC200848108411FE34225820942015FC10201020102013FE1000
+462E:010001007FFC11101110292845440100FFFE1200111010A010401430180E1000
+462F:2020112400A4FCA8082011FC1104350459FC9504150411FC1104110411141108
+4630:2004100E03B8F08810882128212E6BA8B0A82AA822A8213E21002280247E2800
+4631:0100FFFE0820111022880C603018DFF6101010101FF004880C503530C60E0400
+4632:200011FC0004F8FC080411FC100033FE560299F8148810881050102010D81306
+4633:202010200050FC880904120210F83420582095FC1420112410A410A813FE1000
+4634:220812280228F2281FA4224422546E92B7102AA02A203228224422FC22442200
+4635:200011FC0004F80409FC100414043BFE54209222117410A81124122210A01040
+4636:200011FC0008F010122222AA22726A22B2722AAA232622A22242220223FE2002
+4637:2020112400A4FCA8082011FC11243524597495AC152411241124110411141108
+4638:2080104007FEF1201120223C22446E64B2942B48224822302220225022882306
+4639:2040102003FEF8000888108815543A225400902013FE10201020102010201020
+463A:2040102003FEF2021404200023FE6820B0202920213C212022A02260243E2800
+463B:2040102003FEF880090413FE100235FC590495FC150411FC1104110411141108
+463C:2040102003FEF2021504210021DE6A52B2522B52249A2094211021122212240E
+463D:20001040039CFA040A04139C120436045BFC949014901090109011121212140E
+463E:2040102003FEFA020C0411F81108350859F89500150011FC1104110411FC1104
+463F:200013FE0202F20213FE221022926A92B2922AFE221022922292249224FE2802
+4640:200013DE0252F252125223DE22526A52B2522BDE2252225222522252255228A6
+4641:20481044005EFDE008281012106A35965848945E15E0102410281012106A1186
+4642:209010900108F1481244249221086BFCB044282020A42282228A228A24782000
+4643:2040104003FEF88009FC122015FE300055FC990415FC110411FC110411141108
+4644:2008103C01E0F820082013FE102034A0592C9524152411AC1124112411FC1104
+4645:200013FE0050F8500BFE125216523BFE5400904017FE10881190106010D81304
+4646:201013D40058FA52098C108815043AFA5420902011FE10201050108811041202
+4647:200013FE0020FC4009FC1154115435545954952C142013FE1050108811041202
+4648:210011780108F20812FE26402A406A7CB2902A1022FE22102228222822442282
+4649:2008101C01F0FD10091011FE1110357C5944957C1544117C11441244127C1444
+464A:20A810A803FEF8A808A8100013FE3622582095FC152411241134112810201020
+464B:2040102003FEFA020C0411FC100035FC590495FC150411FC1104100013FE1000
+464C:2020102001FCF92409FC102013FE340059FC9504152411241124105010881304
+464D:200013FA000CF84A0B88112A112635225BF8952A152C112A1128122A12261422
+464E:201E13E00122FC940840108811F0342058C495FE1422102013FE105010881306
+464F:2028102403FEF82009FC112411FC352459FC9524140813FE1088104810481018
+4650:200013FE0000F9FC0904110415FC380057FE928A125213FE12221222122A1204
+4651:2080104007FEF00013F822082FFE6A08B3F828A4212823102510294821862100
+4652:2040102003FEF840088811F01020344459FE940215FC112411FC112411FC1104
+4653:200013FE0252FA520BFE1020142039FC5420902017FE10401088110413FE1102
+4654:200013FE0200FA7C0A441244167C3A0056EE92AA12AA12AA12EE120013FE1000
+4655:212411240224F4A41154214A23926D08B1082928212E212821282158214E2180
+4656:202012220222F3FE100023DE22526A52B3DE2A52225223DE22522252255A28A4
+4657:2040102003FEF888085013FE16223AFA562292FA128A128A12FA1202120A1204
+4658:201410120010F7FE1410249024D26C92B7F22C94249425C82AAA289A31A62042
+4659:200013FE0202F3FE1210225422386A54B2822A50227C2290221025FE24102810
+465A:02001FF010101FF010101FFC10001FFC0004492C0200FFFE06801C48E530060E
+465B:2040102003FEF88809241242109035F85808944414A81190128814A410C21080
+465C:2020147C0284F148103020CE26106A7CB2102A7C221022FE2210221025FE2800
+465D:0100FFFE08207E2008F8FF2814287F6A082AFF560B8204880C503530C60E0400
+465E:202017A400A8F2921114220825F46802B3F82A08220823F8220821102FFE2000
+465F:200017FC0444F5F4149427FC24046DF4B5142DF4244424F4254425FC244427FC
+4660:200017FE0400F628154827EE24926C84B6A02EA827E824882494251429243242
+4661:202011FC0124F9FC082013FE100035FC590495FC150411FC110411FC10881104
+4662:210410880000FBFE0A2212AA1272322257FE980015FC110411FC110411FC1104
+4663:200011FC0040FBFE088811041652305057DE985015DC105013DE105010501050
+4664:2000127C0144F1741054205426FE6A82B2BA2AAA22BA2282228A2284250028FE
+4665:200011FC0020FBFE0A2211AC142039AC545090C8132610F8100810D010201010
+4666:208813FE0088F9FC0954115415FC380057FE924210F810881148103010601380
+4667:201C11E00020FBFE082011FC11AC357459FC942015FC102013FE10001154122A
+4668:21FC112401FCF92409FC102013FE34A859249642142013FE10601194168810C6
+4669:208813FE0088FBFE0A0211FC14003BFE544090A2135410B81354109213501020
+466A:22882108FABE2008729CA92A2288FFFE0A203118CFE6028804501C2065180606
+466B:209413980092FD8E0A8011FC112435FC592495FC148811FC108813FE10881104
+466C:23DE125203DEFA520BDE125217DE398C5652904017FE10881190106010D81304
+466D:204017FE0492F3FC109023FC20906FFEB1082BFC250A21F82240227C254028FE
+466E:208813FE0088FBDE0A5213DE14A0389055FE912013FC152011FC112011FE1100
+466F:201417FE0490F4D4149427FA25AA6A96B1A22BF8220823F82040227C254028FE
+4670:220C110A07C8F29E155426F4245E6FD4B1142FDE2554255425D4245E25502490
+4671:23FE120203FEFA920A54129216FE3AAA56FE932212FA12AA12FA122215FA1004
+4672:00007FFC044004403FF8244824483FF801000100FFFE0280044008203018C006
+4673:00007FFC044004403FF8244824483FF801001110111022A0044008203018C006
+4674:7FFC04403FF8244824483FF80200FFFE08201FF02828C8260FE00808080807F8
+4675:00007FFC04403FF8244824483FF801003FF80100FFFE000001003FF80100FFFE
+4676:0010FE10281029FE2922FE20AA50AA50AAD2AACCAF48C24482448252FE608240
+4677:1FF010101FF010101FF010101FF004421842E03E0020FFFE0820042004A00040
+4678:00087E08420842FE7E08420842887E48424842087E0824282412240243FE8000
+4679:00007EFC2484248424FC24842484FFFC2484248424FC2450245024924492850E
+467A:100011FC1104110455FC5904510491FC1104110411FC2850245044924112820E
+467B:0800087C0B447C44487C484448447F7C09441944297C49288B28084A084A0886
+467C:00007EFC1284128422FC2A84448480FC3E84228422FC225022503E922292010E
+467D:01000100FFFE0280244818303FF8D0161FF010101FF010101FF004421842E03E
+467E:200010FC1084FE8482FC0484408440FC7C84408440FC40504C5070924092010E
+467F:100010FC10847C8410FC10841084FEFC1084388434FC5250905010921092110E
+4680:0800107C3E442244327C2A442A44FE7C224432442A7C2A282228424A4A4A8486
+4681:0800087C10447F44417C41445D44557C55445544557C5D284128414A454A4286
+4682:100010FC10847C8410FC1084FE8428FC28846C84AAFC2850285048924892990E
+4683:0800087C0F440844087C7E444244427C7A444A444A7C7A284228424A7E4A4286
+4684:00007E7C02443E44027CFFC40844097C49442A441C7C2A28C928094A284A1086
+4685:0800087C0844FF44087C2A442A442A7C5D4488441C7C2A284928884A084A0886
+4686:2200227C7F4422442A7C08443E442A7C2A442A44FF7C08281428124A224A4086
+4687:1000107C52445144957C08443044C07C7E4442447E7C42287E28424A7E4A4286
+4688:0000FF7C144414447F7C554455447F7C084408447F7C082808280F4AF04A4086
+4689:20002F7CF5442544757C2544F544297C23440844087CFFA81428224A414A8086
+468A:2200147C00447F44007C14442244417C00447F44557C5528552857CAFC4A0086
+468B:00003E7C224422443E7C00447F44417C7F4441447F7C41287F28144A224A4286
+468C:0800107C7F4441447F7C41447F44107CFFC42244497C88A87F68084A084A0886
+468D:0800FF7C08447E44087CFF4400447E7C42447E44427C7E2842287E4A244A4286
+468E:0800087C7F4410443E7C1044FFC4227C414490C4267C22283628224A3E4A2286
+468F:08004A7C2C440844FF7C2A444944887C42447744927C5A282F28224A424A8286
+4690:4000777CA5442544FD7C27445544807C7E444244427C7E284228424A7E4A4286
+4691:0000FEFCAA84AA84FEFC00847C8444FC7C8444847CFC44507C5000922892450E
+4692:1000087C7F442244FF7C00447F44497C7F4449447F7C08287F28084A0F4AF086
+4693:0000FEFC2884FE84AAFCFE8400847CFC44847C8444FC7C501050FE921092110E
+4694:200010FCFE8482847CFC548498847CFCC4847C8444FC7C5044507C922892450E
+4695:7700007C77445544777C554408447F7C54447F44557C7F2855285E4A554A9B86
+4696:0000FEFC1084FE8492FC54840084EEFCAA84EE8400FCFE505450BA921092FF0E
+4697:200820487848484890447C8454A455227C20544054407C48548455FE44828C00
+4698:12001380249C490087C01540257E67C8A548254827C8254825482548246828D0
+4699:100010FE3C002400487CBE442A442A7C3E442A442A7C3E442A004A0042FE8600
+469A:101010503C50247C4890BE102A102AFE3E282A282A283E282A4A4A4A42868700
+469B:101010503C50247C4850BE902A102AFE3E002A002A7C3E442A444A44427C8644
+469C:102010403CFE24924892BEFE2A922AA23EFE2A482A883FFE2A084A0842088608
+469D:2040202079FE480090887C88555456227C00542055FE7C205420542044208C20
+469E:2020202078204BFE90207D24552455247EAA547054A87CA85524562244208C20
+469F:100010FC3C8424FC4884BEFC2A002AFE3E082BFE2A083E882A484A0842288610
+46A0:200021FC7904490491FC7D04550455FC7C00551255D47D185510555245928D0E
+46A1:200021FC7924492491FC7D24552455FC7C20541054547D425542554A46388C00
+46A2:2048214879484BFE91487D48557855007DFE542057FE7C7054A8552446228C20
+46A3:100010FC3C84248448FCBE842A842AFC3E002BFE2A203EA02ABC4AA04360863E
+46A4:1000107C3C542454487CBE542A542A7C3E102AFE2A923E962ABE4A82428A8684
+46A5:100010EE3C22242248EEBE882A882AEE3E222AAA2A663E662AAA4A2242AA8644
+46A6:2008203C79D0491C91107D7C555455587D705554554C7D40567854A8442A8C46
+46A7:200021DC7844495490CC7D54542854447D92542054C87C3254C4541844608D80
+46A8:201221D478484A8A91047E0255DC54547C6255C0551E7DC25454544845548CA2
+46A9:201821E078404BFE90887D74565254707C0055FC55047D745554557445048D0C
+46AA:200021FC7954495491FC7C0057FE54007DFC550455FC7C625494558846A48CC2
+46AB:10207E204A7E7EC41028FF1020283EC652001FE020405FF091101FF011102130
+46AC:2020212478A84BFE90A87D24562255087DC8565E55487CA854BE550845088E08
+46AD:208823FE7888480091DC7D5455DC54887DFE569054FC7C9054FC549044FE8C80
+46AE:2000100011FCFE4400487C4800507C5E00427C424482448244827D0245140208
+46AF:100408040804FFA400247F2400247F2400247F244124412441247F0441140008
+46B0:208010801080FE8400887C9000A07CC000807C804480448444847C84447C0000
+46B1:202010201020FE2000207CA800A47CA401227D224622442044207C2044A00040
+46B2:200810081010FE2000407C8800087C1000207C444484440844107C2044C00300
+46B3:202010200020FDFE00207820002079FC00847888484848504820785049880606
+46B4:200010FC1084FE8400847CFC00847C8400847CFC4484448444847C8445140208
+46B5:200810881048FE4800087C8800487C4800087C0E45F8440844087C0844080008
+46B6:2000100011FCFE2000207C2000207DFE00207C204450445044887C8845040202
+46B7:209010900108FD0802047C0203FC7880010079F8480848084808780848500020
+46B8:202010201050FE5000887D0402027C8800887C884488448844887D0845080208
+46B9:201011100110FD120112791401D87910011079104910491249527992490E0000
+46BA:204010401040FE8000FE7D0802887C8800887C504450442044507C8845040202
+46BB:020007F0182062400980060019007FFC00003FF800003FF800003FF820083FF8
+46BC:200011F81048FE4800487C4800487DF800887C884488448844887C8847FE0000
+46BD:2008103C11E0FE2000207C3C01E07C2000207C3E47E0442044227C224422001E
+46BE:2008103C11E0FE2000207C2000207DFE00207C204420442044207C2045FC0000
+46BF:204010401040FE7C00847C8801207C2000207C504450445044887C8845040202
+46C0:2008101C01E0FD00010079FC01447944014479284928491049107A284A440482
+46C1:200010FC1084FE8400847DFE00847C8400847DFE4484448444847C8444940088
+46C2:200810680388FC880088788800887BFE0088788848884888490879084A080408
+46C3:2000100011FCFC0000007C0003FE7C9000907C904490449044927D124512020E
+46C4:42002200023CFBA402A472A404A474A40AB471285120512252227222541E0800
+46C5:200011FC1124FD2401247DFC01247D2401247DFC4524442044207C2044200020
+46C6:202010201020FE2001FC7D2401247D2401247DFC4524452445247D2445FC0104
+46C7:200010F81088FE8800887C8801067E0000007DFC4504450445047D0445FC0104
+46C8:204010401080FCFC01207E2000207C2001FE7C204450445044887C8845040202
+46C9:200011FC1104FF0401047DFC01207D2001FE7D204520451045127D4A45860102
+46CA:2000100010FCFE8400847C8400847C8400FC7C844400444844447C8444820102
+46CB:202810240024FC2001FE792001247924012479284928491849127A1A4A260442
+46CC:2040104010FCFE8401047EF400947C9400F47C844494448844827C82447E0000
+46CD:209010900090FBFC0094789403FC7A9002907BFE48924892491A79144A100410
+46CE:204010200020FBFE02027C04000078900090789048884908490879044A040402
+46CF:200010FC1084FE8400847CFC00807CA000A27CA444B844A044A27D22451E0200
+46D0:00003FF800087FC800083F8820883FA80110FFFE00003FF800003FF820083FF8
+46D1:200010400020FC280008788800907A9402A27AA24CC2488849887A8844780000
+46D2:00007DFE108010FC1E04F02801107FFC00003FF800003FF800003FF820083FF8
+46D3:0480248024FC24A02510040001007FFC00003FF800003FF800003FF820083FF8
+46D4:200013FE1020FE2000407DFC01547D5401547D544554455445547D4445140108
+46D5:2020102003FEFE2202227BFE02227A2203FE7820492048A0484078A049180606
+46D6:2020102001FCFD24012479FC0124792401FC782048244818483278CA4B060002
+46D7:00407E2049FE480048007EFC4200420042FC7E00480048FC488448847EFC0084
+46D8:20801088009CFD7001107B100510791001FE79104910491049107910497C0100
+46D9:209010900090FD1001FE7B100510793801387954495449924910791049100110
+46DA:08007EF808483E4808887EA809107FFC00003FF800003FF800003FF820083FF8
+46DB:2000100011FCFF0401047D7401547D5401547D544574450445047DFC45040000
+46DC:202010200040FDFC010479040194795401247924495449944904790449FC0104
+46DD:200011FC0024FC2401FC784400447BFE00007820482049244924792449FC0004
+46DE:200011FC1104FDFC01047DFC00007C0001FC7C20442047FE44207C2044200020
+46DF:202010200020FBFE002078200124792401247AAA482048504850788849040202
+46E0:200011FE1000FE0000FC7C8400847C8400FC7C004484444444487C0045FE0000
+46E1:201C13E00220FE2003FE7A2002907B0A020679FA490849084908790849F80108
+46E2:201C11E00020FC2003FE78A801247A22000078F8488848884888788A490A0206
+46E3:2020102001FCFD2401FC792401FC780003FE7880490049FC4804780448280010
+46E4:200010FC1084FE8400847C8400FC7C1000107C90449E449044907CD0453E0200
+46E5:218410680030FCC80304784003FE78A001207BFC4D2449244934792848200020
+46E6:200010501048FE8401247C2000507C8801067EF84488448844887C8844F80088
+46E7:201011101110FD9201547D1001FE7D1001387D544592451045107D1045FE0000
+46E8:2040102011FCFE0000887C5003FE7C2000207C2045FC442044207C2044200020
+46E9:200011FE1048FE4800487DCE01027D0201027DCE4448444844487C4845FE0000
+46EA:2040102003FEFA0200887904020279FC000479FC490049FC4804780448280010
+46EB:200010FC0080FCF8008078F800807BFE01407924492849104908794449820100
+46EC:2080108001FCFD04028478F40144784403FC78444954495449F4780448280010
+46ED:2020102001FCFC2000207BFE0088785001FC782048204BFE4820782048200020
+46EE:2088108810E8FD2C012A7EA800487CA0011E7E0044FC448444847C8444FC0084
+46EF:200011FE0102FD0201FE7910011079FE01107910497E494249427A424A7E0442
+46F0:200011FC1104FF0401FC7D0401047DFC00007D1245D4451845107D524592010E
+46F1:2020102001FCFD240124792401FC78200040782048A44A824A8A7A8A44780000
+46F2:2020104001FCFD0401FC790401FC782000207BFE4A224A224A2A7A2448200020
+46F3:2020102003FEFC5000887924022279FC012479FC492449FC48227822481E0000
+46F4:2020102001FCFC500088790403FE780801E87928492849E84928780848280010
+46F5:201C13E00044F92400A8789003FE7A02000079FC488448884850782048D80306
+46F6:2020102003FEFC2001FC782003FE7820000078204BFE487048A879244A220020
+46F7:2040102003FEFA020504790001DE7A5202527B524C9A4894491079124A12040E
+46F8:2020101001FEFD0001107910011E79100110797E4942494249427A424A7E0442
+46F9:208010FC0104FDF800087BFE004078A20334785848944B34485278904B500020
+46FA:21FC11240124FDFC0124792401FC7850008879044A8A48884888788849080208
+46FB:2008101C01F0FD10011079FE0110797C0144797C4944497C49447A44427C0444
+46FC:2040119C0104FD0401DC7904010479FC0000780049FC4820482078204BFE0000
+46FD:2008103C01E0FC2000207BFE002078A0012C7924492449AC4924792449FC0104
+46FE:2020102003FEFC2001FC782003FE7840008879F048244BFE482279244AA20040
+46FF:200013FE0000FDFC0104790401FC780003FE7A8A4A524BFE4A227A224A2A0204
+4700:400023DE014AF94A035A756A014A72D6002070205120513C5120712057FE0000
+4701:202011FC0220FBFE02007A2003FC7A2003FE7A004BE048204BFE785048880306
+4702:2020104001FCFD0401FC790401FC784003FE788849244A224DFC782048200020
+4703:20501048FEFE00907DFE00907CFE00907C9044FE7C8001003FF80100FFFE0000
+4704:200011FE0102FDFE011079540138795401827950497C499049107AFE4A100410
+4705:2020122203FEFC90008879FE03107D1001FE7910491049FE4910791049FE0100
+4706:00803FFE24103F7C26382D5434923FFC20002FF820002FF820004FF848088FF8
+4707:2040102003FEFC8801247A42009079F80008784448A849904A887CA448C20080
+4708:212412480124FC0001FC792401FC792401FC78204BFE487048A8792446220020
+4709:2020102003FEFC7000AC7B220050788801247A22492448A849247A2248A00040
+470A:2090109007FEF89003FC7A9403FC7A9403FC780049F8490849F8790849F80108
+470B:202011FC0124FDFC00207BFE000079FC010479FC490449FC490479FC48880104
+470C:1204110420082B8A4812F3BC100423884812FBBE0A820280AAAAABAA82A20000
+470D:2020102001FCFC200154788801047AFA008878F8488848F8482078A849240060
+470E:208812AA02DCFC8801547A2200007BFE02427C444BFC48444844788449140208
+470F:4020272005FEFD40057C7690057E7500057C7544557C5644547C74445444044C
+4710:00407BFC488051F84A204DFC688852F84188FFFE00003FF800003FF820083FF8
+4711:200013FE0050FDDC0104790401DC785000507BFE4840482048A47A8A4A8A0478
+4712:2040108003FEFE2202AA7A2203FE7A7202AA7A0248204BFE4850788849040602
+4713:208813FE0088FC0001487BFE01487978010079FC48204BFE487078A84B260020
+4714:202010FE0240FD7C0090797E00007B7C0144797C4944497C4944794C4A80047E
+4715:2088108803FEFC8801FC792401FC792401FC78204BFE4A224A2A7AFA4A0A0206
+4716:200013FE0050FBFE02527BFE000079FC010479FC490449FC490479FC48880104
+4717:4014201207FEF41005D0741405D4755805CA74165442582452A2728A54780000
+4718:4288228807E8FA90041E77E40454785407547554555457485548705452940122
+4719:200013FE0202FBFE02027BFE01087A52039C79084A524BDE48007AA44A520452
+471A:440022FE02AAF8AA00FE70100E54729202107254529252105210750058FE0000
+471B:208011F80210FDFC012479FC00927B0E008079F84A1049FC492479FC4892030E
+471C:2040107C0040FBFE020279FC00A87954028879FC4A8A48F8488878F8488800F8
+471D:2044128402EAFE4E02A47AEE02227BFE02447A844AEA4A4E4AA47AEE4A2203FE
+471E:4040202003FEF888005277AC02AA72A805AC7000510451FC510471FC51040204
+471F:2088108C03EAF88800887BFE01487B6A014A7B6A494C4B6C494A796A4B960022
+4720:2042139C0210FBDE02947A9404207BFC02047BFC4A044BFC4A047BFC49080204
+4721:43FC204001F8F90801F8710807FE744202A4728A547A508051F872885070038E
+4722:202013FE0222FDFC002078F8002079FC002079FC495449FC48407AA44A8A047A
+4723:0008201C11E0110001000100F1FE111011101110111015101910121002100410
+4724:011041102110211007FC0110E110211021102FFE200029103108220804040804
+4725:0000407C2F442144027C0244E4442744217C250025002AFE3200250008FE0000
+4726:0110211017FE1110020003FCF40413E4122413E4122417E41A24100400280010
+4727:000023DE114A114A035A056AF14A12D6102010201120153C1920112007FE0000
+4728:0020202011FC112401FC0020F3FE122213FE1020104014241AA2128A04780000
+4729:0110411027FC211001F00208E2EA26AC22A822AA26EA2A06300022A402520452
+472A:0040244022404A4089F8144822484148BC4824482448244A248A3C8A25060200
+472B:0000240022F84A208820142022204120BC2024202420242024203DFC24000000
+472C:0020242022204A2089FC152423244124BD2425FC2524252425243D2425FC0104
+472D:010001F801007FFE40029FF40820111022880C603018DFF6101010101FF01010
+472E:0020241022FE4A8289141450227E4150BC90241025FE241024103C1024100010
+472F:00402440227E4A82892214AA22724122BCFE2422247224AA25223C22240A0004
+4730:0020484045FC950411FC290445FC80407BFE488849244A224DFC782048200020
+4731:000049F8450895F8110829F8440083FC7A944BFC480049F84890786049980606
+4732:01244A484524940013FC2A94466482947BFC4A484B684A484B6A7A4A4A460362
+4733:00007FFC000000001FF0101010101FF008200440FFFE1000100010001FF80000
+4734:0020FE200020003E7C204420442045FC7C840088444828502E20F05041880606
+4735:0010FE10001001FE7D124514451045FC7D440144452829282F10F22842440482
+4736:0020FE20003C00447CA84410442844D67C1000FC441028902EFEF01040100010
+4737:0000FEFC0004007C7C0444FC440045FE7D0200FC444428442E28F01040680186
+4738:0000FEFE008200827CFE4480448C44B07C9C00B0449E28F02E92F112410E0200
+4739:0020FE2001FE00207C2045FC452445247DFC0020447028A82F24F22240200020
+473A:0048FE48004801FE7C48444845FE44007CFC0084448428FC2E84F08440FC0084
+473B:0000FEFC008400847CFC4484448444FC7C0001FE442028A02EBCF0A04160023E
+473C:00207E20247E18A4FF2829104A2898C600007FFC00001FF010101FF004407FFC
+473D:0020FE50008801047EFA440045E2452A7D2A01EA452A292A2FEAF122412A0164
+473E:0020FE1001FE00007C84444845FE44007CFC0084448428FC2E84F08440FC0084
+473F:00003F2024203F3E21403F5024883F0800007FFC00001FF010101FF004407FFC
+4740:0020FEDE008A00CA7CAA44D244A644007CFE0092449228FE2E92F09240FE0082
+4741:08202AA42CA84920145022887FFE40029FF400001FF010101FF008200440FFFE
+4742:7E7848487E8E420042F87E4848307ECE00007FFC00001FF010101FF004407FFC
+4743:0000FEFE008200FE7C8244FE444444AA7CEE004444AA28EE2E00F0D440AA012A
+4744:0108FA9403DE06B47BDE529453DE529473DE021097FC510860903860C1980606
+4745:0020FE200820102030204A209DFC28204C209A202A204820882008202BFE1000
+4746:08001FF822484488095012207FFC02000D1072A00CC071A006981886E2800100
+4747:000025FC2220424080A425382450249825382454249425502422440243FE8000
+4748:001CFDE01100210061FE95003900517C994435445554914811421242523E2400
+4749:044024481450FFFE800200007FFC02000D1072A00CC071A006981886E2800100
+474A:0020FC2013FE202061FC94243BFE502499FC34205520913E112012A0527E2400
+474B:0040FC2013FE2202600095FC380050009BFE3420552891241222142250A02040
+474C:0000FBDE2042414AA084154A3A525420980037DE505291521094114852542422
+474D:0000FBFE22224020A1FE142039FC512499FC352451FC902013FE102050202020
+474E:0020FD241124212461FC94003BFE5020984035FC55549154115411545154210C
+474F:0020FDFC112423FE612495FC382051FC992435FC544093FE108811D05070238C
+4750:0010FB9022FE42A0A2BE17483ABE52809ABE36A252BE9322123E122252222226
+4751:0020FDFC1088205063FE940039FC512499FC352455FC902011FC102053FE2000
+4752:03F0FD2E11E2212A61E495343BEA5032981E35E054A29134106810A453222020
+4753:0124FA4821244000A3FC16943A6452949BFC364853689248136A124A52462362
+4754:0088FBFE208843DEA25217DE38A0509099FE352053FC952011FC112051FE2100
+4755:03FCF90811F8210865F8990E37F8500897FE3A94579C9294139C12D657BC2084
+4756:1008201CD5F0095051502150D15019502950C94819482948C9440A4452422400
+4757:0C203020C22014204BFE3020C870147024A8CCA815242622C420042028201020
+4758:0C0030F8C288148848883106CA0015FC2484CC8414482450C420045028881306
+4759:0C0031FEC300150449443128C92815102510CD2815282544C584050029FE1000
+475A:100021FCD5040904510421FCD10019402944C94819702940C9420A42523E2400
+475B:10102010D41009FE51122114D11019FC2944C94419282928C9100A2852442482
+475C:10402040D488090453FE2002D08819442A42C8F819882A50C820085051882606
+475D:0C203020C3FC145048883104CBFE140825E8CD28152825E8C528040828281010
+475E:10202020D43E082051FE2122D13819E02922C91E19002978CA480A4A548A2906
+475F:1080209ED7EA088A51CA208AD3EA189228A6C8201BFE2820C850088851042602
+4760:100021FED5100920517C2144D17C1944297CC91019102954C9520A9252502420
+4761:10882088D7FE0888508820F8D0201BFE2A22CB321AAA2B76CA220A22522A2224
+4762:100021F8D50809F8510821F8D0001BFC2A94CBFC180029F8C890086051982606
+4763:1200217ED4400C7C524420FCD1401E7E2A20C8201BFE2870C8A8092452222020
+4764:0C203020C3FC142049543088C90416FA2488CCF8148824F8C42004A829241060
+4765:104021FCD50409FC510421FCD10419FC2820C92418A82924C8200BFE50202020
+4766:10402080D7FE0A52525227FED000181E2BE0C8A219222A74C8A8092456222020
+4767:00407C40448044FC7D04460444847C44444444147C2400442984240444288010
+4768:040025FC2488245024202450008C1FF010101FF010101FF010101FF008201010
+4769:00207C20445044887D04461244207C40458844107C2000442988241044608380
+476A:00007C0045FE44127C14441044907C90449E44907C90009028D02530451E8200
+476B:00807C80448044FE7D40454046407C7C444044407C40007C2840244044408040
+476C:00407C20440045FC7C20442044207C2045FC44207C2000202820242047FE8000
+476D:00807C80450045FC7E04440445E47D24452445247DE401242804240444288010
+476E:00207C10441045FE7C20442044447C8445F844107C200044288225FE44828000
+476F:00807C8044FE45007E204520452C7D7447A445247D3401282922250244FE8000
+4770:00207C20442045FC7C20442047FE7C08440845FE7C0800882848240844288010
+4771:02001FF0081010307EFC2244468C1FF010101FF010101FF010101FF008201010
+4772:00007CFC448444847CFC449044907C88448445327D0802002860241844048000
+4773:08000F7C28447F28A11016283846DFF010101FF010101FF010101FF008201010
+4774:01007FFC01001FF011101FF001007FFE50129FF410101FF010101FF008201010
+4775:00287C2445FE44207C2045FC45247D2445FC45247D2401FC292425244524810C
+4776:00407C2047FE44007C0045FC45047D0445FC44207D2801242A22242244A08040
+4777:20003E7C48440844FF44247C42001FF010101FF010101FF010101FF008201010
+4778:00887C8847FE44887CA8442047FE7C20442045FC7C8400882850242044D88306
+4779:004078204BFE4A027D04490049DE7A524A524B527C9A0094511049128A12040E
+477A:102008107EFC04482448183064CC1FF010101FF010101FF010101FF008201010
+477B:00007DFC450445047DFC451045107DFE451045107D7C014429442544457C8244
+477C:00207C2047FE44207DFC442047FE7C0045FC45047DFC010429FC250445148108
+477D:000079FE49104910797C4910491079FE490049107910017C51104A108AFE0400
+477E:3F500048FFFE08402F2028122F0AF0063FFA20083FF820083FF820083FF80820
+477F:0500397821083D7822083FF808203FF8D0161FF010101FF010101FF008201010
+4780:00807CBC448445087DFE472045207D7C459045107DFE01102928252845448182
+4781:00007BFE4A004AFC7A844AFC4A847AFC4A204BFE7A4802C852304A488A8403FE
+4782:00007DFC442044407DFC455445547D544544452C7C2003FE2850248845048202
+4783:0008700857C85210721E54A457D47114511457D47114010851C84E1484140022
+4784:2040FEFE21203CAC24F447AC54A2887E00001FF010101FF010101FF008201010
+4785:000079FE4900497E790049FE49547948496449427900017E51424A428A7E0442
+4786:00207D2444A844207DFC450445047DFC450445FC7D04010429FC240044888104
+4787:08203E2008F87F282A685D2A08563E8200001FF010101FF010101FF008201010
+4788:001E7BE0494448A879F84908490879FC4904490479FE010252AA4AAA8D0A0004
+4789:00207D2444A845FC7C4047FE44887DFC468A44F87C8800F8288824F844508088
+478A:007C78404BFE4A427A784BC44A3C7AA84B544AF87B8C02FA52884AF88A8804F8
+478B:0200713C57A4502474BC532457A4713C512457A4713C059055584968812A0346
+478C:00087C3C45E05420542057FE54205420542055FC550411042904250445FC8104
+478D:00207C2047FE442055FC542057FE540055FC550455FC110429FC250441148108
+478E:00F87C88448854F85488548854F8540055FC5504550411FC2904250445FC8104
+478F:00007DFC4524452455FC5524552455FC54205410545411422942254A42388000
+4790:00207C2047FE542055FC544057FE5488550456FA5488108828F82488448880F8
+4791:08000800087C7E1008100810FF10141014105610551095102410241054FE8800
+4792:080008FE08827E8208BA0882FF8214BA14AA56AA55AA94BA24822482548A8884
+4793:080008FE08007E5208A40928FF94144A140056FE551095102410241055FE8800
+4794:080008FE08827E8208FE0880FF8C14B0149C56B0559E94F024922512550E8A00
+4795:0800087C08107EFE08920854FF101454140056FE551094FE24AA24AA54AA8886
+4796:0850084808487E40085C09E0FE400840282028242E14280C280458004FFE8000
+4797:0808080808087E0808FE0818FE180828282828482E482888281858004FFE8000
+4798:08400840087C7E8009000800FEF80810282028402E842884287C58004FFE8000
+4799:100013FE10207C20102011FCFD241124112451245D2451345128702050208FFE
+479A:0810081008FE7E10081008FCFF040804286828102E282844288258004FFE8000
+479B:080009FE08207EA008BC08A4FEA408FC280428042E042828281058004FFE8000
+479C:0800080009FE7E1008200820FE68086428A229222E202820282058004FFE8000
+479D:0800080008FC7E2008200820FE2008FC282828242E24282029FE58004FFE8000
+479E:1050105010507DFC10541054FDFC1150115051FE5C525052505A709451108FFE
+479F:0820082008407EFC08840884FE8408FC288428842E8428FC288458004FFE8000
+47A0:080009FE08207E200840087CFEC40944284428442E44287C284458004FFE8000
+47A1:0800080008FC7E84088408FCFE84088428FC28842E0029FE280058004FFE8000
+47A2:0840084008407EFE08A00920FE3C08202820283E2E202820282058004FFE8000
+47A3:0808081C08E07E80088008FEFE90089028B028982E94291029105A004FFE8000
+47A4:1080108011007DFC12041004FDE41124112451245DE451245004702850108FFE
+47A5:0810081009FE7E20084008FCFF44087C2844287C2E442854284858004FFE8000
+47A6:08200820083C7E4408A80810FF2808442882287C2E442844287C58004FFE8000
+47A7:0808081C08E07E8008FE0880FE8008BC28A428A42EA4293C29245A004FFE8000
+47A8:0820082008FC7E20082009FEFE00082028FC28202E20282029FE58004FFE8000
+47A9:0810081008287E440882087CFF000800287C28442E44287C284458004FFE8000
+47AA:080008FE08807E8408B808A0FFBE08A428A428A42EC4288028FE58004FFE8000
+47AB:100011FC10447C4413FE1044FC4411FC108050FC5D84528450FC708450008FFE
+47AC:080C087008107EFE08380854FE920800287C28242E2E2842288A59044FFE8000
+47AD:1020104810847DFE10021048FC841142107C50845D6850105068718450008FFE
+47AE:0810081008287E4408BA0810FEFE0810285828942F122850282058004FFE8000
+47AF:080E08F008227E9208540800FF7C0808281028FE2E102810285058204FFE8000
+47B0:1020102011FC7C20102013FEFC501050115451525E5250905090713050008FFE
+47B1:0828084408927E1008280844FE82097C284428442E44287C284458004FFE8000
+47B2:101010D813947C94109013FEFC94109410D853925CAA50CA5286710250008FFE
+47B3:0820081008FC7E0008840848FEFE080028FC28842E8428FC288458004FFE8000
+47B4:11FC112411247D74112411FCFD041174115451545D7451045204721454088FFE
+47B5:100011EE10227CAA104410AAFD32120011EE50225CAA504450AA711252208FFE
+47B6:11F8110811087DF811081108FDF8108011FC52545C9451245244709451088FFE
+47B7:100011FC11047DFC11001110FD541154117C51105D5451545254747C50008FFE
+47B8:100010F810007C0011FC1020FD241222106050005DFC5104510471FC50008FFE
+47B9:0820084008FC7E8408FC0884FEFC080029FE28202EFC282029FE58004FFE8000
+47BA:081E09F009107F1009FE0910FF7E0942297E29422F7E2942297E5A004FFE8000
+47BB:11F8105010207DFC112411FCFD2411FC112450405DFC50445084712852108FFE
+47BC:0820083C08447E78080808FEFF20085228AC28582EAC284A28AA58104FFE8000
+47BD:08100810087C7E1008FE08A2FE440878281428FE2E10285428B258004FFE8000
+47BE:101E13E0123C7A2012FE12A2FAB812E4129C52805AB85328554A728650008FFE
+47BF:01007FFE44429FF404403FF80440FFFE092017D02108DFF6010011F8290047FE
+47C0:0844082808FE7E10087C0810FEFE08202820287E2E882908287E58004FFE8000
+47C1:1124124811247C0011FC1124FDFC112411FC50205DFE507050A8712452208FFE
+47C2:10FC108410FC7C8410FC1000FDFE114A11FE50005CFC5048503070CC53028FFE
+47C3:1040108811FC7D08125213FEFC50118C162251C85C3251CC503071C050008FFE
+47C4:102013FE10207DFC102013FEFC0011FC110451FC5D0451FC510471FC50888FFE
+47C5:08047F7808403E402A7E3E482A48FF4809883FF00100FFFC110011F8290047FE
+47C6:11FC112411FC7D2411FC10A8FCA813FE10A850A85DFC502053FE702050208FFE
+47C7:0894091809DE7E94095A09DEFE9409FE289028D42EAA29162A2258004FFE8000
+47C8:109411D210907DFE101011D4FD5411D4101453E85C8A51CA509673E250008FFE
+47C9:11FC115411547DFC108011FCFE4411F4115451545DF4504451F4701450088FFE
+47CA:1020103E10207DFE112211F8FD2211FE112051525DAC525A52AA744850908FFE
+47CB:1040107C10847D0813FE1144FD92117C1100517C5D00517C5244727C54008FFE
+47CC:1048104C11FA7C4813FE10A8FDFA134A15EC514C5DEA514A51F6712250008FFE
+47CD:104011FC11247D94114C1124FDFC102013FE528A5D2453FE508070FC51048FFE
+47CE:108811DC10887DDE10881154FE2211FC110451FC5D0451FC510471FC50888FFE
+47CF:1124117412587BFE115412DAFBFE1082102053FE587050A85124722250208FFE
+47D0:13FE120012227ECC124413EEFE4412EE135452105E90529E549073FE50008FFE
+47D1:1020105010887D74120211FCFD5411FC100051FC5D5451FC5154710C50008FFE
+47D2:108813FE10887BDE125213DEF8A011FE112053FC5D2051FC512071FE51008FFE
+47D3:00007C0045FE442044207C201020102010205C205020502050205C20E0A00040
+47D4:00407E404240424042407E60085008484E444844484048404E40F04000400040
+47D5:00007DF8448844C844A87CA8108810505C505050502050205C50E08801040202
+47D6:00207C204420442045247D24112411245D245124512451245D24E1FC00040000
+47D7:00047C1E45F0451045107D10111011FE11105D1051105108510A5D4AE1860102
+47D8:00807C40444047FC44007C0011F011105D105110511051125D12E212020E0400
+47D9:00007900497E49124912791211D2171251125D12515251925922E022004A0084
+47DA:00007CFC4400440044007DFE104810485C485048504850485C88E08801080208
+47DB:00207C20442047FE44207C2011FC11245D245124512451345D28E02000200020
+47DC:00207C20442045FE45227D221122112211525D4A518A510251025D02E10A0104
+47DD:00007CF84488448844887D06120011FC10845C845048505050205C50E0880306
+47DE:00207C20442044A844A47CA21122112012245C245028500850105C20E0C00300
+47DF:0200077C384420442044207C3F90241024502C5C24502650255044B0449E8500
+47E0:00287C244424442045FE7D201124112411245D285128516851945D14E02C0044
+47E1:00047C1E45F0451045107D10111011FE11105D1051105108510A5D4AE1A60112
+47E2:00807C80448044FE45027D04122010205CA850A4512451225E22E02000A00040
+47E3:00207C284424442045FC7C20107010705CA850A8512451245E22E02000200020
+47E4:00407C204428440844087C48105411525D525160526050445CC4E144023C0000
+47E5:00007DF84408445044207C1013FE10625CA450A0512052205C20E02000A00040
+47E6:00087C3C45E0442044207DFE104010405C7C50A450A851285D10E22804440082
+47E7:00007C0045FC452445247D241124112411FC5D245124512451245D24E1FC0104
+47E8:00007DFC4504450445047DFC1120112011FE5D205120511051125D4AE1860102
+47E9:00207C20442045FC44207C20102013FE5C205040504050885D04E3FE01020000
+47EA:00047C1E45E0440044207C1011FE100410085C105020504050805D40E23E0000
+47EB:0100111009207FFE40029FF4101010101FF00100110011F81100290047FE8000
+47EC:00087C1C45E0450045007D00110011FE5D105110511051105D10E11007FE0000
+47ED:00807C80448044FE45407D401240107C5C4050405040507C5C40E04000400040
+47EE:00907C944492451245107F7E1510111011105D285128512851285D44E1440182
+47EF:00087C3C45E0442044207DFE102010205C2051FC510451045D04E10401FC0104
+47F0:00407C40449C450046407C4010BE118812885C885088508850885C88E0A80090
+47F1:00207C2047FE442044207DFC112411245D24512C507050A85D24E62200200020
+47F2:00407C20442047FE44407C88110413FE10925C905090509051125D12E20E0400
+47F3:00003EEE2222222222AA3E660822086628AA2E22282228AA284458004FFE8000
+47F4:00007DFE45004500457C7D00110011FE5D505152515451485D48E24402520460
+47F5:00287C244424442045FE7C20112010B25CB4506850A851245E22E02000A00040
+47F6:00207C2044A844A844A87D741222102010205DFC5020502050205C20E3FE0000
+47F7:0104790E493049204FE07920113E11641DA457245124512451245D24E1440384
+47F8:00207C20447C44C445287C90106011805C48504851FE50485C48E08800880108
+47F9:00047C1E45E0442245127C941080100811FE5C085088504850485C08E0280010
+47FA:00007EFC4284428442FC7E84088408FC4E84488448FC48004E48F04400820102
+47FB:00207C204450448845047E0210F810205C2053FE502051245D22E22200A00040
+47FC:00087C0C44EA440A44087DFE1048104811485D6851485148514A5D6AE3860102
+47FD:00407C2045FC444044907D0813FC10045D505150515051505E50E2520452080E
+47FE:00007BDE4842494A4884794A125214201C0053DE5052515250945D48E2540422
+47FF:00007DF84408440845F87C08100813FE5C205222517450A85D24E22200A00040
+4800:00207D2444A444A844207DFC1104110411745D545154515451745D04E1140108
+4801:0040789049084BFC49087A1014A417BE50825C0053FC50005800E00007FE0000
+4802:082008207EFC08301C682AA4C92208201FF010101FF0010011F81100290047FE
+4803:00007BFE482048204BFE7A221222133252AA5EAA537652665A22E222022A0204
+4804:00507C50445045FC45547D54115411FC5D545154515453FE5C00E05000880104
+4805:00007DFE4502451A45627D22112211FA5D225132516A51A65D22E12201FE0102
+4806:00007CFC448044F844807CF8108013FE11405D245128511051085D44E1820100
+4807:00007DFE4502450245FE7D10115211525D52517E511051525D52E252027E0402
+4808:0020782049FC482448247BFE1024102451FC5E22517450A85924E22200A00040
+4809:00207C1045FE450246047CF8108810885CF85080508050FC5C84E08400FC0084
+480A:00907C904490479E44907C901090139C10905C905090539E50905C90E0900090
+480B:00407C8045FC452445247DFC112411445DFC5090511053FE5C10E01000100010
+480C:00207C2247B444A844A87D2412A210405DFC510451FC51045DFCE10401140108
+480D:00007BDE4A424A424A427BDE1200123E53D25E12521453D45A08E21402240242
+480E:00007DFE4502450245FE7D0011FE11205D4451FE511251105EFEE210041009FE
+480F:00107BD448584A52498C7888110412FA10205C2053FE502050505C88E1040202
+4810:00007DFC450445FC45047DFC110411FC5C28502453FE50505C50E08801040202
+4811:002078204BFE485048887B2611FC10201C2053FE5000502051FC5C20E02003FE
+4812:00807C9E449245D244927C9E109211D25D52515E515251525DD2E022002A0044
+4813:00887C48445047FE44507C5011FC11545D54518C510451FC5D04E10401FC0104
+4814:00007C844448440045FE7C20104411A810305C585198503450525D90E0500020
+4815:009078924AD44A984A927AD2170E10201C2053FE507050A851245E22E0200020
+4816:00207D2044BE444244847F101110112811445C8250FC508450845C84E0FC0084
+4817:00207C4045FC450445FC7D0411FC11045DFC5028502453FE5C50E08801040202
+4818:00207C4045FC450445547D241154110411FC5C00511251D451185D52E192010E
+4819:00207C1045FE448444487DFE1102122410105DFE5040507C50445C84E0940108
+481A:0080F04097FC94049110F208203C23D0A290BA90A290A288A288B4A4C4D40892
+481B:0008783C4BC048044A44792811FC12201C2053FE5020512451245D24E1FC0004
+481C:00887C8845FE448844007DFE1088108810F85C8850F85088509E5DE8E0080008
+481D:00007CF84488448844F87C0011FC11045DFC510451FC51045DFCE05000880104
+481E:0014F012901097FE9410F49024D22492A7F2BC94A494A5C8BAAAE89A11A60042
+481F:08207E2008F8FF2814287F6A082AFF5608821FF010101FF0010011F83100CFFE
+4820:14507FFC245247CE80007FFC41043FF821083FF810101FF0010011F83100CFFE
+4821:00207C3C442045FE45227D3811E4111C11005D7C5144517C51445D7CE14402FE
+4822:0820FFFE08203FF824483FF800007FFE40029FF410101FF0010011F83100CFFE
+4823:00007BDE4A524BDE4A107A5211CE10001C8853FE5088508853FE5C88E1040202
+4824:00007DDC4554455445DC7C0011FC112411FC5D2451FC502053FE5C20E0200020
+4825:0108F10895489390911EF7D425642554A554BF54A5D4A548A548B554C46404C2
+4826:00807CEE454A444A45FA7C4E10AA110010FC5C84508450FC50845C84E0FC0084
+4827:00007BFC4A044A044BFC7A2212FC122813FE5E2052FC538452FC5C84E4FC0884
+4828:00807CF8450847FE45447D9211FE11005D7C5100517C51005D7CE244027C0444
+4829:0020F13C912097FE9010F01423FE2210A3F0BA54A254A2D4BB68E44A08960322
+482A:00447A844AEA4A4E4AA47AEE122213FE12445E8452EA524E52A45EEEE22203FE
+482B:03F0792E49E2492A49E4793413EA10321C1E53E050A2513450685CA4E3220020
+482C:00A0F74E915A952A922AF21C25DA280AA1EAB92AA1EAA22CA148B068C3880008
+482D:0108F10897CE91129124F7DE2552255EA7D2B91EA392A55EA940B114C1120122
+482E:012478A849FC48404BFE790813FC152251FC5D2051FC512059FEE00202AA0004
+482F:0040F0A0911092089DF6F0002EEE2AAAAEEEB800AFFEA922AFFEB922C92A0804
+4830:00887BFE48884BDE4A527BDE10A0109011FE5D2053FC552051FC5D20E1FE0100
+4831:03FE7A024BFE4A924A547A9212FE12AA52FE5F2252FA52AA5AFAE22205FA0004
+4832:102020207C5044507C8845247E12441045FCFC040C0814882450442094100810
+4833:102020207D2445247D2445247DFC44204420FD240D2415242524452495FC0804
+4834:102020107C1044007DFE44007C0444844484FC480C4814482450441095FE0800
+4835:104420447C4444847CBE45847E8444A44494FC940C8414842484448494940888
+4836:104020407C8044FC7D2046207C20442047FEFC200C5014502488448895040A02
+4837:105020507C5045527CD444587C50445844D4FD520C5014502492449295120A0E
+4838:102020207DFC44507C8845047EFA440047FEFC400C8015FC2404440494280810
+4839:102020107C1045FE7C2044247C4444F84412FC220C4415882410442894440982
+483A:108020407C5E45027D02457A7D4A454A454AFD4A0D7A154A25024502950A0904
+483B:102020107DFE45027C4844847D0244FC4404FCFC0C8014FC2404440494280810
+483C:102020507C8845047EFA44007DE2452A452AFDEA0D2A152A25EA4522952A0964
+483D:102021247924492479FC48007BFE480049FCF904190429FC488888502BFE1000
+483E:100023DE7A524BDE7A524BDE7A024A224A22FA221A522A4A4A8A8A022A0A1204
+483F:102021FC7D2445FC7C2047FE7C0045FC4504FDFC0D0415FC250445FC94880904
+4840:101021FE7C0045FE7D02457A7D4A45FE4400FCFC0C8414FC248444FC940009FE
+4841:111020907BDE48107A5E49827BDE48104BDEFA501BDE2A504BDE8A502A5212CE
+4842:080408040844FF4408447F4449447F4449447F4C0874FF440804080408040804
+4843:104010401040FE4011FC7C4454447C4454447C841084FE841104110412281410
+4844:100010F01090FE9010907C9054907C9054907C901090FE9210921112110E1200
+4845:108210921092FE9210927C9254927C9254927C921092FE921092111211021202
+4846:101010901090FE8810887D2455247E2254207C401048FE44108411FE10821000
+4847:1000100011FCFE0010007C0057FE7C9054907C901090FE9011121112120E1400
+4848:100810881050FE2010507C8855007C0854887C881050FE501020105010881306
+4849:104010201000FDFC10007C0054F07C9054907C901090FE9210921112110E1200
+484A:1008101C11E0FD0011007DFC55447D4455447D281128FF101110122812441482
+484B:102010201020FDFE10207C2054207DFC54847C881048FE501020105011881606
+484C:104010401040FC4013FE7C4054807C9054907D201120FE481244148411FE1082
+484D:102010201020FC2011FC7C2054207C2055FE7C201050FE501088108811041202
+484E:102010101010FEFE10827C8254827CFE54827C801080FE801080110011001200
+484F:100811C81048FE4810487DC855087D0855107DD01054FE541052105E12821100
+4850:102010101010FEFE10827D0454407C4854507C601040FE4210421042103E1000
+4851:100011FC1104FD0411047DFC55207D2055FE7D201120FD101112114A11861102
+4852:1000100011FCFD2411247D2455247D2455FC7D241124FD241124112411FC1104
+4853:11001100211C47C0810017C0257E67C8A54827C821082FE82108210821282110
+4854:10201020107CFC8411487C3054207C4855907C3E1042FDA41018101010601180
+4855:100011F81010FC2010247DA854B07CA855287D241222FCA01040100011FC1000
+4856:1000100011FCFE0010507C8855247C2054207DFC1020FE201020102013FE1000
+4857:7DF0111011901D52F20E05001FF001001FF011101FF011101FF00100FFFE0100
+4858:1080108010FEFD0211027EFA54AA7CAA54FA7CAA10AAFEFA108A100210141008
+4859:1020101010FCFE8410847CFC54847C8454FC7CA210A4FE981090108810C41082
+485A:1020104011FCFD0411047DFC55047D0455FC7C501050FE5010921092110E1200
+485B:10101010FEFE10107C7C545454547C7C545454547C7C1010FEFE101010101010
+485C:1020102011FCFC2010207DFE54887D0456227C2011FCFE201020102013FE1000
+485D:2040202023FEFA022504F900A9DEFA52AA52FB52249AF894211021122212240E
+485E:1FF010101FF010101FF01010FFFE11103FF8C1061FF011101FF01110FFFE0100
+485F:1020104010FEFC9210927CFE54927CA254FE7C481088FDFE1008100810081008
+4860:10201020103EFE2010207CFC54847CFC54847CFC1084FEFC1000104810841102
+4861:1110111211D4FD1811527D92552E7C4055FC7D041104FDFC1104110411FC1104
+4862:1040102011FEFD0211027DFE55007D0055FE7DAA11AAFEFE12AA12AA14A21086
+4863:100013FE1222FC2011FE7C2055FC7D2455FC7D2411FCFC2013FE102010201020
+4864:02003FD00260FFFE1C10EFF008100FF001007FFC11101FF01110FFFE01000100
+4865:1040102013FEFE0210507C8855247C5054887D0412FAFC881088108810F81088
+4866:21F820882070F98C2000FBDEAA52F98CAA52F82023FEF87020A8212426222020
+4867:1040108011FCFD0411047DFC55007DFE55007DFE1002FEAA12AA140210141008
+4868:082004407FFC0100FFFE04001FF0E1003FFC01001FF011101FF01110FFFE0100
+4869:1020102013FEFC2011FC7D0455FC7D0455FC7D0411FCFD0413FE108811041202
+486A:1020101011FEFD0211027DFE55007DEE55227DAA1166FD22116612AA12221466
+486B:10201220117CFCA410187CE657107D7E55107D7C1110FDFE1110111012FE1400
+486C:200021F82108F9F82108F9F8A800FBFCAA94FBFC2000F9F82090206021982606
+486D:1084104811FEFE1010FC7C2055FE7C40547C7CA41124FEFC1044104411FE1000
+486E:112411241224FCA411547D4A57927D0855087D28112EFD2811281158114E1180
+486F:1020104011FCFD24117C7D8C55547D2455547DFC1040FC2412A2128A14881078
+4870:0878FF4808863E782A483E30404881043FF801001FF011101FF01110FFFE0100
+4871:200023FE2200FA7C2244FA44AA7CFA00AAEEFAAA22AAFAAA22EE220023FE2000
+4872:100013DE1252FE5213DE7C0055FC7D2455FC7D2411FCFC2013FE102010201020
+4873:214021442158FBF02150F9D0A95EF9D4A954F95423F4F8142154223424142024
+4874:102011FC1088FC5013FE7C0055FC7D2455FC7D2411FCFC2011FC102013FE1000
+4875:104412241128FC7E10107C28574A7D1C55287D4C111AFD2A1148111012FE1400
+4876:201023C8227EFA402262FBD4AA00FA3EABC8FA48267EFA48224823C822482008
+4877:108813FE1088FC2011FC7C2057FE7C4054887DFC1000FDFC1154115417FE1000
+4878:108813FE1088FDFC11547D5455FC7C2854247DFE1120FD241114114A11961122
+4879:102011FE1020FDFE11027EFC54A47CFC54A47CFC1000FDFE10A210BC1160123E
+487A:208823DE2088F9DC2088FBDEA888FBFCA804F9FC2004FBFC204022A4228A247A
+487B:204021FC2124F994214CF924A9FCF820ABFEFA8A2124FBFE208020FC2104220C
+487C:200021FC2020FBFE2222F9ACA820F9ACA800FBEE22AAFAAA22AA22AA23EE22AA
+487D:252827BE2948FFBE2318FDAAA946FBFCAA04FBFC2204FBFC220423FC21082204
+487E:210821EC210AFFEA2928FBC8A93EFFE8A948FBE82A28FB682AA82BF42AB432A2
+487F:21FC202023FEFA2221ACF820A9ACF800ABBEFAAA23BEF80023FE212422AA27FE
+4880:104010401040FEFE2080290048F87E08081008200E40F8804902090208FE0800
+4881:100010FC1084FE84208428FC48847E84088408FC0E84F8844884088409140A08
+4882:104010201020FE0021FE280048047E84088408480E48F848485008100BFE0800
+4883:00407C2045FC44887C5043FE7C20A5FC24203C2010080810066001800E70F00E
+4884:101024FE42447E2800FE7E10427C7E10082008207EFC08301C682AA4C9220820
+4885:02001C7810081E7810081FF800003FFC20002FF820003FFE288848504A308C0E
+4886:000001FE7D00457C450001FE39542948296429422B082DFE4948412882080418
+4887:200011FE7D00457C450001FE39542948296429422B082DFE4948412882080418
+4888:3FFC20002FF820003FFE286849104A888C643FF8D55613901FF00A2009200FE0
+4889:111827C8244836D8254826C837D800003FFC20002FF820003FFC24484430860E
+488A:000023F81010102000400040F7FE104010401040104011401080280047FE0000
+488B:000023FC1090109000900090F090109010901110111012101410280047FE0000
+488C:0040404020402FFE00400040E7FC244424442444245424482040204050008FFE
+488D:00802040104017FE01000100F1F8110811081108120812081450282047FE0000
+488E:000023FC1090109000900090F7FE109010901110111012101410280047FE0000
+488F:001021101090109000100210F1101110101E17F0101010101010281047FE0000
+4890:000021F81108110801F80108F10811F811081108110817FE1000280047FE0000
+4891:0008203C13E0122002200220F3FE122012101212128A13261212280047FE0000
+4892:0080204017FC100001100208F414111010A0104010A011101208280047FE0000
+4893:0040202013FE1202040401FCF020102017FE10201020102010A0284047FE0000
+4894:004020A0111012080DF60000F00013F812081208120813F81000280047FE0000
+4895:002820241024102003FE0220F224122413A812281212121A14261442288047FE
+4896:0040204013F8104807FE0048F3F8104013F81040104017FC1040284047FE0000
+4897:0120412021202FFC09240924E9242FFC2924292429242FFC200050008FFE0000
+4898:0040202013FE120204140010F3FE1010111010901090101010101050282047FE
+4899:000023FC1204120403FC0204F20413FC1204120413FC100011081204280047FE
+489A:00004FFE204027FC044407FCE44427FC2040274020C020B02108220450008FFE
+489B:000023FC12041294030C0204F2F41294129412F4120412141208280047FE0000
+489C:03F8200811F8100803F80000F7FC144413F81248124812681250284047FE0000
+489D:000027FE10901090039C0204F204139C10901090109017FE1000280047FE0000
+489E:0210421022102F7C02100630E7382AD42A52329223102210221050008FFE0000
+489F:0420422020202FBE04480488E72825282510291029283544228450008FFE0000
+48A0:00404244224424A801100208EC06211021102FFE21102210221054108FFE0000
+48A1:029042902FFC229002F00200E3F82040204027FC21502248244450408FFE0000
+48A2:004040A0211022880C4603F8E20823F8220823F8220025FC250429FC50008FFE
+48A3:002020FE134C107007A001FEF00011FC100011FC100011FC110411FC280047FE
+48A4:03904E18221422100F7E0610E7382AB42A54325022902210221050008FFE0000
+48A5:000027FC1040127802400FFEF00013F8120813F8120813F8120813F8280047FE
+48A6:0080204017FC1040009005E4F24814A411F01010104017FC10401040284047FE
+48A7:000027BC108414A4029404A4F0501188162610C0131010641388103028C047FE
+48A8:02244224242429240154024AE6922A102250225E2250225022B0229E53008FFE
+48A9:00105F902210221E0FA404C4E4943FD420082F88289428A22FC250008FFE0000
+48AA:0078478020802FFC01200210E5E8292627F8240825E8252825E8241850008FFE
+48AB:072025FE1540157C0690057EF500157C1544157C1644147C1444144C280047FE
+48AC:003C47C020442224010807FEE4022A08220823BE24882AA8213E220854088FFE
+48AD:0208411027FC204003F80040E7FC20002440227C208422282C20245054888FFE
+48AE:000047FC20402FFE08420358E0402358200027FC244427FC244427FC50008FFE
+48AF:0244444820B0230C0C420244E4A823183C06240827BE28883528223E54088FFE
+48B0:07BC208414A4129404A40120F21017FC1A2013FC122013FC122013FE2A0047FE
+48B1:004027FC104013F8000007FCF4A417FC120813F8120813F8120813F8291047FE
+48B2:07BC24A417BC14A407BC0140F3FC124017FC1A4013FE129010601398280047FE
+48B3:00003C7C24442448244824502448244824442444244425684650444080400040
+48B4:0000077C78440848084808500848FFC808440844104410682050204040408040
+48B5:00007E7C004400480048FF50104810482044204444444268FF50414000400040
+48B6:0800087C084408487F48085018481C482A442944484488680850084008400840
+48B7:00003F3E212221242924252825242124FFE22122212221342128412045208220
+48B8:00003F3E2122212421243F28212421243F2221222122213427A8F82040200020
+48B9:00007FBE4022402440247F2841244124412241227F224034402840207FA00020
+48BA:0800087C49444948494849507F48084808444944494449684F50794000400040
+48BB:00007FBE4822482448247F2841244124412241227F224834482848207FA00020
+48BC:1200123E122212247F241228122412241222FFA2002212341128212020A040A0
+48BD:044004407FFC0440FFFE10102FE8C8260FE000001FF011101FF0100410040FFC
+48BE:0800287C28443E484848085008487F4814441444144414682550264044408040
+48BF:1000083E0822FFA480A411281024FFA42222222242223434082814202220C120
+48C0:1000107C3F4421484248BFD020482F48294429442D442A6828504A404C408840
+48C1:0000F7BE10A210A494A452A852A410A431A252A294A210B410A810A052A02120
+48C2:0800087C08447F4808483E5008487F4818441C442A442A684850884008400840
+48C3:2000207C3F444848884808507F48084808442E44284428682F50F04040400040
+48C4:0800087C144422484148BE50084808487F4408442A4429684950884028401040
+48C5:00003FBE202220242F24202820243FA4282228A22D222A34292848A04C208820
+48C6:00007FBE002224A449249228492424A400227FA20822083408280BA0FC200020
+48C7:08000A7C094408487F480850084849482A4408441C442A68C950084028401040
+48C8:00007CF8448844887CF800007DFC5524552455247DFC410041004D02710240FE
+48C9:20401248444420140860738020001FF010101FF000003FF821083FF820021FFE
+48CA:0800493E29222A2408247F28412441245D225522552255345D28412045204220
+48CB:010007BE782208A444A42528202404247FA20C221622153424A8442084200420
+48CC:0800041E7FD2401243945E14521852145FD252125212521A5554595094D00250
+48CD:0800083EFFA214242224492888A47F2449227F2249227F3408280A200C200820
+48CE:248024BE49229224492424A824A400247FA248A248A27FB448A848A07FA040A0
+48CF:1500153E152225242FA465286524A524252225223FE22034252824A028A03020
+48D0:2200227C7F4422482A4808503E482A482A442A44FF4408681450124022404040
+48D1:00003FBE20222FA42AA42AA82FA42AA42AA22FA222222FB4422843A09C200820
+48D2:0800083E7F2249247F240828FFA400247F22412249224934492814202220C120
+48D3:0000FFBE00227F24412441287F240024FFA2A2A294A2FFB488A888A08AA08120
+48D4:0800497C2A4408487F48415041487F4841447F44414441687F50004022404140
+48D5:00007FBE48227F2448247F28482448247FA200A2AAA2AAB4AAA880A005200220
+48D6:00007E7848487E4848787E0048FC48A47EA402A4AAFCAA80AA8082821482087E
+48D7:0800103E7F2241247F2441287F241024FFA22222492288B47F68082008200820
+48D8:0800493E2A22FFA480A43E28222422243E2208227F22083408280F20F0204020
+48D9:0400445E44527FD200147BD44A584A547BD24A524A527BDA4A544A50AB501490
+48DA:08007F3E4922FFA449247F2808247F2449227F221022FF34212872200C20F320
+48DB:0800083EFFA21C242B24C8A814242224492288A249222A34492888A028201020
+48DC:08000F3E08227FA448A44E287924472440225F2251225F3451285F2051A0BE20
+48DD:00003FDE205220523FD422342FD822943FF222122FD2385A2FD448504FD08850
+48DE:0000F7BE94A294A4F7A422281424FFA40822492249227F340928102020204020
+48DF:0000F7BE2122A524F7A46328B5A421247FA240A240A27FB440A840A07FA040A0
+48E0:1100111E7BD21112FFF411142A9844543FB2209220923F9A209420903F902090
+48E1:4100223EFFA208247F240828FFA4152464A22422FFA224343528E2A025A068A0
+48E2:2280229E27D2FA922294729427F8F81427D274526C52A7DA2454245027D02450
+48E3:2480151E7FD240521F1411147FD855544E527FD204127FDA0414FFF02A504530
+48E4:7BC04A5E7BD24A527BD414143FD86414BF9224123FD2001A3F9410900F10F090
+48E5:0020FFA0142014227F225524552855305720612041207F22412241227F1E4100
+48E6:0020FFA0142014207F7C5524552455245724612441247F24414441447F944108
+48E7:0020FFA8142414247F20553E55E055205720612041207F20411441147F0C4104
+48E8:0010FF901410141C7F70551055105510571E61F041107F12411241127F0E4100
+48E9:0020FE20282029FCFE20AAA8AAA8AAA8AEA8C2A882F8FE2282228222FE1E8200
+48EA:0010FE10281028FEFE10AA10AAFEAA92AE92C2928292FE9A82948210FE108210
+48EB:0010FE10281028FEFE10AA10AAFCAA44AE44C2448228FE2882108228FE448282
+48EC:0048FE4428442840FE5EABE0AA40AA44AE44C2488230FE228252828AFF068202
+48ED:0010FE1428122812FE10AAFEAA10AA10AE10C2288228FE2882288244FE448282
+48EE:0028FE2428242820FEFEAA20AA20AA3CAE34C2548254FE5482888288FF148222
+48EF:0000FFBC142414247F24553C552455245724613C41247F24412441247F7E4100
+48F0:0000FFBE142014207F20553E5522552257226122413E7F20412041207F3E4100
+48F1:0020FFA01420147C7F445584557455545754615441747F54410441047F284110
+48F2:0020FE2028402848FE84AAFCAA04AA48AE48C2FE8248FE4882488288FE888308
+48F3:0000FEFC28042804FEFCAA04AA04AAF4AE94C2948294FEF482048204FE148208
+48F4:0000FE4428282892FEAAAAC6AA82AAFEAE28C2288228FE288248824AFE8A8306
+48F5:0000FEFE28482848FE78AA48AA48AA78AE48C248824EFEF882088208FE088208
+48F6:0008FE1C28702810FE10AAFEAA10AA10AE10C27C8244FE4482448244FE7C8244
+48F7:0010FE502850287CFE90AA10AA10AAFEAE10C2388238FE5482548292FE108210
+48F8:083813C0304057FC9040104013F81000FFFE04403FF82848303827C820083FF8
+48F9:0050FE5828542894FE90AA9CABF0AA94AE94C2948298FE9882948294FEAC82C4
+48FA:0000FE7C28442844FE7CAA00AAFEAA82AE82C2FE8282FE8282FE8282FE8A8284
+48FB:0010FE1028282844FE92AA08AA7CAA04AE08C210827CFE4482448244FE7C8244
+48FC:0020FE1028FE2800FE00AA7CAA44AA44AE7CC2108254FE5282928210FE508220
+48FD:20003E7C48440844FF441444227C4000FFFE04403FF82848303827C820083FF8
+48FE:0020FE1028FE2882FF04AA7CAA44AA44AE7CC2448244FE7C82448244FFFE8200
+48FF:0000FE7C28102810FEFEAA10AA10AA50AE20C2FE82AAFEAA82AA82AAFFFE8200
+4900:0044FE4429FE2844FE54AA10ABFEAA20AE40C27E82C2FF4282428242FE7E8242
+4901:0048FE4829FC2848FE78AA48AA78AA48AE48C3FE8280FEA882C48280FEFE8200
+4902:0088FE882BFE2888FE88AAF8AA88AA88AEF8C22083FEFE7082A88324FE228220
+4903:0040FE2029FE2800FE84AA48ABFEAA00AEFCC2848284FEFC82848284FEFC8284
+4904:0000FEFE28102820FEFEAAAAAAAAAABAAEAAC2AA82BAFEAA82AA82AAFEFE8282
+4905:0010FE1028282844FE82AA7CAA00AAE2AEAAC2AA82EAFEAA82AA82E2FEAA82A4
+4906:0010FED42848294AFE84AA84AB02AAF8AE20C22083FCFE2082508248FE848304
+4907:0020FE1028FE2882FE28AA44AA92AA28AE44C282827CFE0482288210FE2882C4
+4908:0044FE82297C2820FE40AA7CAA04AA28AE10C2FE82AAFEAA82AA82AAFFFE8200
+4909:0010FE0C282428AAFEB0AB24AA64AB9CAE00C2FE82AAFEAA82AA82AAFFFE8200
+490A:0044FE4428FE2844FE00AAFEAA44AA44AE7CC244827CFE44824E82F4FE048204
+490B:4408240C280AFE0829FE2808FE08AAEAAAAAAEAAC2ECFE0C822A82CAFE168222
+490C:0020FE2028502848FEA4ABFEAA84AAFCAE84C2FC8280FEFC83448344FE7C8244
+490D:0088F88823FE2088F888A8F8A820ABFEDA228B328AAAFB768A228A22FA2A8A24
+490E:00FCFE28281029FEFE52AA94AB50AA20AEFEC2AA82C6FEBA82AA82BAFE828286
+490F:0028FEEE282828EEFE28AAEEAA28AA06AEF8C21082FEFE1082FE8210FE508220
+4910:0000FBDE208822A8FBFEA988AADAACA6D9F889088908F9F889088908F9F88908
+4911:0028FE28287C2828FE28AAFEAA10AA7CAE54C27C8254FE7C82008228FE448282
+4912:0124F92422AA23AEF924AAAAABAEA924DBFE89108914F9148A8A8A4AFA168C22
+4913:0048FE4829FE2848FEFEAA82AB7CAA00AEFEC22082D2FE2C82D8822CFECA8230
+4914:42043FD88A904F9E2A945FD48224FFFE04803FF82488287830083FF820083FF8
+4915:0124F974225822DAFBFEA954AADAABFED8A288208BFEF87088A88924FA228820
+4916:01FCF90421FC2104F9FCA888A9FCA888DBFE88888924FAAA887088A8F9248860
+4917:08207F7C14C47F3822D63E3822507F7C0810FFFE04403FF8284837B820083FF8
+4918:0148F94C22AA2008FBFEA948AB68A94ADB6A894A8B6CF94C896A8B8AF8168822
+4919:00F8F90821F02010FBFEA8C4AB28A8D4DB3288D08A28FFBE8AAA8FBEFA8A8FBE
+491A:00003DFC2524252425FC3D24252425FC24203C2025FC24202420442057FE8800
+491B:10041004288424844284BC8410841084FE8C109494E4588450041E04F0044004
+491C:102010202820243C41E0B82010201020FC3E13E09420582250221C22E01E4000
+491D:10001040299E25124112B91211121112FD121112955A599451101C10E0104010
+491E:10401050284824484040B9FE10501050FC5010509490589050921D12E10E4200
+491F:1000100029FE25024302BC0010781048FE4810489448584A504A1E8AF0864100
+4920:10101010281024904290BC90109E1090FE9010909490589050901E90F1FE4000
+4921:10201020282025FC4124B92411FC1124FD24112497FE590451041D04E1144108
+4922:100011FC290425044104B9FC10401040FDFC10449444588450841D04E2284410
+4923:1008103C29E024204124B8A410A81020FDFE10209420582050201C20E0A04040
+4924:10201010281025FE4220BC24104410F8FE1210229444598850101E28F0444182
+4925:1040104028FC25044208B9FE1100117CFD4411449554594851421E42E23E4400
+4926:10A810A428A42520412EBBF015201124FD2411249528591051321D4AE1864102
+4927:1000100029FC25044104B97411541154FD5411549574590451041DFCE1044000
+4928:1004101E29E025004106B97811501150FD5211549548594851441E54E2624440
+4929:1020101029FE25024000B81C10E01020FC20103E95E0582050221C22E01E4000
+492A:100010F8288824884088B88811261220FDFE1020947058A851241E22E0204020
+492B:102011242924252441FCB82010501088FD441222942059F850081C10E0104020
+492C:201022105110491084547A5222522090F81021142E04B20862083A10E22000C0
+492D:21842068503048C88304784023FE20A0F92023FC2D24B12461343928E0200020
+492E:101010102890249E4090B89013FE1000FC1010929492591452081C10E0604380
+492F:100213E2294425484140B942114213E4FD4811409542594251441E44E2484450
+4930:108010807DFC124410481CA0E11006C81830EFEE01003FF809200540FFFE0000
+4931:10201124292425FC4000B80C11F01100FD0011FE9510591051101E10E2104410
+4932:1020102029FC24204020B82013FE1048FC48114C954A5A4A50881C88E1284210
+4933:2080204057FE492081207A3C22442664FA9423482A48B23062203A50E2880306
+4934:200021FC5008481082227AAA22722222FA7222AA2B26B2A262423A02E3FE0002
+4935:109010902890279E4090B8901090139CFC90109094905B9E50901C90E0904090
+4936:102010202BFE24504088B924122211FCFD2411FC952459FC50221C22E01E4000
+4937:200023FE52004AFC82847AFC228422FCFA2023FE2A48B2C862303A48E28403FE
+4938:208020FC510449F880087BFE204020A2FB3420582894B33460523890E3500020
+4939:104010202BFE262240A4B92810501088FD0410F89488588850501C20E0D84306
+493A:100010022BDC24904090B91011DE1354FD541154955459D451541C24E0244044
+493B:104010402BFE248041FCBA2015FE1000FDFC110495FC590451FC1D04E1144108
+493C:2040208051FC490481FC790421FC2020F83223B428A8B12861243A24E4A20040
+493D:100011FC295425544154B9FC102010A8FCA41124942058A850A41D24E0204020
+493E:101E11E0282225124094B880102011CEFD02110295CE590251021D02E1FE4102
+493F:108013DE288A25CA408ABBD210A61008FCF0102095FC582053FE1C20E0A04040
+4940:10201124292425FC4020BBFE10001020FDFC1124952459FC50201C24E3FE4102
+4941:200023FC500848D080207BFE228A2252FAFA22222A22B3FE62223A22E3FE0202
+4942:200023FE52024CFC800079FC204020A4FB3820582894B33460523890E3500020
+4943:104010402BFE26924088B9FE13101510FDFE1110951059FE51101D10E1FE4100
+4944:200023FE52004A4882487AFC22482248FBFE22002AFCB28462FC3A84E2FC0484
+4945:01007FFC01007D7C11107D7C11101CFEE10006C01830EFEE01003FF80920FFFE
+4946:0100FFFE04407C7C04403C7804407D7C06C01830EFEE01003FF811100920FFFE
+4947:1020101029FE25024102B9FE110011EEFD2211AA9566592251661EAAE2224466
+4948:2088208853FE488880247BFE20502088F904228A2888B3FE60883888E1080208
+4949:100013FE2A02244040F8B908121011FCFD24112495FC585050581C96E112420E
+494A:102013FE282025FC4020BBFE100011FCFD0411FC950459FC51041DFCE0884104
+494B:1020101029FE240042FCBC8410FC1000FEFC10089410585050201E00F1544252
+494C:020001007FFC40043C7824483C7824483D7806C01830EFEE01003FF80920FFFE
+494D:08207E2008F8FF2814287F6A082AFF56098206C01830EFEE01003FF80920FFFE
+494E:23FE220052FC4A0083FE7A9422A822C4FA0022FC2A84B2FC62843CFCE484088C
+494F:2280228E54EA494A804A724A25EA2C4AF44A256AA54A754E25683788C4080408
+4950:00207E7C14C40838FEC62A2048FCA844118C06C01830EFEE01003FF80920FFFE
+4951:102010202BFE24A840A8B97412221070FCA811469478588851501C20E0504180
+4952:7CF8048804F87C2041FC7D2405FC04282BFC16C41830EFEE01003FF80920FFFE
+4953:1088108829FE248840F8B88810F81088FDFE108895245AFA50201C20E1FE4000
+4954:200023FE5050485083FE7A52225223FEF92420A82BFEB07060A83924E6220020
+4955:2108210855484B90811E77D425642554F5542754A5D4754825483554C46404C2
+4956:108810502BFE245041FCB954118C1174FD0411FC94205BFE50501C88E1044202
+4957:2108210857C84908811E7B9220242380F80827C82908B10865943954E1240342
+4958:10881088295426224088B88811541222FDFC1104950459FC51041D04E1FC4104
+4959:2044272455284D7E85107630254A251AF52C254CA51A762A24483408C4280410
+495A:3FF820082EE82AA82EE82AA82EE82AA82FE8228824483BB8210A4FEA45469FF2
+495B:108013DE288A25CA408ABBD210A61040FC8811F094245BFE50221D24E2A24040
+495C:200023DE52524BDE82527BDE22222222FAFA22222A72B2AA63263A22E22A0204
+495D:202023FE52504BFE82527BFE229422D8FA9222CE2A00B28462983CE2E482087E
+495E:2108220827C854508FDE746427D42214F91427D42A14B3C862483C54E55408A2
+495F:2200227C52444A7C87447A7C2220237EFA9226522A6AB242627A3A02E2140608
+4960:2088208853FE48888014781223FE2210FAF422142AF4B2A862AA3AFAE2160422
+4961:2114255455544DFE855477D4245C2440F77E2510A5FE751025383554C5920910
+4962:0810FF7E08107F7C41047F2822101F28E14406C01830EFEE01003FF80920FFFE
+4963:2C7844486C4844867D7800487C301048FD8406C01830EFEE01003FF80920FFFE
+4964:11FC10202BFE262241ACB82011AC1040FCFC110496F4589450F41C8AE082407E
+4965:202023FE5088485083FE7A5023FC2254FBFE22542BFCB25062D83D54E6520850
+4966:202021FE54404AFC81107AFE200026FCFA8422FC2A84B2FC62843A8CE50008FE
+4967:2040207C50404BFE820279FC20A82154FA8821FC2A8AB0F8608838F8E08800F8
+4968:200023DE52524BDE82527BDE220222FAFA8A22FA2A02B2FA628A3AFAE2020206
+4969:228822A856A84BF0801E722425D42C14F41425D4A554754825683554C6140422
+496A:200023FE52024BFE82027BFE21082252FB9C21082A52B3DE60003AA4E2520452
+496B:2110211457D249108FFE729024502FF4F49427F4A49477E8248A37FAC4260042
+496C:108813FE2888242443FEB82011FC1124FDFC112495FC592450081DFEE0884058
+496D:14141010FEFE10105454383854549292313006C01830EFEE01003FF80920FFFE
+496E:200023FE50504BFE82527BFE200023DEFA9223D22A52B3D2629A3A94E3D00010
+496F:200023FC52944A9483FC7910225223DCF81223CE2A40B3D2625C3BD0E25202CE
+4970:2040202057FE4900810079FC20002088FBFE22AA2AAAB3FE608838AAE3FE0022
+4971:202023FE52024840819C790421DC2104F9FC21002BFEB40262AA3AAAE4140008
+4972:200827E854084DC8855E755225E42400F7E826A8A6A877E8241437F4C0240042
+4973:23FC204051F8490881F8790827FE2442FAA4228A2C7AB08061F83A88E070038E
+4974:2020222253FE489081FE7B1025FE2110F9FE211029FEB10063DE3A52E2720206
+4975:20102010577E4D1085FE754425EE2744F56425DEA50075FE2728352AC04A0086
+4976:200023FE52224ACC82447BEE224422EEFB5422442A10B210625E3A50E25005FE
+4977:244227722AA2511A8BEA722A23EA222AFBEA222A2BEAB14A67F23942E24A0444
+4978:F7FC124817FCFC4686ECF55416EC155457EC26C41830EFEE01003FF80920FFFE
+4979:208023DE508A49D280A67BD0209C2050FBFE20502AAAB3FE62523AAAE3FE0002
+497A:200023FC3810211041107910A21023FEF8302050209021102A10341020500020
+497B:100010003DFC20204020BC20102013FEFC5010501050109014921912120E0400
+497C:108010803C8020FC4154BE5410541094FC941124122410441444188411280010
+497D:204020483A44224043FE7880A08020FCF9442144214822502A20345028880306
+497E:200023FE3A022484408078FCA0802100F9FC2004200423F42804300420280010
+497F:1008101C3DE021004100BDFE11201120FD3C11241124112415241A4412540488
+4980:200027BC3884208444A47A94A2942084F98C229424A420842884308422940108
+4981:2100211E391227D241147914A7D82114F91227D22112211A2914321022100410
+4982:204020203BFC220442047BFCA20023DCFA44235422CC22442ACC3554244408CC
+4983:208820883BFE20A8402279FAA0242028FBFE204020FC21842AFC348420FC0084
+4984:102013FE3C2021FC4124BDFC112411FCFC2213FE1050109415881AA814C40082
+4985:208820503BFE202041FC7820A3FE2124F8A823FE200021FC2904310421FC0104
+4986:23DE22523BDE225243DE78A0A1FE2320FDFC212021FE200029FC30882070078E
+4987:00103E50205020483C8820A43D2422422040FE8010F820084408FE0802500020
+4988:00403E40204020403DFE20403C40204020FCFE90109021104510FE1002FE0000
+4989:00003EFE20AA20AA3CAA20AA3CAA20AA20AAFEAE10C220824482FEFE02820000
+498A:00203E202020203C3C2020203DFE20002020FE2010A820A44522FE2202A00040
+498B:00883C8820883BD0209E3BE4209427D4F91421D421544948F9484A5402D40422
+498C:00007C7C44447C7C44447C7C410441044FE44104410441045FF4400440144008
+498D:7C7C44447C7C44447C7C4004440447F4480457C4418442044414441443F4400C
+498E:7C7C44447C7C44447C7C40044FC440045FE4450445044504492450E440144008
+498F:00007C7C44447C7C44447C7C410442844464581C444444444444484450544008
+4990:00007C7C44447C7C44447C7C400440E45F0441045FE441047FFC410445144208
+4991:7C7C44447C7C44447C7C420442044FC4424442445FF442044504448448545008
+4992:7C7C44447C7C44447C7C40045FE44104420447C44C445444444447C444544008
+4993:7C7C44447C7C44447C7C4104410441F4410441044FE4482448244FE440144008
+4994:7C7C44447C7C44447C7C400440044FE448244FE448244FE440045FF44004400C
+4995:7C7C44447C7C44447C7C4004482444445FF4444444447FFC444448444844504C
+4996:7C7C44447C7C44447C7C410441045FF441044FE440044FE448244FE44824400C
+4997:7C7C44447C7C44447C7C410442044FE44AA44AA44AA44AA45FF4400440144008
+4998:7C7C44447C7C44447C7C40044FE448244FE448244FE4491448A44A444C24481C
+4999:7C7C44447C7C44447C7C410441045FF441047FFC40445FF44844444441544088
+499A:7C7C44447C7C44447C7C400440E44F0441045FF441044FE448244FE440144008
+499B:7C7C44447C7C44447C7C420447C448845FE441245FF441244FE441044304400C
+499C:7C7C44447C7C44447C7C40045FF442044FE444247FFC40044FE448244FF44008
+499D:7C7C44447C7C44447D7C41044FE441045FF442844AA44A945494448449944008
+499E:7C7C44447C7C44447C7C400449F44444504449F44444484458444BFC4804400C
+499F:7C7C44447C7C44447C7C410449244924555441044FE4410441045FF44004400C
+49A0:7C7C44447C7C44447C7C40045FF44204451459A44AC445A45A9444945A84410C
+49A1:7C7C44447C7C44447C7C41045FF4501447C4444447C4440447E4442447E4400C
+49A2:7C7C44447C7C44447C7C5084488463E45084488457F47104522457F45014400C
+49A3:7C7C44447C7C44447E7C41045FF4482444447FFC40044FE4482448244FE4400C
+49A4:7C7C44447C7C44447C7C40044EE44AA444444AA451044EE44AA444444AA4510C
+49A5:7C7C44447C7C44447C7C4004444444445EF444444EE45554644C444444544008
+49A6:7C7C44447C7C44447C7C410442844C6477DC41045FF4492445447FFC4004400C
+49A7:7C7C44447C7C44447C7C400442044CE448244EE448244FE4428444945874400C
+49A8:7C7C44447C7C44447C7C41045FF441044FE449244FE449244FE445444924410C
+49A9:7C7C44447C7C44447FFC48244FE448244FE448244FE444044FC4544443945C68
+49AA:7C7C44447C7C44447FFC48244FE448244FE444044FF459146A944FD44054402C
+49AB:7C7C44447C7C44447C7C400444445FF4444441044FE449245FF442844444482C
+49AC:7C7C44447C7C44447C7C44045EF444544E5444545EB445045FF442844444482C
+49AD:7C7C44447C7C44447C7C40E44F0441045FF44544492457D4444447C4445447C8
+49AE:7C7C44447C7C44447D7C4FE441044FE442045FF444444FE4545C67C4444447CC
+49AF:7C7C44447C7C44447C7C40047F444844527C5F9444545F54442447547C94510C
+49B0:783C48247A3C4BA47CBC4FC4554447C445444FE449244FE449244FE4411440F4
+49B1:7C7C44447C7C44447C7C41E45E2445444F8448844FC448444FE448245524656C
+49B2:7C7C44447C7C44447C7C420447C448445FF46A244C944FF448044BE44A2453EC
+49B3:7C7C44447C7C44447C7C520457746D54775455646F547C545654556466C4444C
+49B4:7C7C44447C7C44447FFC4AA44FE441044FE441045FF444444FE441045FF4410C
+49B5:7C7C44447C7C44447C7C40045FF449245FF4711C5BB455545BB455545BB4511C
+49B6:200013FC1004420447C4484450844FE441245FF441244FE44104450442144008
+49B7:200013FC10044004410449244924555441044FE4410441045FF4400440144008
+49B8:200017FC00044FE449244FE449244FE441045FF45114515457D450545034400C
+49B9:00207C2044204820482050204BFE482044204420442068205020402040204020
+49BA:00007C0045FE4820482050204820482044204420442068205020402040A04040
+49BB:00007DFC440448084810502048204BFE44204420442068205020402040A04040
+49BC:00407C4044404BF8484850484848484847FE444044A068A05110411042084406
+49BD:00007DF844084850482050104BFE482244244420442068205020402040A04040
+49BE:1040104020807C88450447FE7C02409040907C90449044907D124512020E0400
+49BF:00207C204420482049FC512449244924452445FC452468205020402040204020
+49C0:00407C40444048404BFE5040488048904490452045206A485244448441FE4082
+49C1:00807C80450049FC4A04540449E449244524452445E469245004400440284010
+49C2:00007DFC444448444844504448944888450044FC448468845084408440FC4084
+49C3:00007C0045FC4924492451244924492445FC4524452469245124412441FC4104
+49C4:00807C8044F849084B1054A0484048A04518460645F869085108410841F84108
+49C5:004078404BFC484053F8504863F852404BFC4844485468A850A0411042084406
+49C6:00907C90449048904BFC509048904890449047FE440068905088410841044204
+49C7:0040782048204BFE5040504060A050A249A44A984C906888508440A240C04080
+49C8:00007BFE48505050505061FC5154495449544954695C51844104410441FC4104
+49C9:00007DFC4524492449FC5124492449FC4420442045FC68205020402043FE4000
+49CA:00207D20452049FC4920522048204BFE4400440045FC69045104410441FC4104
+49CB:00007DFC4504490449FC5104490449FC4504450445FC6850509040924112420E
+49CC:0008783C4BC0504452246128510048404BFE4888690853904060405041884604
+49CD:00887C8445024A224820505048884904460245FC450469045104410441FC4104
+49CE:00007CFC4484488448FC500049FE4902450245FE4502690251FE4102410A4104
+49CF:00407C4044FC48884950502048D84B2644F8442044F8682053FE402040204020
+49D0:00407C2047FE480049FC510449FC480045FC440844106BFE5020402040A04040
+49D1:004078204BFE52025404600053FE482048204920693C512042A04260443E4800
+49D2:00207C2044204BFE482051244924492446AA447044A868A85124422244204020
+49D3:00007DFC452449244974512449FC490445744554455469745104420442144408
+49D4:00207C20445048884944522249F848084450442044A46A82528A428A44784000
+49D5:00147812481057FE5010601053D24A524A524A546BD4500840EA471A42264042
+49D6:00487C44445E49E048285012486A49964448445E45E0682450284012406A4186
+49D7:01007D0045FE4A004DFC510449FC490445FC448044FC69085290406041984606
+49D8:010079F84A0853F0501067FE508049444E6848B06928566840A4412246A04040
+49D9:00407A484A48524853F8604050A049104A884C86689052A84294449442804100
+49DA:00207C1045FE480048FC508448FC480045FE4502457A694A517A4102410A4104
+49DB:004078204BFC5108509063FE52024C4448204BFC688050F84088410841284210
+49DC:00207C1045FE4910497C511449FE4914457C4510457C694451444244427C4444
+49DD:00207D24452449FC482053FE4800482045FC4524452469FC5020402443FE4102
+49DE:00007DFE452049FC492051FC4920492045FE440246AA6AAA52AA420240144008
+49DF:001E7DE04422491248945080482049CE4502450245CE69025102410241FE4102
+49E0:00207BFE482051FC512461FC512449FC48224BFE680853FE4108408840284010
+49E1:00107DFE4510497C491451FE4914497C4510457C4554697C5154427C4254444C
+49E2:00007BFE4A00527C52446244527C4A004AEE4AAA6AAA52AA42EE420043FE4000
+49E3:00007DFC445049FC4954515449FC480045FC440047FE682050A8412442A24040
+49E4:00507A524954505053FE608850504BFE482049FC682053FE4050408841044602
+49E5:002078204BFE502051FC612451FC492449FC48226BFE5042402442A2428A4478
+49E6:000E7BF048445224510863F852084BFC4A044BFE6A0252AA42AA450244144808
+49E7:010478884BFE482051FC502063FE5054499248904BFE689050D4438A409641A2
+49E8:00507A524954485053FE5088605053FE482049FC48206BFE50A8412446224020
+49E9:00087B884888511057DE629452A44B944A944B946A9452C84388469440A440C2
+49EA:002078104BFE4A1052FE5254625452BA4A284A444A826A2052FE4444443848C6
+49EB:00207BFE480051FC510461FC50004BFE4A0249FC684053A440D8433440D24330
+49EC:004078204BFE520251FC6148525049FC4B0449FC690451FC410441FC40884104
+49ED:004078804BFE5222528A625253264A524AAA4BFE6840502442A2428A44884078
+49EE:00207BFE4A2251FC502060F8502049FC482049FC695451FC404042A4428A447A
+49EF:01F07A104FFC520453FC622453B84A2249FE4A106FFC524443FC40D0414A463E
+49F0:0406E438AF08A910B224AFBCCA88AA94AFBEAA8AAA88AFACC02A954A95488018
+49F1:20502048208020FEFD90269024FC2490249024FC25902690449040FE80800080
+49F2:00507C48108010FE1190129010FCFE90109010FC10901090109010FE10801080
+49F3:08500848088008FE49904E9048FC4890489048FC48904E905890E0FE00800080
+49F4:105010481080FEFE11901290FCFC0490049048FC28901090289044FE82800080
+49F5:105010481080FEFE9390129010FC2890289028FC28904A904C9088FE00800080
+49F6:090008801FFC30805FF890801FF810801FFC12000100FFFE0000082010102008
+49F7:205020483C8044FEA990129028FC4490829030FC08900090609010FE08800080
+49F8:10501048108010FEFD90129010FC10907C9044FC4490449044907CFE44800080
+49F9:010000803FFE2250224824FE24902D9036FE2490249024FE4490449084FE0480
+49FA:082808240840FF7E10C81148207E3E486248A27E2248224822483E7E22400040
+49FB:08500848148022FE4190BE9000FC00903E9022FC2290229022903EFE22800080
+49FC:1050504850807CFE5190929010FCFE90009000FC7C904490449044FE7C804480
+49FD:0628782408404A7E2AC82D48087EFF4818481C7E2A482A484848887E08400840
+49FE:10501048284044FE82907D9012FC1090FE9010FC10907C90449044FE7C804480
+49FF:242824247E40247E24C8FF48007E7E484248427E7E48424842487E7E42400040
+4A00:20501048288044FE9190129054FC38901090FEFC10903890549094FE10801080
+4A01:7E20243E1848FFA829104A28984609001FFC30805FF890801FF810801FFC1000
+4A02:0620382008A47EA819202C504A8809041FFC30805FF890801FF810801FFC1000
+4A03:00287E2442407E7E42C87F48087EFF488148107EFF4822486448187E2440C240
+4A04:082814242240497EBEC80548087EFFC814487F7E5548634841487F7E41407F40
+4A05:10281024FE40107EAAC84548827E7D4844487C7E44487C481048547E92403040
+4A06:49202A3E7F4849485DA86B10492841460A001FF831005FF091001FF011001FF8
+4A07:285024487EFEC9907EFC48907EFC48907EFE40807DFC0488285010202858C586
+4A08:20501048FE8082FE7D90569098FC7C90C4907CFC44907C9044907CFE28804480
+4A09:002877245540777E55C87748557E77482248557E1048FF482248647E1C40E340
+4A0A:08801FFC3080DFF810801FFC14283F7E64C8BF7E24483F7E10041E7C12442244
+4A0B:00003FF801007FFE41029D7401001D70000000F03F00020003F87E02020201FE
+4A0C:00003FF801007FFE41029D7401001D7000001FF000007FFC044008441044603C
+4A0D:3FF801007FFE41029D7401001D70000008203FF808200820FFFE102020204020
+4A0E:3FF801007FFE41029D7401001D7000007F1001107F1040207F2401420AFE0442
+4A0F:3FF801007FFE41029D7401001D704080208009FC12042448E04020A023182C06
+4A10:3FF801007FFE41029D7401001D70010006C01830E7CE00001FF010101FF01010
+4A11:3FF801007FFE492284140100FFFE01007FF801083FF821003FFC0284044C1830
+4A12:3FF801007FFE41029D7401001D7000007EFC224412240A14122422444A940408
+4A13:3FF801007FFE41029D7401001D7000003FF8200827C8244827C820083FF82008
+4A14:00003FF801007FFE41029D7401001D70000011100920FFFE044008423042C03E
+4A15:3FF801007FFE41029D7401001D70000011FC482020200BFE7020102010A00040
+4A16:3FF801007FFE41029D7404007FFC08001FF028104FF088100FF0081008500820
+4A17:3FF801007FFE41029D74000000FC7F00121009203FF00040FFFE010005000200
+4A18:3FF801007FFE41029D7400001FF010101FF010101FF010101FF004421842E03E
+4A19:3FF801007FFE41029D7401001D700000203813C08040484017FEE040204023FC
+4A1A:3FF801007FFE41029D7401001D7008001FF86488090836280110489487F20000
+4A1B:3FF801007FFE41029D7401001D700000100CFDF0110039FE5510921012101410
+4A1C:3FF801007FFE41029D7401001D7000003E7C22443E7C22443E7C22444A948508
+4A1D:3FF801007FFE41029D74000001003FF80100FFFE10101FF010101FF010101030
+4A1E:3FF801007FFE41029D74000001F87F0001001FF011107FFC412441F45E144008
+4A1F:3FF801007FFE41029D7401001D702000104083F8404017FC2040E3F820402FFE
+4A20:3FF801007FFE492284141FF010101FF010101FF008001FFC2104528414541FE8
+4A21:3FF801007FFE41029D7401001D7000001FE0004051944924551442047FFC0004
+4A22:3FF801007FFE41029D7408207FFC08200FE008200FE00820FFFE124014201FF8
+4A23:3FF801007FFE41029D7408207FFC08200FE001003FF821083FF80100FFFE0100
+4A24:3FF801007FFE41029D7401001D702040104007FCF44417FC144417FC280047FE
+4A25:3FF801007FFE41029D7409001FF831005FF091001FFC10003FF0082007C0F83E
+4A26:3FF801007FFE41029D7402003FF808207FFC41043FF8040007F0081010502020
+4A27:3FF801007FFE41029D7401001D7020201050FE880526441028FC2E08F0704008
+4A28:3FF801007FFE41029D740080210013F80208F3F8120013FC120413FC280047FE
+4A29:3FF801007FFE41029D7401001D7020201020FDFC092411FC392455FC90201020
+4A2A:3FF801007FFE41029D74000011FC112411FCFD2411FC10201DFCE02043FE0000
+4A2B:3FF801007FFE41029D74000001007FFC11102BA845641918E3E60E4001800E40
+4A2C:3FF801007FFE41029D7401001D702000111081104FBC1110E3B8255429122110
+4A2D:00107F100854FFB888906B7C08446B44007C7E440044FF7C104422447F540148
+4A2E:3FF801007FFE49229414FEFE10107C7C1010FEFE10103FF800081FF800083FF8
+4A2F:3FF801007FFE41029D7400207BFE482051FC612451FC492449FC687050A84124
+4A30:3FF801007FFE49228414211017FC911041F048400BF81248E3F820402FFE2040
+4A31:3FF801007FFE41029D74120027FC42088BF8120833F8510093F8151010E0171E
+4A32:00207F20083CFFC488886B7E08526B52007EFF90082C7F2A5528554A554A4386
+4A33:3FF801007FFE41029D7400003EF822883EF822883EF822883EF814502692450E
+4A34:3FF801007FFE41029D740000550836087F7E14087F4808283E2808080F287810
+4A35:3FF801007FFE4922A7FC10A017FC84A447FC520813F82208E3F8204027FC2040
+4A36:3FF801007FFE41029D7408201FF000104FE44AA449647FFC0440FC7C24444444
+4A37:3FF801007FFE41029D74000011087BCE11083B88557EBF9220943F88209421A2
+4A38:3FF801007FFE41029D7400187BE0495053F8604053F8480849F86840529444F4
+4A39:3FF801007FFE41029D74108011FC228828706B8EA9FC29AC297429FC28202154
+4A3A:3FF801007FFE49229FF404400FE000007C7C1010FEFE92925454FEFE28287C7C
+4A3B:7C7C1010FEFE92927C7C54547C7C00007C7C1010FEFE92927C7C54547C7C0000
+4A3C:104411FEFE5410487CFE1190FEFE00907CFE44907CFE44807DFE4444543849C6
+4A3D:04407C7C04403C7804407C7C044004403FF0001000103FF02000200420041FFC
+4A3E:010000803FFE2000212021202F3C212021202738212021204F3C412081200120
+4A3F:00003FF801000200FFFE08203018C44604407C7C04403C7804407C7C04400440
+4A40:04407C7C04403C7804407C7C04401FF010101FF010101FF010101FF008201010
+4A41:04407C7C04403C7804407C7C04403FF002007FF802020DFE70401C78F1C41C3C
+4A42:0020FE2010202050FE50AA88AB44BA22AA20AAF8BA08AA08AA10FE1082200020
+4A43:0010FE9010902092FE92AA94AAF4BA98AA90AA90BA90AA92AAB2FED2828E0000
+4A44:0000FE7C10442044FE54AA54AA54BA54AA54AA54BA10AA28AA28FE4A828A0106
+4A45:0010FE10101020FEFE92AA94AA90BAFCAAA4AAA4BAA8AAA8AA90FEA883440282
+4A46:0040FE401040207EFEA0AAA0AB20BA3EAA20AA20BA20AA3EAA20FE2082200020
+4A47:0010FE1010102010FE1EAA10AA10BA10AAFEAA82BA82AA82AA82FE8282FE0082
+4A48:0040FE40107E2080FF7CAA44AA64BA54ABFEAA44BAA4AA94AAFEFE0482280010
+4A49:0014FE1210FE2010FE10AAFEAA92BA92AAFEAA92BA92AAFEAA92FE9282920086
+4A4A:0020FE1010FE2082FE40AA4EAA6ABAAAAAAAAAAABB6CAA28AA4AFE4A828A0106
+4A4B:0010FE0810FE20A4FEA4AAA4AAFEBAA4AAA4AAF6BAACAAB4AAA4FEA483240024
+4A4C:0028FE241040207EFEC8AB48AA7EBA48AA48AA7EBA48AA48AA7EFE4082AA012A
+4A4D:0010FE1010FE2010FEAAAA44AA82BB7CAA44AA7CBA44AA7CAA10FE5482920030
+4A4E:0010FE1010282044FE82AA7CAA00BAEEAAAAAAAABAEEAA44AA44FEAA82AA0112
+4A4F:0024FEFE10242000FEFEAAAAAAAABAFEAA14AAFEBA90AAD2AAACFEAA82960122
+4A50:22202220FF20227E3E4008807F3C490449087F100820FFC008420842083E0800
+4A51:2200227EFF0222023E02083E7F20492049407F7E0802FF820802080208140808
+4A52:2200227EFF1022103E1008107F1049FE49107F100810FF900810081008500820
+4A53:28802880FC8028FE390212427C42548254A27D1213FAFD0A1002100210141008
+4A54:280028F8FE882888388811067E0055FC54847C841048FE501020105010881306
+4A55:28002840FD9E2912391211127D12551255127D12115AFD941110101010101010
+4A56:28202820FE2028A838A410A27D22552056247C241028FE081010102010C01300
+4A57:280028FCFE842884388410FC7C84548454847CFC1084FE841104110412141408
+4A58:22002200FF7E22083E1008107F24494449787F080810FF940822087E08220800
+4A59:28202810FE1029FE382010207C44548455F87C101020FE44108211FE10821000
+4A5A:2804281EFDF02910391011107D1055FE55107D101110FD08110A114A11A61112
+4A5B:28402820FC282808380810487C54555255527D601260FC4410C41144123C1000
+4A5C:28202820FE20282039FC11247D24552455247DFC1124FF241124112411FC1104
+4A5D:2808281CFDF02950395011507D50555055507D481148FD681154127412521400
+4A5E:28202820FE202820383E10207C20542055FC7D041104FF041104110411FC1104
+4A5F:28202820FDFE282039FC10247DFC552055FE7C22102AFC541050108811041202
+4A60:50005006FBB8508870882108F93EAB88A888FA882288F93E21002280247E2800
+4A61:28202820FC202BFE382010207D24552455247EAA1020FC501050108811041202
+4A62:5104510EF930512077E02120F93EA964A9A4FF242124F9242124212425442284
+4A63:28202820FC502888390412FA7C20542057FE7C201128FD241222142210A01040
+4A64:280028FCFE84288438FC10847C8454FC54847C8410FCFE50105010921112120E
+4A65:5004500EFBB8508870882128F92EABA8A8A8FAA822A8F93E21002280247E2800
+4A66:108020FC6910AA9028602890230C04407FFC044007C001001FF01110FFFE0100
+4A67:28402820FDFE2800380010FC7C00540054FC7C001000FCFC1084108410FC1084
+4A68:280028FCFE8028F8388010F87C8057FE55407D241128FF101108114411821100
+4A69:50405020FBFE520275042100F9DEAA52AA52FB52249AF894211021122212240E
+4A6A:28202810FDFE29023A0410F87C88548854F87C801080FCFC1084108410FC1084
+4A6B:500053FEF820502073FE2222FA22AB32AAAAFAAA2376FA6622222222222A2204
+4A6C:28202820FDFE282038FC10407DFE548855247E2210F8FC2011FE102010201020
+4A6D:28202820FDFC2850388811047FFE540855E87D281128FDE81128100810281010
+4A6E:280029F8FC08280839F810087C0857FE54207E221174FCA81124122210A01040
+4A6F:500053FCF8085010702023AEFAA2AAAAAAA4FAA423AAF83220A0204027FE2000
+4A70:280028F8FE88288838F810007DFE548854F87C8810F8FE88109E13E810081008
+4A71:504050A0F910520875F62000FBC4AA54AA54FBD42254FA5423D42244225422C8
+4A72:28402820FDFE2948394811FE7D48557855007DFC1144FD4811281210122814C6
+4A73:28402820FDFE292238A411287C50548855047CF81088FC881050102010D81306
+4A74:2880289EFC9229D23892109E7C9255D255527D5E1152FD5211D21022102A1044
+4A75:28002BFEFE2228203BFE10207DFC552455FC7D2411FCFC2013FE102010201020
+4A76:28202924FD2429FC382011FE7C00542055FC7D241124FDFC1020102413FE1102
+4A77:28202810FDFE2884384811FE7D02562454107DFE1040FC7C1044108410941108
+4A78:28882888FDFE2888380011FE7C88548854F87C8810F8FC88109E11E810081008
+4A79:280028FEFE00287C3844107C7C0054FE54827CAA1092FEFE1092109210921086
+4A7A:50905088F9045242748821FCF804A800ABDEF8422252F94A22522042214A2084
+4A7B:280029FEFD2029FC392011FC7D20552055FE7C0212AAFEAA12AA120210141008
+4A7C:28202A20FD7C28A4381810E67F10557E55107D7C1110FDFE1110111012FE1400
+4A7D:500053FEFA00527C72442244FA7CAA00AAEEFAAA22AAFAAA22EE220023FE2000
+4A7E:50405020FBFE520072482248FBFEAA48AA48FA482278FA002554252A2A2A3000
+4A7F:282029FCFC2028883BFE10887DFC550455FC7D0411FCFD0411FC108811041202
+4A80:282029FEFF0228F8388810F87C8054FC54847CFC1000FE2010541142114A1238
+4A81:28502952FCD4285039FE10887C5055FE54207CFC1020FDFE1050108811041202
+4A82:52085208FFBE520872082FBEFAAAAAAAAAAAFBAE2208FF1C2AAA324822082208
+4A83:51085088FBC8501073DE2264FBD4A814ABD4F8542094F8E82388209422942122
+4A84:28882888FDFC2888388813FE7C2055FC55247DFC1124FDFC1000108811041202
+4A85:280029FCFD54295439FC10807DFE564255F27D521152FDF2104A13FA100A1004
+4A86:285029FCFD5429FC395411FC7C0055FC54007DFC1104FDFC1088105013FE1000
+4A87:28882BFEFC8828243BFE10207DFC552455FC7D2411FCFD24100811FE10881058
+4A88:2810287CFE54297C391010FE7C00577C55447D7C1140FD7C1144117C1280147E
+4A89:51245248F924500073FC2294FA64AA94ABFCFA482368FA48236A224A22462362
+4A8A:51105090FBDE5010725E2182FBDEA810ABDEFA5023DEFA5023DE2250225222CE
+4A8B:2810287CFE54297C391010FE7C44577C55447D7C1144FD7C112811441280147E
+4A8C:51F05210FBFC560473FC2224FBB8AA22A9FEFA1027FCFA4423FC20D0214A263E
+4A8D:53DE5252FBDE525273DE2222FAFAAA22AAFAFAAA22FAFAAA22FA227222AA2226
+4A8E:522253FEF89051FE731025FEF910A9FEA910F9FE2100FBFE228A237622522276
+4A8F:101010107E1022FEFF9200927E9242AA7EAA08CA7E82088248827E82088A0884
+4A90:104010207C282408FE0800487C5445527D5211607E60104450C47D44123C1000
+4A91:102010107E1022FEFF8200847E4042447E4808507E60084248427E42083E0800
+4A92:102010107E0022FEFF1000107E1042107E7C08107E10081048107E1008FE0800
+4A93:102010207E202220FF3C00207E2042207EFC08847E84088448847E8408FC0884
+4A94:102810247DFE2420FE2001FC7D2445247DFC11247D2411FC51247D241124110C
+4A95:108010807CFE2502FE2200AA7C7244227DFE10227C7210AA51227C22100A1004
+4A96:104010407E7E2280FF7C00447E7C42447E7C08207E3C084448A87E10082808C6
+4A97:100011DC7D442544FF4401DC7D0045007DDC11147D1411D451087D0811141122
+4A98:100010FC7C842484FEFC00847C8444FC7C0011FE7C101090509C7C901150123E
+4A99:101410127DFE2410FEFE00927CFE44927CFE10927C0411FE50447C241024100C
+4A9A:100011FC7D0425FCFF0401FC7C0047DE7C4212527D4A10C6535A7C42114A1084
+4A9B:101E10F07C922454FEFE00547C9245007CFE10927C9210FE50927C9210FE1082
+4A9C:104010787C8825FEFEA400D27CFE44807CBC10807CBC108050BC7D24113C1224
+4A9D:104411FE7C542448FEFE01907CFE44907CFE10907CFE108051FE7C44103811C6
+4A9E:00003FF80100FFFE028004401830E44E04407C7C04403C7804407C7C0440FFFE
+4A9F:100011F8FE88105010207C50558C545055DC545055DC5C5011DC105013FE1000
+4AA0:1640F87C9084FE2832205250968C100004407C7C04403C7804407C7C0440FFFE
+4AA1:11201CBE704250947D9034A85C46900004407C7C04403C7804407C7C0440FFFE
+4AA2:12201D3E70425094531051287D46145035DC345055DC985011DC105013FE1000
+4AA3:1220113E1042FC94131011287C46545055DC54505DDC305051DC905013FE1000
+4AA4:281E29F02892EE5429FE2854EE92290028FE2892EE9228FE28922E92F0FE4082
+4AA5:10001EFC1044FF2881107E2800C67E2842EE7E2842EE7E2842EE7E2824FE4200
+4AA6:200010007CF8002044202820FE2000207C20442044207C20442044207DFC4400
+4AA7:202010207C2000A044AC28B4FEE401A47CA444B444A87CA244A244827C7E4400
+4AA8:204010407C4000FC44842904FE0400847C44444444447C04440444047C284410
+4AA9:202010207C20005044502888FF4402227C2044F844087C08441044107C204420
+4AAA:10007E7C124422444A7C844401003FF80820FFFE00001FF010101FF010101FF0
+4AAB:200010FE7C00005244A42928FE94004A7C0044FE44107C10441044107DFE4400
+4AAC:202010207DFE0020442029FEFF0202047CF8441044207DFE442044207CA04440
+4AAD:202010107CFE000044442828FEFE00007C7C444444447C7C444444447C7C4444
+4AAE:204010407CFE012244AA28FAFE4200947D4844FE45227EAA44FA44427C944508
+4AAF:08202AA44D28145022887FFE41029FF404407FFC00001FF010101FF010101FF0
+4AB0:2040102079FC0088485033FEFC0001FC790449FC490479FC48204A947A8A4C7A
+4AB1:000001FEFC20044005FC050405047DFC410441FC4104450459FC608841040202
+4AB2:000000FEFE10282028FC2884288428FC288428FC28842A844CFC484880840102
+4AB3:000000FE7E10122012FCFF84128412FC7E8412FC1084108420FC204840848102
+4AB4:080008FE08107F20497C08440844147C1444147C14442544267C440080280044
+4AB5:00007EFE0410242024FC248444847FFC0C8414FC1484248444FC844814840902
+4AB6:00007CFE4410442044FC7C84448444FC7C8444FC448444844EFCF04800840102
+4AB7:200020FE40107E2082FC02847A844AFC4A844AFC7A844A8402FC024814840902
+4AB8:00007EFE421042207EFC4884488448FC7E8448FC488448844AFC4A4866844302
+4AB9:00007EFE0810082010FC1484328451FC908410FC108400840EFCF04840840102
+4ABA:100010FE10107E2010FC10841084FEFC108410FC2084288444FCFE4842840102
+4ABB:100010FE20104420FEFC0284248424FC2484FEFC2484248424FC444844848502
+4ABC:100010FE9210922092FC9284FE8410FC108492FC928492849EFCF24800840102
+4ABD:00007CFE4410442044FC7C840084FEFC208440FC7C84048404FC044828841102
+4ABE:0010FF10082810287E44428242087E1042647E08421242647E08243042C08100
+4ABF:080008FE10107F20417C41446544557C4944497C55446544417C7F0041280044
+4AC0:00007EFE421042207EFC428442847EFC408448FC44844A8452FC604840840102
+4AC1:100011FE20207C4045FC45047D0445FC45047DFC4504450445FC7C8845040202
+4AC2:100010FE3E104220A47C18441044247CC8441F7C2144D2440C7C08003028C044
+4AC3:00007F7E401040205E7C404440447F7C5044517C5A445444527C910098281044
+4AC4:440024FE281000207CFC4484448444FC7C8428FC288428842AFC4C4888840102
+4AC5:100008FE7F104120497C084408447F7C0844187C1C442A44497C880008280844
+4AC6:0400053E048804107FBE44224422753E5522553E5522522252BEA680899410A2
+4AC7:0C0030FEC6101820637C0C44F044007C7E44427CFF444244FF7C42004A284444
+4AC8:0800497E491049207F7C08441444227C514488FC08447E44027C040004280844
+4AC9:0C0030FEC210142048FC3084C88414FC2484CCFC14842484C4FC044828841102
+4ACA:0000FEFE08101020347C52449144107C00447E7C42444244427C42007E284244
+4ACB:0C0070FE1010FE2038FC5484928400FC1084FCFC2484448428FC10482884C502
+4ACC:080010FE7F104920497C7F444944497C7F44147C2444FF44047C040004280444
+4ACD:140014FE1410F720147C14441444777C1444147C1444F744147C140014281444
+4ACE:0000F77E11105520227C55448944107C0044F77C11445544227C550089281044
+4ACF:2200227EFF902220227C3E442244227C3E44227C2244FF44007C140022284144
+4AD0:2200227E22102220F7FC22442244667C7744AAFCAA443244227C220022282244
+4AD1:100010FEFE10102028FC4484FE8404FC748454FC5484748454FC044814840902
+4AD2:000006FE781048207F7C48444544537C6144007C7E4442447E7C42007E284244
+4AD3:200010FE7C10002044FC24842884FEFC008400FC7C84448444FC44487C844502
+4AD4:20002F7EF5102520757C2544F544297C2344087C0844FFC4147C2200412880C4
+4AD5:200010FEFE10002044FC2884FE8482FC10847CFC5484548454FC5C4810841102
+4AD6:220022FEFF1022203E7C22443E44227C2244FF7C40445444627C40007E280044
+4AD7:0000777E51105120517C77444044407C7744417C49447544427C420045284944
+4AD8:00007CFE44107C2044FC7C8420847EFC928452FC6A8442847AFC024814840902
+4AD9:080008FE7F1008202A7C2244FFC4227C2A44087C7F441C442A7C490089280844
+4ADA:00003EFE221022203A7C2A442A447F7C41445D7C554455445D7C410045284244
+4ADB:20002F3E210841105FBEC82248224FBE5222423E5FA24222453E448048945022
+4ADC:08002A3E2A08AA90CCBEDDA2FFA2AABEAAA2DDBEFFA299A288BE8F80F0940022
+4ADD:060078FE08100820FF7C1C442A44497CBE44227C22443E44227C22003E282244
+4ADE:440024FE28100020FEFC108410847CFC108410FCFE840084AAFCAA48AA840102
+4ADF:00007CFE441044207CFC0084FE8482FCFE8482FCFE848284FEFC284844848502
+4AE0:180060FE0C1070200CFC70840084FEFC108434FC528490847CFC44487C844502
+4AE1:2200147EFF901420147C7F441544FFFC15447F7C14443644557C948014281444
+4AE2:03007C7E471044205F7C554456445C7C5544537C50445744557C5500A9A80044
+4AE3:0E00F0FE2210922044FC20844484F8FC108424FCFE841084FEFC284844848302
+4AE4:0000FF7E811000207E7C42447E44427C7E44107C0844FF44007C240042288144
+4AE5:080010FE7F104920497C7F44497C49447F7C10441A7C2CA82FC44882480287FE
+4AE6:0800083E7F080810083EFFA22022413EFFA240BE00227F22553E55005794FC22
+4AE7:100020FE7C1044207CFC44847C8410FCFE8428FC548492847CFC104810841102
+4AE8:1200123E12087A1013FE7CA210A2FCBE22A23ABE29222922293E4A805A9484A2
+4AE9:1000223E7F08421094BEF7A20822363EC92230BEC4221922623E0C003014C022
+4AEA:100010FEFE101020BAFC5484BA8410FCBA8454FCBA84108428FC244842848102
+4AEB:08007F7E4910FFA0497C7F4408447F7C49447F7C1044FF44217C72000C28F344
+4AEC:0000F7BE2108A510F7BE6322B5A2213E7FA240BE40A27FA240BE40807F9440A2
+4AED:10007CFE54107C2010FCFE8400847CFC44847CFC44847C8444FC7C4828844502
+4AEE:00007F7E01103F20017C7F440044777C2544F77C0244FFC4427C22002A280444
+4AEF:4100211E0FE4F108429E44527FF2505E5752555E55525752555E5040A14C0092
+4AF0:0020F92420A843FEF8A889248A22F9048904F9DE8A448D54F89E010452048C04
+4AF1:00007FBE08087F9054BE54A254A241BE00227FBE08227FA254BE5480549441A2
+4AF2:0280025E7FC442085E1E42925E92571E5D5242DE88520492545E51408F0C0012
+4AF3:00007F7E551055207F7C20447F44917C7D44557C55447D44117C7D0005280244
+4AF4:2200223EF7882210773EAAA22262003E7F22003EFFA20822493E4880A8941022
+4AF5:10007F3E49086510533E49227F22083EFFA2A2BE4922FFA2203E3F0041148322
+4AF6:20802A9EF5E42A8871DE6AB2A4922A9E2092041E04127FD20A1E1100208C4052
+4AF7:0000FFBE0808EB90AABEEBA20822FFBE0822EBBEAAA2EBA2083E0F80F8144022
+4AF8:00007FDE404A434A5C4A444A5F4A554A55525F52446A45445F404922801E0000
+4AF9:00007FC0407E43485C4844485F48554855485F484448457E5F404922801E0000
+4AFA:100011FC1104FD3411C4114421F42954295429F4514455545DF4851602060402
+4AFB:00007FDE405243525C52445E5F52555255525F52445E45405F404922801E0000
+4AFC:00107F1041104D7C711451147D1455FE7D10512855247D4444804042803E0000
+4AFD:00007FC6405843485C4E44585F4E5578554A5F4A444A45465F404922801E0000
+4AFE:00407C2044284C087448545455527D6256607C4454C4553C52007D004482807E
+4AFF:001E7FCA404A434A5C5244665F40555E55525F52445E45525F404922801E0000
+4B00:00487C4844884CBE752A55CA544A7C8A54AA7DF25412542A52447D004482807E
+4B01:00107F08417E4D42712051247D3855207D225122551E7D0044804042803E0000
+4B02:00287C2444204DFC7520552455247D2855287D105594552C52447D004482807E
+4B03:00107F0841004D7C710051447D2455287D28511055FE7D0044804042803E0000
+4B04:00147C1244104DFE7510551455147DD455087D0A551A552652427D004482807E
+4B05:00407C4045FC4C847484552856107D0857DE7D4A554A5652525A7DE44482807E
+4B06:00447D8444944C9477F4549455947DD456B47C945484549452887D004482807E
+4B07:440025FC290401347DC4454445F445547D5429F4294429542BF44D168A060402
+4B08:00007F4441284D00717C51447D44557C7D285128554A7D8644804042803E0000
+4B09:00207C2045FC4C20742057FE54507C5055547D525652549052907D304482807E
+4B0A:00107F1041FE4D10715451547DBA55107D28512455427D8044804042803E0000
+4B0B:00207C2044F84C2075FC548855447C7854887D505420545052887D084482807E
+4B0C:10001DFC11047D3455C4594471F455544D5441F45D44555457F4951622060402
+4B0D:00807C8044FC4D54765454A455547C8854207C145552554A52387D004482807E
+4B0E:00147C1247FE4C10741055D455547D5455CC7C0A54CA571652227D404482807E
+4B0F:00207F10417C4D44712851FE7D00557C7D445144557C7D4444804042803E0000
+4B10:00187CE044204DFC747054A855247C4057FE7C8855905470538C7D004482807E
+4B11:007C7F54417C4D54717C51007D7C55447D7C5144557C7D4444CC4042803E0000
+4B12:00207DFC45044C507488552454507C8855067CF85408545052207D50448A807E
+4B13:00207F1041FE4D44712851FE7D00557C7D44517C55447D7C44804042803E0000
+4B14:00207C5044884D0474F8540055C47D5455D47D5455D4554453547D484482807E
+4B15:00007DFC45044D3475C455447DF4555455547DF4554455547DF4491682060402
+4B16:00107F20417C4D44717C51447D7C55007D7C5110557C7D1044FC4042803E0000
+4B17:00007CF844887C9844E87CA800A8FEF840A87EF8AAA82AAA4AAA92FA2A864502
+4B18:00207DFC44004CF8748854F854007DFC55047D7455545574530C7D004482807E
+4B19:000E7F7041124D447120517C7D9055107DFE511055547D7C44804042803E0000
+4B1A:00007DFC45204DF8752055F855207DFC54047D545554540452287D104482807E
+4B1B:01FC7D2445FC4D2475FC54A854A87FFE54A87CA855FC542053FE7D2044A2807E
+4B1C:00407C2045FC4C507524555455FC7C2055FC7D4455545574530C7D004482807E
+4B1D:00287F7C41284DFE7110517C7D54557C7D54517C55007D4444824042803E0000
+4B1E:00207DFE44204CFC740055FE54027CF854207DFE540455DE53547DCC4482807E
+4B1F:00827D7A452A4DAA754A559A55427CA255F27C4A55F2555252E67DF84482807E
+4B20:00003FF801007FFE41029D7401001D7000047FE808247212120EFFD0122A221E
+4B21:02003FD00260FFFE1C10EFF008100FF000047FE808247212120EFFD0122A221E
+4B22:0800080014FC122429247E24A2243E2422243E242024284424442A8433282210
+4B23:082008201420127E29407E80A23C3E0422083E102020284024422A42323E2000
+4B24:00003FFC200420043FFC208023602C9837F6241027F0241027F4446845188604
+4B25:04200210013EFFC00022011A02860D603FF8C8260FE008200FE808D00A300C08
+4B26:080008781448124829487E86A3003EFC22443E442028282824102A2832442182
+4B27:0800080014FC120029007E00A3FE3E5022503E502050285024522A92328E2100
+4B28:10801080288025FE5202FC8244827DE244A27CA2412A512A4A1A540264144008
+4B29:00007FFC010003600D18710402800D603FF8C8260FE008200FE808D00A300C08
+4B2A:0800080014FE121029107E20A2203E6822643EA22122282024202A2032202020
+4B2B:0804081E14F0129029907E90A2903EFE22903E9020902888248A2AAA32D6208A
+4B2C:10201020282025FC5324FD2445247D2445247FFE402050504850548865044202
+4B2D:00007DFC444444447C94010802800D603FF8C8260FE008200FE808D00A300C08
+4B2E:10081048292825285328FD0845087D0845087D08414851944914542264424082
+4B2F:0810081014101210291E7E10A2103E1022FE3E822082288224822A8232FE2082
+4B30:080008FE1422122229227E22A24A3E4422803E7E2042284224422A42327E2042
+4B31:102010202820242053FEFC7044A87CA845247D24422250F84820542064204020
+4B32:08400840148012FC29047E04A2F43E9422943E9420F4289424042A0432282010
+4B33:10201020292424A452A8FC2045FC7C2044207C2043FE50204820542064204020
+4B34:10201020282025FE5220FC2044207DFC44707CA840A851244924562264204020
+4B35:10201010281025FE5220FC2444447CF844127C22404451884810542864444182
+4B36:080008FC1484128429FC7E84A2843EFC22A23EA42098289024882AA432C22080
+4B37:08200820147C128429487E30A2203E4823903E3E204229A424182A1032602180
+4B38:7F7C08041E282210542809443280CD603FF8C8260FE008200FE808D00A300C08
+4B39:100011FE282024205248FC8445FE7C2244207C2041FC50204820542067FE4000
+4B3A:110410842888240053FEFC2044207DFC44207C2043FE50204820542064204020
+4B3B:10281024283E25E05220FC3C45E07C20443E7DE0402250244818546A65864002
+4B3C:0800087C14441244297C7E00A2FE3E8222823EFE2082288224FE2A82328A2084
+4B3D:088408441448120029FC7E84A2843E8422FC3E482048284824482A8A328A2106
+4B3E:10881048285025FC5224FC2445FC7D2045207DFE40225022486A54A465204020
+4B3F:100011FC2904250453FCFD00451C7D70451C7D70411E51F0491055126512420E
+4B40:100010782A2825285128F82848787B284928792A412A512649225A806C7E4000
+4B41:100CFEF010801CFEF088110832880D603FF8C8260FE008200FE808D00A300C08
+4B42:100010F82888248852F8FC0045FC7D2445247D2441FC510049005502650240FE
+4B43:10201020285024885144FA2249F878084850782040A452824A8A5A8A6C784000
+4B44:102010202BFE242053FCFD2445FC7C2045FC7C2443FE502449FC542064A04040
+4B45:100011FC290425245324FDFC45247D2445747D54415451744904550465FC4104
+4B46:7F2048307E2842247E2049207E800D603FF8C8260FE008200FE808D00A300C08
+4B47:1080108028FC25045244FC4447FC7C4445F47C0441F4511449F4540464284010
+4B48:10101010287C271451FEF9144A7C7A104F7C791041FE55104A10530064FE4800
+4B49:1020102028FE244052FCFD1046FE7C0044FC7C8440FC508448FC548464944088
+4B4A:108810882BFE248852A8FC2045FC7D2445247D2443FE50204850548865044202
+4B4B:1100117C294426445244FE7C4A107A104AFE7A38425452544A945B126A104210
+4B4C:107CFF44107C7E44427C7F44028C0D603FF8C8260FE008200FE808D00A300C08
+4B4D:1020102029FC24205220FCF844207C2045FC7C0041FC51544954555467FE4000
+4B4E:10481148294827FE5148F9484978790049FE782043FE507048A859246E224020
+4B4F:1040102029FE25025102F9FE4900790049FE79AA41AA52FE4AAA5AAA6CA24086
+4B50:11041088280027FE5020F82049FC782048207BFE404050244AA25A8A6C884078
+4B51:10881050280025FE5250FDFC44547DFE44547DFC405050D84954565264504050
+4B52:1010102028FC248452FCFC8444FC7C8444FC7C20401050544942554A66384000
+4B53:102011242924252453FCFC0047FE7C0045FC7D04410451FC4888545067FE4000
+4B54:10101220297C25445044F87C4B407940497C79444144517C49445A806C7E4000
+4B55:100CFEF054807CFE5488FF0812880D603FF8C8260FE008200FE808D00A300C08
+4B56:1040102029FE25005148F94849FE794849487948417851004AD452AA652A4800
+4B57:1040102029FC24885050FBFE480079FC490479FC410451FC489058926912460E
+4B58:100011FC290425FC5104F9FC48207BFE480079FC410451FC482059246A224060
+4B59:100013DE288826A853FEF9884ADA7CA649F87908410851F84908590869F84108
+4B5A:102011FC2888245053FEFC0045FC7D2445FC7D2441FC502049FC542067FE4000
+4B5B:100813882888251057DEFA944AA47B944A947B94429452C84B885E9468A440C2
+4B5C:1020102029FC24205354FC8845047EFA44887CF8408850F8482054A865244060
+4B5D:10201050288825745202FDFC45247DAC45247DFC400050F8488854F8648840F8
+4B5E:100011FC295425FC5220FDFC44207FFE44887C5041FC50204BFE542064204020
+4B5F:108813FE288824005148FBFE49487978490079FC402053FE487058A86B264020
+4B60:102013FE2A88265053FEFA504AFC7A544BFE7A5442FC52504AD8555466524850
+4B61:103C13C0294424A451F8F8204BFC780049F8780841F8500849F85AC46AAA447A
+4B62:104010202BFE26225154F94A4A3A780049FC795443FE500049FC582068A04040
+4B63:104010202BFE24885052FFAC4AAA7AA84DAC7800410451FC490459FC69044204
+4B64:1010107C2A54257C5110F8FE48007B7C4944797C4140517C4944597C6A80447E
+4B65:110810902BFC244051F8F8804BFC794849FC7B0A45F8510849FA5934698C4102
+4B66:108813FE2888241252FEF8104CFE7A924AFE789241FE52924E045AFE6A44422C
+4B67:102013FE2A4827FE5248FAEC4B5A7A484A207A44427852144AFE5A106A5444B2
+4B68:122213FE289025FE5310FDFE491079FE491079FE410053FE4A8A5B766A524276
+4B69:102013FE2A4827FE5248FAEC4B5A7A484A507BDE425053DC4A5055DE64504850
+4B6A:200021FC21043DFC45044BFE800021FC212421FC212425FC282031FC202003FE
+4B6B:4084444859FE6020424042FC3E8400847CFC448444847CFC448444847CFC4484
+4B6C:4092452459246092420042FE3E1000207CFC448444FC7C8444FC44847CFC4484
+4B6D:440028FEFE10102020FC7C84448444FC7C8444FC44847C8444FC44487C844502
+4B6E:3F042018FF62220C7F7010100820FFFE02003FF820083FF820083FF820083FF8
+4B6F:042078201124FF241124392455FC90207C20452445247D24452445247DFC4404
+4B70:0420782011FCFE4010F8384057FE90887D24462244F87C2045FC44207C204420
+4B71:0420792410A4FEA8102039FC552491247D7445AC45247D24452445047D144508
+4B72:0420782011FCFE501088390457FE90087DE8452845287DE8452844087C284410
+4B73:7C4011FCFD2439FC5524FDFC24681BA2651E7FF809203FF8C8260FE008200FE0
+4B74:00001FF811001FF011001FF011001FFC0004292444940108FFFE010001000100
+4B75:00007E7848487E4848487E48486848587E580248AA48AA4AAA4A828A14860900
+4B76:00007EFE48487E4848487E48484848487E480248AA48AA48AA88828815080A08
+4B77:00087F1C48707F1048107F1C487048107F90009EAAF0AA90AA9280920512020E
+4B78:00107E8848847E8449027E02488848887E880250AA50AA20AA50828815040A02
+4B79:00007C40519E7D1251127D12511251127D120512555A55945510841014100810
+4B7A:00207E1048107EFE48007E00487848487E480248AA48AA4AAA4A828A14860900
+4B7B:00107E5048507E5048887E8849044AFA7E480248AA48AA48AA88828815280A10
+4B7C:00007F3C48007F0048007F7E482448247FA400A4AAA4AAA4AAA480A405440284
+4B7D:00087F2848287F28483E7F28484848087F8800FEAA88AA88AA88808805080208
+4B7E:00207E2848247E2448207E2048FC48207E200250AA50AA50AA88828815040A02
+4B7F:00107E1048507E50487C7E90491048107EFE0210AA28AA28AA28824414440882
+4B80:00407E4048FC7E8449047EF4489448947EF40284AA94AA88AA828282147E0800
+4B81:00207E2048407E4848847EFC480448487E4802FEAA48AA48AA48828814880908
+4B82:00287E2448247E2048FE7E204820483C7E340254AA54AA54AA88828815140822
+4B83:00107E1048107E7E48107E10481048FE7E100210AA20AA28AA4482FE14420800
+4B84:00107F0848087F7E48107F10482448247FB80088AA90AA90AAA480BE05020200
+4B85:00147E1248127E1048FE7E90489248927E920294AA94AAB4AACA828A14160822
+4B86:00007EFE48087E1048347E52489048107E000210AA10AAFEAA10821014100810
+4B87:00207E2048FC7E2449FE7E2448FC48207E2002FCAA20AA20ABFE822014200820
+4B88:00107F10481E7F2248547F08481048647F88009EAAA2AAC2AA94808805100260
+4B89:00407E40487E7E8049007E1C48E048A07EA202A4AAA8AA90AA9082A814C40882
+4B8A:00207C2051FE7C2051FC7C2451FC51207DFE0422542A54545450848815040A02
+4B8B:00027C0253E27C8A508A7CEA50AA512A7DAA056A564A544A54828482150A0A04
+4B8C:0090F890A090F910A1FEFB10A510A138F9380954A954A992A910891009103110
+4B8D:3FF821003FF021003FF021003FFC492486940108FFFE048808503A20CC180806
+4B8E:00C27C3450187C6451827C2051FE50507C9005FE56925492549A849414100810
+4B8F:00007EFE48107E10487C7E24482448FE7E000200AA7CAA44AA448244147C0844
+4B90:00007EFE48827E8248AA7EC6488248BA7EAA02AAAABAAAAAAA828282148A0884
+4B91:00047E1E48E07E12488A7E4C484048087EFE0208AA88AA48AA28820814280810
+4B92:00147E1248FE7E1048107EFE489248927EFE0292AA92AAFEAA92829214920886
+4B93:00207E20483E7E2048FC7E8448FC48847EFC02A4AA20ABFEAA20822014200820
+4B94:00047E1E48F07E1048FE7E54485448547EFE0254AA54AAFEAA10821014FE0800
+4B95:0000FBDEA042F94AA084F94AA252A420F8000BDEA852A952A89489480A543422
+4B96:007C7E4448447E7C48447E44487C48007EFE0282AA82AAFEAA82828214FE0882
+4B97:00107E9248927E9248FE7E0048FE48807EBE0288AA88AAFEAA88830815080A08
+4B98:00007E2048CE7E8248827EEE488248827EFE0228AA28AA28AA48824A148A0906
+4B99:00087E0C480A7E0849FE7E08480848EA7EAA02AAAAECAA0CAA2A82CA14160822
+4B9A:00107E10487E7E1048107EFE482448427E90023CAA44AAA4AA288210142808C6
+4B9B:0014FB94A294FAA4A2BEFAA4A364A2B4FAAC0AACAAA4AAA4AB248A240A24322C
+4B9C:00147E5448547EFE48547E54485C48407E7E0210AAFEAA10AA38825414920810
+4B9D:00007EFE48927E1048FE7E10487C48547E7C0254AA7CAA10AAFE821014100810
+4B9E:00207E2049FE7E2048FC7E4049FE48887F0402FAAA88AA88AAF88288148808F8
+4B9F:00407C2051FE7D2250A47D28505050887D0404F8548854885450842014D80B06
+4BA0:00007EFE48007E7C48447E44487C48007EFE0292AA92AAFEAA92829214FE0882
+4BA1:00407E40487E7E80487C7E44487C48447E7C0220AA3CAA44AAA88210142808C6
+4BA2:00047E1E48F07E1048107EFE481048507E960292AA92AAD6AA92829214FE0882
+4BA3:00007EFC48447E3848447EEE48AA48447EAA0210AAFEAA38AA54829214100810
+4BA4:00207E2049FE7F5248487EFE489049907EFE0290AA90AAFEAA90829014FE0880
+4BA5:00007EFE48007E7C48447E7C480048FE7E8202AAAA92AAFEAA92829214920886
+4BA6:00207E1048FE7E00487C7E44487C48007EFE0282AABAAAAAAABA8282148A0884
+4BA7:101010281044FE8211FE7C9044FC7C9044FC7C9010FEFE0212AA12AA14141008
+4BA8:00207E1048FE7EA248107EFE484448287EFE0210AA10AA7CAA10821014100810
+4BA9:00007E7C48447E7448547EFE4882487C7E44027CAA44AA7CAA44824414540848
+4BAA:00847C8450DE7D4451547EDE504450847D24042055FE547054A8852416220820
+4BAB:0020F9FCA124FBFEA124F9FCA020A1FCF92409FCA840ABFEA88889D00870338C
+4BAC:00487E4849FE7E4848007EFC488448FC7E8402FCAA20ABFEAA20825014880906
+4BAD:000E7EF048227E9248447EFE488248FE7E8202FEAA82AAFEAA288248148A0906
+4BAE:00207C2053FE7CA850A87D74522250707CA80546567854885550842014500980
+4BAF:0088F888A088FBD0A09EFBE4A094A7D4F91409D4A954A948A9488A540AD43422
+4BB0:00207E1048FE7E4448287EFE488248927EFE0292AABAAAAAAAAA82BA14820886
+4BB1:0000FA7EA110F930A04AF89AA62CA24CFA9A0A2AAA4AAA88AA288D1008FE3000
+4BB2:00287E28487C7E2848287EFE4810487C7E54027CAA54AA7CAA00822814440882
+4BB3:003CFBE0A124F8A8A3FEF8A8A124A202F9FC0924A924A9FCA924892409FC3104
+4BB4:00107ED448487F4A48847E84497A48007EFC0284AAFCAA00AA84824815FE0800
+4BB5:00207DFC50887C5053FE7C0051FC51247DFC052455FC542055FC842017FE0800
+4BB6:00507E4848FE7F9048FC7E9048FC48907EFE0280AA10AAFEAA38825414920810
+4BB7:00007EFE48AA7EAA48FE7E4048FE49227EFA02AAAAAAAAFAAA2282FA140A0804
+4BB8:0A803138228838382288393822887FFE51029FF411001FF011001FFC2A44492C
+4BB9:0020F93CA120FBFEA010F814A3FEA210FBF00A54AA54AAD4AB688C4A08963322
+4BBA:0040F820A3FEF888A052FFACA2AAA2A8FDAC0800A904A9FCA90489FC09043204
+4BBB:0020FBFEA020F9FCA000FBFEA002A1FCF8200BFEA800ABFEA8048BBE0AA4338C
+4BBC:00127E5448A87E4448927E54489848247EC20284AAEEAB24AAB4825E14440884
+4BBD:0040F820A3FEFA50A3FEFA52A3FEA200FA940AD8AA90AAD2AA8E8C000954322A
+4BBE:0110F890A3DEF810A25EF982A3DEA010FBDE0A50ABDEAA50ABDE8A500A5232CE
+4BBF:0020FBFEA24AF9FEA048F9FEA048A3FEF88409FEAA84A8FCA920893C0AA0347E
+4BC0:03FCF908A1F8F908A1F8F90EA7F8A008FFFE0A94AB9CAA94AB9C8AD60FBC3084
+4BC1:00400FFEF200A3F8F000A7F8F408A7F8F2201D5C57F4BC9495DC1C9657F62CA2
+4BC2:3FF821003FF021003FF892487EFC48907EFC48907EFEAAAA0100FFFE0920711C
+4BC3:0040F82008204BFE4A024C4448407FFE048804881D08E4D04420045028881304
+4BC4:0000F8FC08844884488448FC48207C2005FE05221D52E58A450A0502290A1104
+4BC5:0000F1FE108450FC508450FC50867BFC08040BDE3852C952089409482A541422
+4BC6:00207F20412079204920FFA080A07F2041207F2041207F2241224122451E4200
+4BC7:00207C204420742054FCFE2482247C2444247C4444447C444484448455284A10
+4BC8:00007CFC440074005400FEFE82507C5044507C5044507C5244524492548E4900
+4BC9:00407C404440747C5444FE8882A07D2044207C5044507C484488448455044A02
+4BCA:00007C0045FE74045404FEF482947C9444947C9444F47C944404440454144808
+4BCB:00507C484448744055FEFE4082407C7C44A47CA444A87D284510462854444882
+4BCC:00007CFE4482748254FEFEA082A07CA044F87CA844A87CA84528452A564A4886
+4BCD:00207C20445074505488FF2482127C1045FC7C0444087C884450442054104810
+4BCE:00207C20445074505488FF0482FA7C2044207C2045FC7C204420442054204820
+4BCF:00047C1E44F074105410FEFE82107C1044107CFE44827C824482448254FE4882
+4BD0:00107C10441074FE5492FE9282AA7CC644927C9244AA7CC644824482548A4884
+4BD1:00207C20452474A454A8FE2083FE7C5044507C5044507C5244524492548E4900
+4BD2:00207C20444E74805520FE20825E7CC445447C4444447C444444444454544848
+4BD3:00207C2044FC74205420FE2083FE7C0044207C2044FC7C204420442055FE4800
+4BD4:00207C1045FE75025400FE1C82E07C2044207C3E45E07C2044224422541E4800
+4BD5:00007C0645D874485448FE88829E7DC844487D4845487C9E44804540563E4C00
+4BD6:00207C1044FC74845484FEFC82847C8444FC7CA244A47C984490448854C44882
+4BD7:01107D12451475D85510FF1283527D8E45207C2045FC7C204420442057FE4800
+4BD8:00207C1045FE75025604FEF882007C0045FE7C5044507C5044924492550E4A00
+4BD9:00147C1244FE74105410FEFE82927C9244FE7C9244927CFE4492449254924886
+4BDA:00207C4444F874105424FEFE82027CFC44847CFC44847CFC4484448454944888
+4BDB:00407C2045FC75045480FE9C82D47D5445547D5446D87C504494449455144A0C
+4BDC:00007CFC4484748454FCFE8482847CFC44407CFE452A7E4A44924522544A4884
+4BDD:00207C2044FE744054FCFF1082FE7C0044FC7C8444FC7C8444FC448454944888
+4BDE:00007CF84488748854E8FEA882A87DFC45047D7445547D544574450455144908
+4BDF:00007C844448740055FEFE2082447DA844307C5845987C344452459054504820
+4BE0:00007CF84488748854F8FE8882887CF844007DFC45547D544554455457FE4800
+4BE1:00887C50440075FE5450FFFC82547DFE44547DFC44507CD84554465254504850
+4BE2:00803FFE24103F7C26382D5437FA220823C822482FFE2A0A23F8420842288210
+4BE3:00207DFC452475FC5420FFFE82007DFC45047DFC45047DFC450445FC54884904
+4BE4:00107C28444474BA5500FEFE82927CD644927CFE44007C7C4444447C5444487C
+4BE5:00007CFE448274FE5482FEFE82447CAA44EE7C4444AA7CEE440044D454AA492A
+4BE6:00247CFE4424740054FEFEAA82AA7CFE44147CFE44907CD244AC44AA54964922
+4BE7:01007FFC00001FF010101FF000007FFE40029FF4101017D0145017D010101030
+4BE8:0100FFFE00001FF010101FF000007FFC40044FE448244FEC0200FFFE1830E00E
+4BE9:0100FFFE00001FF010107FFC40044FE448244FEC00003FF821083FF820021FFE
+4BEA:200011FEFE1000207CFC44847C8400FCFE8482FCBA84AA84AAFCBA4882848702
+4BEB:00207C1045FE7C0044FC7C8410FCFE0001FE7D02457A7D4A117A5502930A3104
+4BEC:1000FEEE44AA7CAA00EEFE00AA7CBA54827CFE54447C7C1010FEFE1010101010
+4BED:3E0420183E6020043E182062FF0422187F6000003FF00820044003801C70E00E
+4BEE:3E0420183E6020043E182062FF0422187F6000003FE00420047C08043014C008
+4BEF:3E0420183E6020043E182062FF0422187F60010011102108416403801C00E000
+4BF0:3E0420183E6020043E182062FF0422187F60028004401C70E44E044008401040
+4BF1:3E0420183E6020043E182062FF0422187F6000007FFC01000770190CE1020100
+4BF2:3E0420183E6020043E182062FF0422187F6000003FF821083FF8200220021FFE
+4BF3:3E0420183E6020043E182062FF0422187F60044008203218C44608201FF00810
+4BF4:3F0820303EC42018FF62220C7F7000000FE01020601C1FE0082004C00780F87E
+4BF5:3E0420183E6020043E182062FF0422187F6001003FF801000820FFFE08201020
+4BF6:3F0820303EC42018FF62220C7F7000001FF010101FF010101FF01010FFFE0000
+4BF7:3E0420183E6020043E182062FF0422187F600090FFFE10887E50102420D4C70C
+4BF8:3E0420183E6020043E182062FF0422187F60410021FC0A441048E0A021182606
+4BF9:3F042018FF62220C7F7000003FF000101FF000107FFE40029FF4082007C0F83E
+4BFA:3F042018FF62220C7F7000183FE021003FFC20802C64301C1FF0101010101FF0
+4BFB:3F0820303EC42018FF62220C7F7011001FF82100FFFE00001FF010101FF01010
+4BFC:3E0420183E6020043E182062FF0422187F601400082014A46CA8155064881906
+4BFD:3F0820303EC42018FF62220C7F7001003FF80440FFFE00001FF010101FF01010
+4BFE:3F042018FF62220C7F7000003FF8210827C821082FE8200827C8444847C88018
+4BFF:3E0420183E6020043E182062FF0422187F6001003FF80820145001007FFC0100
+4C00:3F042018FF62220C7F7000001FF00100FFFE0920711C0200FFFE082007C07838
+4C01:3F042018FF62220C7F7000003FF000101FF00010FFFE111009A005401930E30E
+4C02:3F0820303EC42018FF62220C7F7000183FE0121009207FFC05401930E10E0100
+4C03:3E0420183E6020043E182062FF0422187F60082004407FFC044024481450FFFE
+4C04:3F0820303EC42018FF62220C7F7000003FF821083FF821083FF84904489287F2
+4C05:3F042018FF62220C7F7000007FFC02001FF010101FF010101FF010101FF00820
+4C06:3F042018FF62220C7F7000001FF0022001407FFC188462880100FFFE0920711C
+4C07:3F042018FF62220C7F7002001FD00220FFFE03000FF03810CFF008100FF00810
+4C08:3F042018FF62220C7F70082004407FFC01003FF80200FFFE080037F0C0801FFC
+4C09:3F042018FF62220C7F70000010783E4822482A86FF7822482A2842104A2884C6
+4C0A:3F042018FF62220C7F700110FFFE21083FF821083FF821080020FFFE08200460
+4C0B:3F042018FF62220C7F7000001FF010101FF010107FFC44043FF8082007C07838
+4C0C:3E0420183E6020043E182062FF0422187F60108821544A22113C312052A0147E
+4C0D:3F042018FF62220C7F7001007FFC09103108C6C41930E92E05C0193061080300
+4C0E:3F042018FF62220C7F7001001FF011101FF00100FFFE10101FF010101FF00820
+4C0F:3F042018FF62220C7F7008287F240820FFFE12203FA46424BF2824123FAA2046
+4C10:3F042018FF62220C7F7024203F3E21403F5024883F0800003FF824482448FFFE
+4C11:3F042018FF62220C7F7000003FF801007FFE492285147FFC02003FF824482458
+4C12:3F042018FF62220C7F7008207FFC08207FFE40029FF40600192006C038A00318
+4C13:3F042018FF62220C7F7002001FF014901250FFFE92122FE8440407E008203060
+4C14:3F042018FF62220C7F7008003E7822482A867E7822482A30464C3FF82448FFFE
+4C15:3F042018FF62220C7F7001FC01003FFE210221F02F0420FC20004FFC4914BFFE
+4C16:3F042018FF62220C7F7028503E7C4890FEFE1528264A5FF6149012501FF00820
+4C17:BEFA8822BEFA8822BEFA84028782888297C284428FE289228FE289228F1281F6
+4C18:BEFA8822BEFA8822BEFA8002BEFA924A8A2A934A82828C62B19A860280729F86
+4C19:0010FE1000107CFE44107C1000FCFE448244AA449228FE289210922892448682
+4C1A:0020FE1000107CFE44447C440044FE448244AA289228FE109210922892448682
+4C1B:0000FE0001FE7C4044407C780048FE488268AA989298FE88928A92AA92CA8686
+4C1C:0000EFEE200227C22442E7CE80088FE88828EAAE29222FE229222922A92A4864
+4C1D:0044FE2400287CFE44927CD600BAFE9282FEAA00927CFE44927C9244927C8644
+4C1E:713C17C4719C47F0725C17C45A5423C8FFFE00001FF010107FFC44445FF4410C
+4C1F:3FF80000FFFE082010103FF802081FF011101FF012101FF004A808BA3082C07E
+4C20:081010107F10497C49547F54497C49547F54107C1A102C902F904810480287FE
+4C21:080810087F284928493E7F48490849087F7E10081A082C942F924820484287FE
+4C22:102020407C8E550054207C5E54C455447C4410442A442D544F48480287FE0000
+4C23:100021FC7D04550455AC7D54555455547D5411AC2B042D144F08480287FE0000
+4C24:10201040FDFC11247D2455FC7D2455247DFC1040386854B292BE11201122121E
+4C25:00507FFC00403E4822503E2000547FFC11141FF012101FF004A808BA3082C07E
+4C26:080010087F10497E494A7F7E4952497E7F2810481A7E2C882F884808480287FE
+4C27:1020203C7C2054FE54A27CB854E4549C7C8010B82AA82D2A4F464A0287FE0000
+4C28:100021FC7D2455FC55007D7C5544557C7D44117C2A442D7C4F00480287FE0000
+4C29:102010407DFC12941494FFFC10A420A47EFCA22022443E6A226E22A03EA2231E
+4C2A:1020924054FCAA94449482FC7CA444A444FC7C204444446A7C6E44A044A24D1E
+4C2B:1010207C7C1054FE54447CEE544454EE7C0010FE2A282D2A4F46488287FE0000
+4C2C:10FC20287C1055FE54527C9055FE54AA7CC610BA2AAA2DBA4F84480287FE0000
+4C2D:0020FE4010FCFE94AA94AAFCAAA486A400FCFE201044FE6AAA6EAAA0AAA2871E
+4C2E:208843FEF820A9FCA820FBFEA854A992F89023FE209054D45B8A5E9651A28FFE
+4C2F:1100215C7D84555854C87D3E55CA56A87DEC10A82B682D5E4F80480287FE0000
+4C30:00207C4010FCFE94929454FC10A454A400FCFE201044FE6AAA6EAAA0AAA2871E
+4C31:0020FE4010FCFE94929454FC00A4EEA4AAFCEE200044FE6A546EBAA010A2FF1E
+4C32:102010203E20422084207F20492049207F20492049207F22002255224A9E8A80
+4C33:200020007CFE441088107E10521052107E10521052107E100010AA10AA500020
+4C34:20402040788048FC91007E0054F854087C10542054407C800084AA84AA7C0000
+4C35:200021FC7C04440888107E20522053FE7E20522052207E200020AA20AAA00040
+4C36:202020107C10440089FE7E40524052407E40524052407E400040AA40AA7E0000
+4C37:20202020782049FE90207C20542054FC7C20542054207DFE0020AA20AA200020
+4C38:200820487848484890447C8454A455227C20544054407C480084ABFEAA820000
+4C39:202820247C244420882E7EF0522052247E24522852287E100032AA4AAB860002
+4C3A:2004200E7C70444088407E40527E52487E48524852487E480048AA88AA880108
+4C3B:102010203E20423E84447F44494449A47F28492849107F10002855284AC48A82
+4C3C:202020207820485090507C88554456227C2054F854087C080010AA10AA200020
+4C3D:2020202078204BFE90207C2055FC55247D24552455247D340128AA20AA200020
+4C3E:2000200078FC48A490A47CA454A454A47CFC548054807C800082AA82AA7E0000
+4C3F:20402040787E488091207CA054AC54B47DE454A454B47CA800A2AA82AA7E0000
+4C40:20202020782048FC90A47CA454A454A47CA455FE54207C500050AA88AB040202
+4C41:2020202078204BFE90507C50548855247E22542055FC7C200020AA20AA200020
+4C42:201020507850489090FC7D5455D454947C94551455547DD40054AA24AA340048
+4C43:201020107C504450887C7E90531052107EFE521052287E280028AA44AA440082
+4C44:2008201C79F0495091507D50555055507D50554855487D680154AA74AA520400
+4C45:2020202078204BFE90207C20542055FC7C7054A854A87D240124AA22AA200020
+4C46:200021FC78444848908E7C82557A56147C20542057FE7C200020AA20AAA00040
+4C47:200020007CFC448488847E8452FC52847E84528452FC7E840000AA00ABFE0000
+4C48:200020FC7800480090007DFC542054207CA854A455247D220222AA20AAA00040
+4C49:200020F87888488890887CF8548854887C8854F854887C880088AA88ABFE0000
+4C4A:20202020792448A490A87C20542057FE7C7054A854A87D240124AA22AA200020
+4C4B:204820487848484891FE7C48544854487C4855FE54007C480044AA84AA820102
+4C4C:200020FE7C90449088907EBC52A452A47EA452A452BC7E900090AA90AAFE0000
+4C4D:200021FE7840484090407C78548854A87C98550855487C300010AA10ABFE0000
+4C4E:200021FE7800480090FC7C84548454FC7C84548454FC7C840000AA00ABFE0000
+4C4F:200021FE7800480090FC7C84548454847CFC540054847C440048AA00ABFE0000
+4C50:2008203C79C0480491447CA8540055F87C10542057FE7C200020AA20AAA00040
+4C51:2080208C78B048A093E07CA054BE54E87CA857A854A87CA800A8AAA8AAC80188
+4C52:2000207C7C444444887C7E0052FE52927E92529252FE7E800080AA82AA82007E
+4C53:2000200679D8484890487C88549E55C87C48554855487C9E0080AB40AA3E0400
+4C54:2088208878884910915E7D64575455547D54555455547D480148AB54AB140122
+4C55:2080208078FE490092FC7C8454A454947DFE548455247D1401FEAA04AA280010
+4C56:200020FE7C28442888287EEE52AA52AA7EAA52AA52EE7E280028AA28AA480088
+4C57:08000F7C28447F28A11016283846CFE010403FF051101FF011101FF024884244
+4C58:03043C2404247FA416242504440C0FE010403FF051101FF011101FF024884244
+4C59:20802080789C48F490947C9457F454147C94549455C87EA80088AA94AA9401A2
+4C5A:200021F87808480890F87C08540855FC7C20552454A87C7000A8AB24AAA20040
+4C5B:20142012781049FE90107C1055D255527D52555455D47C0800CAAB1AAA260042
+4C5C:20482048784849FE90487C4855FE54007CFC548454847CFC0084AA84AAFC0084
+4C5D:2020204078FE489290927CFE549254A27CFE544854887DFE0008AA08AA080008
+4C5E:2020202079FE485090887D0456FA54007C0055FE54207CA400A2AB22AA200060
+4C5F:200020FE7C82448288FE7E88528852FE7E88528852BE7EA200A2AAA2AABE0122
+4C60:20482044785E49E090287C12546A55967C48545E55E07C240028AA12AA6A0186
+4C61:2080208078FE490292227CAA547254227DFE542254727CAA0122AA22AA0A0004
+4C62:2080208078F8490892107DFC542454247DFE542454247DFC0024AA20AAA00040
+4C63:2040202079FE480090887C88555456227C00542055FE7C200020AA20AA200020
+4C64:20402040787C488491087E00542054CE7C82548254EE7C820082AA82AAFE0082
+4C65:24043FA44424FFA404243F8424942FE810403FF051101FF011101FF024884244
+4C66:20502048788048FE91907E9054FC54907C9054FC54907C900090AAFEAA800080
+4C67:2020212478A8482091FC7C4057FE54887D0456FA54887C8800A8AA92AA82007E
+4C68:2082208273E2908A208AFBEAAAAAAAAAFAAAAAEAA88AF9CA02A2AC82A88A0084
+4C69:200020FE7C8244C688AA7EFE52A252927EFE52A252A27EBA0082AA82AA8A0084
+4C6A:2010201079FE481090107CFE541054107DFE542054527CD40148AA44AA620040
+4C6B:04047FC404243FA424A43FA4150424944FE810403FF051101FF011101FF02488
+4C6C:200021FE78124890909C7C90557E56007CFC548454FC7C8400FCAA84AA940088
+4C6D:208020FE7890489090D07CBC559456947CAC54A454B47C880088AA88AAFE0080
+4C6E:2080209E73EA908A21CAF88AABEAA892F8A6A820ABFEF8200050A888A9040602
+4C6F:7E20243E1848FFA829104A2898460FE010403FF051101FF011101FF024884244
+4C70:2008203C79E0482093FE7C2055FC55247DFC552455FC7C2001FCAA20ABFE0000
+4C71:202020107CFE440088447E2852FE52827E10527C52547E540054AA5CAA100010
+4C72:2040207C788448F890087DFE544054A47D38545854947D340054AA92AB500020
+4C73:200021FE7900497C91547D54557C55547D54557C55107D10017CAA10AA1004FE
+4C74:2040205E78404860915E7D525552555E7C52545254527C5E0052AA40AA5E0040
+4C75:205020887924484090907DF8540854007DDC544455547CCC0154AA44AA5400C8
+4C76:2100209E79D2495491547DD8555455527DD25512559A7D5401D0AB50AA100010
+4C77:0F1008107F9048A04E3E79444F2451245F2475285F2855105F284028AAC40082
+4C78:20A0212C7924492491AC7D24552455FC7C2055FC54887C500020AA50AA880306
+4C79:204420247C2844FE88107E7C521052FE7E205220527C7E500090AB10AAFE0000
+4C7A:202021247924492491FC7C0057FE54007DFC550455047DFC0088AA50ABFE0000
+4C7B:2000207C7C44447488547EFE5282527C7E44527C52447E7C0044AA44AA540048
+4C7C:200021FE7902490291FE7D245524557E7D24552455FE7D520154AA48AA640442
+4C7D:202020207850484890A47DFE568454FC7C8454FC54807CFC0144AB44AA7C0044
+4C7E:202021FC79244BFE91247DFC542055FC7D2455FC54407DFE0088ABD0AA70038C
+4C7F:21002102711C97D02110FFD0AD5EAFD4FD54AFD4A914FFD40114A924A9240144
+4C80:08207E2008F8FF2814287F6A082A0FE610423FF051101FF011101FF024884244
+4C81:200423E47224922423EEFA04AAE4AA04FA0CABF4AA44FA640554AD44AA5400C8
+4C82:22102110711097BE2240FA00ABBEAA8AFA88AAA8AAAEFAA804A8ADA8A85E1080
+4C83:209221247892480090FE7C9254FE54927CFE541055FE7C380054AA92AB100010
+4C84:2208220873C8921027DEFA54AB64AAD4FFF4AA54AD54FCC807C8A854AAA40142
+4C85:2100213C712493A4213CF924A924ABBCF924A924A93CF92802A8AACAAC4A0886
+4C86:202020207C78444888907E7C525452547E7C525452547E7C0000AAAAAAAA0000
+4C87:20102210797C4910907C7C545754557C7D10553855547D920110AA90AA7E0000
+4C88:2020201079FE494891487D4855FE55487D4855EC555A7D680148AB48AA480048
+4C89:21402144715893F02150F9D0A95EA9D4F954A954ABF4F8140154AA34AC140024
+4C8A:2010239072FE92A022BEFB48AABEAA80FABEAAA2AABEFB22023EAA22AA220226
+4C8B:2088208879DC488893DE7C88555456227CFC548454847CFC0084AA84AAFC0084
+4C8C:2108210877C89108211EFB92A824AB80F808AFC8A908F9080594A954A9240342
+4C8D:112420A879FC48406BFE59084A84FCFA49104BFC6D2459FC492449FC48009954
+4C8E:200823887088911027DEFA94AAA4AB94FA94AB94AA94FAC80388AE94A8A400C2
+4C8F:2048216A78DC484890B47D2255FE55027C20542054FC7C240044AA44AA940108
+4C90:2020203E782049FE91227DFC5522557E7D54557C55547D7C0110AAFEAA2204C6
+4C91:210420887BFE482091FC7C2057FE54547D92549057FE7C9000D4AB8AAA9601A2
+4C92:210021DE724A948A23EAFAB6AAA4ABF4FABEAAA4ABE4FABE02A4AAA4AA240464
+4C93:202020207850488891047EFA540054007DDC555455547DDC0088AA88AB540222
+4C94:200023FE700091FC2124F9FCA924ABFEF800A9FCA924F9FC0124A9FCA80003FE
+4C95:2084204879FE4848914A7CCC544855FE7C0054FC54847C8400FCAA84AA8400FC
+4C96:202023FE702091FC2000FBFEA802A9FCF820ABFEA800FBFE0004ABBEAAA4038C
+4C97:21202120725692482580F970AA2EAA24FEF4AA24AAACFA740224AA34AAC4020C
+4C98:2108210879EE4A9490427C1055FE55027CF8548854F87C8000FCAA84AAFC0084
+4C99:2108210871EE92942042F800ABDEAA52FBD2AA52ABD2FA1A0294AB50AA100010
+4C9A:2088208873EE90922084FBEEAAAAAAAEFBEAA88EA9CAFAAE04A0A88CA88A0092
+4C9B:208823FE788849FC91547DFC540057FE7E0254F854887CF80088AAF8AA8800F8
+4C9C:3C3C4848FCFC54547C7C54547C7CAAAA3C3C4848FCFC54547C7C54547C7CAAAA
+4C9D:202020207C50445088887D04560254F87C88548854A87C9000821C82E07E4000
+4C9E:204020207C20440089FE7C00540454847C84544854487C4800501C10E3FE4000
+4C9F:200020407D9E451289127D1255D255127D125512555A7D9401101C10E0104010
+4CA0:202020207DFE442088FC7C4055FE54887D0456FA54887C8800F81C88E08840F8
+4CA1:208820487C5045FE88507C5055FC55547D54558C55047DFC01041D04E1FC4104
+4CA2:01243CA825FC244027FE3D08268424FA25103FFC252425FC252445FC54008BFE
+4CA3:0F1008107F9048A04E3E79444F2451245F2475285F2855105F284028BF440082
+4CA4:400044FE7A28882814FEFAAAAAAAA8AAF9AEAAC2AE82FAFE02821A82E2FE4082
+4CA5:02003FE004221822E21E1FF010101FF010101FF010001FFC10001FFC2A44452C
+4CA6:101020107F1041107F7E41107F1040107F9040287FA800A8AAA8AAC481440682
+4CA7:1040108011FC110411FCFD0411FC110011FE11001DFEE00242AA02AA0202000C
+4CA8:004000807DFC110411FC110411FC110011FE110011FE1C02E2AA42AA0202000C
+4CA9:3FFC20043FFC220027F0241027F0241027F0240027FC240047FC40048AA40AAC
+4CAA:1040108011FC110411FCFD0411FC110011FE290025FE240242AA42AA8202000C
+4CAB:0080FDF8290829F8290829F8290029FC290029FC280429542A5C480247FE8000
+4CAC:1004201E7CF044907C9044907C9040FE7E9040907E900288AA8AAAAA82C60C82
+4CAD:04200E40F0FC908490FC9084FCFC908090FE908090FE88028AAAC6AA8302000C
+4CAE:00207C4000FC008400FCFE8428FC288028FE288028FE2A024EAA4AAA8202000C
+4CAF:00207E4022FC248424FC28842EFC22802AFE248044FE4A0292AA20AA4102000C
+4CB0:0040008079FC010401FC0104FDFC210021FE210041FE50028AAAFAAA0A02000C
+4CB1:102020107F0041FE7F2041207F3C40247FA440247FA400A4AAA4AAA481540688
+4CB2:0020284024FC248442FC528490FC108020FE208048FE4402FCAA44AA0102000C
+4CB3:1020084008FCFF8400FC00843CFC248024FE248024FE250246AA44AA8102000C
+4CB4:1040108011FC150459FC510451FC910011FE110011FE280226AA42AA4202800C
+4CB5:0100111021E84F04F2001FF010101FF010101FF010001FFC10001FFC2A44452C
+4CB6:1FF00000FFFE0844323CDFF010101FF010101FF010001FFC10001FFC2A44452C
+4CB7:04001FF010101FF010101FF010001FFC10001FFC492484940108FFFE0920711C
+4CB8:1040108011FC290425FC4304A9FC290029FE290029FE28024AAA4AAA8A02000C
+4CB9:00407E8009FC090411FC150433FC510091FE110011FE00020EAAF2AA4202000C
+4CBA:4840488049FC4904FDFC490449FC490079FE490049FE48024AAA7AAA4A02000C
+4CBB:2040108001FCFD0421FC410449FC8900F1FE110021FE20024AAAFAAA0A02000C
+4CBC:1040108051FC51047DFC510491FC110011FE7D0011FE100212AA1EAAE202400C
+4CBD:00400080F9FC210421FC410479FC4900C9FE490049FE48027AAA4AAA0202000C
+4CBE:00007DFE108010FC1E04F02802101FF010101FF010101FFC10001FFC0004492C
+4CBF:00203E4022FC228422FC3E8420FC288028FE2E8028FE28024AAA4CAA8902000C
+4CC0:101020107C5044507C7C44907D1040107EFE40107E280228AA28AA4482440C82
+4CC1:105020487C4844407DFE44407C40407C7EA440A47EA80328AB10AA2882440C82
+4CC2:0020FC4024FC248444FC548488FC00807CFE448044FE440244AA7CAA4502000C
+4CC3:02001FF010101FF010101FFC10001FFC0004492C08001EF8228854980882307E
+4CC4:1420144014FC548455FC5E8454FC548054FE548054FE54025DAA76AAC502000C
+4CC5:100020007F3E41227F2241227F22403E7FA240007F940094AAA2AAA281420600
+4CC6:1040108021FC790449FC490449FC490079FE490049FE48024AAA7AAA4A02000C
+4CC7:00203C4024FC34842CFC248424FCFE8044FE648054FE44027EAA04AA2902100C
+4CC8:104020407CFC44847D0446F47C9440947EF440847E940288AA82AA82827E0C00
+4CC9:204020803DFC4504A9FC110429FC450083FE310009FE000262AA12AA0A02000C
+4CCA:2820244024FC2084FEFC208420FC3E8042FE448054FE880216AA22AA4202000C
+4CCB:2040208021FCF904A9FCA904A9FCA900F9FEA10021FE28023AAAEAAA4202000C
+4CCC:1040108021FC4904FDFC050479FC490049FE790049FE78024AAA4AAA4A02580C
+4CCD:24102420247C24447F7C2444247C2440247EFF40007E240224AA42AA4302820C
+4CCE:0040408099FC890489FC890489FCD90089FE890089FE8802FAAA8AAA0202000C
+4CCF:1040108011FC7D0411FC1104FDFC010011FE11007DFE100212AA1EAAE202400C
+4CD0:410021FC0A441048E0A0211826061FF010101FF010101FFC10001FFC0004492C
+4CD1:10201040FEFC108420FC3E8422FC6280BEFE228022FE3E0222AA22AA2302260C
+4CD2:08207F280824FFFE10207F2041247F2441247FA840287F900092AAAAAAC60182
+4CD3:102012407EFC148414FCFF8408FC108020FE7E80A0FE22022CAA30AA2102000C
+4CD4:060038F820083CF820083FF802001FF010101FF010101FFC10001FFC0004492C
+4CD5:0E20F04022FC928454FC0084FCFC088010FE168018FEF00252AA12AA5202200C
+4CD6:100021FE7CA044A87CA844E87CA840A87EA840E87EA802AAAABAABEA82260C20
+4CD7:02001FF010101FF010101FFC5244892C02403C500848FFFE08507E240854198C
+4CD8:201040D8F3949094F09093FEF0908094F89480D8FB980890A8AAA8CA8A863102
+4CD9:081008207F7C49447F7C49447F7C0040FF7E2040407E7E0202AA02AA1502080C
+4CDA:00407C8045FC7D0445FC7D0401FC01007DFE110011FEFE0212AA12AA1202100C
+4CDB:00207E4042FC42847EFC428442FC7E8010FE1080FEFE220264AA18AA2502C20C
+4CDC:1020104028FC448482FC7C8410FC1080FEFE108054FE520292AA10AA5102200C
+4CDD:202010407CFC008444FC288400FCFE8000FE00807CFE440244AA44AA7D02440C
+4CDE:081008207F7C10443E7C1044FFFC2240497E88C03E7E08027FAA08AA0902080C
+4CDF:00200E40EAFCAA84AAFCAE84EAFCAA80AAFEAE80EAFEAA020AAA12AA1302260C
+4CE0:02100F20787C0844FF7C2A442A7CFF402A7E2A40FF7E080208AA0EAA7102200C
+4CE1:2820244040FC7E84C8FC48847EFC488048FE7E8048FE480248AA7EAA4102400C
+4CE2:4840488049FCFD0449FC490479FC490079FE490049FEFC0202AA52AA4A02840C
+4CE3:08507F480840FFFE20403E502222465A82861FF010101FF010101FFC5244892C
+4CE4:10109220527C5444107CFE44927C9240BA7ED640927E920292AA82AA8B02840C
+4CE5:1020924092FCFE8410FC288444FC928008FEFC8004FE080252AA22AA1202000C
+4CE6:20201040FEFC828400FC7C8400FC7C8044FE7C8044FE7C0202AA1EAAE202400C
+4CE7:21004178F1089208F2FE9640FA40827CFA908210FAFE0A10AA28AA288A443282
+4CE8:102020407CFC44847CFC44847CFC0080FEFE108010FE7C0212AA1EAAF202400C
+4CE9:0020FE4028FC2884FEFCAA84AAFCFE8010FEFC8024FE44022AAA12AA2A02C40C
+4CEA:1020924092FC9284FEFC0084FEFC108020FEFE80AAFEAA02AAAAAAAAAB02860C
+4CEB:0A107420157C5244227C2144417CBE40087E08407F7E080214AA12AA2302400C
+4CEC:28402880FDFC290439FC11047DFC550055FE7D0011FEFC0212AA12AA1202100C
+4CED:0020EE40AAFCAA84AAFCEA84AAFCAA80EAFE8A80CAFEAE02D8AA88AA0902080C
+4CEE:00207C1045E07C2245B47CA8452456A28A401FF010101FF010101FFC5244892C
+4CEF:1C20704010FCFE8410FC7C8454FC7C8054FE7C8010FE7C0210AA1EAAF102400C
+4CF0:1008179014BC24A424BC67A4A23C22202FBE272026BE2A822AAA322A2202220C
+4CF1:00207E7C14C40838FEC62A2048FCA844128C1FF010101FF010101FFC5244892C
+4CF2:11FE1100FD7C11001DFEF1541248546422421FF010101FF010101FFC5244892C
+4CF3:1020544054FC7C8492FC9284FEFC00807CFE0080FEFE100254AA92AA5102200C
+4CF4:0020FE40AAFCAA84AAFCFE8410FC548052FE928010FE540252AA92AA1102100C
+4CF5:11041108111E7D1213DE5552555E5550BB5E1150395E554292521252154A1884
+4CF6:100E20F07C2244927C4444207C4440F87E1040247EFE0210AAFEAA2882440C82
+4CF7:11102110CAA814443240D27C154014FE0A001FF010101FF010101FFC5244892C
+4CF8:00803FFE24103F7C26382D543412210027F0241027F0241027FC40044AA4800C
+4CF9:20404020F3FE9202F00893EEF008801CFBE48154F9480954A964A942893E3200
+4CFA:08101420227C4944BEFC0444087CFFC0147E7F40557E6302412A7F2A41427F0C
+4CFB:08047F7808403E402A7E3E482A48FF480A881FF010101FF010101FFC5244892C
+4CFC:100020FE7C8044807CBC44A47CA440BC7E8040EE7EAA02AAAAEEAA8082FE0C00
+4CFD:1020924092FCFE8428FC24847EFCC88048FE7E8048FE7E0248AA48AA7F02400C
+4CFE:0A107420157C5244227C21445D7C80407E7E4240427E7E0242AA24AA0F02F00C
+4CFF:24102620357C54445F7C7444947C64402A7E4940917E0002AAAAAAAAAB02000C
+4D00:101008207F7C2244FF7C00447F7C49407F7E49407F7E08027F2A082A0F42F00C
+4D01:20201040FEFC82847CFC54847CFC54807CFE1080FEFE920292AABAAA8B02840C
+4D02:20103E20427CFF44497C49447F7C1040287ED540267ECD0215AA24AAD502080C
+4D03:102010407CFC1084FEFC4484EEFC448064FEDE8000FEFE0228AA2AAA4D02880C
+4D04:0F10F020117C8944427C0044FF7C8140427E7740927E5A022F2A222A4242820C
+4D05:08107F20087C2244FFFC22447F7C41407F7E41407F7E41027F2A222A4142808C
+4D06:2820AA406CFC2884FEFC448428FCFE8010FE7C8010FEFE0210AA28AA4502820C
+4D07:00107F20087CFFC488FC6B44087C6B40147E2A40457EBE0202AA04AA1902040C
+4D08:10202040FEFC9284D6FCBA84FEFC9280BAFED68082FE1002FEAA28AA4502820C
+4D09:0020FE40AAFCAA84FEFC0084FEFC00807CFE44807CFE2A0264AAA2AA3102200C
+4D0A:41082210FFBC08247F3C0824FFBC152064BE2420FFBE2402352AE2AA2582688C
+4D0B:200043FCF2949294F3FC9000F7FE8000FBFC8204FBFC08A2A914AB088D443182
+4D0C:104820487DFE44487CFE44827D7C40007EFE40207ED2022CAAD8AA2C82CA0C30
+4D0D:00100020777C5544557C7744557C5540777E5540557E7702002A552A88C2000C
+4D0E:00001FF011101FF011103FF82AA83EF82AA83FF810101FF010101FFC5244892C
+4D0F:22082210FFBC22243E3C41245D3CD5E0553E5520DD7E4182002A552A4A828A8C
+4D10:0808FF9084BC77242A3C77242ABCFFA0003E7F20413E7F02412A7F2A2202410C
+4D11:7F0849107F3C4924FFBCAAA4FFBCAAA0FFBE0020FFBEA2823E2A222A2782F80C
+4D12:7F080810FFBC88A46B3C08246B3C0020EFBEAAA0EFBE0002FFAA492AAA82FF8C
+4D13:0010FFA0087C084408647F544944494C4940497E49024D024A7A0802080A0804
+4D14:2020104000FCFE8400A4288444948288048044FE2802100229FA440284140008
+4D15:7F0408441E44224454440844320CDFE01420126010001FF800087F8800280010
+4D16:10201040FEFC10847CA41084FE9400887C8044FE7C0244027DFA440254144808
+4D17:00207E4042FC7E8442A47E8442947E88148012FEFF02100229FA240242148008
+4D18:03107C20477C44445F64555456445C4C5540537E50025702557A5502A98A0004
+4D19:02087910493E4BA248327AAA412247E67920693EAB82A902297A3902290A0104
+4D1A:104010201E2010FC1000FE009278C648AA48D648AA48C64A924AFE8A82860100
+4D1B:101010921E5210541010FEFE9282C682AAFED682AA82C6FE9282FE82828A0084
+4D1C:101010201EFE10921092FEFE9292C692AAFED620AA24C65A925EFE908292010E
+4D1D:1000107C1E44107C1044FE7C9200C7FEAAA0D6EEAAAAC6EA92BAFFE48224002A
+4D1E:100011DC1E44115410CCFF549250C648AAFED790AAFEC69092FEFE9082FE0080
+4D1F:00803FFE22203FFC22243FFC242027BC2422279E200023F0221042904452980E
+4D20:00803FFE22203FFC22243FFC242027BC2422279E203827C020405FFE41108E0E
+4D21:00007FFE024012480A503FFE22203FFC22243FFC284028482F7048444B448C3C
+4D22:00803FFE22203FFC22243FFC242027BC2422279E204020402FFE415042488C46
+4D23:08047F1E54F054107F92555255547F1054FE54105E10541054105C1056508020
+4D24:00803FFE22203FFC22243FFC242027BC242227DE224023FC24404BF840409FFE
+4D25:00803FFE22203FFC22243FFC242027BC2422279E24003FBC24A444A44ABC9124
+4D26:00803FFE22203FFC22243FFC242227BE20403FFE200027F8200047F8440887F8
+4D27:081C7F70541054FE7F38555455927F10542054FE5E24544454285C10562880C4
+4D28:08007F7E544854507F5C555455547F5C545454545E5C5448545C5CAA568A8118
+4D29:00803FFE22203FFC22243FFC20003FFC21402FF829482FF820005FFC44908988
+4D2A:00803FFE22203FFC22243FFC280024F824083E78220824FE2E545538445484B2
+4D2B:08007F7C541054FE7F92555455107F54542854545E8A547C54045C0856308008
+4D2C:08480844FF442A402A5E5DE088401C402A4050401E2022225412080A14066002
+4D2D:08080808FF082A082AFE5D0888181C182A2850281E4822885408080814286010
+4D2E:08100810FF102A102A925D9288921C922A9250921E922292549208FE14026000
+4D2F:08400840FF402A7E2AAA5D2A882A1C4A2A4A50921F1222225422084214946008
+4D30:08480844FF442A402A5E5DE088401C442A4450481E3022225452088A15066002
+4D31:08200810FF102AFE2A825D0488401C482A5050601E40224254420842143E6000
+4D32:08100810FF102AFE2A105D1088101C7C2A1050381E3822545454089214106010
+4D33:08200810FF102AFE2A825D0488001C282A2850281E2822285444084414446082
+4D34:08100810FF102A102A1E5D1088101C102AFE50821E8222825482088214FE6082
+4D35:10841048FE0054FC5448BA481048384855FEA2483C484448A84810882888C108
+4D36:10401040FEFC54885550BA2010D83B2654F8A2203CF84420ABFE10202820C020
+4D37:10401020FE2055FE5502BA0410F838005400A3FE3C504450A89010922912C20E
+4D38:080E08F0FF222A922A545D00887C1C082A1050101EFE22105410081014506020
+4D39:0800087CFF542A542A7C5D5488541C7C2A1050FE1E1022385454089214106010
+4D3A:08200810FF7C2A002A445D2888001CFE2A0050001E7C224454440844147C6044
+4D3B:0640387C08947E242CD44A0801007FFC11102BA845641918E3E60E4001800E40
+4D3C:10481044FE5E55E05428BA12106A39965448A25E3DE04424A8281012286AC186
+4D3D:10201040FEFE54925492BAFE109238A254FEA2483C8845FEA80810082808C008
+4D3E:10841044FE4855FE5420BAFC102039FE5440A2803CFE4510AA10141029FEC000
+4D3F:100011FEFF0254785400BAFC104038A45538A2583C944534A85210902950C020
+4D40:10101092FE54541054FEBA82108238FE5482A2FE3C824482A8FE10002844C082
+4D41:10481148FF5E556A5554BBC81050386455C4A37E3D444564A95411442954C248
+4D42:10201010FEFE54445428BAFE1082389254FEA2923CBA44AAA8AA10BA2882C086
+4D43:08280828FF7C2A282A285DFE88101C7C2A54507C1E54227C5400082814446082
+4D44:105011FCFF5455FC5554BBFC100039FC5400A3FC3D0445FCA88810502BFEC000
+4D45:08207F20083E3E4408A87F1010281E462280FFFE11C82AB40DD0764E01801E40
+4D46:10481048FEFE544854FEBA82117C380054FEA2203CD2442CA8D8102C28CAC030
+4D47:081004107FD04910493E49247FD4491459145D946B544D084908491489140922
+4D48:111023E040480BFC110033F0551010E0111012883FFE24103F7C26384D549412
+4D49:00803FFE24103F7C26382D543492214026303BEE20002FA428A44FA448A4898C
+4D4A:0088788849FC488868885BFE4820FDFC492449FC492449FC4800488849049A02
+4D4B:282028207DFE28402840FEFC10847D8456FC54847C8454FC54847C8428944488
+4D4C:282028207C2029FC2820FEA810A87CA8557456227C50545054887C8829044602
+4D4D:282028107DFE280028FCFE8410FC7C0054FC54087C1055FE54107C1028504420
+4D4E:282029247D24292429FCFE0013FE7C20544055FC7D54555455547D542954450C
+4D4F:280029DC7C44295428CCFF5410287C44559254207CC8543254C47C1828604580
+4D50:280029DC7D54295429DCFE0011FC7D2455FC55247DFC542057FE7C2028204420
+4D51:0C00700011FCFE24382454A490A428A455249024542438445444928451142208
+4D52:0C0070FC1084FE8438845484908428FC54849084548438845484928450FC2084
+4D53:0C1070101090FE9038FE549091102810541091FE541038105410921050102010
+4D54:0C20702013FEFE2039FC552491FC292455FC9020547038A85524962250202020
+4D55:0C0071FC1104FF0439FC5510911029FE55109110557C394455449344517C2244
+4D56:7E7C48047E2842107E2848FC7F0001007FFC09103288CC643938C54609203310
+4D57:0C0071FC1000FEF83888548890F8280055FC9124552439FC5524932451FC2104
+4D58:0C0070FC1084FEFC388454FC900029FE548090FE552A3A4A5492932250542088
+4D59:0C00702010FEFE4438825520907C288854509068559E382254D49208503021C0
+4D5A:0C1E71E01022FF1238945480902029CE5502910255CE39025502930251FE2102
+4D5B:0C0071EE114AFFEA392A55E49144294A55F09000541038FE5410921051FE2000
+4D5C:0C5071FC1154FFFC395455FC900029FE5500917C550039FE5550935451482266
+4D5D:00207F2049206B205D2049207F2008207F2008200F20F022002255224A9E8000
+4D5E:00047F0449046B245D2449247F2408247F2408240F24F024000455044A948008
+4D5F:0000FE7C9210D610BA109210FE1010FEFE1010101E10E0100210AA10A8108010
+4D60:0040FE409240D6FCBA849304FE041084FE4410441E44E0040204AA04A8288010
+4D61:00003FF801007FFC04401830E00E3FF8292825483FF801007FFC0100FFFE4444
+4D62:0010FE109210D67CBA109210FE1010FEFE1010381E38E0540254AA92A8108010
+4D63:0000FE0092FCD684BA849284FEFC1084FE8410841EFCE0840200AA00A9FE8000
+4D64:3FF808200820FFFE0820102020207FF8292825483FF801007FFC0100FFFE4444
+4D65:0040FE40927CD684BB0892FCFEA410A4FEA410FC1E80E0800282AA82A87E8000
+4D66:0000FE9C9248D608BA889248FE5E1008FE2810481EC8E0480248AA48A8488018
+4D67:08207F280824FFFE00207F2049246B2449247F2808287F100812FFAA0046AA82
+4D68:0048FE449240D6FEBA509254FE581052FE5410581E52E054029AAA92A92E8240
+4D69:03043C2404247FA416242504440C3FF8292825483FF801007FFC0100FFFE4444
+4D6A:0000FEFC9284D684BAFC9284FE8410FCFE0010901E92E0F40298AA92A8D2808E
+4D6B:01007FFC50043EF84288A2AA1492187EE0003FF8292825483FF80100FFFE2448
+4D6C:0010FE1092DAD654BA549292FF501020FEFE10821E82E0FE0282AA82A8FE8082
+4D6D:0020FE2092FAD624BA2893FEFE201040FEFC11441E44E07C0244AA44A87C8044
+4D6E:0000FE7C9244D67CBA44927CFE0010FEFE40107E1EAAE12A024AAA92A82A8044
+4D6F:0008FE1C92E0D620BBFE9220FEFC10A4FEFC10A41EFCE02002FCAA20A9FE8000
+4D70:0040FE7E9280D77CBA44927CFE44107CFE0010FE1E40E0FE032AAA4AA8928026
+4D71:0010FE1092FED610BA7C9200FE7C1044FE7C10281EFEE000027CAA44A87C8044
+4D72:007CFE449244D67CBA0092EEFEAA10AAFEEE10101EFEE0380254AA92A9108010
+4D73:0010FE289244D6BABB0092FEFE9210D6FE9210FE1E00E07C0244AA7CA844807C
+4D74:0000FEFE92AAD6AABAEE9228FEEE10AAFEAA10EE1EAAE0AA02EEAAA8A82A801E
+4D75:20403F7E48909FF8149012501130FFFE08203FF8D55613901FF001007FFC2448
+4D76:200021FC21547D5445DC845075DC5554555455DC7554555405DC05502852103E
+4D77:100011FC11547D5411DC1050FDDC0154115411DC7D54115411DC1D50E052403E
+4D78:7C101052FE94382854449FF212901EF002803EF822883EF822883EFA028201FE
+4D79:201C7DC8917EFDC828185FF092901EF002803EF822883EF822883EFA028201FE
+4D7A:21F8210821F8250AF5FA250A25FA2402279E20903090EF9E4492049204920892
+4D7B:1C4414441CEE55445DEE55445DEE41447744140014FEF702557E550255FE9502
+4D7C:0440247C24A83D5004287DFE248844488FF848244FE448247FFC0440FC7C2444
+4D7D:0810FF7E08107E7C42447E282418FEE601003FF80100FFFE040008201FF00810
+4D7E:081017FE3210D15010200810FF1008FE7E1000FC7E4442487E2824101E28E0C6
+4D7F:0810FF1008FC7E1000FC7E4442287E1024281EC6E10001FC01003FF820083FF8
+4D80:0810FF7E08107E7C42047E4824381E44E10006C01830E7CE00001FF010101FF0
+4D81:0810FF7E08107E7C42447E3824447E8201187D6009183FF6D0101FF010101FF0
+4D82:2020CE208220EE7C82448284FE04008492449224DA249204DA0492049328D910
+4D83:2010CE108210EE2882288244FE4400A292109210DA7C9204DA0892089310D910
+4D84:2000CEFC8210EE1082948254FE58001093FE9210DA109210DA1092109310D910
+4D85:2020CE20823CEE4482A88210FE2800449282927CDA449244DA449244937CD944
+4D86:2028CE248240EE7E82C88348FE7E00489248927EDA489248DA48927E9340D940
+4D87:2010CE1082FEEE9282FE8292FEFE0000927C9244DA7C9244DA7C92449344D94C
+4D88:2014CE1283FEEE1082FE8292FEFE009292FE9292DA0493FEDA4492249324D90C
+4D89:2020CEDE828AEECA82AA82D2FEA6000092FE9292DA9292FEDA92929293FED982
+4D8A:20007CFC44247C2444247C240024FEFC9244FE449244FE440044FE4445FE8400
+4D8B:20007CFC44447C4844487C50005CFE449244FE449268FEA80090FE9845248442
+4D8C:20407C4044FC7C8445047EF40094FE9492F4FE849294FE880082FE82447E8400
+4D8D:0040FEF8208828F84488FCF8140011FC11247DFC112411FC1C00E3FE40880108
+4D8E:10103E1022283E2822443E82007C7F0049007F7C49447F440044FFC4227C4244
+4D8F:4420287C0044FC7C1444147CFC0090FE9092FEFE329232FE5A0054FE90441084
+4D90:20107C2844447CBA45007CFE0092FED69292FEFE9200FE7C0044FE7C4444847C
+4D91:20207CF844207DFC45047CF800A8FEF892A8FEF89244FEFC0020FEB844A0857C
+4D92:0100FFFE02847D78255025484D6420083FF820083FF822083FF8244843889C68
+4D93:2040202023FEF888A852AFACAAAAAAA8ADACA800A904B9FC210421FC21042204
+4D94:102050205C2050A0FEAC28B4AAE4D7A482A4FEB4AAA8AAA2D6A29E82E27E0200
+4D95:080028002F7C2854FF54145455546B54417C7F40554055406B424F42713E0100
+4D96:081028102F102828FF28144455446BA241107F10557C55046B084F0871100110
+4D97:0800287E2F042804FF74145455546B5441547F54557455546B044F0471140108
+4D98:082028102F1028FEFF00140455446B4441247F24552855286B084F1071FE0100
+4D99:0800287E2F402840FF40147C55446B4441447F44557C55406B404F40717E0100
+4D9A:081028102F10287CFF54145455546B54417C7F54551055146B124F7E71220100
+4D9B:7F0408441E44224454440844310CC9E009007FFC04402AA83FF824482AA83FF8
+4D9C:101050505C50507CFE502890AA10D6FE8200FE00AA7CAA44D6449E44E27C0244
+4D9D:102050205C2051FCFE2028A8AAA8D6A88374FE22AA50AA50D6889E88E3040202
+4D9E:082428242F7E2824FF24143C55246B24413C7F24552455FE6B004F2471220142
+4D9F:102050205C3C5044FE482880AA20D6CC8284FE84AACCAA84D6849E84E2FC0284
+4DA0:00283FFE20202FA420282F9048AA4FC68082010011F81100FFFE04402AA83FF8
+4DA1:100250E25CA250AAFEAA28EAAAAAD6AA82EAFEAAAAAAAAA2D6E29E02E24A02A4
+4DA2:100C500A5C0850FEFE882888AAFAD68A828AFEECAAACAAACD6EA9E8AE2960322
+4DA3:101050545C545054FE7C2800AAFED600827CFE44AA44AA7CD6449E28E2FE0200
+4DA4:1000507C5C445074FE5428FEAA82D67C8244FE7CAA44AA7CD6449E44E2540248
+4DA5:1020503C5C2050FEFEA228B8AAE4D69C8280FEBCAAA4AABCD6A49EBCE2A4037E
+4DA6:102051FC5C2050FCFE2029FEAA00D6FC8284FEFCAA84AAFCD6849EFCE2480284
+4DA7:101050105C7E5010FEFE2844AAEED6448264FEDEAA00AAFED6289E28E24A0286
+4DA8:101050105C285044FE82287CAA00D6EE82AAFEAAAAEEAA44D6449EAAE2AA0312
+4DA9:102050105DFE5054FFA828ACABAAD6A883ACFE00AA84AAFCD6849EFCE2840304
+4DAA:104C51FA5C4851FEFE082868AA5AD6FA83AAFEFCAAACAAFCD6AA9EFAE2960222
+4DAB:13DE52525FDE5000FFFE2A00AAC8D64E83EAFEB2AAEAAAAAD6EA9EB4E3E4022A
+4DAC:00007C7C1010FEFE1010101008407F7C1440FF7C22043E7C22403E7C2242263E
+4DAD:140012FE12101010FF90147C14101510151016FE260024022C02540243FE8000
+4DAE:04400420FFFE0910116021844F0480FC00001FF001007FFC028004401830600C
+4DAF:208027FC240427BCF0A056BE52A257B652AA96AA50B626A222BE57A052A2867E
+4DB0:1000FF8680B8F7881408D7CE5458F6C85548D54E16F8D44857CAF40A544ACFC6
+4DB1:408047FC740497BC50A026BE52A28FB60AAA66AA10B606A282BE47A022A2067E
+4DB2:104013FE12027FDE5450575E7D5257DA55565756FC5A4752455E47D055524B3E
+4DB3:081008081400227E5D0080807F3855287F2800287F28552A7F2A554A55464380
+4DB4:08402A7C48941410212846C41830EFEE00003BB82AA87FFC44447FFC4444444C
+4DB5:1004103E2BE0463CBA2002FCFEA4AAB8FEE4029CFE80AAB8FEA8AAAAAB2A8646
+4DB6:020003F802007FFE000011F811087DF811081DF8300057FE1090109C5150223E
+4DB7:00000110791049104910491049104910491049107A104A1202120412040E0800
+4DB8:00000080788048804880492049204A204840484078884884010403FE01020000
+4DB9:000001000100210821082108210821083FF80100010002000200040008003000
+4DBA:3C102410241025FF3D112511251125293D252543258125012501450155058902
+4DBB:3C202420242025FE3D2224242420242824283C48244824882489450956078800
+4DBC:7848488449124A21784449824BFE480278204810495249414A458845A83C1000
+4DBD:3D5225222552258A3DFE2448244824873D102420247C24842548442054588984
+4DBE:000008100810681F8BA188AAEBC88888FF88081408140C1412222122C1410000
+4DBF:084808481448124828487E48A2483E4822483E482088288924892A8933072100
+4DC0:0000000000007FFC00007FFC00007FFC00007FFC00007FFC00007FFC00000000
+4DC1:0000000000007C7C00007C7C00007C7C00007C7C00007C7C00007C7C00000000
+4DC2:0000000000007C7C00007FFC00007C7C00007C7C00007C7C00007FFC00000000
+4DC3:0000000000007FFC00007C7C00007C7C00007C7C00007FFC00007C7C00000000
+4DC4:0000000000007C7C00007FFC00007C7C00007FFC00007FFC00007FFC00000000
+4DC5:0000000000007FFC00007FFC00007FFC00007C7C00007FFC00007C7C00000000
+4DC6:0000000000007C7C00007C7C00007C7C00007C7C00007FFC00007C7C00000000
+4DC7:0000000000007C7C00007FFC00007C7C00007C7C00007C7C00007C7C00000000
+4DC8:0000000000007FFC00007FFC00007C7C00007FFC00007FFC00007FFC00000000
+4DC9:0000000000007FFC00007FFC00007FFC00007C7C00007FFC00007FFC00000000
+4DCA:0000000000007C7C00007C7C00007C7C00007FFC00007FFC00007FFC00000000
+4DCB:0000000000007FFC00007FFC00007FFC00007C7C00007C7C00007C7C00000000
+4DCC:0000000000007FFC00007FFC00007FFC00007FFC00007C7C00007FFC00000000
+4DCD:0000000000007FFC00007C7C00007FFC00007FFC00007FFC00007FFC00000000
+4DCE:0000000000007C7C00007C7C00007C7C00007FFC00007C7C00007C7C00000000
+4DCF:0000000000007C7C00007C7C00007FFC00007C7C00007C7C00007C7C00000000
+4DD0:0000000000007C7C00007FFC00007FFC00007C7C00007C7C00007FFC00000000
+4DD1:0000000000007FFC00007C7C00007C7C00007FFC00007FFC00007C7C00000000
+4DD2:0000000000007C7C00007C7C00007C7C00007C7C00007FFC00007FFC00000000
+4DD3:0000000000007FFC00007FFC00007C7C00007C7C00007C7C00007C7C00000000
+4DD4:0000000000007FFC00007C7C00007FFC00007C7C00007C7C00007FFC00000000
+4DD5:0000000000007FFC00007C7C00007C7C00007FFC00007C7C00007FFC00000000
+4DD6:0000000000007FFC00007C7C00007C7C00007C7C00007C7C00007C7C00000000
+4DD7:0000000000007C7C00007C7C00007C7C00007C7C00007C7C00007FFC00000000
+4DD8:0000000000007FFC00007FFC00007FFC00007C7C00007C7C00007FFC00000000
+4DD9:0000000000007FFC00007C7C00007C7C00007FFC00007FFC00007FFC00000000
+4DDA:0000000000007FFC00007C7C00007C7C00007C7C00007C7C00007FFC00000000
+4DDB:0000000000007C7C00007FFC00007FFC00007FFC00007FFC00007C7C00000000
+4DDC:0000000000007C7C00007FFC00007C7C00007C7C00007FFC00007C7C00000000
+4DDD:0000000000007FFC00007C7C00007FFC00007FFC00007C7C00007FFC00000000
+4DDE:0000000000007C7C00007FFC00007FFC00007FFC00007C7C00007C7C00000000
+4DDF:0000000000007C7C00007C7C00007FFC00007FFC00007FFC00007C7C00000000
+4DE0:0000000000007FFC00007FFC00007FFC00007FFC00007C7C00007C7C00000000
+4DE1:0000000000007C7C00007C7C00007FFC00007FFC00007FFC00007FFC00000000
+4DE2:0000000000007FFC00007C7C00007FFC00007C7C00007C7C00007C7C00000000
+4DE3:0000000000007C7C00007C7C00007C7C00007FFC00007C7C00007FFC00000000
+4DE4:0000000000007FFC00007FFC00007C7C00007FFC00007C7C00007FFC00000000
+4DE5:0000000000007FFC00007C7C00007FFC00007C7C00007FFC00007FFC00000000
+4DE6:0000000000007C7C00007FFC00007C7C00007FFC00007C7C00007C7C00000000
+4DE7:0000000000007C7C00007C7C00007FFC00007C7C00007FFC00007C7C00000000
+4DE8:0000000000007FFC00007C7C00007C7C00007C7C00007FFC00007FFC00000000
+4DE9:0000000000007FFC00007FFC00007C7C00007C7C00007C7C00007FFC00000000
+4DEA:0000000000007C7C00007FFC00007FFC00007FFC00007FFC00007FFC00000000
+4DEB:0000000000007FFC00007FFC00007FFC00007FFC00007FFC00007C7C00000000
+4DEC:0000000000007C7C00007FFC00007FFC00007C7C00007C7C00007C7C00000000
+4DED:0000000000007C7C00007C7C00007C7C00007FFC00007FFC00007C7C00000000
+4DEE:0000000000007C7C00007FFC00007FFC00007C7C00007FFC00007C7C00000000
+4DEF:0000000000007C7C00007FFC00007C7C00007FFC00007FFC00007C7C00000000
+4DF0:0000000000007C7C00007FFC00007FFC00007FFC00007C7C00007FFC00000000
+4DF1:0000000000007FFC00007C7C00007FFC00007FFC00007FFC00007C7C00000000
+4DF2:0000000000007C7C00007C7C00007FFC00007C7C00007C7C00007FFC00000000
+4DF3:0000000000007FFC00007C7C00007C7C00007FFC00007C7C00007C7C00000000
+4DF4:0000000000007FFC00007FFC00007C7C00007FFC00007C7C00007C7C00000000
+4DF5:0000000000007C7C00007C7C00007FFC00007C7C00007FFC00007FFC00000000
+4DF6:0000000000007C7C00007C7C00007FFC00007FFC00007C7C00007FFC00000000
+4DF7:0000000000007FFC00007C7C00007FFC00007FFC00007C7C00007C7C00000000
+4DF8:0000000000007FFC00007FFC00007C7C00007FFC00007FFC00007C7C00000000
+4DF9:0000000000007C7C00007FFC00007FFC00007C7C00007FFC00007FFC00000000
+4DFA:0000000000007FFC00007FFC00007C7C00007C7C00007FFC00007C7C00000000
+4DFB:0000000000007C7C00007FFC00007C7C00007C7C00007FFC00007FFC00000000
+4DFC:0000000000007FFC00007FFC00007C7C00007C7C00007FFC00007FFC00000000
+4DFD:0000000000007C7C00007C7C00007FFC00007FFC00007C7C00007C7C00000000
+4DFE:0000000000007C7C00007FFC00007C7C00007FFC00007C7C00007FFC00000000
+4DFF:0000000000007FFC00007C7C00007FFC00007C7C00007FFC00007C7C00000000
+4E00:0000000000000000000000000000FFFE00000000000000000000000000000000
+4E01:00007FFC01000100010001000100010001000100010001000100010005000200
+4E02:0000FFFE040004000800080010001FF000100010001000100010001000A00040
+4E03:02000200020002000200023C07C0FA0002000200020002040204020401FC0000
+4E04:01000100010001000100010001000100010001000100010001000100FFFE0000
+4E05:0000FFFE01000100010001000100010001000100010001000100010001000100
+4E06:0000FFFE02000200040004000800080010002000400080000000000000000000
+4E07:00000000FFFE04000400040007F0041004100810081010101010201040A08040
+4E08:00800080008000807FFC0080108010800880048002800100028004401830E00E
+4E09:000000007FFC00000000000000003FF800000000000000000000FFFE00000000
+4E0A:02000200020002000200020003F80200020002000200020002000200FFFE0000
+4E0B:0000FFFE02000200020002000240022002100208020802000200020002000200
+4E0C:0000FFFE08200820082008200820082008200820082010201020202040208020
+4E0D:00007FFC00800080010001000340052009101108210441048100010001000100
+4E0E:1000100010001FFC1000200020003FF8000800080008FFC80008000800500020
+4E0F:0000FFFE01000100210021FC2104210421043FFC000400040004000400280010
+4E10:0000FFFE01000100210021FC2100210021003FFC000400040004000400280010
+4E11:00003FF0021002100210021002103FF0041004100410041004100410FFFE0000
+4E12:00003FF8010801080908050802080308048804880808105020200000FFFE0000
+4E13:0100010001003FF802000200FFFE040008000FF0001000200640018000400020
+4E14:00001FF01010101010101FF01010101010101FF01010101010101010FFFE0000
+4E15:00007FFC0080010001000340052009103108C1040100010001000000FFFE0000
+4E16:02201220122012201220FFFE122012201220122013E01000100010001FFC0000
+4E17:111011101110111011101110FFFE11101110111011101110111011101FF01010
+4E18:001000781F8010001000100010001FFC104010401040104010401040FFFE0000
+4E19:0000FFFE0100010001007FFC4104410442844244442448244004400440144008
+4E1A:04400440044004404444244424481448145014600440044004400440FFFE0000
+4E1B:08200820082008200820082008201450125022882088410482020000FFFE0000
+4E1C:0200020002007FFC04000900110021003FF80100092011102108410405000200
+4E1D:0810081010201020224442847CF804080810102020407EFC00000000FFFE0000
+4E1E:00003FF00020004000807D0405880950092011102108410685000200FFFE0000
+4E1F:00007FFC0100010001003FF8010001000100FFFE02000400082010103FF81008
+4E20:04400440044004447C48045004600440044204421C42E43E44000000FFFE0000
+4E21:0000FFFE0100010001007FFC410449244924492449244FE44024400440144008
+4E22:001000F83F00010001003FF8010001000100FFFE02000400082010103FF81008
+4E23:0000FFFE0440044004407C7C4444444444447C7C044408400840104020404040
+4E24:0000FFFE0440044004407FFC4444444444444AA44A9451144204400440144008
+4E25:00007FFC024012480A5002403FFE200020002000200020002000400040008000
+4E26:1010082004407FFC0440044004404444244414481450044004400440FFFE0000
+4E27:010001007FFC01001110091009200100FFFE1200111010A010401430180E1000
+4E28:0100010001000100010001000100010001000100010001000100010001000100
+4E29:0040004010401040104010401040104010C013401C4010400040004000400040
+4E2A:0100010002800440082010102108C10601000100010001000100010001000100
+4E2B:0000201010200840048001000100010001000100010001000100010001000100
+4E2C:0100010001001100090009000100030005000900310001000100010001000100
+4E2D:01000100010001003FF8210821082108210821083FF821080100010001000100
+4E2E:00007FF00410041004107FD0041004100410FFD00412040A040A040604020400
+4E2F:0100010C017007807900010C017007807900010C017007807900010001000100
+4E30:0100010001007FFC0100010001003FF8010001000100FFFE0100010001000100
+4E31:04400440444444444444444444444C44547C644404400840084010402040C040
+4E32:010001003FF8210821083FF8010001007FFC410441047FFC4104010001000100
+4E33:044004403FF8244824483FF8044004407FFC444444447FFC4844104020404040
+4E34:08800880088049FE49404A204C20480049FC492449244924492409FC09040800
+4E35:0440244814500440FFFE0000082004403FF801000100FFFE0100010001000100
+4E36:0000000000000000000004000200010000800040004000000000000000000000
+4E37:0000000000000008200810100810042004400080000000000000000000000000
+4E38:02000200020002007FE0022012200A20042004200A20092211222022401E8000
+4E39:00001FF0101010101210111011101010FFFE1010101010102010201040508020
+4E3A:010021001100110001007FF80208020802880448044808081008200840508020
+4E3B:0200010000007FFC01000100010001003FF801000100010001000100FFFE0000
+4E3C:08200820082008207FFC08200A2009200820FFFE082008201020102020204020
+4E3D:0000FFFE000000003EF822882288228832C82AA82AA82288228822882AA82490
+4E3E:2208110811100020FFFE082011102108CFE6010001007FFC0100010001000100
+4E3F:0100010001000100010001000100010001000200020004000400080010002000
+4E40:000000000000080008001400140024004200010000C00030000E000000000000
+4E41:000000003F000100010001000100010001000080008000400020001000080006
+4E42:000000102010201010201020082008400440028001000280044008203018C006
+4E43:00003FF00410042004200440047C040408040804080410041004200440288010
+4E44:000000100010001000100220012000C0004000A0011022102400380020000000
+4E45:04000400040007E008200820104020404080008001400240042008103008C006
+4E46:0010081008101020102020407FC020800080014001400220042008103008C006
+4E47:002003F03E00020002000200020003FCFE000200020002040204020401FC0000
+4E48:01000100020002000440084010802080410002000420081010083FFC10040000
+4E49:020001102110201010201020082008400440028001000280044008203018C006
+4E4A:0000000801FC7E00000820081010101008200840000000000000000000000000
+4E4B:02000100010000007FF800100020004000800100020004001800240043FE0000
+4E4C:010002001FF01010101010101050102010001FFC000400047FE4000400280010
+4E4D:080008000FFE12001200220043F882000200020003FC02000200020002000200
+4E4E:001000F83F0001001110091009200100FFFE0100010001000100010005000200
+4E4F:001001F87E0000000200010001007FF8003000C003000C003000480087FE0000
+4E50:002000F01F0010001100210021003FFC01000920091011082104410405000200
+4E51:000801FC7F00010009040908119021A045408540092011102108410681000100
+4E52:002000F01F00100010001FF81080108010801080FFFE00000800100020004000
+4E53:002000F01F00100010001FF81080108010801080FFFE00000040002000100008
+4E54:001000F83F00010002007FFC044008203018C826082008200820102010202020
+4E55:000800FC3F8020802FF8208020803FFE208020802FF82888488848A888900080
+4E56:00701F8001000100FFFE0100092009247928093009221922E91E010001000100
+4E57:00F83F0001007FFC09200920FFFE092009207FFC0380054009203118C1060100
+4E58:00F83F0001007FFC01000924F93809223922CB9E054009203118C10601000100
+4E59:00007FF00020004000800100020004000800100010002004200420041FFC0000
+4E5A:100010001000100010001000100010001000100010001004100410040FFC0000
+4E5B:00000000FFFC0004000800100000000000000000000000000000000000000000
+4E5C:000000001000103010D017103810D0101010105010201002100210020FFE0000
+4E5D:04000400040004007FE0042004200420082008200820102210222022401E8000
+4E5E:080008001FFC1000200040009FE000200040018006000804100410040FFC0000
+4E5F:010001001100113011D017103910D1101110115011201102100210020FFE0000
+4E60:00007FF8000800080808040802080208006801880E0870082008000800500020
+4E61:020002000420082010403F800108020804101FE000400080010006001800E000
+4E62:082008200820082049204920492049204920492049204F2279220022001E0000
+4E63:084008401040104022404240FC4004400840104024404242FE424242003E0000
+4E64:0000FFFE02000240022002100208020000007FF0006001800600180420041FFC
+4E65:000801FC7E000010101008200440008000007FF0006001800600180420041FFC
+4E66:0220021002083FE00220022002200220FFFC0204020402040204022802100200
+4E67:0040044002401240084009FC7E400040004000007FF0006003801C0420041FFC
+4E68:08200820102022204120FFA000A000207F20412041204122412241227F1E4100
+4E69:08200820082008200FA00820082008207F20412041204122412241227F1E4100
+4E6A:0000FDFC052405240924092411FC112421242124412441FC400240023FFE0000
+4E6B:100010007E7C124412441244227C4A4484007FF0006001800600180420041FFC
+4E6C:00003FFC20003FF820083FF820003FFC00007FF0006001800600180420041FFC
+4E6D:0000FFFE040008001FF02810C8100FF000007FF0006001800600180420041FFC
+4E6E:0C0070FC408444845C8464944488088010807FF0006001800600180420041FFC
+4E6F:00F87F0011100920FFFE01000100050002007FF0006001800600180420041FFC
+4E70:00007FFC0004088804802480108010800100FFFE010002C0042008103008C004
+4E71:04400E40384008400840FF40084008403E4022402240224222423E42223E0000
+4E72:4080208009FC12042448E04020A023182C0600007FF0006003801C0420041FFC
+4E73:02200F20F020012091204A200020FE20042008200F20F82248220822281E1000
+4E74:080C08F07E8008800EFE788808882908120800007FF0006003801C0420041FFC
+4E75:102008207F20002022201420FFA00820082008207F20082208220822081E0800
+4E76:012001107FFC01003FF821083FF821083FF8210800003FF001C01E0420041FFC
+4E77:1020082040A824A409221228703010C0170000007FF0006003801C0420041FFC
+4E78:0800087C28442E643A54EAFE2A442AA42A942EFE2804282A201220021FFE0000
+4E79:08200820FFA008207F2041207F2041207F2049200820FFA208220822081E0800
+4E7A:061838E020803EFC22903E902090411080007FF0006001800600180420041FFC
+4E7B:10100810FF2820443E822210220842204A1084087FF0006003801C0420041FFC
+4E7C:2080104087FC4040104023F8E040204027FC20007FF0006003801C0420041FFC
+4E7D:01081FD001207FFC02000FF03810CFF008100FF000003FF001C01E0420041FFC
+4E7E:104010401080FEFE11007E0044FC7C0844107C201040FE801102110210FE1000
+4E7F:0F20F020112089204220102022207C2008201120FFA008A24A228922281E1000
+4E80:04000FE010403FF051101FF011101FF001003FF821083FF821083FFA010200FE
+4E81:08200820FFA0087E7F4041807F7C41047F0800107F200840FFC20842083E0800
+4E82:0F20F02049202220FE2014200820FF209520BD208320BD2295228922951EA300
+4E83:082049202A20FFA02A20492088A04120412077A09120552227A24122811E0100
+4E84:0820FFA008207F200020FFA080A07F2000207F2041207F22412222220F9EF000
+4E85:0010001000100010001000100010001000100010001000100010001000500020
+4E86:00007FF800100020004001800100010001000100010001000100010005000200
+4E87:0800080008000FFC100411082110410001000100010001000100010005000200
+4E88:00001FF000100220014000807FFE008200840080008000800080008002800100
+4E89:080008001FE020204040BFF8010801087FFE010801083FF80108010005000200
+4E8A:010001007FFC111009203FF801080108FFFE010801083FF80108010005000200
+4E8B:01000100FFFE01003FF821083FF801003FF80108FFFE01083FF8010005000200
+4E8C:0000000000003FF800000000000000000000000000000000FFFE000000000000
+4E8D:00003FF80000000000000000FFFE010001000100010001000100010005000200
+4E8E:00003FF80100010001000100FFFE010001000100010001000100010005000200
+4E8F:00003FF8000000000000FFFE0400040008000FF0001000100010001000A00040
+4E90:00003FF8020002000200FFFE0400040008000FF0001000100010001000A00040
+4E91:00003FF80000000000000000FFFE0200040004000840102020107FF820080008
+4E92:00007FFC0400040004000FF008100810101010201FE0002000400040FFFE0000
+4E93:00003FF8000000000000FFFE0820082008200820082010201020202040208020
+4E94:00007FFC02000200020002003FF00410041004100410081008100810FFFE0000
+4E95:08200820082008207FFC0820082008200820FFFE082008201020102020204020
+4E96:000000003FF8000000000000FFFE0000000000003FF8000000000000FFFE0000
+4E97:010001002108210821083FF80000000000003FF80000000000000000FFFE0000
+4E98:00007FFC000000001FF0101010101FF0101010101FF0101000000000FFFE0000
+4E99:00007FFC0400040004000FF008100A10111010200420022000400040FFFE0000
+4E9A:00007FFC044004400440044044442444244814481450044004400440FFFE0000
+4E9B:04400440244427482470244224422F42F03E400000001FF0000000007FFC0000
+4E9C:00007FFC0440044004403FF824482448244824483FF8044004400440FFFE0000
+4E9D:0400082010103FF80810102024487EFC020400003FF8000000000000FFFE0000
+4E9E:00007FFC0440044004403C7820082008200820083C78044004400440FFFE0000
+4E9F:00003FF0002000400180793C49044944492849107928014405000200FFFE0000
+4EA0:020001000100FFFE000000000000000000000000000000000000000000000000
+4EA1:0200010001000000FFFE1000100010001000100010001000100010001FFC0000
+4EA2:020001000100FFFE000000000FE00820082008200820082210221022201E4000
+4EA3:020001000100FFFE042004200420042004200420042008200820102020204020
+4EA4:020001000100FFFE0000101010082024482404400280010002800C403030C00E
+4EA5:0200010000007FFC02000400082010403F8801100620184060A003100C087004
+4EA6:020001000100FFFE044004402450244824484444444488440840104021404080
+4EA7:020001007FFC00000820042004403FFE20002000200020002000400040008000
+4EA8:02000100FFFE00001FF0101010101FF000003FF0006001800100010005000200
+4EA9:020001000100FFFE000000003FF82108210821083FF82108210821083FF82008
+4EAA:02000100FFFE0440145024484844094010807FE0002000200010001000080006
+4EAB:020001007FFC00001FF010101FF000001FE000400180FFFE0100010005000200
+4EAC:02000100FFFE000000001FF01010101010101FF0010011101108210445040200
+4EAD:020001007FFC00001FF010101FF000007FFE40029FF401000100010005000200
+4EAE:020001007FFC00000FE008200FE000007FFE400287C40440044008423042C03E
+4EAF:02000100FFFE00001FF010101FF000003FF8200820083FF8200820083FF82008
+4EB0:02000100FFFE000000001FF010101FF010101FF0010011101108210445040200
+4EB1:02000100FFFE0800080013F81208320853F89208120813F81208100017FC1000
+4EB2:020001003FF8000008200440FFFE010001007FFC010009201110210845040200
+4EB3:01007FFC00001FF010101FF000007FFE400280F43F00020003F87E02020201FE
+4EB4:01007FFC00001FF010101FF000007FFE41029FF401007FFC02003FE00822701E
+4EB5:0100FFFE000008407DF808480CC8784A08AA2906130204880C503530C60E0400
+4EB6:0100FFFE00003FF8200827C824483FF800001FF010101FF010101FF00000FFFE
+4EB7:010000803FFC041002203FFE22402FF822483FFE22482FF826604A50524C8240
+4EB8:20881048FC5001FC7D2445247DFC01247D2409FC10201C20F3FE102050202020
+4EB9:0100FFFE00002FEC48246BAC48246BAC4AA4FFFE90121FF010101FF01010FFFE
+4EBA:0100010001000100010001000280028004400440082008201010200840048002
+4EBB:0800080008001000100030003000500090001000100010001000100010001000
+4EBC:01000100010001000280028004400440082010102008C00600000000FFFE0000
+4EBD:010001000100028002800440082010102008C006020001000080008000000000
+4EBE:008000800080208020802140214022202220241028083006200020003FFE0000
+4EBF:080008000BFC1008101030203040508090801100110012021202120211FE1000
+4EC0:08200820082010201020302037FE502090201020102010201020102010201020
+4EC1:08000800080013FC1000300030005000900010001000100017FE100010001000
+4EC2:084008400840104013FC30443044504490441084108410841104110412281410
+4EC3:080008000BFE1020102030203020502090201020102010201020102010A01040
+4EC4:00003FFE20002000208020802080208020802140214022204220441088081006
+4EC5:08000BFC09041104110430883088508890501050102010201050108811041602
+4EC6:0840084008401040104030503048504490441040104010401040104010401040
+4EC7:090009000900110017F0311031105110911011101110121212121412180E1000
+4EC8:0800082009201120112031203120512091201110111012101208140818041002
+4EC9:080009F0091011101110311031105110911011101110111211121212120E1400
+4ECA:0100010002800440082012102108C10600001FF0001000200020004000800100
+4ECB:0100010002800440082010102008C82608200820082008201020102020204020
+4ECC:010001000280024004200810110861040100028002800440082010102008C006
+4ECD:080008000BF810881090309030A050BC90841084110411041104120412281410
+4ECE:0820082008200820082008200820082008501450125012882088210442048402
+4ECF:08400840084010401040308030805080910011101108120817FC120410041000
+4ED0:0100010002800440082010102108C10601000100FFFE01000100010001000100
+4ED1:0100010002800440082010102008C806083008C00F0008080808080807F80000
+4ED2:0100010002800440082010102008C6060180004000000C00030000C000200000
+4ED3:010001000280044008203018C0060FE00820082008A008440804080407FC0000
+4ED4:08000BF80808101010203040304057FE90401040104010401040104011401080
+4ED5:084008400840104010403FFE304050409040104010401040104017FC10001000
+4ED6:084008400A401258126832C833485E4892481248125812421202120211FE1000
+4ED7:081008100810101013FE30103010511091101090109010501020105011881606
+4ED8:081008100810101017FE30103010501091101090109010101010101010501020
+4ED9:1040104010402040244464446444A4442444244424442444244427FC20042000
+4EDA:0100010002800440082010102108C1060100210821082108210821083FF80008
+4EDB:081008780BC01040104030403040507E97C010401040104210421042103E1000
+4EDC:08000800080013FE10203020302050209020102010201020102017FE10001000
+4EDD:0100010002800440082010102008C0061FF0010001000100010001007FFC0000
+4EDE:080008000BFC1044104432443244524494841084108411041104120414281810
+4EDF:081008780BC0104010403040304057FE90401040104010401040104010401040
+4EE0:08000BFC084010401040304030405FFE90401040104010401040104010401040
+4EE1:08800880090011FE1200340031F8500890101060108011001202120211FE1000
+4EE2:08800880090011FC120432043404590490841044104410041004100410281010
+4EE3:089008880888108010BE37C03080504090401040102010221012100A10061002
+4EE4:01000100028004400A2011102108C0061FF00010002004400280010000800080
+4EE5:0010041022102110211020102010202020202020244028503088210402020402
+4EE6:0820082008201020102031283124512492221222122214221020102010A01040
+4EE7:02000200020003F8020002000200FFFE0100010001000280044008203018C006
+4EE8:080008000BFC100010003000300051F89000100010001000100017FE10001000
+4EE9:084008400840104010403040307C504090401040104010401040104017FE1000
+4EEA:088008480A481208120831103110511090A010A01040104010A0111012081406
+4EEB:084008400880108011003110321054209020104010801108120417FE12021000
+4EEC:0900088008BC1204120432043204520492041204120412041204120412141208
+4EED:080008000BF81088108832883188508890C810A81098110E1108120814501820
+4EEE:0808083C0BC012001200320033F8528892881288125012501220145014881906
+4EEF:0840084008401148114432423242544890481048101010101020104011801600
+4EF0:080008800B3C122412243224322452249224122412B413281220102010201020
+4EF1:0840084008A010A01110328834465040900013F8100810101010102010201040
+4EF2:084008400840104017FC3444344454449444144417FC14441040104010401040
+4EF3:08200A200A2012221222322433A85230922012201220122212A21322121E1000
+4EF4:080009FC09041104110431FC31045104910411FC110411041204120414141808
+4EF5:11001100110023F8224062406440A04020402FFE204020402040204020402040
+4EF6:082008200920112011FC322032205420902017FE102010201020102010201020
+4EF7:0840084008A010A0111032083406511091101110111011101110121012101410
+4EF8:081008780FC0104010403040304057FE904010A010A011101110120814041802
+4EF9:08400840084017FC10403040304053FC9040104010401FFE1040104010401040
+4EFA:01000280044008203018C0061FF01000100010001FF01000100010001FF80000
+4EFB:081008780BC010401040304030405FFE90401040104010401040104017FC1000
+4EFC:080008000BFE1020102030203020502091FC1020102010201020102017FE1000
+4EFD:081008900890108811083104320455FA90881088108810881108110812281410
+4EFE:08000FFE08801080108030F8310851089108120813F810101010101017FE1000
+4EFF:08800840084017FE11003100310051F891081108110811081208120814501820
+4F00:082009200920111011103248324854449882108011101108120817FC12041000
+4F01:010001000280044008203118C1060100110011F81100110011001100FFFE0000
+4F02:1040104010402FFE2040604067FCA44424442444244424542448204020402040
+4F03:08000BF80808111010A0304037FE504290441040104010401040104011401080
+4F04:08000BFC08441044104433FC32405240944017FE10421042104A104410401040
+4F05:08400840084017FC1040324832485248924813F81048104010421042103E1000
+4F06:09000900090011FC12A434A430A4512491241244144410841104120414281010
+4F07:080009F0091011101110320E340053F891081110109010A0104010A013181C06
+4F08:0800088008401020112031003100550495021502150219081108110810F81000
+4F09:08800840084013FC1000300031F05110911011101110111211121212120E1400
+4F0A:08000BF808881088108837FE30885088908813F8108810801100110012001400
+4F0B:100017F81108211021106120613CA10421042288228822502420245028882306
+4F0C:08000BFE0A00120012F8328832885288928812A81290128214821482187E1000
+4F0D:08000BFC084010401040304033F8508890881088108811081108110817FE1000
+4F0E:08400840084017FE10403040304057F892081208111010A0104010A011181606
+4F0F:0840085008481048104037FE3040504090A010A010A011101110120814041802
+4F10:089008880888108010BE37C03080504490441048103010221052118A16061002
+4F11:084008400840104017FE304030E050E091501150124814441842104010401040
+4F12:0808081C09E011001100310031FE511091101110111011101110121012101410
+4F13:080008000BFE102010203040304050D091481244144410401040104010401040
+4F14:080008000BFE12021404300031F05110911011101110111212121212140E1800
+4F15:08400840084013FC10403040304057FE904010A010A011101110120814041802
+4F16:088008800880108017FE3080310051FC91441244124814501420185010881306
+4F17:0100010002800440082010102828C82608200820082014501250228841048202
+4F18:089008880888108017FE30A030A050A090A010A01120112211221222121E1400
+4F19:08400840084010401244324432485450904010A010A011101110120814041802
+4F1A:010001000280044008203018CFE6000000007FFC02000400082010103FF81008
+4F1B:08000BFC0A001208128832503250522092201250125012881308120013FE1000
+4F1C:088008800BF01090109031123112524E944010401FFE10401040104010401040
+4F1D:080008000BFC10001000300037FE50409040108010801108120417FE12021000
+4F1E:010001000280044008203018C1061110091009200100FFFE0100010001000100
+4F1F:08400840084017FE1040304033FC5040904017FE10421042104A104410401040
+4F20:08400840084013F81040308037FE5080910013F81008111010A0104010201020
+4F21:08400840084017FE108030A0312053FC90201020102017FE1020102010201020
+4F22:08000BFC0810111011103110321053FE90301050109011101210141010501020
+4F23:08000BF80A0812081248324832485248924812A812A81120112012221422181E
+4F24:08800880090011FE12003440304053FC90441044108410841104110412281410
+4F25:090009080908111011203140310057FE91401120112011101108114411821100
+4F26:0840084008A010A0111032083406511091201140118011001104110410FC1000
+4F27:0840084008A01110120834043BF2521092101210125012201204120411FC1000
+4F28:0900090009FC1204120435043884508490141024104413841104100410281010
+4F29:08800840084017FC1110311031105110911010A010A0104010A0111012081C06
+4F2A:08400A4009401140104037FC30445044908410A4109411141104120414281810
+4F2B:084008200820100013FE3202340450009000100010001000100013FE10001000
+4F2C:080009FC090411041104310431FC512491201120111011101208120814041802
+4F2D:08800840084017FE104030803108521097E0104010801108120417FE12021000
+4F2E:12001200127C22242FA464A464A4A4A824A82928251022102528294830842102
+4F2F:08400840088013FC120432043204520493FC1204120412041204120413FC1204
+4F30:084008400840104017FE30403040504093F81208120812081208120813F81208
+4F31:0840084008A010A0111032083446504091501148124812441444104011401080
+4F32:08000BFC0A041204120433FC32005240924412481270124014421442183E1000
+4F33:08480A480A481248124837FE3248524892481248127812001200120013FE1000
+4F34:08400A4409481150104037FC3040504090401FFE104010401040104010401040
+4F35:1000100017FC24A424A464A464A4A4A424A42524251C26042404240427FC2404
+4F36:0840084008A010A0111032483426502093F810081010111010A0104010201020
+4F37:104010401040204027FC64446444A444244427FC244424442444244427FC2404
+4F38:08400840084017FC14443444344457FC94441444144417FC1444104010401040
+4F39:080009F809081108110831F831085108910811F8110811081108110817FE1000
+4F3A:08000BFC0804100417F43004300453E492241224122413E41004100410141008
+4F3B:08000BF808401040124831483150504097FE1040104010401040104010401040
+4F3C:1008110810882448244864086408A40824102410241025282624244420822102
+4F3D:140014001400243C2FA464A464A4A4A424A424A424A424A428A428BC32A42100
+4F3E:08000BFC082010201040304030D0514892441444104010401040100017FE1000
+4F3F:080008000BFC1204120432043204520493FC1204100010901088110412021402
+4F40:08000BF80A0812081208320833F85200920013FC120412041204120413FC1204
+4F41:08400840088010801110320837FC5004900013F8120812081208120813F81208
+4F42:080008000BFE10201020302031205120913C1120112011201120112017FE1000
+4F43:1000100017FC2444244464446444A7FC2444244424442444244427FC24042000
+4F44:090809080908110817FE310831085108910811F8110811081108110811F81108
+4F45:08400840084013FC10403040304057FE90E01150115012481444184210401040
+4F46:080008000BFC12041204320433FC52049204120413FC12041000100017FE1000
+4F47:08400820082013FE120234043000500093FE1020102010201020102010A01040
+4F48:08400840084017FE108030A0312051FC93241524112411241134112810201020
+4F49:084008400840104013FC30403040504097FE1040108010801110120817FC1204
+4F4A:08200820082013FE12223224322053FC92841288124812501220145014881906
+4F4B:08000BFC088410841084310431145208940011FC110411041104110411FC1104
+4F4C:1120112011202522252265E46528A530252025202520252225E23E22281E2000
+4F4D:088008400840100017FC3000300852089208111011101110112010201FFE1000
+4F4E:0808083C0BE0122012203220322053FE9220121012101212120A128A13261212
+4F4F:08800840080017FC104030403040504097FC104010401040104010401FFE1000
+4F50:088008800880108017FE30803100510091FC1220122014201420182013FE1000
+4F51:084008400840104017FE30803080510093FC1504190411041104110411FC1104
+4F52:08400840084013F81248324832485248924817FE104010A010A0111012081406
+4F53:084008400840104017FC304030E050E091501150124815F41842104010401040
+4F54:084008400840107E104030403040504093FC1204120412041204120413FC1204
+4F55:0800080017FE1008200833C8524892481248124813C812481008100810281010
+4F56:1000108010402028212861086110A51425222522254229882108230824F82800
+4F57:08400820082013FE12023404310051089110112011C011021102110210FE1000
+4F58:010001000280044008203018CFE6000000007FFC010011101108210445040200
+4F59:0100010002800440082010102FE8C10601003FF8010011101108210445040200
+4F5A:104010401240224023FC62406440A0402FFE204020A020A02110220824042802
+4F5B:1120112011202FFC2124612467FCA52029202FFE21222122222A222424202820
+4F5C:09000900090011FE12803280348050F890801080108010FC1080108010801080
+4F5D:11001100120023FC2404680463E4A22422242224222423E42224200420282010
+4F5E:100013F8100020002FFE60806080AFFE21082210261021A02060209023082C04
+4F5F:0880088008F81108131034A0304050A093181C0610C010201010118010601010
+4F60:08800880088011FE110232043420502091281124122412221422102010A01040
+4F61:1040104010A020A0211062086444A84220402444244424442444244427FC2004
+4F62:08000BFE0A001200120033FC320452049204120413FC12001200120013FE1000
+4F63:100017FC14442444244467FC6444A444244427FC244424442444284428543008
+4F64:080008000FFC1100110031F0311051109190125012501210121212921312120E
+4F65:0100010002800440082010102FE8C0060210111009100920082000407FFC0000
+4F66:080008000FFE104010403080308051F893081508190811081108110811F81108
+4F67:084008400840107C10403040304057FE90401040105010481044104010401040
+4F68:0880088009FC1104120435F431145114911411F4110411281112110210FE1000
+4F69:100017FC1404240425F464446444A5F425542554255425542574244624462842
+4F6A:080008000BFC1204120432F4329452949294129412F41204120413FC12041000
+4F6B:0880088009F81208151030A0304050A093181C0613F812081208120813F81208
+4F6C:08400840084413F41048305037FE504090801184129814E018821082107E1000
+4F6D:0900090009F8131014A0304031B0564E904013FC1040144017FE104010401040
+4F6E:0840084008A011101208340633F85000900013F8120812081208120813F81208
+4F6F:0A0809080910100017FC3040304053F89040104017FE10401040104010401040
+4F70:08000BFE08201020104031FC31045104910411FC110411041104110411FC1104
+4F71:010001000280044008201010EFEE000000007FFC0100010011F811001100FFFE
+4F72:0880088008FC1104128834503020504091FC13041D0411041104110411FC1104
+4F73:084008400BFC1040104030403FFE50009040104013FC1040104010401FFE1000
+4F74:08000BFE09081108110831F83108510891F811081108111E17E8100810081008
+4F75:090408840888100013FE308830885088908817FE108810881108110812081408
+4F76:0840084008401FFE1040304037FC5000900013F8120812081208120813F81208
+4F77:08000BF80A08120813F83208320853F892441248123012201210128813061200
+4F78:081008780BC01040104037FE30405040904013F8120812081208120813F81208
+4F79:1100110013F8220824106BFE6200A2F82288228822A8229022822482247E2800
+4F7A:0840084008A011101208340633F850409040104013F810401040104017FE1000
+4F7B:089008900890149212943098309051989294149210901090111211121212140E
+4F7C:10801040104027FC200061106208A4042110211020A0204020A0211022082C06
+4F7D:102010201420227E224260846010A11021102E10222822282248224420842102
+4F7E:081009100908120814043BFA3208520893F81208120813F81208120812281210
+4F7F:104010401FFE2040204067FC6444A44427FC2040224021402080214022302C0E
+4F80:10041FC414842494249464946494AFD424942494249424942484288428943088
+4F81:10401240124023FC244068406040A7FE212021202120212022222222241E2800
+4F82:084008200BFE12001200320C32F052209220123E13E0122014221422181E1000
+4F83:100017FC14042404240467FC6000A2482248224822482248224A244A244A2806
+4F84:100017FE104020802110620867FCA0442040204027FC2040204020402FFE2000
+4F85:08400820082017FE10403084310853F090221044118816101020105011881604
+4F86:0100010001007FFC010011101110292845440380054009203118C10601000100
+4F87:1040104017FE204027FC604463FCA240244027FE204220AA20A4211022082C06
+4F88:1080108011F82210252060C06090A3202C7C2084210826902060204021802E00
+4F89:1040104017FC20A0211062086DF6A00027FC2080210023F82008200820502020
+4F8A:084008440A4411481150304037FE5090909010901090109211121112120E1400
+4F8B:1004100417C42214221463D46254A45426542554289420942104220424142808
+4F8C:01000280044009203098CFE6004000803FF800000000FFFE082010103FF80008
+4F8D:08400840084013FC1040304037FE5010901017FE101012101110111010501020
+4F8E:084008400A4811481150304037FE504090E01150115012481444184210401040
+4F8F:08400A400A4013FC14403040304057FE90E01150115012481444184210401040
+4F90:084008400880110013FC3294329452949294129412941294129412941FFE1000
+4F91:084008400FFE1080110031FC3304550499FC1104110411FC1104110411141108
+4F92:08400820082013FE12023444304053FE90881088110810D01020105010881304
+4F93:084008400BF8104817FE304833F85040904017FC104010401FFE104010401040
+4F94:084008400890110813FC30243120512091FC1220102017FE1020102010201020
+4F95:100017FC10402040208067FC64A4A4A424A424A424A424A424A4248424142408
+4F96:010002800440082037D8C00600003FF82488248824883FF82488248824A82010
+4F97:100017FC1404240425F464046404A5F425142514251425F42404240424142408
+4F98:08400820082013FE12023404303853C090401040107E17C0104010421042103E
+4F99:082808240824102017FE3020302057E0912011101110111011CA170A12061002
+4F9A:08800880090011FC1204340433E45224922413E41224122413E4100410281010
+4F9B:091009100910111013FC311031105110911017FE100011101108120814041804
+4F9C:088009000BF812081288324832485FFE92081288124812481208120814281810
+4F9D:08800840084017FE108030803140514493481530192011101108114411821100
+4F9E:090009000900111E17D232523252525292521492129211121292125E14521800
+4F9F:08400840084017FE10803080317C51089310151011FE11101110111011501120
+4FA0:08400840084017FC10403248315050409FFE10A010A011101110120814041802
+4FA1:100017FE10A020A020A067FC64A4A4A424A424A424A424A424A427FC24042000
+4FA2:08000FFC0840104013F83248324853F8924812481FFE12081208120812281210
+4FA3:100013F8120822082208620863F8A000200027FC240424042404240427FC2404
+4FA4:088008880BE8109010A037FE3080510093FC1480190011F81008100810501020
+4FA5:0880088008BC13C01050302430D4530C900017FE1090109011121112120E1400
+4FA6:08400840087E1040104033F832085248924812481248124810A0111012081404
+4FA7:100417C414442454255465546554A55425542554255421042284224424142808
+4FA8:081008780BC01040104037FE30A0511092081516111011101110121012101410
+4FA9:0840084008A011101208340631F05000900017FC104010801110120817FC1204
+4FAA:088008400FFE1208111030A0304051B0960E1110111011101110121012101410
+4FAB:088008401FFE12001200320033FC508090801FFE110812081390106011981604
+4FAC:10401040104027FC248468886140A14423482530292021102108214421822100
+4FAD:08000BF80A08120813F8322032205210920814C61420180011C0103010081000
+4FAE:0900090009FC120015F831083148512897FE11081248122813FC100810501020
+4FAF:08000BF80808100817FE3100310053F8944010401FFE104010A0111012081C06
+4FB0:08000BF80888108817FE3088308853F89100110013F815081908110811F81108
+4FB1:08000BF80A081208120833F83000500097FC1040104013F8104010401FFE1000
+4FB2:08000BFC0A00120012F83200320053FC92A012A412A812901290148814A418C2
+4FB3:084008400A4812481248355438E25040904017FC10401040104010401FFE1000
+4FB4:01000280044008203018CFE600003F04092409243F241124112417A47804200C
+4FB5:08000BF8080811F8100833F8300057FC940413F01110111010A0104011B0160E
+4FB6:080009F8090811081108310831F85040908013FC120412041204120413FC1204
+4FB7:08000BF80A08120813F83200320053FC920412F41294129414F4140418281010
+4FB8:08000FFC0800100013F8320832085208920813F810001208110811101FFE1000
+4FB9:1000100C1770211021106210627CA710211025102510227C2200250028FE3000
+4FBA:08400A480A48124813F8304030A0511092881446104013F01010102010201040
+4FBB:0A0809080910102013F832083208520893F810A010A0112011221222141E1800
+4FBC:082008200BFE1020102033FE3202540491F81010102013FE1020102010A01040
+4FBD:0BF80A480A4813F81248324833F85080908017FC108411041104120414281810
+4FBE:084008440BF41048104837FE3020504093F81110122015FE1820102010A01040
+4FBF:100017FE104027FC2444644467FCA444244427FC224021402080214022302C0E
+4FC0:0808083C0BC01044122431283100504093FE1088110813901060105011881604
+4FC1:080008F80888108812F83200320053FC9044104417FE104010A0111012081406
+4FC2:0804081E0BE01080110833F030205048918417FE102211281124122214A21040
+4FC3:08000BF80A0812081208320833F8504090401240127C12401240154018FE1000
+4FC4:102811A41724212021206FFE6120A12421A423282D2821102112212A25462282
+4FC5:085008480848104017FE304032445164916810D0115012481444104211401080
+4FC6:0840084008A01110120835F63040504097FC1040125012481444184411401080
+4FC7:08000C400ABE110812883488308850BE918812881488108810881088153E1200
+4FC8:08400A400A4013FC14403840304057FE9000100013F812081208120813F81208
+4FC9:08000FFC0880108013F83108310857FE9000100013F812081208120813F81208
+4FCA:084008400888110413FE300230885144924210F8118812501020105011881606
+4FCB:08000BF80A08120813F8300037FC54449444144417FC14001402140213FE1000
+4FCC:1048104417FE2040204067FC6444A44427FC2444244427FC2444244424542408
+4FCD:088008400BF81208120833F83208520893F81240124412281210128813061200
+4FCE:100011F811082908250845F891081108110811F8290825084508810807FE0000
+4FCF:08400A4809481150104033F83208520893F81208120813F81208120812281210
+4FD0:108411C417042114211461146FD4A11423142394255425042904210421142108
+4FD1:100017F8101021A0204067FC6444A44427FC2444244427FC2444244424542408
+4FD2:084008200BFE1202140431F83000500093FE10901090109011121112120E1400
+4FD3:08000BFC080011241248349032485124900013FC104010401040104017FE1000
+4FD4:08000BF80A08120813F83208320853F89208120813F81120112012221422181E
+4FD5:1080104017FE2402284460406040A7FC20E02150215022482444284220402040
+4FD6:100017FC1020204020D061486644A040200023F8220822082208220823F82208
+4FD7:091009080A041444104030A0311052089C0613F8120812081208120813F81208
+4FD8:0808083C0BC0100412443128300053F89010102017FE10201020102010A01040
+4FD9:1208111010E02110220860806FFEA140224027FC2A4422442254224820402040
+4FDA:100017FC1444244427FC64446444A7FC2040204027FC2040204020402FFE2000
+4FDB:0900090009F01210122037FC3A445244924413FC12A410A0112012221422181E
+4FDC:1040104017FC244427FC644467FCA0003FFE2100220023FC2004200420282010
+4FDD:08000BF80A081208120833F83040504097FC10E0115012481444184210401040
+4FDE:01000280044008203018CFE600003E0822483E4822483E48224822082A282410
+4FDF:104010801110220827FC61046100A3F8244020402FFE204020A0211022082C06
+4FE0:08400840084017FE1040324832485248955418A210A011101110120814041802
+4FE1:084008200BFE1000100031FC3000500091FC1000100011FC1104110411FC1104
+4FE2:0880088009F8131014A0304031B05E4E90801320104411881610102010C01700
+4FE3:08000BF80A08120813F83000300057FC904010401FFE104010A0111012081406
+4FE4:09080888089013FC1024302433FC5220922013FE106210A2112A122414201020
+4FE5:104010401FFE204027FC64446444A7FC2444244427FC20403FFE204020402040
+4FE6:1040104017FC204023F8608067FEA090211021FE221022902450281020502020
+4FE7:08200820082013FE10203020302051FC9040102010A41282128A128A14781000
+4FE8:08000BFC089012941198309033FE520092001200120012001200140014001800
+4FE9:10001FFE1120212021206FFC6924A92429242AA42A542C4C2884280428142808
+4FEA:10001FFE1000200027BC64A464A4A4A426B425AC24A424A424A424A424A425AC
+4FEB:08400840084017FC10403248314851509FFE10E0115011501248144418421040
+4FEC:108811C81F08210821086FD06110A3102390255425642922217E212221022100
+4FED:0840084008A010A01110320835F6500090881048124811501110102017FE1000
+4FEE:1080108011F821082A906C60A9982E2628C02B10282028C82B10206021802600
+4FEF:1040102017FE2400248864886508A57E27082548252825282908290831282110
+4FF0:100011801700211E21126FD26112A3122392235225522512291E211221002100
+4FF1:08000BF80A08120813F8320833F8520893F8120812081FFE1000111012081404
+4FF2:12101110111027D0203E62926252A452289222922112211222A224A2284A2084
+4FF3:089008900890179E109030903090539C909010901090179E1090109010901090
+4FF4:10A0109010BC27C8205060646194AE0C20A0209020BC27C82050206421942E0C
+4FF5:1040104017FC2040204063F86040A0402FFE2088215023202510294821862100
+4FF6:0900090009DC11141114311437D4501491141114158815481948111415141222
+4FF7:100017BE14AA24AA24AA67AA64AAA4AA24BE27A024A024A024A228A22AA2311E
+4FF8:084008400FFC104013F8308037FC51109248144611F0104017FC104010401040
+4FF9:08000FFE089010901090339C320452049204139C109010901090109017FE1000
+4FFA:084008800BFC11101248344633F85248924813F81248124813F810421042103E
+4FFB:0880088009F81208151030E033185C0693F81248124813F81248124813F81208
+4FFC:088008400FFE1100120837FC300453F8920813F8120813F81208120812281210
+4FFD:101010901710243E242264446790A51025102510252825282528294429443082
+4FFE:084008800BFC1224122433FC3224524493FC1090111017FE1010101010101010
+4FFF:08400840087C104013FC3244327053C09244123C120012F0149014921912120E
+5000:080009FC090011F8110031F831005FFE92801248125012201210128813061200
+5001:09000900090013DE129234923092509293F2109210921152115E122014201800
+5002:08840884090813DE110831083108510897BE1108110811081108120812081408
+5003:1110111013D8225424526A906110A2FE2C00200023F822082208220823F82208
+5004:09080890086011981644304037FE508091FC130415FC110411FC110411141108
+5005:088008400BFC10001110311032A854449000104017FE10401040104010401040
+5006:100017FC1040204027FC64446444A6642554255426EC24CC2444244424542408
+5007:1080104017FE24022A04620063BCA4A424A426A429342128222222222422281E
+5008:08400840084017FC1040324832485248955410E0115011501248144418421040
+5009:0100028004400A203118DFF610101FF010101FF010002FF8280848088FF80808
+500A:089008900908114812443492310853FC9044102010A41282128A128A14781000
+500B:100017FC1444244427FC64446444A5F425142514251425F42514240427FC2404
+500C:084008200BFE1202140431F83108510891F81100110011FC1104110411FC1104
+500D:088008400BFC100012083108311057FE9000100013FC12041204120413FC1204
+500E:08900890089013FC12943294329453FC92941294129417FE1000109011081204
+500F:1080108011F821082A906C60A9982E46285028482BFC284028A0211022082404
+5010:0840084010FC10883550542094D81706142014A414A415281450104810841302
+5011:100017BC14A424A427BC64A464A4A7BC24042404240424042404240424142408
+5012:100410041FC422142214649467D4A114211427D42114211421C42E0424142008
+5013:08400A440A44144810A0311036085044904012481248145010A0111012081C06
+5014:100017FC1404240427FC64206524A524252425FC242025242524292429FC3004
+5015:081008780BC01040104037FC324852489FFE1248124817FC1040104017FC1000
+5016:084008400FFC1040104037FE311050A097FC104010401FFE1040104010401040
+5017:100017BC14A424A424A467BC64A4A4A424A427BC24A424A424A424A42AA4314C
+5018:1040124811482150204067FC6404A40425F425142514251425F4240424142408
+5019:100013F8100828082FFE69006900ABF82C4028402FFE284028A0211022082C06
+501A:084008400BFC10A01110320837FE500893C812481248124813C8100810281010
+501B:090809080FFE1108110831F83108510891F81108110817FE1000109011081204
+501C:100017FC1444244425F464446444A7FC240425F42514251425F4240424142808
+501D:08100810FF9008107F1041107F1041107F1049100828FFA80848084408840902
+501E:088008400FFE1000100033F83208520893F81040125012481444184411401080
+501F:09100910091017FC111031103FFE500093F81208120813F81208120813F81208
+5020:09400920092013FE122036203BFC5220922013FC12201220122013FE12001200
+5021:09F80908090811F81108310831F8500093FC1204120413FC1204120413FC1204
+5022:1040104017FE204023F8604867FEA04823F820402240227C2240254024FE2800
+5023:1410121012102FA0243E644467A4A4A424A824A8249024902AA8292830442082
+5024:082008200BFE104011FC3504350455FC950415FC1504150415FC140017FE1000
+5025:08400820082013FE1202349431085204900011FC102010201020102017FE1000
+5026:10401248115027FC208061006FFEA21024082BF43212221022502224220421FC
+5027:1080104017FE2402280463F06000A00027FC2040225022482444284421402080
+5028:08000BFC0A04120413FC3220322053FE9220122012FC12841284148414FC1884
+5029:084008400FFC104013F8304037FE500093F8120813F8120813F8120812281210
+502A:080008400B9C12041204339C3204520493FC109010901090109011121212140E
+502B:1040104010A0211022086DF66000A7FC24A424A427FC24A424A424A424142408
+502C:08400840087E104013FC320433FC520493FC1244104017FE1040104010401040
+502D:08380BC00840104017FC315032485486908017FC1110121011A0106010901308
+502E:08000BF80A48124813F83248324853F8904017FC10E011501248144610401040
+502F:12081228122822282FA462446254A69227102AA02A203228224422FC22442200
+5030:1040104017FC204020406FFE6208A484288221F82208251020A0204021B02E0E
+5031:100017FC1404240427FC64046404A7FC20002420242227AC2430242225A2261E
+5032:104010401FFE2040204067FC6444A7FC244427FC24E421502248244438422040
+5033:104010401FFE204027FC644467FCA04027FC20443FFE204427FC204021402080
+5034:084008400FFE10A01150324835F650409150111017FE11101110111012101410
+5035:081008180BD41014101037FE30105090909012D012901290128A12EA17061202
+5036:08000BFC0A04120413FC320433FC5204920413FC100017FE1000110812041402
+5037:084008400FFC10A01110320835F65000900017FC104012481244144411401080
+5038:0808083C0BC01044122431283100502093FE107010A810A81124122214201020
+5039:0840084008A01110120835F63040504093F81248124813F810A0111012081406
+503A:084008400FFC104013F8304037FE500093F8120812481248124810A011101608
+503B:10001FDE14922492249467946498A49427922492249225DA2E94209020902090
+503C:084008400FFC1040104033F8320853F8920813F8120813F8120812081FFE1000
+503D:0840084008A01110120835F63040504097FC1040104013F81208120813F81208
+503E:100010FE14102420247C64446754A45424542454255426542420202820442082
+503F:088008400BFC10001108309037FE5040904017FE108811081090106011981604
+5040:1110111017FC21102150604063F8A248224822482FFE204020A0211022082406
+5041:103E17C0108424442208604067FCA444244427FC244424443FFE240424142408
+5042:09080888089017FE100033C43254525493D41254125413D412541244125412C8
+5043:08000BFE0A0012FC128432FC328452FC922013FE124812C812301248128413FE
+5044:100017FC1040208027FC64A464A4A4A42484244C20402FFE20A0211022082C06
+5045:1008103C17C020402FFE604067FCA44427FC244427FC204027FC20402FFE2000
+5046:1040104017FC204023F860806FFEA110220827FC2A0A220823F82208220823F8
+5047:100017BC14842484248467BC6400A40027BC2424242427A82410242824442482
+5048:08000BF80A0813F8120833F8310053FC9444124412A4120413F4100410281010
+5049:088008800BF8110817FE300033F8520893F8104017FC1040144017FE10401040
+504A:0804081E0BE0102011FC3124312451FC902013FE1222122A12FA1202120A1204
+504B:08000BFC0A04120413FC32003284524892FC1248124813FE1448144818881108
+504C:1108110817FE21082148604067FEA080210023FC250429042104210421FC2104
+504D:08000BF80A08120813F83208320853F8900017FE1040124012781240154018FE
+504E:08000BF80A48124813F83248324853F8900017FE124012441228129013081206
+504F:1080104017FC2404240467FC6400A40027FC26A42AA42BFC2AA42AA432A4220C
+5050:084008200BFC10001108309033FE5210922012C81210122412C8141014601980
+5051:20002FF8280848684B884888C8884BE84AA84AA84BE8488A48AA50EA57266002
+5052:08000BF80A0813F8120833F830005FFE920013FC149419241244148411281210
+5053:08000BFC0A04120413FC320033FC5240928813FC1224122015FC1420182013FE
+5054:08000BDE0A52125213DE300031FC500097FE1080110011FC1004100410281010
+5055:0A200A240BA8123012A23322325E508093FC1204120413FC1204120413FC1204
+5056:084008440BF41048105037FE3040508091F81308150811F81108110811F81108
+5057:0820082009241122122A303030C0570091FC110411FC110411FC110411FC1104
+5058:08000BF80A0812081208320833F85000900017BC14A414A414A414A417BC14A4
+5059:088008400BFC10001108309037FE5442984413FC124412441254124810401040
+505A:1210121012102FA0223E62446224AFA428A428A828A828902FA8282820442082
+505B:1008103C17C0204020406FFE6040A140265C24442444275C2444244427FC2404
+505C:1080104017FC200023F8620863F8A0002FFE280223F820402040204021402080
+505D:089008920F9C10901192368E300053FC920413FC120413FC1204120412141208
+505E:08900A900A9017FE1290329032F0520093FC104017FE10E0115012481C461040
+505F:084008800BF8120813F8320833F8500097FC1040104013F81040104017FC1000
+5060:08000BFE0850105013FE3252325253FE9000104017FE10881190106010D81304
+5061:090809080FFE110811F8310831F85108910817FE125012881304120013FC1000
+5062:13901E101210221222526FD46258A69027102AA82A2832282248224422842302
+5063:088008400FFC1000120831103FFE500093F81208120813F81208120813F81208
+5064:09080888089017FE1090309033FC52949294130C120413FC1204120413FC1204
+5065:1020102010FC2E2423FE622464FCA4202EFC222022202BFE2420262029FE3000
+5066:08000BFE08221120113C312032FE540091FC110411FC110411FC110411141108
+5067:1000108017FC211022086C8661F8A610216021A02E7E21842648203020C02F00
+5068:1120112415A82530252465A46E1CA040204027FC20E0215022482C4620402040
+5069:090009000BF8120814103BFC320453FC920413FC120413FC1000110812041402
+506A:100017FC100023F82208620863F8A00027FC2444244427FC2444244427FC2404
+506B:111011101210247C2910611062FEA6082A0822FE220822482228220822282210
+506C:1100110013FC24942B9461646254A4842128221020402124252A250A28F82000
+506D:08000FFE0840108013FC3294329452F49294129412F412941294129413FC1204
+506E:080009F80908110811F8300037FE510891F8110811F81108113E17C810081008
+506F:088008400FFE100013F832083208520893F810A4112813101510194811861100
+5070:0900093C0FD411141394311437D45124914C104017FE104010A0111012081C06
+5071:103C17E01420242027FE642065FCA504250425FC250425FC2904290431FC2104
+5072:08000BFC0A44124413FC3244324453FC9000104010241522150A190810F81000
+5073:104014441444244427FC60006FFEA040208027FC24A424A424A424A424A4240C
+5074:100217C21442245227D264526452A7D22452245227D2200222822242244A2804
+5075:1040107E1040204027FC64046404A7FC240427FC2404240427FC211022082404
+5076:100017FC1444244427FC64446444A7FC20402FFE284228522BF22912280A2804
+5077:084008A00910120815F6300033C45254925413D41254125413D41244125412C8
+5078:09C008A00910120815F6300033CA524A925413D41268125413D4124A124A12C0
+5079:0840084010FC10883550542094D8170614F814A814A814A814F810A810A810F8
+507A:091009100BD8125414523A90311052FE9C0013F81208120813F81208120813F8
+507B:0820092408A8102013FE30A831245202904017FE108811081190106011981604
+507C:08400840087E104013FC300431FC500493FC10401240127C1240154014FE1800
+507D:08400A40094017F81088309030FC5104910813FE1202142A1AAA128214141008
+507E:1040104017FC204022486FFE6208A00027FC240424442444244420B0230C2C02
+507F:08400A480950104017FE3402380451F09000100017FC10801110120817FC1204
+5080:1040108017FC2444244467FC6444A48427FC208021502164227C24422842303E
+5081:1140165C14442444275C64446444A7FC204027FC2208211020A0204021B02E0E
+5082:1004103E17E0243E242065FE6522A53825E2251E250029782A48324A248A2906
+5083:084008400FFC104013F8304037FE5080911013E0104817FC1044124815441080
+5084:104010401FFE244422A861106208AC0623F8220823F8220823F8220823F82208
+5085:085008480FFE104017FC344437FC544497FC144410081FFE1208110811281010
+5086:100017FE1420244025FC650465FCA50425FC2524242024A829242A2230A02040
+5087:090809080FFE1108100037FE310851F8910811F81108113E17C8100810081008
+5088:100017FC10A020A027FC64A464A4A7FC2040204027FC20E0215022482C462040
+5089:08000BFE0A0012FC120033FE32A8529092C81286120813FE1288144814081818
+508A:080009F80908110811F8300033FC520493FC120413FC120413FC109011081204
+508B:091009100FFC111013F8311037FC504093F8124813F8124817FE120812281210
+508C:08000BFC0A4013F8124033F83240524093FC1004155415541554140410281010
+508D:1080104017FC2208211067FE6402A884204027FC210021F82108220822282410
+508E:1040104017FC204023F8620863F8A20823F8220823F822082FFE211022082404
+508F:1040102017FE242025FC642467FEA42425FC242025FC25042504290429FC3104
+5090:1080104017FE200023F8620863F8A00027FC240425F4251425F4240424142408
+5091:1208120813BE24882AA8613E6208A448284827FC20E0215022482C4620402040
+5092:083C0FC00A4411281080311033E05040918813FC1044104017FC10A01110160E
+5093:1080104017FE2402240267FE6400A7DE24422652254A24C62B5A2842314A2084
+5094:0A080910080017FE10A037FC30A45FFE90A417FC10A011B012A81CA610A010A0
+5095:1080108017FE2522211063FC6620AA2023FC2220222023FC2220222023FE2200
+5096:0840084008A01190124837FE3A0853F8920813F8120013F81508150819F81108
+5097:088008400FFC1080110833F03060518497FE100217FC144417FC144417FC1404
+5098:01000280044008203118D116111029284544111029284544FFFE010001000100
+5099:088808880BFE1088108837FE308051FC932415FC112411FC112411241124110C
+509A:1410121012102FA0203E654464A4A8A431282528221022102528292830442082
+509B:084008200BFE120214943108326450909108120415FA11081108110811F81108
+509C:1004103E17C02244212461286200A3FC244020402FFE20402444244427FC2004
+509D:08000BF80A0813F8120833F83000500097BC108414A4129414A4108412941108
+509E:09080888089013FC104031F8304053FE9080110011FC12201420182013FE1000
+509F:092009100A081486191033F83008500097BC108414A4129414A4108412941108
+50A0:1204110411042FC4203E67846004A7A420142794248424842484278424942008
+50A1:1410120812082FBE2000608268A2A8A22492251225142114220421882E3E2400
+50A2:1080104017FC2404200063F86080A144266820B02128266820A4212226A02040
+50A3:084008400FFC104013F8308037FC511092481446124811501248144411401080
+50A4:1110111417D221102FFE62106210AFD4241429142FD4210821CA2F1A25262142
+50A5:08400A480950104017FE3402380453F89208120813F810A0112011241224141C
+50A6:080009F8090811E8112837FE340251F8910811F8110811F81108110811281110
+50A7:1080104017FE2402281463E06200A20023FC221022102FFE2000211022082404
+50A8:1020102018FA2424242861FE6020BC4024FC25442644247C25442644247C2044
+50A9:102810241740217E21C86948657EA5482248227E254825482948207E20402040
+50AA:1080111013F8221024A46FBE6042A0A023182C46219026642188263021C02E00
+50AB:100017FC144427FC244467FC6100A21027E020C823042FFE2042224825442882
+50AC:08200A220BFE1090108831FE3310551091FE1110111011FE1110111011FE1100
+50AD:102017FE142025FC242467FE6424A5FC242025FC252425FC252429FC2924312C
+50AE:08A008A00FFE10A017FC34A437FC54A497FC100013F8120813F8120813F81208
+50AF:084008800BFC124412F4331432A4524492A413FC104010241522150A190810F8
+50B0:10401444144427FC200067BC64A4A4A427BC24A424A427BC24A424A42AB43148
+50B1:11241124122424242954614A6292A6102A102250225C2250225022B0229E2300
+50B2:121012101FD022202FBE6244BFA42424242427A824A8249024A829A828443082
+50B3:10401FFE104027FC244467FC6444A7FC20422FFE20102FFE2210211021502020
+50B4:100017FC140024F82488648864F8A40025DC25542554255425DC240027FE2000
+50B5:08200BFE082011FC102033FE300051FC910411FC110411FC110411FC10881104
+50B6:10141012101027FE2410649064D2A49227F22494249425C82AAA289A31A62042
+50B7:090009FC0A0015F8110831F8310851F8900017FE110013FC14A4112412541088
+50B8:1040104017FC2040255462486554A04025542248255420A020A0211022082C06
+50B9:088008400BF8111010A037FE300053F8920813F8120813F81120112212221C1E
+50BA:090009100BDC125415543288310852F49402100013FC10401150124815441080
+50BB:084008800BFC12941264329433FC50909108128414FA11081290106011981606
+50BC:1110111017FE211021F0604063F8A24823F8204027FC20402FFE20A02110260C
+50BD:104017FC111020A02FFE600063F8A20823F8220823F820402FFE204020402040
+50BE:100011FE1010242024FC64846784A4FC248424FC2584268424FC204820842102
+50BF:100017FC1040227822406FFE6100A1FC220023FC200425542554280420282010
+50C0:12A812A817FC22A822AA64E66800A7FC2444204023F822482248224822582040
+50C1:1008103C17C02040224861506FFEA15022482C46208020442A422A1231F02000
+50C2:104013F812482FFE224863F86040A3F8224823F820802FFE211020E023182C04
+50C3:111011101FFE2110240067FC6804B7F4249427F4249427F42494249424342008
+50C4:10001FFE10A027FC24A464A467FCA00027FC20002FFE20402248244429422080
+50C5:111011101FFE211021F0604067FCA44427FC20402FFE204027FC20402FFE2000
+50C6:1020182015FE242021FC61246DFCA52425FC242025FE242024202A2031FE2000
+50C7:08000FBC088414A4129434A430505188962610C0131010641388103010C01700
+50C8:13F8120813F8220823F8600067FCA4A424A427FC200023F8211020E023182C06
+50C9:010002800440082037D8C00600003EF8228822883EF808200820145022884104
+50CA:100017FC10A027FC24A467FC6040AFFE2110220827F62A1023F02204220421FC
+50CB:084008A0091012481DF63020304053F8920813F8120813F8120813F811101208
+50CC:121012101F9022202FBE6AC46AA4AFA42AA42AA82FA822103FA8222822442282
+50CD:11C8170811082FE8211E67CA654AA7CA254A27CA210A27CA211221D22E2A2444
+50CE:100017BC14A427BC242064A4639CA000211027FC211021102FFE211022082404
+50CF:090009F00A1017FC1A24324433FC5080914416A81130166810A8112416A21040
+50D0:088808500BFE102011FC302033FE512490A817FE100011FC1104110411FC1104
+50D1:103813C0108027FE2110620865F6A91021F0200027FC240425F4251425F4240C
+50D2:1080104017FC2514220863F86088A7FE208823F8210023F82508290821F82108
+50D3:08400BF80A4813F8104037FE300053F8920813F8120813F8120813F811101208
+50D4:090808900FFE109013FC3294331C520493FC120413FC100817FE110810A81010
+50D5:10A014A412A820A027FC611060A0A7FC204023F8204027FC20A0211022082C06
+50D6:104017FC104023F8200063F86208A3F821102FFE200023F82208220823F82208
+50D7:08880AAA0ADC148811543222300053FE9242144413FC10441044108411141208
+50D8:220832482A484A90421E5FE4D0545054575455545554554857485054515450A2
+50D9:1110111017FC211021106FFE6040A7FC244427FC244427FC2000211022082404
+50DA:1040104017FC20A02514620867FCAA0A23F8220823F820402248244429442080
+50DB:1510151015102F90253E67226544A790251025102F902028252828A430442082
+50DC:102017A410A822922114620865F4A80223F82208220823F8220821102FFE2000
+50DD:17FC140417FC240025F8641067FEA4202460279C2484250829DE2F0831082318
+50DE:1004103E17C02244212863F86208A3FC220423FE240226AA2AAA2A0230142008
+50DF:124812481554275C22486554675CA2482FFE22202228222825142494242C2844
+50E0:08780FC00A48115017FC31503248540693F81248124813F81248124813F81208
+50E1:104010401FFE204027FC644467FCA44427FC20442FFE204220242522250A28F8
+50E2:103C17C010442224210867FE6402AA08220823BE24882AA8213E220824082808
+50E3:1110111017BC21102FFE611062A8A44423FA2208220823F82208220823F82208
+50E4:08000BDE0A52125213DE300031FC512491FC112411FC102013FE102010201020
+50E5:1040104017FC20402FFE611067BCA1102190263E20002FFE2120212222222C1E
+50E6:141412121F922010207E6F906890A8902F9022282B282AA83228224A2A4A2486
+50E7:09040888080013FE122232AA3272522293FE100011FC110411FC110411FC1104
+50E8:104017FC104021102FFE611063F8A20823F8220823F8220823F8211022082404
+50E9:179E1492179E2492279E640264F2A49224F2249224F224922492253224022406
+50EA:08000BFC0848103013FE305230945350902013FE1252128A1376125212721206
+50EB:08000FFE08901090139C32043204539C9090109017FE10401524150A190A10F8
+50EC:1140112013FE222026206BFC6220A22023FC2220222023FE2200252424922892
+50ED:100017BC1108252827BC631865AAA946200023F82208220823F82208220823F8
+50EE:08400BF8091010A017FC300033F8524893F8124813F8104013F8104017FE1000
+50EF:10401248115027FC215062486444A208220823BE24882AA8213E220824082808
+50F0:10101010FEFE1010FEFE929292923838545492921010111002800C603018C006
+50F1:084008200BFE1202120233FE3250524892FE139012FE129014FE149018FE1080
+50F2:100017FE10A027FC24A464A467FCA208220823BE24882AA8213E220824082808
+50F3:100017FC10A020A027FC64A464A4A7FC2248215027FC20E0215022482C462040
+50F4:100017BC14A427BC24A467BC6404A5F4251425F4251425F42514240424142408
+50F5:10001FFE100027FC244467FC6444AFFE200027FC244427FC244427FC20002FFE
+50F6:100017FC14A424A427BC60A067BCA4A424A427BC24A424A427BC24A220A2207E
+50F7:110817FE1108200024886FFE6488A4F8240027FC20402FFE215022482C462040
+50F8:1110111017BC211023B865546912A00023F8200027FC20402248244429422080
+50F9:10001FFE11202FFC29246FFC6000A7F8240827F8240827F8240827F822102408
+50FA:13F81208120823F8200067BC64A4A4A427BC20402FFE21602250244838462040
+50FB:10101008178824BE248064946788A47E2408278826BE2A882A882B8832882008
+50FC:10A010A017FC24A427FC64A467FCA00027FC200023F8220823F8211020A02FFE
+50FD:10C81708112A212C2FC861086388A55429142122204020242522250A290820F8
+50FE:083C0BC008441224110837FE344252A4928A147A108010F8110812901060179E
+50FF:1080104017FE25122BFC611067FCA11027FE2110224825F42842204027FC2000
+5100:111017FE104023FC204067FEA080272821242FFE212021A42F1A2112276E0000
+5101:1140112013FE222027FC6A2063FCA22023FE2200279E2492249224F224022406
+5102:08900BFC0A9413FC129433FC300053FC920012F8120013FE1520151415481986
+5103:10401FFE100027FC240465F46514A7FC200023F8220823F8220823F820002FFE
+5104:088008400BFC1108109037FE300053FC920413FC120413FC10401524150A18FA
+5105:10401248115027FE2402680463F8A20823F8200027FC244427FC244427FC2404
+5106:1288128817E82290241E67E46454A85427542554255427482548205422942122
+5107:08000BFC0A94129413FC300037FE500093FC120413FC10A2111413081D441182
+5108:104010A013182DF6200067FC6554A4E427FC200023F8220823F8220823F82208
+5109:1040104010A02110220865F66800A7BC24A424A427BC22102210252829443082
+510A:1110111017BC211023B865546912A00027FC2044224022782240254028FE3000
+510B:120013F8141027FE2D48762467FEA40025FC240025FC240025FC290429FC3104
+510C:121014101F9028902FBE68A46FD4A41422142FD424142788248828942A943122
+510D:082008880A5213261252328A322253FE90881144127A10881150102010D81706
+510E:111417D211102FFE21106FD06112A7D2255227D4255427C8210A2FDA21262142
+510F:108010DC128423D424486A946324AC402248215027FC20E0215022482C462040
+5110:1080104017FE24022BFC61486250A7FC220427FC2A0423FC220423FC21082204
+5111:08000BFE0A0213FE120233FE31085252939C1108125213DE100012A412521452
+5112:100017FC10402FFE284263586040A35820002FFE204027FC24A424A424A4240C
+5113:10401FFE104027FC200063F86208AFFE280227FC211023F8204027FC20402FFE
+5114:104017FC104023FC20006FFE6002A3F8204027FE200027FE200827FE24A82798
+5115:1080104017FC211020A46F586554A5522B582000220823F8220823F822082408
+5116:101017D0151027DE245067E86504A7C4200023F822A822A822A822A82FFE2000
+5117:1400157C160424A82390607C6414A7942A5022502FDC2250255024B0289E2100
+5118:08400BF8084817FE104833F8304057FE900012A4145213F812A812A81FFE1000
+5119:101014FE129222FE201061FE6000AEFE228222FE228022FE228222FE250028FE
+511A:088808880BFE108813FE325233FE500093FE124210F811081290106010C01700
+511B:1100120017FC2AA822A86FFE62A8A2A82FFE220823BE24882AA8213E22082C08
+511C:1080104017FC244422A862946474A00023F822A82FFE200027FC204021402080
+511D:1110155415B8291022A864446000A7FC2444204027FC20E0215022482C462040
+511E:100017FC124824442FFE644466ECA55426EC244426EC255426EC244424542408
+511F:0A4809500FFE140211F8310833FC520493FC120413FC120413FC110812041402
+5120:09240A480924100013FC32943264529493FC124813681248136A124A12461362
+5121:13F81248124823F82248624863F8A0002FBE2AAA2AAA2FBE2AAA2AAA2FBE28A2
+5122:1020103E102027FE242265F86422A5FE252425FC252425FC28402AA4328A247A
+5123:1040102017FE248825FC648867FEA42025FC252425FC252429FC288831042202
+5124:0BF80A080BF8120813F8311037FC51109FFE11101248155410E01150124810C0
+5125:08200BFE082011FC100033FE325253FE910411FC110411FC110411FC10881104
+5126:1080104017FC24A027FC64A467FCA400252425A8253025A4251C28002AA43452
+5127:12081FBE12082FBE2208651468A2A7FC240427FC240427FC240427FC21102208
+5128:08420B9C0A1013DE12943294342053FC920413FC120413FC120413FC11081204
+5129:10001F7C1944297C2F446944697CAF20297E29AA2F2A204A2A922922294A3104
+512A:17FC108013F8220823F862086FFEA8822548251428F4210023F8250820F02F0E
+512B:104017FE100021F8210861F86000A7FE240223F82180264421B8266821A62E60
+512C:1200123C1FA422242FBC62247FE4A03C2FA428A42FBC28902F9828A828AA29C6
+512D:1400123C1FA4202428BC65246FA4A23C22242FA4223C2B102A9832A82A2A2446
+512E:100017FE14442598248867DE6488A5DC26AA248824202520253C2920292037FE
+512F:1248115017FC20802FFE620867FCAA4223F8224023F8224023FC200425542008
+5130:11101FFE1110203C2FC064886250A7F8240827FC240427FE28022AAA32AA2004
+5131:142012201FBE2520223E7F82603EAFA028BE2FA028BE2FA028BE28A028A2299E
+5132:14101210127A2F1220146F7E6008AF10203C2F6429A4293C29242F24293C2024
+5133:09F00A100FFC120413FC322433B8522291FE121017FC124413FC10D0114A163E
+5134:104017FC100023B822A863B86110A7FC211027FC21102FFE212823102D482186
+5135:108011F812882070238E680069FCA92429AC292429FC282029FC202023FE2154
+5136:0A220BFE089011FE131035FE311051FE911011FE110013FE128A137612521276
+5137:17BE100017BC24A426B464A46040A7FE24A027FC24A427FC251229DC291231CE
+5138:100017FC14A424A427FC621062A8A4BE2F68223C24A82FBC20282AA82ABE2020
+5139:152817BE194827BE231865AA6946A3FC220423FC220423FC220423FC21082204
+513A:151815141F90253E272862686FBEAAA82FA8223E2FA822283FE8253E28A03060
+513B:1248115017FC240421F0611067FCA55424E427FC204027FC20402FFE22A42452
+513C:17BC14A417BC200027FE64006590A49E27D4256425D4255425D425682BC83054
+513D:17FC144417FC24442FFE6AAA6FBEAAAA2FBE222027C020842FFE204225482884
+513E:104017FC124823F820406FFE6AAAA3B8211027FC21102FFE212823102D482186
+513F:08400840084008400840084008400840084008400840104210422042403E8000
+5140:00000000FFFE08400840084008400840084008400840104410442044403C8000
+5141:0100010002000440082010103FF804480440044004400840084210422042C03E
+5142:0100010001007FFC01001100110021003FFE02800480048008841084207CC000
+5143:00003FF8000000000000FFFE04400440044004400840084210422042403E8000
+5144:00003FF8200820082008200820083FF80440044004400840084010422042C03E
+5145:02000100FFFE04000400082010103FF80448044004400440084408441044603C
+5146:04400440444424481450144004600C50144824444440084208421042203E4000
+5147:08202448228821082288244828283FF80440044004400440084408441044603C
+5148:0100110011001FF8210041000100FFFE044004400440084008421042203EC000
+5149:010021081108091009200100FFFE0440044004400440084208421042203EC000
+514A:04400440082011102108C206044008201FF0045004400440084408441044603C
+514B:01000100FFFE010001003FF82008200820083FF804400440084010422042C03E
+514C:04400440082010102008DFF61010101010101FF004400440044008441044603C
+514D:080008000FE0102020407FF8A108210821083FF822880480088010822082C07E
+514E:000801FC7F00010001003FF82108210821083FF8228804A0089010922082C07E
+514F:001000F81F80108010F81080108010801FFE11201120112022222222441E9800
+5150:000023F82208220823F82208220823F82208000004400440044008441044603C
+5151:10100820044000001FF01010101010101FF0145004400440084408441044603C
+5152:0000060038F8200820083CF8200820083FF8044004400440084408441044603C
+5153:00007EFE081008104890489048907EFE08100810142814282548264A448A8106
+5154:080008000FE0102020407FF8A108210821083FF8228804A0089010922082C07E
+5155:00003C7824482448244827C8200820083FF8244804400440084010422042C03E
+5156:02000100FFFE082011102208444408201FF0045004400840084010422042C03E
+5157:02000100FFFE0820101020085FF41010101010101FF00440044008441044603C
+5158:00207C200048008401FEFE02240024FC2484248424FC24842402440243FE8000
+5159:08100810FF10081008107F7E411041107F101410141014102412240243FE8000
+515A:01001110091009207FFE400280041FF0101010101FF00440044008423042C03E
+515B:0808081CFF70081008107F1041FE41107F101410141014102412240243FE8000
+515C:0100120067DC4444444447C44444444457C4601C04400440044008441044603C
+515D:08080828FF24084408427F80417C41247F24144414441494250A240243FE8000
+515E:083808E0FF20083808E07F20413C41E07F2414241424141C2402240243FE8000
+515F:0810285028503E7C4890081008107EFE1428142814281428254A264A44868100
+5160:0100121017D2F454145817D014523452D7CE100004400440044008441044603C
+5161:080008FEFF100820087C7F444144417C7F441444147C14442402240243FE8000
+5162:0820082008207EFE082008207EFC428442847EFC14501450255026924492810E
+5163:100011FEFD00117C11547D7C4554457C7D10297C29102AFE2C00480247FE8000
+5164:101011FE9528557C592811FEFD10297C2954297C29542A7C2A284C44480287FE
+5165:0400020001000100010002800280028004400440082008201010201040088006
+5166:040042004100410040804080414041404220422044104808500440007FFE0000
+5167:0400020002007FFC410441044284428444444824501440044004400440144008
+5168:0100010002800440082010102FE8C106010001001FF00100010001007FFC0000
+5169:0000FFFE0100010001007FFC4104514449244924555465944104410441144008
+516A:0600010002800C603018CFE600003E24222422483E4822903E48224822242624
+516B:0000004004400440044004400440042008200820081010101008200820044002
+516C:00800480048008400840102020104208820604000440082010203FF010100000
+516D:02000100008000800000FFFE0000000004400420081008081008200440040000
+516E:044004400820082010102008DFF6040008000FE0002000200020002001400080
+516F:201010100820084000007FF80208020802080208022802100200020002000200
+5170:101008100420044000007FFC0000000000003FF80000000000000000FFFE0000
+5171:04200420042004203FFC042004200420042004207FFE00000420081010082004
+5172:00007FFC010001003FF801000100FFFE0000044004400820082010102008C006
+5173:10100810082000003FF8010001000100FFFE010002800280044008203018C006
+5174:0408020821081110081008200040FFFE00000440042008100808100820044004
+5175:002000F01F00100010001FF81080108010801080FFFE00000840102020104008
+5176:082008207FFC082008200FE0082008200FE008200820FFFE0000082010102008
+5177:00001FF0101010101FF010101FF010101FF010101010FFFE0440082010102008
+5178:0440044004403FF82448244824483FF8244824482448FFFE0440082010102008
+5179:082004200440FFFE1020102020402448448878F008101020142822447EFC0204
+517A:0440082010102FE8C4260420082010A0604000003E442258226022423E42223E
+517B:0820044002887FFC01003FF80200FFFE04400830344EC4440440044008401040
+517C:102008407FFC048004803FF00490FFFE04903FF00CC014A02498C48604800480
+517D:082004403FF821083FF821083FF80000FFFE00001FF01010101010101FF01010
+517E:082004403FF821083FF821083FF8000008207FFC08200820FFFE082010102008
+517F:08100420FFFE08203EF808283EAA0866389200001FF000007FFC040008101FF8
+5180:04447C7804421C3EE4003FF821083FF821083FF804403FF80440FFFE10102008
+5181:440025FE29027D0255FE55247D24557E55247D2411FE1152FD54124812641442
+5182:00007FFC40044004400440044004400440044004400440044004400440144008
+5183:00007FFC4004400440045FF44004400440045FF4400440044004400440144008
+5184:00003FF8200820082008FFFE200820082008FFFE200820082008200820282010
+5185:0100010001007FFC410441044104428442444424481450144004400440144008
+5186:00007FFC410441044104410441047FFC40044004400440044004400440144008
+5187:02000200FFFE040004000FF00810181028104810881008100810081008500820
+5188:00007FFC40044004400448244444428441044284444448244004400440144008
+5189:0100010001003FF8210821083FF8210821082108FFFE20082008200820282010
+518A:00003FF824482448244824482448FFFE24482448244824482448240820282010
+518B:00007FFC40044004400447C4444444444444444447C444444004400440144008
+518C:00001E7812481248124812481248FFFE12481248124812481248128826A84110
+518D:0000FFFE010001003FF8210821083FF821082108FFFE20082008200820282010
+518E:00001FF0101010101F90109010907FFC40044004400440044004400440144008
+518F:00007FFC400444444824501467CC444444444444444447C44444400440144008
+5190:00003FF820082FE820082FE800001FF010101FF010101FF01010101010501020
+5191:010001003FF821083FF821083FF800001FF0101017D0101017D0101010501020
+5192:00003FF820082FE820082FE8200800001FF010101FF010101FF010101FF01010
+5193:082008207FFC08203FF80820FFFE01003FF821083FF82108FFFE200820282010
+5194:00003FF820082FE820082FE800007DFC4420442047FE44207C20442000A00040
+5195:7FFC40045FF440045FF404000FE010203FF8510811081FF8028004821882607E
+5196:00007FFE40028004000000000000000000000000000000000000000000000000
+5197:000000007FFE4002800400000FC00840084008400840104210422042403E8000
+5198:0100010001003FFC2104410801000280028002800480048008841084207C4000
+5199:00007FFE4002900410001FF8100020003FF800080008FFC80008000800500020
+519A:000000007FFE400281040100010021082108210821082108210821083FF80008
+519B:00007FFE4002820402003FF80400090011003FF801000100FFFE010001000100
+519C:0100010001007FFC4204820805000508089018A02840482088100A080C060800
+519D:00007FFE400280041FF0101010101FF0101010101FF0101010101010FFFE0000
+519E:00007FFE4002810411100920054001007FFC0540092011102108C10601000100
+519F:00007FFE410282041FF010101FF010101FF0000010F01F00100410040FFC0000
+51A0:00007FFE400280043E08000800FE7E08144814281408142A2412240243FE8000
+51A1:00007FFE40029FF400007FFC02000D08719002A00CC071A006981886E2800100
+51A2:00007FFE400280047FFC0200060819106AA004C01BA062980C863080C2800100
+51A3:00007FFE400280047F0022FC22443E44224422283E2822102790FA2842440282
+51A4:00007FFE400288040FE0102020405FF8110811081FF8028004A008921082607E
+51A5:00007FFE400280041FF010101FF010101FF012100100FFFE0000082010102008
+51A6:000000007FFE400280243E38002000207EF814081450142014542484240443FC
+51A7:00007FFE400280040820082008207EFC08201C301A702A6848A4892208200820
+51A8:00007FFE400280043FF800001FF010101FF000003FF821083FF821083FF82008
+51A9:00007FFE400282041CF010101EF010101FF008001FFC20044924249424944008
+51AA:FFFE84423FF804401FF010101FF010101FF002007FFC09203FF8D11611300100
+51AB:000040002000200000000800080010001000E000200020002000200020000000
+51AC:040004000FF010102820444003800C603018C006070000C000200E0001800040
+51AD:010001000100FFFE02800440082010102608C186004000000C00030000C00020
+51AE:0000400027FC204000400840084010401040E0402040204020402FFE20000000
+51AF:000047F02010201002100A100A1013FC1004E004200427F42004200420280010
+51B0:004040402040204400680770116011502150E248224824442842204021400080
+51B1:000047FE20802080008008F80908110811082208E3F820102010201027FE0000
+51B2:004040402040204007FC0444144414442444E44427FC24442040204020400040
+51B3:00804080208027F800880088108810882FFEE080214021402220241028081006
+51B4:000043FC20102110011009100A1013FE1030E050209021102210241020500020
+51B5:000047F8240824080408040817F811202120E1202120222022222422281E1000
+51B6:0040404020802110020807FC1004100023F8E208220822082208220823F80208
+51B7:0040404020A020A0011002481426102023F8E0082010211020A0204020200020
+51B8:0040424421482150004007FC104010402040EFFE204020402040204020400040
+51B9:009040882088208007FE0080110011FC2144E244224824502420285020880306
+51BA:000043FC2204220402040BFC0A20122013FEE220222022102212228A23060202
+51BB:00404040204027FE008009200920122013FCE020212821242222242220A00040
+51BC:00404240224023FC04400040104017FE2120E1202120212022222222241E0800
+51BD:000440042FC42224022403A412A414A426A4E5A4292421242204220424140808
+51BE:0040404020A021100208140613F81000200023F8E20822082208220823F80208
+51BF:0040404023F8204807FE004813F810402040E7FC204020402FFE204020400040
+51C0:0100410023F02410002017FC104410442FFE2044E04427FC2044204021400080
+51C1:004040402FFE2040004007FC1444144427FCE04020E0215022482C4620400040
+51C2:0100410021F02210022007FC1A4412442244E3FC22A420A0212022222422081E
+51C3:0040404020A02110020805F61040104027FCE040225022482444284421400080
+51C4:0040404027FC204003F8004817FE104823F8E08027FE21082390206021980604
+51C5:000047FC2444244407FC0444144415F42514E514251425F42514240427FC0404
+51C6:01404120212023FE022016201BFC1220222023FCE2202220222023FE22000200
+51C7:02084228222822280FA40244125416922710EAA02A203228224422FC22440200
+51C8:003C47C02244212800000BF80848104817FEE048204823F82048204021400080
+51C9:008040402FFE2000000003F81208120823F8E040225022482444284421400080
+51CA:0040404027FC204003F8104017FE100023F82208E3F8220823F8220822280210
+51CB:000047FC2444244405F40444144417FC2404E5F42514251425F4240424140808
+51CC:0040404023F82040004007FE111012882484E1F0231024A0204020A023100C0C
+51CD:0040404027FC204003F80A480BF8124813F8E04020E0215022482C4620400040
+51CE:0040404020A021100208040611F010402040E3F820402248214821502FFE0000
+51CF:00144012201027FE0410041015D014122412E5D42554254825DA242A28461082
+51D0:000047FC20A020A007FC04A414A414A427FCE040204027FC204020402FFE0000
+51D1:0040404027FC204003F8008017FC11102208E5F6204023F8204020A021100608
+51D2:004042482248224803F8000017FC100023F8E208220823F8211020A027FE0000
+51D3:000047FC20A020A007FC04A414A417FC2040E04027FC20E0215022482C460040
+51D4:0040404020A02190024817FE1A0813F8220823F8E20023F82508250829F80108
+51D5:000047FC2404200003F80A080BF8120813F8E080204027FC2000211022080404
+51D6:4140212003FE0A2017FCEA2023FC222023FE02000100FFFE0100010001000100
+51D7:0040444427FC2120011003FE122016202BFCE220222023FC2220222023FE0200
+51D8:04804482249C2FD004900790149E17942494E4942FD42014251428A430240044
+51D9:000047FC24A427FC004003F8104017FC2110E0A023F820402FFE204020400040
+51DA:0110411027BC211003B805541912100023F8E00027FC20402248244429420080
+51DB:00404FFE200027FC040405F4151415F42404E7FC200023F820002FFE224804C4
+51DC:00404FFE200027FC040405F4151415F42404E7FC200823F020402FFE21500E4E
+51DD:0400457C260424A80390107C141417942A502250EFDC2250255024B0289E0100
+51DE:08008BDE4A924A920BD22A5E2A502BD04A92CA924BCE50004000452444920892
+51DF:00404FFE204027FC000007FC14A417FC2208E3F8220823F8220823F821100208
+51E0:00000FE0082008200820082008200820082008201020102220222022401E8000
+51E1:00000FE00820082008200A20092008A008A008201020102220222022401E8000
+51E2:0200020004001FE01020102010201020102010201020102220222022401E8000
+51E3:02000200020002001FE0102010201020102010201020102220222022401E8000
+51E4:00003FF8200820082FC8204828482488228821082288244A284A400A40068002
+51E5:00003FFC200420043FFC2000200023E02220222022202220242244224822901E
+51E6:100010F010901E901290229022905290949414940894090C1400230040FE8000
+51E7:00003FF820082108210821082FE829282928292829A8294A210A410A41068002
+51E8:00003FF8200820082FC8200820083FE82208248828483FEA282A400A40068002
+51E9:00003FF820082108210821082FE82108238823482528252A290A510A41068002
+51EA:00003FF820082088208820882088248824E824882488248A248A5FFA40068002
+51EB:020004003FE02020242022A020403FF800081F8810A8109010822082407E8000
+51EC:00003FF8200820082FE82008200827C82448244827C8244A244A47CA44468002
+51ED:08380BC01040304057FE90401040104013F800000FE00820082010222022C01E
+51EE:00003FF8200820082FE82108220827C82448244827C8244A244A47CA44468002
+51EF:100092F092909290FE900090FE90029002907E904090409246925912610E0200
+51F0:00003FF8220827C8244827C8244827C820082FE8210827CA210A4FEA40068002
+51F1:0800490049787F480048FF4800487F48414841487F484248244A0F4AF08A4106
+51F2:00003FF8244822883FF822882FE822A83FF822A82FE8228A26CA4AAA52968282
+51F3:00907EA004442BA810102FE8C8260FE004407FFC00000FE0082008221022601E
+51F4:000043FC22400BF80A4013F82240E3FC2004255420080FE0082008221022601E
+51F5:000000000000000040044004400440044004400440044004400440047FFC0004
+51F6:000000101010082044444284410442844444482450146014400440047FFC0004
+51F7:01000100010001004FE4410441044104410441045FF44004400440047FFC0004
+51F8:00000FE008200820082008200820783C4004400440044004400440047FFC4004
+51F9:00007C7C444444444444444444444444444447C440044004400440047FFC4004
+51FA:0100010021082108210821083FF801080100010041044104410441047FFC0004
+51FB:0100010001003FF8010001000100FFFE0100010021082108210821083FF80008
+51FC:01000100010001105D244544458449444924511461144504420440047FFC0004
+51FD:00003FF00020004051944924454441044544492451144504420440047FFC0004
+51FE:00003FF00020004041845D745594555455245D5441944504420440047FFC0004
+51FF:0440244814500440FFFE0000044022882FE8210821082FE8210821083FF80008
+5200:000000003FF80208020802080208020802080408040808080808100820504020
+5201:00003FF800080008000800480088010802080408080810086008000800500020
+5202:0004000400040044004400440044004400440044004400040004000400140008
+5203:00003FF802080208020822082208220842080208040804080808080810506020
+5204:00007FF004100410241014100C100410061005900870081E1010101020A0C040
+5205:00007FE00420042004200420242824244422842208200820102010202140C080
+5206:00400440042008201010200840049FE204200420042008200820102021404080
+5207:1000100011FC104410441E44F044104410441244144418841084010402280410
+5208:000401040104212411240A240A24042404240A240A2411242104400480140008
+5209:1004100420043FA4402480243F2402240424082410242024408440843F940008
+520A:00047F0408040824082408240824FFA408240824082408240804080408140808
+520B:0004070478040824082408240824FFA408240824102410242004200440148008
+520C:0404040404040424FFA404240424042444242424242404240404040414140808
+520D:040004000FF0101020204040BFF80008000800081FF80008000800083FF80008
+520E:2004200420043FA454A494A414A424A424A448A488A410A42084408485140208
+520F:200420043F84402480243F24002400247F240124012401240144014400D40048
+5210:00043F04210421242924252425242124FFE42124212421242104410445148208
+5211:00047F8412041224122412241224FFE412241224122412242204220442148208
+5212:100414041204102413A4FC2410241124112412240C2408A414842284C1940088
+5213:00043F04000400240024FFA41224122412241224122422A42304420480140008
+5214:0804080408047F240924092409240924FFE40824082414241204210441148008
+5215:00003FF80208020804080850302000007EFC122412241224224422444A948508
+5216:00043F042104212421243F242124212421243F24212421242104410445148208
+5217:00047F84080408241F2411242124212452248A24042404240804100420144008
+5218:100408040804FFA4022442242224142414240824082414242404420482140008
+5219:00047F0441044124492449244924492449244924492414241204210440948088
+521A:00047F0441044124652455245524492449245524552465244104410445144208
+521B:0804080414041224212440A4BE242224222422242A242424208420841F940008
+521C:1202120212027F82129212927F92521252127FD21252125223422282420A8204
+521D:2000100001FCFC44084410441044344458449444144410841084110412281410
+521E:00043F042104212421243F24212421243F242124212421242784F80440140008
+521F:00047F041104112421242524422480243F2421242124212421043F0421140008
+5220:00027BC24A424A4A4A4A4A4A4A4AFFEA4A4A4A4A4A4A4A4A4A425A42854A0884
+5221:00027F824082408240927F92441244127FD24412441242124242514260CA4044
+5222:0804080414041224212448A4842404247F240124222414240804040404140008
+5223:0804080408041024122421247FA420A400243F2421242124210421043F142108
+5224:040444842484252404247FA4042404240424FFE4042408240804100420144008
+5225:00047F044104412441247F240024102410241F2411241124210421044A148408
+5226:0804080408047F24082408240824FFA408241024102422244104FF8440940008
+5227:0800080008FC7F24082408240824FFA41024102424244224FF44414400940108
+5228:100410043F0421244124BD24252425243D24212425242224208420841F940008
+5229:010407847C04042404240424FFA40C241624152424A424244404840404140408
+522A:00047F0455045524552455245524FFA455245524552455245504510445144208
+522B:00047F044104412441247F2410241024FF24112411241124210421044A148408
+522C:14041204100417247824102417A4F824112412240C2408A414842284C1940088
+522D:00047F04020404240C2412242124C0A400247F240824082408040F04F0144008
+522E:02040F04780408240824FFA40824082408247F2441244124410441047F144108
+522F:00047F84000400243F24212421243F24212421243F24212400040784F8144008
+5230:0004FF840804102422244124FFA408A4082408247F24082408040F84F8144008
+5231:2400240025F824487E482448254C254AFE4A2448244824482448448844A88510
+5232:080408047F04082408240824FFA40024082408247F24082408040F04F0144008
+5233:08040804FF84142422244124BEA40024FFA4102420247F24010401040A140408
+5234:00047F041104122423A420A44AA489240824FFA418242C242A04490488940808
+5235:0004FF84220422243E24222422243E242224222427A4FA244204020402140208
+5236:0404240424043FA444240424FFE4042404243FA424A424A42684250404140408
+5237:00023FC2204220423FD22212221222123FD252525252525293421282020A0204
+5238:0100111009203FF8020002007FFC082010102FE8C42604200820082011402080
+5239:01046204140408241424222449240824FFA408242A2429244884888428141008
+523A:08040804FF84082408247F24492449244D244A241C242A244904888408140808
+523B:100408040004FFA40824112421247E240424092412242424CC0412042114C088
+523C:1000100010FC7E24102410A410A4FEA410A41124202428244444FE4442940108
+523D:08040804140422244124BEA400240024FFA41024102422244104FF0441140008
+523E:080408040804FFA40824492429242A24FFA40824082414241204210441148008
+523F:08044904490449247F24102410243F244124A12412241424080410042014C008
+5240:08044904490449247F2400247F24012401243F242024202423042C0430140008
+5241:00043E0422042224222449A488240824FFA408241C242A244904888408140808
+5242:10040804FF840224642418242624C12422A42224222422242204420442148208
+5243:420422042404FF2409240924FF2488248824FFA418A428A44A84890408140808
+5244:00047F84000424A449249224492424A400247FA40824082408040B84FC140008
+5245:00047F84000400243F242124212421243F240024212411241204078478142008
+5246:080404043F04212421243F24212421243F242024242422242504290430142008
+5247:00047F04410441247F24412441247F24412441247F2400242204210440948088
+5248:00043F04210421243F2400247FA440A440A47FA440A440A47F84408442944108
+5249:080408042A042A242A245D2488A4082408247F240824082408040F84F8144008
+524A:0804490429042A2408247F24412441247F24412441247F244104410445144208
+524B:08080808FF48084808487F48414841487F481448140814282412240243FE8000
+524C:08040804FF84082408247F24492449247F2408241C242A244904880408140808
+524D:101008100820FFFE00003E08224822483E48224822483E48220822082A282410
+524E:02046404180416242124CA2409240824FFA418241C242A242904488488940808
+524F:4200240000FC7E24242424A424A424A4FEA42524242424242444444444948508
+5250:00047F044104412441247F2408240824FFA488A494A4A2A4C284808482948108
+5251:0804080414041224212440A4BE24002411240924492422242204078478142008
+5252:1204120412047F2412241224FFA400243F24212421243F24210421043F142108
+5253:0C80708011FCFD2432243844548491041228101000007FF80408080810506020
+5254:00043F04210421243F24212421243F2410243FA44AA492A42484488412942108
+5255:120212021202F3C21212121212127392121212121212F3D212021202120A1204
+5256:100408047F84002421241224FFE4002400243F242124212421043F0421140008
+5257:240422042F04F024142409243524CB2424242F24F0241224140409043514C308
+5258:22042204FF84222422243E24222422243E2422242224FFA40004220441148088
+5259:4200240001F87E4824482448254C254AFE4A2448244824482448448844A88510
+525A:04020402FFC204023F9224923F9204123F920492FFD204923F820402140A0804
+525B:00027FC2404251424A527FD2445244525552555255525F5240424042414A4084
+525C:080404047F8440A420243BA42AA42AA42AA45AA44BA48A241204128423144208
+525D:20043E0442047C240424FFA40824092449242A241C242A24C904090428141008
+525E:080408047F84142422244124FFE4012479244924492449247904010405140208
+525F:00047B8408842AA411242AA444A4882400247BA408A42AA411042A8444948808
+5260:10040804FF84002400247F244124412441247F2408242A244904888428141008
+5261:0804090449044A2488241424222449248824492449248A241404220441148088
+5262:0004FF84080410242824C4A40D2456242524D5240CA414A42404C40414140808
+5263:08040804140422244124BEA4082408247F24492449247F240804140422144108
+5264:10040804FF840224642418242624C12422A43E24222422243E04420442148208
+5265:00047E0402043E240224FFA40824092449242A241C242A24C904090428141008
+5266:08040804FF8414242224492488A47F2449247F2449247F2408040A040C140808
+5267:00043F84208420A43FA4242424243FA4242424243FA450A4508490841F941088
+5268:08040804FF8408247F240824FFA40824FFA4102420247F24A10421043F142108
+5269:070278020802FF822A122A92EB122A926A92A9921C122A1249028882080A0804
+526A:0820FFFE00003E0822483E4822483E482208261800007FF80408080810506020
+526B:040202023FE2248224923FF22492279220122FD22052249222824102468A9844
+526C:08044904490449247F240024FFA4082410247F24552455245504550455144308
+526D:00043F84208420A43FA420243FA4242429242FA422242FA4220443845E148808
+526E:00047F0441044124792449244924FFA480A4BEA4A2A4A2A4BE84808482948108
+526F:00027FC200023F82209220923F9200127FD2445244527FD2444244427FCA4044
+5270:03823C0204027FC215121512FFD2151215127FD20E12151224824442840A0404
+5271:08000800147E22124112BED2085208527F52499249127F1208221422224A4184
+5272:10040804FF8480A409247F2408247F240824FFA408247F24410441047F144108
+5273:22042204FF8422240824142422244124BEA4002400247F24410441047F144108
+5274:0804490449047F240024FF2400247F24412441247F24422424040F04F0144008
+5275:08040C041204292444A4BF2421243F2421243F2420243F24510451049F141108
+5276:20043F0441047E240224FFA4102428A4CD2416242524CD2414842484D4140808
+5277:080404043F8411240A243FA422242A242FA4322422242FA42204420443949C08
+5278:0804FF8408047F2449247F2449247F2408A4FFA40224FFA4420422040A140408
+5279:0004770411045524332455240C243324C4A4182462240CA4710406041814E008
+527A:082008207E7E08C4FF281C102A2848C600003FFE20002FF82208420844289810
+527B:0202222222223FEA000A3DEA252A252A3DEA252A252A3DEA2522252255AA8A44
+527C:100422047F04422494A4F7A408243624C92430A4C424192462040C043014C008
+527D:0002FFE20A027FC24A524A527FD200127FD20012FFF2041224824442942A0804
+527E:00027FC240024F82489248924F9240125DD25552555255525DC240027FEA0004
+527F:49049204490400247F2449247F2449247F240824FFA41C242A04490488140808
+5280:00047F0412040C24FFA414A42524D4240824FFA494A4A2A4DD8494849C948188
+5281:120211023FC222026212BFD2221222123FD2221222123FD2200254824A4A8A44
+5282:00027FF24002514A4A4A5F7A449A442A550A554A5F4A444A44A248A2492A9204
+5283:08047F040904FFA409247F240824FFA400247F2449247F2449047F040014FF88
+5284:420442047BC44524A8A4142422244124BEA4002400247F24410441047F144108
+5285:00047F04550455247F2420247FA490A47CA454A454A47CA41284FE8402940108
+5286:02023FF22882250A3FEA250A2FCA254A3FEA254A2FCA250A2D825542652A8504
+5287:08040F0408047FA448A47E244924472440247FA4482455244A04B7040A943608
+5288:00407C2045FC44887C5043FE7C20A5FC24203C2000007FF80408080810506020
+5289:080277C252424A42555264920A1211123F92C4523F120492250217C27C0A2004
+528A:04020B0230C2DF2200127FD255524E527FD200123F9220923F8220823F8A2084
+528B:00047F0441047F240024F7A494A4F7A408240824FFA41C242A04490488940808
+528C:020213C212027FEA010A014A3FEA210A3F0A254A254A2D4A368244A2896A3224
+528D:08040804140422244124BEA40024002477245524552477242204220455148888
+528E:0800080014FC22244124BE240024002477245524552477242244224455948908
+528F:080449042A04FFA480A43E24222422243E2400247F2449247F0449047F144108
+5290:11027FC2150212023FD26412BF9224123F9224123FD220127F8211020E0A7184
+5291:080204027FC211020A52F59255525532B592001220923F9220823F82208A4084
+5292:08000800147E22124112BE5200520052775255925512771222222222554A8884
+5293:08023F8220823F8220923F9200127FD244527FD244527FD20002FFE2110A2104
+5294:08000800147C22244124BE2400A4006477245534552C7726222422245544888C
+5295:0844738442047BE452A452A484247FA440A47FA440A47FA440847F8421144088
+5296:3E024202FF8240827F924492771244523FD24212FF9248927F821A02294AC7C4
+5297:52827BE294827BEA318A5AAA946A3FCA204A3FCA204A3FCA20423FC2108A2044
+5298:02023FF224823FEA248A2ECA35AA248A250A3DEA250A3DCA25025DE2450A8504
+5299:1F0221023E0202027FD2189265121A9266521A122492FBF2AAA2FBE228AAFBE4
+529A:7FC240427FC252424A9252525FD255525FD264525F5255525F424442BF4A0084
+529B:02000200020002007FF802080208020802080408040808080808108820504020
+529C:1020102010201020FF201120112011201120112021202122212241224A1E8400
+529D:004000400040FC4005FC04444844284410441084288424844504810402280410
+529E:02000200020002007FF002100210121812142412441208100810101020A04040
+529F:004000400040FE4011FC1044104410441044108410841E84F104410402280410
+52A0:100010001000107CFE4412441244124412441244124412442244227C4A448400
+52A1:040004000FF0182024C003000CC03230C20E1FF0021004100410081010A02040
+52A2:00200020FF20202020FC20243E24222422242224222422244244424494A80910
+52A3:0100111011082124414401800E00F10001003FF8020802080408080810506020
+52A4:022007203820202020FC20243F24242424242424242424442444448445288210
+52A5:102008200820FF2000FC00243C24242424242424242425444644448481280210
+52A6:020002003FF00410081010A06040102010207EFC12241224224422444A948508
+52A7:04200E207820082008FC7E24082408240824FF24082408440844088429281210
+52A8:004000407C40004001FC0044FE4420442044208448844484FD04450402280410
+52A9:00207C204420442044FC7C24442444247C244424442444444E44F08401280210
+52AA:10001000FEFC22844488285010202858C586020002007FF80408080810506020
+52AB:0820082008207E2008FC08240824FF241024102420244444FE44428401280210
+52AC:2020202020207E2042FC82247A244A244A244A247A244A440244028415280A10
+52AD:00207E201220122022FC2A24442480243E2422242224222422443E4422A80110
+52AE:08200820482048207EFC482488240824FF240824082414442244428481280210
+52AF:00200020FF20102010FC10243E2422246224A224222422443E44228401280210
+52B0:1020102020207E2042FC4224422442247E2442244224422442447E4442A80110
+52B1:00107FD0401040105F7E481248124F12491249124912491249125122952A2244
+52B2:00207E200420082018FC24244224812400247E240824084408440E84F1284210
+52B3:08200820FFFE082000007FFE420282043FF00210021004100410081010A02040
+52B4:22081108111000207FFE4002820402007FF80208020804080408080810506020
+52B5:0100111009203FF8020002007FFC082012102208DFF604100410081010A02040
+52B6:04200E207020402040FC7F24402440245E2452245224522452449E4492A80110
+52B7:2220122014207F2008FC08243E24082408247F24082408441044108421284210
+52B8:082008207F20082008FC0824FFA40024082408247F24082408440F44F0A84110
+52B9:102008200020FF2000FC24244224812424241424082414442244428481280210
+52BA:101010102410427EFF120912481248127F1288220822FFA20842084208940908
+52BB:00107F904010407E7F92441244125F12441244227FA2402240427FC200940108
+52BC:082008200820FF2008FC08247E24002400247E244224422442447E4442A80110
+52BD:7F84082410243F2451240A24040408043014C20802007FF80408080810506020
+52BE:102008200820FF2008FC102422247C24092412242424C82414442244C0A80110
+52BF:084008407DF808480C4819C8684A08AA2886130202007FF80408080810506020
+52C0:0820082008207F2008FC08247F24412441247F24142414242544264444A88110
+52C1:00207F20002025204AFC9224492424A400247F240824082408440F44F8A80110
+52C2:0820282028203E2048FC0824FF24002400243E242224222422443E4422A80110
+52C3:082008207F20082008FC7F24412482243C24042408240F447844088429281210
+52C4:201020103F904010BF7E211229122512FFD22112491245127F9201220A2A0444
+52C5:08200820FFA0082008FC7F24492449247F2408241C242A444944888409280A10
+52C6:102008207E20422042FC7E24422442247E244024482444444A44528461284210
+52C7:3FF0066001803FF821083FF821083FF82108220802007FF80408080810506020
+52C8:00107E1002103410087E7F12491249127F12491249127F1249124922492A4344
+52C9:202020203E20442088FC7F244924492449247F4414441494250A240243FE8000
+52CA:08200820FF20087C08247F24412441247F241444145414882502240243FE8000
+52CB:00203E20222022203EFC00247F2441244924492449244944144412842128C210
+52CC:082049202A207F2008FC1024FFA422244124BEA422242A24244420442CA83110
+52CD:10100810FF900010007E7F124112411241127F1208122A12491288A2282A1044
+52CE:082008207E20082008FCFF242224412488A408247E24082408440F44F8A84110
+52CF:102008207F20002022FC1424FFA4002400243E242224222422443E4422A80110
+52D0:00203E20042008207EFC08240824282410247F245524554455445784FD280210
+52D1:082008200820FF2008FC2A242A242A245D2488241C242A444944888409280A10
+52D2:22202220FFA022203EFC08247F24492449247F240824FFC40844088409280A10
+52D3:441044907510461054FE64924B9210127F12411241127F12411241227F2A4144
+52D4:0020FFA0082010207F7C552455245D24552455245D245524554455447F944108
+52D5:0F2078200820FFA0087C7F2449247F2449247F2408247F2408440FC4F8944108
+52D6:0020FF208120BD2081FCBD24812400247E2442247E2442247E4442447EA84310
+52D7:1FF010101FF010101FF000003E2022203EFC22243E2422242F44F04440940108
+52D8:22202220FF2022203EFC22243E2422242224FF2440245444624440847F280210
+52D9:0040FC4004FC688811500820FED813063440304053FC50449084108451142208
+52DA:52105210FF9052105E7E40127F1200127F1241124912491249121422222AC144
+52DB:00203E20222022203EFC00247F2441247F2441247F2441247F44144422A84110
+52DC:282044209220202048FCFC2404240024EE242224AA246624AA442244AAA84510
+52DD:0020792448A8482049FC78404BFE488849447A424DF848484888488849289A10
+52DE:08202AA42CA84920145022887FFE410281043FF8020802080408080810506020
+52DF:04407FFC04401FF010101FF010101FF00400FFFE10102208DFF6041008503020
+52E0:0020772011205520337C55240C243324C4A4182462240CA4714406441894E108
+52E1:0020FFA014207F2055FC55247F2400247F240024FFA408242A444944A8A81110
+52E2:10407C4011F8FE4844C892487CAA10AA1D06E20202007FF80408080810506020
+52E3:08107F1008107F10087EFF9200127F1241127F1241127F1241127F22222A4144
+52E4:22202220FFA022203EFC08247F2449247F2408247F2408447F4408840F28F210
+52E5:7CF8048804F87C2041FC7D2405FC04282BFC120402007FF80408080810506020
+52E6:49209220492000207F7C49247F2449247F240824FFA41C242A44494488940908
+52E7:202020203F20482088FC7F24142422247F24A4243F2424243F4424443FA82110
+52E8:20203E204220FF2049FC49247F2410242824D5242624CD2415442444D4A80910
+52E9:5220FFA052205E2040FC7F2400247E2442247E2442247E4442447E8425284210
+52EA:061078101010FF90227E5D1294921C1200127F1241125D1255125D22412A4344
+52EB:0F10F81049102A7EFF922A12491280927F12492249227F22494249427F944108
+52EC:081049102A107F10107EFF9222125112A2923C1209127F120812492288AA1844
+52ED:101008107F102210FF7E00127F1249127F1249127F1208127F1208220F2AF044
+52EE:08100F1008107F9048FE7E124912471240127F92481255124A12B7220AAA3644
+52EF:0820FF200020FF20817CBD24A524FF2400247E2442247E2442447E440094FF08
+52F0:100010FE7E92129222FE2A92449280FE4410FF0855285520556455AA5928B318
+52F1:22102210FF9022107F7E49127F1249127F120812FF9288928A92BEA282AA81C4
+52F2:7F200820FF2008FC7F2449247F2449247F2408447F440894FF08000024484224
+52F3:071078100810FF90087E7F126B125D127F1208127F120812FF920022552A8AC4
+52F4:08100F9008107F9048FE7E1248925F9255125F1255125F1248125522B2AA5E44
+52F5:00107F904A107F904A7E5F1255125F1255125F1244127F926492AEA2A2AA2144
+52F6:22104F90821E14A42FD46014AF9428882F88289429A202007FFC040418286010
+52F7:0810FF9000107710557E771222127F1222127F122212FF9228926522B22A2144
+52F8:2210FF902210F79094FEF792281224127F924812FF1248127F1248227FAA4044
+52F9:100010003FFC2004400480040004000400040004000400040004000400280010
+52FA:0800080010001FF8200840088008040802080108010800080008000800500020
+52FB:0800080010001FF82008400880081F880008000800083FC80008000800500020
+52FC:100010003FFC2004440484043F84048404840884089410942074400400280010
+52FD:0800080010001FF8200842088208020805080488048808481048200800500020
+52FE:0800080010001FF820084208820804080408088810483FE81028000800500020
+52FF:0800080008001FFC124422444244844404440884108421044204040408281010
+5300:080008000FFC10042004480484040204002400C403041C040804000400280010
+5301:0800080008001FF811082908450882080308048804480838100E200840500020
+5302:100010003FFC200448048844088409040E0408140814081407F4000400280010
+5303:080008000FFC1004210441049104128412441424182410041FE4000400280010
+5304:100010003FFC20044204810400043FF408040804080408040FE4000400280010
+5305:080008001FF0101020105F909090109010901F9010501020100410040FFC0000
+5306:0800080008001FFC1244224442449C440644098410C421244214040408281010
+5307:100010003FFC2204420487E40824102424440244028401040604180460280010
+5308:0800080010001FF820084088888825282228252828A820283FE8000800500020
+5309:100010003FFC20044004BFE4020412440A440A8402047FF40204020402280210
+530A:100010003FFC2004420492440A8402047FF407040A8412446224020402280010
+530B:100010003FFC200448048FC4120402047FF40204124412441FC4004400280010
+530C:100010003FFC22044504888410446FB400041FC4104410441FC4000400280010
+530D:100010001FFC22444224BFF402043FE422243FE422243FE42224222422B42048
+530E:100010001FFC24047FE48884124462341FC412441FC412441FC4022401F40008
+530F:10401040FEFC2884450482F47C940094FEF4208440947C8804820482287E1000
+5310:100010001FFC20047FE480041FC410441FC400043FE422243FE422243FF42028
+5311:100010003FFC28045EF492141E1412F41E8412847EF40A1412142A5444280010
+5312:100010001FFC28844884BFE40A8405040884174460341FC4104410441FD41048
+5313:100010003FFC4004BDE4252425243D34260425E43C2420A428442CA433282010
+5314:100010003FFC28045EF492941E9412F41E0412F47E940A9412F42A0444280010
+5315:1000100010001008103010C013001C001000100010001004100410040FFC0000
+5316:0880088008841088109030A030C05080918012801480108210821082107E1000
+5317:044004400440044404487C500460044004400440044004421C42E442443E0400
+5318:409241244248492448925040608043FE4202428A42524A224A524A8A3BFE0202
+5319:00003E4022403E4422483E500060FF40084408442F44283C280058004FFE8000
+531A:00007FFC4000400040004000400040004000400040004000400040007FFE0000
+531B:00007FFC4200420047F0441048205020404040A041104608580440007FFE0000
+531C:00007FFC40804080448044F047905C9044D044A44484440443FC40007FFE0000
+531D:00007FFC4080408040804FF8488848884888488848A84890408040807FFE0000
+531E:00007FFC400040004FF84080408040804080408040805FFC400040007FFE0000
+531F:00007FFC4000410040805FFC400043E04220422042244424481C50007FFE0000
+5320:00007FFC4000403847C04400440047FC4420442044204820482050207FFE0000
+5321:00007FFC400040004FF84080408047F04080408040804FF8400040007FFE0000
+5322:00007FFC4400440047F84928512862484448488851084250442040007FFE0000
+5323:00007FFC400040004FF8488848884FF8488848884FF84888408040807FFE0000
+5324:00007FFC400040005FFC408040804FF8408040A040905FFC400040007FFE0000
+5325:00007FFC4200441048085FFC4004441044107FFE44104410481050107FFE0000
+5326:00007FFC442044205FA0487852285FA8422843A85E2A4A2A424642807FFE0000
+5327:00007FFC408040805FFC4080449044904AA8514441204220441048107FFE0000
+5328:00007FFC4220522052205E2043FC42207E205220522052F8620042007FFE0000
+5329:00007FFC4080488848884FF840805FFC400040804FF840805FFC40007FFE0000
+532A:00007FFC424042407E7C424042405E78424042407E7C4240424042407FFE0000
+532B:00007FFC44004FFC5124624444A849104FF848084FF848084FF840007FFE0000
+532C:7FFE4080414042204C1873F640004FA448A44FA448A44FA448844A9449087FFE
+532D:00007FFC44205F2044205F7855285F2855285F28442A5F2A444644807FFE0000
+532E:00007FFC40804FF848884FF840807FFE40004FF84888496842104C087FFE0000
+532F:00007FFC40A0489045FE612057FC452049FC7920492049FE490040007FFE0000
+5330:7FFE40005F7C51445F7C40004FF848884FF848884FF840807FFE408040807FFE
+5331:7FFE40804FF848884FF840807FFE48084FF848084FF848084FF8441048087FFE
+5332:00007FFC40805FFC42204C1877F6441047F040004F7849484F7840007FFE0000
+5333:7FFE4080414042204C1873E640005F7C514451445F7C44104A28514440007FFE
+5334:7FFE48404F7C54906FF848084FF848084FF848084FF842205FFC442048207FFE
+5335:7FFE40804FF840804FF849484FF8441047F0441047F0441047F0422044107FFE
+5336:7FFE44105FFC44904FFC58806FF848804FF848804FFC4408473844087FFE0000
+5337:7FFE49484F7849484F7849484F78448047F84C8057F0648047FC44007FFE0000
+5338:00000000FFFE10001000100010001000100010001000100010001FFE00000000
+5339:00007FFC444044404440444044404440444444444844483C500040007FFE0000
+533A:00007FFC4000401044104220414040804140422044104810400040007FFE0000
+533B:00007FFC440044004FF8508040805FFC4080414042204410580840007FFE0000
+533C:00007FFC40804140422044105BEC400047F04410441047F0441040007FFE0000
+533D:7FFE40004FF848084FF848084FF841005FFE4210472040C043304C0840007FFE
+533E:00007FFC40804FF848084FF848004FFC592469244FFC4924492C40007FFE0000
+533F:00007FFE422042205FFC422041005FFC420047F84A08520843F840007FFE0000
+5340:00007FFC40004FF0481048104FF040005E78524852485E78524840007FFE0000
+5341:010001000100010001000100FFFE010001000100010001000100010001000100
+5342:00007FF004100410041004100410FFD0041004100412040A040A040604020400
+5343:001000F83F000100010001000100FFFE01000100010001000100010001000100
+5344:084008400840084008400840FFFE084008400840084008400840084008400840
+5345:101011101110111011101110FFFE111011101110111011101110211020104010
+5346:020002003FE00420042008221022211E41000100FFFE01000100010001000100
+5347:012007A03C200420042004200420FFFE04200420042008200820102020204020
+5348:0800080008001FF811002100410001000100FFFE010001000100010001000100
+5349:0100010001007FFC01000100092008200820FFFE082008201020102020204020
+534A:0100210811080910092001003FF8010001000100FFFE01000100010001000100
+534B:0100010001007FFC01000100092008200820FFFE08200820082008200FE00820
+534C:201024902490249024902490FFFE249024902490249024902490249024902010
+534D:00043F84008400840084008400843FFC2084208020802080208020FE20002000
+534E:08800888109030E0518096841084107C11000100FFFE01000100010001000100
+534F:2080208020802080FBF020902090229822942492289220902110211022502420
+5350:200021FC210021002100210021003FFC01040104010401040104FF0400040000
+5351:020004003FF8210821083FF8220822083FF808801080FFFE0080008000800080
+5352:020001007FFC0820082008201450228801000100FFFE01000100010001000100
+5353:010001FC010001001FF010101FF010101FF011100100FFFE0100010001000100
+5354:2040204023FC2084F88421142208201024102FBE24922492249228A22AAA3144
+5355:1010082004403FF8210821083FF8210821083FF801000100FFFE010001000100
+5356:010001003FF8010001007FFC04040288128008800900FFFE0240042018106008
+5357:01000100FFFE010001007FFC482444444FE4410441045FF44104410441144008
+5358:2208110811103FF8210821083FF8210821083FF801000100FFFE010001000100
+5359:22102210FF9022103E1022103E7E22102210FFD040105210611040107F900010
+535A:205020482FFE204027FCFC4427FC244427FC244420082FFE2208210821282010
+535B:210447C88812F3BC20084B92F83E0380AAAAABAA01000100FFFE010001000100
+535C:0200020002000200020002800240022002100210020002000200020002000200
+535D:084008400840084008400840F87E084008400840084008400840084008400840
+535E:0200010001000000FFFE02000200024002200210021002000200020002000200
+535F:004000407C4044404440446044504448444444447C4044400040004000400040
+5360:01000100010001FE01000100010001003FF8200820082008200820083FF82008
+5361:0200020003F8020002000200FFFE020002000240022002100208020002000200
+5362:0100010001FC010001001FF81008100810081FF8100810002000200040008000
+5363:0100010001FE010001003FF8200820083F88208820883F88200820083FF82008
+5364:0100010001FE010001003FF8200824482288210822882448282820083FF82008
+5365:0100010001FE010001003FF8200829282528224825482888214822283FF82008
+5366:0840084008407F4008400860FFD0084808447F440840084008400FC0F0400040
+5367:00207FA04820482048207F304128412441227F224820482048207FA000200020
+5368:0100010001FC01001FF010101F9010907FFC40044FE4482448244FE440144008
+5369:000003F802080208020802080208020802080208022802100200020002000200
+536A:000003F802080208020802880248024802080208022802100200020002000200
+536B:00007FF8020802080208020802080208022802100200020002000200FFFE0000
+536C:0000060078FC408440844084408440844084408440844EA87090008000800080
+536D:00000000FEFC10841084108410841084108410841E84F0A84090008000800080
+536E:007C3F80200020003FFE2000200027F024102410245024242404440443FC8000
+536F:0C0070FC44844484448444844484448444844C8474A804900880088010802080
+5370:0000060078FC4084408440847E8440844084408440844EA87090008000800080
+5371:040004000FF0101020205FFC100013F012101210125012202204220441FC8000
+5372:000000007F7C1144114421442544424480443F4421442154214821403F402140
+5373:00007E7C424442447E44424442447E444044484444544A485240604000400040
+5374:08000800087C7F44084408440844FFC41044104424444254FF48414000400040
+5375:0C0070FC4484448464A454945494448444844C8474A804900880088010802080
+5376:100010003E7C4244A444184410442444C8441F442144D2540C4808403040C040
+5377:0100111009203FF8020002007FFC082010102FE8C826082008A80848080807F8
+5378:200020003F7C4844884408447F44084408442E44284428542F48F04040400040
+5379:08000800107C7F445544554455445544554455445544555457C8FC4000400040
+537A:1FC000447D88055009203118C50602003FF800001FF010101050102410040FFC
+537B:14001200217C49440844144422444144BE4422442244225422483E4022400040
+537C:0080FC8029F82A082DFE2900297829482968295029442A442C3C480247FE8000
+537D:080010007E7C42447E4442447E440044404440447E44405440484C4070400040
+537E:00007700557C5544774400447F440044FFC420443F440154014801400A400440
+537F:080073DE42524A524A524BD24A524A524A525BD26A124A9A125412B023104210
+5380:080008007F7C1C442A44494414442244494488442A441C542A48C94028401040
+5381:0808144822285C8888487F0E08F82A08490818087FFC01040114010801000100
+5382:00003FFE20002000200020002000200020002000200020002000400040008000
+5383:040004000FF0101020205FFC1000100010001000100010002000200040008000
+5384:00003FFE2000200027F024102410241024102450242024042404440443FC8000
+5385:00003FFE2000200020002FFE2040204020402040204020402040404041408080
+5386:00003FFE20002080208020802FFC208420842104210422042204440448289010
+5387:00003FFE2000201020F827802080208020FE3F802080208220824082407E8000
+5388:00003FFE200020002FFC20802080208020803FFE208020802080408040808080
+5389:00003FFE200020002FFE2100210021F821082108210822082208440848509020
+538A:00003FFE2000200027FE201022102210241027FE20502090211042104C508020
+538B:00003FFE200020802080208020802FFC2080208020902088208840805FFE8000
+538C:00003FFE200020802090208820802FFC20802140214022202220441048089006
+538D:00003FFE2000208020802FFC21002240244027FC204020404FFE404080400040
+538E:00003FFE20002000203C27C024402440244027FE242024202412450A46468422
+538F:00003FFE20002200220023FE2480248028FC3080208020FC2080408040808080
+5390:00003FFE20002220221022002FFC22402240224824502460484248C2933E2000
+5391:00003FFE200020202FA028A228A428A828B028A028A028A22FA248A2401E8000
+5392:00003FFE20002100210023FC2240244020403FFE204024442444444447FC8004
+5393:00003FFE2040204027FC204020402FFE20002040204027FC204040404FFE8000
+5394:00003FFE2000200027FC20802110220827FC2044204027FC204040404FFE8000
+5395:00003FFE20002F8428A428A42AA42AA42AA42AA42AA422242504448448949008
+5396:00003FFE241024083FFE249024A024C8249024A424C8249228E24982567EA000
+5397:00003FFE2080204027FC2000211020A02FFE2040204027FC2040404040408040
+5398:00003FFE200027FC2444244427FC2444244427FC2040204027FC404040408FFE
+5399:00003FFE204020402FFC204027FC244427FC244427FC20402FFE404040408040
+539A:00003FFE200027F8240827F8240827F8200027F8201020202FFE404041408080
+539B:00003FFE2000200C2F70294029402940297E2948294829482F48408840888108
+539C:00003FFE2000203827C0204027FC224822482FFE224822482FFE4040404087FC
+539D:00003FFE221022102FFC221022103FFE200027F82408240847F84408840807F8
+539E:00003FFE2120212021203F3E212021202F3C212021203F3E2120412041208120
+539F:00003FFE2080210027F02410241027F02410241027F020802490488852848100
+53A0:00003FFE20002F84288428A42FA428A42FA428A428A42FA42024490448949088
+53A1:00003FFE2080210027FC240427FC240427FC2040274421682250444859468080
+53A2:00003FFE22002200227C2F442244267C27442AC42A7C324422444244427C8244
+53A3:00003FFE20A020903FFE21402630380E2FF828882FF828884FF8488880800080
+53A4:00003FFE2000230C2E70221022103FFE2210273826B42A542A52529042108210
+53A5:00003FFE2000289025102FBE222222442A902A902F9022104228442884440882
+53A6:3FFE20003FFC210027F8240827F8240827F8240827F8220047F84A0881F01E0E
+53A7:00003FFE20802FFC208027F8240827F8240827F8240827F824087FFE42108408
+53A8:00003FFE20083F8820082F08297E290829082F4820282908260843885C288810
+53A9:00003FFE20002F7E291029102F502950297E2F1028282A2829284B4A4D4A8886
+53AA:00003FFE21102FFE211021F0204027FC244427FC20402FFE204047FC40408FFE
+53AB:00003FFE221022102F90221E2FA422243FD4241427942488248848944AA49142
+53AC:3FFE200027F8240827F8240827F8222027B02D2827FE380047F8440887F80408
+53AD:00003FFE20102F9428922F9028FE2F9020102F9028902F9028A84FA848C48982
+53AE:00003FFE2900290C3FB0292029202F3E29282F28292829285FA840488A881108
+53AF:00003FFE221022103FFE27182AB4325222102210208024442452441243F08000
+53B0:00007FFE420852484A504A9E5FE4505457545554554857485048515450948022
+53B1:00003FFE204020A0211022082DF6200027BC24A424A427BC211042A844448882
+53B2:00003FFE21102FFE211023F8224823F8224823F8204027FC245445F44414840C
+53B3:1104088408883FFE20002710211E2FD424A427942494278824E85F9440A480C2
+53B4:3FFE28882F8A20082FBE28882F88289429A2200027FC244427FC444447FC8040
+53B5:3FFE20802FF828082FF844904A8881007EFE48905EBC52A45EBC48906AD49930
+53B6:0200020002000200040004000400080008401020101020107FF8200800080000
+53B7:020002000200FFFE0400040004400840088010801100221044088FFC04040004
+53B8:080808080808080808081010101010102020242424244242FEFE424202020000
+53B9:020002003FE002200220042004220822311EC10002000420081010083FFC1004
+53BA:010001000100FFFE0280044009203118C20602000420081010083FFC10040004
+53BB:0100010001003FF80100010001000100FFFE020002000400082010103FF80008
+53BC:020002000400082010103FF81108010009200910110821044104010005000200
+53BD:020002000400082010103FF80008101010101010202024244242FEFE42420000
+53BE:00007FF00410041004103F90041004107FD0041008101112208A7FCA00460002
+53BF:00001FF0101010101FF0101010101FF010101010FFFE0400082010103FF81008
+53C0:01000100FFFE01003FF8210821083FF8210821083FF80400082010103FF80008
+53C1:0200044008201FF002007FFC0820101027C8C00600000FE0000000003FF80000
+53C2:0200044008201FF002007FFC082010902308CC4601800610182000C007007800
+53C3:040008201FF0102024487EFC010006C018B0E30E0C403190062038C007007800
+53C4:040008201FF0102024487EFC010006C01830E00E0FE000001FF000007FFC0000
+53C5:040008201FF0102024487EFC010006C01830E20E02201290124822480A000400
+53C6:000E03F078440224010803FEFE42104013FE208028FC4544FD28421004680186
+53C7:00100210797C001400FE0014FB7C21922154413851544992F930490002FE0400
+53C8:00003FF01010101010200820082004400440028001000280044008203018C006
+53C9:00003FF01010121011200920082004400440028001000280044008203018C006
+53CA:00003FE008200820084008400CF80A080A080910111010A0204020A043188C06
+53CB:020002000200FFFE040004000FF00A1012101120214040808140062018186006
+53CC:00000000FDFC0484448444842888288810501050282028204450448881040202
+53CD:001000F83F00200020003FF8240824102210222021402080414042208C183006
+53CE:0400040045FC448444844484448844884C505450642044200450048805040602
+53CF:020002003FF0021002100210FFFE020002003FF010100820044003801C70E00E
+53D0:00FC3F00010001007FFE0200040007F80A080A08111020A0404080A003180C06
+53D1:01001110110822003FFC0200040007F80A080908111010A0204040A003181C06
+53D2:00003FF000201E40018006601818E00400003EF8028822881450082034D8C306
+53D3:01000100FFFE01003FF8210821083FF801003FF010100820044003801C70E00E
+53D4:080008000EFC084408440844FF440028082808284A1049108928084828841102
+53D5:00003EF8020822881450082034D0C30800003EF8028822881450082034D8C306
+53D6:0000FF8022FC22443E44224422443E442228222827A8FA104210022802440282
+53D7:0008007C3F88110808907FFE400280043FF0082004400280010006C01830E00E
+53D8:02000100FFFE044014502448444400003FF0082004400280010006C01830E00E
+53D9:0800080014FC22444144BE44084408287F2808282A1029104928884828841102
+53DA:00003E7C2204220422043E7C200020003EFC204420443E282010202820C42302
+53DB:1008101C95E0590011007DFC11441144FF441128112811102110222842448482
+53DC:020001007FFE4112912422C00430180CE0023FF010100820044003801C70E00E
+53DD:100010FC108410847C941088108010FCFEA410A410A824A84290FEA842C40082
+53DE:00007F00417C41247F2440245F24402840287FA84410551094A8A4A814440882
+53DF:010005003978210821083D78210821083FF801003FF00820044003801C70E00E
+53E0:1FE0044003800C407EFC22441C3862440000FFFE90121FF010101FF01010FFFE
+53E1:10001F00107CFFA480A47F242A245528A2287F28A2903E1022283E2822443E82
+53E2:24481450FFFE08207FFC01003FF80100FFFE22003EFC22443E282390FE2802C6
+53E3:000000003FF820082008200820082008200820082008200820083FF820080000
+53E4:0100010001000100FFFE0100010001001FF0101010101010101010101FF01010
+53E5:0800080010001FF8200840089F8810881088108810881F881088000800500020
+53E6:00001FF01010101010101FF0020002007FF80208040804080808100820504020
+53E7:00001FF01010101010101FF0000000007FF8040804080808080810082050C020
+53E8:000000007DFC44444444444444444444444444447C4444840084010402280410
+53E9:000000FC7C8444844484448444844484448444847C9444880080008000800080
+53EA:00001FF01010101010101010101010101FF01010000008200810100820044004
+53EB:000400047C8444844484448444844484448C44B47CC444840004000400040004
+53EC:00007FF804080408080808081050202040009FF810081008100810081FF81008
+53ED:000000207920492049204920492049204920491079104A100208040808041002
+53EE:000000007BFE4820482048204820482048204820782048200020002000A00040
+53EF:00007FFE001000101F10111011101110111011101F1011100010001000500020
+53F0:0200020004000820101020087FFC200400001FF010101010101010101FF01010
+53F1:004000407C4044424444444844504460444044C07D40444200420042003E0000
+53F2:0100010001003FF82108210821083FF82108010011000900060005801870E00E
+53F3:020002000200FFFE04000400080008001FF8280848088808080808080FF80808
+53F4:020002003FE00220042004220822301EC0001FF010101010101010101FF01010
+53F5:00007FFC40004000400047F0441044104410441047F04410400040007FFE0000
+53F6:0020002078204820482048204BFE482048204820782048200020002000200020
+53F7:00001FF01010101010101FF00000FFFE080010001FF000100010001000A00040
+53F8:00003FF8000800087FE8000800081F8810881088108810881F88108800280010
+53F9:000007F87A084A084A0849104910491048A048A07840484000A0011002080C06
+53FA:020001007880488048404840484048A048A048A0791049100208020804040802
+53FB:00400040784048404BFC48444844484448444884788448840104010402280410
+53FC:000003FC780448044804481448244844488449044A0478044804000400280010
+53FD:000001F0791049104910491049104910491049107A104A1202120412040E0800
+53FE:00003FF800600180010001000100050002001FF010101010101010101FF01010
+53FF:000000007DFC44204420442044204420442044207C2044200020002003FE0000
+5400:0008003C7DE0442044204420442047FE442044207C2044200020002000200020
+5401:000001FC782048204820482048204BFE48204820782048200020002000A00040
+5402:02000100FFFE1000100010001FF8000000001FF010101010101010101FF01010
+5403:00800080790049FE4A004C0049F8480848104860788049000202020201FE0000
+5404:040004000FE0082014402280410006C01830E00E1FF01010101010101FF01010
+5405:000000007EFC4284428442844284428442844284428442847EFC428400000000
+5406:00200020784048404884488449084BF849104810782048400088010403FE0102
+5407:000003F8780848104820484048404FFE48404840784048400040004001400080
+5408:010001000280044008203018CFE6000000001FF010101010101010101FF01010
+5409:010001000100FFFE0100010001003FF8000000001FF01010101010101FF01010
+540A:00001FF01010101010101FF0010001003FF82108210821082128211001000100
+540B:00100010781048104BFE48104810481049104890789048100010001000500020
+540C:00003FFC200420042FF42004200427E424242424242427E42424200420142008
+540D:0200020007F00810142062400280010006001FF8E8080808080808080FF80808
+540E:001000F81F00100010001FFE10001000100017F8140824082408440887F80408
+540F:01000100FFFE010001003FF82108210821083FF811000900060005801870E00E
+5410:0040004078404840484048404FFC48404840484078404840004000400FFE0000
+5411:0200040008007FFC4004400447C4444444444444444447C44444400440144008
+5412:0008003C7BC04840484048404840487E4BC048407840484200420042003E0000
+5413:000007FE78404840484048404850484848444844784048400040004000400040
+5414:0020002078204920492C493449644BA449244934792849220122010200FE0000
+5415:00001FF010101010101010101FF0000000003FF820082008200820083FF82008
+5416:0000020279044888485048204820482048204820782048200020002000200020
+5417:000003F07810481049104910491049FC4804480478044BF40004000400280010
+5418:00800080788049FC49204A20482048204BFE4820782048200020002000200020
+5419:00400040784048404A444A444A484C50484048A078A049100110020804040802
+541A:000003F87888488848884FFE4888488848884BF8788848800100010002000400
+541B:00003FF804080408FFFE040804083FF8080008001FF81808280848088FF80808
+541C:000003F8788848884888488848884FF849084908790849080108010807FE0000
+541D:020001007FFC0820044003800C603018C0061FF010101010101010101FF01010
+541E:00003FF801000100FFFE0280044008203018DFF610101010101010101FF01010
+541F:0040004078A048A049104A884C46484048004BF8780848100010002000200040
+5420:004000507848484848404FFE4840484048A048A048A079104910020804040802
+5421:002002207A204A224A224A244BA84A304A204A207A204A2202A20322021E0000
+5422:01000080088848044812481287F0000000001FF810081008100810081FF81008
+5423:00000040F0209010909090809080928492829282F28294880088008800780000
+5424:0040004078A048A049104A084C06491049104910791049100110021002100410
+5425:000000007BFE48104810482048204868486448A479224A220420002000200020
+5426:00007FFC008001000300056009183104C10200001FF01010101010101FF01010
+5427:000003F87A484A484A484A484A484BF84A084A007A004A020202020201FE0000
+5428:0040004078404BFC48404A484A484A484A484BF87848484000420042003E0000
+5429:0010009078904888490849044A044DFA48884888488878884908010802280410
+542A:00A000A078A0492449244B284D304920496049A07920492201220122011E0100
+542B:01000100028004400A203118C1060FE0004000801FF01010101010101FF01010
+542C:0008001C79E049004900490049FE491049104910791049100110021002100410
+542D:0080004078404FFC4800480049F04910491049107910491202120212040E0800
+542E:00800080790049104A084FFC48044920492049207920492002220222041E0800
+542F:010000801FFC1004100410041FFC10001000100017FC24042404440487FC0404
+5430:00400040784048404BFE4840488048904890492079204A480244048401FE0082
+5431:0020002078204BFE48204820482049FC48844888784848500020005001880606
+5432:000403E478244824482449E4490449044A044BE4782448240024002401440084
+5433:000007E00420142017E0100010001FF001100110FFFE0280044008203018C006
+5434:00001FF0101010101FF0000000003FF801000100FFFE0280044008203018C006
+5435:004000407840494849444A424A424C4848484848781048100020004001800600
+5436:004000200020FBFE8A228A228A328A4A8A4A8A86FB068A0202020202020A0204
+5437:0040004078404BF848484848484848484FFE484078A048A00110011002080406
+5438:000007F87908491049104920493C490449044A887A884A500420045008880306
+5439:00800080788048FC490449084A404C40484048A078A049100110020804040802
+543A:000001F07910491049104A0E4C004BF849084910789048A0004000A003180C06
+543B:01000100790049FC4AA44CA448A4492449244A447C4448840104020404280010
+543C:001007D078504890491049104950499049104F107910491201120112050E0200
+543D:002000207920492049FC49204A20482048204BFE782048200020002000200020
+543E:00007FFC020002003FF0041004100810FFFE00001FF01010101010101FF01010
+543F:0100110011001FF8210041000100FFFE010001001FF01010101010101FF01010
+5440:000003FC78104910491049104A104BFE48304850789049100210041000500020
+5441:00400040788048FC49044A044884484448444814482478444984000400280010
+5442:00001FF010101010101010101FF0020004003FF820082008200820083FF82008
+5443:000003FE7A004A004AF84A884A884A884A884AA87A904A8204820482087E1000
+5444:00003FE00420047C0804101461080100FFFE010001003FF8200820083FF82008
+5445:0080004078404FFC4910491049104910491048A078A0484000A0011002080C06
+5446:00001FF01010101010101FF0010001007FFC03800540092011102108C1060100
+5447:010001047D880550092011102108C50602001FF010101010101010101FF01010
+5448:00001FF01010101010101FF0000000007FFC010001003FF801000100FFFE0000
+5449:000007E00420142017E0100010001FF000100010FFFE00000440082010102008
+544A:0100110011001FF8210041000100FFFE000000001FF01010101010101FF01010
+544B:0040004078404BFC4840484048404FFE484048A078A049100110020804040802
+544C:001001107890489048104910489048904810481E7BF048100010001000100010
+544D:0000000079FC4800480048004BFE48204820484078404888010403FE01020000
+544E:000001FC790449044904490449FC492449204920791049100208020804040802
+544F:000800687B8848884888488848884BFE48884888788848880108010802080408
+5450:0040004078404BFC4A444A444A444A444AA44A947B144A040204020402140208
+5451:001000F83F00010002007FFC044008203018C0061FF01010101010101FF01010
+5452:000003FC78404840484048404FFE484048A048A078A0492001220222041E0800
+5453:009000907BFE4890489048004BF8481048204840788049000202020201FE0000
+5454:00400040784048404FFE4840484048A048A048A0791049100288024804440802
+5455:000003FC7A004A084A884A504A504A204A204A507A504A880308020003FE0000
+5456:000003FE7A004A204A204A204AFC4A244A244A247A444A440484048409281210
+5457:000001FC79044904492449244924492449244924792448500048008401020602
+5458:00001FF0101010101FF000003FF82008210821082108210822C8043018086004
+5459:00001FF01010101010101FF0010001007FFC4104428444444824400440144008
+545A:004000407C40448044FE450846884488448844507C5044200050008801040202
+545B:0040004078A048A049104A084C0649F049104910795049200104010400FC0000
+545C:0020004079FC49044904490449144908490049FE7802480203FA000200140008
+545D:0040002079FC4904490449FC49004900497C49087910492001420282027E0400
+545E:000001FC780448044BF44804480449F449144914791449F40004000400140008
+545F:0080004078404BFE48404840488849084BF0482078404888010403FE01020000
+5460:00400040784048404FFC484048E048E0495049504A487DF44842004000400040
+5461:000003FC7A044A044A044BFC4A204A204BFE4A207A204A100212028A03060202
+5462:000003FC7A044A044A044BFC4A004A404A444A487A704A4004420442083E1000
+5463:000001F8790849484928490849084FFE4A084A887A484A0803FE000800500020
+5464:0040004078A048A049104A484C2648204BF848087810491000A0004000200020
+5465:0040004078404BF84A484A484BF84A484A484A484FFE7A084A08020802280210
+5466:002001207120522052FC54A4572451245224522474A447A400C4004400940108
+5467:0008003C7BE04A204A204A204A204BFE4A204A107A104A12020A028A03260212
+5468:00003FF8210821082FE8210821083FF8200827C82448244827C8400840288010
+5469:000001FC7800480048004BFE48204820492849247A244A220422002000A00040
+546A:000003FC7A044A044A044A044BFC4890489048907890491201120212040E0800
+546B:0020002078204820483E48204820482049FC4904490479044904010401FC0104
+546C:000000007BFC4A944A944A944A944A944A944A944A9C7B044A04020403FC0204
+546D:004802487A484A484A484FFE4A484A484A484A487A784A000200020003FE0000
+546E:0000000079FC4904490449044904490449FC4904780048900088010402020402
+546F:000001FC78204820492448A448A848204BFE4820782048200020002000200020
+5470:0440044024442758246024422F42F03E40001FF010101010101010101FF01010
+5471:0008003C7BD04A904A904A904A904A904A904A887A884AC802A404D404920800
+5472:0090009078904A904A924AD44A984A904A904A907A904A9203D20E12040E0000
+5473:0040004078404BFC4840484048404FFE48E0495079504A480444084200400040
+5474:00800080790049FC4A044C0449E449244924492479E449240004000400280010
+5475:000000007BFE4808480849E8492849284928492879E849280008000800280010
+5476:02000200E27CA224AFA4A4A4A4A4A4A8A4A8A928E510A2100528094810840102
+5477:000007FCF4449444944497FC94449444944497FCF44490400040004000400040
+5478:000003FC782048204840484048D049484A444C44784048400040000007FE0000
+5479:004000407A404A404BFC4A404C4048404FFE484078A048A00110020804040802
+547A:000001F879084908490849F848004BFE4880490079F848080008000800500020
+547B:0040004078404BF84A484A484A484BF84A484A487A484BF80248004000400040
+547C:0008003C7BE04820492448A448A848204BFE4820782048200020002000A00040
+547D:0100010002800440082037D8C00600003EF82288228822883EA8229000800080
+547E:0000000079FC49044904490449FC49044904490479FC49040000000003FE0000
+547F:00200020782049FC4820482048204BFE4820484078404888010403FE01020000
+5480:000001F879084908490849F849084908490849F8790849080108010807FE0000
+5481:01080108790849084FFE490849084908490849F8790849080108010801F80108
+5482:000003FE7A104A104A104AFE4A924A924A924A927A9A4A940210021003FE0000
+5483:0120012079204AA04AAC4EB44AE44BA44AA44AB47AA84AA202A20282027E0200
+5484:00200020792449244924492449FC4824482048207A224A220222022203FE0002
+5485:020001003FF8000008200440FFFE000000001FF010101010101010101FF01010
+5486:0080008079FC49044A044DF449144914491449F4790449280112010200FE0000
+5487:00000040782048284808488848904A944AA24AA27CC248880188028804780000
+5488:0090009078904BFC489448944BFC4A904A904BFE78924892011A011402100410
+5489:0040004078404BF84A484A484A484A484A484FFE784048A000A0011002080406
+548A:003803C07840484048404FFC484048E048E0495079504A480444084200400040
+548B:01000100790049FE4A804A804C8048F848804880788048FC0080008000800080
+548C:04000E007800087C0844FF44084418441C442A442A444844887C084408000800
+548D:002000207840488849044BFE4802480049FC4904790449040104010401FC0104
+548E:104010401E502248224454440840144023FEC0001FF01010101010101FF01010
+548F:00400020781049E0482248344BB848B048A848A8792849240224042200A00040
+5490:0088008878884908497E4B084D08494849284928790849080108010801280110
+5491:01000100793E49084FC849084908494849884F08790849080108010805280210
+5492:00007CF84488448844887CF8000000000FC0084008400840104010422042C03E
+5493:000000007BFC4900490049F04910491049904A507A504A10021202920312020E
+5494:004000407840487C4840484048404FFE48404840785048480044004000400040
+5495:00200020782048204BFE48204820482049FC4904790449040104010401FC0104
+5496:04000400F400943C9FA494A494A494A494A494A4F4A494A408A408BC12A42100
+5497:00400040784048404BFE48404880488048FE491079104A100210041001FE0000
+5498:0040004078404BFE488048A0492049FC4B244D24792449240134012800200020
+5499:00900088788848804BFE48A048A048A448A449287928493202220262049E0800
+549A:0080008078F849084B104CA0484048A04B184C0678C048200010018000600010
+549B:0040002078204BFE4A024C04480048004BFE4820782048200020002000A00040
+549C:0040002078204BFE4A024C04490049084910492079C049020102010200FE0000
+549D:0108010871085210529454A457BC510851085210742057BC000000000FFE0000
+549E:000003FC789048904890489048904FFE48904890789048900110011002100410
+549F:000003FE78204820484049FC49044904490449FC490479044904010401FC0104
+54A0:00001FF0101010101FF000007FFC10101FF010101FF01010103EFFD000100010
+54A1:000003FE79084908490849F84908490849F849087908491E07E8000800080008
+54A2:00003EF8228822883EF800003FF80000FFFE040008000FF00010001000A00040
+54A3:004000447A444948495048404FFE4890489048907890489201120112020E0400
+54A4:0040002078204BFE4A024C0448384BC048404840787E4FC0004000420042003E
+54A5:000003FE78204840488849044BFE4822482048207BFE48200020002007FE0000
+54A6:00400040F7FE904097FC904493FC9240944097FEF04290AA00A4011002080C06
+54A7:00040004EFC4A214A214A3D4A254A454A654A554E894A0940104020404140808
+54A8:4080208009FC12042448E04020A023182C0600001FF01010101010101FF01010
+54A9:01040084788848004BFE4820482049FC482048207BFE48200020002000200020
+54AA:004000407A484948495048404FFE484048E0495079504A480444084200400040
+54AB:00003E7C22442244224422443E7C2A002828282428442442248242004180807E
+54AC:00800040F04097FC900091109208940491109110F0A0904000A0011002080C06
+54AD:0020002078204BFE4820482049FC4800480049FC790449040104010401FC0104
+54AE:00200120792049FC49204A2048204BFE487048A878A849240124022200200020
+54AF:0080008078F849084B104CA0484048A049184A067DF849080108010801F80108
+54B0:0080008079FC49044A0449E44924492449E44924792449E40104000400280010
+54B1:0020004079FC49044904490449FC49044904490449FC79044904010401FC0104
+54B2:02080108791048004BFC4840484048404FFE4840784048A000A0011002080406
+54B3:00400020F02097FE90409084910893F090229044F18896100020005001880604
+54B4:0040004078404BFE4880489048904912495249547A904A280428004400840102
+54B5:002000207BFE4850488849044AFA48004BFE4840788049FC0004000400280010
+54B6:0008003C79E0482048204BFE48204820482049FC790449040104010401FC0104
+54B7:0090009078904A9249944898489049984A944C9278904890011201120212040E
+54B8:0050004800403FFE204020402F44204420442F28292829122F32494A40868102
+54B9:0040002078204BFE4A024C4448404BFE48884888790848D00020005000880304
+54BA:000003FE7800480049FC4904490449FC4904490479FC49040000000003FE0000
+54BB:009000907890491049FE4B104D10493849384954795449920110011001100110
+54BC:00001FF0101010101F90109010907FFC400440044FE4482448244FE44004400C
+54BD:000007FCF40494449444944497FC9444944494A4F49495140604040407FC0404
+54BE:0040004078444BF4484848504FFE4840488049844A987CE048820082007E0000
+54BF:0100017CF1249224922496FE9A2492249224927CF22492200220022002400280
+54C0:02000100FFFE000000001FF0101010101FF0028004440C283410C50806060400
+54C1:00001FF010101010101010101FF0000000007C7C44444444444444447C7C4444
+54C2:000007FE7890489048904BFC4A944A944A944A947A9C4B040204020403FC0204
+54C3:000003FC7A044A044AF44A044A044AF44A944A947A944AF40204020402140208
+54C4:01100110791049104BFC49104910491049104FFE780049100108020804040804
+54C5:01000100790049FE4A024A024D1248A24A4A4AAA7B1A4A0A03FA000200140008
+54C6:00800080F1F89210952090C0909093209C7C9084F10896900060004001800E00
+54C7:0020002079FC4820482048204BFE48004820482079FC48200020002003FE0000
+54C8:0040004000A0F8A089108A088C0689F4880088008BF8FA088A08020803F80208
+54C9:0840084808447F4408400840FFFE004000443E442228222A22123E2A22460082
+54CA:00400040F7FE9080910091FC9304950499FC9104F10491FC0104010401140108
+54CB:021002507250525C5F7452D4525452545254525C725053520E420442003E0000
+54CC:0008003CF7C09400941C95E09520952295249528F51095100508094409821100
+54CD:0040004078804BFC4A044A044AF44A944A944A947A944AF40204020402140208
+54CE:011001107BFC4910491048004A084A084910491078A0484000A0011002080C06
+54CF:000003F87A084A084BF84A084A084BF84A444A487A304A200210028803060200
+54D0:000003FE7A004A004BFC4A204A204AF84A204A207A204BFC0200020003FE0000
+54D1:000003FC78904890489048924C924A944A944A98789048900090009007FE0000
+54D2:001002107910491048FE48104B104928492449447942498201000280047E0000
+54D3:0080008078BC4BC04850482448D44B0C48004BFE7890489001120112020E0400
+54D4:01100112791449D8491049124952498E492048207BFE48200020002000200020
+54D5:002001247924492449FC4840484048FC49044A84784848500020004000800300
+54D6:0080008078FE49104A10481048FC4890489048907BFE48100010001000100010
+54D7:00900094791449184B104D324952490E492048207BFE48200020002000200020
+54D8:00800080793C4A004C804880497E4B084D084908790849080108010801280110
+54D9:0040004078A049104A084C0649F0480048004FFC784048800110020807FC0204
+54DA:000001F079104910491049104A4E4C404BFC484078E049500248044600400040
+54DB:00807C8844B044C444847C7C00000440082010102FE8C4260420082010A06040
+54DC:004000207BFE490448884850482048D84B064888788848880088010801080208
+54DD:00400040F04097FC948498889140914493489530F92091100108014401820100
+54DE:00400040789049084BFC48244920492049FC4A2078204FFE0020002000200020
+54DF:02200220F220943C95449F449284922494149F94F404900401840E0404280010
+54E0:00200120792049FE4A204C2048204BFE4800480079FC49040104010401FC0104
+54E1:00001FF0101010101FF000003FF820083FF820083FF820083FF8082010102008
+54E2:000003FE7820482049FC482048204BFE488848887BFE48880088010801080208
+54E3:000003FC7800480049F849084908490849F84800790848880090000007FE0000
+54E4:0110010879004FFE494849504964494849504A647A484A520462044209BE1000
+54E5:00007FFC00101F90109010901F900000FFFE00101F90109010901F9000500020
+54E6:002801A4F724912091209FFE9120912491A49328FD2891100112012A05460282
+54E7:0020002079FC4820482048204BFE48484848494C794A4A4A0088008801280210
+54E8:0020012478A448A8482049FC4904490449FC4904790449FC0104010401140108
+54E9:000007FCF444944497FC9444944497FC90409040F7FC9040004000400FFE0000
+54EA:00000FDE72525252525457D45258525452525FD27252525A0254045005500890
+54EB:000001FC79044904490449FC482048204920493C7920492002A00260043E0800
+54EC:0100010079FE4A044A044EF44A944A944A944A947AF44A940204020402140208
+54ED:00003C782448244824483C78000001100108FFFE01000280044008203018C006
+54EE:004000447BF4484848484FFE482048404BF849107A204DFE0820002000A00040
+54EF:000001FC7904490449FC4904490449FC4904490479FC4850009000920112020E
+54F0:004000207BFE4A024C24492049FC49204A2048207BFE48200020002000200020
+54F1:002000207BFE482048204BFE4A024C0449F8481078204BFE0020002000A00040
+54F2:080C08F07E8008800EFE788808882908120800001FF01010101010101FF01010
+54F3:0208021C726052405FC05240527E52C853485E4872485248024802480A880508
+54F4:008000407BF84A084A084BF84A084A084BF84A407A444A280210028803060200
+54F5:000203E27A224A2A4A2A4BEA490A490A4BEA492A792A492A0222022204AA0844
+54F6:0088008878884B8E48884888480049FC482048207BFE48200020002000200020
+54F7:0008003C7BC048444A244928490048104BFE4810791048900090001000500020
+54F8:0008003C7BC048444A244928490048404BFE488879084B900060005001880604
+54F9:0008003C7BC048044A44492848004BF8481048204FFE78204820002000A00040
+54FA:00480044F7FE9040904093FC9244924493FC9244F24493FC0244024402540208
+54FB:000001FC790449FC490449FC4800480049FC482078204BFE0020002000200020
+54FC:004000207BFE480049F84908490849F848004BFC780848300020002000A00040
+54FD:000007FEF04097FC9444944497FC9444944497FCF24091400080014002300C0E
+54FE:010400847888481049FC49044904490449FC48507850489000920112020E0400
+54FF:080008007F7C114411442544427C0000FFFE00101F90109010901F9000500020
+5500:001C01E0782048204BFE48A849244A2249F84888789048BE0102010202140408
+5501:004000207BFE4800480049FC4800480049FC4800780049FC0104010401FC0104
+5502:01100108F2049444904090A0911092089C0693F8F20892080208020803F80208
+5503:010001007BF84A084C104BFC4A444A444BFC4A447A444BFC0244044404540808
+5504:000001FC7904490449FC4904490449FC4904490449FC78004888008401020202
+5505:0040004078A049104A884C4649F04810482048407BF84A080208020803F80208
+5506:00400040788849044BFE4802488849444A4248F879884A500020005001880606
+5507:00003FFC20002FF820003FFE248824502530260E20002FF8480848088FF80808
+5508:000001F87908490849F848004BFC4A444A444A447BFC4A000202020201FE0000
+5509:00400080F110920897FC9104910093F8944090409FFEF04090A0011002080C06
+550A:0020002078204BFE482048204924492449244AAA782048500050008801040202
+550B:002000207850488849044AFA482048204BFE4820792849240222042200A00040
+550C:0004000E7BB8488848884928492E4BA848A84AA87AA8493E01000280047E0800
+550D:004000207BFE4A024C0449F8480048004BFE48907890489001120112020E0400
+550E:004200E27B82488A488A488A4FEA488A498A49CA7AAA4A8204820082008A0084
+550F:01840068783048C84B0448404BFE48A049204BFC7D2449240134012800200020
+5510:010000803FFE20802FF820883FFE20882FF820802FF82808480848088FF80808
+5511:00400040F24892489248955498E29040904097FCF0409040004000400FFE0000
+5512:00000FFEF0A090A097FC94A494A494A4951C9604F40497FC0404040407FC0404
+5513:002000207BFE482049FC4924492449FC4924492449FC78204BFE002000200020
+5514:000007FCF040904093F89088908897FE90009000F3F892080208020803F80208
+5515:0020004079FC4904490449FC4904490449FC482078204BFE0020002000200020
+5516:000003FC7890489048904BFC4A944A944A944A947BFC48900090009007FE0000
+5517:0020002079FC4820482048204BFE482048204920793C492002A00260043E0800
+5518:0000FEFC104420443E286210A2283E44228200001FF01010101010101FF01010
+5519:001008907510521255525954515851905310552879285128014801440A840502
+551A:000001FC780448FC480449FC48004BFE4A0249F8788848880050002000D80306
+551B:00400040F7FC904093F8904097FE908090F89108F31094A0004000A003180C06
+551C:010001007FFC01003FF8054009203118C10600003E442258226022423E42223E
+551D:000001FC782048204BFE4800480049FC49044924792449240154008801040602
+551E:01040124791449144FC449244914495449864F3C790449040104010405040204
+551F:010001003FF801000100FFFE040008201FF000103E442258226022423E42223E
+5520:008800887BFE488848004BFE4A024C4448404BFC784448840084010402280410
+5521:000003FE7850485048504BFE4A524A524A524AAA7AA64B0202020202020A0204
+5522:0020012478A448A8482049FC4904492449244924792449240050008801040202
+5523:0020004079FC4904490449FC4904490449FC48407840487E07C000420042003E
+5524:01000100F1F0921094209BF89248924892489248F7FE90A000A0011002080C06
+5525:001004107A284A2848444992490849084AFE4E027A044A440228021002080008
+5526:00100210791049104C544A524A524890481049147E044A0802080210022000C0
+5527:000007BC74A454A454A457A454A454A454A457A47434552804A0056006200020
+5528:000007BC74A455245524563C552454A454A454BC76A4552404240424047E0400
+5529:001C01E0782048204BFE48A849244A4248404BFE7888490800D0003000480184
+552A:00400040F7FC904093F8908097FC911092489446F1F0904007FC004000400040
+552B:0040004078A049104A084C0649F0484048404BF878404A48014801500FFE0000
+552C:00400040787C48404BFC4A444A704BC04A444A3C7A004AF0049004920912120E
+552D:008800887BFE4888488848F84888488848F8488878884BFE0000008801040202
+552E:090008800FFC10803FF850809FF810801FFC00001FF81008100810081FF81008
+552F:00A00090788049FE49104B104DFC4910491049FC79104910011001FE01000100
+5530:000207E27422542A57EA548A548A548A57EA56AA76AA5AAA0AA212E2008A0084
+5531:01F80108790849F84908490849F848004BFC4A047A044BFC0204020403FC0204
+5532:000000407B9C4A044A044B9C4A044A044BFC489078904890009001120212040E
+5533:004000207BFC4A044A044BFC4A004A284A244BFE7A204A500250048805040A02
+5534:02080108F11097FC9040904093F8904090809FFEF1209120022002220422081E
+5535:004000807BFC49104A484C464BF84A484A484BF84A487A484BF800420042003E
+5536:0088008878884BFE488848884FFE480049FC4904790449FC0104010401FC0104
+5537:004000207BFE488049044BFE480249FC490449FC790449FC0104010401140108
+5538:0040004078A049104A884C4648004BF048104820784049240522050A090800F8
+5539:0108008878084FD44A144A224A004BC84A444A447A404A500248044405440880
+553A:0090009078904BFC4A944A944A944BFC4A944A944A947FFE4800009001080204
+553B:0040004078404FFC48404A484A484A484D5448E0795049500248044408420040
+553C:008000407BFC4800490848904FFE484048404FFE788849080090006001980604
+553D:01000106F138912097A09120913E932493A49564F52499240124012401240144
+553E:00100078F3C09040904097FC9248924897FE9248F24897FC0040004007FC0000
+553F:01000100F3FC9494989491249244948491289210F0409124052A050A08F80000
+5540:000003FE7A104A104AFE4A104A104BFE4A004A107A104AFE0210041005FE0800
+5541:000007FCF444944495F49444944497FC940495F4F514951405F4040404140808
+5542:00E80F08E228A928A548A008A7C8A088A108A108E1E8AF08010A010A050A0206
+5543:00200120793C492049204FFE48004BFC4A044BFC7A044BFC0204020402140208
+5544:000003FE7840488049444A2448684AB049304AA8786848A40122022000A00040
+5545:00200020783E482049FC490449FC490449FC492448207BFE4820002000200020
+5546:020001007FFC082004403FF820082448282837D82448244827C8200820282010
+5547:020001007FFC082004403FF821082FE8210827C82448244827C8200820282010
+5548:0020002079FC482048204BFE4888485049FC482078204BFE0020002000200020
+5549:011001107110511057BC51105110533853B85554755459920110011001100110
+554A:00000EFCEA08AA08AAE8AAA8ACA8AAA8AAA8AAA8EAE8AAA80C08080808280810
+554B:0008003C7BC048444A244928490048204BFE487078A848A80124022204200020
+554C:0040002078204BFE4A024C9449084A04480049FC782048200020002007FE0000
+554D:004000207BFE480049FC490449FC480049FC480878104BFE0020002000A00040
+554E:200021FE20203E2049FC8844084409FEFE00080008FC08840884088408FC0884
+554F:00007CF844887CF844887CF8400840084FC8484848484FC84848400840284010
+5550:00800040F7FC90009110911092A8944490009040F7FE90400040004000400040
+5551:002000207BFE482049FC48244BFE482449FC48207920493E012002A0027E0400
+5552:000003FE7A024A024BFE4A104A924A924A924AFE7A104A920292049204FE0802
+5553:104008403E7E228823483E5020204058418680001FF01010101010101FF01010
+5554:104808443E7E23C022243E282212206A418680021FF01010101010101FF01010
+5555:0100010079FC4A044D0449E44A8448844FF448847AA44AA403E4000400280010
+5556:00400244F244944890A091109608904490409248F248945000A0011002080C06
+5557:0080008078F849084A104C0048404B9C4A044A047B9C4A040204020403FC0204
+5558:00800040F7FE94029A04920093BC94A494A496A4F9349128022202220422081E
+5559:04400440244427582460244224422F42F03E00003E7C2244224422443E7C2244
+555A:00001FF0101010101FF00100FFFE02003FF8200827C8244827C820083FF82008
+555B:002000207BFE482049FC48244BFE482449FC48407BFE488401C8003000CC0302
+555C:000007BC708452945108529454A45840500057BC70A452A40128029004A80846
+555D:000001807700511E51125FD2511253125392535275525512091E011201000100
+555E:000007FE7890489048904B9C4A044A044A044B9C789048900090009007FE0000
+555F:082004203F20213E214421443F4420A420283F283110511051289F2811440082
+5560:060C3870204020403F7E244824482448448881001FF01010101010101FF01010
+5561:00900090F090979E909090909090939C90909090F090979E0090009000900090
+5562:000003FE782048204BFE4A224A224B324AAA4AAA7B764A6602220222022A0204
+5563:0400040077DE5912511251125FD25112511255D27512551A05D41E1008100010
+5564:004000807BFC4A244A244BFC4A244A444BFC489079104FFE0010001000100010
+5565:0040004078A049104A084DF6484048404FFC484078404BF80208020803F80208
+5566:012001107110517E57805104514451C4512453247528512801080110057E0200
+5567:002000207BFE482049FC48204BFE480049FC4904792449240124005000880304
+5568:002000207BFE482049FC48204BFE480049FC490479FC490401FC010401140108
+5569:01100110F7D09110911091189FF4901291129110F7D09110011001D00E100410
+556A:021002107220527C5FC45244524452C4537C5E4472445244024402440A7C0444
+556B:004000447BF4484848504FFE4840488049F84B087D0849F80108010801F80108
+556C:010001007FFC010011100920FFFE00003FF8200827C8244827C820083FF82008
+556D:0210021072105FBC52105510557E57905120513C71C45F080528011001080104
+556E:00400040F27C9240924092409FFE900094449444F4A494940514040407FC0004
+556F:000003FE7A024A024BFE4A224A224AFA4A224A327A2A4BFE0202020203FE0202
+5570:000003FE7A524A524A524BFE4820484048FC49047A8848500020004001800600
+5571:002001247924492449FC480048004BFE4840488078FC49840284048400FC0084
+5572:0088008879084BDE4A524A624A424A524BCA4A4A7A424A42024203C202540008
+5573:00400248F15097FC908091009FFE921094089BF4F212921002500224020401FC
+5574:01040088785049FC4924492449FC4924492449FC7820482003FE002000200020
+5575:00100410721052FE58925494549052FC52A454A47CA854A80490052805440282
+5576:004000207BFE4A024C0448004BFE482048204920793C492002A00260043E0800
+5577:0100009E7BD24A524A544BD44A584A544BD24A127A924A5A02D4035002100010
+5578:004000407BF848484FFE48484BF848404A484A487AE84B580248024804480848
+5579:000003FC7A044A044BFC4A204A204BFE4A204A207AFC4A840284048404FC0884
+557A:000001FC790449FC490449FC48004BFE490049FE7A4A4C920122024200940108
+557B:01003FF8082004407FFE41029FF411101150112001003FF8200820083FF82008
+557C:0040002079FC4800488848504BFE4A224C2449FC492479244934012800200020
+557D:004000A079104A084DF648004BF84A084A084BF87910491007FC011002100410
+557E:008801C877085108512A512A57AC514853085388755455140914012401240142
+557F:008800887BFE488848F8488848F8488848884BFE790049480184010001FE0000
+5580:004000207BFE4A02488048F849084A90486049987E0649F80108010801F80108
+5581:01FC0124792449FC4924492449FC482048204BFE7A224A2A02FA020A02020206
+5582:000003F87A484A484BF84A484A484BF848004FFE7A404A440228029003080206
+5583:00400040F7FC9040904097FC951494A495F49444F44495F40444044404540408
+5584:082004407FFC01003FF801007FFC11100920FFFE00001FF0101010101FF01010
+5585:000001FC790449FC490449FC4904484048204BFE780049040088000007FE0000
+5586:101010101010FEFE101010107C7C000000007C7C44444444444444447C7C4444
+5587:0104010477C45104511457D45554555457D45114739455540944010401140108
+5588:022002247BA84A304AA24B224A5E48804BFC4A047A044BFC0204020403FC0204
+5589:010001787108520852FE56405A40527C5290521072FE52100228022802440282
+558A:00140012701057FE5410541055D05412541255D47554554805DA042A08461082
+558B:0048014879484BFE494849484978490049FE48207BFE487000A8012406220020
+558C:00007EFC428442847EFC00001008110811085548532891082108210841088108
+558D:009000927AD44A984A924AD24F0E482048204BFE787048A80124062200200020
+558E:000001FC7904490449E4492449244BFE4A024AFA7A8A4A8A02FA0202020A0204
+558F:01080108F7FE91089148904097FE9080910093FCF50499040104010401FC0104
+5590:0100011E77F25112521453D4525856545BD25252725253DA02540250025002D0
+5591:008000407BFC4800490848904FFE480049F84908790849F80108010801F80108
+5592:0088008879EC492A4A284D484888497E4E0049FC7904490401FC0104010401FC
+5593:000003FE785048504BFE4A524A524BFE480048404FFE78884990006000D80304
+5594:000003FC7A044A044BFC4A004BFC4A404A884BFC7A244A2005FC0420082013FE
+5595:000007FE784048804BFC4A944A944AF44A944A947AF44A940294029403FC0204
+5596:010801087108510857BE510853085388557E55227922512201220122013E0122
+5597:000003FE7A2248204BFE482049FC492449FC492479FC482003FE002000200020
+5598:00400444F444944497FC90009FFE9040908097FCF4A494A404A404A404A4040C
+5599:010001F8F20893F0901097FE90809144966890B0F128966800A4012206A00040
+559A:01000100F3F09410982097FC940494A495149444F0409FFE00A0011002080C06
+559B:003C07C07A44492848004BFC488048804FFE490079F84A880250042008D80306
+559C:01007FFC01003FF800003FF820083FF80820FFFE00003FF8200820083FF82008
+559D:000003F87A084BF84A084BF849004BFC4C444A447AA44A0403F4000400280010
+559E:008001007BDE4A524A524BD24A524A524BD248127A5A4B940210025001D00010
+559F:000003FE7A224BFE4A224BFE480049FC490449FC790449FC0104010401140108
+55A0:0008003C79E048204BFE482049FC492449FC492479FC482001FC002003FE0000
+55A1:0040004079FC48844BFE480049FC490449FC48207BFE4820022003FE00200020
+55A2:0004001E7BE0482048204FFE482048A04B2E4A227A224BAE0222022203FE0202
+55A3:0100010079FC4A044C0449E44924492479E44804002800102488224442448004
+55A4:0020004079FC490449FC490449FC48004BFE4820782049FC0020002003FE0000
+55A5:004000207BFE4A484A484BFE4A484A784A004AFC7A444A480228041004680986
+55A6:00001FF0101010101FF000007D7C454445447D7C01002108210821083FF80008
+55A7:004000207BFE4A024C0449FC480049FC490449FC790449FC0104000003FE0000
+55A8:00800040F7FE900093F8920893F8900097FE9402F9F49110011002120412080E
+55A9:01C000A079104A084DF648004BCA4A4A4A544BD47A684A5403D4024A024A02C0
+55AA:010001007FFC01003D7825483D780100FFFE1200111010A010401430180E1000
+55AB:0080009E7BEA488A49CA488A4BEA489248A648207BFE48200050008801040602
+55AC:00F83F000200FFFE04400FE03458C7C600003FF8200827C8244827C820282010
+55AD:004000207BFC4800490848904BFE4A104A204AC87A104A2402C8041004600980
+55AE:00007EFC428442847EFC00003FF821083FF821083FF80100FFFE010001000100
+55AF:002000207BFE485048A849244AFA482048A848887BFE48880088008801080208
+55B0:0040004078A049104A884C464BF84A084BF84A087BF84A440228029003080204
+55B1:000007FEF40095FC9524952495FC9524952495FCF420942005FC0820082013FE
+55B2:011001107210529E54A25F2251425212548A5FCA744250020A82094211540008
+55B3:00400040F7FC90E091509248944693F8920893F8F20893F8020800000FFE0000
+55B4:0014001277FE5410541057F05492549257D2555475545488054A0A1A08261042
+55B5:008800887BFE48884888480049FC49244924492479FC49240124012401FC0104
+55B6:2208111000207FFE400280041FF0101010101FF000003FF8200820083FF82008
+55B7:002001FC782048884BFE4888480049FC49044924792449240124005000880304
+55B8:012001107FFC01003FF821083FF821083FF8210800007C8844B044C47C84447C
+55B9:00400040F7FC90A0911092489DF69040904097FCF000904003F8004000400FFE
+55BA:0106017871105222524456F85A14522252FE5212721052540292031202500220
+55BB:004000A079104A084DF648004BC44A544A544BD47A544A5403D40244025402C8
+55BC:0080008079F84A084C104BFC480449FC48044BFC780448400124052A050A08F8
+55BD:0020012478A848204BFE48A849244A0248404FFE788849080190006001980604
+55BE:2208111000207FFE410291041FF021000100FFFE00001FF0101010101FF01010
+55BF:00001FF0101010101FF000007C7C444444447C7C01007FFC05401930E10E0100
+55C0:10001078FE4810487C480086FE0082FC00447C4400287C28441044287C444582
+55C1:0004001E7BF04A1E4A104AFE4A924A984AF24A8E7A804AB802A804AA054A0A86
+55C2:0008003C7BC048044A44492849FC4A2048204BFE782049240124012401FC0004
+55C3:004000207BFE480049FC490449FC48004BFE4A027AFA4A8A02FA0202020A0204
+55C4:07FC0080F3F8920893F8920893F8920893F89080F1F8931004A0004001B00E0E
+55C5:004000807BF84A084BF84A084BF84A084BF8485078484FFE00A0011002080C06
+55C6:00400040F0A09190924897FE9A0893F8920893F8F20093F80508050809F80108
+55C7:010001007FFC111029284544FFFE00003FF8200827C8244827C820083FF82008
+55C8:012402487A4849244BF84A084BF848004BF84A487A484BF80202020201FE0000
+55C9:002000207BFE482049FC48204BFE4840488849F078244BFE0022012402A20040
+55CA:000001FC782048204BFE480049FC490449FC490479FC490401FC008801040202
+55CB:004001FC7844489449084BDE494A494A4A9449FC790449FC010401FC0104010C
+55CC:02080108F110900097FC900091109208940493F8F2A892A802A802A80FFE0000
+55CD:0440025E7292501257D2511E55525552555257DE7152511202120222042A0844
+55CE:000001FE792049FC492049FC4920492049FE48027AAA4AAA02AA020200140008
+55CF:008800887BFE488848A84850488849244A2249FC782048A80124022200A00040
+55D0:004000207BFE4A024C2449FC482049FC48204BFE782049FC0104010401FC0104
+55D1:0020002079FC482048204BFE488049044BFE48027BFC4A940294029407FE0000
+55D2:01100110F7FC9110904090A09110920895F69000F00093F80208020803F80208
+55D3:03F00110F0E09318900097BC94A4931894A49040F7FC90E0015002480C460040
+55D4:00400040F7FC904093F8920893F8920893F89208F3F892080FFE011002080404
+55D5:000003FE7A004AFC4A004BFE4AA84A904AC84A867A084BFE0288044804080818
+55D6:0140065CF4449444975C9444944497FC904097FCF208911000A0004001B00E0E
+55D7:000001FC790449E449244BFE4A0249FC490449FC790449FC0104010401140108
+55D8:001E03E0792248944840488849F0482048C449FE7822482003FE005000880306
+55D9:004000207BFC490848904BFE4A024C4448204BFC788048F80088010801280210
+55DA:0040008079FC4904490449FC490049FE490049FE78024AAA02AA040200140008
+55DB:0108009078004BFE48A04BFC48A44FFE48A44BFC78A049B002A80CA600A000A0
+55DC:0040004479F848504BFE484048F849824A7E4C0079FC490401FC010401FC0104
+55DD:00000FFEF00093F89208920893F8900097FC9514F4A497FC0444044404540408
+55DE:0084004478484BFE488448844908494A4A524B9C788449080108025203DE0042
+55DF:0108008878904BFC484049F848404BFE4880490079FC4A200420082003FE0000
+55E0:0E40F04022789288555000207C500888110610F81E88F0885088108850F82088
+55E1:0090008879044A424C8849FC480448004BDE48427A52494A02520042014A0084
+55E2:000001F87908490849F84908490849F848004BFC7A944A940294029407FE0000
+55E3:00003E7C220422043EF400047F045574555455547F5455545574550451144308
+55E4:00200124792449FC48204BFE4800482049FC4924792449FC0020002403FE0102
+55E5:00400080F3F8920893F8920893F8908097FC9110F24894440BFA004000400040
+55E6:00400040F7FC904097FC9484991893E090409088F7FC90440250044809480080
+55E7:10007E7812482A48457882800C6037D8C0063FF8248824883FF8248824A82010
+55E8:00800880E4FEA100AAFCA484A4A4A094A3FEA484ED24A51405FE040404280010
+55E9:0020012478A8482049FC4904490449FC490449FC4904790449FC000000880104
+55EA:00400040F7FC904093F8908097FC9110926895C6F04093F800E0015806440040
+55EB:000003FC790849F8490849F8490E4FF848084FBC78A44AA40128029004A80846
+55EC:01100110F7FE9110910092FE920896089AE892A8F2A892E802A8020802280210
+55ED:01007FFC01001FF010101FF010101FF010101FF01010FFFE00903EE422843E7C
+55EE:000000FEEE28AA28AA28AAFEAAAAAEAAAAAAAAAAEAAEAAC20E820A8200FE0082
+55EF:000007FCF444944497FC944494A49514940497FCF04090240522050A090800F8
+55F0:020003FC752455245D2455FC5524552455745554755455540574050405FC0504
+55F1:00200050788849744A0248F8488848F8480C49F0782049FC002003FE00200060
+55F2:00900108F29490609198964690FC930890B090D0F73E90C20324001800600780
+55F3:000E03F078444A2449084BFE4A4248404BFE488078FC49440128021004680186
+55F4:010800907BFC4840484049F8484048404BFC48A078A848B4013C01220222041E
+55F5:01FC0808E450A420A1FCA124BD24A5FCA524A5FCE524A524052C0A0011FE0000
+55F6:000001FC792449FC492449FC48A848A84BFE48A878A849FC002003FE00200020
+55F7:01080108710857D0511E579451245FD4521453D472545248024804D404240842
+55F8:08207F20087E7E4408A4FF2810101E282244468280003FF8200820083FF82008
+55F9:0020082075FE542051FC51245DFC552455FC542075FE542004200A2011FE0000
+55FA:002002227BFE4890488849FE4B104D1049FE4910791049FE0110011001FE0100
+55FB:004000207BFE4A004A484A484BFE4A484A484A487A784A000554052A0A2A1000
+55FC:008800887BFE4888480049FC490449FC490449FC78204BFE0050008801040202
+55FD:01080108F7C89108911E97D29564954097C89108F38895480954011401240142
+55FE:04200220723E5F4054A05420573C55505510551075FE5510052809280B441082
+55FF:004000A079104A484DF6482048404BF84A084BF87A084BF8020803F801100208
+5600:00800040F7FC911090A097FC944495F4944495F4F514951405F4040404140408
+5601:00140012701057FE5410549054D2549257F25494749455C80AAA089A11A60042
+5602:0040785E48524A524A524A527A5E02407A5E4AD24B524A524852785E48520040
+5603:002007FE742055FC542457FE542455FC542055FC752455FC052409FC0924112C
+5604:010003F87A084BF84A084BF84A004BFE4A004BFE78424FFA0164065818460040
+5605:000007BE7488548857A854A854A857BE54105518749855A806AA044A00460080
+5606:01100110F7FE911091F0904093F8924893F89040F7FC90400FFE00A00110060C
+5607:00800110F3F8921094A49FBE904290A093189C46F19096640188063001C00E00
+5608:00A000A077FE50A057FC54A457FC54A457FC500073F8520803F8020803F80208
+5609:0100FFFE01003FF800001FF010101FF00820FFFE10007F7C11442144457C8244
+560A:002002227A224BFE48004BFE4A204BFC4A204BFE7A004A2005FC04200BFE0000
+560B:02080248E748A290A29EAFE4A114A214AFD4A494E914A1C80F08011405140222
+560C:00000FFEE0A0A7FCA4A4A4A4A7FCA000A7FCA000EFFEA0400248044409420080
+560D:004003F8F2489FFE924893F8904093F8924893F8F0809FFE011000E003180C04
+560E:07FC00807BF84A084BF84A084BF84A084BF84910797C4F800090006201B20E0E
+560F:100011DC11441144FD4411DC110011007DDC4514451445D445087D0845140122
+5610:000007BCF08494A4929494A490509188962690C0F31090640388003000C00700
+5611:0040007C78404BFE4A424A784BC44A3C4A084AF07B244AA805FE042008A00040
+5612:008803DE788849DC48884BDE488848004BFC4804780449FC0004000403FC0004
+5613:00000FFEE82AA826AFFEA822ABAAAAAAABAAA832E996AE2E084608820FFE0802
+5614:000003FE7A004A7C4A444A444A7C4A004AEE4AAA7AAA4AAA02EE020003FE0000
+5615:000007FCF040927892409FFE910091FC920093FCF00495540554080400280010
+5616:002003FE782049FC48204BFE480049FC490449FC790449FC010401FC00880104
+5617:111009207FFE50129FF4000020F03F0420041FFC00001FF810081FF810081FF8
+5618:0040007C78404BFE4A424A784BC44A3C4A004A507A544B5404D8045009FE0000
+5619:04100210E8FEA492A2FCA4A4ACA8A510A528A6C6E080AFFE0110032000E00718
+561A:0200027C7444597C5144527C56005AFC520853FE720852880248020802280210
+561B:00400020F7FE94909490949097FC949094D895B8F5B496D40892089010900090
+561C:004007FC7150515052E8544450E053585C46508071F8520804D0002000D00708
+561D:0204020477845494590C57C45564555457C45546757C57C405440544044408C4
+561E:0290029077D0529053BC511457D45554555457D4711457D40124012401540188
+561F:0200023EEF62A264A2A4AFE8A124A224A7A2ACA2F4A2A7B404A804A007A004A0
+5620:07FC0080F3F8920893F8920893F8920897FE94A2F89C97F00050002400D4030C
+5621:0020012478A84BFE4A0248F84888488848F84820782049FC0020002003FE0000
+5622:000007DE7542555457C85544557E57CA510A510877C85108010801C80E280410
+5623:00400444744457FC500057BC54A454A457BC54A474A457BC04A404A40AB41148
+5624:00000FBEE8A2AAAAAAAAAAAAA514A8A2A080AFFEE110A21003A0006001980E04
+5625:021002107450595C5150525056FE5A0052105250725C525002B00290030E0200
+5626:3FF820083FF8101020085FF404403FF824483FF80400FFFE08201E4003C03C38
+5627:00800040F7FE9402989490509524954A98FA9300F04094440444044407FC0004
+5628:0040004077FC50445FFE504457FC5040555454E4744457FC04E409540A4C1044
+5629:008803FE7888480049FC48A848A84BFE48A848A879FC482003FE002000200020
+562A:000003FE7A524A524BFE480049FC490449FC490479FC490401FC008801040202
+562B:0110011479D24A504A7E4D5048904AA8492849447A444C82000802A402520452
+562C:000003F8F20893F8920893F890009FFE948097BCF494979404D40F88009400A2
+562D:0104010477E85110510057C4500457C85450544277C25444028400E80F100420
+562E:008802AA7ADC4C8849544A2248004BFE4A424C447BFC48440044008401140208
+562F:004003F8F04897FE904893F890409554975C9444F7FC9444075C055405540844
+5630:024802487554575C52485554575C52485FFE52207228522805140494042C0844
+5631:000007FCF40497FC940095FC942095FC952495FCF42097FE062A06FA0A0A1206
+5632:0200023C0FA4E224A224AFBCA8A4AFA4A8A4AFBCA224E224AFA402240244028C
+5633:002001FC792449FC48204BFE480049FC490449FC790449FC010401FC00880104
+5634:00900294F2D8929292D2970E91F0921097FC9A44F3FC924403FC044404540808
+5635:0020002079FC48204BFE49084B9C490849884E3E78004BFE009000900112020E
+5636:04800482E49CAFD0A490A790A49EA794A494A494EFD4A014051408A410240044
+5637:004001FC790449FC490449FC490449FC4820492478A84924002003FE00200020
+5638:0080008079FE4B544D5449544BFE4954495449544FFE78004954012A022A0000
+5639:00400040F7FC90A09514920897FC9A0A93F89208F3F890400248044409440080
+563A:003803C0F08097FE9110920895F6991091F09000F7FC940405F4051405F4040C
+563B:004007FCF04093F8900093F8920893F891109FFEF00093F80208020803F80208
+563C:3E7C22443E7C00003FF821083FF821083FF80000FFFE00003FF820083FF82008
+563D:000003DE7A524A524BDE480049FC492449FC492479FC482003FE002000200020
+563E:000003FE78504BFE4A524BFE480049FC490449FC790449FC002003FE00200020
+563F:000007FCF444955494E4944497FC904097FC9040F0409FFE0000052404920892
+5640:000003DE7A524BDE4A104A5249CE480048884BFE7888488807FE008801040202
+5641:000007FEF0909090939C92049204939C90909090F7FE90400524050A090A00F8
+5642:01080090F7FE909093FC9294931C920493FC9204F3FC900807FE010800A80010
+5643:003C03E0792448A84BFE48A849244A0249FC4924792449FC0124012401FC0104
+5644:008003DE788A49CA488A4BD248A64840488849F078244BFE0022012402A20040
+5645:0004003EF7C09244912893F8920893FC920493FEF40296AA0AAA0A0210140008
+5646:000007BC7108552857BC531855AA5946500053F87208520803F80208020803F8
+5647:002001FC788848504BFE480049FC492449FC492479FC482001FC002003FE0000
+5648:04140212EF92A010A07EAF90A890A890AF90A228EB28AAA81228024A0A4A0486
+5649:00080788708851105FDE549454A4579454945794749454C807880C9400A400C2
+564A:000003FC784848304BFE485248944B5048204BFE7A524A8A0376025202720206
+564B:0208010877C85010579E549457A4501457945094711451C80708011405240242
+564C:02080110F00097FC9444955494E4944497FC9000F3F8920803F8020803F80208
+564D:01400120F3FE922096209BFC9220922093FC9220F22093FE0200052404920892
+564E:002003FE782049FC48004BFE4A0249FC480049FC790449FC0104008803FE0000
+564F:004000A0F11896E6900093F8920893F8900097BCF08494A4029404A402940108
+5650:00003E7C224422443E7C00003FFC010001007FFE00003E7C224422443E7C2244
+5651:0020004079FC490449FC490449FC4820492448A87924482003FE002000200020
+5652:0020012478A84BFE48A849244A224904490449DE7A444D54009E010402040404
+5653:0040007C78404BFE4A424A784BC44A3C4A004A507B544B5405DC04500BFE0000
+5654:002007A4F0A892929114920895F4980293F89208F20893F8020801100FFE0000
+5655:00F83F2009401FE010201FF010101FFC20042AA4400CBFF8200820083FF82008
+5656:00000FBEF208971C92089FBE904090A093189C46F02093F80008001000200040
+5657:00A004A4F2A890A097FC911090A097FC904093F8F04097FC00A0011002080C06
+5658:00000FFEE800AA28A948ABEEA892A884AAA0AAA8EBE8A8880894091409241242
+5659:004000A0F11092489DF690A0924892A893F89040F7FC9484052405F40414040C
+565A:000003FC78044BFC48044BFC48004BBC49244FBC78084BFE0108008800A80010
+565B:00200020793C492049204FFE480048204AAA4A227BFE4A7202AA022203FE0002
+565C:010003F0F4109FFC944497FC944497FC90009FFEF00093F8020803F8020803F8
+565D:01080108E214A294A4BCAF08A110A224A4BEAF8AE088A02C0AAA0ACA08280010
+565E:00400040F0A09110920895F6980097BC94A494A4F7BC92100210052809441082
+565F:010000803FFE224824FE2D9036FC249024FC249024FE24804FFC48048FFC0804
+5660:001004107A7C481048FE48444E284AFE4A104A7C7A104AFE0210021005FE0800
+5661:010001F87A084FFE4A884B244BFE4A004AFC4A007AFC4A0002FC048404FC0884
+5662:00800100F7FC94449554944497FC94E495549404F04097FE00A0011002080C06
+5663:000003F87AA84AA84BF849004BFC4C844BE44AA47AA44BE4009407F400140008
+5664:01100110F7BC911093B895549912900093F89000F7FC90400248044409420080
+5665:009003FC7A944BFC4A944BFC48004BFC4A004AF87A004BFE0520051405480986
+5666:0020013C79204FFE481048144BFE4A104BF04A547A544AD40368044A08960322
+5667:008800887BFE488849FC492449FC492449FC48207BFE4A22022A02FA020A0206
+5668:00003E7C224422443E7C01200110FFFE02800C603018C0063E7C224422443E7C
+5669:00007FFC01003D78254825483D7801007FFC01003D78254825483D780100FFFE
+566A:03F80208F20893F8900097BC94A494A497BC9040FFFE91600250044818460040
+566B:008000407BFC490848904FFE48004BFC4A044BFC7A044BFC00400524050A08FA
+566C:02100210F3DE95289884900097FC904092489248F248955408E200400FFE0000
+566D:0108020877C8545057DE546457D45214511457D4721453C802480454055408A2
+566E:000003FC7A944A944BFC48004FFE48004BFC4A047BFC48A2011403080D440182
+566F:003C03C070445224510857FE544252A4528A547A708050F8010802900060079E
+5670:0040002077FE50285224527E54C85748517E524874C8577E01480248047E0840
+5671:0040007C78404BFE4A424A784BC44A3C4A004BFE7A404BA4025805B4045209B0
+5672:004000A0F3189DF6900097FC955494E497FC9000F3F8920803F8020803F80208
+5673:0020003E78204BFE4A224BF84A224AFE4A844AFC7A004AFC022005FE04480986
+5674:002001FC782048884BFE488849FC490449FC490479FC490401FC008801040202
+5675:211017FE108003F8F20813F8120813F8120813F8280047FE00003FF820083FF8
+5676:008803FE788849FC490449FC490449FC488049FE7A224D52010201FA000A0004
+5677:021001107790503E54A253445F9050105790549077A854A804A807C400440082
+5678:0200023EE208BFD0A23EAAA2AAA2AABEAAA2AFBEE222A22202BE030002140022
+5679:00400248F15097FE9402980493F8920893F89000F7FC944407FC044407FC0404
+567A:0200010277DC50105450529057DE5114511457D4711455940554092405240244
+567B:00800040F7FE95129BFC911097FC911097FE9110F24895F40842004007FC0000
+567C:00100008778854BE548054945788547E5408578876BE5A880A880B8812880008
+567D:0800FF0008FE7E1000107E3042387E542492FF1000107E10421042007EFE4200
+567E:004000207BFE4A8A49444A2249FC48884BFE480079FC490401FC010401FC0104
+567F:03DE00427A52494A4A5248204BFE4888488849547A22482003FE002000200020
+5680:004000207BFE4A224954494A4A3A480049FC49547BFE480001FC002000A00040
+5681:000003DE78424A52494A4A52489049084BFE4D1079FE491001FE011001FE0100
+5682:001007D0751057DE545057E8550457C4500053F872A852A802A802A80FFE0000
+5683:040002FE7AAA48AA48FE48104E544A924A104A547A924A100210050008FE0000
+5684:008803FE78A8489049FE4B2049FC492049FC492079FE490003FC00880070038E
+5685:000007FCE040AFFEA842A358A040A358A000AFFEE040A7FC04A404A404A4040C
+5686:010807FEF108902097FE900091F8910891F89000F7FE940205FA050A05FA0406
+5687:01100110711057BC511051105FFE52A852A856EC7AAA52AA02A805A804480898
+5688:00000FFEE808ABC8AA4CABCAAA48ABDEA808ABC8EA48ABD40A540BD40A5412E2
+5689:02840284EAA4A6C4A29EAFE4A004A454A28CAFE4E104A7C4010401C40E140008
+568A:008003F8F20893F8920893F8900097FC944497FCF44497FC00000FFE01100210
+568B:004007FC704053FC500057FE500253F8504057FE700057FE000807FE04A80798
+568C:0080004077FC511050A45F58555455525B585000720853F8020803F802080408
+568D:004003F8704857FE504853F8504057FE500052A4745253F802A802A80FFE0000
+568E:004007FEF00091F8910891F8900097FE940293F8F180964401B8066801A60E60
+568F:004007FCF04097FE94029BFC924893F8924893F8F00097FC02440278054008FE
+5690:012400A87BFE4A8A48F8490C49F0490248FE480079FC490401FC010401FC0104
+5691:003C07C0F0409FFE904097FC955494E497FC9040F7FC90400FFE000005240892
+5692:0040002077FE548857DE548855DC56AA54885440748855F00420044809FC1084
+5693:0080004077FE54025A2453BC54A45AA8551052E874045BFA00400248044400C0
+5694:004007FC704057FE54025BFC524853F8524853F8710857FC02440278054008FE
+5695:010003F074105FFC544457FC544457FC5524589273F8520803F8020803F80208
+5696:008803DE788849DC48884BDE48884BFC480449FC78044BFC004002A4028A047A
+5697:03F80208F3F8920893F8911097FC91109FFE9110F248955400E00150024800C0
+5698:07FC0080E3F8A208A3F8A208AFFEA882A548A514E8F4A10003F8050800F00F0E
+5699:00200120793C49204FFE48904A944B6C4A044BFC7A944A94036C020403FC0004
+569A:00003E7C22443E7C00003FFC21003FF820083FF821003FFC00003E7C22443E7C
+569B:044404E4E8A8AAAAAEEEA4A4AAAAAEEEA242A040EFFEA0E0015002480C460040
+569C:01FC012479AC492449FC482049FC48204BFE49547A2A482001FC002003FE0000
+569D:0040002077FE548855FC548857FE542055FC552475FC552409FC088811040202
+569E:0100FFFE01007FFC00003FF820083FF81010FEFE10107C7C00007C7C44447C7C
+569F:0090031EF12A97CA910A93929522995690889124F22294A8007001AC06220060
+56A0:020205E274A256AA552A566A510A528A544A5BAA710A57CA0122054201EA0E04
+56A1:05080508EFBEA508A708A208AFBEAA80AA88AF88E23EAF8802080208023E0200
+56A2:01007FFC11101FF00100FFFE94522FE844441FF004407FFC05081890EA600C18
+56A3:3EF822883EF80000FFFE01001FF01010111002C00C30700800003EF822883EF8
+56A4:002007FE748857DE548855DC56AA548C55F0542075FC542007FE082008A01040
+56A5:0110011077FC511051F0520852EA56AC52A852AA76EA5A06000002A402520452
+56A6:000007FE74445598548857DE548855DC56AA548874205520053C0920092017FE
+56A7:0040007C78404BFC4A444BF04A444AFC4AA84AF87AA84AF8020005FC05540BFE
+56A8:0210011077DE5010545E528257DE501057DE545077DE545007DE0450045204CE
+56A9:04140412E9FEAA10B2FEBC92A4FEA892B2FEBE92E20481FE2A442A242024000C
+56AA:03DE02527BDE4A524BDE4A424A7A4A8A4B124ADA7A8A4ADA028A02FA020A0204
+56AB:0400023CEFA4A024A8BCA524AFA4A23CA224AFA4E23CAB100A9812A80A2A0446
+56AC:0100013E750855D0553E55225FE2503E5122557E756255A208BE010002140C22
+56AD:0800FF7E08087E0800107E3442527E922410FF10007C7E44424442447E7C4244
+56AE:11002BDE4A5273D42A524BD27A1A12942350CA403FFC200427E4242427E4200C
+56AF:07FC0040F7FE94429B5C9040975C912093FC9620FBFC922003FC022003FE0200
+56B0:004000207BFE4A484BFE4A484AEC4B5A4A484BFE7A204A7C02C40344047C0844
+56B1:010801EC710A57E8552855DE572854EA540A57EA740C57EC0A2A0BEA115607E2
+56B2:200011DCFD5401547DDC44007DFC01247DFC092411FC1C20F3FE102050202020
+56B3:3AB821083AB82288393822887FFE400291041FF02100FFFE00001FF010101FF0
+56B4:3E7C22443E7C00003FFE20002E20223C3FA829482F2829282F1049D07F288144
+56B5:01F0021077FC520453FC522453B8522251FE521077FC524403FC00D0014A063E
+56B6:03DE02527BDE4A524BDE4A524BDE498C4A5248407FFE48880190006000D80304
+56B7:004007FCF00093B892A893B8911097FC911097FCF1109FFE012803100D480186
+56B8:00080FE8E928AB68A9AEA928AFE8A108AFE8A11EE112BFF200121552155E2012
+56B9:0820083CEE20B4FEA4A2A4B8BFE2A49EB582B5BCF5AAB79C18FF010801280210
+56BA:01FC095475FC5488505053FE5C4054A25534545875B45452059204500A2011FE
+56BB:00007BDE489249124BD24A527A5E03C07A5E4BD24A524A524BD2781E49920240
+56BC:003C07C07244512857FC54A457FC5008578854FE778854A80798050805A80690
+56BD:011007D0711E57A451545FD45208539454A25BFC720453FC020403FC01080204
+56BE:008803FE78884BDE4A524BDE48A0489049FE49207BFC4D2001FC012001FE0100
+56BF:010807FE712853FE522057FC5A2053FC522053FE7080531C0204039C020403FC
+56C0:02080208E27EAF88A23EAFAAAABEAFAAAABEAF8AE27EAF84027E02240214020C
+56C1:03FC010879F8490849F8490E4FF848084FFE4A947B9C4A94039C02D607BC0084
+56C2:3EF822883EF80000FFFE02001FF010101FF010101FF0082010103EF822883EF8
+56C3:04140212EFA0A53EA564AAA4A03EA224AFA4A23EEB24AAA412A4023E0A200420
+56C4:04180214EF90A53EAAA8ADE8A8BEAFA8A228AFBEEAA8AAA80BA808BE0AA00920
+56C5:0000EEFEAA82AA82EEFE00A4FEA492FEFEA492A4FEFE10A8FEAA112411321220
+56C6:008803FE788849FC492449FC49244BFE4A2A4AFA7A2649FC012401FC002203FE
+56C7:0FBE000077BC54A456B454A4504057FE54A057FC74A457FC051209DC091211CE
+56C8:010807FE71085390513C57D452B4555C5396512273FC500007FE0080010403FE
+56C9:000007FC74A454A457FC521052A854BE5F68523C74A85FBC00280AA80ABE0020
+56CA:01007FFC11101FF00100FFFE92921EF004403FF80440FFFE04880C503530C60E
+56CB:052807BE794857BE531855AA594653FC520453FC720453FC020403FC01080204
+56CC:01100FFEE510A400AF06B138AF88AA88AABEAF88EA9CAF9A0028154815480008
+56CD:10101010FEFE10107C7C00007C7C44447C7C2828FEFE00007C7C44447C7C4444
+56CE:00440E28EAFEAA92AED6AABAAAFEAE00AA7CAA44EE44A07C0A440944117C0044
+56CF:281029FEFE1028FC380010FC7C8454FC7C4811FE7C0010FCFE84288444FC8284
+56D0:010801ECE10AAFEAA928ABC8A93EAFE8A948ABE8EA28AB680AA80BF40AB412A2
+56D1:07FC040477FC552454A8552455FC555455FC564475F4555409F4084413F40008
+56D2:011007FE711057BC54A457BC54A457BC544457FC755455F4044404E405540448
+56D3:008003DE788A49D248A64BD0489C48504BFE48507AAA4BFE025202AA03FE0002
+56D4:004007FC724853F850405FFE5AAA53B8511057FC71104FFE012803100D480186
+56D5:0790051E77A8548457BE552A57BE500053F8520873F8520803F800A00124061C
+56D6:021007DEE928AFFEA912AFFEA228A444A9FEAF48E27EA5480F7E0048157E1540
+56D7:00007FFC4004400440044004400440044004400440044004400440047FFC4004
+56D8:00007FFC400440044FC44844484448444FC448044824482447E4400440144008
+56D9:00007FFC4004400440047F8440844084408440847F844084400440047FFC4004
+56DA:00007FFC4004410441044104410442844244444444244824502440047FFC4004
+56DB:000000007FFC444444444444444444444844483C5004600440047FFC40040000
+56DC:00007FFC400440044104410442044204444448245FF44814400440047FFC4004
+56DD:00007FFC400440044FE44044408441045FF4410441044104450442047FFC4004
+56DE:00003FFC2004200427E42424242424242424242427E4200420043FFC20040000
+56DF:0200020004007FFC40044824444442844104428444444824400440047FFC4004
+56E0:00007FFC40044104410441045FF441044284424444244814501440047FFC4004
+56E1:00007FFC4204420442047FFC444444444884468441044284444448247FFC4004
+56E2:00007FFC4004408440845FF4408441844284448448845084428441047FFC4004
+56E3:00007FFC4004408440845FF4408448844484448440844084428441047FFC4004
+56E4:00007FFC410441045FF44104492449244FE441144114411440F440047FFC4004
+56E5:00007FFC4004420441045FF44004400447C4444444444454483450047FFC4004
+56E6:00007FFC4004410441045D1445A445444924491451146504420440047FFC4004
+56E7:00007FFC40044444442448145014600447C4444444444444444444447FFC4004
+56E8:00007FFC40045FF440844104410443844544492451146114410441047FFC4004
+56E9:00007FFC400440044FE4400440045FF44204444448245FF4481440047FFC4004
+56EA:040008007FFC4004408448944514422445444884514442244C2440047FFC4004
+56EB:00007FFC4404440447F449544954525442944494491442A4444440047FFC4004
+56EC:00007FFC44444444444447C444444444444447C444444444444444447FFC4004
+56ED:00007FFC40044FE4400440045FF444844484448448944894507440047FFC4004
+56EE:00007FFC4504450449245944698449044F144914491448F4480440047FFC4004
+56EF:00007FFC400440045FF4410441044FE44104410441045FF4400440047FFC4004
+56F0:00007FFC4104410441045FF4410443844344452449145114410441047FFC4004
+56F1:040008007FFC4204420447F4481452244144408441444624580440047FFC4004
+56F2:00007FFC4444444444445FF44444444444447FFC44444444484450447FFC4004
+56F3:00007FFC40044104448442A45224484444444284410446C4583440047FFC4004
+56F4:00007FFC410441045FF441044FE441045FF4411441144154412441047FFC4004
+56F5:00007FFC41044104428444444824549C650446044424442443E440047FFC4004
+56F6:00007FFC400444444824511441044FE44104410441045FF4400440047FFC4004
+56F7:00007FFC400440E44F04410441045FF44304458449445124410440047FFC4004
+56F8:00007FFC400440045FF44104410449E44904490449045FF4400440047FFC4004
+56F9:00007FFC41044104428444444A24511C6FE4402440444284410440847FFC4004
+56FA:00007FFC410441045FF4410441044FE44824482448244FE4482440047FFC4004
+56FB:00007FFC40045FE4502450245FE451045FF4510450945454583440047FFC4004
+56FC:00007FFC42044204444448245FF440144FE4482448244FE4482440047FFC4004
+56FD:00007FFC400440045FF4410441044FE44104414441245FF4400440047FFC4004
+56FE:00007FFC4204420447E44C445284410446C4783C43044084460441847FFC4004
+56FF:00007FFC420442045FF444044FE4542467E4442447E4442444A444447FFC4004
+5700:7FFC400444444824521441045FF44404440447E44424482448A450447FFC4004
+5701:00007FFC41045FF440044FE440044FE440044FE448244FE4482440047FFC4004
+5702:00007FFC40044FE44204451459A442C444A459A4429444945A8441047FFC4004
+5703:00007FFC414441245FF441044FE449244FE449244FE44924496440047FFC4004
+5704:00007FFC40045FF442044FE444247FFC40044FE4482448244FE440047FFC4004
+5705:3FF00020064001807FFC444442845FF4410441047FFC4104410441047FFC4004
+5706:00007FFC40044FE448244FE440045FF45014511451145294444448247FFC4004
+5707:00007FFC4104428444444BA450144FE44AA44AA44FE44AA44AA448647FFC4004
+5708:00007FFC492445445FF442047FFC482457D4644C44C4442443E440047FFC4004
+5709:00007FFC410441044FE441045FF4444442844FE441045FF4410441047FFC4004
+570A:7FFC41044FE441044FE441047FFC40044FE448244FE448244FE4482448647FFC
+570B:00007FFC40A440947FFC40845E94529452A45EA4405446B4591440047FFC4004
+570C:00007FFC4104511451145FF440047FFC41045FF452945294503440047FFC4004
+570D:7FFC42044FE444245FFC40044FE448244FE441045FF4410451045FFC41047FFC
+570E:7FFC440448245FF440144FE448244FE448244FE448244FE4444448247FFC4004
+570F:00007FFC492445445FF442047FFC482457D4604C47C4442443E440047FFC4004
+5710:00007FFC40045FF4529452945FF441047FFC440447F44814505460247FFC4004
+5711:7FFC41245FF441044FE449244FE449244FE4492440445FF44844454440847FFC
+5712:00007FFC41044FE441045FF440044FE448244FE4411446A45A4442247FFC4004
+5713:7FFC40044FE448244FE440045FF450145FF450145FF450145FF4444448247FFC
+5714:7FFC41044FE441045FF4420444444FE440044FE44AA44AA45FF440047FFC4004
+5715:7FFC410441044FE441245FF441244FE441045FF448244FE448244FE440047FFC
+5716:7FFC40044FE448244FE441047FFC41045FF4501457D454545FF440047FFC4004
+5717:7FFC420444444FE441047FFC42045FF4545457D4545457D454545FF440047FFC
+5718:7FFC41045FF441044FE449244FE449244FE441145FF440445FF4484444C47FFC
+5719:00007FFC4444482457D441044FE44AA44BA44AA44BA44AA44FE440047FFC4004
+571A:7FFC41044FE449244FE441045FF448244FE448244FE448244FE4444448247FFC
+571B:7FFC40045FF452945FF441044FE441045FF4444442844FE441047FFC41047FFC
+571C:7FFC40045FF452945FF440047FFC40044FE448244FE445144CA4744446247FFC
+571D:0000FFFE800291129392A82ABBBA9012ABAAB83A8382AAAAABAA8002FFFE8002
+571E:FFFE9112A3A2B83A9392A82ABBBA8282ABAA8102BFFA854289229112FFFE8002
+571F:0100010001000100010001003FF80100010001000100010001000100FFFE0000
+5720:10801080108010801080FE80108010801080108016801884E0844084007C0000
+5721:0100010001000100010001003FF80100010001200110011001000100FFFE0000
+5722:1000100013FE10201020FE20102010201020102016201820E020402000A00040
+5723:00003FF0082004400280010006C01830E10E01001FF00100010001007FFC0000
+5724:10401040104010401040FE60105010481044104416401840E040404000400040
+5725:0100010001003FF8010001000100FFFE0440044004400440084408441044603C
+5726:12001100108010801040FC40104010A010A010A011101D10E208420804040802
+5727:00003FFE200020802080208020802FFC2080208020802080208040805FFE8000
+5728:020002000400FFFE080008401040304057FC904010401040104010401FFE1000
+5729:100011FC102010201020FC20102013FE1020102010201C20E020402000A00040
+572A:10401040108010FE1100FE0010FC10081010102010401C80E102410200FE0000
+572B:1008103C13C010401040FE401040107E13C0104016401842E0424042003E0000
+572C:200021FC200020002000FBFE20802080210021FC20043804E004400400280010
+572D:010001003FF8010001000100FFFE0000010001003FF8010001000100FFFE0000
+572E:1000100011F810081008FC08100811F81108110011001D00E102410200FE0000
+572F:100011FC110411041104FD04110411FC1100110011001D00E102410200FE0000
+5730:1020102010201120112CFD34116413A41124113411281D22E122410200FE0000
+5731:00200C2070201020102011FC1020FE201020102010201020202023FE40008000
+5732:1008103C11E010201020FC20102013FE1020102010201C20E020402000200020
+5733:11041124112411241124FD24112411241124112411241D24E124422402040404
+5734:10401040108010FC1104FD04120414841044102410241C04E004400400280010
+5735:10401040104010401040FE40107C10401040104016401840E040404007FE0000
+5736:010001007FFC0280044008203118C10601003FF80100010001000100FFFE0000
+5737:100013FE104010401040FE40105010481044104416401840E040404000400040
+5738:10201020102010201124FD24112411241124112411241D24E12441FC00040000
+5739:10401020102013FE1200FE0012001200120012001E00E2004200040004000800
+573A:200023F0202020402080F90023FC21242124212422243A44E444488401280210
+573B:1008101C11E011001100FD0011FE11101110111011101D10E110421002100410
+573C:00003FF8200820083FF8200820083FF8010001003FF8010001000100FFFE0000
+573D:11001100110011FC12A4FCA410A41124112412441C44E0844104020404280010
+573E:100017F8110811101110FD20113C1104110412881E88E2504420045008880306
+573F:10201020105010501088FD04120210881088108810881C88E088410801080208
+5740:10201020102011201120FD20113C11201120112011201D20E120412007FE0000
+5741:1004101E11F011101110FD10111011FE1110111011101D08E10A414A01860102
+5742:1008101C11E011001100FDFC114411441144112811281D10E110422802440482
+5743:1000100011FC10001000FC0013FE10901090109010901C90E1124112020E0400
+5744:200021F0211021102110FA0E240023F821082110209038A0E04040A003180C06
+5745:10201020105010501088FD4412221020100011FC10041C08E008401000100020
+5746:104010401040108010FEFD08128810881088105010501C20E050408801040202
+5747:10401040108010FC1104FE04108410441044101410241C44E184400400280010
+5748:1000100013FC12041408FC0011F011101110111011101D12E2124212040E0800
+5749:10201020102013FE1020FD2411241124112411FC10241C20E0224022001E0000
+574A:10401020102013FE1080FC80108010FC1084108410841C84E104410402280410
+574B:10101090109010881108FD04120415FA1088108810881C88E108410802280410
+574C:0440082010102FE8C4260420082010A0614001003FF8010001000100FFFE0000
+574D:100011F8110811081148FD281128110817FE110811081D08E108420802280410
+574E:10801080108010FC1104FD0812401440104010A010A01D10E110420804040802
+574F:1000100013FE10101010FC2010201068106410A41D22E2224420002000200020
+5750:01001110111011101110292825244544810001003FF8010001000100FFFE0000
+5751:10801040104013FC1000FC0011F011101110111011101D12E1124212020E0400
+5752:2080208820B03EC0208020842684387C210001003FF8010001000100FFFE0000
+5753:0820082008207FFC08200820FFFE10202020412001003FF801000100FFFE0000
+5754:010001047D880550092011102108C5060200010001003FF801000100FFFE0000
+5755:00781FA01120112011201110211021084004010001003FF801000100FFFE0000
+5756:00003FF800000000FFFE044004420842303EC10001003FF801000100FFFE0000
+5757:10401040104013FC1044FC441044104413FE104010A01CA0E110420804040802
+5758:100017FE108010801080FCF8110811081108120813F81C10E010401007FE0000
+5759:00007FFE0888088811102220111008880888010001003FF801000100FFFE0000
+575A:040025FC2504248824502420245825860400010001003FF801000100FFFE0000
+575B:1000100011FC10001000FC0013FE10201020104010401C88E10443FE01020000
+575C:200023FE220022202220FA2022FC22242224222422443A44E484448409281210
+575D:100011FC110411041124FD24112411241124112411241C50E048408401020602
+575E:1020104011FC11041104FD0411141108110011FE10021C02E3FA400200140008
+575F:10801040104017FC1110FD1011101110111010A010A01C40E0A0411002080C06
+5760:00407C404440484044A044A0551049084204450201003FF801000100FFFE0000
+5761:20202020202023FE2222FA24222023FC2284228822483A50E220445004880906
+5762:10201020112410A410A8FC2011FC10201020102013FE1C20E020402000200020
+5763:01001110092001007FFE40028104010001003FF80100010001000100FFFE0000
+5764:10201020102011FC1124FD24112411FC1124112411241DFCE124402000200020
+5765:100011F8110811081108FDF811081108110811F811081D08E108410807FE0000
+5766:1000100011FC11041104FD0411FC11041104110411FC1D04E000400003FE0000
+5767:1000100013FE10201020FC40104010FC1184128414841C84E084408400FC0084
+5768:10401020102013FE1202FC04110011081110112011C01D02E102410200FE0000
+5769:110811081108110817FEFD0811081108110811F811081D08E108410801F80108
+576A:100011FC102010201124FCA410A8102013FE102010201C20E020402000200020
+576B:1020102010201020103EFC201020102011FC110411041D04E104410401FC0104
+576C:2008203C23D022902290FA90229022902290228822883AC8E2A444D404920800
+576D:100011FC110411041104FDFC110011401144114811701D40E1424242023E0400
+576E:10201020104010401088FD0413FE1002100011FC11041D04E104410401FC0104
+576F:100013FC102010201040FE4010D011481244144416401840E040400007FE0000
+5770:100011FE110211021102FD7A114A114A114A114A117A1D4AE1024102010A0104
+5771:10201020102011FC1124FD2411241124112413FE10201C50E050408801040202
+5772:10901090109013FC1094FC9413FC1290129013FE10921C92E11A411402100410
+5773:202021202120222022FCF4A4272421242224222424A437A4E0C4404400940108
+5774:010001003FF801000100FFFE08201010210841043FF8010001000100FFFE0000
+5775:1008101C11E011001100FD00110011FE1110111011101D10E110411007FE0000
+5776:200021F8210821482128F908210827FE2208228822483A08E3FE400800500020
+5777:2000200027FE20082008FBC8224822482248224823C83A48E008400800280010
+5778:10801080110011FC1204FC0411E411241124112411E41D24E004400400280010
+5779:10401020102013FE1202FC04100010901090109010881D08E108410402040402
+577A:105010481048104013FEFC80108010FC1144114411281D28E210422804440182
+577B:1008103C13E012201220FE20122013FE1220121012101E12E20A428A03260212
+577C:1008101C11E011001100FD0011FE11101110113011181D14E112421002100410
+577D:10201020105010501088FD241212101011FC100410081C88E050402000100010
+577E:10401020102013FE1202FC041000100013FE102010201C20E020402000A00040
+577F:2088208820882108217EFB08250821482128212821083908E108410801280110
+5780:1008103C13E010201124FCA410A8102013FE102010201C20E020402000A00040
+5781:10401040108010FC1120FE201020102013FE102010501C50E088408801040202
+5782:001000F83F00010001007FFC09200920FFFE092009207FFC010001003FF80000
+5783:108010401040100013FCFC00100811081108109010901C90E0A0402007FE0000
+5784:04400420FFFE0910112011C023044D0480FC010001003FF801000100FFFE0000
+5785:109010881088108013FEFCA010A010A410A410A811281D32E1224262029E0400
+5786:20402040207E20402040FBFC22042204220423FC22043A00E200440004000800
+5787:2000200023DE22522252FA52225222522272220222023A02E20243FE02020000
+5788:089008881080309E57E0908010441034110C01003FF8010001000100FFFE0000
+5789:1080108011FC11041204FDF411141114111411F411041D28E112410200FE0000
+578A:200023FC220422042204FBFC2220222023FE222022203A10E212428A03060202
+578B:00047F84122412241224FFA4122422042214410881003FF801000100FFFE0000
+578C:200023FE2202220222FAFA02220222FA228A228A228A3AFAE2024202020A0204
+578D:10201020104011FC1104FD04110411FC1104110411FC1D04E104410401FC0104
+578E:2080208021F822082510F8A0204020A023182C0623F83A08E208420803F80208
+578F:1020102011FC102413FEFC2411FC1020102011FC10201C20E3FE402000200020
+5790:4080208009FC12042448E04020A023182C06010001003FF801000100FFFE0000
+5791:2040204020FC21082290F86020482190263E204220843B48E030402000C00700
+5792:0400082010103FF80810102024487EFC0204010001003FF801000100FFFE0000
+5793:20402020202027FE2040F884210823F0202220443988E6104020005001880604
+5794:00007FFC044004403FF8244824483FF8010001003FF8010001000100FFFE0000
+5795:007C3F8020003FFE20002FF8280828082FF8208020802FFC40804080BFFE0000
+5796:1040108011F811081108FD0811F811001100110011FC1D04E104410401FC0104
+5797:10901090109012921194FC98109011981294149210901C90E11241120212040E
+5798:10901094109211121110FF7E151011101110112811281D28E128414401440182
+5799:10201020112410A410A8FC2013FE10901090109010901C92E1124112020E0400
+579A:010001003FF8010001000100FFFE1010101010107CFC101010101E10F0FE4000
+579B:100011F0111011101110FD10124E144013FC10401CE0E1504248044600400040
+579C:100013F81088109010BCFD0411141248104017FE10401CE0E150424804460040
+579D:1040104010FC11041208FDFE1100117C1144114411541D48E1424242023E0400
+579E:2040202023FE22022000F83823C020402040207C23C03840E0424042003E0000
+579F:110410841088100013FEFC20102011FC1020102013FE1C20E020402000200020
+57A0:100011F81108110811F8FD08110811F81144114811301D20E110414801860100
+57A1:08A00890108030FC57809048105010241054118C160401003FF801000100FFFE
+57A2:1008101C11E011001100FDFE11001100117C114411441D44E144427C02440400
+57A3:100013FE1000100011FCFD04110411FC1104110411FC1D04E000400003FE0000
+57A4:200027FE204020802110FA0827FC20442040204027FC3840E04040400FFE0000
+57A5:2040204020A02110FA08240623F82000200023F822083A08E208420803F80208
+57A6:00003FF020103FF020103FF0220821902C60311C01003FF801000100FFFE0000
+57A7:20402040208023FC2204FA0422F422942294229422943AF4E204420402140208
+57A8:1040102013FE12021414FC10101013FE1010111010901C90E010401000500020
+57A9:00007FFC04402448144814500440FFFE0000010001003FF801000100FFFE0000
+57AA:110410841088100011FEFC8810881088108813FE10881C88E108410802080408
+57AB:084008407DF808480C4819C8684A08AA2886110201003FF801000100FFFE0000
+57AC:108810881088108811FEFC8810881088108813FE10001C88E084410402020402
+57AD:200023FC209020902090F892249222942294229820903890E090409007FE0000
+57AE:2040204027FC20A02110FA082DF6200027FC208021003BF8E008400800500020
+57AF:101012101110111010FEFC10131011281124114411421D82E1004280047E0000
+57B0:10201020103E10201020FDFE1000100011FE102010281C24E022402000200020
+57B1:1020112410A410A410A8FC2013FC10041004100411FC1C04E004400403FC0004
+57B2:102011241124112411FCFC0011FC1004100411FC11001D00E102410200FE0000
+57B3:20802080213C22002480F880217E23082508210821083908E108410801280110
+57B4:20402020202027FE2000F800209022542224222422543A94E204420403FC0004
+57B5:10401020102013FE1202FC44104013FE1088108811081CD0E020405000880304
+57B6:1040102011FC10001088FC5013FE10201020102011FC1C20E020402000200020
+57B7:100013F81208120813F8FE08120813F81208120813F81D20E12042220422181E
+57B8:1040102013FE12021404FDF81000100013FE109010901C90E1124112020E0400
+57B9:2100211E21122FD22114F91427D8211421122FD22112391AE214421004100810
+57BA:1008103C11C010041144FCA8100011F81010102013FE1C20E020402000A00040
+57BB:100011FC1104110411FCFD04110411FC1104110411FC1C00E088408401020202
+57BC:10F8208841088A06100031F850889050102010D8170601003FF801000100FFFE
+57BD:200C11F08100490009FE1110E11022102210251001003FF801000100FFFE0000
+57BE:100011FC110411FC1104FDFC1000100011FC10201C20E3FE4020002000200020
+57BF:2040202023FE22002200FAFE22042228221023FE3A12E2144210041004500820
+57C0:00F83F000100FFFE01000924F93809223922C91E01003FF801000100FFFE0000
+57C1:102011241124112411FCFC20105010881144122210201DF8E008401000100020
+57C2:100013FE1020102011FCFD24112411FC1124112411FC1D20E0A0404000B0030E
+57C3:204020802110220827FCF904210023F82440204027FE3840E0A0411002080C06
+57C4:210021F8230824902060F9982646204023F8204023F83840E7FC404000400040
+57C5:004078204BFE508048F84488550849284210410001003FF801000100FFFE0000
+57C6:1080108010F811081210FDFC1124112411FC112411241DFCE124422402140408
+57C7:100011F8100810D01020FDFC1124112411FC112411241DFCE12441240124010C
+57C8:104010401088110413FEFC0210881144124210F81D88E2504020005001880606
+57C9:10201020102013FE1020FC2011241124112412AA10201C50E050408801040202
+57CA:0100210821083FF8000001047D88095011202518C20601003FF801000100FFFE
+57CB:100011FC1124112411FCFD24112411FC1020102011FC1C20E020402003FE0000
+57CC:1040102011FC11041104FDFC1104110411FC112011221D14E108414401820100
+57CD:100010FC1084108410FCFC0011FE1102110211FE11021D02E1FE4102010A0104
+57CE:20282024202027FE2420FC20242427A424A424A824A83C90E692492A08461082
+57CF:2008201C277021102110FA50225C27502150255025503A7CE200450008FE1000
+57D0:100011FC100410FC1004FDFC100013FE120211F810881C88E050402000D80306
+57D1:080C08F07E8008800EFE7888088829081208010001003FF801000100FFFE0000
+57D2:1008103C13C010441224FD281100101013FE101011101C90E090401000500020
+57D3:1008103C13C011241098FC601390101013FE101011101C90E090401000500020
+57D4:2048204427FE20402040FBFC2244224423FC224422443BFCE244424402540208
+57D5:100011FC110411041104FDFC1000100013FE102010201DFCE020402003FE0000
+57D6:2108210827FE21082108F800209020922114231825103932E1524112010E0100
+57D7:101010101090109E1090FC9013FE10001010109210921D14E208401000600380
+57D8:200820082788248824FEFC88248827C824A824A824883C88E788448800280010
+57D9:200023F82208220823F8F800200027FC2404244424443C44E4B4410806041802
+57DA:200023F8220822082208FBF82040204027FC244424A43D14E614440404140408
+57DB:200027FC240424A42514FE0C240425F42514251425143DF4E514440404140408
+57DC:082008207EFC08301C682AA4C9220820092001003FF8010001000100FFFE0000
+57DD:20202020205020882144FA2221F820082050202020A43A82E28A428A04780000
+57DE:1040102013FE12021404FC0013FE102010201120113C1D20E2A04260043E0800
+57DF:20142012201027FE2010F81023D222522252225423D43808E0EA471A02260042
+57E0:1020104011FC110411FCFD0011FC110411FC10201C20E3FE4020002000200020
+57E1:200027FE209020902090FB9C220422042204239C20903890E090409007FE0000
+57E2:204022482150204023F8F88027FC2110220825F429123910E1504124010400FC
+57E3:1040102013FE10001088FC88115412221000102013FE1C20E020402000200020
+57E4:2040208023FC22242224FBFC2224224423FC20903910E7FE4010001000100010
+57E5:1020102013FE102011FCFC2013FE100011FC110411FC1D04E1FC410401140108
+57E6:2040202023FE22022504F90021DE225222522352249A3894E11041120212040E
+57E7:100011F81108110811F8FD0811F8110811F811081D08E3FE4000009001080204
+57E8:2040204020A021102208FDF6200027FC24A424A427FC3CA4E4A444A404140408
+57E9:1080108011F811081210FDFC1024102413FE102410241DFCE024402000A00040
+57EA:10401020102013FE1202FC9411081204100011FC10201C20E020402007FE0000
+57EB:2020212420A420A82020FBFE2202220222FA228A228A3A8AE2FA4202020A0204
+57EC:2040204027FC204023F8FA4823F8224823F8204020E03950E2484C4600400040
+57ED:2040204023F82048F84827FE2048204823F8244422E83950E248444601400080
+57EE:10201122112212241050FC8813041022102011241D24E2284050008801040602
+57EF:2040208027FE21102248FC4623F82248224823F822483A48E3F840420042003E
+57F0:1008103C13C010441224FD281100102013FE107010A81CA8E124422204200020
+57F1:2100210021DC2114F114211427D42014211421143588E5484948011405140222
+57F2:1020102013FE102011FCFC4013FE10881124122210F81C20E3FE402000200020
+57F3:2080208020F82108FA1024002040239C22042204239C3A04E204420403FC0204
+57F4:2040204027FC20402040FBF8220823F8220823F822083BF8E20842080FFE0000
+57F5:2008203C21E020202020FBFE2124212427FE212421243BFEE020402003FE0000
+57F6:104010407C40104011F8FE480048454892C810487C68105A108A1C8AE1064202
+57F7:104010407C4011F81048FE48444829487CC8104810A8FEA8108A110A11061202
+57F8:100011FC110411FC1104FDFC1080108011FE124A144A1C92E122424200940108
+57F9:1040102011FC10001108FC90100013FE1000100011FC1D04E104410401FC0104
+57FA:082008207FFC08200FE008200FE00820FFFE082011102108CFE6010001003FF8
+57FB:1040102013FE100011FCFD0411FC100011FC10081C10E3FE4020002000A00040
+57FC:2040204023FC20A02110FA0827FE200823C8224822483A48E3C8400800280010
+57FD:200023F8200821F82008FBF8200027FE2442284423F83A48E248424802580040
+57FE:00007F7C22443E4422283E1023A8FE440282010001003FF801000100FFFE0000
+57FF:23F8120882084BF80A401248E27022442444253C09003FF801000100FFFE0000
+5800:100013FE1202120213FEFE1012921292129212FE12101E92E292449204FE0802
+5801:100011FC1124112411FCFD24112411FC102013FE10701CA8E124422200200020
+5802:0100111009207FFE40029FF4101010101FF0010001003FF801000100FFFE0000
+5803:102008107EFE10201E3C1224122422444A94850801003FF801000100FFFE0000
+5804:20002040239C22042204FB9C2204220423FC209020903890E09041120212040E
+5805:7F7C48447F44414841287F30481048287F44008201003FF801000100FFFE0000
+5806:21402120212023FE2220FE202BFC2220222023FC22203A20E22043FE02000200
+5807:08200820FFFE08200FE001003FF821083FF801007FFC01003FF80100FFFE0000
+5808:200023FE2202228A2252FBFE2222222222AA22AA22AA3AFAE2024202020A0204
+5809:2040202023FE20802104FBFE200221FC210421FC210439FCE104410401140108
+580A:00007FFC04403C78200820083C780440FFFE010001003FF801000100FFFE0000
+580B:200023DE225222522252FBDE22522252225223DE22523A52E2524252055208A6
+580C:200027FC2444244427FCFC44244425F42514251425143DF4E514440407FC0404
+580D:2100210021F02210FA2027FC2A442244224423FC22A438B0E128422A0422081E
+580E:2020202021FC20202020FBFE20882144224220F821883A50E020405001880606
+580F:0820081009FE7E40187C2C442A8448948908080001003FF801000100FFFE0000
+5810:100013FE1210121012FEFE10121013FE1200121012101EFEE210441005FE0800
+5811:100CFEF0208048807EFE08880E88F9084A08090801003FF801000100FFFE0000
+5812:100011FC1104110411FCFD04110411FC1000111211D41D18E11041520192010E
+5813:102011241124112411FCFC0011FE1100117C111011101DFEE110421002100410
+5814:100013FE120212521088FD041020102013FE102010701CA8E124422200200020
+5815:00207BFE484048FC51844AFC488468FC5084418C01003FF801000100FFFE0000
+5816:21242248249022482124F880210027FC2404251424A43C44E4A4451407FC0404
+5817:1040102013FE12021088FD0412221028102413FE10201C50E050408801040202
+5818:204022482150204023F8F88027FC2110224824443842E3F84040004007FC0000
+5819:200027FC20A020A027FCFCA424A424A427FC20403840E7FC404000400FFE0000
+581A:100013FE1222102013FEFC2011FC112411FC112411FC1C20E3FE402000200020
+581B:200023FE200021FC2104F90421FC200023FE222222223BFEE222422203FE0202
+581C:1020102013FE102011FCFD2411AC1174112411FC10201C70E0A8412402220020
+581D:100011FC1104110411E4FD24112413FE120212FA1E8AE28A42FA0202020A0204
+581E:20902290229027FE2290FA9022F0220023FC204027FE38E0E15042480C460040
+581F:208020FC210421F82008FBFE204020A22334205820943B34E052409003500020
+5820:2100217821082208FAFE26402A40227C2290221022FE3A10E228422802440282
+5821:08000BF8120833F8504097FC115012481446114001003FF801000100FFFE0000
+5822:2100217C21442244FA44267C2A10221022FE223822543A54E294431202100210
+5823:11FC1124112411FC1124FD2411FC1020102013FE12221E2AE2FA420A02020206
+5824:100011FC1104110411FCFD04110411FC100013FE10201D20E13C412002A0047E
+5825:00407F40127E0C88FF4819482A504820A850118C01003FF801000100FFFE0000
+5826:1110111211D411181152FD92112E104011FC110411041DFCE104410401FC0104
+5827:100013FE1020104011FCFD54115411541154112C1C20E3FE4050008801040202
+5828:100011FC110411FC1104FDFC108011FE1222112211521D02E1FA400200140008
+5829:2100213C21002100F9BC25642524253C252421242124393CE1244100017E0100
+582A:1088108813FE108810F8FC8810F81088108813FE11001D48E184410001FE0000
+582B:20002088225222222252FA8A220223FE20882144227A3888E150402000D80706
+582C:204020A02110220825F6F80023C42254225423D422543A54E3D44244025402C8
+582D:1020104011FC110411FCFD0411FC100013FE102010201DFCE020402003FE0000
+582E:100013DE1252125213DEFC0011FC100013FE108011001DFCE004400400280010
+582F:010001003FF80100FFFE08203EF808200E2078FC0000FFFE044008421042603E
+5830:200023FE220022FC2284FAFC228422FC222023FE22483AC8E2304248028403FE
+5831:100010FC7C8410841094FE88448028FC7CA410A410A8FEA8109010A810C41082
+5832:7E7C42447E4442447E44484444545A486240404001003FF801000100FFFE0000
+5833:200023FC2224222423FCFA0022FC2284228422FC22843AFCE484448408FC1084
+5834:200023F8220823F82208FBF820002FFE220023FC24943924E244448401280210
+5835:2040204423F42048F85027FE2040208021F82B08350821F8C108010801F80108
+5836:2040204023FE208021FCFA2025FE200021FC210421FC3904E1FC410401140108
+5837:2080204027FC20002208F9102FFE200023F8220822083BF8E208420803F80208
+5838:20002FF828082868FB88288828882BE82AA82AA83BE8E88A48AA10EA17262002
+5839:1008103C11E0102013FEFC2011FC112411FC112411FC1C20E1FC402003FE0000
+583A:23F82248224823F82248FA4823F820A02110220825163910E110411002100410
+583B:204013F890484FFE404813F82040E3FC20402FFE2040204001003FF80100FFFE
+583C:080808087E0808FEFE0808487E2808080F28F01001003FF801000100FFFE0000
+583D:100013FE1252125213FEFC00100013FE10201020113C1D20E120412007FE0000
+583E:2040204027FC204023F8F88027FE2110220827FC3A0AE20843F80208020803F8
+583F:20142012201027FE2410FC1025D02412241225D425543D48E5DA442A08461082
+5840:200023FC2204220423FCFA002284224822FC224822483BFEE448444808881108
+5841:3FF821083FF821083FF8600C183006C01830610C01003FF801000100FFFE0000
+5842:2110211027FC2110F1102FFE2110220827F42A123210E3F04204020401FC0000
+5843:2108210827FE2148F82027FE2200220023FC200022483A48E248444A044A0846
+5844:200023FC229422942294FBFC2080204027FE208020F83888E108410802280410
+5845:208023382228222823A8FA462200227C23A4222422283BA8E610422802440282
+5846:2080204027FE2090FA942492200023F8200823F822003BFCE004400400280010
+5847:1040102013FE12021404FDFC100011FC110411FC11041DFCE104400003FE0000
+5848:00007DFC44207D2045FE7C5048525492650E01003FF8010001000100FFFE0000
+5849:204022482150224824A4F918260623F8220823F822083BF8E208420802280210
+584A:2020204023FC22242224FBFC2224224423FC204020A838B4E13C41220222041E
+584B:08202AA42CA84920145022887FFE4002810401003FF8010001000100FFFE0000
+584C:200023F8220823F82208FBF82000200027BC208424A43A94E4A4408402940108
+584D:0020792448A8482049FC78404BFE488849247A224C2049FC482048204BFE9800
+584E:1040102013FE12021050FC88112410501088110412FA1C88E088408800F80088
+584F:102011241124112411FCFC0013FE100011FC110411041DFCE088405003FE0000
+5850:1020102013FE102011FCFC2013FE1040108811F01C24E3FE4022012402A20040
+5851:2200147CFF44087C4944497C7F4408441094210841003FF801000100FFFE0000
+5852:201020102710257C2510F51025FE2708250825FE25083548E728400800280010
+5853:100013FE1202100011FCFD0411FC110411FC10401C20E3FE4000008801040202
+5854:2110211027FC21102040F8A02110220825F6200020003BF8E208420803F80208
+5855:21202110220824862910FBF82008200027BC208424A43A94E4A4408402940108
+5856:203823C0204027FC2150F954275821542354254C20E03950E248444408420040
+5857:204010A0911042084DF6104027FCE040224824442942208001003FF80100FFFE
+5858:2040202027FE242025FCFC2427FE242425FC242025FC3D04E504490409FC1104
+5859:1040102013FE100011FCFD0411FC100013FE12021EFAE28A42FA0202020A0204
+585A:200027FE2402280427FEF8802184224426A821303AF0E4A8412802240CA20040
+585B:200027FC20A020A027FCFCA424A427FC2040204027FC38E0E15042480C460040
+585C:200027FE240229F42000FBF820802144266820B03928E66840A4012206A00040
+585D:2040202023FC21082090FBFE22022444202023FC208038F8E088410801280210
+585E:020001007FFE44429FF404403FF80440FFFE082011102108DFF6010001007FFC
+585F:0820FFFE082000007FFC08401F48625014621842E03E01003FF801000100FFFE
+5860:2010242022F82288F88820F82E80228022FC228422843AFCE284450008FE0000
+5861:111811E2110210FE1000FCFC128412FC128412FC12841EFCE20043FE01080204
+5862:1040108011FC11041104FDFC110011FE110011FE1C02E2AA42AA040200140008
+5863:200013F8920842084BF8080017FCE04023F8204027FC01003FF801000100FFFE
+5864:100011F81108110811F8FC0013FC120413FC120413FC1E04E3FC409001080204
+5865:200023FE200021FC2104F90421FC200023FE228A22523BFEE2224222022A0204
+5866:7C2045FE482051FC492445FC452455FC482043FE402001003FF801000100FFFE
+5867:220821082110200027FCF80021102208240423F822A83AA8E2A842A80FFE0000
+5868:2090209023FC20902090F89027FE209021482244244A3954E14A424A01400080
+5869:2100210021FE220025F8F908210821F8200023FC22943A94E294429407FE0000
+586A:101E11E0102211121094FC80102011CE1102110211CE1D02E102410201FE0102
+586B:2040204027FC204023F8FA0823F8220823F8220823F83A08EFFE411002080404
+586C:200027FE2420244025FCFD0425FC250425FC25243C20E4A849240A2210A00040
+586D:100011F81108110811F8FD08110811F8100013FC12941E94E294429407FE0000
+586E:2084210423C4224423DEFA4423C42264225427D420C43944E244444401540088
+586F:204023BE221222922252FAAA2324204023FE222222223BFEE222422203FE0202
+5870:210011FC920045F84148112823FEE148222823FC205001203FF801000100FFFE
+5871:10007E7C42447E7C42447E7C484444445A94610801003FF801000100FFFE0000
+5872:210021FC220025F82108F9F8210821F8200027FE21003BFCE4A4412402540088
+5873:2020247C228421482030F8CE2610227C2210227C22103AFEE210421005FE0800
+5874:20202222222223FE2000FBDE2252225223DE225222523BDEE2524252055A08A4
+5875:010000803FFE22203FFC22243FFC28402F7828422F3E20802FF840807FFE8000
+5876:2040202023FE22502250FBFE2252225223FE220022923AD4E298449204D2088E
+5877:20202020203E20202020FBFE22022326228A225223263A52E28A432603FE0202
+5878:200023FE2200227C2244FA44227C220022EE22AA22AA3AAAE2EE420003FE0000
+5879:08047F7808407F40497E7F4849487F4808487F48088801003FF801000100FFFE
+587A:010000803FFE221022102FBC231826B42A52208020802FFC408040809FFE0000
+587B:1088108813FE10881000FDFC110411FC110411FC1C20E3FE4050008801040202
+587C:102013FE102011FC1124FDFC112411FC102213FE1C08E3FE4108008800280010
+587D:2040204027FC20402554FA482554204025542248255438A0E0A0411002080C06
+587E:1040FE4000407DF844487C4800C87C4808AAFEAA1106520221003FF80100FFFE
+587F:102011FC112413FE1124FDFC102011FC112411FC1C40E3FE408801D00070038C
+5880:200027FC240427FC2420FCA8247024A8250424A03CFCE52044200BFE08201020
+5881:23F8220823F8220823F8F80027FC24A424A427FC20003BF8E11040E003180C06
+5882:100013FE105011FC1154FD5411FC100011FC100013FE1C20E0A8412402A20040
+5883:2080204023F82110F8A027FE200023F8220823F822083BF8E120412202220C1E
+5884:20142012201027FE2410FC9024D2249227F224943C94E5C84AAA089A11A60042
+5885:7F7C49047F2849107F7E08127F1408100F50F02001003FF801000100FFFE0000
+5886:22A822A827FC22A8FAAA24E6280027FC2444204023F83A48E248424802580040
+5887:102011FC1088105013FEFC0011FC110411FC110411FC1C20E3FE402000200020
+5888:224822482FE8224823DEF24A23CA224A224A2FEA240A354AE632441207EA0044
+5889:202027FE242025FCF42427FE242425FC242025FC3524E5FC452409FC0924112C
+588A:08207E2008F8FF2814287F6A082AFF560882010001003FF801000100FFFE0000
+588B:2040208821FC21082252FBFE20502188262620C023103864E388403000C00700
+588C:2040202023FE22002248FA4823FE2248224822483A78E2004554052A0A2A1000
+588D:10007EFC42107E9042907EFE001040287E2840484C8A710601003FF80100FFFE
+588E:2200211E27D2201227D4FC5427D8201427D22092211239DAE714411005100210
+588F:0420247E24943D48043005C87C0825FE24882448441881003FF801000100FFFE
+5890:1088108813FE108810F8FC2011FC112411FC102013FE1C20E1FC402003FE0000
+5891:2040202023FE20882050FBFE222222FA222222FA228A3A8AE2FA4202020A0204
+5892:2040202023FE20882050FBFE2252228A230622FA228A3A8AE2FA4202020A0204
+5893:04407FFC04401FF010101FF010101FF00400FFFE10102108CFE6010001003FF8
+5894:1020122213FE10901088FDFE1310151011FE111011101DFEE110411001FE0100
+5895:200027FC20402278F2402FFE210021FC220023FC3004E5544554080400280010
+5896:204020A0211022082DF6F00023F8220823F8200027FC3444E7FC444407FC0404
+5897:21042088200023FE2222FBFE2222222223FE200021FC3904E1FC410401FC0104
+5898:2110211021102FDEF12027C0245C27C4244827C83110EFD041220122011E0100
+5899:2040204027FC20402248F95027FE200023F8220822E83AA8E2E8420803F80208
+589A:22782128246C22AA202AF94822982040204027FC20E03950E2484C4600400040
+589B:200427C42444244427DEFC0425C42404241427EC3C84E4C44AA40A8414940188
+589C:00887C5045FC484050A24B5444B8675458924350402001003FF801000100FFFE
+589D:2020202021FC202023FEF908239C21082188263E20003BFEE09040900112020E
+589E:22082110200027FC2444FD5424E4244427FC200023F83A08E3F8420803F80208
+589F:2040207C204023FE2242FA7823C4223C2200225022543B54E4D8445009FE0000
+58A0:100013DE1252125213DEFC0011FC112411FC112411FC1C20E3FE402000200020
+58A1:1088105013FE102011FCFC2013FE112410A813FE10001DFCE104410401FC0104
+58A2:202423A820922514F2082C0427BA20A827C6240037BCE08440A8009005280244
+58A3:20A024A422A820A027FCF91020A027FC204023F83840E7FC40A0011002080C06
+58A4:204023F8224823F8F84027FE200023F8220823F822083BF8E20843F801100208
+58A5:102011FC1088105013FEFC0011FC112411FC112411FC1C20E1FC402003FE0000
+58A6:103C13E0112410A813FEFCA81124120211FC112411241DFCE124412401FC0104
+58A7:203823C0208027FE2110FA0825F6291021F0200027FC3C04E5F4451405F4040C
+58A8:00003FF8292825483FF801003FF80100FFFE2448422401003FF801000100FFFE
+58A9:221021102FD0201027BEFCA427D4201427942094211439C8EF08411405140222
+58AA:08407F40007E3E8823483E4800503E5004207F500888290411003FF80100FFFE
+58AB:2108209027FE209023FCFA94231C220423FC22043BFCE00847FE010800A80010
+58AC:00403C78248828F030102BFE244025A4345829B4205221B001003FF80100FFFE
+58AD:2028202423FE22202224FBA42298249025AA284623FA3AA8E2A842A80FFE0000
+58AE:00407BFC488051F8622055FC488848F8688850F8408841003FF801000100FFFE
+58AF:104013FE188055F8522095FC108810F8108810F8108801003FF801000100FFFE
+58B0:200023FE205023FE2252FBFE200021FC210421FC210439FCE02043FE00200020
+58B1:202027A420A822922114FA0825F4280223F8220822083BF8E20841100FFE0000
+58B2:2100210023FC26A82AA8F2A827FC22A822A822A82FFE3000E2A8425404540000
+58B3:102011FC1020108813FEFC8811FC110411FC110411FC1D04E1FC408801040202
+58B4:2110211027FC21102110F7FE204027FC244427FC244437FCE000411002080404
+58B5:100011FC102013FE1222FDAC102011AC100011FC1C00E3FE4040008801FC0084
+58B6:20102410227C201020FEF844262822FE2210227C22103AFEE210421005FE0800
+58B7:108813FE1088100011FCFCA810A813FE10A810A811FC1C20E3FE402000200020
+58B8:2108210827FE21082044FBF42048205027FE208021FC3B04E5FC490401FC0104
+58B9:200027BC24A427BC24A4FFBC240425F4251425F425143DF4E514440404140408
+58BA:2080210027FC24442554FC4427FC24E4255424043840E7FE40A0011002080C06
+58BB:2040204027FC2248FA4825542FFE200023F8220822E83AA8E2E8420803F80208
+58BC:0800FF7808487F4849867F0049787F480828FF9049287F4401003FF80100FFFE
+58BD:221024102F9028902FBEF8A42FD4241422142FD424143788E48848940A941122
+58BE:0600F8FC4A8424FC3884CCFC36A2CA9412A86AC4048201003FF801000100FFFE
+58BF:200027FC24A427FC2040FBF8204027FC211020A03BF8E0404FFE004000400040
+58C0:20102008278824BEF48024942788247E2408278836BEEA884A880B8812880008
+58C1:00407C2045FC44887C5043FE7C20A5FC24203D2001003FF801000100FFFE0000
+58C2:3F7821483F4820862A783F482A483F2820104A289146200001003FF80100FFFE
+58C3:100013FE100011FC1124FDFC112413FE100011FC11241DFCE12441FC000003FE
+58C4:000027882088FABE210877D86B5CA52A29482508220801003FF801000100FFFE
+58C5:02000100FFFE104824FE799010FC22907CFC089030FEC08001003FF80100FFFE
+58C6:0A803138228838382288393822887FFE4002810401003FF801000100FFFE0000
+58C7:20402FFE200027FC2404FDF4251427FC200023F822083BF8E20843F800000FFE
+58C8:20402FFE200027FC2404FDF4251425F4240427FC20083BF0E0404FFE01500E4E
+58C9:2040207C204023FE2242FA7823C4223C220023FE22403BA4E25845B4045209B0
+58CA:2020202027FE202023FEFA52225223FE2040202027FE38A4E1A84290048800C6
+58CB:20402248215027FE2402F80423F8220823F8200027FC3C44E7FC444407FC0404
+58CC:2080204027FE2110FA08251423F8211023F8211027FC3928E3104D4801860100
+58CD:420C2FB082204FA00ABE2FA84AA8CFA842285FA84248028801003FF80100FFFE
+58CE:203C27C020402FFEF04027FC255424E427FC204037FCE0404FFE000005240892
+58CF:201027D0251027DEFC5027E8250427C4200023F822A83AA8E2A842A80FFE0000
+58D0:7FFC111021087FFCB55A292835582108355829283458201801003FF80100FFFE
+58D1:08000F00087CFFA480A47F24492494A822107F28A2443E0201003FF80100FFFE
+58D2:211027FC2110204023F8F84027FC2080211023F820003BF8E2A842A80FFE0000
+58D3:00003FFE288C2F8A28882FBE20082F8828882F94289429A2404047FC80401FFE
+58D4:204027FC204023FC2000F7FE200223F8204027FE200037FEE00847FE04A80798
+58D5:204027FE200021F8F90821F8200027FE240223F829803644E1B8466801A60E60
+58D6:100011FC102013FE1222FDAC102011AC100013FE10201DFCE15441540154010C
+58D7:204023F8204827FE2048FBF8204027FE200022A424523BF8E2A842A80FFE0000
+58D8:00001FF011101FF011101FF000003EF82AA83EF82AA83EF801003FF80100FFFE
+58D9:2040202027FE248825FCFC8827FE242025FC25243DFCE52445FC040004880904
+58DA:2040207C204023FC2244FBF0224422FC22A822F822A83AF8E20045FC05540BFE
+58DB:27BC24A427BC24A427BCFC8424F42514262425B425143DB4E51445F404140408
+58DC:11FC110411FC110413FEFC2013FE122211AC102011FC1C00E3FE4040008801FC
+58DD:202029FC252421FCF82023FE2D0425FC250425FC25043DFCE48845040BFE1000
+58DE:208020402FFE200027FCFCA427FC224821502208244438A8E11043080D460180
+58DF:08407E7C2440FF7C00047E7C42407E7C42407E7C4242463E01003FF80100FFFE
+58E0:2210211027DE2010245EFA8227DE201027DE245027DE3C50E7DE4450045204CE
+58E1:10001F7C1024FFA480A87F102A285546A2107F10A2BC3E1022103E1022FE3E00
+58E2:200027FE244425982488F7DE248825DC26AA248824203520E53C4920092017FE
+58E3:40445F444AAA4AEE4E44EAAA4AEE4E004A284AAA6BAA4EEE9A28022802480288
+58E4:204027FC200023B8F2A823B8211027FC211027FC3110EFFE412803100D480186
+58E5:27FE240025FC25AC2574FDFC242025FC242027FE3C00E554482009FC102003FE
+58E6:21102FFE211027BC24A4F7BC2140212023FE222027FC3A20E3FC422003FE0200
+58E7:27BC24A427BC200027FEFC002590249E27D4256425D43D54E5D445680BC81054
+58E8:00003EF82AA83EF82AA83EF800003EF82AA83EF82AA83EF801003FF80100FFFE
+58E9:27FC20402FFE28422358F5002FBC25242724223C2FA43AA4EFBC42241FA4024C
+58EA:244428E82E0E24E4FA0A2EEE20A02AEA200023F820083BF8E20043FC00040038
+58EB:010001000100010001000100FFFE01000100010001000100010001003FF80000
+58EC:001000F83F000100010001000100FFFE0100010001000100010001003FF80000
+58ED:01000100FFFE010001007FFC000000003FF80108010801280110010001000100
+58EE:0820082008204820282028200BFE182028204820882008200820082009FC0800
+58EF:042024202420242024203C2007FE0420FC20242024202420242045FC44008400
+58F0:01000100FFFE01007FFC00003FF8210821083FF8200020002000400040008000
+58F1:010001007FFC010001001FF000007FFE40028004101010E01F08100810080FF8
+58F2:010001007FFC010001001FF000007FFE4002844404400440044008441044203C
+58F3:010001007FFC010001001FF000007FFE400280040FE00820082010222022C01E
+58F4:01000100FFFE010001007FFC00001FF0101010101FF0000008200440FFFE0000
+58F5:010001007FFC0100010001003FF8000010101010FEFE1010101010107C7C0000
+58F6:010001007FFC010001001FF000007FFE40028444044024481448145004407FFC
+58F7:010001007FFC01001FF000007FFE444284443FF8244824483FF804400440FFFE
+58F8:010001007FFC01001FF000007FFE4002BFFC04402448144814500440FFFE0000
+58F9:010001007FFC01001FF000007FFE40029FF400001FF010101FF008200440FFFE
+58FA:010001007FFC01001FF000007FFE444284443C7820083C7804400440FFFE0000
+58FB:100013FE10221120113CFD2012FE140011FC110411FC1D04E1FC410401140108
+58FC:010001007FFC01001FF000007FFE4002BFFC04403C7820083C780440FFFE0000
+58FD:01007FFC01003FF80000FFFE00023FF00100FFFE00007FFC00107DFC44907C30
+58FE:0800087EFF40084008407E7C00447E44424442447E7C424024400F40F07E4000
+58FF:1088105013FE105011FCFF54118C1174110411FC1C0873FE2108008800A80010
+5900:01003FF801001FF001007FFC01041FF011101FF00100FFFE00083EFE22483E18
+5901:0100FFFE01003FF800007FFC44447FFC00003FF821082FE8210827C824483FF8
+5902:0400040004000FF008101010302048208440028001000280044008203018C006
+5903:00003FF00410042004200440047C04040BE4082409441084114422244C288010
+5904:1040104010401E40126022502248524494441440084008401440230040FE8000
+5905:040004000FF01820644003801C70E10E01001FF0010021003FF8010001000100
+5906:040004000FF01820644003801C70E10E1FF001001FF001007FFC010001000100
+5907:040004000FF01820644003801C70E00E1FF0111011101FF0111011101FF01010
+5908:040004000FF01820644003801C70E10E111009207FFC05400920111061080100
+5909:01000100FFFE04401450244848C4140027F0082014402280410006C01830E00E
+590A:0400040004002FF028101010302048208440028001000280044008203018C006
+590B:0400082010103FF8000808201210220847E4082014402280010006C01830E00E
+590C:010001003FF801000100FFFE1210220847E4882214402280010006C01830E00E
+590D:100010001FFC20005FF090101FF010101FF004000FF01820644003801C70E00E
+590E:010011101110292845443FF801000100FFFE08000FF01420224041800E60701C
+590F:7FFC02001FF010101FF010101FF010101FF008001FF02820444003801C70E00E
+5910:10001FE020207FF8A30824881FF010101FF010101FF008001FF0282007C0F83E
+5911:210827C820086B9AB02C2388200853944A928BA204000FE0144003801C70E00E
+5912:0000FFFE110013DC52545BD4525C53D05A52E3CE24084FE4944203801C70E00E
+5913:17C0621C47C4444477DC444447C4745C47C4000024084FE4944203801C70E00E
+5914:0440FFFE110013DC52545BD4525C53D05A52E3CE24084FE4944203801C70E00E
+5915:020002000200020007F80408080810102410422001400080010002000C007000
+5916:10401040104010403E40226042504248A4441444084008401040204040408040
+5917:1000100010F81E8812882288228852888AA804900480088208821082207E4000
+5918:10001000107C1E4412442244224452448A440444044408540848104020404040
+5919:00003FF8200820082FE82208220827C8244828483488228A210A420A44068802
+591A:0200020007F008203840048003400C8071F802080C103220014001800E007000
+591B:00003FF0001000101FF000100010FFFE020007F008103420024001800E007000
+591C:02000100FFFE0880088010F81108314852289510111010A0104010A011181606
+591D:2020202021203D2025FC45204620A420142009FC082010201020202043FE8000
+591E:102010203F304128A224142208203020C02000003E442258226022423E42223E
+591F:20202020407C7E4482A802107A204AD04A1E4A227A644A9402080210142008C0
+5920:102010203E40427EA4821902107A284ACF4A114A327A4A4A040208023014C008
+5921:101010103E1042FEA4101810107C2800CF00117C32444A4404440844307CC044
+5922:0820FFFE08203FF824483FF800007FFE420287F408103420024001800E007000
+5923:0100FFFE10103FF800003FF824483FF800007FFE44028FF4342002C007007800
+5924:02000FF0346003801D007FFE4002BFFC01003FF821083FF821083FF810102008
+5925:00207E204A7C4A447EA84A104A207ED0081EFF2218642C942A084A10882008C0
+5926:22202220FF7C22443EA822103E2022D0221EFF2240645494620840107E2000C0
+5927:01000100010001000100FFFE010001000280028004400440082010102008C006
+5928:100010001000200020007F80008001000100FFFE01000280044008203018C006
+5929:00003FF80100010001000100FFFE01000280028004400440082010102008C006
+592A:01000100010001000100FFFE0100010002800280044004400A2011102108C006
+592B:01000100010001003FF8010001000100FFFE028004400440082010102008C006
+592C:0100010001001FF001100110011001100110FFFE02800280044008203018C006
+592D:001000F83F000100010001000100FFFE0100028002800440082010102008C006
+592E:0100010001001FF011101110111011101110FFFE02800280044008203018C006
+592F:010001007FFC0280044008203018C10601003FF8020802080408080810506020
+5930:010001007FFC0280044008203018C44604400440044004400840084010402040
+5931:01001100110011001FF8210041000100FFFE010002800280044008201010600C
+5932:010001007FFC0280044008203118C10601000100FFFE01000100010001000100
+5933:010001000100FFFE02800440082010102008CFE600000000000000007FFC0000
+5934:00800080088004802480108010800080FFFE010001400220041008083004C004
+5935:010001007FFC0280044008203018C10601000920091011082104410405000200
+5936:082008200820082008207EFE0820082008501450125012882088210442048402
+5937:01000100FFFE01003FF8010801083FF8210021003FFC0284044C08203018C006
+5938:010001007FFC0440082017D02008C0063FF8040008000FF00010001000A00040
+5939:0100010001007FFC0100111009200100FFFE010002800280044008203018C006
+593A:010001007FFC0280044008203018C0460040FFFE004010400840084001400080
+593B:010001007FFC01000280044008203018C0061FF010101010101010101FF01010
+593C:010001007FFC0280044008203018C92609200920092009201120112021204020
+593D:020002007FFC044008203018CFE6000000007FFC02000400082010103FF81008
+593E:0100010001007FFC01001110111011102928454402800280044008203018C006
+593F:010001007FFC0280044008203018DFF61110111011101FF0100410040FFC0000
+5940:00007FFC01000300056019186104000001000100FFFE0280044008203018C006
+5941:020002007FFC044008203018DFF610001220114010801140122010001FF80000
+5942:080008000FE0102020405FF09110111011101110FFFE0280044008203018C006
+5943:020002007FFC044008203018C0F63F00210021003FFC208020402A243114210C
+5944:020002007FFC044009203118DFF6111011101FF0111011101FF40104010400FC
+5945:020002007FFC044008203018C60638F82088228822882E8832A8249004800880
+5946:020002007FFC044008203018DFF6100010001FE0102010201FE0100010001FF8
+5947:010001003FF8028004400820FFFE001000101F90109010901F90001000500020
+5948:020002007FFC044008203018CFE6000000007FFC010011101108210445040200
+5949:010001007FFC01003FF80200FFFE044009203118CFE6010001003FF801000100
+594A:00800FF840805FFC40804FF840805FFC40007F0001007FFC028004401830E00E
+594B:010001007FFC0280044008203018C0061FF0111011101FF0111011101FF01010
+594C:0100010001FC010001001FF0101010101FF0010001007FFC028004401830E00E
+594D:0100111009203FF8020002007FFC082010102448C44604400840084010402040
+594E:020002007FFC044009203118CFE6010001007FFC000001003FF801000100FFFE
+594F:010001007FFC01003FF80200FFFE0440082037D8C1061FF0010002C00C303008
+5950:080008001FE020204040BFF822882448282821080100FFFE028004401830E00E
+5951:080008007F7C08243E2408247F44085409880100FFFE0280044008203018C006
+5952:020002007FFC04400A203118DFF6040008401F8001100620384001A00E107008
+5953:020002007FFC044008203218C7E618400580068039F80610192000C003003C00
+5954:020002007FFC044009203118CFE60100092008207FFC08200820102010202020
+5955:020001007FFC0440245044488944108001000100FFFE0280044008203018C006
+5956:0840484028FC09041A8828504820884009800100FFFE0280044008203018C006
+5957:010001007FFC028004400FF03418C7E6040007E00400FFFE040008101FF80008
+5958:2420242024203DFC0420FC20242024F845000100FFFE0280044008203018C006
+5959:040008201FF00210FFFE08203118DFF611101FF011101FF40104010400FC0000
+595A:00FC7F002208151008401F8003200C103FF8010801007FFC028004401830E00E
+595B:020002007FFC044008203018C0063CF824883CF8248824F83C88248801280210
+595C:044004407C7C04403C7804407C7C044005400100FFFE0280044008203018C006
+595D:020002007FFC044008203FF8D11617D011101FF0101017D0245027D040108030
+595E:020002007FFC044008203018C90608801FFC30805FF890801FF810801FFC1000
+595F:020002007FFC044008203E78D24E12481E78124812481E78124822882AA84510
+5960:08200440FFFE04403FF82848303827C820083FF801007FFC028004401830E00E
+5961:7FFC02001FF010101FF010101FF010101FF00200FFFE08203458C44608401040
+5962:020002007FFC044008203218DFD60220FFFE03000FF03810CFF008100FF00810
+5963:00003FF802007FFC04401830E00E3CF8248824F83C8824F824883C8801280210
+5964:020002007FFC044008203FF8C10602003FF8244827C8244827C824483FF82008
+5965:020004003FF82008292825482FE82548292820080100FFFE02800C603018C006
+5966:00407EFC15440838FE441AA22CFC4844A894110801007FFC028004401830E00E
+5967:020004003FF820682FA825482FE823482528280801007FFC02800C603018C006
+5968:083E4BC42A48292008081BFE2908C8880828091001007FFC028004401830E00E
+5969:02007FFC04201818E0063FF8200027F0241027F020002F7829482F7820003FFC
+596A:02007FFC04201898E8461FF830805FF810801FF810801FFC1020FFFE08200460
+596B:020002007FFC044008203018C14625481778840847F814082778E54825482808
+596C:0440247C24A83D5004287DFE2488444885180100FFFE0280044008203018C006
+596D:01000100FFFE01007D7C11107D7C45447D7C45447D7C0280044008203018C006
+596E:02007FFC04201818E9061FF831005FF891001FFC10003FF821083FF821083FF8
+596F:02007FFC04201918E9E609007FFC00283FFE20202FA422282A90532A46469882
+5970:00003FF824483FF80000FEFEAAAAAAAAFEFE010001007FFC028004401830E00E
+5971:210447C88812F3BC20084B92F83E0380AAAAABAA01007FFC028004401830E00E
+5972:100010EEFEAA28AA44EE90007AFE1492FEFE10927CFEC4107DFE44107C104410
+5973:02000200020002000400FFFE0420082008201040184006800180066018106008
+5974:1000100011FC1084FC8424842488248824504850282010202850448881040202
+5975:1000100013FE1020FC2024202420242024204820282010202820442084A00040
+5976:1000100013F81088FC90249024A024BC24844884290411042904460482280410
+5977:1008103C11E01020FC202420242027FE24204820282010202820442084200020
+5978:100011FC10201020FE202220222023FE42202420142008201420222042208020
+5979:1020102010201120FD2C2534256427A425244934292811222922450284FE0000
+597A:10801080108010F8FD0825082510261024204820285010502888450882040402
+597B:1020102010201020FEFE22442244224442442484144808281410222842448082
+597C:1010103811E01020FE2022202220223E43E024201420082214222222421E8000
+597D:100010FC10041008FC102420242025FE24204820282010202820442084A00040
+597E:1020102010201020FD242524252425242524492429241124292445FC80040000
+597F:20402040204023FEFC88248825082490645024203450248A2502440243FE8000
+5980:00400040FC40044007FE048804887C8840884108409044505820605040880304
+5981:10401040108010FCFD0426042404250424844844284410042804440484280010
+5982:100010001000107CFE4422442244224442442444144408441444227C42448000
+5983:1000100011F81008FC082408240825F825084900290011002902450284FE0000
+5984:02000100FFFE100010001FF802000200FFFE042008201E400180066018186004
+5985:1000100011FC1020FC2024202420242024204820282010202820442083FE0000
+5986:08400840084048402BFE28880888088818882908C89008500820085008880B04
+5987:1000100011FC1004FC042404240425FC2404480428041004280445FC80040000
+5988:100013F010101010FD102510251025FC24044804280413F42804440484280010
+5989:10201020102011FEFD222624242024202450485028501050289044928512020E
+598A:1008103C11E01020FC202420242027FE24204820282010202820442085FC0000
+598B:1020102010201020FDFC24202420242027FE4820285010502888448885040202
+598C:1088108810881088FDFC24882488248827FE4888288810882888450885080208
+598D:100013FE10881088FC882488248827FE24884888288810882888448881080208
+598E:1020102010501050FC8825042602248824884888288810882888450881080208
+598F:10401020102013FEFC8824882488248824884850285010202850448881040602
+5990:1010109010901088FC882524252426222420484028481044288445FE84820000
+5991:1000100011FC1124FD2425242524252425FC4900290011002902450284FE0000
+5992:10401020102011FEFD022502250225FE25024900290011002A00460084000800
+5993:10201020102013FEFC202420242025FC24844888284810502820445081880606
+5994:10801040104013FCFC00240025F02510251049102910111229124612820E0400
+5995:1020102010201020FDFC252425242524252449FC292410202820442084200020
+5996:1008103C11E01020FC20242025FE242024204850285010502888448881040202
+5997:1020102010501050FC88254426222420240049FC280410082808441084100020
+5998:1000100010FC1000FC00240025FE24202420484028401088288445FE84820000
+5999:10201020102010A8FCA424A22522252026244824282810082810442080C00300
+599A:1000100011FE1010FC1024202420246824A449222A2210202820442084200020
+599B:01002108210821083FF801000100FFFE02000200FFFE08201C4003800C707008
+599C:10401040104013F8FC4824482448244827FE484028A010A02910451082080406
+599D:042024202420242025FE3C4404440444FC442484244824282410442844448582
+599E:100011F810481048FC482448244825F824884888288810882888448883FE0000
+599F:00001FF0101010101FF0101010101FF002000200FFFE08201C4003800C707008
+59A0:1020102010201020FDFE2522252225222552494A298A110229024502850A0104
+59A1:1008101C11E01100FD00250025FE251025104910291011102910461082100410
+59A2:1010109010901088FD082504260425FA24884888288810882908450882280410
+59A3:1010111011101112FD12251425D82510251049102910111229524592850E0000
+59A4:100011F810081050FC20241027FE242224244820282010202820442084A00040
+59A5:00FC7F00020821081110102002000200FFFE042008201E400180066018186004
+59A6:10201020102013FEFC202420242025FC24204820282013FE2820442084200020
+59A7:100011FC10001000FC0027FE24902490249048902890109229124512820E0400
+59A8:10401020102011FEFC4024402440247C24444844284410442884448481280210
+59A9:200023FC20402040F84048404FFE484088A048A030A0112029224A22841E0800
+59AA:100011FE11001104FD4425282528251025104928292811442984450085FE0000
+59AB:1020112010A010A0FC2027FE2422242224424852284A108A2882450282140408
+59AC:1000100013FE1020FC202440244024FC25844A842C8410842884448484FC0084
+59AD:2050204820482040FBFE4880488048FC89444944312811282A104A2884440182
+59AE:100011FC11041104FD0425FC25002540254449482970114029424642823E0400
+59AF:1020102010201020FDFC252425242524252449FC292411242924452485FC0104
+59B0:10801080108010FEFD4025402640247C244048402840107C2840444084400040
+59B1:100013FC10841084FC84250425142608240049FC290411042904450485FC0104
+59B2:1000100010FC1084FC84248424FC24842484488428FC10842800440085FE0000
+59B3:10801080108010FEFD0225042620242024A848A4292411222A22442080A00040
+59B4:100010F83E884288A4A818941084207CC2000200FFFE08201C4003800C707008
+59B5:10401020100013FEFC2024202420242025FC4820282010202820442083FE0000
+59B6:10201010101011FEFC2024202444248425F8481028201044288245FE84820000
+59B7:1020102011201120FDFC25202620242025FE4820285010502888448885040202
+59B8:1000100013FE1008FC0825E8252825282528492829E811282808440884280010
+59B9:10201020102011FCFC202420242027FE247048A828A811242924462284200020
+59BA:10201020102013FEFC202420242025FC247048A828A811242924462280200020
+59BB:010001007FFC01003FF80108FFFE01083FF80200FFFE08201C4003800C707008
+59BC:1040102010281008FC08244824542552255249602A60104428C44544823C0000
+59BD:10201020102011FCFD242524252425FC25244924292411FC2924442080200020
+59BE:020001003FF8000008200440FFFE020002007FFC042008401C8003800C707008
+59BF:100010007E7C1244124422444A7C844402000200FFFE08201C4003800C707008
+59C0:101C11E010201020FC2027FE24202470247048A828A811242A22442080200020
+59C1:10801080110011FCFE04240425E425242524492429E411242804440484280010
+59C2:1004101E11E01000FC20241025FE2404240848102820104028804540823E0000
+59C3:1000100013FE1020FC20242025202520253C4920292011202920452087FE0000
+59C4:100011FC11041104FD0425FC2520252025FE4920292011102912454A85860102
+59C5:10201020112410A4FCA8242025FC2420242048202BFE10202820442084200020
+59C6:100010FC108410A4FC942484248427FE250449442924110429FE440484280010
+59C7:0810081017FE3010521091101110105012200200FFFE08201C4003800C707008
+59C8:1020102010501050FC8825242612241025FC4804280810882850442084100010
+59C9:10201020102013FEFC20242025FC252425244924292411342928442084200020
+59CA:10201020102E11F0FD202520252025FE2422486228A2112A2E24442084200020
+59CB:1020102010201040FC48248425FE2482240048FC288410842884448480FC0084
+59CC:10201020102011FCFD24252425FC2524252449242BFE11042904450485140108
+59CD:100011FC11541154FD542554255427FE25544954295411542954454485140108
+59CE:10201020102011FCFD2425242524252425244BFE282010502850448881040202
+59CF:1088108810881088FDFE248824882488248848F8288810882888448884F80088
+59D0:100011F811081108FD0825F825082508250849F8290811082908450887FE0000
+59D1:1020102010201020FDFE24202420242025FC4904290411042904450485FC0104
+59D2:1008104811281128FD2825082508250825084908294811942914442284420082
+59D3:1020102011201120FDFC252026202420242049FC282010202820442083FE0000
+59D4:00701F8001000100FFFE054009203118C2060200FFFE08201C4003800C707008
+59D5:0880088828902EA028C028842E84F07C02000200FFFE08201C4003800C707008
+59D6:100011FE11001100FD0025FC250425042504490429FC11002900450085FE0000
+59D7:100011DC11541154FD542554255427FE2554495429541154295446D48224044C
+59D8:1104108410881000FDFE24882488248824884BFE288810882908450882080408
+59D9:10801088109C1170FD1027102510251025FE49102910111029104510857C0100
+59DA:2090209020902292F9944898489049988A944C9230901090291249128212040E
+59DB:100011FE11021102FD7A25022502257A254A494A294A117A29024502850A0104
+59DC:082004407FFC01003FF80100FFFE02000400FFFE082010201C4003800C707008
+59DD:20202120212021FCF9204A2048204BFE487090A850A8212431244A2248208020
+59DE:10201020102013FEFC20242025FC2400240049FC290411042904450485FC0104
+59DF:10201010101013FEFC202442248425F82410482228C413082810442880C40302
+59E0:10201020104011FEFD022502257A254A254A494A294A117A29024502850A0104
+59E1:1008103C11E01020FC2027FE24202420242049FC290411042904450485FC0104
+59E2:1020102010481084FDFE2402240024FC248448FC288410FC2884448484940088
+59E3:10401020102011FEFC0024882504260224884888285010502820445080880306
+59E4:1008101C11E01100FD0025FE25002500257C4944294411442944467C82440400
+59E5:10401040104411F4FC48245027FE2440248049842A9810E028824482847E0000
+59E6:04000400FFFE08201C4003800C70700800101010FEFE2224646418182434C2C2
+59E7:10001000FE7C2210641018102410C21010FE1010FE102210641018102410C210
+59E8:2040204027FC2040FBF848484BF84A408BFC4844305410A828A0491082080406
+59E9:1080108010FE1110FE10241024FC2490249048902BFE10102810441084100010
+59EA:100011FE10201040FC88250425FE24222420482029FE10202820442083FE0000
+59EB:100011FE11201120FD2025FC250425042504490429FC11202920452085FE0000
+59EC:100011FE11101110FD10257C2544254425444944297C11102910451085FE0000
+59ED:02001FF00410085010207EFC12242A5444880400FFFE08201C4003800C707008
+59EE:100013FE10001000FDFC2504250425FC2504490429FC11042800440083FE0000
+59EF:1040104412441148FD50244027FE2490249048902890109229124512820E0400
+59F0:1080108011FC1104FE0425E42524252425E44924292411E42904440484280010
+59F1:1020102013FE1050FC88250426FA240027FE4840288011FC2804440484280010
+59F2:20402020202023FEFA024C4448404BFE48889088510820D03020485048888304
+59F3:1040104010FC1104FE88245024202440248049FC2A8410842884448484FC0084
+59F4:00047FA410243F2451240A040C043014C2080200FFFE08201C4003800C707008
+59F5:200027FC24042404F5F45444544455F455549554555425542574544654468842
+59F6:1020102010501088FD04260225FC2400240049FC290411042904450485FC0104
+59F7:1020102011FE1040FC4024FC2484258426FC4884288410FC2884448484940088
+59F8:100011DC10881088FC882488248827DE24884888288810882888450881080208
+59F9:10401020102011FEFD022604241825E024404840287E13C0284044448444003C
+59FA:10201120112011FCFD202620242027FE2490489028901090291245128212040E
+59FB:100011FC11041124FD24252425FC252425244954294C118C2904450481FC0104
+59FC:10201020107C1084FD482430242024482590483E284211A42818441084600180
+59FD:1040104010FC1104FE0825FE2500257C254449442954114829424542853E0200
+59FE:1020102010501088FD04260225FC24202420482029FC10202820442083FE0000
+59FF:4080208009FC12042448E04020A023182C060400FFFE08201C4003800C707008
+5A00:2028202420242020FBFE48204924492489244BA8312811102A124A2A84460082
+5A01:0028002400203FFE202020203FE4222422243FA824A828902512422A45469882
+5A02:1088108810881088FDFE24882488248824884BFE280010882884450482020402
+5A03:1020102011FC1020FC20242027FE24002420482029FC10202820442083FE0000
+5A04:010011100920FFFE054009203118C0060200FFFE042008201C4003800C707008
+5A05:200023FC20902090F89048924C924A948A944A98309010902890489087FE0000
+5A06:2080208020BC23C0F850482448D44B0C88004BFE3090109029124912820E0400
+5A07:1008101C10E01020FC2025FE2450248825044A8A288810882888448884880108
+5A08:02000100FFFE0440145014482444420402007FFC042008401C8003800C707008
+5A09:1020102011FC1124FDFC252425FC240027FE4880290011FC2804440484280010
+5A0A:100011F811081108FDF82508250825F82508490829F81090289045128212040E
+5A0B:1020112410A410A8FC2025FC2504250425FC4904290411FC2904450485140108
+5A0C:100011FC11241124FDFC2524252425FC2420482029FC10202820442087FE0000
+5A0D:2028202420242020FBFE4A204A244A248BA44AA832A812902A924DAA84460882
+5A0E:080C08F07E8008800EFE78880888290812080200FFFE08201C4003800C707008
+5A0F:10901088108013FEFCA024A824B024A424A848B02924112A2932462282DE0400
+5A10:1008103C11C01004FD4424A8240025F8241048202BFE10202820442084A00040
+5A11:1020082040A824A4092A723010C0170002007FFC042008401C8003800C707008
+5A12:1080108010FE1100FEFC248424A4249425FE48842924111429FE440484280010
+5A13:200023FC22042204FBFC4A004A184AE08A384AE0323C13E02A224C22841E0800
+5A14:1020102013FE1020FC2025FC25042504250449FC28501050289244928112020E
+5A15:1020102013FE1020FC2025FC2524252425FC4820287010A82924462280200020
+5A16:100011FC11041104FD04250425FC242024204920293E1120292046A0847E0800
+5A17:2000200623B82088F8884908493E4B8888884A883288113E29004A80847E0800
+5A18:1040102011FC1104FD0425FC2504250425FC4920292211142908454485820100
+5A19:100011FE10001092FD24264825242492240049FE282010202820442083FE0000
+5A1A:11FC1124112411FCFD24252425FC244024404BFE284210822882450282140408
+5A1B:200020F820882088FAF84A004A004BFC8844484437FE104028A0491082080406
+5A1C:20002FDE22522252F25457D45258525452529FD25252225A2254545055508890
+5A1D:100013FE10101020FC6824A427222420240049FC290411042904450485FC0104
+5A1E:2008203C23C02044FA244928490048408BFE4888310813902860485081880604
+5A1F:200021F821082108F9F848004BFC4A044A0493FC5204220433FC4A044A148208
+5A20:200023FC22002200FAF84A004A004BFC8AA04AA432A812902A904C8884A408C2
+5A21:20202020202023FEF8204820482049FC8840482030A412822A8A4A8A84780000
+5A22:1020102010501088FD44262224F824082410482029FC11042904450485FC0104
+5A23:11081088109011FCFC24242425FC2520252049FE286210A2292A462484200020
+5A24:2420242024203DFC0420FC20242024F846000200FFFE08201C4003800C707008
+5A25:101010D813941094FC9027FE24902494249448D82B98109028AA44CA84860182
+5A26:1010103811C01100FD0025FC25102510251049102BFE10002890450882040402
+5A27:1104108410881010FDFC25042504250425FC48502850109028924512820E0400
+5A28:100011FC110411FCFD0425FC2400240025FC4820282013FE2820442084200020
+5A29:1080108010F81108FE1025FC25242524252449FC28501050289044928112020E
+5A2A:100013FE10401040FDFC2484248427FE2400480029FC11042904450485FC0104
+5A2B:2004200E23B82088F8884928492E4BA888A84AA832A8113E29004A80847E0800
+5A2C:2010201823D42014F8104FFE4810489088904AD0329012902A8A4AEA87060202
+5A2D:2020204020882104FBFE4882488049FC8A20482033FE10202850488881040602
+5A2E:1040102013FE1000FC0025FC2400240025FC4800280011FC2904450485FC0104
+5A2F:200020F820882088FAF84A004A004BFC8804480437FE100028A0491082080406
+5A30:21082148212822A8FAA84E884A884A884A88928852A822D432944A224A428282
+5A31:200023F822082208FBF8480048004BF88840484037FE104028A0491082080406
+5A32:200021FC21042104F90449FC482048204BFE92225252228A330A4A024A0A8204
+5A33:204220E22382208AF88A488A4BEA488A498A91CA52AA228234824882488A8084
+5A34:110010BC10041124FD24252425FC2524257449AC292411242924450485140108
+5A35:200027E0225E2252FA524BD24A524A544BD49254524822E83754485448628040
+5A36:00007F7C22443E4422283E1023A8FE4402820400FFFE08201C4003800C707008
+5A37:1008103C11E01020FDFE24A824A824A827FE48A828A813FE2820442085FC0000
+5A38:1088108813FE1088FC8824F82488248824F84888288813FE2800448885040202
+5A39:20102388208820FEF8904B904A244A244A3893885090209030A448BE4A828100
+5A3A:200023DE2042214AF884494A4A524C2088004BDE305211522894494882540422
+5A3B:1020102013FE1020FDFC252425FC252425FC4820287010A82924462280200020
+5A3C:10FC1084108410FCFC84248424FC240025FE4902290211FE2902450285FE0102
+5A3D:100011F810081008FDF82408240827FE24204A22297410A82924462280A00040
+5A3E:100011FE11101110FD7C2510251025FE250049102910117C2910461082FE0400
+5A3F:00007BFE480851E8492845E85408482842100200FFFE08201C4003800C707008
+5A40:2000277E25042504F57455545654555455549554557425542604540454148408
+5A41:01001FF01110FFFE11101FF001001FF011101FF00200FFFE08201C4003C03C38
+5A42:2020204021FC2104F9FC490449FC4820482093FE52222222322A4A2448208020
+5A43:2040202023FE2202F80049FC480048004BFE90205128212432224C2248A08040
+5A44:1040102011FC1000FD082490240027FE2400480029FC11042904450485FC0104
+5A45:1100110011FC1204FC44255424E4244427FC484428E411542A44444484140008
+5A46:202013FE922242204BFC1284E448243029CE0400FFFE08201C4003800C707008
+5A47:2008203C23C02044FA244928490048208BFE487030A810A829244A2284200020
+5A48:2020202021FC2020F8204BFE488849448A4248F8318812502820485081880606
+5A49:2040202023FE2202FD04490049DE4A528A524B52349A1094291049128212040E
+5A4A:1020102013FE1020FC2025FC2420242027FE484028A411A82A90448884C60080
+5A4B:10201020103E1020FDFE2522253825E02522491E290011782A48464A848A0906
+5A4C:2100210021DC2114F114511457D4501451149114558825482948511455148222
+5A4D:1020102011FC1050FC88250427FE240825E84928292811E82928440884280010
+5A4E:10A01090109011FEFD20252027FC2520252049FC29201120292045FE85000100
+5A4F:1080108010F81108FE1025FC25242524252449FC28501058289444928112020E
+5A50:100011FC11241124FDFC2524252425FC24204BFE287010A82924462280200020
+5A51:201C21E020202020FBFE48A849244A42484093FE5088210830D0483048488184
+5A52:102010A210A21124FC50248827042422242048A428A411282850448885040202
+5A53:04400440FC7E04407C7C0440FC7E044006400200FFFE08201C4003800C707008
+5A54:209020902090279EF890489048904B9C489090905090279E3090489048908090
+5A55:2020202023FE2020F9FC48244BFE482489FC48203120113E29204AA0827E0400
+5A56:200023FC20402040FBFE48A049104A084C4690405048226432524C5249408080
+5A57:20002040239C2204FA044B9C4A044A048BFC489030901090289049128212040E
+5A58:1020112410A81020FDFC244027FE248825044AFA2C88108828A844928482007E
+5A59:1080108010F81108FE1025FC2424242425FE4824282411FC2824442084A00040
+5A5A:201C23E0222023FEFA204A924B0A4A0649FC9104510421FC3104490449FC8104
+5A5B:1040102013FE1000FC0025FC2504250425FC4820292811242A22442280A00040
+5A5C:00007F7C48447F4441287F1048287F4400820400FFFE08201C4003800C707008
+5A5D:2040202023FE2202FC0448004BFE482088204920313C11202AA04A60843E0800
+5A5E:1020102011FC1020FC2027FE2488245025FC4820282013FE2820442084200020
+5A5F:200023FE22222222FBFE4A224A224AFA4A8A928A528A22FA328A4A024BFE8202
+5A60:1040102013FE1202FC0425F82508250825F84900290011FC2904450485FC0104
+5A61:20202020202023FEF8204924492449248AAA487030A810A829244A2284200020
+5A62:1040108011FC1124FD2425FC2524254425FC4890291013FE2810441084100010
+5A63:2050225222522252FBDE4A024A024BFE8A024A0233DE12522A52425284520802
+5A64:200023FE22222222FAFA4A224A224BFE8A024AFA328A128A2AFA4A02820A0404
+5A65:10201020103E1020FDFC250425FC250425FC4924282013FE2820442084200020
+5A66:200021FC200420FCF80449FC48004BFE4A22902051FC21243124493449288020
+5A67:1020102013FE1020FDFC242027FE240025FC490429FC110429FC450485140108
+5A68:1020102010501088FD0426FA240025FC2554495429FC1154295445548504010C
+5A69:1020112411241124FDFC240025FE2500257C4910291011FE2910461082100410
+5A6A:082008207EFC08301C682AA4C92208200A207FFC042008401C80038006703808
+5A6B:100011FC11041104FDFC2504250425FC2400491229D41118291045528592010E
+5A6C:1008103C11C01044FD2424A82490241C25E04820282013FE2820442085FC0000
+5A6D:100011FE10481048FC4825CE25022502250249CE284810482848444885FE0000
+5A6E:100011FC11041104FDFC2510251025FE25104910297C114429444544857C0244
+5A6F:0000FEFE00007C7C444464645454444446440200FFFE08201C4003800C707008
+5A70:10501050105011FCFD542554255425FC25544954295413FE2800448881040202
+5A71:00407C2005FC7C4040887DF00420044829FC10040200FFFE08201C4003C03C38
+5A72:1088108813FE1088FC8824502450249425944A98289010B228D24492848E0080
+5A73:200023FE20002000F8F848A84AAA4AFA4AAA92AA52AA22FA32024A024BFE8002
+5A74:00003EF822882AA82AA82AA81450628802007FFC042008401C80038006703808
+5A75:11041088105011FCFD24252425FC2524252449FC282010202BFE442084200020
+5A76:2040202023FE2222F82049FC4924492449FC9124512421FC3124482048208020
+5A77:1040102013FE1000FDFC250425FC240027FE4A0229FC10202820442084A00040
+5A78:100010FC108410FCFC8424FC240025FE248048FE292A124A2892452284540088
+5A79:200023FE20502050FBFE4A524A524BFE4800904057FE20883190486048D88304
+5A7A:00207E20247E18A4FF2829104A2898C602007FFC042008401C80038006703808
+5A7B:2020202023FE2020F8204BFE4A8A4A524AFA9222522222FA32224A224A2A8204
+5A7C:1088108813FE1088FCA8242027FE2440248048FC298412842884448484FC0084
+5A7D:200023DE22422242FA424BDE4A004A3E4BD29212521423D432084A144A248242
+5A7E:21C020A021102208FDF648004BCA4A4A4A5493D45268225433D44A4A4A4A82C0
+5A7F:100013FE10221120FD3C252026FE240025FC490429FC110429FC450481140108
+5A80:21FC2124212421FCF924492449FC4820482093FE5222222A32FA4A0A4A028206
+5A81:2040204021FC2084FBFE480049FC490449FC902053FE202032204BFE48208020
+5A82:2040202021FC2000F88848504BFE4A224C2491FC512421243134492848208020
+5A83:200021FC20482030FBFE4852489449108A30482033FE107028A8492486220020
+5A84:1104108813FE1020FC2025FC2420242027FE4800282013FE2820445080880306
+5A85:1088108813FE1088FCF8248824F8248824884BFE290011482984450085FE0000
+5A86:100013FE10201040FDFC2554255425542554492C282013FE2850448881040202
+5A87:1040102011FC1000FC88245027FE2420242049FC282010A82924462280A00040
+5A88:200023FE22222020FBFE482049FC492449FC912451FC202033FE482048208020
+5A89:200023FC22042204FBFC4A004BFC4A408A884BFC322412202DFC4420882013FE
+5A8A:21082088209027FEF8004BC44A544A544BD49254525423D432544A444A5482C8
+5A8B:1020102013FE1020FDFC244027FE248825044AFA2888108828F84488848800F8
+5A8C:1088108813FE1088FC88240025FC25242524492429FC11242924452485FC0104
+5A8D:1040104010F81108FE1025FC250425FC250449FC290411FC2800448881040202
+5A8E:1020102211FA1024FC2827FE2420244024FC49842A8410FC2884448484FC0084
+5A8F:1020112411241124FDFC240027FE2420244049FC29541154295445548554010C
+5A90:00007F7C444444445F7C51405F4244427FBE0200FFFE08201C4003800C707008
+5A91:2008203C21E02020FBFE482049FC492449FC912451FC202031FC48204BFE8000
+5A92:21102110211027FCF91029F0291029F048404FFE284010E011502A4E44448040
+5A93:1020104011FC1104FDFC250425FC240027FE4820282011FC2820442083FE0000
+5A94:200027FE20402080FBFC4A944A944AF44A94929452F4229432944A944BFC8204
+5A95:1020105010881104FEFA240025FC2504250449FC288810882BFE448881080208
+5A96:2110211027FC2110F95048404BF84A488A484A4837FE104028A0491082080406
+5A97:2040202023FE2202FC0449FC480049FC490491FC510421FC310448004BFE8000
+5A98:1110111211D41118FD522592252E244025FC4904290411FC2904450485FC0104
+5A99:200C200A200823FEFA084BF84A4A4A4A8BEA4AAC32AC124C2AAA4B0A82160422
+5A9A:100011FC11241124FDFC2500257C25442544497C2944117C29444644827C0444
+5A9B:203C27C022442128F8004BFC488048804FFE910051F8228832504C2048D88306
+5A9C:10201020103E1020FC2025FC250425FC250449FC290411FC2800448885040202
+5A9D:0610381008527E5408901C282A2848440A820200FFFE08201C4003800C707008
+5A9E:100011FC11041104FDFC2504250425FC24004BFE28201120293C452082A0047E
+5A9F:10481148114813FEFD4825482578250025FE48202BFE107028A8452486220020
+5AA0:1040104013FE1080FDFC262025FE240025FC490429FC110429FC450485140108
+5AA1:1020102013FE1020FDFC252425AC2574252449FC2820107028A8452482220020
+5AA2:100011FE1102117AFD02257A2502240024FC488428FC108428FC448484FC0084
+5AA3:212020A024782228F8A8492A4F2A494649A0902053FE207030A849244A228020
+5AA4:100011FC11241124FDFC2524252425FC24204810285411422942454A82380000
+5AA5:2040202021FE2102F90249FE4900490089FE49AA31AA12FE2AAA4AAA84A20086
+5AA6:200023FE222223FEFA224BFE480049FC490491FC510421FC3104490449148108
+5AA7:100010FC10841084FCF42494249425FE2502497A294A114A297A4502850A0104
+5AA8:21082088209027FEF89048904BFC4A944A94930C520423FC32044A044BFC8204
+5AA9:1080109E109213F2FC92249E249225D22552495E2952115229D24422842A0044
+5AAA:200021F821082108F9F84908490849F888004BFC329412942A944A9487FE0000
+5AAB:20402040207E2040FBFC480449FC48048BFC48403240127C2A40454084FE0800
+5AAC:2100217C21442244FA444E7C4A104A104AFE92385254225432944B124A108210
+5AAD:0BFE3020C1FC09043124C52409243050C08803040200FFFE08201C4003C03C38
+5AAE:204020A021102208FDF648004BC44A544A5493D45254225433D44A444A5482C8
+5AAF:20402240214027F8F888489048FC490489084BFE3202142A2AAA4A8284140008
+5AB0:2080208021FC2244F95449F4488449284A9091FC5244255431F4488449288210
+5AB1:2008203C23C02004FA44492849FC4A20482093FE502021243124492449FC8004
+5AB2:1020104011FC1154FD242554250425FC2400491229D41118291045528592010E
+5AB3:2020204021FC2104F9FC490449FC490489FC4840302010A42A8A4A8A84780000
+5AB4:2020202021FC2020FBFE480049FC4904490491FC5052209431884EA448C28080
+5AB5:0020792448A8482049FC78404BFE488849447A424DFC488849D0483048489984
+5AB6:2108210827FE2108F8004FFE490849F8490891F85108213E37C8480848088008
+5AB7:200023FE220022FCFA004BFE4AA84A908AC84A86320813FE2A884C4884080818
+5AB8:20202124212421FCF8204BFE4800482049FC9124512421FC302048244BFE8102
+5AB9:204023BE22122292FA524AAA4B2448404BFE9222522223FE32224A224BFE8202
+5ABA:2108254825482550F7DE502450145FD450149794549424A824C8549458149022
+5ABB:10783E4822482A86FF7822482A2842104A2884C60200FFFE08201C4003C03C38
+5ABC:100010F810A810A8FCD8248824F82400240049FC295411542954455483FE0000
+5ABD:200021FE212021FCF92049FC4920492089FE480232AA12AA2AAA4A0280140008
+5ABE:1088108813FE1088FDFC248827FE242025FC492429FC11242BFE450485140108
+5ABF:2020204023FC2224FA244BFC4A244A448BFC484030A810B4293C49228222041E
+5AC0:2040204027FC2040FBF848804FFC49108A684DC6304013F828E0495886440040
+5AC1:2040202023FE2202F80049FC484048A24B34905850942334305248904B508020
+5AC2:10A0112C11241124FDAC2524252425FC242049FC288810502820445080880306
+5AC3:1020102013FE1020FDFC250425FC250425FC490429FC11042BFE448881040202
+5AC4:100011FE11101120FD7C2544257C2544257C4910291011542952469282500420
+5AC5:21082088209023FCF84049F848404BFE4880910051FC2220342048204BFE8000
+5AC6:1040102013FE1202FC50248825242450248849042AFA10882888448884F80088
+5AC7:100013FE12021000FDFC250425FC250425FC4840282013FE2800448881040202
+5AC8:08202AA42CA84920145022887FFE400282040200FFFE08201C4003800C707008
+5AC9:2020201021FE2100F9204D204B3C495089904B1035FE111029284A2882440482
+5ACA:2020202023FE2020F9FC48204BFE4840488891F0502423FE302249244AA28040
+5ACB:200023DE20422042FBDE4A104A104BDE48429252514A214A325248424A948108
+5ACC:10881050100013FEFC5025FC245427FE245449FC285010D82954465284500050
+5ACD:101E11E010221112FC942480242025CE2502490229CE11022902450285FE0102
+5ACE:2040202023FC2108F8904BFE4A024C44482093FC508020F83088490849288210
+5ACF:2100209E23D22252FA544BD44A584A544BD292125292225A32D44B504A108010
+5AD0:200827C825482548F7FE5554555457D45214922457D4224822485254555488A0
+5AD1:7FFC03000D70710C01007FFC04403FF824483FF80400FFFE08201E4003C03C38
+5AD2:200E23F020442224F9084BFE4A4248404BFE908050FC214431284A104C688186
+5AD3:108010F811081210FDFC25242554258C25044810291211D4291845528592010E
+5AD4:2040202023FE2202FC1449E04900490049FC9110511027FE3000489049088204
+5AD5:100011FE1140117CFD90251025FE2528254449FE2820101029444542824A0038
+5AD6:100013FE105011FCFD54255425FC240025FC48002BFE102028A8452482A20040
+5AD7:200023FE2200227CFA444A444A7C4A004AEE92AA52AA22AA32EE4A004BFE8000
+5AD8:100011FC112411FCFD2425FC2440248825F04820284413FE2822452482220060
+5AD9:2420222022202F7EF4805400577C551455109550555C255029505B5050BEA100
+5ADA:200021F8210821F8F90849F848004BFC4A9493FC500021F83090486049988606
+5ADB:7F7848485F4C64805F7844484A4851307F4C0400FFFE08201C4003800C707008
+5ADC:202021FC20882050FBFE480049FC490449FC910451FC202033FE482048208020
+5ADD:1020101011FE1110FD7C251425FE2514257C4910299211542938465482920430
+5ADE:202023FE222022FCFA244BFE4A244AFC8A204AFC32A412FC2AA44CFC84A408AC
+5ADF:200023FE22482248FBFE4A484A204BFE4A4092FC53442244327C4A004BFE8000
+5AE0:08203E7E08A47F281C102A2849443FFE210021003FFE2210272040C043308C0C
+5AE1:2040202023FE2088F8504BFE4A224AFA4A2292FA528A228A32FA4A024A0A8204
+5AE2:11F87D0811F81108FDF8110829F824904112860E0200FFFE08201C4003C03C38
+5AE3:200027FC20402278FA404FFE490049FC4A0093FC500425543554480448288010
+5AE4:1088108813FE1088FCF8242025FC252425FC48202BFE102029FC442083FE0000
+5AE5:102013FE102011FCFD2425FC252425FC24224BFE280813FE2908448884280010
+5AE6:2020212420A823FEFA0248F84888488848F8902051FC21243124493449288020
+5AE7:102013FE102011FCFC2027FE240025FC250449FC290411FC290445FC84880104
+5AE8:1088108813FE1088FCF8242025FC252425FC482029FC10202BFE445080880306
+5AE9:2108210827C82110F11E57E45554555457D49114539425482948511451148122
+5AEA:200027BC208424A4FA944CA4485049884E2690C0531020643388483048C08700
+5AEB:2110211027FC2110F8004BF84A084BF88A084BF8304017FC28A0491082080406
+5AEC:2040202023FE2200FA484A484BFE4A488A484A48327812002D54452A8A2A1000
+5AED:2040207C204023FEFA424A784BC44A3C8A084AF0332412A82DFE442088A00040
+5AEE:11FC102013FE1222FDAC242025AC240025FC48002BFE108028FC440484280010
+5AEF:08207F20087E7E4408A4FF2810101E28224446828200FFFE08201C4003C03C38
+5AF0:2108210827C82108F11E57D25564554057C89108538825482954511451248142
+5AF1:1020102013FE1020FD2424A827FE240025FC4904297411542974450485FC0104
+5AF2:2040202027FE2490F490549057FC549054D895B855B426D42892589050908090
+5AF3:082049202A3E7F4849485DA86B10492841460400FFFE08201C4003800C707008
+5AF4:102013FE102011FCFD0425FC242025FC248848502BFE102029FC442084200020
+5AF5:2080208021FE2354FD5449544BFE49544954915457FE20003154492A4A2A8000
+5AF6:2090208821FE2110FB104DFE4910491089FE4910311011FE29004AA482520452
+5AF7:2020272025FE2540F57C5690557E5500557C9544557C2644247C54445444844C
+5AF8:1088105013FE1020FDFC242027FE252424A84BFE280011FC2904450485FC0104
+5AF9:1088108811FC1088FC8827FE242025FC252449FC292411FC2800448881040202
+5AFA:239C2294239C2294FB9C4A044AF44A944AF4929452F4229432944B344A04820C
+5AFB:200023DE225223DEFA524BDE4A224A224AFA9222527222AA33264A224A2A8204
+5AFC:200021FC212421ACF974492449FC482089FC482033FE10002AA44A5284520000
+5AFD:2020202023FE2050FA8A49044BFE4D0449FC910451FC202031244A224CA28040
+5AFE:2020212420A823FEF8A849244A224904890449DE32441554289E490482040404
+5AFF:202021FC202423FEF82449FC48204BFE480091FC512421FC312449FC480083FE
+5B00:2004203E27C02244F12853F8520853FC520493FE540226AA2AAA5A0250148008
+5B01:202027A420A82292F9144A084DF448028BF84A08320813F82A0841108FFE0000
+5B02:2110209423D22012FA5049904FFE48104BD29252525423D4324A4A4A4BD68022
+5B03:0BFE104061FC090411FC610405FC090431FCC0880504FFFE08201E4003C03C38
+5B04:202023FE202021FCF8004BFE4A0249FC480091FC510421FC310448884BFE8000
+5B05:108813FE10881000FDFC24A824A827FE24A848A829FC10202BFE442084200020
+5B06:204020A0211826E6F00053F8520853F8500097BC508424A4229454A452948108
+5B07:102011FC112411FCFC2027FE240025FC250449FC290411FC290445FC84880104
+5B08:2020202021FC2020FBFE49084B9C49084988963E500023FE309048904912820E
+5B09:102013FE102011FCFC0025FC250425FC24884BFE280011FC2904450485FC0104
+5B0A:0440FFFE044017D0F01217DC3452D7D2100E0400FFFE08201C4003800C707008
+5B0B:200023DE22522252FBDE480049FC492449FC912451FC202033FE482048208020
+5B0C:101811E0104013FEFC88257426522470240049FC29041174295445748504010C
+5B0D:2108254825482550F7DE501457E4501457D4911457D4210821085FD450248042
+5B0E:2200220823A824A8F93E57C85548555C554897C852BE228022825482547E8800
+5B0F:203C23E0212420A8FBFE48A849244A0249FC9124512421FC3124492449FC8104
+5B10:1020102010501088FD0426FA2400240025DC4954295411DC2888448885540222
+5B11:2040202021FC2088F8504BFE480049FC490491FC510421FC30204A944A8A847A
+5B12:1020105010881174FE0225FC252425AC252449FC280010F8288844F8848800F8
+5B13:2108220827C82450F7DE546457D45214511497D4521423C822485454555488A2
+5B14:22002208238824A8F93E57C85548557E554897C852BE228022A25492547E8800
+5B15:100011FC115411FCFC2025FC242027FE2488485029FC10202BFE442084200020
+5B16:00407C2045FC44887C5043FE7C20A5FC24203C200200FFFE08201C4003C03C38
+5B17:202023FE200023FCFA044AF44A944BFC480091F8510821F8310849F8480083FE
+5B18:20882448225020FCF82048504E944A388A504A98323412542A904A2085FE0800
+5B19:2020202023FE2124F9244AAA4FFE480049FC9104517421543174490449FC8104
+5B1A:202023FE22882250FBFE4A504AFC4A548BFE4A5432FC12502AD84D5486520850
+5B1B:200023FC22942294FBFC48004FFE48004BFC920453FC20A231144B084D448182
+5B1C:10207E20243EFF4200947E1042287E2842447E820200FFFE08201C4003C03C38
+5B1D:208023F8220823F8FA084BF84A004BFC8A004BFC304413FC28A0499486C80086
+5B1E:208823FE208821FCF8204BFE482049FC492491FC512421FC30204BFE482087FE
+5B1F:2104208823FE2020F9FC48204BFE48544992909053FE209030D44B8A489681A2
+5B20:10F81088108810F8FC0025DC2554255425DC48202BFE107028A8452482220020
+5B21:203C23C020442224F10857FE544252A4528A947A508020F8210852905060879E
+5B22:2080204027FE2110FA084D144BF849104BF8911057FC212833104D4849868100
+5B23:2040202023FE2222F954494A4A3A480049FC915453FE200031FC482048A08040
+5B24:2040202027FE2488F7DE548855DC56AA54889440548825F02420544859FC9084
+5B25:200023DE20422252F94A4A52489049084BFE951051FE211031FE491049FE8100
+5B26:204027FC204023FCF00057FE500253F8504097FE500027FE200857FE54A88798
+5B27:204023F8204827FEF8484BF848404FFE480092A4545223F832A84AA84FFE8000
+5B28:2108209023FE2108F9084A524B9C49088A524BDE304010A42AAA4A8A84780000
+5B29:2140224C22642244FB4C4A644AA44BAC8AA44AA437FE10002910490882040404
+5B2A:2040202023FE2202F9FC49484A5049FC4B0491FC510421FC310449FC48888104
+5B2B:208822AA22DC2488F9544A2248004BFE8A22482033FE107028A8492486220020
+5B2C:200021FC202023FEFA2249AC482049AC480093FE502021FC315449544954810C
+5B2D:200027FC22482444FFFE544456EC555456EC944456EC255426EC544454548408
+5B2E:3FFE28882F8A20082FBE28882F88289429A220803FFE2208271040E0431C9C02
+5B2F:20402FFE204027FCF00053F852085FFE580297FC511023F8204057FC50408FFE
+5B30:3EF822883EF822883EF822883EF8145022880400FFFE08201C4003800C707008
+5B31:420C2FB082204FA00ABE2FA84AA8CFA842285FA84248FFFE08201C4003C03C38
+5B32:0000F93EA92AA92AF93EAFAAAAAAFABE42904490FABE491249124A92ACAA1044
+5B33:108813FE10A81090FDFE272025FC252025FC492029FE11002BFC44888070038E
+5B34:0100FFFE20003FF800003FF820083FF8010079384FA87AA84AB8792A4AAA9C46
+5B35:21082110223E2222F4BE5722513E520854BE97AA502A20AA256A552E54088008
+5B36:104010F8108810F8FC8824F8240025FC252449FC292411FC280047FE84880108
+5B37:2040202027FE2488F7DE548855DC56AA54889440549025202448548455FC8884
+5B38:202023FE2202241CFBE0492448A84BFE4924920255FC212431FC492449FC8104
+5B39:220024EC24A424A4F6EC54A454A456EC54A494A45FFE20002110510852048404
+5B3A:23FE224823FE2248FA204BFE4A404AFC8B444A7C320013FE28404AA4828A047A
+5B3B:202023FE202021FCF8004BFE4A524BFE490491FC510421FC310449FC48888104
+5B3C:220225E224A226AAF52A566A510A528A544A9BAA510A27CA2122554251EA8E04
+5B3D:23FA22AA23FA2002F7FE540055FC555455FC940057FE204027FE50A051188606
+5B3E:2108210827CE2112F12457DE5552555E57D2911E5392255E2940511451128122
+5B3F:2110211027FC2110F1F0520852EA56AC52A892AA56EA2A06200052A452528452
+5B40:21FC202023FE2222F9AC482049AC4800489E93F2509E21D232BE4C92489E8092
+5B41:3FF801007FFE41029D7401001D7000003BB82AA83BB80400FFFE082007C07838
+5B42:221023DE25282084FBF84A084BF84A088BFA4A243298130628004BFC82940FFE
+5B43:204027FC200023B8FAA84BB849104FFC491097FC511027FE31284B104D488186
+5B44:23DE225223DE2252FBDE4A224AFA4A224AFA92AA52FA22AA32FA4A724AAA8226
+5B45:2148214C22AA2008F7FE51485368514A536A914C536C2148216A539A50268042
+5B46:23DE225223DE2252FBDE4A524BDE498C4A52904057FE20883190486048D88304
+5B47:2108229423DE26B4FBDE4A944BDE4A944BDE921057FC21083090486049988606
+5B48:222223FE209021FEFB104DFE491049FE491091FE510023FE328A4B764A528276
+5B49:208823FE208823DEFA524BDE48A0489049FE912053FC252031FC492049FE8100
+5B4A:202023FE224823FEFA484AEC4B5A4A488A504BDE325013DC2A504DDE84500850
+5B4B:23DE200023DE2252FB5A4A5248204BFE4A5093FE525223FE32924ADC4A9284CE
+5B4C:210447C88812F3BC20084B92F83E0380AAAAABAA0200FFFE08201C4003C03C38
+5B4D:27BC24A427BC2000F7FE54005590549E57D4956455D4255425D455685BC89054
+5B4E:23FE220223FE2292FA544A924AFE4AAA4AFE932252FA22AA32FA4A224DFA8004
+5B4F:208823FE208823DEFA524BDE4A524BDE4A2293FE52AA22FA32224A724AAA8224
+5B50:00007FF800100020004001800100FFFE01000100010001000100010005000200
+5B51:00007FF800100020004001840118016003801D00E10041000100010005000200
+5B52:00007FF80010002000400180010001FE01000100010001000100010005000200
+5B53:00007FF800100020204011800900050003000100018001400130010C05000200
+5B54:00407E4002400440084008400A400C403840C8400840084208420842283E1000
+5B55:00003FF008100820083C100417C4205440880100FFFE01000100010005000200
+5B56:00007EFC02040408081008200A200DFE3820C820082008200820082028A01040
+5B57:020001007FFE400280041FE0004000800100FFFE010001000100010005000200
+5B58:04000400FFFE0800080013F810103020504097FE104010401040104011401080
+5B59:00207E2002200420082008A80AA40CA43922C9220A2208200820082028A01040
+5B5A:00F87F0022101110112000001FE0004000800100FFFE01000100010005000200
+5B5B:010001003FF8010001007FFE400280040FE000400080FFFE0100010005000200
+5B5C:0040FC400440088010FE1108168818883088D050105010201050108851042202
+5B5D:020002083FD002200240FFFE010002003FE0104020805FFC8080008002800100
+5B5E:00001FE0004000800100FFFE0100010005000200091049084824482487E00000
+5B5F:00001FE000400180FFFE01000100050002003FF82448244824482448FFFE0000
+5B60:00003FF800087FC800083F8820883FA800103FE000800100FFFE010005000200
+5B61:00207E2002200440084808840BFE0C823800C8FC088408840884088428FC1084
+5B62:0080FC8005FC0904120415F4151419143114D1F4110411281112110250FE2000
+5B63:00701F80010001007FFC054009203118CFE600400080FFFE0100010005000200
+5B64:0008F83C0BD01290229022902A9032902290E288228822C822A424D4A4924800
+5B65:10001000FEFC2244642818102428C2C600003FE000800100FFFE010005000200
+5B66:22081108111000207FFE400280041FE000400180FFFE01000100010005000200
+5B67:0820102022FC7C24082412447F54008801003FE000800100FFFE010005000200
+5B68:00001FE000800100FFFE0100010005007A7C080810101EFEF010101050502020
+5B69:0020FC1004100BFE10201042148419F83010D02210C413081010102850C42302
+5B6A:02000100FFFE0440145014482444444400003FE000800100FFFE010005000200
+5B6B:000CFDF004200844108811F01420184431FED022102010A81124122250A02040
+5B6C:7FFC008003600D1871040100100010FCFE042208221064FE141008103450C220
+5B6D:0000FDFC0504090411FC1104150419FC3104D10411FC10001088108451022202
+5B6E:0040FC2007FE0A02100011FC1400180033FED020112811241222142250A02040
+5B6F:00007EFC48447E4442287E1048287EC600003FE000800100FFFE010005000200
+5B70:10400840FF4000407EF842487E4801487EC8044808680E5AF88A088A29061202
+5B71:3FFC20043FFC200023F020203FFE204020C02FBE210423885E7E42088A280410
+5B72:0000FDFE04480848104811CE150219023102D1CE104810481048104853FE2000
+5B73:082004407FFC12483CF0082014503EF800003FE000800100FFFE010005000200
+5B74:1FE00040FFFE010003007C7C08081EFEF010105030201FF010101FF010101FF0
+5B75:200ECEF08A22AA92AA54EE00AA7CAA08AA10AA10EEFEA8102810481048508820
+5B76:0820FFFE082012483CF0082014503EF800003FE000800100FFFE010005000200
+5B77:08203E7E08A47F281C102A2849443FFE200023F0202020402FFE404041408080
+5B78:0A803138228838382288393822887FFE4002BFE400800100FFFE010005000200
+5B79:3E1022FE3E4420287EFEA2103EFC221000003FE000800100FFFE010005000200
+5B7A:0000FDFC04200BFE122211AC142019AC3000D3FE102011FC115411545154210C
+5B7B:0020FDFC04240BFE102411FC14201BFE3000D2A4145211FC1154115457FE2000
+5B7C:52107EFE28447E28A2FE3E1020103E7C22103E1000001FE00040FFFE01000300
+5B7D:0820FFFE28207DFC44887C5041FE7C2045FC7C2000001FE00040FFFE01000300
+5B7E:03DEFA520BDE125223DE22522BDE318C2252E04027FE208821902060A0D84304
+5B7F:210447C88812F3BC20084B92F83E0380AAAAABAA00001FE00040FFFE01000300
+5B80:0200010001007FFE400280040000000000000000000000000000000000000000
+5B81:0200010001007FFE4002800400003FF801000100010001000100010005000200
+5B82:0200010001007FFE4002800400000FE0082008200820102010222022401E8000
+5B83:020001007FFE4002800408000808083009C00E00080008040804080407FC0000
+5B84:0200010001007FFE4002820402001FE0022002200420042008221022201E4000
+5B85:020001007FFE40028004002003F03E00020003FCFE0002040204020401FC0000
+5B86:020001007FFE400280043FF8000800083FF8200020003FFC0004000400280010
+5B87:020001007FFE400280043FF8010001000100FFFE010001000100010005000200
+5B88:020001007FFE4002804400400040FFFE00400040104008400840004001400080
+5B89:020001003FFC2004420802000200FFFE0420082018400640018002600C107008
+5B8A:0200010001007FFE40028104012001107FFC010002800280044008203018C006
+5B8B:020001007FFE40028104010001007FFC03800540092011102108C10601000100
+5B8C:020001007FFE400280041FF0000000007FFC044004400440084408441044603C
+5B8D:020001007FFE40028204010000800000FFFE0000044004200810100820044004
+5B8E:020001007FFE4002800400F03F0001000100FFFE01000280044008203018C006
+5B8F:020001007FFE4002820402007FFC04000480088009001100222044108FF80408
+5B90:020001007FFE40028404040007F00810081014202220014000400080FFFE0000
+5B91:020001007FFE4002882408203FF8082008200820FFFE08201020102020204020
+5B92:020001007FFE4002800400F83F00010001F83F00010001FC7F020102010200FE
+5B93:0200010001007FFE400281040090089048244842488289020E101810E7F00000
+5B94:020001007FFE4002820401007FFC0100010001003FF8010001000100FFFE0000
+5B95:020001007FFE4002800400007FFC0400040008001FF82808C80808080FF80808
+5B96:020001007FFE400280047E10021002103E10202040287E24024402FE14420800
+5B97:0200010001007FFE400280041FF0000000007FFC010011101108210445040200
+5B98:020001007FFE400280041FF0101010101FF0100010001FF8100810081FF81008
+5B99:020001007FFE4002810401003FF82108210821083FF82108210821083FF82008
+5B9A:020001007FFE4002800400003FF801000100110011F811001100290047FE8000
+5B9B:020001007FFE400290041EF812882288228852A88C90048208821082207E4000
+5B9C:020001007FFE400280041FF0101010101FF0101010101FF010101010FFFE0000
+5B9D:020001007FFE4002800400007FFC0100010001003FF8010001200110FFFE0000
+5B9E:020001007FFE4002888404800480108008800880FFFE01400220041018086004
+5B9F:020001007FFE4002810401003FF801001FF001007FFC0280044008203018C006
+5BA0:020001007FFE4002842404100410FFFE04800888089010A010C220824182867E
+5BA1:020001007FFE410281043FF8210821083FF8210821083FF82108010001000100
+5BA2:020001007FFE400288040FF010202C4003801C70E00E1FF0101010101FF01010
+5BA3:020001007FFE400280043FF800001FF010101FF010101FF010100000FFFE0000
+5BA4:020001007FFE400280043FF8040008201FF0011001003FF801000100FFFE0000
+5BA5:020001007FFE420282047FF804000FF018102FF048108FF00810081008500820
+5BA6:020001007FFE400280043FF8210021003FF02010201020103FF0210021003FFC
+5BA7:020001007FFE400280043FFC2080208027F82408240827F8208020803FFE0000
+5BA8:020001007FFE4002800404404448245024600C403460C852084A1042203E4000
+5BA9:020001007FFE410291140920054001007FFC0540092011102108C10601000100
+5BAA:020001007FFE4002810411001FF821000100FFFE04400440044008423042C03E
+5BAB:020001007FFE400280041FF0101010101FF000003FF82008200820083FF82008
+5BAC:020001007FFE4002809400883FFC208020883E88225022502A244454418C8604
+5BAD:020001007FFE400280043FF80408FFFE04083FF808001FF8280848088FF80808
+5BAE:020001007FFE400280041FF0101010101FF0020004003FF8200820083FF82008
+5BAF:020001007FFE4002810C1FD00120FFFE01001FF0082030C0CFFC008002800100
+5BB0:020001007FFE420281043FF8000008200440FFFE010001007FFC010001000100
+5BB1:020001007FFE40028884088010FE11403240547C90401040107E104010401040
+5BB2:020001007FFE400280041FF0101010101FF00100FFFE054009203118C1060100
+5BB3:020001007FFE400281043FF801001FF00100FFFE01001FF0101010101FF01010
+5BB4:020001007FFE40029FF410101FF010101FF00400FFFE08201C4003800C703008
+5BB5:020001007FFE40029114092001001FF010101FF010101FF01010101010501020
+5BB6:020001007FFE400280047FFC02000D08719002A00CC071A006981886E2800100
+5BB7:020001007FFE400280F43F00111009200100FFFE0380054009203118C1060100
+5BB8:020001007FFE400280043FF820002FF020003FFC248824504420451886060400
+5BB9:020001007FFE4002882411102288044008203018DFF61010101010101FF01010
+5BBA:020001007FFE40029FF4101010101FF00000FFFE09200920112011222122411E
+5BBB:020001007FFE4002BFF410104824244803801C70E00E0100210821083FF80008
+5BBC:020001007FFE400280243E2001FE00447E4414C814281410146A2586240243FE
+5BBD:020001007FFE400284443FF8044000001FF0101011101110129004821882E07E
+5BBE:020001007FFE400280741F80100010001FF810801080FFFE0000084010202010
+5BBF:020001007FFE400288040FFC1040308053F89208120813F81208120813F81208
+5BC0:020001007FFE4002801400F83F001110082001007FFC054009203118C1060100
+5BC1:01007FFE400281047FFC01003FF80108FFFE01083FF8110011F8290047FE8000
+5BC2:020001007FFE400288040F7C08440844FF44002808282A104910892828441082
+5BC3:020001007FFE48028FE4102020405FF8110811081FF8028004A008921082607E
+5BC4:020001007FFE420282043FF804800840FFFE00101F90109010901F9000500020
+5BC5:020001007FFE40029FF401001FF0111011101FF0111011101FF0044008201010
+5BC6:020001007FFE40028224094028884B141C10E7F001002108210821083FF80008
+5BC7:020001007FFE400280243E38002000207EF814081450142014542484240443FC
+5BC8:01007FFE4102BFFC01001FF00100FFFE00001FF010101FF010101FF010101030
+5BC9:020001007FFE490288841FFC108030805FF8908010801FF8108010801FFC1000
+5BCA:020001007FFE420283F402003FF820083FF820083FF820083FF8082010102008
+5BCB:020001007FFE4822BFFC08203FF80820FFFE10102FE8C82608A00848080807F8
+5BCC:020001007FFE4002BFFC00001FF010101FF000003FF821083FF821083FF82008
+5BCD:020001007FFE4002820409084924482487E000003FF8244824482448FFFE0000
+5BCE:020001007FFE4002840425FC24203C2005FC05247D2425542594250445148508
+5BCF:020001007FFE48028FE410403FF852481428110801007FFC028004401830E00E
+5BD0:020001007FFE40028424242025FC3C20042007FE7C6024B02528262644208420
+5BD1:020001007FFE40028BFC080811F8300853F8900017FC140413F8111010E0171C
+5BD2:020001007FFE44429FF404403FF80440FFFE082013102088C046060001800040
+5BD3:020001007FFE40029FF411101FF011101FF001003FF8210821482FE824282010
+5BD4:020001007FFE40029FF410101FF010101FF000007FFC110011F8290047FE8000
+5BD5:020001007FFE4002BFFC02003FF8244824483FF80000FFFE0100010005000200
+5BD6:020001007FFE4002A3FC100811F8800843F8500017FC2404E3F8211020E0271C
+5BD7:01007FFE420281440880292847E4180061003FF821083FF82108FFFE20082018
+5BD8:01007FFE4102BFFC01001FF010101FF010101FF010101FF01010FFFE08201010
+5BD9:020001007FFE40028004061C38E828A82CA82AA82AA82AA828A455545D748212
+5BDA:020001007FFE4002BFFC01001FF001007FFC10001FF02100FFFE010021083FF8
+5BDB:020001007FFE4822BFFC08201FF010101FF010101FF010101FF004421842E03E
+5BDC:020001007FFE41029494142823E800003FF824482448FFFE0100010005000200
+5BDD:01007FFE4002800413F8100891F8500853F8100037FC540493F8111010E0171C
+5BDE:01007FFE400284443FF804401FF010101FF010101FF002007FFC04401830E00E
+5BDF:01007FFE400290841EF822885450282017D82006DFF001001110210845040200
+5BE0:020001007FFE4102BFFC2108FFFE21083FF811101FF00400FFFE082007C07838
+5BE1:01007FFE4002BFF404001FF010101FF010101FF01010FFFE082037D8C2460CC0
+5BE2:01007FFE4002840424FC2404247C3C0404FC04007DFE250224FC2448443085CE
+5BE3:020001007FFE4042842425FC24003CF8040004F87C0024F82488248844F88488
+5BE4:020001007FFE400285FC242024F83C48044805FE7C0024FC2484248444FC8484
+5BE5:01007FFE4002BCFC24481428254806C01830E30E0C403180063038C007003800
+5BE6:01007FFE40029FF41110FFFE22103FF010101FF010101FF010101FF008201010
+5BE7:01007FFE4102949414A823E800003FF82448FFFE00003FF80100010005000200
+5BE8:01007FFE44429FF404403FF80440FFFE082011102FE8C1060920111025080200
+5BE9:01007FFE400280FC3F0011100920FFFE09203018DFF611101FF011101FF01010
+5BEA:01007FFE400280FC7F00221011201FE010201FF010101FFC20042AA44AA4800C
+5BEB:01007FFE400282041CF010101EF010101FF008001FFC20044924249424944008
+5BEC:020001007FFE4822BFFC08201FF010101FF010101FF010101FF00452184AE03E
+5BED:01007FFE4102BFFC01001FF011101FF011101FF001087FFC02044908482487E4
+5BEE:01007FFE400281047FFC044028281FF02828CFE608200FE00100111025080200
+5BEF:01007FFE490288841FFC30805FF890801FF810801FFC10003E7C224423D42008
+5BF0:01007FFE4002BFFC24483FF80000FFFE00001FF010101FF005081890EA600C1C
+5BF1:020001007FFE404289FC490449FC490479FC090409FCF8204BFE48A849248A22
+5BF2:020001007FFE4002A47C3A0422281E1020FE3E124850085E7F5014B0229E4100
+5BF3:01007FFE4082BEFC09243EA809247EA000401FF010101FF010101FF008201010
+5BF4:020001007FFE400288047F7C2244147CFF44087C7F44087C2A28492AA94A1086
+5BF5:0100FFFE88427F7C2240147CFF04007C7F40417C7F40417C7F40417C4542423E
+5BF6:01007FFE4082BEFC09203EFC08207EA400FC1FF010101FF010101FF008201010
+5BF7:01007FFE48229D7449245D7449245D7449247FFC00007FFC10101FF00820FFFE
+5BF8:0040004000400040FFFE00400040004010400840084000400040004001400080
+5BF9:0010001000107E1002FE02102410149008500850141012102210401000500020
+5BFA:0100010001003FF801000100FFFE002000207FFC082004200420002000A00040
+5BFB:00003FF8000800081FF8000800083FF800200020FFFE08200420042000A00040
+5BFC:00003FF0201020103FF0200420041FFC00200020FFFE08200420042000A00040
+5BFD:000801FC7E0002082108111010400040FFFE0040104008400840004001400080
+5BFE:2010101010100010FEFE04100410489028501050101028102410441080500020
+5BFF:020002007FFC02003FF80400FFFE082008201FFC102024204220822000A00040
+5C00:000800087F884008407E5F0851085148512851285F08510840087F8800280010
+5C01:0808080808087F08087E0808FF080048082808287F08080808080F08F0284010
+5C02:01000100FFFE01003FF821083FF821083FF80020FFFE08200420042000A00040
+5C03:012001107FFC01003FF821083FF821083FF821080020FFFE0820042004A00040
+5C04:080810083E0822083EFE22083E0822082248FE2806280A08120822084A280410
+5C05:08080808FF08080808FE7F08414841287F281408140814282412240243FE8000
+5C06:088008F809084A1028A0284008900B1018102BFEC81009100890081008500820
+5C07:0440247C24C4252824903CA004480588FC0825FE240824882448440884280410
+5C08:01007FFC01003FF821083FF821083FF80104FFFE0022FFFE0820042004A00040
+5C09:00043F84208420843FBE20042F84202420143FD422042A844A4452448A140408
+5C0A:08200440FFFE04403FF82848303827C820083FF80020FFFE0820042004A00040
+5C0B:00003FF000101FF000103FF000003E7C08447F7C0020FFFE0820042004A00040
+5C0C:08080808FF880808087E7F0800087F48412841287F08000822081788F8284010
+5C0D:1408140855083608147EFF080008224814287F2808083E0808080F0878282010
+5C0E:211017FE108003F8F20813F8120813F8120813F8280047FE0020FFFE08200460
+5C0F:0100010001000100010011101108110421042102410281020100010005000200
+5C10:01000100010009200910110811042104410001000000180024000380007E0000
+5C11:010001000100092009101108110421144110012000400080010002000C007000
+5C12:010001000280044008203118C106010009200910110821044104010005000200
+5C13:0800080008001FFC100021004100810001001110110821044102810205000200
+5C14:0800080008001FFC100421084100810001001110110821044102810205000200
+5C15:00003FF008100820083C10041004211441080920091011082104410405000200
+5C16:01000100092009101108210800000104FFFE01000280028004400830300EC004
+5C17:0200020003F8020002000200FFFE010001000920111021084104010005000200
+5C18:01000100092009101108210441040000010001003FF8010001000100FFFE0000
+5C19:010011101108210441043FF82008200827C824482448244827C8200820282010
+5C1A:010021081110092001003FF82008200827C824482448244827C8200820282010
+5C1B:0100010009200910110821044104101010101010545452529292101050502020
+5C1C:010009201110210800000100FFFE02800C603018C10609200910110825080200
+5C1D:01001110092001007FFE400280041FF0000000007FFC0400082010103FF81008
+5C1E:010001007FFC2288145008203FF8D0161FF010101FF001001110210845040200
+5C1F:00103E1022103E5422523E520090FF12080408082F102860298058004FFE8000
+5C20:22102210FF1022103E5422523E5222902210FF1440045408620840107E2000C0
+5C21:100011FC9104550459FC1104FD0429FC2800291229D429182B104D524992810E
+5C22:0400040004000400FFFE048004800480048008800880108210822082407E8000
+5C23:04400420081010082004444284420440044004400440084208421042203E4000
+5C24:0420041004100400FFFE048004800480048008800880108210822082407E8000
+5C25:20802080208021F8FD082A082888284828482808280828502822480247FE8000
+5C26:004024402240427C808425042444242424242404240424282412440243FE8000
+5C27:0200020002FC7F20014000840764381C0000FFFE04400440044008423042C03E
+5C28:0420041004100400FFFE049004A004C8049008A408C8109210E221824E7E8000
+5C29:000024FC22204220802024F8242024202420242025FC24002402440243FE8000
+5C2A:200023F820402040FC40284029F028402840284028402BF82802480247FE8000
+5C2B:000001FCFE202420242025FC242024202420242027FE24002400440243FE8000
+5C2C:2020202020502088FD042A022888288828882888290829082A0A480247FE8000
+5C2D:010001007FFC010009200820FFFE082008207FFC04400440084010422042C03E
+5C2E:200023F820882090FCBC290429142A4828402BFC28E029502A4A484247FE8000
+5C2F:2080208021F82208FDFE2900297829482968295029442A442C3E480247FE8000
+5C30:203C21E0202023FEFC2029FC292429FC292429FC282029FC28204BFE480287FE
+5C31:20401050FE48004800407DFE4450445044507C501090549092921112510E2200
+5C32:2088205023FE2050FDFC28542BFE285429FC285028D829542A52485247FE8000
+5C33:20F8208820E820A8FDFC290428F8288828F8288828F82888288848AA489287FE
+5C34:2090229022BC22D0FE882A8828002BF82AA82AA82AA82FFE2802480247FE8000
+5C35:202021FC212421FCFC202BFE290429FC290429FC290429FC28884906480287FE
+5C36:03E8FE882BCE2A502BE42A822BE0280029FC2954295429542BFE480247FE8000
+5C37:23E8228823CE2250FFE42A822BE0280029FC2954295429542BFE480247FE8000
+5C38:00001FF810081008100810081FF8100810001000100010002000200040008000
+5C39:000000003FF004100410FFFE041004103FF00410040008000800100020004000
+5C3A:00001FF810081008100810081FF8108010801080104010402020201040088006
+5C3B:00003FF8200820083FF8210021002FE0212021202220222044224422881E1000
+5C3C:00001FFC1004100410041FFC10001200120C123013C012022202220241FE8000
+5C3D:00001FF81008100810081FF81048104010202310208840068C00030000800040
+5C3E:00003FFC200420043FFC200020F02F00210021F02F00210021F85F02410280FE
+5C3F:00003FF8200820083FF82080208020882ED022E022A024A04490488892840100
+5C40:00003FF8200820083FF8200020003FFC200427E42424242447E4400480280010
+5C41:00003FF8200820083FF820002840284028442F4828502860484449448A440C3C
+5C42:00003FFC200420043FFC200020002FFC200020003FFE2100221044084FFC8404
+5C43:00003FFC200420043FFC2000200027FC240424442444244424B4410846049802
+5C44:00003FFC200420043FFC208020402FFE28023124212022102210440848049002
+5C45:00003FF8200820083FF8208020803FFE208020802FF82808480848088FF80808
+5C46:00003FFC200420043FFC2000208028842BE4288428842FF4280448044FFC8004
+5C47:00003FFC200420043FFC200027FC24442444244427FC24442444444447FC8404
+5C48:00003FF8200820083FF820802888288828882FF820803084508450849FFC0004
+5C49:00003FF8200820083FF820902490249024903FFC2490249044F04400840007FE
+5C4A:00003FF8200820083FF82080208020802FF8288828882FF8488848888FF80808
+5C4B:00003FFC200420043FFC20002FFC2100221027F8208820802FFC40804080BFFE
+5C4C:00003FFC200420043FFC200027FC2404240427FC20402FFE2842484A48448040
+5C4D:00003FFC200420043FFC200020003FFE2420242427A828B0352042224422981E
+5C4E:00003FFC200420043FFC2080249022A020803FFC21C022A02490488850868080
+5C4F:00003FF8200820083FF8241022202FF8222022203FFC22204220442084200820
+5C50:00003FFC20043FFC2020242029FE3020222025FC2C8434884450442084D80706
+5C51:00003FF8200820083FF82080249022A02FF828082FF828084FF8480888280810
+5C52:00003FFC20043FFC20002FF828002BF828002FFC2A482A5052205298A3060200
+5C53:00003FFC200420043FFC200027FC240427FC240427FC240427FC411042088404
+5C54:000002FE3C822082208220FE3E8024A024A224A424B82EA0F1224122021E0400
+5C55:3FFC200420043FFC222022203FFC222022203FFC244024442428451046088406
+5C56:00003FFC20043FFC210020802FF8241022203FFC208020804FF8408080800080
+5C57:00083F082108217E3F08204823283C2827083C0827A83C122402440243FE8000
+5C58:00003F7E210221043F082008237E3C0827083C0827883C2A2412440243FE8000
+5C59:00003FFC20043FFC20002EFC2A082AE82CA82AA82AA82AE84AA84E0888280810
+5C5A:00003FFC20043FFC20003FFE20802FFC28842CA42A9428844CA44A948884080C
+5C5B:00003FFC200420043FFC210822102F7C221022103F7E22102210441044108810
+5C5C:00003FFC200420043FFC222824A82AA823FE24A82CA834A824B8448044FE8400
+5C5D:00003FFC200420043FFC212021202F3C212021202738212021204F3C41208120
+5C5E:00003FFC20043FFC20002FF820802FF828882FF820803FFC509457F490141008
+5C5F:3FFC20043FFC200024883FFE248824F8240027FC20402FFE415042488C460040
+5C60:00003FFC20043FFC2080208827F020A03FFE208023F826085BF8420883F80208
+5C61:3FFC20043FFC249022A03FFC22A02490288821003FFC2210472040C083300C08
+5C62:3FFC20043FFC20802FF828883FFE28882FF8249027F021005FFE441083E01C1C
+5C63:3FFC20043FFC22102410289C3090229025FE2C103490249C44904550863E0400
+5C64:3FFC20043FFC221021202FFC2A9429A42FFC200027F8240847F8440887F80408
+5C65:3FFC20043FFC210029FE320021FC250429FC390429FC288049FC4A8888700B8E
+5C66:00003FFC20043FFC2000252428A831FC24A8292438402BFE4888499088700B8C
+5C67:3FFC20043FFC244825482BFE354825782D0035FE242027FE44A8452486220420
+5C68:3FFC20043FFC242029FC312423FE25242DFC34A824F8244045FE44888470058C
+5C69:3FFC20043FFC220025FC284033FE24882D74365225FC2504457445548574050C
+5C6A:3FFC20043FFC20402FFE288227FC21102BFA260C2BFA220843F84040844808C4
+5C6B:3FFC20043FFC200022FE2A202BFE2E4422BA23283EFE2A824ABA4AAA92BA2286
+5C6C:3FFC20043FFC249022A024902FF829482FFC24842FF4349447F440948FF40008
+5C6D:3FFC20043FFC220823F8220823F8211022082FBE28A22FBE48A24FBE851408A2
+5C6E:01000100210821082108210821083FF801080100010001000100010001000100
+5C6F:010001000100FFFE010021082108210821083FF8010001020102010200FE0000
+5C70:101008100820FFFE010001002108210821083FF802080400040008003000C000
+5C71:01000100010001002108210821082108210821082108210821083FF800080000
+5C72:0008007C078078000100010001002108210821082108210821083FF800080000
+5C73:060001000280044008203118C10601002108210821082108210821083FF80008
+5C74:010001002108210821083FF8020002007FF80208040804080808100820504020
+5C75:01002108210821083FF8000000003FFC20002000200020002000400040008000
+5C76:010001002108210821083FF8000000007FF8040804080808080810082050C020
+5C77:1000100013F810885490549054A054BC5484548455045D046504020402280410
+5C78:1000100011FC102054205420542054205420542054205C206420002003FE0000
+5C79:10401040108010FE5500560054FC54085410542054405C806502010200FE0000
+5C7A:1000100011F8100854085408540855F85508550055005D006502010200FE0000
+5C7B:1000100011FC104454445544554455445544564454445C846484010402280410
+5C7C:1000100013FC109054905490549054905490549054905C9265120112020E0400
+5C7D:100011FC1020102054205420542057FE5420542054205C206420002000200020
+5C7E:102010201020102055245524552455245524552455245D24652401FC00040000
+5C7F:104010401040107E54405480548054FC5404540454045DF46404000400280010
+5C80:0100010021082108210821083FF80000010041044104410441047FFC00040000
+5C81:01002108210821083FF80200020007F00810141022200140008003001C00E000
+5C82:01002108210821083FF8000000003FF00010001000103FF02000200420041FFC
+5C83:01002108210821083FF8000000003FF802081208120822080408080810506020
+5C84:100010FC10841084548454FC54845484548454FC54845C846504010402140408
+5C85:1008101C11E01100550055FC554455445544552855285D106510022802440482
+5C86:1008103C11E010205420542057FE54205420545054505C506488008801040202
+5C87:01002108210821083FF800000C0070FC4084408440844C847094408800800080
+5C88:100011FE1008108854885488550855FE5418542854485C886508020800280010
+5C89:10801080108010FC55545654545454945494552456245C446444008401280010
+5C8A:00003FF8210821083FF82000200220021FFE010001002108210821083FF80008
+5C8B:100013FC1084108854885490549C54845544554455285D286610022804440182
+5C8C:0100210821083FF800003FF0082008400CF80A08111010A0204020A043188C06
+5C8D:100011FC1088108854885488548857FE5488548854885C886488010801080208
+5C8E:101010901090108855085504560455FA5488548854885C886508010802280410
+5C8F:100011FC10001000540057FE549054905490549054905C9265120112020E0400
+5C90:10201020102013FE54205420542055FC5484548854485C506420005001880606
+5C91:0100210821083FF80100028004400A203118C1061FE000200040004000800100
+5C92:10201020105010505488554456225420540055FC54045C086408001000100020
+5C93:1008101C10E010805480548054FE54885488548854885C886508010802080408
+5C94:0440082010102FE8C4260420082010A06040010001002108210821083FF80008
+5C95:01002108210821083FF801000280044008203458C44604400440084008401040
+5C96:100011FE1100110455445528552855105510552855285D446584010001FE0000
+5C97:0100210821083FF800003FF82008204824482288210822882448280820282010
+5C98:100011FC1104110455245524552455245524555454505C90649001120212040E
+5C99:001000F83F00010002007FFC044008203018C10601002108210821083FF80008
+5C9A:0100210821083FF800001FF0101010501450129011101292244A284A40068002
+5C9B:010002001FF0101012101150102010001FFC0204222422243FE4000400280010
+5C9C:0100210821083FF800003FF82108210821083FF820002002200220021FFE0000
+5C9D:0100210821083FF8080008001FFC2400440087F00400040007F8040004000400
+5C9E:10801080108010FE554055405640547C5440544054405C7E6440004000400040
+5C9F:10201020102011FC5524552455245524552457FE54205C506450008801040202
+5CA0:100010FE10801080548054FC548454845484548454FC5C806480008000FE0000
+5CA1:00007FFC40044824442444445FF4410441044924492449244FE4400440144008
+5CA2:0100210821083FF800000000FFFE001000101F90109010901F90001000500020
+5CA3:10801080110011FC5604540455E455245524552455E45D246404000400280010
+5CA4:20402020202023FEAA02AC04A800A890A890A890A888B908C908010402040402
+5CA5:10101010101011FE55125514551055FC5544554455285D286510022802440482
+5CA6:01002108210821083FF80200010001007FFC00001010082004400000FFFE0000
+5CA7:0100210821083FF800007FF80408080810502020DFF81008100810081FF81008
+5CA8:100010F810881088548854F854885488548854F854885C886488008803FE0000
+5CA9:01002108210821083FF8000000007FFC040004000FF818082808C8080FF80808
+5CAA:0100210821083FF804403FF8044804481FF8144024403FFC0844105420484040
+5CAB:102010201020102055FC552455245524552455FC55245D246524012401FC0104
+5CAC:100011FC11241124552455FC55245524552455FC55245C206420002000200020
+5CAD:1020102010501050548855245612541055FC540454085C886450002000100010
+5CAE:10201010101011FE5502560454805488549054A054C05C8264820082007E0000
+5CAF:100011FE1010101054205420546854A45522562254205C206420000003FE0000
+5CB0:2010209020902110A97EAA52AB92A892A912A912AA52BBD2C8620022004A0084
+5CB1:089008881080309E57E0908010441034110C010021082108210821083FF80008
+5CB2:100011FC110411045504550455FC54505450545054505C9264920112020E0400
+5CB3:00701F80100010001FF8108010801080FFFE010001002108210821083FF80008
+5CB4:1008101C10E0108054805480548054FE5488548854885C886488008801FE0000
+5CB5:102010201020102055FE54205420542055FC550455045D046504010401FC0104
+5CB6:10201020104011FC550455045504550455FC550455045D046504010401FC0104
+5CB7:100011FC11041104550455FC5520552055FE552055205D106512014A01860102
+5CB8:0100210821083FF800003FFC20002FF8208020803FFE20804080408080800080
+5CB9:100013FC108410845484550455145608540055FC55045D046504010401FC0104
+5CBA:0100210821083FF8010002800C603218C1061FE0002000400C80030000800040
+5CBB:1004101E11F0111055105510551055FE5510551055105D08650A014A01A60112
+5CBC:100011FC10201020552454A454A8542057FE542054205C206420002000200020
+5CBD:0100210821083FF8020002007FFC0400090011003FF801001110210845040200
+5CBE:1020102010201020543E54205420542055FC550455045D046504010401FC0104
+5CBF:0100210821083FF8000008004BF848084808480849F848084808100813F82008
+5CC0:01002108210821083FF80000010001003FF8210821083FF8210821083FF82008
+5CC1:0100210821083FF800000C0070FC4084448444845C8464944888088010806080
+5CC2:10401040107C108455885650542054505488570654605C10640800C000200010
+5CC3:020821081110102000007FFE400281040100210821082108210821083FF80008
+5CC4:100013FC110410885450542054D85726542055FC54205C2067FE002000200020
+5CC5:1020102010401088550457FE54025488548857FE54885C886508010802080408
+5CC6:10201020105010885504560255FC5400540055FC55045D046504010401FC0104
+5CC7:0100210821083FF8010002800C603018CFE600001FF01010101010101FF01010
+5CC8:2080208020F82108AB10ACA0A840A8A0A918AA06ADF8B908C908010801F80108
+5CC9:0100210821083FF808000FF010202C4003801C70E00E1FF0101010101FF01010
+5CCA:040008003FF0201020103FF020003FF8200820083FF80100210821083FF80008
+5CCB:1080108011FC1104560455E45524552455E4552455245DE46504000400280010
+5CCC:100011FE102010405488550455FE54225420542055FE5C206420002003FE0000
+5CCD:2020202021FC2024ABFEA824A9FCA820A820A9FCA820B820CBFE002000200020
+5CCE:0100210821083FF800003FF020103FF020103FF02208211020A024402830300E
+5CCF:100013FE10201020544055FC555455545554555455545D546554014401140108
+5CD0:10201010101013FE54205442548455F85410542254C45F086410002800C40302
+5CD1:0100210821083FF801000280044008203018CFE6010001001FF0010001007FFC
+5CD2:100011FE11021102557A55025502557A554A554A554A5D7A65020102010A0104
+5CD3:1020102013FE102055FC542455FC552055FE5422542A5C546450008801040202
+5CD4:10401040104411F45448545057FE54405480558456985CE064820082007E0000
+5CD5:0100210821083FF802000100FFFE00001FF0101010101FF0101010101FF01010
+5CD6:20402020202023FEAA02AC44A840ABFEA888A888A908B8D0C820005000880304
+5CD7:1040104010FC1104560855FE5500557C5544554455545D4865420242023E0400
+5CD8:100013FE1000100055FC5504550455FC5504550455FC5D046400000003FE0000
+5CD9:10201020102011FC5420542057FE5408540855FE54085C886448000800280010
+5CDA:0100210821083FF8000002007FFC04401830E10E01001FF0010001007FFC0000
+5CDB:0100210821083FF800047F84082408241F24212451240A24040408043014C008
+5CDC:0100210821083FF801000280044008203118C10609F00900090009007FFC0000
+5CDD:0100210821083FF800003FF820082FE8200827C82448244827C8200820282010
+5CDE:0100210821083FF808001FE020205FFC900017F0141014542424240443FC8000
+5CDF:0100210821083FF8040004007FFC08001FF028104FF088100FF0081008500820
+5CE0:10201020103E1020542055FE5400540055FE542054285C246422002000200020
+5CE1:10201020102011FC5420552454A454A8542057FE54505C506488008801040202
+5CE2:2002200227E2210AA90AA9EAA92AAA2AAB2AAAAAAC4AB84AC8820102020A0404
+5CE3:1080108010BC13C05450542454D4570C540057FE54905C9065120112020E0400
+5CE4:1008103C11E01020542057FE545054885504568A54885C886488010801080208
+5CE5:1080108010F81108561055FC5424542455FE542454245DFC6424002000A00040
+5CE6:02000100FFFE044014501448244444440100010021082108210821083FF80008
+5CE7:10401020102013FE54005488550456025488548854505C506420005000880306
+5CE8:101010D813941094549057FE54905494549454D857985C9064AA00CA02860102
+5CE9:010041047FFC0000064038500848FFFE084008400E2478280812082A28C61302
+5CEA:10001050104810845524542054505488550656F854885C886488008800F80088
+5CEB:200027DE20922292AA94AA94ABD8A894A992A992AA92BA9ACC94089002900110
+5CEC:1028102413FE1020542055FC5524552455FC552455245DFC652401240124010C
+5CED:1020112410A410A8542055FC5504550455FC550455045DFC6504010401140108
+5CEE:200023F820882088AFFEA888A888ABF8A900A900ABF8BD08C908010801F80108
+5CEF:010041047FFC08001FF0282007C01830E10E1FF001001FF001007FFC01000100
+5CF0:1040104010FC10885550542054D8572654F8542054F85C2067FE002000200020
+5CF1:000045FC2824102429FC484488440BFE18002820482089240924092451FC2004
+5CF2:0100210821083FF800000608780808480848FF481C482A484948880808280810
+5CF3:0100210821083FF8000010401040247E24886488A54824502420205020882306
+5CF4:100011FC1104110455FC5504550455FC5504550455FC5C50645000920112020E
+5CF5:2040202023FE2202AC44A840ABFEA840A890A890A910B920CA24024204FE0842
+5CF6:020004001FF010101FF010101FF010001FFC10001FFC020422243FE400280010
+5CF7:0100210821083FF8020001003FF808200440FFFE010001007FFC010001000100
+5CF8:2028202420242020ABFEAA20AA24AA24ABA4AAA8AAA8BA90CA9205AA04460882
+5CF9:010002800C603018CFE601003FF801001110250802000100210821083FF80008
+5CFA:100013FE1020102055FC5524552455FC5524552455FC5D2064A0004000B0030E
+5CFB:2040204020882104ABFEA802A888A944AA42A8F8A988BA50C820005001880606
+5CFC:10201120112011FC55205620542057FE5400540055FC5D046504010401FC0104
+5CFD:10201020102013FE5420542055245524552456AA54205C506450008801040202
+5CFE:200C11F08100490009FE1110E11022102210251001002108210821083FF80008
+5CFF:100013FE1040104055FC5484548457FE5400540055FC5D046504010401FC0104
+5D00:0100210821083FF8020001001FF010101FF010101FF011081090126014181806
+5D01:0100210821083FF81080108010FC7D041248104010401CA0E0A0411002080C06
+5D02:2088208823FE2088A800ABFEAA02AC44A840ABFCA844B884C884010402280410
+5D03:20402040204027FCA840AA48A948A950AFFEA8E0A950B950CA48044408420040
+5D04:10201020105010505488550456FA54005444542455245CA86488001003FE0000
+5D05:10401040107C1084550856FE5492549254FE549254925CFE64920112010A0204
+5D06:20402020202023FEAA02AC94A908AA04A800A9FCA820B820C820002007FE0000
+5D07:0100210821083FF8020001007FFE40029FF400007FFC01001110210845040200
+5D08:020001007FFE40029FF400007FFC11102108450402000100210821083FF80008
+5D09:1020102213B410A854A8552456A2544055FC550455045DFC6504010401FC0104
+5D0A:2088208820882088ABDEA888A888A99CA9DCAAAAAAAABCC8C888008800880088
+5D0B:0100210821083FF800007FFC11101110FFFE111011107FFC0100FFFE01000100
+5D0C:100011FE1102110255FE5510551055FE55105510557E5D4265420242027E0442
+5D0D:10201020102013FE542055245524552456AA547054A85CA86524022204200020
+5D0E:1020102011FC10505488550457FE540855E8552855285DE86528000800280010
+5D0F:201C23E0222023FEAA20AA92AB0AAA06A9FCA904A904B9FCC904010401FC0104
+5D10:100011FC1104110455FC5504550455FC5400551255D45D18651001520192010E
+5D11:0100210821083FF800001FF810081FF810081FF82080208C3EF020822682387E
+5D12:0100210821083FF8020001007FFC0820145022880100FFFE0100010001000100
+5D13:200023FE22222222ABFEAA22AA22AAFAAA8AAA8AAA8ABAFACA8A020203FE0202
+5D14:010041047FFC090008801FFC108030805FF8908010801FF8108010801FFC1000
+5D15:100011FE11101110557C5510551055FE5500551055105D7C6510021002FE0400
+5D16:0100210821083FF800003FFC20802FF820803FFC200020804FF840809FFE0000
+5D17:0100210821083FF800007FFC482444445FF441044924492449244FE440144008
+5D18:1020102010501088550456FA540055FC5554555455FC5D54655401540104010C
+5D19:0100210821083FF802800C6037D8C0063FF8248824883FF82488248824A82010
+5D1A:2020202021FC2020A820ABFEA888A944AA42A8F8A988BA50C820005001880606
+5D1B:200023FE22022202ABFEAA10AA92AA92AA92AAFEAA10BA92CA92049204FE0802
+5D1C:2008203C21E02020ABFEA8A8A8A8A8A8ABFEA8A8A8A8BBFEC820002001FC0000
+5D1D:1020102013FE102055FC542057FE540055FC550455FC5D0465FC010401140108
+5D1E:2040202023FE2000A9FCA904A9FCA800A9FCA808A810BBFEC820002000A00040
+5D1F:0100210821083FF8010002800C603018CFE6010001003FF811100920FFFE0000
+5D20:1020102013FE102055FC552455FC552455FC542054705CA86124062200200020
+5D21:200021FC20082010AA22AAAAAA72AA22AA72AAAAAB26BAA2CA42020203FE0002
+5D22:101E13E011221094540055FC5424542457FE542454245DFC6424002000A00040
+5D23:010041047FFC00701F8001007FFC05401930E10E04007FFC08201C4003807C78
+5D24:21842068203020C8AB24A820ABFEA840A8FCA984AAFCB884C8FC008400940088
+5D25:1040108011FC1124552455FC5524554455FC549055105FFE6410001000100010
+5D26:2040208027FE2110AA48AC46ABF8AA48AA48ABF8AA48BA48CBF800420042003E
+5D27:0100210821083FF8101010901090FD0831483A44544250909088110813FC1104
+5D28:1020102013FE102055FC542457FE542455FC542055205D3E652002A0027E0400
+5D29:0100210821083FF800003E7C224422443E7C224422443E7C224422444A948508
+5D2A:1040102013FE100054885488555456225400542057FE5C206420002000200020
+5D2B:0100210821083FF800003FF820083FF820802490249027F02080488848888FF8
+5D2C:0100210821083FF80100FFFE01003FF821083FF821083FF803800D603118C106
+5D2D:0100210821083FF81000100CFEF0208048807EFE08880E88F888490809080A08
+5D2E:0100210821083FF800003FF8210821082FE8210827C8244827C820083FF82008
+5D2F:10201020105010885504560254F85420542055FC54205D2464A400A803FE0000
+5D30:1092109211241248552454925492540055FE552255225DFE6522012201FE0102
+5D31:0100210821083FF800003F0421243F2421243F24212421243F24120421144088
+5D32:1020104011FC110455FC550455FC540057FE542054205DFC6420002003FE0000
+5D33:204020A021102208ADF6A800ABC4AA54AA54ABD4AA54BA54CBD40244025402C8
+5D34:0100210821083FF8002800243FFE20202FA422242FA824982D12422A45468882
+5D35:100010FC108410FC548454FC540055FE548054FE552A5E4A6492012200540088
+5D36:0100210821083FF8080008087F0808FEFF08084808287F2808080F08F0284010
+5D37:10881048105013FE5450545055FC55545554558C55045DFC6504010401FC0104
+5D38:100013FE1020104055FC5504550455FC550455FC55045D0465FC000000880104
+5D39:2040202021FC2000A888A850ABFEAA22AC24A9FCA924B924C934012800200020
+5D3A:0100210821083FF820401040FEFE212020AC3CB425E424AC24A044A25482887E
+5D3B:211021102210247CA910A910AAFEAE08AA08AAFEAA08BA48CA28020802280210
+5D3C:100011FC1104110455FC5504550455FC540057FE54205D20653C012002A0047E
+5D3D:0100210821083FF800001FF0111011101FF0111011101FF001004884481287F2
+5D3E:200023FE20502050ABFEAA52AA52ABFEA800A840AFFEB888C990006000D80304
+5D3F:100011DC1154115455DC540055FC540057FE548054FC5C046404000400280010
+5D40:0100210821083FF80000084008207EFC082018201CFC2A202A20482089FE0800
+5D41:1088108813FE108854F8548854F85488548857FE55005D486584010001FE0000
+5D42:0100210821083FF8004013F8204847FE884813F8304053FC904017FE10401040
+5D43:1020101011FE10005484544855FE55085510556455085D1265640208023004C0
+5D44:2104208823FE2020A820A9FCA820A820ABFEA800A820BBFEC820005000880306
+5D45:0100210821083FF8002800243FFE20202FA420242FA8289828924FAA40468082
+5D46:0C487044104013FEFC503890549091121212110E01002108210821083FF80008
+5D47:08481C44F04013FE1050FC5010923892350E5420502091241124112411FC1004
+5D48:203C27C022442128A800ABFCA880A880AFFEA900A9F8BA88CA50042008D80306
+5D49:2040202023FE2000A9FCA904A9FCA800ABFEAA02A9FCB820C820002000A00040
+5D4A:203823C0204027FCA950A954AF58A954AB54AD4CA8E0B950CA48044408420040
+5D4B:100011FE1112111255FE5500557E55425542557E55425D7E62420242047E0842
+5D4C:0100210821083FF800202220223EFF42229422103E10221022283E2822440082
+5D4D:00407F40127E0C88FF4819482A504820A850118C01002108210821083FF80008
+5D4E:21FC2124212421FCA924A924A9FCA820A820ABFEAA22BA2ACAFA020A02020206
+5D4F:010041047FFC00002448238824483FF81010220847E40820144003801C70E00E
+5D50:0100210821083FF800001FF0101010D01710111017D0155027CA212A4FE68022
+5D51:100011FC110411FC550455FC548055FE5622552255525D0265FA000200140008
+5D52:00001FF0101010101FF000007C7C444444447D7C01002108210821083FF80008
+5D53:0100210821083FF800001FF0101010101FF000007EFC4284428442847EFC4284
+5D54:010041047FFC00001FF011101FF011101FF00000FFFE111010A014401830100E
+5D55:2000208822522222AA52AA8AAA02ABFEA888A944AA7AB888C950002000D80706
+5D56:1020102013FE107054A85524562255FC550455FC55045DFC6504000003FE0000
+5D57:0100210821083FF8004800443FFE20402F4422442A282AA83112422A44C69B02
+5D58:2088208823FE2088A800ABFEAA02AC24A820ABFEA870B8A8C8A8012402220020
+5D59:0100210821083FF800000C1070901050FC903050381E55F05010901010101010
+5D5A:0100210821083FF8104010403E7C4084BD2810201020FE501050148819041202
+5D5B:0100210821083FF802800C6037D8C0063E0822483E4822483E48220822282610
+5D5C:010041047FFC020001003FF808200440FFFE00101F90109010901F9000500020
+5D5D:2020212420A82020ABFEA8A8A924AA02A840AFFEA888B908C990006001980604
+5D5E:010002800C603018CFE601003FF80100111025080200101092929292FEFE0202
+5D5F:010041047FFC00003FFC2280224027FC2C4037F8244027F82440444047FC8400
+5D60:101E13E0112210945440548855F0542054C455FE54225C2063FE005000880306
+5D61:010041047FFC044008203218C4460FE000207EFC224412240A1412242A544488
+5D62:102010201050104854A455FE568454FC548454FC54805CFC65440144027C0044
+5D63:1020101011FE1110557C551455FE5514557C5510557C5D4465440244027C0444
+5D64:08202AA42CA84920145022887FFE40028104010021082108210821083FF80008
+5D65:2104210421DE2244AD54A89EA904AA24AC24ABFEA870B8A8C924062200200020
+5D66:102011241124112455FC540057FE540055FC550455045DFC6488005003FE0000
+5D67:204023BE22122292AA52AAAAAB24A840ABFEAA22AA22BBFECA22022203FE0202
+5D68:2040208021FC2104A904A9FCA900A9FEA900A9FEA802BAAACAAA040200140008
+5D69:010041047FFC0200FFFE00001FF010101FF000007FFC40044FE448244FE4400C
+5D6A:2040202023FC2000A9F8A908A9F8A800ABFCAA04AAF4BA94CAF4020402140208
+5D6B:20842044204823FEA884A884A908A94AAA52AB9CA884B908C908025203DE0042
+5D6C:0100210821083FF8020004003FF821083FF821083FF8029004A808FA308AC07E
+5D6D:2040202023FC2108A890ABFEAA02AC44A820ABFCA880B8F8C888010801280210
+5D6E:1020102013FE102055FC550455FC550455FC550455FC5D0463FE008801040202
+5D6F:11081088109013FC544055F8544057FE5480550055FC5E206420082003FE0000
+5D70:10881050100011FE545055FC545457FE545455FC54505CD86554025200500050
+5D71:2040202023FE2202AC94A908AA64A890A908AA04ADFAB908C908010801F80108
+5D72:1020104011FC110455FC550455FC550455FC542057FE5C7064A8012402220020
+5D73:0100210821083FF8082004407FFC01003FF80200FFFE080037F0C0801FFC0000
+5D74:2040224821502248ACA4A918AE06ABF8AA08ABF8AA08BBF8CA08020802280210
+5D75:0100210821083FF8004078404BFC48404FFE78104FFE48104A10791048500020
+5D76:200023DE20422042ABDEAA10AA10ABDEA842AA52A94AB94ACA52004202940108
+5D77:2124212422242424A954A94AAA92AE10AA10AA50AA5CBA50CA5002B0029E0300
+5D78:0100210821083FF81110211041108AA8144430405240927C1240154014FE1800
+5D79:010041047FFC00007CF8048804F87C2041FC41247D2405FC042004242BFE1002
+5D7A:200027BC208424A4AA94ACA4A850A988AE26A8C0AB10B864CB88003000C00700
+5D7B:1020101011FE1110557C551455FE5514557C551055925D546538025402920430
+5D7C:2040202023FC2000A908A890ABFEAA20AAA0AAFCAB20BA20CAFC0420042009FE
+5D7D:2154215423FE2154A954AA72AC00ABFEAA22A820A9FCB924C9240124012C0020
+5D7E:010041047FFC08201FF0102025487EFC04401930E64E1990062018C007003800
+5D7F:010041047FFC00000000FDFC104011F8110811F8110811F8110811F850902108
+5D80:11FC102013FE122255AC542055AC540055FC540057FE5C8064FC000400280010
+5D81:102011FC112413FE552455FC542055FC552455FC54405FFE648801D00070038C
+5D82:102011FC1088105057FE540055FC550455FC550455FC5C2067FE002000200020
+5D83:22002202223C2FA0AA20AFA0AABEAFA4AAA4AFA4AA24BFA4CA24024402440284
+5D84:0100210821083FF808067F7808407F40497E7F4849487F4808487F4808880908
+5D85:082008207F20087E7E4408A4FF2810101E28224446828100210821083FF80008
+5D86:2090209027FE2090ABFCAA94ABFCAA94ABFCA800A9F8B908C9F8010801F80108
+5D87:200023FE2200227CAA44AA44AA7CAA00AAEEAAAAAAAABAAACAEE020003FE0000
+5D88:0100210821083FF80440247C24A83D50042804487DFE24882448244844088418
+5D89:0100210821083FF800A0009079FE49204B204DFC492049FC7920492001FE0100
+5D8A:0100210821083FF810A01090F9FE11201B2015FC3120D1FC1120112051FE2100
+5D8B:1040108011FC110455FC550455FC550055FE550055FE5C0262AA02AA0202000C
+5D8C:010041047FFC04001FF010101FF010101FF010001FFC10001FFC492484940008
+5D8D:100013DE10421252554A56525442542055FC550455045DFC6504010401FC0104
+5D8E:0100210821083FF800003F0821083F0820FE2E0820483F2844285508A4A80C10
+5D8F:010041047FFC00007FFE40005FDC45045FC4554459DC50505FD050525FD2904E
+5D90:010041047FFC010079F04A9050606198560649F04A406BF8544043F8404047FC
+5D91:208020F8210823FEAD12A922A9FEA840A8A2AB54A898BB34C854009203500020
+5D92:21042088200023FEAA22AAAAAA72AA22ABFEA800A9FCB904C9FC010401FC0104
+5D93:103C13E0112410A855FE54A85524560255FC552455245DFC6524012401FC0104
+5D94:0100210821083FF808401440227C5C8489283E2008204A5028500E8871042202
+5D95:2090208821FE2110AB10ADFEA910A910A9FEA910A910B9FEC90002A402520452
+5D96:204020A0211826E6A800ABF8AA08ABF8A800AFBCA884BCA4C29404A402940108
+5D97:208822AA22DC2488A954AA22A800ABFEAA42AC44ABFCB844C844008401140208
+5D98:0100210821083FF81090108813FEFC48103231CE3890548853FE9048103211CE
+5D99:2020212420A823FEA8A8A924AA22A904A904A9DEAA44BD54C89E010402040404
+5D9A:010041047FFC01007FFC044028281FF02828CFE608200FE00100111025080200
+5D9B:1020102011FC102055545488550456FA548854F854885CF8642000A801240060
+5D9C:010041047FFC00003E7C081048907EFE1428244A46863FF820083FF820083FF8
+5D9D:202027A420A82292A914AA08ADF4A802ABF8AA08AA08BBF8CA0801100FFE0000
+5D9E:00407BFC488051F8622055FC488848F8688850F840884100210821083FF80008
+5D9F:2088205023FE2050A9FCA954A98CA974A904A9FCA808BBFEC908008800A80010
+5DA0:101811E0104013FE5488557456525470540055FC55045D74655401740104010C
+5DA1:010041047FFC00003FFE289025102FBE22222AD42A902F902228442844448882
+5DA2:2020202021FC2020ABFEA908AB9CA908A988AE3EA800BBFEC89000900112020E
+5DA3:010041047FFC010008801FFC30805FF810801FF810801FFC1000248822444244
+5DA4:010041047FFC01003FF80100FFFE08203EF808207EFC00007FFC04401842E03E
+5DA5:20002FFE28002A28A948ABEEA892A884AAA0AAA8ABE8B888C894091409241242
+5DA6:108010F8110813FE5544559255FE5500557C5500557C5D00657C0244027C0444
+5DA7:100011FC115411FC542055FC542057FE5488545055FC5C2067FE002000200020
+5DA8:0A803138228838382288393822887FFE4002810401002108210821083FF80008
+5DA9:105011FC115411FC555455FC540055FE5500557C55005DFE6550015401480266
+5DAA:010041047FFC24481450FFFE082004407FFC01003FF80100FFFE05401930E10E
+5DAB:2050225221542050ABFEA888A850ABFEA820A9FCA820BBFEC8A8012406220020
+5DAC:2104208823FE2020A9FCA820ABFEA854A992A890ABFEB890C8D4038A009601A2
+5DAD:0100210821083FF810407C2045FC44887C5043FE40207C2045FC44207C204420
+5DAE:1020102010501088550456FA5400540055DC555455545DDC6488008801540222
+5DAF:41047FFC00003E2822243E240020FFFE22203E2822283E1022122F2AF2464282
+5DB0:210021DE224A248AABEAAAB6AAA4ABF4AABEAAA4ABE4BABECAA402A402240464
+5DB1:108813FE108811FC550455FC550455FC548055FE56225D52650201FA000A0004
+5DB2:010041047FFC08801FFC30805FF890801FF810801FFC10003E7C224423D42008
+5DB3:21083FF800007FFC06003B0804B019C062A00C98732610207CFC10201E20F1FE
+5DB4:04003FF82008292825482FE8254829280200FFFE08203118D11611101FF00010
+5DB5:200023FC22942294ABFCA800A890AF9EA890A890AB9CB890C890079E00900090
+5DB6:010041047FFC000022204AA08ABE1FC420A46F24A0282F28291029A829443082
+5DB7:010041047FFC0000247C3A0422281E1020FE3E124850085E7F5014B0229E4100
+5DB8:208822AA22DC2488A954AA22A800ABFEAA22A820ABFEB870C8A8012406220020
+5DB9:202023FE202021FCA800ABFEA802A9FCA820ABFEA800BBFEC80403BE02A4038C
+5DBA:010041047FFC100013FC284045F8930809F8FD0805F8090851F8200010900108
+5DBB:010041047FFC08207F280824FFFE12203FA46424BFA824183F92242A3FC62082
+5DBC:2140224C22642244AB4CAA64AAA4ABACAAA4AAA4AFFEB800C910010802040404
+5DBD:0100210821083FF8001052182F945014977E1010372850289728154457442082
+5DBE:203E27C022442128ABF8A840AFFCA800ABF8A808ABF8B808CBF80544052A08FA
+5DBF:200021FC202023FEAA22A9ACA820A9ACA800ABFEA820B9FCC95401540154010C
+5DC0:010041047FFC08002A284D240820142E3F706424BF2424283F12242A3F462082
+5DC1:200023FE224823FEAA48AAFCAAA4AAFCAAA4AAFCAA20BBFEC32A057A050A0906
+5DC2:21083FF808801FFC30805FF890801FF810801FFC10003FFC24242BD4224423CC
+5DC3:41047FFC08407F7C2240147CFF04007C7F40417C7F40417C7F40417C4542423E
+5DC4:2110209023DE2010AA5EA982ABDEA810ABDEAA50ABDEBA50CBDE0250025202CE
+5DC5:21083FF808007EFE08103E20227C3E4422543E5422543E542254FF2824444282
+5DC6:208822AA22DC2488A954AA22ABFEAA02A8F8A888A8F8B800C9FC010401FC0104
+5DC7:208820CC208A23E8AAA8AADEABA8AA6AAA0AABEAAC0CBFECCA2A03EA015607E2
+5DC8:010041047FFC000029007DFC29043A4411547CE455F47C4410E4FD5410541008
+5DC9:21F0221027FC2204ABFCAA24ABB8AA22A9FEAA10AFFCBA44CBFC00D0014A063E
+5DCA:23DE225223DE2252ABDEAA52ABDEA98CAA52A840AFFEB888C990006000D80304
+5DCB:010041047FFC10007DFC44047CFC40047DFC44007DFE11225CFC50A45EACF020
+5DCC:41047FFC220811103FFC20002E20223C3FA829482F2829282F1049D07F288144
+5DCD:010041047FFC0C20704011FCFD2439FC552493FCFC24245A685E10902912C60E
+5DCE:200027FE204022EEAAAAABEAAAAEAAE8ABAAACE6AA88BDF4CA90006001980606
+5DCF:208823FE208823DEAA52ABDEA8A0A890A9FEA920ABFCBD20C9FC012001FE0100
+5DD0:010041047FFC08007F7C00443E7C22443E7C00107F6441245DFE55245D244344
+5DD1:252827BE294827BEAB18ADAAA946ABFCAA04ABFCAA04BBFCCA0403FC01080204
+5DD2:210447C88812F3BC20084B92F83E0380AAAAABAA01002108210821083FF80008
+5DD3:010041047FFC22003CFE21101F7C52445E7C52445E7C52447F7C002824444282
+5DD4:21083FF808007EFE08103E20227C3E44227C3E44227C3E44227CFF2824444282
+5DD5:2108209027FE2108ABFEAA54ABC8AA3EABC8AA5CABC8B840CBFE00880070038C
+5DD6:010041047FFC00001E7812483FFC20202E20223C3FC829282F2849905F288144
+5DD7:23DE225223DE2000ABFEAA00AAC8AA4EABEAAAB2AAEABAAACAEA02B405E4082A
+5DD8:210821EC210A2FEAA928ABC8A93EAFE8A948ABE8AA28BB68CAA80BF40AB412A2
+5DD9:211027FE204022EEAAAAABEAAAAEAAE8ABAAACE6AA88BDF4CA90006001980606
+5DDA:010041047FFC08000F9008147F9248FE7E1048905FA851285F28554455449382
+5DDB:0000000008880888088811101110222022201110111008880888088800000000
+5DDC:0000041004100820082010402080410020801040082008200410041000000000
+5DDD:1004108410841084108410841084108410841084108410842084208440048004
+5DDE:1004108410841084108454A45294529490841084108410842084208440048004
+5DDF:02000100FFFE1000100010001FF800001110111011101110211021124112800E
+5DE0:00007FFE00000888111022201110088800003FF80100010001000100FFFE0000
+5DE1:000021241124112402480248F490124812481124112411241000280047FE0000
+5DE2:088811102220111008883FF821083FF821083FF80100FFFE054009203118C106
+5DE3:22081108111000003FF821083FF821083FF80100FFFE054009203118C1060100
+5DE4:1084210810843FF82448238824483FF80000294825282948252A210A29463182
+5DE5:000000007FFC0100010001000100010001000100010001000100FFFE00000000
+5DE6:020002000200FFFE04000400040008000FF8108010802080408080803FFE0000
+5DE7:000003FEFC40104010801080110011FC100410041E04E0044004000400280010
+5DE8:00003FF82000200020003FF02010201020103FF020002000200020003FFC0000
+5DE9:000001F07D1011101110111011901150115011101D10E11242120212040E0800
+5DEA:00003FF8200020003FF0201020103FF0200020003FFC00007FF8000800080008
+5DEB:000000007FFC01000100111011101110292829284544858401000100FFFE0000
+5DEC:00007DF01110111011121D12E20E440001003FF80100FFFE028004401830600C
+5DED:00407C4013FC104410441C84E114420801003FF80100FFFE028004401830600C
+5DEE:082004407FFC010001003FF802000200FFFE0400080017F82080408080801FFC
+5DEF:00207C1005FE08201048288445FE820200A87CA810A810A810AA1D2AE1264200
+5DF0:0020FE1055FE5420A848548455FE0002FEA810A810A810A81EAAF12A41260200
+5DF1:00003FF0001000100010001000103FF02000200020002004200420041FFC0000
+5DF2:00003FF0001000100010201020103FF02000200020002004200420041FFC0000
+5DF3:00003FF0201020102010201020103FF02000200020002004200420041FFC0000
+5DF4:00003FF8210821082108210821083FF82008200020002002200220021FFE0000
+5DF5:007C3F80200020003FFE200020002FF82888288828882FF828084802480287FE
+5DF6:0000FEFC2284228442844A84848400FC7E8042804280428242827E82427E0000
+5DF7:044004403FF804400440FFFE044008201FF02828C8260FE008200808080807F8
+5DF8:00007F7C4844484448445E445244527C524052405E404842484248427F3E0000
+5DF9:1FC000447D88055009203118C50602003FF800003FF000103FF0200420041FFC
+5DFA:00007CF8448844887CF84080428442843E7C00000000FFFE0000082010102008
+5DFB:0100111009203FF802007FFC082010102FE8C02600200FE008000808080807F8
+5DFC:00003FF0211021103FF02000200420041FFC00003E442258226022423E42223E
+5DFD:00007CF844887CF8408042843E7C044004403FF804400440FFFE082010102008
+5DFE:0100010001003FF8210821082108210821082108210821282110010001000100
+5DFF:01000100FFFE0100010001003FF8210821082108210821282110010001000100
+5E00:00007FFC0100010001003FF82108210821082108210821282110010001000100
+5E01:000801FC7F00010001003FF82108210821082108210821282110010001000100
+5E02:0200010000007FFC0100010001003FF821082108210821082128211001000100
+5E03:020002000200FFFE0400090011003FF851089108110811081128111001000100
+5E04:0800080008FE7F1049104910491049104910491049104B100810081008500820
+5E05:082008204820482049FC49244924492449244924492409341128102020204020
+5E06:100011F011107D1055105510559055505550551055105D1211121212120E1400
+5E07:010001003FF80108FFFE01083FF8010001003FF8210821082128211001000100
+5E08:08000BFE48204820482049FC4924492449244924492409341128102020204020
+5E09:1010109010907C8855085504560455FA5488548854885C881108110812281410
+5E0A:1000100011FC7D24552455245524552455FC550055005D001102110210FE1000
+5E0B:00783F80208020803FFC20402822311A21061FF0111011101150112001000100
+5E0C:18180660018006603A180200FFFE048008801FF82888488888A8089000800080
+5E0D:020001003FFC200420043FFC2040204027FC2444244424444454444880400040
+5E0E:1020102010207DFE55225624542054205450545054505C50109010921112120E
+5E0F:1020102010207DFE5420542054FC5420542055FE54225C22102A102410201020
+5E10:1080108410847C88549054A0548057FE54A0549054905C88108410A210C01080
+5E11:10001000FEFC2244642818102428C34601003FF8210821082128211001000100
+5E12:08A0109030BE57C0904010241014110C01003FF8210821082128211001000100
+5E13:1020102010207DFE54205420542055FC547054A854A85D241124122210201020
+5E14:1010101010107DFE55125514551055FC5544554455285D281110122812441482
+5E15:1020102010407DFC550455045504550455FC550455045D041104110411FC1104
+5E16:1020102010207C20543E54205420542055FC550455045D041104110411FC1104
+5E17:1050104810487C4055FE54405440547C54A454A454A85D281110122810441082
+5E18:020001007FFE400288241010210801003FF82108210821082128211001000100
+5E19:1020102011207D2055FC55205620542057FE542054505C501088108811041202
+5E1A:00001FF000100FF000101FF000007FFE410281041FF011101110115011200100
+5E1B:010002001FF010101FF010101FF0010001003FF8210821082128211001000100
+5E1C:1000100011FC7D04550455045504550455FC550454005C901088110412021402
+5E1D:020001003FF80000082004407FFE410281041FF0111011101150112001000100
+5E1E:100013FE10207C20544055FC55045504550455FC55045D041104110411FC1104
+5E1F:020001007FFC0440245044488944108001003FF8210821082128211001000100
+5E20:02001CF0101010101EF0101010101FF001003FF8210821082128211001000100
+5E21:1104108410887C0055FE548854885488548857FE54885C881108110812081408
+5E22:1020102010507C885504560255FC5400540055FC55045D041104110411FC1104
+5E23:1110091009207FFC02000400FFFE11102108DFF6111011101150112001000100
+5E24:10001000FE7C224442443444087C3400C20001003FF821082108212821100100
+5E25:102020207C20442045FC45247D24412441247D244524453445287C2044200020
+5E26:092009207FFC0920092000007FFE410281041FF0111011101150112001000100
+5E27:10201020103E7C20542055FC550455245524552455245D241050104810841104
+5E28:1104108410887C1055FC55045504550455FC545054505C9010921112120E1400
+5E29:1020112410A47CA8542055FC5504550455FC550455045DFC1104110411141108
+5E2A:100011FE11007D00557C5500550055FE5550555255545D481148124412521460
+5E2B:100023FE7C204420442045FC7D24412441247D244524453445287C2044200020
+5E2C:00003FF80208FFFE04083FF808001FF82808CFF800801FFC1084109410880080
+5E2D:010000803FFE222022203FFC2220222023E020802FF82888488848A888900080
+5E2E:0800087CFF4808507E480844FF54104820404100BFF821082108212821100100
+5E2F:092009207FFC09200FE000007FFE410281041FF0111011101150112001000100
+5E30:080009FC480448FC480449FC48004BFE4A22482049FC09241124113421284020
+5E31:2040204027FCF840ABF8A880AFFEA890A910A9FEAA10BA902450281020502020
+5E32:1044104410887DDC548854885488548855DE548854885C881088108810881108
+5E33:100010FC10807CF8548054F8548057FE5540552455285D101108114411821100
+5E34:10481044105E7DE054285412546A55965448545E55E05C2410281012106A1186
+5E35:2040202023FEFA02AD04A900A9DEAA52AA52AB52AC9AB894211021122212240E
+5E36:145014507FFC1450245247CE80007FFC41041FF0111011101150112001000100
+5E37:1050104810807CFE5590569054FC5490549054FC54905C90109010FE10801080
+5E38:0100111009207FFE40028FE4082008200FE001001FF011101110115011200100
+5E39:2080204023FCF800A908A890AFFEA840A840AFFEA888B9082090206021982604
+5E3A:1088108811FC7C88548854F85488548854F8548854885DFE1000108811041202
+5E3B:2040204027FCF840ABF8A840AFFEA800ABF8AA08AA48BA48224820A021102608
+5E3C:200023FE2202FA02ABFEAA22AA22AAFAAA22AA32AA2ABBFE2202220223FE2202
+5E3D:200023FC2204FAF4AA04AAF4AA04A800A9F8A908A9F8B90821F8210821F82108
+5E3E:1020102211FA7C24542857FE5420544054FC558456845CFC1084108410FC1084
+5E3F:210021782108FA08AAFEAE40AA40AA7CAA90AA10AAFEBA102228222822442282
+5E40:10201020103E7C20542055FC550455FC550455FC55045DFC1000108811041202
+5E41:100013FE10207C4055FC5504550455FC550455FC55045D0411FC100010881104
+5E42:00007FFE40029FF410101FF010101FF00200FFFE09203FF8D116115011200100
+5E43:1040104011FC7C8457FE540055FC550455FC542057FE5C20122013FE10201020
+5E44:200023FC2204FA04ABFCAA00ABFCAA40AA88ABFCAA24BA2025FC2420282033FE
+5E45:100011FE10007CF85488548854F8540055FC552455245DFC1124112411FC1104
+5E46:100011FC11047DFC550455FC548055FE5622552255525D0211FA100210141008
+5E47:080808087E0808FEFE0808487E2808080F28F11001003FF82108212821100100
+5E48:200023FC2204FA04ABFCAA00AA84AA48AAFCAA48AA48BBFE2448244828883108
+5E49:204821482148FBFEA948A948A978A900A9FEA820ABFEB87020A8212426222020
+5E4A:100011FC10207C2057FE540055FC550455FC550455FC5D0411FC108811041202
+5E4B:10783E4822482A86FF7822482A2842104A28854601003FF82108212821100100
+5E4C:100011FC11047DFC550455FC5420552454A8542057FE5C50105010921112120E
+5E4D:101E11E010227D1254945480542055CE5502550255CE5D021102110211FE1102
+5E4E:200023FE2202F800A9FCA904A9FCA904A9FCA840A820BBFE2000208821042202
+5E4F:2040202023FEFA02A800A9FCA840A8A2AB34A858A894BB342052209023502020
+5E50:0020792448A849FC48407BFE49084A244C2279FC492449244934492848209820
+5E51:12101A902A904AA08FBE10442FA46224A2242FA82AA82A902AA82BA822442282
+5E52:1020104011FC7D24557C558C55545524555455FC54405C2412A2128A14881078
+5E53:2040208821FCF908AA52ABFEA850A988AE26A8C0AB10B8642388203020C02700
+5E54:200021F82108F9F8A908A9F8A800ABFCAA94ABFCA800B9F82090206021982606
+5E55:04407FFC04401FF010101FF010101FF00400FFFE11103FF8D116115011200100
+5E56:100013FE10507DFC5554555455FC540055FC540057FE5C2010A8112412A21040
+5E57:200023FE221AFA16ABFEAA12AAEAAAAAAAAAAAEAAA0EBA6A239A222623FE2202
+5E58:102013FE10207DFC542057FE540055FC550455FC55045DFC110411FC10881104
+5E59:1088108813FE7C88540055FC550455FC550455FC54205DFE1050108811041202
+5E5A:087CFF4808507E480844FF54104822405FF090101FF010103FF8210821180100
+5E5B:102011FC10887C5057FE540055FC550455FC550455FC5C2013FE102010201020
+5E5C:100011FC11047DFC550455FC542057FE540055FC55045DFC1020112412221060
+5E5D:200023DE2252FA52ABDEA800A9FCA924A9FCA924A9FCB82023FE202020202020
+5E5E:205022522154F850ABFEA888A850ABFEA820A9FCA820BBFE2050208821042602
+5E5F:2110209423D2F812AA50A990AFFEA810ABD2AA52AA54BBD4224A224A23D62022
+5E60:2080208021FEFB54AD54A954ABFEA954A954A954AFFEB8002154212A222A2000
+5E61:207827C02248F950ABFCA950AA48AC06ABF8AA48AA48BBF82248224823F82208
+5E62:102011FC10887C5057FE540055FC552455FC552455FC5C2011FC102013FE1000
+5E63:49202A207F3E49485DA86B2849104928404601003FF821082108212821100100
+5E64:082049202A3E7F4841A85D2855105D28424601003FF821082108212821100100
+5E65:212420A823FEFA02A8F8A888A8F8A80CA9F0A820A9FCB82023FE202020A02040
+5E66:00407C2045FC44887C5043FE7C20A5FC24203D2001003FF82108212821100100
+5E67:10F8108810887CF8540055DC5554555455DC542057FE5C7010A8112412221020
+5E68:210021F82208FFFEAA88AB24ABFEAA00AAFCAA00AAFCBA0022FC248424FC2884
+5E69:102011FC10207C8857FE548855FC550455FC550455FC5D0411FC108811041202
+5E6A:208823FE2088FBFEAA02A9FCA800ABFEA840A8A2AB54B8B82354209223502020
+5E6B:08083EFE08087F4808283E0809287FF028200FE008200FE001003FF821082118
+5E6C:202023FE2020F9FCA800ABFEA802A9FCA820ABFEA800BBFE200423BE22A4238C
+5E6D:210827FE2108F800ABFCAA94AA94ABFCA828ABFEAA20BB2422A82292242A28C6
+5E6E:2040202023FEFA44ABF4AA44AAEEAA04AAF4AAACAAE4BA1422A4247425942808
+5E6F:2108210821EEFA94A842A800ABDEAA52ABD2AA52ABD2BA1A2294235022102010
+5E70:102013FE12227DFC542054F8542055FC542055FC55545DFC104012A4128A147A
+5E71:23DE225223DEFA52ABDEAA22AAFAAA22AAFAAAAAAAFABAAA22FA227222AA2226
+5E72:00003FF801000100010001000100FFFE01000100010001000100010001000100
+5E73:00007FFC010001001110091009200100FFFE0100010001000100010001000100
+5E74:100010001FFC2080208040801FF8108010801080FFFE00800080008000800080
+5E75:00007C7C10101010101010101010FEFE10101010101010102010201040108010
+5E76:10100810082000007FFC0820082008200820FFFE082008201020102020204020
+5E77:0808080810107C7C1010101010101010FCFE1010101010102010201040108010
+5E78:010001003FF801000100FFFE082004403FF801000100FFFE0100010001000100
+5E79:102010201050FE5010887D0446FA7C2044207C2011FCFE201020102010201020
+5E7A:0200020004000810101020207FC02080010002000400082010103FF810080000
+5E7B:0800080011FC100422044204FC0404040804100424044204FE04420400280010
+5E7C:104010402040204045FC4444F84408441044108428844484FD04450402280410
+5E7D:0100010009200920514455547DF44924492455547DF44514410441047FFC0004
+5E7E:1110212045447978111025247D7C15241110FFFE1080108828522422405A8186
+5E7F:0100008000803FFC200020002000200020002000200020002000400040008000
+5E80:010000803FFE2000200022002204221822602380220022022202420241FE8000
+5E81:010000803FFE2000200020002FFE204020402040204020404040404081400080
+5E82:010000803FFE2000208020802080208020802140214022204220441088081006
+5E83:010000803FFE20002080208020802100210021002210220844084FFC84040004
+5E84:0100008000803FFC20002080208020802FFC208020802080208040805FFE8000
+5E85:010000803FFE20002100210022202220244028802100220844044FFE84020000
+5E86:010000803FFE20002080208020802FFC20802140214022204220441088081006
+5E87:010000803FFE20002420242024242428273024202420242245224622841E0000
+5E88:010000803FFE20802140222024102908308620802FF020104020402080400080
+5E89:010000803FFE204020402FFE204024442444244427FC204220424042403E8000
+5E8A:010000803FFE2000208020802FFC208021C022A022A024904888508680800080
+5E8B:010000803FFE208020803FFC208020802FF02410222021404080416086183806
+5E8C:010000803FFE200020002FFC2020242028202FFE20A021204620582080A00040
+5E8D:010000803FFE2000201C27E02400240027FE2420242024204820482090202020
+5E8E:010000803FFE2040204020A0211022082D162110211021104110421082100410
+5E8F:010000803FFE200023F8201020A020402FFE2042204420404040404081400080
+5E90:010000803FFE2100208027F824082408240827F8240824004400480088001000
+5E91:010000803FFE200020002FFC208020803FFE21402140224042424442883E1000
+5E92:010000803FFE20802080208020802FFC2080208020902088408840809FFE0000
+5E93:010000803FFE210021003FFC2200248028802FF8208020805FFE408080800080
+5E94:010000803FFE200020002104288424842448224822102210402040409FFE0000
+5E95:010000803FFE2000203C27C024402440244027FE242024202412450A46468422
+5E96:010000803FFE2200220027F8280837C82448244827C824282412440243FE8000
+5E97:010000803FFE20802080208020FC2080208027F8240824084408440887F80408
+5E98:010000803FFE2000200027FC2444244427FC2444244427FC2444404040408040
+5E99:010000803FFE2000208020802FF82888288828882FF82888488848888FF80808
+5E9A:010000803FFE200020802FF8208820883FFE208820882FF8414042208C183006
+5E9B:010000803FFE2000211021102512251425D8251025102510251245D25E12880E
+5E9C:010000803FFE200022082208240824FE2C083488244824484408440884280410
+5E9D:010000803FFE2100210023F82610292020C023303C0E20C04020430080C00020
+5E9E:010000803FFE2220221022002FFC22402240224824502460484248C2933E2000
+5E9F:010000803FFE2080249028882FFE210021FC2284228824502420485051888606
+5EA0:010000803FFE241022203FFC208020802FF8208020803FFE2080408040808080
+5EA1:010000803FFE208020403FFE20802100228426882A5032204210428883060200
+5EA2:010000803FFE200020002FFC2100221027F8208820802FFC40804080BFFE0000
+5EA3:010000803FFE212021202924252821302120233025282924222042224422881E
+5EA4:010000803FFE2000204027FC204020403FFE200020102FFC4210411081500020
+5EA5:010000803FFE20002220222024202DFE347024A824A825242622442044208420
+5EA6:010000803FFE222022203FFC2220222023E020002FF02410422041C08630380E
+5EA7:010000803FFE20802490249024902AA831C420802FF8208040804080BFFE0000
+5EA8:010000803FFE2080208827F020A03FFE20802FF02620384047FC404081400080
+5EA9:010000803FFE20802140222024103BEC208020802FF820804490488892840100
+5EAA:010000803FFE24102410247E3F102410257C26443C4424284410442894440882
+5EAB:010000803FFE20803FFC20802FF828882FF828882FF820805FFE408080800080
+5EAC:010000803FFE221022083FFE224822502264224822522264444A447288C2133E
+5EAD:010000803FFE20002E0E22F0241024102EFE221022102AFE4400460089FE1000
+5EAE:010000803FFE20002FFC21202FFC292429242A1C2C042FFC480448048FFC0804
+5EAF:010000803FFE204820442FFE204027FC244427FC244427FC2444444444548408
+5EB0:010000803FFE22082108211027FC2110211021102FFE21104110421084100810
+5EB1:010000803FFE208020802FFC20803FFE2408290433F22610492040C08730380E
+5EB2:010000803FFE204020402FFE204022482248255428E2215042484C4680400040
+5EB3:010000803FFE2080210027FC244427FC248427FC212022203FFE402040208020
+5EB4:00803FFE221022102FFC221022103FFE200027F82408240847F84408840807F8
+5EB5:010000803FFE200020802FFC2120221024882FF6349027F0249047F24082807E
+5EB6:010000803FFE2000222022203FFC22202220222023E020004A48492491240000
+5EB7:010000803FFE20802FF820883FFE20882FF8288024C422A84490488892860100
+5EB8:00803FFE20802FF820883FFE20882FF820802FF828882FF848884FF888880898
+5EB9:010000803FFE221022103FFE221023F0200027F8240827F84420441088081006
+5EBA:010000803FFE221024882924221027F8208820802FFC21C042A0449898860080
+5EBB:010000803FFE222022203FFC2220222023E020002410241044104A2891442082
+5EBC:010000803FFE280029FC28202E4029FC2904292429242B242D24485040888304
+5EBD:010000803FFE200027F8248827F8248827F820802FFC288448A44BF489140808
+5EBE:010000803FFE200022802CB8288828882EB8288828882FF8414042208C183006
+5EBF:010000803FFE211021102FFE2110200027FC2444244427FC2444444447FC8404
+5EC0:010000803FFE20402FFE2842224824B023082C0427F82208211040E043189C06
+5EC1:010000803FFE20002F84288428A42FA428A42FA428A42FA44024490488941088
+5EC2:010000803FFE20002200227C3F442244267C27442AC42AFC52446244827C0244
+5EC3:010000803FFE20402F5021242A1824083BF6212021202FFC212042244424881C
+5EC4:010000803FFE20002F78294829482F862900297C2F4428442A2849104B288D46
+5EC5:010000803FFE20802FFC20803FFE220024082FFC20002FFC49244924BFFE0000
+5EC6:010000803FFE208021002FFC28842FFC28842FFC21482154425C44468842303E
+5EC7:00803FFE2080277C2424252424A425542648208027FC244447FC444487FC0404
+5EC8:010000803FFE20002FFC208027F8240827F8240827F8220027F84A0841F09E0E
+5EC9:010000803FFE220821102FFE212027FC21243FFE212427FC2330452859268120
+5ECA:010000803FFE220021002FBE28A22FA428A82FA42A2229222AAA4CA448208020
+5ECB:010000803FFE2140265C2444275C244427FC20402FFC2208211040E043188C06
+5ECC:010000803FFE22203FFE22223FFE240027FC240027FE2002224A4926500A8004
+5ECD:010000803FFE2400221E2F922014289825143FD220122F9A489448908F900890
+5ECE:010000803FFE200029FE282028FC2E8428FC288428FC2A844CFC480080480084
+5ECF:010000803FFE24002FBC28A42FA428C22F80207E29222A222C94488847948062
+5ED0:00803FFE20002F7E291029102F502950297E2F1028282A2849284B4A8D4A0886
+5ED1:00803FFE24103FFE241027F020802FF828882FF820803FFC40804FF880803FFE
+5ED2:010000803FFE22102F90221E2FA422243FD4241427942488448848948AA41142
+5ED3:00803FFE22003FBC20242FA428A82FA820242FA4212423F45E2842208A200420
+5ED4:010000803FFE20802FF828883FFE28882FF8249027F021003FFE441043E09C1C
+5ED5:010000803FFE20102F2829442A922C7C2A082910297E2D002AFE4820484488FE
+5ED6:00803FFE20002F7C2924251429A421602618388623202C4041884E3081C00E00
+5ED7:010000803FFE22A822A82FFC22AA24E628002FFE284223F84248424882580040
+5ED8:010000803FFE208020402FFC29202FFC29242FFC2A202A244BB8522492A4231C
+5ED9:010000803FFE200027FC244427FC244427FC211027FC21102FFE400042088404
+5EDA:010000803FFE22043FC422042FBE20042FA428942F942884450443849C140808
+5EDB:00803FFE20002FF828882FF828882FF820802FF820803FFE488853E480803FFE
+5EDC:00803FFE200027FC240427FC244425F8245027FE244024F849884AF8948800F8
+5EDD:00803FFE2900290C3FB0292029202F3E29282F28292829285FA840488A881108
+5EDE:010000803FFE22002220252028BE374222942F90221032904A2843A89C440882
+5EDF:010000803FFE22002FBC22242FA428BC2FA428A42FBC22245FA4424482540288
+5EE0:00807FFE420852484A504A9E5FE4505457545554554857485048515450948022
+5EE1:010000803FFE220024002FFC355025502FFC255025503FFE40004A4889241124
+5EE2:010000803FFE20402F5021242A1824083B7621502F8C28782F48413045488284
+5EE3:010000803FFE22202FF822203FFC20802FF828882FF828884FF8422084100808
+5EE4:00803FFE20803FFC20802FF828882FF828882FF820803FFC40A45F3A91221F1E
+5EE5:00803FFE214026303BEC20002FF82AA829C82FF8200027F0441047F0841007F0
+5EE6:010000803FFE2010278824BE248027A22494243E2F882C8854BE478884880008
+5EE7:00803FFE204027FC2248224825543FFE200027FC240425F4451445F4840407FC
+5EE8:00803FFE24002F3C311422242FCC2A802FA82ABE2FC82A884ABE4A8888881188
+5EE9:00803FFE20402FFE200027FC240425F4251427FC200823F040404FFE81500E4E
+5EEA:00803FFE20402FFE200027FC240425F4251427FC200027FC40004FFE824804C4
+5EEB:00803FFE20002EEE2A222AAA2A662EAA2A102A282E542AAA4A50522492482610
+5EEC:00803FFE2040207C204027FE244225F8244424FC24A824F844A849FC895413FE
+5EED:00803FFE2010237C2E10227C2F1022FE2644277C2AC42A7C5244427C82280244
+5EEE:00803FFE20002FBE28A22FBE28A22FBE28A22FBE251428A24FFE431080E00F1C
+5EEF:010000803FFE240027222914323E2F882A882F9C2A882F88403E554895480008
+5EF0:00807FFE40207E2055FE54205DFC555455545DFC542056105C547542454A8638
+5EF1:00803FFE20002AA835242ABE2F6829682FBE20282FA82ABE4FA8482888BE07A0
+5EF2:00803FFE20002FBE2514271C25542FFE29202FFC29242FFC4A244BB89222239E
+5EF3:00807FFE40107F1052FE5E1052FE5EAA52AA7EFE42007EFE4A245E124AA4BE9C
+5EF4:00000000F80008001000100020007800080008004800300010002C0043FE8000
+5EF5:00000124F92409241248124824907A480A4809244924312410002C0043FE8000
+5EF6:0008003CF9E0082010201120213C792009200920492031FC10002C0043FE8000
+5EF7:0008003CF9E008201020102021FC782008200820482033FE10002C0043FE8000
+5EF8:00200020F82009FC11241124212479FC09240924492431FC10002C0043FE8000
+5EF9:00200020F84009FC11041104210479FC09040904490431FC11042C0043FE8000
+5EFA:00400040FBF8084817FE104823F878400BF80840484037FC10402C4043FE8000
+5EFB:000003FCFA040A0412F4129422947AF40A040A044BFC320410002C0043FE8000
+5EFC:000007FEF890089013FC129422947A940A9C0B044A0433FC12042C0043FE8000
+5EFD:000003FCFA940A9412F4129422947AF40A940A944A9433FC12042C0043FE8000
+5EFE:0000000008200820082008200820FFFE08200820082008201020102020204020
+5EFF:08100810081008100810FFFE081008100810081008100810081008100FF00810
+5F00:00007FFC08200820082008200820FFFE08200820082008201020102020204020
+5F01:02000400082010103FF80008082008200820FFFE082008201020102020204020
+5F02:00003FF0201020103FF0200420041FFC000008200820FFFE0820102020204020
+5F03:010000803FFC0200042008101FF80008042004207FFE04200420082010202020
+5F04:00007FFC010001003FF801000100FFFE000008200820FFFE0820102020204020
+5F05:0440082010102FE8C4260420082010A0604008200820FFFE0820102020204020
+5F06:010001003FF80100FFFE040008201FF0001008200820FFFE0820102020204020
+5F07:010002800C603018CFE600001FF010101FF008200820FFFE0820102020204020
+5F08:020001007FFC04402450444889441080000008200820FFFE0820102020204020
+5F09:2420242024203DFC0420FC20242024F8440008200820FFFE0820102020204020
+5F0A:082049202A3E7F4849485DA86B104928434608200820FFFE0820102020204020
+5F0B:022002100210020002FEFF0002000200020001000100008000420022001A0006
+5F0C:0048004400440040FFFE00400040004000400040002000227F92000A00060002
+5F0D:0048004400440040FFFE0040004000407E400040002000220F12F00A40060002
+5F0E:0048004400440040FFFE004000407F40004000403E2000220012078AF8064002
+5F0F:0048004400440040FFFE004000403E4008400840082008220F12780A20060002
+5F10:00483E4400440040FFFE0040004000407E400040002000220F12F00A40060002
+5F11:00144412281013FE28104410101011F0FC9010905890548894EA138A51062002
+5F12:441028141012281045FE1010141011D0FC9030903890548850EA938A10061002
+5F13:00007FF00010001000103FF02000200040007FF8000800080008000800500020
+5F14:00003FF80108010801081FF81100110021003FFC010401040114010801000100
+5F15:00087F080108010801083F082008200840087F0801080108010801080A080408
+5F16:00003FF8000800081FF8100020003FFC000400040004002800100000FFFE0000
+5F17:0440044004407FF8044804483FF8244024403FFC044408440854104820404040
+5F18:00207C200420042004207C404040404040807C880484050407FE050228021000
+5F19:00007CFE0410041004107C10401041FE40107C10041004100410041028501020
+5F1A:0820042004407FF8010801083FF8210021003FFC010401040114010801000100
+5F1B:0020F82008200920092C7934416443A441247934092809220922090250FE2000
+5F1C:00007DFC0404040404047CFC4080408041007DFC040404040404040428281010
+5F1D:00007DFC0524052405247D24412441FC41047D00050005000502050228FE1000
+5F1E:00407C400440047C04847C884120402040207C50045004500488048829041202
+5F1F:0820042004407FF8010801083FF8210021003FFC030405040914110861000100
+5F20:0100F9080908091009207940410047FE41407920092009100908094451822100
+5F21:00007CFE0480048004807CFC4084408440847C8404FC04800480048028FE1000
+5F22:00207D240524052405FC7C20402043FC41047C88048804500420045029881606
+5F23:0088F88808880908097E7B084508414841287928090809080908090851282110
+5F24:0004F81E09F0091009107910411041FE4110791009100908090A094A51A62112
+5F25:0080F880088009FE09027A0444204020412879240A240A220C22082050A02040
+5F26:0040F82008200BFE084078404088410843F078200840088809040BFC51042000
+5F27:0008F83C0BD00A900A907A904290429042907A880A880AC80AA40CD454922800
+5F28:0000FBFC088408840884790441144208440079FC090409040904090451FC2104
+5F29:08007F7C114432280C101228614600003FF000103FF020003FF8000800500020
+5F2A:00007DFC0408041004307C484084430240007DFC04200420042004202BFE1000
+5F2B:00007DFE0520052005207DFC4104410441047D0405FC05200520052029FE1000
+5F2C:00007DFE0510051005507D5C4144414441447D44055C05500510051029FE1000
+5F2D:0000FBFE09080908090879F84108410841F879080908091E0BE8080850082008
+5F2E:111009207FFC0400FFFE10102008DFF600100FF0080010001FF8000800280010
+5F2F:02000100FFFE044014502448444400003FF000103FF020003FF8000800500020
+5F30:00207D2404A404A804207DFC4104410441FC7D04050405FC0504050429141108
+5F31:00007EFC020402047EFC408040807EFC22441224060C1A3462C4020414280810
+5F32:0000F9F80908090809F8780043FC420442047BFC0A040A040BFC0A0452142208
+5F33:0000FBFC080009240A487C904248412440007BFC084008400840084057FE2000
+5F34:0040F8200BFE080009FC790441FC400041FC780808100BFE0820082050A02040
+5F35:0000F8FC088008F8088078F8408047FE41407924092809100908094451822100
+5F36:0040F8200BFE0800080079FC41044104410479FC082008A809240A2250A02040
+5F37:0020F840088809040BFE7822402043FE42227A220BFE08200824082257FE2002
+5F38:0000FBDE0A520A520A527BDE4252425242527BDE0A520A520A520A52555228A6
+5F39:0104F888085009FC0924792441FC4124412479FC082008200BFE082050202020
+5F3A:0000F9FC0904090479FC402083FE8222FA220A220BFE082008240822903F63C1
+5F3B:0000F01E17C211021102F7DE855085508550F6DE14421442144217C2A4544008
+5F3C:0000F01E17C211021202F7DE845084508450F7DE14421442144217C2A4544008
+5F3D:0048F94809480BFE094879484178410041FE78200BFE087008A8092456222020
+5F3E:0242F924080009FC0924792441FC4124412479FC082008200BFE082050202020
+5F3F:01007FFE44429FF404403FF80440FFFE08201FF02028DFE610001FF0001000E0
+5F40:1000FE7810487C480048FE8682007CFC00447C4404287C2840107C2804440D82
+5F41:0000FBFE080809E8092879E8400043FE400879E80928092809E8080850282010
+5F42:0440244814500440FFFE0000FC8004F87D20402081FCFC200450045028881104
+5F43:0000F9FC092409FC092479FC40A840A843FE78A808A809FC08200BFE50202020
+5F44:0000FBFE0A000A7C0A447A44427C420042EE7AAA0AAA0AAA0AEE0A0053FE2000
+5F45:0108F8900FFE08000BC47A5443D4425443D47A440ACC08000BFC088451142608
+5F46:49202A3E7F4849485DA86B10492841463FF000103FF020003FF8000800500020
+5F47:0020F9FC08240BFE082479FC402042AA43AE7A220BFE0A220BAE0AAA52AA2422
+5F48:0000FBDE0A520A520BDE780041FC412441FC792409FC08200BFE082050202020
+5F49:0088F88809FC088808887BFE402041FC412479FC092409FC0800088851042202
+5F4A:0000FBFE080009FC092479FC412443FE400079FC092409FC092409FC500023FE
+5F4B:0000FBFC0A940A940BFC780047FE400043FC7A040BFC08A209140B085D442182
+5F4C:0000F7FC124814441FFEF44486EC855486ECF44416EC155416EC1444A4544408
+5F4D:0040F02017FE148815FCF48887FE842085FCF52415FC152415FC1400A4884904
+5F4E:21084FD2F03C23884812FBBE0280ABAA00003FF000103FF020003FF800080070
+5F4F:03DEFA520BDE0A520BDE78A041FE432045FC792009FE080009FC08885070278E
+5F50:000000007FF800080008000800083FF800080008000800087FF8000800000000
+5F51:04000400040008000FF008101010102020203FE00040004000800080FFFE0000
+5F52:080008004BFC480448044804480449FC4804480448040804100413FC20044000
+5F53:0100210811080910092001007FF80008000800083FF80008000800087FF80008
+5F54:08000FE0082010201FC000400040FFFE010021081190056009203118C5060200
+5F55:00003FF0001000101FF000100010FFFE010021081190056009203118C5060200
+5F56:08000FF010101FE00020FFFE02000D08719002A00CC071A006981886E2800100
+5F57:1010FEFE10107C7C1010FEFE101000007FF8000800083FF8000800087FF80008
+5F58:08000FF010101FE00020FFFE0200421043D2751441184FD041126292444E0820
+5F59:08000FF010101FE000207FFE40029FF411101FF011101FF00100FFFE1110610C
+5F5A:00003FF000101FF000107FFE40029FF411101FF011101FF00100FFFE1110610C
+5F5B:3FF000101FF00010FFFE92485484FF7A3828544892980820FFFE082010202020
+5F5C:08000FF010101FE00020FFFE92485484FF7A3828544892980820FFFE08201020
+5F5D:08000FE010201FC00040FFFE92245478FE1238FE545492920820FFFE08201020
+5F5E:3FF000101FF00010FFFE92245478FE1238FE545492920820FFFE082010202020
+5F5F:0044FDFE04540448FCFE059004FEFC9000FE0890FEFE088049FE2844083819C6
+5F60:7E4403FE3E5402487EFE0190EEFE4A906EFEC09004FEFE8045FE244424380DC6
+5F61:0040008001000600180000200040018006001800001000200040018006003800
+5F62:00007F8412041208121012221202FFC412081210122212022204220842108260
+5F63:100408040808FF90222422442208221214221444080808101420230040FE8000
+5F64:00003F04210421082910252225022104FFC82110212221022104410845108260
+5F65:020001003FF8042003C004203FFC202021C02E10206021882E10406043809C00
+5F66:020001003FF8082004403FFC2000202021C02E10206021882E10406043809C00
+5F67:005000480040FFFE004000507C6045C8445044647DA800120E32F0CA43060002
+5F68:0002FFE2000400087BD04A424A424A446B485AD04A424A424A444A484A505AE0
+5F69:010007847804088844902522200204047F880C10162215022484440884100460
+5F6A:0400078404043FC8245027243C84238820102F24290429084912512290FE2000
+5F6B:00003F84248424882E9024A23F8220842E882A902AA22E822084408842908160
+5F6C:1082108210841088FBD01082308239C455A852909282148210841088109010A0
+5F6D:08000804FF84080808107F2200027F04410841107F22000222041788F8104060
+5F6E:10000804FF848088141022224902140422084110BEA22202220422083E102260
+5F6F:0000FF8414047F08551055227F0200047F080010FFA208022A044908A8901060
+5F70:100008047F0422081410FFA200027F0441087F1041227F020804FF8808100860
+5F71:00007F0441047F0841107F220802FFC400087F1041227F020804490888901860
+5F72:7BC200027BC44A486B504A4204027FC44A087FD04A427FC252445B88525099E0
+5F73:0800080010002000480008001000300050009000100010001000100010001000
+5F74:08400840108020FC490409041204348450449024102410041004100410281010
+5F75:08400840104022404A580A6812C8374852489268125012441244120411FC1000
+5F76:100017F82108411091101120213C6104A1042288228822502420245028882306
+5F77:08400820102023FE48800880108030FC50849084108410841104110412281410
+5F78:082009201120211049100A48124834445882908011101108120817FC12041000
+5F79:080009F01110211049100A0E140033F851089110109010A0104010A013181C06
+5F7A:0800080013FE2020482008201020302051FC9020102010201020102017FE1000
+5F7B:1000120022FC42249224122423A46E24A224222422A423242244204420942108
+5F7C:08200820102023FE4A220A24122033FC52849288124812501220145014881906
+5F7D:0808083C13E022204A200A20122033FE5220921012101212120A128A13261212
+5F7E:0840084010A020A049100A481426302053F890081010111010A0104010201020
+5F7F:08900890109023FC4894089413FC3290529093FE10921092111A111412101410
+5F80:08800840100027FC484008401040304057FC904010401040104010401FFE1000
+5F81:0800080013FE20204820082011203120513C9120112011201120112017FE1000
+5F82:080009F811082108490809F811083108510891F8110811081108110817FE1000
+5F83:082009201120212049FC0A2012203420502091FC102010201020102017FE1000
+5F84:08000BF8101020204860089811043602500093FC104010401040104017FE1000
+5F85:08400840104023FC4840084017FE3010501097FE101012101110111010501020
+5F86:08000FFE1090209048900BFC1294329452949294129C13041204120413FC1204
+5F87:08800880110021FC4A040C0413E43224522493E41224122413E4100410281010
+5F88:08000BF8120822084BF80A08120833F852449248123012201210128813061200
+5F89:09040884108820004BFE0820102031FC5020902013FE10201020102010201020
+5F8A:0800080013FC22044A040AF4129432945294929412F41204120413FC12041000
+5F8B:0840084013F820484FFE084813F83040504093F81040104017FC104010401040
+5F8C:08200840108821104BE00840108833FC5084908011F813081490106011981606
+5F8D:0820082011FC20204820082017FE30005020902011FC10201020102017FE1000
+5F8E:080009FC11042104490409FC1000300053FE9020102011FC1020102013FE1000
+5F8F:082008201120213C4920092017FE300050209124112412281410102010C01700
+5F90:1040104020A04110920815F620406040A7FC2040225022482444284421402080
+5F91:08000BFC100021244A480C9012483124500093FC104010401040104017FE1000
+5F92:0820082011FC20204820082013FE302050209120113C112012A01260143E1800
+5F93:080409041088209048000BFE102030205120913C1120112012A01260143E1800
+5F94:0888088813FE208848880840102033FC5008901010201040108011001280147E
+5F95:10401040204047FC9040124821486150AFFE20E0215021502248244428422040
+5F96:0840082013FE2202480009FC1000300053FE9020112811241222142210A01040
+5F97:08000BF8120823F84A080BF8100033FC501097FE101012101110101010501020
+5F98:089008901090279E489008901090339C509090901090179E1090109010901090
+5F99:082008201120213C4920092017FE300050209120113C112012A01460183E1000
+5F9A:104010402FFE404097FC1444255464E4A44427FC20E0215022482C4620402040
+5F9B:0840084013FC20A049100A0817FE300853C892481248124813C8100810281010
+5F9C:0820092410A420A848200BFE1202320252FA928A128A128A12FA1202120A1204
+5F9D:0840084017FC204048400BF8120833F8520893F8120813F8120812081FFE1000
+5F9E:088808881088208849540A221442302050209120113C112012A01260143E1800
+5F9F:100017FC2444444495F41444244467FCA40425F42514251425F4240424142808
+5FA0:08400840104027FC48400A4812483248555490E0115011501248144418421040
+5FA1:1400140027DE4912911211122FD26112A11225D22512251A25D43E1028102010
+5FA2:1040104027FE404093F8104827FE6048A3F820402240227C2240254024FE2800
+5FA3:11101110211047FC911011102FFE6000A3F82208220823F82208220823F82208
+5FA4:08100810177C211449FE0A14127C3710517C951015FE12101210150018FE1000
+5FA5:080009FC1104210449FC0904110431FC500093FE10201120113C112012A0147E
+5FA6:100017BC24844484948417BC24006400A7BC2424242427A82410242824442482
+5FA7:0840082013FE22024A020BFE1200320053FE9352155215FE1552155219521106
+5FA8:0840088013F822084BF80A0813F8300057FC9040104013F81040104017FC1000
+5FA9:0900090011FE22004DFC090411FC310451FC908010FC11081290106011981606
+5FAA:103C17E02420442097FE142025FC6504A50425FC250425FC2904290431FC2104
+5FAB:0880088013F821084FFE080013F8320853F8904017FC1040144017FE10401040
+5FAC:0840082013FC210848900BFE12023444502093FC108010F81088110811281210
+5FAD:0808083C13C020044A44092811FC3220502093FE102011241124112411FC1004
+5FAE:110815482548455097DE102420146FD4A0142794249424A824C8249428143022
+5FAF:083C0FC0124421284880091013E03040518893FC1044104017FC10A01110160E
+5FB0:08000BFE1020213C4920092017FE300057FE90201120113C1120112017FE1000
+5FB1:100017FC20A047FC94A414A427FC6000A7FC20002FFE20402248244429422080
+5FB2:100017FC240447FC942014A8247064A8A50424A024FC252024202BFE28203020
+5FB3:0820082017FE204048400BFC1294329453FC904010241522150A190810F81000
+5FB4:12101A902A904AA08FBE104420246FA4A22422282FA8221022282FA820442082
+5FB5:110815482548455097DE101427E46014A7D4211427D4210821082FD420242042
+5FB6:1108110825484390911E17D425646554A554275425D4254825482554246424C2
+5FB7:104010402FFE404097FC14A424A467FCA0002FFE204020242522250A290820F8
+5FB8:08400BF8111020A04BFC080013F8324853F8924813F8104013F8104017FE1000
+5FB9:1210111027D0421094BE1FE420546794A49427942494278824882494249425A2
+5FBA:0820082011FC20204BFE0908139C31085188963E100013FE109010901112120E
+5FBB:104010A023184DF6900017FC255464E4A7FC200023F8220823F8220823F82208
+5FBC:121014102F9048909FBE18A42FD46414A2142FD424142788248828942A943122
+5FBD:12101A902A904FA0803E1FC4242468A4AF24222824A83FD022282AA832442682
+5FBE:12101A902A904F90943E12242FD46014AF9420142F9420082F8828942F942022
+5FBF:0910089013DE20104A5E098213DE301053DE925013DE125013DE1250125212CE
+5FC0:104017FC200043B892A813B8211067FCA11027FC21102FFE212823102D482186
+5FC1:0BF80A0813F822084BF80A4813F8344457FC90801FFE1248155418E2115016C8
+5FC2:17BC14A427BC44A497BC14A427BC6120A3FE222027FC2A2023FC222023FE2200
+5FC3:0000020001000080008004000408240424042402440244128410041003F00000
+5FC4:1000100010001000180054005000500090001000100010001000100010001000
+5FC5:00000400021001100120082028482844288449024A028C120810181027F04000
+5FC6:1000100013FC1008181054205040508090801100110012021202120211FE1000
+5FC7:104010401040104019FC54445044504490441084108410841104110412281410
+5FC8:00003FF80000000000000000FFFE000001000880088848044812481287F00000
+5FC9:1000100017FC1084188454845084508490841084110411041204120414281810
+5FCA:1000100013FE1020182054205020502090201020102010201020102010A01040
+5FCB:1000100013F8100818085408500853F892081200120012021202120211FE1000
+5FCC:00003FF0001000103FF02000200420041FFC0100088848844812481287F00000
+5FCD:00003FF802081208120824080808105060200100088848844812481287F00000
+5FCE:001000F83F0001000100FFFE0100010001000000010008844892481287F00000
+5FCF:1010107813C0104018405440504057FE90401040104010401040104010401040
+5FD0:02000200020003F8020002000200FFFE00000100088848844812481287F00000
+5FD1:0000FFFE02000240022002100208020000000100088848844812481287F00000
+5FD2:0048004400440040FFFE0040084004401440554050A050A29292120A0E060002
+5FD3:100011FC1020102018205420502053FE90201020102010201020102010201020
+5FD4:10801080110011FE1A00540051F8500890101060108011001202120211FE1000
+5FD5:1040104010401840544053FE50409040104010A010A010901110110812041402
+5FD6:10101010101010101BFE54105010501091101090109010101010101010501020
+5FD7:0100010001087FFC0100010001103FF800000A102908292C6824482407E00000
+5FD8:02000100FFFE10001000100010001FF800000100088848844812481287F00000
+5FD9:10201010101010001BFE54805080508090801080108010801080108010FE1000
+5FDA:1020102010201120192C5534516453A491241134112811221122110210FE1000
+5FDB:100011F0111011101910551051905150915011101110111211121212120E1400
+5FDC:010000803FFE2000210020802240220022002A082A042A145210421081F00000
+5FDD:00003FF801000100FFFE0280044009203118C106119011482124412405000200
+5FDE:020001007FFC0820044003800C603018C0060100088848844812481287F00000
+5FDF:10401020102013FE188854885088508890881050105010201050108811041602
+5FE0:010001003FF82108210821083FF8210801000100088848844812481287F00000
+5FE1:10201020102010201BFE5622522252229222122213FE12221020102010201020
+5FE2:00007FFC020002003FF0041004100810FFFE0000010008844892481287F00000
+5FE3:100013FC1084108818885490509C508491441144112811281210122814441182
+5FE4:10801080108011FC192056205020502093FE1020102010201020102010201020
+5FE5:100010003FFC20004FF080003FF000100810041014905050514A514A8F060002
+5FE6:1040104010A018A0551052085406911011101110111011101110121012101410
+5FE7:10901088108810801BFE54A050A050A090A010A01120112211221222121E1400
+5FE8:1000100013F818005400500057FC9120112011201120112012221222141E1800
+5FE9:04400440082010102208C44608201FF000100100088848844812481287F00000
+5FEA:102011201120191055105248524894441882108011101108120817FC12041000
+5FEB:10401040104013F8184854485048504897FE104010A010A01110111012081406
+5FEC:100013F81008191054A0504057FE904210441040104010401040104011401080
+5FED:10401020102010001BFE54405040506090501048104410441040104010401040
+5FEE:10401040104017FE18405440504057F892081208111010A0104010A011181606
+5FEF:1008103C13E012201A205620522053FE9220121012101212120A128A13061202
+5FF0:1080108013F01890549051125112924E144010401FFE10401040104010401040
+5FF1:10401040104013FC1A4454485040504090A010A010A0112011221222141E1800
+5FF2:10401040104010401BFE5440504050A090A010A0111011101288124814441802
+5FF3:10201020102013FE1820552451245124912411FC1024102010221022101E1000
+5FF4:1040104010A018A05510528854469040100013F8100810101010102010201040
+5FF5:01000100028004400A203118C1060FE000400080010008844892481287F00000
+5FF6:1000100011FC18005400500053FE90201020104010401088110413FE11021000
+5FF7:10001008110810881A5256525222522292521292130A120A120213FE10021000
+5FF8:100013F81088108818885488508857F891081108110811081108110817FE1000
+5FF9:1000100013FE1020182054205020502091FC1020102010201020102017FE1000
+5FFA:10801080108010FC1904550852405440904010A010A010901110110812041402
+5FFB:1008101C11E011001900550051FE511091101110111011101110121012101410
+5FFC:10801040104017FC1800540051F05110911011101110111211121212120E1400
+5FFD:080008001FF81248224844880888110822280410010008844892481287F00000
+5FFE:1100110011FC1A00540051F85000900013F8100810081008100A100A10061002
+5FFF:0440082010102FE8C4260420082010A060400100088848844812481287F00000
+6000:1000100017FE102018205440504050D091481244144210401040104010401040
+6001:010001007FFC0100028004400A203118C0060100088848844812481287F00000
+6002:0820082008200820145012502288208841048202010008844892481287F00000
+6003:100013FC104018405440504057FE904010A010A010A0112011221222141E1800
+6004:100013FC120012081A8856505250522092201250125012881308120013FE1000
+6005:110011081108111019205540510057FE91401120112011101108114411821100
+6006:1040104010A018A055105208540691F011101110115011201104110410FC1000
+6007:100013FE120012001A0057FC520452049204120413FC12001200120013FE1000
+6008:10481248124812481A4857FE5248524892481248127812001200120013FE1000
+6009:1080108011FC11041A0455F451145114911411F4110411281112110210FE1000
+600A:100013FC108410841884550451145208940011FC110411041104110411FC1104
+600B:100013FC120412041A0457FC5220522093FE1220122012101212128A13061202
+600C:100013FC102010201840544050D0514892441444104010401040100017FE1000
+600D:10801080108018FE554051405240907C104010401040107E1040104010401040
+600E:080008000FFC1400240047F00400040007F80400010008844892481287F00000
+600F:10401040104013F81A48564852485248924817FE104010A010A0111012081406
+6010:10801080110011FC1A04540451E451249124112411E411241004100410281010
+6011:2040224421483150A840A7FCA040A04020402FFE204020402040204020402040
+6012:10001000FEFC22844488285010202858C5860000010008844892481287F00000
+6013:21002100213E211237D2AA52A252A254A254249422882108229424A428422080
+6014:1000100013FE10201820542051205120913C1120112011201120112017FE1000
+6015:10201020104011FC190455045104510491FC1104110411041104110411FC1104
+6016:10401040104013FE188054A0512051FC93241524112411241134112810201020
+6017:104010401040187E544050405040904013FC1204120412041204120413FC1204
+6018:010001007FFC010001001FF0101010101FF00100088848844812481287F00000
+6019:10201020102010201BFE54205020502091FC1104110411041104110411FC1104
+601A:100011F811081108190855F851085108910811F8110811081108110817FE1000
+601B:1000100011FC11041904550451FC51049104110411FC11041000100013FE1000
+601C:1040104010A018A0551052485426902013F810081010111010A0104010201020
+601D:00003FF8210821083FF8210821083FF820080100088848844812481287F00000
+601E:10201020102010201BFE562252225222922213FE122212221222122213FE1202
+601F:1008103C13E012201A205620522053FE9220121012101212120A128A13261212
+6020:02000400082010103FF800081FF0101010101FF0010008844892481287F00000
+6021:10201020104018405488510453FE9002100011FC110411041104110411FC1104
+6022:102010201120112019FC55205220502093FE1020105010501088108811041202
+6023:090009001FF0210001007FFC0280044008203018C10608844892481287F00000
+6024:0810081017FE3010521091101110105010200100088848844812481287F00000
+6025:08000FE0102020405FF8000800081FF8000800083FF802005104511290120FF0
+6026:100013F8104010401A4855485150504097FE1040104010401040104010401040
+6027:102010201120112019FC552052205020902011FC102010201020102013FE1000
+6028:100010F83E884288A2A8149008841084207CC000010008844892481287F00000
+6029:100011FC11041104190455FC51005140914411481170114011421242123E1400
+602A:100017F81208111018A0544050A053189C46104017FC1040104010401FFE1000
+602B:10901090109013FC1894549453FC5290929013FE10921092111A111412101410
+602C:1000100013FE12521A5256525252525292521292128E13021202120213FE1202
+602D:1000104010201028180854885090529492A212A214C210881188128814781000
+602E:2220222022203420AD7CA924AE24A2242424242429242F242144204420942108
+602F:10401040104010401BFC54405040504097FE1040108010801110120817FC1204
+6030:10401020102013FE184054405088510893F0102010401088110413FC11041000
+6031:080008001FF812482A4844880A88110822A80410010008844892481287F00000
+6032:100013FE10201020182057FE522252229252124A128A130212021202120A1204
+6033:100013FC120412041A04560453FC5090909010901090111211121212140E1800
+6034:10281024102410201BFE56205224522492241228122812901312122A10461082
+6035:10201028102410201BFE54205070507090A810A8112412221420102010201020
+6036:10201020102013FE1A225624522053FC92841288124812501220145014881906
+6037:011001080100FFFE01001110111011102110C00E010008844892481287F00000
+6038:0120011001007FFC0380054009203118C1060000010008844892481287F00000
+6039:104010402240227863C8AE48226822522242220221FE02005104511290120FF0
+603A:10401020101019E05422503453B890B010A810A8112811241224142210A01040
+603B:10100820044000001FF01010101010101FF01010010008844892481287F00000
+603C:000800087E0802FE240814480828140822284010010008844892481287F00000
+603D:10401040104013FC18405440504057FE90E01150115012481444184210401040
+603E:1000100011FC1104190455045104510491FC1104100010901088110412021402
+603F:100017F81208111018A0544051B0564E904013F81040104017FC104010401040
+6040:1040104010FC11081A90546050485190963E1042108413481030102010C01700
+6041:08380BC01040304057FC90401040104013F80100088848844812481287F00000
+6042:10801080110011FC1A04540453E45224922413E41224122413E4100410281010
+6043:1040104010401BFC5440504057FE9010101017FE101012101110111010501020
+6044:10201020102013FE1820542051FC5000900011FC110411041104110411FC1104
+6045:10401040104419F45448505053FE904010801184129814E010821082107E1000
+6046:100017FE10801080188054F85108514891281208128810501010101017FE1000
+6047:100013FE120012001BFC5620522052F892201220122013FC1200120013FE1000
+6048:10401040109011081BFC54245120512091FC1220102017FE1020102010201020
+6049:11001104113811C01902550250FE500091FC1104110411FC1104110411FC1104
+604A:2040204023FC3084A884A114A208A01024102FBE24922492249228A22AAA3144
+604B:02000100FFFE0440145014482444444400000100088848844812481287F00000
+604C:109010901090129219945498509051989294149210901090111211121212140E
+604D:10401044124419485550504057FE9090109010901090109211121112120E1400
+604E:100013FE102010401888550453FE50229020102013FE10201020102017FE1000
+604F:100010FCFE042208221064FE141008103450C220010008844892481287F00000
+6050:00007DF011101110119011501D12E212440E0800010008844892481287F00000
+6051:1040104010FC11041A0855FE5100517C914411441154114811421242123E1400
+6052:100013FE1000100019FC5504510451FC9104110411FC11041000100013FE1000
+6053:100017FE10901890549053FC5294929412941294129C13041204120413FC1204
+6054:10401020102013FE180054885104520290881088105010501020105010881306
+6055:10001000FE7C2244444434440844147C2244C000010008844892481287F00000
+6056:020004003FF8244822882108228824483FF80100088848844812481287F00000
+6057:1020102013FE10501888550452FA500093FE1040108011FC1004100410281010
+6058:109010901090191055FE53105510913811381154115411921110111011101110
+6059:082004407FFC010001003FF801000100FFFE0100088848844812481287F00000
+605A:01003FF801000100FFFE000001003FF801000100FFFE02005104511290120FF0
+605B:1000100013FC12041A0456F4529452949294129412F41204120413FC12041000
+605C:102810241024182057FE5020502097E0112011101110111011CA170A12061002
+605D:080008007F7C08243E2408247F44085408880100088848844812481287F00000
+605E:1040104017FC10401BF8544853F8524093FC1044105410A810A0111012081406
+605F:11001100110019FE56025202551298A2124A12AA131A120A13FA100210141008
+6060:10401040104013FE1880549051105110937C151011101110111011FE11001100
+6061:10081190106010981B045440504057FE90801090111011201248148419FC1084
+6062:10401040104013FE188054905090511291521154129012281428104410841102
+6063:4080208009FC12042448E04020A023182C060100088848844812481287F00000
+6064:10401040108011001BFC56945294529492941294129412941294129417FE1000
+6065:0000FF20241024103C00244024403D44254225422E42F4484448044804380400
+6066:10401040108013FC1A04560452F4529492941294129412F41204120412141208
+6067:0000FFFE020004003FF824882488248824A82010010008844892481287F00000
+6068:100013F8120812081BF85608520853F892441248123012201210128813061200
+6069:00003FF8210821082FE821082288244828283FF8010008844892481287F00000
+606A:1080108010F811081B1054A0504050A09118120615F811081108110811F81108
+606B:200027FC2404240435F4AC04A404A5F4A5142514251425F42404240424142408
+606C:1008103C11E01020182055FE50205020902011FC110411041104110411FC1104
+606D:044004403FF804400440FFFE0440082012102208C2261290124822480A000400
+606E:1040104010A011101A08540653F850409040104013F810401040104017FE1000
+606F:010002001FF010101FF010101FF010101FF01010010008844892481287F00000
+6070:1040104010A011101A08540653F85000900013F8120812081208120813F81208
+6071:10901090110811481A445492510853FC909410901090109011121112120E1400
+6072:11041084108810001BFE548850885088908817FE108810881108110812081408
+6073:00003FF020103FF020103FF0220821902C60301C010008844892481287F00000
+6074:02000100FFFE00003FF820083FF820083FF80100088848844812481287F00000
+6075:01000100FFFE01003FF821083FF821083FF80000010008844892481287F00000
+6076:00007FFC04402448144814500440FFFE00000100088848844812481287F00000
+6077:08400840104037FC50E091501150124814441842104002005104511290120FF0
+6078:2010201027903010A87EA012AFD2A21222122422252228A22FC2204220942108
+6079:100013FE122012281A24562053FE522092201250125012501488148819041202
+607A:102011241124112419FC540051FC5004900411FC110011001102110210FE1000
+607B:200427C4244424543554AD54A554A554A5542554255421042284224424142808
+607C:10401020102017FE180054005090525492241224125412941204120413FC1004
+607D:100013FE12021C44544053FC508090A0112011FC1020102017FE102010201020
+607E:1090109017FE109018905440502057FE91001100110011001100110011FC1000
+607F:3FF0066001803FF821083FF821083FF821082018010008844892481287F00000
+6080:100013FC100818D0542053FE5222922213FE1222122213FE12221222122A1204
+6081:100011F81108110819F8540053FC5204920413FC1204120413FC120412141208
+6082:12201224122813B01A20562252A2531E9040104013FC10401040104017FE1000
+6083:200027FC244424443444AFFCA444A4C4A4E42554264424442444240427FC2404
+6084:1020112410A410A8182055FC5104510491FC1104110411FC1104110411141108
+6085:10101090108811081A0455FA51085108910811F810901090109011121212140E
+6086:010002800C603018CFE601003FF8111025080200010008844892481287F00000
+6087:1040104010A011101A0855F65040504097FC1040125012481444184411401080
+6088:10101014101210101BFE54105150515497F4115411541148124A125A14261042
+6089:00F83F00111009200100FFFE092011102108C006010008844892481287F00000
+608A:080C08F07E8008800EFE78880888290812080100088848844812481287F00000
+608B:1040102017FE11081890546050605198960611F8110811081108110811F81108
+608C:11081088109013FC1824542453FC5220922013FE106210A2112A122414201020
+608D:100011FC110411FC190455FC5000500091FC1020102013FE1020102010201020
+608E:10201120112011FE1A205420502053FE9000100011FC11041104110411FC1104
+608F:10201020102013FE1820542051245124912412AA102010501050108811041202
+6090:4420282010A428A448A8992028204850885008885104220201004884481287F2
+6091:1048104413FE1840544053FC5244924413FC1244124413FC1244124412541208
+6092:100011F81108110819F8540053FC52449244124413FC12001202120211FE1000
+6093:100013F8120812081BF85608520853F89208120813F81120112012221422181E
+6094:1100110011FC1A0055F851085148912817FE11081248122813FC100810501020
+6095:2208211020E03110AA08A080AFFEA140224027FC2A4422442254224820402040
+6096:1020102013FE1820542053FE5202940411F81010102013FE1020102010A01040
+6097:1080108011F81A08541053FC52449244124413FC10A010A011221122121E1400
+6098:00003FF8240027F028803FFC2140222024103FFC010008844892481287F00000
+6099:1040102013FE100019F85508510851F8900013FC100810301020102010A01040
+609A:1020102013FE1020182055FC5124512491FC1020107010A81124122210201020
+609B:10401040108811041BFE540250885144924210F8118812501020105011881606
+609C:100011FC11041104190455FC5000500093FE1020102011FC1020102013FE1000
+609D:200027FC2444244437FCAC44A444A7FCA040204027FC2040204020402FFE2000
+609E:100010F8108810881AF85600520053FC9044104417FE104010A0111012081406
+609F:100013FE1040104019FC5484508453FE9000100011FC11041104110411FC1104
+60A0:10401040247E6488A54824502420205820862300010008844892481287F00000
+60A1:0604780408440844FF441C442A44490488140808010008844892481287F00000
+60A2:1080104013F812081A0857F85208520893F81240124412281210128813061200
+60A3:01001FF0111011101FF001003FF8210821083FF8010002005104511290120FF0
+60A4:020004003FF8220823C824482A882108228824083FF8200801004884481287F2
+60A5:02000100FFFE00003FF800003FF800003FF820083FF802005104511290120FF0
+60A6:12081108111010201BF856085208520893F810A010A0112011221222141E1800
+60A7:108411C4170411141914551457D4511493141394155415041904110411141108
+60A8:0900090011FC3204544899501148124414441140108002005104511290120FF0
+60A9:104212221124110418085400520A528A925212221252128A130A120213FE1002
+60AA:00007FFC04403FF8244824483FF80440FFFE0100088848844812481287F00000
+60AB:01007FFC01003FF800007FFE40028FE4082010222022C11E288828A4482407E0
+60AC:1FF010101FF010101FF01010FFFE082010103FF810080100288828A4482407E0
+60AD:108012FC12A412A41AA8569052A850C69020102011FC10201020102013FE1000
+60AE:200023F82208220833F8A800A000A7FCA04020402FFE204020A0211022082C06
+60AF:110010BE128212021A42562253FE5292925212221252128A130A1202120A1204
+60B0:1040102013FE1202180055FC5000500093FE1020112811241222142210A01040
+60B1:109010901090179E189054905090539C909010901090179E1090109010901090
+60B2:044004407C7C044004403C78044004407C7C0440010008844892481287F00000
+60B3:00803FFE008007F8240827F8240827F8240827F820003FFE01004884481287F2
+60B4:1080104013FC18005510511052A894441000104017FE10401040104010401040
+60B5:100010FC108018F8548050F8508097FE11401124112811101108114411821100
+60B6:00007C7C44447C7C44447C7C42044104450454245454645443C4400440144008
+60B7:1040102013FC12041A0457FC52005228922413FE122012501250148815041A02
+60B8:203823C0204027FC30E0A950A248AC46A3F02020204027FC2040204021402080
+60B9:01007FFE40029FE410201FE010001FF0101010101FF002005104511290120FF0
+60BA:1040102013FE1A02540451F85108910811F81100110011FC1104110411FC1104
+60BB:1020102013FE1020182057FE5088505093FE1020102017FE1020102010201020
+60BC:10401040107E10401BFC560453FC520493FC1244104017FE1040104010401040
+60BD:1040104017FC10401BF8544857FE504893F8108017FE11081390106011981604
+60BE:10401020102013FE1A02549451085204900011FC102010201020102017FE1000
+60BF:100013FC104010401BFE54A05110520894461040104812641252145211401080
+60C0:2040204020A03110AA08ADF6A000A7FC24A424A427FC24A424A424A424142408
+60C1:080C08F07E8018802CFE2A884888888809080100088848844812481287F00000
+60C2:1080108010F811081A1054005040539C92041204139C12041204120413FC1204
+60C3:100013FC120412041BFC5604520453FC90001220122413A81230122212A2131E
+60C4:08000F7C08440844FF4808282A30491089282844108202005104511290120FF0
+60C5:1020102013FE102051FC582057FF940011FC110411FC110411FC11041114110C
+60C6:100013FE122212221AFA5622522253FE920212FA128A128A12FA1202120A1404
+60C7:1040102013FE100019FC550451FC500091FC1008101013FE1020102010A01040
+60C8:100013F8124812481BF85648524853F8904017FC10E011501248144610401040
+60C9:10400840407E2040084013FC7204120413FC1000010008844892481287F00000
+60CA:1040102013FE1000180055FC5104510491FC1020112811241222142210A01040
+60CB:1040102013FE12021D04550051DE525292521352149A1094111011121212140E
+60CC:020001007FFE400290041EF8228824A8549008841084607C01004884481287F2
+60CD:1040104010A011101A08540651F05040904013F8104012481148115017FC1000
+60CE:08207FFC08200FE008200FE00820FFFE10102208C10609002828282447E40000
+60CF:211021102110211037BCA910A110A338A3B82554255429922110211021102110
+60D0:10141012101017FE1810541053D252529252125413D4100810EA171A12261042
+60D1:00500048FFFE00403E4022243E2800120E2A70C603020100288828A4482407E0
+60D2:0600787C08440844FF441C442A44497C88440800010008844892481287F00000
+60D3:1020112410A81BFE5440508057FE9108120415FA1908110811281112110210FE
+60D4:104012441244144818A0551056085044904012481248145010A0111012081C06
+60D5:100011FC110411FC190455FC5080508091FE124A144A10921122124210941108
+60D6:1FF010101FF010101FF008001FF82248448809081228241001004884481287F2
+60D7:2040204020A03110AA88A446A800A3F020102020204021242522250A290820F8
+60D8:100013FE1202128A1A5257FE5242522293FE12821282128212FA1202120A1204
+60D9:200027BC208422943108AA94A4A4A840A00027BC20A422A42128229024A82846
+60DA:1080108010FC11541A5454A45124524490941108104010A412AA128A14781000
+60DB:101C13E0122013FE1A205692530A520691FC1104110411FC1104110411FC1104
+60DC:10881088108813FE1888548857FE500091FC1104110411FC1104110411FC1104
+60DD:1020112410A410A8182057FE5202520292FA128A128A128A12FA1202120A1204
+60DE:201020902710243E3422AC44A790A510A5102510252825282528294429443082
+60DF:10A01090108011FE1910571055FC5110911011FC11101110111011FE11001100
+60E0:010001007FFC01003FF821083FF821083FF80104FFFE0102288828A4482407E0
+60E1:00007FFC04403C78200820083C780440FFFE0000010008844892481287F00000
+60E2:01000080088848044812481287F00000101008082220A124A4A2A4A41D1C0000
+60E3:108050807CFC515492541CA4F124124410941108010008844892481287F00000
+60E4:10101388108810FE1890579052245224923813881090109010A410BE12821100
+60E5:01000500397821083D7821083FF8028004401830E10E08844892481287F00000
+60E6:1040102013FE12001A205620523E5220922012FC128412841284148414FC1884
+60E7:100013F8120812081BF8560853F8520893F8120812081FFE1000111012081404
+60E8:20802090210833FCA840A7FEA110A2482C862310202020C42308203020C02700
+60E9:100023FE40208920113C31205120912017FE1000010008844892481287F00000
+60EA:01007FFC01001FF010101FF010101FF010101FF01010FFFE01004884481287F2
+60EB:08000FF010202C4003801C70E00E1FF011101FF011101FF001004884481287F2
+60EC:200027FE2420242035FCAC20A524A4A8A7FE2420245024482484250427FE2000
+60ED:21002102211C2FD03210AA10A51EA7D4A114211421D42F142514212421242144
+60EE:11041088105011FC1924552451FC5124912411FC1020102013FE102010201020
+60EF:11FC1124112413FE1924552451FC500091FC1104112411241124105810841302
+60F0:1040104013FE108019FC562055FE500091FC110411FC110411FC110411141108
+60F1:109211241248112418925440508053FE9202128A125212221252128A13FE1202
+60F2:100013FE122210201BFE542051FC512491FC112411FC102013FE102010201020
+60F3:080008F808887E8808F818881CF82A88488808F8010008844892481287F00000
+60F4:2040244424443444AFFCA000AFFEA040208027FC24A424A424A424A424A4240C
+60F5:10901290129017FE1A90569052F0520093FC104017FE10E0115012481C461040
+60F6:1020104011FC110419FC550451FC500093FE1020102011FC1020102013FE1000
+60F7:01007FFC01003FF80200FFFE08201FF02828CFE608200FE001004884481287F2
+60F8:110011FE120215F2191255F2511251FA900413F81010102017FE102010A01040
+60F9:08207FFC08200200FFFE08001FF02810C8100FF0010008844892481287F00000
+60FA:100011FC110411FC190455FC5020512091FE1220102011FC1020102013FE1000
+60FB:200227C22442245237D2AC52A452A7D2A452245227D2200222822242244A2804
+60FC:1040102013FE12021A0257FE5200520093FE1352155215FE1552155219521106
+60FD:100013FC120413FC1A2057FE5210528A9306100013FC120413FC120413FC1204
+60FE:10001088125212221A52568A520253FE90881144127A10881150102010D81706
+60FF:100011FC1104110419FC5504510451FC900013FE10201120113C112012A0147E
+6100:208821C827083108A92AA12AA7ACA14823082388255425142914212421242142
+6101:0E207820082408A4FEA819202C504A50888809040A020100288828A4482407E0
+6102:08107F1008107F7E41123E1204120F1278220822284A108401004884481287F2
+6103:1040102013FE1A02540451FC500091FC110411FC110411FC1104100013FE1000
+6104:100013F8124812481BF85648524853F8900017FE124012441228129013081206
+6105:2110211027FC211031F0A840A3F8A248A24823F820402FFE2040204020402040
+6106:1200213C48009400217E6208AE08220822282210210008844892481287F00000
+6107:1040104011FC10841BFE540051FC510491FC102013FE1020122013FE10201020
+6108:010002800C6037D8C0063E0822483E4822483E482208261801004884481287F2
+6109:104010A0111012081DF6540053C45254925413D41254125413D41244125412C8
+610A:100013FE100011FC1904550451FC500093FE1222122213FE1222122213FE1202
+610B:103C17C012441928540053FC5080908017FE110011F812881250142018D81306
+610C:1080108010F811081A1055FC51045154918C1124102013FE1050108811041602
+610D:00207F20413E7F4448A47F244828451053286146010008844892481287F00000
+610E:1100110011FE1A0055FC510451FC910411FC108010FC11081290106011981606
+610F:01003FF808200440FFFE00001FF010101FF010101FF002005104511290120FF0
+6110:100017FE104010801BFC5694529452F49294129412F412941294129413FC1204
+6111:100013FC108810501BFE562253FE522293FE1222104013FE1042108211141208
+6112:100013F812081BF8560853F8510093FC1444124412A4120413F4100410281010
+6113:200023F8220833F8AA08A3F8A000AFFE220023FC249429242244248421282210
+6114:2080204027FC3000AA08A110AFFEA00023F82208220823F82208220823F82208
+6115:200027BC24A424A437BCA800A3F8A000A7FC2100220023F82008200820502020
+6116:1110111017FC111019F0551051F05110911017FE120012901308120013FC1000
+6117:00407F40127E0C88FF4819482A504820A850108C010008844892481287F00000
+6118:1040102013FE1202188054F85108529090601198160611F81108110811F81108
+6119:020001007FFE48029FF4282007C01830E00E1FF010101FF001004884481287F2
+611A:1FF011101FF011101FF001003FF8210821482FE82428201001004884481287F2
+611B:007C3F80110808907FFE41029494142823E808000FF01420224041800E60701C
+611C:200027FE2420242035FCAC20A4A8A4A8A5742420245024482484250027FE2000
+611D:100013FE120012FC1A8456FC528452FC922013FE124812C812301248128413FE
+611E:100013FE102010401BFE56525252525292421226102017FE1050108811041602
+611F:002800243FFE20202FA420242FA8289828924FAA4046808201004884481287F2
+6120:100011F81108110819F85508510851F8900013FC129412941294129417FE1000
+6121:1080108010FC11541AD454B4512C524490941108104010A412AA128A14781000
+6122:100013FC124412441BFC5644524453FC9000104010241522150A190810F81000
+6123:100013FC12941A94569453FC5080904017FE108010F810881108110812281410
+6124:102011FC102010881BFE5488500051FC91041124112411241124105010881304
+6125:2110211027FC21103150A840A3F8A248A24822482FFE204020A0211022082406
+6126:1020102011FC192455FC502053FE900011FC1104112411241124105010881304
+6127:2040208027FC24443444AFFCA444A484A7FC208021502164227C24422842303E
+6128:08007F7808483E4800867F78414800303ECE0000010008844892481287F00000
+6129:100011FC102010201BFE540051FC510491FC110411FC110411FC108811041202
+612A:100011F81108110819F8540053FC520493FC120413FC120413FC109011081204
+612B:1040104017FC10401BF8544057FE5080911013E0104817FC1044124815441080
+612C:2200147CFF44087C4944497C7F44084410942108410008844892481287F00000
+612D:1040104411F810501BFE544050F85182927E140011FC110411FC110411FC1104
+612E:1008103C13C010041A44552851FC5220902013FE102011241124112411FC1004
+612F:10A0109011FE1B2055FC512051FC912011FE110013F811081090106011981606
+6130:100011FC110411FC190455FC5020512490A8102013FE1090109011121212140E
+6131:1020101011FE190055205120553C93501190131015FE11101128122812441482
+6132:100011F8110811E8192857FE540251F8910811F8110811F81108110811281110
+6133:00003E7C22443E7C22443E7C22443E7C00000100088848844812481287F00000
+6134:10201020105018C8552453FE550491FC110411FC110011FC1284128414FC1084
+6135:100013DE104210421BDE5610521053DE90421252114A114A1252104212941108
+6136:104011FC10441094190857DE514A514A929411FC110411FC110411FC1104110C
+6137:1040124812481A4857F8500057FC900013F81208120813F8111010A017FE1000
+6138:082008207F7C2A242A245D2408241C442A944808010008844892481287F00000
+6139:2040202023FE22023494A908A264A090A108220425FA21082108210821F82108
+613A:1088108813FE1088180055FC510451FC910411FC1124102013FE102010201020
+613B:000C7DF00440088811F010201C44F3FE102211245222206001004884481287F2
+613C:120C13F2120219FE540051FC550495FC150415FC150415FC140017FE11041202
+613D:1028102413FE102019FC552451FC512491FC1124100813FE1088104810481018
+613E:1100110011FC1A0055F8500053F8908812A811C817F8108A11CA16AA10861082
+613F:00003FFE208027F8240827F8240827F8225024482944208020444A424A1291F0
+6140:103C17C0124419285480511053E09040118813FC1044104017FC10A01110160E
+6141:3FF820082FF822082D2822C82DA822982D8820083FF802005104511290120FF0
+6142:200017F8911040A047FC144427FCE44427FC244424040100288828A4482407E0
+6143:2120211022083486A910A3F8A008A00027BC208424A4229424A4208422942108
+6144:200027FC20A020A037FCACA4A4A4A7FCA040204027FC20E0215022482C462040
+6145:100013F81148111018A0544051B0564E904013F81248124813F8104417FC1004
+6146:103C13C010441224192855005040539C92041204139C12041204120413FC1204
+6147:0600387820483E4822863E0022FC3E4420283E1022284A4685004884481287F2
+6148:08200440FFFE10201020244878F0102024487EFC02040100288828A4482407E0
+6149:2080204027FC20803108ABF0A060A184A7FE200227FC244427FC244427FC2404
+614A:211020A0200027FE30A0ABF8A0A8A7FEA0A823F820A021B022A82CA620A020A0
+614B:108024987EE000847E7C42007E9842E07E844284467C02005104511290120FF0
+614C:2108210827FE21483020AFFEA200A200A3FC2000224822482248244A244A2846
+614D:200023F8224822A83318AA08A3F8A000A00027FC24A424A424A424A42FFE2000
+614E:2040204027FC204033F8AA08A3F8A208A3F8220823F822082FFE211022082404
+614F:100013FE1202100019FC550451FC510491FC1040102013FE1000108811041202
+6150:3FF801007FFC00001FF010101FF010101FF010101FF0082011104884481287F2
+6151:200023FC210821F83108A9F8A10EA7F8A00827BC20A422A42128229024A82846
+6152:1050105013FE10501BFE565253FE525293FE100011FC110411FC110411FC1104
+6153:20002FFE20A027FC34A4ACA4A7FCA000A7FC20002FFE20402248244429422080
+6154:2110211027FC21103000ABF8A208A3F8A20823F8204027FC20A0211022082C06
+6155:04407FFC04401FF010101FF010101FF00400FFFE12102208CB2612902A900400
+6156:200027FE242A242637FEAC22A7AAA6AAA7AA24322596262E2446248227FE2402
+6157:08200820FFBE08447FA449247F281C282A1049288844088201004884481287F2
+6158:2080211023F8221034A4AFBEA042A0A0A3182C46219026642188263021C02E00
+6159:08047F7808407F40497E7F4849487F4808487F48088802005104511290120FF0
+615A:22002202223C2FA03220AFA0AABEAFA4AAA42FA422242FA42224224422442284
+615B:1020122213FE1090188855FE5310551091FE1110111011FE1110111011FE1100
+615C:20203FA0403EBF4429A425247FE8292845107FA8014402825104511290120FF0
+615D:3FFC24202FF825203FFC220027F02A1033F020003FFC02005104511290120FF0
+615E:102011FC108810501BFE540051FC510491FC110411FC102013FE102010201020
+615F:21C8270821082FE8311EAFCAA54AA7CAA54A27CA210A27CA211221D22E2A2444
+6160:21082108210827D0311EAF94A124AFD4A21423D422542248224824D424242842
+6161:2040204027FC20403554AA48A554A040A5542248255420A020A0211022082C06
+6162:23F8220823F83208ABF8A000A7FCA4A424A427FC200023F8211020E023182C06
+6163:100011FC112413FE192455FC500051FC910411FC110411FC110411FC10881104
+6164:08787F4808483E8600787F4841489C2815102628404602005104511290120FF0
+6165:10101450127C1290181054FE50005600927C12441244127C1244150018FE1000
+6166:0A2009207FBE08446AA41C242A28491028281046010008844892481287F00000
+6167:1010FEFE10107C7C1010FEFE10103FF800081FF800083FF801004884481287F2
+6168:200027BE2488248837A8ACA8A4A8A7BEA4102518249825A826AA244A20462080
+6169:2010241022FE3210A8FEA092A6FEA29222FE221022FE22102210251028FE2000
+616A:100013FE1200127C1A445644527C520092EE12AA12AA12AA12EE120013FE1000
+616B:1110211041108AA814443240527C9240154018FE110008844892481287F00000
+616C:1088108813FE108818F8542051FC512491FC102013FE102011FC102013FE1000
+616D:081408127F104AFE2C10FF101C282A2849448882010008844892481287F00000
+616E:010001FC01003FFE21022FF4210027F8244827F8244827F820804A44521281F0
+616F:110011FC120015F8190855F8510851F8900017FE110013FC14A4112412541088
+6170:3F0821083F7E20082F4820285FA8440895282C90010008844892481287F00000
+6171:102013FE102011FC192455FC512451FC902213FE100813FE1108108810281010
+6172:1088108813FE1088188854F8502053FE9222133212AA137612221222122A1224
+6173:200027DC251427D43454AFC8A508A514A7E22000204027FC204020402FFE2000
+6174:100013DE10421252194A56525042502091FC1104110411FC1104110411FC1104
+6175:202027FE242025FC3424AFFEA424A5FCA42025FC252425FC252429FC2924312C
+6176:00803FFE22203FFC22243FFC20003FFE20822A5431F2220027F84A0841F09E0E
+6177:2040202027FE242035FCAC24A7FEA424A5FC2420256224B429282A2630A02040
+6178:145014507FFC245247CE80007FFC41041FF011101150112001004884481287F2
+6179:10407C4011F8FE48444828C87C68109AFE8A1106120202005104511290120FF0
+617A:204023F822482FFE3248ABF8A040A3F8A24823F820802FFE211020E023182C04
+617B:10401248115013F8188057FC5110520897FC1A0A13F8120813F8120813F81208
+617C:002800243FFE2220232422242FA822282A92522A46468102288828A4482407E0
+617D:20142012201027FE3410AC90A4D2A492A7F22494249425C82AAA289A31A62042
+617E:14202220493E144222944110BE28222822443E82010008844892481287F00000
+617F:43FE222023FC0A200BFC1220E3FE212227FA2122022602005104511290120FF0
+6180:100017BC108414A41A9454A450505188962610C0131010641388103010C01700
+6181:1040108013FC12441AF4571452A4524492A413FC104010241522150A190810F8
+6182:7FFC02001FF010101FF010107FFE41029494142823E808001FF0682007C0F83E
+6183:01007FFC01003FF80200FFFE08203CF8D0161CF010101FF001004884481287F2
+6184:104027FC40408BF8120833F8520893F8120813F8120817FE01004884481287F2
+6185:7F200820FF2008FC7F2449247F2449247F2408447F440894FF08020851249FE4
+6186:1020112410A813FE1A0254F85088508890F81020102011FC1020102013FE1000
+6187:0688388809FE7E88088808F83E88228822883EF8010008844892481287F00000
+6188:1040107C104013FE1A42567853C4523C920012501254135414D8145019FE1000
+6189:1082108217F41088188057E2500253E49228122013E012221142107417881210
+618A:111017FC21102FFE6100A3F826482BF8224823F82248225801004884481287F2
+618B:082049202A3E7F4449A45D286B28491049284346010008844892481287F00000
+618C:08401440227C5C8489443E2C08144A2428C40E28701022005104511290120FF0
+618D:203823C0208027FE3110AA08A5F6A910A1F0200027FC240425F4251425F4240C
+618E:11041088100013FE1A2256AA5272522293FE100011FC110411FC110411FC1104
+618F:2100211023DC22543554AA88A108A2F4A402200023FC20402150224825442080
+6190:20402248215027FC3150AA48A444A208A20823BE24882AA8213E220824082808
+6191:43FC22400BF80A4013F82240E3FC200425542008010008844892481287F00000
+6192:104013F8124813F8184057FE500053F8920813F8120813F8120813F811101208
+6193:204020402FFE204037FCAC44A7FCA444A7FC20442FFE204220242522250A28F8
+6194:2140212023FE22203620ABFCA220A220A3FC2220222023FE2200252424922892
+6195:202027A420A822923114AA08A5F4A802A3F82208220823F8220821102FFE2000
+6196:081408127F102AFE2A105D101C282A2849448882010008844892481287F00000
+6197:082008207F3E2A442AA45D2408281C102A284846010008844892481287F00000
+6198:102013FE102019FC540051FC510491FC108817FE100011FC1104110411FC1104
+6199:01007FFC01003FF800003FF820083FF80820FFFE20083FF801004884481287F2
+619A:100013DE125212521BDE540051FC512491FC112411FC102013FE102010201020
+619B:100013FE10501BFE565253FE500091FC110411FC110411FC102013FE10201020
+619C:2020272025FE2540357CAE90A57EA500A57C2544257C2644247C24442444244C
+619D:08407F40007E3E8823483E4800503E5004207F500888290411004884481287F2
+619E:221021102FD0201037BEACA4A7D4A014A7942094211421C82F08211425142222
+619F:200027FC20A020A037FCACA4A4A4A7FCA248215027FC20E0215022482C462040
+61A0:3FFE289025102FBE22222AD42A902F90222844284444888201004884481287F2
+61A1:1210121013DE152818A4542053FE502093FE1222122A127410A8112416221020
+61A2:1020102011FC10201BFE5508539C51089188163E100013FE109010901112120E
+61A3:103C13E0112410A81BFE54A85124520291FC1124112411FC1124112411FC1104
+61A4:102011FC102010881BFE548851FC510491FC110411FC110411FC108811041202
+61A5:08202AA80820145022887FFC400402003FF804080850302001004884481287F2
+61A6:108812AA12DC148819545622500053FE9242144413FC10441044108411141208
+61A7:102011FC108810501BFE540051FC512491FC112411FC102011FC102013FE1000
+61A8:7C200420FF3E22443EA422283E282390FE28424402820100288828A4482407E0
+61A9:1C10702010FCFE8410FC7C8444FC44847CFC4400010008844892481287F00000
+61AA:279E2492279E2492379EAC02A4F2A492A4F2249224F224922492253224022406
+61AB:200027BC24A427BC34A4AFBCA484A444A5F4242424A4244424A4250424142408
+61AC:100013F812081BF8560853F8504097FE100013F8120813F810401248144410C0
+61AD:2040204027FC20A03514AA08A7FCAA0AA3F8220823F820402248244429442080
+61AE:2100210023FC36A8AAA8A2A8A7FCA2A822A822A82FFE200022A8225424542000
+61AF:200027BC2108252837BCAB18A5AAA946A00023F82208220823F82208220823F8
+61B0:100013FC104810301BFE545250945350902013FE1252128A1376125212721206
+61B1:221421122FD22010307EAF90A490A490A790212825A825682928214A254A2286
+61B2:01007FFC41043FF801001FF00100FFFE01003FF824483FF801004884481287F2
+61B3:100013FC100413FC180457FC500053BC912417BC100813FE1108108810A81010
+61B4:200027FC24A424A437BCA8A0A7BCA4A4A4A427BC24A424A427BC24A220A2207E
+61B5:00407C2045FC44887C5043FE7C20A5FC24203C20010008844892481287F00000
+61B6:1080104013FC1908549057FE500093FC120413FC120413FC10401524150A18FA
+61B7:2110211027BC3110ABB8A554A912A00027FC2044224022782240254028FE3000
+61B8:2040204020A03110AA08A5F6A800A7BC24A424A427BC22102210252829443082
+61B9:109013FC12941BFC569453FC500093FC120012F8120013FE1520151415481986
+61BA:110011F8120817FE1A88572453FE520092FC120012FC120012FC148414FC1884
+61BB:102017FE100013FE1A0256FA528A53FE900011FC110411FC110411FC100017FE
+61BC:2220FFA0223E20447FA481287D2845107D280A44048202005104511290120FF0
+61BD:21102FFE21103200ABFCA4A4ABA4A164225424942108204020242522250A28F8
+61BE:2014201227FE241035D0AC14A5D4A558A5CA24162442282422A2228A24782000
+61BF:2108220827C8245037DEAC64A7D4A214A11427D4221423C822482454255428A2
+61C0:204020A023182DF63000AFFCA554A4E4A7FC200023F8220823F8220823F82208
+61C1:200023FC22943294ABFCA000A7FEA00023FC220423FC20A2211423082D442182
+61C2:211027FE211023F83040AFFCA040A3F8A24823F8224823F8204027FC20402FFE
+61C3:2220FFA022203EFC08247F2449247F2408247F440854FF8801004884481287F2
+61C4:228822882FE8228833BEA90AA7CAA54AA7CA210A27CA210A27D2211221EA2E44
+61C5:1040107C104013FE1A42567853C4523C920013FE124013A4125815B4145219B0
+61C6:23F82208220833F8A800A7BCA4A4A4A427BC20402FFE21602250244838462040
+61C7:0600F8FC4A8424FC3884CCFC36A2CA9412A86AC4048202005104511290120FF0
+61C8:2200239E248A290A37D2AD66A540A7D4A55E256427C42544255E2544244428C4
+61C9:010000803FFE224824FE2D9034FC249024FC249024FE24804244524A920A21F8
+61CA:2080210027FC24443554AC44A7FCA4E4A554240420402FFE20A0211022082C06
+61CB:27882088FABE210877D86B5CA52A294825082208010008844892481287F00000
+61CC:200027FC24A427FC3040ABF8A040A7FCA11020A023F820402FFE204020402040
+61CD:20402FFE200027FC3404ADF4A514A5F4A40427FC200823F020402FFE21502E4E
+61CE:2040204027FC3248AA48A554AFFEA00027FC240425F4251425F4240427FC2404
+61CF:10A0109011FE132019FC552051FC512091FE110013DE12521252127212021206
+61D0:1040102013FE100019FC5554515451FC902013FE10501094118812A814C41082
+61D1:01104FFE211027FC80A047FC54A414A4E56426542484240C01004884481287F2
+61D2:221022102F9C22243248AFBEAAA2AAAAAFAA222A272A2AAA3288221422222242
+61D3:103C13C010441224190857FE544252A4928A147A108010F8110812901060179E
+61D4:20402FFE200037FCAC04A5F4A514A5F4240427FC200023F820002FFE224824C4
+61D5:00003FFE288C2F8A28882FBE20082F8828882F94289429A2408042408A1411F2
+61D6:080C147022105C1088FE3E1008104A7C28440E44707C22005104511290120FF0
+61D7:21102110211037BCA910A110AFFEA2A822A826EC2AAA22AA22A825A824482898
+61D8:42A827FC22AA84E6400057FC1444E3F822482258214008844892481287F00000
+61D9:1140124C126412441B4C566452A453AC92A412A417FE10001110110812041404
+61DA:203E27C02244212833F8A840A7FCA000A3F8200823F8200823F82544252A28FA
+61DB:20402FFE204027FC3000ABF8A208AFFEA80227FC211023F8204027FC20402FFE
+61DC:1088108813FE10881BFE565253FE500093FE124210F811081290106010C01700
+61DD:2400257C260434A8AB90A07CA414A7942A5022502FDC2250255024B0289E2100
+61DE:108813FE108813FE1A0255FC500053FE904010A2135410B81354109213501020
+61DF:140855083608147E7F0814487F2808283E0808080F28781021004884481287F2
+61E0:2080204027FC211030A4AF58A554A552AB582000220823F8220823F822082408
+61E1:2040202027FE248837DEAC88A5DCA6AAA4882440249025202448248425FC2884
+61E2:201027D0251027DE3450AFE8A504A7C4A00023F822A822A822A822A82FFE2000
+61E3:011047FC211081F0404017FC1664E55426EC2444244C02005104511290120FF0
+61E4:204027FC204033FCA800A7FEA002A3F8204027FE200027FE200827FE24A82798
+61E5:204027FC204027FE3402ABFCA248A3F8A24823F8200027FC22442278254028FE
+61E6:200027FC20402FFE3842AB58A040A358A0002FFE204027FC24A424A424A4240C
+61E7:2080204027FC244432A8AA94A474A000A3F822A82FFE200027FC204021402080
+61E8:20002FFE28082BC83A4CABCAAA48ABDEA8082BC82A482BD42A542BD42A5432E2
+61E9:2208211027FC3040ABF8A080A7FCA14823FC260A2BF8220823FA2234228C2302
+61EA:23F8220823F8220833F8A910A7FCA110AFFE21102248255420E02150224820C0
+61EB:1042139C12101BDE56945294542093FC120413FC120413FC120413FC11081204
+61EC:00803FFE22202FF822203FFC20802FF828882FF828882FF842205494924A23FA
+61ED:2040202027FE248835FCAC88A7FEA420A5FC252425FC252425FC240024882904
+61EE:27FC208023F83208ABF8A208AFFEA8822548251428F4210023F8250820F02F0E
+61EF:0A20FFA0493E7F4449A451240828FF2820103E284244868201004884481287F2
+61F0:220225E224A226AA352AAE6AA10AA28AA44A2BAA210A27CA2122254221EA2E04
+61F1:110817FE110810001BFC5694529453FC902813FE1220132412A81292142A18C6
+61F2:22204AA08ABE1FC420A46F24A0282FA822102FA822442F8201004884481287F2
+61F3:108813DE108819DC548853DE508893FC100411FC100413FC104012A4128A147A
+61F4:2114211227D23110A910A7FEA290A6D2229226D2229426D4228A22CA2F162022
+61F5:110817FE110813FC1A9457FC500057FE940211F8110811F8110811F8110811F8
+61F6:2108210827CE21123124AFDEA552A55EA7D2211E2392255E2940211421122122
+61F7:208020402FFE200037FCACA4A7FCA248A1502208244420A8211023082D462180
+61F8:3E0E22F03E2022443EF822103E2422FE7F1008542A92595001204884481287F2
+61F9:204027FC200023B832A8ABB8A110A7FCA11027FC21102FFE212823102D482186
+61FA:2448244C2AAA3008AFFEA288AEE8A28A2EEA228C2EEC228822EA2F1A24262042
+61FB:109413981092118E1A8055FC512451FC912411FC108811FC108813FE10881104
+61FC:27BC24A427BC24A437BCACA4A7BCA120A3FE222027FC2A2023FC222023FE2200
+61FD:21102FFE211027BC34A4AFBCA140A120A3FE222027FC2A2023FC222023FE2200
+61FE:13FC110811F8190855F8510E57F8900817FE1294139C1294139C12D617BC1084
+61FF:1020FF2010BE7C440050FE9083907CA800A47CC244207C1045542F42F14A4238
+6200:210447C88812F3BC20084B92F83E0380AAAAABAA010008844892481287F00000
+6201:2850FE4828FE399012907CFE54907C9010FE7C901090FEFE28804504249243F0
+6202:202027FE248827DE3488ADDCA6AAA488A45027DE245025DC24502BDE28503050
+6203:2248215027FC240431F0A910A7FCA554A4E427FC204027FC20402FFE22A42452
+6204:13DE125213DE12521BDE54A051FE532095FC112011FE100011FC10881070178E
+6205:1000FEF82820FEFC00007CF844887CF844887CF81088FEF81050020851249FE4
+6206:1040FEF82948FE3001CE7CF844207DFC44887CA810A8FE5011884884481287F2
+6207:1040FEF82948FE3001CE7CF844207DFC44887CF81088FEF81050028851249FE4
+6208:022002100210020002FEFF0002080208021001200140008003420C22701A0006
+6209:00900088008800807FFE408040804088408840904060484450A46114420C0404
+620A:0090008800803FFE208020802084204420482048203020222052408A43068C02
+620B:02400220022002FC7F0002000200023EFFC002100120014001840E447034000C
+620C:0050004800403FFE20402040204420443E442028202820122032404A40868102
+620D:0050004800403FFE204020402044304428442428242820122032404A40868102
+620E:004800440040FFFE00400840084408447F440828082810121032204A40860302
+620F:0020002800247E240220023E25E0142408240828142812102232404A00860102
+6210:0050004800403FFE2040204020443E4422442228222822122A32444A40868102
+6211:04400E50784808480840FFFE084008440A440C48183068220852088A2B061002
+6212:004800440040FFFE00401240124412447F441228122812122232224A40860302
+6213:004800440040FFFE0040004000443E4422442228222822123E32224A00860302
+6214:0240022002FC7F10016003841C64E01C0240022002FC7F10016003841C64E01C
+6215:042024282424242424203C3E05E00424FC242428242824102432444A84860502
+6216:004800440040FFFE004000403E442244224422283E2800120732784A20860302
+6217:0828082414241220212E40F0BE202224222422282A2824102112212A1F460082
+6218:1020102810241E241020103E11E010247E2442284228421042327E4A42860102
+6219:0028FF2481248120BD2E81F08120BD24A524A528A528BD108112812A85468282
+621A:0028002400203FFE222023A0222422243FE4202822282A903252422A4A468482
+621B:7FFC02001FF010101FF010101FF010101FF0024003F87E20014000840764381C
+621C:005000480040FFFE00403E4022443E4400447F2808283E1208320F4A78862302
+621D:00287E24422442207E2E42F042207E24422442287E2800102412222A41468182
+621E:7FFC02001FF010101FF010101FF010107FFE424283FC7E20014000840764381C
+621F:08200828FFA408247F20413E7FE041247F2449280828FF900832084A08860902
+6220:10400848FF44004442402440FFFE00407E44424442287E2A4212422A7E464282
+6221:22202228FF2422243E20223E3FE022242224FF28402854106232404A7E860102
+6222:3F28212421243F200020FFFE21203F2421243F28212827D0F912412A01460182
+6223:0A28742415245220222E21F04120BE24082408287F2808101412122A22464082
+6224:00107E14221224103F16557849125512A21200147F145508551A57AAFC460082
+6225:00207E2842247E2442207E3E09E048247F2488287E2808100F32F04A40860102
+6226:90A8492400247F20492E49F07F20492449247F2808280810FF92082A08460882
+6227:08280C241224292044AEBFF021203F2421243F2820283F105112512A9F461182
+6228:0028FF2402247A204A2E7AF00020FF2402247A284A284A107A12022A0A460482
+6229:0028FF2422245520F72E00F0FF2000247E24422842287E104212422A7E464282
+622A:082008287F240820FFFE142022247FA4A4243F2824283F1024123FAA20462082
+622B:10141012FE1011FE20103C1025D26552BD52255425D43C0824CA271A24262C42
+622C:00107F941212529033161278FFD200123F12211421143F08211A212A3F462182
+622D:10100814FF92809000167F7808127F1249127F1449147F08001A222A41468082
+622E:0010771411125510331655780C123312C492181462140C88711A062A1846E082
+622F:10281E2410247F20512E5CF072204E2440244A286AA85B104A128F2A78460082
+6230:0010F79494929490F79600787F1249127F1249147F140808FF9A082A08460882
+6231:08100F1408127F9048964E787912471240124A146A94AA88BB9A0A2A7F462082
+6232:08280F2408247F20492E4CF07920472440245F2840285F1051125F2A8A463F82
+6233:0020EE282224AA246620AA3E01E024247F24C8287E2848107E32484A7F864102
+6234:08207F280824FFFE00207F2049247F2449247F2822287F102212FFAA22464182
+6235:7728552477245520772E55F0772022247FA4A4283F2824103F12242A3FC62082
+6236:001000F81F0010001FF81008100810081FF81008100010002000200040008000
+6237:0200010001001FF810081008100810081FF81008100010001000200020004000
+6238:00007FFE000000001FF81008100810081FF81008100010002000200040008000
+6239:020001003FFC200420043FFC200020002FF0202020C0210042004404840403FC
+623A:08000400047C3F442144214421443F44217C204020402040204240424042803E
+623B:020001003FFC200420043FFC2080208020802FFC214021404220441088081006
+623C:0000FC7E0440044004407C7C4444444444447C7C044408400840104020404040
+623D:020001003FFC200420043FFC20002220212024202220207E5FA0402080200020
+623E:020001003FFC200420043FFC208020A020902FFC214021404220441088081006
+623F:020001003FFC200420043FFC210020803FFC2200220023F84408440888281010
+6240:0208071C38E0208020803E8022FE228822883E88208820884108410882080408
+6241:020001003FFC200420043FFC200020002FFC292429242FFC492449248924080C
+6242:020001003FFC200420043FFC2080208020FC208020802FF8480848088FF80808
+6243:020001003FFC200420043FFC200020002FFC280429E42924492449E488140808
+6244:020001003FFC200420043FFC210022002FFC280429E42924492449E488140808
+6245:010000803FFC20043FFC210023F02C2022C023403CFC23084C90406081801E00
+6246:020001003FFC200420043FFC210020802FFC2140224426284A10528883060200
+6247:020001003FFC200420043FFC200020003F7C2104292425144924514485140208
+6248:010000803FFC20043FFC200027F0241027F020002FF828884FF84802880207FE
+6249:010000803FFC20043FFC212021203F3E212021202F3C212041205F3E81200120
+624A:010000803FFC20043FFC24882490296022182C84348A2488495042208C183006
+624B:001000F83F00010001003FF8010001000100FFFE010001000100010005000200
+624C:1000100010001000F8001000140018003000D000100010001000100050002000
+624D:0080008000800080FFFE01800280028004800480088010802080408002800100
+624E:1080108010801080FE801080108012801C803080D080108410841084507C2000
+624F:1080108010801080FDF010901090149018903090D090109211121112520E2400
+6250:1040104010401040FDFC10441044144418443084D08410841104110452282410
+6251:1080108010801080FE8010A0109012881C843084D08010801080108050802080
+6252:1000102011201120FD2011201120152019203110D21012101208140854042802
+6253:1000100013FE1020FC2010201020142018203020D02010201020102050A02040
+6254:1000100013F81088FC90109010A014BC18843084D10411041104120452282410
+6255:1040104010401040FC4010801080148019003110D108120817FC120450042000
+6256:1200110010801080FC401040104014A018A030A0D11011101208120854042802
+6257:1020102010201020FC20102011FC142018203020D02010201020102053FE2000
+6258:1008103C13C01040FC4010401040147E1BC03040D040104210421042503E2000
+6259:1010101010101010FDFE10101010151019103090D09010501020105051882606
+625A:10401040108010FCFD0412041004150418843044D04410041004100450282010
+625B:1000100011FC1020FE201020102012201C203020D02010201020102053FE2000
+625C:100011FC10201020FC20102014201BFE3020D020102010201020102050A02040
+625D:100011FC10001000FC0013FE10401440188030FCD00410041004100450282010
+625E:100011FC10201020FC20102014201BFE3020D020102010201020102050202020
+625F:100013F010901090FC901090109013F018903090D0901092108A108A50862082
+6260:100017F812081288FE4811501110151018A030A0D040104010A0111052082C06
+6261:1020102010201120FD2C1134116417A419243134D12811221122110250FE2000
+6262:10401040108010FEFD00120010FC140818103020D04010801102110250FE2000
+6263:1000100011FC1104FD0411041104150419043104D1041104110411FC51042000
+6264:1000100013FC1090FC9010901090149018903090D090109211121112520E2400
+6265:102010201020103CFDE0102010201420183E33E0D020102210221022501E2000
+6266:1008103C11E01020FC201020102017FE18203020D02010201020102050202020
+6267:1040104010401040FDF8104810481448194830C8D04810A810AA110A52062402
+6268:1000100011FC1044FC4411441144154419443244D04410841084110452282410
+6269:10201010101011FEFD0011001100150019003100D10011001100120052002400
+626A:1100108010BC1204FA04120416041A043204D204120412041204120452142208
+626B:1000100013FC1004FC041004100415FC18043004D0041004100413FC50042000
+626C:100011F810101020FC40108011FE149218923092D11211221222144250942108
+626D:100011FC10441044FC441044104415FC18843084D08410841084108457FE2000
+626E:1010109010901088FD081104120415FA18883088D08810881108110852282410
+626F:1020102010201120FD201120113C152019203120D12011201120112057FE2000
+6270:1040105010481048FC4011FE1050145018503050D090109010921112510E2200
+6271:100013FC10841088FC881090109C148419443144D12811281210122854442182
+6272:1040104010A010A0FD10128814461040180033F8D00810101010102050202040
+6273:1008101C11E01100FD0011FC1144154419443128D12811101110122852442482
+6274:1020102010501050FC8811041202108818883088D08810881088110851082208
+6275:1020102010201050FC50108815041A023060D010100010C01020101050082000
+6276:1020102010201020FDFC1020102014201BFE3020D05010501088108851042202
+6277:1008103C11E01020FC20102013FE142018203050D05010501088108851042202
+6278:1010111011101110FD1011FE11001500190031F8D10811081108120852082408
+6279:1010111011101112FD12111411D8151019103110D110111211521192510E2000
+627A:1008103C13E01220FE201220122017FE1A203210D2101212120A128A53062202
+627B:10801080108010FCFD04110812401440184030A0D0A010901110110852042402
+627C:200023FE22002200FAF8228822882A883288E2A82290228224822482A87E5000
+627D:10201020102013FEFC20112411241524192431FCD024102010221022501E2000
+627E:1090108810881080FCBC13C01080148818883090D060104410A41114520C2004
+627F:1FE000400080010479280FF00920111017D0210821084FE48102010005000200
+6280:10201020102013FEFC201020102015FC18843088D04810501020105051882606
+6281:1040104010801088FD0413FE1002149018903090D090109011121112520E2400
+6282:1000100013FE1020FC2010201020142019FC3020D02010201020102057FE2000
+6283:1040102010201000FDFE10401040146018503048D04410441040104050402040
+6284:10201020102010A8FCA410A2112215201A243024D02810081010102050C02300
+6285:10801080108010FEFD0212421042148218A23112D3FA110A1002100250142008
+6286:10401020102013FEFC8810881088148818883050D05010201050108851042602
+6287:1000100011FE1102FD021102110215FA19023102D1021102110211FE51022000
+6288:100011FC11041104FD0411FC11041504190431FCD10411041204120454142808
+6289:10401040104013F8F84810481448184837FED04010A010A01110111052082406
+628A:100011FC11241124FD241124112415FC19043100D10011001102110250FE2000
+628B:1000104010201010FC901080108012841A823282D28214881088108850782000
+628C:10201020102011FEFD2212241020142018503050D0501050109010925112220E
+628D:1008106813881088FC88108814881BFE3088D088108810881108110852082408
+628E:1000100011FC1000FC00100013FE142018203040D0401088110413FE51022000
+628F:1000100011FC1000FC00100013FE109018903090D090109011121112520E2400
+6290:1020102010201020FDFE1122112215221952314AD18A110211021102510A2104
+6291:10001080133C1224FE241224122416241A243224D2B413281220102050202020
+6292:100011F810081050FC20101013FE142218243020D02010201020102050A02040
+6293:1008101C11F01150FD5011501150155019503148D14811481144124452422400
+6294:1000100013FE1020FC201040104014D019483244D44410401040104050402040
+6295:100010F810881088FC881106120015FC18843084D04810501020105050882306
+6296:1010111010901090FC101110109014901810301ED3F010101010101050102010
+6297:10801040104013FCFC00100011F0151019103110D110111211121212520E2400
+6298:1008101C11E01100FD00110011FE151019103110D11011101110121052102410
+6299:1008103C11E01020FC2011FC10201420182033FED02010201020102050A02040
+629A:100013FC10401040FC40104017FE104018A030A0D0A0112011221222541E2800
+629B:121012101210127CFA14179412941A9432A4D2A412D4128A14821482587E3000
+629C:1040104010401040FBFE1080148018FC3144D144114812501220145058882306
+629D:20802080213E2102FA42224227C228823082E1022142222227E22222A00A4004
+629E:100011FC11041104FD04110411FC152419203120D11011101208120854042802
+629F:10201020102011FCFC20104011FE1440188031FCD00410881050102050102010
+62A0:100011FE11001104FD4411281128151019103128D12811441184110051FE2000
+62A1:1040104010A010A0FD1012081406111019203140D18011001104110450FC2000
+62A2:1040104010A010A0FD101208140611F019103110D15011201104110450FC2000
+62A3:10401040108010FCFD0412041084144418443014D02410441184100450282010
+62A4:10401020102011FEFD021102110215FE19023100D10011001200120054002800
+62A5:100011FC11041104FD141108110015FC19443144D12811281110112851442182
+62A6:100013FE10201020FC2013FE122216221A52324AD28A130212021202520A2204
+62A7:1000100011FC1104FD0411041104150419FC3104D00010901088110452022402
+62A8:100011FC10201020FD2410A410A814201BFE3020D02010201020102050202020
+62A9:10201020102011FCFD24112411FC152419243124D7FE11041104110451142108
+62AA:10401040104013FEFC8010A0152019FC3324D524112411241134112850202020
+62AB:10101010101011FEFD121114111015FC19443144D12811281110122852442482
+62AC:1020102010401088FD0413FE1002140019FC3104D10411041104110451FC2104
+62AD:10401020102013FEFA021404100018F03090D0901090109011121112520E2400
+62AE:1040104010A01110FA081426104018803310D020104010881310102050C02700
+62AF:100011F811081108FD0811F811081508190831F8D10811081108110857FE2000
+62B0:10201020102011FCFD24112411241524192433FED02010501050108851042202
+62B1:1080108011FC1104FA0415F4111419143114D1F4110411281112110250FE2000
+62B2:1000100017FE1008FC0813C8124816481A483248D3C812481008100850282010
+62B3:100011FC11041104FD0411FC1100154019443148D170114011421242523E2400
+62B4:2048224822482248FA4827FE22482A483248E2482278220022002200A3FE4000
+62B5:1008103C13E01220FE201220122013FE1A203210D2101212120A128A53262212
+62B6:1020102011201120FDFC1120122010201BFE3020D05010501088108851042202
+62B7:100013FC10201020FC40104014D019483244D444104010401040100057FE2000
+62B8:1008103C13C01000FC40102013FC140818103020D040108011001280547E2000
+62B9:10201020102013FEFC201020102015FC187030A8D0A811241124122250202020
+62BA:10201020102011FCFC201020102013FE187030A8D0A811241124122250202020
+62BB:10201020102013FEFA22122216221BFE3222D222122213FE1222102050202020
+62BC:100011FC11241124FD2411FC11241524192431FCD12410201020102050202020
+62BD:1020102010201020FDFC112411241524192431FCD12411241124112451FC2104
+62BE:1020102010201020FDFE1020102014201BFE3020D04010401088110453FE2102
+62BF:100013FC12041204FE0413FC122016201BFE3220D22012101212128A53062202
+62C0:100011FC11041104FD04110411FC145018503050D050109210921112520E2400
+62C1:220022002200221EF7D22252225222523252E252225222522452245EA9525080
+62C2:10901090109013FCFC94109413FC16901A9033FED0921092111A111452102410
+62C3:10801080108010FEFD4011401240107C18403040D040107E1040104050402040
+62C4:10401020100013FEFC2010201020142019FC3020D02010201020102053FE2000
+62C5:1000100011FC1104FD04110411FC150419043104D1FC11041000100053FE2000
+62C6:1008101C11E01100FD00110011FE151019103130D11811141112121052102410
+62C7:100011F811081148FD281108110817FE1A083288D248120813FE100850502020
+62C8:104010401040107EFC4010401440184033FCD204120412041204120453FC2204
+62C9:1040102010201000FBFE1000140419043104D088108810881090101057FE2000
+62CA:1088108810881108FD7E13081508114819283128D10811081108110851282110
+62CB:221022102210227CFA1427D422942A9432A4E2A422D4228A24822482A87E5000
+62CC:10201020112410A4FCA8102011FC142018203020D3FE10201020102050202020
+62CD:10201020104011FCFD0411041104150419FC3104D10411041104110451FC2104
+62CE:1040104010A010A0FD101248142610201BF83008D010111010A0104050202020
+62CF:10001000FEFC2244642818102428C2C600201FC001003FF801007FFC01000300
+62D0:100011FC11041104FD0411FC104014401BFC3044D04410841084110452282410
+62D1:1088108810881088FDFE108810881488188830F8D08810881088108850F82088
+62D2:100011FE11001100FD0011FC1104150419043104D1FC11001100110051FE2000
+62D3:1000100013FE1020FC201040104014FC19843284D48410841084108450FC2084
+62D4:1050104810481040FBFE1080148018FC3144D144112811281210122854442182
+62D5:10201010101011FEFD02120410801488189030A0D0C0108210821082507E2000
+62D6:1080108010FE1100FE201120112C15741BA43124D13411281122110250FE2000
+62D7:2020212021202220FAFC24A4272429243224E22424A427A420C42044A0944108
+62D8:10801080110011FCFA04140411E419243124D12411E411241004100450282010
+62D9:1020102011241124FD24112415FC18243020D020122212221222122253FE2002
+62DA:1020102010401088FD0413FE10021488188833FED08810881108110852082408
+62DB:100013FC10841084FC841104111412081C0031FCD10411041104110451FC2104
+62DC:04001EFCF020102010FCFE20102010FC1020FE2011FE10202020202040208020
+62DD:100013FE10201020FDFC1020102015FC18203020D3FE10201020102050202020
+62DE:1008101C11E01100FD001100110015FE19103110D11011101110111057FE2000
+62DF:1008108810481228FA28120812081A083208D208121012981324122450422082
+62E0:220022382228FBA822A822A834A826AAEAAA22AA2126214022802260A41E4800
+62E1:10201010101011FEFD0011101110151019103120D1281124124412FE54422800
+62E2:1090108810881080FBFE10A014A018A430A4D1281128113212221262549E2800
+62E3:1040104017FC1080FC8013E0112012201BFC3020D12811241222142250A02040
+62E4:104010401040107CFC40104014401BFE3040D040105010481044104050402040
+62E5:200027FC24442444FC4427FC24442C443444E7FC2444244424442844A8545008
+62E6:1000110810881090FC0013FE10001400180031FCD00010001000100053FE2000
+62E7:10401020102013FEFA0214041000180033FED020102010201020102050A02040
+62E8:1040104812441240FBFE1080148018FC3144D144114812501220145058882306
+62E9:200027F822082110F0A0204021B0264E3040E3F82040204027FC2040A0404040
+62EA:100017FE10901090FC9013FC129416941A943294D29C13041204120453FC2204
+62EB:100011F811081108FDF81108110815F819443148D13011201110114851862100
+62EC:1008103C11E01020FC2013FE10201420182031FCD10411041104110451FC2104
+62ED:1028102410241020FBFE102014201BA03120D1101110111011CA170A52062002
+62EE:10201020102013FEFC20102011FC1400180031FCD10411041104110451FC2104
+62EF:100011FC10081010FC2213B210B414A819283124D22214A01040100057FE2000
+62F0:10801088109C1170FD1013101510111019FE3110D110111011101110517C2100
+62F1:1088108810881088FDFE108810881488188833FED00010881084110452022402
+62F2:044004407FFC0440FFFE08203018C0E61F0001003FF801007FFC010005000200
+62F3:0100111009203FF802007FFC082010F03F08C1061FE001003FF8010005000200
+62F4:1020102010501088FD04120211FC142018203020D1FC10201020102053FE2000
+62F5:10401040104013FEFC801080117815081B103510D1FE11101110111051502120
+62F6:1124112412481124FD241000108014FC19043184D24814281010102050C02300
+62F7:1040104411F41048FC5013FE1040148019FE3240D48010FC1004100450282010
+62F8:1040104010FC1108FA90106014481990363ED042108413481030102050C02700
+62F9:1040104011FC1044FC84108415281A103108D3DE114A114A114A1252535A24A4
+62FA:1020102013FE1020FC2011FC112415241924312CD07010A81124162250202020
+62FB:10401040104013FEFC8010901090151219523154D29012281428104450842102
+62FC:1104108410881000FDFE108810881488188833FED08810881108110852082408
+62FD:1020102011FC1124FD2411FC1124152419FC3020D0241018103210CA53062002
+62FE:1020102010501088FD04120211FC1400180031FCD10411041104110451FC2104
+62FF:010006C01830EFEE00001FF010101FF000201FC001003FF801007FFC01000300
+6300:1004101E11E01100FD0611781150155019523154D14811481144125452622440
+6301:10201020102011FCFC20102013FE1008180833FED00810881048100850282010
+6302:1020102011FC1020FC20102013FE100018203020D1FC10201020102053FE2000
+6303:100011FE10201040FC88110411FE142218203020D1FE10201020102053FE2000
+6304:1040104412441148FD50104017FE109018903090D090109211121112520E2400
+6305:100013F810881090FCBC110415141A483040D7FE104010E01150124854462040
+6306:100011F011101110FD101110124E14401BFC3040D0E011501248144650402040
+6307:11001104113811C0FD02110210FE140019FC3104D10411FC1104110451FC2104
+6308:08007F7C08243E2408247F44085408F83F0001003FF801007FFC010005000200
+6309:10401020102013FEFA02144410401BFE3088D088110810D01020105050882304
+630A:10401040107C1040FC4013FE100010001BFE3040D05010481044104050402040
+630B:100013FE12201220FE2013FC120416041A043204D3FC12201220122053FE2000
+630C:1080108011F81208FD1010A0144018A03318DC0613F812081208120853F82208
+630D:10401020102013FEFC0010881104120218883088D05010501020105050882306
+630E:2040204027FC20A0F11022082DF6200037FCE080210023F820082008A0504020
+630F:100011FE11021102FD7A11021102157A194A314AD14A117A11021102510A2104
+6310:10001000FE7C224442443444087C3400C2201FC001003FF801007FFC01000300
+6311:1090109010901292FD941098109015981A943492D0901090111211125212240E
+6312:200220022FC22212FA1223D222522C523652E5522892209221022202A40A4804
+6313:10401020102013FEFA02140410381BC03040D040107E17C0104010425042203E
+6314:10401020102013FEFC40104010A014A219A43298D4901088108410A250C02080
+6315:100013FE11081108FD0811F81108150819F83108D108111E17E8100850082008
+6316:1040102013FE1202FC881104120214F818103020D04010801102110250FE2000
+6317:1020102013FE1020FDFC102411FC152019FE3022D02A10541050108851042202
+6318:1020102011241122FA2A101014601B803040D04013FC10441084108451142208
+6319:2208110811100020FFFE0820101020E8DF0601003FF801007FFC010005000200
+631A:1080FBF010901990F0941154520C24E41F0001003FF801007FFC010005000200
+631B:02000100FFFE044014502448444400F03F0001003FF801007FFC010005000200
+631C:100013FC10901090FC901092149212941A943298D09010901090109057FE2000
+631D:2408220822082008F8FE2E0822482A283228E2082208222822102500A8FE4000
+631E:1010121011101110FCFE10101310152819243144D142118211001280547E2000
+631F:10201020102011FCFC20112410A414A8182033FED05010501088108851042202
+6320:1080108010BC13C0FC50102410D4130C180033FED090109011121112520E2400
+6321:1040124411441144FD48104017FC100418043004D3FC10041004100457FC2004
+6322:2010207823C02040F84027FE20A029103208E5162110211021102210A2104410
+6323:1080108011F01210F82013FC1044184437FED044104413FC1044104051402080
+6324:1080104017FE1208FD1010A0144019B0360ED110111011101110121052102410
+6325:100013FE12021444FC4013FC108014A0192031FCD020102017FE102050202020
+6326:100013FC10041004FDFC1004100417FC18083008D7FE11081088108850282010
+6327:100013DE10421042FA52114A154A184230C6D14A1252104210421042514A2084
+6328:2040208021102208F7FC2104210023F83440E0402FFE204020A02110A2084C06
+6329:1010109010881108FA0415FA110819083108D1F810901090109011125212240E
+632A:100017DE12521252FA5417D412581A543252DFD21252125A1254145055502890
+632B:2040204022482248F248255428E220403040E7FC2040204020402040AFFE4000
+632C:1020102013FE1020FC2013FE1202140419F83010D02013FE1020102050A02040
+632D:100013FE10201020FDFC1124112415FC19243124D1FC112010A0104050B0230E
+632E:11081088109013FCFC24102413FC16201A2033FED06210A2112A122454202020
+632F:100013FC12001200FEF81200120017FC1AA032A4D2A812901290148854A428C2
+6330:100011FC11041104FD0411FC100014001BFE3020D02011FC1020102053FE2000
+6331:1010121011101110FC5412521252109018103114D604120812081210522020C0
+6332:204012484444201408607380200000F03F0001003FF801007FFC010005000200
+6333:100011FE10001092FD24124811241492180031FED02010201020102053FE2000
+6334:1100110011FC1200FDF81108114815281BFE3108D248122813FC100850502020
+6335:100013FE10201020FDFC102014201BFE3088D08813FE10881088110851082208
+6336:100011FC11041104FDFC1100110015FE1902317AD14A114A127A120254142008
+6337:2100211E211227D2F914211427D829143112E7D22112211A21142210A2104410
+6338:100011FC11041104FDFC1104150419FC3104D10411FC1050105010925112220E
+6339:100011F811081108FDF8100013FC12441A443244D3FC12001202120251FE2000
+633A:2000200C27702110F9102210227C2F103110E5102510227C22002500A8FE5000
+633B:1004100E13B81088FC881128152E1BA830A8D2A812A8113E11001280547E2800
+633C:1008103C13C01044FA2411281500184033FED088110813901060105051882604
+633D:1080108011F81208FC1013FC124416441A4433FCD0A010A011221122521E2400
+633E:10201020102013FEFC20102011241524192432AAD02010501050108851042202
+633F:101C11E010201020FDFE102011FC1524192431FCD124112411FC102050202020
+6340:110011F813081490FC601198164610401BF83040D3F8104017FC104050402040
+6341:10201120112011FCFD201220102013FE18003000D1FC11041104110451FC2104
+6342:100013FE10401040FDFC1084108417FE18003000D1FC11041104110451FC2104
+6343:100011FC10441044FBFE1044144419FC3080D08011FC12841484108450FC2084
+6344:1028102410241020FDFE1020112014B218B43068D0A811241222102050A02040
+6345:200027F8201021A0F84027FC24442C4437FCE444244427FC24442444A4544408
+6346:200027FC24442444FC4427FC24442CC434E4E5542644244424442404A7FC4404
+6347:10201020102011FCFC20102013FE145018503154D15211521252109050902130
+6348:1020102010501088FD0412FA102014201BFE3020D12811241222142250A02040
+6349:100011FC11041104FD0411FC102014201920313CD120112012A01260543E2800
+634A:1008103C13C01004FA44112810001BF83010D02017FE10201020102050A02040
+634B:1008103C13C01044FA2411281500181033FED010111010901090101050502020
+634C:200427C424442454FC5427D422142A1437D4E2542254225424442444A9545088
+634D:100011FC110411FCFD0411FC1000140019FC3020D02013FE1020102050202020
+634E:1020112410A410A8FC2011FC1104150419FC3104D10411FC1104110451142108
+634F:100011FC11041104FDFC1104110415FC18203020D1FC10201020102053FE2000
+6350:100011F811081108FDF8100013FC16041A0433FCD204120413FC120452142208
+6351:100010FC10841284FEFC1284128416FC1A0033E0D02013FE1020105050882306
+6352:1020102013FE1020FC2011FC1124152419FC3020D07010A81124122250202020
+6353:200027DE20922492F494249427D820943192E1922292229A24942890A2904110
+6354:1080108011FC1104FA0815FE1122192231FED122112211FE11221222522A2404
+6355:1048104417FE1040FC4013FC124416441BFC3244D24413FC1244124452542208
+6356:1040102013FE1202FC0411F8100014001BFE3090D090109011121112520E2400
+6357:101010101090109EFC90109013FE140018103092D09211141208101050602380
+6358:1040104010881104FBFE1002148819443242D0F8118812501020105051882606
+6359:1020102013FE1020FDFC1124112415FC19243124D1FC102013FE102050202020
+635A:100011FC11241124FDFC1124112415FC18203020D1FC10201020102053FE2000
+635B:100011F811081108FD08110811F81400180033FCD20412041204120453FC2204
+635C:1020102011FC1124FD2411FC1124152419FC3020D3FC10881050102050D82306
+635D:1104108410881010FDFC11041104150419FC3050D050109010921112520E2400
+635E:1088108813FE1088FC0013FE12021444184033FCD04410841084110452282410
+635F:100010F810881088FCF8100011FC150419243124D12411241050104850842304
+6360:1008101C11E01100FD0011FE1110151019103110D7FE10001090110852042402
+6361:1040104010A010A0FD10120815F6100018883048D24811501110102057FE2000
+6362:1080108010F81108FA1015FC112419243124D12417FE10501050108851042602
+6363:2040208023F82208FA88224822182A0033FEE0822492249227F22002A0144008
+6364:200023FC22042204FBFC220022182AE03238E2E0223C23E022222422A41E4800
+6365:1040102013FE1202FD04110011DE12521A523352D49A1094111011125212240E
+6366:1020102010501088FD04120210F81420182031FCD020112410A410A853FE2000
+6367:1020102013FE1020FDFC104013FE148819243222D0F8102013FE102050202020
+6368:1020102010501088FD0412FA102014201BFE3020D02011FC1104110451FC2104
+6369:1040102013FC1204FA0413FC16001A283224D3FE122012501250148855042A02
+636A:101C13E0122013FEFE201292130A120619FC3104D10411FC1104110451FC2104
+636B:200027BC24A424A4FFBC24A424A42FBC3404E4042404240424042404A4144408
+636C:2040202027FE2400FC88248825082D7E3708E5482528252829082908B1284110
+636D:1040108013FC1224FA2413FC16241A4433FCD090111017FE1010101050102010
+636E:11FE11021102FF0211FE1310151019FF1110311051FE928212821482548228FE
+636F:200420042FC42214FA14249427D429143114E7D42114211421C42E04A4144008
+6370:100011FC11241124FDFC1124112415FC182033FED07010A81124122250202020
+6371:100013FE12101210FEFE1210121017FE1A003210D21012FE1210141055FE2800
+6372:1020112410A813FEFC40108017FE11081A0435FAD908110811281112510220FE
+6373:1008101C11E01100FDFE11101510191037FED000102012221222122253FE2002
+6374:2090209021082148FA44249221082BFC3044E02020A42282228A228AA4784000
+6375:10901090109013FCFE941294129417FC1A943294D29417FE1000109051082204
+6376:1010107813C01040F84017FC12481A4837FED248124817FC1040104057FC2000
+6377:2040204027FE2040FBF8204827FE284833F8E0402240227C22402540A4FE4800
+6378:1020102011FC1024FC2413FE1024142419FC3222D17410A81124122250A02040
+6379:1020102013FE1050FCA8112412FA142018A83088D3FE10881088108851082208
+637A:1020102013FE1050FC88110412FA1000180033FED02011241122122250A02040
+637B:1020102010501088FD44122211F8140818503020D0A41282128A128A54782000
+637C:101C11E010201020FBFE10A815241A423040D3FE1088110810D0103050482184
+637D:1040102013FE1000FC88108815541A223000D02013FE10201020102050202020
+637E:1040102013FE1202FC0411F81108150819F83100D10011FC1104110451FC2104
+637F:1020102013FE1020FDFC102413FE142419FC3040D3FE108411C8103050CC2302
+6380:201020902710243EF4222444279025103510E5102528252825282944A9445082
+6381:100010FC108010F8FC8010F8108017FE19403124D12811101108114451822100
+6382:1040102013FE1200FE201220123E12201A2032FCD28412841284148454FC2884
+6383:100011FC100410FCFC0411FC100013FE1A223020D1FC11241124113451282020
+6384:2040204020A02110F2082DF6200027FC34A4E4A427FC24A424A424A4A4144408
+6385:1020102013FE1020FDFC102013FE140019FC3104D1FC110411FC110451142108
+6386:100013FE1202128AFE5213FE122216221AAA32AAD2AA12FA12021202520A2204
+6387:200027BC20842294F908229424A428403000E7BC20A422A421282290A4A84846
+6388:101C13E010841244FD48111017FE1402180033F8D108111010A0104051B0260E
+6389:10201020103E1020FDFC110415FC190431FCD124102013FE1020102050202020
+638A:1040102011FC1000FD081090100013FE18003000D1FC11041104110451FC2104
+638B:1040102013FE1200FE1C12F0129016901AFE3290D290129012AA12CA54A62812
+638C:111009203FFC20044FE808200FE000F03F0001003FF801007FFC010005000200
+638D:100011FC11041104FDFC1104110415FC18003112D1D41118111011525192210E
+638E:1040104013FC10A0FD10120817FE10081BC83248D248124813C8100850282010
+638F:1080108010FE1102FE8210F2114214421BFA3042D152115211F2100250142008
+6390:10401040107C1084FD081200102015CE19023102D1CE11021102110251FE2102
+6391:1088108813FE1088FC8810F81088148818F83088D08813FE1000108851042202
+6392:109010901090179EF890109010901B9C3090D0901090179E1090109050902090
+6393:2100210021DC2114F914211427D428143114E1142588254829482114A5144222
+6394:00007EFC48447E4442287E1048287EC600201FC001003FF801007FFC01000300
+6395:1020102011FC1020FC2013FE108815441A4230F8D18812501020105051882606
+6396:1080104017FE1120FD20123C124416641A943348D24812301220125052882306
+6397:100017FE10901090FC90139C120416041A04339CD09010901090109057FE2000
+6398:200027FC24042404F7FC2420252425243524E5FC2420252425242924A9FC5004
+6399:103C17C012441128FC0013F81448184837FED048104813F81048104051402080
+639A:100013FE10201020FBFE122212221B3232AAD2AA1376126612221222522A2204
+639B:1088108813E81088FC88108817EC140A188A3088D3E81088108810E853882108
+639C:10001040139C1204FE04139C120416041BFC3090D0901090109011125212240E
+639D:10141012101017FEF810101017D21A523252D25413D4100810EA171A52262042
+639E:1020112211221224FC5010881304142218203124D12412281050108851042602
+639F:1040102013FE1202FC04100013FE142018203120D13C112012A01260543E2800
+63A0:1040102013FE1000FC0011FC1104150419FC3020D12811241222142250A02040
+63A1:1008103C13C01044FA2411281500182033FED07010A810A81124122254202020
+63A2:200027FC240424A4F91022082040284037FCE04020E0215022482C46A0404040
+63A3:24043FA44424FFA404243F842494258800201FC001003FF801007FFC01000300
+63A4:100013DE12521252FA5213DE12521A523252D3DE1252125212521252555228A6
+63A5:1080104013FC1000FD08109017FE1040184037FED08811081090106051982604
+63A6:100011FC110411FCFD0411FC1080148019FE324AD44A10921122124250942108
+63A7:10401020102013FEFA02149411081A043000D1FC102010201020102057FE2000
+63A8:10A01090108011FEFD10131015FC1110191031FCD1101110111011FE51002100
+63A9:1040108017FE1110FE48144613F816481A4833F8D248124813F810425042203E
+63AA:10881088108813FEF888108817FE180031FCD104110411FC1104110451FC2104
+63AB:20002FC024BC24A4F4A427A424A424A837A8E4A8249025D02EA820A8A0C44082
+63AC:1100110011FC1204FC44115414E4184433FCD04410E411541244104450142008
+63AD:200023FC20402040FBFE20A021102A083446E0402048226422522452A1404080
+63AE:1040102013FC1204FE0413FC120012FC1A8432FCD28412FC1484148458942088
+63AF:10201120113C1120F92017FE10001BFC3204D3FC120413FC1204120452142208
+63B0:10003A86E2B824882448F85E202827882288FABE2288248824882A8851288010
+63B1:00F03F0001003FF801007FFC010005047A7810107CFC1010FEFE101050502020
+63B2:100011FC110411FCFD0411FC108015FE1A023112D1EA110A10FA100250142008
+63B3:2040207C204023FEFA42227823C42A3C3240E24023FC224424842484A9144208
+63B4:200023FE22022202FBFE222222222AFA3222E232222A23FE22022202A3FE4202
+63B5:1020102010501088FD0412FA100017DE1A523252D25213DA1254101050102010
+63B6:1040102013FE1220FEFC1224122417FE1A243224D2FC12201250145054882906
+63B7:2440225E22922012FFD421142118291437F2E1122112211A22942250A4504810
+63B8:11041088105011FCFD24112411FC1524192431FCD020102013FE102050202020
+63B9:100011FC10081010F82013FE142018A03040D1FC115411541154115457FE2000
+63BA:10801090110813FCFC4017FE111012481C863310D02010C41308103050C02700
+63BB:100011FC10841088FC50102014D81B263020D1FC1124112411FC102253FE2002
+63BC:11FC1124112413FEFD24112411FC140019FC3104D12411241124105850842302
+63BD:11081090100013FCFC901090109214921A943298D09010901090109057FE2000
+63BE:210021F8220823F0F81027FE208029443668E0B02128266820A42122A6A04040
+63BF:1088108813FE1088FCA8102013FE1440188030FCD18412841084108450FC2084
+63C0:1020102013FE1020FDFC112411AC1574192431FCD020107010A8112452222020
+63C1:10201020103E1020FC2011FC110415FC190431FCD10411FC1000108851042202
+63C2:21082088209027FEF890209023FC2A943294E30C220423FC22042204A3FC4204
+63C3:11081088109017FEF80013C412541A5433D4D254125413D412541244525422C8
+63C4:204020A021102208FDF6200023C42A543254E3D42254225423D42244A25442C8
+63C5:FDFE204840487DFEC44844887D0800E81F0001003FF801007FFC010005000200
+63C6:101013D410581252FD8C1088110412FA18203020D3FE10201050108851042202
+63C7:1020102013FE1020FC2013FE128A16521AFA3222D22212FA12221222522A2204
+63C8:1100110011FE1202FC8217F2100213F2180233F2D00213F2121213F250142008
+63C9:200021FC20482030FBFE2052209429103230E02023FE207020A82124A6224020
+63CA:100013FE100011FCFD04110411FC14001BFE3222D22213FE1222122253FE2202
+63CB:100011FC11241124FDFC1124112415FC180033FED12011221114114851842102
+63CC:100011FC11241124FDFC1124152419FC3000D040102412A2128A148850782000
+63CD:2040204027FC2040FBF8208027FC29103208E5F6204023F8204020A0A1104608
+63CE:1040102013FE1202FC0411FC140019FC3104D1FC110411FC1104100053FE2000
+63CF:1088108813FE1088FC88100011FC152419243124D1FC11241124112451FC2104
+63D0:100011FC11041104FDFC1104110415FC180033FED0201120113C112052A0247E
+63D1:1040119C11041104FDDC1104110415FC18003000D1FC10201020102053FE2000
+63D2:2008203C27C02040F8402FFE20402940365CE4442444275C24442444A7FC4404
+63D3:22102110211027BEFA28224823AA2AAE32BAE2EA22AE22A824AA24A2A9A2501E
+63D4:1080108010FC1154FAD410B4152C1A443094D108104010A412AA128A54782000
+63D5:1088108813FE1088FCF8108810F81488188833FED10011481184110051FE2000
+63D6:100011F811081108FDF8100017FE150819F83108D1F81108113E17C850082008
+63D7:101C13E012201220FBFE122012FC1A843284D2FC128412FC1484148458FC2084
+63D8:1020104011FC1104FDFC110411FC14001BFE3020D02011FC1020102053FE2000
+63D9:1040102013FE1202FE0213FE120016001BFE3352D55215FE1552155259522106
+63DA:100011F8110811F8FD0811F814001BFE3100D1FC125414941124124450A82110
+63DB:1080108011F81208FC1013FE12021A52328AD222102017FE1050108851042602
+63DC:1020105010881104FEFA100015FC19043104D1FC1088108813FE108851082208
+63DD:1088108811EC112AFA2815481088197E3600D1FC1104110411FC1104510421FC
+63DE:1040102013FE1000FD04108817FE100019FC3104D10411FC1104110451FC2104
+63DF:100013FE10221120FD3C112012FE140019FC3104D1FC110411FC110451142108
+63E0:100013FE120012FCFA8412FC16841AFC3220D3FE124812C812301248528423FE
+63E1:200023FC22042204FBFC220023FC2A403288E3FC2224222025FC2420A82053FE
+63E2:1040102013FE1202FC8010F815081A903060D198160611F81108110851F82108
+63E3:2040244424442444F7FC20002FFE20403080E7FC24A424A424A424A4A4A4440C
+63E4:100013DE12521252FA5213D212521A523252D3D2121A1294125012B053102010
+63E5:1080104013FC1000FD08109017FE1442184433FCD24412441254124850402040
+63E6:1082108217F21082FC8A13EA16AA1AAA33EAD08A11CA12AA14A21082508A2084
+63E7:04047FC404243FA424A43FA41504249444281FC001003FF801007FFC01000300
+63E8:1040102013FE1000FDFC110411FC14001BFE3202D1FC10201020102050A02040
+63E9:1110111211D41118FD521192112E144019FC3104D10411FC1104110451FC2104
+63EA:208821C827082108F92A212A27AC29483308E3882554251429142124A1244142
+63EB:0620382008A47EA819202C504A8809E41F0001003FF801007FFC010005000200
+63EC:1040102013FE1202FC88110412221028182433FED02010501050108851042202
+63ED:100013F8120813F8FE0813F8110013FC1C443244D2A4120413F4100450282010
+63EE:100013FE12221020FDFE102011FC152419FC3124D1FC102013FE102050202020
+63EF:220022FE22202220FB2022BC26442A54324CE28422A4221822082208A2FE4200
+63F0:1008103C11E01020FBFE102015FC192431FCD12411FC102011FC102053FE2000
+63F1:49042A247F2441247F2441247F244104432C1FC001003FF801007FFC01000300
+63F2:10481148114813FEFD4811481178150019FE3020D3FE107010A8112456222020
+63F3:1080109E13EA108AFDCA108A13EA149218A63020D3FE10201050108851042602
+63F4:203C27C022442128F80023FC2080288037FEE10021F8228822502420A8D84306
+63F5:20102010277C2114F9FE2214227C2F10317CE51025FE221022102500A8FE4000
+63F6:20002FDE24922492F4942794249824943792E492249225DA2E942090A0904090
+63F7:101C11E010201020FDFE10A0112C1524192431ACD124112411FC112450202020
+63F8:1020102013FE1070FCA81124122211FC190431FCD10411FC1104100057FE2000
+63F9:1050105213DC1050FCD2134E100015FC190431FCD10411FC1104110451142108
+63FA:1008103C13C01004FA44112815FC18203020D3FE102011241124112451FC2004
+63FB:2014201227FE2410FC1027F024922C9237D2E55425542488254A2A1AA8265042
+63FC:100013FE10401080FDFC1284108414FC18203022D3B410A81128122454A22040
+63FD:10901290129E12A8FAC4108015FC19043124D12411241154105010905112260E
+63FE:100011F811081108FDF81108110815F8180033FCD29412941294129457FE2000
+63FF:22102210221023BEF422244427902A103210EF902228222822A82344A2444082
+6400:210021F022102420FBFC224422442BFC30A0E122261E20C020302180A0604010
+6401:2200217C25042484F4F4251426A4244434A4E71C25F42514251425F4A5144408
+6402:1020112410A81020FBFE10A811241A023040D7FE108811081190106051982604
+6403:11081088109013FCFE041204120413FC18403020D0A41282128A128A54782000
+6404:2100213C21002100F9BC256425242D3C3524E1242124213C21242100A17E4100
+6405:24842244224827FEFC02280423F82A083248E248224822A820A02122A2224C1E
+6406:1088108813FE1088FDFC108813FE142019FC3124D1FC112413FE110451142108
+6407:204020A021182686F84023F0201028A03040E7FE2088215023202510A9484186
+6408:1040102013FE1202FC5010881124145018883104D2FA10881088108850F82088
+6409:1040104013FE12A2FC9011FE15101B1035FED110111011FE1110111051FE2100
+640A:1080108011FC1244FD5411F4108415281A9031FCD244155411F4108451282210
+640B:1004101E13F0121EFE1012FE129216981AF2328ED28012B812A814AA554A2A86
+640C:200023FC22042204FBFC224822482AFC3248E24823FE22A422A82490A4C84886
+640D:100011F811081108FDF8100013FC16041BFC3204D3FC120413FC109051082204
+640E:20062F7821102120FA44227823102A24367EEA122210225422522292AA504420
+640F:1028102413FE1020FDFC112411FC152419FC3124D00813FE1088104850482018
+6410:2080204027FC2080F90823F02060298437FEE00227FC244427FC2444A7FC4404
+6411:1108110817FE1108F80017FE110819F83108D1F81108113E17C8100850082008
+6412:1040102013FC1108FC9013FE12021444182033FCD08010F81088110851282210
+6413:11081088109013FCFC4011F8104017FE18803100D1FC12201420182053FE2000
+6414:200023F821482110F8A0204021B02E4E3040E3F82248224823F82044A7FC4004
+6415:1020102011FC1020FC2013FE108015041BFE3002D3FC12941294129457FE2000
+6416:1040108011FC1248FD3010C0130011FC1A203020D3FE10201124112451FC2004
+6417:1020104011FC1104FDFC110411FC150019FE3100D1FE1042124A13FA50142008
+6418:1040104411F81050FBFE104014F81982327ED40011FC110411FC110451FC2104
+6419:100013FE120012FCFE0013FE12A816901AC83286D20813FE1288144854082818
+641A:104011FC10441094FD0813DE114A154A1A9431FCD10411FC110411FC5104210C
+641B:111010A0100017FEF8A013F810A81FFE30A8D3F810A011B012A814A650A020A0
+641C:10A0112C11241124FDAC1124112415FC182031FCD08810501020105050882306
+641D:1020104011FC1104FDFC110411FC150419FC3028D02413FE1050108851042202
+641E:1040102013FE1000FDFC110411FC14001BFE3202D2FA128A12FA1202520A2204
+641F:21002100213E27C8F90827C825482FC8357EE7C821082FE821082108A1084108
+6420:2440225E22922012F7D2211E255225523552E7DE2152211222122222A42A4844
+6421:23F0211020E02318F80027BC24A42B1834A4E04027FC20E021502248AC464040
+6422:100013FC10901294FD98109017FE180031F8D108110811F81108110851F82108
+6423:20142012201027FEFC10241027F22C923492E5B426D42488254A293AAA265042
+6424:1104108410881000FBFE1000148819043202D1FC115411541154115457FE2000
+6425:10101220117C1144FC44107C13401540197C3144D144117C11441280547E2000
+6426:200027BC20842084F7BC2420242027BC3084E4A42294229424A42084A5284210
+6427:2080204027FE2402FC0227FE24002FDE3442E652254A24C62B5A2842B14A4084
+6428:100011FC110411FCFD0411FC100014001BDE3042D252114A12521042514A2084
+6429:2208220823BEF4882AA8213E22083448E84827FC20E0215022482C46A0404040
+642A:2040202027FE2420FDFC242427FE2C2435FCE42025FC250425042904A9FC5104
+642B:08783E48228E2A007EF822482A3046CC80201FC001003FF801007FFC01000300
+642C:2100223C27A424A4F6A425A424C22F8034BCE4A426A425A424942488A49449A2
+642D:2110211027FC2110F84020A021102A0835F6E000200023F822082208A3F84208
+642E:100013FE10501050FBFE125216521BFE3020D02013FE107010A8112456222020
+642F:103C13C010441224F928110014401B9C3204D204139C12041204120453FC2204
+6430:100011FC110411E4FD2413FE120211FC190431FCD10411FC1104110451142108
+6431:100013FC12041204FBFC124012201BFC3288D25013FE122015FC142058202020
+6432:2080204027FC2404F9102208203C2BD03290E29022902288228824A4A4D44892
+6433:1040102013FE1202FC2411FC102015FC182033FED02011FC1104110451FC2104
+6434:01007FFE44429FF404403FF80440FFFE082017D02108DFF601007FF801000300
+6435:200023F8224822A8FB18220823F828003000E7FC24A424A424A424A4AFFE4000
+6436:10201020105010C8FD2413FE150411FC190431FCD10011FC1284128454FC2084
+6437:1020102013FE1020FDFC110411FC150419FC3104D1FC110413FE108851042202
+6438:1020102013FE1020FDFC104013FE1488193432E2D02011FC107010AC53222020
+6439:100013FE100011FCFD04110411FC14001BFE328AD25213FE12221222522A2204
+643A:10A0109011FE1320FDFC112011FC152019FE3100D3FC1088109E1102520A2404
+643B:010006C01830EFEE00001FF010101FF0040C78F010107CFC1010FEFE10103030
+643C:10401248115013F8F88017FC11101A2835C4D84213F8104017FC104051402080
+643D:1088108813FE1088FCA81050108815241A2231FCD02010A81124122250A02040
+643E:1040102013FE128AFD04108010FE15401A40307CD0401040107E104050402040
+643F:11003906E2B822882448F85E238820082008FBBE228822882288238842A88010
+6440:1040108011FC1104FD0411FC110015FE190031FED00212AA12AA140250142008
+6441:200027FC24442444F7FC244424A425143404E7FC204020242522250AA90840F8
+6442:100013FC110811F8FD0811F8110E17F818083008D20411081090110852042402
+6443:100011FC10201020FBFE100015FC190431FCD10411FC110411FC108851042202
+6444:100013FC110811F8FD0811F8110E17F8180837BCD0A412A41128129054A82846
+6445:2040207C204027FEF442247027C42444343CE4202410245425422942A94A5238
+6446:100013FE12521252FBFE1020142019FC3020D02017FE10401088110453FE2102
+6447:1008103C13C01004FA44112811FC1A203020D3FE102011241124112451FC2004
+6448:1040102013FE1202FC1411E01100150019FC3110D11017FE1000109051082204
+6449:1040102013FE1202FCA81124145018883346D0F8110812881050102050402380
+644A:202820242740217EF1C82948257E25483248E27E254825482948207EA0404040
+644B:2000245C22942114FA9424542126290037DCE1142594255429482108A5144222
+644C:1040102013FC1000FD08109017FE1A2032A0D2FC1320122012FC1420542029FE
+644D:1040102017FE1402FD0011FE121016201A7C3244D244127C12441244527C2244
+644E:200027BC208424A4FA9424A4205029883626E0C02310206423882030A0C04700
+644F:1020102013FE1020FDFC104013FE148819043242D59C110411DC110451FC2104
+6450:212421242224F4242954214A22923610EA102250225C2250225022B0A29E4300
+6451:200027FE242A2426F7FE242227AA26AA37AAE4322596262E24462482A7FE4402
+6452:200023FC22042204FBFC220022842A4832FCE248224823FE24482448A8885108
+6453:1020147C12841148FC3010CE16101A7C3210D27C121012FE1210121055FE2800
+6454:1040102013FE1020FC4812F21124165218F83008D02013FE1020102050202020
+6455:22A822A827FC22A8FAAA24E628002FFC3444E04023F8224822482248A2584040
+6456:1100111013DC1254FD54128811081AF43402D00013FC10401150124855442080
+6457:2108210827C82108F91E27D225642D4037C8E1082388254829542114A1244142
+6458:2080204027FC2110F8A027FC24442DF43444E5F42514251425F42404A4144408
+6459:2010241022FE2210F8FE209226FE2A9232FEE21022FE221022102510A8FE4000
+645A:1020112410A813FEFA0210F81488188830F8D020102011FC1020102053FE2000
+645B:1040102013FE1000FD541124115415FC182033FED242129212FA120A52022206
+645C:100011FC112413FEFD2411FC100015FC190431FCD10411FC110411FC50882104
+645D:1040102013FE1250FE5013FE125216521BFE3200D29212D41298149254D2288E
+645E:100013FC124413FCFE4413FC108015101BE03048D18413FE1022112852A42442
+645F:102011FC112413FEFD2411FC102015FC192431FCD04013FE108811D05070238C
+6460:1040108013FC1244FAF4131412A41A4432A4D3FC104010241522150A590820F8
+6461:200027BE24882488F7A824A824A827BE3410E518249825A826AA244AA0464080
+6462:1040107C104013FEFA42127813C41A3C3208D2F0132412A815FE142058A02040
+6463:1040107C104013FEFA42127813C41A3C3200D2FC128412FC128414FC548429FE
+6464:1020102013FE1020FAAA112412AA182032AAD12412AA10501050108851042602
+6465:110011FC120015F8F90811F8150819F83000D7FE110013FC14A4112452542088
+6466:2200220E2F74F254255428D427543054EFD424542754215421522154A55C4284
+6467:1020122213FE1090FC8811FE1310151019FE3110D11011FE1110111051FE2100
+6468:100013FE120213FEFE101254123816541A823250D27C1290121015FE54102810
+6469:00803FFE24103F7C26382D543412203827C0204027F820402FFE404041408080
+646A:20902290229E22A2FAD423A8209428A437FEE28422A4229422942284A4944888
+646B:2200227C22442744FA7C224422442F7C3244E244227C22282528254AA84A5086
+646C:1080104013F81110F8A017FE10001BF83208D3F8120813F81120112252222C1E
+646D:2040202023FE2200FA48224823FE2A483248E248227822002554252AAA2A5000
+646E:08207F20087E7E4408A4FF2810101E2822645FC281003FF801007FFC01000300
+646F:08207E2008F8FF2814287F6A082AFF5608A21FC001003FF801007FFC01000300
+6470:08203E2008F87F282A685D2A08563E8200201FC001003FF801007FFC01000300
+6471:100011F8110811F8FD0811F8100017FC1A9433FCD00011F81090106051982606
+6472:22002202223C2FA0F2202FA02ABE2FA43AA4EFA422242FA422242244A2444284
+6473:100013FE1200127CFE441244127C16001AEE32AAD2AA12AA12EE120053FE2000
+6474:11FC102013FE1222FDAC102011AC140019FC3000D3FE108010FC100450282010
+6475:20142012201027FEFC10249024D22C9237F2E494249425C82AAA289AB1A64042
+6476:102013FE102011FCFD2411FC112415FC182233FED00813FE1108108850282010
+6477:1124124811241000FDFC112411FC152419FC3020D3FE107010A8112456222020
+6478:1110111017FC1110FC0013F8120817F81A0833F8D04017FC10A0111052082406
+6479:04407FFC04401FF010101FF010101FF00400FFFE10502788C1061FF001000300
+647A:200027BC208424A4FA9424A42084284033F8E208220823F822082208A3F84208
+647B:1040108811FC1108FA5213FE145019883626D0C0131010641388103050C02700
+647C:200027DC251427D4FC5427C825082D1437E2E000204027FC20402040AFFE4000
+647D:100013FE105011FCFD54115411FC140019FC3000D3FE102010A8112452A22040
+647E:2000277C21442144F97C271024102C7C3454E7542154217C21102114AAFE4402
+647F:1020105010881346FC2011FC108814501BFE3000D1FC110411FC110451FC2104
+6480:08007F7808483E4800863E782A483E3040689FC601003FF801007FFC01000300
+6481:102013FE104810F0FC2013FE1242109019F83028D12011FC122017FE50202020
+6482:200027FC244427FCFC4427FC21002BF83510E0E023182C0623F82208A3F84208
+6483:1078FE4810487C8654787C485430FECE10201FC001003FF801007FFC01000300
+6484:20002FBE28A22AAAFAAA2AAA251428A23080EFFE2110221023A02060A1984E04
+6485:20002FFE28002A28F9482BEE289228843AA0EAA82BE8288828942914A9245242
+6486:49202A3E7F4849485DA86B104928414600201FC001003FF801007FFC01000300
+6487:2108210825482390F91E27D425642D543554E75425D4254825482554A46444C2
+6488:208822AA22DC2488F954222220002BFE3242E44423FC204420442084A1144208
+6489:08407F40227E3E8801483E4804507E200850288C10F03F0001007FFC01000300
+648A:279E2492279E2492FF9E240224F22C9234F2E49224F2249224922532A4024406
+648B:200027BC24A427BCFCA427BC24042DF43444E4E42444244425F42404A4144408
+648C:104013F8124813F8F84017FE10001BF83208D3F8120813F8120813F851102208
+648D:200027BC21082528F7BC231825AA29463000E3F82208220823F82208A20843F8
+648E:102013FE102011FCFC0013FE120215FC180031FCD10411FC1104108853FE2000
+648F:100013FC100413FCFC0413FC100017BC192437BCD00813FE1108108850A82010
+6490:112410A813FE1202FCF8108810F8140019FC3010D11011FE1050109053102030
+6491:112410A813FE1202FCF8108810F8140C19F03020D1FC102013FE102050A02040
+6492:2288228827C82290FA9E27D420242FD43454E7D4245427C824482454A46444C2
+6493:1020102011FC1020FBFE1108179C19083188D63E100013FE109010905112220E
+6494:100011FC110411FCFD0411FC14201BFE3000D1FC110411FC1020112452222060
+6495:24802482249C2FD0F4902790249E27943494E4942FD42014251428A4B0244044
+6496:2008278820882110FFDE249424A427943494E794249424C827882C94A0A440C2
+6497:1088108811FC1088FC8813FE102015FC192431FCD12411FC1000108851042202
+6498:1210121013DE1228FD4410A015101A0835F6D000100013F81208120853F82208
+6499:2108209027FE2090FBFC2294231C2A0433FCE20423FC200827FE2108A0A84010
+649A:2110211421D22250FA7E255020902AA83128E14422442482200822A4A2524452
+649B:1020112410A813FEFCA8112412221104190431DED2441554109E110452042404
+649C:202027A420A82292F914220825F4280233F8E208220823F822082110AFFE4000
+649D:2004203E27C02244F92823F822082BFC3204E3FE240226AA2AAA2A02B0144008
+649E:102011FC10881050FDFE100011FC152419FC3124D1FC102011FC102053FE2000
+649F:101C11E0104013FEFC88110412FA148818F83000D3FE120212FA128A52FA2206
+64A0:21102114211227D2F91027DE24702FD23452E7D421142FD8210A211AA1264142
+64A1:2080211023F82210FCA427BC204028A03358EC462048226422522452A1404080
+64A2:100013FE105013FEFE5213FE100015FC190431FCD10411FC102013FE50202020
+64A3:100013DE12521252FBDE100015FC192431FCD12411FC102013FE102050202020
+64A4:2208210827C82210F49E2FD4206427943494E7942494278824882494A4A445C2
+64A5:202423A820922514F2082C0427BA20A837C6E40027BC208420A82090A5284244
+64A6:1040104017FC1110FA48144613F8185037FCD08013F81D0811F8110851F82108
+64A7:21102110221C22A4F4C82F3E212A222A34AAEFBE20A020222AA22AA2A81E4000
+64A8:1090108811FE1110FB1015FE1110191031FED110111011FE110012A452522452
+64A9:2040204027FC20A0F514220827FC2A0A33F8E20823F8204022482444A9444080
+64AA:2080211023F82080F7FE224825F4284233F8E24823F8224823F82040A7FC4040
+64AB:1100110013FC16A8FAA812A817FC1AA832A8D2A81FFE100012A8125454542000
+64AC:103813C0107813C0FC7813C4103C140018C63738D1CE173811CE1738514A2186
+64AD:207827C022482150FBFC215022482C0633F8E248224823F822482248A3F84208
+64AE:200023F8220823F8FA0823F820002FFE3480E7BC2494279424D42F88A09440A2
+64AF:1088105013FE1020FDFC104013FE148019FC3284D4FC108410FC108450FC2084
+64B0:200027BC24A427BCFC2024A4239C28003110E7FC211021102FFE2110A2084404
+64B1:2020272025FE2540FD7C2690257E2D00357CE544257C2644247C2444A444444C
+64B2:1050125211541050FBFE108814501BFE3020D1FC102013FE1050108851042602
+64B3:221022102510F4BE2822274422103210EF1022102AA8272822282344AC444082
+64B4:221021102FD02010F7BE24A427D420143794E094211421C82F082114A5144222
+64B5:1088108813DE1088FBDE108811541A2233FCD080112013FC102017FE50202020
+64B6:108813FE10881000FDFC10A810A817FE18A830A8D1FC102013FE102050202020
+64B7:220022FE22102FA0F27C2244275420543054E7542554255425282724A5424082
+64B8:210023F024102FFCF44427FC244427FC3000EFFE200023F8220823F8A20843F8
+64B9:12441124112813FEFA0211F8150819F83108D1F8110811F8109010905112260E
+64BA:2080204027FC2514FA48244423F82A4833F8E04027FC244427FC2444A0404040
+64BB:20102410227C2010F8FE204426282AFE3210E27C221022FE22102210A5FE4800
+64BC:2014201227FE2410F5D0241425D4255835CAE4162442282422A2228AA4784000
+64BD:2108220827C82450F7DE246427D422143114E7D4221423C822482454A55448A2
+64BE:1000127C11441174FC54105416FE12821ABA32AAD2BA1282128A1284550028FE
+64BF:1020102010501088FD0412FA1000140019DC3154D15411DC1088108851542222
+64C0:2108210821142FD4F12227C0245C27C83448E7C8213E2FC821082108A1084108
+64C1:2040202027FE2028FA24227E24C82F48317EE24824C82F7E21482248A47E4840
+64C2:200027FC20402FFEF842235820402B583000E7FC2444244427FC2444A44447FC
+64C3:109013FC129413FCFE9413FC100017FC1A0032F8D20013FE1520151455482986
+64C4:1040107C104013FEFE4213F8124412FC1AA832F8D2A812F8122015FC5444298C
+64C5:102013FF1000FDFE1102117A114A157A190231FED00010FC108410FC508433FF
+64C6:1108110817FE1108F84413F41048185037FED08011FC130415FC190451FC2104
+64C7:100013FE125213FEFC2011FC14201BFE3088D05011FC102017FE102050202020
+64C8:1050125211541050FBFE108814501BFE3020D1FC102013FE10A8112456222020
+64C9:100013F812A812A8FBF8110013FC1C8433E4D2A412A413E4109417F450142008
+64CA:083C7F242A243E422A3CFFA449187F6600201FC001003FF801007FFC01000300
+64CB:20402248215027FEF402280423F8220833F8E00027FC244427FC2444A7FC4404
+64CC:2210221023DE2528F8C4204027FE28403248E248255428A220A02110A2084C06
+64CD:23F82208220823F8F80027BC24A42CA437BCE0402FFE216022502448B8464040
+64CE:2420FF20247E7EC482287A104A287AC604201FC001003FF801007FFC01000300
+64CF:2288228827E82290FC1E27E4245428543754E5542554274825482054A2944122
+64D0:100013FC12941294FBFC100017FE180033FCD20413FC10A2111413085D442182
+64D1:101013D412521252FBD0101017FE1A5033D2D25213D4125412EA174A50562062
+64D2:204020A021102248FDF620A022482AA833F8E04027FC2484252425F4A414440C
+64D3:200027FE24282624FD7E244824C82C7E3648E57E24482448257E2640A7FE4000
+64D4:108010F8110813FEFD44119211FE1500197C3100D17C1100117C1244527C2444
+64D5:10A0109011FE1320FDFC112011FC152019FE3100D3DE12521252127252022206
+64D6:108813FE108811FCFD0411FC110415FC188031FED2221552110211FA500A2004
+64D7:20102008278824BEF48024942788247E3408E78826BE2A882A882B88B2884008
+64D8:3E1022FE3E4420287EFEA2103EFC221000201FC001003FF801007FFC01000300
+64D9:1040108013FE1222FEAA122213FE16721AAA3202D02013FE1020105050882306
+64DA:1040107C104013FEFE42127813C4163C1A0033FED24013A4125815B4545229B0
+64DB:108813FE10881000FD4813FE11481578190031FCD02013FE107010A853262020
+64DC:2108210827CC210AF90827DE24482EC83548E7C8255427D425542554A45444E2
+64DD:200027BC24A424BCF7A424BC24A427A43024E04C23F822A822A822A8AFFE4000
+64DE:22102A9027102220FFBE224427A42AA43228EFA82490289025282228A5444882
+64DF:200027FC2248F4442FFE244426EC3554E6EC244426EC255426EC2444A4544408
+64E0:2080204027FC2110F0A42F58255425523B58E000220823F8220823F8A2084408
+64E1:20402FFE204027FCF00023F822082FFE3802E7FC211023F8204027FCA0404FFE
+64E2:200027BC208424A4FA9424A421202A1037FCEA2023FC222023FC2220A3FE4200
+64E3:204027FC204023FCF80027FE20022BF83040E7FE200027FE200827FEA4A84798
+64E4:208023F8220823F8FA0823F820002FFC3444E7FC244427FC20002FFEA1104210
+64E5:00007E40487E7E9043087EFE48AA7EFE00201FC001003FF801007FFC01000300
+64E6:2080204027FE2402FA2423BC24A42AA83510E2E824042BFA20402248A44440C0
+64E7:0A0033B822083BB820883AB82288FFFE082037D8C1061FF001007FFC01000300
+64E8:200820682F8828EEF88A2BF22AA42AC43B84EAA42A642A0A2AEA2AAAAAAA5530
+64E9:200027FC20402FFEF842235820402B583000EFFE204027FC24A424A4A4A4440C
+64EA:3FFE28882F8A20082FBE28882F88289429A227F8204027FC20405FFE404080C0
+64EB:20002FFE28082BC8FA4C2BCA2A482BDE3808EBC82A482BD42A542BD4AA5452E2
+64EC:2400257C2604F4A82390207C24143794EA5022502FDC2250255024B0A89E4100
+64ED:108813FE10A81090FDFE132011FC152019FC3120D1FE110013FC10885070238E
+64EE:2110211427D22110FFFE229024502FF43494E7F4249427E8248A27FAA4264042
+64EF:1040102013FE1202FDFC1148165019FC3304D1FC110411FC110411FC50882104
+64F0:1040102013FE1222FD54114A123A100019FC3154D3FE100011FC102050A02040
+64F1:200027BC24A427BCFCA427BC24842DF43694E4E4271C24E424A424A4A4E4440C
+64F2:2440228E2FEAF28A2FEA2AAA2C6C3BAAE82A2FEA210A2FEA228C2448A8284008
+64F3:1108110811EE1294FC42100013DE16521BD23252D3D2121A1294135052102010
+64F4:2040202027FE2488FDFC248827FE2C2035FCE52425FC252425FC2400A4884904
+64F5:202027FE248827DEF48825DC26AA248C35F0E42025FC242027FE2820A8A05040
+64F6:121013DE15281084FD08109017FE10001BD43254D3D4125413D41244525422C8
+64F7:2200227E22102FA0F27C22442744207C3044E77C25442544257C2700A5284044
+64F8:1124124811241000FBFC129416641A9433FCD24813681248136A124A52462362
+64F9:2290229027D0229EFB92212227C82D4837C8E10827C821142FD42294A4544822
+64FA:200027FC24A424A4F7FC222024A427B83022EF9E28802FA428B82FA2A8A2499E
+64FB:210827C825482FF0F55E27E4211427D43554E7D422142FC824482694A1944662
+64FC:210023F024102FFCF44427FC244427FC3524E89223F8220823F82208A3F84208
+64FD:244424E428A82AAAFEEE24A42AAA2EEE3242E0402FFE20E021502248AC464040
+64FE:27FC208023F82208F3F822082FFE28823548E51428F4210023F82508A0F04F0E
+64FF:2020201024FE2244FA2820FE20922EFE3292E2BA22AA22BA22862500A8FE4000
+6500:22882108FABE2008729CA92A2288FFFE082037D8C1061FF001007FFC01000300
+6501:2208211027FC2040FBF8208027FC294833FCE60A2BF8220823FA2234A28C4302
+6502:23F82248224823F8F248224823F820003FBEEAAA2AAA2FBE2AAA2AAAAFBE48A2
+6503:1088108813FE1088FD1011DE125215541A883174D20211FC1020112452222060
+6504:2020203E202027FEFC2225F824222DFE3524E5FC252425FC28402AA4B28A447A
+6505:108811DC108813DEFC881154122211FC190431FCD10411FC110411FC50882104
+6506:108813DE108813DEFD54122211FC142019FC3124D1FC112411FC102053FE2020
+6507:20402FFE284227FCF84023F820402FFC3040E7FC24A427FC20402524A52A48FA
+6508:102013FE125013FEFA5213FE12941AD83292D2CE120812F0122015FC54A82B26
+6509:27FC204027FE2442FB5C2040275C292033FCE6202BFC222023FC2220A3FE4200
+650A:200027FE24442598FC8827DE24882DDC36AAE48824202520253C2920A92057FE
+650B:2108210827CE2112F92427DE25522D5E37D2E11E2392255E29402114A1124122
+650C:2FFE28022BFA2AAAFBFA28022BFA280239F2E91229F228AA29922ACAA8824FFE
+650D:40807FFC48004FF8E0004FF848084FF86080DC9C57D45D54555C5C965556EE22
+650E:1040107C104013FCFE4413F0124416FC1AA832F8D2A812F8120015FC55542BFE
+650F:1110109013DE1010FA5E118217DE181033DED25013DE125013DE1250525222CE
+6510:104017FE149213FCFC9013FC109017FE19483224D5FA10A411A8129054C82086
+6511:1140126C1244136CFEA413AC12A417FE19083244D5F2104017FC104050402040
+6512:2108252827BE2948F7BE231825AA29463000E3F822082248224820B0A1084604
+6513:204027FE249223FCF89023FC20902FFE3108E3FC250A21F82240227CA54048FE
+6514:27BC24A427BC24A4FFBC244425F42C4435F4E55425F4255425F424E4A554444C
+6515:2448244C2AAAF0082FFE22882EE8328AEEEA228C2EEC228822EA2F1AA4264042
+6516:13DE125213DE1252FBDE125213DE198C3252D04017FE10881190106050D82304
+6517:204027FE24A027FCFCA427FC25142DD83512E54E25A424A827FE28A8A9245222
+6518:204027FC200023B8FAA823B821102FFC3110E7FC21102FFE21282310AD484186
+6519:11F0121017FC1204FBFC122413B81A2231FED21017FC124413FC10D0514A263E
+651A:108812AA12DC1488F954122217FE1A0230F8D08810F8100011FC110451FC2104
+651B:104017FE14921108FC80131C1204179C1A0433FCD24813681248136A52462362
+651C:122213FE109011FEFB1015FE111019FE3110D1FE110013FE128A137652522276
+651D:13FC110811F81108FDF8110E17F8180837FED294139C1294139C12D657BC2084
+651E:200027FC24A4F4A427FC221022A834BEEF68223C24A82FBC20282AA8AABE4020
+651F:204027FE24A027FCFCA427FC24002DFC3504E574252425FC257429ACA92451FC
+6520:202027FE248827DEFC8825DC26AA2C883450E7DE245025DC24502BDEA8505050
+6521:241822142F90253EFAA82DE828BE2FA83228EFBE2AA82AA82BA828BEAAA04920
+6522:252827BE294827BEFB1825AA29462BFC3204E3FC220423FC220423FCA1084204
+6523:21084FD2F03C23884812FBBE0280ABAA00201FC001003FF801007FFC01000300
+6524:251825142F90253EF72822682FBE2AA83FA8E23E2FA822283FE8253EA8A05060
+6525:221023DE25282084FBFC22A422542BFC3080E7FE22A825E4285223F8A15042C8
+6526:2FBE200027BC24A4F6B424A4204027FE34A0E7FC24A427FC251229DCA91251CE
+6527:2200221E2FC42208F79E24922792249E3792E49E279224922FDE2500A48C4892
+6528:20402FFE2A0A2434F3C02290228822A434D0E18E2E742B542AD42A52AB5A5294
+6529:2248215027FC2404F9F0211027FC2D5434E4E7FC204027FC20402FFEA2A44452
+652A:22AC244426AC2444F6AC24042FFE2A0A33F8E20823F8220823F820A0A124461C
+652B:13DE125213DE1252FBDE10A011FE1B2035FCD12011FE100011FC10885070278E
+652C:2790251E27A82484FFBE252A27BE280033F8E20823F8220823F820A0A124461C
+652D:21F0221023E02020F7FC2188265021A83664E1A022482FBE2AAA2FBEA28A4FBE
+652E:204027FC224823F8F0402FFE2AAA23B83110E7FC21102FFE21282310AD484186
+652F:0100010001007FFC0100010001003FF01010082004400280010006C01830E00E
+6530:102010201020FE2010FC1024FC24442444242844284410941908240043FE8000
+6531:202010201020FDFE00200820882089FC48844888504850501C20E05041880606
+6532:10101010FE1010FE28104410FEFC044474445444542874285410042814440982
+6533:11FC100410FCFE0411FC1000FDDE449247DE28082BFE110818A8241043FE8000
+6534:01000100010001FC0100010001003FF01010082004400280010006C01830E00E
+6535:0400040004000FFE08101010302048208440028001000280044008203018C006
+6536:084008404840488048FE49084A88488848885850685048200850088809040A02
+6537:00400040FE40208020FE210842887C8804880450045004200450048829041202
+6538:082008200820103E12443244524492A412281228121012101228104810841102
+6539:00400040FC8004FE0508050806887C8840884050405044205850608841040202
+653A:004000407C40448044FE4508468844887C884050405040204450588861040202
+653B:004000400040FE8010FE1108128810881088105010501E20F050408801040202
+653C:00407C401040108010FE11081288FE8810881050105010201050108811041202
+653D:002014201220123E214421444044BEA41228122812101210222822484A848502
+653E:204010400040FE8020FE21083E88248824882450245024204450548889040202
+653F:00200020FF20083E0844084448444EA448284828481048104F28F04800840102
+6540:1040104020407C8044FE4508468844887C8844504450442044507C8845040202
+6541:1020102010201E3E1020102010207DFC44844488444844507C20445001880606
+6542:1020102020203F3E414481443D4425A4252825283D102510012801480A840502
+6543:0020FE208220823E8244FE44904490A4FF289028901088108928A528C3448182
+6544:0040FC400440688010FE0908FE88128834883050505050209050108851042202
+6545:1040104010401080FEFE1108128810887C8844504450442044507C8845040202
+6546:08100810141E22104110BEFC004400443E4422282228221022103E2822440082
+6547:08100810FF900820083E7F44492449244D244A281C282A10492888A808440882
+6548:102008200020FF3E00442444424481A424281428081014102228424880840102
+6549:104010409440548058FE1108FE88308838885450545090201050108811041202
+654A:081008100E10081E08100810FEFC0044084408444A2849288910082828441082
+654B:204020403C404480C4FE290812882888448882507C504420445044887D044602
+654C:04200E203820083E0844FF44084408A43E2822282210221022283E4822840102
+654D:081008101410221E4110BE1008FC08447F4408442A2829284910882828441082
+654E:0240644018402480D2FE1108FE882088FE88445088500F20F850088829041202
+654F:402040207F20803E7E44424452444AA4FFA8422892108A10FF28024814840902
+6550:00207F204020403E5E44404440447FA4502851285A1054105228912898441082
+6551:1040144012401080FEFE11081088928854881050385054209250108851042202
+6552:1210121012102FA02ABE6AC46AA4AFA42AA42AA82AA82F902228222822442282
+6553:004028402440428080FE7D084688448844887C502850282028502A884D048A02
+6554:0020FF201020103E7E4422442244FFA4002800287E104210422842287E444282
+6555:08200820FFA0083E08447F44494449A47F2808281C102A104928884808840902
+6556:0820082008207F3E08443E440844FFA410281E281210121022282A4844848102
+6557:00407C40448044FE7D08450846887C88448844507C5000202850248845048202
+6558:082008201420223E4144BE44084408A47F2808282A1029104928884828841102
+6559:082008207EA0093E0A44FF4408447EA4242848288F1078100828084828841102
+655A:44402440284000807CFE4508468844887C882850285028202A504C8889040202
+655B:082008201420123E214440C4BE4400A411280928491022102228074878842102
+655C:082008201420223E514488447E4402A4142808282A10A110A128A5281C440082
+655D:0810491029102A20083E7F44492449245D246B28492849104928412845444282
+655E:0820492029202A3E08447F44414441A45D285528551055105D28412845444282
+655F:1420142014207F3E5544554455447FA4552855285510FF902428224842848102
+6560:0010F7101110551E2210551089FC10440044F744112855282210552889441082
+6561:00107E104210421E7E10421042FC7E4420447F44952825284910912825444282
+6562:00207E200220043EFF44224422443EA422283E28221022102F28F22842440282
+6563:242024207E20243E2444FF4400447EA442287E2842107E10422842284A444482
+6564:00107F104910491E7F10491049FC7F440844FF441C282A284910882808440882
+6565:0810091049104A1E8810141022FC49448844494449288A281410222841448082
+6566:10200820FF20003E7E4442447E4400A47E28042808100F10F828084828841102
+6567:081008107F1E1410221041FCFF4402447A444A284A287A104A1002280A440482
+6568:102008207F20003E22441444FF4400A400283E282210221022283E2822440082
+6569:511029102A100020FFBE80C401247E24042408280F28F8100828082828441082
+656A:0020F7201120553E22445544994400A4F7281128551022105528894810840102
+656B:082010207E20423E7E4442447E4410A40828FF2820103E10222842484A848502
+656C:22202220FFA0223E40447F44414481A47D28452845107D10452801280A440482
+656D:00207E2042207E3E42447E440044FFA440287F2895102510492891482A844502
+656E:02100F107810081E0810FF1028FC4B44494449446B28492849107F2841440082
+656F:0010FE108210FE1E8810FF1088FCA544C3440044FE288228FE108228FE448282
+6570:082049202A20083EFF442A44494488A41028FE2822104210642818283444C282
+6571:0810491049107F1E0010FF1000FC7F44414441447F28422824100F28F0444082
+6572:10100810FF10001E7E1042107EFC0044FF448144BD28A528BD10812885448282
+6573:0820492049207F3E0044FF4400447FA4412841287F10421024280F48F0844102
+6574:08200820FFBE08447FA449247F282A104928884600007FFC010011F81100FFFE
+6575:102008207F20223E14447F44414449A47F2849285D10551055285D2841444382
+6576:0210E210BFD0A220AFBECAC4AFA4AAA4AFA4A228A728CA909268822882448282
+6577:0A200920FFA0083E7F4449447F4449A47F2849281010FF9020283E2842448682
+6578:08107F104910FFA0493E7F4408247F2449247F281028FF10212872280C44F382
+6579:082008200F20083EFF448144064478A449282A28FF1018102C284A4888840902
+657A:0010FF90801E9F10911091FC9F448044BBC4AAA8AAA8AA90BB908028FFC40082
+657B:10001FE020207FF8A30824881FF010101FF010101FF008001FF8282007C0F83E
+657C:0810FF9008107F1E00107F1041FC7F442244FFC400287F28411041287F444182
+657D:061078101010FF9E22105D1094FC1C4400447F4441285D2855105D2841444382
+657E:22101410FF9008207F3E0844FFA449242A24FFA800287F10412841287F444182
+657F:061078101010FFA0223E5D4494A41C2400247F2841285D1055285D2841444382
+6580:00107F10551E55107F1020FC7F4491447D44552855287D1011107D2805440282
+6581:00207F2055207F3E08447F440844FFA4222814287F100810FFA8084808840902
+6582:082008201420223E4144BE44004400A477285528551077102228222855448882
+6583:49202A3E7F4849485DA86B10492841460000FFFE10803E9842E024841884E07C
+6584:08203E3E08447FA82A10492808443FFE20802FFC249024902AA851C446B0988E
+6585:34104B105510631E55106B10557CFFA480A47E2404280F28F810082828441082
+6586:34104B1055106320553E6B445524FFA480A47E2804280F10F828082828441082
+6587:020001000100FFFE10101010082008200440028001000280044008203018C006
+6588:020001007FFC0820044003801C70E00E0FE000400080FFFE0100010005000200
+6589:020001007FFC0820044003801C70F01E10101FF0101010101FF0101020104010
+658A:020001007FFC0820044003801C70E00E3FF808200FE008200FE0083EFFE00020
+658B:020001007FFC0820044003801C70E00E1FF0020004003FF82488248824A82010
+658C:0010201411D20012FC100BFE08104890289012D012902A902A8A4AEA87060202
+658D:01007FFC0820044003801C70E00E1FF010101FF010101FF010101FF00842F03E
+658E:020001007FFC0820044003801C70E00E17D0101017D011101590255029104010
+658F:0040202011FC0104FD0409FC0904490429FC1120112229142908494481820100
+6590:04407C7C044004403C78044004407C7C04400100FFFE0820044003801C70E00E
+6591:00000200F93E21082FC820882488FA8822BE210821083A88E2884448087E0000
+6592:0040202011FE0102FD0209FE0900490029FE11AA11AA2AFE2AAA4AAA84A20086
+6593:0200417C25040444FDF4144415F41554957455D4255425F454E455548444044C
+6594:20201020FEA0052C6924112429ACD52411247DFC55247C5010501C88E5044202
+6595:03DE225213DE0252FFDE0A220AFA4A222AFA12AA12FA2AAA2AFA4A7282AA0226
+6596:01007FFC082007C01830E7CE244837D82448FFFE90121FF010101FF01010FFFE
+6597:0040044002400240104008400840004000FE7F40004000400040004000400040
+6598:1010101010901E5012102290225052108A1E05F0041008100810101020104010
+6599:080808884A482A482C080888FE4818481C082A0E2AF848088808080808080808
+659A:1020102024487EFC224400007FFE4442824410400840007EFFC0004000400040
+659B:100810883C4824484808BE882A482A483E082A0E2AF83E082A084A0842088608
+659C:08080848142822284108BE48082808287F0E08782A0829084908880828081008
+659D:00003E7C224422443E7C00007FFE4442824410400840007EFFC0004000400040
+659E:080828484B28492849086B48492849287F0E4978080814081208210841088008
+659F:22082248FF2822283E0822483E282228220EFF7840085408620840087E080008
+65A0:22082248FFA822287F082248FFA808287F0E49787F084908FFC8410845084208
+65A1:102010201050FE8811047C1244907C5045107C90101EFEF01010101010101010
+65A2:220822487F2822282208FFC808287F28490E7F7849087F080008220841088088
+65A3:00087F48552855287F0820487FA890A87C8E54F854887C881288FE8802880108
+65A4:001000F81F001000100010001FFE104010401040104010402040204040408040
+65A5:001000F81F001000100010001FFE1040104011C0106010502048204040408040
+65A6:0200070438782040204020403F7E244824482448244824482448448844888108
+65A7:044008201850248803000CC03030C0EE1F00100010001FF81080108020804080
+65A8:0408241C24E0248024803C8004FE0488FC882488248824882508450846088408
+65A9:2008201C21E0FD004100510091FEFD10111011101D10F1105110121012101410
+65AA:2000200440787E40824002407A7E4A484A484A487A484A480248028814880908
+65AB:0008001CFCE01080108020803CFE64886488A488248824883D08250822080408
+65AC:1008101C10E0FE8010807C8054FE7C9054907C901090FE901090111011101210
+65AD:0400040455784E4044407F40447E4E48554865484448444840487F8800880108
+65AE:240024047E7824402440FF40007E7E48424842487E48424842487E8842880108
+65AF:220022047F78224022403E40227E22483E4822482248FF480448228841888108
+65B0:100008047F78004022401440FF7E084808487F4808482A484948888828881108
+65B1:100010047D7812401440FF40107E20487E48A24822483E48224822883E882308
+65B2:000077045578554077401440147E7748414841487748144814481F88F0884108
+65B3:22002202FFBC22203E2008207F3E49247F2408247F2408247F2408440F44F084
+65B4:080049022A3CFFA02A20492088BE4124412477A49124552427A4414481440184
+65B5:10006F044578554069404B40107EFFC8144877484148774814481788F8882108
+65B6:00000DFC7154415441FC40807DFC4A4449F44954495449F4484449F448148808
+65B7:0882509C5D5049D054905DDE44547FD4489450945D5449D454945DD444647FC4
+65B8:7FC2405C7FD052504A90525E5FD455545FD464545F5455545F544454BF640084
+65B9:020001000100FFFE04000400040007F004100410041008100810101020A04040
+65BA:202010200050FE50208821043E02248824882488248824884488550889080208
+65BB:208010800080FEFC210022003CF02490249024902490249244925512890E0200
+65BC:202010200020FE50205020883D04260224602410240024C04420541088080000
+65BD:2080108010FE0120FE202120212C3D7427A425242534252A2522450254FE8800
+65BE:208010800080FEFE212022203C2025FC25242524252425244534552888200020
+65BF:2080108010FE0100FE0020FC20043C08241025FE241024102410441054508820
+65C0:202010200048FE8421FE20023C20242024A824A4252425224622542088A00040
+65C1:020001003FF8082004407FFE420281043FF80400040007F00810081010502020
+65C2:2080108010FE0100FE0C20F020803C80248024FE248824882488450855088A08
+65C3:2080108010FE0100FE0020FC20843CA42494248425FE24842484450455148A08
+65C4:2080108010FE0100FE1C21E020203C3C25E02420243E27E0242044225422881E
+65C5:2080108010FE0100FE0C20F020903C902492249424882488248444A454C28880
+65C6:2080108010FE0120FE2021FE20203C2025FC2524252425242534452854208820
+65C7:2080108010FE0100FE10201020FE3C92249024FC24A424A424A8451055288A46
+65C8:2020101001FEFE20204820843DFE240224A824A824A824A844A854AA892A0206
+65C9:01107FFC01003FF821083FF821083FF821080080FFFE08000FF810082028C010
+65CA:2080108010FE0100FE0020FC20403C402478244824A82498248844AA54CA888E
+65CB:2080108010FE0100FE0021FC20243C2424A024A024BC24A024A04560553E8A00
+65CC:2080108010FE0110FE10209020FE3C902510241024FE24102410441055FE8800
+65CD:2080108010FE0120FE20205020883D242612241025FC24042488445054208810
+65CE:2080108010FE0100FE0020FC20843C8424FC248024A424A824B0452255228A1E
+65CF:2080108010FE0100FE80208020FC3CA02520242027FE24202450445054888906
+65D0:2100110011FE0200FC50205022543D58245024D825542652245044505492890E
+65D1:2020102011FC0050FC88210423FE3C0825E82528252825E82528440854288810
+65D2:2100110011FE0240FC2021FE20403C8425FE240224A824A824A844AA552A8A26
+65D3:2100110011FE0220FD2420A820203DFC250425FC250425FC2504450455148908
+65D4:40102010007CF71441FE4114727C5210577C511051FE551052105300B4FE0800
+65D5:10100810FF2820443E822210220842204A10840800007C8844B044C47C84447C
+65D6:2100110011FE0200FC2021FC20503C8827FE240825E8252825E8440854288810
+65D7:2100110011FE0200FC8821FC20883CF8248824F82488248827FE445054888904
+65D8:2110109413D20012FA50219027FE38102BD22A522A542BD42A4A4A4A4BD69822
+65D9:203C13E0112400A8FDFE20A821243E0225FC2524252425FC2524452455FC8904
+65DA:210011FE120001FEFC5021FC21543DFC240025FC240027FE242044A855248A64
+65DB:2100110011FE0200FC1C23E021243CA827FE2524260225FC252445FC552489FC
+65DC:210011FE122004FCFC0021FE21023D7A254A25FE248424FC248444FC540089FE
+65DD:208010FE11300248FCB4210221FE3DAA257225FE240024FC248444FC548488FC
+65DE:2080108010FE0100FE44202822FE3D2024542728255C252A254A452856908C7E
+65DF:2100110001FEFE002540224C3A642B4C2A642AA42BAC2AA44FFE689091080204
+65E0:00003FF002000200020002007FFC0480048004800880088010842084407C8000
+65E1:00003FF002000200420042007FFC0480048004800880088010842084407C8000
+65E2:00007DFC442044207D20452045FE7C204020483044504A5052926092410E0200
+65E3:100021FC7C2044207D2045207DFE0020402040307C50405040924C92710E0200
+65E4:00007DFC442044207520552055FEFE208220BA30AA50AA50BA9282928B0E8600
+65E5:00001FF0101010101010101010101FF01010101010101010101010101FF01010
+65E6:00001FF010101010101010101FF010101010101010101FF000000000FFFE0000
+65E7:200023FC2204220422042204220423FC2204220422042204220423FC22042000
+65E8:2000207023803C08200820081FF800001FF0101010101FF0101010101FF01010
+65E9:00001FF0101010101FF0101010101FF001000100FFFE01000100010001000100
+65EA:002000207C2044204420442047FE7C2044204420442044207C20442000200020
+65EB:000000007DFC44444444444444447C4444444444444444847C84450402280410
+65EC:080008000FFC100410042FC4484488440FC4084408440FC40844000400280010
+65ED:200020F820882088FC8824F8248824882488248824F8248A2402440243FE8000
+65EE:020002003FE0042008223022C01E00001FF0101010101FF0101010101FF01010
+65EF:00001FF0101010101FF0101010101FF0020002007FE00420042008221022601E
+65F0:000000FC7C2044204420442044207DFE44204420442044207C20442000200020
+65F1:1FF0101010101FF0101010101FF000003FF801000100FFFE0100010001000100
+65F2:00001FF0101010101FF0101010101FF001000100FFFE0280044008203018C006
+65F3:004000407C8044FC4504460444047D0444844444444444047C04440400280010
+65F4:000001FC7C2044204420442047FE7C2044204420442044207C20442000A00040
+65F5:00001FF0101010101FF0101010101FF00000010021082108210821083FF80008
+65F6:000800087C08440845FE440844087C0844884448444844087C08440800280010
+65F7:00400020782049FE490049007900490049004900490079004900020002000400
+65F8:000001F87C1044204440448045FE7C9244924492451245227E22444200940108
+65F9:01002108210821083FF80100FFFE00001FF0101010101FF0101010101FF01010
+65FA:000007FC784048404840484078404BFC4840484048407840484000400FFE0000
+65FB:1FF0101010101FF0101010101FF0020001007FFC08200440038004401830E00E
+65FC:004000207C2047FE4488448844887C8844884450445044207C50448801040602
+65FD:0020002078204BFE4820492449247924492449FC4824482078224822001E0000
+65FE:01000100FFFE010021083FF80102010200FE00003FF820083FF820083FF82008
+65FF:008000807C8045FC4520462044207C2047FE4420442044207C20442000200020
+6600:004000407C8044FC4504460444847C4444444414442444447D84440400280010
+6601:0020002078204BFE4820482049FC792449244924492449347928482000200020
+6602:3FF820083FF820083FF800000C0070FC4084408440844C847094408800800080
+6603:00001FF010101FF010101FF000003FFC20802080214021402220441048089006
+6604:0008003C7BC04A004A004A007BF84A884A884A884A507A504A20045004880906
+6605:000003FC7884488848884890489C788449444944492849287A104A2804440182
+6606:00003FF0201020103FF0201020103FF00000208020843E9820E020842684387C
+6607:00001FF010101FF010101FF000000720782008200820FFFE0820102010202020
+6608:002000107C1044FE4482448244827CFE44824480448044807C80450001000200
+6609:004000207C2047FE4480448044807CFC44844484448444847D04450402280410
+660A:00001FF010101FF010101FF0000000003FF801000100FFFE028004401830E00E
+660B:3FF801000200FFFE044008203018C0061FF0101010101FF0101010101FF01010
+660C:1FF0101010101FF0101010101FF000003FF8200820083FF8200820083FF82008
+660D:000001FC7D0445044504450445047DFC45044504450445047D0445FC01040000
+660E:000000FC7C844484448444FC7C844484448444FC7C8444840104010402140408
+660F:00783F80208020803FFC20402822301A20061FF0101010101FF0101010101FF0
+6610:001000907C9044884508450446047DFA44884488448844887D08450802280410
+6611:002000207C5044504488454446227C20440045FC440444087C08441000100020
+6612:01000100790049FC4AA44CA448A4792449244A444C44488479044A0404280010
+6613:0FF0081008100FF0081008100FF0040008001FFC224442440484088411280210
+6614:044004403FF804400440FFFE000000001FF0101010101FF0101010101FF01010
+6615:0004000E7CF044804480448044FE7C8844884488448844887C88450801080208
+6616:00100090789048884888492449247A224C4048404888488479044BFE01020000
+6617:00001FF0101010101FF0101010101FF0020001007FFC00000440082010102008
+6618:00001FF010101FF010101FF002000100FFFE040007F004100810101020A04040
+6619:00001FF010101FF010101FF000003FF800000000FFFE0400082010103FF81008
+661A:01000100FFFE01002288145008203018DFF6101010101FF0101010101FF01010
+661B:000001FE7D004500450045FC45047D044504450445FC45007D00450001FE0000
+661C:00001FF010101FF010101FF00000FFFE08001FF8224844480888110822280410
+661D:104010403E5022485444084017FE2000DFF0101010101FF0101010101FF01010
+661E:000003FE7820482048204BFE7A224A224A524A4A4A8A7B024A020202020A0204
+661F:00001FF010101FF010101FF0010011001FF8210041001FF0010001007FFC0000
+6620:00200020782049FC492449247924492449244BFE482078504850008801040202
+6621:002000107C1045FE4420442044447C8445F84410442044447C8245FE00820000
+6622:002000207D2445244524452445FC7C2044204524452445247D24452401FC0004
+6623:002000207C5044884504461244207C4045884410442044447D88441000600380
+6624:002000207C5044504488452446127C1045FC4404440844887C50442000100010
+6625:010001007FFC01003FF80200FFFE082010102FE8C82608200FE0082008200FE0
+6626:00001FF010101FF010101FF002007FFC044008203458C4460440044008401040
+6627:00200020782049FC4820482048207BFE487048A848A8492479244A2200200020
+6628:01000100790049FE4A804A804C8078F848804880488048FC7880488000800080
+6629:0040004078404FFE4840484048407BFC484048E049504A487C46484000400040
+662A:00001FF010101FF010101FF0082010103FF808280820FFFE0820102020204020
+662B:00800080790049FC4A044C0449E479244924492449E449247804480400280010
+662C:00003FF820083FF820803FFC20402C243014200C1FF010101FF010101FF01010
+662D:000003FC788448844884490449147A084C0049FC490449047904490401FC0104
+662E:00001FF010101FF010101FF0004000407DFC1044104410841C84E10442280410
+662F:1FF0101010101FF0101010101FF00000FFFE0100110011F811002900450083FE
+6630:00001FF010101FF010101FF0000000007FFC0100110011F811001100FFFE0000
+6631:1FF0101010101FF0101010101FF00200010001007FFC0000101008200440FFFE
+6632:0090009078904BFC489448947BFC4A904A904BFE48927892491A011402100410
+6633:004000407A404A404BFC4A404C4078404FFE484048A048A079104A0804040802
+6634:00001FF010101FF010101FF000000C0070FC448444845C846494488810806080
+6635:000001FC79044904490449FC49007940494449484970494079424A42023E0400
+6636:08000400027C3C44044404C4757C164416441544257C248044408430140E0800
+6637:00001FF0101010101FF0101010101FF000003FF82448244824482448FFFE0000
+6638:004000407C7C44844588465044207C5044884706446044107C0844C000200010
+6639:00400020781049E0482248347BB848B048A848A8492879244A24042200A00040
+663A:00001FF010101FF010101FF000007FFC01003FF8210822882448282820082018
+663B:00001FF010101FF010101FF000007CFC10841084108410841E94F08840800080
+663C:00001FF8100810081FF81040102020102FE848268FE008200FE000007FFC0000
+663D:00900088788848804BFE48A048A078A448A44928492849327A224A62049E0800
+663E:00001FF0101010101FF0101010101FF0044044442444144814500440FFFE0000
+663F:00200010781049FE490049107910491049104920492879244A4402FE04420800
+6640:0090009078904A9249944898489079984A944C9248904890791249120212040E
+6641:00001FF0101010101FF0101010101FF0244814500C601450644808421042603E
+6642:002000207C2045FC4420442047FE7C08440845FE440844887C48440800280010
+6643:00001FF010101FF010101FF00100111009200100FFFE0440044008421042603E
+6644:004000447A444948495048404FFE7890489048904890489279124912020E0400
+6645:000003FE7800480049FC4904490479FC4904490449FC49047800480003FE0000
+6646:002000207DFC44204420442047FE7C004420442045FC44207C20442003FE0000
+6647:002000207BFE4850488849047AFA48004BFE4840488079FC4804000400280010
+6648:004000207C2047FE4400448845047E0244884488445044507C20445000880306
+6649:00007FFC0810102024487EFC02040000FFFE00001FF010101FF010101FF01010
+664A:000003FE7840488049104A084BFC7844484048404BFC48407840484007FE0000
+664B:00007FFC0440244814500440FFFE00001FF0101010101FF0101010101FF01010
+664C:0040004078804BFC4A044A044AF47A944A944A944A944AF47A044A0402140208
+664D:000001FE7D024502457A450245027D7A454A454A454A457A7D024502010A0104
+664E:01100110791049104BFC49107910491049104FFE480079104908020804040804
+664F:00001FF010101FF010101FF001007FFC42040200FFFE08201C4003800C707008
+6650:0020001078104BFE48204842488479F84810482248C44B087810482800C40302
+6651:00001FF010101FF010101FF0020004003FF8200827C82448244827C820282010
+6652:000007FE7890489048904BFC4A947A944A944A944A9C4B047A044A0403FC0204
+6653:0080008078BC4BC04850482448D47B0C48004BFE4890489079124912020E0400
+6654:00900094791449184B104D324952790E492048204BFE48207820482000200020
+6655:1FF010101FF010101FF000007FFE42029FF4040009001FF001007FFC01000100
+6656:000003FE7A024C4448404BFC488078A0492049FC482048207BFE482000200020
+6657:0040004078A049104A884C4649F07810482048404BF84A087A084A0803F80208
+6658:000001FC7D0445FC450445FC44007C0045FC4420442047FE7C20442000200020
+6659:00400040788849044BFE4802488879444A4248F849884A507820485001880606
+665A:0080008079F84A084C104BFC4A447A444A444BFC48A048A079224922021E0400
+665B:000003F87A084A084BF84A087A084BF84A084A084BF87920492002220422181E
+665C:00001FF010101FF010101FF004407FF801083FF821003FFC0304051419086100
+665D:01003FF80108FFFE01083FF801007FFC00003FF820083FF820083FF80000FFFE
+665E:01840068783048C84B0448407BFE48A049204BFC4D2479244934012800200020
+665F:1FF010101FF010101FF000883FFC208020883E88225022502A244454418C8604
+6660:00280024782448204BFE4A207A244A244BA44AA84AA87A904A9205AA04460882
+6661:004800447BFE484048404BFC4A447A444BFC4A444A444BFC7A444A4402540208
+6662:080C08F07E8008800EFE788808882908120800001FF010101FF010101FF01010
+6663:0104010E793049204FE04920793E496449A44F24492479244924012405440284
+6664:000003FE7840484049FC488448847BFE4800480049FC49047904490401FC0104
+6665:004000207BFE4A024C0449F8780048004BFE48904890789049120112020E0400
+6666:0100010079FC4A004DF84908494879284FFE49084A484A287BFC480800500020
+6667:00200120792049FC49204A2078204BFE4800480049FC79044904010401FC0104
+6668:1FF010101FF010101FF000003FFC20002FF820003FFE2908289048604A188C06
+6669:0080008079F84A084C104BFC4A447A444A444BFC48A048A079224922021E0400
+666A:0090009078904BFC4A944A944A947BFC4A944A944A944FFE7800489001080204
+666B:00400040787E48404BFC4A044BFC7A044BFC4A4448404FFE7840484000400040
+666C:004000207BFE48004888488849547A22480048204BFE48207820482000200020
+666D:000003FE7A224A224AFA4A227A224BFE4A024AFA4A8A7A8A4AFA0202020A0404
+666E:082004407FFC044024481450FFFE00001FF0101010101FF0101010101FF01010
+666F:1FF010101FF010101FF00100FFFE00001FF0101010101FF00100210845040200
+6670:0200020CF27092409F409240927EF64897489AC89A489248F248924802480288
+6671:0020012279224A24485048887B0448224820492449247A284850008801040602
+6672:000000407B9C4A044A044B9C7A044A044BFC489048907890489001120212040E
+6673:080C08F07E8018802CFE2A884888888809081FF0101010101FF0101010101FF0
+6674:002000207BFE482049FC48204BFE780049FC490449FC490479FC490401140108
+6675:104008403E7E228823503E20205841869FF0101010101FF0101010101FF01010
+6676:0FE0082008200FE0082008200FE000007EFC428442847EFC428442847EFC4284
+6677:1FF010101FF010101FF008401F6022505448084037FEC0001FF0101010101FF0
+6678:1FF010101FF010101FF000207F20043E044427A42428242824102F28F0444082
+6679:01FC010479FC4904490449FC7800490049FE4A4A4C4A789249120222004A0184
+667A:20003E7C48440844FF441444227C40001FF0101010101FF0101010101FF01010
+667B:004000807BFC49104A484C464BF87A484A484BF84A484A487BF848420042003E
+667C:00800040F7FE94029A04920093BCF4A494A496A499349128F22292220422081E
+667D:01100110F110911097BC91109110F33893B8955495549992F110911001100110
+667E:004000207BFE4800480049FC49047904490449FC482048A879244A2200A00040
+667F:00FC00847C8444FC4484448444FC7C0045FE4502450245FE7D02450201FE0102
+6680:0090008879004A7E4C90489049107B104D7E49104910491079104910017E0100
+6681:0020002079FC482048A848887BFE488848004BFE4890789049120112020E0400
+6682:100CFEF0208048807EFE08880E88F9084A081FF8101010101FF0101010101FF0
+6683:00001FF010101FF010101FF004407C7C044004407C7C04400440FC7E04400440
+6684:004000207BFE4A024C0449FC480079FC490449FC490449FC7904480003FE0000
+6685:0100013CF100910091BC95649524F53C952491249124913CF1249100017E0100
+6686:02100110F11097BE9228924893AAF2AE92BA92EA92AE92A8F4AA94A209A2101E
+6687:000007BCF4849484948497BC9400F40097BC9424942497A8F410942804440482
+6688:1FF010101FF010107FFC41043FF801001FF011101FF011101FF00100FFFE0100
+6689:000003FE7A2248204BFE482079FC492449FC492449FC78204BFE002000200020
+668A:000003FE7C20444045FC450445047DFC450445FC450445047DFC440000880104
+668B:00207F20413E7F4448A47F2448284510532861461FF010101FF010101FF01010
+668C:001003D478584A52498C488849047AFA482048204BFE48207850488801040202
+668D:000001FC7D0445FC450445FC44807DFE46224522455245027DFA440200140008
+668E:008800887BFE488848A8482049FC7924492449244BFE48207850488801040202
+668F:004000447BF4484848504FFE4840788049F84B084D0849F87908490801F80108
+6690:0040004079FC48844BFE480049FC790449FC48204BFE48207A204BFE00200020
+6691:1FF010101FF010101FF002001FD00220FFFE03000FF03810CFF008100FF00810
+6692:000001FC790449FC490449FC7820492049FE4A20482079FC4820002003FE0000
+6693:00407F40127E0C88FF4819482A504820A850108C1FF010101FF010101FF01010
+6694:002000207BFE482048204BFE7A8A4A524AFA4A224A227AFA4A220222022A0204
+6695:002000207BFE482049FC492479AC4974492449FC4820787048A8012402220020
+6696:003C07C07A44492848004BFC788048804FFE490049F87A884A50042008D80306
+6697:008000407BFC4800490848904FFE780049F84908490849F87908490801F80108
+6698:000001F8790849F8490849F878004BFE490049FC4A547C944924024400A80110
+6699:00400040F7FC904093F8908097FCF110920895F691109110F1F09110011001F0
+669A:0008003C7BC048044A44492879FC4A2048204BFE482079244924012401FC0004
+669B:0108008878904BFC484049F848407BFE4880490049FC4A207C20482003FE0000
+669C:20201010FEFE00004444242428280EFEF00000001FF010101FF010101FF01010
+669D:000003FE7A02480049FC490449FC790449FC484048204BFE7800488801040202
+669E:0020004079FC490449FC490479FC490449FC48204BFE787048A8012402220020
+669F:002001247924492449FC48007BFE480049FC4904490479FC4888005003FE0000
+66A0:1FF010101FF010101FF00100FFFE10101FF000007FFC40044FE448244FE4400C
+66A1:0090008879044A424C8849FC780448004BDE48424A52794A4A520042014A0084
+66A2:100011F811087DF8550855F87C0057FE550055FC7E5454941124124410A81110
+66A3:0100010079FC4A004DF848007BF848884AA849C84FF8788A49CA06AA00860082
+66A4:0020004079FC490449FC490479FC48404BFE488849247A224DFC002000200020
+66A5:000001FC790449FC490449FC78204BFE4A0248404BFE78884990006000980304
+66A6:00003FFE221022103FBE27182AB432522210200027F8240827F8440847F88408
+66A7:000E03F078444A2449084BFE7A4248404BFE488048FC79444928021004680186
+66A8:7DFC44207D2045FE7C5048525492650E1FF010101FF010101FF00000FFFE0000
+66A9:010001107BDC4A544D544A8879084AF44C0248004BFC78404950024805440080
+66AA:008800887BFE4888488848F878204BFE4A224B324AAA7B764A220222022A0224
+66AB:08047F7808407F40497E7F4849487F4808487F4808881FF010101FF010101FF0
+66AC:08203E2008F87F282228496A3E2A08567E8200001FF010101FF010101FF01010
+66AD:0020004079FC490449FC490449FC7820492448A8492448207BFE482000200020
+66AE:04407FFC04401FF010101FF010101FF00400FFFE10102FE8C8260FE008200FE0
+66AF:008800887BFE4888480049FC790449FC490449FC48207BFE4850008801040202
+66B0:01240124F22494249954914A9292F6109A109250925C9250F25092B0029E0300
+66B1:000003FE7A484A484BFE4A487A204BFE4A404AFC4B447A444A7C020003FE0000
+66B2:002001FC788848504BFE480049FC790449FC490449FC48207BFE482000200020
+66B3:008803DE788849DC48884BDE788848004BFC4804480479FC4804000403FC0004
+66B4:1FF010101FF010101FF008207FFC0820FFFE08203118C9260540092015102208
+66B5:008800887BFE488848F8482079FC492449FC482049FC78204BFE005000880306
+66B6:02100110F11097BE9240920093BEF28A928892A892AE92A8F4A895A8085E1080
+66B7:002003FE782049FC492449FC792449FC48224BFE48087BFE4908008800280010
+66B8:00400040F7FC90A09514920897FCFA0A93F8920893F89040F248944409440080
+66B9:07F8440827F8240807F80240E7FC2C4037F8244027F8244027FC54008FFE0000
+66BA:000003DE7A524A524BDE480079FC492449FC492449FC78204BFE002000200020
+66BB:000001FC790449FC490449FC78204BFE480049FC490479FC4820012402220060
+66BC:49202A3E7F4849485DA86B10492841461FF0101010101FF0101010101FF01010
+66BD:0020012478A84BFE48A849244A227904490449DE4A444D54789E490402040404
+66BE:02080108F7C89010979E949497A4F01497949094911491C8F708911405240242
+66BF:002003FE782049FC480049FC790449FC48884BFE480079FC4904010401FC0104
+66C0:002003FE782049FC48004BFE7A0249FC480049FC490479FC4904008803FE0000
+66C1:10007EFC42107E9042FE7E3040507C92410E5FF070101FF010101FF00000FFFE
+66C2:0088008879FC488848884BFE782049FC492449FC492479FC4800008801040202
+66C3:00100210797C481448FE48144B7C799249544938495449927930490002FE0400
+66C4:008803FE7888480049FC48A848A87BFE48A848A849FC48207BFE482000200020
+66C5:1FF010101FF010101FF004407FFC04403FF809207FFC09203FF801007FFC0100
+66C6:3FFE2000218C2E7022103FBE27182AB43252221027F8240847F8440887F80408
+66C7:1FF010101FF010103FF801007FFE41029D7400003FF80000FFFE10103FF80008
+66C8:002001FC788848504BFE480079FC492449FC492449FC782049FC002003FE0000
+66C9:0020002079FC48204BFE49087B9C490849884E3E48007BFE489000900112020E
+66CA:009007FC78944BFC4A904BFE79124BFA4D0E49F8490879F8490801F800900108
+66CB:000003FE78504BFE4A524BFE780049FC490449FC490479FC482003FE00200020
+66CC:00F87C8844F87C8844F87C8802A801107FFC482410102FE8010001007FFC0000
+66CD:004001FC790449FC490449FC790449FC4820492448A87924482003FE00200020
+66CE:000001FC795449FC482049FC78204BFE4888485049FC78204BFE002000200020
+66CF:1FF010101FF010101FF0210027DE545297D4E458245457D29512F49A25544610
+66D0:0FE008200FE008200FE07C7C44447C7C44447D7C11001FF821005FF00100FFFE
+66D1:1FF010101FF010107FFC44447C7C44447D7C06C01930E64E01800E2000C01F00
+66D2:01080208F7C8945097DE946497D4F214911497D4921493C8F2489454055408A2
+66D3:3FF820083FF820083FF811101FF041047FFC0200FFFE09203FF8C5460BA01110
+66D4:02880288F7E89290941E97E49454F8549754955495549748F548905402940122
+66D5:010001F87A084FFE4A884B247BFE4A004AFC4A004AFC7A004AFC048404FC0884
+66D6:003C03C0F0449224910897FE9442F2A4928A947A908090F8F10892900060079E
+66D7:00500252795448504BFE488878504BFE482049FC48207BFE48A8012406220020
+66D8:000001FC78204BFE4A2249AC782049AC48004BFE482079FC495401540154010C
+66D9:000003FE7A524A524BFE482449FC78284BFE482048FC49847AFC488400FC0084
+66DA:011007FCF11097FC940493F89000F7FC9080914496A89170F6A8912606A00040
+66DB:003C07C0F0409FFE904097FC9554F4E497FC904097FC9040FFFE900005240892
+66DC:000007BCF08494A4929494A49120F21097FC9A2093FC9220F3FC922003FE0200
+66DD:03F80208F3F8920893F8911097FCF1109FFE911092489554F0E09150024800C0
+66DE:000003FE7A484BFE4A484AFC7AA44AFC4AA44AFC4A207BFE4B2A057A050A0906
+66DF:1FF010101FF010107FFC44447C7C44447FFC20002FF820003FFC24484430860E
+66E0:00400020F7FE948895FC948897FEF42095FC952495FC9524F5FC940004880904
+66E1:0FE008200FE008200FE07C7C44447C7C4444FFFE90121FF010101FF01010FFFE
+66E2:004000207BFE4A2249FC48507A8A49FC4A8A48F8488878F84820012402A20040
+66E3:01100110F7FC911091F0920892EAF6AC92A892AA96EA9A06F00092A402520452
+66E4:07FC0040F7FE94429B5C9040975CF12093FC96209BFC9220F3FC922003FE0200
+66E5:0040007C78404BFC4A444BF07A444AFC4AA84AF84AA87AF84A0005FC05540BFE
+66E6:011007FCF04093F8904097FC9000F3D4911297FE93509534F38C908A02960102
+66E7:3FF820083FF820083FF800107F1000FE3E9222923EFE00107F1455127FFE4902
+66E8:02100110F7DE9010945E928297DEF01097DE945097DE9450F7DE9450045204CE
+66E9:1FF010101FF010101FF00100FFFE22883EF804403FF80440FFFE04901C60671C
+66EA:000003FEF252925293FE91089154F25E97B4911E925497DEF0149554055E0010
+66EB:210447C88812F3BC20084B92F83E0380AAAAABAA00001FF010101FF010101FF0
+66EC:0FBE0000F7BC94A496B494A49040F7FE94A097FC94A497FCF51299DC091211CE
+66ED:02480150F7FC940491F0911097FCF55494E497FC904097FCF0409FFE02A40452
+66EE:07BC04A4F7BC900097FE94009590F49E97D4956495D49554F5D495680BC81054
+66EF:03FE02027BFE4A924A544A927AFE4AAA4AFE4B224AFA7AAA4AFA022205FA0004
+66F0:000000007FFC40044004400440047FE440044004400440047FFC400400000000
+66F1:00003FF82008200820083FF82108210821083FF8210801000100010001000100
+66F2:04400440044004407FFC44444444444444447FFC44444444444444447FFC4004
+66F3:0100010001003FF8210821083FF8210821083FF8009000A0004201A20E1AF006
+66F4:0000FFFE010001003FF8210821083FF8210821083FF811000A00060019C0E03E
+66F5:0120011001003FF8210821083FF8210821083FF8009000A0004201A20E1AF006
+66F6:080008001FF8224844480888112822101FF0101010101FF0101010101FF01010
+66F7:00001FF010101FF010101FF0080008001FFC21045284944410041F8400280010
+66F8:01003FF00110FFFE01103FF001003FF80100FFFE00001FF010101FF010101FF0
+66F9:04400440FFFE04403FF824483FF824483FF800001FF010101FF010101FF01010
+66FA:01000100FFFE01003FF821083FF821083FF800001FF010101FF010101FF01010
+66FB:1FF010101FF010101FF00000101010103EFC4210A490149008FE101020104010
+66FC:00001FF010101FF010101FF000007FFC44447FFC00003FF0082007C01830E00E
+66FD:082004403FF821083FF821083FF800001FF0101010101FF0101010101FF01010
+66FE:082004403FF82108292825483FF800001FF0101010101FF0101010101FF01010
+66FF:082008207EFC0820FEFE1450228841069FF0101010101FF0101010101FF01010
+6700:1FF010101FF010101FF00000FFFE22003EF822883E9022502F20F25042880306
+6701:3E7C081048907EFC1428244A468600001FF0101010101FF0101010101FF01010
+6702:1FF010101FF010101FF00000FFFE22203E2022FC3E2422242F24F24442540288
+6703:010002800C6037D8C0063FF8292825483FF800001FF010101FF010101FF01010
+6704:1020102013FE7C2055FC55247DAC5574552455FC7C20547010A8112412221020
+6705:100011FC11047DFC110411FC1080FDFE122211222152290245FAFC0244140008
+6706:444024402840FE7E92AAD72ABA2A924AFE4A00927D1244227C2244427C944408
+6707:1010282044FEBA920092FEFE9292D69292FEFE2800487DFE44087C0844087C08
+6708:07FC040404040404040407FC04040404040407FC040404040804080410142008
+6709:02000200FFFE040004000FF0081018102FF0481088100FF00810081008500820
+670A:0000780049FC4800480078004BFE489048907890489048904892491249129A0E
+670B:00003E7C2244224422443E7C2244224422443E7C22442244224442844A948508
+670C:00103C502450245024883C88250426FA24483C48244824482488448855288A10
+670D:00003EFC2284228422943E88228022FC22A43EA422A822A8229042A84AC48482
+670E:00203C202450245024883D242612241025FC3C04240824882450442054108810
+670F:00203C202524252425243D2425FC242024203D24252425242524452455FC8804
+6710:00803C80250025FC26043C0425E4252425243D2425E425242404440454288810
+6711:00487A484A484A484A487FFE4A484A484A487A484A784A004A004A004BFE9800
+6712:00203C20242025FC25243D242554258C25243D242554258C2504450455148908
+6713:00503C502450255224D43C582450245824D43D52265024502492449255128A0E
+6714:4200227C2444FF440844087C4944494449447F7C094410441084208441148208
+6715:00883C482450240025FC3C202420242027FE3C20245024502488448855048A02
+6716:00403C2025FC250425043DFC2504250425FC3D20252225142508454455828900
+6717:1000087C7E44424442447E7C424442447E44407C484444445A84628441140208
+6718:00407840488849044BFE7802488849444A4278F849884A504820485049889E06
+6719:0000FE7C8244AA44A644C67C8244BA44AA44AA7CAA44AA44FE84828401140208
+671A:02000100FFFE100010001FF800007CFC448444FC7C8444FC44847C8401140208
+671B:1000087CFF44207C2044267C3844209401087FFC010001003FF801000100FFFE
+671C:00403C2027FE240025FC3D0425FC240025FC3C08241027FE2420442054A08840
+671D:0800083EFFA208227F22413E7F2241227F22493E0822FFA208420842088A0904
+671E:08207FFC08200FE008200FE00820FFFE10102FE8C8260FE008200FE008200860
+671F:2200227C7F44224422443E7C224422443E44227C2244FF440484228441148208
+6720:008878884BFE488848A8782049FC4924492479244BFE48204850488849049A02
+6721:000078884A524A224A527A8A4A024BFE488879444A7A48884950482048D89B06
+6722:00007F7C48447E7C42447E7C48447F5400887FFC01003FF801000100FFFE0000
+6723:00203DFC2488245027FE3C0025FC252425FC3D2425FC242025FC442057FE8800
+6724:3E7C22443E7C22443E7C22444A9485083E7C22443E7C22443E7C22444A948508
+6725:00887AAA4ADC4C8849547A2248004BFE4A427C444BFC48444844488449149A08
+6726:00887BFE48884BFE4A0279FC48004BFE484078A24B5448B84B5448924B509820
+6727:011078904BDE48104A5E79824BDE48104BDE7A504BDE4A504BDE4A504A529ACE
+6728:01000100010001007FFC03800540054009201110210841048102010001000100
+6729:0100010001000100FFFE01000100092009101108110821044104810405000200
+672A:0100010001003FF8010001000100FFFE03800540092011102108C10601000100
+672B:010001000100FFFE0100010001007FFC03800540092011102108C10601000100
+672C:01000100010001007FFC0380054005400920111021084FE48102010001000100
+672D:0880088008800880FE80088018801C802A802A804880888408840884087C0800
+672E:0100012001100100FFFE01000920092009200920112011202120411E81000100
+672F:01000120011001107FFC03800540054009201110210841048102010001000100
+6730:010001007FFC0380054009203118C1063FF80010006003801C0420041FFC0000
+6731:0100110011001FF8210041000100FFFE03800540092011102108C10601000100
+6732:1040104010401040FC4010403040384054A054A090A011101110120814041802
+6733:1000102011201120FD2011203120392055205110911012101208140818041002
+6734:0840084008400840FE40085018481C442A442A40484088400840084008400840
+6735:00000FE00820082008201020201EC10001007FFC0380054009203118C1060100
+6736:00003FF008100820083C10041004201441080100FFFE054009203118C1060100
+6737:0800080009FC0844FE44084418441C442A442A44484488840884090409280A10
+6738:1040104010401040FDFC10443044384454445484908410841104110412281410
+6739:1080108010801080FDF0109030903890549054909090109211121112120E1400
+673A:100011F011101110FD10111031103910551055109110111211121212120E1400
+673B:0804080408840884FE84088418841C842A8C2AB448C488840804080408040804
+673C:0880088008800884FE88089018A01CC02A802A804880888408840884087C0800
+673D:100013FE10401040FC801080310039FC54045004900410041004100410281010
+673E:080008000BFE0820FE20082018201C202A202A20482088200820082008A00840
+673F:01000100FFFE010001003FF821082108210821282390054009203118C1060100
+6740:00081810066001800660181861040100FFFE0100112011102108210445040200
+6741:0880084008400820FE20082018201C502A502A50484888880888088409040A02
+6742:020002003FE0042004220822111E61000100FFFE010009201110210845040200
+6743:100013FC11041104FD0410883088388854505450902010201050108811041602
+6744:1008103C11E01020FC20102030203BFE54205420902010201020102010201020
+6745:100011FC10201020FC20102030203BFE54205420902010201020102010A01040
+6746:100011FC10201020FC20102030203BFE54205420902010201020102010201020
+6747:100011FC10001000FC0013FE30403840548054FC900410041004100410281010
+6748:100013FC11041144FD2410A83088388854505450902010201050108811041602
+6749:0804080408080810FE20084418041C082A102A224842880408080810082008C0
+674A:1104112411241124FD2411243124392455245124912411241124122412041404
+674B:100011F011101110FD10111031903950555055109110111211121212120E1400
+674C:1000100013FC1090FC90109030903890549054909090109211121112120E1400
+674D:100011FC10041008FC10102030203BFE54205420902010201020102010A01040
+674E:010001007FFC0380054009203118C1060FE000400080FFFE0100010005000200
+674F:010001007FFC0380054009203118C10600001FF010101010101010101FF01010
+6750:0808080808080808FEFE080818181C182A282A28484888880808080808280810
+6751:1010101010101010FDFE10103010381055105490909010101010101010501020
+6752:1000100011FC1044FC4411443944354452445044908410841104110412281410
+6753:10401040108010FCFD0412043004390454845444904410041004100410281010
+6754:1008103C13C01040FC4010403840347E53C050409040104210421042103E1000
+6755:0820082008200820FE2009FE18201C202A202A50485088500888088809040A02
+6756:1010101010101010FDFE10103010391055105490909010501020105011881606
+6757:02000100FFFE1000100010001FF801000100FFFE0380054009203118C1060100
+6758:00003FFC200420043FFC2000208020803FFE21C022A024902888508640808080
+6759:0848084408440840FE5E09E018401C402A402A40482088220812080A08060802
+675A:10401040108010FEFD00120030FC380854105420904010801102110210FE1000
+675B:100011FC10041004FC0410FC30803880550055FC900410041004100410281010
+675C:1020102010201020FC20102033FE382054205420902010201020102017FE1000
+675D:1020102010201120FD2C113431643BA455245534912811221122110210FE1000
+675E:1000100011F81008FC081008300839F855085500910011001102110210FE1000
+675F:01000100FFFE010001003FF82108210821083FF82388054009203118C1060100
+6760:1000100011FC1020FC2010203020382054205420902010201020102013FE1000
+6761:040004000FF01820644003801D70E10E01007FFC010009201110210845040200
+6762:010001007FFC0380054009203118C10600003FF80100010001000100FFFE0000
+6763:1020102010201020FD241124312439245524552491241124112411FC10041000
+6764:1000100013FE1080FC80108030FC388454845484910411041204120414281810
+6765:0100010001007FFC0100111009100920FFFE0380054009203118C10601000100
+6766:10801080108010F8FD08110831103A1054205020905010501088110812041402
+6767:1020101010101000FDFE10803080388054805480908010801080108010FC1000
+6768:100011F810101020FC40108031FE389254925492911211221222144210941108
+6769:100013F010101010FD101110311039FC54045404900413F41004100410281010
+676A:10201020102010A8FCA410A23122392056245424902810081010102010C01300
+676B:0810081008100890FE900890189E1C902A902A9048908890089008900BFE0800
+676C:100011FC10001000FC0013FE30903890549054909090109211121112120E1400
+676D:10801040104013FCFC00100031F03910551055109110111211121212120E1400
+676E:10201020102013FEFC20102031FC392455245524912411341128102010201020
+676F:1000100013FE1020FC201040384034D051485244944410401040104010401040
+6770:0100010001007FFC03800540092011102108C106010000002488224442448004
+6771:01000100FFFE010001003FF821083FF821083FF82388054009203118C1060100
+6772:1FF0101010101FF0101010101FF0010001007FFC0380054009203118C1060100
+6773:010001007FFC0380054009203118C1061FF0101010101FF0101010101FF01010
+6774:084008400840087CFE84088819201C202A202A50485088500888088809040A02
+6775:10801080108011FCFD2012203020382057FE5420902010201020102010201020
+6776:10201020102013FEFC20112431243924552455FC9024102010221022101E1000
+6777:100011FC11241124FD241124312439FC55045500910011001102110210FE1000
+6778:100010F810881088FC881106320039FC54845484904810501020105010881306
+6779:10A010A010A01124FD24132835303920556051A09120112211221122111E1100
+677A:1000104010201010FC90108030803A8456825282928214881088108810781000
+677B:080009F808480848FE48084818481DF82A882A8848888888088808880BFE0800
+677C:100011F810081050FC20101033FE382254245420902010201020102010A01040
+677D:1008103C11E01020FC2011FC38203420502053FE902010201020102010A01040
+677E:1010109010901088FC88112431243A225440544090881084110413FE11021000
+677F:1008101C11E01100FD0011FC3144394455445528912811101110122812441482
+6780:04400440082010102208C44608201FF001100100FFFE054009203118C1060100
+6781:100013FC10841088FC881090309C388455445544912811281210122814441182
+6782:080008FC08840884FE8408FC18841C842A842AFC488488840884088409140A08
+6783:10401040108010FCFD0412043084384454445414902410441184100410281010
+6784:10801080108010FCFD04110432443844548454A4911411F41014100410281010
+6785:100011FC10881088FC88108830883BFE54885088908810881088110811081208
+6786:1008103C11E01020FC20103C31E038205420503E93E01020102210221022101E
+6787:1010111011101112FD12111431D83910551055109110111211521192110E1000
+6788:208020843E9820E020842684387C21000100FFFE0380054009203118C1060100
+6789:1000100013FE1020FC2010203020382055FC5020902010201020102017FE1000
+678A:10001040119E1112FD1211123112391255125512915A11941110101010101010
+678B:10401020102013FEFC801080308038FC54845484908410841104110412281410
+678C:1010109010901088FD0811043A0435FA50885088908810881108110812281410
+678D:1090109011081108FA04140233FC3880550051F8900810081008100810501020
+678E:1020102010201020FDFC10203020382057FE5420905010501088108811041202
+678F:100011F811081108FD0813FE31083908550853FE910811081108110811281110
+6790:1008101C11E01100FD00110031FE391055105110911011101110121012101410
+6791:100017FE10801080FC8010F8390835085108520893F810101010101017FE1000
+6792:080009FE08080888FE88088819081DFE2A182A284848888809080A0808280810
+6793:0808088808480848FE08088818481C482A082A0E49F888080808080808080808
+6794:1020102010501050FC88114432223820540055FC900410081008101010101020
+6795:10401040104013FCFA4414483040384054A050A090A0112011221222141E1800
+6796:0808083C09E00820FE20082019FE1C202A202A50485088500888088809040A02
+6797:1020102010201020FDFE10203070387054A850A8912412221420102010201020
+6798:10201020102011FEFD221122312239225552554A918A110211021102110A1104
+6799:100011FE11001100FD78114831483948554855689150114211421142123E1400
+679A:1040104010401080FCFE11083288388854885450905010201050108811041202
+679B:1008101C11F01150FD5011503150395055505548914811481144124412421400
+679C:00001FF0111011101FF0111011101FF011100100FFFE054009203118C1060100
+679D:10201020102013FEFC201020302039FC54845488904810501020105011881606
+679E:1110111011101110FD10111031103910551052A8926812281444144418841102
+679F:1000100011FC1000FC00100033FE38205420544090401088110413FE11021000
+67A0:1040104011F81048FC88108A310A3A265420502093FE10201020102010201020
+67A1:1008106813881088FC88108830883BFE54885488908810881108110812081408
+67A2:100013FC12001208FE88125032503A2056205250925012881308120013FE1000
+67A3:01000100FFFE01003FF821082388254809203018C606018000400E0001800040
+67A4:0820082808240824FE2009FE18201C202A202A50485088500888088809040A02
+67A5:200023FE22002220FA20222022FC72246A24A224A24422442484248429283210
+67A6:10401020102011FCFD041104310439FC55045500910011001100120012001400
+67A7:100011FC11041104FD241124312439245524555490501090109011121212140E
+67A8:1080108410841088FC9010A030803BFE54A0549090901088108410A210C01080
+67A9:010001007FFC052009103108C5440440082011102108C206044008201FF00010
+67AA:1040104010A010A0FD101208340639F055105110915011201104110410FC1000
+67AB:200023F822082208FB2822A822A872486A48A2A8A2A8232A240A240A28063002
+67AC:100011F811081108FD4811283928350853FE5108910811081108120812281410
+67AD:010002001FF010101210115010201FFC010401047FF4038805401930E10E0100
+67AE:0810081008100810FE1E081018101C102AFE2A82488288820882088208FE0882
+67AF:1020102010201020FDFE10203020382055FC5504910411041104110411FC1104
+67B0:100011FC10201020FD2410A430A8382057FE5420902010201020102010201020
+67B1:0820082008200840FE48088419FE1C822A002AFC488488840884088408FC0884
+67B2:0400080010103FF800081FF0101010101FF00100FFFE054009203118C1060100
+67B3:1000100011FC1104FD0411043104390455FC5504900010901088110412021402
+67B4:100011F811081108FD0811F83000380057FC5444904410841084110412281410
+67B5:100011F811081108FD0811F830003BFE5480550091F810081008100810501020
+67B6:080008007F7C094411441144257C420001000100FFFE054009203118C1060100
+67B7:220022002200FA1E27D2225272526A52AA52A252225222522452245E29523080
+67B8:10801080108011FCFD04120431E4392455245524912411E41124100410281010
+67B9:1080108011FC1104FA0415F431143914551451F4910411281112110210FE1000
+67BA:10201020102013FEFC201020302039FC547054A890A811241124122210201020
+67BB:1048114811481148FD4813FE3148394855485548917811001100110011FE1000
+67BC:12201220FFFE1220122013E010001FF801000100FFFE054009203118C1060100
+67BD:010001007FFC01001010FFFE101010101FF00100FFFE054009203118C1060100
+67BE:10201020102013FEFC20102031243924552455FC912411241224122414241020
+67BF:10201020102013FEFC20102038A83488508857FE908810881108110812081408
+67C0:10101010101011FEFD121114311039FC55445544912811281110122812441482
+67C1:10201010101011FEFD02120430803888549054A090C0108210821082107E1000
+67C2:1080108010FE1100FA201120312C397457A45124913411281122110210FE1000
+67C3:1020102010501050FC8811243212381055FC5404900810881050102010101010
+67C4:100013FE10201020FC2013FE32223A225652524A928A130212021202120A1204
+67C5:100011FC11041104FD0411FC31003940554455489170114011421242123E1400
+67C6:1040102010201000FDFE10003004388454845448904810481050101013FE1000
+67C7:103811C010401040FC4013FC304038E054E05550915012481444184210401040
+67C8:10201020112410A4FCA8102031FC38205420542093FE10201020102010201020
+67C9:0804081E09E00800FE20081019FE1C042A082A1048208840088009400A3E0800
+67CA:10401040107C1084FD881250302038505488530690601010100810C010201010
+67CB:089008881080309E57E0908010441034110C0100FFFE054009203118C1060100
+67CC:100011FC10041004FDF41004300439F45514551491F411141004100410281010
+67CD:10201020102011FCFD24112431243924552453FE902010501050108811041202
+67CE:1088108810881108FD7E13083508394855285528910811081108110811281110
+67CF:10201020104011FCFD0411043104390455FC5504910411041104110411FC1104
+67D0:08200820FFFE082008200FE0082008200FE00100FFFE054009203118C1060100
+67D1:1088108810881088FDFE108830883888548854F8908810881088108810F81088
+67D2:20801080009C47E0208008841084607C21000100FFFE054009203118C1060100
+67D3:2080108003F04090211009121212640E29000100FFFE054009203118C1060100
+67D4:00001FF0022001407FFC04841888628001000100FFFE054009203118C1060100
+67D5:100011F810081050FC20101033FE386254A454A0912012201420102010A01040
+67D6:100013FC10841084FC84110431143A08540051FC910411041104110411FC1104
+67D7:1010109010901108FD081204340239F855085508910811081108110811F81108
+67D8:1000100013FE1020FC201040304038FC55845284948410841084108410FC1084
+67D9:100011FC11241124FD2411FC31243924552455FC912410201020102010201020
+67DA:1020102010201020FDFC112431243924552455FC912411241124112411FC1104
+67DB:10201020102011FCFD241124312439FC55245524912411FC1124102010201020
+67DC:100011FE11001100FD0011FC310439045504550491FC11001100110011FE1000
+67DD:1008101C11E01100FD00110031FE391055105530911811141112121012101410
+67DE:10801080108010FEFD4011403240387C544050409040107E1040104010401040
+67DF:10201020102011FCFD24112431FC39245524552493FE11041104110411141108
+67E0:20402020202023FEFA022404200070006BFEA020A02020202020202020A02040
+67E1:100011FC10001000FBFE10003020382257B250B490A811281124122414A21040
+67E2:1008103C13E01220FE20122032203BFE5620521092101212120A128A13261212
+67E3:1020102011201120FDFC11203220382057FE5420905010501088108811041202
+67E4:100011F811081108FD0811F831083908550855F8910811081108110817FE1000
+67E5:01000100FFFE0540092011103FF8D01610101FF0101010101FF00000FFFE0000
+67E6:0800080008FC0884FE84088418FC1C842A842A8448FC88840800080009FE0800
+67E7:1008101C11F01150FD5011503150395055505548914811681154127412521400
+67E8:10401040104013FEFC8010A0392035FC53245524912411241134112810201020
+67E9:100013FC12001240FE40127832883A9057105220925012881304120013FE1000
+67EA:1010109010901110FD7E12523392389255125112925213D210621022104A1084
+67EB:10901090109013FCFC94109433FC3A90569053FE90921092111A111412101410
+67EC:01000100FFFE010001003FF82108292825483FF82388054009203118C1060100
+67ED:1050104810481040FBFE1080308038FC55445144912811281210122814441182
+67EE:1020102011241124FD24112431FC382054205524912411241124112411FC1004
+67EF:1000100017FE1008FC0813C832483A485648524893C812481008100810281010
+67F0:010001007FFC054009203118CFE6000000007FFC010011101108210445040200
+67F1:10401020100013FEFC2010203020382055FC5420902010201020102013FE1000
+67F2:1000104010201028FC08108830903A9456A252A294C210881188128814781000
+67F3:10001080131E1252FE52125232523A52565252D2935A12541090109011101210
+67F4:0880088828902EA028C028842E84F07C01000100FFFE054009203118C1060100
+67F5:100011FC11541154FD54115431543BFE55545554915411541154114411141108
+67F6:1000100013FE1252FE52125232523A525652528E92821302120213FE12021000
+67F7:100011FC11041104FD04110431FC3850545054509050109210921112120E1400
+67F8:100011FE10101010FC201020306838A455225222902010201020100013FE1000
+67F9:10201020102E11F0FD201120312039FE5422546290A2112A1624102010201020
+67FA:100011FC11041104FD0411FC3040384055FC5444904410841084110412281410
+67FB:010001007FFC054009203118C1061FF010101FF010101FF010101010FFFE0000
+67FC:10401020102013FEFA0214043000389054905090908811081108110412041402
+67FD:100011FC10841088FC501020305038885726502091FC10201020102013FE1000
+67FE:1000100013FE1020FC20102031203920553C5520912011201120112017FE1000
+67FF:10401020100013FEFC20102031FC392455245524912411241134112810201020
+6800:101C11E011001100FDFE11003100397C554455449154114811421242123E1400
+6801:21002100211E21D2FA522252225275526892A092A11A21142210241028102010
+6802:100010FC108410A4FC94108430843BFE550455449124110411FE100410281010
+6803:1008101C11E01100FD0011FE31203920553C5524912411241124124412541488
+6804:22081108111000207FFE4002810401007FFC03800540092011102108C1060100
+6805:100011DC11541154FD54115431543BFE5554515491541154115412D41224144C
+6806:010001007FFC01003FF8210821083FF80280044008203318C0C6060001800040
+6807:100011FC10001000FC0013FE3020382055285524922412221422102010A01040
+6808:105010481040105CFDE01040305E39E054445048903010221052108A13061002
+6809:1088108813FE1088FC88100033FE3842544254429042104A1044104010401040
+680A:1090108810881080FBFE10A030A038A454A451289128113212221262149E1800
+680B:10401040104017FEF880112031203A2057FC5020912811241222142210A01040
+680C:10201020103E1020FC2011FC31043904550455FC910411001100120012001400
+680D:1020102011201120FDFC112032203820542055FC902010201020102013FE1000
+680E:1008103C13C01200FE20122032203BFE54205420912811241222142210A01040
+680F:1000110810881090FC0013FE30003800540055FC900010001000100013FE1000
+6810:10401020101011E0FC22103433B838B054A854A8912811241224142210A01040
+6811:2004200427842084F8BE2484228472A46914A114A28422842484280420142008
+6812:1080108011FC1104FE0411E43124392455E45524912411E41104100410281010
+6813:1020102010501088FD04120231FC38205420502091FC10201020102013FE1000
+6814:080008007F7C08243E2408447F54088809000100FFFE054009203118C1060100
+6815:100011FE11201120FD2011FC310439045504550491FC11201120112011FE1000
+6816:100017FE10901090FC9013FC32943A9456945294929C13041204120413FC1204
+6817:00007FFC044004403FF8244824483FF801000100FFFE054009203118C1060100
+6818:10201020107C1084FD481030302038485590543E904211A41018101010601180
+6819:2080208020FC2108FA902060219876266820A1FCA020222023FE202020202020
+681A:1088104810501000FDFC10203020382055FE5420905010501088108811041202
+681B:1040104011FC1044FC84108431283A10550853DE914A114A114A1252135A14A4
+681C:1020102013FE1020FC2011FC312439245524552C907010A81124162210201020
+681D:1008103C11E01020FC2013FE30203820542055FC910411041104110411FC1104
+681E:00007EFC08200820FEFE08201020202041200100FFFE054009203118C1060100
+681F:1104108410881000FDFE108830883888548853FE908810881108110812081408
+6820:083813C03040504097FC1040104013F800000100FFFE054009203118C1060100
+6821:10401020102011FEFC00108831043A0254885088905010501020105010881306
+6822:100013FE10201020FC4011FC31043904550455FC910411041104110411FC1104
+6823:10801088109C1170FD1013103510391055FE55109110111011101110117C1100
+6824:2020242022202220F83221B220B472A86AA8A4A8A52429242A22202020A02040
+6825:0100410021FC0A441448E0A02110260801000100FFFE054009203118C1060100
+6826:1082109210921092FC92109232DA3AB654925092909210921092111211021202
+6827:1020102011FC1124FD2411FC3124392455FC542090241018103210CA13061002
+6828:101010101210113EFD2210443810349050905310912811281128114410441082
+6829:100013DE10421042FE52114A314A384254C6514A9252104210421042114A1084
+682A:10201120112011FCFD20122030203BFE547054A890A811241124122210201020
+682B:10401040104017FEF8801080317C39085710551091FE11101110111011501120
+682C:1040104010F81108FA1011FC31243924552451FC910011001102110210FE1000
+682D:100013FE10201020FC4011FC3154395455545554915411541154114411141108
+682E:100013FE11081108FD0811F83108390855F855089108111E17E8100810081008
+682F:1040104017FE1080FD0013FC3504390455FC5504910411FC1104110411141108
+6830:10A810A410A41120FD2E13F03520392455245524912811101132114A11861102
+6831:1088108810881088FDFE108830883888548853FE900010881084110412021402
+6832:1040104411F41048FC5013FE3040388055FE5240948010FC1004100410281010
+6833:10401040104411F4FC48105033FE384054805584929814E010821082107E1000
+6834:1080108010FE1100FA0010FC308438A45494508493FE10841084110411141208
+6835:1002100217E2110AF90A11EA312A3A2A572A52AA944A104A10821102120A1404
+6836:100013FC12041244FE44124433FC3A44564452A4929413141204120413FC1204
+6837:1104108410881000FBFE1020302039FC5420502093FE10201020102010201020
+6838:10201010101013FEFC201042308439F85410542290C413081010102810C41302
+6839:100013F812081208FBF8120832083BF856445248923012201210128813061200
+683A:11001104113811C0FD02110230FE380055FC5504910411FC1104110411FC1104
+683B:1028102410241020FBFE102030203BA0552051109110111011CA170A12061002
+683C:1080108010F81108FB1014A0304038A05518520695F811081108110811F81108
+683D:084008487F4408440840FFFE004008440844FF4418282C2A2A12492A88460882
+683E:02000100FFFE0440145014482444444400000100FFFE054009203118C1060100
+683F:1090109410921112FD10137E3110391055105528912811281128114411441182
+6840:101010103EFC4210A490149008FE101020104110FFFE054009203118C1060100
+6841:10801080113C1200FC801080317E3B0855085508910811081108110811281110
+6842:1020102011FC1020FC20102033FE38005420542091FC10201020102013FE1000
+6843:1090109010901292FD941098309039985694549290901090111211121212140E
+6844:10201020112410A4FCA8102033FE3890549054909090109211121112120E1400
+6845:1040104010FC1104FE0811FE3100397C554451449154114811421242123E1400
+6846:100011FE11001100FDFE11103110397C55105510911011FE1100110011FE1000
+6847:10001000FE7C224442443444087C3400C3000100FFFE054009203118C1060100
+6848:01007FFC40040400FFFE08201E4003C03C380100FFFE054009203118C1060100
+6849:10401020102013FEFE02144430403BFE54885488910810D01020105010881304
+684A:0100111009203FF8020002007FFC082011102108DFF6030005C0193061080100
+684B:1020102013FE1020FDFC102431FC392055FE5422902A10541050108811041202
+684C:0100010001FC01001FF810081FF810081FF80100FFFE054009203118C1060100
+684D:1020102013FE1050FC88110432FA380057FE5440908011FC1004100410281010
+684E:100013FE10201040FC88110433FE38225420542093FE10201020102017FE1000
+684F:1000101E13F21092FC941094309838945492549290F2171A1214101010101010
+6850:100013FC12041204FEF4120432043AF456945294929412F41204120412141208
+6851:1FE0064001800E4000007CF82448183066CC01007FFC054009203118C1060100
+6852:010001007FFC010009200820FFFE082009200100FFFE054009203118C1060100
+6853:100013FE10001000FDFC1104310439FC5504550491FC11041000100013FE1000
+6854:10201020102013FEFC20102031FC3800540055FC910411041104110411FC1104
+6855:10001040119C1104FD041104310439DC5504550491041104110411FC11041000
+6856:1020102010401080FDFC11543154395455545554915411541154115413FE1000
+6857:100013F810881090FCBC110439143648504057FE904010E01150124814461040
+6858:1040108011F81108FD08110831F839005500550091FC11041104110411FC1104
+6859:1040104010901108FBFC10243120392055FC5220902017FE1020102010201020
+685A:1124112412481124FD241000308038FC55045184924814281010102010C01300
+685B:08200820083E0820FE2009FE18001C002BFE2A20482888240822082008200820
+685C:1040102412241108FD0810103040384057FE5488910811901060105011881604
+685D:2208220822082388FABE228824A874A86AA8A128A13E21082208220824082808
+685E:21002100211E21D2FA542254225875546892A092A112211A2214241028102010
+685F:10501048107E13C0FC40107C3BC03440507E53C090441028103210CA17061002
+6860:100011FE10481048FC4810483248394A554A554C904810481048104813FE1000
+6861:1080108010BC13C0FC50102430D43B0C540053FE9090109011121112120E1400
+6862:10201020103E1020FC2011FC3104392455245524912411241050104810841104
+6863:1020112410A410A4FCA8102033FC38045404500491FC10041004100413FC1004
+6864:1020112411241124FDFC100031FC3804540455FC910011001102110210FE1000
+6865:2010207823C02040F84027FE20A071106A08A516A11021102110221022102410
+6866:1090109411141118FB1015323152390E5520502093FE10201020102010201020
+6867:1020102010501088FD04120238F83400500053FE902010401088110413FE1102
+6868:0840484028FC09041A882850486089800100FFFE0380054009203118C1060100
+6869:10201010101011FEFD00111031103910557C5510911011101110121012FE1400
+686A:100013FC10041004FDFC100430043BFC5408500897FE11081088108810281010
+686B:2010221021102110F4542252225270906810A114A604220822082210222020C0
+686C:1020082040A824A409227228103010C007000100FFFE054009203118C1060100
+686D:100013FC12001200FEF8120032003BFC56A052A492A812901290148814A418C2
+686E:100013FE10101020FC6810A433223820540055FC910411041104110411FC1104
+686F:100011FC11041104FD0411FC3000380057FE5420902011FC1020102013FE1000
+6870:101C13E012201220FBFE122032903B0A560651FA910811081108110811F81108
+6871:100013FC10001124FA48149032483924540053FC904010401040104017FE1000
+6872:1020102013FE1020FC2013FE3A02340451F85010902013FE1020102010A01040
+6873:10401080110413FEFC22102033FE385054885124922211FC1020102010201020
+6874:1008103C11C01004FD4410A8300039F85410502093FE10201020102010A01040
+6875:2008203C23C02044FA242128210070406BFEA088A10823902060205021882604
+6876:200027F8201021A0F84027FC244474446FFCA444A44427FC2444244424542408
+6877:1080108010F81108FA1015FC3124392455FC5124912411FC1124122412141408
+6878:11841068103010C8FB04104033FE38A0552053FC952411241134112810201020
+6879:1040102011FC1104FD0411FC3104390455FC5520912211141108114411821100
+687A:100013FE10501050FC5013DE32523A525652525293DE10501090109011101210
+687B:210021F823082490F8602198264670406BF8A040A3F8204027FC204020402040
+687C:010001007FFC092011102108C284044009203118CB2605C01930610805000200
+687D:010001007FFC05401930E10E082009201550238801003FF801000100FFFE0000
+687E:100011FC10441044FBFE1044304439FC5480508091FC12841484108410FC1084
+687F:100011FC110411FCFD0411FC3000380055FC5420902013FE1020102010201020
+6880:1020102013FE1020FC2011FC3124392455FC5420907010A81124122210201020
+6881:000023F01090829452922492E110225025200100FFFE054009203118C1060100
+6882:1028102410241020FDFE1020312038B254B4546890A811241222102010A01040
+6883:2000200C27702110F9102210327C6F106110A510A510227C2200250028FE3000
+6884:100013FE10501050FDFC115431543954558C5504910411FC1104110411FC1104
+6885:1100110011FC1200FDF811083948352857FE51089248122813FC100810501020
+6886:2100211E21122FD2F114211427D871146912AFD2A112211A2214221024102810
+6887:100013FE10201020FDFC102030203BFE5488508893FE10881088110811081208
+6888:1040102013FE1000FDF81108310839F8540053FC900810301020102010A01040
+6889:1048114811481148FD4811C8307E384857C851489148114811481148125C1440
+688A:080C08F07E8008800EFE78880888290812080100FFFE054009203118C1060100
+688B:100011F811081108FDF8100033FC3A04560453FC9204120413FC120412141208
+688C:1020102010501088FD0412FA3020382057FE5420912811241222142210A01040
+688D:1020104011FC1104FD0411FC3104390455FC54409040107E17C010421042103E
+688E:1020104011FC1104FDFC110431FC38005500550C91F011001102110210FE1000
+688F:10201120112011FCFD20122030203BFE5400540091FC11041104110411FC1104
+6890:12201224122813B0FE20122232A23B1E5440504093FC10401040104017FE1000
+6891:2010289025102212F5522954215871906B10A528A9282128214821442A842502
+6892:1020102010501088FD44122230F838085410542091FC11041104110411FC1104
+6893:1040102011FC1000FC88105033FE38205420542091FC10201020102010201020
+6894:1008101C11E01100FDFE1100317C3954555455549154117C114012421242143E
+6895:100013FC10441144FD441284389435085240502090A41282128A128A14781000
+6896:080008FC08840884FEFC088418841CFC2A842A8448FC88000848084408820902
+6897:100013FE10201020FDFC1124312439FC5524552491FC112010A0104010B0130E
+6898:100011FC11041104FDFC1104310439FC5504550491FC1050105010921112120E
+6899:1020102011FC1124FD2411FC3020382057FE5222922213FE1222102010201020
+689A:1080108011F81208FC1013FC32443A44564453FC90A010A011221122121E1400
+689B:20002FDE22522252FA5427D432586A546252AFD2A252225A2254245025502890
+689C:10201020102013FEFC20102039243524512452AA902010501050108811041202
+689D:0840084010FC10883550542094D81726142015FC142014A81524122210A01040
+689E:100011F810081008FDF811003104390454FC5440902010A4128A128A14781000
+689F:04001FF010101FF010101FF010001FFC10001FFC01043FF405481930E10E0100
+68A0:100011F811081108FD08110831F83800540053FC920412041204120413FC1204
+68A1:1040102013FE1202FC0411F83800340053FE50909090109011121112120E1400
+68A2:1020112410A410A8FC2011FC3104390455FC5104910411FC1104110411141108
+68A3:1020112411241124FDFC10203050388855445222902011F81008101010101020
+68A4:1020112411241124FDFC100030883888550452FA904810481088108811281210
+68A5:020001007FFE48229214244808201FF001100100FFFE054009203118C1060100
+68A6:082008207EFC08201C702AA8C826040007F0081014202240018002000C007000
+68A7:100013FE10401040FDFC108430843BFE5400500091FC11041104110411FC1104
+68A8:03083C0804487F480C4816482508442805100100FFFE054009203118C1060100
+68A9:100011FC11241124FDFC1124312439FC5420542091FC10201020102013FE1000
+68AA:100013FC10001000FDF811083108390855F85400910810881090100017FE1000
+68AB:100011FC100410FCFC0411FC380037FE520251F8908810881050102010D81306
+68AC:1020102011FC1124FDFC112431FC380057FE5480910011FC1004100410281010
+68AD:1040104010881104FBFE100230883944564250F8918812501020105011881606
+68AE:100011FC11041104FDFC1100310039FE5502557A914A114A127A120214141008
+68AF:11081088109011FCFC24102431FC3920552051FE906210A2112A122414201020
+68B0:1010101410121010FBFE10103150395457F4515491541148124A125A14261042
+68B1:100013FE12221222FE2213FE32223A62567252AA932212221222120213FE1202
+68B2:1010109010881108FA0415FA31083908550851F890901090109011121212140E
+68B3:1040102013FC1040FC90110833FC38045550515091501150125012521452180E
+68B4:1004100E13B81088FC881128312E3BA854A852A892A8113E11001280147E1800
+68B5:082008207EFC08201C702AA8C82600000FE0082008200A20092011222022401E
+68B6:100013FC12041204FBFC120032183AE0563852E0923C13E012221422141E1800
+68B7:100010FC1E0410487E28421042287EC401000100FFFE054009203118C1060100
+68B8:208421C427042114F914211427D471146B14A394A55425042904210421142108
+68B9:1008101C11E01100FD0011FE311039105510511097FE10001090110812041402
+68BA:082008207EFC08201C702AA8C8260000FFFE0200024002200210020802000200
+68BB:22502250225025FCF4542C5435FC75506D50A5FEA4522452245A249424902510
+68BC:1020102013FE1020FDFC104033FE3848548854FE910811481228140810281010
+68BD:10201020102013FEFC201020302039FC5440542090A41282128A128A14781000
+68BE:10201020102013FEFC20112430A438A855FE547090A810A81124122214201020
+68BF:101012101110117EFC2010283748397E5508550891FE110811081288147E1000
+68C0:1040104010A010A0FD10120835F6380054885048924811501110102017FE1000
+68C1:1104108410881010FDFC11043104390455FC54509050109010921112120E1400
+68C2:100013F810081008FDF8100830083BF8544051489148125010A0111012081406
+68C3:0C8070FC1124FD24122438445484912810100100FFFE054009203118C1060100
+68C4:020001007FFC10103FF801081110FFFE11101FF001007FFC05401930E10E0100
+68C5:207823C0204027FCF84023F8204877FE6848A3F8A0E0215022482C4620402040
+68C6:1020102010501088FD0412FA300039FC5554555491FC1154115411541104110C
+68C7:1090109011081148FA44149231083BFC5444502090A41282128A128A14781000
+68C8:1020102013FE1020FDFC102033FE380055FC550491FC110411FC110411141108
+68C9:1020104011FC1104FDFC110431FC3820542053FE92221222122A122410201020
+68CA:08207FFC08200FE008200FE00820FFFE11102108DFF6030005C0193061080100
+68CB:1108110813FC1108FD0811F83108390855F85108910817FE1000109011081204
+68CC:2008203C23C02044FA242128210070206BFEA070A0A820A82124222224202020
+68CD:100011FC11041104FDFC1104310439FC5400551291D41118111011521192110E
+68CE:100013FE12021252FC8811043020382057FE5420907010A81124162210201020
+68CF:100011FC110411FCFD0411FC300039FE540853FE900811081088100810281010
+68D0:044004407C7C04403C7804407C7C044005400100FFFE054009203118C1060100
+68D1:109010901090179EF890109030903B9C549050909090179E1090109010901090
+68D2:1020102013FE1020FDFC104033FE38885524522290F8102013FE102010201020
+68D3:1080104011FC1000FD08108830903BFE5400540091FC11041104110411FC1104
+68D4:101C13E0122013FEFE201292330A3A0655FC5104910411FC1104110411FC1104
+68D5:1040102013FE1202FC0011FC3000380057FE5420912811241222142210A01040
+68D6:100010FC108010F8FC8010F830803BFE55405524912811101108114411821100
+68D7:01007FFC01003FF823880D60301001007FFC01003FF82108238805601918E106
+68D8:10201020FDFC102010207CF854A854A854A85CB81020387054A8952610201020
+68D9:1040102013FC1204FE0413FC32003A28562453FE922012501250148815041A02
+68DA:100013DE12521252FE5213DE32523A52565253DE9252125212521252155218A6
+68DB:1040102013FE1080FD0413FE300239FC550455FC910411FC1104110411141108
+68DC:21082088200827D4FA142222220073C86A44A244A24022502248244425442880
+68DD:100011FC11041124FD2411FC3124392455745554915411741104110411FC1104
+68DE:100013FE1202121AFEE2122232223BFE5622527292AA13261222122213FE1202
+68DF:1020102013FE1020FDFC112431FC392455FC5420907010A81124162210201020
+68E0:0100111009207FFE40029FF4101010101FF00100FFFE054009203118C1060100
+68E1:100013FE1202128AFE5213FE32223A2256AA52AA92AA12FA12021202120A1204
+68E2:100013FE1202128AFE5213FE32423A2257FE52829282128212FA1202120A1204
+68E3:1020102011FC1024FC2413FE3824342451FC5222917410A81124122210A01040
+68E4:10881088108813FEFC88108837FE380055FC5104910411FC1104110411FC1104
+68E5:2088248822882108F93E22882498701C68ACA2AAA14821082288228824882808
+68E6:1080108011F01210FC2013FC3044384457FE5444904413FC1044104011401080
+68E7:10481044105E11E0FC281012306A39965448545E91E0102410281012106A1186
+68E8:102008203E3E224422843E282210402881440100FFFE054009203118C1060100
+68E9:1050125212521252FBDE120232023BFE5602520293DE12521252125214521802
+68EA:1020112211221224FC5010883304382254205524912412281050108811041602
+68EB:10141012101017FEF810101033D23A525652525493D4100810EA171A12261042
+68EC:1020112410A81020FDFC104033FE3888550452FA9488108810A810921082107E
+68ED:2080204027FE2120F920223C224476646A94A348A24822302220225022882306
+68EE:010001007FFC054009203118C106082008207EFC08301C682AA4C92208200820
+68EF:1020102010501088FD44122231F838085450542090A41282128A128A14781000
+68F0:2010207823C02040F84027FC224872486FFEA248A24827FC2040204027FC2000
+68F1:1020102011FC1020FC2013FE30883944564254F8918812501020105011881606
+68F2:1020102013FE1020FDFC102433FE382455FC504093FE108411C8103010CC1302
+68F3:100013DE1042114AFC84114A3A523420500053DE905211521094114812541422
+68F4:200027BE24A224A2FCAA27A424A074BE6CAAA7AAA4AA24AA24A424A424AA29B0
+68F5:100011FC11241124FDFC1124312439FC542053FE907010A81124122210201020
+68F6:10401040104017FCF840124832483A48555450E0915011501248144418421040
+68F7:20002FC024BC24A4F4A427A424A474A86FA8A4A8A49025D02EA820A820C42082
+68F8:00007F00227C3E0422283E1023A8FE4402000100FFFE054009203118C1060100
+68F9:10201020103E1020FDFC110431FC390455FC5524902013FE1020102010201020
+68FA:1040102013FE1202FC0411F83108390855F85500910011FC1104110411FC1104
+68FB:0820FFFE08200460081037E8C22404A018400100FFFE054009203118C1060100
+68FC:082008207EFC08201C702AA8C8240440082010102FE8C4260420082010A06040
+68FD:082008207EFC08201C702AA8C92402800E603118C1061FE00020004000800100
+68FE:082008207EFC08201C702AA8C82600007FFE40028FE40820082010222022C01E
+68FF:10001040139C1204FE04139C32043A0457FC549090901090109011121212140E
+6900:1040102013FE1202FD04110031DE3A5256525352949A1094111011121212140E
+6901:1040102013FE1000FDFC110431FC380055FC5408901013FE1020102010A01040
+6902:100011F810081008FDF8100830083BFE54205222917410A81124122210A01040
+6903:10401040107C1040FBFC124432703BC05644523C920012F0149014921912120E
+6904:1080104013FC1000FD08109037FE3840544057FE908811081090106011981604
+6905:2040204023FC20A0F910220827FE70086BC8A248A248224823C8200820282010
+6906:100011FC11241124FD74112431FC390455745154915411741104120412141408
+6907:100011F811081108FDF8110831F8390855F85108910817FE1000109011081204
+6908:1100110011FC1204FC84149432A4388457FC508491C412A41494108410A81010
+6909:02000100FFFE10103EFC4210149018FEE0100110FFFE054009203118C1060100
+690A:1040102013FE1000FC88108831543A225400502093FE10201020102010201020
+690B:1040102013FE1000FC0011FC3104390455FC5420912811241222142210A01040
+690C:10401020102013FEFA02149431083A04540051FC902010201020102017FE1000
+690D:1020102013FE1020FC2011FC310439FC550455FC910411FC1104110417FE1000
+690E:10A01090109011FEFD10131035FE3910551055FE91101110111011FE11001100
+690F:100017FE10901090FC90139C32043A045604539C909010901090109017FE1000
+6910:100013FC12041204FBFC122032203BFE5620522092FC12841284148414FC1884
+6911:1040108011FC1124FD2411FC3124394455FC5490911013FE1010101010101010
+6912:2100210021DC2114F914211427D470146914A114A58825482948211425142222
+6913:100013FE10401080FD44122430683AB0553052A8906810A41122122010A01040
+6914:1092109211241248FD2410923092380055FE5522912211FE1122112211FE1102
+6915:2008208822882288FABE24482018779C6AACA2AAA2C822882288248824882988
+6916:1040102011FC1104FD0411FC3120391055FE55209120113C1124124412541488
+6917:1040102013FE1202FC04100033FE382054205520913C112012A01260143E1800
+6918:082008207EFC08201C702AA8C824020001007FF8006001800E003000480087FE
+6919:11F81108110811F8FD08110831F8380057FC5204920413FC1204120413FC1204
+691A:100013DE12521252FBDE125232523BDE560252029202120212021202120A1204
+691B:1108110817FE1108FD08100038903492511453189510113211521112110E1100
+691C:1020102010501088FD0412FA3020382055FC5524912411FC1050108811041202
+691D:100011FC7D0411241124FC5010902912460E8100FFFE054009203118C1060100
+691E:080C08F07E8018802CFE2A884888888809080100FFFE054009203118C1060100
+691F:1020102011FC1020FC2013FE3002389454505510909013FE1028104410821302
+6920:100CFEF0208048807EFE08880E88F9084A080100FFFE054009203118C1060100
+6921:1002100217E2110AFD0A124A33EA388A548A53EA908A108A10E21702120A1004
+6922:100013FE12021202FBFE122232223AFA56225232922A13FE1202120213FE1202
+6923:10901090109013FCFE94129432943BFC56945294929417FE1000109011081204
+6924:100013FE12521252FE5213FE3020384054FC5104928810501020104011801600
+6925:11001100110013DEFA9214923092389257F2509290921152115E122014201800
+6926:1020112410A81020FDFC104033FE38885544524295F810481088108811281210
+6927:1020102010501088FD0412FA30003BDE56525252925213DA1254101010101010
+6928:1040102013FE1200FE44124432843ABE578452A4929412941284128414941088
+6929:1040102013FE1220FEFC122432243BFE5624522492FC12201250145014881906
+692A:10841048100011FEFC48104830483A48554A554C904810481048104813FE1000
+692B:11041088105011FCFD24112431FC3924552455FC9020102013FE102010201020
+692C:1040102013FE1202FC0411F83108390855F85508910811F81108110817FE1000
+692D:201027902490257EFD202620257C74A46CA4A4BCA6A4253C242424242424242C
+692E:10401048108411FEFC2013FE3088392456425188901010621184101810601380
+692F:1020112411241124FDFC100033FE3820544055FC91541154115411541154110C
+6930:20002FDE24922492F4942794249874946F92A492A49225DA2E94209020902090
+6931:1100110011FE1200FDFC110431FC390455FC548090FC11081290106011981606
+6932:1040104011FC1084FBFE100031FC390455FC502093FE1020122013FE10201020
+6933:100011FC11241124FDFC1124312439FC540053FE912011221114114811841102
+6934:102011DC11141114FD1411D43126390055DC5514911411D41708110811141122
+6935:100013DE12421242FE4213DE32003A3E57D25212921413D41208121412241242
+6936:1000108812521222FE52128A32023BFE54885144927A10881150102010D81706
+6937:20142012201027FEFC10241025D074126C12A5D4A554254825DA242A28463082
+6938:22102110211027BEFA28224823AA72AE6ABAA2EAA2AE22A824AA24A229A2301E
+6939:1110111017FC1110FDF0111039F03510511057FE920012901308120013FC1000
+693A:2100217C21442244FA44267C2A1072106AFEA238A25422542294231222102210
+693B:100013FE120012FCFE8412FC32843AFC562053FE924812C812301248128413FE
+693C:1080108E11201210FCC010AE31043B1455245164912411241124110411141108
+693D:210021F8220823F0F81027FE208071446E68A0B0A128266820A4212226A02040
+693E:11081088109017FEF80013C432543A5457D45254925413D412541244125412C8
+693F:1020102013FE1020FDFC104033FE3888550452FA9088108810F81088108810F8
+6940:1004101E13E01020FDFC1124312439FC542053FE9222122A12FA1202120A1204
+6941:1040102013FE1202FC8010F831083A9054605198960611F81108110811F81108
+6942:1020102013FE1070FCA81124322239FC550451FC910411FC1104100013FE1000
+6943:100013FC12041204FBFC120033FC3A40568853FC9224122015FC1420182013FE
+6944:1040102013FE1202FE0213FE32003A0057FE5352955215FE1552155219521106
+6945:100013FE100011FCFD04110431FC380057FE5222922213FE1222122213FE1202
+6946:100013FE10501050FBFE125232523BFE5400504097FE10881190106010D81304
+6947:100011FC11041104FDE4112431243BFE560252FA928A128A12FA1202120A1204
+6948:100013FE10221120FD3C11203AFE340051FC510491FC110411FC110411141108
+6949:1088108813FE1088FCA8102033FE3840548054FC918412841084108410FC1084
+694A:100011F8110811F8FD0811F830003BFE550051FC925414941124124410A81110
+694B:1082108217F21082FC8A13EA32AA3AAA57EA508A91CA12AA14A21082108A1084
+694C:1040102013FC1000FD08109033FE3A10562052C89210122412C8141014601980
+694D:010001007FFC0380054009203118C10600007BBC4AA44AA44AA44AA47BBC4AA4
+694E:100013FE12221020FDFE102031FC392455FC552491FC102013FE102010201020
+694F:1020102013FE1050FC88132631FC3820542053FE9000102011FC1020102013FE
+6950:11FC1124112411FCFD24112431FC385054885104928A10881088108811081208
+6951:101013D410581252FD8C108831043AFA5420502093FE10201050108811041202
+6952:100011FC11241124FDFC1124312439FC54005440902412A2128A148810781000
+6953:200027FC24042434FDC4244425F475546D54A5F4A444245425F4249428063002
+6954:2100213C27D42114FB94211427D47124694CA040A7FE204020A0211022082C06
+6955:1040104013FE1080FDFC122035FE380055FC550491FC110411FC110411141108
+6956:100013DE12521252FE5213D232523A52565253D2921A1294125012B013101010
+6957:2020202020FC2E24FBFE222424FC74206EFCA220A2202BFE2420262029FE3000
+6958:00207E20247E1884FF2829104A2899440100FFFE0380054009203118C1060100
+6959:2008278820882288F93E210827D8715C6B2CA32AA54825082908210825082208
+695A:082008207EFC08201C702AA8C82400007FFC0104110011F81100290047FE8000
+695B:1088108813FE1088FCA8102033FE38205420542091FC11041104110411FC1104
+695C:2100211E211227D2F912211E211277D26C52A45EA45227D224522022202A2044
+695D:1020102013FE1020FDFC112431AC3974552455FC9020107010A8112412221020
+695E:100013FC12941294FE9413FC3080384057FE548090F810881108110812281410
+695F:1040102013FE1000FDFC110439FC340053FE520291FC10201020102010A01040
+6960:1020102013FE1020FC2013FE328A3A5256FA5222922212FA12221222122A1204
+6961:11C010A011101208FDF6100033CA3A4A565453D49268125413D4124A124A12C0
+6962:11081088109017FEF890109033FC3A945694530C920413FC1204120413FC1204
+6963:100013FC12241224FBFC120032FC3A84568452FC928412FC1284128414FC1884
+6964:1080108010FC1154FAD410B4312C3A4454945108904010A412AA128A14781000
+6965:103C17C012441128FC0013FC3080388057FE550091F812881250142018D81306
+6966:1040102013FE1202FC0411FC300039FC550455FC910411FC1104100013FE1000
+6967:2110211027FC2110F950204023F872486A48A248A7FE204020A0211022082406
+6968:10201020103E1020FC2011FC310439FC550455FC910411FC1000108811041202
+6969:210021FE21102210FAFE2292269272FE6A92A292A2FE22902250222022582286
+696A:10481148114813FEFD4811483178390055FE542093FE107010A8112416221020
+696B:100011F811081108FDF8100037FE390855F8550891F81108113E17C810081008
+696C:100011FC110411FCFD0411FC388035FE522251229152110211FA100210141008
+696D:044024481450FFFE082004407FFC01003FF80100FFFE054009203118C1060100
+696E:1020102211FA1024FC2813FE3020384054FC5184928410FC1084108410FC1084
+696F:201C23E022202220FBFE222022FC72846A84A2FCA28422FC2484248428FC2084
+6970:1020102010A0112CFD24112431AC3924552455FC912410501050108811041202
+6971:2040204027FC2040FBF8208027FC71106A08A5F6A04023F8204020A021102608
+6972:2014201227FE2410FC1027F0249274926FD2A554A5542488254A2A1A28263042
+6973:1088108813FE1088FC8810F83088388854F8542093FE107010A8112412221020
+6974:1040102011FC1000FC88105033FE3A22542455FC912411241134112810201020
+6975:100013FC10081010FC2013AE32A23AAA56A452A493AA103210A0104017FE1000
+6976:410021FC0A441048E0A0211026081FF410101FF001007FFC05401930E10E0100
+6977:1110111211D41118FD521192312E384055FC5104910411FC1104110411FC1104
+6978:208821C827082108F92A212A27AC71486B08A388A55425142914212421242142
+6979:100013F811081110FD1C12E432A43A5454A8510093FC12941294129417FE1000
+697A:100010FC10481030FDFE1052389435105230502091FE107010A8112412221020
+697B:1020104011FC1104FDFC110439FC340053FE5020902011FC1020102013FE1000
+697C:2020212420A82020FBFE20A8212472026840A7FEA08821082190206021982604
+697D:0100420427C81450044017D02448C44407C00100FFFE054009203118C1060100
+697E:1040108011FC1104FDFC110431FC3820543253B490A811281124122414A21040
+697F:101C11E010201020FBFE10A831243A2255FC5104910411FC1104110411FC1104
+6980:100010F810881088FC88108830F83888540053DE925212521252125213DE1252
+6981:1040102011FE1102FE0411FC3040388855FC5424902011FC1020102013FE1000
+6982:200027BE24882488FFA824A824A877BE6C10A518A49825A826AA244A20462080
+6983:082008207EFC08201C702AA8C82600003FF8210821083FF8210821083FF82008
+6984:10901290129E12A8FEC4108031FC39045524552491241154105010901112160E
+6985:100011F811081108FDF81108310839F8540053FC929412941294129417FE1000
+6986:104010A011101208FDF6100033C43A54565453D49254125413D41244125412C8
+6987:1040102011FC1000FC88105033FE3820542055FC902010A81124122210A01040
+6988:110010BC12841204FEF4129432943AF4560452F49294129412F4120412141208
+6989:1044112410881010FBFE108831243A2254F85020902013FE1020102010201020
+698A:120811081108103EFBAA10AA30BE392A55AA536A953E112A1108110811081108
+698B:100011FC100410FCFC0411FC3004380057DE5442904213DE1042104213DE1042
+698C:100013FA100C104AFB88112A3126392257F8512A912C112A1128122A12261422
+698D:200023FE22022202FBFE2210229272546AFEA282A2FE228222FE2482248A2884
+698E:13FE104011FC1104FDFC110431FC390455FC548090FC11081290106011981606
+698F:1104108410881000FBFE100030883904560251FC915411541154115417FE1000
+6990:100013FC12041204FBFC124832483AFC5648524893FE12A412A8149014C81886
+6991:1028102413FE1020FDFC112431FC392455FC5524900813FE1088104810481018
+6992:100013DE10421042FBDE121032103BDE54425252914A114A1252104212941108
+6993:20402028209022A4FAC2248A218876786800A3FCA29422942294229427FE2000
+6994:1100109E13D21252FE5413D432583A5457D252129292125A12D4135012101010
+6995:1040102013FE1202FC501088312438505488510492FA10881088108810F81088
+6996:08007F7808483E4800487F864100BEFC004408447E2818282C104A2888440982
+6997:100013FC10901294FD98109037FE380055F85508910811F81108110811F81108
+6998:200020FC3E8048F888887EF8148022FC40000100FFFE054009203118C1060100
+6999:1088108813FE1088FC2010503888350452FA5000900011FC1104110411FC1104
+699A:1104108410881000FBFE1020302039FC5420502093FE100012A4125214521000
+699B:1020102013FE1020FDFC10403BFE3488513452E2902011FC107010AC13221020
+699C:1040102013FC1108FC9013FE32023C44542053FC908010F81088110811281210
+699D:2000245C22942114FA942454212671006FDCA114A59425542948210825142222
+699E:100011FE11101120FD7C1144317C3944557C5510911011541152129212501420
+699F:1040102013FE1242FC2011FC3088385057FE5020902011FC1020102010201020
+69A0:100013FE12021000FDFC110431FC390455FC5440902013FE1000108811041202
+69A1:1020102013FE1020FDFC102033FE3840548855F0902413FE1022112412A21040
+69A2:1040102013FE1202FC0011FC304038A257345458909413341052109013501020
+69A3:1008103C13C01004FA44112831FC3A20542053FE902011241124112411FC1004
+69A4:2208220823BE2488FAA8213E220874486848A7FCA0E0215022482C4620402040
+69A5:100011FC110411FCFD0411FC3020392454A8502093FE1090109011121212140E
+69A6:102010201050FE5010887D0446227C2045FC7C601070FEA810A4112412201020
+69A7:100013FE12281228FEEE122832283AEE5628522892EE12281228122813FE1000
+69A8:1040102013FE128AFD04108030FE39405640507C90401040107E104010401040
+69A9:1040107C104013FEFE42127833C43A3C5640522093FE12881250142014581986
+69AA:100011FE112011FCFD2011FC3120392055FE500292AA12AA12AA120210141008
+69AB:10A0109011FE1320FDFC112031FC392055FE5500902013FE1020102010201020
+69AC:1020102011FC1020FBFE100031FC3904550451FC90521094118816A410C21080
+69AD:2084210423C42244FBDE224433C46A646254A7D4A0C421442244244421542088
+69AE:08202AA44D28145022887FFE4002810401007FFC0380054009203118C1060100
+69AF:201020102710257CFD10251025FE77086D08A5FEA50825482728200820282010
+69B0:1040104411F81050FBFE104030F83982567E540091FC110411FC110411FC1104
+69B1:2080204027FE2000FBF822082FFE72086BF8A0A4A12823102510294821862100
+69B2:200023F8224822A8FB18220823F870006800A7FCA4A424A424A424A42FFE2000
+69B3:2040202023FE2202FAEC2224224472446AEEA224A2A422A4224E2460249E2900
+69B4:104013BE12121292FE5212AA3324384057FE5222922213FE1222122213FE1202
+69B5:1108110817FE1108F80017FE310839F8550851F89108113E17C8100810081008
+69B6:1020101013FE1220FAFC122433FE3A2456FC522092FC12841284148414FC1884
+69B7:1080108017FE1522FD1013FC36203A2057FC5220922013FC1220122013FE1200
+69B8:1100113E112A112AF93E17AA312A393E55085108913E118817081208107E1000
+69B9:1004101E13F0121EFE1012FE32923A9856F2528E928012B812A814AA154A1A86
+69BA:00203D2424A8242025FC3C4027FE248825243E2225FC247024A8452456248820
+69BB:100011FC110411FCFD0411FC3800340053DE50429252114A12521042114A1084
+69BC:1020102011FC1020FC2013FE3080390457FE540293FC12941294129417FE1000
+69BD:103C17C012441128FC80111033E03840558853FC9044104017FC10A01110160E
+69BE:100011FC110411E4FD2413FE320239FC550455FC910411FC1104110411141108
+69BF:1020112411241124FDFC100033FE380055FC5504910411FC1088105013FE1000
+69C0:0100FFFE00001FF010101FF000007FFC40044FE448244FEC0100FFFE0920711C
+69C1:1040102013FE1000FDFC110431FC380057FE520292FA128A12FA1202120A1204
+69C2:20062F7821102120FA44227833106A24667EAA12A2102254225222922A502420
+69C3:10003E7822482A48FE8623782A4842304A48848401007FFC05401930E10E0100
+69C4:103C13C010441224FD28110030403B9C56045204939C12041204120413FC1204
+69C5:100013FE100011FCFD04110431FC380057FE528A925213FE12221222122A1204
+69C6:1110111017FE1110FA0013FC34043BE4562453E4922413E41224100410281010
+69C7:111811E0110210FEFC00117C3144397C5544557C9144117C110011FE10881104
+69C8:100013FE120012FCFE0013FE32A83A9056C85286920813FE1288144814081818
+69C9:1020101011FE1100F9201520333C39505590531095FE11101128122812441482
+69CA:2200147CFF44087C4944497C7F44084410942108FFFE054009203118C1060100
+69CB:1088108813FE1088FDFC108833FE382055FC552491FC112413FE110411141108
+69CC:10101220117C1144FC44107C33403940557C55449144117C11441280147E1000
+69CD:10201020105010C8FD2413FE350439FC550451FC910011FC1284128414FC1084
+69CE:11081088109013FCFC4011F830403BFE5480550091FC12201420182013FE1000
+69CF:10881050100013FEFC5011FC30543BFE545455FC905010D81154125210501050
+69D0:1020104011FC1124FD2411FC3124394455FC544090B010A4113C11221222141E
+69D1:00007CF84488448844887CF810201020FDFC307038A854A85124922210201020
+69D2:1040102013FE1040FC8811F03020384455FE540291FC112411FC112411FC1104
+69D3:100011FC10201020FBFE100031FC390455FC510491FC110411FC108811041202
+69D4:1040108013F81208FBF8120833F8388057FC5110924814441BFA104010401040
+69D5:10201020103E1020FDFC110431FC390455FC502093FE107010A8112412221020
+69D6:01007FFC01001FF000007FFE4002BFF408001FF068100FF00100FFFE0920711C
+69D7:1040104017FE1080FDF8128834F8380057FE520292FA128A12FA1202120A1204
+69D8:1104108813FE1020FDFC102033FE3820552454A8907010A81124162210A01040
+69D9:1020102013FE1020FDFC110431FC390455FC550491FC110413FE108811041202
+69DA:100013FE105013FEFE52125233FE380055FC5504912411241124105010881304
+69DB:10481148114E1150FD68114431443840540055FC915411541154115417FE1000
+69DC:10A0109011FE1320FDFC112031FC392055FE510093FC1088109E1102120A1404
+69DD:1020104011FC1104FDFC110431FC390055FE550091FE1042124A13FA10141008
+69DE:1080104017FC1110F8A017FE30003BF8564853F8924813F8124A1042103E1000
+69DF:1040102013FE1202FC1411E03100390055FC5110911017FE1000109011081204
+69E0:2020242022FA2224F82821FE2E2072406AFCA344A244227C22C42344227C2044
+69E1:11F810881070118CFC0013DE3252398C5652502093FE107010A8112416221020
+69E2:100013DE10421252FD4A12523042382055FC5504910411FC1104110411FC1104
+69E3:1040102013FE1202FC2011FC3050388857FE540891E8112811E8100810281010
+69E4:1010101012FE1110FD7C1054307C3B54557C511091FE111011101290147E1000
+69E5:108813DE108811DCFC8813DE3888340053FC5004900411FC1004100413FC1004
+69E6:202027FE242025FCFC2427FE242475FC6C20A5FCA52425FC252429FC2924312C
+69E7:08047F7808407F40497E7F4849487F4808487F48088801007FFC05401930E10E
+69E8:2200211E27D22012F7D4245427D870146FD2A092A11221DA2714211025102210
+69E9:00007DFC44207D2045FE7C5048525492650E0100FFFE054009203118C1060100
+69EA:2100223E27882488FCA827A824BE74886F88A010A4982718242824AA23CA2086
+69EB:102013FE102011FCFD2411FC312439FC542253FE900813FE1108108810281010
+69EC:2200220E2F742254F55428D4275470546FD4A454A754215421522154255C2284
+69ED:20142012201027FEFC10249024D274926FF2A494A49425C82AAA289A31A62042
+69EE:1040108811FC1108FA5213FE30503988562650C0931010641388103010C01700
+69EF:1020122213FE1090FC8811FE3B10351051FE5110911011FE1110111011FE1100
+69F0:2020247C22842148F83020CE2610727C6A10A27CA21022FE2210221025FE2800
+69F1:100011FE10481048FDFE114A314A398E550255FE910211FE10001154112A122A
+69F2:2204220427842494F90C27C4256475546FC4A546A57C27C425442544244428C4
+69F3:0440247C24A83D5004287DFE2488444885180100FFFE054009203118C1060100
+69F4:1040102013FC1204FBFC120032F83A8856F8520093FC132415FC1502190210FE
+69F5:1020102011FC1124FDFC102033FE3A2257FE50209040102412A2128A14781000
+69F6:200027FE242A2426F7FE242227AA76AA6FAAA432A596262E2446248227FE2402
+69F7:08203E2008F87F282228496A3E2A08567E820100FFFE054009203118C1060100
+69F8:2110211027D02110F93C27D4201472B46D54A11CA7D42114211421E427262242
+69F9:1020104011FC1104FDFC110431FC3820552454A89124102013FE102010201020
+69FA:2040202027FE2420FDFC242427FE74246DFCA420A56224B429282A2630A02040
+69FB:2200227C22442744FA7C22442244777C6A44A244A27C22282528254A284A3086
+69FC:11F87D0811F81108FDF8110829F824904112860E01007FFC05401930E10E0100
+69FD:1090109017FE1090FBFC129433FC3A9457FC500091F8110811F8110811F81108
+69FE:100011F8110811F8FD0811F830003BFC569453FC900011F81090106011981606
+69FF:1088108817FE1088FCF8102031FC392455FC502093FE102011FC102017FE1000
+6A00:1040102013FE1088FC5013FE32223AFA562252FA928A128A12FA1202120A1204
+6A01:1020102013FE1020FDFC104033FE388855045242959C110411DC110411FC1104
+6A02:2104220447C89452E45C47C89452F45E17C20100FFFE054009203118C1060100
+6A03:1100109E13D21252FE5213DE32523A5257D2521E9292125212D21352122A1044
+6A04:2010271025FE2510FD7C2654257C75546D7CA510A53826542492241024102410
+6A05:2124212422242424F954214A229276106A10A250A25C2250225022B0229E2300
+6A06:1040102013FE1000FD541124315439FC542053FE9242129212FA120A12021206
+6A07:2120213C214422A8FA1026A82AC672BC6AA4A2BCA2A422BC222422242224222C
+6A08:2080204023F82110F8A027FE200073F86A08A3F8A20823F82120212222222C1E
+6A09:1020102013FE1020FAAA112432AA382056AA512492AA10501050108811041602
+6A0A:24482288F93E22886458729CA92A228825480100FFFE0280044008203018C006
+6A0B:20FE240422282210F8FE20922E9272FE6A92A2FEA29222922296250028FE2000
+6A0C:100011FC112413FEFD2411FC300039FC550455FC910411FC110411FC10881104
+6A0D:102013FE102011FCFC2013FE300039FC550455FC910411FC110411FC10881104
+6A0E:1020101013FE1202F88010FE31103B20557C51449144117C11441144117C1144
+6A0F:100011FC112411FCFD2411FC3040388855F05420904413FE1022112412221060
+6A10:10201020103E1020FC2013FE32023B26568A525293261252128A132613FE1202
+6A11:22782128246C22AAF82A2148229870406840A7FCA0E0215022482C4620402040
+6A12:1040102013FE1242FC2812943AAA34CA50F85300902011241124112411FC1004
+6A13:102011FC112413FEFD2411FC302039FC552455FC904013FE108811D01070138C
+6A14:1124124811241000FDFC112431FC392455FC502093FE107010A8112416221020
+6A15:2108210827C82108F91E27D2256475406FC8A108A38825482954211421242142
+6A16:010006C01830EFEE00001FF010101FF0000013FEFC0811E8392855E890081018
+6A17:11FC102013FE1222FDAC102031AC380055FC500093FE108010FC100410281010
+6A18:1020112410A813FEFE0210F83088388854F85420902011FC1020102013FE1000
+6A19:100013FE105011FCFD54115431FC380055FC540093FE102010A8112412A21040
+6A1A:1040102013FE1250FE5013FE32523A5257FE5200929212D41298149214D2188E
+6A1B:200027BC208424A4FA9424A4205071886E26A0C0A31020642388203020C02700
+6A1C:1040102013FE1200FE48124833FE3A4856485248927812001554152A1A2A1000
+6A1D:1040107C104013FEFE42127833C43A3C560052FC928412FC128414FC148419FE
+6A1E:100013FE1200127CFE441244327C3A0056EE52AA92AA12AA12EE120013FE1000
+6A1F:102011FC10881050FBFE100031FC390455FC510491FC102013FE102010201020
+6A20:1088108813FE1088FC8810F830203BFE5622533292AA137612221222122A1224
+6A21:1110111017FC1110FC0013F832083BF8560853F8904017FC10A0111012081406
+6A22:1040108011FC1104FDFC110431FC390055FE550091FE100212AA12AA1202100C
+6A23:1104108813FE1020FDFC102033FE3820541054E0902213B410A8112416A21040
+6A24:2110211E21222254F20826942AE272886A88A2BEA28822AC222A224A22282210
+6A25:108813FE10881080FDF8128830703B8E542055FC902011FC102013FE10201020
+6A26:1210121013DE1528F884102030103BFE5420502091FC10201020102013FE1000
+6A27:2000245C22942114FA94241420A67140691CA7D4A11423942548290821142122
+6A28:200023FE220223FEFA102254223872546A82A250A27C2290221025FE24102810
+6A29:1080108011FE1220FC4013FE3890350853FE551091FE111011FE111011FE1100
+6A2A:1110111013FCFD10111017FE30403BF8564853F8924813F81000111012081404
+6A2B:200027DC251427D4FC5427C8250875146FE2A000A04027FC204020402FFE2000
+6A2C:1040108013FC1244FEF4131432A43A4456A453FC904010241522150A190810F8
+6A2D:1088108813FE1088FCF8108830F8388857FE5088912412FA1020102013FE1000
+6A2E:100013FE10501050FBFE125232523BFE54205124912412281050108811041202
+6A2F:1020102013FE1020FD2410A833FE380055FC5504917411541174110411FC1104
+6A30:100011FC102013FEFE2211AC302039AC540055FC900411FC1004100411FC1004
+6A31:20002FBE28A22AAAFAAA2AAA251478A26880AFFEA110221023A0206021982E04
+6A32:101417FE101013D0FC1013D030103BD0565053D0925013C8124A13CA11861242
+6A33:100013FC100413FCFC0413FC30003BBC552457BC900813FE1108108810A81010
+6A34:1110109413D21012FA50119037FE381057D25252925413D4124A124A13D61022
+6A35:1090108811FE1110FB1015FE3110391055FE5110911011FE110012A412521452
+6A36:100011F8110811F8FD0811F8380037FE524053DC925413D4126817C810541062
+6A37:082008207EFC18302C684AA488207F7C22443E4422283E28221027A8FA440282
+6A38:1050125211541050FBFE108830503BFE542051FC902013FE1050108811041602
+6A39:210421042FE42104F93E27C4200477E46C54A454A7C42444228420E42F142408
+6A3A:108813FE10881000FDFC10A830A83BFE54A854A891FC102013FE102010201020
+6A3B:102011FC112411FCFC2013FE300039FC550455FC910411FC110411FC10881104
+6A3C:27FC240427FC2400FDF8241027FE74206C60A79CA484250829DE2F0831082318
+6A3D:1088105013FE1050FDFC1154318C3974550455FC900813FE1108108810A81010
+6A3E:2114211221122790F97E21502FD471546954A548A5EA25562722250024FE2800
+6A3F:100013DE12521252FBDE100031FC392455FC512491FC102013FE102010201020
+6A40:1040102013FE1040FC8411FE30A838AA5526520091FC11541154115413FE1000
+6A41:1110111011DE12A8FC44110031FC3A0455F4511491F4111411F4111410281010
+6A42:1088105013FE1050FDFC1154318C3974550455FC902013FE1050108811041202
+6A43:102413A810921514FA08140433BA38A854C65380923C138410A8109012A81144
+6A44:2008278820882110FFDE249424A477946C94A794A49424C827882C9420A420C2
+6A45:1080108011FE1354FD54115433FE39545554515497FE10001154112A122A1000
+6A46:20003FFC529092907FFC12901290FFFE082008207EFC18202C704AA889240820
+6A47:103813C0107813C0FC7813C4383C340050C6573891CE173811CE1738114A1186
+6A48:1020102011FC1020FBFE1108339C39085588563E900013FE109010901112120E
+6A49:1020112410A813FEFCA8112432223904550451DE92441554109E110412041404
+6A4A:100013FE105013DEFA52125233DE385057FE5222922213FE1222122213FE1202
+6A4B:101811E0104013FEFC88117432523870540055FC91041174115411741104110C
+6A4C:13DE125213DE1252FBDE120232F23A9256F2529292F212921292133212021206
+6A4D:100013DE125213DEFE5213DE32023AFA562252729222122212FA1202120A1204
+6A4E:103C13E0112410A8FBFE10A831243A0255FC5124912411FC1124112411FC1104
+6A4F:1088105013FE1020FDFC102033FE392454A853FE900011FC1104110411FC1104
+6A50:01007FFC11101FF00100FFFE80023FF804001FF068100FF00100FFFE0920711C
+6A51:2040204027FCF8A02514220877FC6A0AABF8A20823F820402248244429442080
+6A52:100011FC102013FEFE2211AC302039AC540055FC900013FE1040108811FC1084
+6A53:203C27C02044FA24210827FE74026A08AA08A3BE24882AA8213E220824082808
+6A54:221021102FD02010F7BE24A427D470146F94A094A11421C82F08211425142222
+6A55:112410A813FE1202FCF8108830F8380055FC5410911011FE1050109013101030
+6A56:1020112410A813FEFE0210F83088388854F8502093FE107010A8112412221020
+6A57:1088108813FE1088FC0013DE32523A5257DE5252925213DE12521022102A1044
+6A58:100013FC10481030FBFE105230943B50542053FE9252128A1376125212721206
+6A59:102017A410A81292F914120835F4380257F85208920813F8120811101FFE1000
+6A5A:102011FC102413FEFC2411FC30203AAA57AE522293FE122213AE12AA12AA1422
+6A5B:20002FFE28002A28F9482BEE289278846AA0AAA8ABE828882894291429243242
+6A5C:3FFE289025103FDE22222A882F882294242228803FFE21C022A0449858868080
+6A5D:100013FE105013FEFE5213FE300039FC550455FC910411FC102013FE10201020
+6A5E:1020102013FE1020FDFC112431FC392455FC502293FE1042102412A2128A1478
+6A5F:1124112412AA13AEF92412AA33AE392457FE511091141114128A124A12161422
+6A60:102013FE104010F8FB48103033D0383C55C45048903013C410A8119016A810C6
+6A61:108010F8110813FEFD12112239FE344050A25354909813341054109213501020
+6A62:2020272025FE2540FD7C2690257E75006D7CA544A57C2644247C24442444244C
+6A63:208020402FFE2882F548251428F470006FFCA444A7FC244427FC244424542408
+6A64:01002488242443E4000024241212A0A0A4A41C1C01007FFC05401930E10E0100
+6A65:282211FC28284BFE984029FC4E8488FC288410FC01007FFC05401930E10E0100
+6A66:102011FC10881050FBFE100031FC392455FC512491FC102011FC102013FE1000
+6A67:11041088100013FEFE2212AA32723A2257FE540091FC110411FC110411FC1104
+6A68:102011FC10201088FBFE108831FC390455FC510491FC110411FC108811041202
+6A69:108812AA12DC1488F954122233FE3A02540050F890881088108A110A12061400
+6A6A:1110111411D21250FA7E155030903AA85528514492441482100812A412521452
+6A6B:1088108813FE1088FCF8100033FE382055FC552491FC112411FC108811041202
+6A6C:100013DE108812A8FBFE118832DA3CA655F85108910811F81108110811F81108
+6A6D:102013FE102011FCFD0411FC302039FC5488505093FE102011FC102010201020
+6A6E:104013BE12921252FEAA1324304039FC550455FC910411FC110411FC10881104
+6A6F:208822AA22DC2488F9542222200073FE6A42A444A3FC20442044208421142208
+6A70:104011FC110411FCFD0411FC310439FC5420552490A81124102013FE10201020
+6A71:200027FE24002404F7E4240425DE75446D44A5D4A40C2544248424E42B142008
+6A72:102013FE102011FCFC0011FC390435FC508853FE900011FC1104110411FC1104
+6A73:2010275425382510FD7C271025FE75286D24A752A5FC2514252425242B542088
+6A74:1090109212D4129AFAD2174E308839F05420504493FE10221128122414A21040
+6A75:2288228827C82290FA9E27D4202477D46C54A7D4A45427C824482454246424C2
+6A76:21102114211227D2F91027DE247077D26C52A7D4A1142FD8210A211A21262142
+6A77:2040228822EA2EAAF2AC22E822AA76AA6AE6A000A1202120212022222422281E
+6A78:10F81088108810F8FC88108830F8380057DE5252925213DE1252125213DE1252
+6A79:108010F8111013FCFD2411FC392435FC500053FE900011FC110411FC110411FC
+6A7A:100013DE125213DEFE5213DE32023AFA568A52FA928A12FA128A1202120A1204
+6A7B:200023F820482048FBF82088208877FC6800A7BCA294229427BC229422D42F3E
+6A7C:2220223C24442578F9082EFE222074D2681AAF2CA0CC201A232A2CC820282010
+6A7D:10101210117C1010FCFE1044332839FE5510557C911011FE1110111012FE1400
+6A7E:11FC1104110411FCFC0013DE32523A5257DE502093FE107010A8112416221020
+6A7F:100013FE100011FCFD2411FC31243BFE540055FC912411FC112411FC100013FE
+6A80:20402FFE200027FCFC0425F4251477FC6800A3F8A20823F8220823F820002FFE
+6A81:102013FE100011FCFD04117431543974550455FC900810F0102013FE10A81326
+6A82:109013FC129413FCFE9413FC30003BFC560052F8920013FE1520151415481986
+6A83:001E7BE4492853FC602053FE48004BFC680453FC400443FC0100FFFE0920711C
+6A84:2108220827C82450FFDE246427D472146914A7D4A21423C822482454255428A2
+6A85:1020113C112013FEFC10101433FE3A1057F05254925412D41368144A18961322
+6A86:2108210821482548F58E290822887448693EA162A5A22522292222A2247E2822
+6A87:10A0109011FE1320FDFC112031FC392055FE510093DE12521252127212021206
+6A88:100013FC12941294FBFC100037FE380057FC520493FC10A2111413081D441182
+6A89:100017E0125E13D2FE5213D23A7237DE504053FE902011FC1020102013FE1000
+6A8A:2108210821142FD4F12227C0245C77C86C48A7C8A13E2FC82108210821082108
+6A8B:108813FE108813FEFC88112432FA382055FC552491FC112411FC102013FE1020
+6A8C:200023FC22942294FBFC20002090779E6890A090A39C20902090279E20902090
+6A8D:1040102011FC1088FC5013FE300039FC550455FC910411FC10201294128A147A
+6A8E:1020105010881124FEFA10503124395455FC502093FE1242129212FA120A1206
+6A8F:1050125211541050FBFE108830503BFE542051FC902013FE10A8112416221020
+6A90:110011F8120817FEFA88132433FE3A0056FC520092FC120012FC148414FC1884
+6A91:100011FC102013FEFA2211AC302039AC540051FC9124112411FC1124112411FC
+6A92:082008207EFC18302C684AA69FF010D01710111017D0155027CA212A4FE68022
+6A93:210026DC24542454F6D42454246677C0681CA014A7D42114210821C827142222
+6A94:1020112410A813FEFE0210F83088388854F8540091FC112411FC112411FC1104
+6A95:0800FF7808487F4849867F0049787F480828FF9049287F440100FFFE0920711C
+6A96:104412241128107EFC101028334A391C5528554C911A112A1148111012FE1400
+6A97:00407C2045FC44887C5043FE7C20A5FC24203C2001007FFC05401930E10E0100
+6A98:20102008278824BEFC8024942788747E6C08A788A6BE2A882A882B8832882008
+6A99:21F8210821F8250AF5FA250A25FA74026F9EA090A0902F9E2492249224922892
+6A9A:2110211027BC2110FBB82554291270006FFCA044A24022782240254028FE3000
+6A9B:2000227C21442174F854205426FE72826ABAA2AAA2BA2282228A2284250028FE
+6A9C:204020A023182DF6F00027FC255474E46FFCA000A3F8220823F8220823F82208
+6A9D:101013D412521252FBD0101037FE3A5057D2525293D4125412EA174A10561062
+6A9E:2200239E248A290AF7D22566254077D46D5EA564A7C42544255E2544244428C4
+6A9F:100013FE105013FEFE5213FE300039FC550455FC910411FC110411FC10881104
+6AA0:2420FF20243E7E4482847A284A107A2804440100FFFE054009203118C1060100
+6AA1:100011FC115411FCFC2011FC30203BFE5488545091FC102013FE102010201020
+6AA2:1020102010501088FD0412FA3000380055DC5554915411DC1088108811541222
+6AA3:2040204027FC2248FA4825542FFE70006BF8A208A2E822A822E8220823F82208
+6AA4:10441028120011FEFD20107C30443B7C5544517C9144117C11441280147E1000
+6AA5:1104108813FE1020FDFC10203BFE34545192509093FE109010D4138A109611A2
+6AA6:20022FE222822FEAFAAA2AAA2FEA700A6BCAA00AAFEA210A25422522292A2304
+6AA7:108813FE10881100FBFC155430D43B24545450949348102010A4128A128A1478
+6AA8:1104108813FE1020FDFC102033FE38005620513E904211141610122812441082
+6AA9:102013FE100011FCFD04117431543974550455FC900011FC100013FE11241262
+6AAA:1020104010F8128AFD8C10F8318C3A8A54F8502093FE107010A8112416221020
+6AAB:2080204027FE2402FA2423BC34A46AA86510A2E8A4042BFA20402248244420C0
+6AAC:211027FC211027FCF40423F8200077FC6880A144A6A8217026A8212626A02040
+6AAD:2200227C254424C4F87C27442244727C6F52A252AA542748224823542C622040
+6AAE:204027FC204023FCF80027FE200273F86840A7FEA00027FE200827FE24A82798
+6AAF:20402FFE204027FCF80023F832086FFE6802A7FCA11023F8204027FC20402FFE
+6AB0:21082110223E2222F4BE2722213E72086CBEA7AAA02A20AA256A252E24082008
+6AB1:110811EE12941042FC88108833FE388854F8548890F8108813FE108811041202
+6AB2:13FE122213FE1222FEFA12AA32FA3AAA56FA522693FE120A13FE128A125A13FE
+6AB3:2080204027FE2402FBFC2148225077FC6A04A7FCAA0423FC220423FC21082204
+6AB4:108813FE10A81090FDFE132031FC392055FC512091FE110013FC10881070138E
+6AB5:1044128412EA124EFEA412EE32223BFE5644528492EA124E12A412EE122213FE
+6AB6:1020102013FE1050FC8813FE32003A7C5644527C920012EE12AA12EE120013FE
+6AB7:200027FC22482444FFFE244426EC75546EECA444A6EC255426EC244424542408
+6AB8:1040102013FE1222FD54114A323A380055FC515493FE100011FC102010A01040
+6AB9:24202220223E2F40F490247E272475426DFEA504A57425542974290433142008
+6ABA:204027FE200021F8F90821F8200077FE6C02A3F8A180264421B8266821A62660
+6ABB:100813E8128813EEFE2813F432823BE2540051FC915411541154115417FE1000
+6ABC:203E27C022442128FBF8204027FC70006BF8A008A3F8200823F82544252A28FA
+6ABD:100011FC102013FEFA2211AC302039AC540053FE902011FC115411541154110C
+6ABE:08202AA44D28145022887FFE4002882408207EFC08301C682AA4C92208200820
+6ABF:3FFE28942F9228902FFE20102F9028A82FA428C4298020404FFE416086581846
+6AC0:110817FE110811F8FD0811F8390837FE5108529495E2104813FC1040124814C4
+6AC1:1040102013FE1242FC2812943AAA34CA5378502091FC112411FC102213FE1002
+6AC2:200027BC208424A4F29424A4212072106FFCAA20A3FC222023FC222023FE2200
+6AC3:27FE242025FC2524FDFC242027FE75046DFCA504A5FC250425FC2488250427FE
+6AC4:101C11E0102013FEFC2011FC31AC397455FC542091FC102013FE10001154122A
+6AC5:2080204027FC2110F0A42F58255475526B58A000A20823F8220823F822082408
+6AC6:2104221427CC2544FD5427CC2546755C6FC4A104A2A422D424F02482287E2000
+6AC7:2080209E208427E8FCBE2492249277DE6E52A55EA5522492289E2940314C2252
+6AC8:202427A820922514F2E8240423FA72086BF8A110A7FC200021F021102212240E
+6AC9:200027FE24842484F7E4249E25C474046DD4A54CA5C42544288428C433142008
+6ACA:200027BC24A427BCFCA427BC248475F46E94A4E4A71C24E424A424A424E4240C
+6ACB:104011FC11241194FD4C112439FC342053FE528A912413FE108010FC1104120C
+6ACC:23FC204021F82108F9F8210827FE74426AA4A28AA47A208021F822882070238E
+6ACD:1042139C121013DEFE94129434203BFC560453FC920413FC120413FC11081204
+6ACE:2040202027FE2488FDFC248827FE74206DFCA524A5FC252425FC240024882904
+6ACF:200020FE242822FEFAAA20FE201071FE6E44A2FEA344227C2242223E250028FE
+6AD0:1FF011101FF011101FF000003EF82AA83EF82AA83EF801007FFC05401930E10E
+6AD1:23F82248224823F8FA48224823F870006FBEAAAAAAAA2FBE2AAA2AAA2FBE28A2
+6AD2:1088108813FE1088FD1011DE3A52355452885174920211FC1020112412221060
+6AD3:108011F8120815FCFD2411FC392435FC5154522A91FC110411FC110411FC1104
+6AD4:100013FE124813FEFE4812FC32A43AFC56A452FC922013FE132A157A150A1906
+6AD5:108811DC108813DEFC881154322239FC550455FC910411FC110411FC10881104
+6AD6:2020203E202027FEFC2225F8242275FE6D24A5FCA52425FC28402AA4328A247A
+6AD7:110817FE11081000FBFC129432943BFC542853FE9220132412A81292142A18C6
+6AD8:108813DE108811DCFC8813DE30883BFC540451FC900413FC104012A4128A147A
+6AD9:1088108817FE1088FBFE1200327C3A44567C520092EE12AA12AA12EE120013FE
+6ADA:100013DE125213DEFE5213DE32023AFA568A52FA920212FA128A12FA12021206
+6ADB:1108110811EE1294FC42100033DE3A5257D2525293D2121A1294135012101010
+6ADC:01007FFC11101FF00100FFFE88421F6032504C4837FEC1007FFC05401930E10E
+6ADD:102013FE102011FCFC0013FE32523BFE550455FC910411FC110411FC10881104
+6ADE:2120213C21442278FA8824FE2F2071526A1AA4ACAFCC209A202A2AC82AA82810
+6ADF:244424E428A82AAAFEEE24A42AAA7EEE6A42A040AFFE20E0215022482C462040
+6AE0:202027FE241027D4FD4A2484250277DC6C54A5E6A50025DC2844285431482094
+6AE1:2210221023DE2528F884204423F870506FFCA080A3F82D0821F8210821F82108
+6AE2:210827C825482FF0F55E27E4211477D46D54A7D4A2142FC82448269421942662
+6AE3:110817FE11081410FAFE1210307C3854567C5254927C121012FE1210151018FE
+6AE4:121013DE15281084FD08109037FE380057D4525493D4125413D41244125412C8
+6AE5:1040102013FE1244FBF4124432EE3A0456F452AC92E4121412A4147415941808
+6AE6:102013FE125013FEFE5213FE32003BFE56925348923A124012FC1548143019CE
+6AE7:24102210207A2712F814277E20087710683CA764A5A4253C25242724253C2024
+6AE8:1040107C104013FCFE4413F032443AFC56A852F892A812F8120015FC15541BFE
+6AE9:13DE125213DE1252FBDE1242327A3A8A571252DA928A12DA128A12FA120A1204
+6AEA:200027FE24442598FC8827DE248875DC6EAAA488A4202520253C2920292037FE
+6AEB:00207F2410FC28284DFE1620247C4EC4157C64440C7C01007FFC05401930E10E
+6AEC:2200213C27A42024F4BC232427A4713C6924A7A4A13C259025582968252A2246
+6AED:2F7E29102F502950FF7E2A282B287D4A6886A7F8A40827F8240827F820002FFE
+6AEE:100013FE102013AEFEAA12AA33AE382057FE502093AE12AA12AA13AE102013FE
+6AEF:2206223827882488F90827DE254875486FDCA55AA56827E820082AA82AA82008
+6AF0:208020402FFE2000F7FC24A427FC72486950A208A44420A8211023082D462180
+6AF1:52107EFE28447E28A2FE3E1020103E7C22103E1001007FFC05401930E10E0100
+6AF2:20202F3C214425BEFA2A212A2FBE72906B2AA25AA22C225C222A22482A282410
+6AF3:2210211027DE2010F45E228227DE70106FDEA450A7DE245027DE2450245224CE
+6AF4:2108210827CE2112F92427DE2552755E6FD2A11EA392255E2940211421122122
+6AF5:1088108813FE10A8FC9011FE31203BFC552051FC912011FE110012A412521452
+6AF6:102013FE122211FCFC2010F8302039FC542055FC915411FC104012A4128A147A
+6AF7:208027FC240427BCF8A026BE22A277B66AAAA6AAA0B626A222BE27A022A2267E
+6AF8:2140226C2244236CFAA423AC22A477FE6908A244A5F2204027FC204020402040
+6AF9:211027FE215023F8F84827FE204873F86D54A75CA44427FC2444275C25542954
+6AFA:200027FC20402FFEF8422358204073586800A000AEEE2AAA2AAA2AAA2EEE2AAA
+6AFB:13DE125213DE1252FBDE125233DE398C5652504097FE10881190106010D81304
+6AFC:2148214C22AAF80827FE21487368694AAB6AA14C236C2148216A239A20262042
+6AFD:00187BE0495053F8604053F8480849F86840529444F401007FFC05401930E10E
+6AFE:21822E3C20882A90F522243C27887A126A3EAF88A2082AAC2AAA2BCA2EA82090
+6AFF:108812AA12DC1488F954122233FE3A0254F8508890F8100011FC110411FC1104
+6B00:204027FC200023B8FAA823B8211077FC6910A7FCA1102FFE212823102D482186
+6B01:22882FE82AA82FE8FABE2FE830086FDC681AABE8A8282FC82AA82A482B283228
+6B02:108813FE10881412FAFE101034FE3A9256FE509291FE1292160412FE1244122C
+6B03:11F0121017FC1204FBFC122433B83A2255FE521097FC124413FC10D0114A163E
+6B04:13DE125213DE1252FBDE122232FA3A2256FA52AA92FA12AA12FA127212AA1226
+6B05:2140226C2244236CFAA423AC22A477FE6908A2F4A44223F8204027FC204020C0
+6B06:2108229423DE26B4FBDE229423DE72946BDEA210A7FC21082090206021982606
+6B07:13FC110811F81108FDF8110E37F8380857FE5294939C1294139C12D617BC1084
+6B08:122213FE109011FEFB1015FE311039FE551051FE910013FE128A137612521276
+6B09:249222942FFE2110F7FC204023F870406FFEA480A7BC2494279424C82F9420A2
+6B0A:108813FE108813DEFE5213DE30A0389055FE512093FC152011FC112011FE1100
+6B0B:13DE125213DE1252FBDE125233DE389055FE511093FE151011FE111011FE1100
+6B0C:2090209027FE2094F80A21FE250877E8694AA1EAAF2A25EA254C29EA22162462
+6B0D:210827FE212823FEFA2027FC2A2073FC6A20A3FEA080231C2204239C220423FC
+6B0E:2288F93E2288729CA92A2288FFFE80023E0822FE3E0822483E28280824283A10
+6B0F:200027FC24A424A4F7FC221022A874BE6F68A23CA4A82FBC20282AA82ABE2020
+6B10:13DE100013DE1252FB5A125230203BFE565053FE925213FE129212DC129214CE
+6B11:252827BE294827BEFB1825AA294673FC6A04A3FCA20423FC220423FC21082204
+6B12:210447C88812F3BC20084B92F83E0380AAAAABAA01007FFC05401930E10E0100
+6B13:2248215027FC2404F9F0211027FC75546CE4A7FCA04027FC20402FFE22A42452
+6B14:13DE125213DE1252FBDE10A031FE3B2055FC512091FE100011FC10881070178E
+6B15:27BC24A427BC2000F7FE24002590749E6FD4A564A5D4255425D425682BC83054
+6B16:2790251E27A82484F7BE252A27BE70006BF8A208A3F8220823F820A02124261C
+6B17:108813FE108813DEFE5213DE32523BDE562253FE92AA12FA1222127212AA1224
+6B18:13FE120213FE1292FE54129232FE3AAA56FE532292FA12AA14FA142219FA1004
+6B19:27FC244427FC2444FFFE2AAA2FBE7AAA6FBEA220A7C020842FFE204225482884
+6B1A:21F0221023E02020F7FC2188265071A86E64A1A0A2482FBE2AAA2FBE228A2FBE
+6B1B:23FE202027FE2422F9AC228027DE72926B92A11EA7D2255227DE21122FD22126
+6B1C:204027FC224823F8F0402FFE2AAA73B86910A7FCA1102FFE212823102D482186
+6B1D:2288F93E2288729CA92A22887FFC44447FFC22083EFE22483E28280824283A10
+6B1E:27FC20402FFE2842FB582040235870006EEEAAAAAEEE20002FFE224825542FFE
+6B1F:228027DE229227D2FD5E27D231126C9E67D2AD12B7DE250827CC251427D42422
+6B20:0800080008000FFC10041108211041000100028002800440082010102008C006
+6B21:00804080208020FC010409080A4014401040E0A020A021102110220824040802
+6B22:00800080FC8004FC050449082A401440104028A024A045108110020804040802
+6B23:022007203820207E204220843F10241024102410242824282448444444848102
+6B24:2020202020203F7E2042408440107E10021002101A28E2284248024414840902
+6B25:004000407C40447C4484448845207C2044204450445044507C88448801040202
+6B26:084008401440147C228452888920082000207E50025004500488088809040202
+6B27:00407E404040447C6484548849204820542054506450405040887E8801040202
+6B28:2040204040407E7C828402887B204A204A204A507A504A500288028815040A02
+6B29:00207F201120117E21422584421080103F1021102128212821283F4421440082
+6B2A:102010209220927E92429284FE10101010109210922892289E48F24400840102
+6B2B:202020203F20487E884208847F10081008102E10282828282F48F04440840102
+6B2C:102008200820FF7E0842108422107C10091012102428C82814482244C0840102
+6B2D:0020FE208220927E92429284FE1092109210AA10A628C2288248FE4482840102
+6B2E:422022202420FF7E084208844910491049107F10092810281048204440848102
+6B2F:104010401040FE7C108410887D20002000207C504450445044887C8845040202
+6B30:0820082010207F7E5542558455105510551055105528552857A8FC4400440082
+6B31:104010402840247C428480887D20002000207C504450445044887C8845040202
+6B32:142012202120497E0842148422104110BE1022102228222822483E4422840102
+6B33:082008200F20087E08427F845510551055107F10552855285528514445444282
+6B34:104008407E40427C42847E88432042207E204050485044504A88528861044202
+6B35:40404C407040447C44843C8841207C2090201050FE5010502888248845048202
+6B36:08200820FFA0087E08427F84491049107F1008101C282A284948884408840902
+6B37:422024201820247E52421084FF10201028107E10AA282A282A482E4408840902
+6B38:102010202020447EFE42028440107C1090101010FE2810281048284444848502
+6B39:082008207F20143E22224144FF5002907A104A104A107A284A2802440A440482
+6B3A:22202220FFA0227E22423E84221022103E1022102228FFA82448224442848102
+6B3B:104052405440907C288444888320102010205250545090502888248843048202
+6B3C:0020F7201120557E22425584891010100010F710112855282228554489441082
+6B3D:104010402840247C4284BC8811201020FE2010509450585050881E88F1044202
+6B3E:08200820FF20087E08427E8400107E100010FF1008284A284948894428841102
+6B3F:102010203E20227E4442808410106610421042106628422842487E4442840102
+6B40:082008207F201C7E2A42498400107E100010FF1008284A284948894428841102
+6B41:22202220FF20227E3E4222843E1022102210FF1040285428624840447E840102
+6B42:102092209220927EFE420084FE1010102010FE10AA28AA28AA28AA44AA448682
+6B43:02200F207820087E0842FF8428104B10491049106B28492849487F4441840102
+6B44:00203E202220227E3A422A842A107F1041105D10552855285D28414445444282
+6B45:0040FE402840287CFE84AA88AB20FE2010201050FE50105010881E88F1044202
+6B46:10200820FF20007E42422484FF1000107E10421042287E28424842447E844302
+6B47:00207E2042207E7E42427E8420107F1089104910552841287D2801440A440482
+6B48:102028204420827E7D420084F11095109510F51095289528F52891449544B282
+6B49:22201420FFA0147E14427F841510FF9015107F1014283628552894C414441482
+6B4A:10200820FF20007E7E4242847E100010FF108110BD28A528BD28814485448282
+6B4B:03207C204720447E5F42558456105C10551053105028572855485544A9840102
+6B4C:0020FF2002207A7E4A427A840010FF1002107A104A284A287A2802440A440482
+6B4D:102020207F20417E41427F8440107FD040107F9000A8AAA8AAA800C405440282
+6B4E:22202220FF20227E3E4208847F1049107F1008107F280828FF48144422844102
+6B4F:22202220FFA0227E3E4208847F1049107F1008107F2808287F2808440F44F082
+6B50:0020FFA080209F7E914291849F108010BB90AA90AAA8AAA8BBA88044FFC40082
+6B51:0410079004103FDE245227243C88238820882F0832482A945FD442148A140422
+6B52:20201020FE20447E2842FE8482109210FE109210BA28AA28AA28BA4482448682
+6B53:202020203F20483E88227F44145022907F10A4103F1024283F2824443F442082
+6B54:10201E2010207F3E51225C4472504E9040104A106A905B284A288F4478440082
+6B55:08207F200820223EFFA222447F5041907F1041107F1041287F28224441448082
+6B56:0820FF2008207E7E00427E8442107E102410FF1000287E28422842447E444282
+6B57:04103F9004907FDE04923FA40408554875C844487FC8445475D4555455548462
+6B58:0820292029204A7E144222844110001022102A90B72862282228524445448882
+6B59:0820142022205D3E80A23E4422503E9000107710111055283328554411443382
+6B5A:11100A107FD0041E3F9204247FC8248815087FC800083F94209420943F9420A2
+6B5B:082008201420227E4142BE840010001077105510552877282228224455448882
+6B5C:00207F205520557E7F4220847F1091107D10551055287D2811287D4405440282
+6B5D:00207F2055207F7E08427F840810FF90221014107F280828FFA8084408440882
+6B5E:00207F2041207F7E41427F842210551077102210552877280028554455440082
+6B5F:28204B204D20497E6B424D845510771055105510FFA800282228214441448082
+6B60:772055202220557EF742558422105510FF9014107F28552863285D4441447F82
+6B61:22202220FFA0227E77425584771012103F106410BF2824283F2824443F442082
+6B62:01000100010001001100110011F81100110011001100110011001100FFFE0000
+6B63:00007FFC0100010001000100110011F8110011001100110011001100FFFE0000
+6B64:0440044004402444244827502460244024402440244024422F42F042403E0000
+6B65:0100010011F8110011001100FFFE0100010011081110212040C003001C00E000
+6B66:004000503F4800480040FFFE0040044004402740242024222412278AF8064002
+6B67:0820082008200BFE48204E20482049FC4884488848484E505820E05001880606
+6B68:0100010011F8110011001100FFFE00000100110011F811001100290047FE8000
+6B69:0100010011F8110011001100FFFE0100011011081114212440C003001C00E000
+6B6A:00007FFC0100030005601918610400007FFC0100110011F811001100FFFE0000
+6B6B:080008FE0880088048804EFC488448844884488448FC4E805880E08000FE0000
+6B6C:010011F811001100FFFE010002001FF0101012101110FFFE1210211040508020
+6B6D:10201020102011FC50205C2053FE5008500851FE50085C887048C00800280010
+6B6E:0100010011F811001100FFFE00000810081048904E9C489048904E90F1FE0000
+6B6F:0100010011F811001100FFFE0000292825482FE823882548292820083FF80008
+6B70:00007EFC122452A4932422442A544488081008104E9C489048904E90F1FE0000
+6B71:1008103C11E0102053FE5C2051FC512451FC512451FC5C2071FCC02003FE0000
+6B72:008008FC088008807FFE002800243FFE20202FA422242A182A90512A46469882
+6B73:008008FC088008807FFE002800243FFE20202FA422242B182A9252AA4A468482
+6B74:3FFE221022103FBE261027382AD43292221022502040227C424042409FFE0000
+6B75:102011FE102011FC50205DFE500051FC510451FC51045DFC7104C1FC00880104
+6B76:08442F7828422F3EF0001FF011101FF011101FF001003FF821482FE824282018
+6B77:3FFE2000230C3C7024103F7E24102E3835542492208024F844804480BFFE0000
+6B78:10007DFC44047CFC40047DFC44007FFE122210205DFC512451245D34E1280020
+6B79:0000FFFE02000200040007F8080810102410422001400080010002000C007000
+6B7A:0080008000FE088008800FF8100814102210412001400080010002000C007000
+6B7B:0000FFFC1080108010841E88229022A052C08C800480088408841084207C4000
+6B7C:0008003CFDE0202020203C20442047FE64209420082008201020202040208020
+6B7D:0008001CFDE0210021003D0045FE451065109510091009101110221042108410
+6B7E:00800080FC8020FC21543E5444544494649495240A2408441044208441288010
+6B7F:00800080FCFC210421043E28441047FC65049488088808501020205041888606
+6B80:0008003CFDE0202020203C2045FE442064209450085008501088208841048202
+6B81:000000F8FC88208820883D06460045FC64849484084808501020205040888306
+6B82:000001F8FD08210821083DF845084508650895F8090809081108210847FE8000
+6B83:00200020FC2021FC21243D2445244524652497FE082008501050208841048202
+6B84:00200020FC50208821043E124420444065889410082008441188201040608380
+6B85:00200020FD20212021FC3D2046204420642095FC082008201020202043FE8000
+6B86:0020FC202020204020483C8445FE4482640094FC088408841084208440FC8084
+6B87:00800080FCFE210022F83C104420444065FC9494089409241224244440A88110
+6B88:00200020FC40208021FC3D544554455465549554095409541154215443FE8000
+6B89:0080FE8020FC210421043FF445144514A5F41914091411F41114200440148008
+6B8A:00200120FD2021FC21203E20442047FE647094A808A809241124222240208020
+6B8B:00500048FC40205C21E03C40445E47E064449448083008221052208A43068002
+6B8C:000003FCF800212422483C904A48492468009BFC084010401040204047FE8000
+6B8D:0008003CFDC0200421443CA8440045F8641094200BFE08201020202040A08040
+6B8E:00200020FC2023FE20203C2045244524652496AA082008501050208841048202
+6B8F:00280024FC24202023FE3C20452044B264B4946808A809241222202040A08040
+6B90:00200020FDFE202020203DFC4524452465FC9420087008A81124222240208020
+6B91:0020FC2023FE202020203DFC45044504650495FC08500850109220924112820E
+6B92:000000F8FC88208820F83C0045FC450465249524092409241050204840848304
+6B93:00200020FC50205020883D0446FA440064449424092408A81088201043FE8000
+6B94:00200020F9FC202420243BFE4824482469FC9A22097410A81124222240A08040
+6B95:00400020FDFC200021083C90440047FE6400940009FC09041104210441FC8104
+6B96:0020FC2023FE202020203DFC450445FC650495FC090409FC1104210447FE8000
+6B97:00400080FBFC211022483C464BF84A486A489BF80A48124813F820424042803E
+6B98:00900088FCBC23C020503C2444D4472C649094BC0BC008481050202440D4830C
+6B99:001C03E0FA2023FE22203A924B0A4A0669FC9904090411FC1104210441FC8104
+6B9A:01040088FC5021FC21243D2445FC4524652495FC0820082013FE202040208020
+6B9B:000003FCF808201020203BAE4AA24AAA6AA49AA40BAA103210A0204047FE8000
+6B9C:00480148FD4823FE21483D484578450065FE94200BFE087010A8212446228020
+6B9D:00200020FBFE202021FC38404BFE488869349AE2082011FC107020AC43228020
+6B9E:000001F8F908210821F838004BFC4A046BFC9A040BFC120413FC209041088204
+6B9F:000001F8FD08210821F83D08450845F8640097FC0A940A941294229447FE8000
+6BA0:00200040FDFC210421FC3D0445FC450465FC942808240BFE1050208841048602
+6BA1:00400020FBFE2202241439E04900490069FC9910091017FE1000209041088204
+6BA2:01540154FBFE215421543A724C004BFE6A22982009FC112411242124412C8020
+6BA3:0088FC8823FE208820F83C2045FC452465FC94200BFE082011FC202043FE8000
+6BA4:008000FEFD0022FC20843CFC448444FC640097FE088009FE12522092412A8044
+6BA5:0040FC2023FE220220003DFC442045FC652495FC092409FC1000208841048202
+6BA6:00400080FDFC210421FC3D0445FC450065FE950009FE080212AA22AA4202800C
+6BA7:02140112FBD22010203E3BD04A504A506BD099280BA813681528212A452A8246
+6BA8:002001FCFD2421FC20203FFE440045FC650495FC090409FC110421FC40888104
+6BA9:008000DCFA8423D424483A944B244C406A4899500FFC10E0115022484C468040
+6BAA:002003FEF82021FC20003BFE4A0249FC680099FC090411FC1104208843FE8000
+6BAB:000003DEFA52225223DE380049FC492469FC992409FC102013FE202040208020
+6BAC:000001FCFD5421FC20203DFC442047FE6488945009FC082013FE202040208020
+6BAD:000003FEFC0021FC21243DFC452447FE640095FC092409FC112421FC400083FE
+6BAE:00200020FC50208821043EFA4400440065DC9554095409DC1088208841548222
+6BAF:00400020FBFE220221FC39484A5049FC6B0499FC090411FC110421FC40888104
+6BB0:002003FEF82021FC20003BFE4A524BFE690499FC090411FC110421FC40888104
+6BB1:0088008CFBEA208820883BFE49484B6A694A9B6A094C136C114A216A47968022
+6BB2:0148014CFAAA200827FE39484B68494A6B6A994C0B6C1148116A239A40268042
+6BB3:00000FE00820082008201020201EC0003FF010100820044003800C603018C006
+6BB4:00007EF840884488648854864900480055FC54846488405040207E5000880306
+6BB5:060038F82088208820883C86210020003DFC208420882C50F020205020882306
+6BB6:1000087800487F480848088608007EFC08440844082808280F10F02840440182
+6BB7:0600387820483E4822483E8622003EFC20443E442228222842104A2884440182
+6BB8:080008787F48084808483E8600003EFC2A442A443E2820282010402840448182
+6BB9:00007F78484848485F486486440044FC7F4444444A285128601040287E440182
+6BBA:040044782848104828484486920010FCFE441044582854289210122850442182
+6BBB:080008787F4808483E4800867F0041FC82443C44242824282510262844448182
+6BBC:080008787F4808483E4800867F0041FCBE4400443C2824282510262844448182
+6BBD:420024781848244852481086FF0020FC3E446244BE2822283E1022282A442582
+6BBE:100010787D4812481448FF86100020FC7E44A24422283E28221022283E442382
+6BBF:00003F78214821483F4820862A002AFC3F442A442A283F2820104A2891442182
+6BC0:2000CE7882488248EE4882868200FEFC10441044FE28102810101E28F0444182
+6BC1:2000CE7882488248EE4882868200FEFC00440044FE28102810101E28F0444182
+6BC2:1000FE7810487C480048FE86820010FC7C44204450287C281010FE2810441182
+6BC3:20001078FE4800487C4844867C0000FCFE448244BA28AA28BA1082288A448582
+6BC4:10007E7810487E4852487E8652007EFC1044FF4410287E28421042287E444382
+6BC5:100008787F4822481448FF86100029FCCE4414442628CD2815102428D4440982
+6BC6:0000FFB880289F28912891469F00807CBBA4AAA4AAA8AAA8BB908028FFC40082
+6BC7:1000673841287728412841467F00087C49242A24FFA81C282A10492888440882
+6BC8:2040CE9C8A94AA94AAD4EE94AAA6AAC0AA9CAA94EE94A8D42B884888489488A2
+6BC9:7F7848485F4C64805F784A4851307F4C00007FFC1110111029284544FFFE0000
+6BCA:0878FF4808863E782A483E3040489FF40200FFFE08203FF8D0161390129013B0
+6BCB:00001FF01110111011101110FFFE21102210221022103FFC0410081010A02040
+6BCC:00001FF011101110111011101110FFFE221022102210221022103FF000100010
+6BCD:00001FF01010121011101110FFFE20102210211021103FFC0010001000A00040
+6BCE:10001FFC200020005FF0911011101110FFFE2210221022103FFC001000A00040
+6BCF:10001FFC200020005FF0901012101110FFFE2010221021103FFC001000A00040
+6BD0:01000100FFFE01003FF800001FF011101110FFFE211022103FFC041008501020
+6BD1:00103E502250325C2A7422D42254FF544254525C4A5042507F420242143E0800
+6BD2:01003FF801001FF001007FFC00001FF012101110FFFE221021103FFC00100060
+6BD3:402040107DFE80207C48448465FE5402FEA844A8A4A894A8FEAA052A29261200
+6BD4:0080208020802084208820903EA020C0208020802080208226823882207E0000
+6BD5:2080208820B03EC0208020842684387C21000100FFFE01000100010001000100
+6BD6:2080208820B03EC0208020842684387C0100009048A4484289820E101810E7F0
+6BD7:001001107D1055125512551455D87D1055105510551055127D524592010E0000
+6BD8:00003FF8210821083FF8210821083FF80000208020843E9820E020842684387C
+6BD9:410041187DE041044D0470FC0000FFFE108010883E9042E0148008843084C07C
+6BDA:1FC020807FE0A0203FE020883CF420841FFC20407FF0A2103FF005441924E0FC
+6BDB:001001F87E000200020003F03E000200020003FCFE00020002040204020401FC
+6BDC:08201C207020102010A81CA47124112212221C20F02010A2104210020FFE0000
+6BDD:08041C08703011C010041C08703011C010041C08F03011C2100210020FFE0000
+6BDE:2080208820B03EC020842084267C380000F03F0001F03F0001F87F02010200FE
+6BDF:0100111011082124414401800E00F00000F03F0001F03F0001F87F02010200FE
+6BE0:080008007F7C094411441144257C420000F03F0001F03F0001F87F02010200FE
+6BE1:08401C407040107C10401C40704011F811081D08F10811FA110A10020FFE0000
+6BE2:10003BF8E0A020A023F83AA8E2A822A822B83B08E20823F8220A200220021FFE
+6BE3:00007EFC22441224060C1A3462C4000000F03F0001F03F0001F87F02010200FE
+6BE4:281824E04220923810E02020443CFEE002222422241E24002402440243FE8000
+6BE5:11003900E1FC220424043BE4E22423E422243A24E3E42004202A201220021FFE
+6BE6:0008FF1C44E0442044207C3C44E044207C20443C44E04F22F4220422041E0400
+6BE7:10503848E0402FFC20403A48E2482F5022503A20E2282468289A210A20021FFE
+6BE8:08201CA070FC112010201DFE7050105010901C92F112120E100010020FFE0000
+6BE9:08201C20712410A410A81C2073FE102010701CA8F1241222102010020FFE0000
+6BEA:10403840E090210823FC3824E12021FC21203A20E7FE20202022202220221FFE
+6BEB:01007FFC00001FF010101FF000007FFE400281F43E0003F03E0003FA7E0201FE
+6BEC:08201C28702413FE10201D2470A8107010A81D24F22210A0104010020FFE0000
+6BED:0008FF1C00E000207E20423C42E042207E20003C42E0222224220F22F01E4000
+6BEE:1020102011241122FA2A101014601B80303CD3C0107C13C0107C17C25042203E
+6BEF:10403A44E244244820A03910E608204420403A48E248245020A22112220A1FFE
+6BF0:08401C2071FC100010881C5073FE100010F81C88F088108A10FA10020FFE0000
+6BF1:11003900E1FC220424843C94E2A427FC208439C4E2A4249420AA209220021FFE
+6BF2:0004F70E117055102210551C897010100010F71E11705510221255128912100E
+6BF3:01F03E0003F03E0003FA7E0201FE0000183071C01C7871C01C7871C41444183C
+6BF4:10903890E090279E20903890E39C209020903890E79E20902092209220021FFE
+6BF5:0808101C24E07E201020FF3C24E042208920303CC4E008223222C422381EC000
+6BF6:08401C8871FC102413FE1C88713412C210181CE0F00C103011C010020FFE0000
+6BF7:00047F0E41705D1041105D1C417000103E10221E3E7022103E1222123E12220E
+6BF8:08001DFC712411FC11241DFC7020101411521D42F248103A100210020FFE0000
+6BF9:0804140E22704110BE90001C78F04A904A907A9E4AF04A907A9248924A92590E
+6BFA:10203850E088210426FA3800E3C4225423D43A54E3D42244225622CA20021FFE
+6BFB:1008101CFEE020207E20883C7EE000207E20423C7EE042227E2242224A1E4400
+6BFC:00087E1C42E07E2042207E3C20E07F209120513C69E041227D2201220A1E0400
+6BFD:10103810E77C211422FE3A14E77C2110217C3910E6FE2210251228FE20021FFE
+6BFE:00047F0E41707F1041107F1C0070F7901090949E52F03190D69210925292210E
+6BFF:1004220E7F7042109490F79C08703610C910309EC470191062120C123012C00E
+6C00:08047F0E4970FF9049107F1C08707F1049107F1E1070FF10211272120C12F30E
+6C01:11103910E7FC211023F83A08E3F8220823F83840E7FC20A02112220A20021FFE
+6C02:08203E7E08A47F281C102A2849443FFE200020782F8020F0278040FA4F82807E
+6C03:1004080E7F702210FF10001C7F7049107F10491E7F7008107F1208120F12F00E
+6C04:7E04140E0870FF1029104A1CA87010107F10551E63705D1055125D124112430E
+6C05:082049202A3E7F4841A85D2855105D2842F63F0001F03F0001F87F02010200FE
+6C06:11083890E3FC209022943998E09027FE200039F8E10821F8210A21FA20021FFE
+6C07:11003BF0E4102BF822483BF8E24827FC20003BF8E20823F8220A23FA20021FFE
+6C08:1008FE1C00E0FE208220BA3CAAE0FE2000207C3C44E07C2244227C22001EFE00
+6C09:00047F0E41707F100010F79C94F0F7900810081EFF701C102A1249128892080E
+6C0A:10203BFEE00023FC22043AF4E29423FC210839F8E10821F8200227FE20021FFE
+6C0B:2404FF0E2470FF1081107E1C0070FF101010289ED5702E10D5122492D412080E
+6C0C:108039F8E20825FC212439FCE12421FC21543AFAE08820F8208A20FA20021FFE
+6C0D:7704550E777055107710551C777022107F90A41E3F7024103F1224123F92200E
+6C0E:3F84248E3FF024907FD0555C7FF055507FD0041E7FF048501F122A1204127FCE
+6C0F:001000F83F802080208020803FFE208020802040204020222012280A30062002
+6C10:001000F83F802080208020803FFE208020802040204020222112288A30462042
+6C11:00003FF82008200820083FF8208020803FFC20802040204024242814300C2004
+6C12:00F03F00210021003FFC2080204028243114210C0100FFFE0100010001000100
+6C13:200013FC12040204FA0443FC4220422043FE4220422042107A12028A03060202
+6C14:100010003FFC20004FF080003FF000100010001000100010000A000A00060002
+6C15:100010003FFC20004FF080003FF000100410041004100410080A080A10062002
+6C16:100010003FFC20004FF080003FF000103F101110121017D0204A204A42868102
+6C17:100010003FFC20004FF080003FF00010009030900D100210050A188A60460002
+6C18:100010003FFC20004FF080003FF000100010111011101110210A210A41068102
+6C19:100010003FFC20004FF080003FF000100410041044504450444A7FCA00460002
+6C1A:100010003FFC20004FF080003FF000102490249024902490248A448A44868082
+6C1B:20003FFC40009FF000007FF00010121021104090BF501112110A110A25064202
+6C1C:20003FFC40009FF000007FF000103F90209020903F902092208A208A3F862082
+6C1D:100010003FFC20004FF080003FF0041004107FD044504A50514A604A41464082
+6C1E:20003FFC40009FF000007FF000107FD004107FD044504A52514A604A41464082
+6C1F:20003FFC40009FF000007FF012107F9012907F9052107FD2124A134A22864202
+6C20:20003FFC40009FF000007FF0041004107FD044507FD044527FCA444A04060402
+6C21:20003FFC40009FF000007FF010101F90209051100E103192CC6A030A1C060302
+6C22:20003FFC40009FF000007FF000103FD003100CD070301FD2020A020A7FF60002
+6C23:100010003FFC20004FF080003FF00410249015107FD00E10150A248A44460402
+6C24:20003FFC40009FF000007FF000107FD0445044505F5044524A4A514A7FC64042
+6C25:20003FFC40009FF000007FF000107FD00A103F902A902A92338A208A3F862082
+6C26:20003FFC40009FF000007FF004107FD0081011103E100492190A620A0D063082
+6C27:20003FFC40009FF000007FF011100A107FD004103F900412FFEA040A04060402
+6C28:20003FFC40009FF000007FF004107FD040500810FFD01112320A0C0A1B066082
+6C29:20003FFC40009FF000007FF000107F901210125092905312520A120AFFC60002
+6C2A:20003FFC40009FF000007FF004107FD004103F9020903F920A0A124A224641C2
+6C2B:20003FFC40009FF000007FF000107FD02490491024907FD2040A040AFFE60002
+6C2C:20003FFC40009FF000007FF00010FFD01210739040904092738A120A1206FFE2
+6C2D:20003FFC40009FF000007FF004107FD004103F9024903F92248A3F8A15062482
+6C2E:20003FFC40009FF000007FF0041024900B10109060500412248A0B0A10866042
+6C2F:20003FFC40009FF000007FF000107F9000903F900090FFF2248A150A24864C42
+6C30:20003FFC40009FF000007FF004107FD004103F900410FFF2208A3F8A20862182
+6C31:20003FFC40009FF000007FF010901F9010903FF010103FD24A4A124A25460882
+6C32:20003FFC40009FF000007FF000103F9020903F9020903F92000A7FCA4A46FFE2
+6C33:20003FFC40009FF000007FF000103F9024902A903F9000127FCA4A4A4A46FFE2
+6C34:010001000100010801087D9005A0094009401120111021084106810005000200
+6C35:0000200010001000800040004800080010001000E00020002000200020000000
+6C36:00003FF000200040008401087D9005A005400940092011102108C10605000200
+6C37:0100010011000908090801907DA005400940092011102108C106010005000200
+6C38:0200010000801F00010401087D9005A005400940092011102108C10605000200
+6C39:00400040F84008440F480950116012502248244448444140408240023FFE0000
+6C3A:01000100010041082108111011200180054009201110E1084104010005000200
+6C3B:008020801080108087FC40844884088410841084E10421042104220422280410
+6C3C:010001047D880550092011102108C5060200010001000280044008203018C006
+6C3D:01000280044008203118C10601003D8405880950092011102108C10605000200
+6C3E:000023F812081208820842084A080A0812501220E20022022202220221FE0000
+6C3F:010021001100110087F041104910091011101110E110221222122412280E1000
+6C40:0000200013FE1020802040204820082010201020E02020202020202020A00040
+6C41:00402040104010408040404047FE104010402040E04020402040204020400040
+6C42:0120011001007FFC01002108111009A003400520091011086106010005000200
+6C43:0000202011201120812041204920092011201110E11022102208240828041002
+6C44:0040204010401040804040404840084010A010A0E0A021102110220824040802
+6C45:000027FE10801080810041004A000BF810081008E00820082008200820500020
+6C46:0600010002800C603118C10601003D8405880950092011102108C10605000200
+6C47:000023FE12001200820042004A000A0012001200E20022002200220023FE0000
+6C48:000027FC10041004800440144824084410841104E60420042004200420280010
+6C49:000027F812081208820841104910091010A010A0E040204020A0211022080C06
+6C4A:000027F812081288824841504910091010A010A0E040204020A0211022080C06
+6C4B:00802080110011FC820442045404190410842044E04420042004200420280010
+6C4C:0204224412441244824442444244124412442244E24422442244244424040804
+6C4D:008020801080108087F0409048900A9011901090E1502152220A220A24060802
+6C4E:000023F012101210821043105290125012502210E210221224122412280E1000
+6C4F:0040204010401040804047FE4840084010A010A0E0A021102110220824040802
+6C50:00802080108010FC810441044284144810282010E01020202040208021000600
+6C51:0010207813C01040804040404840087E17C01040E040204220422042203E0000
+6C52:004020201020100087FE41004900090011001100E10021002100210021FC0000
+6C53:000023F8100810108020404048400FFE10401040E04020402040204021400080
+6C54:00802080110011FE8200440041F8100810102060E08021002202220221FE0000
+6C55:0040204010401040844444444444144414442444E4442444244427FC20040000
+6C56:010001002108210821083FF80000010001047D880550092011102108C5060200
+6C57:0000200013FC1040804040404840084017FE1040E04020402040204020400040
+6C58:0010207813C010408040404048400FFE10401040E04020402040204020400040
+6C59:000021FC102010208020402048200BFE10201020E02020202020202020A00040
+6C5A:000023F810401040804047FE48800880110011F8E00820082008200820500020
+6C5B:000027F01110111081104110411017D011102110E1102112210A210A21060102
+6C5C:000023F812081208820842084A080BF812001200E20022022202220221FE0000
+6C5D:00802080108010808FFE41084108120812102610E1A0204020A0211022080C04
+6C5E:00003FF8010001000100FFFE0000010001047D880550092011102108C5060200
+6C5F:0000200017FC1040804040404840084010401040E040204020402FFE20000000
+6C60:0040204012401258826842C853481E4812482248E25822422202220221FE0000
+6C61:000023F810001000800047FE40801080110021F8E00820082008200820500020
+6C62:00402040104010408040404047FC104010402040E0402040204020402FFE0000
+6C63:00802080108010F88108410849100A1010201020E05020502088210822040402
+6C64:000023F0102010408080410043FC112411242124E22422442444288421280210
+6C65:00402040104017FE80404040404017FC12042208E11020A0204020A023180C06
+6C66:0008203C13E01220822042204A200BFE12201210E2102212220A228A23060202
+6C67:000027FC111011108110411049100FFE11101110E11021102110211022100410
+6C68:000023FC12041204820442044A040BFC12041204E2042204220423FC22040000
+6C69:0000200017FC140484044404440417F414042404E4042404240427FC24040000
+6C6A:000027FC1040104080404040404013FC10402040E0402040204020402FFE0000
+6C6B:011021101110111087FC41104110111011102FFEE11021102110221022100410
+6C6C:082008207FFC08200820FFFE10202020412001047D88095011202118C5060200
+6C6D:002020201020102083FE42224A220A221252124AE28A230222022202220A0204
+6C6E:0100410021FC2204020485044884408410142024E04423842104200420280010
+6C6F:0080408020802FFE008080804120512011202240E2402488248829FC20840004
+6C70:004020401040104087FE4040484008A010A010A0E11021102288224824440802
+6C71:0040205010481048804047FE4840084010A010A0E0A021102110220824040802
+6C72:000027F81108111081104120493C090411041288E28822502420245028880306
+6C73:0008203C13C01200820042004BF80A8812881288E25022502220245024880906
+6C74:008020401040100087FE4080488008C010A01090E08820882080208020800080
+6C75:0040204010A010A0811042884C460840100013F8E00820102010202020200040
+6C76:00802040104017FC8110411049100910111010A0E0A0204020A0211022080C06
+6C77:008020801080108081F841084A080D10111010A0E0A0204020A0211022080406
+6C78:00802040104017FE81004100490009F811081108E10821082208220824500820
+6C79:0000200811081088825242524A220A2212521292E30A220A220223FE20020000
+6C7A:00802080108017F8808840884888088817FE1080E14021402220241028081006
+6C7B:00802080108011FC812041204A200820102017FEE02020202020202020200020
+6C7C:002020201120112081FC422042201420102027FEE02020202020202020200020
+6C7D:0100210011FC1200840041F84800080013F81008E0082008200A200A20060002
+6C7E:001021101110120882084404580213F811082108E10821082208220824500820
+6C7F:000023F81008111080A0404047FE104210442040E04020402040204021400080
+6C80:0800087C080409280910EA082CFE2A1229144910489088900810081028501020
+6C81:0000208010401020812041004100150415022502E50229082108210820F80000
+6C82:0008203C13C012008200420043FE121012102210E21022102210241024100810
+6C83:0010207817C0104080404040404017FE104020A0E0A021102110220824040802
+6C84:0000200013FC10008000400047FE104010402080E0802108220427FE22020000
+6C85:0000200013F810008000400047FC112011202120E120212022222222241E0800
+6C86:00802040104017FC8000400049F0091011101110E110211222122212240E0800
+6C87:0080208011001110820847FC4004112011202120E120212022222222241E0800
+6C88:00402040104017FE84444848404010A010A020A0E120212022222222241E0800
+6C89:0000200013FE12028404400041F0111011102110E110211222122212240E0800
+6C8A:1020102010207E2453A894B010A8112429222A222C2028A22842480247FE8000
+6C8B:009020881088108087FE40A048A008A010A010A0E120212221222222221E0400
+6C8C:00402040104017FC804042484A480A48124813F8E048204020422042203E0000
+6C8D:000027FE10801080808040F84908090811081208E3F820102010201027FE0000
+6C8E:01202120112012248224462856301A20126022A0E220222222222222221E0200
+6C8F:0000220012FC12248224422453A41E2412242224E2A423242244204420940108
+6C90:004020401040104087FE404048E008E011501150E24824442842204020400040
+6C91:000023F8108810888088408848880BF811081108E1082108210821082FFE0000
+6C92:0080208010FC11048104422848100BFC11041088E08820502020205021880606
+6C93:010001087D1005A009603118C50602001FF0101010101FF0101010101FF01010
+6C94:000027FE104010408240427C4A440A44124413FCE00420042004200420280010
+6C95:01002100110011FC82A444A440A4112411242244E44420842104220424280010
+6C96:004020401040104087FC44444444144414442444E7FC24442040204020400040
+6C97:00003FF801000100FFFE028004401830E10E11100B2005C01930610805000200
+6C98:0020222012201222822242244BA80A3012201220E220222222A22322221E0000
+6C99:0040204010401148814442424242144810482048E01020102020204021800600
+6C9A:0040204010401040824042404A7C0A4012401240E2402240224022402FFE0000
+6C9B:0040404020402FFE0040804047FC544414442444E44424542448204020400040
+6C9C:0010221012101210821043FE4A000A00120013F8E20822082208240824080808
+6C9D:0820082008200A200A32EDB228B42CA82AA82AA8492449248A22082028A01040
+6C9E:00004FFE20402040004087FC4444544414442444E44424542448204020400040
+6C9F:01002100110011FC820444844084110411442224E7F422142004200420280010
+6CA0:0008203C17D01490849044904490149014902488E48824882484288428821000
+6CA1:000021F01110111081104210540E180013F82208E108211020A0204021B00E0E
+6CA2:000021FC110411048104410449FC092411201120E11021102208220824040802
+6CA3:00202020102013FE80204020482009FC10201020E02027FE2020202020200020
+6CA4:000023FC12001208828842504A500A2012201250E25022882308220023FE0000
+6CA5:000023FE12001220822042204AFC0A2412241224E24422442484248429281210
+6CA6:0040204010A010A0811042084406111011202140E18021002104210420FC0000
+6CA7:0040404020A02110020884044BF2421012102210E25022202204220421FC0000
+6CA8:000023F812081208832842A84AA80A48124812A8E2A8232A240A240A28061002
+6CA9:0040224011401140804047FC40441044108420A4E09421142104220424280810
+6CAA:00802040104013FC82044204420413FC12042200E20022002400240028001000
+6CAB:00402040104017FE8040404048400BFC104010E0E15022482446284020400040
+6CAC:00402040104013FC8040404048400FFE10E01150E15022482444284220400040
+6CAD:004020501048104087FC404040E010E011502150E24824442842204020400040
+6CAE:000023F812081208820843F84A080A08120813F8E2082208220822082FFE0000
+6CAF:010001087D1005A009603118C50602007FFC040008001FF82808C8080FF80808
+6CB0:0000200017FE104080404080488009F813081508E90821082108210821F80108
+6CB1:00802040104017FC840448084200121012202240E38022042204220421FC0000
+6CB2:0100210013FC120084404840427812C813482E48E248225A2242220221FE0000
+6CB3:0000200017FE1008800843C84248124812482248E3C822482008200820280010
+6CB4:0040204010A01110820844264040108013102020E04020882310202020C00700
+6CB5:00802080108011FE810242045420102011282124E22422222422202020A00040
+6CB6:000023FC10001000800040004FFE104010402248E24424442442284221400080
+6CB7:009020881088108087FE4080490009FC11441244E24824502420285020880306
+6CB8:01202120112017F88128412847F81520152027FCE12421242234222824200820
+6CB9:004020401040104087FC444444441444144427FCE44424442444244427FC0404
+6CBA:000027FC1444144484444444444417FC14442444E4442444244427FC24040000
+6CBB:0040204010801110820847FC4004100013F82208E20822082208220823F80208
+6CBC:000027FC108410848084410441141208140023FCE20422042204220423FC0204
+6CBD:004020401040104087FE40404840084013F81208E20822082208220823F80208
+6CBE:004020401040107E804040404840084013FC1204E20422042204220423FC0204
+6CBF:000021F01110111081104110420E1400100023F8E20822082208220823F80208
+6CC0:000023FC1004100487F4400448040BE412241224E22423E42004200420140008
+6CC1:000027F8140814088408440847F8112011202120E120222022222422281E1000
+6CC2:000023FC12041204820442F44A940A9412941294E2F422942204220422140208
+6CC3:01002100120013FC8404480443E4122412242224E22423E42224200420280010
+6CC4:004822481248124882484FFE4248124812482248E27822002200220023FE0000
+6CC5:000027FC140414448444444444441444144424A4E49425142604240427FC0404
+6CC6:004020401240124083FC42404440104017FE2040E0A020A02110220824040802
+6CC7:020022001200121E87D242524A520A5212521252E25222522452245E29521080
+6CC8:0080208010F81108831044A0404010A013182C06E0C020202010218020600010
+6CC9:010002001FF0101010101FF0101010101FF001047D88095011202118C5060200
+6CCA:00402040108013FC820442044A040A0413FC1204E20422042204220423FC0204
+6CCB:00402040104017FC804040404150111011102FFEE11021102210221024100810
+6CCC:0000208010401028812841084110151415222522E54229882108230824F80800
+6CCD:004020401040104087FC404048E008E011501150E24825F42842204020400040
+6CCE:01002100110011FE82804280448010F810802080E08020FC2080208020800080
+6CCF:0040204012481248824842484BF8084810401040E44424442444244427FC0004
+6CD0:0010479024902510057E86124512549214922492E692251224222422244A0484
+6CD1:0220422022202420057C89244E24422414242424E9242F242144204420940108
+6CD2:0008203C13D01290829042904A900A9012901288E28822C822A424D424920800
+6CD3:0008278810881088808847884408141014102790E09420A420A220BE25020200
+6CD4:010821081108110887FE410841081108110821F8E10821082108210821F80108
+6CD5:004020401040104087FC4040404010401FFE2040E0802100221024082FFC0404
+6CD6:00002100163C14A484A444A444A414A414A425A4E6B424A82120212022200420
+6CD7:0000200017FC14A484A444A444A414A414A42524E51C26042404240427FC0404
+6CD8:0010207817C01040844442444248104017FE2040E04020402040204021400080
+6CD9:000023F810401040824841484950084017FE1040E04020402040204020400040
+6CDA:0120212011201524852445E84530152015202520E520252225E22E22241E0000
+6CDB:00102078178010008080404047F8101010202040E08021002200250028FC0000
+6CDC:0008203C13E01220822042204A200BFE12201210E2102212220A228A23260212
+6CDD:0008203C13C01200820042004BFE0A1012101270E21022182214241024100810
+6CDE:00802040104017FC840448084000100017FC2040E04020402040204021400080
+6CDF:000027FC10401040804040404A400A7812401240E2402240224022402FFE0000
+6CE0:0040204010A010A0811042484426102013F82008E010211020A0204020200020
+6CE1:0100210011FC1204820447E44A241224122423E4E21422082202220221FE0000
+6CE2:00202020102013FE822242244A200BFC12841288E24822502220245024880906
+6CE3:008020401040100087FC40004008120812082110E1102110212020202FFE0000
+6CE4:0008210810881448844844084408140814102410E41025282624244420820102
+6CE5:000023FC12041204820443FC4A000A4012441248E270224024422442283E1000
+6CE6:000023FC1204120483FC42404A400A4013F81248E24822482488248A290A0206
+6CE7:002820241024102083FE42204A240A2412241228E22822902312222A20460082
+6CE8:00802040100017FC804040404040104013FC2040E0402040204020402FFE0000
+6CE9:004022401240124083FC444054401840104023FCE0402040204020402FFE0000
+6CEA:000023FC12041204820443FC4A040A04120413FCE20422042204220423FC0204
+6CEB:00802040104017FE804040804108121017E02040E0802108220427FE22020000
+6CEC:00402020102013FE820244044000109010902090E08821082108210422040402
+6CED:010821081108120882FE46084A08120812882248E24822082208220822280210
+6CEE:0040204012481148815040404BF8084010401040E7FC20402040204020400040
+6CEF:000023FC12041204820443FC4A200A2013FE1220E22022102212228A23060202
+6CF0:010001007FFC01003FF80200FFFE044009203118CB2605C01930610805000200
+6CF1:00402040104013F8824842484A480A48124817FEE04020A020A0211022080406
+6CF2:00402040105C13E0824042404A400BFC104410C4E14422542C48204020400040
+6CF3:00802040102013C0804440444F48115011602160E25024482844304221400080
+6CF4:010001087D1005A009603118C506020000003FF82448244824482448FFFE0000
+6CF5:0000FFFE040008001FF02810C8100FF0010001047D88095011202118C5060200
+6CF6:22081108111000207FFE40028004010001047D880550092011102108C5060200
+6CF7:012021101110110087FE41404940094811481250E2502262244224C2293E1000
+6CF8:00402040107E1040804043FC4A040A04120413FCE20422002200240024000800
+6CF9:000023F812081208820842084BF80A0812081208E20823F8200020002FFE0000
+6CFA:0008203C17C0140084404440444017FE10402040E24822442442284221400080
+6CFB:000027FE14021904810041FC49000A0013FC1004E00427F42004200420280010
+6CFC:004020481244124083FE4080488008FC11441144E14822502220245028880306
+6CFD:000027F81208111080A0404041B0164E104023F8E040204027FC204020400040
+6CFE:000027F8101010208060409841041602100023FCE04020402040204027FE0000
+6CFF:000023F81208120883F842084A080BF812441248E23022202210228823060200
+6D00:0080210013F812088288424842481FFE12082288E24822482208220824280810
+6D01:0040404020402FFE0040804047FC5000100023F8E20822082208220823F80208
+6D02:00402020102017FE8090409048900A9412921292E49220902110211022500420
+6D03:00802080108017FE810041204A200AA414A41528EA5020502088210822040402
+6D04:000027FE1402140284F244924492149214922492E4F224922402240227FE0402
+6D05:000027FC1040104083F842484A480BF812481248EFFE22082208220822280210
+6D06:000023F810101020804447644168115012502248E4442942208020002FFE0000
+6D07:000027FC140414448444444447FC1444144424A4E49425142604240427FC0404
+6D08:0100210013F8120884104BFE420012F812882288E2A8229022822482247E0800
+6D09:0008203C13C01200820043FE4A000A00120012FCE28422842484248428FC0084
+6D0A:00402040104017FE80804080497C090813101510E1FE21102110211021500120
+6D0B:020821081110100087FC4040404013F810402040E7FE20402040204020400040
+6D0C:000240022FC22212021283D24252545216522552E892209221022202240A0804
+6D0D:000027FE14201420842044F84488148814882488E4F824202420242027FE0000
+6D0E:0040208013FC1204820442044BFC0A0412041204E3FC22042204220423FC0204
+6D0F:00002FFE10401040808047FC44A414A414A424A4E4A424A424A4248424140408
+6D10:00802080113C120084804080497E0B0815081108E10821082108210821280110
+6D11:0120412821242224022086204AFC422012202250E25022502288228823040202
+6D12:00002FFE10A010A087FC44A444A414A414A424A4E51C26042404240427FC0404
+6D13:0040204017FC1040804043F84A480A4812481258E0E0215022482C4620400040
+6D14:00402040104013FC8040404047FE1010101027FEE01022102110211020500020
+6D15:001021101108120884044BFA4208120813F82208E20823F82208220822280210
+6D16:000023F81208120883F84000400017FC10402040EFFE204020A0211022080C06
+6D17:00402240124013FC84404840404017FE11202120E120212022222222241E0800
+6D18:0080208813E8109080A047FE4880090013FC1480E90021F82008200820500020
+6D19:00402240124013FC84404040404017FE10E02150E15022482444284220400040
+6D1A:0100210011F8131084A0404051B0164E104023FCE040244027FE204020400040
+6D1B:0080208011F81208851040A0404010A013182C06E3F822082208220823F80208
+6D1C:08001FF0282007C01830E00E1FF010101FF001047D88095011202118C5060200
+6D1D:00802040104017FC84044888408017FC11102110E21021A0204020A021100608
+6D1E:000027FC1404140485F44404440415F415142514E51425F42404240424140408
+6D1F:0040204017FE104087FC404443FC1240144027FEE04220AA20A4211022080C06
+6D20:004020401090110883FC40244920092011FC1220E02027FE2020202020200020
+6D21:0040204017FC1040804043F84840084017FE10E0E15021502248244428420040
+6D22:0100217C11241224822446FE4A2412241224227CE22422202220222022400280
+6D23:00402040124811488150404047FE104010E02150E15022482444284220400040
+6D24:0040204010A011108208440643F8104010402040E3F820402040204027FE0000
+6D25:0040204013F8104887FE40484BF80840104013F8E040204027FC204020400040
+6D26:000027FE10201020804043FC4A040A04120413FCE20422042204220423FC0204
+6D27:0040204017FE1080810041FC4304150419FC2104E10421FC2104210421140108
+6D28:00802040104017FC800041104208140411102110E0A0204020A0211022080C06
+6D29:00402040104017FC8444444447FC1444144427FCE02820122032204A21860E02
+6D2A:011021101110111087FC41104110111011102FFEE00021102108220824040804
+6D2B:004020401080110083FC42944A940A9412941294E2942294229422942FFE0000
+6D2C:000027F81408140887F84488448814E815282528E6A8244A244A288A29061202
+6D2D:000023FE1200120083FC42204A200AF812201220E22023FC2200220023FE0000
+6D2E:0090209010901492829440984090119812942492E0902090211221122212040E
+6D2F:080008007F7C08243E2408447F540888090001047D88095011202118C5060200
+6D30:000023FE12001200820043FC4A040A0412041204E3FC22002200220023FE0000
+6D31:000027FC1208120883F84208420813F812082208E20E23F82E08200820080008
+6D32:01042124112411248124412445B4156C19242124E12421242124222422040404
+6D33:010021001100111E87D242524252125212522492E29221122292225E24520800
+6D34:020821081110100087FC41104110111011102FFEE11021102210221024100810
+6D35:00802080110011FC8204440443E41224122423E4E224222423E4200420280010
+6D36:02002200120013FC840444044A24114414942554E634241427F4200420280010
+6D37:000027FE104010808110420847FC104410402040E7FC2040204020402FFE0000
+6D38:008020881488129082A040804FFC112011202120E120212422242224241C0800
+6D39:000027FC1000100083F84208420813F812082208E3F82208200020002FFE0000
+6D3A:0080208010FC1104828844504020104011FC2304ED0421042104210421FC0104
+6D3B:0010207813C01040804047FE40401040104023F8E20822082208220823F80208
+6D3C:0040204013F810408040404047FC100010402040E3F820402040204027FC0000
+6D3D:0040204010A011108208440643F81000100023F8E20822082208220823F80208
+6D3E:0008203C17C01400841C45E04520152215242528E51025102508294429821100
+6D3F:0040204017FC10A0811042084DF6100017FC2080E10023F82008200820500020
+6D40:005020501050105083FE42524A520A52125213FEE25222522252225223FE0202
+6D41:0080204017FE10808110420847FC100410002248E24822482248224A244A0846
+6D42:020821081110100083FC40404840084017FE1040E04020A020A0211022080406
+6D43:00402040104017FC80404248515010401FFE20A0E0A021102110220824040802
+6D44:0100210013F0121084204BFC4044104417FE2044E04423FC2044204021400080
+6D45:00A02090108010B887C0408040BC17C010882090E060204420A42114260C0004
+6D46:0840484028FC09041A8828504860898001047D880550092011102108C5060200
+6D47:0080208010BC13C08050402448D40B0C100017FEE090209021122112220E0400
+6D48:00402040107E1040804043F84A080A4812481248E248224820A0211022080404
+6D49:010021FE11101510857C45544554155415542554E5542154225C221024100810
+6D4A:00402040104017FC844444444444144417FC2444E040204820442FFE24020000
+6D4B:000427C414441454855445544554155415542554E55421042284224424140808
+6D4C:01202128112412248220463E4BE0122412242228E22822102212222A22460282
+6D4D:0040204010A011108208440641F01000100027FCE04020802110220827FC0204
+6D4E:0080204017FE1208811040A0404011B0160E2110E11021102110221022100410
+6D4F:0204410421042FE4009484944294529411142114E29422942444284430140008
+6D50:0040202013FC1000810840904BFE0A0012001200E20022002200240024000800
+6D51:000023FE12021444804043FC488008A0112011FCE020202027FE202020200020
+6D52:004044402240227C005080904E10521012FE2210E21022902310221020100010
+6D53:00402040104017FC848448884140114413482530E92021102108214421820100
+6D54:000027F81008100883F84008400817F810102010EFFE22102110211020500020
+6D55:000023F81208120883F842204A200A10120814C6E420280021C0203020080000
+6D56:0010207817801088844842504200102017FC2020E22021202120202020A00040
+6D57:005020481048104087FE40404A440964116810D0E15022482444204221400080
+6D58:000023FC1204120483FC42004A180AE0123812E0E23C23E022222422241E0800
+6D59:0208421C226022400FC08240427E52C813482E48E2482248224822482A880508
+6D5A:008020801110120887FC400441101288148421F0E31024A0204020A023100C0C
+6D5B:0040204010A011108288444641F0101010202040E3F822082208220823F80208
+6D5C:0010203813C01200820043FC4220122012202220EFFE20002120221024080804
+6D5D:01102108110017FE814841504964094811501264E24822522462244229BE1000
+6D5E:000023F8120812088208420843F8104010402240E27C22402240254028FE1000
+6D5F:0210221012101420853E4D444DA4152415282528E51025102428242824440482
+6D60:0208211010E01110820840804FFE1140124027FCEA4422442254224820400040
+6D61:0040204013FC1040804047FE5402180411F02010E0202FFE2040204021400080
+6D62:000027FC1000100083F842084A080A08120813F8E0002208210821102FFE0000
+6D63:0080204017FC1404880843F04000100017FC2120E120212022242224241C0800
+6D64:0040202013FE1202844440404BFE084010901090E11021202224224224FE0842
+6D65:000023F81208120883F8400047FC144414442444E7FC24002402240223FE0000
+6D66:004840442FFE2040004087FC4444544417FC2444E44427FC2444244424540408
+6D67:000023F812081208820843F84800080017FC1040E04023F8204020402FFE0000
+6D68:0080204017FE140288444040404017FC10E02150E15022482444284220400040
+6D69:00402240124013FC84404840404017FE10002000E3F822082208220823F80208
+6D6A:0080204013F81208820843F84A080A0813F81240E24422282210228823060200
+6D6B:000047FE240229140208840443F8504010402040E7FC20402040204020400040
+6D6C:000027FC1444144487FC4444444417FC10402040E7FC2040204020402FFE0000
+6D6D:00002FFE104017FC8444444447FC1444144427FCE24021402080214022300C0E
+6D6E:0008203C13C010048244412848000BF810101020E7FE20202020202020A00040
+6D6F:000027FC1040104083F84088408817FE10002000E3F822082208220823F80208
+6D70:008421C417041114811441144FD4111413142394E55425042904210421140108
+6D71:000023FC1200120082F842004A000BFC12A012A4E2A822902290248824A408C2
+6D72:010021F813081490806041984646104013F82040E3F8204027FC204020400040
+6D73:0088208410BE17C08032400E48000BFC120413FCE20423FC2204220422140208
+6D74:0110210812041444804040A041101208140623F8E20822082208220823F80208
+6D75:000227821484148886904582448214841FC82490E482248224842488289011A0
+6D76:0040202013FE12028424412049FC092012201020E7FE20202020202020200020
+6D77:0100210011FC120085F841084948092817FE1108E248222823FC200820500020
+6D78:000023F8100811F8800843F8400017FC140423F0E110211020A0204021B0060E
+6D79:00402040104017FE8040424842481248155428A2E0A021102110220824040802
+6D7A:010821081108113E81AA456A452A152A192A213EE12A21082108210821080108
+6D7B:000027FC140414A48514460C540415F415142514E51425F42514240424140408
+6D7C:0100210011F01210822047FC4A441244124423FCE2A420A0212022222422081E
+6D7D:0008203C13C01044822441284900084013FE1088E10823902060205021880604
+6D7E:0040204013FC10408040404047FE109012942292E49229122110221024500820
+6D7F:000023FC1204120483FC42044A040BFC12041204E3FC20002110210822040404
+6D80:000023F81208120883F84208420813F812082208E3F82120212022222422181E
+6D81:01022102110411088FD041024302138415482550E90221022104210821100160
+6D82:0040204010A01110820845F64040104017FC2040E25022482444284421400080
+6D83:000027FC14441444844447FC444414C414E42554E64424442444240427FC0404
+6D84:0040204017FC144487FC444447FC10001FFE2100E20023FC2004200420280010
+6D85:000027FC1404140487FC4404440417FC10402040E7FC2040204020402FFE0000
+6D86:0000203E1788148884884488448817BE14882488E48824882788248820080008
+6D87:000023FC100011248248449052481124100023FCE04020402040204027FE0000
+6D88:0040224811481150804043F84A080A0813F81208E20823F82208220822280210
+6D89:002020201120113C8120412047FE100010202124E12422282410202020C00700
+6D8A:000023FC10441144814442844894090812401020E0A42282228A228A24780000
+6D8B:0040202013FE1202840440504048104017FE2040E0A020A02110211022080406
+6D8C:000027F8101011A0804047FC4444144417FC2444E44427FC2444244424540408
+6D8D:0040204413F41048804847FE4020104013F82110E22025FE2820202020A00040
+6D8E:0008201C1770111081104250425C175011502550E550227C2200250028FE1000
+6D8F:0000200C1770111081104210427C171011102510E510227C2200250028FE1000
+6D90:012043A82E24222402209FFE4220522412A42328E2282E102232224A2A860402
+6D91:004040402FFE2040004087FC4444544417FC2040E0E0215022482C4620400040
+6D92:000023F81088108887FE408848880BF811001100E3F825082908210821F80108
+6D93:000021F81108110881F840004BFC0A04120413FCE204220423FC220422140208
+6D94:004022481248124883F8404048A0091012881446E04023F02010202020200040
+6D95:02102110112017F88048404847F81440144027FCE0C421442254244828400040
+6D96:012021101110120082FE460056041A8412842248E24822482250221022FE0200
+6D97:0010209010881108820445FA41081108110821F8E0902090209021122212040E
+6D98:004020801110120887FC4104410013F814402040EFFE204020A0211022080C06
+6D99:0040202013FC1204820443FC4A000A20122013FEE22022502250248825040A02
+6D9A:020821081110102083F842084A080A0813F810A0E0A0212021222222241E0800
+6D9B:0040204017FC104083F8408047FE1090111021FEE21022902450281020500020
+6D9C:0020202013FE102081FC40004BFE0A0214041090E0902090209021122112020E
+6D9D:0108210817FE1108800047FE54021884108027FCE08421042104220424280810
+6D9E:00402040104017FC804042484148115017FE20E0E15021502248244428420040
+6D9F:00202420122012FE804040504E9012FE12102210E3FE22102210251028FE0000
+6DA0:000027FC1444144485F4444444E4144415F42454E45424742444244427FC0404
+6DA1:000023F812081208820843F84040104017FC2444E4A425142614240424140408
+6DA2:000023F81208120883F84000400017FC14042444E444244424B4210826041802
+6DA3:0100210011F0121084204BF84248124812482248EFFE20A020A0211022080C06
+6DA4:0080208011F813088490406041981646104027FCE04022482244244421400080
+6DA5:008040402FFE200003F88208420853F8100023F8E01020602040204021400080
+6DA6:0200217C1504140485F444444444144415F42444E444244425F4240424140408
+6DA7:0200217C15041404840445F44514151415F42514E51425F42404240424140408
+6DA8:00404F442144214801488F50484058FE18502F50E1482148214421442A620440
+6DA9:000023FC10441244824444844094110812202020E13C21202120212027FE0000
+6DAA:0080204013FC100082084108411017FE10002000E3FC22042204220423FC0204
+6DAB:0080404027FE2402080483F84208520813F82200E20023FC2204220423FC0204
+6DAC:0040204017FC104080404FFE411010A017FC2040E0402FFE2040204020400040
+6DAD:001C23E0108412448148411057FE1402100023F8E108211020A0204021B0060E
+6DAE:000247E22422242A07EA848A448A548A17EA26AAE6AA2AAA2AA232E2208A0084
+6DAF:000027FE1420142085FC4420442017FE14002420E42025FC242028202BFE1000
+6DB0:000027BC108412948108429454A41840100027BCE0A422A42128229024A80846
+6DB1:000021FC110011F8810041F851001FFE12802248E25022202210228823060200
+6DB2:0080204017FE11208120423C4244166412942348E24822302220225022880306
+6DB3:00402020102013FE8202449441081204100021FCE02020202020202027FE0000
+6DB4:0080404027FE24020A04820043BC54A414A426A4E9342128222222222422081E
+6DB5:000023F8101010208444455444E4144414E42554E64C25442484240427FC0004
+6DB6:0010207813C01040804047FC424812481FFE2248E24827FC2040204027FC0000
+6DB7:0040204017FC104083F842484BF80A4813F81040E0E0215022482C4620400040
+6DB8:000027FC1444144487FC4444444415F415142514E51425F42514240427FC0404
+6DB9:003823C01040104087FC415042481486108027FCE110221021A0206020900308
+6DBA:000023FC1204120483FC42204A200BFE12201220E2FC22842284248424FC0884
+6DBB:0040204010A01110820845F64040104017FC2040E04023F82208220823F80208
+6DBC:0080204017FE1000800043F84A080A0813F81040E25022482444284421400080
+6DBD:001C23E0122013FE822042924B0A0A0611FC1104E10421FC2104210421FC0104
+6DBE:0040204417681150815042484544108013F82208E20823F82208220823F80208
+6DBF:00004FFE20802184024484684AB0413012A82468E8A421242222242020A00040
+6DC0:0040202013FE12028404400043FE102010202120E13C212022A02260243E0800
+6DC1:0080204013FC10008108409047FE1040104027FEE08821082090206021980604
+6DC2:000023F8120813F8820843F848000BFC101017FEE01022102110201020500020
+6DC3:00402248115017FC808041004FFE121014082BF4F212221022502224220401FC
+6DC4:0124212412481490824841244124100017FC2444E44427FC2444244427FC0404
+6DC5:0200420C227022400F408240427E564817482AC8EA4832482248224822480288
+6DC6:0210212010C013308C8840804FFE110013F82608EBF8220823F8220822280210
+6DC7:0108210817FE1108810841F84908090811F81108E10827FE2000209021080204
+6DC8:000023FE1202120283FE42104A920A92129212FEE21022922292249224FE0802
+6DC9:000023F81248124883F842484A480BF8104017FCE0E021502248244620400040
+6DCA:0100210011F81208841048204180163C14042404E7BC24042404240427FC0404
+6DCB:011021101110111087BC41104110133813B82554E55429922110211021100110
+6DCC:0040224811481150804047FC4404140415F42514E514251425F4240424140408
+6DCD:000027FC1444144485F44444444417FC140425F4E514251425F4240424140808
+6DCE:0040204017FC104083F8408047FC111012482446E1F0204027FC204020400040
+6DCF:000023FC120413FC820443FC48000BFC10401040E7FE204020A0211022080406
+6DD0:03F82208120813F88208420843F8100017FC2404E40427FC2404240427FC0404
+6DD1:0100210011DC11148114411447D4101411142114E58825482948211425140222
+6DD2:0040204017FC104083F8404847FE104813F82080E7FE21082390206021980604
+6DD3:020842082FFE2208028880404FFE4100110021F8E10821082208220824280810
+6DD4:0040204017FC1040804043F84A080BF8120813F8E20823F8220822082FFE0000
+6DD5:0040204013F81040804047FC4110120814442040E3F820402040204027FC0000
+6DD6:00402040107E104083FC42044BFC0A0413FC1244E04027FE2040204020400040
+6DD7:0100210011FC12048484449442A4108417FC2084E1C422A42494208420A80010
+6DD8:0100210011FC1204850441E44284108417F42084E2A422A423E4200420280010
+6DD9:0080404027FE2402080483F04000500017FC2040E25022482444284421400080
+6DDA:0040202013FC1204820443FC4A000A28122413FEE22022502250248825040A02
+6DDB:01042104150417D4891441144FF4111417D42554E5542554254425C421140108
+6DDC:000027BC14A414A484A447BC44A414A414A427BCE4A424A424A424A42AA4114C
+6DDD:000027BE14AA14AA84AA47AA44AA14AA14BE27A0E4A024A024A228A22AA2111E
+6DDE:02084228222822280FA482444254569217102AA0EA203228224422FC22440200
+6DDF:00902090109013FC829442944A940BFC12941294E29427FE2000209021080204
+6DE0:000027FC1444144487FC4444444417FC10002000EFFE22082208220824080808
+6DE1:004022441244144880A041104608104410402248E248245020A0211022080C06
+6DE2:00142012101017FE801040104BD20A5212521254E3D4200820EA271A22260042
+6DE3:00002040139C12048204439C4A040A0413FC1090E0902090209021122212040E
+6DE4:0210411020102FA8042884444402579014882488E48024A0249028882A881100
+6DE5:008020F81088110881F0401048100BFE10201222E17420A82124222220A00040
+6DE6:0040204010A011108208440641F01040104023F8E0402248214821502FFE0000
+6DE7:0040202013FE12028444402048280888109012A4E2C224822188228824780000
+6DE8:003C27C012441128800043F84848084817FE1048E04823F82048204021400080
+6DE9:0040204017FC104080404FFE42081484188221F8E208251020A0204021B00E0E
+6DEA:0040204010A0111082084DF6400017FC14A424A4E7FC24A424A424A424140408
+6DEB:0008203C17C01084844442484210103C17C02040E0402FFE2040204027FC0000
+6DEC:0080204017FC10008110411042A8144410002040E7FE20402040204020400040
+6DED:0080204017FC1404840447FC4440144017FE24E0E95029503248244428420040
+6DEE:01402120112013FE822046204BFC1220122023FCE2202220222023FE22000200
+6DEF:0080204017FE1100820847FC400413F8120823F8E20823F82208220822280210
+6DF0:0040204010A0111082884446400013F010102020E04021242522250A290800F8
+6DF1:000027FC140414A4811042084040104017FC2040E0E0215022482C4620400040
+6DF2:00402040107C104083FC42444A700BC01244123CE20022F0249024922912120E
+6DF3:0080204017FC100083F842084BF8080013F81010E02027FC2040204021400080
+6DF4:0100210013FC1494889441244244148411282210E0402124252A250A28F80000
+6DF5:00A024A414A414A487BC4404440417FC14042404E7BC24A424A424A428A41004
+6DF6:00402040104017FC8040424842481248155420E0E15021502248244428420040
+6DF7:000027FC1404140487FC4404440417FC10002420E42227AC2430242225A2061E
+6DF8:0040204017FC104083F8404047FE100013F82248E24823F82208220822280210
+6DF9:0040208017FE11108248444643F81248124823F8E248224823F820422042003E
+6DFA:00A0209010BC17C88050406451941E0C10A02090E0BC27C82050206421940E0C
+6DFB:000023FC1040104087FE40A04110120814462040E04822642252245221400080
+6DFC:010001087D1005A009603118C506020008100A146AD42C582A544A94A9521020
+6DFD:0108210817FE110881084020482009201120113CE1202120212021202FFE0000
+6DFE:010006C01830EFEE01003FF811100920FFFE000001087D90096011202518C206
+6DFF:0040208013F8120883F842084BF80840104017FCE44424442454244820400040
+6E00:0040204017FE10A08150424845F6104011502110E7FE21102110211022100410
+6E01:0040474421682150024884444940408010002040E74421682250244829460080
+6E02:03F82208120813F8820842084BF80880104017FCE110211020A0204021B00E0E
+6E03:0108210817FE11088148404047FE1080110023FCE50429042104210421FC0104
+6E04:009020901090179E8090409048900B9C10901090E090279E2090209020900090
+6E05:2040104017FC004083F840404FFE080013F8120813F8E20823F8220822280210
+6E06:0844448420042FD404948494449454941FF42494E49424942484288428941088
+6E07:000023F8120813F8820843F849000BFC14041224E3D4221421F4200420280010
+6E08:0040202017FE11088090406041981606110821F8E10821F82108210822080408
+6E09:002020201120113C8120412047FE100010282124E122222A2410202020C00700
+6E0A:04442444165415548564444447FC144414C424E4E55425542644284428441044
+6E0B:002020201120113C8120412047FE100010002204E10820902108220424020000
+6E0C:000023F81008100883F84008400817FE10402444E2E821502248244621400080
+6E0D:0040204017FC104083F8404047FE100013F82208E2482248224820A021100608
+6E0E:0040204013F81040804047FC4004112810A02220E12027FC2050208821040604
+6E0F:0040204013FC10A08110420857FE100813C82248E248224823C8200820280010
+6E10:01004102211C2FD002108210451E57D411142114E1D42F142514212421240144
+6E11:000023F81208120883F8404047FC1444144427FCE444244427FC20422042003E
+6E12:0040208013FC1224822443FC4A240A4413FC1090E11027FE2010201020100010
+6E13:003C27C010841444824842104840084013F81040E04027FC20A0211022080C06
+6E14:0100410023F0221004208FFC5444544417FC2444E44427FC200020002FFE0000
+6E15:04442244128417D48114411451141FF411142114E29422542444244428140008
+6E16:0080204017FC1444804043F84248124813F82248E24823F82248204020400040
+6E17:00802090110813FC804047FE411012481C862310E02020C42308203020C00700
+6E18:000023F81090106087FC40A44128122014602040E7FC20E0215022482C460040
+6E19:0100210013F01410882047FC440414A415142444E0402FFE20A0211022080C06
+6E1A:0080208817E8109080A04FFE4080110013F82608EA0823F82208220823F80208
+6E1B:00142012101017FE8410441045D01412141225D4E554254825DA242A28461082
+6E1C:000027FC1040108087FC44A444A414A41484244CE0402FFE20A0211022080C06
+6E1D:004020A01110120885F6480047C41454145427D4E454245427D4244425540488
+6E1E:0208211017FE1040808043F84A080A0813F81208E20823F82208220823F80208
+6E1F:0080204017FC100083F8420843F810001FFE2802E3F820402040204021400080
+6E20:23FC120083F84A080A0813F8E20023FC21000100FFFE054009203118C1060100
+6E21:0040202017FE1488848847FE448814F8140025FCE48424882450282028D81306
+6E22:40002FF8280888684B88488808882BE82AA84AA8CBE8488A48AA50EA57262002
+6E23:0040204017FC10E081504248444613F8120823F8E20823F8220820002FFE0000
+6E24:021082105FD00210823E5FD2505220922F124112C21243925E2242224A4A0484
+6E25:000023FC1204120483FC42004BFC0A40128813FCE224222025FC2420282013FE
+6E26:000023F81208120883C84248424817FC140425F4E514251425F4240424140408
+6E27:0080204013FC10008108409047FE1442184423FCE24422442254224820400040
+6E28:000023F81248124883F842484A480BF8100017FEE24022442228229023080206
+6E29:000023F81208120883F84208420813F8100027FCE4A424A424A424A42FFE0000
+6E2A:0008203C17C0104083F842484A480BF8104017FCE444245425F4240424140408
+6E2B:00902290129017FE8290429042F0120013FC2040E7FE20E0215022482C460040
+6E2C:000227C21442145287D24452445217D214522452E7D2200222822242244A0804
+6E2D:000027FC144417FC844447FC400013F8120823F8E20823F82208220822280210
+6E2E:0110211017FE1110800047FE4008100813C82248E24823C82248200820280010
+6E2F:0110211017FC111081104FFE4110120817F42A12E21023F02204220421FC0000
+6E30:004020A0111012088DF6400043F81208120823F8E110211027FC211022100410
+6E31:01002100113E17C8854845484548154817C82508E108214821C82E48243E0000
+6E32:0080404027FC2404080883F8400053F8120823F8E20823F82208200027FC0000
+6E33:0000277E11241124813C47244424143C14242724E126217C210421042A040404
+6E34:000023F8120813F8820843F849000BFC14441244E2A4220423F4200420280010
+6E35:020842082FFE22080208800047FC544414442444E7FC24442444244427FC0404
+6E36:0110211017FC11108150404043F8124812482248EFFE204020A0211022080406
+6E37:0080204017FC11108208440443F81208120823F8E110211021122212240E0800
+6E38:02102110111017BE8220424043BC128412882288E2BE22882488248829A81010
+6E39:0200220013FE1402888247FA400217F2100227F2E00227F2241227F220140008
+6E3A:401020102F10891049144F52095229922F104914C9044F084910402040400180
+6E3B:00402040124812448454406049800E0013F81208E3F8220823F8220823F80208
+6E3C:0208211017FE1040804043FC4840084017FE1000E04027FC20A0211022080C06
+6E3D:0128212417A4112081204FFE4020102417A424A8E4A82490279224AA20460082
+6E3E:000027FC1444104087FE40404BF80A4813F81248E3F8204027FE204020400040
+6E3F:0040204017FC10E0815042484C4613F810002000E7FC20402248244429420080
+6E40:002027A810B014A483184110420815F410402040E7FC204020A0211022080404
+6E41:02102210122812288F444282427C130012002E7CE2442244224422442A7C0444
+6E42:000027BC14A414A487BC400043F810001FFE2100E20023F82008200820500020
+6E43:010043BC2E102210023C8F904210523C12102F90E27E22102210221024100810
+6E44:000023FC1224122483FC42004AFC0A84128412FCE28422FC2484248428FC1084
+6E45:004040402FFE204007FC8444455454E4144427FCE0E0215022482C4620400040
+6E46:0080204017FC1000820841104FFE100013F82208E20823F82208220823F80208
+6E47:0080204017FC120881104FFE400013F8120823F8E20823F82208220822280210
+6E48:020842082FFE2208020883F84208520813F82040EFFE20E0215022482C460040
+6E49:0208421C2270221003108AFE4A104A101210227CE244224422442244227C0244
+6E4A:0040204017FC104083F8408047FC1110120825F6E04023F8204020A021100608
+6E4B:0080208013F8110887FE40004BF80A0813F81040E7FC2040244027FE20400040
+6E4C:0040204010A01110828844464BF80A0813F81208E3F822442228229023080204
+6E4D:004024441444144487FC40004FFE1040108027FCE4A424A424A424A424A4040C
+6E4E:000027FE1040108087FE4492449214F214922492E4F224922492249227FE0402
+6E4F:000027FE1040108083FC42044A040BFC120413FCE204220423FC200021080204
+6E50:021042102220227C0FC482444244574416FC2A44EA44324422442244227C0244
+6E51:000027FC104412408278424055FE180013F82208E3F8220823F8220822280210
+6E52:000023F81208120883F840004FFE120813F82208E3F82208227E2F8820080008
+6E53:001021101108120485FA408841081228141023F8E2A822A822A822A82FFE0000
+6E54:0208410821102FFE000087C44454545417D42454E45427D42454244425540488
+6E55:00102010177C111481FE4214427C1710117C2510E5FE22102210250028FE0000
+6E56:0100211E111217D28112411E411217D21452245EE45227D224522022202A0044
+6E57:01042104110417C4813E410447C4102411142114E7C42104210421C42E140408
+6E58:02004200227C22440F448244427C574416C42A44F27C224422442244227C0244
+6E59:0080204017FE1090829844944114123014402040E7FE204020A0211022080C06
+6E5A:00402488152815E8844844A845E8140815E82528E5E8252825EA292A292A1166
+6E5B:0108210817FE110881F8410849F80908110817FEE25022882304220023FC0000
+6E5C:000023F81208120883F842084A080BF8100017FEE040224022782240254008FE
+6E5D:0220222413A8123082A243224A5E088013FC1204E20423FC2204220423FC0204
+6E5E:0040207E1040104087FC4404440417FC140427FCE404240427FC211022080404
+6E5F:0040208013F8120883F842084BF8080017FC1040E04023F82040204027FC0000
+6E60:004024441444144487FC4100410017FE11202220E2A422A82550245028880106
+6E61:03F82248124813F8824842484BF80840104017FCE444245425F424142404040C
+6E62:000027FC100013F88208420843F8100017FC2444E44427FC2444244427FC0404
+6E63:000023FC120413FC822043FE4A100A8A13061000E3FC220423FC220423FC0204
+6E64:02102110111017BE822842484BAA0AAE12BA12EAE2AE22A824AA24A229A2101E
+6E65:0080204017FC14048110420844441050104827FEE04020A020A0211022080406
+6E66:000023F8120813F8820843F848400A4013FC1440E04023F82040204027FE0000
+6E67:000027F8111010A087FC444447FC144417FC2444E08027FC2084210422280410
+6E68:000023FC120413FC820443FC4A040BFC10501048E7FE204020A0211022080C06
+6E69:0008203C17C010408FFE404047FC144417FC2444E7FC204027FC20402FFE0000
+6E6A:010021F8120813F0801047FE40801144166820B0E128266820A4212226A00040
+6E6B:43902E102210821242524FD40258269027104AA8CA2852284248424442840302
+6E6C:0610381008527E5408901C282A444882090001047D88095011202118C5060200
+6E6D:01082088109017FE809040904BFC0A941294130CE20423FC2204220423FC0204
+6E6E:000027FC10A010A087FC44A444A414A417FC2040E04027FC204020402FFE0000
+6E6F:000023F8120813F8820843F850001FFE120023FCE49429242244248421280210
+6E70:008021F81208151080E043184C0613F810402240E3FC244023F820402FFE0000
+6E71:0040204017FC104083F8404047FC104017FC2080E10023F82D08210821F80108
+6E72:003C27C012441128800043FC4880088017FE1100E1F822882250242028D80306
+6E73:004040402FFE2040004087FC451454A415F42444E44425F42444244424540408
+6E74:01082090100013FC809040904092149212942298E09020902090209027FE0000
+6E75:0208211017FC104083F8404047FC1100110023F8E4102820204020A023180C06
+6E76:0080210013F8120883F8420843F8104010402764E16821502248244429420080
+6E77:0040204017FC104083F8408047FE1110120827FCEA0A220823F82208220803F8
+6E78:0080204017FE100083F8420843F8100017FE2402E9F42110211022122412080E
+6E79:000027FE140015FC8524452445FC1524152425FCE420242025FC2820282013FE
+6E7A:0100217C114412448244467C4A10121012FE2238E25422542294231222100210
+6E7B:0040202017FE100081F8410849F8080013FC1204E20423FC2204220423FC0204
+6E7C:0100261C14041404871C4404440417FC10002000E7FC2040204020402FFE0000
+6E7D:0248424824902FFE049082484248500017FC2444E44427FC2444244427FC0404
+6E7E:010020801FFC112085284924400017F0101027F0E40027F82008200820500020
+6E7F:000027F81408140887F84408440817F811202120E9242528233021202FFE0000
+6E80:011041102FFE2110000087FC4040504017FC2444E554255425F4240424140408
+6E81:0088208813FE1088800043FE42021424102023FEE07020A820A8212422220020
+6E82:0102210217C21112811247D24552155217D22112E392254229222102210A0104
+6E83:0040204013F8124883F840404FFE100013F82208E2482248224820A021100608
+6E84:00402444144417FC808041F84208151010E02318EC4623F820402FFE20400040
+6E85:00104F94289228900A9E8AF04A905A9E1AF02A94EA942208250A249A28261042
+6E86:42002200257C84A448245724022422282FA84228CB104A9052A842284A440482
+6E87:004022481150104087FC41504248140410802FFEE1102210232020C023300C08
+6E88:00402240114017F88088409048FC0904110813FEE202242A2AAA228224140008
+6E89:000027BE1488148887A844A844A817BE14102518E49825A826AA244A20460080
+6E8A:000027BC14841484848447BC4400140017BC2424E42427A82410242824440482
+6E8B:000023F811081110811C42E442A4125414A82100E3FC22942294229427FE0000
+6E8C:001023D410581452828C4108420415FA10902090E7FE2090211021122212040E
+6E8D:000027FC10A014A482A840A04FFE100013F82208E20823F82208220823F80208
+6E8E:02102210127C12108F90421042FE170016902A10EA7C32102210221022FE0200
+6E8F:0040202017FE142085FC442447FE142415FC2420E5FC25042504290429FC1104
+6E90:000027FE1420144085FC450445FC150415FC2524E42024A829242A2230A00040
+6E91:004022441148104083FC42044A040BFC120413FCE204220423FC200021080204
+6E92:0040204013F8104087FE40004BF80A08120813F8E0A4212823102D4821860100
+6E93:011020A0100017FE80A043F840A817FE10A823F8E0A021B022A82CA620A000A0
+6E94:020821081110100087FC404048400BF810401040E7FE2000254824A428A40000
+6E95:000047FE240229F4000083F840805144166820B0E128266820A4212226A00040
+6E96:2140112083FC524017F82A40E3F8224023FC22000100FFFE0100010001000100
+6E97:003823C0104017FC81504154475811541354254CE0E021502248244428420040
+6E98:0040204013FC104080404FFE4080111013F82008E7FC24A424A424A42FFE0000
+6E99:0040204017FC104083F8408047FC111012482446E24821502248244421400080
+6E9A:0110211017FC1110804040A049100A0815F61000E00023F82208220823F80208
+6E9B:0080204017FC140481104208483C0BD012901290E2902288228824A424D40892
+6E9C:0080277C1424152484A445544648108017FC2444E44427FC2444244427FC0404
+6E9D:0110211017FC111083FC41104FFE104013FC2244E3FC22442FFE220422140208
+6E9E:000023F81148111080A0404041B0164E104023F8E248224823F8204427FC0004
+6E9F:000027FC1404100083F842084BF80A0813F81080E04027FC2000211022080404
+6EA0:01082088109013FC804041F848400BFE10801100E1FC22202420282023FE0000
+6EA1:001020101710157C8510451045FE1708150825FEE50825482728200820280010
+6EA2:020821081110100087FC400041101208140423F8E2A822A822A822A82FFE0000
+6EA3:022042202250248805048EFA540055FC15542554E5FC2554255425542504050C
+6EA4:000023FC124013F8824043F84A400A4013FC1004E55425542554240420280010
+6EA5:005040482FFE204007FC844447FC544417FC2444E0082FFE2208210821280010
+6EA6:010825481548155087DE402440141FD410142794E49424A824C8249428141022
+6EA7:000027FC10A010A087FC44A444A417FC10402040E7FC20E0215022482C460040
+6EA8:0110211417D2111081104FFE4010111417D42114E3942548290A211A21260142
+6EA9:0080210013F81208820843F84A000BFE120013FCE00425542554280420280010
+6EAA:003C27C0124411288080411043E01040118823FCE044204027FC20A02110060E
+6EAB:400023F822480A488AA8530853F822082000C7FC44A444A444A444A44FFE0000
+6EAC:0208211017FC1040804043F84840088017FC10A0E1282134223C22222422081E
+6EAD:000027FC144417FC844447FC41101208148421F8E20825082090206021980E06
+6EAE:020024FE17101510857C45544754145414542754E554255C2510271025100010
+6EAF:0440425E2292201207D2811E45525552155227DEE152211222122222242A0844
+6EB0:004022481248124883F8400047FC100013F82208E20823F8211020A027FE0000
+6EB1:0040204017FC104083F8408047FC1110126825C6E04023F820E0215826440040
+6EB2:00402140165C14448444475C4444144417FC2040E7F8211020A0206023981C06
+6EB3:000021F81108110881F840004BFC0A0413FC1204E3FC220423FC209021080204
+6EB4:0040208013F8120883F8420843F8120813F82050E04827FE20A0211022080C06
+6EB5:000021B81628142887A844A847CE148017B82428E7A824A8249028902AA81146
+6EB6:0040202013FE1202849441084A64089011081204E5FA21082108210821F80108
+6EB7:000027FE140215FA844244C2452A146A14B2252AE46A24AA2522244227FE0402
+6EB8:0040204017FC104083F8404047FE1080111023E0E04827FC2044224825440080
+6EB9:0040204017FC10408FFE4882411013E010402088E7FC20442248244429420080
+6EBA:000027BC1084108487BC4420442017BC108424A4E294229424A4208425280210
+6EBB:000023F8120813F8820843F8400017BC108424A4E294218C26B4208422940108
+6EBC:00002FFE1210121084A44738421014A417BC2040E04027FC204020402FFE0000
+6EBD:000023FE120012FC820043FE4AA80A9012C81286E20823FE2288244824080818
+6EBE:0080210017FC1444844447FC4444148417FC20C8E1502168227C22422442083E
+6EBF:001080945F54155495585510557C1F10351055FED51055105F10511040100010
+6EC0:0080204017FC1080810843F04860098417FE1002E7FC244427FC244427FC0404
+6EC1:40102F1029288A284A444CBA0A10291029FE4910CD584A544892491248500820
+6EC2:0080404027FC221001208FFE4882504417FC2100E10021F82108220822280410
+6EC3:0120211012081486891043F84008100017BC2084E4A4229424A4208422940108
+6EC4:0040204010A01190824847FE4A0813F8120823F8E20023F82508250829F80108
+6EC5:00142012101017FE8410441047F21492149225B4E6D42488254A293A2A261042
+6EC6:00002FFE100013F88208420843F8100017FC2514E4A427FC2444244424540408
+6EC7:0040204017FC104083F8420843F8120813F82208E3F822082FFE211022080404
+6EC8:0080204017FE100083F8420843F8100017FC2404E5F4251425F4240424140408
+6EC9:000023F8120813F8820843F848400A4811501040E7FC2120212022242424081C
+6ECA:0100210011FC120085F840004BF8088812A811C8E7F8208A21CA26AA20860082
+6ECB:01082088109017FE810841084210129414A42738E1082210221024A427BC0084
+6ECC:44202420247C88444AA84A101A282AD62A104AFECA104A544892491248500820
+6ECD:00402244124413FC80404FFE4000104013FC2244E24423FC2040204427FE0202
+6ECE:08202AA42CA84920145022887FFE4002810401047D88095011202118C5060200
+6ECF:01104208251420A000E083184C0653F810402040E7FC2040224821502FFE0000
+6ED0:0208220813BE14888AA8413E42081448184827FCE0E0215022482C4620400040
+6ED1:000023F8120813C882484FFE480213F8120823F8E20823F82208220822280210
+6ED2:000027FC100813C88248424843C810001FFE2008E3C82248224823C820280010
+6ED3:0080204017FC1484804043F8411010A017FC2040E04023F82040204020400040
+6ED4:003E4FC020842444024882104100561C14042404E71C24042404240427FC0404
+6ED5:0020792448A849FC482078404BFE488849247A224D2448A849244A2248A09840
+6ED6:0080204017FE100083F842084FFE120813F820A4E12823102510294821860100
+6ED7:0210221013DE1528888440784780108010F82780E08020F82F8420842084007C
+6ED8:000047FE24022914020885F44040504017FC2000E00023F82208220823F80208
+6ED9:000027FE1450148885FE469044FC149014FC2490E49024FE2480240027FE0000
+6EDA:0080204017FC111082484484412013F010102088E15023202510294821860100
+6EDB:0004203E17C0124481244128420013FC14402040EFFE20402444244427FC0004
+6EDC:0040208013F8120883F842084BF8088017FC1110E24824442BFA204020400040
+6EDD:0080204017FC111080A047FE48000BF8124813F8E24823F8224A2042203E0000
+6EDE:0150215017FC11508150400047FE1442184423F8E24822482248225820400040
+6EDF:0420842044781F488490447C44541E542454447CC4405F4044424442443E0400
+6EE0:000023FC110811F8810841F8410E17F8100827BCE0A422A42128229024A80846
+6EE1:0108210817FE1108800047FE4090109017FE2492E492256A26462402240A0404
+6EE2:0110211017FE111080004FFE4802100017FC2040E04023F8205020482FFE0000
+6EE3:000023FE120012FC820043FE4AA80A9012C81286E20022FC2284248424FC0884
+6EE4:0040207C104017FE8442447047C41444143C2420E410245425422942294A1238
+6EE5:00902490149E149084A844A444C41080100027FCE4A424A424A424A42FFE0000
+6EE6:008040402FFE20A002A882A444A45040104027FEE0E021502248244428420040
+6EE7:4410221022108FA0403E454404A428A431284528C21042104528492850440082
+6EE8:0080204017FE1402881443E04A000A0013FC1210E2102FFE2000211022080404
+6EE9:005040482E8022FE039092904AFC5A90149024FCEA902A90329020FE20800080
+6EEA:00004FBE20882510023E81224FAA52AA122A222AE22A222A221022142A220442
+6EEB:4440244024FC88884B505A201AD82B062AF84A88CAF84A884AF8488848880898
+6EEC:0040202013FC120483FC42004AF80A8812F81200E3FC232425FC2502290200FE
+6EED:000027FC144417FC844447FC5248124817FE2248E24827FC20402FFE20400040
+6EEE:420023C222028FE44A284B920E4229C428084B92CA824A844A8A4C92547E0800
+6EEF:02A822A817FC12A882AA44E6480017FC14442040E3F822482248224822580040
+6EF0:0080204013F8111080A047FE400013F8120823F8E20823F82120212222220C1E
+6EF1:408020402FFE880250044F90001C20102F90457CC50445284910492A514220FE
+6EF2:0080211013F8121084A44FBE404210A013182C46E19026642188263021C00E00
+6EF3:0080204017FC111080A047FC44A41514160C25F4E514251425F4240424140408
+6EF4:0080204017FC111080A047FC444415F4144425F4E514251425F4240424140408
+6EF5:0080404027FE2402089480504524554A18FA2300E04024442444244427FC0004
+6EF6:01082108110817D0811E479451241FD4121423D4E2542248224824D424240842
+6EF7:00402040107E1040804047FC4404164C151424A4E64C24A42514264C27FC0404
+6EF8:0210411021102FDE0028878840085788103E2788E48824882488278824880008
+6EF9:0040207C104017FE8442447845C4143C140824F0E52424A827FE282028A01040
+6EFA:02204220243E25480DA895104528544614802040E1242522250A250A28F80000
+6EFB:0040202013FC1000810840904BFE0A2012A012FCE320222022FC2420242009FE
+6EFC:0110211017BE111083B845544912100013F02210E290225022522212240E0800
+6EFD:002027FE142015FC842447FE442415FC142025FCE52425FC252429FC2924112C
+6EFE:0080204017FC1110820845F44110111011F02088E15023202510294821860100
+6EFF:0110211017FC1110811041F0404017FC14442664E55426EC2444244424540448
+6F00:08007F7808483E4800863E782A483E304048808401087D90096011202518C206
+6F01:0100210013F0121084204FFC5444144417FC2444E44427FC2000252424920892
+6F02:00004FFE20A027FC04A484A447FC500017FC2000EFFE20402248244429420080
+6F03:008040402FFE2802120483BC422452241FA42028E2282B10329022282A440482
+6F04:00202222122213FE800043FE4A200BFC122013FEE200222025FC24202BFE0000
+6F05:024824901248100083F842484BF80A4813F81040E7FC20E0215022482C460040
+6F06:0040204017FC10E08158464440A0111012482C46E24821502248244421400080
+6F07:021042102450295C0150825046FE5A0012102250E25C225022B02290230E0200
+6F08:0100211013DC125485544288410812F414022000E3FC20402150224825440080
+6F09:0080204017FC14A084A047FC44A414A417FC2400E52425A82530292429A4111C
+6F0A:004043F822482FFE024883F8404053F8124823F8E0802FFE211020E023180C04
+6F0B:00204F3C29442AA80A108C284AC6493819102950ED7E2A90287C281028FE0800
+6F0C:011041102FFE211001F0804047FC544417FC2040EFFE204027FC20402FFE0000
+6F0D:00004FFE282A28260FFE88224BAA4AAA1BAA2832E9962E2E284628822FFE0802
+6F0E:01244124222424240954814A429256101A102250E25C2250225022B0229E0300
+6F0F:000047FE2402240207FE840047FE542017FE2622E6AA2A222AAA3222222A0204
+6F10:08207E2008F8FF2814287F6A082AFF56098201047D88095011202118C5060200
+6F11:0100423E2788248804A887A844BE548817882010E4982718242824AA23CA0086
+6F12:0000277C11441144817C47104410147C14542754E154217C211021142AFE0402
+6F13:0080204017FE100082A8424842A813F8104027FCE484252425F424142404040C
+6F14:0080204017FC1404800043F8404013F8124823F8E24823F82000211022080404
+6F15:00A020A017FE10A087FC44A447FC14A417FC2000E3F8220823F8220823F80208
+6F16:0208224817481290829E4FE4411412141FD42494E91421C82F08211425140222
+6F17:0040208013FC124482F443144AA40A4412A413FCE04020242522250A290800F8
+6F18:07FE240015FC140087FE451445481586140025FCE50425FC250429FC2904110C
+6F19:00404FFE204027FC044487FC444457FC10422FFEE0102FFE2210211021500020
+6F1A:000027FC140014F88488448844F8140015DC2554E554255425DC240027FE0000
+6F1B:00402248115017FC804040804FFE111012482446EA4821502248244421400080
+6F1C:0110211017BC111083B845544912111010402040E7FC2040204020402FFE0000
+6F1D:000027BC108414A4829444A44084104013F82208E20823F82208220823F80208
+6F1E:000E27F010441224810843FC4A040BFC120413FCE20423FC2090211022120C0E
+6F1F:0040444422482FFE080283F84208520813F82040E04027FC204020402FFE0000
+6F20:0110211017FC1110800043F84A080BF8120813F8E04027FC20A0211022080C06
+6F21:010021FC120015F8810841F8490809F8100017FEE10023FC24A4212422540088
+6F22:0110211017FE111081F040404BF80A4813F81040E7FC20402FFE20A02110060C
+6F23:0020482025FE242001FC81244DFC552415FC2420E5FE242024202A2031FE0000
+6F24:0110411027BC211003B885544912408010802FFCE1102210212020C023300C08
+6F25:008040402FFE29120248844443F8504010402FFEE000204023F8204020400FFE
+6F26:08203E3E08447FA82A10492808443FFE200020882ED022A02490488852868100
+6F27:0110411021102FDE012087C0445C57C4144827C8E1102FD021222122211E0100
+6F28:0020247C12841148803040CE4610127C1210227CE21022FE2210221025FE0800
+6F29:0420422022202F7E04808400477C551415102550E55C255029502B5030BE2100
+6F2A:0020492025FC222006508A8843FE520816E82AA8E2A822E822A822082A280410
+6F2B:03F8220813F8120883F8400047FC14A414A427FCE00023F8211020E023180C06
+6F2C:004027FC104013F8804047FE48000BF8120813F8E20823F8220823F821100208
+6F2D:0110211017FC1110804847FC40A0111012082514E11027FE2110211022100410
+6F2E:0040202017FE142085FC442447FE142415FC2420E56224B429282A2630A00040
+6F2F:000027FC144417FC844447FC4100121017E020C8E3042FFE2042224825440882
+6F30:00402444144417FC800047BC44A414A417BC24A4E4A427BC24A424A42AB41148
+6F31:0108210817C81108811E47D24564154017C82108E38825482954211421240142
+6F32:00004F3E2120213C01208F3C482048FE18502F52E1542148214821442A620440
+6F33:004027FC111010A08FFE400043F8120813F82208E3F820402FFE204020400040
+6F34:00402444144417FC8080404047FE14021BF42000E7FC20402250244829440080
+6F35:0108210812881250841E4B944124111417D42114E59425482948211425240242
+6F36:0040204013F8124883F8404047FC144417FC2040E08020482544251428F00000
+6F37:0200211E17D2101287D4445447D8101417D22092E11221DA2714211025100210
+6F38:02004202223C2FA002208FA04ABE4FA41AA42FA4E2242FA42224224422440284
+6F39:000027FC1040127882404FFE410011FC120023FCE00425542554280420280010
+6F3A:0040204017FC1040855442484554104015542248E55420A020A0211022080C06
+6F3B:000027BC108414A4829444A440501188162620C0E31020642388203020C00700
+6F3C:0040244417FC1120811043FE522016201BFC2220E22023FC2220222023FE0200
+6F3D:000027FC140417FC842044A8447014A8150424A0E4FC252024202BFE28201020
+6F3E:0208211017FC104083F8404047FC1040102021C0E0442768215022482D460080
+6F3F:0440247C24A83D5004287DFE24884448851801047D88095011202118C5060200
+6F40:000027FC14A414A487FC4000401C17E012482248E24825542554286220400040
+6F41:200024FE3810222022FC1E84008408FC0A84ECFC28842C844AFC4A48A8841102
+6F42:00402444144417FC80004208411017FC11102110E5142318211021102FFE0000
+6F43:0240444028FC3088035084204CD8570614F82488E4F8248824F8248824880498
+6F44:0108210817C81110811E47E44554155417D42114E39425482948211421140122
+6F45:0100210013FC144080804FFE4120121017FC2A20E3FC222023FC222023FE0200
+6F46:01104FFE211020000FFE8882511443E010402088E7FC20442250244829440080
+6F47:011041102FFE2110004087FC40445FFE104427FCE04025642554265428441044
+6F48:000027FC14A414A484A447FC40801144166820B0E128266820A4212226A00040
+6F49:00402444144417FC800047FC440417FC140427FCE000242427A8243225A2061E
+6F4A:421022102510849E48105710027C22242FA44224CB284AA8529042284A440482
+6F4B:42102210251084A0483E5744002424A432A44AA8C8A8411043A85C2840440082
+6F4C:0080204017FC1514820847FC4080111013F82048E04023F8204020402FFE0000
+6F4D:04508448448008FE8B905E9044FC049028905EFCC8904090469058FE40800080
+6F4E:0108210815481390811E47D44564155415542754E5D4254825482554246404C2
+6F4F:000027F81090106087FC40A4412816A0104027FCE4A4251426EC24A424E4040C
+6F50:0140212013FE122086204BFC4220122013FC2220E22023FE2200252424920892
+6F51:002423A81092151482084C0447BA10A817C62400E7BC208420A8209025280244
+6F52:010041F0221027FC0A24824443FC5080114426A8E130266820A8212426A20040
+6F53:004040402FFE204007FC844447FC544417FC2044EFFE204220242522250A08F8
+6F54:010027BC11141394811447A4414C1080111023E0E04827FC2044224825440080
+6F55:0100210013FC16A88AA842A847FC12A812A822A8EFFE200022A8225424540000
+6F56:00004FBE220827BC02088FBE400057FC14442444E7FC24002402240223FE0000
+6F57:0140212013FE16208BFC422043FC122013FE2240E0402FFE215022482C460040
+6F58:007827C01248115087FC41504248140613F82248E24823F82248224823F80208
+6F59:0004203E17C01244812843F84A080BFC120413FEE40226AA2AAA2A0230140008
+6F5A:004023F8104817FE804843F840401554175C2444E7FC2444275C255425540844
+6F5B:000027BC1108152887BC431855AA1946100023F8E208220823F82208220803F8
+6F5C:0110411027BC21100FFE811042A8544413FA2208E20823F82208220823F80208
+6F5D:004020A0111816E6800043F84A080BF8100017BCE08424A4229424A422940108
+6F5E:0010279014BC14A484C447A841101128114625C0E53C2524252425A42E3C0024
+6F5F:010026381408140887384408440817F8120027FCE80425542554280420280010
+6F60:000027BC14A417BC842044A4439C1000111027FCE11021102FFE211022080404
+6F61:021041102FD0201007BE84A447D4501417942094E11421C82F08211425140222
+6F62:0110211017FC111081104FFE404017FC144427FCE44427FC2000211022080404
+6F63:000027BC14A417BC84A447BC4484144415F42424E4A4244424A4250424140408
+6F64:000027BC14A417BC84A447BC440415F4144424E4E444244425F4240424140408
+6F65:000027FC10A010A087FC44A444A417FC12482150E7FC20E0215022482C460040
+6F66:0040204017FC10A08514420847FC1A0A13F82208E3F820402248244429440080
+6F67:02082110100017FC8444455444E4144417FC2000E3F8220823F8220823F80208
+6F68:0080210017FC14A484A44FFE4000103C17C02144E24424E8215022482C460040
+6F69:000027FC144417FC844447FC4110111017FC2110E1102FFE2000211022080404
+6F6A:020043DE251221120FD28292425E540013FC2204E20423FC2204220423FC0204
+6F6B:00402248115013F8808047FC41101288151621E0E04823FC20442248244400C0
+6F6C:000027BC14A414A487BC40004BF80A4813F81248E3F8204027FC204020400040
+6F6D:000027FC10A017FC84A447FC400013F8120823F8E20823F8204027FC20400040
+6F6E:0100411E27D22112011287DE445257D2145227DEE11221122FD22122212A0144
+6F6F:000023FC100413FC800443FC48000BBC112417BCE00823FE2108208820A80010
+6F70:004023F8124813F8804047FE48000BF8120813F8E20823F8220823F821100208
+6F71:004027FC104013F8800047FC440413F8100023F8E20823F82208211027FC0000
+6F72:01104E102254223802108F7C4244534416FC2644EA44227C2244224422540248
+6F73:000023FC1204120483FC42224AFC0A2813FE1220E2FC238422FC248424FC0884
+6F74:0020492025FA222406288BFE4220524016FC2B44E244227C224422442A7C0444
+6F75:0288228817C81290829E4FD4402417D4145427D4E45427C824482454246404C2
+6F76:000027FC1444155484E4444447FC104017FC2040E0402FFE2000252424920892
+6F77:021023DE15281084804043F8404817FE104823F8E04023FC204027FE20400040
+6F78:042084205FFC0420956855AA652600002FF84808CFF848084FF8480848280810
+6F79:0040204017FC10E08150464C40401110111027BCE11023B82554291221100110
+6F7A:07FC240417FC140085F8441047FE14201460279CE484250829DE2F0831080318
+6F7B:003823C0104017FC8150424844A4111012482C46E24821502248244421400080
+6F7C:004023F8111010A087FC40004BF80A4813F81248E3F8204023F8204027FE0000
+6F7D:0208211017FC10A084A442A84FFE100013F82208E20823F82208220823F80208
+6F7E:00402248115017FC8150424844441208120823BEE4882AA8213E220824080808
+6F7F:000027FC144415F4849447FC440415F4151425F4E44424F4254425FC244407FC
+6F80:00004FBC229426B40AD484A445AC584011082108E5A8252C252825A82E7E0000
+6F81:40402040227C824042404FFE0000220822084228CBAE4A284A284BA85E7E0000
+6F82:010825481548155087DE401447E4101417D42114E7D4210821082FD420240042
+6F83:0BFE104061FC090411FC610405FC090431FCC088010C7D90096011202518C206
+6F84:002027A410A812928114420855F4180213F82208E20823F8220821102FFE0000
+6F85:004023F8104817FE804843F8404017FE100023F8E24823F8224823F8200007FE
+6F86:0040404027FC20400FFE811047BC51101190263EE0002FFE2120212222220C1E
+6F87:0110455425B8291002A88444400057FC14842888E7F820882088210822280410
+6F88:0208210817C81210849E4FD44064179414942794E49427882488249424A405C2
+6F89:00084788208821100FDE849444A4579414942794E49424C827882C9420A400C2
+6F8A:0108209017FE109083FC42944B1C0A0413FC1204E3FC200827FE210820A80010
+6F8B:000023F8120813F8820843F8404017FE100023F8E20823F820402248244400C0
+6F8C:04804482249C2FD004908790449E579414942494EFD42014251428A430240044
+6F8D:010441042FE42104013E87C4400457E414542454E7C42444228420E42F140408
+6F8E:010441042FE82110010087C4400457C814502442E7C22444228420E82F100420
+6F8F:000023F81208120883F8400047BC14A414A427BCE04024442444244427FC0004
+6F90:000047FC20402FFE0842835840405358100027FCE0002FFE2100220827FC0204
+6F91:000027FE10A017BC84A444A447BC10A017FC2444E44427FC2444244427FC0404
+6F92:000020FE10101720827C42444244127C1244227CE3C42E44207C202820440082
+6F93:01402140127E1480897C4144427C16441A7C2220E23C224422A82210222802C6
+6F94:01082128122817BE84A844C8448814FE17802480E4BE24A224A227A224BE0022
+6F95:01102FFE1110100087FC415051501FFE11502150E7FC20402FFE204020400040
+6F96:000027BC14A417BC84A447BC4444144415F42444E4E42554264C244424540408
+6F97:000027BC14A417BC84A447BC440415F4151425F4E51425F42514240424140408
+6F98:0110211017BC111083B845544912100013F82208E20823F82208220823F80208
+6F99:00002080173C140487BC440447FC120013FC2400E7FE2002255224AA28AA0004
+6F9A:010027FC14441554844447FC44E4155410002FFEE20023FC2004200420280010
+6F9B:010043F024102FFC144487FC444457FC10002FFEE00023F8220823F8220803F8
+6F9C:0200217C1504144485F4444445F41554157425D4E55425F424E425542444044C
+6F9D:008040402FFE28820548851448F4400017FC2444E7FC244427FC244424540408
+6F9E:0040207C104017FE844245F8444415FC150825F8E40025FE24202BFE28881306
+6F9F:00404FFE200027FC040485F4451455F4140427FCE00823F020402FFE21500E4E
+6FA0:000027FC14A414A487BC40A047BC14A414A427BCE4A424A427BC24A220A2007E
+6FA1:03F84208220823F8000087BC44A454A417BC2040EFFE21602250244838460040
+6FA2:00402248115017FE8402480443F8120813F82000E7FC244427FC244427FC0404
+6FA3:0108410821142FD4012287C0445C57C8144827C8E13E2FC82108210821080108
+6FA4:000027FC14A417FC804043F8404017FC111020A0E3F820402FFE204020400040
+6FA5:4400273C291492144FA44ACC0A802FA82ABE4AC8CF884A884ABE4A8848881188
+6FA6:00004FBE20882510023E81224FA252BE1222223EE2222222223E22002A140422
+6FA7:00A020A017FC14A487FC44A447FC100017FC2000E3F8220823F8211020A00FFE
+6FA8:0210221013DE15288884400047FC104012482248E248255428E220402FFE0000
+6FA9:0A803138228838382288393822887FFE410281047D88095011202118C5060200
+6FAA:000047FC20402FFE084283584040535810A02398EC4623F02010232020C00020
+6FAB:0110211017FC111083F842484BF80A4813F81040E7FC2444245425F42414040C
+6FAC:0440227C1084112886204250488C0BF8120813F8E20823F8220823F821100208
+6FAD:0040202017FE10288224427E44C81748117E2248E4C82F7E21482248247E0840
+6FAE:004040A023182DF6000087FC455454E417FC2000E3F8220823F8220823F80208
+6FAF:008040DC228423D404488A9443244C4012482150E7FC20E0215022482C460040
+6FB0:0040204010A01110820845F6400017BC14A424A4E7BC22102210252829441082
+6FB1:40002FDC285488544FD44A940AA62FC02A9C4A94CFD448145288524864540822
+6FB2:00A024A412A810A087FC411040A017FC104023F8E04027FC215022482C460040
+6FB3:0080210017FC14448554444447FC14E415542404E0402FFE20A0211022080C06
+6FB4:000023FC1294129483FC400047FE100013FC2204E3FC20A2211423082D440182
+6FB5:0200210217DC10108450429047DE1114111427D4E11425942554292425240244
+6FB6:00404FFE200027FC040485F4451457FC100023F8E20823F8220823F820000FFE
+6FB7:03F8220813F8120883F8400047FC14A417FC2040E7FE210021F8210822280410
+6FB8:0014201217FE141085D0441445D4155815CA2416E442282422A2228A24780000
+6FB9:020043F8241027FE0D48962447FE540015FC2400E5FC240025FC290429FC1104
+6FBA:0080204013FC1108809047FE400013FC120423FCE20423FC20402524250A08FA
+6FBB:00882448125010FC802040504694123812502298E23422542290222025FE0800
+6FBC:00102008178814BE848044944788147E14082788E6BE2A882A882B8832880008
+6FBD:0040207C104013FE824242784BC40A3C120013FEE24023A4225825B4245209B0
+6FBE:00102410127C101080FE4044462812FE1210227CE21022FE2210221025FE0800
+6FBF:0110211017BC111083B845544912100013F82000E7FC20402248244429420080
+6FC0:021044102F9028900FBE88A44FD4541412142FD4E4142788248828942A941122
+6FC1:000027FC14A414A487FC420053FE14421BFA224AE3FA2052207A278A22140008
+6FC2:002027FE1508149087FC445045FC145417FE2454E5FC245024D829542A521050
+6FC3:009023FC129413FC829443FC48000BFC120012F8E20023FE2520251425480986
+6FC4:000044F8228822E800A880A84DFC450415742554E5742504251425082A0011FE
+6FC5:00404FFE280223F8000883F8400857FC144423F8E248204027F8211020E00F1E
+6FC6:004027FC104011108FFE411043F8120813F82208E3F8220823F8211022080404
+6FC7:0040204017FC1248824845544FFE100017FC2404E5F4251425F4240427FC0404
+6FC8:03D42252125213D080104FFE425013D4125423D4E25422F82F4A244A20560062
+6FC9:002840242F40297E09C88F48497E59481F48297EE94829482F48297E20400040
+6FCA:0020213C112017FE801040144BFE0A1013F01254E25422D42368244A28960322
+6FCB:0110211017BC111083B845544912100017FC2044E24022782240254028FE1000
+6FCC:1C20702211B4FCA810A87D2456A27C4055FC7D0411047DFC11041F04F1FC4104
+6FCD:01104FFE2110220003FC84A44BA4416412542494E108204020242522250A08F8
+6FCE:01F8210811F8150A85FA450A45FA1402179E2090E0902F9E2492249224920892
+6FCF:000027BE1108110887BE4108410817BE10002080E0442512252229C023040CFC
+6FD0:03FC220413FC120483FC40444BF8085017FE1040E1FC270421FC210421FC0104
+6FD1:021042102F9C222402488FBE4AA25AAA1FAA222AE72A2AAA3288221422220242
+6FD2:4200227E2A108BA04A7C4A441FD4205422544AD4CAD44B545120422844441882
+6FD3:004027FC111010A087FE44A047F814A817FE24A8E7F824A025B02AA82CA610A0
+6FD4:000027FC124814448FFE444446EC155416EC2444E6EC255426EC244424540408
+6FD5:000027FC140417FC840447FC421014A417382210E4A427BC2000254824A408A4
+6FD6:000027FC14A414A487FC404843F8105017FE2040E1F8230825F8210821F80108
+6FD7:01102FFE111013F8820843F8420813F810802FFEE24827FC2A4A224822580040
+6FD8:0080204017FC144482A842944474100013F822A8EFFE200027FC204021400080
+6FD9:0110455425B8291002A884444FFE480210402248E248245020A0211022080C06
+6FDA:0110455425B8291002A88444400057FC14442040E7FC20E0215022482C460040
+6FDB:011027FC111017FC840443F8400017FC10802144E6A8217026A8212626A00040
+6FDC:004023F8104817FE804843F8404017FE100022A4E45223F822A822A82FFE0000
+6FDD:010827FE110811F8810841F8410817FE11082294E5E2204823FC2040224804C4
+6FDE:008023F8120813F8820843F8400017FC144427FCE44427FC20002FFE21100210
+6FDF:0080204017FC111080A44F58455415521B582000E20823F8220823F822080408
+6FE0:004027FE100011F8810841F8400017FE140223F8E180264421B8266821A60E60
+6FE1:000047FC20402FFE084283584040535810002FFEE04027FC24A424A424A4040C
+6FE2:07BC208414A4129484A4404047FC1110111022A8E44420402FFE204020400040
+6FE3:4210221022289FA842444F8A08A82F9828C84FA8C20E5FB84208420842080208
+6FE4:004027FC104013FC800047FE400213F8104027FEE00027FE200827FE24A80798
+6FE5:008041F82690206001A08FFE480247FC104027FCE44427FC244427FC22080404
+6FE6:003E27C01244112883F8404047FC100013F82008E3F8200823F82544252A08FA
+6FE7:028442842AA426C4029E8FE440045454128C2FE4E10427C4210421C42E140008
+6FE8:0210212017FC1210821044A44738121014A427BCE08021482554251428F00000
+6FE9:010827FE1148122087FE4A2043FC122013FC2220E3FE220027F8211020E00F1E
+6FEA:021042102F9C22240FC8823E4FAA502A1FAA28BEEFA028A02FA228A22AA2091E
+6FEB:001027D0151017DE845047E8450417C4100023F8E2A822A822A822A82FFE0000
+6FEC:0040207C104017FE840243FC424814A4111023F8E60C2BFA220823F8220803F8
+6FED:011027FC1110104083F8404047FC1080111023F8E00023F822A822A82FFE0000
+6FEE:012821AA116C122882FE464456281AFE1210227CE21022FE2210222822440282
+6FEF:000027BC108414A4829444A44120121017FC2A20E3FC222023FC222023FE0200
+6FF0:422822242440857E49C85F48027E244829485F7EC14840485548557E50400040
+6FF1:0080404027FE24020BFC8148425057FC120427FCEA0423FC220423FC21080204
+6FF2:0200421C2F942214071480264F8048BC17142014E2142F8827082A9432240242
+6FF3:0108452827BE294807BE831845AA594613F82208E20823F82208220823F80208
+6FF4:0110455425B8291002A884444FFE484210402764E16821502248244429420080
+6FF5:002027FE140213FC822443FC4A000AFC128412FCE28422FC228424FC24480884
+6FF6:07BC24A417BC14A487BC4404443415C4144427FCE44425F4251425F424140408
+6FF7:0108799009603518C206011047FC211081F0404017FC1664E55426EC2444244C
+6FF8:01102FFE1110104081B04E4E43F8120813F82208E3F8220025FC250429FC0104
+6FF9:000027FC144417FC844447FC404017FC10402FFEE5242892204027FC20400FFE
+6FFA:00142792149E14F08794448A449617E214942492E79E20702514248A28960062
+6FFB:0010277C1554157C851046FE4500157C1544257CE544267C2444247C24280444
+6FFC:044444E428A82AAA0EEE84A44AAA4EEE12422040EFFE20E0215022482C460040
+6FFD:02084FBE22082FBE0208851448A257FC140427FCE40427FC240427FC21100208
+6FFE:0020203E102017FE842245F8442215FE152425FCE52425FC28402AA4328A047A
+6FFF:000027FE148817FE848845FC452415FC152425FCE42027FE262A2AFA2A0A1206
+7000:07FC408023F8220803F882084FFE588215482514E8F4210023F8250820F00F0E
+7001:0208211017FC104083F8408047FC114813FC260AEBF8220823FA2234228C0302
+7002:010043F024102FFC144487FC444457FC15242892E3F8220823F8220823F80208
+7003:40002F7C2944897C4F444944097C2F20297E49AACF2A404A4A924922494A1104
+7004:0210221013DE15288084400047BC14A417A424A4E7A42434252826A024200020
+7005:0110455425B8291002A884444FFE480213F82040E04023F8205020482FFE0000
+7006:00404FFE204027FC000087FC44A457FC120823F8E20823F8220823F821100208
+7007:0040202017FE148885FC448847FE142015FC2524E5FC252429FC288831040202
+7008:07BC24A4129414A48FFE484247FC104013F82248E3F8224823F8204027FC0040
+7009:00404FFE28822338020883B8420853F8120027FCE80425542554280420280010
+700A:010023DC12541366824047DC42541348125424A2E00023FC2294229427FE0000
+700B:004047FC2404283807C08248415057FC12482404EBFA224823F8224823F80208
+700C:0080204017FC14A087FC44A447FC1400152425A8E53025A4251C28002AA41452
+700D:002027FE140015FC852445FC452415FC142025FCE42027FE25242AFA282013FE
+700E:010827FE1108100083FC42944A940BFC102813FEE220232422A82292242A08C6
+700F:020225E214A216AA852A466A410A128A144A2BAAE10A27CA2122254221EA0E04
+7010:0114211217D2111081104FFE429016D2129226D2E29426D4228A22CA2F160022
+7011:03F8220813F8120883F8411047FC11101FFE2110E248255420E02150224800C0
+7012:00404FFE2248255408E2815042484DF6100027FCE40425F4251425F4240407FC
+7013:028842A826A82BF0001E822445D45C1415D42494E49425C82488249425D40422
+7014:02009FDC42140F9480145FD450660F80201C4F94C2145FD447084A8852540222
+7015:0100213E150815D0853E45224FE2103E1122257EE56225A228BE210022140C22
+7016:07FC204017FE14428B5C4040475C112013FC2620EBFC222023FC222023FE0200
+7017:00404FFE284227FC004083F8404057FC104027FCE4A427FC20402524252A08FA
+7018:0040207C104013FC824443F04A440AFC12A812F8E2A822F8220025FC25540BFE
+7019:4400223C2FA4802448BC45240FA4223C22244FA4C23C4B104A9852A84A2A0446
+701A:0410841044281F4484825F0051EE1F2231AA5F66C4225F6644AA442244AA0444
+701B:0080BFFC48000FF880004FF848080FF820805C9CD7D45D54555C5C9655562E22
+701C:00084F8820082708053E852A472A502A1FAA2DBEEAA82F882A8A2A8E2ABA0990
+701D:000027FE14441598848847DE448815DC16AA2488E4202520253C2920292017FE
+701E:022042202FB822480F90827C4F9450141FFE2894EF9428FC2F9428902A900930
+701F:011027FE115013F8804847FE404813F81554275CE44427FC2444275C25540954
+7020:0110455425B8291002A8844447FC5484111023E0E04827FC2044224825440080
+7021:00104E7E2B202ABC0AC88CBE4A004BBC1AA42ABCEAA42CBC28A428AC29400A3E
+7022:002049FC252421FC002083FE4D0445FC150425FCE50425FC248825042BFE1000
+7023:010041BC252427A804908AA8414652A017BC20A0E3B820A027BC20A02FFE0000
+7024:008040402FFE200007FC84A447FC524811502208E44420A8211023082D460180
+7025:07BC24A4129414A4804047FC400011F0111021F0E00027FC240424E424A404EC
+7026:00109F90427A04128C1452FE47080A10333C46E4CAA4523C422442244A3C0424
+7027:0210211017DE1010845E428247DE101017DE2450E7DE245027DE2450245204CE
+7028:0108210817CE1112812447DE4552155E17D2211EE392255E2940211421120122
+7029:01804E3E22083F90023E87224AA2527E1022273EE5222522257E298029141022
+702A:20207F3EAA447FA82A103F2804441FF010101FF010101FF001843D480930730E
+702B:02009FDC42140F9480145FD450660F80241C4894CF1442945FC84A8852540622
+702C:4200223E2F888210423E4FA20AA22ABE2FA2423EC72246A24ABE520042140222
+702D:0410841044281F4484825F7C55001FE235AA5FAAC4EA5FAA44AA44E244AA04A4
+702E:07FC40402FFE2842035880404358500011102FBEE11023B82554291221100110
+702F:008822AA12DC14888154422247FE140211F82108E1F8200023FC220423FC0204
+7030:40002EFE2254829242FE4E9208D628BA28D64E92C2D642BA42D642924A9A0484
+7031:40002FFE29128FFE40004FFE08802AA2288A494ACA2A488A4AAA5082514A2224
+7032:0208820845080890905E6FA4401400143DD45554D5545DC84888489455542222
+7033:011027FE1110104087FE44A047FC14A417FC2500E5FC250025FC280435540008
+7034:07BC24A417BC14A487BC44A447BC131814A42080EFFC2110232020C021B00608
+7035:0248215017FC1150864C43F8424813F8124823F8E11027FC21102FFE22080404
+7036:00404F402A7E2A800A008F7C49444944197C2F00EAEE2AAA2AAA2AAA2FEE00AA
+7037:000027BC14A4129484A443F8424813F8124823F8E11027FC21102FFE22080404
+7038:0448444C2AAA20080FFE82884EE8528A1EEA228CEEEC228822EA2F1A24260042
+7039:404020A0211082084DF640000EEE2AAA2EEE4000CFFE49224FFE4922492A0804
+703A:01F0221017FC120483FC42244BB80A2211FE1210E7FC224423FC20D0214A063E
+703B:011447D221102FFE001087D0455257D2155227D4E29427C8228A2FFA22A60442
+703C:004027FC100013B882A843B8411017FC111027FCE1102FFE212823102D480186
+703D:004027FE149213FC809043FC409017FE110823FCE50A21F82240227C254008FE
+703E:07BC24A417BC14A487BC444445F4144415F42554E5F4255425F424E42554044C
+703F:021043D0241E2FE405548FF4454857D411B22220E7C0208827FC204423500488
+7040:07FC40402FFE28420358804043585000127C2FC4E27C27442AFC3244227C0244
+7041:4FBE28A22FBE88A24FBE484209F2291229F24912C9F248464F6A49524A4A0CC6
+7042:003C27C01244112887FC44A447FC1008178824FEE78824A82798250825A80690
+7043:015023F8155417FC855447FC455417FC100027FCE00023F8220823F821100FFE
+7044:03FC210811F8110881F8410E47F8100817FE2294E39C2294239C22D627BC0084
+7045:07FC444427FC244407FC80004FBE5AAA1FBE2AAAEFBE2040204027FC20400FFE
+7046:009027FE109013E8828843CE4A500BD412A213E2E00023FC2294229427FE0000
+7047:049242942FFE211007FC804043F850401FFE2480E7BC2494279424C82F9400A2
+7048:07BC24A417BC14A487BC44A447BC112013FE2220E7FC2A2023FC222023FE0200
+7049:0A98951454900A3E9F2851685F3E00283F28553ED5285F2850A850BE4FA00020
+704A:0FBE45282FBE2308059A892647FC500013F82208E3F8200027FC249425F4044C
+704B:00404FFE29202FFC09248FFC49004BFE18022AAAE8442BF828402FFC291013F8
+704C:01104FFE211027BC04A487BC4140512013FE2220E7FC2A2023FC222023FE0200
+704D:0FBE48A22FBE28A20FBE8C424A924FDE19262D5AEFD22912292A2A462C0A0804
+704E:05089FC8555C1FC895485FFE40081FD020144FBEC8804FBE48AA452A43AA1C7E
+704F:40002FBE28888F9048BE4FA202223FEA202A4FAAC8AA4FAA42084A9452520622
+7050:0110455425B8291002A884444FFE484210A02318EDF6204027FC224821500FFE
+7051:0FBE400027BC24A406B484A4404057FE14A027FCE4A427FC251229DC291211CE
+7052:052847BE294827BE031885AA494653FC120423FCE20423FC220423FC21080204
+7053:210447C88812F3BC20084B92F83E0380AAAAABAA01087D90096011202518C206
+7054:05109FD0555C1FE495485FFE402A1FEA202A4FBEC8A04FA048A2452243A21C1E
+7055:040C820A5FC8051E92545574505E1FD422145FDED45455545754505E51501090
+7056:002027FE148817DE848845DC46AA1488145027DEE45025DC24502BDE28501050
+7057:081088FE48003EFE2A822ABAAAAA6AFE3E00287C08444A7C8E443A7C100000FE
+7058:451825142F90853E472842680FBE2AA82FA8423ECFA842285FE8453E48A01060
+7059:0248215017FC140481F0411047FC155414E427FCE04027FC20402FFE22A40452
+705A:02AC444426AC244406AC84044FFE4A0A13F82208E3F8220823F820A02124061C
+705B:4F1E29122F1E89124F1E4BBA0AAA2BBA29F24952C9F2495249F248424BFA0846
+705C:0080BFFC48000FF880004FF848080FF820005DDCD5545DD4555C5DD654962D62
+705D:40002FBE28888F9048BE4FA202223FFE20224FBEC8A24FA2423E4A8052540622
+705E:47FC20402FFE8842435845000FBC25242724423CCFA44AA44FBC42245FA4024C
+705F:07FC240417FC152484A8452445FC155415FC2644E5F4255429F4284433F40008
+7060:0790251E17A8148487BE452A47BE100013F82208E3F8220823F820A02124061C
+7061:011027FE111017BC84A447BC44A417BC144427FCE55425F4244424E425540448
+7062:004027FC124813F880404FFE4AAA13B8111027FCE1102FFE212823102D480186
+7063:444428E82E0E84E44A0A4EEE00A02AEA200047F8C00847F8440047FC40040038
+7064:444424E42A0A8EEE44044AEA0E0E20E02AAA4AEAC0404FFE415042484C460040
+7065:02001FF010101FF010101FF0092013107C7C44447C7C44447C7C92925454B2B2
+7066:00009FDE50441FC8905E5FD24892155E3DD2489ED5525DD2401E5540554C0012
+7067:42102A902F9C8AA44FC84ABE0FAA202A3FEA403ECFA048A04FA248A245221F9E
+7068:04109F9C493406089FB6401C4F8808BE2F8048BECFA2423E5FA2423E42140222
+7069:42082A882F9C8A884F884ABE0F8820103FD4403ECF8048BE4FAA48AA452A1FFE
+706A:428822E82F5E82EC475A4AE802082FFE29425494C55847F2420443E8420203E4
+706B:010001000100110811081110212021004280028004400440082010102008C006
+706C:0000000000000000000000000000000000000000000000002488224442448004
+706D:0000FFFE0100010011081108111021204280028004400440082010102008C006
+706E:010011081108229004401830E00E0440044004400440084010422042C03E0000
+706F:1000100013FE1020542058205020902010201020102028202420442040A08040
+7070:040004000400FFFE0480088008880A9012A014802140414082200210040E1804
+7071:1000100011FC1044544458445044904410441044104428842484450442288410
+7072:080408040804094449444A444C44884408440844144412442104210440148008
+7073:0800080008001FFC100422044244924412842204050404840844100460280010
+7074:1000100011FC1020542058205020902010201020102028202420442043FE8000
+7075:00003FF8000800081FF8000800083FF801001110111022A0044008203018C006
+7076:10201020102010205420582051FC902010201020102028202420442043FE8000
+7077:010011081108229004401830E00E082008200820FFFE08200820102020204020
+7078:040004000FE01040208003600C18700401001110111022A0044008203018C006
+7079:1010107813C01040544058405040907E17C010401040284224424442403E8000
+707A:1020102010201120552C5934516493A411241134112829222522450240FE8000
+707B:010001003FF8010001000100FFFE000001001110111022A0044008203018C006
+707C:10401040108010FC55045A045004910410841044104428042404440440288010
+707D:1110111022204440222011101110000001001110111022A0044008203018C006
+707E:020001007FFE400281040100110811081110212002800280044008203018C006
+707F:102010201020102055245924512491241124112411242924252445FC40048000
+7080:100011F8101014205840508051FE909210921092111229222622444240948108
+7081:00007FF80200420042007FFC0480088010842084C07C00002488224442448004
+7082:101010901090148858885124512492221440104010882884250443FE41028000
+7083:0440082010102FE8C4260420082010A06040010011101120228004401830E00E
+7084:100013F81088148858885088508897F811081108110829082508410847FE8000
+7085:00001FF0101010101FF0101010101FF00100110811102280044008203018C006
+7086:10401020102013FE548858885088908810881050105028202450448841048602
+7087:104010401040148058FE51085288908810881050105028202450448841048202
+7088:100010F81088148858885106520091FC10841084104828502420445040888306
+7089:10801040104015FC59045104510491FC11041100110029002600420044008800
+708A:104010401040127C528454885920902010201050285028502488448841048202
+708B:1000100011FE1010541058205020906810A41122122228202420442040208020
+708C:1020102010501450588851045202908810881088108828882488450841088208
+708D:1008101C11E01500590051FC5144914411441128112829102510422842448482
+708E:010011081110212002C004301808600401001110111022A0044008203018C006
+708F:10401040104014405944514451489250104010A010A028902510410842048402
+7090:10201020102011FC54205820502091FC1020102010202BFE2420442040208020
+7091:10201020102014205BFE50205070907010A810A811242A222420442040208020
+7092:10201020102010A854A458A25122912012241024102828082410442040C08300
+7093:101011101090109054105910509090901010101E13F028102410441040108010
+7094:10401040104017F8584850485048904817FE104010A028A02510411042088406
+7095:10801040104013FC5400580051F09110111011101110291225124612420E8400
+7096:10201020102011FE5420592451249124112411FC1024282024224422401E8000
+7097:08200820FFFE0820082008200FE0082001001110111022A0044008203018C006
+7098:1008101C11E015005900510051FE911011101110111029102510421042108410
+7099:020004000FF81210692004C003000C0071001110111022A0044008203018C006
+709A:002000207C20442444A444A444A87D2044204450445044507C88448801040202
+709B:010011081108229004401830E00E08800888109030E0518096841084107C1000
+709C:10401040104013FE5440584051FC9040104013FE10422842244A444440408040
+709D:1040104010A014A059105208540691F011101110115029202504450440FC8000
+709E:10401020102014005BFE50405040906010501048104428442440444040408040
+709F:1000100011FC15045904510451FC91041104110411FC29042400400043FE8000
+70A0:100011FC11241124552459FC51249124112411FC112428202420442040208020
+70A1:1000100013FE14205820502051209120113C1120112029202520412047FE8000
+70A2:102010281024102055FE58205070907010A810A811242A222420442040208020
+70A3:1000100013FE1008540859E8512891281128112811E829282408440840288010
+70A4:100013FC108410845484590451149208140011FC110429042504450441FC8104
+70A5:10901090109013FC5494589453FC9290129013FE10922892251A451442108410
+70A6:10501048104814405BFE5080508090FC11441144112829282610422844448182
+70A7:1080108010FE15005A205120512C917413A41124113429282522450240FE8000
+70A8:10201010101015FE5902520450809088109010A010C0288224824482407E8000
+70A9:1040104010A014A0591052485426902013F810081010291024A0444040208020
+70AA:10201020112415245924512451FC902010201124112429242524452441FC8004
+70AB:10201010101015FE582050205044908411F8101010202844248245FE40828000
+70AC:100011FE11001100550059FC510491041104110411FC29002500450041FE8000
+70AD:0100210821083FF808000800FFFE10801088148824902940414082200C183006
+70AE:1080108011FC15045A0455F451149114111411F4110429282512450240FE8000
+70AF:100011FE110215025902517A514A914A114A114A117A294A25024502410A8104
+70B0:080008001FF020105F90109010901F901050102410040FFC0000488844448444
+70B1:02000400082010103FF800081FF0101010101FF00100111022A004401830E00E
+70B2:102010201040108855045BFE5002900011FC1104110429042504450441FC8104
+70B3:100013FE10201420582053FE522292221252124A128A2B0226024202420A8204
+70B4:10201020102011FC5524592451249124112413FE102028502450448841048202
+70B5:10401040107C108455885A50502090501088130610602810240844C040208010
+70B6:1020102010201020543E58205020902011FC1104110429042504450441FC8104
+70B7:10401020100015FE582050205020902011FC1020102028202420402043FE8000
+70B8:11001100110015FE5A805280548090F810801080108028FC2480448040808080
+70B9:02000200020003FC020002003FF02010201020103FF000002488224442448004
+70BA:020012000A007FF0042004400FF8080810101FFC20042AA44AA4900400280010
+70BB:1000100013FE102054205840504090FC11841284148428842484448440FC8084
+70BC:1040104017FC108054805BE05120922013FC1020112829242622442240A08040
+70BD:1000100011FC1104550459045104910411FC1104100028902488450442028402
+70BE:100011FC110411045504590451FC9050105010501050289224924512420E8400
+70BF:1020104011F815085908514851289128110817FE110829082508410842288410
+70C0:1008103C13E01020552458A450A8902013FE1020102028202420442040A08040
+70C1:1008101C11E0110055205920512091FE1020102010A828A42522462240A08040
+70C2:1000110810881490580053FE50009000100011FC100028002400400043FE8000
+70C3:100011FC100810105430584850849302100011FC102028202420442043FE8000
+70C4:10401020102013FE540058885104920210881088105028502420445040888306
+70C5:102010201040148059FC51545154915411541154115429542554415443FE8000
+70C6:10801080113C120054805880517E930815081108110829082508450841288110
+70C7:10201020105014885904520251FC90201020102011FC28202420442043FE8000
+70C8:00047F84082408241F24212451240A24040408143008C0002488224442448004
+70C9:080008001FE020204040BFF820082288244828280100111022A004401830E00E
+70CA:11041084108814005BFE5020502091FC1020102013FE28202420442040208020
+70CB:08400840104037FC50E091501150124814441842104000002488224442448004
+70CC:109010901090151059FE53105510913811381154115429922510451041108110
+70CD:10201120112011FC55205A20502093FE1090109010902890251245124212840E
+70CE:00003FF808200820FFFE08201020202041201110111022A0044008203018C006
+70CF:020004001FF0101010101FF010001FFE10001FFC000409242494249440280010
+70D0:1020104011F8150859485128512893FE11081148112829282508420842288410
+70D1:10901090109014925A945098509091981294149210902890251241124212840E
+70D2:10281024102414205BFE5020502093A0112011101110291025CA470A42068002
+70D3:1020102011FC14205820502053FE90001020102011FC28202420402043FE8000
+70D4:100011FE11021102557A59025102917A114A114A114A297A25024502410A8104
+70D5:0028002400203FFE202020202FA4222422642AA832282510249248AA50468082
+70D6:084008487F4408440840FFFE00400844294429442A28482A1412122A22464082
+70D7:10201010101013FE54205842508491F81010102210C42B082410442840C48302
+70D8:108810881088108855FE588850889088108813FE100028882484450442028402
+70D9:1080108010F815085B1054A0504090A01118120615F829082508450841F88108
+70DA:102010201050108855045A0251FC9000100011FC110429042504450441FC8104
+70DB:10201020102011FC552459245124912411FC112410202828242445FE40828000
+70DC:100013FE1000140059FC5104510491FC1104110411FC29042400400043FE8000
+70DD:00001FE0004000807D040588095011202118450682001FF00000488844448444
+70DE:10881088108814885BE85088518C91CA12AA1288148828882488448840888088
+70DF:100013FE120216225A22522253FE922212221252124A2A8A2702420243FE8202
+70E0:1040104017FE1080550059FC5304950419FC1104110429FC2504450441148108
+70E1:010011081108229004401830E44E04403FF804400440FFFE0000082010102008
+70E2:1040102013FE12025400583853C090401040107C13C0284024424442403E8000
+70E3:10401040104013FE54805890509091121152115412902A282428444440848102
+70E4:1040104411F4104854505BFE5040908011FE1240148028FC2404440440288010
+70E5:100011FE11201120552059FC510491041104110411FC29202520452041FE8000
+70E6:100013FE1020104055FC59045104912411241124112429442450448841048204
+70E7:2080208020BC23C0A850B024A0D4A30C200027FE2090209051124912420E8400
+70E8:10901094111415185B1055325152910E1120102013FE28202420442040208020
+70E9:10201020105014885904520250F89000100013FE102028402488410443FE8102
+70EA:108810481050100055FC58205020902013FE1020105028502488448841048202
+70EB:23F0102080C043FC11242124E2442484292820100100111022A004401830E00E
+70EC:100011FC1104150459FC511051109108110412621410280024E0441840048000
+70ED:104010401040FDF8104810481CC83048D0AA10AA510622020000488844448444
+70EE:7F84082410243F2451240A24040408043014C10811101120228004401830E00E
+70EF:11841068103014C85B04504053FE90A0112013FC152429242534412840208020
+70F0:1008103C11C01004554458A8500091F81010102013FE28202420442040A08040
+70F1:100013FE120216525A8A5306520292FA128A128A128A2AFA268A4202420A8204
+70F2:080C08F07E8008800EFE7888088829081208010011101120228004401830E00E
+70F3:1028102413FE1020542059FC5124912411FC1124112429FC252445244124810C
+70F4:100011FE100014925924524851249092100011FE102028202420442043FE8000
+70F5:1088108813FE10885400588050FC910412041484104428442404440440288010
+70F6:1000100613B8148858885108513E9388108812881288293E25004280447E8800
+70F7:1040102013FE16025C0451F85000900013FE10901090289025124112420E8400
+70F8:1080108010FE15005AFC508450A4909413FE10841124291425FE440440288010
+70F9:0100FFFE00001FF010101FF000003FF000600180010005000200488844448444
+70FA:1040102011FC1104550459FC5104910411FC1120112229142508454441828100
+70FB:1004100E13B8148858885128512E93A810A812A812A8293E25004280447E8800
+70FC:100013FE1040148059445224506890B011301228106828A42522422040A08040
+70FD:1040104010FC10885550582050D8932610F8102010F8282027FE442040208020
+70FE:01000910092012C0043019086914091012A004401830610C1FF0010001007FFC
+70FF:100213C2124416485B5052C2524292441FE8125012422A4226444248445088E0
+7100:10001050104810845524582050509088110612F8108828882488448840F88088
+7101:0080008078FC49044A48484078B0030C0C02010011101120228004401830E00E
+7102:1040104024FE6488A55024202450208801041110111022A0044008203018C006
+7103:1020102011FC10205420582053FE90481048114C114A2A4A2488448841288210
+7104:00003FF80408FFFE04083FF808001FF8280848088FF808080000488844448444
+7105:10201120112011FC55205A20502093FE1000100011FC29042504450441FC8104
+7106:100010FC1084108454FC580051FE9102110211FE1102290225FE4502410A8104
+7107:1020112410A410A8542059FC5104910411FC1104110429FC2504450441148108
+7108:1000087C3E442244227C3E4022422042413E9110111022A0044008203018C006
+7109:00007FFC010011F811001100FFFE08000FF810001FFC00042924249440280010
+710A:100011FC110411FC550459FC5000900011FC102010202BFE2420442040208020
+710B:2420242024203DFC0420FC20242024F84400010011101120228004401830E00E
+710C:10401040108815045BFE500250889144124210F811882A502420405041888606
+710D:11081088109015FC5824502451FC9120112011FE106228A2252A422444208020
+710E:1000100C11F0FD00110011FE1D10F11011101210521024100000488844448444
+710F:00003FF0002000400180793C4944492849107928014405000200488844448444
+7110:100013FE1040104055FC5884508493FE1000100011FC29042504450441FC8104
+7111:100013FE122216225A2253FE52229262127212AA13222A222622420243FE8202
+7112:100010FC108410845484588450FC9000100011FE110229022502450241FE8102
+7113:10201020105014885944522250F890081010102011FC29042504450441FC8104
+7114:10401040107C148459085210513E912211221122113E292225224522413E8122
+7115:1080108010F815085A1055FC512491241124112413FE28502450448841048602
+7116:110010BE128216025A2252125252924212CA135612522A3226024202420A8204
+7117:100011FC1104150459FC5100510091FE1102117A114A294A267A420244148008
+7118:020002007FFC02003FF80400FFFE08201FFC20204420822002A0004024884244
+7119:1040102011FC100055085890500093FE1000100011FC29042504450441FC8104
+711A:082008207EFC08301C682AA4C922082009201110111022A0044008203018C006
+711B:7C7C44447C7C44447D7C4104410449244924494451844244422444244804500C
+711C:100011FC1104110455FC5904510491FC1000111211D42918251045524192810E
+711D:101C13E0122013FE56205A92530A920611FC1104110429FC2504450441FC8104
+711E:1040102013FE100055FC590451FC900011FC100810102BFE2420442040A08040
+711F:10881088108817FE5888508857FE900011FC1104110429FC2504450441FC8104
+7120:1040102013FE100054885888515492221000102013FE28202420442040208020
+7121:100010001FFC2AA04AA00AA07FFC0AA00AA00AA07FFC00002488224442448004
+7122:10201010101015FE5902525450889104100010FC102028202420442041FE8000
+7123:00007F0022FC3E4422443E44222822282F10F228424402820000488844448444
+7124:010000803FFE2210221025FE2C903450441044508520111022A004401830E00E
+7125:1040102013FE12025504590051DE925212521352149A2894251045124212840E
+7126:090008801FFC108030805FF8908010801FF8108010801FFC1000488844448444
+7127:10901090110815485A445492510893FC1044102010A42A82268A428A44788000
+7128:100013FC120412F456045AF4500091F8110811F8110829F82508450841288110
+7129:100013DE125216525A5253DE52529252125213DE12522A5226524252455288A6
+712A:1040102013FE120254885904520291FC100411FC110029FC2404440440288010
+712B:1088108813FE108854A8582051FC912411241154114C29842504450441148108
+712C:100011F81108150859F85108510891F8108011FC125428942524424440948108
+712D:08202AA42CA84920145022887FFE400280040FE00820082008221022201EC000
+712E:201020902710243EAC22B444A790A51025102510252825285528494449449082
+712F:10201020103E142059FC510451FC910411FC112410202BFE2420442040208020
+7130:10401040107C148459085200502091CE1102110211CE29022502450241FE8102
+7131:010011081108229004401830E00E08100A102A542C5448981410222842448082
+7132:2080204027FE2120A920B23CA244A664229423482248223052204A5042888306
+7133:10A01090108015FE5910531055FC9110111011FC11102910251045FE41008100
+7134:1040102013FE108055045BFE500291FC110411FC110429FC2504450441148108
+7135:100013FE1202168A5A5253FE5222922212AA12AA12AA2AFA26024202420A8204
+7136:102010281E24222033FE4A20A450145008881088210442020000488844448444
+7137:1040108011FC1124552459FC5124914411FC109011102BFE2410441040108010
+7138:00003E7C224422443E7C224422443E7C01001110111022A0044008203018C006
+7139:100013FE1202168A5A5253FE5242922213FE128212822A8226FA4202420A8204
+713A:100011FC110411FC550459FC5000902811C8108810882BFE2488448841088208
+713B:11F81108110815F85908510851F8900013FC120412042BFC2604420443FC8204
+713C:1020102011FC102054A8588853FE9088100013FE1090289025124512420E8400
+713D:00007CFC448444FC7C8444FC44847C84011402080100111022A004401830E00E
+713E:10201020105014885944522251F890081050102010A42A82268A428A44788000
+713F:1040102013FE16205AFC5224522493FE1224122412FC2A202650445044888906
+7140:100013FE120216025BFE521052929292129212FE12102A922692449244FE8802
+7141:1088108813FE108854F8588850F89088108813FE110029482584450041FE8000
+7142:1088108813FE108854F8582051FC9124112411FC10202BFE2420442040208020
+7143:1020102013FE105054885B2651FC9020102013FE1000282025FC4420402083FE
+7144:1008103C11E014205BFE502051FC912411FC112411FC282025FC442043FE8000
+7145:102011DC11141114551459D45126910011DC1114111429D42708450841148122
+7146:100013DE124216425A4253DE5200923E13D2121212142BD42608421442248242
+7147:100013FE1222102055FE582051FC912411FC112411FC282027FE442040208020
+7148:200027FC24042434ADC4B444A5F4A554255425F42444245455F44C9448069002
+7149:1020102013FE102055FC592451AC9174112411FC1020287024A8452442228020
+714A:1040102013FE1202540459FC500091FC110411FC110429FC2504440043FE8000
+714B:100011FC110415FC590451FC5020912011FE1220102029FC2420402043FE8000
+714C:1020104011FC150459FC510451FC900013FE1020102029FC2420402043FE8000
+714D:208821C827082108A92AB12AA7ACA14823082388255425145914492441248142
+714E:10100820FFFE00003E4822483E4822483E0822082A2824100000488844448444
+714F:100013FE100015FC5904510451FC900013FE122212222BFE2622422243FE8202
+7150:1088108813FE108854A8582051FC91241124112413FE28202450448841048202
+7151:01081FD001207FFC02000FF03810CFF008100FF00100111022A004401830E00E
+7152:2040204021FC2084ABFEB000A1FCA10421FC202023FE202052204BFE40208020
+7153:102011241124112455FC580053FE9020104011FC11542954255445544154810C
+7154:1020522054209020283C44208220102010FC5284548490842884248442FC8084
+7155:00007F7C444454445744517C51405740544244427F3E00002488224442448004
+7156:101E13E010441524588851FC5040904013FE108010FC29442528421040688186
+7157:100013FE1020104055FC5954515491541154112C10202BFE2450448841048202
+7158:20142012201027FEAC10B410A5D0A412241225D42554254855DA4C2A48469082
+7159:100013FE105014505BFE52525252925213FE102010202BFE2420402047FE8000
+715A:00007CFE448044FC7C8444FC44807CFE01001110111022A0044008203018C006
+715B:00003EF822883EF822883EF822883EF801001110111022A0044008203018C006
+715C:100011FC110415FC590451FC51049040102013FE100029042488400047FE8000
+715D:100013FC122416245BFC520052FC9284128412FC12842AFC2684428444FC8884
+715E:202020203C40447E88847F44024402287E2802100228FE440082488844448444
+715F:100013FE122213FE56225BFE500091FC110411FC110429FC2504450441148108
+7160:10481148114817FE594851485178910011FE102013FE287024A8412446228020
+7161:20102010207C2714A9FEB114A27CA210277C211021FE251052104B0044FE8800
+7162:08202AA44D28145022887FFE400280041FE0042004203FA004200414040C0404
+7163:100011FC104814305BFE5052509491101230102013FE287024A8412446228020
+7164:1088108813FE1088548858F85088908810F8102013FE287024A8452442228020
+7165:2080208020F82108AA10B5FCA104A154218C2124202023FE5050488841048602
+7166:0100790049FC4A044C0479E44924492449E44804782800102488224442448004
+7167:00007DFC44444444444444947D0844FC4484448444847CFC0000488844448444
+7168:100011FC1124112455FC5924512491FC100013FE112029222514454841848102
+7169:100013FE1020144059FC5104510491FC110411FC1104290425FC440040888104
+716A:11081088109017FE5890509053FC92941294130C12042BFC2604420443FC8204
+716B:2108209020002BFEB080A184A244A4A82130227024A8212852244C2248A08040
+716C:200023F822082BF8B208A3F8A000A7FE220023FC2494292452444C8449288210
+716D:2484490424A400247FA408241F24612412240C043014C0080000488844448444
+716E:020002083FD00220FFFE01000FF03810CFF0081008100FF00000488844448444
+716F:1110111211D4111855525992512E904011FC1104110429FC2504450441FC8104
+7170:100010F8108814885888508850F89088100013DE12522A522652425243DE8252
+7171:100011FC1104150459E45124512493FE120212FA128A2A8A26FA4202420A8204
+7172:08000BF8120833F8504097FC11501248144410400100111022A004401830E00E
+7173:1100113C112417A45924513C512493A412A412BC12A42AA427A4444440548088
+7174:100011F81108150859F85108510891F8100013FC12942A942694429447FE8000
+7175:1020102013FE1420582053FE528A925212FA122212222AFA26224222422A8204
+7176:100011FC1104150459FC5104510491FC100013FE10202920253C412042A0847E
+7177:2080204027FE2000ABF8B208A3F8A00027FE240229F4211051104A124412880E
+7178:1040102011FE1102550259FE5100910011FE11AA12AA2AFE24AA44AA40A28086
+7179:1088108813FE148859FC508853FE902011FC112411FC292427FE410441148108
+717A:200024F822882288A8F8B088AE88A2F822A22294228822A852C44A84450088FE
+717B:1020101013FE16205AFC522453FE922412FC122012FC2A842684448444FC8884
+717C:2080208021FC2A44B154A1F4A084A128229021FC2244255451F4488449288210
+717D:1020101011FE1502590251FE510091EE112211AA11662922256642AA42228466
+717E:100011FC1124152459FC51245154918C110411FC1040282024A4428A428A8478
+717F:1028102413FE102055FC592451FC912411FC112410082BFE2488444840488018
+7180:100011FC110411FC550459FC5020912410A8102013FE2890249045124212840E
+7181:104011FC1044109455085BDE514A914A129411FC110429FC250445FC4104810C
+7182:2100210021FC2A00B5F8A000A3F8A08822A821C827F8208A51CA4EAA48868082
+7183:00407EFC15440838FE441AA22CFC4844A89411080100111022A004401830E00E
+7184:1020104011FC150459FC510451FC910411FC1040102028A4268A428A44788000
+7185:100013F8124812A857185A0853F89000100017FC14A42CA424A444A44FFE8000
+7186:1020102011FC1420582053FE5080910413FE100213FC2A942694429447FE8000
+7187:1040102013FE140059FC510451FC900013FE120212FA2A8A26FA4202420A8204
+7188:00002FBC2A242A242FA428BC28A02FA02A224A224F9E80002488224442448004
+7189:100010FC1084108454FC580051FE910211FE110211FE290225FE444840848102
+718A:1080249842E07E8400847E7C42807E9842E07E844284467C0000488844448444
+718B:108024987EE000847E7C42007E9842E07E844284467C0100111022A00C60701C
+718C:100013DE125217DE5A5253DE520292221222122212522A4A268A4202420A8204
+718D:1020101011FE1102540058FC5084908410FC100011FE29022502450241FE8102
+718E:1008103C13C010045644592851FC9220102013FE102029242524452441FC8004
+718F:00F83F000100FFFE01003FF8292825483FF801003FF80100FFFE488844448444
+7190:100013FE1202100055FC590451FC910411FC104010202BFE2400448841048202
+7191:10881050100015FE585051FC505493FE105411FC105028D82554425240508050
+7192:08202AA42CA84920145022887FFE400281041110111022A0044008203018C006
+7193:2080210023F82208AA08B3F8A200A3FE220023FC200425545554480440288010
+7194:1040102013FE160258505088512490501088110412FA28882488448840F88088
+7195:100011FC102014205BFE500051FC910411FC110411FC290425FC448841048202
+7196:101E11E01022111254945880502091CE1102110211CE29022502450241FE8102
+7197:2040204020A02990B248A7FEAA08A3F8220823F8220023F855084D0849F88108
+7198:104013BE121216925A5252AA5324904013FE122212222BFE2622422243FE8202
+7199:00007F7C444444445F44517C51405F40444244427FBE00002488224442448004
+719A:100011FC112415FC592451FC50A890A813FE10A810A829FC242043FE40208020
+719B:100013FE105011FC5554595451FC900011FC100013FE282024A8452442A28040
+719C:1020104011FC1524597C518C51549124115411FC1020281025544542414A8238
+719D:1040102013FE125056505BFE5252925213FE120012922AD42698449244D2888E
+719E:100013DC129417D45A5453C85288929413E21000102029FC2420402043FE8000
+719F:1040FE4000407DF844487C4800C87C4808AAFEAA110652022000488844448444
+71A0:100013DE10421252554A5A525042902011FC1104110429FC2504450441FC8104
+71A1:204023F822482FFEAA48B3F8A040A3F8224823F820802FFE511048E043188C04
+71A2:1020147C12841548583050CE5610927C1210127C12102AFE2610421045FE8800
+71A3:1020122213FE1090548859FE5310951011FE1110111029FE2510451041FE8100
+71A4:100013DE1042114A54C6594A525290021040102011FC280025084488409083FE
+71A5:20FE240422282210A8FEB092AE92A2FE229222FE2292229252964D0048FE8000
+71A6:102011241122152A5A325060519097FE112011FC112029FC2520452041FE8100
+71A7:11102110CAA814443240D27C154014FE0800010011101120228004401830E00E
+71A8:3F0821083F7E20082F4820285FA8440895282C900100111022A004401830E00E
+71A9:1040102013FC16045BFC520052F8928812F8120013FC2B2425FC4502490280FE
+71AA:20102190261E2222AA54B208AF90A2642208271E2AA2224252144A0842108260
+71AB:1040102013FE120056485A4853FE92481248124812782A002554452A4A2A9000
+71AC:082008207F20087E7E4408A4FF2810101E282244468280002488224442448004
+71AD:1010FEFE10107C7C1010FEFE10103FF800081FF800083FF8111022A00C60701C
+71AE:200027BC208424A4AA94B4A4A050A188262620C0231020645388483040C08700
+71AF:1088108813FE108854F8582051FC912411FC102011FC282027FE445040888306
+71B0:100013FE1200167C5A445244527C920012EE12AA12AA2AAA26EE420043FE8000
+71B1:104010407C4010F8FE48444892C87C4810AA1CAAE10642020000488844448444
+71B2:400044FE7810422042FC3E84008410FC528452FC5484908428FC244844848102
+71B3:100011F8110811F8550859F8500093FC129413FC100029F82490446041988606
+71B4:20402444244427FCA800B7FCA404A7FC240427FC2000242457A84C3245A2861E
+71B5:1040102013FE1488585053FE5252928A130612FA128A2A8A26FA4202420A8204
+71B6:200023F8220823F8AA08B3F8A000AFFE248027BC2494279454D44F88409480A2
+71B7:11041088100013FE56225AAA5272922213FE100011FC290425FC450441FC8104
+71B8:200027BC21082528AFBCB318A5AAA946200023F82208220853F84A08420883F8
+71B9:01007FFC01003FF800003FF820083FF80820FFFE00003FF820083FF824884244
+71BA:102013FE102011FC540059FC510491FC108813FE100029FC2504450441FC8104
+71BB:204020A021182EE6B000A3F8A208A3F8200027BC208424A452944CA44A948108
+71BC:200027FC244427FCAC44B7FCA110A11027FC211021102FFE5000491042088404
+71BD:102011FC102417FE582451FC502092AA13AE122213FE2A2227AE42AA42AA8422
+71BE:1110109413D214125A50519057FE901013D2125212542BD4264A424A43D68022
+71BF:1088108811FC108854885BFE502091FC112411FC112429FC2400448841048202
+71C0:100013DE1252125257DE580051FC912411FC112411FC282027FE442040208020
+71C1:108813FE1088100055FC58A850A893FE10A810A811FC282027FE442040208020
+71C2:100013FE105013FE56525BFE500091FC110411FC110429FC242047FE40208020
+71C3:1110111411D216505A7E5550509092A81128114412442C82240842A442528452
+71C4:101010523E5422904428804410826610425242546698421042287E2842440082
+71C5:081008527E5408900828FF4424824210895208547E98081008280F28F8444082
+71C6:101C11E0104017FE5888510452FA948810F8100013FE2A0226FA428A42FA8206
+71C7:1088105013FE105055FC5954518C9174110411FC10082BFE2508448840A88010
+71C8:202027A420A82A92B114A208A5F4A80223F82208220823F8520849104FFE8000
+71C9:2208210827C82010AF9EB494A7A4A01427942094211421C85708491445248242
+71CA:1108211002E00C1870040010525294942828C4C401007FFC05401930E10E0100
+71CB:1090108811FE15105B1055FE5110911011FE1110111029FE250042A442528452
+71CC:102011FC102014885BFE508851FC910411FC110411FC290425FC448841048202
+71CD:22402242225C27F0AA50B3D0A25EA3D42254225427F4201452944C6448248044
+71CE:2040204027FC20A0AD14B208A7FCAA0A23F8220823F8204052484C4449448080
+71CF:100013FC104814305BFE505250949350102013FE12522A8A2776425242728206
+71D0:20402248215027FCA950B248A444A210239024BC2A902150517E4A1042108410
+71D1:102011FC108814505BFE500051FC912411FC112411FC282025FC442043FE8000
+71D2:1020102011FC14205BFE5108539C91081188163E10002BFE249044904112820E
+71D3:24482288F93E22886458729CA92A22882448010011101120228004401830E00E
+71D4:103C13E0112410A855FE58A85124920211FC1124112429FC2524452441FC8104
+71D5:0440FFFE0440044017D01012F01C17D014503452D7D2100E0000488844448444
+71D6:100013FC100413FC54045BFC500093BC112417BC10082BFE2508448840A88010
+71D7:279E2492279E2492AF9EB402A4F2A49224F2249224F2249254924D3244028406
+71D8:100013DE125217DE5A5253DE5242922212FA121212522A2226524282420A8204
+71D9:23F8120893F8420843F810002FFEE20027FC292422540588111022A00C60701C
+71DA:1010525254549090282844448282101010525254549890102828242842448082
+71DB:0000FEFE12907EFC42847EFC1290FEFE01001110111022A0044008203018C006
+71DC:2000279E2492279EAC92B79EA442A422240A25462542255256324C02440A8404
+71DD:100011FC110415FC590451FC502093FE100011FC110429FC2420452442228060
+71DE:142012203F3E24426494BF1024103F10242824283F4420820000488844448444
+71DF:08202AA44D28145022887FFE40029FF410101FF000003FF8200820083FF82008
+71E0:2080210027FC2444AD54B444A7FCA4E425542404204027FE50A0491042088C06
+71E1:100013FE125213FE542059FC502093FE1088105011FC282027FE442040208020
+71E2:0A803138228838382288393822887FFE41029114111022A0044008203018C006
+71E3:102013FE100011FC5504597451549174110411FC100828F0242047FE40A88326
+71E4:1088108813FE148859FC512451FC912411FC102013FE2A22262A42FA420A8206
+71E5:10F81088108814F8580051DC5154915411DC102013FE287024A8412442228020
+71E6:208020DC22842BD4B448AA94A324AC402248215027FC20E051504A484C468040
+71E7:104412241128147E58105028534A911C1128114C111A292A2548411042FE8400
+71E8:220821102FFE2840B7FCA040AFFEA054279221102FFE211051D44F0A49168322
+71E9:2108220827C82450AFDEB464A7D4A214211427D4221423C852484C54455488A2
+71EA:108813FE108815005BFC555450D49324105410941348282024A4428A428A8478
+71EB:102013FE1288125057FE5A5052FC925413FE125412FC2A5026D8455446528850
+71EC:210026DC24542454AED4B454A466A7C0201C201427D42114510849C847148222
+71ED:200023F822A82AA8B3F8A100A3FCA48423E422A422A423E450944FF448148008
+71EE:210827C820086B9AB02C2388200853944A928BA200003FF0082004C00780F87E
+71EF:100011FC102013FE562259AC502091AC105010C8132628F8240844D040208010
+71F0:203C23C020442224A908B7FEA442A2A4228A247A208020F851084A904060879E
+71F1:1040102011FC1488585053FE500091FC110411FC110429FC24204294428A847A
+71F2:104013FC1044109455085BDE514A92D611FC110411FC290425FC450441FC8088
+71F3:200027BE24922492ACAAB7A4A4C0A4BE24A224A227BE24A250004AA442528452
+71F4:204020A023182DF6B000A7FCA554A4E427FC200023F8220853F84A084BF88208
+71F5:10101410127C141058FE5044562892FE1210127C12102AFE2610421045FE8800
+71F6:109013FC129417FC5A9453FC500093FC120012F812002BFE2520451445488986
+71F7:102013FE100015FC5904517451549174110411FC100029FC240043FE41248262
+71F8:100011FC102013FE562259AC502091AC100013FE102029FC255445544154810C
+71F9:FEFE202050509A9A2C2C48489C9C2A2AC8C818180100111022A004401830E00E
+71FA:102013FE100014F8588850F8500093FE1202127212522A76242043FE40A88326
+71FB:101C11E0102013FE542059FC51AC917411FC102011FC282027FE44004154822A
+71FC:204023F8204827FEA848B3F8A040A7FE200022A4245223F852A84AA84FFE8000
+71FD:204027FC204023FCA800B7FEA002A3F8204027FE200027FE50084FFE44A88798
+71FE:01007FFC01003FF80000FFFE00023FF00100FFFE00107DFC44907C3024884244
+71FF:100013DE10421252554A5A525090910813FE151011FE291025FE451041FE8100
+7200:21102110211027BCA910B110AFFEA2A822A826EC2AAA22AA52A84DA844488898
+7201:100813E8128817EE5A2853F4528293E2100011FC115429542554415447FE8000
+7202:2FEC48244BA4682C4BA46AAC4BA44824FFFE810211101120228004401830E00E
+7203:108812AA12DC148859545222500093FE1222102013FE287024A8412446228020
+7204:100013FE124817FE5A4852FC52A492FC12A412FC12202BFE272A457A450A8906
+7205:11FC112411AC152459FC502051FC902013FE1154122A282025FC402043FE8000
+7206:11FC110411FC150459FC508853FE908817FE108811242AAA247040A841248060
+7207:0820FFFE082010407C4011F8FE4844C892487CAA10AA1D06E202488844448444
+7208:2020203E202027FEAC22B5F8A422A5FE252425FC252425FC58404AA4528A847A
+7209:11241248112414005BFC52945264929413FC124813682A48276A424A42468362
+720A:2080204027FC24A0AFFCB4A4A7FCA400252425A8253025A4551C48004AA49452
+720B:21C82708210827C8A93EB7CAA54AA7CA254A27CA210A27CA510A4FEA4AAA9156
+720C:2040202027FE2488ADFCB488A7FEA42025FC252425FC252455FC4C0044888904
+720D:244424E428A82AAAAEEEB4A4AAAAAEEE224220402FFE20E051504A484C468040
+720E:1040102013FE122255FC5850528A91FC128A10F8108828F82420452442A28040
+720F:200027FE24442598AC88B7DEA488A5DC26AA248824202520553C4920492097FE
+7210:1040107C104013FC56445BF0524492FC12A812F812A82AF8260045FC45548BFE
+7211:1088108813FE14A8589051FE512093FC152011FC112029FE250042A442528452
+7212:101010101EFE221054AAA8441082287CCA442A7C2C44487C1410125422924030
+7213:13DE125213DE16525BDE5242527A928A131212DA128A2ADA268A42FA420A8204
+7214:211027FC204023F8A840B7FCA000A3D4211227FE23502534538C488A42968102
+7215:210827C820086B9AB02C2388200853944A928BA20100111022A004401830E00E
+7216:2210211027DE2010AC5EB282A7DEA01027DE245027DE245057DE4C50445284CE
+7217:11FC110411FC150459FC508853FE908811FC10A813FE28A825FC442043FE8020
+7218:108010DE128213D454485AB4514A96A411FA128810F8288824FA449440A880C4
+7219:102013FE100015DC595451DC508893FE108813FE10882BFE2494418842A480C2
+721A:204020A021102208ADF6B000AEEEAAAA2EEE20002FFE29225FFE4922492A8804
+721B:13DE125213DE16525BDE522252FA922212FA12AA12FA2AAA26FA427242AA8226
+721C:249222942FFE2910B7FCA040A3F8A0402FFE248027BC249457944CC84F9480A2
+721D:101E13E0112214945BFE525253FE900413C4127E13C42A5427CC428442D48348
+721E:2040204023F82248ABF8B044A7FCA00422082FBE2AAA2FBE52084A8A4FBE8082
+721F:208823FE208823DEAA52B3DEA0A0A09021FE212023FC252051FC492041FE8100
+7220:27BC24A427BC24A4AFBCB4A4A7BCA12023FE222027FC2A2053FC4A2043FE8200
+7221:108813FE108811FC552459FC512493FE122A12FA122629FC252445FC402283FE
+7222:00803FFE24103F7C26382D54341221202F3C2120273821202F3C41205244A122
+7223:2248215027FC2404A9F0B110A7FCA55424E427FC204027FC50404FFE42A48452
+7224:211027FE211027BCACA4B7BCA4A4A7BC244427FC255425F454444CE445548448
+7225:13FE120213FE16925A54529252FE92AA12FE132212FA2AAA24FA442249FA8004
+7226:2790251E27A82484AFBEB52AA7BEA00023F8220823F8220853F848A04124861C
+7227:27FC20402FFE2842AB58B040A358A0002EEE2AAA2EEE20005FFE4A4845548FFE
+7228:2FEC48246BAC48246BAC4AA4FFFE88227EFC2C684AA4FFFE11102928C6C61830
+7229:228822E82F5E22ECAF5ABAE8A208AFFE29423494255827F252044BE8420283E4
+722A:001000F81F201220122012201220122012201210121022102208420842048002
+722B:00000008007C07807A1021101120100000000000000000000000000000000000
+722C:0E00740055FC55245524552455FC550055005502550252FE5200510090FE1000
+722D:000801FC7E10221011203FF801080108FFFE010801083FF80108010005000200
+722E:024007403A7C2A842B742A542A542A742A482942294228BE28404830480E8800
+722F:000801FC7E102210112001003FF8210821083FF821082108FFFE200820282010
+7230:000801FC7E10221011203FF8020002007FFC04000FE01420224041808660381C
+7231:000801FC7E10221011207FFE420282047FF8040007F00A10112020C043301C0E
+7232:00FC7F00121009201FF0101010101FF8100810081FFE20022AA2495251548008
+7233:00F83F2009401FE010201FF010101FFC20042AA4400C9FE00040018005000200
+7234:0004FF0E8D748B54FF548954E954A954EB548554E5548B549154FF9200920100
+7235:00FC7F00220811107FFC44447FFC00087E0842FE7E0842487E28480874284210
+7236:044008201010200840240820082004400440028001000280044008203018C006
+7237:044008201850248803000CC03030C00E1FF00210021002100250022002000200
+7238:044008201850248803000CC03030C00E1FF0111011101FF01010100410040FFC
+7239:044008201850248803000CC03230C7CE1A4001A01E7801880E90006003803C00
+723A:084010202850448803001CE0E01E00007F7822483E5022483E4423D4FE480240
+723B:00081810066001800660181860040020082004400280010002800C403030C00E
+723C:040045F829081108290845F881080508450829F8110829084508810807FE0000
+723D:010001007FFC01002928111029280100292811102AA80280044008203018C006
+723E:00007FFC21084104BFFA21083558292835582108355829283558210821282010
+723F:00100810081008100FF00010001000107FF00810081008101010101020104010
+7240:042024202420242025FE3C2004700470FCA824A8252425242622442044208420
+7241:0400240025FE240824083DE805280528FD28252825E825282408440844288410
+7242:048424442448240025FE3C20042004FCFC20242025FE24202420442044208420
+7243:04482548254827FE25483D4805780500FDFE242027FE247024A8452446228420
+7244:042024202450244824A43DFE068404FCFC8424FC248024FC25444544467C8444
+7245:102057FE542055FC542477FE142415FCF42055FC552455FC552455FC5524892C
+7246:082028202BFE292429243AAA0FFE0800F9FC2904297429542974490449FC8904
+7247:004010401040104010401FFC1000100010001FE0102010201020202020204020
+7248:0808481C49E0490049007DFC41444144794449284928491049104A284A448C82
+7249:04202420252424A424A83E2021FC20203C20242027FE24202420442044208420
+724A:040025FC2444244424443E44209420883D0024FC248424842484448444FC8484
+724B:04482444245E25E024283E12206A21963C48245E25E0242424284412446A8586
+724C:0840488049FC492449247DFC4124414479FC489049104BFE4810481048108810
+724D:0820482048FC482048207DFE4002409478504890485049FE4828484448828902
+724E:0880488048FC49544AD47CB4412C424478944908484048A44AAA4A8A4C788800
+724F:08204850488849044AFA7C0041E2412A792A49EA492A492A49EA4922492A8964
+7250:0808483C49E0482048207DFE402040A0792C4924492449AC4924492449FC8904
+7251:0840482049FE490249027DFE4100410079FE49AA4AAA4AFE4CAA48AA48A28886
+7252:0848494849484BFE49487D484178410079FE48204BFE487048A849244E228820
+7253:0820481049FE488448487DFE41024224781049FE4840487C4844488448948908
+7254:082848244BFE482049FC7D2441FC412479FC492448084BFE4888484848488818
+7255:0820484049FC4924497C7D8C41544124795449FC484048244AA24A8A4C888878
+7256:084048204BFE4A024BFE7E1443FE42107AFE4A924AFE4A924AFE4A924C928896
+7257:081049FE4910497C49147DFE4114417C7910497C4954497C49544A7C4A548C4C
+7258:08204BFE482049FC48007FFE425243FE790449FC490449FC490449FC48888904
+7259:00003FFC004000401040104020403FFE01400240044008401040604001400080
+725A:111009207FFE40029FF410101FF000007FFC104020403FFE0240044019406080
+725B:01001100110011001FF82100410001000100FFFE010001000100010001000100
+725C:08000800480048007E004800880008000E00F800480008000800080008000800
+725D:08800880488048847E88489088A008C00E80F8804880088408840884087C0800
+725E:10401040504050407DFC5044904410441C44F084508410841104110412281410
+725F:02000400082010103FF80008010011001FF821000100FFFE0100010001000100
+7260:10201020502051207D2C5134916413A41D24F134512811221122110210FE1000
+7261:08200820482048207E20482089FC08200E20F82048200820082008200BFE0800
+7262:020001007FFE40028104110011001FF8210041000100FFFE0100010001000100
+7263:1000100051FC50447C445144914411441D44F244504410841084110412281410
+7264:10201010501050007DFE5080908010801C80F080508010801080108010FC1000
+7265:10401020502053FE7C805080908010FC1C84F084508410841104110412281410
+7266:0808083C49E048207E20483C89E008200E20F83E4BE00820082208220822081E
+7267:08400840484048807EFE49088A8808880E88F850485008200850088809040A02
+7268:10801040504053FC7C00500091F011101D10F1105110111211121212120E1400
+7269:10801080508050FC7D545254905410941C94F124522410441044108411281010
+726A:08100810489048907EFE4890891008100E10F9FE481008100810081008100810
+726B:08500848484848407E5E49E0884008440E44F848483008220852088A0B060802
+726C:10201020502E51F07D205120912011FE1C22F06250A2112A1624102010201020
+726D:1000100053FC52947E945294929412941E94F294529C13041204120413FC1204
+726E:08A0109030BE57C0904010241014110C09001FF821000100FFFE010001000100
+726F:10201020502050207DFE5020902010201DFCF104510411041104110411FC1104
+7270:10201020502050207DFC5124912411241D24F1FC512411241124112411FC1104
+7271:1000100053FE50087C0851E8912811281D28F12851E811281008100810281010
+7272:10201020512051207DFC5120922010201C20F1FC502010201020102013FE1000
+7273:100010FC508450A47C945084908413FE1D04F1445124110411FE100410281010
+7274:1004101E51F051107D105110911011FE1D10F11051101108110A114A11A61112
+7275:010001003FF80280044008207FFE410289040FF0110001007FFC010001000100
+7276:0100111009203FF802007FFC082011102908CFF6110001007FFC010001000100
+7277:10201020505050887D04520291FC10201C20F02051FC10201020102013FE1000
+7278:1040102053FE52027C0451F8900810101C20F3FE502010201020102010A01040
+7279:10201020502051FC7C20502093FE10081C08F1FE500810881048100810281010
+727A:100017FE509050907C9053FC929412941E94F294529C13041204120413FC1204
+727B:10901088508051FE7CA050A890B010A41CA8F0B05124112A1132122212DE1400
+727C:100011FE500050927D245248912410921C00F1FE502010201020102013FE1000
+727D:01007FFC08201FC002007FFE48229FF4011011001FF821000100FFFE01000100
+727E:100013FE504050407DFC5084908413FE1C00F00051FC11041104110411FC1104
+727F:10201120512051FC7D205220902013FE1C00F00051FC11041104110411FC1104
+7280:00003FFC20043FFC2000288826B02808248027F8288020805FFE408080800080
+7281:03083C0804487F480C48164825084428051011001FF821000100FFFE01000100
+7282:0C8070FC1124FD241244388455289010010011001FF821000100FFFE01000100
+7283:1040102051FC50007D085090900013FE1C00F00051FC11041104110411FC1104
+7284:1020102051FC50507C88510493FE10081DE8F128512811E81128100810281010
+7285:100013FE5202528A7E5253FE922212221EAAF2AA52AA12FA12021202120A1204
+7286:1020102053FE50207C2051FC910411FC1D04F1FC510411FC1104110417FE1000
+7287:010009000FF0110001007FFC0100111051507C7C90901E10F0FE501010101010
+7288:1020112450A850207DFC504093FE10881D04F2FA5488108810A810921082107E
+7289:1040102053FE50007DFC510491FC10001DFCF008501013FE1020102010A01040
+728A:1020102051FC50207C2053FE900210941C50F110509013FE1028104410821302
+728B:100011F8510851087DF8510891F811081DF8F108510817FE1000109011081204
+728C:100013DE524252427A4253DE9200123E1BD23212D21413D41208121412241242
+728D:10101010577C51147DFE5214927C17101D7CF51055FE12101210150018FE1000
+728E:08087E0808FEFE0808487E2808080F28F11011001FF821000100FFFE01000100
+728F:1080104053FC52047E0453FC920012001FFCF354535415FC155415541944110C
+7290:10C417045124511479145784912411141B943346D53C15041104110411041104
+7291:100011FC510451FC7D0451FC910411FC1C28F02453FE10501050108811041202
+7292:1040102053FE50007DFC510491FC10001FFEF20252FA128A12FA1202120A1204
+7293:1080108051FC5244795451F4908411281A9031FCD244155411F4108411281210
+7294:1100110051FC52007DF8500093F810881AA831C8D7F8108A11CA16AA10861082
+7295:1088108853FE5088788857FE908011FC1B2435FCD12411FC112411241124110C
+7296:08202AA42CA84920145022887FFE410289041FF821000100FFFE010001000100
+7297:1040102053FE52027C2451FC902011FC1C20F3FE502011FC1104110411FC1104
+7298:010000803FFE22102F7C26382B5432922040224023FC244020405FFE40408040
+7299:1040108851FC51087A5253FE905011881E2630C0D31010641388103010C01700
+729A:3F0821083F7E20082F4820285FA8440895282C9011001FF82100FFFE01000100
+729B:08203E7E08A47F281C102A2849443FFE2480248027F8288020805FFC40808080
+729C:1108108853C850107BDE526493D410141BD43054D09410E81388109412941122
+729D:102011FC508850507DFE500091FC11241DFCF12451FC102011FC102013FE1000
+729E:101811E0504053FE7C885174925210701C00F1FC51041174115411741104110C
+729F:7CF8048804F87C2041FC7D2405FC04282BFC100411001FF82100FFFE01000100
+72A0:1104108853FE50207DFC502093FE10541D92F09053FE109010D4138A109611A2
+72A1:100013FE524853FE7E4852FC92A412FC1EA4F2FC522013FE132A157A150A1906
+72A2:102013FE502051FC7C0053FE925213FE1D04F1FC510411FC110411FC10881104
+72A3:11241248512450007BFC5294926412941BFC3248D3681248136A124A12461362
+72A4:100013FC529452947BFC5110925213DC181233CED24013D2125C13D0125212CE
+72A5:1040102053FE52507BFE525293FE12001A9432D8D29012D2128E140015541A2A
+72A6:13F8120853F852087BF8511097FC11101FFE3110D248155410E01150124810C0
+72A7:111017FC504053F8784057FC900013D4191237FED3501534138C108A12961102
+72A8:081024483F7E64C8BF7E24483F7E24483F7E204011001FF82100FFFE01000100
+72A9:7C4011FCFD2439FC5524FDFC246818A2651E11001FF821000100FFFE01000100
+72AA:211027FEA040A2EEFAAAABEAAAAE2AE83BAAECE6228825F42290206021982606
+72AB:51184B947C3ED3A87C7E53A87C3E53A87EBE43A011001FF82100FFFE01000100
+72AC:01000120011001100100FFFE010001000280028004400440082010102008C006
+72AD:0000440028001000280048008800080018002800480088000800080050002000
+72AE:01100108010801007FFE0200040007F80A080A08111020A0404080A003180C06
+72AF:0000440029F81108290849088908090819282910490089020902090250FE2000
+72B0:00804480288010802BF0489088900890189028904890889209120912520E2400
+72B1:004044402840104029F8484888480848194828C8484888A808AA090A52062402
+72B2:00104410281010102BFE48308830085018502890489089100A10081050502020
+72B3:00404440288010FC29044A048804090418842844484488040804080450282010
+72B4:000045FC282010202820482088200BFE18202820482088200820082050202020
+72B5:00804480290011FE2A004C0089F8080818102860488089000A020A0251FE2000
+72B6:084008480844484428402FFE08400840184028A0C8A00890091009080A040C02
+72B7:00204410281011FE2900490089000900190029004900890009000A0052002400
+72B8:000047F02810101029104910891009FC1804280448048BF40804080450282010
+72B9:00904488288810802BFE48A088A008A018A028A04920892209220A22521E2400
+72BA:00804440284013FC2800480089F00910191029104910891209120A12520E2400
+72BB:00204420282013FE2820482089FC092419242924492489340928082050202020
+72BC:00108FD0505020905110911011501190311057109110111211121112A50E4200
+72BD:000045FC28101110291049108A100BFE183028504850889009100A1050502020
+72BE:0040885050482048504097FE1040104030A050A090A0111011101208A4044802
+72BF:00404420282010002BFE48408840086018502848484488440840084050402040
+72C0:042024282424242424203DFE04200420FC202450245024502488448845048602
+72C1:004044402880108829044BFE88020890189028904890889009120912520E2400
+72C2:0000440029FC1020282048208820082019FC2820482088200820082053FE2000
+72C3:000045FC284410442844484488440BFC18842884488488840884088453FE2000
+72C4:00404440284010402944494489480A50184028A048A088900910090852042402
+72C5:0008443C29E010202820482088200BFE18202820482088200820082051FC2000
+72C6:002044202820102029FC492489240924192429FC492488200820082050202020
+72C7:00404440284010402BFE484088E008E0195029504A488C440842084050402040
+72C8:000045FC29041104292449248924092419242924492488500848088451022602
+72C9:000045FE2810101028204820886808A419222A22482088200820080053FE2000
+72CA:00003FF820083FF820083FF820083FF801100108FFFE0280044008203018C006
+72CB:000045FC2800100028004BFE88200820192829244A248A220C22082050A02040
+72CC:002044202920112029FC49208A200820182029FC482088200820082053FE2000
+72CD:0080448029FC11042A044DF489140914191429F4490489280912090250FE2000
+72CE:000045FC29241124292449FC89240924192429FC492488200820082050202020
+72CF:0080448028FE11002A204920892C09741BA42924493489280922090250FE2000
+72D0:0008883C53D02290529092901290129032905288928812C812A414D4A4924800
+72D1:0040444028A010A029104A488C2608201BF828084810891008A0084050202020
+72D2:00904490289013FC289448948BFC0A901A902BFE48928892091A091452102410
+72D3:00104410281011FE29124914891009FC194429444928892809100A2852442482
+72D4:000045FC29041104290449FC89000940194429484970894009420A42523E2400
+72D5:002089205120222052FC94A4172411243224522494A417A410C41044A0944108
+72D6:00404420282013FE2A024C048800089018902890488889080908090452042402
+72D7:00804480290011FC2A044C0489E409241924292449E489240804080450282010
+72D8:00284424282410202BFE4A208A240A241A242A284A288A900B120A2A50462082
+72D9:000045F829081108290849F889080908190829F8490889080908090857FE2000
+72DA:0000440029FC11042904490489FC09041904290449FC89040800080053FE2000
+72DB:00204420284011FC290449048904090419FC2904490489040904090451FC2104
+72DC:00204420282010202BFE48208820082019FC2904490489040904090451FC2104
+72DD:00804480288011FE29024A048C200820192829244A248A220C22082050A02040
+72DE:00404420282013FE2A024C04880008001BFE2820482088200820082050A02040
+72DF:000045FE2800100029FC4904890409FC1904290449FC89040800080053FE2000
+72E0:000045F82908110829F84908890809F819442948493089200910094851862100
+72E1:00404420282013FE2800488889040A0218882888485088500820085050882306
+72E2:0080448028F811082B104CA0884008A019182A064DF889080908090851F82108
+72E3:009044902890129229944898889009981A942C9248908890091209125212240E
+72E4:00204420282013FE2820482089FC0800180029FC490489040904090451FC2104
+72E5:0080448029FC11042A0449E48924092419E42924492489E40904080450282010
+72E6:00008BF852A822A852A89FFE12A812A832A85FFE92A812A812A812A8A2084218
+72E7:0008443C29E0102028204BFE88200820182029FC490489040904090451FC2104
+72E8:00284424282410202BFE48208924092419242BA8492889100A120A2A54462082
+72E9:0040882053FE220254149010101013FE301051109090109010101010A0504020
+72EA:000045FE29021102297A49028902097A194A294A494A897A09020902510A2104
+72EB:00404440284413F4284848508FFE0840188029844A988CE008820882507E2000
+72EC:00204420282011FC292449248924092419FC29244820882808240BFE51022000
+72ED:00204420282011FC2820492488A408A818202BFE485088500888088851042202
+72EE:010089FE51102510557C9554155415543554555495541154125C1210A4104810
+72EF:0040884050A021105208940611F01000300057FC9040108011101208A7FC4204
+72F0:0080448029F0121028204BFC884408441FFE284448448BFC0844084051402080
+72F1:002094285224222450209E2012FC12203220525092D0135012881088A1044202
+72F2:00008810579020905110921012D81354325456929A92131212101210A2504620
+72F3:0040884050A02110520895F61040104037FC50409250124814441844A1404080
+72F4:02208A24522823B05220922212A2131E3040504093FC104010401040A7FE4000
+72F5:00904488288013FE28A048A888B008A418A828B04924892A09320A2252DE2400
+72F6:01844468283010C82B0448408BFE08A019202BFC4D2489240934092850202020
+72F7:000045F82908110829F848008BFC0A041A042BFC4A048A040BFC0A0452142208
+72F8:000045FC2924112429FC4924892409FC1820282049FC88200820082053FE2000
+72F9:00204420282013FE282048208924092419242AAA482088500850088851042202
+72FA:004044202BFE1000280049FC8800080019FC2800480089FC0904090451FC2104
+72FB:00404440288811042BFE4802888809441A4228F849888A500820085051882606
+72FC:0040442029FC1104290449FC8904090419FC2920492289140908094451822100
+72FD:000045FC2904110429FC4904890409FC1904290449FC88000888088451022202
+72FE:0104890E5130212057E09120113E116431A457249124112411241124A5444284
+72FF:0004440E2BB8108828884928892E0BA818A82AA84AA8893E09000A80547E2800
+7300:00108A10511021105454925212521090301051149604120812081210A22040C0
+7301:008489C457042114511491141FD41114331453949554150419041104A1144108
+7302:000045FC290411FC290449FC8800080019FC282048208BFE0820082050202020
+7303:0040884050A020A05110920815F61000308850489248115011101020A7FE4000
+7304:004044202BFE1000280049FC89040904190429FC482088A809240A2250A02040
+7305:009088905090279E509090901090139C309050909090179E10901090A0904090
+7306:044004407C7C04403C7804407C7C04400440012001107FFC028004401830E00E
+7307:00204420283E102029FE4922893809E01922291E490089780A480A4A548A2906
+7308:0040448029FC1124292449FC8924094419FC289049108BFE0810081050102010
+7309:008844882BFE1088288848F88888088818F8288848888BFE0800088851042202
+730A:00009040539C22045204939C1204120433FC50909090109010901112A212440E
+730B:01100108FFFE0280044008203018C00614281224FDFE10202850245044888106
+730C:081008140812FF1208102AFE2A102A105D1088281C282A284944884408840902
+730D:00408840504027FC5040924812481248355450E09150115012481444A8424040
+730E:00884488288813FE288848888FFE080019FC2904490489FC0904090451FC2104
+730F:0040882053FC2204520493FC120012FC328452FC928412FC14841484A8944088
+7310:02088908511027FC5040904013F8104030805FFE9120112012201222A422481E
+7311:000045FC2904110429FC4904890409FC1800291249D48918091009525192210E
+7312:00107E1442127E1242107EFE00107E1042107E2842287E28424442444A844502
+7313:00008BF85248224853F89248124813F8304057FC90E0115012481446A0404040
+7314:004044202BFE1202280049FC880008001BFE2820492889240A220C2250A02040
+7315:002097205120213E5142974414901410341057549152115211921110A5504220
+7316:01F84508290811F82908490889F808001BFC2A044A048BFC0A040A0453FC2204
+7317:0040884053FC20A05110920817FE100833C852489248124813C81008A0284010
+7318:00828882528223EA548A908A17FA108A33EA52AA92AA12AA12A212E2A08A4084
+7319:003C47C02A44112828004BF8884808481FFE284848488BF80848084051402080
+731A:00A04490288011FE29104B108DFC0910191029FC49108910091009FE51002100
+731B:000045FC2808101028204BFE882008A0184029FC495489540954095457FE2000
+731C:002044202BFE102029FC48208BFE080019FC290449FC890409FC090451142108
+731D:0080884057FC20005110911012A814443000504097FE104010401040A0404040
+731E:0040884050A02110520895F61040104037FC5040904013F812081208A3F84208
+731F:0000948452442248500093F81248124833F85248924813F8124A144AA4464802
+7320:00904490289013FC2A944A948A940BFC1A942A944A948FFE0800089051082204
+7321:00008BFE52522252525293FE1020104030FC51049288105010201040A1804600
+7322:0100891E511227D25112911E111217D23452545E945217D214521022A02A4044
+7323:000044882A5212222A524A8A8A020BFE188829444A7A88880950082050D82706
+7324:001045D428581252298C488889040AFA1820282049FE88200850088851042202
+7325:00008BF85248224853F89248124813F8300057FE9240124412281290A3084206
+7326:000097FC5404243465C4A44425F425546554A5F42444245425F42494A8065002
+7327:000045FC2904110429E4492489240BFE1A022AFA4A8A8A8A0AFA0A02520A2204
+7328:003C97C052442128500093FC1080108037FE510091F8128812501420A8D84306
+7329:00008BF8520823F8520893F81040124033FC5440904013F810401040A7FE4000
+732A:0040884453F42048505097FE1040108031F85308950811F811081108A1F84108
+732B:008844882BFE10882888480089FC09241924292449FC89240924092451FC2104
+732C:000097FC544427FC544497FC100013F8320853F8920813F812081208A2284210
+732D:010089F8520823F0501097FE10801144366850B09128166810A41122A6A04040
+732E:08100814FF92081208107F7E4110551049105D1049287F284928494445444282
+732F:004094445444244457FC90001FFE1040308057FC94A414A414A414A4A4A4440C
+7330:0080449E2BEA108A29CA488A8BEA089218A628204BFE88200850088851042602
+7331:00008BF85090206057FC90A4112812203460504097FC10E011501248AC464040
+7332:000045FC290411FC290449FC888009FE1A2229224952890209FA080250142008
+7333:000097BC54842484548497BC1400140037BC5424942417A814101428A4444482
+7334:010089785108220852FE96401A40127C3290521092FE121012281228A2444282
+7335:0080884053FC2204520493FC1200120033FC5354935415FC15541554A944410C
+7336:01084488289017FE289048908BFC0A941A942B0C4A048BFC0A040A0453FC2204
+7337:221012141412FF92141014FE7F1055105510632841287F28414441447F844102
+7338:00008BFC5224222453FC920012FC1284328452FC928412FC12841284A4FC4884
+7339:0040904057FC20E051509248144613F8320853F8920813F812081000A7FE4000
+733A:0008443C2BC010042A44492889FC0A2018202BFE482089240924092451FC2004
+733B:00068F78511021205244927813101224367E5A129210125412521292A2504620
+733C:002844242BFE102029FC492489FC092419FC292448088BFE0888084850482018
+733D:000047FE2A02100029FC490489FC090419FC284048208BFE0800088851042202
+733E:00008BF8520823C852489FFE180213F8320853F8920813F812081208A2284210
+733F:0040904053F8204057FE900013F81208320853F890A4112813101D48A1864100
+7340:0140965C54442444575C9444144417FC304057FC9208111010A01040A1B0460E
+7341:00008BFC524023F8524093F81240124033FC50049554155415541404A0284010
+7342:000045FE29101120297C4944897C0944197C29104910895409520A9252502420
+7343:08104914491249127F1000FE7F1000107F1041287F28412822440F44F0844102
+7344:02109114511227D250109790103E17903010579094A814A814A817C4A0444082
+7345:020094FE57102510557C955417541454345457549554155C15101710A5104010
+7346:0020444029FC110429FC490489FC08401BFE288849248A220DFC082050202020
+7347:0208891057FC2040504093F81040108037FC50A091281134123C1222A422481E
+7348:020889085110200057FC900011101208340453F892A812A812A812A8AFFE4000
+7349:0040884057FC204053F8908017FC1110326855C6904013F810E01158A6444040
+734A:0040884050A02190524897FE1A0813F8320853F8920013F815081508A9F84108
+734B:004045FC290411FC290449FC890409FC1820292448A8892408200BFE50202020
+734C:000045F8290811F8290849F888000BFC1A942BFC480089F80890086051982606
+734D:0080884053F8211050A097FE100013F8320853F8920813F811201122A2224C1E
+734E:0440247C24A83D5004287DFE248844488418012001107FFC028004401830E00E
+734F:008844882BFE1088280049FC890409FC190429FC48208BFE0850088851042202
+7350:002045FC288810502BFE480089FC090419FC290449FC88200BFE082050202020
+7351:01008902511C27D0511097D0155E17D4355457D4911417D411141124A1244144
+7352:08207F20083E7E440884FF2820103E284244872201107FFC028004401830E00E
+7353:01089108510827D0511E979411241FD4321453D492541248124814D4A4244842
+7354:0020444029FC110429FC490489FC0820192428A8492488200BFE082050202020
+7355:002046222BFE1090288849FE8B100D1019FE2910491089FE0910091051FE2100
+7356:002045FC282010882BFE488889FC090419FC290449FC890409FC088851042202
+7357:00009FFE58002A286948ABEE289228846AA0AAA82BE8288828942914A9245242
+7358:082049202A3E7F4849485DA86B104928414440200110FFFE02800C603018C006
+7359:0108890855482390511E97D4156415543554575495D4154815481554A46444C2
+735A:0088448829FC108828884BFE882009FC192429FC492489FC0800088851042202
+735B:00A094A452A820A057FC911010A017FC304053F8904017FC10A01110A2084C06
+735C:0020452428A813FE28A849248A220904190429DE4A448D54089E090452042404
+735D:000045FC284810302BFE485288940B5018202BFE4A528A8A0B760A5252722206
+735E:002045FC288810502BFE480089FC092419FC292449FC882009FC082053FE2000
+735F:0020442029FC10202BFE49088B9C090819882E3E48008BFE089008905112220E
+7360:0040904057FC20A05514920817FC1A0A33F8520893F8104012481444A9444080
+7361:00808B1C52042204539C9204120413FC310053FE940212AA12AA1402A0144008
+7362:00388BC0508027FE5110920815F6191031F0500097FC140415F41514A5F4440C
+7363:9090491402127F1249107FFE49107F100010FFA800287F28414441447F844102
+7364:0208890857C82010579E949417A4101437945094911411C817081114A5244242
+7365:01088A0857C8245057DE946417D41214311457D4921413C812481454A55448A2
+7366:008847FE288811FC290449FC890409FC188029FE4A228D52090209FA500A2004
+7367:00008BFC5294229453FC900017FE100033FC520493FC10A211141308AD444182
+7368:000045FC2954115429FC488089FE0A4219F22952495289F2084A0BFA500A2004
+7369:0020893C512027FE5010901413FE121033F05254925412D41368144AA8964322
+736A:004088A053182DF6500097FC155414E437FC500093F8120813F81208A3F84208
+736B:0040444028A011102A084DF6880008001BB82AA84AA88BB80910091052A82444
+736C:0200939E548A290A67D2A566254027D4655EA56427C42544255E2544A44448C4
+736D:021092105F9C22246248AFBE2AA22AAA6FAAA22A272A2AAA32882214A2224242
+736E:000097FC524824446FFEA44426EC255466ECA44426EC255426EC2444A4544408
+736F:003C97C050402FFE504097FC155414E437FC504097FC10401FFE1000A5244892
+7370:0080884057FC244452A892941474100033F852A89FFE100017FC1040A1404080
+7371:004044202BFE120229FC49488A5009FC1B0429FC490489FC090409FC50882104
+7372:008847FE28A8109029FE4B2089FC092019FC292049FE89000BFC08885070238E
+7373:000045FC282013FE2A2249AC882009AC18002BFE482089FC095409545154210C
+7374:011097FC511027FC540493F8100017FC3080514496A8117016A81126A6A04040
+7375:01248A485124200053FC92941264129433FC524893681248136A124AA2464362
+7376:03FC884051F8210851F8910817FE144232A4528A947A108011F81288A070438E
+7377:0040882057FE248855FC948817FE142035FC552495FC152415FC1400A4884904
+7378:77105514771200127F1049FE7F1049107F100028FFA800287F4441447F844102
+7379:0040887C504023FC524493F0124412FC32A852F892A812F8120015FCA5544BFE
+737A:0108890857CE2112512497DE1552155E37D2511E9392155E19401114A1124122
+737B:08100F1408127F1249105EFE49107F104A105F2851285B2855445F4455849502
+737C:00009EFE5254229262FEAE9228D628BA68D6AE9222D622BA22D62292AA9A4484
+737D:004097FC500023B852A893B8111017FC311057FC91101FFE11281310AD484186
+737E:01108FFE511027BC54A497BC1140112033FE522097FC1A2013FC1220A3FE4200
+737F:000097FE504022EE62AAABEA2AAE2AE86BAAACE6228825F422902060A1984606
+7380:000097FC54A424A467FCA21022A824BE6F68A23C24A82FBC20282AA8AABE4020
+7381:07BC94A457BC200057FE94001590149E37D4556495D4155415D41568ABC85054
+7382:024097E2525C2EF06AB0AEF0201E27D46554A7D4255427D421142FE4A1244144
+7383:03DE46522BDE12522BDE48A089FE0B201DFC292049FE880009FC08885070278E
+7384:020001000100FFFE02000420082010403F8011000200042008103FF810080008
+7385:101008100810FE101054105220524290FC104814100420084408FE10422000C0
+7386:101008080808FEFE1010101020204242FCFC4848101020204444FEFE42420000
+7387:020001007FFC020044442F88111022484FE400200100FFFE0100010001000100
+7388:10400840087EFE801100101C20E042A0FCA248A410A820904490FEA842C40082
+7389:00007FFC010001000100010001003FF8010001000120011001100100FFFE0000
+738A:000000007FFC010001200110011001003FF801000100010001000100FFFE0000
+738B:00007FFC010001000100010001003FF8010001000100010001000100FFFE0000
+738C:00400040FF4008400840084008407E4008400840084008420F42F042403E0000
+738D:1000100010003FFC21004100810001003FF801000100010001000100FFFE0000
+738E:00000000FEFE1010101010107C1010101010101010101E10F010401000500020
+738F:00400040FE40104011FC10447C4410441044108410841E84F104410402280410
+7390:00000020FD201120112011207D2011201120111011101E10E208440808041002
+7391:000001F0FD1011101110111011107D1011101110111011121D12E212420E0400
+7392:00000000FDFC1020102010207C2010201020102010201C20E020402003FE0000
+7393:00400040FE8010FC110412047C0411041084104410441E04F004400400280010
+7394:01040124FD241124112411247D2411241124112411241D24E124422402040404
+7395:000001FCFC201020102010207C2013FE1020102010201C20E020402000200020
+7396:00800080FC8010F8110811087D1012101020102010501C50E088410802040402
+7397:000001FCFC201020102010207C2013FE1020102010201C20E020402000A00040
+7398:00000000FDF810081008100810087DF811081100110011001D02E10240FE0000
+7399:00800080FC8010FE1080110011007DFC10041004100413F41C04E00440280010
+739A:000001F8FC101020104010807DFE10921092109211121D22E222444200940108
+739B:000003F8FC0810081108110811087DFE10021002100213FA1C02E00240140008
+739C:00100090FC901088108811247D2412221440104010881C84E10443FE01020000
+739D:00800080FC8011FC112012207C20102013FE102010201C20E020402000200020
+739E:00200020FC20102011FC10207C20102013FE102010501C50E088408801040202
+739F:00400020FC2013FE1088108810887C8810881050105010201C50E08841040602
+73A0:00200020FC501050108811047E0210881088108810881C88E088410801080208
+73A1:000001FEFE081088108810887D0811FE1018102810481E88F108420800280010
+73A2:00100090FC9010881108110412047DFA10881088108810881D08E10842280410
+73A3:00400020FE20100013FE10407C4010601050104810441E44F040404000400040
+73A4:00200020FC2013FE1020102010207DFC10201020102013FE1C20E02040200020
+73A5:000000FCFE841084108410FC7C841084108410FC10841E84F104410402140408
+73A6:00400040FC4013F8104810487C48104817FE104010A01CA0E110411002080406
+73A7:00400040FC801088110413FE7C0210901090109010901C90E1124112020E0400
+73A8:00000000FDFC1020102010207C20102011FC102010201C20E020402003FE0000
+73A9:00000000FDFC10001000100013FE7C9010901090109010901D12E112420E0400
+73AA:00200020FC5010501088114412227C20100011FC100410081C08E01040100020
+73AB:00400040FE40108010FE11087E8810881088105010501E20F050408801040202
+73AC:000001F8FD081108114811287D28110817FE110811081D08E108420802280410
+73AD:00100110FD101112111211147DD811101110111011101D12E1524192010E0000
+73AE:00400040FC4013FE1040104011FC7C40104013FE104210421C4AE04440400040
+73AF:00000000FDFE10101010102010207C6810A41122122210201C20E02040200020
+73B0:000001FCFD0411041124112411247D2411241154105010901C90E1124212040E
+73B1:00200020FE501050108811047E0210F81088108810A81E90F0824082007E0000
+73B2:00200020FC5010501088112412127C1011FC1004100810881C50E02040100010
+73B3:00500054FC5210921090119E11F07E9010901090109010901C8AE08A40860082
+73B4:00480148FD481148114813FE7D4811481148114811781D00E100410001FE0000
+73B5:00880088FE88108813FE10887C881088108810F810881E88F088408800F80088
+73B6:000001FCFC201020112410A47CA8102013FE102010201C20E020402000200020
+73B7:00200020FC201020103E102010207C2011FC1104110411041D04E10441FC0104
+73B8:00800080FDFC1104120415F411147D14111411F4110411281D12E10240FE0000
+73B9:00400020FE2011FE102010207C44108411F8101010201E44F08241FE00820000
+73BA:080008001FFC2104410809201110250802007FFC01003FF801200110FFFE0000
+73BB:00200020F82023FE222222242220FBFC2284228822483A50E220445004880906
+73BC:00900090F8902290229222D4FA9822902290229022903A92E3D24E12040E0000
+73BD:00800080FD0011FC120414047DE411241124112411E41D24E004400400280010
+73BE:000001FCFD241124112411FC7D241124112411FC11241C20E020402000200020
+73BF:000001FCFE441044104410447C941088110010FC10841E84F084408400FC0084
+73C0:00200020FC4011FC1104110411047D0411FC1104110411041D04E10441FC0104
+73C1:00000000FBFC2100210021F02110F9102190225022503A10E21242920312020E
+73C2:00000000FDFE1008100811E811287D281128112811E811281C08E00840280010
+73C3:00200020FC2011FC1124112411FC7D241124112413FE11041D04E10441140108
+73C4:00200020FD20112011FC112012207C20102011FC102010201C20E02043FE0000
+73C5:00200020FC2011FC112411247D2411FC1124112411241DFCE124402000200020
+73C6:00200020FC401088110413FE7C02100011FC110411041D04E104410401FC0104
+73C7:000001F8FD081108110811F87D081108110811F811081D08E108410807FE0000
+73C8:02000200FA00221E27D222522252FA522252225222523A52E452445E09521080
+73C9:000001FCFD041104110411FC11207D2011FE1120112011101D12E14A41860102
+73CA:0000F7BC24A424A424A424A4F4A42FFE24A424A424A434A4E4A445A408541088
+73CB:00000080FB1E2252225222522252FA52225222D2235A3A54E090409001100210
+73CC:00000040F8202028200820882090FA9422A222A224C23888E188428804780000
+73CD:00200020FC501088110412127C2010401188101010201C44E188401000600380
+73CE:00800080FC8010FE110211047E20102010A810A411241D22E222402000A00040
+73CF:00000000FDFC10201020102010207C2011FC1020102810241C24E02043FE0000
+73D0:00200020FC2011FC1020102010207DFE10201020104010481C84E1FE40820000
+73D1:00900088FC88108013FE10A010A07CA410A410A8112811321D22E262429E0400
+73D2:00200020FDFC102413FE10247DFC1020102011FC10201C20E3FE402000200020
+73D3:00400020FC2013FE100010887D0412021088108810501C50E020405000880306
+73D4:00400040F84027FE20802080F97C21082310251021FE3910E110411001500120
+73D5:00400040FDFC1044108410847D281210110813DE114A1D4AE14A4252035A04A4
+73D6:00200020FD2410A410A8102013FE7C9010901090109010921D12E112420E0400
+73D7:00200120FD2011FC112012207C2013FE1090109010901C90E11241120212040E
+73D8:00200040FDF81108114811287D2813FE1108114811281D28E108420802280410
+73D9:00880088FC88108813FE108810887C88108817FE100010881C84E10442020402
+73DA:000001FCFD041124112411247DFC112411241154114C1D8CE104410401FC0104
+73DB:00200020FDFE1040104010FC7C84118412FC108410841CFCE084408400940088
+73DC:01040084FC88100013FE10207C2011FC1020102013FE1C20E020402000200020
+73DD:000003DEF84220422252214AF94A204220C6214A22523842E0424042014A0084
+73DE:00800080F8F82108231024A02040F8A02118220625F821083908E10801F80108
+73DF:000007F8F408240827F824882488F4E82528252826A8244A344AC88A09061202
+73E0:00200120FD2011FC112012207C2013FE107010A810A81D24E124422200200020
+73E1:0000FEFE101010107C7C10101010FEFE0100010001000280044008203018C006
+73E2:000001F8FD08110811F811087D0811F81144114811301D20E110414801860100
+73E3:00800080FDFC1104120411E47D24112411E4112411241DE4E104400400280010
+73E4:00800080FC8011FC112012207C20102017FE102011241D24E124412401FC0004
+73E5:000003FEFD081108110811F87D08110811F8110811081D1EE3E8400800080008
+73E6:00200020FC4011FE110211027D7A114A114A114A114A1D7AE1024102010A0104
+73E7:00900090F8902292219420982090F99822942492209020903912E1120212040E
+73E8:00200020FC5010881104120211FC7C00100011FC110411041D04E10441FC0104
+73E9:00800080F93C220024802080217EFB082508210821083908E108410801280110
+73EA:00200020FDFC10201020102013FE7C001020102011FC10201C20E02043FE0000
+73EB:00400020FC2013FE104010887D0413FE1092109010901C90E1124112020E0400
+73EC:00280024F824202023FE22202224FA24222423A822283A10E212442A04460882
+73ED:00800080F8BE2288228822882288FABE2288248820883908E108423E04000800
+73EE:000007FCF404240425F424442444F5F425542554255425543574C44604460842
+73EF:00400040FC4411F41048105013FE7C4010801184129810E01C82E082407E0000
+73F0:00200124FCA410A410A8102011FC7C041004100411FC10041C04E00441FC0004
+73F1:00400024FA242108210820102040F84023FE208821083990E060405001880604
+73F2:000003FEFA022444204023FC2080F8A0212021FC20203820E3FE402000200020
+73F3:02040104F9082FE8229422A42288FA8A2292212421043908E2904240043E0800
+73F4:001000D8FB942094209023FEF8902094209420D823983890E0AA40CA02860102
+73F5:000001FCFD041104110411FC7C00100013FE102010201DFCE020402003FE0000
+73F6:01080088FC9011FC1024102411FC7D20112011FE106210A21D2AE22444200020
+73F7:00100018FBD42014201027FE2010F890209022D022903A90E28A42EA07060202
+73F8:000003FEF840204021FC20842084FBFE2000200021FC3904E104410401FC0104
+73F9:00280024F824202023FE22202224FA2423A422A822A83A90E29245AA04460882
+73FA:000001FCFC44104413FE10447C4411FC1080108011FC1E84E484408400FC0084
+73FB:00800080FCFE110012FC10847CA4109413FE108411241D14E1FE400400280010
+73FC:000001FCFD04110411FC11047D0411FC1104110411FC1C00E088408401020202
+73FD:00000006FBB8208820882108213EFB88208822882288393EE1004280047E0800
+73FE:000001FCFD04110411FC110411047DFC1104110411FC10501C90E0924112020E
+73FF:000001FCFD041104110411FC7C2010201120113C11201D20E2A04260043E0800
+7400:00200020FC5010881144122210F87C081010102011FC11041D04E10441FC0104
+7401:01000100FDFE1200140011FE7C2210241120113C11201D20E12042A0047E0800
+7402:00200010FDFE1000100010FC10007C0010FC1000100010FC1C84E08440FC0084
+7403:00280024FC24102013FE102011207CB210B4106810A811241E22E02040A00040
+7404:000000FCFC84108410FC10007DFE1102110211FE11021D02E1FE4102010A0104
+7405:00400020FDFC1104110411FC11047D0411FC1120112211141D08E14441820100
+7406:000001FCFD24112411FC112411247DFC1020102011FC10201C20E02043FE0000
+7407:001C01E0FC20102013FE10A87D24122211F8108810901CBEE102410202140408
+7408:0008003CFDC01004114410A810007DF81010102013FE10201C20E02040A00040
+7409:00400020FBFC20402090210823FCF8042150215021503950E25042520452080E
+740A:000007DEF89224922494249427D8F8942192219222923A9AE494489002900110
+740B:01840068F83020C823042040FBFE20A0212023FC25243924E134412800200020
+740C:00200124FD24112411FC10207C5010881144122210201DF8E008401000100020
+740D:004200E2FB82208A208A208A27EAF88A218A21CA22AA3A82E4824082008A0084
+740E:00240224FD24117E102410247C24137E1124112411241D24E144410002FE0400
+740F:00200420FA2022FE204020502E90FAFE2210221023FE3A10E210451008FE0000
+7410:00200124FCA410A8102011FC11047D2411241124112411241C50E08841040202
+7411:00200124FCA410A8102011FC7D04110411FC110411041DFCE104410401140108
+7412:00400040FCFC1088115010207CD8132610F8102010F81C20E3FE402000200020
+7413:00400020FBFE2202240421F82000F80023FE209020903890E1124112020E0400
+7414:00400020FBFE22022404200023FEF82020202120213C3920E2A04260043E0800
+7415:00400080FDFC1124112411FC11247D4411FC1090111013FE1C10E01040100010
+7416:00480044FC5E11E0102810127C6A11961048105E11E01C24E0284012006A0186
+7417:00400020FDFE1000108810887D5412221000102013FE1C20E020402000200020
+7418:001C03E0FA2023FE22202292230AFA0621FC2104210439FCE104410401FC0104
+7419:00140012F81027FE20102010FBD222522252225423D43808E0EA471A02260042
+741A:000003FCFA04220423FC22202220FBFE2220222022FC3A84E284448404FC0884
+741B:000007FCFC0424A4211022082040F84027FC204020E03950E2484C4600400040
+741C:00400040F84027FC204022482248FA48255420E021503950E248444408420040
+741D:01FC0104FD0411FC110411047DFC1040102013FE10881C88E050402000D80706
+741E:7CFC448444FC7C8444FC44847C84011402087FFC01003FF801200110FFFE0000
+741F:00A00090FC9011FE111013107DFE1110111011FE11101D10E11041FE01000100
+7420:00500050FC5011FC1154115411547DFC11541154115413FE1C00E08841040202
+7421:01000100F9DC21142114211427D4F8142114211425883D48E948411405140222
+7422:000003FEF8402080214422242068FAB0213022A8206838A4E122422000A00040
+7423:00400020F9FC2000210820902000FBFE2000200021FC3904E104410401FC0104
+7424:00800080FDF81108121015FC7C24102413FE102410241DFCE024402000A00040
+7425:00400040F87C204023FC22442270FBC02244223C22003AF0E49044920912120E
+7426:00400040FBFC20A02110220827FEF80823C8224822483A48E3C8400800280010
+7427:00007FFC04403C7820083C780440FFFE00007FFC01003FF801200110FFFE0000
+7428:000001FCFD04110411FC110411047DFC1000111211D411181D10E1524192010E
+7429:00FC0084FC8410FC108410847CFC100011FE110211021DFEE102410201FE0102
+742A:01080108FBFC2108210821F82108F90821F8210821083BFEE000409001080204
+742B:00200020FDFC104010F8104013FE7C881124122210F810201DFCE02040200020
+742C:00400020FBFE22022504210021DEFA5222522352249A3894E11041120212040E
+742D:000001F8FC08100811F810087C0813FE1020122211741CA8E124422200A00040
+742E:00400020FBFE2202200021FC2000F80023FE202021283924E222442200A00040
+742F:00200010FDFE1102120410F87C88108810F8108010801CFCE084408400FC0084
+7430:00200122F9222224205020882304F82220202124212422283850E08801040602
+7431:000001FCFD241124117411247DFC11041174115411541D74E104420402140408
+7432:00900090F890239E209020902090FB9C209020902090239E3890E09000900090
+7433:01100110F910211027BC21102110FB3823B8255425543992E110411001100110
+7434:0000FEFE101010107C7C10101010FEFE010006C01A30E10E1FE0004000800100
+7435:0000FEFE101010107C7C10101010FEFE0000208020843E9820E020842684387C
+7436:0000FEFE101010107C7C10101010FEFE00003FF8210821083FF8200220021FFE
+7437:01080088F89023FC2040204021F8F840204027FE20A038A0E12041220222041E
+7438:00200020FC3E102011FC110411FC7D0411FC1124102013FE1C20E02040200020
+7439:0000FEFE101010107C7C10101010FEFE010001007FFC054009203118C1060100
+743A:02100110F910247C221022102010F97E21102210262022243A42E2FE02420000
+743B:00200020FC5010881104120210F87C20102011FC102011241CA4E0A843FE0000
+743C:00400020FBFE2000200021FCF904210421FC202021283924E222442200A00040
+743D:00200022FDFA1024102813FE7C20104010FC118412841CFCE084408400FC0084
+743E:03F80248FA4823F82248224823F8F8A021102208251621103910E11002100410
+743F:000003FEFA22202023FE2020F9FC212421FC212421FC3820E3FE402000200020
+7440:0004001EFBE0202021FC21242124F9FC202023FE22223A2AE2FA4202020A0204
+7441:000001FEFD02117A1102117A11027C0010FC108410FC10841CFCE08440FC0084
+7442:000001FEFD12111211FE11007D7E11421142117E11421D7EE2424242047E0842
+7443:00400040FBFC204021F8208023FCF910220825F621103910E1F04110011001F0
+7444:00400020FBFE2202240421FC2000F9FC210421FC210439FCE104400003FE0000
+7445:000001FCFD04110411FC11047D0411FC100013FE10201D20E13C412002A0047E
+7446:000001FCFD0411FC110411FC10207D2011FE1220102011FC1C20E02043FE0000
+7447:002001FEFC2010FC102011FE7C0010FC10A4109411FE1CA4E11441FE00040018
+7448:000001FCFC48103013FE10527C9411101230102013FE1C70E0A8412406220020
+7449:000001FCFD0411FC111011FE7D10114A1186100011FC1D04E1FC410401FC0104
+744A:0008000CF80A23FE2208220822E8FA0A220A22EC22AC3AA8E2EA421A02260442
+744B:00400040FDFC108413FE10007DFC110411FC102013FE1C20E22043FE00200020
+744C:000003FEFC20104011FC115411547D541154112C102013FE1C50E08841040202
+744D:00800080F8F82108221025FCF9042154218C212420203BFEE050408801040602
+744E:01100112FDD41118115211927D2E104011FC110411041DFCE104410401FC0104
+744F:00400020FBFE22022088210421FCF890211023FE20503890E110461000500020
+7450:01080088F89027FE200023C42254FA5423D4225422543BD4E2544244025402C8
+7451:008000FCFD0411F8100813FE10407CA213341058109413341C52E09043500020
+7452:000000FCFC8410FC108410FC10007DFE108010FE112A124A1C92E12240540088
+7453:00200020FBFE202021FC2124F9AC2174212421FC20203870E0A8412402220020
+7454:00400080FDFC110411FC11047DFC1020103213B410A81D28E124422404A20040
+7455:000003DEFA422242224223DE2200FA3E23D2221222143BD4E208421402240242
+7456:00800338FA28222823A822462200FA7C23A4222422283BA8E610422802440282
+7457:003C07C0FA442128200023FC2080F88027FE210021F83A88E250442008D80306
+7458:00000FDEF4922492249427942498F49427922492249225DA3E94C09000900090
+7459:00920124FA482124209220402080FBFE2202228A22523A22E252428A03FE0202
+745A:0100013CF92427E42124213C2124FBA422A422BC22A43AA4E3A4404400540088
+745B:00880088FBFE208820A8202021FCF9242124212423FE3820E050408801040202
+745C:004000A0F910220825F6200023C4FA54225423D422543A54E3D44244025402C8
+745D:00200040FDFC110411FC11047DFC100013FE102010201DFCE020402003FE0000
+745E:00200222FA22222223FE200027FEF820204023FE22523A52E252425202520206
+745F:0000FEFE101010107C7C10101010FEFE011008A0484449828E121810E7F00000
+7460:004003BEFA122292225222AA2324F84023FE222222223BFEE222422203FE0202
+7461:0100027EFB88228822BE22AA23AAFA2A222A23AA22AA3AAEE288438802880008
+7462:00400020FBFE2202249421082264F8902108220425FA3908E108410801F80108
+7463:00200124FCA8102011FC11047D0411FC110411FC11041D04E1FC400000880104
+7464:00400080FDFC1248113010C013007DFC1220102013FE10201D24E12441FC0004
+7465:000001F8FD08110811F811087D0811F8100013FC12941E94E294429407FE0000
+7466:00400080FDFC1104110411FC7D0011FE110011FE10021EAAE2AA440200140008
+7467:00200020FBFE202021FC204023FEF888213422E2202039FCE07040AC03220020
+7468:000003FCF89022942198209027FEF80021F82108210821F83908E10801F80108
+7469:08202AA44D28145022887FFE400280043FFC010001001FF80100012001107FFE
+746A:000001FEFD2011FC112011FC7D20112011FE100212AA1EAAE2AA420200140008
+746B:001E01E0FC221112109410807C2011CE1102110211CE1D02E102410201FE0102
+746C:204017FE8090490813FCE1502252244E00007FFC01003FF801200110FFFE0000
+746D:00200010FBFE222022FC222423FEFA2422FC222022FC3A84E284448404FC0884
+746E:000003FEF850205023FE22522252FBFE2020202023FE3870E0A8412406220020
+746F:0100009EFBD22252225423D42258FA5423D2221222923A5AE2D4435002100010
+7470:00200040FBFC2224222423FC2224FA4423FC204020A838B4E13C41220222041E
+7471:00200020FBFE202021FC210421FCF90421FC210421FC3904E3FE408801040202
+7472:00400040F8A02190224827FEFA0823F8220823F822003BF8E508450809F80108
+7473:00840044FC4811FE102010FC7C2011FE1040108010FE1D10E210441001FE0000
+7474:1000FE7810487C480048FE8682007CFC0044FE4410287C2810101E28F0444182
+7475:000001FCFCA41088105010207CD81326102011FC11241D24E1FC402203FE0002
+7476:0008003CFBC0200422442128F9FC2220202023FE20203924E124412401FC0004
+7477:000E03F0F8442224210823FE2242F84023FE208020FC3944E128421004680186
+7478:00400020FBFE2202241421E02100F90021FC2110211027FE3800E09001080204
+7479:00880088FBFE208820A820502088F9742222202021FC3820E0A8412402A20040
+747A:00200124FCA813FE120210F87C88108810F8102011FC1D24E124413401280020
+747B:000001FCFD2413FE112411FC7C0011FC110411FC11041DFCE10441FC00880104
+747C:002003FEFC2011FC112411FC11247DFC102213FE100813FE1D08E08840280010
+747D:01240124FA2424242954214AFA9226102A102250225C3A50E25042B0029E0300
+747E:00880088FBFE208820F8202021FCF92421FC202023FE3820E1FC402003FE0000
+747F:00007F7848485F4C64805F7844484A4851307F4C00007FFC01003FF80120FFFE
+7480:00200222FBFE2090208821FE2310FD1021FE2110211039FEE110411001FE0100
+7481:00400080FBFC224422F4231422A4FA4422A423FC20403824E522450A090800F8
+7482:00880088FBFE208820F8208820F8F88823FE208821243AFAE020402003FE0000
+7483:00400020FBFE2000215421242154F9FC202023FE22423A92E2FA420A02020206
+7484:00400020FDFC1088105013FE7C0011FC110411FC11041DFCE09040920112060E
+7485:01240248FD24100011FC11247DFC112411FC102013FE1C70E0A8412406220020
+7486:000007BCF88424A4229424A42050F988262620C023103864E388403000C00700
+7487:02100110F91027BE2240220023BEFA8A228822A822AE3AA8E4A845A8085E1080
+7488:01080108F90827D0211E2794F9242FD4221423D422543A48E24844D404240842
+7489:00100410FAFE221020FE209226FEFA9222FE221022FE3A10E210451008FE0000
+748A:00880088FBFE2088208820F82020FBFE2222233222AA3B76E2224222022A0224
+748B:002001FCFC88105013FE10007DFC110411FC110411FC1C20E3FE402000200020
+748C:00400020FBFE2202200021FC2020F9FC212421FC212439FCE000408801040202
+748D:008803FEF888200021FC20A820A8FBFE20A820A821FC3820E3FE402000200020
+748E:00000FBEF8A22AAA2AAA2AAA2514F8A220802FFE21103A10E3A0406001980E04
+748F:010001F8FA0823F020102FFE2080FC8824EA274A244C3DE8E44A464A04A60110
+7490:00100790FCBC24A424C427A82110F928214625C0253C3D24E52445A40E3C0024
+7491:00800080F9FE23542554215423FEF9542154215427FE20003954E12A022A0000
+7492:002007A4F8A822922114220825F4F80223F8220822083BF8E20841100FFE0000
+7493:008803FEFC88101C11E0102013FE7CA81124122211F810881C9EE082410A0204
+7494:01040088F80023FE222222AA2272FA2223FE200021FC3904E1FC410401FC0104
+7495:000003FCF80423FC200423FC2000FBBC212427BC20083BFEE108408800A80010
+7496:0200017EF840247C224420FCF940267E2220202023FE3870E0A8412402220020
+7497:21F8110841F821080BFE090073FC14A41154128800007FFC01003FF80120FFFE
+7498:00200124F8A823FE20A821242222F904210421DE22442554389EE10402040404
+7499:00200020FBFE2050228A2104FBFE250421FC210421FC3820E124422204A20040
+749A:000003FCF848203023FE20522094FB50202023FE22523A8AE376425202720206
+749B:004003F8F84827FE204823F8F8402554275C244427FC3C44E75C455405540844
+749C:00880088FDFC1088108813FE10207DFC112411FC112411FC1C00E08841040202
+749D:002001FCFD2411FC102013FE7C0011FC110411FC11041DFCE10441FC00880104
+749E:00500252F954205023FE20882050FBFE202021FC20203BFEE050408801040602
+749F:000001FCFD0411FC110411FC7C2013FE100011FC11041DFCE020412402220060
+74A0:003C03E0FD2410A813FE10A87D24120211FC112411241DFCE124412401FC0104
+74A1:00280424FA7E22C82148207E2648FA48227E224822483A7EE240450008FE0000
+74A2:000003FEF85023DE2252225223DEF85023FE222222223BFEE222422203FE0202
+74A3:01240124FAAA23AE212422AA23AEF92427FE211021143914E28A424A02160422
+74A4:00200020FBFE202021FC2124F9FC212421FC202223FE3842E02442A2028A0478
+74A5:02880288F7E82290241E27E42454F8542754255425543748E548405402940122
+74A6:003C03C0F8442224210827FE2442FAA4228A247A208038F8E10842900060079E
+74A7:3E1022FE3E4420287EFEA2103EFC221000007FFC01003FF801200110FFFE0000
+74A8:008000DCFA8423D424482A942324FC402248215027FC38E0E15042480C460040
+74A9:0040007CF84023FE2242227823C4FA3C220023FE22403BA4E25845B4045209B0
+74AA:01FC0104F90421FC200023DE2252FA5223DE202023FE3870E0A8412406220020
+74AB:00200124FCA813FE120210F810887C8810F8100011FC11241DFCE12441FC0104
+74AC:01080208F7C8245027DE246427D4F214211427D4221423C83248C454055408A2
+74AD:000004FEFA92227C2010207C2654FA7C2254227C221022FE3A10E51008FE0000
+74AE:002007FEF80023FE220222FA228AFBFE200021FC210439FCE10441FC000007FE
+74AF:00200050FC881174120211FC7D2411AC112411FC10001CF8E08840F8008800F8
+74B0:000003FCFA94229423FC2000FBFE200023FC220423FC38A2E11443080D440182
+74B1:000007BEF108210827BE21082108F7BE20002080204425123522C9C003040CFC
+74B2:00880448FA5020FC202020502694FA382250229822343A54E290422005FE0800
+74B3:00A000FCFD2013FE10A811247E2211FC110411FC11041DFCE10441FC00880104
+74B4:00880088FBDE208821DC22AA2488F80023FE20222120393CE12042A0047E0800
+74B5:0140024CFA642244234C226422A4FBAC22A422A427FE3800E110410802040404
+74B6:004003F8F84827FE204823F8F84027FE200022A424523BF8E2A842A80FFE0000
+74B7:014807C8F90827D0255E27E4FD5427D42554211427D43A08E3C84254055408A2
+74B8:00400020FBFE220221FC2148FA5021FC230421FC210439FCE10441FC00880104
+74B9:002003FEFC2011FC100013FE10027DFC102013FE100013FE1C04E3BE42A4038C
+74BA:2FEC48244BA4682C4BA46AAC4BA44824FFFE80027FFC01003FF801200110FFFE
+74BB:03DE0042FA52214A2252202023FEF8882088215422223820E7FE402000200020
+74BC:000803E8FA8823EE222823F42282FBE2200021FC21543954E154415407FE0000
+74BD:7FFC21087FFCB55A29283558210835582928355800007FFC01003FF80120FFFE
+74BE:00400020FBFE2088205227AC22AAFAA825AC2000210439FCE10441FC01040204
+74BF:0040007CF84027FE240223FCFA4824A4211023F8260C3BFAE20843F8020803F8
+74C0:000001FCFC2013FE122211AC7C2011AC100013FE10201DFCE15441540154010C
+74C1:008803FEFCA8109011FE13207DFC112011FC112011FE1D00E3FC40880070038E
+74C2:008803FEFC88102011FC102013FE7C40108811FC100011FC1D54E15447FE0000
+74C3:03F80248FA4823F822482248FBF820002FBE2AAA2AAA3FBEEAAA4AAA0FBE08A2
+74C4:002003FEFC2011FC100013FE7E5213FE110411FC11041DFCE10441FC00880104
+74C5:044404E4F8A82AAA2EEE24A42AAAFEEE224220402FFE20E03150C2480C460040
+74C6:0042039CFA1023DE229422942420FBFC220423FC22043BFCE20443FC01080204
+74C7:03FC0040F9F8210821F8210827FEFC4222A4228A247A3880E1F842880070038E
+74C8:00500190FC9E13EA108A11D2128A7CA410501088132610A81C70E0A841240060
+74C9:008801DCFC8813DE108811547E2211FC110411FC11041DFCE10441FC00880104
+74CA:010001F8FA0827FE22622292F9FC210421FC210421FC3880E1F842880070038E
+74CB:00200010F4FE2244222820FE2092F6FE229222BA22AA22BA3286C50008FE0000
+74CC:00400020FDFE100011FC115411FC7C201122108C112210541CC8E14442520060
+74CD:0008073EF590255E2564265E2500F5DE2552255E2552265E3452C45604A0051E
+74CE:01080108F7CE2112212427DE2552F55E27D2211E2392255E3940C11401120122
+74CF:01100090FBDE2010225E2182FBDE201023DE225023DE3A50E3DE4250025202CE
+74D0:0040007CF84023FC224423F0FA4422FC22A822F822A83AF8E20045FC05540BFE
+74D1:000007FEF4442598248827DE2488F5DC26AA248824202520353CC920092017FE
+74D2:01040514F7DE29242FFF210CF3552DA723FC220422243A24E24400B001080604
+74D3:03DE0252FBDE225223DE222222FAFA2222FA22AA22FA3AAAE2FA427202AA0226
+74D4:03DE0252FBDE225223DE225223DEF98C2252204027FE3888E190406000D80304
+74D5:F7FC124817FCFC4686ECF55416EC155456EC244400007FFC01003FF80120FFFE
+74D6:002003FEF80021DC215421DC2088FBFE208823FE208827FE3894E18806A400C2
+74D7:022203FEF89021FE231025FE2110F9FE211021FE210023FE3A8AE37602520276
+74D8:008803FEF88823DE225223DE20A0F89021FE212023FC3D20E1FC412001FE0100
+74D9:004003FCF84021F8200023FCF80421F0204023FC20083BBCE2A8439805240892
+74DA:052807BEF94827BE231825AAF94623FC220423FC22043BFCE20443FC01080204
+74DB:010801ECF10A2FEA29282BC8293EFFE829482BE82A282B683AA8CBF40AB412A2
+74DC:001000F81F2012201220122012201220122012101290225022A8432842048002
+74DD:02200720383C2A442A842A242A142A142A0429042928289028404A304D0E8900
+74DE:0210071038502A7C2A902B102AFE2A102A2829242942288228404A304D0E8900
+74DF:02400740387C2A842B742A542A542A742A482942294228BE28404A304D0E8900
+74E0:1008101CFEE828A844A882A87CA800A8FEA820A440A47CA404A2052829341224
+74E1:1008101C7CE810A810A8FEA844A828A87CA810A410A4FEA410A2112811341224
+74E2:0008FE1C28E8FEA8AAA8AAA8FEA800A87CA800A4FEA410A454A2932851342224
+74E3:409021C82708FD3E058055542548FD7E25482548755C25282508494849A89128
+74E4:1008FE1C00E8EEA8AAA8EEA844A8FEA844A8FEA444A4FEA450A2CB2865344224
+74E5:06FE38202C542AB42A5829B454545D9290307EFC52A47EFC10201424FEFE0202
+74E6:0000FFFE04000400040007E008200A20092009200820102213221C22101E0000
+74E7:0020FC202020202020203DFC2420242054204C20442044205422640243FE0000
+74E8:000001FC7C801080108010F8108810881148112811281D08E108414A018A0106
+74E9:0010FC3820E0202020203C2025FC242054204C20442044205422640243FE0000
+74EA:0004FC0E20F0208020803CFC248424C454A84C90452845445602640243FE0000
+74EB:044008203018DFE604200420082010A020407FFC08000FE0092010A41624181C
+74EC:200011FC0080FE80208020F83C88248825482528252825084508554A898A0106
+74ED:000011FC10801080FE8092F81088108829482928292829084B084D4A898A0106
+74EE:0440082010102208C44608201FF0000000007FFC08000FE0092010A41624181C
+74EF:00007EFC40404440644054784848484854A854986488408840AA7ECA008A0006
+74F0:0010FC502048208820843D0226F8244854484C88448845285612640243FE0000
+74F1:0020FC7021C0204020703DC02440247857C04C4844484448543A640243FE0000
+74F2:0020FC2021FE202021243D24252425FC54204C244424441C5402640243FE0000
+74F3:100011FC10801080FE8010F8108810887D4845284528450845087D4A458A0106
+74F4:100010FC284024404240917808480848FEA802984488288810AA08CA088A0006
+74F5:100011FC208028804480FEF8428800887D4845284528450845087D4A458A0106
+74F6:420024FC00407E402440247824482448FEA824982488248824AA44CA448A8406
+74F7:0100410021FC0A441448E0A02110260C00007FFC08000FE0092010A41624181C
+74F8:0000FDFC2020204020F83C88248824F854884C8844F844885402640243FE0000
+74F9:00007EFC424042407E4000787E48424842A87E98428842887EAA42CA4A8A4406
+74FA:00003EFC204020403C40207820483C4820A82098FE88208824AA42CAFE8A4206
+74FB:420024FC1840244052401078FF48204828A87E98AA882A882AAA2ECA088A0806
+74FC:0000FDFC2124212421FC3D24252425FC54204DFC4420442055FE640243FE0000
+74FD:0100111009207FFE40029FF410101FF000007FFC08000FE0092010A41624181C
+74FE:0C0071FC1080FE80388054F8928800881148FD28252845082908114A298AC506
+74FF:100008FC7F40004022401478FF48004800A83E982288228822AA3ECA228A0006
+7500:02000F7C78200820FFA02A382A28FFA82A582A48FFC80848085A0F6AF04A4006
+7501:220022FC4440EE404440447844484448EFA844984488448844AA44CA448A8406
+7502:1000087C7E20422042207E38422840287F58554855487F48D55A556A554A4306
+7503:0620382008A47EA819202C504A88090400007FFC08000FE0092010A41624181C
+7504:0000FEFC28402840FE40AA78AA48FE4810A81098FE88108810AA1ECAF08A4006
+7505:0000FDFE2100217C21543D7C2554257C55104D7C451046FE5402640243FE0000
+7506:082004407FFC12483CF0082014503EF800007FFC08000FE0092010A41624181C
+7507:08202AA42CA84920145022887FFE400280047FFC08000FE0092010A41624181C
+7508:080010FC7E4042407E4042787E4842487EA80898FF8818882CAA4ACA888A0806
+7509:2200147CFFA0142014207F381528FFA815587F4814483648555A94EA144A1406
+750A:08007F7C4920FFA049207F3808287F2849587F481048FF48215A726A0C4AF306
+750B:200010FCFE4044402840FE7882489248FEA89298BA88AA88AAAABACA828A8606
+750C:0000FEFC80408040BC40A478A448BC4880A8EE98AA88AA88EEAA80CAFE8A0006
+750D:0820FFFE08203FF824483FF800007FFE4002BFF408000FE0092010A41624181C
+750E:100010FCFE4010407C4054787C4854487CA81298FE880888FEAA48CA288A1806
+750F:08047F0808103E6400083E1022643E0814107F6000007FFC08000FE011241C9C
+7510:0800497C2A200820FF202A38492888284258774892485A482F5A226A424A8206
+7511:440024FC2840FE409240D678BA489248FEA800987C8844887CAA44CA7C8A4406
+7512:2000207C7FA0D52055205538FFA8552855585548FFC800486A5A556A954A0006
+7513:00407C2045FC44887C5043FE7C20A5FC24203C2000007FFC08000FE011241C9C
+7514:20003E7C4220FFA0512064B87FA840285F5840485F4840485F5A516A5F4A9106
+7515:0100FFFE104824FE799010FC22907CFC089030FEC0807FFC08000FE011241C9C
+7516:3EF822883EF822883EF822883EF8145022887FFC08000FE0092010A41624181C
+7517:08000F7C08207F2049205E3849287F284A585F4851485B48555A5F6A554A9506
+7518:08100810081008107FFE08100810081008100FF008100810081008100FF00810
+7519:005000480040FFFE004022402240FF40224022203E20221222123E0A22060002
+751A:082008207FFC082008200FE0082008200FE008200820FFFE1220141010001FF8
+751B:4404441E44F04410FE1044FE4410441044107CFE44824482448244827CFE4482
+751C:08881C887088108811FEFC88108810887C8844F84488448844887C8844F80088
+751D:08480F4808487F4849FE4E4878484948477840485E485248527A520291FE2000
+751E:0100111009207FFE40029FF410101FF000001010FFFE10101FF010101FF01010
+751F:01001100110011003FFC21004100810001003FF80100010001000100FFFE0000
+7520:002000207D20452045FC452046207C20442045FC442044207C20442003FE0000
+7521:08100810489048907EFE48908910081008107EFE0810081008100E10F1FE4000
+7522:010000803FFE022001C002203FFE2080248027FC2880308027F8408040809FFE
+7523:010000803FFE041002203FFE2080248027FC2880308027F8408040809FFE0000
+7524:00100010FF50087C105030904A109C7C28104C109A1029FE48808860281E1000
+7525:11FC1124512451FC7D24512491FC10407C4013FE104210821C82E10242140408
+7526:0010FF101050107CFE5092909210FE7C92109210FE1090FE500020005FFE8000
+7527:101050507E7E90907C7C10101EFEE0001FF010101FF010101FF0101010501020
+7528:00003FF82108210821083FF82108210821083FF8210821082108410841288010
+7529:00003FF82108210821083FF82108210821083FF82108210821284112410280FE
+752A:040008003FF82108210821083FF82108210821083FF821082108410841288010
+752B:01200110FFFE010001003FF8210821083FF8210821083FF82108210821282010
+752C:00003FF00020064001803FF8210821083FF8210821083FF82108210821282010
+752D:7FFC01000770190CE10200003FF8210821083FF8210821083FF8410841288110
+752E:08001FF822484488095012203FF8210821083FF8210821083FF8410841288110
+752F:020001007FFE41029494142823E800003FF821083FF821083FF8210821282010
+7530:00003FF8210821082108210821083FF8210821082108210821083FF820080000
+7531:01000100010001003FF821082108210821083FF821082108210821083FF82008
+7532:00003FF82108210821083FF82108210821083FF8210801000100010001000100
+7533:0100010001003FF82108210821083FF82108210821083FF82108010001000100
+7534:01000100010001003FF821082108210821083FF820082008200820083FF82008
+7535:0100010001003FF82108210821083FF82108210821083FF8210A0102010200FE
+7536:0200020004003FF821082108210821083FF821082108210821083FF820080000
+7537:3FF8210821083FF8210821083FF8000001007FFC010401040204040418146008
+7538:0800080010001FF820084008BF88248824883F88248824883F88208800500020
+7539:010001003FF821083FF821083FF80000FFFE080010001FF00010001000A00040
+753A:000000007DFE54105410541054107C1054105410541054107C10441000500020
+753B:0000FFFE000000004FE4492449244FE44924492449244FE4400440047FFC0004
+753C:00003FF8210821083FF8210821083FF800000000FFFE01000100010005000200
+753D:008200927C9254925492549254927C9254925492549254927C92451201020202
+753E:0888111022201110088800003FF82108210821083FF82108210821083FF82008
+753F:002000107C10540055FE548054807C8054805480548054807C80448000FC0000
+7540:00001FF0111011101FF0111011101FF000000000FFFE08200820082010202020
+7541:010001001FF0111011101FF0111011101FF00000FFFE08200820082010202020
+7542:008000807C8054F85508550855107E1054205420545054507C88450802040402
+7543:104010401040FE7C92849284FF0492449224FE24920410041004100410281010
+7544:0408420821101110102000403FF82108210821083FF82108210821083FF82008
+7545:100011F810107C20544054807DFC5454545454947D2454241044108411281010
+7546:100008080808FF88000800087F104910491049207F244924494249FE7F424102
+7547:004000407C8054FC5504560454847C4454445414542454447D84440400280010
+7548:0008001C7DE05500550055FC55447D4455445528552855107D10462802440482
+7549:002000207C20542055FC542054207C2057FE5420545054507C88448801040202
+754A:008800887C88548855FE548854887C8857FE5488548854887C88450801080208
+754B:004000407C40548054FE550856887C8854885450545054207C50448801040202
+754C:00001FF0111011101FF0111011101FF002800C603458C4460440084008401040
+754D:002000207C5054505488550456027C8854885488548854887C88450801080208
+754E:002000287C245424542055FE54207C2054205450545054507C88448801040202
+754F:00001FF0111011101FF0111011101FF00000FFFE111010A010401430180E1000
+7550:0000FFFE00001FF0101010101FF000003FF8210821083FF8210821083FF82008
+7551:100011FC1124112455245924512491FC1124112411242924252445FC41048000
+7552:101008100810FF90001000107F104910491049287F284928494449447F844102
+7553:010001047D88095011202118C50602003FF8210821083FF8210821083FF82008
+7554:002000207D2454A454A8542055FC7C205420542057FE54207C20442000200020
+7555:1FF0111011101FF0111011101FF000003FF8210821083FF8210821083FF82008
+7556:0008001C7DF055505550555055507D5055505548554855687D54467402520400
+7557:02000100FFFE00001FF010101FF000003FF8210821083FF8210821083FF82008
+7558:002000207C2055FC5524552455FC7D245524552457FE55047D04450401140108
+7559:060078FC4044484444445A94610800003FF8210821083FF8210821083FF82008
+755A:0200044008201FF002007FFC082010103FF8D11611101FF0111011101FF01010
+755B:002000207C5054885504561254207C4055885410542054447D88441000600380
+755C:020001007FFC040008201FC003100C083FFC00043FF821083FF821083FF82008
+755D:102008200820FFBC002400447F444988490849107F104928492849447F844102
+755E:01000100FFFE012001207D205538554855487D885510551055287D4845840102
+755F:00003FF821083FF821083FF81210220847E4882214402280010006C01830E00E
+7560:010002001FF010101FF010101FF000003FF8210821083FF8210821083FF82008
+7561:002000107C1055FE5420542454447CF854125422544455887C10442800440182
+7562:00003FF821083FF821083FF8092009207FFC092009203FF801007FFC01000100
+7563:010002800C603018CFE600001FF010101FF000003FF821083FF821083FF82008
+7564:002000207C2055FC5420542057FE7C08540855FE540854887C48440800280010
+7565:00800080F8F8A908AB10ACA0F840A8A0A918AA06ADF8F9088908010801F80108
+7566:002000207DFC54205420542057FE7C005420542055FC54207C20442003FE0000
+7567:00003FF821083FF821083FF808001FF0282007C01830E00E1FF010101FF01010
+7568:010011100920FFFE054009203118C0061FF0111011101FF0111011101FF01010
+7569:004000207C2055FE5440544054A07CA255A45698549054887C8844A400C20080
+756A:00F83F00111009200100FFFE092010103FF8D11611101FF0111011101FF01010
+756B:01003FF80108FFFE01083FF801007FFC00003FF821083FF821083FF80000FFFE
+756C:010002800C603018CFE601003FF81110250802003FF821083FF821083FF82008
+756D:002000207C505488550456FA54207C2057FE5420552855247E22442200A00040
+756E:008000807CFE550056FC548454A47C9457FE5484552455147DFE440400280010
+756F:00400040F888A904ABFEA802F888A944AA42A8F8A988FA508820005001880606
+7570:00003FF821083FF821083FF8082008207FFC08200820FFFE0000082010102008
+7571:00007FFC02803EF8228822883EF802803FF8210821083FF8210821083FF82008
+7572:010002800C6037D8C0063FF809201110250802003FF821083FF821083FF82008
+7573:00003FF821083FF821083FF80000FFFE80021FF010101FF010101FF01010FFFE
+7574:00200020FBFEA820A9FCA840FBFEA848A888A8FEA908F9488A28040800280010
+7575:01003FF80108FFFE01083FF80100FFFE00001FF051145FF451145FF440047FFC
+7576:0100111009207FFE40029FF4101010101FF000003FF821083FF821083FF82008
+7577:000003DEF842A94AA884A94AFA52AC20A800ABDEA852F9528894014802540422
+7578:002000207DFC54505488550457FE7C0855E85528552855E87D28440800280010
+7579:00400020FBFEAA02AD04A900F9DEAA52AA52AB52AC9AF894891001120212040E
+757A:00007FFC00003FF821083FF82108FFFE00003FF821083FF821083FF80000FFFE
+757B:002001247CA8542055FC544057FE7C8855245622542055FC7C20442003FE0000
+757C:000000FC7C8454FC548454FC54007DFE548054FE552A564A7C92452200540088
+757D:0008003C7DE0542057FE542055FC7D2455FC552455FC54207DFC442003FE0000
+757E:1FF0111011101FF0111011101FF00000FEFE92929292FEFE92929292FEFE8282
+757F:1110212045447978111025247D7C05240110FFFE00807C8854527C22545A7D86
+7580:0020542055FEA82055FC542403FE7C2455FC54207CA054BC54A07D60453E0200
+7581:000007BCF884ACA4AA94ACA4F850A988AE26A8C0AB10F8648B88003000C00700
+7582:00003FF821083FF821083FF8183006C018307FFE50129FF410101FF01010FFFE
+7583:002001FC7C88545057FE540055FC7D2455FC552455FC54207DFC442003FE0000
+7584:00200124F8A8ABFEA8A8A924FA22A904A904A9DEAA44FD54889E010402040404
+7585:000003FEF800A9FCA924A9FCF924ABFEA800A9FCA924F9FC892401FC000003FE
+7586:0000FBFE080009FCF92481FC8124FBFE480049FCE92449FC692489FC500023FE
+7587:002003FEF820A9FCA800ABFEF802A9FCA820ABFEA800FBFE880403BE02A4038C
+7588:0080F8BE0080709C5294729C0280FABEAAAAACAAF8BEA8AAA8AAF93E89220200
+7589:1FF011101FF011103FF82AA83EF82AA8FFFE88020FF010101FE00020FFFE0000
+758A:1FF011101FF011103FF82AA83EF82AA8FFFE90121FF010101FF01010FFFE0000
+758B:000000007FFC0104010801001100110011F81100110011002900250043FE8000
+758C:010001007FFC01003FF80108FFFE01083FF80100110011F81100290047FE8000
+758D:00007FFC0104110011F0290047FE80001FF010101FF010101FF00000FFFE0000
+758E:002000207DFE0420082011FC512451245DFC5020507050A85D247222C0200020
+758F:002000107DFE04200848108451FE50025CA850A850A850A85D2A712AC22A0406
+7590:01003FF801007FFE40029FF411101FF011101FF000007FFC010411F02900C7FE
+7591:40004DFC7008445044203DFE40247C2890A010B8FEA010A028E02520451E8200
+7592:008000401FFE1000900050005000100030005000900010002000200040008000
+7593:008000401FFE1000900057F8510811103120513C910411042204220444288810
+7594:008000401FFE1000900057FC5040104030405040904010402040204041408080
+7595:008000401FFE1000900052005208121032605380920012042204220441FC8000
+7596:008000401FFE1000900057FC5084108430845084909410882080208040808080
+7597:008000401FFE1000900057FC5008101030205040904010402040204041408080
+7598:008000401FFE10009000500057FC10403040504090401040204020404FFE8000
+7599:008000401FFE1100910053FC5400180033F850109060108021002202420281FE
+759A:008000401FFE11009100510053F01210341058209020104020A0211046089806
+759B:008000401FFE10009010501057FE101030105210911011102010201040508020
+759C:008000401FFE10009000500057FE104030405050904810442040204040408040
+759D:008000401FFE100090405040504014443444544494441444244427FC40048000
+759E:008000401FFE1000900053F85000100037FE5080910013F82008200840508020
+759F:008000401FFE1000900053FC5200120032005FFE92001200220023FC40008000
+75A0:008000401FFE1000900057FC5100110031F85108910812082208240848509020
+75A1:008000401FFE100093F0502050C0110033FC5124912412242244244448A88110
+75A2:008000401FFE100090405040524412443248545090A010A02110220844048802
+75A3:008000401FFE100090905088508017FE30A0512091201120222222224422881E
+75A4:008000401FFE1000900053F8524812483248524893F812002202220241FE8000
+75A5:008000401FFE1040904050A0511012083D165110911011102110221042108410
+75A6:008000401FFE10009040504053F810483048504897FE10A020A0211042088C06
+75A7:008000401FFE1000903C57C054401440344057FE942014202412250A46068402
+75A8:008000401FFE1000900057FC50101210341057FE90501090211022104C508020
+75A9:008000401FFE1080908057F0511011123212544E904017FE2040204040408040
+75AA:008000401FFE1020922052205222122433A852309220122222A22322421E8000
+75AB:008000401FFE100093F052105210140E380057F89208111020A0204041B08E0E
+75AC:008000401FFE100093FE52005220122032FC5224922412442244248444A88910
+75AD:008000401FFE10009110511051101110311052A8926812282444244448849102
+75AE:008000401FFE104090A05110520814063BF052109210125022202204420481FC
+75AF:008000401FFE1000900053F85208132832A85248924812A8252A240A48069002
+75B0:008000401FFE10809040500057FC10403040504093F81040204020404FFE8000
+75B1:008000401FFE1200920053FC54041BE43224522493E4121422082202420281FE
+75B2:008000401FFE1040904057FC5444144037F85508951014A0244028A049189606
+75B3:008000401FFE1000920852085FFE12083208520893F812082208220843F88208
+75B4:008000401FFE1000900057FE5008100833C85248924813C82248200840288010
+75B5:008000401FFE1000911051105512151435D8551095101510251225D25E12880E
+75B6:008000401FFE100090485248524812483FFE5248924812782200220043FE8000
+75B7:008000401FFE1000903C57C054401440344057FE942014202412250A46468422
+75B8:010000803FFE20002000A7F86408240827F86408A40827F8200040005FFE8000
+75B9:008000401FFE104090A051105208142630C05310902010C02308201040E08700
+75BA:008000401FFE1000907857805040102037FC5008903010C023002480487E9000
+75BB:008000401FFE1000900053FC520412043204520493FC12042090210842048402
+75BC:008000401FFE1100910053F85610192030C053309C0E10C02020230040C08020
+75BD:008000401FFE1000900053F85208120833F85208920813F8220822084FFE8000
+75BE:008000401FFE1200920053FC5240144030405FFE904010A020A0211042088C06
+75BF:010000803FFE21203FFCA12461242FFC29206920AFFE21222222422A44248820
+75C0:008000401FFE1200920053FC5404180433E45224922413E42224200440288010
+75C1:008000401FFE10809080508050FC1080308057F8940814082408240847F88408
+75C2:010000803FFE24002400A4006FBC24A424A464A4A4A424A428A448BC52A4A100
+75C3:008000401FFE108090405FFE50801108321057E0904010802110220847FC8204
+75C4:008000401FFE1200920053FE5500190031F85100910011FC2100210041008100
+75C5:008000401FFE1000900057FC5040104037FC544494A415142614240444148408
+75C6:008000401FFE100093FC5204520413FC3200524092441248227024424442883E
+75C7:008000401FFE100090005FFC504010403240527C92401240224022405FFE8000
+75C8:008000401FFE1000900057FC5444144437FC5444944417FC2444284448549008
+75C9:008000401FFE100097F85010502010D833045C0293F81040204020404FFE8000
+75CA:008000401FFE104090A0511052081DF63040504093F81040204020404FFE8000
+75CB:008000401FFE10009040504057FC14443444544497FC10402048207C4F828402
+75CC:008000401FFE1000900057FC540415F4340455F49514151425F4240444148408
+75CD:008000401FFE10409FFE50405FFC104437FC544097FE104220AA211442088C06
+75CE:008000401FFE108090405FFE5080110833F05020904411882610206841848602
+75CF:008000401FFE1040904057FE5080110033FC550499FC110421FC210441148108
+75D0:008000401FFE1000900057FC5404140435F45514951415F42404240447FC8404
+75D1:008000401FFE108091F852105D2010C031A0567C908411082690206040C08700
+75D2:008000401FFE111090A057FC5040104033F85040904017FC2040204040408040
+75D3:008000401FFE100097FC50805110120837FC5044904017FC204020404FFE8000
+75D4:008000401FFE1040904057FC504010403FFE501090101FFE2210211041508020
+75D5:008000401FFE100097F8540857F8140837F85484948814502420251846068400
+75D6:008000401FFE1000900053FC5090109034925292929410982090209047FE8000
+75D7:008000401FFE1200920053FE54001BF8328852489FFE1488244827FC40088030
+75D8:008000401FFE1000900057FC500013F83208520893F81000211020A04FFE8000
+75D9:008000401FFE100097FC5000524814903248500097FC1040204020404FFE8000
+75DA:010000803FFE20802088A7F060A03FFE20806FF0A620384027FC404041408080
+75DB:010000801FFE100097F850A0504017FC344457FC944417FC2444244444548448
+75DC:008000401FFE1000903853C0504017FC31505248944611F02110211042128C0E
+75DD:010000803FFE22102208BFFE6248225022646248A2522264244A447248C2933E
+75DE:008000401FFE100097FC5020504011D036485044900013F822082208420883F8
+75DF:008000401FFE104092485150504013F8320853F8920813F82208220842288210
+75E0:008000401FFE10809108520457FE110A3284548291F813082490206041988E06
+75E1:008000401FFE105090485FFE504017FC344457FC944417FC2444244444548448
+75E2:008000401FFE100090C45704511411143FD45314939415542504290441148108
+75E3:008000401FFE10009040504057FC1040304053FC900010402124252A450A88F8
+75E4:008000401FFE1040904052485248155438E25040904017FC2040204040408FFE
+75E5:008000401FFE10009210512057F814083408540897F81120212022224422981E
+75E6:008000401FFE100097FC508053F8108831085FFE900013F82208220843F88208
+75E7:008000401FFE10109210511051541452329252109114160422082210422080C0
+75E8:008000401FFE1108910857FE5108100037FE5402904017FC2084210442288C10
+75E9:008000401FFE104097FC544457FC144437FC504097F81208211020E043188C06
+75EA:008000401FFE110091F0521054201BF83248524892481FFE20A0211042088C06
+75EB:008000401FFE10009200517C5404144435F4544494E415542644244444548408
+75EC:008000401FFE100093F8520853F8120833F8510093FC14942924224444A88110
+75ED:008000401FFE100097BC54A454A417BC34A454A497BC14A424A424A44AA4914C
+75EE:008000401FFE100093FC520053F8120033F852009FFE14882450252046188406
+75EF:008000401FFE1080904057FC540413F03210521093F0120023F82208420883F8
+75F0:008000401FFE10409248525054A0111032085C449248125024A0211042088C06
+75F1:008000401FFE100090905090579E10903090539C90901090279E209040908090
+75F2:008000401FFE1110911051105FFE111035545554955415542554295641108110
+75F3:010000803FFE22102210A2107FBE221026106738AAB42A543292421042108210
+75F4:008000401FFE1200920053BC5524192431245FE49124112422A422BC44248800
+75F5:00801FFE1000103893C0504017FC315052489C4611F010202FFE204041408080
+75F6:008000401FFE10A090A057FC54A414A437FC54A494A41FFE2000211042088404
+75F7:010000803FFE20002080AFFC6120221024886FF6B49027F0249047F24082807E
+75F8:010000803FFE21002504A7C469143FF4211467D4A5542554255445C441148108
+75F9:008000401FFE100093F8524853F8124833F850009FFE11102110211042108410
+75FA:008000401FFE1080910057FC544417FC348457FC914012403FFE204040408040
+75FB:00803FFE20002038AFC068402FFC28206B1AAC0627F8240827F8440847F88408
+75FC:008000401FFE100097FC5444544417FC344455F49514151425F4240447FC8404
+75FD:008000401FFE1120911053FE522016203BFC5220922013FC2220222043FE8200
+75FE:008000401FFE1000977E55045574165435545554955415742754240444148408
+75FF:008000401FFE103897C050405FFE115032485C4690801FFE2108231040E08F1C
+7600:010000803FFE20002410A2106FA8242824446792A488248828A048905288A108
+7601:008000401FFE1000904057FC5110111032A8544490401FFE2040204040408040
+7602:008000401FFE10009FFC5120512017383408540897381120212021205FFE8000
+7603:010000803FFE20002FFCA100630824882D506260A5E029502250444859448080
+7604:010000803FFE22102FFCA21062103FFE200067F8A408240827F84408440887F8
+7605:008000401FFE1208911057FC544417FC344457FC944410402FFE204040408040
+7606:008000401FFE1090910853FC504017FE311052689D86103021C0201840608380
+7607:00803FFE200827F0A0406FFE204027FC6444A7FC244427FC204047FC40408FFE
+7608:008000401FFE110097BC51145794111437A4514C90401FFE20A0211042088C06
+7609:008000401FFE104090A053185DF61000378454A497A414A427A4248444948588
+760A:010000803FFE200022F8A20864082DFE348064F8A520242025FE445044888506
+760B:010000803FFE20002FF8A80868682B8828886BE8AAA82BE8288A50EA5726A002
+760C:008000401FFE1100910457C4511417D4355457D4911413942554294441148108
+760D:008000401FFE100093F8520853F8120833F850009FFE120027FC292442548488
+760E:008000401FFE111097FC511051F0111031F0511097FE120022902308420083FC
+760F:008000401FFE1040904453F45048105037FE508091F8130825F8290841F88108
+7610:010000803FFE20002280ACB8688828882EB86888A8882FF8214042204C18B006
+7611:010000803FFE200023F0A21063D0225022506FFCA80429E4292449E448148808
+7612:008000401FFE100097FE54425BFC104033F8524893F8124823F820404FFE8040
+7613:010000803FFE220023F0A4206FFC34A425146444A0402FFE20A0411042088C06
+7614:008000401FFE111091105FFE511010403FFE5040904017FC2404240447FC8404
+7615:008000401FFE100097BC5484548417BC3400547C97A414242428279044288446
+7616:008000401FFE1080904057FC521011203FFE500093F8120823F8220843F88208
+7617:010000803FFE20802FF8A49062A03FFE21406220AC9830862FF8408040809FFC
+7618:008000401FFE124891505FFE51501248344450809FFE11082390206041988604
+7619:008000401FFE100097FC5248511010E033185C4693F8124823F8204447FC8004
+761A:010000803FFE28902510AFBE622222442A906A90AF9022102228442844448882
+761B:008000401FFE110097BC51145394111437A4514C9100104020242522450A88F8
+761C:010000803FFE210027F8A40867F8240827F86408A7F8208020444A424A1291F0
+761D:008000401FFE100097FC54A454A417FC30405150924814442150224844448040
+761E:010000803FFE204027FCA2486248255428A26318AC4623F8204040404FFE8000
+761F:010000803FFE200027F8A40867F8240827F86000AFFC2924292449247FFE8000
+7620:008000401FFE1444924854A45110120837FC5A0A93F8120823F8220842288210
+7621:008000401FFE104091B05E4E53F8120833F8520893F8120025FC250449FC8104
+7622:010000803FFE24002F78A9486D482B863F006978A9482D482B28491049289346
+7623:010000803FFE20802100AFFC68842FFC28846FFCA1482154225C44464842B03E
+7624:008000401FFE1080977C542455A415543648508097FC144427FC244447FC8404
+7625:008000401FFE111090A057FC504013F8308057FC910013F82440284047FE8000
+7626:008000401FFE1140965C5444575C144437FC504097FC1208211020E043188C06
+7627:00803FFE208020FCA0806FFE288228F06F84A87C280029FC29004BFE490091FC
+7628:00801FFE104017FC904053F8120833F8520893F8120813F822082FFE41108208
+7629:008000401FFE1110911057FC515010A0311052E89C0613F82208220843F88208
+762A:00803FFE210027F8A40867F8240827F86408A7F8212026183A664388420881F8
+762B:010000803FFE20502048BEFE72902A902BFE6490A4902AFE2A90529040FE8080
+762C:008000401FFE1000973C5120513C1720343C5420977E1128212A212445248232
+762D:00803FFE20003FFEA1206FFC29242FFC6000A7F820002FFC2248444449428080
+762E:008000401FFE111093F8521054A417FC30A053189C4613902064239840608380
+762F:008000401FFE142092205F7E544014A0373C5550951015FE251029284B449082
+7630:00803FFE200027FCA44467FC244427FC6100A20827F020C42FFE444849449082
+7631:010000803FFE20402FFEA2486248255428A26318AC0620802A444A4A520A81F8
+7632:010000803FFE22002448A848705422A425006C10B490249C24904550463E8400
+7633:00803FFE20002F7CA924651429A421606618B88623202C4021884E3041C08E00
+7634:00803FFE204027FCA1106FFE200023F86208A3F8220823F820404FFE40408040
+7635:010000803FFE222023BCA4A46AA82510220865F6A80027FC2250444849448080
+7636:010000803FFE22202220AFA0623E2FC22A946A90AF90221027284AA852448282
+7637:010000803FFE22102210AF90623E2FA42AD46A94AF94220827084A9452248242
+7638:008000401FFE120097BC52A454A415BC384057FC94A41554244424A44514840C
+7639:010000803FFE22102520A8BC7744220422246F94A2142A84270443C45C288010
+763A:010000803FFE20002FFCA8046FFC28002FFE6820ABFE2B322AAA4B324AAA9206
+763B:010000803FFE20802FF8A8887FFE28882FF86490A7F021003FFE441043E09C1C
+763C:008000401FFE111097FC511053F8120833F8520893F810402FFE20A043188C06
+763D:00803FFE22083FFEA20863F8204027FC6444A7FC20402FFE204047FC40409FFE
+763E:00803FFE20402E78AA886B102CFC2A046AFCAA042BFC2E2028144952494A8A38
+763F:00803FFE20002FBEA8A26AAA2AAA2AAA6514A8A23FFE2208271040E0431C9C02
+7640:010000803FFE22202FF8A2207FFC20802FF86888AFF828882FF8422044108808
+7641:008000401FFE108094FC550058FC128432FC54849CFC144024FC2548443085CE
+7642:008000401FFE104097FC50A0551413F8360C5BFA920813F82040244449428080
+7643:00803FFE20202F3CA9446AA82C102A286946A9382D502A7E2890487C481088FE
+7644:008000401FFE1120911053FE56201BFC322053FC922013FE2200252444928892
+7645:008000401FFE100097FE50A057BC14A437BC50A097FC144427FC244447FC8404
+7646:010000803FFE21102554A5B8691022A824446FFEA88230842FF8410842288C10
+7647:00803FFE20002F3CA9246F3C29242F3C6804A9E4292429E4292449E449248A6C
+7648:010000803FFE20402F50A1246A1824083B766150AF8C28782F48413045488284
+7649:00803FFE20002FBEA8A26FBE200027FC6444A7FC244427FC20407FFE40408040
+764A:010000803FFE20102F28A9446A922C7C2A086910A97E2D002AFE4820484488FE
+764B:008000401FFE100097FC50A053B8120833B850A09FFE10402124252A450A88F8
+764C:008000401FFE100093F8520853F8100037BC54A497BC10402444244447FC8004
+764D:010000803FFE20802E4EA44465F4242425246EAEA444244424A446A4590E8200
+764E:008000401FFE100097BC54A457BC14A437BC540495F4151425F4251445F4840C
+764F:00801FFE100017FC94A457FC10003FFE500093F8120813F8214423284D10818C
+7650:00801FFE10A013189DF6500017FC355454E497FC100013F8220823F8420883F8
+7651:00803FFE212027F8A52867F825282FFE6800ABFC28002FFE2A444A285298A306
+7652:00803FFE204021A0A6187BF6200027A864A8A7A824A8278824A845904A5491F2
+7653:010000803FFE25102950B55067DE28243B946814AB942A942A884AC84A948C22
+7654:008000401FFE104097FC51105FFE100033F8520893F8120823F82544452A88FA
+7655:008000401FFE1040902057FE5228127E34C8577E924814C8277E2248447E8840
+7656:010000803FFE20102788A4BE648027A22494643EAF882C8834BE478844888008
+7657:00803FFE200027FCA0406FFE284223586040A358200027FC244447FC444487FC
+7658:00801FFE11101FFE911053F8124833F8524893F8104017FC245425F44414840C
+7659:010000803FFE21002E78A8086F7828082FF86888ACC82AA82CCA4AAA4CC68882
+765A:00803FFE220023F8A4106FFE352426FA6400A5FC240025FC240049FC490491FC
+765B:00803FFE20402FFEA00067FC240425F46514A7FC200823F020404FFE41508E4E
+765C:010000803FFE20002FDCA8546FD42AA22A806FDCAA942FD4280852885454A862
+765D:00803FFE20402FFEA00067FC240425F46514A7FC200027FC20004FFE424884C4
+765E:00803FFE22102F9CA22462482FBE2AA26AAAAFAA222A272A2AAA529442228242
+765F:00803FFE210027F8A6486528249827F86210A5E8380627F8254847F845488558
+7660:010000803FFE20402FFEA0A06F5E255425546B5AA20823F8220843F844088808
+7661:010000803FFE2480273CA48463942408277E6A0AA2282FAE22284558484E9080
+7662:00801FFE1208111097FC504013F830805FFE921017F81A1623F0226443188204
+7663:010000803FFE24002744A928727E2F902A906FBCAA902F90207E43905C108010
+7664:008000401FFE121093DE5528588417BC34A457A494A417A42434252846A08420
+7665:010000803FFE25102950B55067DE28243B946814AFD429142B8849084FD48822
+7666:00803FFE200027FCA55464E427FC204067FCA0402FFE24A4285247FC40408FFE
+7667:00803FFE20002FFCA8886B3029102FBC6BB8AD542912284029784940494097FC
+7668:00803FFE200027FCA0406FFE284223586220A7FE2C2037FC242047FC442087FE
+7669:010000803FFE2210221EBFA262442FBE2AA26ABEAFA2223E27224ABE52948222
+766A:00803FFE2010237CAE10627C2F1022FE6644A77C2AC42A7C3244427C42288244
+766B:00803FFE24003FBEA4086F10293E2F22692AAF2A292A2F2A292A7F94491290A2
+766C:010000803FFE24002722A914723E2F882A886F9CAA882F88203E554855488008
+766D:00803FFE20002FBEA8A26FBE28A22FBE68A2AFBE251428A22FFE431040E08F1C
+766E:00803FFE20042EF8AA546AFE2C102AFE6A04AAFC2A042EFC282049544A4A8838
+766F:00801FFE14A417BC94A457BC14A437BC512093FE122017FC2A2023FC422083FE
+7670:00803FFE20002AA8B5246ABE2F6829686FBEA0282FA82ABE2FA8482848BE87A0
+7671:00803FFE25182F94A53E672822682FBE6AA8AFA8223E2FA822285FBE452088A0
+7672:00803FFE22003FBEA2086F9028BE2FA268BEAFA228BE2FA228BE5FC0491490A2
+7673:00803FFE244427FCA4446FFE2AAA2FBE6AAAAFBE220827F020C44FFE424884C4
+7674:00803FFE24442AEAAE0E64E42AAA2EEE6000A7FC204027FC20404FFE404080C0
+7675:00803FFE244428E8AE0E64E42A0A2EEE60A0AAEA20402FFE28A24912484288A6
+7676:00887C9004A004C0448224442448085008201020101020084004800200000000
+7677:00907EA002444448283010102008DFF6010001000100FFFE0100010001000100
+7678:00907EA002444448283010102008CFE6010001007FFC010002C0042018106008
+7679:00907EA002444448283010102FE8C8260820101C2FE000200C4003800C707008
+767A:00907EA002444448283010102008DFF6044004407FFC0440084008441044603C
+767B:00803E9002A424481450082017D02008DFF6101010101FF0082004407FFC0000
+767C:00907EA00444282810103CF8C49604903D0C200041F87C0804D0042028501188
+767D:0100020004003FF820082008200820083FF8200820082008200820083FF82008
+767E:0000FFFE0100020004003FF82008200820083FF820082008200820083FF82008
+767F:0820082010203F2021202120212021203F2021202120212221223F22211E0000
+7680:020004003FF8200820083FF8200820083FF80000203823C03C04200420041FFC
+7681:020004001FF0101010101FF0101010101FF001000100FFFE0100010001000100
+7682:010002001FF0101010101FF0101010101FF00200020003FCFE000204020401FC
+7683:040008003FF8200820083FF8200820083FF8044004400440084408441044603C
+7684:1040104020407E7C42844284430442447E2442244204420442047E0442280010
+7685:1000100021FC7D2445244524452445247DFC45004500450045027D0244FE0000
+7686:208020883CB020C020842C84317C02001FF0101010101FF0101010101FF01010
+7687:020004001FF010101FF010101FF000007FFC010001003FF801000100FFFE0000
+7688:1004100E20F07C80448044FC44A444A47CA444A844A8449045107D2846440082
+7689:1090109020907A904A924AD44A984A907A904A904A904A924AD27F124A0E0000
+768A:1020102020507C5044884524461244107DFC44044408448844507C2044100010
+768B:020004001FF010101FF010101FF002007FFC044009203118CFE6010001000100
+768C:1020102020207DFE44204420442045FC7C7044A844A8452445247E2244200020
+768D:020004001FF010101FF010101FF0200020F83E882088208826A8389000800080
+768E:1040102020207BFE4800488849044A0278884888485048204850788849040602
+768F:1084104820007CFC44484448444844487DFE44484448444844487C8844880108
+7690:020004001FF010101FF010101FF021081110092011102108FFFE010001000100
+7691:1020112421247D2445FC440045FC44047C0445FC4500450045027D0244FE0000
+7692:101010D82394789448904BFE48904894789448D84B98489048AA78CA4A860102
+7693:1020112021207DFC45204620442047FE7C00440045FC450445047D0445FC0104
+7694:100011FC21047DFC450445FC440044007DFC4420442047FE44207C2044200020
+7695:00000000FEFE1020102020407EFC4284428442847EFC4284428442847EFC4284
+7696:1040102023FE7A024C0449F8480048007BFE489048904890491279124A0E0400
+7697:100011FC212479244974492449FC4904797449544954497449047A044A140408
+7698:1020102023FE7C2045FC442047FE44007DFC450445FC450445FC7D0445140108
+7699:080C08F07E8018802CFE2A8848888888090804001FF010101FF010101FF01010
+769A:102011242124792449FC48004BFE480079FC4904490449FC488878504BFE0000
+769B:020004001FF010101FF010101FF0081010207EFC428442847EFC428442847EFC
+769C:1020101021FE7C0044FC448444FC44007DFE4502457A454A457A7D02450A0104
+769D:102020207D2444A47CA844207DFE0050FE50105010507C5210521E92F08E4100
+769E:1020104021FC790449FC490449FC48407BFE488849244A224DFC782048200020
+769F:102013FE20207DFC442047FE440045FC7D0445FC450445FC45047DFC44880104
+76A0:1020122223FE7890488849FE4B104D1079FE4910491049FE4910791049FE0100
+76A1:1020104021FC7D0445FC450445FC44207D2444A84524442047FE7C2044200020
+76A2:1020102021FC78204BFE49084B9C490879884E3E48004BFE489078904912020E
+76A3:108813FE2088780049FC48A848A84BFE78A848A849FC48204BFE782048200020
+76A4:103C13E0212478A84BFE48A849244A0279FC4924492449FC4924792449FC0104
+76A5:104011FC210479FC490449FC490449FC7820492448A8492448207BFE48200020
+76A6:1088110823C87A504BDE4A644BD4491478944FF4491449C849487A544B5404A2
+76A7:103C13C020447A2449084FFE4C424AA47A8A4C7A488048F849087A904860079E
+76A8:02001FF010101FF010101FF020407EFC42847EFC42847EFC01003FF80100FFFE
+76A9:100021FC7D0445FC7D0445FC7C200124FCA8102013FE7C9010901D12E212440E
+76AA:1124117422587ADA4BFE49544ADA4BFE78A248204BFE487048A879244A220020
+76AB:1040102023FE7A504BFE4A524BFE4A007A944AD84A904AD24A8E7C004954022A
+76AC:11FC102023FE7A224DAC482049AC489079FE4B204DFC492049FC792049FE0100
+76AD:101E13E0212278944BFE4A524BFE48047BC44A7E4BC44A544BCC7A844AD40348
+76AE:0080008000803FFC2084208820802FF02410241022202140208041404630980E
+76AF:0800087C08107F1049104A1048107EFE4210421052104C1044104A1092102010
+76B0:08200820087E7F4249824A7A484A7E4A427A4242524A4C4444424A42923E2000
+76B1:201020103E1042FE84920894FE9002FC02A47EA402A802A80290FF2802440082
+76B2:0010FF10911010FEFE922094289048FC7EA408A408A80EA8F890492809440A82
+76B3:10101410121010FEFE921094109092FC54A410A438A854A89290112851442282
+76B4:10101010201044FEFE9228944490A2FC3CA444A444A8A8A81090292845448282
+76B5:241024107E1024FE2492FF9400907EFC42A442A47EA842A842907F2842440082
+76B6:10101010FE1038FE5492929410907CFC44A47CA444A87CA800901D28E1444282
+76B7:08100810FF1008FE08927E9400907EFC42A442A47EA842A824900F28F1444282
+76B8:0010FE10921010FEFE9210947C9054FC7CA454A47CA810A8FE90112811441282
+76B9:080008FE08927F1049FE4A10487C7E54427C4254527C4C1044FE4A1092102010
+76BA:40104010FE1022FEAA92FA94429094FC48A4FEA422A8AAA8FA90432894440882
+76BB:10101E1010107EFE52925C9472904EFC40A45CA454A85CA854905D2896443882
+76BC:1010FE1010107CFE0092FE9482907CFC00A47CA444A87CA8449029280F44F282
+76BD:1010FE100010FEFE8292BA94AA90FEFC00A47CA444A87CA844907D280044FE82
+76BE:1010FE1010107CFE0092FE94AA90FEFC44A47CA444A87CA844907D2828444482
+76BF:000000003FF82448244824482448244824482448244824482448FFFE00000000
+76C0:0100010001800140012001100108010001003FF82448244824482448FFFE0000
+76C1:00003FF008100820083C10041004201440083FF82448244824482448FFFE0000
+76C2:00003FF801000100FFFE010001000500020000003FF8244824482448FFFE0000
+76C3:00007FFC010003000570090C3102C10000003FF82448244824482448FFFE0000
+76C4:00007FF801083FF821003FFC01040114010800003FF8244824482448FFFE0000
+76C5:010001003FF82108210821083FF82108010001003FF8244824482448FFFE0000
+76C6:0440082010102FE8C4260420082010A0604000003FF8244824482448FFFE0000
+76C7:010001007FFC028004400A203118C00600003FF82448244824482448FFFE0000
+76C8:00003FF008100FA008BC128411042294444800003FF8244824482448FFFE0000
+76C9:00701F8001000100FFFE054009203118C0063FF82448244824482448FFFE0000
+76CA:101008200000FFFE000008201010200840043FF82448244824482448FFFE0000
+76CB:024002207FFC04000BF0112020C043301C0E00003FF8244824482448FFFE0000
+76CC:100010F83E884288A2A8149008841084207CC0003FF8244824482448FFFE0000
+76CD:010001003FF801000100FFFE040008201FF000103FF8244824482448FFFE0000
+76CE:010001001FF011101110FFFE02800C603018C0063FF8244824482448FFFE0000
+76CF:0240022003F87E0003FCFE10016003821C62E01E00003FF8244824482448FFFE
+76D0:082008207F20082808240F22F020402000003FF82448244824482448FFFE0000
+76D1:04402440247C2440249024882508040000003FF82448244824482448FFFE0000
+76D2:010002800C603018CFE600001FF010101FF000003FF8244824482448FFFE0000
+76D3:100009FC402020200BFE10207020102010A000403FF8244824482448FFFE0000
+76D4:040004007FFC08401248125024A0411082080C0600003FF8244824482448FFFE
+76D5:100009F0411025900550095071121112120E14003FF8244824482448FFFE0000
+76D6:082004407FFC010001003FF801000100FFFE000000003FF8244824482448FFFE
+76D7:4080208009FC12042448E04020A023182C0600003FF8244824482448FFFE0000
+76D8:020004001FF011101090FFFE10101210215040203FF8244824482448FFFE0000
+76D9:012001107FFC01003FF821083FF821083FF8210800003FF824482448FFFE0000
+76DA:011001087FFC0100211811A007401920E118450602003FF824482448FFFE0000
+76DB:009000883FFC208020883E48225022244A54448C81043FF824482448FFFE0000
+76DC:0080208011FC820454482040E0A023182C0600003FF8244824482448FFFE0000
+76DD:3FF000101FF00010FFFE111009A005401930E50E02003FF824482448FFFE0000
+76DE:021002FC7F4000840764781C021002FC7F4000840764781C00003FF82448FFFE
+76DF:00007CFC448444FC7C8444FC44847C84011402083FF8244824482448FFFE0000
+76E0:08000FE010201FC000407FFC0600192006C039B0068C398000003FF82448FFFE
+76E1:01003FF80108FFFE01083FF801007FFC248842443FF8244824482448FFFE0000
+76E2:00207C28542455FE7C20545054507C88010402023FF8244824482448FFFE0000
+76E3:00003F2024203F3E21403F5024883F0800003FF82448244824482448FFFE0000
+76E4:10783E4822482A86FF7822482A2842104A2884463FF8244824482448FFFE0000
+76E5:1100611C4D444544759C49844944755C420400003FF8244824482448FFFE0000
+76E6:010006C01930E7CE0080FFFE04403FF8284837B820083FF800003FF82448FFFE
+76E7:010001F801003FFC21042FE0210827F8249027F0249027F020004FF84948BFFE
+76E8:0BFE104061FC090411FC610405FC090431FCC08801043FF824482448FFFE0000
+76E9:08207F20083EFF4422A47F280828FF10082808463FF8244824482448FFFE0000
+76EA:23F8120893F8420843F810002FFEE20027FC2924225404883FF824482448FFFE
+76EB:010006C01830EFEE00001FF010107FFC04401FF014501BB010103FF82448FFFE
+76EC:00407E7C48907E1042FE7E10487C48447E7C00003FF8244824482448FFFE0000
+76ED:102022207C3E0A447FA408247F2814287F1008287F4408823FF824482448FFFE
+76EE:00003FF82008200820083FF82008200820083FF820082008200820083FF82008
+76EF:000000007BFE4820482078204820482078204820482048207820482000A00040
+76F0:000001FC7C20442044207C20442047FE7C204420442044207C20442000200020
+76F1:000001FC7C20442044207C20442047FE7C204420442044207C20442000A00040
+76F2:02000100FFFE1000100010001FF800001FF010101FF010101FF010101FF01010
+76F3:002000107C10440045FE7C80448044807C804480448044807C80448000FC0000
+76F4:010001007FFC01001FF0101010101FF010101FF010101FF010101010FFFE0000
+76F5:004000407C8044FE45007E0044FC44087C104420444044807D02450200FE0000
+76F6:000000007DFC440044007C0047FE44907C904490449044907D124512020E0400
+76F7:004000407C8044FC45047E04448444447C444414442444447D84440400280010
+76F8:080008FC08840884FE8408FC18841C842A842AFC488488840884088408FC0884
+76F9:0020002078204BFE4820792449244924792449FC4824482078224822001E0000
+76FA:0008001C7CE0448044807C8044FE44887C884488448844887D08450802080408
+76FB:00900090790849084A047C024BFC4880790049F8480848087808480800500020
+76FC:0010009078904888490879044A044DFA78884888488848887908490802280410
+76FD:002000207C2045FC44207C20442045FC7C204420442047FE7C20442000200020
+76FE:007C3F8020803FFC20802FF8280828082FF8280828082FF8480848088FF80808
+76FF:004000207C2047FE44887C88448844887C884450445044207C50448801040602
+7700:000000FC7C84448444847CFC448444847C8444FC448444847D04450402140408
+7701:010011101108212440C003000C003FF8D0081FF810081FF8100810081FF81008
+7702:0004001E7DF0451045107D10451045FE7D104510451045087D0A454A01860102
+7703:0000000079FC4800480078004BFE4820782048404840488879044BFE01020000
+7704:000003FE7C20442045207D3E452245227D2245FE440244027C02440200140008
+7705:0008001C79E04900490079FC49444944794449284928491079104A2802440482
+7706:004000207C2045FE44407C404440447C7C444444444444447C84448401280210
+7707:004000407840494849447A424A424C4878484848481048107820484001800600
+7708:0040004078404BFC4A447C484840484078A048A048A0492079224A22041E0800
+7709:00003FF8210821083FF820002FF8280828082FF828082FF8480848088FF80808
+770A:0008003C7DE0442044207C3C45E044207C20443E47E044207C2244220022001E
+770B:00F87F0001003FF80200FFFE040008001FF028104FF088100FF008100FF00810
+770C:00000FF048104FF048104FF048104FF040007FFC010011101108210445040200
+770D:000001FE7D00450445447D28452845107D104528452845447D84450001FE0000
+770E:000001FC7800480048007BFE48204820792849244A244A227C22482000A00040
+770F:002000207C2045FC45247D24452445247D2447FE442044507C50448801040202
+7710:000000007BFE48204820782049204920793C4920492049207920492007FE0000
+7711:0010009078904910497E7A524B924892791249124A524BD278624822004A0084
+7712:002000207C2045FC45247D24452445FC7D244524452445FC7D24442000200020
+7713:00280024782448204BFE7A204A244A247A244A284A284A907B124A2A00460082
+7714:00007FFC444444447FFC01000920111021084104092011102108410401000100
+7715:002000207C50448845047E12442044407D884410442044447D88441000600380
+7716:000001FC7D04450445047D0445FC44507C504450445044927C924512020E0400
+7717:008000807D0045FC46047C0445E445247D24452445E445247C04440400280010
+7718:01000100FFFE01002288145008203018DFF610101FF010101FF010101FF01010
+7719:002000207C20444044487C8445FE44827C0044FC448444847C84448400FC0084
+771A:010011001FF821005FF00100FFFE00001FF010101FF010101FF010101FF01010
+771B:002000207C2045FC44207C20442047FE7C7044A844A845247D24462200200020
+771C:002000207C2047FE44207C20442045FC7C7044A844A845247D24462200200020
+771D:0040002078204BFE4A027C04480048007BFE4820482048207820482000A00040
+771E:20703F8420041FFC00000FF848084FF848084FF848084FF840007FFE10102008
+771F:010001007FFC01001FF010101FF010101FF010101FF01010FFFE082010102008
+7720:000001FC7D04450445047DFC452045207DFE4520452045107D12454A01860102
+7721:0004001E7DF0451045107D10451045FE7D104510451045087D0A454A01A60112
+7722:10001EF8228862A894920882307EC0001FF010101FF010101FF010101FF01010
+7723:002000207D20452045FC7D20462044207DFE4420445044507C88448801040202
+7724:000001FC7D04450445047DFC450045407D444548457045407D424642023E0400
+7725:088008882E9028E028842E84F07C00001FF010101FF010101FF010101FF01010
+7726:0090009078904A904A927AD44A984A907A904A904A904A927AD24F12020E0000
+7727:000001FC7C44444444447C44449444887D0044FC448444847C84448400FC0084
+7728:0008003C7BC04800484078204BFC4808781048204840488079004A80047E0000
+7729:0040002078204BFE48407840488849087BF048204840488879044BFC01040000
+772A:000001FE7C20442044207DFE452245227D52454A458A45027D024502010A0104
+772B:002000207D2444A444A87C2045FC44207C20442047FE44207C20442000200020
+772C:00900088788848804BFE78A048A048A478A44928492849327A224A62049E0800
+772D:002000207DFC442044207C2047FE44007C20442045FC44207C20442003FE0000
+772E:000001FE7D024502457A7D024502457A7D4A454A454A457A7D024502010A0104
+772F:00200020792448A448A8782048204BFE787048A848A8492479244A2200200020
+7730:000001FE7C20444044887D0445FE44227C20442045FE44207C20442003FE0000
+7731:002000207BFE482049FC782449FC492079FE4822482A48547850488801040202
+7732:000003FE7C88448844F87C88448844F87C884488448E47F87C08440800080008
+7733:004000407CFC450446887C50442044407C8045FC468444847C84448400FC0084
+7734:0080008079FC49044A0479E44924492479E44924492449E47904480400280010
+7735:002000207C7C448445487C30442044487D90443E444245A47C18441000600180
+7736:000001FE7D00450045FE7D104510457C7D104510451045FE7D00450001FE0000
+7737:0100111009203FF802007FFC082010102FE8C8260FE008200FE008200FE00820
+7738:00400040789049084BFC78244920492079FC4A2048204FFE7820482000200020
+7739:008800487C50440045FC7C20442044207FFE4420445044507C88448801040202
+773A:0090009078904A9249947898489049987A944C9248904890791249120212040E
+773B:010400847C88440047FE7C20442045FC7C20442047FE44207C20442000200020
+773C:000003F87A084A084BF87A084A084BF87A444A484A304A207A104A8803060200
+773D:0004001E7DE0450045067D78455045507D524554454845487D44465402620440
+773E:00007FFC444444447FFC000000FC7F0011101110111029282528454481820100
+773F:00400020781049E0482278344BB848B078A848A8492849247A244C2200A00040
+7740:082004407FFC01003FF80200FFFE04000FF018102FF0C8100FF008100FF00810
+7741:0100010079F04A104C207BF8484848487BFE484848484BF87848484001400080
+7742:0208050808881248050808883FF820002FF828082FF828082FF848084FF88808
+7743:00400040788849044BFE7802488849447A4248F849884A507820485001880606
+7744:002001247CA444A844207DFC450445047DFC4504450445FC7D04450401140108
+7745:000001FC7D0445FC45047DFC440044007DFC4420442047FE7C20442000200020
+7746:004000207BFE4A024C0479F8480048007BFE48904890489079124912020E0400
+7747:0108008878904BFC482478244BFC4A207A204BFE486248A2792A4A2404200020
+7748:000001FC7D04450445047DFC440044007DFE4420442045FC7C20442003FE0000
+7749:0020002079244924492479244AAA4C727820482049FC48207820482003FE0000
+774A:000000FC7C84448444FC7C0045FE45027D0245FE450245027DFE4502010A0104
+774B:001000D87B94489448907BFE48904894789448D84B98489078AA48CA02860102
+774C:0080008079F84A084C107BFC4A444A447A444BFC48A048A079224922021E0400
+774D:000003F87A084A084BF87A084A084BF87A084A084BF8492079204A220422181E
+774E:01840068783048C84B0478404BFE48A079204BFC4D2449247934492800200020
+774F:000003FE7A224A224A227BFE4A224A627A724AAA4B224A227A224A0203FE0202
+7750:0020002078204BFE4820792448A448A87BFE487048A848A879244A2204200020
+7751:0040004078A048A049107A084DF64800788848484A4849507910482007FE0000
+7752:0020012279224A24485078884B0448227820492449244A287850488801040602
+7753:0090009078904BFC4A947A944A944BFC7A944A944A944FFE7800489001080204
+7754:002000207850488849047AFA480049FC7954495449FC4954795449540104010C
+7755:004000207BFE4A024D04790049DE4A527A524B524C9A4894791049120212040E
+7756:0020002079FC482048207BFE488849447A4248F849884A507820485001880606
+7757:000001F87908490849F87908490849F8788049FC4A544C9479244A4400940108
+7758:00003FF8244824483FF80000FFFE00001FF010101FF003040C881870EA180C06
+7759:004000207BFC4A044A047BFC4A004A287A244BFE4A204A507A504C8805040A02
+775A:000003FE7A104A104AFE7A104A104BFE7A004A104A104AFE7A104C1005FE0800
+775B:002000207BFE482049FC78204BFE480079FC490449FC490479FC490401140108
+775C:003C07C07A44492848007BF8484848487FFE484848484BF87848484001400080
+775D:0C8070FC1124FE24384454A8911000001FF010101FF010101FF010101FF01010
+775E:0020002078204BFE48207924492449247AAA487048A848A879244A2204200020
+775F:004000207BFE48004888788849544A22780048204BFE48207820482000200020
+7760:0020012478A8482049FC78404BFE488879044AFA4C88488878A848920082007E
+7761:00100078F3C090409040F7FC92489248F7FE9248924897FCF040904007FC0000
+7762:00A00090788049FE49107B104DFC4910791049FC49104910791049FE01000100
+7763:08000EFC0844FF4408282A10492808441FF210101FF010101FF010101FF01010
+7764:000001FC7924492449FC7924492449FC780048004BFE48887888488801080208
+7765:004000807BFC4A244A247BFC4A244A447BFC489049104FFE7810481000100010
+7766:0020002079FC482048207BFE488849047A22482049FC48207820482003FE0000
+7767:001C03E07A204BFE4A207A924B0A4A0679FC4904490449FC7904490401FC0104
+7768:000000407B9C4A044A047B9C4A044A047BFC489048904890789049120212040E
+7769:000001F87808480849F8780848084BFE78204A22497448A879244A2200A00040
+776A:00007FFC44447FFC01003FF80100FFFE082004403FF80100FFFE010001000100
+776B:002000207BFE482049FC78244BFE482479FC48204920493E79204AA0027E0400
+776C:0008003C7BC048444A247928490048207BFE487048A848A879244A2204200020
+776D:000001FC792449244974792449FC4904797449544954497479044A0402140408
+776E:004000A079104A084DF678004BC44A547A544BD44A544A547BD44A44025402C8
+776F:00207E20427E7EA448247F284810652843461FF010101FF010101FF010101FF0
+7770:008800887BFE488848A878204BFE4840788048FC49844A847884488400FC0084
+7771:000003DE7A424A424A427BDE4A004A3E7BD24A124A144BD47A084A1402240242
+7772:000001FC790449FC490479FC4820492079FE4A20482049FC7820482003FE0000
+7773:002000207BFE485048887B2649FC482078204BFE4800482079FC4820002003FE
+7774:000003FE7A2248204BFE782049FC492479FC492449FC48207BFE482000200020
+7775:012801247BA4492049207FFE482048247BA44AA84AA84A907B92482A00460082
+7776:004000407BFC484049F878804BFC49107A084DF64910491079F04910011001F0
+7777:00200020F0FC9E2493FEF22494FC9420FEFC922092209BFEF420962009FE1000
+7778:000003FC7A244A244BFC7A004AFC4A847A844AFC4A844AFC7A844A8404FC0884
+7779:004000447BF4484848507FFE4840488079FC4B044D0449FC7904490401FC0104
+777A:008000BC7884490849FE7B204D20497C7990491049FE49107928492801440182
+777B:004000207BFE4A024C0479FC480049FC790449FC490449FC7904480003FE0000
+777C:000001FC7904490449FC7904490449FC78004BFE48204920793C492002A0047E
+777D:001003D478584A52498C788849044AFA782048204BFE48207850488801040202
+777E:040008007FFC44447FFC01003FF80100FFFE082004403FF80100FFFE01000100
+777F:010001F801007FFE40029FF4092032900C603FF8D0161FF010101FF010101FF0
+7780:7E20243E1848FFA829104A28984600001FF010101FF010101FF010101FF01010
+7781:000003FC7A044BFC4A047BFC4A044BFC785048484FFE484078A0491002080C06
+7782:022807243C24242024FE3F2024202F3C29342F5429542F54298849884F148922
+7783:0008001C79F04910491079FE4910497C7944497C4944497C79444A44027C0444
+7784:008800887BFE48884888780049FC49247924492449FC49247924492401FC0104
+7785:008801C8F7089108912AF12A97AC9148F308938895549514F914912401240142
+7786:0020002079FC492449FC78204FFE480079FC4904492449247924485000880304
+7787:001000927A5249544910787E48104B38795449924910491079104A80047E0000
+7788:0090008879044A424C8879FC480448007BDE48424A52494A7A524842014A0084
+7789:1000FE7810487C480048FE8682007CFC00447C4444287C2844107C2844447D82
+778A:002000107BFE4A204AFC7A244BFE4A247AFC4A204AFC4A847A844C8404FC0884
+778B:002000207BFE482049FC790449FC490479FC490449FC49047BFE488801040202
+778C:0020002079FC482048207BFE488049047BFE48024BFC4A947A944A9407FE0000
+778D:0140065CF4449444975CF444944497FCF04097FC92089110F0A0904001B00E0E
+778E:004000207BFE4A024C2479FC482049FC78204BFE482049FC7904490401FC0104
+778F:7FFC44447FFC01001FF001007FFC00001FF010101FF0048808503820CB180C06
+7790:1FF810081FF810081FF810081FF800007E7E42427E7E42427E7E42427E7E4242
+7791:000003FE7A02480049FC790449FC490479FC484048204BFE7800488801040202
+7792:01080108F7FE91089000F7FE90909090F7FE94929492956AF6469402040A0404
+7793:02020122782A4FEA482A7BAA482A4BAA782A4BAA4AAA4AAA7BAA4AAA00420082
+7794:002003FE782049FC48207BFE480049FC790449FC490449FC790449FC00880104
+7795:002001FC788848504BFE780049FC490479FC490449FC48207BFE482000200020
+7796:7F7848485F4C64805F784A4851307F4C00001FF010101FF010101FF010101FF0
+7797:0040008079FC490449FC790449FC490079FE490049FE48027AAA4AAA0202000C
+7798:000003FE7A004A7C4A447A444A7C4A007AEE4AAA4AAA4AAA7AEE4A0003FE0000
+7799:008800887BFE4888480079FC490449FC790449FC48204BFE7850488801040202
+779A:004000207BFE4A02480079FC482049FC792449FC492449FC7800488801040202
+779B:01240124F22494249954F14A92929610FA109250925C9250F25092B0029E0300
+779C:002001FC79244BFE492479FC482049FC792449FC48404BFE788849D00070038C
+779D:004000207BFE480049547924495449FC78204BFE4A424A927AFA4A0A02020206
+779E:008800887BFE4888488878F848204BFE7A224B324AAA4B767A224A22022A0224
+779F:000003FE785049FC4954795449FC480079FC48004BFE482078A8492402A20040
+77A0:0020012478A84BFE4A0278F84888488878F84820482049FC7820482003FE0000
+77A1:0200027CF2449744927CF2449244977CF2449244927C9228F528954A084A1086
+77A2:0820FFFE08203FF824483FF800007FFE40029FF410101FF010101FF010101FF0
+77A3:0020002079FC492449FC78204BFE4A227BFE4820484048247AA24A8A04780000
+77A4:00007BDE4A524BDE4A527BDE4A024AFA7A224A724A224A227AFA4A02020A0204
+77A5:082049202A3E7F4849485DA86B10492843461FF010101FF010101FF010101FF0
+77A6:002003FE782049FC480079FC490449FC78884BFE480049FC7904490401FC0104
+77A7:00A0009079FE49104B107DFE4910491079FE4910491049FE79004AA402520452
+77A8:00A004A4F2A890A097FCF11090A097FCF04093F8904097FCF0A0911002080C06
+77A9:000007FCF40497FC9400F5FC942095FCF52495FC942097FEF62A96FA0A0A1206
+77AA:002007A4F0A892929114F20895F49802F3F89208920893F8F20891100FFE0000
+77AB:000003FE78504BFE4A527BFE480049FC790449FC490449FC78204BFE00200020
+77AC:003C07C0F04492249108F7FE94029A08F20893BE94889AA8F13E920804080808
+77AD:00400040F7FC90A09514F20897FC9A0AF3F8920893F89040F248944409440080
+77AE:02080108F7C89210949EFFD490649794F494979494949788F488949404A405C2
+77AF:03DE7A524BDE4A524BDE7A024AF24A927AF24A924AF24A927A924B3202020206
+77B0:00080788F08891109FDEF49494A49794F4949794949494C8F7889C9400A400C2
+77B1:008803FE7888480049FC78A848A84BFE78A848A849FC48207BFE482000200020
+77B2:000003FC784848304BFE785248944B5078204BFE4A524A8A7B764A5202720206
+77B3:002001FC788848504BFE780049FC492479FC492449FC482079FC482003FE0000
+77B4:0080008079FE4B544D5479544BFE4954795449544FFE48007954492A022A0000
+77B5:00400248F15097FC9150F24894449208F20893BE94889AA8F13E920804080808
+77B6:002001FC792449FC48207BFE480049FC790449FC490449FC790449FC00880104
+77B7:00007BDE4A524BDE4A527BDE4A024AFA7A8A4AFA4A8A4AFA7A8A4A02020A0204
+77B8:008803FE7888480049487BFE49484978790049FC48204BFE787048A803260020
+77B9:003C03C0F04492249108F7FE944292A4F28A947A908090F8F10892900060079E
+77BA:004000A0F3189DF69000F7FC955494E4F7FC900093F89208F3F8920803F80208
+77BB:010001F87A084FFE4A887B244BFE4A007AFC4A004AFC4A007AFC4C8404FC0884
+77BC:0040004078A049104A087DF6480048007BB84AA84AA84BB87910491002A80444
+77BD:0810FF7E08107E7C42447E282418FEE600001FF010101FF010101FF010101FF0
+77BE:00003EF822883EF822883EF822883EF801007FFC482410102FE8010001007FFC
+77BF:3EF822883EF822883EF822883EF808801FFC30805FF890801FF810801FFC1000
+77C0:028802A8F6A89BF0901EF22495D49C14F41495D495549548F568955406140422
+77C1:00C80708F12A912C9FC8F10893889554F914912290409024F522950A090800F8
+77C2:01FC0104790449FC48007BDE4A524A527BDE48204BFE487078A8492406220020
+77C3:004000207BFE4A224954794A4A3A480079FC49544BFE480079FC482000A00040
+77C4:001C01E078204BFE482079FC49AC497479FC482049FC48207BFE48000154022A
+77C5:000003DE78424A52494A7A52489049087BFE4D1049FE491079FE491001FE0100
+77C6:008803FE78A8489049FE7B2049FC492079FC492049FE49007BFC48880070038E
+77C7:008803FE78884BFE4A0279FC48004BFE784048A24B5448B87B54489203500020
+77C8:004001FC790449FC490479FC48204BFE7A8A49244BFE488078FC488401140208
+77C9:004000207BFE4A0249FC79484A5049FC7B0449FC490449FC790449FC00880104
+77CA:01080110F23E922294BEF722913E9208F4BE97AA902A90AAF56A952E04080008
+77CB:000003FE7A484BFE4A487AFC4AA44AFC7AA44AFC4A204BFE7B2A4D7A050A0906
+77CC:002000107BFE4A444AFE7A444BFE4A107AFE4A924AFE4A927AFE4A0002440482
+77CD:7CF844887CF844887CF809001FF831005FF091001FFC10003FF0082007C0F83E
+77CE:010001F87A084FFE4A627A9249FC490479FC490449FC488079F84A880070038E
+77CF:004001FC79244994494C792449FC48207BFE4A8A49244BFE788048FC0104020C
+77D0:01FC78204BFE4A224DAC782049AC489079FE4B204DFC492079FC492001FE0100
+77D1:0040007C78404BFC4A447BF04A444AFC7AA84AF84AA84AF87A004DFC05540BFE
+77D2:010807FE79084BFC4A947BFC48004FFE7C0249F8490849F8790849F8010801F8
+77D3:011078904BDE48104A5E79824BDE48107BDE4A504BDE4A507BDE4A50025202CE
+77D4:00887BFE48884BDE4A527BDE48A0489079FE49204BFC4D2079FC492001FE0100
+77D5:21084FD2F03C23884812FBBE0280ABAA00001FF010101FF010101FF010101FF0
+77D6:03DE78004BDE4A524B5A7A5248204BFE7A504BFE4A524BFE7A924ADC029204CE
+77D7:01003FF801000FE00820092009207FFC08207EFC08203EF822882AA82AA8FFFE
+77D8:02480150F7FC940491F0F11097FC9554F4E497FC904097FCF0409FFE02A40452
+77D9:0FBE08A2EFBEA8A2AFBEE802AB92A892EFDEAAAAABCAAAAAEB92AAD20FAA08C4
+77DA:03FE02027BFE4A924A547A924AFE4AAA7AFE4B224AFA4AAA7AFA4A2205FA0004
+77DB:00001FF000100220014000807FFE018202840480088010802080C08002800100
+77DC:00207E200250245018880944FE220A20180019FC280448088808081028101020
+77DD:00207C200450285010880924FE121A1029FC2804480848888850082028101010
+77DE:1FF0022001407FFC04841888628001003FF82448282837D82448244827C82018
+77DF:00107C9204522854101008FEFE821A8228FE2882488248FE88820882288A1084
+77E0:00487C48044829FE10480848FFFE1A0028FC2884488448FC8884088428FC1084
+77E1:03DEFA520BDE525223DE10A0FDFE372035FC512051FE500091FC10885070278E
+77E2:0800080008001FF81100210041000100FFFE010002800280044008203018C006
+77E3:02000400082010103FF8080808001FF0210001007FFC0280044008203018C006
+77E4:00407C40048004FC05207E204020402043FE7C20045004500488048829041202
+77E5:20002000207C7E444844884408440844FF44084414441444227C224442008000
+77E6:080008001FE020204040BFFC240024002FF8308020803FFC414042208410180C
+77E7:200421E43C245024902411E41104FF04110411E4102428242424442441448084
+77E8:2008203C21E07C205020902013FEFC2010201050105028502488448841048202
+77E9:200021FE3D005100910011FC1104FF041104110411FC29002500450041FE8000
+77EA:2010202020FC7C8450A490941094FDFE108410A4109428942484450441148208
+77EB:2008203C21E07C20502093FE1050FC881104128A108828882488450841088208
+77EC:2020202021247D245124912412AAFC721020102011FC28202420442043FE8000
+77ED:200021FE3C00500090FC10841084FE8410FC1000108428442448440041FE8000
+77EE:201C21E03C20502093FE10A81124FE42104013FE1088290824D0443040488184
+77EF:201821E03C4053FE908811741252FE70100011FC11042974255445744104810C
+77F0:210420883C0053FE922212AA1272FE2213FE100011FC290425FC450441FC8104
+77F1:208823FE20A87C9051FE932011FCFD2011FC112011FE290027FC44884070838E
+77F2:200023FE42527A52A3FE2110225223DCF81223CE224023D2525C4BD04A5282CE
+77F3:0000FFFE020002000400040008000FF81808280848088808080808080FF80808
+77F4:00000000FEFE1010101020103E1062106210A210221022103E10221000500020
+77F5:00040004FE041044104420443E4462446244A244224422043E04220400140008
+77F6:000001F0F9102110211041107910C91049104910491049127A124212040E0800
+77F7:000001FCFC041008101020203C2067FE6420A420242024203C20242020A00040
+77F8:000001FCFC201020102020203C2067FE6420A420242024203C20242020200020
+77F9:00000000FDFC1090109020903C9064906490A490249024923C922492210E0200
+77FA:0008003CFDE01020102020203C20643E65E0A420242024223C222422201E0000
+77FB:00400040FE8010FE110022003CF86410A4202440244024823D02250200FE0000
+77FC:00000000FDFC1020102020203C2064206420A420242024203C20242023FE0000
+77FD:00400040FC40107E108220823D4266246414A408240824103C20244020800300
+77FE:000001F0F9102110211041107990C95049504910491049127A124212040E0800
+77FF:00200010FC1010FE108020803C8064806480A480248024803C80250021000200
+7800:000001F8FC101020104020803DFE64926492A492251225223E22244220940108
+7801:000001F8FC081008108820883C8864FE6402A402240225FA3C02240220140008
+7802:00200020FC2010A810A420A23D2265206624A424242824083C10242020C00300
+7803:000000FCFC84108410A420943C94648465FEA484248424843C84250421140208
+7804:00200020FC2011FC102420243C24642465FEA420245024503C88248821040202
+7805:00200020FC201020103221B23CB464A864A8A4A8252425243E22242020A00040
+7806:00200020FC20102011FC20203C20642067FEA420245024503C88248821040202
+7807:00400020FC2013FE108820883C8864886488A450245024203C50248821040602
+7808:000001FEFD001100117821483D4865486548A568255025423D422542223E0400
+7809:010001007FFC01003FF801007FFC01007FFC040008003FF0C81008100FF00810
+780A:00400020FC0011FC100020003CF064906490A490249024923C922512210E0200
+780B:00100010FC101090109020903C9E64906490A490249024903C90249023FE0000
+780C:00000100F97E21122112411279D24F12C91249124952499279224822004A0084
+780D:00400040FC40107C108420883D2064206420A450245024503C88248821040202
+780E:00200020FC501050108821043E0264886488A488248824883C88250821080208
+780F:00100050FC501050108820883D0466FA6448A448244824483C88248821280210
+7810:000003FCF884208820884090789CC88449444944492849287A10422804440182
+7811:000003FCF8102110211041107A10CBFE48304850489049107A10441000500020
+7812:00100110FD101112111221143DD865106510A510251025123D522592210E0000
+7813:000000F8FC881088108821063E0065FC6484A484244824503C20245020880306
+7814:000001FCFC881088108820883C8867FE6488A488248824883C88250821080208
+7815:00400040FDF810481088208A3D0A66266420A42027FE24203C20242020200020
+7816:00200020FC2011FC102020403DFE64406480A5FC240424883C50242020100010
+7817:00400040FC4013FE108020A03D2065FC6420A420242027FE3C20242020200020
+7818:00200020FC2013FE102021243D2465246524A5FC242424203C222422201E0000
+7819:00000000FBFC2100210041F079104910C9904A504A504A107A124A920312020E
+781A:000001FCFD041104112421243D2465246524A554245024903C9025122212040E
+781B:00200020FC501050108821443E2264206400A5FC240424083C08241020100020
+781C:000003F8FA082208232842A87AA8CA484A484AA84AA84B2A7C0A440A08061002
+781D:00200020FC2011FC102020203C2065FE6420A420244024483C8425FE20820000
+781E:00200020FC2013FE102020203C2065FC6470A4A824A825243D24262220200020
+781F:00800080FC8010FE114021403E40647C6440A4402440247E3C40244020400040
+7820:000000F8FC881088108820F83C8864886488A4F8248824883C88248823FE0000
+7821:00000000FDFC1020102020203C20642065FCA420242824243C24242023FE0000
+7822:00000000FDFE1008100821E83D2865286528A52825E825283C08240820280010
+7823:00200010FC1011FE110222043C8064886490A4A024C024823C822482207E0000
+7824:00800080FCFE1100122021203D2C657467A4A524253425283D22250220FE0000
+7825:0004001EFDF01110111021103D1065FE6510A510251025083D0A254A21A60112
+7826:088008882E9028E028842E84F07C00007FFC040008003FF0C81008100FF00810
+7827:00200020FC201020103E20203C20642065FCA504250425043D04250421FC0104
+7828:00400020FDFC1104110421FC3D006500657CA508251025203D422682227E0400
+7829:00900090F89023FC209440947BFC4A90CA904BFE48924892791A491402100410
+782A:000000FCFC8410A4109420843C8467FE6504A544252425043DFE240420280010
+782B:00400020FC0013FE102020203C20642065FCA420242024203C20242023FE0000
+782C:00400020FC20100011FE20003C0464846484A448244824483C50241023FE0000
+782D:0004001EFDE01000102020103DFE64046408A410242024403C802540223E0000
+782E:10001000FEFC2244642818102428C2C60000FFFE08001FF82808C8080FF80808
+782F:00200020FD2010A0103221B23CB464A864A8A4A8252425243E22242020A00040
+7830:000001FCFC201020112420A43CA8642067FEA420242024203C20242020200020
+7831:00200020FC501050108821243E12641065FCA404240824883C50242020100010
+7832:00800080FDFC1104120425F43D1465146514A5F4250425283D12250220FE0000
+7833:00000000FEFE1020102020403E7C62C462C4A3442244224422443E7C22440000
+7834:00100010FC1011FE111221143D1065FC6544A544252825283D10262822440482
+7835:00200020FC20102011FE20203C70647064A8A4A8252426FA3C20242020200020
+7836:00200020FC4011FC110421043D04650465FCA504250425043D04250421FC0104
+7837:00200020FC2011FC112421243D2465FC6524A524252425FC3D24242020200020
+7838:000003FEFA102210221042FE7A924A92CA924A924A9A4A947A104A1003FE0000
+7839:01100110FBFC2110211040007A08CA084910491048A0484078A0411002080C06
+783A:000001FEFD001100110021FE3D206520653CA524252425243D24224402540488
+783B:04400420FFFC0910116021844F0480FC0000FFFE08001FF82808C8080FF80808
+783C:00200020FC501050108821043E02640065FCA420242024203C20242023FE0000
+783D:000001FCFD241124112421FC3D2465246524A5FC252425243D2425242104020C
+783E:0008001CFDE01100112021203D2065FE6420A42024A824A43D22262220A00040
+783F:00200010F81021FE2100411079104910C9104920492849247A444AFE04420800
+7840:00200020FD241124112421243DFC64206420A524252425243D24252421FC0004
+7841:000001FCFC081010103020483C8467026400A5FC242024203C20242023FE0000
+7842:00200020FC501088110422023DFC64206420A42025FC24203C20242023FE0000
+7843:00200120FD2011FC112022203C2067FE6470A4A824A825243D24262220200020
+7844:00200020FD2410A410A820203DFE64906490A490249024923D122512220E0400
+7845:00200020F9FC2020202040207BFE4800C820482049FC48207820482003FE0000
+7846:00200020FC501050108821043EFA64006400A4F8248824883C88248820F80088
+7847:00200020FC4011FC110421043D9465546524A524255425943D04250421FC0104
+7848:00200020FC2013FE102020203DFC64006400A5FC250425043D04250421FC0104
+7849:00200020FDFC102413FE202421FC7C206420A5FC2420242027FE3C2024200020
+784A:00400040FCFC1104120821FE3D00657C6544A544255425483D422542213E0200
+784B:00200010FC1013FE102020423C8465F86410A42224C427083C10242820C40302
+784C:00400040FC781088115020203C5064886506A4F8248824883C88248820F80088
+784D:000001F8FD08110811F821083D0865F86544A548253025203D10254821860100
+784E:000207E2FA42224A224A424A7A4A4FEACA4A4A4A4A4A4A4A7A424C42044A0844
+784F:000001DCFC881088108820883C8867DE6488A488248824883C88250821080208
+7850:000001FEFD021102117A21023D02657A654AA54A254A257A3D022502210A0104
+7851:01040084FC88100013FE20883C8864886488A7FE248824883D08250822080408
+7852:000003FEFC50105011FC21543D5465546554A554258C25043D04250421FC0104
+7853:00400040FC4411F41048205023FE7C406480A584269824E024823C82247E0000
+7854:00880088FC88108813FE20883C8864886488A7FE240024883C84250422020402
+7855:000003FEFC20104011FC21043D0465246524A524252425443C50248821040204
+7856:00200020FC2011FC102021243CA464A86420A7FE245024503C88248821040202
+7857:00800080F8BC23C02050402478D44B0CC8004BFE4890489079124912020E0400
+7858:00000000FDFC1104110421743D5465546554A554257425043D0425FC21040000
+7859:00200124FD24112411FC20003DFC64046404A5FC250025003D02250220FE0000
+785A:0008003CFDE01020102023FE3C5064886504A68A248824883C88250821080208
+785B:00400020F82027FE2090409078904A94CA924A924C9248907910491002500420
+785C:000001FEFC001092112422483D2464926400A5FE242024203C20242023FE0000
+785D:00200124FCA410A8102021FC3D04650465FCA504250425FC3D04250421140108
+785E:00200120FD2011FC112022203C2067FE6400A40025FC25043D04250421FC0104
+785F:0004000EFBB8208820884128792E4BA8C8A84AA84AA8493E79004A80047E0800
+7860:00400020FDFC1104110421FC3D04650465FCA520252225143D08254421820100
+7861:00400020FBFE2202244440407BFE4840C8904890491049207A244A4204FE0842
+7862:00200020FC501088110422FA3C20642067FEA420252825243E22242220A00040
+7863:00200022FDFA1024102423FE3C10642065FCA488251026FE3C10241020500020
+7864:00200020FC2013FE102020203D2465246524A6AA242024503C50248821040202
+7865:00900088FC8013FE10A020A83CB064A464A8A4B02524252A3D32222202DE0400
+7866:000003FEFC20102011FC20203C2067FE6488A48827FE24883C88250821080208
+7867:000001F8FC0810D0102021FC3D24652465FCA524252425FC3D2425242124010C
+7868:00200020FDFE102011FC21243D2465FC6524A52425FC24203DFE242020200020
+7869:080C08F07E8008800EFE7888088829081208FFFE08001FF82808C8080FF80808
+786A:001000D8FB942094209043FE78904894C89448D84B98489078AA48CA02860102
+786B:00400020FBFC2040209041087BFC4804C9504950495049507A504A520452080E
+786C:000001FEFC20102011FC21243D2465FC6524A52425FC25203CA0244020B0030E
+786D:00480048FDFE1048104820203C1065FE6480A480248024803C80248020FC0000
+786E:00400040FC7C1084110822FE3C92649264FEA492249224FE3C922512210A0204
+786F:000001F8FD08110811F821083D0865F86508A50825F824903C9021120212040E
+7870:1020082040A824A4092A723010C017000000FFFE08001FF82808C8080FF80808
+7871:000001FCFD241124112421FC3D2465646574A5AC252425243D24250421FC0104
+7872:00000050FC481084112420203C5064886506A6F8248824883C88248820F80088
+7873:00200020F9FC2020202040207BFE4848C848494C494A4A4A7888488801280210
+7874:00880088FDFE1088108820503C5064946594A698249024B23CD22492208E0080
+7875:00200020FC3E1020102021FE3D02654A652AA5122512252A3D4A250221FE0102
+7876:00200124FD24112411FC20203C5064886544A622242025F83C08241020100020
+7877:00400040F8A020A0211042087DF64800C88848484A4849507910482007FE0000
+7878:00200124FD24112411FC20003DFE6500657CA510251025FE3D10221002100410
+7879:02080228F22822282FA442447254D69257105AA05A205228724452FC02440200
+787A:000001FEFC20104010A221123C3465586498A554243424523C90251020500020
+787B:00007EFC48447E4442287E1048287EC60000FFFE08001FF82808C8080FF80808
+787C:000003DEFA522252225243DE7A524A52CA524BDE4A524A527A524A52055208A6
+787D:00400080FBFC2110224844467BF84A48CA484BF84A484A487BF848420042003E
+787E:0008003CFDE0102013FE20A83CA864A867FEA4A824A827FE3C20242021FC0000
+787F:00400020F82023FE2202449479084A04C80049FC482048207820482007FE0000
+7880:00400040FCF81108101021FC3C24642467FEA424242425FC3C24242020A00040
+7881:08207FFC08200FE008200FE00820FFFE10103FF8C4060FE0182068200FE00820
+7882:00400020FBFE2202200041FC78004800CBFE4820492849247A224C2200A00040
+7883:00200020FBFE202021FC40207BFE4800C9FC490449FC490479FC490401140108
+7884:01100110F910211027BC411079104B38CBB84D544D5449927910491001100110
+7885:000003FEFA02221A22E242227A224BFECA224A724AAA4B267A224A2203FE0202
+7886:202013FC82244BF812882450E470298C2000FFFE08001FF82808C8080FF80808
+7887:00400020FBFE2202240440007BFE4820C8204920493C49207AA04A60043E0800
+7888:001C03E0FA2023FE222042927B0A4A06C9FC4904490449FC7904490401FC0104
+7889:000001FCFD241124117421243DFC65046574A554255425743D04220402140408
+788A:00480044FC5E11E0102820123C6A65966448A45E25E024243C282412206A0186
+788B:00200124FD24112411FC20003DFE640865E8A528252825E83D28240820280010
+788C:000001F8F808200821F8400878084BFEC8204A22497448A879244A2200A00040
+788D:000001F8FD0811F8110821F83C0065FC6410A7FE241025103C90241020500020
+788E:00400020FDFE1000108820883D5466226400A42027FE24203C20242020200020
+788F:00480048FC4811FE104820483DFE640064FCA484248424FC3C84248420FC0084
+7890:00200020F9FC2020202043FE78884944CA4248F849884A507820485001880606
+7891:00400080FDFC1124112421FC3D24654465FCA490251027FE3C10241020100010
+7892:00200020FC501088110422023CF864206420A5FC242025243CA424A823FE0000
+7893:00500048FC8010FE119022903CFC64906490A4FC249024903C9024FE20800080
+7894:0008000CFCEA100A100821FE3C4864486548A568254825483D4A256A23860102
+7895:00200020FDFC10501088210423FE7C0865E8A528252825E825283C0824280010
+7896:00200020FC501088110422FA3C0065FC6554A55425FC25543D5425542104010C
+7897:00400020FBFE22022504410079DE4A52CA524B524C9A4894791049120212040E
+7898:00500050FC5011FC115421543D5465FC6554A554255427FE3C00248821040202
+7899:000003FEFA02228A225243FE7A224A22CAAA4AAA4AAA4AFA7A024A02020A0204
+789A:00400020FDFC1000110820903C0067FE6400A40025FC25043D04250421FC0104
+789B:00200020FBFE202021FC40207BFE4800C9FC4904492449247924485000880304
+789C:00800090F90823FC204047FE79104A48CC864B10482048C47B08483000C00700
+789D:000003FEFC20104011FC21543D5465546554A52C242027FE3C50248821040202
+789E:00001FF010101FF000007C7C44447C7C0000FFFE08001FF82808C8080FF80808
+789F:00900290FA9027FE229042907AF0CA004BFC48404FFE48E0795042480C460040
+78A0:00400020FBFE200021FC410479FC4800CBFE4A0249FC48207820482000A00040
+78A1:002001FEFC2010FC102021FE3C0064FC64A4A49425FE24A43D1425FE20040018
+78A2:000000FCFC84108410F420943C9465FE6502A57A254A254A3D7A2502210A0104
+78A3:000001FCFD0411FC110421FC3C8065FE6622A522255225023DFA240220140008
+78A4:00880088FBFE208820A8402079FC4924C92449244BFE48207850488801040202
+78A5:00800040FBFC2204220443FC7A00CA004BFC4B544B544DFC7D5445540944010C
+78A6:00400020FBFE2202208040F879084A90C86049984E0649F87908490801F80108
+78A7:0020FE4010FC7C8410FC1E84F0FC00007FFC040008003FF0C81008100FF00810
+78A8:000001FCFD24112411FC21243D2465FC6400A7FE252025223D14254821840102
+78A9:000003FEFC20104011FC21043D0465FC6504A5FC250425043DFC240020880104
+78AA:00880088FBFE208820F8408878F84888C8884BFE490049487984490001FE0000
+78AB:00800338FA28222823A842467A004A7CCBA44A244A284BA87E104A2802440282
+78AC:000003DEFA422242224243DE7A004A3ECBD24A124A144BD47A084A1402240242
+78AD:000001F8F90821F8210841F878004BFEC90049FC4A544C9479244A4400A80110
+78AE:000001FCFD04110411FC21043D0465FC6400A7FE242025203D3C252022A0047E
+78AF:00920124FA4821242092404078804BFECA024A8A4A524A227A524A8A03FE0202
+78B0:01080090F80023FC2090409078924C92CA944A98489048907890489007FE0000
+78B1:00140012F01027FE2410441075D0D412541255D45554554875DA542A08461082
+78B2:00400020F9FC2000208840507BFE4A22CC2449FC492449247934492800200020
+78B3:00200124F924212421FC408078804BFEC890491049524A547AA84C2808440082
+78B4:00200020FBFE207020A841247A2249FCC90449FC490449FC7904480003FE0000
+78B5:00200020FC3E1020102021FC3D0465FC6504A5FC250425FC3C00248821040202
+78B6:0080009EFBEA208A21CA408A7BEA4892C8A648204BFE48207850488801040602
+78B7:0008001CFDF01110111021FE3D10657C6544A57C2544257C3D442244027C0444
+78B8:000007FCF404243425C4444475F4D554555455F45444545475F4549408061002
+78B9:00400020FBFE2202240441FC780049FCC90449FC490449FC7904480003FE0000
+78BA:00400040FBFE22A2209041FE79104B10CDFE4910491049FE7910491001FE0100
+78BB:00200010FDFE100010FC20843CFC640065FEA502257A254A3D7A2502210A0104
+78BC:000001FEF92021FC212041FC79204920C9FE48024AAA4AAA7AAA4A0200140008
+78BD:000001FCFC20102013FE20003DFC650465FCA50425FC25043DFC248821040202
+78BE:000001FEFD02110211FE21243D24657E6524A52425FE25523D54264822640442
+78BF:000003FEFA02220223FE42107A92CA544AFE4A824AFE4A827AFE4482048A0884
+78C0:02440124F928207E2010435479544954C97C49144920492079404A80047E0000
+78C1:01080088F09027FE210841087210D29454A4573851085210721054A407BC0084
+78C2:004003BEFA122292225242AA7B244840CBFE4A224A224BFE7A224A2203FE0202
+78C3:0004001EFBF0221E221042FE7A92CA984AF24A8E4A804AB87AA844AA054A0A86
+78C4:00200010FDFE1110117C21143DFE6514657CA510257C25443D442244027C0444
+78C5:00400020FBFC2108209043FE7A024C44C8204BFC488048F87888490801280210
+78C6:000001FCFD0411E4112423FE22027DFC6504A5FC250425FC25043D0425140108
+78C7:00200040FDFC1104115421243D54650465FCA400251225D43D1825522192010E
+78C8:00200040FBFC2224222443FC7A244A44CBFC484048A848B4793C49220222041E
+78C9:03F00110F0E02318200047BC74A4D31854A4504057FC50E0715052480C460040
+78CA:7FFC040008001FF0281048108FF000007EFE102020407EFCA34422443E7C2244
+78CB:00840044FC4811FE102020FC3C2065FE6440A48024FE25103E10241021FE0000
+78CC:00200020FBFE202021FC410479FC4904C9FC490449FC49047BFE488801040202
+78CD:00400020FBFE2202242441FC782049FCC8204BFE482049FC7904490401FC0104
+78CE:001E03E0FD2210941040208821F07C2064C4A5FE2422242027FE3C5024880306
+78CF:00880050FC0013FE105021FC3C5467FE6454A5FC245024D83D54265220500050
+78D0:08783E48228E2A007EF822482A3046CC0000FFFE08001FF82808C8080FF80808
+78D1:00200124FD24112411FC20003FFE640065FCA504250425FC3C88245023FE0000
+78D2:000000FCFC84108410FC20003DFE650265FEA50225FE25023DFE244820840102
+78D3:00100220F97C21442044407C7B404940C97C49444944497C79444A80047E0000
+78D4:02080208F3BE24882AA8413E7208D448584857FC50E0515072485C4600400040
+78D5:00200020FCFC1020102021FE3C40648465FEA40225FC25543D54255423FE0000
+78D6:000001DEFC42115210CA21523C42642064FCA484248424FC3C84248420FC0084
+78D7:00280024FBFE202021FC412479FC4924C9FC492448084BFE7888484800480018
+78D8:0008003CFBC020042244412879FC4A20C8204BFE482049247924492401FC0004
+78D9:00400020FBFE208821244242789049F8C808484448A849907A884CA400C20080
+78DA:002003FEFC2011FC112421FC3D2465FC6422A7FE240827FE3D08248820280010
+78DB:08047F7808407F40497E7F4849487F4808487F4808887FFC08001FF868080FF8
+78DC:01000110FBDC22542554428879084AF4CC0248004BFC484079504A4805440080
+78DD:00880088F88823D0209E43E478944FD4C91449D44954494879484A5402D40422
+78DE:00200222FA2223FE200043DE7A524A52CBDE4A524A524BDE7A524A52055A08A4
+78DF:000007BCF88424A4229444A478504988CE2648C04B1048647B88483000C00700
+78E0:00200020F83E2020202043FE7A024B26CA8A4A524B264A527A8A4B2603FE0202
+78E1:02480248F7E8224823DE424A73CAD24A524A5FEA540A554A7632541207EA0044
+78E2:00200020FBFE202022AA41247AAA4820CAAA49244AAA48507850488801040602
+78E3:00400088F9FC2108225243FE78504988CE2648C04B1048647B88483000C00700
+78E4:000000DCFB14221423D442547BE6CA404BDC4A144BD44A547A484448055408A2
+78E5:000001FCFD2411FC112421FC3C40648865F0A420244427FE3C22252422220060
+78E6:000003FEFC5011FC115421543DFC640065FCA40027FE24203CA8252422A20040
+78E7:002003FEFC2011FC102023FE3C0065FC6504A5FC250425FC3D0425FC20880104
+78E8:00803FFE22102F7C221027382AD422102FFC2100220027F84A08520883F80208
+78E9:000C000AF80823FE220842487A6ACA4A4BFA4A4C4A4C4AEC7B5A444A04D60822
+78EA:00200222FBFE2090208841FE7B104D10C9FE4910491049FE7910491001FE0100
+78EB:01240124F22424242954414A7292D6105A105250525C5250725052B0029E0300
+78EC:08007F7808483E4800863E782A483E304048FFFE08001FF82808C8080FF80808
+78ED:03FE0200FAFC220023FE42947AA8CAC44A004AFC4A844AFC7A8444FC0484088C
+78EE:00200124FD2411FC102020503C8865746602A5FC255425543DFC25542154010C
+78EF:01240124FAAA23AE212442AA7BAE4924CFFE4910491449147A8A4A4A02160422
+78F0:00880050FBFE202021FC40207BFE4924C8A84BFE480049FC7904490401FC0104
+78F1:008802AAFADC24882154422278004BFECA424C444BFC48447844488401140208
+78F2:0200017EF840247C224440FC79404E7ECA2048204BFE487078A8492402220020
+78F3:01040088F80023FE222242AA7A724A22CBFE480049FC490479FC490401FC0104
+78F4:002007A4F0A822922114420875F4D80253F85208520853F8720851100FFE0000
+78F5:000003DEFA5223DE225243DE7A024AFACA8A4AFA4A8A4AFA7A8A4A02020A0204
+78F6:0080031CFA042204239C42047A04CBFC49004BFE4C024AAA7AAA440200140008
+78F7:00200124F8A823FE20A841247A224904C90449DE4A444D54789E490402040404
+78F8:00880050FBFE205021FC4154798C4974C90449FC48204BFE7850488801040202
+78F9:000003FEFC5013FE125223FE3C0065FC6504A5FC250425FC3C2023FE00200020
+78FA:00880088FDFC1088108823FE3C2065FC6524A5FC252425FC3C00248821040202
+78FB:003C03E0FD2410A813FE20A83D24660265FCA524252425FC3D24252421FC0104
+78FC:00A00090FDFE132011FC21203DFC652065FEA500242027FE3C7024A823260020
+78FD:00200020F9FC202023FE41087B9C4908C9884E3E48004BFE789048900112020E
+78FE:000003DEFA52225223DE400079FC4924C9FC492449FC48207BFE482000200020
+78FF:3FFE21042E3822102FBC27182AB4325220002FFC210023F826085A0843F88208
+7900:03DE0252FBDE225223DE42027AF24A92CAF24A924AF24A927A924B3202020206
+7901:00A00090F9FE2110231045FE79104910C9FE4910491049FE79004AA402520452
+7902:002003FEFC2011FC100021FC3D0465FC6488A7FE240025FC3D04250421FC0104
+7903:012400A8FBFE220220F8408878F8480CC9F0482049FC48207BFE482000A00040
+7904:001801E0FC4013FE108821743E5264706400A5FC250425743D5425742104010C
+7905:02080108F7C82010279E449477A4D01457945094511451C87708511405240242
+7906:00200020FC501088110422FA3C00640065DCA554255425DC3C88248821540222
+7907:00400080FBFE222222AA42227BFE4A72CAAA4A0248204BFE7850488801040602
+7908:00440224F928207E201040287B4A491CC928494C491A492A7948491002FE0400
+7909:01080208F7C8245027DE446477D4D214511457D4521453C872485454055408A2
+790A:0878FFC808483E862B783E482A28FF9049287F4600007FFC08001FF868080FF8
+790B:000001FCFD5411FC102021FC3C2067FE6488A45025FC24203FFE242020200020
+790C:000001FCFC2013FE122221AC3C2065AC6400A5FC252425243DFC2524212401FC
+790D:008803FEFC8811FC110421FC3D0465FC6480A5FE262225523D0225FA200A0004
+790E:00880088FBDE208821DC42AA7C884800CBFE48224920493C79204AA0047E0800
+790F:00500252F954205023FE408878504BFEC82049FC48204BFE78A8492406220020
+7910:0A803138228838382288393822887FFE4002BFF404000FF0181068100FF00810
+7911:00200124FCA813FE120220F83C88648864F8A40025FC25243DFC252421FC0104
+7912:01040088FBFE202021FC40207BFE4854C99248904BFE489078D44B8A009601A2
+7913:000003FEFC0011FC112421FC3D2467FE6400A5FC252425FC3D2425FC200003FE
+7914:001003C8FA7E2240226243D47A004A3ECBC84A484E7E4A487A484BC802480008
+7915:3E1022FE3E4420287EFEA2103EFC22100000FFFE08001FF82808C8080FF80808
+7916:0140024CFA642244234C42647AA44BACCAA44AA44FFE48007910490802040404
+7917:00400020FBFE220221FC41487A5049FCCB0449FC490449FC790449FC00880104
+7918:000003FEFA0223FE220243FE79084A52CB9C49084A524BDE78004AA402520452
+7919:020002BEFB02225421C8403E7A0A4BCACD2849284FEE49287AA84A58044E0080
+791A:008803FEF888202021FC40207BFE4840C88849FC480049FC7954495407FE0000
+791B:000803E8FA8823EE222843F47A824BE2C80049FC495449547954495407FE0000
+791C:0A0033B822083BB820883AB82288FFFE10103FF8C4060FF0181068100FF00810
+791D:000001FCFC2013FE122221AC3C2065AC6400A7FE242025FC3D5425542154010C
+791E:008803FEF88823FE220241FC78004BFEC84048A24B5448B87B54489203500020
+791F:000007C4F51427C8250847D47514D50057D450545554554875485454005401A2
+7920:01080090FBFE2108210842527B9C4908CA524BDE484048A47AAA4A8A04780000
+7921:008803FEFC88102413FE20203DFC652465FCA52425FC25243C0825FE20880058
+7922:01080090FBFC204021F840807BFC4948C9FC4B0A4DF8490879FA4934018C0102
+7923:004801FEFC48100011FE214A3D4A65FE6414A5FE251025923D4C254A21160222
+7924:00880088FBFE2088211041DE7A524D54CA8849744A0249FC7820492402220060
+7925:07DE0512F7D2245427C8451477E2D00053FC520453FC520473FC520403FC0108
+7926:00200010FBFE224422FE42447BFE4A10CAFE4A924AFE4A927AFE4A0002440482
+7927:000001FCF92421FC212441FC79044800CBFE4AAA4AAA4BFE7AAA4AAA03FE0222
+7928:00001FF011101FF011103FF82AA83EF82AA83EF800007FFC08001FF868080FF8
+7929:0042039CFA1023DE229442947C204BFCCA044BFC4A044BFC7A044BFC01080204
+792A:000001FEFD2811FE1128217C3D54657C6554A57C251025FE3D9222BA028A0484
+792B:01240174FA5822DA23FE41547ADA4BFEC8A248204BFE487078A8492402220020
+792C:22882108FABE2008729CA92A2288FFFE08203FF8C4060FF0181068100FF00810
+792D:01FC0020FBFE222225AC402079AC4890C9FE4B204DFC492079FC492001FE0100
+792E:001007C8F53E27C0251447D27522D50057D450545554554875485454005401A2
+792F:008802AAFADC2488215442227BFE4A42C88849F048244BFE7822492402A20040
+7930:000007FEF4442598248847DE7488D5DC56AA54885420542074BC54A004A00BFE
+7931:08407F7C1440FF7C22043E7C22403E7C2242263E00007FFC08001FF868080FF8
+7932:01100090FBDE2010225E41827BDE4810CBDE4A504BDE4A507BDE4A50025202CE
+7933:00400020FBFE224823FE42487AEC4B5ACA484BFE4A204A7C7AC44B44047C0844
+7934:008803FEF088241222FE401074FED29252FE509251FE5292760452FE0244022C
+7935:01FC0020FBFE222221AC402079AC4800C89E4BF2489E49D27ABE4C92009E0092
+7936:008803FEF88823DE225243DE78A04890C9FE49204BFC4D2079FC492001FE0100
+7937:009007FEF89023E8228843CE7A504BD4CAA24BE248004BFC7A944A9407FE0000
+7938:052807BEF94827BE231845AA79464BFCCA044BFC4A044BFC7A044BFC01080204
+7939:07BC04A4F7BC200027FE44007590D49E57D4556455D4555475D455680BC81054
+793A:00003FF80000000000000000FFFE010001001110110821044102810205000200
+793B:200010001000F800080010001000380054009400100010001000100010001000
+793C:208010801080F8800880108010803880548094801080108410841084107C1000
+793D:2000100013F8F8880890109010A038BC54849484110411041104120412281410
+793E:202010201020F8200820102013FE382054209420102010201020102017FE1000
+793F:204010401080F8FC090412041004390454849444104410041004100410281010
+7940:2000100011FCF90409041104110439FC55049500110011021102110210FE1000
+7941:200010FC1084FC8804880890108838885484928410C410A81090108010801080
+7942:202010201020F920092C113411643BA455249534112811221122110210FE1000
+7943:200013F01010F81009101110111039FC54049404100413F41004100410281010
+7944:202010201050F850088811041202388854889488108810881088110811081208
+7945:2008103C11E0F8200820102013FE382054209450105010501088108811041202
+7946:2000100011FCF8200820102010203BFE54209420105010501088108811041202
+7947:2004101E11F0F91009101110111039FE5510951011101108110A114A11861102
+7948:2008101C11E0F9000900110011FE391055109510111011101110121012101410
+7949:202010201020F92009201120113C392055209520112011201120112017FE1000
+794A:204010201020FBFE08801080108038FC54849484108410841104110412281410
+794B:200010F81088F88808881106120039FC54849484104810501020105010881306
+794C:202010201020F82009FC112411243924552495FC112410201020102010201020
+794D:2008103C11E0F8200820102010203BFE54209420102010201020102011FC1000
+794E:202010201020FBFE0820102019FE3420502093FE10221022102A102410201020
+794F:2000100013FEF82008201040184034FC51849284148410841084108410FC1084
+7950:202010201020F8200BFE10401040388054FC9184128410841084108410FC1084
+7951:202010201120F92009FC11201220382057FE9420105010501088108811041202
+7952:200013FC1084F8840884110411143A08540095FC110411041104110411FC1104
+7953:205010481048F8400BFE1080108038FC55449544112811281210122814441182
+7954:208810881088F908097E13081508394855289528110811081108110811281110
+7955:200010401020F8280808108810903A9456A292A214C210881188128814781000
+7956:200011F81108F908090811F811083908550895F8110811081108110817FE1000
+7957:4008203C23E0FA2012201220222033FE6A20AA1022102212220A228A23262212
+7958:00003E7C0000000000007EFE081008102A542952495288900810081028501020
+7959:202010201020F9FC0820102010203BFE547094A810A811241124122210201020
+795A:208010801080F8FE094011401240387C544094401040107E1040104010401040
+795B:202010201020F9FC0820102010203BFE5420942010401048108411FE10821000
+795C:202010201020F8200BFE10201020382055FC9504110411041104110411FC1104
+795D:200013FC1204FA040A04120413FC3890549094901090111211121212140E1800
+795E:202010201020F9FC09241124112439FC55249524112411FC1124102010201020
+795F:0100111011101FF0410441047FFC00003FF80000FFFE01001110210845040200
+7960:200011FC1004F8040BF41004100439E455249524112411E41004100410141008
+7961:088008882E9028E028842E84F07C00003FF80000FFFE01001110210845040200
+7962:208010801080F8FE090211041220382054A894A4112411221222102010A01040
+7963:2080108010FEF9000A00101C11E0392055229524112811101110114811841102
+7964:200013DE1042F8420A52114A114A384254C6914A1252104210421042114A1084
+7965:210410841088F8000BFE1020102039FC5420902013FE10201020102010201020
+7966:200011FC1104F90409FC1000100039FC5420902013FE10201050108811041202
+7967:209010901090FA9209941098189035985294949210901090111211121212140E
+7968:00007FFC04403FF8244824483FF800003FF80000FFFE01001110210845040200
+7969:202011201120F9FC0920122010203BFE547094A810A811241124122210201020
+796A:2040104010FCF9040A0811FE1100397C554495441154114811421242123E1400
+796B:202010201050F8880904120211FC3800540095FC110411041104110411FC1104
+796C:200013FE1020F8400888110413FE38225420902013FE10201020102017FE1000
+796D:100010801EBC22445448A83010102FE8C00600007FFC01001110210845040200
+796E:202010201020FBFE0820102011FC3800540095FC110411041104110411FC1104
+796F:20201020103EF820082011FC1104392455249524112411241050104810841104
+7970:202011201120F9FC0920122010203BFE5400940011FC11041104110411FC1104
+7971:210410841088F81009FC11041104390455FC94501050109010921112120E1400
+7972:200011FC1004F8FC080411FC10003BFE560291F8108810881050102010D81306
+7973:200013FC1200FA000AF8120012003BFC56A092A412A812901290148814A418C2
+7974:201010141012F8100BFE10101150395457F4955411541148124A125A14261042
+7975:400023FE2222FA22122213FE222232626A72AAAA232222222222220223FE2202
+7976:410820882090FBFC1024102423FC32206A20ABFE206220A2212A222424202020
+7977:2020102013FEF82009FC104013FE3848548894FE110811481228140810281010
+7978:200011FC1104F904090411FC1820342053FE92221252128A130A1202120A1204
+7979:2080108010FEF9020A8210F21142384257FA94421152115211F2100210141008
+797A:2108110813FCF908090811F81108390855F89508110817FE1000109011081204
+797B:200011FC1104F924092411FC1124392455749554115411741104110411FC1104
+797C:200011FC1124F92409FC1124192435FC502093FE107010A81124122210201020
+797D:2040102013FEF8000888108811543A225400902013FE10201020102010201020
+797E:2020102011FCF820082013FE18883544524290F8118812501020105011881606
+797F:208010F81088F90809F01010181037FE50209222117410A81124122210A01040
+7980:0100FFFE00003FF8200827C8244827C820083FF800003FF80000FFFE11102308
+7981:082008207EFC1C702AA849268A2000001FF000000000FFFE0100111025084204
+7982:200011FC1124F9240974112411FC390455749554115411741104120412141408
+7983:4040204027FCF840104013F8220833F86A08ABF8220823F8220822082FFE2000
+7984:400021F82008F80811F81008200833FE6820AA22217420A82124222220A02040
+7985:210410881050F9FC0924112411FC3924552495FC1020102013FE102010201020
+7986:2040108013FCFA240A2413FC1A24364453FC9090111017FE1010101010101010
+7987:2040104413F4F848085017FE1040388055F89308150811F81108110811F81108
+7988:200013FE1222F8200BFE102011FC392455FC952411FC102013FE102010201020
+7989:208810481050FBFE0850105011FC39545554958C110411FC1104110411FC1104
+798A:4100213C27D4F9141394111427D43124694CA84027FE204020A0211022082C06
+798B:200013FE1050F85009FC11541154395455FC9420102011FC1020102013FE1000
+798C:408420442048FBFE108410842108314A6A52AB9C208421082108225223DE2042
+798D:200011FC1104F90409E4112411243BFE560292FA128A128A12FA1202120A1204
+798E:20201020103EF820082011FC110439FC550495FC110411FC1000108811041202
+798F:400023FE2000F9FC1104110421FC30006BFEAA22222223FE2222222223FE2202
+7990:203C17C01244F928080013FC1080388057FE950011F812881250142018D81306
+7991:21FC11241124F9FC0924112419FC3420502093FE1222122A12FA120A12021206
+7992:210011F81208FBF0081017FE10803944566894B01128166810A4112216A01040
+7993:200011F81108F9F8090811F810003BFE550095FC125414941124124410A81110
+7994:200011FC1104F90409FC1104190435FC500093FE10201120113C112012A0147E
+7995:2040104011FCF8840BFE100011FC390455FC902013FE1020122013FE10201020
+7996:2088108813FEF888088810F81088388854F8902013FE107010A8112412221020
+7997:200011FC1124F92409FC1124112439FC54009440102412A2128A148810781000
+7998:2040102011FCF8000888105013FE3A22542495FC112411241134112810201020
+7999:2050105213DCF85008D2134E100039FC550495FC110411FC1104110411141108
+799A:210410841088F8000BFE1020182035FC5020902013FE100012A4125214521000
+799B:2020102013FEF82009FC110411FC390455FC950411FC110413FE108811041202
+799C:08202AA44D28145022887FFE400280043FF80000FFFE01001110210845040200
+799D:200011FC1124F9FC092411FC18883544524290F8118812501020105011881606
+799E:2040102013FEF80009FC110419FC340053FE920212FA128A12FA1202120A1204
+799F:2020101011FEF910097C111411FE3914557C9510117C114411441244127C1444
+79A0:4004201E23F0FA1E121012FE229232986AF2AA8E228022B822A824AA254A2A86
+79A1:200011FE1120F9FC092011FC1120392055FE900212AA12AA12AA120210141008
+79A2:200011FC1104F9FC090411FC1800340053DE90421252114A12521042114A1084
+79A3:2028102413FEF82009FC112411FC392455FC9524100813FE1088104810481018
+79A4:200013FE1252FA520BFE100013DE38425652954A10C6135A10421042114A1084
+79A5:2088108813FEF88808F8108810F8388857FE9488112412FA1020102013FE1000
+79A6:020027DE491297D2211265DAA5142FD000003FF80000FFFE0100111025080200
+79A7:404027FC2040FBF8100013F8220833F86910AFFE200023F82208220823F82208
+79A8:4124212422AAFBAE112412AA23AE31246FFEA91021142114228A224A22162422
+79A9:400023FE2222FBFE122213FE208830886BFEA888208827FE2000208821042202
+79AA:200013DE1252FA520BDE100011FC392455FC952411FC102013FE102010201020
+79AB:200013FE1050FBFE0A5213FE100039FC550495FC110411FC102013FE10201020
+79AC:202010501088F9740A0211FC112439AC552495FC100010F8108810F8108810F8
+79AD:408824482250F8FC10201050269432386A50AA98223422542290222025FE2800
+79AE:409023FC2294FBFC129413FC200033FC6800ABFC220423FC2108209027FE2000
+79AF:409023FC2294FBFC129413FC200033FC6A00AAF8220023FE2520251425482986
+79B0:400023FE2124FA2217FE1222237632AA6B76AA22237622AA23762222222A2204
+79B1:404027FC2040FBFC100017FE200233F86840AFFE200027FE200827FE24A82798
+79B2:200013FE1248FBFE0A4812FC12A43AFC56A492FC122013FE132A157A150A1906
+79B3:202013FE1000F9DC095411DC188837FE508893FE108817FE1094118816A410C2
+79B4:404020A021100208F5F610002EEE2AAA6EEEB0002FFE29222FFE2922292A2804
+79B5:400023BE2288FB9012BE13A2203E37E2693EA92225BE2514252225002BFE3000
+79B6:452827BE2948FFBE131815AA294633FC6A04ABFC220423FC220423FC21082204
+79B7:4100255E2384F90817DE11122392355E6912A81E21522FF2211E2280244C2812
+79B8:0100010001007FFC420442044404444448245FF4481440044004400440144008
+79B9:001000F83F0001001FF0111011101FF001007FFC410441245FF448144004400C
+79BA:00003FF8210821083FF8210821083FF801007FFC410441245FE4482440144008
+79BB:02000100FFFE00001450139014501FF001007FFC420444444FE4442440144008
+79BC:010001FC01001FF01450139014501FF001007FFC420444444FE4442440144008
+79BD:010002800C603118CFE60440139014501FF001007FFC420444444FE44424400C
+79BE:001000F83F000100010001007FFC038005400540092011102108C10601000100
+79BF:00701F80010001007FFC054009203118C006044004400440044008421042603E
+79C0:00701F80010001007FFC054009203118CFE60420044004780808080810506020
+79C1:04200E20782008200820FF40084018401C402A482A84488489FE088208020800
+79C2:00F83F0001000100FFFE0540092011102008C10401000280044008203018C006
+79C3:00701F80010001007FFC054009203118C0060FC00840084008441044203C4000
+79C4:04000EFC780408080810FF20082019FE1C202A202A2048208820082008A00840
+79C5:08081C3CF3C010401040FC401040307E3BC054405040904210421042103E1000
+79C6:08001DFCF02010201020FC20102033FE38205420542090201020102010201020
+79C7:08401C40F040104011F8FC4810483048394854C8544890A810AA110A12061402
+79C8:08201C20F02010201124FD24112431243924552455249124112411FC10041000
+79C9:00F83F0001007FFC01003FF80108FFFE01083FF80380054009203118C1060100
+79CA:00701F80010001007FFC054009203118C0E61F00010001007FFC010001000100
+79CB:08401C40F04010401144FD4411483250384054A054A090901110110812041402
+79CC:103811C010401440584053FC504090E010E0115011502A482444484240408040
+79CD:08201C20F020102011FCFD2411243124392455FC552490201020102010201020
+79CE:08101C90F09010881108FD04120435FA38885488548890881108110812281410
+79CF:08081C3CF1E010201020FC3C11E038203420503E53E09020102210221022101E
+79D0:08001C00F1FC10001000FC0013FE30203820544054409088110413FE11021000
+79D1:08101D10F09010901010FD10109038903410501E53F090101010101010101010
+79D2:08201C20F02010A810A4FCA2112231203A245424542890081010102010C01300
+79D3:08201C20F02013FE1020FC20102031FC38845488544890501020105011881606
+79D4:08801C40F04013FC1000FC0011F03110391055105510911211121212120E1400
+79D5:08101D10F11011121112FD1411D83110391055105510911211521192110E1000
+79D6:08041C1EF1F011101110FD10111031FE3910551055109108110A114A11861102
+79D7:08081C3CF1E010201020FC2013FE302038205450545090501088108811041202
+79D8:08001C40F02010281008FC8810903A9436A252A254C290881188128814781000
+79D9:08201C20F020102013FEFC201020302039FC5504550491041104110411FC1104
+79DA:08201C20F12410A410A8FC2011FC38203420502053FE90201020102010201020
+79DB:08101C10F01011FE1112FD14111031FC39445544552891281110122812441482
+79DC:08001DFCF10411041104FDFC11003140394455485570914011421242123E1400
+79DD:08381DE0F02010201020FDFC10203070387054A854A891241124122210201020
+79DE:08201C20F020102011FCFD2411243124392455FC552491241124112411FC1104
+79DF:08001DF8F10811081108FDF811083108390855F8550891081108110817FE1000
+79E0:08001DFEF01010101020FC20106838A435225222502090201020100013FE1000
+79E1:08501C48F048104013FEFC80108030FC39445544552891281210122814441182
+79E2:08201C20F05010501088FD241212301039FC5404540890881050102010101010
+79E3:08201C20F02013FE1020FC20102031FC387054A854A891241124122210201020
+79E4:08001DFCF02010201124FCA410A830203BFE5420542090201020102010201020
+79E5:08201C20F0201020103EFC201020302039FC5504550491041104110411FC1104
+79E6:01007FFC01003FF80200FFFE082010D02F08C1061FF005400920111061080100
+79E7:08201C20F02011FC1124FD2411243124392457FE542090501050108811041202
+79E8:08801C80F08010FE1140FD401240307C384054405440907C1040104010401040
+79E9:08201C20F120112011FCFD201220302039FE5420545090501088108811041202
+79EA:08041C1EF1F011101110FD10111031FE3910551055109108110A114A11A61112
+79EB:08401C50F048104017FCFC4010E038E035505150524894441842104010401040
+79EC:08001DFEF10011001100FDFC110431043904550455FC91001100110011FE1000
+79ED:08201C20F02E11F01120FD20112039FE3422546250A2912A1624102010201020
+79EE:08201C20F04010401088FD0413FE3002380055FC550491041104110411FC1104
+79EF:04000E0078FC08840884FF84088418841CFC2A842A0048488844088408820902
+79F0:08801C80F08010FE1102FD041220302038A854A4512491221222102010A01040
+79F1:08001DFEF1021102117AFD021102317A394A554A554A917A11021102110A1104
+79F2:08201C20F02011FC1020FC2013FE3008380855FE540890881048100810281010
+79F3:08081C3CF1E010201020FDFE10203020382055FC550491041104110411FC1104
+79F4:08201C20F05010881104FE0211FC3000380055FC550491041104110411FC1104
+79F5:08001DFCF10411241124FD2411FC312439245554554C918C1104110411FC1104
+79F6:0100410021FC0A441448E0A02110260800E01F0001007FFC05401930E10E0100
+79F7:08001DFEF02010401088FD0411FE30223820542055FE90201020102013FE1000
+79F8:08201C20F02013FE1020FC2011FC3000380055FC550491041104110411FC1104
+79F9:00801888709C11701110FB101510311039FE55105110911011101110117C1100
+79FA:08401C20F3FE12021000FC3813C038403440507C53C0904010421042103E1000
+79FB:08201C20F07C10841148FC30102030483990543E544291A41018101010601180
+79FC:08201D20F12011FC1120FE20102033FE387054A850A891241124122210201020
+79FD:08201D24F124112411FCFC40104038FC35045284504890501020104010801300
+79FE:08201C20F02013FE1242FC4410A038A235A4529854909088108410A210C01080
+79FF:08281C24F3FE10201020FDFC1124312439FC5524552491FC112411241124110C
+7A00:09841C68F03010C81304FC4013FE38A0352053FC552491241134112810201020
+7A01:01007FFC00001FF010101FF000007FFE400280741F800100FFFE05401930E10E
+7A02:08401C20F1FC11041104FDFC1104310439FC5520552291141108114411821100
+7A03:08041C1EF1E010021122FC94100039FC3408501053FE90101010101010501020
+7A04:08401C40F088110413FEFC02108831443A4254F8518892501020105011881606
+7A05:08101C90F08811081204FDFA11083108390855F854909090109011121212140E
+7A06:08001CFCF08410841084FC8410FC3800340055FE510291021102110211FE1102
+7A07:08001DFCF12411241124FDFC11243164397455AC552491241124110411FC1104
+7A08:08001DFCF10411FC1104FDFC1000380035FC5420502093FE1020102010201020
+7A09:08001DFEF020102011FCFD24112431FC3924552455FC912010A0104010B0130E
+7A0A:09081C88F09011FC1024FC2411FC3120392055FE546290A2112A122414201020
+7A0B:00000DFCF10411041104FDFC1000380035FC5420502091FC10201020102017FE
+7A0C:08201C20F05010881104FEFA102030203BFE5420552891241222142210A01040
+7A0D:08201D24F0A410A81020FDFC1104310439FC5504550491FC1104110411141108
+7A0E:09041C84F088101011FCFD041104310439FC54505450909010921112120E1400
+7A0F:08001DFEF04810481048FDCE11023102390255CE504890481048104813FE1000
+7A10:08201C20F05010881104FEFA100031FC3954555455FC9154115411541104110C
+7A11:08201C20F1FC10201020FDFE108831043A22542051FC90201020102013FE1000
+7A12:08001DFCF10411241124FDFC1124312439745554555491741104110411FC1104
+7A13:08881C88F08813FE1088FC8817FE300039FC5504550491FC1104110411FC1104
+7A14:08201C20F05010881144FE2211F838083450542050A49282128A128A14781000
+7A15:08401C20F3FE100011FCFD0411FC380035FC5408501093FE1020102010A01040
+7A16:08801C40F1FC10001108FC88109033FE3800540055FC91041104110411FC1104
+7A17:08401C80F1FC11241124FDFC1124394435FC5490511093FE1010101010101010
+7A18:08881C88F3FE10881088FCF81088388834F85488508893FE1000108811041202
+7A19:08201C20F3FE10201020FDFC110431FC390455FC550491FC1104110417FE1000
+7A1A:08A01C90F09011FE1110FF1015FE3110391055FE55109110111011FE11001100
+7A1B:10003BFEE202221A22E2FA22222233FE6A226272A2AA23262222222223FE2202
+7A1C:10203820E1FC20202020FBFE208831446A4260F8A18822502020205021882606
+7A1D:10003BDEE25222522252FBDE225232526A5263DEA252225222522252255228A6
+7A1E:08001DFCF124112411FCFD24112431FC382057FE547090A81124122210201020
+7A1F:0100FFFE00003FF8200827C8244827C820083FF800001FF00100FFFE0920711C
+7A20:08001DFCF12411241174FD2411FC310439745554555491741104120412141408
+7A21:08401C20F3FE10001088FC88115432223800542053FE90201020102010201020
+7A22:10143812E01027FE2010F81023D232526A526254A3D4200820EA271A22262042
+7A23:2008203C7DE0442088207C2055FE54207C70546854A87CA401221C20E0204020
+7A24:08401C20F3FE10001000FDFC1104310439FC5420552891241222142210A01040
+7A25:00701F8001007FFC054009203118C006149022481FF010101FF010101FF01010
+7A26:08401C40F1FC108413FEFC0011FC390435FC502053FE9020122013FE10201020
+7A27:08801C9EF3EA108A11CAFC8A13EA389234A6502053FE90201050108811041602
+7A28:08401C20F1FE11021102FDFE1100390035FE55AA51AA92FE12AA12AA14A21086
+7A29:08001DFEF12211FE1122FDFE100030FC388454FC548490FC1084108410941088
+7A2A:09001D00F1FE120015FCFD0411FC310439FC548054FC91081290106011981606
+7A2B:08001DFEF00010FC1084FC8410FC300039FE5522552291FE1122112211FE1102
+7A2C:08001DFCF020104011FCFD54115439543544552C502093FE1050108811041202
+7A2D:09101D12F1D411181152FD92112E304039FC5504550491FC1104110411FC1104
+7A2E:08081C3CF1E0102013FEFC2011FC312439FC552455FC902011FC102013FE1000
+7A2F:08001C88F25212221252FE8A12023BFE34885144527A90881150102010D81706
+7A30:08001DFEF0121090109CFC90117E320038FC548450FC908410FC108410941088
+7A31:081E1DE0F04411241088FC2011FC3924352455FC5124912413FE110411141108
+7A32:08041C1EF1E010221112FC941080313E39225522553E912211221122113E1122
+7A33:08401CF8F108121011FCFC04100439FC3404540451FC9040102412A2128A1478
+7A34:08881C50F00011FE1050FDFC105433FE385455FC545090D81154125210501050
+7A35:08841C44F04813FE1084FC841108314A3A52579C508491081108125213DE1042
+7A36:08141C12F01013FE1014FC18139032B43A98569053B2900C10CA171A10661002
+7A37:08001DFCF12411FC1124FDFC108831443A4254F8518892501020105011881606
+7A38:08401C20F3FE10401088FDF01020304439FE540255FC912411FC112411FC1104
+7A39:08201C20F3FE102011FCFD0411FC390435FC550451FC910417FE108811041202
+7A3A:10003BFCE204220423FCFA40222033FC6A886250A3FE222025FC242028202020
+7A3B:081E1DE0F02211121094FC80102031CE3902550255CE91021102110211FE1102
+7A3C:08401C20F3FE12021000FDFC104030A23B345458509493341052109013501020
+7A3D:08501C48F3FC10A01122FE1E111031E0390454FC540091FC110411FC110411FC
+7A3E:01007FFC08200FE000007FFC48244FE440045FEC01007FFC05401930E10E0100
+7A3F:08401C20F3FE100011F8FD0811F8380037FC520452F49294129412F412141208
+7A40:1000FE7810487C480048FE8682007CFC00447C441028FE283810542892441182
+7A41:08881C88F1FE10881000FDFE1088308838F8548854F89088109E11E810081008
+7A42:08201C20F3FE102011FCFD2411FC392435FC5440502492A2128A148810781000
+7A43:08401C20F3FE12021050FC88112430503888550452FA90881088108810F81088
+7A44:11003910E3DC22542554FA88210832F46C026000A3FC20402150224825442080
+7A45:08201C10F1FE1110117CFD1411FE3914357C5510519291541138125412921430
+7A46:08201C40F1FC110411FCFD0411FC38203524563250C093181060118C103013C0
+7A47:10403888E1FC21082252FBFE205031886E2660C0A31020642388203020C02700
+7A48:010000803FFE22102F7C26382B543292203827C020402FFE215042484C468040
+7A49:08001DFEF10211FE1110FD541138395435825550517C9190111012FE12101410
+7A4A:1000E7BE2488248827A8FCA824A837BE6C106518A49825A826AA244A20462080
+7A4B:10003BDEE0422252214AFA52202830C46B126060A188203221C4201820602380
+7A4C:2008203C79E0482090207C2055FE54207C70546854A87CA40122AA20AA200020
+7A4D:08201DFEF02011FC1020FDFE100031FC390455FC550491FC110411FC10881104
+7A4E:40004CFE7010442044FC3C8400840CFC708410FCFE84108438FC544890841102
+7A4F:08081C3CF1C010441124FCA811FC300438FC540455FC904010A412AA128A1478
+7A50:1100E1F0222027F82A48FBF8224833F8684067FCA44427FC244427FE2042203E
+7A51:08201C20F3FE10201124FCA813FE300039FC5504557491541174110411FC1104
+7A52:00701F800100FFFE05401930E20E1FF010101FF010101FFC10001FFC0004492C
+7A53:10003BFEE22223FE2222FBFE208830886BFE6088A08827FE2000208821042202
+7A54:0088188871FC10881088FBFE102031FC392455FC512491FC1000108811041202
+7A55:08A01C90F1FE132011FCFD2011FC392035FE5500502093FE107010A813261020
+7A56:0124192472AA13AE1124FAAA13AE31243BFE551051149114128A124A12161422
+7A57:08201C20F3FE102011FCFD2411FC392435FC502253FE9042102412A2128A1478
+7A58:08201C20F1FC102013FEFD08139C31083988563E500093FE109010901112120E
+7A59:08501E52F154105013FEFC88105033FE382055FC502093FE1050108811041602
+7A5A:08181DE0F04013FE1088FD7412523070380055FC55049174115411741104110C
+7A5B:08901C88F1FE11101310FDFE1110391035FE5510511091FE110012A412521452
+7A5C:08201DFCF088105013FEFC0011FC312439FC552455FC902011FC102013FE1000
+7A5D:100039F8E10821F82108F9F8200037FE6A4063DCA25423D4226827C820542062
+7A5E:08801CF8F11013FC1524FDFC112431FC380057FE540091FC110411FC110411FC
+7A5F:1088E448225020FC2020F850269432386A506298A23422542290222025FE2800
+7A60:08501DFCF15411FC1154FDFC100031FE3900557C550091FE1150115411481266
+7A61:0020182073FE11241124FAAA17FE300039FC5504517491541174110411FC1104
+7A62:08201D3CF12017FE1010FC1413FE32103BF05654525492D41368144A18961322
+7A63:10803840E7FE21102208FD1423F831106BF86110A7FC212823102D4821862100
+7A64:08001DFCF02013FE1222FDAC102031AC380057FE502091FC115411541154110C
+7A65:11403A4CE2642244234CFA6422A433AC6AA462A4A7FE20002110210822042404
+7A66:08401C20F3FE120211FCFD48125039FC370455FC510491FC110411FC10881104
+7A67:10803840E7FC211020A4FF58255435526B586000A20823F8220823F822082408
+7A68:0C2071FC1124FDFC10203BFE540091FC010439FC290429FC29044DFC48888104
+7A69:103EE7C02244212823F8F84027FC30006BF86008A3F8200823F82544252A28FA
+7A6A:10003BFEE124222227FEFA22237632AA6B766222A37622AA23762222222A2204
+7A6B:00881BFE70A8109011FEFB2011FC312039FC552051FE910013FC10881070138E
+7A6C:10403820E7FE248825FCFC8827FE34206DFC6524A5FC252425FC240024882904
+7A6D:08801DF8F20815FC1124FDFC112431FC3954562A55FC910411FC110411FC1104
+7A6E:08401C20F3FE125013FEFE5213FE32003A9456D8529092D2128E140015541A2A
+7A6F:00201BFE702013AE12AAFBAE102033FE380057FE520292FA128A12FA120213FE
+7A70:1040E7FC200023B822A8FBB8211037FC691067FCA1102FFE212823102D482186
+7A71:001E1BE07122109413FEFA5213FE30043BC4567E53C4925413CC128412D41348
+7A72:13DE3800E3DE2252235AFA52202033FE6A5063FEA25223FE229222DC229224CE
+7A73:1528E7BE294827BE2318FDAA294633FC6A0463FCA20423FC220423FC21082204
+7A74:0200010001007FFE400280440440044004200820082010101010200840048002
+7A75:020001007FFE40028824101020081FE000C0030004000800100810080FF80000
+7A76:020001007FFE400288241210220802003FE002200420042008221022201E4000
+7A77:020001007FFE400288241010220802007FF00210041004100810101020A04040
+7A78:020001007FFE400288241010220804000FF0101068200440028003001C00E000
+7A79:020001007FFE482290142FF8001000101FF0100020003FF80008000800500020
+7A7A:020001007FFE400288241010200800001FF0010001000100010001007FFC0000
+7A7B:020001007FFE4002882410102FE80100010001007FFC01000100010005000200
+7A7C:020001007FFE400288241010210801007FFC0540092011102108C10601000100
+7A7D:020001007FFE48229014282808203FF8082008200820FFFE0820102010202020
+7A7E:020001007FFE48229014200800F03F0001000100FFFE0280044008203018C006
+7A7F:020001007FFE4822901400003FFC0040104020403FFE01400640184061400080
+7A80:020001007FFE482291142108FFFE01002108210821083FF8010A0102010200FE
+7A81:020001007FFE4002882411102148012001007FFC01000280044008203018C006
+7A82:020001007FFE48229014210811001FF8210041000100FFFE0100010001000100
+7A83:020001007FFE48229014200021FC2C44F0442044204424842884310422280410
+7A84:020001007FFE4822901428080FF81400240047F00400040007F8040004000400
+7A85:020001007FFE4822901420081FF0101010101FF010101FF0101010101FF01010
+7A86:020001007FFE4822901401F03E00020001007FF8006001800E003000480087FE
+7A87:020001007FFE4822901408001FF020105F90109010901F901050102410040FFC
+7A88:020001007FFE482290140840084012F822487C480848144822887E8821280210
+7A89:020001007FFE4822901420081FF0010001003FF8210822882448280820282010
+7A8A:020001007FFE4822901420781FA012201220122012101290224822A843248202
+7A8B:020001007FFE4822901421081110111011101FF001002108210821083FF80008
+7A8C:020001007FFE4822901420080C0070FC4084448444845C846494488808801080
+7A8D:020001007FFE48229014200800007DFE1040108011FC10041E04E00440280010
+7A8E:020001007FFE4822911422081FF010101210115010201FFC000400047FD40008
+7A8F:020001007FFE48229014100009FC4820202020200BFE10207020102010A01040
+7A90:020001007FFE4822901401003FF801000100FFFE000001003FF801000100FFFE
+7A91:020001007FFE48229014200808001FF821000100FFFE0100210821083FF80008
+7A92:020001007FFE4822901400007FFC040008201FF0011001003FF801000100FFFE
+7A93:020001007FFE482292142408082010103FF80008010008844892481287F00000
+7A94:020001007FFE4822921401007FFC08201010244844440280010006C01830E00E
+7A95:020001007FFE4822901404404448245024600C403460C852084A1042203E4000
+7A96:020001007FFE4822911409000FF011000100FFFE00001FF0101010101FF01010
+7A97:020001007FFE4822921404003FF8220823C824482A882108228824083FF82008
+7A98:020001007FFE482290143FF80408FFFE04083FF808001FF8280848088FF80808
+7A99:020001007FFE4822911C0FD00120FFFE01001FF0082030C0CFFC008002800100
+7A9A:020001007FFE4822909400883FFC208020883E88225022502A244454418C8604
+7A9B:020001007FFE4822901420083E2001FE00247E4414E81410146A2586240243FE
+7A9C:020001007FFE4822911401003FF821083FF801007FFC41047FFC410401000100
+7A9D:020001007FFE482290142FE8082008200FE001003FF821082288244820082018
+7A9E:020001007FFE4822941427E8082010402678180810081E78100810081FF81008
+7A9F:020001007FFE482290143FF820083FF820802490249027F02080488848888FF8
+7AA0:020001007FFE482290143FF811101FF011101FF00100FFFE054009203118C106
+7AA1:01007FFE482290143EF8020814D00820145062883EF80288145008203458C286
+7AA2:020001007FFE4822901400500048FFFE00403E4022243E2800120E2A70C60302
+7AA3:020001007FFE4822921401007FFC0820145022880100FFFE0100010001000100
+7AA4:020001007FFE482290143FF810081FF810081FF82080208C3EF020822682387E
+7AA5:020001007FFE48229014000011FC7D0411241124FD241154285024904112860E
+7AA6:020001007FFE482291142FE801007FFC048412880900FFFE0260041018086004
+7AA7:020001007FFE4822911401FC01003FF820083FF820083FF80100FFFE01000100
+7AA8:020001007FFE4A2291143FF808200440FFFE00001FF010101FF010101FF01010
+7AA9:020001007FFE482290143FF810101F9010907FFC40044FE448244FE44004400C
+7AAA:020001007FFE48229014004023F81040804047FC10002040E3F82040204027FC
+7AAB:01007FFE4822901408007F7C08243E2408447F5408880200FFFE04401830E00E
+7AAC:020001007FFE492292940C6037D8C0063E0822483E4822483E48220822282610
+7AAD:020001007FFE4822911409207FFC05401930610C0400FFFE08201E4003C03C38
+7AAE:01007FFE4822901408003F7C21043F04217C3F4021407F7C05041904E5280210
+7AAF:020001007FFE48229014244802803FF801001FF001007FFC0000248822444244
+7AB0:01007FFE4822901401F87E002208111020003FF841000100FFFE010021083FF8
+7AB1:020001007FFE4822909411F822886870ABAE282029FC282028A8292422A42040
+7AB2:020001007FFE48229014080049482A280808FF48182E2CF84A08880808080808
+7AB3:020001007FFE48229014061C38E828A82CA82AA82AA82AA828A455545D748212
+7AB4:01007FFE4822901401007FFC01001FF010101FF010101FF01010FFFE10102008
+7AB5:01007FFE482294141FF010101FF010101FF010001FFC10001FFC492484940008
+7AB6:01007FFE482291143FF82108FFFE21083FF811101FF00400FFFE082007C07838
+7AB7:01007FFE482290140040FD9E4952495279524952795249DA5D54E89008900910
+7AB8:01007FFE4822901400F83F0011100920FFFE09203118C20609002908282447E4
+7AB9:01007FFE4822901405FC242024F83C48044805FE7C0024FC2484248444FC8484
+7ABA:020001007FFE48229014000011F87D0811F81108FDF8110829F824904112860E
+7ABB:01007FFE4822911402003FF8220827E82A48218826483FF801004884481287F2
+7ABC:01007FFE48229114222011101FF011101FF011101FF001007FFC05401930E10E
+7ABD:020001007FFE4822901422203C20213E1F4220943F104810FFA8142822444182
+7ABE:01007FFE4822901408207F20083E3E4200943E1000107F1008282A2849441882
+7ABF:01007FFE4822911479F04A9050606198560649F04A406BF8544043F8404047FC
+7AC0:020001007FFE4822901401F8FD0811F8110851F85D0851F850905C90F112060E
+7AC1:01007FFE4822901401F03E0003F03E0003FA7E0201FE0C20703C1DE2F0221C1E
+7AC2:01007FFE482291147FFC044028281FF02828CFE608200FE00100111025080200
+7AC3:01007FFE492297D401007FFC11101FF011103FF821083FF821083FFA010200FE
+7AC4:01007FFE4822961438F820083CF820083FF80000294825282948252A29463182
+7AC5:01007FFE482290143E2022203E3E22443EA408247F2810281E1022282A444482
+7AC6:01007FFE4822901408003E7C22443E44227C3E0022FEFE8212822282CAFE0482
+7AC7:01007FFE492297D401003FF824483FF810101FF010101FF010101FF008201010
+7AC8:01007FFE492297D401007FFC00001FF012903EF822883EF822883EFA028201FE
+7AC9:01007FFE4822901408407E7C2440FF7C00047E7C42407E7C42407E7C4242463E
+7ACA:01007FFE482290140C40707C104055FC39241154FD0433FE3A22564A92FA1206
+7ACB:02000100010000007FFC000000101010082008200440044004800000FFFE0000
+7ACC:1000080008F07E9000900490449044902490289028900E92F0924112010E0200
+7ACD:1020082008207E200020042047FE44202420282028200E20F020402000200020
+7ACE:020001003FF8000008200440FFFE0000044004407FFC04400840084010402040
+7ACF:1008083C09E07E2000200420442047FE2420282028200E20F020402000200020
+7AD0:100008F808887E8800880506460045FC2484288428480E50F020405000880306
+7AD1:204010401040FC4003FE08408880889048904920512052481E44E48441FE0082
+7AD2:020001003FF8000008200440FFFE001000101F90109010901F90001000500020
+7AD3:1008081C08E07E200020043C44E044202420283E29E00E20F02240220022001E
+7AD4:200810681388FC880088088888888BFE48884888508850881D08E10842080408
+7AD5:201010901090FC88010809048A048DFA48884888508850881D08E10842280410
+7AD6:08004BF84A08491048A0484048B04B0C0A0001003FF8000008200440FFFE0000
+7AD7:1020082008207EA800A404A2452245202624282428280E08F010402000C00300
+7AD8:1040084008807EFE0102060244F244922492289228F20E92F002400200140008
+7AD9:1020082008207E20003E04204420442025FC290429040F04F104410401FC0104
+7ADA:204010201020FDFE01020A048800880049FE4820502050201C20E02040A00040
+7ADB:1020082008507E50008805244612441025FC280428080E88F050402000100010
+7ADC:020001003FF808200440FFFE00001FF011101FF011101FF01112010200FE0000
+7ADD:1020081008107EFE00000400448444842444284828480E10F01041FE00000000
+7ADE:020001003FF808200440FFFE00001FF0101010101FF00440044008423042C03E
+7ADF:020001003FF808200440FFFE00001FF010101FF010101FF0044008421042603E
+7AE0:020001003FF808200440FFFE00001FF010101FF010101FF00100FFFE01000100
+7AE1:100009FE08107E10002004FC44844484248428FC28840E84F084408400FC0084
+7AE2:202010401088FD0401FE0802888088FC4920482053FE50201C50E08841040202
+7AE3:204010401088FD0403FE0802888889444A4248F8518852501C20E05041880606
+7AE4:2040102013FE0202FC4400400BFE884088904890511051201A24E24204FE0842
+7AE5:020001003FF808200440FFFE00001FF011101FF011101FF001003FF80100FFFE
+7AE6:2020102013FEFC20002009FC8924892449FC4820507050A81D24E22240200020
+7AE7:1020084008F87E8800F8048844F8448A248C29F828180E28F048408803280010
+7AE8:20201020103EFC2001FC090489FC890449FC4924502053FE1C20E02040200020
+7AE9:2020101011FEFD02020408F88888888848F84888508850F81C88E08843FE0000
+7AEA:00007EFC48447E4442287E1048287EC6020001003FF8000008200440FFFE0000
+7AEB:2040104010F8FD08001009FC882488244BFE4824502451FC1C24E02040A00040
+7AEC:2004101E13E0FC2001FC0924892489FC48204BFE5222522A1EFAE202420A0204
+7AED:200011FC1104FDFC010409FC888089FE4A224922515251021DFAE00240140008
+7AEE:200013FC1204FE0403FC0A008A848A484AFC4A48524853FE1C48E44848881108
+7AEF:202011241124FD2401FC08008BFE8820484049FC515451541D54E1544154010C
+7AF0:100009FE09007F7C01540554457C45542554297C29100F10F17C4210021004FE
+7AF1:202013FE1020FDFC012409FC892489FC48224BFE500853FE1D08E08840280010
+7AF2:21041088100003FEFA2202AA0A728A228BFE480051FC510419FCE10401FC0104
+7AF3:201013D21054FD48008A09048AFA8C0049FC4904510451FC1D04E08847FE0000
+7AF4:2088105013FEFC5001FC0954898C8974490449FC500853FE1D08E08840A80010
+7AF5:200013FE100803BEFA8802A80ABE8B8888084BFE528A52521BFEE222022A0224
+7AF6:20201010FEFE44442828FEFE00007EFC428442847EFC28502A502C924912820E
+7AF7:1020FE7C44A42818FEE600107CFE44107C9044FE7C101020FE7C10C8103011CE
+7AF8:20201010FEFE44442828FEFE00007C7C44447C7C44447C7C28282A284C4A8886
+7AF9:10401040104010403EFE289049108A1008100810081008100810081008500820
+7AFA:104010401F7E289024884508800000003FF800000000000000000000FFFE0000
+7AFB:104010401F7E289024884508820002007FF80208040804080808100820504020
+7AFC:104010401F7E28902488450880000FE0082008200A200920092210222022401E
+7AFD:104010403F7E2890450880003FF801000100FFFE010001000100010005000200
+7AFE:104010401F7E2890248845088100117013901D10F11011501122110210020FFE
+7AFF:104010403F7E4890850800003FF8010001000100FFFE01000100010001000100
+7B00:104010403F7E4890850802000100FFFE0800080008000800080008000FFC0000
+7B01:104010401F7E289024884508800000003FF801000100010001000100FFFE0000
+7B02:104010403F7E28904508820002007FE002200A200420062009221022201E4000
+7B03:104010403F7E28904508BFF00010101010101FFC000400047FE4000400280010
+7B04:104010403F7E4890850800007FFC082008200820FFFE08200820102020204020
+7B05:104010403F7E28904508981006600180066018186C240240018006601818E006
+7B06:104010403F7E2890450880003FF82108210821083FF820002002200220021FFE
+7B07:104010403F7E289045088100008000007FFE0100012001100108010001000100
+7B08:104010403F7E2890450880003FE0082008400C780A081210112020C043308C0E
+7B09:104010403F7E4890950810001FF820084C088208006801881E08080800500020
+7B0A:104010403F7E28904508801000F81F2012201220122012102210220842048202
+7B0B:104010403F7E489085083FF002100210FFFE021004103FF0081010002000C000
+7B0C:104010403F7E489085083FFC0020102020203FFE012002200C203020C0A00040
+7B0D:104010403F7E4890850801003FF8210821082288244828282008200820282010
+7B0E:104010403F7E4890850800001FF0000000007FFC04400440044408441044603C
+7B0F:104010403F7E4890950810001FF8224842488488088811082208440808501020
+7B10:204020407EFE51108A0801007FFC000000000FE00820082008221022201EC000
+7B11:104010403F7E2890450880F03F0001000100FFFE01000280044008203018C006
+7B12:104010403F7E28904508828004400A203118C1061FE000200040004000800100
+7B13:104010403F7E489085082080208020883C9020A020C0208424842884307C0000
+7B14:104010403F7E4890850800F83F00010001F83F00010001FC7F020102010200FE
+7B15:104010403F7E2890450880001FF010101110111011101290149008823082C07E
+7B16:104010403F7E2890450880002410221021102110201024202830304821840602
+7B17:104010403F7E2890450888001FF02820444003801C70E30E00C00E0001800040
+7B18:104010401F7E289024884508810001FE010001003FF82008200820083FF82008
+7B19:104010403F7E28904508910011003FFC4100810001003FF8010001000100FFFE
+7B1A:20403F7E4890850800003FF8210821083FF8210821083FF82108010001000100
+7B1B:104010403F7E2890450881003FF82108210821083FF82108210821083FF82008
+7B1C:104010403F7E2890450880000100210821083FF801000100410441047FFC0004
+7B1D:104010403F7E489085083FF820082FC820482688210822882C4820083FF82008
+7B1E:104010403F7E48908508082010103FF8000800001FF01010101010101FF01010
+7B1F:104010403F7E2890450880781FA012201220122012101290224822A843248202
+7B20:104010401F7E2890248845088200010001007FFC00001010082004400000FFFE
+7B21:104010403F7E2890450880001FF0101010101FF010101FF010101010FFFE0000
+7B22:104010403F7E489085083FF8200820083FF8208020803FFC204020242C14300C
+7B23:20403F7E4890850808001FF020105F90109010901F901050102410040FFC0000
+7B24:20403F7E4890850800007FF80408080810502020DFF81008100810081FF81008
+7B25:104010403F7E2890450880003FF800087FE800081F88108810881F8810A80010
+7B26:104010403F7E489085080810081013FE30105110909010901010101010501020
+7B27:20403F7E4890850800001E78124812481248FFFE124812481248128826A84110
+7B28:104010403F7E4890850801007FFC03800540092011102FE8C106010001000100
+7B29:104010403F7E28904508885008481040307C57C09040102010201014100C1004
+7B2A:104010403F7E2890450880001FF0101010101FF0101010101FF00000FFFE0000
+7B2B:104010403F7E2890450881701F80110021003FFC0304050409043128C1100100
+7B2C:20403F7E489085083FF8010801083FF8210021003FFC030405041928E1100100
+7B2D:104010403F7E28904508828004400A203118C1061FE0002000400C8003000080
+7B2E:104010403F7E28904508880008001FFC2400440087F00400040007F804000400
+7B2F:104010403F7E28904508900011F8FE881288228824506450182018502488C306
+7B30:20403F7E4890850804403FF8044804481FF8144024403FFC0844105420484040
+7B31:104010403F7E4890950810001FF8200840089F88108810881F88000800500020
+7B32:104010403F7E28904508882010103FF8000808200820FFFE0820082010202020
+7B33:104010403F7E489085081000107C7E441244124412441244224422444A7C8444
+7B34:104010403F7E489085080000FFFE001000101F90109010901F90001000500020
+7B35:104010403F7E48908508100009F84908210825080528091071021102110210FE
+7B36:104010403F7E28904508880008001FF0210001007FFC0280044008203018C006
+7B37:104010403F7E489085080C0070FC4084448444845C8464944888088010806080
+7B38:104010403F7E2890450880003FFC2000200027F82408240827F8200020003FFE
+7B39:104010403F7E28904508822012201220FFFE1220122013E0100010001FFC0000
+7B3A:20403F7E489085080240022003F87E00020003FCFE10012000C007443834000C
+7B3B:104010403F7E2890450880007CFC10841084108410841E94F088408000800080
+7B3C:104010403F7E28904508804004207FFC04800488089008A010C223824C82807E
+7B3D:104010401F7E28902488450880003FF8244824482448244824482448FFFE0000
+7B3E:104010403F7E489085082080108017F8008870881108110812281410280047FE
+7B3F:20403F7E4890850808000FF010202C4003801C70E00E1FF0101010101FF01010
+7B40:104010403F7E2890450881003FF801000100FFFE000001003FF801000100FFFE
+7B41:104010403F7E2890454884403FF82448244824483FF82448244824483FF82008
+7B42:104010403F7E4890854820401258926843C84E480A48125AE242220221FE2000
+7B43:104010403F7E489085083FF8210821082FE8210822882448282820083FF82008
+7B44:104010403F7E4890850804404448245024600C403460C852084A1042203E4000
+7B45:104010403F7E48908508110011003FF841000100FFFE0440084010422042C03E
+7B46:104010403F7E489085083FF00110FFFE01103FF001003FF80100FFFE01000100
+7B47:104010403F7E2890450880007EFC088408880890088808840E84F0A840900080
+7B48:20403F7E4890850800F01F0001000100FFFE010001001FF0101010101FF01010
+7B49:20403F7E4890850801003FF801000100FFFE000000207FFC0820042004A00040
+7B4A:204020407EFE51108A0801007FFC08201010244844440280010006C01830E00E
+7B4B:104010403F7E489085083E20222022FC3E24222422243E24224442444A948508
+7B4C:104010403F7E289045088280044008203018CFE6010001001FF0010001007FFC
+7B4D:20403F7E4890950810001FF820085FC890481FC810481FC81048000800500020
+7B4E:104010403F7E489095081000FE7C124422442244644414440844147C2244C000
+7B4F:104010403F7E2890450888A00890108030FC57809048105010241054118C1604
+7B50:20403F7E4890850800003FFE20002FFC2080208027F8208020802FFC20003FFE
+7B51:104010403F7E4890850800007DF011101110119011501D12E2124212040E0800
+7B52:104010403F7E28904508BFF820082FE8200827C82448244827C8200820282010
+7B53:104010403F7E2890450880007EFC082008200820FEFE08200820102020204020
+7B54:104010403F7E2890450882800C603018CFE600001FF01010101010101FF01010
+7B55:20403F7E48908508100021FC4000880013FE3020502090201020102010A01040
+7B56:104010403F7E489085080100FFFE01003FF821082388255809201110610C0100
+7B57:104010403F7E489085081040104027FC6444A444244427FC2444204020402040
+7B58:104010403F7E28904508880008007EFC088408840E847884088408FC28841000
+7B59:104010403F7E4890850801007FFC01003FF80100FFFE054009203118C1060100
+7B5A:20403F7E48908508208020883EB020C42084267C39000100FFFE010001000100
+7B5B:20403F7E4890850808004BFE4820482049FC4924492449241134112820204020
+7B5C:104010403F7E289045089110092001007FF8000800083FF8000800087FF80008
+7B5D:104010403F7E2890450888001FF020205FF80108FFFE01081FF8010805000200
+7B5E:204020407EFE51108A0801003FFC2004410801007FFC054009203118C1060100
+7B5F:20403F7E4890850800F87F00221011203FE000400080FFFE0100010005000200
+7B60:104010403F7E28904508908010FC7D041204108410541C24E044418400280010
+7B61:204020407EFE51108A880440082037D8C10601003FF801001110210845040200
+7B62:104010403F7E48908508100011FCFD24112411241DFCF10011001102510220FE
+7B63:204020407EFE511088080608780808480848FF481C482A484948880808280810
+7B64:204020407EFE51108A0801001FF010101FF010101FF011081090126014181806
+7B65:104010403F7E2890450880001FF0101010101FF000003FF8200820083FF82008
+7B66:204020407EFE51108A0801003FFC20045FE800007FFC0440044008441044603C
+7B67:104010403F7E289045089FF010101FF010101FF010101FF0044008421042603E
+7B68:104010403F7E4890850802800C603118CFE6004000801FF0101010101FF01010
+7B69:104010403F7E489085083FE0044002803FF821083FF821083FF8210821282010
+7B6A:104010403F7E28904508BFFC20002FF828882FF828882FF8208020803FFE0000
+7B6B:104010403F7E2890450880003FF820083FF820083FF820083FF8082010102008
+7B6C:104010403F7E28904508809000883FFC208020883E48225022244A54448C8104
+7B6D:20403F7E4890850800003FF801001FF001007FFC00000820FFFE082010202020
+7B6E:104010403F7E4890850800007FFC01001110111011102928454485840100FFFE
+7B6F:104010403F7E489085283E20222022FC3E2422243E24222422442F44F0944108
+7B70:104010403F7E289045088880088010FE11403240547C90401040107E10401040
+7B71:104010403F7E4890850810401040247E24886488A54824502420205020882306
+7B72:104010403F7E48908508111009201FF010101FF010101FF01010101010501020
+7B73:104010403F7E4890850800387BC00840104023F8784008402BFC1000280047FE
+7B74:104010403F7E4890850801007FFC11101110292845440280044008203018C006
+7B75:20403F7E4890850800187BE00840104022787A400A402BFC1000280047FE8000
+7B76:104010403F7E4890850811001FF821000100FFFE00001FF0101010101FF01010
+7B77:104010403F7E48908508104011F818485448504853FE904010A0111012081406
+7B78:20403F7E489085081FF010101FF010101FF000003FF80100FFFE010001000100
+7B79:20403F7E4890850801007FFC02003FF80400FFFE08201FFC2420422080A00040
+7B7A:104010403F7E489085083FFE20002FFC2080208027F820A020902FFC20003FFE
+7B7B:20403F7E489085087FFC01003FF821083FF821083FF821001A00060019C0603E
+7B7C:20403F7E489085081FF0101010101FF000003FF820082108220804E01818E004
+7B7D:104010403F7E489085081FF010101FF000003FF80100FFFE028004401830E00E
+7B7E:104010403F7E2890450882800440082037D8C00602101110092008407FFC0000
+7B7F:104010403F7E289045088FE0144003801C70E10E01003FF80100111025080200
+7B80:20403F7E4890850810000BF8200827C82448244827C82448244827C820082018
+7B81:204020407EFE51108A0801003FF808200440FFFE00001FF0101010101FF01010
+7B82:104010403F7E4890850801007FFC11101110292845440380054009203118C106
+7B83:20403F7E4890850800007F0022FC3E4422443E44222822282F10F22842440282
+7B84:204020407EFE51108A0804003FF821083FF822083FF808801080FFFE00800080
+7B85:104010403F7E489085083FF821083FF821083FF80000FFFE0820082010202020
+7B86:20403F7E4890850800003FF8210822882448000020843E9820E020842684387C
+7B87:20403F7E4890850800003FF8210821082FE8210827C8244827C820083FF82008
+7B88:20403F7E4890850820801110120887FC4204500013F82208E208220823F82208
+7B89:20403F7E48908508100011F8FD08110815F8184033FCD0441084108451142208
+7B8A:104010403F7E4890952808207E50105010881F0612601210220022C04A308408
+7B8B:20403F7E48908508021002FC7F4000840764781C021002FC7F4000840764781C
+7B8C:20403F7E489085087F84100422247F24092408247F24082408240F04F0144008
+7B8D:20403F7E48908508100013FE1220FE2012FC12A41EA4F2A412B412A8522023FE
+7B8E:20403F7E4890850801F801003FFE210221F02F0420FC200027E044224822B01E
+7B8F:20403F7E4890850800FC7F00220811103FF80108FFFE01083FF8010805000200
+7B90:20403F7E4990BFF801001FF00100FFFE00001FF010101FF010101FF010101030
+7B91:20403F7E489085087FFC01003FF80108FFFE01083FF8110011F8290047FE8000
+7B92:20403F7E489085081FF000100FF000101FF000007FFE41029FF4111011501120
+7B93:20403F7E489085083FF000101FF00010FFFE111009A005401930E10E05000200
+7B94:104010403F7E48908528104009FC49042104250405FC09047104110411FC1104
+7B95:20403F7E48908508082008207FFC08200FE008200FE00820FFFE082010102008
+7B96:104010403F7E48908508082008207EFC08200C701A682AA44922882008200820
+7B97:20403E7E489080003FF820083FF820083FF820083FF80820FFFE082010202020
+7B98:20403F7E489085083FF8200820C8270821082FE823882548292821083FF82008
+7B99:20403F7E489085083EFC228422943E88228022FC3EA422A422A822904AA884C6
+7B9A:104010403F7E289045088C04122421245EA480243F242124212421043F142108
+7B9B:20403F7E48908508001C7DF00950115011501D503148D14811441254525A2468
+7B9C:20403F7E4890850801007FFE40028824101020081FF00100010001007FFC0000
+7B9D:104010403F7E4890850810881088FBFE108810881CF8F0881088108850F82088
+7B9E:20403F7E48908508111009203FF802007FFC082010102FE8C8260868080807F8
+7B9F:104010403F7E289045089FF810081FF810081FF82080208C3EF020822682387E
+7BA0:20803EFE491080F83F0001007FFC09200920FFFE092009207FFC010001003FF8
+7BA1:20403F7E4890850801007FFE40029FE410201FE010001FF0101010101FF01010
+7BA2:204020407EFE51108A0801007FFE400290041EF8228824A8549008841084607C
+7BA3:204020407EFE511088080804FFA408247F2449244B241C242A24490488140808
+7BA4:204020407EFE51108A0801007FFC08200820145022880100FFFE010001000100
+7BA5:20403F7E489085082020102013FC822442204BF80A881288E25024202450298C
+7BA6:20403F7E489085083FF801001FF001007FFC00001FF01010111002C00C307008
+7BA7:20403F7E4890850800003FFC208020802FF8249022A02FFC2140222024103FFE
+7BA8:20403F7E48908508100011FC1088FC70138E10201DFC3020D3FE102050202020
+7BA9:20403F7E489085083FF8244824483FF8020007F008103420024001800E007000
+7BAA:20403F7E48908508082004403FF821083FF821083FF80100FFFE010001000100
+7BAB:10401F7C28A045103FF80108FFFE01083FF80100254825282528292821084108
+7BAC:20403F7E4890850808207FFC08200200FFFE040008001FF02810C8100FF00810
+7BAD:20403F7E4890850810100820FFFE00003E4822483E4822483E0822082A282410
+7BAE:20403F7E50908A0801007FFE40029FF400001FF010101FF010101FF00000FFFE
+7BAF:20403F7E48908508080017FC304053F8924813F8124813F8114010C013301C0E
+7BB0:20403E7E48909FF820085FC890481FC810681FD000001FE00040FFFE01000300
+7BB1:104010403F7E28904508880008FC7E84088418FC1C842A842AFC4884888408FC
+7BB2:20403F7E489085281120092009FC422020202BFE08901090709011121112120E
+7BB3:20403F7E489085083FF820083FF8241022202FF8222022202FFC422044208820
+7BB4:104010403F7E2890452880243FFE20202FA420242FA8289828924FAA40468082
+7BB5:20403F7E489085081110216843841C00FFF010101FF010101FF010101FF01010
+7BB6:204020407EFE51108808087C7F440844087C3E442244227C22443E8422940108
+7BB7:104010403F7E4890A5481040FEFE212020AC3CB425E424AC24A044A25482887E
+7BB8:104010403F7E2890450882001FD00220FFFE03000FF03810CFF008100FF00810
+7BB9:20403F7E4890850810401440247C7884110424447E24002454044A048A280010
+7BBA:20403F7E489085087FFC01003FF80200FFFE08201FF02828CFE608200FE00820
+7BBB:20403F7E48908508004013F8204847FE884813F8304053FC904017FE10401040
+7BBC:20403F7E489085083FFC20043FFC20002FF8220024102FF820804FF84080BFFE
+7BBD:20403E7E48909FF001007FFC01001FF011101FF011101FF001003FF80100FFFE
+7BBE:20403F7E48908508080049042A247F2441247F2441247F244124410445144208
+7BBF:20403F7E489085081FF010101FF000007FFC10101FF010101FF0103EFFD00010
+7BC0:104010403F7E4890850800007E7C42447E4442447E44484444545A4862404040
+7BC1:204020407EFE51108A081FF010101FF010101FF000007FFC01003FF80100FFFE
+7BC2:20403F7E489085081FF010101FF010101FF021003FF841009FF00100FFFE0000
+7BC3:20403F7E489085083FF821083FF820002FF828082FF828084FF848088FF80808
+7BC4:20403F7E4890850808007F7C08447F4449447F4449547F480842FFC20842083E
+7BC5:20403F7E489085080100210821083FF80000FFFE02003FF82488248824A82010
+7BC6:20403E7E489088000FE010201FC00040FFFE06003B0804B019C062A00C987306
+7BC7:20403F7E4890850800803FFC20043FFC20002FFC292429242FFC49244924880C
+7BC8:20403F7E48908508080008087F0808FEFF08084808287F2808080F08F0284010
+7BC9:20403F7E489085087DF01110119011521D12E20E01007FFC054009203118C106
+7BCA:104010403F7E489085082090109013FC80904890489017FEE000209021082204
+7BCB:104010403F7E489085083FFC20802FF82080249024902AA83144222024103FFE
+7BCC:20403F7E4890850809F00810101037FC510091F81240104017FC10A01110120C
+7BCD:20403F7E489085080C20702010A410A4FCA83120382054505050908811041202
+7BCE:104010403F7E4890850800207C2044A87CA445227D22462844107C6001800600
+7BCF:104010403F7E489085282220223EFF42229422103E10221022283E2822440082
+7BD0:20403F7E48908508100013FEFE20122032FC3AA456A492A412B412A8122013FE
+7BD1:20403F7E489085081FF011101FF00100FFFE00001FF01010111002C00C307008
+7BD2:204020407EFE51108A880E603118DFE610201FE010201FE01008119014601810
+7BD3:20403F7E48908508111009207FFC05401930610C0400FFFE08201E4003C03C38
+7BD4:20803EFE49109FF010101FF000003FF820083FF820083FF820083FF808201010
+7BD5:20403F7E4890850801003FF801007FFC080010103FF800003FF824482448FFFE
+7BD6:20803EFE491080803FFC20802FF820883FFE20882FF820804FF848088FF80808
+7BD7:20803EFE491088801FFC30805FF890801FF810801FFC10003FF00C6003807C7C
+7BD8:20803EFE491090001FFC210451141FF4020814001FFC210451141FF404143808
+7BD9:20403E7E48908200FFFE00001FF010101FF000007FFC40044FE448244FE4400C
+7BDA:20403F7E489085083FFC224022403E7822402E7022403E78224022403FFC0000
+7BDB:20403F7E4890850800007EFC02047EFC40807EFC020422441A3462C414280810
+7BDC:20403F7E489085081FC000447D88055009203118C50602003FF8000024884244
+7BDD:20403F7E489085487FFC04403FF80440FFFE11101FF01110FFFE101010501020
+7BDE:20403F7E48908508200017FC140487FC440457FC104027FCE04020402FFE2000
+7BDF:20403F7E4890850808400FFC104033F8504097FE120813F8120813F812081218
+7BE0:20403F7E48908508108011F822886870ABAE282029FC282028A8292422A42040
+7BE1:20403F7E48909FF810101FF010101FF010101FF002007FFC04401A30E44E0FE0
+7BE2:20803EFE4910BFF801007FFC00001FF010101FF010101FF010101FF008201010
+7BE3:20403F7E489085083FF8082004407FFE420281043FF8040007F0081010502020
+7BE4:20403F7E4890850800001FF811001FF011001FF011001FFC0004292444940008
+7BE5:104010403F7E489085087FFC04403FF824483FF801007FFC05401930E10E0100
+7BE6:20403E7E489082003FF82448238824483FF8000020843E9820E020842684387C
+7BE7:20403F7E4890850804007FFC450408801FFC30805FF810801FF810801FFC1000
+7BE8:20403F7E48908508784048A05110620855F648404BFC68405150424845444080
+7BE9:20403E7E4890900023FE7C20442045FC7D2441247D24452445347D2844200020
+7BEA:20403F7E4890857C3F8020F820802FFC288428F02B882878480051E09224241C
+7BEB:20403F7E489085087DF0111011901D52E20E5FF001001FF001007FFC01000300
+7BEC:20403F7E4890850806C01A30E10E1FF010101FF010101FF010002FF848088FF8
+7BED:20403F7E50908A0801003FF80820FFFE00003FF821083FF821083FFA010200FE
+7BEE:20403F7E489085080480248024FC24A0251000003FF8244824482448FFFE0000
+7BEF:104010403F7E4890952810243C3E41E0BC20102E13F4FC281012106A15861802
+7BF0:20403F7E489085081000087C7F4422481450FFC800443E44225422483E402240
+7BF1:20403F7E489085080080FFFE0440139014501FF001007FFC44444FE44424400C
+7BF2:20403F7E489085081010FEFE10107C7C1010FEFE10103FF800081FF800083FF8
+7BF3:20403F7E489085083FF821083FF821083FF80920FFFE09203FF801007FFC0100
+7BF4:20403F7E4890850823FC10801144066870B01128166810A4112416A0284047FE
+7BF5:20403F7E489085081110211041108AA8144430405240927C1240154014FE1800
+7BF6:20403E7E4890FFFC010011F81100FFFE10001FF820003FFC0004492484940008
+7BF7:20403F7E4890850823F0151010E0071C704013F8104011F0104017FC284047FE
+7BF8:20803EFE491088201FF0102025487EFC04401930E64E1990062018C007003800
+7BF9:20403F7E489085081FF0149012501FF00200FFFE08203FD8C84608C0080807F8
+7BFA:104010403F7E48909528104011FC7D2411FC11441DFC7050109013FE50102010
+7BFB:20403F7E489085087FFC04403FF824483FF800003FF80000FFFE111025080200
+7BFC:20403F7E48908508120067DC444447C4444457DC60000440044008421042603E
+7BFD:20403F7E48908508140027DE4912811217D221126112A5D2251A25D42E102410
+7BFE:20403F7E489085083FF8244824483FF800903FFC208030482850242440D4830C
+7BFF:20803EFE4910FFFC01003FF821083FF821083FF801047FFC0020FFFE08200460
+7C00:20803EFE4910BFF801003FF80100FFFE10101FF010101FF010101FF008201010
+7C01:20403F7E489085081020213C4120892017FE300050209120113E112012A0147E
+7C02:20403F7E489085087FFC40A47FFC40845E9452945E64405446B459147FFC4004
+7C03:20403F7E489085280C4070FC13081090FC6030903B3E544255A4901810601380
+7C04:20803EFE4910BFF820083FF8200027F0241027F020002FF828884FF8480287FE
+7C05:20403F7E4890850800803FFC041002203FFE208024802FFC308047F840809FFE
+7C06:20403F7E50908A0801007FFE4022BE3C00207EF814081450142424D4440483FC
+7C07:20403F7E4890850820401040FEFE212020403CFC2520242025FE445054888906
+7C08:20403F7E489085083FFC20043FFC220824102F78241024103F7C441044108810
+7C09:20403F7E48908548224013F81440004077FC100013F8120813F8280047FE0000
+7C0A:20403F7E4890850808207FFC08200FE008200FE00820FFFE11102FE8C1063FF8
+7C0B:20403F7E489085081FF010101FF010101FF410881470180E3FF824482448FFFE
+7C0C:20403F7E489085080820FFA0083E7F42499449107F101C102A28492888440882
+7C0D:20403F7E489085083FF82108FFFE21083FF811101FF00400FFFE082007C07838
+7C0E:20403F7E489085081090109013FCFC9013FE10001DF8F10811F8110851F82108
+7C0F:20403F7E4890850800803FFE22203FFC22243FFC284028482F7048444B448C3C
+7C10:20403F7E4890850808207F20083E7F4249847F1049107F100828FFA808440882
+7C11:20403F7E489085087FFC00001FF01010FFFE10101FF0048808503820CB180C06
+7C12:20803EFE49109FF010101FF010101FF010101FF00200FFFE08203518CA2617F0
+7C13:20403F7E4890850800047F0849105D6049047F0841105D6255045D0845108260
+7C14:20403F7E489085087FFC00003FF81010FFFE10103FF8048808503820CB180C06
+7C15:20403F7E4890850822207F2022203EFC08247F2449247F240844FF4408940908
+7C16:20403F7E48908508040C55704E4044405F7E44484E48554844487F8800880108
+7C17:20403F7E489095080BF040902A94129275121250142001007FFC05401930E10E
+7C18:20403F7E489085083FF00110FFFC01103FF0092025482FE82388254829284108
+7C19:20803EFE4950804827FC204023F8FA4823F8224823F8224820102FFE211020B0
+7C1A:20403F7E489085087FFC444444447FFC0028FFFE08207F2449284D104A2A0846
+7C1B:20403F7E48908508220C2270FF4022403E40227E3E482248FF48224841488088
+7C1C:20403F7E4890850823F8120893F8420843F810002FFEE20027FC292422540488
+7C1D:20403F7E489085087FFC044028281FF02828CFE608200FE00100111025080200
+7C1E:20403F7E489085083EF822883EF800001FF011101FF011101FF00100FFFE0100
+7C1F:20403E7E4890FFFC04403FF824483FF810101FF010101FF00100FFFE01000100
+7C20:20403F7E489085283FF801001FF011101FF011101FF0111000003FF82448FFFE
+7C21:20403F7E489085083E7C22443E7C22443E7C200427E4242427E4242427F42008
+7C22:20403F7E489085083E7C22443E7C22443F7C20842FF420442244218426542008
+7C23:20803EFE49109FF011101FF001007FFC10101FF010101FF010101FF008201010
+7C24:20403E7E4890BFF824483FF800001FF010101FF010101FF010101FF008201010
+7C25:20403F7E4890850800701F800200FFFE082037D8C4463FF8200827C8244827D8
+7C26:20403F7E4890850800907EA00444282817D02008DFF610101FF0082004407FFC
+7C27:20403E7E489084403FF80440FFFE01003FF821083FF821083FF8082010102008
+7C28:20403F7E489085087CF844887CF842843E7C04403FF80440FFFE082010102008
+7C29:20403F7E4890850808202AA80820145022887FFC400402003FF8040808503020
+7C2A:20403F7E489085083E7C081048907EFE1428244A46863FF820083FF820083FF8
+7C2B:20803EFE4910BFF80108FFFE01083FF825483D7821083FF821083D7825484548
+7C2C:20403F7E48908508008078F849084A907860119812065DF8510851085DF8E108
+7C2D:20403F7E489085087FFC111029284544FFFE08203018DFF6101010101FF01010
+7C2E:20403F7E4890850808203EF808207EFC145022885FF410101FF010101FF01010
+7C2F:20403F7E489085081088108813FEFC8810F8388834F8508853FE908811041202
+7C30:20403F7E489085080820484049FC7D2441FC414479FC48A049204BFE48208820
+7C31:20403F7E48908508104808487EFC104810781E4812781248224823FE4A488484
+7C32:20403F7E4890850800203C4025FC25243DFC254425FC3C50249027FE54108810
+7C33:20403F7E4890850808107F2808443E82227C3E1022103EFE08107F1008100810
+7C34:20403F7E4890850801F801003FFE210221F02F0420FC292425285FFE42108408
+7C35:20403F7E489085081040FE7810887D5054207CD857067CF81088FE8810F81088
+7C36:20403F7E48908508200011F8FC0808F810083BFE5420953410A8112412A21040
+7C37:20403F7E48909FF820207FFEA4882BF4200027F8200027F8200047F8440887F8
+7C38:20403F7E4890850824102410FEFE24923C9024FC3CA424A4FEA8291045288246
+7C39:20403E7E4890911009203FFC20044FE808200FE000003FF821083FF821083FF8
+7C3A:20403F7E489085087FFE44429FF404403FF80440FFFE082011102FE8C1061FF0
+7C3B:20403F7E4890850821F8110811E8012873FC120412F4129412F412142A0847FE
+7C3C:20403F7E48908508211027FCF91027FC291037FEE24823F822482FFEA2084218
+7C3D:20403F7E5090890802800440183067CC00003EF8228822883EF8082014502288
+7C3E:20403F7E489085083FFC22203FFC22402FF822483FFC22482FF846604A50B24C
+7C3F:20403F7E4890854827FC104013F8824843F84A480BF81248F01027FC22102130
+7C40:20403F7E489085082080277CF4A425A436542088E7FC244427FC2444A7FC4404
+7C41:20403F7E4890850808207F3C08443E882A7C2A443E5408541C542A2848440882
+7C42:20403F7E48908508084014402AFE7F10A2103EFE22923E92289A24942A103010
+7C43:20403F7E489085083F2024203F3E21403F5024883F0800003FF824482448FFFE
+7C44:20403F7E4890BFFC208027F0249027F020803FFC241027F0241027F022203FFC
+7C45:20403F7E489085080A0033B822083A38238820883AB82288FFFE082010102008
+7C46:20803EFE491088207FFC09201FF831005FF091001FFC10003FF0082007C0F83E
+7C47:20803EFE491080803FFC00000FF008107FFE40029FF40100069839E00690398C
+7C48:20403F7E489085087F7C14207F20553855287F48086808587F4A084A0F6AF046
+7C49:20803EFE4910FFFE01003FF800001FF010107FFE48229FF401003FF80100FFFE
+7C4A:20803EFE4910BEF812480A28124808801FFC30805FF890801FF810801FFC1000
+7C4B:20403E7E489080007FFC21084104BFFA21083558292835582108355829283558
+7C4C:20803EFE4910FFFC01003FF80000FFFE00023FF00100FFFE00107DFC44907C30
+7C4D:20403F7E4890850810487CFC10487C4811FEFE0010FC388454FC948410FC1084
+7C4E:20403F7E48908508247C3A0422281E1020FE3E124850085E7F5014B0229E4100
+7C4F:20403F7E48908508208011FEFE8821FE20883CF8248824F8248845FE54888904
+7C50:20403E7E489080203D2424A825FC3C4027FE24883D2426AA247044A855248A62
+7C51:20403E7E48909FF0149012501FF00200FFFE09203FF8CA2609200FE808D00E38
+7C52:20403F7E4890850827FE20A0F7BC24A437BC20A067FCA44427FC2444A7FC4404
+7C53:20803EFE4910A03817C01248815047FC524814042BFAE24823F8224823F82208
+7C54:20403E7E489088007F204920FFBE49447FA42A243E281028FF1022281C446282
+7C55:20403F7E48908508104011BC1114FD5411AC304039FC552451FC912411FC1104
+7C56:20403E7E489084203F280424FFFE122073A4122473A812287392121A17A6F842
+7C57:20403E7E4890BFF801007FFE41029D7408801FFC30805FF890801FF810801FFC
+7C58:20403E7E489081243CA825FC24403DFE248825443E8A24F0242445FC54A88964
+7C59:20403F7E48908508100029F84408B8F810087DFE1020953450A81D24E2A24040
+7C5A:20803EFE491081F801003FFC21042FE0210827F8249027F024904FF849489FFC
+7C5B:20403F7E48908508109010882BFE4448B83211CE7C90108897FE50481C32E1CE
+7C5C:20403F7E4890850811FC1154FDFC102015FC182033FED08811FC102053FE2020
+7C5D:20403F7E489085087FFC10001FF808200FE079384FA87AA84AB8792A4AAA9C46
+7C5E:20403E7E4A90A7DE491297D2211265DAA5142FD000003FF80000FFFE11102308
+7C5F:20403F7E489095081080FEF811087EFC548454FC7C8410FC388454FC90481084
+7C60:20403F7E4890950808407E7C2440FF7C00047E7C42407E7C42407E7C4242463E
+7C61:20403F7E48908508104010A0FD1012E814061BB832A8D3B81110111052A82444
+7C62:20403F7E4890850808201420223E5D4480A47724552877282210222855448882
+7C63:20403F7E4890FD7C44447C7C44447C7C41045FF441045FF455545FF44544592C
+7C64:20403E7E4890912011282AA4FFFE122073A4122473A812287392121A17A6F842
+7C65:20803EFE491082800C6037D8C0063BB82AA83BB800003FF824883FF8248824B8
+7C66:20403F7E489085FC10202BFE4420B9FC11247DFC112495FC50201DFEE02047FE
+7C67:20403F7E489085F840802FFC28840BF0E8882BF829402AA8317022A851608FFE
+7C68:20403F7E4890850808201420223E5D4280847710551077102228222855448882
+7C69:20403E7E489087F8454824A827F80040EFFC2A1424882BF4210021F052108FFE
+7C6A:20803EFE49108882511C5DD048905DD0445E7FF451145DD448945DD444547FE4
+7C6B:20403F7E4890850828503E7C4890FEFE1528264A5FF6149012501FF008201010
+7C6C:20403F7E4890950808287F24147E494855C87F7E08487F7E514855485D7E4340
+7C6D:20403E7E4890BF7E12241B3412A43FFC22403FF822483FF828442F7848428F3E
+7C6E:20403E7E4890FFFC44447FFC10A0209045FE792013FC25207DFC012055FE8100
+7C6F:20403F7E489085087FFC10001FF808200FE07BB84AA87BA84AB87BAA492A9AC6
+7C70:20403F7E489085083EF822883EF822883FF831005FF091001FFC082007C0F83E
+7C71:20403E7E4890BFF801007FFE41029D7401001D7048907EFCC9907EFC48907EFC
+7C72:20403F7E4890850818FE24107E7C81447F7C55447F7C00447F7C55287F445582
+7C73:0100210811080910092001007FFC038005400540092011102108C10601000100
+7C74:06000100028004401830E10E1110092005407FFC0540092011102108C1060100
+7C75:081008104A102A102C100810FEFE18101C102A102A1048108810081008100810
+7C76:080008004AF02A902C900890FE9018901C902A902A90489288920912090E0A00
+7C77:0808081C4AE02A202C200820FE20183E1DE02A202A20482288220822081E0800
+7C78:100013F09490549058901090FC9033F03890549054909092108A108A10861082
+7C79:10401040944054405BFE1088FC88308838885508549090501020105010881304
+7C7A:084008404A402AFE2C800900FE7C18081C102A202A4048808902090208FE0800
+7C7B:01001110092001007FFC05400920111060080100FFFE0280044008203018C006
+7C7C:102010209420542059241124FD2431243924552455249124112411FC10041000
+7C7D:100011FC9404540858101020FC2033FE38205420542090201020102010A01040
+7C7E:1000100095FC544458441144FD44314439445644544490841084110412281410
+7C7F:080808084A082A082CFE0808FE0818081C882A482A4848088808080808280810
+7C80:10101010941054105BFE1010FC10311039105490549090501020105011881606
+7C81:0808081C4AE02A202C200820FE2019FE1C202A202A2048208820082008200820
+7C82:040004000FE01040208003600C187004111009207FFC054009203118C1060100
+7C83:101011109510551259121114FDD83110391055105510911211521192110E1000
+7C84:1008101C95E05500590011FCFD44314439445528552891101110122812441482
+7C85:10801080948054FC59541254FC54309438945524562490441044108411281010
+7C86:10201020942054A858A410A2FD2231203A245424542890081010102010C01300
+7C87:10801040944057FC58001000FDF03110391055105510911211121212120E1400
+7C88:100011F89448544858481048FC4831F838885488548890881088108813FE1000
+7C89:101010509450545058881088FD0432FA38485448544890481088108811281210
+7C8A:208020883CB020C020842C84307C0000111009207FFC054009203118C1060100
+7C8B:1040104095F854485888108AFD0A32263820542057FE90201020102010201020
+7C8C:100411E494245424582411E4FD043104390455E4542490241024102411441084
+7C8D:1008103C95E054205820103CFDE030203820543E57E09020102210221022101E
+7C8E:080008FC4A842A842C840884FEFC18A01CA02AA02A904890890809080A040C02
+7C8F:082008204A202A202C2009FEFE2018201C202A502A504850888808C809240A02
+7C90:082008104A102AFE2C820882FE8218FE1C822A802A8048808880090009000A00
+7C91:1000100095FC552459241124FD24312439FC5500550091001102110210FE1000
+7C92:082008104A102A002DFE0800FE0418841C842A482A4848488850081009FE0800
+7C93:088808884A882A882DFE0888FE8818881C882AF82A8848888888088808F80888
+7C94:080008FE4A802A802C8008FCFE8418841C842A842AFC48808880088008FE0800
+7C95:10201020944055FC59041104FD04310439FC5504550491041104110411FC1104
+7C96:10201020942055FE58201020FC2031FC387054A854A891241124122210201020
+7C97:100011F895085508590811F8FD083108390855F8550891081108110817FE1000
+7C98:1020102094205420583E1020FC20302039FC5504550491041104110411FC1104
+7C99:102010209420542059FC1124FD243124392455FC552491241124112411FC1104
+7C9A:1080108094FE55005A201120FD2C31743BA45524553491281122110210FE1000
+7C9B:010001003FF80108FFFE01083FF80100292825482FE823882548292841088108
+7C9C:0100111011101FF0410441047FFC0000111009207FFC054009203118C1060100
+7C9D:100011FE95005500590011FEFD203120393C5524552491241124124412541488
+7C9E:100013FE9450545059FC1154FD54315439545554558C91041104110411FC1104
+7C9F:7FFC044004403FF8244824483FF80000111009207FFC054009203118C1060100
+7CA0:108810889488548859FE1088FC883088388857FE540090881084110412021402
+7CA1:100011FE95025502597A1102FD02317A394A554A554A917A11021102110A1104
+7CA2:0100410021FC0A441448E0A021102608111009207FFC054009203118C1060100
+7CA3:100011DC9554555459541154FD5433FE3954555455549154115412D41224144C
+7CA4:02003FF8292825482FE82388254829283FF80000FFFE10001FF8000800500020
+7CA5:0100F93C09040D440B84793C412047E04120793C0B840D440904090451282110
+7CA6:0100111009207FFC054009203118C10610103EFC4210A290149008FE3010C010
+7CA7:10201010941055FE59001110FD103110397C5510551091101110121012FE1400
+7CA8:080009FE4A202A202C4008FCFE8418841C842AFC2A8448848884088408FC0884
+7CA9:10401040944455F458481050FDFE304038805584569890E010821082107E1000
+7CAA:0100111009207FFC054009203118C44604403FF804400440FFFE082010102008
+7CAB:100013FE94205420584011FCFD54315439545554555491541154114411141108
+7CAC:105010509450545059FC1154FD543154395455FC555491541154115411FC1104
+7CAD:082008204A502A482C840902FEFC18001C002AFC2A8448848884088408FC0884
+7CAE:1040102095FC5504590411FCFD04310439FC5520552291141108114411821100
+7CAF:100011F89508550859F81108FD0831F83908550855F89090109011121212140E
+7CB0:1008103C95C05404594410A8FC0031F83810542057FE90201020102010A01040
+7CB1:000023F0909042941292E51222502420111009207FFC054009203118C1060100
+7CB2:08000F7C28043F44612892100C683184C000111009207FFC054009203118C106
+7CB3:100011FE9420542059FC1124FD2431FC3924552455FC912010A0104010B0130E
+7CB4:100011FC9524552459FC1124FD2431FC3820542055FC90201020102013FE1000
+7CB5:04003FF820C82F2825483FF8254829283FF80000FFFE10001FF8000800500020
+7CB6:100011F89408540859F81008FC0833FE38205622557490A81124122210A01040
+7CB7:1080108094FE55025A42124AFD5230423BFE544254E29152124A104210541008
+7CB8:1088108897FE5488588810F8FC88308838F85488548893FE1000108811041202
+7CB9:1040102095FE540058881088FD5432223800542055FE90201020102010201020
+7CBA:1040108095FC5524592411FCFD24314439FC5490551093FE1010101010101010
+7CBB:100010FC948054F8588010F8FC8033FE39405524552891101108114411821100
+7CBC:080049122A120812FF242A24494888904248774892245A242F92221242128200
+7CBD:2040202023FEAA02700021FCF800200073FE6820A92821242222242220A02040
+7CBE:1020102095FE542058FC1020FDFE300038FC548454FC908410FC108410941088
+7CBF:100011FC9524552459FC1124FD2431FC382057FE547090A81124122210201020
+7CC0:1088108895FE548858881050FC50309439945698549090B210D21092108E1080
+7CC1:10401048948455FE582013FEFC8831243A425588541090621184101810601380
+7CC2:1088108897FE548858F81088FCF83088388857FE550091481184110011FE1000
+7CC3:100010FC948454FC588410FCFC0031FE388054FE552A924A1092112210541088
+7CC4:1040102095FE5502590211FEFD00310039FE55AA55AA92FE12AA12AA14A21086
+7CC5:200021FC2048A83073FE2052F894211072306820ABFE207020A8212426222020
+7CC6:100013FE9420544059FC1154FD54317439545554557491541154115411FC1104
+7CC7:108010BC9484550859FE1320FD20317C3990551055FE91101128112811441182
+7CC8:200023FE2022A920713C2120FAFE240071FC6904A9FC210421FC210421142108
+7CC9:200020882252AA227252228AFA0223FE70886944AA7A20882150202020D82706
+7CCA:1080109E949255D25892109EFC9231D23952555E5552915211D21022102A1044
+7CCB:210820882090ABFE700023C4FA54225473D46A54AA5423D422542244225422C8
+7CCC:2088208821ECA92A72282548F888217E760069FCA904210421FC2104210421FC
+7CCD:210820882090AFFE71082108FA10229474A46F38A9082210221024A427BC2084
+7CCE:100011FE9500557C59541154FD7C31543954557C55109110117C1210121014FE
+7CCF:200023FE2202AA0273FE2210FA92225472FE6A82AAFE228222FE2482248A2884
+7CD0:1028102497FE542059FC1124FDFC312439FC5524540893FE1088104810481018
+7CD1:200023DE2042A84273DE2210FA1023DE70426A52A94A214A2252204222942108
+7CD2:1088108897FE5488588813FEFC8031FC3B2455FC552491FC112411241124110C
+7CD3:1000FE7810487C480048FE8682007CFC104454443828FE281010382854449182
+7CD4:100011FC94A4548858501020FCD83326382055FC5524912411FC102213FE1002
+7CD5:11041084948854005BFE1020FC2031FC3820542057FE900012A4125214521000
+7CD6:1020101095FE5510597C1114FDFE3114397C5510557C914411441244127C1444
+7CD7:2040208023F8AA0873F82208FBF8220873F86850A84827FE20A0211022082C06
+7CD8:1040102095FE5502580010FCFC4030A23B345458549493341052109013501020
+7CD9:101010509650557C58901010FCFE3300397C55445544917C1144110012FE1400
+7CDA:1048104895FE544858001048FD48314839FE5448544893C811481148117E1240
+7CDB:1020112494A857FE5A0210F8FC88308838F85420542091FC1020102013FE1000
+7CDC:010000803FFE22102F7C26382B5432922080249022A03FFC21C042A044989886
+7CDD:2040208821FCA908725223FEF8502188762668C0AB1020642388203020C02700
+7CDE:111009207FFC054019307FFC11101FF011101FF004403FF80440FFFE08201010
+7CDF:2090209027FEA89073FC2294FBFC229473FC6800A9F8210821F8210821F82108
+7CE0:1020101095FE5510597C1114FDFE3114397C5510559291541138125412921430
+7CE1:1040102095FC5488585013FEFC0031FC390455FC550491FC109010921112160E
+7CE2:1088108897FE5488580011FCFD0431FC390455FC542093FE1050108811041202
+7CE3:200027BC2108AD2877BC2318FDAA294670006BF8AA08220823F82208220823F8
+7CE4:2288228827C8AA90729E27D4F82427D474546FD4AC5427C824482454246424C2
+7CE5:100011FE942055FE59521152FD523106380055FE542091FE1152115211521106
+7CE6:102013FE942055FC580011FCFD0431FC388857FE540091FC1104110411FC1104
+7CE7:100011FC950455FC590413FEFC0031FC392455FC552491FC102011FC102013FE
+7CE8:200023BE20A2A8A270BE2388FA08223E722A6BAAA8AA20BE2088208A257E2202
+7CE9:10201050948855745A0211FCFD2431AC392455FC540090F8108810F8108810F8
+7CEA:00407C2045FC44887C5043FE7C20A5FC24203C20111009207FFC05401930E10E
+7CEB:200023FC2294AA9473FC2000FBFE200073FC6A04ABFC20A2211423082D442182
+7CEC:200027FC24A4ACA477FC2048FBF8205077FE6840A9F8230825F8210821F82108
+7CED:202020882252AB267252228AFA2223FE70886944AA7A20882150202020D82706
+7CEE:201027D02510AFDE745027E8FD0427C470006BF8AAA822A822A822A82FFE2000
+7CEF:100011FC942057FE5A2211ACFC2031AC380057FE542091FC115411541154110C
+7CF0:23FE222223FEAA2272FA22AAFAFA22AA72FA6A26ABFE220A23FE228A225A23FE
+7CF1:52107EFE28447E28A2FE3E1020103E7C22103E10111009207FFC05401930E10E
+7CF2:200023FE2248ABFE724822FCFAA422FC72A46AFCAA2023FE232A257A250A2906
+7CF3:553C1424FFA422427F00083CFF8408286B1049287F4410100920FFFE0920711C
+7CF4:200011DC2844455490CC11545400384810FEFD9012FC389054FC949010FE1080
+7CF5:0820FFFE28207DFC44887C5041FE7C2045FC7C20111009207FFC05401930E10E
+7CF6:540055DC7C44115454CC55547C00004854FE399012FCFC9038FC549092FE1080
+7CF7:208823FE2088ABDE725223DEFA5223DE72226BFEAAAA22FA2222227222AA2224
+7CF8:02000400082010403F800100061018087FFC0104092009101108210445040200
+7CF9:080008001000120022007C000800100024007E00020000005200490089000000
+7CFA:084008401040124022407C400840104024407E400240004452444944893C0000
+7CFB:00F83F000400082010403F800100061018087FFC010409201110210845040200
+7CFC:104010402040244045FCF844104420444844FC84048400845504550482280410
+7CFD:0800080010FE121022107C100810101024107E10021000105210491089500020
+7CFE:080408041044124422447C4408441044244C7E54026400445204490489040004
+7CFF:1000100021FC24444444F844104420444844FC44044400845484550482280410
+7D00:1000100021F824084408F808100821F84908FD00050001005502550280FE0000
+7D01:100013FC210425444524F8A8108820884850FC50042000205450548881040602
+7D02:080808081008120822FE7C080808100824487E28022800085208490889280010
+7D03:10821092209224924492F892109220924892FC92049200925492551281020202
+7D04:10401040208024FC4504FA04100421044884FC44044400045404540480280010
+7D05:1000100021FC24204420F820102020204820FC20042000205420542083FE0000
+7D06:100011FC202024204420F820102023FE4820FC20042000205420542080A00040
+7D07:10401040208024FE4500FA0010FC20084810FC20044000805502550280FE0000
+7D08:104010402040244045F8F848104820484948FCC8044800A854AA550A82060402
+7D09:1000100021FC24444444F944114421444944FE44044400845484550482280410
+7D0A:020001007FFC082007C01830E20E04201FC0018006103FF80108112025104208
+7D0B:10401020202027FE4488F888108820884888FC50045000205450548881040602
+7D0C:10401050204824484440F9FE105020504850FC500490009054925512810E0200
+7D0D:10201020202025FE4522F922112221224952FD4A058A010255025502810A0104
+7D0E:10401048204424444440FBFE104020404840FCA004A000905510550882040402
+7D0F:10081088204824484408F888104820484808FC0E05F800085408540880080008
+7D10:100011F8204824484448F848104821F84888FC88048800885488548883FE0000
+7D11:1000100021FE24104410F8201020206848A4FD22062200205420542080200020
+7D12:10201020205024504488F904120220884888FC88048800885488550881080208
+7D13:100011F8200824504420F81013FE20224824FC20042000205420542080A00040
+7D14:1020102020202BFE4820F124112421244924FDFC0424002054225422801E0000
+7D15:10101110211025124512F91411D821104910FD100510011255525592810E0000
+7D16:100411E4202424244424F9E4110421044904FDE4042400245424542481440084
+7D17:10201020202024A844A4F8A2112221204A24FC24042800085410542080C00300
+7D18:10401040204028404BFEF040108020904890F92009200248AA44AC8481FE0082
+7D19:1004101E21F025104510F910111021FE4910FD1005100108550A554A81860102
+7D1A:100013FC208424884488F890109C20844944FD4405280128AA10AA2884440182
+7D1B:10101090209024884508F904120425FA4888FC88048800885508550882280410
+7D1C:1000100020FC24004400F80011FE20204820FC4004400088548455FE80820000
+7D1D:1008103C21E024204420F820102023FE4820FC20042000205420542081FC0000
+7D1E:10201020202025FE4522FA24102020204850FC5004500050549054928112020E
+7D1F:10201020205024504488F944122220204800FDFC040400085408541080100020
+7D20:01003FF801001FF00100FFFE020004201FC0018006103FF80108112025104208
+7D21:10401020202025FE4440F8401040207C4844FC44044400445484548481280210
+7D22:010001003FF8010001007FFE420284241FC0018006103FF80108112025104208
+7D23:1040104021F828484888F08A110A22264820F8200BFE0020A820A82080200020
+7D24:1004100E20F024804480F88010FE20884888FC88048800885488550881080208
+7D25:084008407F4008400E4078440844283C144008801F0002103FF8010815202210
+7D26:1000100021FC25244524F9241124212449FCFD00050001005502550280FE0000
+7D27:040025FC2488245024202450028C04201FC0018006103FF80108112025104208
+7D28:1088108820882908497EF308150821484928FD28050801085508550881280110
+7D29:102010202120252045FCF920122020204BFEFC20045000505488548881040202
+7D2A:1090109020902A904A92F2D4129822904A90FA900A900292AAD2AF12820E0000
+7D2B:088028882EF028842E84F07C020004201FC0018006103FF80108112025104208
+7D2C:102010202020242045FCF924112421244924FDFC052401245524552481FC0104
+7D2D:20082788408840889088E788240844109410F790009410A4A8A2A0BE85020200
+7D2E:042004207FA00E221522649E020004201FC0018006103FF80108112025104208
+7D2F:00003FF821083FF821083FF8020004201FC0018006103FF80108112025104208
+7D30:1000100021FC25244524F9241124212449FCFD24052401245524552481FC0104
+7D31:105010482048244047FEF880108020FC4944FD4405280128AA10AA2884440182
+7D32:10481148214825484548FBFE114821484948FD48057801005500550081FE0000
+7D33:10201020202025FC4524F924112421FC4924FD24052401FC5524542080200020
+7D34:10101010201025FE4512F914111021FC4944FD4405280128A910AA2882440482
+7D35:1040102020202BFE4A02F404100020004BFEFC20042000205420542080A00040
+7D36:10201020202025FC4420F820102023FE4820FC2004400048548455FE80820000
+7D37:10201020205024504488F9241212201049FCFC04040800885450542080100010
+7D38:10401020200025FE4420F8201020202049FCFC20042000205420542083FE0000
+7D39:100011FC204424444444F844109420884900FCFC048400845484548480FC0084
+7D3A:108810882088248847FEF888108820884888FCF8048800885488548880F80088
+7D3B:10201020202025FC4524F924112421244924FFFE042000505450548881040202
+7D3C:1090109020902BFC4894F09413FC22904A90FBFE08920092A91AA91482100410
+7D3D:10201010201025FE4502FA04108020884890FCA004C0008254825482807E0000
+7D3E:10201020205024884504FA12102020404988FC10042000445588541080600380
+7D3F:10201020204024404488F90413FE20024800FDFC050401045504550481FC0104
+7D40:10201020212425244524F92411FC20204820FD24052401245524552481FC0004
+7D41:1080108020FE25004620F920112C21744BA4FD24053401285522550280FE0000
+7D42:10401040207C28844988F250102020504888FB0608600010A808A8C080200010
+7D43:10201010201025FE4420F8201044208449F8FC1004200044548255FE80820000
+7D44:100011F8210825084508F9F8110821084908FDF805080108A908A90887FE0000
+7D45:100011FE210225024502F97A114A214A494AFD4A057A014A55025502810A0104
+7D46:10201020212424A444A8F82011FC20204820FC2007FE00205420542080200020
+7D47:10801080210029FC4A04F40411E421244924FD2405E401245404540480280010
+7D48:10201020204025FC4504F9041104210449FCFD04050401045504550481FC0104
+7D49:102010282024242045FEF8201070207048A8FCA8052402225420542080200020
+7D4A:102010202020242045FEF87010A820A84924FD24062200F85420542080200020
+7D4B:10201010201025FE4500F910111021104910FD2005280124AA44AAFE84420800
+7D4C:100011FC208424884450F820105020884B26FC2005FC00205420542083FE0000
+7D4D:10801088209C25704510FB101510211049FEFD100510011055105510817C0100
+7D4E:10401040209C25004640F84010BE21884A88FC88048800885488548880A80090
+7D4F:1020102021FC25244524F9FC1124212449FCFC2004240018543254CA83060002
+7D50:1020102020202BFE4820F02011FC20004800FDFC050401045504550481FC0104
+7D51:10201120212025FC4520FA20102023FE4870FCA804A801245524562280200020
+7D52:11041124212429244924F12415B4256C4924F92409240124A924AA2482040404
+7D53:1020102021FC24204420F82013FE20004820FC2005FC00205420542083FE0000
+7D54:100013FE202024204440F9FC110421044904FDFC050401045504550481FC0104
+7D55:100013FC204424444484F928121021FC4924FD2405FC01005502550280FE0000
+7D56:10401044224429484950F04017FE20904890FC900490009255125512820E0400
+7D57:1000100021FE25024502F97A114A214A494AFD4A057A0102550255FE81020000
+7D58:101010102210293E4922F044101020904890FB1009280128A928A94480440082
+7D59:100013FE2000240045FCF904110421FC4904FD0405FC01045400540083FE0000
+7D5A:100013FE204024404440F87C108420A44894FD04054400285408540883FE0000
+7D5B:108010F811082290206065986646A48825F02420244825FC2020212422A22040
+7D5C:08007F7C08243E2408447F540A8804201FC0018006103FF80108112025104208
+7D5D:1020102023FE24504488F90412FA20004BFEFC40048001FC5404540480280010
+7D5E:10401020202025FE4400F888110422024888FC88045000505420545080880306
+7D5F:10201020205024884504FA0211FC20204820FC2005FC00205420542083FE0000
+7D60:1020102021FE24404440F8FC108421844AFCFC84048400FC5484548480940088
+7D61:10401040207824884550F820105020884906FCF8048800885488548880F80088
+7D62:1080108021FC25044604F9E41124212449E4FD24052401E45504540480280010
+7D63:110410842088280049FEF088108820884888FBFE08880088A908A90882080408
+7D64:100013FE2050245045FCF954115421544954FD54058C01045504550481FC0104
+7D65:10901094209229124910F37E151021104910FD28052801285528554481440182
+7D66:10201020205024884504FA0211FC20004800FDFC050401045504550481FC0104
+7D67:100011FE21022502457AF9021102217A494AFD4A054A017A55025502810A0104
+7D68:10281024202428204BFEF020112421244924FBA809280110AA12AA2A84460082
+7D69:1090109020902A924994F098109021984A94FC9208900090A912A9128212040E
+7D6A:100011FC210425244524F92411FC21244924FD54054C018C5504550481FC0104
+7D6B:040008201FF0102024487EFC020004201FC0018006103FF80108112025104208
+7D6C:1008103C21E024204420FBFE102020204820FDFC050401045504550481FC0104
+7D6D:111009207FFC0200FFFE08203218C4261FC0018006103FF80108112025104208
+7D6E:08007F7C114432440C44327CC20004201FC0018006103FF80108112025104208
+7D6F:10201010201025FE4420F824104420F84812FC22044401885410542880440182
+7D70:100011FE202024404488F90411FE20224820FC2005FE00205420542083FE0000
+7D71:1040102020202BFE4840F088110423FE4892FC900490009055125512820E0400
+7D72:102010202048248845F0F8201040208849FCFC24042000A85524562280A00040
+7D73:1080108020FC29084A90F060119826264820F9FC08200220ABFEA82080200020
+7D74:11041084208828004BFEF020102021FC4820FC2007FE00205420542080200020
+7D75:10201020205028884904F20210F820004800FBFE08200040A888A90483FE0102
+7D76:1040104020F825084610F9FC112421244924FDFC050001005502550280FE0000
+7D77:1080FBF010901990F0941154520C24241FC0018006103FF80108112025104208
+7D78:100011F82108250845F8F908110821F84908FD0805F80090549055128212040E
+7D79:100010F82088248844F8F80011FC21044904FDFC0504010455FC550481140108
+7D7A:11841068203028C84B04F04013FE20A04920FBFC0D240124A934A92880200020
+7D7B:1080108020F825084610F9FC112421244924FDFC04500050549054928112020E
+7D7C:1008103C21E024964448F830104821944824FC4C059400245444558480280010
+7D7D:100010FC208424844484F88410FC20004800FDFE050201025502550281FE0102
+7D7E:10281024202428204BFEF220122422244BA4FAA80AA80290AA92ADAA84460882
+7D7F:102810242024242045FEF820112020B248B4FC6804A801245622542080A00040
+7D80:1020102023FE24204420F9FC1124212449FCFC20047000A85524562280200020
+7D81:2100211E411247D29114E11427D841149112F7D20112111AA914A21082100410
+7D82:1040102023FE24004400F9FC110421044904FDFC04500050549054928112020E
+7D83:1020112420A424A84420F9FC1104210449FCFD04050401FC5504550481140108
+7D84:1040102023FE2A024C04F1F8100020004BFEFC900490009055125512820E0400
+7D85:100011FC200424FC4404F9FC100023FE4A02FDF8048800885450542080D80306
+7D86:100013FE2020242045FCF924112421FC4924FD2405FC012054A0544080B0030E
+7D87:100013FE2050245045FCF95411542154498CFD04050401FC5504550481FC0104
+7D88:11081088209025FC4424F82411FC21204920FDFE046200A2552A562484200020
+7D89:101C11E02020242047FEF8A81124222249F8FC88049000BE5502550282140408
+7D8A:1020102020202BFE4820F020112421244924FAAA08200050A850A88881040202
+7D8B:1040102023FE2A024C44F04013FE20404890F89009100120AA24AA4284FE0842
+7D8C:10001050204824844524F820105020884906FEF8048800885488548880F80088
+7D8D:1020102023FE28204820F3FE1202240449F8FC10042003FE5420542080A00040
+7D8E:1000100623B828884888F108113E23884888FA880A88013EA900AA80847E0800
+7D8F:1008103C23C028444A24F128110020404BFEF88809080390A860A85081880604
+7D90:110410842088241045FCF9041104210449FCFC500450009054925512820E0400
+7D91:100013FE22222A224A22F3FE122222624A72FAAA0B220222AA22AA0283FE0202
+7D92:1008103C21C024044544F8A8100021F84810FC2007FE00205420542080A00040
+7D93:100011FE200028924924F248112420924800FDFE042000205420542083FE0000
+7D94:1000100CFEF02820444482F87C100024FEFE201240507C540492051228501020
+7D95:1020102020202BFE4820F020102021FC4840F82008A40282AA8AAA8A84780000
+7D96:1004100E23B828884888F128112E23A848A8FAA80AA8013EA900AA80847E0800
+7D97:100013FE22022A524A8AF306120222FA4A8AFA8A0A8A02FAAA8AAA02820A0204
+7D98:1040104020FC24884550F82010D8232648F8FC2004F8002057FE542080200020
+7D99:10101110211025924554F91011FE21104938FD54059201105510551081FE0000
+7D9A:1020102023FE282049FCF00013FE22024C04F89008900090A890A9128112020E
+7D9B:100013FC204429444944F284109421084A40F82008A40282AA8AAA8A84780000
+7D9C:1040102023FE2A024800F1FC100020004BFEF82009280124AA22AC2280A00040
+7D9D:10881088208828884BDEF0881088219C49DCFAAA0AAA04C8A888A88880880088
+7D9E:1008103C21E028204BFEF0A810A820A84BFEFCA804A803FE5420542081FC0000
+7D9F:1040102023FC2A044A04F3FC120022284A24FBFE0A200250AA50AC8885040A02
+7DA0:108010F82088290849F0F010101023FE4820FA22097400A8A924AA2280A00040
+7DA1:1040102023FE24004400F9FC110421044904FDFC042000A85524562280A00040
+7DA2:100011FC212425244574F92411FC21044974FD54055401745504560482140408
+7DA3:1020112420A8242045FCF84013FE20884904FEFA0488008854A854928082007E
+7DA4:7E7C12442A484444BE44225422483E00044008801F0002103FF8010815202210
+7DA5:100011FC2124292449FCF124112421FC4800F8000BFE0088A888A88881080208
+7DA6:08207FFC08200FE008200FE00820FFFE14502888DF0602103FF8010815202210
+7DA7:1040102023FE240045FCF90411FC200049FCFC08041003FE5420542080A00040
+7DA8:1088108823FE24884488F8F81088208848F8FC88048803FE5400548881040202
+7DA9:1040102023FE2A024D04F10011DE22524A52FB520C9A0094A910A9128212040E
+7DAA:1020102023FE242045FCF82013FE200049FCFD0405FC010455FC550481140108
+7DAB:10481044205E25E04428F812106A21964848FC5E05E0002454285412806A0186
+7DAC:101C13E020842A444948F11017FE24024800FBF809080110A8A0A84081B0060E
+7DAD:10A01090208025FE4510FB1015FC21104910FDFC05100110551055FE81000100
+7DAE:104008403E7E228823503E2020584186844008801F0002103FF8010815202210
+7DAF:1080108021FC25044684F8F4114420444BFCFC440554015455F4540480280010
+7DB0:1040102023FE2A024C04F1F81108210849F8FD00050001FC5504550481FC0104
+7DB1:100013FE22022A8A4A52F3FE122222224AAAFAAA0AAA02FAAA02AA02820A0204
+7DB2:100011FE2102218A4952F9FE1122211221FE4942F542017A55025502550A8104
+7DB3:100013DE22522A524A52F3DE125222524A52FBDE0A520252AA52AA52855208A6
+7DB4:100013DE2042294A4884F14A125224204800FBDE08520152A894A94882540422
+7DB5:1008103C23C028444A24F128110020204BFEF87008A800A8A924AA2284200020
+7DB6:100011FC2124292449FCF124112421FC4820FBFE087000A8A924AA2280200020
+7DB7:1040102021FE24004488F888115422224800FC2005FE00205420542080200020
+7DB8:10201020205024884504FAFA100021FC4954FD5405FC0154555455548104010C
+7DB9:1088108820E8252C452AFAA8104820A0491EFE0004FC00845484548480FC0084
+7DBA:1020102021FC24504488F90413FE200849E8FD28052801E85528540880280010
+7DBB:1040102023FE2A024C04F00013FE20204820F920093C0120AAA0AA60843E0800
+7DBC:1040108021FC25244524F9FC1124214449FCFC90051003FE5410541080100010
+7DBD:10201020203E242045FCF90411FC210449FCFD24042003FE5420542080200020
+7DBE:1020102021FC28204820F3FE108821444A42F8F809880250A820A85081880606
+7DBF:1020104021FC290449FCF10411FC20204820FBFE0A220222AA2AAA2480200020
+7DC0:1020102023FE242045FCF82413FE202449FCFC4007FE008455C8543080CC0302
+7DC1:1020102023FE242045FCF82413FE202449FCFC200520013EA920AAA0827E0400
+7DC2:1020112221222A244850F088130420224820F92409240228A850A88881040602
+7DC3:10881088208824884554FA22144220204820FD20053C0120AAA0AA60843E0800
+7DC4:100011FC2104250445FCF904110421FC4800FD1205D40118551055528192010E
+7DC5:20002FC044BC44A494A4E7A424A444A897A8F4A8049015D0AEA8A0A880C40082
+7DC6:100011FC210425FC4504F9FC1080208049FEFE4A044A0092A922AA4280940108
+7DC7:1092109221242A484924F0921092200049FEFD22052201FE5522552281FE0102
+7DC8:1020102021FC24204420FBFE1088205049FCFC20042003FE5420542080200020
+7DC9:100013FE202028204BFEF222122223324AAAFAAA0B760266AA22AA22822A0204
+7DCA:7EFC48447E4442287E1048287EC604201FC0018006103FF80108112025104208
+7DCB:1090109020902B9E4890F0901090239C4890F8900890039EA890A89080900090
+7DCC:101C11E0202028204BFEF0A8112422424840FBFE08880108A8D0A83080480184
+7DCD:101C13E022202BFE4A20F292130A220649FCFD04050401FC5504550481FC0104
+7DCE:1014101220102BFE4810F01013D222524A52FA540BD4000CA86AAB8A81160022
+7DCF:10901090210829484A44F492110823FC4844F82008A40282AA8AAA8A84780000
+7DD0:4000400C7EF080207C4444F864105424FEFE4412A4509454FE92051228501020
+7DD1:100011F82008280849F8F008100823FE4820FA22097400A8A924AA2280A00040
+7DD2:1020102221FA24244428FBFE1020204048FCFD84068400FC5484548480FC0084
+7DD3:1088108823FE288848A8F02011FC21244924F9240BFE0020A850A88881040202
+7DD4:1020112420A428A84820F3FE120222024AFAFA8A0A8A028AAAFAAA02820A0204
+7DD5:1040102023FE24884450F82010D823064888FCF80488008854F8550881080208
+7DD6:1020102221FA24244428FBFE1024204248FCFD84068400FC5484548480FC0084
+7DD7:11001100213C29244BA4F124113C23A44B64FD24093C0124A924A924813C0124
+7DD8:1008100C200A2BFE4A08F20812E8220A4A0AFAEC0AAC02A8AAEAAA1A82260442
+7DD9:1088108823FE248844F8F82011FC21244924FDFC042003FE5420542080200020
+7DDA:1040108021FC290449FCF10411FC20204832FBB408A80128A924AA2484A20040
+7DDB:100013FE2020244045FCF954115421544954FD2C042003FE5450548881040202
+7DDC:1000200C7CF044207C4444F87C10102410FEFE12925092549292971210501020
+7DDD:100011F82108290849F8F00017FE210849F8F90809F80108A93EAFC880080008
+7DDE:1080133822282A284BA8F2461200227C4BA4FA240A2803A8AE10AA2882440282
+7DDF:1008103C21E028204BFEF02011FC212449FCFD2405FC002055FC542083FE0000
+7DE0:1080104023FC28004908F09017FE24424844FBFC0A440244AA54AA4880400040
+7DE1:100011FC210425FC4510F9FE1110214A4986FC0005FC010455FC550481FC0104
+7DE2:1088108823FE24884488F80011FC21244924FD2405FC01245524552481FC0104
+7DE3:108010FC210429F84808F3FE104020A24B34F85808940334A852A89083500020
+7DE4:1048114821482BFE4948F1481178210049FEF8200BFE0070A8A8A92486220020
+7DE5:1100117C21442A444A44F67C1A1022104AFEFA380A540254AA94AB1282100210
+7DE6:100011FC2124252445FCF924112421FC4820FC10045401425542554A82380000
+7DE7:1088104820502BFE4850F05011FC21544954FD8C050401FC5504550481FC0104
+7DE8:1040102021FE25024502F9FE1100210049FEFDAA05AA02FEAAAAAAAA84A20086
+7DE9:101E13E0204425244488F9FC104020404BFEFC8004FC01445528561080680186
+7DEA:1100117E211025104590F95E1322252A4926FD420552010C55045504817E0100
+7DEB:1080108020FC29544AD4F0B4112C22444894F908084000A4AAAAAA8A84780000
+7DEC:100017FE204028804BFCF294129422F44A94FA940AF40294AA94AA9483FC0204
+7DED:100013FE22222BFE4A22F3FE100021FC4904FDFC050401FC5504550481140108
+7DEE:1100110021FE2A004DFCF10411FC210449FCFC8004FC01085690546081980606
+7DEF:1040104021FC28844BFEF00011FC210449FCF8200BFE0020AA20ABFE80200020
+7DF0:104010A021102A084DF6F00013C422544A54FBD40A540254ABD4AA44825402C8
+7DF1:1100117821082A084AFEF6401A40227C4A90FA100AFE0210AA28AA2882440282
+7DF2:1010101023902A904A94F3B212B222D24B90FA940A840388AA90A82080400180
+7DF3:010000803FFE22003FBC22142F9422143FA4220C24202FC041085FFC88881184
+7DF4:1020102023FE242045FCF92411AC21744924FDFC0420007054A8552482220020
+7DF5:1000108822522A224A52F28A120223FE4888F9440A7A0088A950A82080D80306
+7DF6:110011FE21102A104AFEF292169222FE4A92FA920AFE0290AA50AA2082580286
+7DF7:100013FE2222242045FEF82011FC212449FCFD2405FC002057FE542080200020
+7DF8:100013FE2050245045FCF9541154215449FCFC20042001FC5420542083FE0000
+7DF9:100011FC2104290449FCF104110421FC4800FBFE08200120A93CA92082A0047E
+7DFA:100010FC2084248444F4F894109421FE4902FD7A054A014A557A5502810A0104
+7DFB:2008200847C84210921EE4A427D441149114F7D401141108A9C8AE1484140022
+7DFC:100010F82088248844F8F888108820F84800FDFC055401545554555483FE0000
+7DFD:10201020203E24204420F9FC110421FC4904FDFC050401FC5400548881040202
+7DFE:100011FE2100257C4554F954117C21544954FD7C05100110557C5610821004FE
+7DFF:1040109021082BFC4804F00011F821084908F9F808400024AAA2AA8A84880078
+7E00:100013DE22422A424A42F3DE1200223E4BD2FA120A1403D4AA08AA1482240242
+7E01:100011FC200428FC4804F3FE104020A24B34F85808940334A852A89083500020
+7E02:10881048205025FC4504F904110421FC4820FC10045401425542554A82380000
+7E03:100013FE20222520453CF92012FE240049FCFD0405FC010455FC550481140108
+7E04:100011FC212425FC4524F9FC102021FC4924FDFC052401FC542054228022001E
+7E05:100C100A20082BFE4A08F3F8124A224A4BEAFAAC0AAC024CAAAAAB0A82160422
+7E06:2100213C4100410091BCE5642524453C9524F1240124113CA924A100817E0100
+7E07:1040102023FE2A024C04F1FC100021FC4904FDFC050401FC5504540083FE0000
+7E08:08202AA44D28145022887FFE420284241FC0018006103FF80108112025104208
+7E09:100013FC20902A944998F09017FE200049F8FD08050801F85508550881F80108
+7E0A:11041084208828004BFEF000108821044A02F9FC09540154A954A95487FE0000
+7E0B:10101220217C25444444F87C13402140497CFD440544017CA944AA80847E0000
+7E0C:124411242128247E4410FB5411542154497CFD1405200120A940AA80847E0000
+7E0D:1020101021FE24844448F9FE110222244810FDFE0440007C5444548480940108
+7E0E:100011FC210425E44524FBFE120221FC4904FDFC050401FC5504550481140108
+7E0F:08783E48228E2A007EF822482A3046CC844008801F0002103FF8010815202210
+7E10:1080108021FC2A444954F1F4108421284A90F9FC0A440554A9F4A88481280210
+7E11:10881050200025FE4450F9FC105423FE4854FDFC045000D85554565280500050
+7E12:10841044204825FE4420F8FC102021FE4840FC8004FE01105610541081FE0000
+7E13:100011FE21102520457CF944117C2144497CFD1005100154A952AA9282500420
+7E14:11F810882070298C4800F3DE1252218C4A52F8200BFE0070A8A8A92486220020
+7E15:100010F820A824A844D8F88810F820004800FDFC055401545554555483FE0000
+7E16:1040102023FE2A024C24F1FC102021FC4820FBFE082001FCA904A90481FC0104
+7E17:1040102023FE280049FCF10417FE210449FCFC5204940188568854A480C20080
+7E18:101E13E0212228944840F08811F0202048C4F9FE08220020ABFEA85080880306
+7E19:1088108821FE24884400F9FE1088208848F8FC8804F80088549E55E880080008
+7E1A:101E11E0202225124494F880102021CE4902FD0205CE01025502550281FE0102
+7E1B:1028102423FE242045FCF92411FC212449FCFD24040803FE5488544880480018
+7E1C:100010FC2084248444FCF80011FE210249FEFD0205FE010255FE544880840102
+7E1D:1020102023FE242045FCF90411FC210449FCFD0405FC010457FE548881040202
+7E1E:1040102023FC280049F8F10811F820004BFCFA040AF40294AAF4AA0482140208
+7E1F:100013FE220022FC4A00FBFE12A822904AC8FA860A0813FEAA88A44884080818
+7E20:1000FE7810487C480048FE8682007CFC2044444478281428FE10542892443182
+7E21:1040102023FE2A424820F1FC108820504BFEFC20042001FC5420542080200020
+7E22:0020792448A849FC48407BFE488849444A8A78F0482449FC482049244A229860
+7E23:00007C0C44F07C2044447CF844107C2444FEFE12105054545292931250502020
+7E24:1020102023FE242045FCF82013FE20404888FDF0042403FE5422552482A20040
+7E25:1020102023FE242045FCF84013FE20884934FEE2042001FC547054AC83220020
+7E26:108010A2211225144680F8FE110821084B28FD2E0528012855285558814E0180
+7E27:1110111E21222A544A08F6941AE222884A88FABE0A8802ACAA2AAA4A82280210
+7E28:100011FC210425FC4504F9FC1020212448A8FC2007FE0090549055128212040E
+7E29:1100111023DC2A544D54F288110822F44C02F8000BFC0040A950AA4885440080
+7E2A:100011FC212425FC4524F9FC10A820A84BFEFCA804A801FCA820ABFE80200020
+7E2B:1020147C228429484830F0CE1610227C4A10FA7C0A1002FEAA10AA1085FE0800
+7E2C:100C100A200823FE4A08FA48126A224A4BFAFA4C0A4C12ECAB5AA44A84D60822
+7E2D:1040102023FE28004954F124115421FC4820FBFE0A420292AAFAAA0A82020206
+7E2E:1020101023FE2A024880F0FE111023204D7CF9440944017CA944A944817C0144
+7E2F:1040102023FE2A024800F1FC102021FC4924FDFC052401FC5400548881040202
+7E30:11081108222824AE44A8F928137E25004908FD28052E01285558554881860100
+7E31:1124112422242C244954F14A129226104A10FA500A5C0250AA50AAB0829E0300
+7E32:100011FC212425FC4524F9FC1040208849F0FC20044403FE5422552482220060
+7E33:102013FE202025FC4524F9FC112421FC4822FDFE040801FE5508548880280010
+7E34:102013FE204820F04820FBFE1242209049F8F828092011FCAA20A7FE80200020
+7E35:100011F8210829F84908F1F8100023FC4A94FBFC080001F8A890A86081980606
+7E36:08207E2008F8FF2814287F6A082AFF560A8204200FC002103FF8010815202210
+7E37:102011FC21242BFE4924F1FC102021FC4924FDFC044003FE548855D08070038C
+7E38:1088108823FE24884400F9FC110421FC4904FDFC042003FE5450548881040202
+7E39:100013FE205025FC4554F95411FC200049FCFC0007FE002054A8552482A20040
+7E3A:1010101022FE2510457CF854107C2354497CFD1005FE0110A910AA90847E0000
+7E3B:010000803FFE22102F7C26382B543292210827F0206023842FFE404245488884
+7E3C:12101110211027BE4A40FA0013BE228A4A88FAA80AAE12A8ACA8A5A8885E1080
+7E3D:1020104021FC2524457CF98C115421244954FDFC0420001055545542814A0238
+7E3E:102013FE202025FC4420FBFE100021FC4904FDFC050401FC550455FC80880104
+7E3F:1040108821FC29084A52F3FE105021884E26F8C00B100064AB88A83080C00700
+7E40:1020122223FE28904888F1FE1310251049FEFD10051001FE5510551081FE0100
+7E41:20203F20403EBE482AA8FF284A107F28044608801F0002103FF8010815202210
+7E42:1040102023FE28204848F2F21124225248F8FC08042003FE5420542080200020
+7E43:1020122222222BFE4800F3DE125222524BDEFA520A5203DEAA52AA52855A08A4
+7E44:7F7848485F4C64805F784A4851307F4C044008801F0002103FF8010815202210
+7E45:112412482124280049FCF12411FC212449FCF8200BFE0070A8A8A92486220020
+7E46:100013DE20422A52494AF252102820C44B12F86009880032A9C4A81880600380
+7E47:00000E0CF0F02220924444F820103C2450FE1012FE501054549255125C506420
+7E48:10081388209028A448BEF38A1208223E4A2AFBAA08AA00BEA888A88A82BE0102
+7E49:11FC110421FC250445FCF90411FC20504954FCD804D80154565254908092010E
+7E4A:1088108C23EA28884888F7FE1008214A494AFD5A0B6C014CA94AA9EA87160022
+7E4B:1078FE4810487C8654787C485430FECE144008801F0002103FF8010815202210
+7E4C:1040108023FC2A944A64F29413FC20904908FA840CFA0108AA90A86081980606
+7E4D:1020102021FC242447FEF82411FC202049ACFD74052401FCA964AAB4832C0424
+7E4E:1110111421D22A504A7EF550109022A84928F9440A440482A808AAA482520452
+7E4F:100013DE22522BDE4A10F25211CE20004888FBFE08880088ABFEA88881040202
+7E50:1020102023FE282049FCF12411FC212449FCF8220BFE0042A824AAA2828A0478
+7E51:101811E020402BFE4888F174125220704800FDFC05040174555455748104010C
+7E52:1104108820002BFE4A22F2AA127222224BFEF80009FC0104A9FCA90481FC0104
+7E53:100011F8210821F84908F9F8100027FE4A40FBDC0A5413D4AA68A7C880540062
+7E54:1110109423D228124A50F19017FE20104BD2FA520A5403D4AA4AAA4A83D60022
+7E55:1088105023FE282049FCF02013FE212448A8FBFE080001FCA904A90481FC0104
+7E56:2288228847C84290929EEFD4202447D49454F7D4045417C8AC48A454846404C2
+7E57:1020112420A82BFE48A8F124122221044904F9DE0A440554A89EA90482040404
+7E58:100013FC204828304BFEF052109423504820FBFE0A52028AAB76AA5282720206
+7E59:103C13E0212428A84BFEF0A81124220249FCFD24052401FC5524552481FC0104
+7E5A:1020102021FC24204554F888110422FA4888FCF8048800F8542054A881240060
+7E5B:081008107F1E08103E7E0842FF7E22427C7E085212107F7E08102A1049101810
+7E5C:1088105023FE245045FCF954118C21744904FDFC040803FE5508548880A80010
+7E5D:13DE125223DE2A524BDEF20212F222924AF2FA920AF20292AA92AB3282020206
+7E5E:1020102021FC28204BFEF108139C21084988FE3E080003FEA890A8908112020E
+7E5F:100013DE22522A524BDEF00011FC212449FCFD2405FC002057FE542080200020
+7E60:01002488242443E4000024241212A0A0A4A41C1C04201FC002103FF809201310
+7E61:204023F8404847FE9048E3F820404554975CF44407FC1444AF5CA55485540844
+7E62:102011FC212425FC4420FBFE100021FC4904FDFC050401FC550455FC80880104
+7E63:102011FC20242BFE4824F1FC102023FE4800FDFC052401FC552455FC800003FE
+7E64:0820FFFE08201FF01490125011301FF00400FFFE12502F88C2261FF009481320
+7E65:102013FE202029FC4800F1FC110421FC4888FBFE080001FCA904A90481FC0104
+7E66:2000277C41444144917CE7102410447C9454F7540154117CA910A1148AFE0402
+7E67:100011FC20202BFE4A22F1AC102021AC4800FDFC040003FE5440548881FC0084
+7E68:10101210217C241044FEF844132821FE4910FD7C051001FE5510551082FE0400
+7E69:100011FC2154255445DCF85011DC21544954FDDC0554015455DC55508052003E
+7E6A:10201050208829744A02F1FC112421AC4924FDFC040000F8548854F8808800F8
+7E6B:0878FFC808483E862B783E482A28FF9049287F4604201FC002103FF809201310
+7E6C:1020102023FE29244924F2AA17FE200049FCFD04057401545574550481FC0104
+7E6D:0820FFFE082000007FFC4924492455FC5DAC49FC55245D3C41CC6B0441144008
+7E6E:100013FE200025FC4524F9FC112423FE4800FDFC052401FC552455FC800003FE
+7E6F:100013FC22942A944BFCF00017FE20004BFCFA040BFC00A2A914AB088D440182
+7E70:11FC1104210429FC4800F3DE125222524BDEF8200BFE0070A8A8A92486220020
+7E71:108813FE208829004BFCF55410D423244854F8940B480020A8A4AA8A828A0478
+7E72:110011DE224A2C8A4BEAF2B612A423F44ABEFAA40BE402BEAAA4AAA482240464
+7E73:2108220847C8445097DEE46427D442149114F7D4021413C8AA48A454855408A2
+7E74:3E1022FE3E4420287EFEA2103EFC2210045008801F0002103FF8010815202210
+7E75:102017FE20002BFE4A02F2FA128A23FE4800F9FC090401FCA904A9FC800007FE
+7E76:1040102021FC24884450FBFE100021FC4904FDFC050401FCA820AA94828A047A
+7E77:109013FC229423FC4A94FBFC100023FC4A00FAF80A0013FEAD20A51485480986
+7E78:10881448225028FC4820F050169422384A50FA980A340254AA90AA2085FE0800
+7E79:100011FC215425FC4420F9FC102023FE4888FC5005FC002057FE542080200020
+7E7A:1210121023D02C5E48A4F3D4105420544BC8F848085407E2A800AAA482520452
+7E7B:100011FC20202BFE4A22F1AC102021AC4800FBFE082001FCA954A9548154010C
+7E7C:1044128422EA2A4E4AA4F2EE122223FE4A44FA840AEA024EAAA4AAEE822203FE
+7E7D:1040102023FE2A0249FCF148125021FC4B04F9FC090401FCA904A9FC80880104
+7E7E:1010107C2254257C4510F8FE1000237C4944FD7C0540017C5544557C8280047E
+7E7F:100813E822882BEE4A28F3F4128223E24800F9FC09540154A954A95487FE0000
+7E80:112811AA216C2A284AFEF64416282AFE4A10FA7C0A1002FEAA10AA2882440282
+7E81:101C11E020202BFE4820F1FC11AC217449FCFC2005FC002057FE54008154022A
+7E82:20403E7E4890BFF8248822483FF80200FFFE092012502F88C2261FF009481320
+7E83:2080204047FC411090A4EF58255445529B58F000020813F8AA08A3F882080408
+7E84:108813FE208828204A3CF144103820D64B38F910097C0110A97EA910831004FE
+7E85:244424E448A84AAA9EEEE4A42AAA4EEE9242F0400FFE10E0A950A2488C460040
+7E86:11FC112421AC252445FCF82011FC20204BFEFD54062A002055FC542083FE0000
+7E87:920054FEFE10302054FC9284208444FC788410FC2484FE8410FC544892843102
+7E88:1100113E21082FD0493EF12213A2203E4822FBBE0AA202A2AABEAB8082940022
+7E89:108811DC20882BDE4888F154122221FC4904FDFC050401FC550455FC80880104
+7E8A:1020101021FE2528457CF92811FE2110497CFD54057C0154A97CAA0082440482
+7E8B:13FC104021F8290849F8F10817FE24424AA4FA8A0C7A0080A9F8AA888070038E
+7E8C:102013FE202029FC4800F3FE125223FE4904FDFC050401FC550455FC80880104
+7E8D:1FF011101FF011103FF82AA83EF82AA83EF808801F0002103FF8010815202210
+7E8E:1088108C23EA28884888F3FE1148236A494AFB6A094C036CA94AA96A87960022
+7E8F:202027FE440045FC9524E5FC252445FC9420F5FC042017FEAD24AAFA882013FE
+7E90:1200113E27C828104ABEF262142220BE4AA2FABE09220122AABEAA8084140022
+7E91:1040107C20402BFC4A44F3F0124422FC4AA8FAF80AA802F8AA00ADFC85540BFE
+7E92:13FE120022FE22924AFEFA9212FE22104AFEFA100BFE12AAAA10A2FE841009FE
+7E93:13DE125223DE2A524BDEF25213DE218C4A52F8400FFE0088A990A86080D80304
+7E94:11F0121027FC2A044BFCF22413B8222249FEFA100FFC0244ABFCA8D0814A063E
+7E95:102013FE200029DC4954F1DC108823FE4888FBFE088807FEA894A98886A400C2
+7E96:1148114C22AA28084FFEF1481368214A4B6AF94C0B6C0148A96AAB9A80260042
+7E97:122213FE209029FE4B10F5FE111021FE4910F9FE090003FEAA8AAB7682520276
+7E98:252827BE494847BE9318E5AA294643FC9204F3FC020413FCAA04A3FC81080204
+7E99:200023FE4252425293FEE1082154425E97B4F11E025417DEA814A554855E0010
+7E9A:13DE100023DE2A524B5AF252102023FE4A50FBFE0A5203FEAA92AADC829204CE
+7E9B:0100FFFE01001FF01210FFFE10901FF0001C3EE022242AF82A24FFFE2A5459B2
+7E9C:1790151E27A82C844FBEF52A17BE20004BF8FA080BF80208ABF8A8A08124061C
+7E9D:11FC112421FC29244BFEF2AA13FE22AA4BFEF88809F00064ABFEA92482220060
+7E9E:444444E44A0A4EEEA404AAEACE0E40E04AAA8AEAA040E0240522A50AA90800F8
+7E9F:10001000200024004400F800100020004000FC00400000001C00E00040000000
+7EA0:10041004208424844484F88410842084408CFCB440C400841C04E00440040004
+7EA1:100011FC202024204420F820102023FE4020FC20402000201C20E02040A00040
+7EA2:1000100021FC24204420F820102020204020FC20402000201C20E02043FE0000
+7EA3:100810082008240845FEF808100820084088FC48404800081C08E00840280010
+7EA4:1008103C21E024204420F820102023FE4020FC20402000201C20E02040200020
+7EA5:10401040208024FE4500FA0010FC20084010FC20404000801D02E10240FE0000
+7EA6:108010802080210445FEFA04140420844044FC24002400041C04E04440280010
+7EA7:100013FC208420884888F890109C20844144F944412801281A10E22844440182
+7EA8:104010402040244045F8F848104820484148FCC8404800A81CAAE10A42060402
+7EA9:10201010201025FE4500F900110021004100FD00410001001D00E20042000400
+7EAA:1000100023F820084808F008100823F84208FA00420002021A02E20241FE0000
+7EAB:1000100023FC20444844FA44124422444484F884408401041904E20444280810
+7EAC:10201020202025FE4420F82010FC20204020FDFE402200221C2AE02440200020
+7EAD:1000100021FC24004400F80013FE20204020FC40404000881D04E3FE41020000
+7EAE:10401040204020404BFEF840108020904090F920412002481A44E48441FE0082
+7EAF:10401040204023FC4840FA48124822484248FBF8404800401842E042403E0000
+7EB0:10101110211025124512F91411D821104110FD10411001121D52E192410E0000
+7EB1:10401040204021484944FA42124224484048F848401000101820E04041800600
+7EB2:100013FC220422044A94FA54122422244254FA54429403041A04E20442140208
+7EB3:10201020202020204BFEF222122222224252FA4A428A03021A02E202420A0204
+7EB4:1008103C21E024204420F820102023FE4020FC20402000201C20E02041FC0000
+7EB5:11101110211021104910F910111021104110FAA8426802281C44E44448841102
+7EB6:1040104020A020A04910FA08140621104120F940418001001904E10440FC0000
+7EB7:10101090209020884908F904120425FA4088F888408800881908E10842280410
+7EB8:1008103C23E022204A20FA20122023FE4220FA10421002121A0AE28A43060202
+7EB9:10801040204027FC4910F110111021104110F8A040A0004018A0E11042080C06
+7EBA:10401020202027FE4480F880108020FC4084FC84408400841D04E10442280410
+7EBB:104010202020240045FEF902120420004000FC00400000001C00E1FE40000000
+7EBC:100411E4202424244424F9E4110421044104FDE4402400241C24E02441440084
+7EBD:100011FC204424444444F844104421FC4084FC84408400841C84E08447FE0000
+7EBE:100011F8200824504420F81013FE20224024FC20402000201C20E02040A00040
+7EBF:105010482040245C45E0F840105E23E04044FC48403000221C52E08A43060002
+7EC0:110811082108250847FEF908110821084108FDF8410801081D08E10841F80108
+7EC1:10481248224822484A48F7FE124822484248FA48427802001A00E20043FE0000
+7EC2:10501048204820404BFEF880108020FC4144F944412801281A10E22844440182
+7EC3:1040104027FC20804880FBE01120222043FCF820412801241A22E42240A00040
+7EC4:100011F8210821084908F9F8110821084108F9F8410801081908E10847FE0000
+7EC5:10201020202025FC4524F924112421FC4124FD24412401FC1D24E02040200020
+7EC6:1000100021FC25244524F9241124212441FCFD24412401241D24E12441FC0104
+7EC7:1000100021FC25044504F9041104210441FCFD04400000901C88E10442020402
+7EC8:1080108020F821084B10FCA0104020A04318FC0640C000201810E18040600010
+7EC9:1080108020F821084A10FC2013FC20044004F80441FC00041804E00443FC0004
+7ECA:10201020212424A444A8F82011FC20204020FC2043FE00201C20E02040200020
+7ECB:10901090209023FC4894F89413FC22904290FBFE40920092191AE11442100410
+7ECC:10201020212425244524F92411FC20204020FD24412401241D24E12441FC0004
+7ECD:100013FC208420844884F904111422084400F9FC410401041904E10441FC0104
+7ECE:100013FC210420884850F82010D823264020F9FC402000201BFEE02040200020
+7ECF:100011FC200824104430F848108423024000FDFC402000201C20E02043FE0000
+7ED0:10201020204024884504FBFE1002200041FCFD04410401041D04E10441FC0104
+7ED1:2100211E211247D25114F11427D821144112F7D24112011A3114C21002100410
+7ED2:10281024202420204BFEF820112421244124FBA8412801101A12E22A44460082
+7ED3:10201020202027FE4420F82011FC20004000FDFC410401041D04E10441FC0104
+7ED4:1040104027FC20A04910FA081DF6200047FCF880410003F81808E00840500020
+7ED5:1080108020BC23C04850F82410D4230C4000FBFE409000901912E112420E0400
+7ED6:100011FE202024404488F90411FE20224020FC2041FE00201C20E02043FE0000
+7ED7:10801080213C22004C80F080117E23084508F908410801081908E10841280110
+7ED8:1040104020A021104A08F40611F020004000FBFC404000801910E20847FC0204
+7ED9:1040104020A021104A08F40613F820004000FBF8420802081A08E20843F80208
+7EDA:10801080210021FC4A04F40413E422244224FBE4422402241BE4E00440280010
+7EDB:1080108020FC21084A90F860119826264020F9FC402002201BFEE02040200020
+7EDC:1080108020F821084B10FCA0104020A04118FA0645F801081908E10841F80108
+7EDD:1080108020F821084A10F5FC112421244124F9FC410001001902E10240FE0000
+7EDE:10401020202025FE4400F888110422024088FC88405000501C20E05040880306
+7EDF:10401020202023FE4840F888110423FE4092F890409000901912E112420E0400
+7EE0:100013FE2020242045FCF924112421FC4124FD2441FC01201CA0E04040B0030E
+7EE1:1020112420A424A84420F9FC1104210441FCFD04410401FC1D04E10441140108
+7EE2:100011F82108210849F8F80013FC22044204FBFC420402041BFCE20442140208
+7EE3:103813C0204020404FFCF9501248244643F0F9104120017C1A04E20444280810
+7EE4:10001050204824844524F820105020884106FCF8408800881C88E08840F80088
+7EE5:1008103C23C020444A24F9281100204043FEF888410803901860E05041880604
+7EE6:1080108021F823084C90F060119826464040FBFC404002481A44E44441400080
+7EE7:10201220222023244AA8F22013FC22204270FAA8432402201A20E22043FE0000
+7EE8:11081088209023FC4824F82413FC22204220FBFE406200A2192AE22444200020
+7EE9:1040104027FC20404BF8F04017FE200043F8FA08424802481A48E0A041100608
+7EEA:1040104423F420484850F7FE1040208041F8FB08450801F81908E10841F80108
+7EEB:1020102021FC20204820FBFE108821444242F8F8418802501820E05041880606
+7EEC:1088108823FE248844A8F82011FC21244124FD2443FE00201C50E08841040202
+7EED:1020102021FC24204420FBFE100220944050FD10409003FE1C28E04440820302
+7EEE:1020102021FC24504488F90413FE200841E8FD28412801E81D28E00840280010
+7EEF:109010902090279E4890F8901090239C4090F8904090079E1890E09040900090
+7EF0:10401040207E20404BFCFA0413FC220443FCFA44404007FE1840E04040400040
+7EF1:1020112420A420A84820FBFE1202220242FAFA8A428A028A1AFAE202420A0204
+7EF2:100011FC2104250445FCF904110421FC4000FD1241D401181D10E1524192010E
+7EF3:100011F02110211049F0F84013F822484248FBF8424802481BFAE0424042003E
+7EF4:10A01090208025FE4510FB1015FC21104110FDFC411001101D10E1FE41000100
+7EF5:1020104021FC210449FCF10411FC20204020FBFE422202221A2AE22440200020
+7EF6:101C13E0208422444948F91017FE24024000FBF84108011018A0E04041B0060E
+7EF7:200027BC24A444A454A4F7BC24A424A444A4F7BC44A404A434A4C4A40AA4114C
+7EF8:100013FE222222224AFAFA22122223FE4202FAFA428A028A1AFAE202420A0404
+7EF9:1080108020FE25024682F8F21142204243FAFC42415201521DF2E00240140008
+7EFA:1088108821EC212A4A28F5481088217E4600F80041FC01041904E10441FC0104
+7EFB:10401248215020404BF8F88017FC21104208FDF4491201101950E124410400FC
+7EFC:1040102023FE22024800F9FC1000200043FEF820412801241A22E42240A00040
+7EFD:1040102023FE22024C04F80013FE20204020F920413C01201AA0E260443E0800
+7EFE:1040102023FE22024C04F9F81108210841F8F900410001FC1904E10441FC0104
+7EFF:100011F82008200849F8F808100823FE4020FA22417400A81924E22240A00040
+7F00:200027BC208442945108F29424A428404000F7BC40A402A43128C29004A80846
+7F01:11241124224824904A48F9241124200043FCFA44424403FC1A44E24443FC0204
+7F02:1088108823FE248844F8F82011FC21244124FDFC402003FE1C20E02040200020
+7F03:11001100213E21224FA2F122113E23A24362FD22493E01221922E122413E0122
+7F04:20142012201047FE5410F41025D024124412F5D44554054835DAC42A08461082
+7F05:100017FE204020804BFCF294129422F44294FA9442F402941A94E29443FC0204
+7F06:10901290229E22A84AC4F88011FC21044124F924412401541850E0904112060E
+7F07:100011FC2104210449FCF904110421FC4000FBFE40200120193CE12042A0047E
+7F08:20102010271045105514F752255225924710F514450807103520C04000800300
+7F09:100011F82108210849F8F00017FE210841F8F90841F80108193EE7C840080008
+7F0A:100011F82108210849F8F908110821F84000FBFC429402941A94E29447FE0000
+7F0B:1020102021FC252445FCF82013FE200041FCFD04412401241D24E05040880304
+7F0C:100011FC2124212449FCF924112421FC4000F840402402A21A8AE48840780000
+7F0D:1008103C21E020204820FBFE1124212447FEF924412403FE1820E02043FE0000
+7F0E:10801338222822284BA8FA461200227C43A4FA24422803A81E10E22842440282
+7F0F:110011FE211022104AFEF292169222FE4292FA9242FE02901A50E22042580286
+7F10:1040108021FC210449FCF90411FC20204032FBB440A801281924E22444A20040
+7F11:11001178210822084AFEF6401A40227C4290FA1042FE02101A28E22842440282
+7F12:10101220217C25444444F87C13402140417CFD444144017C1D44E280447E0000
+7F13:103C17C0224421284800FBFC1080208047FEF90041F802881A50E42048D80306
+7F14:1040102021FC24004488F85013FE22224424FDFC412401241D34E12840200020
+7F15:1020112420A820204BFEF8A8112422024040FBFE408801081990E06041980604
+7F16:1080104023FC22044A04FBFC1200220043FCFB54435405FC1D54E5544944010C
+7F17:100013FC220423FC4A20FBFE1210228A4306F80043FC02041BFCE20443FC0204
+7F18:108010FC210421F84808FBFE104020A24334F858409403341852E09043500020
+7F19:100013FC209022944998F89017FE200041F8F908410801F81908E10841F80108
+7F1A:1050104827FE20404BFCFA4413FC224443FCFA44400803FE1908E08840A80010
+7F1B:100013FE220022FC4A00FBFE12A8229042C8FA86420803FE1A88E44844080818
+7F1C:1040104027FC20404BF8FA0813F8220843F8FA0843F802081FFEE11042080404
+7F1D:1020147C228421484830F8CE1610227C4210FA7C421002FE1A10E21045FE0800
+7F1E:1040102023FE200049FCF90417FE210441FCF852409401881A88E4A440C20080
+7F1F:1040102023FE200049FCF90411FC200043FEFA0242FA028A1AFAE202420A0204
+7F20:2040202027FE440055FCF524252425FC4524F52445FC042035FCC820082013FE
+7F21:1040102023FE20004954F924115421FC4020FBFE424202921AFAE20A42020206
+7F22:11041084208820004BFEF800108821044202F9FC415401541954E15447FE0000
+7F23:10881050200025FE4450F9FC105423FE4054FDFC405000D81D54E25240500050
+7F24:1040102023FE22024C14F9E01100210041FCF910411007FE1800E09041080204
+7F25:100013FE205025FC4554F95411FC200041FCFC0043FE00201CA8E12442A20040
+7F26:100011F8210821F84908F9F8100023FC4294FBFC400001F81890E06041980606
+7F27:100011FC212425FC4524F9FC1040208841F0FC20404403FE1C22E12442220060
+7F28:20002FBE28A24AAA5AAAFAAA251428A24080F7FE4110021033A0C06001980E04
+7F29:2040202027FE44025100F1FE221026204A7CF2444244027C3244C244027C0244
+7F2A:100017BC208424A44A94F4A4105021884626F8C0431000641B88E03040C00700
+7F2B:112412482124240045FCF92411FC212441FCFC2043FE00701CA8E12446220020
+7F2C:220022FE22104FA0527CF244275420544054F754455405543528C72405420082
+7F2D:1020102023FE20504A8AF90413FE250441FCF90441FC00201924E22244A20040
+7F2E:1088105023FE202049FCF82013FE212440A8FBFE400001FC1904E10441FC0104
+7F2F:11041088200023FE4A22FAAA1272222243FEF80041FC010419FCE10441FC0104
+7F30:100013FE200025FC4524F9FC112423FE4000FDFC412401FC1D24E1FC400003FE
+7F31:101014FE229222FE4810F9FE10002EFE4282FAFE428002FE1A82E2FE450008FE
+7F32:11FC1104210421FC4800FBDE1252225243DEF82047FE007018A8E12446220020
+7F33:100013FC229422944BFCF80017FE200043FCFA0443FC00A21914E3084D440182
+7F34:2108220827C8445057DEF46427D422144114F7D4421403C83248C454055408A2
+7F35:2108252827BE494857BEF31825AA29464000F3F8420802483248C0B001080604
+7F36:0800080010001FF82100410001000100FFFE010021082108210821083FF80008
+7F37:200020003F3E482288220822FFA2082208224922492A49244F20792000200020
+7F38:200020003F7E481088100810FF10081008104910491049104F1079FE01000000
+7F39:080008001FF8210041000100FFFE01002108210821083FF80000488844448444
+7F3A:202020203C2051FC90241024FE24102413FE5420545054505C88648805040202
+7F3B:200020003DFE504090401078FE48104810685498549854885C8A64AA04CA0086
+7F3C:204020403C40507C90441088FEA0112010205450545054485C88648405040202
+7F3D:202020203C20502091FE1070FEA810A811245524562254F85C20642004200020
+7F3E:208420483C0050FC90481048FE48104811FE5448544854485C48648804880108
+7F3F:2008201C3CE05080908010FEFE80108010BC54A454A454A45CA4653C05240200
+7F40:205020503C50515290D41058FE50105810D45552565054505C9264920512020E
+7F41:400043FE7A02A28A225223FEFA22222222AAAAAAAAAAAAFABA02CA02020A0204
+7F42:3EF822882AA82AA82AA81450228849041FF821000100FFFE010021083FF80008
+7F43:08202AA44D28145022887FFE400288041FF821000100FFFE0100210821083FF8
+7F44:08007F7808483E4800863E782A483E30404890861FF02100FFFE010021083FF8
+7F45:4040407C7840A3FE22422278FBC4223C2208AAF0AB24AAA8BDFECC2008A00040
+7F46:200021FC3D2453FE912411FCFE0011FC110455FC550455FC5D0465FC04880104
+7F47:410840907BFEA09023FC2294FB1C220423FCAA04ABFCA808BBFEC90800A80010
+7F48:400043FE7850A3FE225223FEF80021FC2104A9FCA904A9FCB820CBFE00200020
+7F49:412440A87BFEA20220F82088F8F8200C21F0A820A9FCA820BBFEC82000A00040
+7F4A:08787F4808483E862B783E482A28FF9049287F4620003FF84100FFFE21083FF8
+7F4B:0100FFFE104824FE799010FC22907CFC089030FEC8803FF84100FFFE21083FF8
+7F4C:3EF822883EF822883EF822883EF81450228810001FF02100FFFE010021083FF8
+7F4D:1FF011101FF011103FF82AA83EF82AA83EF810001FF02100FFFE010021083FF8
+7F4E:41FC410479FCA10423FE2020FBFE222221ACA820A9FCA800BBFEC840008801FC
+7F4F:4040407C7840A3FC224423F0FA4422FC22A8AAF8AAA8AAF8BA00CDFC05540BFE
+7F50:408843FE7888A3DE225223DEF8A0209021FEA920ABFCAD20B9FCC92001FE0100
+7F51:00007FFC40044004421452944A54442444244A544A5452946104400440144008
+7F52:00003FF82448244824483FF80000000000000000000000000000000000000000
+7F53:00003FF820082448228821082288244820080000000000000000000000000000
+7F54:00007FFC4004482444445FF4410440845FF444044404440447E4400440144008
+7F55:00007FFE40028824101020081FF0010001000100FFFE01000100010001000100
+7F56:00003FF82448244824483FF801000280044008203018C2060100008000800000
+7F57:00003FF82448244824483FF8020004000FF0101068200440028003001C00E000
+7F58:00003FF8244824483FF8000000007FFC010003000570090C3102C10001000100
+7F59:00007FFE400288241010210801000100FFFE03800540092011102108C1060100
+7F5A:00007FFC444444447FFC0000200810880088F088108810881488180810280010
+7F5B:00007FFC444444447FFC000000781FA01220122012101290124822A843248202
+7F5C:00007FFC444444447FFC020001007FFC010001003FF8010001000100FFFE0000
+7F5D:00007FFC444444447FFC00001FF0101010101FF010101FF010101010FFFE0000
+7F5E:00007FFC44447FFC00003FF0002006400180FFFE0282048408803080C2800100
+7F5F:00007FFC444444447FFC01000100FFFE010001001FF01010101010101FF01010
+7F60:7FFC444444447FFC00003FF8200820083FF8208020803FFC208020442C24301C
+7F61:00007FFC444444447FFC000000007FFC0100110011F8110011001100FFFE0000
+7F62:00007FFC444444447FFC010001003FF801000100FFFE0400082010103FF81008
+7F63:00007FFC444444447FFC01003FF801000100FFFE000001003FF801000100FFFE
+7F64:00007FFC444444447FFC082004407FF801083FF821003FFC0304051419086100
+7F65:7FFC44447FFC00001FF010101FF000003FF820083FF820083FF8200820282010
+7F66:7FFC44447FFC000000F87F00221011203FE000400080FFFE0100010005000200
+7F67:00007FFC444444447FFC082008207EFC08201C301A702A6848A4892208200820
+7F68:3FF8244824483FF802007FFC044009203FF8D1161FF011101FF40104010400FC
+7F69:00007FFC44447FFC010001FC01003FF820083FF820083FF80100FFFE01000100
+7F6A:00007FFC444444447FFC000004407C7C044004407C7C04400440FC7E04400440
+7F6B:00007FFC444444447FFC000008207F200820FF30082808247F2408200F20F020
+7F6C:7FFC44447FFC00003EF8020814D00820145062883EF80288145008203458C286
+7F6D:00007FFC444444447FFC00500048FFFE00403E4022243E2800120E2A70C60302
+7F6E:7FFC444444447FFC0100FFFE02001FF010101FF010101FF010101FF01010FFFE
+7F6F:00007FFC44447FFC01003FF808200440FFFE00001FF010101FF010101FF01010
+7F70:7FFC444444447FFC080004047FA400243F2400243F2400243F2421043F142108
+7F71:7FFC444444447FFC0100FFFE01003FF8244822882FE821083FF8210821282010
+7F72:00003FF8244824483FF802001FD00220FFFE03000FF03810CFF008100FF00810
+7F73:7FFC444444447FFC00001FF0111011101FF0111011101FF001004884481287F2
+7F74:3FF8244824483FF8010001003FF80100FFFE040008201FF00010488844448444
+7F75:7FFC444444447FFC00001FF811001FF011001FF011001FFC0004292444940008
+7F76:7FFC444444447FFC040079FC40444844545462883FF821083FF821083FF82008
+7F77:7FFC444444447FFC1080249842E07E8400847E7C42807E9842E07E844284467C
+7F78:7FFC444444447FFC10080808FF0800FE7E0800887E4800487E0842087E284210
+7F79:00007FFC444444447FFC10A0109019FE552053FC952011FC1120112011FE1100
+7F7A:7FFC44447FFC1110222011101FF011101FF011101FF001007FFC05401930E10E
+7F7B:7FFC444444447FFC00003F0821083F0820FE2E0820483F2844285508A4A80C10
+7F7C:7FFC44447FFC00003FF821083FF821083FF80920FFFE09203FF801007FFC0100
+7F7D:7FFC444444447FFC00007FFE42004A4452A4452448A452244AA4530444949848
+7F7E:3FF8244824483FF8082004403FF8292825483FF800001FF010101FF010101FF0
+7F7F:00007FFC44447FFC01003FF80440FFFE11101FF011101FF001003FF80100FFFE
+7F80:3FF82AA824482AA80000FFFE02803EF822883EF802803FF821083FF821083FF8
+7F81:00007FFC44447FFC22007F7822083E4808487F7C49047F0408F4FF0408140808
+7F82:7FFC444444447FFC100011FC25047DFC080011FC25047DFC010455FC5504810C
+7F83:7FFC44447FFC0820FFFE08201FF010101FF01010FFFE09203FF8D11611300100
+7F84:7FFC444444447FFC1020103C24207DFC090411FC25047DFC002055FE54208020
+7F85:00007FFC444444447FFC1050148825FE7A9010FC24907EFC009054904AFE8A80
+7F86:7FFC44447FFC108024987EE000847E7C42007E9842E07E844284467C24884244
+7F87:7FFC444444447FFC2820FDFC2820385010887DFE54087DE81128FDE810081018
+7F88:00007FFC444444447FFC2800FDFE292039FC11207DFC55207DFE1002FEAA1004
+7F89:7FFC444444447FFC000021082390482473B820104BA4783E0388AAACABCA8298
+7F8A:0820042004407FFC0100010001003FF8010001000100FFFE0100010001000100
+7F8B:092009200920F93E09200920082001007FFC01000100FFFE0100010001000100
+7F8C:0820042004407FFC010001003FF802000200FFFE04800480088010822082C07E
+7F8D:020002007FFC044008203018C82604407FFC01003FF80100FFFE010001000100
+7F8E:1010081004207FFC010001003FF80100FFFE010001007FFC028004401830E00E
+7F8F:220412041408FF90082008447F0408080810FFA208420804100810102060C180
+7F90:08200820F83E082001003FF801000100FFFE04000FE01040608003401C30E00E
+7F91:082004407FFC01003FF80100FFFE040007E0082010406080014006201818E006
+7F92:441024502850FE50108810887D0412FA1048FE48104810482088208841288210
+7F93:4400240029FCFD24112411247D24112411FCFD00110011002102210240FE8000
+7F94:0820042004407FFC0100010001003FF8010001000100FFFE0000488844448444
+7F95:082004407FFC01003FF80100FFFE010000801F0001047D88095011202518C206
+7F96:440024F82888FE88108811067E0011FC1084FE84104810502020205040888306
+7F97:0820042004407FFC010001003FF802000200FFFE049004A408BC10822082C07E
+7F98:01043C842488240027FE3C20242025FC24203C2027FE24202420442054208820
+7F99:082004407FFC010001003FF801000100FFFE010011101120228004401830E00E
+7F9A:442024202850FC50108811247E12101011FCFC04100810882050202040108010
+7F9B:082004407FFC01003FF80100FFFE04407FF804483FF824403FFC084410542048
+7F9C:444024202820FDFE110212047C00100011FEFC20102010202020202040A08040
+7F9D:4404241E29F0FD10111011107D1011FE1110FD1011101108210A214A41A68112
+7F9E:082004407FFC01003FF80200FFFE04000FF011102110CFF0021002103FFE0000
+7F9F:440025FC2808FC10103010487C8413021000FDFC102010202020202043FE8000
+7FA0:442024202BFEFC2011FC10247DFC112011FEFC22102A10542050208841048202
+7FA1:082004407FFC01003FF80100FFFE4080208009FC12042448E04020A023182C06
+7FA2:441424122810FDFE101010907C92109213F2FC9410941088208A211A41268242
+7FA3:3FF80208FFFE04083FF808001FF82808CFF804407FFC01003FF80100FFFE0100
+7FA4:00827E44122812FEFF10121012107E7C201020107E1062FEA21022103E102210
+7FA5:440025FE2800FC92112412487D2410921000FDFE102010202020202043FE8000
+7FA6:4420241029FEFD02120410F87C00100011FEFC501050105020922092410E8200
+7FA7:444024402888FD0413FE10027C8811441242FCF8118812502020205041888606
+7FA8:082004407FFC01003FF80100FFFE0080208011FC820454482040E0A023182C06
+7FA9:082004407FFC01003FF80100FFFE02403C500848FFFE08480E5078240854198C
+7FAA:4440242029FCFD04110411FC7D04110411FCFD20112211142108214441828100
+7FAB:4440242029FEFD02120410507C8811041000FDFC102010202020202043FE8000
+7FAC:8808480C500AFBFE22082208FAE8220A220AFAEC22AC22A822EA421A42268442
+7FAD:884048A05110FA0825F62000FBC422542254FBD42254225423D44244425482C8
+7FAE:04407FFC01003FF80100FFFE248842443FF801001FF00100FFFE02800C60701C
+7FAF:440025FC2904FDFC110411FC7C8011FE1222FD221152110221FA200240148008
+7FB0:442025242924FD2411FC10807C8013FE1090FD101152125422A8242848448082
+7FB1:440025FE2910FD20117C11447D7C1144117CFD10111011542152229242508420
+7FB2:04407FFC01003FF80100FFFE00283E240824FFFE2A207D2490A81E12022A0C46
+7FB3:443C27E02924FCA813FE10A87D24120211FCFD24112411FC2124212441FC8104
+7FB4:082004407FFC01003FF80100FFFE454429287CFE10107C7C1010FEFE10102010
+7FB5:442025FC2820FC8813FE10887DFC110411FCFD0411FC110421FC208841048202
+7FB6:88204BFE5000FBFC220422F4FA9423FC2000F9F8210821F8210841F8400083FE
+7FB7:442024202850FC88110412FA7C00100011DCFD54115411DC2088208841548222
+7FB8:0100FFFE20003FF800003FF820083FF80440729C57D47114539C711657D6B122
+7FB9:04407FFC01003FF80100FFFE482482823FF801001FF00100FFFE02800C60701C
+7FBA:880049FC5020FBFE222221ACF82021AC2000FBFE202021FC215441544154810C
+7FBB:88204BFE5250FBFE225223FEFA0023FE2292FB48223A224022FC4548443089CE
+7FBC:3FFC20043FFC22202FF8208027F020803FFC2AA83F7C24105F7C4410BF7E0810
+7FBD:00007EFC0204020422441224122402040A14122462C422440204020414280810
+7FBE:0000EE00227C2210AA1066102210221026106A10B210221022102210AAFE4400
+7FBF:00007EFC22441224060C1A3462C40204042004207FFE04200420082010202020
+7FC0:0010EE1022102210AAFE66922292229226926AFEB292221022102210AA104410
+7FC1:0440082012102408C8261FF0001000007EFC224412240A14122422444A940408
+7FC2:0008EE2822282228AA4466442282237C26246A24B224222422442244AA944508
+7FC3:080008EE08227E2210AA1066202228224826486A90B2142222227E2222AA0044
+7FC4:0010EE10221022FEAA10661022FC224426446A44B228222822102228AA444482
+7FC5:100011DC1044FE44115410CCFC4444CC45542844284411541888240043FE8000
+7FC6:00007EFC224412241A3462C404003FC004400844113C2100FFFE010001000100
+7FC7:00007EFC224412241A3462C4022401107FFE020007F00A10112060C003301C0E
+7FC8:00007DDC5444544455547CCC54445444544C7CD4556410441044104411541088
+7FC9:100011DC1044FC44115430CC38445444524C90D411647C441044104411541088
+7FCA:200013DE1042FC420252094A894A884248C6494A525250421C42E042414A0084
+7FCB:0020EE10221022FEAA0066042244224426246A24B228222822082210AAFE4400
+7FCC:00007EFC22441224060C1A3462C4010000807FFC0000101008200440FFFE0000
+7FCD:0010EE10221022FEAA926694229022FC26A46AA4B2A822A822902328AA444482
+7FCE:100011DC28442444435490CC08440044FC4C04D4096450442044104411540088
+7FCF:00007EFC224412241A3462C4030406C01830E30E0C403180063038C007003800
+7FD0:0010EE1022502250AA7C66902310221026FE6A10B228222822282244AA444482
+7FD1:0040EE40228022FCAB04660422F4229426946A94B2F4229422042204AA284410
+7FD2:00007EFC224412241A3462C4010402001FF8100810081FF8100810081FF81008
+7FD3:100011DC1044FE44115410CC7C440044004C7CD44564444444447C4445540088
+7FD4:440025DC2844FE44115410CC7C441044104CFED4116410442044204441548088
+7FD5:010006C01830EFEE00001FF010101FF000007EFC224412240A1412246AD40408
+7FD6:100011DC28442444435480CC7C440044004C7CD44564444444447C4445540088
+7FD7:100010EE3E224222A4AA186610222422C8261F6A21B2D2220C22082230AAC044
+7FD8:200021DCFE442444295412CC2A44C6CC0154FC4428442954288A480247FE8000
+7FD9:100092EE92229222FEAA206620223E224226426AA4B214220822102220AAC044
+7FDA:7EFC224412241A3462C400007FFE42029FF4040009001FF001007FFC01000100
+7FDB:108010F811082290286069986E06ABB828882AA8299829982AA8288822A82110
+7FDC:00007EFC224412241A3462C4020401007FFC092009201550228804401830E00E
+7FDD:100008EE7F22412292AA10667F2210221426246A24B228224A225122BFAA1144
+7FDE:0020EE1022FE2200AA00667C22442244267C6A10B254225222922210AA504420
+7FDF:00007EFC224412241A3462C4020409001FFC30805FF890801FF810801FFC1000
+7FE0:00007EFC224412241A3462C4020401007FFC0820145022880100FFFE01000100
+7FE1:04407C7C04403C7804407C7C0440044000007EFC224412240A1412246AD40408
+7FE2:00007F6E492249225DAA49667F2241225D26556A55B25D2241224122452A8264
+7FE3:7EFC22441A3462C4020401003FF80820FFFE04007FFC08201C4003800C707008
+7FE4:00007CEE442244227CAA0066FE22AA22AA26AA6AFEB2AA22AA22AA22A2AA8644
+7FE5:01081FD001207FFC02000FF03810CFF008100FF000007EFC22441A3462C4060C
+7FE6:0820FFFE00003E0822483E4822483E482208261800007EFC22441A3462C4060C
+7FE7:200011DCFE44824401547CCC00447C44444C7CD445647C4400441C44E1544088
+7FE8:7EFC22441A3462C402041FF010101FF010101FF000007FFC110011F8290047FE
+7FE9:100008EE7E22422242AA7E66422240227F26556A55B27F22D522552255AA4344
+7FEA:0028EE9222AA2282AAFE6628224422A2263C6A44B24422A822102228AA444482
+7FEB:0000EE7C2200AA006600AAFE225010507E50425042507E52425242927E8E4300
+7FEC:7CF82448142824487FFC41043FF801001FF011101FF011101FF00100FFFE0100
+7FED:0040EE5C22442284AABE66902390229E26A86A88B2BE228822882294AA9444A2
+7FEE:0000FEEE00227C2244AA7C660022FE228226AA6A92B2FE229222922292AA8644
+7FEF:7CF8244814282548FFFE00001FF010101FF000007FFC40044FE448244FE4400C
+7FF0:102010201050FE8811067C0045DC7C4445547CCC1044FECC1154104411541088
+7FF1:100021DC7C4444447D5444CC7C441044FE4C28D4556492447C44104411541088
+7FF2:0000FEEE2822FE22AAAAAA66FE2200227C26006AFEB210225422922250AA2044
+7FF3:00007F7848485F4C64805F7844484A4851307F4C00007EFC22441A3462C4060C
+7FF4:0010EC1026FE2510B57C6C54247C2754257C6D10B5FE251025102690B47E4800
+7FF5:0010EE20227C2244AA7C6644227C2240267E6A40B27E220222AA22AAAB02440C
+7FF6:100021DC7C4444447D5444CC7C441044544C38D455641044FE44104411541088
+7FF7:080049EE2A220822FFAA2A66492288224226776A92B25A222F22222242AA8244
+7FF8:10007EEE10222422FEAA24667E2242227E26426A7EB242227E22242242AA8144
+7FF9:10007DDC1044FE444554EECC4444EECC0154FC4428442954288A480247FE8000
+7FFA:2000FEEE8222FE2282AAFE668222FE221026926A54B292221022FE2210AA1044
+7FFB:0E00F1DC92445444FF5438CC544482447C4C54D455647C44544454447D544488
+7FFC:7EFC22441A3462C402043FF821083FF821083FF804403FF80440FFFE08201010
+7FFD:08004E764812FF12045A05367F9244127C125536555A75125A12929225DAC8A4
+7FFE:0000FEEEAA22AA22FEAA0066FE2200227C26446A7CB22A226422A22231AA2044
+7FFF:1000FEEE10227C2200AAFE6602227C221026FE6A00B2FF220222FF22AAAAE644
+8000:100011DC9044555458CC1154FC00284828FE29902AFC28902AFC4C9048FE8080
+8001:020002083FD002200240FFFE010002000C1018E02F0048088808080807F80000
+8002:020002083FC802100220FFFE0080010002000C003000C0000000000000000000
+8003:020002083FD002200240FFFE010002000FF81200240047F08010001000A00040
+8004:02203FC00280FFFE02200FC03408C3F8000001F03E0003F03E0003FA7E0201FE
+8005:020002083FD002200240FFFE010002000FF0181028104FF0881008100FF00810
+8006:02083FD00220FFFE02000C703F84C80407FC00001FF010101FF010101FF01010
+8007:020002083FD002200240FFFE03001C00EFF810082FC8C8480FC8000800500020
+8008:02203FC00280FFFE02200FC03408C3F810003FF840089F8810881F8800500020
+8009:020002103FE00240FFFE010007F81C00E7F800081F88108810881F8800500020
+800A:020002103FE00240FFFE010006001FF0E40008201FF001001FF001007FFC0000
+800B:02203FC00280FFFE02200FC03408C3F800007FFC08201FF001001FF001007FFC
+800C:00007FFC0100010002003FF82488248824882488248824882488248820282010
+800D:0000FFFE020004003FF82488248824A822100200FFFE08201C4003800C707008
+800E:0000FFFE020004003FF824882488248824A8211001007FFC028004401830E00E
+800F:0002FFE20404040808107FC24A424A444A484A504A424A424A444848415040A0
+8010:0008FF880808080810FE7F085508550855485528552855085508550841284310
+8011:01002108210821083FF800000000FFFE020004003FF824882488248824A82010
+8012:010001007FFC010001003FF801000100FFFE0380054009203118C10601000100
+8013:1000100011FEFE1010107C101010FE1010103810341054105010901010501020
+8014:100010FC1004FC08100878101010FDFE10103810341054109010101010501020
+8015:108810881088FE8811FC7C881088FE8813FE3888348854885088910811081208
+8016:102010201020FCA810A478A21122FD2012243824342854089010102010C01300
+8017:1008101C10E0FE2010207C3C10E0FE201020383E35E05420502290221022101E
+8018:100010FC1000FE0010007C0011FEFE201020384034485484508491FE10821002
+8019:1000100011FCFD24112479241124FD2411FC3900350055009102110210FE1000
+801A:101010101010FDFE111279141110FDFC11443944352855289110122812441482
+801B:102010201020FE4010487C8411FEFE82100038FC348454845084908410FC1084
+801C:100011F81108FD081108790811F8FD00110039FC350455049104110411FC1104
+801D:100010F81088FE8810887CF81088FE88108838F8348854885088908813FE1000
+801E:110011001100FD1C13D479541154FD5411543954355455549154125C13541480
+801F:100011FE1100FF0011007DFC1104FF041104390435FC55005100910011FE1000
+8020:102010201050FC8811047A0211FCFC00100039FC350455049104110411FC1104
+8021:1008100813C8FE48125E7A4A13CAFE4A124A3BCA364A524A526A93D216121026
+8022:1088108813FEFC8810007BFE1202FC4410403BFC344454849084110412281410
+8023:102010201050FC8811047AFA1000FDFC1154395435FC5554915411541104110C
+8024:104810481048FDFE1048784811FEFC0010FC3884348454FC9084108410FC1084
+8025:1020112410A4FCA810207BFE1202FE0212FA3A8A368A528A52FA9202120A1204
+8026:11FC11241124FDFC1124792411FCFC2010203BFE3622522A52FA920A12021206
+8027:1020112410A8FC2013FE78A81124FE0210403BFE348851085190906011981604
+8028:100011FE1100FD7E110079FE1154FD4811643942350851FE5148922812081418
+8029:1088108813FEFC8811FC788813FEFC2011FC392435FC512453FE910411141108
+802A:1040102013FCFD0810907BFE1202FC4410203BFC348054F89088110811281210
+802B:102013FE1020FDFC10207BFE1000FDFC110439FC350455FC910411FC10881104
+802C:102011FC1124FFFE112479FC1020FDFC112439FC344055FE908811D01070138C
+802D:1124112412AAFFAE11247AAA13AEFD2413FE391035145114528A924A12161422
+802E:1048116A10DCFE4810B47D2211FEFF021020382034FC54245044904410941108
+802F:108813FE10A8FC9011FE7B2011FCFD2011FC392035FE550093FC10881070138E
+8030:13FC104011F8FD0811F8790817FEFC4212A43A8A347A508051F892881070138E
+8031:1040102013FEFE4813FE7A4812ECFF5A12483BFE3620527C52C49344147C1844
+8032:1040102013FEFC0011FC795411FCFC201122388C3522545490C8114412521060
+8033:00007FFC101010101FF0101010101FF010101010103E17D0F810001000100010
+8034:0020FFA0222022203E20222022203E202220222027A0FA2242220222021E0200
+8035:0000FF80227E22083E08220822083E08220822082788FA084208020802280210
+8036:0000FFBE222222243E24222822243E242222222227A2FA344228022002200220
+8037:010001007FFC0280044008203FF8C8260FE008200FE0082009F87E2000200020
+8038:0820082014502288410400007FFC10101FF010101FF01010103EFFD000100010
+8039:0020FF20242024503C50248825443E22242024F82E08F4084410041004200420
+803A:0000FF0024FC24003C00240025FE3C20242024402E40F488448405FE04820400
+803B:0010FF10241024903C902490249E3C90249024902E90F4904490049005FE0400
+803C:0000FF7C244424443C4424FE24443C44244424FE2E44F4444444044404540448
+803D:0040FC4048404BFC7A444C484840784048A048A04CA07920C9220A220C1E0800
+803E:0040FF40244024403DFE244024403C50249024902EA0F5284544064404FE0442
+803F:0020FF20242024243CA424A424A83D20242024502E50F4504488048805040602
+8040:0048FF44244424403C5E25E024403C44244424482E30F4224452048A05060402
+8041:0010FC9048904888790849044A047DFA488848884C887888C90809080A280C10
+8042:00007FFC08200FE008200FE0083EFFE000203EF8028822881450082034D8C306
+8043:0020FF20242025FC3D24252425FC3D24252425242FFEF5044504050405140508
+8044:0020FC204850488879044A1248207840498848104C207844C988081008600B80
+8045:0040FC40488048FC79204A20482078204BFE48204C507850C888088809040A02
+8046:0020FF20245024503C88252426123C1025FC24042E08F4884450042004100410
+8047:0000FF0024FE24103C10241024903C90249E24902E90F4904490049007FE0400
+8048:0010FC9048904910797E4A524B927892491249124E527BD2C8620822084A0884
+8049:0010FF10249224923C92249224FE3C10241024922E92F4924492049204FE0402
+804A:0000FC804B1E4A527A524A524A527A524A524AD24F5A7A54C890089009100A10
+804B:04800440FFFE0940118466FC00007FFC08200FE008200FE0083EFFE000200020
+804C:0000FF0024FC24843C84248424843C8424FC24842E00F4484444048404820502
+804D:0040FC2048204BFE7A024C04480078004BFE48204C207820C820082008A00840
+804E:0050FF50245025523CD4245824503C5824D425522E50F450449204920512060E
+804F:0000FDFC48204820784049FC49547954495449544D547954C954094409140908
+8050:0020FC2048204BFE7820482049FC7800480049FC4D047904C904090409FC0904
+8051:0000FDFE48884888788848F84888788848F848884C88789ECBE8080808080808
+8052:0008FF1C24E024203C2025FE24203C20242024FC2E84F4844484048404FC0484
+8053:00007DF0111011901D52F20E04007FFC08200FE008200FE0083EFFE000200020
+8054:0088FC484850480079FC4820482078204BFE48204C507850C888088809040A02
+8055:0020FD20492049FC79204A2048207BFE480048004DFC7904C904090409FC0904
+8056:00007F00227C3E4422443E4423C4FE7C024402007FFC01003FF801000100FFFE
+8057:0020FC2048204BFE782048204924792449244AAA4C207850C850088809040A02
+8058:0020FC2049FC492479FC492449FC78004BFE48804D0079FCC804080408280810
+8059:0020FC204BFE482079FC48204BFE780049FC49044DFC7904C9FC090409140908
+805A:7F00227C3E0422283E1023A8FE44020000F87F0009041188635005201918E106
+805B:0020FF4024FE24923C9224FE24923CA224FE24482E88F5FE4408040804080408
+805C:0020FF10241025FE3D02265424883D04240024FC2E20F4204420042005FE0400
+805D:0014FC12481049FE7810481049D27952495249544DD47808C8CA0B1A08260842
+805E:00007C7C44447C7C44447C7C40044FE4444447C4444447C444745FC440544048
+805F:20003E7C4844FF441444227C40007FFC08200FE008200FE0083EFFE000200020
+8060:0084FF48240024FC3C48244824483C4825FE24482E48F4484448048804880508
+8061:0090FC90490849487A444C9249087BFC484448204CA47A82CA8A0A8A0C780800
+8062:0020FF1024FE24823D04240024FE3C10241024902E9EF490449004D0053E0600
+8063:0000FF2024CE24823C8224EE24823C8224FE24282E28F4284448044A048A0506
+8064:0040FC204BFE480079FC490449FC78004BFE4A024DFC7820C820082008A00840
+8065:0004FC1E4BE0482079FC4924492479FC48204BFE4E227A2ACAFA0A020A0A0A04
+8066:0080FC8048FC49547AD448B4492C7A44489449084C4078A4CAAA0A8A0C780800
+8067:0010FDD448584A52798C488849047AFA482048204DFE7820C850088809040A02
+8068:0108FD4A4A524B9C79084A524BDE7842488848884FFE7888C888090809080A08
+8069:0020FC2049FC492479FC48204BFE780049FC49044D247924C924085008880B04
+806A:0088FC48485049FC79044904490479FC482048104C547942C942094A0A380800
+806B:0108FD4A4A524B9C79084A524BDE7842482048204FFE7820C850088809040A02
+806C:0090FC8849044A427C8849FC480478004BDE48424E52794ACA520842094A0884
+806D:0010FF2024FE24923C9224FE24923C9224FE24202E24F45A445E04900492050E
+806E:0084FC844908494A7A524B9C48847908494A4BDE4C427800C954092A0A2A0800
+806F:0108FD4A4A524B9C79084A524BDE784248904A924E927B9EC890089008900910
+8070:0020FC4049FC4924797C498C49547924495449FC4C407824CAA20A8A0C880878
+8071:08207F20087E7E4408A4FF2810101E2822447FFE88200FE0083EFFE000200020
+8072:08007F7808483E4800863E782A483E304048FFFE08200FE0083EFFE000200020
+8073:11102110CAA814443278D24015FC18007FFC08200FE008200FE0083EFFE00020
+8074:0020FC204BFE4840784049FC4954795449FC48404C247AA2CA8A0C8808780800
+8075:0020FDFC492449FC78204BFE480079FC490449FC4D0479FCC90409FC08880904
+8076:7FFC08200FE008200FE0083EFFE000207EFC24483C7824483C78264EFDF80408
+8077:0110FC944BD248127A5049904FFE78104BD24A524E547BD4CA4A0A4A0BD60822
+8078:0080FCF849084BFE7944499249FE7900497C49004D7C7900C97C0A440A7C0C44
+8079:0040FC204BFE4A227954494A4A3A780049FC49544FFE7800C9FC082008A00840
+807A:0040FC204BFE4A02791049DE4A527D544A8849744E0279FCC82009240A220860
+807B:42043FD88A904F9E2A945FD482247FFC08200FE008200FE0083EFFE000200020
+807C:002078200BFE1020FDFC4954495479FC48007BFE48405C24EAA24A8A0C880878
+807D:0020FC204BFE782049FC79544954F9FC0800FBFE284078242AA2FA8A0C880878
+807E:08403E7C1440FF7822083E782242263E00007FFC08200FE0083EFFE000200020
+807F:010001003FF80108FFFE01083FF8010001003FF801000100FFFE010001000100
+8080:010001003FF80108FFFE01083FF8010801000100010001000100010001000100
+8081:010000803FFC20043FFC20802FF820883FFE20882FF820804FFC4080BFFE0080
+8082:00200020FDFC202423FE3C2445FC4420642095FC0820082013FE202040208020
+8083:010001003FF80108FFFE01083FF8010021082548252825282928410841088108
+8084:40204C2070FC442445FE3C2440FC7C20902011FCFE20102029FE242044208020
+8085:01003FF80108FFFE01083FF8054025483D7821083FF821083D78254845488108
+8086:00203E2020FC20243DFE202420FC3C20202021FCFE20202025FE4220FE204220
+8087:08403E7E22A83E10206E41009FF00110FFFE01101FF001003FF80100FFFE0100
+8088:08243E3E22E83E12202A41469FF00110FFFE01101FF001003FF80100FFFE0100
+8089:0100010001007FFC410442844444492451044104428442444444480440144008
+808A:00003E0022FC220422083E102220222022403E4022802282228242824A7E8400
+808B:00203E202220222022FE3E222222222222223E2222422242224242824A948508
+808C:00003CF02490249024903C902490249024903C902490249224924512550E8A00
+808D:00403C402440244025F83C482448244824483C482448244A248A448A55068A00
+808E:00007FFE4002800400001FF0101010101FF0101010101FF01010101010501020
+808F:0600010002800C603118C1063FF8228824482928210822882448200820282010
+8090:00403C40248024FE25003E0024FC240824103C20244024802502450254FE8800
+8091:00403C40248024FC25043E042404250424843C44244424042404440454288810
+8092:00403C402440244025F83C482448254824C83C482468245A248A448A55068A02
+8093:02000100FFFE100010001FF800001FF010101FF010101FF01010101010501020
+8094:00203C2024202520252C3D34256427A425243D34252825222522450254FE8800
+8095:00003C0024FC242424243CA424A424A424A43D24242424442444448455288A10
+8096:010021081110092001003FF8200820083FF8200820083FF82008200820282010
+8097:00403C402440244027FE3C882488248824883D08249024502420445054888B04
+8098:00083C082408240825FE3C082408240824883C48244824082408440854288810
+8099:1FF0101010101FF000003FF8200820083FF8200820083FF82008200820282010
+809A:00203C202420242024203C2025FC242024203C20242024202420442057FE8800
+809B:00003C0025FC242024203C202420242024203C20242024202420442057FE8800
+809C:00043E042208221022203E442204220822103E2222422204220842104A2084C0
+809D:00003DFC2420242024203C20242027FE24203C20242024202420442054208820
+809E:00403C242524250425043C882488248824503C50242024202450448855048A02
+809F:00003CFC2400240024003DFE2440244024803CFC240424042404440454288810
+80A0:00003DF82410242024403C8025FE249224923C92251225222622444254948908
+80A1:00003CF82488248824883D06260025FC24843C84244824502420445054888B06
+80A2:00203C20242025FE24203C20242025FC24843C88244824502420445055888E06
+80A3:00203C202450245024883D442622242024003DFC240424082408441054108820
+80A4:00203C202420242025FC3C202420242027FE3C20245024502488448855048A02
+80A5:00003DFC2524252425243D24252425FC25043D00250025002502450254FE8800
+80A6:00103C502450245034882C88250426FA2C483448244824482488448855288A10
+80A7:00003C0025FE241024103C202420246824A43D22262224202420442054208820
+80A8:00203C20242025FC24203C20242025FC24203C20242027FE2420442054208820
+80A9:010000801FF8100810081FF8100017F8140817F8140827F82408440884280410
+80AA:00403C20242025FE24403C402440247C24443C44244424442484448455288A10
+80AB:0040784048404BFC48407A484A484A484A487BF84848484048424842483E9800
+80AC:00403C502448244824403DFE2450245024503C502490249024924512550E8A00
+80AD:00203C20242025FE25223D222522252225523D4A258A250225024502550A8904
+80AE:00403C20240025FC24003C0024F0249024903C902490249224924512550E8A00
+80AF:0100010011F811001100FFFE00001FF010101FF010101FF01010101010501020
+80B0:00203C282424242424203DFE2420242024203C50245024502488448855048A02
+80B1:00407840484048404BFE7840488048904890792049204A484A444C8449FE9882
+80B2:02000100FFFE080010103FF800081FF010101FF010101FF01010101010501020
+80B3:00803C80248024FC25543E542454249424943D24262424442444448455288810
+80B4:18180660018006603A180200FFFE04000FF818082FF848088FF8080808280810
+80B5:00043C0E24F0248024803C8024FE248824883C88248824882488450855088A08
+80B6:00103D102510251225123D1425D8251025103D102510251225524592550E8800
+80B7:00403C402440247C24843C882520242024203C50245024502488448855048A02
+80B8:00103C902490248825083D042624242224203DFE242024202420442054208820
+80B9:00483C482484248425023E0025FE244024803CFC240424042404440454288810
+80BA:00203C20242027FE24203C2025FC252425243D24252425342528442054208820
+80BB:010001F8010001003FFC200440081FF010101FF010101FF01010101010501020
+80BC:00887888488848884BFE7888488848884FFE7888488848884888490849089A08
+80BD:00203C202420242024203DFE2420242024203C5024502450248844C855248A02
+80BE:040025F824882450242024D8270604001FF010101FF010101FF0101010501020
+80BF:00203C202420242025FC3D242524252425243DFC252424202420442054208820
+80C0:00803C842484248824903CA0248027FE24A03C9024902488248444A254C08880
+80C1:00807880488048804BF0789048904A984A947C9248924890491049104A509C20
+80C2:00203C20242025FC25243D24252425FC25243D24252425FC2524442054208820
+80C3:00003FF821083FF821083FF800001FF010101FF010101FF01010101010501020
+80C4:010001003FF821083FF821083FF800001FF010101FF010101FF0101010501020
+80C5:00203C202520252025FC3D202620242025FE3C20245024502488448855048A02
+80C6:00003C0024FC248424843C8424FC248424843C8424FC24842400440055FE8800
+80C7:00503C50245025FC24543C5425FC255025503DFE24522452245A449454908910
+80C8:00503C482448244025FE3C402440247C24A43CA424A825282510462854448882
+80C9:00103C10242024FC24843C842484248424FC3C84248424842484448454FC8884
+80CA:00803C80250025FC36042C0425E425242D24352425E425242404440454288810
+80CB:00203C2024202420243E3C202420242025FC3D04250425042504450455FC8904
+80CC:048004987CE004841C84E47C40001FF010101FF010101FF01010101010501020
+80CD:0008781C49F049504950795049504950495079484948496849544A744A529C00
+80CE:00203C202420244024483C8425FE248224003CFC248424842484448454FC8884
+80CF:00203C20242E25F025203D20252025FE24223C6224A2252A2624442054208820
+80D0:00203C202524252435242D2425FC24202C203524252425242524452455FC8804
+80D1:00003C0024FC248424843C842484248424FC3C84240024482444448454828902
+80D2:00003CFC2484248424843CFC248024A024A23CA424B824A024A24522551E8A00
+80D3:00003DFC2420242025243CA424A8242027FE3C20242024202420442054208820
+80D4:088008882E9028E028842E84F07C01003FF82288244829282108228824482018
+80D5:00443C442444248424BE3D84268424A424943C94248424842484448454948888
+80D6:00203C20252424A424A83C2025FC242024203C2027FE24202420442054208820
+80D7:00203C202450248825043E122420244025883C10242024442588441054608B80
+80D8:00203C10241025FE24203C202444248425F83C1024202444248245FE54828800
+80D9:00803C80248024FE25403D402640247C24403C402440247E2440444054408840
+80DA:00007BFC482048204840784048D049484A447C4448404840484048004FFE9800
+80DB:00003DFC2524252425243DFC2524252425243DFC252424202420442054208820
+80DC:002078204920492049FC79204A204820482079FC48204820482048204BFE9800
+80DD:00043C1E25F0251025103D10251025FE25103D1025102508250A454A55A68912
+80DE:0080788049FC49044A047DF449144914491479F4490449284912490248FE9800
+80DF:00003CFC248424A424943C84248427FE25043D442524250425FE440454288810
+80E0:00203C20242025FC24203C20242027FE24203C2024402448248445FE54828800
+80E1:0800087C084408447F44087C08443E442244227C224422443E84228401140208
+80E2:00003C0025FE240824083DE82528252825283D2825E825282408440854288810
+80E3:0080788048FE49004A207920492C49744BA47924493449284922490248FE9800
+80E4:01002208244827882108224827C8200827C8244827C8244827CA444A444A84C6
+80E5:7FFC0104110011F81100290047FE80001FF010101FF010101FF0101010501020
+80E6:00203C20242025FC25243D242524252425243FFE242024502450448855048A02
+80E7:00907888488848804BFE78A048A048A448A478A84928493249224A624A9E9C00
+80E8:0040784048404FFE4880792049204A204BFC7820492849244A224C2248A09840
+80E9:00403C402440247C24403C40244027FE24403C40245024482444444054408840
+80EA:00203C20243C242024203CFC2484248424843CFC248424802480450055008A00
+80EB:000079FC480848104830784848844B02480079FC48204820482048204BFE9800
+80EC:10001000FEFC2244642818102428C2C601003FF8228824482108228824482018
+80ED:00003DFC2504252425243D2425FC252425243D54254C258C2504450455FC8904
+80EE:0080788048FC49084A90786049984E26482079FC48204A204BFE482048209820
+80EF:00203C2025FC245024883D0426FA240027FE3C40248025FC2404440454288810
+80F0:004078404FFC48404BF878484BF84A404BFC7844485448A848A049104A089C06
+80F1:004078444A444948495078404FFE48904890789048904892491249124A0E9C00
+80F2:004078204BFE48404890789049244BE448447848488849104A30484848849B04
+80F3:00403C402478248825503C202450248825063CF8248824882488448854F88888
+80F4:00007BFC4A044A044AF47A044A044AF44A947A944A944AF44A044A044A149A08
+80F5:00003DFE2420244024883D0425FE242224203C2025FE24202420442057FE8800
+80F6:0040782048204BFE4800788849044A0248887888485048504820485048889B06
+80F7:10001FFC20045454939414541FF400081FF010101FF010101FF0101010501020
+80F8:01007900490049FE4A027A024D1248A24A4A7AAA4B1A4A0A4BFA480248149808
+80F9:00003DFC2420242024403DFC2554255425543D54255425542554454455148908
+80FA:0040782048204BFE4A027C4448404BFE48887888490848D04820485048889B04
+80FB:00807880493C4A004C807880497E4B084D087908490849084908490849289910
+80FC:00843C48240024FC24483C482448244825FE3C48244824482448448854888908
+80FD:104024444248FF70014000427E42423E42007E44424842707E4042424A42443E
+80FE:082008287F240820FFFE002008247F24492455286B2849105512632A45464282
+80FF:00203C2025FC242024203C2027FE240024203C2025FC24202420442057FE8800
+8100:1FC000447D88055009203518C2063FF800001FF010101FF010101FF010101030
+8101:00503C502450255234D42C58245024582CD43552245024502492449255128A0E
+8102:01003D04253825C025023D0224FE240025FC3D04250425FC2504450455FC8904
+8103:00803C8024F8250826103DFC2524252425243DFC250025002502450254FE8800
+8104:0040784048404BFE4880789048904912495279544A904A284C28484448849902
+8105:02001FF00410085010207EFC12242A5444881FF010101FF010101FF010101030
+8106:00403C4024FC250426083DFE2500257C25443D442554254825424542553E8A00
+8107:0040784049FC48444884788449284A1049087BDE494A494A494A4A524B5A9CA4
+8108:0004781E49E049004906797849504950495279544948494849444A544A629C40
+8109:00407820481049E0482278344BB848B048A878A8492849244A244C2248A09840
+810A:2108111009201290244808203FF8C82608200FE0082008200FE0082008A00840
+810B:00001FF00410045008207EFC12442A9445081FF010101FF010101FF010101030
+810C:00803C8024FE251026103C1024FC249024903C9027FE24102410441054108810
+810D:002078204850488849047A0248F8480048007BFE48204840488849044BFE9902
+810E:000479884850482048507888492448204BFE782048A848A449224A2248A09840
+810F:00207810481049FE4900791049104910497C79104910491049104A104AFE9C00
+8110:004078204BFE490448887850482048D84B067888488848884888490849089A08
+8111:0040782048204FFE4800780048904A544A247A244A544A944A044A044BFC9804
+8112:00203C20252424A424A83C20242027FE24703CA824A825242524462254208820
+8113:0020782048204BFE4A427C4448A048A249A47A984C904888488448A248C09880
+8114:02000100FFFE04401450254841043FF822882448292821082288244820082018
+8115:00803C8024F8250826103DFC2524252425243DFC245024502490449255128A0E
+8116:002078204BFE482048207BFE4A024C0449F8781048204BFE4820482048A09840
+8117:00803C8024FC255426543CA42524264424943D0825FC25042504450455FC8904
+8118:004078204BFE4A024C0479F8480048004BFE789048904890491249124A0E9C00
+8119:00283C242424242027FE3C20252024B224B43C6824A825242622442054A08840
+811A:01007900491E4B924912791249124FD2491279124A1A4A944FD04A5048109810
+811B:00007BFC480049244A487C904A48492448007BFC48404840484048404FFE9800
+811C:00003DFE2410242024FC3C84248424FC24843C8424FC24842484448454FC8884
+811D:004078204BFE480049F87908490849F848007BFC480848304820482048A09840
+811E:00203C2024A824A824A83D742622242024203DFC242024202420442057FE8800
+811F:00043C1E25E0242225123C942480240825FE3C08248824482448440854288810
+8120:0004780E4BB8488848887928492E4BA848A87AA84AA8493E49004A804C7E9800
+8121:000078064BB8488848887908493E4B8848887A884A88493E49004A804C7E9800
+8122:00803C8024FE250026FC3C8424A4249427FE3C842524251425FE440454288810
+8123:3FFC20002FF820003FFC24482430260E2FF828082FF848084FF8880808280810
+8124:000079FE49004900497C7900490049FE495079524954494849484A444A529C60
+8125:0020782048204BFE482078204924492449247AAA482048504850488849049A02
+8126:00107814481248104BFE7810489048504848780848884AA84A9A4AAA4C669802
+8127:00403C402488250437FE2C02248825442E4234F8258826502420445055888E06
+8128:00203C2027FE242024203DFC2524252425FC3C20247024A82524462254208820
+8129:1080108011F821082A906C60A9982E0629F8290829F8290829F8210821282110
+812A:00C23C342418246425823C2025FE245024903DFE26922492249A449454108810
+812B:00107890488849084A047DFA49084908490879F848904890489049124A129C0E
+812C:0008783C4BC048044A44792848004BF8481078204FFE48204820482048A09840
+812D:000079FC49044904490479FC480048004BFE7820482049FC482048204BFE9800
+812E:0008783C4BC048444A247928490048404BFE788849084B904860485049889E04
+812F:004878444BFE484048407BFC4A444A444BFC7A444A444BFC4A444A444A549A08
+8130:00003DFE2400240024FC3C842484248424FC3C00248424442448440055FE8800
+8131:010478844888481049FC79044904490449FC785048504890489249124A0E9C00
+8132:00007BFC4A044A044BFC7A004A204A224BB27AB44AA84AA84D244D244AA29840
+8133:00427A2249244904480878004A0A4A8A4A527A224A524A8A4B0A4A024BFE9802
+8134:00003DFE2410242024683CA42522242024003CFC248424842484448454FC8884
+8135:000079FC4904490449FC7800480049FC482078204BFE48204850488849049A02
+8136:000079FC49044904490479FC482048204BFE7A224A524A8A4B0A4A024A0A9A04
+8137:004278E24B82488A488A788A4FEA488A498A79CA4AAA4A824C824882488A9884
+8138:0020782048504850488879044AFA480048447824492448A8488848104BFE9800
+8139:00003CFC248024F824803CF8248027FE25403D24252825102508454455828900
+813A:004078204BFE48004888788849544A22480078204BFE48204820482048209820
+813B:002078204BFE482049FC78244BFE482449FC78204920493E49204AA04A7E9C00
+813C:00007BFE482048204BFE7A224A224B324AAA7AAA4B764A664A224A224A2A9A04
+813D:00503C48248024FE25903E9024FC249024903CFC24902490249044FE54808880
+813E:004078804BFC4A244A247BFC4A244A444BFC789049104FFE4810481048109810
+813F:00203C2027FE242024203DFC2420242027FE3C4024A425A82690448854C68880
+8140:00203C202450248825043EFA240025FC25543D5425FC2554255445545504890C
+8141:0084788C49084FBE49087908490849084FBE79084908490849084A08AA089408
+8142:00003DFC2524252425FC3D24252425FC24203FFE247024A82524462254208820
+8143:00203D2424A8242025FC3C4027FE248825043EFA2488248824A844925482887E
+8144:00083C3C25E0242027FE3CA824A824A827FE3CA824A827FE2420442055FC8800
+8145:00203CA224A2252424503C882704242224203CA424A425282450448855048A02
+8146:00507850485049FC49547954495449FC4954795449544BFE4800488849049A02
+8147:001C79E0482048204BFE78A849244A4248407BFE4888490848D0483048489984
+8148:002078204BFE482049FC78204BFE480049FC790449FC490449FC490449149908
+8149:000078404B9C4A044A047B9C4A044A044BFC789048904890489049124A129C0E
+814A:0088788848884BFE488878884FFE480049FC7904490449FC4904490449FC9904
+814B:008078404FFE492049207A3C4A444E644A947B484A484A304A204A504A889B06
+814C:004078804BFC49104A487C464BF84A484A487BF84A484A484BF848424842983E
+814D:002078204850488849447A2249F848084850782048A44A824A8A4A8A4C789800
+814E:7EFC48447E4442287E1048287EC600001FF010101FF010101FF0101010501020
+814F:00007BDE4842494A4884794A4A524C2048007BDE48524952489449484A549C22
+8150:00803FFE2208220825FE2C883448245820802FFC29442AA4488449448A24080C
+8151:002078104BFE4A004A447A444A844ABE4B847AA44A944A944C844C8448949888
+8152:00003DFC2504250425FC3D10251025FE25103D10257C254425444544557C8A44
+8153:0090789048904F9E4890789048904B9C4890789048904F9E4890489048909890
+8154:0040782048204BFE4A027C9449084A04480079FC48204820482048204FFE9800
+8155:004078204BFE4A024D04790049DE4A524A527B524C9A4894491049124A129C0E
+8156:002078204BFE482049FC792449FC492449FC7820487048A849244E2248209820
+8157:00203C2025FC252425243DFC2524252425FC3C0027FE24882488448855088A08
+8158:00007BFE4A024A024BFE7A224A224AFA4A227A324A2A4BFE4A024A024BFE9A02
+8159:004078204BFE4A02480079FC480048004BFE7820492849244A224C2248A09840
+815A:004078204BFE4A024C0478004BFE482048207920493C49204AA04A604C3E9800
+815B:00003DFE2502250225FE3D0025FC252025443DFE2512251025FC4510561089FE
+815C:00883C8827FE248824883CF82488248824F83C2027FE247024A8452456228820
+815D:00003DFC2420244025FC3D542554255425443D2C242027FE2450448855048A02
+815E:00403C7C248424F824083DFE244024A425383C58249425342454449255508820
+815F:00403C2025FE250226043DFC2440248825FC3C24242025FC2420442057FE8800
+8160:002078204BFE482049FC78404BFE488849047AFA482049FC4820485048889B04
+8161:000079FC4904490449E4792449244BFE4A027AFA4A8A4A8A4AFA4A024A0A9A04
+8162:01FC7924492449FC4924792449FC482048207BFE4A224A2A4AFA4A0A4A029A06
+8163:0040782049FC4800488878504BFE4A224C2479FC492449244934492848209820
+8164:00203C1025FE240024843C4825FE240024FC3C84248424FC2484448454FC8884
+8165:00007BF84A084BF84A087BF848404A404BFC7C4048404BF8484048404FFE9800
+8166:009279244A4849244892784048804BFE4A027A8A4A524A224A524A8A4BFE9A02
+8167:004078A049104A084DF678004BC44A544A547BD44A544A544BD44A444A549AC8
+8168:00203D242524252425FC3C0027FE242024403DFC25542554255445545554890C
+8169:002078204BFE482048207BFE4A8A4A524AFA7A224A224AFA4A224A224A2A9A04
+816A:00007BFE4A2248204BFE782049FC492449FC792449FC48204BFE482048209820
+816B:00083C3C25E0242027FE3C2025FC252425FC3D2425FC242025FC442057FE8800
+816C:00003CFC2448243025FE3C522494251026303C2025FE247024A8452456228820
+816D:00003DDC2554255425DC3C0025FC240025FE3C8024FC24042404440454288810
+816E:000079FC4924492449FC7924492449FC4800784048244AA24A8A4C8848789800
+816F:00043C1E25F0251025103DFE2510257C25443D7C2544257C25444544557C8A44
+8170:00007BFE485048504BFE7A524A524BFE480078404FFE48884990486048D89B04
+8171:00107810487C4B1449FE79144A7C4A104F7C791049FE4D104A104B004CFE9800
+8172:00003DFC2524252425FC3D24252425FC24003FFE252025222514454855848902
+8173:00007A9E4A524A524D5279124A924A524C327BD24A5A4A544A504A504BD09A50
+8174:00203C2024A0252C25243D2425AC252425243DFC252424502450448855048A02
+8175:00007BDE4A424A424A427BDE4A004A3E4BD27A124A144BD44A084A144A249A42
+8176:00203DDC2514251425143DD42526250025DC3D14251425D42708450855148922
+8177:00003DFC240024F824883C8824F8240025FC3D24252425FC2524452455FC8904
+8178:00003CFC248424FC24843CFC240025FE24803CFE252A264A2492452254548888
+8179:00403C4024FE248025FC3E8424FC248424FC3C40247C24C42528441054688986
+817A:0040788049FC490449FC790449FC482048327BB448A8492849244A244CA29840
+817B:001878144FFE48104BD078104BF048104BE87A284AA84AA84AAA494A4A269C22
+817C:00003DFE2420244025FC3D542554257425543D54257425542554455455FC8904
+817D:00003CF82488248824F83C88248824F824003DFC255425542554455457FE8800
+817E:0248794849504FFC48407FFE49104A084DF67810491049FC48044BE448149808
+817F:00007A7C49444944487C78444F44497C4950794A49444954496249424A809C7E
+8180:004078204BFC490848907BFE4A024C4448207BFC488048F84888490849289A10
+8181:00883C50240025FE24503DFC245427FE24543DFC245024D82554465254508850
+8182:2040FEFE21003C1C24E0449454A888C61FF010101FF010101FF0101010501020
+8183:00003CF824A824A824D83C8824F8240024003DFC255425542554455457FE8800
+8184:00A03D2C2524252425AC3D24252425FC24203DFC248824502420445054888B06
+8185:00203C1025FE2510257C3D1425FE2514257C3D10257C254425444544557C8A44
+8186:002078204BFE482049FC78204BFE4840488879F048244BFE482249244AA29840
+8187:00107A20497C49444844787C4B404940497C79444944497C49444A804C7E9800
+8188:00007BFE480049FC4904790449FC48004BFE7A8A4A524BFE4A224A224A2A9A04
+8189:01043C842488240027FE3C002488250426023DFC255425542554455457FE8800
+818A:002878244BFE482049FC792449FC492449FC792448084BFE4888484848489818
+818B:08202AA44D28145022887FFE40029FF410101FF010101FF01010101010501020
+818C:00203D2424A8255424883D0426FA248824883CF82488248824F8448854888898
+818D:00203C4025FC250425543D242554250425FC3C00251225D4251845525592890E
+818E:001E7BE0492248944840788849F0482048C479FE482248204BFE485048889B06
+818F:01007FFC08200FE000007FFE48228FE400001FF010101FF010101FF010101030
+8190:2040FEFE21003C1C24E0449454A888C601003FF8228824482108228824482018
+8191:004078204BFE4A024C1479E04900490049FC791049104FFE4800489049089A04
+8192:00007BFE4A004A7C4A447A444A7C4A004AEE7AAA4AAA4AAA4AEE4A004BFE9800
+8193:010079FC4A004DF8490879F8490849F848007FFE49004BFC4CA449244A549888
+8194:004078204BFE4A504A507BFE4A524A524BFE7A004A924AD44A984A924AD29C8E
+8195:000077FE542A542657FE742257AA56AA57AA74325596562E5446548257FEB402
+8196:00207A20497C48A4481878E64B10497E4910797C491049FE491049104AFE9C00
+8197:00207A224BFE4890488879FE4B104D1049FE7910491049FE4910491049FE9900
+8198:00007BFE485049FC4954795449FC480049FC78004BFE482048A849244AA29840
+8199:00007BBE48A248A248BE7B884A084A3E4A2A7BAA48AA48BE4888488A4D7E9A02
+819A:010001FC01003FFE20022FFC28842FFC28842FFC240827F8240847F844088418
+819B:0020792448A84BFE4A0278F84888488848F87820482049FC482048204BFE9800
+819C:008878884BFE4888480079FC490449FC490479FC48204BFE4850488849049A02
+819D:002078204BFE487048AC7B224850488849247A22492448A849244A2248A09840
+819E:00203DFE242025FC25243DFC252425FC24223DFE240825FE2508448854288810
+819F:004078204BFE482048487AF249244A5248F8780848204BFE4820482048209820
+81A0:00007BDE48424A52494A7A52482848C44B1278604988483249C4481848609B80
+81A1:0020792448A849FC48407BFE488849044BFE7D0449FC490449FC490449FC9904
+81A2:002079FC49244BFE492479FC482049FC492479FC48404BFE488849D048709B8C
+81A3:004078204BFE4A8A49047BFE4840488849FC7824482049FC482048204BFE9800
+81A4:000079FC48204BFE4A2279AC482049AC480079FC480449FC4804480449FC9804
+81A5:10141010FDFE11107DD43948554A929611223FF8228824482108228824482018
+81A6:0020792448A84BFE48A879244A224904490479DE4A444D54489E49044A049C04
+81A7:00203DFC2488245037FE2C0025FC25242DFC352425FC242025FC442057FE8800
+81A8:008278824FF4488848807BE248024BE44A287A204BE04A22494248744F889A10
+81A9:00147BFE48104BD048107BD048104BD04A507BD04A504BC84A4A4BCA49869A42
+81AA:0040782049FC488848507BFE4A224C2449FC7924492C482049FC490449FC9904
+81AB:00203C2025FC242025543C88250426FA24883CF8248824F8242044A855248860
+81AC:00387BC048784BC048787BC4483C480048C67B3849CE4F3849CE4F38494A9986
+81AD:00203DFC252425FC24203FFE240025FC25043DFC250425FC250445FC54888904
+81AE:0020782049FC48204BFE79084B9C490849887E3E48004BFE4890489049129A0E
+81AF:00107BD248544948488A79044AFA4C0049FC7904490449FC490448884FFE9800
+81B0:003C7BE0492448A84BFE78A849244A0249FC7924492449FC4924492449FC9904
+81B1:011078944BD248124A5079904FFE48104BD27A524A544BD44A4A4A4A4BD69822
+81B2:00A0789049FE49104B107DFE4910491049FE7910491049FE49004AA44A529C52
+81B3:008878504BFE482049FC78204BFE492448A87BFE480049FC4904490449FC9904
+81B4:00803C8025FE275425543D5427FE255425543D5427FE24002554452A562A8800
+81B5:00883C8827FE248824203FFE2488248825543E22242027FE2420442054208820
+81B6:00007BDE4A524BDE4A527BDE4A024AFA4A227A724A224A224AFA4A024A0A9A04
+81B7:0280724E54EA55AA59AA7EEA52AC54AA55EA7F8A528A52AA54AC54E858A8B008
+81B8:002079FE4C404AFC49107AFE48004EFC4A847AFC4A844AFC4A844A8C4D0098FE
+81B9:00203DFC2420248827FE3C8825FC250425FC3D0425FC250425FC448855048A02
+81BA:00803FFE225024FC2D9036FC249024FC200027F8240827F8440847F884080418
+81BB:00207BFE48004BFC4A047AF44A944BFC480079F8490849F8490849F848009BFE
+81BC:00007A7C49444974485478544EFE4A824ABA7AAA4ABA4A824A8A4A844D0098FE
+81BD:00803CF8250827FE25443D9225FE2500257C3D00257C2500257C4544557C8A44
+81BE:00203C502488257426023DFC252425AC25243DFC240024F8248844F8548888F8
+81BF:00503DFC255425FC25543DFC240025FE25003D7C250025FE2550455455488A66
+81C0:7E7842487E4854867E7854487E3094CE62001FF010101FF010101FF010101030
+81C1:00207BFE4A884A504BFE7A504AFC4A544BFE7A544AFC4A504AD84D544E529850
+81C2:3E1022FE3E4420287EFEA2103EFC221000001FF010101FF010101FF010101030
+81C3:004078204FFE48284A247A7E4CC84F48497E7A484CC84F7E49484A484C7E9840
+81C4:0040787C48404BFE4A427A784BC44A3C4A007BFE4A404BA44A584DB44C5299B0
+81C5:00003DFC2554255425FC3C8025FE264225F23D52255225F2244A47FA540A8804
+81C6:0040782049FC488848507BFE480049FC490479FC490449FC48204A944A8A9C7A
+81C7:00A0789049FE4B2049FC792049FC492049FE79004BDE4A524A524A724A029A06
+81C8:00887BFE488849FC490479FC490449FC488079FE4A224D52490249FA480A9804
+81C9:00203C202450248825043EFA2400240025DC3D54255425DC2488448855548A22
+81CA:00F83C88248824F824003DDC2554255425DC3C2027FE247024A8452456228820
+81CB:7E7842487E4854867E7854487E3094CE63003FF8228824482108228824482018
+81CC:008878884FC848BE48887BC8481C4BD44A547A544BD44A48498848D44F149A22
+81CD:0080704057FC511050A47F58555455525B587000520853F8520853F85208B408
+81CE:03DE78424A52494A4A5278204BFE4888488879544A2248204BFE482048209820
+81CF:004078204BFE4A0249FC79484A5049FC4B0479FC490449FC490449FC48889904
+81D0:001C3DE0242027FE24203DFC25AC257425FC3C2025FC242027FE440055548A2A
+81D1:000079FC48204BFE4A2279AC482049AC48007BFE482049FC495449544954990C
+81D2:00887BFE48A8489049FE7B2049FC492049FC792049FE49004BFC488848709B8E
+81D3:0090709057FE5094500A77FE540855E8554A75EA552A55EA554C55EA5416B862
+81D4:03DE7A924BD24A544BC87A944BE2480049FC790449FC490449FC490449FC9888
+81D5:004078204BFE4A504BFE7A524BFE4A004A947AD84A904AD24A8E4C0049549A2A
+81D6:2FEC48244BA4682C4BA46AAC4BA4FFFE10103FF8D0161FF010101FF010101030
+81D7:00207BFE4A8A49FC488879FC490449FC490479FC490449FC4890489449129A0E
+81D8:01247A48492448004BFC7A944A644A944BFC7A484B684A484B6A4A4A4A469B62
+81D9:0110711057FC511051F0720852EA56AC52A872AA56EA5A06500052A45252B452
+81DA:0040787C48404BFC4A447BF04A444AFC4AA87AF84AA84AF84A004DFC49549BFE
+81DB:01FC78204BFE4A224DAC782049AC489049FE7B204DFC492049FC492049FE9900
+81DC:0108752857BE594857BE731855AA5946500073F852085248524850B05108B604
+81DD:0100FFFE20003FF800003FF820083FF8054077DC555477D4511C7FF65556B922
+81DE:03DE7A524BDE4A524BDE7A524BDE489049FE79104BFE4D1049FE491049FE9900
+81DF:0090709057FE5094500A71FE550857E8514A71EA5F2A55EA554C59EA5216B462
+81E0:210447C88812F3BC20084B92F83E0380AAAAABAA01003FF82288244821082298
+81E1:2450FF4824FE3D9008FC7E9052FC7E9024FE4280BFF822882448292822882458
+81E2:052877BE594857BE531875AA594653FC520473FC520453FC520453FC5108B204
+81E3:00003FFC2100210021003FF820082008200820083FF82100210021003FFC0000
+81E4:00007E0048FC484448447E444244422842287E2848104810482848487E840102
+81E5:00207E204820482048207E204220422042507E5048504850484848887E840102
+81E6:0000FE7E1248124812487E7E42424242424242427E7E124812481248FE7E0000
+81E7:002800245FFE502057A07520152017A4F4A454A857A85510951227AA20464082
+81E8:00407E40487E488049007E7C42444244427C7E0048EE48AA48AA48AA7EEE00AA
+81E9:0000FEFE12907EFC42847EFC1290FEFE02007FFC04401830E44E044008401040
+81EA:0100020004001FF01010101010101FF0101010101FF01010101010101FF01010
+81EB:0820082010207F20412041207F20412041207F204120412241227F22411E0000
+81EC:020004001FF010101FF010101FF010101FF00100FFFE054009203118C1060100
+81ED:020004003FF820083FF820083FF820083FF801200110FFFE028004401830E00E
+81EE:02001FF010101FF010101FF010101FF0000000FC7F0011101110292845440100
+81EF:02001FF010101FF010101FF010101FF021081110092011102108FFFE01000100
+81F0:02001FF010101FF010101FF010101FF00000FFFE08401F48625014621842E03E
+81F1:02001FF01490125011301FF001007FFE4A2291143FF8040007F0081010502020
+81F2:102020207E7C42847F0842FE7E8042BC7EA410A4FEB418A834A25322911E1200
+81F3:00007FFC02000400082010103FF80008010001003FF8010001000100FFFE0000
+81F4:0040FE401040208028FE4508FE881288108810507C50102010501E88F1044202
+81F5:0040FE401078208829504420FE501288110610F87C88108810881E88F0F84088
+81F6:0020FE20102021FE28404440FEBC1284118812887CFE108810881E88F0A84090
+81F7:084008487F4408440840FFFE00407F44104422447F28092A3E12082A0F46F082
+81F8:0000FEFE1010202028444482FEFE1212101010107CFE101010101E10F1FE4000
+81F9:0028F8242024402053FE8A20FA242A2423A4FAA822A822903A92E5AA44460882
+81FA:0100FFFE01003FF800001FF010107FFE40029FF408201FF001003FF80100FFFE
+81FB:0020F82023FE402051FC8840FBFE28882134FAE2202021FC3870E0AC43220020
+81FC:00000400387820082008200820083C78200820082008200820083FF820080000
+81FD:040004000FF01010202040408C003078200820083C782008200820083FF82008
+81FE:010005003978210821083D782108210821083FF821080280044008203018C006
+81FF:001001F83F000100FFFE01000D003178210821083D782108210821083FF82008
+8200:00FC7F0002082108111010200C003078200820083C782008200820083FF82008
+8201:060038F8200820083EF8200820083FF808200820FFFE08200820102020204020
+8202:010001007FFC01003FF80200FFFE044008203418D87610101C7010101FF01010
+8203:060038F8200820083EF8200820083FF810001FF820003FFC0004492484940008
+8204:060038F8200820083EF8200820083FF810003FFC400489242494249440280010
+8205:3E7820083C7820083FF800001FF011101FF011101FF002007FF8040818286010
+8206:1100611C47C44204751C47C4410477DC41044104FFFE00000820101020084004
+8207:0A003238238822083A38238820883AB822882288FFFE00000820101020084004
+8208:00002FEC48244BA4682C4BA44AA46AAC4BA44824FFFE00000820101020084004
+8209:0A0033B822083BB820883AB82288FFFE082011102FE8C1061FF0010001000100
+820A:0820FFFE09201FFC30805FF890801FF810801FFC02001C7810081E7810081FF8
+820B:2FEC48244BA4682C4BA46AAC4BA4FFFE80021FF010101FF010101FF01010FFFE
+820C:001000F83F0001000100FFFE0100010001001FF010101010101010101FF01010
+820D:01000280044008203018CFE6010001003FF8010001001FF0101010101FF01010
+820E:01000280044009203118CFE6010001003FF8000000001FF0101010101FF01010
+820F:04040E04784408440844FF44084408443E4C22542264224422043E0422040004
+8210:08041C1E71F011101110FD10111011FE7D10451045104508450A7D4A45860102
+8211:08201C20702011FC1124FD2411FC11247D24452447FE450445047D0445140108
+8212:100011F82808445082207C1013FE1022FE24102010207C20442044207CA04440
+8213:08001DFC710411FC1104FDFC108010807DFE464A444A449245227E4244940108
+8214:08001DFC7020102011FEFC50105010887D244622442444B244AA7D2A44A00040
+8215:08201CA270A211241050FC88130410227C2044A444A4452844507C8845040202
+8216:102810242BFE442082207DFC11241124FFFC112411247DFC452445247D24450C
+8217:102810242BFE542092207DFC11241124FDFC01247D2445FC452445247D24450C
+8218:1020101029FE450282007CF810881088FEF8108010807CFC448444847CFC4484
+8219:00F83F000100FFFE01001FF010101FF00C0C70701010FEFE10107C7C44447C7C
+821A:08801CF8710813FE1144FD9211FE11007D7C4500457C4500457C7D44457C0244
+821B:1010101010101E1012FE2210229052908A90049004FE08100810101020104010
+821C:007C3F800108108808907FFE481208101EFC221052900C9008FE101020104010
+821D:02003FF00410FFFE1110222011107FFE440288241FF001001FF021003FF80100
+821E:10003FFC4AA00AA07FFC0AA00AA07FFC101010103EFC4210149008FE3010C010
+821F:020004001FF01010121011101110FFFE10101210111011102010201040508020
+8220:080010003EFC222432242A242A24FE24222432242A242A44224442844B288610
+8221:080010003E7C221032102A102A10FE10221032102A102A10221042104AFE8400
+8222:102020207C204420652455245524FD244524652455245524452445FC54048800
+8223:104020247D244504650454885488FC8844506450542054204450448855048A02
+8224:080010003E78224832482A482A48FE68225832482A482A4A224A428A4A868500
+8225:100020007DFC4524652455245524FD2445FC6500550055004502450254FE8800
+8226:102020207C204420642055FE5420FC204420645054505450448844C855248A02
+8227:081010203E78224832482A482A48FE68225832482A482A4A224A428A4A868500
+8228:1004200E7CF04480648054FC54A4FCA444A464A854A854904510452856448882
+8229:101020907C904488648855245524FE224420644054485444448445FE54828800
+822A:104020207C0045FC6400540054F0FC90449064905490549244924512550E8A00
+822B:104020207C2045FE644054405440FC7C44446444544454444484448455288A10
+822C:080010783E48224832482A862A00FEFC224432442A282A28221042284A448582
+822D:101021107D1045126512551455D8FD10451065105510551245524592550E8800
+822E:102020107C1044FE648254825482FCFE44826480548054804480450055008A00
+822F:102020207C20442065FC55245524FD24452465FC552454204420442054208820
+8230:100021FC7D044504652455245524FD2445246554545054504490449255128A0E
+8231:102020207C504450648855045602FCF84488648854A8549044824482547E8800
+8232:082010203E50225032882B242A12FE1023FC32042A082A88225042204A108410
+8233:102020207C20442065FC55245524FD24452465FC552455244524452455FC8904
+8234:108020807C8044FE654055405640FC7C444064405440547E4440444054408840
+8235:082010103E1022FE32822A842A40FE44224832502A602A42224242424A3E8400
+8236:081010103E2022FC32842A842A84FE8422FC32842A842A84228442844AFC8484
+8237:102020107C1045FE642054205444FC8445F8641054205444448245FE54828800
+8238:100020007DFE4408640855E85528FD284528652855E855284408440854288810
+8239:080010783E48224832482A482A8EFF00220032FC2A842A84228442844AFC8484
+823A:100021FC7D244524652455FC5524FD24452465FC552454204420442054208820
+823B:102020207C3C4420642054FC5484FC84448464FC548454804480450055008A00
+823C:104820487C48444865FE54485448FC48444865FE540054484444448454828902
+823D:082010203E3C224432A82A102A28FED6221032FC2A102A9022FE42104A108410
+823E:100023FE7C50445065FC55545554FD5445546554558C55044504450455FC8904
+823F:102020207BFE4850688859044AFAF8004BFE4840688059FC4804480448289810
+8240:1008203C7DC04404654454A85400FDF84410642057FE54204420442054A08840
+8241:081010503E50227C32502A902A10FEFE220032002A7C2A44224442444A7C8444
+8242:104020407CFC44886550542054D8FF2644F8642054F8542047FE442054208820
+8243:100021FC7D24452465FC55245524FDFC4420642055FC54204420442057FE8800
+8244:102021247CA444A8642055FC5504FD0445FC6504550455FC4504450455148908
+8245:102020207C504488650456FA5420FC2047FE6420552855244622442254A08840
+8246:082010103EFC228432842AFC2A84FE8422FC32A22AA42A98229042884AC48482
+8247:100020067BB8488868885908493EFB8848884A886A88593E49004A804C7E9800
+8248:102020107DFE44206448548455FEFC0244A864A854A854A844A844AA552A8A06
+8249:100021FC7D04450465FC5500551CFD70451C6570551E55F04510451255128A0E
+824A:081010203E7C2244327C2A442A7CFE10221032FE2A922A92229242964A108410
+824B:100021FC7C084410642057FE5420FCA0444065FC555455544554455457FE8800
+824C:102020207850488869445A2249F8F8084850482068A45A824A8A4A8A4C789800
+824D:100021FC7D04450465FC55105510FDFE45106510557C554445444544557C8A44
+824E:102020407DFC450465FC550455FCFC0047FE6420542055FC4420442057FE8800
+824F:108420487DFE4420644054FC5484FC8444FC6484548454FC4484448454FC8884
+8250:105021247D54450465FC54505488FD4444786488548855504420445054888906
+8251:102020107DFE4502650255FE5500FD0045FE65AA56AA54FE44AA44AA54AA8886
+8252:100021FE7D02457A6502557A5502FC0044FC648454FC548444FC448454FC8884
+8253:104821487D4847FE654855485578FD0045FE642057FE547044A8452456228820
+8254:104020207DFE4548654855FE5548FD78450065FC554455484528451055288AC6
+8255:102020107DFE4484644855FE5502FE24441065FE5440547C4444448454948908
+8256:108420447C4845FE642054FC5420FDFE4440648054FE55104610441055FE8800
+8257:110420847C88440067FE54005488FD04460265FC555455544554455457FE8800
+8258:10A0212C7D24452465AC55245524FDFC442065FC548854504420445054888B06
+8259:102020207C50444864A455FE5684FCFC448464FC548054FC45444544567C8844
+825A:105020507DFE445065FC555455FCFD5445FC640054F8548844F8448854F88888
+825B:102021FC7D2447FE652455FC5420FDFC452465FC544057FE448845D054708B8C
+825C:115421547BFE495469545A724C00FBFE4A22482069FC592449244924492C9820
+825D:100021FC78204BFE6A2259AC4820F9AC480049FC680459FC4804480449FC9804
+825E:111021107DDE46A8644454505554FCD8445064D8555456524490449255128A0E
+825F:102021FC7C88445067FE540055FCFD2445FC652455FC542045FC442057FE8800
+8260:101023D278544948688A59044AFAFC0049FC4904690459FC490448884FFE9800
+8261:1020212478A84BFE6A0258F84888F88848F8480069FC592449FC492449FC9904
+8262:102020207BFE492469245AAA4FFEF80049FC4904697459544974490449FC9904
+8263:1040207C78404BFE6A425BF84A44FAFC4AA84AF86AA85AF84A204DFC4844998C
+8264:110420887BFE482069FC58204BFEF854499248906BFE589048D44B8A489699A2
+8265:101023D47A524A526BD058104FFEFA504BD24A526BD45A544AEA4F4A48569862
+8266:100823E87A884BEE6A285BF44A82FBE2480049FC69545954495449544FFE9800
+8267:108823FE7CA8449065FE572055FCFD2045FC652055FE550047FC448854708B8E
+8268:108823FE78884BFE6A0259FC4800FBFE484048A26B5458B84B5448924B509820
+8269:104020207BFE488868525FAC4AAAFAA84DAC4800690459FC490449FC49049A04
+826A:108021F87E0845FC652455FC5524FDFC4554662A55FC550445FC450455FC8904
+826B:1040207C78404BFC6A445BF04A44FAFC4AA84AF86AA85AF84A004DFC49549BFE
+826C:11F022107BFC4E046BFC5A244BB8FA2249FE4A106FFC5A444BFC48D0494A9A3E
+826D:110822947BDE4EB46BDE5A944BDEFA944BDE4A106FFC59084890486049989E06
+826E:00003FF0201020103FF0201020103FF022002208211020A02440282030182006
+826F:020001003FF0201020103FF0201020103FF02208211020A02040242028183006
+8270:000001F8FD08050845F84508290829F811441148293029204510454881860100
+8271:2200227CFF4422443E7C08447F44497C7F5208527F540848FF48144422624140
+8272:080008001FE020204040BFF82108210821083FF820002002200220021FFE0000
+8273:1080108010F8FD08121015FC11247D24112411FC1100FD001102110210FE1000
+8274:28202820287CFE442A882A7CFE54A854A854FF7C294029402D424A42483E8800
+8275:4240244000FC7E88251024FC24A424A4FFA424FC2480248024824482447E8400
+8276:28402840FEF8AA88FF10AAFCFEA400A4FEA400FC7C8044807C8248823E7EC000
+8277:2A107F10AA9CFFA4AAC8FFBEAAAAFFAA002AFFBE00207F2041227F222222FF9E
+8278:10101010101092929292929292929292FEFE1212101010102010201040108010
+8279:08200820FFFE0820082000000000000000000000000000000000000000000000
+827A:08200820FFFE0820082000003FE000C00300040008001000200420041FFC0000
+827B:08200820FFFE08200A20020002007FF802080408040808080808100820504020
+827C:08200820FFFE0820082000007FFC010001000100010001000100010005000200
+827D:08200820FFFE08200820040004007FE0042004200820082010222022401E8000
+827E:04400440FFFE044000200820082004400440028001000280044008203018C006
+827F:04400440FFFE044000003FF8040804100420047C080408041004204440288010
+8280:08200820FFFE0820082000003FF8020802080208020804080408080810506020
+8281:08200820FFFE0820082000000FE00820082008200820102210222022401E8000
+8282:08200820FFFE0820082000007FF8020802080208020802500220020002000200
+8283:08200820FFFE0820082000000FE0082008200A200920092210221022201E4000
+8284:08200820FFFE08200820020002007FE002200A200420062009221022201E4000
+8285:08200820FFFE08200A200210021002FEFF00020001000100008000420032000E
+8286:08200820FFFE082000003FF0121011200820044002800100028004401830E00E
+8287:08200820FFFE08200820010001003FF821082108210821082128211001000100
+8288:09200920F93E0920092001003FF8010001000100FFFE01000100010001000100
+8289:08200820FFFE0820082000003FF8010001000100FFFE01000100010001000100
+828A:04400440FFFE0440000000F83F00010001000100FFFE01000100010001000100
+828B:08200820FFFE082000003FF8010001000100FFFE010001000100010005000200
+828C:0820FFFE082000003FF800000000FFFE040008000FF000100010001000A00040
+828D:04400440FFFE0440100010001FF8200840088808040802080208000800500020
+828E:04400440FFFE044000003FF8000800083FF8200020003FFC0004000400280010
+828F:08200820FFFE082009200100010001003FF801000100010001000100FFFE0000
+8290:08200820FFFE082008200000FFFE020002000240022002100208020002000200
+8291:08200820FFFE082000003FF00010001000103FF020002004200420041FFC0000
+8292:08200820FFFE0820082002000100FFFE0800080008000800080008000FFC0000
+8293:08200820FFFE0820082000001FE0004000800100FFFE01000100010005000200
+8294:01002108210821083FF8010011101010929292929292FEFE2212201040108010
+8295:08200820FFFE08200A20020007F808081010642002400280010006001800E000
+8296:08200820FFFE0820092001000100FFFE0100028002800440082010102008C006
+8297:08200820FFFE0A20040008101FE000C003040C083FF01020004001800E007000
+8298:08200820FFFE082008202080208020883C9020A020C0208424842884307C0000
+8299:08200820FFFE0820092001003FF801000100FFFE01000280044008203018C006
+829A:08200820FFFE082009200100FFFE01002108210821083FF8010A0102010200FE
+829B:08200820FFFE082000003FF002100210FFFE021004103FF0081010002000C000
+829C:08200820FFFE082000003FF0020002007FFC02800480048008841084207CC000
+829D:08200820FFFE08200A20010001007FF8003000C003000C003000480087FE0000
+829E:04400440FFFE044010001FFC20005FF880003FF0001000100010000A00060002
+829F:08200820FFFE082000000FE008201020601C00001FE00820044003801C70E00E
+82A0:08200820FFFE08200820020001007FFC0820082004400280010006C01830E00E
+82A1:04400440FFFE0440080008000FFC10042108410001000280044008203018C006
+82A2:08200820FFFE082000000800080013FC3000500090001000100017FE10001000
+82A3:08200820FFFE0820082000007FFC008001000300056009183104C10201000100
+82A4:04400440FFFE044000007F400240044008400F40F840484208420842283E1000
+82A5:08200820FFFE082009200280044008203458C446044004400840084010402040
+82A6:08200820FFFE0820092000803FF8200820083FF8200820002000400040008000
+82A7:08200820FFFE082000003FF0002006400180FFFE008200840080008002800100
+82A8:04400440FFFE044000003FF0082008400CF80A08111010A0204020A043188C06
+82A9:08200820FFFE08200920028004400A203118C1061FE000200040004000800100
+82AA:08200820FFFE082000783F802080208020803FFE2040204020242814300C2004
+82AB:08200820FFFE082000001FF0000000007FFC044004400440084408441044603C
+82AC:08200820FFFE082000400440082010102008DFE6042004200820102021404080
+82AD:08200820FFFE082000003FF82108210821083FF820002002200220021FFE0000
+82AE:08200820FFFE0820092001003FF8210821082288244828282008200820282010
+82AF:08200820FFFE0820082002000100008004082404240244028410041003F00000
+82B0:08200820FFFE092001007FFC010001003FF0082004400280010006C01830E00E
+82B1:08200820FFFE082000000888089010A030C050809180128214821082107E1000
+82B2:08200820FFFE0820092002800C603018C80608E00F0078080808080807F80000
+82B3:08200820FFFE08200A200100FFFE0400040007F0041008100810101020A04040
+82B4:08200820FFFE0820100010001FF8224842488488088811082208440808501020
+82B5:08200820FFFE0820092001003FF0011001100110FFFE0280044008203018C006
+82B6:08200820FFFE082010001FF8200844088408090810883FC81048000800500020
+82B7:08200820FFFE08200820010001000100110011F81100110011001100FFFE0000
+82B8:08200820FFFE0820082000003FF800000000FFFE02000400082010103FF81008
+82B9:08200820FFFE082000381FC0100010001FFC1040104010402040204040408040
+82BA:08200820FFFE0820082000F03F0001000100FFFE01000280044008203018C006
+82BB:080008001FF8220852481FC80408085030201FF8220852489FC8040808503020
+82BC:08200820FFFE0820082000F83F00010001F83F00010001FC7F020102010200FE
+82BD:08200820FFFE082000003FFC0020102020203FFE012002200C203020C0A00040
+82BE:08200820FFFE082009200100FFFE010001003FF8210821082108212821100100
+82BF:08200820FFFE0820100017F8210821106120A13C210421042204220424282810
+82C0:08200820FFFE08200A2001007FFC000000000FE00820082008221022201EC000
+82C1:08200820FFFE0820082000000820082008200820082014501250228841048202
+82C2:08200820FFFE082009200100110811081110212002800280044008203018C006
+82C3:08200820FFFE08200A200200FFFE040004000FF008101420224041808670380E
+82C4:08200820FFFE08200A2001000100FFFE02000200024002200210020002000200
+82C5:08200820FFFE0820082002044244244414440844084414442404420482140008
+82C6:08200820FFFE08200820200021FC2C44F0442044204424842884310422280410
+82C7:08200820FFFE092001007FFC010001001FF0010001007FFC0104010401140108
+82C8:08200820FFFE082000003FFC210021002FF82108210822082208440848509020
+82C9:08200820FFFE082000003FFC22402240224022442444243C280020003FFC0000
+82CA:08200820FFFE082000003FFC2000200027E02420242024A024444404440483FC
+82CB:08200820FFFE0820082000001FF010101110111011101290028004821882607E
+82CC:04400440FFFE04400800083009C00E000800FFFE0900088008400A300C0E0800
+82CD:08200820FFFE082009200280044008203018CFE60820082008A80848080807F8
+82CE:08200820FFFE08200A2001007FFE4002800400000000000000007FFC00000000
+82CF:08200820FFFE08200A2002007FF0021002142212221224124410081010A02040
+82D0:0820FFFE082000003FF8010801083FF8210021003FFC030405041928E1100100
+82D1:04400440FFFE044010001EF812882288228852A88C90048208821082207E4000
+82D2:08200820FFFE0820082001003FF8210821083FF821082108FFFE200820282010
+82D3:08200820FFFE0920028004400A203118C1061FE0002000400C80030000800040
+82D4:08200820FFFE08200400082010103FF8000800001FF01010101010101FF01010
+82D5:08200820FFFE082000007FF80408080810502020DFF81008100810081FF81008
+82D6:08200820FFFE0820092001003FF82108210821083FF82108210821083FF82008
+82D7:08200820FFFE0820082000003FF82108210821083FF82108210821083FF82008
+82D8:04400440FFFE044000003FF82008200827C824482448244827C8200820282010
+82D9:08200820FFFE08200A20010000007FFC001010100820044004800000FFFE0000
+82DA:08200820FFFE082000003FF8210821083FF8210821083FF82108410841288010
+82DB:08200820FFFE082000007FFC001000101F10111011101F101110001000500020
+82DC:08200820FFFE082000003FF8200820083FF8200820083FF8200820083FF82008
+82DD:08200820FFFE082008200000044004447C480470044004420C423442C43E0400
+82DE:04400440FFFE044008001FF020105F90109010901F901050102410040FFC0000
+82DF:04400440FFFE044010001FF8200840089F88108810881F881088000800500020
+82E0:08200820FFFE08203FF8200820083FF8208020803FFC204020242414280C3004
+82E1:08200820FFFE0820000024102210211021102010202024202850308821040602
+82E2:08200820FFFE082000001FF0101010101FF0100010001FF8100810081FF81008
+82E3:08200820FFFE082000003FF8200020003FF0201020103FF02000200020003FFC
+82E4:08200820FFFE082000007FFC00800100036005101908610401000100FFFE0000
+82E5:08200820FFFE08200A200200FFFE040008001FF028104810881008100FF00810
+82E6:08200820FFFE0820092001000100FFFE010001001FF01010101010101FF01010
+82E7:08200820FFFE08200A2001007FFE400280043FF8010001000100010005000200
+82E8:04400440FFFE04401FF8100810081FF810001200123813C02204220441FC8000
+82E9:08200820FFFE0820092002003FF82008200820083FF82008200820083FF82008
+82EA:08200820FFFE082000007FFC010001003FF82108228824482828200820282010
+82EB:08200820FFFE08200920010001FE0100010001003FF82008200820083FF82008
+82EC:08200820FFFE082000003FF8210821082108210822882448282820083FF82008
+82ED:08200820FFFE08201040104021FC24444444F844104420444884FC8445280210
+82EE:08200820FFFE0820000008200820102031245124912411241124112411FC1004
+82EF:08200820FFFE0820010001007FFC03800540092011102FE8C106010001000100
+82F0:08200820FFFE082000007E10021002103E10202040287E24024402FE14420800
+82F1:08200820FFFE0820010001001FF0111011101110FFFE0280044008203018C006
+82F2:04400440FFFE0440080008001FFC2400440087F00400040007F8040004000400
+82F3:08200820FFFE0820040008001FF02820444003801C70E30E00C00E0001800040
+82F4:08200820FFFE082000001FF0101010101FF0101010101FF010101010FFFE0000
+82F5:08200820FFFE0820010011001FF821000100FFFE01000280044008203018C006
+82F6:08200820FFFE082009200280044009203118C106010009201110210805000200
+82F7:04400440FFFE044010101010FFFE1010101010101FF01010101010101FF01010
+82F8:08200820FFFE0820001000F83F00111009200100FFFE01000100010005000200
+82F9:08200820FFFE082000007FFC01001110091009200100FFFE0100010001000100
+82FA:08200820FFFE082000001FF012101110FFFE1010221021103FFC001000A00040
+82FB:04400440FFFE044008100810101013FE30105110909010901010101010501020
+82FC:08200820FFFE0920110011003FFC4100810001003FF8010001000100FFFE0000
+82FD:08200820FFFE0820000000781FA012201220122012101290224822A843248202
+82FE:08200820FFFE0820082001000090089048244842488289020E101810E7F00000
+82FF:08200820FFFE0820092001003FF801000100FFFE0380054009203118C1060100
+8300:08200820FFFE082004403FF8044804481FF8144024403FFC0844105420484040
+8301:08200820FFFE082009202108210821083FF8010801004104410441047FFC0004
+8302:08200820FFFE0820009000883FFC2080208820882050205020244054418C8604
+8303:04400440FFFE0440100009F84908210825080528091071021102110210FE0000
+8304:08200820FFFE082000001000107C7E441244124412441244224422444A7C8444
+8305:08200820FFFE082000003FF0002006400180FFFE0282048408803080C2800100
+8306:08200820FFFE082000000C0070FC4084448444845C8464944888088010806080
+8307:04400440FFFE044002100208FFFE040004000FF008101420224041808670380E
+8308:08200820FFFE08200440044024442448275024602440244224422F42F03E4000
+8309:08200820FFFE092001000100FFFE010001007FFC0380054009203118C1060100
+830A:04400440FFFE0440001000781F80100010001FFC1040104010401040FFFE0000
+830B:08200820FFFE082008783F802080208020803FFE2040204022242914308C2084
+830C:04400440FFFE0440080008401040104037FE5040904010401040104013FC1000
+830D:04400440FC7E0440144010001FF8200840089F88108810881F88000800500020
+830E:04400440FFFE044000003FF0006001800E70700C1FF0010001000100FFFE0000
+830F:08200820FFFE08200820004004207FFC04800488089008A010C223824C82807E
+8310:04400440FFFE0440100010001FF822484A4884880A8811082288440808501020
+8311:08200820FFFE092002001FF012101110115010201FFC00047FE4000400280010
+8312:04400440FFFE044010001E7C12442248225052488C4404440854104820404040
+8313:08200820FFFE08200A2001007FFE40028004044004400820082010102008C006
+8314:08200820FFFE082000007FFE4002810401003FF80100010001000100FFFE0000
+8315:08200820FFFE082000007FFE400280041FE0042004203FA004200414040C0404
+8316:04400440FFFE044008000FF010202C4003801C70E00E1FF0101010101FF01010
+8317:08200820FFFE0820020007F808103420024001800FF81808E80808080FF80808
+8318:04400440FFFE044000003FF804080850302000007EFC1224122422444A948508
+8319:08200820FFFE082000900088FFFE0080108810887E50105010242054418C8604
+831A:08200820FFFE0820060078FC408440847E844084408440944E88708000800080
+831B:04400440FFFE044000003FF020103FF020103FF02208211020A024402830300E
+831C:04400440FFFE04400000FFFE044004403FF8244824482848303820083FF82008
+831D:08200820FFFE082000003FFC2080208027F82408240827F8208020803FFE0000
+831E:08200820FFFE082000003FFC210021003FF8200820083FF8210021003FFC0000
+831F:08200820FFFE082001003FF00110FFFE01103FF001003FF80100FFFE01000100
+8320:04400440FFFE0440000008400840104037FC50E0915011501248144418421040
+8321:08200820FFFE0A2001007FFC400480081FE000400080FFFE0100010005000200
+8322:08200820FFFE082000047F84082408241F24212451240A24040408043014C008
+8323:04400440FFFE044000001FF010101FF000003FF80100FFFE028004401830E00E
+8324:0820FFFE0820020007E01840648003200C4071F806081A10012000C007007800
+8325:08200820FFFE082001003FF801000100FFFE000001003FF801000100FFFE0000
+8326:08200820FFFE09200100FFFE01003FF8210821082128239005601918E1060100
+8327:08200820FFFE0820092001003FF82108210821083FF80100011001F87F042004
+8328:08200820FFFE08204080208020FC0904124814402040E0A020A0211022082C06
+8329:08200820FFFE082000781F80100010001FFC1000100017F82408240847F88408
+832A:08200820FFFE08200100111009100920FFFE04400440044008421042203EC000
+832B:08200820FFFE082008202040102087FE490009001100E1002100210021FC0000
+832C:08200820FFFE0A2002000400FFFE08001040304053FC90401040104017FE1000
+832D:08200820FFFE08200A2001007FFC08201010244844440280010006C01830E00E
+832E:08200820FFFE0A20020003F802000200FFFE0000010011101108210445040200
+832F:08200820FFFE0820000008500848104037FE504090A010A01110111012081406
+8330:0820FFFE092001003FF8210821083FF8210821083FF811000A00060019C0E03E
+8331:04400440FFFE0540110011003FF841000100FFFE0380054009203118C1060100
+8332:04400440FFFE04401020102020402448448878F008101020142822447EFC0204
+8333:08200820FFFE08200820200017FC90404040484008401040E04020402FFE2000
+8334:04400440FFFE044000003FF82008200827C82448244827C8200820083FF82008
+8335:04400440FFFE044000003FF8210821082FE8210822882448282820083FF82008
+8336:08200820FFFE082009200280044009203118DFF6010009201110210805000200
+8337:08200820FFFE0820000008A00890108030FC57809048105010241054118C1604
+8338:08200820FFFE082000007FFC10101FF010101FF01010103EFFD0001000100010
+8339:08200820FFFE082010001000FE7C124422442244644414440844147C2244C000
+833A:08200820FFFE0A200100FFFE0400082010103FF804480440044008441044603C
+833B:1010929292929292FEFE2010401080001010929292929292FEFE221220104010
+833C:08200820FFFE082000003FF820082FE8200827C82448244827C8200820282010
+833D:08200820FFFE082000001040104027FC6444A444244427FC2444204020402040
+833E:08200820FFFE0820082000007FFC082008200820FFFE08200820102020204020
+833F:08200820FFFE0820082000007DF011101110119011501D12E2124212040E0800
+8340:04400440FFFE144010001FF820085FC890481FC810481FC81048000800500020
+8341:08200820FFFE082000007FFC00001FF010101FF010101FF010100000FFFE0000
+8342:0820FFFE0A2002007FFC0440082037D8C0063FF808000FE00020002001400080
+8343:08200820FFFE09200280044008203018CFE6010001001FF0010001007FFC0000
+8344:08200820FFFE08200A2001007FFC040008401F8001100620384001A00E107008
+8345:08200820FFFE0820092002800C603018CFE600001FF01010101010101FF01010
+8346:12041204FFC4122400247FA4122412241224FFE4122412242204220442148208
+8347:04400440FFFE0440100021FC4000880013FE3020502090201020102010A01040
+8348:04400440FFFE0440101010103E1022FC4210A490149008FE1010201040108010
+8349:04400440FFFE044000001FF010101FF010101FF00100FFFE0100010001000100
+834A:08200820FFFE082000047F84122412241224FFE4122412242204220442148208
+834B:08200820FFFE082000007FFC010002003FF82488248824882488248824A82010
+834C:08200820FFFE0A2001007FFE400282040200FFFE042008201C4003800C707008
+834D:08200820FFFE082004404440448044FE450846885C9064504420045004880506
+834E:08200820FFFE082000007FFC040008201FF0011001003FF801000100FFFE0000
+834F:04400440FFFE04400810087813C0304050409FFE104010401040104017FC1000
+8350:08200820FFFE0A2002007FFC040009F8081018202BFE48208820082008A00840
+8351:08200820FFFE08200100FFFE01007FF801083FF821003FFC0284044C1830E00E
+8352:08200820FFFE0A200100FFFE100010001FF8000011101110111021124112810E
+8353:04400440FFFE0440101008207FFC082008200820FFFE08200820102020204020
+8354:0820FFFE0A2002003FF0041018A06040102010207EFC1224224422444A948508
+8355:08200820FFFE082000003E20222022FC3E24222422243E24224442444A948508
+8356:08200820FFFE0A2002083FD002200240FFFE0100061018E02F00C808080807F8
+8357:08200820FFFE0820009000883FFC2080208830882850245020244054418C8604
+8358:08200820FFFE0820000008204820282028200BFE082018202820C82009FC0800
+8359:08200820FFFE082020401040104007FC704010A01090110812041404280047FE
+835A:08200820FFFE0820010001003FF8010011100920FFFE0280044008203018C006
+835B:08200820FFFE0A2002FC7F20014000840764381C00007FFC044008421042603E
+835C:08200820FFFE0820208020883EB020C42084267C39000100FFFE010001000100
+835D:08200820FFFE082000047F044124492449244924492449241424220441148088
+835E:08200820FFFE082000F03F000200FFFE044008203458C4460440044008401040
+835F:08200820FFFE092002800440082037D8C00600003FF80200044008201FF00810
+8360:08200820FFFE0A2001007FFC0820044003800C603018C4460440044008401040
+8361:08200820FFFE0820000023F01020104080804BFC48A41124E244248421282210
+8362:08200820FFFE0A2001007FFE400280043FF801000100FFFE0100010005000200
+8363:08200820FFFE082000007FFE4002810401007FFC0380054009203118C1060100
+8364:0820FFFE082000007FFE420282043FF8090011001FF001000100FFFE01000100
+8365:08200820FFFE082000007FFE4002810401047D880550092011102108C5060200
+8366:08200820FFFE082000007FFE4002810411001FF821000100FFFE010001000100
+8367:08200820FFFE082000007FFE400281041110111022A00280044008203018C006
+8368:08200820FFFE08203FF000101FF000103FF00020FFFE08200420042000A00040
+8369:04400440FFFE04401FF0101010101FF010801040162021102088460681800040
+836A:04400440FFFE044000007C200420082010A810A41D24F1221222102050A02040
+836B:04400440FFFE044000007CFC4484488450FC4884448444FC5484488441144208
+836C:04400440FFFE044000007FFC04040288128008800900FFFE0240042018106008
+836D:08200820FFFE08201000100021FC4420F82010202020FC2040201C20E3FE4000
+836E:04400440FFFE044010081008200845FEF80810882048FC4840081C08E0284010
+836F:04400440FFFE04401080108020FC4504FA0410842044FC4400041C04E0284010
+8370:04400440FFFE0440102010201020FC2031FC3820542050209020102013FE1000
+8371:08200820FFFE08203FF820083FF8200020702F8020F02F8020F85F824082807E
+8372:0440FFFE044000001FF0111011101FF0111011101FF001003FF801000100FFFE
+8373:08200820FFFE082000007FFC00001FF0101010101FF0000008200440FFFE0000
+8374:04400440FFFE044010201020FDFC10201420182033FED0501050108851042202
+8375:08200820FFFE082000007FF80208120824280810310008844892481287F00000
+8376:08200820FFFE08200040004078A049104A884C4648404BF07810482000200040
+8377:04400440FFFE0440100017FE20086008A7C824482448244827C8200820282010
+8378:08200820FFFE092001003FF801007FFE40029FE400400180FFFE010005000200
+8379:08200820FFFE0820010011F811001100FFFE010009081110606001800E00F000
+837A:08200820FFFE08200820108010FC7D041204108410541C24E044418400280010
+837B:04400440FFFE04404420282010A428A448A89920282048508850088851042202
+837C:08200820FFFE092002800440082037D8C10601003FF801001110210845040200
+837D:08200820FFFE082000F87F00221011200200FFFE042008201C4003800C707008
+837E:0820FFFE08200400082010103FF804480820121067E80820144003801C70E00E
+837F:08200820FFFE0820009000883FFC208020883E88225022502A244454418C8604
+8380:08200820FFFE082000003FF820002FF020003FFC248824504420451886060400
+8381:08200820FFFE082000007FFC01001110111011102928454485840100FFFE0000
+8382:08200820FFFE08203F04210421243F24082408247FA408A410A4108422944108
+8383:0440FFFE044030100CE003000CC03230FFFE080011003FF0D110115011200100
+8384:0820FFFE082000007FFC01003FF821083FF821083FF821001A00060019C0603E
+8385:08200820FFFE082008800840104033FC50009008120811101110102017FE1000
+8386:08200820FFFE09200110FFFE01003FF821083FF821083FF82108210821282110
+8387:04400440FFFE044000203E20222022FC3E2422243E24222422442F44F0944108
+8388:08200820FFFE082021F011101110820C440053F011102110E0A0204021B02E0E
+8389:04400440FFFE044000000608780808480848FF481C482A484948880808280810
+838A:04400440FFFE044000002420242024203C2007FE0420FC202420242025FC4400
+838B:04400440FFFE04400880088010FE11403240547C90401040107E104010401040
+838C:04400440FFFE0440082004401FF01010101010101FF00440044008421042603E
+838D:04400440FFFE0440011001087FFC0100211811A007401920E118410605000200
+838E:08200820FFFE082000001020082040A824A40522092272281010106011800600
+838F:08200820FFFE082010001020FC2010A814A419223122D2281010106051802600
+8390:08200820FFFE08202040104013FC8244444810A010A0E120212022222422281E
+8391:0440FFFE044008001FF0282007C01830E10E1FF001001FF001007FFC01000100
+8392:08200820FFFE082000001FF0101010101FF000003FF82008200820083FF82008
+8393:04400440FFFE144010003FFC40009FF012101110FFFE221021103FFC00100060
+8394:04400440FFFE044000003FF8200824482828301827C82448244824483FF82008
+8395:08200820FFFE092001007FFC054009203118C1061FF01010101010101FF01010
+8396:08200820FFFE082000007FFE08881110222011103FF8010001000100FFFE0000
+8397:08200820FFFE082001007FFC01003FF821083FF821083FF80100FFFE01000100
+8398:08200820FFFE0A2001003FF8000008200440FFFE010001007FFC010001000100
+8399:08200820FFFE082000003FF80408FFFE04083FF808001FF8280848088FF80808
+839A:04400440FFFE044000187BE00840104022787A400A402BFC1000280047FE8000
+839B:04400440FFFE044000387BC00840104023F8784008402BFC1000280047FE8000
+839C:08200820FFFE0820000010401040247E24886488A54824502420205020882306
+839D:08200820FFFE082001001110111011102928454481003FF801000100FFFE0000
+839E:08200820FFFE0A2001003FFC200440081FE000007FFC0440044008441044603C
+839F:08200820FFFE09200280044009203098CFE6004000801FF0101010101FF01010
+83A0:04400440FFFE04701F8001007FFC054009203118CFC6044004F0081010506020
+83A1:04400440FFFE044000001FF0101010101FF00100110011F81100290047FE8000
+83A2:08200820FFFE0820092001007FFC11101110292845440280044008203018C006
+83A3:08200820FFFE092000807FFC080008000FF80000010008844892481287F00000
+83A4:08200820FFFE08200000FFFE04403FF824482448283830083FF820083FF82008
+83A5:08200820FFFE082044002BF81048284848489BF8284848888888088857FE2000
+83A6:08200820FFFE08200100111009201FF010101FF010101FF01010101010501020
+83A7:08200820FFFE082000001FF010101FF010101FF010101FF0044008421042603E
+83A8:08200820FFFE0A2001001FF010101FF010101FF0110410881050122014181806
+83A9:08200820FFFE082000F87F00221011203FE000400080FFFE0100010005000200
+83AA:08200820FFFE0820064038500848FFFE084008400E2478280812082A28C61302
+83AB:08200820FFFE082000001FF010101FF010101FF001007FFC028004401830E00E
+83AC:08200820FFFE0820040007E0082010403FF8510811081FF8028004821882607E
+83AD:08200820FFFE082000007E7C42447E4442447E44404450544848544062404040
+83AE:08200820FFFE082000003FF821083FF821083FF802007FFC0404080410286010
+83AF:08200820FFFE082008202040104097FE40E0415011502248E444284220402040
+83B0:04400440FFFE04401080108010FC7D041248104010401CA0E0A0411002080C06
+83B1:08200820FFFE092001003FF80100111009207FFC0380054009203118C1060100
+83B2:08200820FFFE0820208017FC1140024073FC1040104017FE1040284047FE0000
+83B3:04400440FFFE044000107C10441045FE44107D104490449044107C1044500020
+83B4:04400440FFFE04401FF0101010101FF001007FFC410442844444484440144008
+83B5:08200820FFFE092002003FF82108210821083FF8228804900888108A2082C07E
+83B6:08200820FFFE0820092002800440082037D8C00602101110092008407FFC0000
+83B7:08200820FFFE082044402850104828404FFE984028A048A08910091052082406
+83B8:04400440FFFE04404490288810882BFE48A098A028A0492089200A225222241E
+83B9:08200820FFFE082000007FFE400280043FF8010001001FF00100014001207FFC
+83BA:08200820FFFE08207FFE42029FF410101210115010201FFC000400047FD40008
+83BB:04400440FFFE044000003FE00420047C08043014C0083E44225822623E42223E
+83BC:04400440FFFE04401020102023FE44207924112421247DFC00221C22E022401E
+83BD:0820FFFE0820024002207FFC044008203018C82608207FFC0820102020204020
+83BE:0820FFFE0A2002007FFC0440092037D8C106092008207FFC0820082010202020
+83BF:04400440FFFE044008000804FFA408247F2449244B241C242A24490488140808
+83C0:08200820FFFE0A2001007FFE400290041EF82288248854A8089008841084607C
+83C1:0820FFFE09203FF801001FF00100FFFE00001FF010101FF010101FF010101030
+83C2:08200820FFFE0820104020407E7C4284430442447E244224420442047E284210
+83C3:08200820FFFE0820200013FE920042004BFC0A041204E3FC2200220023FE2000
+83C4:08200820FFFE08200100FFFE01003FF821083FF821083FF803800D603118C106
+83C5:08200820FFFE082001007FFE40029FE410201FE010001FF0101010101FF01010
+83C6:08200820FFFE08207F0022FC22443E44224422283E2822102790FA2842440282
+83C7:04400440FFFE044010101010FEFE12102210227C6444144408441444227CC044
+83C8:08200820FFFE082010401020FC2011FC140018083108D0901090102053FE2000
+83C9:08200820FFFE08203FF000101FF00010FFFE111009A005401930E10E05000200
+83CA:04400440FFFE044010001FFC220452448A8402047FF407040A84124462140208
+83CB:08200820FFFE0820004000407BF8484048404FFC48E079504A48044408420040
+83CC:0820FFFE082000003FF8200820C8270821082FE823882548292821083FF82008
+83CD:08200820FFFE09200280044009203098CFE60040028001004884481287F20000
+83CE:08200820FFFE082000001FF810081FF810081FF82080208C3EF020822682387E
+83CF:04400440FFFE0440200017FE100880084BC84A481248E3C82248200820280010
+83D0:0440244814500440FFFE082004407FFC01003FF80100FFFE028004401830E00E
+83D1:08200820FFFE08200888111022201110088800003FF821083FF821083FF82008
+83D2:08200820FFFE082000003FF820083FF820083FF80100FFFE054009203118C106
+83D3:08200820FFFE082000003FF821083FF821083FF80100FFFE054009203118C106
+83D4:08200820FFFE08203EFC228422943E88228022FC3EA422A422A822904AA884C6
+83D5:08200820FFFE092002800C6037D8C0063FF8248824883FF82488248824A82010
+83D6:04400440FFFE04401FF010101FF010101FF000003FF820083FF820083FF82008
+83D7:04400440FFFE04401020102011FCFD24112411241DFCF1241124112451FC2104
+83D8:04400440FFFE0440101010901090FD0831483A44544250909088110813FC1104
+83D9:0820FFFE082000F83F0001007FFC09200920FFFE092009207FFC010001003FF8
+83DA:08200820FFFE0820021002FC7F4000840764781C021002FC7F4000840764781C
+83DB:08200820FFFE082000007C7C44447C7C44447C7C400440044004400440144008
+83DC:08200820FFFE0820001000F83F001110082001007FFC054009203118C1060100
+83DD:08200820FFFE082010481044FDFE1040144018FC30A4D12811281210542820C6
+83DE:08200820FFFE08200C80708010FC1124FD243224384454445084910412281010
+83DF:0440FFFE044008000FE0102020405FF8110811081FF8028004A008921082607E
+83E0:04400440FFFE04402020102013FC822442204BF80A881288E25024202450298C
+83E1:04400440FFFE044000001FE040445194492443C445444924551442047FFC0004
+83E2:08200820FFFE082010801080FDFC120415F411141D14F1F4110C1102510220FE
+83E3:08200820FFFE082000007F7C484448447F44412841287F10481048287F440082
+83E4:04400440FFFE0540111009203FF802007FFC082010102FE8C8260868080807F8
+83E5:04400440FFFE04401000100C11F0FD00110031FE391055105110921012101410
+83E6:04400440FFFE0440201813E01200020073FC1220122012201420282047FE0000
+83E7:08200820FFFE092000803FFE200020782F80288028802FFC284048244A948C4C
+83E8:08200820FFFE0A2001003FF808200440FFFE04007FFC08201C4003800C707008
+83E9:08200820FFFE082001003FF808200440FFFE000000001FF0101010101FF01010
+83EA:0820FFFE0A2001007FFE400280043FF0040008001FF02810481008100FF00810
+83EB:08200820FFFE08207FFC01003FF821083FF801007FFC01003FF80100FFFE0000
+83EC:08200820FFFE082023FC10841084808449144A0815FCE1042104210421FC2104
+83ED:08200820FFFE082020801110120887FC4204500013F82208E208220823F82208
+83EE:08200820FFFE092000803FFE20802FF820883FFE20882FF8214042204C18B006
+83EF:04400440FFFE04407FFC11101110FFFE111011107FFC0100FFFE010001000100
+83F0:08200820FFFE0820001C7DF00950115011501D503148D14811441254525A2468
+83F1:08200820FFFE082001003FF80100FFFE1010220847E40820144003801C70E00E
+83F2:08200820FFFE0820082004407C7C044004407C7C04400440FC7E044004400440
+83F3:08200820FFFE0820092002800C603018CFE6010001003FF811100920FFFE0000
+83F4:08200820FFFE0A2002007FFC044009203FF8D1161FF011101FF40104010400FC
+83F5:04400440FFFE04407FFC482444445FF4410440845FF44404440447E440144008
+83F6:04400440FFFE044001007FFC01003FF80200FFFE092017D02108DFF601000100
+83F7:0820FFFE08201FF000100FF000101FF000007FFE41029FF41110115011200100
+83F8:04400440FFFE0440102008207E50105010881F0612601210220022C04A308408
+83F9:04400440FFFE0440100009F80908410821F82908090811F87108110817FE1000
+83FA:0820FFFE092000801FFC10041FFC100017F8140817F8240827F8440884280410
+83FB:04400440FFFE04400820082008207EFC08201C301A702A6848A4892208200820
+83FC:08200820FFFE082001000910092012C0043019086914091012A004401830600C
+83FD:04400440FFFE044008000F7C08440844FF44002808282A104910892828441082
+83FE:04400440FFFE04403FF801000200FFFE08203118C10609901148214805000200
+83FF:08200820FFFE08207F84100422247F24092408247F24082408240F04F0144008
+8400:08200820FFFE092001F801003FFE210221F02F0420FC200027E044224822B01E
+8401:04400440FFFE0440082008207FFC08200FE008200FE00820FFFE082010102008
+8402:04400440FFFE04400E00787C08440844FF4418441C442A444A44887C08440800
+8403:08200820FFFE0A2001007FFC08200820145022880100FFFE0100010001000100
+8404:0820FFFE082020003FFC48049FE422040204FFFC0204222422243FE400280010
+8405:0820FFFE08200100FFFE010021083FFA010200FE00003FF820083FF820083FF8
+8406:08200820FFFE0A2004003FF821083FF822083FF808801080FFFE008000800080
+8407:04400440FFFE04400FF808000FF008000FF00800FFFE111010A014401830100E
+8408:08200820FFFE082000001FF010101FF010101FF010101FF00450084A1042603E
+8409:08200820FFFE082000003EFC22A422A43EA422FC22803E80228222824A7E8400
+840A:08200820FFFE092001007FFC11101110292845440380054009203118C1060100
+840B:0820FFFE09207FFC01003FF80108FFFE01083FF80200FFFE08201C4003C07C38
+840C:08200820FFFE082000007CFC448444847CFC448444847CFC4504010402140C08
+840D:08200820FFFE0820200017FC904042484950084017FEE0402040204020400040
+840E:0820FFFE082000701F8001007FFC05401930E10E04007FFC08201C4003807C78
+840F:04400440FFFE044008001FE020204440B878200820083C78200820083FF82008
+8410:0820FFFE082001007FFC01003FF80108FFFE01083FF8110011F8290047FE8000
+8411:08200820FFFE092008801FFC108030805FF8908010801FF8108010801FFC1000
+8412:08200820FFFE0A2001007FFC08201210244808201FF00440044008441044603C
+8413:08200820FFFE0A2001007FFE40029FF4101010101FF010101FF010101010FFFE
+8414:04400440FFFE0440100011FCFC4410441494190832FCD0841084108450FC2084
+8415:0820FFFE0A2001007FFC0820044003801C70E82E0FE008200FE0082010202020
+8416:0820FFFE0820060038F8200820083CF8200820083FF80440044008423042C03E
+8417:08200820FFFE0A2001007FFE400280041FF0000000007FFC1110210845040200
+8418:08200820FFFE0A2002007FFC0440082037D8C0063FF801000920111025080200
+8419:04400440FFFE044010201020FDFE11223224385054505490909011121212140E
+841A:08200820FFFE0820100011FC1088FC70138E10201DFC3020D3FE102050202020
+841B:08200820FFFE08203FF820083FF820083FF820083FF80820FFFE082010202020
+841C:04400440FFFE044010201020FE3E9220922092FC92849A849484108410FC1084
+841D:0820FFFE082000003FF8244824483FF8020007F008103420024001800E007000
+841E:08200820FFFE082000003FF8210822882448000020843E9820E020842684387C
+841F:08200820FFFE08200640384009F808487E4818C81C482A68289A488A09060A02
+8420:08200820FFFE082000003E7C224422443E7C224422443E7C224422444A948508
+8421:04400440FFFE04400020104009FC49042104250405FC09047104110411FC1104
+8422:08200820FFFE08202100110013F884084BE85228122823E8E2182204220421FC
+8423:08200820FFFE0A2001007FFE400280041FF00100110011F81100290047FE8000
+8424:08200820FFFE082000007FFE410281041FF0111011101FF0010001087FFC0004
+8425:08200820FFFE08207FFE40029FF4101010101FF000003FF8200820083FF82008
+8426:08200820FFFE082000007FFE440288441F8003200C103FF80108112025104208
+8427:08200820FFFE082001003FF80108FFFE01083FF8010025482528292841088108
+8428:04400440FFFE044000207DFC4488485051FE4900450045005500490042004400
+8429:04400440FFFE04400C20702010A410A4FCA83120382054505050908811041202
+842A:08200820FFFE08200C10709010501010FC903050381E55F05010901010101010
+842B:0820FFFE082000F83F000100FFFE054009203118DFF610101FF010101FF01010
+842C:04400440FFFE04401FF011101FF011101FF001003FF8210821482FE824282010
+842D:08200820FFFE082000F03F0001001FF011101FF001007FFC412441F45E144008
+842E:08200820FFFE092002800C6037D8C0063E0822483E4822483E48220822282610
+842F:0820FFFE082004000FE010203FF850081FF810081FF810081FF8042008101008
+8430:08200820FFFE092001007FFC01003FF8292825483FF8038005601918E1060100
+8431:08200820FFFE0A2001007FFE40029FF400001FF010101FF010101FF00000FFFE
+8432:08200820FFFE082000FC7F00220811103FF80200FFFE04000FF0122021C0CE3C
+8433:08200820FFFE08200100FFFE01003FF8244822882FE821083FF8210821282010
+8434:0820FFFE08203F04210421243F2421243F24212421243F240024120421144088
+8435:04400440FFFE04401FF010101F9010907FFC40044FE4482448244FE440144008
+8436:0820FFFE082001007FFC01003FF80200FFFE08201FF02828CFE608200FE00820
+8437:04400440FFFE0440080049042A247F2441247F2441247F244124410445144208
+8438:08200820FFFE082005003978210821083D78210821083FF8028004401830E00E
+8439:08200820FFFE092000803FFC20043FFC20002FFC292429242FFC49244924880C
+843A:0820FFFE08207FFC40045FF440045FF400001FF010101FF010101FF010101FF0
+843B:08200820FFFE0A2001003FF808200440FFFE00001FF010101FF010101FF01010
+843C:0820FFFE082000003EF822883EF800003FF80000FFFE08000FF0001000A00040
+843D:08200820FFFE0820208010F811088290486049981606E1F82108210821F82108
+843E:0820FFFE082000003FE008200BF80A88112822905FF8124812481248FFFE0000
+843F:04400440FFFE0440203813C01040804047FC5040104023F8E208220823F82208
+8440:04400440FFFE0440103813C0FC40104017FC18403040D3F81208120853F82208
+8441:0440FFFE0440082004407FFC01003FF80100FFFE0200FFFE08201C4003C03C38
+8442:04400440FFFE044020203E20442088FC7F24492449247F441454248A450283FE
+8443:08200820FFFE082000807C8044FE454046407C7C44404440447E7C4044400040
+8444:08200820FFFE082000403E40227E22A03EA0233C22203E20223E22204A208420
+8445:04400440FFFE0440000011F81108290845F89108110829F82508410887FE0000
+8446:04400440FFFE044008000BF81208320853F8904017FE10E0115012481C461040
+8447:0440FFFE04401FF0022001407FFC0484188862800100FFFE05401930E10E0100
+8448:04400440FFFE144020087FFC00043FF820083FF80100FFFE054009203118C106
+8449:04400440FFFE044012207FFC122013E010001FF80100FFFE05401930E10E0100
+844A:08200820FFFE092006C01830EFEE00001FF010101FF00820FFFE082010202020
+844B:08200820FFFE082000803C8024FC25043EF4249424943CF42494240454288810
+844C:0820FFFE08200400FFFE08201E4003C03C381010FEFE2224646418182434C2C2
+844D:04400440FFFE04407FFC00001FF010101FF000003FF821083FF821083FF82008
+844E:08200820FFFE0820004013F8204847FE884813F8304053FC904017FE10401040
+844F:08200820FFFE0820204013F890484FFE404813F82040E3FC20402FFE20402040
+8450:08200820FFFE0820044008203018CFE6042018A060403FF8244824482448FFFE
+8451:04400440FFFE0440080008087F0808FEFF08084808287F2808080F08F0284010
+8452:04400440FFFE04401000100025FC7C200820102024207E20002054204BFE8A00
+8453:08200820FFFE082008202090109013FC80904890489017FEE000209021082204
+8454:0820FFFE0820000009F00810101037FC510091F81240104017FC10A01110120C
+8455:08200820FFFE08201200213C49009400247E6108A2082E082208220822282010
+8456:08200820FFFE0A2001007FFE48229114212801107FFC0280044008203018C006
+8457:0820FFFE082002083FD002200240FFFE03000C003FF0C8100FF008100FF00810
+8458:04400440FFFE044008881110FFFE1110088800003FF821083FF821083FF82008
+8459:04400440FFFE0440080008FC7E84088418FC1C842A842AFC4884888408FC0884
+845A:04400440FFFE044008207FFC08200FE008200FE00820FFFE1240142010001FF8
+845B:0820FFFE08201FF010101FF010101FF008001FFC21045284944410041FA80010
+845C:0440FFFE044008007F7C08243E2408447F5408880100FFFE02800C603018C006
+845D:04400440FFFE044000207F202A2054FC2A2400247E24082408440E44F0944108
+845E:0820FFFE082000007DFC048804887CF8408840887CF80488049E05E828081008
+845F:08200820FFFE092002001FF010101FF010101FF000007FFC01003FF80100FFFE
+8460:04400440FFFE04400BF8080811F8300853F8900017FC140413F8111010E0171C
+8461:04400440FFFE24403FFC42247FF482043FE422243FE422243FE4222422A4204C
+8462:08200820FFFE092001007FFC04800A603118C0063FF8244824482448FFFE0000
+8463:0820FFFE08201FF001007FFC01001FF011101FF011101FF001003FF80100FFFE
+8464:04400440FFFE04401008100824087DFE0808108824487E48000854084A288A10
+8465:04400440FFFE044010100820FFFE00003E4822483E4822483E0822082A282410
+8466:0820FFFE082002003FF00410FFFE00001FF010101FF001001FF021003FF80100
+8467:04400440FFFE044008107F1008107F7E41123E1204120F1278220822284A1084
+8468:04400440FFFE04401FF011101FF011101FF00000FFFE111010A014401830100E
+8469:04400440FFFE0440100021FC7D244524452445247DFC4500450045027D0244FE
+846A:04400440FFFE044010041F0422247FA4A4A43FA424A43FA424A4248442948108
+846B:04400440FFFE04400800087C7F440844087C3E442244227C22443E8422940108
+846C:0820FFFE0820FFFE10803E9842E024841884E07C08200820FFFE082010202020
+846D:0820FFFE082000007CF8440844087CF8400041F87C88405040207C5040884306
+846E:0820FFFE0820060038F8208820883D06220021F83C8820882C50F02020D82706
+846F:08200820FFFE082010401440247C7884110424447E24002454044A048A280010
+8470:04400440FFFE044009100A0817FC31105208948411F813081490106011981606
+8471:04400440FFFE044008001FF82A4844480A88110822A8041001004884481287F2
+8472:0820FFFE0A2004001FF010101FF010101FF001047D88095011202118C5060200
+8473:04400440FFFE0440002800243FFE20202FA422242FA824982D12422A45468882
+8474:04400440FFFE0440002800243FFE20202FA420242FA8289828924FAA40468082
+8475:0820FFFE082000907EA00444282810102FE8C10601007FFC010002C00C307008
+8476:0820FFFE09207FFC00001FF010101FF000007FFE40029FF40100010005000200
+8477:0820FFFE08207FFC41043FF801001FF011101FF011101FF00100FFFE01000100
+8478:0820FFFE082000003FF8210821083FF8210821083FF802005104511290120FF0
+8479:08200820FFFE082020401040FEFE212020AC3CB425E424AC24A044A25482887E
+847A:0820FFFE08201FF010101FF000007FFC10101FF010101FF0103EFFD000100010
+847B:04400440FFFE044000001FF0101010D01710111017D0155027CA212A4FE68022
+847C:08200820FFFE08202448238824483FF81010220847E40820144003801C70E00E
+847D:08200820FFFE08207FFC04403FF824483FF80400FFFE08201C4003800C703008
+847E:08200820FFFE082010001EF8228862A894920882307EC10008844892481287F0
+847F:08200820FFFE08203FF821083FF820002FF828082FF828084FF848088FF80808
+8480:04400440FFFE04401FF010101FF010101FF000003FF8244824482448FFFE0000
+8481:08200820FFFE08202050104817FC00C00160F150124814441040280047FE0000
+8482:0820FFFE0A2001003FF8082004407FFE410281041FF011101150112001000100
+8483:0440FFFE044008000FE010201FC00040FFFE06003B0804B019C062A00C987306
+8484:08200820FFFE08207FFE400280043E0800087EFE14481428140A242A241243FE
+8485:0440FFFE04401080088043F0289011127212140E1100FFFE05401930E10E0100
+8486:0820FFFE082000007DF0111011901D52F20E0400FFFE08201C4003800C707008
+8487:04400440FFFE044800243FFE20202FA428A42AA82AA82A902A92452A49469082
+8488:04400440FFFE044020883C9020E42C84307C04001FF010101FF010101FF01010
+8489:0820FFFE082001001FF011101FF00100FFFE00001FF01010111002C00C307008
+848A:04400440FFFE04400880109830E057849084107C00007C8844B044C47C84447C
+848B:08200820FFFE0820008008F849102AA0285008901BFE29104890889008100830
+848C:04400440FFFE0440111009207FFC05401930610C0400FFFE08201E4003C03C38
+848D:0820FFFE0820240014007FE0042008200FF8080810081FFE2002255249548008
+848E:04400440FFFE0440201C13E0920E42F04A900A901292E2942288248824A428C2
+848F:08200820FFFE08207FFE4002BFF404803FF82488287830083FF820083FF82008
+8490:08200820FFFE0A2004003FF821083FF821083FF8029002A804B8088A3082C07E
+8491:0820FFFE08200600387820483E4822863F0022FC3E4420443E2822104A2884C6
+8492:0440FFFE0440100023FE7C20442045FC7D2441247D24452445347D2844200020
+8493:04400440FFFE04401020102025FE7C200924112425247DFC002254225422801E
+8494:08200820FFFE0820004078404BFC48404FFE78104FFE48104A10791048500020
+8495:04400440FFFE04401FF01110129014501FF000003FF8244824482448FFFE0000
+8496:0820FFFE09207FFC01001FF010101FF010101FF010101FF01010FFFE08201010
+8497:08200820FFFE08A0204013F8920843F84A080BF81242E2442228229023082206
+8498:0440FFFE044008007F7C114432440C7C3220DFC001003FF801007FFC01000300
+8499:0820FFFE08207FFE40028FE400007FFC06003B0804B019C062A00C9872860100
+849A:0820FFFE082000007FFC00001FF010101FF000007FFC482444445FF44104410C
+849B:04400440FFFE0440202020203DFC50241024FC2411FE542054505C5074880506
+849C:08200820FFFE082000007C7C00000000FEFE1010101054545252929250502020
+849D:0440FFFE044000003FFC2080210027F0241027F0241027F0408044908A881104
+849E:08200820FFFE082021401120120082FC46005A8812482248E250220022FC2200
+849F:08200820FFFE08202080108010FCFD0402F44894489448F410941E04F0284010
+84A0:0820FFFE082002003FF820083FF820083FF820083FF8010008844892481287F0
+84A1:0820FFFE082001003FF8082004407FFE420281043FF8040007F0081010502020
+84A2:08200820FFFE0820784048A05110620855F648404BFC68405150424845444080
+84A3:08200820FFFE0820104020A041108A0815F6304053FC90401150124815441080
+84A4:08200820FFFE0820204010A0911042084DF6104027FCE0402248244429422080
+84A5:08200820FFFE0820040079FC40444844545462883FF821083FF821083FF82008
+84A6:0440FFFE044008801FFC30805FF890801FF810801FFC10003FF00C6003807C7C
+84A7:04400440FFFE0440002800243FFE222023A422242FA8289828924FAA40468082
+84A8:0440FFFE044013F8104023F820406FFEA00023F8220823F8220823F822082218
+84A9:08200820FFFE08200C0071F811081108FDF83108390855F85108910817FE1000
+84AA:0820FFFE092001107FFC01003FF821083FF821083FF821080020FFFE08200460
+84AB:0440FFFE0440082004407FFC01003FF80200FFFE080017F8208040809FFC0000
+84AC:08200820FFFE08207FFE44028FE410203FF8510811081FF802800492188AE07E
+84AD:0820FFFE082010001FFC210451141FF4020814001FFC210451141FF404143808
+84AE:08200820FFFE082004007FFC450408801FFC30805FF810801FF810801FFC1000
+84AF:11021102FFE2110A000A7BCA4A4A4A4A7BCA4A4A4A4A7BCA4A424A42AB4A1484
+84B0:08200820FFFE082010783E4822482A862300FEFC22442A44222842104A2884C6
+84B1:04400440FFFE044010281024FDFE102015FC192431FCD12411FC11245124210C
+84B2:08200820FFFE0828404427FE204087FC444457FC1444E7FC2444244424540408
+84B3:04400440FFFE04401020102025FC7D2409241154254C7D840104550455148108
+84B4:08200820FFFE08204100227CFFC40844497C494449447F7C1144204440948108
+84B5:0440FFFE044000387FC02208151008401F8001201FF002107FFC04401830E00E
+84B6:04400440FFFE04401010109024887D040A0211F824487C480088548855288210
+84B7:0820FFFE08201FF010101FF000003FF820083FF820083FF820083FF808201010
+84B8:08200820FFFE08201FC000447D88055009203118C50602003FF8000024884244
+84B9:0820FFFE082010100820FFFE04403FF80448FFFE04483FF80C603458C4460440
+84BA:0820FFFE092000801FFC1000920053F8544010403FFE504090A0211022084C06
+84BB:08200820FFFE082000007EFC02047EFC40807EFC020422441A3462C414280810
+84BC:08200820FFFE092006C01A30E10E1FF010101FF010101FF010002FF848088FF8
+84BD:0820FFFE082000003FF821082FE82288244828283FF8010008844892481287F0
+84BE:08200820FFFE08202040124811500040F7FC10E01150124814441040280047FE
+84BF:0820FFFE08200200FFFE00001FF010101FF000007FFC40044FE448244FE4400C
+84C0:04400440FFFE0440000C7DF00440088811F010201C44F3FE1022112452222060
+84C1:0820FFFE082001007FFC01003FF80200FFFE082017D02108DFF6054009201110
+84C2:08200820FFFE08207FFE40029FF410101FF010101FF00100FFFE082010102008
+84C3:0820FFFE08200500397821083D7821083FF801003FF00820044003801C70E00E
+84C4:0820FFFE08200100FFFE08201FC003100C083FFC00043FF821083FF821083FF8
+84C5:04400440FFFE0440202017FE1080810843FC500411502150E15022522252244E
+84C6:0820FFFE092000803FFC222022203FFC222023E020802FF8488848A888900080
+84C7:0820FFFE08201FF010101F9010907FFE40029FF410101FF010101FF010101030
+84C8:08200820FFFE082004003F7C21443F4821503F48284424442A54324820400040
+84C9:08200820FFFE0A2001007FFE400289241290244808203FF8C82608200FE00820
+84CA:0820FFFE0820044008203218C4460FE000207EFC224412240A1412242A544488
+84CB:0820FFFE082001003FF801007FFC080010103FF800003FF824482448FFFE0000
+84CC:0440FFFE04401110111029287FFC0100FFFE08001FF02820444003801C70E00E
+84CD:0820FFFE0A203FC00280FFFE02200FC03408C3F800001FF010101FF010101FF0
+84CE:0820FFFE092000803FFC20802FF820883FFE20882FF820804FF848088FF80808
+84CF:08200820FFFE08200000061C38E828A82CA82AA82AA82AA828A455545D748212
+84D0:0820FFFE08203FFC20002FF820003FFC24482430260E20205FFC442082A00040
+84D1:0820FFFE082001007FFC00001FF01010FFFE10101FF0048808503820CB180C06
+84D2:04400440FFFE044008007F7C08107F1049107F1049FE7F100810FF9008100810
+84D3:08200820FFFE08A0104017FC20006208A1102FFE200023F82208220823F82208
+84D4:04400440FFFE0440082004407FFC010001003FF801000100FFFE248822444244
+84D5:04400440FFFE04401020102011FCFC20102033FE3800542051FC9020102013FE
+84D6:0820FFFE082002003FF82448238824483FF8000020843E9820E020842684387C
+84D7:08200820FFFE0820104023F84040884017FC3040524092781240154018FE1000
+84D8:0820FFFE0A2001007FFC08201210244848241FF00510088818502920CA180C06
+84D9:08200820FFFE092000803FFE2080249024902AA831C420802FF8408040809FFE
+84DA:08200820FFFE0820108011FC228828706B8EA8202848299028642988203021C0
+84DB:04400440FFFE044008200820FFBE08447FA449244B281C282A10492888440882
+84DC:08200820FFFE08207F7C140414047F04557C574061407F40414241427F3E4100
+84DD:08200820FFFE08200480248024FC24A0251000003FF8244824482448FFFE0000
+84DE:08200820FFFE082000FC7F00220811100C20307820083C78200820083FF82008
+84DF:04400440FFFE044010041F0422247FA4A4A43FA424A43FA40004078478142008
+84E0:08200820FFFE09200080FFFE0440139014501FF001007FFC44444FE44424400C
+84E1:08200820FFFE082023F8100811F8800843F8500017FC2404E3F8211020E0271C
+84E2:04400440FFFE144008003E7C22443E44227C3E442244287C24442A4432942108
+84E3:0820FFFE082000007DFC0420284011FCFD041524112411241124105050882304
+84E4:08200820FFFE0820404023F820400FFE1110128824F4E11022A0204021B02E0E
+84E5:08200820FFFE082000007FFE410282840C603018DFF601003FF8111009207FFC
+84E6:0440FFFE04401FF010101FF01010FFFE10102FC8C04608400FF800087FA80010
+84E7:08200820FFFE0820108011F822886870ABAE282029FC282028A8292422A42040
+84E8:0440FFFE0440108011FC228828706B8EA80029FC290429FC290429FC2104210C
+84E9:0820FFFE082000807CF805082A901060FD981606304053F89048108851502620
+84EA:08200820FFFE082047F8211020A007FCE44427FC244427FC2444245454088FFE
+84EB:0820FFFE082023FC10801144066870B01128166810A4112416A0284047FE0000
+84EC:0820FFFE0820010023F0151010E0071C704013F8104011F0104017FC284047FE
+84ED:0820FFFE092000803FFC20803FFC222024902FF8349427F0249047F24082807E
+84EE:0820FFFE0820004027FC104013F8024873F8124813F8104017FC284047FE0000
+84EF:04400440FFFE04401110211041108AA8144430405240927C1240154014FE1800
+84F0:04400440FFFE04401020213C4120892017FE300050209120113E112012A0147E
+84F1:08200820FFFE08202108109093FC40904890089017FEE0902090211021100210
+84F2:0820FFFE082000003FF8200027F0241027F020002F7829482F7820003FFC0000
+84F3:0440FFFE044008207FFC08200FE001003FF821083FF801007FFC0100FFFE0000
+84F4:0820FFFE09207FFC01003FF821083FF821083FF801047FFC0020FFFE08200460
+84F5:04400440FFFE0440102013FE1020FDFC102413FE1C24F1FC1020113C512022FE
+84F6:04400440FFFE044000A0009079FE49204B204DFC492049FC7920492001FE0100
+84F7:04400440FFFE044010A01090F9FE11201B2015FC3120D1FC1120112051FE2100
+84F8:0440FFFE04407FFC04403FF824483FF824483FF800001FF010101FF010101FF0
+84F9:04400440FFFE0440140027DE4912811217D221126112A5D2251A25D42E102410
+84FA:08200820FFFE0820104010407C4010F8FE48444892C87C4810AA1CAAE1064202
+84FB:08200820FFFE0820104010407C4011F8FE48444828C87C4810AAFEAA11061202
+84FC:0820FFFE08203CF824481428254806C01830E30E0C403180063038C007003800
+84FD:0820FFFE08203FF821083FF821083FF80920FFFE09203FF801007FFC01000100
+84FE:08200820FFFE092001FC01003FF829282448228829282288244829283FF82008
+84FF:0820FFFE082001007FFE48028BF4108033F85208920813F81208120813F81208
+8500:04400440FFFE04401000087C7F4422481450FFC800443E44225422483E402240
+8501:0820FFFE09203FF80440FFFE00001FF010101FF010101FF00100FFFE01000100
+8502:0820FFFE08201FF011101FF011101FF0040008201FC003103FF8112025104208
+8503:08200820FFFE08207CF8048804F87C2041FC41247D2405FC042004242BFE1002
+8504:08200820FFFE08207C7C44447C7C44447C7C40044FE4482448244FE440144008
+8505:0820FFFE08207C7C44447C7C44447C7C41044FF442444644418442444C24400C
+8506:08200820FFFE0820204013F8104087FE4110528814F42110E2A0204021B02E0E
+8507:08200820FFFE082000007DFC44207D20452045FE7C50505048925492610E4200
+8508:0820FFFE082000007FFC04403FF824483FF800003FF80000FFFE111025080200
+8509:0820FFFE08200100FFFE101020085FF4101010101FF0048808503820CB180C06
+850A:04400440FFFE044011FC110415FC550459FC500091FC10202BFE242044208020
+850B:08200820FFFE0820220013BE921242125FD210142214EA88324822142A242442
+850C:0820FFFE082000000820FFA0083E7F42499449107F101C102A28492888440882
+850D:08200820FFFE092000803FFE22203FFC22243FFC284028482F7048444B448C3C
+850E:04400440FFFE244010F8FC8800887906020079F8008878884850482078D84B06
+850F:0820FFFE0A2001007FFC082004407FFC4444482457D4644C444447C440144008
+8510:0820FFFE0A2001007FFC082004407FFC41045FF441044FE448244FE44004400C
+8511:0820FFFE082000003FF8244824483FF800903FFC208030482850242440D4830C
+8512:0820FFFE082000003FF80208FFFE04083FF808001FF82808CFF8000024444222
+8513:0820FFFE08201FF010101FF010107FFC44447FFC00003FF0082007C01830E00E
+8514:0820FFFE28203FFC4004BFE400041FC410441FC400043FE422243FE422243FEC
+8515:0820FFFE0820145014507FFC245247CE80007FFC41041FF01110115011200100
+8516:0820FFFE092001F801003FFC21042FE0210827F8241027F0241047F044109FFC
+8517:08200820FFFE092000803FFC222022203FFC2220222023E020004A4849249124
+8518:0440FFFE044008201FF0102025487EFC04401930E64E1990062018C007003800
+8519:08200820FFFE082020401040FEFE210020003DFE2422242024BC44A055608A3E
+851A:08200820FFFE082000003F0821083F0820FE2E0820483F2844285508A4A80C10
+851B:08200820FFFE082010041F2422147F84A4A43F9424863FBC2484248442848104
+851C:04400440FFFE0440082008207F3E08443EA40824FF2810281E1022284A448482
+851D:04400440FFFE04400020792448A848207BFE487078A848A849247A2248200020
+851E:0820FFFE082001003FF82108FFFE21083FF811101FF00400FFFE082007C07838
+851F:08200820FFFE082020401040FEFE212020403CFC2520242025FE445054888906
+8520:08200820FFFE0820104010FC24887D50082010D827067C60001054C054308008
+8521:0440FFFE044010801EF822885450282017D82006DFF001001110210845040200
+8522:0440FFFE0440202013FC82244BF812882450E470298C2400FFFE082007C07838
+8523:08200820FFFE08200440247C24A83D50042804487DFE24882448244844088418
+8524:0820FFFE0A2001007FFE42028924284849940E1077F00100210821083FF80008
+8525:08200820FFFE092002003FF8220827E82A48218826483FF801004884481287F2
+8526:0820FFFE082004001FF010101FF010101FF010001FFC10001FFC492484940008
+8527:0820FFFE08201010FEFE10107C7C1010FEFE10103FF800081FF800083FF80008
+8528:0820FFFE08207FFC45445FF442047FFC482457D4644C44C4442443E440047FFC
+8529:0820FFFE0A2001007FFE4002BFFC01003FF821083FF821083FF8101020084004
+852A:04400440FFFE044008067F7808407F40497E7F4849487F4808487F4808880908
+852B:0820FFFE08207FFC010011F81100FFFE10001FF820003FFC0004492484940008
+852C:0820FFFE082000107DFE0420184851FE50025CA850A850A85D2A712AC22A0406
+852D:0820FFFE0820004078A04910524865F4502048404BF8680057FC4080411043F8
+852E:04400440FFFE04407FFC40A47FFC40845E9452945E64405446B459147FFC4004
+852F:04400440FFFE044000207BFE482051FC612451FC492449FC687050A841244622
+8530:0820FFFE09203FF820083FF8200027F0241027F020002FF828884FF8480287FE
+8531:0820FFFE082022001478084814482A8609007EFC08442A4449288910282810C6
+8532:0820FFFE0A2001007FFE400280443E40007C7E88155014201452248A43FE8000
+8533:0440FFFE044023F8104013F8804047FE500013F82208E3F8220823F822082218
+8534:08200820FFFE092000803FFC242024203F7C24202E702D6834A4452244208420
+8535:04400440FFFE044800243FFE20202FA42A242FA828A82F902A124FAA40468082
+8536:0820FFFE09207FFC01003FF80100FFFE10101FF010101FF010101FF008201010
+8537:0820FFFE082001003FF811100920FFFE00003FF8200827C8244827C820083FF8
+8538:08200820FFFE0920120067DC444447C4444457DC60000440044008421042603E
+8539:04400440FFFE044008200820143E22445DA48024112809284A1027A8F8444082
+853A:0820FFFE0820200017FC050444844FF459046FE449044FE449044FF448144008
+853B:0820FFFE0A2001007FFE400280243E3800207EF81408145014242454248443FC
+853C:0820FFFE082043F8220823F80208E3F8210023FC244422A42A0433F420140008
+853D:04400440FFFE0440082049202A3E7F4449A449245D286B284910412845444282
+853E:0820FFFE08200640387C08947E241C442A9449080100FFFE054009203118C106
+853F:0820FFFE082000F87F00221011201FE010201FF010101FFC20042AA44AA4800C
+8540:0440FFFE044010101010FEFE1010FEFE92929292969638385454929210101010
+8541:0820FFFE08203FF000101FF000103FF000003E7C08447F7C0020FFFE08200460
+8542:0440FFFE044000203D2424A825FC3C4027FE24883D2426FA2448444854A88910
+8543:0820FFFE082000F83F0011100920FFFE09203018DFF611101FF011101FF01010
+8544:0820FFFE08207C7C44447C7C44447C7C410440844AA44A144A5451C440144008
+8545:08200820FFFE082023F8124893F842484BF8084017FCE444245425F42414040C
+8546:04400440FFFE044800243FFE20202FA428A42FA828A82F9028924FAA45468882
+8547:0820FFFE08203EF822883EF800001FF011101FF011101FF00100FFFE01000100
+8548:0820FFFE08207FFC04403FF824483FF810101FF010101FF00100FFFE01000100
+8549:08200820FFFE092008801FFC30805FF810801FF810801FFC1000248822444244
+854A:08200820FFFE0820082001002488242443E4000024241212A0A0A4A41C1C0000
+854B:0820FFFE0820010011F811001100FFFE081008104E9C489048904E90F1FE0000
+854C:04400440FFFE04401FF010101FF010101FF000007EFC42847EFC42847EFC4284
+854D:0440FFFE044020A01110120885F64000578414A427A4E4A427A4248424942588
+854E:0820FFFE082000701F800200FFFE082037D8C4463FF8200827C8244827C82018
+854F:08200820FFFE0820004453F42048505097FE108031FC530495FC190451FC2104
+8550:0440FFFE04407FFC1110292845441110292845447FFC0100FFFE010001000100
+8551:0820FFFE08207C7C44447C7C44447C7C400447C4444447C4444447C4445448C8
+8552:0820FFFE08203FF824483FF800001FF010101FF010101FF010101FF008201010
+8553:0820FFFE08203FF801007FFE41029D7401001D7000003FF80000FFFE10103FF8
+8554:0440FFFE0440100010FC7C841094FE88448028FC7CA410A4FEA8109010A810C6
+8555:08200820FFFE0820228814500BFE145025FC4D54158C250445FC850429FC1104
+8556:0820FFFE082023FC120043F82A080BF8720013FC1100FFFE05401930E10E0100
+8557:08200820FFFE0820008078F849084A907860119812065DF8510851085DF8E108
+8558:0820FFFE082001003FF80100FFFE08203EF808207EFC00007FFC04401842E03E
+8559:0820FFFE09203FF801001FF011101FF011101FF001087FFC02044908482487E4
+855A:0820FFFE08201FF010107FFC44447C7C00003FF80000FFFE10001FF800080070
+855B:08200820FFFE08200C88705011FC1024FDFC312039FE546250AA912412201020
+855C:08200820FFFE082004407C7C04403C7804407C7C0440020009084924482487E0
+855D:04400440FFFE0440108010F825087E1009FC112425247DFC01005502550280FE
+855E:0820FFFE08201FF010101FF01010FFFE22003EFC22443E4422282F10F22842C6
+855F:0820FFFE08A03E900464282810103EF8C2961E90110C20F03E90026014900908
+8560:0440FFFE044008007F7C114432440C44367CC8801F0002103FF8010815202210
+8561:0440FFFE05407FFC0920FFFE08203FF820083FF820083FF820083FF808201010
+8562:0820FFFE09201FF011101FF00100FFFE10101FF010101FF010101FF008201010
+8563:0820FFFE082000FC7F00220811107FFE400290243DF84420A92011FC2020C020
+8564:0820FFFE08200010FF50107C29904E10967C2510CD1014FE2440C430140E0800
+8565:0820FFFE082000507E4804FE2490259044FE7E900C9014FE2490449094FE0880
+8566:0820FFFE082000000BFE102021FC490411FC210445FC090411FC2000C0880104
+8567:0820FFFE0820020013FC240043F88A0813F8320853F8910013F8151010E0171C
+8568:0820FFFE082000003FFE289025102FBE22222AD42A902F902228442844448882
+8569:08200820FFFE082023F8120893F8420843F810002FFEE20027FC292422540488
+856A:04400440FFFE044010003FFC4AA00AA07FFC0AA00AA07FFC0000248822444244
+856B:0820FFFE09201FF004407FFC00001FF011101FF011101FF001003FF80100FFFE
+856C:04400440FFFE04401020102024407C8809F0102024487DFC002054A855248060
+856D:0820FFFE09203FF80108FFFE01083FF825483D7821083FF821083D7825484548
+856E:0820FFFE082002001CF010101EF010101FF008001FFC20044924249424944008
+856F:0820FFFE0820010079F04A9050606198560649F04A406BF8544043F8404047FC
+8570:04400440FFFE044023F8120893F842084BF8080017FCE524252425242FFE0000
+8571:04400440FFFE04400C20712410A81020FDFC310439FC550451FC910411141108
+8572:0820FFFE0820220C14707F4049407F40497E7F480848FF480848088808880908
+8573:08200820FFFE08207C7C44447C7C44447C7C40044FE448244FE448244FE4400C
+8574:04400440FFFE044021F8210845F88908F1F8200043FCFA9402941A94E7FE4000
+8575:0440FFFE0440204020A021583A264DF8490849F8A90811F81144212841508188
+8576:0820FFFE08203FF801007FFE41029D7401001D7006C01930EFEE004006800100
+8577:0820FFFE082000007DFE042028FC1084FEFC128414FC108410FC100050482084
+8578:0820FFFE0820000047BC248427BC0400E7BC240427A82410242854448FFE0000
+8579:0820FFFE0A200100FFFE10A0209045FE7B2011FC25207DFC0920112021FEC100
+857A:0440FFFE04403E2822243E240020FFFE22203E2822283E1022122F2AF2464282
+857B:08200820FFFE082000483E4820483CFC20483C482048FEFE20004448FE844302
+857C:0440FFFE044000203EFC20243DFE20243CFC2020FEFC102025FE7E2022200020
+857D:0820FFFE082002401FF812481FF812483FFC20002FF820003FFE24484530860E
+857E:0820FFFE08203FF801007FFE41029D7401001D7000003FF821083FF821083FF8
+857F:0440FFFE0440101E13E0152254945BFC504097FE108011FC2A48243044488186
+8580:08200820FFFE082023F81248924842A84BF8080017FCE4A424A424A42FFE0000
+8581:0820FFFE082004003FF8292825482FE8254828280100FFFE02800C603018C006
+8582:0820FFFE082010003E2022203E3E22443EA408247F2810281E1022282A444482
+8583:0440FFFE0440202017FE100081F8410851F8100027FEE40225FA250A25FA2406
+8584:0820FFFE0820004827FC104013F8824843F84A480BF81248F01027FC22102130
+8585:0820FFFE082023FE2200FAFC4A004BFE4AA4929852C6220853FE4A8884480818
+8586:0820FFFE082000F87F00221011207FFC4204292847E408001FF0282007C0F83E
+8587:04400440FFFE044022204AA08ABE1FC420A46F24A0282F28291029A829443082
+8588:0820FFFE092002800C6037D8C0063FF829283FF800001FF010101FF010101FF0
+8589:0820FFFE092011F81100FFFE00243FFE20202FA422242A182A90512A46469882
+858A:04400440FFFE044010041F0422247FA4A4A43FA424A43FA400042A8445540008
+858B:0820FFFE492021FC0A44F0B0230E3FF010101FF010101FF010101FF008201010
+858C:08200820FFFE0820210027DE545297D4E458245457D29512F49A255446108410
+858D:0440FFFE04407F102A107F1012100C107F904A905E9040905E924A9244924B8E
+858E:0820FFFE08207FFC44447FFC00007FFE4922911431FC5F1090A0104411A4161C
+858F:0820FFFE082001003FF80820FFFE00001FF010101FF010101FF04904489287F2
+8590:04400440FFFE04400C2071FC102013FEFC8831443A7A54885150902010D81706
+8591:0820FFFE08207FFC00003FF821083FF82108FFFE00003FF821083FF82108FFFE
+8592:0440FFFE044008000F7828087F28A110162838C4D11009207FFC05401930610C
+8593:0820FFFE082023F8100813F8800847FC544413F82248E04027F8211020E02F1E
+8594:0820FFFE09207FFC111029284544FFFE00003FF8200827C8244827C820083FF8
+8595:0820FFFE082001003FFC22203FFC22402FF822483FFC22482FF846604A50B24C
+8596:08200820FFFE082021F8110811E8012873FC120412F4129412F412142A0847FE
+8597:0820FFFE08207FFC41044FE441045FF440044FE448244FE446944A6452147FFC
+8598:0820FFFE0820004023F8104017FC0110F7FC104013F8104017FC1040284047FE
+8599:04400440FFFE044020A020907DFE9120132011FCFD2011FC2920252041FE8100
+859A:0820FFFE082000FC7E8410FC10843CFC240047FEA48019FE0A521092212A4044
+859B:08200820FFFE082010407C2045FC44887C5043FE40207C2045FC44207C204420
+859C:0820FFFE082000403E2022FC22883E5021FE20203E2052FC52209E2012200020
+859D:0820FFFE08201FF020207FFEA4882BF4200027F8200027F8200047F8440887F8
+859E:0820FFFE082000407EA0119812463DF8250845F8A50819F80944112821904108
+859F:08200820FFFE092002800440183067CC00003EF8228822883EF8082014502288
+85A0:08200820FFFE082013FC104015F8550859F8510891F8110829F8249045088204
+85A1:0820FFFE08201FF010101FF010105FF450145FF440047C7C0440FC7C24444444
+85A2:04400440FFFE044020FC3C244444BE8C2A503E7C2A903E102AFE2A1042108610
+85A3:0440FFFE04400810FF1008FE7E1000107EFE42427E44422824100E28F0444182
+85A4:0820FFFE082000507E5011DC10503C5025DC6450945009DC0850105023FE4000
+85A5:0820FFFE08203FF824483FF808001FFC2204DFC412441FC402243FE410280010
+85A6:0820FFFE09203FFC24403FF824483FF8240027FC28002FFC20044AA451548008
+85A7:0820FFFE09207FFC00001FF010107FFE4002BFF408401F48625014621842E03E
+85A8:0820FFFE08207FFC44447FFC00007FFE4002BFF408401F48625014621842E03E
+85A9:0440FFFE0440002079FC4888505063FE52204AA04AFC6B2052FC4420442049FE
+85AA:0820FFFE0820100008047F7822401440FF7E08487F4808482A484988A8881108
+85AB:0820FFFE08203FF80100FFFE11101FF011101FF001003FF80100FFFE24884244
+85AC:0820FFFE0920020047C4244817D0244847C40100FFFE054009203118C1060100
+85AD:0440FFFE044000200C4071FC112411FCFD4431FC3850549051FE901010101010
+85AE:0440FFFE0440000049202A20FF3E2A4449A41024FE282228641018282444C282
+85AF:0820FFFE08203FF824483FF802001FD00220FFFE03000FF03810CFF008100FF0
+85B0:0820FFFE08203FF80100FFFE01003FF829283FF801003FF80100FFFE24484224
+85B1:08200820FFFE0820140855083608147E7F0814487F2808283E0808080F287810
+85B2:0820FFFE09207FFE40029FF4092011C006001FF868080FF808080FF804100808
+85B3:0820FFFE0820004023F8104017FC000073F8120813F810C411A812902C8847FE
+85B4:0820FFFE09207FFC4204A92847E400003FF82448FFFE00007FFC010005000200
+85B5:0820FFFE09207FFC01003FF80000FFFE00023FF00100FFFE00107DFC44907C30
+85B6:0440FFFE0440080031FCCB242D2431FCC924152425FCCC2015FC2420D4200BFE
+85B7:0820FFFE08203FF801007FFE41029D7401001D7000007FFC02003FF824482458
+85B8:0820FFFE0820200017FC10A087FC44A457FC100027FCE0002FFE2040224824C4
+85B9:0820FFFE0920FFFE01003FF800001FF010107FFE48229FF401003FF80100FFFE
+85BA:0820FFFE08200100FFFE02887D7025484D6690101FF010101FF0101020104010
+85BB:0820FFFE082022481490124883F8424853F8124823F8E0402FFE215022482444
+85BC:0820FFFE09203FFC24403FF824483FF828402F7828442F3C20804FF840809FFC
+85BD:0820FFFE082000007F7C14207F20553855287F48086808587F4A084A0F6AF046
+85BE:0820FFFE08207FFC111021087FFCB55A29283558210835582928355820082018
+85BF:08200820FFFE0820247C3A0422281E1020FE3E124850085E7F5014B0229E4100
+85C0:0440FFFE044008202AA44D28145022887FFE410291141120228004401830E00E
+85C1:0820FFFE082001007FFC08200FE000007FFC48244FEC01007FFC05401930E10E
+85C2:0820FFFE08207F00227C3E0422283E1023A8FE4403F87F04118863700D18F106
+85C3:0440FFFE044008207F2000203E3E22423E8400107F1041105D2855285D444382
+85C4:0440FFFE044008207FFC08200FE00820FFFE14502F8841241FF0011009201310
+85C5:0820FFFE08207FFC44447FFC0800FF8400247F2400247F2400247F0441147F08
+85C6:0820FFFE0A2001007FFE4442BFFC0440FFFE082031D8CF0601007FFC01000300
+85C7:04400440FFFE04400A0033B822083A38238820883AB82288FFFE082010102008
+85C8:0440FFFE04400020F7A490A89292F114920895F4F84293F89040F0A091100608
+85C9:08200820FFFE082010487CFC10487C4811FEFE0010FC388454FC948410FC1084
+85CA:0440FFFE044000200DFE7102110211FEFD0031FE39AA56AA52FE94AA10A21086
+85CB:0820FFFE08203EF812480A28124808801FFC30805FF890801FF810801FFC1000
+85CC:0820FFFE0A2001007FFC42442B904C2837E0C1001FF011101FF001087FFC2004
+85CD:0820FFFE082000003F2024203F3E21403F5024883F0800003FF824482448FFFE
+85CE:0820FFFE09203FF80108FFFE01083FF801007FFC248842443FF824482448FFFE
+85CF:0440FFFE044800241FFE502057A0752417A4F4A857A85510951227AA20464082
+85D0:0820FFFE082008103020CAFC2C843084C8FC14842484CCFC1448244AD48A0906
+85D1:0440FFFE14401FE020207FF8A30824881FF011101FF008001FF0282007C0F83E
+85D2:08200820FFFE08200DFC710411FC1104FDFC308039FE56225552910211FA1006
+85D3:08200820FFFE082020443E2844FEFF1049107F7C49107F1000FE0F10F0104010
+85D4:0820FFFE0A207FFC4104BFF8044028281FF02828CFE608200FE0010015102208
+85D5:0820FFFE0820100011FC7D2411FC7D2411FCFC2013FE3A22562A92FA120A1206
+85D6:0820FFFE08203F7C24443F2821103F2824463FF010101FF010101FF008201010
+85D7:0440FFFE044042102F9022100F9E0AA2EA882F88220827142A94322252428FFE
+85D8:0820FFFE092001F801003FFC21042FE0210827F8249027F0249047F44A4A93FA
+85D9:0440FFFE0440100008787F48224814867F0010FC694416446D281490642818C6
+85DA:0820FFFE09207FFC01003FF824483FF810101FF010101FF010101FF008201010
+85DB:0820FFFE0A2001007FFE42029CF410101EF010101FF008001FFC20040AA412AC
+85DC:0820FFFE08200640387C08947E241C442A94490802C01D30E92E054009201310
+85DD:0820FFFE08203E2008F87F282A285D6A082A3E5600823FF80000FFFE10103FF8
+85DE:0820FFFE082000007FFC08001FF02810CFF000007EFE20407EFCA3443E7C2244
+85DF:04400440FFFE04403FF821083FF821083FF80000FEFE9292FEFE9292FEFE8282
+85E0:0820FFFE092002001FF010101FF010101FF020407EFC42847EFC42847EFC4284
+85E1:0820FFFE08A0404027FC211000A007FCE44427FC244425F4251425F4540C8FFE
+85E2:04400440FFFE044022204AA08ABE1FC420A46F24A0282FA822102FA822442F82
+85E3:0820FFFE08207FFC44447FFC24987EE000847E7C42007E9842E07E844284467C
+85E4:0440FFFE044000203D2424A825FC3C4027FE24883D2426AA247044A855248A62
+85E5:04400440FFFE044021104BA472B823904AA47BBC0100FFFE05401930E10E0100
+85E6:0820FFFE08A03FFE24103F7C26382D5434122FF8208027F820805FFE40808180
+85E7:04400440FFFE0440103C13C025447CA809FC104027FE7C8000F85548563080CE
+85E8:08200820FFFE09203FFC24403FF824483FF828402F7828442F3C40004A489124
+85E9:0820FFFE0820203817C01248815047FC524814042BFAE24823F8224823F82208
+85EA:0440FFFE044008007F204920FFBE49447FA42A243E281028FF1022281C446282
+85EB:0820FFFE0820000027FC10A017FC84A447FC520813F82208E3F8204027FC2040
+85EC:0820FFFE08207DFC452449FC482053FE490445FC450455FC490441FC40884104
+85ED:0820FFFE09207FFE5022A8143EF822083E0822F83E8022FCFE0412042228CE10
+85EE:0440FFFE044010A0109011FEFD2013FC312039FC552051FE900012A412521452
+85EF:0820FFFE08203F0821083F7E20082F4820285FA8440895282C900100489487F2
+85F0:0820FFFE08207784428462A454A469A414242224DD2408247F244A042F94F008
+85F1:08200820FFFE092000803FFC2100AFF868882FF86888AFF8215042F84C8AB07E
+85F2:04400440FFFE0440100013FE1200FE7C1244327C3A0056EE52AA92EE120013FE
+85F3:0440FFFE05407FFC08200FE000007FFC48244FEC00003FF80100FFFE0920711C
+85F4:04400440FFFE144010F824887CF8088810F824007DFC01545554555483FE0000
+85F5:0820FFFE08200BF8120833F8504097FE115012480100FFFE06801C48E530060E
+85F6:0820FFFE08203FFE21042E3822102FBC27182AB432522040247C444044409FFE
+85F7:04400440FFFE044020201022FDFC00287BFE004079FC068478FC488478FC4884
+85F8:04400440FFFE04400022FCFA2024602895FE344058FC948435FC568490FC2084
+85F9:04400440FFFE0440200011FCFD0401FC790401FC788001FE7A224D5279FA4806
+85FA:0820FFFE08207C7C44447C7C44447D7C44844FE459044FC449044FC449044FEC
+85FB:0820FFFE082023F8120813F8800047BC54A417BC2040EFFE215022482C462040
+85FC:0820FFFE09207FFC41043FF801001FF001007FFC24483FF801004884489287F2
+85FD:04400440FFFE044008007F7C2244147CFF44087C7F44087C2A28492AA94A1086
+85FE:04400440FFFE14401080FEF811087EFC548454FC7C8410FC388454FC90481084
+85FF:0820FFFE08203FF801007FFE41029D7408801FFC30805FF890801FF810801FFC
+8600:08200820FFFE082011FC1154FDFC102015FC182033FED08811FC102053FE2020
+8601:0820FFFE08207FFC01003D7825483D7801007FFC01003D7825483D780100FFFE
+8602:0820FFFE09202488242443E424281214A0A0A4A41C1C0100FFFE05401930E10E
+8603:0820FFFE092011F81100FFFE08102E5C28502E50F0FE01007FFC05401930E10E
+8604:0820FFFE0820770C5570774000407F7E49487F4849487F480848FF8808880908
+8605:0820FFFE0820220047DC888017C0257E67C8A54827C821082FE8210822A82450
+8606:0820FFFE092001F801003FFC21042FE0210827F8249027F024904FF849489FFC
+8607:04400440FFFE0440200C3E704410FF1049FE7F1049387F34005455528A900010
+8608:0820FFFE0820060038FE08107F7C1C442A7C49441C7C1444157C262824444082
+8609:0820FFFE08203FF82448FFFE901213F020102FFC6804A7F02210212020C02738
+860A:0440FFFE0440100010F824A87CA808D810F824007DFC01545554555483FE0000
+860B:04400440FFFE044009FE28202EFC2884FEFC088428FC2A8444FC08003048C084
+860C:0820FFFE0A2027DE491297D2211265DAA5142FD000003FF80000FFFE11102308
+860D:0820FFFE08A03F1004107FD0043E7FD255527FD204127FD20412FFE22AAA4544
+860E:0820FFFE08203FF801007FFE41029D7400003EF822A83EA822F83E844284867C
+860F:0820FFFE0820400049FE742044FC3C8400FC7C8400FCFE8410FC5400D2482084
+8610:04400440FFFE0440203C13C0FD4400A879FC00407BFE008078F849487A3048CE
+8611:0820FFFE08A03FFE22102FBC231826B42A5220003FFC44004FF8940827F80408
+8612:0820FFFE08A01CF0F11012F810A8FCF810A831FC392455FC552491FC1022101E
+8613:08200820FFFE08200C8070F811081210FDFC312439FC552451FC90001154122A
+8614:0440FFFE0440480075FE44203CFC00840CFC708410FCFE8410FC380054489084
+8615:0440FFFE04402020247C4AA4F81810E626104AFEFA10027CAA10AAFE051008FE
+8616:0440FFFE044020207DFC44887C5041FE7C2045FC7C2001007FFC05401930E10E
+8617:0820FFFE082000407C2045FC7C5043FE7C20A5FC3C2001007FFC05401930E10E
+8618:0820FFFE082001007FFC00003EF822883EF804403FF80440FFFE04901C60671C
+8619:0820FFFE08207F7848485E8664785F484A307F4C00007EFC22441A3462C4060C
+861A:08200820FFFE082020443E2844FEFF1049107F7C49107F1000FE55104A908A90
+861B:0820FFFE0820241024FEFF2024443CFE24023C7C2444FF7C5444627C40447E4C
+861C:04400440FFFE044029007DFC29043A4411547CE455F47C4410E4FD5410541008
+861D:04400440FFFE044008201420223E5D4280847710551077102228222855448882
+861E:04400440FFFE044008201420223E5D4480A47724552877282210222855448882
+861F:0440FFFE044001FC7CA845FC482051FC480445FC440455FC484042A4428A447A
+8620:0820FFFE0820104057FC524855547FFE100017FCF40455F4551455F4940417FC
+8621:0820FFFE08203EF822883EF822883EF822883EF814502288FFFE082007C07838
+8622:0440FFFE0440100008407E7C2440FF7C00047E7C42407E7C42407E7C4242463E
+8623:04400440FFFE044022207F10227EFF9008107F10497C7F1049107F1022FE4100
+8624:0440FFFE0440103C27C07A4449284BF84A087BFC4A044BFE7A024CAA04AA0906
+8625:0820FFFE092002800C6037D8C0063BB82AA83BB800003FF824883FF8248824B8
+8626:04400440FFFE04403FF801007FFE41029D7401001D7000003BB82AA83BB82AA8
+8627:0820FFFE08A000F840802FFC28840BF0E8882BF829402AA8317022A851608FFE
+8628:0820FFFE0820070CF87051102A2420783E104824FF7E081249544F5271920030
+8629:0820FFFE28203F20403EBE482AA8FF284A107F2808461F8002103FF811102308
+862A:0820FFFE09203FFC24403FF824483FF828402F7828442F3C44905FFC82A01C9C
+862B:08200820FFFE082027D01510179E84A047A8554417C42000E7F8252825282FFE
+862C:0440FFFE044010007DFC44047CFC40047DFC44007DFE11225CFC50A45EACF020
+862D:0820FFFE08207C7C44447C7C44447C7C41045FF441045FF455545FF44544592C
+862E:0820FFFE08203FF824483FF800003FFE22042A942514289422544A8445148888
+862F:0820FFFE082021F8110841F821080BFE090073FC14A4115412883FF82448FFFE
+8630:04400440FFFE044021FC210449FCF90413FE22524BFEF80001FCA888A870038E
+8631:0440FFFE0440100093FE5420FEFC388454FC928400FC1484FEFC280044488084
+8632:0440FFFE04401FF011101FF011103FF82AA83EF82AA83EF801003FF80100FFFE
+8633:08200820FFFE082022107F7C2210FF90087E7F0049107F10497C7F10227E4100
+8634:0820FFFE08201D7049245D7449245D7449247FFC00007FFC10101FF00820FFFE
+8635:0820FFFE08200094FDD2481249507BFE481049D4795449D44F48F9CA09560822
+8636:0440FFFE04400C20704011FCFD2439FC552493FCFC24245A685E10902912C60E
+8637:0440FFFE0440FFFE110013DE5A5253DE52505BD2E40E0FE0544483821C70E00E
+8638:0820FFFE08200050FE4810FE11907CFC549054FC6C9044FE7C8045547D2A462A
+8639:0820FFFE08A0104017FC10005BF856A853F892441158124410A8119016A810C6
+863A:0440FFFE0440100008287F24147E494855C87F7E08487F7E514855485D7E4340
+863B:0820FFFE08207F3C2A243E422A3CFFA449187F6608401F8002103FF811102308
+863C:0820FFFE08A03FFE24103F7C26382D54341221203F3E21202F3C41205F3E8120
+863D:0820FFFE08201FF011101FF011103FF82AA83EF82AA83EF801007FFC0920711C
+863E:0820FFFE08A0204027FC200023F8FAA823F822442118224438A8E19046A800C6
+863F:0820FFFE08207FFC44447FFC10A0209045FE792013FC25207DFC012055FE8100
+8640:0820FFFE0920FFFE02887D7025484D6682807EFC02803EF802807EFC0280FFFE
+8641:0440FFFE0440FFFE110013DE5A5253DE52505BD2E64E0FE0544483821C70E00E
+8642:0820FFFE08203FF801007FFE41029D7400403EFC23483E3009CE2E7828487E78
+8643:0820FFFE08202294129215508FFE42905EF412942EF4E2942EE8228A22F62F22
+8644:0820FFFE08A021F822882070FBAEA8F8A850FBFE22A02AFC3B20CA78042009FE
+8645:0820FFFE082001243CA825FC24403FFE248825FC3EA224F824A044FC54048AAC
+8646:0820FFFE08201FF011101FF011107FFC4AA47EFC4AA47EFC20087FFC11102308
+8647:0820FFFE08A87BFE08880BDE7A5243DE40A079FE09200BFC0D2009FC512021FE
+8648:0820FFFE082000007BDE489249124BD27A5E03C07A5E4BD24A524BD2799E4A52
+8649:0820FFFE08207F10007C3E44227C3E44007C7F40557E49407F7E490249AA4306
+864A:0820FFFE082021084FD2F03C23884812FBBE0280ABAA01007FFC05401930E10E
+864B:0820FFFE082077DC444477DC4444FFFE92921C7010101FF008201FF0642C0860
+864C:0820FFFE49202A3E7F4849485DA86B1049285FF612903EF822883EF8228A3DFE
+864D:0100010001F8010001003FFC200421082100211821E02F002104410440FC8000
+864E:010001F801003FFC210421602F88210820F8200023E02220222044244824901C
+864F:010001F801003FFC210421602F88210820F821002FF821082108420844509820
+8650:010001F801003FFC210421602F88210820F8200027F824003FFE440047F88000
+8651:010001F801003FFC210421602F88210820F82000208020442A424A12521081F0
+8652:0008007C3F80208020F820802FFE288228F02F84287C28004BE052229422281E
+8653:2020203E202021FEF922293829E02922291E29002B782D484948424A824A0486
+8654:010001F801003FFE210221F02F0420FC210020802FF822202140408043608C1C
+8655:010001F801003FFE210221F02F0420FC2400243827A828AA352A42464580987E
+8656:010001F801003FFE210221F02F0420FC201027E0224821502FFE404041408080
+8657:010001F801003FFE210221F02F0420FC2000201C27E0240027FE442044209FFE
+8658:010001F801003FFE210221F02F0420FC200027F8240827F8240847F84408BFFE
+8659:010001F801003FFC210421602F88210820F8210020882A242A445380460899F8
+865A:010001F801003FFC210421602F88210820F8224032482A482A5042405FFC8000
+865B:010001F801003FFE210221F02F0420FC2120292429242F3C212041205FFE8000
+865C:010001F801003FFC21042FE0210827F8249027F0249027F041005FF884080818
+865D:08200F2008207F7E496A4EAA782A492A474A40924E224A544A0A520291FE2000
+865E:010001F801003FFC21042FE0210827F8241027F020002FF820805FFC42209C1C
+865F:0020783E482049FE4922793801E0FD22211E41007978094809480A4A524A2486
+8660:2010101E0010FEFE0092289C44F08292048E448028B810A828A8452A852A0246
+8661:010001F801003FFE210221F02F0420FC200021202924252821205FFE42108408
+8662:04101E1EE01022FE9292549C40F00492FF8E048044B824A824A8052A152A0A46
+8663:08100C1EEA100AFE0892FE9C28F02892B88EA880AAB8AAA8B6A8C32A812A0246
+8664:10101E1E10107EFE52925C9C70F052924E8E40805CB854A854A8972A952A2246
+8665:10281E24102E7EF052285C12702A52D64E28402E5CF0542454285612942A20C6
+8666:2810241E2E10F0FE2892129C2AF0D692288E2E80F0B824A828A812AA2B2AC646
+8667:08000FBC08007FC048404F3E7890479052205FBE72025F8252025F8252149F88
+8668:08020F8208047FC848504F0278824784400848907DE248825DC46AA8489088A0
+8669:1020923E522055FE11227D3845E07D22451E7D00117859485548964A524A2486
+866A:2120213C39642318FA66AABEB2AAE6BEAAAA9ABE8288BABEAA88AE7E2A0042AA
+866B:0100010001003FF821082108210821083FF8210801000110010801FC7E040000
+866C:0840084008407F4049404940494049407F40484008400A440F44F144403C0000
+866D:0800080008FE7F2249224922492249227F22482208220A420F42F18241140208
+866E:1000100010F07C9054905490549054907C905090109014921C92E512410E0200
+866F:0804080408447F4449444944494449447F44484C08740A440F04F10440040004
+8670:0800080008FE7F1049104910491049107F10481008100A100F10F11040500020
+8671:00007FF0009003D07C1004103F902490249024903F900412048A07CA78462002
+8672:0820082008207F2049204930492849247F22482208200A200F20F12040200020
+8673:0820082008207F7C49444984490449447F24481408140A040F04F10440280010
+8674:1008101C10E07C20542054205420543E7DE05020102014221E22E222401E0000
+8675:1020102010207D20552C5534556457A47D245134112815221D22E50240FE0000
+8676:100011FC10207C2054205420542057FE7C205020102014201E20E22040A00040
+8677:0800087C08107F1049104910491049FE7F10481008100A100F10F11040100010
+8678:100011FC10047C0854105420542057FE7C205020102014201E20E22040A00040
+8679:1000100011FC7C2054205420542054207C205020102014201E20E22043FE0000
+867A:00200020FE2025FC25242524252425FC24202420242825FC2404440243FE8000
+867B:1020101010107C0055FE5480548054807C805080108014801E80E28040FC0000
+867C:1040104010807CFE5500560054FC54087C105020104014801D02E50240FE0000
+867D:00001FF0101010101FF0010001003FF8210821083FF80120011001F87F042004
+867E:100013FE10407C4054405440545054487C445044104014401E40E24040400040
+867F:0000FFFE040007F00810101020A041403FF8210821083FF8010001087FFC2004
+8680:2020202020203DFC45244924A124212421FC212420202028282433FE21020000
+8681:1040102411247D0455045488548854887C505050102014201C50E48841040602
+8682:100011F810087C0854885488548854FE7C025002100215FA1C02E40240140008
+8683:040008401F8003080C103FE000C0070079001FF0111011101FF001087FFC2004
+8684:1040102010207DFE544054405440547C7C445044104414441E84E28441280210
+8685:100011FE11007D0055785548554855487D485168115015421D42E542423E0400
+8686:1000100011FC7D2455245524552455247DFC5100110015001D02E50240FE0000
+8687:100010FC10847C845484548454FC54A07CA050A0109014901D08E50842040402
+8688:100011FC10887C8854885488548857FE7C885088108814881C88E50841080208
+8689:020001007FFC0820044003801C70E10E1FF0111011101FF0110001087FFC2004
+868A:1040102010207DFE54885488548854887C885050105014201E20E25040880106
+868B:1020102010207DFE55225522552255227D52514A118A15021D02E502410A0104
+868C:1020102010207DFC54205420542055FC7C205020102017FE1C20E42040200020
+868D:1010111011107D125512551455D855107D105110111015121D52E592410E0000
+868E:1000100010FC7C8454845484548454847CFC5084108414841E84E28440FC0084
+868F:100010FC10847C84548454FC548454847C8450FC108414841E84E28441140208
+8690:1040104010807CFC55045604548454447C445014102414441D84E40440280010
+8691:1020102010207DFE54205420542055FC7C845088104814501E20E25041880606
+8692:100010FC10847C8454A45494549454847DFE5084108414841C84E50441140208
+8693:100411E410247C24542455E4550455047D0451E4102414241C24E42441440084
+8694:1004101E11F07D1055105510551055FE7D105110111015081D0AE54A41860102
+8695:00003FF801000200FFFE044008203118DFF6111011101FF0110001087FFC2004
+8696:1000100011FC7C005400540057FE54907C905090109014901D12E512420E0400
+8697:1020102010207DFC54245424542454247DFE5020105014501E88E28841040202
+8698:1048104410447C4057FE5450545054507C505050109014921C92E512410E0200
+8699:1020102010507C5054885544562254207C0051FC100414081E08E21040100020
+869A:1008101C10E07C805480548054FE54887C885088108814881D08E50842080408
+869B:1020102010207C2055FC5524552455247D2451FC112414201E20E22040200020
+869C:100011FE10087C8854885488550855FE7C185028104814881D08E60840280010
+869D:1008103C11E07C205420543C55E054207C20503E13E014201E22E2224022001E
+869E:1020102010207C2055FE5420547054707CA850A8112415241E22E42040200020
+869F:1000100011FC7C2054205420542054207DFC5020102014201C20E42043FE0000
+86A0:044008203018DFE60420042008A0104021001FF0111011101FF001087FFC2004
+86A1:1010109010907C8855085504560455FA7C885088108814881D08E50842280410
+86A2:1040102010007DFC5400540054F054907C905090109014921C92E512410E0200
+86A3:1008104810487C485444548454A455227C205040104014481C84E5FE40820000
+86A4:00003FF012100920044003801C70E10E1FF0111011101FF0110001087FFC2004
+86A5:1010108810847C8455025602548854887C885050105014201E50E28841040202
+86A6:100010FC10847C84548455FE548454847C8451FE108414841E84E28440940088
+86A7:1020102010507C5054885504560254887C885088108814881C88E50841080208
+86A8:1020102010207C2055FC5420542054207DFE5020105014501E88E28841040202
+86A9:0100210821083FF80100FFFE000001003FF8210821083FF8010001087FFC2004
+86AA:1010111010907C9054105510549054907C10501E13F014101E10E21040100010
+86AB:1040104010FC7C84550456F4549454947CF45084109414881E82E282407E0000
+86AC:100011FC11047D0455245524552455247D245154105014901C90E5124212040E
+86AD:100011FC11047D04550455FC550055407D445148117015401D42E642423E0400
+86AE:1050105410527C925490559E55F056907C905090109014901E8AE28A40860082
+86AF:1004100E10F07C8054805480548054FE7C885088108814881C88E48843FE0000
+86B0:1020102010207C2055FC5524552455247D2451FC112415241D24E52441FC0104
+86B1:1080108010807CFE554055405640547C7C4050401040147E1E40E24040400040
+86B2:100011FC10207C20552454A454A854207FFE5020102014201E20E22040200020
+86B3:1004101E11F07D1055105510551055FE7D105110111015081D0AE54A41A60112
+86B4:201020902090F910A97EAA52AB92A892F912A11222522BD23862E822404A0084
+86B5:1000100013FE7C08540855E8552855287D28512811E815281C08E40840280010
+86B6:1088108810887C8855FE5488548854887C8850F8108814881E88E28840F80088
+86B7:100010FE10807C80548054FC548454847C84508410FC14801E80E28040FE0000
+86B8:1008101C11E07D005500550055FE55107D105130111815141D12E61042100410
+86B9:1044104410447C8454BE5584568454A47C945094108414841E84E28440940088
+86BA:1020102010207DFC5524552455FC55247D24512417FE15041D04E50441140108
+86BB:042004207FA00E20152224A2441E01001FF0111011101FF0110001087FFC2004
+86BC:1080108010807DFC5504560455E455247D245124112415E41D24E40440280010
+86BD:100011FE10107C1054205420546854A47D225222102014201C20E40043FE0000
+86BE:1010101010107DFE55125514551055FC7D445144112815281D10E62842440482
+86BF:1020101010107DFE54205420544454847DF85010102014441C82E5FE40820000
+86C0:1040102010007DFE54205420542054207DFC5020102014201C20E42043FE0000
+86C1:100011FC10447C4454445444549454887D0050FC108414841E84E28440FC0084
+86C2:1050104810487C4055FE54405440547C7CA450A410A815281D10E62840440082
+86C3:100011FE10207C20542055FE552255227D52514A118A15021D02E502410A0104
+86C4:1020102010207C2055FE5420542054207DFC5104110415041D04E50441FC0104
+86C5:1020102010207C20543E5420542054207DFC5104110415041D04E50441FC0104
+86C6:100010FC10847C84548454FC548454847C8450FC108414841C84E48443FE0000
+86C7:1020101010107DFE55025604548054887C9050A010C014821E82E282407E0000
+86C8:1020102011207D2055FC5520562054207DFE5020105014501E88E28841040202
+86C9:1020102010507C5054885524561254107DFC5004100814881E50E22040100010
+86CA:010001003FF8210821083FF8010001087FFC00043FF8244824482448FFFE0000
+86CB:7FFC0104110011F81100290047FE81001FF0111011101FF0110001087FFC2004
+86CC:1008101C11F07D5055505550555055507D505148114815681D54E67442520400
+86CD:2208111000207FFE4002810401003FF8210821083FF80120011001F87F042004
+86CE:100011FE11007D00550055FE552055207D3C5124112415241D24E64442540488
+86CF:100011FC10847C8854505420545054887F26502011FC14201C20E42043FE0000
+86D0:1050105010507C5055FC5554555455547D5451FC115415541D54E55441FC0104
+86D1:1020102010487C8455FE5412549054907CFE5110101017FE1C10E41040100010
+86D2:1040104010787C8855505420545054887D0650F8108814881E88E28840F80088
+86D3:082008287F240820FFFE002008247F24492449287F28481009120FAAF0464082
+86D4:1000100011FE7D025502557A554A554A7D4A514A117A15021D02E5FE41020000
+86D5:1020102011FE7C40544054FC548455847EFC5084108414FC1E84E28440940088
+86D6:1090108810807DFE54A054A854B054A47CA850B01124152A1D32E62242DE0400
+86D7:040008003FF020103FF020003FF820083FF801003FF821083FF801087FFC0004
+86D8:1104108410887C0057FE5420542055FC7C20502013FE14201E20E22040200020
+86D9:1020102011FC7C205420542057FE54007C20502011FC14201C20E42043FE0000
+86DA:2002200223E2F90AA90AA9EAA92AAA2AFB2AA2AA244A284A3882E902420A0404
+86DB:1020112011207DFC55205620542057FE7C7050A810A815241D24E62240200020
+86DC:2100217C2124FA24AA24AEFEAA24AA24FA24A27C22242A203A20EA2042400280
+86DD:100011F811087D0855F85508550855F87D445148113015201D10E54841860100
+86DE:1008103C11E07C20542057FE542054207C2051FC110415041D04E50441FC0104
+86DF:1040102010207DFE54005488550456027C885088105014501C20E45040880306
+86E0:2040204021FCF844A884A884A928AA10F908A3DE214A294A394AEA52435A04A4
+86E1:100013DE10427C425652554A554A54427CC6514A125214421C42E442414A0084
+86E2:1104108410887C0055FE5488548854887C8853FE108814881D08E50842080408
+86E3:1020102010207DFE5420542054FC54007C0050FC108414841E84E28440FC0084
+86E4:1020102010507C505488550456FA54007C0050F8108814881E88E28840F80088
+86E5:10201020107C7C8455485430542054487D90503E104215A41E18E21040600180
+86E6:1020102013FE7C2055FC542455FC55207DFE5022102A14541E50E28841040202
+86E7:100011FC11047D04550455AC555455547D54515411AC15041D04E50441140108
+86E8:100011FE10207C20544054FC548454847C8450FC108414841E84E28440FC0084
+86E9:00007DF01110119011521D12E20E45001FF0111011101FF0110001087FFC2004
+86EA:080008007F7C08243E2408447F54088809001FF0111011101FF001087FFC2004
+86EB:1040104010FC7D04560855FE5500557C7D445144115415481D42E542413E0200
+86EC:044004407FFC04400440FFFE082010102108DFF6111011101FF001087FFC2004
+86ED:100011FE10207C405488550455FE54227C20502011FE14201C20E42043FE0000
+86EE:02000100FFFE044014502448444401001FF0111011101FF0110001087FFC2004
+86EF:1040104010447DF45448545057FE54407C805184129814E01C82E482407E0000
+86F0:10801080FBF010901990F0941154520C25041FF0111011101FF001087FFC2004
+86F1:1020102010207DFC5420552454A454A87C2053FE105014501E88E28841040202
+86F2:2080208020BCFBC0A850A824A8D4AB0CF800A3FE209028903912E912420E0400
+86F3:208020BE2088FA88AABEAAAAAAAAAAAAFAAAA2AA22AA28AA392EE90842080408
+86F4:1040102013FE7C8854505420545054887D065088108814881C88E50841080208
+86F5:100011FE10007C9255245648552454927C0051FE102014201C20E42043FE0000
+86F6:1004101E11E07C2255125494548054087DFE5008108814481E48E20840280010
+86F7:1028102410247C2055FE5420552054B27CB4506810A815241E22E42040A00040
+86F8:1020112410A47CA8542055FC550455047DFC5104110415FC1D04E50441140108
+86F9:100011F810087CD0542055FC552455247DFC5124112415FC1D24E5244124010C
+86FA:1020102010207DFC542054A854A854A87D745222105014501E88E28841040202
+86FB:1010109010887D08560455FA550855087D0851F8109014901C90E5124212040E
+86FC:1020102011FE7C2055FC5524552455FC7D24512411FC14201DFEE42040200020
+86FD:100010FC10847C8454FC5484548454FC7C84508410FC14001E48E24440820102
+86FE:201020D82394F894A890ABFEA890A894F894A0D82398289038AAE8CA42860102
+86FF:1020102010507C885544562254F854087C10502011FC15041D04E50441FC0104
+8700:00003FF8244824483FF810001FFC22045FC4924412441FC4022403F47C142008
+8701:2100210021FEFA00AC00A9FEA822A824F920A13C212029203920EAA0447E0800
+8702:1040104010FC7C885550542054D857267CF8502010F814201FFEE42040200020
+8703:3FFC20002FF820003FFC24482430260E20802FF8288848884FF880841FFE0802
+8704:100011FE11007D00557C5500550055FE7D505152115415481D48E64442520460
+8705:1028102413FE7C20542055FC552455247DFC5124112415FC1D24E5244124010C
+8706:100011FC11047D0455FC5504550455FC7D04510411FC14501C50E4924112020E
+8707:080C08F07E8008800EFE788808882908120801003FF821083FF801087FFC0004
+8708:100011FC11047D0455FC5400540055FC7C20502013FE14201C50E48841040202
+8709:1008103C11C07C04554454A8540055F87C10502013FE14201E20E22040A00040
+870A:208421C42704F914A914A914AFD4A914FB14A39425542D043904E90441140108
+870B:1040102011FC7D04550455FC550455047DFC5120112215141D08E54441820100
+870C:1110111211147DD8551055125552558E7D20502011FC14201C20E42043FE0000
+870D:1020102010507C885504560254F854207C2053FE102015241D22E62240A00040
+870E:1000107C10447C44547C540054FE54827C8250FE108214821EFEE282408A0084
+870F:101C11E010207C2057FE54A8552456227DF85088109014BE1D02E50242140408
+8710:1088108810887DC8549E548A548A57EA7C8A508A110A154A1FEAE512402A0044
+8711:00187BE0104022787A400A402BFC10002FFE41003FF821083FF801087FFC0004
+8712:2004200E23B8F888A888A928A92EABA8F8A8A2A822A8293E3900EA80447E0800
+8713:2000200623B8F888A888A908A93EAB88F888A2882288293E3900EA80447E0800
+8714:1080108010FE7D02550256FA54AA54AA7CFA50AA10AA14FA1E8AE20240140008
+8715:1104108410887C1055FC5504550455047DFC5050105014901C92E512420E0400
+8716:100011FE114A7D4A554A557A554A554A7D4A517A114A154A1D4AE5FE41020000
+8717:200021FC2104F904A904A9FCA820A820FBFEA22222522A8A3B0AEA02420A0204
+8718:210021002100FBDEAA92AC92A892A892FBF2A09220922952395EEA2044200800
+8719:210421142114F914AFD2A922A92AAB48FB88A550251029143922E97E41220100
+871A:044004407C7C04403C7804407C7C044001001FF0111011101FF001087FFC2004
+871B:100011FC11047D0455FC5510551055FE7D105110117C15441D44E544417C0244
+871C:020001007FFE42028924284849940E1077F001003FF821083FF801087FFC0004
+871D:08207FFC08200FE008200FE00820FFFE10102108DFF611101FF001087FFC0004
+871E:1088108811FC7C88548854F8548854887CF85088108815FE1C00E48841040202
+871F:1020101011FE7C40548455FE540254FC7C8450FC108414FC1E84E28440940088
+8720:200023FE2202FA1AAAE2AA22AA22ABFEFA22A27222AA2B263A22EA2243FE0202
+8721:1048104810487DFE5448544855FE54007CFC5084108414FC1E84E28440FC0084
+8722:100011FC10087C10542057FE542054A07C4051FC115415541D54E55443FE0000
+8723:1088104810507DFC5420542055FC54207C2053FE105014501C90E4924112020E
+8724:080C08F07E8018802CFE2A884888888809081FF0111011101FF001087FFC2004
+8725:210021062138F920AFA0A920A93EAB24FBA4A564252429243924E92441240144
+8726:1020102010507C88550456FA540055FC7D54515411FC15541D54E5544104010C
+8727:2040202023FCFA04AA04ABFCAA00AA28FA24A3FE22202A503A50EC8845040A02
+8728:1020102013FE7C2055FC542457FE54247DFC50201120153E1D20E6A0427E0400
+8729:100011FC11247D245574552455FC55047D745154115415741D04E60442140408
+872A:1080108010FE7D02568254F2554254427FFA5042115215521DF2E40240140008
+872B:100011FC11047D0455FC5504550455FC7C00511211D415181D10E5524192010E
+872C:200021FC2008F810AA22AAAAAA72AA22FA72A2AA23262AA23A42EA0243FE0002
+872D:10401040107C7C8455085600542055CE7D02510211CE15021D02E50241FE0102
+872E:201420122010FBFEA810A810ABD2AA52FA52A25423D4280C386AEB8A41160022
+872F:1020102011FE7C2054FC544055FE54887D24522210F814201DFEE42040200020
+8730:00003EFC22A43EA422FC3E80228222824A7E85003FF821083FF801087FFC0004
+8731:1040108011FC7D24552455FC552455447DFC5090111017FE1C10E41040100010
+8732:101C11E010207C2057FE54A8552456427C4053FE108815081CD0E43040480184
+8733:1020101011FE7C0054FC548454FC54007CFC5008101015FE1E10E21040500020
+8734:100010FC10847C8454FC5484548454FC7C4050FE112A144A1C92E522404A0084
+8735:1050115411547D5455DC5504550455FC7D04510411DC15541D54E55442540404
+8736:1040102011FE7C0054885488555456227C00502013FE14201E20E22040200020
+8737:1020112410A87C2055FC544057FE54887D0452FA148814881CA8E4924082007E
+8738:00007EFC48447E4442287E1048287EC601001FF0111011101FF001087FFC2004
+8739:1088108813FE7C8854A8542055FC55247D245154114C15841D04E50441140108
+873A:20002040239CFA04AA04AB9CAA04AA04FBFCA090209028903890E9124212040E
+873B:1020102013FE7C2055FC542057FE54007DFC510411FC15041DFCE50441140108
+873C:10A0109010807DFE5510571055FC55107D1051FC111015101D10E5FE41000100
+873D:200023FE2020F820ABFEAA22AA22AB32FAAAA2AA23762A663A22EA22422A0204
+873E:100011FC11247D2455FC5524552455FC7C2053FE107014A81D24E62240200020
+873F:2040202023FEFA02AD04A900A9DEAA52FA52A352249A28943910E9124212040E
+8740:1020102013FE7C2055FC552455FC55247DFC5020107014A81D24E62240200020
+8741:00007FFC04403C7820083C780440FFFE01001FF0111011101FF001087FFC2004
+8742:2080228622B8FAA0ABE0AA3EAA2AAA2AFBAAA2AA22A42AA43AA4ECCA448A0892
+8743:100013DE10427D4A5484554A565254207C0053DE105215521C94E54842540422
+8744:200023FE2202FA8AAA52ABFEAA42AA22FBFEA28222822A823AFAEA02420A0204
+8745:3EF8082008207EFC08201450228841049FF2111011101FF0110001087FFC2004
+8746:10A810A813AE7CA854A8542055FC54207C20502013FE14201E20E22040200020
+8747:200021F02110F910A9F0A840ABF8AA48FA48A3F822482A483BFAE8424042003E
+8748:200023FE2202FA02ABFEAA22AA22AAFAFA22A232222A2BFE3A02EA0243FE0202
+8749:1104108810507DFC5524552455FC55247D2451FC102014201DFEE42040200020
+874A:2040202023FEFA02AC04A800ABFEA820F820A120213C29203AA0EA60443E0800
+874B:200024842244FA48A800ABF8AA48AA48FBF8A24822482BF83A4AEC4A44460802
+874C:20C427042124F914A914AF84A924A914FB94A346253C2D043904E90441040104
+874D:200023DE2252FA52AA52ABD2AA52AA52FA52A3D2221A2A943A50EAB043100010
+874E:100011FC11047DFC550455FC548055FE7E225122115215021DFAE40240140008
+874F:2040202023FEF800A9FCA904A9FCA800FBFEA20221FC28203820E82040A00040
+8750:100011FE11027D7A5502557A550254007CFC508410FC14841EFCE28440FC0084
+8751:100013FE10227D20553C552056FE54007DFC510411FC15041DFCE50441140108
+8752:100013FE10207C4055FC5554555455747D545154117415541D54E55441FC0104
+8753:204020A02110FA08ADF6A800ABC4AA54FA54A3D422542A543BD4EA44425402C8
+8754:1110111211D47D1855525592552E54407DFC5104110415FC1D04E50441FC0104
+8755:10201020282025FC5324FD2445247D2445FC7D2440205028482455FE64824000
+8756:1040102013FE7E02540455FC540055FC7D0451FC110415FC1D04E40043FE0000
+8757:2020204021FCF904A9FCA904A9FCA800FBFEA020202029FC3820E82043FE0000
+8758:100011FE11007D7C5544557C5544557C7D1051FE112415641D18E524414201FE
+8759:1020101011FE7D02550255FE550055007DFE51AA12AA14FE1CAAE4AA40AA0086
+875A:100010FC10487C3055FE5452549455107E30502011FE14701CA8E52442220020
+875B:200C200A2008FBFEAA08ABF8AA4AAA4AFBEAA2AC22AC2A4C3AAAEB0A42160422
+875C:1040104010F87D08561055FC550455FC7D0451FC110415FC1C00E48841040202
+875D:1040107C10847CF8540855FE544054A47D385058109415341C54E49241500020
+875E:100011FC11247D2455FC5500557C55447D44517C1144157C1D44E644427C0444
+875F:100011FE11227DFE552255FE540054FC7C8450FC108414FC1E84E28440940088
+8760:100011FE10007CFC5484548454FC54007DFE5122112215FE1D22E52241FE0102
+8761:100013FE10207C4055FC5554555455547D54512C102015FE1C50E48841040202
+8762:100013FE10207C4055FC5504550455FC7D0451FC110415041DFCE40040880104
+8763:210820882088FBDEA910A920A9DEA942F944A144215E29443A44EA4444D40808
+8764:1088104810507DFE5450545055FC55547D54518C110415FC1D04E50441FC0104
+8765:00207E20247E18A4FF2829104A2898C601001FF0111011101FF001087FFC2004
+8766:200023DE2242FA42AA42ABDEAA00AA3EFBD2A21222142BD43A08EA1442240242
+8767:1088108813FE7C8854A8542055FC55247D24512413FE14201E50E28841040202
+8768:00003FF0021002107FEA0206020208207EFC4AA44AA47EFC08200A24FEFE0202
+8769:1008103C11E07C2057FE542055FC55247DFC512411FC14201DFCE42043FE0000
+876A:100010FC10847CFC548454FC540055FE7C8050FE112A164A1C92E52240540088
+876B:1020102211FA7C24542857FE542054407CFC5184128414FC1E84E28440FC0084
+876C:200020882252FA22AA52AA8AAA02ABFEF888A144227A28883950E82040D80706
+876D:100011FC11047D0455FC5504550455FC7C0053FE102015201D3CE52042A0047E
+876E:1040104010FE7C8055FC568454FC54847CFC5040107C14C41D28E41040680186
+876F:101E13E010447D24548855FC544054407DFE508010FC15441D28E61040680186
+8770:1020102013FE7C505488572655FC54207C2053FE100014201DFCE420402003FE
+8771:02000100FFFE100010001FF8000008207EFC4AA44AA47EFC08200A24FEFE0202
+8772:2082208227F2F882A88AABEAAAAAAAAAFBEAA08A21CA2AAA3CA2E882408A0084
+8773:102011FE10207CFC542055FE540054FC7CA4509411FE14A41D14E5FE40040018
+8774:2100213C2124FBA4A924A93CA924ABA4FAA4A2BC22A42AA43BA4E84440540088
+8775:0620382008A47EA819202C504A88090401001FF0111011101FF001087FFC2004
+8776:204821482148FBFEA948A948A978A900F9FEA02023FE287038A8E92446220020
+8777:1020101011FE7D005544552855FE55107D5451541154157C1D14E52042400080
+8778:100010FC10847C8454F45494549455FE7D02517A114A154A1D7AE502410A0104
+8779:100010F810887C8854F85488548854F87C0051FC115415541D54E55443FE0000
+877A:2004201E23E0F820A9FCA924A924A9FCF820A3FE22222A2A3AFAEA02420A0204
+877B:2020202023FEF820A820ABFEAA8AAA52FAFAA22222222AFA3A22EA22422A0204
+877C:2020212420A8F820ABFEA8A8A924AA02F840A7FE208829083990E86041980604
+877D:1020102013FE7C2055FC544057FE54887D0452FA108814881CF8E488408800F8
+877E:2088208823FEF888A800ABFEAA02AC24F820A3FE207028A838A8E92442220020
+877F:100011FC11247DFC552455FC542055FC7D2451FC112415FC1C20E4224022001E
+8780:088049F82A90286008901FFE2A10C950092001003FF821083FF801087FFC0004
+8781:1000127C11447D44547C54445744557C7D50514A114415541D62E5424280047E
+8782:2100209E23D2FA52AA54ABD4AA58AA54FBD2A21222922A5A3AD4EB5042100010
+8783:2040202023FCF908A890ABFEAA02AC44F820A3FC208028F83888E90841280210
+8784:2100227E2388FA88AABEAAAAABAAAA2AFA2AA3AA22AA2AAE3A88EB8842880008
+8785:2020204021FCF904A9FCA904A9FCA904F9FCA040202028A43A8AEA8A44780000
+8786:208420442048FBFEA884A884A908A94AFA52A39C208429083908EA5243DE0042
+8787:101E13E011227C945440548855F054207CC451FE102214201FFEE45040880306
+8788:100011FE11107D20557C5544557C55447D7C5110111015541F52E29242500420
+8789:209020882104FA42AC88A9FCA804A800FBDEA0422252294A3A52E842414A0084
+878A:1088105010007DFE545055FC545457FE7C5451FC105014D81D54E65240500050
+878B:10A0112C11247D2455AC5524552455FC7C2051FC108814501E20E25040880306
+878C:10783E4822482A86FF7822482A2842104A2885463FF821083FF801087FFC0004
+878D:0020FE2000207CFC44A47CA400A4FEA482FCAAA49220FE28922492FE92428600
+878E:200023FE2000F9FCA904A904A9FCA800FBFEA28A22522BFE3A22EA22422A0204
+878F:2020201021FEF900A920AD20AB3CA950F990A31025FE29103928EA2842440482
+8790:2040208021FCF904A904A9FCA900A9FEF900A1FE20022AAA3AAAEC0240140008
+8791:1020104011FC7D0455FC550455FC55047DFC5028102415FE1C50E48841040202
+8792:102010201050FE8811267C2045FC7D2445247D2411FCFE201028103C13C41104
+8793:2040204027FCF840ABF8A880AFFCA910FA68A5C620402BF838E0E95846440040
+8794:2004201E23F0FA1EAA10AAFEAA92AA98FAF2A28E22802AB83AA8ECAA454A0A86
+8795:1020104011FC7D0455545524555455047DFC5000111215D41D18E5524192010E
+8796:100010FC10847CF4549455FE550254FC7C8450FC108414FC1E84E28440940088
+8797:1020101011FE7D10557C551455FE55147D7C5110117C15441D44E644427C0444
+8798:1020112411247D2455FC540057FE54007DFC5104110415FC1C88E45043FE0000
+8799:010001007FFC038005401930E10E08207EFC4AA44AA47EFC08200A24FEFE0202
+879A:20444258FF6201427E3E42007E4C42727E42423E01003FF821083FF801047FFE
+879B:2040202023FEFA02AC24A9FCA820A9FCF820A3FE202029FC3904E90441FC0104
+879C:08007F7808483E4800867F78414800303ECE01003FF821083FF801087FFC0004
+879D:2020204023FCFA24AA24ABFCAA24AA44FBFCA04020A828B4393CE9224222041E
+879E:200021FE2120F9FCA920A9FCA920A920F9FEA00222AA2AAA3AAAEA0240140008
+879F:200023FE2202F800A9FCA904A9FCA904F9FCA04020202BFE3800E88841040202
+87A0:210420842088F800ABFEA800A888A904FA02A1FC215429543954E95447FE0000
+87A1:020001007FFC082007C01830E00E08207EFC4AA44AA47EFC08200A24FEFE0202
+87A2:08202AA44D28145022887FFE410281041FF0111011101FF0010001087FFC0004
+87A3:00203D2424A8242025FC3C4027FE24A825243EFA24A824A824F8442455FC8804
+87A4:20201020FE2005FC6924112429FCD52411247DFC55247C5010501C88E5044202
+87A5:1020102010507C4854A455FE568454FC7C8450FC108014FC1D44E544427C0044
+87A6:1020102013FE7C2055FC542057FE54407C8851F0102417FE1C22E52442A20040
+87A7:1040104411F87C5057FE544054F855827E7E540011FC15041DFCE50441FC0104
+87A8:1048104811FE7C48540055FE544854487DFE514A114A15B61D22E502410A0104
+87A9:2110211E2122FA54AA08AE94AAE2AA88FA88A2BE22882AAC3A2AEA4A42280210
+87AA:2040202023FEF888A850ABFEAA52AA8AFB06A2FA228A2A8A3AFAEA02420A0204
+87AB:08207F20083EFF4414A85610A5284C4681001FF0111011101FF001087FFC2004
+87AC:2090209027FEF890ABFCAA94ABFCAA94FBFCA00021F8290839F8E90841F80108
+87AD:2040202023FEF800A954A924A954A9FCF820A3FE22422A923AFAEA0A42020206
+87AE:2154215423FEF954A954AA72AC00ABFEFA22A02021FC29243924E924412C0020
+87AF:08207F20087E7E4408A4FF2810101E282244468281003FF821083FF801047FFE
+87B0:2040202023FEFA50AA50ABFEAA52AA52FBFEA20022922AD43A98EC9244D2088E
+87B1:3F0821083F7E20082F4820285FA8440895282C9001003FF821083FF801047FFE
+87B2:2040202023FEFA8AA904ABFEA840A888F9FCA024202029FC3820E82043FE0000
+87B3:2020212420A8FBFEAA02A8F8A888A888F8F8A020202029FC3820E82043FE0000
+87B4:00207BFE482051FC612451FC492449FC687050A841243FFA21083FF801047FFE
+87B5:100013FE10507DFC5554555455FC54007DFC500013FE14201CA8E52442A20040
+87B6:00003FFC20003FF820083FF820003FFC10207EFC52A47EFC10201424FEFE0202
+87B7:00803FFE22002FF828882FF829082FF822203FFC20A02FF848884FF880843FFE
+87B8:14202220493E144222944110BE28222822443E8201003FF821083FF801047FFE
+87B9:20802080208EFBE8A888ABE8AAAEABEAFAAAA3EA208A2BEA388AE892409200A2
+87BA:100011FC11247DFC552455FC544054887DF05020104417FE1C22E52442220060
+87BB:202021FC2124FBFEA924A9FCA820A9FCF924A1FC20402BFE3888E9D04070038C
+87BC:1088108813FE7C8854F8542055FC55247DFC502013FE14201DFCE42043FE0000
+87BD:08001FF0282007C01830E18E0C40030010A07EFC52A47EFC10201424FEFE0202
+87BE:1040102013FE7E02540055FC542055FC7D2451FC112415FC1C00E48841040202
+87BF:0440247C24A83D5004287DFE24884448841801003FF821083FF801087FFC0004
+87C0:2040202023FEF820A848AAF2A924AA52F8F8A00820202BFE3820E82040200020
+87C1:3FF820083FF821003FFC20802C64301C10207EFC52A47EFC10201424FEFE0202
+87C2:104011FC11047DFC550455FC550055FE7D0051FE102215FA1C76E4A843260020
+87C3:200021F82108F9F8A908A9F8A800ABFCFA94A3FC200029F83890E86041980606
+87C4:08207E2008F8FF2814287F6A082AFF56088201003FF821083FF801087FFC0004
+87C5:1040102011FE7D005548554855FE55487D48114815781D00E6D442AA052A0800
+87C6:1088108813FE7C88540055FC550455FC7D0451FC102017FE1C50E48841040202
+87C7:04407FFC04401FF010101FF010101FF00400FFFE11103FF8D1161FF001087FFC
+87C8:200023FE221AFA16ABFEAA12AAEAAAAAFAAAA2EA220E2A6A3B9AEA2643FE0202
+87C9:200023DE2042FA52A94AAA52A828A8C4FB12A0602188283239C4E81840600380
+87CA:1FF0022001407FFC048418886280010010207EFC52A47EFC10201424FEFE0202
+87CB:201C21E02020F924A8A8ABFEA870A8A8F924A222204028243AA2EA8A44880078
+87CC:1020104011FC7D24557C558C555455247D5451FC102014101D54E542414A0238
+87CD:2062238A208AFFEAA88AA9CAAAA2AC8AF8A4A02023FE287038A8E92442220020
+87CE:2088208823FEF888A888A8F8A820ABFEFA22A33222AA2B763A22EA22422A0224
+87CF:2088208823FEF888A820ABFCA824AFFEF824A3FC20202AB43AACEB2C42240424
+87D0:2020212420A8FBFEAA02A8F8A888A888F8F8A02021FC29243924E93441280020
+87D1:102011FC10887C5057FE540055FC55047DFC510411FC14201FFEE42040200020
+87D2:2088208823FEF888A824ABFEA850A888F904A28A20882BFE3888E88841080208
+87D3:208020F82108FBFEAD12A922A9FEA840F8A2A35420982B343854E89243500020
+87D4:200021FC2124F9ACA974A924A9FCA820F9FCA02023FE28003AA4EA5244520000
+87D5:2090229422D8FA92AAD2AF0EA9F0AA10FFFCAA4423FC2A443BFCEC4444540808
+87D6:214021442158FBF0A950A9D0A95EA9D4F954A15423F428143954EA3444140024
+87D7:01007FFC11101FF00100FFFE91121FF041047FFC01003FF821083FF801047FFE
+87D8:10541092119E7EF0548A5486540254FC7C8450FC108414FC1E84E2FC40480084
+87D9:2110209423D2F812AA50A990AFFEA810FBD2A25222542BD43A4AEA4A43D60022
+87DA:08047F0808103E6400083E1022643E0814107F6001003FF821083FF801047FFE
+87DB:2082208227F4F888A880ABE2A802ABE4FA28A22023E02A223942E87447880210
+87DC:101811E010407FFE54885574565254707C0051FC110415741D54E5744104010C
+87DD:2200217E2040FC7CAA44A8FCA940AE7EFA20A02023FE287038A8E92442220020
+87DE:082049202A3E7F4849485DA86B10492841461FF0111011101FF001087FFC2004
+87DF:1020102011FC7C2055545488550456FA7C8850F8108814F81E20E2A841240060
+87E0:203C23E02124F8A8ABFEA8A8A924AA02F9FCA124212429FC3924E92441FC0104
+87E1:200E23F02044FA24A908ABF8AA08ABFCFA04A3FE22022AAA3AAAED0244140808
+87E2:102013FE10207DFC540055FC550455FC7C8853FE100015FC1D04E50441FC0104
+87E3:2124212422AAFBAEA924AAAAABAEA924FBFEA110211429143A8AEA4A42160422
+87E4:200023DE2252FBDEAA10AA52A9CEA800F888A3FE208828883BFEE88841040202
+87E5:1088108811FC7C88548857FE542055FC7D2451FC112415FC1C00E48841040202
+87E6:102011FC10207C8857FE548855FC55047DFC510411FC15041DFCE48841040202
+87E7:208822AA22DCFC88A954AA22A800ABFEFA42A44423FC28443844E88441140208
+87E8:3FFE289025103FDE22222A882F8822942422284027FC244427FC40444FFE8002
+87E9:20002FFE2800FA28A948ABEEA892A884FAA0AAA82BE828883894E91449241242
+87EA:2020202023FEF820A9FCA924A9FCA924F9FCA02223FE28423824EAA2428A0478
+87EB:200023FE2050FBFEAA52ABFEA800A9FCF904A1FC210429FC3820EBFE40200020
+87EC:200023DE2252FA52ABDEA800A9FCA924F9FCA12421FC28203BFEE82040200020
+87ED:1090108811FE7D10571055FE551055107DFE111015101DFEE50042A402520452
+87EE:1088105013FE7C2055FC542057FE55247CA853FE100015FC1D04E50441FC0104
+87EF:2020202021FCF820ABFEA908AB9CA908F988A63E20002BFE3890E8904112020E
+87F0:202021FC2024FBFEA824A9FCA820AAAAFBAEA22223FE2A223BAEEAAA42AA0422
+87F1:2080208021FEFB54AD54A954ABFEA954F954A15427FE28003954E92A422A0000
+87F2:010001003FF821083FF801087FFC000410207EFC52A47EFC10201424FEFE0202
+87F3:100011FC10047CFC540455FC540055DC7C9453DC100817FE1D08E48840A80010
+87F4:240CFF7024403C40247E3C482448FF482448428801003FF821083FF801047FFE
+87F5:200023FE2200FA04ABF4AA04AAEEAAA4FAA4A2EC22042AA43A44EA7445940008
+87F6:200027E0225EFBD2AA52ABD2AA72AFDEF840A3FE202029FC3820E82043FE0000
+87F7:2020212420A8FBFEAA02A8F8A888A888F8F8A00021FC292439FCE92441FC0104
+87F8:7FFC06003B0804B019C062A00C98728611207EFC52A47EFC10201424FEFE0202
+87F9:20003EFC4424BE542A983E502AFC3E102AFE2A1045103FF821083FF801047FFE
+87FA:101011FE10007DFE5502557A554A55FE7C0050FC108414FC1E84E2FC400001FE
+87FB:2104208823FEF820A9FCA820ABFEA854F992A09023FE289038D4EB8A409601A2
+87FC:2420FF20247E7EC482287A104A287AC605001FF0111011101FF001087FFC2004
+87FD:10101210117C7C1054FE5444572855FE7D10517C111015FE1D10E51042FE0400
+87FE:108010F811087FFE5544559255FE55007D7C5100117C15001D7CE544417C0244
+87FF:0878FFC808483E862B783E482A28FF9049287F4601003FF821083FF801047FFE
+8800:1220113E10427C9457105528544655FC7D0451FC110415FC1D04E5FC40880104
+8801:11002BDE4A5273D42A524BD27A1A12942350C24001003FF821083FF801047FFE
+8802:108813FE10887C00554857FE554855787D0051FC102017FE1C70E4A843260020
+8803:0100FFFE20003FF800003FF820083FF80000711C57D4755457DC715657D6B062
+8804:202020502088F924AEFAA850A924A954F9FCA02023FE2A423A92EAFA420A0206
+8805:100011FC11547D5455DC545055DC55547D5451DC115415541DDCE5504052003E
+8806:0820FFFE08201FF011101FF011107FFC41245FEC01003FF821083FF801047FFE
+8807:2088208823FEF888A9FCA924A9FCA924F9FCA02023FE2A223A2AEAFA420A0206
+8808:00107C1445FE7C9044947DD4448A7C8A291645223FF821083FF801087FFC0004
+8809:100011FC11547D5455FC540057FE54007DFC510411FC14621C94E58842A400C2
+880A:202023FE2288FA50ABFEAA50AAFCAA54FBFEA25422FC2A503AD8ED5446520850
+880B:100011FC11547D5455FC548055FC56447DF45154115415F41C44E5F440140008
+880C:100011FC11547DFC542055FC542057FE7C88505011FC14201FFEE42040200020
+880D:200823C82248FBCEAA4AABD2A904ABE4FCA4A2A423642A2A3BEAE82A414A0090
+880E:108813FE10887C2057FE5450548857267CF85020108815FE1C88E48841080208
+880F:210021DE224AFC8AABEAAAB6AAA4ABF4FABEA2A423E42ABE3AA4EAA442240464
+8810:2040202023FEF888A852AFACAAAAAAA8FDACA000210429FC3904E9FC41040204
+8811:208822AA22DCFC88A954AA22A800ABFEFA22A02023FE287038A8E92446220020
+8812:7FFC21087FFCB55A29283558210835582928355801003FF821083FF801047FFE
+8813:208823FE2088FBFEAA02A9FCA800ABFEF840A0A2235428B83B54E89243500020
+8814:202023FE2000F9FCA904A9FCA800ABFEFA02A1FC20402BA438D8EB3440D20330
+8815:200021FC2020FBFEAA22A9ACA820A9ACF800A3FE202029FC3954E9544154010C
+8816:108813FE10A87C9055FE572055FC55207DFC512011FE15001FFCE4884070038E
+8817:200023DE2042FA52A94AAA52A890A908FBFEA51021FE291039FEE91041FE0100
+8818:2110211423F2F910AFFEAA90AA50AFF4FA94A3F422942BE83A8AEBFA42260042
+8819:2040202023FEFA02A9FCA948AA50A9FCFB04A1FC210429FC3904E9FC40880104
+881A:08207FFC08200200FFFE08001FF02810C8100FF010207CF854A87CF81224FEFC
+881B:104811FE10487C0055FE554A554A55FE7C1451FE111015921D4CE54A41160222
+881C:22882108FABE2008729CA92A2288FFFE08203018C1063FF821083FF801047FFE
+881D:200021FC2124F9FCA924A9FCA904A800FBFEA2AA22AA2BFE3AAAEAAA43FE0222
+881E:20403F7E4890BF7C21443F4421443F5424483A4001003FF821083FF801047FFE
+881F:212422482124F800ABFCAA94AA64AA94FBFCA24823682A483B6AEA4A42460362
+8820:00007FFC02003FF8244827C8244827C824483FF810207CF854A87CF81224FEFC
+8821:0FE010201FC00040FFFE0C1073200DC072B00C8EF3207CF854A87CF81224FEFC
+8822:01007FFC01003FF80200FFFE08203FF8C8260FE010207CF854A87CF81224FEFC
+8823:100011FE11287DFE5528557C5554557C7D54117C15101DFEE59242BA028A0484
+8824:08200440FFFE04403FF82848303827C820083FF810207CF854A87CF81224FEFC
+8825:52107EFE28447E28A2FE3E1020103E7C22103E1001003FF821083FF801047FFE
+8826:2040207C2040FBFCAA44ABF0AA44AAFCFAA8A2F822A82AF83A00EDFC45540BFE
+8827:01007FFC01001FF000007FFE48029FF42810CFF010207CF854A87CF81224FEFC
+8828:208823FE20A8F9FCA824ABFEA824A9FCFAAAA3AE22222BFE3A22EBAE42AA04AA
+8829:22102110203AFB92A814ABBEA808AB90F83CA3E422A42ABC3AA4EBA442BC0024
+882A:08407F7C1440FF7C22043E7C22403E7C2242263E01003FF821083FF801047FFE
+882B:0704782425241E2464241A24652419046514020810207CF854A87CF81224FEFC
+882C:2110209023DEF810AA5EA982ABDEA810FBDEA25023DE2A503BDEEA50425202CE
+882D:210013F0151000E0775C11F0104013FC284047FE10207CF854A87CF81224FEFC
+882E:23EE228A22EAFB50ABEEAA4AAAA4ABEAF800A3DE20422A52394AEA52414A0084
+882F:00807FFE42004FF848884FF849084FF842807FFC44905F7C55545F7C4492BFFE
+8830:102013FE10007DDC555455DC548857FE7C8853FE108817FE1C94E58842A400C2
+8831:01001FF011101FF001087FFC10207CF854A87CF81224FEFC00003FF82448FFFE
+8832:440024FE28AA00AAFEFE004028FE452282FA00AAFEAAAAFAAA22AAFAAF0AF804
+8833:23DE225223DEFA52ABDEAA52ABDEA98CFA52A04027FE28883990E86040D80304
+8834:108813FE10887DFC555455FC542255FC7C2853FE104015FC1E84E4FC408400FC
+8835:222223FE2090F9FEAB10ADFEA910A9FEF910A1FE21002BFE3A8AEB7642520276
+8836:3E7C48907EFC142A66C63FF820083FF820083FF810207CF854A87CF81224FEFC
+8837:23DE225223DEFA52ABDEAA52ABDEA890F9FEA11023FE2D1039FEE91041FE0100
+8838:208823FE2088FBDEAA52ABDEA8A0A890F9FEA12023FC2D2039FCE92041FE0100
+8839:01007FFC11101FF00100FFFE88021FF068100FF010207CF854A87CF81224FEFC
+883A:7CF81020FDFC28504488BFF620103FF020103FF010207CF854A87CF81224FEFC
+883B:210447C88812F3BC20084B92F83E0380AAAAABAA01003FF821083FF801047FFE
+883C:23DE225223DEFA52ABDEA8A0A9FEAB20FDFCA12021FE280039FCE8884070078E
+883D:08282A244D2E087014243F246428BF12242A3F4610207CF854A87CF81224FEFC
+883E:23FE220223FEFA92AA54AA92AAFEAAAAFAFEA32222FA2AAA3AFAEA2245FA0004
+883F:249079E414547DFC0004FFFC249479E41454FFFC10207CF854A87CF81224FEFC
+8840:0100010002003FF82448244824482448244824482448244824482448FFFE0000
+8841:02000100FFFE1000100010001FF8010002003FF82448244824482448FFFE0000
+8842:08000800107E7F125512555255525552555255925512552257A2FC4200940108
+8843:0800080010FE7F10551055205530555855545592551255105790FC1000100010
+8844:080008FC10247F2455245524552455FC554455445544554457C4FC4401FE0000
+8845:0810081010947F545558551055FC55105510551055FE55105790FC1000100010
+8846:040008003FF824482448FFFE000000F87F0009041188635005201918E1060100
+8847:0804080E10707F405546555855545554555655545554555457D2FC9200980110
+8848:0800087E10247F24553C55245524553C552455245526557C5784FC0400040004
+8849:08200820103C7F4455A85510552855445582557C5544554457C4FC44007C0044
+884A:102410FE2024FE00AAFEAAAAAAAAAAFEAA14AAFEAA90AAD2AFACF8AA00960122
+884B:01003FF80108FFFE01083FF801007D7C11107D7C44447C7C45447FFC2448FFFE
+884C:080009FC100020004800080013FE302050209020102010201020102010A01040
+884D:10001200211C410080001400223E6288A0882108270821082108210821282010
+884E:1000100027DC410081001100213E6108AFE82108210821082108210821282110
+884F:100010002F9C400080001FC0253E6508A5082508254829882908300820282010
+8850:1000100027DC44008400178024BE6488A48827882408240827C8200820282010
+8851:11001100229C42408420190020BE6008AFC82048208825082208210821282010
+8852:12001100201C4FC08200140024BE6888AF0821082208220824882F8820A82010
+8853:11001180215C4140810017C0213E6308A3882348254825082908210821282110
+8854:12001200239C4200840017802A3E6208AF882208220822082288230822282010
+8855:20002FE0482E48208BA01820283E6BA4AAA42AA42AA42BA42824282428B42848
+8856:14801480249C44809FE0148024BE6488A4882FE8200824882448284830082018
+8857:1100110027DC4100810017C0203E6108A10827C82108210821C82E0824282010
+8858:1400140027EE4900910011002FDE6104A10425C42504250425C43E0428142008
+8859:10001FC0221C42008F80148024BE6FC8A0082008278824882488248827A82490
+885A:140014E024AE4EA084A014E024BE6EA4AAA42AE42AA42AA42EA4212421342268
+885B:120012002FCE44409FE010002FDE6844AFC421042FC4210429042FE421142108
+885C:144012802FEE4100820017C0245E6444A7C42444244427C42444244427D42448
+885D:108011C0271C410087C0110027FE6548A7C8254827C8210827C821082FE82010
+885E:110017C0224E4FE0800017C0245E67C4A0042FE421042FE42924292429742108
+885F:154015402A8E4540854010002FDE6104A7C4244427C4244427C4244427D42448
+8860:110011002FEE410087C0144027DE6444A7C4244427C424442FE4228424542828
+8861:120013C0244E488087C01540255E67C4A544254427C421042FE4210422942448
+8862:2EE02AA04EEE4AA08EE01AA02EFE6444AFF4348427E4248427E4248427F42408
+8863:020001000100FFFE0200020005000508089018A02840482088100A080C060800
+8864:200010000000FC00080010001000340058009400140010001000100010001000
+8865:1040084000407E400240046008501A482C444A440A4008400840084008400840
+8866:200011FC0020F8200820102014203BFE54209020102010201020102010201020
+8867:200011FC0020F8200820102014203BFE54209020102010201020102010A01040
+8868:010001007FFC010001003FF801000100FFFE0500088818502820C9180A060C00
+8869:200013FC0104F944092410A81088348858509450142010201050108811041602
+886A:202010200020F920092C1134116437A459249534152811221122110210FE1000
+886B:1004080400087E100220044408041A082C104A220A42080408080810082008C0
+886C:201010100010FC1009FE10101010341059109490149010101010101010501020
+886D:202010200020FC2009FC1020102034205BFE9420145010501088108811041202
+886E:02000100FFFE000008201210244848241FF0029004440C283410C50806060400
+886F:201010900090FC8809081104120435FA58889488148810881108110812281410
+8870:02000100FFFE00001FF01010FFFE10101FF0028004440C283410C50806060400
+8871:200013FC0084F88808881090109C348459449544152811281210122814441182
+8872:202010200020FDFE09221122112235225952954A158A110211021102110A1104
+8873:201010900090F8880888112415243A225440904010881084110413FE11021000
+8874:202010200020FDFE09221224102034205850945014501050109010921112120E
+8875:2000100001FCFD04090411041104350459FC9504150411041104110411FC1104
+8876:202010200020FC2009FC112411243524592495FC152410201020102010201020
+8877:02000100FFFE01003FF8210821083FF80100028004440C283410C50806060400
+8878:2040104000A0F8A0091012081406311055109910151011101110121012101410
+8879:2004101E01F0FD1009101110111035FE5910951015101108110A114A11861102
+887A:02000100FFFE00007FFC20403FFE02400D407080030804900C603518C6060400
+887B:200010FC0084FC84088411FE10843484588495FE148410841084108410941088
+887C:202010200020FBFE08201020102035FC58849488144810501020105011881606
+887D:2008103C01E0FC2008201020102035FE58209420142010201020102011FC1000
+887E:01000280044009203098CFE6004002800100FFFE05000C883450C530060E0400
+887F:202010200050FC500888114412223420580095FC140410081008101010101020
+8880:204010400080FCFC090412041084344458449414142410441184100410281010
+8881:010001003FF80100FFFE00001FF0101010101FF0050408883850CA200C180806
+8882:202010200020F9FC082410241424382455FE9020105010501088108811041202
+8883:200021FC2C44F04420842484291432080100FFFE05000C883450C530060E0400
+8884:2008103C01E0FC200820102011FE342058209450145010501088108811041202
+8885:04001FE0142012A010401FFC000402140108FFFE05000C883450C530060E0400
+8886:202010200020FDFE0820102010FC3420582095FE14221022102A102410201020
+8887:200010FC0084FC8408A410941094348459FE9484148410841084110411141208
+8888:080008007F7C094411441144257C42000100FFFE05000C883450C530060E0400
+8889:202010100010F9FE0902120410803488589094A014C0108210821082107E1000
+888A:202010200050F850088811241212301055FC9804140810881050102010101010
+888B:08A0109030BE57C0904010241014120C0100FFFE05000C883450C530060E0400
+888C:0100FFFE08001FF020105F9010D01FA010040FFC030004880C503530C60E0400
+888D:2080108001FCF9040A0415F411143514591495F4150411281112110210FE1000
+888E:202011200120F22012FC24A427246924B2242A2424A427A420C4204420942108
+888F:204010400040FC400BFE10401080348058FE9510151012101210141011FE1000
+8890:200010400020F8280808108814903A9456A292A214C210881188128814781000
+8891:200013FC0084F8840884110415143A08540091FC110411041104110411FC1104
+8892:2000100001FCFD040904110411FC35045904950415FC11041000100013FE1000
+8893:200011F80108FD08090811F811083508590895F8150811081108110817FE1000
+8894:2000100003FEF808080811E8112835285928952815E811281008100810281010
+8895:204010200020FBFE0A0214041000349058909490148811081108110412041402
+8896:202010200020FC2009FC112411243524592495FC152411241124112411FC1104
+8897:202010200050FC88090412121020344059889410142010441188101010601380
+8898:2080108000FEFD000A201120112C35745BA49524153411281122110210FE1000
+8899:202010200040FDFC090411041104350459FC9504150411041104110411FC1104
+889A:205010480048FC400BFE1080108034FC59449544152811281210122814441182
+889B:2004101E01F0FD1009101110111035FE5910951015101108110A114A11A61112
+889C:202010200020FDFE08201020102035FC587094A814A811241124122210201020
+889D:208810880088F908097E13081508314855289928150811081108110811281110
+889E:02000100FFFE0820101020085FF4101010101FF004440C283410C50806060400
+889F:202010200120F92009FC11201220302055FE9820145010501088108811041202
+88A0:02000100FFFE11001FF822007FFC048008603298C4440C283410C50806060400
+88A1:202010200020F9FC0924112415FC39245524912413FE11041104110411141108
+88A2:202010200124F8A408A8102015FC38205420902013FE10201020102010201020
+88A3:204811480148F948094813FE1148354859489548157811001100110011FE1000
+88A4:0100FFFE00001FF0022001407FFC048418886280030004880C503530C60E0400
+88A5:2000100003FEF82008201040144038FC55849284148410841084108410FC1084
+88A6:202010200124FD240924112411FC342058209524152411241124112411FC1004
+88A7:208010800100F9FC0A04140411E435245924952415E411241004100410281010
+88A8:204010200020FBFE08401040108835085BF0942014401088110413FC11041000
+88A9:202010200020FC20083E10201020342059FC9504150411041104110411FC1104
+88AA:202010200020F9FC0820102014203BFE5420904010401088110413FE11021000
+88AB:201010100010F9FE09121114151039FC55449144112811281110122812441482
+88AC:02000100FFFE080010103FF800081FF0101010101FF0048808503820CB180C06
+88AD:04400420FFFE0910116021844F0482FC0100FFFE05000C883450C530060E0400
+88AE:208010800080F9FE090012001420302055289924162412221422102010A01040
+88AF:204010480244FA400BFE1080148038FC55449144114812501220145018881306
+88B0:1FF012101110FFFE121021103FFC001002A00140FFFE04880C503420C5180606
+88B1:209010940092F9120910137E1510311055109928152811281128114411441182
+88B2:0100FFFE02000FE034C00700388003F81D3001C03F0004880C503530C60E0400
+88B3:20201020007CFC8409481030102034485990943E144211A41018101010601180
+88B4:2020102003FEFC500888110412FA34005BFE9440148011FC1004100410281010
+88B5:20801088009CF970091013101510311055FE99101510111011101110117C1100
+88B6:2080108000FCF9080A90106011983626582095FC1420122013FE102010201020
+88B7:202010200050F8880904120211FC3400580095FC150411041104110411FC1104
+88B8:204010400040FBFE08801080117835085B10951015FE11101110111011501120
+88B9:200013FE0020FC20084011FC11043504590495FC150411041104110411FC1104
+88BA:202010200020FBFE0820102011FC3400580095FC150411041104110411FC1104
+88BB:200013FE0020FC20084011FC1154355459549554155411541154114411141108
+88BC:2080108000F8F9080B1014A0104034A05918960615F811081108110811F81108
+88BD:410021002100011EF7D2125222526A52B2522C92229221122292225E24522800
+88BE:202011200120F9FC09201220102033FE547098A814A811241124122210201020
+88BF:2020102001FCF8200820102013FE30005420982015FC10201020102013FE1000
+88C0:200011FE0102F9220922112211FE352259229552154A118A1102110211FE1102
+88C1:084008487F4408440840FFFE10400844FF4410442928662AA212292A30462082
+88C2:00047F8408241F24212452240C243004C20C0100FFFE04880C503420C5180606
+88C3:20401040007CFC40084013FE100034005BFE9440145010481044104010401040
+88C4:20401040009CF9000A40104010BE35885A889488148810881088108810A81090
+88C5:082048202BFE082018202820C9FC0A000100FFFE05000C883450C530060E0400
+88C6:2020112400A4FCA408A8102013FC34045804940415FC10041004100413FC1004
+88C7:202010200040F88009FC11541154355459549554155411541154115413FE1000
+88C8:200013FE0202FC44084013FC108034A0592095FC1420102013FE102010201020
+88C9:200011F80108F90809F81108110835F859449548153011201110114811861100
+88CA:04001FF010101FF010101FF010001FFC10001FFC01043FEC04801C486530060E
+88CB:200013FC0000FC0009F811081108350859F89400150810881090100017FE1000
+88CC:202010200020FBFE0820102011243524592496AA142010501050108811041202
+88CD:200013FE0222FA220A2213FE16223A62567292AA132212221222120213FE1202
+88CE:200011FC0104F904090411FC1000340059FE9420142011FC1020102013FE1000
+88CF:0100FFFE00001FF011101FF011101FF001001FF001007FFC04880C503530C60E
+88D0:200010FC0084FC8408FC100011FE3502590295FE1502110211FE1102110A1104
+88D1:2040108001F8F90809F8110815FA390A550C93F8101810281048118816281010
+88D2:02000100FFFE0400387820083C7820083FF8028004440C283410C50806060400
+88D3:201010140012F8100BFE10101550395457F4915411541148124A125A14261042
+88D4:02000100FFFE048808503A20CC1808063FF82448282837D8244827C820282010
+88D5:200010500048FC840924102010503488590694F8148810881088108810F81088
+88D6:200011FE0100FD00097C1100110035FE59509552155411481148124412521460
+88D7:2040102003FCF8400890110813FC30045550995015501150125012521452180E
+88D8:012001107FFC111009A00540193062080100FFFE05000C883450C530060E0400
+88D9:200011FC0044F8440BFE1044104435FC5880948015FC12841484108410FC1084
+88DA:080C08F07E8008800EFE78880888290812080100FFFE04880C503420C5180606
+88DB:0100FFFE00001FF010101FF000003FF821083FF820021FFE04881850EB300C0E
+88DC:2028102403FEF820082011FC1124352459FC9524152411FC112411241124110C
+88DD:242024203C2005FCFC20242024F846000100FFFE05000C883450C530060E0400
+88DE:210410840088FC1009FC11041104350459FC94501450109010921112120E1400
+88DF:1020082040A824A409227228103010C007000100FFFE04880C503420C5180606
+88E0:3FF80208FFFE04083FF808001FF82808CFF80100FFFE04880C503420C5180606
+88E1:200011FC0124FD2409FC1124112435FC5820942015FC10201020102013FE1000
+88E2:201012100110F97E082010281748357E5908950815FE110811081288147E1000
+88E3:202010200050F8880904120211FC340058449424112410A81088101013FE1000
+88E4:2010100801FEFD10091011FE112035285948957E1508110811FE120812081408
+88E5:210010BE0282F202120222FA228A6A8AB2FA2A8A228A22FA22022202220A2204
+88E6:0100FFFE000019F8609040607BFC40A441287A60030004880C503530C60E0400
+88E7:202010A200A2F9240850108813043022542098A414A411281050108811041202
+88E8:2040108003FCFA240A2413FC16243A4457FC9090111017FE1010101010101010
+88E9:200011FC0104FD0409FC1104110435FC5800951215D41118111011521192110E
+88EA:2080108000FEFD020A8210F2114234425BFA94421552115211F2100210141008
+88EB:205012520252F25213DE220222026BFEB2022A0223DE22522252225224522802
+88EC:2020102001FCFC20082013FE108835445A4294F8158812501020105011881606
+88ED:20201020003EFC2009FE1122113835E05922951E150011781248124A148A1906
+88EE:20FC10840084FCFC0884108410FC340059FE9502150211FE1102110211FE1102
+88EF:200011FC0124FD240974112411FC350459749554155411741104120412141408
+88F0:200017BC0084F2941108229424A46840B0002FBC20A422A42128229024A82846
+88F1:2020102003FEF820082011FC102034205BFE944014A411A81290148810C61080
+88F2:200013FE0020F02013FE222222226B32B2AA2AAA2376226622222222222A2204
+88F3:0100111009207FFE40029FF410101FF00100FFFE05000C883450C530060E0400
+88F4:044004407C7C04403C7804407C7C06400100FFFE05000C883450C530060E0400
+88F5:02000100FFFE04407C7C04403C7804407C7C0440030804900C603518C6060400
+88F6:209010900090F79E1090209020906B9CB09028902090279E2090209020902090
+88F7:2020112400A8F82009FC104017FE3888550492FA1488108810A810921082107E
+88F8:200011FC0124F92409FC1124152439FC542093FE107010A81124122210201020
+88F9:0100FFFE00001FF011101FF011101FF00100FFFE131065880C503530C60E0400
+88FA:2020102003FEF85008881124122231FC552499FC152411FC10221022101E1000
+88FB:08000E7C08047F4408282A1049281A440100FFFE05000C883450C530060E0400
+88FC:200011F80108F90809F81108150839F8548091FC125414941124124410941108
+88FD:24043FA44424FFA404243F842494258802000100FFFE04880C503420C5180606
+88FE:200013FC0204F20413FC222022206BFEB2202A2022FC22842284248424FC2884
+88FF:2020102001FCFC500888110413FE340859E89528152811E81128100810281010
+8900:2088108803FEFC88088810F81088348858F89488148813FE1000108811041202
+8901:00001FF011101FF011101FF00100FFFE09201110630804900C603518C6060400
+8902:2110111007D0F110111021182FF46812B112291027D02110211021D02E102410
+8903:20201120013CFD20092013FE100035FC590495FC150411FC1104110411141108
+8904:2020102003FEF82009FC102413FE342459FC944017FE108411C8103010CC1302
+8905:2040102001FCF8000888105013FE3222542499FC152411241134112810201020
+8906:200011FC0104FD0409FC1104110435FC580097FE14201120113C112012A0147E
+8907:2100110001FEFA000DFC110411FC350459FC948014FC11081290106011981606
+8908:2008103C01E0F8200BFE102011FC352459FC952415FC102011FC102013FE1000
+8909:2100113C07D4F1141394211427D46924B14C284027FE204020A0211022082C06
+890A:2080104003FCF204120423FC22006A00B3FC2B54235425FC255425542944210C
+890B:204811480148FBFE094811481578390055FE902013FE107010A8112416221020
+890C:200013FE0222F8200BFE102011FC352459FC952415FC102013FE102010201020
+890D:202011240124FD2409FC100013FE3420584095FC15541154115411541154110C
+890E:02000100FFFE00180CE0302021FC3CA821243C20030804900C603518C6060400
+890F:0100FFFE00200C2031FC21243DFC212421243DFC030004880C503530C60E0400
+8910:200013F80208F3F8120823F821006BFCB4442A4422A4220423F4200420282010
+8911:201E13E00044FD24088811FC104034405BFE948014FC11441128121010681186
+8912:0100FFFE08000BF8120833F8504097FE11501248030004880C503530C60E0400
+8913:2100117C0144F2441244267C2A106A10B2FE2A38225422542294231222102210
+8914:200013FE0000F9FC0904110415FC380057FE9222122213FE1222122213FE1202
+8915:204010A00110F20815F6200023C46A54B2542BD42254225423D42244225422C8
+8916:208010FC0104FDF8080813FE104034A25B349458149413341052109013501020
+8917:200013FE0200FAFC0A8412FC16843AFC562093FE124812C812301248128413FE
+8918:2040104001FCF8840BFE100015FC390455FC902013FE1020122013FE10201020
+8919:2050105203DCF85008D2134E100035FC590495FC150411FC1104110411141108
+891A:2020102201FAF824082813FE1420384054FC9184128410FC1084108410FC1084
+891B:2020112400A8F02013FE20A821246A02B0402BFE208821082190206021982604
+891C:008079F84A087DE8492879E8491449049AFC0100FFFE04880C503420C5180606
+891D:224211240000FDFC0924112411FC3524592495FC1420102013FE102010201020
+891E:200011F80108F90809F81108150839F8540093FC129412941294129417FE1000
+891F:200011FC0104F9FC090411FC14003BDE54429252114A10C6135A1042114A1084
+8920:2088108803FEFC8809FC108813FE342059FC952415FC112413FE110411141108
+8921:2088108803FEF888082010501488390456FA9000100011FC1104110411FC1104
+8922:0100FFFE02001FF011101FF012101FF004A808BA3382C4FE0C503530C60E0400
+8923:2040102003FEFA0208501088152438505488910412FA10881088108810F81088
+8924:2020102001FCF8200BFE100011FC3504590495FC14521094118816A410C21080
+8925:200013FE0200F2FC120023FE22A86A90B2C82A86220823FE2288244824082818
+8926:211012120454F7D81010201227D26C4EB4402FD22454245827D024522552248E
+8927:7E1024523C5424903C282744FC8206000100FFFE05000C883450C530060E0400
+8928:210810880090FBFC084011F814403BFE5480910011FC12201420182013FE1000
+8929:10003E7822482A48FE8623782A4842304A4886840100FFFE06801C48E530060E
+892A:2000127C0144F944087C10441744357C5950954A15441154116211421280147E
+892B:2004101E03F0F21E121022FE22926A98B2F22A8E228022B822A824AA254A2A86
+892C:21F810880070F18C100023DE2252698CB252282023FE207020A8212426222020
+892D:0100FFFE00003FFC21003FF821003FFE29224496030004880C503530C60E0400
+892E:08202AA44D28145022887FFE400282040100FFFE05000C883450C530060E0400
+892F:2040102007FEF488148827FE24886CF8B4202DFC252425242934292830202020
+8930:01007FFE44429FF404403FF80440FFFE0A2011102FE8C28E04501C2065180606
+8931:02000100FFFE00003FF824483FF8111009201110230804900C603518C6060400
+8932:2020101001FEFD10097C1110117C3554597C9554157C111011FE121012101410
+8933:2010101002FEF910097C1054147C3B54557C911011FE111011101290147E1000
+8934:20481148014EF9500968114411443440580095FC155411541154115417FE1000
+8935:2040102003FEF80009541124155439FC542093FE1242129212FA120A12021206
+8936:200013DE0042FA52094A12521042342059FC9504150411FC1104110411FC1104
+8937:221012100450F95C1150225026FE6A00B2102A50225C225022B02290230E2200
+8938:202011FC0124FBFE092411FC142039FC552491FC104013FE108811D01070138C
+8939:2110111007D0F110113C27D420146AB4B554291C27D42114211421E427262242
+893A:08207E2008F8FF2814287F6A082AFF560A820100FFFE04880C503420C5180606
+893B:0100FFFE08203E2008F87F282A685D2A08563E82030004880C503530C60E0400
+893C:400023FE205003FEF25213FE20206FFEB088290423FA250821F82102210220FE
+893D:3F0821083F7E20082F4820285FA8440895282E900100FFFE06801C48E530060E
+893E:200013FE0050FDFC0954115411FC340059FC940017FE102010A8112412A21040
+893F:2090109007FEF8900BFC129413FC36945BFC940015F8110811F8110811F81108
+8940:202013FE0020FDFC082013FE100035FC590495FC150411FC110411FC10881104
+8941:200013BE00A2F0A210BE238822086A3EB22A2BAA20AA20BE2088208A257E2202
+8942:2040108801FCF9080A5213FE14503988562690C0131010641388103010C01700
+8943:0100FFFE00000CF8308820F83C2021FC20A83D24030004880C503530C60E0400
+8944:0100FFFE00003EF822883EF804407FFC04403FF80440FFFE04441C28E5180606
+8945:200011FC0124FDFC092411FC10A834A85BFE94A814A811FC102013FE10201020
+8946:205012520154F8500BFE108814503BFE542091FC102013FE1050108811041602
+8947:200013DE0252FBDE0A5213DE16023AFA568A92FA128A12FA128A1202120A1204
+8948:200013DE0252FBDE0A10125211CE3400588897FE1488108817FE108811041202
+8949:279E1492079EF492179E240224F26C92B4F22C9224F224922492253224022406
+894A:200013F80208F3F8120823F820006FFEB4802FBC2494279424D42F88209420A2
+894B:420822080FBEE20822082FBE4AAA5AAAEAAA5BAE4208471C4AAA524842084208
+894C:200013DE0252FA520BDE100011FC352459FC952415FC102013FE102010201020
+894D:20A0109001FEFB2009FC112011FC352059FE9500142013FE107010A813261020
+894E:203C13E00124F8A80BFE10A81124360259FC9524152411FC1124112411FC1104
+894F:202413A80092F5141208240423BA68A8B0C62B80223C238420A8209022A82144
+8950:208010F80108FBFE0D12112215FE384054A29354109813341054109213501020
+8951:200011FC0004FCFC080411FC100035DC589497DC140813FE1108108810A81010
+8952:210811080548F390111E27D425646D54B5542F5425D4254825482554246424C2
+8953:2020102001FCF8200BFE1108139C35085988963E140013FE109010901112120E
+8954:2088108803FEF888088810F814203BFE5622933212AA137612221222122A1224
+8955:210010BE0282F22212FA222222FA6AAAB2BA2AEA22AA22FA227222AA22222226
+8956:2080110007FCF4441554244427FC6CE4B5542C0420402FFE20A0211022082C06
+8957:200011FC0154F9FC082011FC14203BFE5488905011FC102013FE102010201020
+8958:202010500088FD740A0211FC112435AC592495FC140010F8108810F8108810F8
+8959:20F810880088FCF8080011DC1154355459DC942015FE107010A8112412221020
+895A:204412240128FC7E08101028134A351C5928954C151A112A1148111012FE1400
+895B:209013FC0294FBFC0A9413FC14003BFC560092F8120013FE1520151415481986
+895C:208010F80108FBFE0944119211FE3500597C9500157C1100117C1244127C1444
+895D:202010200050FC88090412FA1000340059DC9554155411DC1088108811541222
+895E:00407C2045FC44887C5043FE7C20A5FC24203E200100FFFE06801C48E530060E
+895F:2110111007BCF11013B8255429126800B3F8280027FC20402248244429422080
+8960:2020112400A8FBFE0A0210F81088348858F8940015FC112411FC112411FC1104
+8961:200013F802A8F2A813F8210023FC6C84B3E42AA422A423E4209427F420142008
+8962:202013FE0000FBFC0A0412F4129437FC580095F8150811F8110811F8100013FE
+8963:204010F80088FCF8088810F8100035FC592495FC152411FC100013FE10881108
+8964:200813E80288FBEE0A2813F416823BE2540091FC115411541154115417FE1000
+8965:212811AA016CF22812FE264426286AFEB2102A7C221022FE2210222822442282
+8966:200011FC0020FBFE0A2211AC142039AC540093FE102011FC115411541154110C
+8967:200017FC0248F4441FFE244426EC6D54B6EC2C4426EC255426EC244424542408
+8968:214411440554F364115E27E420046A34B14C2BE4208423E4208420E427142008
+8969:202013FE0020FDFC080013FE125237FE590495FC150411FC110411FC10881104
+896A:210817FE0108F00013FC229422946BFCB0282BFE2220232422A82292242A28C6
+896B:2020102007FEF02013AE212423AE6AAAB3AE2AAA23AE20502050208821042602
+896C:200013FC0294F29413FC211022526BDCB0122BCE224023D2225C23D0225222CE
+896D:2100113E0108F7D0113E212223A2683EB0222BBE22A222A222BE238022942022
+896E:21FC110401FCFD0409FC108811FC34885BFE9488152412AA107010A811241060
+896F:4200213C27A40024F4BC132427A4693CB1242FA4213C259025582968252A2246
+8970:2108110807CEF112112427DE25526D5EB7D2291E2392255E2940211421122122
+8971:2210111007DEF010145E228227DE6810B7DE2C5027DE245027DE2450245224CE
+8972:08407F7C1440FF7C22043E7C22403E7C2242263E0100FFFE06801C48E530060E
+8973:4148214C22AA0008F7FE11482368694AB36A294C236C2148216A239A20262042
+8974:27BC14A407BCF4A417BC244425F46C44B5F42D5425F4255425F424E42554244C
+8975:23FC110801F8F10811F8210E27F86808B7FE2A94239C2294239C22D627BC2084
+8976:411427D221100FFEF01017D025526FD2B5522FD4229427C8228A2FFA22A62442
+8977:2140126C0244F36C12A423AC22A46FFEB1082AF4244223F8204027FC204020C0
+8978:252817BE0948F7BE131825AA29466BFCB2042BFC220423FC220423FC21082204
+8979:27BE100007BCF4A416B424A420406FFEB4A02FFC24A427FC251229DC291231CE
+897A:211017FE0110F00017FE254A254A6EFEB7EA2D6A267E27CA244E257225422406
+897B:22A8124807BEF2A8175C2AAA22886FFEB2182DE4284223F8204027FC204020C0
+897C:210817FE0108F390113C27D422B46D5CB396292223FC200027FE2080210423FE
+897D:211017FE0110F7BC14A427BC24A46FBCB4442FFC255425F4244424E425542448
+897E:0000FFFE0440044004407FFC444444444444444447C444444004400440044004
+897F:0000FFFE0440044004403FF8244824482448244828383008200820083FF82008
+8980:00007FFC044004403FF8244824483FF800000000000000000000000000000000
+8981:00007FFC044004403FF8244824483FF802007FFC042008401C80038006703808
+8982:FFFE04403FF824483FF8000001F03E0001007FF80060018006001800E7FE0000
+8983:FFFE04403FF824483FF800001FF010101FF010101FF00100FFFE010001000100
+8984:00007FFC04403FF8244824483FF80850104837FE504090A010A0111012081406
+8985:0040FE402840287EFEAAAB2AAA2AFE4A104AFE9225124422282210422894C408
+8986:FFFE04403FF824483FF8120027FC42088BF8120833F8510093F8151010E0171E
+8987:FFFE04403FF824483FF822007F7C22443E44087C7F4449447F7C0844FF540888
+8988:FFFE04403FF824483FF810207E20523E4A447EA41028FF2820103E2842448682
+8989:FFFE04403FF824483FF828207DFC2850388813FE7C0855E87D2811E8FE081018
+898A:FFFE04403FF824483FF82800FDFE292039FC11207DFC55207DFE1002FEAA1004
+898B:00001FF0101010101FF0101010101FF0101010101FF00440044008423042C03E
+898C:000001F8FD08050805F84908290811F81108290825F844908090011202120C0E
+898D:010009201110210841041FF010101FF010101FF010101FF0044008421042603E
+898E:00007E7C420442087E10421042FE7E10421042107E1024502422240243FE8000
+898F:100010FC10847C8410FC10841084FEFC1084108410FC2850245044928092010E
+8990:00007E88425042207E50428842007E88425042207E5024882402240243FE8000
+8991:080048FC4884488448FC7E84408440FC40847C8444FC4450445044924492850E
+8992:04000EFC7084108410FC1C84708410FC10841E84F0FC1050145018921092010E
+8993:000801FC7E102210112000001FF010101FF010101FF010101FF004421842E03E
+8994:00007FFC010003600D1871041FF010101FF010101FF010101FF004421842E03E
+8995:1000087C0A440244127C134454C454FC54449844197C112831284F4A804A0086
+8996:200011FC1104F90409FC1104110439FC5504950411FC1050109010921112120E
+8997:00007F7C014401447D7C014401447D7C454445447D7C45280128014A0A4A0486
+8998:100010FC10841E8410FC1084108410FC7E84428442FC425042507E924292010E
+8999:200020FC20847E8442FC4484908410FC5484548452FC5250925010925092210E
+899A:2208111000207FFE40029FF410101FF010101FF010101FF0044008421042603E
+899B:0200077C38442044237C2C44284428FC2D442A442A7C29282928494A4C4A8886
+899C:280028FC28842884AAFC6C84288428FC6C84AA8428FC28502A504C924892810E
+899D:00007CFC10841084FEFC1084108400FC1084528452FC9450285024924492810E
+899E:00007CFC448444847CFC448444847CFC448444847CFC28502A502C924892810E
+899F:0800087C0844FF44087C084408447E7C104408442A7CA128A128A54A1C4A0086
+89A0:00007E7C12441244FF7C124412447E7C204420447E7C6228A228224A3E4A2286
+89A1:0000007C7F440844087C2A442A442A7C5D444944887C08280F28F04A404A0086
+89A2:100052FC5484908428FC4484828410FC1084528454FC9050285024924292810E
+89A3:0C0070FC1084FE8438FC5484928400FC1084FC8424FC4450285010922892C50E
+89A4:10001EFC10847E8452FC5C84708452FC4E8440845CFC5450545096929492210E
+89A5:1400147C14447F44557C554455447F7C55445544557CFFA82428224A424A8086
+89A6:1000287C444482447D7C0044F144957C9544F544957C9528F528914A954AB286
+89A7:3F2024203F3E21403F5024883FF810101FF010101FF010101FF004421842E03E
+89A8:0000777C55445544777C00447F44007CFFC420443F7C01280128014A0A4A0486
+89A9:1000107C7D441244147CFF441044207C7E44A244227C3E282228224A3E4A2286
+89AA:1000087C7F440044227C1444FF44087C08447F44087C2A28492888CA284A1086
+89AB:1000087C7F440044227C14447F44517C08447F44107C1E281228224A2A4A4486
+89AC:0800497C49447F44007CFF4400447F7C414441447F7C422824280F4AF04A4086
+89AD:0000FF7C814400447E7C42447E44427C7E441044087CFF280028244A424A8186
+89AE:08202AA44D28145022887FFE40029FF410101FF010101FF010101FF00842F03E
+89AF:2200227CFFC422447F7C2244FFC4087C7F4449447F7C4928FFE8414A454A4286
+89B0:10001E7C10447F44517C5C4472444E7C40445E44527C5E2852285E4A524ABF86
+89B1:08047F7808403E402A7E3E482A48FF4808881FF010101FF010101FF00442783E
+89B2:2200227CFFC422443E7C08447F44497C7F4408447F7C08287F28084A0F4AF086
+89B3:2000207C3F444844887C7F441444227C7F44A4443F7C24283F28244A3F4A2086
+89B4:0A00747C15445244227C21445D44807C7E444244427C7E284228244A0F4AF086
+89B5:E700A57CE744A544E77C8144BD44A57CBD44A544BD7CA528A528CD4A814A8386
+89B6:0F00F07C49442244FE7C14440844FF7C9544BD44837CBD289528894A954AA386
+89B7:10001E7C10447F44517C5C4472444E7C40444A446AFC5B284A288F4A784A0086
+89B8:0000777C55447744557C774441445D7C55445D44557C5D285528414A454A4286
+89B9:0144F9548B548DF8F80E89128AEAFE0A8A0A8AEAFAAA52A452B456AA5B0A9210
+89BA:3AB821083AB82288393822887FFE50129FF410101FF010101FF004421842E03E
+89BB:08000F7C08447F44497C4C447944477C40445F44407C5F2851285F4A8A4A3F86
+89BC:0000FF7C52449144FFFC9144DB44B57CDB449144DB7CB528DB28914A954A8286
+89BD:7E40487E7E9043087EFE48AA7FFE10101FF010101FF010101FF004421842E03E
+89BE:1000087C7F444144867C784449442A7CFF442A44417CBE282A283E4A2A4A3E86
+89BF:1000FEFC10847C8400FCFE84AA84FEFC44847C8444FC7C5044507C922892450E
+89C0:2200227CFFC42244777C55447744127C3F446444BF7C24283F28244A3F4A2086
+89C1:00001FF01010101011101110111011101110129012900480048008823082C07E
+89C2:000001FC0104FD0405240524492429241124115428502490449081120212040E
+89C3:00003E7C220422082A102A102AFE2A102A102A10081014501422240243FE8000
+89C4:100011FC11047D04112411241124FF241124115410502890249045128212040E
+89C5:01F87E0012100910092000001FF010101110111011101290028004821882607E
+89C6:200011FC1104F90409241124112439245524955410501090109011121212140E
+89C7:100011FC11041F0411241124112411247D2445544450449044907D124612040E
+89C8:04402440247C2490250804001FF010101110111011101290028004841884607C
+89C9:2208111000207FFE400280041FF010101110111011101290028004841884607C
+89CA:0800497C494449447F5400547F54015401543F542010202823282C4A308A0106
+89CB:0000007C7F44084408542A542A542A545D544954881008280F28F04A408A0106
+89CC:0800087C7E4408440854FF5401542A54185448542810FF281428224A414A8186
+89CD:1400147C14447F445554555455547F54555455545510FFA82428224A428A8106
+89CE:1000287C444482447D540054F15495549554F55495109528F528914A954AB286
+89CF:2400247CFF4424447E542454FF5408547E544A547E104A28FF28424A4A4A4486
+89D0:2200227CFFC422443E5408547F5449547F5408547F1008287F28084A0F4AF086
+89D1:10001E7C10447F4451545C5472544E5440544A546A905B284A288F4A784A0086
+89D2:080008001FE020204040BFF8210821083FF8210821083FF82108410841288010
+89D3:100410041F2421244224BFA424A424A43FA424AC24B43FA42484448442848104
+89D4:101010101F102110427EBF92249224923F92249224923F92249244A242AA8144
+89D5:1080108050F851087E1055FC912411241DFCF124512411FC1124122412141408
+89D6:20202020782049FC90247C24542454247DFE542054507C505488548845048E02
+89D7:1004101E3CF024904890BE902A902AFE3E902A902A903E882A8A4AAA42C68682
+89D8:101010103C1024104854BE522A522A903E102A142A043E082A084A10422086C0
+89D9:100010FC3C4424484848BE502A5C2A443E442A442A683EA82A904A9843248642
+89DA:2008201C79F0495091507D50555055507D50554855487D685554567446528C00
+89DB:100010003CFC24844884BE842AFC2A843E842A842AFC3E842A004A0043FE8600
+89DC:088028882EF028842E84F07C08000FC010803FF851081FF811081FF811082118
+89DD:1004101E3CF024904890BE902A902AFE3E902A902A903E882A8A4AAA42D6868A
+89DE:104010403C7E2480497CBE082A102A203EFE2A4A2A4A3E922B124A2242548688
+89DF:101010103C7C24104810BE102AFE2A003E102A102A7C3E102A104A1042FE8600
+89E0:111009207FFC0200FFFE08203818CFC610803FF851081FF811081FF811082118
+89E1:104010403C7824884950BE202A502A883F062AF82A883E882A884A8842F88688
+89E2:08007F7C08243E2408447F5408880FC010803FF851081FF811081FF811082118
+89E3:100010FC3C2424244854BE882A102A503E7C2A902A103EFE2A104A1042108610
+89E4:2040204078FC490492087DFE5500557C7D44554455547D4855425542453E8E00
+89E5:20202020792448A490A87C2055FE54907C90549054907C9255125512460E8C00
+89E6:20202020782049FC91247D24552455247DFC552454207C28542457FE45028C00
+89E7:108810483C50240049FCBE202A202AFC3E202A202BFE3E202A204A2042208620
+89E8:200021FC7820482093FE7C00542054227FB254B454A87D285524562444A28C40
+89E9:202820247824482093FE7C20552054B27CB4546854A87D245622542044A08C40
+89EA:104010203CFC24004888BE502BFE2A203E202A202AFC3E202A204A2042208620
+89EB:2020202079FE482090207DFC552455247DFC542054707CA85524562244208C20
+89EC:20002040799C490491047DDC550455047DFC545054507C505490549245128E0E
+89ED:2020202079FC485090887D0457FE54087DE8552855287DE85528540844288C10
+89EE:100010FC3C042404487CBE042A042AFE3E102A922A543E382A544A9242508620
+89EF:21042088785049FC91247D2455FC55247D2455FC54207C2057FE542044208C20
+89F0:102010203CFA24244828BFFE2A202A403EFC2B442A443E7C2A444A44427C8644
+89F1:00283FFE20202FA420282F9048AA4FC690823FF851081FF811081FF811082118
+89F2:208820507BFE482091FC7C2057FE54007CA054FC55207C2057FE542044208C20
+89F3:0800FFB808287F280028FFC6A0803E7C4224FF2449287F2849107F2849448B82
+89F4:1040107E3C80257C4844BE7C2A442A7C3E002AFE2A403EFE2B2A4A4A42928626
+89F5:2048204879FC484890487DFE542055FC7D2455FC55247DFC5400544844848D02
+89F6:200021DC7954495491DC7C0055FC55247DFC552455FC7C2057FE542044208C20
+89F7:0A803138228839382288FFFE88020FC010803FF851081FF811081FF811082118
+89F8:200021FC7954495491FC7C8055FC56447DF4555455547DF4544455F444148C08
+89F9:105010483CFE259048FCBE902AFC2A903EFE2A002AEE3EAA2AAA4ABA42828686
+89FA:48F8705044203DFC20247CB890A07D7E2A004FF010202FF848880FF808881098
+89FB:212421747A584ADA93FE7D5456DA57FE7CA2542057FE7C7054A8552446228C20
+89FC:208020F879084BFE91227D5254FC54847CFC548454FC7C4054FC554444388CEE
+89FD:2010211279FE484890FE7D9056FE54907CFE549054FE7C8055DE555245728D06
+89FE:208820887BFE488890F87D04557457567D54555457747D0654005554452A8E2A
+89FF:222223FE789049FE93107DFE551055FE7D1055FE54007DFE554A55F645528D76
+8A00:02000100FFFE000000003FF8000000003FF8000000003FF8200820083FF82008
+8A01:200010001000FE0000007C0000007C0000007C004400440044007C0044000000
+8A02:2000100011FEFE2000207C2000207C2000207C204420442044207C2044A00040
+8A03:204010401040FE4000407C5000487C4400447C404440444044407C4044400040
+8A04:2040202023FC2000FDF8240025F8240025F82508250825FA250A440243FE8000
+8A05:204010401040FE4001F87C4800487C4800487C484448444A448A7C8A45060200
+8A06:200410041084FE8400847C8400847C84008C7C9444E4448444047C0444040004
+8A07:100010001FFC20044204BFE400041FC400041FC400041FC410441FC410540008
+8A08:202010201020FE2000207C2003FE7C2000207C204420442044207C2044200020
+8A09:200011F00110FD100110791001907950015079104910491249127A124A0E0400
+8A0A:200013F00090FC900090789000907BF00090789048904892488A788A48860082
+8A0B:204010401040FEFC00847D0400047D0400847C444444440444047C0444280010
+8A0C:2000100010FCFE2000207C2000207C2000207C204420442044207C2045FE0000
+8A0D:200011F81088FEC800A87CA800887C5000507C504420442044507C8845040202
+8A0E:201010101010FE1001FE7C1000107C1001107C904490441044107C1044500020
+8A0F:200010FC1020FE2000207C2000207DFE00207C204420442044207C2044A00040
+8A10:200010FC1020FE2000207C2000207DFE00207C204420442044207C2044200020
+8A11:202010201020FEA000AC7CB400E47DA400A47CB444A844A244A27C82447E0000
+8A12:2000100010FCFE2400247CA400A47CA400A47D244424444444447C8445280210
+8A13:210411240124FD240124792401247924012479244924492449247A244A040404
+8A14:0100210821083FF802000100FFFE00003FF800003FF800003FF820083FF82008
+8A15:202010201020FE2001247D2401247D2401247D244524452445247DFC44040000
+8A16:204010401080FEFE01007E0000FC7C0800107C204440448045027D0244FE0000
+8A17:2008103C11E0FE2000207C2000207C3E01E07C204420442244227C22441E0000
+8A18:2000100010FCFE0400047C0400047CFC00847C804480448044827C82447E0000
+8A19:204010401040FDF800487C4800487D4800C87C4844A844A8448A7D0A45060202
+8A1A:200017FC020441045FF440044FE440044FE440044FE4482448244FE44824400C
+8A1B:20A010A000A0FD2401247B2805307920016079A04920492249227922491E0100
+8A1C:201010501050FE5000887C8801047EFA00487C484448444844887C8845280210
+8A1D:200011FC1010FE9000907C9001107DFE00307C504450449045107E1044500020
+8A1E:2008103C11E0FE2000207C2003FE7C2000207C504450445044887C8845040202
+8A1F:200810481048FE4800447C8400A47D2200207C404440444844847DFE44820000
+8A20:200411E40024FC24002479E401047904010479E4482448244824782449440084
+8A21:202010201050FE5000887D4402227C2000007DFC4404440844087C1044100020
+8A22:2004100E10F0FE8000807C8000FE7C8800887C884488448844887D0845080208
+8A23:202010201020FDFC00247C2400247C2403FE7C204450445044887C8845040202
+8A24:200810881050FE2000507C8801007C0800887C884450445044207C5044880306
+8A25:202010200020FC2003FE7A2202227A2202527A4A4A8A4B024A027A024A0A0204
+8A26:202010200020FDFE01227A24002078200050785048504850489078924912020E
+8A27:204010501048FE4800407DFE00507C5000507C504490449044927D12450E0200
+8A28:201010101010FE9000907C90009E7C9000907C904490449044907C9045FE0000
+8A29:200010080108FC8802527A5202227A2202527A924B0A4A0A4A027BFE48020000
+8A2A:204010201020FDFE00407C4000407C7C00447C444444444444847C8445280210
+8A2B:200010400020FC100090788000807A8402827A824A824C884888788848780000
+8A2C:202010201020FEA800A47CA201227D2002247C244428440844107C2044C00300
+8A2D:200010F81088FE8800887D0602007DFC00847C844448445044207C5044880306
+8A2E:200011FC0088FC880088788800887BFE00887888488848884888790849080208
+8A2F:200013FC0084FC8800887890009C788401447944492849284A107A2844440182
+8A30:202010200020FBFE0020792401247924012479FC4824482048227822481E0000
+8A31:208010800080FDFC01207A200020782003FE7820482048204820782048200020
+8A32:202010200020FC2001FC792401247924012479FC492448204820782048200020
+8A33:200011FC0104FD040104790401FC792401207920491049104A087A0844040802
+8A34:2008101C01E0FD000100790001FE7910011079304918491449127A104A100410
+8A35:2000100003FCFE9402947A9402947A9402947A944A9C4B044A047A044BFC0204
+8A36:2000100003FEFC08000879E8012879280128792849E849284808780848280010
+8A37:202010200020FDFC01247924012479FC01247924492449FC4924782048200020
+8A38:201C10E01020FE2000207DFE00207C7000707CA844A8452446227C2044200020
+8A39:202010281024FC2003FE7C2000707C7000A87CA84524462244207C2044200020
+8A3A:202010200050FC8801047A120020784001887810482048444988781048600380
+8A3B:204010200000FDFE002078200020782001FC782048204820482078204BFE0000
+8A3C:2000100003FEFC200020782001207920013C7920492049204920792047FE0000
+8A3D:208010800100FDFC02047C0401E479240124792449E449244804780448280010
+8A3E:088028882EF028842E84F07C01007FFC00003FF800003FF800003FF820083FF8
+8A3F:209010900090FA9002927AD402987A9002907A904A904A924AD27F124A0E0000
+8A40:202010201020FE20003E7C2000207C2001FC7D044504450445047D0445FC0104
+8A41:202010200020FC2003FE78200020782001FC7904490449044904790449FC0104
+8A42:208810880088FD08017E7B080508794801287928490849084908790849280110
+8A43:202010101010FDFE00207C2000447C8401F87C104420444444827DFE44820000
+8A44:202010200120FD2001FC79200220782003FE7820485048504888788849040202
+8A45:202010201050FE5000887D2402127C1001FC7C044408448844507C2044100010
+8A46:2004101E11F0FF1001107D1001107DFE01107D1045104508450A7D4A45A60112
+8A47:202010200020FDFC012479240124792401247BFE482048504850788849040202
+8A48:00003FF8244824483FF80100FFFE00003FF800003FF800003FF820083FF82008
+8A49:41002100013EF91207D27252025272540254749452885108529474A458420080
+8A4A:202010201124FEA400A87C2001FC7C2000207C2047FE442044207C2044200020
+8A4B:200011FC0104FD040104790401FC78500050785048504892489279124A0E0400
+8A4C:208810881088FE8801FE7C8800887C8800887CF84488448844887C8844F80088
+8A4D:204811480148FD4801487BFE0148794801487948497849004900790049FE0000
+8A4E:200010FE1080FE8000807CFC00847C8400847C8444FC448044807C8044FE0000
+8A4F:201010900090FD10017E7A5203927892011279124A524BD248627822484A0084
+8A50:208010801080FCFE01407D4002407C7C00407C404440447E44407C4044400040
+8A51:202010101010FEFE00827D0400407C4800507C604440444244427C42443E0000
+8A52:202010201020FE4000487C8401FE7C8200007CFC4484448444847C8444FC0084
+8A53:202010201020FDFC00207C2000207DFE00207C204440444844847DFE44820000
+8A54:200011FC1044FE4400447C4400947C8801007CFC4484448444847C8444FC0084
+8A55:200011FC1020FE2001247CA400A87C2003FE7C204420442044207C2044200020
+8A56:201010100010FDFE01127914011079FC014479444928492849107A284A440482
+8A57:200011FE1102FF0201027D7A014A7D4A014A7D4A457A454A45027D02450A0104
+8A58:202010200124FD240124792401FC782000207924492449244924792449FC0004
+8A59:205010480048FC4003FE7880008078FC01447944492849284A107A2844440182
+8A5A:2000100010FCFE8400847C8400FC7C8400847C8444FC448444007C0045FE0000
+8A5B:200010F81088FE8800887CF800887C8800887CF84488448844887C8845FE0000
+8A5C:202011240124FD2401FC782000207BFC01047888488848504820785049880606
+8A5D:204010200020FDFE01027A040000780001FE7820482048204820782048A00040
+8A5E:200011FC1004FE0401F47C0400047DF401147D1445F4451444047C0444280010
+8A5F:04800440FFFE0940118466FC01007FFC00003FF800003FF800003FF820083FF8
+8A60:204010200010FDE00022783403B878B000A878A8492849244A247C2248A00040
+8A61:200013DE0042FC420252794A014A784200C6794A4A52484248427842494A0084
+8A62:2080108001FCFD04020479E40124792401E47924492449E44904780448280010
+8A63:208010841098FEE000827C82007E7C0000FC7C84448444FC44847C8444FC0084
+8A64:201011101110FF2801447D0001FE7C0000A87CA844A844A844A87CAA452A0206
+8A65:202010201050FE5000887D0402FA7C0000007CF84488448844887C8844F80088
+8A66:201010140012FC1003FE7810001079D0009078904890488848EA7B8A48060002
+8A67:108010803EFC62449448483031102FE8C0061FF000001FF000001FF010101FF0
+8A68:204010200020FDFE0000788801047A0200887888485048504820785048880306
+8A69:202010200020FDFC0020782003FE7808000879FE480848884848780848280010
+8A6A:200011F80108FD0801F87908010879F801447948493049204910794849860100
+8A6B:2040102003FEFA020000783803C078400040787C4BC0484048427842483E0000
+8A6C:2008101C01E0FD00010079FE01007900017C79444944494449447A7C4A440400
+8A6D:2040104000FCFD04020879FE0100797C014479444954494849427A424A3E0400
+8A6E:202010200050FC8801047A0201FC78200020782049FC4820482078204BFE0000
+8A6F:202010200040FDFC01047904010479FC0104790449FC49044904790449FC0104
+8A70:202010200020FBFE0020782001FC7800000079FC490449044904790449FC0104
+8A71:2008103C11E0FE2000207DFE00207C2000207DFC4504450445047D0445FC0104
+8A72:202010101010FDFE00207C2400447CF800127C224444458844107C2844440182
+8A73:210410840088FC0003FE7820002079FC002078204BFE48204820782048200020
+8A74:2020102011FEFE4000407CFC00847D8402FC7C84448444FC44847C8444940088
+8A75:202011200120FDFC01207A2000207BFE0090789048904890491279124A12040E
+8A76:208210920092FC920092789202DA7AB604927892489248924892791249020202
+8A77:200011FE1102FF02017A7D0201027D7A014A7D4A454A457A45027D02450A0104
+8A78:202010200124FCA400A8782000207BFE007078A848A8492449247A2248200020
+8A79:08000FF010203FFE6508A8843FFE200027F8200027F8200027F8440847F88408
+8A7A:20201020107EFE8201447C2800107C2000407CFE4542444244427C42447E0042
+8A7B:2080108000F8FD0803107CA0004078A001187A064DF849084908790849F80108
+8A7C:204010400040FDFE0080789000907912015279544A904A284C28784448840102
+8A7D:200011DC0088FC880088788800887BDE00887888488848884888790849080208
+8A7E:210011000100FDFE02027A02051278A2024A7AAA4B1A4A0A4BFA780248140008
+8A7F:2020102001FCFC200020782003FE78000020782049FC4820482078204BFE0000
+8A80:200013FE1088FE8800F87C8800887CF800887C88448E47F844087C0844080008
+8A81:210410840088FC0001FE78880088788800887BFE48884888490879084A080408
+8A82:205010501050FD5200D47C5800507C5800D47D524650445044927C924512020E
+8A83:20201020107CFE8401487C3000207C4801907C3E444245A444187C1044600180
+8A84:2020102003FEFC20002079FC0020782003FE787048A848A849247A2244200020
+8A85:202011200120FDFC01207A2000207BFE007078A848A8492449247A2248200020
+8A86:200013FE0200FE0003FC7A2002207AF802207A204A204BFC4A007A004BFE0000
+8A87:2020102003FEFC500088790402FA780003FE7840488049FC4804780448280010
+8A88:200011FE0020FC400088790401FE78220020782049FE4820482078204BFE0000
+8A89:2208110811100020FFFE082011102FE8C0061FF000001FF000001FF010101FF0
+8A8A:1110091009207FFC0200FFFE09203FF8C0061FF000001FF000001FF010101FF0
+8A8B:200011F80008FC0801F879000104790400FC7840482048A44A8A7A8A44780000
+8A8C:202010200020FBFE00207820002079FC0040782048A44A824A8A7A8A4C780000
+8A8D:200013FC0044FD4401447A84009479080240782048A44A824A8A7A8A44780000
+8A8E:2020102003FEFC20002079FC0124792401FC7820487048A849247A2248200020
+8A8F:2020101010FCFE8400847CFC00847C8400FC7CA244A4449844907C8844C40082
+8A90:201010D80394FC9400907BFE00907894009478D84B98489048AA78CA4A860102
+8A91:4000244002BEF90802887488008870BE018872885488508850887088553E0200
+8A92:202010400088FD0403FE7882008079FC022078204BFE48204850788849040602
+8A93:080C7EF008800EFE78880A8819087FFC00003FF800003FF800003FF820083FF8
+8A94:2000100603B8FC8800887908013E7B8800887A884A88493E49007A80447E0800
+8A95:2004100E03B8FC8800887928012E7BA800A87AA84AA8493E49007A80447E0800
+8A96:2020102003FEFC2000207BFE02027C0401F8781048204BFE4820782048A00040
+8A97:204210E20382FC8A008A788A03EA788A018A79CA4AAA4A824C827882488A0084
+8A98:201C11E00020FC2003FE78A801247A2201F87888489048BE490279024A140408
+8A99:200011FE0000FC9201247A4801247892000079FE48204820482078204BFE0000
+8A9A:2020112410A4FEA800207DFC01047D0401FC7D04450445FC45047D0445140108
+8A9B:200011FC0004FCFC000479FC00007BFE020279F8488848884850782048D80306
+8A9C:204010400088FD0403FE780200887944024278F849884A504820785049880606
+8A9D:202010201050FE8801447E2200F87C0800107C2045FC450445047D0445FC0104
+8A9E:200013FC0040FC4001F8788800887BFE0000780049F849084908790849F80108
+8A9F:2020102211FAFE2400247DFE00107C2001FC7C88451046FE44107C1044500020
+8AA0:202810240024FC2003FE7A2002247A2403A47AA84AA84A904A927DAA44460882
+8AA1:201010140012FC1003FE78100150795407F47954495449484A4A7A5A44260042
+8AA2:200011F80108FD0801F87908010879F80108790849F84890489079124A12040E
+8AA3:200011FC0020FC20012479240124792402AA7AAA4CB24820482078204BFE0000
+8AA4:200011FC0104FD0401FC7800000079FC002078204BFE48204850788849040202
+8AA5:202011200120FDFC01207A2000207BFE0000780049FC49044904790449FC0104
+8AA6:200011F81008FED000207DFC01247D2401FC7D24452445FC45247D244524010C
+8AA7:2028102411FEFE2000207DFC01247D2401FC7D24452445FC45247D244524010C
+8AA8:2080108010FEFD0002FC7C8400A47C9403FE7C844524451445FE7C0444280010
+8AA9:202010101010FEFE00007C7C00007C7C00007C7C4444444444447C7C44440000
+8AAA:201010900088FD0802047DFA01087908010879F848904890489079124A12040E
+8AAB:200011FE0100FD00017C7900010079FE015079524954494849487A444A520460
+8AAC:210410840088FC1001FC79040104790401FC785048504890489279124A0E0400
+8AAD:2020102003FEFC2001FC780003FE7A020404789048904890489079124912020E
+8AAE:2088108813FEFC8800887C5000507C9401947E98449044B244D27C92448E0080
+8AAF:20FC10841084FEFC00847C8400FC7C0001FE7D02450245FE45027D0245FE0102
+8AB0:20A010900080FDFE01107B1005FC7910011079FC49104910491079FE49000100
+8AB1:2020102003FEFC2001FC782403FE782401FC78204920493E49207AA04A7E0400
+8AB2:200011FC0124FD2401FC7924012479FC00207BFE487048A849247A2248200020
+8AB3:400023FE0202FA0203FE721002927292029272FE521052925292749254FE0802
+8AB4:2040102003FEFA02000079FC0000780003FE7820492849244A227C2248A00040
+8AB5:218410680030FCC80324782003FE784000FC79844AFC488448FC788448940088
+8AB6:2040102003FEFC000088788801547A22000078204BFE48204820782048200020
+8AB7:200013FE0202FE8A02527BFE02427A2203FE7A824A824A824AFA7A024A0A0204
+8AB8:201013880088FCFE00907B9002247A2402387B884890489048A478BE4A820100
+8AB9:205010500050FBDE00507850005079DC00507850485048504BDE785048500050
+8ABA:202010200020FBFE002079240124792402AA787048A848A849247A224C200020
+8ABB:2020102203B4FCA800A8792402A2784001FC7904490449FC4904790449FC0104
+8ABC:2020101001FEFD02020478F80088788800F87888488848F8488878884BFE0000
+8ABD:20001040039CFA0402047B9C02047A0403FC789048904890489079124A12040E
+8ABE:7C7C44447C7C44447C7C41045FF440044FE440044FE440044FE448244FE4400C
+8ABF:200011FC0124FD240174792401FC7904017479544954497449047A044A140408
+8AC0:2040108001FCFD24012479FC0124794401FC789049104BFE4810781048100010
+8AC1:200013DE0042FD4A0084794A02527C2000007BDE48524952489479484A540422
+8AC2:20401040007CFC8401087A00002079CE0102790249CE49024902790249FE0102
+8AC3:208810880088FC8803DE78880088799C01DC7AAA4AAA4CC84888788848880088
+8AC4:2040102003FEFC0001FC790401FC780001FC780848104BFE4820782048A00040
+8AC5:08207FFC08200FE008200FE00820FFFE11103FF8C0061FF000001FF010101FF0
+8AC6:2088108813FEFC8800887CF800887C8800F87C88448847FE44007C8845040202
+8AC7:202010A200A2FD240050788803047822002078A448A449284850788849040202
+8AC8:2008103C01E0FC2003FE78A800A878A803FE78A848A84BFE4820782049FC0000
+8AC9:201C11E00020FC2003FE78A801247A4200407BFE4888490848D0783048480184
+8ACA:2080108000FEFD0202427A4A0152784203FE784248E249524A4A784248540008
+8ACB:2020102003FEFC2001FC782003FE780001FC790449FC490449FC790449140108
+8ACC:2020102013FEFC2001FC7D2401FC7D2401FC7C20447044A845247E2244200020
+8ACD:2080108001F8FD0802107DFC0024782403FE7824482449FC4824782048A00040
+8ACE:204810481048FDFE00487C4801FE7C0000FC7C84448444FC44847C8444FC0084
+8ACF:200017E0025EFA5202527BD202527A5403D47A544A484AE84F54785448620040
+8AD0:17F8240867F8A2A024A4289C01007FFC00003FF800003FF800003FF820083FF8
+8AD1:200013FE0040FC8001447A2400687AB001307AA8486848A449227A2048A00040
+8AD2:2040102003FEFC00000079FC01047904010479FC482048A849247A2248A00040
+8AD3:20481044105EFDE000287C12006A7D9600487C5E45E0442444287C12446A0186
+8AD4:4100210001DCF9140114711407D4701401147114558855485948711455140222
+8AD5:20201020003EFC2001FE7922013879E00122791E490049784A487A4A448A0906
+8AD6:202010200050FC8801047AFA000079FC0154795449FC4954495479544904010C
+8AD7:202010200050FC8801447A2201F878080050782048A44A824A8A7A8A44780000
+8AD8:2020102003FEFC20002079FC0020782003FE784048A449A84A907C8848C60080
+8AD9:201C13E00220FBFE02207A92030A7A0601FC7904490449FC4904790449FC0104
+8ADA:2020101010FEFE8201047C0000FE7C1000107C90449E449044907CD0453E0200
+8ADB:2020102000A0FD2C0124792401AC7924012479FC492448504850788849040202
+8ADC:204811480148FBFE014879480178790001FE78204BFE487048A879244E220020
+8ADD:200013FE0022FD20013C792002FE7C0001FC790449FC490449FC790449140108
+8ADE:2040102001FEFD02010279FE0100790001FE79AA49AA4AFE4AAA7AAA44A20086
+8ADF:200011FC0104FD0401FC7904010479FC00007BFE48204920493C79204AA0047E
+8AE0:2040102003FEFA02040479FC000079FC010479FC490449FC490478004BFE0000
+8AE1:2088110402FAFC40008078F800087850002079FC49544954495479544BFE0000
+8AE2:200013FE0222FC2003FE782001FC792401FC792449FC48204BFE782048200020
+8AE3:200010FC1084FE8400F47C9400947DFE01027D7A454A454A457A7D02450A0104
+8AE4:200013DE0252FE5203DE780001FC780003FE7880490049FC4804780448280010
+8AE5:2008103C01E0FC2003FE782001FC792401FC792449FC482049FC78204BFE0000
+8AE6:2040102001FCFC000088785003FE7A22042479FC492449244934792848200020
+8AE7:2110111201D4FD1801527992012E784001FC7904490449FC4904790449FC0104
+8AE8:200013FE0000FDFC0104790401FC780003FE7A224A224BFE4A227A224BFE0202
+8AE9:208410480000FDFE0048784800487A48014A794C48484848484878484BFE0000
+8AEA:2040102003FEFC0001FC790401FC780003FE7A0249FC48204820782048A00040
+8AEB:2020102003FEFC2001FC792401AC7974012479FC4820487048A879244A220020
+8AEC:0C28702411FEFE503852548E91007FFC00003FF800003FF800003FF820083FF8
+8AED:204010A00110FA0805F6780003C47A5402547BD44A544A544BD47A444A5402C8
+8AEE:2020112000BEFC4200847B10011079280144788248FC48844884788448FC0084
+8AEF:202011240124FD2401FC780003FE7820004079FC49544954495479544954010C
+8AF0:200011FC0124FD2401FC7924012479FC0000784048244AA24A8A7C8848780000
+8AF1:2040104001FCFC8403FE780001FC790401FC78204BFE48204A207BFE48200020
+8AF2:200013FE0050FC5001FC79540154795401FC7820482049FC482078204BFE0000
+8AF3:2020101011FEFE0000847C4801FE7C0000FC7C84448444FC44847C8444FC0084
+8AF4:2008100C000AFBFE02087A0802E87A0A020A7AEC4AAC4AA84AEA7A1A4A260442
+8AF5:2020102003FEFC2000207BFE028A7A5202FA7A224A224AFA4A227A224A2A0204
+8AF6:2088108803FEFC8800F8788800F8788800887BFE490049484984790049FE0000
+8AF7:400027FC0404FC3405C4744405F47554055475F45444545455F4749458061002
+8AF8:2020102201FAFC2400287BFE0020784000FC79844A8448FC4884788448FC0084
+8AF9:200011F80108FDF8010879F800007BFE010079FC4A544C9449247A4448A80110
+8AFA:2020101001FEFC000084784801FE7908011079644908491249647A084A3004C0
+8AFB:2020104001FCFD0401FC790401FC780003FE7820482049FC482078204BFE0000
+8AFC:201E13E00044FD24008879FC0040784003FE788048FC494449287A1048680186
+8AFD:2088108803FEFC8800F8782001FC7924012479FC48204BFE4820782048200020
+8AFE:2088108803FEFC8800A8782003FE7840008078FC49844A844884788448FC0084
+8AFF:200010F81088FE8800F87C0001FE7C8800F87C8844F84488449E7DE844080008
+8B00:2088108803FEFC88008878F80088788800F878204BFE487048A879244A220020
+8B01:200011FC1104FDFC01047DFC00807DFE02227D224552450245FA7C0244140008
+8B02:200013FE0222FBFE02227BFE000079FC010479FC490449FC4904790449140108
+8B03:200011FC0104FDFC010479FC0020792001FE7A20482049FC482078204BFE0000
+8B04:024879504BF848804FFC79104A484FFC48027BF848004BF848004BF84A089BF8
+8B05:2040104010FEFD2200AA7CFA00427C9401487CFE452246AA44FA7C4244940108
+8B06:2020101001FEFD02010279FE010079EE012279AA4966492249667AAA4A220466
+8B07:01007FFE44429FF404403FF80440FFFE09201FF02008DFF600001FF010101FF0
+8B08:1FF010101FF010101FF008207FFC0820FFFE0A203118DFF600000FE008200FE0
+8B09:2020104003FCFE2402247BFC02247A4403FC784048A848B4493C79224A22041E
+8B0A:2088108803FEFCA800107BFE0080788000FC780048A848A848A878AA492A0206
+8B0B:4208220803BEF4880AA8713E02087448084877FC50E0515052487C4650400040
+8B0C:200013FE0008FDE8012879E800007BFE000879E84928492849E8780848280010
+8B0D:08202AA44D28145022887FFE4102BFF400001FF000001FF000001FF010101FF0
+8B0E:201010940254FD580110787E00107B30013879544994491049107A804C7E0000
+8B0F:20A0112C1124FD2401AC7D2401247DFC00207DFC4488445044207C5044880306
+8B10:404020280090FAA402C2748A01887678000073FC529452945294729457FE0000
+8B11:201E13E00122FC940040788801F0782000C479FE482248204BFE785048880306
+8B12:202010200050FC4800A479FE028478FC008478FC488048FC494479444A7C0044
+8B13:2020102003FEFC2001FC790401FC790401FC790449FC49044BFE788849040202
+8B14:4040207C0040FBFE0242727803C07244023C720052FC528053FE7480548008FC
+8B15:4004201E03F0FA1E021072FE0292729802F2728E528052B852A874AA554A0A86
+8B16:200011FC0124FDFC012479FC00887944024278F849884A504820785049880606
+8B17:2040102003FCFD0800907BFE02027C4400207BFC488048F84888790849280210
+8B18:200013FC0204FA0403FC7A4002207BFC02887A504BFE4A204DFC7C2048200020
+8B19:208810500000FDFE005079FC00547BFE005479FC485048D849547A5248500050
+8B1A:210410840088FC0003FE780000887904020279FC495449544954795447FE0000
+8B1B:2088108803FEFC8801FC788803FE782001FC792449FC49244BFE790449140108
+8B1C:200011FE0110FD20017C7944017C7944017C79104910495449527A924A500420
+8B1D:4084210403C4FA4403DE724403C47264025477D450C451445244744451540088
+8B1E:2040102003FEFC0001FC790401FC780003FE7A024AFA4A8A4AFA7A024A0A0204
+8B1F:203C13C00044FA240128790000407B9C02047A044B9C4A044A047A044BFC0204
+8B20:2040108001FCFA48013078C0030079FC022078204BFE48204924792449FC0004
+8B21:2008103C03C0F8040244792801FC7A2000207BFE482049244924792449FC0004
+8B22:20A0109001FEFB2001FC792001FC792001FE79004BF849084890786049980606
+8B23:21FC102003FEFE2201AC782001AC780001FC78004BFE488048FC780448280010
+8B24:200013FE0050FDFC0154795401FC780001FC78004BFE482048A879244AA20040
+8B25:2020104001FCFD24017C798C01547924015479FC4820481049547942494A0238
+8B26:0878FF4808863E782A483E304148FFFC00003FF800003FF800003FF820083FF8
+8B27:2040102003FEFC0001547924015479FC00207BFE4A424A924AFA7A0A4A020206
+8B28:2088108803FEFC88000079FC010479FC010479FC48204BFE4850788849040202
+8B29:04407FFC04401FF010101FF010101FF00400FFFE11102FE8C0060FE008200FE0
+8B2A:2040102003FEFC8800507BFE02527A8A03067AFA4A8A4A8A4AFA7A024A0A0204
+8B2B:2040102003FEFC8800507BFE02227AFA02227AFA4A8A4A8A4AFA7A024A0A0204
+8B2C:200013DE0042FA52014A7A52002878C4031278604988483249C4781848600380
+8B2D:2108109007FEF80003C47A5403D47A5403D47A444ACC48004BFC788449140608
+8B2E:202013FE0020FDFC00207BFE000079FC010479FC490449FC490479FC48880104
+8B2F:2020103C0020FDFE0122793801E4791C0100797C4944497C4944797C494402FE
+8B30:2010101002FEFD10017C7854007C7B54017C791049FE491049107A90447E0000
+8B31:202011FC0124FBFE012479FC002079FC012479FC48404BFE488879D04870038C
+8B32:2040108801FCFD0802527BFE00507988062678C04B1048644B88783048C00700
+8B33:200013FE0200FE7C02447A44027C7A0002EE7AAA4AAA4AAA4AEE7A004BFE0000
+8B34:200011FC0124FBFE012479FC000079FC010479FC490449FC490479FC48880104
+8B35:200013DE0042FA52014A7A520042782001FC7904490449FC4904790449FC0104
+8B36:2040102001FEFD000148794801FE794801487948497849004AD47AAA452A0800
+8B37:08207E20087EFEC410281E10222846C68100FFFE00003FF800003FF820083FF8
+8B38:410821080108F7D0011E779401247FD4021473D452545248524874D454240842
+8B39:2088108803FEFC8800F8782001FC792401FC78204BFE482049FC78204BFE0000
+8B3A:08207E2008F8FF2814287F6A082AFF560982FFFE00003FF800003FF820083FF8
+8B3B:40102190061EFA22025472080F9072640208771E5AA252425214720852100260
+8B3C:2040107C0040FDFC0144797801C4793C01047978499449584AFE7A1044500020
+8B3D:7CF804887CF840207DFC052415FC0A22FFFE00003FF800001FF010101FF01010
+8B3E:200011F80108FDF8010879F800007BFC02947BFC480049F84890786049980606
+8B3F:4100211E07D2F912011277DE045277D2045277DE511251125FD27122512A0144
+8B40:200813880088F91007DE7A9402A47B9402947B944A944AC84B887E9448A400C2
+8B41:208813FE0088FC0001FC78A800A87BFE00A878A849FC48204BFE782048200020
+8B42:200013DE0252FE5203DE780001FC792401FC792449FC48204BFE782048200020
+8B43:4040207C0040FBFE0242727803C4723C020072505254535454D8745059FE0000
+8B44:210410880000FBFE02227AAA02727A2203FE780049FC490449FC790449FC0104
+8B45:400027DE014AFB5A056A725202D674200084708452D45296529472D4573E0000
+8B46:202013FE0020FDFC000079FC010479FC00887BFE480049FC4904790449FC0104
+8B47:2020102003FEFC8801247A2201FC782803FE784049FC4E8448FC788448FC0084
+8B48:4208210807C8F810079E749407A4701407947094511451C85708711455240242
+8B49:202017A400A8FA9201147A0805F4780203F87A084A084BF84A0879104FFE0000
+8B4A:2020102001FCFC2003FE7908039C790801887E3E48004BFE489078904912020E
+8B4B:239C1294039CFE94039C7A0402F47A9402F47A944AF44A944A947B344A04020C
+8B4C:400E23F00044FA24010873F8020873FC020473FE520252AA52AA750254140808
+8B4D:00803FFE229025FE2E9034FE249024FE24402FFE200027FC400047FC840407FC
+8B4E:200013FC0048FC3003FE785200947B5000207BFE4A524A8A4B767A524A720206
+8B4F:2124112402AAFBAE01247AAA03AE792407FE7910491449144A8A7A4A4A160422
+8B50:2088105003FEFC5001FC7954018C7974010479FC48084BFE4908788848A80010
+8B51:201811E00040FBFE0088797402527870000079FC49044974495479744904010C
+8B52:203C13E00124FCA803FE78A801247A0201FC7924492449FC4924792449FC0104
+8B53:2020102003FEFC2001FC792401FC792401FC78224BFE484248247AA24A8A0478
+8B54:200013DE0252FBDE02107A5201CE780000887BFE488848884BFE788849040202
+8B55:2080108001FEFB540554795403FE7954015479544FFE48004954792A4A2A0000
+8B56:200013DE0088FAA803FE798802DA7CA601F87908490849F84908790849F80108
+8B57:2210121003DEFA28054478A001107A0805F6780048004BF84A087A084BF80208
+8B58:2110109403D2F8120250799007FE781003D27A524A544BD44A4A7A4A4BD60022
+8B59:2090108801FEFD1003107DFE0110791001FE7910491049FE49007AA44A520452
+8B5A:200013FE0050FBFE02527BFE000079FC010479FC490449FC48207BFE48200020
+8B5B:2088108803DEF88807FE788801547A2201FC7904490449FC4904790449FC0104
+8B5C:2108109003FCF8900294799800907BFE000079F84908490849F87908490801F8
+8B5D:400027FC04A4FCA407BC70A007BC74A404A477BC54A454A457BC74A250A2007E
+8B5E:200011FC0154FD5401FC780003FE780001FC790449FC4862489479884AA400C2
+8B5F:20F810880088FCF8000079DC0154795401DC78204BFE487048A879244A220020
+8B60:202017FE0000FBFE02027AFA028A7BFE000079FC490449FC490479FC480007FE
+8B61:2020112400A8FBFE020278F80088788800F8780049FC492449FC792449FC0104
+8B62:204412240128FC7E00107828034A791C0128794C491A492A494879104AFE0400
+8B63:202010200050FC8801047AFA0000780001DC7954495449DC4888788849540222
+8B64:4108220807C8F45007DE746407D47214011477D4521453C852487454555408A2
+8B65:10207E204A7E7EC41028FF1020283EC64300FFFE00003FF800003FF820083FF8
+8B66:2420FF20247E7EC482287A104A287AC60500FFFE00003FF800003FF820083FF8
+8B67:402023FE0288FA5003FE725002FC725403FE725452FC525052D8755456520850
+8B68:409023FC0294FBFC029473FC000073FC020072F8520053FE5520751455480986
+8B69:2040102001FCFC8800507BFE000079FC010479FC490449FC48207A944A8A047A
+8B6A:208813FE0088FDFC010479FC010479FC008079FE4A224D52490279FA480A0004
+8B6B:208010F80108FBFE0144799201FE7900017C7900497C4900497C7A444A7C0444
+8B6C:3E1022FE3E4420287EFEA2103EFC22100100FFFE00003FF800003FF820083FF8
+8B6D:410026DC0454FC5406D47454046677C0001C701457D45114510871C857140222
+8B6E:202010501088FD7402027DFC01247DAC01247DFC440044F844887CF8448800F8
+8B6F:200011FC0154FDFC002079FC00207BFE0088785049FC48204BFE782048200020
+8B70:2104108803FEFC2001FC782003FE7854019278904BFE489048D47B8A489601A2
+8B71:08207FFC01003FF80100FFFE11107D7C01007D7C01007D7C01007D7C45447D7C
+8B72:4080204007FEF9100208751403F8711003F8711057FC512853107D4851860100
+8B73:200011FC0020FBFE022279AC002079AC00007BFE482049FC495479544954010C
+8B74:2010107C0254FD7C011078FE00007B7C0144797C4940497C4944797C4A80047E
+8B75:414421440554FB64015E77E400047234014C77E4508453E4508470E457140008
+8B76:0100FFFE00003FF800003FF820083FF80810FEFE00007CFC00007CFC44847CFC
+8B77:208813FE00A8FC9001FE7B2001FC792001FC792049FE49004BFC78884870038E
+8B78:202013FE0020FDFC00007BFE000279FC00207BFE48004BFE48047BBE4AA4038C
+8B79:202013FE0000FDFC010479FC00007BFE020279FC48404BA448D87B3448D20330
+8B7A:220012BE0302FA5401C8783E020A7BCA052879284FEE49284AA87A584C4E0080
+8B7B:3EF822883EF822883EF822883EF814502288FFFE00003FF800003FF820083FF8
+8B7C:7E40487E7E9043087EFE48AA7EFE02000100FFFE00003FF800003FF820083FF8
+8B7D:0A0033B822083BB820883AB82288FFFE11103FF840049FF200001FF010101FF0
+8B7E:208813FE0000FDE2012A79EA012A79EA0122796648004BDE4A52794A4A5200C6
+8B7F:208813DE0088FDDC00887BDE00887BFC000479FC48044BFC48407AA44A8A047A
+8B80:202013FE0020FDFC00007BFE02527BFE010479FC490449FC490479FC48880104
+8B81:4020201004FEFA44022870FE009276FE029272BA52AA52BA5286750058FE0000
+8B82:210011F80208FFFE02627A9201FC790401FC790449FC488049F87A884870038E
+8B83:208811DC0088FBDE00887954022279FC010479FC490449FC490479FC48880104
+8B84:83F842480248E3F80248E24803F8E0000FBEEAAAAAAAAFBEAAAAEAAAAFBE08A2
+8B85:202013FE0202FC1C03E0792400A87BFE01247A024DFC492449FC792449FC0104
+8B86:22004F9C94802FDE6108AFC8250827D80100FFFE00003FF800003FF820083FF8
+8B87:23DE125203DEFE5203DE7A42027A7A8A03127ADA4A8A4ADA4A8A7AFA4A0A0204
+8B88:400027FE0444FD98048875FE048875DC06AA748854205520553C752055200BFE
+8B89:2010107C0254FD7C011078FE00447B7C0144797C4944497C492879444A80047E
+8B8A:210447C88812F3BC20084B92F83E0380AAAAABAA08001FF8282007C01830E00E
+8B8B:08407F7C1440FF7C22043E7C22403E7C2342FFFE00003FF800003FF820083FF8
+8B8C:4110211007FCF91001F0720802EA76AC02A872AA56EA5A06500072A452520452
+8B8D:200013FE0020FBAE02AA7AAA03AE782003FE78204BAE4AAA4AAA7BAE482003FE
+8B8E:3218291440207BBED06853A8783E53A850287BBE52A852A852A87BBE42A04020
+8B8F:22004F9C94802FDE6208AFC82A482AD80100FFFE00003FF800003FF820083FF8
+8B90:48907EFCC9907EFC48907EFC48907EFC0100FFFE00003FF800003FF820083FF8
+8B91:804040A00110E2080DF6E0000EEEEAAA0EEEE000AFFEA922AFFEE922A92A0804
+8B92:21F0121007FCFA0403FC7A2403B87A2201FE7A104FFC4A444BFC78D0494A063E
+8B93:202013FE0000FDDC015479DC00887BFE00887BFE48884BFE489479884AA400C2
+8B94:400E2770052AFD14053E7608057E7500057E7502553E5602547E741454AA04BA
+8B95:23DE125203DEFE5203DE7A2202FA7A2202FA7AAA4AFA4AAA4AFA7A724AAA0226
+8B96:2148114C02AAFC0803FE79480368794A036A794A4B6C494C496A7B8A48160022
+8B97:222213FE0090F9FE03107DFE011079FE011079FE49004BFE4A8A7B764A520276
+8B98:43FC210801F8F90801F8710E07F8700807FE7294539C5294539C72D657BC0084
+8B99:208813FE0088FBDE02527BDE00A0789001FE79204BFC4D2049FC792049FE0100
+8B9A:452827BE0948F7BE031875AA094673FC020473FC520453FC520473FC51080204
+8B9B:410827FE0108FB90013C77D402B4755C0396712253FC500057FE7080510403FE
+8B9C:4248215007FCF40401F0711007FC755404E477FC504057FC50407FFE52A40452
+8B9D:23DE125203DEFC0003FE7A0002C87A4E03EA7AB24AEA4AAA4AEA7AB445E4082A
+8B9E:810841EC010AEFEA0928EBC8093EEFE80948EBE8AA28AB68AAA8EBF4AAB412A2
+8B9F:81084FE40100E7CE0000EFEE0AA0EFEE0440E7CEA44AA7CAA44AE7CEA28A0440
+8BA0:000020001000100000000000F000100010001000100010001400180010000000
+8BA1:004020401040104000400040F7FE104010401040104010401440184010400040
+8BA2:0000200013FE102000200020F020102010201020102010201420182010A00040
+8BA3:0080208010801080008000A0F090108810841084108010801480188010800080
+8BA4:004020401040104000400040F040104010A010A010A015101910120804040802
+8BA5:000021F01110111001100110F1101110111011101110151219121212020E0400
+8BA6:0000200013FC104000400040F040104017FE1040104010401440184010400040
+8BA7:0000200013FE102000200020F020102010201020102014201820102007FE0000
+8BA8:001020101010101003FE0010F010101011101090109010101410181010500020
+8BA9:004020401040104000400040F07C10401040104010401440184010400FFE0000
+8BAA:002020201020102001240124F12411241124112411241124152419FC10040000
+8BAB:00802080110011FE02000400F1F8100810101060108015001A02120201FE0000
+8BAC:0010207813C0104000400040F040107E17C010401040144218421042003E0000
+8BAD:010421241124112401240124F124112411241124112415241924122402040404
+8BAE:008020481248120802080110F110111010A010A01040144018A0111002080C06
+8BAF:000027F01110111001100110F11017D01110111011101112150A190A11060102
+8BB0:0000200011F8100800080008F00811F811081100110011001502190210FE0000
+8BB1:0000200013FC104400440244F244124414841084108415041904120404280810
+8BB2:011021101110111007FC0110F11011101FFE1110111015101910121002100410
+8BB3:00402040104017FE00400040F3FC1040104017FE10421042144A184410400040
+8BB4:000023FC1200120802880250F2501220122012501250128817081A0013FE0000
+8BB5:000023FE12001200020003FCF20412041204120413FC120016001A0013FE0000
+8BB6:000023FC1010111001100110F21013FE10301050109015101A10141000500020
+8BB7:002020201020102003FE0222F22212221252124A128A130216021A02120A0204
+8BB8:00802080108011FC01200220F020102013FE1020102010201420182010200020
+8BB9:00A020A010A0112401240328F5301120116011A01120112215221922111E0100
+8BBA:0040204010A010A001100208F406111011201140118011001504190410FC0000
+8BBB:000020081108108802520252F222122212521292130A160A1A0213FE00020000
+8BBC:002021201120111001100248F248144418821080111015081A0817FC02040000
+8BBD:000043F822082208032802A8E2A82248224822A822A82B2A340A240A08061002
+8BBE:000021F0111011100110020EF40013F811081110109014A0184010A003180C06
+8BBF:00802040104017FE01000100F10011F811081108110815081A08120804500820
+8BC0:00402040104013FC00440044F044104417FE104010A014A01910120804040802
+8BC1:0000200013FE102000200020F1201120113C1120112015201920112007FE0000
+8BC2:002020201020102003FE0020F020102011FC1104110411041504190411FC0104
+8BC3:0000200017FE1008000803C8F24812481248124813C812481408180810280010
+8BC4:000023F81040104002480148F150104017FE1040104014401840104000400040
+8BC5:000021F811081108010801F8F1081108110811F8110815081908110807FE0000
+8BC6:0000200011FC110401040104F104110411FC1104100014901888110402020402
+8BC7:000023FC12041204020402F4F29412941294129412F416941A04120402140208
+8BC8:01002100110011FE02800280F48010F810801080108014FC1880108000800080
+8BC9:0008201C11E0110001000100F1FE111011101130111815141912121002100410
+8BCA:0040404020A0211002080426E040208023102020204028883310202000C00700
+8BCB:0008203C13E0122002200220F22013FE1220121012101212160A1A8A13260212
+8BCC:0080208010F8110802100420F3FC10041004100411FC10041404180413FC0004
+8BCD:000023FC1004100407F40004F00413E412241224122413E41404180410140008
+8BCE:002020201124112401240124F1FC102010201124112411241524192411FC0004
+8BCF:000023FC1084108400840104F1141208140011FC110411041504190411FC0104
+8BD0:00202020102013FE02220224F22013FC12841288124816501A20145004880906
+8BD1:000023FC1104108800500020F0D81326102011FC102014201BFE102000200020
+8BD2:0020202010401088010403FEF002100011FC1104110411041504190411FC0104
+8BD3:000023FE1200120003FC0220F22012F812201220122013FC16001A0013FE0000
+8BD4:0040404027FC2040004003F8E040204027FE20E0215029503248244408420040
+8BD5:002820241024102007FE0020F02017E0112011101110151019CA170A02060002
+8BD6:0020202011FC102000200020F3FE10001020102011FC10201420182013FE0000
+8BD7:00402040104013FC00400040F7FE1010101017FE101012101510191010500020
+8BD8:00202020102017FE00200020F3FE1000100011FC110411041504190411FC0104
+8BD9:00802080108017FE01000120F22012A414A415281A5010501488190812040402
+8BDA:00284024202027FE04200420E42427A424A424A824A82C903692292A08461082
+8BDB:00202120112011FC01200220F02013FE107010A810A815241924122200200020
+8BDC:00202120112011FC01200220F02013FE1090109010901090151219121212040E
+8BDD:0008203C11E01020002003FEF0201020102011FC110411041504190411FC0104
+8BDE:0008401C2F70211002100450EF5C21502950295025502A7C33002480087E1000
+8BDF:0008403C23C02200020003FEE2002200220022FC22842A843484248408FC0084
+8BE0:0040204010A0111002080406F3F810401040104013F810401440184017FE0000
+8BE1:0100410023F8220804100BFEE20022F82288228822A822902A823482247E0800
+8BE2:0200420023FC240404040BE4E224222423E42224222423E42A24300420140008
+8BE3:01002104113811C001020102F0FE100011FC1104110415FC1904110401FC0104
+8BE4:0080208011F01210002003FCF044104417FE1044104413FC1444184011400080
+8BE5:008040402FFE208001100110E22427E42048208821102A203450208803040C04
+8BE6:020821081110100007FC0040F04013F81040104017FE10401440184010400040
+8BE7:00402020102013FE02020404F03813C010401040107E17C0144018421042003E
+8BE8:000023FE12021444004003FCF08010A0112011FC102014201BFE102000200020
+8BE9:000047BC2084208404A40294E2942084218C229424A420842884308422940108
+8BEA:0040404027FC204003F80080E7FE2090211021FE22102A903450281000500020
+8BEB:0014401220102FFE00100290E29222922FD2229422942A88328A249A04260842
+8BEC:000047FC2040204002480248E248255424D2286220402840304020400FFE0000
+8BED:000047FC2040204003F80088E08827FE2000200023F822082A08320823F80208
+8BEE:0020212410A410A8002001FCF104110411FC1104110411FC1504190411140108
+8BEF:000043F82208220803F80000E7FC204020402FFE204020A028A0311022080406
+8BF0:00202120112011FE02200420F02013FE1000100011FC11041504190411FC0104
+8BF1:001C47E0204020400FFE0150E2482C4623F021102120217C2A04320424280810
+8BF2:0100210011FC120005F80108F148112817FE11081248122817FC180810500020
+8BF3:0000444022BE210802880488E08820BE218822882488208828883088253E0200
+8BF4:020821081110102003F80208F208120813F810A010A0152019221222041E0800
+8BF5:000047F8201021A0004007FCE444244427FC2444244427FC2C44344424540408
+8BF6:004040802110220807FC0104E10023F8244020402FFE204028A0311022080C06
+8BF7:0040404027FC204003F80040E7FE200023F8220823F822082BF8320822280210
+8BF8:0040404423F42048005007FEE040208021F82308250821F82908310821F80108
+8BF9:00004FC024BC24A404A407A4E4A424A827A824A8249025D02EA830A820C40082
+8BFA:0108410827FE210801480040E7FE2080210023FC250429042904310421FC0104
+8BFB:0020202011FC1020002003FEF002109410501110109013FE1428184410820302
+8BFC:00004FFE2080218402440468EAB0213022A8246828A421242A22342020A00040
+8BFD:009020901090179E00900090F090139C109010901090179E1890109000900090
+8BFE:000043F82248224803F80248E24823F8204027FC20E029503248244600400040
+8BFF:003843C02040204007FC0150E2482486208027FC21102A1031A0206000900308
+8C00:00404140265C24440444075CE444244427FC244420A020A02910320824040802
+8C01:01404120212023FE02200620EBFC2220222023FC222022202A2033FE22000200
+8C02:0040404020A0211002880446E80023F020102020204029243522250A090800F8
+8C03:000047FC2444244405F40444E44427FC240425F425142D1435F4240404140808
+8C04:0080408020F8210802100400E040239C22042204239C22042A04320423FC0204
+8C05:0040202013FE1000000001FCF1041104110411FC102014A81924122200A00040
+8C06:0080204017FC100003F80208F3F8100013F81010102017FC1840104001400080
+8C07:0080404027FC200001100110E2A824442000204027FE20402840304020400040
+8C08:004022441244144800A00110F6081044104012481248145018A0111002080C06
+8C09:0040202013FE1222002001FCF124112411FC1124112415FC1924102000200020
+8C0A:0040202013FE1202040401F8F108110811F81108110815F81908110807FE0000
+8C0B:020842082FFE2208020803F8E208220823F820402FFE20E0295032482C460040
+8C0C:0110411027FC211001F00110E1F02110211027FE220022902B08320023FC0000
+8C0D:00904290229027FE02900290E2F0220023FC204027FE20E0295032482C460040
+8C0E:0108410827FE2148002007FEE200220023FC2000224822482A48344A244A0846
+8C0F:004040402FFE204007FC0444E55424E4244427FC20E029503248244600400040
+8C10:0220222413A8123002A20322F25E108013FC1204120413FC16041A0413FC0204
+8C11:0040207C104013FE02420278F3C01244123C120012FC16801BFE1480048008FC
+8C12:000043F8220823F8020803F8E10023FC2444224422A422042BF4300420280010
+8C13:000047FC244427FC044407FCE00023F8220823F8220823F82A08320822280210
+8C14:000047BC24A424A407BC0000E3F820002FFE2100220023F82808300820500020
+8C15:004020A01110120805F60000F3C41254125413D41254125417D41A44125402C8
+8C16:003C47C022442128000003FCE080208027FE210021F82A883250242008D80306
+8C17:010021F01210142003FC0244F24413FC10A01122161E10C01430198010600010
+8C18:00402240117C108401080620F22012501288110611F811081508190811F80108
+8C19:0080404027FC200002080110EFFE200023F82208220823F82A08320823F80208
+8C1A:0040202013FC100001080090F3FE1210122012C8121016241AC8141004600980
+8C1B:0040202011FC100000880050F3FE1222142411FC112411241534192810200020
+8C1C:0010409224522254021000FEE010263822542292231022102A10350028FE0000
+8C1D:0080404027FC2404040407FCE400240027FC26A42AA42BFC3AA42AA412A4020C
+8C1E:000023FE10221120013C0120F2FE140011FC110411FC150419FC110401140108
+8C1F:0110411027FC2110000003F8E20823F8220823F8204027FC28A0311022080C06
+8C20:004042482150204007FE0402E80423F82208220823F820A0292031242224041C
+8C21:000047FC244427FC044407FCE1102208248421F8220825083090206001980E06
+8C22:010842082788248807BE0488E78824C824A82FA821882A883488288802A80110
+8C23:0008203C13C0100402440128F1FC1220102013FE102011241524192411FC0004
+8C24:0040202013FC1108009003FEF2021444102013FC108010F81488190811280210
+8C25:020841082110200007FC0000E1102208240423F822A822A82AA832A82FFE0000
+8C26:02084110200027FE00A007FCE0A42FFE20A427FC20A029B032A82CA600A000A0
+8C27:00404028209022A402C2048AE1882678200023FC229422942A94329427FE0000
+8C28:011041102FFE211001F00040E7FC244427FC20402FFE20402FFC30402FFE0000
+8C29:03F8420823F8220803F80000E7FC24A424A427FC200023F8291030E023180C06
+8C2A:0080404027FC211000A007FCE44425F4244425F4251425142DF4340424140408
+8C2B:0108209017FE100003C40254F3D4125413D4124412CC14001BFC108401140608
+8C2C:000047BC208424A4029404A4E0502188262620C0231020642B88303020C00700
+8C2D:000023FE105013FE025203FEF00011FC110411FC110415FC182013FE00200020
+8C2E:000047BC2108252807BC0318E5AA2946200023F8220822082BF83208220803F8
+8C2F:0140412023FE222006200BFCE220222023FC222022202BFE3200252404920892
+8C30:0200417C2504244405F40444E5F42554257425D4255425F42CE435542444044C
+8C31:0208411027FC20A004A402A8EFFE200023F82208220823F82A08320823F80208
+8C32:000047F82090206007FC00A4E12826A0204027FC24A425142EEC34A424E4040C
+8C33:0108410827CC210A010807DEE44826C8254827C8255427D42D543554245404E2
+8C34:001044FE229222FE001001FEE0002EFE228222FE228022FE2A8232FE250008FE
+8C35:020043F8241027FE0D481624E7FE240025FC240025FC2C0035FC290409FC1104
+8C36:0448444C2AAA20080FFE0288EEE8228A2EEA228C2EEC2A8832EA2F1A04260042
+8C37:08200810110821044280044008203018C0061FF010101010101010101FF01010
+8C38:08881C84F102122210201050FC881104120211FC110411042104210441FC8104
+8C39:004048404440944013FE2840448080907890492049204A484A447C8449FE0082
+8C3A:000024FC22084A4888481448228841FEBC1824282428244824883D0824280010
+8C3B:000025F822484A48884815F822484148BC4825F824482448248A3C8A250A0206
+8C3C:0048244822484A4889FE144822484148BC4825FE2400244824443C8424820102
+8C3D:002048204450948811442A2244F880087810482049FC49044904790449FC0104
+8C3E:0040482045FE95021204285044888104780049FC48204820482078204BFE0000
+8C3F:0E00F05022489284452420204450F888110624F8FE881088FE88288844F88288
+8C40:001E4BE0452294941040288845F0802078C449FE482248204BFE785048880306
+8C41:20001050FE48828411247C2010507C881104FEFA10887C88448844887CF84488
+8C42:000024EE22224AAA886614AA22104128BC442592242024C824323CC4241800E0
+8C43:000853884888891027DE32944AA487947A944B944A944AC84B887E9448A400C2
+8C44:00204BFE442095FC10002BFE465283FE790449FC490449FC490479FC48880104
+8C45:011050904BDE8810225E31824BDE84107BDE4A504BDE4A504BDE7A504A5202CE
+8C46:00007FFC000000001FF010101010101010101FF00000101008200440FFFE0000
+8C47:0000FE0001FC00207C204420442044207C200020442028202E20F02043FE0000
+8C48:0100210821083FF800007FFC00001FF0101010101FF0000008200440FFFE0000
+8C49:0020FE20002001FE7C204420442045FC7C840088444828502E20F05041880606
+8C4A:04403FF824483FF824483FF800007FFC00001FF010101FF008200440FFFE0000
+8C4B:108010803EFC62449448483030102FE8C0061FF010101FF008200440FFFE0000
+8C4C:0040FC2003FE02027D04490049DE4A527A5203528C9A489451101912E212040E
+8C4D:0020FE4000FE00927C9244FE449244A27CFE0048448829FE2E08F00840080008
+8C4E:7EFC48447E4442287E1048287E4400827FFC00001FF010101FF008200440FFFE
+8C4F:0088FE50000001FE7C5045FC445447FE7C5401FC445028D82F54F25240500050
+8C50:08201D7049245D7449245D7449247FFC00007FFC00001FF010101FF004407FFC
+8C51:2844FE28AA00FEFCAA14FE1400FCFE9000907CFE44327C32445A28541E90E110
+8C52:2A227F14AABEFF8AAA8AFFBEAAA8FFA8003EFF9A001A7F2A412E7F482208FF88
+8C53:2A107F10AA90FFBCAA90FFA8AAA8FFA40054FF82007C7F5441547F542254FFFE
+8C54:2A087F08AA9CFF88AA88FFBEAA88FF900014FFBE00007F3E412A7F2A222AFFFE
+8C55:00007FFC020006000908119062A004C008C011A06290048808863080C2800100
+8C56:00007FFC020006000908119062A014C008C015A06290048808863080C2800100
+8C57:0000FDFE2820284028A22B34285828942B34285228922B102850482247FE8000
+8C58:0020FC20102023FE6020952439245124992435FC5424902010221022501E2000
+8C59:020001003FF808200440FFFE02000D08719002A00CC071A006981886E2800100
+8C5A:00007BFE4840488049447A24486848B049307A28486848A449224A2048A09840
+8C5B:0000FCF810882088608895063A0051FC98843484544890501020105050882306
+8C5C:0000FDFE1048204860489448384853FE98483448544890481088108851082208
+8C5D:0000FDFC1124212461249524392451FC99043500550091001102110250FE2000
+8C5E:0040FE40088010FC31044A049CF428944C949A942AF448948804080428281010
+8C5F:0040FC2011FC2104610495FC39005100997C35085510912011421282527E2400
+8C60:0000FEF80888108830884AF89C8828884C889AF82A884888888808882BFE1000
+8C61:08001FE020207FF8A10822083FF80600191062A00CC071A006901888E2860100
+8C62:111009207FFC0400FFFE10102FC8C606191062A00CC071B006881884E2800100
+8C63:0000FDDC1088208860889488388853DE98883488548890881088110851082208
+8C64:0000FDF81108210861F89508390851F899443548553091201110114851862100
+8C65:0020FE10081011FE30204A249C4428F84C129A222A4449888810082828441182
+8C66:010001F801003FFE210221F02F0420FC20002FF823002C9023605CD843469CC0
+8C67:0028FC2413FE2020602095FC3924512499FC3524552491FC112411245124210C
+8C68:00C2FC34101820646182942039FE5050989035FE56929092109A109450102010
+8C69:0000FDFE1020204060A295123834505898983514543490521090111050502020
+8C6A:01007FFC00001FF010101FF000007FFE40029FF40600192006C039B0068C3980
+8C6B:0080F8F8090853FE25121122FDFE244028A223542098233420542092A3504020
+8C6C:0020FE2008FA102430284BFE9C2028404CFC9B442A44487C88440844287C1044
+8C6D:0000FDDC11442144614495DC3900510099DC3514551491D41108110851142122
+8C6E:0020FDFC1020208863FE9488380051FC99043524552491241124105050882304
+8C6F:000EFEF00822109230444A209C4428F84C109A242AFE481088FE082828441082
+8C70:1000FE7810487C480048FE8682007CFC0044FE44202854282810DC282A44D982
+8C71:0000FCF81088208860F89488388850F8980035FC555491541154115453FE2000
+8C72:0000FDFE11102120617C9544397C5144997C3510551091541152129252502420
+8C73:010041047DF4492451446BAC4D3459646DB44B2C596469A4596441047FFC0004
+8C74:0020FE1008FE104430284AFE9C8228924CFE9A922ABA48AA88AA08BA28821086
+8C75:0124F924222444A4A154154A3B92550899083528512E912811281158514E2180
+8C76:0020FDFC1020208863FE948839FC510499FC350455FC910411FC108851042202
+8C77:0020FBFE202041FCA00017FE3A0251FC980035FC510491FC1104108853FE2000
+8C78:00E007007A0C113008C00780784000A003300C507090011006101810E0A00040
+8C79:0C403040C28014FC49043204C80415042484CC4414442404C404040428281010
+8C7A:0C103010C210141049FE3010C83014302450CC5014902510C410041028501020
+8C7B:0C0030FCC220142048203020C82015FE2420CC2014202420C420042028201020
+8C7C:0C103110C310151249123114C9D815102510CD1015102512C5520592290E1000
+8C7D:0C203020C22015FE49223122C92215222552CD4A158A2502C5020502290A1104
+8C7E:0C0031FEC210141048203020C86814A42522CE2214202420C42004002BFE1000
+8C7F:0C803080C28015FC49043204C9E415242524CD24152425E4C524040428281010
+8C80:0C203020C324152449243124C9FC14202420CD2415242524C524052429FC1004
+8C81:10402020D4200BFE52022404D00018902890C89018882908C908090452042402
+8C82:0C0031FCC244144448443044C89414882500CCFC14842484C484048428FC1084
+8C83:0C203020C24015FC49043104C904150425FCCD0415042504C504050429FC1104
+8C84:0C203020C3FC14244BFE3024C9FC14202420CDFC14202420C7FE042028201020
+8C85:10902090D490091051FE2310D51019382938C95419542992C910091051102110
+8C86:0C0031FEC200140048FC3084C88414FC2484CC8414FC2484C400040029FE1000
+8C87:0C0031F8C308150849F83108C90815F82544CD4815302520C510054829861100
+8C88:0C103020C2FC148448A43094C89415FE2484CCA414942494C484050429141208
+8C89:10802080D4F80908531024A0D04018A02918CA061DF82908C908090851F82108
+8C8A:0C0030FEC2201420484030FCC88414842484CCFC14842484C484048428FC1084
+8C8B:0C0031FCC30415FC490431FCC800140025FCCC20142027FEC420042028201020
+8C8C:0C203040C3FC1504490431FCC904150425FCCC5014502450C4920492290E1200
+8C8D:0C0031FCC324152449FC3124C92415FC2420CC2015FC2420C42004202BFE1000
+8C8E:10002040D79C0A045204239CD2041A042BFCC89018902890C89009125212240E
+8C8F:10402080D5FC0924512421FCD124194429FCC89019102BFEC810081050102010
+8C90:104020A0D5100A0855F62000D3C41A542A54CBD41A542A54CBD40A44525422C8
+8C91:100023DED6420A42524223DED2001A3E2BD2CA121A142BD4CA080A1452242242
+8C92:0C203124C324152449FC3000CBFE14202440CDFC15542554C55405542954110C
+8C93:0C883088C3FE148848883000C9FC15242524CD2415FC2524C524052429FC1104
+8C94:0C203040C3FC150449543124C954150425FCCC00151225D4C51805522992110E
+8C95:101E23E0D522089450402088D1F0182028C4C9FE18222820CBFE085050882306
+8C96:11042084D488080053FE2000D08819042A02C9FC19542954C954095457FE2000
+8C97:102021FCD5240BFE512421FCD02019FC2924C9FC18402BFEC88809D05070238C
+8C98:0C883088C3FE1488480031FCC90415FC2504CDFC142025FEC450048829041202
+8C99:100023FED6000A7C52442244D27C1A002AEECAAA1AAA2AAACAEE0A0053FE2000
+8C9A:100023DED6520A5253DE2000D1FC192429FCC92419FC2820CBFE082050202020
+8C9B:108823FED4880BDE525223DED0A0189029FEC9201BFC2D20C9FC092051FE2100
+8C9C:13DE2252D7DE0A5253DE20A0D1FE1B202DFCC92019FE2800C9FC08885070278E
+8C9D:00003FF8200820083FF8200820083FF8200820083FF800000820101020084004
+8C9E:010001FC010001003FF8200820083FF820083FF8200820083FF8082010102008
+8C9F:0800101020087FFC200400003FF820083FF820083FF820083FF8082010102008
+8CA0:080008001FE020204040BFF820083FF820083FF820083FF80000046018186004
+8CA1:00107C10441044107DFE441044307C30445044507C9001102810241044508020
+8CA2:00003FF801000100FFFE00003FF820083FF820083FF820083FF8082010102008
+8CA3:04200210013EFFC00022001A3FF620103FF020103FF020103FF0084010202010
+8CA4:0020782048204920792C493449647BA449244934792801225122490288FE0000
+8CA5:00407C20440045FC7C00440044F07C90449044907C90009228922512450E8200
+8CA6:00007C0045FC44007C00440047FE7C90449044907C900090289225124512820E
+8CA7:044008203018CFE6042018A060401FF010101FF010101FF010101FF008201010
+8CA8:0880109830E057849084107C00001FF010101FF010101FF010101FF008201010
+8CA9:0008781C49E04900790049FC49447944494449287928011051104A288A440482
+8CAA:010002800C603118CFE6004000801FF010101FF010101FF010101FF008201010
+8CAB:00001FF01110FFFE11101FF000001FF010101FF010101FF010101FF008201010
+8CAC:01003FF801001FF00100FFFE00001FF010101FF010101FF010101FF008201010
+8CAD:0008007C3F80208020803FFE208027F8240827F8240827F8240847F842108408
+8CAE:00203F2800240020FFFE00207FA040A07FA040907F9040907F8A120A21064082
+8CAF:00407C20442045FE7D02460444007C0045FE44207C2000202820242044A08040
+8CB0:12207FFC122013E010001FF800001FF010101FF010101FF010101FF008201010
+8CB1:00107810481049FE79124914491079FC494449447928012851104A288A440482
+8CB2:088028882EF028842E84F07C00001FF010101FF010101FF010101FF008201010
+8CB3:0024FFFE00203FA000207FA000203FA020A03F9020903F90208A3F8A11062082
+8CB4:01001FF011101FF00100FFFE00001FF010101FF010101FF010101FF008201010
+8CB5:040008201FF00210FFFE08203018DFF610101FF010101FF010101FF008201010
+8CB6:00047C1E45E044007C20441045FE7C04440844107C20004028802540463E8000
+8CB7:00007FFC444444447FFC00003FF820083FF820083FF820083FF8082010102008
+8CB8:08901088307ED7C01022101A00061FF010101FF010101FF010101FF008201010
+8CB9:00107C10449044907CFE449045107C10441044FE7C1000102810241045FE8000
+8CBA:00007DFC450445047D04450445FC7C50445044507C50005028922492450E8200
+8CBB:04407FF804483FF824403FFC08441FF4301C5FF010101FF010101FF008201010
+8CBC:00207C20442044207C3E442044207C2045FC45047D0401042904250445FC8104
+8CBD:00207C20442044407C48448445FE7C82440044FC7C8400842884248444FC8084
+8CBE:00047C1E45F045107D10451045107DFE451045107D100108290A254A45A68112
+8CBF:060078FC4044484444445A9461081FF010101FF010101FF010101FF008201010
+8CC0:100010007E7C124422442A7C44009FF010101FF010101FF010101FF008201010
+8CC1:01003FF801000820FFFE082000001FF010101FF010101FF010101FF008201010
+8CC2:0080788048F849087B104CA0484078A049184A067DF801085108490889F80108
+8CC3:081813E0304057FC904013F800001FF010101FF010101FF010101FF008201010
+8CC4:00207C2045FE44407C4044FC44847D8446FC44847C8400FC2884248444948088
+8CC5:00207C10441045FE7C20442444447CF8441244227C4401882810242844448182
+8CC6:00827C42444444007CFE444444447C44444445FE7C4400442884248445048204
+8CC7:410021FC0A441048E0A0211826061FF010101FF010101FF010101FF008201010
+8CC8:00007FFC04403FF824483FF800001FF010101FF010101FF010101FF008201010
+8CC9:00207C20444044807DFC455445547D54455445547D5401542954255447FE8000
+8CCA:00147C12441045FE7C10449044927C9247F244947C940088288A251A45268242
+8CCB:00407C20442045FE7C00448845047E02448844887C5000502820245044888306
+8CCC:0100FFFE08401F90062038D007087FF410101FF010101FF010101FF008201010
+8CCD:00207810481049FE7900491049107910497C49107910011051104A108AFE0400
+8CCE:00287C24443E45E07C20443C45E07C20443E45E07C2200242818246A45868002
+8CCF:00007CFC448444847CFC448444847CFC448444847CFC00002848244444828102
+8CD0:00407840488849047BFE4802488879444A4248F8798802505020485089880606
+8CD1:000079FE49004900797C4900490079FE495049527954014851484A448A520460
+8CD2:00207C20445044887D0446FA44007C0047FE44207D2801242A22242244A08040
+8CD3:01007FFE4002BFFC0910316003803FF8E0083FF820083FF820083FF808201010
+8CD4:01007FFE4002BFFC21083FF820002FF828082FF828082FF828084FF844108808
+8CD5:00287C24442444207DFE442045207CB244B444687CA801242A22242044A08040
+8CD6:00207C20445044887D0446FA44207C2047FE44207D2801242A22242244A08040
+8CD7:0020782049FC4924792449FC482078204BFE4A227A2203FE5222482088200020
+8CD8:00207810481049FE7900491049107910497C49107914011251124A108AFE0400
+8CD9:00007CFE449244927CBA449244FE7C8244BA44AA7CAA00BA28822502450A8204
+8CDA:01007FFC092015502388054009203FF8D0161FF010101FF010101FF008201010
+8CDB:082008207EFC0820FEFE145022885FF690101FF010101FF010101FF008201010
+8CDC:00007CFC448444847CFC448444847CFC444044FE7D2A024A28922522444A8084
+8CDD:00007BFE4A024A5278884904482078204BFE4820787000A851244E2288200020
+8CDE:111009207FFE40029FF410103FF820083FF820083FF820083FF8082010102008
+8CDF:00507C50445045FC7D54455445547DFC455445547D5403FE2800248845048202
+8CE0:00407C2045FC44007D08449044007DFE440044007DFC01042904250445FC8104
+8CE1:00803FFE20802FF820883FFE21082FF824102FF8341627F0441047F082200410
+8CE2:00007EFC48447E4442287E1048287FF610101FF010101FF010101FF008201010
+8CE3:0100FFFE01003FF800007FFC44447FFC10101FF010101FF010101FF008201010
+8CE4:00487C44445E45E07C284412446A7D964448445E7DE0002428282412446A8186
+8CE5:00407C2045FE44007C88448845547E22440044207DFE00202820242044208020
+8CE6:00087C0C44EA440A7C0845FE44487C48454845687D480148294A256A47868102
+8CE7:00207CA244A245247C50448847047C22442044A47CA401282850248845048202
+8CE8:01007FFC40041FF000007FFC1110250842041FF010101FF010101FF008201010
+8CE9:004078204BFE4A02780049FC480078004BFE48207928012452224C2288A00040
+8CEA:060C387020403F7E2448244844889FF010101FF010101FF010101FF008201010
+8CEB:01007FFC0920092015507FFE40029FF410101FF010101FF010101FF008201010
+8CEC:00007CFC448044F87C8044F844807FFE454045247D2801102908254445828100
+8CED:00207C2245FA44247C2847FE44207C4044FC45847E8400FC2884248444FC8084
+8CEE:01003FF80108FFFE01083FF801007FFC24885FF410101FF010101FF008201010
+8CEF:010079FE4A024DF2791249F2491279FA48044BF87810002057FE482088A00040
+8CF0:00207C2047FE44207DFC444047FE7C88450446FA7C88008828F82488448880F8
+8CF1:00007BFE4A2248207BFE482049FC792449FC492479FC002053FE482088200020
+8CF2:13F8120823F86040A7FC215022481FF010101FF010101FF010101FF008201010
+8CF3:012879244BA4492079204FFE482078244BA44AA87AA802905392482A88460082
+8CF4:10201020FE7810881110FEFC928492FCFE8410FC388454FC9200104810841102
+8CF5:00007DFE4502457A7D02457A45027C0044FC44847CFC008428FC248444FC8084
+8CF6:00207C20445044487CA445FE46847CFC448444FC7C8000FC29442544467C8044
+8CF7:01007FFC01003D7825483D7801007FFE50129FF410101FF010101FF008201010
+8CF8:00203D2424A825FC24403FFE248825FC268A3CF8248824F8248844F854508888
+8CF9:01047884488848007BFE4800488879044A0249FC79540154515449548FFE0000
+8CFA:011078A048004BFC78A04BF848A87BFE48A84BF878A001B052A84CA688A000A0
+8CFB:00287C2447FE44207DFC452445FC7D2445FC45247C0803FE2888244844488018
+8CFC:008878884BFE488879FC48884BFE782049FC492479FC012453FE490489140108
+8CFD:01007FFE44429FF404403FF80440FFFE08201FF02828CFE608200FE004400820
+8CFE:00207DFE482048FC48205DFE540054FC54845CFC488448FC48847EFC00480084
+8CFF:00007BDE48424A52794A4A52482878C44B1248607988003251C4481888600380
+8D00:7F7848485F4C64805F784A4851307F4C00001FF010101FF010101FF008201010
+8D01:7E2042207E20423E7E4442447E4424A442287E2842107E1042287E4824844302
+8D02:0040788849FC49087A524BFE485079884E2648C07B1000645388483088C00700
+8D03:0020782049FC492479FC48204BFE7A224BFE48207840002452A24A8A8C780000
+8D04:08207E2008F8FF2814287F6A082AFF5608821FF010101FF010101FF008201010
+8D05:08207F20087E7E4408A4FF2810101E2822445FF290101FF010101FF008201010
+8D06:002878244BFE4850788849044A027998495449107BBE011052A84AA88C440882
+8D07:41D42010FBFE109052C8228A57E680021FF010101FF010101FF010101FF00820
+8D08:0104788848004BFE7A224AAA4A727A224BFE480079FC010451FC490489FC0104
+8D09:00007BFE48504BFE7A524BFE480079FC490449FC790401FC50204BFE88200020
+8D0A:28503E7C4890FEFE1528264A44861FF010101FF010101FF010101FF008201010
+8D0B:3FFE225024882DFE369024FC249024FE200027FC240427FC440447FC82080404
+8D0C:00507A52495448507BFE488848507BFE482049FC782003FE5050488889040602
+8D0D:008078F849084BFE7944499249FE7900497C4900797C0100517C4A448A7C0444
+8D0E:008878884BFE488879FC492449FC792449FC48207BFE0222522A4AFA8A0A0206
+8D0F:0100FFFE20003FF800003FF820083FF8000077DC545477D4545C77D65296B462
+8D10:002079FC48244BFE782449FC48207BFE48004AA47C5201FC515449548FFE0000
+8D11:1000FEFC44202820FEFE00007CFC44847CFC44847CFC1084FEFC104810841102
+8D12:7E2051FC7D2445FC7C24514A7EF800003FF820083FF820083FF820083FF80820
+8D13:000C700A51FE550875E85548574A71EA512A5FEC754C054C55EA4A0A82160422
+8D14:3FF820083FF820083FF820083FF8082010107EFC42847EFC42847EFC24484284
+8D15:2010CEFE8A10AA7CAA00EEFEAAAAAAFEAA44AA7CEE44A87C2844487C48288844
+8D16:00207BFE482049FC78004BFE4A527BFE490449FC790401FC510449FC88880104
+8D17:3FFE224025F82D0835F8250825FE26AA240627F8240827F8440847F882100408
+8D18:012478A84BFE4A0278F8488849FC790449FC490479FC010451FC480088880104
+8D19:0E1C08107EFC4A945CB84A945CB8952A22461FF010101FF010101FF008201010
+8D1A:011078904BDE48107A5E49824BDE78104BDE4A507BDE025053DE4A508A5202CE
+8D1B:1040FE7C44C82830FECE00787C2045FC7C8844F87C8810F8FE8810F810501088
+8D1C:0090709057FE5094700A51FE550877E8514A51EA7F2A05EA554C49EA82160462
+8D1D:00001FF010101010101011101110111011101110121002800440082010102008
+8D1E:0100010001FC010001003FF820082108210821082208220804C008303008C004
+8D1F:040004000FE0102020405FF010101110111011101110121002C0042018106008
+8D20:02000400082010103FF8000800001FF01010111011101110121004C018306008
+8D21:00003FF8010001007FFC000000001FF01010111011101110121004C018306008
+8D22:00107C104410541055FE54105430543054505450549011102810241044508020
+8D23:010001007FFC01003FF80100FFFE00001FF0101011101110111002600C187004
+8D24:040025F824882450242024D8270604001FF0101011101110111002600C187004
+8D25:00407C404440548054FE55085688548854885450545010202850248845048202
+8D26:00807C8444845488549054A0548055FE54A054A054901090288824A444C28080
+8D27:08800880109830E057849084107C00001FF0101011101110111002600C187004
+8D28:007C3FC0204020403FFE2040204027FC240424442444244424B4410846049802
+8D29:00047C0E44F04480548054FC54A454A454A454A854A810902910252842448082
+8D2A:01000280044009203098CFE6004000801FF0101011101110111002600C187004
+8D2B:044008203018DFE60420042008A010403FF0101011101110111002600C187004
+8D2C:00087C3C45C044005420541055FC5404540854105420104028802540423E8000
+8D2D:00807C80448054FC5504550456445444548454A4551411F42814240444288010
+8D2E:00407C204420540055FE5502560454005400540054001000280025FE44008000
+8D2F:1FF011101110FFFE111011101FF000001FF0101011101110111002600C187004
+8D30:00280024FFFE00203FA000207FA000203FA0209024902490248A0A0A11066082
+8D31:00507C484440445C55E05440545E57E054445448543010222852248A43068002
+8D32:01003FF801000820FFFE082000001FF01010111011101110121004C018306008
+8D33:12201220FFFE122013E010001FF800001FF0101011101110111002600C187004
+8D34:00207C2044205420543E54205420542055FC5504550411042904250445FC8104
+8D35:01001FF0111011101FF00100FFFE00001FF0101011101110111002600C187004
+8D36:00007DFC450445045504550455FC5450545054505450109228922512420E8400
+8D37:08901088307ED7C01022101A00061FF01010111011101110121004C018306008
+8D38:060078FC4044484444445A94610800001FF0101011101110111002600C187004
+8D39:04407FF804483FF824403FFC0844105420085FF010101110111002C00C303008
+8D3A:100010007E7C124422442A7C44009FF01010111011101110121004C018306008
+8D3B:00207C20442054405448548455FE5482540054FC548410842884248444FC8084
+8D3C:00147C12441045FE541054905492549257F2549454941088288A251A41268242
+8D3D:10801080FBF010901990F0941154520C24041FF010101110111002C00C303008
+8D3E:00007FFC04403FF8244824483FF800001FF0101011101110111002600C187004
+8D3F:00207C2045FE5440544054FC5484558456FC5484548410FC2884248444948088
+8D40:088008882E9028E028842E84F07C00001FF0101011101110111002600C187004
+8D41:083813C03040504097FC1040104013F800001FF010101110111002C00C303008
+8D42:00407C40447854885550542054505488550654F8548810882888248844F88088
+8D43:00207C10441045FE5500551055105510557C5510551011102910261042FE8400
+8D44:0100410021FC0A441448E0A02110260C1FF0101011101110111002600C187004
+8D45:00207C10441047FE54205442548455F85410542254C413082810242840C48302
+8D46:00007CFC4484548454FC54905490548854845532550812002860241844048000
+8D47:00287C244424542055FE5420552054B254B4546854A811242A22242044A08040
+8D48:00007DFE45004500557C5500550055FE55505552555411482948264442528460
+8D49:010001007FFC11100920FFFE054009203018DFF610101110111002C00C303008
+8D4A:00207C2044505488550456FA5400540057FE5420552811242A22242244A08040
+8D4B:00087C0C44EA440A540855FE544854485548556855481148294A256A43868102
+8D4C:004000407C4445FC4448545057FE544054F85588568854F82888248844F88088
+8D4D:01007FFC0920092015507FFE400280041FF0101011101110111002600C187004
+8D4E:00207C2045FC4420542057FE5402549454505510549013FE2828244440828302
+8D4F:111009203FFC20044FE808200FE000001FF0101011101110111002600C187004
+8D50:00007CFC4484548454FC5484548454FC544054FE552A124A28922522444A8084
+8D51:1FF010101110111002C00C30700800003EF822882AA82AA82AA8145022884104
+8D52:00007DFC452445245574552455FC550455745554555411742904260442148408
+8D53:00803FFE20802FF820883FFE21082FF824102FF8341624904490416082100C08
+8D54:00407C2045FC540055085490540057FE5400540055FC11042904250445FC8104
+8D55:00207CA244A245245450548857045422542054A454A411282850248841048202
+8D56:10801080FEF8110812107DFC5504552455247D24112439245450908811041202
+8D57:00007DFE4502457A5502557A5502540054FC548454FC108428FC248440FC8084
+8D58:08207F20087E7E4408A4FF2810101E28224446829FF01010111002C00C307008
+8D59:00287C2447FE542055FC552455FC552455FC5524540813FE2888244844488018
+8D5A:00887C50440055FE545055FC545457FE545455FC545010D82954265244508050
+8D5B:01007FFE44429FF404403FF80440FFFE08201FF02928C92609200AA004401820
+8D5C:00207DFE482048FC48205DFE540055FC55045D244924492449247E5000880304
+8D5D:3FFE225024FE2D9036FC249024FC249024FE200027FC2444444440B0830C1C02
+8D5E:081028503E7C48907EFE14282548468A81061FF010101110111002C00C303008
+8D5F:41D42010FBFE109052C8228A57E680021FF0101011101110111002600C187004
+8D60:00887C48445055FC552455AC5574552455FC540054F8108828F8248844F88088
+8D61:00807CF8450847FE5544559255FE5500557C5500557C1100297C2644427C8444
+8D62:0100FFFE20003FF800003FF820083FF8000077DC54547554555C75565296B462
+8D63:1040FE7844D02920FE5801867CF844207DFC44007CF81088FEA810A810501188
+8D64:0100010001003FF801000100FFFE044004402448244444428842084011402080
+8D65:0810081008107E10083E0822FF44149014105610551095282428242454448882
+8D66:0820082008207E40087E0884FF44144414445628552895102410242854448882
+8D67:080008FC08847E8408940888FF8014FC14A456A455A894A8249024A854C48882
+8D68:0810081008107EFE08920892FF92149214FE5692551095142412241E54F28800
+8D69:0820082008787E480890087CFF5414541454567C5540954024422442543E8800
+8D6A:08100810081E7E10081008FEFF82149214925692559294922428242454428882
+8D6B:0820082008207EF808200820FEFE1450145056D8555494522450249054908930
+8D6C:08200820083E7E20082008FCFF8414FC148456FC558494FC2400244854848902
+8D6D:0820082408F47E28082808FEFF101420147C56C45544957C24442444547C8844
+8D6E:100011DC11447D44114411DCFF00290029DC6D14AB1429D42908490849149922
+8D6F:1020101011FE7D10117C1114FDFE2914297C6D10AB7C294429444A444A7C9C44
+8D70:0100010001003FF801000100FFFE01000100110011F811001100290047FE8000
+8D71:010001003FF8010001000100FFFE00002010102000C003000C00130020FE4000
+8D72:0820082008207E2008FC0824FF240824282428442E442894290858004FFE8000
+8D73:0804080408447E4408440844FF44084C285428642E042804280458004FFE8000
+8D74:0420042004203F20043004287FA404240420242027A02420242054004FFE8000
+8D75:0800080408847E4408280828FE100810282828282E442884280058004FFE8000
+8D76:080008FC08207E2008200820FE2009FE282028202E202820282058204FFE8000
+8D77:0800080008F87E0808080808FEF80888288028802E842884287C58004FFE8000
+8D78:0810081008107E1008920892FE920892289228922E9228FE280258004FFE8000
+8D79:0820082008407EFE09020842FE220822280A28322EC22802281458084FFE8000
+8D7A:0820082008507E5008880944FE2208F8280828102E102820282058004FFE8000
+8D7B:0810081008107E5408520852FE900812280428082E102860298058004FFE8000
+8D7C:0420042004203F3E044204047F9004100410242827A42442248254004FFE8000
+8D7D:0820082008207EFC08240824FE2409FE282028502E482884290458004FFE8000
+8D7E:0800080C08707E400840087EFF480848284828482E882888290858004FFE8000
+8D7F:1004101E11F07D1011101110FDFE1110111051105D10514A5186710250008FFE
+8D80:0810081008167EF808900890FEFE0812283228522E962910281058104FFE8000
+8D81:0820082008507E5008880924FE420890282028442E882810282058404FFE8000
+8D82:0840084008407EFE08820924FE2008A828A429222E2228A0284058004FFE8000
+8D83:082008A008A07EFC08A00920FE2009FE282028502E482884290458004FFE8000
+8D84:080008F808887E8808F80888FF8808F8288828882E8829FE280058004FFE8000
+8D85:080009FC08447E4408440894FF0808FC288428842E8428FC280058004FFE8000
+8D86:0800081C08F07E90089008FEFE900890289028AA2ECA28A6281258004FFE8000
+8D87:0820081008107EFE08040844FF440828282828282E1028FE280058004FFE8000
+8D88:0820082008207E3E08200820FF2008FC288428842E8428FC288458004FFE8000
+8D89:0810081008927E92089208FEFF100892289228922E9228FE280258004FFE8000
+8D8A:1028102410207DFC11201124FD241128112851105D94512C704450004FFE8000
+8D8B:0840084008787E88091008FCFE04080428FC28042E0429FC280058004FFE8000
+8D8C:0810081008107EFE0810087CFF00087C284428442E44287C284458004FFE8000
+8D8D:10201020107C7C8813501024FCC8131E102250E45C1850105060738050008FFE
+8D8E:0810085008507EFC09100810FEFE0830283828542E942910281058004FFE8000
+8D8F:081C08E008207E2009FE0820FE2008FC288428842E8428FC288458004FFE8000
+8D90:080009DC08447E44095408CCFE4408CC295428442E44285428C858004FFE8000
+8D91:1020122011207D3E10421084FC901090131051105D2851245142708250008FFE
+8D92:0810085008507E50095408D8FE5008D8295428522E922892290E5A004FFE8000
+8D93:100010F810887C8810881088FD26122011FE50205C7050A85124722250208FFE
+8D94:100213F210827C8A108A11EAFD2A112A12AA504A5C4A5082510A720450008FFE
+8D95:0800087C08447E7C0844087CFF00087C281028102EFE2810281058104FFE8000
+8D96:0810081008547E54085408BAFF100810287C28102E1028FE280058004FFE8000
+8D97:080008F808887E88088808F8FE2008A028BC28A02EA029602A3C58004FFE8000
+8D98:080008FE08827EFE0880088CFEF0089C28F0289E2EF02912290E5A004FFE8000
+8D99:0810089208547E1008FE0882FEFE088228FE28822E82288A288458004FFE8000
+8D9A:0820082009FE7E20082009FCFF24092429FC28702EA829242A2258204FFE8000
+8D9B:0820082008507E8809040AFAFE20082029FC28202EA828702BFE58004FFE8000
+8D9C:0880088009FE7E2208AA0872FE2209FE282228722EAA2922282A58044FFE8000
+8D9D:1020102010507C8811441222FDF81008105050205CA4528A528A747850008FFE
+8D9E:0848084808FC7E48084809FEFE0008FC288428FC2E8428FC288458004FFE8000
+8D9F:1020112410A47CA811FC1104FD041174115451545D745104710C50004FFE8000
+8DA0:10201020103E7C2011FC1104FDFC110411FC51245C2053FE5020702050208FFE
+8DA1:0850084808807EFE09900A90FEFC0890289028FC2E90289028FE58804FFE8000
+8DA2:11F8100810F87C0813FE1020FC24112410A850705CA85324502470A050408FFE
+8DA3:100013E0115E7D4211D2114AFD4A11C4114451645DCA534A705250404FFE8000
+8DA4:0820081008FE7E82080008FEFF20084028FC29442E44287C284458004FFE8000
+8DA5:1088105013FE7C50105011FCFD54118C110451FC5D04510451FC710450008FFE
+8DA6:1220113E10427C9413101128FC46100011FC51045D04510451FC710450008FFE
+8DA7:080008FC08847EFC088408FCFE0009FE2810289C2E902890297E5A004FFE8000
+8DA8:108011FC12447D5411F41084FD18108011FC52445D5451F45084711850008FFE
+8DA9:100011FC11247DFC112411FCFC88108811FC50885C8853FE5088710450008FFE
+8DAA:1088108811FC7C88108813FEFC2011FC112451FC5D2451FC5000708851048FFE
+8DAB:103C13C010407BFE10901108FAF4149213FC52045AF4529452F4720C50008FFE
+8DAC:0810087C08107EFE084408EEFE4408EE280028FE2E28282A284658804FFE8000
+8DAD:10A0109011FE7D2013FC1120FDFC1120112051FE5C0052A45252745250008FFE
+8DAE:0800087C08447E7C080008EEFEAA08EE281028FE2E382854289258104FFE8000
+8DAF:080009EE08AA7E6608AA0850FEFE099028FC28902EFC289028FE58804FFE8000
+8DB0:100013FE11247A2217FE1376FAAA1376122253765AAA53765222720650008FFE
+8DB1:1108152817BE794817BE1318FDAA194613F852085A48524850A0711052088FFE
+8DB2:152817BE19487FBE131815AAF94613FC120453FC5A0453FC520473FC51088FFE
+8DB3:00001FF010101010101010101FF001000100110011F811002900250043FE8000
+8DB4:00007C204520452045207D20112011205D205110511052105E08E40808041002
+8DB5:00407C40444044FC44847D04100411045C845044504450045C04E00400280010
+8DB6:00007DFC4420442044207C20102013FE5C205020502050205C20E02000A00040
+8DB7:00407C40448044FE45007E0010FC10085C105020504050805D02E10200FE0000
+8DB8:0000FFFE040007F0081010A0604000001FF010101FF0010011F81100290047FE
+8DB9:00207C20442045FC44247C24102410245DFE5020505050505C88E08801040202
+8DBA:00207C204420442045FC7C20102010205DFE5020505050505C88E08801040202
+8DBB:00207C204450445044887D44122210205C0051FC500450085C08E01000100020
+8DBC:00007DFE4448444844487C48104813FE5C485048504850485C88E08801080208
+8DBD:00407C20442047FE44807C80108010FC5C845084508450845D04E10402280410
+8DBE:00207C204420452045207D20113C11205D205120512051205D20E12007FE0000
+8DBF:00007BFC4884488848887890109C108451445D44512851285A10E22804440182
+8DC0:00007CFC4484448444847CFC108410845C8450FC508450845D04E10402140408
+8DC1:00007DFC4524452445247D24112411FC11045D005100510051025D02E0FE0000
+8DC2:00207C20442045FE44207C20102011FC5C845088504850505C20E05001880606
+8DC3:00087C3C45E0442044207C2013FE10205C205050505050505C88E08801040202
+8DC4:00207C204450445044887D04120210F85C88508850A850905C82E082007E0000
+8DC5:00087C1C45E0450045007D0011FE11105D105130511851145D12E21002100410
+8DC6:00207C204440444044887D0413FE100210005DFC5104510451045D04E1FC0104
+8DC7:00487D484548454845487FFE114811485D485148517851005D00E10001FE0000
+8DC8:00207C204450448845047E121020104011885C105020504451885C10E0600380
+8DC9:00207C204450445044887D24121210105DFC5004500850885C50E02000100010
+8DCA:00207C20442045FC44207C20102013FE5C7050A850A851245D24E22200200020
+8DCB:00507C484448444047FE7C80108010FC5D445144512851285E10E22804440182
+8DCC:00207C204520452045FC7D201220102011FE5C205050505050885C88E1040202
+8DCD:00207C204420442047FE7C201020102011FC5D045104510451045D04E1FC0104
+8DCE:00207C10441045FE45027E04108010885C9050A050C050825C82E082007E0000
+8DCF:010079004900491C4BD479541154115451545D54515451545954E25C03540480
+8DD0:00487C4844484548454A7D6C114811485D4851485148514A5D6AE38A01060000
+8DD1:00807C8045FC450446047DF4111411145D1451F4510451285D12E10200FE0000
+8DD2:00007C0045FE440844087DE81128112811285D2851E8512850085C08E0280010
+8DD3:00407C20440047FE44207C20102010205DFC5020502050205C20E02003FE0000
+8DD4:00807C80450045FC46047C0411E411245D24512451E451245C04E00400280010
+8DD5:00207C2044204420443E7C201020102011FC5D045104510451045D04E1FC0104
+8DD6:00007C0045FE442044207C40104010FC10845D845284508450845C84E0FC0084
+8DD7:0088788848884908497E7B081508114851285D28510851085908E10801280110
+8DD8:00207C20452444A444A87C2011FC10205C20502053FE50205C20E02000200020
+8DD9:00007DF84508450845087DF8110811085D0851F8510851085D08E10807FE0000
+8DDA:00007DDC4554455445547D54115413FE5D545154515451545D54E2D40224044C
+8DDB:00107C10441045FE45127D14111011FC5D445144512851285D10E22802440482
+8DDC:00007DFC4504450445047DFC110011405D445148517051405D42E242023E0400
+8DDD:00007DFE4500450045007DFC110411045D04510451FC51005D00E10001FE0000
+8DDE:00087C1C45E0450045207D20112011FE5C20502050A850A45D22E22200A00040
+8DDF:00007DF84508450845F87D08110811F85D445148513051205D10E14801860100
+8DE0:00207C2047FE442045FC7C2411FC112011FE5C22502A505450505C88E1040202
+8DE1:00407C20442047FE44907C90109012945E925292549250905D10E11002500420
+8DE2:00207C20447C448445487C30102010485D90503E504251A45C18E01000600180
+8DE3:00207920492049FC49207A20102013FE50905C90509050905912E1120212040E
+8DE4:00407C20442045FE44007C881104120210885C885050505050205C50E0880306
+8DE5:00007DFC44444448445E7C82108A11245C2053FE502050705CA8E12402220020
+8DE6:00207D20452045FC45207E20102013FE5C7050A850A851245D24E22200200020
+8DE7:00207C204450448845047E0211FC10205C20502051FC50205C20E02003FE0000
+8DE8:002078204BFE48504888790416FA100053FE5C40508051FC5804E00400280010
+8DE9:00207C2045FC452445247DFC112411245DFC5020502450185C32E0CA03060002
+8DEA:00407C4044FC450446087DFE1100117C5D445144515451485D42E242023E0400
+8DEB:00007DF01110119011521D12E20E44001FF010101FF0010011F81100290047FE
+8DEC:00207C2045FC442044207C2013FE10005C20502051FC50205C20E02003FE0000
+8DED:0080788048FC49084A9078601198162610205DFC5020522053FE5C20E0200020
+8DEE:00007DFE4420444044887D0411FE10225C20502051FE50205C20E02003FE0000
+8DEF:00407C404478448845507C201050108811065CF85088508850885C88E0F80088
+8DF0:01047C844488440045FE7C88108810885C8853FE508850885D08E10802080408
+8DF1:00207C20442045FC44207C2013FE100810085DFE5008508850485C08E0280010
+8DF2:00207C204450448845047E0211FC100010005DFC5104510451045D04E1FC0104
+8DF3:00507C504450455244D47C581050105810D45D525050505050925C92E112020E
+8DF4:00007BFE48504850485079FC115411541D545154515C518451045D04E1FC0104
+8DF5:00507C484440445C45E07C40105E11E05C445048503050225C52E08A03060002
+8DF6:00107A104910491048FE78101310112851245D44514251825900E280047E0000
+8DF7:00807C8044BC47C044507C2410D4130C5C0053FE509050905D12E112020E0400
+8DF8:01107D12451445D845107D121152118E11205C2053FE502050205C20E0200020
+8DF9:00007A0C497049104810781010FE171051105D10511051105910E280047E0000
+8DFA:00007CF84488448844887C88112612205DFE5020507050A85D24E22200200020
+8DFB:00407C2045FE448844507C201050108811065C885088508850885D08E1080208
+8DFC:00007DFC4504450445FC7D00110011FE5D02517A514A514A5E7AE20204140008
+8DFD:00007DF84408440845F87D00110411045CFC5040502050A45E8AE28A04780000
+8DFE:1040104024FE6488A5502420245020881FF410101FF0010011F81100290047FE
+8DFF:00207C2045FC442044207C2013FE10205C205120513C51205EA0E260043E0800
+8E00:00007DFC4504450445047DFC102010205D20513C512051205EA0E260043E0800
+8E01:00007DFE4400449245247E481124109210005DFE5020502050205C20E3FE0000
+8E02:00007BFE49204928492879E81128112851285DE85128512A593AE3EA00260020
+8E03:00207D2444A444A844207DFC110411045DFC5104510451FC5D04E10401140108
+8E04:00107C104490449E44907C9013FE10005C105092509251145E08E01000600380
+8E05:080C08F07E8008800EFE78880888290812081FF010101FF0010011F83100CFFE
+8E06:00407C404488450447FE7C021088114412425CF85188525050205C50E1880606
+8E07:00807C8044FE450046FC7C8410A410945DFE5084512451145DFEE00400280010
+8E08:00207C2047FE442044207DFC112411245DFC5020507050A85D24E22200200020
+8E09:00407C2045FC450445047DFC1104110411FC5D205122511451085D44E1820100
+8E0A:00007DF8440844D044207DFC112411245DFC5124512451FC5D24E1240124010C
+8E0B:0100F100911E93929112F112211227D2A112B912A21AA294A7D0B250C0100010
+8E0C:00207C2047FE442045FC7C4013FE10485C8850FE510851485E28E40800280010
+8E0D:00207C2245FA442444247DFE1010102011FC5C88511052FE54105C10E0500020
+8E0E:00007DFE4410442044687CA41122102010005CFC5084508450845C84E0FC0084
+8E0F:002078224BB448A848A8792412A2104051FC5D04510451FC5904E10401FC0104
+8E10:00487C44445E45E044287C12106A119610485C5E51E0502450285C12E06A0186
+8E11:00887C8847FE448844887CF8108810885CF85088508853FE5C00E08801040202
+8E12:001C7DE04420442047FE7CA8112412425C4053FE508851085CD0E03000480184
+8E13:00A07C90449045FE45207D2013FC112011205DFC5120512051205DFEE1000100
+8E14:00207C20443E442045FC7D0411FC11045DFC5124502053FE5C20E02000200020
+8E15:00207C2047FE442045FC7C2413FE10245DFC50205120513E5D20E2A0027E0400
+8E16:00487C48444845FE44487C4811FE100010FC5C84508450FC50845C84E0FC0084
+8E17:00207C204450448845447E2211F810085C50502050A452825E8AE28A04780000
+8E18:01007D0045FC460444447D5410E4104413FC5C4450E4515452445C44E0140008
+8E19:00007BE0495C495449D47954115411D451545D54516853C85848E05400540062
+8E1A:00207C204450448845047EFA100011FC11545D5451FC515451545D54E104010C
+8E1B:00207C2045FC442044207DFE108811045E22502051FC50205C20E02003FE0000
+8E1C:0020782049FC482048207BFE1088114412425CF85188525050205C50E1880606
+8E1D:00007DFC4524452445FC7D24112411FC10205DFE507050A851245E22E0200020
+8E1E:00007DFE4502450245FE7D10111011FE5D105110517E51425D42E242027E0442
+8E1F:0100790049004BDE4A927C921092109253F25C9250925152595EE22004200800
+8E20:004078204BFE4A024D04790011DE12521E525352549A509451105D12E212040E
+8E21:00207D2444A8442045FC7C4013FE10885D0452FA548850885CA8E0920082007E
+8E22:00007CFC4484448444FC7C84108410FC5C4050FE512A524A5C92E122004A0084
+8E23:00407C2045FC440045087C90100013FE10005C0051FC510451045D04E1FC0104
+8E24:00407C2045FE440044887C881154122210005C2053FE502050205C20E0200020
+8E25:00407C2045FC440044887C5013FE10405C4053FE508851885C50E03000C80304
+8E26:00207C2045FC445044887D0413FE10085DE85128512851E85D28E00800280010
+8E27:00807C80449C44F444947C9413F4101410945C9451C852A850885C94E09401A2
+8E28:008878884888488849547A221442102050205D20513C51205AA0E260043E0800
+8E29:00087C3C45C0444445247CA8108010205DFE507050A850A85D24E22204200020
+8E2A:004078204BFE4A024C0479F81000100053FE5C20512851245A22E42200A00040
+8E2B:01087C90440045FC44907C901092129211945D985090509050905C90E3FE0000
+8E2C:001C7DE04510451045FE7D101110117C5D445154515451545D54E22802440482
+8E2D:00807C8044F8450846107DFC102410245DFE5024502451FC5C24E02000A00040
+8E2E:00207C1045FE450045207D20113C11205D20517C514451445D44E244027C0444
+8E2F:0440F25E9292901297D4F11421182114A7F2B912A112A11ABA94E25004500810
+8E30:00207C504488450446FA7C0011E2112A5D2A51EA512A512A5DEAE122012A0164
+8E31:00407C2045FE454845487DFE114811785D0051FC514451485D28E210022804C6
+8E32:00087C1C45F0451045107DFE1110117C5D44517C5144517C5D44E244027C0444
+8E33:00207C2047FE442045FC7C4013FE10885D0452FA508850885CF8E088008800F8
+8E34:00007DFC4448443045FC7D2411FC11245DFC5124504051FC5C44E08401140208
+8E35:00087C3C45E0442047FE7C2011FC11245DFC512451FC50205DFCE02003FE0000
+8E36:00007DFC4504450445FC7D04110411FC5C0053FE502051205D3CE12002A0047E
+8E37:00207C2245FA442444287FFE1020104010FC5D84528450FC50845C84E0FC0084
+8E38:00887C8847FE448844F87C8810F810885C8853FE510051485D84E10001FE0000
+8E39:00207D244524452445FC7C0013FE10205C4051FC515451545D54E1540154010C
+8E3A:001078104F7C491449FE7A14127C1710517C5D1055FE52105A10E50008FE0000
+8E3B:00007CFC4484448444F47C94109411FE5D02517A514A514A5D7AE102010A0104
+8E3C:00007CFC448444FC44847CFC100011FE5C8050FE512A524A5C92E12200540088
+8E3D:00047C1E47E0442045FC7D24112411FC5C2053FE5222522A5EFAE202020A0204
+8E3E:00007DFE440044FC44847C8410FC100011FE5D22512251FE51225D22E1FE0102
+8E3F:000878C84B084908492A792A13AC11481D0853885554511451145D24E1240142
+8E40:00487D48454847FE45487D48117811005DFE502053FE50705CA8E12406220020
+8E41:00407C2045FE450245027DFE110011005DFE51AA51AA52FE5EAAE2AA04A20086
+8E42:00007DFC4448443047FE7C52109411105E30502053FE50705CA8E12406220020
+8E43:00887C8847FE448844A87C2013FE104010805CFC5184528450845C84E0FC0084
+8E44:00407C2045FC440044887C5013FE12225C2451FC512451245D34E12800200020
+8E45:00207C2047FE447044A87D24122211FC5D0451FC510451FC5D04E00003FE0000
+8E46:00007A7C49444944487C78441744117C11505D4A5144515451625D42E280047E
+8E47:01007FFE44429FF404403FF80440FFFE08201FF02828CFE6010009F0150023FC
+8E48:001E7DE04422451244947C80102011CE11025D0251CE510251025D02E1FE0102
+8E49:00847C44444845FE44207CFC102011FE5C40508050FE51105E10E41001FE0000
+8E4A:001E7BE0492248944840788811F0102050C45DFE502250205BFEE05000880306
+8E4B:00007DFC450445FC45047DFC1000100013DE5C425252514A52525C42E14A0084
+8E4C:00207C204450444844A47DFE128410FC5C8450FC508050FC5D44E144027C0044
+8E4D:00007BFC4A044A044BFC7A48124812FC12485E4853FE52A452A85C90E4C80886
+8E4E:00207C2047FE442045FC7D0411FC110411FC5D0451FC510453FE5C88E1040202
+8E4F:0004781E4BF04A1E4A107AFE1292129852F25E8E528052B85AA8E4AA054A0A86
+8E50:00207D2444A8455444887D0412FA148810885CF85088508850F85C88E0880098
+8E51:00007DFE448444FC44847CFC108613FC5C0453DE505251525C94E14802540422
+8E52:00487C4845FE444844007DFE104810485DFE514A514A51B65D22E102010A0104
+8E53:00407DBC4514459445547DA4114C100011FC5D24512451FC51245D24E1FC0104
+8E54:08047F7808403E402A7E3E482A48FF4808881FF010101FF0010011F83100CFFE
+8E55:00007DFC452445FC45247DFC10A810A85DFE50A850A851FC5C20E3FE00200020
+8E56:00207C2047FE442045FC7C4013FE10885D045242559C51045DDCE10401FC0104
+8E57:004078204BFE4A504A507BFE1252125253FE5E00529252D45A98E49204D2088E
+8E58:00007BDE48424A52494A7A52102810C453125C605188503259C4E01800600380
+8E59:00243FFE222023A422243FA82B10529A46269FF210101FF0010011F83100CFFE
+8E5A:0020792448A84BFE4A0278F8108810881CF85020502051FC50205C20E3FE0000
+8E5B:02A8F2A897FC92A892AAF4E6280027FCA444B840A3F8A248A248B248C2580040
+8E5C:002078104BFE4A02488078FE111013201D7C51445144517C51445D44E17C0144
+8E5D:010879084A284CAE48A87928137E15001D085128512E512851585D48E1860100
+8E5E:000078FE48104A204A7C7A4413C4127C52445E7C52C453445A7CE02800440082
+8E5F:00207BFE482049FC48207BFE100011FC1D0451FC510451FC51045DFCE0880104
+8E60:004078204BFE4A004A487A4813FE124852485E48527852005D54E52A0A2A1000
+8E61:00487D48455E456A45547DC81050106413C45D7E5144516451545D44E2540448
+8E62:004078204BFE488848507BFE122212FA52225EFA528A528A5AFAE202020A0204
+8E63:00887C8847FE448844887CF8102013FE5E22533252AA53765E22E222022A0224
+8E64:012479244A244CA44954794A1392150811085D28512E512851285D58E14E0180
+8E65:00107C1046FE4510457C7C54107C13545D7C511051FE51105D10E290047E0000
+8E66:00207A224A224BFE48007BDE1252125253DE5E52525253DE5A52E252055A08A4
+8E67:009078904FFE48904BFC7A9413FC129453FC5C0051F8510859F8E10801F80108
+8E68:0110791449D24A504A7E7D50109012A851285D44524454825808E2A402520452
+8E69:49202A3E7F4849485DA86B10492841461FF010101FF0010011F81100290047FE
+8E6A:002079FC492449FC48207BFE100011FC11045DFC510451FC51045DFCE0880104
+8E6B:000079FC484848304BFE7852109413501C2053FE5252528A53765E52E2720206
+8E6C:00107BD248544948488A790412FA140051FC5D04510451FC5904E08807FE0000
+8E6D:0104788848004BFE4A227AAA1272122253FE5C0051FC510459FCE10401FC0104
+8E6E:00007DFC445045FC45547DFC102013FE5C48508451FA52885CF8E0840084007C
+8E6F:003C7DE0452444A845FE7CA8112412025DFC5124512451FC5D24E12401FC0104
+8E70:00007BFE4A004A044BF47A0412EE12A452A45EEC520452A45A44E27405940008
+8E71:00207DFC4488445047FE7C0011FC11245DFC512451FC50205DFCE02003FE0000
+8E72:008878504BFE485049FC7954118C117451045DFC500853FE5908E08800A80010
+8E73:00247BA848924D144A087C0413BA10A81CC65380523C538450A85C90E2A80144
+8E74:0214F1129FD29010907EF79024902490A790B928A5A8A568A928B14AC54A0286
+8E75:08287F2400FE3E2022503E504952988E00001FF010101FF0010011F83100CFFE
+8E76:0000F7FE940096289548F7EE24922484A6A0BEA8A7E8A488BC94E51409241242
+8E77:3FFE289025103FDE22222A882F88229424222BF8220823F82040427C454088FE
+8E78:0020792448A84BFE48A879241222110411045DDE52445554509E5D04E2040404
+8E79:00207C504488457446027CF8108810F810005DDC5044515450CC5D54E04400CC
+8E7A:0020782049FC48204BFE7908139C11081D88563E500053FE50905C90E112020E
+8E7B:00187DE0444047FE44887D741252107010005DFC5104517451545D74E104010C
+8E7C:00507A52495448504BFE7888105013FE50205DFC502053FE5850E08801040602
+8E7D:00207C2045FC442045547C88110412FA10885CF8508850F850205CA8E1240060
+8E7E:010878884BC848104BDE7A6413D4101413D45C54509450E853885C94E2940122
+8E7F:004078204BFE4A8A49247A2211FC112451FC5C2053FE52225BFEE22200200020
+8E80:00007DFC452447FE45247DFC100011FC5D0451FC510451FC5D04E1FC00880104
+8E81:00F87C88448844F844007DDC115411545DDC502053FE50705CA8E12402220020
+8E82:00107A10497C481048FE7844132811FE11105D7C511051FE51105D10E2FE0400
+8E83:001078084BC84A7E4A407A5413C8127E52085FC8537E55485D48E5C809480008
+8E84:3E1022FE3E4420287EFEA2103EFC221000001FF010101FF0010011F83100CFFE
+8E85:00007DFC4554455445FC7C8011FC124411F45D54515451F450445DF4E0140008
+8E86:0040787C48404BFE4A427A7813C4123C1E0053FE524053A452585DB4E45209B0
+8E87:008878884BFE48A8482279FA1024102853FE5C4050FC51845AFCE48400FC0084
+8E88:008879084BC84A504BDE7A6413D4111450945FF4511451C85948E254035404A2
+8E89:0820FFFE08201FF011101FF011107FFC41245FFC10101FF0010011F83100CFFE
+8E8A:00207BFE482049FC48007BFE100211FC1C2053FE500053FE50045FBEE2A4038C
+8E8B:0080F04097FC911090A4FF5825542552AB58B800A208A3F8BA08E3F802080408
+8E8C:008079004BFE4D5449547BFE1154115413FE5D0451DE524451545C9EE1040204
+8E8D:00007BDE48424A52494A7A521090110813FE5D1051FE511051FE5D10E1FE0100
+8E8E:0000F7FC924894449FFEF44426EC2554A6ECBC44A6ECA554A6ECB444C4540408
+8E8F:00487DFE4448450044BE7C821152117E11D25D7E5152517E51525D7EE1420106
+8E90:01247A48492448004BFC7A941264129413FC5E4853685248536A5E4AE2460362
+8E91:0440F28E9FEA928A9FEAFAAA2C6C2BAAA82ABFEAA10AAFEAA28CB448C8280008
+8E92:012479744A584ADA4BFE795412DA13FE10A25C2053FE507050A85D24E2220020
+8E93:00427B9C4A104BDE4A947A94142013FC52045FFC520453FC5A04E3FC01080204
+8E94:0020F7FE940095FC9524F5FC252425FCA420BDFCA420A7FEBD24EAFA082013FE
+8E95:004078204BFE4A444BF47A4412EE120452F45EAC52E452145AA4E47405940808
+8E96:01107A124BAA493A4A927BBA108A13FE1D12521253AA513A52925FBAE08A03FE
+8E97:22004F9C94802FDE6108AFC8250827D801001FF010101FF0010011F83100CFFE
+8E98:011078904BDE48104A5E798213DE101013DE5E5053DE525053DE5E50E25202CE
+8E99:03DE7A524BDE4A524BDE7A22129212FA1FA252FA52A252FA52A25EFAE2820206
+8E9A:0000F0FE942892FE92AAF0FE201021FEA644BAFEA344A27CBA42E23E050008FE
+8E9B:22004F9C94802FDE6208AFC82A482AD800001FF010101FF0010011F83100CFFE
+8E9C:0108F52897BE994897BEF31825AA2946A000BBF8A208A248BA48E0B001080604
+8E9D:03DE7A524BDE4A524BDE7A2212FA122252FA5EAA52FA52AA5AFAE27202AA0226
+8E9E:0248F2E8930896EA9A1CF2E8220822E8A5B4B8E2A000A3F8B910E0E003180C06
+8E9F:00207BFE480049DC495479DC108813FE1C8853FE508853FE50945D88E2A400C2
+8EA0:0820FFFE28207DFC44887DFE40207DFC44207FF010101FF0010011F83100CFFE
+8EA1:03FCF10891F8910891F8F10E27F82008A7FEBA94A39CA294A39CB2D6C7BC0084
+8EA2:079EF492979E949297FEF51225F22512A5F2BC02A7BAA6AAA59AB6AAC59A0406
+8EA3:03DE7A524BDE4A524BDE7A5213DE109011FE5D1053FE551051FE5D10E1FE0100
+8EA4:0108F7FE910890009114F7BE21142794B17EAF80A13EA3A2B57EC922013E0122
+8EA5:0040F7FE949291089080F31C2204239CA204BBFCA248A368A248B36AC2460362
+8EA6:0528F7BE994897BE9318F5AA294623FCA204BBFCA204A3FCBA04E3FC01080204
+8EA7:03DE78004BDE4A524B5A7A52102013FE1E5053FE525253FE52925EDCE29204CE
+8EA8:0110F7FE904092EE92AAFBEA2AAE2AE8ABAABCE6A288A5F4A290B060C1980606
+8EA9:03DE7A524BDE4A524BDE78A011FE132015FC5D2051FE500051FC5C88E070078E
+8EAA:00887BFE48884BDE4A527BDE125213DE124A5EFE539252FE52925EFEE2820206
+8EAB:020004001FF010101FF010101FF2101410187FF00050009003101C10E0500020
+8EAC:080010FC3E0422043E04227C3E4022402280FEFC06040A04120422044A280410
+8EAD:102020207C2045FE7D2246247C2044204450FC500C5014502490449295120A0E
+8EAE:101020507C5044507C8844887D0446FA4448FC480C4814482488448895280A10
+8EAF:100021FE7D0045047D4445287D2845104510FD280D2815442584450095FE0800
+8EB0:102020207C2044207DFE44707CA844A84524FD240E2214F82420442094200820
+8EB1:100021FC7C4444487C5E44827C8A45244420FDFE0C20147024A8452496220820
+8EB2:100020F87C8844887C8844887D26462045FEFC200C7014A82524462294200820
+8EB3:0800107C3E4422443E4422443E7C22002200FEFE06820A82128222824AFE0482
+8EB4:082010103EFC22843E8422FC3E84228422FCFEA206A40A98129022884AC40482
+8EB5:100021FC7C2444A47CA445247C54444844A0FC100C5415422542454A96380800
+8EB6:100021FC7D2445247DFC45247D2445FC4420FDFE0C7014A82524462294200820
+8EB7:101C21E07C2044207FFE44A87D2446424440FFFE0C88150824D0443094480984
+8EB8:102020207DFC44507C8845047FFE440845E8FD280D2815E82528440894280810
+8EB9:108020807CFE45027E2244AA7C72442245FEFC220C7214AA25224422940A0804
+8EBA:102021247CA444A87C2045FC7D0445044574FD540D5415542574450495140908
+8EBB:104020207DFE45027E0444507C8845044400FDFC0C2014202420442097FE0800
+8EBC:100020FC7C8044F87C8044F87C8047FE4540FD240D2815102508454495820900
+8EBD:100023FE7A004AFC7A844AFC7A844AFC4A20FBFE1A482AC84A308A482A8413FE
+8EBE:108420487DFE44207C2044FC7C20442045FEFC000C2015FE2420445094880B06
+8EBF:1020201079FE4910797C491479FE4914497CF9101992295449388A542A921430
+8EC0:100023FE7A004A7C7A444A447A7C4A004AEEFAAA1AAA2AAA4AEE8A002BFE1000
+8EC1:102021FC7D2447FE7D2445FC7C2045FC4524FDFC0C4017FE248845D094700B8C
+8EC2:1048216A7CDC44487CB445227DFE45024420FC200CFC14242444444494940908
+8EC3:100021DC7D5445547DDC44007DFC452445FCFD240DFC142027FE442094200820
+8EC4:111020947BD248127A5049907FFE48104BD2FA521A542BD44A4A8A4A2BD61022
+8EC5:100023FE7A004A587A544ABE7BA84AE84ABEFAA81AA82ABE4AA88AA82ABE14A0
+8EC6:105021FC7D5445FC7D5445FC7C0045FC4400FDFC0D0415FC2488445097FE0800
+8EC7:102023FE782049FC78004BFE780249FC4820FBFE18002BFE48048BBE2AA4138C
+8EC8:104020207BFE4A547A7E4AA87BBC4AA84ABCFAA81ABE2AA04A548B422D4A1238
+8EC9:102023FE7A1249DC78A849DC78AA4BFE4800F9FC190429FC490489FC28881104
+8ECA:010001007FFC01003FF8210821083FF8210821083FF80100FFFE010001000100
+8ECB:08200820FFA008207F20492049207F20492049207F200822FFA20822081E0800
+8ECC:108010801080FC8013F07C9054907C9054907C901090FE9211121112120E1400
+8ECD:00007FFE410281043FF801001FF011101FF011101FF00100FFFE010001000100
+8ECE:01007FFC01003FF821083FF821083FF80100FFFE01003FF8200820083FF82008
+8ECF:1000100013FCFC9010907C9054907C9054907C901090FE9211121112120E1400
+8ED0:100011F01090FE9010907C9054907DF054907C901090FE92108A108A10861082
+8ED1:102010201020FE2010207DFE54207C2054207C501050FE501088108811041202
+8ED2:0800087C0810FF1008107F1049107F7E49107F100810FF100810081008100810
+8ED3:1000100010F0FE9010907C9054907CD054B07C901090FE9210921112110E1200
+8ED4:1000100011FCFE2410247CA454A47CA455247C241024FE441044108411141208
+8ED5:102010201020FC2011247D2455247D2455247D241124FF24112411FC10041000
+8ED6:1000100011FCFE2010207C2054207C2055FC7C201020FE201020102013FE1000
+8ED7:100010F81088FE8810887D0656007DFC54847C841048FE501020105010881306
+8ED8:102010201020FDFE10207D2455247D2455247DFC1024FE2010221022101E1000
+8ED9:102010201020FE3E10207C2054207DFC54847C881048FE501020105011881606
+8EDA:102010201020FE2010207DFE54207C2054207C501050FE50108810C811241202
+8EDB:100011FE1100FD0011787D4855487D4855487D681150FD4211421142123E1400
+8EDC:102010201020FDFE11227D2255227D2255527D4A118AFF0211021102110A1104
+8EDD:1004101E10F0FE9010907C9054907CFE54907C901090FE88108A10AA10C61082
+8EDE:1008101C10E0FE2010207C3C54E07C2054207C3E11E0FE20102410241024101C
+8EDF:104010401040FE7C10847C8855207C2054207C501050FE501088108811041202
+8EE0:1008103C11E0FE2010207C2054207DFE54207C201020FE201020102011FC1000
+8EE1:102010201050FE5010887D4456227C2054007DFC1004FE081008101010101020
+8EE2:1000100010FCFE0010007C0055FE7C2054207C401040FE88108411FE10821000
+8EE3:01007FFC01003FF821083FF821083FF80100FFFE0100600C183006C01830600C
+8EE4:1008103C13E0FC2011247CA454A87C2057FE7C201020FE201020102010A01040
+8EE5:104010401040FEFC10847D0454F47C9454947C941094FEF41094100410281010
+8EE6:100011FC1104FD0411047D0455FC7C5054507C501050FE9210921112120E1400
+8EE7:1004101E10F0FE9010907C9054907CFE54907C901090FE88108A10AA10D6108A
+8EE8:102010201050FE5010887D2456127C1055FC7C041008FE881050102010101010
+8EE9:102010201020FE4010487C8455FE7C8254007CFC1084FE841084108410FC1084
+8EEA:201020902090F910217EFA52AB92F892A912F9122252FBD220622022204A2084
+8EEB:102010201050FE8811047E1254207C4055887C101020FE441188101010601380
+8EEC:040008201FF00210FFFE09203FF8C1061FF011101FF011101FF00100FFFE0100
+8EED:100010FE1080FE8010FE7C9054907CBC54907C901090FEFE1080108010FE1000
+8EEE:102010201020FDFC11247D2455247D2455247FFE1020FE501050108811041202
+8EEF:100011FC1020FC2011247CA454A87C2057FE7C201020FE201020102010201020
+8EF0:04447C5804621C42E43E01007FFC01001FF011101FF011101FF00100FFFE0100
+8EF1:1008101C11F0FD5011507D5055507D5055507D481148FD681154127412521400
+8EF2:102010201020FE2011FE7C2054207C2054FC7C841084FE841084108410FC1084
+8EF3:1040104010FCFE8411047EF454947C9454F47C841094FE8810821082107E1000
+8EF4:104010201000FDFE10207C2054207C2055FC7C201020FE201020102013FE1000
+8EF5:104410441044FE8410BE7D8456847CA454947C941084FE841084108410941088
+8EF6:1040102011FCFD0411047DFC55007D00557C7D081110FD2011421282127E1400
+8EF7:105010481048FC4013FE7C8054807CFC55447D441128FD281210122814441182
+8EF8:102010201020FE2011FC7D2455247D2455247DFC1124FF241124112411FC1104
+8EF9:1000100011FCFF0411047D0455047D0455FC7D041000FE901088110412021402
+8EFA:100011FC1044FE4410447C4454947C8855007CFC1084FE841084108410FC1084
+8EFB:1000100013FEFC0810087DE855287D2855287D2811E8FD281008100810281010
+8EFC:102010201120FD2011FC7D2056207C2055FE7C201050FE501088108811041202
+8EFD:100011FC1084FE8810507C2054507C8857267C2011FCFE201020102013FE1000
+8EFE:101010141012FC1013FE7C1054107DD054907C901090FC8810EA138A10061002
+8EFF:108410481000FEFC10487C4854487C4855FE7C481048FE481048108810881108
+8F00:100013FE1020FE2010407DFC55547D5455547D541154FF541154114411141108
+8F01:104810481048FE4811FE7C4854487C4854487DFE1000FE481044108410821102
+8F02:08207FFC0820FFFE101021085FF481021FF011101FF011101FF00100FFFE0100
+8F03:104010201020FDFE10007C8855047E0254887C881050FE501020105010881306
+8F04:102010201124FEA410A87C2057FE7C9054907C901090FE9211121112120E1400
+8F05:104010401078FE8811507C2054507C8855067CF81088FE881088108810F81088
+8F06:102010101010FDFE10207C2454447CF854127C221044FD881010102810441182
+8F07:102010201050FE8811047E0255FC7C2054207C2011FCFE201020102013FE1000
+8F08:1010102010FCFE8410A47C9454947DFE54847CA41094FE941084110411141208
+8F09:08207F280824FFFE0820FFA008247F2449247F2849287F100812FFAA08460882
+8F0A:100011FE1020FE4010887D0455FE7C2254207C2011FEFE201020102013FE1000
+8F0B:010041047FFC0200FFFE09203FF8C1061FF011101FF011101FF00100FFFE0100
+8F0C:200023FE2020F8202020FBFEAA22FA22AAAAFAAA22AAFAFA22022202220A2204
+8F0D:100010501048FE8411247C2054507C8855067EF81088FE881088108810F81088
+8F0E:101010921052FE5410107CFE54827C8254FE7C821082FEFE10821082108A1084
+8F0F:100013FE1050FC5011FC7D5455547D54558C7D041104FDFC1104110411FC1104
+8F10:1020101011FEFD0212047CF854007C0055FE7C501050FE5010921092110E1200
+8F11:100010FC1024FE2411FE7C2454247CFC54407C4010FCFEC411441044107C1044
+8F12:100013FE1120FD2811287DE855287D2855287DE81128FD2A113A13EA10261020
+8F13:1080108010F8FD0812107DFC55247D2455247DFC1050FE50109010921112120E
+8F14:1028102413FEFC2010207DFC55247D2455FC7D241124FDFC112411241124110C
+8F15:100011FE1000FE9211247E4855247C9254007DFE1020FE201020102013FE1000
+8F16:100010FE1092FE9210BA7C9254FE7C8254BA7CAA10AAFEBA10821102110A1204
+8F17:10001040119CFF0411047DDC55047D0455FC7C501050FE50109010921112120E
+8F18:1020102010FCFC2010207DFE54487C8455227C781088FD48105010201050118C
+8F19:100013E0115CFD5411547DD455547D5455D47D541148FD6813C8105410541062
+8F1A:10481044105EFDE010287C12546A7D9654487C5E11E0FE2410281012106A1186
+8F1B:200023FE2020F82023FEFA22AA22FB32AAAAFAAA2376FA6622222222222A2204
+8F1C:109210921124FE4811247C9254927C0055FE7D221122FDFE1122112211FE1102
+8F1D:100013FE922254205BFE1020FDFC292429FC292429FC28202BFE4C2048208020
+8F1E:200023FE2202FA8A2252FBFEAA42FA22ABFEFA822282FA8222FA2202220A2204
+8F1F:200023DE2042F94A2084F94AAA52FC20A800FBDE2052F9522094214822542422
+8F20:100011FC1124FD2411FC7D2455247DFC54207DFE1070FEA81124122210201020
+8F21:10401040107CFC8411087E0054207DCE55027D0211CEFD021102110211FE1102
+8F22:1020102011FCFC5010887D0457FE7C0855E87D281128FDE81128100810281010
+8F23:100011DC1154FD5411547DDC55547D5455547DDC1154FD54115412D41224144C
+8F24:1020102011FEFE2010FC7C2055FE7C0054FC7C8410FCFE8410FC108410941088
+8F25:100011FC1104FD0411FC7D0455047DFC54007D1211D4FD18111011521192110E
+8F26:08203EF808207EFC145023885FF401001FF011101FF011101FF00100FFFE0100
+8F27:104410441088FDDC10887C8854887C8855DE7C881088FE881088108810881108
+8F28:1020101011FEFD0210007CF854887C8854F87C801080FEFC1084108410FC1084
+8F29:04407C7C04403C7804407C7C05403FF801001FF011101FF01110FFFE01000100
+8F2A:102010201050FE8811047EFA54007DFC55547D5411FCFF54115411541104110C
+8F2B:104810481048FDCE10487C4854487DCE54487C481048FDCE1048104810481048
+8F2C:1040102013FEFC0010007DFC55047D0455047DFC1020FEA81124122210A01040
+8F2D:100013FE1020FC4011FC7D5455547D5455547D2C1020FDFE1050108811041202
+8F2E:100010FC1048FE3011FE7C5254947D1056307C2011FEFE7010A8112412221020
+8F2F:100010F81088FE8810F87C0055FE7C8854F87C8810F8FE88109E13E810081008
+8F30:100010FC1084FEFC10847CFC54007DFE54807CFE112AFE4A1092112210541088
+8F31:2008200C200AFBFE2208FA08AAE8FA0AAA0AFAEC22ACFAA822EA221A22262442
+8F32:102011241124FD2411FC7C0057FE7C2054407DFC1154FF54115411541154110C
+8F33:1020102013FEFC2011FC7C4057FE7C8855047EFA1020FDFC1020105010881304
+8F34:1008101C11F0FD1011107DFE55107D7C55447D7C1144FD7C11441244127C1444
+8F35:100010FC1084FEFC10847CFC54407CFE55127C9210AAFE8210FA100210141008
+8F36:108810481050FDFE10507C5055FC7D5455547D8C1104FDFC1104110411FC1104
+8F37:1080108010FEFD0212427DFA54027DF254027DF21002FDF2111211F210141008
+8F38:204020A02110FA0825F6F800ABC4FA54AA54FBD42254FA5423D42244225422C8
+8F39:1040104010FEFE8011FC7E8454FC7C8454FC7C40107CFEC41128101010681186
+8F3A:1052105210A4FDFE10A47C5254527C0054FE7C921092FEFE1092109210FE1082
+8F3B:100010FE1000FE7C10447C44547C7C0054FE7C921092FEFE1092109210FE1082
+8F3C:100010F81088FE8810F87C8854887CF854007DFC1154FF541154115413FE1000
+8F3D:104010481084FDFE10207FFE54887D0457FE7D241124FDFC1124112411FC1104
+8F3E:200023FC2204FA0423FCFA48AA48FAFCAA48FA4823FEFAA422A8249024C82886
+8F3F:010017C0611C47C4454477DC454447C4711C47C44104FFFE0000101020084004
+8F40:100010F810A8FEA810D87C8854F87C0054007DFC1154FF541154115413FE1000
+8F41:101E11E01022FD1210947C8054207DCE55027D0211CEFF021102110211FE1102
+8F42:0800FFB808287F280028FFC688807F7C08247F2449287F284910FFA808440882
+8F43:1020102013FEFC2011FC7C4057FE7C8855347EE21020FDFC107010AC13221020
+8F44:2040202023FEFA022424F9FCA820F9FCA820FBFE2020F9FC2104210421FC2104
+8F45:1020102011FCFC2013FE7C0055FC7D0455047DFC1052FC94118816A410C21080
+8F46:2040202023FEFA502250FBFEAA52FA52ABFEFA002292FAD42298249224D2288E
+8F47:200023DE2042FA52214AFA52A828F8C4AB12F8602188F83221C4201820602380
+8F48:112412481124FC0011FC7D2455FC7D2455FC7C2013FEFC7010A8112416221020
+8F49:102013FE1020FDFC11247DFC55247DFC54227DFE1008FDFE1108108810281010
+8F4A:108813DE1088FDDC10887FDE54887C0057FC7C041004FDFC1004100413FC1004
+8F4B:1010101012FEFD10117C7C54547C7F54557C7D1011FEFD1011101290147E1000
+8F4C:100011FC1020FFFE12227DAC54207DAC54007DFC1004FDFC1004100411FC1004
+8F4D:2108208823E8F910229EFFD4A864FBD4AA54FBD42254FBC822482254226422C2
+8F4E:201C21E02040FBFE2088F904AAFAFC88A8F8F80023FEFA0222FA228A22FA2206
+8F4F:23FE220223FEFA0022FCFA08ABFEFA10AA30FBCE2242FA8424EE27842884218C
+8F50:1050115210D4FC5011FE7C8854507DFE54207CFC1020FDFE1050108811041202
+8F51:1020102011FCFC2011547C8855047EFA54887CF81088FEF8102010A811241060
+8F52:102011FC1020FC8813FE7C8855FC7D0455FC7D0411FCFD0411FC108811041202
+8F53:103C13E01124FCA813FE7CA855247E0255FC7D241124FDFC1124112411FC1104
+8F54:2020212420A8FBFE20A8F924AA22F904A904F9DE2244FD54209E210422042404
+8F55:108813FE1088FDFC11047DFC55047DFC54807DFE1222FD52110211FA100A1004
+8F56:2020202023FEF9242124FAAAAFFEF800A9FCF9042174F9542174210421FC2104
+8F57:2014201223FEFA1022F0FA14AAF4FAB8AAEAFA162442F82422A2228A24782000
+8F58:100011FC1154FD5411FC7C0057FE7C0055FC7D0411FCFC621094118812A410C2
+8F59:1104108813FEFC2011FC7C2057FE7C5455927C9013FEFC9010D4138A109611A2
+8F5A:08007F3C2A243E422A3CFFA449187F6601007FFC11101FF01110FFFE01000100
+8F5B:214421442554FB64215EFBE4A804FA34A94CFBE42084FBE4208420E427142008
+8F5C:200021FC2020FBFE2222F9ACA820F9ACA800FBFE2020F9FC215421542154210C
+8F5D:1A3823883A38238838B82288FFFE11103FF8C1061FF011101FF01110FFFE0100
+8F5E:200823E82288FBEE2228FBF4AA82FBE2A800F9FC2154F9542154215427FE2000
+8F5F:01003FF801001FF011101FF01110FFFE01001110FEFE54547C7C5454FEFE1010
+8F60:200021FC2124F9FC2124F9FCA904F800ABFEFAAA22AAFBFE22AA22AA23FE2222
+8F61:210427C4410897D2E55C47C89552F7DE0100AFEAA92A01003FF820083FF82008
+8F62:212421742258FADA23FEF954AADAFBFEA8A2F82023FEF87020A8212422222020
+8F63:200023FE2222FACC2244FBEEAA44FAEEAB54FA442210FA90229E249024902BFE
+8F64:2040207C2040FBFC2244FBF0AA44FAFCAAA8FAF822A8FAF8220025FC25542BFE
+8F65:208823FE2088FBDE2252FBDEAA52FBDEAA4AFAFE2392FAFE229222FE22822206
+8F66:0200020002007FFC04000900110021003FF801000100FFFE0100010001000100
+8F67:104010401040FE402040284048407E40084008400E40F84248420842083E0800
+8F68:208020802080FC8043F050909090FC90109010901C90F09251121112120E1400
+8F69:1000100010FEFE102010281048107E1009FE08100E10F8104810081008100810
+8F6A:102010201020FE20202029FE48207E20082008500E50F8504888088809040A02
+8F6B:1000100010FCFE24202428A448A47EA408A409240E24F8444844088409280A10
+8F6C:202020202020FDFC4020504093FEFC40108011FC1C04F0885050102010101010
+8F6D:200021FE2100FD00417851489148FD48114811681D50F14251421142123E1400
+8F6E:2040204020A0FCA0411052089406FD10112011401D80F1005104110410FC1000
+8F6F:104010401040FE7C2084288849207E20082008500E50F8504888088809040A02
+8F70:020002007FFC080011003FF80100FFFE010001003EF80288145008203458C286
+8F71:102010201020FE2021FE282048207E2008FC08840E84F8844884088408FC0884
+8F72:2000200021FEFC08400851E89128FD28112811281DE8F1285008100810281010
+8F73:20202020203EFC20402051FC9104FD04110411FC1D04F1005100120012001400
+8F74:202020202020FC2041FC51249124FD24112411FC1D24F1245124112411FC1104
+8F75:2000200021FCFD04410451049104FD0411FC11041C00F0905088110412021402
+8F76:202020202120FD2041FC51209220FC2013FE10201C50F0505088108811041202
+8F77:2008203C23E0FC20412450A490A8FC2013FE10201C20F0205020102010A01040
+8F78:202020202050FC88410452129020FC40118810101C20F0445188101010601380
+8F79:2008201C21E0FD00412051209120FDFE102010201CA8F0A45122122210A01040
+8F7A:100011FC1044FE442044284448947E88090008FC0E84F8844884088408FC0884
+8F7B:200021FC2008FC10403050489084FF02100011FC1C20F0205020102013FE1000
+8F7C:201020142012FC1041FE50109010FDD0109010901C90F08850EA138A10061002
+8F7D:082008287F240820FFFE10201024FF24202448287F2808100F12F82A08460882
+8F7E:100010FE1010FE202044288248FE7E12081008100EFEF8104810081009FE0800
+8F7F:2008203C21E0FC20402053FE9050FC881104128A1C88F0885088110811081208
+8F80:2010202020FCFC8440A450949094FDFE108410A41C94F0945084110411141208
+8F81:202020202050FC884104520291FCFC20102010201DFCF0205020102013FE1000
+8F82:104010401078FE882150282048507E88090608F80E88F8884888088808F80888
+8F83:204020202020FDFE400050889104FE02108810881C50F0505020105010881306
+8F84:200023FE2120FD28412851E89128FD28112811E81D28F12A513A13EA10261020
+8F85:2028202423FEFC20402051FC9124FD2411FC11241D24F1FC512411241124110C
+8F86:200023FE2050FC50405053FE9252FE52125212AA1EA6F30252021202120A1204
+8F87:082008207EFC0820FEFE145022884206BFF8050009001FF00100FFFE01000100
+8F88:04407C7C04403C7804407C7C064002003FF8050009001FF00100FFFE01000100
+8F89:100013FE92025444584013FCFC8028A0292029FC282028202BFE4C2048208020
+8F8A:200021FC2104FD0441FC51049104FDFC100011121DD4F118511011521192110E
+8F8B:200023FE2202FA8A425253FE9242FE2213FE12821E82F28252FA1202120A1204
+8F8C:2040202023FEFC00400051FC9104FD0411FC10201D28F1245222142210A01040
+8F8D:200023DE2042FD4A4084514A9252FC20100013DE1C52F1525094114812541422
+8F8E:209220922124FA48412450929092FC0011FE11221D22F1FE5122112211FE1102
+8F8F:2020202023FEFC2041FC504093FEFC88110412FA1C20F1FC5020105010881304
+8F90:200021FE2000FCFC4084508490FCFC0011FE11221D22F1FE5122112211FE1102
+8F91:200021F82108FD0841F8500097FEFD0811F811081DF8F108513E17C810081008
+8F92:100010F81088FE8820F8288848887EF8080009FC0F54F954495409540BFE0800
+8F93:204020A02110FA0825F6400053C49254FA5413D41A54F25453D41244125412C8
+8F94:2208220847D08A22F53C27C84110F93E07C0193EE1003FF8200820083FF82008
+8F95:2020202021FCFC2043FE500091FCFD04110411FC1C52F094518816A410C21080
+8F96:2040202023FEFE02442451FC9020FDFC102013FE1C20F1FC5104110411FC1104
+8F97:200023FC2204FA0443FC52489248FEFC124812481FFEF2A452A8149014C81886
+8F98:2040202023FEFA50425053FE9252FE5213FE12001E92F2D45298149214D2188E
+8F99:2208210827C8FA10249E4FD450649794FC9417941C94F7885488149414A415C2
+8F9A:2020212420A8FBFE20A8412452229104F90411DE1A44F554509E110412041404
+8F9B:020001003FF8000008200440FFFE0100010001007FFC01000100010001000100
+8F9C:01007FFC01001FF010101FF001003FF808200440FFFE01003FF8010001000100
+8F9D:10401020202029FC4400FE88425001FE7C20442045FC442044207C2044200020
+8F9E:00201E10F01011FF1000FE441024102811FF7C10441045FF441044107C104410
+8F9F:00407C20442045FC44007C88405041FE7C206420A5FCA42024203C2024200020
+8FA0:02001FF010101FF010101FF010101FF001003FF80820FFFE01003FF801000100
+8FA1:204010201020FDFC000044882850FDFE10201020FDFC10202020202040208020
+8FA2:10401020FE2011FC1000FE88925093FEFE20102039FC54209220102010201020
+8FA3:2020102011FCFC20002045FC2924FD2411FC1020FC7010A82124222240208020
+8FA4:04201E10E01022FE92005444FE2882FE00107C10047C68101010281044108210
+8FA5:08204A1052107EFE24004844BE2822FE22103E10207C3E10221022103E102210
+8FA6:421022082208FA3E078052942288FABE22882288729C2288248844884A889108
+8FA7:401020082788FABE028052942288FABE22882288729C2288248844884A889108
+8FA8:2010108810887CBE00802A941288FEBE128810887C9C11081108220824084008
+8FA9:2010120811087D3E00002B141108FD3E110811087D1C11481188210820084008
+8FAA:08204F10481048FEFF00084410287EFE42107E10407C7F1041107F1041100010
+8FAB:2010108810887D3E01402BD41088FCBE110813C87C1C100810C8230820084008
+8FAC:401022082108F93E000057D42088FCBE22882108711C22882288448848088008
+8FAD:0F20F010491022FEFE0014440828FFFE9510BD10837CBD10951089109510A310
+8FAE:411021082288FABE078051142108FABE27C82148711C25882548494845088208
+8FAF:421021082008FBBE000053942008FBBE20082388729C22882288438842888008
+8FB0:00003FFC200020002FF8200020003FFC24802488245024204410450886060400
+8FB1:00003FFC20002FF820003FFE288848504A308C0E0020FFFE0820042004A00040
+8FB2:04403FF824483FF824483FF800003FFC20002FF820003FFE288848504A308C0E
+8FB3:082008207EFC08201C702AA8C8243FFC20002FF820003FFE288848504A308C0E
+8FB4:0000EEFEAA80AA80EEBC0080FE8092FEFEA092B2FEB410A8FEA8112411321220
+8FB5:003803C07C00003803C03C0C007007807800010011F811001100290047FE8000
+8FB6:000020001000100000000000F000100010001000100010001000280047FE0000
+8FB7:0000200010001000000007FCF000100010001000100010001000280047FE0000
+8FB8:0000200017F8110801100120F13C110411041204120414281810280047FE0000
+8FB9:00402040104013FC00440044F044108410841104110412281410280047FE0000
+8FBA:0000200017F8108800880088F088108810881108110812281410280047FE0000
+8FBB:0040204010401040004007FEF040104010401040104010401040280047FE0000
+8FBC:0200210010801040004000A0F0A0111011101208140418021000280047FE0000
+8FBD:000023F81010102000400040F040104010401040104011401080280047FE0000
+8FBE:004020401040104007FE0040F04010A010901108120414041000280047FE0000
+8FBF:004020401040144404440444F44414441444144417FC10041000280047FE0000
+8FC0:000021FC1020102000200020F3FE102010201020102010201020280047FE0000
+8FC1:0010207813C0104000400040F7FE104010401040104010401040280047FE0000
+8FC2:000023F81040104000400040F7FC104010401040104010401140288047FE0000
+8FC3:000023F81000100007FE0080F10011F810081008100810501020280047FE0000
+8FC4:0100210011FE1200040001F8F010106010801104110410FC1000280047FE0000
+8FC5:00004FE02220222002200220EFA02220222422142214220C220450008FFE0000
+8FC6:004020401040125802E80748F248126812541244120411FC1000280047FE0000
+8FC7:00102010101017FE00100010F210111011101010101010501020280047FE0000
+8FC8:0000200017FE1080008000FCF084108410841104110412281410280047FE0000
+8FC9:000021FC11041104010401FCF104110011001100110012001400280047FE0000
+8FCA:00004FFE2040204007FC0444E44424442444245424482040204050008FFE0000
+8FCB:000027FC1040104000400040F3F8104010401040104017FC1000280047FE0000
+8FCC:000021FC1104110401FC0104F10411FC11041104110412141408280047FE0000
+8FCD:0040204017FC104002480248F24813F8104410441044103C1000280047FE0000
+8FCE:00002080133C122402240224F2241224122412B4132812201020282047FE0000
+8FCF:004020401040104007FE0040F04010A010901108124414241020280047FE0000
+8FD0:000023F810001000000007FCF04010801110120817FC12041000280047FE0000
+8FD1:0008201C11E01100010001FEF110111011101110121012101410280047FE0000
+8FD2:00802040104017FE00000000F1F011101110111012121212140E280047FE0000
+8FD3:000023FC1010111001100210F3FE103010501090111016501020280047FE0000
+8FD4:0008203C13C01200020003FCF204128812501220125014881504280047FE0000
+8FD5:00802080108011FC01200220F020102017FE1020102010201020282047FE0000
+8FD6:005020481048104007FE0040F04010A010901108120414041000280047FE0000
+8FD7:000023FC1040104000400040F7FE104010A01090110812041404280047FE0000
+8FD8:000023FC1020102000400040F0D0114812441444104010401040280047FE0000
+8FD9:00802040104017FC00100210F12010A0104010A0111012081408280047FE0000
+8FDA:00402040104017FC04440444F444144417FC1444104010401040280047FE0000
+8FDB:00902090109013FC00900090F09017FE10901090111011101210280047FE0000
+8FDC:000023F810001000000007FCF120112011201120112412241224141C280047FE
+8FDD:008040802FFC2080008007F8E08020802FFC208420842094208850808FFE0000
+8FDE:0040204017FE108000A00120F3FC10201020102017FE10201020282047FE0000
+8FDF:000021F811081108010801F8F108112011101208120414041000280047FE0000
+8FE0:004020401040107E00400040F3FC120412041204120413FC1204280047FE0000
+8FE1:000023FC1204120403FC0200F2801284129812E012821282147E280047FE0000
+8FE2:000023FC1084108400840114F20811FC11041104110411FC1000280047FE0000
+8FE3:004822481248124807FE0248F248124812781200120013FE1000280047FE0000
+8FE4:0200220013FC144004400A58F2E81748126812501244120411FC280047FE0000
+8FE5:000023FC1204120402F40294F294129412F41294120412141208280047FE0000
+8FE6:04004400243C2FA404A404A4E4A424A424A428A428BC32A4210050008FFE0000
+8FE7:0040204017FC1444044407FCF444144417FC1444104010401040280047FE0000
+8FE8:008020801110120807FC0204F00013F812081208120813F81208280047FE0000
+8FE9:00802080110011FE02020424F020112811241222142210A01040280047FE0000
+8FEA:00404040204027FC04440444E44427FC24442444244427FC200050008FFE0000
+8FEB:00402040108013F802080208F20813F812081208120813F81208280047FE0000
+8FEC:00802040100017FC00400040F04013F81040104010401FFE1000280047FE0000
+8FED:00402240124013FC02400440F04017FE104010A0109011081208280047FE0000
+8FEE:01002100110013FE02800480F0F81080108010FC108010801080280047FE0000
+8FEF:01102110111011D002580254F252155218901090111012101410280047FE0000
+8FF0:004020501048104007FC00C0F0E0115011481244144410401040280047FE0000
+8FF1:0080404027FC240408080200E210226023802204220421FC200050008FFE0000
+8FF2:00402040104013FC00400040F7FE104010801110120817FC1204280047FE0000
+8FF3:000023F81010102000500188F60413F810401040104017FC1000280047FE0000
+8FF4:000023FC1204120402F40294F29412F41204120413FC12041000280047FE0000
+8FF5:000023FC120412F402040204F2F41294129412F4120412141208280047FE0000
+8FF6:0040204017FE1080010003FCF50419FC110411FC110411141108280047FE0000
+8FF7:0040224811481150004007FCF04010E011501248144410401040280047FE0000
+8FF8:02082110100017FC01100110F11017FE11101110121012101410280047FE0000
+8FF9:00402020102017FE00900090F294129214921110111012501420280047FE0000
+8FFA:00004FFE20A020A007FC04A4E4A424A4251C2604240427FC240450008FFE0000
+8FFB:0040208011F81610012000C0F120167C10841348103010C01700280047FE0000
+8FFC:00402040104017FC00400040F3F81000100013F81208120813F81208280047FE
+8FFD:0020204013FC1204020403FCF200120013FE1202120213FE1202280047FE0000
+8FFE:000427E411041114011403D4F2541254155410941094110412141408280047FE
+8FFF:0100210011FC1204040403E4F224122413E41224122413E410041028281047FE
+9000:03F82208120813F802080208F3F8124412281210128813041204280047FE0000
+9001:020241043088101003FE0020F020102017FF10201050108811042A02440183FF
+9002:007823C01040104007FE0040F04013F812081208120813F81208280047FE0000
+9003:00A020A014A412A801B000A0F1B012A814A4112011241224141C280047FE0000
+9004:0080208010FC110802900060F1981626102011FC1020122013FE1020282047FE
+9005:003C23C01200120003FE0200F20012FC12841484148418FC1084280047FE0000
+9006:0208410821102FFE00400040E4442444244427FC20842100220054008FFE0000
+9007:021042502250225C0F7402D4E2542254225C23502E422442203E50008FFE0000
+9008:0040208013FC1204020402F4F2941294129412F4120412141208280047FE0000
+9009:00402240124013F804400040F7FC11201120112012241224141C280047FE0000
+900A:00104F9020902110021002D8E354225426922A92231222102A50242050008FFE
+900B:004840442FFE204007FC0444E7FC244427FC244424442454240850008FFE0000
+900C:00402040107C1040004003FCF20413F4121413F4120413FC1204280047FE0000
+900D:0040224811481150004003F8F208120813F81208120813F8120812282A1047FE
+900E:000027FE1090109003FC0294F294130C120413FC1204120413FC1204280047FE
+900F:003823C0104017FC01500248F44613F01110113C110412141408280047FE0000
+9010:000023FC1040108001440668F0B01128166810A41124162010A0284047FE0000
+9011:00402050104817FC00400248F15010E011501248144411401080280047FE0000
+9012:011020A013F81048004803F8F240124013FC10C4114412541448284047FE0000
+9013:003C47E0242025FC042007FEE420242025FC2524252429342928302050008FFE
+9014:004020A01110120805F60040F04017FC10401248124414441140288047FE0000
+9015:000027FC1000124804900248F00017FC1040104010401FFE1000280047FE0000
+9016:09104510221026520A520254E29026282A24324422422A82250050008FFE0000
+9017:000027FC1000100003F80208F20813F810001208111017FC1000280047FE0000
+9018:00802100120817FC01040100F3F81440104017FE104010A011102A0847FE0000
+9019:0080204017FC100003F80000F3F8100013F81208120813F81208280047FE0000
+901A:000047F8201021A0004007FCE444244427FC2444244427FC2444245454088FFE
+901B:00004880257C22100D100110E17C23102D10211021102A7E240050008FFE0000
+901C:00004FF82080208007F00110E1102FFC200027F82408240827F850008FFE0000
+901D:0208421C226022400FC0027EE2C823482E48224822482A48248851008FFE0000
+901E:03F822081208120803F80000F7FC1040104013F81040104017FC280047FE0000
+901F:0040204017FC104003F80248F24813F810E01150124814441040280047FE0000
+9020:0040224013F81440004007FCF000100013F81208120813F81208280047FE0000
+9021:00802110120817FC00040110F208150411F812081590106011902E0847FE0000
+9022:010021F81308149000600198F606104013F8104013F8104017FC1040284047FE
+9023:004040402FFE204007FC0444E7FC244427FC20402FFE2040204050408FFE0000
+9024:001022101110145402520092F0101114160412081210122010C0280047FE0000
+9025:000023FC1294129402F40294F29412F412941294129413FC1204280047FE0000
+9026:00004FFE2000200007BC04A4E4A426B425AC24A424A424A425AC50008FFE0000
+9027:01102248144410A001100208F40613F812081208120813F81208280047FE0000
+9028:0040204017FC104001500150F2E8144410E01150124814441040280047FE0000
+9029:0000208017FC111002480C46F3F810401150111017FE111012101410281047FE
+902A:0110211017FC111001100FFEF00013F8120813F8120813F81208280047FE0000
+902B:000047BC2084252802100528E84027BC2084252822102528284450008FFE0000
+902C:00842084110817BC01080108F108110817BE11081108110811082A0847FE0000
+902D:0080204017FC140403F00210F21013F0120013F81208120813F8280047FE0000
+902E:0040204013F8104807FE0048F3F8144412481150124814441140288047FE0000
+902F:000047F8200823F800080FFEE040244422E8215022482444214050808FFE0000
+9030:02204220223E2F400280027CE30422082E7E2208220822082A28241050008FFE
+9031:000047FC2444244405F40444E7FC240425F4251425F42404280C50008FFE0000
+9032:0140212013FE122006200BFCF220122013FC1220122013FE1200280047FE0000
+9033:0080204017FE1100020807FCF00413F8120813F8120813F8120812282A1047FE
+9034:00402040107E104003F80208F3F8120813F810401FFE10401040284047FE0000
+9035:0040204013F81040004007FCF1101248144413F81040104017FC1000280047FE
+9036:003823C0104017FC01500248F44410801FFE11081390106011981604280047FE
+9037:000023F8120813F8020803F8F10013FC14941924124414A811102A0047FE0000
+9038:0100410021F0221004200FFCE444244427FC20A02130212A2222241E50008FFE
+9039:0040204013F81040004007FCF11010A013F81040104017FC10401040284047FE
+903A:0040204013F8104007FE0080F11013E0104411A81690108810C4280047FE0000
+903B:000047FC24A424A407FC0080E1F82208251020A0204021802E0050008FFE0000
+903C:000027FC100013F8020803F8F00017FC144417FC144417FC1404280047FE0000
+903D:0108210817FE1108004007FEF080110013FC1504190411FC1104280047FE0000
+903E:004040A0211022080DF60000E78424A427A424A427A424842494258850008FFE
+903F:01F8210811F8110801F80000F7FE110013FC14A4112412541088280047FE0000
+9040:008027FC110013F804400BFCF00013F8120813F8120813F8120812282A1047FE
+9041:001E23E01220122003FE0220F2FC128412FC128412FC148414FC280047FE0000
+9042:0110209010A017FC00800144F66810B01128166810A4112416A0284047FE0000
+9043:0040202013FC100001080090F3FE122012C81210122412C812101460298047FE
+9044:004044442444244407FC0000EFFE208027FC24A424A424A424A4240C50008FFE
+9045:00004FFC280428040FFC0910E8A02FFC28402BF8284037FC204050408FFE0000
+9046:0080204017FC111000A007FCF444104013F812481248126812501040284047FE
+9047:000023F8124813F8024803F8F04017FC14441454147415941404140C280047FE
+9048:000043F8220823F8020803F8E0002FFC204022782240254028FE50008FFE0000
+9049:00402040107C104003F80208F3F8120813F8120813F810A011102A0847FE0000
+904A:042042202FBE2440043C0784E488248824FE24882488288829A850108FFE0000
+904B:000027FC144413F8004003F8F24813F8124813F8104017FC1040284047FE0000
+904C:000027BC14A417BC000003F8F00017FE110011F8100810081050282047FE0000
+904D:0080204013FC1204020403FCF20013FC1354155415FC19541144110C280047FE
+904E:01F8210811E81128012803FCF20412F4129412F4120412141208280047FE0000
+904F:000023F8120813F8020803F8F10013FC14441AA4120413F41014280847FE0000
+9050:000047BC2484248407BC0400E40027BC2404240427A82410242854448FFE0000
+9051:0040208013F8120803F80208F3F8100017FC104013F8104017FC280047FE0000
+9052:020841102FFE20A007FC04A4E4A42524261C240427FC240427FC50008FFE0000
+9053:02082110100017FC008003F8F20813F8120813F8120813F81208280047FE0000
+9054:0040204013F8104007FC0110F0A017FC104013F8104017FC1040284047FE0000
+9055:0040204013F8108807FE0000F3F8120813F8104013FC144017FE1040280047FE
+9056:004040402FFE204007FC0514E4A425F4244425F424442454244850008FFE0000
+9057:004023F8124813F800400FFEF00013F812081248124810A011102A0847FE0000
+9058:011027FC111013F8011007FCF04013F8124813F8124817FE120812282A1047FE
+9059:004020FC1324109800E00700F1F81240104017FC1040124413FC280047FE0000
+905A:00402140165C1444075C0444F7FC104017FC10081190106011981604280047FE
+905B:0080477C2424252404A40554E648208027FC244427FC244427FC50008FFE0000
+905C:00064FB82090212002440278E3102E24227E221222542A92245050208FFE0000
+905D:000027FC14A414A407FC0040F150124814441150124814441040280047FE0000
+905E:001E47E0243C242005FE0522E53825E2251E250029782A48328A250650008FFE
+905F:000023FC1204120403FC0240F22013FC1288125013FE122015FC1420282047FE
+9060:0040204013F8104007FC0000F3F8120813F810C411A8129014881084280047FE
+9061:0440225E1292101207D2011EF5521552155217DE115212121222142A284447FE
+9062:000023F8120813F8020803F8F00017BC108414A4129414A412941108280047FE
+9063:004023F8124813F8004007FEF00013F8120813F8120013F8120813F8280047FE
+9064:000023FC124013F8024003F8F24013FC10041554155415541428281047FE0000
+9065:003C23C010041244012801FCF220102013FE102011241124112411FC280047FE
+9066:03FC224417FE124403FC0000F3FC120413FC120413FC120413FC11082A0447FE
+9067:004047FC21102FFE000003F8E20823F8220823F820402FFE204050408FFE0000
+9068:021042102F90221E07A40244EF9424142788248824942AA2294250008FFE0000
+9069:0080404027FC211000A007FCE44427FC244425F4251425F42404240C50008FFE
+906A:0080211013F8121004A407FCF0A013181C4613901064139810601380280047FE
+906B:021042102F90223E0FA40AC4EAA42F94220827082A943224224450008FFE0000
+906C:022042202FA0223C0FC40A90EA902F90221027282AA83244228450008FFE0000
+906D:00A02FFE10A017FC04A407FCF4A417FC100013F8120813F8120813F8280047FE
+906E:0040402027FE240004880488E7FE2488248824F828002AA43252245250008FFE
+906F:0000477E25102530074A059AE52C274C259A252A254A25A82B1050008FFE0000
+9070:02A822A817FC12AA04E60800F7FC1444104013F8124812481258284047FE0000
+9071:004043F822482FFE024803F8E04023F8224823F820802FFE211020E053188FFE
+9072:07FC440427FC242004A80470E4A8250424A024FC252024202BFE282050208FFE
+9073:0110211017FC111000400248F2481554104013F81040104017FC280047FE0000
+9074:00402248115017FC01500248F4441210139014BC1A901150117E12102A1047FE
+9075:01104FFE20A027FC04A4051CE60427FC240427FC20102FFE211020B050008FFE
+9076:0040204013F8104007FC0210F73812101F7C100017FC11201224141C280047FE
+9077:07FC20A017FC14A407FC0080F7FE120815F4191211F0110410FC280047FE0000
+9078:0F3C49242F3C28A2079E0110E7FC211021102FFE21102208240450008FFE0000
+9079:000023F81090106007FC0124F6A8104017FC14A4151416EC14A414EC280047FE
+907A:004023F8124813F800400FFEF00013F8120813F8120813F811101208280047FE
+907B:000027BC14A414A407BC0110F0A017FC10401248124813F810401080290047FE
+907C:004040402FFC20A0051403F8E60C2BFA220823F8204022482444294450808FFE
+907D:0040407C204027FE044205F8E44427FC24C0272228D42B183074239250208FFE
+907E:0210421023DE2528088407FCE04022482248255428E220402FFE50008FFE0000
+907F:0010478824BE248004A20794E43E28082F8834BE24882788248850008FFE0000
+9080:020044102F9028900F9E08A4EFC422143FD424082788289432A2214250008FFE
+9081:01104FFE211023F8024803F8E24823F8204027FC245425F42414240C50008FFE
+9082:04004F3C291432140F940AA8EAA82FBC2AC82A882FBE2A882A88318850088FFE
+9083:008040402FFE2A12140C0120E7FC20802144266821B0266821A426A450408FFE
+9084:000047FC24A427FC00000FFEE00023F8220823F8214423282D9051088FFE0000
+9085:002027FE100013FC020402F4F29413FC110811F8110811F8100017FE280047FE
+9086:002423A810921514020805F4F00213F8120813F81208111017FC280047FE0000
+9087:07FC424824442FFE044406ECE55426EC244426EC255426EC2444240C50008FFE
+9088:011042202D7C25C402440D7CE3442544297C23282528292A254652808FFE0000
+9089:008043F8220823F8020803F8E0402FFE2912220825F42912211021F050008FFE
+908A:008047F8254824A807F80040EFFC2A1424882BF4210021F02210243050008FFE
+908B:02484490224827F8052804C8E52827F8249026D0249026D4248C26C450008FFE
+908C:0190461E222A2F8A031206AAEA4420A023182C46225021602250254850808FFE
+908D:010043F0251020E0071C03F8E24823F8224823F820082FFE2248215052488FFE
+908E:04004F8C35702A2004441A78EF9020242F7E20102F5429922F3050008FFE0000
+908F:00004FFE29122FFE02280424E97E2FC8227E25482F7E21482AFE2A4050008FFE
+9090:0FBE40002FBE2CB20AAA0040EFFE29202FFC29242FFC2A282BB22A1E53808FFE
+9091:00001FF0101010101FF000003FF82108210821083FF82008200220021FFE0000
+9092:0000FF7C08440848084808500848084808440844084408680850284010400040
+9093:00007E7C02440248424824501448084808441444144422684250804000400040
+9094:00007F7C01440148014801503F48214820442044204421682650384020400040
+9095:088811102220111008881FF010101FF000003FF8210821083FF8200220021FFE
+9096:0800083E0822082449244928492449244922492249224F347928002000200020
+9097:00007F7C08440848084808500848FFC808440844084408680850084008400840
+9098:00007F7C08440848084808500848FFC808440844084408680850084028401040
+9099:1000083E08220024FFA4202820242024202220222022203420283F2000200020
+909A:1000107C10441048FE4822502248224842442444144408681450224042408040
+909B:0000007C7F44084808480850084808480844084408440F68F050404000400040
+909C:1000107C10441F482148215051488A480A440444044408681050204040408040
+909D:0800043E04223FA4202420282024202420222022202220342028402040208020
+909E:0800087C08447F48084808500848FFC808441444124422682150414080400040
+909F:1000087C0844FF48004800503C48244824442444244425684650444080400040
+90A0:0000147C12441248214821504048BE481244124412441268225022404A408440
+90A1:1000083E0822FFA4102410281F24112411221122112211342128252042208020
+90A2:00007FBE12221224122412281224FFE412221222122212342228222042208220
+90A3:00007E7C1244124812487E50124812487E4412441244226822504A4084400040
+90A4:0200077C38442048204820503FC8244824442444244424682450444044408440
+90A5:0800087C08447F48494808500848144814441444144425682650444080400040
+90A6:0800087C0844FF48084808507E4808480844FF44084410681050204040408040
+90A7:00003F3E002200240024FFA81224122412221222122222B42328422080200020
+90A8:0800083E0822FFA4082449284924492449227F220822083409280A200C200820
+90A9:0800087C0844094849484A504C48884808440844144412682150214040408040
+90AA:00007FBE022222242224222842247FE406220A2212222234422882200A200420
+90AB:100010F81088FC8810F810007DFC11241124FF2411FC110021002102410280FE
+90AC:1000203E7E22422442244A28442440247F22012201221D34E12841200A200420
+90AD:1000103E20223F24412481283D242524252225223D222534012801200A200420
+90AE:0800087C08447F4849484950494849487F4449444944496849507F4041400040
+90AF:2200223E22222224FFA42228222422243E2222222222223422283E2022200020
+90B0:0800083E102222244124FFA800A400247F22412241224134412841207F204120
+90B1:0000033E3C222024202420283FA42224222222222222223427A8F82040200020
+90B2:1000083E0A2202241224132854A454A4542298221922113431284F2080200020
+90B3:0000FF7C08440848104814503248514890441044104400680E50F04040400040
+90B4:00007FBE0822082408247FA848A448A454A252A262A240B440A840A042A04120
+90B5:00007F3E1122112421242528422480243F2221222122213421283F2021200020
+90B6:1200123E122212241224F3A812241224122212221222323452A8932012200020
+90B7:0000FF7C204420483C482450244834484C444C44444445685550654043400040
+90B8:010007BE7C2244244424442844247FA4442244224422423442A852A069A044A0
+90B9:2000207C3E44424884480850FE48024802447E44024402680250FE4002400040
+90BA:1400143E142214A494A455285524562414221422142217B4F828402000200020
+90BB:0800087C14441248214848D0844804487F440144224414680850044004400040
+90BC:00007FBE402240247FA4442844245F24442244227FA2403440287FA000200020
+90BD:0800087C7F44084808480850FFC80048084408447F44086808500F40F0404040
+90BE:0800487C48447F48484888500848FFC818441C442A4429684950884008400840
+90BF:0800083E08227F2408240828FFA4022402227FA202222234122802200A200420
+90C0:0800083EFFA2142422244128BEA40024FFA2102220227F34012801200A200420
+90C1:0800083EFF22102410243F2821246124BF22212221223F342128212025202220
+90C2:1000083E0022FFA40824112821247E240422092212222434CC2812202120C0A0
+90C3:0800087C144422484148BED0004800483E4422442244226822503E4022400040
+90C4:0100323E0C22122469240828FFA410242422242248228A3411283F2011200020
+90C5:0000FFBE0822102422244128FFA408A4082208227F22083408280FA0F8204020
+90C6:0800083E0822FFA4082408287F24002400227F224122413441287F2041200020
+90C7:2000203E7F22412481247928492449247922492249227934412801200A200420
+90C8:0200073E7822402440247FA8402440245F2251225122513451289F2091200020
+90C9:0000773E22222224222422282224F7A422222222222222342228422042208220
+90CA:1000087C0044FF48004824504248814824441444084414682250424080400040
+90CB:0800083E10227F24412441287F24412441227F224122413441287F2041200020
+90CC:100010F810887C8810F81000FDFC0124112411247DFC110011001D02E10240FE
+90CD:0800103E3F222124292425282524FF2421222922252225342128412045208220
+90CE:0800043E3F22212421243F28212421243F222022242222342528292030202020
+90CF:0800083E0822FFA40824492829242A24FFA20822082214341228212041208020
+90D0:0800083E142222244124BEA800240024FFA21022102222344128FF2041200020
+90D1:2200123E14227F24082408280824FFA408220822142212342128412080200020
+90D2:000020F810887C8844F844007DFC452445247D2441FC510049005502650240FE
+90D3:00007FBE48A208247FA41028142424247FA20422042207B4FC28442004200420
+90D4:008001DE771211121114251425D8751415125512551227DA201450108FF00010
+90D5:0400053E04A204247FA4442844247524552255225522523452A8A6A089A010A0
+90D6:00007FBE002200243F242128212421243F22002221221134122807A078202020
+90D7:30800D3E0622192460A408287FE4142424227FA2A4A224B426A8252004200420
+90D8:00003E3E22222224222422283E24002400227F2241224134412841207F204120
+90D9:0A00093EFFA2082408247F28492449247F22492249227F344928492049204320
+90DA:0000FFBE082208247F2411281124FFE4002200227F224134412841207F204120
+90DB:02000F3EF022012491244A280024FE24042208220F22F8344828082028201020
+90DC:0800483E48227F24482488280824FFA4002200227F224134412841207F204120
+90DD:0800083E7F22082408240828FFA412241222532252A292B4222822204A208420
+90DE:1000087C7E44424842487E50424842487E4451444A4444684450524062404040
+90DF:0800083E0822FFA408242A282A242A245D2288A2082214341228212041208020
+90E0:00007FBE082208247F24492849247F24492249227F220834682818202620C120
+90E1:00007F3E11221124FFE4112811247F24202220227F22A134212821203F202120
+90E2:00007F7C4144414841487F5000487F48084408447F44086808500F40F0404040
+90E3:0800087C7F44084808487F50414882483C44044408440F687850084028401040
+90E4:1400127C214449480848145022484148BE4422442244226822503E4022400040
+90E5:00007E7C424442487E48425042487E48424442447E4400682450224041408140
+90E6:00007FDE001200127BD44A544A584A546B525AD24A524A5A4A544A504A505AD0
+90E7:00003E3E222222243E2400287F2441244922492249224934142812202120C120
+90E8:1000083E7FA2002421241228FFE4002400223F222122213421283F2021200020
+90E9:61001A3E0C223224C9240828FFA410243F226122BF2221343F28212025202220
+90EA:0800083EFFA208247F240928FFA409247F221022FF22213472280C203320C0A0
+90EB:1000203E7F22492449247F28492451247F2224224422FFB40428042004200420
+90EC:0800083EFFA208247F240828FFA400247F2241227F2241347F28412045204220
+90ED:1000087CFF4400487E4842507E4800487E44044408440F68F850084028401040
+90EE:00003FBE24A224A42EA424A83FA420A42EA22AA22AA22EB420A840A042A08120
+90EF:0800093E49224A2488241428222449248822492249228A3414282220412080A0
+90F0:0000FC1E48124BD278544A5449587954489248925C92E95A49540A5008100810
+90F1:2100113E122200247FA41228122412241222FFA2122212341228122022204220
+90F2:0800087C0844FF4808482A502A482A485D4488441C442A684950884008400840
+90F3:1000677C414441487748415041487F4814441444144414682550264044408040
+90F4:1100111E111211127BD41114111833143B9255525512991A1114111011101110
+90F5:02000F3E78220824FFA42A282A24FFA42A222A22FFA2083408280F20F0204020
+90F6:200010F87C88008844F8280001FCFF24012401247DFC4500450045027D0244FE
+90F7:200023DE22524A524BD4F254125823D44A12FA920A5212DA1354221040108010
+90F8:4100223E14227F24492449287F24492449227F2208220834FFA8082008200820
+90F9:00007E7C42447E4842487E5042487E4814441244FF4410682850244042408040
+90FA:212422483D244400A8F8108820F8C80011FC3D24452485FC290011042104C0FC
+90FB:3F00A13EBF22A124BF24A128BF248024FFA20022492249349228922049204920
+90FC:1000103E7F222124FFE400287F2441247F220822FFA208348828FFE008200820
+90FD:080008BE7EA209240A24FFE8082410243F226122A1223F34212821203F202120
+90FE:00007FDE40125F9250945F9450985F9444127FD24912591A4614491050907FD0
+90FF:00007F7C494449487F4840505F48514851445F4451445F68515051409F401140
+9100:2200223EFFA222242A240828FFA4102420223F226122A134212821203F202120
+9101:140014BEF722142434A4D3A800247F2441227F2241227F344128412045204220
+9102:0000773E55225524772400287F240024FFA220223F220134012801200A200420
+9103:0800143E22224124BEA4002878A44AA44AA27AA24AA24AB47AA848A04AA05920
+9104:0000FF7C144414487F48555055487F48084408447F44086808500F40F0404040
+9105:010007BEF82208247F24492849247F240822FFA288A28AB4BEA880A082A08120
+9106:0000FFBE88A20824FFA408287F2449247F2249227F220834FFA8082008200820
+9107:1000179E109220922FF46414A41827D4291221122FF2211A2294225024502810
+9108:0A00747C15445248224821504148BE48084408447F4408681450124022404040
+9109:2100209E23D24A524A54F3D4125822544BD2FA120A92125A12D4235042108010
+910A:200027FE22524A524BD4F254125823D44A52FA520A7217DA1054205040508050
+910B:28004B7C494449486B48495049487F4808447F44014432680C50124061400040
+910C:0800043E7FA244245F2445287FA445245F2244225F225134512851205F209120
+910D:0000FFBE80A200247F2441287F2441247F2210220822FFB400282220412080A0
+910E:0800103E7F2241247F2441287F2441247F22102208222934A2A8A2A01E200020
+910F:00007FBE40225F2440247FA855245224592250A242227FB452284A2082200620
+9110:1000083EFFA2102422247C28082411247FA200A27F2249347F2849207F204120
+9111:00007FBE122252A433241228FFE400243F22212221223F34212821203F202120
+9112:1000103E3FA248A42AA43EA810A4252452223FA248A2AAB43EA810A025204220
+9113:0800103E7F2241247F2441287F2441247F220A220922FFB40828142022204120
+9114:1000203E7F22412441247F2840247FE440227FA200A2AAB4AAA800A005200220
+9115:2080211E23D24A524A54F3D4125822544BD2F8120A52139A1214225041D08010
+9116:00003F3E212221243F2400287FA440A47FA240A27FA240B47FA81220212040A0
+9117:1000087CFF4400487E4842507E480048FF448144BD44A568BD50814085408240
+9118:02003FDE22122F9222943FD422982F9422122F922A922F9A4A944F908A900990
+9119:1F00113E11221F2404247FE804243FA420A22EA22AA22EB420A83FA020A00020
+911A:2200223EFFA222247F2441287F2441247F220822FFA208341428222041208120
+911B:4900927C494400487F4849507F4849487F440844FFC41C682A50494088400840
+911C:0800043E7FA2522452247FA852A452A47FA2522252225BB4522852A09B201220
+911D:0000773E11225524332455280C243324C4A2182262220CB4712806201820E020
+911E:2200227CFFC422483E4808507F4849487F4408447F4408687F5008400F40F040
+911F:0800FFBE08227F2449247F2849247F2408A2FFA20222FFB4422822200A200420
+9120:7F00083EFFA288A46B2408286B2400247F220022FFA220343F2801200A200420
+9121:10007F3E41227F2441247F2840247FA440227FA208A27EB41DA82A20C9200820
+9122:00007FBE042227242424FFA820243FA440227FA200A2AAB4AAA800A005200220
+9123:08007F3E22221424FFA400287F2441247F2241227F220834FFA8082008200820
+9124:7E00427C7E4442487E480050FF48A548FF4400447E4402683450084014406240
+9125:1000203E7F2241247F2441287F2440247FA240227FA200B4AAA8AAA080A00320
+9126:2000203E7FA2D52455245528FFA4552455225522FFA200346A28552095200020
+9127:0500723E12A2512421245EA880A43F24212221223F222134122807A078202020
+9128:49202A3E7F4449A85D106B2849461FF010101FF000003FF821083FF820021FFE
+9129:00007F3E01223F2401247F28002477242522F7220222FFB4422822202A200420
+912A:1200FF9E12927F9252147FD422587F54A1D23F1221123F1A21143F1012102110
+912B:4100223E0022FFA488A4AAA89CA488A4FFA200227F2241347F2841207F204120
+912C:03C07C1E289215123F14211421183F94209220923FD2205A55545550A1500090
+912D:2200147CFF4414487F48555063485D4841447F440844FF681450224041408040
+912E:1000EFBEA4A294A4AAA4C92810247F2441227F2241227F3441287F2022204120
+912F:2200143EFFA208247F240828FFA449242A22FFA200227F34412841207F204120
+9130:0800493E2A22FFA42A24492888A44124412277A29122553427A8412081200120
+9131:0F00F83E49222A24FFA42A28492480A47F22492249227F34492849207F204120
+9132:0000F7BE94A294A4F7A400287F2449247F2249227F220834FFA8082008200820
+9133:00007F3E55225524772414287724552455227722552255347728542014A00FA0
+9134:1400557C36441448FF48225014487F4808447F440844FF681C502A4049400840
+9135:00007F3E41227F240024F7A894A4F7A408220822FFA21C342A28492088A00820
+9136:04000B1E30D2DF3200147FD455584E547FD200123F92209A3F9420903F902090
+9137:12007FBE52A27FA452A47FA800247FA400227FA240A27FB4212812200FA0F020
+9138:2200FFBE22227F24552455287F240024FFA290A23E22223452280C201820E020
+9139:FC004BBE78A24AA479244D28FAA40CA407A2F82228A24D341A282920C8A00820
+913A:0800043E7FA24A245F244A287FA444245F2255225F2255345F288020912020A0
+913B:2200F7BE2222F7A4552488A87F2408247F2249227F2249347F280820FFA00820
+913C:2200773E2222F7A42224552888A47F2441227F2241227F3441287F2022204120
+913D:04007FDE40125F9254945F9454985F9444125F9244127FDA5494AF5084103FD0
+913E:7F80083E3F2221243F2421287FA448A4252252A20E2210343F2851200E207120
+913F:2200FFBE222277245524772800247F2449227F2249227F340828FFA008200820
+9140:2200221EFF9222123E1441145D58D59455125552DD5240DA001454904A508A50
+9141:3E00421EFF9240927F944494771844543FD24212FF92489A7F941A102950C7D0
+9142:1080529E7BD29492FBF431945AD8949400123F922092249A24940B1010906050
+9143:00007FCE040AFFEA842A358A040C358A000A000AEEEAAAAAAAACAAA8EEE8AAA8
+9144:11007FDE11127BD24A547BD4141812143FD224127F92A41A3F9424103FD02010
+9145:44407FDE12123FD26214BFD422183FD422123FD220127FDA51546ED04A504ED0
+9146:2A007F3EAAA2FFA4AAA4FFA8AAA4FFA40022FFA200227F3441287F202220FFA0
+9147:52807BDE9492FBF231945AD494983F9420923F9220923F9A20943F9011102090
+9148:7BC0001E7BD24A526B544A5404187FD44A127FD24A527FDA52545B90525099D0
+9149:0000FFFE044004407FFC444444444844503C600440047FFC400440047FFC4004
+914A:0000FF80147E14107F105510551055105710611041107F10411041107F504120
+914B:101008100820FFFE044004407FFC44444844503C60047FFC400440047FFC4004
+914C:0020FE202820287CFE44AA84AA04AA44AE24C2148214FE0482048204FE288210
+914D:0000FE0028F82808FE08AA08AA08AAF8AE88C2808280FE8082828282FE7E8200
+914E:0008FE0828082808FEFEAA08AA08AA08AE48C2288228FE0882088208FE288210
+914F:0020FE20282028A0FEACAAB4AAE4ABA4AEA4C2B482A8FEA282A28282FE7E8200
+9150:0000FE7C28102810FE10AA10AA10AAFEAE10C2108210FE1082108210FE108210
+9151:0000FEFC28202820FE20AA20AA20ABFEAE20C2208220FE2082208220FEA08240
+9152:00004FFE20A020A007FC84A444A454A4151C2604E40427FC2404240427FC0404
+9153:010002800C603118CFE600400080FFFE04803FF82488287830083FF820083FF8
+9154:0040FE4029F82848FE88AA8AAB0AAA26AE20C22083FEFE2082208220FE208220
+9155:0008FE1C28F02810FE10AA1CAAF0AA10AE10C21E82F0FE1082128212FE12820E
+9156:0010FE1028102810FEFEAA92AA92AA10AE28C2288228FE288248824AFE8A8306
+9157:0000FE4428442828FEAAAAAAAA92AA92AEAAC2AA82A6FEC682828282FEFE8202
+9158:0000FE7828482848FE48AA86AB00AAFCAE44C2448228FE2882108228FE448382
+9159:0008FE8828482848FE08AA88AA48AA48AE08C20E82F8FE0882088208FE088208
+915A:0008FE2828282828FE44AA44AA82AB7CAE24C2248224FE2482448244FE948308
+915B:0000FEFC28002800FE00AAFEAA50AA50AE50C2508250FE5282528292FE8E8300
+915C:0020FE20282028FCFE20AA20AA20ABFEAE20C2508250FE4882888284FF048202
+915D:0000FE00287C2800FE00AA00AAFEAA10AE10C2208220FE44824282FEFE428200
+915E:0020FE2028202820FE20ABFEAA20AA20AE20C2508250FE50828882C8FF248202
+915F:0010FF90141014107F1E551055105510577C614441447F44414441447F7C4144
+9160:0000FE0028FE2804FE04AAF4AA94AA94AE94C29482F4FE9482048204FE148208
+9161:0020FE10281028FEFE82AA84AA40AA44AE48C2508260FE4282428242FE3E8200
+9162:0040FE402840287EFEA0AAA0AB20AA3CAE20C2208220FE3E82208220FE208220
+9163:0044FE4428442844FEFEAA44AA44AA44AE44C27C8244FE4482448244FE7C8244
+9164:0010FE1028102810FEFEAA10AA10AA10AE7CC2448244FE4482448244FE7C8244
+9165:0004FE1E28F02810FE10AA10AAFEAA10AE38C2348254FE5282908210FE108210
+9166:0020FE2828A428A0FEFEAA40AA40AA7CAEA4C2A482A8FEA882908328FE448282
+9167:0020FE1028FE2882FF0CAA08AA08AAFEAE08C2488228FE2882088208FE288210
+9168:082008287F240820FFFE0020FFA414247F245528632841107F12412A7F464182
+9169:0020FE20287E2882FF44AA28AA10AA20AE40C2FE8342FE4282428242FE7E8242
+916A:0020FE20283C2844FEA8AA10AA28AA44AE82C27C8244FE4482448244FE7C8244
+916B:0010FE1028282828FE44AA82AA7CAA10AE10C210827CFE1082108210FEFE8200
+916C:0004FE4428542854FE54AA54AADCAB74AE54C2548254FE5482548254FE848304
+916D:0020FE2028FE2820FE40AA7CAA44AAC4AF7CC2448244FE7C82448244FE44824C
+916E:0000FEFE28822882FEBAAA82AA82AABAAEAAC2AA82AAFEBA82828282FE8A8284
+916F:0080FE82288C28F0FE82AA82AA7EAA00AEFCC2848284FEFC82848284FEFC8284
+9170:0010FE502850287CFE90AA10AA10AAFEAE28C2288228FE28824A824AFE868300
+9171:0840488029FC1A482830C9C00800FFFE04803FF82488287830083FF820083FF8
+9172:0000FE7C28442844FE44AA7CAA00AA00AEFEC2108210FE7C82108210FEFE8200
+9173:0020FE4428F82810FE24AAFEAA02AAFCAE84C2FC8284FEFC82848284FE948288
+9174:0010FE1028282828FE44AABAAA10AA10AEFEC2108258FE5482928312FE508220
+9175:0020FE2229FA2824FE24ABFEAA10AA20AFFCC2888310FEFE82108210FE508220
+9176:0040FE40287E2880FF7CAA44AA64AA54AEFEC24482A4FE9482FE8204FE288210
+9177:0010FE502850287CFE50AA90AA10AAFEAE00C200827CFE4482448244FE7C8244
+9178:0010FE1028202844FEFEAA28AA44AAA2AE3CC2448244FEA882108228FE448282
+9179:0004FE1E28E02822FE92AA54AA40AA08AFFEC2088288FE4882488208FE288210
+917A:0014FE1228FE2810FE10AAFEAA92AA92AEFEC2928292FEFE82928292FE928286
+917B:000EFEF028222892FE54AA00AA7CAA08AE10C21082FEFE1082108210FE508220
+917C:0020FE1029FE2820FE48AA84ABFEAA02AEA8C2A882A8FEA882A882AAFF2A8206
+917D:0000FEFE282828AAFE6CAA28AAFEAA80AE80C2808280FE8082808300FF008200
+917E:0000FBFE20002000FBDEAA52AA52AA52DB5A8AD68A52FA528A528A52FA528AD6
+917F:0020FE1028FC2884FE84AAFCAA84AA84AEFCC2A282A4FE9882908288FEC48282
+9180:0050FE48288028FEFF90AA90AAFCAA90AE90C2FC8290FE90829082FEFE808280
+9181:0000FEFC28042804FE7CAA04AA04AAFEAE10C2928254FE3882548292FE508220
+9182:0048FE4828482848FEFEAA48AA48AAECAEDCC35A8248FE4882488248FE488248
+9183:0020FE2029FE2850FEA8AB26AAF8AAA8AEA8C2F882A8FEA882F882AAFE22821E
+9184:0040FE4028FE2882FF42AA7AAAA2AA22AFFEC22282AAFEAA82FA8202FE148208
+9185:0020FE1028FC2800FE84AA48AA00AAFEAE00C20082FCFE8482848284FEFC8284
+9186:0028FE24282E28F0FE28AA12AA2AAAD6AE28C22E82F0FE2482288212FE2A82C6
+9187:0020FE1028FE2800FE7CAA44AA7CAA00AE7CC2088210FEFE82108210FE508220
+9188:0020FEA228A22924FE50AA88AB04AA22AE20C2A482A4FF2882508288FF048202
+9189:0040FE2029FE2800FE88AA88AB54AA22AE00C22083FEFE2082208220FE208220
+918A:0000FEEE282228AAFE44AAAAAB12AA00AEEEC22A82AAFE4A824482A4FF2A8210
+918B:0048FE48284829FEFE48AA48ABFEAA00AEFCC2848284FEFC82848284FEFC8284
+918C:0000FEFC28842884FEFCAA84AA84AAFCAE00C2908292FEF482988292FED2828E
+918D:0000FE7C2844287CFE44AA7CAA00ABFEAE10C210825EFE50825082B0FE9E8300
+918E:0008F80C200A23FEFA08AA08AAE8AA0ADA0A8AEC8AACFAA88AEA8A1AFA268C42
+918F:0020FE2028FA2824FE28ABFEAA20AA40AEFCC3448244FE7C82448244FE7C8244
+9190:0100F93C212427E4F924A93CA924ABA4DAA48ABC8AA4FAA48BA48844F8548888
+9191:0000FEFC28142850FE5CAA50AA7EAA80AE7CC244827CFE44827C8244FE44824C
+9192:0000FE7C2844287CFE44AA7CAA10AA50AE7CC2908210FE7C82108210FEFE8200
+9193:0010FE1028FE2892FE92AA28AA28AA4AAE86C30082FEFEAA82AA82AAFEAA83FE
+9194:0620382008A47EA819202C504A880904FFFE04403FF82848303827C820083FF8
+9195:0020FE1029FE2800FE7CAA44AA7CAA00AEFEC2828282FEFE82828282FEFE8282
+9196:0000FE7C28442844FE7CAA44AA44AA7CAE00C2FE82AAFEAA82AA82AAFFFE8200
+9197:0008FEEC282828AAFE44AA44AA84AB7AAE28C22882FEFE288228824AFE4A8286
+9198:0010FE10287E2810FE10AAFEAA20AA42AEFEC20082FEFEAA82AA82AAFFFE8200
+9199:0050FE9628922892FED6AA92AA92AAFEAE10C2FC8244FE4482288210FE2882C6
+919A:0008FE4A292A28ACFE88AA3EAA08AB98AE9CC2AA82CAFE8882888340FE3E8200
+919B:0044FE4428FE2844FE10AA28AA44AA82AE7CC2108210FE7C82108210FEFE8200
+919C:0010FE2028FE2892FE92AAFEAA92AA92AEFEC2208224FE5A825E8290FE92830E
+919D:0044FE24282828FEFE10AA7CAA10AAFEAE20C220827CFE5082908310FEFE8200
+919E:0000FE7C28542854FE6CAA44AA7CAA00AE00C2FE82AAFEAA82AA82AAFFFE8200
+919F:08202AA44D28145022887FFE4002BFF404803FF82488287830083FF820083FF8
+91A0:0010FE10287C2854FE54AAFEAA28AA44AE82C30082FEFEAA82AA82AAFFFE8200
+91A1:0040FE2029FE2902FE50AA88AB44AA40AEFEC320823CFE20823E8220FE208220
+91A2:0020F82023FC2040F880A9F8AA88AC88D8F8880089FCF95489548954FBFE8800
+91A3:0020FE1028FE2890FEBCAA94AAFEAA94AEBCC29082BCFEA482A482A4FEBC8324
+91A4:083E4BC42A4829281BFE2908C8A80810FFFE04403FF82848303827C820083FF8
+91A5:0000FEFE282828FEFEAAAAAAAAFEAA00AE7CC20082FEFE1082548292FE508220
+91A6:0010FE20284428FEFE44AAAAAAEEAA10AE28C25482AAFE5082248248FE108260
+91A7:0000FBFE2200227CFA44AA44AA7CAA00DAEE8AAA8AAAFAAA8AEE8A00FBFE8800
+91A8:0020FE1028FE2828FE92AAAAAA82AAFEAE10C2FE82A2FEAA82BA8282FE8A8284
+91A9:0028FE2828FE2828FEFEAAAAAAFEAAAAAEFEC200827CFE44827C8244FE7C8244
+91AA:0000FEEE282228AAFE66AAAAAA10AA28AE44C3928220FEC8823282C4FE1882E0
+91AB:7F7848485E8664785F484A307F480084FFFE04403FF82848303827C820083FF8
+91AC:0440247C3CA805507C2825FE44888058FFFE04403FF82848303827C820083FF8
+91AD:0028FEAA286C2828FEFEAA44AA28AAFEAE10C27C8210FEFE82108228FE448282
+91AE:0028FE242840287EFEC8AB48AA7EAA48AE48C27E8248FE48827E8240FEAA832A
+91AF:0040F82023FE2040F884A9FEA8A8A8AAD9268A0089FCF95489548954FBFE8800
+91B0:0000FEFE282828FEFEAAAAFEAA00AA7CAE44C27C8244FE7C821082FEFE108210
+91B1:0024FBA820922514FA08AC04ABBAA8A8D8C68B808A3CFB8488A88890FAA88944
+91B2:0028FEFE28AA28FEFEAAAAFEAA00AAFEAE80C2BE8280FEFE82A882AAFEA48332
+91B3:0000FEFE28AA28FEFE10AAFEAA10ABFEAE44C22882FEFE1083FE8210FE108210
+91B4:0028FEFE28AA28FEFEAAAAFEAA00AAFEAE00C2FE8282FEFE82448228FEFE8200
+91B5:0040F87C204023FEFA42AA78ABC4AA3CDA008BFE8A40FBA48A588DB4FC5289B0
+91B6:0010FE1028282844FE82AA7CAA00AAEEAEAAC2AA82EEFE44824482AAFEAA8312
+91B7:0010FEFE28442828FEFEAA00AA7CAA44AE7CC244827CFE2082948342FE44823C
+91B8:0020FE1029FE2848FE84AB4AAAFCAA48AEFCC24883FEFE5482C88354FE628240
+91B9:0000FE7C281028FEFE92AA54AA10AA54AE00C2FE8210FEFE82AA82AAFEAA8286
+91BA:001CF9E0202023FEF820A9FCA9ACA974D9FC882089FCF8208BFE8800F9548A2A
+91BB:0020FBFE202021FCF800ABFEA802A9FCD8208BFE8800FBFE88048BBEFAA48B8C
+91BC:0110F91027FC2110F9F0AA08AAEAAEACDAA88AAA8EEAFA0688008AA4FA528C52
+91BD:0000F9FC202023FEFA22A9ACA820A9ACD8008BEE8AAAFAAA8AAA8AAAFBEE8AAA
+91BE:0040F82023FE2248FBFEAA48AAECAB5ADA488B248AA8FBFE8A708AA8FD268820
+91BF:0020FBFE224823FEFA48AAECAB5AAA48DA208A448A78FA148AFE8A10FA548CB2
+91C0:0010FEFE280028EEFEAAAAEEAA44AAFEAE44C2FE8244FEFE825082CAFF648242
+91C1:2FEC48246BAC48246BAC4AA4FFFE92921D7010101FF004401830EFEE04201860
+91C2:001EFBE021222094FBFEAA52ABFEA804DBC48A7E8BC4FA548BCC8A84FAD48B48
+91C3:03DEF80023DE2252FB5AAA52A820ABFEDA508BFE8A52FBFE8A928ADCFA928CCE
+91C4:0020FBFE224823FEFA48AAECAB5AAA48DA508BDE8A50FBDC8A508BDEFA508C50
+91C5:03DEFA5223DE2000FBFEAA00AAC8AA4EDBEA8AB28AEAFAAA8AEA8AB4FDE4882A
+91C6:001000F83F00010011100910092001007FFC03800540092011102108C1060100
+91C7:001000F83F00020011100910082001007FFC03800540092011102108C1060100
+91C8:0C00F1FC1104550439041104FDFC112031203920552051109110110812041402
+91C9:0C20F0201020542039FC1124FD241124312439FC552451249124112411FC1104
+91CA:0C00F3FC1104548838501020FCD81326302039FC5420502093FE102010201020
+91CB:0C00F1FC115455FC382011FCFC2013FE3088385055FC502093FE102010201020
+91CC:00003FF8210821083FF8210821083FF8010001003FF8010001000100FFFE0000
+91CD:001000F83F000100FFFE01001FF011101FF011101FF001003FF80100FFFE0000
+91CE:00007F7C490449287F104908497E7F12081408107F10081008100F10F0504020
+91CF:00001FF010101FF01010FFFE00001FF011101FF011101FF001001FF001007FFC
+91D0:08203E7E08A47F281C102A2849443FFE20002FF828882FF828884FF840809FFC
+91D1:0100010002800440082010102FE8C10601003FF80100111009100920FFFE0000
+91D2:10001000280024004200BC0010001000FE0010009400580050001E00F0004000
+91D3:10801080288024804280BC8010801080FE8010809480588450841E84F07C4000
+91D4:1000100028FE24044208BC1010201020FE4010409480588250821E82F07E4000
+91D5:100011FC280424084210BC2010201020FE2010209420582050201E20F0A04040
+91D6:1000100029FC24444244BC4410441044FE4410449444588450841F04F2284410
+91D7:10041004280424444244BC4410441044FE4410449444580450041E04F0144008
+91D8:100010002BFE24204220BC2010201020FE2010209420582050201E20F0A04040
+91D9:10401040284024404240BC5010481044FE4410409440584050401E40F0404040
+91DA:108010802880248043F0B89010901090FC9010909490589251121D12E20E4400
+91DB:102010202820242042FCBC2410241024FE2410449444584450841E84F1284210
+91DC:044008201850248803000CC03030C00E1FF0010001003FF80100111009207FFC
+91DD:10201020282024204220BC2013FE1020FE2010209420582050201E20F0204020
+91DE:10801040284024204220BC2010201050FE5010509448588850881E84F1044202
+91DF:10001010289024904090B89010901090FC9010909508590851081E04E2044402
+91E0:100010F0289024904290BC9010901090FE9010909490589250921F12F10E4200
+91E1:0820101021084284044008203018CFE6010001003FF8010011100920FFFE0000
+91E2:1000100029FC24444248BC481050105EFE4210429482588250821F02F1144208
+91E3:104010402840247C4284BC8411041044FE2410249404580450041E04F0284010
+91E4:08040804140822104120BE44080408087F10082249422A0408080F10F02040C0
+91E5:10201020282024204020B8A810A410A4FD2211229622582050201C20E0A04040
+91E6:1000100028FC24844284BC8410841084FE8410849484588450841EFCF0844000
+91E7:11041124292425244124B92411241124FD2411249524592451241E24E2044404
+91E8:100010FC280424084210BC20102011FEFE2010209420582050201E20F0A04040
+91E9:100011F0291025104110B91011901150FD5011109510591251121E12E20E4400
+91EA:100010FC282024204220BC20102011FEFE2010209420582050201E20F0A04040
+91EB:100010FC280024004200BDFE10401040FE8010FC9404580450041E04F0284010
+91EC:100010FC282024204220BC20102011FEFE2010209420582050201E20F0204020
+91ED:1000100028FC24204220BC2010201020FE2010209420582050201E20F1FE4000
+91EE:101010102810241043FEBC1010301030FE5010509490591050101E10F0504020
+91EF:104010202820240043FEBC8010801080FE8010809480588050801E80F0FC4000
+91F0:1000100029FC24244024B8A410A410A4FD2410249424584450441C84E1144208
+91F1:10201020282024204220BDFE10201020FE2010509450585050881E88F1044202
+91F2:1000100028FC24844284BC84108410FCFE8410809480588250821E82F07E4000
+91F3:10401040288024FE4100BA0010FC1008FC1010209440588051021D02E0FE4000
+91F4:1050104828482440425EBDE010401040FE4010409420582250121E0AF0064002
+91F5:100011F8288824C842A8BCA810881050FE5010509420582050501E88F1044202
+91F6:1020102028202520412CB934116413A4FD2411349528592251221D02E0FE4000
+91F7:10201020282024204020B82011FC1020FC2010209420582050201C20E3FE4000
+91F8:104010402840247C4244BC8410C41124FE1810089410581050201E40F0804100
+91F9:104010402840244043FEB88810881088FC8811089490585050201C50E0884304
+91FA:1008103C29E024204020B820102013FEFC2010209420582050201C20E0204020
+91FB:104010402840244041F8B84810481048FD4810C8944858A850AA1D0AE2064402
+91FC:1000100029FC24444044B94410C41044FC641054944C588650841D04E2284410
+91FD:1008101C29F025504150B95011501150FD5011489548594851441E44E2424400
+91FE:100011FE280824884088B888110811FEFC1810289448588851081E08E0284010
+91FF:1004100E28F024804280BC8010FE1088FE8810889488588850881F08F1084208
+9200:1000100029FC25244124B92411241124FDFC11009500590051021D02E0FE4000
+9201:10401020282025FE4240BC401040107CFE4410449444584450841E84F1284210
+9202:10201020282025FE4122BA2410201020FC5010509450585050901C92E112420E
+9203:100010FC284824484248BC48104811FEFE4810489448584850481E48F0884108
+9204:10081088284824484208BC8810481048FE08100E95F8580850081E08F0084008
+9205:100010FC288424844284BCFC10841084FE8410FC9484588450841E84F1144208
+9206:10081048284824484044B88410A41122FC2010409440584850841DFEE0824000
+9207:102010202820242041FCB82010201020FDFE10209450585050881C88E1044202
+9208:1000100029FE24104210BC2010201068FE6410A29522582050201E20F0204020
+9209:10201020282025FE4122B92211221122FD52114A958A590251021D02E10A4104
+920A:10001040282024104050B84010401144FD42114295425A4450441C44E03C4000
+920B:10A010A028A025244124BB2815301120FD6011A09520592251221D22E11E4100
+920C:10201020282025FC4024B82410241024FDFE10209450585050881C88E1044202
+920D:10201020282025FE4020B92411241124FD2411FC9424582050221C22E01E4000
+920E:10801080288024FC4104B90412441044FC8410A4951459F450141C04E0284010
+920F:100411E4282424244024B9E411041104FD0411E49424582450241C24E1444084
+9210:10201020285024504088B94412221020FC0011FC9404580850081C10E0104020
+9211:1008101C29E025004100B9FC11441144FD4411289528591051101E28E2444482
+9212:100013FC288424884088B890109C1084FD4411449528592852101E28E4444182
+9213:1008103C29E024204020B820102013FEFC2010209420582050201C20E1FC4000
+9214:10201020282024A842A4BCA211221120FE2410249428580850101E20F0C04300
+9215:100011F8284824484048B848104811F8FC8810889488588850881C88E3FE4000
+9216:10101090289024884108B904120415FAFC8810889488588851081D08E2284410
+9217:10401040288024884104BBFE10021090FC9010909490589051121D12E20E4400
+9218:10201020282025FE4020B820102011FCFC8410889448585050201C50E1884606
+9219:102010202820243E4220BC20102011FCFE8410889448585050201E50F1884606
+921A:10101110291025124112B91411D81110FD1011109510591251521D92E10E4000
+921B:1048104428442440425EBDE010401044FE4410489430582250521E8AF1064002
+921C:104010402840244043FEB84010801090FC90112095205A4852441C84E1FE4082
+921D:101010102890249042FEBC9011101010FE1011FE9410581050101E10F0104010
+921E:10401040288024FC4104BA0410841044FC4410149424584451841C04E0284010
+921F:100011FC282424244224BDFC11201120FF2011FE94225822502A1E24F0204020
+9220:100010F8288824884288BD06120011FCFE8410849448585050201E50F0884306
+9221:102010202820242041FCB92411241124FD2411FC9524582050201C20E0204020
+9222:102010202820242041FEB82010701070FCA810A89524592452221C20E0204020
+9223:100010FE281024104290BC9E10901090FE9010FE9402580250021E02F0144008
+9224:1000100028FC24844284BC8410841084FEFC10849484588450841E84F0FC4084
+9225:102010202820242442A4BCA410A81120FE2010509450585050881E88F1044202
+9226:10201020282024204220BDFE10201020FE2010509450585050881EC8F1244202
+9227:10401020280025FC4000B80010F01090FC9010909490589250921D12E10E4200
+9228:1000100029FC24004000B80013FE1090FC9010909490589051121D12E20E4400
+9229:10201010281024FE4282BC82108210FEFE8210809480588050801F00F1004200
+922A:100011FE290025004178B94811481148FD4811689550594251421D42E23E4400
+922B:10401020282025FE4288BC8810881088FE5010509420582050501E88F1044202
+922C:100010FC288424844284BC8410FC1090FE9010909490588850881E84F1044202
+922D:088008882E9028E028842E84F17C06C01830EFEE01003FF809200540FFFE0000
+922E:100011FC290425044104B9FC11001140FD4411489570594051421E42E23E4400
+922F:10201020292425244124B92411FC1020FC2011249524592451241D24E1FC4004
+9230:10401020280025FE4020B82011FC1124FD2411249524592451341D28E0204020
+9231:100011FC290425044104B9FC11201120FDFE11209520591051121D4AE1864102
+9232:1008101C29F025504150B95011501150FD5011489548596851541E74E2524400
+9233:100010002BFE24084008B9E811281128FD28112895E8592850081C08E0284010
+9234:10201020285024504088B92412121010FDFC10049408588850501C20E0104010
+9235:100011FE282024204020B9FE11221122FD52114A958A590251021D02E10A4104
+9236:10201020282024404248BC8411FE1082FE0010FC9484588450841E84F0FC4084
+9237:102010202820242043FEB82010201020FDFC11049504590451041D04E1FC4104
+9238:105010482848244043FEBC401040107CFEA410A494A8592851101E28F0444082
+9239:10101010281025FE4112B914111011FCFD4411449528592851101E28E2444482
+923A:1000100029FC24204020B82010201020FDFC10209428582450241C20E3FE4000
+923B:100010FC288424844284BC8410FC1080FE8010FE9482588250821E82F0FE4082
+923C:10801080288024FE4340BD401240107CFE4010409440587E50401E40F0404040
+923D:10201020282025FE4040B850109010FEFD92129294925892509A1C94E0104010
+923E:102010202820242041FCB92411241124FD2411FC9524592451241D24E1FC4104
+923F:1000100029FC25244124B92411241124FDFC11249524592451241D24E1FC4104
+9240:100011FC292425244124B9FC11241124FD2411FC9524582050201C20E0204020
+9241:10201020285024884104BA1210201040FD8810109420584451881C10E0604380
+9242:10201020282025FC4124B924112411FCFD241020952058C050401CA0E1184206
+9243:10401040288024FC4120BA2010201020FDFE10209450585050881C88E1044202
+9244:102010202920252041FCB92012201020FDFE10209450585050881C88E1044202
+9245:100010FE288024804280BCFC10841084FE84108494FC588050801E80F0FE4000
+9246:1020102028202420403EB82010201020FDFC11049504590451041D04E1FC4104
+9247:1080108028FE250042207D20912C11747BA411249534592851221D02E0FE4000
+9248:10201010281025FE4102BA0410801088FC9010A094C0588250821C82E07E4000
+9249:10201010281025FE4020B82010441084FDF810109420584450821DFEE0824000
+924A:100011FC284424444044B84410941088FD0010FC9484588450841C84E0FC4084
+924B:1080108029FC25044204BDF411141114FD1411F49504592851121D02E0FE4000
+924C:101C11E0282024204020BBFE10201070FC7010A894A8592452221C20E0204020
+924D:10401020282824084008B84810541152FD5211609660584450C41D44E23C4000
+924E:102010202920252041FCB92012201020FC2011FC9420582050201C20E3FE4000
+924F:100010F8288824884088B8F810881088FC8810F89488588850881C88E3FE4000
+9250:100010002BFE24204020B840104010FCFD8412849484588450841C84E0FC4084
+9251:10101010282024FC4284BC8410841084FEFC10849484588450841E84F0FC4084
+9252:10401020280025FE4020B82010201020FDFC10209420582050201C20E3FE4000
+9253:10801080288024FE4120BA20102011FCFD2411249524592451341D28E0204020
+9254:100011FE291025104110B97C11541154FD5411549554595C51101D10E1FE4000
+9255:100010FE2880248042BCBCA410A410A4FEA410A494BC58A450801E80F0FE4000
+9256:10401040287C24844188BA5010201050FC8813069460581050081CC0E0204010
+9257:108810882888248843FEBC8810881088FE8810F89488588850881E88F0F84088
+9258:10501050285025FC4054B85411FC1150FD5011FE94525852505A1C94E0904110
+9259:1000100029FC25044104B90411041104FDFC11049400589050881D04E2024402
+925A:20002080531E4A5282527A5222522252FA5222D22B5AB25460903890E1100210
+925B:100010F8288824884088B88811061200FC0010FC9484588450841C84E0FC4084
+925C:1088108828882508417EBB0815081148FD2811289508590851081D08E1284110
+925D:102010102810240041FEB80010041084FC8410489448584850501C10E1FE4000
+925E:202820245024482083FE7A2022242224FA2422282A28B29063123A2AE0460082
+925F:100010FE281024104220BC2010681064FEA211229420582050201E00F1FE4000
+9260:10201020282025FC4124B92411241124FD2413FE9420585050501C88E1044202
+9261:10201020292424A440A8B82011FC1020FC20102097FE582050201C20E0204020
+9262:102010202820242043FEB82010701070FCA810A895245AFA54201C20E0204020
+9263:10201020282025FC4020B820102013FEFC2010209440584850841DFEE0824000
+9264:10801080290025FC4204BC0411E41124FD24112495E4592450041C04E0284010
+9265:102010282824242041FCB82010701070FCA810A89524592452221C20E0204020
+9266:1000100029FE24104010B81010901090FC9E10909490589050901C90E3FE4000
+9267:100010FC288424A44094B884108413FEFD0411449524590451FE1C04E0284010
+9268:10801080288024FE4102B90412201020FCA810A49524592252221C20E0A04040
+9269:10201020285024504088B90412221020FCA810A49524592252221C20E0A04040
+926A:102410A428A424A442A4BDFE10A410A4FEA410A494BC588050801E80F0FE4000
+926B:110011002900251C43D4B95411541154FD5411549554595451541E5CE3544480
+926C:100011FC290425044104B9FC11041104FD0411FC9504590451041D04E1FC4104
+926D:1000100028FC24844284BC8410FC1084FE84108494FC588450001E00F1FE4000
+926E:10201020282025FC4124B924112411FCFD241124952459FC51241C20E0204020
+926F:10081048292825284128B90811081108FD0811089548599451141C22E0424082
+9270:100011FC2804240443F4B804100411E4FD241124952459E450041C04E0144008
+9271:10201010281025FE4100B91011101110FD1011209528592452441EFEE4424800
+9272:102010202820243C4220BC20102011FEFE2010209428582450221E20F0204020
+9273:10901090289024904090BB9210941098FC9010909490599252921C92E08E4080
+9274:04402440247C24902488250802800C603018CFE601003FF8092005407FFC0000
+9275:10201020282025FC4124B92411241124FDFC11249420582850241DFEE0824000
+9276:100213E22942254A414AB94A114A13EAFD4A114A954A594A51421E42E24A4444
+9277:104810482848244841FEB84810481048FC4811FE9400584850441C84E0824102
+9278:10401020282025FE4000B88811041202FC8810889450585050201C50E0884306
+9279:10201020287C24844148B83010201048FD90103E944259A450181C10E0604180
+927A:100013FE2888248840F8B888108810F8FC881088948E5BF850081C08E0084008
+927B:10401040287824884150B82010501088FD0610F89488588850881C88E0F84088
+927C:110410842888240041FEB88810881088FC8813FE9488588851081D08E2084408
+927D:201020145012481083FE7810201021D0F89020902890B08860EA3B8AE0060002
+927E:102010202848248441FEB81210901090FCFE1110941059FE50101C10E0104010
+927F:10201020285024884104BA0211FC1000FC0011FC9504590451041D04E1FC4104
+9280:100011F82908250841F8B908110811F8FD4411489530592051101D48E1864100
+9281:10401040288024FE4102BA0211F21112FD1211F29512591251F21C02E0144008
+9282:10821092289224924092B89212DA12B6FC9210929492589250921D12E1024202
+9283:10401020282025FE4040B888110411FEFC9210909490589051121D12E20E4400
+9284:10201020284025FC4104B90411741154FD5411549554597451041D04E1144108
+9285:100011FC290425044174B90411041174FD5411549554597451041D04E1144108
+9286:100013FE282024204040B9FC11041104FD0411FC9504590451041D04E1FC4104
+9287:1020102029FE24204020B8FC10201020FDFE107094A858A851241E22E4204020
+9288:1020102029FC24204020B82013FE1000FC20102095FC582050201C20E3FE4000
+9289:1020102029FC242443FEB82411FC1020FC2011FC9420582053FE1C20E0204020
+928A:202820245024482083FE7A2022242224FA2423A82A28B21062123C2AE4460882
+928B:10801088289C25704110BB1015101110FDFE11109510591051101D10E17C4100
+928C:10201020282025FE4040B84010BC1084FD88128894FE588850881C88E0A84090
+928D:100011FE282024404088B90411FE1022FC20102095FE582050201C20E3FE4000
+928E:00007DF01110119011521D12E20E450006C01830EFEE01003FF811100920FFFE
+928F:100011DC295425544154B954115413FEFD5411549554595451541ED4E224444C
+9290:00047F8408241F24212452240C243104C6CC1830EFEE01003FF811100920FFFE
+9291:10201120292025FC4120BA20102013FEFC9010909490589051121D12E212440E
+9292:100011DC288824884088B888108813DEFC8810889488588850881D08E1084208
+9293:10201020285024884104BA0211FC1020FC20102095FC582050201C20E3FE4000
+9294:100013FE281024204068B8A413221020FC00102094205BFE50201C20E0204020
+9295:102010202BFE242041FCB82411FC1120FDFE1022942A585450501C88E1044202
+9296:10201120292025FC4120BA20102013FEFC7010A894A8592451241E22E0204020
+9297:1008101C29E025004100B9FE11001100FD7C11449544594451441E7CE2444400
+9298:1040104028FC25044288B85010201040FC8011FC9684588450841C84E0FC4084
+9299:2020202053FE48508088790422FA2000FBFE20402880B1FC60043804E0280010
+929A:105010502850255242D4BC5810501058FED411529450585050921E92F112420E
+929B:1008103C29E024204020BBFE10201020FC2011FC9504590451041D04E1FC4104
+929C:11001100229C424084201BC0213E6108AFC8210829482588250821C82E282410
+929D:109010902890251041FEBB1015101138FD3811549554599251101D10E1104110
+929E:10001FF820085FC890481FC810481FE8011006C01830EFEE01003FF80920FFFE
+929F:101010922892249242FEBC0010101010FEFE10929492589A50941E10F0104010
+92A0:10401040284425F44048B85013FE1040FC801184969858E050821C82E07E4000
+92A1:10201020282027FE4020B82011FC1000FC0011FC9504590451041D04E1FC4104
+92A2:200021FC5000480083FE780020202022FBB220B428A8B12861243A24E4A20040
+92A3:210021005100491E87D27A5222522252FA5224922A92B11262923A5EE4520800
+92A4:10201020292424A440A8B820102013FEFC7010A894A8592451241E22E0204020
+92A5:10401020282025FE4040B84010A010A2FDA412989490588850881CA4E0C24080
+92A6:100011FE290225224122B92211FE1122FD221152954A598A51021D02E1FE4102
+92A7:104010442A4425484150B84017FE1090FC9010909490589251121D12E20E4400
+92A8:10401020282027FE4202BC44104013FEFC881088950858D050201C50E0884304
+92A9:1008103C29E024204020B9FC10201020FC2013FE9420584050881D04E3FE4102
+92AA:1020102029FE24404240BCFC10841184FEFC1084948458FC50841E84F0944088
+92AB:1080108028F825084210BDFC11241124FD2411FC9500590051021D02E0FE4000
+92AC:1040104429F424484050BBFE10401080FDFE1240948058FC50041C04E0284010
+92AD:10281024283E25E04220BC3C11E01020FE3E11E09422582450181E6AF1864002
+92AE:02000100FFFE0440145024484444010006C01830EFEE01003FF811100920FFFE
+92AF:102010202848248841F0B82010401088FDFC1024942058A851241E22E0A04040
+92B0:1088108829FE24884088B80011041104FC8810889450582050501C88E1044202
+92B1:100010F82888248840F8B820102011FCFD2411249524592451341D28E0204020
+92B2:100011FC290425FC4104B9FC10001000FDFC102094205BFE50201C20E0204020
+92B3:10101090288825084204BDFA11081108FD0811F89490589050901D12E212440E
+92B4:080C08F07E8008800EFE78880888290816C81830EFEE01003FF811100920FFFE
+92B5:1020104028F8248840F8B88810F8108AFC8C13F89418582850481C88E3284010
+92B6:102810242824242043FEB820112010B2FCB4106894A8592452221C20E0A04040
+92B7:10101092285224544210BCFE10821082FEFE1082948258FE50821E82F08A4084
+92B8:100013FE292025284128B9E811281128FD2811E89528592A513A1FEAE0264020
+92B9:101C11E02820242043FEB8A811241222FDF81088949058BE51021D02E2144408
+92BA:242024203DFC0420FC2024F8450006C01830EFEE01003FF809200540FFFE0000
+92BB:11081088289025FC4024B82411FC1120FD2011FE946258A2512A1E24E4204020
+92BC:1020102028A824A840A8B97412221020FC2011FC9420582050201C20E3FE4000
+92BD:101C13E02A20262043FEBA201290130AFE0611FA9508590851081D08E1F84108
+92BE:200021FC5020482083FE780020202022FBB220B428A8B12861243A24E4A20040
+92BF:100011F8280824D04020B9FC11241124FDFC1124952459FC51241D24E124410C
+92C0:100011FE2800240042FCBC8410841084FEFC10009484584450481E00F1FE4000
+92C1:100010FC288424844284BC8410FC1000FE0011FE9502590251021F02F1FE4102
+92C2:1080108028FE250042FCB88410A41094FDFE10849524591451FE1C04E0284010
+92C3:1040102029FC25044104B9FC11041104FDFC11209522591451081D44E1824100
+92C4:100013FE282024A44128B85010881104FC0010FC9484588850501C20E0D84706
+92C5:1040102029FC24004088B85013FE1020FC20102095FC582050201C20E0204020
+92C6:108010FC7D04104410341CC4E11406C81830EFEE01003FF809200540FFFE0000
+92C7:100011FC2904250441FCB904110411FCFD04110495FC580050881C84E1024202
+92C8:101C09E0402024200BFE70501088110406C01830EFEE01003FF811100920FFFE
+92C9:102010202BFE24204020B9FC11241124FDFC1020947058A851241E22E0204020
+92CA:10881084290226224020B85010881104FE0210FC9484588450841C84E0FC4084
+92CB:2004200E53B8488880887928212E23A8F8A822A82AA8B13E61003A80E47E0800
+92CC:2000200653B8488880887908213E2388F88822882A88B13E61003A80E47E0800
+92CD:2020202053FE482080207BFE22022404F9F820102820B3FE60203820E0A00040
+92CE:1020101029FE25024204B8F810001000FDFE10509450585050921C92E10E4200
+92CF:10201020282025FC4020B8A810A810A8FD7412229450585050881C88E1044202
+92D0:1040102029FE25024244B84011FE1040FC501090949058A051241D42E27E4422
+92D1:104010402888250443FEB80210881144FE4210F895885A5050201C50E1884606
+92D2:1040104028FC24884150B82010D81326FCF8102094F8582053FE1C20E0204020
+92D3:204220E25382488A808A788A23EA208AF98A21CA2AAAB28264823882E08A0084
+92D4:1080108028F825084210B9FC11241124FD2411FC9450585050901C92E112420E
+92D5:2020202050204BFE80207820202021FCF840202028A4B282628A3A8AE4780000
+92D6:1004101E29E024224112B89410801020FDFE1044948459C850301C28E0C44302
+92D7:100010F82888248840F8B80011FC1104FD0411FC9504590451FC1D04E1144108
+92D8:100011FC2904250441FCB800100011FCFC20102097FE582050501C88E1044202
+92D9:100011FE2820242042FCBC44104411FEFE00100094FC588450841E84F0FC4084
+92DA:1040104024FE6488A55024202450218806C41830EFEE01003FF811100920FFFE
+92DB:2020202051FC4924812479FC20202020FBFE22222A22B3FE62223820E0200020
+92DC:100011FC290425044104B90411FC1020FC201120953E592051201EA0E47E4800
+92DD:1004101E29E024224112B89410801008FDFE10089488584850481C08E0284010
+92DE:100011FE280024924124BA4811241092FC0011FE9420582050201C20E3FE4000
+92DF:100011FC280424FC4004B9FC100013FEFE0211F89488588850501C20E0D84306
+92E0:100011FE29002500417CB900110011FEFD5011529554594851481E44E2524460
+92E1:10201020285024884144BA2210F81008FC10102095FC590451041D04E1FC4104
+92E2:1008103C29C024044144B8A8100011F8FC10102097FE582050201C20E0A04040
+92E3:200027DE50924C9284947C9427D82094F99221922A92B29A64943890E2900110
+92E4:2008200853C84A48825E7A4A23CA224AFA4A23CA2A4AB24A626A3BD2E6120026
+92E5:100011FC290425044104B9FC10001000FDFE1020942059FC50201C20E3FE4000
+92E6:100011FC2904250441FCB900110011FEFD02117A954A594A527A1E02E4144008
+92E7:100011F82908250841F8B908110811F8FD08110895F8589050901D12E212440E
+92E8:201020D85394489480907BFE20902094F89420D82B98B09060AA38CAE2860102
+92E9:1048104829FE24484248BC20101011FEFE8010809480588050801E80F0FC4000
+92EA:102810242BFE24204020B9FC11241124FDFC1124952459FC51241D24E124410C
+92EB:03043C0404247FA40E2415246484050C06C01830EFEE01003FF811100920FFFE
+92EC:101C11E0FD0011FC1D04F1681210312806C41830EFEE01003FF811100920FFFE
+92ED:110410842888241041FCB90411041104FDFC10509450589050921D12E20E4400
+92EE:202820245024482083FE7A2022242224FBA422A82AA8B29062923DAAE4460882
+92EF:10201120292025FC4120BA20102013FEFC00100095FC590451041D04E1FC4104
+92F0:100011FC2924252441FCB924112411FCFC20102095FC582050201C20E3FE4000
+92F1:201020145012481083FE781020902050F84820082888B2A8629A3AAAE4660002
+92F2:1010103829C025004100B9FC11101110FD10111097FE580050901D08E2044402
+92F3:102010202BFE242041FCB84013FE1048FC8810FE9508594852281C08E0284010
+92F4:102010202BFE24204020B9FC11041104FD0411FC9450585050921C92E112420E
+92F5:101C11E02820242043FEB8A811241222FC0010F89488588850881C8AE10A4206
+92F6:1020101029FE24204248BC8411FE1002FEA810A894A858A850A81EAAF12A4206
+92F7:200027E0525E4A5282527BD222522254FBD422542A48B2E867543854E0620040
+92F8:100011FC2904250441FCB910111011FEFD101110957C594451441D44E17C4244
+92F9:100010FC288024F84080B8F8108013FEFD4011249528591051081D44E1824100
+92FA:2040202053FE4A028504790021DE2252FA5223522C9AB09461103912E212040E
+92FB:7E7C48047E4442287E1048287EC4010006C01830EFEE01003FF811100920FFFE
+92FC:200023FE52024A8A82527BFE22222222FAAA22AA2AAAB2FA62023A02E20A0204
+92FD:10201020283E242041FCB90411FC1104FDFC112494205BFE50201C20E0204020
+92FE:1040104028FE24824142B87A10A21022FDFE102294AA58AA50FA1C02E0144008
+92FF:1020112428A424A84020B9FC11041104FD7411549554595451741D04E1144108
+9300:10201020285024884104BAFA100011FCFD54115495FC595451541D54E104410C
+9301:100011FC2924252441FCB924112411FCFC2011FE947058A851241E22E0204020
+9302:1020102029FC24204020BBFE10881144FE4210F895885A5050201C50E1884606
+9303:102009FE4122252009FC110472681410112806C41830EFEE01003FF80920FFFE
+9304:108010F82888250841F0B810101013FEFC201222957458A851241E22E0A04040
+9305:0640387C08947E241C442A94490806C01830EFEE01003FF809200540FFFE0000
+9306:102010202BFE242041FCB82013FE1000FDFC110495FC590451FC1D04E1144108
+9307:1080104029FC24004108B888109013FEFC00100095FC590451041D04E1FC4104
+9308:1020112428A8242041FCB84013FE1088FD0412FA9488588850A81C92E082407E
+9309:101C13E02A2027FE4220BA92130A1206FDFC1104950459FC51041D04E1FC4104
+930A:1040102029FE24004088B88811541222FC00102095FE582050201C20E0204020
+930B:200023DE52524A5282527BDE22522252FA5223DE2A52B25262523A52E55208A6
+930C:102011242924252441FCB80011FE1100FD7C1110951059FE51101E10E2104410
+930D:1040108029FC25244124B9FC11241144FDFC109095105BFE50101C10E0104010
+930E:10401040287C24844108BA00102011CEFD02110295CE590251021D02E1FE4102
+930F:100013FE285024504050B9DC11041104FD0411DC9450585050501C50E3FE4000
+9310:10A01090288025FE4110BB1015FC1110FD1011FC9510591051101DFEE1004100
+9311:2040202053FC4A0482047BFC22002228FA2423FE2A20B25062503C88E5040A02
+9312:2000277E55044D048574755426542554F5542554A574755426043404C4140408
+9313:10881048285025FC4020B82011FC1020FC2013FE9450585050901C92E112420E
+9314:102010222BB424A840A8B92412A21040FDFC1104950459FC51041D04E1FC4104
+9315:100011FC2904250441FCB904110411FCFC00111295D4591851101D52E192410E
+9316:08000E7C08047F4408282A104928194406C01830EFEE01003FF811100920FFFE
+9317:101C11E02820242043FEB8A811241242FC4013FE9488590850D01C30E0484184
+9318:2008203C51E0482083FE78A820A820A8FBFE20A828A8B3FE60203820E1FC0000
+9319:10921092292426484124B89210921000FDFE1122952259FE51221D22E1FE4102
+931A:1080108028F825084210B9FC10241024FDFE1024942459FC50241C20E0A04040
+931B:102010202BFE245040A8B92412FA1020FCA8108897FE588850881C88E1084208
+931C:202020205050488881447A2221F82008F850202028A4B282628A3A8AE4780000
+931D:2040202053FE4A02800079FC20002000FBFE20202928B12462223C22E0A00040
+931E:104010202BFE240041FCB90411FC1000FDFC100894105BFE50201C20E0A04040
+931F:102010A228A225244050B88813041022FC2010A494A4592850501C88E1044202
+9320:2040202053FE4A028404780023FE2020F8202120293CB12062A03A60E43E0800
+9321:1020102029FC24504088B90413FE1008FDE81128952859E851281C08E0284010
+9322:10481044285E25E04228BC12106A1196FE48105E95E0582450281E12F06A4186
+9323:200023DE5042494A8084794A22522420F80023DE2852B15260943948E2540422
+9324:108810882BFE24884288BCF810881088FEF8108894885BFE50001E88F1044202
+9325:104010202BFE24804104BBFE100211FCFD0411FC950459FC51041D04E1144108
+9326:1020104028FC248440FCB88410FC1020FC2011FE95225922512A1D24E0204020
+9327:1020101029FE25024204BCF810881088FEF81080948058FC50841E84F0FC4084
+9328:108810882BFE24884088B80011FC1124FD24112495FC592451241D24E1FC4104
+9329:10F81088288824F84088B88810F81000FDFC1104950459FC51041D04E1FC4104
+932A:10501050285025FC4154B954115411FCFD54115495545BFE50001C50E0884104
+932B:100010FC2884248440FCB884108410FCFC4010FE952A5A4A50921D22E04A4084
+932C:102010202BFE242041FCB92411FC1124FDFC1020947058A851241E22E0204020
+932D:100011FC292425244174B92411FC1104FD7411549554597451041E04E2144408
+932E:100011FC290425244124B9FC11241124FD7411549554597451041D04E1FC4104
+932F:10481048284825FE4248BC4811FE1000FEFC1084948458FC50841E84F0FC4084
+9330:10201020282025FE4020B87010A810A8FD2412229420580051541D2AE22A4000
+9331:010002800C603018DFF601003FF8111009207FFC00007EFE08103E7C08107EFE
+9332:100011F82808240841F8B808100813FEFC201222957458A851241E22E0A04040
+9333:100011FC280824104020BBFE102010A0FC4011FC9554595451541D54E3FE4000
+9334:1020102029FC24204020BBFE10881104FE22102095FC582050201C20E3FE4000
+9335:108810882BFE24884088B85010501094FD941298949058B250D21C92E08E4080
+9336:2020202053FE4820802079FC20202020FBFE204028A4B1A862903C88E0C60080
+9337:20882088208857E8888873E822A823E8FAA823E82888B7E8608A388AE08A0086
+9338:2020202050204BFE8020792421242124FAAA207028A8B0A861243A22E4200020
+9339:10201120293C25204120BBFE100011FCFD0411FC950459FC51041D04E1144108
+933A:110811082BFE25084148B82013FE1080FC8010F89488588850881D08E1284210
+933B:2010201451D2481280107BFE20102090F89022D02A90B290628A3AEAE7060202
+933C:2020202053FE48508088790422FA2000F80023FE2820B12461223A22E0A00040
+933D:100013FE282024A44128B85010881144FC4010FC95845A8850501C20E0D84706
+933E:1004FF7828407F7E08480F48F888090806C01830EFEE01003FF811100920FFFE
+933F:10201020283E242041FEB922113811E0FD22111E9500597852481E4AE48A4906
+9340:100011FC290425FC4104B9FC100011FEFC0813FE9408590850881C08E0284010
+9341:2010209057104C3E8422744427902510F5102510A528752825283944C9441082
+9342:10201020285024884104BA0210F81020FC2011FC9420592450A41CA8E3FE4000
+9343:2080208050FC4954825478A421242244F89421082840B0A462AA3A8AE4780000
+9344:104010202BFE24004000B9FC11041104FDFC10209528592452221C22E0A04040
+9345:221021102110547C8A1072102010217EF91022102E20B22462423AFEE2420000
+9346:200023DE52524A5283DE7A52225223DEFA0222022A02B20262023A02E20A0204
+9347:1110111229D425184152B992112E1040FDFC1104950459FC51041D04E1FC4104
+9348:108810882BFE248840A8B82011FC1124FD24112497FE582050501C88E1044202
+9349:100011FC2904250441FCB904110411FCFC0013FE94205920513C1D20E2A0447E
+934A:102010202BFE242041FCB92411AC1174FD2411FC9420587050A81D24E2224020
+934B:100010F82888248840E8B8A810A811FCFD0411749554595451741D04E1144108
+934C:0020112049FC22200BFE10907092110E16C01830EFEE01003FF811100920FFFE
+934D:2040202053FE4A4882487BFE22482278FA0022FC2A44B24862283C10E4680986
+934E:1008101C29F025104110B9FE1110117CFD44117C9544597C51441E44E27C4444
+934F:1020102028FC244441FEB80010FC1084FCFC102095FE582051201DFEE0204020
+9350:2000208852524A2282527A8A220223FEF88821442A7AB08861503820E0D80706
+9351:1040104028FE248041FCBA8410FC1084FCFC1040947C58C451281C10E0684186
+9352:100010FC2848243041FEB85210941110FE30102095FE587050A81D24E2224020
+9353:100010F82888248840F8B80013FE1088FCF8108894F85888509E1DE8E0084008
+9354:200023DE52524A5283DE780021FC2000FBFE20802900B1FC60043804E0280010
+9355:100013FE2A22242043FEB82011FC1124FDFC112495FC582053FE1C20E0204020
+9356:108810882BFE248840F8B88810F81088FC8813FE9500594851841D00E1FE4000
+9357:1040102029FC24004088B85013FE1222FC2411FC9524592451341D28E0204020
+9358:200223C252424A5283D27A52225223D2FA5222522BD2B00261823942E24A0404
+9359:1090089043FC2090089017FE7090110816C41830EFEE01003FF811100920FFFE
+935A:100010FC288424FC4084B8FC100011FEFC8010FE952A5A4A50921D22E0544088
+935B:2080233852284A2883A87A462200227CFBA422242A28B3A866103A28E2440282
+935C:200023DE52424A4282427BDE2200223EFBD222122A14B3D462083A14E2240242
+935D:11FC1124292425FC4124B92411FC1020FC2013FE96225A2A52FA1E0AE2024206
+935E:10201020283E24204020B9FC110411FCFD0411FC950459FC50001C88E1044202
+935F:100011FC290425FC4104B9FC10201120FDFE1220942059FC50201C20E3FE4000
+9360:1020104028FC248440FCB88410FC1000FDFE1020942058FC50201C20E1FE4000
+9361:100011FC2924252441FCB924112411FCFC0013FE9520592251141D48E1844102
+9362:100010FE2800247C4244BC44107C1000FEFE1092949258FE50921E92F0FE4082
+9363:1048104829FE24484200BDFC10441044FE94110896FC588450841E84F0FC4084
+9364:1008103C29E024204020BBFE102010A0FD2C1124952459AC51241D24E1FC4104
+9365:1080109E2BEA248A41CAB88A13EA1092FCA6102097FE582050501C88E1044602
+9366:22102110211057BE8A28724823AA22AEFABA22EA2AAEB2A864AA3CA2E9A2101E
+9367:1080108028FE25024242B9FA100211F2FC0211F2940259F251121DF2E0144008
+9368:101011D428582652418CB888110412FAFC20102095FE582050501C88E1044202
+9369:108810882BFE248840A8B82013FE1040FC8010FC95845A8450841C84E0FC4084
+936A:00207E20247E1884FF2829104A28994406C01830EFEE01003FF811100920FFFE
+936B:0620382008A47EA819202C504A88090406C01830EFEE01003FF811100920FFFE
+936C:208821C857084908812A712A27AC2148F3082388A554751429143124C1240142
+936D:108010BC2884250841FEBB201520117CFD90111095FE591051281D28E1444182
+936E:204020A051104A0885F6780023C42254FA5423D42A54B25463D43A44E25402C8
+936F:2080208050FC495482D478B4212C2244F89421082840B0A462AA3A8AE4780000
+9370:101E13E0284425244088B9FC10401040FDFE108094FC594451281E10E0684186
+9371:2048214851484BFE8148794821782100F9FE20202BFEB07060A83924E6220020
+9372:100011FC290425FC4110B9FE1110114AFD86100095FC590451FC1D04E1FC4104
+9373:3F2024203F3E21403F5024883F08010006C01830EFEE01003FF811100920FFFE
+9374:102011242924252441FCB80013FE1020FC4011FC9554595451541D54E154410C
+9375:20102010577C491481FE7214227C2710F17C2510A5FE721022103500C8FE0000
+9376:100011FC2924252441FCB924112411FCFC2010109454594251421D4AE2384000
+9377:102010202BFE24504088BB2611FC1020FC2013FE9400582051FC1C20E02043FE
+9378:1080109E289225D24092B89E109211D2FD52115E9552595251D21C22E02A4044
+9379:104010202BFE26024404B9FC100011FCFD0411FC950459FC51041C00E3FE4000
+937A:1020102229FA24244028BBFE10201040FCFC1184968458FC50841C84E0FC4084
+937B:100011FC290425FC4104B9FC108011FEFE2211229552590251FA1C02E0144008
+937C:2008200C500A4BFE82087A0822E8220AFA0A22EC2AACB2A862EA3A1AE2260442
+937D:1040102029FE25024102B9FE11001100FDFE11AA96AA5AFE54AA1CAAE0A24086
+937E:1008103C29E0242043FEB82011FC1124FDFC112495FC582051FC1C20E3FE4000
+937F:1052105228A425FE42A4BC5210521000FEFE1092949258FE50921E92F0FE4082
+9380:1090109E28A225544108BB5415621140FD4411589542594451181D02E10C4130
+9381:20002FDE54924C928494779424982494F7922492A49275DA2E943090C0900090
+9382:110410882BFE24204020B9FC10201020FDFE100094205BFE50201C50E0884306
+9383:2008241C52E04A80888C74B024A822AAF2AC24A8ACA874A824A43524C5320220
+9384:104010202BFE240041FCB90411041104FDFC10529494598852881CA4E0C24080
+9385:11FC1124292425FC4124B92411FC1050FC881104968A588850881C88E1084208
+9386:2108208850904BFE80007BC422542254FBD422542A54B3D462543A44E25402C8
+9387:100011FC2924252441FCB900117C1144FD44117C9544597C51441E44E27C4444
+9388:10841044284825FE4020B8FC102011FEFC40108094FE591052101C10E1FE4000
+9389:100011FC290425FC4104B9FC100013DEFC421252954A58C6535A1C42E14A4084
+938A:1020101029FE24844048B9FE11021224FC1011FE9440587C50441C84E0944108
+938B:2040202053FE4A02842479FC202021FCF82023FE2820B1FC61043904E1FC0104
+938C:10881050280025FE4050B9FC105413FEFC5411FC945058D851541E52E0504050
+938D:2020202053FE482083FE7A42248C21F0F82020442BFEB02261283A24E4A40040
+938E:2100210051FC4A0085F8780023F82088FAA821C82BF8B08A61CA3AAAE0860082
+938F:204017FE8090490813FCE1502252244E010006C01830EFEE01003FF80920FFFE
+9390:1008103C2BC024044244B92811FC1220FC2013FE9420592451241D24E1FC4004
+9391:1020102028FC24204020B9FE10401084FDFE100295FC595451541D54E3FE4000
+9392:100011FE2900257E4100B9FE11541148FD641142950459FE51441E24E204440C
+9393:2090208851044A42848879FC20042000FBDE20422A52B14A62523842E14A0084
+9394:104010202BFE26024050B88811241050FC88110496FA588850881C88E0F84088
+9395:1020101029FE2510417CB91411FE1114FD7C1110957C594451441E44E27C4444
+9396:1020112428A8242041FCB904110411FCFD0411FC9504590451FC1C00E0884104
+9397:102010202850244840A4B9FE128410FCFC8410FC948058FC51441D44E27C4044
+9398:200023FE500049FC8104790421FC2000FBFE228A2A52B3FE62223A22E22A0204
+9399:2440225E5292481287D2791E25522552FD5227DE2952B11262123A22E42A0844
+939A:10101220297C25444044B87C13401140FD7C11449544597C51441E80E47E4000
+939B:102810242BFE242041FCB92411FC1124FDFC112494085BFE50881C48E0484018
+939C:10003E782A482248FE862B7842484A30854806C41830EFEE01003FF80920FFFE
+939D:108810882BFE24884020B85010881104FEFA1000940059FC51041D04E1FC4104
+939E:1020104029FC25044154B92411541104FDFC1000951259D451181D52E192410E
+939F:21F820885070498C80007BDE2252218CFA5220202BFEB07060A83924E6220020
+93A0:200023FE52524A5283FE7800200023FEF8202020293CB12061203920E7FE0000
+93A1:2084204450484BFE808478842108214AFA52239C2884B10861083A52E3DE0042
+93A2:1040108029FC25044104B9FC110011FEFD0011FE94025AAA52AA1C02E0144008
+93A3:08202AA44D28145022887FFE410286C41830EFEE01003FF809200540FFFE0000
+93A4:100011FC290425FC4104B9FC10201124FCA8102097FE589050901D12E212440E
+93A5:108011F822886870AB8E282029FC28A8216406C01830EFEE01003FF80920FFFE
+93A6:204023BE52124A9282527AAA23242040FBFE22222A22B3FE62223A22E3FE0202
+93A7:102011242924252441FCB80013FE1000FDFC1104950459FC50881C50E3FE4000
+93A8:10A0109029FE272041FCB92011FC1120FDFE110094205BFE50201C20E0204020
+93A9:2000245C529449148294745421262100F7DC2114A594755429483108C5140222
+93AA:10A0112C2924252441ACB924112411FCFC2011FC9488585050201C50E0884306
+93AB:1020104029FC25044154B92411541104FC881144967A588851501C20E0D84706
+93AC:1020101029FE240040FCB88410FC1000FDFE1102957A594A517A1D02E10A4104
+93AD:111811E0290224FE4000B97C1144117CFD44117C9544597C51001DFEE0884104
+93AE:102010202BFE242041FCB90411FC1104FDFC110495FC590453FE1C88E1044202
+93AF:2100209E53D24A5282547BD422582254FBD222122A92B25A62D43B50E2100010
+93B0:10881050280025FC4000B85010881104FC0011FC9554595451541D54E3FE4000
+93B1:1020102029FC242043FEB80011FC1104FD0411FC9452589451881EA4E0C24080
+93B2:1020112428A8242043FEBA02100011FCFD04110495FC585050501C92E112420E
+93B3:1020104029FC250441FCB90411FC1104FDFC102095FE587050A81D24E2224020
+93B4:1020104029FC250441FCB90411FC1104FDFC1040942058A4528A1E8AE4784000
+93B5:2040202053FE4A02800079FC204020A2FB3420582894B33460523890E3500020
+93B6:100013FE280825E84128B9E8100013FEFC0811E89528592851E81C08E0284010
+93B7:200021FE512049FC812079FC21202120F9FE20022AAAB2AA62AA3A02E0140008
+93B8:20A0209051FE4B2085FC792021FC2120F9FE21002BFCB088609E3902E20A0404
+93B9:102210122914248040BEB808100811BEFC8810889494589250A21D40E23E4000
+93BA:22002100513C482487A478A4213C2124FBA42564293CB12461243924E17E0100
+93BB:109211242A4825244092B80011FC1104FDFC110495FC590451FC1C88E1044202
+93BC:1020103C282025FE4122B93811E2111EFD0411789510597C51101EFEE2104430
+93BD:2020222253FE488081F87A882070238EF82021FC2820B1FC60203BFEE0200020
+93BE:100010F82888248840F8B888108810F8FC0011FC9554595451541D54E3FE4000
+93BF:10201050288825744202B8F8108810F8FC0C11F0942059FC50201DFEE0204060
+93C0:20202020503E482080207BFE22022326FA8A22522B26B252628A3B26E3FE0202
+93C1:112412482924240041FCB92411FC1124FDFC102097FE587050A81D24E6224020
+93C2:200023FE52004A7C82447A44227C2200FAEE22AA2AAAB2AA62EE3A00E3FE0000
+93C3:2220212051204FBE82407A2023BC22D0FA9022902AFEB29064A83DA8E8441082
+93C4:102013FE282025FC4124B9FC112411FCFC2213FE94085BFE51081C88E0284010
+93C5:2120213C214452A88A1076A82AC622BCFAA422BC2AA4B2BC62243A24E224022C
+93C6:100011FC292427FE4124B9FC100011FCFD0411FC950459FC51041DFCE0884104
+93C7:22102110211057BE8A40720023BE228AFA8822A82AAEB2A864A83DA8E85E1080
+93C8:2010201052FE4910817C7854207C2354F97C211029FEB11061103A90E47E0000
+93C9:2108210857C84908811E77D225642540F7C82108A388754829543114C1240142
+93CA:08207F20083E7E440884FF2820103E28434486C21830EFEE01003FF80920FFFE
+93CB:2088208853FE4888808878F8202023FEFA2223322AAAB37662223A22E22A0224
+93CC:108810882BFE24884000B9FC110411FCFD0411FC94205BFE50501C88E1044202
+93CD:100011FC292425FC4124B9FC10401088FDF0102094445BFE50221D24E2224060
+93CE:200021FC512449FC812479FC20A820A8FBFE20A828A8B1FC60203BFEE0200020
+93CF:208823DE508849DC80887BDE20882000FBFC20042804B1FC60043804E3FC0004
+93D0:200023DE50424A52814A7A52202820C4FB1220602988B03261C43818E0600380
+93D1:104010202BFE24884050BBFE122212FAFE2212FA968A5A8A52FA1E02E20A4204
+93D2:2040208851FC490882527BFE20502188FE2620C02B10B06463883830E0C00700
+93D3:1020104029FC2524417CB98C11541124FD5411FC9420581051541D42E14A4238
+93D4:104010202BFE26024000B9FC102011FCFD2411FC952459FC50001C88E1044202
+93D5:2040202053FE4A5082507BFE22522252FBFE22002A92B2D462983C92E4D2088E
+93D6:00803FFE22203FFC22243FFC242027BC246227BE23182DF6204047FC42488FFE
+93D7:200023DC52944BD482547BC822882294FBE220002820B1FC60203820E3FE0000
+93D8:20882288529E4AAA82947B88209020A4F88427BE2A84B2A462943A84E4940088
+93D9:102012222BFE24904088B9FE13101510FDFE1110951059FE51101D10E1FE4100
+93DA:200C200A50084BFE82087A48226A224AFBFA224C2A4CB2EC635A3C4AE4D60822
+93DB:1020112428A827FE4202B8F810881088FCF8102095FC592451241D34E1284020
+93DC:1020112428A827FE4202B8F810881088FCF81020942059FC50201C20E3FE4000
+93DD:100011F8290825F84108B9F8100013FCFE9413FC940059F850901C60E1984606
+93DE:101011FE2910257C4114B9FE1114117CFD10117C9554597C51541E7CE254444C
+93DF:1020101029FE24004084B84811FE1110FD50117E95905910517E1E10E21044FE
+93E0:2020247C52844948803078CE2610227CFA10227C2A10B2FE62103A10E5FE0800
+93E1:1040102029FC24884050BBFE100011FCFD0411FC950459FC50901C92E112460E
+93E2:100013FE285025FC4154B95411FC1000FDFC100097FE582050A81D24E2A24040
+93E3:1040102029FE25004148B94811FE1148FD4811489578590052D41EAAE52A4800
+93E4:102011FC292427FE4124B9FC102011FCFD2411FC94405BFE50881DD0E070438C
+93E5:102010102BFE26024080B8FE11101320FD7C11449544597C51441D44E17C4144
+93E6:112411242A2424A441547D4A9392150879081128952E592851281D58E14E4180
+93E7:08007F7808483E4800863E782A483E30414886C41830EFEE01003FF80920FFFE
+93E8:08047F7808403E402A7E3E482A48FF48098806C01830EFEE01003FF80920FFFE
+93E9:21002102511C4FD0811077D0255E27D4F55427D4A11477D421143124C1240144
+93EA:2090209057FE489083FC7A9423FC2294FBFC200029F8B10861F83908E1F80108
+93EB:2062238A208A57EA888A71CA22A2248AF8A420202BFEB07060A83924E2220020
+93EC:2040207C50404BFE82427A7823C4223CFA0822F02B24B2A865FE3C20E8A00040
+93ED:201C21E05020492480A87BFE207020A8F92422222840B02462A23A8AE4880078
+93EE:1020101029FE2510417CB91411FE1114FD7C11109592595451381E54E2924430
+93EF:2020202053FE482082AA792422AA2020FAAA21242AAAB05060503888E1040602
+93F0:2020222252224BFE80007BDE22522252FBDE22522A52B3DE62523A52E55A08A4
+93F1:102011FC2888245043FEB80011FC1104FDFC110495FC582053FE1C20E0204020
+93F2:202023FE504848F080207BFE22422090F9F820282920B1FC62203BFEE0200020
+93F3:2104208850004BFE82227AAA22722222FBFE200029FCB10461FC3904E1FC0104
+93F4:2010279054BC4CA484C477A821102128F14625C0A53C7524252435A4CE3C0024
+93F5:108813FE2888240041FCB8A810A813FEFCA810A895FC582053FE1C20E0204020
+93F6:10A0109029FE272041FCB92011FC1120FDFE110094205BFE50701CA8E3264020
+93F7:105012522954245043FEB888105013FEFC2011FC94205BFE50501C88E1044602
+93F8:2020202053FE482081FC792421FC2124F9FC20222BFEB04260243AA2E28A0478
+93F9:200023BE50A248A280BE7B882208223EFA2A23AA28AAB0BE6088388AE57E0202
+93FA:202423A8209255148A08740423BA20A8F8C623802A3CB38460A83890E2A80144
+93FB:2020212450A84BFE80A8792422222104F90421DE2A44B554609E3904E2040404
+93FC:2210221053DE4D2880A4782023FE2020FBFE22222A2AB27460A83924E6220020
+93FD:204023F850484FFE804873F820402554F75C2444A7FC7444275C3554C5540844
+93FE:2288228857C84A90829E77D4202427D4F45427D4A45477C824483454C46404C2
+93FF:2020212450A84BFE820278F820882088F8F820202BFEB07060A83924E2220020
+9400:102011FC292425FC4020BBFE100011FCFD0411FC950459FC51041DFCE0884104
+9401:22402242525C4FF082507BD0225E23D4FA5422542FF4B01462943C64E8240044
+9402:200023FE50504BDE82527A5223DE2050FBFE22222A22B3FE62223A22E3FE0202
+9403:2020202051FC482083FE7908239C2108F988263E2800B3FE60903890E112020E
+9404:1088108829FC24884088BBFE102011FCFD2411FC952459FC50001C88E1044202
+9405:49202A3E7F4849485DA86B104928414406C01830EFEE01003FF811100920FFFE
+9406:010878904BFC504049A4445855B4485241B046C01830EFEE01003FF80920FFFE
+9407:103C13E0292424A843FEB8A811241202FDFC1124952459FC51241D24E1FC4104
+9408:101811E0284027FE4088B97412521070FC0011FC9504597451541D74E104410C
+9409:100013DE2A5227DE4210BA5211CE1000FC8813FE9488588853FE1C88E1044202
+940A:2000277C55444D7C8544757C260025FEF540257EA5AA752A264A3492C42A0444
+940B:2000227C5144497C84447A7C220021FEF940227E2EAAB32A624A3A92E22A0044
+940C:208020F851084BFE8512792221FE2040F8A223542898B33460543892E3500020
+940D:11F81050282027FC40A4B92812A01040FDFC1154958C597451541D74E104410C
+940E:1090108829FE25104310BDFE11101110FDFE1110951059FE51001EA4E2524452
+940F:108810502BFE245041FCB954118C1174FD0411FC94085BFE51081C88E0A84010
+9410:1020102029FC24204154B888110412FAFC8810F8948858F850201CA8E1244060
+9411:208820885108493E82487B88209C2100FA4023DC2814B05462B43A94E21C0014
+9412:208822AA22DC548889547222200023FEFA4224442BFCB04460443884E1140208
+9413:2108208853C8481083DE7A6423D42014FBD420542894B0E863883894E2940122
+9414:200023FE50504BFE82527BFE200021FCF90421FC2904B1FC60203BFEE0200020
+9415:200023DE50884AA883FE798822DA24A6F9F821082908B1F861083908E1F80108
+9416:2124212452AA4BAE81247AAA23AE2124FBFE21102914B114628A3A4AE2160422
+9417:23DE225253DE4A5283DE7A0222F22292FAF222922AF2B29262923B32E2020206
+9418:102011FC2888245043FEB80011FC1124FDFC112495FC582051FC1C20E3FE4000
+9419:101010D42848254A4284BC84117A1000FEFC108494FC580050841E48F1FE4000
+941A:100013FE285025DC4104B90411DC1050FC5013FE9440582050A41E8AE28A4478
+941B:100011FC290425FC4104B9FC102013FEFC0011FC950459FC50201D24E2224060
+941C:08207F20223E3E4400843E2804107E2809442EC21830EFEE01003FF80920FFFE
+941D:200027FE54004E28854877EE24922484F6A026A8A7E8748824943514C9241242
+941E:100011FC280424FC4004B9FC100011DCFC9413DC94085BFE51081C88E0A84010
+941F:108810882BDE248847FEB88811541222FDFC1104950459FC51041D04E1FC4104
+9420:2108209053FC489082947998209027FEF80021F82908B10861F83908E10801F8
+9421:2094209253F2489087FE701023D22252F25223D4A454728C20EA370AC0160022
+9422:22882108FABE2008729CA92A2288210806C01830EFEE01003FF811100920FFFE
+9423:112410A82BFE260240F8B88810F8100CFDF0102095FC582053FE1C20E0A04040
+9424:21F8210851F84D0A85FA750A25FA2402F79E2090A0907F9E24923492C4920892
+9425:108810502BFE242041FCB82013FE1124FCA813FE940059FC51041D04E1FC4104
+9426:200023DE52524BDE82527BDE220222FAFA5222522BFEB25262523A92E20A0204
+9427:200023DE52524BDE82527BDE220222FAFA8A22FA2A8AB2FA628A3A02E20A0204
+9428:109017FC289427FC4290BBFE111213FAFD0E11F8950859F851081DF8E0904108
+9429:104412242928247E4010B828134A111CFD28114C951A592A51481D10E2FE4400
+942A:1020103E282025FE4122B9FC1122117EFD54117C9554597C51101EFEE22244C6
+942B:20A0209051FE4B2081FC792021FC2120F9FE21002BDEB25262523A72E2020206
+942C:2020213C51204BFE8010781423FE2210FBF022542A54B2D463683C4AE8960322
+942D:2040208053FE4A2282AA7A2223FE2272FAAA22022820B3FE60503888E1040602
+942E:202023FE52884A5083FE7A5022FC2254FBFE22542AFCB25062D83D54E6520850
+942F:108810882BFE24A840227DFA902410287BFE104094FC598452FC1C84E0FC4084
+9430:10F81088288824F84000B9DC11541154FDDC102095FE587050A81D24E2224020
+9431:10201020285024884104BAFA10001000FDDC1154955459DC50881C88E1544222
+9432:100011FC2954255441FCB88011FC1244FDF41154955459F450441DF4E0144008
+9433:100011FC282027FE4222B9AC102011ACFC0011FC9524592451FC1D24E12441FC
+9434:201023C8527E4A4082627BD42200223EFBC822482E7EB24862483BC8E2480008
+9435:208C23EA50884BFE80087BE8222A23EAF80A23EC288CB3EC608A38EAE3960022
+9436:100011FC2954255441FCB80013FE1000FDFC110495FC586250941D88E2A440C2
+9437:108813FE288824004148BBFE11481178FD0011FC94205BFE50701CA8E3264020
+9438:100011FC295425FC4020B9FC102013FEFC88105095FC582053FE1C20E0204020
+9439:2000227C514449748054785426FE2282FABA22AA2ABAB282628A3A84E50008FE
+943A:1020112428A827FE4202B8F810881088FCF8100095FC592451FC1D24E1FC4104
+943B:2040207C50404BFE82427A7823C4223CFA0023FE2A40B3A462583DB4E45209B0
+943C:102011FC2820248843FEB88811FC1104FDFC110495FC590451FC1C88E1044202
+943D:10101210297C241040FEB844132811FEFD10117C951059FE51101D10E2FE4400
+943E:3E1022FE3E4420287EFEA2103EFC231006C01830EFEE01003FF811100920FFFE
+943F:1040102029FC24884050BBFE100011FCFD0411FC950459FC50201E94E28A447A
+9440:100E11F028A2245441FEB92210141152FD4A12389440587C50841D48E03041CE
+9441:2020208852524B2682527A8A222223FEF88821442A7AB08861503820E0D80706
+9442:101C11E0282027FE4020B9FC11AC1174FDFC102095FC582053FE1C00E154422A
+9443:100011DC2844255440CCB95410001048FCFE119096FC589050FC1C90E0FE4080
+9444:202023FE502049FC80007BFE200221FCF82023FE2800B3FE60043BBEE2A4038C
+9445:208822AA22DC548889547222200023FEFA2220202BFEB07060A83924E6220020
+9446:2144214455544B64814E7BE42004222CF94423E42884B3E4608438E4E7140008
+9447:2040202053FE4888805277AC22AA22A8F5AC2000A10471FC210431FCC1040204
+9448:200027FC224854448FFE744426EC2554FEEC24442EECB55466EC3C44E4540408
+9449:108813FE2888242041FCB82013FE1040FC8811FC940059FC51541D54E7FE4000
+944A:108813FE28A8249041FEBB2011FC1120FDFC112095FE590053FC1C88E070438E
+944B:1000FEFE10547CA854547C7C5410FEFE110006C01830EFEE01003FF80920FFFE
+944C:2040202053FE4A0281FC7948225021FCFB0421FC2904B1FC610439FCE0880104
+944D:3EF822883EF822883EF822883EF81450238806C01830EFEE01003FF80920FFFE
+944E:23FE222052FC4AA482FC7A2023FE2284FAFC22842AFCB28462FC3A48E28403FE
+944F:104010202BFE26224154B94A123A1000FDFC115497FE580051FC1C20E0A04040
+9450:100011FC282027FE4222B9AC102011ACFC0013FE942059FC51541D54E154410C
+9451:200823E852884BEE82287BF4228223E2F80021FC2954B15461543954E7FE0000
+9452:7E40487E7E9043087EFE48AA7EFE010006C01830EFEE01003FF811100920FFFE
+9453:1010107C2A54257C4110B8FE1000137CFD44117C9540597C51441D7CE280447E
+9454:2040202053FE4A02851479DE22522554FA8821742A02B1FC60203924E2220060
+9455:2042239C52104BDE82947A94242023FCFA0423FC2A04B3FC62043BFCE1080204
+9456:210827FE5108480083FC7A94229423FCF82823FE2A20B32462A83A92E42A08C6
+9457:10501190289E27EA408AB9D2128A10A4FC501088972658A850701CA8E1244060
+9458:23F8224852484BF88248724823F82000FFBE2AAAAAAA7FBE2AAA3AAACFBE08A2
+9459:2394211027BE51188BAA7546221823E0FA0421FC2800B3F862083BF8E20803F8
+945A:108811DC288825DE4088B954122211FCFD0411FC950459FC51041DFCE0884104
+945B:1020101029FE2528417CB92811FE1110FD7C1154957C5954517C1E00E2444482
+945C:112410A82BFE260240F8B88811FC1104FDFC110495FC590451FC1C00E0884104
+945D:208823FE50884820823C7944203820D6FB382110297CB110617E3910E31004FE
+945E:212422485124480083FC7A9422642294FBFC22482B68B248636A3A4AE2460362
+945F:102013FE282025FC4000BBFE125213FEFD0411FC950459FC51041DFCE0884104
+9460:244424E458A84AAA8EEE74A42AAA2EEEF2422040AFFE70E021503248CC460040
+9461:20202120513C492087FE78902294236CFA0423FC2A94B294636C3A04E3FC0004
+9462:2020203C50204BFE82227AF8222422FCFAA422FC2AA4B2FC64203D54E94A023A
+9463:2040202053FE4A5083FE7A5223FE2200FA9422D82A90B2D2628E3C00E5540A2A
+9464:11FC110429FC250441FC7C8891FC10887BFE108895245AAA50701CA8E1244060
+9465:108011F82A0825FC4124B9FC112411FCFD54122A95FC590451FC1D04E1FC4104
+9466:27DE251227D254548FC8751427E22000FBFC22042BFCB20463FC3A04E3FC0108
+9467:102013FE2A8A25FC4088B9FC110411FCFD0411FC950459FC50901C94E112420E
+9468:2110209053DE4810825E798223DE2010FBDE22502BDEB25063DE3A50E25202CE
+9469:200023FE50204BAE82AA7AAA23AE2020FBFE20202BAEB2AA62AA3BAEE02003FE
+946A:2040207C50404BFC82447BF0224422FCFAA822F82AA8B2F862003DFCE5540BFE
+946B:010006C01830EFEE01001FF009203FF8101028287C7C92927C7C10105454FEFE
+946C:13D012902BDE266843C4BA8413F81108FDF8110895F8590851F81C90E112460E
+946D:23DE225253DE4A5283DE7A2222FA2222FAFA22AA2AFAB2AA62FA3A72E2AA0226
+946E:208823FE208854128AFE701024FE2292FAFE209229FEB29266043AFEE244022C
+946F:2148214C52AA480883FE79482368214AFB6A214A2B6CB14C616A3B8AE0160022
+9470:10201050288825744202B9FC115411FCFC0011FC9554595451FC1D54E154410C
+9471:21F0221057FC4A0483FC7A2423B82222F9FE22102FFCB24463FC38D0E14A063E
+9472:102013FE280025DC4154B9DC108813FEFC8813FE94885BFE50941D88E2A440C2
+9473:204027FE54924BFC80907BFC209027FEF90823FC2D0AB1F862403A7CE54008FE
+9474:222223FE209051FE8B1075FE211021FEF91021FE2900B3FE628A3B76E2520276
+9475:208823FE50884BDE82527BDE20A02090F9FE21202BFCB52061FC3920E1FE0100
+9476:2090209057FE4894800A71FE250827E8F14A21EAAF2A75EA254C39EAC2160462
+9477:23FC210851F8490881F8790E27F82008FFFE22942B9CB294639C3AD6E7BC0084
+9478:27FC244457FC4C4487FC70002FBE2AAAFFBE2AAAAFBE7040204037FCC0400FFE
+9479:204027FE5492490880807B1C2204239CFA0423FC2A48B36862483B6AE2460362
+947A:23DE225253DE4A5283DE7A5223DE2090F9FE21102BFEB51061FE3910E1FE0100
+947B:22A8224857BE4AA8875C7AAA22882FFEF21825E4A84273F8204037FCC04000C0
+947C:200023FE52524A5283FE71082154225EF7B4211EA25477DE20143554C55E0010
+947D:252827BE294857BE8B1875AA294623FCFA0423FC2A04B3FC62043BFCE1080204
+947E:21084FD2F03C23884812FBBE0280ABAA010006C01830EFEE01003FF80920FFFE
+947F:55781448FF4822867F7808486B2849107F2806C41830EFEE01003FF80920FFFE
+9480:210821EC510A4FEA89287BC8293E2FE8F9482BE8AA287B682AA83BF4CAB412A2
+9481:23DE225253DE4A5283DE78A021FE2320FDFC212029FEB00061FC3888E070078E
+9482:2248215057FC4C0481F0711027FC2554F4E427FCA04077FC20403FFEC2A40452
+9483:23FE220253FE4A9282547A9222FE22AAFAFE23222AFAB2AA62FA3A22E5FA0004
+9484:208823FE50884BDE82527BDE225223DEFA2223FE2AAAB2FA62223A72E2AA0224
+9485:100010001E00200020007C0090001000FE001000100012001400180010000000
+9486:108010801E80208020807C8090801080FE8010801080128414841884107C0000
+9487:100010003DFC20084010BC2010401040FC801080110011041504190410FC0000
+9488:102010201E20202020207C2093FE1020FE201020102012201420182010200020
+9489:100010003DFE20204020BC2010201020FC201020102010201420182010A00040
+948A:100410041E04204420447C4490441044FE441044104412041404180410140008
+948B:104010401E40204020407C6090501048FE441044104012401440184010400040
+948C:100011FC1E04200820107C2090201020FE201020102012201420182010A00040
+948D:102010203C2020204020BC2011FC1020FC201020102010201420182013FE0000
+948E:1008103C3DE020204020BC20102013FEFC201020102010201420182010200020
+948F:110411243D2421244124BD2411241124FD2411241124112415241A2412040404
+9490:100810081E10202020407C8890081010FE201044108412081410182010C00300
+9491:100013FC3C8420884088BC90109C1084FD4411441128112816101A2814440182
+9492:100011F03D1021104110BD1011901150FD5011101110111215121A12120E0400
+9493:104010403C8020FC4104BE0410041104FC841044104410041404180410280010
+9494:108010403C5E21024102BD0211021102FD0211021102110215021902110A0104
+9495:104010403C40204043FEBC8810881088FC881108109010501420185010880304
+9496:100011F83C1020204040BC8011FC1054FC541094112410241444188411280010
+9497:100013FC3D0421444124BCA810881088FC501050102010201450188811040602
+9498:100011FC3C8820884088BC88108813FEFC881088108810881488190811080208
+9499:100013FE3C2020204120BD3E11201120FD2011FE100210021402180210140008
+949A:100010003DFE20104010BC2010201068FCA41122122210201420182010200020
+949B:102010201E20202020207DFE90201020FE20105010501250148818C811240202
+949C:100011FE3D0021004100BDFC11041104FD04110411FC11001500190011FE0000
+949D:20402040384027FC40407A48A2482248FA4823F82048204028423042203E0000
+949E:102010203C2020A840A4BCA211221120FE241024102810081410182010C00300
+949F:102010203C20202041FCBD2411241124FD2411FC112410201420182010200020
+94A0:102010203C2021FE4122BD2211221122FD52114A118A110215021902110A0104
+94A1:100011FC3D0421044124BD2411241124FD241124112410501448188411020602
+94A2:100011FC3D0421044194BD5411541124FD241154115411941504190411140108
+94A3:1008101C3DE021004100BDFC11441144FD4411281128111015101A2812440482
+94A4:102010203C5020504088BD4412221020FC0011FC100410081408181010100020
+94A5:100010FC3C8420844084BCFC10841084FC8410FC108410841504190412140408
+94A6:104010403C40207C4084BC8811201020FC201050105010501488188811040202
+94A7:104010403C8020FC4104BE0410841044FC441014102410441584180410280010
+94A8:102010403CFC20844084BC8410941088FC8010FE1002100215FA180210140008
+94A9:108010803C8020FC4104BD0412441044FC8410A4111411F41414180410280010
+94AA:104010203C0021FC4000BC0010F01090FC9010901090109214921912110E0200
+94AB:104010203C2023FE4080BC80108010FCFC841084108410841504190412280410
+94AC:102010201E20202420A47CA490A81120FE201050105012501488188811040202
+94AD:101011103C9020904010BD1010901090FC10101E13F010101410181010100010
+94AE:100011F83C4820484048BC48104811F8FC881088108810881488188813FE0000
+94AF:100011FC3D2421244124BD24112411FCFD041100110011001502190210FE0000
+94B0:100010003DFC20204020BC2010201020FDFC1020102810241424182013FE0000
+94B1:105010483C40205C41E0BC40105E11E0FC441048103010221452188A13060002
+94B2:100010003DFE20104010BC1010901090FC9E1090109010901490189013FE0000
+94B3:108810883C88208843FEBC8810881088FC8810F8108810881488188810F80088
+94B4:102010203C20202043FEBC2010201020FDFC1104110411041504190411FC0104
+94B5:102010203C20202041FEBC7010A810A8FD241124122210F81420182010200020
+94B6:100010003DFE20084008BDE811281128FD28112811E811281408180810280010
+94B7:100011FE3D002100417CBD4411441144FD441144117C11441500190011FE0000
+94B8:20402040384023FE408078A0A12021FCFB242524212421242934312820200020
+94B9:105010483C48204043FEBC80108010FCFD4411441128112816101A2814440182
+94BA:202820243824202043FE7A20A2242224FA242228222822902B12322A20460082
+94BB:102010203C202020403EBC2010201020FDFC1104110411041504190411FC0104
+94BC:100011FC3D0421044104BDFC11041104FD0411FC110411041504190411FC0104
+94BD:100010003DFC21044104BD0411FC1104FD04110411FC11041400180013FE0000
+94BE:100011FC3D2421244124BDFC11241124FD2411FC112410201420182010200020
+94BF:100010003DFC21244124BD2411241124FDFC1124112411241524192411FC0104
+94C0:102010203C20202041FCBD2411241124FD2411FC112411241524192411FC0104
+94C1:102010203D20212041FCBD2012201020FDFE1020105010501488188811040202
+94C2:102010203C4021FC4104BD0411041104FDFC1104110411041504190411FC0104
+94C3:2040204038A020A041107A48A4262020FBF820082010211028A0304020200020
+94C4:2008203C3BC0220042207A20A22023FEF8202020212821242A22342220A00040
+94C5:100010F83C8820884088BC8811061200FC0011FC110411041504190411FC0104
+94C6:200020803B1E225242527A52A2522252FA5222D2235A22542890309021100210
+94C7:108010803DFC21044204BDF411141114FD1411F4110411281512190210FE0000
+94C8:104010203C0023FE4020BC2011FC1124FD241124112411241534192810200020
+94C9:102010103C1021FE4020BC2010441084FDF8101010201044148219FE10820000
+94CA:102010103C1021FE4102BE0410801088FC9010A010C0108214821882107E0000
+94CB:104010203C2820084008BC4810541152FD5211601260104414C41944123C0000
+94CC:100011FC3D0421044104BDFC11001140FD4411481170114015421A42123E0400
+94CD:101010103C1021FE4112BD14111011FCFD4411441128112815101A2812440482
+94CE:100013FC3D0420884050BC2010D81326FC2011FC1020102017FE182010200020
+94CF:200427C43A84229442947A94A29427D4FA942294229422942A84348424940888
+94D0:104010443DF420484050BDFE10401080FDFE1240148010FC1404180410280010
+94D1:104010403C4421F44048BC5013FE1040FC801184129810E014821882107E0000
+94D2:100011FE3C8820884088BCF810881088FCF810881088109E15E8180810080008
+94D3:104810483DFE20484048BC20101011FEFC801080108010801480188010FC0000
+94D4:200023FC3890209040907892A4922294FA942298209020902890309027FE0000
+94D5:102010203DFE20404040BCFC10841184FEFC1084108410FC1484188410940088
+94D6:202820243824202043FE7A20A2242224FBA422A822A822902A9235AA24460882
+94D7:102010203C2021FC4020BD2410A410A8FC2013FE105010501488188811040202
+94D8:200027DE3892449244947C94A7D82094F992219222922A9A3494289002900110
+94D9:2080208038BC23C040507824A0D4230CF80023FE2090209029123112220E0400
+94DA:100011FE3C2020404088BD0411FE1022FC20102011FE10201420182013FE0000
+94DB:102011243CA420A440A8BC2013FC1004FC04100411FC10041404180413FC0004
+94DC:200023FC3A04220442F47A04A20422F4FA942294229422F42A04320422140208
+94DD:100010FC3C8420844084BC8410FC1000FC0011FE110211021502190211FE0102
+94DE:200021FC3904210441FC7820A02023FEFA222222222222222A2A322420200020
+94DF:200023FE3A02222242227A22A3FE2222FA222252224A228A2B02320223FE0202
+94E0:102011243D24212441FCBC0011FC1004FC0411FC110011001502190210FE0000
+94E1:200223E23A22222A42AA7AAAA2AA22AAFAAA22AA22AA208229423122220A0404
+94E2:20202120392021FC41207A20A02023FEF87020A820A821242924322220200020
+94E3:102011203D2021FC4120BE20102013FEFC90109010901090151219121212040E
+94E4:200020063BB8208840887908A13E2388F88822882288213E29003280247E0800
+94E5:1008103C3DE020204020BDFC10201020FC2013FE102010401488190413FE0102
+94E6:1008103C3DE020204020BDFE10201020FC2011FC110411041504190411FC0104
+94E7:109010943D1421184310BD321152110EFD20102013FE10201420182010200020
+94E8:2040204038A0211042087C06A3F82040F840204023F820402840304027FE0000
+94E9:100411883C5020204050BC8811241020FFFE102010A810A415221A2210A00040
+94EA:2040204038A0211042087C06A3F82000F80023F8220822082A08320823F80208
+94EB:105010503C50215240D4BC5810501058FCD4115212501050149218921112020E
+94EC:104010403C7820884150BC2010501088FD0610F8108810881488188810F80088
+94ED:104010403CFC21044288BC5010201040FC8011FC128410841484188410FC0084
+94EE:2080208039F8220840107BFCA0242024FBFE2024202423FC2824302020A00040
+94EF:108010803CF821084210BDFC11241124FD2411FC110011001502190210FE0000
+94F0:104010203C2021FE4000BC8811041202FC881088105010501420185010880306
+94F1:104010203C2023FE4040BC4010A010A2FDA4129814901088148418A210C00080
+94F2:204020203BFC200041087890A3FE2200FA002200220022002A00340024000800
+94F3:104010203C2023FE4040BC88110413FEFC9210901090109015121912120E0400
+94F4:2200217C3904240842107A20A07E212AF92A222A264A22522A923322224A0084
+94F5:20402020382023FE42027C44A04023FEF8882088210820D02820305020880304
+94F6:100011F83D08210841F8BD08110811F8FD441148113011201510194811860100
+94F7:210021003900211E47D27A52A2522252FA522492229221122A92325E24520800
+94F8:102010203DFC202040FCBC2011FE1048FC4810FE1088114815281A0810280010
+94F9:208820883BFE208840007BFEA2022444F84023FC204420842884310422280410
+94FA:204820443BFE204040407BFCA2442244FBFC2244224423FC2A44324422540208
+94FB:100013FE3C40204041FCBC84108413FEFC00100011FC11041504190411FC0104
+94FC:20202020382023FE40207924A0A420A8FBFE207020A820A82924322224200020
+94FD:201020143812201043FE7810A0902050F8482008208822A82A9A32AA24660002
+94FE:201022103910217E40207828A748217EF908210821FE210829083288247E0000
+94FF:208022FC3AA422A442A87A90A2A820C6F820202021FC20202820302023FE0000
+9500:102011243CA420A84020BDFC11041104FDFC1104110411FC1504190411140108
+9501:102011243CA420A84020BDFC11041124FD241124112411241450188811040202
+9502:100011FC3D24212441FCBD24112411FCFC20102011FC10201420182013FE0000
+9503:100011FC3D0421044104BDFC10001000FDFE1020102011FC1420182013FE0000
+9504:200820083BC82248425E7A4AA3CA224AFA4A23CA224A224A2A6A33D226120026
+9505:200021FC39042104410479FCA0202020FBFE22222252228A2B0A3202220A0204
+9506:20202120392021FC41207A20A02023FEF800200021FC21042904310421FC0104
+9507:201020D83B94209440907BFEA0902094F89420D82398209028AA30CA22860102
+9508:101C11E03C20202043FEBCA811241222FDF81088109010BE1502190212140408
+9509:102010203D2421244124BD2412AA1472FC20102011FC10201420182013FE0000
+950A:1004101E3DE020224112BC9410801008FDFE1008108810481448180810280010
+950B:104010403CFC20884150BC2010D81326FCF8102010F8102017FE182010200020
+950C:104010203DFC20004088BC5013FE1020FC20102011FC10201420182010200020
+950D:204020203BFC204040907908A3FC2004F9502150215021502A5032522452080E
+950E:210020BE3A82220242FA7A52A2522252FBFE2252225222922B123202220A0204
+950F:210020BE3A82220242027AFAA28A228AFAFA228A228A22FA2A023202220A0204
+9510:220821083910402043F87A08A2082208FBF820A020A0292031242224041C0800
+9511:21082088389023FC40247824A3FC2220FA2023FE206220A2292A322424200020
+9512:104010203DFC21044104BDFC11041104FDFC1120112211141508194411820100
+9513:100011FC3C0420FC4004BDFC100013FEFE0211F8108810881450182010D80306
+9514:200023F83A08420843F87A00A20023FCFA0422F422942A9434F4240408280010
+9515:2000277E3D04250445747D54A6542554FD542554257425542E04340424140408
+9516:202020203BFE202041FC7820A3FE2000F9FC210421FC210429FC310421140108
+9517:2020202239FA202440287BFEA0202040F8FC2184228420FC2884308420FC0084
+9518:208820883BFE208840A87820A3FE2040F88020FC218422842884308420FC0084
+9519:21102110391027FC41107910AFFE2000FBF82208220823F82A08320823F80208
+951A:208820883BFE208840887800A1FC2124F924212421FC21242924312421FC0104
+951B:202020203BFE205040A87924A2FA2020F8A8208823FE20882888308821080208
+951C:102010203DFC20504088BD0413FE1008FDE81128112811E81528180810280010
+951D:100011FC3D0421FC4104BDFC100011FEFC0813FE100811081488180810280010
+951E:100011FC3D24212441FCBD24112411FCFC2013FE107010A815241A2210200020
+951F:100011FC3D04210441FCBD04110411FCFC00111211D41118151019521192010E
+9520:10FC10843C8420FC4084BC8410FC1000FDFE1102110211FE1502190211FE0102
+9521:100011F83D08210841F8BD08110811F8FC8011FC1254109415241A4410940108
+9522:100011FC3D0421244124BDFC11241124FD741154115411741504190411FC0104
+9523:200023FE3A52225242527BFEA0202040F8FC2104228820502820304021800600
+9524:2008203C39E0202040207BFEA1242124FBFE2124212423FE2820302023FE0000
+9525:105010483C8020FE4190BE9010FC1090FC9010FC10901090149018FE10800080
+9526:102010403DFC210441FCBD0411FC1020FC2013FE12221222162A1A2410200020
+9527:101C11E03D10211041FEBD101110117CFD4411541154115415541A2812440482
+9528:201020503B90221E42127A24A3C82288FA882288228822942A94349424940822
+9529:102011243CA8202041FCBC4013FE1088FD0412FA1488108814A818921082007E
+952A:2080208038FC2154425478A4A1242244F8942108204020A42AAA328A24780000
+952B:104010203DFC20004108BC90100013FEFC00100011FC11041504190411FC0104
+952C:204022443A44244840A07910A6082044F84022482248245028A0311022080C06
+952D:204020203BFE220244047800A3FE2020F8202120213C21202AA03260243E0800
+952E:201020103B7C211441FE7A14A27C2710F97C251025FE22102A10350028FE0000
+952F:200023FC3A04220443FC7A20A22023FEFA20222022FC22842A84348424FC0884
+9530:200021FC3808201040207BFEA02020A0F84021FC215421542954315427FE0000
+9531:109210923D2422484124BC9210921000FDFE1122112211FE1522192211FE0102
+9532:2100213C3BD4211443947914A7D42124F94C204027FE204028A0311022080C06
+9533:208820883BFE208840A87820A1FC2124F924212427FE20202850308821040202
+9534:111011123DD421184152BD92112E1040FDFC1104110411FC1504190411FC0104
+9535:109010903C9E22A241D4BC88109410A4FDFE128414A410941494188410940088
+9536:200021FC3924212441FC7924A12421FCF8002040202422A22A8A348820780000
+9537:200023DE3A52225243DE7800A1FC2000FBFE2080210021FC2804300420280010
+9538:1008103C3DE020204020BDFE102010A0FD2C1124112411AC1524192411FC0104
+9539:200820C83B082108412A792AA3AC2148F9082388255421142914312421240142
+953A:1008103C3DE0202043FEBC2011FC1124FDFC112411FC102015FC182013FE0000
+953B:208023383A28222843A87A46A200227CFBA42224222823A82E10322822440282
+953C:10A0112C3D24212441ACBD24112411FCFC2011FC108810501420185010880306
+953D:102010403CFC208440FCBC8410FC1000FDFE1020102010FC1420182011FE0000
+953E:101E13E03C4421244088BDFC10401040FDFE108010FC114415281A1010680186
+953F:204020203BFE200041FC7904A1042104F9FC2052209421882A8834A420C20080
+9540:204020203BFE224842487BFEA2482278FA0022FC224422482A28341024680986
+9541:210420883BFE2020402079FCA0202020FBFE2000202023FE2820305020880306
+9542:102011243CA8202043FEBCA811241202FC4013FE108811081590186011980604
+9543:20842044384823FE40847884A108214AFA52239C208421082908325223DE0042
+9544:209027FC389423FC42907BFEA1122216FDFC2104212421242924305020880304
+9545:200023FC3A24422443FC7A00A2FC2284FA8422FC22842AFC3484248408FC1084
+9546:208820883BFE2088400079FCA10421FCF90421FC202023FE2850308821040202
+9547:202020203BFE402041FC7904A1FC2104F9FC210421FC290437FE208801040202
+9548:202820243BFE202041FC7924A1FC2124F9FC2124200823FE2888304820480018
+9549:200023FE380021FC41047904A1FC2000FBFE228A225223FE2A223222222A0204
+954A:200023FC390821F8410879F8A10E27F8F80827BC20A422A42928329024A80846
+954B:2020212438A8202043FE7A02A00021FCF904210421FC2050285030922112020E
+954C:20A0209039FE232045FC7920A1FC2120F9FE210023FC2088289E3102220A0404
+954D:204020803BF8220843F87A08A3F82208FBF8204027FE20E02950324824460040
+954E:102010503C8821744202BCF8108810F8FC0C11F0102011FC14201BFE10200060
+954F:204023BE3A12229242527AAAA3242040FBFE2222222223FE2A22322223FE0202
+9550:204020203BFE200041FC7904A1FC2000FBFE220222FA228A2AFA3202220A0204
+9551:204020203BFC210840907BFEA2022444F82023FC208020F82888310821280210
+9552:210420843888200043FE7800A0882104FA0221FC215421542954315427FE0000
+9553:204020203BFE2202400079FCA04020A2FB342058209423342852309023500020
+9554:204020203BFE2202441479E0A1002100F9FC2110211027FE2800309021080204
+9555:204020203BFE220240507888A1242050F888210422FA20882888308820F80088
+9556:100013FE3C5021FC4154BD5411FC1000FDFC100013FE102014A8192412A20040
+9557:2020212438A823FE420278F8A0882088F8F82020202021FC2820302023FE0000
+9558:200021F8390821F8410879F8A00023FCFA9423FC200021F82890306021980606
+9559:100011FC3D2421FC4124BDFC10401088FDF01020104413FE1422192412220060
+955A:202022223A2223FE40007BDEA2522252FBDE2252225223DE2A523252255A08A4
+955B:202027FE3C2025FC442477FEA42425FCFC2025FC252425FC2D2439FC2924112C
+955C:208020403BF8211040A077FEA00023F8FA0823F8220823F82920312222220C1E
+955D:204020203BFE208840507BFEA22222FAFA2222FA228A228A2AFA3202220A0204
+955E:22202120392047BE42407A20A3BC22D0FA90229022FE2A9034A825A808441082
+955F:22102110391047BE42407A00A3BE228AFA8822A822AE2AA834A825A8085E1080
+9560:200023DE38422252414A7A52A02820C4FB1220602188203229C4301820600380
+9561:200023FE385023FE42527BFEA00021FCF90421FC210421FC282033FE20200020
+9562:20002FFE38004A2849487BEEA8922884FAA02AA82BE828883894291409241242
+9563:202020203BFE2050428A7904A3FE2504F9FC210421FC20202924322224A20040
+9564:20A024A43AA820A047FC7910A0A027FCF84023F8204027FC28A0311022080C06
+9565:208020F8391023FC452479FCA12421FCF80023FE200021FC290431FC210401FC
+9566:210820883BC8201043DE7A64A3D42014FBD42054209420E82B88309422940122
+9567:2200217C3D04244445F47C44A5F42554FD7425D4255425F42CE435542444044C
+9568:210820903BFC209042947998A09027FEF80021F82108210829F83108210801F8
+9569:204020203BFE228A41247A22A1FC2124F9FC202023FE22222BFE322220200020
+956A:200023BE38A220A240BE7B88A208223EFA2A23AA20AA20BE2888308A257E0202
+956B:202027A438A8229241147A08A5F42802FBF82208220823F82A0831102FFE0000
+956C:208823FE38A8209041FE7B20A1FC2120F9FC212021FE21002BFC30882070038E
+956D:100011FC3C2023FE4222BDAC102011ACFC0011FC1124112415FC1924112401FC
+956E:200023FC3A94229443FC7800A7FE2000FBFC220423FC20A2291433082D440182
+956F:200023F83AA822A843F87900A3FC2484FBE422A422A423E4289437F420140008
+9570:202023FE3A88225043FE7A50A2FC2254FBFE225422FC22502AD8355426520850
+9571:2040202039FC208840507BFEA00021FCF90421FC210421FC28203294228A047A
+9572:2080204037FE44024A2473BCA4A42AA8F51022E8240423F828403248244400C0
+9573:204020203BFE225043FE7A52A3FE2200FA9422D8229022D22A8E340025540A2A
+9574:212422483924200043FC7A94A2642294FBFC2248236822482B6A324A22460362
+9575:21F022103BFC260443FC7A24A3B82222F9FE221027FC22442BFC30D0214A063E
+9576:204027FC380023B842A87BB8A11027FCF91027FC211027FE2928331025480186
+9577:00000FF808000FF008000FF00800FFFE1200111010A010401220141818061000
+9578:00000FF8080008000FF0080008000FF008000800FFFE0400082010103FF81008
+9579:00403E40204020783C8820883C8821102010FE10102820284448FE4402840102
+957A:00083E3C21E020203C2020203DFE20202020FE50105020504488FE8803040202
+957B:00203E2020A020A03CFC20A03D20202021FEFE20103020504448FE8803040202
+957C:00003EFE208220FE3C8820AA3CAA20AA20BEFE8810AA20AA44AAFEAA02BE0102
+957D:00203E2021FC20203D5420883D0422FA2088FEF8108820F84420FEA803240060
+957E:00003BFE21243A2227FE3A22237622AAFB76222223764AAAFB764A22022A0204
+957F:0800081008200840088009000800FFFE0A0009000880084009200A180C060800
+9580:00003E7C224422443E7C224422443E7C20042004200420042004200420142008
+9581:00007CF844887CF844887CF84008408840884108410842084408480840284010
+9582:00007C7C44447C7C44447C7C4004400440045FF4400440044004400440144008
+9583:00007C7C44447C7C44447C7C4004410441044104428442444424480440144008
+9584:0010771055105510771055105510771041104128412841284128414445444282
+9585:00007C7C44447C7C44447C7C40045FF441044104410441044104450442144008
+9586:00007C7C44447C7C44447C7C40045FF440044FE440045FF44004400440144008
+9587:00007C7C44447C7C44447C7C40045FF442044284424442244204420442144008
+9588:00007C7C44447C7C44447C7C40044FE4410441045FF441044104410441144008
+9589:00007C7C44447C7C44447C7C408440844FF44184428444844884428441144008
+958A:00007C7C44447C7C44447C7C4104410449244924492449244FE4400440144008
+958B:00007CF844887CF844887CF840084FC8448844885FE844884488488850A84010
+958C:7C7C44447C7C44447C7C420441045FF4400447C444444444485450344004400C
+958D:00007C7C44447C7C44447C7C420441047FFC440447E444244824514460944008
+958E:7C7C44447C7C44447C7C410441045FF44204448444844904522467F44214400C
+958F:00007C7C44447C7C44447C7C40045FF441044FE4410441045FF4400440144008
+9590:7C7C44447C7C44447C7C400441C45E0443C45E0443E45E04422441E440144008
+9591:7C7C44447C7C44447D7C410441045FF441044384454449245114410441144008
+9592:7C7C44447C7C44447C7C400447E4442447E4442447E4442448A4504440144008
+9593:00007CF844887CF844887CF840084FC848484FC848484FC84848400840284010
+9594:7C7C44447C7C44447C7C420441045FF440444444428441044284444448544008
+9595:00007C7C44447C7C44447C7C40044FE4408448844FF442844484588441944008
+9596:7C7C44447C7C44447C7C410441045D1445A44544492449145114650442144008
+9597:00007C7C44447C7C44447C7C4084448442844884448440F45F84408440944088
+9598:7C7C44447C7C44447C7C40044FE449244FE449244FE449244104410440144008
+9599:00007C7C44447C7C44447C7C420441045FF441044FE4492449A4494441144108
+959A:00007C7C44447C7C44447C7C420441044FE44444424442845FF4400440144008
+959B:7C7C44447C7C44447C7C40045FF44104492445445FF441044104410441144008
+959C:00007CF844887CF844887CF840085FE840484F4849484F484048414840A84010
+959D:7C7C44447C7C44447D7C4104428444444A24511C6FE440244044428441144088
+959E:7C7C44447C7C44447C7C440448245FF4445444445FF444444444444448544008
+959F:00007C7C44447C7C44447C7C4204414444845524561464544C4473C440144008
+95A0:00007C7C44447C7C44447C7C40045FF441044FE4410441445FF4400440144008
+95A1:7C7C44447C7C44447E7C41045FF4420444444F8441244644588443444C344008
+95A2:7C7C44447C7C44447C7C4004444442844FE441045FF44104428444444824400C
+95A3:7C7C44447C7C44447C7C420447E44824544443844C64701C47C44444445447C8
+95A4:7C7C44447C7C44447C7C4104428444445BB4400447C44444444447C444544008
+95A5:7C7C44447C7C44447C7C40044544492459F46F244944488449544A344814400C
+95A6:00007C7C44447C7C44447D7C4284444458344444444444444AA4511440144008
+95A7:7C7C44447C7C44447C7C400444445FF4444444447FFC4004444444244824400C
+95A8:7C7C44447C7C44447C7C41044FE441045FF441044FE441045FF4400440144008
+95A9:7C7C44447C7C44447C7C410441044FE4492449244FE441145FF440144004400C
+95AA:7C7C44447C7C44447C7C40045FF442844FE44AA44AA44CE448244FE44824400C
+95AB:7C7C44447C7C44447C7C40045FF4511451145FF453945554593451145FF4400C
+95AC:7C7C44447C7C44447E7C41044FE448244FE448244FE4491448A44A444C24481C
+95AD:7C7C44447C7C44447C7C40044FE448244FE440045FF450145FF4400440144008
+95AE:7C7C44447C7C44447C7C40345DC4444448445DF44444544449F4560461F4400C
+95AF:00007C7C44447C7C44447C7C5084488462A452944C8470245044518456144008
+95B0:7C7C44447C7C44447C7C400442044CE4482448244EE4482448244FE44004400C
+95B1:7C7C44447C7C44447C7C444448245FF4682C48244FE44284428444944874500C
+95B2:7C7C44447C7C44447C7C444442844FE448244FE442844284449458744004400C
+95B3:7C7C44447C7C44447D7C41045FF441044FE449244FE449244FE441045FF4410C
+95B4:7C7C44447C7C44447C7C40044FE448244FE448244FE448244FE444444824400C
+95B5:7C7C44447C7C44447C7C450444844FF459046FE449044FE449044FF44804400C
+95B6:7C7C44447C7C44447FFC48244FE448244FE440045FF450145FF450145FF44008
+95B7:08008BDE525223DE52528BDE22022222FA222222B252AA4A2A8A2202A20A4204
+95B8:7C7C44447C7C44447C7C40045FF442844EE4482448244EE4428442845FF4400C
+95B9:7C7C44447C7C44447D7C42045FF449245FF4692C4FE449244FE4411440F4400C
+95BA:7C7C44447C7C44447C7C40044FE448244FE448244FE441045FF4444443845C6C
+95BB:7C7C44447C7C44447E7C420447E4482452444CE4482448244EE4482448244FEC
+95BC:7C7C44447C7C44447C7C480444445E4448A44F144A4C4A244A8452446624400C
+95BD:7C7C44447C7C44447C7C40645F8451045FE4509458744FE448244FE448244FEC
+95BE:7C7C44447C7C44447C7C408440A45FF440844EA44AA44EA4405446B45914420C
+95BF:7C7C44447C7C44447C7C40E45F2449445FF4501447C440444684410442844C4C
+95C0:7C7C44447C7C44447C7C44445FF444447FFC482457D4644C47C4442443E4400C
+95C1:7C7C44447C7C44447C7C40044EE44AA44EE44AA44EE44824482448244864400C
+95C2:7C7C44447C7C44447C7C492445445FF442047FFC482457D4644C44C4442443EC
+95C3:7C7C44447C7C44447C7C4FE448244FE448244FE448244FE441445FF44284444C
+95C4:7C7C44447C7C44447C7C40045FF442844FE44AA44FE442045FF4444443845C6C
+95C5:7C7C44447C7C44447FFC48244FE448244FE4420443F442045FE4444443845C6C
+95C6:7C7C44447C7C44447C7C400447C4444447C440044EE44AA44AA44EE440144008
+95C7:7C7C44447C7C44447E7C41044FE4444442845FF440044FE448244FE448244FEC
+95C8:7C7C44447C7C44447C7C42044FC444445FF448244FE441044FE451045FF44108
+95C9:7C7C44447C7C44447C7C40045FF442845FF452945FF441044FE441045FF4400C
+95CA:7C7C44447C7C44447C7C4004483445C4404453FC484441F4451449F450144008
+95CB:7C7C44447C7C44447C7C40944EA4424C5454482457D4410C4FE442844444582C
+95CC:7C7C44447C7C44447C7C41045FF441045FF4555453945FF4454449245114410C
+95CD:7C7C44447C7C44447C7C41144FE441445FF442044FE4742447E4442447E4400C
+95CE:7C7C44447C7C44447D7C42044FE448244FE448244FE441145DA445444924531C
+95CF:FC7E8442FC7E8442FC7E8002BFE2A022AFA2A222AFA2AAAAAFAAA25ADFCA8046
+95D0:7C7C44447C7C44447D7C4FE441044FE448244FE448244FE448247FFC4444482C
+95D1:7C7C44447D7C46447FFC48244FE448244FE448244FE441045FF445444924410C
+95D2:7C7C44447C7C44447C7C47C4444447C4444447C440044EE44AA446644AA4466C
+95D3:7C7C44447C7C44447D7C49244FE440045FF440044FE448244FE444445FF4400C
+95D4:7C7C44447C7C44447C7C41044FE441045FF444444FE440044FE44AA45FF4400C
+95D5:7C7C44447C7C44447C7C51444A445F744494552455445F44444448A449145208
+95D6:7C7C44447C7C44447C7C40044FF449044FE449044FE449044FF440145554402C
+95D7:7C7C44447C7C44447C7C4844484452945CE4484452945EF440044AA45154400C
+95D8:00007C7C44447C7C44447C7C40245E2440F45E2452A45E6452244F2478B45048
+95D9:7C7C44447C7C44447C7C480444445E7C52945E9451545E246A544E8C4004400C
+95DA:7C7C44447C7C44447C7C480449E45D2449E449247DE4492449E454C45154623C
+95DB:7C7C44447C7C44447C7C492445445FF4501447C4444447C441044FE441045FEC
+95DC:7C7C44447C7C44447C7C484452945CE44A545EF4428452945EF4428444944888
+95DD:7C7C44447C7C44447C7C40245F24517C5F9451145F5451245F244A545194400C
+95DE:7C7C44447C7C44447C7C40045C44447C7F5452945E1452545E2453A47E544298
+95DF:7C7C44447C7C44447D7C46C4583447C4444447C440044EE44AA446644AA4466C
+95E0:7C7C44447C7C44447D7C4FE449244FE441047FFC48244FE448244FE44444482C
+95E1:7C7C44447C7C44447EFC4AA44EE440044FE449244FE449244FE441045FF44108
+95E2:7C7C44447C7C44447C7C40845E4453F45EA450445EF46A444AE44E444A544008
+95E3:7C7C44447C7C44447C7C492445445FF4501447C444444FE449244FE449244FEC
+95E4:7C7C44447C7C44447FFC4AA44FE440045FF440044FC448444FC445244CC4562C
+95E5:7C7C44447C7C44447C7C50844BE4408447F459444BE448844FF44884488457EC
+95E6:7C7C44447C7C44447C7C42844FE44AA44FE44AA45FF4444447C4444442844FEC
+95E7:7C7C44447C7C44447C7C408463E4508447F4722453E45154532455146FF4400C
+95E8:200013FC10044004400440044004400440044004400440044004400440144008
+95E9:200017FC000440044004400440045FF440044004400440044004400440144008
+95EA:200017FC00044004410441044104410442844244442448244004400440144008
+95EB:200017FC000440045FF44004400440044FE44004400440045FF4400440144008
+95EC:200017FC000440044FE44104410441045FF44104410441044104410440144008
+95ED:200017FC0004408440845FF44084418442844484488450844284410440144008
+95EE:200017FC00044004400447C44444444444444444444447C44444400440144008
+95EF:200013FC100440045F844084488448844FE4402440245FA44024414440944008
+95F0:200013FC1004400440045FF4410441044FE44104410441045FF4400440144008
+95F1:200017FC010441045FF4410441044FE4410441045FF44114411441544124400C
+95F2:200017FC00044104410441045FF4410443844544492451144104410440144008
+95F3:200017FC0204420442045FF444044484488449045144522467F4421440144008
+95F4:200013FC1004400447C444444444444447C444444444444447C4400440144008
+95F5:200017FC0004420441045FF44044444442844104428444444844400440144008
+95F6:200017FC0004420441045FF44004400447C44444444444544834500440144008
+95F7:200017FC00044204410441044404542454146454444443C44004400440144008
+95F8:200017FC000440044FE4492449244FE4492449244FE449244104410441144008
+95F9:200017FC0004420441045FF4410441044FE44924492449A44944410441144008
+95FA:200017FC000441044FE4410441045FF4400441044FE4410441045FF44004400C
+95FB:200017FC000440045FF4444447C4444447C4444444745FC44044404440544008
+95FC:200017FC00044844444445F440445C4444A4449445144A0451F4400440144008
+95FD:200017FC0004410441044FE44924492449244FE44904412441F45E144804400C
+95FE:200017FC0004400447C44444444447C440044FE4482448244FE4400440144008
+95FF:200017FC0104492449244FE440044FE4402440244FE44804481447F44004400C
+9600:200017FC000445444524490459F46F044924492448C4489449544A3448144008
+9601:200017FC0204420447E44C445284410442844C6477DC4444444447C440144008
+9602:200017FC0004420441045FF4420444444F8441244644588443444C244004400C
+9603:200017FC000440045FF4511451145FF4511453945554593451145FF44004400C
+9604:200017FC0004440447C4488451046FE449244FE449244FE44114411440F4400C
+9605:200017FC00044444428440044FE4482448244FE4428442844484489450744008
+9606:200017FC020441044FE448244FE448244FE4491448A44A444C2448144004400C
+9607:200017FC010441144FE441445FF442044FE4742447E4442447E4442440144008
+9608:200017FC008440A440945FF440844EA44AA44EA440C4465458B441144204400C
+9609:200017FC000442045FF444444924711C4FE449244FE449244FE4411440F44008
+960A:200017FC00044FE448244FE448244FE440045FF450145FF450145FF44004400C
+960B:200017FC000442044CE448244EE448244FE4428442844494449448745004400C
+960C:200017FC000440E45F044A2445445FF4501447C440444684410442844444482C
+960D:200017FC000440645F8451045FF450845C5450344FE448244FE448244FE4482C
+960E:200017FC0204420447E4482452444CE4482448244EE4482448244FE440144008
+960F:200017FC0004484444445EA448A449144E0C4A444A244A044A8452445624600C
+9610:200017FC0004444442844FE449244FE449244FE441045FF44104410440144008
+9611:200017FC010441045FF441045FF45114555453945FF44544492451244104410C
+9612:200017FC00044FE448244FE448244FE448244FE441445FF4410442844444482C
+9613:200017FC01044FE449244FE441047FFC40044FE448244924492442844444482C
+9614:200017FC0004483445C46444504451F44444484479F44914491449F44004400C
+9615:200017FC000440845E9442A44A4C4454482457D4610C4FE4410442844444582C
+9616:200013FC11044FE441045FF4420444444FE440044FE44AA44AA45FF440144008
+9617:200017FC01045FF441044FE448244FE448244FE448244FE448247FFC4444482C
+9618:200017FC00044FE448244FE448244FE440045EF4421452944A5452944A54442C
+9619:200017FC000451444A445F744494552455445F44444448A44914520440144008
+961A:200017FC00045C44447C7F5452945E1452545E2453A47E544294430440144008
+961B:200017FC00045FF452945FF440047FFC40044FE448244FE445144CA47444462C
+961C:020004003FF020103FF020003FF8200820083FF801000100FFFE010001000100
+961D:00007C0044004800480050004800480044004400440068005000400040004000
+961E:00407C40444048404BFC50444844484444444484448468845104410442284410
+961F:00407C4044404840484050404840484044A044A044A069105110420844044802
+9620:00007DF04490489048905090489049F04490449044906892508A408A40864082
+9621:00087C3C45E048204820502048204BFE44204420442068205020402040204020
+9622:00007C0047FC48904890509048904890449044904490689251124112420E4400
+9623:00407C40448048FE4900520048FC480844104420444068805102410240FE4000
+9624:00207C2044204920492C513449644BA445244534452869225122410240FE4000
+9625:0040784048405044506867705160495049504A486A4854444842404041404080
+9626:00407C40444048404944514449484A50444044A044A068905110410842044402
+9627:00107D104490489048105110489048904410441E45F068105010401040104010
+9628:00007DFE450049004978514849484948454845684550694251424142423E4400
+9629:00087C68478848884888508848884BFE44884488448868885108410842084408
+962A:00087C1C45E04900490051FC4944494445444528452869105110422842444482
+962B:00007C0045FE4810481050204820486844A44522462268205020402040204020
+962C:00807C4044404BFC4800500049F04910451045104510691251124212420E4400
+962D:00407C4044804888490453FE48024890449044904490689051124112420E4400
+962E:00007DFC44004800480053FE48904890449044904490689251124112420E4400
+962F:00207C204420492049205120493C492045204520452069205120412047FE4000
+9630:00107D10451049124912511449D84910451045104510691251524192410E4000
+9631:00887C88448848884BFE508848884888448847FE448868885088410841084208
+9632:00407C2044204BFE48805080488048FC44844484448468845104410442284410
+9633:00007C0045FC4904490451044904490445FC4504450469045104410441FC4104
+9634:00007DFC45044904490451FC49044904450445FC450469045204420444144808
+9635:00407C4044404BFE488050A0492049FC4420442044206BFE5020402040204020
+9636:00207C2044504850488851044A02488844884488448868885088410841084208
+9637:00007C0045FE48204820502049204920453C4520452069205120412047FE4000
+9638:00407C2045FC4904490451FC49004900457C45084510692051424282427E4400
+9639:00207C20442049FC4820502048204BFE4420444044406888510443FE41024000
+963A:00047C1E45F0491049105110491049FE4510451045106908510A414A41A64112
+963B:00007DF845084908490851F849084908450845F8450869085108410847FE4000
+963C:00807C80448048FE494051404A40487C444044404440687E5040404040404040
+963D:00207C2044204820483E50204820482045FC4504450469045104410441FC4104
+963E:00207C2044504850488851244A12481045FC4404440868885050402040104010
+963F:00007DFE4408480849E85128492849284528452845E869285008400840284010
+9640:00407C20442049FE49025204490049084510452045C069045104410440FC4000
+9641:00807C8044FE49004A205120492C497447A44524453469285122410240FE4000
+9642:00207820482053FE5222622452204BFC4A844A886A4852504220445044884906
+9643:00007DFE44204820482051FE492249224552454A458A690251024102410A4104
+9644:00887C8844884908497E53084D08494845284528450869085108410841284110
+9645:000079FC48005000500063FE50204820492849246A2452224422402040A04040
+9646:00207C20442049FC4820502048204BFE44204420452469245124412441FC4004
+9647:00907C88448848804BFE50A048A048A444A445284528693252224262449E4800
+9648:00407840484057FE5080612051204A204BFC4820692851244222442240A04040
+9649:00007DFC440848104830504848844B02440045FC442068205020402043FE4000
+964A:00207C20447C488449485030482048484590443E444269A45018401040604180
+964B:00007BFE4820502052FC62A452A44AA44AD44A846A8452944288420043FE4000
+964C:00007DFE44204820484051FC49044904450445FC450469045104410441FC4104
+964D:00807C8044FC49084A90506049984E26442045FC44206A2053FE402040204020
+964E:00207D20452049FC4920522048204BFE447044A844A869245124422240204020
+964F:00207C2045FE4840484050FC4884498446FC4484448468FC5084408440944088
+9650:00007BF84A08520853F8620852084BF84A444A486A3052204210428843064200
+9651:00007DFE44204820484051FE49524952455245524552695251524142410A4104
+9652:00407C4044FC49044A0851FE4900497C454445444554694851424242423E4400
+9653:002078204BFE48505088510462FA50004BFE4840488069FC5004400440284010
+9654:00407820482057FE5040608451084BF048224844698856104020405041884604
+9655:00407840484057FC50406248515048404FFE48A068A051104110420844044802
+9656:00407C40448849044BFE500248884944464244F845886A505020405041884606
+9657:00207D2444A448A8482051FC4904490445FC4504450469FC5104410441144108
+9658:00007BFC48005124524864905248492448004BFC684050404040404047FE4000
+9659:00007DFE45004900497C5100490049FE45504552455469485148424442524460
+965A:001078184BD45014501067FE5010489048904AD06A905290428A42EA47064202
+965B:02207A244A2853B05220622252A24B1E484048406BFC50404040404047FE4000
+965C:00207C2044204BFE4820502049244924452446AA442068505050408841044202
+965D:00407840484057FE5040645052484A484D5448A268A051104110420844044802
+965E:00287DC8448848884BFE5088488849084628442045FC68205020402043FE4000
+965F:002078204920513C5120612057FE480048204924692452284410402040C04700
+9660:00287C2445FE4820482051FC4924492445FC4524452469FC512441244124410C
+9661:00207C2045FC4820482050204BFE482044204520453C692052A04260443E4800
+9662:004078204BFE5202540461F8500048004BFE48906890509041124112420E4400
+9663:00207C2045FE482049FC5124492449FC4524452445FC682053FE402040204020
+9664:00007840484050A05110620855F6484048404BFC684051504248444441444080
+9665:00407C40447C488449085210493E492245224522453E692251224122413E4122
+9666:00207C2047FE482049FC50404BFE4848448844FE450869485228440840284010
+9667:00007DFC4504490449FC5104490449FC4420442045FC68205020402043FE4000
+9668:00007CF84488488848F8500049FC490445244524452469245050404840844304
+9669:0040784048A050A05110620855F64800488848486A4851504110402047FE4000
+966A:00407C2045FC48004908509048004BFE4400440045FC69045104410441FC4104
+966B:00907C9044904B9E4890509048904B9C4490449044906B9E5090409040904090
+966C:00007FE04A5E5252525263D252524A544BD44A546A4852E84754405440624040
+966D:00207C2045FC4850488851044BFE480845E84528452869E85128400840284010
+966E:00A07C90448049FE491053104DFC4910451045FC45106910511041FE41004100
+966F:00207C2044504888490452FA480049FC4554455445FC6954515441544104410C
+9670:00207C20445048884944522249F84808441045FC44006BFE5040408841FC4084
+9671:00807C8044FE49024A42524A4952484247FE444244E26952524A404240544008
+9672:0008783C49E05020502063FE512449244FFE4924692453FE4020402043FE4000
+9673:004078404FFC504053F8624853F84A484BF8484068E0515042484C4640404040
+9674:004078804BFC5224522463FC52244A444BFC4890691057FE4010401040104010
+9675:0020782049FC5020502063FE508849444A4248F8698852504020405041884606
+9676:0100790049FC5204550461E4528448844FF448846AA452A443E4400440284010
+9677:0080788048F851085210640050404B9C4A044A046B9C52044204420443FC4204
+9678:00207C2045FC4820482053FE488849044622442045FC68205020402043FE4000
+9679:00287DC8448848884BFE508848884908460045FC4504690451FC4104410441FC
+967A:00207C2044504888490452FA4820482045FC4524452469FC5050408841044202
+967B:00007BFE4850505053FE625252524A524BFE4820682053FE4020402047FE4000
+967C:00207C2245FA4824482853FE4820484044FC4584468468FC5084408440FC4084
+967D:00007CFC448448FC488450FC480049FE448044FE452A6A4A5092412240544088
+967E:00007BFE4820504051FC6154515449544954492C682053FE4050408841044202
+967F:00007DFE4510491049FC51104954495445BA4510452869245142418041FE4000
+9680:00087C3C45E048204BFE502049FC492445FC452445FC682051FC402043FE4000
+9681:00007BFE4A0052FC528462FC52844AFC4A204BFE6A4852C842304248428443FE
+9682:00207C50448849044AFE508048F8488044F8448047FE68405088410443FE4002
+9683:004078A04910520855F6600053C44A544A544BD46A54525443D44244425442C8
+9684:00007DFC4504490449FC5104490449FC440047FE44206920513C412042A0447E
+9685:01FC7924492449FC5124512461FC502048204BFE4A226A2A52FA420A42024206
+9686:008079F84A08551050E063185C064BF848404A406BFC544043F840404FFE4000
+9687:000C780A48084BFE520853F8624A524A4BEA4AAC4AAC6A4C52AA430A42164422
+9688:00007BF84A484A4853F85248624853F848004FFE4A406A445228429043084206
+9689:00407D9C4504490449DC5104490449FC4400440045FC68205020402043FE4000
+968A:01047888480053FE504060C251224A54489849386A5450944112461040504020
+968B:004078404BFE508051FC622055FE480049FC490469FC510441FC410441144108
+968C:00407C2045FE4800488450484BFE480044FC4484448468FC5084408440FC4084
+968D:00207C4045FC490449FC510449FC480047FE4420442069FC5020402043FE4000
+968E:01107D1245D4491849525192492E484045FC4504450469FC5104410441FC4104
+968F:0010781049FE5420524060FC514448444E7C4A446A7C524442544248450048FE
+9690:0080788049F84A08541053FC600451FC48044BFC480468405124452A450A48F8
+9691:00207D244524492449FC50004BFE480045FC4504450469FC5088405043FE4000
+9692:00887C50440049FE485051FC48544BFE445445FC445068D85154425240504050
+9693:00207C2045FE484048FC51104AFE4800442045FE444068FC5110421041FE4000
+9694:00007BFE480051FC5104610451FC48004BFE4A8A6A5253FE42224222422A4204
+9695:00007CFC4484488448FC500049FE490245FE450245FE690251FE404840844102
+9696:00407C8045FC4904490451FC490049FE450045FE44026AAA52AA440240144008
+9697:002078404BFC4A24522453FC622452444BFC484048A868B4513C41224222441E
+9698:020879084910480057FC5000611052084C044BF84AA86AA852A842A84FFE4000
+9699:00207CA845244A22480051FC490449FC450445FC442068A85124422240A04040
+969A:00207D2444A84BFE4A0250F84888488844F84420442069FC5020402043FE4000
+969B:010079104BDC52545554628851084AF44C0248006BFC50404150424845444080
+969C:00207DFC448848504BFE500049FC490445FC450445FC682053FE402040204020
+969D:00407C8045FC490449FC510449FC490045FE450045FE680252AA42AA4202400C
+969E:01087908490857D0511E679451244FD44A144BD46A545248424844D444244842
+969F:01247A484924500051FC612451FC492449FC48206BFE507040A8412446224020
+96A0:00087C3C45C04844492450A849FC480444FC440445FC684050A442AA428A4478
+96A1:004078204BFC50005108609053FE4A204AA04AFC6B20522042FC4420442049FE
+96A2:00207C2045FC48204BFE51084B9C49084588463E44006BFE509040904112420E
+96A3:0020792448A853FE50A8612452224904490449DE6A445554409E410442044404
+96A4:00207DFC452449FC482053FE480049FC450445FC450469FC510441FC40884104
+96A5:00107BD248545148508A610452FA4C0049FC4904690451FC4104408847FE4000
+96A6:00107BC84A7E5240526263D452004A3E4BC84A486E7E5248424843C842484008
+96A7:00887C484A5050FC5020605056944A384A504A986A3452544290422045FE4800
+96A8:002079FE4C404AFC511052FE600056FC4A844AFC4A846AFC5284428C450048FE
+96A9:004078804BFE522252AA622253FE4A724AAA4A02682053FE4050408841044602
+96AA:00207C2044504888490452FA4800480045DC4554455469DC5088408841544222
+96AB:00207DFC442048884BFE508849FC490445FC450445FC690451FC408841044202
+96AC:00007BFE49244A2257FE5222637652AA4B764A224B766AAA53764222422A4204
+96AD:000079FC48204BFE522251AC602051AC48004BFE482069FC515441544154410C
+96AE:004078204BFE4888505257AC62AA52A84DAC4800490469FC510441FC41044204
+96AF:00207BFE482049FC500053FE600251FC48204BFE48006BFE500443BE42A4438C
+96B0:00007BFE4A024BFE520253FE610852524B9C49084A526BDE500042A442524452
+96B1:003E7FC04A44492853F8504067FC50004BF848084BF8680853F84544452A48FA
+96B2:00207CA845244A2A483050C04BFE492045FC452045FC692051FE400242AA4004
+96B3:00407BFC488051F84A204DFC688850F8418846C01930E10E1190214845240200
+96B4:011078904BDE4810525E518263DE50104BDE4A504BDE6A5053DE4250425242CE
+96B5:0108F1EC910AA7E8A528C5DEA72894EA940A97EAD40CA7EC8A2A8BEA915687E2
+96B6:010001003FF801080108FFFE010801083FF821081190056009203118C5060200
+96B7:10201020FCFC102411FE7C2400FC7C200124FCA8107054A85324922210A03040
+96B8:10201020FEFC382455FE922410FC7C200124FEA8107054A85324922250A02040
+96B9:0900088008801FFC108030805FF8908010801FF81080108010801FFC10001000
+96BA:020002007FFC450408801FFC308050809FF8108010801FF8108010801FFC1000
+96BB:090008801FFC30805FF890801FF810801FFC10003FF00820044003801C70E00E
+96BC:090008801FFC30805FF890801FF810801FFC11000100FFFE0100010001000100
+96BD:090008801FFC30805FF890801FF810801FFC10003FE00420047C08043014C008
+96BE:00A00090FC8005FE05104B102DFC2910111011FC29102510451081FE01000100
+96BF:28502448248020FE3D90E29020FC2090209020FC20902090149014FE0C800480
+96C0:010011101108212440C003000C803040DFFC10801FF810801FF810801FFC1000
+96C1:00003FFE20002250224824FE24902D9036FE2490249024FE2490449044FE8480
+96C2:08500848148014FE2390529088FC089000907EFC02900490049008FE08800080
+96C3:00507E48248024FE2590269024FCFF90249024FC24902490249024FE44808480
+96C4:0850084808807EFE1190129020FC2890489048FC9090149022907EFE22800080
+96C5:00507E48048024FE2590269044FC7F900C9014FC14902490449084FE14800880
+96C6:090008801FFC30805FF890801FF810801FFC1100FFFE054009203118C1060100
+96C7:010000803FFC20043FFC2280224027FC2C4037F8244027F84440444087FC0400
+96C8:0440FC7E0440010008801FFC108030805FF8908010801FF8108010801FFC1000
+96C9:20A0209020807DFE5110931015FCFD10111011FC11102910251045FE41008100
+96CA:2050204820807EFE439082907AFC4A904A904AFC4A907A904A9002FE14800880
+96CB:090008801FFC30805FF890801FF810801FFC10003E7C2244224423C420142008
+96CC:14501448148054FE55905E9054FC5490549054FC549054905D9076FEC4800080
+96CD:02000100FFFE1050104824FE45907A9010FC2490449078FC0890109020FEC080
+96CE:00507C48448044FE45907E9044FC44907C9044FC449044904E90F0FE00800080
+96CF:205020483E8042FE85900A90FEFC029002907EFC029002900290FEFE02800080
+96D0:010001F801003FFE210221F02F0422FC224027FE2C4037FC244047FC444087FE
+96D1:20502048F88028FE29902A9046FC90901090FEFC10903490529092FE50802080
+96D2:205020483C8044FEC5902A9010FC2890449082FC7C904490449044FE7C804480
+96D3:10501048288044FE83907E9010FC1090FE9010FC54905290929010FE50802080
+96D4:1428122420403F7E64C8A5483F7E244824483F7E2448244824483F7E20402040
+96D5:00287F244940497E5DC849487F7E41485D48557E55485D484148417E45408240
+96D6:00507C48448044FE7D90129010FCFE90929092FCFE901090149012FEFE800280
+96D7:10401040107EFE8011507C4844FE7D9046907CFC1090FEFC1090109010FE1080
+96D8:00443DFE2454244834FE2D9024FE2490FEFE249024FE248025FE244444388DC6
+96D9:081024483F7E64C8BF7E24483F7E24483F7E20401FF00820044003801C70E00E
+96DA:0820FFFE08203EF822883EF8090008801FFC30805FF890801FF810801FFC1000
+96DB:202820247F40917E55C87D48217E4A48A4487F7E914855487D48217E4A408440
+96DC:10500848FE8000FE259026905AFC91901090FEFC10905490929012FE50802080
+96DD:492892244940007E7CC845487C7E0048FE48927E9248FE488148817E7F400040
+96DE:0E50F048228092FE4590229044FCF890109024FCFE901090FE9028FE44808280
+96DF:010042047FFC08803440CFFC18802FF848800FFE08003FFC24242BD4224423CC
+96E0:30182A1441207D3ED06853287D3E512851287D3E5128516851A87D3E40204020
+96E1:0028EE242240AA7E66C8AB48187E66488948307EC4481948E2480C7E3040C040
+96E2:102808247F40147E49C85548417E7F4808487F7E514855485D48417E45404240
+96E3:22282224FF40227E3EC809487F7E49487F48087E7F480848FF48147E22404140
+96E4:3AB821083AB82288393822887FFE48829FFC30805FF890801FF810801FFC1000
+96E5:08801FFC30805FF890801FF810801FFC24483F7E64C8BF7E24483F7E24483F7E
+96E6:318C294A22107BDE56B4D2947BDE529452947BDE5294529452947BDE42104210
+96E7:08801FFC3080DFF810801FFC14283F7E64C8BF7E24483F7E0100FFFE0920711C
+96E8:0000FFFE0100010001007FFC4104410449444524410449444524410441144008
+96E9:3FF801007FFE41029D7401001D7000003FF80000FFFE04000FF0001000A00040
+96EA:3FF801007FFE41029D7401001D7000003FF8000800081FF8000800083FF80008
+96EB:00003FF801007FFE41029D7401001D700000FFFE020002400220021002000200
+96EC:00003FF801007FFE41029D7401001D70000001007FFC038005601918E1060100
+96ED:3FF801007FFE41029D7401001D7000003FE008400CF81210112020C043309C0E
+96EE:00003FF801007FFE41029D7401001D70000001F03E0003F03E0003FA7E0201FE
+96EF:3FF801007FFE41029D7401001D70020001007FFC08200440038004401830E00E
+96F0:3FF801007FFE41029D7401001D70044008203018DFE604200420082010A02040
+96F1:3FF801007FFE41029D7401001D70020001007FFC040007F00410081010A06040
+96F2:3FF801007FFE41029D7401001D7000003FF800000000FFFE082010103FF80008
+96F3:3FF801007FFE41029D7401001D7000003FFC200021002FF82108420844509820
+96F4:00003FF801007FFE41029D7401001D70020001003FF8000008200440FFFE0000
+96F5:3FF801007FFE41029D7401001D70000001001FF011101110FFFE02801C70E00E
+96F6:3FF801007FFE41029D7401001D7002800C603218C1061FE00020064001800040
+96F7:00003FF801007FFE41029D7401001D7000003FF8210821083FF8210821083FF8
+96F8:00003FF801007FFE41029D7401001D70000008207FFC08200FE008200FE00820
+96F9:3FF801007FFE41029D7401001D7008001FF020105F9010901FD0102010040FFC
+96FA:3FF801007FFE41029D7401001D7000001FF0022001407FFC0484188862800100
+96FB:3FF801007FFE41029D7401001D7000003FF821083FF821083FF80102010200FE
+96FC:3FF801007FFE41029D7401001D7000007FFC040008001FF82808C8080FF80808
+96FD:3FF801007FFE41029D7401001D70000000F87F0011100920FFFE010005000200
+96FE:3FF801007FFE41029D7401001D7004000FE0144003801C70E20E0FE004201860
+96FF:3FF801007FFE41029D7401001D700000244814500C601450644808421042603E
+9700:00003FF801007FFE41029D7401001D700000FFFE02003FF82488248824A82010
+9701:3FF801007FFE41029D7401001D7000807FFC082007C01830E44E044008401040
+9702:00003FF801007FFE41029D7401001D702040104087FE50E02150E24824442842
+9703:3FF801007FFE41029D7401001D70204013FC824454A810A0E1222222241E2800
+9704:3FF801007FFE41029D7401001D70111009203FF820083FF820083FF820082018
+9705:3FF801007FFE41029D74000001007FFC00003FF800003FF800003FF820083FF8
+9706:3FF801007FFE41029D7401001D7000087C3C09E010203DFC44202BFE10006FFE
+9707:3FF801007FFE41029D7401001D7000003FFC20002FF820003FFC24484430860E
+9708:00003FF801007FFE41029D7401001D70204017FC40402BF80A48724812581040
+9709:3FF801007FFE41029D7401001D7010001FFC20005FF01210FFFE20903FFC0030
+970A:3FF801007FFE41029D7401001D7000001FF000007FFC044024481450FFFE0000
+970B:3FF801007FFE41029D7402001FF002107FFC02101FF004007FFC082007C07838
+970C:3FF801007FFE41029D7400003FF8210827C821082FE8200827C8444847C88018
+970D:3FF801007FFE41029D7401001D7008801FFC30805FF890801FF810801FFC1000
+970E:3FF801007FFE41029D7401001D7002003FF808207FFC0200FFFE082007C07838
+970F:00003FF801007FFE41029D7401001D7004407C7C04403C7804407C7C04400440
+9710:3FF801007FFE41029D7401001D70000027881088878854102790E0A422BE2102
+9711:3FF801007FFE41029D7401001D7020001040807C48400BF81208E20823F82208
+9712:00107F100810FFA888A86B4408A26B1000107E7C0004FF04100822087F100110
+9713:3FF801007FFE41029D7401001D70060038F820083CF820083FF808421042E03E
+9714:3FF801007FFE41029D7401001D702080104087FC4040104023F8E040204027FC
+9715:00107F10087EFF9088906B5408546B5400547F7C0014FF90101222127F12210E
+9716:3FF801007FFE41029D7401001D70082008207EFC08301C682AA4C92208200820
+9717:3FF801007FFE41029D7401001D70204010A00158462629F0081070A010401020
+9718:3FF801007FFE41029D7401001D70200013FC020442F42A040AF4729412F4120C
+9719:3FF801007FFE41029D7401001D700820FFFE09201FF01110FFFE02801C70E00E
+971A:00003FF801007FFE41029D7401001D7000207E20247E18A4FF2829104A2898C6
+971B:3FF801007FFE41029D7401001D7000007BDE08427BDE42107BDE0842294A1084
+971C:3FF801007FFE41029D7401001D70000008FC7E8418FC2C844AFC888408FC0884
+971D:00003FF801007FFE41029D7401001D7000007BBC4AA44AA44AA44AA47BBC4AA4
+971E:3FF801007FFE41029D7401001D7000003EF822083EF820003EF820483E3020CC
+971F:3FF801007FFE41029D7401001D701090089043FC2090089017FE709011081204
+9720:3FF801007FFE41029D7401001D7020201050FC8849444A2210F81E08F0104020
+9721:3FF801007FFE41029D7401001D7000203C1024E03C2225B43CA8252426A24C40
+9722:3FF801007FFE41029D7401001D70000C7DF045087D7045447D68455055488A66
+9723:3FF801007FFE492284140FE008203FF820083FF820083FF820083FF808201010
+9724:3FF801007FFE41029D74040079FC40444844545462883FF821083FF821083FF8
+9725:3FF801007FFE41029D7400007FFE40029FF406003B0804B019C062A00C987306
+9726:3FF801007FFE41029D7401001D7022042208F7B022047708AAB2224422182260
+9727:3FF801007FFE41029D74000000407EFC15440838FE441AA22CFC4844A8941108
+9728:3FF801007FFE41029D7400003F0821083F7E20082F4820285F88440895282C90
+9729:3FF801007FFE41029D740000087C7F4422483E5000483E4404647F5808401840
+972A:3FF801007FFE41029D7401001D70203C17C08244412817FC2040EFFE204027FC
+972B:3FF801007FFE41029D7400007EFC22441A3462C404001FF010101FF010101FF0
+972C:3FF801007FFE492284143FF821083FF821083FF804403FF80440FFFE08201010
+972D:3FF801007FFE4922841423F8120803F8720813F8110013FC14441AA413F4000C
+972E:3FF801007FFE49228414211017FC911041F0411011F02110E7FC2250228823FC
+972F:3FF801007FFE41029D74000000907EA004442BA810102FE8C8260FE004407FFC
+9730:3FF801007FFE41029D74000012203F20123E7F4400A43F2421283F1021282346
+9731:3FF801007FFE49229FF402207FFC04887A8001003FF8282837D8244827C82018
+9732:3FF801007FFE41029D7401001D7000407CF845487C3011CE5C0050F85C88E0F8
+9733:3FF801007FFE41029D74008079F84A884870538E492049FC6A2050F8402043FE
+9734:00207C2010FCFE2493FE542410FC542001247CA80070FEA821244822FCA00440
+9735:3FF801007FFE41029D7400003E2822243E240020FFFE22243E282392FE2A0246
+9736:3FF801007FFE41029D74008047FC21100FFE884257FC1100E1F8220822282410
+9737:3FF801007FFE4922841401F8790849F849084BFE79004BFC4CA449247A544888
+9738:3FF801007FFE41029D7422007F7C22443E44087C7F4449447F7C0844FF540888
+9739:3FF801007FFE41029D7401001D7000107EFE42447E2840FE7E10627CBE102210
+973A:3FF801007FFE41029D7401001D702010455097DE20246FD4A014278824D428A2
+973B:3FF801007FFE41029D7404403FF824483FF824487FFC10101FF00820FFFE0000
+973C:00807C8010FCFF0092F8540011F8544801687CC801F8FE4A20EA495AFC460442
+973D:3FF801007FFE49228514FFFE02887D7025484D6690101FF010101FF010102010
+973E:3FF801007FFE41029D743000CBFC2D2431FCC92415FC64200DFC3420C5FE1800
+973F:3FF801007FFE41029D7400807DF8068828701088FD0634F8508890F8508820F8
+9740:3FF801007FFE41029D7408207FFC08207FFE40029FF40600192006C038A00318
+9741:3FF801007FFE492284143FF821083FF821083FF80000FEFE9292FEFE9292FEFE
+9742:3FF801007FFE492284147FFE40005F3C44107F7E4E345552609044F84480BFFE
+9743:3FF801007FFE41029D7401001D70081024483F7E64C8BF7E24483F7E24483F7E
+9744:3FF801007FFE4922A41411FCFD0401FC790401FC788001FE7A224D5279FA4806
+9745:00287CFE102AFEFE92A854FE104A54FE00827CFE0082FEFE208248FEFC440482
+9746:00107E10117CFE1492FE5414137C559201547D380154FF9221304900FEFE0400
+9747:3FF801007FFE41029D74000008407F7C1440FF7C22043E7C22403E7C2242263E
+9748:3FF801007FFE41029D7401001D7000003BB82AA83BB800007FFC11102928FFFE
+9749:000E7DF010A2FE5493FE552210145552014A7E380040FE7C20844948FC3004CE
+974A:3FF801007FFE41029D74000049245D7449247FFC00003FF808200FE004407FFC
+974B:3FF801007FFE41029D74200017FE840047DC148827FEE5CC26AA293C292013FE
+974C:3FF801007FFE492285147FFC40843CF809283CB009287FF011101FF008201010
+974D:3FF801007FFE41029D74284024FC7E8448FCFE8448FE7E8048FE48027EAA4004
+974E:3FF801007FFE41029D74084014FC22845CFC88843EFE08804AFE28020EAA7004
+974F:3FF801007FFE41029D7410407EFC528428FC3E8468FEBE8028FE3E0228AA3E04
+9750:3FF801007FFE49229FF411101FF000007C7C1010FEFE929254547C7C54547C7C
+9751:010001007FFC01003FF80100FFFE00001FF0111011101FF01010101010501020
+9752:010001007FFC01003FF80100FFFE00001FF010101FF010101FF0101010501020
+9753:100010FCFE8410847CA410A4FEA400A47CA444A47C5044507C5044925492490E
+9754:10401040FE7E10807D00107CFE0000007CF844087C0844087C0A440A54064802
+9755:00200020FDFE102010FC102051FE5C0050FC508450FC50845CFCF08400940088
+9756:2020102013FEFC2001FC08208BFE880049FC490451FC51041DFCE10441140108
+9757:10201020FD2410A47CA81020FDFE00507C5044507C5044507C924492550E4A00
+9758:10401040FCFC10887D1010FCFEA400A47CA444FC7C8044807C824482447E4C00
+9759:10401040FE7810887C1011FCFE2400247DFE44247C2445FC7C24442054A04840
+975A:100011FCFF0411047DFC1104FF0401FC7D0445047DFC44507C90449255124A0E
+975B:10201010FEFE10827D041000FEFE00107C1044907C9E44907C9044D0553E4A00
+975C:101E11E0FE92104C7C0010FCFE2400247DFE44247C2444FC7C24442054A04840
+975D:10801080FCFC11007EF81000FDF800487D6844C87DF8444A7CEA475A54464842
+975E:044004400440FC7E0440044004407C7C0440044004400440FC7E044004400440
+975F:044004407C7C04403C7804407C7C044000F03F0001F03F0001F87F02010200FE
+9760:11001FF02100FFFE00001FF010101FF004407C7C04403C7804407C7C04400440
+9761:00803FFE24103F7C26382D543412212021203F3E21202F3C21205F3E41208120
+9762:0000FFFE0200020004003FF82448244827C82448244827C8244824483FF82008
+9763:0000FFFE0200020004003FF82008200827C82448244827C8200820083FF82008
+9764:0040FE4010FC2084FF04AAF4AA94BA94AAF4AA84BA94AA88AA82FE82827E0000
+9765:3FFC20903FFC21402630380C27F020802FF82A282BE82A284BE84A288FF80808
+9766:0000FEFC10842084FEFCAA84AA84BAFCAA84AA84BAFCAA50AA50FE528292010E
+9767:0010FEFE109220FEFE10ABFEAA00BAFEAA82AAFEBA82AAFEAA82FEFE82440082
+9768:3FFE28882F8A20082FBE28882F88289429A23FFE20802FFC292449E449248FFC
+9769:082008207FFC082008200FE001003FF8210821083FF80100FFFE010001000100
+976A:22002200FF7E22083E0808087F08490849087F080808FF880808080808280810
+976B:280029F8FE8828C838A810A87C88545054507C501020FE201050108811041202
+976C:2200227CFF1022103E1008107F1049FE49107F100810FF900810081008100810
+976D:22002200FF7E22123E1208527F52495249527F920812FFA20822084208940908
+976E:22202220FF20227E3E4208827F02498249427F220822FF820802080208140808
+976F:22102210FF1022103E10087C7F10491049107F100810FF90081008FE08000800
+9770:28002800FDFC2890389010907C90549054907C901090FC9210921092110E1200
+9771:28002800FDFC2844384411447CC4544454647C54104CFC861084110412281410
+9772:28202820FE202850385010887D44562254207CF81008FE081010101010201020
+9773:2204220EFF7022403E4008407F7E494849487F480848FFC80848088808880908
+9774:28502850FE502892389211947E98549054B07CD01090FE9010921092108E1080
+9775:280029F8FE482848384810487C4855F854887C881088FE881088108813FE1000
+9776:280029FCFD242924392411247D2455FC55047D001100FD001102110210FE1000
+9777:280429E4FE242824382411E47D04550455047DE41024FE241024102411441084
+9778:28002BFCFC842888388810907C9C548455447D441128FD281210122814441182
+9779:28202820FE2029FE392211227D22552255527D4A118AFF0211021102110A1104
+977A:28202820FC202BFE382010207C2055FC54707CA810A8FD241124122210201020
+977B:280028F8FE882888388810F87C88548854887CF81088FE881088108813FE1000
+977C:28002800FEFC2884388410847CFC548454847C8410FCFE841000100011FE1000
+977D:28202820FD2428A438A810207DFC542054207C2013FEFC201020102010201020
+977E:282828A8FEA828A838A813FE7CA854A854A87CA810B8FE801080108010FE1000
+977F:50105090F8905110717E2252FB92A892A912F9122252FBD220622022204A2084
+9780:280029FCFE442844384410447C94548855007CFC1084FE841084108410FC1084
+9781:28102810FE1029FE391211147D1055FC55447D441128FF281110122812441482
+9782:2808283CFDE02820382010207DFE542054707C6810A8FCA41122102010201020
+9783:280829C8FE482848384811C87D08550855107DD01054FE541052105E12821100
+9784:28402840FEFC2884390412F47C94549454F47C841094FE8810821082107E1000
+9785:28202820FE2029FC392411247D24552455247FFE1020FE501050108811041202
+9786:280029FEFC202820382011FE7D22552255527D4A118AFD0211021102110A1104
+9787:280029FCFD042924392411247DFC552455247D54114CFD8C1104110411FC1104
+9788:28202820FE502848388411027CFC540054007CFC1084FE841084108410FC1084
+9789:28502850FE50295238D410587C50545854D47D521050FE50109210921112120E
+978A:28202820FC202BFE382010207DFC540054007DFC1104FD041104110411FC1104
+978B:28202820FEFC2820382010207DFE540054207C2010FCFE201020102011FE1000
+978C:01007FFC44043FF8082007C0783804407FFC044007C001001FF01110FFFE0100
+978D:28402820FC202BFE3A0214447C4057FE54887C881108FCD01020105010881304
+978E:280028FCFE84288438FC10847C8454FC54A27CA41098FE90108810A410C21080
+978F:7CF8108810CA1D2AF20608207FFC08200FE001003FF821083FF80100FFFE0100
+9790:28202820FE3E2820382011FE7C00540055FE7C201028FE241022102010201020
+9791:28102910FC902890387E10107D90549054987CA810A4FCC410801140123E1000
+9792:2808281CFEE02820382011FE7C50548855047E8A1088FE881088108810881108
+9793:280028FCFE842884388410FC7C00540055FE7C201020FEFC1020102011FE1000
+9794:28802880FCF829083A1011FC7D24552455247DFC1050FC50109010921112120E
+9795:280029FEFC20282039FC11247D2455FC55247D2411FCFD2010A0104010B0130E
+9796:2804281EFDE02822391210947C80542055FE7C441084FDC81030102810C41302
+9797:108011F8128820702B8E68886BFEA88828F8282029FC292429FC202023FE2020
+9798:28102892FE522854381010FE7C82548254FE7C821082FEFE10821082108A1084
+9799:280028F8FE88288838F810007DFC550455047DFC1104FF0411FC110411141108
+979A:28202810FE1029FE390212547C88550454007CFC1020FE201020102011FE1000
+979B:28202810FEFC2800388810507C0055FE54007C0010FCFE841084108410FC1084
+979C:28202822FDB428A838A811247EA2544055FC7D041104FDFC1104110411FC1104
+979D:28202924FCA428A8382011FC7D04550455747D541154FD541174110411141108
+979E:28202840FCFE2892389210FE7C9254A254FE7C481088FDFE1008100810081008
+979F:28202810FDFE280038FC10847CFC540054FC7C081010FDFE1010101010501020
+97A0:28802880FEFE29023A2210AA7C72542255FE7C221072FEAA11221022100A1004
+97A1:28902888FC8828BE3BC010827CA254E254927D921294FC941084108812BE1100
+97A2:28482948FD482BFE394811487D78550055FE7C2013FEFC7010A8112416221020
+97A3:280029FCFC4828303BFE10527C94551056307C2013FEFC7010A8112416221020
+97A4:08087F0808FEFF0808487F2808080F28F01004407FFC04401FF01110FFFE0100
+97A5:28202830FE482884397A10007CFC548454847CFC1048FE4811FE104810881108
+97A6:500850C8FB085108712A212AFBACA948A908FB882554F9142114212421242142
+97A7:28882848FC502BFE385010507DFC555455547D8C1104FDFC1104110411FC1104
+97A8:280029FCFD0429FC390411FC7C8055FE56227D221152FD0211FA100210141008
+97A9:50825082FAA251CA708A23EAFA2AAA2AABEAFA2A222AFBEA2222222222AA2244
+97AA:7E20243E1848FFA829104A28984604407FFC044007C001001FF01110FFFE0100
+97AB:28802880FCFE29023A4211FA7C0255F254027DF21002FDF2111211F210141008
+97AC:50105010F87C571471FE2114FA7CAA10AF7CF91021FEFD102210230024FE2800
+97AD:288028FEFE90297C395413547D7C555455547D7C1190FF501120113011481186
+97AE:280028FCFE84288438FC10847C8454FC54007DFE1020FEA010BC10A01160123E
+97AF:28482848FDFE2848382011FE7C40544054BC7D841288FCBE1088108810A81090
+97B0:280028F8FE88288838F810887C8854F854007DFC1154FF541154115413FE1000
+97B1:281E28E0FE222892385410407C2054CE54827C8210EEFE821082108210FE1082
+97B2:50885088FBFE508871FC2088FBFEA820A9FCF92421FCF92423FE210421142108
+97B3:28882888FDFE2888382010507C88550456FA7C001000FDFC1104110411FC1104
+97B4:50885088FBFE5088708827FEF880A9FCAB24FDFC2124F9FC212421242124210C
+97B5:281E2BE0FD222894384010887DF0542054C47DFE1022FC2013FE105010881306
+97B6:08783E48228E2A007EF822482A3046CC7FFC044007C001001FF01110FFFE0100
+97B7:7FFC08200FE000003FF824482FE82108211804407FFC04401FF01110FFFE0100
+97B8:280029FCFD2429FC392411FC7CA854A857FE7CA810A8FDFC102013FE10201020
+97B9:5100509EFBD2501273D42254FBD8A814ABD2F8522092F8DA2394209022902110
+97BA:28202924FCA82BFE3A0210F87C88548854F87C201020FDFC1020102013FE1000
+97BB:282029FCFD242BFE392411FC7C2055FC55247DFC1040FDFE108811D01070138C
+97BC:282029FCFD2429FC382013FE7C0055FC55047DFC1104FDFC110411FC10881104
+97BD:281829E0FC402BFE388811747E52547054007DFC1104FD74115411741104110C
+97BE:28882BFEFC88280039FC10A87CA857FE54A87CA811FCFC2013FE102010201020
+97BF:51245124FAAA53AE712422AAFBAEA924AFFEF9102114F914228A224A22162422
+97C0:50405020FBFE525073FE2252FBFEAA80AAFEFA8022FEFA02255625562A022006
+97C1:28002BFEFC0029FC392411FC7D2457FE54007DFC1124FDFC112411FC100013FE
+97C2:288028F8FD082BFE394411927DFE5500557C7D00117CFD00117C1244127C1444
+97C3:28102A10FD7C281038FE10447F2855FE55107D7C1110FDFE1110111012FE1400
+97C4:28882BFEFCA8289039FE13207DFC552055FC7D2011FEFD0013FC10881070138E
+97C5:280029FCFD0429FC390411FC7C88555455DC7C881154FDDC100011A811541254
+97C6:500050FEFC2852FE72AA20FEF810A9FEAE44FAFE2344FA7C2242223E250028FE
+97C7:28202BFEFC2029FC380013FE7E5257FE55047DFC1104FDFC110411FC10881104
+97C8:284829FEFC48280039FE114A7D4A55FE54147DFE1110FD92114C114A11161222
+97C9:508853FEF888502073FE2250FBFEAA52ABFEFA8022FEFA8022FE24022AAA2004
+97CA:508853FEF88853DE725223DEFA52ABDEAA22FBFE22AAFAFA2222227222AA2224
+97CB:020002003FF00410FFFE00001FF010101FF001003FF8010021003FFC01000100
+97CC:100010007EFE2212FF1200527E5242527E9208127E12082248227E42088A0904
+97CD:102810247E242220FF7E00207E20423C7E3408547E54085448887E8809140822
+97CE:101010107E1022FEFF1000107E10427C7E1008387E38085448547E9208100810
+97CF:111009207FFC0400FFFE12102FE8C4263FF810101FF001001FF021003FF80100
+97D0:102010207C502450FE8801047EFA44007C0010F87C88108850887C8810F81088
+97D1:102011FC944455FE580011FCFD0429FC282029FC2820292029FC4820482287FE
+97D2:101010927E522254FF1000FE7E8242827EFE08827E8208FE48827E82088A0884
+97D3:1020102010FCFE4411FE7C0044FC7C8444FC7C1010FCFE10109010FE10101010
+97D4:1000107C7E402278FF4000787E4043FE7EA008A47E98089048887EA408C20880
+97D5:102010107EFE2200FF7C00447E7C42007E7C08087E1008FE48107E1008500820
+97D6:100010FC7C482430FEFE00527C9445507C2010107DFE103850547C9211101010
+97D7:100011FE7D022420FEFC00207DFC45247DFC11247DFC102053FE7C2010201020
+97D8:101410547E5422FEFF5400547E5C42407E7E08107EFE081048387E5408920810
+97D9:00103E7C22243EFE22003E7C0044FF7C0810083C2F50287E281058104FFE8000
+97DA:108810887DFE2488FEF800207DFC45247D2411FC7C2013FE50207C2010201020
+97DB:104410447DFE2444FE4401FE7C4044FE7D9212FE7C9210FE50927C9210921086
+97DC:101E11E07C222512FE9400807C2045CE7D0211027DCE110251027D0211FE1102
+97DD:104810487DFE2448FEFC00487DFE44107CFC10947CFC109451FE7C8410941088
+97DE:100010F87C882488FEF800887C8844F87C0011FC7D54115451547D5413FE1000
+97DF:101010207E7C2244FF7C00447E7C42107EFE08287E540892487C7E1008100810
+97E0:100010FE7E9222FEFF9200FE7E5442547EFE08547E5408FE48107EFE08100810
+97E1:104410FE7E442200FFFE00547E5442FE7E5408547EFE081048FE7E1008100810
+97E2:101010107DFE2410FEFC00947CFC44947CFC10127DFE102250147D52114A1238
+97E3:100011FC7D542554FFFC00807DFC46447DF411547D5411F450447DF410141008
+97E4:104811FE7C482400FFFE014A7D4A45FE7C1411FE7D101192514C7D4A11161222
+97E5:101010FE7E10227CFF0000FE7EAA42FE7E44087C7E44087C48447E7C08280844
+97E6:0100010001007FFE010001003FF8010001007FFC010401040104012801100100
+97E7:2000200021FCFC24202420A4F8A420A42124FC24242424443444288421142208
+97E8:205020482048FC4021FE2040F840207C20A4FCA424A8252835102A2820442082
+97E9:102010201020FEFE10207C2044FC7C2044207DFE1022FE22102A102410201020
+97EA:00203E2022FC3E2022203EF80020FF2008FC08242F242834282858204FFE8000
+97EB:200020F82088FC8820F82088F88820F82000FDFC255425543554295423FE2000
+97EC:201E21E02022FD1220942080F82021CE2102FD0225CE25023502290221FE2102
+97ED:044004407C7C0440044004407C7C0440044004407C7C044004400440FFFE0000
+97EE:08200820FFFE0820082004407C7C044004407C7C044004407C7C04400440FFFE
+97EF:082008287F240820FFFE0020122473A4122473A812287390121217AAF8464082
+97F0:08000F7C28447F28A110162838C6C2807EFC02803EF802807EFC0280FFFE0000
+97F1:112011282AA444640020FFFE122073A4122473A812287390121217AAF8464082
+97F2:0100FFFE02847D78255025484D6402807EFC02803EF802807EFC0280FFFE0000
+97F3:020001003FF8000008200440FFFE00001FF0101010101FF0101010101FF01010
+97F4:200013FE7C200020442029FCFF2401247D24452445247D34452844207C204420
+97F5:204010407C8000FC45042A04FE8400447C44441444247C44458444047C284410
+97F6:200011FC7C44004444442844FE9400887D0044FC44847C84448444847CFC4484
+97F7:201010107C92009244922892FEFE00107C10449244927C92449244927CFE4402
+97F8:204010407CFC008845502820FED803267CF8442044F87C2047FE44207C204420
+97F9:202010407CFC008444FC2884FEFC00007DFE442044207CFC442044207DFE4400
+97FA:208810887DFC008844A82820FEF800A87CA844A844A87DFC442044507C884504
+97FB:2000107C7C440044447C2800FEFE00827CFE448244FE7C8244FE44287C444482
+97FC:20201220797C00A4481830E6FB10017E7910497C491079FE491049107AFE4C00
+97FD:1020281044FE92007C440828FEFE2800FE7CAA44CE44827CFE448244FE7C8244
+97FE:08007F7808483E4800863E782A483E30414EBFFC0440FFFE10101FF010101FF0
+97FF:110023DE7A5213D42A527BDA1294235001003FF80440FFFE10101FF010101FF0
+9800:204411FE7C54004844FE2990FEFE00907CFE449044FE7C8045FE44447C3845C6
+9801:00007FFE020004001FF8100810081FF810081FF8100810081FF8081010082004
+9802:000001FEFE20104011FC1104110411FC110411FC1104110411FC108851042202
+9803:000021FE2020204021FC3D04210421FC210425FC2904310421FC008801040202
+9804:200020FE20102020FCFC2484248424FC248424FC2584268444FC404880840102
+9805:000001FE0020FC4011FC1104110411FC110411FC11041D04E1FC408801040202
+9806:040045FE5420544055FC5504550455FC550455FC5504550455FC548885040602
+9807:00007CFE1010102010FC10841084FEFC108410FC1084108410FC104810841102
+9808:080009FE1020204041FC8904090411FC210445FC8504090411FC208841048202
+9809:080009FE0810082048FC4E84488448FC488448FC48844E8458FCE04800840102
+980A:000001FE7C20104011FC11047D0411FC110411FC11041D04E1FC408801040202
+980B:00007EFE401040205EFC5284528452FC5A8454FC5084528454FC584850848102
+980C:000028FE2410242042FC5284908410FC208420FC48844484FCFC444800840102
+980D:100011FE1020FE4011FC1104FD0405FC050449FC2904110429FC448881040202
+980E:08001DFE6020404041FC41047F0449FC490449FC4904490449FC488889040A02
+980F:100008FE0810FF2000FC00843C8424FC248424FC2484258446FC444880840102
+9810:00007CFE0410282010FC0884FE8412FC148410FC1084108410FC104850842102
+9811:00007CFE0010002000FCFE84288428FC288428FC28842A844CFC484880840102
+9812:000028FE2410242042FC428480847CFC248424FC2484248444FC444894840902
+9813:100011FE1020FE4011FC5504550455FC55047DFC1104110415FC188811040202
+9814:100011FE10207C4055FC5504550455FC7D0455FC5504550455FC7C8845040202
+9815:100010FE10101E2010FC1084108410FC7E8442FC4284428442FC7E4842840102
+9816:100011FE9420584011FC7D04110411FCFF0411FC1104110421FC208841048202
+9817:080008FE08107F20497C4A4448447F7C4144527C4A4444444A7C910021280044
+9818:100011FE2820244043FC9104090401FCFD0405FC0904510421FC108811040202
+9819:000001FEFC20104011FC110451045DFC510451FC510451045DFCF08801040202
+981A:00007CFE0410682010FC2884448492FC10847CFC108410841EFCF04840840102
+981B:100010FE1010FE2010FC7C841084FEFC308438FC5484548490FC104810841102
+981C:100011FE2820244043FC81047D0401FC01047DFC4504450445FC7C8845040202
+981D:200010FE0010FE2000FC2884448482FC048444FC2884108428FC444884840102
+981E:100008FE7E10422094FC10841084FEFC248424FC4884288410FC284844848102
+981F:200020FE3C104420C4FC2884108428FC448482FC7C84448444FC44487C844502
+9820:1000107E3F102120427CBFC420442F7C2944297C2D442A44287C4A004C288844
+9821:100010FE1010FE2010FC10847C8400FC00847CFC4484448444FC7C4844840102
+9822:08001DFE7020104011FCFD04110411FC7D0445FC4504450445FC7C8845040202
+9823:00007EFE4810482048FC7E84428442FC7E8448FC4884488448FC7E4800840102
+9824:00007DFE4820484049FC5D04550455FC55045DFC4904490449FC7E8801040202
+9825:40005F7E54105420547C5F445144517C51445F7C54445444547C54005F284044
+9826:100008FE0810FF2008FC108422847CFC098412FC2484C88414FC2248C0840102
+9827:080011FE7C20444045FC45047D0441FC41047DFC4504450445FC7C8845040202
+9828:0000EEFE22102220AAFC6684228422FC26846AFCB284228422FC2248AA844502
+9829:420024FE00107E2024FC2484248424FCFF8424FC2484248424FC444844848502
+982A:080008FE4A102A202CFC0884FE8418FC1C842AFC2A84488488FC084808840902
+982B:280028FE28102820AAFC6C84288428FC6C84AAFC288428842AFC4C4848848102
+982C:080008FE08107E2008FC4A842A842CFC0884FEFC0884148412FC224840848102
+982D:0000FEFE002000407CFC4484448444FC7C8400FC448428842EFCF00040480084
+982E:0800097EEA102C204A7C4944A844107C2444247CFF442444247C440044288444
+982F:100010FE3E10622094FC48843084C0FC248424FCFF84248424FC444844848502
+9830:080008FE0810FFA0087C2A442A442A7C5D4488FC08441444127C210041288044
+9831:04001EFEE010222092FC5484408404FCFF8404FC4484248424FC044814840902
+9832:000001BE76081210123E222227A2723E1222523E522227A2203E50008F940022
+9833:100010FE10107C2010FC1084FE8428FC28846CFCAA84288428FC484848849902
+9834:40004CFE7010422042FC3E8400847CFC0084FEFC1084548452FC924850842102
+9835:00007EFE12101220FF7C124412447E7C2044207C7E446244A27C22003E282244
+9836:080028FE28103E2048FC0884FF8400FC00843EFC2284228422FC3E4822840102
+9837:080008FE1410222051FC88847E8402FC048408FC7E84428442FC7E4842840102
+9838:0000FEFE54105420A8FC5484548400FCFE8410FC108410841EFCF04840840102
+9839:0C0070FE1010FE2010FC3884548492FC008428FC288428842AFC4C4848848102
+983A:0C0070FE1010FE2010FC3884548492FC7C8424FC28842E8422FC42484A848502
+983B:080008FE28102E2028FC2884FF8400FC08842AFC2A844C8484FC08483084C102
+983C:100010FEFE10102010FCFE84928492FCFE8410FC3884548492FC104810841102
+983D:0C0070FE1010FE2010FC3884548492FC008438FC288428842AFC4C4848848102
+983E:0BFE104061FC090411FC610405FC090431FCC088090428802E9828E22E82F07E
+983F:060018FE62100C20737C0C44F444147C55445E7C54445544557C5D00F3280044
+9840:140012FE20103F20647CA4443F44247C24443F7C24442444247C3F0020282044
+9841:1000087E7F104120827C00447F44087C0844287C2E442844287C58004F288044
+9842:100010FE1010FE2010FC5484548454FCBA8410FC3884548492FC104810841102
+9843:100052FE5410902028FC4484828410FC108452FC5484908428FC244842848102
+9844:00007F7E02100420497C6B445D44497C5D446B7C49446944517C470079280044
+9845:100008FE7E10422042FC7E8440845EFC52845EFC52845E8452FC524892841702
+9846:00007F7E491049207F7C494449447F7C0844FF7C1C442A44497C880008280844
+9847:100008FE00107F20007C22442244557C88C4087CFF440844087C080008280844
+9848:40004CFE7010422042FC3E84208444FC788410FC2484FE8410FC544892843102
+9849:100010FE2810242042FCBC84108410FCFE8410FC9484588450FC1E48F0844102
+984A:100020FE7E1042207EFC40847E8442FC7E8410FC1084FE8410FC104810841102
+984B:00007F7E491049207F7C494449447F7C0844047C154450C450FC52808E280044
+984C:00003EFE22103E20227C3E44007CFF44087C08442F7C2828284458824FFE8000
+984D:200010FEFE10822020FC3C844484A8FC108428FC4484FE8444FC44487C844502
+984E:0000EEFEAA10AA20EEFC00847C8400FCFE8420FC40847C8404FC044828841102
+984F:100008FE7F1022201CFC22847F8444FC488472FC4484488471FC42488C847102
+9850:0000FEFE92101020FEFC10847C8454FC7C8454FC7C841084FEFC104810841102
+9851:020002BE02087F90423E42225E2242BE42A25EBE56A255225D7E414042D48462
+9852:00007CFE541054207CFC548454847CFC1084FEFC92849684BEFC82488A848502
+9853:100092FE92109220FEFC0084FE8410FC2084FEFCAA84AA84AAFCAA48AA848702
+9854:100008FE7F102220147C7F444444487C5244447C48445144427C440088283044
+9855:00007CFE441044207CFC448444847CFC288428FCAA846C8428FC2E48F0844102
+9856:0800107E7F104120557C49445544417C7F44087C054454C450FC92000E280044
+9857:0800497E49107F20007CFF4400447F7C4144417C7F444244247C0F00F0284044
+9858:00007F7E441048205F7C51445F44517C5F44447C56445544657C450094280844
+9859:00007EFE22101C20227C77445544227C5544087C7F441C442A7C490088280844
+985A:4600787E40903FA0007C5F4451445F7C51445F7C51445F44407C7F8022284144
+985B:100010FEFE1010207CFC44847C8444FC7C8444FC7C844484FEFC284844848302
+985C:2200223EFF8822107F3E2222FFA2083E7F22493E7F224922FFBE410045144222
+985D:00007CFE4410742054FCFE8482847CFC44847CFC44847C8444FC444854844902
+985E:100092FE5410FE2030FC5484928400FC148412FCFE84108428FC244844848102
+985F:0000777E11105520337C55440C44337CC4C4187C62440CC4717C06001828E044
+9860:0000FEFE2810FE20AAFCAA84FE8400FC7C8400FCFE84108454FC924850842102
+9861:100008FE7F102220147CFF441044297CCE44147C2644CD44157C2400D4280844
+9862:2200223EFF882210223E3E220822FFBE88A2CCBEAAA2DDA288BE88808A948922
+9863:0200029E02047FC8421E4A124E124A9E7E924A9E4A925D126B5E49405ACC8452
+9864:100010FE7C101020FEFC4484EE8444FC6484DEFC0084FE8428FC2A484C848902
+9865:00007CFE44107C2044FC7C841084FEFC00847CFC44847C8410FC544892843102
+9866:280024FE7E10C82048FC7E84488448FC7E8448FC48847E8440FCAA48AA840102
+9867:100008FE7F104120417C7F445444527C7F44547C5F4454445F7C54009F281044
+9868:FEFE10207EFC42847EFC42847EFC42847EFC244842840000FFFE082010202020
+9869:080008FE14102220417CBE440044007C7744557C55447744227C220055288844
+986A:040027BE2408FFD0023E02A27FE2423E7E224ABE4AA25AA26D3E894012D46462
+986B:1000FEFE0010FE2082FCBA84AA84FEFC00847CFC44847C8444FC7C480084FF02
+986C:00007F3E0808FF9088BE6B2208226B3E0022FFBE08227F22553E550055144322
+986D:2200FFBE22087F10553E55227F22003EFFA290BE3E222222523E0C001814E022
+986E:1000087EFF9080A07F7C524494447F7CC1447F7C41447F44417C7F0022284144
+986F:0000FEFE8210FE2082FCFE844484AAFCEE8444FCAA84EE8400FCAA48AA840102
+9870:087E2E10287EFF422A7E4C42327EC4243FFA21083FF822083FF80880FFFE0080
+9871:08000FBE08087F9048BE7E2248A25FBE55225F3E55225F22403EBF802A947FE2
+9872:29004A7E14106220097C2A445444227C4844FF7C00447F44417C5D0055287F44
+9873:7F80213E3F0821103F3E21E2FF22013EFFE252BE73A252A273BE5AC0F79410A2
+9874:2200227EFF902220777C55447744127C3F44647CBF4424443F7C24003F282044
+9875:00007FFC020004001FF010101110111011101110111012900240042018106008
+9876:000001FEFE20104011FC11041124112411241124112411441050508821040202
+9877:000021FE2020204021FC3D042124212421242524292431442050008801040202
+9878:000079FE1020104011FC11041124FD2411241124112411441050108811041202
+9879:000001FE0020FC4011FC1104112411241124112411241D44E050408801040202
+987A:040045FE5420544055FC55045524552455245524552455445450548885040602
+987B:080009FE1020204041FC89040924112421244524852409441050208841048202
+987C:000001FE7C20104011FC11047D2411241124112411241D44E050408801040202
+987D:00007CFE0020004000FCFE84289428942894289428942AA44C30484880840302
+987E:00007EFE402040405EFC5284529452945A945494509452A45430584850848302
+987F:100011FE1020FE4011FC55045524552455247D24112411441450188811040202
+9880:08001CFE6020404040FC40847E94489448944894489448A44830484888840B02
+9881:000029FE2820244045FC450481247D2425242524252425442450448855048A02
+9882:000028FE2420244042FC52849094109420942094489444A4FC30444800840302
+9883:100008FE0820FF4000FC00843C94249424942494249425A44630444880840302
+9884:0000F9FE0820504021FC1104FD242524292421242124214420502088A1044202
+9885:100010FE1E20104010FC7C844494449444947C94449440A44030404880840302
+9886:100011FE2820244043FC910409240124FD240524092451442050108811040202
+9887:080008FE08107F20497C4A4448547F54415452544A5444544A28912421420082
+9888:00007EFE04100820187C24444254815400547E540854085408280E24F0424082
+9889:100010FE1020FE4010FC10847C94009400947C94449444A444307C4844840302
+988A:080008FE08207E4008FC4A842A942C940894FE94089414A41230224840848302
+988B:0000037EEC102420247C44444F54E4542454A454A4544F544020A0281F440082
+988C:100010FE2820244042FC80847C94009400947C94449444A444307C4844840302
+988D:200024FE3820224022FC1E84009408940A94EC9428942CA44A304A48A8841302
+988E:400044FE7820424042FC3E840094109452945294549490A42830244844848302
+988F:100008FE0820FF4008FC108422947C94099412942494C8A414302248C0840302
+9890:00007DFE4820484049FC5D045524552455245D244924494448507E8801040202
+9891:100011FE50205C4051FC5104FF2401241124552455245544845008883104C202
+9892:080009FEEA102C204A7C4944A854105424542454FF5424542428442444428482
+9893:0C0071FE1020FE4011FC39045524932401243924292429442A504C8849048202
+9894:080008FE14102220517C88447E540254045408547E54425442287E2442420082
+9895:40004CFE7020424042FC3E8400947C940094FE94109454A45230924850842302
+9896:40004DFE7020444045FC3D0401240D2471241124FF2411443850548891041202
+9897:00007F7E491049207F7C494449547F540854FF541C542A544920882808440882
+9898:00003EFE22103E20227C3E440054FF54085408542F282844288258004FFE8000
+9899:00003EFE2A102A203E7C2A442A543E5408547F5449544B545F28412445424282
+989A:0000EEFEAA10AA20EE7C0044FE540054FF5440547E5402540228022414420882
+989B:0800497E491049207F7C0044FFD4085410547F54555455545520552855444382
+989C:100008FE7F102220147C7F444454485452544454485451544228442488423082
+989D:100008FE7F104120107C1E44225454540854145422547F54A22822243E422282
+989E:00007F7E22103E20227C3E4423D4FE540254F754115455542220552889441082
+989F:240024FEFF102420007CFF4424542454FF54A554A554DB549128812485428282
+98A0:080008FE7F1008203E7C22443E5422543E5422543E5422547F28142422424182
+98A1:00007EFE22101C20227C774455542254555408547F541C542A28492488420882
+98A2:00007F7E41107F20417C7F440854FFD400547F5441547F540820492888C41882
+98A3:920054FEFE103020547C924420544454785410542454FE541028542492423082
+98A4:0800FF7E0010FF20817CBD44A554FF5400547E5442547E5442207E280044FE82
+98A5:00007F7E0810FFA088FC6B4408546B540054FFD408547F545520552855444382
+98A6:08002EFE2820FF7C2A544C543228C4443FF821083FF822083FF80880FFFE0080
+98A7:2200227EFF902220777C5544775412543F546454BF5424543F2024283F442082
+98A8:00003FF8200820E82F0821082FE8292829282FE82908214A21EA5E2A48068002
+98A9:00027FC2404443485C5244425F44554855505F42444445485F504922801E0000
+98AA:00007FFC01000160011001001FF010D01710111017D0155027CA212A4FE68022
+98AB:00087FC84048435C5C4844485F7E554855485F54445245625F404922801E0000
+98AC:00007FDE404443545C5444645F7E5544554C5F54446445545F484922801E0000
+98AD:00087FC84048434E5C4844485F48555C55545F544454455C5F544922801E0000
+98AE:00407F40417C4D84717451547D5455747D48514255427D3E44804042803E0000
+98AF:80004FF848080868EB880888A888ABE8AAA8AAA84BE8388AC8AA10EA17262002
+98B0:00087FCA4048437E5C4844505F5E5552556A5F44444A45525F404922801E0000
+98B1:00087FC8404843525C5E44425F40555E55525F52445E45525F404922801E0000
+98B2:00027DF244824C8A748A55EA552A7D2A56AA7C4A544A5482530A7D044482807E
+98B3:00047FD8404843485C7E44485F48555C55545F544454455C5F404922801E0000
+98B4:00207F20413E4D407180517E7D1255507D5C515055507DBE44804042803E0000
+98B5:00107F5441384D10717C51447D7C55447D7C514455447D4C44804042803E0000
+98B6:00007F7C41444D7C7144517C7D44557C7D4451FE55007D2844C44042803E0000
+98B7:00107F5241944D28714451847D1055127D5451A855247D4444804042803E0000
+98B8:00007F7C41544D7C7154517C7D0055247D12516055A47D1C44804042803E0000
+98B9:00107F7C41244DFE7100517C7D44557C7D10513C55507D7E44904052803E0000
+98BA:007C7F44417C4D44717C51007DFE55407D7E51AA55527D2A44844042803E0000
+98BB:0E00F1FC2304933445C421443DF451541154FFF41144555455F45D1662060402
+98BC:00A07D2C45244DAC752455FC54207DFC54047CC85430544853847D004482807E
+98BD:100055FC550455347DC401447DF401547D5445F47D44455429F41D16E2064402
+98BE:00007DF844A84C887450542054D87F2654F87CA854F8542453FC7D044482807E
+98BF:00007DFC51047D3451C47D4451F451547D5405F45544555455F4851616060C02
+98C0:00407DBC45144D5475A4552C54407DFC55247DFC552455FC52007D004482807E
+98C1:0000FDFC2504B5346DC4B54425F411547D5445F445447D5445F445167E064402
+98C2:00007DDC44444D5474CC555454207C5054A87D5454A0544852907D2044C2807E
+98C3:00007DFC44504DFC755455FC54007CF854007DFC54A8552452607D004482807E
+98C4:0000FEF82888FE98AAE8AAA8FEF800A87CF800A8FEA810BA54CA928A51062202
+98C5:00007DFE44504DDC755455DC54507DFC55247DFC552455FC52007D004482807E
+98C6:140011FCFF04293445C4834425F437542554FFF4254455544BF4891612060402
+98C7:00287C2045FC4C507488550454487C6C54487DFE544854A852947D1244A2807E
+98C8:00207CA444A44D287450548855047C8856AA7DDC5488555452227D004482807E
+98C9:00207C2045FC4D54748855FC568A7CF854887CF854A8552452607D004482807E
+98CA:08002AF82C88489814E822A841F824A82DF8B6A864A824BA54CA4A8A91060202
+98CB:00007DDE44844DCE748455DE54207C1854487CD45562544853B87D004482807E
+98CC:4400FEF844880098EEE8AAA8EEF824A87EF8C8A87EA848BA7ECA488A7F064202
+98CD:1FF010D01710111017D0155027CA212A4FE680227CF854A87CF854AA7DFE8202
+98CE:00003FF02010201028502450229022902110211022902292244A484A40068002
+98CF:00007DF84410442044C04DFC6C545494552454446C8445284410420241FE8000
+98D0:00103F10211E21102510357C294429442944297C3544250020824062401E8000
+98D1:00407C4044FC450446F44C946CF454845494548A6C82447E4400420241FE8000
+98D2:200013F81208FE0803280AA88AA88A484A484AA852A8532A1C0AE40A48061002
+98D3:00007CF8448844F844884CF86C8854F8548855FC6C0044504488420241FE8000
+98D4:00007DFC452445FC45244DFC6C205414555255426E4844384400420241FE8000
+98D5:00A07D2C452445AC45244DFC6C2055FC540454C86C3044484584420241FE8000
+98D6:0E00F0F822889288448820983CD850A810A8FEA810D8548A548A5D0A65060202
+98D7:00407DBC4514455445A44D2C6C4055FC552455FC6D2445FC4400420241FE8000
+98D8:0000FEF82888FE88AA88AA98FED800A87CA800A8FED8108A548A930A51062202
+98D9:000014F81088FE882888449882D824A836A824A8FFD8248A548A4B0A89061202
+98DA:00207CA444A4452844504C886D04548856AA55DC6C8845544622420241FE8000
+98DB:00007FE000240A28722412201212120AFFC6124812501248224022244214820C
+98DC:08001DFAF00C544A3988FEAA34A652A281F87CAA54AC54AA7CA854AA54A67D22
+98DD:00047FE808247212120EFFD0122A221EFDF82448D5AA56ACFDFA54A855AA9326
+98DE:0000FFC000400044004800500060005000480044002000200012000A00060002
+98DF:0100028004400A203118DFF610101FF010101FF0100811901060121014081804
+98E0:080008001400120029007E00A2003E0022003E002000280024002A0032002000
+98E1:0040404020A0211002880C460BF8120813F8E20823F822442228229023080204
+98E2:080008781448124829487E48A2483E4822483E482048284A244A2A8A32862100
+98E3:0800080014FE121029107E10A2103E1022103E102010281024102A1032502020
+98E4:082008201420122029207E20A2203E2022503E502050285024482A8832842102
+98E5:0808081C14E0122029207E20A2203E3E22E03E202020282224222A22321E2000
+98E6:0800087C1410121029107E10A2103EFE22103E102010281024102A1032102010
+98E7:2020202020503C4824A445FA4688A4F8148808F808A21094108820A440C48080
+98E8:102010201050244824A479FA0A8810F824887CF804A20894088810A420C44080
+98E9:10201020282025FC5220FCA844A87CA844A87CA840F8502248225422641E4000
+98EA:08000808141C127029107E10A2103E1022FE3E102010281024102A10327C2000
+98EB:1008103C29E024205220FC2045FE7C2044207C50405050504888548865044202
+98EC:0100111009203FF802007FFC082011102FE8C8260FE008200FE808D00A300C08
+98ED:10401040284024FE5280FD2044207DFC44247C24404450444844548464A84110
+98EE:082008201420127E28424484BE1022103E1022103E2820283E4820443E842102
+98EF:1004100E28F024805280FCFC44A47CA444A47CA840A850904910552866444082
+98F0:082008101410120029FE7E20A2203E3022283E282024282424202A2032202020
+98F1:00200020FC50208821443E2245FC450465FC950409FC09221114214841848102
+98F2:104010402840247C5284FC8845207C2044207C50405050504888548865044202
+98F3:10201010280024FE5210FC1044107C1044FE7C10401050104810541065FE4000
+98F4:10201020282024405248FC8445FE7C8244007CFC408450844884548464FC4084
+98F5:084008401440127E29A07EA0A3203E3C22203E202020283E24202A2032202020
+98F6:10401020282824085208FC4844547D5245527D604260504448C45544663C4000
+98F7:0800087C1444124429447E7CA2443E4422443E7C2044284424442A4432FE2000
+98F8:00207C204450444844A47DFA0288FEF8208840F87CA20494048804A428C41080
+98F9:100010802B1E26525252FA524A527A524A527AD2435A52544890589069104210
+98FA:088028882EF028842E84F17C02800D603FF8C8260FE008200FE808D00A300C08
+98FB:10201020285024885304FE1244207C4045887C10402050444988541064604380
+98FC:080008FE1402120229FA7E02A2023EFA228A3E8A20FA288A24022A0232142008
+98FD:0840084014FC128429047EF4A2943E9422F43E842094288824822A82327E2000
+98FE:10801080288024FE5320FE2044207DFC45247D24412451244934552864204020
+98FF:081008101492129229927E92A2FE3E1022103E922092289224922A9232FE2002
+9900:1088108829FE24885288FC0045047D0444887C88405050204850548865044202
+9901:10401044284E24B85288FD8846887C8844FE7C88408850884888548864BE4080
+9902:1008103C29E024205220FDFE44207C2044207DFC410451044904550465FC4104
+9903:10401020282025FE5200FC8845047E0244887C88405050504820545064884306
+9904:081008101428122829447E82A27C3E0022003E7C2044284424442A44327C2044
+9905:08840848140012FC29487E48A2483E4823FE3E482048284824482A8832882108
+9906:105010502850255252D4FC5844507C5844D47D5240505050489254926512420E
+9907:080008FE1482128229BA7E82A2823EBA22AA3EAA20AA28BA24822A82328A2084
+9908:410021FC0A441440E0B0210822842D603FF8C8260FE008200FE808D00A300C08
+9909:08100810142012FE29827E82A2BA3EAA22AA3EAA20AA28BA24822A82328A2084
+990A:082004407FFC01003FF80400FFFE11102FE8C8260FE008200FE808D00A300C08
+990B:111009207FFC0400FFFE111022C8CD363FE8C8240FE008200FE808D00A300C08
+990C:080008FE1444124429447E7CA2443E44227C3E442044284E24F42A0432042004
+990D:00003FFE21083FFC2410288833642C9837F6241027F0241027F4446845188604
+990E:084008401478128829507E20A2503E8823063EF82088288824882A8832F82088
+990F:10401020282025FE5240FC4044A07CA245A47E9844905088488854A464C24080
+9910:08000F7828087F28A11017283AC4CD603FF8C8260FE008200FE808D00A300C08
+9911:1020102029FE24205220FDFE45027E0444F87C10402051FE4820542064A04040
+9912:1004101E29E024225312FC9444807C2045FE7C44408451C84830542864C44302
+9913:101010D82B9424945090FBFE48907894489478D84398509048AA58CA6A864102
+9914:102810242BFE24205220FDFC45247D2445FC7D24412451FC492455246524410C
+9915:081008101420124429FE7E28A2443EA2223C3E44204428A824102A2832442082
+9916:100011FE2800240052FCFC8444847C8444FC7C00408450444848540065FE4000
+9917:102010202BFE24205220FDFC45247D2445FC7C20407050A84924562264204020
+9918:081008101428122829447EBAA2103E1022FE3E102058285424922B1232502020
+9919:10C21034281824645382FC2045FE7C5044907DFE42925092489A549464104010
+991A:11841068283024C85324FC2047FE7C4044FC7D8442FC508448FC548464944088
+991B:100011FC2904250453FCFD0445047DFC44007D1241D45118491055526592410E
+991C:100011FC2924252453FCFD2445247DFC44207DFE407050A84924562264204020
+991D:1084108429FE248452A4FC1045FE7C4044407C7C404450444844548464944108
+991E:10481044285E25E05228FC12446A7D9644487C5E41E0502448285412646A4186
+991F:100013DE2842254A5084F94A4A527C2048007BDE40525152489459486A544422
+9920:10441044288825DC5288FC8844887C8845DE7C88408850884888548864884108
+9921:10401040287C24845308FE0044207DCE45027D0241CE51024902550265FE4102
+9922:08200810147C120029447E24A2283EFE22003E00207C284424442A44327C2044
+9923:102010202BFE24505288FD2446227DFC45247DFC412451FC48225422641E4000
+9924:102010A228A225245250FC8847047C2244207CA440A451284850548865044202
+9925:04407C7C04403C7804407D7C06C00D603FF8C8260FE008200FE808D00A300C08
+9926:100010FC288024F85280FCF844807FFE45407D24412851104908554465824100
+9927:103810E0282025FC5270FCA845247C2044407DFE404850884850542064504188
+9928:0820081014FE128229047E7CA2443E44227C3E402040287E24422A42327E2042
+9929:082008201450128829267E10A3FE3E2022443EF82012286425882A1832642182
+992A:100013FE2820244053FCFD5445547D5445547D2C402053FE4850548865044202
+992B:100013FE2A22242053FEFC2045FC7D2445FC7D2441FC50204BFE542064204020
+992C:1080109E289225D25292FC9E44927DD245527D5E4152515249D25422642A4044
+992D:1020104028FC248452FCFC8444FC7C0045FE7C20402050FC4820542065FE4000
+992E:7F2010501E882346549009241048619006601FF8E8160FF008100FF408680C1C
+992F:1040107C288424F85208FDFE44407CA445387C58409451344854549265504020
+9930:1080108E2920261054C0F8AE49047B144D247964412451244924590469144108
+9931:108010BC2884250851FEFB204D20797C4990791041FE51104928592869444182
+9932:080008FC148412FC29847EFCA2403EFE23123E9220AA288224FA2A0232142008
+9933:0800087C1444127C29447E7CA2003EFE22403E7E20AA292A244A2A92322A2044
+9934:102010202BFE245050A8F9244AFA782048A8788843FE50884888588869084208
+9935:100010FC28A424A452FCFCA444A47CFC44007DFE40905094488854A864C44082
+9936:100010FC288424F45294FDFE45027CFC44847CFC408450FC4884548464944088
+9937:0810081014FE123829547E92A2003E7C22443E7C2044287C24442A0032FE2000
+9938:102210122914248052BEFC0844087DBE44887C884094509248A25540663E4000
+9939:0820081014FE129029BC7E94A2FE3E9422BC3E9020BC28A424A42AA432BC2124
+993A:102810242BFE242053FCFD2445FC7D2445FC7D24400853FE4888544864484018
+993B:084408241428120029FE7E10A2103E7C22103E1020FE280024AA2AAA32AA2000
+993C:1080108028FC250052F8FC0045F87C4845687CC841F8504A48EA555A64464042
+993D:1020104029FC25245324FDFC45247D4445FC7C4040B050A4493C55226622441E
+993E:104013BE2A1226925252FAAA4B2478404BFE7A22422253FE4A225A226BFE4202
+993F:10A0112C2924252453ACFD2445247DFC44207DFC408850504820545064884306
+9940:101E11E0282225125294FC8044207DCE45027D0241CE51024902550265FE4102
+9941:1020102028FC24205220FDFE44407C8445FE7C0241FC51544954555467FE4000
+9942:100010F82888248852F8FC8844887CF844007DFC415451544954555467FE4000
+9943:108810882BFE24885200FDFC45047DFC45047DFC402053FE4850548865044202
+9944:1020112428A827FE5202FCF844887C8844F87C20402051FC4820542067FE4000
+9945:087C0844147C1244297C7E00A2FE3EAA22FE3E0020FC284424282A1032682186
+9946:100011FC292425FC5324FDFC44A87CA847FE7CA840A851FC482057FE64204020
+9947:100013FE2A00267C5244FA444A7C7A004AEE7AAA42AA52AA4AEE5A006BFE4000
+9948:1084104829FE241052FCFC2045FE7C40447C7CA4412450FC4844544465FE4000
+9949:108810882BFE248852F8FC2045FC7D2445FC7C2043FE502049FC542067FE4000
+994A:114811482BE82550515EFBE448147BD44A547BD4425453C84A485A546A5442E2
+994B:102011FC292425FC5220FFFE44007DFC45047DFC410451FC490455FC64884104
+994C:100013DE2A5227DE5210FA5249CE780048887BFE408850884BFE588869044202
+994D:108810502BFE242051FCF8204BFE792448A87BFE400051FC4904590469FC4104
+994E:102013FE282025FC5200FDFC45047DFC44887FFE400051FC4904550465FC4104
+994F:3C20043EFF4422A83E1023287E44038006601FF8E8160FF008100FF408680C1C
+9950:102013FE282025FC5000FBFE4A0279FC480079FC410451FC490458886BFE4000
+9951:112411242AAA27AE5124FAAA4BAE79244FFE7910411451144A8A5A4A6A164422
+9952:1020102029FC242053FEF9084B9C790849887E3E400053FE489058906912420E
+9953:1020112428A827FE5202FCF844887C8844F87C2043FE507048A8552466224020
+9954:0100FFFE10A025FE7B2015FC792011FEE6601FF8E8160FF008100FF408680C1C
+9955:7C1C4410FEFE20927CF8049428BC11AA06661FF8E8160FF008100FF408680C1C
+9956:1020113C292027FE5010F8144BFE7A104BF07A54425452D44B68544A68964322
+9957:110023DE7A5213D42A527BDA129423D006601FF8E8160FF008100FF408680C1C
+9958:101011FE280025FE5302FD7A454A7DFE44007CFC408450FC488454FC640041FE
+9959:102011FC2820248853FEFC8845FC7D0445FC7D0441FC510449FC548865044202
+995A:108813FE2888242053FCFC2047FE7C4044887DFC400051FC4954555467FE4000
+995B:108813FE288827FE5202F9FC48007BFE484078A2435450B84B5458926B504020
+995C:3FFE28882F8A20082FBE28882F8828D429A223F826162BF0221043F44268831C
+995D:104010202BFE264853FEFA484AEC7B5A4A487BFE4220527C4AC45344647C4844
+995E:11F012102BFC260453FCFA244BB87A2249FE7A1047FC52444BFC58D0694A423E
+995F:102013FE280025DC5154F9DC48887BFE48887BFE408853FE489459886AA440C2
+9960:100013FE2A52265253FEF90849547A5E4FB4791E425457DE48145554655E4010
+9961:152817BE294827BE5318FDAA49467BFC4A047BFC420453FC4A045BFC69084204
+9962:104017FC2A4827F85040FFFE4AAA7BB849107BFC411057FE492853106D484186
+9963:2000200020003E00440048008000100010001000100012001400180010000000
+9964:2000200020FE3E10441048108010101010101010101012101410181010500020
+9965:200021F021103D1045104910A1102110211021102110211229123212220E0400
+9966:2010207823C03C40444048408040207E27C020402040244228423042203E0000
+9967:200021F820103C2044404880A1FE209220922092211221222A22344220940108
+9968:2040204020403BFC4840524882482248224823F82048204028423042203E0000
+9969:2080208020FC3D00460048F88000200021F8200820082408280A300A20060002
+996A:2008203C21E03C2044204820802023FE20202020202024202820302021FC0000
+996B:2008203C21E03C204420482083FE202020202050205024502888308821040202
+996C:20802080210039FE4A005440804023FC20442044208420842904310422280410
+996D:2008201C21E03D00450049FCA144214421442128212821102910322822440482
+996E:2040204020403E7C448448888120102010201050105012501488188811040202
+996F:2050204820403C5C45E04840A05E23E020442048203020222852308A23060002
+9970:2080208020803CFE45204A20802021FC21242124212425242934312820200020
+9971:2080208021FC39044A0455F481142114211421F4210421282912310220FE0000
+9972:200023FC20043C0447F44804A00423E422242224222423E42804300420140008
+9973:2020202021243D244524492481FC202020202124212425242924312421FC0004
+9974:2020202020403C8845044BFE8002200021FC2104210425042904310421FC0104
+9975:200023FE21083D08450849F8A108210821F821082108211E2BE8300820080008
+9976:2080208020BC3BC04850502480D4230C200027FE2090209029123112220E0400
+9977:2040204020803BFC4A04520482F4229422942294229422F42A04320422140208
+9978:2020202020503C8845044A0281FC2000200021FC210425042904310421FC0104
+9979:2080208020F839084B1054A0804020A02118220625F821082908310821F80108
+997A:2040202020203DFE44004888A104220220882088205020502820305020880306
+997B:2040202020203BFE4840504080A020A221A4229824902088288430A220C00080
+997C:21042084208838004BFE508880882088208827FE208820882908310822080408
+997D:2020202023FE3C2044204BFEA202240421F82010202023FE2820302020A00040
+997E:200023FC20003C0045F849088108210821F82000210824882890300027FE0000
+997F:201020D823943C9444904BFEA0902094209420D82398209028AA30CA22860102
+9980:2020202020503C8845044AFAA020202023FE2020212821242A22342220A00040
+9981:2008203C23C038444A2451288100204023FE2088210823902860305021880604
+9982:2040204020883D0447FE4802A0882144224220F8218822502820305021880606
+9983:200021FC21243D2445FC4924812421FC202023FE207024A82924322220200020
+9984:200021FC21043D0445FC4904A10421FC2000211221D42118291031522192010E
+9985:2080208020F839084A1054008040239C22042204239C22042A04320423FC0204
+9986:2040202023FE3A024C0451F88108210821F82100210021FC2904310421FC0104
+9987:2040204027FC38E049505248844623F8220823F8220823F82A08300027FE0000
+9988:2020202021FC3D2445FC482083FE200021FC2104212425242924305020880304
+9989:200021FC21043DE445244BFE820221FC210421FC210425FC2904310421140108
+998A:20A0232E22223E2247AE4A22A22223FE202023FE210420882850302020D80706
+998B:210021F022103C204BFC5244824423FC20A02122261E20C02830318020600010
+998C:2020202021FC3C2044204BFEA080210423FE200223FC22942A94329427FE0000
+998D:2110211027FC3910480053F8820823F8220823F8204023FC28A0311022080406
+998E:2028202423FE3C2045FC4924A1FC212421FC2124200823FE2888304820480018
+998F:204023BE22123A924A5252AA8324204023FE2222222223FE2A22322223FE0202
+9990:2208211027FC38404BF8508087FC210023F82488288823F82908310827FE0000
+9991:2088208823FE3C8844F84820A1FC212421FC202023FE202029FC302023FE0000
+9992:23F8220823F83A084BF8500087FC24A424A427FC200023F8291030E023180C06
+9993:2288228827C83A904A9E57D4802427D4245427D4245427C82C483454246404C2
+9994:200023DE22523BDE4A10525281CE2000208823FE208820882BFE308821040202
+9995:204027FC22483BF848405FFE8AAA23B8211027FC21102FFE292833102D480186
+9996:10100820FFFE020004003FF8200820083FF8200820083FF8200820083FF82008
+9997:211020A0200023FCFC8025F8250825F8250825F8250825FA250A440243FE8000
+9998:441424122810FDFE101020107DD2455245527D5445D47C0844CA471A7C264442
+9999:00701F8001000100FFFE054009203118DFF6101010101FF0101010101FF01010
+999A:041078501050FE5010883888550492FA7C48444844487C48448844887D284610
+999B:045078481048FE4011FE38405440907C7CA444A444A87D28451046287C444482
+999C:040078FC1084FE84108438FC548090A07CA444A844B07CA044A245227D1E4600
+999D:044078201028FE0810083848545491527D52456046607C4444C445447E3C4400
+999E:0420782011FEFE20102039FE550292047CF8441044207DFE442044207CA04440
+999F:0408783C11C0FE04114438A8540091F87C10442047FE7C20442044207CA04440
+99A0:042078201050FE8811443A2254F890087C10442045FC7D04450445047DFC4504
+99A1:044878481048FDCE10483848544891CE7C48444844487DCE444844487C484448
+99A2:04487844105EFDE010283812546A91967C48445E45E07C24442844127C6A4586
+99A3:0420782011FEFE5010A8392654F890A87CA844F844A87CA844F844AA7C22441E
+99A4:040079FC1104FDFC110439FC548091FE7E22452245527D0245FA44027C144408
+99A5:0440784010FEFE8011FC3A8454FC90847CFC4440447C7CC4452844107C684586
+99A6:048878501000FDFE105039FC545493FE7C5445FC44507CD8455446527C504450
+99A7:040078F81088FE8810F83888548890F87C0045FC45547D54455445547FFE4400
+99A8:0878FF4808863E782A483E3040489FE401007FFC09203FF8C8260FE008200FE0
+99A9:042079FC1020FC8813FE388855FC91047DFC450445FC7D0445FC44887D044602
+99AA:0420781011FEFF0210FC38A8553090FC7D8444FC44847CFC448444FC7C484484
+99AB:1FE001007FFC09203FF8C8260FE008247FF81010FEFE545492927C7C44447C7C
+99AC:00003FF821003FF021003FF0210021003FF80008124849284928800800500020
+99AD:00007F00487C7F2448247F24482448287FA800A8AA90AA90AAA880A805440282
+99AE:000043FC224023F802400BF80A40124013FCE004255425542554240420280010
+99AF:00007F7C48107F1048107F104810487E7F900090AA90AA90AA90809005100210
+99B0:00107F1048107F3C48247F44480448247F940094AA84AA84AA84808405280210
+99B1:00107F1048107F10487E7F10481048107F9000A8AAA8AAA8AAA880C405440282
+99B2:00087F1C48707F1048107F104810481E7FF00090AA90AA92AA928092050E0200
+99B3:00207E2048207EA048AC7EB448E449A47EA402B4AAA8AAA2AAA28282147E0800
+99B4:00027F22482A7F2A482A7F2A482A482A7FAA00AAAAAAAAAAAAAA80AA05420282
+99B5:3FF821003FF021003FF021003FFC4924849408280820FFFE0820102020204020
+99B6:00107E1048107EFE48107E1048FC48447E440244AA28AA28AA10822814440882
+99B7:00087F0848087F3E48087F08483E482A7FAA00AAAAAAAAAAAAAE808805080208
+99B8:00007F0C48307F2048207F20483E48247FA400A4AAA4AAA4AAA480A405440284
+99B9:00007F3E48227F2248227F224822483E7FA200A2AAA2AAA2AAA280BE05220200
+99BA:00007EFC48447E4848487E50485C48447E440244AA68AAA8AA90829815240842
+99BB:00107F1048207F2848447F7C480448287FA800A8AAA8AAA8AAAA80CA05460280
+99BC:00207E1048107EFE48447E44484448447E440228AA28AA10AA10822814440882
+99BD:3FF821003FF021003FF021003FFC4924849401083FF8210821083FF801000100
+99BE:00107E1048107E1048FE7E92489248107E280228AA28AA28AA48824A148A0906
+99BF:00107F0848007F3E48227F224822483E7FA200A0AAA0AAA0AAA080A005400280
+99C0:00487E4448447E4049FE7E50485048507E500250AA50AA52AA528292148E0900
+99C1:00027F2248147F0848147F22484248007FA200A2AA94AA94AA88809405240242
+99C2:400049FC5120612045FC45203DFC1120112011FEFC0212AA12AA120210141008
+99C3:00107F1048107F10487C7F14481448147F9400FEAA90AA90AAA880A805440282
+99C4:00207E2048207E2048FE7E20482048307E500250AA48AA48AAC882A415240A02
+99C5:00007E7C48447E4448447E44487C48547E500250AA48AA48AA48828414840902
+99C6:00007DFE51007D0451447D28512851107D100528552855445584850015FE0800
+99C7:00107F1048107F20483E7F4448A448247FA800A8AA90AA90AAA880A805440282
+99C8:00087E1C48607E4048407E404840487E7E480248AA48AA48AA48824815FE0800
+99C9:00007EFE48827E8248827EBA48AA48AA7EAA02AAAABAAAAAAA828282148A0884
+99CA:00107E1048107EFE48927E94489048FC7EA402A4AAA8AAA8AA90832815440A82
+99CB:00007F7E48127F1248127F22482A48447F8000BEAAA2AAA2AAA280A2053E0222
+99CC:10003EF84288A2AA1492187EE0001FF011001FF011001FF011001FFC2A44492C
+99CD:00007F7C48107F1048547F34483848107FFE0090AA90AA90AA90809005100210
+99CE:00087F0848087F08483E7F2A482A482A7FAA00BEAAAAAAAAAAAA80AA053E0222
+99CF:00007F3E48207F2048207F3E482248227FA200A2AABEAAA0AAA080A0053E0200
+99D0:00107F0848007F3E48087F08480848087FBE0088AA88AA88AA888088057E0200
+99D1:08007F7C114432280C10122861461FF011001FF011001FF011001FFC2A44492C
+99D2:00207F2048207F7E48427F82483A482A7FAA00AAAABAAAAAAA82808205140208
+99D3:00007F3E48087F0848087F18481C482A7FAA00CAAA88AA88AA888080053E0200
+99D4:00007F3C48247F2448247F3C482448247FA400BCAAA4AAA4AAA480A4057E0200
+99D5:100010007E7C124422442A7C44009FF011001FF011001FF011001FFC2A44492C
+99D6:00107F1048287F2848447F92480848007FBC0084AA88AAA8AA90808805040200
+99D7:00107F1048287F2848447F92482048407F880090AAA0AA84AA88809005200240
+99D8:00087F0848107F1048247F7E482248007FBC00A4AAA4AAA4AAA480A4053C0224
+99D9:00487E4848487E8848FE7E88498848887EC802A8AAA8AA88AA88828814A80890
+99DA:00207C2050207DFC51247D24512451247D2407FE542054505450848815040A02
+99DB:00087F0848087F3E482A7F2A482A482A7FBE0088AAC8AAA8AA90809805240242
+99DC:00107E0848087E0248227E24482448A87EAC02B2AB32AA20AA6282A2151E0800
+99DD:00107F0848087F7E48427F42482048247FA800B0AAA0AAA2AAA280A2051E0200
+99DE:00407C40507E7C8051207CA050AC50B47DE404A454B454A854A28482147E0800
+99DF:00007E0048FE7EAA48AA7EAA48AA48AA7EAA02AAAAAEAAC2AA82828214FE0882
+99E0:00007E2048CE7EAA48AA7EAA48AA48AA7EAA02AAAAEAAAACAA28824814480888
+99E1:00003EF822883EF800001FF811001FF011001FF011001FFC0004292444940008
+99E2:00847E4848007EFC48487E48484848487FFE0248AA48AA48AA48828814880908
+99E3:00507E5048507F5248D47E58485048587ED40352AA50AA50AA92829215120A0E
+99E4:00007F7E48107F1048247F22487E480A7F880088AABEAA88AA888088057E0200
+99E5:00147E1248127E1048FE7E10485248527E5202F4AA54AA54AA8A828A15160822
+99E6:111009207FFC0200FFFE08203018DFF611001FF011001FF011001FFC2A44492C
+99E7:00007EFE48827E8248BA7E82488248BA7EAA02AAAAAAAABAAA828282148A0884
+99E8:00107F1048107F3E48227F42483A482A7FAA00BAAAAAAAAAAABA808205140208
+99E9:00087F0848147F1448227F40483E48087F880088AABEAA88AA888088057E0200
+99EA:00107E5048507E7C48907E10481048FE7E280228AA28AA28AA4A824A14860900
+99EB:00207E2049247EA448A87E2049FE48507E500250AA50AA52AA528292148E0900
+99EC:00007F7E48247F2448247F3C482448247FBC00A4AAA4AAAEAAF4808405040204
+99ED:00207C1050107DFE50207C24504450F87C120422544455885410842814440982
+99EE:00207E1048107EFE48007E44488249007E440244AA28AA28AA10822814440982
+99EF:00107E5048507E7C48907E10481048FE7E100238AA38AA54AA54829214100810
+99F0:00007EFE48827E9248927E9248FE48927E9202AAAAA6AAC6AA82828214FE0882
+99F1:00407E4048787E8849507E20485048887F0602F8AA88AA88AA88828814F80888
+99F2:00827C9250927C9250927C9252DA52B67C920492549254925492851215020A02
+99F3:0004F80EA3B8F888A088F928A12EA3A8F8A80AA8AAA8A93EA9008A800C7E3800
+99F4:0010F814A012F810A3FEF810A150A154FFF40954A954A948AA4A8A5A0C263042
+99F5:00007EFE48287E2848287EEE48AA48AA7EAA02AAAAEEAA28AA28822814480888
+99F6:00007EFC48847E8448FC7E8048FE48827EBA02AAAAAAAABAAA82828214940908
+99F7:00107E1048FE7E1048107EFE489248927EFE0210AA38AA54AA92831014100810
+99F8:00007EFC48047E7C48047EFC480049FE7F0202FCAA44AA44AA28821014680986
+99F9:00487E4448407EFE48507E54485848527E540258AA52AA54AA9A8292152E0A40
+99FA:00207E1048FC7E8448847EFC488448847EFC02A2AAA4AA98AA90828814C40882
+99FB:00007F3E48227F3E48227F3E480048007FBE0088AA88AAFEAA88808805080208
+99FC:00107E1048287E2848447EBA481048107EFE0210AA58AA54AA92831214500820
+99FD:00007F3E48227F22483E7F00483E48227FA200BEAAA2AABEAAA280A2052A0224
+99FE:00847E4448487E0048FC7E84488448847EFC0248AA48AA48AA48828A148A0906
+99FF:00107E1048207E4448FE7E28484448A27E3C0244AA44AAA8AA10822814440882
+9A00:0010F8D8A394F894A090FBFEA090A094F89408D8AB98A890A8AA88CA0A863102
+9A01:00107E1048FC7E9448FC7E9448FC48007FFE0240AA80AAFCAA04820414280810
+9A02:00207F1048107F7C48007F28481048FE7F900090AAFCAA90AA90809005100210
+9A03:00107E2048447E8248FE7E004840487E7E900210AAFEAA10AA28824414820900
+9A04:00007EFC48047E04487C7E04480448FE7E100292AA54AA38AA54829214500820
+9A05:00507E4848807EFE49907E9048FC48907E9002FCAA90AA90AA9082FE14800880
+9A06:00007EFE48927E9248BA7E9248FE48827EBA02AAAAAAAABAAA828282148A0904
+9A07:0020F820A050F888A104FAFAA020A020FBFE0820A820A9FCA904890409FC3104
+9A08:00227E2248447EEE48447E44484448447EEE0244AA44AA44AA44824414440884
+9A09:00007EFC48847E8448FC7E84488448FC7E000290AA92AAF4AA98829214D2088E
+9A0A:00407E4048FE7E8249427E7A48A248227EFA0222AAAAAAAAAAFA820214140808
+9A0B:00107E1048107EFE48107E54485448547EBA0210AA38AA54AA92821014100810
+9A0C:00207E1048FE7E8248007E7C480048007EFE0210AA10AA54AA52829214500820
+9A0D:00007E7C48547E54487C7E544854487C7E1002FEAA10AA38AA54829214100810
+9A0E:00207E2049FC7E2048507E8849FE48087EE802A8AAA8AAE8AAA8820814280810
+9A0F:00247F24487E7F2448247F3C482448247FBC00A4AAA4AAFEAA8080A405220242
+9A10:0020F820A050F888A144FA22A1F8A008F8500820A8A4AA82AA8A8A8A0C783000
+9A11:00287E2848287EEE48287E28482848EE7E280228AA28AAEEAA28822814280828
+9A12:00007EFC48447E2848107E68499648107EFE0292AA92AAFEAA10821415FE0882
+9A13:00107E2848447E82487C7E10481048FE7E920292AAFEAA10AA28822814440882
+9A14:00007EFC48847EFC48847EFC484048FE7F120292AAAAAA82AAFA820214140808
+9A15:00007EFE48287E2848FE7EAA48AA48FE7E1003FEAA24AA44AA68821814640982
+9A16:7E20243E1848FFA829104A2898461FF011001FF011001FF011001FFC2A44492C
+9A17:1000087C7E50427C42507E7C425040507F7C550455547F54D554558455144308
+9A18:00407E40487E7EAA496A7E5A489649227E4A0284AA20AA94AB428244143C0800
+9A19:00407C2051FE7D0251027DFE510051007DFE05AA56AA56FE54AA84AA14A20886
+9A1A:00847C4450487DFE50007DE2512A512A7DEA052A552A55EA552A8522152A0964
+9A1B:00007DFA500C7C4A51887CAA50A650A27DF804AA54AC54AA54A8852A15260A22
+9A1C:00107E20487C7E44487C7E44487C48007EFE0210AA10AA7CAA10821014FE0800
+9A1D:0010F810A03CFB94A0FEF894A13CA110FBBC0890A8FEAA90A91089800A7E3400
+9A1E:00107E1048FE7E1048FC7E1048FE48107EFE0220AA40AAFCAB448244147C0844
+9A1F:00207C5050887D0452FA7C0051E2512A7D2A05EA552A552A55EA8522152A0964
+9A20:00007EFC48847E8448FC7E84488448FC7E0003FEAA20AAA0AABC82A015600A3E
+9A21:00107E2048FE7E8248FE7E8248FE48107E1202D4AA58AA54AA94829215500820
+9A22:00007DDC51447D4451447DDC510051007DDC0514551455D45508850815140922
+9A23:00287E9248AA7E8248FE7E28484448A27E3C0244AA44AAA8AA10822814440882
+9A24:00107ED448487F4A48847E84490248F87E200220ABFCAA20AA50824814840904
+9A25:00007CFC50487C3051FE7C52509451107E30042055FE547054A8852416220820
+9A26:00007DFC51247D2451FC7D24512451FC7C200410545455425542854A16380800
+9A27:00007E7C48447E4448747E54485448FE7E8202BAAAAAAAAAAABA8282148A0884
+9A28:02427D2450007DFC51247D2451FC51247D2405FC5420542057FE842014200820
+9A29:00107E2048FE7E9248927EFE489248927EFE0220AA24AA5AAA5E82901492090E
+9A2A:00507E9648927E9248D67E92489248FE7E1002FCAA44AA44AA288210142808C6
+9A2B:01007FFE44429FF404403FF80440FFFE09201FF02908CFE609000FF800081558
+9A2C:001CF9E0A020FBFEA0A8F8AAA3ACA0AAF9AA0AA6A870A8A8A9248A220C203020
+9A2D:0020793C492053FE48A46B285070438000003FF821003FF821003FFE29224496
+9A2E:00207EDE488A7ECA48AA7ED248A648007EFE0292AA92AAFEAA92829214FE0882
+9A2F:00207E1048FE7E0048447E2848FE48A27E1002FEAA20AA3CAA24824414540888
+9A30:012478A849FC48404BFE79084BFC4D2249FC792049FC492049FE48024AAA9804
+9A31:000E7EF048227E9248447E20484448F87E100224AAFEAA10AAFE822814440882
+9A32:00887C8853FE7C8850007DFC510451FC7D0405FC5524542057FE842014200820
+9A33:00007EFE48907EFC48907EFC489048907EFE0202AAAAAAAAAAAA828214140808
+9A34:00007E7C48447E7C48447E7C481048FE7E820220AAFEAA44AA68821014280844
+9A35:00007EFE48887E9048BE7EA248BE48A27EBE0288AAACAAAAAACA828A15280A10
+9A36:00407E4048FE7F2248AA7EFA484248947F4802FEAB22AAAAAAFA824214940908
+9A37:00007DFC50A47C8850507C2050D853267C2005FC5524552455FC842217FE0802
+9A38:00207C1051FE7D0251027DFE510051EE7D2205AA55665522556686AA16220C66
+9A39:00887C8853FE7C8850F87C2051FC51247DFC042055FC542055FC842017FE0800
+9A3A:08207E2008F8FF2814287F6A082AFF5608823FF821003FF821003FFE29224496
+9A3B:00107E1048FE7E1048BA7E5448BA48107EBA0254AABAAA10AA28822814440882
+9A3C:00207E1048FE7EA848A87EFE48AA48AA7EFE0280AACAAAECAB48824A146A0846
+9A3D:00007DDE50427D5250CA7D52504250207CFC0484548454FC5484848414FC0884
+9A3E:00007DFC51247DFC51247DFC504050887DF00420544457FE5422852416220860
+9A3F:00107EFE48447E2848FE7E00487C48447E7C0244AA7CAA10AAFE821014100810
+9A40:0820FFFE08201FF010101FF01010FFFE08203FF8D1061FF011001FFC2A44452C
+9A41:08207F20087E7E4408A4FF2810101E2822447FFAA1003FF821003FFE29224496
+9A42:00107E2048447EFE48447EAA48EE48107E280254AAAAAA50AA24824814100860
+9A43:00007EFE48287EFE48AA7EAA48FE48007E7C0200AAFEAA10AA54829214500820
+9A44:00207C4051FC7D24517C7D8C515451247D5405FC5420541055548542154A0A38
+9A45:0000FBFEA200FA7CA244FA44A27CA200FAEE0AAAAAAAAAAAAAEE8A000BFE3000
+9A46:00007EFE48927EFE48927EFE485448547EFE0254AA54AAFEAA1082FE14100810
+9A47:08203E2008F87F282A685D2A08563E8200003FF821003FF821003FFE29224496
+9A48:00FC7E2848107FFE48527E94495048207EFE02AAAAC6AABAAAAA82BA14820886
+9A49:00207C3C50207DFE51227D3851E4511C7D00052855AA556C5528862814FE0800
+9A4A:00447EFE48447E0048FE7E54485448FE7E540254AAFEAA10AAFE821014100810
+9A4B:0024FBA8A092FD14A208FC04A3BAA0A8F8C60B80AA3CAB84A8A888900AA83144
+9A4C:0020F9FCA024FBFEA024F9FCA020A2AAFBAE0A22ABFEAA22ABAE8AAA0AAA3422
+9A4D:0020F820A1FCF820A3FEF908A39CA108F9880E3EA800ABFEA89088900912320E
+9A4E:0020F924A0A8FBFEA0A8F924A222A104F90409DEAA44AD54A89E89040A043404
+9A4F:03FEFA02A3FEFA00A2FCFA08A3FEA210FA300BCEAA42AA84ACEE8F840884318C
+9A50:0108F888A3C8F810A3DEFA64A3D4A014FBD40854A894A8E8AB8888940A943122
+9A51:00007EFE48287EEE48AA7EAA48EE48287EFE0292AA92AAFEAA92829214FE0882
+9A52:00007EEE48AA7EAA48EE7E0048FE48927EFE0292AAFEAA10ABFE821014100810
+9A53:00447E2448287EFE48927ED648BA48927EFE0200AA7CAA44AA7C8244147C0844
+9A54:00007EFE48287EFE48AA7EFE4800487C7E44027CAA44AA7CAA1082FE14100810
+9A55:0018F9E0A040FBFEA088F974A252A070F80009FCA904A974A95489740904310C
+9A56:008CFBEAA088FBFEA008FBE8A22AA3EAF80A0BECA88CABECA88A88EA0B963022
+9A57:00207C2050507C8851047EFA500050007DDC0554555455DC5488848815540A22
+9A58:0100FFFE20003FF800003FF820083FF8000077DC551477D4551C77D65056B562
+9A59:00107EFE48007EFE48827EBA48AA48FE7E00027CAA44AA7CAA44827C140008FE
+9A5A:2420FF20247E7EC482287A104A287AC604003FF821003FF821003FFE29224496
+9A5B:00007DFC51547DFC50207DFC502053FE7C88045055FC542057FE842014200820
+9A5C:00507D5250D47C5051FE7C88505051FE7C2004FC542055FE54A8852416220820
+9A5D:00107EFE48107E7C48007EFE4882487C7E20027CAAC4AB7CAA1082FE14540992
+9A5E:0040F820A3FEFA02A1FCF948A250A1FCFB0409FCA904A9FCA90489FC08883104
+9A5F:03F07D2E51E27D2A51E47D3453EA50327C1E07E054A25534546884A417220820
+9A60:0110F910A7FCF910A1F0FA08A2EAA6ACFAA80AAAAEEAAA06A8008AA40A523452
+9A61:10407E7C2440FF7C42047E7C42407E7842423FFE21003FF821003FFE29224496
+9A62:0040F87CA040FBFCA244FBF0A244A2FCFAA80AF8AAA8AAF8AA008DFC095433FE
+9A63:01247CA851FC7C4053FE7D0853FC55227DFC052055FC552055FE840216AA0804
+9A64:00107EFE48007EEE48AA7EEE484448FE7E4402FEAA44AAFEAA5082CA15640842
+9A65:0094FB98A092F98EA280F9FCA124A1FCF92409FCA888A9FCA8888BFE08883104
+9A66:01FCF820A3FEFA22A1ACF820A1ACA000F89E0BF2A89EA9D2AABE8C92089E3092
+9A67:0290FA90A7D0FABEA3CAF92EA7DAA54AFD7E0FCAA91EAFEAA90A8902090A3104
+9A68:0222FBFEA090F9FEA310FDFEA110A1FEF91009FEA900ABFEAA8A8B760A523276
+9A69:0088FBFEA088FBDEA252FBDEA0A0A090F9FE0920ABFCAD20A9FC892009FE3100
+9A6A:03DEF800A3DEFA52A35AFA52A020A3FEFA500BFEAA52ABFEAA928ADC0A9234CE
+9A6B:7FF842007FF042007FFC5244892C7E7E48487E7E48487E7E48487E7E02029696
+9A6C:00007FE0002000201020102010201FFC000400040004FFE40004000400280010
+9A6D:00007C0005FC24842484248424883E88025002501A20E2204250028815040A02
+9A6E:00207C2004202420242025FE24203E20022002501A50E2504288028815040A02
+9A6F:0104F924092449244924492449247D24052405241D24E524452406242A041404
+9A70:0020F82008204920492C493449647FA4052405341D28E5224522050228FE1000
+9A71:0000F9FE090049044944492849287D10051005281D28E5444584050029FE1000
+9A72:00007CFC048424842484248424843EFC028402841A84E2844284028414FC0884
+9A73:0008F888085048204850488849007C08048804881C50E4504420045028881306
+9A74:0040F820082048FC4884488448847CFC048404801C80E4804480050029001200
+9A75:0000F8F808884888488848F848887C88048804F81C88E488448804882BFE1000
+9A76:0020F820082049FC4924492449247D2405FC04201CA0E4604460049029081206
+9A77:0000F9FC095449544954495449547D540594058C1D04E504450405FC29041000
+9A78:0088F88808884908497E4B084D087D48052805281D08E5084508050829281110
+9A79:0080F880090049FC4A044C0449E47D24052405241DE4E5244404040428281010
+9A7A:0080F88008F849084A104C204BFC7C04040404041DFCE404440404042BFC1004
+9A7B:0040F82008004BFE4820482048207C2005FC04201C20E420442004202BFE1000
+9A7C:0020F810081049FE49024A0448807C88049004A01CC0E48244820482287E1000
+9A7D:08007F7C114432280C10122861461FE00020082008200FFC00047FC400140008
+9A7E:080008007F7C11441144257C42001FE00020082008200FFC00047FC400140008
+9A7F:0000FBFC090448884850482048D87F26042005FC1C20E42047FE042028201020
+9A80:0020F8200840488849044BFE48027C0005FC05041D04E5044504050429FC1104
+9A81:0080F88008BC4BC04850482448D47F0C040007FE1C90E490451205122A0E1400
+9A82:00007CF8448844887CF800003FE00020082008200FFC00047FE4000400280010
+9A83:0000F9FC090449244924492449FC7D24052405541D4CE58C4504050429FC1104
+9A84:0008F83C09E0482048204BFE48507C880504068A1C88E4884488050829081208
+9A85:0090F894091449184B104D3249527D0E052004201FFEE4204420042028201020
+9A86:0080F88008F849084B104CA048407CA0051806061DF8E5084508050829F81108
+9A87:0020F810081049FE4820482448447CF8041204221C44E5884410042828441182
+9A88:0084F8440848480049FE484848487C48044807FE1C48E4484448044828881108
+9A89:3FF0001010101FFC00047FE400280010FCFC040444447E7E0202F2F20A0A0404
+9A8A:0000F3FE1000500053DE525252527A520B5A0AD63A52CA520A520A522A5212D6
+9A8B:0020F82009FC492449FC492449FC7C0007FE04801D00E5FC4404040428281010
+9A8C:0020F82008504850488849044AFA7C00044404241D24E4A8448804102BFE1000
+9A8D:0040F82009FC4800488848504BFE7C20042004201DFCE4204420042028201020
+9A8E:0000F8FC0804487C480448FC48007DFE050204FC1C44E4444428041028681186
+9A8F:0040F840088849044BFE480248887D44064204F81D88E6504420045029881606
+9A90:0088F8880BFE4888488848F848887C8804F804881C88E7FE4400048828841104
+9A91:0020F82009FC4850488849044BFE7C0805E805281D28E5E84528040828281010
+9A92:0000F9FC0924492449FC492449247DFC042007FE1C70E4A84524062228201020
+9A93:0050F848088048FE49904A9048FC7C90049004FC1C90E490449004FE28801080
+9A94:0040F8200BFE4A024C0448F848007C0005FE04201CA8E4A44522062228A01040
+9A95:0020F82009FC48244BFE482449FC7C20052405241D74E5AC452405242A241424
+9A96:0040F848088449FE48204BFE48887D24064205881C10E4624584041828601380
+9A97:0040F82009FE4902490249FE49007D0005FE05AA1EAAE6FE44AA04AA28A21086
+9A98:0020793C492053FE48A46B28507043801FE0002008200FFC00047FC400140008
+9A99:0010FBD408584A52498C488849047EFA042004201DFEE4204450048829041202
+9A9A:0000F9FC08A448884850482048D87F26042005FC1D24E52445FC04222BFE1002
+9A9B:7E20243E1848FFA829104A28984600001FE0002008200FFC00047FC400140008
+9A9C:08207F20087E7E4408A4FF2810101E2822445FE2802008200FFC00047FD40008
+9A9D:0040F9BC09144994495449A4494C7C0005FC05241D24E5FC4524052429FC1104
+9A9E:01007FFE44429FF404403FF80440FFFE08201FD02048C8460FF800087FA80010
+9A9F:0020F81009FE4902490249FE49007DEE052205AA1D66E522456606AA2A221466
+9AA0:0000FBFE085049FC4954495449FC7C0005FC04001FFEE42044A805242AA21040
+9AA1:0000F9FC092449FC492449FC48407C8805F004201C44E7FE442205242A221060
+9AA2:0020F84009FC4924497C498C49547D24055405FC1C20E41045540542294A1238
+9AA3:03FEF20213FE520052FC520853FE7A100A300BCE3A42CA840CEE0F842884118C
+9AA4:07E0F25C13C4525453C8526857D47864083C0FC03944CA6808D009482E461040
+9AA5:0094FB980892498E4A8049FC49247DFC052405FC1C88E5FC448807FE28881104
+9AA6:01FCF8200BFE4A2249AC482049AC7C00049E07F21C9EE5D246BE0492289E1092
+9AA7:0020F3FE100051DC515451DC50887BFE08880BFE3888CBFE089409882AA410C2
+9AA8:1FF010101F90109010907FFE40029FF410101FF010101FF01010101010501020
+9AA9:00407C404440744055F8FE4882487C4844487C4844487C4A448A448A55064A00
+9AAA:00007C0044F074905490FE9082907CD044B07C9044907C9244924512550E4A00
+9AAB:00407C40444075F85448FE4882487D4844C87C4844A87CA8448A450A55064A02
+9AAC:00007CFC442074205420FE2082207DFE44207C2044207C204420442054A04840
+9AAD:00007CFC442074205420FE2082207DFE44207C2044207C204420442054204820
+9AAE:3F1021143D12251225107F9640B8BF1021103F1021103F10210A210A25062202
+9AAF:00407C20440075FC5400FE0082F07C9044907C9044907C9244924512550E4A00
+9AB0:00007CF8448874885488FF0682007DFC44847C8444487C504420445054884B06
+9AB1:00207C20442074505450FE8883067C4844487C4844487C484448448854884908
+9AB2:00407C4044FC74845504FEF482947C9444F47C8444947C8844824482547E4800
+9AB3:00107C10441074FE5492FE9482907CFC44A47CA444A87CA84490452855444A82
+9AB4:00087C284428742854A8FEAA82BC7CA844A87CA844A87CA844AA44BA54EA4986
+9AB5:00207C204420742055FEFE7082A87CA845247D2446227CF84420442054204820
+9AB6:00047C1E44F074905490FE9082907CFE44907C9044907C88448A44AA54D6488A
+9AB7:00207C204420742055FEFE2082207C2044FC7C8444847C844484448454FC4884
+9AB8:00207C10441075FE5420FE2482447CF844127C2244447D884410442854444982
+9AB9:00207C10441074FE5400FE4482827D0044447C4444287C284410442854444882
+9ABA:00087C1C44E074805480FEFE82807C8044BC7CA444A47CA444A4453C55244A00
+9ABB:00207C2045FC74505488FF0482FA7C0047FE7C4044807DFC4404440454284810
+9ABC:00407C40447874885550FE2082507C8845067CF844887C884488448854F84888
+9ABD:00047C1E45E074225512FE9482807C2045FE7C4444847DC84430442854C44B02
+9ABE:00007DFE4420742055FCFF2483247DFC45247D2445FC7D2044A0444054B04B0E
+9ABF:00847C48440074FC5448FE4882487C4845FE7C4844487C484448448854884908
+9AC0:00207C4044FE74925492FEFE82927CA244FE7C4844887DFE4408440854084808
+9AC1:00007CF844A874A854F8FEA882A87CF844207DFC44207C7044A8452654204820
+9AC2:00407C2045FC75045440FE7882887D5044207CD847067CF84488448854F84888
+9AC3:00FC7CA444A474FC54A4FEA482FC7C2044207DFE45227D2A45FA450A55024906
+9AC4:00087C0844FE751054A0FE7E82A27C2245BE7CA244BE7CA244AA44A455404A3E
+9AC5:00207D2444A8742055FEFE6882A47D0244207DFE44487C8844D04430544C4982
+9AC6:00147C1245FE741054FEFE9282FE7C9244FE7C9244047DFE444444245424480C
+9AC7:00207C1045FE740054FCFE8482FC7C0045FE7D02457A7D4A457A4502550A4904
+9AC8:00207C1044FE74005444FE2882FE7CA244107CFE44207C3C4424444454544888
+9AC9:00207C2045FE75525448FEFE82907D9044FE7C9044907CFE4490449054FE4880
+9ACA:00847C44444875FE5420FEFC82207DFE44407C8044FE7D104610441055FE4800
+9ACB:00207C1045FE75025448FEFC82487C0044FC7C8444A47CA444A4445054924B0E
+9ACC:00407C2045FE75025418FEE082807CFC44907C9044907DFE4400448855044A02
+9ACD:00207C1045FE75485548FF4883FE7D4845487DEC455A7D684548454856484848
+9ACE:00007CEE442274AA5466FEAA82107C2844447D9244207CC8443244C4541848E0
+9ACF:00207DFC452477FE5524FFFC82207DFC45247DFC44407DFE448845D054704B8C
+9AD0:00207C2044FC742055FEFE8883DC7C8844C87DBC44007DFE445044505494490C
+9AD1:00007CFE44AA74AA54FEFE4082FE7D2244FA7CAA44AA7CFA442244FA540A4804
+9AD2:00487DFE4448740055FEFE8882EA7D2C44CA7C8645487DFE4448444854884908
+9AD3:00107C7E452074BC54C8FEBE82007DBC44A47CBC44A47CBC44A444AC55404A3E
+9AD4:00507DFC455475FC5554FFFC82007DFC44007DFC45047DFC4488445057FE4800
+9AD5:00207C1045FE750254FCFEA883307CFC45847CFC44847CFC448444FC54484884
+9AD6:00207DFE454A74FC5448FEFC82847CFC44847CFC44847CFC445044545492490E
+9AD7:00207C3E442075FE5522FFF883227D7E45547D7C45547D7C450046FE54AA49FE
+9AD8:02000100FFFE00000FE0082008200FE000007FFC40044FE4482448244FE4400C
+9AD9:020001007FFC10101FF010101FF010107FFC40044FE4482448244FE44004400C
+9ADA:20201010FE1001FE7C0044007C780048FE488248BA48AA4AAA4ABA8A82868700
+9ADB:200010FCFE8400847CFC44A07CA000A0FEF882A8BAA8AAA8AAA8BAAA834A8686
+9ADC:2000107EFE42007E7C42447E7C000014FE648224BA24AAFEAA24BA2482448684
+9ADD:2048116AFEDC00487CB445227DFE0102FE208220BAFCAA24AA44BA4482948708
+9ADE:207C1044FE44007C7C0044EE7CAA00AAFEEE8210BAFEAA38AA54BA9283108610
+9ADF:3F04200420083E10202020443E0420082010FF22104224044208FF10412000C0
+9AE0:3E0420183E6020043E182062FF0422187F6000000FE00820082010222022C01E
+9AE1:3E0420183E6020043E182062FF0422187F6000007FFC0440044008423042C03E
+9AE2:3E0420183E6020043E182062FF0422187F60013011D01F107152112210020FFE
+9AE3:3E0420183E6020043E182062FF0422187F6002007FFC040007F0081010A06040
+9AE4:3E0420183E6020043E182062FF0422187F6001007FFC0380054009203118C106
+9AE5:3F0820303EC42018FF62220C7F7000000FF008107FFE08107FFE081008500820
+9AE6:3E0420183E6020043E182062FF0422187F6001F03E0003F03E0003FA7E0201FE
+9AE7:3E0420183E6020043E182062FF0422187F6001007FFC4104028004821882E07E
+9AE8:3E0420183E6020043E182062FF0422187F6000003FF80000FFFE04401842E03E
+9AE9:3F0820303EC42018FF62220C7F700000FFFE010021FC21043FFC000400280010
+9AEA:3E0420183E6020043E182062FF0422187F600100FFFE04000FF0122061C00E3C
+9AEB:3E0420183E6020043E182062FF0422187F6000007FF8080810303FF8D0081FF8
+9AEC:3E0420183E6020043E182062FF0422187F6000007FFC03000D70710C0100FFFE
+9AED:3E0420183E6020043E182062FF0422187F60088008882E9028E028842E84F07C
+9AEE:3E0420183E6020043E182062FF0422187F600110FFFE04000FF0122061C00E3C
+9AEF:3F0820303EC42018FF62220C7F7001003FF821083FF82108FFFE200820282010
+9AF0:3E0420183E6020043E182062FF0422187F6000001220FFFE122013E010001FFC
+9AF1:3F0820303EC42018FF62220C7F7008001FF020105F9010901FD0102010040FFC
+9AF2:3E0420183E6020043E182062FF0422187F6000803FFC208427F0222041C09E3C
+9AF3:3E0420183E6020043E182062FF0422187F6000003FE00440FFFC04841888E180
+9AF4:3F0820303EC42018FF62220C7F7004407FF804483FF824403FFC084410542048
+9AF5:3E0420183E6020043E182062FF0422187F600000FFFE02003FF8248824A82010
+9AF6:3F0820303EC42018FF62220C7F7000003FF808200FE008200FE0083EFFE00020
+9AF7:3E0420183E6020043E182062FF0422187F6004403FF824483FF824483FF82008
+9AF8:3E0420183E6020043E182062FF0422187F6004403FF80440FFFE082010102008
+9AF9:3E0420183E6020043E182062FF0422187F600840104037FCD0E013581C461040
+9AFA:3F0820303EC42018FF62220C7F70000000F83F000100FFFE01001FF010101FF0
+9AFB:3F0820303EC42018FF62220C7F700100FFFE01003FF800003FF820083FF82008
+9AFC:3F042018FF62220C7F7008001FF0282007C01830E10E1FF001007FFC01000100
+9AFD:3E0420183E6020043E182062FF0422187F6011101110292845443FF80100FFFE
+9AFE:3F0820303EC42018FF62220C7F70111009203FF820083FF820083FF820082018
+9AFF:3E0420183E6020043E182062FF0422187F60102048A825240A227028103017C0
+9B00:3F042018FF62220C7F70082004407FF801083FF821003FFC0304051419086100
+9B01:3E0420183E6020043E182062FF0422187F6000083E4808487F481C482A084918
+9B02:3F0820303EC42018FF62220C7F7000201FC010001FF810801080FFFE10202010
+9B03:3F0820303EC42018FF62220C7F7001007FFC40041FF000007FFC111025084204
+9B04:3F0820303EC42018FF62220C7F7000001FF010101FF010101FFC644408943308
+9B05:3F0820303EC42018FF62220C7F7000003E7C22443E7C22443E7C22444A948508
+9B06:3E0420183E6020043E182062FF0422187F6010101088FD443242589095F81008
+9B07:3F042018FF62220C7F7008001FF020205FF80108FFFE01081FF8010805000200
+9B08:3F042018FF62220C7F70111009207FFC0400FFFE10102FE8C82608A0084807F8
+9B09:3F0820303EC42018FF62220C7F700440238824483FF814102FE8144003807C78
+9B0A:3F042018FF62220C7F7001007FFC01003FF80200FFFE08201FF02828CFE60820
+9B0B:3F042018FF62220C7F7010100820FFFE00003E0822483E4822483E4822082618
+9B0C:3F042018FF62220C7F7004007FFC08801FFC28104FF088100FF0081008500820
+9B0D:3E0420183E6020043E182062FF0422187F60107CFF44107C7E44427C7E44428C
+9B0E:3F0820303EC42018FF62220C7F7004047FC404243FA424A43FA4150424944408
+9B0F:3E0420183E6020043E182062FF0422187F6000007C101052FE94382854449282
+9B10:3F042018FF62220C7F7001081FD001207FFC06201C4463FC00001FF811081FF8
+9B11:3F042018FF62220C7F7008407FFC04803FF00490FFFE04903FF00CA03498C486
+9B12:3F042018FF62220C7F7001007FFC01001FF0101011101110FFFE082010102008
+9B13:3F042018FF62220C7F70020001007FFE40229FC410001FF81080FFFE10202010
+9B14:3F042018FF62220C7F70210013F0151000E0775C11F0104013FC284047FE0000
+9B15:3F042018FF62220C7F700820FFFE08201FF010101FF01010FFFE08203018C006
+9B16:3F042018FF62220C7F7008201FF0102025487EFC044018B0E30E0C6003801C00
+9B17:3F042018FF62220C7F7008207FFC08200FE001007FFC5144492455546184410C
+9B18:3F042018FF62220C7F7000001FF010101FF010107FFC44447FFC082007C0F83E
+9B19:3F042018FF62220C7F7008207FFC511449247FFC00001FF010101FF010101FF0
+9B1A:3F042018FF62220C7F7000000BFE104061FC090411FC610405FC090431FCC088
+9B1B:3F042018FF62220C7F7002003FF82448238824483FF829482528294A25263182
+9B1C:3F042018FF62220C7F7000007C7C44447C7C47C47C7C47C4444447C4444448CC
+9B1D:3F042018FF62220C7F7C44447C7C44447C7C40044FE448244FE448244FE4400C
+9B1E:3F042018FF62220C7F7002401FF812481FF812483FFC20003FFC28884A708C0E
+9B1F:3F0820303EC42018FF62220C7F7001003FF82448FFFE10101FF00C883470C60E
+9B20:3F0820303EC42018FF62220C7F7002800C603FF8D55613901FF00A2009200FE0
+9B21:3F042018FF62220C7F7001007FFC4204A92847E400003FF82448FFFE01000300
+9B22:3F042018FF62220C7F7001007FFE40029FF4092011C00FF818886FF804100808
+9B23:3F042018FF62220C7F701084210810843FF82448238824483FF8294A25263182
+9B24:3F042018FF62220C7F700100FFFE22883EF804403FF80440FFFE04901C60671C
+9B25:00005E7A44225E7A44225E7A40024002400240024002400240024002400A4004
+9B26:00005E7A44225E7A44225E7A4082448242824882448240F25F824082408A4084
+9B27:00005E7A44225E7A44225E7A420241025FF241024FE2492249A24942410A4104
+9B28:00005E7A44225E7A44225E7A4002444244424FE2444244425FF24442482A4004
+9B29:00005E7A44225E7A44225E7A42024CE248224EE248224FE242824492587A4004
+9B2A:BEFA8822BEFA8822BEFA8002BF1280129EFE921292929E5292128F12B8529026
+9B2B:BEFA8822BEFA8822BEFA80029C42847ABF5292929E1292529E2293A2FE528296
+9B2C:BEFA8822BEFA8822BEFA8806B3BAAAA2BBA28A3EBBAAA0AABBAA8A2A8BAABC46
+9B2D:BEFA8822BEFA8822BEFA8006BBBAAAA2BBA28A3EBBAAA0AABBAA8A2A8BAABC46
+9B2E:BEFA8822BEFA8822BEFA8102BFF2A012BCF28482B4F29492FCF29482B49283F6
+9B2F:09202448228829282288244829283FF81000103811C01E04100410040FFC0000
+9B30:2288F93E2288729CA92A228800007FFE4A12A4A42AC83F9010241F4810101F20
+9B31:2208F3BC2508739CAD6A27C800007FFE4A12A4A42AC83F9010241F4810101F20
+9B32:0000FFFE00001FF0101010101FF000007FFC482444445FF44104410441144008
+9B33:01FC01003FFE210221F02F0420FC20003FFE220823F820002FFE29124BFA8842
+9B34:0014FE1200FE7C1044107CFE0092FE9282FEAA929292FEFE9292929292928686
+9B35:3E7C48907EFC142A66C60400FFFE00001FF010101FF000007FFC44444FE4410C
+9B36:10F87CA810A8FE52288E4500FFFE00001FF010101FF000007FFC44444FE4410C
+9B37:0028FE9200AA7C8244FE7C280044FEA2823CAA449244FEA89210922892448682
+9B38:0020FEDE008A7CCA44AA7CD200A6FE0082FEAA929292FEFE9292929292FE8682
+9B39:08F83E8808F87E8808F81452228E4100FFFE10101FF000007FFC44444FE4410C
+9B3A:0040FE7E00807D7C44447C7C0044FE7C8200AAFE9240FEFE932A924A92928626
+9B3B:711C1544711C47D0739C1544310C0000FFFE10101FF000007FFC44444FE4410C
+9B3C:020004003FF8210821083FF8220822083FF8051009200948117C2102410280FE
+9B3D:080410047F08491049247F04490849107F2210021A042C882F904820480287FE
+9B3E:081010107F7E491049107F10497C49047F4410281A102CA82FC44884480287FE
+9B3F:0808101C7F60494049407F7E494849487F4810481A482C882F884800480287FE
+9B40:081010107F28492849447F82492849287F2810281A282CA82FA84848480287FE
+9B41:080810487F28492849087F48492849287F0E10F81A082C882F884808480287FE
+9B42:002000407DFC0124012401FCFF24212421FC2040486844B2FCBE45200122021E
+9B43:102820247C2055FE54207C20547C54447C5410882A942D244F40480287FE0000
+9B44:1020104021FC7D24452445FC45247D2445FC4440446844B27CBE45200122021E
+9B45:081010107F10497C49107F1049FE49107F3810541A922C902F904810480287FE
+9B46:101420127C1054FE54907C94549454887C8A10DA2AA62D424F00480287FE0000
+9B47:3FFC20903FFC21402630388C21002FF828882FF828882FF8415042FA8C8A307E
+9B48:081010547F384910497C7F444944497C7F4410441A7C2CC42FC4484C480287FE
+9B49:100021FC7C50545055FC7D54555455547DAC11042B042D144F08480287FE0000
+9B4A:101020147C1257FE54107DD4555455D47C1810CA2B162D224F40480287FE0000
+9B4B:082810247F40497E49C87F48497E49487F48107E1A482CC82FFE4840480287FE
+9B4C:082410247F7E492449247F3C4924493C7F2410241A7E2C802FA84844480287FE
+9B4D:100021FC7D04558C55547DFC554455247DFC11442B742D044F0C480287FE0000
+9B4E:23FE4020F820ABFEAA22FB32AAAAAB76FA66222256225A2A5E0450024FFE8000
+9B4F:0C20704011FCFF24392455FC9324012411FCFC40246844B228BE11202922C61E
+9B50:108820507DFE545055FC7C5457FE54547DFC10502AD82D544F52485287FE0000
+9B51:104020207DFC545055247D5455FC54207DFC11442B542D744F0C480287FE0000
+9B52:100021FC7C5055FC55547DFC540054F87C0011FC2AA82D244F60480287FE0000
+9B53:11FC21247DFC552455FC7CA855FC54A87CA811FC2A202DFC4F20482287FE0000
+9B54:00803FFE24103F7C26382D5435122FF828882FF828882FF8215042F84C8AB07E
+9B55:109421187DDE5494555A7DDE549455FE7C9010D42AAA2D164F20480287FE0000
+9B56:1020203E7C2055FE55227D3C55E2551E7D2811AA2A6C2D284F7C480287FE0000
+9B57:1020FE4010FC7C940094FEFC02A47CA410FCFE200044FF6A026EFFA0AAA2E71E
+9B58:3FFE28882F8A20082FBE28882F88289429A227F8248827F8248847F842528C3E
+9B59:42043FD88A904F9E2A945FD482241FF011101FF012101FF004A808BA3082C07E
+9B5A:040004000FE0102020407FF8A10821083FF8210821083FF80000488844448444
+9B5B:200020007CFE442288227E22522252227E22522252227E420042AA82AA940108
+9B5C:202020207C20442088207E20522052207E50525052507E500048AA88AA840102
+9B5D:100410043E04422484247F24492449247F24492449247F24000455044A948A88
+9B5E:208020407C20442088107E10521052287E28522852287E480044AA44AA840102
+9B5F:200020007C7C441088107E10521052107E10521052107E100010AA10AAFE0000
+9B60:2008203C79E0482090207C205420543E7DE0542054207C220022AA22AA1E0000
+9B61:204020407C40447C88847E84530452447E24522452047E040004AA04AA280010
+9B62:200020007CFC440488047E04520452FC7E84528052807E800082AA82AA7E0000
+9B63:200021F87C08445088207E1053FE52227E24522052207E200020AA20AAA00040
+9B64:205020507850489290927D94569854907CB054D054907C900092AA92AA8E0080
+9B65:200020FC7C44444888487E50525C52447E44524452687EA80090AA98AB240042
+9B66:201020107C10441088547E52525252907E10521452047E080008AA10AA2000C0
+9B67:202020107C1044FE88007E00527852487E48524852487E4A004AAA8AAA860100
+9B68:202020207C2045FC88207EA852A852A87EA852A852F87E220022AA22AA1E0000
+9B69:204020407C40447E88AA7F2A522A524A7E4A529253127E220022AA42AA940008
+9B6A:201020107C10442888287E44528252487E48524852487E480048AA88AA880108
+9B6B:201020107C10441088FE7E92529252107E28522852287E280048AA4AAA8A0106
+9B6C:2008201C79E0490091007DFC554455447D44552855287D100110AA28AA440482
+9B6D:200020FC7C00440088007EFE525052507E50525052507E520052AA92AA8E0100
+9B6E:201020907C90449288927E9452F452987E90529052907E9200B2AAD2AA8E0000
+9B6F:08001FE020207FF8A1083FF821083FF8444482221FF010101FF010101FF01010
+9B70:204020207C2045FE88887E88528852887E88525052507E200020AA50AA880106
+9B71:200021FE7C20442088207E3C524452447E44528452FC7E080008AA08ABFE0000
+9B72:202020107C10447E88427E425242527E7E42524052407E400040AA80AA800100
+9B73:200023FE7820482090207DFC552455247D24552455247D340128AA20AA200020
+9B74:202020107C1045FE88407E405240527C7E44524452447E440044AA44AAA80110
+9B75:200820287C28442888447E445282537C7E24522452247E240044AA44AA940108
+9B76:201020107C1044FE88927E92529252AA7EAA52CA52827E820082AA82AA8A0084
+9B77:204820447844484091FE7C50545054507C50545054507C520052AA92AA8E0100
+9B78:201020907890489090907CFE548054807C8054F854887C880088AA88AA880108
+9B79:2008201C7CE0442088207E3C52E052207E20523E53E07E200022AA22AA22001E
+9B7A:200020007DFE440488047EF4529452947E94529452F47E940004AA04AA140008
+9B7B:200021FC7924492491247DFC552455247D2455FC55247C200020AA20AA200020
+9B7C:20202020782049FC90207C20542055FE7C20542054407C480084ABFEAA820000
+9B7D:204420447C44444488FE7E44524452447E44527C52447E440044AA44AA7C0044
+9B7E:200021FE7C10441088207E20526852A47F22522252207E200020AA00ABFE0000
+9B7F:202020207850485090887D24561254107DFC540454087C880050AA20AA100010
+9B80:202020107C1044FE88827E84524052447E48525052607E420042AA42AA3E0000
+9B81:205020487848484091FE7C405440547C7CA454A454A87D280110AA28AA440082
+9B82:200020FE7C82449288927E92529252927E9252AA52A67EC60082AA82AAFE0082
+9B83:200021FC7C20442089247EA452A852207FFE522052207E200020AA20AA200020
+9B84:20502050785049FC90547C5455FC55507D5055FE54527C52005AAA94AA900110
+9B85:201020087C08440288227E24522452A87EAC52B253327E200062AAA2AB1E0000
+9B86:088028882EF028842E84F07C08000FE010403FF051101FF011101FF024884244
+9B87:20202020782049FC90207C20542057FE7C7054A854A87D240124AA22AA200020
+9B88:204020407C4044FC88847F0452F452947E94529452947EF40094AA04AA280010
+9B89:200021FC7C44444488447E44529452887F0052FC52847E840084AA84AAFC0084
+9B8A:201020107C2044FE88827E82528252827EFE528252827E820082AA82AAFE0082
+9B8B:201020107C10441088FE7E92529252927E9252FE52927E920092AA92AAFE0082
+9B8C:201020087C0844FE88107E10522052427EFC524852107E200044AAFEAA420000
+9B8D:20102010781049FE91127D14551055FC7D44554455287D280110AA28AA440482
+9B8E:201020107C104410881E7E10521052107EFE528252827E820082AA82AAFE0082
+9B8F:202020207920492091FC7D20562054207C2055FC54207C200020AA20ABFE0000
+9B90:202020207C20444088487E8453FE52827E0052FC52847E840084AA84AAFC0084
+9B91:204020407CFC448489047EF4529452947EF4528452947E880082AA82AA7E0000
+9B92:204420447844488490BE7D84568454A47C94549454847C840084AA84AA940088
+9B93:204020407C40447E88A07EA05320523C7E20522052207E3E0020AA20AA200020
+9B94:200020FE7C80448088807EFC528452847E84528452FC7E800080AA80AAFE0000
+9B95:201020107C10441088FE7E10521052107E7C524452447E440044AA44AA7C0044
+9B96:200020007DFE441088107E205220527C7E4452C453447E440044AA44AA7C0044
+9B97:20402040787C488491887E50542054507C88570654607C100008AAC0AA200010
+9B98:205020547852489290907D9655F856907C90549054907C90008AAA8AAA860082
+9B99:200020EE7C22442288AA7E66522252227E26526A52B27E220022AA22AAAA0044
+9B9A:201020107C1044FE88107E10527C52007E00527C52447E440044AA44AA7C0044
+9B9B:202020207820483C90207C2055FE54007C20542054A87CA40122AA22AAA00040
+9B9C:2008201C79E0490091007DFE550055007D7C554455447D440144AA7CAA440400
+9B9D:111009207FFC0200FFFE08203418CFE610403FF051101FF011101FF024884244
+9B9E:200020FE7C10441088207EFE52AA52AA7EAA52AA52AA7EAA00AAAAA2AA8A0084
+9B9F:2040202078204BFE92027C44544057FE7C88548855087CD00020AA50AA880304
+9BA0:2040204078FC490492087DFE5500557C7D44554455547D480142AA42AA3E0400
+9BA1:205020507850495290D47C58545054587CD4555254507C500092AA92AB12020E
+9BA2:20202120792049FC91207E20542057FE7C7054A854A87D240124AA22AA200020
+9BA3:20002040799E491291127D1255D255127D125512555A7D940110AA10AA100010
+9BA4:7F8408241F24212456241804E4140FE810403FF051101FF011101FF024884244
+9BA5:204020407C78448889507E20525052887F0652F852887E880088AA88AAF80088
+9BA6:200020FE7C82448288BA7E82528252BA7EAA52AA52AA7EBA0082AA82AA8A0084
+9BA7:202020207BFE482091FC7C2455FC55207DFE5422542A7C540050AA88AB040202
+9BA8:20802084789848E090827C82547E54007CFC548454847CFC0084AA84AAFC0084
+9BA9:208420487C0044FC88487E48524852487FFE524852487E480048AA88AA880108
+9BAA:2020202079FE484090407CFC548455847EFC548454847CFC0084AA84AA940088
+9BAB:20402020782049FC90007C88550456027C88548854507C500020AA50AA880104
+9BAC:201020107CFE442888447E82527C52007EFE522052407E7C0004AA04AA280010
+9BAD:201020107C7C441088107E1052FE52007E105210527C7E100010AA10AAFE0000
+9BAE:208420447848480091FE7C20542054FC7C20542055FE7C200020AA20AA200020
+9BAF:202020207850485090887D0456FA54007C0054F854887C880088AA88AAF80088
+9BB0:200020007CFE448288827EBA52AA52AA7EAA52AA52BA7E820082AAFEAA820000
+9BB1:20402040784449F490487C5057FE54407C80558456987CE00082AA82AA7E0000
+9BB2:205020547852489290907DBE569054907C9054A854A87CA800A8AAA4AAA400C2
+9BB3:2040204479F4484890507DFE544054807DFE564054807CFC0004AA04AA280010
+9BB4:204820487848488890FE7D885688549C7C9C54AA54AA7CC80088AA88AA880088
+9BB5:208420447C48440088FC7E84528452847EFC524852487E480048AA8AAA8A0106
+9BB6:200020FC7C24442489FE7E24522452FC7E40524052FC7EC40144AA44AA7C0044
+9BB7:20882048785049FC90247C2455FC55207D2055FE54227C22006AAAA4AB200020
+9BB8:2080208078F8490892107DFC552455247D2455FC54507C500090AA92AB12020E
+9BB9:201020927C52445488107EFE528252827EFE528252827EFE0082AA82AA8A0084
+9BBA:04407FFC01003FF80400FFFE14002FE0D0403FF051101FF011101FF024884244
+9BBB:201020107C20444488FE7E28524452A27E3C524452447EA80010AA28AA440082
+9BBC:200020FC7804487C90047CFC540055FE7D0254FC54447C440028AA10AA680186
+9BBD:201020107C28442888447EBA521052107EFE521052587E540092AB12AA500020
+9BBE:2004201E79E0482291127C94548054207DFE544454847DC80030AA28AAC40302
+9BBF:200023FE7920492891287DE8552855287D2855E855287D2A013AABEAAA260020
+9BC0:200C21F07820484490887DF0542054447DFE542254207CA80124AA22AAA00040
+9BC1:200021FE7820482091FC7D24552455FC7D24552455FC7D2000A0AA40AAB0030E
+9BC2:200021FE7C28442888FE7EAA52AA52AA7EC6528252827EFE0082AA82AAFE0082
+9BC3:200021FE7820482090FC7C44544455FE7C00540054FC7C840084AA84AAFC0084
+9BC4:202820247824482091FE7C20552054B27CB4546854A87D240222AA20AAA00040
+9BC5:2004200E7BB8488890887D28552E57A87CA856A856A87D3E0100AA80AA7E0000
+9BC6:201420127CFE441088107EFE529252927EFE529252927EFE0092AA92AA920086
+9BC7:2020201079FE490292047CF8540054007DFE545054507C500092AA92AB0E0200
+9BC8:108011F8128820702B8E688068F8A9102BFC2D2429FC292429FC20002154222A
+9BC9:200021FC7924492491FC7D24552455FC7C20542055FC7C200020AA20ABFE0000
+9BCA:20401248444420140860738028000FE010403FF051101FF011101FF024884244
+9BCB:2008210878884808912C7CAA54AA54487C48548A558A7C840084AA88AA900060
+9BCC:201020507C50447C88507E90521052FE7E005200527C7E440044AA44AA7C0044
+9BCD:2020201079FE482090487C8455FE54027CA854A854A87CA800A8AAAAAB2A0206
+9BCE:201020147812481091FC7D10551055D47D54555455547D48014AAA9AAA260442
+9BCF:2002203278C2484A904A7C4A55FA544A7CCA54EA555A7D420242AA42AA4A0044
+9BD0:201020107C7C441088107E1052FE52107E105250525C7E500070AA90AA8E0100
+9BD1:20C220347818486491827C2055FE54507C9055FE56927C92009AAA94AA100010
+9BD2:200020FC7C04446888107EFE529252927EFE529252927EFE0092AA92AA920086
+9BD3:2020204078F8488890F87C8854F8548A7C8C55F854187C280048AA88AB280010
+9BD4:200020927C92452489247E92529252007EFE529252927EFE0092AA92AAFE0082
+9BD5:2088208879FC488890887CF8548854887CF8548854887DFE0000AA50AA880104
+9BD6:2020202079FE482090FC7C2055FE54007CFC548454FC7C8400FCAA84AA940088
+9BD7:04407FFC01003FF80400FFFE14102FE8D0463FF051101FF011101FF024884244
+9BD8:201C21E07820482093FE7CA8552456427C4057FE54887D0800D0AA30AA480184
+9BD9:2020201079FE480090FC7C8454FC54007CFC540854107DFE0010AA10AA500020
+9BDA:201C20E0782049FE90707CA8552456227CF8541054207DFE0020AA20AAA00040
+9BDB:200020FE7C92449288BA7E9252FE52827EBA52AA52AA7EBA0082AA82AA8A0104
+9BDC:202020107CFE440088447E2853FE52207E2053FE52447EC40028AA18AA640182
+9BDD:200020FE7C82449288927EFE529252927EBA52AA52AA7EBA0082AA82AAFE0082
+9BDE:200020FC7804487C90047CFC540055FE7D22542054FC7CA400A4AAB4AAA80020
+9BDF:201020107CFE441088107EFE529252FE7E9252FE52107E380054AA92AA100010
+9BE0:201020107C1044FE88107E54525452547EBA521052387E540092AA10AA100010
+9BE1:2050205078504BDE90507C50545055DC7C50545054507C5003DEAA50AA500050
+9BE2:200020207CCE448288827EEE528252827EFE522852287E280048AA4AAA8A0106
+9BE3:200020FC7C84448488FC7E84528452FC7E4052FE532A7E4A0092AB22AA4A0084
+9BE4:200020FC7884488490FC7C84548454FC7C00549054927CF40098AA92AAD2008E
+9BE5:2020202078FC482090207DFE544854847D22542054FC7C200020AA20ABFE0000
+9BE6:2088208878E8492C912A7EA8544854A07D1E560054FC7C840084AA84AAFC0084
+9BE7:207C20447C44447C88447E44527C52007EFE528252827EFE0082AA82AAFE0082
+9BE8:204020207DFE440088007EF8528852887E8852F852207EA80124AA22AAA00040
+9BE9:201020107C28444488827F7C520052FE7EAA52AA52FE7EAA00AAAAAAAA820086
+9BEA:2020202078FC482090207DFE544854847D22547854887D480050AA20AA50018C
+9BEB:200023E0795C495491547DD4555455547DD4555455487D6803C8AA54AA540062
+9BEC:0640387C08947E241C442A9448080FE010403FF051101FF011101FF024884244
+9BED:200020FC7C08441088FE7E10521052507E2052FE52AA7EAA00AAAAAAABFE0000
+9BEE:202020107CFE448288007E7C520052007EFE521052107E540052AA92AA500020
+9BEF:20822082728293EA248AF88AAFFAA88AFBEAAAAAAAAAFAAA02A2AAE2A88A0084
+9BF0:201020107C28444488A27F1052FC52047E08522052107E0400A2AAA2AAAA0118
+9BF1:201020107C1E441088FE7E92529852F07E92528E52807EB800A8AAAAAB4A0286
+9BF2:2088204878084BF491147D22550055E87D24552455207D300128AA24AAA40440
+9BF3:2040202073FE9200221CFAF0AA90AA90FAFEAA90AA90FA9002AAAACAACA60812
+9BF4:200021FC7804483491C47C44544455F47D54555455F47C440054AA76AB960002
+9BF5:20402048788449FE90207DFE548855247E42558854107C2200C4AA18AA600180
+9BF6:200020FE7C92441088FE7E10527C52547E7C5254527C7E1000FEAA10AA100010
+9BF7:2000207C7C44447C88447E7C520053FE7E105210525E7E500050AAB0AA9E0100
+9BF8:2040205C7C44448488BE7E905390529E7EA8528852BE7E880088AA94AA9400A2
+9BF9:200021FC790449FC91047DFC542055207DFE562054207DFC0020AA20ABFE0000
+9BFA:2020202479F4482890287DFE542054407CFC558456847CFC0084AA84AAFC0084
+9BFB:2082208273E29082208AFBEAAAAAAAAAFBEAA88AA9CAFAAA04A2A882A88A0084
+9BFC:202820927CAA448288FE7E28524452A27E3C524452447EA80010AA28AA440082
+9BFD:200020EE7CAA44AA88AA7EEA52AA52AA7EEA528A52CA7EAE00D8AA88AA080008
+9BFE:2040207E784848BE90AA7DAA56BE54AA7CAA54BE54C87CA80090AA98AAA400C2
+9BFF:2020201079FE490291027DFE550055007DFE55AA56AA7CFE00AAAAAAAAAA0086
+9C00:201E23E07844492490887DFC544054407DFE548054FC7D440128AA10AA680186
+9C01:201020207CFE448288FE7E8252FE52107E1252D452587E540094AA92AB500020
+9C02:200221E27922492A91EA7D2A552A55EA7D2A552A55EA7C0200C2AAA2AB2A0204
+9C03:200020FC78A448A490FC7CA454A454FC7C0055FE54907C940088AAA8AAC40082
+9C04:200C200A700893FE2208FBF8AA4AAA4AFBEAAAACAAACFA4C02AAAB0AAA160422
+9C05:2000207C7C544454887C7E545254527C7E1052FE52927E9600BEAA82AA8A0084
+9C06:2020202079FE482090FC7C4055FE54887D0456FA54887C8800F8AA88AA8800F8
+9C07:200020FC7848483091FE7C52549455107E30542055FE7C7000A8AB24AA220020
+9C08:201420547C5444FE88547E54525C52407E7E521052FE7E100038AA54AA920010
+9C09:201020207C7C4444887C7E44527C52007EFE521052107E7C0010AA10AAFE0000
+9C0A:202020207BFE482091FC7D2455AC55747D2455FC54207C7000A8AB24AA220020
+9C0B:200021FE7900497E91427D7E5542557E7D1055FE55247D640118AB24AB4201FE
+9C0C:204420247C2844FE88287E2852FE52AA7EAA52C652827EFE0082AA82AAFE0082
+9C0D:200820687988488890AA7CAC55E854A87C8855C856A87C880094AA94AA9400A2
+9C0E:20102010783C4B9490FE7C94553C55107FBC549054FE7E900190AAC0AABE0100
+9C0F:200020FE7C00447C88447E44527C52007EFE529252927EFE0092AA92AAFE0082
+9C10:200021DC7954495491DC7C0055FC54007DFE548054FC7C040004AA04AA280010
+9C11:200020FC788448FC90847CFC540055FE7C8054FE552A7E4A0092AB22AA540088
+9C12:204020407CFE448089FC7E8452FC52847EFC5240527C7EC40128AA10AA680186
+9C13:200021FC7924492491FC7D24552455FC7C20541054547D420142AB4AAA380000
+9C14:2008200C700A93FE2208FA08AAE8AA0AFA0AAAECAAACFAA802EAAA1AAA260442
+9C15:200021DC7944494491447DDC550055007DDC551455147DD40108AB08AB140122
+9C16:2020202079FE484090FE7D1056FE54007CFE548254FE7C8200FEAA82AA8A0084
+9C17:2080209E78924BF290927C9E549255D27D52555E55527D5201D2AA22AA2A0044
+9C18:2040202079FE490292047DFC544054887DFC542454207DFC0020AA20ABFE0000
+9C19:2084208479FE488490A47C2055FE54407C8054FC55847E840084AA84AAFC0084
+9C1A:2020201079FE490292047CFC540054FC7C8454FC54847CFC0084AA00AAFE0000
+9C1B:200020F87888488890F87C88548854F87C0055FC55547D540154AB54ABFE0000
+9C1C:20882050780049FE90507DFC545457FE7C5455FC54507CD80154AA52AA500050
+9C1D:202020107CFE4400887C7E44527C52007EFE528252BA7EAA00BAAA82AA8A0084
+9C1E:202020407CFC448488847EFC528052FE7E8052FE52027EAA00AAAA02AA140008
+9C1F:202020107CFE440088447E2852FE52A27E1052FE52207E3C0024AA44AA540088
+9C20:200021FC78A4488890507C2054D857267C2055FC55247D2401FCAA22ABFE0002
+9C21:202020DE7C8A44CA88AA7ED252A652007EFE529252927EFE0092AA92AAFE0082
+9C22:200020FE789048FC90907CFC549054907CFE540254AA7CAA00AAAA82AA140008
+9C23:2008200879C8497E91487D48557E55C47D44557E55447D6401D4AA04AA140008
+9C24:2100227E7388928822BEFAAAABAAAA2AFA2AABAAAAAAFAAE0288AB88AA880008
+9C25:200020FE7CAA44AA88AA7EFE521052547E52529252107E540052AA92AA100010
+9C26:2084204478484BFE90847C845508554A7E52579C54847D080108AA52ABDE0042
+9C27:012478A849FC48404BFE79084A844CFA49107BFC4D2449FC492449FC48009954
+9C28:200021F8790849F891087DF8540054007DDC544455547CCC0154AA44AA5400C8
+9C29:2004201E79E0480291227C9454FE55107C1055FE54107C920092AA92AAFE0002
+9C2A:201020107C7E441088107EFE522052427EFE520052FE7EAA00AAAAAAABFE0000
+9C2B:2040202079FE490290507C88552454507C88550456FA7C880088AA88AAF80088
+9C2C:2020203C782049FE91227D3855E4551C7D20551055FE7D440128AA10AA2804C6
+9C2D:2020202478F4482891FE7C20547854C27D3E560054FC7C8400FCAA84AAFC0084
+9C2E:200020F878A848A890D87C8854F854007C0055FC55547D540154AB54ABFE0000
+9C2F:200021DC7844484491DC7D10551055DC7C44555454CC7CCC0154AA44AA5400C8
+9C30:220821087908483E93AA7CAA54BE552A7DAA576A553E7D2A0108AB08AB080108
+9C31:201020107AFE4910917C7C54547C57547D7C551055FE7D100110AA90AA7E0000
+9C32:08207E20087EFEC410281E102A284FE690403FF051101FF011101FF024884244
+9C33:2148214873E8914821DEF88AABEAAAAAFAAAABEAA88AFBEA0092A892A8AA00C4
+9C34:11101550255047D0903E17A422546394A49427D42D5427C8254827D420142AA2
+9C35:20203F20403EBE482AA8FF284A107FE810463FF051101FF011101FF024884244
+9C36:2080208879EE492A92AA7D445484557A7E00540055FE7C2000A8AB24AAA20040
+9C37:2110211E712292542208FE94AAE2AA88FA88AABEAA88FAAC022AAA4AAA280210
+9C38:200023FE7200927C2244FA44AA7CAA00FAEEAAAAAAAAFAAA02EEAA00ABFE0000
+9C39:200021EE794A49EA912A7DE45544554A7DF0540054107CFE0010AA10ABFE0000
+9C3A:201020207C4444FE88447EAA52EE52107E28525452AA7E500024AA48AA100060
+9C3B:207C20447C7C4444887C7E0052FE52AA7EFE520052FC7E440028AA10AA680186
+9C3C:200021DE7842495290CA7D52544254207CFC548454847CFC0084AA84AAFC0084
+9C3D:2050205079FE485091FC7D5455FC55547DFC540054F87C8800F8AA88AAF80088
+9C3E:200023FE785049FC91547D5455FC54007DFC540057FE7C2000A8AB24AAA20040
+9C3F:201021FE781048FC90107DFE540054FC7C8454FC54847CFC0084AAFCAA480084
+9C40:7DFC44207D2045FE7C50485254926FEE10403FF051101FF011101FF024884244
+9C41:2000213E78884890902A7C4A571C552C7D4A551A552A7D480128AA90AA7E0000
+9C42:20482148795E496A91547DC8545054647FC4557E55447D640154AB44AA540448
+9C43:2084204879FE481090FC7C2055FE54407C7C54A455247CFC0044AA44ABFE0000
+9C44:202023FE782049FC91247DFC552455FC7C2255FE54087DFE0108AA88AA280010
+9C45:201021FE7910497C91147DFE5514557C7D10557C55547D7C0154AA7CAA54044C
+9C46:201020FE7C44442888FE7E00527C52447E7C5244527C7E1000FEAA10AA100010
+9C47:2020201079FE4910917C7D1455FE55147D7C551055927D540138AA54AA920430
+9C48:200021FC78204BFE92227DAC542055AC7C0055FC54047DFC0004AA04ABFC0004
+9C49:49202A3E7F4849485DA86B1049284FE610403FF051101FF011101FF024884244
+9C4A:20FC2028781049FE90527C94555054207CFE54AA54C67CBA00AAAABAAA820086
+9C4B:2020203C782049FE91227D3855E4551C7D00552855AA7D6C0128AA28AAFE0000
+9C4C:208020F0791049FC93247D2455FC54407CA4555854987D340054AA92AB500020
+9C4D:201221D478484A8A91047E0255DC54547C6255C0551E7DC20054AA48AB5400A2
+9C4E:201821E078404BFE90887D74565254707C0055FC55047D740154AB74AB04010C
+9C4F:200020FE7C2844FE88AA7EFE5200527C7E44527C52447E7C0010AAFEAA100010
+9C50:202021FC702493FE2024F9FCA820AAAAFBAEAA22ABFEFA2203AEAAAAAAAA0422
+9C51:2048204878FC484890487DFE542054FC7CA454FC54A47CFC0000AA48AA840102
+9C52:2088205079FE485091FC7D54559C55047DFC550455FC7C0801FEAA88AA480018
+9C53:200021DC7954495491DC7C0055FC55247DFC552455FC7C2003FEAA20AA200020
+9C54:2044202879FE481090FE7C1055FE54927C5455FE54007CFE0082AA82AAFE0082
+9C55:201C21E078A4486891FE7CA8552456027CFC54A454A47CFC00A4AAA4AAFC0084
+9C56:200023FE7200931422A4FBF6AA4AAA42FB50AB54ABF4FA44024AAA8AAC920920
+9C57:201020927854481091FE7C54549255107C8454EE55247CB4005EAA44AA840104
+9C58:200021FE780249FE90027DFE540055DE7C9257DE54047DFE0084AA44AA540008
+9C59:2020202078FC482091FE7C8855DC54887CC855BC54007DFE0050AA50AA94010C
+9C5A:201020107CFE4410887C7E00527C52447E7C522852FE7E00007CAA44AA7C0044
+9C5B:204420247C2844FE88927ED652BA52927EFE5200527C7E44007CAA44AA7C0044
+9C5C:2280224E74EA95AA29AAFEEAAAACACAAFDEAAF8AAA8AFAAA04ACACE8A8A80008
+9C5D:202021FC7820488893FE7C8855FC55047DFC550455FC7D0401FCAA88AB040202
+9C5E:200021FC7954495491FC7C0057FE54007DFC550455FC7C620094AB88AAA400C2
+9C5F:0A803138228839382288FFFE88020FE010403FF051101FF011101FF024884244
+9C60:202020507888497492027DFC552455AC7D2455FC54007CF80088AAF8AA8800F8
+9C61:2008200C738A92FE2288FBA8AAA8AAAAFBFAAAAAAAACFBAC002AAAAAAC560022
+9C62:20F82088788848F890007DDC555455547DDC542057FE7C7000A8AB24AA220020
+9C63:201021FE780049FE91027D7A554A55FE7C0054FC54847CFC0084AAFCAA0001FE
+9C64:2014201273FE921022F0FA14AAF4AAB8FAEAAA16AC42F82402A2AA8AAC780000
+9C65:2020213879204BFE90107C1455FE55107DF0555455547DD40168AA4AAA960122
+9C66:200021FC7954495491DC7C5055DC55547D5455DC55547D5401DCAB50AA52003E
+9C67:205021FC795449FC91547DFC540055FC7C0055FC55047DFC0088AA50ABFE0000
+9C68:212420A87BFE4A8A90F87D0C55F055027CFE540055FC7D0401FCAB04ABFC0104
+9C69:200021FC78204BFE92227DAC542055AC7C0055FC55247D2401FCAB24AB2401FC
+9C6A:21FC210479FC490491FC7C2255FC54287FFE544055FC7E8400FCAA84AAFC0084
+9C6B:200E21F078A2485491FE7D22541455527D4A563854407C7C0084AB48AA3001CE
+9C6C:200021FC78204BFE92227DAC542055AC7C0057FE54207DFC0154AB54AB54010C
+9C6D:2040202073FE90882052FFACAAAAAAA8FDACA800A904F9FC0104A9FCA9040204
+9C6E:20A0212C7934492491AC7D34555455DC7D54555457FE7C000048AA44AA820102
+9C6F:204421FE7854484890FE7D9054FE54907CFE549054FE7C8001FEAA44AA3801C6
+9C70:200023FE7A524A5293FE7C2455FC54287FFE542054FC7D8402FCAA84AAFC0084
+9C71:200021FE792849FE91287D7C5554557C7D54557C55107DFE0192AABAAA8A0484
+9C72:212422487124900023FCFA94AA64AA94FBFCAA48AB68FA48036AAA4AAA460362
+9C73:21242174725892DA23FEF954AADAABFEF8A2A820ABFEF87000A8A924AA220020
+9C74:204421FE7C44440088FE7EAA52AA52FE7E1452FE52907ED200ACAAAAAA960122
+9C75:2110211071DE92A82454F812ABFEAA10FAF4AA14AAF4FAA802AAAAFAAA160422
+9C76:208823FE782049FC90407FFE548855247EFA548854F87C8800FAAA94AAA800C4
+9C77:200023FE702093AE22AAFAAAABAEA820FBFEA820ABAEFAAA02AAABAEA82003FE
+9C78:2020203E782049FE91227DF85522557E7D54557C55547D7C0100AAFEAAAA05FE
+9C79:208823FE7888480091DC7D5455DC54887DFE569054FC7C9000FCAA90AAFE0080
+9C7A:20EE20007CEE44AA88EE7EAA521052FE7EA852FE52AA7EFE00AAAABCAAAA0136
+9C7B:0FE010403FF051101FF011101FF024A85E3424507EFC2A543E7C2A54BE7C95AA
+9C7C:040004000FE0102020407FF8A10821083FF8210821083FF800000000FFFE0000
+9C7D:200020007DFC444488447C44544454447C44544454447C8400841D04E1284210
+9C7E:100010001EF8220824087E08AA082AF83E882A802A803E8000820E82707E2000
+9C7F:204020507C48444888407DFE545054507C50545054907C9000921D12E10E4200
+9C80:202020207C2045FE88207D24552455247D2455FC54247C2000221C22E01E4000
+9C81:08001FE020207FF8A1083FF821083FF80000FFFE00001FF010101FF010101FF0
+9C82:102010101E1023FE24407E40AA402A7C3E442A442A443E4400840E8471282210
+9C83:200020007DFC452489247D24552455247DFC550055007D0001021D02E0FE4000
+9C84:200020007DFE440888087DE8552855287D28552855E87D2800081C08E0284010
+9C85:205020487C48444089FE7C405440547C7CA454A454A87D2801101E28E0444082
+9C86:200020007DFC442088207D2454A454A87C2057FE54207C2000201C20E0204020
+9C87:101010101E102210241E7E10AA102A103EFC2A842A843E8400840E8470FC2084
+9C88:101010101E1E221024107EFEAA822A823E822AFE2A823E8000800F0071002200
+9C89:202020207C20442089FC7D24552455247D2455FC55247D2401241D24E1FC4104
+9C8A:104010401E40227E24A07EA0AB202A3E3E202A202A203E3E00200E2070202020
+9C8B:204420447C44448488BE7D84568454A47C94549454847C8400841C84E0944088
+9C8C:101010101E2022FC24847E84AA842A843EFC2A842A843E8400840E8470FC2084
+9C8D:204020407CFC448489047EF4549454947CF4548454947C8800821C82E07E4000
+9C8E:2208111000207FFC440484080FC010403FF051101FF011101FF00000FFFE0000
+9C8F:201020107C1045FE89127D14551055FC7D44554455287D2801101E28E2444482
+9C90:102010201E20224024487E84ABFE2A823E002AFC2A843E8400840E8470FC2084
+9C91:202020207DFC442088207C2057FE54007C20542055FC7C2000201C20E3FE4000
+9C92:202020207C2047FE88207C2055FC54007C0055FC55047D0401041D04E1FC4104
+9C93:204020447DF4444888507DFE544054807DFE564054807CFC00041C04E0284010
+9C94:202020207DFE444088407CFC548455847EFC548454847CFC00841C84E0944088
+9C95:200021FE7C20442088407DFC555455547D54555455547D5401541D54E104410C
+9C96:200021FC7D04450489747D04550455747D54555455547D7401041D04E1144108
+9C97:400243E27A228A2A12AAFAAAAAAAAAAAFAAAAAAAAAAAF88201421922E20A4404
+9C98:2008201C7DE0450089007DFE550055007D7C554455447D4401441E7CE2444400
+9C99:202020207C50448889047E0254F854007C0057FE54207C4000881D04E3FE4102
+9C9A:204020207DFE448888507C20545054887D06548854887C8800881D08E1084208
+9C9B:204020207C2045FE88007C88550456027C88548854507C5000201C50E0884306
+9C9C:108210441E2822FE24107E10AA102A7C3E102A102A103EFE00100E1070102010
+9C9D:04407FFC01003FF80400FFFE14002FC0D0403FF051101FF011101FF00000FFFE
+9C9E:111009207FFC0200FFFE08203418CFC610403FF051101FF011101FF00000FFFE
+9C9F:200021FC7C04440488FC7C04540455FC7C08540855FE7C8800481C48E0084018
+9CA0:200021FE7C20442089FC7D24552455FC7D24552455FC7D2000A01C40E0B0430E
+9CA1:400043FE7800880013DEFA52AA52AA52FB5AAAD6AA52FA5202521A52E25242D6
+9CA2:401042107910897E1020F828AF48A97EF908A908A9FEF90801081A88E47E4000
+9CA3:2040217E7D52455289547D48555454627C10541054FE7C1000101C10E1FE4000
+9CA4:200021FC7D24452489FC7D24552455FC7C20542055FC7C2000201C20E3FE4000
+9CA5:400440047BC48A44127EFA44AA44ABE4FA54AA54AA44FA4403C41A44E0144008
+9CA6:204020407CF8448889507C2054D857267C2055FC54207D2801241E24E0A04040
+9CA7:200C21F07C20444488887DF0542054447DFE542254207CA801241E22E0A04040
+9CA8:20401248444420140860738028000FC010403FF051101FF011101FF00000FFFE
+9CA9:202020107DFE45028A047CF8540054007DFE545054507C5000921C92E10E4200
+9CAA:100010FC1E24222425FE7E24AA242AFC3E402A402AFC3EC401440E44707C2044
+9CAB:400043DE7A528A521252FBD2AA52AA52FA52ABD2AA1AFA9402501AB0E3104010
+9CAC:200021F87C0844D088207DFC552455247DFC552455247DFC01241D24E124410C
+9CAD:202020207DFE442088FC7C2055FE54007CFC548454FC7C8400FC1C84E0944088
+9CAE:202020207CFC442088207DFE544854847D22547854887D4800501C20E050418C
+9CAF:208820887DFC448888887CF8548854887CF8548854887DFE00001C88E1044202
+9CB0:200023E07D5C455489547DD4555455547DD4555455487D6803C81C54E0544062
+9CB1:205020507C5047DE88507C50545055DC7C50545054507C5003DE1C50E0504050
+9CB2:200021FC7D04450489FC7D04550455FC7C00551255D47D1801101D52E192410E
+9CB3:20FC20847C8444FC88847C8454FC54007DFE550255027DFE01021D02E1FE4102
+9CB4:200021FC7D04452489247DFC552455247D74555455547D7401041D04E1FC4104
+9CB5:200020407D9C450489047DDC550455047DFC545054507C5000901C92E112420E
+9CB6:40204020785088881144FA22A9F8A808F850A820A8A4FA82028A1A8AE4784000
+9CB7:200021FC7D24452489747D2455FC55047D74555455547D7401041E04E2144408
+9CB8:204020207DFE440088007CF8548854887C8854F854207CA801241E22E0A04040
+9CB9:204020487C8445FE88207FFE548855247E42558854107C6201841C18E0604380
+9CBA:200021FC7C04443489C47C44544455F47D54555455F47C4400541C76E1964002
+9CBB:209220927D24464889247C92549254007DFE552255227DFE01221D22E1FE4102
+9CBC:202021FC7C2044888BFE7C88540055FC7D04552455247D2401241C50E0884304
+9CBD:4048414879488BFE1148F948A978A900F9FEA820ABFEF87000A81924E6224020
+9CBE:100010FE1E00227C24447E44AA7C2A003EFE2A922A923EFE00920E9270FE2082
+9CBF:202021247CA8442089FE7D02540054F87C00540055FE7C2000401C88E1FC4084
+9CC0:100010FC1E84228424FC7E84AA842AFC3E002BFE2A203EA000BC0EA07160223E
+9CC1:200020F87C88448888F87C88548854F87C0055FC55547D5401541D54E3FE4000
+9CC2:200021FC7D24452489FC7D24552455FC7C0057FE55207D2201141D48E1844102
+9CC3:200021FC7D24452489FC7D24552455FC7C20541054547D4201421D4AE2384000
+9CC4:200021DC7D54455489DC7C0055FC54007DFE548054FC7C0400041C04E0284010
+9CC5:400840C87B088908112AF92AABACA948F908AB88AD54F91401141924E1244142
+9CC6:204020407CFE448089FC7E8454FC54847CFC5440547C7CC401281C10E0684186
+9CC7:202020407DFC450489FC7D0455FC54007FFE542054207DFC00201C20E3FE4000
+9CC8:204020807DFC450489FC7D0455FC54207C3257B454A87D2801241E24E4A24040
+9CC9:209020907C9E46A289D47C88549454A47DFE568454A47C9400941C84E0944088
+9CCA:202020107DFE450289027DFE550055007DFE55AA56AA7CFE00AA1CAAE0AA4086
+9CCB:200021FC7CA4448888507C2054D857267C2055FC55247D2401FC1C22E3FE4002
+9CCC:08207E20087EFEC410281E1022284FC690403FF051101FF011101FF00000FFFE
+9CCD:204020447DF844508BFE7C4054F855827E7E540055FC7D0401FC1D04E1FC4104
+9CCE:200020FC7C8444FC88847CFC540054007DDC544455547CCC01541C44E1544088
+9CCF:200021FC7D54455489547DFC542054A87CA4552454207CA800A41D24E0204020
+9CD0:2004201E7DE0440289227C9454FE55107C1055FE54107C9200921C92E0FE4002
+9CD1:202020107DFE448488487DFE550256247C1055FE54407C7C00441C84E0944108
+9CD2:208820507C0045FE88507DFC545457FE7C5455FC54507CD801541E52E0504050
+9CD3:414841487BE8894811DEF88AABEAAAAAFAAAABEAA88AFBEA00921892E0AA40C4
+9CD4:200023FE7C5045FC89547D5455FC54007DFC540057FE7C2000A81D24E2A24040
+9CD5:200021FC7C2047FE8A227DAC542055AC7C0055FC54047DFC00041C04E1FC4004
+9CD6:49202A3E7F4849485DA86B1049284FC610403FF051101FF011101FF00000FFFE
+9CD7:400041F8790889F81108F9F8A800ABFCFA94ABFCA800F9F800901860E1984606
+9CD8:20203F20407EBEA82A28FF104A287FC610403FF051101FF011101FF00000FFFE
+9CD9:201021FE7D10457C89147DFE5514557C7D10557C55547D7C01541E7CE254444C
+9CDA:400443E47A248A2413EEFA04AAE4AA04FA0CABF4AA44FA6405541D44EA5440C8
+9CDB:200021DE7C42455288CA7D52544254207CFC548454847CFC00841C84E0FC4084
+9CDC:400043FE7A008B1412A4FBF6AA4AAA42FB50AB54ABF4FA44024A1A8AE4924920
+9CDD:408840507BFE882011FCF820ABFEA924F8A8ABFEA800F9FC01041904E1FC4104
+9CDE:4020412478A88BFE10A8F924AA22A904F904A9DEAA44FD54009E1904E2044404
+9CDF:208820507DFE445089FC7D54559C55047DFC550455FC7C0801FE1C88E0484018
+9CE0:208823FE7CA8449089FE7F2055FC55207DFC552055FE7D0003FC1C88E070438E
+9CE1:401440127BFE8A1012F0FA14AAF4AAB8FAEAAA16AC42F82402A21A8AE4784000
+9CE2:205021FC7D5445FC89547DFC540055FC7C0055FC55047DFC00881C50E3FE4000
+9CE3:201021FE7C0045FE89027D7A554A55FE7C0054FC54847CFC00841CFCE00041FE
+9CE4:210821087DEE469488427C1055FE55027CF8548854F87C8000FC1C84E0FC4084
+9CE5:020004001FF010101FF010101FF010001FFC10001FFC09242494249440280010
+9CE6:100020007F3E41027F0441047F0840087F9040107FA000A2AAA2AAA2811E0600
+9CE7:08003FE020203FE020203FE020003FF820003FF8524889281FD810422042C03E
+9CE8:101020107F1041107F7E41127F1240127F9240127F920092AAA2AAA2814A0684
+9CE9:2040208021FC2104F9FC290429FC290029FE29002BFE2C024AAA42AA8202000C
+9CEA:2040208021FC210421FC290425FC250025FE210021FE200222AA22AA2202200C
+9CEB:00003FFE2100220027F0241027F0241027F0240027FC240027FC40044AA48AAC
+9CEC:04001FF010101FF010101FF010001FFC10001FFC00040F94088808821082607E
+9CED:00400080F9FC290429FC290429FC290029FE290029FE28024AAA4AAA9A02000C
+9CEE:0040008001FCFD0405FC050449FC290011FE110029FE240246AA82AA0202000C
+9CEF:00007FF844085FC850485FC850485FC850085FE850085FEA402AAAAAAAA60042
+9CF0:0040008081FC410421FC210411FC110029FE290025FE240242AA42AA8202000C
+9CF1:00407C8011FC110411FC110411FCFF0011FE110011FE100212AA12AA1202100C
+9CF2:004000803DFC250425FC25043DFC250021FE210021FE200222AA42AA4202800C
+9CF3:3FF820082FE822082FE828282FE828282FE828082FF828082FFA401A55568032
+9CF4:0040008079FC490449FC490449FC490049FE490049FE78024AAA02AA0202000C
+9CF5:0040F88049FC490449FC490449FCF90049FE490049FE48024AAA4AAA4602420C
+9CF6:04200210013EFFC002221FFA10161FF010101FF010001FFC10001FFC2A44452C
+9CF7:1040108011FCFF0411FC1104FDFC050005FE490029FE10022AAA46AA8202000C
+9CF8:01007FFC40047FFC42005FF050105FF050105FF050005FFC50005FFCAA44452C
+9CF9:1040108029FC290445FCA50411FC110001FEFD0005FE08020AAA12AA1202000C
+9CFA:1040108011FC7D0411FC110411FCFD0011FE110011FE280226AA42AA8202000C
+9CFB:0020284024FC248442FC428480FC7C8024FE248024FE240244AA44AA9502080C
+9CFC:0040208011FC0104FDFC090409FC490029FE110011FE28022AAA4AAA8202000C
+9CFD:00407C8029FC290429FC290429FCFF0029FE290029FE28022AAA2AAA4A02880C
+9CFE:0040FE8011FC11047DFC550455FC550055FE550055FE5C0212AA12AA1202100C
+9CFF:004000807DFC110411FC11047DFC110011FE110011FE1C02E2AA42AA0202000C
+9D00:0040FC8011FC110421FC310469FC6500A5FE210021FE200222AA22AA2202200C
+9D01:00400C8071FC110411FC1104FDFC110011FE110029FE280242AA42AA8202000C
+9D02:2040208021FCF90429FC290429FC2900FDFE210021FE200232AA4AAA4A02800C
+9D03:101020107F1041107F7C41147F1440147F94407E7F900090AAA8AAA881440682
+9D04:00200040FEFCA884A8FCA884A8FCA880AAFEAA80A6FEC00282AAFAAA0202000C
+9D05:0040788049FC490469FC590449FCFD0049FE490049FE48024AAA4AAA4A02980C
+9D06:1040108011FC7D0455FC910411FC290029FE290029FE2C024AAA42AA8202000C
+9D07:4040488051FC610445FC45043DFC110011FE1100FDFE100212AA12AA1202100C
+9D08:00007FFE444045FC490449FC590469FC490049FE490049FE48024AAA8AAA0804
+9D09:0040FC8009FC490449FC490489FCFF0019FE190029FE28024AAA8AAA2A02100C
+9D0A:00400080FDFC110411FC110451FC5D0051FE510051FE50025EAAF2AA0202000C
+9D0B:2020104000FCFE8420FC20843CFC248024FE248024FE240244AA54AA8902000C
+9D0C:00003FF801007FFC04401830E20E1FF010101FF010101FFC10001FFC0004492C
+9D0D:020001007FFC082007C01830E20E1FF010101FF010101FFC10001FFC0004492C
+9D0E:0040FC8081FC8904C9FCA90491FC9100A9FEA900C9FE800282AAFEAA0202000C
+9D0F:105020547C5244927C90459E7DF042907E9040907E900290AA8AAA8A82860C82
+9D10:10007E7812482678C2001FF010101FF010101FF010001FFC10001FFC2A44452C
+9D11:08007E7812480C3032CEDFF010101FF010101FF010001FFC10001FFC2A44452C
+9D12:1040108029FC250443FC910409FC0100FDFE050009FE500222AA12AA1202000C
+9D13:2020104014FC048424FC2484AAFCAA80A8FE308032FE220222AA5EAA8102000C
+9D14:08401C80E1FC010421FC1104FDFC050009FE090011FE200242AAA2AA1E02000C
+9D15:101020087F08417E7F4241427F2040247FA840307FA000A2AAA2AAA2811E0600
+9D16:00207E4042FC42847EFC488448FC48807EFE488048FE48024AAA4AAA6702420C
+9D17:2040108011FCFD0401FC090489FC890049FE490051FE50021EAAE2AA4202000C
+9D18:1040108021FC4904FDFC050429FC290029FEFD0029FE28022AAA4AAA4A02880C
+9D19:2040208021FC7D0451FC910411FC1100FDFE110011FE280226AA42AA8202000C
+9D1A:100020007DFE44047C0444F47C9440947E9440947EF40294AA04AA0482140C08
+9D1B:20F83E88449AA882127E3FF0D0101FF010101FF010001FFC10001FFC2A44452C
+9D1C:08442F7828422F3EF2001FF010101FF010101FF010001FFC10001FFC2A44452C
+9D1D:2020204020FC7E8442FC82847AFC4A804AFE4A807AFE4A0202AA02AA1502080C
+9D1E:0040788049FC490449FC790401FCFD0021FE410079FE08020AAA0AAA5202200C
+9D1F:04400E80F1FC910491FC9104FDFC910091FE910091FE88028AAAC6AA9202080C
+9D20:004000807DFC450445FC7D0445FC45007DFE010001FE1C02E2AA42AA0202000C
+9D21:0040788049FC490449FC790449FC490079FE490049FE48024EAAF2AA0202000C
+9D22:04082410243C44245FBC94A4E4BC24A044BE44A094BEF48218AA08AA1282210C
+9D23:1020104010FC1084FEFC108410FC10807CFE448044FE440244AA7CAA4502000C
+9D24:102020207F3C41447F6841A87F1040287FC440827FA00090AA88AAA081100608
+9D25:102020107C1044FE7C8245047C0040287E2840287E280228AA44AA4482440C82
+9D26:01001FF01110FFFE02801C70E20E1FF010101FF010101FFC10001FFC0004492C
+9D27:2020104010FCFE8482FC848400FC788048FE488048FE4A024EAA4AAA8202000C
+9D28:00407C8055FC550455FC7D0455FC550055FE7D0055FE100212AA12AA1202100C
+9D29:1040108051FC51047DFC910411FC1100FDFE110011FE280226AA42AA8202000C
+9D2A:2020104010FCFE8482FC828428FC288024FE248044FE400242AA82AA0202000C
+9D2B:00400080F9FCA904A9FCA904A9FCF900A9FEA900A9FEA802FAAA8AAA0202000C
+9D2C:2208111000207FFE42029FF410101FF010101FF010001FFC10001FFC2A44452C
+9D2D:1040208079FC490449FC490479FC410041FE790049FE48024AAA7AAA4A02000C
+9D2E:10201040FEFC288444FC82847CFC0080FEFE208040FE7C0204AA04AA2902100C
+9D2F:0020FE4010FC108420FCFE84AAFCAA80AAFEAA80AAFEAA02AAAAA2AA8B02840C
+9D30:08201C4070FC108410FCFC8410FC10807CFE448044FE440244AA7CAA4502000C
+9D31:28402880FDFC290429FC010405FC450029FE290011FE10022AAA2AAA4A02800C
+9D32:80208840B0FCC08484FC84847CFC0080F8FE888088FEF8028AAA8AAAFA02880C
+9D33:102008407EFC428494FC108410FCFE8024FE248048FE280212AA2AAA4602800C
+9D34:10101020277C4044907C10442FFC6240A27E2240227E220222AA22AA2B02240C
+9D35:2820284028FC2884AAFC6C8428FC28806CFEAA8028FE28022AAA4CAA4902800C
+9D36:1020104010FCFE8410FC10847CFC008000FE7C8044FE440244AA7CAA4502000C
+9D37:7F0408441E44224454440844320CDFF010101FF010101FFC10001FFC0004492C
+9D38:1040508051FC7D0491FC110411FCFF0031FE390055FE540292AA12AA1202100C
+9D39:4440248029FCFF0411FC11047DFC110011FEFF0011FE100222AA22AA4202800C
+9D3A:10201040FEFC10847CFC14847CFC50807EFE128012FE160228AA24AA4502800C
+9D3B:0020804040FC1F8484FC448444FC048024FE4480C4FE47025CAA48AA4102000C
+9D3C:101020107F3C41247F4441287F1040287FC640007FBC00A4AAA4AAA4813C0624
+9D3D:1000FE7C22441C7CE2001FF010101FF010101FF010001FFC10001FFC2A44452C
+9D3E:1040108021FC4904FDFC450411FC51007DFE910011FEFC0212AA12AA1202100C
+9D3F:2040208051FC490485FC0104F9FC010001FEF90089FE88028AAAFAAA8A02000C
+9D40:081813E0304057FC904013F802001FF010101FF010101FFC10001FFC0004492C
+9D41:2040108001FCFD0401FC290445FC830009FE490029FE10022AAA4AAA8202000C
+9D42:12081210123C22242FBC6224A63C27202ABE2AA0323E2202222A222A2202220C
+9D43:1040208079FC490469FC590449FCF90049FE490069FE58024AAA4AAA4A02980C
+9D44:0040FE8021FC290445FCFD0415FC110011FE7D0011FE10021EAAE2AA4202000C
+9D45:2040208039FC490449FCA90411FC290045FE850079FE48024AAA4AAA7A02480C
+9D46:11001200279C44808780148027BE6408A7C8240827C820482548254828682190
+9D47:202020403EFC288448FC08843CFC288028FE2880FEFE08020AAA0AAA0A02080C
+9D48:0040FC8049FC490479FC490449FC790049FE49004DFE7802CAAA0AAA0A02080C
+9D49:02000100FFFE04401450244842041FF010101FF010101FFC10001FFC0004492C
+9D4A:10201040FEFC108410FC548454FC5480BAFE118010FE280228AA44AA8502000C
+9D4B:00107E20027C02447E7C4044417C41403F7E1040087E2902A2AAA2AA1F02000C
+9D4C:101020107C2844287C4444BA7C1040107EFE40107E580254AA92AB1282500C20
+9D4D:20201040FEFC828400FC7C8400FC0080FEFE288028FE280228AA4AAA4D02800C
+9D4E:04201E40E0FC228492FC548448FC1080FCFE248044FE280210AA28AA4502800C
+9D4F:1020144010FCFE8410FC7C8454FC54807CFE548054FE7C0254AA54AA55024C0C
+9D50:002000407CFC108410FC548454FC5480BAFE108010FE1C02E2AA42AA0202000C
+9D51:0040F88089FC8904F9FC0104F9FC890089FEF90089FE8802FAAA8AAA8A02980C
+9D52:0040488045FC950411FC290445FC810079FE490049FE48024AAA7AAA4A02000C
+9D53:10201040FEFC108410FCFE8482FC048078FE088010FE1E02F0AA10AA5102200C
+9D54:101020107C2044447CFE44287C4440A27E3C40447E4402A8AA10AA2882440C82
+9D55:1020104020FC4484FEFC288444FCA2803CFE448044FEA80212AA2AAA4602800C
+9D56:004000807DFC450445FC7D0445FC45007DFE410051FE480256AA62AA4202000C
+9D57:42102420187C2444527C1044FF7C2040287E7E40AA7E2A022AAA2EAA0902080C
+9D58:00107E20127C1244FF7C1244127C7E40207E20407E7E6202A2AA22AA3F02220C
+9D59:0040788049FC490479FC490449FC790049FE490079FE000252AA4AAA8A02000C
+9D5A:0C20704010FCFE8410FC388454FC928000FE388028FE28022AAA4CAA4902800C
+9D5B:0020FE4054FC5484A8FC548454FC0080FEFE108010FE10021EAAF2AA4202000C
+9D5C:4420244028FCFC8414FC1484FCFC908090FEFE8032FE320252AA96AA1102100C
+9D5D:04103620E57C2544247CFFC4247C2540257E3640E67E24022AAA32AAA1C2408C
+9D5E:02403C500848FFFE08480E50782408541A8C1FF010101FF010101FFC5244892C
+9D5F:280011FC682014F82420D5FC0A001FF010101FF010101FFC10001FFC0004492C
+9D60:1020504050FC7C8490FC1084FEFC008000FE7C8044FE440244AA7CAA4502000C
+9D61:04100620757C0544047CFF44047C1440147E5C40547E5402552A5D2AE342410C
+9D62:1040208079FC490479FC490479FC490049FEF90019FE28024AAA8AAA2A02100C
+9D63:10201040FEFC108410FC7C8454FC548054FE7C8010FE380256AA92AA1202100C
+9D64:202020403CFC448448FCBE842AFC2A803EFE2A802AFE3E022AAA2AAA2B02440C
+9D65:49042A247F240824FFA4080C02001FF010101FF010101FFC10001FFC0004492C
+9D66:100020FC7C0444047C7C44047C0440FE7E1040927E540238AA54AA9282500C20
+9D67:4440288001FC7D0429FC290429FC2900FDFE290029FE28022AAA4AAA4A02880C
+9D68:1020104028FC248442FCB88410FC1080FEFE108010FE7C0244AA44AA7D02440C
+9D69:0008779054BC54A454BC75A4543C57A054BE74A056BE5502552A56AA5482B40C
+9D6A:10201040FEFC288454FC92847CFC54807CFE54807CFE100216AA1AAA1202000C
+9D6B:102010401EFC10847CFC44847CFC44807CFE548010FEFE0212AA12AA1202100C
+9D6C:00107720557C5544557C7744557C5540557E7740557E5502552AB52A8942130C
+9D6D:1020104028FC248442FCBC8410FC1080FEFE108094FE580252AA1EAAF202400C
+9D6E:102010403EFC228444FC808410FC668042FE428066FE420242AA7EAA4302000C
+9D6F:104020807DFC550455FC7D0455FC55007DFE210051FEFC0212AA12AA1202100C
+9D70:00107F20497C49445D7C49447F7C41405D7E5540557E5D02412A412A4542820C
+9D71:102010407CFC108410FCFE8400FC448092FE10807CFE100212AA1EAAE202400C
+9D72:2820284028FCFC8428FC2884FEFC00807CFE448044FE7C0244AA44AA7D02440C
+9D73:102008407EFC428442FC7E8440FC5E8052FE5E8052FE5E0252AA52AA9302160C
+9D74:402040407EFC828422FCAA8472FC2280FEFE228072FEAA0222AA22AA0B02040C
+9D75:202020403CFC448488FC7E8452FC52807EFE10802CFE2A0228AA4AAA4B02860C
+9D76:0020FE4028FC288428FCEE8482FC828082FEEE8028FE28022EAAF0AA4102000C
+9D77:10100820FF7C8144407C7744557C5540557EB540977E1402242A252A4642840C
+9D78:10201040FEFC108428FC4484FEFC048074FE548054FE740254AA04AA1502080C
+9D79:0640387C08947E241C442A944A081FF010101FF010101FFC10001FFC0004492C
+9D7A:20201040FEFC288428FC4E8452FCDA8056FE628054FE4C0248AA54AA6502400C
+9D7B:105020487C8044FE7D9046907CFC40907E9040FC7E900290AA90AAFE82800C80
+9D7C:20201040FEFC828428FC448482FC00807CFE108010FE10021EAAF2AA4202000C
+9D7D:0010F720117C5544227C5544897C1040007EF740117E5502222A552A8942100C
+9D7E:0020FC4084FC8484FCFC848484FCFC8000FE8880EEFE880288AAAAAACD02880C
+9D7F:100020FE7C8244FE7C8244FE7C0040147EE440447E4403FEAA44AA4482840D04
+9D80:102420247F7E41247F24413C7F2440247FBC40247FA400FEAA80AAA481220642
+9D81:20201040FEFC008400FC7C8444FC44807CFE108054FE520292AA10AA5102200C
+9D82:2020CE4082FC8284EEFC828482FCFE8028FE288028FE28024AAA4CAA8902000C
+9D83:100020207CCE44827C8244EE7C8240827EFE40287E280228AA48AA4A828A0D06
+9D84:10201040FEFC10847CFC1084FEFC00807CFE44807CFE44027CAA44AA5502480C
+9D85:0040548055FCA904A9FC550455FC0100F9FEA900A9FEF802AAAAAAAAFA02880C
+9D86:1040108011FC7D0411FC550455FC5500BBFE110039FE540292AA12AA1202100C
+9D87:10201040FEFC10847CFC54847CFC54807CFE108038FE540292AA12AA1202100C
+9D88:10201040FEFC10847CFC1484FEFC14807CFE1080FCFE240244AA28AA3102C80C
+9D89:20201040FEFC00847CFC44847CFC00807CFE048008FE1E02F2AA12AA5202200C
+9D8A:101008207F7C48445E7C4A444A7C7F404A7E4A405E7E4802542A922A2242400C
+9D8B:00207E4042FC42847EFC488448FC7E8048FE48805CFE540254AA54AA5D02940C
+9D8C:00107F20417C41447F7C4444557C5540557E5F40447E5502552A572A9D42000C
+9D8D:00207C4044FC7C8444FC44847CFC20807EFEAA802AFE4A0292AA22AA4B02040C
+9D8E:20201040FEFC828400FC7C8400FC0080FEFE108010FE540252AA92AA5102200C
+9D8F:0E20F04022FC928444FC108410FC7C8010FE1080FCFE10022AAA26AA4202800C
+9D90:08208C404AFC48843EFC0884C8FC5C806AFE488048FE48024AAA62AA9A02000C
+9D91:2AA42CA84920145022885FF410101FF010101FF010001FFC10001FFC2A44452C
+9D92:22082210FA3C222427BCFAA4AABCAAA0FABE22A072BEAA822AAA24AA2482298C
+9D93:50405080F9FC510451FC0104F9FCA900A9FEA900F9FEA802AAAAAAAAFA02880C
+9D94:00107E20247C18447F7C29444A7CA840107E0840FF7E1C022A2A492A8842080C
+9D95:2040108079FC010449FC3104FDFC010079FE490049FE78024AAA4AAA7A02480C
+9D96:0610381008527E5408901C282A2848440A821FF010101FF010101FFC5244892C
+9D97:00407CFC44847CFC44847CFC0080FEFE108010FE5E0252AA52AAB0049FFE0000
+9D98:20102720257C7544257C2744257C7540557E5740557E5502752A492A0942130C
+9D99:20201040FEFC008444FC2884FEFC828010FE7C8054FE540254AA5CAA1102100C
+9D9A:0020EE40AAFCAA84EEFC008478FC0080FCFE208040FE78020AAA0AAA2A02100C
+9D9B:48204A406CFC48844AFC6A8456FC20807EFE428042FE7E0242AA42AA7F02420C
+9D9C:4420FE4044FC00847CFC048428FC1080FEFE328054FE900212AA12AA5202200C
+9D9D:0020FE4000FC7C8444FC44847CFC0080FEFE928092FEFE0292AA92AAFF02820C
+9D9E:021007203C7C2444247C3F44247C2F40297E2F40297E2F02292A492A4F42890C
+9D9F:20201040FEFC828428FC448492FC148012FEFE8010FE10022AAA26AA4202800C
+9DA0:0010FFA0807CBF44A17CBF44A17CBF40887EFFC0927EB2028CAA92AAA102FF8C
+9DA1:00207C4044FC7C8444FC7C8420FC7E8092FE52806AFE42027AAA02AA1502080C
+9DA2:0E20F04022FC928454FC48847CFC1080FEFE20803EFE420254AA88AA1502620C
+9DA3:101008207E7C4244427C7E44427C40407F7E5540557E7F02D52A552A5542430C
+9DA4:0020FE4092FC1084FEFC10847CFC54807CFE54807CFE1002FEAA12AA1202100C
+9DA5:00107F20497C49447F7C40445F7C5140517E5F40517E5F02512A512A9F42110C
+9DA6:107CFF44107C7E44427C7E44028C1FF010101FF010101FFC10001FFC0004492C
+9DA7:221022207F7C22442A7C08443E7C2A402A7E2A40FF7E0802142A122A2242400C
+9DA8:20203C4044FC788408FCFE8420FC52809CFE2C804AFE98022AAA4AAAAA02100C
+9DA9:00207E20247E18A4FF2829104A2898C602001FF010101FF010101FFC5244892C
+9DAA:00207E4042FC7E8442FC7E8442FC7E8014FE1280FEFE10022AAA26AA4202800C
+9DAB:10201040FEFC1084FEFC9284D6FCBA8092FEFE8010FE380254AA92AA1102100C
+9DAC:08100C20127C294444FCBF44217C3F40217E3F40207E3F02512A512A9F42110C
+9DAD:20204410F9FE1040247CFE840084551482081FF010101FF010101FFC5244892C
+9DAE:20201040FEFC00847CFC44847CFC0080FEFE8280BAFEAA02BAAA82AA8B02840C
+9DAF:08202AA44D28145022887FFE42029FF410101FF010101FFC10001FFC0004492C
+9DB0:00207C4044FC44847CFC0084FEFC8280FEFE8280FEFE8202FEAA28AA4502840C
+9DB1:01007FFE44429FF404403FF80440FFFE0A201FF02828CFE608200FF800081558
+9DB2:2820444092FC208448FCFC8404FC0080EEFE2280AAFE6602AAAA22AAAB02440C
+9DB3:2100427EF3889288F2BE92AAF3AA822AFA2A83AAFAAA0AAEAA88AB888A883008
+9DB4:081008207F7C5544127C3F44647CA4403F7E2440247E3F0224AA24AA3F02200C
+9DB5:201020207F7C9144557C7D44217C4A40A47E7F40917E55027D2A212A4A42840C
+9DB6:101008207F7C48445E7C4A447F7C4A405E7E48405E7E520252AA52AA5F02920C
+9DB7:20201040FEFC828410FC7C8410FC7C8010FEFE8010FE7C0244AA44AA7D02440C
+9DB8:0020EE4022FC2284EEFC888488FCEE8022FEAA8066FE6602AAAA22AAAB02440C
+9DB9:2020DE408AFCCA84AAFCD284A6FC0080FEFE928092FEFE0292AA92AAFF02820C
+9DBA:1020924054FCAA8444FC82847CFC448044FE7C8044FE44027CAA44AA45024C0C
+9DBB:00207C4044FC748454FCFE8482FC7C8044FE7C8044FE7C0244AA44AA5502480C
+9DBC:22101420007C7FC4147C7F44157CFFC0157E7F40147E3602552A94AA1442140C
+9DBD:282024407EFCC8847EFC48847EFC48807EFE508010FEFE0212AA12AA1202100C
+9DBE:108010FE1140FEFC10847CFC44847CFC44807CFE1080FEFE100212AA12AA1004
+9DBF:082004407FFC12483CF0082014503EF802001FF010101FF010101FFC5244892C
+9DC0:21081110123CFFE4213C2124423C52A094BEE720213E4202422A94AAF782108C
+9DC1:22101420007C7F44007C1444227C4140007E7F40557E5502552A57AAFC42000C
+9DC2:0E20F04022FC928444FC20843CFC508010FEFE8010FE540254AA5CAA6502000C
+9DC3:00107E20427C7E44427C7E44087CFF40817E1040FF7E220264AA18AA2502C20C
+9DC4:0E20F04022FC928444FC208444FCF88010FE2480FEFE1002FEAA28AA4502820C
+9DC5:0020FE4028FC2884FEFCAA84AAFCFE8010FE1080FEFE380254AA92AA1102100C
+9DC6:4610782040FC3FC4007C5F44517C5F40517E5F40517E5F02402A7FAA2242410C
+9DC7:1000FE7810487C480048FE8692007CFC44447C4444287E2840107F280144AB82
+9DC8:2004401EF3F0921EF21092FEF2928298FAF2828EFA800AB8AAA8ACAA8D4A3A86
+9DC9:03107C20477C44445F7C5544567C5C40557E5340507E5702552A552AA9C2000C
+9DCA:0020FE4000FC7C8444FC7C8400FCFE8082FEAA8092FEFE0292AA92AA9302860C
+9DCB:22082210FFBC22242A3C1424223C5D2088BE08207F3E08022A2A492AA882100C
+9DCC:100020FE7C9044FC7C9044FC7C9040907EFE40027EAA02AAAAAAAA8282140C08
+9DCD:104020807DFC45047DFC45047DFC45007DFE1100FDFE10023AAA56AA9202100C
+9DCE:102020407CFC44847CFC44847CFC1080FEFE288054FE92027CAA10AA1102100C
+9DCF:10201040FEFC10847CFC44847CFC44807CFE44807CFE4402FEAA28AA4502820C
+9DD0:00107E20427C7E44427C7E44007C7F40407E5E40407E7F02552A522A5942910C
+9DD1:44104420777CAA44117C2044107CFF40007E0440447E240228AA0EAAF102400C
+9DD2:10201040FEFC10847CFC54847CFC54807CFE1280FEFE0802FEAA48AA2902180C
+9DD3:101008207F7C4044527C52447F7C5240527E5E40407E5502552A552A8042000C
+9DD4:08207F20087E7E4408A4FF2810101E2822445FF290101FF010101FFC5244892C
+9DD5:009079FE4B204DFC492049FC792001FE02001FF010101FF010101FFC5244892C
+9DD6:7F7848485F4C64805F784A4851307F4C02001FF010101FF010101FFC5244892C
+9DD7:0020FE4080FC8084BCFCA484A4FCBC8080FEEE80AAFEAA02EEAA80AAFF02000C
+9DD8:0820FFA0083E7F4449A87F102A28494682001FF010101FF010101FFC5244892C
+9DD9:08207E2008F8FF2814287F6A082AFF560A821FF010101FF010101FFC5244892C
+9DDA:0020EE4022FCAA8466FCAA8410FC288044FE928020FEC80232AAC4AA1902E00C
+9DDB:02083FD0223C2FA422BC3FE422BC2FA0223E2FA02ABE2F824AAA4FAA8A82098C
+9DDC:08107F20497CFFC4497C7F44087C7F40497E7F40107EFF02212A722A0C42F30C
+9DDD:0020FE4092FCFE8492FCFE8454FC5480FEFE548054FEFE0210AAFEAA1102100C
+9DDE:10201040FEFC1084BAFC5484BAFC1080BAFE5480BAFE10022AAA26AA4202800C
+9DDF:208010FCFD4020F83D2024FC445055888A041FF010101FF010101FFC5244892C
+9DE0:2040208079FC490491FC7D0455FC55007DFE550055FE7C0202AAAAAAAA02000C
+9DE1:200820107FBCD524553C5524FFBC5520553E5520FFBE00026A2A552A9502000C
+9DE2:3FFE289025103FDE22222A882F88229425222FF0241027F0241047FC40048AAC
+9DE3:0020FE4028FCFE84AAFCFE8400FC7C8044FE7C8044FE7C0210AAFEAA1102100C
+9DE4:0020EE40AAFCAA84EEFC00847CFC54807CFE54807CFE1002FEAA12AA1202100C
+9DE5:1020244878F014287EFC002054A8556402001FF010101FF010101FFC5244892C
+9DE6:282024407EFCC88448FC7E8448FC48807EFE488048FE7E0240AAAAAAAB02000C
+9DE7:1020FE4010FC7C8400FCFE8482FC7C8000FE7C8044FE7C0244AA28AA0F02F00C
+9DE8:44204440FEFC448400FCFE8454FC5480FEFE548054FEFE0210AAFEAA1102100C
+9DE9:49202A3E7F4849485DA86B104928414602001FF010101FF010101FFC5244892C
+9DEA:00003EF822883EF822883EF822887FFE42029FF410101FF010101FFC5244892C
+9DEB:08087F10093CFFA4093C7F24083CAAA0EBBE88A0FFBE8882EBAAAAAAAA82088C
+9DEC:282028407CFC288428FCFE8410FC7C8054FE7C8054FE7C0200AA28AA4502820C
+9DED:0E20F04092FC5484FEFC388454FC82807CFE548054FE7C0254AA54AA7D02440C
+9DEE:06107820107CFFC4227C5D4494FC1C40007E7F40417E5D02552A5D2A4142430C
+9DEF:081008207F7C0844557C2244417CBEC0227E3E40227E3E0208AA2AAA4902180C
+9DF0:0440FFFE044017D2F01C17D03452D7CE02001FF010101FF010101FFC5244892C
+9DF1:2020FE4082FCFE8482FCFE8482FCFE8010FE928054FE920210AAFEAA1102100C
+9DF2:08287F2400FE3E2022503E504952988E02001FF010101FF010101FFC5244892C
+9DF3:EE20AA40EEFCAA84EEFC8284BAFCAA80BAFEAA80BAFEAA02AAAADAAA8302860C
+9DF4:0020EE40AAFCEE84AAFCEE8492FC9280FEFE9280BAFED60292AA92AA8B02840C
+9DF5:00107F20417C41447F7C48445D7C4A407F7E48405E7E72025EAA52AA5F02920C
+9DF6:0020FE40AAFCAA84FEFC00847CFC44807CFE44807CFE44027CAA00AA2902440C
+9DF7:22101420FF7C14447F7C5544637C5D40417E7F40047EFF0244AA24AA25020C0C
+9DF8:7E101420087CFF44297C4A44A87C10407F7E5540637E5D02552A5D2A4142430C
+9DF9:00803FFE225024FC2D9036FC249024FC210027F0241027F0441047FC80040AAC
+9DFA:00403EFC23483E3009CE2E7828487E7802001FF010101FF010101FFC5244892C
+9DFB:21084088F3C89010F3DE9264F3D48014FBD48054F89408E8AB88A8948A943122
+9DFC:0020EE40AAFCEE84AAFCEE8482FCBA80AAFEBA80AAFEBA02AAAA82AA8B02840C
+9DFD:0A803138228838382288393822887FFE42029FF410101FF010101FFC5244892C
+9DFE:1020FE4044FC2884FEFC00847CFC44807CFE44807CFE10020AAAA9AAA5021C0C
+9DFF:3E1022FE3E4420287EFEA2103EFC221002001FF010101FF010101FFC5244892C
+9E00:00107F20557C55447F7C20447F7C91407D7E5540557E7D02112A7D2A0542020C
+9E01:0100FFFE20003FF800003FF820083FF80200779C54947794549C77D65056B562
+9E02:0310BC2044FC1144847C49445E7C0440297E5F40C47E5F0244AA4AAA5102208C
+9E03:21044088F3FE9020F1FC9020F3FE8054F9928090FBFE0890A8D4AB8A889631A2
+9E04:10207E204A7E7EC41028FF1020283EC642001FF010101FF010101FFC5244892C
+9E05:00107F20557C7F44087C7F44087CFFC0227E14407F7E0802FFAA08AA0902080C
+9E06:08100F20087C7F44497C7C44497C5F40527E5E40407E5E02482A7F2A5242A10C
+9E07:1020FE4000FCFE8482FCBA84AAFCFE8000FE7C8044FE7C0244AA7CAA0102FE0C
+9E08:14105520367C1444FF7C2244147C7F40087E7F40087EFF021CAA2AAA4902080C
+9E09:11FC1104FDFC310459FC948011FE125202AA1FF410101FF010101FFC5244892C
+9E0A:02087910493C4BA4483C7AA4413C47E0793E6920ABBEA902292A392A2902010C
+9E0B:0810FF20917C4A44A57C1C44007C7F40557EFFC0007E7F0208AA08AA2902100C
+9E0C:104421FE7C5444487CFE45907CFE40907EFE40907EFE0280ABFEAA4482380DC6
+9E0D:0008FF90493C88A4FFFC88A4DDBCAAA0DDBE88A0DDBEAA82DDAA88AA8A82810C
+9E0E:3EF822883EF822883EF822883EF8145022881FF010101FF010101FFC5244892C
+9E0F:2410FF20247CFF44817C7E44007CFF40107E28C0D57E2E02D5AA24AAD502080C
+9E10:0010EE20227CAA44667CAA44007C24407F7EC8407E7E48027EAA48AA7F02400C
+9E11:510C278A500897BE30085788949457A422021FF010101FF010101FFC5244892C
+9E12:1A3823883A38238838B82288FFFE10102208DFF610101FF010101FFC5244892C
+9E13:00087F10493C7F24493C7F24413C0020FFBEAAA0AABEFF82AAAAAAAAFF82888C
+9E14:21FC4104F9FC8904F9FC8888F9FC8088FDFE8088FD2406AA547054A885241860
+9E15:08080F90083C7FA448BC7E2448BC5FA0553E5F20553E5F02402ABFAA2A827FCC
+9E16:7F080810FFBC88A46B3C08246B3C24207FBEC8207F3E48027F2A482A7F82400C
+9E17:08403E7C1440FF7822083E782242263E02001FF010101FF010101FFC5244892C
+9E18:FE201040FEFC928454FC108454FC00802EFEFA802EFE7A02AEAA2AAA2F022A0C
+9E19:1020284044FCBA8400FCFE84AAFCFE8000FEFE80AAFEAA02FEAAAAAAAB02860C
+9E1A:00107720557C7744557C7744557C7740227E5540107EFF0222AA64AA1D02E30C
+9E1B:4420FE4044FC0084EEFCAA84EEFC24807EFEC8807EFE48027EAA48AA7F02400C
+9E1C:77105520777C5544777C5544777C22407FFEA4403F7E24023F2A242A3FC2200C
+9E1D:77100020777C5544777C5544087C7F40547E7F40557E7F02552A5E2A55429B0C
+9E1E:21084FD2F03C23884812FBBE0280ABAA02001FF010101FF010101FFC5244892C
+9E1F:010002001FF01010121011101150102010001FFC000400047FE4000400280010
+9E20:2020204020FC2084FCA4248424942488248024FE2502260245FA400280140008
+9E21:0020004000FCFC8404A4048448942888108010FE2802240245FA800200140008
+9E22:04200410023EFFC00080004202321FEE1420126010001FF800087F8800280010
+9E23:0020004079FC4904494449244924490C490049FE7802480203FA000200140008
+9E24:002000403EFC228422A422843E942288208020FE2002200221FA400240148008
+9E25:00207E4040FC448464A4548448944888548054FE6402400241FA7E0200140008
+9E26:00207E4004FC248424A4248444947F880C8014FE1402240245FA840214140808
+9E27:08100820147C124421644054BE44224C2240227E2A022402217A21021F0A0004
+9E28:4020484050FC608444A444843C941088108010FEFE02100211FA100210141008
+9E29:08100820087C7F44496408540844144C1440147E14022502267A4402800A0004
+9E2A:1020104010FC1084FEA41084109410887C8044FE4402440245FA7C0244140008
+9E2B:10101020107CFF44206428544844484C7E40087E2C022A02497A8902280A1004
+9E2C:102010401EFC108410A47C844494448844807CFE4402400241FA400280140008
+9E2D:0020FE4092FC928492A4FE84929492889280FEFE9202100211FA100210141008
+9E2E:00207E4042FC428442A47E840094FF88208040FE7E02020203FA020214140808
+9E2F:01001FF011101110FFFE02801C70E20E04001FE0122011601FFC00047FD40008
+9E30:1020104028FC248442A4918408940888FE8002FE4402280211FA080208140008
+9E31:011007A07C7C44444464445444447F4C4440447E4402420242FA5282698A4484
+9E32:2020204040FC7E8482A402847A944A884A804AFE7A024A0203FA020214140808
+9E33:10003EF84288A2AA1492187EE2001FE01420126010001FF800087F8800280010
+9E34:2208111000207FFE410282041FF010101210115010201FFC000400047FD40008
+9E35:102020107C1044FE548245045440484840507E6002400242FA420242143E0800
+9E36:1020244878F010207EFC0000FFFE020004001FE0122011601FFC00047FD40008
+9E37:10801080FBF010901990F0941154520C24041FE0122011601FFC00047FD40008
+9E38:00107F20087C084410647F545544554C5540557E55025502557A5102450A4204
+9E39:04200E4038FC088408A4FF84089408883E8022FE2202220223FA3E0222140008
+9E3A:12081210123E22222FB2622AA62227262AA02ABE32022202227A2202220A2204
+9E3B:10101020277C4044906410542FC4624CA240227E22022202227A22022A0A2404
+9E3C:082010403EFC228432A42A842A94FE88228032FE2A022A0223FA42024A148408
+9E3D:1020104028FC248442A480847C94008800807CFE4402440245FA7C0244140008
+9E3E:02000100FFFE04401450244842041FE01420126010001FF800087F8800280010
+9E3F:00108020407C1F44846444544444044C2440447EC40247025C7A4802400A0004
+9E40:001000207F7C084408642A542A442A4C5D40497E880208020F7AF002400A0004
+9E41:10201040FEFC108410A4FE8482940488788008FE10021E02F1FA100250142008
+9E42:0008FF90003E0022F7B294AA94A294A6D6A0B5BE9482948294FA9482948AB584
+9E43:00103E20227C22443E6400547F44414C41407F7E410241027F7A4102450A4204
+9E44:08104820487C7F44886408540844FF4C0040007E7E024202427A42027E0A4204
+9E45:04103620E57C25442464FFD42444254C2540367EE60224022AFA3282A18A4084
+9E46:2820244042FC928410A42884449482887C8044FE4402440245FA7C0244140008
+9E47:40102F20017C4944496449547F44494C5D406B7E49024902497A4102450A4204
+9E48:4420244028FCFC8414A41484FC9490889080FEFE3202320253FA960210141008
+9E49:04100620757C05440464FF540444144C14405C7E54025402557A5D02E30A4104
+9E4A:24102420247CFF4424642454FFC4004C7E40427E42027E02427A42027E0A4204
+9E4B:22082210FFBE22222232002A7F2249264920493E7F024902497A49027F0A4104
+9E4C:08080810FFBE14222232492A88A27F2649207F3E49027F02087A0A020C0A0804
+9E4D:00107E20427C42447E64425442447E4C0040447E77024402447A5502660A4404
+9E4E:101020207F7C494449647F544944514C7F40247E4402FF82047A0402040A0404
+9E4F:00107720557C5544556477545544554C5540777E55025502557AB502890A1304
+9E50:102010403EFC228444A4808410946688428042FE6602420243FA7E0242140008
+9E51:10100820FF7C00447E6442547E44004C7E40047E08020F02F87A0802280A1004
+9E52:101008207F7C48445E644A544A447F4C4A404A7E5E024802547A9202220A4004
+9E53:10100820FF7C8144406477545544554C5540B57E97021402247A2502460A8404
+9E54:081008207F7C0944FFE409547F44084C4940497E5D026B02497A4902890A0904
+9E55:2008279024BEFCA224B227AA24A274A654A057BE5482548274FA08820A8A1104
+9E56:00107E20427C7E4442647E5420447F4C8940497E550241027D7A01020A0A0404
+9E57:00107720557C5544776400547F44004CFFC0207E3F020102017A01020A0A0404
+9E58:00207C4044FC748454A4FE9482947C8C44807CFE44027C0245FA440254144808
+9E59:0620382008A47EA819202C504A881FE41420126010001FF800087F8800280010
+9E5A:21081110123EFFE22132212A422252A694A0E73E21024202427A9482F78A1084
+9E5B:00107F20497C49447F6440545F44514C51405F7E51025F02517A51029F0A1104
+9E5C:00207E20247E18A4FF2829104A289AC604001FE0122011601FFC00047FD40008
+9E5D:0020FE4000FC7C8444A47C840094FE888280AAFE9202FE0293FA920292148608
+9E5E:0E20F04022FC928444A420843C9450881080FEFE1002540255FA5C0264140008
+9E5F:2820444092FC208448A4FC8404940088EE8022FEAA026602ABFA2202AA144408
+9E60:2020DE408AFCCA84AAA4D284A6940088FE8092FE9202FE0293FA9202FE148208
+9E61:1020924054FCAA8444A482847C94448844807CFE440244027DFA440244144C08
+9E62:22101420007C7F44006414542244414C00407F7E55025502557A5782FC0A0004
+9E63:22101420007C7FC414647F541544FFCC15407F7E14023602557A9482140A1404
+9E64:081008207F7C554412643F546444A44C3F40247E24023F02247A24023F0A2004
+9E65:7F7848485F4C64805F784A4851307F4C04001FE0122011601FFC00047FD40008
+9E66:00107720557C5544556455542244554C0840FF7E12022202347A0C02320AC104
+9E67:101008207F7C4044526452547F44524C52405E7E40025502557A5502800A0004
+9E68:00107720117C5544336455540C44334CC4C0187E62020C82717A0602180AE004
+9E69:081008207F7C0844556422544144BECC22403E7E22023E02087A2A02490A1804
+9E6A:282024407EFCC88448A47E84489448887E8048FE48027E0241FAAA02AA140008
+9E6B:08287F2400FE3E2022503E5049529A8E04001FE0122011601FFC00047FD40008
+9E6C:7E101420087CFF4429644A54A844104C7F40557E63025D02557A5D02410A4304
+9E6D:00403EFC23483E3009CE2E7828487E7804001FE0122011601FFC00047FD40008
+9E6E:0020FE40AAFCAA84FEA40084FE9400887C8044FE7C022A0265FAA20231142008
+9E6F:1020FE4000FCFE8482A4BA84AA94FE8800807CFE44027C0245FA7C020014FE08
+9E70:00803FFE225024FC2D9036FC249024FC210027F02490242047FC40049FD40008
+9E71:104421FE7C54444864FE559044FE4C9040FE7C9004FE0480F5FE0444143809C6
+9E72:2410FF20247CFF4481647E540044FF4C104028FED5022E02D57A2482D40A0804
+9E73:2208FF90223EF7A294B2F7AA282224267FA0483EFF0248027F7A48027F8A4004
+9E74:7F1008207F7C49442A6408542A44004C2740FD7E27027502AF7A2502270A2504
+9E75:0100010001FE010001003FF8200829282448228829282288244829283FF82008
+9E76:102010201E2010501050FE889344C622AA20D6F8AA08C6089210FE1082200020
+9E77:102010201E5010501088FF249212C610ABFCD604AA08C6889250FE2082100010
+9E78:101010281E441082107CFE109210C6FEAA92D692AAFEC6109228FE2882440082
+9E79:100C100A1E0810FE1088FE8892FAC68AAA8AD6ECAAACC6AC92EAFE8A82960122
+9E7A:104410241E2810FE1010FE7C9210C6FEAA20D620AA7CC6509290FF1082FE0000
+9E7B:108810501E0011FE1050FEFC9254C7FEAA54D6FCAA50C6D89354FE5282500050
+9E7C:101010101E2810441082FE7C9200C6EEAAAAD6AAAAEEC6449244FEAA82AA0112
+9E7D:0100F9FEA220A43EF8208BFE8AAAFA52A326A252A2AAFBFE00003FF82448FFFE
+9E7E:208420443C4821FE2020FCFC842095FED440A480D4FE95108610FC1085FE0000
+9E7F:010000803FFE222022203FFC222422243FFC284028442F58486048448B440C3C
+9E80:010000803FFE22203FFC22243FFC28402F7828422F3E200028784F82480287FE
+9E81:010002000FF0706003801D00E0803FFC22403FF822483FF828442F7848428F3E
+9E82:010000803FFE22203FFC22243FFC28402F7828422F3E200023F042104412980E
+9E83:010000803FFE22203FFC22243FFC28442F4828742B442C3C40004A4889241124
+9E84:044008203018DFF60410095010A03FFC22403FF822483FF828442F7848428F3E
+9E85:00803FFE22203FFC22243FFC242227BE24002FF830082FC828684FD0480287FE
+9E86:00803FFE22203FFC22243FFC242227BE200027F8240827F8240847F84408BFFE
+9E87:00803FFE22203FFC22243FFC242027BC2422279E200823F020404FFE41508E4E
+9E88:00803FFE22203FFC22243FFC242027BC2422279E20802FFE204047FC40409FFE
+9E89:00007C7C10101010FEFE111010903FFC22403FF822483FF828442F7848428F3E
+9E8A:111009207FFC05401930610C00803FFC22403FF822483FF828442F7848428F3E
+9E8B:00803FFE22203FFC22243FFC242027BC2422279E224821502FFE415042488C46
+9E8C:00803FFE22203FFC22243FFC200027F0241027F020002FF820805FFC42209C1C
+9E8D:00803FFE22203FFC22243FFC242227BE20403FFE220024082FFC44944892908E
+9E8E:00803FFE22203FFC22243FFC242227BE20002FFC28002BFC28004FFE4A28939E
+9E8F:00803FFE22203FFC22243FFC20002FFC21043FFE21042FFC220047FC4A0493FC
+9E90:00803FFE22203FFC22243FFC242227BE20402FFE211020E02F1E43F8420883F8
+9E91:00803FFE22203FFC22243FFC242227BE21002E7828082F7828084FF842229C1E
+9E92:08447F4455FE54447F44557C55447F44547C54445E4455FE54005C2856448082
+9E93:082008207EFC1C702AA8C92608A03FFC22403FF822483FF828442F7848428F3E
+9E94:00803FFE22203FFC22243FFC222027B02D2832242DFE300027F84408440887F8
+9E95:00803FFE22203FFC22243FFC20002FFC28242BC428842FF42AA44C944FFC8804
+9E96:00803FFE22203FFC22243FFC20803FFE20002FF828082FF82080488852848100
+9E97:3F7E00003E7C224432642B5400803FFC22403FF822483FF828442F7848428F3E
+9E98:00803FFE22203FFC22243FFC20102FE020803FFC24902FF8341647F0441087F0
+9E99:00803FFE22203FFC22243FFC200020282FFE28202BA428282BAC4A944BAC9044
+9E9A:00803FFE22203FFC22243FFC20002F7C29042F7C28002F7C28444F28483088CE
+9E9B:00803FFE22203FFC22243FFC20002F7E21242F3C28242F3C2126417C45048204
+9E9C:00803FFE22203FFC22243FFC20002FFE211027FC251427FC20404FFE4150864C
+9E9D:00803FFE22203FFC22243FFC242027BC24222F9E29082F7E29485F2845089B18
+9E9E:00803FFE22203FFC22243FFC204027FC21102FFE220823F822084FFE40408040
+9E9F:08107F54543854FE7F10553855567F90548454EE5EA454B4555E5C4456848104
+9EA0:00803FFE22203FFC22243FFC28882FF828883FFE20002FF828884FF84888BFFE
+9EA1:00803FFE22203FFC22243FFC20402FFE20A02F5E255425542B5A440847F88808
+9EA2:00803FFE22203FFC22243FFC200027FC20402FFE2842235820004EEE4AAA8EEE
+9EA3:13DEFE52ABDEA800FFFEAA00AAC8FE4EABEAAAB2BEEAAAAAAAEABAB4ADE4002A
+9EA4:00803FFE22203FFC22243FFC4810FF7E54487F7E554A7F7E52645B7652A49B36
+9EA5:01007FFC0920092015502388054009203218C7E6082013400080014006203800
+9EA6:010001007FFC010001003FF801000100FFFE08001FF02820444003801C70E00E
+9EA7:08200820FF402A7E2A805D00887C1C042A0850101E20224054420842143E6000
+9EA8:08100810FF102A102A545D5288521C902A1050141E04220854080810142060C0
+9EA9:10201020FE20542055FCBA201020382055FEA2203C504450A88810882904C202
+9EAA:100011FEFE20542054A0BABC10A438A454A4A2FC3C044404A80410042828C010
+9EAB:080008FEFF102A102A505D5E88501C502A50507E1E0222025402080214146008
+9EAC:10101010FE1054FE5492BA94109038FC54A4A2A43CA844A8A89011282944C282
+9EAD:10401040FEFC54845504BAF41094389454F4A2843C944488A8821082287EC000
+9EAE:08100810FF102A7E2A105D1088101CFE2A1050101E202228544408FE14426000
+9EAF:10501050FE50545055FCBB54115439545554A3FC3D544554A954115429FCC104
+9EB0:10201020FE48548455FEBA121090389054FEA3103C1045FEA81010102810C010
+9EB1:10141012FEFE54105410BAFE1092389254FEA2923C9244FEA89210922892C086
+9EB2:080008FCFF842A842AFC5D8488841CFC2A8450841EFC2250545008521492610E
+9EB3:08100810FF102AFE2A105D5488541C542ABA50101E3822545492081014106010
+9EB4:10801080FEFE55025622BAAA1072382255FEA2223C7244AAA9221022280AC004
+9EB5:080008FEFF102A202AFE5DAA88AA1CBA2AAA50AA1EBA22AA54AA08AA14FE6082
+9EB6:10201010FEFE54285492BAAA108238FE5410A2FE3CA244AAA8BA1082288AC084
+9EB7:10A811FCFEAA57FE56AABBFE12AA3BFE5400A3FE3C0045FCA90411FC2888C3FE
+9EB8:10201020FE2010207DFC1020FE2020203DFE44204850A8501088288841048202
+9EB9:10801080FEFE11027E2210AAFE7220223DFE44224872A8AA11222822400A8004
+9EBA:100011FEFE2010407DFC1154FF5421743D5445544974A9541154295441FC8104
+9EBB:010000803FFE2210221022103FBE2210261027382AB42A545292421082100210
+9EBC:010000803FFE221022102FBC231826B42A522100221027E040C043088FFC0004
+9EBD:010000803FFE221022102FBC231826B42A522100224024804910420887FC0004
+9EBE:010000803FFE22102F7C26382B54329220782F8020F82F8020FC5F824082807E
+9EBF:00803FFE24103F7C26382D543412200027F8240827F820002FFC480448048FFC
+9EC0:010000803FFE22102F7C26382B5432923F80297C2F2429242F2849905F288146
+9EC1:00803FFE24103F7C26382D5434122FE020803FFC24902FF8341647F0441087F0
+9EC2:00803FFE24103F7C26382D5434922FF822A02FFC22202FF828884FF844108808
+9EC3:08207FFC08200FE00000FFFE01001FF0111011101FF0111011101FF008201010
+9EC4:044004403FF804400440FFFE01001FF011101FF011101FF0000008201010600C
+9EC5:221022107F1022282228FFC408447FA249107F10497C7F040008220821104110
+9EC6:221022107F10221022FEFF9208927F1049287F2849287F280048224A218A4106
+9EC7:221022107F102210221EFF9008107F10497C7F4449447F4400442244217C4144
+9EC8:222022107F0022FE2210FF9008107F10497C7F1049107F100010221021FE4100
+9EC9:110808907FFE44429FF404407FFC01001FF011101FF011101FF0044008201010
+9ECA:282028207CF828202820FE2011FC7C00542054207CF8542054207C2029FC4400
+9ECB:1088108895FC5488588813FEFC2029FC292429FC292429FC288849044A0287FE
+9ECC:0A803138228839382288FFFE84423FF80440FFFE11101FF011101FF008201010
+9ECD:00F83F0001007FFC092011102288C44409203118CB2605C01930610805000200
+9ECE:0640387C08947E241C442A94490802800C603118C92605400920111025080200
+9ECF:0C2070201020FE20383E54209020282055FC9104550439045504930451FC2104
+9ED0:0C40702011FCFE5039245554910429FC542091FC554439545574930451142108
+9ED1:00003FF82108292825483FF8010001003FF801000100FFFE0000488844448444
+9ED2:00003FF821083FF821083FF801003FF801000100FFFE00002488224442448004
+9ED3:00287F2449246B205D2E49F07F2008207F2008200FA0F0100012550A4A868002
+9ED4:0020FE209220D650BA509288FF441222FE2010F81E08E0080210AA10A8208020
+9ED5:0010FE109210D610BAFE9292FE921010FE2810281E28E0280248AA4AA88A8106
+9ED6:0000FEFE9210D610BA909290FE9010FEFE1010101E28E0280248AA4AA88A8106
+9ED7:0020FE209220D7FCBA2092A8FEA810A8FEA810A81EF8E0220222AA22A81E8000
+9ED8:0020FE289224D624BA2093FEFE201020FE2010501E50E0500288AA88A9048202
+9ED9:00107F1449127F10497E7F1008287F2808440F44F08200002488224442448004
+9EDA:0044FE449244D644BAFE9244FE441044FE44107C1E44E0440244AA44A87C8044
+9EDB:08901088307ED7C01022101A00063FF8292825483FF801007FFC0100FFFE4444
+9EDC:0010FE109292D692BA929292FEFE1010FE1010921E92E0920292AA92A8FE8002
+9EDD:0010FE509250D690BAFC9354FFD41094FE9411141F54E1D40254AA24A8348048
+9EDE:0010FE109210D610BA1E9210FE101010FEFE10821E82E0820282AA82A8FE8082
+9EDF:0020FE20927CD684BB489230FE201048FE90103E1E42E0A40218AA10A82080C0
+9EE0:0020FE209220D7FEBA209220FEFC1000FE0010FC1E84E0840284AA84A8FC8084
+9EE1:3FFC20903FFC21402630380C2FF82AA829C82FF820802FF840805FFC8A481124
+9EE2:0010FE109220D644BAFE9228FE4410A2FE3C10441E44E0A80210AA28A8448082
+9EE3:0040FE40927ED680BB7C9244FE641054FEFE10441EA4E09402FEAA04A8288010
+9EE4:0020FE2093FED650BAA89326FEF810A8FEA810F81EA8E0A802F8AAAAA822801E
+9EE5:0020FE1092FED600BA00927CFE441044FE7C10101E54E0520292AA10A8508020
+9EE6:0020FE1092FED682BA40924EFE6A10AAFEAA10AA1F6CE028024AAA4AA88A8106
+9EE7:0640387C08947E241C442A9448083FF8292825483FF801007FFC0100FFFE4444
+9EE8:111009207FFE40029FF410103FF8292825483FF801003FF80100FFFE24484224
+9EE9:0010FE1092FCD610BA1093FEFE021054FE3010901E50E1FE0228AA44A8828102
+9EEA:0020FE289244D6FEBA2093FEFE881114FE2210481E10E02202C4AA18A8608180
+9EEB:0000FEFE9228D628BAFE92AAFEAA10AAFEFE10101E10E0FE0210AA10A9FE8000
+9EEC:000CFE0A9208D6FEBA889288FEFA108AFE8A10EC1EACE0AC02EAAA8AA8968122
+9EED:0020FE309248D684BB7A9200FEFC1084FE8410FC1E48E04803FEAA48A8888108
+9EEE:0048FE4893FCD648BA789248FE781048FE4811FE1E80E0A802C4AA80A8FE8000
+9EEF:0020FE1092FED600BA449228FEFE1000FE7C10441E44E07C0244AA44A87C8044
+9EF0:0010FE1092FED610BA7C9244FE7C1044FE7C10441E7CE04402FEAA28A8448082
+9EF1:012478A849FC48404BFE79084BFC4DAE497479FC482049FC48204BFE49549A2A
+9EF2:0010FE209244D6FEBA4492AAFEEE1010FE2810541EAAE0500224AA48A8108060
+9EF3:7F7848485E8664785F484A307F4C00003FF8292825483FF80100FFFE24484224
+9EF4:11101550255047D0903E17A420546FD4A9542DD42B542FC821082FD420142AA2
+9EF5:0040FE7C9284D7FEBAA292C8FEFE1080FEBE10801EBEE08002BEAAA2A8BE8122
+9EF6:3FFE28882F8A20082FBE28882F88289429A220002FFE29522FFE40405FFE8924
+9EF7:0010FEFE9210D67CBA0092FEFEAA10FEFE44107C1E44E07C0244AA7CA8288044
+9EF8:0040F87CA840ABFCFA44ABF0FA4422FCFAA822F83AA8E2F80A00A5FCA5540BFE
+9EF9:0440244814500440FFFE0100111009203FF82108254825282928210821282110
+9EFA:1408552836281428FF4449442A827F7C492449245D246B244944494449944B08
+9EFB:1428552436241420FF7E49202A207F3C493449545D546B544988498849144B22
+9EFC:14145512367E1410FF10497E2A527F52497E49525D526B7E4952495249524B46
+9EFD:00003FF8228822883EF802803EF8228822883EF8228822883EF8228A028201FE
+9EFE:1FF0101010101FF001003FF8210821083FF8210821083FF8210A0102010200FE
+9EFF:1FF00000FFFE0844303CDFF012901EF002803EF822883EF822883EFA028201FE
+9F00:01003FF80100FFFE10103FF852941EF002803EF822883EF822883EFA028201FE
+9F01:01003FF80100FFFE04201FF000001FF012903EF822883EF822883EF8028201FE
+9F02:00001FF010101FF01010FFFE00001FF012903EF822883EF822883EF8028201FE
+9F03:01003FF80100FFFE01003FF80100FFFE12903EF822883EF822883EF8028201FE
+9F04:09000FF011007FFC05401930E10E1FF012903EF822883EF822883EF8028201FE
+9F05:20003F7C4844FFC4147C224441001FF012903EF822883EF822883EF8028201FE
+9F06:0000FDFC8554015479DC485079DC4954795421DC1154FD5401DC51504852883E
+9F07:08207E20087EFEC410281E1022285FF692903EF822883EF822883EF8028201FE
+9F08:49202A3E7F4849485DA86B1049285FF612903EF822883EF822883EF8028201FE
+9F09:00003EF822883FF811101FF01110FFFE12903EF822883EF822883EF8028201FE
+9F0A:00107E7C42287EFE40107E7CA2103FF012903EF822883EF822883EF8028201FE
+9F0B:1FF00000FFFE0844303CDFF010101FF001003FF821083FF821083FFA010200FE
+9F0C:00001FF010101FF01010FFFE00001FF010103FF821083FF821083FFA010200FE
+9F0D:00003EF822883FF811101FF01110FFFE01003FF821083FF821083FFA010200FE
+9F0E:0FE008200FE048244FE448244FE440047C7C04400440FC7C2444244444448444
+9F0F:7FFE40028FE408200FE008204FE448244FE440047C7C0440FC7C244444448444
+9F10:7FF81008101E2FE2482A8FE408204FE448244FE440047C7C0440FC7C24444444
+9F11:010001FC01001FF010101FF010105FF450145FF440047C7C0440FC7C24444444
+9F12:00807FFC048019806FE008200FE048244FE448244FE47C7C0440FC7C2444C444
+9F13:08100810FF1008FE08107E1000FC7E44424442447E28422824100F28F0444082
+9F14:08100810FF10081E08107E1000FC7E44424442447E28422824100F28F0444082
+9F15:0810FF7E08107E7C42047E4824381E44E8001FF0282007C01830E18E0C400300
+9F16:01007FFC0920FFFE08200810FF1008FE7E1000FC7E4442487E2824101E28E0C6
+9F17:249014A024940884707C0810FF1008FE7E1000FC7E4442487E2824101E28E0C6
+9F18:0810FF7E08107E7C42447E282418FEE624483C7820083FF820083C7824484448
+9F19:0810FF7E08107F7C41447F2822101F28FFF611101FF012101FF004407FFC0040
+9F1A:0810FF7E08107E7C42047E4824381E44EFF008000FF00800FFFE111014E0181C
+9F1B:0810FF7E08107E7C42447E3824447EA222385424082037FEC0001FF010101FF0
+9F1C:0810FF7E08107E7C42447E3824447FF2092007C0F93E1FF011101FF001087FFC
+9F1D:24A414A487BC440417FC24044FBC90A40810FF7E08107E7C42447E282418FEE6
+9F1E:0810FF7E08107E7C42447E282418FEE611107FFE48228FE401001FF001007FFC
+9F1F:0810FF7E08107E7C42447E3824D47EA204442BA810102FE8C8260FE004407FFC
+9F20:060038F820083EF8200820083FF800002948252821082948252A210A2D663182
+9F21:22081108111000003FF8210821083FF8210821083FF82108210A410A41068002
+9F22:2008CE288228EE2882448244FE82017C92249224DA249224DA4492449394D908
+9F23:2010CE148212EE12821082FEFE10001092109228DA289228DA2892449344D982
+9F24:2020CE108210EEFE82448244FE44004492449228DA289210DA1092289344D982
+9F25:2028CE248224EE2082FE8220FE20003C92349254DA549254DA8892889314D922
+9F26:2000CEFC8224EE2482248224FE5400489280927CDA449244DA449244937CD944
+9F27:2020CE108210EEFE82828284FE40004492489250DA609242DA429242933ED900
+9F28:2020CE20823EEE4282C48328FE10002892449382DA309208DA0492609310D908
+9F29:2040CE408240EEFC82848304FEF4009492949294DA9492F4DA9492049328D910
+9F2A:2010CE108250EE50827C8250FE9000109210927CDA109210DA10921093FED900
+9F2B:2000CE0082FEEE1082108220FE20007C924492C4DB449244DA449244937CD944
+9F2C:2010CE108210EE1082FE8292FE920092929292FEDA929292DA92929293FED982
+9F2D:2010CE108210EE7C82108210FEFE0008920892FEDA089248DA2892089328D910
+9F2E:2000CC0685D8EC4884488488FC9E01C8A848F948A948F89EA880A940FA3EA400
+9F2F:2000CEFE8210EE10827C8224FE2400FE92009200DA7C9244DA449244937CD944
+9F30:2000CE7C8244EE44827C8244FE44007C92449244DA7C9200DA2892249342D982
+9F31:2010CE1082FEEE10827C8210FEFE0000927C9244DA7C9244DA7C92449354D948
+9F32:2000CEFE8292EE1082FE8210FE7C0054927C9254DA7C9210DAFE92109310D910
+9F33:2000CEFE8282EEFE828282FEFE8200FE92149212DAFE9210DA2892289344D982
+9F34:2000CDFE8500ED7E8542857EFD42017EA910F9FEA924F964A918A924FB42A5FE
+9F35:2020CE1082FEEE8282448292FE14001292FE9210DA289228DA2892449344D982
+9F36:2008CC3C85D0ED1C8510857CFD540158A970F954A94CF940AA78A8A8FA2AA446
+9F37:200ECEF08222EE9282448220FE4400F892109224DAFE9210DAFE92289344D982
+9F38:2088CC508400EDFE845085FCFC5403FEA854F9FCA850F8D8A954AA52FA50A450
+9F39:2000CE7C8244EE7C8244827CFE1000FE92829210DAFE9224DA6892109328D944
+9F3A:2000CDFC8524EDFC852485FCFD040000ABFEFAAAAAAAFBFEAAAAAAAAFBFEA622
+9F3B:02001FF010101FF010101FF000003FF821083FF821083FF80000FFFE08201020
+9F3C:10043E0422443E4422443E4400447F4449447F4C49747F440004FF8422044204
+9F3D:10203E2022203E2022F83E2800287F2849287F2849287F2A002AFFCA22464280
+9F3E:10003E00227C3E1022103E1000107F1049FE7F1049107F100010FF9022104210
+9F3F:10003E00227C3E2822283E2800287F2849287F2849287F2A002AFFAA22464280
+9F40:10003E7C22203E2022203E3800287F2849587F4849487F48005AFFEA224A4206
+9F41:10403E4022403EFC22843F0400747F5449547F5449747F540004FF8422284210
+9F42:20207C2044FC7C2445FE7C2400FCFE209324FEA89270FEA80124FE2244A08440
+9F43:20007CFC44847CFC44847CFC0040FEFE9312FE9292AAFE8200FAFE0244148408
+9F44:10103E1022FE3E3822543E9200007F7C49447F7C49447F7C0044FF8022FE4200
+9F45:20207C4044FC7C8444FC7C8400FCFE8492FCFE289224FEFE0020FE5044888506
+9F46:20927D2444927C00447C7C44007CFE0092FEFE929292FEFE0080FE824482847E
+9F47:20207C3C44207CFE44A27CB800E4FE9C9280FEBC92A4FEBC00A4FEBC44A4857E
+9F48:20287CFE44AA7CFE44AA7CFE0000FEFE9280FEBE9280FEFE00A8FEAA44A48532
+9F49:2020FBFE8924F9FC8820FBFE0356F9DCA888FBFEA888FBFE0094F98852A490C2
+9F4A:020001007FFC0440028C7D702550255045488D6610101FF010101FF010102010
+9F4B:0100FFFE02847D78255025484D6420083FF820083FF821082548252849288108
+9F4C:0100FFFE02847D78255025484D6420083FF820083FF820082528294842888C48
+9F4D:0100FFFE02847D78255025484D6420083FF820083FF840083FF824482448FFFE
+9F4E:0100FFFE02847D78255025484D6420083FF820082FE828282FE828284FE88448
+9F4F:0100FFFE02887D7025484D66A0083FF822882EE822882EE822884EE842888FE8
+9F50:020001007FFC0820044003800C603018C8260820082008200820102010202020
+9F51:020001007FFC0820044003801C70E28E2EE822882EE822882EE822885FF88008
+9F52:0100110011F811001100FFFE044024482AA831183FF824482AA831183FF80008
+9F53:082028202F202820FF20142055206B2041207F20552055226B224F22711E0100
+9F54:082028202F202820FF22142455286B3041207F6055A055226B224F22711E0100
+9F55:082028202F20287EFF401480553C6B0441087F10552055406B424F42713E0100
+9F56:100050FC5C085048FE482848AA88D6FE8218FE28AA28AA48D6889F08E2280210
+9F57:0800280C2F702840FF401440557E6B4841487F48554855486B484F4871480188
+9F58:081028102F102828FF28144455AA6B2841287F28552855286B284F4871480188
+9F59:104050405CFC5084FF042AF4AA94D69482F4FE84AA94AA88D6829E82E27E0200
+9F5A:082028202F20283EFF50145055906B1E41107F105510551E6B104F1071100110
+9F5B:102850A85CA850A8FEA829FEAAA8D6A882A8FEA8AAB8AA80D6809E80E2FE0200
+9F5C:100850285C285028FEA828AAAABCD6A882A8FEA8AAA8AAA8D6AA9EBAE2EA0386
+9F5D:102050205C205040FE482884ABFED6828200FEFCAA84AA84D6849E84E2FC0284
+9F5E:080028002F7C2844FF44144455446B44417C7F44550055286B244F4471420182
+9F5F:0800287C2F442844FF44147C55446B4441447F7C554455446B444F4471FE0100
+9F60:080028FC2F242824FF24142455546B4841807F7C554455446B444F44717C0144
+9F61:081028102F102828FF281454558A6B08417C7F04550855286B104F1071080108
+9F62:081028102E1028282828FF54008A49086B7C49047F085D286B104F1079080008
+9F63:082028202F20287CFF44148455746B5441547F54557455546B044F0471280110
+9F64:111009207FFC0400FFFE111029E8C9067FFC04402AA83FF824482AA83FF80008
+9F65:102050205CFC50A4FEA428FCAAA4D6A482FCFE20AA24AA18D6129E6AE3860202
+9F66:0800087C2F442844FF7C144455446B7C41507F52555455486B5441667F420000
+9F67:08007F7C08243E2408447F5409E809007FFC04402AA83FF824482AA83FF80008
+9F68:080028202F4C2844FF44144455446B6C41447F44554455446B444F7C71440100
+9F69:102050105C1050FEFE002844AA82D7008244FE44AA28AA28D6109E28E2440282
+9F6A:0800287C2F442844FF441444557C6B1041107F50555E55506B504F70719E0100
+9F6B:100050FE5C925092FE9228FEAA92D6B282BAFED6AA92AA92D6929E82E2FE0282
+9F6C:080028FC2F102810FF7C142455246BFE41007F00557C55446B444F44717C0144
+9F6D:100050325CCC5088FE8828E8AAAED6AA82AAFEEAAA8AAA8AD68A9E8AE3120222
+9F6E:102050205DFC5020FE502888ABFED60882E8FEA8AAA8AAE8D6A89E08E2280210
+9F6F:100050205CCE5082FE8228EEAA82D68282FEFE28AA28AA28D6489E4AE28A0306
+9F70:104850485C4851FEFE482848ABFED60082FCFE84AA84AAFCD6849E84E2FC0284
+9F71:100051F05CAE50AAFEEA28AAAAAAD6EA82AAFEAAAAB4ABE4D6249E2AE22A0230
+9F72:100E51F05C1050FEFE922892AAFED61082FEFE92AA9AAA96D6FE9E82E28A0284
+9F73:100050FE5C925010FEFE2810AA7CD654827CFE54AA7CAA10D6FE9E10E2100210
+9F74:102050105CFE5044FE2828FEAA88D69082A4FE88AA90AAA2D6849E88E3100260
+9F75:1000507C5C545054FE7C2854AA54D67C8210FEFEAA92AA96D6BE9E82E28A0284
+9F76:100050EE5CAA50AAFEEE2800AA7CD60082FEFE20AA40AA7CD6049E04E2280210
+9F77:100050FE5C825082FEFE2880AABED6908294FEBEAA8AAA88D6BE9E88E308027E
+9F78:104450285C0050FEFE002828AA44D6828200FEFEAAAAAAAAD6AA9EAAE3FE0200
+9F79:082004407FFC0100FFFE04001FF8E0801FFC010009F009007FFC24482AA83FF8
+9F7A:104050405CFE5122FEAA28FAAA42D6948348FEFEAB22AAAAD6FA9E42E2940308
+9F7B:101050105CFE5010FE7C2844AA7CD644827CFE44AA7CAA44D6FE9E28E2440282
+9F7C:108850885DFE5088FEDC29AAAA88D60083FEFE22AAA0AABCD6A09F60E23E0200
+9F7D:104450445DEE5044FEEE2954AA44D600827CFE00AAFEAA10D6549E92E2500220
+9F7E:0F1408127F10497E7E1049287F2852449EFA04807FFE04402AA431143FFC0004
+9F7F:0100010011F8110011001100FFFE00002108210822882448282820083FF80008
+9F80:0820082028202F2228222824FF2800304920496055A0632241224722791E0100
+9F81:0820082028202F7E28402880FF3C0004490849105520634041424742793E0100
+9F82:0800080C28702F4028402840FF7E004849484948554863484148474879480188
+9F83:0800087C28442F442844287CFF4400444944497C554463444144474479FE0100
+9F84:1020102050505E5050885124FE12001093FC9204AA08C68882508E20F2100210
+9F85:10401040507C5E84508451F4FE940094929492F4AA84C6A882928E82F27E0200
+9F86:080008FE28222F2228222822FF4A00444980497E5542634241424742797E0142
+9F87:1008102850285E2850A850AAFEBC00A892A892A8AAA8C6A882AA8EBAF2EA0386
+9F88:100010FC50845E8450FC5084FE8400FC92A292A4AA98C69082888EA4F2C20280
+9F89:100011FC50205E2050FC5044FE4401FE92009200AAFCC68482848E84F2FC0284
+9F8A:0800087C28442F4428442844FF7C001049104950555E635041504770799E0100
+9F8B:100E11F050105EFE50925092FEFE001092FE9292AA9AC69682FE8E82F28A0284
+9F8C:100010FE50825E8250FE5080FEFE009092A492FEAA92C69082FC8E90F31002FE
+9F8D:104008407E7E2440187EFF02007E7E40427E7E40427E7E40427E42404A42443E
+9F8E:00003FFE22202FBC2520223C3F84203C2FA028BC2FA028BC2FA048BC48A2899E
+9F8F:08407F7C1440FF7C22043E7C22403E782242263E08200820FFFE082010202020
+9F90:00807FFE42205FBC4920463C7F84403C5FA050BC5FA050BC5FA050BC52A2911E
+9F91:08407F7C1440FF7C22043E7C22403E782242263E00003FF80200FFFE0860701C
+9F92:08407F7C1440FF7C22043E7C22403E7C2242263E00003FF80000FFFE11102308
+9F93:21102090FBDE2010425E79824BDEC8107BDE4A504BDE7A504BDE4A504A525ACE
+9F94:08407F7C1440FF7C22043E7C22403E782242263E04403FF80440FFFE08201010
+9F95:010006C01830EFEE00001FF010101FF008403E7C1440FF7822083E782242263E
+9F96:88884E4EF8F8A8A84E4EF2F20E0EE8E8AEAEA8A8EEEEA8A8EEEEA8A8AAAAA6A6
+9F97:3FF801007FFE492284143BB82AA83BB808403E7C1440FF7822083E782242263E
+9F98:08403E7C1440FF7822083E782242487EE8E8AEAEF8F80E0EE2E2AEAEE8E8AEAE
+9F99:0420041004100400FFFE048004880488049008A008C0108211822282447E8000
+9F9A:042004107FFC092009C4170420FCC44004403FF804400440FFFE082010102008
+9F9B:010006C01830EFEE00001FF010101FF004400420FFFE0910116021844F0480FC
+9F9C:04003FF820083EF802807A800AFCFE940AD47AA402A47AD40A94FEFC0A8279FE
+9F9D:1080E7FC240427BC20A0FEBE22A237B66AAA66AAA0B626A222BE27A022A2267E
+9F9E:49202A3E7F485DA86B10456E3FF820083EF802807AF80AD8FEA80AD87A8A01FE
+9F9F:040004000FE0102020407FF8A10821083FF8210821083FF821080102010200FE
+9FA0:010002800C603018DFF600003BB82AA83BB800003FF824883FF8248824A82010
+9FA1:08100810141022105D3E80A27F4455907F1000107F1055287F28552455444382
+9FA2:0808081C14F022105D1080907F7C55107F3800347F5455547F92551055104310
+9FA3:080008FC140422045D7C80847F0455FE7F1000927F5455387F54559255504320
+9FA4:0848084A146C22485D4A80EA7F5655207F7E00427F42557E7F425542557E4342
+9FA5:0800087E140822105D7C80C47F44557C7F44007C7F4455447F7C552855444382
+9FA6:112410A410A813FE16025AFA508890F8102011FC112429242524452C40208020
+9FA7:01FC010479FC490449FC484479F848504FFF48804BFC7D0449FC010401FC0104
+9FA8:00003FFC228024402FFC3440244027F8244027F82440244027FC24003FFC0000
+9FA9:04200420FFFF0420240CFF7024403C40087F7E484A487E480848FF8808880908
+9FAA:0820082008207E2008200820FF20085008500E502848288828845B02480087FF
+9FAB:10101010FF1010287E445282537C7E10521052107EFE1010FF10101010101010
+9FAC:100013FE1A02268A22527FFE924212227FFE128216825A8232FA1E02E20A0204
+9FAD:7DFE51227DFE512251227DFE504850487EFC0248564853FE8200024814840902
+9FAE:7FDE514A7CC6514A52527CFC50A450FC7EA402FC564852FE824803FE14840902
+9FAF:10281024282025FE4120B920112411247D28111815105910312A1E2AF2464482
+9FB0:0000000000000100010001000100010011F011001100110011002D00430080FC
+9FB1:00007FFC4004402448244424424441444084414442244414581440047FFC4004
+9FB2:1020101029FE251041FEBD10117C11547D7C1154157C591031FE1E10E2104410
+9FB3:101010107EFC10101010FEFE2448529410107E7C1010101010101E10E1FE0000
+9FB4:00000000000000007FFC00080010032000C00020001000000000000000000000
+9FB5:00F87F0001003FF80100FFFE0200040008003000C00000000000000000000000
+9FB6:010001007FFC01003FF80100FFFE000000000000000000000000000000000000
+9FB7:082008207FFC08200820FFFE0000000000000000000000000000000000000000
+9FB8:01001110092001007FFE40048008000000000000000000000000000000000000
+9FB9:1110092001003FFC010002007FFE082010102008C00600000000000000000000
+9FBA:10001000FE0010007C00440044007C0044007C0054001000FE00100010001000
+9FBB:208827E84812F3DC20084BD2F83E03C0AA52ABD2000000000000000000000000
+9FBC:0040207C204027FE240223FCFA642492210823FC250A21F83908C1F8010801F8
+9FBD:1080108010FC1108561055FC5524992411FC1124112429FC24004554412A822A
+9FBE:08400840087E7F424AA248AA48727EFE4222627254AA4D2288229402220A4004
+9FBF:08200820FFFE0820044008400BF81040304057FC904013F81040104017FE1000
+9FC0:0420FFFE04207F7850485E8665784A487F3000C8FFFE04403FF824482BA83FF8
+9FC1:209010900090FC9003FC78900090789000907BFE48004800489079084A040404
+9FC2:10201040FEFC10847CFC54847CFC548054FE7C8054FE1002FEAA10AE1152100C
+9FC3:00400040F7FC90409250F148914892D4F460904090A090A0F110920804040802
+9FC4:10000BF840882288098850C82108222825100100FFFE05400920111C61080100
+9FC5:21FC102003FEFA2209AC1020118C382054509188162611F8100810D010201010
+9FC6:404020400040FBFE0880108020F830886948A150215022202220245028882104
+9FC7:088008F81110122035FC5044904417FE1044104413FC10441040104011401080
+9FC8:080009FC11042104490409FC1124312051209110111011101208120814041802
+9FC9:08000BFE104020404840084013F8304850489088108810881088108817FE1000
+9FCA:08200820FFFE082008204000202090204120293C11201120E1202120212027FE
+9FCB:204017FE0040FBFC08001BF816083BF855109FFE100013F81208120813F81208
+9FCC:008040402FFE2000800043F84A080BF8120813F8E04022482244244229420080
+9FCD:2080208020FC21082290F86021982626202021FC3C20E22043FE002000200020
+9FCE:00100010FA102110217E401078104F28C92849244944494279024A80447E0000
+9FCF:102010203DFE202041FCBC20102013FEFC40107C108411481450182010D80706
+9FD0:200024FE72285228A0FE74AA52AA53AA79AE52C256827AFE0282AA82AAFE0082
+9FD1:000047FE2040204000400840084013FC1040E040204820442044204027FE0000
+9FD2:08200820FFFE08207FFC02001FF0101011101110111012100280046018106008
+9FD3:08200820FFFE08207FFC04001FF010101FF010101FF010101FF0082010102008
+9FD4:200023FE3C0821E841287DE8900013FEFC0811E81128112815E8180810280010
+9FD5:200020FC7C84448488A47C94549454847FFE548454847C8401041D04E2144408
+9FD6:010001000280044008203018CFE600001FF01010101010101FF010100000FFFE
+9FD7:01000280044008203018C8060BF0089017FE309053F09080110012000000FFFE
+9FD8:10101F101528252825447F44A5BA250025002F7C2544244424442844287C3044
+9FD9:10101F1015FE2510257C7FC4A5442544257C2F28252824282448284A288A3306
+9FDA:20503E502A5C4A544AF4FF484A484A744AD45F624A5C485448545054505C6054
+9FDB:040084FE5E54449205FE3E924AD651BA68D6CE9252D66ABA44D64C92529A2184
+9FDC:480044FE44544092FFFE409272D652BA52D6CA924AD64ABA44D644925F9AC084
+9FDD:40005FFE55545592F5FE5F9248D6C4BAFFD6C8924ED64ABA4AD652925A9A6484
+9FDE:0200E2FE42544A926BFEAA92AAD6AABAEAD6AA922AD62ABA42D642924A9A8484
+9FDF:11203920E120253E25422544FD902510655475546D52A592A192211025502220
+9FE0:120032FEE2542A922BFE2A92FAD62ABA6AD67A926AD6AABAA2D622922A9A2484
+9FE1:0000FEFEAA54AA92FFFE24922AD65FBADAD62F925AD6FFBA0AD6AA92AF9A8884
+9FE2:0010FF10552855287544564456BA75005500557C55447D44D6441444147C1444
+9FE3:0010FF1055FE5510757C564456447544557C552855287D28D648144A148A1506
+9FE4:0050FF50555C555475F456485648757455D45562555C7D54D6541454145C1454
+9FE5:40002EFEEA54AA92ABFEEC92ACD6AABAEAD69A92EAD6AABA9CD6B892D89A8884
+9FE6:51445154FA54525425FEF91AAA0AAAFAAE0AFAEA22AA22A452B44AAA4B0A820A
+9FE7:0400EEFEAA54BA92A4FECA92D1D6AEBAA4D6A492BFD6C4BA8ED684929F9A8084
+9FE8:00007EFE1054FE9291FE569210D6D6BA00D67E924AD64ABA7ED64A924A9A7E84
+9FE9:20003CFE24547E92D3FE7E9252D67EBA2AD6D5927ED642BA7ED642927E9A4284
+9FEA:211010A017FC0080F14816D0116816A8112416A4284047FE0000244422224222
+9FEB:20003FFC40009FF000007FF008107FD055504E507FD04E52554AFFEA0A06F1E2
+9FEC:000000007DFF1111111121113D1165FFA5112511251125113DFF210100000000
+9FED:104010401C7F208121127A1090101054FC521092109111111410181010500020
+9FEE:00803FFE200024442FFE244427FC200027FE284223FC2244424C424080400040
+9FEF:000050807EFE50AA952A384AD11212860C603118C92605407FFC03800D60711C
+9FF0:01082108110817DF810847C8545E17C8244827DFC10947C9410D410A41080108
+9FF1:00000000FDFC11241124112411247DFC11041100110011001D02E10240FE0000
+9FF2:0044FDFF004400007CFF4511441044FE7C120012441228222E42F08441080000
+9FF3:204420823DE2452F49297DAAD56855E97D2A55AC55687D295529B2292AA70040
+9FF4:102010201E7E228225447E28AA182A243E422A812A303E0800040E6070102008
+9FF5:202020203C2045FE48207C20D42055FC7C00542054127D5101451A45E03C4000
+9FF6:204020203DF8450849087DF8D50855087DF8554455487D3001101D48E1864100
+9FF7:102010101E7C220024443E286AFE2A003E7C2A442A443E7C00440E44707C2044
+9FF8:204420823DE2452F49297DAAD56855E97D2A55AC55687D2901291E29E2A74040
+9FF9:202020103CFF4481494A7C28D55256657CC4553C54107C9200921C92E0FE4002
+9FFA:081008207F7C08443E6408547F44104C1E40227E24025402087A1402200A4004
+9FFB:2010CE108210EEFE82208248FE48008892FF92C9DB499249DA4D924A9308D908
+9FFC:2040CE408240EE4782F58255FE55005592559255DA559255DA9592D793A5D900
+9FFD:00007FFE73866DBE718E7DBE73BE7FFE7FFE618E6FB663B66FB66F8E7FFE0000
+9FFE:00007FFE73866DBE718E7DBE73BE7FFE7FFE61866FBE638E6FBE6F867FFE0000
+9FFF:00007FFE73866DBE718E7DBE73BE7FFE7FFE61866FBE638E6FBE6FBE7FFE0000
+A000:000000000000000010101FF010101010101010107C101010082007C000000000
+A001:000003800440000010101FF010107C10121012107C101010082007C000000000
+A002:000000000000000010101FF010107C10121012107C101010082007C000000000
+A003:000000000000000000600050004800403BC004400A400A4004403BC000000000
+A004:0000000000000000139014500C6007C0044004400E4004400440038000000000
+A005:0000038004400000018001600100038004400440038001000D00030000000000
+A006:0000000000000000018001600100038004400440038001000D00030000000000
+A007:0000000000000000071008F009900A800A800A800A80099008F0071000000000
+A008:000000000000000000080008018831680D180300010001000100010000000000
+A009:000003800440000001A0016001200D2003200120012001200D20032000000000
+A00A:000000000000000001A0016001200D2003200120012001200D20032000000000
+A00B:0000000000300040034002C002401A3006000200020002001A00060000000000
+A00C:0000038004400000101011101110111010101FF0101011101110111000000000
+A00D:0000000000000000101011101110111010101FF0101011101110111000000000
+A00E:00000000000004200A500A50042004200420042004200420042003C000000000
+A00F:00000000000000000FE0111011100FE001000700080007000800070000000000
+A010:00000380044000000C700A880988088808A808A808A848882888187000000000
+A011:00000000000000000C700A880988088808A808A808A848882888187000000000
+A012:00000000000000000C700A880988088808880888088848882888187000000000
+A013:000003800440000000603858044008401FC0084004403840034000C000000000
+A014:000000000000000000603858044008401FC0084004403840034000C000000000
+A015:00000000000000001110111011100EE000000000044004400440044000000000
+A016:0000000000000000038004400440055004E004E0055004400440038000000000
+A017:000003800440000010F011001200120012001FF012001200110010F000000000
+A018:000000000000000010F011001200120012001FF012001200110010F000000000
+A019:0000000000000000062005A00460040004F0050007F0050004F0040000000000
+A01A:00000000000000001C18222022402240224023F82240224022201C1800000000
+A01B:000003800440000007D00820105010901110111012101410082007C000000000
+A01C:000000000000000007D00820105010901110111012101410082007C000000000
+A01D:00000000000000000700089008880888089008E0089008880888071000000000
+A01E:0000000000000000082008200FE0082008200380044004400440038000000000
+A01F:0000038004400000082008200FE00820082000001110111011100EE000000000
+A020:0000000000000000082008200FE00820082000001110111011100EE000000000
+A021:0000000000000000082008200FE0082008200000000004400820101000000000
+A022:000003800440000003E0041009D00090009001D000100E100990086000000000
+A023:000000000000000003E0041009D00090009001D000100E100990086000000000
+A024:00000000000000000FE0010001000100010001000100010001000FE000000000
+A025:000000000000000000F01700090014801070148009001700010000F000000000
+A026:000003800440000007C0082008200BA0092009200BA00820082007C000000000
+A027:000000000000000007C0082008200BA0092009200BA00820082007C000000000
+A028:00000000000000001FF0010001001FF0000000001FF0010001001FF000000000
+A029:00000380044000000EE01110111001000100000011101110082007C000000000
+A02A:00000000000000000EE01110111001000100000011101110082007C000000000
+A02B:00000000000000000FE0010009200540038003800540092001000FE000000000
+A02C:00000000000000000FE01010101010100FE00100012001200100010000000000
+A02D:0000038004400000010001000100010001200120012001200D20030000000000
+A02E:0000000000000000010001000100010001200120012001200D20030000000000
+A02F:000000000000000001E0020004E0050005000500050004E0020001E000000000
+A030:00000380044000000860088008800BE008800BE0088008800880070000000000
+A031:00000000000000000860088008800BE008800BE0088008800880070000000000
+A032:0000000000000000030002C00200039002500220022002501B90060000000000
+A033:0000038004400000018001600100016001800160011001600D80036000000000
+A034:0000000000000000018001600100016001800160011001600D80036000000000
+A035:00000000000000000CC00AA00990088008801C800880088022801C8000000000
+A036:00000380044000000030002800241FE022204AA042204AA022201FE000000000
+A037:00000000000000000030002800241FE022204AA042204AA022201FE000000000
+A038:00000000000000000060005000480FC010403FC020403FC010400FC000000000
+A039:000003800440000001C002201220122012E017201A200220022001C000000000
+A03A:000000000000000001C002201220122012E017201A200220022001C000000000
+A03B:00000000000000000000110011000A500A5004500A500A501100110000000000
+A03C:00000380044000000E0011001100115011501F501150115011000E0000000000
+A03D:00000000000000000E0011001100115011501F501150115011000E0000000000
+A03E:000000000000000007C0082011101110082007C00100111011100EE000000000
+A03F:0000000000000000000010101010101010101FF0101010101010101000000000
+A040:00000380044000001110111011101FF01110111011101110092007C000000000
+A041:00000000000000001110111011101FF01110111011101110092007C000000000
+A042:0000000000000000088008900890089008F00890089008900880070000000000
+A043:000003800440000007F008000FF0080007F000800AA00AA00AA0008000000000
+A044:000000000000000007F008000FF0080007F000800AA00AA00AA0008000000000
+A045:000000000000000007F009100FF0091007F0001008100810042003C000000000
+A046:0000000000000000070008A0089008901CA008C01CA008900890072000000000
+A047:00000380044000000920092009200540038000000FE0000000000FE000000000
+A048:00000000000000000920092009200540038000000FE0000000000FE000000000
+A049:000000000000000007F008000FF0080007F0008007F0008007F0008000000000
+A04A:0000000000000000062005A004600400040004000400046005A0062000000000
+A04B:00000380044000000FE0102010200FE0102010200FE0102010200FE000000000
+A04C:000000000000000007F00810081007F00810081007F00810081007F000000000
+A04D:00000000000000C000B0078008800A800A800880078000800680018000000000
+A04E:00000380044000000E0011001150155015F015501150110011000E0000000000
+A04F:00000000000000000E0011001150155015F015501150110011000E0000000000
+A050:000000000000000000C000A00090078008801080108010800880078000000000
+A051:0000038004400000000030182828244822A8212822A824482828301800000000
+A052:0000000000000000000030182828244822A8212822A824482828301800000000
+A053:00000000000000000CC00AA0099008801CA008A008A008A022801C8000000000
+A054:000003800440000008C008A00890008007800890109010900880078000000000
+A055:000000000000000008C008A00890008007800890109010900880078000000000
+A056:00000000000000000380044007C0044007C004400380111011100EE000000000
+A057:0000038004400000010011100920054003800380054009201110010000000000
+A058:0000000000000000010011100920054003800380054009201110010000000000
+A059:000000000000000037D80820145012901290129012901450082037D800000000
+A05A:000000000000000007C008200820082007C011100EE000000100010001000000
+A05B:00000380044000000000007800800D180B200978092009186880187800000000
+A05C:0000000000000000003C0040008C069005BC0490048C0440343C0C0000000000
+A05D:0000000000000000181804200240024002400FF0024002400420181800000000
+A05E:00000000000000000000300C0FF00420024003C0024004200FF0300C00000000
+A05F:000003800440000000000406020A47122AA212422AA24712020A040600000000
+A060:000000000000000000000406020A47122AA212422AA24712020A040600000000
+A061:00000000000000001110111011100EE0000000000FE0000000001FF000000000
+A062:00000380044000000CA00AA009A000200FA000200FA0002001A0006000000000
+A063:00000000000000000CA00AA009A000200FA000200FA0002001A0006000000000
+A064:0000000000000000038014501450145004400440145014501450038000000000
+A065:0000000000000000008000800790089010901090089007900080008000000000
+A066:000003800440000001000920054003800540092001000FE001000FE000000000
+A067:000000000000000001000920054003800540092001000FE001000FE000000000
+A068:00000000000000000EE01110010007C00820111011100100082007C000000000
+A069:00000380044000000640054034D02C10231020D0203007800000078000000000
+A06A:0000000000000000032002A01A68160811881068101803C0000003C000000000
+A06B:0000000000000000314029442548235000603F4000400240014000C000000000
+A06C:0000000000000000304C08500850304C034002C0320C0A100A10320C00000000
+A06D:00000380044000000010019001500D300B000920092029201900010000000000
+A06E:0000000000000000000800C800A8069805800490049014900C80008000000000
+A06F:000000000000000000C018B01688118000900090189016801180100000000000
+A070:0000038004400000002000201820162011A0106001C0022002A002A000000000
+A071:0000000000000000002000201820162011A0106001C0022002A002A000000000
+A072:0000000000000000066005D0044005400540044007C0044015400CC000000000
+A073:0000038004400000019001700110010001000100010011001D00130000000000
+A074:0000000000000000019001700110010001000100010011001D00130000000000
+A075:0000000000000000018001600D00030001000100018001600D00030000000000
+A076:000000000000000003000AC00A300A0002A002A00BE00AA00AA0020000000000
+A077:000003800440000007C009200FE0092007C0010001400150011000E000000000
+A078:000000000000000007C009200FE0092007C0010001400150011000E000000000
+A079:00000000000000001860165011C81040104011F0104011F01040104000000000
+A07A:00000700088000001FC00220021002001FC0020002001FC00200020000000000
+A07B:00000000000000001FC00220021002001FC0020002001FC00200020000000000
+A07C:0000000000000000010001000FE001000100010001000FE00100010000000000
+A07D:00000000000000000E0011141114208420FC20842094249424801B0000000000
+A07E:00000380044000000000044004401FF00280010002801FF00440044000000000
+A07F:00000000000000000000044004401FF00280010002801FF00440044000000000
+A080:0000000000001010145014501290129011101290129014501450101000000000
+A081:0000000000000000038802680E18124022402240224002180268038800000000
+A082:038004400000111011100EE000000100010007C00100010010100FE000000000
+A083:000000000000111011100EE000000100010007C00100010010100FE000000000
+A084:00000000000000001110111011100EE0000001000100111010100FE000000000
+A085:000000000000000003D005300910090009F0090009000910052003C000000000
+A086:000003800440000009C00A2002200E20122012200E2002200A2009C000000000
+A087:000000000000000009C00A2002200E20122012200E2002200A2009C000000000
+A088:0000000000000000010007C009201110115011501110092007C0010000000000
+A089:00000380044000003838454445444444444447C4444444444544393800000000
+A08A:00000000000000003838454445444444444447C4444444444544393800000000
+A08B:0000000000000770088009A00AA00A800BE00A800AA009A00880077000000000
+A08C:000003800440000011501150111011501F50111011501150092007C000000000
+A08D:000000000000000011501150111011501F50111011501150092007C000000000
+A08E:00000000000000006360145813461440634000400C400B4008C0080000000000
+A08F:000003800440000031182928254823883FF82388254829283118010000000000
+A090:000000000000010031182928254823883FF82388254829283118010000000000
+A091:0000000000000000018001600100092009200920092001000D00030000000000
+A092:00000380044000001110092007C001001FF0010007C009201110111000000000
+A093:00000000000011101110092007C001001FF0010007C009201110111000000000
+A094:000000000000000007C00920111012901290129013901450082007C000000000
+A095:0000038004400000155015501110092007C001000100110011000E0000000000
+A096:0000000000000000155015501110092007C001000100110011000E0000000000
+A097:0000000000000000001001900150013001000920092009200100010000000000
+A098:00000000000000000600058004000400058004200710048034480C4800000000
+A099:0000038004400000001030102C10231020D02038204400440044003800000000
+A09A:0000000000000000001030102C10231020D02038204400440044003800000000
+A09B:000000000000000000C030B0088C048004803F80048004800880308000000000
+A09C:00000380044000000240024012480A50046000400C400B4008C0080000000000
+A09D:00000000000000000240024012480A50046000400C400B4008C0080000000000
+A09E:000000000000000009800960091809000180016031182D002300200000000000
+A09F:000000000000000000600050004807C00840124015401240084007C000000000
+A0A0:000003800440000001801160111801000F8811482520250011000F0000000000
+A0A1:000000000000000001801160111801000F8811482520250011000F0000000000
+A0A2:000000000000000003C004200400020001800040012002A0092007C000000000
+A0A3:0000000000000FE008200440028002A0012002A00280044008200FE000000000
+A0A4:00000380044000000020092009200020092009200020062001A0006000000000
+A0A5:00000000000000000020092009200020092009200020062001A0006000000000
+A0A6:000000000000000007C00920155015501110111015501550092007C000000000
+A0A7:0000038004400000111011101010082007C00000082008200820082000000000
+A0A8:0000000000000000111011101010082007C00000082008200820082000000000
+A0A9:000003800440000001000100012009200920090001C001200D10031000000000
+A0AA:000000000000000001000100012009200920090001C001200D10031000000000
+A0AB:00000000000008500850001008500850001008500850031002D0023000000000
+A0AC:000003800440000007C009200FE0092007C001000540155011100EE000000000
+A0AD:000000000000000007C009200FE0092007C001000540155011100EE000000000
+A0AE:000000000000000007C0082016D01290111017D010101390082007C000000000
+A0AF:0000038004400000031002D002300200023002C0030012C00A30060000000000
+A0B0:0000000000000000031002D002300200023002C0030012C00A30060000000000
+A0B1:00000000000000C800A8009800800FF800800FF8008018800680018000000000
+A0B2:000003800440000007C00820145022882128212822881450082007C000000000
+A0B3:000000000000000007C00820145022882128212822881450082007C000000000
+A0B4:0000000000000000000800C800A8109810801090009018900680018000000000
+A0B5:00000000000000001860175012C81240124012401FC012401240124000000000
+A0B6:0000038004400000038004400440044004401FF0044004400440038000000000
+A0B7:0000000000000000038004400440044004401FF0044004400440038000000000
+A0B8:00000000000000001110111011100EE00000010007C0010007C0010000000000
+A0B9:000000000000121011101090121011101090121011101090082007C000000000
+A0BA:000003800440000000C006B0058004C004B014800CC000B00680018000000000
+A0BB:000000000000000000C006B0058004C004B014800CC000B00680018000000000
+A0BC:00000000000000000638054404C404541F5404541F54044434440C3800000000
+A0BD:000000000000000000C000A00090008007800880128012800880078000000000
+A0BE:000003800440000001800160011801C0012001C0010007C00920092000000000
+A0BF:000000000000000001800160011801C0012001C0010007C00920092000000000
+A0C0:000000000000000003C00420081000100010001000100E100990086000000000
+A0C1:000003800440000001000118012401240FE40124012431180D00030000000000
+A0C2:000000000000000001000118012401240FE40124012431180D00030000000000
+A0C3:0000000000000000009000880A880A900AE00090008818880690018000000000
+A0C4:0000038004400000042004200420042007E004200420242014200C2000000000
+A0C5:0000000000000000021002100210021003F00210021012100A10061000000000
+A0C6:00000000000000000388045003E0004001F0024801F018400640018000000000
+A0C7:00000380044000000080008008F008800880008000F018800680018000000000
+A0C8:00000000000000000080008008F008800880008000F018800680018000000000
+A0C9:00000000000000000C200B2008E008000F700880094008800F70080000000000
+A0CA:0000038004400000101010101010082007C00000082008200820082000000000
+A0CB:0000000000000000101010101010082007C00000082008200820082000000000
+A0CC:0000000000000000020002200220022002000FF0020002200220022000000000
+A0CD:00000000000000000380044004401EF008201EF008200920092006C000000000
+A0CE:000003800440000000C000B00480078004800080008000800680018000000000
+A0CF:0000000000000000018000B00480078004800080008000800680018000000000
+A0D0:000000000000000000C000B008800F800880008000800E800980080000000000
+A0D1:00000000000009200AB00AAC092008200FE0082009200AA06AA0192000000000
+A0D2:000003800440000018081608118810681018014009480948041003E000000000
+A0D3:000000000000000018081608118810681018014009480948041003E000000000
+A0D4:00000000000000001808160811881068101802200AA80888041003E000000000
+A0D5:0000038004400000012000A018E0052002200220052018E000A0012000000000
+A0D6:0000000000000000009000500C7002900110011002900C700050009000000000
+A0D7:0000000000000000092005200720090011F01100092007200520090000000000
+A0D8:0000000000000000030012C01230120002200220122012001200020000000000
+A0D9:00000380044000000820282828282828183008200FE008200820082000000000
+A0DA:00000000000000000820282828282828183008200FE008200820082000000000
+A0DB:0000000000000000000002400240181016601180166018100240024000000000
+A0DC:0000038004400000000801883968051823002300050039000100010000000000
+A0DD:0000000000000000000801883968051823002300050039000100010000000000
+A0DE:0000000000000000009000A000C0009000A000C0188016801180100000000000
+A0DF:0000038004400000111011101510092017C0010031002D002300200000000000
+A0E0:0000000000000000111011101510092017C0010031002D002300200000000000
+A0E1:000000000000000010101010082007C00100012031402D802300200000000000
+A0E2:000000000000000011101110082007C001001900150013001000000000000000
+A0E3:0000038004400000001800200040064005C004400440044034200C1800000000
+A0E4:0000000000000000001800200040064005C004400440044034200C1800000000
+A0E5:00000000000000001C1013901170010001C009200920092001C0010000000000
+A0E6:000000000000000011101110111011100110012001C031000D00030000000000
+A0E7:000003800440000009200540139013900540092001000FE001000FE000000000
+A0E8:000000000000000009200540139013900540092001000FE001000FE000000000
+A0E9:00000000000000003FF80100010009C00920092009C0010001003FF800000000
+A0EA:000000000000000007C0082010101FF0101010101FF01010082007C000000000
+A0EB:0000038004400000101010101390145008201450139010101010101000000000
+A0EC:0000000000000000101010101390145008201450139010101010101000000000
+A0ED:0000000000000000030002C0020032380EC803080EC832381A00060000000000
+A0EE:0000000000000000024002401A48164813C81268125802400240018000000000
+A0EF:000003800440000000800C88129012A012C00C80008018800680018000000000
+A0F0:000000000000000000800C88129012A012C00C80008018800680018000000000
+A0F1:000000000000002401A41F74212C212011000F001100210021001F0000000000
+A0F2:000003800440000001E000100C10102011C010200C100010001001E000000000
+A0F3:000000000000000001E000100C10102011C010200C100010001001E000000000
+A0F4:0000000000000000003000280224142008A015202220052008A0004000000000
+A0F5:0380044000001C700380044008203E2008203E200820044003801C7000000000
+A0F6:0000000000001C700380044008203E2008203E200820044003801C7000000000
+A0F7:000000000000008000400FE00820044002800100028004400920111000000000
+A0F8:000003800440000000200020002001E002201F2004201F20022001E000000000
+A0F9:000000000000000000200020002001E002201F2004201F20022001E000000000
+A0FA:000000000000018001402128210811104FE441044FE411102108210800000000
+A0FB:000003800440000010101010082007C000000820082009200100010000000000
+A0FC:000000000000000010101010082007C000000820082009200100010000000000
+A0FD:000000000000000001802148210811100FE401040FE411102508230800000000
+A0FE:000003800440000011101110092007C01110111001001FF001001FF000000000
+A0FF:000000000000000011101110092007C01110111001001FF001001FF000000000
+A100:0000000000000000008832842A84268800F0008832842A842688008000000000
+A101:000003800440000000C004A0029012800C800080188016801180100000000000
+A102:000000000000000000C004A0029012800C800080188016801180100000000000
+A103:000000000100020001000080111011100EE00440054005400440038000000000
+A104:0000038004400000001C0020004C065005D004500450044C34200C1C00000000
+A105:0000000000000000001C0020004C065005D004500450044C34200C1C00000000
+A106:00000000000000000420042072424E4241824272424E04200420042000000000
+A107:0000000000000000110011201120112011001FF81100112011200E2000000000
+A108:0000000003800440000010180828044812881108128804480828101800000000
+A109:0000000000000000000010180828044812881108128804480828101800000000
+A10A:00000000000000000000080C04141A2415441084514432240414080C00000000
+A10B:0000038004400000002000A000A008A00EA009A00020062001A0006000000000
+A10C:0000000000000000002000A000A008A00EA009A00020062001A0006000000000
+A10D:00000000000000000100010007C009200920082008200820082007C000000000
+A10E:000003800440000001800160011801001FF0010031002D002300200000000000
+A10F:000000000000000001800160011801001FF0010031002D002300200000000000
+A110:000000000000000001800160011801001FF00100010031000D00030000000000
+A111:03800440000001C00130010007C0054003800380054007C00100190007000000
+A112:0000000001C00130010007C0054003800380054007C001001900070000000000
+A113:000000000000000018081608118810E81098008003E004900888088800000000
+A114:0000000000000000041008900910071009100890041000100190007000000000
+A115:00000380044000001E20212021C01E8000F0088008F008800088007000000000
+A116:00000000000000001E20212021C01E8000F0088008F008800088007000000000
+A117:00000000000000000FE01010101010100FE0010001F00100010000F000000000
+A118:000003800440000001800160011801001FF00100050005000500010000000000
+A119:000000000000000001800160011801001FF00100050005000500010000000000
+A11A:000000000FE0000001800160011801001FF00100010031000D00030000000000
+A11B:00000380044000000080008027F02080208027F0008018800680018000000000
+A11C:00000000000000000040004013F81040104013F800400C40034000C000000000
+A11D:00000000000000000008018801680118010001001FF001000100010000000000
+A11E:000003800440000008C004B024801880008007F0008000800680018000000000
+A11F:000000000000000008C004B024801880008007F0008000800680018000000000
+A120:00000000000000000850085007900010079008500850031000D0003000000000
+A121:00000000000000000FE0001003900410041004100410039000100FE000000000
+A122:00000380044000000820082000001FE0001000101FE000000840084000000000
+A123:00000000000000000820082000001FE0001000101FE000000840084000000000
+A124:0000000000000FE0001000100F9000100F9000100F90001000100FE000000000
+A125:0000000000000000711C092009201010600C1010092009200920701C00000000
+A126:03800440000000100FF000100FF000100FF00010031002D00230020000000000
+A127:00000000000000100FF000100FF000100FF00010031002D00230020000000000
+A128:000000000000000008040AC40AB4088C0A800A8008804A802A80188000000000
+A129:0000000000000000018001600100018001600100018001600D00030000000000
+A12A:000003800440000001801160111811800160011831802D602318200000000000
+A12B:000000000000000001801160111811800160011831802D602318200000000000
+A12C:00000000000000003C78410441043C78410441043C78410441043C7800000000
+A12D:000003800440000012480A88070807080A8812480F8802080788007800000000
+A12E:000000000000000012480A88070807080A8812480F8802080788007800000000
+A12F:0000000000000000030002C00230030002C0023002000F801240124000000000
+A130:00000000000000000E00117011801100112011201100118011700E0000000000
+A131:000003800440000007C00820101010101010101010101010082007C000000000
+A132:000000000000000007C00820101010101010101010101010082007C000000000
+A133:000000000000000007F008080808080807F000401650155014D0040000000000
+A134:000003800440000001800D600B000928092829F8192801280D00030000000000
+A135:000000000000000001800D600B000928092829F8192801280D00030000000000
+A136:000000000000000018081608118810E810980080049004900490008000000000
+A137:000003800440000010C008B00480108008800480008000800680018000000000
+A138:000000000000000010C008B00480108008800480008000800680018000000000
+A139:000000000000000018881688118810E8109800800FF8008000800FF800000000
+A13A:0000038004400000210821083FF82108210801000FE0010001000FE000000000
+A13B:0000000000000000210821083FF82108210801000FE0010001000FE000000000
+A13C:0000000000000000010021083FF82108010007C0092011101110111000000000
+A13D:00000000000000001FF0010007C0092009200920092007C001001FF000000000
+A13E:0380044000001FF00100311C0D6403840D64311C01001FF001001FF000000000
+A13F:0000000000001FF00100311C0D6403840D64311C01001FF001001FF000000000
+A140:000000000FE001000FE001003908270821C8213801000FE001000FE000000000
+A141:00000380044000000FE001000380054009200920092009200540038000000000
+A142:00000000000000000FE001000380054009200920092009200540038000000000
+A143:00000000000000000FE001000FE0082004400280010002800440082000000000
+A144:000000000000000001800140012001000100092007C000000920092000000000
+A145:0000038004400000111011101FF011101110092007C000000920092000000000
+A146:0000000000000000111011101FF011101110092007C000000920092000000000
+A147:000000000000031002D002300F800200020010400F8000001240124000000000
+A148:00000380044000000EE0010002800440054005400440028001000EE000000000
+A149:00000000000000000EE0010002800440054005400440028001000EE000000000
+A14A:000000000000000008600FD02848184003C0044008400840044003C000000000
+A14B:0000000000001FC0104008800510051003F005100510088010401FC000000000
+A14C:0000038004400000111011101110092007C00100110011001100010000000000
+A14D:0000000000000000111011101110092007C00100110011001100010000000000
+A14E:00000000000000000F8010801088088807F808881088108010800F8000000000
+A14F:000003800440000011101110111011101110111011101110092007C000000000
+A150:000000000000000011101110111011101110111011101110092007C000000000
+A151:0000000000000000008000801808160811881068101800000490049000000000
+A152:0000038004400000002008200FE008200020002008200E2009A0006000000000
+A153:0000000000000000002008200FE008200020002008200E2009A0006000000000
+A154:000000000000000003800440044009200920082008200920092006C000000000
+A155:000003800440000001800160210817D0111017D0210801000D00030000000000
+A156:000000000000000001800160210817D0111017D0210801000D00030000000000
+A157:00000000000000000C60125013C812400C4000400C400B4008C0080000000000
+A158:00000380044000000C60125012480C4000401FF80040074004C0040000000000
+A159:00000000000000000C60125012480C4000401FF80040074004C0040000000000
+A15A:0000000000000000188824A824A824A818A800F000A018A006A0018000000000
+A15B:0000000000000000004007F008400FF0084007F000400E4009C0080000000000
+A15C:0380044000000400099012501250125011900810031002D00230020000000000
+A15D:0000000000000400099012501250125011900810031002D00230020000000000
+A15E:0000000004000800101014501450111011100810031002D00230020000000000
+A15F:0000038004400000183024282424242019E0022004200420022001E000000000
+A160:0000000000000000183024282424242019E0022004200420022001E000000000
+A161:00000000000000000660095829402940264010400FC00040034000C000000000
+A162:00000000000000000000088008800520052003E0052005200880088000000000
+A163:00000380044000000120012001200120012001C00100111011100FE000000000
+A164:00000000000000000120012001200120012001C00100111011100FE000000000
+A165:00000000000000000FE01010101010100FE001001FF001001FF0010000000000
+A166:00000380044000000FE01010101010100FE001001F2001201F20010000000000
+A167:00000000000000000FE01010101010100FE001001F2001201F20010000000000
+A168:0000000000000000098011601118090001001FF001001FF00100010000000000
+A169:0000038004400000018001600118010001001FF001001FF00100010000000000
+A16A:0000000000000000018001600118010001001FF001001FF00100010000000000
+A16B:0000000000000000018001402128210811100FE001000FE01110210821080000
+A16C:000000000000000001800140012001001FF001000FE010102108210800000000
+A16D:000003800440000011101110092007C001001900150013401040018000000000
+A16E:000000000000000011101110092007C001001900150013401040018000000000
+A16F:000000000000046025582546044064401C4000400C400B4008C0080000000000
+A170:00000000000000000010031002D0023002001FC802081FC80200020000000000
+A171:000003800440000000080188016801180D000B80296019180100010000000000
+A172:000000000000000000080188016801180D000B80296019180100010000000000
+A173:00000000000000000FE008200440038004400820018001400500030000000000
+A174:000003800440000003800540054035482F4825E8255805400540038000000000
+A175:000000000000000003800540054035482F4825E8255805400540038000000000
+A176:0000000000000000223055285524222008201420142009A00160010000000000
+A177:000003800440000000C022B0228C088008800080188016801180100000000000
+A178:000000000000000000C022B0228C088008800080188016801180100000000000
+A179:03800440000001800540030000000EE00100028001000EE00000018005400300
+A17A:000001800540030000000EE00100028001000EE0000001800540030000000000
+A17B:0000000000000000000020C412A8118808100FF0081010C812A8218400000000
+A17C:00000000000003600458334640403340044003401840164011C0100000000000
+A17D:0000000000000000006000500048004023C8244808400840244823C800000000
+A17E:000003800440000000900A900A900A9000F00E90009004900290019000000000
+A17F:000000000000000000900A900A900A9000F00E90009004900290019000000000
+A180:000000000000000000C000A00090008007A008C0118012800C80078000000000
+A181:000003800440000000E0011001100710059015500D300110011000E000000000
+A182:000000000000000000E0011001100710059015500D300110011000E000000000
+A183:00000000000000000600058004000798046005C00640078034000C0000000000
+A184:0380044000000660055014C80C600050004001F00C400B4008C0080000000000
+A185:0000000000000660055014C80C600050004001F00C400B4008C0080000000000
+A186:000000000000000001800160011817C0110017C001000D000B00080000000000
+A187:00000380044000001D8003600118010003001D00010031000D00030000000000
+A188:00000000000000001D8003600118010003001D00010031000D00030000000000
+A189:000000000000000008E00910091009500950095009500910091008E000000000
+A18A:00000000000000000700089008900FF0089008900FF008900890070000000000
+A18B:0380044000003E60415808463E40084041403E4000400E4009C0080000000000
+A18C:0000000000003E60415808463E40084041403E4000400E4009C0080000000000
+A18D:000000000000000024C018B0008C248018800080188016801180100000000000
+A18E:0000038004400000018001600D00030001000D00030001000D00030000000000
+A18F:0000000000000000018001600D00030001000D00030001000D00030000000000
+A190:000000000000000031800D60031831000D00030031002D002300200000000000
+A191:000000000000000000C000B000800A800A800A80008000800680018000000000
+A192:03800440000012C00CB0008012800C80008012800C8000801C80038000000000
+A193:00000000000012C00CB0008012800C80008012800C8000801C80038000000000
+A194:000000000000000000600A580A400A40004011400E400040034000C000000000
+A195:000003800440000000C014B01480148000E01C90009000900680018000000000
+A196:000000000000000000C014B01480148000E01C90009000900680018000000000
+A197:000000000410041003E018881688118810E81098008003E00490049000000000
+A198:0380044000000820082007C001100FF0110011000FF0010007C0082008200000
+A199:000000000820082007C001100FF0110011000FF0010007C00820082000000000
+A19A:000000000000000017D0082017D0101010101010082007C010100FE000000000
+A19B:038004400000038004400440038031102D10231021D021300380054005400000
+A19C:0000000001C00220022001C018881688118810E8109801C002A002A000000000
+A19D:0000000000000000089007100010031002D00230020007000A800A8000000000
+A19E:000000000000000007000880088008800B900AD00AB008800880070000000000
+A19F:0000038004400000008007900890108010901090108008900790008000000000
+A1A0:0000000000000000008007900890108010901090108008900790008000000000
+A1A1:000000000000000007800840102000A800A800A800701C20132010C000000000
+A1A2:0380044000000EE001000280044004400FE0044005400540028001000EE00000
+A1A3:000000000EE001000280044004400FE0044005400540028001000EE000000000
+A1A4:000000000000000027C828281010183017D0101011101110082007C000000000
+A1A5:000003800440000001000124012401F801200124012431F80D20032000000000
+A1A6:000000000000000001000124012401F801200124012431F80D20032000000000
+A1A7:000000000000000027C828281010183017D0101010101010082007C000000000
+A1A8:03800440000007C0082010101E1011D0103011D01E101010082007C000000000
+A1A9:00000000000007C0082010101E1011D0103011D01E101010082007C000000000
+A1AA:000000000000000007C008201010101010101FF010101010082007C000000000
+A1AB:00000000000001800160011801001FF001001FF001001D001300100000000000
+A1AC:000003800440000004F00900090004800070048009000900090004F000000000
+A1AD:000000000000000004F00900090004800070048009000900090004F000000000
+A1AE:00000000000000000FE0101010100FE00100090008E00100090008E000000000
+A1AF:000003800440000007C00820101010101010101010101450082017D020080000
+A1B0:000000000000000007C00820101010101010101010101450082017D020080000
+A1B1:00000000000000000110011000E00040034002C0020007000880088000000000
+A1B2:0000038004400000111011101110092007C00100390027002100210000000000
+A1B3:0000000000000000088808880888049003E000801C8013801080108000000000
+A1B4:000000000000000001C0022006300528042004200420042014A00C6000000000
+A1B5:000003800440000002C01AB0168C538032800280188016801180100000000000
+A1B6:000000000000000002C01AB0168C538032800280188016801180100000000000
+A1B7:0000000000000000001001900170010031482D4823C821780140010000000000
+A1B8:000003800440000000400440044004400440044000400C40034000C000000000
+A1B9:000000000000000000400440044004400440044000400C40034000C000000000
+A1BA:000000000000000007C009201110111011101FF011101110092007C000000000
+A1BB:00000000000000000020022002200AA008A008A00020062001A0006000000000
+A1BC:00000380044000000040044004400440004004400A400A400640098000000000
+A1BD:00000000000000000040044004400440004004400A400A400640098000000000
+A1BE:00000000000000000020062009200920092006200020062001A0006000000000
+A1BF:0000000000000000102010281028102010281FE8102010281028102000000000
+A1C0:00000380044000000C200A2009200820082008200820092008A0086000000000
+A1C1:00000000000000000C200A2009200820082008200820092008A0086000000000
+A1C2:00000000000000C000B0188C23E0188023E0188000800E800980080000000000
+A1C3:000005500550001003D00430081008000800080008000810042003C000000000
+A1C4:000003800440000001800160011803800540054013901110092007C000000000
+A1C5:000000000000000001800160011803800540054013901110092007C000000000
+A1C6:0000000000000000044004400FE01450244824480FE014502448238800000000
+A1C7:0000000000000000145015501110082007C001000FE001000900060000000000
+A1C8:000003800440000001800160010007C00920092007C001000D00030000000000
+A1C9:000000000000000001800160010007C00920092007C001000D00030000000000
+A1CA:000000000000000003800540054009200FE009200FE00920092006C000000000
+A1CB:0000038004400000042009200920082004200020062005A00460040000000000
+A1CC:0000000000000000042009200920082004200020062005A00460040000000000
+A1CD:00000000000000001808170810E81018010001000000111011100EE000000000
+A1CE:000000000000000007C00820129012901010101011101110082007C000000000
+A1CF:00000380044000001110111011100EE004400440054005400440038000000000
+A1D0:00000000000000001110111011100EE004400440054005400440038000000000
+A1D1:000000000000100408081C10222049404880494022201C100808100400000000
+A1D2:0000038004402008111009200440028001000280044009201110200800000000
+A1D3:0000000000002008111009200440028001000280044009201110200800000000
+A1D4:000000000000000010841084088807F000800C800B8008806A801A8000000000
+A1D5:000003800440000018081608118810E81098008000800000041003E000000000
+A1D6:000000000000000018081608118810E81098008000800000041003E000000000
+A1D7:000000000000000018081608118810E810980080008006800580040000000000
+A1D8:000003C00420000003C00420040004000200018000400020042003C000000000
+A1D9:000000000000000003C00420040004000200018000400020042003C000000000
+A1DA:00000000000000000F0010802048004800480078004838482648218000000000
+A1DB:000007C00820000003C00420081001100110011000100E100990086000000000
+A1DC:000000000000000003C00420081001100110011000100E100990086000000000
+A1DD:00000000000000000008018801680118010007C02108210810100FE000000000
+A1DE:000000000000000007C0092011101110010007C011101110092007C000000000
+A1DF:0000038004400000145014501390082007C00100010001000900060000000000
+A1E0:0000000000000000145014501390082007C00100010001000900060000000000
+A1E1:000000000000000001880168011801001FF001002548254810100FE000000000
+A1E2:000000000000000014501390082007C00000000007C008201390145000000000
+A1E3:000003800440000010101010082007C00000000007C008201010101000000000
+A1E4:000000000000000010101010082007C00000000007C008201010101000000000
+A1E5:00000000000007C008201010145013901010139014501010082007C000000000
+A1E6:00000000000000000000406020A0112C0A3004300A30113020AC406000000000
+A1E7:00000380044000000000406C20B011300A2C04200A2C113020B0406C00000000
+A1E8:00000000000000000000406C20B011300A2C04200A2C113020B0406C00000000
+A1E9:00000000000007C008201290129010101FF0101011101110082007C000000000
+A1EA:000000000000000044444444444444443BB811101550155011100EE000000000
+A1EB:000003800440000031000D08011031200D400180010031000D00030000000000
+A1EC:000000000000000031000D08011031200D400180010031000D00030000000000
+A1ED:0000000000000000000008200820082000001FF0000001000100010000000000
+A1EE:00000000000000000180016001180100011001F031102D002300200000000000
+A1EF:0000038004400000018001600100090009000900010001000D00030000000000
+A1F0:0000000000000000018001600100090009000900010001000D00030000000000
+A1F1:000000000000000001800960091809000100010031002D002300200000000000
+A1F2:00000000000000E0191005500350031003F0031003500550191000E000000000
+A1F3:0000038004400000101010101FF010101010101010101010082007C000000000
+A1F4:0000000000000000101010101FF010101010101010101010082007C000000000
+A1F5:000000000000000007C008201010145017D0145014501390082007C000000000
+A1F6:0000038004400000101010101FF010101010101010101450082017D020080000
+A1F7:0000000000000000101010101FF010101010101010101450082017D020080000
+A1F8:0000000000000000040005E0040005E0040005E0040004600580060000000000
+A1F9:000003800440000001C00220022004101F100410041004900490036000000000
+A1FA:000000000000000001C00220022004100F100410041004900490036000000000
+A1FB:0000000000001FF01010092005400280010002800540092010101FF000000000
+A1FC:0000038004400000000801880168011831002D08238821682118010000000000
+A1FD:0000000000000000000801880168011831002D08238821682118010000000000
+A1FE:0000000000000000010031182928254823882388254829283118010000000000
+A1FF:0000000000000000038002601218124012401E40124012181260038000000000
+A200:0000000003800440000010180828044802881FF8028804480828101800000000
+A201:0000000000000000000010180828044802881FF8028804480828101800000000
+A202:00000000000000000180096009180900011001F031102D002300200000000000
+A203:000003800440000000601158114011400440047004480048034800C000000000
+A204:000000000000000000601158114011400440047004480048034800C000000000
+A205:0000000001800160010003800540038001000D00030007C00820082000000000
+A206:0000000000000000031002D01E300200020003C002001E000200020000000000
+A207:038004400000180006C000B018800680008018E0069000900690018000000000
+A208:000000000000180006C000B018800680008018E0069000900690018000000000
+A209:000000000000030002C0023002000FF01200120012000FF00200020000000000
+A20A:0000000000000000044004401390111011100EE0044004400440038000000000
+A20B:0000038004400000082008200820082000000000010001000100010000000000
+A20C:0000000000000000082008200820082000000000010001000100010000000000
+A20D:0000000000000000101010101010082007C00000111011101110111000000000
+A20E:0000000000000000111011101110092007C0010001001FF00100010000000000
+A20F:000003800440000000101A5016501250135012D00010031000D0003000000000
+A210:00000000000002101A5016501250135012D002100010031000D0003000000000
+A211:000000000000000003E004900490008000800080188016801180100000000000
+A212:03800440000000400640054004401F40044014400C400040034000C000000000
+A213:0000000000000020032002A002200FA002200A200620002001A0006000000000
+A214:00000000000007C008201010101010100C601010111011100D60010000000000
+A215:0000038004400000002008A005200520052008A00020062001A0006000000000
+A216:0000000000000000002008A005200520052008A00020062001A0006000000000
+A217:00000380044000000F6010D01648094016401040164009401640004000000000
+A218:00000000000000000F6010D01648094016401040164009401640004000000000
+A219:00000000000000000400040004001C0816081188106810380020002000000000
+A21A:0000000000000000020802080208020803F8020802081A081608100800000000
+A21B:03800440000007E00810080007E00010081007E0008007F0008007F000800000
+A21C:00000000000007E00810080007E00010081007E0008007F0008007F000800000
+A21D:000000000000000021382140218021800180014031382D002300200000000000
+A21E:000000000000000008400840084000400C40034000C001E00210021000000000
+A21F:00000380044000001830244804400440044004400FE014502448238800000000
+A220:00000000000000001830244804400440044004400FE014502448238800000000
+A221:000000000FE010101110111010100FE001001FF001001FF00500030000000000
+A222:00000000000000000180016031082D0823882168211801000D00030000000000
+A223:000003800440000000200020002000200020082008200E2009A0086000000000
+A224:000000000000000000200020002000200020082008200E2009A0086000000000
+A225:00000000000000000840084008400840004000400C400B4008C0080000000000
+A226:00000000000000000AC00AB000801F8000800A800A8000800680018000000000
+A227:0000038004400000111011101010101011101110101010101110111000000000
+A228:0000000000000000111011101010101011101110101010101110111000000000
+A229:000000000000000019602558244027C02440254025401840034000C000000000
+A22A:0000000000000000000809881568151815000F00050009001100010000000000
+A22B:038004400000183006D0011006D018300000183006D0011006D0183000000000
+A22C:000000000000183006D0011006D018300000183006D0011006D0183000000000
+A22D:0000000000000000183006D0011006D01830010001001FF00100010000000000
+A22E:0380044000000FE01010101010100FE000000FE01010101010100FE000000000
+A22F:0000000000000FE01010101010100FE000000FE01010101010100FE000000000
+A230:000003800440000006183D944472441024101C102410441044103C1000000000
+A231:000000000000000006183D944472441024101C102410441044103C1000000000
+A232:000000000000000003E00410041007F00410051006100C10141003E000000000
+A233:0000038004400000186016581040104010401FC0124012401240124000000000
+A234:0000000000000000186016581040104010401FC0124012401240124000000000
+A235:0000000000000000010C01100120012001E0012031202D10230C200000000000
+A236:0380044001000FE0111011100FE0210821080FE0111011100FE0010000000000
+A237:0000000001000FE0111011100FE0210821080FE0111011100FE0010000000000
+A238:0000000000000000000007C008200820082007C0010007C00920092000000000
+A239:0000000000000000000007C009200FE0092007C0010007C00920092000000000
+A23A:03800440000003E004100410041003E00080038002000F801240124000000000
+A23B:00000000000003E004100410041003E00080038002000F801240124000000000
+A23C:000000000000000000780080038004401E380440038000800080007800000000
+A23D:0380044000000070008000900790088012701200127008800790009000800070
+A23E:0000007000800090079008801270120012700880079000900080007000000000
+A23F:00000000000000000FB8104020A020A020B820A020A020A010400FB800000000
+A240:000000000000000008202AA81AB0193018301AB01AB02928082007C000000000
+A241:0000000003800440000006E0010002C002000FE0020002C0010006E000000000
+A242:0000000000000000000006E0010002C002000FE0020002C0010006E000000000
+A243:00000000000000000410041003E0008007F0008007F0108010800F0000000000
+A244:00000380044000001410141014101590169014901090109008A007C000000000
+A245:00000000000000001410141014101590169014901090109008A007C000000000
+A246:000000000000000000000E1009900870000000000E1009900870000000000000
+A247:0380044000000100311829282448228821082288244829283118010000000000
+A248:0000000000000100311829282448228821082288244829283118010000000000
+A249:0000000000001FF0004007C008400840084007C008400840084007C000000000
+A24A:0000000000000000004009400940094000400F4000400C40034000C000000000
+A24B:0000038004400000003000400090039002F00280028002401A30060000000000
+A24C:0000000000000000003000400090039002F00280028002401A30060000000000
+A24D:0000000000000000070008A008A0088008F0088008A008A00880070000000000
+A24E:000000000000000010C020B0248C22801180008007E008800880070000000000
+A24F:000003800440000010C020B0248C228011800080008018800680018000000000
+A250:000000000000000010C020B0248C228011800080008018800680018000000000
+A251:000000000000000012C022B0248C228011800280028018800680018000000000
+A252:00000000000000002288228822881C7000000820082008200440038000000000
+A253:000003800440000001E00200040004000400040004000400020001E000000000
+A254:000000000000000001E00200040004000400040004000400020001E000000000
+A255:00000000000000001110111011100EE000000380044004400440038000000000
+A256:00000000000000000FC0002007A00820072000A00F20002000200FC000000000
+A257:0000038004400000018001600900050003000100010001000D00030000000000
+A258:0000000000000000018001600900050003000100010001000D00030000000000
+A259:0000000000000000000030182828244822882108228824482828301800000000
+A25A:0380044000000920092007C00FE01110111011100FE007C00920092000000000
+A25B:0000000000000920092007C00FE01110111011100FE007C00920092000000000
+A25C:0000000000000000018031602D1823002100010031002D002300210000000000
+A25D:00000380044000000180056005180500014009400540131011100FE000000000
+A25E:00000000000000000180056005180500014009400540131011100FE000000000
+A25F:000000000000000001800160110811087D3E1108110801000D00030000000000
+A260:0000000000000000202020203828262821A820702020202010400F8000000000
+A261:000003800440000018881688118810E810980080008006800580040000000000
+A262:000000000000000018881688118810E810980080008006800580040000000000
+A263:0000000000000000008008E008903E8808880888009018E00680018000000000
+A264:00000000000000000FE0101024482288010001002288244810100FE000000000
+A265:0380044000000380044005400540044007C00440028001000280044000000000
+A266:0000000000000380044005400540044007C00440028001000280044000000000
+A267:00000000000000001C70028001000100010001000100010002801C7000000000
+A268:0000038004400000038004400440044007C0082009200920082007C000000000
+A269:0000000000000000038004400440044007C0082009200920082007C000000000
+A26A:00000000000000000088029002A002C012E00C900090189006E0018000000000
+A26B:00000380044000000020022002200FA0022002200020062001A0006000000000
+A26C:00000000000000000020022002200FA0022002200020062001A0006000000000
+A26D:00000000000000000E00110011001F2011501FD011501F2011000E0000000000
+A26E:0000000000000000098011601118090007000900110011000900010000000000
+A26F:0000038004400000118011600918070009001100110001000D00030000000000
+A270:0000000000000000118011600918070009001100110001000D00030000000000
+A271:00000000000000000050035002D002700240024002000F801240124000000000
+A272:000003800440000001C002A003E002A031C02C8023C002200490049000000000
+A273:000000000000000000E0015001F0015018E0164011E001100248024800000000
+A274:000000000000000000E001100110011018E0164011E001100248024800000000
+A275:0000000000000000098015601518090001001FF001001FF00100010000000000
+A276:000003800440000001801960051813002B002B00130005001900010000000000
+A277:000000000000000001801960051813002B002B00130005001900010000000000
+A278:000000000000000001001FE00910151009101FE0010007C00920092000000000
+A279:00000000000000000F00103810400880078008801040103810000F0000000000
+A27A:000003800440000007C00820139014501450145014501390082007C000000000
+A27B:000000000000000007C00820139014501450145014501390082007C000000000
+A27C:0000000000000000000020201040089005280228052808901040202000000000
+A27D:00000380044000000C300B2808E4082008201C202A202A202A20082000000000
+A27E:00000000000000000C300B2808E4082008201C202A202A202A20082000000000
+A27F:0000000000000000038004400E4004400E400440038004400920092000000000
+A280:0000000000000000022002200E240BA42A741A2C02A002A0022001C000000000
+A281:000003800440000018081608118810681018000007E00000000007E000000000
+A282:000000000000000018081608118810681018000007E00000000007E000000000
+A283:0000000000000000180816081188106810180000042004200420042000000000
+A284:00000380044000000E70018001800250025002500180058002400D3000000000
+A285:00000000000000000E70018001800250025002500180058002400D3000000000
+A286:00000000000001C001300F8001400F4001400F80010003800540054000000000
+A287:00000380044000000710089008A007C0008003E000800BE00880070000000000
+A288:00000000000000000710089008A007C0008003E000800BE00880070000000000
+A289:0000000000000000000004400440028002A001200AA006800640054000000000
+A28A:038004400000180006C000B01888068000801880068003E00490049000000000
+A28B:00000000180006C000B018880680008018800680008003E00490049000000000
+A28C:0000000000000000018001600118014001401D10139011700100010000000000
+A28D:00000000000011101110092007C00100150015001F0015001500010000000000
+A28E:00000380044000000440044004401390111011100EE004400AA00AA000000000
+A28F:00000000000000000440044004401390111011100EE004400AA00AA000000000
+A290:000000000000000003D00430081009000900090009000810042003C000000000
+A291:00000380044000001440144014401FF814401440144001F0004001F000000000
+A292:00000000000000001440144014401FF814401440144001F0004001F000000000
+A293:000000000000000001801560151815001FE01500150001000100010000000000
+A294:000000000000000801881D6803180B000B7003801DA001A00180017000000000
+A295:0000038004400000007807800880107814801480107808800780007800000000
+A296:0000000000000000007807800880107814801480107808800780007800000000
+A297:00000000000000000440044004401390111011100EE0000000000EE000000000
+A298:00000380044000000380044004400E40044004400E4004400440038000000000
+A299:00000000000000000380044004400E40044004400E4004400440038000000000
+A29A:0000000000000000010001180124013C012401FC012431180D00030000000000
+A29B:000000000000000001000280044008200FE001000280044008200FE000000000
+A29C:00000380044000000804087408AC09200A200C200A20692058A0406000000000
+A29D:00000000000000000804087408AC09200A200C200A20692058A0406000000000
+A29E:00000000000000000FE0101010100FE0101010100FE0101010100FE000000000
+A29F:0000038004400000018001600118010017D01110111017D00100010000000000
+A2A0:0000000000000000018001600118010017D01110111017D00100010000000000
+A2A1:00000000000000400C400B4008C008000BE00A20094008800940022000000000
+A2A2:0000000000000000070008A008A008C0088008A008A008C00880070000000000
+A2A3:00000000038004400000064001C0064001C00000064001C0064001C000000000
+A2A4:00000000000000000000064001C0064001C00000064001C0064001C000000000
+A2A5:000000000000000007C00820111011100000000007C008201110111000000000
+A2A6:0000000003800440000060305054489405180210051408941058203000000000
+A2A7:0000000000000000000060305054489405180210051408941058203000000000
+A2A8:0000000000000248015000E001500248034012C00A8007000A80124000000000
+A2A9:000000000380044000000440044002800280010002800A800840074000000000
+A2AA:000000000000000000000440044002800280010002800A800840074000000000
+A2AB:000000000000000000F00900090000F00900090000F00900090000F000000000
+A2AC:000003800440000003C0240C2410022021E022200410240C240003C000000000
+A2AD:000000000000000003C0240C2410022021E022200410240C240003C000000000
+A2AE:00000000000000001860165011C8104012401240124010401040104000000000
+A2AF:0000038004400000030002C002300200020002001FC002000200020000000000
+A2B0:0000000000000000030002C002300200020002001FC002000200020000000000
+A2B1:0000000000000FE00820044002800280010002800280044008200FE000000000
+A2B2:0000000000001E0811CC103A1188114811081108110815085308300000000000
+A2B3:0000038004400000038004400450045004500460044004400440038000000000
+A2B4:0000000000000000038004400450045004500460044004400440038000000000
+A2B5:0000000000000000030002C00230020002000F8010401FC010400F8000000000
+A2B6:000000000000000007C00820109016901190109016901190082007C000000000
+A2B7:000003800440000007C00820101011901150111015101310082007C000000000
+A2B8:000000000000000007C00820101011901150111015101310082007C000000000
+A2B9:000000000000000007800840132802A802280A3006201C20132010C000000000
+A2BA:03800440000001C00130010001C0012007C00900070001001900070000000000
+A2BB:00000000000001C00130010001C0012007C00900070001001900070000000000
+A2BC:00000000000000000C6002800100028002800440044009200920092000000000
+A2BD:000000000000000002200220022802280F282AE81A380228022801C000000000
+A2BE:000003800440000001C00220022802280F282AE81A380228022801C000000000
+A2BF:000000000000000001C00220022802280F282AE81A380228022801C000000000
+A2C0:0000000000000000071008900890089008901FF0089008900890071000000000
+A2C1:000003800440000007C00820139010501390105013901010082007C000000000
+A2C2:000000000000000007C00820139010501390105013901010082007C000000000
+A2C3:00000000000000001110111011100EE0000004401550155011100EE000000000
+A2C4:000000000000000011C42224222412240E3C122422242224122401C400000000
+A2C5:00000000038004400000406020A011244A24443C4A24112420A0406000000000
+A2C6:00000000000000000000406020A011244A24443C4A24112420A0406000000000
+A2C7:000000000000000010C013B01080088007800080188016801180100000000000
+A2C8:0000038004400000070008900890089008F00890089008900880070000000000
+A2C9:0000000000000000070008900890089008F00890089008900880070000000000
+A2CA:000000000000000008200420022001200CA00A60090008800840082000000000
+A2CB:0000000003800440000004400440028002A0012002A002800440044000000000
+A2CC:0000000000000000000004400440028002A0012002A002800440044000000000
+A2CD:0000000000000000018001600100010001000100010001000D00030000000000
+A2CE:0000038004400000183006C0010006C018300100010007C00100010000000000
+A2CF:0000000000000000183006C0010006C018300100010007C00100010000000000
+A2D0:000000000000000018081608158814681458044007C004400440044000000000
+A2D1:0000038004401000086024501048084003C0044008400840044003C000000000
+A2D2:0000000000001000086024501048084003C0044008400840044003C000000000
+A2D3:00000000000000000020062005A0046004000520052004000520052000000000
+A2D4:0000000000000FE0010011400920051011400920051011400920051000000000
+A2D5:000003800440000007C00820101017D001000100054005400540010000000000
+A2D6:000000000000000007C00820101017D001000100054005400540010000000000
+A2D7:0000000000000000180816081188106811180100010004400440044000000000
+A2D8:00000000000000001FC00200020012680AA807380AA8126802001FC000000000
+A2D9:00000000038004400000110011000A500A5004000A500A501100110000000000
+A2DA:00000000000000000000110011000A500A5004000A500A501100110000000000
+A2DB:00000000000000000000110011000A500A5004000A700A001100110000000000
+A2DC:038004400010031002D002300F8002000F800200070008800880070000000000
+A2DD:000000000010031002D002300F8002000F800200070008800880070000000000
+A2DE:00000000000000000100010007C011101110092007C004400820082000000000
+A2DF:000003800440000007C008200FE008200FE0082007C00100011000E000000000
+A2E0:000000000000000007C008200FE008200FE0082007C00100011000E000000000
+A2E1:00000000000000000F00114011400F40114011000F000110011000E000000000
+A2E2:0000038004400000030002C002300200070008800880070010400F8000000000
+A2E3:0000000000000000030002C002300200070008800880070010400F8000000000
+A2E4:000000000180016001000F28112811F811280F28010001000D00030000000000
+A2E5:0000038004400000060005800460040004A004A007E004A004A0040000000000
+A2E6:0000000000000000060005800460040004A004A007E004A004A0040000000000
+A2E7:0000000000000000000004400820101004400820101004400820101000000000
+A2E8:0380044000000010031002D0023002000A6006A0032006A00A60020000000000
+A2E9:0000000000000010031002D0023002000A6006A0032006A00A60020000000000
+A2EA:000000000000000001E0022004200420022001E0006009A00E20082000000000
+A2EB:000003800440000003800440044004400FC01440144014401440044000000000
+A2EC:000000000000000001C002200220022007E00A200A200A200A20022000000000
+A2ED:000000000000000007F0008001C0013001000120012001200D00030000000000
+A2EE:0000000003800440000004400440044000000FE0000004400440044000000000
+A2EF:0000000000000000000004400440044000000FE0000004400440044000000000
+A2F0:0000000000000000012009100910092001C00120091009100920010000000000
+A2F1:000003800440000011201510151011201FC011201510151011200E0000000000
+A2F2:000000000000000011201510151011201FC011201510151011200E0000000000
+A2F3:0000000000000000112011101110112011C011201110111011200E0000000000
+A2F4:0000000000000000010007C00100000001800160010001000D00030000000000
+A2F5:000003800440010007C00100000001800160010007C001000D00030000000000
+A2F6:000000000000010007C00100000001800160010007C001000D00030000000000
+A2F7:0000000000000000098011601118090007480948110011480948010000000000
+A2F8:0000038004400000044004400380111013900D6001000D6003800D6000000000
+A2F9:0000000000000000044004400380111013900D6001000D6003800D6000000000
+A2FA:00000380044000000010031002D0023002000F801240124012400F8000000000
+A2FB:00000000000000000010031002D0023002000F801240124012400F8000000000
+A2FC:0000038004400000008003E00080060005800460040004400440040000000000
+A2FD:0000000000000000008003E00080060005800460040004400440040000000000
+A2FE:0000038004400000010007C00100111011100EE00000010007C0010000000000
+A2FF:0000000000000000010007C00100111011100EE00000010007C0010000000000
+A300:00000000010007C041044C64345804400380010007C0010007C0010000000000
+A301:0000038004400000101010101FF011101110111011101110092007C000000000
+A302:0000000000000000101010101FF011101110111011101110092007C000000000
+A303:0000000000000000000009F012101210091000F009101210121009F000000000
+A304:000003800440000002400280030003C00220022003C003000280024000000000
+A305:000000000000000002400280030003C00220022003C003000280024000000000
+A306:000000000000000007C0082014501FF0145014501FF01450082007C000000000
+A307:000003800440000010101450145014501010111011101110082007C000000000
+A308:000000000000000010101450145014501010111011101110082007C000000000
+A309:000000000000000000880088008800880C8810F8208824882288118800000000
+A30A:000003800440000007C008201FF010101FF0082007C008201110111000000000
+A30B:000000000000000007C008201FF010101FF0082007C008201110111000000000
+A30C:0000000000000000030012C01230120002000200120012001200020000000000
+A30D:000003800440000004440444024801F018402040404048404640218000000000
+A30E:000000000000000004440444024801F018402040404048404640218000000000
+A30F:000000000000000011101110092007C001000100078009400640004000000000
+A310:000000000000000000B808C008C008B8088000B800C018C006B8018000000000
+A311:00000380044000000080089008F0089008800080009018F00690018000000000
+A312:00000000000000000080089008F0089008800080009018F00690018000000000
+A313:00000F901050001003D00430081008000800080008000810042003C000000000
+A314:0000038004400000060005800460040005200520052005200400040000000000
+A315:0000000000000000060005800460040005200520052005200400040000000000
+A316:00000000000000000C000B0008C008000A200940088009400A20080000000000
+A317:00000000000003C004200500048002000180004002200120042003C000000000
+A318:0000038004400000118009600500110009400520011001400D20031000000000
+A319:0000000000000000118009600500110009400520011001400D20031000000000
+A31A:00000000000007C008200A800A80080007C0002002A002A0082007C000000000
+A31B:000003800440000008C008A00090078008800880078000800880088000000000
+A31C:000000000000000008C008A00090078008800880078000800880088000000000
+A31D:0000000000000000004010501050135002C00200121012101210020000000000
+A31E:0000000000000820082007C00000111011100EE0000007C00820082000000000
+A31F:0000038004400000024002400240020003E00200024002401A40060000000000
+A320:0000000000000000012001200120010001F00100012001200D20030000000000
+A321:000000000000000003C00420081008103E10081008100810042003C000000000
+A322:00000380044000000100092009201D20090009F0010001200D20032000000000
+A323:00000000000000000100092009201D20090009F0010001200D20032000000000
+A324:00000000000000001010101010101010082007C00000010007C0010000000000
+A325:00000380044000001010101010101010082007C00100110011000E0000000000
+A326:00000000000000001010101010101010082007C00100110011000E0000000000
+A327:0000000000000000008007F00080008007F00080188016801180100000000000
+A328:0000038004400000101010101010082007C00000010001000100010000000000
+A329:0000000000000000101010101010082007C00000010001000100010000000000
+A32A:0000000000000000000811881F6811180100011011101F101110010000000000
+A32B:00000380044000000020062005A0046004000440044005F00440044000000000
+A32C:00000000000000000020062005A0046004000440044005F00440044000000000
+A32D:0000000000000000001003101ED002300200022002201EF80220022000000000
+A32E:000003800440000018081608118811681518054001400540051000E000000000
+A32F:000000000000000018081608118811681518054001400540051000E000000000
+A330:000000000000000018081608118810E81098008002A002A0008007F000000000
+A331:00000000000000001110111013900D60010005401550155011100EE000000000
+A332:00000380044000000FE0101010100FE0210821080FE0101010100FE000000000
+A333:00000000000000000FE0101010100FE0210821080FE0101010100FE000000000
+A334:0000000000000FE0101010100FE001001FF001000FE0101010100FE000000000
+A335:0000000000000000000811881F681118110011001F0011000100010000000000
+A336:000003800440000007C00820101010101FF0111011101110092007C000000000
+A337:000000000000000007C00820101010101FF0111011101110092007C000000000
+A338:00000000000000001860165011C0104012401540154015401240104000000000
+A339:00000380044000000180016001000100010001C0012001200D20030000000000
+A33A:00000000000000000180016001000100010001C0012001200D20030000000000
+A33B:000000000000000007C00820119011501110119015501350082007C000000000
+A33C:000000000000000000401FF800400440047800400C400B4008C0080000000000
+A33D:00000380044000001C60135010C002400FC002400C400B4008C0080000000000
+A33E:00000000000000001C60135010C002400FC002400C400B4008C0080000000000
+A33F:000000000000049003E00080049003E01880168013E014100490049000000000
+A340:0000000000000000112015101510112015C01520111015101510112000000000
+A341:00000380044000000180016007D8090009C0090037C02D002300200000000000
+A342:00000000000000000180016007D8090009C0090037C02D002300200000000000
+A343:00000000000000000F001088224802400FC80248024038482648218000000000
+A344:0380044000000EE0111011101110010001000FE0000009200920092000000000
+A345:0000000000000EE0111011101110010001000FE0000009200920092000000000
+A346:0000000000700E8011A011A01180157015001570118011A011A00E8000700000
+A347:03800440010001000440044018101610111010D0103004400540010000000000
+A348:00000000010001000440044018101610111010D0103004400540010000000000
+A349:000000000000000003883A680618120012001200120006183A68038800000000
+A34A:00000380044000000580056025181900010001003FF801000100010000000000
+A34B:00000000000000000580056025181900010001003FF801000100010000000000
+A34C:000000000000000007E008200820082007E0002001200920082007C000000000
+A34D:000000000000000005800560251819000100010007C009201110111000000000
+A34E:00000380044000001860165011C010401240124010401FC01040104000000000
+A34F:00000000000000001860165011C010401240124010401FC01040104000000000
+A350:000000000000000001000540044002801E90111012F002800440054001000000
+A351:00000000000000000008018801680118010005402548210811100FE000000000
+A352:00000380044000000100010001000100054005402548210811100FE000000000
+A353:00000000000000000100010001000100054005402548210811100FE000000000
+A354:000000000000000015501550155011101550155015501110092007C000000000
+A355:00000000000000000638054404C40444044404440444245414540C3800100000
+A356:000003800440000001900F6811281128091007000900110011000F0000000000
+A357:000000000000000001900F6811281128091007000900110011000F0000000000
+A358:000000000000000000000100028002800100000004400AA00AA0044000000000
+A359:0000038004400000031002E81A28062802101A00060002001A00060000000000
+A35A:0000000000000000031002E81A28062802101A00060002001A00060000000000
+A35B:00000000000007C00820080007C00020082007C000000FE000000FE000000000
+A35C:000003800440000011101110092007C00110011007C009201110111000000000
+A35D:000000000000000011101110092007C00110011007C009201110111000000000
+A35E:0000000000000E100990087000000E100990087000000E100990087000000000
+A35F:0000038004400000038002601218120013E01200120012180260038000000000
+A360:0000000000000000038002601218120013E01200120012180260038000000000
+A361:00000000000000000180016001000FE009200540038003800540092000000000
+A362:000003800440000001800160010007C0092007C0010007C00920092000000000
+A363:000000000000000001800160010007C0092007C0010007C00920092000000000
+A364:0000000000000100038005400440054003800100038005400920092000000000
+A365:000000000000000030C02CA8239820882480248020803F802080208000000000
+A366:00000380044000000C300A280820282018A00C600A20082028A0186000000000
+A367:00000000000000000C300A280820282018A00C600A20082028A0186000000000
+A368:000000000000000000002230125008900510021C051008901250223000000000
+A369:000000000000000018181514111210101FF01010111091105050303000000000
+A36A:03800440000018081608118810E81098008018881688118810E8109800000000
+A36B:00000000000018081608118810E81098008018881688118810E8109800000000
+A36C:00000000000000000C300B2C082008200FE008200820082069A0186000000000
+A36D:00000000000000001FF011100920054013901110139005400920111000000000
+A36E:00000380044000001FF011100920054003801FF0028004400920111000000000
+A36F:00000000000000001FF011100920054003801FF0028004400920111000000000
+A370:00000000000000001FF01110092005403B8827C822B804400920111000000000
+A371:00000380044000000E001128112815F8152815F81528112811000E0000000000
+A372:00000000000000000E001128112815F8152815F81528112811000E0000000000
+A373:0000000000000000072008A008800AF00A800A800AF0088008A0072000000000
+A374:00000380044000000C040B34082C082008203E200820082C6834180400000000
+A375:00000000000000000C040B34082C082008203E200820082C6834180400000000
+A376:000000001C1001C805A8059801800E8000800FF8008018800680018000000000
+A377:000003800440000018081608118810E81098008001C00220022001C000000000
+A378:000000000000000018081608118810E81098008001C00220022001C000000000
+A379:000000000000000005500550011007D00110055004500C100390007000000000
+A37A:0380044000001C0803880B680B1803001D0001001FF001001FF0010000000000
+A37B:0000000000001C0803880B680B1803001D0001001FF001001FF0010000000000
+A37C:0000038004400000033012E812243A2012201220022002201A20062000000000
+A37D:0000000000000000033012E812243A2012201220022002201A20062000000000
+A37E:0000038004400000010001200920150015F01500092001200D00030000000000
+A37F:0000000000000000010001200920150015F01500092001200D00030000000000
+A380:0000000000000000014811481130110011F80100013031480D48030000000000
+A381:00000380044000000380044007C008200FE0082008200920092006C000000000
+A382:00000000000000000380044007C008200FE0082008200920092006C000000000
+A383:00000000000007C008201010045004500110011000100E100990086000000000
+A384:0000000000000000000801880168011801003FF8010011007D00110000000000
+A385:00000380044000000FC00020002000200FE000200020002000200FC000000000
+A386:00000000000000000FC00020002000200FE000200020002000200FC000000000
+A387:000000000000000018081608118810E81098008003E008800880070000000000
+A388:0000000000000000181014101210101011101110101010901050103000000000
+A389:0000038004400000082014501450145008200540028002800280010000000000
+A38A:0000000000000000082014501450145008200540028002800280010000000000
+A38B:000000000000000036D808201450145014503FF814501450082036D800000000
+A38C:0000038004400000018000400620082009200920082006200040018000000000
+A38D:0000000000000000018000400620082009200920082006200040018000000000
+A38E:0000000000000000008000A800A800A800F800A818A816A81180100000000000
+A38F:00000380044000000040004000400040004000500C500B5008D0080000000000
+A390:00000000000000000040004000400040004000500C500B5008D0080000000000
+A391:000000000000000000C007A00890088004A003A004A008800880078000000000
+A392:0000038004400000080809881D6809180900010007C009201110111000000000
+A393:0000000000000000080809881D6809180900010007C009201110111000000000
+A394:00000000000007C008201110111010101FF0101011101110082007C000000000
+A395:000003800440000003801450145004400FE00440145014500440038000000000
+A396:000000000000000003801450145004400FE00440145014500440038000000000
+A397:0000000000000000024002500260024002400240024006400A40024000000000
+A398:000003800440000003C004200910011007D0011001100E100990086000000000
+A399:000000000000000003C004200910011007D0011001100E100990086000000000
+A39A:000000000220022003E006300A3001D00010001000100E100990086000000000
+A39B:0000000000000000000801880168011801001FF0010009200920010000000000
+A39C:000003800440000004040434042C0420042007E0042034202C20202000000000
+A39D:000000000000000004040434042C0420042007E0042034202C20202000000000
+A39E:000000000000000000C000A00090008007B008C010F010C008B0078000000000
+A39F:0000000000000000070008800BA00AE0088008800BA00AE00880070000000000
+A3A0:000003800440100028C02FB0288C10800080108028802F802880108000000000
+A3A1:000000000000100028C02FB0288C10800080108028802F802880108000000000
+A3A2:000000000000082008200440139011107D7C111011100D000B00080000000000
+A3A3:00000380044000000FE01010101010100FE001000100110011000E0000000000
+A3A4:00000000000000000FE01010101010100FE001000100110011000E0000000000
+A3A5:000000000000000009300550039003900550093001000D000B00080000000000
+A3A6:00000380044000000810081008100FF008100A100C1018102810081000000000
+A3A7:00000000000000000810081008100FF008100A100C1018102810081000000000
+A3A8:00000000000000000080088008800F80088008800080008000800FF800000000
+A3A9:0000038004400000030002C00200020003E00210024802A81AA0064000000000
+A3AA:0000000000000000030002C00200020003E00210024802A81AA0064000000000
+A3AB:0000000000000000000010180828044802880108028804480828101800000000
+A3AC:0000038004400000018001602918290029003F00290029002900010000000000
+A3AD:0000000000000000018001602918290029003F00290029002900010000000000
+A3AE:0000000000000000093009280FE40920092009200FE049202920192000000000
+A3AF:00000380044000000FE001000FE0010009200540038003800540092000000000
+A3B0:00000000000000000FE001000FE0010009200540038003800540092000000000
+A3B1:000000000000000018081608118810E81098008002A001C001C002A000000000
+A3B2:000000000000000009C01130110009200720092011201100093001C000000000
+A3B3:0380044000000540054004401390111011100EE0054005400440038000000000
+A3B4:0000000000000540054004401390111011100EE0054005400440038000000000
+A3B5:00000000000000000000190C251422241D4400841D4422242514190C00000000
+A3B6:0000000000000000008002A002A002A01880168011C012200490049000000000
+A3B7:000003800440100011801F601118114001401950171011D01130010000000000
+A3B8:000000000000100011801F601118114001401950171011D01130010000000000
+A3B9:0000000000001C0003800B600B1803401D4001401910171011D0113000000000
+A3BA:0000000000000000010009200540038009200540038009200540038000000000
+A3BB:0000038004400000012801280128012801280128013031E00D20032000000000
+A3BC:0000000000000000012801280128012801280128013031E00D20032000000000
+A3BD:000000000000000007E008100810081007E00080068009000680008000000000
+A3BE:000003800440000007900860086007A00020002007A008600860079000000000
+A3BF:000000000000000007900860086007A00020002007A008600860079000000000
+A3C0:0000000000000000022002201A28162813A81268123802200220022000000000
+A3C1:000003800440000003E004000400020001E0020004000400040003E000000000
+A3C2:000000000000000003E004000400020001E0020004000400040003E000000000
+A3C3:0000000000000490049002A001C0008000801880168011801000100000000000
+A3C4:000003800440100011E012000400140017E0140004001400120011E000000000
+A3C5:000000000000080008F0090002000A000BF00A0002000A00090008F000000000
+A3C6:000000000000018001600118010007C00920111017D011101110010000000000
+A3C7:00000380044000000E0011481148113011F811301148114811000E0000000000
+A3C8:00000000000000000E0011481148113011F811301148114811000E0000000000
+A3C9:00000000000000000760088009800A800A800A800A8009800880076000000000
+A3CA:00000380044000000C200A20082009200AA00AA00920082008A0086000000000
+A3CB:00000000000000000C200A20082009200AA00AA00920082008A0086000000000
+A3CC:000000000000000010001210112010C01FF010C0112012101000100000000000
+A3CD:0000000000000440028001002288145008201450228801000280044000000000
+A3CE:00000380044000000700088009C00AA00AA00AA00AA009C00880070000000000
+A3CF:00000000000000000700088009C00AA00AA00AA00AA009C00880070000000000
+A3D0:000000000000000000000440044012902AA829282AA812900440044000000000
+A3D1:0000038004400000038004400440038009300550039003900550093000000000
+A3D2:0000000000000000038004400440038009300550039003900550093000000000
+A3D3:000000000000000001E00210021012D00B5006500B5012D0021001E000000000
+A3D4:000000000920054003800380054009200540054001000FE001000FE000000000
+A3D5:000003800440000007C031102D10231021D02130010005400540010000000000
+A3D6:000000000000000003E018881688118810E81098008002A002A0008000000000
+A3D7:00000000000000001E00010009300550039003900550093001001E0000000000
+A3D8:0000038004400000092005400380038005400920010005400540010000000000
+A3D9:0000000000000000092005400380038005400920010005400540010000000000
+A3DA:000000000000000002480248015000E0034002C007000A801240124000000000
+A3DB:0000038004400000062005A004600400052007F00520052007F0052000000000
+A3DC:0000000000000000062005A004600400052007F00520052007F0052000000000
+A3DD:000000000000000000300028262415200CA03FA00620052004A0006000000000
+A3DE:0000038004400000007818800480027802800280027804801880007800000000
+A3DF:0000000000000000007818800480027802800280027804801880007800000000
+A3E0:000000000000000007C0082001000D200B2009A009600100082007C000000000
+A3E1:00000380044000000100010031102C10231020D0203001000100010000000000
+A3E2:0000000000000000008000801888160811881068101800800080008000000000
+A3E3:000000001FF8002000A000A0062005A0046004000480048004001FF800000000
+A3E4:000000000000073004E8042435A00C60042035A00C60042035A00C6000000000
+A3E5:000003800440000008040934092C08200FE00820092069205820402000000000
+A3E6:000000000000000008040934092C08200FE00820092069205820402000000000
+A3E7:00000000000000000EF0010002800FE0028002800FE0028001000EF000000000
+A3E8:00000000101017D0082017D0101011101110101017D0082017D0101000000000
+A3E9:0000038004400000044004401390111011100EE0000001000100010000000000
+A3EA:0000000000000000044004401390111011100EE0000001000100010000000000
+A3EB:00000000000000000F801058136012C0124012401A40166010580F8000000000
+A3EC:00000000000000001110111011100EE000000100010007C00100010000000000
+A3ED:00000380044000001110111011100EE000000100010009000900060000000000
+A3EE:00000000000000001110111011100EE000000100010009000900060000000000
+A3EF:000000000000044004400380111011100EE000000100110011000E0000000000
+A3F0:00000000000007C0082011901150111017D0111015101310082007C000000000
+A3F1:000003800440000001E00200044004A004A004A004A00440020001E000000000
+A3F2:000000000000000001E00200044004A004A004A004A00440020001E000000000
+A3F3:000000000000000003D0043009100A800A800A800A800910042003C000000000
+A3F4:000003800440000010101190115011101110111015101310082007C000000000
+A3F5:000000000000000010101190115011101110111015101310082007C000000000
+A3F6:00000000000000000180016009181100110017C0110011000900010000000000
+A3F7:00000380044000000380026002000A000A000A000A000A000260038000000000
+A3F8:00000000000000000380026002000A000A000A000A000A000260038000000000
+A3F9:0000000000000E0009C00800088008800BE008800880080009C00E0000000000
+A3FA:0000038004400000000801880968111811001700110011000900010000000000
+A3FB:0000000000000000000801880968111811001700110011000900010000000000
+A3FC:0000000000000000003000280024102023E024201CA024A0242013E000000000
+A3FD:000000000380044000000440044002800AA009200AA002800440044000000000
+A3FE:000000000000000000000440044002800AA009200AA002800440044000000000
+A3FF:000000000000000007C00820101010101110111010101010082007C000000000
+A400:000000000000000000003F8020A411240A1807F80A18112420A43F8000000000
+A401:00000380044000000400048804880450042007F80420245014880C8800000000
+A402:00000000000000000400048804880450042007F80420245014880C8800000000
+A403:000000000000000000001100114811480A3007F80A3011481148110000000000
+A404:000000000000000003F00410041003F0001003F000100BF0081007E000000000
+A405:000003800440000010101010101011F010101F101010101011F0101000000000
+A406:000000000000000010101010101011F010101F101010101011F0101000000000
+A407:00000000000000001010101011F010101F10101011F01010082007C000000000
+A408:0000000000000000010011001100111001100110111011001100010000000000
+A409:00000380044000000E00190015001120115017D01150152019000E0000000000
+A40A:00000000000000000E00190015001120115017D01150152019000E0000000000
+A40B:000000000000000007C00920111010101010101012901450082007C000000000
+A40C:00000000000000000700088008F0088008F0088008F008800880070000000000
+A40D:000003800440000007C00820101010101010101010101110092007C000000000
+A40E:000000000000000007C00820101010101010101010101110092007C000000000
+A40F:000000000000000000100810101010900E90109010100B1000D0003000000000
+A410:000003800440000007C008201010101010101010101012900AA007C000000000
+A411:000000000000000007C008201010101010101010101012900AA007C000000000
+A412:0000000000000000010011180928054803880388054809281118010000000000
+A413:0000038004400000082008200440038001000D000B0008000800080000000000
+A414:0000000000000000082008200440038001000D000B0008000800080000000000
+A415:00000000000009200AA009200440038001000D000B0008000800080000000000
+A416:0380044000001830145013901390155019300100092005400380054009200000
+A417:0000000018301450139013901550193001000920054003800540092000000000
+A418:0000000000000000082008200440038009200920038004400820082000000000
+A419:0000038004400000044004401FF004400440044004401FF00440044000000000
+A41A:0000000000000000044004401FF004400440044004401FF00440044000000000
+A41B:000000000000180004C01FA00490188000800F801080108010800F8000000000
+A41C:00000000000000000820082004400380010005400540110011000E0000000000
+A41D:0000038004400000183024480440044003800FE0010001000900060000000000
+A41E:0000000000000000183024480440044003800FE0010001000900060000000000
+A41F:0000000000000000092009200440038001000920092009200100010000000000
+A420:0380044000001830044012901290129004401830038004400920092000000000
+A421:0000000000001830044012901290129004401830038004400920092000000000
+A422:000000000000000002080208011008E01400140008E001100208020800000000
+A423:00000000000000000C040AC409B41C8C2A802A8008801C802A802A8000000000
+A424:000003800440000018C016B0118C10807C8010807C8010801080108000000000
+A425:000000000000000018C016B0118C10807C8010807C8010801080108000000000
+A426:0000000000001830044002800280028004401830038004400820082000000000
+A427:00000000000000000FE01010101010100FE0010007000800082007C000000000
+A428:038004400000001007F008800FF0088007F0010001C002A00490049000000000
+A429:000000000000001007F008800FF0088007F0008001C002A00490049000000000
+A42A:0000000000000000000007C0082009200920044009200920082007C000000000
+A42B:0000038004400000008007F00880088007F0008001C002A00490049000000000
+A42C:0000000000000000008007F00880088007F0008001C002A00490049000000000
+A42D:00000000000000003808260821C82538050001403948270821C8203800000000
+A42E:00000380044000000EE00440044004400380010007C001000900060000000000
+A42F:00000000000000000EE00440044004400380010007C001000900060000000000
+A430:000000000AC00AA00F900A800A8000800A800A800F800A800A80008000000000
+A431:00000000000000000FF01080108010800FF00080008008800880070000000000
+A432:000003800440000011101110092007C0010001000100110011000E0000000000
+A433:000000000000000011101110092007C0010001000100110011000E0000000000
+A434:0000000000000000202020203FF82024202420382020202010400F8000000000
+A435:00000000000000001110111011100EE0000009200920092000000FE000000000
+A436:03800440000003800440054005401E50155014F0054005400440038000000000
+A437:00000000000003800440054005401E50155014F0054005400440038000000000
+A438:00000000000007C00820082007C001000FE001000540155010100FE000000000
+A439:0000038004400000066005D00440044007C004400000111011100EE000000000
+A43A:0000000000000000066005D00440044007C004400000111011100EE000000000
+A43B:0000000000000000000060305054489445104214451448905054603400000000
+A43C:000000000380044000006030505448924512421C451248925054603000000000
+A43D:000000000000000000006030505448924512421C451248925054603000000000
+A43E:00000000000000000EE00100028002800EA00BA00AE0028001000EE000000000
+A43F:03800440000001E0020004400440040007E0040004400440020001E000000000
+A440:00000000000001E0020004400440040007E0040004400440020001E000000000
+A441:000000000000000003C00400082008100F90081008200800040003C000000000
+A442:000003800440000000600058004003F8184020404C404B4008C0080000000000
+A443:00000000000000000030002C002001FC0C201020262025A00460040000000000
+A444:00000000000000000F2010D010501020080006000100008010800F0000000000
+A445:038004400000049002A001C001C002A004900080188016801180100000000000
+A446:000000000000049002A001C001C002A004900080188016801180100000000000
+A447:0000000000000000082008200180014001200100010009000500030000000000
+A448:03800440000002C01AA0069002801A8006800080188016801180100000000000
+A449:00000000000002C01AA0069002801A8006800080188016801180100000000000
+A44A:000000000000111011100FE001000FE01110111001000D000B00080000000000
+A44B:000003800440000001800160011801001FF001001FF001001FF0010000000000
+A44C:000000000000000001800160011801001FF001001FF001001FF0010000000000
+A44D:00000000000000000C000B0008C0080008400840084008400800080000000000
+A44E:0000000000000000600612480A50099008100FF0081009901248624600000000
+A44F:0000038004400000088608880890081008100FF0081049902A481A4600000000
+A450:0000000000000000088608880890081008100FF0081049902A481A4600000000
+A451:0000000000000000610C11100920082008200FE0082009201110610C00000000
+A452:03800440000003800440092009200440038000000FF00060018006000FF00000
+A453:0000000003800440092009200440038000000FF00060018006000FF000000000
+A454:00000000082028282448238810100FE0210821083FF821082108010000000000
+A455:0000000000000000311809200540054005400540054005400920311800000000
+A456:00000380044000000D200BA0096001000D200BA0096001001900070000000000
+A457:00000180016001000D200BA0096001000D200BA0096001001900070000000000
+A458:000000000000000003800440044008200820082008200920092006C000000000
+A459:000000000000000007C00820111011101FF0111011101010082007C000000000
+A45A:0000038004400000088008800E8009C008B00880089008900890088000000000
+A45B:0000000000000000088008800E8009C008B00880089008900890088000000000
+A45C:0000000000000000008007F008800880088007F0008000900090009000000000
+A45D:00000000000000001110111011100EE000000440028001000280044000000000
+A45E:00000000038004400000110811080A080A0804680A580A401140114000000000
+A45F:00000000000000000000110811080A080A0804680A580A401140114000000000
+A460:00000000000006200920062000200620092006200020062001A0006000000000
+A461:00000000000000001110111011100EE004400540038001000900060000000000
+A462:00000380044000001110111011100EE004400440044015401540088000000000
+A463:00000000000000001110111011100EE004400440044015401540088000000000
+A464:000000000000000000002208220814681458084014E0144022E0224000000000
+A465:00000380044000000920092004400380044008200FE008200440038000000000
+A466:00000000000000000920092004400380044008200FE008200440038000000000
+A467:000000000000111011100EE0000004400380000014501390082007C000000000
+A468:00000380044000000660055004C804400E40154015400E400440044000000000
+A469:00000000000000000660055004C804400E40154015400E400440044000000000
+A46A:00000000000000001860165811C6104096405A4032405A409640104000000000
+A46B:000000000000000004400440038001000D200BA00960010001000FE000000000
+A46C:00000380044000000100010031102D10231021D0213001000100010000000000
+A46D:00000000000000000080008018881688118810E8109800800080008000000000
+A46E:00000000000000000220022001C018881688118810E810980080008000000000
+A46F:0000038004400000111011101110092007C031102D10231021D0213000000000
+A470:0000000000000000088808880888049003E018881688118810E8109800000000
+A471:0000000000000000000800C800A8009800801F8024803F8024801F8000000000
+A472:000003800440000028F029083A04280428040004000403840264021800000000
+A473:000000000000000028F029083A04280428040004000403840264021800000000
+A474:0000000000000180016001000920054003800540092001000D00030000000000
+A475:0000000000000000000400640054004C0FC038E01540154038E007C000000000
+A476:00000380044000000010031002D0023002001FC002001FC00200020000000000
+A477:00000000000000000010031002D0023002001FC002001FC00200020000000000
+A478:000001C00130010007C00920155013901550092007C001001900070000000000
+A479:000000000000000012C012B00C8000C00CB0128012C000B00680018000000000
+A47A:00000380044000000CC012B012801E80128012E00C9000900690018000000000
+A47B:00000000000000000CC012B012801E80128012E00C9000900690018000000000
+A47C:00000000000002000FA0022000200FA0106010001F00102010400F8000000000
+A47D:00000000000000000CC012B012800080128012800C8000800680018000000000
+A47E:000003800440000003D00430081008000F80080008000810042003C000000000
+A47F:000000000000000003D00430081008000F80080008000810042003C000000000
+A480:000000000000000008200820044003800120014001800110011000E000000000
+A481:000000000180016001000D200BA00960010007C001000D000B00080000000000
+A482:0380044000001110111017D011101110082007C00100111011100EE000000000
+A483:0000000000001110111017D011101110082007C00100111011100EE000000000
+A484:00000000000000000020092009200FE0092009200020062001A0006000000000
+A485:0380044000000180016001000D200BA00960010007C001000D00030000000000
+A486:0000000000000180016001000D200BA00960010007C001000D00030000000000
+A487:000000000000092009200440038000000FE00000038004400920092000000000
+A488:00000380044000000040004003C0044008400840044003C00040004000000000
+A489:00000000000000000040004003C0044008400840044003C00040004000000000
+A48A:000000000000000000F00700090010801070108009000700010000F000000000
+A48B:038004400000393805400540393801001FF00100393805400540393800000000
+A48C:000000000000393805400540393801001FF00100393805400540393800000000
+A48D:00007FFE61B66DB661866DF66DF67FFE7FFE738E6DB673B66DB6738E7FFE0000
+A48E:00007FFE61B66DB661866DF66DF67FFE7FFE73866DBE738E6DBE73867FFE0000
+A48F:00007FFE61B66DB661866DF66DF67FFE7FFE73866DBE738E6DBE73BE7FFE0000
+A490:0000000000000000010001000100010001000100010001000100010000000000
+A491:000000000000000000400040004000400040004000400C40034000C000000000
+A492:0000000000000000040004000400040004000400040004600580060000000000
+A493:0000000000000000060005800460040004000400040004000400040000000000
+A494:0000000000000000018001600100010001000100010001000D00030000000000
+A495:00000000000000000020062005A0046004000400040004000400040000000000
+A496:00000000000000000040004000400040004000400C400B4008C0080000000000
+A497:000000000000000001800160011801000100010031002D002300200000000000
+A498:000000000000000000C800A80098008000800080008018800680018000000000
+A499:0000000000000000180816081188106810180000000000000000000000000000
+A49A:000000000000000003C00420040004000200018000400020042003C000000000
+A49B:0000000000000000004000400040034002C00200020002000200020000000000
+A49C:000000000000000003C00420081000100010001000100E100990086000000000
+A49D:000000000000000003D00430081008000800080008000810042003C000000000
+A49E:00000000000000000E2009A008600800080008000800086009A00E2000000000
+A49F:000000000000000001E00200040004000400040004000400020001E000000000
+A4A0:00000000000000000FC0002000200020002000200020002000200FC000000000
+A4A1:0000000000000000082008200440038000000000000000000000000000000000
+A4A2:0000000000000000000000000000000000000000038004400820082000000000
+A4A3:0000000000000000180806080188006800180000000000000000000000000000
+A4A4:000000000000000010101010101010101010101010101010082007C000000000
+A4A5:0000000000000000086008800880088008800880088008800880070000000000
+A4A6:0000000000000000183024480440044004400440044004400440038000000000
+A4A7:000000000000000003800440044008200820082008200920092006C000000000
+A4A8:000000000000000007C00820101010101010101010101010082007C000000000
+A4A9:0000000000000000038004400440044004400440044004400440038000000000
+A4AA:00000000000000000FE01010101010100FE00000000000000000000000000000
+A4AB:000000000000000001000280044008200FE00000000000000000000000000000
+A4AC:000000000000000000C000A00090008007800880108010800880078000000000
+A4AD:000000000000000000C000A00090008007C008A0109010800880078000000000
+A4AE:0000000000000000000800C800A8009807800880108010800880078000000000
+A4AF:0000000000000000002000200020002001E0022004200420022001E000000000
+A4B0:000000000000000003C004000400020001C0020004000400040003C000000000
+A4B1:0000000000000000078000400040008007000080004000400040078000000000
+A4B2:000000000000000003E00400040003E00400040003E00400040003E000000000
+A4B3:00000000000000001110111011100EE000000000000000000000000000000000
+A4B4:0000000000000000444444444C64345804400440038000000000000000000000
+A4B5:00000000000000001C7008200820044003800000000000000000000000000000
+A4B6:00000000000000004444444444443BB800000000000000000000000000000000
+A4B7:0000000000000000183024480440044003800000000000000000000000000000
+A4B8:00000000000000000710089008A007C000800080008000800C80030000000000
+A4B9:00000000000000000E20112011400F800100010001000120012000C000000000
+A4BA:000000000000000007900860086007A00020002007A008600860079000000000
+A4BB:000000000000000000200020002000200020022005200520032004C000000000
+A4BC:0000000000000000000004400440028002800100028002800440044000000000
+A4BD:00000000000000000C6002800100028002800440044008200820082000000000
+A4BE:0000000000000FE00820044002800280010002800280044008200FE000000000
+A4BF:0000000000000000000030182828244822882108228824482828301800000000
+A4C0:0000000000000000000010180828044802880108028804480828101800000000
+A4C1:0000000000000000000030182828244802880108028804480828101800000000
+A4C2:00000000000000000000190C251422241D4400841D4422242514190C00000000
+A4C3:0000000000000FE0082004400440028002800100028002800440044000000000
+A4C4:00000000000000000FE001000100010001000100010001000100010000000000
+A4C5:00000000000000001FC002200210020002000200020002000200020000000000
+A4C6:0000000000000000000004400440044000000000000000000000000000000000
+A4C7:00007FFE61B66DB661866DF66DF67FFE7FFE71866FF66FEE6FDE71DE7FFE0000
+A4C8:00007FFE61B66DB661866DF66DF67FFE7FFE71CE6FB66FCE6FB671CE7FFE0000
+A4C9:00007FFE61B66DB661866DF66DF67FFE7FFE71CE6FB66FC66FF671CE7FFE0000
+A4CA:00007FFE61B66DB661866DF66DF67FFE7FFE71866FB66F866FB671B67FFE0000
+A4CB:00007FFE61B66DB661866DF66DF67FFE7FFE718E6FB66F8E6FB6718E7FFE0000
+A4CC:00007FFE61B66DB661866DF66DF67FFE7FFE71C66FBE6FBE6FBE71C67FFE0000
+A4CD:00007FFE61B66DB661866DF66DF67FFE7FFE718E6FB66FB66FB6718E7FFE0000
+A4CE:00007FFE61B66DB661866DF66DF67FFE7FFE71866FBE6F8E6FBE71867FFE0000
+A4CF:00007FFE61B66DB661866DF66DF67FFE7FFE71866FBE6F8E6FBE71BE7FFE0000
+A4D0:000000007C4242427C424242427C0000
+A4D1:000000007C4242427C40404040400000
+A4D2:0000000002020202023E4242423E0000
+A4D3:00000000784442424242424244780000
+A4D4:000000007F0808080808080808080000
+A4D5:000000000808080808080808087F0000
+A4D6:000000003C424240404E4242463A0000
+A4D7:00000000424448506060504844420000
+A4D8:000000004222120A06060A1222420000
+A4D9:00000000040404040404044444380000
+A4DA:000000003C42424040404042423C0000
+A4DB:000000003C42420202020242423C0000
+A4DC:000000007E02020408102040407E0000
+A4DD:000000007E4040407C40404040400000
+A4DE:0000000002020202023E0202027E0000
+A4DF:00000000424266665A5A424242420000
+A4E0:0000000042626252524A4A4646420000
+A4E1:000000004040404040404040407E0000
+A4E2:000000003C424240300C0242423C0000
+A4E3:000000007C4242427C48444442420000
+A4E4:0000000042422222123E4242423E0000
+A4E5:00000000080814142222224141410000
+A4E6:00000000414141222222141408080000
+A4E7:00000000424242427E42424242420000
+A4E8:000000005C62424272020242423C0000
+A4E9:00000000384444404040404040400000
+A4EA:00000000424242425A5A666642420000
+A4EB:00000000424224241818242442420000
+A4EC:00000000414122221408080808080000
+A4ED:000000003E424242423E4242423E0000
+A4EE:0000000018242442427E424242420000
+A4EF:00000000424242427E42422424180000
+A4F0:000000007E4040407C404040407E0000
+A4F1:000000007E0202023E020202027E0000
+A4F2:00000000080808080808080808080000
+A4F3:000000003C42424242424242423C0000
+A4F4:000000004242424242424242423C0000
+A4F5:000000003C4242424242424242420000
+A4F6:000000007E0202020202020202020000
+A4F7:000000001E22424242424242221E0000
+A4F8:00000000000000000000000018180000
+A4F9:00000000000000000000000018080810
+A4FA:00000000000000000000000066660000
+A4FB:00000000000000000000000066620204
+A4FC:00000000000018180000001808081000
+A4FD:00000000000018180000001818000000
+A4FE:00000000000000000070000006060000
+A4FF:000000000000007E0000007E00000000
+A500:0000000000000FE00100010001001930254825481930010001000FE000000000
+A501:0000000000000FE001000FE0010019302548193001000FE001000FE000000000
+A502:000000000000242024401A800100010002000200022001480090016000000000
+A503:0000000000003E0008000800046003A0012001E000200020002000F800000000
+A504:0000000000003E0008003E00046003A0012001E0002000F8002000F800000000
+A505:0000000000003838444447C44544393801000380044004400440038000000000
+A506:0000000000000380044004400440139001003938454447C44444383800000000
+A507:00000000000004200860086004A003200020002000200020002000F800000000
+A508:00000000000004200860086004A003200020002000A80020002000F800000000
+A509:0000000000001FF0010001000540010001000100010001000100010000000000
+A50A:0000000000001FF0010001000540010001000FE0010001000100010000000000
+A50B:0000000000001FF0010001000100010001000100010001000100010000000000
+A50C:000000000000038004400440044003800100010001000100010007C000000000
+A50D:0000000000000380044004400440038001000100010007C0010007C000000000
+A50E:000000000000124012400DC00040004000400078004000400040007800000000
+A50F:000000000000124012400DF80040004000400078004000400040007800000000
+A510:00000000000049004900370001000150015403A8050009000900060000000000
+A511:00000000000049004900372001000150015403A8050009200900060000000000
+A512:000000000000124012400DC00040004000480078004800400040004000000000
+A513:000000000000124012400DC0004000480078004800400040071008E000000000
+A514:00000000000006180A2812482288020802080208020802080208020800000000
+A515:0000000000001F800080008000800080008007F8088808880888070800000000
+A516:0000000000000920092009200920092009200920092009200920092000000000
+A517:00000000000009200920092009200920092009200920092000000FE000000000
+A518:0000000000001010101010100000010001000100000010101010101000000000
+A519:00000000000010101FF010100000010001000100000010101FF0101000000000
+A51A:000000000000000000001C703EF83EF83EF83EF83EF81C70482437D800000000
+A51B:000000000000000000001C70228822882288228822881450482437D800000000
+A51C:00000000000000002000204020003FE020083FE0200020402000000000000000
+A51D:000000000000000020002000204020003FE82000204020002000000000000000
+A51E:000000000000A00AA00AA00AA44AAAAAAAAAAAAAA44AFBBEA00AA00A00000000
+A51F:0000000000002008200820082C68329821082288228822882108200800000000
+A520:000000000000042004200420042004203FFC0420042004200420042000000000
+A521:000000000000062009600A6004A0032000200020002000200020007800000000
+A522:0000000000000810142822440990024002400240024002400240018000000000
+A523:000000000000082000001C70228822882288228822881450482437D800000000
+A524:000000000000124012400DC0004000480078004800400040004001F000000000
+A525:000000000000124012400DC000500044007C004400500040004001F000000000
+A526:000000000000124012400DC00040044407FC044400400040004001F000000000
+A527:000000000000000003800440004001800240024001800200022001C000000000
+A528:000000000000124012400DC00040124012400DC0007000C80548023001000000
+A529:000000000000124012400DC00040124012400DC0007000CA0532020C01000000
+A52A:0000000000000E000F800FE00F800E000C000E000F800FE00F800E0000000000
+A52B:000000000000308C49523E3C0410041004100410041004100808100400000000
+A52C:0000000000000E001100110011100A100FF00A101110110011000E0000000000
+A52D:0000000000000E001100110011500A100FF00A101150110011000E0000000000
+A52E:00000000000003800D6011101390244824482388145018300C60038000000000
+A52F:0000000000003FF801000100054001000FE00100054001000100010000000000
+A530:000000000000010001000100054001003FF80100054001000100010000000000
+A531:0000000000001110111011101EE01000100010001110111011100EE000000000
+A532:00000000000000C00100111011101EE01000111011100EE00080030000000000
+A533:000000000000121012200DC00080008001100100012401040088007000000000
+A534:000000000000121012200DC00088008001100100012401040088007000000000
+A535:00000000000008000800080009E00A500C900860080008000800080000000000
+A536:00000000000008000A00080009E00A500C9008600A0008000800080000000000
+A537:00000000000000000000018003C007E007E003C0018000000000000000000000
+A538:00000000000000000000018003C007E007E003C001800000071008E000000000
+A539:00000000000000000000018003C007E017E803C0018000000000000000000000
+A53A:00000000000001000200010044A245223BDC0100008001000200010000000000
+A53B:0000000000001C0022002200222814281FE814282228220022001C0000000000
+A53C:0000000000001C002200220022A814281FE8142822A8220022001C0000000000
+A53D:0000000000000060018006000180186024101860018006000180006000000000
+A53E:0000000000000060018006000180186024141860018006000180006000000000
+A53F:00000000000003E004000FC008000800080009800A400C400440038000000000
+A540:00000000000000000000000004404C6433980000000000000000000000000000
+A541:0000000000000000000004400000000004404C64339800000000000000000000
+A542:00000000000000000100000004404C6433980000000001000000000000000000
+A543:00000000000001000200040004000800080009C00A200C20042003C000000000
+A544:00000000000001000200040004000800080009C00A200CA0042003C000000000
+A545:000000000000248024801B80008000A8008801F8028804A80480030000000000
+A546:0000000000000738084010801080210021002100108010800840073800000000
+A547:00000000000007E0001007E00400043005D00610001003F0040003F000000000
+A548:00000000000000800080008000800080008007F8088808880888070800000000
+A549:0000000000000380044004400440038001000540010005400100010000000000
+A54A:00000000000000000380044004400440044004402288210812900C6000000000
+A54B:00000000000000000380044004400444044004402288210812900C6400000000
+A54C:000000000000442244224E7235AC042004200420042004200420042000000000
+A54D:00000000000000000100444444444EE437D80440044005400440044000000000
+A54E:000000000000121012200DC00080008001000100010401040088007000000000
+A54F:000000000000248024801B8000800080008000B000C8008000B000C800000000
+A550:000000000000222022201DE00020002000A80020002000200020002000000000
+A551:000000000000380E44104220424032400FF0024C024204420822701C00000000
+A552:0000000000003FE020202020203C202422242024203C202020203FE000000000
+A553:00000000000000003FF02088208824B0208020803FF000080008003000000000
+A554:00000000000001000100028002800440044008200820101010101FF000000000
+A555:0000000003800C6018301450228821082288145018300C600380000000000000
+A556:00000000000001000100028012900440044008200820101010101FF000000000
+A557:0000000000000FC008200810081008200FC008200810081008200FC000000000
+A558:00000000000003C00420082001C001000100010001C00820042003C000000000
+A559:00000000000010F011081208107010401FC0104010701208110810F000000000
+A55A:0000000000001110111013900D60010001000100010001000100010000000000
+A55B:00000000000017D0111013900D6001000100010001000100010007C000000000
+A55C:0000000000000008010800081108110812980C68000801080008000800000000
+A55D:00000000000000140214001422142214253418D4001402140014001400000000
+A55E:0000000000000A000A000A000BF00A000A000BF00A000A000A000A0000000000
+A55F:0000000000000A000A000A000BF00A000A000BF00A000200071008E000000000
+A560:0000000000000030000800083FF02220222022202220222022203FE000000000
+A561:0000000000000030008800083FF02220222422202220222022203FE000000000
+A562:0000000000000EE01110111011100FE003800440044004400380000000000000
+A563:0000000000000EE01110111011100FE003800440044014500380000000000000
+A564:000000000000000000000EE0111011100FE0111011100EE00000000000000000
+A565:000000000000010000000EE0111011104FE4111011100EE00000010000000000
+A566:000000000000003001C006401880010007001930014801880088007000000000
+A567:0000000000001FF0038003800540054009200920111011102108210800000000
+A568:0000000000000EE0111011101FF0038005400540092009201110111000000000
+A569:000000000000121012200DC00080488049003700010401040088007000000000
+A56A:00000000000004000800086004A0032000200020002000200020002000000000
+A56B:0000000000000E00110011000100010002000C3810443FC40044003800000000
+A56C:0000000000001FF022882288228822881FF022882288228822881FF000000000
+A56D:000000000000442244224E7235AC042004200420442244224A52318C00000000
+A56E:0000000000003018482444443FF8044004400440044008200820101000000000
+A56F:0000000000000FE00100010001000100010001000100010001000FE000000000
+A570:000000000000444044403BC000400040007C0044004400440044007C00000000
+A571:00000000000010001F8010800080008800F8008800800080008001C000000000
+A572:00000000000010001F80108000A0008800F8008800A00080008001C000000000
+A573:00000000000010001F801080008008880FF8088800800080008001C000000000
+A574:0000000000001C0008000800080008080FF8008800800080008001C000000000
+A575:0000000000001C0008000800082008080FF8008800A00080008001C000000000
+A576:0000000000000390045008300810040003800040002008200C400B8000000000
+A577:0000000000000390045009300810040003800040002009200C400B8000000000
+A578:0000000000000000006001900610186010001200106011901610186000000000
+A579:000000000000000000000000381C7C3E7FFE7C3C381C00000000000000000000
+A57A:0000000000000100028002800440044008200440044002800280010000000000
+A57B:0000000000000100028002800440044028280440044002800280010000000000
+A57C:000000000000002000200FE0082008200820082008200FE00020002000000000
+A57D:0000000000002108210823881D70010001000FE0010001000100010000000000
+A57E:0000000000002108210823881D70010001000FE001000FE00100010000000000
+A57F:00000000000000E011000200020002001200020002000200110000E000000000
+A580:00000000000000E011000200020002001220020002000200110000E000000000
+A581:000000000000442244224E7235AC0420042004200420042004200E7000000000
+A582:000000000000442244224E7235AC0420042004A00420042004200E7000000000
+A583:000000000000248024801B80009800A800C80188028004800480030000000000
+A584:000000000000248024981BA800C8018802800480048003001C40238000000000
+A585:0000000000000FE001004104410441047FFC41044104410401000FE000000000
+A586:000000000000248024801B800080008000F001A802A804900480030000000000
+A587:000000000000222022202220222022203FE0002000200020002000F800000000
+A588:000000000000222022202220222022203FE00020002000A8002000F800000000
+A589:0000000000000380044004400440028001000280044004400440038000000000
+A58A:0000000000000380044014500440028001000280044014500440038000000000
+A58B:0000000000000100010001000920010001000100092001000100010000000000
+A58C:0000000000000100010001000100010009200100010001000100010000000000
+A58D:0000000000001040104010401040104012481040104010401040104000000000
+A58E:0000000000000400040004000480040004000400048004000400040000000000
+A58F:0000000000003018482444443FF80440044004400440082008201FF000000000
+A590:0000000000003018482444443FF8044004400440082008281FF8000800000000
+A591:0000000000003F800080008007F8008800880088008800880008000800000000
+A592:00000000000000000000010038387C7C7FFC7C7C383801000000000000000000
+A593:0000000000004900490037200100017801840324050809000900060000000000
+A594:0000000000000FE00100010009200100010001000920010001000FE000000000
+A595:0000000000002108210823881D700100010005F4001000100010001000000000
+A596:0000000000004210421047103AE0020002000BE8002000F8002000F800000000
+A597:0000000000004210421047103AE00200020003E000200020002000F800000000
+A598:00000000000003800C6010101390244824482288911292924C64339800000000
+A599:0000000000002108210823881D700100010001F0001000100010001000000000
+A59A:0000000000004210421047103AE00200020003E0002000F8002000F800000000
+A59B:0000000000000420042004203FFC0420042004203FFC04200420042000000000
+A59C:0000000000003838444444444444383800000380044004400440038000000000
+A59D:0000000000000E001100110011000A0007F00A081108111011000E0000000000
+A59E:0000000000000E001100110011400A0007F00A081148111011000E0000000000
+A59F:000000000000100029082B881D700100010001000100010001000FE000000000
+A5A0:000000000000100029082B881D700100010001000540010001000FE000000000
+A5A1:000000000000101029282BA81D700100010001000100010001000FE000000000
+A5A2:0000000000000060008001003938454447C445443938010002000C0000000000
+A5A3:000000000000001800200040385C446247E246623A5C024004801B0000000000
+A5A4:000000000000070008800880088007000240020003E002000240020000000000
+A5A5:0000000000000E001100110011000E0004A0042007E0042004A0040000000000
+A5A6:0000000000001130115011501190119011101310131015101510191000000000
+A5A7:0000000000001130115011501190119051141310131015101510191000000000
+A5A8:000000000000000000001000100010001FF01008100810080030000000000000
+A5A9:0000000000001000100010001FF010081008100800300000071008E000000000
+A5AA:000000000000000000001000120010001FF01008120810080030000000000000
+A5AB:000000000000000000001000100010001FF01008100810480070004000000000
+A5AC:0000000000000C30145004100410041000000080008000800080008000000000
+A5AD:0000000000000C30145004100410041000000080008002A00080008000000000
+A5AE:0000000000000C3014500410041004100000008000800080008003E000000000
+A5AF:0000000000000C30145004100410041000000080008002A0008003E000000000
+A5B0:000000000000000000001100150011001FF01108150811080030000000000000
+A5B1:000000000000000000001100110011001FF01108110811080030000000000000
+A5B2:000000000000000000001500150015001FF01508150815080030000000000000
+A5B3:000000000000000000001400150014001FF01408150814080030000000000000
+A5B4:00000000000003800C6010101010200821082008101010100C60038000000000
+A5B5:000000000000038004400540044003800100010005400100010007C000000000
+A5B6:000000000000038004400540044003800100010001000100010007C000000000
+A5B7:00000000000004000860086004A0032004200420042004200420042000000000
+A5B8:0000000000001FF0111011101110111011F011101110111011101FF000000000
+A5B9:0000000000000820082008200920082008200920082008200440038000000000
+A5BA:000000000000111011101EE01000111011101EE01000111011100EE000000000
+A5BB:0000000000003838044002800280028022900280028002800440383800000000
+A5BC:0000000000003938044002800280028002800280028002800440393800000000
+A5BD:00000000000022301DD022301DD022301DD00010001000100010007C00000000
+A5BE:0000000000007C7C044004400440044007C004400440044004407C7C00000000
+A5BF:000000000000111011100EE00000111011100EE00000111011100EE000000000
+A5C0:00000000000022301DD022301DD022301DD000100010007C0010007C00000000
+A5C1:000000000000000000000000381C442247E246623A5C024004801B0000000000
+A5C2:00000000000000D8012002403A5C466247E246623A5C024004801B0000000000
+A5C3:0000000000000030004800880110020007000F801FC00F800700020000000000
+A5C4:0000000000000030004800880110124007000F801FC00F800700020000000000
+A5C5:000000000000221022301DD00010221022301DD0001000100010007C00000000
+A5C6:000000000000221022301DD00010221022301DD0001000540010007C00000000
+A5C7:0000000000000FE002800280044004400820482430181FF00820044000000000
+A5C8:00000000000007C0000007C001000280044028285FF428281450082000000000
+A5C9:000000000000000003C004200FF0042003C004200420042003C0000000000000
+A5CA:000000000000000003C004200FF0042003C004200FF0042003C0000000000000
+A5CB:0000000000001FF010001000100010001FF010001000100010001FF000000000
+A5CC:000000000000124012400DC000480050006000C0014002400240018000000000
+A5CD:0000000000001FF010001080100010001FF010001080100010001FF000000000
+A5CE:000000000000124012400DC000480050006004C8014002400240018000000000
+A5CF:000000000000000003C004200400040003C004200420042003C0000000000000
+A5D0:00000000000003C004200400040003C00420042003C00000071008E000000000
+A5D1:0000000000000C6012902108228802800280010001000100010007C000000000
+A5D2:0000000000000C6012902108228802800280010001000540010007C000000000
+A5D3:00000000000000E001300230020002E0033002300200020002000F8000000000
+A5D4:00000000000000E001300230020002E00B3402300200020002000F8000000000
+A5D5:00000000000000E001300230020002E00330023002000F8002000F8000000000
+A5D6:00000000000000E001300230020002E00B34023002000F8002000F8000000000
+A5D7:00000000000003E00210021003E00210021003E002000A8002000F8000000000
+A5D8:00000000000007F00508050805F00508050805F00500050005001FC000000000
+A5D9:00000000000007F00508050805F00508050805F00500154005001FC000000000
+A5DA:000000000000000003E004100490041003E004100490041003E0000000000000
+A5DB:00000000000001E006100860080009C00E2008C0080008F00B080C3000000000
+A5DC:00000000000000000000044040044444644C5BB4400444200000000000000000
+A5DD:0000000000000000010000000380044008200820082004400380101000000000
+A5DE:0000000000001FF00000038004400820082008200440038000001FF000000000
+A5DF:00000000000003D00450087008500400038000400A200A200E400B8000000000
+A5E0:0000000000003870448842840204020407F808101020204059B266CC00000000
+A5E1:000000000000044004A004A004A004C807500C20145014501450082000000000
+A5E2:000000000000000000020002309248924C924B6E300200020002000000000000
+A5E3:0000000000003E100808083408C00B000C000B0008C0083408083E1000000000
+A5E4:000000000000084014A014A014A008C8155026200A500A500A50042000000000
+A5E5:000000000000084014A014A014A048CA155026200A500A500A50042000000000
+A5E6:0000000000000C6012902108228802800280010001000120012000C000000000
+A5E7:0000000000000C6012902108228802800280010001000128013000C000000000
+A5E8:00000000000000C003000C00030000C0002000C003000C00030000C000000000
+A5E9:00000000000000C003000C00030000C0082400C003000C00030000C000000000
+A5EA:00000000000010E011001200120012001200120012001200110010E000000000
+A5EB:0000000000001070148011001100110011001100110011001480107000000000
+A5EC:000000000000000000000000381C442247E24422381C00000000000000000000
+A5ED:000000000000000000000000381C442247E24422381C00000240000000000000
+A5EE:0000000000000000000001003838444447C44444383801000000000000000000
+A5EF:000000000000000C0014002470444C8443844264441C48005000600000000000
+A5F0:000000000000000C0114002470444C8443844264441C48005100600000000000
+A5F1:00000000000000F0030804300800080008000800080008F00B080C3000000000
+A5F2:00000000000000F0030806300A000A000A000A000A000AF00B080C3000000000
+A5F3:000000000000038004400440428441047FFC4104428404400440038000000000
+A5F4:000000000000038004400440529441047FFC4104529404400440038000000000
+A5F5:000000000000000003C014281FF8142803C014281FF8142803C0000000000000
+A5F6:000000000000000003C044227FFE442213C844227FFE442203C0000000000000
+A5F7:0000000000001010101010101010101000000100010001000100010000000000
+A5F8:000000000000101010101010101001000100010001000000071008E000000000
+A5F9:0000000000001010101010101010101000000100010009200100010000000000
+A5FA:0000000000000100010001001110101010101010111001000100010000000000
+A5FB:0000000000000100010001000100454445443BB8010001000100010000000000
+A5FC:0000000000000100010001000100454445443BB8010011100100010000000000
+A5FD:0000000000000100010011100100454445443BB8010011100100010000000000
+A5FE:00000000000007C0010011100100454405443BB801001110010007C000000000
+A5FF:0000000000000F00108020800700040007F804000700208010800F0000000000
+A600:0000000000000F00108020800720040007E804000720208010800F0000000000
+A601:0000000000000F00108020800728040807F804080728208010800F0000000000
+A602:0000000000000F00108020880708040807F804080708208810800F0000000000
+A603:0000000000002108210813900D6001000100010001000100010007C000000000
+A604:0000000000002108210813900D6001000100010005400100010007C000000000
+A605:0000000000002108210813900D60010001000540010007C0010007C000000000
+A606:0000000000002108210813900D6001000100010007C00100010007C000000000
+A607:0000000000002108210813900D60010001000100010009200FE0082000000000
+A608:0000000000001248124812481248124812481248124812481248124800000000
+A609:0000000000001EF00100028002800280028002800280028001001EF000000000
+A60A:0000000000002108210813900D600100010001F0015001F0015001F000000000
+A60B:000000000000121012200DC00080008001000138014401440088007000000000
+A60C:0000000000000000000000003FFC0000000000003FFC00000000000000000000
+A60D:0000000000000000000000000000000001000100028002800440044000000000
+A60E:000000000000000000000420024001800FF00180024004200000000000000000
+A60F:0000000000000000000000000000000000003A884694438452C422B800000000
+A610:00000000000001C002200410641064161C1E04100410041002D601CE00000000
+A611:000000000000111011100EE004400440044004400440155015500EE000000000
+A612:000000000000060C183060C01830060C01FE060C183060C01830060C00000000
+A613:00000000000003C004200400040004000380040004000400042003C000000000
+A614:000000000000222022601DA00020002000E40138002000200020002000000000
+A615:0000000000000014071408940894089445144214251418FC0014001400000000
+A616:0000000000000FE00820092008200820092008200820092008200FE000000000
+A617:0000000000000218022802480288020802080208220812080A08060800000000
+A618:00000000000003700D983118010001700198011801000100010007C000000000
+A619:0000000000000FE001000100010001F0010801080130010001000FE000000000
+A61A:0000000000001110000019982220222022202220222019980000111000000000
+A61B:000000000000121012200DC0008000800100010001FC01040088007000000000
+A61C:0000000000003FF8210811101110092009200540054003800380010000000000
+A61D:0000000000000FF008900C900B600800080008000800080008003E0000000000
+A61E:000000000000442044603BA000240020003E0020002400200020002000000000
+A61F:0000000000001C00220022001C6008900510031004E004000200018000000000
+A620:000000000000111011100EE0000007C00820101010101010082007C000000000
+A621:0000000000000080008000800080008000800080008000800080008000000000
+A622:0000000000000380044004400380010005400100054001000164019800000000
+A623:0000000000003800440047804440384003800040004003800200020000000000
+A624:0000000000000C000A00090008000900090009000FE001200120012000000000
+A625:0000000000000C000A00090008000800080009C00A200C100C10082000000000
+A626:00000000000001C002001F8004000400040004C005200620022001C000000000
+A627:0000000000000CC01340004000400040004000E001100110011000E000000000
+A628:00000000000004200000000004200420042003C004200420042003C000000000
+A629:0000000000000070008800880C701220114011800E4000400080030000000000
+A62A:0000000000003018482444443FF8044004400440044048242828101000000000
+A62B:000000000000038004400440044003800100010001000110011000E000000000
+A62C:00007FFE61CE6DBE618E6DB66DCE7FFE7FFE61C67DBE61BE6FBE61C67FFE0000
+A62D:00007FFE61CE6DBE618E6DB66DCE7FFE7FFE618E7DB661B66FB6618E7FFE0000
+A62E:00007FFE61CE6DBE618E6DB66DCE7FFE7FFE61867DBE618E6FBE61867FFE0000
+A62F:00007FFE61CE6DBE618E6DB66DCE7FFE7FFE61867DBE618E6FBE61BE7FFE0000
+A630:00007FFE61CE6DBE618E6DB66DCE7FFE7FFE63CE7DB671B67DB663CE7FFE0000
+A631:00007FFE61CE6DBE618E6DB66DCE7FFE7FFE63EE7DCE71EE7DEE63C67FFE0000
+A632:00007FFE61CE6DBE618E6DB66DCE7FFE7FFE63867DF671867DBE63867FFE0000
+A633:00007FFE61CE6DBE618E6DB66DCE7FFE7FFE638E7DF671C67DF6638E7FFE0000
+A634:00007FFE61CE6DBE618E6DB66DCE7FFE7FFE63B67DB671867DF663F67FFE0000
+A635:00007FFE61CE6DBE618E6DB66DCE7FFE7FFE63867DBE71867DF663867FFE0000
+A636:00007FFE61CE6DBE618E6DB66DCE7FFE7FFE63CE7DBE718E7DB663CE7FFE0000
+A637:00007FFE61CE6DBE618E6DB66DCE7FFE7FFE63867DF671EE7DDE63DE7FFE0000
+A638:00007FFE61CE6DBE618E6DB66DCE7FFE7FFE63CE7DB671CE7DB663CE7FFE0000
+A639:00007FFE61CE6DBE618E6DB66DCE7FFE7FFE63CE7DB671C67DF663CE7FFE0000
+A63A:00007FFE61CE6DBE618E6DB66DCE7FFE7FFE63867DB671867DB663B67FFE0000
+A63B:00007FFE61CE6DBE618E6DB66DCE7FFE7FFE638E7DB6718E7DB6638E7FFE0000
+A63C:00007FFE61CE6DBE618E6DB66DCE7FFE7FFE63C67DBE71BE7DBE63C67FFE0000
+A63D:00007FFE61CE6DBE618E6DB66DCE7FFE7FFE638E7DB671B67DB6638E7FFE0000
+A63E:00007FFE61CE6DBE618E6DB66DCE7FFE7FFE63867DBE718E7DBE63867FFE0000
+A63F:00007FFE61CE6DBE618E6DB66DCE7FFE7FFE63867DBE718E7DBE63BE7FFE0000
+A640:000000007E02020408102040407E3A44
+A641:0000000000007E0204081020407E3A44
+A642:000000007E020204087C2040407E3A44
+A643:0000000000007E02047E1020407E3A44
+A644:000000003C4242020C304042423C0000
+A645:0000000000003C42020C3040423C0000
+A646:00000000202020202020202024180000
+A647:00000000000020202020202024180000
+A648:00000000103810103844828282820000
+A649:00000000000010381038444444440000
+A64A:000000000000424224183C4A524A423C
+A64B:00000000020244442810282828100000
+A64C:00000000000000003C78428442844004400440044004410442843C7800000000
+A64D:00000000000000000000000030184004400440044004410442843C7800000000
+A64E:00000000205050101E111111111E0000
+A64F:0000000000002050501E1111111E0000
+A650:00000000E2222222322A2A2A2A320000
+A651:000000000000E22222322A2A2A320000
+A652:00000000507E50505C525252525C0000
+A653:000000000000507E50505C52525C0000
+A654:00000000324A4A4A4E4A4A4A4A320000
+A655:000000000000324A4A4E4A4A4A320000
+A656:000000008894A2A2FEA2A2A2A2A20000
+A657:0000000000004C42424E7252524E0000
+A658:0000000008081414223E2241417F0000
+A659:000000000000081414223E41417F0000
+A65A:000000003E222214081C227F49490000
+A65B:0000000000003E22143E417F49490000
+A65C:0000000048485454527E6241417F0000
+A65D:000000000000444A4A517F51515F0000
+A65E:0000000000000100038005400540092009202910111001000100010000000000
+A65F:0000000000081C2A2AA9490808080000
+A660:000000002121212121212121217F4040
+A661:000000000000222222222222227E4040
+A662:000000000000000003FC048004800480088008800880108010803FC020402040
+A663:00000000000000000000000007F80480088008801080108010801FC010400000
+A664:00000000000000000FFC08800880088008800880088010801080208000000000
+A665:0000000000000000000000000FF8088008800880088010801080208000000000
+A666:000000000000000021FC2100330033002D002D00210021002100210000000000
+A667:00000000000000000000000021F8330033002D002D0021002100210000000000
+A668:000000003C4242425A5A4242423C0000
+A669:0000000000003C42425A5A42423C0000
+A66A:000000007C82828282AA8282827C0000
+A66B:0000000000003E4141415541413E0000
+A66C:00000000000000001E782184218421842DB42DB42184218421841E7800000000
+A66D:0000000000000000000000001E78218421842DB42DB4218421841E7800000000
+A66E:0E70118815A811880E7039CE463156B5463139CE0E70118815A811880E700000
+A66F:007E4200000000000000000000000000
+A670:0000028001002AA8101028280000A0144008A014000000002828129029280280
+A671:007E420000000000000000000000427E
+A672:0100010007C0010001000000F01E00000000F01E00000000F01E054005400540
+A673:1028EE824482EE281000000000000000
+A674:001C2238221C00000000000000000000
+A675:0022262A322200000000000000000000
+A676:00140008080800000000000000000000
+A677:00221408102000000000000000000000
+A678:0030101C121C00000000000000000000
+A679:004242724A7200000000000000000000
+A67A:00202038243800000000000000000000
+A67B:00545454280000000000000000000000
+A67C:00242418000000000000000000000000
+A67D:000A0A06020000000000000000000000
+A67E:00242418000000000000000000000000
+A67F:000A0A06020000000000000000000000
+A680:001010101E1212122222224242FF8181
+A681:0000000010101E1222224242427F4100
+A682:000000003C424240201008040242423C
+A683:00000000182424201010080804242418
+A684:00000000000000003C464248024802503FE004600250024842443C4200000000
+A685:0000000000000000000000003C46424802503FE00450024842443C4200000000
+A686:0000000092929292926E020202020000
+A687:000000000000929292926E0202020000
+A688:000000001C1414142424244649FA8186
+A689:0000000000001C1424244446497A4106
+A68A:00000000FE1010101619111111110502
+A68B:000000000000FE101016191111110502
+A68C:00000000FE10101010101010120C0000
+A68D:000000000000FE1010101010120C0000
+A68E:0000000042424242424242427E39413E
+A68F:0000000000004242424242427E39413E
+A690:000000007F0808080808080808384030
+A691:0000000000007F080808080808384030
+A692:00000000FA22222222261A0202020000
+A693:000000000000FA222222261A02020000
+A694:00000000304840405864424242420000
+A695:00000000000030484040586444440000
+A696:000000009292929292929292FE39413E
+A697:000000000000929292929292FE39413E
+A698:00000000000000001E78218421842184218421842184218421841E7800000000
+A699:0000000000000000000000001E782184218421842184218421841E7800000000
+A69A:000000007C929292FE929292927C0000
+A69B:0000000000003E49497F4949493E0000
+A69C:0070501C121C00000000000000000000
+A69D:00202038243800000000000000000000
+A69E:081C2A2A2A1C08000000000000000000
+A69F:004C507C504C00000000000000000000
+A6A0:00000000080C0A080808084848300000
+A6A1:000000004246464A4A52526262420000
+A6A2:0000007C007C00384482828244380000
+A6A3:00000000043448485250202040400000
+A6A4:000000000020000020242262528C0000
+A6A5:00000000404040404048407C00080000
+A6A6:000000000020007C02027C0020000000
+A6A7:000000007C0408081010303048460000
+A6A8:000000007E0204040408080808040000
+A6A9:00000000408C92A2A284780000100000
+A6AA:000000001C2222A47820242024200000
+A6AB:00000000103054901050102020200000
+A6AC:00000000401C22222A2A242020200000
+A6AD:0000000002020202027E2212227E0000
+A6AE:00000000405040780404784050400000
+A6AF:00000000001860004860504840400000
+A6B0:00000000704C424C7040404040400000
+A6B1:00000000404040407C40404040400000
+A6B2:00000000928244442828101010100000
+A6B3:000000004444444444444440407E0000
+A6B4:000000008888888A888E505220200000
+A6B5:00000000828282443810101010100000
+A6B6:00000000484848484A48484A48784800
+A6B7:0000000002002C3464A6202820200000
+A6B8:00000000304080988442320204180000
+A6B9:00000000201008041210101010100000
+A6BA:00000000601218244444241810600000
+A6BB:000000004000007848484E4040400000
+A6BC:000000000010C0300C020C30C0100000
+A6BD:00000002040818240202024244380000
+A6BE:00000000505050507C14141414140000
+A6BF:00000000182442422272020204040000
+A6C0:00000000182442427E02020204040000
+A6C1:00000000182442424202020204040000
+A6C2:00000000405E405E4040404040400000
+A6C3:00000000000202020204545428280000
+A6C4:00000000465A62625A46404040400000
+A6C5:0000000008084A485868484840400000
+A6C6:0000000002020202027A0606067A0000
+A6C7:00000002040810204220100804020000
+A6C8:00000000384492925410101010100000
+A6C9:000000007C04080810102020407C0000
+A6CA:0000000010101010242A22524C800000
+A6CB:000000003E1828480808080808080000
+A6CC:00000000100038441804443800100000
+A6CD:0000000070080404083020F820200000
+A6CE:00000000102828284444444482820000
+A6CF:00000000380082C6AAAA920010100000
+A6D0:000000003E4040403E00080808080000
+A6D1:00000000320804040404080810600000
+A6D2:00000000384402020204042810080000
+A6D3:000000001C2222A47820242424240000
+A6D4:00000000101210103854929292920000
+A6D5:00000000605048444040444850600000
+A6D6:00000000404040407848484848440000
+A6D7:00000000385492929280808080800000
+A6D8:00000000C2A29286864A4A5252220000
+A6D9:0000000018284A0C1828480808080000
+A6DA:000000004040404040404840407E0000
+A6DB:000000007E4242424242424242420000
+A6DC:00000000100018244454542404040000
+A6DD:000000003048888A4838080808100000
+A6DE:000000007E0202027E40404040400000
+A6DF:00000000828244444444282828100000
+A6E0:000000003028242224283060A0200000
+A6E1:00000000006294888A7400007E000000
+A6E2:000000201008102020404040221C0000
+A6E3:00000000407C44040404040404040000
+A6E4:000000046211090A0808101020C00000
+A6E5:000000000E1070504E40404040400000
+A6E6:000000003E0808780402020204080000
+A6E7:00000000380808780402020204080000
+A6E8:000000007050501010101010107C0000
+A6E9:00000000080808780402020204080000
+A6EA:00000000182848083C02020204080000
+A6EB:00000000700804040830202020200000
+A6EC:000000001018141210101010107C0000
+A6ED:00000000700804044830282420200000
+A6EE:000000001E1212121212121212720000
+A6EF:000000003844422204182042423C0000
+A6F0:00102844000000000000000000000000
+A6F1:003E0000000000000000000000000000
+A6F2:00000000200008040402020244380000
+A6F3:00000000040408081010242040400000
+A6F4:00000000222222224455448888880000
+A6F5:00000000000000003E08101020200000
+A6F6:0000000000000000F424484A90900000
+A6F7:00000000101010109254381000100000
+A6F8:00007FFE61CE6DBE618E6DB66DCE7FFE7FFE61CE6FB663CE6FB66FCE7FFE0000
+A6F9:00007FFE61CE6DBE618E6DB66DCE7FFE7FFE61CE6FB663C66FF66FCE7FFE0000
+A6FA:00007FFE61CE6DBE618E6DB66DCE7FFE7FFE61866FB663866FB66FB67FFE0000
+A6FB:00007FFE61CE6DBE618E6DB66DCE7FFE7FFE618E6FB6638E6FB66F8E7FFE0000
+A6FC:00007FFE61CE6DBE618E6DB66DCE7FFE7FFE61C66FBE63BE6FBE6FC67FFE0000
+A6FD:00007FFE61CE6DBE618E6DB66DCE7FFE7FFE618E6FB663B66FB66F8E7FFE0000
+A6FE:00007FFE61CE6DBE618E6DB66DCE7FFE7FFE61866FBE638E6FBE6F867FFE0000
+A6FF:00007FFE61CE6DBE618E6DB66DCE7FFE7FFE61866FBE638E6FBE6FBE7FFE0000
+A700:0000000000000000001C20201C000000
+A701:0000000000000000001C20201C003C00
+A702:000000001C20201C0000000000000000
+A703:000000001C20201C003C000000000000
+A704:00000000380404380000000000000000
+A705:0000000038040438003C000000000000
+A706:00000000000000000038040438000000
+A707:00000000000000000038040438003C00
+A708:00000000501010101010101010100000
+A709:00000000101050101010101010100000
+A70A:00000000101010105010101010100000
+A70B:00000000101010101010105010100000
+A70C:00000000101010101010101010500000
+A70D:00000000141010101010101010100000
+A70E:00000000101014101010101010100000
+A70F:00000000101010101410101010100000
+A710:00000000101010101010101410100000
+A711:00000000101010101010101010140000
+A712:000000001E1010101010101010100000
+A713:0000000010101E101010101010100000
+A714:00000000101010101E10101010100000
+A715:00000000101010101010101E10100000
+A716:000000001010101010101010101E0000
+A717:00000000101050101000000000000000
+A718:00000000001204081000000000000000
+A719:00000000000010007C00000000000000
+A71A:00000000000004047C00000000000000
+A71B:0000000010387C101010000000000000
+A71C:000000001010107C3810000000000000
+A71D:00000000101010100010000000000000
+A71E:00000000100010101010000000000000
+A71F:00000000000000001000101010100000
+A720:007E5050000000000000000000000000
+A721:00000000000000000000000050507E00
+A722:00007078040438000070780404380000
+A723:00000030380404180030380404180000
+A724:00000000387C604040403C0000000000
+A725:000000000000387C604040403C000000
+A726:00000000424242427E4242424242120C
+A727:0000004040405C62424242424242120C
+A728:00000000000000003F800400040007F8041004200440047004080008010800F0
+A729:00000000000000000800080008003FFC08080810082008380804060400840078
+A72A:000000003C424850304C4040423C0000
+A72B:000000001C22202018202020221C0000
+A72C:00000000040C1424447C040424180000
+A72D:000000000000040C14247C0404042418
+A72E:000000000818284888FE08084B310102
+A72F:00000000000008182848FE080B094932
+A730:0000000000007C404078404040400000
+A731:0000000000003C4240300C02423C0000
+A732:00000000000000000C6012901290210821083FF8210821082108210800000000
+A733:0000000000000000000000001EF0210801081FF82108210823181DE800000000
+A734:00000000000000000CF013081308210821083F0821082108210820F000000000
+A735:0000000000000000000000001EF0210801081F082108210823081CF000000000
+A736:00000000000000000C0812081208210821083F0821082108210820F000000000
+A737:0000000000000000000000001E08210801081F082108210823181CE800000000
+A738:00000000000000000E0812081208211021103F1020A020A02040204000000000
+A739:0000000000000000000000001E08210801081F902190219022601C6000000000
+A73A:00000000000000000E0812081208211021103FF820A020A02040204000000000
+A73B:0000000000000000000000001E08210801081FFC2190219022601C6000000000
+A73C:00000000000000000E0812081208211021103F1020A020A02040204004800300
+A73D:0000000000000000000000001E08210801081F902190219022601C60012000C0
+A73E:000000003C4242021A1A0242423C0000
+A73F:0000000000003C42021A1A02423C0000
+A740:0000000042E448506060504844420000
+A741:00000040F04044485060504844420000
+A742:00000000424448506060544854420000
+A743:00000040404044485060544854420000
+A744:0000000042E448506060544854420000
+A745:00000040F04044485060544854420000
+A746:000000004040404040202020203E0000
+A747:000000301010101008080808083E0000
+A748:0000000040F0404040404040407E0000
+A749:0000001808081C0808080808083E0000
+A74A:000000003C424242FF424242423C0000
+A74B:0000000000003C4242FF4242423C0000
+A74C:0000000275898E888888888888700000
+A74D:00000000000275898E88888888700000
+A74E:00000000000000001EF0210821082108210821082108210821081EF000000000
+A74F:0000000000000000000000001EF02108210821082108210821081EF000000000
+A750:000000007C4242427C404040F0400000
+A751:0000000000005C6242424242625CF040
+A752:000000001E1111117E90909050100000
+A753:00000000000016191111111179969050
+A754:000000004EA929291E08080808080000
+A755:0000000000004AAD292929291D0A0808
+A756:000000003C4242424242425A643D0205
+A757:0000000000003A4642424242463A0702
+A758:00000000000000000F00108010901088108810881090169019200F4000800140
+A759:0000000000000000000000000E901188108810881090109011A00EC001800280
+A75A:000000003C4242020408080404020000
+A75B:0000000000003C4202021C1008040000
+A75C:00000000788404040810224284FE0408
+A75D:000000000000384404081222447E0408
+A75E:00000000494949323222545488880000
+A75F:0000000000004A4A5234646498980000
+A760:00000000424242425A5A66664242020C
+A761:00000000000041494949494949370106
+A762:0000003C4040403E0408101C0202423C
+A763:00000000003040403C08102038044438
+A764:00005060C07844424244784040400000
+A765:000000506040DC6242424242625C4040
+A766:000000404078444242447840F0400000
+A767:0000004040405C6242424242625CF040
+A768:00000000444444484850506040400000
+A769:00000000000022222424283020200000
+A76A:00000000384404041804040404380000
+A76B:00000000000038440404180404040438
+A76C:0000000C1212127C1010101050200000
+A76D:0000000C1212127C1010101010105020
+A76E:00000000182442424A32020204380000
+A76F:000000000000182442424A3202020438
+A770:00001824424A32020438000000000000
+A771:0000000000000100010001001D002300210021082108211023241DF800400080
+A772:00000000000018000800080008000800080008100810082008483FF000800100
+A773:000000000000000000000000760049004900490849084910492449F800400080
+A774:0000000000000000000000005C0062004200421042104220424843F000800100
+A775:00000000002000200040009017E0190012001000100010001000100000000000
+A776:0000000000000000000000007C00420042007C1050104820444843F000800100
+A777:00000000000000201020104010907FE0110012001000100010000C0000000000
+A778:0000000038444444381C224202FC0000
+A779:00000000FC22424242424242423C0000
+A77A:000040300804023E42424242423C0000
+A77B:000000005C6240404040407840404040
+A77C:0000000000002C322020202038202020
+A77D:000000007E0408101008384444443800
+A77E:000000001C2222221C10080810207E00
+A77F:0000000000003C42423C10080810207E
+A780:000000007E0202020202020202020000
+A781:00000000003E0808080808080808080C
+A782:000000005C6242424242414040400000
+A783:00000000000058644444424040404040
+A784:000000002E3020202020202020202020
+A785:0000000000002E302020202020202020
+A786:000000007E10204040404040221C0000
+A787:0000000000007E1020404040221C0000
+A788:00000000000000000000000000182442
+A789:00000000000000181800001818000000
+A78A:00000000000000003C00003C00000000
+A78B:00000000080808080808080000000000
+A78C:00000000080808080800000000000000
+A78D:00000000424242427E02020202020000
+A78E:00000018080838483E08080808080600
+A78F:0000000000183C3C1800000000000000
+A790:0000000044646454544C4C4444460202
+A791:00000000000058644444444444460202
+A792:000000001C22222070202022221C0000
+A793:0000000000001C2220702020221C0000
+A794:0000000000003C4240404040423E020C
+A795:0000004040405C624242424242430106
+A796:000000001C1212123C525252121C0000
+A797:00000000101010101C325252525C4030
+A798:000000001E1010107C10101010101060
+A799:0000000C1010107C107C101010100000
+A79A:000000003A46422212224242463A0000
+A79B:0000000000003A4642322242463A0000
+A79C:00000000384442221222424244380000
+A79D:00000000000038444232224244380000
+A79E:000000004242422212224242463A0000
+A79F:000000000000424242322242463A0000
+A7A0:000000003D424648506642C2463A0000
+A7A1:0000000000023A477CC438203C42423C
+A7A2:000000004244485062645868C4420000
+A7A3:000000404040444850605678C4420000
+A7A4:00000000426263565A6ACA4646420000
+A7A5:0000000000005C634E72C24242420000
+A7A6:000000007C475AE27C48444442420000
+A7A7:0000000000005C6242506040C0400000
+A7A8:000000003C42404C30CC0242423C0000
+A7A9:0000000000001E2026186601211E0000
+A7AA:0000000062A2A2223E22222222220000
+A7AB:000000003C4202021C020202423C0000
+A7AC:000000003C424242424242464A320478
+A7AD:000000001010103050543810101E0000
+A7AE:000000007F49490808080849497F0000
+A7AF:0000000000003C424242425A663C0300
+A7B0:000000004222120A06060A1222420000
+A7B1:000000000808080808080808087F0000
+A7B2:000000001F040404040424544C380400
+A7B3:00000000424224241818182424424200
+A7B4:000000007C4242427C424242427C4040
+A7B5:000000003844444858444242524C4040
+A7B6:00000000225541414141494949360000
+A7B7:00000000000022554141494949360000
+A7B8:0000000042424342464A526242BC0000
+A7B9:0000000000004342464A526246BA0000
+A7BA:0000006028541422223E222222220000
+A7BB:0000180810003C42023E4242463A0000
+A7BC:000000603E48080808080808083E0000
+A7BD:000018081000180808080808083E0000
+A7BE:000000C062A2222222222222221C0000
+A7BF:000018081000424242424242463A0000
+A7C0:00007FFE61866DF661EE6DDE6DDE7FFE7FFE71CE6FB66FB66FB671CE7FFE0000
+A7C1:00007FFE61866DF661EE6DDE6DDE7FFE7FFE71EE6FCE6FEE6FEE71C67FFE0000
+A7C2:0000000000800100417041884108220822702208150815080888087000000000
+A7C3:00000000000000000100020042F0430842082670250825081888187000000000
+A7C4:000000003C42424040404042463A020C
+A7C5:000000003C424240300C0242625C4030
+A7C6:000000007E02020408102040427E020C
+A7C7:00000000784442427E42424244780000
+A7C8:0000000202023A46427E4242463A0000
+A7C9:000000003C424220107E0442423C0000
+A7CA:0000000000003C42307E0C02423C0000
+A7CB:00007FFE61866DF661EE6DDE6DDE7FFE7FFE718E6FB66F8E6FB6718E7FFE0000
+A7CC:00007FFE61866DF661EE6DDE6DDE7FFE7FFE71C66FBE6FBE6FBE71C67FFE0000
+A7CD:00007FFE61866DF661EE6DDE6DDE7FFE7FFE718E6FB66FB66FB6718E7FFE0000
+A7CE:00007FFE61866DF661EE6DDE6DDE7FFE7FFE71866FBE6F8E6FBE71867FFE0000
+A7CF:00007FFE61866DF661EE6DDE6DDE7FFE7FFE71866FBE6F8E6FBE71BE7FFE0000
+A7D0:00007FFE61866DF661EE6DDE6DDE7FFE7FFE63CE6DB66DB66DB663CE7FFE0000
+A7D1:00007FFE61866DF661EE6DDE6DDE7FFE7FFE63EE6DCE6DEE6DEE63C67FFE0000
+A7D2:00007FFE61866DF661EE6DDE6DDE7FFE7FFE63866DF66D866DBE63867FFE0000
+A7D3:00007FFE61866DF661EE6DDE6DDE7FFE7FFE638E6DF66DC66DF6638E7FFE0000
+A7D4:00007FFE61866DF661EE6DDE6DDE7FFE7FFE63B66DB66D866DF663F67FFE0000
+A7D5:00007FFE61866DF661EE6DDE6DDE7FFE7FFE63866DBE6D866DF663867FFE0000
+A7D6:00007FFE61866DF661EE6DDE6DDE7FFE7FFE63CE6DBE6D8E6DB663CE7FFE0000
+A7D7:00007FFE61866DF661EE6DDE6DDE7FFE7FFE63866DF66DEE6DDE63DE7FFE0000
+A7D8:00007FFE61866DF661EE6DDE6DDE7FFE7FFE63CE6DB66DCE6DB663CE7FFE0000
+A7D9:00007FFE61866DF661EE6DDE6DDE7FFE7FFE63CE6DB66DC66DF663CE7FFE0000
+A7DA:00007FFE61866DF661EE6DDE6DDE7FFE7FFE63866DB66D866DB663B67FFE0000
+A7DB:00007FFE61866DF661EE6DDE6DDE7FFE7FFE638E6DB66D8E6DB6638E7FFE0000
+A7DC:00007FFE61866DF661EE6DDE6DDE7FFE7FFE63C66DBE6DBE6DBE63C67FFE0000
+A7DD:00007FFE61866DF661EE6DDE6DDE7FFE7FFE638E6DB66DB66DB6638E7FFE0000
+A7DE:00007FFE61866DF661EE6DDE6DDE7FFE7FFE63866DBE6D8E6DBE63867FFE0000
+A7DF:00007FFE61866DF661EE6DDE6DDE7FFE7FFE63866DBE6D8E6DBE63BE7FFE0000
+A7E0:00007FFE61866DF661EE6DDE6DDE7FFE7FFE61CE6FB663B66FB661CE7FFE0000
+A7E1:00007FFE61866DF661EE6DDE6DDE7FFE7FFE61EE6FCE63EE6FEE61C67FFE0000
+A7E2:00007FFE61866DF661EE6DDE6DDE7FFE7FFE61866FF663866FBE61867FFE0000
+A7E3:00007FFE61866DF661EE6DDE6DDE7FFE7FFE618E6FF663C66FF6618E7FFE0000
+A7E4:00007FFE61866DF661EE6DDE6DDE7FFE7FFE61B66FB663866FF661F67FFE0000
+A7E5:00007FFE61866DF661EE6DDE6DDE7FFE7FFE61866FBE63866FF661867FFE0000
+A7E6:00007FFE61866DF661EE6DDE6DDE7FFE7FFE61CE6FBE638E6FB661CE7FFE0000
+A7E7:00007FFE61866DF661EE6DDE6DDE7FFE7FFE61866FF663EE6FDE61DE7FFE0000
+A7E8:00007FFE61866DF661EE6DDE6DDE7FFE7FFE61CE6FB663CE6FB661CE7FFE0000
+A7E9:00007FFE61866DF661EE6DDE6DDE7FFE7FFE61CE6FB663C66FF661CE7FFE0000
+A7EA:00007FFE61866DF661EE6DDE6DDE7FFE7FFE61866FB663866FB661B67FFE0000
+A7EB:00007FFE61866DF661EE6DDE6DDE7FFE7FFE618E6FB6638E6FB6618E7FFE0000
+A7EC:00007FFE61866DF661EE6DDE6DDE7FFE7FFE61C66FBE63BE6FBE61C67FFE0000
+A7ED:00007FFE61866DF661EE6DDE6DDE7FFE7FFE618E6FB663B66FB6618E7FFE0000
+A7EE:00007FFE61866DF661EE6DDE6DDE7FFE7FFE61866FBE638E6FBE61867FFE0000
+A7EF:00007FFE61866DF661EE6DDE6DDE7FFE7FFE61866FBE638E6FBE61BE7FFE0000
+A7F0:00007FFE61866DF661EE6DDE6DDE7FFE7FFE61CE6FB663B66FB66FCE7FFE0000
+A7F1:00007FFE61866DF661EE6DDE6DDE7FFE7FFE61EE6FCE63EE6FEE6FC67FFE0000
+A7F2:00007FFE61866DF661EE6DDE6DDE7FFE7FFE61866FF663866FBE6F867FFE0000
+A7F3:00007FFE61866DF661EE6DDE6DDE7FFE7FFE618E6FF663C66FF66F8E7FFE0000
+A7F4:00007FFE61866DF661EE6DDE6DDE7FFE7FFE61B66FB663866FF66FF67FFE0000
+A7F5:00000000040404043C04040404040000
+A7F6:0000000000000404043C040404040000
+A7F7:0000000000000000427E420000000000
+A7F8:00000042FF427E424242000000000000
+A7F9:000000000036494F4837000000000000
+A7FA:000000000000494949494949497F0000
+A7FB:000000007E0202023E02020202020000
+A7FC:000000003E4242423E02020202020000
+A7FD:00000000424242425A5A666642420000
+A7FE:00003E080808080808080808083E0000
+A7FF:000000000000000010411041104128A228A228A2451445148208820800000000
+A800:000000000000FFFF003000500090011002100410081010106008000000000000
+A801:000000000000FFFF040005000680048001000600010000800040000000000000
+A802:0480024001200000000000000000000000000000000000000000000000000000
+A803:000000000000FFFF080011E02210241020E02110201010200FC0000000000000
+A804:0E0001000080FFFF10801080108011001E001000100010000800000000000000
+A805:000000000000FFFF0040034004C00840084004C0034018401840000000000000
+A806:004000A001100000000000000000000000000000000000000000000000000000
+A807:000000000000FFFF226022A023202E2032200220022002200110000000000000
+A808:000000000000FFFF26602AA03320222000200020002000200010000000000000
+A809:000000000000FFFF0840084004400C4014401440084000400020000000000000
+A80A:000000000000FFFF00C003400440034000C003400440034000E0000000000000
+A80B:0030004800300000000000000000000000000000000000000000000000000000
+A80C:000000000000FFFF004000C00140024004400840064001C00020000000000000
+A80D:000000000000FFFF100011801280148019E00290046008000800000000000000
+A80E:000000000000FFFF0820102021E0212011200E20002000200010000000000000
+A80F:000000000000FFFF200026002A28322802480248029002900320000000000000
+A810:000000000000FFFF0700088008400480010002400420082007C0000000000000
+A811:000000000000FFFF080008000B000C800880088009000A000C00000000000000
+A812:000000000000FFFF010001000960119011101010102008400780000000000000
+A813:000000000000FFFF0800080009800A400A400880088009000600000000000000
+A814:000000000000FFFF0040004018C01F4008400840084010402020000000000000
+A815:000000000000FFFF0020026006A02B2012200020002000200010000000000000
+A816:000000000000FFFF100011801280148018800080008000400030000000000000
+A817:000000000000FFFF2010203013500D9001100010001000100008000000000000
+A818:000000000000FFFF006000A00120022005200520052002200010000000000000
+A819:000000000000FFFF206020A02120222024202820302020200010000000000000
+A81A:000000000000FFFF40C041704248445048605050604840400020000000000000
+A81B:000000000000FFFF00400040074008C008C00740004000400020000000000000
+A81C:000000000000FFFF01E0022004201E2025200220002000200010000000000000
+A81D:000000000000FFFF406020A011200A2004200A200A2004200010000000000000
+A81E:000000000000FFFF006000A0012012200C200020002000200010000000000000
+A81F:000000000000FFFF006000A0012012200C2000A0012002200190000000000000
+A820:000000000000FFFF010001000160019001100010002000400780000000000000
+A821:000000000000FFFF00100E301150119002100510009000900008000000000000
+A822:000000000000FFFF206020A021202220242028A0312022200190000000000000
+A823:000000000000000F000200020002000200020002000200020001000000000000
+A824:000C00120002000F000200020002000200020002000200020001000000000000
+A825:0000000000000000000000000000000000000000000000080008001001E00000
+A826:0200010000800000000000000000000000000000000000000000000000000000
+A827:000800040002000F000200020002000200020002000200020001000000000000
+A828:00000000000030484830000000000000
+A829:00000000304848300030484830000000
+A82A:0000000000000000301848244824301800000180024002400180000000000000
+A82B:00000000000000000C60129012900C6000000C60129012900C60000000000000
+A82C:0000000000000000000000000000000000000000000000000000018000400020
+A82D:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE618E7DB661B66FB6618E7FFE0000
+A82E:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE61867DBE618E6FBE61867FFE0000
+A82F:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE61867DBE618E6FBE61BE7FFE0000
+A830:0000000000000080008000800080008000800080008000800080000000000000
+A831:0000000000000120012001200120012001200120012001200120012000000000
+A832:0000000000000920092009200920092009200920092009200920092000000000
+A833:00000000000000000000000000000000007003801C0000000000000000000000
+A834:000000000000000000000000007003801C000000007003801C00000000000000
+A835:0000000000000000007003801C00007003801C00007003801C00000000000000
+A836:00000000000001C002200220022001C000000000000000000000000000000000
+A837:0000000000000000004000800100020004000E001100110011000E0000000000
+A838:000000000000001000100010001000100010001000100010002001C000000000
+A839:00000000000000700080008000800040004000400040004001800E0000000000
+A83A:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE63867DB671867DB663B67FFE0000
+A83B:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE638E7DB6718E7DB6638E7FFE0000
+A83C:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE63C67DBE71BE7DBE63C67FFE0000
+A83D:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE638E7DB671B67DB6638E7FFE0000
+A83E:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE63867DBE718E7DBE63867FFE0000
+A83F:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE63867DBE718E7DBE63BE7FFE0000
+A840:0000000000007FFF400040007FFE400040007FFE408040804080000000000000
+A841:0000000000004FF84808480848087808480848084FF840007FFE000000000000
+A842:0000000000007FFF40004FF84808480878084808480848084FF8000000000000
+A843:0000000000007F044104410441044104410441044104410441FC000000000000
+A844:0000000000007FFC4104410441044104410441044104410441FC000000000000
+A845:00000000000041FC41044104410441047F0441044104410441FC000000000000
+A846:0000000000004104410441044104410441044104410441047FFC000000000000
+A847:0000000000007FFC4100408040404020401C4000400040004000000000000000
+A848:000000000000407440884100410040C07FFC4000400040007FFE000000000000
+A849:0000000000007FFF41044104410471C449244514430C430C4104000000000000
+A84A:0000000000004060408041004100710049004500430043004100000000000000
+A84B:0000000000007FF0406040804100428044404440444044404380000000000000
+A84C:0000000000007FFC0004000400047F04410441044104410441FC000000000000
+A84D:0000000000007FFC0004000400047E04010401040104010400F8000000000000
+A84E:0000000000007FFC4004400440047F04410441044104410441FC000000000000
+A84F:0000000000007FF0006000807F00428044404440444044404380000000000000
+A850:0000000000007FFF4080408041E042107E0842484188401047E0000000000000
+A851:0000000000007FFF40404080410043E0401040084008401043E0000000000000
+A852:0000000000007FFF40024002400241FE410241027F0241024102000000000000
+A853:0000000000004000443044D047107C10471044D0443040007FFF000000000000
+A854:0000000000007C1F43604080414042204220422041C040007FFE000000000000
+A855:0000000000007FFC410441044104410441044104410441044104000000000000
+A856:0000000000007F04410441044104410441FC4000400040004000000000000000
+A857:0000000000001FF80010002000401FE000100008000800101FE0000000000000
+A858:0000000000000410041004100410041007F00410041004100410000000000000
+A859:0000000000007FFC000400047F044104410441FC400040007FFC000000000000
+A85A:0000000000007FFC40004000400041FC41044104410441047F04000000000000
+A85B:0000000000007FFF003000C023002C0030002800244022802100000000000000
+A85C:00000000000041E242144408440042004100608051004A004400000000000000
+A85D:0000000000007FF8003000C023002C0030F02B08240800087FF0000000000000
+A85E:0000000000007FF0418042004400484048204820482044404380000000000000
+A85F:000000000000400041E0421044087C08440843884008401040E0000000000000
+A860:0000000000007FFF410041004100410041104120414041804100000000000000
+A861:0000000000004008403043C04C00700070004C0043C040304008000000000000
+A862:0000000000007FF0401040107810471040F04000400040007FFF000000000000
+A863:0000000000007FFF41044104410471C449244514430C40007FFF000000000000
+A864:00000000000043CF44314411440942094105608551034A034401000000000000
+A865:0000000000007FFF40004000400040F047107810401040107FF0000000000000
+A866:0000000000004003400440084008401040104010401040107FF0000000000000
+A867:0000000000001FFC08040404020401040084004400240014000C000000000000
+A868:0000000000000804040404040208020802080410041008203FC0000000000000
+A869:0000000000007FFE4000400040007FFC40C04100410040884074000000000000
+A86A:0000000000004104430C430C4514492471C44104410441047FFF000000000000
+A86B:0000000000004100430043004500490071004100410040804060000000000000
+A86C:0000000000004380444044404440444042804100408040607FF0000000000000
+A86D:0000000000007FFE000600180860068001FC00020002000201FC060008000000
+A86E:0000000000007FFC40004000400041FC41044104460458046004000000000000
+A86F:00000000000041E042104408440442004100608051004A004400000000000000
+A870:000000000000403F43514491440942094105608551034A034401000000000000
+A871:0000000000007FFF000600180060008001000100020002000200000000000000
+A872:000000000000080008000800080008000FE00800080008000800000000000000
+A873:00000000000000000040002006101F183F181F18061000200040000000000000
+A874:0000000000007FFF400140014101410141017F01000100017FFF000000000000
+A875:000000007FFF400141017F0100017FFF400141017F0100017FFF000000000000
+A876:0000000000000080008000800080008000800080008000800080000000000000
+A877:0000000000000220022002200220022002200220022002200220000000000000
+A878:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE61CE7DB67BCE77B677CE7FFE0000
+A879:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE61CE7DB67BC677F677CE7FFE0000
+A87A:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE61867DB67B8677B677B67FFE0000
+A87B:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE618E7DB67B8E77B6778E7FFE0000
+A87C:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE61C67DBE7BBE77BE77C67FFE0000
+A87D:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE618E7DB67BB677B6778E7FFE0000
+A87E:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE61867DBE7B8E77BE77867FFE0000
+A87F:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE61867DBE7B8E77BE77BE7FFE0000
+A880:000000000000000000000004000A000A00040000000000000000000000000000
+A881:00000000000000000004000A000A000400000004000A000A0004000000000000
+A882:000000000000000036004900490002007C008000808081007E00000000000000
+A883:000000000000000036004900490002007C008100808081407E00000000000000
+A884:000000000000000063009480A400820061008100810082007C00000000000000
+A885:000000000000000063009480A700820061008100810082007C00000000000000
+A886:0000000000000000CF00308029004C0092008200820084007800000000000000
+A887:0000000000000000CE00310028804C8092808280828084807880000000000000
+A888:00000000000000004C8092809280628004807880808081007E00000000000000
+A889:00000000000000004C0092009200620004007900808081407E00000000000000
+A88A:000000000000000077008880888080808080BE80848088804700000000000000
+A88B:000000000000000077008880888080808080BE80848088804700060021001E00
+A88C:00000000000000003F00408080009300948094808F0044003800000000000000
+A88D:00000000000000003F0040808080A480AA80AA809C8048803080000000000000
+A88E:00000000000000003F0040808000A900AA80AA80970042003C00000000000000
+A88F:00000000000000003F0040809E00A10091008600990041003E00000000000000
+A890:00000000000000003F0040809C80A280928084809A8042803C80000000000000
+A891:00000000000000003F0040809000A9008A80B2808F8049803180000000000000
+A892:0000000000000000270058805080288008800880088008800880000000000000
+A893:000000000000000084404AA027C02440484049209220922061C0000000000000
+A894:0000000000000000670088808880888088808880888088807300000000000000
+A895:000000000000000062009500A500820065008500888088807300000000000000
+A896:00000000000000007F0080808080B8804480B880808080804300000000000000
+A897:00000000000000006100928050801080F8804100810082007C00000000000000
+A898:000000000000000063009480A280808070808100810082007C00000000000000
+A899:00000000000000007700888088808080A080D080908094806300000000000000
+A89A:0000000000000000770088809480A280A2809480888094804900000000000000
+A89B:00000000000000003C0042008900950095008F80910092004C00000000000000
+A89C:0000000000000000FF8040003800060071008880908081007E00000000000000
+A89D:00000000000000003E0041008080808080808080808041003E00000000000000
+A89E:00000000000000007F8001002200470088808080808041003E00000000000000
+A89F:0000000000000000020085004480258052804080408021001E00000000000000
+A8A0:00000000000000003E0041008C8092809280BA80828044803900000000000000
+A8A1:00000000000000003E0041008080808080808080808040803080000000000000
+A8A2:0000000000000000330048801080210042003400080014000800000000000000
+A8A3:0000000000000000780084008400480010006200810083007C80000000000000
+A8A4:000000000000000063009480A080808060808080808081007E00000000000000
+A8A5:00000000000000003D004280830082008200A200520052002200000000000000
+A8A6:00000000000000004300A0801080110021002200420044003800000000000000
+A8A7:0000000000000000180025804380420084009480888041003E00000000000000
+A8A8:0000000000000000B600B900610002007C008100808080807F00000000000000
+A8A9:00000000000000004D8092409240904090409040904090406180000000000000
+A8AA:00000000000000006C80928092804480188060808080B8804700000000000000
+A8AB:00000000000000004300A0805080110021002200420044003800000000000000
+A8AC:0000000000000000F780140012002200210041004080F880C700000000000000
+A8AD:0000000000000000770088808880808080808080808080806300000000000000
+A8AE:0000000000000000E30080804100220014000800140014000800000000000000
+A8AF:00000000000000003900448084809480A8809480848084806300000000000000
+A8B0:000000000000000061009280D280A10082808280848044803900000000000000
+A8B1:00000000000000004880B5009900910088808880848084808300000000000000
+A8B2:0000000000000000FF00100020007100A8809080808041003E00000000000000
+A8B3:00000000000000006B0094809480808080808080808081006600000000000000
+A8B4:00000000000000000012001200120012000E0002000200020002000000000000
+A8B5:0000000000000000002E0012001400040008000800100010000C000000000000
+A8B6:003C004200240000000000000000000000000000000000000000000000000000
+A8B7:00700088000800080008000800080008000800080008000A0004000000000000
+A8B8:00000000000000000044002A003A003400100028002800280010000000000000
+A8B9:000000000000000800500034003A003400100028002800280010000000000000
+A8BA:0000000000000000001C002A00240020001C000200020022001C000000000000
+A8BB:0000000000000000001C002A00240020001C000200020022001C0040003C0002
+A8BC:000000000000000000DC0122012201220126012A012A012A00A4000000000000
+A8BD:000000000000000000DC0122012201220126012A012A012A00A4020001F00008
+A8BE:0000000000000000000C001200120016000A0002000200040008000000000000
+A8BF:0000000000000000003E0022001400040008000800120012000C000000000000
+A8C0:0000000000000000001800240026001A00020002000A0016000C000000000000
+A8C1:0000000000000000003E002200120004003800080008000A0004000000000000
+A8C2:0000000000000000007E0046002A000A0072000A000A000A0004000000000000
+A8C3:000000000000000000E4009A001A001C001800180038005A0024000000000000
+A8C4:0000000000000000000000000000000000000000000000000000002000100008
+A8C5:00000004000A000A00040011000E000000000000000000000000000000000000
+A8C6:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE71CE6FBE6F8E6FB671CE7FFE0000
+A8C7:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE71866FF66FEE6FDE71DE7FFE0000
+A8C8:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE71CE6FB66FCE6FB671CE7FFE0000
+A8C9:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE71CE6FB66FC66FF671CE7FFE0000
+A8CA:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE71866FB66F866FB671B67FFE0000
+A8CB:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE718E6FB66F8E6FB6718E7FFE0000
+A8CC:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE71C66FBE6FBE6FBE71C67FFE0000
+A8CD:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE718E6FB66FB66FB6718E7FFE0000
+A8CE:0000000000000000008000800080008000800080008000800080000000000000
+A8CF:0000000000000000024002400240024002400240024002400240000000000000
+A8D0:000000000000000003C0042008100810081008100810042003C0000000000000
+A8D1:000000000000000001C00220022001C000400080008000800060000000000000
+A8D2:000000000000000007C008200020022001C00100008000400030000000000000
+A8D3:0000000000000000038004400040018000400040084008400780000000000000
+A8D4:00000000000000000140022002200140008001400220022001C0000000000000
+A8D5:0000000000000000062008200840087007880088010801080110000000000000
+A8D6:000000000000000003C004200400030002000400040002400180000000000000
+A8D7:0000000000000000024004A004A0046004200220024001400080000000000000
+A8D8:0000000000000000010002800240044004200620052005200240000000000000
+A8D9:00000000000000000800040004000440088009400820042003C0000000000000
+A8DA:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE63866DB66D866DB663B67FFE0000
+A8DB:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE638E6DB66D8E6DB6638E7FFE0000
+A8DC:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE63C66DBE6DBE6DBE63C67FFE0000
+A8DD:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE638E6DB66DB66DB6638E7FFE0000
+A8DE:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE63866DBE6D8E6DBE63867FFE0000
+A8DF:00007FFE61CE6DB661CE6DB66DCE7FFE7FFE63866DBE6D8E6DBE63BE7FFE0000
+A8E0:0000018002400240018000000000000000000000000000000000000000000000
+A8E1:0180024001800300008000400000000000000000000000000000000000000000
+A8E2:0180024000800100008000400000000000000000000000000000000000000000
+A8E3:0180004001800040018000400020000000000000000000000000000000000000
+A8E4:0000044002800100028001000000000000000000000000000000000000000000
+A8E5:01000100012000E0002000100010000800080000000000000000000000000000
+A8E6:00C0010000C0010000E000200010000000000000000000000000000000000000
+A8E7:044004A00460022001C000000000000000000000000000000000000000000000
+A8E8:004000800100012000C000000000000000000000000000000000000000000000
+A8E9:00C0012000C00040002000200000000000000000000000000000000000000000
+A8EA:1CE002400C4023C01C4000000000000000000000000000000000000000000000
+A8EB:07E0004004800240018000000000000000000000000000000000000000000000
+A8EC:0FF00080038004E0039000900000000000000000000000000000000000000000
+A8ED:07E0004003C00440004000400040000000000000000000000000000000000000
+A8EE:0FC0048004800380008000800000000000000000000000000000000000000000
+A8EF:07E0008001800100008000400000000000000000000000000000000000000000
+A8F0:030004000FE004C0054004C00440000000000000000000000000000000000000
+A8F1:007000800040012000C000000000000000000000000000000000000000000000
+A8F2:000000000000000008900410031000E000000000000000000000000000000000
+A8F3:000000000000000008900410031000E0000000E0001000080008000800000000
+A8F4:00000000000000000450031000E000000450031000E000000060001000080008
+A8F5:000000000000000008900410031000E0000000E0001000100060001000080000
+A8F6:000000000000000008900410031000E0000000E0001000E0001000E000400020
+A8F7:000000000000000008900410031000E0000000E0010000800240018000000000
+A8F8:00000000000000000718082408240714080C08040808041003E0000000000000
+A8F9:00000000000000000038004400040004070408040808041003E0000000000000
+A8FA:0000000002200140008000000000000000000000000000000000000000000000
+A8FB:000000000000FFFF000000000000000000000000000000000000000000000000
+A8FC:0000000000000000000000000078008C60E618E60C06060C03F801F000000000
+A8FD:0000253811640E6400601FE0006000601FE01860186008600060406030600F80
+A8FE:13E0081007F8FFFF0C300C300C300C300C600400020001800060001000180018
+A8FF:13E0081007F80000000000000000000000000000000000000000000000000000
+A900:00000000000000001FF820042004200420042004200420041FF8000000000000
+A901:00000000000000003FFC000400041FFC20042000203C20441FF8000000000000
+A902:0000000000000000101010100820082004400440028002800100000000000000
+A903:00000000000000000FF8081008200040008001180228044807F0000000000000
+A904:0000000000000000107011901610181010101010001000100060000000000000
+A905:00000000000000001FF810001000100010001000100010001C00000000000000
+A906:0000000000000000101810681188160818081038104810481030000000000000
+A907:0000000000000000003800081008100810081008100810080FF0000000000000
+A908:0000000000000000100010001000100010001000100810081FF8000000000000
+A909:00000000000000001C0010001000100410041004100410040FF8000000000000
+A90A:00000000000000003C780488050806080C081408240824083808000000000000
+A90B:00000000000000001FF82004200420043FFC0004000420041FF8000000000000
+A90C:000000000000000011F01210141018101FF01010101010101010000000000000
+A90D:00000000000000001FF820042004200020002000200420041FF8000000000000
+A90E:00000000000000000FF0100810080B0804880B08100820083E08000000000000
+A90F:00000000000000001FF800080008038802480228022802180C08000000000000
+A910:0000000000000000106011901610182010401020101010701000000000000000
+A911:00000000000000001FF820040004000420043FF8200020041FF8000000000000
+A912:00000000000000000C000B0008C0083009800A400CC009400880000000000000
+A913:0000000000000000000800080008103810081008100810080FF0000000000000
+A914:00000000000000000FF010080F0000F0180810081FF010000F80000000000000
+A915:00000000000000001FF820042018206021802600380420041FF8000000000000
+A916:00000000000000000FC010201020100013E01420182010201010000000000000
+A917:0000000000000000200820082008210822882448282830181FF0000000000000
+A918:00000000000000000FF8001000200040008001180228044807F0000000000000
+A919:000000000000000008F009100A100C1008100870089008900860000000000000
+A91A:000000000000000008F009100A100C1008100810081008100810001000100060
+A91B:000000000000000020F021082108210821082108210821081E08000000000000
+A91C:000000000000000020F021082108210821081E08000820081FF0000000000000
+A91D:00000000000000001000100010001C0810081008100810080FF0000000000000
+A91E:00000000000000001FF820042000200020041FFC000420041FF8000000000000
+A91F:00000000000000000E1012101410183010501F90001000100060000000000000
+A920:0000000000000000600C583446C4410400040004400440043FF8000000000000
+A921:00000000000000000FF010081008000818081608118810681018000000000000
+A922:00000000000000001FF82004200420001E002000200420041FF8000000000000
+A923:000000000000000010081008100810081018102810C813081C08000000000000
+A924:00000000000000001FF8200C20340044018402040C0430041FF8000000000000
+A925:00000000000000001FF82004300C2C3423C42004200420041FF8000000000000
+A926:0000010000000000000000000000000000000000000000000000000000000000
+A927:0C00030000C00000000000000000000000000000000000000000000000000000
+A928:010006C018300000000000000000000000000000000000000000000000000000
+A929:0820082007C00000000000000000000000000000000000000000000000000000
+A92A:0920082007C00000000000000000000000000000000000000000000000000000
+A92B:0000000000000000000000000000000000000000000000000000000001000000
+A92C:0000000000000000000000000000000000000000000000000000080010200FC0
+A92D:0000000000000000000000000000000000000000000000000000090010200FC0
+A92E:000000000000000000000000000003C00C301008000000000000000000000000
+A92F:0000000000000000008000800080008000800080008000800080000000000000
+A930:0000000000000000010002800240052004800800080010001000000000000000
+A931:0000000000000000010002800240042004000800080010001000000000000000
+A932:000000000000000004440A880A881110111022A022A044404440000000000000
+A933:0000000000000000010002800240062005400880080010001000000000000000
+A934:00000000000000000180024002200610054008A0080010001000000000000000
+A935:0000000000000000030C05140514092409241144114421842184000000000000
+A936:0000000000000000001000100020002000400840048002800100000000000000
+A937:0000000000000000001000200040008001000200040008001000000000000000
+A938:000000000000000004400440028002800100210812900AA00440000000000000
+A939:0000000000000000008001400120029002480620051008A00840000000000000
+A93A:000000000000000004200A500948148412802100200040004000000000000000
+A93B:000000000000000004440AA80AA8111010002000200040004000000000000000
+A93C:00000000000000000210052804E4084008401080108021002100000000000000
+A93D:00000000000000000210052804E4084008401080188025002300000000000000
+A93E:0000000000000000018802880290049004A008A008C010C01080000000000000
+A93F:00000000000000004004400420082008101011100AA00AA00440000000000000
+A940:00000000000000000210052004E0084008401080108021002100000000000000
+A941:0000000000000000004000A0009001080100220012000C000400000000000000
+A942:00000000000000000108021002100420042008400C4012801180000000000000
+A943:0000000000000080014002200220041004900948094812241224000000000000
+A944:00000000000000000D4415441484148815481548262826282410000000000000
+A945:000000000000000004440AA80AA811101100220032004C004400000000000000
+A946:0000000000000000011002A002A0044006000A00090011001000000000000000
+A947:0000000000000000000000000000000000008000000000000000000000000000
+A948:0000000000000000000000000000000000000000000000000000800000000000
+A949:0000000000000000000000000000800080008000800000000000000000000000
+A94A:0008001400220000000000000000000000000000000000000000000000000000
+A94B:0000000000000000000000000000800080008000800000000000000080000000
+A94C:0000000000000000000000000000000000000000000000000000800080006000
+A94D:0000000000000000000000000000000000000000000000000000A000A000A000
+A94E:0000000000000000000000000000000000000000000000000000000A000A000A
+A94F:0002000400000000000000000000000000000000000000000000000000000000
+A950:0012002400000000000000000000000000000000000000000000000000000000
+A951:0022001400080000000000000000000000000000000000000000000000000000
+A952:0000000000000000000000000000000000000000000000000000000200000002
+A953:0004000A00040000000000000000000000000000000000000000000000000000
+A954:00007FFE61CE6DB661C66DF66DCE7FFE7FFE61B66FB661867DF661F67FFE0000
+A955:00007FFE61CE6DB661C66DF66DCE7FFE7FFE61866FBE61867DF661867FFE0000
+A956:00007FFE61CE6DB661C66DF66DCE7FFE7FFE61CE6FBE618E7DB661CE7FFE0000
+A957:00007FFE61CE6DB661C66DF66DCE7FFE7FFE61866FF661EE7DDE61DE7FFE0000
+A958:00007FFE61CE6DB661C66DF66DCE7FFE7FFE61CE6FB661CE7DB661CE7FFE0000
+A959:00007FFE61CE6DB661C66DF66DCE7FFE7FFE61CE6FB661C67DF661CE7FFE0000
+A95A:00007FFE61CE6DB661C66DF66DCE7FFE7FFE61866FB661867DB661B67FFE0000
+A95B:00007FFE61CE6DB661C66DF66DCE7FFE7FFE618E6FB6618E7DB6618E7FFE0000
+A95C:00007FFE61CE6DB661C66DF66DCE7FFE7FFE61C66FBE61BE7DBE61C67FFE0000
+A95D:00007FFE61CE6DB661C66DF66DCE7FFE7FFE618E6FB661B67DB6618E7FFE0000
+A95E:00007FFE61CE6DB661C66DF66DCE7FFE7FFE61866FBE618E7DBE61867FFE0000
+A95F:0000000000000000008009300940058012700E4801A002900C90010000000000
+A960:00003E7C2044204420443E7C0000000000000000000000000000000000000000
+A961:00003E442044207C20443E7C0000000000000000000000000000000000000000
+A962:00003E102010201020283E440000000000000000000000000000000000000000
+A963:00003E7C2008201020283E440000000000000000000000000000000000000000
+A964:00007CF804087C0840087C080000000000000000000000000000000000000000
+A965:00003DDC04443C4420443C440000000000000000000000000000000000000000
+A966:00003E7C02403E4020403E7C0000000000000000000000000000000000000000
+A967:00003DDC05103D1021103DDC0000000000000000000000000000000000000000
+A968:00003E7C02443E4420443E7C0000000000000000000000000000000000000000
+A969:00003E4402443E7C20443E7C0000000000000000000000000000000000000000
+A96A:00003D5405543DDC21543DDC0000000000000000000000000000000000000000
+A96B:00443E7C02443E7C20383E440038000000000000000000000000000000000000
+A96C:00003E1002103E1020283E440000000000000000000000000000000000000000
+A96D:00003E7C02083E1020283E440000000000000000000000000000000000000000
+A96E:00003E7C02043E7C20043E040000000000000000000000000000000000000000
+A96F:00003E7C2204220422043E040000000000000000000000000000000000000000
+A970:00003E7C2240224022403E7C0000000000000000000000000000000000000000
+A971:00003E102210221022283E440000000000000000000000000000000000000000
+A972:0000293C2920393C2AA03C7C0000000000000000000000000000000000000000
+A973:0000227C22043E7C22043E040000000000000000000000000000000000000000
+A974:0000223022FC3E3022483E300000000000000000000000000000000000000000
+A975:000008920892089E1552223E0000000000000000000000000000000000000000
+A976:00000E3E1102113E11200E3E0000000000000000000000000000000000000000
+A977:00001C3022FC223022481C300000000000000000000000000000000000000000
+A978:00003FEC047F088C1552222C0000000000000000000000000000000000000000
+A979:00003E7C20403E7C20403E7C0000000000000000000000000000000000000000
+A97A:00003E3014FC143014483E300000000000000000000000000000000000000000
+A97B:00000C103F100C1012280C440000000000000000000000000000000000000000
+A97C:00003EFC00000C3012480C300000000000000000000000000000000000000000
+A97D:00007FFE61CE6DB661C66DF66DCE7FFE7FFE618E7DB67BB677B6778E7FFE0000
+A97E:00007FFE61CE6DB661C66DF66DCE7FFE7FFE61867DBE7B8E77BE77867FFE0000
+A97F:00007FFE61CE6DB661C66DF66DCE7FFE7FFE61867DBE7B8E77BE77BE7FFE0000
+A980:11880A5007E00000000000000000000000000000000000000000000000000000
+A981:0240038000000000000000000000000000000000000000000000000000000000
+A982:0040008001000200000000000000000000000000000000000000000000000000
+A983:0000000000000000000600090009000500020006000100010001000100010002
+A984:0000000000000000300040008000B03C88A4B0FE882489A47264000000000000
+A985:000000000000000038D845244524440444044404450424842784018002600010
+A986:0000000000000000228855545554505450545054545452545E74060009800040
+A987:0000000000000000228855545554505450545054545458545B74040002000C00
+A988:000000000000000038D845244524440444044404450424842788003000460078
+A989:000000000000000030C049204920492049204920492049204E2004000F000080
+A98A:000000000000000031B04A484A4848084A08491C4F2800480788080809880670
+A98B:000000000000000031B04A484A4848084A0C491A4F2A004C078A080A098C0670
+A98C:000000000000000000000000000007800A401180100010700F88000000000000
+A98D:000003000400038000400180000007800A401180100010700F88000000000000
+A98E:000000000000000039C0492090909090909090904F2000400380043809C00E00
+A98F:00000000000000002388545454545454545454545E5455545574020000000000
+A990:00000000000000002388545454545454545454545E5455545574060009800040
+A991:00000000000000002384544854505450545054505E5055505560020000000000
+A992:000000000000000031104AA84AA84AA84AA82AA80AA80AA80EE8000000000000
+A993:0000000000000000231855145514551455145514555455545CA0000000000000
+A994:000000000000000038D8452445244404440444044484244427C4000000000000
+A995:0000000000000000387044484448444844484E485548554848C8000000000000
+A996:000000000000000010002200452049524A55529654A5552A2210000000000000
+A997:000000000000000038784484451C45E045C04530450824882780000000000000
+A998:000000000000000038784484451C45E045C04530450824882780018002600010
+A999:000800140014000E31454AA54AA648244A2449244F2400440784080808C80730
+A99A:0000000000008000457EAADAAADAA0DAA8DAA4DABCDA00000000000000000000
+A99B:000000000000000031B04A484A484808480848084B084C884708084008400780
+A99C:000000000000000031B04A484A4848084808480849884A484F88000000000000
+A99D:000000000000000038F048909050905090509050925092504D90000000000000
+A99E:0000000000000000398048409040904090409040924092404D80000000000000
+A99F:0000000000000000224855B455B455B455B435B415B415B41DB4000000000000
+A9A0:000000000000000027CC543454345434533450B450B450B45F34000000000000
+A9A1:000000000000000038F048909050905090509250955091504F90010001400080
+A9A2:000000000000000039E04A109210921092109210939096504990000000000000
+A9A3:000000000000000038F048909050905090509050925092504D90000000000000
+A9A4:000000000000000039E04A109210921092109F10929092905110000000000000
+A9A5:0000000000000000387044484448444844484448444844482388000000000000
+A9A6:0000000000000000386048909090905090209030924892484D90000000000000
+A9A7:0000000000000000629C95549554905490549054945492545F64000000000000
+A9A8:00000000000000003C782448244804404F4074E00258014400C0000000000000
+A9A9:00000000000000003F18482448244824472448244824482427C4000000000000
+A9AA:000000000000000039CE494A494A494A494A494A494A494A2E32000000000000
+A9AB:00000000000000003C78228412840284048408841C8402840184000000000000
+A9AC:000C0012000E000264929B6A9B6A9B6A5B6A1B6A1B6A1B6A1B6E000000000000
+A9AD:000000000000000039DC4A549254925492549254925492544E64000000000000
+A9AE:00000000000000001CF024884848484848484848484848482788000000000000
+A9AF:0000000000000000233054C854C854C855C836C817FC14CA1CC8000000000000
+A9B0:00000000000000003878484890489148924893FC904A90484F88000000000000
+A9B1:00000000000000003C3C44248424842484248E249524952448C4000000000000
+A9B2:000000000000000039FC49649164916491649164916491644E64000000000000
+A9B3:0000024001802424181800000000000000000000000000000000000000000000
+A9B4:0000000000000000000600090009000100020002000400050007000000000000
+A9B5:0000000000000000000000040004000200020001000900060000000000000000
+A9B6:01E0021004100410047003900000000000000000000000000000000000000000
+A9B7:01E00210053004D0047003900000000000000000000000000000000000000000
+A9B8:000000000000000000000000000000050005000500050005000500050019003E
+A9B9:000000000000000000000004000F00140014000E00050005000500050019003E
+A9BA:00000000000000004800B400B400B400B400B400B400B4003400040004000300
+A9BB:1800200010000800300000004800B400B400B400B400B4003400040004000300
+A9BC:0780084008200610000000000000000000000000000000000000000000000000
+A9BD:0000000000000000000000000000000100060002000100010001003200340058
+A9BE:000E000A000A000A000A000A000A000A000A002A002A00CA030A040A04CA0331
+A9BF:180020004000800080008000800080008000800080048008401C2002180207FC
+A9C0:000E000A000A000A000A000A000A000A000A000A000A030A048A040A04CA0331
+A9C1:00000006060A04080408020861E04004206A1F8400100612042203C2000A000C
+A9C2:00003000500043C044204860080021F856042002078610401020102050606000
+A9C3:2800D586C586C586D586F58601861D8621862F86A5E6999F818781C741D73EA9
+A9C4:6800D586C586C586D586F58681869D86A186AF86A5E6999F818781C741D73EA9
+A9C5:30004006E806D586C586F58681869D86A186AF86A5E6999F818781C741D73EA9
+A9C6:0000000000000000000001C0022002200220022001C000000000000000000000
+A9C7:0000000000000000000000000240038000000000024003800000000000000000
+A9C8:00000000000000001800040002000100008000800040034000C0000000000000
+A9C9:0000000000000000330008800440022001100110008806E80198000000000000
+A9CA:00000000000000000600010001000100010001000100010001000100010000C0
+A9CB:0000000000000000198004400440044004400440044004400440044004400330
+A9CC:0000001000200140010000C006000100010001000100010001000100010000C0
+A9CD:0000018000400040004000400040004000400040003001800040014002000400
+A9CE:00007FFE61CE6DB661C66DF66DCE7FFE7FFE71866FBE6F8E6FBE71867FFE0000
+A9CF:0000000000000000000000000820072002C00200010001000100000000000000
+A9D0:0000000000000000000001C0022002200220022001C000000000000000000000
+A9D1:000000000000000031104AA84AA84AA84AA82AA80AA80AA80EE8000000000000
+A9D2:000000000000000031B04A484A4848084A08491C4F2800480788080809880670
+A9D3:00000000000000002367549554955015541552255E4500850F05100511850E79
+A9D4:000000000000000000C00100020002C0022002C00220022001C0000000000000
+A9D5:00000000000000000380044008200B2008A00B2008A008A00720002000200018
+A9D6:000000000000000000000000000007800A401180100010700F88000000000000
+A9D7:000000000000000039DC4A549254925492549254925492544E64000000000000
+A9D8:0000000000000000386048909090905090209030924892484D90000000000000
+A9D9:000000000000000039CE494A494A494A494A494A494A494A2E32000000000000
+A9DA:00007FFE61CE6DB661C66DF66DCE7FFE7FFE63866DB66D866DB663B67FFE0000
+A9DB:00007FFE61CE6DB661C66DF66DCE7FFE7FFE638E6DB66D8E6DB6638E7FFE0000
+A9DC:00007FFE61CE6DB661C66DF66DCE7FFE7FFE63C66DBE6DBE6DBE63C67FFE0000
+A9DD:00007FFE61CE6DB661C66DF66DCE7FFE7FFE638E6DB66DB66DB6638E7FFE0000
+A9DE:000000000000000000800140022002200220022001C000000000000000000000
+A9DF:00000000000000001C7022882288228822882288228822882388000000000000
+A9E0:0000000000000000000000F801440082000200F2008C00780000000000000000
+A9E1:00000000000000000000018C024203A1002100210252018C0000000000000000
+A9E2:00000000000000000000018C024A0029002500230252018C0000000000000000
+A9E3:00000000000000000000018C02D20120002001FC0252018C0000000000000000
+A9E4:0000000000000000000000C60108021002100216012900C60000000000000000
+A9E5:0070008800800070008800000000000000000000000000000000000000000000
+A9E6:0000000000900120024004800000000000000000000000000000000000000000
+A9E7:00000000000000000000018C02520421042102210122062C0020002000200038
+A9E8:0000000000180020002001AC0232042104210421027201AC00200020002000E0
+A9E9:00000000000000000000018C02520421042D04210242000C0000000000000000
+A9EA:00000000000000000000018C02120421042D04210242018C0000000000000000
+A9EB:00000000000000000000018C02520421042D04210212018C0000000000000000
+A9EC:00000000000000000000000001020201022502510251018E0000000000000000
+A9ED:00000000000000000000018C0252042105AD04210242018C0000000000000000
+A9EE:00000000000000000000018C0252042105AD04210252018C0000000000000000
+A9EF:0000000000000000000000380244028201CA00A2004400000000000000000000
+A9F0:000003C00420081008100810081008100810081008100810042003C000000000
+A9F1:000003C004200E1009100620000003C004200E10091006200040007000000000
+A9F2:0000081008100810042003D0001003D00420080008000800042003C000000000
+A9F3:000003E0041000100010061005E0040005E0061000100010041003E000000000
+A9F4:000007C0082008000800086007A0002007A0086008000800082007C000000000
+A9F5:000003C0042008100800080008000BC00C200810081008100420024000000000
+A9F6:0000000002400420081008100810043003D00010001000100810042003C00000
+A9F7:000000000780084010201C2012200C2000200020002000200020003800000000
+A9F8:000003C00420080008000800040003C00420081008100810042003C000000000
+A9F9:000000000000000000000070008841044104410422881C700000000000000000
+A9FA:00000000000000000000018C0242042105A104210212018C0000000000000000
+A9FB:00000000000000000000018C02520421042D04210242018C0000000000000000
+A9FC:00000000000000000000018C02520421042D04210252018C0000000000000000
+A9FD:0000000000000000000000480084010201320102008400780000000000000000
+A9FE:0000000000180020002001AC02320421042D04210252018C0000000000000000
+A9FF:00007FFE61CE6DB661C66DF66DCE7FFE7FFE61866FBE638E6FBE6FBE7FFE0000
+AA00:00000000000000000E0611C9222929323480188013C004A00300000000000000
+AA01:00000000000000000CC013201020282050400780082008500790000000000000
+AA02:0000000000000000038004400820082004400180020002400180000000000000
+AA03:00380044004400480E20111011080928025804300420024001E0000000000000
+AA04:00000000000000000E70118818081408083000C00110011000E0000000000000
+AA05:00000000000000000380044008201C200AC0042000F0012800C0000000000000
+AA06:00000000000000000EE011101110102008000800080008001000000000000000
+AA07:00000000000000001B0C24922452206411C01280148015002200000000000000
+AA08:000000000000000007700888108810101000100011000A800700000000000000
+AA09:0000000000000000186C24922492148404800880090006000200000000000000
+AA0A:00000000000000001C2822502230161001100120014003800400000000000000
+AA0B:00000000000000001C2822502230161001100120014003800430044804900300
+AA0C:00000000000000001C3022482248114001800F00120012000C00000000000000
+AA0D:00000000000000001886254925491544064C1C94248828901060000000000000
+AA0E:000000000000000038D8452445242C8802800280028007000800000000000000
+AA0F:0000000000000000031804A404A404A8052013902B5027301CE0000000000000
+AA10:00000000000000001986264940314022406040A02920152028C0000000000000
+AA11:00000000000000001986264940314022406040A02920152028C4004A00480030
+AA12:00000000000000001986264940314022406040A02920152029C4024A01480230
+AA13:0000000000000000077008880888101010001600190009000600000000000000
+AA14:00000000000000000E0C111211120928025804300420024001C0000000000000
+AA15:00000000000000001C7022882288165001400140014003800400000000000000
+AA16:00000000000000000C70128812880A5002400440048003000100000000000000
+AA17:00000000000000001C0C22122212110801080F08129012600C40000000000000
+AA18:00000000000000001C0C22122212110801080F08129012600C48009400900060
+AA19:00000000000000001C0C22122212110801080F08129012600C0008C009200600
+AA1A:0000000000000000077008880888040004002400540048003000000000000000
+AA1B:00000000000000001C1822242224162801200120014003800400000000000000
+AA1C:00000000000000000E0C1112111209080A284A58AA30911060E0000000000000
+AA1D:0000000000000000183024482448085010401040104008400780000000000000
+AA1E:0000000000000000306C48924892108020802080208010800F00000000000000
+AA1F:0000000000000000306C4892489228840A80110012800C800400000000000000
+AA20:0000000000000000183824442444144805400880094006400248009400900060
+AA21:0000000000000000183824442444144805400880095006200250005000200000
+AA22:0000000000000000306C48924892248404400240024002800700000000000000
+AA23:000000000000000000F001080108009000800680098009000600000000000000
+AA24:0000000000000000073808C4080410041008101012000D000600000000000000
+AA25:00000000000000001838244424441448044008D0092006500250002000000000
+AA26:00000000000000000C1C12222A22522402200440048003000100000000000000
+AA27:0000000000000000073808C408040408020012002A0024001800000000000000
+AA28:00000000000000000770088808980428021412002A0024001800000000000000
+AA29:0038004400480020001800040004000000000000000000000000000000000000
+AA2A:001C00220041004D003200040000000000000000000000000000000000000000
+AA2B:001C002200490041004D00320004000000000000000000000000000000000000
+AA2C:00380045008E009A006400080000000000000000000000000000000000000000
+AA2D:00000000000000000000000000000000000000000000000000000002001C0020
+AA2E:00000011000E0000000000000000000000000000000000000000000000000000
+AA2F:0000000000000000000000006000900090008000A0005000A000000000000000
+AA30:0000000000000000000000006000900090008000A00050002000080070008000
+AA31:0002001C00200024001800100020000000000000000000000000000000000000
+AA32:0000000000000000000000000000000000000000000000000000000C00040008
+AA33:0000000000000000000000000000000600090009000800040032000A0012003C
+AA34:5800A8008800100020004000800080008000800080008000800082004A003400
+AA35:000000000000000000000000000000000000000000000000000000040008000C
+AA36:0000000000000000000000000000000000000008000500020005000500050002
+AA37:00007FFE61866DB661866DB66DB67FFE7FFE63867DF671EE7DDE63DE7FFE0000
+AA38:00007FFE61866DB661866DB66DB67FFE7FFE63CE7DB671CE7DB663CE7FFE0000
+AA39:00007FFE61866DB661866DB66DB67FFE7FFE63CE7DB671C67DF663CE7FFE0000
+AA3A:00007FFE61866DB661866DB66DB67FFE7FFE63867DB671867DB663B67FFE0000
+AA3B:00007FFE61866DB661866DB66DB67FFE7FFE638E7DB6718E7DB6638E7FFE0000
+AA3C:00007FFE61866DB661866DB66DB67FFE7FFE63C67DBE71BE7DBE63C67FFE0000
+AA3D:00007FFE61866DB661866DB66DB67FFE7FFE638E7DB671B67DB6638E7FFE0000
+AA3E:00007FFE61866DB661866DB66DB67FFE7FFE63867DBE718E7DBE63867FFE0000
+AA3F:00007FFE61866DB661866DB66DB67FFE7FFE63867DBE718E7DBE63BE7FFE0000
+AA40:00000000000000000EE011101110101008100820082008401080000000000000
+AA41:00000000000000000EE01110111020102010202020202C401C80000000000000
+AA42:00000000000000001C2022502250163001180124014403880410000000000000
+AA43:0004000800300000000000000000000000000000000000000000000000000000
+AA44:00000000000000001C3822442244114401840F08120812100C20000000000000
+AA45:0000000000000000077008880888100810081610191009200640000000000000
+AA46:0000000000000000381C44224422221202121E14252424C81890000000000000
+AA47:00000000000000000770088808880408020812102A1024201840000000000000
+AA48:0000000000000000306C48924892248204420244024402880710000000000000
+AA49:000000000000000000F801040104008400840688098809100620000000000000
+AA4A:00000000000000000E701188100820082008201024102A201C40000000000000
+AA4B:00000000000000001C7812842A84524402440448048803100120000000000000
+AA4C:0000002000000000000000000000000000000000000000000000000000000000
+AA4D:0000000000000000000000000006000900050001000200040004000000000000
+AA4E:00007FFE61866DB661866DB66DB67FFE7FFE6D866DBE618E7DBE7D867FFE0000
+AA4F:00007FFE61866DB661866DB66DB67FFE7FFE6D866DBE618E7DBE7DBE7FFE0000
+AA50:000000000000000003C0042008100810081008100810042003C0000000000000
+AA51:00000000000000000FE0101010103C200CC00100010001000100000000000000
+AA52:000203840478080013B824442444280429042A88270810100FE0000000000000
+AA53:00000000000000000E7011881008200820102024244A2A4A1C30000000000000
+AA54:0000000000000000000406080908109020507C20220022001C00000000000000
+AA55:00000000000000000F0010801080090002800040034004800340000000000000
+AA56:000000000000000000F001080108009000800680098009000600000000000000
+AA57:000000000000000000F801040104008400840688098809100660008800940060
+AA58:00000000000000001C3822442244114401840F08120812100C60008800940060
+AA59:0000000000000000183824442444084410841088108809100660008800940060
+AA5A:00007FFE61866DB661866DB66DB67FFE7FFE61866FB661867DB661B67FFE0000
+AA5B:00007FFE61866DB661866DB66DB67FFE7FFE618E6FB6618E7DB6618E7FFE0000
+AA5C:0000000000000000000001C00220041024101310082007C00000000000000000
+AA5D:0000000000000000008000800080008000800080008000800080000000000000
+AA5E:0000000000000000024002400240024002400240024000400040000000000000
+AA5F:0000000000000000049004900490049004900090009000100010000000000000
+AA60:00000000000000000000018C0252042304250429024A000C0000000000000000
+AA61:00000000000000000000018C02520421042102210152060C0000000000000000
+AA62:000000000000000000000118010401020102014201A401180000000000000000
+AA63:00000000000000000000018C025204A104A104A10252060C0000000000000000
+AA64:00000000000000000000000C02520421042104210252018C0000000000000000
+AA65:00000000000000000000010C0212042104210421026201AC00200020002000E0
+AA66:00000000000000000000018C0252042105A104210242018C0000000000000000
+AA67:00000000000000000000018C0252042105A104210252018C0000000000000000
+AA68:00000000000000000000018C0252042305A50429024A018C0000000000000000
+AA69:00000000000000000000018C0252042105B904250252018C0000000000000000
+AA6A:00000000000000000000018C02520421043904250252018C0000000000000000
+AA6B:0000000000000000000000380244028201C200A2004400000000000000000000
+AA6C:0000000000000000000000000102020102310249024901860000000000000000
+AA6D:00000000000000000000000C005200A1006100210022002C00200020012000C0
+AA6E:00000000000000000000018C02420621052104A10292018C0000000000000000
+AA6F:00000000000000000000011801A4014201420142012401180000000000000000
+AA70:000003E00410000003E004100000000000000000000000000000000000000000
+AA71:00000000000000000000018C02520521052105210242000C0000000000000000
+AA72:00000000000000000000004C00B2011101110711052A030C0000000000000000
+AA73:00000000000000000000010C01820181014101210112010C0000000000000000
+AA74:00300048004000200010040808C810A810A810A808C807880088038804C80330
+AA75:0018002400200010000818C42524421442142214142460C40084038404E40318
+AA76:000C001200100008000438E24512020A020A020A020A02320222326242B23C4C
+AA77:000006000900080004000FF0109020502050205010500F5C0040004000400070
+AA78:000000000000000C001208A02720102010401040274008C00000000000000000
+AA79:0000000000000000000007800840102010201020082007A00020002000200038
+AA7A:00000000002007C00800098C0A420C210C210C210A12099C08100810081007E0
+AA7B:0000000000000000000000000000000000000100028003000200010000000000
+AA7C:00000000000001FE000000000000000000000000000000000000000000000000
+AA7D:0000000000000000000000000000000007E00000000000000000000000000000
+AA7E:0000000000000000000000710089000501E501150089007900090009000D001A
+AA7F:00000000000000000000011102A90045074504C502AD011500050005000D001A
+AA80:00000000000000001830085008900890091009100A100C100000000000000000
+AA81:000000000000000003E00410082808480888090806101E200000000000000000
+AA82:0000000000000E04110820882088208820882088110809F00008000800880070
+AA83:000000000000661C222222422242224222422242224C1D82000200020022001C
+AA84:0000000000000E0811102090209020907110291C293210CC0000000000000000
+AA85:00000000000008F00508020802080208000800080030000800080208010800F0
+AA86:000000000000038004400820082008201C200A200A2004200020002004400380
+AA87:000000000000038004400820082008200820046003A000200020002004400380
+AA88:00060008000EDB094C86488848884888488849EA4A95310A0000000000000000
+AA89:02000400080013C0142014101010101010100810042003C00000000000000000
+AA8A:000000300048008000801880248004800480048004E003D00060000000000000
+AA8B:0000000000000210052804F0042004200420042004200820002000200012000C
+AA8C:0000003C0042008000803060488008800880088008C0092006C0000000000000
+AA8D:0000003C00420080008030604880088008800880088008800700008000800300
+AA8E:0000000000003008081004200240018001802240142008180000000000000000
+AA8F:0007000800100E1011102090209020907110291C293210CC0000000000000000
+AA90:00000000000066D823242224222422242224222422241C240004000400840078
+AA91:0000000000000770088810881008780814080C080008000800080008010800F0
+AA92:000000000000000003E00410080808080808080804101E200000000000000000
+AA93:00000000000060E021102210221022102210239026501990001000100012000C
+AA94:0000000000000770088810881008780814080C10000000000000000000000000
+AA95:0000000000003040484008400840084008400840084807B00000000000000000
+AA96:0000000000000E00110020802080208070802880288010800080008800880070
+AA97:0000000000000C1004100410041004100410043004500390001000100012000C
+AA98:000200040008DB084C88488848884888488849EA4A95310A0000000000000000
+AA99:000000000000000018202440048004800480048004E003D00060000000000000
+AA9A:0000002000400080008018802480048004800480048003000000000000000000
+AA9B:000400080008000832481248124812481248124812480DB00000000000000000
+AA9C:0018002400403040084008400840084008400840048003000000000000000000
+AA9D:000800100010001031101110111011101110111011100EE00000000000000000
+AA9E:0000003C004200800080606014801A801080108010C011200EC0000000000000
+AA9F:000400080008010862882288228822882288228822881C700008000800300000
+AAA0:0000042004401B80308008800900090009000960089007600000000000000000
+AAA1:0000001C00220020632025202520292029203138316420980000000000000000
+AAA2:0000000000016D822644244424442444244224E22552188C0000000000000000
+AAA3:0000000000043808441004100410041004080E08150808F00000000000000000
+AAA4:020C02120DA03820442004200420042004200420024001800000000000000000
+AAA5:020802100DA03820442004200420042004200420024001800000000000000000
+AAA6:0000000000002300148008400840084008400840102420180000000000000000
+AAA7:0000000000002300148008400840084008400858103420380010000800000000
+AAA8:000000000000CDC046204420442044204420442044203820002000200012000C
+AAA9:0000000000000780084008400090012000C000800D0002000000000000000000
+AAAA:000000000000DB704C884884488448844884488448A430980000000000000000
+AAAB:00000000000003C0042004100010001000100810042003C00000000000000000
+AAAC:000000000000CCC055204E104410441044104422442438180000000000000000
+AAAD:00000000000030E0111012081208120814081408144808300000000000000000
+AAAE:00000000000003C0042004100250019000100410042003C00000000000000000
+AAAF:000003C004200410021001F800140414042403C4000400040004000400880070
+AAB0:0000042008400880070000000000000000000000000000000000000000000000
+AAB1:0000000000000780044000400040004000400040004000400000000000000000
+AAB2:00000100010006C0000000000000000000000000000000000000000000000000
+AAB3:080014E017100800100008000000000000000000000000000000000000000000
+AAB4:0000000000000000000000000000000000000000000C0012000E0022001C0000
+AAB5:000000000000042008401080108010801080108010800C600000000000000000
+AAB6:000001E002100400040004000400040004000400040003000000000000000000
+AAB7:0010002000400280010000000000000000000000000000000000000000000000
+AAB8:001000A0004002A0010000000000000000000000000000000000000000000000
+AAB9:0000000000000080010002000200020002000200020001800000000000000000
+AABA:0000000000E0010002000200010000C0010001C002A004400000000000000000
+AABB:00000600090008800880049003E0008000800080008003000000000000000000
+AABC:00000000000001C00220040004000400020001C0008001000200020004000600
+AABD:0000002000400080009031E04A8008800880088008C0092006C0000000000000
+AABE:038802700E2009C0388027000000000000000000000000000000000000000000
+AABF:0040004000400080008000800000000000000000000000000000000000000000
+AAC0:0000000000000180024004400440048007000420044003800000000000000000
+AAC1:0000003006400980030004000000000000000000000000000000000000000000
+AAC2:0000000000000780044000400040004000400040004000400040008001000200
+AAC3:00007FFE61866DB661866DB66DB67FFE7FFE718E6FF66FC66FF6718E7FFE0000
+AAC4:00007FFE61866DB661866DB66DB67FFE7FFE71B66FB66F866FF671F67FFE0000
+AAC5:00007FFE61866DB661866DB66DB67FFE7FFE71866FBE6F866FF671867FFE0000
+AAC6:00007FFE61866DB661866DB66DB67FFE7FFE71CE6FBE6F8E6FB671CE7FFE0000
+AAC7:00007FFE61866DB661866DB66DB67FFE7FFE71866FF66FEE6FDE71DE7FFE0000
+AAC8:00007FFE61866DB661866DB66DB67FFE7FFE71CE6FB66FCE6FB671CE7FFE0000
+AAC9:00007FFE61866DB661866DB66DB67FFE7FFE71CE6FB66FC66FF671CE7FFE0000
+AACA:00007FFE61866DB661866DB66DB67FFE7FFE71866FB66F866FB671B67FFE0000
+AACB:00007FFE61866DB661866DB66DB67FFE7FFE718E6FB66F8E6FB6718E7FFE0000
+AACC:00007FFE61866DB661866DB66DB67FFE7FFE71C66FBE6FBE6FBE71C67FFE0000
+AACD:00007FFE61866DB661866DB66DB67FFE7FFE718E6FB66FB66FB6718E7FFE0000
+AACE:00007FFE61866DB661866DB66DB67FFE7FFE71866FBE6F8E6FBE71867FFE0000
+AACF:00007FFE61866DB661866DB66DB67FFE7FFE71866FBE6F8E6FBE71BE7FFE0000
+AAD0:00007FFE61866DB661866DB66DB67FFE7FFE63CE6DB66DB66DB663CE7FFE0000
+AAD1:00007FFE61866DB661866DB66DB67FFE7FFE63EE6DCE6DEE6DEE63C67FFE0000
+AAD2:00007FFE61866DB661866DB66DB67FFE7FFE63866DF66D866DBE63867FFE0000
+AAD3:00007FFE61866DB661866DB66DB67FFE7FFE638E6DF66DC66DF6638E7FFE0000
+AAD4:00007FFE61866DB661866DB66DB67FFE7FFE63B66DB66D866DF663F67FFE0000
+AAD5:00007FFE61866DB661866DB66DB67FFE7FFE63866DBE6D866DF663867FFE0000
+AAD6:00007FFE61866DB661866DB66DB67FFE7FFE63CE6DBE6D8E6DB663CE7FFE0000
+AAD7:00007FFE61866DB661866DB66DB67FFE7FFE63866DF66DEE6DDE63DE7FFE0000
+AAD8:00007FFE61866DB661866DB66DB67FFE7FFE63CE6DB66DCE6DB663CE7FFE0000
+AAD9:00007FFE61866DB661866DB66DB67FFE7FFE63CE6DB66DC66DF663CE7FFE0000
+AADA:00007FFE61866DB661866DB66DB67FFE7FFE63866DB66D866DB663B67FFE0000
+AADB:0007000800100E12110C208420B823C87D08291C292A10CC0000000000000000
+AADC:0007000800100E12110C2084208820887108291C292A10CC0000000000000000
+AADD:02000400080008000B8004400A20092008E01C500A480A480430000000000000
+AADE:1F7C21844508105001020A0405545AAC4AA44AA464980000145041043EF80000
+AADF:0000007000800100012000C00040008000801FE0209007E0088011C00EA000C0
+AAE0:000000000000000001C002200410081008100010001013900C70000000000000
+AAE1:00000000000000001FF008000800080008100810082004400380000000000000
+AAE2:00000000000000001CE0249017A0102010200840084008403030000000000000
+AAE3:000000000000000001900190016002000200020034004C004C00000000000000
+AAE4:0000000000000000070C089210A2204250A28912850A48923062000000000000
+AAE5:00000000000000001FF00100010001000FE009200FE009200FE0000000000000
+AAE6:00000000000000000700088018C0252042104010202020201040000000000000
+AAE7:0000000000000000183024482288210822882448282824482388000000000000
+AAE8:00000000000000003FF0100013F0101010201040104010801080000000000000
+AAE9:00000000000000007FFC22881450082014502288228814500820000000000000
+AAEA:000000000000000007C00820082008200FE00820082008200FE0000000000000
+AAEB:00006000900090007C0020002000200020002000200020002000000000000000
+AAEC:0000000000000000000000000000000000000000000000000490049003600000
+AAED:008000400020006000A000400000000000000000000000000000000000000000
+AAEE:0000600090007000200020003800200020002000200020002000000000000000
+AAEF:0000000C0012001C000800080038000800080008000800080008000000000000
+AAF0:0000000000000000008000800080008000800080008000800080000000000000
+AAF1:000000000000000010100C600380000003800C60101000000000000000000000
+AAF2:00000080022001C0000001C002200020004001800200022001C0000000000000
+AAF3:000000000000000007C008200820044002800100028004400820000000000000
+AAF4:0000000000000000038000400020002000400080010000800060000000000000
+AAF5:000000000000000000000004000A000A00040004000400000000000000000000
+AAF6:0000000000000000000000000000000000000000000000000000008001C00080
+AAF7:00007FFE61866DB661866DB66DB67FFE7FFE61866FF663EE6FDE6FDE7FFE0000
+AAF8:00007FFE61866DB661866DB66DB67FFE7FFE61CE6FB663CE6FB66FCE7FFE0000
+AAF9:00007FFE61866DB661866DB66DB67FFE7FFE61CE6FB663C66FF66FCE7FFE0000
+AAFA:00007FFE61866DB661866DB66DB67FFE7FFE61866FB663866FB66FB67FFE0000
+AAFB:00007FFE61866DB661866DB66DB67FFE7FFE618E6FB6638E6FB66F8E7FFE0000
+AAFC:00007FFE61866DB661866DB66DB67FFE7FFE61C66FBE63BE6FBE6FC67FFE0000
+AAFD:00007FFE61866DB661866DB66DB67FFE7FFE618E6FB663B66FB66F8E7FFE0000
+AAFE:00007FFE61866DB661866DB66DB67FFE7FFE61866FBE638E6FBE6F867FFE0000
+AAFF:00007FFE61866DB661866DB66DB67FFE7FFE61866FBE638E6FBE6FBE7FFE0000
+AB00:00007FFE618E6DB6618E6DB66D8E7FFE7FFE73CE6DB66DB66DB673CE7FFE0000
+AB01:000000000600060007000F8018C018C01FC01FFC18CC18C018C018C000000000
+AB02:000000000600060007000F8018C018C01FC01FC018C018C018CC18FC00000000
+AB03:000000000180018001C003E00630063007F007F0063000300030003000000000
+AB04:000000000600060007000F8018C018C01FC01FC018C018F818CC18F800000000
+AB05:000000000300038001C003E00630063007F007F0063006300630063000000000
+AB06:000000000180018001C003E00630063007F007F0063006000600060000000000
+AB07:00007FFE618E6DB6618E6DB66D8E7FFE7FFE73866DF66DEE6DDE73DE7FFE0000
+AB08:00007FFE618E6DB6618E6DB66D8E7FFE7FFE73CE6DB66DCE6DB673CE7FFE0000
+AB09:0600060007000F8018801F8018800D0006001FC030C030FC018C018000000000
+AB0A:0600060007000F8018801F8018800D0006001FC030C030C0019801F800000000
+AB0B:03000300038007C00C400FC00C40068003000FF00C300C300030003000000000
+AB0C:0600060007000F8018801F8018800D0006000600060003F03F9830F000000000
+AB0D:0600060007000F8018801FF818980D0006000600060003003FF0303000000000
+AB0E:0300038007C00C400FC00C400680030007F00C30180018001800180000000000
+AB0F:00007FFE618E6DB6618E6DB66D8E7FFE7FFE73866DBE6D8E6DBE73BE7FFE0000
+AB10:00007FFE618E6DB6618E6DB66D8E7FFE7FFE7BCE73B67BB67BB671CE7FFE0000
+AB11:60307FF0401018C018C018C018C01FC01FC018FC18CC18CC18C018C000000000
+AB12:60307FF0401018C018C018C018C01FC01FC018C018C018C018CC18FC00000000
+AB13:30183FF820080C600C600C600C600FE00FE00C600C6000600060006000000000
+AB14:60307FF0401018C018C018C018C01FC01FC018C018C018F818CC18F800000000
+AB15:30183FF8200800001C3036303630063007F007F0063006300630063000000000
+AB16:30183FF820080C600C600C600C600FE00FE00C600C600C000C000C0000000000
+AB17:00007FFE618E6DB6618E6DB66D8E7FFE7FFE7B8673F67BEE7BDE71DE7FFE0000
+AB18:00007FFE618E6DB6618E6DB66D8E7FFE7FFE7BCE73B67BCE7BB671CE7FFE0000
+AB19:00007FFE618E6DB6618E6DB66D8E7FFE7FFE7BCE73B67BC67BF671CE7FFE0000
+AB1A:00007FFE618E6DB6618E6DB66D8E7FFE7FFE7B8673B67B867BB671B67FFE0000
+AB1B:00007FFE618E6DB6618E6DB66D8E7FFE7FFE7B8E73B67B8E7BB6718E7FFE0000
+AB1C:00007FFE618E6DB6618E6DB66D8E7FFE7FFE7BC673BE7BBE7BBE71C67FFE0000
+AB1D:00007FFE618E6DB6618E6DB66D8E7FFE7FFE7B8E73B67BB67BB6718E7FFE0000
+AB1E:00007FFE618E6DB6618E6DB66D8E7FFE7FFE7B8673BE7B8E7BBE71867FFE0000
+AB1F:00007FFE618E6DB6618E6DB66D8E7FFE7FFE7B8673BE7B8E7BBE71BE7FFE0000
+AB20:60307FF0401000001F803FC06260C230C230C230F338DAB6CAB2FBBE00000000
+AB21:60307FF0401000001F803FC06260C230C23FC233F338DAB4CAB2FBBE00000000
+AB22:60307FF0401000001F803FC06260C230C230C230F330DAB0CAB3FBBF00000000
+AB23:30183FF820080FE01FF031186118799865587DD8001800340032003E00000000
+AB24:60307FF0401000001F803FC06260C23FC239C237F330DABCCAB2FBBE00000000
+AB25:60307FF040101FC07FE0C630E6389724F33C030003800340032003E000000000
+AB26:30183FF820080FE01FF01A183218231862946252739C680064007C0000000000
+AB27:00007FFE618E6DB6618E6DB66D8E7FFE7FFE61867DF661EE6FDE61DE7FFE0000
+AB28:000018181FF81008018003C00660066003C007E00E700C300C300C3000000000
+AB29:000060607FE0402006000F00198019800F001F8039C030FC30CC30C000000000
+AB2A:000060607FE0402006000F00198019800F001F8039C030C030CC30FC00000000
+AB2B:30303FF02010030007800CC00CC007800FC01CC018E018600060006000000000
+AB2C:000030603FE02020030007800CC00CC007800FC01CE01878186C187800000000
+AB2D:000030603FE0202006000F0019F819980F001F8039C030C030C030C000000000
+AB2E:30603FE02020030007800CC00CC007800FC01CE0186018601800180000000000
+AB2F:00007FFE618E6DB6618E6DB66D8E7FFE7FFE61867DBE618E6FBE61BE7FFE0000
+AB30:000000000000344C44FE44444C340000
+AB31:0000000000007C9210709E92927C0000
+AB32:00000000000018244244485224180000
+AB33:0000000000003C42427E40FE403E0000
+AB34:0000000000001C22227EA0A0A21C0000
+AB35:0000000C1010107C1010101010000000
+AB36:0000000000003A4642423E02122A1C08
+AB37:00000000301014127C905010107C0000
+AB38:000000003010127C90127C90107C0000
+AB39:000000003010103854543810107C0000
+AB3A:0000000000006C52525252575A540000
+AB3B:0000000000005C62424242474A440000
+AB3C:0000000000005C6242424244444E1408
+AB3D:00000000000010284444444428100000
+AB3E:00000000000014284C54546428500000
+AB3F:0000000000023C460A0A1212623C4000
+AB40:0000000000006C9290909E92926C0000
+AB41:0000000000025CA6262AEAB2B25C0000
+AB42:0000000000006C921212FE92926C0000
+AB43:0000000000004C9292929292926C0000
+AB44:0000000000429CA6A6AAAAB2A25C0000
+AB45:00000000000010101038444444440000
+AB46:0000000000007C42427C505048480906
+AB47:00000000000028302020202020200000
+AB48:000000000000546A4A40404040400000
+AB49:0000000000002C3222202070A0A04000
+AB4A:0000000000002A3525202070A0A04000
+AB4B:000000000000665A4202020202020000
+AB4C:000000000000CCB48406050505020000
+AB4D:0000000C101010101010101010600000
+AB4E:000000000000404040424242463A0000
+AB4F:000000000000404040FE44444C340000
+AB50:000000000000928282929292926E0000
+AB51:000000000000EC929292928282920000
+AB52:00000000000042A2A2222222261A0000
+AB53:00000000000042422424181824244242
+AB54:0000000000008484484830304C4A8A84
+AB55:00000000000042422424181824A4C282
+AB56:00000000000084844830304A85850200
+AB57:0000000000002121120C0C1221418000
+AB58:000000000000424224181A2545820000
+AB59:0000000000002121120C0C1221A1C080
+AB5A:0000000000004040424242261A02023C
+AB5B:00000000000044380038440000000000
+AB5C:00000020203824242424040800000000
+AB5D:0000007014127C9050107C0000000000
+AB5E:0000003808083A4C08083E0000000000
+AB5F:000000000042A222261A000000000000
+AB60:0000000000007050505C5252525C0000
+AB61:0000000000004C52527E5050524C0000
+AB62:0000000000006C92121E1010926C0000
+AB63:0000000000008C9292929292926C0000
+AB64:000000000000324A46424242463A0000
+AB65:0000000000007C828282442828EE0000
+AB66:0000000000000200020002003BF84608421042204240428047083BF800080006
+AB67:00000000000000001000100010F07F08110010C01030100813080DF0010000C0
+AB68:00000000000004051E2404444C340000
+AB69:00000000002236554949000000000000
+AB6A:0000000000000404047C040404000000
+AB6B:0000000000004040407C404040000000
+AB6C:00007FFE618E6DB6618E6DB66D8E7FFE7FFE73C66FBE63BE6DBE73C67FFE0000
+AB6D:00007FFE618E6DB6618E6DB66D8E7FFE7FFE738E6FB663B66DB6738E7FFE0000
+AB6E:00007FFE618E6DB6618E6DB66D8E7FFE7FFE73866FBE638E6DBE73867FFE0000
+AB6F:00007FFE618E6DB6618E6DB66D8E7FFE7FFE73866FBE638E6DBE73BE7FFE0000
+AB70:00000000000078444242424244780000
+AB71:0000000000007C42427C504844430000
+AB72:0000000000007F080808080808080000
+AB73:0000000000001C081412215155260000
+AB74:00000000000030484B494E4848300000
+AB75:00000000000008080008080808080000
+AB76:0000000000003C42207F0442423C0000
+AB77:0000000000001C0222525262423C0000
+AB78:000000000000404C5476404040400000
+AB79:00000000000042424242261A023C0000
+AB7A:000000000000182442427E4242420000
+AB7B:00000000000004040404044444380000
+AB7C:0000000000007E40407C4040407E0000
+AB7D:000000000000080848A8BB490A0C0000
+AB7E:0000000000003C0202427C4040400000
+AB7F:0000000000001C22223E2222AACC0000
+AB80:0000000000002020203E202020200000
+AB81:0000000000007E424040404040400000
+AB82:0000000000003048484830B7B4480000
+AB83:0000000000004242425A5A6666420000
+AB84:00000000000006090838444444380000
+AB85:0000000000003C42524C404040400000
+AB86:0000000000001E2040505C5244380000
+AB87:0000000000004266665A5A4242420000
+AB88:00000000000038440202721E02020000
+AB89:000000000000180A15203C52520C0000
+AB8A:000000000000324A4A4E4A4A4A320000
+AB8B:0000000000004242427E424242420000
+AB8C:000000000000381038440202423C0000
+AB8D:000000000000474242261A02E2443800
+AB8E:0000000000003C4242427E42423C0000
+AB8F:0000000000004040F040404E443C0418
+AB90:000000000000788480809E8484780000
+AB91:0000000000000C12121222A2A2420000
+AB92:0000000000004040405C624242420000
+AB93:0000000000007E0204081020407E0000
+AB94:0000000000003844E404E4443C040400
+AB95:0000000000003048484A4D4948300000
+AB96:000000000000FE101010101010FE0000
+AB97:0000000000000C1202424A4A4A340000
+AB98:0000000000006619292A484848300000
+AB99:000000000000F1A12222242428100000
+AB9A:0000000000001C22029AA2A2A25C0000
+AB9B:0000000000003C42403C4042423C0000
+AB9C:000000000000424242427E42423C0000
+AB9D:0000000000001C2222021AD2B26C0000
+AB9E:000000000000040C1424447E04040000
+AB9F:000000000000404040407C42427C0000
+ABA0:0000000000000808080B5D6808080000
+ABA1:000000000000649AE240988484780000
+ABA2:0000000000007C42425C484442420000
+ABA3:000000000000202020202022221C0000
+ABA4:000000000000AAAA92B2CACA86820000
+ABA5:0000000000003C4247201F44423C0000
+ABA6:000000000000F09010101211110E0000
+ABA7:000000000000040404040C1424440000
+ABA8:0000000000007C0404040C1424440000
+ABA9:00000000000082824444282810100000
+ABAA:0000000000003C4240300C02423C0000
+ABAB:00000000000036494260504848300000
+ABAC:00000000000018241824225555220000
+ABAD:0000000000001C2242404040407E0000
+ABAE:000000000000404040404040407E0000
+ABAF:0000000000003C4240404040423C0000
+ABB0:0000000000000444A47E242424180000
+ABB1:00000000000066999A28444444380000
+ABB2:0000000000007C42427C404040400000
+ABB3:0000000000003C4247404042423C0000
+ABB4:000000000000F1911212141418100000
+ABB5:0000000000404040434D744444440000
+ABB6:00000000000044485060605048440000
+ABB7:0000000000000202023E4242423C0000
+ABB8:000000000000304A454040454A300000
+ABB9:00000000000038444440404E443B0000
+ABBA:00000000000022555351311995620000
+ABBB:0000000000003C4272525E42423C0000
+ABBC:000000000000324949714141221C0000
+ABBD:0000000000000C12120A064244380000
+ABBE:0000000000003C4240407C42423C0000
+ABBF:0000000000001E2101015D4949360000
+ABC0:00000000000000007FF824B024D02590269024902C9034903FF0000000000000
+ABC1:0000000000000000063009481084100410040808080804100220000000000000
+ABC2:00000000000000001FF80020002007A008601000100008400780000000000000
+ABC3:00000000000000007FF82400240024003FE024C02500251024E0000000000000
+ABC4:00000000000000007FF844882490249014A014A014A054A86498000000000000
+ABC5:00000000000000001FFC041008100820104010080810042003C0000000000000
+ABC6:00000000000000003FF020101020102008400FC0084028503030000000000000
+ABC7:00000000008001001FF011080890086004000400240024001800000000000000
+ABC8:00000000000000001FF8100008C0052006280410040004001800000000000000
+ABC9:000000000000000007F004900490049064909490149024907FF0000000000000
+ABCA:00000000000000001FFC00800080008008881084108409480630000000000000
+ABCB:00000000000000003FF8200810101010092008A0086008203018000000000000
+ABCC:00000000000000007FFF0808100413640D580240042008241018000000000000
+ABCD:00000000000000007FFC000001800240042008200920112060C0000000000000
+ABCE:00000000000000003FFC10001070089007E00010088815481230000000000000
+ABCF:00000000000000001FF8100008000600058004600410051018E0000000000000
+ABD0:00000000000000001FF01000102010401F801000101010201FC0000000000000
+ABD1:00000000000000003FF8124012401240124012400A480A5007E0000000000000
+ABD2:00000000000000001FF009200924092409180900090009000900000000000000
+ABD3:00000000000000000FF800100020004000800100020004300FC0004000300000
+ABD4:00000000000000000E70118810881F8010801080108010801F80000000000000
+ABD5:00000000000000000FE004400280010002800440082004400380000000000000
+ABD6:00000000000000001FF0001000E0030004000820082004400380000000000000
+ABD7:00000000000000000FFC04480288011002900450083004480384000000000000
+ABD8:00000000000000001FF004000400040004001FC0248024901860000000000000
+ABD9:00000000000000001FFC0040004000400840104010C009400640000000000000
+ABDA:00000000000000001FF00220022012200C200020002000200020000000000000
+ABDB:00000000000000003FF812481248124012401240124012401FC0000000000000
+ABDC:00000000000000000FF80010001000100010071000D000300010000000000000
+ABDD:00000000000000003FF8108010801FE010801080108010801080000000000000
+ABDE:00000000000000003FF821081110111009200920092029283118000000000000
+ABDF:00000000000000003FF8049009201200122011C00808081007E0000000000000
+ABE0:000000000000000020402080210022003F800240024002400180000000000000
+ABE1:00000000000000001FF009200920092009200920092009200FE0000000000000
+ABE2:00000000000000001FF01000080007C0042004100910092010C0000000000000
+ABE3:00180004001C0024002400180000000000000000000000000000000000000000
+ABE4:0000000600090009003E00080008000800080008000800080008000000000000
+ABE5:0040002000100000000000000000000000000000000000000000000000000000
+ABE6:0000000000000000000000000006000900090006000000000000000000000000
+ABE7:00020015000E0004000C00000000000000000000000000000000000000000000
+ABE8:0000000000000000000000000000000000000000000000000360049004100220
+ABE9:000200250015000E000400000000000000000000000000000000000000000000
+ABEA:0002000500050003000100020004000000000000000000000000000000000000
+ABEB:0000000000000000044004400440044004400440044004400440000000000000
+ABEC:0000000000000000000000000000000000000000000000060006000000000000
+ABED:000000000000000000000000000000000000000000000000000000007FFE0000
+ABEE:00007FFE618E6DB6618E6DB66D8E7FFE7FFE61866FBE638E6FBE61867FFE0000
+ABEF:00007FFE618E6DB6618E6DB66D8E7FFE7FFE61866FBE638E6FBE61BE7FFE0000
+ABF0:0000000003000CC01020102020102010102010200CC003000000000000000000
+ABF1:000000000000000003800440082008C004000300008004400380000000000000
+ABF2:000000000000000003800440082008C004000360049004500390000000000000
+ABF3:000000000000000003800440082008CC0412036A04A804A80310000000000000
+ABF4:00000000000000000380044000800300040008C0082004400380000000000000
+ABF5:00000000000000000FC010202210251015000E00040004000400000000000000
+ABF6:00000000000000000FC010202210252015000E00048005000600040000000000
+ABF7:00000000000000000C3011480950012003D00508088809100620000000000000
+ABF8:00000000000000000FC010202210252015000E00040014000C00040000000000
+ABF9:00000000000000000FC010202210252015000E0004001F802400180000000000
+ABFA:00007FFE618E6DB6618E6DB66D8E7FFE7FFE61866FB663866FB66FB67FFE0000
+ABFB:00007FFE618E6DB6618E6DB66D8E7FFE7FFE618E6FB6638E6FB66F8E7FFE0000
+ABFC:00007FFE618E6DB6618E6DB66D8E7FFE7FFE61C66FBE63BE6FBE6FC67FFE0000
+ABFD:00007FFE618E6DB6618E6DB66D8E7FFE7FFE618E6FB663B66FB66F8E7FFE0000
+ABFE:00007FFE618E6DB6618E6DB66D8E7FFE7FFE61866FBE638E6FBE6F867FFE0000
+ABFF:00007FFE618E6DB6618E6DB66D8E7FFE7FFE61866FBE638E6FBE6FBE7FFE0000
+AC00:00000000001000101F9000900090009E01100110021004101810001000100000
+AC01:000000083E0802080208040E080830080008000007F800080008000800080000
+AC02:000000083E0802080208040E080830080008000000003EF80208020802080000
+AC03:000000083E0802080208040E080830080008000000001F080108011401620000
+AC04:000000083E0802080208040E080830080008000808000800080008000FF80000
+AC05:000000083E0802080208040E0808300800080000000010F8101010301ECC0000
+AC06:000000083E0802080208040E08083008000800000808087F081C08220F9C0000
+AC07:000000083E0802080208040E080830080008000003F802000200020003F80000
+AC08:000000083E0802080208040E080830080008000007F8000807F8040007F80000
+AC09:000000083E0802080208040E08083008000800003EF802083E0820083E080000
+AC0A:000000083E0802080208040E08083008000800003EF802883E8820883EF80000
+AC0B:000000083E0802080208040E08083008000800003E8802883EF820883EF80000
+AC0C:000000083E0802080208040E08083008000800001F0801081F0810141F620000
+AC0D:000000083E0802080208040E08083008000800003EF802803EF820803EF80000
+AC0E:000000083E0802080208040E08083008000800003EFC02483E4820483EFC0000
+AC0F:000000083E0802080208040E08083008000800001F08017F1F1C10221F1C0000
+AC10:000000083E0802080208040E080830080008000003F802080208020803F80000
+AC11:000000083E0802080208040E08083008000800000208020803F8020803F80000
+AC12:000000083E0802080208040E0808300800080000110811081F0811141F620000
+AC13:000000083E0802080208040E0808300800080000001000100010006801840000
+AC14:000000083E0802080208040E08083008000800000048004800A8011406620000
+AC15:000000083E0802080208040E0808300800080000000003F00408040803F00000
+AC16:000000083E0802080208040E080830080008000003F80020002000D003080000
+AC17:000000083E0802080208040E0808300800080000004003F8004000A003180000
+AC18:000000083E0802080208040E080830080008000003F8000803F8000800080000
+AC19:000000083E0802080208040E080830080008000003F8020003F8020003F80000
+AC1A:000000083E0802080208040E080830080008000000000FF8022002200FF80000
+AC1B:000000083E0802080208040E080830080008000000800FF803E0041003E00000
+AC1C:00000000001200121F9200920092009E01120112021204121812001200120000
+AC1D:000000283E28022802280438082830280028000007F800080008000800080000
+AC1E:000000283E28022802280438082830280028000000003EF80208020802080000
+AC1F:000000283E28022802280438082830280028000000003E100210022802C40000
+AC20:000000283E28022802280438082830280028002808000800080008000FF80000
+AC21:000000283E280228022804380828302800280000000020F8201020303ECC0000
+AC22:000000283E280228022804380828302800280000202021FC207020883E700000
+AC23:000000283E28022802280438082830280028000003F802000200020003F80000
+AC24:000000283E28022802280438082830280028000007F8000807F8040007F80000
+AC25:000000283E2802280228043808283028002800003EF802083E0820083E080000
+AC26:000000283E2802280228043808283028002800003EF802883E8820883EF80000
+AC27:000000283E2802280228043808283028002800003E8802883EF820883EF80000
+AC28:000000283E2802280228043808283028002800001F0801081F0810141F620000
+AC29:000000283E2802280228043808283028002800003EF802803EF820803EF80000
+AC2A:000000283E2802280228043808283028002800003EFC02483E4820483EFC0000
+AC2B:000000283E2802280228043808283028002800003E1002FE3E3820443E380000
+AC2C:000000283E28022802280438082830280028000003F802080208020803F80000
+AC2D:000000283E2802280228043808283028002800000208020803F8020803F80000
+AC2E:000000283E280228022804380828302800280000110811081F0811141F620000
+AC2F:000000283E280228022804380828302800280000000800080008003400C20000
+AC30:000000283E2802280228043808283028002800000048004800A8011406620000
+AC31:000000283E280228022804380828302800280000000001F00208020801F00000
+AC32:000000283E28022802280438082830280028000003F80020002000D003080000
+AC33:000000283E280228022804380828302800280000004003F8004000A003180000
+AC34:000000283E28022802280438082830280028000003F8000803F8000800080000
+AC35:000000283E28022802280438082830280028000003F8020003F8020003F80000
+AC36:000000283E28022802280438082830280028000000000FF8022002200FF80000
+AC37:000000283E28022802280438082830280028000000800FF803E0041003E00000
+AC38:00000000001000101F900090009E00900110011E021004101810001000100000
+AC39:000000083E080208020E0408080E30080008000007F800080008000800080000
+AC3A:000000083E080208020E0408080E30080008000000003EF80208020802080000
+AC3B:000000083E080208020E0408080E30080008000000001F080108011401620000
+AC3C:000000083E080208020E0408080E30080008000008000800080008000FF80000
+AC3D:000000083E080208020E0408080E300800080000000010F8101010301ECC0000
+AC3E:000000083E080208020E0408080E3008000800000808087F081C08220F9C0000
+AC3F:000000083E080208020E0408080E30080008000003F802000200020003F80000
+AC40:000000083E080208020E0408080E30080008000007F8000807F8040007F80000
+AC41:000000083E080208020E0408080E3008000800003EF802083E0820083E080000
+AC42:000000083E080208020E0408080E3008000800003EF802883E8820883EF80000
+AC43:000000083E080208020E0408080E3008000800003E8802883EF820883EF80000
+AC44:000000083E080208020E0408080E3008000800001F0801081F0810141F620000
+AC45:000000083E080208020E0408080E3008000800003EF802803EF820803EF80000
+AC46:000000083E080208020E0408080E3008000800003EFC02483E4820483EFC0000
+AC47:000000083E080208020E0408080E3008000800001F08017F1F1C10221F1C0000
+AC48:000000083E080208020E0408080E30080008000003F802080208020803F80000
+AC49:000000083E080208020E0408080E3008000800000208020803F8020803F80000
+AC4A:000000083E080208020E0408080E300800080000110811081F0811141F620000
+AC4B:000000083E080208020E0408080E300800080000001000100010006801840000
+AC4C:000000083E080208020E0408080E3008000800000048004800A8011406620000
+AC4D:000000083E080208020E0408080E300800080000000003F00408040803F00000
+AC4E:000000083E080208020E0408080E30080008000003F80020002000D003080000
+AC4F:000000083E080208020E0408080E300800080000004003F8004000A003180000
+AC50:000000083E080208020E0408080E30080008000003F8000803F8000800080000
+AC51:000000083E080208020E0408080E30080008000003F8020003F8020003F80000
+AC52:000000083E080208020E0408080E30080008000000000FF8022002200FF80000
+AC53:000000083E080208020E0408080E30080008000000800FF803E0041003E00000
+AC54:00000000001200121F920092009E00920112011E021204121812001200120000
+AC55:000000283E28022802380428083830280028000007F800080008000800080000
+AC56:000000283E28022802380428083830280028000000003EF80208020802080000
+AC57:000000283E28022802380428083830280028000000003E100210022802C40000
+AC58:000000283E28022802380428083830280028002808000800080008000FF80000
+AC59:000000283E280228023804280838302800280000000020F8201020303ECC0000
+AC5A:000000283E280228023804280838302800280000202021FC207020883E700000
+AC5B:000000283E28022802380428083830280028000003F802000200020003F80000
+AC5C:000000283E28022802380428083830280028000007F8000807F8040007F80000
+AC5D:000000283E2802280238042808383028002800003EF802083E0820083E080000
+AC5E:000000283E2802280238042808383028002800003EF802883E8820883EF80000
+AC5F:000000283E2802280238042808383028002800003E8802883EF820883EF80000
+AC60:000000283E2802280238042808383028002800001F0801081F0810141F620000
+AC61:000000283E2802280238042808383028002800003EF802803EF820803EF80000
+AC62:000000283E2802280238042808383028002800003EFC02483E4820483EFC0000
+AC63:000000283E2802280238042808383028002800003E1002FE3E3820443E380000
+AC64:000000283E28022802380428083830280028000003F802080208020803F80000
+AC65:000000283E2802280238042808383028002800000208020803F8020803F80000
+AC66:000000283E280228023804280838302800280000110811081F0811141F620000
+AC67:000000283E280228023804280838302800280000000800080008003400C20000
+AC68:000000283E2802280238042808383028002800000048004800A8011406620000
+AC69:000000283E280228023804280838302800280000000001F00208020801F00000
+AC6A:000000283E28022802380428083830280028000003F80020002000D003080000
+AC6B:000000283E280228023804280838302800280000004003F8004000A003180000
+AC6C:000000283E28022802380428083830280028000003F8000803F8000800080000
+AC6D:000000283E28022802380428083830280028000003F8020003F8020003F80000
+AC6E:000000283E28022802380428083830280028000000000FF8022002200FF80000
+AC6F:000000283E28022802380428083830280028000000800FF803E0041003E00000
+AC70:00000000000200021F8200820082009E01020102020204021802000200020000
+AC71:000000083E080208020804380808300800080000000007F80008000800080000
+AC72:000000083E08020802080438080830080008000000003EF80208020802080000
+AC73:000000083E08020802080438080830080008000000001F080108011401620000
+AC74:000000083E08020802080438080830080008000000001000100010001FF80000
+AC75:000000083E080208020804380808300800080000000020F8201020303ECC0000
+AC76:000000083E080208020804380808300800080000202021FC207020883E700000
+AC77:000000083E08020802080438080830080008000003F802000200020003F80000
+AC78:000000083E08020802080438080830080008000007F8000807F8040007F80000
+AC79:000000083E0802080208043808083008000800003EF802083E0820083E080000
+AC7A:000000083E0802080208043808083008000800003EF802883E8820883EF80000
+AC7B:000000083E0802080208043808083008000800003E8802883EF820883EF80000
+AC7C:000000083E0802080208043808083008000800000F8800880F8808140FA20000
+AC7D:000000083E0802080208043808083008000800003EF802803EF820803EF80000
+AC7E:000000083E0802080208043808083008000800003EFC02483E4820483EFC0000
+AC7F:000000083E0802080208043808083008000800003E1002FE3E3820443E380000
+AC80:000000083E08020802080438080830080008000003F802080208020803F80000
+AC81:000000083E0802080208043808083008000800000208020803F8020803F80000
+AC82:000000083E080208020804380808300800080000210821083F0821143F620000
+AC83:000000083E080208020804380808300800080000001000100010006801840000
+AC84:000000083E0802080208043808083008000800000048004800A8011406620000
+AC85:000000083E080208020804380808300800080000000003F00408040803F00000
+AC86:000000083E08020802080438080830080008000003F80020002000D003080000
+AC87:000000083E080208020804380808300800080000004003F8004000A003180000
+AC88:000000083E08020802080438080830080008000003F8000803F8000800080000
+AC89:000000083E08020802080438080830080008000003F8020003F8020003F80000
+AC8A:000000083E08020802080438080830080008000000000FF8022002200FF80000
+AC8B:000000083E08020802080438080830080008000000800FF803E0041003E00000
+AC8C:00000000000A000A1F8A008A008A00BA010A010A020A040A180A000A000A0000
+AC8D:000000283E280228022804E8082830280028000007F800080008000800080000
+AC8E:000000283E280228022804E8082830280028000000003EF80208020802080000
+AC8F:000000283E280228022804E8082830280028000000003E100210022802C40000
+AC90:000000283E280228022804E8082830280028000008000800080008000FF80000
+AC91:000000283E280228022804E80828302800280000000020F8201020303ECC0000
+AC92:000000283E280228022804E80828302800280000202021FC207020883E700000
+AC93:000000283E280228022804E8082830280028000003F802000200020003F80000
+AC94:000000283E280228022804E8082830280028000007F8000807F8040007F80000
+AC95:000000283E280228022804E808283028002800003EF802083E0820083E080000
+AC96:000000283E280228022804E808283028002800003EF802883E8820883EF80000
+AC97:000000283E280228022804E808283028002800003E8802883EF820883EF80000
+AC98:000000283E280228022804E808283028002800001F0801081F0810141F620000
+AC99:000000283E280228022804E808283028002800003EF802803EF820803EF80000
+AC9A:000000283E280228022804E808283028002800003EFC02483E4820483EFC0000
+AC9B:000000283E280228022804E808283028002800003E1002FE3E3820443E380000
+AC9C:000000283E280228022804E8082830280028000003F802080208020803F80000
+AC9D:000000283E280228022804E808283028002800000208020803F8020803F80000
+AC9E:000000283E280228022804E80828302800280000110811081F0811141F620000
+AC9F:000000283E280228022804E80828302800280000000800080008003400C20000
+ACA0:000000283E280228022804E808283028002800000048004800A8011406620000
+ACA1:000000283E280228022804E80828302800280000000001F00208020801F00000
+ACA2:000000283E280228022804E8082830280028000003F80020002000D003080000
+ACA3:000000283E280228022804E80828302800280000004003F8004000A003180000
+ACA4:000000283E280228022804E8082830280028000003F8000803F8000800080000
+ACA5:000000283E280228022804E8082830280028000003F8020003F8020003F80000
+ACA6:000000283E280228022804E8082830280028000000000FF8022002200FF80000
+ACA7:000000283E280228022804E8082830280028000000800FF803E0041003E00000
+ACA8:00000000000200021F820082009E00820102011E020204021802000200020000
+ACA9:000000083E080208023804080838300800080000000007F80008000800080000
+ACAA:000000083E08020802380408083830080008000000003EF80208020802080000
+ACAB:000000083E08020802380408083830080008000000001F080108011401620000
+ACAC:000000083E08020802380408083830080008000800001000100010001FF80000
+ACAD:000000083E080208023804080838300800080000000020F8201020303ECC0000
+ACAE:000000083E080208023804080838300800080000202021FC207020883E700000
+ACAF:000000083E08020802380408083830080008000003F802000200020003F80000
+ACB0:000000083E08020802380408083830080008000007F8000807F8040007F80000
+ACB1:000000083E0802080238040808383008000800003EF802083E0820083E080000
+ACB2:000000083E0802080238040808383008000800003EF802883E8820883EF80000
+ACB3:000000083E0802080238040808383008000800003E8802883EF820883EF80000
+ACB4:000000083E0802080238040808383008000800000F8800880F8808140FA20000
+ACB5:000000083E0802080238040808383008000800003EF802803EF820803EF80000
+ACB6:000000083E0802080238040808383008000800003EFC02483E4820483EFC0000
+ACB7:000000083E0802080238040808383008000800003E1002FE3E3820443E380000
+ACB8:000000083E08020802380408083830080008000003F802080208020803F80000
+ACB9:000000083E0802080238040808383008000800000208020803F8020803F80000
+ACBA:000000083E080208023804080838300800080000210821083F0821143F620000
+ACBB:000000083E080208023804080838300800080000001000100010006801840000
+ACBC:000000083E0802080238040808383008000800000048004800A8011406620000
+ACBD:000000083E080208023804080838300800080000000003F00408040803F00000
+ACBE:000000083E08020802380408083830080008000003F80020002000D003080000
+ACBF:000000083E080208023804080838300800080000004003F8004000A003180000
+ACC0:000000083E08020802380408083830080008000003F8000803F8000800080000
+ACC1:000000083E08020802380408083830080008000003F8020003F8020003F80000
+ACC2:000000083E08020802380408083830080008000000000FF8022002200FF80000
+ACC3:000000083E08020802380408083830080008000000800FF803E0041003E00000
+ACC4:00000000000A000A1F8A008A00BA008A010A013A020A040A180A000A000A0000
+ACC5:000000283E28022802E8042808E830280028000007F800080008000800080000
+ACC6:000000283E28022802E8042808E830280028000000003EF80208020802080000
+ACC7:000000283E28022802E8042808E830280028000000003E100210022802C40000
+ACC8:000000283E28022802E8042808E830280028002808000800080008000FF80000
+ACC9:000000283E28022802E8042808E8302800280000000020F8201020303ECC0000
+ACCA:000000283E28022802E8042808E8302800280000202021FC207020883E700000
+ACCB:000000283E28022802E8042808E830280028000003F802000200020003F80000
+ACCC:000000283E28022802E8042808E830280028000007F8000807F8040007F80000
+ACCD:000000283E28022802E8042808E83028002800003EF802083E0820083E080000
+ACCE:000000283E28022802E8042808E83028002800003EF802883E8820883EF80000
+ACCF:000000283E28022802E8042808E83028002800003E8802883EF820883EF80000
+ACD0:000000283E28022802E8042808E83028002800001F0801081F0810141F620000
+ACD1:000000283E28022802E8042808E83028002800003EF802803EF820803EF80000
+ACD2:000000283E28022802E8042808E83028002800003EFC02483E4820483EFC0000
+ACD3:000000283E28022802E8042808E83028002800003E1002FE3E3820443E380000
+ACD4:000000283E28022802E8042808E830280028000003F802080208020803F80000
+ACD5:000000283E28022802E8042808E83028002800000208020803F8020803F80000
+ACD6:000000283E28022802E8042808E8302800280000110811081F0811141F620000
+ACD7:000000283E28022802E8042808E8302800280000000800080008003400C20000
+ACD8:000000283E28022802E8042808E83028002800000048004800A8011406620000
+ACD9:000000283E28022802E8042808E8302800280000000001F00208020801F00000
+ACDA:000000283E28022802E8042808E830280028000003F80020002000D003080000
+ACDB:000000283E28022802E8042808E8302800280000004003F8004000A003180000
+ACDC:000000283E28022802E8042808E830280028000003F8000803F8000800080000
+ACDD:000000283E28022802E8042808E830280028000003F8020003F8020003F80000
+ACDE:000000283E28022802E8042808E830280028000000000FF8022002200FF80000
+ACDF:000000283E28022802E8042808E830280028000000800FF803E0041003E00000
+ACE0:00000000000000003FF0001000100010001002100200020002007FFC00000000
+ACE1:000000001FF0001000100010011001007FFC00001FF000100010001000100000
+ACE2:000000001FF0001000100010011001007FFC000000003EF80208020802080000
+ACE3:000000001FF0001000100010011001007FFC000000001E100210022802C40000
+ACE4:000000001FF0001000100010011001007FFC000000001000100010001FF00000
+ACE5:000000001FF0001000100010011001007FFC0000000020F8201020303ECC0000
+ACE6:000000001FF0001000100010011001007FFC0000202021FC207020883E700000
+ACE7:000000001FF0001000100010011001007FFC00001FF01000100010001FF00000
+ACE8:000000001FF0001000100010011001007FFC00001FF000101FF010001FF00000
+ACE9:000000001FF0001000100010011001007FFC00003EF802083E0820083E080000
+ACEA:000000001FF0001000100010011001007FFC00003EF802883E8820883EF80000
+ACEB:000000001FF0001000100010011001007FFC00003E8802883EF820883EF80000
+ACEC:000000001FF0001000100010011001007FFC00003E1002103E1020283EC40000
+ACED:000000001FF0001000100010011001007FFC00003EF802803EF820803EF80000
+ACEE:000000001FF0001000100010011001007FFC00003EFC02483E4820483EFC0000
+ACEF:000000001FF0001000100010011001007FFC00003E2003FC3E7020883E700000
+ACF0:000000001FF0001000100010011001007FFC00001FF01010101010101FF00000
+ACF1:000000001FF0001000100010011001007FFC0000101010101FF010101FF00000
+ACF2:000000001FF0001000100010011001007FFC0000222022203E2022503E880000
+ACF3:000000001FF0001000100010011001007FFC000000000100010002800C400000
+ACF4:000000001FF0001000100010011001007FFC00000000024002400DA033100000
+ACF5:000000001FF0001000100010011001007FFC0000000007C00820082007C00000
+ACF6:000000001FF0001000100010011001007FFC0000000007E00080014006200000
+ACF7:000000001FF0001000100010011001007FFC0000008007E00080014006200000
+ACF8:000000001FF0001000100010011001007FFC00001FF000101FF0001000100000
+ACF9:000000001FF0001000100010011001007FFC00001FF010001FF010001FF00000
+ACFA:000000001FF0001000100010011001007FFC000000001FF0044004401FF00000
+ACFB:000000001FF0001000100010011001007FFC000001001FF007C0082007C00000
+ACFC:00000000001000103FD000500050005E0450041004107FD00010001000100000
+ACFD:000000081F880088008E0088048804087FE8000007F800080008000800080000
+ACFE:000000081F880088008E0088048804087FE8000000003EF80208020802080000
+ACFF:000000081F880088008E0088048804087FE8000000001F080108011401620000
+AD00:000000081F880088008E0088048804087FE8000008000800080008000FF80000
+AD01:000000081F880088008E0088048804087FE80000000010F8101010301ECC0000
+AD02:000000081F880088008E0088048804087FE800000808087F081C08220F9C0000
+AD03:000000081F880088008E0088048804087FE8000003F802000200020003F80000
+AD04:000000081F880088008E0088048804087FE8000007F8000807F8040007F80000
+AD05:000000081F880088008E0088048804087FE800003EF802083E0820083E080000
+AD06:000000081F880088008E0088048804087FE800003EF802883E8820883EF80000
+AD07:000000081F880088008E0088048804087FE800003E8802883EF820883EF80000
+AD08:000000081F880088008E0088048804087FE800001F0801081F0810141F620000
+AD09:000000081F880088008E0088048804087FE800003EF802803EF820803EF80000
+AD0A:000000081F880088008E0088048804087FE800003EFC02483E4820483EFC0000
+AD0B:000000081F880088008E0088048804087FE800001F08017F1F1C10221F1C0000
+AD0C:000000081F880088008E0088048804087FE8000003F802080208020803F80000
+AD0D:000000081F880088008E0088048804087FE800000208020803F8020803F80000
+AD0E:000000081F880088008E0088048804087FE80000110811081F0811141F620000
+AD0F:000000081F880088008E0088048804087FE80000001000100010006801840000
+AD10:000000081F880088008E0088048804087FE800000048004800A8011406620000
+AD11:000000081F880088008E0088048804087FE80000000003F00408040803F00000
+AD12:000000081F880088008E0088048804087FE8000003F80020002000D003080000
+AD13:000000081F880088008E0088048804087FE80000004003F8004000A003180000
+AD14:000000081F880088008E0088048804087FE8000003F8000803F8000800080000
+AD15:000000081F880088008E0088048804087FE8000003F8020003F8020003F80000
+AD16:000000081F880088008E0088048804087FE8000000000FF8022002200FF80000
+AD17:000000081F880088008E0088048804087FE8000000800FF803E0041003E00000
+AD18:00000000001200123FD200520052005E0452041204127FD20012001200120000
+AD19:000000281FA800A800B800A804A804287FA8000007F800080008000800080000
+AD1A:000000281FA800A800B800A804A804287FA8000000003EF80208020802080000
+AD1B:000000281FA800A800B800A804A804287FA8000000001F080108011401620000
+AD1C:000000281FA800A800B800A804A804287FA8000008000800080008000FF80000
+AD1D:000000281FA800A800B800A804A804287FA80000000010F8101010301ECC0000
+AD1E:000000281FA800A800B800A804A804287FA800000808087F081C08220F9C0000
+AD1F:000000281FA800A800B800A804A804287FA8000003F802000200020003F80000
+AD20:000000281FA800A800B800A804A804287FA8000007F8000807F8040007F80000
+AD21:000000281FA800A800B800A804A804287FA800003EF802083E0820083E080000
+AD22:000000281FA800A800B800A804A804287FA800003EF802883E8820883EF80000
+AD23:000000281FA800A800B800A804A804287FA800003E8802883EF820883EF80000
+AD24:000000281FA800A800B800A804A804287FA800001F0801081F0810141F620000
+AD25:000000281FA800A800B800A804A804287FA800003EF802803EF820803EF80000
+AD26:000000281FA800A800B800A804A804287FA800003EFC02483E4820483EFC0000
+AD27:000000281FA800A800B800A804A804287FA800001F08017F1F1C10221F1C0000
+AD28:000000281FA800A800B800A804A804287FA8000003F802080208020803F80000
+AD29:000000281FA800A800B800A804A804287FA800000208020803F8020803F80000
+AD2A:000000281FA800A800B800A804A804287FA80000110811081F0811141F620000
+AD2B:000000281FA800A800B800A804A804287FA80000001000100010006801840000
+AD2C:000000281FA800A800B800A804A804287FA800000048004800A8011406620000
+AD2D:000000281FA800A800B800A804A804287FA80000000003F00408040803F00000
+AD2E:000000281FA800A800B800A804A804287FA8000003F80020002000D003080000
+AD2F:000000281FA800A800B800A804A804287FA80000004003F8004000A003180000
+AD30:000000281FA800A800B800A804A804287FA8000003F8000803F8000800080000
+AD31:000000281FA800A800B800A804A804287FA8000003F8020003F8020003F80000
+AD32:000000281FA800A800B800A804A804287FA8000000000FF8022002200FF80000
+AD33:000000281FA800A800B800A804A804287FA8000000800FF803E0041003E00000
+AD34:00000000000400043FC40044004400440444040404047FF40004000400040000
+AD35:000000081F88008800880088048804087FE8000007F800080008000800080000
+AD36:000000081F88008800880088048804087FE8000000003EF80208020802080000
+AD37:000000081F88008800880088048804087FE8000000001F080108011401620000
+AD38:000000081F88008800880088048804087FE8000008000800080008000FF80000
+AD39:000000081F88008800880088048804087FE80000000010F8101010301ECC0000
+AD3A:000000081F88008800880088048804087FE800000808087F081C08220F9C0000
+AD3B:000000081F88008800880088048804087FE8000003F802000200020003F80000
+AD3C:000000081F88008800880088048804087FE8000007F8000807F8040007F80000
+AD3D:000000081F88008800880088048804087FE800003EF802083E0820083E080000
+AD3E:000000081F88008800880088048804087FE800003EF802883E8820883EF80000
+AD3F:000000081F88008800880088048804087FE800003E8802883EF820883EF80000
+AD40:000000081F88008800880088048804087FE800001F0801081F0810141F620000
+AD41:000000081F88008800880088048804087FE800003EF802803EF820803EF80000
+AD42:000000081F88008800880088048804087FE800003EFC02483E4820483EFC0000
+AD43:000000081F88008800880088048804087FE800001F08017F1F1C10221F1C0000
+AD44:000000081F88008800880088048804087FE8000003F802080208020803F80000
+AD45:000000081F88008800880088048804087FE800000208020803F8020803F80000
+AD46:000000081F88008800880088048804087FE80000110811081F0811141F620000
+AD47:000000081F88008800880088048804087FE80000001000100010006801840000
+AD48:000000081F88008800880088048804087FE800000048004800A8011406620000
+AD49:000000081F88008800880088048804087FE80000000003F00408040803F00000
+AD4A:000000081F88008800880088048804087FE8000003F80020002000D003080000
+AD4B:000000081F88008800880088048804087FE80000004003F8004000A003180000
+AD4C:000000081F88008800880088048804087FE8000003F8000803F8000800080000
+AD4D:000000081F88008800880088048804087FE8000003F8020003F8020003F80000
+AD4E:000000081F88008800880088048804087FE8000000000FF8022002200FF80000
+AD4F:000000081F88008800880088048804087FE8000000800FF803E0041003E00000
+AD50:00000000000000003FF0001000100010001008900880088008807FFC00000000
+AD51:000000001FF0001000100010049004807FFC00001FF000100010001000100000
+AD52:000000001FF0001000100010049004807FFC000000003EF80208020802080000
+AD53:000000001FF0001000100010049004807FFC000000001E100210022802C40000
+AD54:000000001FF0001000100010049004807FFC000000001000100010001FF00000
+AD55:000000001FF0001000100010049004807FFC0000000020F8201020303ECC0000
+AD56:000000001FF0001000100010049004807FFC0000202021FC207020883E700000
+AD57:000000001FF0001000100010049004807FFC00001FF01000100010001FF00000
+AD58:000000001FF0001000100010049004807FFC00001FF000101FF010001FF00000
+AD59:000000001FF0001000100010049004807FFC00003EF802083E0820083E080000
+AD5A:000000001FF0001000100010049004807FFC00003EF802883E8820883EF80000
+AD5B:000000001FF0001000100010049004807FFC00003E8802883EF820883EF80000
+AD5C:000000001FF0001000100010049004807FFC00003E1002103E1020283EC40000
+AD5D:000000001FF0001000100010049004807FFC00003EF802803EF820803EF80000
+AD5E:000000001FF0001000100010049004807FFC00003EFC02483E4820483EFC0000
+AD5F:000000001FF0001000100010049004807FFC00003E2003FC3E7020883E700000
+AD60:000000001FF0001000100010049004807FFC00001FF01010101010101FF00000
+AD61:000000001FF0001000100010049004807FFC0000101010101FF010101FF00000
+AD62:000000001FF0001000100010049004807FFC0000222022203E2022503E880000
+AD63:000000001FF0001000100010049004807FFC000000000100010002800C400000
+AD64:000000001FF0001000100010049004807FFC00000000024002400DA033100000
+AD65:000000001FF0001000100010049004807FFC0000000007C00820082007C00000
+AD66:000000001FF0001000100010049004807FFC0000000007E00080014006200000
+AD67:000000001FF0001000100010049004807FFC0000008007E00080014006200000
+AD68:000000001FF0001000100010049004807FFC00001FF000101FF0001000100000
+AD69:000000001FF0001000100010049004807FFC00001FF010001FF010001FF00000
+AD6A:000000001FF0001000100010049004807FFC000000001FF0044004401FF00000
+AD6B:000000001FF0001000100010049004807FFC000001001FF007C0082007C00000
+AD6C:0000000000003FE00020002000200020002000003FF801000100010001000000
+AD6D:000000001FF000100010001000007FFC010001001FF000100010001000100000
+AD6E:000000001FF000100010001000007FFC0100010000003EF80208020802080000
+AD6F:000000001FF000100010001000007FFC0100010000001E100210022802C40000
+AD70:000000001FF0001000100010000000007FFC010001001100100010001FF00000
+AD71:000000001FF000100010001000007FFC01000100000020F8201020303ECC0000
+AD72:000000001FF000100010001000007FFC01000100202021FC207020883E700000
+AD73:000000001FF000100010001000007FFC010001001FF01000100010001FF00000
+AD74:000000001FF000100010001000007FFC010001001FF000101FF010001FF00000
+AD75:000000001FF000100010001000007FFC010001003EF802083E0820083E080000
+AD76:000000001FF000100010001000007FFC010001003EF802883E8820883EF80000
+AD77:000000001FF000100010001000007FFC010001003E8802883EF820883EF80000
+AD78:000000001FF000100010001000007FFC010001003E1002103E1020283EC40000
+AD79:000000001FF000100010001000007FFC010001003EF802803EF820803EF80000
+AD7A:000000001FF000100010001000007FFC010001003EFC02483E4820483EFC0000
+AD7B:000000001FF000100010001000007FFC010001003E2003FC3E7020883E700000
+AD7C:000000001FF000100010001000007FFC010001001FF01010101010101FF00000
+AD7D:000000001FF000100010001000007FFC01000100101010101FF010101FF00000
+AD7E:000000001FF000100010001000007FFC01000100222022203E2022503E880000
+AD7F:000000001FF000100010001000007FFC0100010000000100010002800C400000
+AD80:000000001FF000100010001000007FFC010001000000024002400DA033100000
+AD81:000000001FF000100010001000007FFC01000100000007C00820082007C00000
+AD82:000000001FF000100010001000007FFC01000100000007E00080014006200000
+AD83:000000001FF000100010001000007FFC01000100008007E00080014006200000
+AD84:000000001FF000100010001000007FFC010001001FF000101FF0001000100000
+AD85:000000001FF000100010001000007FFC010001001FF010001FF010001FF00000
+AD86:000000001FF000100010001000007FFC0100010000001FF0044004401FF00000
+AD87:000000001FF000100010001000007FFC0100010001001FF007C0082007C00000
+AD88:00000008000800083FE8002800280028002800087FE8040804F8040804080000
+AD89:000800083F080108010801087FE8027802080000000007F80008000800080000
+AD8A:000800083F080108010801087FE802780208000000003EF80208020802080000
+AD8B:000800083F080108010801087FE802780208000000001F080108011401620000
+AD8C:000800083F0801080108010800087FE80278020802081000100010001FF80000
+AD8D:000800083F080108010801087FE8027802080000000020F8201020303ECC0000
+AD8E:000800083F080108010801087FE8027802080000202021FC207020883E700000
+AD8F:000800083F080108010801087FE802780208000003F802000200020003F80000
+AD90:000800083F080108010801087FE802780208000007F8000807F8040007F80000
+AD91:000800083F080108010801087FE80278020800003EF802083E0820083E080000
+AD92:000800083F080108010801087FE80278020800003EF802883E8820883EF80000
+AD93:000800083F080108010801087FE80278020800003E8802883EF820883EF80000
+AD94:000800083F080108010801087FE80278020800000F8800880F8808140FA20000
+AD95:000800083F080108010801087FE80278020800003EF802803EF820803EF80000
+AD96:000800083F080108010801087FE80278020800003EFC02483E4820483EFC0000
+AD97:000800083F080108010801087FE80278020800003E1002FE3E3820443E380000
+AD98:000800083F080108010801087FE802780208000003F802080208020803F80000
+AD99:000800083F080108010801087FE80278020800000208020803F8020803F80000
+AD9A:000800083F080108010801087FE8027802080000210821083F0821143F620000
+AD9B:000800083F080108010801087FE8027802080000001000100010006801840000
+AD9C:000800083F080108010801087FE80278020800000048004800A8011406620000
+AD9D:000800083F080108010801087FE8027802080000000003F00408040803F00000
+AD9E:000800083F080108010801087FE802780208000003F80020002000D003080000
+AD9F:000800083F080108010801087FE8027802080000004003F8004000A003180000
+ADA0:000800083F080108010801087FE802780208000003F8000803F8000800080000
+ADA1:000800083F080108010801087FE802780208000003F8020003F8020003F80000
+ADA2:000800083F080108010801087FE802780208000000000FF8022002200FF80000
+ADA3:000800083F080108010801087FE802780208000000800FF803E0041003E00000
+ADA4:0000000A000A000A3FEA002A002A002A002A000A7FEA040A047A040A040A0000
+ADA5:002800283F280128012801287FA805E804280000000007F80008000800080000
+ADA6:002800283F280128012801287FA805E80428000000003EF80208020802080000
+ADA7:002800283F280128012801287FA805E80428000000001F080108011401620000
+ADA8:002800283F2801280128012800287FA8042805E804281428100010001FF80000
+ADA9:002800283F280128012801287FA805E804280000000020F8201020303ECC0000
+ADAA:002800283F280128012801287FA805E804280000202021FC207020883E700000
+ADAB:002800283F280128012801287FA805E80428000003F802000200020003F80000
+ADAC:002800283F280128012801287FA805E80428000007F8000807F8040007F80000
+ADAD:002800283F280128012801287FA805E8042800003EF802083E0820083E080000
+ADAE:002800283F280128012801287FA805E8042800003EF802883E8820883EF80000
+ADAF:002800283F280128012801287FA805E8042800003E8802883EF820883EF80000
+ADB0:002800283F280128012801287FA805E8042800000F8800880F8808140FA20000
+ADB1:002800283F280128012801287FA805E8042800003EF802803EF820803EF80000
+ADB2:002800283F280128012801287FA805E8042800003EFC02483E4820483EFC0000
+ADB3:002800283F280128012801287FA805E8042800003E1002FE3E3820443E380000
+ADB4:002800283F280128012801287FA805E80428000003F802080208020803F80000
+ADB5:002800283F280128012801287FA805E8042800000208020803F8020803F80000
+ADB6:002800283F280128012801287FA805E804280000210821083F0821143F620000
+ADB7:002800283F280128012801287FA805E804280000001000100010006801840000
+ADB8:002800283F280128012801287FA805E8042800000048004800A8011406620000
+ADB9:002800283F280128012801287FA805E804280000000003F00408040803F00000
+ADBA:002800283F280128012801287FA805E80428000003F80020002000D003080000
+ADBB:002800283F280128012801287FA805E804280000004003F8004000A003180000
+ADBC:002800283F280128012801287FA805E80428000003F8000803F8000800080000
+ADBD:002800283F280128012801287FA805E80428000003F8020003F8020003F80000
+ADBE:002800283F280128012801287FA805E80428000000000FF8022002200FF80000
+ADBF:002800283F280128012801287FA805E80428000000800FF803E0041003E00000
+ADC0:00000008000800083FE8002800280028002800087FE804080408040804080000
+ADC1:000800083F080108010801087FE8020802000000000007F80008000800080000
+ADC2:000800083F080108010801087FE802080200000000003EF80208020802080000
+ADC3:000800083F080108010801087FE802080200000000001F080108011401620000
+ADC4:000800083F0801080108010800087FE80208020802081008100010001FF80000
+ADC5:000800083F080108010801087FE8020802000000000020F8201020303ECC0000
+ADC6:000800083F080108010801087FE8020802000000202021FC207020883E700000
+ADC7:000800083F080108010801087FE802080200000003F802000200020003F80000
+ADC8:000800083F080108010801087FE802080200000007F8000807F8040007F80000
+ADC9:000800083F080108010801087FE80208020000003EF802083E0820083E080000
+ADCA:000800083F080108010801087FE80208020000003EF802883E8820883EF80000
+ADCB:000800083F080108010801087FE80208020000003E8802883EF820883EF80000
+ADCC:000800083F080108010801087FE80208020000000F8800880F8808140FA20000
+ADCD:000800083F080108010801087FE80208020000003EF802803EF820803EF80000
+ADCE:000800083F080108010801087FE80208020000003EFC02483E4820483EFC0000
+ADCF:000800083F080108010801087FE80208020000003E1002FE3E3820443E380000
+ADD0:000800083F080108010801087FE802080200000003F802080208020803F80000
+ADD1:000800083F080108010801087FE80208020000000208020803F8020803F80000
+ADD2:000800083F080108010801087FE8020802000000210821083F0821143F620000
+ADD3:000800083F080108010801087FE8020802000000001000100010006801840000
+ADD4:000800083F080108010801087FE80208020000000048004800A8011406620000
+ADD5:000800083F080108010801087FE8020802000000000003F00408040803F00000
+ADD6:000800083F080108010801087FE802080200000003F80020002000D003080000
+ADD7:000800083F080108010801087FE8020802000000004003F8004000A003180000
+ADD8:000800083F080108010801087FE802080200000003F8000803F8000800080000
+ADD9:000800083F080108010801087FE802080200000003F8020003F8020003F80000
+ADDA:000800083F080108010801087FE802080200000000000FF8022002200FF80000
+ADDB:000800083F080108010801087FE802080200000000800FF803E0041003E00000
+ADDC:0000000000003FE00020002000200020002000007FFC04400440044004400000
+ADDD:000000001FF000100010001000007FFC044004401FF000100010001000100000
+ADDE:000000001FF000100010001000007FFC0440044000003EF80208020802080000
+ADDF:000000001FF000100010001000007FFC0440044000001E100210022802C40000
+ADE0:000000001FF0001000100010000000007FFC044004401440100010001FF00000
+ADE1:000000001FF000100010001000007FFC04400440000020F8201020303ECC0000
+ADE2:000000001FF000100010001000007FFC04400440202021FC207020883E700000
+ADE3:000000001FF000100010001000007FFC044004401FF01000100010001FF00000
+ADE4:000000001FF000100010001000007FFC044004401FF000101FF010001FF00000
+ADE5:000000001FF000100010001000007FFC044004403EF802083E0820083E080000
+ADE6:000000001FF000100010001000007FFC044004403EF802883E8820883EF80000
+ADE7:000000001FF000100010001000007FFC044004403E8802883EF820883EF80000
+ADE8:000000001FF000100010001000007FFC044004403E1002103E1020283EC40000
+ADE9:000000001FF000100010001000007FFC044004403EF802803EF820803EF80000
+ADEA:000000001FF000100010001000007FFC044004403EFC02483E4820483EFC0000
+ADEB:000000001FF000100010001000007FFC044004403E2003FC3E7020883E700000
+ADEC:000000001FF000100010001000007FFC044004401FF01010101010101FF00000
+ADED:000000001FF000100010001000007FFC04400440101010101FF010101FF00000
+ADEE:000000001FF000100010001000007FFC04400440222022203E2022503E880000
+ADEF:000000001FF000100010001000007FFC0440044000000100010002800C400000
+ADF0:000000001FF000100010001000007FFC044004400000024002400DA033100000
+ADF1:000000001FF000100010001000007FFC04400440000007C00820082007C00000
+ADF2:000000001FF000100010001000007FFC04400440000007E00080014006200000
+ADF3:000000001FF000100010001000007FFC04400440008007E00080014006200000
+ADF4:000000001FF000100010001000007FFC044004401FF000101FF0001000100000
+ADF5:000000001FF000100010001000007FFC044004401FF010001FF010001FF00000
+ADF6:000000001FF000100010001000007FFC0440044000001FF0044004401FF00000
+ADF7:000000001FF000100010001000007FFC0440044001001FF007C0082007C00000
+ADF8:00000000000000003FF00010001000100010001000007FFC0000000000000000
+ADF9:000000001FF0001000100010001000007FFC00001FF000100010001000100000
+ADFA:000000001FF0001000100010001000007FFC000000003EF80208020802080000
+ADFB:000000001FF0001000100010001000007FFC000000001E100210022802C40000
+ADFC:000000001FF0001000100010001000007FFC000000001000100010001FF00000
+ADFD:000000001FF0001000100010001000007FFC0000000020F8201020303ECC0000
+ADFE:000000001FF0001000100010001000007FFC0000202021FC207020883E700000
+ADFF:000000001FF0001000100010001000007FFC00001FF01000100010001FF00000
+AE00:000000001FF0001000100010001000007FFC00001FF000101FF010001FF00000
+AE01:000000001FF0001000100010001000007FFC00003EF802083E0820083E080000
+AE02:000000001FF0001000100010001000007FFC00003EF802883E8820883EF80000
+AE03:000000001FF0001000100010001000007FFC00003E8802883EF820883EF80000
+AE04:000000001FF0001000100010001000007FFC00003E1002103E1020283EC40000
+AE05:000000001FF0001000100010001000007FFC00003EF802803EF820803EF80000
+AE06:000000001FF0001000100010001000007FFC00003EFC02483E4820483EFC0000
+AE07:000000001FF0001000100010001000007FFC00003E2003FC3E7020883E700000
+AE08:000000001FF0001000100010001000007FFC00001FF01010101010101FF00000
+AE09:000000001FF0001000100010001000007FFC0000101010101FF010101FF00000
+AE0A:000000001FF0001000100010001000007FFC0000222022203E2022503E880000
+AE0B:000000001FF0001000100010001000007FFC000000000100010002800C400000
+AE0C:000000001FF0001000100010001000007FFC00000000024002400DA033100000
+AE0D:000000001FF0001000100010001000007FFC0000000007C00820082007C00000
+AE0E:000000001FF0001000100010001000007FFC0000000007E00080014006200000
+AE0F:000000001FF0001000100010001000007FFC0000008007E00080014006200000
+AE10:000000001FF0001000100010001000007FFC00001FF000101FF0001000100000
+AE11:000000001FF0001000100010001000007FFC00001FF010001FF010001FF00000
+AE12:000000001FF0001000100010001000007FFC000000001FF0044004401FF00000
+AE13:000000001FF0001000100010001000007FFC000001001FF007C0082007C00000
+AE14:00000000000800083FC80048004800480048000800087FE80008000800080000
+AE15:000000081F88008800880088008800087FE8000007F800080008000800080000
+AE16:000000081F88008800880088008800087FE8000000003EF80208020802080000
+AE17:000000081F88008800880088008800087FE8000000001F080108011401620000
+AE18:000000081F88008800880088008800087FE8000008000800080008000FF80000
+AE19:000000081F88008800880088008800087FE80000000010F8101010301ECC0000
+AE1A:000000081F88008800880088008800087FE800000808087F081C08220F9C0000
+AE1B:000000081F88008800880088008800087FE8000003F802000200020003F80000
+AE1C:000000081F88008800880088008800087FE8000007F8000807F8040007F80000
+AE1D:000000081F88008800880088008800087FE800003EF802083E0820083E080000
+AE1E:000000081F88008800880088008800087FE800003EF802883E8820883EF80000
+AE1F:000000081F88008800880088008800087FE800003E8802883EF820883EF80000
+AE20:000000081F88008800880088008800087FE800001F0801081F0810141F620000
+AE21:000000081F88008800880088008800087FE800003EF802803EF820803EF80000
+AE22:000000081F88008800880088008800087FE800003EFC02483E4820483EFC0000
+AE23:000000081F88008800880088008800087FE800001F08017F1F1C10221F1C0000
+AE24:000000081F88008800880088008800087FE8000003F802080208020803F80000
+AE25:000000081F88008800880088008800087FE800000208020803F8020803F80000
+AE26:000000081F88008800880088008800087FE80000110811081F0811141F620000
+AE27:000000081F88008800880088008800087FE80000001000100010006801840000
+AE28:000000081F88008800880088008800087FE800000048004800A8011406620000
+AE29:000000081F88008800880088008800087FE80000000003F00408040803F00000
+AE2A:000000081F88008800880088008800087FE8000003F80020002000D003080000
+AE2B:000000081F88008800880088008800087FE80000004003F8004000A003180000
+AE2C:000000081F88008800880088008800087FE8000003F8000803F8000800080000
+AE2D:000000081F88008800880088008800087FE8000003F8020003F8020003F80000
+AE2E:000000081F88008800880088008800087FE8000000000FF8022002200FF80000
+AE2F:000000081F88008800880088008800087FE8000000800FF803E0041003E00000
+AE30:00000000000800081F8800880088008801080108020804081808000800080000
+AE31:000000083E080208020804080808300800080000000007F80008000800080000
+AE32:000000083E08020802080408080830080008000000003EF80208020802080000
+AE33:000000083E08020802080408080830080008000000001F080108011401620000
+AE34:000000083E08020802080408080830080008000800001000100010001FF80000
+AE35:000000083E080208020804080808300800080000000020F8201020303ECC0000
+AE36:000000083E080208020804080808300800080000202021FC207020883E700000
+AE37:000000083E08020802080408080830080008000003F802000200020003F80000
+AE38:000000083E08020802080408080830080008000007F8000807F8040007F80000
+AE39:000000083E0802080208040808083008000800003EF802083E0820083E080000
+AE3A:000000083E0802080208040808083008000800003EF802883E8820883EF80000
+AE3B:000000083E0802080208040808083008000800003E8802883EF820883EF80000
+AE3C:000000083E0802080208040808083008000800000F8800880F8808140FA20000
+AE3D:000000083E0802080208040808083008000800003EF802803EF820803EF80000
+AE3E:000000083E0802080208040808083008000800003EFC02483E4820483EFC0000
+AE3F:000000083E0802080208040808083008000800003E1002FE3E3820443E380000
+AE40:000000083E08020802080408080830080008000003F802080208020803F80000
+AE41:000000083E0802080208040808083008000800000208020803F8020803F80000
+AE42:000000083E080208020804080808300800080000210821083F0821143F620000
+AE43:000000083E080208020804080808300800080000001000100010006801840000
+AE44:000000083E0802080208040808083008000800000048004800A8011406620000
+AE45:000000083E080208020804080808300800080000000003F00408040803F00000
+AE46:000000083E08020802080408080830080008000003F80020002000D003080000
+AE47:000000083E080208020804080808300800080000004003F8004000A003180000
+AE48:000000083E08020802080408080830080008000003F8000803F8000800080000
+AE49:000000083E08020802080408080830080008000003F8020003F8020003F80000
+AE4A:000000083E08020802080408080830080008000000000FF8022002200FF80000
+AE4B:000000083E08020802080408080830080008000000800FF803E0041003E00000
+AE4C:00000000001000107B9008900890089E11101110221044100810001000100000
+AE4D:00000008F78810881088108E2108C6080008000007F800080008000800080000
+AE4E:00000008F78810881088108E2108C6080008000000003EF80208020802080000
+AE4F:00000008F78810881088108E2108C6080008000000001F080108011401620000
+AE50:00000008F78810881088108E2108C6080008000808000800080008000FF80000
+AE51:00000008F78810881088108E2108C60800080000000010F8101010301ECC0000
+AE52:00000008F78810881088108E2108C608000800000808087F081C08220F9C0000
+AE53:00000008F78810881088108E2108C6080008000003F802000200020003F80000
+AE54:00000008F78810881088108E2108C6080008000007F8000807F8040007F80000
+AE55:00000008F78810881088108E2108C608000800003EF802083E0820083E080000
+AE56:00000008F78810881088108E2108C608000800003EF802883E8820883EF80000
+AE57:00000008F78810881088108E2108C608000800003E8802883EF820883EF80000
+AE58:00000008F78810881088108E2108C608000800001F0801081F0810141F620000
+AE59:00000008F78810881088108E2108C608000800003EF802803EF820803EF80000
+AE5A:00000008F78810881088108E2108C608000800003EFC02483E4820483EFC0000
+AE5B:00000008F78810881088108E2108C608000800001F08017F1F1C10221F1C0000
+AE5C:00000008F78810881088108E2108C6080008000003F802080208020803F80000
+AE5D:00000008F78810881088108E2108C608000800000208020803F8020803F80000
+AE5E:00000008F78810881088108E2108C60800080000110811081F0811141F620000
+AE5F:00000008F78810881088108E2108C60800080000001000100010006801840000
+AE60:00000008F78810881088108E2108C608000800000048004800A8011406620000
+AE61:00000008F78810881088108E2108C60800080000000003F00408040803F00000
+AE62:00000008F78810881088108E2108C6080008000003F80020002000D003080000
+AE63:00000008F78810881088108E2108C60800080000004003F8004000A003180000
+AE64:00000008F78810881088108E2108C6080008000003F8000803F8000800080000
+AE65:00000008F78810881088108E2108C6080008000003F8020003F8020003F80000
+AE66:00000008F78810881088108E2108C6080008000000000FF8022002200FF80000
+AE67:00000008F78810881088108E2108C6080008000000800FF803E0041003E00000
+AE68:00000000001200127B9208920892089E11121112221244120812001200120000
+AE69:00000028F7A810A810A810B82128C6280028000007F800080008000800080000
+AE6A:00000028F7A810A810A810B82128C6280028000000003EF80208020802080000
+AE6B:00000028F7A810A810A810B82128C6280028000000003E100210022802C40000
+AE6C:00000028F7A810A810A810B82128C6280028002808000800080008000FF80000
+AE6D:00000028F7A810A810A810B82128C62800280000000020F8201020303ECC0000
+AE6E:00000028F7A810A810A810B82128C62800280000202021FC207020883E700000
+AE6F:00000028F7A810A810A810B82128C6280028000003F802000200020003F80000
+AE70:00000028F7A810A810A810B82128C6280028000007F8000807F8040007F80000
+AE71:00000028F7A810A810A810B82128C628002800003EF802083E0820083E080000
+AE72:00000028F7A810A810A810B82128C628002800003EF802883E8820883EF80000
+AE73:00000028F7A810A810A810B82128C628002800003E8802883EF820883EF80000
+AE74:00000028F7A810A810A810B82128C628002800001F0801081F0810141F620000
+AE75:00000028F7A810A810A810B82128C628002800003EF802803EF820803EF80000
+AE76:00000028F7A810A810A810B82128C628002800003EFC02483E4820483EFC0000
+AE77:00000028F7A810A810A810B82128C628002800003E1002FE3E3820443E380000
+AE78:00000028F7A810A810A810B82128C6280028000003F802080208020803F80000
+AE79:00000028F7A810A810A810B82128C628002800000208020803F8020803F80000
+AE7A:00000028F7A810A810A810B82128C62800280000110811081F0811141F620000
+AE7B:00000028F7A810A810A810B82128C62800280000000800080008003400C20000
+AE7C:00000028F7A810A810A810B82128C628002800000048004800A8011406620000
+AE7D:00000028F7A810A810A810B82128C62800280000000001F00208020801F00000
+AE7E:00000028F7A810A810A810B82128C6280028000003F80020002000D003080000
+AE7F:00000028F7A810A810A810B82128C62800280000004003F8004000A003180000
+AE80:00000028F7A810A810A810B82128C6280028000003F8000803F8000800080000
+AE81:00000028F7A810A810A810B82128C6280028000003F8020003F8020003F80000
+AE82:00000028F7A810A810A810B82128C6280028000000000FF8022002200FF80000
+AE83:00000028F7A810A810A810B82128C6280028000000800FF803E0041003E00000
+AE84:00000000001000107B900890089E08901110111E221044100810001000100000
+AE85:00000008F7881088108E1088210EC6080008000007F800080008000800080000
+AE86:00000008F7881088108E1088210EC6080008000000003EF80208020802080000
+AE87:00000008F7881088108E1088210EC6080008000000001F080108011401620000
+AE88:00000008F7881088108E1088210EC6080008000008000800080008000FF80000
+AE89:00000008F7881088108E1088210EC60800080000000010F8101010301ECC0000
+AE8A:00000008F7881088108E1088210EC608000800000808087F081C08220F9C0000
+AE8B:00000008F7881088108E1088210EC6080008000003F802000200020003F80000
+AE8C:00000008F7881088108E1088210EC6080008000007F8000807F8040007F80000
+AE8D:00000008F7881088108E1088210EC608000800003EF802083E0820083E080000
+AE8E:00000008F7881088108E1088210EC608000800003EF802883E8820883EF80000
+AE8F:00000008F7881088108E1088210EC608000800003E8802883EF820883EF80000
+AE90:00000008F7881088108E1088210EC608000800001F0801081F0810141F620000
+AE91:00000008F7881088108E1088210EC608000800003EF802803EF820803EF80000
+AE92:00000008F7881088108E1088210EC608000800003EFC02483E4820483EFC0000
+AE93:00000008F7881088108E1088210EC608000800001F08017F1F1C10221F1C0000
+AE94:00000008F7881088108E1088210EC6080008000003F802080208020803F80000
+AE95:00000008F7881088108E1088210EC608000800000208020803F8020803F80000
+AE96:00000008F7881088108E1088210EC60800080000110811081F0811141F620000
+AE97:00000008F7881088108E1088210EC60800080000001000100010006801840000
+AE98:00000008F7881088108E1088210EC608000800000048004800A8011406620000
+AE99:00000008F7881088108E1088210EC60800080000000003F00408040803F00000
+AE9A:00000008F7881088108E1088210EC6080008000003F80020002000D003080000
+AE9B:00000008F7881088108E1088210EC60800080000004003F8004000A003180000
+AE9C:00000008F7881088108E1088210EC6080008000003F8000803F8000800080000
+AE9D:00000008F7881088108E1088210EC6080008000003F8020003F8020003F80000
+AE9E:00000008F7881088108E1088210EC6080008000000000FF8022002200FF80000
+AE9F:00000008F7881088108E1088210EC6080008000000800FF803E0041003E00000
+AEA0:00000000001200127B920892089E08921112111E221244120812001200120000
+AEA1:00000028F7A810A810B810A82138C6280028000007F800080008000800080000
+AEA2:00000028F7A810A810B810A82138C6280028000000003EF80208020802080000
+AEA3:00000028F7A810A810B810A82138C6280028000000003E100210022802C40000
+AEA4:00000028F7A810A810B810A82138C6280028002808000800080008000FF80000
+AEA5:00000028F7A810A810B810A82138C62800280000000020F8201020303ECC0000
+AEA6:00000028F7A810A810B810A82138C62800280000202021FC207020883E700000
+AEA7:00000028F7A810A810B810A82138C6280028000003F802000200020003F80000
+AEA8:00000028F7A810A810B810A82138C6280028000007F8000807F8040007F80000
+AEA9:00000028F7A810A810B810A82138C628002800003EF802083E0820083E080000
+AEAA:00000028F7A810A810B810A82138C628002800003EF802883E8820883EF80000
+AEAB:00000028F7A810A810B810A82138C628002800003E8802883EF820883EF80000
+AEAC:00000028F7A810A810B810A82138C628002800001F0801081F0810141F620000
+AEAD:00000028F7A810A810B810A82138C628002800003EF802803EF820803EF80000
+AEAE:00000028F7A810A810B810A82138C628002800003EFC02483E4820483EFC0000
+AEAF:00000028F7A810A810B810A82138C628002800003E1002FE3E3820443E380000
+AEB0:00000028F7A810A810B810A82138C6280028000003F802080208020803F80000
+AEB1:00000028F7A810A810B810A82138C628002800000208020803F8020803F80000
+AEB2:00000028F7A810A810B810A82138C62800280000110811081F0811141F620000
+AEB3:00000028F7A810A810B810A82138C62800280000000800080008003400C20000
+AEB4:00000028F7A810A810B810A82138C628002800000048004800A8011406620000
+AEB5:00000028F7A810A810B810A82138C62800280000000001F00208020801F00000
+AEB6:00000028F7A810A810B810A82138C6280028000003F80020002000D003080000
+AEB7:00000028F7A810A810B810A82138C62800280000004003F8004000A003180000
+AEB8:00000028F7A810A810B810A82138C6280028000003F8000803F8000800080000
+AEB9:00000028F7A810A810B810A82138C6280028000003F8020003F8020003F80000
+AEBA:00000028F7A810A810B810A82138C6280028000000000FF8022002200FF80000
+AEBB:00000028F7A810A810B810A82138C6280028000000800FF803E0041003E00000
+AEBC:00000000000200027B8208820882089E11021102220244020802000200020000
+AEBD:00000008F7881088108810B82108C60800080000000007F80008000800080000
+AEBE:00000008F7881088108810B82108C6080008000000003EF80208020802080000
+AEBF:00000008F7881088108810B82108C6080008000000001F080108011401620000
+AEC0:00000008F7881088108810B82108C6080008000000001000100010001FF80000
+AEC1:00000008F7881088108810B82108C60800080000000020F8201020303ECC0000
+AEC2:00000008F7881088108810B82108C60800080000202021FC207020883E700000
+AEC3:00000008F7881088108810B82108C6080008000003F802000200020003F80000
+AEC4:00000008F7881088108810B82108C6080008000007F8000807F8040007F80000
+AEC5:00000008F7881088108810B82108C608000800003EF802083E0820083E080000
+AEC6:00000008F7881088108810B82108C608000800003EF802883E8820883EF80000
+AEC7:00000008F7881088108810B82108C608000800003E8802883EF820883EF80000
+AEC8:00000008F7881088108810B82108C608000800000F8800880F8808140FA20000
+AEC9:00000008F7881088108810B82108C608000800003EF802803EF820803EF80000
+AECA:00000008F7881088108810B82108C608000800003EFC02483E4820483EFC0000
+AECB:00000008F7881088108810B82108C608000800003E1002FE3E3820443E380000
+AECC:00000008F7881088108810B82108C6080008000003F802080208020803F80000
+AECD:00000008F7881088108810B82108C608000800000208020803F8020803F80000
+AECE:00000008F7881088108810B82108C60800080000210821083F0821143F620000
+AECF:00000008F7881088108810B82108C60800080000001000100010006801840000
+AED0:00000008F7881088108810B82108C608000800000048004800A8011406620000
+AED1:00000008F7881088108810B82108C60800080000000003F00408040803F00000
+AED2:00000008F7881088108810B82108C6080008000003F80020002000D003080000
+AED3:00000008F7881088108810B82108C60800080000004003F8004000A003180000
+AED4:00000008F7881088108810B82108C6080008000003F8000803F8000800080000
+AED5:00000008F7881088108810B82108C6080008000003F8020003F8020003F80000
+AED6:00000008F7881088108810B82108C6080008000000000FF8022002200FF80000
+AED7:00000008F7881088108810B82108C6080008000000800FF803E0041003E00000
+AED8:00000000000A000A7B8A088A088A08BA110A110A220A440A080A000A000A0000
+AED9:00000028F7A810A810A810E82128C6280028000007F800080008000800080000
+AEDA:00000028F7A810A810A810E82128C6280028000000003EF80208020802080000
+AEDB:00000028F7A810A810A810E82128C6280028000000003E100210022802C40000
+AEDC:00000028F7A810A810A810E82128C6280028000008000800080008000FF80000
+AEDD:00000028F7A810A810A810E82128C62800280000000020F8201020303ECC0000
+AEDE:00000028F7A810A810A810E82128C62800280000202021FC207020883E700000
+AEDF:00000028F7A810A810A810E82128C6280028000003F802000200020003F80000
+AEE0:00000028F7A810A810A810E82128C6280028000007F8000807F8040007F80000
+AEE1:00000028F7A810A810A810E82128C628002800003EF802083E0820083E080000
+AEE2:00000028F7A810A810A810E82128C628002800003EF802883E8820883EF80000
+AEE3:00000028F7A810A810A810E82128C628002800003E8802883EF820883EF80000
+AEE4:00000028F7A810A810A810E82128C628002800001F0801081F0810141F620000
+AEE5:00000028F7A810A810A810E82128C628002800003EF802803EF820803EF80000
+AEE6:00000028F7A810A810A810E82128C628002800003EFC02483E4820483EFC0000
+AEE7:00000028F7A810A810A810E82128C628002800003E1002FE3E3820443E380000
+AEE8:00000028F7A810A810A810E82128C6280028000003F802080208020803F80000
+AEE9:00000028F7A810A810A810E82128C628002800000208020803F8020803F80000
+AEEA:00000028F7A810A810A810E82128C62800280000110811081F0811141F620000
+AEEB:00000028F7A810A810A810E82128C62800280000000800080008003400C20000
+AEEC:00000028F7A810A810A810E82128C628002800000048004800A8011406620000
+AEED:00000028F7A810A810A810E82128C62800280000000001F00208020801F00000
+AEEE:00000028F7A810A810A810E82128C6280028000003F80020002000D003080000
+AEEF:00000028F7A810A810A810E82128C62800280000004003F8004000A003180000
+AEF0:00000028F7A810A810A810E82128C6280028000003F8000803F8000800080000
+AEF1:00000028F7A810A810A810E82128C6280028000003F8020003F8020003F80000
+AEF2:00000028F7A810A810A810E82128C6280028000000000FF8022002200FF80000
+AEF3:00000028F7A810A810A810E82128C6280028000000800FF803E0041003E00000
+AEF4:00000000000200027B820882089E08821102111E220244020802000200020000
+AEF5:00000008F788108810B810882138C60800080000000007F80008000800080000
+AEF6:00000008F788108810B810882138C6080008000000003EF80208020802080000
+AEF7:00000008F788108810B810882138C6080008000000001F080108011401620000
+AEF8:00000008F788108810B810882138C6080008000800001000100010001FF80000
+AEF9:00000008F788108810B810882138C60800080000000020F8201020303ECC0000
+AEFA:00000008F788108810B810882138C60800080000202021FC207020883E700000
+AEFB:00000008F788108810B810882138C6080008000003F802000200020003F80000
+AEFC:00000008F788108810B810882138C6080008000007F8000807F8040007F80000
+AEFD:00000008F788108810B810882138C608000800003EF802083E0820083E080000
+AEFE:00000008F788108810B810882138C608000800003EF802883E8820883EF80000
+AEFF:00000008F788108810B810882138C608000800003E8802883EF820883EF80000
+AF00:00000008F788108810B810882138C608000800000F8800880F8808140FA20000
+AF01:00000008F788108810B810882138C608000800003EF802803EF820803EF80000
+AF02:00000008F788108810B810882138C608000800003EFC02483E4820483EFC0000
+AF03:00000008F788108810B810882138C608000800003E1002FE3E3820443E380000
+AF04:00000008F788108810B810882138C6080008000003F802080208020803F80000
+AF05:00000008F788108810B810882138C608000800000208020803F8020803F80000
+AF06:00000008F788108810B810882138C60800080000210821083F0821143F620000
+AF07:00000008F788108810B810882138C60800080000001000100010006801840000
+AF08:00000008F788108810B810882138C608000800000048004800A8011406620000
+AF09:00000008F788108810B810882138C60800080000000003F00408040803F00000
+AF0A:00000008F788108810B810882138C6080008000003F80020002000D003080000
+AF0B:00000008F788108810B810882138C60800080000004003F8004000A003180000
+AF0C:00000008F788108810B810882138C6080008000003F8000803F8000800080000
+AF0D:00000008F788108810B810882138C6080008000003F8020003F8020003F80000
+AF0E:00000008F788108810B810882138C6080008000000000FF8022002200FF80000
+AF0F:00000008F788108810B810882138C6080008000000800FF803E0041003E00000
+AF10:00000000000A000A7B8A088A08BA088A110A113A220A440A080A000A000A0000
+AF11:00000028F7A810A810E810A821E8C6280028000007F800080008000800080000
+AF12:00000028F7A810A810E810A821E8C6280028000000003EF80208020802080000
+AF13:00000028F7A810A810E810A821E8C6280028000000003E100210022802C40000
+AF14:00000028F7A810A810E810A821E8C6280028002808000800080008000FF80000
+AF15:00000028F7A810A810E810A821E8C62800280000000020F8201020303ECC0000
+AF16:00000028F7A810A810E810A821E8C62800280000202021FC207020883E700000
+AF17:00000028F7A810A810E810A821E8C6280028000003F802000200020003F80000
+AF18:00000028F7A810A810E810A821E8C6280028000007F8000807F8040007F80000
+AF19:00000028F7A810A810E810A821E8C628002800003EF802083E0820083E080000
+AF1A:00000028F7A810A810E810A821E8C628002800003EF802883E8820883EF80000
+AF1B:00000028F7A810A810E810A821E8C628002800003E8802883EF820883EF80000
+AF1C:00000028F7A810A810E810A821E8C628002800001F0801081F0810141F620000
+AF1D:00000028F7A810A810E810A821E8C628002800003EF802803EF820803EF80000
+AF1E:00000028F7A810A810E810A821E8C628002800003EFC02483E4820483EFC0000
+AF1F:00000028F7A810A810E810A821E8C628002800003E1002FE3E3820443E380000
+AF20:00000028F7A810A810E810A821E8C6280028000003F802080208020803F80000
+AF21:00000028F7A810A810E810A821E8C628002800000208020803F8020803F80000
+AF22:00000028F7A810A810E810A821E8C62800280000110811081F0811141F620000
+AF23:00000028F7A810A810E810A821E8C62800280000000800080008003400C20000
+AF24:00000028F7A810A810E810A821E8C628002800000048004800A8011406620000
+AF25:00000028F7A810A810E810A821E8C62800280000000001F00208020801F00000
+AF26:00000028F7A810A810E810A821E8C6280028000003F80020002000D003080000
+AF27:00000028F7A810A810E810A821E8C62800280000004003F8004000A003180000
+AF28:00000028F7A810A810E810A821E8C6280028000003F8000803F8000800080000
+AF29:00000028F7A810A810E810A821E8C6280028000003F8020003F8020003F80000
+AF2A:00000028F7A810A810E810A821E8C6280028000000000FF8022002200FF80000
+AF2B:00000028F7A810A810E810A821E8C6280028000000800FF803E0041003E00000
+AF2C:00000000000000003EF8020802080208020800000100010001007FFC00000000
+AF2D:000000003EF8020802080208010001007FFC00001FF000100010001000100000
+AF2E:000000003EF8020802080208010001007FFC000000003EF80208020802080000
+AF2F:000000003EF8020802080208010001007FFC000000001E100210022802C40000
+AF30:000000003EF8020802080208010001007FFC000000001000100010001FF00000
+AF31:000000003EF8020802080208010001007FFC0000000020F8201020303ECC0000
+AF32:000000003EF8020802080208010001007FFC0000202021FC207020883E700000
+AF33:000000003EF8020802080208010001007FFC00001FF01000100010001FF00000
+AF34:000000003EF8020802080208010001007FFC00001FF000101FF010001FF00000
+AF35:000000003EF8020802080208010001007FFC00003EF802083E0820083E080000
+AF36:000000003EF8020802080208010001007FFC00003EF802883E8820883EF80000
+AF37:000000003EF8020802080208010001007FFC00003E8802883EF820883EF80000
+AF38:000000003EF8020802080208010001007FFC00003E1002103E1020283EC40000
+AF39:000000003EF8020802080208010001007FFC00003EF802803EF820803EF80000
+AF3A:000000003EF8020802080208010001007FFC00003EFC02483E4820483EFC0000
+AF3B:000000003EF8020802080208010001007FFC00003E2003FC3E7020883E700000
+AF3C:000000003EF8020802080208010001007FFC00001FF01010101010101FF00000
+AF3D:000000003EF8020802080208010001007FFC0000101010101FF010101FF00000
+AF3E:000000003EF8020802080208010001007FFC0000222022203E2022503E880000
+AF3F:000000003EF8020802080208010001007FFC000000000100010002800C400000
+AF40:000000003EF8020802080208010001007FFC00000000024002400DA033100000
+AF41:000000003EF8020802080208010001007FFC0000000007C00820082007C00000
+AF42:000000003EF8020802080208010001007FFC0000000007E00080014006200000
+AF43:000000003EF8020802080208010001007FFC0000008007E00080014006200000
+AF44:000000003EF8020802080208010001007FFC00001FF000101FF0001000100000
+AF45:000000003EF8020802080208010001007FFC00001FF010001FF010001FF00000
+AF46:000000003EF8020802080208010001007FFC000000001FF0044004401FF00000
+AF47:000000003EF8020802080208010001007FFC000001001FF007C0082007C00000
+AF48:00000010001000107BD008500850085E08500010041004107FD0001000100000
+AF49:00000008F7881088108E1088148804087FE8000007F800080008000800080000
+AF4A:00000008F7881088108E1088148804087FE8000000003EF80208020802080000
+AF4B:00000008F7881088108E1088148804087FE8000000001F080108011401620000
+AF4C:00000008F7881088108E1088148804087FE8000008000800080008000FF80000
+AF4D:00000008F7881088108E1088148804087FE80000000010F8101010301ECC0000
+AF4E:00000008F7881088108E1088148804087FE800000808087F081C08220F9C0000
+AF4F:00000008F7881088108E1088148804087FE8000003F802000200020003F80000
+AF50:00000008F7881088108E1088148804087FE8000007F8000807F8040007F80000
+AF51:00000008F7881088108E1088148804087FE800003EF802083E0820083E080000
+AF52:00000008F7881088108E1088148804087FE800003EF802883E8820883EF80000
+AF53:00000008F7881088108E1088148804087FE800003E8802883EF820883EF80000
+AF54:00000008F7881088108E1088148804087FE800001F0801081F0810141F620000
+AF55:00000008F7881088108E1088148804087FE800003EF802803EF820803EF80000
+AF56:00000008F7881088108E1088148804087FE800003EFC02483E4820483EFC0000
+AF57:00000008F7881088108E1088148804087FE800001F08017F1F1C10221F1C0000
+AF58:00000008F7881088108E1088148804087FE8000003F802080208020803F80000
+AF59:00000008F7881088108E1088148804087FE800000208020803F8020803F80000
+AF5A:00000008F7881088108E1088148804087FE80000110811081F0811141F620000
+AF5B:00000008F7881088108E1088148804087FE80000001000100010006801840000
+AF5C:00000008F7881088108E1088148804087FE800000048004800A8011406620000
+AF5D:00000008F7881088108E1088148804087FE80000000003F00408040803F00000
+AF5E:00000008F7881088108E1088148804087FE8000003F80020002000D003080000
+AF5F:00000008F7881088108E1088148804087FE80000004003F8004000A003180000
+AF60:00000008F7881088108E1088148804087FE8000003F8000803F8000800080000
+AF61:00000008F7881088108E1088148804087FE8000003F8020003F8020003F80000
+AF62:00000008F7881088108E1088148804087FE8000000000FF8022002200FF80000
+AF63:00000008F7881088108E1088148804087FE8000000800FF803E0041003E00000
+AF64:00000012001200127BD208520852085E08520012041204127FD2001200120000
+AF65:00000028F7A810A810B810A814A804287FA8000007F800080008000800080000
+AF66:00000028F7A810A810B810A814A804287FA8000000003EF80208020802080000
+AF67:00000028F7A810A810B810A814A804287FA8000000001F080108011401620000
+AF68:00000028F7A810A810B810A814A804287FA8000008000800080008000FF80000
+AF69:00000028F7A810A810B810A814A804287FA80000000010F8101010301ECC0000
+AF6A:00000028F7A810A810B810A814A804287FA800000808087F081C08220F9C0000
+AF6B:00000028F7A810A810B810A814A804287FA8000003F802000200020003F80000
+AF6C:00000028F7A810A810B810A814A804287FA8000007F8000807F8040007F80000
+AF6D:00000028F7A810A810B810A814A804287FA800003EF802083E0820083E080000
+AF6E:00000028F7A810A810B810A814A804287FA800003EF802883E8820883EF80000
+AF6F:00000028F7A810A810B810A814A804287FA800003E8802883EF820883EF80000
+AF70:00000028F7A810A810B810A814A804287FA800001F0801081F0810141F620000
+AF71:00000028F7A810A810B810A814A804287FA800003EF802803EF820803EF80000
+AF72:00000028F7A810A810B810A814A804287FA800003EFC02483E4820483EFC0000
+AF73:00000028F7A810A810B810A814A804287FA800001F08017F1F1C10221F1C0000
+AF74:00000028F7A810A810B810A814A804287FA8000003F802080208020803F80000
+AF75:00000028F7A810A810B810A814A804287FA800000208020803F8020803F80000
+AF76:00000028F7A810A810B810A814A804287FA80000110811081F0811141F620000
+AF77:00000028F7A810A810B810A814A804287FA80000001000100010006801840000
+AF78:00000028F7A810A810B810A814A804287FA800000048004800A8011406620000
+AF79:00000028F7A810A810B810A814A804287FA80000000003F00408040803F00000
+AF7A:00000028F7A810A810B810A814A804287FA8000003F80020002000D003080000
+AF7B:00000028F7A810A810B810A814A804287FA80000004003F8004000A003180000
+AF7C:00000028F7A810A810B810A814A804287FA8000003F8000803F8000800080000
+AF7D:00000028F7A810A810B810A814A804287FA8000003F8020003F8020003F80000
+AF7E:00000028F7A810A810B810A814A804287FA8000000000FF8022002200FF80000
+AF7F:00000028F7A810A810B810A814A804287FA8000000800FF803E0041003E00000
+AF80:00000008000800087BC808480848084808480008040804087FE8000800080000
+AF81:00000008F788108810881088148804087FE8000007F800080008000800080000
+AF82:00000008F788108810881088148804087FE8000000003EF80208020802080000
+AF83:00000008F788108810881088148804087FE8000000001F080108011401620000
+AF84:00000008F788108810881088148804087FE8000008000800080008000FF80000
+AF85:00000008F788108810881088148804087FE80000000010F8101010301ECC0000
+AF86:00000008F788108810881088148804087FE800000808087F081C08220F9C0000
+AF87:00000008F788108810881088148804087FE8000003F802000200020003F80000
+AF88:00000008F788108810881088148804087FE8000007F8000807F8040007F80000
+AF89:00000008F788108810881088148804087FE800003EF802083E0820083E080000
+AF8A:00000008F788108810881088148804087FE800003EF802883E8820883EF80000
+AF8B:00000008F788108810881088148804087FE800003E8802883EF820883EF80000
+AF8C:00000008F788108810881088148804087FE800001F0801081F0810141F620000
+AF8D:00000008F788108810881088148804087FE800003EF802803EF820803EF80000
+AF8E:00000008F788108810881088148804087FE800003EFC02483E4820483EFC0000
+AF8F:00000008F788108810881088148804087FE800001F08017F1F1C10221F1C0000
+AF90:00000008F788108810881088148804087FE8000003F802080208020803F80000
+AF91:00000008F788108810881088148804087FE800000208020803F8020803F80000
+AF92:00000008F788108810881088148804087FE80000110811081F0811141F620000
+AF93:00000008F788108810881088148804087FE80000001000100010006801840000
+AF94:00000008F788108810881088148804087FE800000048004800A8011406620000
+AF95:00000008F788108810881088148804087FE80000000003F00408040803F00000
+AF96:00000008F788108810881088148804087FE8000003F80020002000D003080000
+AF97:00000008F788108810881088148804087FE80000004003F8004000A003180000
+AF98:00000008F788108810881088148804087FE8000003F8000803F8000800080000
+AF99:00000008F788108810881088148804087FE8000003F8020003F8020003F80000
+AF9A:00000008F788108810881088148804087FE8000000000FF8022002200FF80000
+AF9B:00000008F788108810881088148804087FE8000000800FF803E0041003E00000
+AF9C:00000000000000003EF8020802080208020804400440044004407FFC00000000
+AF9D:000000003EF8020802080208044004407FFC00001FF000100010001000100000
+AF9E:000000003EF8020802080208044004407FFC000000003EF80208020802080000
+AF9F:000000003EF8020802080208044004407FFC000000001E100210022802C40000
+AFA0:000000003EF8020802080208044004407FFC000000001000100010001FF00000
+AFA1:000000003EF8020802080208044004407FFC0000000020F8201020303ECC0000
+AFA2:000000003EF8020802080208044004407FFC0000202021FC207020883E700000
+AFA3:000000003EF8020802080208044004407FFC00001FF01000100010001FF00000
+AFA4:000000003EF8020802080208044004407FFC00001FF000101FF010001FF00000
+AFA5:000000003EF8020802080208044004407FFC00003EF802083E0820083E080000
+AFA6:000000003EF8020802080208044004407FFC00003EF802883E8820883EF80000
+AFA7:000000003EF8020802080208044004407FFC00003E8802883EF820883EF80000
+AFA8:000000003EF8020802080208044004407FFC00003E1002103E1020283EC40000
+AFA9:000000003EF8020802080208044004407FFC00003EF802803EF820803EF80000
+AFAA:000000003EF8020802080208044004407FFC00003EFC02483E4820483EFC0000
+AFAB:000000003EF8020802080208044004407FFC00003E2003FC3E7020883E700000
+AFAC:000000003EF8020802080208044004407FFC00001FF01010101010101FF00000
+AFAD:000000003EF8020802080208044004407FFC0000101010101FF010101FF00000
+AFAE:000000003EF8020802080208044004407FFC0000222022203E2022503E880000
+AFAF:000000003EF8020802080208044004407FFC000000000100010002800C400000
+AFB0:000000003EF8020802080208044004407FFC00000000024002400DA033100000
+AFB1:000000003EF8020802080208044004407FFC0000000007C00820082007C00000
+AFB2:000000003EF8020802080208044004407FFC0000000007E00080014006200000
+AFB3:000000003EF8020802080208044004407FFC0000008007E00080014006200000
+AFB4:000000003EF8020802080208044004407FFC00001FF000101FF0001000100000
+AFB5:000000003EF8020802080208044004407FFC00001FF010001FF010001FF00000
+AFB6:000000003EF8020802080208044004407FFC000000001FF0044004401FF00000
+AFB7:000000003EF8020802080208044004407FFC000001001FF007C0082007C00000
+AFB8:00000000000000007DF0041004100410041000003FF801000100010001000000
+AFB9:000000003EF802080208020800007FFC010001001FF000100010001000100000
+AFBA:000000003EF802080208020800007FFC0100010000003EF80208020802080000
+AFBB:000000003EF802080208020800007FFC0100010000001E100210022802C40000
+AFBC:000000003EF8020802080208000000007FFC010001001100100010001FF00000
+AFBD:000000003EF802080208020800007FFC01000100000020F8201020303ECC0000
+AFBE:000000003EF802080208020800007FFC01000100202021FC207020883E700000
+AFBF:000000003EF802080208020800007FFC010001001FF01000100010001FF00000
+AFC0:000000003EF802080208020800007FFC010001001FF000101FF010001FF00000
+AFC1:000000003EF802080208020800007FFC010001003EF802083E0820083E080000
+AFC2:000000003EF802080208020800007FFC010001003EF802883E8820883EF80000
+AFC3:000000003EF802080208020800007FFC010001003E8802883EF820883EF80000
+AFC4:000000003EF802080208020800007FFC010001003E1002103E1020283EC40000
+AFC5:000000003EF802080208020800007FFC010001003EF802803EF820803EF80000
+AFC6:000000003EF802080208020800007FFC010001003EFC02483E4820483EFC0000
+AFC7:000000003EF802080208020800007FFC010001003E2003FC3E7020883E700000
+AFC8:000000003EF802080208020800007FFC010001001FF01010101010101FF00000
+AFC9:000000003EF802080208020800007FFC01000100101010101FF010101FF00000
+AFCA:000000003EF802080208020800007FFC01000100222022203E2022503E880000
+AFCB:000000003EF802080208020800007FFC0100010000000100010002800C400000
+AFCC:000000003EF802080208020800007FFC010001000000024002400DA033100000
+AFCD:000000003EF802080208020800007FFC01000100000007C00820082007C00000
+AFCE:000000003EF802080208020800007FFC01000100000007E00080014006200000
+AFCF:000000003EF802080208020800007FFC01000100008007E00080014006200000
+AFD0:000000003EF802080208020800007FFC010001001FF000101FF0001000100000
+AFD1:000000003EF802080208020800007FFC010001001FF010001FF010001FF00000
+AFD2:000000003EF802080208020800007FFC0100010000001FF0044004401FF00000
+AFD3:000000003EF802080208020800007FFC0100010001001FF007C0082007C00000
+AFD4:00000008000800087BC8084808480848000800087FE8040804F8040804080000
+AFD5:00080008F7881088108810887FE8027802080000000007F80008000800080000
+AFD6:00080008F7881088108810887FE802780208000000003EF80208020802080000
+AFD7:00080008F7881088108810887FE802780208000000001F080108011401620000
+AFD8:00080008F78810881088108800087FE80278020802081000100010001FF80000
+AFD9:00080008F7881088108810887FE8027802080000000020F8201020303ECC0000
+AFDA:00080008F7881088108810887FE8027802080000202021FC207020883E700000
+AFDB:00080008F7881088108810887FE802780208000003F802000200020003F80000
+AFDC:00080008F7881088108810887FE802780208000007F8000807F8040007F80000
+AFDD:00080008F7881088108810887FE80278020800003EF802083E0820083E080000
+AFDE:00080008F7881088108810887FE80278020800003EF802883E8820883EF80000
+AFDF:00080008F7881088108810887FE80278020800003E8802883EF820883EF80000
+AFE0:00080008F7881088108810887FE80278020800000F8800880F8808140FA20000
+AFE1:00080008F7881088108810887FE80278020800003EF802803EF820803EF80000
+AFE2:00080008F7881088108810887FE80278020800003EFC02483E4820483EFC0000
+AFE3:00080008F7881088108810887FE80278020800003E1002FE3E3820443E380000
+AFE4:00080008F7881088108810887FE802780208000003F802080208020803F80000
+AFE5:00080008F7881088108810887FE80278020800000208020803F8020803F80000
+AFE6:00080008F7881088108810887FE8027802080000210821083F0821143F620000
+AFE7:00080008F7881088108810887FE8027802080000001000100010006801840000
+AFE8:00080008F7881088108810887FE80278020800000048004800A8011406620000
+AFE9:00080008F7881088108810887FE8027802080000000003F00408040803F00000
+AFEA:00080008F7881088108810887FE802780208000003F80020002000D003080000
+AFEB:00080008F7881088108810887FE8027802080000004003F8004000A003180000
+AFEC:00080008F7881088108810887FE802780208000003F8000803F8000800080000
+AFED:00080008F7881088108810887FE802780208000003F8020003F8020003F80000
+AFEE:00080008F7881088108810887FE802780208000000000FF8022002200FF80000
+AFEF:00080008F7881088108810887FE802780208000000800FF803E0041003E00000
+AFF0:0000000A000A000A7BCA084A084A084A000A000A7FEA040A047A040A040A0000
+AFF1:00280028F7A810A810A810A87FA805E804280000000007F80008000800080000
+AFF2:00280028F7A810A810A810A87FA805E80428000000003EF80208020802080000
+AFF3:00280028F7A810A810A810A87FA805E80428000000001F080108011401620000
+AFF4:00280028F7A810A810A810A800287FA8042805E804281428100010001FF80000
+AFF5:00280028F7A810A810A810A87FA805E804280000000020F8201020303ECC0000
+AFF6:00280028F7A810A810A810A87FA805E804280000202021FC207020883E700000
+AFF7:00280028F7A810A810A810A87FA805E80428000003F802000200020003F80000
+AFF8:00280028F7A810A810A810A87FA805E80428000007F8000807F8040007F80000
+AFF9:00280028F7A810A810A810A87FA805E8042800003EF802083E0820083E080000
+AFFA:00280028F7A810A810A810A87FA805E8042800003EF802883E8820883EF80000
+AFFB:00280028F7A810A810A810A87FA805E8042800003E8802883EF820883EF80000
+AFFC:00280028F7A810A810A810A87FA805E8042800000F8800880F8808140FA20000
+AFFD:00280028F7A810A810A810A87FA805E8042800003EF802803EF820803EF80000
+AFFE:00280028F7A810A810A810A87FA805E8042800003EFC02483E4820483EFC0000
+AFFF:00280028F7A810A810A810A87FA805E8042800003E1002FE3E3820443E380000
+B000:00280028F7A810A810A810A87FA805E80428000003F802080208020803F80000
+B001:00280028F7A810A810A810A87FA805E8042800000208020803F8020803F80000
+B002:00280028F7A810A810A810A87FA805E804280000210821083F0821143F620000
+B003:00280028F7A810A810A810A87FA805E804280000001000100010006801840000
+B004:00280028F7A810A810A810A87FA805E8042800000048004800A8011406620000
+B005:00280028F7A810A810A810A87FA805E804280000000003F00408040803F00000
+B006:00280028F7A810A810A810A87FA805E80428000003F80020002000D003080000
+B007:00280028F7A810A810A810A87FA805E804280000004003F8004000A003180000
+B008:00280028F7A810A810A810A87FA805E80428000003F8000803F8000800080000
+B009:00280028F7A810A810A810A87FA805E80428000003F8020003F8020003F80000
+B00A:00280028F7A810A810A810A87FA805E80428000000000FF8022002200FF80000
+B00B:00280028F7A810A810A810A87FA805E80428000000800FF803E0041003E00000
+B00C:00000008000800087BC8084808480848000800087FE804080408040804080000
+B00D:00080008F7881088108810887FE8020802000000000007F80008000800080000
+B00E:00080008F7881088108810887FE802080200000000003EF80208020802080000
+B00F:00080008F7881088108810887FE802080200000000001F080108011401620000
+B010:00080008F78810881088108800087FE80208020802081008100010001FF80000
+B011:00080008F7881088108810887FE8020802000000000020F8201020303ECC0000
+B012:00080008F7881088108810887FE8020802000000202021FC207020883E700000
+B013:00080008F7881088108810887FE802080200000003F802000200020003F80000
+B014:00080008F7881088108810887FE802080200000007F8000807F8040007F80000
+B015:00080008F7881088108810887FE80208020000003EF802083E0820083E080000
+B016:00080008F7881088108810887FE80208020000003EF802883E8820883EF80000
+B017:00080008F7881088108810887FE80208020000003E8802883EF820883EF80000
+B018:00080008F7881088108810887FE80208020000000F8800880F8808140FA20000
+B019:00080008F7881088108810887FE80208020000003EF802803EF820803EF80000
+B01A:00080008F7881088108810887FE80208020000003EFC02483E4820483EFC0000
+B01B:00080008F7881088108810887FE80208020000003E1002FE3E3820443E380000
+B01C:00080008F7881088108810887FE802080200000003F802080208020803F80000
+B01D:00080008F7881088108810887FE80208020000000208020803F8020803F80000
+B01E:00080008F7881088108810887FE8020802000000210821083F0821143F620000
+B01F:00080008F7881088108810887FE8020802000000001000100010006801840000
+B020:00080008F7881088108810887FE80208020000000048004800A8011406620000
+B021:00080008F7881088108810887FE8020802000000000003F00408040803F00000
+B022:00080008F7881088108810887FE802080200000003F80020002000D003080000
+B023:00080008F7881088108810887FE8020802000000004003F8004000A003180000
+B024:00080008F7881088108810887FE802080200000003F8000803F8000800080000
+B025:00080008F7881088108810887FE802080200000003F8020003F8020003F80000
+B026:00080008F7881088108810887FE802080200000000000FF8022002200FF80000
+B027:00080008F7881088108810887FE802080200000000800FF803E0041003E00000
+B028:00000000000000007DF0041004100410041000007FFC04400440044004400000
+B029:000000003EF802080208020800007FFC044004401FF000100010001000100000
+B02A:000000003EF802080208020800007FFC0440044000003EF80208020802080000
+B02B:000000003EF802080208020800007FFC0440044000001E100210022802C40000
+B02C:000000003EF8020802080208000000007FFC044004401440100010001FF00000
+B02D:000000003EF802080208020800007FFC04400440000020F8201020303ECC0000
+B02E:000000003EF802080208020800007FFC04400440202021FC207020883E700000
+B02F:000000003EF802080208020800007FFC044004401FF01000100010001FF00000
+B030:000000003EF802080208020800007FFC044004401FF000101FF010001FF00000
+B031:000000003EF802080208020800007FFC044004403EF802083E0820083E080000
+B032:000000003EF802080208020800007FFC044004403EF802883E8820883EF80000
+B033:000000003EF802080208020800007FFC044004403E8802883EF820883EF80000
+B034:000000003EF802080208020800007FFC044004403E1002103E1020283EC40000
+B035:000000003EF802080208020800007FFC044004403EF802803EF820803EF80000
+B036:000000003EF802080208020800007FFC044004403EFC02483E4820483EFC0000
+B037:000000003EF802080208020800007FFC044004403E2003FC3E7020883E700000
+B038:000000003EF802080208020800007FFC044004401FF01010101010101FF00000
+B039:000000003EF802080208020800007FFC04400440101010101FF010101FF00000
+B03A:000000003EF802080208020800007FFC04400440222022203E2022503E880000
+B03B:000000003EF802080208020800007FFC0440044000000100010002800C400000
+B03C:000000003EF802080208020800007FFC044004400000024002400DA033100000
+B03D:000000003EF802080208020800007FFC04400440000007C00820082007C00000
+B03E:000000003EF802080208020800007FFC04400440000007E00080014006200000
+B03F:000000003EF802080208020800007FFC04400440008007E00080014006200000
+B040:000000003EF802080208020800007FFC044004401FF000101FF0001000100000
+B041:000000003EF802080208020800007FFC044004401FF010001FF010001FF00000
+B042:000000003EF802080208020800007FFC0440044000001FF0044004401FF00000
+B043:000000003EF802080208020800007FFC0440044001001FF007C0082007C00000
+B044:00000000000000003EF80208020802080208000000007FFC0000000000000000
+B045:000000003EF8020802080208000000007FFC00001FF000100010001000100000
+B046:000000003EF8020802080208000000007FFC000000003EF80208020802080000
+B047:000000003EF8020802080208000000007FFC000000001E100210022802C40000
+B048:000000003EF8020802080208000000007FFC000000001000100010001FF00000
+B049:000000003EF8020802080208000000007FFC0000000020F8201020303ECC0000
+B04A:000000003EF8020802080208000000007FFC0000202021FC207020883E700000
+B04B:000000003EF8020802080208000000007FFC00001FF01000100010001FF00000
+B04C:000000003EF8020802080208000000007FFC00001FF000101FF010001FF00000
+B04D:000000003EF8020802080208000000007FFC00003EF802083E0820083E080000
+B04E:000000003EF8020802080208000000007FFC00003EF802883E8820883EF80000
+B04F:000000003EF8020802080208000000007FFC00003E8802883EF820883EF80000
+B050:000000003EF8020802080208000000007FFC00003E1002103E1020283EC40000
+B051:000000003EF8020802080208000000007FFC00003EF802803EF820803EF80000
+B052:000000003EF8020802080208000000007FFC00003EFC02483E4820483EFC0000
+B053:000000003EF8020802080208000000007FFC00003E2003FC3E7020883E700000
+B054:000000003EF8020802080208000000007FFC00001FF01010101010101FF00000
+B055:000000003EF8020802080208000000007FFC0000101010101FF010101FF00000
+B056:000000003EF8020802080208000000007FFC0000222022203E2022503E880000
+B057:000000003EF8020802080208000000007FFC000000000100010002800C400000
+B058:000000003EF8020802080208000000007FFC00000000024002400DA033100000
+B059:000000003EF8020802080208000000007FFC0000000007C00820082007C00000
+B05A:000000003EF8020802080208000000007FFC0000000007E00080014006200000
+B05B:000000003EF8020802080208000000007FFC0000008007E00080014006200000
+B05C:000000003EF8020802080208000000007FFC00001FF000101FF0001000100000
+B05D:000000003EF8020802080208000000007FFC00001FF010001FF010001FF00000
+B05E:000000003EF8020802080208000000007FFC000000001FF0044004401FF00000
+B05F:000000003EF8020802080208000000007FFC000001001FF007C0082007C00000
+B060:00000008000800087BC80848084808480848000800087FE80008000800080000
+B061:00000008F788108810881088108800087FE8000007F800080008000800080000
+B062:00000008F788108810881088108800087FE8000000003EF80208020802080000
+B063:00000008F788108810881088108800087FE8000000001F080108011401620000
+B064:00000008F788108810881088108800087FE8000008000800080008000FF80000
+B065:00000008F788108810881088108800087FE80000000010F8101010301ECC0000
+B066:00000008F788108810881088108800087FE800000808087F081C08220F9C0000
+B067:00000008F788108810881088108800087FE8000003F802000200020003F80000
+B068:00000008F788108810881088108800087FE8000007F8000807F8040007F80000
+B069:00000008F788108810881088108800087FE800003EF802083E0820083E080000
+B06A:00000008F788108810881088108800087FE800003EF802883E8820883EF80000
+B06B:00000008F788108810881088108800087FE800003E8802883EF820883EF80000
+B06C:00000008F788108810881088108800087FE800001F0801081F0810141F620000
+B06D:00000008F788108810881088108800087FE800003EF802803EF820803EF80000
+B06E:00000008F788108810881088108800087FE800003EFC02483E4820483EFC0000
+B06F:00000008F788108810881088108800087FE800001F08017F1F1C10221F1C0000
+B070:00000008F788108810881088108800087FE8000003F802080208020803F80000
+B071:00000008F788108810881088108800087FE800000208020803F8020803F80000
+B072:00000008F788108810881088108800087FE80000110811081F0811141F620000
+B073:00000008F788108810881088108800087FE80000001000100010006801840000
+B074:00000008F788108810881088108800087FE800000048004800A8011406620000
+B075:00000008F788108810881088108800087FE80000000003F00408040803F00000
+B076:00000008F788108810881088108800087FE8000003F80020002000D003080000
+B077:00000008F788108810881088108800087FE80000004003F8004000A003180000
+B078:00000008F788108810881088108800087FE8000003F8000803F8000800080000
+B079:00000008F788108810881088108800087FE8000003F8020003F8020003F80000
+B07A:00000008F788108810881088108800087FE8000000000FF8022002200FF80000
+B07B:00000008F788108810881088108800087FE8000000800FF803E0041003E00000
+B07C:00000000000800087B8808880888088811081108220844080808000800080000
+B07D:00000008F7881088108810882108C60800080000000007F80008000800080000
+B07E:00000008F7881088108810882108C6080008000000003EF80208020802080000
+B07F:00000008F7881088108810882108C6080008000000001F080108011401620000
+B080:00000008F7881088108810882108C6080008000800001000100010001FF80000
+B081:00000008F7881088108810882108C60800080000000020F8201020303ECC0000
+B082:00000008F7881088108810882108C60800080000202021FC207020883E700000
+B083:00000008F7881088108810882108C6080008000003F802000200020003F80000
+B084:00000008F7881088108810882108C6080008000007F8000807F8040007F80000
+B085:00000008F7881088108810882108C608000800003EF802083E0820083E080000
+B086:00000008F7881088108810882108C608000800003EF802883E8820883EF80000
+B087:00000008F7881088108810882108C608000800003E8802883EF820883EF80000
+B088:00000008F7881088108810882108C608000800000F8800880F8808140FA20000
+B089:00000008F7881088108810882108C608000800003EF802803EF820803EF80000
+B08A:00000008F7881088108810882108C608000800003EFC02483E4820483EFC0000
+B08B:00000008F7881088108810882108C608000800003E1002FE3E3820443E380000
+B08C:00000008F7881088108810882108C6080008000003F802080208020803F80000
+B08D:00000008F7881088108810882108C608000800000208020803F8020803F80000
+B08E:00000008F7881088108810882108C60800080000210821083F0821143F620000
+B08F:00000008F7881088108810882108C60800080000001000100010006801840000
+B090:00000008F7881088108810882108C608000800000048004800A8011406620000
+B091:00000008F7881088108810882108C60800080000000003F00408040803F00000
+B092:00000008F7881088108810882108C6080008000003F80020002000D003080000
+B093:00000008F7881088108810882108C60800080000004003F8004000A003180000
+B094:00000008F7881088108810882108C6080008000003F8000803F8000800080000
+B095:00000008F7881088108810882108C6080008000003F8020003F8020003F80000
+B096:00000008F7881088108810882108C6080008000000000FF8022002200FF80000
+B097:00000008F7881088108810882108C6080008000000800FF803E0041003E00000
+B098:0000000000100010001040104010401E4010401040107F900010001000100000
+B099:00000008000800084008400E400840087E08000007F800080008000800080000
+B09A:00000008000800084008400E400840087E08000000003EF80208020802080000
+B09B:00000008000800084008400E400840087E08000000001F080108011401620000
+B09C:00000008000800084008400E400840087E08000808000800080008000FF80000
+B09D:00000008000800084008400E400840087E080000000010F8101010301ECC0000
+B09E:00000008000800084008400E400840087E0800000808087F081C08220F9C0000
+B09F:00000008000800084008400E400840087E08000003F802000200020003F80000
+B0A0:00000008000800084008400E400840087E08000007F8000807F8040007F80000
+B0A1:00000008000800084008400E400840087E0800003EF802083E0820083E080000
+B0A2:00000008000800084008400E400840087E0800003EF802883E8820883EF80000
+B0A3:00000008000800084008400E400840087E0800003E8802883EF820883EF80000
+B0A4:00000008000800084008400E400840087E0800001F0801081F0810141F620000
+B0A5:00000008000800084008400E400840087E0800003EF802803EF820803EF80000
+B0A6:00000008000800084008400E400840087E0800003EFC02483E4820483EFC0000
+B0A7:00000008000800084008400E400840087E0800001F08017F1F1C10221F1C0000
+B0A8:00000008000800084008400E400840087E08000003F802080208020803F80000
+B0A9:00000008000800084008400E400840087E0800000208020803F8020803F80000
+B0AA:00000008000800084008400E400840087E080000110811081F0811141F620000
+B0AB:00000008000800084008400E400840087E080000001000100010006801840000
+B0AC:00000008000800084008400E400840087E0800000048004800A8011406620000
+B0AD:00000008000800084008400E400840087E080000000003F00408040803F00000
+B0AE:00000008000800084008400E400840087E08000003F80020002000D003080000
+B0AF:00000008000800084008400E400840087E080000004003F8004000A003180000
+B0B0:00000008000800084008400E400840087E08000003F8000803F8000800080000
+B0B1:00000008000800084008400E400840087E08000003F8020003F8020003F80000
+B0B2:00000008000800084008400E400840087E08000000000FF8022002200FF80000
+B0B3:00000008000800084008400E400840087E08000000800FF803E0041003E00000
+B0B4:0000000000120012001240124012401E4012401240127F920012001200120000
+B0B5:000000280028002840284038402840287E28000007F800080008000800080000
+B0B6:000000280028002840284038402840287E28000000003EF80208020802080000
+B0B7:000000280028002840284038402840287E28000000003E100210022802C40000
+B0B8:000000280028002840284038402840287E28002808000800080008000FF80000
+B0B9:000000280028002840284038402840287E280000000020F8201020303ECC0000
+B0BA:000000280028002840284038402840287E280000202021FC207020883E700000
+B0BB:000000280028002840284038402840287E28000003F802000200020003F80000
+B0BC:000000280028002840284038402840287E28000007F8000807F8040007F80000
+B0BD:000000280028002840284038402840287E2800003EF802083E0820083E080000
+B0BE:000000280028002840284038402840287E2800003EF802883E8820883EF80000
+B0BF:000000280028002840284038402840287E2800003E8802883EF820883EF80000
+B0C0:000000280028002840284038402840287E2800001F0801081F0810141F620000
+B0C1:000000280028002840284038402840287E2800003EF802803EF820803EF80000
+B0C2:000000280028002840284038402840287E2800003EFC02483E4820483EFC0000
+B0C3:000000280028002840284038402840287E2800003E1002FE3E3820443E380000
+B0C4:000000280028002840284038402840287E28000003F802080208020803F80000
+B0C5:000000280028002840284038402840287E2800000208020803F8020803F80000
+B0C6:000000280028002840284038402840287E280000110811081F0811141F620000
+B0C7:000000280028002840284038402840287E280000000800080008003400C20000
+B0C8:000000280028002840284038402840287E2800000048004800A8011406620000
+B0C9:000000280028002840284038402840287E280000000001F00208020801F00000
+B0CA:000000280028002840284038402840287E28000003F80020002000D003080000
+B0CB:000000280028002840284038402840287E280000004003F8004000A003180000
+B0CC:000000280028002840284038402840287E28000003F8000803F8000800080000
+B0CD:000000280028002840284038402840287E28000003F8020003F8020003F80000
+B0CE:000000280028002840284038402840287E28000000000FF8022002200FF80000
+B0CF:000000280028002840284038402840287E28000000800FF803E0041003E00000
+B0D0:000000000010001000104010401E40104010401E40107F900010001000100000
+B0D1:0000000800080008400E4008400E40087E08000007F800080008000800080000
+B0D2:0000000800080008400E4008400E40087E08000000003EF80208020802080000
+B0D3:0000000800080008400E4008400E40087E08000000001F080108011401620000
+B0D4:0000000800080008400E4008400E40087E08000008000800080008000FF80000
+B0D5:0000000800080008400E4008400E40087E080000000010F8101010301ECC0000
+B0D6:0000000800080008400E4008400E40087E0800000808087F081C08220F9C0000
+B0D7:0000000800080008400E4008400E40087E08000003F802000200020003F80000
+B0D8:0000000800080008400E4008400E40087E08000007F8000807F8040007F80000
+B0D9:0000000800080008400E4008400E40087E0800003EF802083E0820083E080000
+B0DA:0000000800080008400E4008400E40087E0800003EF802883E8820883EF80000
+B0DB:0000000800080008400E4008400E40087E0800003E8802883EF820883EF80000
+B0DC:0000000800080008400E4008400E40087E0800001F0801081F0810141F620000
+B0DD:0000000800080008400E4008400E40087E0800003EF802803EF820803EF80000
+B0DE:0000000800080008400E4008400E40087E0800003EFC02483E4820483EFC0000
+B0DF:0000000800080008400E4008400E40087E0800001F08017F1F1C10221F1C0000
+B0E0:0000000800080008400E4008400E40087E08000003F802080208020803F80000
+B0E1:0000000800080008400E4008400E40087E0800000208020803F8020803F80000
+B0E2:0000000800080008400E4008400E40087E080000110811081F0811141F620000
+B0E3:0000000800080008400E4008400E40087E080000001000100010006801840000
+B0E4:0000000800080008400E4008400E40087E0800000048004800A8011406620000
+B0E5:0000000800080008400E4008400E40087E080000000003F00408040803F00000
+B0E6:0000000800080008400E4008400E40087E08000003F80020002000D003080000
+B0E7:0000000800080008400E4008400E40087E080000004003F8004000A003180000
+B0E8:0000000800080008400E4008400E40087E08000003F8000803F8000800080000
+B0E9:0000000800080008400E4008400E40087E08000003F8020003F8020003F80000
+B0EA:0000000800080008400E4008400E40087E08000000000FF8022002200FF80000
+B0EB:0000000800080008400E4008400E40087E08000000800FF803E0041003E00000
+B0EC:000000000012001200124012401E40124012401E40127F920012001200120000
+B0ED:000000280028002840384028403840287E28000007F800080008000800080000
+B0EE:000000280028002840384028403840287E28000000003EF80208020802080000
+B0EF:000000280028002840384028403840287E28000000003E100210022802C40000
+B0F0:000000280028002840384028403840287E28002808000800080008000FF80000
+B0F1:000000280028002840384028403840287E280000000020F8201020303ECC0000
+B0F2:000000280028002840384028403840287E280000202021FC207020883E700000
+B0F3:000000280028002840384028403840287E28000003F802000200020003F80000
+B0F4:000000280028002840384028403840287E28000007F8000807F8040007F80000
+B0F5:000000280028002840384028403840287E2800003EF802083E0820083E080000
+B0F6:000000280028002840384028403840287E2800003EF802883E8820883EF80000
+B0F7:000000280028002840384028403840287E2800003E8802883EF820883EF80000
+B0F8:000000280028002840384028403840287E2800001F0801081F0810141F620000
+B0F9:000000280028002840384028403840287E2800003EF802803EF820803EF80000
+B0FA:000000280028002840384028403840287E2800003EFC02483E4820483EFC0000
+B0FB:000000280028002840384028403840287E2800003E1002FE3E3820443E380000
+B0FC:000000280028002840384028403840287E28000003F802080208020803F80000
+B0FD:000000280028002840384028403840287E2800000208020803F8020803F80000
+B0FE:000000280028002840384028403840287E280000110811081F0811141F620000
+B0FF:000000280028002840384028403840287E280000000800080008003400C20000
+B100:000000280028002840384028403840287E2800000048004800A8011406620000
+B101:000000280028002840384028403840287E280000000001F00208020801F00000
+B102:000000280028002840384028403840287E28000003F80020002000D003080000
+B103:000000280028002840384028403840287E280000004003F8004000A003180000
+B104:000000280028002840384028403840287E28000003F8000803F8000800080000
+B105:000000280028002840384028403840287E28000003F8020003F8020003F80000
+B106:000000280028002840384028403840287E28000000000FF8022002200FF80000
+B107:000000280028002840384028403840287E28000000800FF803E0041003E00000
+B108:0000000000020002000240024002401E4002400240027F820002000200020000
+B109:000000080008000840084038400840087E080000000007F80008000800080000
+B10A:000000080008000840084038400840087E08000000003EF80208020802080000
+B10B:000000080008000840084038400840087E08000000001F080108011401620000
+B10C:000000080008000840084038400840087E08000000001000100010001FF80000
+B10D:000000080008000840084038400840087E080000000020F8201020303ECC0000
+B10E:000000080008000840084038400840087E080000202021FC207020883E700000
+B10F:000000080008000840084038400840087E08000003F802000200020003F80000
+B110:000000080008000840084038400840087E08000007F8000807F8040007F80000
+B111:000000080008000840084038400840087E0800003EF802083E0820083E080000
+B112:000000080008000840084038400840087E0800003EF802883E8820883EF80000
+B113:000000080008000840084038400840087E0800003E8802883EF820883EF80000
+B114:000000080008000840084038400840087E0800000F8800880F8808140FA20000
+B115:000000080008000840084038400840087E0800003EF802803EF820803EF80000
+B116:000000080008000840084038400840087E0800003EFC02483E4820483EFC0000
+B117:000000080008000840084038400840087E0800003E1002FE3E3820443E380000
+B118:000000080008000840084038400840087E08000003F802080208020803F80000
+B119:000000080008000840084038400840087E0800000208020803F8020803F80000
+B11A:000000080008000840084038400840087E080000210821083F0821143F620000
+B11B:000000080008000840084038400840087E080000001000100010006801840000
+B11C:000000080008000840084038400840087E0800000048004800A8011406620000
+B11D:000000080008000840084038400840087E080000000003F00408040803F00000
+B11E:000000080008000840084038400840087E08000003F80020002000D003080000
+B11F:000000080008000840084038400840087E080000004003F8004000A003180000
+B120:000000080008000840084038400840087E08000003F8000803F8000800080000
+B121:000000080008000840084038400840087E08000003F8020003F8020003F80000
+B122:000000080008000840084038400840087E08000000000FF8022002200FF80000
+B123:000000080008000840084038400840087E08000000800FF803E0041003E00000
+B124:00000000000A000A000A400A400A403A400A400A400A7F8A000A000A000A0000
+B125:0000002800280028402840E8402840287E28000007F800080008000800080000
+B126:0000002800280028402840E8402840287E28000000003EF80208020802080000
+B127:0000002800280028402840E8402840287E28000000003E100210022802C40000
+B128:0000002800280028402840E8402840287E28000008000800080008000FF80000
+B129:0000002800280028402840E8402840287E280000000020F8201020303ECC0000
+B12A:0000002800280028402840E8402840287E280000202021FC207020883E700000
+B12B:0000002800280028402840E8402840287E28000003F802000200020003F80000
+B12C:0000002800280028402840E8402840287E28000007F8000807F8040007F80000
+B12D:0000002800280028402840E8402840287E2800003EF802083E0820083E080000
+B12E:0000002800280028402840E8402840287E2800003EF802883E8820883EF80000
+B12F:0000002800280028402840E8402840287E2800003E8802883EF820883EF80000
+B130:0000002800280028402840E8402840287E2800001F0801081F0810141F620000
+B131:0000002800280028402840E8402840287E2800003EF802803EF820803EF80000
+B132:0000002800280028402840E8402840287E2800003EFC02483E4820483EFC0000
+B133:0000002800280028402840E8402840287E2800003E1002FE3E3820443E380000
+B134:0000002800280028402840E8402840287E28000003F802080208020803F80000
+B135:0000002800280028402840E8402840287E2800000208020803F8020803F80000
+B136:0000002800280028402840E8402840287E280000110811081F0811141F620000
+B137:0000002800280028402840E8402840287E280000000800080008003400C20000
+B138:0000002800280028402840E8402840287E2800000048004800A8011406620000
+B139:0000002800280028402840E8402840287E280000000001F00208020801F00000
+B13A:0000002800280028402840E8402840287E28000003F80020002000D003080000
+B13B:0000002800280028402840E8402840287E280000004003F8004000A003180000
+B13C:0000002800280028402840E8402840287E28000003F8000803F8000800080000
+B13D:0000002800280028402840E8402840287E28000003F8020003F8020003F80000
+B13E:0000002800280028402840E8402840287E28000000000FF8022002200FF80000
+B13F:0000002800280028402840E8402840287E28000000800FF803E0041003E00000
+B140:000000000002000200024002401E40024002401E40027F820002000200020000
+B141:000000080008000840384008403840087E080000000007F80008000800080000
+B142:000000080008000840384008403840087E08000000003EF80208020802080000
+B143:000000080008000840384008403840087E08000000001F080108011401620000
+B144:000000080008000840384008403840087E08000800001000100010001FF80000
+B145:000000080008000840384008403840087E080000000020F8201020303ECC0000
+B146:000000080008000840384008403840087E080000202021FC207020883E700000
+B147:000000080008000840384008403840087E08000003F802000200020003F80000
+B148:000000080008000840384008403840087E08000007F8000807F8040007F80000
+B149:000000080008000840384008403840087E0800003EF802083E0820083E080000
+B14A:000000080008000840384008403840087E0800003EF802883E8820883EF80000
+B14B:000000080008000840384008403840087E0800003E8802883EF820883EF80000
+B14C:000000080008000840384008403840087E0800000F8800880F8808140FA20000
+B14D:000000080008000840384008403840087E0800003EF802803EF820803EF80000
+B14E:000000080008000840384008403840087E0800003EFC02483E4820483EFC0000
+B14F:000000080008000840384008403840087E0800003E1002FE3E3820443E380000
+B150:000000080008000840384008403840087E08000003F802080208020803F80000
+B151:000000080008000840384008403840087E0800000208020803F8020803F80000
+B152:000000080008000840384008403840087E080000210821083F0821143F620000
+B153:000000080008000840384008403840087E080000001000100010006801840000
+B154:000000080008000840384008403840087E0800000048004800A8011406620000
+B155:000000080008000840384008403840087E080000000003F00408040803F00000
+B156:000000080008000840384008403840087E08000003F80020002000D003080000
+B157:000000080008000840384008403840087E080000004003F8004000A003180000
+B158:000000080008000840384008403840087E08000003F8000803F8000800080000
+B159:000000080008000840384008403840087E08000003F8020003F8020003F80000
+B15A:000000080008000840384008403840087E08000000000FF8022002200FF80000
+B15B:000000080008000840384008403840087E08000000800FF803E0041003E00000
+B15C:00000000000A000A000A400A403A400A400A403A400A7F8A000A000A000A0000
+B15D:000000280028002840E8402840E840287E28000007F800080008000800080000
+B15E:000000280028002840E8402840E840287E28000000003EF80208020802080000
+B15F:000000280028002840E8402840E840287E28000000003E100210022802C40000
+B160:000000280028002840E8402840E840287E28002808000800080008000FF80000
+B161:000000280028002840E8402840E840287E280000000020F8201020303ECC0000
+B162:000000280028002840E8402840E840287E280000202021FC207020883E700000
+B163:000000280028002840E8402840E840287E28000003F802000200020003F80000
+B164:000000280028002840E8402840E840287E28000007F8000807F8040007F80000
+B165:000000280028002840E8402840E840287E2800003EF802083E0820083E080000
+B166:000000280028002840E8402840E840287E2800003EF802883E8820883EF80000
+B167:000000280028002840E8402840E840287E2800003E8802883EF820883EF80000
+B168:000000280028002840E8402840E840287E2800001F0801081F0810141F620000
+B169:000000280028002840E8402840E840287E2800003EF802803EF820803EF80000
+B16A:000000280028002840E8402840E840287E2800003EFC02483E4820483EFC0000
+B16B:000000280028002840E8402840E840287E2800003E1002FE3E3820443E380000
+B16C:000000280028002840E8402840E840287E28000003F802080208020803F80000
+B16D:000000280028002840E8402840E840287E2800000208020803F8020803F80000
+B16E:000000280028002840E8402840E840287E280000110811081F0811141F620000
+B16F:000000280028002840E8402840E840287E280000000800080008003400C20000
+B170:000000280028002840E8402840E840287E2800000048004800A8011406620000
+B171:000000280028002840E8402840E840287E280000000001F00208020801F00000
+B172:000000280028002840E8402840E840287E28000003F80020002000D003080000
+B173:000000280028002840E8402840E840287E280000004003F8004000A003180000
+B174:000000280028002840E8402840E840287E28000003F8000803F8000800080000
+B175:000000280028002840E8402840E840287E28000003F8020003F8020003F80000
+B176:000000280028002840E8402840E840287E28000000000FF8022002200FF80000
+B177:000000280028002840E8402840E840287E28000000800FF803E0041003E00000
+B178:00000000200020002000200020003FF8000000000100010001007FFC00000000
+B179:000000001000100010001FF0010001007FFC00001FF000100010001000100000
+B17A:000000001000100010001FF0010001007FFC000000003EF80208020802080000
+B17B:000000001000100010001FF0010001007FFC000000001E100210022802C40000
+B17C:000000001000100010001FF0010001007FFC000000001000100010001FF00000
+B17D:000000001000100010001FF0010001007FFC0000000020F8201020303ECC0000
+B17E:000000001000100010001FF0010001007FFC0000202021FC207020883E700000
+B17F:000000001000100010001FF0010001007FFC00001FF01000100010001FF00000
+B180:000000001000100010001FF0010001007FFC00001FF000101FF010001FF00000
+B181:000000001000100010001FF0010001007FFC00003EF802083E0820083E080000
+B182:000000001000100010001FF0010001007FFC00003EF802883E8820883EF80000
+B183:000000001000100010001FF0010001007FFC00003E8802883EF820883EF80000
+B184:000000001000100010001FF0010001007FFC00003E1002103E1020283EC40000
+B185:000000001000100010001FF0010001007FFC00003EF802803EF820803EF80000
+B186:000000001000100010001FF0010001007FFC00003EFC02483E4820483EFC0000
+B187:000000001000100010001FF0010001007FFC00003E2003FC3E7020883E700000
+B188:000000001000100010001FF0010001007FFC00001FF01010101010101FF00000
+B189:000000001000100010001FF0010001007FFC0000101010101FF010101FF00000
+B18A:000000001000100010001FF0010001007FFC0000222022203E2022503E880000
+B18B:000000001000100010001FF0010001007FFC000000000100010002800C400000
+B18C:000000001000100010001FF0010001007FFC00000000024002400DA033100000
+B18D:000000001000100010001FF0010001007FFC0000000007C00820082007C00000
+B18E:000000001000100010001FF0010001007FFC0000000007E00080014006200000
+B18F:000000001000100010001FF0010001007FFC0000008007E00080014006200000
+B190:000000001000100010001FF0010001007FFC00001FF000101FF0001000100000
+B191:000000001000100010001FF0010001007FFC00001FF010001FF010001FF00000
+B192:000000001000100010001FF0010001007FFC000000001FF0044004401FF00000
+B193:000000001000100010001FF0010001007FFC000001001FF007C0082007C00000
+B194:0000001000104010401040104010401E7F900010041004107FD0001000100000
+B195:0000000820082008200E20083F8804087FE8000007F800080008000800080000
+B196:0000000820082008200E20083F8804087FE8000000003EF80208020802080000
+B197:0000000820082008200E20083F8804087FE8000000001F080108011401620000
+B198:0000000820082008200E20083F8804087FE8000008000800080008000FF80000
+B199:0000000820082008200E20083F8804087FE80000000010F8101010301ECC0000
+B19A:0000000820082008200E20083F8804087FE800000808087F081C08220F9C0000
+B19B:0000000820082008200E20083F8804087FE8000003F802000200020003F80000
+B19C:0000000820082008200E20083F8804087FE8000007F8000807F8040007F80000
+B19D:0000000820082008200E20083F8804087FE800003EF802083E0820083E080000
+B19E:0000000820082008200E20083F8804087FE800003EF802883E8820883EF80000
+B19F:0000000820082008200E20083F8804087FE800003E8802883EF820883EF80000
+B1A0:0000000820082008200E20083F8804087FE800001F0801081F0810141F620000
+B1A1:0000000820082008200E20083F8804087FE800003EF802803EF820803EF80000
+B1A2:0000000820082008200E20083F8804087FE800003EFC02483E4820483EFC0000
+B1A3:0000000820082008200E20083F8804087FE800001F08017F1F1C10221F1C0000
+B1A4:0000000820082008200E20083F8804087FE8000003F802080208020803F80000
+B1A5:0000000820082008200E20083F8804087FE800000208020803F8020803F80000
+B1A6:0000000820082008200E20083F8804087FE80000110811081F0811141F620000
+B1A7:0000000820082008200E20083F8804087FE80000001000100010006801840000
+B1A8:0000000820082008200E20083F8804087FE800000048004800A8011406620000
+B1A9:0000000820082008200E20083F8804087FE80000000003F00408040803F00000
+B1AA:0000000820082008200E20083F8804087FE8000003F80020002000D003080000
+B1AB:0000000820082008200E20083F8804087FE80000004003F8004000A003180000
+B1AC:0000000820082008200E20083F8804087FE8000003F8000803F8000800080000
+B1AD:0000000820082008200E20083F8804087FE8000003F8020003F8020003F80000
+B1AE:0000000820082008200E20083F8804087FE8000000000FF8022002200FF80000
+B1AF:0000000820082008200E20083F8804087FE8000000800FF803E0041003E00000
+B1B0:0000001200124012401240124012401E7F920012041204127FD2001200120000
+B1B1:0000002820282028203820283FA804287FA8000007F800080008000800080000
+B1B2:0000002820282028203820283FA804287FA8000000003EF80208020802080000
+B1B3:0000002820282028203820283FA804287FA8000000001F080108011401620000
+B1B4:0000002820282028203820283FA804287FA8000008000800080008000FF80000
+B1B5:0000002820282028203820283FA804287FA80000000010F8101010301ECC0000
+B1B6:0000002820282028203820283FA804287FA800000808087F081C08220F9C0000
+B1B7:0000002820282028203820283FA804287FA8000003F802000200020003F80000
+B1B8:0000002820282028203820283FA804287FA8000007F8000807F8040007F80000
+B1B9:0000002820282028203820283FA804287FA800003EF802083E0820083E080000
+B1BA:0000002820282028203820283FA804287FA800003EF802883E8820883EF80000
+B1BB:0000002820282028203820283FA804287FA800003E8802883EF820883EF80000
+B1BC:0000002820282028203820283FA804287FA800001F0801081F0810141F620000
+B1BD:0000002820282028203820283FA804287FA800003EF802803EF820803EF80000
+B1BE:0000002820282028203820283FA804287FA800003EFC02483E4820483EFC0000
+B1BF:0000002820282028203820283FA804287FA800001F08017F1F1C10221F1C0000
+B1C0:0000002820282028203820283FA804287FA8000003F802080208020803F80000
+B1C1:0000002820282028203820283FA804287FA800000208020803F8020803F80000
+B1C2:0000002820282028203820283FA804287FA80000110811081F0811141F620000
+B1C3:0000002820282028203820283FA804287FA80000001000100010006801840000
+B1C4:0000002820282028203820283FA804287FA800000048004800A8011406620000
+B1C5:0000002820282028203820283FA804287FA80000000003F00408040803F00000
+B1C6:0000002820282028203820283FA804287FA8000003F80020002000D003080000
+B1C7:0000002820282028203820283FA804287FA80000004003F8004000A003180000
+B1C8:0000002820282028203820283FA804287FA8000003F8000803F8000800080000
+B1C9:0000002820282028203820283FA804287FA8000003F8020003F8020003F80000
+B1CA:0000002820282028203820283FA804287FA8000000000FF8022002200FF80000
+B1CB:0000002820282028203820283FA804287FA8000000800FF803E0041003E00000
+B1CC:000000080008400840084008400840087F880008040804087FE8000800080000
+B1CD:0000000820082008200820083F8804087FE8000007F800080008000800080000
+B1CE:0000000820082008200820083F8804087FE8000000003EF80208020802080000
+B1CF:0000000820082008200820083F8804087FE8000000001F080108011401620000
+B1D0:0000000820082008200820083F8804087FE8000008000800080008000FF80000
+B1D1:0000000820082008200820083F8804087FE80000000010F8101010301ECC0000
+B1D2:0000000820082008200820083F8804087FE800000808087F081C08220F9C0000
+B1D3:0000000820082008200820083F8804087FE8000003F802000200020003F80000
+B1D4:0000000820082008200820083F8804087FE8000007F8000807F8040007F80000
+B1D5:0000000820082008200820083F8804087FE800003EF802083E0820083E080000
+B1D6:0000000820082008200820083F8804087FE800003EF802883E8820883EF80000
+B1D7:0000000820082008200820083F8804087FE800003E8802883EF820883EF80000
+B1D8:0000000820082008200820083F8804087FE800001F0801081F0810141F620000
+B1D9:0000000820082008200820083F8804087FE800003EF802803EF820803EF80000
+B1DA:0000000820082008200820083F8804087FE800003EFC02483E4820483EFC0000
+B1DB:0000000820082008200820083F8804087FE800001F08017F1F1C10221F1C0000
+B1DC:0000000820082008200820083F8804087FE8000003F802080208020803F80000
+B1DD:0000000820082008200820083F8804087FE800000208020803F8020803F80000
+B1DE:0000000820082008200820083F8804087FE80000110811081F0811141F620000
+B1DF:0000000820082008200820083F8804087FE80000001000100010006801840000
+B1E0:0000000820082008200820083F8804087FE800000048004800A8011406620000
+B1E1:0000000820082008200820083F8804087FE80000000003F00408040803F00000
+B1E2:0000000820082008200820083F8804087FE8000003F80020002000D003080000
+B1E3:0000000820082008200820083F8804087FE80000004003F8004000A003180000
+B1E4:0000000820082008200820083F8804087FE8000003F8000803F8000800080000
+B1E5:0000000820082008200820083F8804087FE8000003F8020003F8020003F80000
+B1E6:0000000820082008200820083F8804087FE8000000000FF8022002200FF80000
+B1E7:0000000820082008200820083F8804087FE8000000800FF803E0041003E00000
+B1E8:00000000200020002000200020003FF8000004400440044004407FFC00000000
+B1E9:000000001000100010001FF0044004407FFC00001FF000100010001000100000
+B1EA:000000001000100010001FF0044004407FFC000000003EF80208020802080000
+B1EB:000000001000100010001FF0044004407FFC000000001E100210022802C40000
+B1EC:000000001000100010001FF0044004407FFC000000001000100010001FF00000
+B1ED:000000001000100010001FF0044004407FFC0000000020F8201020303ECC0000
+B1EE:000000001000100010001FF0044004407FFC0000202021FC207020883E700000
+B1EF:000000001000100010001FF0044004407FFC00001FF01000100010001FF00000
+B1F0:000000001000100010001FF0044004407FFC00001FF000101FF010001FF00000
+B1F1:000000001000100010001FF0044004407FFC00003EF802083E0820083E080000
+B1F2:000000001000100010001FF0044004407FFC00003EF802883E8820883EF80000
+B1F3:000000001000100010001FF0044004407FFC00003E8802883EF820883EF80000
+B1F4:000000001000100010001FF0044004407FFC00003E1002103E1020283EC40000
+B1F5:000000001000100010001FF0044004407FFC00003EF802803EF820803EF80000
+B1F6:000000001000100010001FF0044004407FFC00003EFC02483E4820483EFC0000
+B1F7:000000001000100010001FF0044004407FFC00003E2003FC3E7020883E700000
+B1F8:000000001000100010001FF0044004407FFC00001FF01010101010101FF00000
+B1F9:000000001000100010001FF0044004407FFC0000101010101FF010101FF00000
+B1FA:000000001000100010001FF0044004407FFC0000222022203E2022503E880000
+B1FB:000000001000100010001FF0044004407FFC000000000100010002800C400000
+B1FC:000000001000100010001FF0044004407FFC00000000024002400DA033100000
+B1FD:000000001000100010001FF0044004407FFC0000000007C00820082007C00000
+B1FE:000000001000100010001FF0044004407FFC0000000007E00080014006200000
+B1FF:000000001000100010001FF0044004407FFC0000008007E00080014006200000
+B200:000000001000100010001FF0044004407FFC00001FF000101FF0001000100000
+B201:000000001000100010001FF0044004407FFC00001FF010001FF010001FF00000
+B202:000000001000100010001FF0044004407FFC000000001FF0044004401FF00000
+B203:000000001000100010001FF0044004407FFC000001001FF007C0082007C00000
+B204:00000000200020002000200020003FF8000000003FF801000100010001000000
+B205:000000001000100010001FF000007FFC010001001FF000100010001000100000
+B206:000000001000100010001FF000007FFC0100010000003EF80208020802080000
+B207:000000001000100010001FF000007FFC0100010000001E100210022802C40000
+B208:000000001000100010001FF0000000007FFC010001001100100010001FF00000
+B209:000000001000100010001FF000007FFC01000100000020F8201020303ECC0000
+B20A:000000001000100010001FF000007FFC01000100202021FC207020883E700000
+B20B:000000001000100010001FF000007FFC010001001FF01000100010001FF00000
+B20C:000000001000100010001FF000007FFC010001001FF000101FF010001FF00000
+B20D:000000001000100010001FF000007FFC010001003EF802083E0820083E080000
+B20E:000000001000100010001FF000007FFC010001003EF802883E8820883EF80000
+B20F:000000001000100010001FF000007FFC010001003E8802883EF820883EF80000
+B210:000000001000100010001FF000007FFC010001003E1002103E1020283EC40000
+B211:000000001000100010001FF000007FFC010001003EF802803EF820803EF80000
+B212:000000001000100010001FF000007FFC010001003EFC02483E4820483EFC0000
+B213:000000001000100010001FF000007FFC010001003E2003FC3E7020883E700000
+B214:000000001000100010001FF000007FFC010001001FF01010101010101FF00000
+B215:000000001000100010001FF000007FFC01000100101010101FF010101FF00000
+B216:000000001000100010001FF000007FFC01000100222022203E2022503E880000
+B217:000000001000100010001FF000007FFC0100010000000100010002800C400000
+B218:000000001000100010001FF000007FFC010001000000024002400DA033100000
+B219:000000001000100010001FF000007FFC01000100000007C00820082007C00000
+B21A:000000001000100010001FF000007FFC01000100000007E00080014006200000
+B21B:000000001000100010001FF000007FFC01000100008007E00080014006200000
+B21C:000000001000100010001FF000007FFC010001001FF000101FF0001000100000
+B21D:000000001000100010001FF000007FFC010001001FF010001FF010001FF00000
+B21E:000000001000100010001FF000007FFC0100010000001FF0044004401FF00000
+B21F:000000001000100010001FF000007FFC0100010001001FF007C0082007C00000
+B220:00000008000840084008400840087F88000800087FE8040804F8040804080000
+B221:00082008200820083F8800087FE8027802080000000007F80008000800080000
+B222:00082008200820083F8800087FE802780208000000003EF80208020802080000
+B223:00082008200820083F8800087FE802780208000000001F080108011401620000
+B224:00082008200820083F88000800087FE80278020802081000100010001FF80000
+B225:00082008200820083F8800087FE8027802080000000020F8201020303ECC0000
+B226:00082008200820083F8800087FE8027802080000202021FC207020883E700000
+B227:00082008200820083F8800087FE802780208000003F802000200020003F80000
+B228:00082008200820083F8800087FE802780208000007F8000807F8040007F80000
+B229:00082008200820083F8800087FE80278020800003EF802083E0820083E080000
+B22A:00082008200820083F8800087FE80278020800003EF802883E8820883EF80000
+B22B:00082008200820083F8800087FE80278020800003E8802883EF820883EF80000
+B22C:00082008200820083F8800087FE80278020800000F8800880F8808140FA20000
+B22D:00082008200820083F8800087FE80278020800003EF802803EF820803EF80000
+B22E:00082008200820083F8800087FE80278020800003EFC02483E4820483EFC0000
+B22F:00082008200820083F8800087FE80278020800003E1002FE3E3820443E380000
+B230:00082008200820083F8800087FE802780208000003F802080208020803F80000
+B231:00082008200820083F8800087FE80278020800000208020803F8020803F80000
+B232:00082008200820083F8800087FE8027802080000210821083F0821143F620000
+B233:00082008200820083F8800087FE8027802080000001000100010006801840000
+B234:00082008200820083F8800087FE80278020800000048004800A8011406620000
+B235:00082008200820083F8800087FE8027802080000000003F00408040803F00000
+B236:00082008200820083F8800087FE802780208000003F80020002000D003080000
+B237:00082008200820083F8800087FE8027802080000004003F8004000A003180000
+B238:00082008200820083F8800087FE802780208000003F8000803F8000800080000
+B239:00082008200820083F8800087FE802780208000003F8020003F8020003F80000
+B23A:00082008200820083F8800087FE802780208000000000FF8022002200FF80000
+B23B:00082008200820083F8800087FE802780208000000800FF803E0041003E00000
+B23C:0000000A000A400A400A400A400A7F8A000A000A7FEA040A047A040A040A0000
+B23D:00282028202820283FA800287FA805E804280000000007F80008000800080000
+B23E:00282028202820283FA800287FA805E80428000000003EF80208020802080000
+B23F:00282028202820283FA800287FA805E80428000000001F080108011401620000
+B240:00282028202820283FA8002800287FA8042805E804281428100010001FF80000
+B241:00282028202820283FA800287FA805E804280000000020F8201020303ECC0000
+B242:00282028202820283FA800287FA805E804280000202021FC207020883E700000
+B243:00282028202820283FA800287FA805E80428000003F802000200020003F80000
+B244:00282028202820283FA800287FA805E80428000007F8000807F8040007F80000
+B245:00282028202820283FA800287FA805E8042800003EF802083E0820083E080000
+B246:00282028202820283FA800287FA805E8042800003EF802883E8820883EF80000
+B247:00282028202820283FA800287FA805E8042800003E8802883EF820883EF80000
+B248:00282028202820283FA800287FA805E8042800000F8800880F8808140FA20000
+B249:00282028202820283FA800287FA805E8042800003EF802803EF820803EF80000
+B24A:00282028202820283FA800287FA805E8042800003EFC02483E4820483EFC0000
+B24B:00282028202820283FA800287FA805E8042800003E1002FE3E3820443E380000
+B24C:00282028202820283FA800287FA805E80428000003F802080208020803F80000
+B24D:00282028202820283FA800287FA805E8042800000208020803F8020803F80000
+B24E:00282028202820283FA800287FA805E804280000210821083F0821143F620000
+B24F:00282028202820283FA800287FA805E804280000001000100010006801840000
+B250:00282028202820283FA800287FA805E8042800000048004800A8011406620000
+B251:00282028202820283FA800287FA805E804280000000003F00408040803F00000
+B252:00282028202820283FA800287FA805E80428000003F80020002000D003080000
+B253:00282028202820283FA800287FA805E804280000004003F8004000A003180000
+B254:00282028202820283FA800287FA805E80428000003F8000803F8000800080000
+B255:00282028202820283FA800287FA805E80428000003F8020003F8020003F80000
+B256:00282028202820283FA800287FA805E80428000000000FF8022002200FF80000
+B257:00282028202820283FA800287FA805E80428000000800FF803E0041003E00000
+B258:00000008000840084008400840087F88000800087FE804080408040804080000
+B259:00082008200820083F8800087FE8020802000000000007F80008000800080000
+B25A:00082008200820083F8800087FE802080200000000003EF80208020802080000
+B25B:00082008200820083F8800087FE802080200000000001F080108011401620000
+B25C:00082008200820083F88000800087FE80208020802081008100010001FF80000
+B25D:00082008200820083F8800087FE8020802000000000020F8201020303ECC0000
+B25E:00082008200820083F8800087FE8020802000000202021FC207020883E700000
+B25F:00082008200820083F8800087FE802080200000003F802000200020003F80000
+B260:00082008200820083F8800087FE802080200000007F8000807F8040007F80000
+B261:00082008200820083F8800087FE80208020000003EF802083E0820083E080000
+B262:00082008200820083F8800087FE80208020000003EF802883E8820883EF80000
+B263:00082008200820083F8800087FE80208020000003E8802883EF820883EF80000
+B264:00082008200820083F8800087FE80208020000000F8800880F8808140FA20000
+B265:00082008200820083F8800087FE80208020000003EF802803EF820803EF80000
+B266:00082008200820083F8800087FE80208020000003EFC02483E4820483EFC0000
+B267:00082008200820083F8800087FE80208020000003E1002FE3E3820443E380000
+B268:00082008200820083F8800087FE802080200000003F802080208020803F80000
+B269:00082008200820083F8800087FE80208020000000208020803F8020803F80000
+B26A:00082008200820083F8800087FE8020802000000210821083F0821143F620000
+B26B:00082008200820083F8800087FE8020802000000001000100010006801840000
+B26C:00082008200820083F8800087FE80208020000000048004800A8011406620000
+B26D:00082008200820083F8800087FE8020802000000000003F00408040803F00000
+B26E:00082008200820083F8800087FE802080200000003F80020002000D003080000
+B26F:00082008200820083F8800087FE8020802000000004003F8004000A003180000
+B270:00082008200820083F8800087FE802080200000003F8000803F8000800080000
+B271:00082008200820083F8800087FE802080200000003F8020003F8020003F80000
+B272:00082008200820083F8800087FE802080200000000000FF8022002200FF80000
+B273:00082008200820083F8800087FE802080200000000800FF803E0041003E00000
+B274:00000000200020002000200020003FF8000000007FFC04400440044004400000
+B275:000000001000100010001FF000007FFC044004401FF000100010001000100000
+B276:000000001000100010001FF000007FFC0440044000003EF80208020802080000
+B277:000000001000100010001FF000007FFC0440044000001E100210022802C40000
+B278:000000001000100010001FF0000000007FFC044004401440100010001FF00000
+B279:000000001000100010001FF000007FFC04400440000020F8201020303ECC0000
+B27A:000000001000100010001FF000007FFC04400440202021FC207020883E700000
+B27B:000000001000100010001FF000007FFC044004401FF01000100010001FF00000
+B27C:000000001000100010001FF000007FFC044004401FF000101FF010001FF00000
+B27D:000000001000100010001FF000007FFC044004403EF802083E0820083E080000
+B27E:000000001000100010001FF000007FFC044004403EF802883E8820883EF80000
+B27F:000000001000100010001FF000007FFC044004403E8802883EF820883EF80000
+B280:000000001000100010001FF000007FFC044004403E1002103E1020283EC40000
+B281:000000001000100010001FF000007FFC044004403EF802803EF820803EF80000
+B282:000000001000100010001FF000007FFC044004403EFC02483E4820483EFC0000
+B283:000000001000100010001FF000007FFC044004403E2003FC3E7020883E700000
+B284:000000001000100010001FF000007FFC044004401FF01010101010101FF00000
+B285:000000001000100010001FF000007FFC04400440101010101FF010101FF00000
+B286:000000001000100010001FF000007FFC04400440222022203E2022503E880000
+B287:000000001000100010001FF000007FFC0440044000000100010002800C400000
+B288:000000001000100010001FF000007FFC044004400000024002400DA033100000
+B289:000000001000100010001FF000007FFC04400440000007C00820082007C00000
+B28A:000000001000100010001FF000007FFC04400440000007E00080014006200000
+B28B:000000001000100010001FF000007FFC04400440008007E00080014006200000
+B28C:000000001000100010001FF000007FFC044004401FF000101FF0001000100000
+B28D:000000001000100010001FF000007FFC044004401FF010001FF010001FF00000
+B28E:000000001000100010001FF000007FFC0440044000001FF0044004401FF00000
+B28F:000000001000100010001FF000007FFC0440044001001FF007C0082007C00000
+B290:00000000200020002000200020003FF80000000000007FFC0000000000000000
+B291:000000001000100010001FF0000000007FFC00001FF000100010001000100000
+B292:000000001000100010001FF0000000007FFC000000003EF80208020802080000
+B293:000000001000100010001FF0000000007FFC000000001E100210022802C40000
+B294:000000001000100010001FF0000000007FFC000000001000100010001FF00000
+B295:000000001000100010001FF0000000007FFC0000000020F8201020303ECC0000
+B296:000000001000100010001FF0000000007FFC0000202021FC207020883E700000
+B297:000000001000100010001FF0000000007FFC00001FF01000100010001FF00000
+B298:000000001000100010001FF0000000007FFC00001FF000101FF010001FF00000
+B299:000000001000100010001FF0000000007FFC00003EF802083E0820083E080000
+B29A:000000001000100010001FF0000000007FFC00003EF802883E8820883EF80000
+B29B:000000001000100010001FF0000000007FFC00003E8802883EF820883EF80000
+B29C:000000001000100010001FF0000000007FFC00003E1002103E1020283EC40000
+B29D:000000001000100010001FF0000000007FFC00003EF802803EF820803EF80000
+B29E:000000001000100010001FF0000000007FFC00003EFC02483E4820483EFC0000
+B29F:000000001000100010001FF0000000007FFC00003E2003FC3E7020883E700000
+B2A0:000000001000100010001FF0000000007FFC00001FF01010101010101FF00000
+B2A1:000000001000100010001FF0000000007FFC0000101010101FF010101FF00000
+B2A2:000000001000100010001FF0000000007FFC0000222022203E2022503E880000
+B2A3:000000001000100010001FF0000000007FFC000000000100010002800C400000
+B2A4:000000001000100010001FF0000000007FFC00000000024002400DA033100000
+B2A5:000000001000100010001FF0000000007FFC0000000007C00820082007C00000
+B2A6:000000001000100010001FF0000000007FFC0000000007E00080014006200000
+B2A7:000000001000100010001FF0000000007FFC0000008007E00080014006200000
+B2A8:000000001000100010001FF0000000007FFC00001FF000101FF0001000100000
+B2A9:000000001000100010001FF0000000007FFC00001FF010001FF010001FF00000
+B2AA:000000001000100010001FF0000000007FFC000000001FF0044004401FF00000
+B2AB:000000001000100010001FF0000000007FFC000001001FF007C0082007C00000
+B2AC:000000080008400840084008400840087F88000800087FE80008000800080000
+B2AD:0000000820082008200820083F8800087FE8000007F800080008000800080000
+B2AE:0000000820082008200820083F8800087FE8000000003EF80208020802080000
+B2AF:0000000820082008200820083F8800087FE8000000001F080108011401620000
+B2B0:0000000820082008200820083F8800087FE8000008000800080008000FF80000
+B2B1:0000000820082008200820083F8800087FE80000000010F8101010301ECC0000
+B2B2:0000000820082008200820083F8800087FE800000808087F081C08220F9C0000
+B2B3:0000000820082008200820083F8800087FE8000003F802000200020003F80000
+B2B4:0000000820082008200820083F8800087FE8000007F8000807F8040007F80000
+B2B5:0000000820082008200820083F8800087FE800003EF802083E0820083E080000
+B2B6:0000000820082008200820083F8800087FE800003EF802883E8820883EF80000
+B2B7:0000000820082008200820083F8800087FE800003E8802883EF820883EF80000
+B2B8:0000000820082008200820083F8800087FE800001F0801081F0810141F620000
+B2B9:0000000820082008200820083F8800087FE800003EF802803EF820803EF80000
+B2BA:0000000820082008200820083F8800087FE800003EFC02483E4820483EFC0000
+B2BB:0000000820082008200820083F8800087FE800001F08017F1F1C10221F1C0000
+B2BC:0000000820082008200820083F8800087FE8000003F802080208020803F80000
+B2BD:0000000820082008200820083F8800087FE800000208020803F8020803F80000
+B2BE:0000000820082008200820083F8800087FE80000110811081F0811141F620000
+B2BF:0000000820082008200820083F8800087FE80000001000100010006801840000
+B2C0:0000000820082008200820083F8800087FE800000048004800A8011406620000
+B2C1:0000000820082008200820083F8800087FE80000000003F00408040803F00000
+B2C2:0000000820082008200820083F8800087FE8000003F80020002000D003080000
+B2C3:0000000820082008200820083F8800087FE80000004003F8004000A003180000
+B2C4:0000000820082008200820083F8800087FE8000003F8000803F8000800080000
+B2C5:0000000820082008200820083F8800087FE8000003F8020003F8020003F80000
+B2C6:0000000820082008200820083F8800087FE8000000000FF8022002200FF80000
+B2C7:0000000820082008200820083F8800087FE8000000800FF803E0041003E00000
+B2C8:000000000008000800084008400840084008400840087F880008000800080000
+B2C9:000000080008000840084008400840087E080000000007F80008000800080000
+B2CA:000000080008000840084008400840087E08000000003EF80208020802080000
+B2CB:000000080008000840084008400840087E08000000001F080108011401620000
+B2CC:000000080008000840084008400840087E08000800001000100010001FF80000
+B2CD:000000080008000840084008400840087E080000000020F8201020303ECC0000
+B2CE:000000080008000840084008400840087E080000202021FC207020883E700000
+B2CF:000000080008000840084008400840087E08000003F802000200020003F80000
+B2D0:000000080008000840084008400840087E08000007F8000807F8040007F80000
+B2D1:000000080008000840084008400840087E0800003EF802083E0820083E080000
+B2D2:000000080008000840084008400840087E0800003EF802883E8820883EF80000
+B2D3:000000080008000840084008400840087E0800003E8802883EF820883EF80000
+B2D4:000000080008000840084008400840087E0800000F8800880F8808140FA20000
+B2D5:000000080008000840084008400840087E0800003EF802803EF820803EF80000
+B2D6:000000080008000840084008400840087E0800003EFC02483E4820483EFC0000
+B2D7:000000080008000840084008400840087E0800003E1002FE3E3820443E380000
+B2D8:000000080008000840084008400840087E08000003F802080208020803F80000
+B2D9:000000080008000840084008400840087E0800000208020803F8020803F80000
+B2DA:000000080008000840084008400840087E080000210821083F0821143F620000
+B2DB:000000080008000840084008400840087E080000001000100010006801840000
+B2DC:000000080008000840084008400840087E0800000048004800A8011406620000
+B2DD:000000080008000840084008400840087E080000000003F00408040803F00000
+B2DE:000000080008000840084008400840087E08000003F80020002000D003080000
+B2DF:000000080008000840084008400840087E080000004003F8004000A003180000
+B2E0:000000080008000840084008400840087E08000003F8000803F8000800080000
+B2E1:000000080008000840084008400840087E08000003F8020003F8020003F80000
+B2E2:000000080008000840084008400840087E08000000000FF8022002200FF80000
+B2E3:000000080008000840084008400840087E08000000800FF803E0041003E00000
+B2E4:00000000001000107F9040104010401E401040107F9000100010001000100000
+B2E5:0000000800087E084008400E40087E080008000007F800080008000800080000
+B2E6:0000000800087E084008400E40087E080008000000003EF80208020802080000
+B2E7:0000000800087E084008400E40087E080008000000001F080108011401620000
+B2E8:0000000800087E084008400E40087E080008000808000800080008000FF80000
+B2E9:0000000800087E084008400E40087E0800080000000010F8101010301ECC0000
+B2EA:0000000800087E084008400E40087E08000800000808087F081C08220F9C0000
+B2EB:0000000800087E084008400E40087E080008000003F802000200020003F80000
+B2EC:0000000800087E084008400E40087E080008000007F8000807F8040007F80000
+B2ED:0000000800087E084008400E40087E08000800003EF802083E0820083E080000
+B2EE:0000000800087E084008400E40087E08000800003EF802883E8820883EF80000
+B2EF:0000000800087E084008400E40087E08000800003E8802883EF820883EF80000
+B2F0:0000000800087E084008400E40087E08000800001F0801081F0810141F620000
+B2F1:0000000800087E084008400E40087E08000800003EF802803EF820803EF80000
+B2F2:0000000800087E084008400E40087E08000800003EFC02483E4820483EFC0000
+B2F3:0000000800087E084008400E40087E08000800001F08017F1F1C10221F1C0000
+B2F4:0000000800087E084008400E40087E080008000003F802080208020803F80000
+B2F5:0000000800087E084008400E40087E08000800000208020803F8020803F80000
+B2F6:0000000800087E084008400E40087E0800080000110811081F0811141F620000
+B2F7:0000000800087E084008400E40087E0800080000001000100010006801840000
+B2F8:0000000800087E084008400E40087E08000800000048004800A8011406620000
+B2F9:0000000800087E084008400E40087E0800080000000003F00408040803F00000
+B2FA:0000000800087E084008400E40087E080008000003F80020002000D003080000
+B2FB:0000000800087E084008400E40087E0800080000004003F8004000A003180000
+B2FC:0000000800087E084008400E40087E080008000003F8000803F8000800080000
+B2FD:0000000800087E084008400E40087E080008000003F8020003F8020003F80000
+B2FE:0000000800087E084008400E40087E080008000000000FF8022002200FF80000
+B2FF:0000000800087E084008400E40087E080008000000800FF803E0041003E00000
+B300:00000000001200127F9240124012401E401240127F9200120012001200120000
+B301:0000002800287E284028403840287E280028000007F800080008000800080000
+B302:0000002800287E284028403840287E280028000000003EF80208020802080000
+B303:0000002800287E284028403840287E280028000000003E100210022802C40000
+B304:0000002800287E284028403840287E280028002808000800080008000FF80000
+B305:0000002800287E284028403840287E2800280000000020F8201020303ECC0000
+B306:0000002800287E284028403840287E2800280000202021FC207020883E700000
+B307:0000002800287E284028403840287E280028000003F802000200020003F80000
+B308:0000002800287E284028403840287E280028000007F8000807F8040007F80000
+B309:0000002800287E284028403840287E28002800003EF802083E0820083E080000
+B30A:0000002800287E284028403840287E28002800003EF802883E8820883EF80000
+B30B:0000002800287E284028403840287E28002800003E8802883EF820883EF80000
+B30C:0000002800287E284028403840287E28002800001F0801081F0810141F620000
+B30D:0000002800287E284028403840287E28002800003EF802803EF820803EF80000
+B30E:0000002800287E284028403840287E28002800003EFC02483E4820483EFC0000
+B30F:0000002800287E284028403840287E28002800003E1002FE3E3820443E380000
+B310:0000002800287E284028403840287E280028000003F802080208020803F80000
+B311:0000002800287E284028403840287E28002800000208020803F8020803F80000
+B312:0000002800287E284028403840287E2800280000110811081F0811141F620000
+B313:0000002800287E284028403840287E2800280000000800080008003400C20000
+B314:0000002800287E284028403840287E28002800000048004800A8011406620000
+B315:0000002800287E284028403840287E2800280000000001F00208020801F00000
+B316:0000002800287E284028403840287E280028000003F80020002000D003080000
+B317:0000002800287E284028403840287E2800280000004003F8004000A003180000
+B318:0000002800287E284028403840287E280028000003F8000803F8000800080000
+B319:0000002800287E284028403840287E280028000003F8020003F8020003F80000
+B31A:0000002800287E284028403840287E280028000000000FF8022002200FF80000
+B31B:0000002800287E284028403840287E280028000000800FF803E0041003E00000
+B31C:00000000001000107F904010401E40104010401E7F9000100010001000100000
+B31D:0000000800087E08400E4008400E7E080008000007F800080008000800080000
+B31E:0000000800087E08400E4008400E7E080008000000003EF80208020802080000
+B31F:0000000800087E08400E4008400E7E080008000000001F080108011401620000
+B320:0000000800087E08400E4008400E7E080008000008000800080008000FF80000
+B321:0000000800087E08400E4008400E7E0800080000000010F8101010301ECC0000
+B322:0000000800087E08400E4008400E7E08000800000808087F081C08220F9C0000
+B323:0000000800087E08400E4008400E7E080008000003F802000200020003F80000
+B324:0000000800087E08400E4008400E7E080008000007F8000807F8040007F80000
+B325:0000000800087E08400E4008400E7E08000800003EF802083E0820083E080000
+B326:0000000800087E08400E4008400E7E08000800003EF802883E8820883EF80000
+B327:0000000800087E08400E4008400E7E08000800003E8802883EF820883EF80000
+B328:0000000800087E08400E4008400E7E08000800001F0801081F0810141F620000
+B329:0000000800087E08400E4008400E7E08000800003EF802803EF820803EF80000
+B32A:0000000800087E08400E4008400E7E08000800003EFC02483E4820483EFC0000
+B32B:0000000800087E08400E4008400E7E08000800001F08017F1F1C10221F1C0000
+B32C:0000000800087E08400E4008400E7E080008000003F802080208020803F80000
+B32D:0000000800087E08400E4008400E7E08000800000208020803F8020803F80000
+B32E:0000000800087E08400E4008400E7E0800080000110811081F0811141F620000
+B32F:0000000800087E08400E4008400E7E0800080000001000100010006801840000
+B330:0000000800087E08400E4008400E7E08000800000048004800A8011406620000
+B331:0000000800087E08400E4008400E7E0800080000000003F00408040803F00000
+B332:0000000800087E08400E4008400E7E080008000003F80020002000D003080000
+B333:0000000800087E08400E4008400E7E0800080000004003F8004000A003180000
+B334:0000000800087E08400E4008400E7E080008000003F8000803F8000800080000
+B335:0000000800087E08400E4008400E7E080008000003F8020003F8020003F80000
+B336:0000000800087E08400E4008400E7E080008000000000FF8022002200FF80000
+B337:0000000800087E08400E4008400E7E080008000000800FF803E0041003E00000
+B338:00000000001200127F924012401E40124012401E7F9200120012001200120000
+B339:0000002800287E284038402840387E280028000007F800080008000800080000
+B33A:0000002800287E284038402840387E280028000000003EF80208020802080000
+B33B:0000002800287E284038402840387E280028000000003E100210022802C40000
+B33C:0000002800287E284038402840387E280028002808000800080008000FF80000
+B33D:0000002800287E284038402840387E2800280000000020F8201020303ECC0000
+B33E:0000002800287E284038402840387E2800280000202021FC207020883E700000
+B33F:0000002800287E284038402840387E280028000003F802000200020003F80000
+B340:0000002800287E284038402840387E280028000007F8000807F8040007F80000
+B341:0000002800287E284038402840387E28002800003EF802083E0820083E080000
+B342:0000002800287E284038402840387E28002800003EF802883E8820883EF80000
+B343:0000002800287E284038402840387E28002800003E8802883EF820883EF80000
+B344:0000002800287E284038402840387E28002800001F0801081F0810141F620000
+B345:0000002800287E284038402840387E28002800003EF802803EF820803EF80000
+B346:0000002800287E284038402840387E28002800003EFC02483E4820483EFC0000
+B347:0000002800287E284038402840387E28002800003E1002FE3E3820443E380000
+B348:0000002800287E284038402840387E280028000003F802080208020803F80000
+B349:0000002800287E284038402840387E28002800000208020803F8020803F80000
+B34A:0000002800287E284038402840387E2800280000110811081F0811141F620000
+B34B:0000002800287E284038402840387E2800280000000800080008003400C20000
+B34C:0000002800287E284038402840387E28002800000048004800A8011406620000
+B34D:0000002800287E284038402840387E2800280000000001F00208020801F00000
+B34E:0000002800287E284038402840387E280028000003F80020002000D003080000
+B34F:0000002800287E284038402840387E2800280000004003F8004000A003180000
+B350:0000002800287E284038402840387E280028000003F8000803F8000800080000
+B351:0000002800287E284038402840387E280028000003F8020003F8020003F80000
+B352:0000002800287E284038402840387E280028000000000FF8022002200FF80000
+B353:0000002800287E284038402840387E280028000000800FF803E0041003E00000
+B354:00000000000200027F8240024002401E400240027F8200020002000200020000
+B355:0000000800087E084008403840087E0800080000000007F80008000800080000
+B356:0000000800087E084008403840087E080008000000003EF80208020802080000
+B357:0000000800087E084008403840087E080008000000001F080108011401620000
+B358:0000000800087E084008403840087E080008000000001000100010001FF80000
+B359:0000000800087E084008403840087E0800080000000020F8201020303ECC0000
+B35A:0000000800087E084008403840087E0800080000202021FC207020883E700000
+B35B:0000000800087E084008403840087E080008000003F802000200020003F80000
+B35C:0000000800087E084008403840087E080008000007F8000807F8040007F80000
+B35D:0000000800087E084008403840087E08000800003EF802083E0820083E080000
+B35E:0000000800087E084008403840087E08000800003EF802883E8820883EF80000
+B35F:0000000800087E084008403840087E08000800003E8802883EF820883EF80000
+B360:0000000800087E084008403840087E08000800000F8800880F8808140FA20000
+B361:0000000800087E084008403840087E08000800003EF802803EF820803EF80000
+B362:0000000800087E084008403840087E08000800003EFC02483E4820483EFC0000
+B363:0000000800087E084008403840087E08000800003E1002FE3E3820443E380000
+B364:0000000800087E084008403840087E080008000003F802080208020803F80000
+B365:0000000800087E084008403840087E08000800000208020803F8020803F80000
+B366:0000000800087E084008403840087E0800080000210821083F0821143F620000
+B367:0000000800087E084008403840087E0800080000001000100010006801840000
+B368:0000000800087E084008403840087E08000800000048004800A8011406620000
+B369:0000000800087E084008403840087E0800080000000003F00408040803F00000
+B36A:0000000800087E084008403840087E080008000003F80020002000D003080000
+B36B:0000000800087E084008403840087E0800080000004003F8004000A003180000
+B36C:0000000800087E084008403840087E080008000003F8000803F8000800080000
+B36D:0000000800087E084008403840087E080008000003F8020003F8020003F80000
+B36E:0000000800087E084008403840087E080008000000000FF8022002200FF80000
+B36F:0000000800087E084008403840087E080008000000800FF803E0041003E00000
+B370:00000000000A000A7F8A400A400A403A400A400A7F8A000A000A000A000A0000
+B371:0000002800287E28402840E840287E280028000007F800080008000800080000
+B372:0000002800287E28402840E840287E280028000000003EF80208020802080000
+B373:0000002800287E28402840E840287E280028000000003E100210022802C40000
+B374:0000002800287E28402840E840287E280028000008000800080008000FF80000
+B375:0000002800287E28402840E840287E2800280000000020F8201020303ECC0000
+B376:0000002800287E28402840E840287E2800280000202021FC207020883E700000
+B377:0000002800287E28402840E840287E280028000003F802000200020003F80000
+B378:0000002800287E28402840E840287E280028000007F8000807F8040007F80000
+B379:0000002800287E28402840E840287E28002800003EF802083E0820083E080000
+B37A:0000002800287E28402840E840287E28002800003EF802883E8820883EF80000
+B37B:0000002800287E28402840E840287E28002800003E8802883EF820883EF80000
+B37C:0000002800287E28402840E840287E28002800001F0801081F0810141F620000
+B37D:0000002800287E28402840E840287E28002800003EF802803EF820803EF80000
+B37E:0000002800287E28402840E840287E28002800003EFC02483E4820483EFC0000
+B37F:0000002800287E28402840E840287E28002800003E1002FE3E3820443E380000
+B380:0000002800287E28402840E840287E280028000003F802080208020803F80000
+B381:0000002800287E28402840E840287E28002800000208020803F8020803F80000
+B382:0000002800287E28402840E840287E2800280000110811081F0811141F620000
+B383:0000002800287E28402840E840287E2800280000000800080008003400C20000
+B384:0000002800287E28402840E840287E28002800000048004800A8011406620000
+B385:0000002800287E28402840E840287E2800280000000001F00208020801F00000
+B386:0000002800287E28402840E840287E280028000003F80020002000D003080000
+B387:0000002800287E28402840E840287E2800280000004003F8004000A003180000
+B388:0000002800287E28402840E840287E280028000003F8000803F8000800080000
+B389:0000002800287E28402840E840287E280028000003F8020003F8020003F80000
+B38A:0000002800287E28402840E840287E280028000000000FF8022002200FF80000
+B38B:0000002800287E28402840E840287E280028000000800FF803E0041003E00000
+B38C:00000000000200027F824002401E40024002401E7F8200020002000200020000
+B38D:0000000800087E084038400840387E0800080000000007F80008000800080000
+B38E:0000000800087E084038400840387E080008000000003EF80208020802080000
+B38F:0000000800087E084038400840387E080008000000001F080108011401620000
+B390:0000000800087E084038400840387E080008000800001000100010001FF80000
+B391:0000000800087E084038400840387E0800080000000020F8201020303ECC0000
+B392:0000000800087E084038400840387E0800080000202021FC207020883E700000
+B393:0000000800087E084038400840387E080008000003F802000200020003F80000
+B394:0000000800087E084038400840387E080008000007F8000807F8040007F80000
+B395:0000000800087E084038400840387E08000800003EF802083E0820083E080000
+B396:0000000800087E084038400840387E08000800003EF802883E8820883EF80000
+B397:0000000800087E084038400840387E08000800003E8802883EF820883EF80000
+B398:0000000800087E084038400840387E08000800000F8800880F8808140FA20000
+B399:0000000800087E084038400840387E08000800003EF802803EF820803EF80000
+B39A:0000000800087E084038400840387E08000800003EFC02483E4820483EFC0000
+B39B:0000000800087E084038400840387E08000800003E1002FE3E3820443E380000
+B39C:0000000800087E084038400840387E080008000003F802080208020803F80000
+B39D:0000000800087E084038400840387E08000800000208020803F8020803F80000
+B39E:0000000800087E084038400840387E0800080000210821083F0821143F620000
+B39F:0000000800087E084038400840387E0800080000001000100010006801840000
+B3A0:0000000800087E084038400840387E08000800000048004800A8011406620000
+B3A1:0000000800087E084038400840387E0800080000000003F00408040803F00000
+B3A2:0000000800087E084038400840387E080008000003F80020002000D003080000
+B3A3:0000000800087E084038400840387E0800080000004003F8004000A003180000
+B3A4:0000000800087E084038400840387E080008000003F8000803F8000800080000
+B3A5:0000000800087E084038400840387E080008000003F8020003F8020003F80000
+B3A6:0000000800087E084038400840387E080008000000000FF8022002200FF80000
+B3A7:0000000800087E084038400840387E080008000000800FF803E0041003E00000
+B3A8:00000000000A000A7F8A400A403A400A400A403A7F8A000A000A000A000A0000
+B3A9:0000002800287E2840E8402840E87E280028000007F800080008000800080000
+B3AA:0000002800287E2840E8402840E87E280028000000003EF80208020802080000
+B3AB:0000002800287E2840E8402840E87E280028000000003E100210022802C40000
+B3AC:0000002800287E2840E8402840E87E280028002808000800080008000FF80000
+B3AD:0000002800287E2840E8402840E87E2800280000000020F8201020303ECC0000
+B3AE:0000002800287E2840E8402840E87E2800280000202021FC207020883E700000
+B3AF:0000002800287E2840E8402840E87E280028000003F802000200020003F80000
+B3B0:0000002800287E2840E8402840E87E280028000007F8000807F8040007F80000
+B3B1:0000002800287E2840E8402840E87E28002800003EF802083E0820083E080000
+B3B2:0000002800287E2840E8402840E87E28002800003EF802883E8820883EF80000
+B3B3:0000002800287E2840E8402840E87E28002800003E8802883EF820883EF80000
+B3B4:0000002800287E2840E8402840E87E28002800001F0801081F0810141F620000
+B3B5:0000002800287E2840E8402840E87E28002800003EF802803EF820803EF80000
+B3B6:0000002800287E2840E8402840E87E28002800003EFC02483E4820483EFC0000
+B3B7:0000002800287E2840E8402840E87E28002800003E1002FE3E3820443E380000
+B3B8:0000002800287E2840E8402840E87E280028000003F802080208020803F80000
+B3B9:0000002800287E2840E8402840E87E28002800000208020803F8020803F80000
+B3BA:0000002800287E2840E8402840E87E2800280000110811081F0811141F620000
+B3BB:0000002800287E2840E8402840E87E2800280000000800080008003400C20000
+B3BC:0000002800287E2840E8402840E87E28002800000048004800A8011406620000
+B3BD:0000002800287E2840E8402840E87E2800280000000001F00208020801F00000
+B3BE:0000002800287E2840E8402840E87E280028000003F80020002000D003080000
+B3BF:0000002800287E2840E8402840E87E2800280000004003F8004000A003180000
+B3C0:0000002800287E2840E8402840E87E280028000003F8000803F8000800080000
+B3C1:0000002800287E2840E8402840E87E280028000003F8020003F8020003F80000
+B3C2:0000002800287E2840E8402840E87E280028000000000FF8022002200FF80000
+B3C3:0000002800287E2840E8402840E87E280028000000800FF803E0041003E00000
+B3C4:000000003FF820002000200020003FF8000000000100010001007FFC00000000
+B3C5:000000001FF0100010001FF0010001007FFC00001FF000100010001000100000
+B3C6:000000001FF0100010001FF0010001007FFC000000003EF80208020802080000
+B3C7:000000001FF0100010001FF0010001007FFC000000001E100210022802C40000
+B3C8:000000001FF0100010001FF0010001007FFC000000001000100010001FF00000
+B3C9:000000001FF0100010001FF0010001007FFC0000000020F8201020303ECC0000
+B3CA:000000001FF0100010001FF0010001007FFC0000202021FC207020883E700000
+B3CB:000000001FF0100010001FF0010001007FFC00001FF01000100010001FF00000
+B3CC:000000001FF0100010001FF0010001007FFC00001FF000101FF010001FF00000
+B3CD:000000001FF0100010001FF0010001007FFC00003EF802083E0820083E080000
+B3CE:000000001FF0100010001FF0010001007FFC00003EF802883E8820883EF80000
+B3CF:000000001FF0100010001FF0010001007FFC00003E8802883EF820883EF80000
+B3D0:000000001FF0100010001FF0010001007FFC00003E1002103E1020283EC40000
+B3D1:000000001FF0100010001FF0010001007FFC00003EF802803EF820803EF80000
+B3D2:000000001FF0100010001FF0010001007FFC00003EFC02483E4820483EFC0000
+B3D3:000000001FF0100010001FF0010001007FFC00003E2003FC3E7020883E700000
+B3D4:000000001FF0100010001FF0010001007FFC00001FF01010101010101FF00000
+B3D5:000000001FF0100010001FF0010001007FFC0000101010101FF010101FF00000
+B3D6:000000001FF0100010001FF0010001007FFC0000222022203E2022503E880000
+B3D7:000000001FF0100010001FF0010001007FFC000000000100010002800C400000
+B3D8:000000001FF0100010001FF0010001007FFC00000000024002400DA033100000
+B3D9:000000001FF0100010001FF0010001007FFC0000000007C00820082007C00000
+B3DA:000000001FF0100010001FF0010001007FFC0000000007E00080014006200000
+B3DB:000000001FF0100010001FF0010001007FFC0000008007E00080014006200000
+B3DC:000000001FF0100010001FF0010001007FFC00001FF000101FF0001000100000
+B3DD:000000001FF0100010001FF0010001007FFC00001FF010001FF010001FF00000
+B3DE:000000001FF0100010001FF0010001007FFC000000001FF0044004401FF00000
+B3DF:000000001FF0100010001FF0010001007FFC000001001FF007C0082007C00000
+B3E0:0000001000107F904010401040107F9E00100010041004107FD0001000100000
+B3E1:000000083F882008200E3F88040804087FE8000007F800080008000800080000
+B3E2:000000083F882008200E3F88040804087FE8000000003EF80208020802080000
+B3E3:000000083F882008200E3F88040804087FE8000000001F080108011401620000
+B3E4:000000083F882008200E3F88040804087FE8000008000800080008000FF80000
+B3E5:000000083F882008200E3F88040804087FE80000000010F8101010301ECC0000
+B3E6:000000083F882008200E3F88040804087FE800000808087F081C08220F9C0000
+B3E7:000000083F882008200E3F88040804087FE8000003F802000200020003F80000
+B3E8:000000083F882008200E3F88040804087FE8000007F8000807F8040007F80000
+B3E9:000000083F882008200E3F88040804087FE800003EF802083E0820083E080000
+B3EA:000000083F882008200E3F88040804087FE800003EF802883E8820883EF80000
+B3EB:000000083F882008200E3F88040804087FE800003E8802883EF820883EF80000
+B3EC:000000083F882008200E3F88040804087FE800001F0801081F0810141F620000
+B3ED:000000083F882008200E3F88040804087FE800003EF802803EF820803EF80000
+B3EE:000000083F882008200E3F88040804087FE800003EFC02483E4820483EFC0000
+B3EF:000000083F882008200E3F88040804087FE800001F08017F1F1C10221F1C0000
+B3F0:000000083F882008200E3F88040804087FE8000003F802080208020803F80000
+B3F1:000000083F882008200E3F88040804087FE800000208020803F8020803F80000
+B3F2:000000083F882008200E3F88040804087FE80000110811081F0811141F620000
+B3F3:000000083F882008200E3F88040804087FE80000001000100010006801840000
+B3F4:000000083F882008200E3F88040804087FE800000048004800A8011406620000
+B3F5:000000083F882008200E3F88040804087FE80000000003F00408040803F00000
+B3F6:000000083F882008200E3F88040804087FE8000003F80020002000D003080000
+B3F7:000000083F882008200E3F88040804087FE80000004003F8004000A003180000
+B3F8:000000083F882008200E3F88040804087FE8000003F8000803F8000800080000
+B3F9:000000083F882008200E3F88040804087FE8000003F8020003F8020003F80000
+B3FA:000000083F882008200E3F88040804087FE8000000000FF8022002200FF80000
+B3FB:000000083F882008200E3F88040804087FE8000000800FF803E0041003E00000
+B3FC:0000001200127F924012401240127F9E00120012041204127FD2001200120000
+B3FD:000000283FA8202820383FA8042804287FA8000007F800080008000800080000
+B3FE:000000283FA8202820383FA8042804287FA8000000003EF80208020802080000
+B3FF:000000283FA8202820383FA8042804287FA8000000001F080108011401620000
+B400:000000283FA8202820383FA8042804287FA8000008000800080008000FF80000
+B401:000000283FA8202820383FA8042804287FA80000000010F8101010301ECC0000
+B402:000000283FA8202820383FA8042804287FA800000808087F081C08220F9C0000
+B403:000000283FA8202820383FA8042804287FA8000003F802000200020003F80000
+B404:000000283FA8202820383FA8042804287FA8000007F8000807F8040007F80000
+B405:000000283FA8202820383FA8042804287FA800003EF802083E0820083E080000
+B406:000000283FA8202820383FA8042804287FA800003EF802883E8820883EF80000
+B407:000000283FA8202820383FA8042804287FA800003E8802883EF820883EF80000
+B408:000000283FA8202820383FA8042804287FA800001F0801081F0810141F620000
+B409:000000283FA8202820383FA8042804287FA800003EF802803EF820803EF80000
+B40A:000000283FA8202820383FA8042804287FA800003EFC02483E4820483EFC0000
+B40B:000000283FA8202820383FA8042804287FA800001F08017F1F1C10221F1C0000
+B40C:000000283FA8202820383FA8042804287FA8000003F802080208020803F80000
+B40D:000000283FA8202820383FA8042804287FA800000208020803F8020803F80000
+B40E:000000283FA8202820383FA8042804287FA80000110811081F0811141F620000
+B40F:000000283FA8202820383FA8042804287FA80000001000100010006801840000
+B410:000000283FA8202820383FA8042804287FA800000048004800A8011406620000
+B411:000000283FA8202820383FA8042804287FA80000000003F00408040803F00000
+B412:000000283FA8202820383FA8042804287FA8000003F80020002000D003080000
+B413:000000283FA8202820383FA8042804287FA80000004003F8004000A003180000
+B414:000000283FA8202820383FA8042804287FA8000003F8000803F8000800080000
+B415:000000283FA8202820383FA8042804287FA8000003F8020003F8020003F80000
+B416:000000283FA8202820383FA8042804287FA8000000000FF8022002200FF80000
+B417:000000283FA8202820383FA8042804287FA8000000800FF803E0041003E00000
+B418:0000000800087F884008400840087F8800080008040804087FE8000800080000
+B419:000000083F88200820083F88040804087FE8000007F800080008000800080000
+B41A:000000083F88200820083F88040804087FE8000000003EF80208020802080000
+B41B:000000083F88200820083F88040804087FE8000000001F080108011401620000
+B41C:000000083F88200820083F88040804087FE8000008000800080008000FF80000
+B41D:000000083F88200820083F88040804087FE80000000010F8101010301ECC0000
+B41E:000000083F88200820083F88040804087FE800000808087F081C08220F9C0000
+B41F:000000083F88200820083F88040804087FE8000003F802000200020003F80000
+B420:000000083F88200820083F88040804087FE8000007F8000807F8040007F80000
+B421:000000083F88200820083F88040804087FE800003EF802083E0820083E080000
+B422:000000083F88200820083F88040804087FE800003EF802883E8820883EF80000
+B423:000000083F88200820083F88040804087FE800003E8802883EF820883EF80000
+B424:000000083F88200820083F88040804087FE800001F0801081F0810141F620000
+B425:000000083F88200820083F88040804087FE800003EF802803EF820803EF80000
+B426:000000083F88200820083F88040804087FE800003EFC02483E4820483EFC0000
+B427:000000083F88200820083F88040804087FE800001F08017F1F1C10221F1C0000
+B428:000000083F88200820083F88040804087FE8000003F802080208020803F80000
+B429:000000083F88200820083F88040804087FE800000208020803F8020803F80000
+B42A:000000083F88200820083F88040804087FE80000110811081F0811141F620000
+B42B:000000083F88200820083F88040804087FE80000001000100010006801840000
+B42C:000000083F88200820083F88040804087FE800000048004800A8011406620000
+B42D:000000083F88200820083F88040804087FE80000000003F00408040803F00000
+B42E:000000083F88200820083F88040804087FE8000003F80020002000D003080000
+B42F:000000083F88200820083F88040804087FE80000004003F8004000A003180000
+B430:000000083F88200820083F88040804087FE8000003F8000803F8000800080000
+B431:000000083F88200820083F88040804087FE8000003F8020003F8020003F80000
+B432:000000083F88200820083F88040804087FE8000000000FF8022002200FF80000
+B433:000000083F88200820083F88040804087FE8000000800FF803E0041003E00000
+B434:000000003FF820002000200020003FF8000004400440044004407FFC00000000
+B435:000000001FF0100010001FF0044004407FFC00001FF000100010001000100000
+B436:000000001FF0100010001FF0044004407FFC000000003EF80208020802080000
+B437:000000001FF0100010001FF0044004407FFC000000001E100210022802C40000
+B438:000000001FF0100010001FF0044004407FFC000000001000100010001FF00000
+B439:000000001FF0100010001FF0044004407FFC0000000020F8201020303ECC0000
+B43A:000000001FF0100010001FF0044004407FFC0000202021FC207020883E700000
+B43B:000000001FF0100010001FF0044004407FFC00001FF01000100010001FF00000
+B43C:000000001FF0100010001FF0044004407FFC00001FF000101FF010001FF00000
+B43D:000000001FF0100010001FF0044004407FFC00003EF802083E0820083E080000
+B43E:000000001FF0100010001FF0044004407FFC00003EF802883E8820883EF80000
+B43F:000000001FF0100010001FF0044004407FFC00003E8802883EF820883EF80000
+B440:000000001FF0100010001FF0044004407FFC00003E1002103E1020283EC40000
+B441:000000001FF0100010001FF0044004407FFC00003EF802803EF820803EF80000
+B442:000000001FF0100010001FF0044004407FFC00003EFC02483E4820483EFC0000
+B443:000000001FF0100010001FF0044004407FFC00003E2003FC3E7020883E700000
+B444:000000001FF0100010001FF0044004407FFC00001FF01010101010101FF00000
+B445:000000001FF0100010001FF0044004407FFC0000101010101FF010101FF00000
+B446:000000001FF0100010001FF0044004407FFC0000222022203E2022503E880000
+B447:000000001FF0100010001FF0044004407FFC000000000100010002800C400000
+B448:000000001FF0100010001FF0044004407FFC00000000024002400DA033100000
+B449:000000001FF0100010001FF0044004407FFC0000000007C00820082007C00000
+B44A:000000001FF0100010001FF0044004407FFC0000000007E00080014006200000
+B44B:000000001FF0100010001FF0044004407FFC0000008007E00080014006200000
+B44C:000000001FF0100010001FF0044004407FFC00001FF000101FF0001000100000
+B44D:000000001FF0100010001FF0044004407FFC00001FF010001FF010001FF00000
+B44E:000000001FF0100010001FF0044004407FFC000000001FF0044004401FF00000
+B44F:000000001FF0100010001FF0044004407FFC000001001FF007C0082007C00000
+B450:000000003FF820002000200020003FF8000000003FF801000100010001000000
+B451:000000001FF0100010001FF000007FFC010001001FF000100010001000100000
+B452:000000001FF0100010001FF000007FFC0100010000003EF80208020802080000
+B453:000000001FF0100010001FF000007FFC0100010000001E100210022802C40000
+B454:000000001FF0100010001FF0000000007FFC010001001100100010001FF00000
+B455:000000001FF0100010001FF000007FFC01000100000020F8201020303ECC0000
+B456:000000001FF0100010001FF000007FFC01000100202021FC207020883E700000
+B457:000000001FF0100010001FF000007FFC010001001FF01000100010001FF00000
+B458:000000001FF0100010001FF000007FFC010001001FF000101FF010001FF00000
+B459:000000001FF0100010001FF000007FFC010001003EF802083E0820083E080000
+B45A:000000001FF0100010001FF000007FFC010001003EF802883E8820883EF80000
+B45B:000000001FF0100010001FF000007FFC010001003E8802883EF820883EF80000
+B45C:000000001FF0100010001FF000007FFC010001003E1002103E1020283EC40000
+B45D:000000001FF0100010001FF000007FFC010001003EF802803EF820803EF80000
+B45E:000000001FF0100010001FF000007FFC010001003EFC02483E4820483EFC0000
+B45F:000000001FF0100010001FF000007FFC010001003E2003FC3E7020883E700000
+B460:000000001FF0100010001FF000007FFC010001001FF01010101010101FF00000
+B461:000000001FF0100010001FF000007FFC01000100101010101FF010101FF00000
+B462:000000001FF0100010001FF000007FFC01000100222022203E2022503E880000
+B463:000000001FF0100010001FF000007FFC0100010000000100010002800C400000
+B464:000000001FF0100010001FF000007FFC010001000000024002400DA033100000
+B465:000000001FF0100010001FF000007FFC01000100000007C00820082007C00000
+B466:000000001FF0100010001FF000007FFC01000100000007E00080014006200000
+B467:000000001FF0100010001FF000007FFC01000100008007E00080014006200000
+B468:000000001FF0100010001FF000007FFC010001001FF000101FF0001000100000
+B469:000000001FF0100010001FF000007FFC010001001FF010001FF010001FF00000
+B46A:000000001FF0100010001FF000007FFC0100010000001FF0044004401FF00000
+B46B:000000001FF0100010001FF000007FFC0100010001001FF007C0082007C00000
+B46C:0000000800087FC84008400840087FC8000800087FE8040804F8040804080000
+B46D:00083F88200820083F8800087FE8027802080000000007F80008000800080000
+B46E:00083F88200820083F8800087FE802780208000000003EF80208020802080000
+B46F:00083F88200820083F8800087FE802780208000000001F080108011401620000
+B470:00083F88200820083F88000800087FE80278020802081000100010001FF80000
+B471:00083F88200820083F8800087FE8027802080000000020F8201020303ECC0000
+B472:00083F88200820083F8800087FE8027802080000202021FC207020883E700000
+B473:00083F88200820083F8800087FE802780208000003F802000200020003F80000
+B474:00083F88200820083F8800087FE802780208000007F8000807F8040007F80000
+B475:00083F88200820083F8800087FE80278020800003EF802083E0820083E080000
+B476:00083F88200820083F8800087FE80278020800003EF802883E8820883EF80000
+B477:00083F88200820083F8800087FE80278020800003E8802883EF820883EF80000
+B478:00083F88200820083F8800087FE80278020800000F8800880F8808140FA20000
+B479:00083F88200820083F8800087FE80278020800003EF802803EF820803EF80000
+B47A:00083F88200820083F8800087FE80278020800003EFC02483E4820483EFC0000
+B47B:00083F88200820083F8800087FE80278020800003E1002FE3E3820443E380000
+B47C:00083F88200820083F8800087FE802780208000003F802080208020803F80000
+B47D:00083F88200820083F8800087FE80278020800000208020803F8020803F80000
+B47E:00083F88200820083F8800087FE8027802080000210821083F0821143F620000
+B47F:00083F88200820083F8800087FE8027802080000001000100010006801840000
+B480:00083F88200820083F8800087FE80278020800000048004800A8011406620000
+B481:00083F88200820083F8800087FE8027802080000000003F00408040803F00000
+B482:00083F88200820083F8800087FE802780208000003F80020002000D003080000
+B483:00083F88200820083F8800087FE8027802080000004003F8004000A003180000
+B484:00083F88200820083F8800087FE802780208000003F8000803F8000800080000
+B485:00083F88200820083F8800087FE802780208000003F8020003F8020003F80000
+B486:00083F88200820083F8800087FE802780208000000000FF8022002200FF80000
+B487:00083F88200820083F8800087FE802780208000000800FF803E0041003E00000
+B488:0000000A000A7FCA400A400A400A7FCA000A000A7FEA040A047A040A040A0000
+B489:00283FA8202820283FA800287FA805E804280000000007F80008000800080000
+B48A:00283FA8202820283FA800287FA805E80428000000003EF80208020802080000
+B48B:00283FA8202820283FA800287FA805E80428000000001F080108011401620000
+B48C:00283FA8202820283FA8002800287FA8042805E804281428100010001FF80000
+B48D:00283FA8202820283FA800287FA805E804280000000020F8201020303ECC0000
+B48E:00283FA8202820283FA800287FA805E804280000202021FC207020883E700000
+B48F:00283FA8202820283FA800287FA805E80428000003F802000200020003F80000
+B490:00283FA8202820283FA800287FA805E80428000007F8000807F8040007F80000
+B491:00283FA8202820283FA800287FA805E8042800003EF802083E0820083E080000
+B492:00283FA8202820283FA800287FA805E8042800003EF802883E8820883EF80000
+B493:00283FA8202820283FA800287FA805E8042800003E8802883EF820883EF80000
+B494:00283FA8202820283FA800287FA805E8042800000F8800880F8808140FA20000
+B495:00283FA8202820283FA800287FA805E8042800003EF802803EF820803EF80000
+B496:00283FA8202820283FA800287FA805E8042800003EFC02483E4820483EFC0000
+B497:00283FA8202820283FA800287FA805E8042800003E1002FE3E3820443E380000
+B498:00283FA8202820283FA800287FA805E80428000003F802080208020803F80000
+B499:00283FA8202820283FA800287FA805E8042800000208020803F8020803F80000
+B49A:00283FA8202820283FA800287FA805E804280000210821083F0821143F620000
+B49B:00283FA8202820283FA800287FA805E804280000001000100010006801840000
+B49C:00283FA8202820283FA800287FA805E8042800000048004800A8011406620000
+B49D:00283FA8202820283FA800287FA805E804280000000003F00408040803F00000
+B49E:00283FA8202820283FA800287FA805E80428000003F80020002000D003080000
+B49F:00283FA8202820283FA800287FA805E804280000004003F8004000A003180000
+B4A0:00283FA8202820283FA800287FA805E80428000003F8000803F8000800080000
+B4A1:00283FA8202820283FA800287FA805E80428000003F8020003F8020003F80000
+B4A2:00283FA8202820283FA800287FA805E80428000000000FF8022002200FF80000
+B4A3:00283FA8202820283FA800287FA805E80428000000800FF803E0041003E00000
+B4A4:0000000800087FC84008400840087FC8000800087FE804080408040804080000
+B4A5:00083F88200820083F8800087FE8020802000000000007F80008000800080000
+B4A6:00083F88200820083F8800087FE802080200000000003EF80208020802080000
+B4A7:00083F88200820083F8800087FE802080200000000001F080108011401620000
+B4A8:00083F88200820083F88000800087FE80208020802081008100010001FF80000
+B4A9:00083F88200820083F8800087FE8020802000000000020F8201020303ECC0000
+B4AA:00083F88200820083F8800087FE8020802000000202021FC207020883E700000
+B4AB:00083F88200820083F8800087FE802080200000003F802000200020003F80000
+B4AC:00083F88200820083F8800087FE802080200000007F8000807F8040007F80000
+B4AD:00083F88200820083F8800087FE80208020000003EF802083E0820083E080000
+B4AE:00083F88200820083F8800087FE80208020000003EF802883E8820883EF80000
+B4AF:00083F88200820083F8800087FE80208020000003E8802883EF820883EF80000
+B4B0:00083F88200820083F8800087FE80208020000000F8800880F8808140FA20000
+B4B1:00083F88200820083F8800087FE80208020000003EF802803EF820803EF80000
+B4B2:00083F88200820083F8800087FE80208020000003EFC02483E4820483EFC0000
+B4B3:00083F88200820083F8800087FE80208020000003E1002FE3E3820443E380000
+B4B4:00083F88200820083F8800087FE802080200000003F802080208020803F80000
+B4B5:00083F88200820083F8800087FE80208020000000208020803F8020803F80000
+B4B6:00083F88200820083F8800087FE8020802000000210821083F0821143F620000
+B4B7:00083F88200820083F8800087FE8020802000000001000100010006801840000
+B4B8:00083F88200820083F8800087FE80208020000000048004800A8011406620000
+B4B9:00083F88200820083F8800087FE8020802000000000003F00408040803F00000
+B4BA:00083F88200820083F8800087FE802080200000003F80020002000D003080000
+B4BB:00083F88200820083F8800087FE8020802000000004003F8004000A003180000
+B4BC:00083F88200820083F8800087FE802080200000003F8000803F8000800080000
+B4BD:00083F88200820083F8800087FE802080200000003F8020003F8020003F80000
+B4BE:00083F88200820083F8800087FE802080200000000000FF8022002200FF80000
+B4BF:00083F88200820083F8800087FE802080200000000800FF803E0041003E00000
+B4C0:000000003FF820002000200020003FF8000000007FFC04400440044004400000
+B4C1:000000001FF0100010001FF000007FFC044004401FF000100010001000100000
+B4C2:000000001FF0100010001FF000007FFC0440044000003EF80208020802080000
+B4C3:000000001FF0100010001FF000007FFC0440044000001E100210022802C40000
+B4C4:000000001FF0100010001FF0000000007FFC044004401440100010001FF00000
+B4C5:000000001FF0100010001FF000007FFC04400440000020F8201020303ECC0000
+B4C6:000000001FF0100010001FF000007FFC04400440202021FC207020883E700000
+B4C7:000000001FF0100010001FF000007FFC044004401FF01000100010001FF00000
+B4C8:000000001FF0100010001FF000007FFC044004401FF000101FF010001FF00000
+B4C9:000000001FF0100010001FF000007FFC044004403EF802083E0820083E080000
+B4CA:000000001FF0100010001FF000007FFC044004403EF802883E8820883EF80000
+B4CB:000000001FF0100010001FF000007FFC044004403E8802883EF820883EF80000
+B4CC:000000001FF0100010001FF000007FFC044004403E1002103E1020283EC40000
+B4CD:000000001FF0100010001FF000007FFC044004403EF802803EF820803EF80000
+B4CE:000000001FF0100010001FF000007FFC044004403EFC02483E4820483EFC0000
+B4CF:000000001FF0100010001FF000007FFC044004403E2003FC3E7020883E700000
+B4D0:000000001FF0100010001FF000007FFC044004401FF01010101010101FF00000
+B4D1:000000001FF0100010001FF000007FFC04400440101010101FF010101FF00000
+B4D2:000000001FF0100010001FF000007FFC04400440222022203E2022503E880000
+B4D3:000000001FF0100010001FF000007FFC0440044000000100010002800C400000
+B4D4:000000001FF0100010001FF000007FFC044004400000024002400DA033100000
+B4D5:000000001FF0100010001FF000007FFC04400440000007C00820082007C00000
+B4D6:000000001FF0100010001FF000007FFC04400440000007E00080014006200000
+B4D7:000000001FF0100010001FF000007FFC04400440008007E00080014006200000
+B4D8:000000001FF0100010001FF000007FFC044004401FF000101FF0001000100000
+B4D9:000000001FF0100010001FF000007FFC044004401FF010001FF010001FF00000
+B4DA:000000001FF0100010001FF000007FFC0440044000001FF0044004401FF00000
+B4DB:000000001FF0100010001FF000007FFC0440044001001FF007C0082007C00000
+B4DC:000000003FF820002000200020003FF80000000000007FFC0000000000000000
+B4DD:000000001FF0100010001FF0000000007FFC00001FF000100010001000100000
+B4DE:000000001FF0100010001FF0000000007FFC000000003EF80208020802080000
+B4DF:000000001FF0100010001FF0000000007FFC000000001E100210022802C40000
+B4E0:000000001FF0100010001FF0000000007FFC000000001000100010001FF00000
+B4E1:000000001FF0100010001FF0000000007FFC0000000020F8201020303ECC0000
+B4E2:000000001FF0100010001FF0000000007FFC0000202021FC207020883E700000
+B4E3:000000001FF0100010001FF0000000007FFC00001FF01000100010001FF00000
+B4E4:000000001FF0100010001FF0000000007FFC00001FF000101FF010001FF00000
+B4E5:000000001FF0100010001FF0000000007FFC00003EF802083E0820083E080000
+B4E6:000000001FF0100010001FF0000000007FFC00003EF802883E8820883EF80000
+B4E7:000000001FF0100010001FF0000000007FFC00003E8802883EF820883EF80000
+B4E8:000000001FF0100010001FF0000000007FFC00003E1002103E1020283EC40000
+B4E9:000000001FF0100010001FF0000000007FFC00003EF802803EF820803EF80000
+B4EA:000000001FF0100010001FF0000000007FFC00003EFC02483E4820483EFC0000
+B4EB:000000001FF0100010001FF0000000007FFC00003E2003FC3E7020883E700000
+B4EC:000000001FF0100010001FF0000000007FFC00001FF01010101010101FF00000
+B4ED:000000001FF0100010001FF0000000007FFC0000101010101FF010101FF00000
+B4EE:000000001FF0100010001FF0000000007FFC0000222022203E2022503E880000
+B4EF:000000001FF0100010001FF0000000007FFC000000000100010002800C400000
+B4F0:000000001FF0100010001FF0000000007FFC00000000024002400DA033100000
+B4F1:000000001FF0100010001FF0000000007FFC0000000007C00820082007C00000
+B4F2:000000001FF0100010001FF0000000007FFC0000000007E00080014006200000
+B4F3:000000001FF0100010001FF0000000007FFC0000008007E00080014006200000
+B4F4:000000001FF0100010001FF0000000007FFC00001FF000101FF0001000100000
+B4F5:000000001FF0100010001FF0000000007FFC00001FF010001FF010001FF00000
+B4F6:000000001FF0100010001FF0000000007FFC000000001FF0044004401FF00000
+B4F7:000000001FF0100010001FF0000000007FFC000001001FF007C0082007C00000
+B4F8:0000000800087F884008400840087F880008000800087FE80008000800080000
+B4F9:000000083F88200820083F88000800087FE8000007F800080008000800080000
+B4FA:000000083F88200820083F88000800087FE8000000003EF80208020802080000
+B4FB:000000083F88200820083F88000800087FE8000000001F080108011401620000
+B4FC:000000083F88200820083F88000800087FE8000008000800080008000FF80000
+B4FD:000000083F88200820083F88000800087FE80000000010F8101010301ECC0000
+B4FE:000000083F88200820083F88000800087FE800000808087F081C08220F9C0000
+B4FF:000000083F88200820083F88000800087FE8000003F802000200020003F80000
+B500:000000083F88200820083F88000800087FE8000007F8000807F8040007F80000
+B501:000000083F88200820083F88000800087FE800003EF802083E0820083E080000
+B502:000000083F88200820083F88000800087FE800003EF802883E8820883EF80000
+B503:000000083F88200820083F88000800087FE800003E8802883EF820883EF80000
+B504:000000083F88200820083F88000800087FE800001F0801081F0810141F620000
+B505:000000083F88200820083F88000800087FE800003EF802803EF820803EF80000
+B506:000000083F88200820083F88000800087FE800003EFC02483E4820483EFC0000
+B507:000000083F88200820083F88000800087FE800001F08017F1F1C10221F1C0000
+B508:000000083F88200820083F88000800087FE8000003F802080208020803F80000
+B509:000000083F88200820083F88000800087FE800000208020803F8020803F80000
+B50A:000000083F88200820083F88000800087FE80000110811081F0811141F620000
+B50B:000000083F88200820083F88000800087FE80000001000100010006801840000
+B50C:000000083F88200820083F88000800087FE800000048004800A8011406620000
+B50D:000000083F88200820083F88000800087FE80000000003F00408040803F00000
+B50E:000000083F88200820083F88000800087FE8000003F80020002000D003080000
+B50F:000000083F88200820083F88000800087FE80000004003F8004000A003180000
+B510:000000083F88200820083F88000800087FE8000003F8000803F8000800080000
+B511:000000083F88200820083F88000800087FE8000003F8020003F8020003F80000
+B512:000000083F88200820083F88000800087FE8000000000FF8022002200FF80000
+B513:000000083F88200820083F88000800087FE8000000800FF803E0041003E00000
+B514:00000000000800087F88400840084008400840087F8800080008000800080000
+B515:0000000800087E084008400840087E0800080000000007F80008000800080000
+B516:0000000800087E084008400840087E080008000000003EF80208020802080000
+B517:0000000800087E084008400840087E080008000000001F080108011401620000
+B518:0000000800087E084008400840087E080008000800001000100010001FF80000
+B519:0000000800087E084008400840087E0800080000000020F8201020303ECC0000
+B51A:0000000800087E084008400840087E0800080000202021FC207020883E700000
+B51B:0000000800087E084008400840087E080008000003F802000200020003F80000
+B51C:0000000800087E084008400840087E080008000007F8000807F8040007F80000
+B51D:0000000800087E084008400840087E08000800003EF802083E0820083E080000
+B51E:0000000800087E084008400840087E08000800003EF802883E8820883EF80000
+B51F:0000000800087E084008400840087E08000800003E8802883EF820883EF80000
+B520:0000000800087E084008400840087E08000800000F8800880F8808140FA20000
+B521:0000000800087E084008400840087E08000800003EF802803EF820803EF80000
+B522:0000000800087E084008400840087E08000800003EFC02483E4820483EFC0000
+B523:0000000800087E084008400840087E08000800003E1002FE3E3820443E380000
+B524:0000000800087E084008400840087E080008000003F802080208020803F80000
+B525:0000000800087E084008400840087E08000800000208020803F8020803F80000
+B526:0000000800087E084008400840087E0800080000210821083F0821143F620000
+B527:0000000800087E084008400840087E0800080000001000100010006801840000
+B528:0000000800087E084008400840087E08000800000048004800A8011406620000
+B529:0000000800087E084008400840087E0800080000000003F00408040803F00000
+B52A:0000000800087E084008400840087E080008000003F80020002000D003080000
+B52B:0000000800087E084008400840087E0800080000004003F8004000A003180000
+B52C:0000000800087E084008400840087E080008000003F8000803F8000800080000
+B52D:0000000800087E084008400840087E080008000003F8020003F8020003F80000
+B52E:0000000800087E084008400840087E080008000000000FF8022002200FF80000
+B52F:0000000800087E084008400840087E080008000000800FF803E0041003E00000
+B530:00000000001000107BD042104210421E421042107BD000100010001000100000
+B531:00000008000877084408440E440877080008000007F800080008000800080000
+B532:00000008000877084408440E440877080008000000003EF80208020802080000
+B533:00000008000877084408440E440877080008000000001F080108011401620000
+B534:00000008000877084408440E440877080008000808000800080008000FF80000
+B535:00000008000877084408440E4408770800080000000010F8101010301ECC0000
+B536:00000008000877084408440E44087708000800000808087F081C08220F9C0000
+B537:00000008000877084408440E440877080008000003F802000200020003F80000
+B538:00000008000877084408440E440877080008000007F8000807F8040007F80000
+B539:00000008000877084408440E44087708000800003EF802083E0820083E080000
+B53A:00000008000877084408440E44087708000800003EF802883E8820883EF80000
+B53B:00000008000877084408440E44087708000800003E8802883EF820883EF80000
+B53C:00000008000877084408440E44087708000800001F0801081F0810141F620000
+B53D:00000008000877084408440E44087708000800003EF802803EF820803EF80000
+B53E:00000008000877084408440E44087708000800003EFC02483E4820483EFC0000
+B53F:00000008000877084408440E44087708000800001F08017F1F1C10221F1C0000
+B540:00000008000877084408440E440877080008000003F802080208020803F80000
+B541:00000008000877084408440E44087708000800000208020803F8020803F80000
+B542:00000008000877084408440E4408770800080000110811081F0811141F620000
+B543:00000008000877084408440E4408770800080000001000100010006801840000
+B544:00000008000877084408440E44087708000800000048004800A8011406620000
+B545:00000008000877084408440E4408770800080000000003F00408040803F00000
+B546:00000008000877084408440E440877080008000003F80020002000D003080000
+B547:00000008000877084408440E4408770800080000004003F8004000A003180000
+B548:00000008000877084408440E440877080008000003F8000803F8000800080000
+B549:00000008000877084408440E440877080008000003F8020003F8020003F80000
+B54A:00000008000877084408440E440877080008000000000FF8022002200FF80000
+B54B:00000008000877084408440E440877080008000000800FF803E0041003E00000
+B54C:00000000001200127BD242124212421E421242127BD200120012001200120000
+B54D:000000280028772844284438442877280028000007F800080008000800080000
+B54E:000000280028772844284438442877280028000000003EF80208020802080000
+B54F:000000280028772844284438442877280028000000003E100210022802C40000
+B550:000000280028772844284438442877280028002808000800080008000FF80000
+B551:0000002800287728442844384428772800280000000020F8201020303ECC0000
+B552:0000002800287728442844384428772800280000202021FC207020883E700000
+B553:000000280028772844284438442877280028000003F802000200020003F80000
+B554:000000280028772844284438442877280028000007F8000807F8040007F80000
+B555:00000028002877284428443844287728002800003EF802083E0820083E080000
+B556:00000028002877284428443844287728002800003EF802883E8820883EF80000
+B557:00000028002877284428443844287728002800003E8802883EF820883EF80000
+B558:00000028002877284428443844287728002800001F0801081F0810141F620000
+B559:00000028002877284428443844287728002800003EF802803EF820803EF80000
+B55A:00000028002877284428443844287728002800003EFC02483E4820483EFC0000
+B55B:00000028002877284428443844287728002800003E1002FE3E3820443E380000
+B55C:000000280028772844284438442877280028000003F802080208020803F80000
+B55D:00000028002877284428443844287728002800000208020803F8020803F80000
+B55E:0000002800287728442844384428772800280000110811081F0811141F620000
+B55F:0000002800287728442844384428772800280000000800080008003400C20000
+B560:00000028002877284428443844287728002800000048004800A8011406620000
+B561:0000002800287728442844384428772800280000000001F00208020801F00000
+B562:000000280028772844284438442877280028000003F80020002000D003080000
+B563:0000002800287728442844384428772800280000004003F8004000A003180000
+B564:000000280028772844284438442877280028000003F8000803F8000800080000
+B565:000000280028772844284438442877280028000003F8020003F8020003F80000
+B566:000000280028772844284438442877280028000000000FF8022002200FF80000
+B567:000000280028772844284438442877280028000000800FF803E0041003E00000
+B568:00000000001000107BD04210421E42104210421E7BD000100010001000100000
+B569:0000000800087708440E4408440E77080008000007F800080008000800080000
+B56A:0000000800087708440E4408440E77080008000000003EF80208020802080000
+B56B:0000000800087708440E4408440E77080008000000001F080108011401620000
+B56C:0000000800087708440E4408440E77080008000008000800080008000FF80000
+B56D:0000000800087708440E4408440E770800080000000010F8101010301ECC0000
+B56E:0000000800087708440E4408440E7708000800000808087F081C08220F9C0000
+B56F:0000000800087708440E4408440E77080008000003F802000200020003F80000
+B570:0000000800087708440E4408440E77080008000007F8000807F8040007F80000
+B571:0000000800087708440E4408440E7708000800003EF802083E0820083E080000
+B572:0000000800087708440E4408440E7708000800003EF802883E8820883EF80000
+B573:0000000800087708440E4408440E7708000800003E8802883EF820883EF80000
+B574:0000000800087708440E4408440E7708000800001F0801081F0810141F620000
+B575:0000000800087708440E4408440E7708000800003EF802803EF820803EF80000
+B576:0000000800087708440E4408440E7708000800003EFC02483E4820483EFC0000
+B577:0000000800087708440E4408440E7708000800001F08017F1F1C10221F1C0000
+B578:0000000800087708440E4408440E77080008000003F802080208020803F80000
+B579:0000000800087708440E4408440E7708000800000208020803F8020803F80000
+B57A:0000000800087708440E4408440E770800080000110811081F0811141F620000
+B57B:0000000800087708440E4408440E770800080000001000100010006801840000
+B57C:0000000800087708440E4408440E7708000800000048004800A8011406620000
+B57D:0000000800087708440E4408440E770800080000000003F00408040803F00000
+B57E:0000000800087708440E4408440E77080008000003F80020002000D003080000
+B57F:0000000800087708440E4408440E770800080000004003F8004000A003180000
+B580:0000000800087708440E4408440E77080008000003F8000803F8000800080000
+B581:0000000800087708440E4408440E77080008000003F8020003F8020003F80000
+B582:0000000800087708440E4408440E77080008000000000FF8022002200FF80000
+B583:0000000800087708440E4408440E77080008000000800FF803E0041003E00000
+B584:00000000001200127BD24212421E42124212421E7BD200120012001200120000
+B585:000000280028772844384428443877280028000007F800080008000800080000
+B586:000000280028772844384428443877280028000000003EF80208020802080000
+B587:000000280028772844384428443877280028000000003E100210022802C40000
+B588:000000280028772844384428443877280028002808000800080008000FF80000
+B589:0000002800287728443844284438772800280000000020F8201020303ECC0000
+B58A:0000002800287728443844284438772800280000202021FC207020883E700000
+B58B:000000280028772844384428443877280028000003F802000200020003F80000
+B58C:000000280028772844384428443877280028000007F8000807F8040007F80000
+B58D:00000028002877284438442844387728002800003EF802083E0820083E080000
+B58E:00000028002877284438442844387728002800003EF802883E8820883EF80000
+B58F:00000028002877284438442844387728002800003E8802883EF820883EF80000
+B590:00000028002877284438442844387728002800001F0801081F0810141F620000
+B591:00000028002877284438442844387728002800003EF802803EF820803EF80000
+B592:00000028002877284438442844387728002800003EFC02483E4820483EFC0000
+B593:00000028002877284438442844387728002800003E1002FE3E3820443E380000
+B594:000000280028772844384428443877280028000003F802080208020803F80000
+B595:00000028002877284438442844387728002800000208020803F8020803F80000
+B596:0000002800287728443844284438772800280000110811081F0811141F620000
+B597:0000002800287728443844284438772800280000000800080008003400C20000
+B598:00000028002877284438442844387728002800000048004800A8011406620000
+B599:0000002800287728443844284438772800280000000001F00208020801F00000
+B59A:000000280028772844384428443877280028000003F80020002000D003080000
+B59B:0000002800287728443844284438772800280000004003F8004000A003180000
+B59C:000000280028772844384428443877280028000003F8000803F8000800080000
+B59D:000000280028772844384428443877280028000003F8020003F8020003F80000
+B59E:000000280028772844384428443877280028000000000FF8022002200FF80000
+B59F:000000280028772844384428443877280028000000800FF803E0041003E00000
+B5A0:00000000000200027BC242024202421E420242027BC200020002000200020000
+B5A1:0000000800087708440844384408770800080000000007F80008000800080000
+B5A2:000000080008770844084438440877080008000000003EF80208020802080000
+B5A3:000000080008770844084438440877080008000000001F080108011401620000
+B5A4:000000080008770844084438440877080008000000001000100010001FF80000
+B5A5:0000000800087708440844384408770800080000000020F8201020303ECC0000
+B5A6:0000000800087708440844384408770800080000202021FC207020883E700000
+B5A7:000000080008770844084438440877080008000003F802000200020003F80000
+B5A8:000000080008770844084438440877080008000007F8000807F8040007F80000
+B5A9:00000008000877084408443844087708000800003EF802083E0820083E080000
+B5AA:00000008000877084408443844087708000800003EF802883E8820883EF80000
+B5AB:00000008000877084408443844087708000800003E8802883EF820883EF80000
+B5AC:00000008000877084408443844087708000800000F8800880F8808140FA20000
+B5AD:00000008000877084408443844087708000800003EF802803EF820803EF80000
+B5AE:00000008000877084408443844087708000800003EFC02483E4820483EFC0000
+B5AF:00000008000877084408443844087708000800003E1002FE3E3820443E380000
+B5B0:000000080008770844084438440877080008000003F802080208020803F80000
+B5B1:00000008000877084408443844087708000800000208020803F8020803F80000
+B5B2:0000000800087708440844384408770800080000210821083F0821143F620000
+B5B3:0000000800087708440844384408770800080000001000100010006801840000
+B5B4:00000008000877084408443844087708000800000048004800A8011406620000
+B5B5:0000000800087708440844384408770800080000000003F00408040803F00000
+B5B6:000000080008770844084438440877080008000003F80020002000D003080000
+B5B7:0000000800087708440844384408770800080000004003F8004000A003180000
+B5B8:000000080008770844084438440877080008000003F8000803F8000800080000
+B5B9:000000080008770844084438440877080008000003F8020003F8020003F80000
+B5BA:000000080008770844084438440877080008000000000FF8022002200FF80000
+B5BB:000000080008770844084438440877080008000000800FF803E0041003E00000
+B5BC:00000000000A000A7BCA420A420A423A420A420A7BCA000A000A000A000A0000
+B5BD:0000002800287728442844E8442877280028000007F800080008000800080000
+B5BE:0000002800287728442844E8442877280028000000003EF80208020802080000
+B5BF:0000002800287728442844E8442877280028000000003E100210022802C40000
+B5C0:0000002800287728442844E8442877280028000008000800080008000FF80000
+B5C1:0000002800287728442844E84428772800280000000020F8201020303ECC0000
+B5C2:0000002800287728442844E84428772800280000202021FC207020883E700000
+B5C3:0000002800287728442844E8442877280028000003F802000200020003F80000
+B5C4:0000002800287728442844E8442877280028000007F8000807F8040007F80000
+B5C5:0000002800287728442844E844287728002800003EF802083E0820083E080000
+B5C6:0000002800287728442844E844287728002800003EF802883E8820883EF80000
+B5C7:0000002800287728442844E844287728002800003E8802883EF820883EF80000
+B5C8:0000002800287728442844E844287728002800001F0801081F0810141F620000
+B5C9:0000002800287728442844E844287728002800003EF802803EF820803EF80000
+B5CA:0000002800287728442844E844287728002800003EFC02483E4820483EFC0000
+B5CB:0000002800287728442844E844287728002800003E1002FE3E3820443E380000
+B5CC:0000002800287728442844E8442877280028000003F802080208020803F80000
+B5CD:0000002800287728442844E844287728002800000208020803F8020803F80000
+B5CE:0000002800287728442844E84428772800280000110811081F0811141F620000
+B5CF:0000002800287728442844E84428772800280000000800080008003400C20000
+B5D0:0000002800287728442844E844287728002800000048004800A8011406620000
+B5D1:0000002800287728442844E84428772800280000000001F00208020801F00000
+B5D2:0000002800287728442844E8442877280028000003F80020002000D003080000
+B5D3:0000002800287728442844E84428772800280000004003F8004000A003180000
+B5D4:0000002800287728442844E8442877280028000003F8000803F8000800080000
+B5D5:0000002800287728442844E8442877280028000003F8020003F8020003F80000
+B5D6:0000002800287728442844E8442877280028000000000FF8022002200FF80000
+B5D7:0000002800287728442844E8442877280028000000800FF803E0041003E00000
+B5D8:00000000000200027BC24202421E42024202421E7BC200020002000200020000
+B5D9:0000000800087708443844084438770800080000000007F80008000800080000
+B5DA:000000080008770844384408443877080008000000003EF80208020802080000
+B5DB:000000080008770844384408443877080008000000001F080108011401620000
+B5DC:000000080008770844384408443877080008000800001000100010001FF80000
+B5DD:0000000800087708443844084438770800080000000020F8201020303ECC0000
+B5DE:0000000800087708443844084438770800080000202021FC207020883E700000
+B5DF:000000080008770844384408443877080008000003F802000200020003F80000
+B5E0:000000080008770844384408443877080008000007F8000807F8040007F80000
+B5E1:00000008000877084438440844387708000800003EF802083E0820083E080000
+B5E2:00000008000877084438440844387708000800003EF802883E8820883EF80000
+B5E3:00000008000877084438440844387708000800003E8802883EF820883EF80000
+B5E4:00000008000877084438440844387708000800000F8800880F8808140FA20000
+B5E5:00000008000877084438440844387708000800003EF802803EF820803EF80000
+B5E6:00000008000877084438440844387708000800003EFC02483E4820483EFC0000
+B5E7:00000008000877084438440844387708000800003E1002FE3E3820443E380000
+B5E8:000000080008770844384408443877080008000003F802080208020803F80000
+B5E9:00000008000877084438440844387708000800000208020803F8020803F80000
+B5EA:0000000800087708443844084438770800080000210821083F0821143F620000
+B5EB:0000000800087708443844084438770800080000001000100010006801840000
+B5EC:00000008000877084438440844387708000800000048004800A8011406620000
+B5ED:0000000800087708443844084438770800080000000003F00408040803F00000
+B5EE:000000080008770844384408443877080008000003F80020002000D003080000
+B5EF:0000000800087708443844084438770800080000004003F8004000A003180000
+B5F0:000000080008770844384408443877080008000003F8000803F8000800080000
+B5F1:000000080008770844384408443877080008000003F8020003F8020003F80000
+B5F2:000000080008770844384408443877080008000000000FF8022002200FF80000
+B5F3:000000080008770844384408443877080008000000800FF803E0041003E00000
+B5F4:00000000000A000A7BCA420A423A420A420A423A7BCA000A000A000A000A0000
+B5F5:000000280028772844E8442844E877280028000007F800080008000800080000
+B5F6:000000280028772844E8442844E877280028000000003EF80208020802080000
+B5F7:000000280028772844E8442844E877280028000000003E100210022802C40000
+B5F8:000000280028772844E8442844E877280028002808000800080008000FF80000
+B5F9:000000280028772844E8442844E8772800280000000020F8201020303ECC0000
+B5FA:000000280028772844E8442844E8772800280000202021FC207020883E700000
+B5FB:000000280028772844E8442844E877280028000003F802000200020003F80000
+B5FC:000000280028772844E8442844E877280028000007F8000807F8040007F80000
+B5FD:000000280028772844E8442844E87728002800003EF802083E0820083E080000
+B5FE:000000280028772844E8442844E87728002800003EF802883E8820883EF80000
+B5FF:000000280028772844E8442844E87728002800003E8802883EF820883EF80000
+B600:000000280028772844E8442844E87728002800001F0801081F0810141F620000
+B601:000000280028772844E8442844E87728002800003EF802803EF820803EF80000
+B602:000000280028772844E8442844E87728002800003EFC02483E4820483EFC0000
+B603:000000280028772844E8442844E87728002800003E1002FE3E3820443E380000
+B604:000000280028772844E8442844E877280028000003F802080208020803F80000
+B605:000000280028772844E8442844E87728002800000208020803F8020803F80000
+B606:000000280028772844E8442844E8772800280000110811081F0811141F620000
+B607:000000280028772844E8442844E8772800280000000800080008003400C20000
+B608:000000280028772844E8442844E87728002800000048004800A8011406620000
+B609:000000280028772844E8442844E8772800280000000001F00208020801F00000
+B60A:000000280028772844E8442844E877280028000003F80020002000D003080000
+B60B:000000280028772844E8442844E8772800280000004003F8004000A003180000
+B60C:000000280028772844E8442844E877280028000003F8000803F8000800080000
+B60D:000000280028772844E8442844E877280028000003F8020003F8020003F80000
+B60E:000000280028772844E8442844E877280028000000000FF8022002200FF80000
+B60F:000000280028772844E8442844E877280028000000800FF803E0041003E00000
+B610:000000003EF820802080208020803EF8000000000100010001007FFC00000000
+B611:000000001EF0108010801EF0010001007FFC00001FF000100010001000100000
+B612:000000001EF0108010801EF0010001007FFC000000003EF80208020802080000
+B613:000000001EF0108010801EF0010001007FFC000000001E100210022802C40000
+B614:000000001EF0108010801EF0010001007FFC000000001000100010001FF00000
+B615:000000001EF0108010801EF0010001007FFC0000000020F8201020303ECC0000
+B616:000000001EF0108010801EF0010001007FFC0000202021FC207020883E700000
+B617:000000001EF0108010801EF0010001007FFC00001FF01000100010001FF00000
+B618:000000001EF0108010801EF0010001007FFC00001FF000101FF010001FF00000
+B619:000000001EF0108010801EF0010001007FFC00003EF802083E0820083E080000
+B61A:000000001EF0108010801EF0010001007FFC00003EF802883E8820883EF80000
+B61B:000000001EF0108010801EF0010001007FFC00003E8802883EF820883EF80000
+B61C:000000001EF0108010801EF0010001007FFC00003E1002103E1020283EC40000
+B61D:000000001EF0108010801EF0010001007FFC00003EF802803EF820803EF80000
+B61E:000000001EF0108010801EF0010001007FFC00003EFC02483E4820483EFC0000
+B61F:000000001EF0108010801EF0010001007FFC00003E2003FC3E7020883E700000
+B620:000000001EF0108010801EF0010001007FFC00001FF01010101010101FF00000
+B621:000000001EF0108010801EF0010001007FFC0000101010101FF010101FF00000
+B622:000000001EF0108010801EF0010001007FFC0000222022203E2022503E880000
+B623:000000001EF0108010801EF0010001007FFC000000000100010002800C400000
+B624:000000001EF0108010801EF0010001007FFC00000000024002400DA033100000
+B625:000000001EF0108010801EF0010001007FFC0000000007C00820082007C00000
+B626:000000001EF0108010801EF0010001007FFC0000000007E00080014006200000
+B627:000000001EF0108010801EF0010001007FFC0000008007E00080014006200000
+B628:000000001EF0108010801EF0010001007FFC00001FF000101FF0001000100000
+B629:000000001EF0108010801EF0010001007FFC00001FF010001FF010001FF00000
+B62A:000000001EF0108010801EF0010001007FFC000000001FF0044004401FF00000
+B62B:000000001EF0108010801EF0010001007FFC000001001FF007C0082007C00000
+B62C:0000001000107BD0421042104210421E7BD00010041004107FD0001000100000
+B62D:000000083B882208220E3B88040804087FE8000007F800080008000800080000
+B62E:000000083B882208220E3B88040804087FE8000000003EF80208020802080000
+B62F:000000083B882208220E3B88040804087FE8000000001F080108011401620000
+B630:000000083B882208220E3B88040804087FE8000008000800080008000FF80000
+B631:000000083B882208220E3B88040804087FE80000000010F8101010301ECC0000
+B632:000000083B882208220E3B88040804087FE800000808087F081C08220F9C0000
+B633:000000083B882208220E3B88040804087FE8000003F802000200020003F80000
+B634:000000083B882208220E3B88040804087FE8000007F8000807F8040007F80000
+B635:000000083B882208220E3B88040804087FE800003EF802083E0820083E080000
+B636:000000083B882208220E3B88040804087FE800003EF802883E8820883EF80000
+B637:000000083B882208220E3B88040804087FE800003E8802883EF820883EF80000
+B638:000000083B882208220E3B88040804087FE800001F0801081F0810141F620000
+B639:000000083B882208220E3B88040804087FE800003EF802803EF820803EF80000
+B63A:000000083B882208220E3B88040804087FE800003EFC02483E4820483EFC0000
+B63B:000000083B882208220E3B88040804087FE800001F08017F1F1C10221F1C0000
+B63C:000000083B882208220E3B88040804087FE8000003F802080208020803F80000
+B63D:000000083B882208220E3B88040804087FE800000208020803F8020803F80000
+B63E:000000083B882208220E3B88040804087FE80000110811081F0811141F620000
+B63F:000000083B882208220E3B88040804087FE80000001000100010006801840000
+B640:000000083B882208220E3B88040804087FE800000048004800A8011406620000
+B641:000000083B882208220E3B88040804087FE80000000003F00408040803F00000
+B642:000000083B882208220E3B88040804087FE8000003F80020002000D003080000
+B643:000000083B882208220E3B88040804087FE80000004003F8004000A003180000
+B644:000000083B882208220E3B88040804087FE8000003F8000803F8000800080000
+B645:000000083B882208220E3B88040804087FE8000003F8020003F8020003F80000
+B646:000000083B882208220E3B88040804087FE8000000000FF8022002200FF80000
+B647:000000083B882208220E3B88040804087FE8000000800FF803E0041003E00000
+B648:0000001200127BD2421242124212421E7BD20012041204127FD2001200120000
+B649:000000283BA8222822383BA8042804287FA8000007F800080008000800080000
+B64A:000000283BA8222822383BA8042804287FA8000000003EF80208020802080000
+B64B:000000283BA8222822383BA8042804287FA8000000001F080108011401620000
+B64C:000000283BA8222822383BA8042804287FA8000008000800080008000FF80000
+B64D:000000283BA8222822383BA8042804287FA80000000010F8101010301ECC0000
+B64E:000000283BA8222822383BA8042804287FA800000808087F081C08220F9C0000
+B64F:000000283BA8222822383BA8042804287FA8000003F802000200020003F80000
+B650:000000283BA8222822383BA8042804287FA8000007F8000807F8040007F80000
+B651:000000283BA8222822383BA8042804287FA800003EF802083E0820083E080000
+B652:000000283BA8222822383BA8042804287FA800003EF802883E8820883EF80000
+B653:000000283BA8222822383BA8042804287FA800003E8802883EF820883EF80000
+B654:000000283BA8222822383BA8042804287FA800001F0801081F0810141F620000
+B655:000000283BA8222822383BA8042804287FA800003EF802803EF820803EF80000
+B656:000000283BA8222822383BA8042804287FA800003EFC02483E4820483EFC0000
+B657:000000283BA8222822383BA8042804287FA800001F08017F1F1C10221F1C0000
+B658:000000283BA8222822383BA8042804287FA8000003F802080208020803F80000
+B659:000000283BA8222822383BA8042804287FA800000208020803F8020803F80000
+B65A:000000283BA8222822383BA8042804287FA80000110811081F0811141F620000
+B65B:000000283BA8222822383BA8042804287FA80000001000100010006801840000
+B65C:000000283BA8222822383BA8042804287FA800000048004800A8011406620000
+B65D:000000283BA8222822383BA8042804287FA80000000003F00408040803F00000
+B65E:000000283BA8222822383BA8042804287FA8000003F80020002000D003080000
+B65F:000000283BA8222822383BA8042804287FA80000004003F8004000A003180000
+B660:000000283BA8222822383BA8042804287FA8000003F8000803F8000800080000
+B661:000000283BA8222822383BA8042804287FA8000003F8020003F8020003F80000
+B662:000000283BA8222822383BA8042804287FA8000000000FF8022002200FF80000
+B663:000000283BA8222822383BA8042804287FA8000000800FF803E0041003E00000
+B664:0000000800087BC842084208420842087BC80008040804087FE8000800080000
+B665:000000083B88220822083B88040804087FE8000007F800080008000800080000
+B666:000000083B88220822083B88040804087FE8000000003EF80208020802080000
+B667:000000083B88220822083B88040804087FE8000000001F080108011401620000
+B668:000000083B88220822083B88040804087FE8000008000800080008000FF80000
+B669:000000083B88220822083B88040804087FE80000000010F8101010301ECC0000
+B66A:000000083B88220822083B88040804087FE800000808087F081C08220F9C0000
+B66B:000000083B88220822083B88040804087FE8000003F802000200020003F80000
+B66C:000000083B88220822083B88040804087FE8000007F8000807F8040007F80000
+B66D:000000083B88220822083B88040804087FE800003EF802083E0820083E080000
+B66E:000000083B88220822083B88040804087FE800003EF802883E8820883EF80000
+B66F:000000083B88220822083B88040804087FE800003E8802883EF820883EF80000
+B670:000000083B88220822083B88040804087FE800001F0801081F0810141F620000
+B671:000000083B88220822083B88040804087FE800003EF802803EF820803EF80000
+B672:000000083B88220822083B88040804087FE800003EFC02483E4820483EFC0000
+B673:000000083B88220822083B88040804087FE800001F08017F1F1C10221F1C0000
+B674:000000083B88220822083B88040804087FE8000003F802080208020803F80000
+B675:000000083B88220822083B88040804087FE800000208020803F8020803F80000
+B676:000000083B88220822083B88040804087FE80000110811081F0811141F620000
+B677:000000083B88220822083B88040804087FE80000001000100010006801840000
+B678:000000083B88220822083B88040804087FE800000048004800A8011406620000
+B679:000000083B88220822083B88040804087FE80000000003F00408040803F00000
+B67A:000000083B88220822083B88040804087FE8000003F80020002000D003080000
+B67B:000000083B88220822083B88040804087FE80000004003F8004000A003180000
+B67C:000000083B88220822083B88040804087FE8000003F8000803F8000800080000
+B67D:000000083B88220822083B88040804087FE8000003F8020003F8020003F80000
+B67E:000000083B88220822083B88040804087FE8000000000FF8022002200FF80000
+B67F:000000083B88220822083B88040804087FE8000000800FF803E0041003E00000
+B680:000000003EF820802080208020803EF8000004400440044004407FFC00000000
+B681:000000001EF0108010801EF0044004407FFC00001FF000100010001000100000
+B682:000000001EF0108010801EF0044004407FFC000000003EF80208020802080000
+B683:000000001EF0108010801EF0044004407FFC000000001E100210022802C40000
+B684:000000001EF0108010801EF0044004407FFC000000001000100010001FF00000
+B685:000000001EF0108010801EF0044004407FFC0000000020F8201020303ECC0000
+B686:000000001EF0108010801EF0044004407FFC0000202021FC207020883E700000
+B687:000000001EF0108010801EF0044004407FFC00001FF01000100010001FF00000
+B688:000000001EF0108010801EF0044004407FFC00001FF000101FF010001FF00000
+B689:000000001EF0108010801EF0044004407FFC00003EF802083E0820083E080000
+B68A:000000001EF0108010801EF0044004407FFC00003EF802883E8820883EF80000
+B68B:000000001EF0108010801EF0044004407FFC00003E8802883EF820883EF80000
+B68C:000000001EF0108010801EF0044004407FFC00003E1002103E1020283EC40000
+B68D:000000001EF0108010801EF0044004407FFC00003EF802803EF820803EF80000
+B68E:000000001EF0108010801EF0044004407FFC00003EFC02483E4820483EFC0000
+B68F:000000001EF0108010801EF0044004407FFC00003E2003FC3E7020883E700000
+B690:000000001EF0108010801EF0044004407FFC00001FF01010101010101FF00000
+B691:000000001EF0108010801EF0044004407FFC0000101010101FF010101FF00000
+B692:000000001EF0108010801EF0044004407FFC0000222022203E2022503E880000
+B693:000000001EF0108010801EF0044004407FFC000000000100010002800C400000
+B694:000000001EF0108010801EF0044004407FFC00000000024002400DA033100000
+B695:000000001EF0108010801EF0044004407FFC0000000007C00820082007C00000
+B696:000000001EF0108010801EF0044004407FFC0000000007E00080014006200000
+B697:000000001EF0108010801EF0044004407FFC0000008007E00080014006200000
+B698:000000001EF0108010801EF0044004407FFC00001FF000101FF0001000100000
+B699:000000001EF0108010801EF0044004407FFC00001FF010001FF010001FF00000
+B69A:000000001EF0108010801EF0044004407FFC000000001FF0044004401FF00000
+B69B:000000001EF0108010801EF0044004407FFC000001001FF007C0082007C00000
+B69C:000000003EF820802080208020803EF8000000003FF801000100010001000000
+B69D:000000001EF0108010801EF000007FFC010001001FF000100010001000100000
+B69E:000000001EF0108010801EF000007FFC0100010000003EF80208020802080000
+B69F:000000001EF0108010801EF000007FFC0100010000001E100210022802C40000
+B6A0:000000001EF0108010801EF0000000007FFC010001001100100010001FF00000
+B6A1:000000001EF0108010801EF000007FFC01000100000020F8201020303ECC0000
+B6A2:000000001EF0108010801EF000007FFC01000100202021FC207020883E700000
+B6A3:000000001EF0108010801EF000007FFC010001001FF01000100010001FF00000
+B6A4:000000001EF0108010801EF000007FFC010001001FF000101FF010001FF00000
+B6A5:000000001EF0108010801EF000007FFC010001003EF802083E0820083E080000
+B6A6:000000001EF0108010801EF000007FFC010001003EF802883E8820883EF80000
+B6A7:000000001EF0108010801EF000007FFC010001003E8802883EF820883EF80000
+B6A8:000000001EF0108010801EF000007FFC010001003E1002103E1020283EC40000
+B6A9:000000001EF0108010801EF000007FFC010001003EF802803EF820803EF80000
+B6AA:000000001EF0108010801EF000007FFC010001003EFC02483E4820483EFC0000
+B6AB:000000001EF0108010801EF000007FFC010001003E2003FC3E7020883E700000
+B6AC:000000001EF0108010801EF000007FFC010001001FF01010101010101FF00000
+B6AD:000000001EF0108010801EF000007FFC01000100101010101FF010101FF00000
+B6AE:000000001EF0108010801EF000007FFC01000100222022203E2022503E880000
+B6AF:000000001EF0108010801EF000007FFC0100010000000100010002800C400000
+B6B0:000000001EF0108010801EF000007FFC010001000000024002400DA033100000
+B6B1:000000001EF0108010801EF000007FFC01000100000007C00820082007C00000
+B6B2:000000001EF0108010801EF000007FFC01000100000007E00080014006200000
+B6B3:000000001EF0108010801EF000007FFC01000100008007E00080014006200000
+B6B4:000000001EF0108010801EF000007FFC010001001FF000101FF0001000100000
+B6B5:000000001EF0108010801EF000007FFC010001001FF010001FF010001FF00000
+B6B6:000000001EF0108010801EF000007FFC0100010000001FF0044004401FF00000
+B6B7:000000001EF0108010801EF000007FFC0100010001001FF007C0082007C00000
+B6B8:000000087BC842084208420842087BC8000800087FE8040804F8040804080000
+B6B9:0008770844084408770800087FE8027802080000000007F80008000800080000
+B6BA:0008770844084408770800087FE802780208000000003EF80208020802080000
+B6BB:0008770844084408770800087FE802780208000000001F080108011401620000
+B6BC:00087708440844087708000800087FE80278020802081000100010001FF80000
+B6BD:0008770844084408770800087FE8027802080000000020F8201020303ECC0000
+B6BE:0008770844084408770800087FE8027802080000202021FC207020883E700000
+B6BF:0008770844084408770800087FE802780208000003F802000200020003F80000
+B6C0:0008770844084408770800087FE802780208000007F8000807F8040007F80000
+B6C1:0008770844084408770800087FE80278020800003EF802083E0820083E080000
+B6C2:0008770844084408770800087FE80278020800003EF802883E8820883EF80000
+B6C3:0008770844084408770800087FE80278020800003E8802883EF820883EF80000
+B6C4:0008770844084408770800087FE80278020800000F8800880F8808140FA20000
+B6C5:0008770844084408770800087FE80278020800003EF802803EF820803EF80000
+B6C6:0008770844084408770800087FE80278020800003EFC02483E4820483EFC0000
+B6C7:0008770844084408770800087FE80278020800003E1002FE3E3820443E380000
+B6C8:0008770844084408770800087FE802780208000003F802080208020803F80000
+B6C9:0008770844084408770800087FE80278020800000208020803F8020803F80000
+B6CA:0008770844084408770800087FE8027802080000210821083F0821143F620000
+B6CB:0008770844084408770800087FE8027802080000001000100010006801840000
+B6CC:0008770844084408770800087FE80278020800000048004800A8011406620000
+B6CD:0008770844084408770800087FE8027802080000000003F00408040803F00000
+B6CE:0008770844084408770800087FE802780208000003F80020002000D003080000
+B6CF:0008770844084408770800087FE8027802080000004003F8004000A003180000
+B6D0:0008770844084408770800087FE802780208000003F8000803F8000800080000
+B6D1:0008770844084408770800087FE802780208000003F8020003F8020003F80000
+B6D2:0008770844084408770800087FE802780208000000000FF8022002200FF80000
+B6D3:0008770844084408770800087FE802780208000000800FF803E0041003E00000
+B6D4:0000000A7BCA420A420A420A420A7BCA000A000A7FEA040A047A040A040A0000
+B6D5:0028772844284428772800287FA805E804280000000007F80008000800080000
+B6D6:0028772844284428772800287FA805E80428000000003EF80208020802080000
+B6D7:0028772844284428772800287FA805E80428000000001F080108011401620000
+B6D8:00287728442844287728002800287FA8042805E804281428100010001FF80000
+B6D9:0028772844284428772800287FA805E804280000000020F8201020303ECC0000
+B6DA:0028772844284428772800287FA805E804280000202021FC207020883E700000
+B6DB:0028772844284428772800287FA805E80428000003F802000200020003F80000
+B6DC:0028772844284428772800287FA805E80428000007F8000807F8040007F80000
+B6DD:0028772844284428772800287FA805E8042800003EF802083E0820083E080000
+B6DE:0028772844284428772800287FA805E8042800003EF802883E8820883EF80000
+B6DF:0028772844284428772800287FA805E8042800003E8802883EF820883EF80000
+B6E0:0028772844284428772800287FA805E8042800000F8800880F8808140FA20000
+B6E1:0028772844284428772800287FA805E8042800003EF802803EF820803EF80000
+B6E2:0028772844284428772800287FA805E8042800003EFC02483E4820483EFC0000
+B6E3:0028772844284428772800287FA805E8042800003E1002FE3E3820443E380000
+B6E4:0028772844284428772800287FA805E80428000003F802080208020803F80000
+B6E5:0028772844284428772800287FA805E8042800000208020803F8020803F80000
+B6E6:0028772844284428772800287FA805E804280000210821083F0821143F620000
+B6E7:0028772844284428772800287FA805E804280000001000100010006801840000
+B6E8:0028772844284428772800287FA805E8042800000048004800A8011406620000
+B6E9:0028772844284428772800287FA805E804280000000003F00408040803F00000
+B6EA:0028772844284428772800287FA805E80428000003F80020002000D003080000
+B6EB:0028772844284428772800287FA805E804280000004003F8004000A003180000
+B6EC:0028772844284428772800287FA805E80428000003F8000803F8000800080000
+B6ED:0028772844284428772800287FA805E80428000003F8020003F8020003F80000
+B6EE:0028772844284428772800287FA805E80428000000000FF8022002200FF80000
+B6EF:0028772844284428772800287FA805E80428000000800FF803E0041003E00000
+B6F0:000000087BC842084208420842087BC8000800087FE804080408040804080000
+B6F1:0008770844084408770800087FE8020802000000000007F80008000800080000
+B6F2:0008770844084408770800087FE802080200000000003EF80208020802080000
+B6F3:0008770844084408770800087FE802080200000000001F080108011401620000
+B6F4:00087708440844087708000800087FE80208020802081008100010001FF80000
+B6F5:0008770844084408770800087FE8020802000000000020F8201020303ECC0000
+B6F6:0008770844084408770800087FE8020802000000202021FC207020883E700000
+B6F7:0008770844084408770800087FE802080200000003F802000200020003F80000
+B6F8:0008770844084408770800087FE802080200000007F8000807F8040007F80000
+B6F9:0008770844084408770800087FE80208020000003EF802083E0820083E080000
+B6FA:0008770844084408770800087FE80208020000003EF802883E8820883EF80000
+B6FB:0008770844084408770800087FE80208020000003E8802883EF820883EF80000
+B6FC:0008770844084408770800087FE80208020000000F8800880F8808140FA20000
+B6FD:0008770844084408770800087FE80208020000003EF802803EF820803EF80000
+B6FE:0008770844084408770800087FE80208020000003EFC02483E4820483EFC0000
+B6FF:0008770844084408770800087FE80208020000003E1002FE3E3820443E380000
+B700:0008770844084408770800087FE802080200000003F802080208020803F80000
+B701:0008770844084408770800087FE80208020000000208020803F8020803F80000
+B702:0008770844084408770800087FE8020802000000210821083F0821143F620000
+B703:0008770844084408770800087FE8020802000000001000100010006801840000
+B704:0008770844084408770800087FE80208020000000048004800A8011406620000
+B705:0008770844084408770800087FE8020802000000000003F00408040803F00000
+B706:0008770844084408770800087FE802080200000003F80020002000D003080000
+B707:0008770844084408770800087FE8020802000000004003F8004000A003180000
+B708:0008770844084408770800087FE802080200000003F8000803F8000800080000
+B709:0008770844084408770800087FE802080200000003F8020003F8020003F80000
+B70A:0008770844084408770800087FE802080200000000000FF8022002200FF80000
+B70B:0008770844084408770800087FE802080200000000800FF803E0041003E00000
+B70C:000000003EF820802080208020803EF8000000007FFC04400440044004400000
+B70D:000000001EF0108010801EF000007FFC044004401FF000100010001000100000
+B70E:000000001EF0108010801EF000007FFC0440044000003EF80208020802080000
+B70F:000000001EF0108010801EF000007FFC0440044000001E100210022802C40000
+B710:000000001EF0108010801EF0000000007FFC044004401440100010001FF00000
+B711:000000001EF0108010801EF000007FFC04400440000020F8201020303ECC0000
+B712:000000001EF0108010801EF000007FFC04400440202021FC207020883E700000
+B713:000000001EF0108010801EF000007FFC044004401FF01000100010001FF00000
+B714:000000001EF0108010801EF000007FFC044004401FF000101FF010001FF00000
+B715:000000001EF0108010801EF000007FFC044004403EF802083E0820083E080000
+B716:000000001EF0108010801EF000007FFC044004403EF802883E8820883EF80000
+B717:000000001EF0108010801EF000007FFC044004403E8802883EF820883EF80000
+B718:000000001EF0108010801EF000007FFC044004403E1002103E1020283EC40000
+B719:000000001EF0108010801EF000007FFC044004403EF802803EF820803EF80000
+B71A:000000001EF0108010801EF000007FFC044004403EFC02483E4820483EFC0000
+B71B:000000001EF0108010801EF000007FFC044004403E2003FC3E7020883E700000
+B71C:000000001EF0108010801EF000007FFC044004401FF01010101010101FF00000
+B71D:000000001EF0108010801EF000007FFC04400440101010101FF010101FF00000
+B71E:000000001EF0108010801EF000007FFC04400440222022203E2022503E880000
+B71F:000000001EF0108010801EF000007FFC0440044000000100010002800C400000
+B720:000000001EF0108010801EF000007FFC044004400000024002400DA033100000
+B721:000000001EF0108010801EF000007FFC04400440000007C00820082007C00000
+B722:000000001EF0108010801EF000007FFC04400440000007E00080014006200000
+B723:000000001EF0108010801EF000007FFC04400440008007E00080014006200000
+B724:000000001EF0108010801EF000007FFC044004401FF000101FF0001000100000
+B725:000000001EF0108010801EF000007FFC044004401FF010001FF010001FF00000
+B726:000000001EF0108010801EF000007FFC0440044000001FF0044004401FF00000
+B727:000000001EF0108010801EF000007FFC0440044001001FF007C0082007C00000
+B728:000000003EF820802080208020803EF80000000000007FFC0000000000000000
+B729:000000001EF0108010801EF0000000007FFC00001FF000100010001000100000
+B72A:000000001EF0108010801EF0000000007FFC000000003EF80208020802080000
+B72B:000000001EF0108010801EF0000000007FFC000000001E100210022802C40000
+B72C:000000001EF0108010801EF0000000007FFC000000001000100010001FF00000
+B72D:000000001EF0108010801EF0000000007FFC0000000020F8201020303ECC0000
+B72E:000000001EF0108010801EF0000000007FFC0000202021FC207020883E700000
+B72F:000000001EF0108010801EF0000000007FFC00001FF01000100010001FF00000
+B730:000000001EF0108010801EF0000000007FFC00001FF000101FF010001FF00000
+B731:000000001EF0108010801EF0000000007FFC00003EF802083E0820083E080000
+B732:000000001EF0108010801EF0000000007FFC00003EF802883E8820883EF80000
+B733:000000001EF0108010801EF0000000007FFC00003E8802883EF820883EF80000
+B734:000000001EF0108010801EF0000000007FFC00003E1002103E1020283EC40000
+B735:000000001EF0108010801EF0000000007FFC00003EF802803EF820803EF80000
+B736:000000001EF0108010801EF0000000007FFC00003EFC02483E4820483EFC0000
+B737:000000001EF0108010801EF0000000007FFC00003E2003FC3E7020883E700000
+B738:000000001EF0108010801EF0000000007FFC00001FF01010101010101FF00000
+B739:000000001EF0108010801EF0000000007FFC0000101010101FF010101FF00000
+B73A:000000001EF0108010801EF0000000007FFC0000222022203E2022503E880000
+B73B:000000001EF0108010801EF0000000007FFC000000000100010002800C400000
+B73C:000000001EF0108010801EF0000000007FFC00000000024002400DA033100000
+B73D:000000001EF0108010801EF0000000007FFC0000000007C00820082007C00000
+B73E:000000001EF0108010801EF0000000007FFC0000000007E00080014006200000
+B73F:000000001EF0108010801EF0000000007FFC0000008007E00080014006200000
+B740:000000001EF0108010801EF0000000007FFC00001FF000101FF0001000100000
+B741:000000001EF0108010801EF0000000007FFC00001FF010001FF010001FF00000
+B742:000000001EF0108010801EF0000000007FFC000000001FF0044004401FF00000
+B743:000000001EF0108010801EF0000000007FFC000001001FF007C0082007C00000
+B744:0000000800087BC842084208420842087BC8000800087FE80008000800080000
+B745:000000083B88220822083B88000800087FE8000007F800080008000800080000
+B746:000000083B88220822083B88000800087FE8000000003EF80208020802080000
+B747:000000083B88220822083B88000800087FE8000000001F080108011401620000
+B748:000000083B88220822083B88000800087FE8000008000800080008000FF80000
+B749:000000083B88220822083B88000800087FE80000000010F8101010301ECC0000
+B74A:000000083B88220822083B88000800087FE800000808087F081C08220F9C0000
+B74B:000000083B88220822083B88000800087FE8000003F802000200020003F80000
+B74C:000000083B88220822083B88000800087FE8000007F8000807F8040007F80000
+B74D:000000083B88220822083B88000800087FE800003EF802083E0820083E080000
+B74E:000000083B88220822083B88000800087FE800003EF802883E8820883EF80000
+B74F:000000083B88220822083B88000800087FE800003E8802883EF820883EF80000
+B750:000000083B88220822083B88000800087FE800001F0801081F0810141F620000
+B751:000000083B88220822083B88000800087FE800003EF802803EF820803EF80000
+B752:000000083B88220822083B88000800087FE800003EFC02483E4820483EFC0000
+B753:000000083B88220822083B88000800087FE800001F08017F1F1C10221F1C0000
+B754:000000083B88220822083B88000800087FE8000003F802080208020803F80000
+B755:000000083B88220822083B88000800087FE800000208020803F8020803F80000
+B756:000000083B88220822083B88000800087FE80000110811081F0811141F620000
+B757:000000083B88220822083B88000800087FE80000001000100010006801840000
+B758:000000083B88220822083B88000800087FE800000048004800A8011406620000
+B759:000000083B88220822083B88000800087FE80000000003F00408040803F00000
+B75A:000000083B88220822083B88000800087FE8000003F80020002000D003080000
+B75B:000000083B88220822083B88000800087FE80000004003F8004000A003180000
+B75C:000000083B88220822083B88000800087FE8000003F8000803F8000800080000
+B75D:000000083B88220822083B88000800087FE8000003F8020003F8020003F80000
+B75E:000000083B88220822083B88000800087FE8000000000FF8022002200FF80000
+B75F:000000083B88220822083B88000800087FE8000000800FF803E0041003E00000
+B760:00000000000800087BC8420842084208420842087BC800080008000800080000
+B761:0000000800087708440844084408770800080000000007F80008000800080000
+B762:000000080008770844084408440877080008000000003EF80208020802080000
+B763:000000080008770844084408440877080008000000001F080108011401620000
+B764:000000080008770844084408440877080008000800001000100010001FF80000
+B765:0000000800087708440844084408770800080000000020F8201020303ECC0000
+B766:0000000800087708440844084408770800080000202021FC207020883E700000
+B767:000000080008770844084408440877080008000003F802000200020003F80000
+B768:000000080008770844084408440877080008000007F8000807F8040007F80000
+B769:00000008000877084408440844087708000800003EF802083E0820083E080000
+B76A:00000008000877084408440844087708000800003EF802883E8820883EF80000
+B76B:00000008000877084408440844087708000800003E8802883EF820883EF80000
+B76C:00000008000877084408440844087708000800000F8800880F8808140FA20000
+B76D:00000008000877084408440844087708000800003EF802803EF820803EF80000
+B76E:00000008000877084408440844087708000800003EFC02483E4820483EFC0000
+B76F:00000008000877084408440844087708000800003E1002FE3E3820443E380000
+B770:000000080008770844084408440877080008000003F802080208020803F80000
+B771:00000008000877084408440844087708000800000208020803F8020803F80000
+B772:0000000800087708440844084408770800080000210821083F0821143F620000
+B773:0000000800087708440844084408770800080000001000100010006801840000
+B774:00000008000877084408440844087708000800000048004800A8011406620000
+B775:0000000800087708440844084408770800080000000003F00408040803F00000
+B776:000000080008770844084408440877080008000003F80020002000D003080000
+B777:0000000800087708440844084408770800080000004003F8004000A003180000
+B778:000000080008770844084408440877080008000003F8000803F8000800080000
+B779:000000080008770844084408440877080008000003F8020003F8020003F80000
+B77A:000000080008770844084408440877080008000000000FF8022002200FF80000
+B77B:000000080008770844084408440877080008000000800FF803E0041003E00000
+B77C:00000000001000103F90009000903F9E2010201020103F900010001000100000
+B77D:0000000800083F0801083F0E20083F080008000007F800080008000800080000
+B77E:0000000800083F0801083F0E20083F080008000000003EF80208020802080000
+B77F:0000000800083F0801083F0E20083F080008000000001F080108011401620000
+B780:0000000800083F0801083F0E20083F080008000808000800080008000FF80000
+B781:0000000800083F0801083F0E20083F0800080000000010F8101010301ECC0000
+B782:0000000800083F0801083F0E20083F08000800000808087F081C08220F9C0000
+B783:0000000800083F0801083F0E20083F080008000003F802000200020003F80000
+B784:0000000800083F0801083F0E20083F080008000007F8000807F8040007F80000
+B785:0000000800083F0801083F0E20083F08000800003EF802083E0820083E080000
+B786:0000000800083F0801083F0E20083F08000800003EF802883E8820883EF80000
+B787:0000000800083F0801083F0E20083F08000800003E8802883EF820883EF80000
+B788:0000000800083F0801083F0E20083F08000800001F0801081F0810141F620000
+B789:0000000800083F0801083F0E20083F08000800003EF802803EF820803EF80000
+B78A:0000000800083F0801083F0E20083F08000800003EFC02483E4820483EFC0000
+B78B:0000000800083F0801083F0E20083F08000800001F08017F1F1C10221F1C0000
+B78C:0000000800083F0801083F0E20083F080008000003F802080208020803F80000
+B78D:0000000800083F0801083F0E20083F08000800000208020803F8020803F80000
+B78E:0000000800083F0801083F0E20083F0800080000110811081F0811141F620000
+B78F:0000000800083F0801083F0E20083F0800080000001000100010006801840000
+B790:0000000800083F0801083F0E20083F08000800000048004800A8011406620000
+B791:0000000800083F0801083F0E20083F0800080000000003F00408040803F00000
+B792:0000000800083F0801083F0E20083F080008000003F80020002000D003080000
+B793:0000000800083F0801083F0E20083F0800080000004003F8004000A003180000
+B794:0000000800083F0801083F0E20083F080008000003F8000803F8000800080000
+B795:0000000800083F0801083F0E20083F080008000003F8020003F8020003F80000
+B796:0000000800083F0801083F0E20083F080008000000000FF8022002200FF80000
+B797:0000000800083F0801083F0E20083F080008000000800FF803E0041003E00000
+B798:00000000001200123F92009200923F9E2012201220123F920012001200120000
+B799:0000002800283F2801283F3820283F280028000007F800080008000800080000
+B79A:0000002800283F2801283F3820283F280028000000003EF80208020802080000
+B79B:0000002800283F2801283F3820283F280028000000003E100210022802C40000
+B79C:0000002800283F2801283F3820283F280028002808000800080008000FF80000
+B79D:0000002800283F2801283F3820283F2800280000000020F8201020303ECC0000
+B79E:0000002800283F2801283F3820283F2800280000202021FC207020883E700000
+B79F:0000002800283F2801283F3820283F280028000003F802000200020003F80000
+B7A0:0000002800283F2801283F3820283F280028000007F8000807F8040007F80000
+B7A1:0000002800283F2801283F3820283F28002800003EF802083E0820083E080000
+B7A2:0000002800283F2801283F3820283F28002800003EF802883E8820883EF80000
+B7A3:0000002800283F2801283F3820283F28002800003E8802883EF820883EF80000
+B7A4:0000002800283F2801283F3820283F28002800001F0801081F0810141F620000
+B7A5:0000002800283F2801283F3820283F28002800003EF802803EF820803EF80000
+B7A6:0000002800283F2801283F3820283F28002800003EFC02483E4820483EFC0000
+B7A7:0000002800283F2801283F3820283F28002800003E1002FE3E3820443E380000
+B7A8:0000002800283F2801283F3820283F280028000003F802080208020803F80000
+B7A9:0000002800283F2801283F3820283F28002800000208020803F8020803F80000
+B7AA:0000002800283F2801283F3820283F2800280000110811081F0811141F620000
+B7AB:0000002800283F2801283F3820283F2800280000000800080008003400C20000
+B7AC:0000002800283F2801283F3820283F28002800000048004800A8011406620000
+B7AD:0000002800283F2801283F3820283F2800280000000001F00208020801F00000
+B7AE:0000002800283F2801283F3820283F280028000003F80020002000D003080000
+B7AF:0000002800283F2801283F3820283F2800280000004003F8004000A003180000
+B7B0:0000002800283F2801283F3820283F280028000003F8000803F8000800080000
+B7B1:0000002800283F2801283F3820283F280028000003F8020003F8020003F80000
+B7B2:0000002800283F2801283F3820283F280028000000000FF8022002200FF80000
+B7B3:0000002800283F2801283F3820283F280028000000800FF803E0041003E00000
+B7B4:00000000001000103F900090009E3F902010201E20103F900010001000100000
+B7B5:0000000800083F08010E3F08200E3F080008000007F800080008000800080000
+B7B6:0000000800083F08010E3F08200E3F080008000000003EF80208020802080000
+B7B7:0000000800083F08010E3F08200E3F080008000000001F080108011401620000
+B7B8:0000000800083F08010E3F08200E3F080008000008000800080008000FF80000
+B7B9:0000000800083F08010E3F08200E3F0800080000000010F8101010301ECC0000
+B7BA:0000000800083F08010E3F08200E3F08000800000808087F081C08220F9C0000
+B7BB:0000000800083F08010E3F08200E3F080008000003F802000200020003F80000
+B7BC:0000000800083F08010E3F08200E3F080008000007F8000807F8040007F80000
+B7BD:0000000800083F08010E3F08200E3F08000800003EF802083E0820083E080000
+B7BE:0000000800083F08010E3F08200E3F08000800003EF802883E8820883EF80000
+B7BF:0000000800083F08010E3F08200E3F08000800003E8802883EF820883EF80000
+B7C0:0000000800083F08010E3F08200E3F08000800001F0801081F0810141F620000
+B7C1:0000000800083F08010E3F08200E3F08000800003EF802803EF820803EF80000
+B7C2:0000000800083F08010E3F08200E3F08000800003EFC02483E4820483EFC0000
+B7C3:0000000800083F08010E3F08200E3F08000800001F08017F1F1C10221F1C0000
+B7C4:0000000800083F08010E3F08200E3F080008000003F802080208020803F80000
+B7C5:0000000800083F08010E3F08200E3F08000800000208020803F8020803F80000
+B7C6:0000000800083F08010E3F08200E3F0800080000110811081F0811141F620000
+B7C7:0000000800083F08010E3F08200E3F0800080000001000100010006801840000
+B7C8:0000000800083F08010E3F08200E3F08000800000048004800A8011406620000
+B7C9:0000000800083F08010E3F08200E3F0800080000000003F00408040803F00000
+B7CA:0000000800083F08010E3F08200E3F080008000003F80020002000D003080000
+B7CB:0000000800083F08010E3F08200E3F0800080000004003F8004000A003180000
+B7CC:0000000800083F08010E3F08200E3F080008000003F8000803F8000800080000
+B7CD:0000000800083F08010E3F08200E3F080008000003F8020003F8020003F80000
+B7CE:0000000800083F08010E3F08200E3F080008000000000FF8022002200FF80000
+B7CF:0000000800083F08010E3F08200E3F080008000000800FF803E0041003E00000
+B7D0:00000000001200123F920092009E3F922012201E20123F920012001200120000
+B7D1:0000002800283F2801383F2820383F280028000007F800080008000800080000
+B7D2:0000002800283F2801383F2820383F280028000000003EF80208020802080000
+B7D3:0000002800283F2801383F2820383F280028000000003E100210022802C40000
+B7D4:0000002800283F2801383F2820383F280028002808000800080008000FF80000
+B7D5:0000002800283F2801383F2820383F2800280000000020F8201020303ECC0000
+B7D6:0000002800283F2801383F2820383F2800280000202021FC207020883E700000
+B7D7:0000002800283F2801383F2820383F280028000003F802000200020003F80000
+B7D8:0000002800283F2801383F2820383F280028000007F8000807F8040007F80000
+B7D9:0000002800283F2801383F2820383F28002800003EF802083E0820083E080000
+B7DA:0000002800283F2801383F2820383F28002800003EF802883E8820883EF80000
+B7DB:0000002800283F2801383F2820383F28002800003E8802883EF820883EF80000
+B7DC:0000002800283F2801383F2820383F28002800001F0801081F0810141F620000
+B7DD:0000002800283F2801383F2820383F28002800003EF802803EF820803EF80000
+B7DE:0000002800283F2801383F2820383F28002800003EFC02483E4820483EFC0000
+B7DF:0000002800283F2801383F2820383F28002800003E1002FE3E3820443E380000
+B7E0:0000002800283F2801383F2820383F280028000003F802080208020803F80000
+B7E1:0000002800283F2801383F2820383F28002800000208020803F8020803F80000
+B7E2:0000002800283F2801383F2820383F2800280000110811081F0811141F620000
+B7E3:0000002800283F2801383F2820383F2800280000000800080008003400C20000
+B7E4:0000002800283F2801383F2820383F28002800000048004800A8011406620000
+B7E5:0000002800283F2801383F2820383F2800280000000001F00208020801F00000
+B7E6:0000002800283F2801383F2820383F280028000003F80020002000D003080000
+B7E7:0000002800283F2801383F2820383F2800280000004003F8004000A003180000
+B7E8:0000002800283F2801383F2820383F280028000003F8000803F8000800080000
+B7E9:0000002800283F2801383F2820383F280028000003F8020003F8020003F80000
+B7EA:0000002800283F2801383F2820383F280028000000000FF8022002200FF80000
+B7EB:0000002800283F2801383F2820383F280028000000800FF803E0041003E00000
+B7EC:00000000000200023F82008200823F9E2002200220023F820002000200020000
+B7ED:0000000800083F0801083F3820083F0800080000000007F80008000800080000
+B7EE:0000000800083F0801083F3820083F080008000000003EF80208020802080000
+B7EF:0000000800083F0801083F3820083F080008000000001F080108011401620000
+B7F0:0000000800083F0801083F3820083F080008000000001000100010001FF80000
+B7F1:0000000800083F0801083F3820083F0800080000000020F8201020303ECC0000
+B7F2:0000000800083F0801083F3820083F0800080000202021FC207020883E700000
+B7F3:0000000800083F0801083F3820083F080008000003F802000200020003F80000
+B7F4:0000000800083F0801083F3820083F080008000007F8000807F8040007F80000
+B7F5:0000000800083F0801083F3820083F08000800003EF802083E0820083E080000
+B7F6:0000000800083F0801083F3820083F08000800003EF802883E8820883EF80000
+B7F7:0000000800083F0801083F3820083F08000800003E8802883EF820883EF80000
+B7F8:0000000800083F0801083F3820083F08000800000F8800880F8808140FA20000
+B7F9:0000000800083F0801083F3820083F08000800003EF802803EF820803EF80000
+B7FA:0000000800083F0801083F3820083F08000800003EFC02483E4820483EFC0000
+B7FB:0000000800083F0801083F3820083F08000800003E1002FE3E3820443E380000
+B7FC:0000000800083F0801083F3820083F080008000003F802080208020803F80000
+B7FD:0000000800083F0801083F3820083F08000800000208020803F8020803F80000
+B7FE:0000000800083F0801083F3820083F0800080000210821083F0821143F620000
+B7FF:0000000800083F0801083F3820083F0800080000001000100010006801840000
+B800:0000000800083F0801083F3820083F08000800000048004800A8011406620000
+B801:0000000800083F0801083F3820083F0800080000000003F00408040803F00000
+B802:0000000800083F0801083F3820083F080008000003F80020002000D003080000
+B803:0000000800083F0801083F3820083F0800080000004003F8004000A003180000
+B804:0000000800083F0801083F3820083F080008000003F8000803F8000800080000
+B805:0000000800083F0801083F3820083F080008000003F8020003F8020003F80000
+B806:0000000800083F0801083F3820083F080008000000000FF8022002200FF80000
+B807:0000000800083F0801083F3820083F080008000000800FF803E0041003E00000
+B808:00000000000A000A3F8A008A008A3FBA200A200A200A3F8A000A000A000A0000
+B809:0000002800283F2801283FE820283F280028000007F800080008000800080000
+B80A:0000002800283F2801283FE820283F280028000000003EF80208020802080000
+B80B:0000002800283F2801283FE820283F280028000000003E100210022802C40000
+B80C:0000002800283F2801283FE820283F280028000008000800080008000FF80000
+B80D:0000002800283F2801283FE820283F2800280000000020F8201020303ECC0000
+B80E:0000002800283F2801283FE820283F2800280000202021FC207020883E700000
+B80F:0000002800283F2801283FE820283F280028000003F802000200020003F80000
+B810:0000002800283F2801283FE820283F280028000007F8000807F8040007F80000
+B811:0000002800283F2801283FE820283F28002800003EF802083E0820083E080000
+B812:0000002800283F2801283FE820283F28002800003EF802883E8820883EF80000
+B813:0000002800283F2801283FE820283F28002800003E8802883EF820883EF80000
+B814:0000002800283F2801283FE820283F28002800001F0801081F0810141F620000
+B815:0000002800283F2801283FE820283F28002800003EF802803EF820803EF80000
+B816:0000002800283F2801283FE820283F28002800003EFC02483E4820483EFC0000
+B817:0000002800283F2801283FE820283F28002800003E1002FE3E3820443E380000
+B818:0000002800283F2801283FE820283F280028000003F802080208020803F80000
+B819:0000002800283F2801283FE820283F28002800000208020803F8020803F80000
+B81A:0000002800283F2801283FE820283F2800280000110811081F0811141F620000
+B81B:0000002800283F2801283FE820283F2800280000000800080008003400C20000
+B81C:0000002800283F2801283FE820283F28002800000048004800A8011406620000
+B81D:0000002800283F2801283FE820283F2800280000000001F00208020801F00000
+B81E:0000002800283F2801283FE820283F280028000003F80020002000D003080000
+B81F:0000002800283F2801283FE820283F2800280000004003F8004000A003180000
+B820:0000002800283F2801283FE820283F280028000003F8000803F8000800080000
+B821:0000002800283F2801283FE820283F280028000003F8020003F8020003F80000
+B822:0000002800283F2801283FE820283F280028000000000FF8022002200FF80000
+B823:0000002800283F2801283FE820283F280028000000800FF803E0041003E00000
+B824:00000000000200023F820082009E3F822002201E20023F820002000200020000
+B825:0000000800083F0801383F0820383F0800080000000007F80008000800080000
+B826:0000000800083F0801383F0820383F080008000000003EF80208020802080000
+B827:0000000800083F0801383F0820383F080008000000001F080108011401620000
+B828:0000000800083F0801383F0820383F080008000800001000100010001FF80000
+B829:0000000800083F0801383F0820383F0800080000000020F8201020303ECC0000
+B82A:0000000800083F0801383F0820383F0800080000202021FC207020883E700000
+B82B:0000000800083F0801383F0820383F080008000003F802000200020003F80000
+B82C:0000000800083F0801383F0820383F080008000007F8000807F8040007F80000
+B82D:0000000800083F0801383F0820383F08000800003EF802083E0820083E080000
+B82E:0000000800083F0801383F0820383F08000800003EF802883E8820883EF80000
+B82F:0000000800083F0801383F0820383F08000800003E8802883EF820883EF80000
+B830:0000000800083F0801383F0820383F08000800000F8800880F8808140FA20000
+B831:0000000800083F0801383F0820383F08000800003EF802803EF820803EF80000
+B832:0000000800083F0801383F0820383F08000800003EFC02483E4820483EFC0000
+B833:0000000800083F0801383F0820383F08000800003E1002FE3E3820443E380000
+B834:0000000800083F0801383F0820383F080008000003F802080208020803F80000
+B835:0000000800083F0801383F0820383F08000800000208020803F8020803F80000
+B836:0000000800083F0801383F0820383F0800080000210821083F0821143F620000
+B837:0000000800083F0801383F0820383F0800080000001000100010006801840000
+B838:0000000800083F0801383F0820383F08000800000048004800A8011406620000
+B839:0000000800083F0801383F0820383F0800080000000003F00408040803F00000
+B83A:0000000800083F0801383F0820383F080008000003F80020002000D003080000
+B83B:0000000800083F0801383F0820383F0800080000004003F8004000A003180000
+B83C:0000000800083F0801383F0820383F080008000003F8000803F8000800080000
+B83D:0000000800083F0801383F0820383F080008000003F8020003F8020003F80000
+B83E:0000000800083F0801383F0820383F080008000000000FF8022002200FF80000
+B83F:0000000800083F0801383F0820383F080008000000800FF803E0041003E00000
+B840:00000000000A000A3F8A008A00BA3F8A200A203A200A3F8A000A000A000A0000
+B841:0000002800283F2801E83F2820E83F280028000007F800080008000800080000
+B842:0000002800283F2801E83F2820E83F280028000000003EF80208020802080000
+B843:0000002800283F2801E83F2820E83F280028000000003E100210022802C40000
+B844:0000002800283F2801E83F2820E83F280028002808000800080008000FF80000
+B845:0000002800283F2801E83F2820E83F2800280000000020F8201020303ECC0000
+B846:0000002800283F2801E83F2820E83F2800280000202021FC207020883E700000
+B847:0000002800283F2801E83F2820E83F280028000003F802000200020003F80000
+B848:0000002800283F2801E83F2820E83F280028000007F8000807F8040007F80000
+B849:0000002800283F2801E83F2820E83F28002800003EF802083E0820083E080000
+B84A:0000002800283F2801E83F2820E83F28002800003EF802883E8820883EF80000
+B84B:0000002800283F2801E83F2820E83F28002800003E8802883EF820883EF80000
+B84C:0000002800283F2801E83F2820E83F28002800001F0801081F0810141F620000
+B84D:0000002800283F2801E83F2820E83F28002800003EF802803EF820803EF80000
+B84E:0000002800283F2801E83F2820E83F28002800003EFC02483E4820483EFC0000
+B84F:0000002800283F2801E83F2820E83F28002800003E1002FE3E3820443E380000
+B850:0000002800283F2801E83F2820E83F280028000003F802080208020803F80000
+B851:0000002800283F2801E83F2820E83F28002800000208020803F8020803F80000
+B852:0000002800283F2801E83F2820E83F2800280000110811081F0811141F620000
+B853:0000002800283F2801E83F2820E83F2800280000000800080008003400C20000
+B854:0000002800283F2801E83F2820E83F28002800000048004800A8011406620000
+B855:0000002800283F2801E83F2820E83F2800280000000001F00208020801F00000
+B856:0000002800283F2801E83F2820E83F280028000003F80020002000D003080000
+B857:0000002800283F2801E83F2820E83F2800280000004003F8004000A003180000
+B858:0000002800283F2801E83F2820E83F280028000003F8000803F8000800080000
+B859:0000002800283F2801E83F2820E83F280028000003F8020003F8020003F80000
+B85A:0000002800283F2801E83F2820E83F280028000000000FF8022002200FF80000
+B85B:0000002800283F2801E83F2820E83F280028000000800FF803E0041003E00000
+B85C:000000001FF0001000101FF0100010001FF000000100010001007FFC00000000
+B85D:00001FF000101FF010001FF0010001007FFC00001FF000100010001000100000
+B85E:00001FF000101FF010001FF0010001007FFC000000003EF80208020802080000
+B85F:00001FF000101FF010001FF0010001007FFC000000001E100210022802C40000
+B860:00001FF000101FF010001FF0010001007FFC000000001000100010001FF00000
+B861:00001FF000101FF010001FF0010001007FFC0000000020F8201020303ECC0000
+B862:00001FF000101FF010001FF0010001007FFC0000202021FC207020883E700000
+B863:00001FF000101FF010001FF0010001007FFC00001FF01000100010001FF00000
+B864:00001FF000101FF010001FF0010001007FFC00001FF000101FF010001FF00000
+B865:00001FF000101FF010001FF0010001007FFC00003EF802083E0820083E080000
+B866:00001FF000101FF010001FF0010001007FFC00003EF802883E8820883EF80000
+B867:00001FF000101FF010001FF0010001007FFC00003E8802883EF820883EF80000
+B868:00001FF000101FF010001FF0010001007FFC00003E1002103E1020283EC40000
+B869:00001FF000101FF010001FF0010001007FFC00003EF802803EF820803EF80000
+B86A:00001FF000101FF010001FF0010001007FFC00003EFC02483E4820483EFC0000
+B86B:00001FF000101FF010001FF0010001007FFC00003E2003FC3E7020883E700000
+B86C:00001FF000101FF010001FF0010001007FFC00001FF01010101010101FF00000
+B86D:00001FF000101FF010001FF0010001007FFC0000101010101FF010101FF00000
+B86E:00001FF000101FF010001FF0010001007FFC0000222022203E2022503E880000
+B86F:00001FF000101FF010001FF0010001007FFC000000000100010002800C400000
+B870:00001FF000101FF010001FF0010001007FFC00000000024002400DA033100000
+B871:00001FF000101FF010001FF0010001007FFC0000000007C00820082007C00000
+B872:00001FF000101FF010001FF0010001007FFC0000000007E00080014006200000
+B873:00001FF000101FF010001FF0010001007FFC0000008007E00080014006200000
+B874:00001FF000101FF010001FF0010001007FFC00001FF000101FF0001000100000
+B875:00001FF000101FF010001FF0010001007FFC00001FF010001FF010001FF00000
+B876:00001FF000101FF010001FF0010001007FFC000000001FF0044004401FF00000
+B877:00001FF000101FF010001FF0010001007FFC000001001FF007C0082007C00000
+B878:0000001000103F90009000903F90201E20103F90041004107FD0001000100000
+B879:000000083F8800883F8E20083F8804087FE8000007F800080008000800080000
+B87A:000000083F8800883F8E20083F8804087FE8000000003EF80208020802080000
+B87B:000000083F8800883F8E20083F8804087FE8000000001F080108011401620000
+B87C:000000083F8800883F8E20083F8804087FE8000008000800080008000FF80000
+B87D:000000083F8800883F8E20083F8804087FE80000000010F8101010301ECC0000
+B87E:000000083F8800883F8E20083F8804087FE800000808087F081C08220F9C0000
+B87F:000000083F8800883F8E20083F8804087FE8000003F802000200020003F80000
+B880:000000083F8800883F8E20083F8804087FE8000007F8000807F8040007F80000
+B881:000000083F8800883F8E20083F8804087FE800003EF802083E0820083E080000
+B882:000000083F8800883F8E20083F8804087FE800003EF802883E8820883EF80000
+B883:000000083F8800883F8E20083F8804087FE800003E8802883EF820883EF80000
+B884:000000083F8800883F8E20083F8804087FE800001F0801081F0810141F620000
+B885:000000083F8800883F8E20083F8804087FE800003EF802803EF820803EF80000
+B886:000000083F8800883F8E20083F8804087FE800003EFC02483E4820483EFC0000
+B887:000000083F8800883F8E20083F8804087FE800001F08017F1F1C10221F1C0000
+B888:000000083F8800883F8E20083F8804087FE8000003F802080208020803F80000
+B889:000000083F8800883F8E20083F8804087FE800000208020803F8020803F80000
+B88A:000000083F8800883F8E20083F8804087FE80000110811081F0811141F620000
+B88B:000000083F8800883F8E20083F8804087FE80000001000100010006801840000
+B88C:000000083F8800883F8E20083F8804087FE800000048004800A8011406620000
+B88D:000000083F8800883F8E20083F8804087FE80000000003F00408040803F00000
+B88E:000000083F8800883F8E20083F8804087FE8000003F80020002000D003080000
+B88F:000000083F8800883F8E20083F8804087FE80000004003F8004000A003180000
+B890:000000083F8800883F8E20083F8804087FE8000003F8000803F8000800080000
+B891:000000083F8800883F8E20083F8804087FE8000003F8020003F8020003F80000
+B892:000000083F8800883F8E20083F8804087FE8000000000FF8022002200FF80000
+B893:000000083F8800883F8E20083F8804087FE8000000800FF803E0041003E00000
+B894:0000001200123F92009200923F92201E20123F92041204127FD2001200120000
+B895:000000283FA800A83FB820283FA804287FA8000007F800080008000800080000
+B896:000000283FA800A83FB820283FA804287FA8000000003EF80208020802080000
+B897:000000283FA800A83FB820283FA804287FA8000000001F080108011401620000
+B898:000000283FA800A83FB820283FA804287FA8000008000800080008000FF80000
+B899:000000283FA800A83FB820283FA804287FA80000000010F8101010301ECC0000
+B89A:000000283FA800A83FB820283FA804287FA800000808087F081C08220F9C0000
+B89B:000000283FA800A83FB820283FA804287FA8000003F802000200020003F80000
+B89C:000000283FA800A83FB820283FA804287FA8000007F8000807F8040007F80000
+B89D:000000283FA800A83FB820283FA804287FA800003EF802083E0820083E080000
+B89E:000000283FA800A83FB820283FA804287FA800003EF802883E8820883EF80000
+B89F:000000283FA800A83FB820283FA804287FA800003E8802883EF820883EF80000
+B8A0:000000283FA800A83FB820283FA804287FA800001F0801081F0810141F620000
+B8A1:000000283FA800A83FB820283FA804287FA800003EF802803EF820803EF80000
+B8A2:000000283FA800A83FB820283FA804287FA800003EFC02483E4820483EFC0000
+B8A3:000000283FA800A83FB820283FA804287FA800001F08017F1F1C10221F1C0000
+B8A4:000000283FA800A83FB820283FA804287FA8000003F802080208020803F80000
+B8A5:000000283FA800A83FB820283FA804287FA800000208020803F8020803F80000
+B8A6:000000283FA800A83FB820283FA804287FA80000110811081F0811141F620000
+B8A7:000000283FA800A83FB820283FA804287FA80000001000100010006801840000
+B8A8:000000283FA800A83FB820283FA804287FA800000048004800A8011406620000
+B8A9:000000283FA800A83FB820283FA804287FA80000000003F00408040803F00000
+B8AA:000000283FA800A83FB820283FA804287FA8000003F80020002000D003080000
+B8AB:000000283FA800A83FB820283FA804287FA80000004003F8004000A003180000
+B8AC:000000283FA800A83FB820283FA804287FA8000003F8000803F8000800080000
+B8AD:000000283FA800A83FB820283FA804287FA8000003F8020003F8020003F80000
+B8AE:000000283FA800A83FB820283FA804287FA8000000000FF8022002200FF80000
+B8AF:000000283FA800A83FB820283FA804287FA8000000800FF803E0041003E00000
+B8B0:0000000800083F88008800883F88200820083F88040804087FE8000800080000
+B8B1:000000083F8800883F8820083F8804087FE8000007F800080008000800080000
+B8B2:000000083F8800883F8820083F8804087FE8000000003EF80208020802080000
+B8B3:000000083F8800883F8820083F8804087FE8000000001F080108011401620000
+B8B4:000000083F8800883F8820083F8804087FE8000008000800080008000FF80000
+B8B5:000000083F8800883F8820083F8804087FE80000000010F8101010301ECC0000
+B8B6:000000083F8800883F8820083F8804087FE800000808087F081C08220F9C0000
+B8B7:000000083F8800883F8820083F8804087FE8000003F802000200020003F80000
+B8B8:000000083F8800883F8820083F8804087FE8000007F8000807F8040007F80000
+B8B9:000000083F8800883F8820083F8804087FE800003EF802083E0820083E080000
+B8BA:000000083F8800883F8820083F8804087FE800003EF802883E8820883EF80000
+B8BB:000000083F8800883F8820083F8804087FE800003E8802883EF820883EF80000
+B8BC:000000083F8800883F8820083F8804087FE800001F0801081F0810141F620000
+B8BD:000000083F8800883F8820083F8804087FE800003EF802803EF820803EF80000
+B8BE:000000083F8800883F8820083F8804087FE800003EFC02483E4820483EFC0000
+B8BF:000000083F8800883F8820083F8804087FE800001F08017F1F1C10221F1C0000
+B8C0:000000083F8800883F8820083F8804087FE8000003F802080208020803F80000
+B8C1:000000083F8800883F8820083F8804087FE800000208020803F8020803F80000
+B8C2:000000083F8800883F8820083F8804087FE80000110811081F0811141F620000
+B8C3:000000083F8800883F8820083F8804087FE80000001000100010006801840000
+B8C4:000000083F8800883F8820083F8804087FE800000048004800A8011406620000
+B8C5:000000083F8800883F8820083F8804087FE80000000003F00408040803F00000
+B8C6:000000083F8800883F8820083F8804087FE8000003F80020002000D003080000
+B8C7:000000083F8800883F8820083F8804087FE80000004003F8004000A003180000
+B8C8:000000083F8800883F8820083F8804087FE8000003F8000803F8000800080000
+B8C9:000000083F8800883F8820083F8804087FE8000003F8020003F8020003F80000
+B8CA:000000083F8800883F8820083F8804087FE8000000000FF8022002200FF80000
+B8CB:000000083F8800883F8820083F8804087FE8000000800FF803E0041003E00000
+B8CC:000000001FF0001000101FF0100010001FF004400440044004407FFC00000000
+B8CD:00001FF000101FF010001FF0044004407FFC00001FF000100010001000100000
+B8CE:00001FF000101FF010001FF0044004407FFC000000003EF80208020802080000
+B8CF:00001FF000101FF010001FF0044004407FFC000000001E100210022802C40000
+B8D0:00001FF000101FF010001FF0044004407FFC000000001000100010001FF00000
+B8D1:00001FF000101FF010001FF0044004407FFC0000000020F8201020303ECC0000
+B8D2:00001FF000101FF010001FF0044004407FFC0000202021FC207020883E700000
+B8D3:00001FF000101FF010001FF0044004407FFC00001FF01000100010001FF00000
+B8D4:00001FF000101FF010001FF0044004407FFC00001FF000101FF010001FF00000
+B8D5:00001FF000101FF010001FF0044004407FFC00003EF802083E0820083E080000
+B8D6:00001FF000101FF010001FF0044004407FFC00003EF802883E8820883EF80000
+B8D7:00001FF000101FF010001FF0044004407FFC00003E8802883EF820883EF80000
+B8D8:00001FF000101FF010001FF0044004407FFC00003E1002103E1020283EC40000
+B8D9:00001FF000101FF010001FF0044004407FFC00003EF802803EF820803EF80000
+B8DA:00001FF000101FF010001FF0044004407FFC00003EFC02483E4820483EFC0000
+B8DB:00001FF000101FF010001FF0044004407FFC00003E2003FC3E7020883E700000
+B8DC:00001FF000101FF010001FF0044004407FFC00001FF01010101010101FF00000
+B8DD:00001FF000101FF010001FF0044004407FFC0000101010101FF010101FF00000
+B8DE:00001FF000101FF010001FF0044004407FFC0000222022203E2022503E880000
+B8DF:00001FF000101FF010001FF0044004407FFC000000000100010002800C400000
+B8E0:00001FF000101FF010001FF0044004407FFC00000000024002400DA033100000
+B8E1:00001FF000101FF010001FF0044004407FFC0000000007C00820082007C00000
+B8E2:00001FF000101FF010001FF0044004407FFC0000000007E00080014006200000
+B8E3:00001FF000101FF010001FF0044004407FFC0000008007E00080014006200000
+B8E4:00001FF000101FF010001FF0044004407FFC00001FF000101FF0001000100000
+B8E5:00001FF000101FF010001FF0044004407FFC00001FF010001FF010001FF00000
+B8E6:00001FF000101FF010001FF0044004407FFC000000001FF0044004401FF00000
+B8E7:00001FF000101FF010001FF0044004407FFC000001001FF007C0082007C00000
+B8E8:000000001FF0001000101FF0100010001FF000003FF801000100010001000000
+B8E9:00001FF000101FF010001FF000007FFC010001001FF000100010001000100000
+B8EA:00001FF000101FF010001FF000007FFC0100010000003EF80208020802080000
+B8EB:00001FF000101FF010001FF000007FFC0100010000001E100210022802C40000
+B8EC:00001FF000101FF010001FF0000000007FFC010001001100100010001FF00000
+B8ED:00001FF000101FF010001FF000007FFC01000100000020F8201020303ECC0000
+B8EE:00001FF000101FF010001FF000007FFC01000100202021FC207020883E700000
+B8EF:00001FF000101FF010001FF000007FFC010001001FF01000100010001FF00000
+B8F0:00001FF000101FF010001FF000007FFC010001001FF000101FF010001FF00000
+B8F1:00001FF000101FF010001FF000007FFC010001003EF802083E0820083E080000
+B8F2:00001FF000101FF010001FF000007FFC010001003EF802883E8820883EF80000
+B8F3:00001FF000101FF010001FF000007FFC010001003E8802883EF820883EF80000
+B8F4:00001FF000101FF010001FF000007FFC010001003E1002103E1020283EC40000
+B8F5:00001FF000101FF010001FF000007FFC010001003EF802803EF820803EF80000
+B8F6:00001FF000101FF010001FF000007FFC010001003EFC02483E4820483EFC0000
+B8F7:00001FF000101FF010001FF000007FFC010001003E2003FC3E7020883E700000
+B8F8:00001FF000101FF010001FF000007FFC010001001FF01010101010101FF00000
+B8F9:00001FF000101FF010001FF000007FFC01000100101010101FF010101FF00000
+B8FA:00001FF000101FF010001FF000007FFC01000100222022203E2022503E880000
+B8FB:00001FF000101FF010001FF000007FFC0100010000000100010002800C400000
+B8FC:00001FF000101FF010001FF000007FFC010001000000024002400DA033100000
+B8FD:00001FF000101FF010001FF000007FFC01000100000007C00820082007C00000
+B8FE:00001FF000101FF010001FF000007FFC01000100000007E00080014006200000
+B8FF:00001FF000101FF010001FF000007FFC01000100008007E00080014006200000
+B900:00001FF000101FF010001FF000007FFC010001001FF000101FF0001000100000
+B901:00001FF000101FF010001FF000007FFC010001001FF010001FF010001FF00000
+B902:00001FF000101FF010001FF000007FFC0100010000001FF0044004401FF00000
+B903:00001FF000101FF010001FF000007FFC0100010001001FF007C0082007C00000
+B904:000000083FC8004800483FC8200820083FC800087FE8040804F8040804080000
+B905:7F8800887F8840087F8800087FE8027802080000000007F80008000800080000
+B906:7F8800887F8840087F8800087FE802780208000000003EF80208020802080000
+B907:7F8800887F8840087F8800087FE802780208000000001F080108011401620000
+B908:7F8800887F8840087F88000800087FE80278020802081000100010001FF80000
+B909:7F8800887F8840087F8800087FE8027802080000000020F8201020303ECC0000
+B90A:7F8800887F8840087F8800087FE8027802080000202021FC207020883E700000
+B90B:7F8800887F8840087F8800087FE802780208000003F802000200020003F80000
+B90C:7F8800887F8840087F8800087FE802780208000007F8000807F8040007F80000
+B90D:7F8800887F8840087F8800087FE80278020800003EF802083E0820083E080000
+B90E:7F8800887F8840087F8800087FE80278020800003EF802883E8820883EF80000
+B90F:7F8800887F8840087F8800087FE80278020800003E8802883EF820883EF80000
+B910:7F8800887F8840087F8800087FE80278020800000F8800880F8808140FA20000
+B911:7F8800887F8840087F8800087FE80278020800003EF802803EF820803EF80000
+B912:7F8800887F8840087F8800087FE80278020800003EFC02483E4820483EFC0000
+B913:7F8800887F8840087F8800087FE80278020800003E1002FE3E3820443E380000
+B914:7F8800887F8840087F8800087FE802780208000003F802080208020803F80000
+B915:7F8800887F8840087F8800087FE80278020800000208020803F8020803F80000
+B916:7F8800887F8840087F8800087FE8027802080000210821083F0821143F620000
+B917:7F8800887F8840087F8800087FE8027802080000001000100010006801840000
+B918:7F8800887F8840087F8800087FE80278020800000048004800A8011406620000
+B919:7F8800887F8840087F8800087FE8027802080000000003F00408040803F00000
+B91A:7F8800887F8840087F8800087FE802780208000003F80020002000D003080000
+B91B:7F8800887F8840087F8800087FE8027802080000004003F8004000A003180000
+B91C:7F8800887F8840087F8800087FE802780208000003F8000803F8000800080000
+B91D:7F8800887F8840087F8800087FE802780208000003F8020003F8020003F80000
+B91E:7F8800887F8840087F8800087FE802780208000000000FF8022002200FF80000
+B91F:7F8800887F8840087F8800087FE802780208000000800FF803E0041003E00000
+B920:0000000A3FCA004A004A3FCA200A200A3FCA000A7FEA040A047A040A040A0000
+B921:7FA800A87FA840287FA800287FA805E804280000000007F80008000800080000
+B922:7FA800A87FA840287FA800287FA805E80428000000003EF80208020802080000
+B923:7FA800A87FA840287FA800287FA805E80428000000001F080108011401620000
+B924:7FA800A87FA840287FA8002800287FA8042805E804281428100010001FF80000
+B925:7FA800A87FA840287FA800287FA805E804280000000020F8201020303ECC0000
+B926:7FA800A87FA840287FA800287FA805E804280000202021FC207020883E700000
+B927:7FA800A87FA840287FA800287FA805E80428000003F802000200020003F80000
+B928:7FA800A87FA840287FA800287FA805E80428000007F8000807F8040007F80000
+B929:7FA800A87FA840287FA800287FA805E8042800003EF802083E0820083E080000
+B92A:7FA800A87FA840287FA800287FA805E8042800003EF802883E8820883EF80000
+B92B:7FA800A87FA840287FA800287FA805E8042800003E8802883EF820883EF80000
+B92C:7FA800A87FA840287FA800287FA805E8042800000F8800880F8808140FA20000
+B92D:7FA800A87FA840287FA800287FA805E8042800003EF802803EF820803EF80000
+B92E:7FA800A87FA840287FA800287FA805E8042800003EFC02483E4820483EFC0000
+B92F:7FA800A87FA840287FA800287FA805E8042800003E1002FE3E3820443E380000
+B930:7FA800A87FA840287FA800287FA805E80428000003F802080208020803F80000
+B931:7FA800A87FA840287FA800287FA805E8042800000208020803F8020803F80000
+B932:7FA800A87FA840287FA800287FA805E804280000210821083F0821143F620000
+B933:7FA800A87FA840287FA800287FA805E804280000001000100010006801840000
+B934:7FA800A87FA840287FA800287FA805E8042800000048004800A8011406620000
+B935:7FA800A87FA840287FA800287FA805E804280000000003F00408040803F00000
+B936:7FA800A87FA840287FA800287FA805E80428000003F80020002000D003080000
+B937:7FA800A87FA840287FA800287FA805E804280000004003F8004000A003180000
+B938:7FA800A87FA840287FA800287FA805E80428000003F8000803F8000800080000
+B939:7FA800A87FA840287FA800287FA805E80428000003F8020003F8020003F80000
+B93A:7FA800A87FA840287FA800287FA805E80428000000000FF8022002200FF80000
+B93B:7FA800A87FA840287FA800287FA805E80428000000800FF803E0041003E00000
+B93C:000000083FC8004800483FC8200820083FC800087FE804080408040804080000
+B93D:7F8800887F8840087F8800087FE8020802000000000007F80008000800080000
+B93E:7F8800887F8840087F8800087FE802080200000000003EF80208020802080000
+B93F:7F8800887F8840087F8800087FE802080200000000001F080108011401620000
+B940:7F8800887F8840087F88000800087FE80208020802081008100010001FF80000
+B941:7F8800887F8840087F8800087FE8020802000000000020F8201020303ECC0000
+B942:7F8800887F8840087F8800087FE8020802000000202021FC207020883E700000
+B943:7F8800887F8840087F8800087FE802080200000003F802000200020003F80000
+B944:7F8800887F8840087F8800087FE802080200000007F8000807F8040007F80000
+B945:7F8800887F8840087F8800087FE80208020000003EF802083E0820083E080000
+B946:7F8800887F8840087F8800087FE80208020000003EF802883E8820883EF80000
+B947:7F8800887F8840087F8800087FE80208020000003E8802883EF820883EF80000
+B948:7F8800887F8840087F8800087FE80208020000000F8800880F8808140FA20000
+B949:7F8800887F8840087F8800087FE80208020000003EF802803EF820803EF80000
+B94A:7F8800887F8840087F8800087FE80208020000003EFC02483E4820483EFC0000
+B94B:7F8800887F8840087F8800087FE80208020000003E1002FE3E3820443E380000
+B94C:7F8800887F8840087F8800087FE802080200000003F802080208020803F80000
+B94D:7F8800887F8840087F8800087FE80208020000000208020803F8020803F80000
+B94E:7F8800887F8840087F8800087FE8020802000000210821083F0821143F620000
+B94F:7F8800887F8840087F8800087FE8020802000000001000100010006801840000
+B950:7F8800887F8840087F8800087FE80208020000000048004800A8011406620000
+B951:7F8800887F8840087F8800087FE8020802000000000003F00408040803F00000
+B952:7F8800887F8840087F8800087FE802080200000003F80020002000D003080000
+B953:7F8800887F8840087F8800087FE8020802000000004003F8004000A003180000
+B954:7F8800887F8840087F8800087FE802080200000003F8000803F8000800080000
+B955:7F8800887F8840087F8800087FE802080200000003F8020003F8020003F80000
+B956:7F8800887F8840087F8800087FE802080200000000000FF8022002200FF80000
+B957:7F8800887F8840087F8800087FE802080200000000800FF803E0041003E00000
+B958:000000001FF0001000101FF0100010001FF000007FFC04400440044004400000
+B959:00001FF000101FF010001FF000007FFC044004401FF000100010001000100000
+B95A:00001FF000101FF010001FF000007FFC0440044000003EF80208020802080000
+B95B:00001FF000101FF010001FF000007FFC0440044000001E100210022802C40000
+B95C:00001FF000101FF010001FF0000000007FFC044004401440100010001FF00000
+B95D:00001FF000101FF010001FF000007FFC04400440000020F8201020303ECC0000
+B95E:00001FF000101FF010001FF000007FFC04400440202021FC207020883E700000
+B95F:00001FF000101FF010001FF000007FFC044004401FF01000100010001FF00000
+B960:00001FF000101FF010001FF000007FFC044004401FF000101FF010001FF00000
+B961:00001FF000101FF010001FF000007FFC044004403EF802083E0820083E080000
+B962:00001FF000101FF010001FF000007FFC044004403EF802883E8820883EF80000
+B963:00001FF000101FF010001FF000007FFC044004403E8802883EF820883EF80000
+B964:00001FF000101FF010001FF000007FFC044004403E1002103E1020283EC40000
+B965:00001FF000101FF010001FF000007FFC044004403EF802803EF820803EF80000
+B966:00001FF000101FF010001FF000007FFC044004403EFC02483E4820483EFC0000
+B967:00001FF000101FF010001FF000007FFC044004403E2003FC3E7020883E700000
+B968:00001FF000101FF010001FF000007FFC044004401FF01010101010101FF00000
+B969:00001FF000101FF010001FF000007FFC04400440101010101FF010101FF00000
+B96A:00001FF000101FF010001FF000007FFC04400440222022203E2022503E880000
+B96B:00001FF000101FF010001FF000007FFC0440044000000100010002800C400000
+B96C:00001FF000101FF010001FF000007FFC044004400000024002400DA033100000
+B96D:00001FF000101FF010001FF000007FFC04400440000007C00820082007C00000
+B96E:00001FF000101FF010001FF000007FFC04400440000007E00080014006200000
+B96F:00001FF000101FF010001FF000007FFC04400440008007E00080014006200000
+B970:00001FF000101FF010001FF000007FFC044004401FF000101FF0001000100000
+B971:00001FF000101FF010001FF000007FFC044004401FF010001FF010001FF00000
+B972:00001FF000101FF010001FF000007FFC0440044000001FF0044004401FF00000
+B973:00001FF000101FF010001FF000007FFC0440044001001FF007C0082007C00000
+B974:000000001FF0001000101FF0100010001FF0000000007FFC0000000000000000
+B975:00001FF000101FF010001FF0000000007FFC00001FF000100010001000100000
+B976:00001FF000101FF010001FF0000000007FFC000000003EF80208020802080000
+B977:00001FF000101FF010001FF0000000007FFC000000001E100210022802C40000
+B978:00001FF000101FF010001FF0000000007FFC000000001000100010001FF00000
+B979:00001FF000101FF010001FF0000000007FFC0000000020F8201020303ECC0000
+B97A:00001FF000101FF010001FF0000000007FFC0000202021FC207020883E700000
+B97B:00001FF000101FF010001FF0000000007FFC00001FF01000100010001FF00000
+B97C:00001FF000101FF010001FF0000000007FFC00001FF000101FF010001FF00000
+B97D:00001FF000101FF010001FF0000000007FFC00003EF802083E0820083E080000
+B97E:00001FF000101FF010001FF0000000007FFC00003EF802883E8820883EF80000
+B97F:00001FF000101FF010001FF0000000007FFC00003E8802883EF820883EF80000
+B980:00001FF000101FF010001FF0000000007FFC00003E1002103E1020283EC40000
+B981:00001FF000101FF010001FF0000000007FFC00003EF802803EF820803EF80000
+B982:00001FF000101FF010001FF0000000007FFC00003EFC02483E4820483EFC0000
+B983:00001FF000101FF010001FF0000000007FFC00003E2003FC3E7020883E700000
+B984:00001FF000101FF010001FF0000000007FFC00001FF01010101010101FF00000
+B985:00001FF000101FF010001FF0000000007FFC0000101010101FF010101FF00000
+B986:00001FF000101FF010001FF0000000007FFC0000222022203E2022503E880000
+B987:00001FF000101FF010001FF0000000007FFC000000000100010002800C400000
+B988:00001FF000101FF010001FF0000000007FFC00000000024002400DA033100000
+B989:00001FF000101FF010001FF0000000007FFC0000000007C00820082007C00000
+B98A:00001FF000101FF010001FF0000000007FFC0000000007E00080014006200000
+B98B:00001FF000101FF010001FF0000000007FFC0000008007E00080014006200000
+B98C:00001FF000101FF010001FF0000000007FFC00001FF000101FF0001000100000
+B98D:00001FF000101FF010001FF0000000007FFC00001FF010001FF010001FF00000
+B98E:00001FF000101FF010001FF0000000007FFC000000001FF0044004401FF00000
+B98F:00001FF000101FF010001FF0000000007FFC000001001FF007C0082007C00000
+B990:0000000800083F88008800883F88200820083F8800087FE80008000800080000
+B991:000000083F8800883F8820083F8800087FE8000007F800080008000800080000
+B992:000000083F8800883F8820083F8800087FE8000000003EF80208020802080000
+B993:000000083F8800883F8820083F8800087FE8000000001F080108011401620000
+B994:000000083F8800883F8820083F8800087FE8000008000800080008000FF80000
+B995:000000083F8800883F8820083F8800087FE80000000010F8101010301ECC0000
+B996:000000083F8800883F8820083F8800087FE800000808087F081C08220F9C0000
+B997:000000083F8800883F8820083F8800087FE8000003F802000200020003F80000
+B998:000000083F8800883F8820083F8800087FE8000007F8000807F8040007F80000
+B999:000000083F8800883F8820083F8800087FE800003EF802083E0820083E080000
+B99A:000000083F8800883F8820083F8800087FE800003EF802883E8820883EF80000
+B99B:000000083F8800883F8820083F8800087FE800003E8802883EF820883EF80000
+B99C:000000083F8800883F8820083F8800087FE800001F0801081F0810141F620000
+B99D:000000083F8800883F8820083F8800087FE800003EF802803EF820803EF80000
+B99E:000000083F8800883F8820083F8800087FE800003EFC02483E4820483EFC0000
+B99F:000000083F8800883F8820083F8800087FE800001F08017F1F1C10221F1C0000
+B9A0:000000083F8800883F8820083F8800087FE8000003F802080208020803F80000
+B9A1:000000083F8800883F8820083F8800087FE800000208020803F8020803F80000
+B9A2:000000083F8800883F8820083F8800087FE80000110811081F0811141F620000
+B9A3:000000083F8800883F8820083F8800087FE80000001000100010006801840000
+B9A4:000000083F8800883F8820083F8800087FE800000048004800A8011406620000
+B9A5:000000083F8800883F8820083F8800087FE80000000003F00408040803F00000
+B9A6:000000083F8800883F8820083F8800087FE8000003F80020002000D003080000
+B9A7:000000083F8800883F8820083F8800087FE80000004003F8004000A003180000
+B9A8:000000083F8800883F8820083F8800087FE8000003F8000803F8000800080000
+B9A9:000000083F8800883F8820083F8800087FE8000003F8020003F8020003F80000
+B9AA:000000083F8800883F8820083F8800087FE8000000000FF8022002200FF80000
+B9AB:000000083F8800883F8820083F8800087FE8000000800FF803E0041003E00000
+B9AC:00000000000800083F88008800883F882008200820083F880008000800080000
+B9AD:0000000800083F0801083F0820083F0800080000000007F80008000800080000
+B9AE:0000000800083F0801083F0820083F080008000000003EF80208020802080000
+B9AF:0000000800083F0801083F0820083F080008000000001F080108011401620000
+B9B0:0000000800083F0801083F0820083F080008000800001000100010001FF80000
+B9B1:0000000800083F0801083F0820083F0800080000000020F8201020303ECC0000
+B9B2:0000000800083F0801083F0820083F0800080000202021FC207020883E700000
+B9B3:0000000800083F0801083F0820083F080008000003F802000200020003F80000
+B9B4:0000000800083F0801083F0820083F080008000007F8000807F8040007F80000
+B9B5:0000000800083F0801083F0820083F08000800003EF802083E0820083E080000
+B9B6:0000000800083F0801083F0820083F08000800003EF802883E8820883EF80000
+B9B7:0000000800083F0801083F0820083F08000800003E8802883EF820883EF80000
+B9B8:0000000800083F0801083F0820083F08000800000F8800880F8808140FA20000
+B9B9:0000000800083F0801083F0820083F08000800003EF802803EF820803EF80000
+B9BA:0000000800083F0801083F0820083F08000800003EFC02483E4820483EFC0000
+B9BB:0000000800083F0801083F0820083F08000800003E1002FE3E3820443E380000
+B9BC:0000000800083F0801083F0820083F080008000003F802080208020803F80000
+B9BD:0000000800083F0801083F0820083F08000800000208020803F8020803F80000
+B9BE:0000000800083F0801083F0820083F0800080000210821083F0821143F620000
+B9BF:0000000800083F0801083F0820083F0800080000001000100010006801840000
+B9C0:0000000800083F0801083F0820083F08000800000048004800A8011406620000
+B9C1:0000000800083F0801083F0820083F0800080000000003F00408040803F00000
+B9C2:0000000800083F0801083F0820083F080008000003F80020002000D003080000
+B9C3:0000000800083F0801083F0820083F0800080000004003F8004000A003180000
+B9C4:0000000800083F0801083F0820083F080008000003F8000803F8000800080000
+B9C5:0000000800083F0801083F0820083F080008000003F8020003F8020003F80000
+B9C6:0000000800083F0801083F0820083F080008000000000FF8022002200FF80000
+B9C7:0000000800083F0801083F0820083F080008000000800FF803E0041003E00000
+B9C8:00000000001000107F9040904090409E4090409040907F900010001000100000
+B9C9:000000087E0842084208420E42087E080008000007F800080008000800080000
+B9CA:000000087E0842084208420E42087E080008000000003EF80208020802080000
+B9CB:000000087E0842084208420E42087E080008000000001F080108011401620000
+B9CC:000000087E0842084208420E42087E080008000808000800080008000FF80000
+B9CD:000000087E0842084208420E42087E0800080000000010F8101010301ECC0000
+B9CE:000000087E0842084208420E42087E08000800000808087F081C08220F9C0000
+B9CF:000000087E0842084208420E42087E080008000003F802000200020003F80000
+B9D0:000000087E0842084208420E42087E080008000007F8000807F8040007F80000
+B9D1:000000087E0842084208420E42087E08000800003EF802083E0820083E080000
+B9D2:000000087E0842084208420E42087E08000800003EF802883E8820883EF80000
+B9D3:000000087E0842084208420E42087E08000800003E8802883EF820883EF80000
+B9D4:000000087E0842084208420E42087E08000800001F0801081F0810141F620000
+B9D5:000000087E0842084208420E42087E08000800003EF802803EF820803EF80000
+B9D6:000000087E0842084208420E42087E08000800003EFC02483E4820483EFC0000
+B9D7:000000087E0842084208420E42087E08000800001F08017F1F1C10221F1C0000
+B9D8:000000087E0842084208420E42087E080008000003F802080208020803F80000
+B9D9:000000087E0842084208420E42087E08000800000208020803F8020803F80000
+B9DA:000000087E0842084208420E42087E0800080000110811081F0811141F620000
+B9DB:000000087E0842084208420E42087E0800080000001000100010006801840000
+B9DC:000000087E0842084208420E42087E08000800000048004800A8011406620000
+B9DD:000000087E0842084208420E42087E0800080000000003F00408040803F00000
+B9DE:000000087E0842084208420E42087E080008000003F80020002000D003080000
+B9DF:000000087E0842084208420E42087E0800080000004003F8004000A003180000
+B9E0:000000087E0842084208420E42087E080008000003F8000803F8000800080000
+B9E1:000000087E0842084208420E42087E080008000003F8020003F8020003F80000
+B9E2:000000087E0842084208420E42087E080008000000000FF8022002200FF80000
+B9E3:000000087E0842084208420E42087E080008000000800FF803E0041003E00000
+B9E4:00000000001200127F9240924092409E4092409240927F920012001200120000
+B9E5:000000287E2842284228423842287E280028000007F800080008000800080000
+B9E6:000000287E2842284228423842287E280028000000003EF80208020802080000
+B9E7:000000287E2842284228423842287E280028000000003E100210022802C40000
+B9E8:000000287E2842284228423842287E280028002808000800080008000FF80000
+B9E9:000000287E2842284228423842287E2800280000000020F8201020303ECC0000
+B9EA:000000287E2842284228423842287E2800280000202021FC207020883E700000
+B9EB:000000287E2842284228423842287E280028000003F802000200020003F80000
+B9EC:000000287E2842284228423842287E280028000007F8000807F8040007F80000
+B9ED:000000287E2842284228423842287E28002800003EF802083E0820083E080000
+B9EE:000000287E2842284228423842287E28002800003EF802883E8820883EF80000
+B9EF:000000287E2842284228423842287E28002800003E8802883EF820883EF80000
+B9F0:000000287E2842284228423842287E28002800001F0801081F0810141F620000
+B9F1:000000287E2842284228423842287E28002800003EF802803EF820803EF80000
+B9F2:000000287E2842284228423842287E28002800003EFC02483E4820483EFC0000
+B9F3:000000287E2842284228423842287E28002800003E1002FE3E3820443E380000
+B9F4:000000287E2842284228423842287E280028000003F802080208020803F80000
+B9F5:000000287E2842284228423842287E28002800000208020803F8020803F80000
+B9F6:000000287E2842284228423842287E2800280000110811081F0811141F620000
+B9F7:000000287E2842284228423842287E2800280000000800080008003400C20000
+B9F8:000000287E2842284228423842287E28002800000048004800A8011406620000
+B9F9:000000287E2842284228423842287E2800280000000001F00208020801F00000
+B9FA:000000287E2842284228423842287E280028000003F80020002000D003080000
+B9FB:000000287E2842284228423842287E2800280000004003F8004000A003180000
+B9FC:000000287E2842284228423842287E280028000003F8000803F8000800080000
+B9FD:000000287E2842284228423842287E280028000003F8020003F8020003F80000
+B9FE:000000287E2842284228423842287E280028000000000FF8022002200FF80000
+B9FF:000000287E2842284228423842287E280028000000800FF803E0041003E00000
+BA00:00000000001000107F904090409E40904090409E40907F900010001000100000
+BA01:000000087E084208420E4208420E7E080008000007F800080008000800080000
+BA02:000000087E084208420E4208420E7E080008000000003EF80208020802080000
+BA03:000000087E084208420E4208420E7E080008000000001F080108011401620000
+BA04:000000087E084208420E4208420E7E080008000008000800080008000FF80000
+BA05:000000087E084208420E4208420E7E0800080000000010F8101010301ECC0000
+BA06:000000087E084208420E4208420E7E08000800000808087F081C08220F9C0000
+BA07:000000087E084208420E4208420E7E080008000003F802000200020003F80000
+BA08:000000087E084208420E4208420E7E080008000007F8000807F8040007F80000
+BA09:000000087E084208420E4208420E7E08000800003EF802083E0820083E080000
+BA0A:000000087E084208420E4208420E7E08000800003EF802883E8820883EF80000
+BA0B:000000087E084208420E4208420E7E08000800003E8802883EF820883EF80000
+BA0C:000000087E084208420E4208420E7E08000800001F0801081F0810141F620000
+BA0D:000000087E084208420E4208420E7E08000800003EF802803EF820803EF80000
+BA0E:000000087E084208420E4208420E7E08000800003EFC02483E4820483EFC0000
+BA0F:000000087E084208420E4208420E7E08000800001F08017F1F1C10221F1C0000
+BA10:000000087E084208420E4208420E7E080008000003F802080208020803F80000
+BA11:000000087E084208420E4208420E7E08000800000208020803F8020803F80000
+BA12:000000087E084208420E4208420E7E0800080000110811081F0811141F620000
+BA13:000000087E084208420E4208420E7E0800080000001000100010006801840000
+BA14:000000087E084208420E4208420E7E08000800000048004800A8011406620000
+BA15:000000087E084208420E4208420E7E0800080000000003F00408040803F00000
+BA16:000000087E084208420E4208420E7E080008000003F80020002000D003080000
+BA17:000000087E084208420E4208420E7E0800080000004003F8004000A003180000
+BA18:000000087E084208420E4208420E7E080008000003F8000803F8000800080000
+BA19:000000087E084208420E4208420E7E080008000003F8020003F8020003F80000
+BA1A:000000087E084208420E4208420E7E080008000000000FF8022002200FF80000
+BA1B:000000087E084208420E4208420E7E080008000000800FF803E0041003E00000
+BA1C:00000000001200127F924092409E40924092409E40927F920012001200120000
+BA1D:000000287E2842284238422842387E280028000007F800080008000800080000
+BA1E:000000287E2842284238422842387E280028000000003EF80208020802080000
+BA1F:000000287E2842284238422842387E280028000000003E100210022802C40000
+BA20:000000287E2842284238422842387E280028002808000800080008000FF80000
+BA21:000000287E2842284238422842387E2800280000000020F8201020303ECC0000
+BA22:000000287E2842284238422842387E2800280000202021FC207020883E700000
+BA23:000000287E2842284238422842387E280028000003F802000200020003F80000
+BA24:000000287E2842284238422842387E280028000007F8000807F8040007F80000
+BA25:000000287E2842284238422842387E28002800003EF802083E0820083E080000
+BA26:000000287E2842284238422842387E28002800003EF802883E8820883EF80000
+BA27:000000287E2842284238422842387E28002800003E8802883EF820883EF80000
+BA28:000000287E2842284238422842387E28002800001F0801081F0810141F620000
+BA29:000000287E2842284238422842387E28002800003EF802803EF820803EF80000
+BA2A:000000287E2842284238422842387E28002800003EFC02483E4820483EFC0000
+BA2B:000000287E2842284238422842387E28002800003E1002FE3E3820443E380000
+BA2C:000000287E2842284238422842387E280028000003F802080208020803F80000
+BA2D:000000287E2842284238422842387E28002800000208020803F8020803F80000
+BA2E:000000287E2842284238422842387E2800280000110811081F0811141F620000
+BA2F:000000287E2842284238422842387E2800280000000800080008003400C20000
+BA30:000000287E2842284238422842387E28002800000048004800A8011406620000
+BA31:000000287E2842284238422842387E2800280000000001F00208020801F00000
+BA32:000000287E2842284238422842387E280028000003F80020002000D003080000
+BA33:000000287E2842284238422842387E2800280000004003F8004000A003180000
+BA34:000000287E2842284238422842387E280028000003F8000803F8000800080000
+BA35:000000287E2842284238422842387E280028000003F8020003F8020003F80000
+BA36:000000287E2842284238422842387E280028000000000FF8022002200FF80000
+BA37:000000287E2842284238422842387E280028000000800FF803E0041003E00000
+BA38:00000000000200027F8240824082409E4082408240827F820002000200020000
+BA39:000000087E0842084208423842087E0800080000000007F80008000800080000
+BA3A:000000087E0842084208423842087E080008000000003EF80208020802080000
+BA3B:000000087E0842084208423842087E080008000000001F080108011401620000
+BA3C:000000087E0842084208423842087E080008000000001000100010001FF80000
+BA3D:000000087E0842084208423842087E0800080000000020F8201020303ECC0000
+BA3E:000000087E0842084208423842087E0800080000202021FC207020883E700000
+BA3F:000000087E0842084208423842087E080008000003F802000200020003F80000
+BA40:000000087E0842084208423842087E080008000007F8000807F8040007F80000
+BA41:000000087E0842084208423842087E08000800003EF802083E0820083E080000
+BA42:000000087E0842084208423842087E08000800003EF802883E8820883EF80000
+BA43:000000087E0842084208423842087E08000800003E8802883EF820883EF80000
+BA44:000000087E0842084208423842087E08000800000F8800880F8808140FA20000
+BA45:000000087E0842084208423842087E08000800003EF802803EF820803EF80000
+BA46:000000087E0842084208423842087E08000800003EFC02483E4820483EFC0000
+BA47:000000087E0842084208423842087E08000800003E1002FE3E3820443E380000
+BA48:000000087E0842084208423842087E080008000003F802080208020803F80000
+BA49:000000087E0842084208423842087E08000800000208020803F8020803F80000
+BA4A:000000087E0842084208423842087E0800080000210821083F0821143F620000
+BA4B:000000087E0842084208423842087E0800080000001000100010006801840000
+BA4C:000000087E0842084208423842087E08000800000048004800A8011406620000
+BA4D:000000087E0842084208423842087E0800080000000003F00408040803F00000
+BA4E:000000087E0842084208423842087E080008000003F80020002000D003080000
+BA4F:000000087E0842084208423842087E0800080000004003F8004000A003180000
+BA50:000000087E0842084208423842087E080008000003F8000803F8000800080000
+BA51:000000087E0842084208423842087E080008000003F8020003F8020003F80000
+BA52:000000087E0842084208423842087E080008000000000FF8022002200FF80000
+BA53:000000087E0842084208423842087E080008000000800FF803E0041003E00000
+BA54:00000000000A000A7F8A408A408A40BA408A408A408A7F8A000A000A000A0000
+BA55:000000287E284228422842E842287E280028000007F800080008000800080000
+BA56:000000287E284228422842E842287E280028000000003EF80208020802080000
+BA57:000000287E284228422842E842287E280028000000003E100210022802C40000
+BA58:000000287E284228422842E842287E280028000008000800080008000FF80000
+BA59:000000287E284228422842E842287E2800280000000020F8201020303ECC0000
+BA5A:000000287E284228422842E842287E2800280000202021FC207020883E700000
+BA5B:000000287E284228422842E842287E280028000003F802000200020003F80000
+BA5C:000000287E284228422842E842287E280028000007F8000807F8040007F80000
+BA5D:000000287E284228422842E842287E28002800003EF802083E0820083E080000
+BA5E:000000287E284228422842E842287E28002800003EF802883E8820883EF80000
+BA5F:000000287E284228422842E842287E28002800003E8802883EF820883EF80000
+BA60:000000287E284228422842E842287E28002800001F0801081F0810141F620000
+BA61:000000287E284228422842E842287E28002800003EF802803EF820803EF80000
+BA62:000000287E284228422842E842287E28002800003EFC02483E4820483EFC0000
+BA63:000000287E284228422842E842287E28002800003E1002FE3E3820443E380000
+BA64:000000287E284228422842E842287E280028000003F802080208020803F80000
+BA65:000000287E284228422842E842287E28002800000208020803F8020803F80000
+BA66:000000287E284228422842E842287E2800280000110811081F0811141F620000
+BA67:000000287E284228422842E842287E2800280000000800080008003400C20000
+BA68:000000287E284228422842E842287E28002800000048004800A8011406620000
+BA69:000000287E284228422842E842287E2800280000000001F00208020801F00000
+BA6A:000000287E284228422842E842287E280028000003F80020002000D003080000
+BA6B:000000287E284228422842E842287E2800280000004003F8004000A003180000
+BA6C:000000287E284228422842E842287E280028000003F8000803F8000800080000
+BA6D:000000287E284228422842E842287E280028000003F8020003F8020003F80000
+BA6E:000000287E284228422842E842287E280028000000000FF8022002200FF80000
+BA6F:000000287E284228422842E842287E280028000000800FF803E0041003E00000
+BA70:00000000000200027F824082409E40824082409E40827F820002000200020000
+BA71:000000087E0842084238420842387E0800080000000007F80008000800080000
+BA72:000000087E0842084238420842387E080008000000003EF80208020802080000
+BA73:000000087E0842084238420842387E080008000000001F080108011401620000
+BA74:000000087E0842084238420842387E080008000800001000100010001FF80000
+BA75:000000087E0842084238420842387E0800080000000020F8201020303ECC0000
+BA76:000000087E0842084238420842387E0800080000202021FC207020883E700000
+BA77:000000087E0842084238420842387E080008000003F802000200020003F80000
+BA78:000000087E0842084238420842387E080008000007F8000807F8040007F80000
+BA79:000000087E0842084238420842387E08000800003EF802083E0820083E080000
+BA7A:000000087E0842084238420842387E08000800003EF802883E8820883EF80000
+BA7B:000000087E0842084238420842387E08000800003E8802883EF820883EF80000
+BA7C:000000087E0842084238420842387E08000800000F8800880F8808140FA20000
+BA7D:000000087E0842084238420842387E08000800003EF802803EF820803EF80000
+BA7E:000000087E0842084238420842387E08000800003EFC02483E4820483EFC0000
+BA7F:000000087E0842084238420842387E08000800003E1002FE3E3820443E380000
+BA80:000000087E0842084238420842387E080008000003F802080208020803F80000
+BA81:000000087E0842084238420842387E08000800000208020803F8020803F80000
+BA82:000000087E0842084238420842387E0800080000210821083F0821143F620000
+BA83:000000087E0842084238420842387E0800080000001000100010006801840000
+BA84:000000087E0842084238420842387E08000800000048004800A8011406620000
+BA85:000000087E0842084238420842387E0800080000000003F00408040803F00000
+BA86:000000087E0842084238420842387E080008000003F80020002000D003080000
+BA87:000000087E0842084238420842387E0800080000004003F8004000A003180000
+BA88:000000087E0842084238420842387E080008000003F8000803F8000800080000
+BA89:000000087E0842084238420842387E080008000003F8020003F8020003F80000
+BA8A:000000087E0842084238420842387E080008000000000FF8022002200FF80000
+BA8B:000000087E0842084238420842387E080008000000800FF803E0041003E00000
+BA8C:00000000000A000A7F8A408A40BA408A408A40BA408A7F8A000A000A000A0000
+BA8D:000000287E28422842E8422842E87E280028000007F800080008000800080000
+BA8E:000000287E28422842E8422842E87E280028000000003EF80208020802080000
+BA8F:000000287E28422842E8422842E87E280028000000003E100210022802C40000
+BA90:000000287E28422842E8422842E87E280028002808000800080008000FF80000
+BA91:000000287E28422842E8422842E87E2800280000000020F8201020303ECC0000
+BA92:000000287E28422842E8422842E87E2800280000202021FC207020883E700000
+BA93:000000287E28422842E8422842E87E280028000003F802000200020003F80000
+BA94:000000287E28422842E8422842E87E280028000007F8000807F8040007F80000
+BA95:000000287E28422842E8422842E87E28002800003EF802083E0820083E080000
+BA96:000000287E28422842E8422842E87E28002800003EF802883E8820883EF80000
+BA97:000000287E28422842E8422842E87E28002800003E8802883EF820883EF80000
+BA98:000000287E28422842E8422842E87E28002800001F0801081F0810141F620000
+BA99:000000287E28422842E8422842E87E28002800003EF802803EF820803EF80000
+BA9A:000000287E28422842E8422842E87E28002800003EFC02483E4820483EFC0000
+BA9B:000000287E28422842E8422842E87E28002800003E1002FE3E3820443E380000
+BA9C:000000287E28422842E8422842E87E280028000003F802080208020803F80000
+BA9D:000000287E28422842E8422842E87E28002800000208020803F8020803F80000
+BA9E:000000287E28422842E8422842E87E2800280000110811081F0811141F620000
+BA9F:000000287E28422842E8422842E87E2800280000000800080008003400C20000
+BAA0:000000287E28422842E8422842E87E28002800000048004800A8011406620000
+BAA1:000000287E28422842E8422842E87E2800280000000001F00208020801F00000
+BAA2:000000287E28422842E8422842E87E280028000003F80020002000D003080000
+BAA3:000000287E28422842E8422842E87E2800280000004003F8004000A003180000
+BAA4:000000287E28422842E8422842E87E280028000003F8000803F8000800080000
+BAA5:000000287E28422842E8422842E87E280028000003F8020003F8020003F80000
+BAA6:000000287E28422842E8422842E87E280028000000000FF8022002200FF80000
+BAA7:000000287E28422842E8422842E87E280028000000800FF803E0041003E00000
+BAA8:000000003FF820082008200820083FF8000000000100010001007FFC00000000
+BAA9:00001FF01010101010101FF0010001007FFC00001FF000100010001000100000
+BAAA:00001FF01010101010101FF0010001007FFC000000003EF80208020802080000
+BAAB:00001FF01010101010101FF0010001007FFC000000001E100210022802C40000
+BAAC:00001FF01010101010101FF0010001007FFC000000001000100010001FF00000
+BAAD:00001FF01010101010101FF0010001007FFC0000000020F8201020303ECC0000
+BAAE:00001FF01010101010101FF0010001007FFC0000202021FC207020883E700000
+BAAF:00001FF01010101010101FF0010001007FFC00001FF01000100010001FF00000
+BAB0:00001FF01010101010101FF0010001007FFC00001FF000101FF010001FF00000
+BAB1:00001FF01010101010101FF0010001007FFC00003EF802083E0820083E080000
+BAB2:00001FF01010101010101FF0010001007FFC00003EF802883E8820883EF80000
+BAB3:00001FF01010101010101FF0010001007FFC00003E8802883EF820883EF80000
+BAB4:00001FF01010101010101FF0010001007FFC00003E1002103E1020283EC40000
+BAB5:00001FF01010101010101FF0010001007FFC00003EF802803EF820803EF80000
+BAB6:00001FF01010101010101FF0010001007FFC00003EFC02483E4820483EFC0000
+BAB7:00001FF01010101010101FF0010001007FFC00003E2003FC3E7020883E700000
+BAB8:00001FF01010101010101FF0010001007FFC00001FF01010101010101FF00000
+BAB9:00001FF01010101010101FF0010001007FFC0000101010101FF010101FF00000
+BABA:00001FF01010101010101FF0010001007FFC0000222022203E2022503E880000
+BABB:00001FF01010101010101FF0010001007FFC000000000100010002800C400000
+BABC:00001FF01010101010101FF0010001007FFC00000000024002400DA033100000
+BABD:00001FF01010101010101FF0010001007FFC0000000007C00820082007C00000
+BABE:00001FF01010101010101FF0010001007FFC0000000007E00080014006200000
+BABF:00001FF01010101010101FF0010001007FFC0000008007E00080014006200000
+BAC0:00001FF01010101010101FF0010001007FFC00001FF000101FF0001000100000
+BAC1:00001FF01010101010101FF0010001007FFC00001FF010001FF010001FF00000
+BAC2:00001FF01010101010101FF0010001007FFC000000001FF0044004401FF00000
+BAC3:00001FF01010101010101FF0010001007FFC000001001FF007C0082007C00000
+BAC4:0000001000103F90209020902090209E20903F90041004107FD0001000100000
+BAC5:000000083F882088208E20883F8804087FE8000007F800080008000800080000
+BAC6:000000083F882088208E20883F8804087FE8000000003EF80208020802080000
+BAC7:000000083F882088208E20883F8804087FE8000000001F080108011401620000
+BAC8:000000083F882088208E20883F8804087FE8000008000800080008000FF80000
+BAC9:000000083F882088208E20883F8804087FE80000000010F8101010301ECC0000
+BACA:000000083F882088208E20883F8804087FE800000808087F081C08220F9C0000
+BACB:000000083F882088208E20883F8804087FE8000003F802000200020003F80000
+BACC:000000083F882088208E20883F8804087FE8000007F8000807F8040007F80000
+BACD:000000083F882088208E20883F8804087FE800003EF802083E0820083E080000
+BACE:000000083F882088208E20883F8804087FE800003EF802883E8820883EF80000
+BACF:000000083F882088208E20883F8804087FE800003E8802883EF820883EF80000
+BAD0:000000083F882088208E20883F8804087FE800001F0801081F0810141F620000
+BAD1:000000083F882088208E20883F8804087FE800003EF802803EF820803EF80000
+BAD2:000000083F882088208E20883F8804087FE800003EFC02483E4820483EFC0000
+BAD3:000000083F882088208E20883F8804087FE800001F08017F1F1C10221F1C0000
+BAD4:000000083F882088208E20883F8804087FE8000003F802080208020803F80000
+BAD5:000000083F882088208E20883F8804087FE800000208020803F8020803F80000
+BAD6:000000083F882088208E20883F8804087FE80000110811081F0811141F620000
+BAD7:000000083F882088208E20883F8804087FE80000001000100010006801840000
+BAD8:000000083F882088208E20883F8804087FE800000048004800A8011406620000
+BAD9:000000083F882088208E20883F8804087FE80000000003F00408040803F00000
+BADA:000000083F882088208E20883F8804087FE8000003F80020002000D003080000
+BADB:000000083F882088208E20883F8804087FE80000004003F8004000A003180000
+BADC:000000083F882088208E20883F8804087FE8000003F8000803F8000800080000
+BADD:000000083F882088208E20883F8804087FE8000003F8020003F8020003F80000
+BADE:000000083F882088208E20883F8804087FE8000000000FF8022002200FF80000
+BADF:000000083F882088208E20883F8804087FE8000000800FF803E0041003E00000
+BAE0:0000001200123F92209220922092209E20923F92041204127FD2001200120000
+BAE1:000000283FA820A820B820A83FA804287FA8000007F800080008000800080000
+BAE2:000000283FA820A820B820A83FA804287FA8000000003EF80208020802080000
+BAE3:000000283FA820A820B820A83FA804287FA8000000001F080108011401620000
+BAE4:000000283FA820A820B820A83FA804287FA8000008000800080008000FF80000
+BAE5:000000283FA820A820B820A83FA804287FA80000000010F8101010301ECC0000
+BAE6:000000283FA820A820B820A83FA804287FA800000808087F081C08220F9C0000
+BAE7:000000283FA820A820B820A83FA804287FA8000003F802000200020003F80000
+BAE8:000000283FA820A820B820A83FA804287FA8000007F8000807F8040007F80000
+BAE9:000000283FA820A820B820A83FA804287FA800003EF802083E0820083E080000
+BAEA:000000283FA820A820B820A83FA804287FA800003EF802883E8820883EF80000
+BAEB:000000283FA820A820B820A83FA804287FA800003E8802883EF820883EF80000
+BAEC:000000283FA820A820B820A83FA804287FA800001F0801081F0810141F620000
+BAED:000000283FA820A820B820A83FA804287FA800003EF802803EF820803EF80000
+BAEE:000000283FA820A820B820A83FA804287FA800003EFC02483E4820483EFC0000
+BAEF:000000283FA820A820B820A83FA804287FA800001F08017F1F1C10221F1C0000
+BAF0:000000283FA820A820B820A83FA804287FA8000003F802080208020803F80000
+BAF1:000000283FA820A820B820A83FA804287FA800000208020803F8020803F80000
+BAF2:000000283FA820A820B820A83FA804287FA80000110811081F0811141F620000
+BAF3:000000283FA820A820B820A83FA804287FA80000001000100010006801840000
+BAF4:000000283FA820A820B820A83FA804287FA800000048004800A8011406620000
+BAF5:000000283FA820A820B820A83FA804287FA80000000003F00408040803F00000
+BAF6:000000283FA820A820B820A83FA804287FA8000003F80020002000D003080000
+BAF7:000000283FA820A820B820A83FA804287FA80000004003F8004000A003180000
+BAF8:000000283FA820A820B820A83FA804287FA8000003F8000803F8000800080000
+BAF9:000000283FA820A820B820A83FA804287FA8000003F8020003F8020003F80000
+BAFA:000000283FA820A820B820A83FA804287FA8000000000FF8022002200FF80000
+BAFB:000000283FA820A820B820A83FA804287FA8000000800FF803E0041003E00000
+BAFC:0000000800083F88208820882088208820883F88040804087FE8000800080000
+BAFD:000000083F882088208820883F8804087FE8000007F800080008000800080000
+BAFE:000000083F882088208820883F8804087FE8000000003EF80208020802080000
+BAFF:000000083F882088208820883F8804087FE8000000001F080108011401620000
+BB00:000000083F882088208820883F8804087FE8000008000800080008000FF80000
+BB01:000000083F882088208820883F8804087FE80000000010F8101010301ECC0000
+BB02:000000083F882088208820883F8804087FE800000808087F081C08220F9C0000
+BB03:000000083F882088208820883F8804087FE8000003F802000200020003F80000
+BB04:000000083F882088208820883F8804087FE8000007F8000807F8040007F80000
+BB05:000000083F882088208820883F8804087FE800003EF802083E0820083E080000
+BB06:000000083F882088208820883F8804087FE800003EF802883E8820883EF80000
+BB07:000000083F882088208820883F8804087FE800003E8802883EF820883EF80000
+BB08:000000083F882088208820883F8804087FE800001F0801081F0810141F620000
+BB09:000000083F882088208820883F8804087FE800003EF802803EF820803EF80000
+BB0A:000000083F882088208820883F8804087FE800003EFC02483E4820483EFC0000
+BB0B:000000083F882088208820883F8804087FE800001F08017F1F1C10221F1C0000
+BB0C:000000083F882088208820883F8804087FE8000003F802080208020803F80000
+BB0D:000000083F882088208820883F8804087FE800000208020803F8020803F80000
+BB0E:000000083F882088208820883F8804087FE80000110811081F0811141F620000
+BB0F:000000083F882088208820883F8804087FE80000001000100010006801840000
+BB10:000000083F882088208820883F8804087FE800000048004800A8011406620000
+BB11:000000083F882088208820883F8804087FE80000000003F00408040803F00000
+BB12:000000083F882088208820883F8804087FE8000003F80020002000D003080000
+BB13:000000083F882088208820883F8804087FE80000004003F8004000A003180000
+BB14:000000083F882088208820883F8804087FE8000003F8000803F8000800080000
+BB15:000000083F882088208820883F8804087FE8000003F8020003F8020003F80000
+BB16:000000083F882088208820883F8804087FE8000000000FF8022002200FF80000
+BB17:000000083F882088208820883F8804087FE8000000800FF803E0041003E00000
+BB18:000000003FF820082008200820083FF8000004400440044004407FFC00000000
+BB19:00001FF01010101010101FF0044004407FFC00001FF000100010001000100000
+BB1A:00001FF01010101010101FF0044004407FFC000000003EF80208020802080000
+BB1B:00001FF01010101010101FF0044004407FFC000000001E100210022802C40000
+BB1C:00001FF01010101010101FF0044004407FFC000000001000100010001FF00000
+BB1D:00001FF01010101010101FF0044004407FFC0000000020F8201020303ECC0000
+BB1E:00001FF01010101010101FF0044004407FFC0000202021FC207020883E700000
+BB1F:00001FF01010101010101FF0044004407FFC00001FF01000100010001FF00000
+BB20:00001FF01010101010101FF0044004407FFC00001FF000101FF010001FF00000
+BB21:00001FF01010101010101FF0044004407FFC00003EF802083E0820083E080000
+BB22:00001FF01010101010101FF0044004407FFC00003EF802883E8820883EF80000
+BB23:00001FF01010101010101FF0044004407FFC00003E8802883EF820883EF80000
+BB24:00001FF01010101010101FF0044004407FFC00003E1002103E1020283EC40000
+BB25:00001FF01010101010101FF0044004407FFC00003EF802803EF820803EF80000
+BB26:00001FF01010101010101FF0044004407FFC00003EFC02483E4820483EFC0000
+BB27:00001FF01010101010101FF0044004407FFC00003E2003FC3E7020883E700000
+BB28:00001FF01010101010101FF0044004407FFC00001FF01010101010101FF00000
+BB29:00001FF01010101010101FF0044004407FFC0000101010101FF010101FF00000
+BB2A:00001FF01010101010101FF0044004407FFC0000222022203E2022503E880000
+BB2B:00001FF01010101010101FF0044004407FFC000000000100010002800C400000
+BB2C:00001FF01010101010101FF0044004407FFC00000000024002400DA033100000
+BB2D:00001FF01010101010101FF0044004407FFC0000000007C00820082007C00000
+BB2E:00001FF01010101010101FF0044004407FFC0000000007E00080014006200000
+BB2F:00001FF01010101010101FF0044004407FFC0000008007E00080014006200000
+BB30:00001FF01010101010101FF0044004407FFC00001FF000101FF0001000100000
+BB31:00001FF01010101010101FF0044004407FFC00001FF010001FF010001FF00000
+BB32:00001FF01010101010101FF0044004407FFC000000001FF0044004401FF00000
+BB33:00001FF01010101010101FF0044004407FFC000001001FF007C0082007C00000
+BB34:000000003FF8200820082008200820083FF800003FF801000100010001000000
+BB35:00001FF01010101010101FF000007FFC010001001FF000100010001000100000
+BB36:00001FF01010101010101FF000007FFC0100010000003EF80208020802080000
+BB37:00001FF01010101010101FF000007FFC0100010000001E100210022802C40000
+BB38:00001FF01010101010101FF0000000007FFC010001001100100010001FF00000
+BB39:00001FF01010101010101FF000007FFC01000100000020F8201020303ECC0000
+BB3A:00001FF01010101010101FF000007FFC01000100202021FC207020883E700000
+BB3B:00001FF01010101010101FF000007FFC010001001FF01000100010001FF00000
+BB3C:00001FF01010101010101FF000007FFC010001001FF000101FF010001FF00000
+BB3D:00001FF01010101010101FF000007FFC010001003EF802083E0820083E080000
+BB3E:00001FF01010101010101FF000007FFC010001003EF802883E8820883EF80000
+BB3F:00001FF01010101010101FF000007FFC010001003E8802883EF820883EF80000
+BB40:00001FF01010101010101FF000007FFC010001003E1002103E1020283EC40000
+BB41:00001FF01010101010101FF000007FFC010001003EF802803EF820803EF80000
+BB42:00001FF01010101010101FF000007FFC010001003EFC02483E4820483EFC0000
+BB43:00001FF01010101010101FF000007FFC010001003E2003FC3E7020883E700000
+BB44:00001FF01010101010101FF000007FFC010001001FF01010101010101FF00000
+BB45:00001FF01010101010101FF000007FFC01000100101010101FF010101FF00000
+BB46:00001FF01010101010101FF000007FFC01000100222022203E2022503E880000
+BB47:00001FF01010101010101FF000007FFC0100010000000100010002800C400000
+BB48:00001FF01010101010101FF000007FFC010001000000024002400DA033100000
+BB49:00001FF01010101010101FF000007FFC01000100000007C00820082007C00000
+BB4A:00001FF01010101010101FF000007FFC01000100000007E00080014006200000
+BB4B:00001FF01010101010101FF000007FFC01000100008007E00080014006200000
+BB4C:00001FF01010101010101FF000007FFC010001001FF000101FF0001000100000
+BB4D:00001FF01010101010101FF000007FFC010001001FF010001FF010001FF00000
+BB4E:00001FF01010101010101FF000007FFC0100010000001FF0044004401FF00000
+BB4F:00001FF01010101010101FF000007FFC0100010001001FF007C0082007C00000
+BB50:000000083FC8204820482048204820483FC800087FE8040804F8040804080000
+BB51:00083F88208820883F8800087FE8027802080000000007F80008000800080000
+BB52:00083F88208820883F8800087FE802780208000000003EF80208020802080000
+BB53:00083F88208820883F8800087FE802780208000000001F080108011401620000
+BB54:00083F88208820883F88000800087FE80278020802081000100010001FF80000
+BB55:00083F88208820883F8800087FE8027802080000000020F8201020303ECC0000
+BB56:00083F88208820883F8800087FE8027802080000202021FC207020883E700000
+BB57:00083F88208820883F8800087FE802780208000003F802000200020003F80000
+BB58:00083F88208820883F8800087FE802780208000007F8000807F8040007F80000
+BB59:00083F88208820883F8800087FE80278020800003EF802083E0820083E080000
+BB5A:00083F88208820883F8800087FE80278020800003EF802883E8820883EF80000
+BB5B:00083F88208820883F8800087FE80278020800003E8802883EF820883EF80000
+BB5C:00083F88208820883F8800087FE80278020800000F8800880F8808140FA20000
+BB5D:00083F88208820883F8800087FE80278020800003EF802803EF820803EF80000
+BB5E:00083F88208820883F8800087FE80278020800003EFC02483E4820483EFC0000
+BB5F:00083F88208820883F8800087FE80278020800003E1002FE3E3820443E380000
+BB60:00083F88208820883F8800087FE802780208000003F802080208020803F80000
+BB61:00083F88208820883F8800087FE80278020800000208020803F8020803F80000
+BB62:00083F88208820883F8800087FE8027802080000210821083F0821143F620000
+BB63:00083F88208820883F8800087FE8027802080000001000100010006801840000
+BB64:00083F88208820883F8800087FE80278020800000048004800A8011406620000
+BB65:00083F88208820883F8800087FE8027802080000000003F00408040803F00000
+BB66:00083F88208820883F8800087FE802780208000003F80020002000D003080000
+BB67:00083F88208820883F8800087FE8027802080000004003F8004000A003180000
+BB68:00083F88208820883F8800087FE802780208000003F8000803F8000800080000
+BB69:00083F88208820883F8800087FE802780208000003F8020003F8020003F80000
+BB6A:00083F88208820883F8800087FE802780208000000000FF8022002200FF80000
+BB6B:00083F88208820883F8800087FE802780208000000800FF803E0041003E00000
+BB6C:0000000A3FCA204A204A204A204A204A3FCA000A7FEA040A047A040A040A0000
+BB6D:00283FA820A820A83FA800287FA805E804280000000007F80008000800080000
+BB6E:00283FA820A820A83FA800287FA805E80428000000003EF80208020802080000
+BB6F:00283FA820A820A83FA800287FA805E80428000000001F080108011401620000
+BB70:00283FA820A820A83FA8002800287FA8042805E804281428100010001FF80000
+BB71:00283FA820A820A83FA800287FA805E804280000000020F8201020303ECC0000
+BB72:00283FA820A820A83FA800287FA805E804280000202021FC207020883E700000
+BB73:00283FA820A820A83FA800287FA805E80428000003F802000200020003F80000
+BB74:00283FA820A820A83FA800287FA805E80428000007F8000807F8040007F80000
+BB75:00283FA820A820A83FA800287FA805E8042800003EF802083E0820083E080000
+BB76:00283FA820A820A83FA800287FA805E8042800003EF802883E8820883EF80000
+BB77:00283FA820A820A83FA800287FA805E8042800003E8802883EF820883EF80000
+BB78:00283FA820A820A83FA800287FA805E8042800000F8800880F8808140FA20000
+BB79:00283FA820A820A83FA800287FA805E8042800003EF802803EF820803EF80000
+BB7A:00283FA820A820A83FA800287FA805E8042800003EFC02483E4820483EFC0000
+BB7B:00283FA820A820A83FA800287FA805E8042800003E1002FE3E3820443E380000
+BB7C:00283FA820A820A83FA800287FA805E80428000003F802080208020803F80000
+BB7D:00283FA820A820A83FA800287FA805E8042800000208020803F8020803F80000
+BB7E:00283FA820A820A83FA800287FA805E804280000210821083F0821143F620000
+BB7F:00283FA820A820A83FA800287FA805E804280000001000100010006801840000
+BB80:00283FA820A820A83FA800287FA805E8042800000048004800A8011406620000
+BB81:00283FA820A820A83FA800287FA805E804280000000003F00408040803F00000
+BB82:00283FA820A820A83FA800287FA805E80428000003F80020002000D003080000
+BB83:00283FA820A820A83FA800287FA805E804280000004003F8004000A003180000
+BB84:00283FA820A820A83FA800287FA805E80428000003F8000803F8000800080000
+BB85:00283FA820A820A83FA800287FA805E80428000003F8020003F8020003F80000
+BB86:00283FA820A820A83FA800287FA805E80428000000000FF8022002200FF80000
+BB87:00283FA820A820A83FA800287FA805E80428000000800FF803E0041003E00000
+BB88:000000083FC8204820482048204820483FC800087FE804080408040804080000
+BB89:00083F88208820883F8800087FE8020802000000000007F80008000800080000
+BB8A:00083F88208820883F8800087FE802080200000000003EF80208020802080000
+BB8B:00083F88208820883F8800087FE802080200000000001F080108011401620000
+BB8C:00083F88208820883F88000800087FE80208020802081008100010001FF80000
+BB8D:00083F88208820883F8800087FE8020802000000000020F8201020303ECC0000
+BB8E:00083F88208820883F8800087FE8020802000000202021FC207020883E700000
+BB8F:00083F88208820883F8800087FE802080200000003F802000200020003F80000
+BB90:00083F88208820883F8800087FE802080200000007F8000807F8040007F80000
+BB91:00083F88208820883F8800087FE80208020000003EF802083E0820083E080000
+BB92:00083F88208820883F8800087FE80208020000003EF802883E8820883EF80000
+BB93:00083F88208820883F8800087FE80208020000003E8802883EF820883EF80000
+BB94:00083F88208820883F8800087FE80208020000000F8800880F8808140FA20000
+BB95:00083F88208820883F8800087FE80208020000003EF802803EF820803EF80000
+BB96:00083F88208820883F8800087FE80208020000003EFC02483E4820483EFC0000
+BB97:00083F88208820883F8800087FE80208020000003E1002FE3E3820443E380000
+BB98:00083F88208820883F8800087FE802080200000003F802080208020803F80000
+BB99:00083F88208820883F8800087FE80208020000000208020803F8020803F80000
+BB9A:00083F88208820883F8800087FE8020802000000210821083F0821143F620000
+BB9B:00083F88208820883F8800087FE8020802000000001000100010006801840000
+BB9C:00083F88208820883F8800087FE80208020000000048004800A8011406620000
+BB9D:00083F88208820883F8800087FE8020802000000000003F00408040803F00000
+BB9E:00083F88208820883F8800087FE802080200000003F80020002000D003080000
+BB9F:00083F88208820883F8800087FE8020802000000004003F8004000A003180000
+BBA0:00083F88208820883F8800087FE802080200000003F8000803F8000800080000
+BBA1:00083F88208820883F8800087FE802080200000003F8020003F8020003F80000
+BBA2:00083F88208820883F8800087FE802080200000000000FF8022002200FF80000
+BBA3:00083F88208820883F8800087FE802080200000000800FF803E0041003E00000
+BBA4:000000003FF8200820082008200820083FF800007FFC04400440044004400000
+BBA5:00001FF01010101010101FF000007FFC044004401FF000100010001000100000
+BBA6:00001FF01010101010101FF000007FFC0440044000003EF80208020802080000
+BBA7:00001FF01010101010101FF000007FFC0440044000001E100210022802C40000
+BBA8:00001FF01010101010101FF0000000007FFC044004401440100010001FF00000
+BBA9:00001FF01010101010101FF000007FFC04400440000020F8201020303ECC0000
+BBAA:00001FF01010101010101FF000007FFC04400440202021FC207020883E700000
+BBAB:00001FF01010101010101FF000007FFC044004401FF01000100010001FF00000
+BBAC:00001FF01010101010101FF000007FFC044004401FF000101FF010001FF00000
+BBAD:00001FF01010101010101FF000007FFC044004403EF802083E0820083E080000
+BBAE:00001FF01010101010101FF000007FFC044004403EF802883E8820883EF80000
+BBAF:00001FF01010101010101FF000007FFC044004403E8802883EF820883EF80000
+BBB0:00001FF01010101010101FF000007FFC044004403E1002103E1020283EC40000
+BBB1:00001FF01010101010101FF000007FFC044004403EF802803EF820803EF80000
+BBB2:00001FF01010101010101FF000007FFC044004403EFC02483E4820483EFC0000
+BBB3:00001FF01010101010101FF000007FFC044004403E2003FC3E7020883E700000
+BBB4:00001FF01010101010101FF000007FFC044004401FF01010101010101FF00000
+BBB5:00001FF01010101010101FF000007FFC04400440101010101FF010101FF00000
+BBB6:00001FF01010101010101FF000007FFC04400440222022203E2022503E880000
+BBB7:00001FF01010101010101FF000007FFC0440044000000100010002800C400000
+BBB8:00001FF01010101010101FF000007FFC044004400000024002400DA033100000
+BBB9:00001FF01010101010101FF000007FFC04400440000007C00820082007C00000
+BBBA:00001FF01010101010101FF000007FFC04400440000007E00080014006200000
+BBBB:00001FF01010101010101FF000007FFC04400440008007E00080014006200000
+BBBC:00001FF01010101010101FF000007FFC044004401FF000101FF0001000100000
+BBBD:00001FF01010101010101FF000007FFC044004401FF010001FF010001FF00000
+BBBE:00001FF01010101010101FF000007FFC0440044000001FF0044004401FF00000
+BBBF:00001FF01010101010101FF000007FFC0440044001001FF007C0082007C00000
+BBC0:000000003FF820082008200820083FF80000000000007FFC0000000000000000
+BBC1:00001FF01010101010101FF0000000007FFC00001FF000100010001000100000
+BBC2:00001FF01010101010101FF0000000007FFC000000003EF80208020802080000
+BBC3:00001FF01010101010101FF0000000007FFC000000001E100210022802C40000
+BBC4:00001FF01010101010101FF0000000007FFC000000001000100010001FF00000
+BBC5:00001FF01010101010101FF0000000007FFC0000000020F8201020303ECC0000
+BBC6:00001FF01010101010101FF0000000007FFC0000202021FC207020883E700000
+BBC7:00001FF01010101010101FF0000000007FFC00001FF01000100010001FF00000
+BBC8:00001FF01010101010101FF0000000007FFC00001FF000101FF010001FF00000
+BBC9:00001FF01010101010101FF0000000007FFC00003EF802083E0820083E080000
+BBCA:00001FF01010101010101FF0000000007FFC00003EF802883E8820883EF80000
+BBCB:00001FF01010101010101FF0000000007FFC00003E8802883EF820883EF80000
+BBCC:00001FF01010101010101FF0000000007FFC00003E1002103E1020283EC40000
+BBCD:00001FF01010101010101FF0000000007FFC00003EF802803EF820803EF80000
+BBCE:00001FF01010101010101FF0000000007FFC00003EFC02483E4820483EFC0000
+BBCF:00001FF01010101010101FF0000000007FFC00003E2003FC3E7020883E700000
+BBD0:00001FF01010101010101FF0000000007FFC00001FF01010101010101FF00000
+BBD1:00001FF01010101010101FF0000000007FFC0000101010101FF010101FF00000
+BBD2:00001FF01010101010101FF0000000007FFC0000222022203E2022503E880000
+BBD3:00001FF01010101010101FF0000000007FFC000000000100010002800C400000
+BBD4:00001FF01010101010101FF0000000007FFC00000000024002400DA033100000
+BBD5:00001FF01010101010101FF0000000007FFC0000000007C00820082007C00000
+BBD6:00001FF01010101010101FF0000000007FFC0000000007E00080014006200000
+BBD7:00001FF01010101010101FF0000000007FFC0000008007E00080014006200000
+BBD8:00001FF01010101010101FF0000000007FFC00001FF000101FF0001000100000
+BBD9:00001FF01010101010101FF0000000007FFC00001FF010001FF010001FF00000
+BBDA:00001FF01010101010101FF0000000007FFC000000001FF0044004401FF00000
+BBDB:00001FF01010101010101FF0000000007FFC000001001FF007C0082007C00000
+BBDC:0000000800083F88208820882088208820883F8800087FE80008000800080000
+BBDD:000000083F882088208820883F8800087FE8000007F800080008000800080000
+BBDE:000000083F882088208820883F8800087FE8000000003EF80208020802080000
+BBDF:000000083F882088208820883F8800087FE8000000001F080108011401620000
+BBE0:000000083F882088208820883F8800087FE8000008000800080008000FF80000
+BBE1:000000083F882088208820883F8800087FE80000000010F8101010301ECC0000
+BBE2:000000083F882088208820883F8800087FE800000808087F081C08220F9C0000
+BBE3:000000083F882088208820883F8800087FE8000003F802000200020003F80000
+BBE4:000000083F882088208820883F8800087FE8000007F8000807F8040007F80000
+BBE5:000000083F882088208820883F8800087FE800003EF802083E0820083E080000
+BBE6:000000083F882088208820883F8800087FE800003EF802883E8820883EF80000
+BBE7:000000083F882088208820883F8800087FE800003E8802883EF820883EF80000
+BBE8:000000083F882088208820883F8800087FE800001F0801081F0810141F620000
+BBE9:000000083F882088208820883F8800087FE800003EF802803EF820803EF80000
+BBEA:000000083F882088208820883F8800087FE800003EFC02483E4820483EFC0000
+BBEB:000000083F882088208820883F8800087FE800001F08017F1F1C10221F1C0000
+BBEC:000000083F882088208820883F8800087FE8000003F802080208020803F80000
+BBED:000000083F882088208820883F8800087FE800000208020803F8020803F80000
+BBEE:000000083F882088208820883F8800087FE80000110811081F0811141F620000
+BBEF:000000083F882088208820883F8800087FE80000001000100010006801840000
+BBF0:000000083F882088208820883F8800087FE800000048004800A8011406620000
+BBF1:000000083F882088208820883F8800087FE80000000003F00408040803F00000
+BBF2:000000083F882088208820883F8800087FE8000003F80020002000D003080000
+BBF3:000000083F882088208820883F8800087FE80000004003F8004000A003180000
+BBF4:000000083F882088208820883F8800087FE8000003F8000803F8000800080000
+BBF5:000000083F882088208820883F8800087FE8000003F8020003F8020003F80000
+BBF6:000000083F882088208820883F8800087FE8000000000FF8022002200FF80000
+BBF7:000000083F882088208820883F8800087FE8000000800FF803E0041003E00000
+BBF8:00000000000800087F884088408840884088408840887F880008000800080000
+BBF9:000000087E0842084208420842087E0800080000000007F80008000800080000
+BBFA:000000087E0842084208420842087E080008000000003EF80208020802080000
+BBFB:000000087E0842084208420842087E080008000000001F080108011401620000
+BBFC:000000087E0842084208420842087E080008000800001000100010001FF80000
+BBFD:000000087E0842084208420842087E0800080000000020F8201020303ECC0000
+BBFE:000000087E0842084208420842087E0800080000202021FC207020883E700000
+BBFF:000000087E0842084208420842087E080008000003F802000200020003F80000
+BC00:000000087E0842084208420842087E080008000007F8000807F8040007F80000
+BC01:000000087E0842084208420842087E08000800003EF802083E0820083E080000
+BC02:000000087E0842084208420842087E08000800003EF802883E8820883EF80000
+BC03:000000087E0842084208420842087E08000800003E8802883EF820883EF80000
+BC04:000000087E0842084208420842087E08000800000F8800880F8808140FA20000
+BC05:000000087E0842084208420842087E08000800003EF802803EF820803EF80000
+BC06:000000087E0842084208420842087E08000800003EFC02483E4820483EFC0000
+BC07:000000087E0842084208420842087E08000800003E1002FE3E3820443E380000
+BC08:000000087E0842084208420842087E080008000003F802080208020803F80000
+BC09:000000087E0842084208420842087E08000800000208020803F8020803F80000
+BC0A:000000087E0842084208420842087E0800080000210821083F0821143F620000
+BC0B:000000087E0842084208420842087E0800080000001000100010006801840000
+BC0C:000000087E0842084208420842087E08000800000048004800A8011406620000
+BC0D:000000087E0842084208420842087E0800080000000003F00408040803F00000
+BC0E:000000087E0842084208420842087E080008000003F80020002000D003080000
+BC0F:000000087E0842084208420842087E0800080000004003F8004000A003180000
+BC10:000000087E0842084208420842087E080008000003F8000803F8000800080000
+BC11:000000087E0842084208420842087E080008000003F8020003F8020003F80000
+BC12:000000087E0842084208420842087E080008000000000FF8022002200FF80000
+BC13:000000087E0842084208420842087E080008000000800FF803E0041003E00000
+BC14:00000000001000102090209020903F9E2090209020903F900010001000100000
+BC15:000000080008420842087E0E42087E080008000007F800080008000800080000
+BC16:000000080008420842087E0E42087E080008000000003EF80208020802080000
+BC17:000000080008420842087E0E42087E080008000000001F080108011401620000
+BC18:000000080008420842087E0E42087E080008000808000800080008000FF80000
+BC19:000000080008420842087E0E42087E0800080000000010F8101010301ECC0000
+BC1A:000000080008420842087E0E42087E08000800000808087F081C08220F9C0000
+BC1B:000000080008420842087E0E42087E080008000003F802000200020003F80000
+BC1C:000000080008420842087E0E42087E080008000007F8000807F8040007F80000
+BC1D:000000080008420842087E0E42087E08000800003EF802083E0820083E080000
+BC1E:000000080008420842087E0E42087E08000800003EF802883E8820883EF80000
+BC1F:000000080008420842087E0E42087E08000800003E8802883EF820883EF80000
+BC20:000000080008420842087E0E42087E08000800001F0801081F0810141F620000
+BC21:000000080008420842087E0E42087E08000800003EF802803EF820803EF80000
+BC22:000000080008420842087E0E42087E08000800003EFC02483E4820483EFC0000
+BC23:000000080008420842087E0E42087E08000800001F08017F1F1C10221F1C0000
+BC24:000000080008420842087E0E42087E080008000003F802080208020803F80000
+BC25:000000080008420842087E0E42087E08000800000208020803F8020803F80000
+BC26:000000080008420842087E0E42087E0800080000110811081F0811141F620000
+BC27:000000080008420842087E0E42087E0800080000001000100010006801840000
+BC28:000000080008420842087E0E42087E08000800000048004800A8011406620000
+BC29:000000080008420842087E0E42087E0800080000000003F00408040803F00000
+BC2A:000000080008420842087E0E42087E080008000003F80020002000D003080000
+BC2B:000000080008420842087E0E42087E0800080000004003F8004000A003180000
+BC2C:000000080008420842087E0E42087E080008000003F8000803F8000800080000
+BC2D:000000080008420842087E0E42087E080008000003F8020003F8020003F80000
+BC2E:000000080008420842087E0E42087E080008000000000FF8022002200FF80000
+BC2F:000000080008420842087E0E42087E080008000000800FF803E0041003E00000
+BC30:00000000001200122092209220923F9E2092209220923F920012001200120000
+BC31:000000280028422842287E3842287E280028000007F800080008000800080000
+BC32:000000280028422842287E3842287E280028000000003EF80208020802080000
+BC33:000000280028422842287E3842287E280028000000003E100210022802C40000
+BC34:000000280028422842287E3842287E280028002808000800080008000FF80000
+BC35:000000280028422842287E3842287E2800280000000020F8201020303ECC0000
+BC36:000000280028422842287E3842287E2800280000202021FC207020883E700000
+BC37:000000280028422842287E3842287E280028000003F802000200020003F80000
+BC38:000000280028422842287E3842287E280028000007F8000807F8040007F80000
+BC39:000000280028422842287E3842287E28002800003EF802083E0820083E080000
+BC3A:000000280028422842287E3842287E28002800003EF802883E8820883EF80000
+BC3B:000000280028422842287E3842287E28002800003E8802883EF820883EF80000
+BC3C:000000280028422842287E3842287E28002800001F0801081F0810141F620000
+BC3D:000000280028422842287E3842287E28002800003EF802803EF820803EF80000
+BC3E:000000280028422842287E3842287E28002800003EFC02483E4820483EFC0000
+BC3F:000000280028422842287E3842287E28002800003E1002FE3E3820443E380000
+BC40:000000280028422842287E3842287E280028000003F802080208020803F80000
+BC41:000000280028422842287E3842287E28002800000208020803F8020803F80000
+BC42:000000280028422842287E3842287E2800280000110811081F0811141F620000
+BC43:000000280028422842287E3842287E2800280000000800080008003400C20000
+BC44:000000280028422842287E3842287E28002800000048004800A8011406620000
+BC45:000000280028422842287E3842287E2800280000000001F00208020801F00000
+BC46:000000280028422842287E3842287E280028000003F80020002000D003080000
+BC47:000000280028422842287E3842287E2800280000004003F8004000A003180000
+BC48:000000280028422842287E3842287E280028000003F8000803F8000800080000
+BC49:000000280028422842287E3842287E280028000003F8020003F8020003F80000
+BC4A:000000280028422842287E3842287E280028000000000FF8022002200FF80000
+BC4B:000000280028422842287E3842287E280028000000800FF803E0041003E00000
+BC4C:000000000010001020902090209E3F902090209E20903F900010001000100000
+BC4D:0000000800084208420E7E08420E7E080008000007F800080008000800080000
+BC4E:0000000800084208420E7E08420E7E080008000000003EF80208020802080000
+BC4F:0000000800084208420E7E08420E7E080008000000001F080108011401620000
+BC50:0000000800084208420E7E08420E7E080008000008000800080008000FF80000
+BC51:0000000800084208420E7E08420E7E0800080000000010F8101010301ECC0000
+BC52:0000000800084208420E7E08420E7E08000800000808087F081C08220F9C0000
+BC53:0000000800084208420E7E08420E7E080008000003F802000200020003F80000
+BC54:0000000800084208420E7E08420E7E080008000007F8000807F8040007F80000
+BC55:0000000800084208420E7E08420E7E08000800003EF802083E0820083E080000
+BC56:0000000800084208420E7E08420E7E08000800003EF802883E8820883EF80000
+BC57:0000000800084208420E7E08420E7E08000800003E8802883EF820883EF80000
+BC58:0000000800084208420E7E08420E7E08000800001F0801081F0810141F620000
+BC59:0000000800084208420E7E08420E7E08000800003EF802803EF820803EF80000
+BC5A:0000000800084208420E7E08420E7E08000800003EFC02483E4820483EFC0000
+BC5B:0000000800084208420E7E08420E7E08000800001F08017F1F1C10221F1C0000
+BC5C:0000000800084208420E7E08420E7E080008000003F802080208020803F80000
+BC5D:0000000800084208420E7E08420E7E08000800000208020803F8020803F80000
+BC5E:0000000800084208420E7E08420E7E0800080000110811081F0811141F620000
+BC5F:0000000800084208420E7E08420E7E0800080000001000100010006801840000
+BC60:0000000800084208420E7E08420E7E08000800000048004800A8011406620000
+BC61:0000000800084208420E7E08420E7E0800080000000003F00408040803F00000
+BC62:0000000800084208420E7E08420E7E080008000003F80020002000D003080000
+BC63:0000000800084208420E7E08420E7E0800080000004003F8004000A003180000
+BC64:0000000800084208420E7E08420E7E080008000003F8000803F8000800080000
+BC65:0000000800084208420E7E08420E7E080008000003F8020003F8020003F80000
+BC66:0000000800084208420E7E08420E7E080008000000000FF8022002200FF80000
+BC67:0000000800084208420E7E08420E7E080008000000800FF803E0041003E00000
+BC68:000000000012001220922092209E3F922092209E20923F920012001200120000
+BC69:000000280028422842387E2842387E280028000007F800080008000800080000
+BC6A:000000280028422842387E2842387E280028000000003EF80208020802080000
+BC6B:000000280028422842387E2842387E280028000000003E100210022802C40000
+BC6C:000000280028422842387E2842387E280028002808000800080008000FF80000
+BC6D:000000280028422842387E2842387E2800280000000020F8201020303ECC0000
+BC6E:000000280028422842387E2842387E2800280000202021FC207020883E700000
+BC6F:000000280028422842387E2842387E280028000003F802000200020003F80000
+BC70:000000280028422842387E2842387E280028000007F8000807F8040007F80000
+BC71:000000280028422842387E2842387E28002800003EF802083E0820083E080000
+BC72:000000280028422842387E2842387E28002800003EF802883E8820883EF80000
+BC73:000000280028422842387E2842387E28002800003E8802883EF820883EF80000
+BC74:000000280028422842387E2842387E28002800001F0801081F0810141F620000
+BC75:000000280028422842387E2842387E28002800003EF802803EF820803EF80000
+BC76:000000280028422842387E2842387E28002800003EFC02483E4820483EFC0000
+BC77:000000280028422842387E2842387E28002800003E1002FE3E3820443E380000
+BC78:000000280028422842387E2842387E280028000003F802080208020803F80000
+BC79:000000280028422842387E2842387E28002800000208020803F8020803F80000
+BC7A:000000280028422842387E2842387E2800280000110811081F0811141F620000
+BC7B:000000280028422842387E2842387E2800280000000800080008003400C20000
+BC7C:000000280028422842387E2842387E28002800000048004800A8011406620000
+BC7D:000000280028422842387E2842387E2800280000000001F00208020801F00000
+BC7E:000000280028422842387E2842387E280028000003F80020002000D003080000
+BC7F:000000280028422842387E2842387E2800280000004003F8004000A003180000
+BC80:000000280028422842387E2842387E280028000003F8000803F8000800080000
+BC81:000000280028422842387E2842387E280028000003F8020003F8020003F80000
+BC82:000000280028422842387E2842387E280028000000000FF8022002200FF80000
+BC83:000000280028422842387E2842387E280028000000800FF803E0041003E00000
+BC84:00000000000200022082208220823F9E2082208220823F820002000200020000
+BC85:000000080008420842087E3842087E0800080000000007F80008000800080000
+BC86:000000080008420842087E3842087E080008000000003EF80208020802080000
+BC87:000000080008420842087E3842087E080008000000001F080108011401620000
+BC88:000000080008420842087E3842087E080008000000001000100010001FF80000
+BC89:000000080008420842087E3842087E0800080000000020F8201020303ECC0000
+BC8A:000000080008420842087E3842087E0800080000202021FC207020883E700000
+BC8B:000000080008420842087E3842087E080008000003F802000200020003F80000
+BC8C:000000080008420842087E3842087E080008000007F8000807F8040007F80000
+BC8D:000000080008420842087E3842087E08000800003EF802083E0820083E080000
+BC8E:000000080008420842087E3842087E08000800003EF802883E8820883EF80000
+BC8F:000000080008420842087E3842087E08000800003E8802883EF820883EF80000
+BC90:000000080008420842087E3842087E08000800000F8800880F8808140FA20000
+BC91:000000080008420842087E3842087E08000800003EF802803EF820803EF80000
+BC92:000000080008420842087E3842087E08000800003EFC02483E4820483EFC0000
+BC93:000000080008420842087E3842087E08000800003E1002FE3E3820443E380000
+BC94:000000080008420842087E3842087E080008000003F802080208020803F80000
+BC95:000000080008420842087E3842087E08000800000208020803F8020803F80000
+BC96:000000080008420842087E3842087E0800080000210821083F0821143F620000
+BC97:000000080008420842087E3842087E0800080000001000100010006801840000
+BC98:000000080008420842087E3842087E08000800000048004800A8011406620000
+BC99:000000080008420842087E3842087E0800080000000003F00408040803F00000
+BC9A:000000080008420842087E3842087E080008000003F80020002000D003080000
+BC9B:000000080008420842087E3842087E0800080000004003F8004000A003180000
+BC9C:000000080008420842087E3842087E080008000003F8000803F8000800080000
+BC9D:000000080008420842087E3842087E080008000003F8020003F8020003F80000
+BC9E:000000080008420842087E3842087E080008000000000FF8022002200FF80000
+BC9F:000000080008420842087E3842087E080008000000800FF803E0041003E00000
+BCA0:00000000000A000A208A208A208A3FBA208A208A208A3F8A000A000A000A0000
+BCA1:000000280028422842287EE842287E280028000007F800080008000800080000
+BCA2:000000280028422842287EE842287E280028000000003EF80208020802080000
+BCA3:000000280028422842287EE842287E280028000000003E100210022802C40000
+BCA4:000000280028422842287EE842287E280028000008000800080008000FF80000
+BCA5:000000280028422842287EE842287E2800280000000020F8201020303ECC0000
+BCA6:000000280028422842287EE842287E2800280000202021FC207020883E700000
+BCA7:000000280028422842287EE842287E280028000003F802000200020003F80000
+BCA8:000000280028422842287EE842287E280028000007F8000807F8040007F80000
+BCA9:000000280028422842287EE842287E28002800003EF802083E0820083E080000
+BCAA:000000280028422842287EE842287E28002800003EF802883E8820883EF80000
+BCAB:000000280028422842287EE842287E28002800003E8802883EF820883EF80000
+BCAC:000000280028422842287EE842287E28002800001F0801081F0810141F620000
+BCAD:000000280028422842287EE842287E28002800003EF802803EF820803EF80000
+BCAE:000000280028422842287EE842287E28002800003EFC02483E4820483EFC0000
+BCAF:000000280028422842287EE842287E28002800003E1002FE3E3820443E380000
+BCB0:000000280028422842287EE842287E280028000003F802080208020803F80000
+BCB1:000000280028422842287EE842287E28002800000208020803F8020803F80000
+BCB2:000000280028422842287EE842287E2800280000110811081F0811141F620000
+BCB3:000000280028422842287EE842287E2800280000000800080008003400C20000
+BCB4:000000280028422842287EE842287E28002800000048004800A8011406620000
+BCB5:000000280028422842287EE842287E2800280000000001F00208020801F00000
+BCB6:000000280028422842287EE842287E280028000003F80020002000D003080000
+BCB7:000000280028422842287EE842287E2800280000004003F8004000A003180000
+BCB8:000000280028422842287EE842287E280028000003F8000803F8000800080000
+BCB9:000000280028422842287EE842287E280028000003F8020003F8020003F80000
+BCBA:000000280028422842287EE842287E280028000000000FF8022002200FF80000
+BCBB:000000280028422842287EE842287E280028000000800FF803E0041003E00000
+BCBC:000000000002000220822082209E3F822082209E20823F820002000200020000
+BCBD:000000080008420842387E0842387E0800080000000007F80008000800080000
+BCBE:000000080008420842387E0842387E080008000000003EF80208020802080000
+BCBF:000000080008420842387E0842387E080008000000001F080108011401620000
+BCC0:000000080008420842387E0842387E080008000800001000100010001FF80000
+BCC1:000000080008420842387E0842387E0800080000000020F8201020303ECC0000
+BCC2:000000080008420842387E0842387E0800080000202021FC207020883E700000
+BCC3:000000080008420842387E0842387E080008000003F802000200020003F80000
+BCC4:000000080008420842387E0842387E080008000007F8000807F8040007F80000
+BCC5:000000080008420842387E0842387E08000800003EF802083E0820083E080000
+BCC6:000000080008420842387E0842387E08000800003EF802883E8820883EF80000
+BCC7:000000080008420842387E0842387E08000800003E8802883EF820883EF80000
+BCC8:000000080008420842387E0842387E08000800000F8800880F8808140FA20000
+BCC9:000000080008420842387E0842387E08000800003EF802803EF820803EF80000
+BCCA:000000080008420842387E0842387E08000800003EFC02483E4820483EFC0000
+BCCB:000000080008420842387E0842387E08000800003E1002FE3E3820443E380000
+BCCC:000000080008420842387E0842387E080008000003F802080208020803F80000
+BCCD:000000080008420842387E0842387E08000800000208020803F8020803F80000
+BCCE:000000080008420842387E0842387E0800080000210821083F0821143F620000
+BCCF:000000080008420842387E0842387E0800080000001000100010006801840000
+BCD0:000000080008420842387E0842387E08000800000048004800A8011406620000
+BCD1:000000080008420842387E0842387E0800080000000003F00408040803F00000
+BCD2:000000080008420842387E0842387E080008000003F80020002000D003080000
+BCD3:000000080008420842387E0842387E0800080000004003F8004000A003180000
+BCD4:000000080008420842387E0842387E080008000003F8000803F8000800080000
+BCD5:000000080008420842387E0842387E080008000003F8020003F8020003F80000
+BCD6:000000080008420842387E0842387E080008000000000FF8022002200FF80000
+BCD7:000000080008420842387E0842387E080008000000800FF803E0041003E00000
+BCD8:00000000000A000A208A208A20BA3F8A208A20BA208A3F8A000A000A000A0000
+BCD9:000000280028422842E87E2842E87E280028000007F800080008000800080000
+BCDA:000000280028422842E87E2842E87E280028000000003EF80208020802080000
+BCDB:000000280028422842E87E2842E87E280028000000003E100210022802C40000
+BCDC:000000280028422842E87E2842E87E280028002808000800080008000FF80000
+BCDD:000000280028422842E87E2842E87E2800280000000020F8201020303ECC0000
+BCDE:000000280028422842E87E2842E87E2800280000202021FC207020883E700000
+BCDF:000000280028422842E87E2842E87E280028000003F802000200020003F80000
+BCE0:000000280028422842E87E2842E87E280028000007F8000807F8040007F80000
+BCE1:000000280028422842E87E2842E87E28002800003EF802083E0820083E080000
+BCE2:000000280028422842E87E2842E87E28002800003EF802883E8820883EF80000
+BCE3:000000280028422842E87E2842E87E28002800003E8802883EF820883EF80000
+BCE4:000000280028422842E87E2842E87E28002800001F0801081F0810141F620000
+BCE5:000000280028422842E87E2842E87E28002800003EF802803EF820803EF80000
+BCE6:000000280028422842E87E2842E87E28002800003EFC02483E4820483EFC0000
+BCE7:000000280028422842E87E2842E87E28002800003E1002FE3E3820443E380000
+BCE8:000000280028422842E87E2842E87E280028000003F802080208020803F80000
+BCE9:000000280028422842E87E2842E87E28002800000208020803F8020803F80000
+BCEA:000000280028422842E87E2842E87E2800280000110811081F0811141F620000
+BCEB:000000280028422842E87E2842E87E2800280000000800080008003400C20000
+BCEC:000000280028422842E87E2842E87E28002800000048004800A8011406620000
+BCED:000000280028422842E87E2842E87E2800280000000001F00208020801F00000
+BCEE:000000280028422842E87E2842E87E280028000003F80020002000D003080000
+BCEF:000000280028422842E87E2842E87E2800280000004003F8004000A003180000
+BCF0:000000280028422842E87E2842E87E280028000003F8000803F8000800080000
+BCF1:000000280028422842E87E2842E87E280028000003F8020003F8020003F80000
+BCF2:000000280028422842E87E2842E87E280028000000000FF8022002200FF80000
+BCF3:000000280028422842E87E2842E87E280028000000800FF803E0041003E00000
+BCF4:000000001010101010101FF0101010101FF000000100010001007FFC00000000
+BCF5:0000101010101FF010101FF0010001007FFC00001FF000100010001000100000
+BCF6:0000101010101FF010101FF0010001007FFC000000003EF80208020802080000
+BCF7:0000101010101FF010101FF0010001007FFC000000001E100210022802C40000
+BCF8:0000101010101FF010101FF0010001007FFC000000001000100010001FF00000
+BCF9:0000101010101FF010101FF0010001007FFC0000000020F8201020303ECC0000
+BCFA:0000101010101FF010101FF0010001007FFC0000202021FC207020883E700000
+BCFB:0000101010101FF010101FF0010001007FFC00001FF01000100010001FF00000
+BCFC:0000101010101FF010101FF0010001007FFC00001FF000101FF010001FF00000
+BCFD:0000101010101FF010101FF0010001007FFC00003EF802083E0820083E080000
+BCFE:0000101010101FF010101FF0010001007FFC00003EF802883E8820883EF80000
+BCFF:0000101010101FF010101FF0010001007FFC00003E8802883EF820883EF80000
+BD00:0000101010101FF010101FF0010001007FFC00003E1002103E1020283EC40000
+BD01:0000101010101FF010101FF0010001007FFC00003EF802803EF820803EF80000
+BD02:0000101010101FF010101FF0010001007FFC00003EFC02483E4820483EFC0000
+BD03:0000101010101FF010101FF0010001007FFC00003E2003FC3E7020883E700000
+BD04:0000101010101FF010101FF0010001007FFC00001FF01010101010101FF00000
+BD05:0000101010101FF010101FF0010001007FFC0000101010101FF010101FF00000
+BD06:0000101010101FF010101FF0010001007FFC0000222022203E2022503E880000
+BD07:0000101010101FF010101FF0010001007FFC000000000100010002800C400000
+BD08:0000101010101FF010101FF0010001007FFC00000000024002400DA033100000
+BD09:0000101010101FF010101FF0010001007FFC0000000007C00820082007C00000
+BD0A:0000101010101FF010101FF0010001007FFC0000000007E00080014006200000
+BD0B:0000101010101FF010101FF0010001007FFC0000008007E00080014006200000
+BD0C:0000101010101FF010101FF0010001007FFC00001FF000101FF0001000100000
+BD0D:0000101010101FF010101FF0010001007FFC00001FF010001FF010001FF00000
+BD0E:0000101010101FF010101FF0010001007FFC000000001FF0044004401FF00000
+BD0F:0000101010101FF010101FF0010001007FFC000001001FF007C0082007C00000
+BD10:0000001000102090209020903F90209E20903F90041004107FD0001000100000
+BD11:00000008208820883F8E20883F8804087FE8000007F800080008000800080000
+BD12:00000008208820883F8E20883F8804087FE8000000003EF80208020802080000
+BD13:00000008208820883F8E20883F8804087FE8000000001F080108011401620000
+BD14:00000008208820883F8E20883F8804087FE8000008000800080008000FF80000
+BD15:00000008208820883F8E20883F8804087FE80000000010F8101010301ECC0000
+BD16:00000008208820883F8E20883F8804087FE800000808087F081C08220F9C0000
+BD17:00000008208820883F8E20883F8804087FE8000003F802000200020003F80000
+BD18:00000008208820883F8E20883F8804087FE8000007F8000807F8040007F80000
+BD19:00000008208820883F8E20883F8804087FE800003EF802083E0820083E080000
+BD1A:00000008208820883F8E20883F8804087FE800003EF802883E8820883EF80000
+BD1B:00000008208820883F8E20883F8804087FE800003E8802883EF820883EF80000
+BD1C:00000008208820883F8E20883F8804087FE800001F0801081F0810141F620000
+BD1D:00000008208820883F8E20883F8804087FE800003EF802803EF820803EF80000
+BD1E:00000008208820883F8E20883F8804087FE800003EFC02483E4820483EFC0000
+BD1F:00000008208820883F8E20883F8804087FE800001F08017F1F1C10221F1C0000
+BD20:00000008208820883F8E20883F8804087FE8000003F802080208020803F80000
+BD21:00000008208820883F8E20883F8804087FE800000208020803F8020803F80000
+BD22:00000008208820883F8E20883F8804087FE80000110811081F0811141F620000
+BD23:00000008208820883F8E20883F8804087FE80000001000100010006801840000
+BD24:00000008208820883F8E20883F8804087FE800000048004800A8011406620000
+BD25:00000008208820883F8E20883F8804087FE80000000003F00408040803F00000
+BD26:00000008208820883F8E20883F8804087FE8000003F80020002000D003080000
+BD27:00000008208820883F8E20883F8804087FE80000004003F8004000A003180000
+BD28:00000008208820883F8E20883F8804087FE8000003F8000803F8000800080000
+BD29:00000008208820883F8E20883F8804087FE8000003F8020003F8020003F80000
+BD2A:00000008208820883F8E20883F8804087FE8000000000FF8022002200FF80000
+BD2B:00000008208820883F8E20883F8804087FE8000000800FF803E0041003E00000
+BD2C:0000001200122092209220923F92209E20923F92041204127FD2001200120000
+BD2D:0000002820A820A83FB820A83FA804287FA8000007F800080008000800080000
+BD2E:0000002820A820A83FB820A83FA804287FA8000000003EF80208020802080000
+BD2F:0000002820A820A83FB820A83FA804287FA8000000001F080108011401620000
+BD30:0000002820A820A83FB820A83FA804287FA8000008000800080008000FF80000
+BD31:0000002820A820A83FB820A83FA804287FA80000000010F8101010301ECC0000
+BD32:0000002820A820A83FB820A83FA804287FA800000808087F081C08220F9C0000
+BD33:0000002820A820A83FB820A83FA804287FA8000003F802000200020003F80000
+BD34:0000002820A820A83FB820A83FA804287FA8000007F8000807F8040007F80000
+BD35:0000002820A820A83FB820A83FA804287FA800003EF802083E0820083E080000
+BD36:0000002820A820A83FB820A83FA804287FA800003EF802883E8820883EF80000
+BD37:0000002820A820A83FB820A83FA804287FA800003E8802883EF820883EF80000
+BD38:0000002820A820A83FB820A83FA804287FA800001F0801081F0810141F620000
+BD39:0000002820A820A83FB820A83FA804287FA800003EF802803EF820803EF80000
+BD3A:0000002820A820A83FB820A83FA804287FA800003EFC02483E4820483EFC0000
+BD3B:0000002820A820A83FB820A83FA804287FA800001F08017F1F1C10221F1C0000
+BD3C:0000002820A820A83FB820A83FA804287FA8000003F802080208020803F80000
+BD3D:0000002820A820A83FB820A83FA804287FA800000208020803F8020803F80000
+BD3E:0000002820A820A83FB820A83FA804287FA80000110811081F0811141F620000
+BD3F:0000002820A820A83FB820A83FA804287FA80000001000100010006801840000
+BD40:0000002820A820A83FB820A83FA804287FA800000048004800A8011406620000
+BD41:0000002820A820A83FB820A83FA804287FA80000000003F00408040803F00000
+BD42:0000002820A820A83FB820A83FA804287FA8000003F80020002000D003080000
+BD43:0000002820A820A83FB820A83FA804287FA80000004003F8004000A003180000
+BD44:0000002820A820A83FB820A83FA804287FA8000003F8000803F8000800080000
+BD45:0000002820A820A83FB820A83FA804287FA8000003F8020003F8020003F80000
+BD46:0000002820A820A83FB820A83FA804287FA8000000000FF8022002200FF80000
+BD47:0000002820A820A83FB820A83FA804287FA8000000800FF803E0041003E00000
+BD48:0000000800082088208820883F88208820883F88040804087FE8000800080000
+BD49:00000008208820883F8820883F8804087FE8000007F800080008000800080000
+BD4A:00000008208820883F8820883F8804087FE8000000003EF80208020802080000
+BD4B:00000008208820883F8820883F8804087FE8000000001F080108011401620000
+BD4C:00000008208820883F8820883F8804087FE8000008000800080008000FF80000
+BD4D:00000008208820883F8820883F8804087FE80000000010F8101010301ECC0000
+BD4E:00000008208820883F8820883F8804087FE800000808087F081C08220F9C0000
+BD4F:00000008208820883F8820883F8804087FE8000003F802000200020003F80000
+BD50:00000008208820883F8820883F8804087FE8000007F8000807F8040007F80000
+BD51:00000008208820883F8820883F8804087FE800003EF802083E0820083E080000
+BD52:00000008208820883F8820883F8804087FE800003EF802883E8820883EF80000
+BD53:00000008208820883F8820883F8804087FE800003E8802883EF820883EF80000
+BD54:00000008208820883F8820883F8804087FE800001F0801081F0810141F620000
+BD55:00000008208820883F8820883F8804087FE800003EF802803EF820803EF80000
+BD56:00000008208820883F8820883F8804087FE800003EFC02483E4820483EFC0000
+BD57:00000008208820883F8820883F8804087FE800001F08017F1F1C10221F1C0000
+BD58:00000008208820883F8820883F8804087FE8000003F802080208020803F80000
+BD59:00000008208820883F8820883F8804087FE800000208020803F8020803F80000
+BD5A:00000008208820883F8820883F8804087FE80000110811081F0811141F620000
+BD5B:00000008208820883F8820883F8804087FE80000001000100010006801840000
+BD5C:00000008208820883F8820883F8804087FE800000048004800A8011406620000
+BD5D:00000008208820883F8820883F8804087FE80000000003F00408040803F00000
+BD5E:00000008208820883F8820883F8804087FE8000003F80020002000D003080000
+BD5F:00000008208820883F8820883F8804087FE80000004003F8004000A003180000
+BD60:00000008208820883F8820883F8804087FE8000003F8000803F8000800080000
+BD61:00000008208820883F8820883F8804087FE8000003F8020003F8020003F80000
+BD62:00000008208820883F8820883F8804087FE8000000000FF8022002200FF80000
+BD63:00000008208820883F8820883F8804087FE8000000800FF803E0041003E00000
+BD64:000000001010101010101FF0101010101FF004400440044004407FFC00000000
+BD65:0000101010101FF010101FF0044004407FFC00001FF000100010001000100000
+BD66:0000101010101FF010101FF0044004407FFC000000003EF80208020802080000
+BD67:0000101010101FF010101FF0044004407FFC000000001E100210022802C40000
+BD68:0000101010101FF010101FF0044004407FFC000000001000100010001FF00000
+BD69:0000101010101FF010101FF0044004407FFC0000000020F8201020303ECC0000
+BD6A:0000101010101FF010101FF0044004407FFC0000202021FC207020883E700000
+BD6B:0000101010101FF010101FF0044004407FFC00001FF01000100010001FF00000
+BD6C:0000101010101FF010101FF0044004407FFC00001FF000101FF010001FF00000
+BD6D:0000101010101FF010101FF0044004407FFC00003EF802083E0820083E080000
+BD6E:0000101010101FF010101FF0044004407FFC00003EF802883E8820883EF80000
+BD6F:0000101010101FF010101FF0044004407FFC00003E8802883EF820883EF80000
+BD70:0000101010101FF010101FF0044004407FFC00003E1002103E1020283EC40000
+BD71:0000101010101FF010101FF0044004407FFC00003EF802803EF820803EF80000
+BD72:0000101010101FF010101FF0044004407FFC00003EFC02483E4820483EFC0000
+BD73:0000101010101FF010101FF0044004407FFC00003E2003FC3E7020883E700000
+BD74:0000101010101FF010101FF0044004407FFC00001FF01010101010101FF00000
+BD75:0000101010101FF010101FF0044004407FFC0000101010101FF010101FF00000
+BD76:0000101010101FF010101FF0044004407FFC0000222022203E2022503E880000
+BD77:0000101010101FF010101FF0044004407FFC000000000100010002800C400000
+BD78:0000101010101FF010101FF0044004407FFC00000000024002400DA033100000
+BD79:0000101010101FF010101FF0044004407FFC0000000007C00820082007C00000
+BD7A:0000101010101FF010101FF0044004407FFC0000000007E00080014006200000
+BD7B:0000101010101FF010101FF0044004407FFC0000008007E00080014006200000
+BD7C:0000101010101FF010101FF0044004407FFC00001FF000101FF0001000100000
+BD7D:0000101010101FF010101FF0044004407FFC00001FF010001FF010001FF00000
+BD7E:0000101010101FF010101FF0044004407FFC000000001FF0044004401FF00000
+BD7F:0000101010101FF010101FF0044004407FFC000001001FF007C0082007C00000
+BD80:000000001010101010101FF0101010101FF000003FF801000100010001000000
+BD81:0000101010101FF010101FF000007FFC010001001FF000100010001000100000
+BD82:0000101010101FF010101FF000007FFC0100010000003EF80208020802080000
+BD83:0000101010101FF010101FF000007FFC0100010000001E100210022802C40000
+BD84:0000101010101FF010101FF0000000007FFC010001001100100010001FF00000
+BD85:0000101010101FF010101FF000007FFC01000100000020F8201020303ECC0000
+BD86:0000101010101FF010101FF000007FFC01000100202021FC207020883E700000
+BD87:0000101010101FF010101FF000007FFC010001001FF01000100010001FF00000
+BD88:0000101010101FF010101FF000007FFC010001001FF000101FF010001FF00000
+BD89:0000101010101FF010101FF000007FFC010001003EF802083E0820083E080000
+BD8A:0000101010101FF010101FF000007FFC010001003EF802883E8820883EF80000
+BD8B:0000101010101FF010101FF000007FFC010001003E8802883EF820883EF80000
+BD8C:0000101010101FF010101FF000007FFC010001003E1002103E1020283EC40000
+BD8D:0000101010101FF010101FF000007FFC010001003EF802803EF820803EF80000
+BD8E:0000101010101FF010101FF000007FFC010001003EFC02483E4820483EFC0000
+BD8F:0000101010101FF010101FF000007FFC010001003E2003FC3E7020883E700000
+BD90:0000101010101FF010101FF000007FFC010001001FF01010101010101FF00000
+BD91:0000101010101FF010101FF000007FFC01000100101010101FF010101FF00000
+BD92:0000101010101FF010101FF000007FFC01000100222022203E2022503E880000
+BD93:0000101010101FF010101FF000007FFC0100010000000100010002800C400000
+BD94:0000101010101FF010101FF000007FFC010001000000024002400DA033100000
+BD95:0000101010101FF010101FF000007FFC01000100000007C00820082007C00000
+BD96:0000101010101FF010101FF000007FFC01000100000007E00080014006200000
+BD97:0000101010101FF010101FF000007FFC01000100008007E00080014006200000
+BD98:0000101010101FF010101FF000007FFC010001001FF000101FF0001000100000
+BD99:0000101010101FF010101FF000007FFC010001001FF010001FF010001FF00000
+BD9A:0000101010101FF010101FF000007FFC0100010000001FF0044004401FF00000
+BD9B:0000101010101FF010101FF000007FFC0100010001001FF007C0082007C00000
+BD9C:000000082088208820883F88208820883F8800087FE8040804F8040804080000
+BD9D:208820883F8820883F8800087FE8027802080000000007F80008000800080000
+BD9E:208820883F8820883F8800087FE802780208000000003EF80208020802080000
+BD9F:208820883F8820883F8800087FE802780208000000001F080108011401620000
+BDA0:208820883F8820883F88000800087FE80278020802081000100010001FF80000
+BDA1:208820883F8820883F8800087FE8027802080000000020F8201020303ECC0000
+BDA2:208820883F8820883F8800087FE8027802080000202021FC207020883E700000
+BDA3:208820883F8820883F8800087FE802780208000003F802000200020003F80000
+BDA4:208820883F8820883F8800087FE802780208000007F8000807F8040007F80000
+BDA5:208820883F8820883F8800087FE80278020800003EF802083E0820083E080000
+BDA6:208820883F8820883F8800087FE80278020800003EF802883E8820883EF80000
+BDA7:208820883F8820883F8800087FE80278020800003E8802883EF820883EF80000
+BDA8:208820883F8820883F8800087FE80278020800000F8800880F8808140FA20000
+BDA9:208820883F8820883F8800087FE80278020800003EF802803EF820803EF80000
+BDAA:208820883F8820883F8800087FE80278020800003EFC02483E4820483EFC0000
+BDAB:208820883F8820883F8800087FE80278020800003E1002FE3E3820443E380000
+BDAC:208820883F8820883F8800087FE802780208000003F802080208020803F80000
+BDAD:208820883F8820883F8800087FE80278020800000208020803F8020803F80000
+BDAE:208820883F8820883F8800087FE8027802080000210821083F0821143F620000
+BDAF:208820883F8820883F8800087FE8027802080000001000100010006801840000
+BDB0:208820883F8820883F8800087FE80278020800000048004800A8011406620000
+BDB1:208820883F8820883F8800087FE8027802080000000003F00408040803F00000
+BDB2:208820883F8820883F8800087FE802780208000003F80020002000D003080000
+BDB3:208820883F8820883F8800087FE8027802080000004003F8004000A003180000
+BDB4:208820883F8820883F8800087FE802780208000003F8000803F8000800080000
+BDB5:208820883F8820883F8800087FE802780208000003F8020003F8020003F80000
+BDB6:208820883F8820883F8800087FE802780208000000000FF8022002200FF80000
+BDB7:208820883F8820883F8800087FE802780208000000800FF803E0041003E00000
+BDB8:0000000A208A208A208A3F8A208A208A3F8A000A7FEA040A047A040A040A0000
+BDB9:20A820A83FA820A83FA800287FA805E804280000000007F80008000800080000
+BDBA:20A820A83FA820A83FA800287FA805E80428000000003EF80208020802080000
+BDBB:20A820A83FA820A83FA800287FA805E80428000000001F080108011401620000
+BDBC:20A820A83FA820A83FA8002800287FA8042805E804281428100010001FF80000
+BDBD:20A820A83FA820A83FA800287FA805E804280000000020F8201020303ECC0000
+BDBE:20A820A83FA820A83FA800287FA805E804280000202021FC207020883E700000
+BDBF:20A820A83FA820A83FA800287FA805E80428000003F802000200020003F80000
+BDC0:20A820A83FA820A83FA800287FA805E80428000007F8000807F8040007F80000
+BDC1:20A820A83FA820A83FA800287FA805E8042800003EF802083E0820083E080000
+BDC2:20A820A83FA820A83FA800287FA805E8042800003EF802883E8820883EF80000
+BDC3:20A820A83FA820A83FA800287FA805E8042800003E8802883EF820883EF80000
+BDC4:20A820A83FA820A83FA800287FA805E8042800000F8800880F8808140FA20000
+BDC5:20A820A83FA820A83FA800287FA805E8042800003EF802803EF820803EF80000
+BDC6:20A820A83FA820A83FA800287FA805E8042800003EFC02483E4820483EFC0000
+BDC7:20A820A83FA820A83FA800287FA805E8042800003E1002FE3E3820443E380000
+BDC8:20A820A83FA820A83FA800287FA805E80428000003F802080208020803F80000
+BDC9:20A820A83FA820A83FA800287FA805E8042800000208020803F8020803F80000
+BDCA:20A820A83FA820A83FA800287FA805E804280000210821083F0821143F620000
+BDCB:20A820A83FA820A83FA800287FA805E804280000001000100010006801840000
+BDCC:20A820A83FA820A83FA800287FA805E8042800000048004800A8011406620000
+BDCD:20A820A83FA820A83FA800287FA805E804280000000003F00408040803F00000
+BDCE:20A820A83FA820A83FA800287FA805E80428000003F80020002000D003080000
+BDCF:20A820A83FA820A83FA800287FA805E804280000004003F8004000A003180000
+BDD0:20A820A83FA820A83FA800287FA805E80428000003F8000803F8000800080000
+BDD1:20A820A83FA820A83FA800287FA805E80428000003F8020003F8020003F80000
+BDD2:20A820A83FA820A83FA800287FA805E80428000000000FF8022002200FF80000
+BDD3:20A820A83FA820A83FA800287FA805E80428000000800FF803E0041003E00000
+BDD4:000000082088208820883F88208820883F8800087FE804080408040804080000
+BDD5:208820883F8820883F8800087FE8020802000000000007F80008000800080000
+BDD6:208820883F8820883F8800087FE802080200000000003EF80208020802080000
+BDD7:208820883F8820883F8800087FE802080200000000001F080108011401620000
+BDD8:208820883F8820883F88000800087FE80208020802081008100010001FF80000
+BDD9:208820883F8820883F8800087FE8020802000000000020F8201020303ECC0000
+BDDA:208820883F8820883F8800087FE8020802000000202021FC207020883E700000
+BDDB:208820883F8820883F8800087FE802080200000003F802000200020003F80000
+BDDC:208820883F8820883F8800087FE802080200000007F8000807F8040007F80000
+BDDD:208820883F8820883F8800087FE80208020000003EF802083E0820083E080000
+BDDE:208820883F8820883F8800087FE80208020000003EF802883E8820883EF80000
+BDDF:208820883F8820883F8800087FE80208020000003E8802883EF820883EF80000
+BDE0:208820883F8820883F8800087FE80208020000000F8800880F8808140FA20000
+BDE1:208820883F8820883F8800087FE80208020000003EF802803EF820803EF80000
+BDE2:208820883F8820883F8800087FE80208020000003EFC02483E4820483EFC0000
+BDE3:208820883F8820883F8800087FE80208020000003E1002FE3E3820443E380000
+BDE4:208820883F8820883F8800087FE802080200000003F802080208020803F80000
+BDE5:208820883F8820883F8800087FE80208020000000208020803F8020803F80000
+BDE6:208820883F8820883F8800087FE8020802000000210821083F0821143F620000
+BDE7:208820883F8820883F8800087FE8020802000000001000100010006801840000
+BDE8:208820883F8820883F8800087FE80208020000000048004800A8011406620000
+BDE9:208820883F8820883F8800087FE8020802000000000003F00408040803F00000
+BDEA:208820883F8820883F8800087FE802080200000003F80020002000D003080000
+BDEB:208820883F8820883F8800087FE8020802000000004003F8004000A003180000
+BDEC:208820883F8820883F8800087FE802080200000003F8000803F8000800080000
+BDED:208820883F8820883F8800087FE802080200000003F8020003F8020003F80000
+BDEE:208820883F8820883F8800087FE802080200000000000FF8022002200FF80000
+BDEF:208820883F8820883F8800087FE802080200000000800FF803E0041003E00000
+BDF0:000000001010101010101FF0101010101FF000007FFC04400440044004400000
+BDF1:0000101010101FF010101FF000007FFC044004401FF000100010001000100000
+BDF2:0000101010101FF010101FF000007FFC0440044000003EF80208020802080000
+BDF3:0000101010101FF010101FF000007FFC0440044000001E100210022802C40000
+BDF4:0000101010101FF010101FF0000000007FFC044004401440100010001FF00000
+BDF5:0000101010101FF010101FF000007FFC04400440000020F8201020303ECC0000
+BDF6:0000101010101FF010101FF000007FFC04400440202021FC207020883E700000
+BDF7:0000101010101FF010101FF000007FFC044004401FF01000100010001FF00000
+BDF8:0000101010101FF010101FF000007FFC044004401FF000101FF010001FF00000
+BDF9:0000101010101FF010101FF000007FFC044004403EF802083E0820083E080000
+BDFA:0000101010101FF010101FF000007FFC044004403EF802883E8820883EF80000
+BDFB:0000101010101FF010101FF000007FFC044004403E8802883EF820883EF80000
+BDFC:0000101010101FF010101FF000007FFC044004403E1002103E1020283EC40000
+BDFD:0000101010101FF010101FF000007FFC044004403EF802803EF820803EF80000
+BDFE:0000101010101FF010101FF000007FFC044004403EFC02483E4820483EFC0000
+BDFF:0000101010101FF010101FF000007FFC044004403E2003FC3E7020883E700000
+BE00:0000101010101FF010101FF000007FFC044004401FF01010101010101FF00000
+BE01:0000101010101FF010101FF000007FFC04400440101010101FF010101FF00000
+BE02:0000101010101FF010101FF000007FFC04400440222022203E2022503E880000
+BE03:0000101010101FF010101FF000007FFC0440044000000100010002800C400000
+BE04:0000101010101FF010101FF000007FFC044004400000024002400DA033100000
+BE05:0000101010101FF010101FF000007FFC04400440000007C00820082007C00000
+BE06:0000101010101FF010101FF000007FFC04400440000007E00080014006200000
+BE07:0000101010101FF010101FF000007FFC04400440008007E00080014006200000
+BE08:0000101010101FF010101FF000007FFC044004401FF000101FF0001000100000
+BE09:0000101010101FF010101FF000007FFC044004401FF010001FF010001FF00000
+BE0A:0000101010101FF010101FF000007FFC0440044000001FF0044004401FF00000
+BE0B:0000101010101FF010101FF000007FFC0440044001001FF007C0082007C00000
+BE0C:000000001010101010101FF0101010101FF0000000007FFC0000000000000000
+BE0D:0000101010101FF010101FF0000000007FFC00001FF000100010001000100000
+BE0E:0000101010101FF010101FF0000000007FFC000000003EF80208020802080000
+BE0F:0000101010101FF010101FF0000000007FFC000000001E100210022802C40000
+BE10:0000101010101FF010101FF0000000007FFC000000001000100010001FF00000
+BE11:0000101010101FF010101FF0000000007FFC0000000020F8201020303ECC0000
+BE12:0000101010101FF010101FF0000000007FFC0000202021FC207020883E700000
+BE13:0000101010101FF010101FF0000000007FFC00001FF01000100010001FF00000
+BE14:0000101010101FF010101FF0000000007FFC00001FF000101FF010001FF00000
+BE15:0000101010101FF010101FF0000000007FFC00003EF802083E0820083E080000
+BE16:0000101010101FF010101FF0000000007FFC00003EF802883E8820883EF80000
+BE17:0000101010101FF010101FF0000000007FFC00003E8802883EF820883EF80000
+BE18:0000101010101FF010101FF0000000007FFC00003E1002103E1020283EC40000
+BE19:0000101010101FF010101FF0000000007FFC00003EF802803EF820803EF80000
+BE1A:0000101010101FF010101FF0000000007FFC00003EFC02483E4820483EFC0000
+BE1B:0000101010101FF010101FF0000000007FFC00003E2003FC3E7020883E700000
+BE1C:0000101010101FF010101FF0000000007FFC00001FF01010101010101FF00000
+BE1D:0000101010101FF010101FF0000000007FFC0000101010101FF010101FF00000
+BE1E:0000101010101FF010101FF0000000007FFC0000222022203E2022503E880000
+BE1F:0000101010101FF010101FF0000000007FFC000000000100010002800C400000
+BE20:0000101010101FF010101FF0000000007FFC00000000024002400DA033100000
+BE21:0000101010101FF010101FF0000000007FFC0000000007C00820082007C00000
+BE22:0000101010101FF010101FF0000000007FFC0000000007E00080014006200000
+BE23:0000101010101FF010101FF0000000007FFC0000008007E00080014006200000
+BE24:0000101010101FF010101FF0000000007FFC00001FF000101FF0001000100000
+BE25:0000101010101FF010101FF0000000007FFC00001FF010001FF010001FF00000
+BE26:0000101010101FF010101FF0000000007FFC000000001FF0044004401FF00000
+BE27:0000101010101FF010101FF0000000007FFC000001001FF007C0082007C00000
+BE28:0000000800082088208820883F88208820883F8800087FE80008000800080000
+BE29:00000008208820883F8820883F8800087FE8000007F800080008000800080000
+BE2A:00000008208820883F8820883F8800087FE8000000003EF80208020802080000
+BE2B:00000008208820883F8820883F8800087FE8000000001F080108011401620000
+BE2C:00000008208820883F8820883F8800087FE8000008000800080008000FF80000
+BE2D:00000008208820883F8820883F8800087FE80000000010F8101010301ECC0000
+BE2E:00000008208820883F8820883F8800087FE800000808087F081C08220F9C0000
+BE2F:00000008208820883F8820883F8800087FE8000003F802000200020003F80000
+BE30:00000008208820883F8820883F8800087FE8000007F8000807F8040007F80000
+BE31:00000008208820883F8820883F8800087FE800003EF802083E0820083E080000
+BE32:00000008208820883F8820883F8800087FE800003EF802883E8820883EF80000
+BE33:00000008208820883F8820883F8800087FE800003E8802883EF820883EF80000
+BE34:00000008208820883F8820883F8800087FE800001F0801081F0810141F620000
+BE35:00000008208820883F8820883F8800087FE800003EF802803EF820803EF80000
+BE36:00000008208820883F8820883F8800087FE800003EFC02483E4820483EFC0000
+BE37:00000008208820883F8820883F8800087FE800001F08017F1F1C10221F1C0000
+BE38:00000008208820883F8820883F8800087FE8000003F802080208020803F80000
+BE39:00000008208820883F8820883F8800087FE800000208020803F8020803F80000
+BE3A:00000008208820883F8820883F8800087FE80000110811081F0811141F620000
+BE3B:00000008208820883F8820883F8800087FE80000001000100010006801840000
+BE3C:00000008208820883F8820883F8800087FE800000048004800A8011406620000
+BE3D:00000008208820883F8820883F8800087FE80000000003F00408040803F00000
+BE3E:00000008208820883F8820883F8800087FE8000003F80020002000D003080000
+BE3F:00000008208820883F8820883F8800087FE80000004003F8004000A003180000
+BE40:00000008208820883F8820883F8800087FE8000003F8000803F8000800080000
+BE41:00000008208820883F8820883F8800087FE8000003F8020003F8020003F80000
+BE42:00000008208820883F8820883F8800087FE8000000000FF8022002200FF80000
+BE43:00000008208820883F8820883F8800087FE8000000800FF803E0041003E00000
+BE44:00000000000800082088208820883F882088208820883F880008000800080000
+BE45:000000080008420842087E0842087E0800080000000007F80008000800080000
+BE46:000000080008420842087E0842087E080008000000003EF80208020802080000
+BE47:000000080008420842087E0842087E080008000000001F080108011401620000
+BE48:000000080008420842087E0842087E080008000800001000100010001FF80000
+BE49:000000080008420842087E0842087E0800080000000020F8201020303ECC0000
+BE4A:000000080008420842087E0842087E0800080000202021FC207020883E700000
+BE4B:000000080008420842087E0842087E080008000003F802000200020003F80000
+BE4C:000000080008420842087E0842087E080008000007F8000807F8040007F80000
+BE4D:000000080008420842087E0842087E08000800003EF802083E0820083E080000
+BE4E:000000080008420842087E0842087E08000800003EF802883E8820883EF80000
+BE4F:000000080008420842087E0842087E08000800003E8802883EF820883EF80000
+BE50:000000080008420842087E0842087E08000800000F8800880F8808140FA20000
+BE51:000000080008420842087E0842087E08000800003EF802803EF820803EF80000
+BE52:000000080008420842087E0842087E08000800003EFC02483E4820483EFC0000
+BE53:000000080008420842087E0842087E08000800003E1002FE3E3820443E380000
+BE54:000000080008420842087E0842087E080008000003F802080208020803F80000
+BE55:000000080008420842087E0842087E08000800000208020803F8020803F80000
+BE56:000000080008420842087E0842087E0800080000210821083F0821143F620000
+BE57:000000080008420842087E0842087E0800080000001000100010006801840000
+BE58:000000080008420842087E0842087E08000800000048004800A8011406620000
+BE59:000000080008420842087E0842087E0800080000000003F00408040803F00000
+BE5A:000000080008420842087E0842087E080008000003F80020002000D003080000
+BE5B:000000080008420842087E0842087E0800080000004003F8004000A003180000
+BE5C:000000080008420842087E0842087E080008000003F8000803F8000800080000
+BE5D:000000080008420842087E0842087E080008000003F8020003F8020003F80000
+BE5E:000000080008420842087E0842087E080008000000000FF8022002200FF80000
+BE5F:000000080008420842087E0842087E080008000000800FF803E0041003E00000
+BE60:00000000001000102490249024903F9E249024903F9000100010001000100000
+BE61:000000084908490849087F0E49087F080008000007F800080008000800080000
+BE62:000000084908490849087F0E49087F080008000000003EF80208020802080000
+BE63:000000084908490849087F0E49087F080008000000001F080108011401620000
+BE64:000000084908490849087F0E49087F080008000808000800080008000FF80000
+BE65:000000084908490849087F0E49087F0800080000000010F8101010301ECC0000
+BE66:000000084908490849087F0E49087F08000800000808087F081C08220F9C0000
+BE67:000000084908490849087F0E49087F080008000003F802000200020003F80000
+BE68:000000084908490849087F0E49087F080008000007F8000807F8040007F80000
+BE69:000000084908490849087F0E49087F08000800003EF802083E0820083E080000
+BE6A:000000084908490849087F0E49087F08000800003EF802883E8820883EF80000
+BE6B:000000084908490849087F0E49087F08000800003E8802883EF820883EF80000
+BE6C:000000084908490849087F0E49087F08000800001F0801081F0810141F620000
+BE6D:000000084908490849087F0E49087F08000800003EF802803EF820803EF80000
+BE6E:000000084908490849087F0E49087F08000800003EFC02483E4820483EFC0000
+BE6F:000000084908490849087F0E49087F08000800001F08017F1F1C10221F1C0000
+BE70:000000084908490849087F0E49087F080008000003F802080208020803F80000
+BE71:000000084908490849087F0E49087F08000800000208020803F8020803F80000
+BE72:000000084908490849087F0E49087F0800080000110811081F0811141F620000
+BE73:000000084908490849087F0E49087F0800080000001000100010006801840000
+BE74:000000084908490849087F0E49087F08000800000048004800A8011406620000
+BE75:000000084908490849087F0E49087F0800080000000003F00408040803F00000
+BE76:000000084908490849087F0E49087F080008000003F80020002000D003080000
+BE77:000000084908490849087F0E49087F0800080000004003F8004000A003180000
+BE78:000000084908490849087F0E49087F080008000003F8000803F8000800080000
+BE79:000000084908490849087F0E49087F080008000003F8020003F8020003F80000
+BE7A:000000084908490849087F0E49087F080008000000000FF8022002200FF80000
+BE7B:000000084908490849087F0E49087F080008000000800FF803E0041003E00000
+BE7C:00000000001200122492249224923F9E249224923F9200120012001200120000
+BE7D:000000284928492849287F3849287F280028000007F800080008000800080000
+BE7E:000000284928492849287F3849287F280028000000003EF80208020802080000
+BE7F:000000284928492849287F3849287F280028000000003E100210022802C40000
+BE80:000000284928492849287F3849287F280028002808000800080008000FF80000
+BE81:000000284928492849287F3849287F2800280000000020F8201020303ECC0000
+BE82:000000284928492849287F3849287F2800280000202021FC207020883E700000
+BE83:000000284928492849287F3849287F280028000003F802000200020003F80000
+BE84:000000284928492849287F3849287F280028000007F8000807F8040007F80000
+BE85:000000284928492849287F3849287F28002800003EF802083E0820083E080000
+BE86:000000284928492849287F3849287F28002800003EF802883E8820883EF80000
+BE87:000000284928492849287F3849287F28002800003E8802883EF820883EF80000
+BE88:000000284928492849287F3849287F28002800001F0801081F0810141F620000
+BE89:000000284928492849287F3849287F28002800003EF802803EF820803EF80000
+BE8A:000000284928492849287F3849287F28002800003EFC02483E4820483EFC0000
+BE8B:000000284928492849287F3849287F28002800003E1002FE3E3820443E380000
+BE8C:000000284928492849287F3849287F280028000003F802080208020803F80000
+BE8D:000000284928492849287F3849287F28002800000208020803F8020803F80000
+BE8E:000000284928492849287F3849287F2800280000110811081F0811141F620000
+BE8F:000000284928492849287F3849287F2800280000000800080008003400C20000
+BE90:000000284928492849287F3849287F28002800000048004800A8011406620000
+BE91:000000284928492849287F3849287F2800280000000001F00208020801F00000
+BE92:000000284928492849287F3849287F280028000003F80020002000D003080000
+BE93:000000284928492849287F3849287F2800280000004003F8004000A003180000
+BE94:000000284928492849287F3849287F280028000003F8000803F8000800080000
+BE95:000000284928492849287F3849287F280028000003F8020003F8020003F80000
+BE96:000000284928492849287F3849287F280028000000000FF8022002200FF80000
+BE97:000000284928492849287F3849287F280028000000800FF803E0041003E00000
+BE98:000000000010001024902490249E3F902490249E3F9000100010001000100000
+BE99:0000000849084908490E7F08490E7F080008000007F800080008000800080000
+BE9A:0000000849084908490E7F08490E7F080008000000003EF80208020802080000
+BE9B:0000000849084908490E7F08490E7F080008000000001F080108011401620000
+BE9C:0000000849084908490E7F08490E7F080008000008000800080008000FF80000
+BE9D:0000000849084908490E7F08490E7F0800080000000010F8101010301ECC0000
+BE9E:0000000849084908490E7F08490E7F08000800000808087F081C08220F9C0000
+BE9F:0000000849084908490E7F08490E7F080008000003F802000200020003F80000
+BEA0:0000000849084908490E7F08490E7F080008000007F8000807F8040007F80000
+BEA1:0000000849084908490E7F08490E7F08000800003EF802083E0820083E080000
+BEA2:0000000849084908490E7F08490E7F08000800003EF802883E8820883EF80000
+BEA3:0000000849084908490E7F08490E7F08000800003E8802883EF820883EF80000
+BEA4:0000000849084908490E7F08490E7F08000800001F0801081F0810141F620000
+BEA5:0000000849084908490E7F08490E7F08000800003EF802803EF820803EF80000
+BEA6:0000000849084908490E7F08490E7F08000800003EFC02483E4820483EFC0000
+BEA7:0000000849084908490E7F08490E7F08000800001F08017F1F1C10221F1C0000
+BEA8:0000000849084908490E7F08490E7F080008000003F802080208020803F80000
+BEA9:0000000849084908490E7F08490E7F08000800000208020803F8020803F80000
+BEAA:0000000849084908490E7F08490E7F0800080000110811081F0811141F620000
+BEAB:0000000849084908490E7F08490E7F0800080000001000100010006801840000
+BEAC:0000000849084908490E7F08490E7F08000800000048004800A8011406620000
+BEAD:0000000849084908490E7F08490E7F0800080000000003F00408040803F00000
+BEAE:0000000849084908490E7F08490E7F080008000003F80020002000D003080000
+BEAF:0000000849084908490E7F08490E7F0800080000004003F8004000A003180000
+BEB0:0000000849084908490E7F08490E7F080008000003F8000803F8000800080000
+BEB1:0000000849084908490E7F08490E7F080008000003F8020003F8020003F80000
+BEB2:0000000849084908490E7F08490E7F080008000000000FF8022002200FF80000
+BEB3:0000000849084908490E7F08490E7F080008000000800FF803E0041003E00000
+BEB4:000000000012001224922492249E3F922492249E3F9200120012001200120000
+BEB5:000000284928492849387F2849387F280028000007F800080008000800080000
+BEB6:000000284928492849387F2849387F280028000000003EF80208020802080000
+BEB7:000000284928492849387F2849387F280028000000003E100210022802C40000
+BEB8:000000284928492849387F2849387F280028002808000800080008000FF80000
+BEB9:000000284928492849387F2849387F2800280000000020F8201020303ECC0000
+BEBA:000000284928492849387F2849387F2800280000202021FC207020883E700000
+BEBB:000000284928492849387F2849387F280028000003F802000200020003F80000
+BEBC:000000284928492849387F2849387F280028000007F8000807F8040007F80000
+BEBD:000000284928492849387F2849387F28002800003EF802083E0820083E080000
+BEBE:000000284928492849387F2849387F28002800003EF802883E8820883EF80000
+BEBF:000000284928492849387F2849387F28002800003E8802883EF820883EF80000
+BEC0:000000284928492849387F2849387F28002800001F0801081F0810141F620000
+BEC1:000000284928492849387F2849387F28002800003EF802803EF820803EF80000
+BEC2:000000284928492849387F2849387F28002800003EFC02483E4820483EFC0000
+BEC3:000000284928492849387F2849387F28002800003E1002FE3E3820443E380000
+BEC4:000000284928492849387F2849387F280028000003F802080208020803F80000
+BEC5:000000284928492849387F2849387F28002800000208020803F8020803F80000
+BEC6:000000284928492849387F2849387F2800280000110811081F0811141F620000
+BEC7:000000284928492849387F2849387F2800280000000800080008003400C20000
+BEC8:000000284928492849387F2849387F28002800000048004800A8011406620000
+BEC9:000000284928492849387F2849387F2800280000000001F00208020801F00000
+BECA:000000284928492849387F2849387F280028000003F80020002000D003080000
+BECB:000000284928492849387F2849387F2800280000004003F8004000A003180000
+BECC:000000284928492849387F2849387F280028000003F8000803F8000800080000
+BECD:000000284928492849387F2849387F280028000003F8020003F8020003F80000
+BECE:000000284928492849387F2849387F280028000000000FF8022002200FF80000
+BECF:000000284928492849387F2849387F280028000000800FF803E0041003E00000
+BED0:00000000000200022482248224823F9E248224823F8200020002000200020000
+BED1:000000084908490849087F3849087F0800080000000007F80008000800080000
+BED2:000000084908490849087F3849087F080008000000003EF80208020802080000
+BED3:000000084908490849087F3849087F080008000000001F080108011401620000
+BED4:000000084908490849087F3849087F080008000000001000100010001FF80000
+BED5:000000084908490849087F3849087F0800080000000020F8201020303ECC0000
+BED6:000000084908490849087F3849087F0800080000202021FC207020883E700000
+BED7:000000084908490849087F3849087F080008000003F802000200020003F80000
+BED8:000000084908490849087F3849087F080008000007F8000807F8040007F80000
+BED9:000000084908490849087F3849087F08000800003EF802083E0820083E080000
+BEDA:000000084908490849087F3849087F08000800003EF802883E8820883EF80000
+BEDB:000000084908490849087F3849087F08000800003E8802883EF820883EF80000
+BEDC:000000084908490849087F3849087F08000800000F8800880F8808140FA20000
+BEDD:000000084908490849087F3849087F08000800003EF802803EF820803EF80000
+BEDE:000000084908490849087F3849087F08000800003EFC02483E4820483EFC0000
+BEDF:000000084908490849087F3849087F08000800003E1002FE3E3820443E380000
+BEE0:000000084908490849087F3849087F080008000003F802080208020803F80000
+BEE1:000000084908490849087F3849087F08000800000208020803F8020803F80000
+BEE2:000000084908490849087F3849087F0800080000210821083F0821143F620000
+BEE3:000000084908490849087F3849087F0800080000001000100010006801840000
+BEE4:000000084908490849087F3849087F08000800000048004800A8011406620000
+BEE5:000000084908490849087F3849087F0800080000000003F00408040803F00000
+BEE6:000000084908490849087F3849087F080008000003F80020002000D003080000
+BEE7:000000084908490849087F3849087F0800080000004003F8004000A003180000
+BEE8:000000084908490849087F3849087F080008000003F8000803F8000800080000
+BEE9:000000084908490849087F3849087F080008000003F8020003F8020003F80000
+BEEA:000000084908490849087F3849087F080008000000000FF8022002200FF80000
+BEEB:000000084908490849087F3849087F080008000000800FF803E0041003E00000
+BEEC:00000000000A000A248A248A248A3FBA248A248A3F8A000A000A000A000A0000
+BEED:000000284928492849287FE849287F280028000007F800080008000800080000
+BEEE:000000284928492849287FE849287F280028000000003EF80208020802080000
+BEEF:000000284928492849287FE849287F280028000000003E100210022802C40000
+BEF0:000000284928492849287FE849287F280028000008000800080008000FF80000
+BEF1:000000284928492849287FE849287F2800280000000020F8201020303ECC0000
+BEF2:000000284928492849287FE849287F2800280000202021FC207020883E700000
+BEF3:000000284928492849287FE849287F280028000003F802000200020003F80000
+BEF4:000000284928492849287FE849287F280028000007F8000807F8040007F80000
+BEF5:000000284928492849287FE849287F28002800003EF802083E0820083E080000
+BEF6:000000284928492849287FE849287F28002800003EF802883E8820883EF80000
+BEF7:000000284928492849287FE849287F28002800003E8802883EF820883EF80000
+BEF8:000000284928492849287FE849287F28002800001F0801081F0810141F620000
+BEF9:000000284928492849287FE849287F28002800003EF802803EF820803EF80000
+BEFA:000000284928492849287FE849287F28002800003EFC02483E4820483EFC0000
+BEFB:000000284928492849287FE849287F28002800003E1002FE3E3820443E380000
+BEFC:000000284928492849287FE849287F280028000003F802080208020803F80000
+BEFD:000000284928492849287FE849287F28002800000208020803F8020803F80000
+BEFE:000000284928492849287FE849287F2800280000110811081F0811141F620000
+BEFF:000000284928492849287FE849287F2800280000000800080008003400C20000
+BF00:000000284928492849287FE849287F28002800000048004800A8011406620000
+BF01:000000284928492849287FE849287F2800280000000001F00208020801F00000
+BF02:000000284928492849287FE849287F280028000003F80020002000D003080000
+BF03:000000284928492849287FE849287F2800280000004003F8004000A003180000
+BF04:000000284928492849287FE849287F280028000003F8000803F8000800080000
+BF05:000000284928492849287FE849287F280028000003F8020003F8020003F80000
+BF06:000000284928492849287FE849287F280028000000000FF8022002200FF80000
+BF07:000000284928492849287FE849287F280028000000800FF803E0041003E00000
+BF08:000000000002000224822482249E3F822482249E3F8200020002000200020000
+BF09:000000084908490849387F0849387F0800080000000007F80008000800080000
+BF0A:000000084908490849387F0849387F080008000000003EF80208020802080000
+BF0B:000000084908490849387F0849387F080008000000001F080108011401620000
+BF0C:000000084908490849387F0849387F080008000800001000100010001FF80000
+BF0D:000000084908490849387F0849387F0800080000000020F8201020303ECC0000
+BF0E:000000084908490849387F0849387F0800080000202021FC207020883E700000
+BF0F:000000084908490849387F0849387F080008000003F802000200020003F80000
+BF10:000000084908490849387F0849387F080008000007F8000807F8040007F80000
+BF11:000000084908490849387F0849387F08000800003EF802083E0820083E080000
+BF12:000000084908490849387F0849387F08000800003EF802883E8820883EF80000
+BF13:000000084908490849387F0849387F08000800003E8802883EF820883EF80000
+BF14:000000084908490849387F0849387F08000800000F8800880F8808140FA20000
+BF15:000000084908490849387F0849387F08000800003EF802803EF820803EF80000
+BF16:000000084908490849387F0849387F08000800003EFC02483E4820483EFC0000
+BF17:000000084908490849387F0849387F08000800003E1002FE3E3820443E380000
+BF18:000000084908490849387F0849387F080008000003F802080208020803F80000
+BF19:000000084908490849387F0849387F08000800000208020803F8020803F80000
+BF1A:000000084908490849387F0849387F0800080000210821083F0821143F620000
+BF1B:000000084908490849387F0849387F0800080000001000100010006801840000
+BF1C:000000084908490849387F0849387F08000800000048004800A8011406620000
+BF1D:000000084908490849387F0849387F0800080000000003F00408040803F00000
+BF1E:000000084908490849387F0849387F080008000003F80020002000D003080000
+BF1F:000000084908490849387F0849387F0800080000004003F8004000A003180000
+BF20:000000084908490849387F0849387F080008000003F8000803F8000800080000
+BF21:000000084908490849387F0849387F080008000003F8020003F8020003F80000
+BF22:000000084908490849387F0849387F080008000000000FF8022002200FF80000
+BF23:000000084908490849387F0849387F080008000000800FF803E0041003E00000
+BF24:00000000000A000A248A248A24BA3F8A248A24BA3F8A000A000A000A000A0000
+BF25:000000284928492849E87F2849E87F280028000007F800080008000800080000
+BF26:000000284928492849E87F2849E87F280028000000003EF80208020802080000
+BF27:000000284928492849E87F2849E87F280028000000003E100210022802C40000
+BF28:000000284928492849E87F2849E87F280028002808000800080008000FF80000
+BF29:000000284928492849E87F2849E87F2800280000000020F8201020303ECC0000
+BF2A:000000284928492849E87F2849E87F2800280000202021FC207020883E700000
+BF2B:000000284928492849E87F2849E87F280028000003F802000200020003F80000
+BF2C:000000284928492849E87F2849E87F280028000007F8000807F8040007F80000
+BF2D:000000284928492849E87F2849E87F28002800003EF802083E0820083E080000
+BF2E:000000284928492849E87F2849E87F28002800003EF802883E8820883EF80000
+BF2F:000000284928492849E87F2849E87F28002800003E8802883EF820883EF80000
+BF30:000000284928492849E87F2849E87F28002800001F0801081F0810141F620000
+BF31:000000284928492849E87F2849E87F28002800003EF802803EF820803EF80000
+BF32:000000284928492849E87F2849E87F28002800003EFC02483E4820483EFC0000
+BF33:000000284928492849E87F2849E87F28002800003E1002FE3E3820443E380000
+BF34:000000284928492849E87F2849E87F280028000003F802080208020803F80000
+BF35:000000284928492849E87F2849E87F28002800000208020803F8020803F80000
+BF36:000000284928492849E87F2849E87F2800280000110811081F0811141F620000
+BF37:000000284928492849E87F2849E87F2800280000000800080008003400C20000
+BF38:000000284928492849E87F2849E87F28002800000048004800A8011406620000
+BF39:000000284928492849E87F2849E87F2800280000000001F00208020801F00000
+BF3A:000000284928492849E87F2849E87F280028000003F80020002000D003080000
+BF3B:000000284928492849E87F2849E87F2800280000004003F8004000A003180000
+BF3C:000000284928492849E87F2849E87F280028000003F8000803F8000800080000
+BF3D:000000284928492849E87F2849E87F280028000003F8020003F8020003F80000
+BF3E:000000284928492849E87F2849E87F280028000000000FF8022002200FF80000
+BF3F:000000284928492849E87F2849E87F280028000000800FF803E0041003E00000
+BF40:000000002108210821083FF8210821083FF800000100010001007FFC00000000
+BF41:0000210821083FF821083FF8010001007FFC00001FF000100010001000100000
+BF42:0000210821083FF821083FF8010001007FFC000000003EF80208020802080000
+BF43:0000210821083FF821083FF8010001007FFC000000001E100210022802C40000
+BF44:0000210821083FF821083FF8010001007FFC000000001000100010001FF00000
+BF45:0000210821083FF821083FF8010001007FFC0000000020F8201020303ECC0000
+BF46:0000210821083FF821083FF8010001007FFC0000202021FC207020883E700000
+BF47:0000210821083FF821083FF8010001007FFC00001FF01000100010001FF00000
+BF48:0000210821083FF821083FF8010001007FFC00001FF000101FF010001FF00000
+BF49:0000210821083FF821083FF8010001007FFC00003EF802083E0820083E080000
+BF4A:0000210821083FF821083FF8010001007FFC00003EF802883E8820883EF80000
+BF4B:0000210821083FF821083FF8010001007FFC00003E8802883EF820883EF80000
+BF4C:0000210821083FF821083FF8010001007FFC00003E1002103E1020283EC40000
+BF4D:0000210821083FF821083FF8010001007FFC00003EF802803EF820803EF80000
+BF4E:0000210821083FF821083FF8010001007FFC00003EFC02483E4820483EFC0000
+BF4F:0000210821083FF821083FF8010001007FFC00003E2003FC3E7020883E700000
+BF50:0000210821083FF821083FF8010001007FFC00001FF01010101010101FF00000
+BF51:0000210821083FF821083FF8010001007FFC0000101010101FF010101FF00000
+BF52:0000210821083FF821083FF8010001007FFC0000222022203E2022503E880000
+BF53:0000210821083FF821083FF8010001007FFC000000000100010002800C400000
+BF54:0000210821083FF821083FF8010001007FFC00000000024002400DA033100000
+BF55:0000210821083FF821083FF8010001007FFC0000000007C00820082007C00000
+BF56:0000210821083FF821083FF8010001007FFC0000000007E00080014006200000
+BF57:0000210821083FF821083FF8010001007FFC0000008007E00080014006200000
+BF58:0000210821083FF821083FF8010001007FFC00001FF000101FF0001000100000
+BF59:0000210821083FF821083FF8010001007FFC00001FF010001FF010001FF00000
+BF5A:0000210821083FF821083FF8010001007FFC000000001FF0044004401FF00000
+BF5B:0000210821083FF821083FF8010001007FFC000001001FF007C0082007C00000
+BF5C:0000001000104450445044507FD0445E44507FD0041004107FD0001000100000
+BF5D:0000248824883F88248E3F88040804087FE8000007F800080008000800080000
+BF5E:0000248824883F88248E3F88040804087FE8000000003EF80208020802080000
+BF5F:0000248824883F88248E3F88040804087FE8000000001F080108011401620000
+BF60:0000248824883F88248E3F88040804087FE8000008000800080008000FF80000
+BF61:0000248824883F88248E3F88040804087FE80000000010F8101010301ECC0000
+BF62:0000248824883F88248E3F88040804087FE800000808087F081C08220F9C0000
+BF63:0000248824883F88248E3F88040804087FE8000003F802000200020003F80000
+BF64:0000248824883F88248E3F88040804087FE8000007F8000807F8040007F80000
+BF65:0000248824883F88248E3F88040804087FE800003EF802083E0820083E080000
+BF66:0000248824883F88248E3F88040804087FE800003EF802883E8820883EF80000
+BF67:0000248824883F88248E3F88040804087FE800003E8802883EF820883EF80000
+BF68:0000248824883F88248E3F88040804087FE800001F0801081F0810141F620000
+BF69:0000248824883F88248E3F88040804087FE800003EF802803EF820803EF80000
+BF6A:0000248824883F88248E3F88040804087FE800003EFC02483E4820483EFC0000
+BF6B:0000248824883F88248E3F88040804087FE800001F08017F1F1C10221F1C0000
+BF6C:0000248824883F88248E3F88040804087FE8000003F802080208020803F80000
+BF6D:0000248824883F88248E3F88040804087FE800000208020803F8020803F80000
+BF6E:0000248824883F88248E3F88040804087FE80000110811081F0811141F620000
+BF6F:0000248824883F88248E3F88040804087FE80000001000100010006801840000
+BF70:0000248824883F88248E3F88040804087FE800000048004800A8011406620000
+BF71:0000248824883F88248E3F88040804087FE80000000003F00408040803F00000
+BF72:0000248824883F88248E3F88040804087FE8000003F80020002000D003080000
+BF73:0000248824883F88248E3F88040804087FE80000004003F8004000A003180000
+BF74:0000248824883F88248E3F88040804087FE8000003F8000803F8000800080000
+BF75:0000248824883F88248E3F88040804087FE8000003F8020003F8020003F80000
+BF76:0000248824883F88248E3F88040804087FE8000000000FF8022002200FF80000
+BF77:0000248824883F88248E3F88040804087FE8000000800FF803E0041003E00000
+BF78:0000001200124452445244527FD2445E44527FD2041204127FD2001200120000
+BF79:000024A824A83FA824B83FA8042804287FA8000007F800080008000800080000
+BF7A:000024A824A83FA824B83FA8042804287FA8000000003EF80208020802080000
+BF7B:000024A824A83FA824B83FA8042804287FA8000000001F080108011401620000
+BF7C:000024A824A83FA824B83FA8042804287FA8000008000800080008000FF80000
+BF7D:000024A824A83FA824B83FA8042804287FA80000000010F8101010301ECC0000
+BF7E:000024A824A83FA824B83FA8042804287FA800000808087F081C08220F9C0000
+BF7F:000024A824A83FA824B83FA8042804287FA8000003F802000200020003F80000
+BF80:000024A824A83FA824B83FA8042804287FA8000007F8000807F8040007F80000
+BF81:000024A824A83FA824B83FA8042804287FA800003EF802083E0820083E080000
+BF82:000024A824A83FA824B83FA8042804287FA800003EF802883E8820883EF80000
+BF83:000024A824A83FA824B83FA8042804287FA800003E8802883EF820883EF80000
+BF84:000024A824A83FA824B83FA8042804287FA800001F0801081F0810141F620000
+BF85:000024A824A83FA824B83FA8042804287FA800003EF802803EF820803EF80000
+BF86:000024A824A83FA824B83FA8042804287FA800003EFC02483E4820483EFC0000
+BF87:000024A824A83FA824B83FA8042804287FA800001F08017F1F1C10221F1C0000
+BF88:000024A824A83FA824B83FA8042804287FA8000003F802080208020803F80000
+BF89:000024A824A83FA824B83FA8042804287FA800000208020803F8020803F80000
+BF8A:000024A824A83FA824B83FA8042804287FA80000110811081F0811141F620000
+BF8B:000024A824A83FA824B83FA8042804287FA80000001000100010006801840000
+BF8C:000024A824A83FA824B83FA8042804287FA800000048004800A8011406620000
+BF8D:000024A824A83FA824B83FA8042804287FA80000000003F00408040803F00000
+BF8E:000024A824A83FA824B83FA8042804287FA8000003F80020002000D003080000
+BF8F:000024A824A83FA824B83FA8042804287FA80000004003F8004000A003180000
+BF90:000024A824A83FA824B83FA8042804287FA8000003F8000803F8000800080000
+BF91:000024A824A83FA824B83FA8042804287FA8000003F8020003F8020003F80000
+BF92:000024A824A83FA824B83FA8042804287FA8000000000FF8022002200FF80000
+BF93:000024A824A83FA824B83FA8042804287FA8000000800FF803E0041003E00000
+BF94:0000000800084448444844487FC8444844487FC8040804087FE8000800080000
+BF95:0000248824883F8824883F88040804087FE8000007F800080008000800080000
+BF96:0000248824883F8824883F88040804087FE8000000003EF80208020802080000
+BF97:0000248824883F8824883F88040804087FE8000000001F080108011401620000
+BF98:0000248824883F8824883F88040804087FE8000008000800080008000FF80000
+BF99:0000248824883F8824883F88040804087FE80000000010F8101010301ECC0000
+BF9A:0000248824883F8824883F88040804087FE800000808087F081C08220F9C0000
+BF9B:0000248824883F8824883F88040804087FE8000003F802000200020003F80000
+BF9C:0000248824883F8824883F88040804087FE8000007F8000807F8040007F80000
+BF9D:0000248824883F8824883F88040804087FE800003EF802083E0820083E080000
+BF9E:0000248824883F8824883F88040804087FE800003EF802883E8820883EF80000
+BF9F:0000248824883F8824883F88040804087FE800003E8802883EF820883EF80000
+BFA0:0000248824883F8824883F88040804087FE800001F0801081F0810141F620000
+BFA1:0000248824883F8824883F88040804087FE800003EF802803EF820803EF80000
+BFA2:0000248824883F8824883F88040804087FE800003EFC02483E4820483EFC0000
+BFA3:0000248824883F8824883F88040804087FE800001F08017F1F1C10221F1C0000
+BFA4:0000248824883F8824883F88040804087FE8000003F802080208020803F80000
+BFA5:0000248824883F8824883F88040804087FE800000208020803F8020803F80000
+BFA6:0000248824883F8824883F88040804087FE80000110811081F0811141F620000
+BFA7:0000248824883F8824883F88040804087FE80000001000100010006801840000
+BFA8:0000248824883F8824883F88040804087FE800000048004800A8011406620000
+BFA9:0000248824883F8824883F88040804087FE80000000003F00408040803F00000
+BFAA:0000248824883F8824883F88040804087FE8000003F80020002000D003080000
+BFAB:0000248824883F8824883F88040804087FE80000004003F8004000A003180000
+BFAC:0000248824883F8824883F88040804087FE8000003F8000803F8000800080000
+BFAD:0000248824883F8824883F88040804087FE8000003F8020003F8020003F80000
+BFAE:0000248824883F8824883F88040804087FE8000000000FF8022002200FF80000
+BFAF:0000248824883F8824883F88040804087FE8000000800FF803E0041003E00000
+BFB0:000000002108210821083FF8210821083FF804400440044004407FFC00000000
+BFB1:0000210821083FF821083FF8044004407FFC00001FF000100010001000100000
+BFB2:0000210821083FF821083FF8044004407FFC000000003EF80208020802080000
+BFB3:0000210821083FF821083FF8044004407FFC000000001E100210022802C40000
+BFB4:0000210821083FF821083FF8044004407FFC000000001000100010001FF00000
+BFB5:0000210821083FF821083FF8044004407FFC0000000020F8201020303ECC0000
+BFB6:0000210821083FF821083FF8044004407FFC0000202021FC207020883E700000
+BFB7:0000210821083FF821083FF8044004407FFC00001FF01000100010001FF00000
+BFB8:0000210821083FF821083FF8044004407FFC00001FF000101FF010001FF00000
+BFB9:0000210821083FF821083FF8044004407FFC00003EF802083E0820083E080000
+BFBA:0000210821083FF821083FF8044004407FFC00003EF802883E8820883EF80000
+BFBB:0000210821083FF821083FF8044004407FFC00003E8802883EF820883EF80000
+BFBC:0000210821083FF821083FF8044004407FFC00003E1002103E1020283EC40000
+BFBD:0000210821083FF821083FF8044004407FFC00003EF802803EF820803EF80000
+BFBE:0000210821083FF821083FF8044004407FFC00003EFC02483E4820483EFC0000
+BFBF:0000210821083FF821083FF8044004407FFC00003E2003FC3E7020883E700000
+BFC0:0000210821083FF821083FF8044004407FFC00001FF01010101010101FF00000
+BFC1:0000210821083FF821083FF8044004407FFC0000101010101FF010101FF00000
+BFC2:0000210821083FF821083FF8044004407FFC0000222022203E2022503E880000
+BFC3:0000210821083FF821083FF8044004407FFC000000000100010002800C400000
+BFC4:0000210821083FF821083FF8044004407FFC00000000024002400DA033100000
+BFC5:0000210821083FF821083FF8044004407FFC0000000007C00820082007C00000
+BFC6:0000210821083FF821083FF8044004407FFC0000000007E00080014006200000
+BFC7:0000210821083FF821083FF8044004407FFC0000008007E00080014006200000
+BFC8:0000210821083FF821083FF8044004407FFC00001FF000101FF0001000100000
+BFC9:0000210821083FF821083FF8044004407FFC00001FF010001FF010001FF00000
+BFCA:0000210821083FF821083FF8044004407FFC000000001FF0044004401FF00000
+BFCB:0000210821083FF821083FF8044004407FFC000001001FF007C0082007C00000
+BFCC:000000002108210821083FF8210821083FF800003FF801000100010001000000
+BFCD:0000210821083FF821083FF800007FFC010001001FF000100010001000100000
+BFCE:0000210821083FF821083FF800007FFC0100010000003EF80208020802080000
+BFCF:0000210821083FF821083FF800007FFC0100010000001E100210022802C40000
+BFD0:0000210821083FF821083FF8000000007FFC010001001100100010001FF00000
+BFD1:0000210821083FF821083FF800007FFC01000100000020F8201020303ECC0000
+BFD2:0000210821083FF821083FF800007FFC01000100202021FC207020883E700000
+BFD3:0000210821083FF821083FF800007FFC010001001FF01000100010001FF00000
+BFD4:0000210821083FF821083FF800007FFC010001001FF000101FF010001FF00000
+BFD5:0000210821083FF821083FF800007FFC010001003EF802083E0820083E080000
+BFD6:0000210821083FF821083FF800007FFC010001003EF802883E8820883EF80000
+BFD7:0000210821083FF821083FF800007FFC010001003E8802883EF820883EF80000
+BFD8:0000210821083FF821083FF800007FFC010001003E1002103E1020283EC40000
+BFD9:0000210821083FF821083FF800007FFC010001003EF802803EF820803EF80000
+BFDA:0000210821083FF821083FF800007FFC010001003EFC02483E4820483EFC0000
+BFDB:0000210821083FF821083FF800007FFC010001003E2003FC3E7020883E700000
+BFDC:0000210821083FF821083FF800007FFC010001001FF01010101010101FF00000
+BFDD:0000210821083FF821083FF800007FFC01000100101010101FF010101FF00000
+BFDE:0000210821083FF821083FF800007FFC01000100222022203E2022503E880000
+BFDF:0000210821083FF821083FF800007FFC0100010000000100010002800C400000
+BFE0:0000210821083FF821083FF800007FFC010001000000024002400DA033100000
+BFE1:0000210821083FF821083FF800007FFC01000100000007C00820082007C00000
+BFE2:0000210821083FF821083FF800007FFC01000100000007E00080014006200000
+BFE3:0000210821083FF821083FF800007FFC01000100008007E00080014006200000
+BFE4:0000210821083FF821083FF800007FFC010001001FF000101FF0001000100000
+BFE5:0000210821083FF821083FF800007FFC010001001FF010001FF010001FF00000
+BFE6:0000210821083FF821083FF800007FFC0100010000001FF0044004401FF00000
+BFE7:0000210821083FF821083FF800007FFC0100010001001FF007C0082007C00000
+BFE8:000000084448444844487FC8444844487FC800087FE8040804F8040804080000
+BFE9:248824883F8824883F8800087FE8027802080000000007F80008000800080000
+BFEA:248824883F8824883F8800087FE802780208000000003EF80208020802080000
+BFEB:248824883F8824883F8800087FE802780208000000001F080108011401620000
+BFEC:248824883F8824883F88000800087FE80278020802081000100010001FF80000
+BFED:248824883F8824883F8800087FE8027802080000000020F8201020303ECC0000
+BFEE:248824883F8824883F8800087FE8027802080000202021FC207020883E700000
+BFEF:248824883F8824883F8800087FE802780208000003F802000200020003F80000
+BFF0:248824883F8824883F8800087FE802780208000007F8000807F8040007F80000
+BFF1:248824883F8824883F8800087FE80278020800003EF802083E0820083E080000
+BFF2:248824883F8824883F8800087FE80278020800003EF802883E8820883EF80000
+BFF3:248824883F8824883F8800087FE80278020800003E8802883EF820883EF80000
+BFF4:248824883F8824883F8800087FE80278020800000F8800880F8808140FA20000
+BFF5:248824883F8824883F8800087FE80278020800003EF802803EF820803EF80000
+BFF6:248824883F8824883F8800087FE80278020800003EFC02483E4820483EFC0000
+BFF7:248824883F8824883F8800087FE80278020800003E1002FE3E3820443E380000
+BFF8:248824883F8824883F8800087FE802780208000003F802080208020803F80000
+BFF9:248824883F8824883F8800087FE80278020800000208020803F8020803F80000
+BFFA:248824883F8824883F8800087FE8027802080000210821083F0821143F620000
+BFFB:248824883F8824883F8800087FE8027802080000001000100010006801840000
+BFFC:248824883F8824883F8800087FE80278020800000048004800A8011406620000
+BFFD:248824883F8824883F8800087FE8027802080000000003F00408040803F00000
+BFFE:248824883F8824883F8800087FE802780208000003F80020002000D003080000
+BFFF:248824883F8824883F8800087FE8027802080000004003F8004000A003180000
+C000:248824883F8824883F8800087FE802780208000003F8000803F8000800080000
+C001:248824883F8824883F8800087FE802780208000003F8020003F8020003F80000
+C002:248824883F8824883F8800087FE802780208000000000FF8022002200FF80000
+C003:248824883F8824883F8800087FE802780208000000800FF803E0041003E00000
+C004:0000000A444A444A444A7FCA444A444A7FCA000A7FEA040A047A040A040A0000
+C005:24A824A83FA824A83FA800287FA805E804280000000007F80008000800080000
+C006:24A824A83FA824A83FA800287FA805E80428000000003EF80208020802080000
+C007:24A824A83FA824A83FA800287FA805E80428000000001F080108011401620000
+C008:24A824A83FA824A83FA8002800287FA8042805E804281428100010001FF80000
+C009:24A824A83FA824A83FA800287FA805E804280000000020F8201020303ECC0000
+C00A:24A824A83FA824A83FA800287FA805E804280000202021FC207020883E700000
+C00B:24A824A83FA824A83FA800287FA805E80428000003F802000200020003F80000
+C00C:24A824A83FA824A83FA800287FA805E80428000007F8000807F8040007F80000
+C00D:24A824A83FA824A83FA800287FA805E8042800003EF802083E0820083E080000
+C00E:24A824A83FA824A83FA800287FA805E8042800003EF802883E8820883EF80000
+C00F:24A824A83FA824A83FA800287FA805E8042800003E8802883EF820883EF80000
+C010:24A824A83FA824A83FA800287FA805E8042800000F8800880F8808140FA20000
+C011:24A824A83FA824A83FA800287FA805E8042800003EF802803EF820803EF80000
+C012:24A824A83FA824A83FA800287FA805E8042800003EFC02483E4820483EFC0000
+C013:24A824A83FA824A83FA800287FA805E8042800003E1002FE3E3820443E380000
+C014:24A824A83FA824A83FA800287FA805E80428000003F802080208020803F80000
+C015:24A824A83FA824A83FA800287FA805E8042800000208020803F8020803F80000
+C016:24A824A83FA824A83FA800287FA805E804280000210821083F0821143F620000
+C017:24A824A83FA824A83FA800287FA805E804280000001000100010006801840000
+C018:24A824A83FA824A83FA800287FA805E8042800000048004800A8011406620000
+C019:24A824A83FA824A83FA800287FA805E804280000000003F00408040803F00000
+C01A:24A824A83FA824A83FA800287FA805E80428000003F80020002000D003080000
+C01B:24A824A83FA824A83FA800287FA805E804280000004003F8004000A003180000
+C01C:24A824A83FA824A83FA800287FA805E80428000003F8000803F8000800080000
+C01D:24A824A83FA824A83FA800287FA805E80428000003F8020003F8020003F80000
+C01E:24A824A83FA824A83FA800287FA805E80428000000000FF8022002200FF80000
+C01F:24A824A83FA824A83FA800287FA805E80428000000800FF803E0041003E00000
+C020:000000084448444844487FC8444844487FC800087FE804080408040804080000
+C021:248824883F8824883F8800087FE8020802000000000007F80008000800080000
+C022:248824883F8824883F8800087FE802080200000000003EF80208020802080000
+C023:248824883F8824883F8800087FE802080200000000001F080108011401620000
+C024:248824883F8824883F88000800087FE80208020802081008100010001FF80000
+C025:248824883F8824883F8800087FE8020802000000000020F8201020303ECC0000
+C026:248824883F8824883F8800087FE8020802000000202021FC207020883E700000
+C027:248824883F8824883F8800087FE802080200000003F802000200020003F80000
+C028:248824883F8824883F8800087FE802080200000007F8000807F8040007F80000
+C029:248824883F8824883F8800087FE80208020000003EF802083E0820083E080000
+C02A:248824883F8824883F8800087FE80208020000003EF802883E8820883EF80000
+C02B:248824883F8824883F8800087FE80208020000003E8802883EF820883EF80000
+C02C:248824883F8824883F8800087FE80208020000000F8800880F8808140FA20000
+C02D:248824883F8824883F8800087FE80208020000003EF802803EF820803EF80000
+C02E:248824883F8824883F8800087FE80208020000003EFC02483E4820483EFC0000
+C02F:248824883F8824883F8800087FE80208020000003E1002FE3E3820443E380000
+C030:248824883F8824883F8800087FE802080200000003F802080208020803F80000
+C031:248824883F8824883F8800087FE80208020000000208020803F8020803F80000
+C032:248824883F8824883F8800087FE8020802000000210821083F0821143F620000
+C033:248824883F8824883F8800087FE8020802000000001000100010006801840000
+C034:248824883F8824883F8800087FE80208020000000048004800A8011406620000
+C035:248824883F8824883F8800087FE8020802000000000003F00408040803F00000
+C036:248824883F8824883F8800087FE802080200000003F80020002000D003080000
+C037:248824883F8824883F8800087FE8020802000000004003F8004000A003180000
+C038:248824883F8824883F8800087FE802080200000003F8000803F8000800080000
+C039:248824883F8824883F8800087FE802080200000003F8020003F8020003F80000
+C03A:248824883F8824883F8800087FE802080200000000000FF8022002200FF80000
+C03B:248824883F8824883F8800087FE802080200000000800FF803E0041003E00000
+C03C:000000002108210821083FF8210821083FF800007FFC04400440044004400000
+C03D:0000210821083FF821083FF800007FFC044004401FF000100010001000100000
+C03E:0000210821083FF821083FF800007FFC0440044000003EF80208020802080000
+C03F:0000210821083FF821083FF800007FFC0440044000001E100210022802C40000
+C040:0000210821083FF821083FF8000000007FFC044004401440100010001FF00000
+C041:0000210821083FF821083FF800007FFC04400440000020F8201020303ECC0000
+C042:0000210821083FF821083FF800007FFC04400440202021FC207020883E700000
+C043:0000210821083FF821083FF800007FFC044004401FF01000100010001FF00000
+C044:0000210821083FF821083FF800007FFC044004401FF000101FF010001FF00000
+C045:0000210821083FF821083FF800007FFC044004403EF802083E0820083E080000
+C046:0000210821083FF821083FF800007FFC044004403EF802883E8820883EF80000
+C047:0000210821083FF821083FF800007FFC044004403E8802883EF820883EF80000
+C048:0000210821083FF821083FF800007FFC044004403E1002103E1020283EC40000
+C049:0000210821083FF821083FF800007FFC044004403EF802803EF820803EF80000
+C04A:0000210821083FF821083FF800007FFC044004403EFC02483E4820483EFC0000
+C04B:0000210821083FF821083FF800007FFC044004403E2003FC3E7020883E700000
+C04C:0000210821083FF821083FF800007FFC044004401FF01010101010101FF00000
+C04D:0000210821083FF821083FF800007FFC04400440101010101FF010101FF00000
+C04E:0000210821083FF821083FF800007FFC04400440222022203E2022503E880000
+C04F:0000210821083FF821083FF800007FFC0440044000000100010002800C400000
+C050:0000210821083FF821083FF800007FFC044004400000024002400DA033100000
+C051:0000210821083FF821083FF800007FFC04400440000007C00820082007C00000
+C052:0000210821083FF821083FF800007FFC04400440000007E00080014006200000
+C053:0000210821083FF821083FF800007FFC04400440008007E00080014006200000
+C054:0000210821083FF821083FF800007FFC044004401FF000101FF0001000100000
+C055:0000210821083FF821083FF800007FFC044004401FF010001FF010001FF00000
+C056:0000210821083FF821083FF800007FFC0440044000001FF0044004401FF00000
+C057:0000210821083FF821083FF800007FFC0440044001001FF007C0082007C00000
+C058:000000002108210821083FF8210821083FF8000000007FFC0000000000000000
+C059:0000210821083FF821083FF8000000007FFC00001FF000100010001000100000
+C05A:0000210821083FF821083FF8000000007FFC000000003EF80208020802080000
+C05B:0000210821083FF821083FF8000000007FFC000000001E100210022802C40000
+C05C:0000210821083FF821083FF8000000007FFC000000001000100010001FF00000
+C05D:0000210821083FF821083FF8000000007FFC0000000020F8201020303ECC0000
+C05E:0000210821083FF821083FF8000000007FFC0000202021FC207020883E700000
+C05F:0000210821083FF821083FF8000000007FFC00001FF01000100010001FF00000
+C060:0000210821083FF821083FF8000000007FFC00001FF000101FF010001FF00000
+C061:0000210821083FF821083FF8000000007FFC00003EF802083E0820083E080000
+C062:0000210821083FF821083FF8000000007FFC00003EF802883E8820883EF80000
+C063:0000210821083FF821083FF8000000007FFC00003E8802883EF820883EF80000
+C064:0000210821083FF821083FF8000000007FFC00003E1002103E1020283EC40000
+C065:0000210821083FF821083FF8000000007FFC00003EF802803EF820803EF80000
+C066:0000210821083FF821083FF8000000007FFC00003EFC02483E4820483EFC0000
+C067:0000210821083FF821083FF8000000007FFC00003E2003FC3E7020883E700000
+C068:0000210821083FF821083FF8000000007FFC00001FF01010101010101FF00000
+C069:0000210821083FF821083FF8000000007FFC0000101010101FF010101FF00000
+C06A:0000210821083FF821083FF8000000007FFC0000222022203E2022503E880000
+C06B:0000210821083FF821083FF8000000007FFC000000000100010002800C400000
+C06C:0000210821083FF821083FF8000000007FFC00000000024002400DA033100000
+C06D:0000210821083FF821083FF8000000007FFC0000000007C00820082007C00000
+C06E:0000210821083FF821083FF8000000007FFC0000000007E00080014006200000
+C06F:0000210821083FF821083FF8000000007FFC0000008007E00080014006200000
+C070:0000210821083FF821083FF8000000007FFC00001FF000101FF0001000100000
+C071:0000210821083FF821083FF8000000007FFC00001FF010001FF010001FF00000
+C072:0000210821083FF821083FF8000000007FFC000000001FF0044004401FF00000
+C073:0000210821083FF821083FF8000000007FFC000001001FF007C0082007C00000
+C074:0000000800084448444844487FC8444844487FC800087FE80008000800080000
+C075:0000248824883F8824883F88000800087FE8000007F800080008000800080000
+C076:0000248824883F8824883F88000800087FE8000000003EF80208020802080000
+C077:0000248824883F8824883F88000800087FE8000000001F080108011401620000
+C078:0000248824883F8824883F88000800087FE8000008000800080008000FF80000
+C079:0000248824883F8824883F88000800087FE80000000010F8101010301ECC0000
+C07A:0000248824883F8824883F88000800087FE800000808087F081C08220F9C0000
+C07B:0000248824883F8824883F88000800087FE8000003F802000200020003F80000
+C07C:0000248824883F8824883F88000800087FE8000007F8000807F8040007F80000
+C07D:0000248824883F8824883F88000800087FE800003EF802083E0820083E080000
+C07E:0000248824883F8824883F88000800087FE800003EF802883E8820883EF80000
+C07F:0000248824883F8824883F88000800087FE800003E8802883EF820883EF80000
+C080:0000248824883F8824883F88000800087FE800001F0801081F0810141F620000
+C081:0000248824883F8824883F88000800087FE800003EF802803EF820803EF80000
+C082:0000248824883F8824883F88000800087FE800003EFC02483E4820483EFC0000
+C083:0000248824883F8824883F88000800087FE800001F08017F1F1C10221F1C0000
+C084:0000248824883F8824883F88000800087FE8000003F802080208020803F80000
+C085:0000248824883F8824883F88000800087FE800000208020803F8020803F80000
+C086:0000248824883F8824883F88000800087FE80000110811081F0811141F620000
+C087:0000248824883F8824883F88000800087FE80000001000100010006801840000
+C088:0000248824883F8824883F88000800087FE800000048004800A8011406620000
+C089:0000248824883F8824883F88000800087FE80000000003F00408040803F00000
+C08A:0000248824883F8824883F88000800087FE8000003F80020002000D003080000
+C08B:0000248824883F8824883F88000800087FE80000004003F8004000A003180000
+C08C:0000248824883F8824883F88000800087FE8000003F8000803F8000800080000
+C08D:0000248824883F8824883F88000800087FE8000003F8020003F8020003F80000
+C08E:0000248824883F8824883F88000800087FE8000000000FF8022002200FF80000
+C08F:0000248824883F8824883F88000800087FE8000000800FF803E0041003E00000
+C090:00000000000800082488248824883F88248824883F8800080008000800080000
+C091:000000084908490849087F0849087F0800080000000007F80008000800080000
+C092:000000084908490849087F0849087F080008000000003EF80208020802080000
+C093:000000084908490849087F0849087F080008000000001F080108011401620000
+C094:000000084908490849087F0849087F080008000800001000100010001FF80000
+C095:000000084908490849087F0849087F0800080000000020F8201020303ECC0000
+C096:000000084908490849087F0849087F0800080000202021FC207020883E700000
+C097:000000084908490849087F0849087F080008000003F802000200020003F80000
+C098:000000084908490849087F0849087F080008000007F8000807F8040007F80000
+C099:000000084908490849087F0849087F08000800003EF802083E0820083E080000
+C09A:000000084908490849087F0849087F08000800003EF802883E8820883EF80000
+C09B:000000084908490849087F0849087F08000800003E8802883EF820883EF80000
+C09C:000000084908490849087F0849087F08000800000F8800880F8808140FA20000
+C09D:000000084908490849087F0849087F08000800003EF802803EF820803EF80000
+C09E:000000084908490849087F0849087F08000800003EFC02483E4820483EFC0000
+C09F:000000084908490849087F0849087F08000800003E1002FE3E3820443E380000
+C0A0:000000084908490849087F0849087F080008000003F802080208020803F80000
+C0A1:000000084908490849087F0849087F08000800000208020803F8020803F80000
+C0A2:000000084908490849087F0849087F0800080000210821083F0821143F620000
+C0A3:000000084908490849087F0849087F0800080000001000100010006801840000
+C0A4:000000084908490849087F0849087F08000800000048004800A8011406620000
+C0A5:000000084908490849087F0849087F0800080000000003F00408040803F00000
+C0A6:000000084908490849087F0849087F080008000003F80020002000D003080000
+C0A7:000000084908490849087F0849087F0800080000004003F8004000A003180000
+C0A8:000000084908490849087F0849087F080008000003F8000803F8000800080000
+C0A9:000000084908490849087F0849087F080008000003F8020003F8020003F80000
+C0AA:000000084908490849087F0849087F080008000000000FF8022002200FF80000
+C0AB:000000084908490849087F0849087F080008000000800FF803E0041003E00000
+C0AC:0000000000100010021002100410041E0A101110609000100010001000100000
+C0AD:000000080008040804080C0E120861080008000007F800080008000800080000
+C0AE:000000080008040804080C0E120861080008000000003EF80208020802080000
+C0AF:000000080008040804080C0E120861080008000000001F080108011401620000
+C0B0:000000080008040804080C0E120861080008000808000800080008000FF80000
+C0B1:000000080008040804080C0E1208610800080000000010F8101010301ECC0000
+C0B2:000000080008040804080C0E12086108000800000808087F081C08220F9C0000
+C0B3:000000080008040804080C0E120861080008000003F802000200020003F80000
+C0B4:000000080008040804080C0E120861080008000007F8000807F8040007F80000
+C0B5:000000080008040804080C0E12086108000800003EF802083E0820083E080000
+C0B6:000000080008040804080C0E12086108000800003EF802883E8820883EF80000
+C0B7:000000080008040804080C0E12086108000800003E8802883EF820883EF80000
+C0B8:000000080008040804080C0E12086108000800001F0801081F0810141F620000
+C0B9:000000080008040804080C0E12086108000800003EF802803EF820803EF80000
+C0BA:000000080008040804080C0E12086108000800003EFC02483E4820483EFC0000
+C0BB:000000080008040804080C0E12086108000800001F08017F1F1C10221F1C0000
+C0BC:000000080008040804080C0E120861080008000003F802080208020803F80000
+C0BD:000000080008040804080C0E12086108000800000208020803F8020803F80000
+C0BE:000000080008040804080C0E1208610800080000110811081F0811141F620000
+C0BF:000000080008040804080C0E1208610800080000001000100010006801840000
+C0C0:000000080008040804080C0E12086108000800000048004800A8011406620000
+C0C1:000000080008040804080C0E1208610800080000000003F00408040803F00000
+C0C2:000000080008040804080C0E120861080008000003F80020002000D003080000
+C0C3:000000080008040804080C0E1208610800080000004003F8004000A003180000
+C0C4:000000080008040804080C0E120861080008000003F8000803F8000800080000
+C0C5:000000080008040804080C0E120861080008000003F8020003F8020003F80000
+C0C6:000000080008040804080C0E120861080008000000000FF8022002200FF80000
+C0C7:000000080008040804080C0E120861080008000000800FF803E0041003E00000
+C0C8:0000000000120012021202120412041E0A121112609200120012001200120000
+C0C9:000000280028042804280C38122861280028000007F800080008000800080000
+C0CA:000000280028042804280C38122861280028000000003EF80208020802080000
+C0CB:000000280028042804280C38122861280028000000003E100210022802C40000
+C0CC:000000280028042804280C38122861280028002808000800080008000FF80000
+C0CD:000000280028042804280C381228612800280000000020F8201020303ECC0000
+C0CE:000000280028042804280C381228612800280000202021FC207020883E700000
+C0CF:000000280028042804280C38122861280028000003F802000200020003F80000
+C0D0:000000280028042804280C38122861280028000007F8000807F8040007F80000
+C0D1:000000280028042804280C3812286128002800003EF802083E0820083E080000
+C0D2:000000280028042804280C3812286128002800003EF802883E8820883EF80000
+C0D3:000000280028042804280C3812286128002800003E8802883EF820883EF80000
+C0D4:000000280028042804280C3812286128002800001F0801081F0810141F620000
+C0D5:000000280028042804280C3812286128002800003EF802803EF820803EF80000
+C0D6:000000280028042804280C3812286128002800003EFC02483E4820483EFC0000
+C0D7:000000280028042804280C3812286128002800003E1002FE3E3820443E380000
+C0D8:000000280028042804280C38122861280028000003F802080208020803F80000
+C0D9:000000280028042804280C3812286128002800000208020803F8020803F80000
+C0DA:000000280028042804280C381228612800280000110811081F0811141F620000
+C0DB:000000280028042804280C381228612800280000000800080008003400C20000
+C0DC:000000280028042804280C3812286128002800000048004800A8011406620000
+C0DD:000000280028042804280C381228612800280000000001F00208020801F00000
+C0DE:000000280028042804280C38122861280028000003F80020002000D003080000
+C0DF:000000280028042804280C381228612800280000004003F8004000A003180000
+C0E0:000000280028042804280C38122861280028000003F8000803F8000800080000
+C0E1:000000280028042804280C38122861280028000003F8020003F8020003F80000
+C0E2:000000280028042804280C38122861280028000000000FF8022002200FF80000
+C0E3:000000280028042804280C38122861280028000000800FF803E0041003E00000
+C0E4:000000000010001002100210041E04100A10111E609000100010001000100000
+C0E5:0000000800080408040E0C08120E61080008000007F800080008000800080000
+C0E6:0000000800080408040E0C08120E61080008000000003EF80208020802080000
+C0E7:0000000800080408040E0C08120E61080008000000001F080108011401620000
+C0E8:0000000800080408040E0C08120E61080008000008000800080008000FF80000
+C0E9:0000000800080408040E0C08120E610800080000000010F8101010301ECC0000
+C0EA:0000000800080408040E0C08120E6108000800000808087F081C08220F9C0000
+C0EB:0000000800080408040E0C08120E61080008000003F802000200020003F80000
+C0EC:0000000800080408040E0C08120E61080008000007F8000807F8040007F80000
+C0ED:0000000800080408040E0C08120E6108000800003EF802083E0820083E080000
+C0EE:0000000800080408040E0C08120E6108000800003EF802883E8820883EF80000
+C0EF:0000000800080408040E0C08120E6108000800003E8802883EF820883EF80000
+C0F0:0000000800080408040E0C08120E6108000800001F0801081F0810141F620000
+C0F1:0000000800080408040E0C08120E6108000800003EF802803EF820803EF80000
+C0F2:0000000800080408040E0C08120E6108000800003EFC02483E4820483EFC0000
+C0F3:0000000800080408040E0C08120E6108000800001F08017F1F1C10221F1C0000
+C0F4:0000000800080408040E0C08120E61080008000003F802080208020803F80000
+C0F5:0000000800080408040E0C08120E6108000800000208020803F8020803F80000
+C0F6:0000000800080408040E0C08120E610800080000110811081F0811141F620000
+C0F7:0000000800080408040E0C08120E610800080000001000100010006801840000
+C0F8:0000000800080408040E0C08120E6108000800000048004800A8011406620000
+C0F9:0000000800080408040E0C08120E610800080000000003F00408040803F00000
+C0FA:0000000800080408040E0C08120E61080008000003F80020002000D003080000
+C0FB:0000000800080408040E0C08120E610800080000004003F8004000A003180000
+C0FC:0000000800080408040E0C08120E61080008000003F8000803F8000800080000
+C0FD:0000000800080408040E0C08120E61080008000003F8020003F8020003F80000
+C0FE:0000000800080408040E0C08120E61080008000000000FF8022002200FF80000
+C0FF:0000000800080408040E0C08120E61080008000000800FF803E0041003E00000
+C100:000000000012001202120212041E04120A12111E609200120012001200120000
+C101:000000280028042804380C28123861280028000007F800080008000800080000
+C102:000000280028042804380C28123861280028000000003EF80208020802080000
+C103:000000280028042804380C28123861280028000000003E100210022802C40000
+C104:000000280028042804380C28123861280028002808000800080008000FF80000
+C105:000000280028042804380C281238612800280000000020F8201020303ECC0000
+C106:000000280028042804380C281238612800280000202021FC207020883E700000
+C107:000000280028042804380C28123861280028000003F802000200020003F80000
+C108:000000280028042804380C28123861280028000007F8000807F8040007F80000
+C109:000000280028042804380C2812386128002800003EF802083E0820083E080000
+C10A:000000280028042804380C2812386128002800003EF802883E8820883EF80000
+C10B:000000280028042804380C2812386128002800003E8802883EF820883EF80000
+C10C:000000280028042804380C2812386128002800001F0801081F0810141F620000
+C10D:000000280028042804380C2812386128002800003EF802803EF820803EF80000
+C10E:000000280028042804380C2812386128002800003EFC02483E4820483EFC0000
+C10F:000000280028042804380C2812386128002800003E1002FE3E3820443E380000
+C110:000000280028042804380C28123861280028000003F802080208020803F80000
+C111:000000280028042804380C2812386128002800000208020803F8020803F80000
+C112:000000280028042804380C281238612800280000110811081F0811141F620000
+C113:000000280028042804380C281238612800280000000800080008003400C20000
+C114:000000280028042804380C2812386128002800000048004800A8011406620000
+C115:000000280028042804380C281238612800280000000001F00208020801F00000
+C116:000000280028042804380C28123861280028000003F80020002000D003080000
+C117:000000280028042804380C281238612800280000004003F8004000A003180000
+C118:000000280028042804380C28123861280028000003F8000803F8000800080000
+C119:000000280028042804380C28123861280028000003F8020003F8020003F80000
+C11A:000000280028042804380C28123861280028000000000FF8022002200FF80000
+C11B:000000280028042804380C28123861280028000000800FF803E0041003E00000
+C11C:0000000000020002020202020402041E0A021102608200020002000200020000
+C11D:000000080008040804080C381208610800080000000007F80008000800080000
+C11E:000000080008040804080C38120861080008000000003EF80208020802080000
+C11F:000000080008040804080C38120861080008000000001F080108011401620000
+C120:000000080008040804080C38120861080008000000001000100010001FF80000
+C121:000000080008040804080C381208610800080000000020F8201020303ECC0000
+C122:000000080008040804080C381208610800080000202021FC207020883E700000
+C123:000000080008040804080C38120861080008000003F802000200020003F80000
+C124:000000080008040804080C38120861080008000007F8000807F8040007F80000
+C125:000000080008040804080C3812086108000800003EF802083E0820083E080000
+C126:000000080008040804080C3812086108000800003EF802883E8820883EF80000
+C127:000000080008040804080C3812086108000800003E8802883EF820883EF80000
+C128:000000080008040804080C3812086108000800000F8800880F8808140FA20000
+C129:000000080008040804080C3812086108000800003EF802803EF820803EF80000
+C12A:000000080008040804080C3812086108000800003EFC02483E4820483EFC0000
+C12B:000000080008040804080C3812086108000800003E1002FE3E3820443E380000
+C12C:000000080008040804080C38120861080008000003F802080208020803F80000
+C12D:000000080008040804080C3812086108000800000208020803F8020803F80000
+C12E:000000080008040804080C381208610800080000210821083F0821143F620000
+C12F:000000080008040804080C381208610800080000001000100010006801840000
+C130:000000080008040804080C3812086108000800000048004800A8011406620000
+C131:000000080008040804080C381208610800080000000003F00408040803F00000
+C132:000000080008040804080C38120861080008000003F80020002000D003080000
+C133:000000080008040804080C381208610800080000004003F8004000A003180000
+C134:000000080008040804080C38120861080008000003F8000803F8000800080000
+C135:000000080008040804080C38120861080008000003F8020003F8020003F80000
+C136:000000080008040804080C38120861080008000000000FF8022002200FF80000
+C137:000000080008040804080C38120861080008000000800FF803E0041003E00000
+C138:00000000000A000A020A020A040A043A0A0A110A608A000A000A000A000A0000
+C139:000000280028042804280CE8122861280028000007F800080008000800080000
+C13A:000000280028042804280CE8122861280028000000003EF80208020802080000
+C13B:000000280028042804280CE8122861280028000000003E100210022802C40000
+C13C:000000280028042804280CE8122861280028000008000800080008000FF80000
+C13D:000000280028042804280CE81228612800280000000020F8201020303ECC0000
+C13E:000000280028042804280CE81228612800280000202021FC207020883E700000
+C13F:000000280028042804280CE8122861280028000003F802000200020003F80000
+C140:000000280028042804280CE8122861280028000007F8000807F8040007F80000
+C141:000000280028042804280CE812286128002800003EF802083E0820083E080000
+C142:000000280028042804280CE812286128002800003EF802883E8820883EF80000
+C143:000000280028042804280CE812286128002800003E8802883EF820883EF80000
+C144:000000280028042804280CE812286128002800001F0801081F0810141F620000
+C145:000000280028042804280CE812286128002800003EF802803EF820803EF80000
+C146:000000280028042804280CE812286128002800003EFC02483E4820483EFC0000
+C147:000000280028042804280CE812286128002800003E1002FE3E3820443E380000
+C148:000000280028042804280CE8122861280028000003F802080208020803F80000
+C149:000000280028042804280CE812286128002800000208020803F8020803F80000
+C14A:000000280028042804280CE81228612800280000110811081F0811141F620000
+C14B:000000280028042804280CE81228612800280000000800080008003400C20000
+C14C:000000280028042804280CE812286128002800000048004800A8011406620000
+C14D:000000280028042804280CE81228612800280000000001F00208020801F00000
+C14E:000000280028042804280CE8122861280028000003F80020002000D003080000
+C14F:000000280028042804280CE81228612800280000004003F8004000A003180000
+C150:000000280028042804280CE8122861280028000003F8000803F8000800080000
+C151:000000280028042804280CE8122861280028000003F8020003F8020003F80000
+C152:000000280028042804280CE8122861280028000000000FF8022002200FF80000
+C153:000000280028042804280CE8122861280028000000800FF803E0041003E00000
+C154:000000000002000202020202041E04020A02111E608200020002000200020000
+C155:000000080008040804380C081238610800080000000007F80008000800080000
+C156:000000080008040804380C08123861080008000000003EF80208020802080000
+C157:000000080008040804380C08123861080008000000001F080108011401620000
+C158:000000080008040804380C08123861080008000800001000100010001FF80000
+C159:000000080008040804380C081238610800080000000020F8201020303ECC0000
+C15A:000000080008040804380C081238610800080000202021FC207020883E700000
+C15B:000000080008040804380C08123861080008000003F802000200020003F80000
+C15C:000000080008040804380C08123861080008000007F8000807F8040007F80000
+C15D:000000080008040804380C0812386108000800003EF802083E0820083E080000
+C15E:000000080008040804380C0812386108000800003EF802883E8820883EF80000
+C15F:000000080008040804380C0812386108000800003E8802883EF820883EF80000
+C160:000000080008040804380C0812386108000800000F8800880F8808140FA20000
+C161:000000080008040804380C0812386108000800003EF802803EF820803EF80000
+C162:000000080008040804380C0812386108000800003EFC02483E4820483EFC0000
+C163:000000080008040804380C0812386108000800003E1002FE3E3820443E380000
+C164:000000080008040804380C08123861080008000003F802080208020803F80000
+C165:000000080008040804380C0812386108000800000208020803F8020803F80000
+C166:000000080008040804380C081238610800080000210821083F0821143F620000
+C167:000000080008040804380C081238610800080000001000100010006801840000
+C168:000000080008040804380C0812386108000800000048004800A8011406620000
+C169:000000080008040804380C081238610800080000000003F00408040803F00000
+C16A:000000080008040804380C08123861080008000003F80020002000D003080000
+C16B:000000080008040804380C081238610800080000004003F8004000A003180000
+C16C:000000080008040804380C08123861080008000003F8000803F8000800080000
+C16D:000000080008040804380C08123861080008000003F8020003F8020003F80000
+C16E:000000080008040804380C08123861080008000000000FF8022002200FF80000
+C16F:000000080008040804380C08123861080008000000800FF803E0041003E00000
+C170:00000000000A000A020A020A043A040A0A0A113A608A000A000A000A000A0000
+C171:000000280028042804E80C2812E861280028000007F800080008000800080000
+C172:000000280028042804E80C2812E861280028000000003EF80208020802080000
+C173:000000280028042804E80C2812E861280028000000003E100210022802C40000
+C174:000000280028042804E80C2812E861280028002808000800080008000FF80000
+C175:000000280028042804E80C2812E8612800280000000020F8201020303ECC0000
+C176:000000280028042804E80C2812E8612800280000202021FC207020883E700000
+C177:000000280028042804E80C2812E861280028000003F802000200020003F80000
+C178:000000280028042804E80C2812E861280028000007F8000807F8040007F80000
+C179:000000280028042804E80C2812E86128002800003EF802083E0820083E080000
+C17A:000000280028042804E80C2812E86128002800003EF802883E8820883EF80000
+C17B:000000280028042804E80C2812E86128002800003E8802883EF820883EF80000
+C17C:000000280028042804E80C2812E86128002800001F0801081F0810141F620000
+C17D:000000280028042804E80C2812E86128002800003EF802803EF820803EF80000
+C17E:000000280028042804E80C2812E86128002800003EFC02483E4820483EFC0000
+C17F:000000280028042804E80C2812E86128002800003E1002FE3E3820443E380000
+C180:000000280028042804E80C2812E861280028000003F802080208020803F80000
+C181:000000280028042804E80C2812E86128002800000208020803F8020803F80000
+C182:000000280028042804E80C2812E8612800280000110811081F0811141F620000
+C183:000000280028042804E80C2812E8612800280000000800080008003400C20000
+C184:000000280028042804E80C2812E86128002800000048004800A8011406620000
+C185:000000280028042804E80C2812E8612800280000000001F00208020801F00000
+C186:000000280028042804E80C2812E861280028000003F80020002000D003080000
+C187:000000280028042804E80C2812E8612800280000004003F8004000A003180000
+C188:000000280028042804E80C2812E861280028000003F8000803F8000800080000
+C189:000000280028042804E80C2812E861280028000003F8020003F8020003F80000
+C18A:000000280028042804E80C2812E861280028000000000FF8022002200FF80000
+C18B:000000280028042804E80C2812E861280028000000800FF803E0041003E00000
+C18C:00000000008000800100010002800440182000000100010001007FFC00000000
+C18D:000000800080018002400C20010001007FFC00001FF000100010001000100000
+C18E:000000800080018002400C20010001007FFC000000003EF80208020802080000
+C18F:000000800080018002400C20010001007FFC000000001E100210022802C40000
+C190:000000800080018002400C20010001007FFC000000001000100010001FF00000
+C191:000000800080018002400C20010001007FFC0000000020F8201020303ECC0000
+C192:000000800080018002400C20010001007FFC0000202021FC207020883E700000
+C193:000000800080018002400C20010001007FFC00001FF01000100010001FF00000
+C194:000000800080018002400C20010001007FFC00001FF000101FF010001FF00000
+C195:000000800080018002400C20010001007FFC00003EF802083E0820083E080000
+C196:000000800080018002400C20010001007FFC00003EF802883E8820883EF80000
+C197:000000800080018002400C20010001007FFC00003E8802883EF820883EF80000
+C198:000000800080018002400C20010001007FFC00003E1002103E1020283EC40000
+C199:000000800080018002400C20010001007FFC00003EF802803EF820803EF80000
+C19A:000000800080018002400C20010001007FFC00003EFC02483E4820483EFC0000
+C19B:000000800080018002400C20010001007FFC00003E2003FC3E7020883E700000
+C19C:000000800080018002400C20010001007FFC00001FF01010101010101FF00000
+C19D:000000800080018002400C20010001007FFC0000101010101FF010101FF00000
+C19E:000000800080018002400C20010001007FFC0000222022203E2022503E880000
+C19F:000000800080018002400C20010001007FFC000000000100010002800C400000
+C1A0:000000800080018002400C20010001007FFC00000000024002400DA033100000
+C1A1:000000800080018002400C20010001007FFC0000000007C00820082007C00000
+C1A2:000000800080018002400C20010001007FFC0000000007E00080014006200000
+C1A3:000000800080018002400C20010001007FFC0000008007E00080014006200000
+C1A4:000000800080018002400C20010001007FFC00001FF000101FF0001000100000
+C1A5:000000800080018002400C20010001007FFC00001FF010001FF010001FF00000
+C1A6:000000800080018002400C20010001007FFC000000001FF0044004401FF00000
+C1A7:000000800080018002400C20010001007FFC000001001FF007C0082007C00000
+C1A8:00000010001002100210041004100A1E11106090041004107FD0001000100000
+C1A9:0000020802080608090E3088040804087FE8000007F800080008000800080000
+C1AA:0000020802080608090E3088040804087FE8000000003EF80208020802080000
+C1AB:0000020802080608090E3088040804087FE8000000001F080108011401620000
+C1AC:0000020802080608090E3088040804087FE8000008000800080008000FF80000
+C1AD:0000020802080608090E3088040804087FE80000000010F8101010301ECC0000
+C1AE:0000020802080608090E3088040804087FE800000808087F081C08220F9C0000
+C1AF:0000020802080608090E3088040804087FE8000003F802000200020003F80000
+C1B0:0000020802080608090E3088040804087FE8000007F8000807F8040007F80000
+C1B1:0000020802080608090E3088040804087FE800003EF802083E0820083E080000
+C1B2:0000020802080608090E3088040804087FE800003EF802883E8820883EF80000
+C1B3:0000020802080608090E3088040804087FE800003E8802883EF820883EF80000
+C1B4:0000020802080608090E3088040804087FE800001F0801081F0810141F620000
+C1B5:0000020802080608090E3088040804087FE800003EF802803EF820803EF80000
+C1B6:0000020802080608090E3088040804087FE800003EFC02483E4820483EFC0000
+C1B7:0000020802080608090E3088040804087FE800001F08017F1F1C10221F1C0000
+C1B8:0000020802080608090E3088040804087FE8000003F802080208020803F80000
+C1B9:0000020802080608090E3088040804087FE800000208020803F8020803F80000
+C1BA:0000020802080608090E3088040804087FE80000110811081F0811141F620000
+C1BB:0000020802080608090E3088040804087FE80000001000100010006801840000
+C1BC:0000020802080608090E3088040804087FE800000048004800A8011406620000
+C1BD:0000020802080608090E3088040804087FE80000000003F00408040803F00000
+C1BE:0000020802080608090E3088040804087FE8000003F80020002000D003080000
+C1BF:0000020802080608090E3088040804087FE80000004003F8004000A003180000
+C1C0:0000020802080608090E3088040804087FE8000003F8000803F8000800080000
+C1C1:0000020802080608090E3088040804087FE8000003F8020003F8020003F80000
+C1C2:0000020802080608090E3088040804087FE8000000000FF8022002200FF80000
+C1C3:0000020802080608090E3088040804087FE8000000800FF803E0041003E00000
+C1C4:00000012001202120212041204120A1E11126092041204127FD2001200120000
+C1C5:0000022802280628093830A8042804287FA8000007F800080008000800080000
+C1C6:0000022802280628093830A8042804287FA8000000003EF80208020802080000
+C1C7:0000022802280628093830A8042804287FA8000000001F080108011401620000
+C1C8:0000022802280628093830A8042804287FA8000008000800080008000FF80000
+C1C9:0000022802280628093830A8042804287FA80000000010F8101010301ECC0000
+C1CA:0000022802280628093830A8042804287FA800000808087F081C08220F9C0000
+C1CB:0000022802280628093830A8042804287FA8000003F802000200020003F80000
+C1CC:0000022802280628093830A8042804287FA8000007F8000807F8040007F80000
+C1CD:0000022802280628093830A8042804287FA800003EF802083E0820083E080000
+C1CE:0000022802280628093830A8042804287FA800003EF802883E8820883EF80000
+C1CF:0000022802280628093830A8042804287FA800003E8802883EF820883EF80000
+C1D0:0000022802280628093830A8042804287FA800001F0801081F0810141F620000
+C1D1:0000022802280628093830A8042804287FA800003EF802803EF820803EF80000
+C1D2:0000022802280628093830A8042804287FA800003EFC02483E4820483EFC0000
+C1D3:0000022802280628093830A8042804287FA800001F08017F1F1C10221F1C0000
+C1D4:0000022802280628093830A8042804287FA8000003F802080208020803F80000
+C1D5:0000022802280628093830A8042804287FA800000208020803F8020803F80000
+C1D6:0000022802280628093830A8042804287FA80000110811081F0811141F620000
+C1D7:0000022802280628093830A8042804287FA80000001000100010006801840000
+C1D8:0000022802280628093830A8042804287FA800000048004800A8011406620000
+C1D9:0000022802280628093830A8042804287FA80000000003F00408040803F00000
+C1DA:0000022802280628093830A8042804287FA8000003F80020002000D003080000
+C1DB:0000022802280628093830A8042804287FA80000004003F8004000A003180000
+C1DC:0000022802280628093830A8042804287FA8000003F8000803F8000800080000
+C1DD:0000022802280628093830A8042804287FA8000003F8020003F8020003F80000
+C1DE:0000022802280628093830A8042804287FA8000000000FF8022002200FF80000
+C1DF:0000022802280628093830A8042804287FA8000000800FF803E0041003E00000
+C1E0:00000008000802080208040804080A0811086088040804087FE8000800080000
+C1E1:000002080208060809083088040804087FE8000007F800080008000800080000
+C1E2:000002080208060809083088040804087FE8000000003EF80208020802080000
+C1E3:000002080208060809083088040804087FE8000000001F080108011401620000
+C1E4:000002080208060809083088040804087FE8000008000800080008000FF80000
+C1E5:000002080208060809083088040804087FE80000000010F8101010301ECC0000
+C1E6:000002080208060809083088040804087FE800000808087F081C08220F9C0000
+C1E7:000002080208060809083088040804087FE8000003F802000200020003F80000
+C1E8:000002080208060809083088040804087FE8000007F8000807F8040007F80000
+C1E9:000002080208060809083088040804087FE800003EF802083E0820083E080000
+C1EA:000002080208060809083088040804087FE800003EF802883E8820883EF80000
+C1EB:000002080208060809083088040804087FE800003E8802883EF820883EF80000
+C1EC:000002080208060809083088040804087FE800001F0801081F0810141F620000
+C1ED:000002080208060809083088040804087FE800003EF802803EF820803EF80000
+C1EE:000002080208060809083088040804087FE800003EFC02483E4820483EFC0000
+C1EF:000002080208060809083088040804087FE800001F08017F1F1C10221F1C0000
+C1F0:000002080208060809083088040804087FE8000003F802080208020803F80000
+C1F1:000002080208060809083088040804087FE800000208020803F8020803F80000
+C1F2:000002080208060809083088040804087FE80000110811081F0811141F620000
+C1F3:000002080208060809083088040804087FE80000001000100010006801840000
+C1F4:000002080208060809083088040804087FE800000048004800A8011406620000
+C1F5:000002080208060809083088040804087FE80000000003F00408040803F00000
+C1F6:000002080208060809083088040804087FE8000003F80020002000D003080000
+C1F7:000002080208060809083088040804087FE80000004003F8004000A003180000
+C1F8:000002080208060809083088040804087FE8000003F8000803F8000800080000
+C1F9:000002080208060809083088040804087FE8000003F8020003F8020003F80000
+C1FA:000002080208060809083088040804087FE8000000000FF8022002200FF80000
+C1FB:000002080208060809083088040804087FE8000000800FF803E0041003E00000
+C1FC:00000000008000800100010002800440182004400440044004407FFC00000000
+C1FD:000000800080018002400C20044004407FFC00001FF000100010001000100000
+C1FE:000000800080018002400C20044004407FFC000000003EF80208020802080000
+C1FF:000000800080018002400C20044004407FFC000000001E100210022802C40000
+C200:000000800080018002400C20044004407FFC000000001000100010001FF00000
+C201:000000800080018002400C20044004407FFC0000000020F8201020303ECC0000
+C202:000000800080018002400C20044004407FFC0000202021FC207020883E700000
+C203:000000800080018002400C20044004407FFC00001FF01000100010001FF00000
+C204:000000800080018002400C20044004407FFC00001FF000101FF010001FF00000
+C205:000000800080018002400C20044004407FFC00003EF802083E0820083E080000
+C206:000000800080018002400C20044004407FFC00003EF802883E8820883EF80000
+C207:000000800080018002400C20044004407FFC00003E8802883EF820883EF80000
+C208:000000800080018002400C20044004407FFC00003E1002103E1020283EC40000
+C209:000000800080018002400C20044004407FFC00003EF802803EF820803EF80000
+C20A:000000800080018002400C20044004407FFC00003EFC02483E4820483EFC0000
+C20B:000000800080018002400C20044004407FFC00003E2003FC3E7020883E700000
+C20C:000000800080018002400C20044004407FFC00001FF01010101010101FF00000
+C20D:000000800080018002400C20044004407FFC0000101010101FF010101FF00000
+C20E:000000800080018002400C20044004407FFC0000222022203E2022503E880000
+C20F:000000800080018002400C20044004407FFC000000000100010002800C400000
+C210:000000800080018002400C20044004407FFC00000000024002400DA033100000
+C211:000000800080018002400C20044004407FFC0000000007C00820082007C00000
+C212:000000800080018002400C20044004407FFC0000000007E00080014006200000
+C213:000000800080018002400C20044004407FFC0000008007E00080014006200000
+C214:000000800080018002400C20044004407FFC00001FF000101FF0001000100000
+C215:000000800080018002400C20044004407FFC00001FF010001FF010001FF00000
+C216:000000800080018002400C20044004407FFC000000001FF0044004401FF00000
+C217:000000800080018002400C20044004407FFC000001001FF007C0082007C00000
+C218:00000000008000800100010002800440182000003FF801000100010001000000
+C219:000000800080018002400C2000007FFC010001001FF000100010001000100000
+C21A:000000800080018002400C2000007FFC0100010000003EF80208020802080000
+C21B:000000800080018002400C2000007FFC0100010000001E100210022802C40000
+C21C:000000800080018002400C20000000007FFC010001001100100010001FF00000
+C21D:000000800080018002400C2000007FFC01000100000020F8201020303ECC0000
+C21E:000000800080018002400C2000007FFC01000100202021FC207020883E700000
+C21F:000000800080018002400C2000007FFC010001001FF01000100010001FF00000
+C220:000000800080018002400C2000007FFC010001001FF000101FF010001FF00000
+C221:000000800080018002400C2000007FFC010001003EF802083E0820083E080000
+C222:000000800080018002400C2000007FFC010001003EF802883E8820883EF80000
+C223:000000800080018002400C2000007FFC010001003E8802883EF820883EF80000
+C224:000000800080018002400C2000007FFC010001003E1002103E1020283EC40000
+C225:000000800080018002400C2000007FFC010001003EF802803EF820803EF80000
+C226:000000800080018002400C2000007FFC010001003EFC02483E4820483EFC0000
+C227:000000800080018002400C2000007FFC010001003E2003FC3E7020883E700000
+C228:000000800080018002400C2000007FFC010001001FF01010101010101FF00000
+C229:000000800080018002400C2000007FFC01000100101010101FF010101FF00000
+C22A:000000800080018002400C2000007FFC01000100222022203E2022503E880000
+C22B:000000800080018002400C2000007FFC0100010000000100010002800C400000
+C22C:000000800080018002400C2000007FFC010001000000024002400DA033100000
+C22D:000000800080018002400C2000007FFC01000100000007C00820082007C00000
+C22E:000000800080018002400C2000007FFC01000100000007E00080014006200000
+C22F:000000800080018002400C2000007FFC01000100008007E00080014006200000
+C230:000000800080018002400C2000007FFC010001001FF000101FF0001000100000
+C231:000000800080018002400C2000007FFC010001001FF010001FF010001FF00000
+C232:000000800080018002400C2000007FFC0100010000001FF0044004401FF00000
+C233:000000800080018002400C2000007FFC0100010001001FF007C0082007C00000
+C234:0000000802080208040804080A081108608800087FE8040804F8040804080000
+C235:0208020806080908308800087FE8027802080000000007F80008000800080000
+C236:0208020806080908308800087FE802780208000000003EF80208020802080000
+C237:0208020806080908308800087FE802780208000000001F080108011401620000
+C238:02080208060809083088000800087FE80278020802081000100010001FF80000
+C239:0208020806080908308800087FE8027802080000000020F8201020303ECC0000
+C23A:0208020806080908308800087FE8027802080000202021FC207020883E700000
+C23B:0208020806080908308800087FE802780208000003F802000200020003F80000
+C23C:0208020806080908308800087FE802780208000007F8000807F8040007F80000
+C23D:0208020806080908308800087FE80278020800003EF802083E0820083E080000
+C23E:0208020806080908308800087FE80278020800003EF802883E8820883EF80000
+C23F:0208020806080908308800087FE80278020800003E8802883EF820883EF80000
+C240:0208020806080908308800087FE80278020800000F8800880F8808140FA20000
+C241:0208020806080908308800087FE80278020800003EF802803EF820803EF80000
+C242:0208020806080908308800087FE80278020800003EFC02483E4820483EFC0000
+C243:0208020806080908308800087FE80278020800003E1002FE3E3820443E380000
+C244:0208020806080908308800087FE802780208000003F802080208020803F80000
+C245:0208020806080908308800087FE80278020800000208020803F8020803F80000
+C246:0208020806080908308800087FE8027802080000210821083F0821143F620000
+C247:0208020806080908308800087FE8027802080000001000100010006801840000
+C248:0208020806080908308800087FE80278020800000048004800A8011406620000
+C249:0208020806080908308800087FE8027802080000000003F00408040803F00000
+C24A:0208020806080908308800087FE802780208000003F80020002000D003080000
+C24B:0208020806080908308800087FE8027802080000004003F8004000A003180000
+C24C:0208020806080908308800087FE802780208000003F8000803F8000800080000
+C24D:0208020806080908308800087FE802780208000003F8020003F8020003F80000
+C24E:0208020806080908308800087FE802780208000000000FF8022002200FF80000
+C24F:0208020806080908308800087FE802780208000000800FF803E0041003E00000
+C250:0000000A020A020A040A040A0A0A110A608A000A7FEA040A047A040A040A0000
+C251:022802280628092830A800287FA805E804280000000007F80008000800080000
+C252:022802280628092830A800287FA805E80428000000003EF80208020802080000
+C253:022802280628092830A800287FA805E80428000000001F080108011401620000
+C254:022802280628092830A8002800287FA8042805E804281428100010001FF80000
+C255:022802280628092830A800287FA805E804280000000020F8201020303ECC0000
+C256:022802280628092830A800287FA805E804280000202021FC207020883E700000
+C257:022802280628092830A800287FA805E80428000003F802000200020003F80000
+C258:022802280628092830A800287FA805E80428000007F8000807F8040007F80000
+C259:022802280628092830A800287FA805E8042800003EF802083E0820083E080000
+C25A:022802280628092830A800287FA805E8042800003EF802883E8820883EF80000
+C25B:022802280628092830A800287FA805E8042800003E8802883EF820883EF80000
+C25C:022802280628092830A800287FA805E8042800000F8800880F8808140FA20000
+C25D:022802280628092830A800287FA805E8042800003EF802803EF820803EF80000
+C25E:022802280628092830A800287FA805E8042800003EFC02483E4820483EFC0000
+C25F:022802280628092830A800287FA805E8042800003E1002FE3E3820443E380000
+C260:022802280628092830A800287FA805E80428000003F802080208020803F80000
+C261:022802280628092830A800287FA805E8042800000208020803F8020803F80000
+C262:022802280628092830A800287FA805E804280000210821083F0821143F620000
+C263:022802280628092830A800287FA805E804280000001000100010006801840000
+C264:022802280628092830A800287FA805E8042800000048004800A8011406620000
+C265:022802280628092830A800287FA805E804280000000003F00408040803F00000
+C266:022802280628092830A800287FA805E80428000003F80020002000D003080000
+C267:022802280628092830A800287FA805E804280000004003F8004000A003180000
+C268:022802280628092830A800287FA805E80428000003F8000803F8000800080000
+C269:022802280628092830A800287FA805E80428000003F8020003F8020003F80000
+C26A:022802280628092830A800287FA805E80428000000000FF8022002200FF80000
+C26B:022802280628092830A800287FA805E80428000000800FF803E0041003E00000
+C26C:0000000802080208040804080A081108608800087FE804080408040804080000
+C26D:0208020806080908308800087FE8020802000000000007F80008000800080000
+C26E:0208020806080908308800087FE802080200000000003EF80208020802080000
+C26F:0208020806080908308800087FE802080200000000001F080108011401620000
+C270:02080208060809083088000800087FE80208020802081008100010001FF80000
+C271:0208020806080908308800087FE8020802000000000020F8201020303ECC0000
+C272:0208020806080908308800087FE8020802000000202021FC207020883E700000
+C273:0208020806080908308800087FE802080200000003F802000200020003F80000
+C274:0208020806080908308800087FE802080200000007F8000807F8040007F80000
+C275:0208020806080908308800087FE80208020000003EF802083E0820083E080000
+C276:0208020806080908308800087FE80208020000003EF802883E8820883EF80000
+C277:0208020806080908308800087FE80208020000003E8802883EF820883EF80000
+C278:0208020806080908308800087FE80208020000000F8800880F8808140FA20000
+C279:0208020806080908308800087FE80208020000003EF802803EF820803EF80000
+C27A:0208020806080908308800087FE80208020000003EFC02483E4820483EFC0000
+C27B:0208020806080908308800087FE80208020000003E1002FE3E3820443E380000
+C27C:0208020806080908308800087FE802080200000003F802080208020803F80000
+C27D:0208020806080908308800087FE80208020000000208020803F8020803F80000
+C27E:0208020806080908308800087FE8020802000000210821083F0821143F620000
+C27F:0208020806080908308800087FE8020802000000001000100010006801840000
+C280:0208020806080908308800087FE80208020000000048004800A8011406620000
+C281:0208020806080908308800087FE8020802000000000003F00408040803F00000
+C282:0208020806080908308800087FE802080200000003F80020002000D003080000
+C283:0208020806080908308800087FE8020802000000004003F8004000A003180000
+C284:0208020806080908308800087FE802080200000003F8000803F8000800080000
+C285:0208020806080908308800087FE802080200000003F8020003F8020003F80000
+C286:0208020806080908308800087FE802080200000000000FF8022002200FF80000
+C287:0208020806080908308800087FE802080200000000800FF803E0041003E00000
+C288:00000000008000800100010002800440182000007FFC04400440044004400000
+C289:000000800080018002400C2000007FFC044004401FF000100010001000100000
+C28A:000000800080018002400C2000007FFC0440044000003EF80208020802080000
+C28B:000000800080018002400C2000007FFC0440044000001E100210022802C40000
+C28C:000000800080018002400C20000000007FFC044004401440100010001FF00000
+C28D:000000800080018002400C2000007FFC04400440000020F8201020303ECC0000
+C28E:000000800080018002400C2000007FFC04400440202021FC207020883E700000
+C28F:000000800080018002400C2000007FFC044004401FF01000100010001FF00000
+C290:000000800080018002400C2000007FFC044004401FF000101FF010001FF00000
+C291:000000800080018002400C2000007FFC044004403EF802083E0820083E080000
+C292:000000800080018002400C2000007FFC044004403EF802883E8820883EF80000
+C293:000000800080018002400C2000007FFC044004403E8802883EF820883EF80000
+C294:000000800080018002400C2000007FFC044004403E1002103E1020283EC40000
+C295:000000800080018002400C2000007FFC044004403EF802803EF820803EF80000
+C296:000000800080018002400C2000007FFC044004403EFC02483E4820483EFC0000
+C297:000000800080018002400C2000007FFC044004403E2003FC3E7020883E700000
+C298:000000800080018002400C2000007FFC044004401FF01010101010101FF00000
+C299:000000800080018002400C2000007FFC04400440101010101FF010101FF00000
+C29A:000000800080018002400C2000007FFC04400440222022203E2022503E880000
+C29B:000000800080018002400C2000007FFC0440044000000100010002800C400000
+C29C:000000800080018002400C2000007FFC044004400000024002400DA033100000
+C29D:000000800080018002400C2000007FFC04400440000007C00820082007C00000
+C29E:000000800080018002400C2000007FFC04400440000007E00080014006200000
+C29F:000000800080018002400C2000007FFC04400440008007E00080014006200000
+C2A0:000000800080018002400C2000007FFC044004401FF000101FF0001000100000
+C2A1:000000800080018002400C2000007FFC044004401FF010001FF010001FF00000
+C2A2:000000800080018002400C2000007FFC0440044000001FF0044004401FF00000
+C2A3:000000800080018002400C2000007FFC0440044001001FF007C0082007C00000
+C2A4:000000000080008001000100028004401820000000007FFC0000000000000000
+C2A5:000000800080018002400C20000000007FFC00001FF000100010001000100000
+C2A6:000000800080018002400C20000000007FFC000000003EF80208020802080000
+C2A7:000000800080018002400C20000000007FFC000000001E100210022802C40000
+C2A8:000000800080018002400C20000000007FFC000000001000100010001FF00000
+C2A9:000000800080018002400C20000000007FFC0000000020F8201020303ECC0000
+C2AA:000000800080018002400C20000000007FFC0000202021FC207020883E700000
+C2AB:000000800080018002400C20000000007FFC00001FF01000100010001FF00000
+C2AC:000000800080018002400C20000000007FFC00001FF000101FF010001FF00000
+C2AD:000000800080018002400C20000000007FFC00003EF802083E0820083E080000
+C2AE:000000800080018002400C20000000007FFC00003EF802883E8820883EF80000
+C2AF:000000800080018002400C20000000007FFC00003E8802883EF820883EF80000
+C2B0:000000800080018002400C20000000007FFC00003E1002103E1020283EC40000
+C2B1:000000800080018002400C20000000007FFC00003EF802803EF820803EF80000
+C2B2:000000800080018002400C20000000007FFC00003EFC02483E4820483EFC0000
+C2B3:000000800080018002400C20000000007FFC00003E2003FC3E7020883E700000
+C2B4:000000800080018002400C20000000007FFC00001FF01010101010101FF00000
+C2B5:000000800080018002400C20000000007FFC0000101010101FF010101FF00000
+C2B6:000000800080018002400C20000000007FFC0000222022203E2022503E880000
+C2B7:000000800080018002400C20000000007FFC000000000100010002800C400000
+C2B8:000000800080018002400C20000000007FFC00000000024002400DA033100000
+C2B9:000000800080018002400C20000000007FFC0000000007C00820082007C00000
+C2BA:000000800080018002400C20000000007FFC0000000007E00080014006200000
+C2BB:000000800080018002400C20000000007FFC0000008007E00080014006200000
+C2BC:000000800080018002400C20000000007FFC00001FF000101FF0001000100000
+C2BD:000000800080018002400C20000000007FFC00001FF010001FF010001FF00000
+C2BE:000000800080018002400C20000000007FFC000000001FF0044004401FF00000
+C2BF:000000800080018002400C20000000007FFC000001001FF007C0082007C00000
+C2C0:00000008000802080208040804080A081108608800087FE80008000800080000
+C2C1:000002080208060809083088000800087FE8000007F800080008000800080000
+C2C2:000002080208060809083088000800087FE8000000003EF80208020802080000
+C2C3:000002080208060809083088000800087FE8000000001F080108011401620000
+C2C4:000002080208060809083088000800087FE8000008000800080008000FF80000
+C2C5:000002080208060809083088000800087FE80000000010F8101010301ECC0000
+C2C6:000002080208060809083088000800087FE800000808087F081C08220F9C0000
+C2C7:000002080208060809083088000800087FE8000003F802000200020003F80000
+C2C8:000002080208060809083088000800087FE8000007F8000807F8040007F80000
+C2C9:000002080208060809083088000800087FE800003EF802083E0820083E080000
+C2CA:000002080208060809083088000800087FE800003EF802883E8820883EF80000
+C2CB:000002080208060809083088000800087FE800003E8802883EF820883EF80000
+C2CC:000002080208060809083088000800087FE800001F0801081F0810141F620000
+C2CD:000002080208060809083088000800087FE800003EF802803EF820803EF80000
+C2CE:000002080208060809083088000800087FE800003EFC02483E4820483EFC0000
+C2CF:000002080208060809083088000800087FE800001F08017F1F1C10221F1C0000
+C2D0:000002080208060809083088000800087FE8000003F802080208020803F80000
+C2D1:000002080208060809083088000800087FE800000208020803F8020803F80000
+C2D2:000002080208060809083088000800087FE80000110811081F0811141F620000
+C2D3:000002080208060809083088000800087FE80000001000100010006801840000
+C2D4:000002080208060809083088000800087FE800000048004800A8011406620000
+C2D5:000002080208060809083088000800087FE80000000003F00408040803F00000
+C2D6:000002080208060809083088000800087FE8000003F80020002000D003080000
+C2D7:000002080208060809083088000800087FE80000004003F8004000A003180000
+C2D8:000002080208060809083088000800087FE8000003F8000803F8000800080000
+C2D9:000002080208060809083088000800087FE8000003F8020003F8020003F80000
+C2DA:000002080208060809083088000800087FE8000000000FF8022002200FF80000
+C2DB:000002080208060809083088000800087FE8000000800FF803E0041003E00000
+C2DC:000000000008000802080208040804080A081108608800080008000800080000
+C2DD:000000080008040804080C081208610800080000000007F80008000800080000
+C2DE:000000080008040804080C08120861080008000000003EF80208020802080000
+C2DF:000000080008040804080C08120861080008000000001F080108011401620000
+C2E0:000000080008040804080C08120861080008000800001000100010001FF80000
+C2E1:000000080008040804080C081208610800080000000020F8201020303ECC0000
+C2E2:000000080008040804080C081208610800080000202021FC207020883E700000
+C2E3:000000080008040804080C08120861080008000003F802000200020003F80000
+C2E4:000000080008040804080C08120861080008000007F8000807F8040007F80000
+C2E5:000000080008040804080C0812086108000800003EF802083E0820083E080000
+C2E6:000000080008040804080C0812086108000800003EF802883E8820883EF80000
+C2E7:000000080008040804080C0812086108000800003E8802883EF820883EF80000
+C2E8:000000080008040804080C0812086108000800000F8800880F8808140FA20000
+C2E9:000000080008040804080C0812086108000800003EF802803EF820803EF80000
+C2EA:000000080008040804080C0812086108000800003EFC02483E4820483EFC0000
+C2EB:000000080008040804080C0812086108000800003E1002FE3E3820443E380000
+C2EC:000000080008040804080C08120861080008000003F802080208020803F80000
+C2ED:000000080008040804080C0812086108000800000208020803F8020803F80000
+C2EE:000000080008040804080C081208610800080000210821083F0821143F620000
+C2EF:000000080008040804080C081208610800080000001000100010006801840000
+C2F0:000000080008040804080C0812086108000800000048004800A8011406620000
+C2F1:000000080008040804080C081208610800080000000003F00408040803F00000
+C2F2:000000080008040804080C08120861080008000003F80020002000D003080000
+C2F3:000000080008040804080C081208610800080000004003F8004000A003180000
+C2F4:000000080008040804080C08120861080008000003F8000803F8000800080000
+C2F5:000000080008040804080C08120861080008000003F8020003F8020003F80000
+C2F6:000000080008040804080C08120861080008000000000FF8022002200FF80000
+C2F7:000000080008040804080C08120861080008000000800FF803E0041003E00000
+C2F8:0000000000100010089008900890191E15102290CC5000100010001000100000
+C2F9:00000008000812081208340E2A0849080008000007F800080008000800080000
+C2FA:00000008000812081208340E2A0849080008000000003EF80208020802080000
+C2FB:00000008000812081208340E2A0849080008000000001F080108011401620000
+C2FC:00000008000812081208340E2A0849080008000808000800080008000FF80000
+C2FD:00000008000812081208340E2A08490800080000000010F8101010301ECC0000
+C2FE:00000008000812081208340E2A084908000800000808087F081C08220F9C0000
+C2FF:00000008000812081208340E2A0849080008000003F802000200020003F80000
+C300:00000008000812081208340E2A0849080008000007F8000807F8040007F80000
+C301:00000008000812081208340E2A084908000800003EF802083E0820083E080000
+C302:00000008000812081208340E2A084908000800003EF802883E8820883EF80000
+C303:00000008000812081208340E2A084908000800003E8802883EF820883EF80000
+C304:00000008000812081208340E2A084908000800001F0801081F0810141F620000
+C305:00000008000812081208340E2A084908000800003EF802803EF820803EF80000
+C306:00000008000812081208340E2A084908000800003EFC02483E4820483EFC0000
+C307:00000008000812081208340E2A084908000800001F08017F1F1C10221F1C0000
+C308:00000008000812081208340E2A0849080008000003F802080208020803F80000
+C309:00000008000812081208340E2A084908000800000208020803F8020803F80000
+C30A:00000008000812081208340E2A08490800080000110811081F0811141F620000
+C30B:00000008000812081208340E2A08490800080000001000100010006801840000
+C30C:00000008000812081208340E2A084908000800000048004800A8011406620000
+C30D:00000008000812081208340E2A08490800080000000003F00408040803F00000
+C30E:00000008000812081208340E2A0849080008000003F80020002000D003080000
+C30F:00000008000812081208340E2A08490800080000004003F8004000A003180000
+C310:00000008000812081208340E2A0849080008000003F8000803F8000800080000
+C311:00000008000812081208340E2A0849080008000003F8020003F8020003F80000
+C312:00000008000812081208340E2A0849080008000000000FF8022002200FF80000
+C313:00000008000812081208340E2A0849080008000000800FF803E0041003E00000
+C314:0000000000120012089208920892191E15122292CC5200120012001200120000
+C315:0000002800281228122834382A2849280028000007F800080008000800080000
+C316:0000002800281228122834382A2849280028000000003EF80208020802080000
+C317:0000002800281228122834382A2849280028000000003E100210022802C40000
+C318:0000002800281228122834382A2849280028002808000800080008000FF80000
+C319:0000002800281228122834382A28492800280000000020F8201020303ECC0000
+C31A:0000002800281228122834382A28492800280000202021FC207020883E700000
+C31B:0000002800281228122834382A2849280028000003F802000200020003F80000
+C31C:0000002800281228122834382A2849280028000007F8000807F8040007F80000
+C31D:0000002800281228122834382A284928002800003EF802083E0820083E080000
+C31E:0000002800281228122834382A284928002800003EF802883E8820883EF80000
+C31F:0000002800281228122834382A284928002800003E8802883EF820883EF80000
+C320:0000002800281228122834382A284928002800001F0801081F0810141F620000
+C321:0000002800281228122834382A284928002800003EF802803EF820803EF80000
+C322:0000002800281228122834382A284928002800003EFC02483E4820483EFC0000
+C323:0000002800281228122834382A284928002800003E1002FE3E3820443E380000
+C324:0000002800281228122834382A2849280028000003F802080208020803F80000
+C325:0000002800281228122834382A284928002800000208020803F8020803F80000
+C326:0000002800281228122834382A28492800280000110811081F0811141F620000
+C327:0000002800281228122834382A28492800280000000800080008003400C20000
+C328:0000002800281228122834382A284928002800000048004800A8011406620000
+C329:0000002800281228122834382A28492800280000000001F00208020801F00000
+C32A:0000002800281228122834382A2849280028000003F80020002000D003080000
+C32B:0000002800281228122834382A28492800280000004003F8004000A003180000
+C32C:0000002800281228122834382A2849280028000003F8000803F8000800080000
+C32D:0000002800281228122834382A2849280028000003F8020003F8020003F80000
+C32E:0000002800281228122834382A2849280028000000000FF8022002200FF80000
+C32F:0000002800281228122834382A2849280028000000800FF803E0041003E00000
+C330:000000000010001008900890089E19101510229ECC5000100010001000100000
+C331:0000000800081208120E34082A0E49080008000007F800080008000800080000
+C332:0000000800081208120E34082A0E49080008000000003EF80208020802080000
+C333:0000000800081208120E34082A0E49080008000000001F080108011401620000
+C334:0000000800081208120E34082A0E49080008000008000800080008000FF80000
+C335:0000000800081208120E34082A0E490800080000000010F8101010301ECC0000
+C336:0000000800081208120E34082A0E4908000800000808087F081C08220F9C0000
+C337:0000000800081208120E34082A0E49080008000003F802000200020003F80000
+C338:0000000800081208120E34082A0E49080008000007F8000807F8040007F80000
+C339:0000000800081208120E34082A0E4908000800003EF802083E0820083E080000
+C33A:0000000800081208120E34082A0E4908000800003EF802883E8820883EF80000
+C33B:0000000800081208120E34082A0E4908000800003E8802883EF820883EF80000
+C33C:0000000800081208120E34082A0E4908000800001F0801081F0810141F620000
+C33D:0000000800081208120E34082A0E4908000800003EF802803EF820803EF80000
+C33E:0000000800081208120E34082A0E4908000800003EFC02483E4820483EFC0000
+C33F:0000000800081208120E34082A0E4908000800001F08017F1F1C10221F1C0000
+C340:0000000800081208120E34082A0E49080008000003F802080208020803F80000
+C341:0000000800081208120E34082A0E4908000800000208020803F8020803F80000
+C342:0000000800081208120E34082A0E490800080000110811081F0811141F620000
+C343:0000000800081208120E34082A0E490800080000001000100010006801840000
+C344:0000000800081208120E34082A0E4908000800000048004800A8011406620000
+C345:0000000800081208120E34082A0E490800080000000003F00408040803F00000
+C346:0000000800081208120E34082A0E49080008000003F80020002000D003080000
+C347:0000000800081208120E34082A0E490800080000004003F8004000A003180000
+C348:0000000800081208120E34082A0E49080008000003F8000803F8000800080000
+C349:0000000800081208120E34082A0E49080008000003F8020003F8020003F80000
+C34A:0000000800081208120E34082A0E49080008000000000FF8022002200FF80000
+C34B:0000000800081208120E34082A0E49080008000000800FF803E0041003E00000
+C34C:000000000012001208920892089E19121512229ECC5200120012001200120000
+C34D:0000002800281228123834282A3849280028000007F800080008000800080000
+C34E:0000002800281228123834282A3849280028000000003EF80208020802080000
+C34F:0000002800281228123834282A3849280028000000003E100210022802C40000
+C350:0000002800281228123834282A3849280028002808000800080008000FF80000
+C351:0000002800281228123834282A38492800280000000020F8201020303ECC0000
+C352:0000002800281228123834282A38492800280000202021FC207020883E700000
+C353:0000002800281228123834282A3849280028000003F802000200020003F80000
+C354:0000002800281228123834282A3849280028000007F8000807F8040007F80000
+C355:0000002800281228123834282A384928002800003EF802083E0820083E080000
+C356:0000002800281228123834282A384928002800003EF802883E8820883EF80000
+C357:0000002800281228123834282A384928002800003E8802883EF820883EF80000
+C358:0000002800281228123834282A384928002800001F0801081F0810141F620000
+C359:0000002800281228123834282A384928002800003EF802803EF820803EF80000
+C35A:0000002800281228123834282A384928002800003EFC02483E4820483EFC0000
+C35B:0000002800281228123834282A384928002800003E1002FE3E3820443E380000
+C35C:0000002800281228123834282A3849280028000003F802080208020803F80000
+C35D:0000002800281228123834282A384928002800000208020803F8020803F80000
+C35E:0000002800281228123834282A38492800280000110811081F0811141F620000
+C35F:0000002800281228123834282A38492800280000000800080008003400C20000
+C360:0000002800281228123834282A384928002800000048004800A8011406620000
+C361:0000002800281228123834282A38492800280000000001F00208020801F00000
+C362:0000002800281228123834282A3849280028000003F80020002000D003080000
+C363:0000002800281228123834282A38492800280000004003F8004000A003180000
+C364:0000002800281228123834282A3849280028000003F8000803F8000800080000
+C365:0000002800281228123834282A3849280028000003F8020003F8020003F80000
+C366:0000002800281228123834282A3849280028000000000FF8022002200FF80000
+C367:0000002800281228123834282A3849280028000000800FF803E0041003E00000
+C368:0000000000020002088208820882191E15022282CC4200020002000200020000
+C369:0000000800081208120834382A08490800080000000007F80008000800080000
+C36A:0000000800081208120834382A0849080008000000003EF80208020802080000
+C36B:0000000800081208120834382A0849080008000000001F080108011401620000
+C36C:0000000800081208120834382A0849080008000000001000100010001FF80000
+C36D:0000000800081208120834382A08490800080000000020F8201020303ECC0000
+C36E:0000000800081208120834382A08490800080000202021FC207020883E700000
+C36F:0000000800081208120834382A0849080008000003F802000200020003F80000
+C370:0000000800081208120834382A0849080008000007F8000807F8040007F80000
+C371:0000000800081208120834382A084908000800003EF802083E0820083E080000
+C372:0000000800081208120834382A084908000800003EF802883E8820883EF80000
+C373:0000000800081208120834382A084908000800003E8802883EF820883EF80000
+C374:0000000800081208120834382A084908000800000F8800880F8808140FA20000
+C375:0000000800081208120834382A084908000800003EF802803EF820803EF80000
+C376:0000000800081208120834382A084908000800003EFC02483E4820483EFC0000
+C377:0000000800081208120834382A084908000800003E1002FE3E3820443E380000
+C378:0000000800081208120834382A0849080008000003F802080208020803F80000
+C379:0000000800081208120834382A084908000800000208020803F8020803F80000
+C37A:0000000800081208120834382A08490800080000210821083F0821143F620000
+C37B:0000000800081208120834382A08490800080000001000100010006801840000
+C37C:0000000800081208120834382A084908000800000048004800A8011406620000
+C37D:0000000800081208120834382A08490800080000000003F00408040803F00000
+C37E:0000000800081208120834382A0849080008000003F80020002000D003080000
+C37F:0000000800081208120834382A08490800080000004003F8004000A003180000
+C380:0000000800081208120834382A0849080008000003F8000803F8000800080000
+C381:0000000800081208120834382A0849080008000003F8020003F8020003F80000
+C382:0000000800081208120834382A0849080008000000000FF8022002200FF80000
+C383:0000000800081208120834382A0849080008000000800FF803E0041003E00000
+C384:00000000000A000A088A088A088A193A150A228ACC4A000A000A000A000A0000
+C385:0000002800281228122834E82A2849280028000007F800080008000800080000
+C386:0000002800281228122834E82A2849280028000000003EF80208020802080000
+C387:0000002800281228122834E82A2849280028000000003E100210022802C40000
+C388:0000002800281228122834E82A2849280028000008000800080008000FF80000
+C389:0000002800281228122834E82A28492800280000000020F8201020303ECC0000
+C38A:0000002800281228122834E82A28492800280000202021FC207020883E700000
+C38B:0000002800281228122834E82A2849280028000003F802000200020003F80000
+C38C:0000002800281228122834E82A2849280028000007F8000807F8040007F80000
+C38D:0000002800281228122834E82A284928002800003EF802083E0820083E080000
+C38E:0000002800281228122834E82A284928002800003EF802883E8820883EF80000
+C38F:0000002800281228122834E82A284928002800003E8802883EF820883EF80000
+C390:0000002800281228122834E82A284928002800001F0801081F0810141F620000
+C391:0000002800281228122834E82A284928002800003EF802803EF820803EF80000
+C392:0000002800281228122834E82A284928002800003EFC02483E4820483EFC0000
+C393:0000002800281228122834E82A284928002800003E1002FE3E3820443E380000
+C394:0000002800281228122834E82A2849280028000003F802080208020803F80000
+C395:0000002800281228122834E82A284928002800000208020803F8020803F80000
+C396:0000002800281228122834E82A28492800280000110811081F0811141F620000
+C397:0000002800281228122834E82A28492800280000000800080008003400C20000
+C398:0000002800281228122834E82A284928002800000048004800A8011406620000
+C399:0000002800281228122834E82A28492800280000000001F00208020801F00000
+C39A:0000002800281228122834E82A2849280028000003F80020002000D003080000
+C39B:0000002800281228122834E82A28492800280000004003F8004000A003180000
+C39C:0000002800281228122834E82A2849280028000003F8000803F8000800080000
+C39D:0000002800281228122834E82A2849280028000003F8020003F8020003F80000
+C39E:0000002800281228122834E82A2849280028000000000FF8022002200FF80000
+C39F:0000002800281228122834E82A2849280028000000800FF803E0041003E00000
+C3A0:000000000002000208820882089E19021502229ECC4200020002000200020000
+C3A1:0000000800081208123834082A38490800080000000007F80008000800080000
+C3A2:0000000800081208123834082A3849080008000000003EF80208020802080000
+C3A3:0000000800081208123834082A3849080008000000001F080108011401620000
+C3A4:0000000800081208123834082A3849080008000800001000100010001FF80000
+C3A5:0000000800081208123834082A38490800080000000020F8201020303ECC0000
+C3A6:0000000800081208123834082A38490800080000202021FC207020883E700000
+C3A7:0000000800081208123834082A3849080008000003F802000200020003F80000
+C3A8:0000000800081208123834082A3849080008000007F8000807F8040007F80000
+C3A9:0000000800081208123834082A384908000800003EF802083E0820083E080000
+C3AA:0000000800081208123834082A384908000800003EF802883E8820883EF80000
+C3AB:0000000800081208123834082A384908000800003E8802883EF820883EF80000
+C3AC:0000000800081208123834082A384908000800000F8800880F8808140FA20000
+C3AD:0000000800081208123834082A384908000800003EF802803EF820803EF80000
+C3AE:0000000800081208123834082A384908000800003EFC02483E4820483EFC0000
+C3AF:0000000800081208123834082A384908000800003E1002FE3E3820443E380000
+C3B0:0000000800081208123834082A3849080008000003F802080208020803F80000
+C3B1:0000000800081208123834082A384908000800000208020803F8020803F80000
+C3B2:0000000800081208123834082A38490800080000210821083F0821143F620000
+C3B3:0000000800081208123834082A38490800080000001000100010006801840000
+C3B4:0000000800081208123834082A384908000800000048004800A8011406620000
+C3B5:0000000800081208123834082A38490800080000000003F00408040803F00000
+C3B6:0000000800081208123834082A3849080008000003F80020002000D003080000
+C3B7:0000000800081208123834082A38490800080000004003F8004000A003180000
+C3B8:0000000800081208123834082A3849080008000003F8000803F8000800080000
+C3B9:0000000800081208123834082A3849080008000003F8020003F8020003F80000
+C3BA:0000000800081208123834082A3849080008000000000FF8022002200FF80000
+C3BB:0000000800081208123834082A3849080008000000800FF803E0041003E00000
+C3BC:00000000000A000A088A088A08BA190A150A22BACC4A000A000A000A000A0000
+C3BD:000000280028122812E834282AE849280028000007F800080008000800080000
+C3BE:000000280028122812E834282AE849280028000000003EF80208020802080000
+C3BF:000000280028122812E834282AE849280028000000003E100210022802C40000
+C3C0:000000280028122812E834282AE849280028002808000800080008000FF80000
+C3C1:000000280028122812E834282AE8492800280000000020F8201020303ECC0000
+C3C2:000000280028122812E834282AE8492800280000202021FC207020883E700000
+C3C3:000000280028122812E834282AE849280028000003F802000200020003F80000
+C3C4:000000280028122812E834282AE849280028000007F8000807F8040007F80000
+C3C5:000000280028122812E834282AE84928002800003EF802083E0820083E080000
+C3C6:000000280028122812E834282AE84928002800003EF802883E8820883EF80000
+C3C7:000000280028122812E834282AE84928002800003E8802883EF820883EF80000
+C3C8:000000280028122812E834282AE84928002800001F0801081F0810141F620000
+C3C9:000000280028122812E834282AE84928002800003EF802803EF820803EF80000
+C3CA:000000280028122812E834282AE84928002800003EFC02483E4820483EFC0000
+C3CB:000000280028122812E834282AE84928002800003E1002FE3E3820443E380000
+C3CC:000000280028122812E834282AE849280028000003F802080208020803F80000
+C3CD:000000280028122812E834282AE84928002800000208020803F8020803F80000
+C3CE:000000280028122812E834282AE8492800280000110811081F0811141F620000
+C3CF:000000280028122812E834282AE8492800280000000800080008003400C20000
+C3D0:000000280028122812E834282AE84928002800000048004800A8011406620000
+C3D1:000000280028122812E834282AE8492800280000000001F00208020801F00000
+C3D2:000000280028122812E834282AE849280028000003F80020002000D003080000
+C3D3:000000280028122812E834282AE8492800280000004003F8004000A003180000
+C3D4:000000280028122812E834282AE849280028000003F8000803F8000800080000
+C3D5:000000280028122812E834282AE849280028000003F8020003F8020003F80000
+C3D6:000000280028122812E834282AE849280028000000000FF8022002200FF80000
+C3D7:000000280028122812E834282AE849280028000000800FF803E0041003E00000
+C3D8:0000000000000220022002200640054008A033100100010001007FFC00000000
+C3D9:000000000220022004400AA0111001007FFC00001FF000100010001000100000
+C3DA:000000000220022004400AA0111001007FFC000000003EF80208020802080000
+C3DB:000000000220022004400AA0111001007FFC000000001E100210022802C40000
+C3DC:000000000220022004400AA0111001007FFC000000001000100010001FF00000
+C3DD:000000000220022004400AA0111001007FFC0000000020F8201020303ECC0000
+C3DE:000000000220022004400AA0111001007FFC0000202021FC207020883E700000
+C3DF:000000000220022004400AA0111001007FFC00001FF01000100010001FF00000
+C3E0:000000000220022004400AA0111001007FFC00001FF000101FF010001FF00000
+C3E1:000000000220022004400AA0111001007FFC00003EF802083E0820083E080000
+C3E2:000000000220022004400AA0111001007FFC00003EF802883E8820883EF80000
+C3E3:000000000220022004400AA0111001007FFC00003E8802883EF820883EF80000
+C3E4:000000000220022004400AA0111001007FFC00003E1002103E1020283EC40000
+C3E5:000000000220022004400AA0111001007FFC00003EF802803EF820803EF80000
+C3E6:000000000220022004400AA0111001007FFC00003EFC02483E4820483EFC0000
+C3E7:000000000220022004400AA0111001007FFC00003E2003FC3E7020883E700000
+C3E8:000000000220022004400AA0111001007FFC00001FF01010101010101FF00000
+C3E9:000000000220022004400AA0111001007FFC0000101010101FF010101FF00000
+C3EA:000000000220022004400AA0111001007FFC0000222022203E2022503E880000
+C3EB:000000000220022004400AA0111001007FFC000000000100010002800C400000
+C3EC:000000000220022004400AA0111001007FFC00000000024002400DA033100000
+C3ED:000000000220022004400AA0111001007FFC0000000007C00820082007C00000
+C3EE:000000000220022004400AA0111001007FFC0000000007E00080014006200000
+C3EF:000000000220022004400AA0111001007FFC0000008007E00080014006200000
+C3F0:000000000220022004400AA0111001007FFC00001FF000101FF0001000100000
+C3F1:000000000220022004400AA0111001007FFC00001FF010001FF010001FF00000
+C3F2:000000000220022004400AA0111001007FFC000000001FF0044004401FF00000
+C3F3:000000000220022004400AA0111001007FFC000001001FF007C0082007C00000
+C3F4:0000001000100890089008901910151E2290CC50041004107FD0001000100000
+C3F5:00000888088811082A8E4448040804087FE8000007F800080008000800080000
+C3F6:00000888088811082A8E4448040804087FE8000000003EF80208020802080000
+C3F7:00000888088811082A8E4448040804087FE8000000001F080108011401620000
+C3F8:00000888088811082A8E4448040804087FE8000008000800080008000FF80000
+C3F9:00000888088811082A8E4448040804087FE80000000010F8101010301ECC0000
+C3FA:00000888088811082A8E4448040804087FE800000808087F081C08220F9C0000
+C3FB:00000888088811082A8E4448040804087FE8000003F802000200020003F80000
+C3FC:00000888088811082A8E4448040804087FE8000007F8000807F8040007F80000
+C3FD:00000888088811082A8E4448040804087FE800003EF802083E0820083E080000
+C3FE:00000888088811082A8E4448040804087FE800003EF802883E8820883EF80000
+C3FF:00000888088811082A8E4448040804087FE800003E8802883EF820883EF80000
+C400:00000888088811082A8E4448040804087FE800001F0801081F0810141F620000
+C401:00000888088811082A8E4448040804087FE800003EF802803EF820803EF80000
+C402:00000888088811082A8E4448040804087FE800003EFC02483E4820483EFC0000
+C403:00000888088811082A8E4448040804087FE800001F08017F1F1C10221F1C0000
+C404:00000888088811082A8E4448040804087FE8000003F802080208020803F80000
+C405:00000888088811082A8E4448040804087FE800000208020803F8020803F80000
+C406:00000888088811082A8E4448040804087FE80000110811081F0811141F620000
+C407:00000888088811082A8E4448040804087FE80000001000100010006801840000
+C408:00000888088811082A8E4448040804087FE800000048004800A8011406620000
+C409:00000888088811082A8E4448040804087FE80000000003F00408040803F00000
+C40A:00000888088811082A8E4448040804087FE8000003F80020002000D003080000
+C40B:00000888088811082A8E4448040804087FE80000004003F8004000A003180000
+C40C:00000888088811082A8E4448040804087FE8000003F8000803F8000800080000
+C40D:00000888088811082A8E4448040804087FE8000003F8020003F8020003F80000
+C40E:00000888088811082A8E4448040804087FE8000000000FF8022002200FF80000
+C40F:00000888088811082A8E4448040804087FE8000000800FF803E0041003E00000
+C410:0000001200120892089208921912151E2292CC52041204127FD2001200120000
+C411:000008A808A811282AB84468042804287FA8000007F800080008000800080000
+C412:000008A808A811282AB84468042804287FA8000000003EF80208020802080000
+C413:000008A808A811282AB84468042804287FA8000000001F080108011401620000
+C414:000008A808A811282AB84468042804287FA8000008000800080008000FF80000
+C415:000008A808A811282AB84468042804287FA80000000010F8101010301ECC0000
+C416:000008A808A811282AB84468042804287FA800000808087F081C08220F9C0000
+C417:000008A808A811282AB84468042804287FA8000003F802000200020003F80000
+C418:000008A808A811282AB84468042804287FA8000007F8000807F8040007F80000
+C419:000008A808A811282AB84468042804287FA800003EF802083E0820083E080000
+C41A:000008A808A811282AB84468042804287FA800003EF802883E8820883EF80000
+C41B:000008A808A811282AB84468042804287FA800003E8802883EF820883EF80000
+C41C:000008A808A811282AB84468042804287FA800001F0801081F0810141F620000
+C41D:000008A808A811282AB84468042804287FA800003EF802803EF820803EF80000
+C41E:000008A808A811282AB84468042804287FA800003EFC02483E4820483EFC0000
+C41F:000008A808A811282AB84468042804287FA800001F08017F1F1C10221F1C0000
+C420:000008A808A811282AB84468042804287FA8000003F802080208020803F80000
+C421:000008A808A811282AB84468042804287FA800000208020803F8020803F80000
+C422:000008A808A811282AB84468042804287FA80000110811081F0811141F620000
+C423:000008A808A811282AB84468042804287FA80000001000100010006801840000
+C424:000008A808A811282AB84468042804287FA800000048004800A8011406620000
+C425:000008A808A811282AB84468042804287FA80000000003F00408040803F00000
+C426:000008A808A811282AB84468042804287FA8000003F80020002000D003080000
+C427:000008A808A811282AB84468042804287FA80000004003F8004000A003180000
+C428:000008A808A811282AB84468042804287FA8000003F8000803F8000800080000
+C429:000008A808A811282AB84468042804287FA8000003F8020003F8020003F80000
+C42A:000008A808A811282AB84468042804287FA8000000000FF8022002200FF80000
+C42B:000008A808A811282AB84468042804287FA8000000800FF803E0041003E00000
+C42C:000000080008088808880888190815082288CC48040804087FE8000800080000
+C42D:00000888088811082A884448040804087FE8000007F800080008000800080000
+C42E:00000888088811082A884448040804087FE8000000003EF80208020802080000
+C42F:00000888088811082A884448040804087FE8000000001F080108011401620000
+C430:00000888088811082A884448040804087FE8000008000800080008000FF80000
+C431:00000888088811082A884448040804087FE80000000010F8101010301ECC0000
+C432:00000888088811082A884448040804087FE800000808087F081C08220F9C0000
+C433:00000888088811082A884448040804087FE8000003F802000200020003F80000
+C434:00000888088811082A884448040804087FE8000007F8000807F8040007F80000
+C435:00000888088811082A884448040804087FE800003EF802083E0820083E080000
+C436:00000888088811082A884448040804087FE800003EF802883E8820883EF80000
+C437:00000888088811082A884448040804087FE800003E8802883EF820883EF80000
+C438:00000888088811082A884448040804087FE800001F0801081F0810141F620000
+C439:00000888088811082A884448040804087FE800003EF802803EF820803EF80000
+C43A:00000888088811082A884448040804087FE800003EFC02483E4820483EFC0000
+C43B:00000888088811082A884448040804087FE800001F08017F1F1C10221F1C0000
+C43C:00000888088811082A884448040804087FE8000003F802080208020803F80000
+C43D:00000888088811082A884448040804087FE800000208020803F8020803F80000
+C43E:00000888088811082A884448040804087FE80000110811081F0811141F620000
+C43F:00000888088811082A884448040804087FE80000001000100010006801840000
+C440:00000888088811082A884448040804087FE800000048004800A8011406620000
+C441:00000888088811082A884448040804087FE80000000003F00408040803F00000
+C442:00000888088811082A884448040804087FE8000003F80020002000D003080000
+C443:00000888088811082A884448040804087FE80000004003F8004000A003180000
+C444:00000888088811082A884448040804087FE8000003F8000803F8000800080000
+C445:00000888088811082A884448040804087FE8000003F8020003F8020003F80000
+C446:00000888088811082A884448040804087FE8000000000FF8022002200FF80000
+C447:00000888088811082A884448040804087FE8000000800FF803E0041003E00000
+C448:0000000000000220022002200640054008A037500440044004407FFC00000000
+C449:000000000220022004400AA0155004407FFC00001FF000100010001000100000
+C44A:000000000220022004400AA0155004407FFC000000003EF80208020802080000
+C44B:000000000220022004400AA0155004407FFC000000001E100210022802C40000
+C44C:000000000220022004400AA0155004407FFC000000001000100010001FF00000
+C44D:000000000220022004400AA0155004407FFC0000000020F8201020303ECC0000
+C44E:000000000220022004400AA0155004407FFC0000202021FC207020883E700000
+C44F:000000000220022004400AA0155004407FFC00001FF01000100010001FF00000
+C450:000000000220022004400AA0155004407FFC00001FF000101FF010001FF00000
+C451:000000000220022004400AA0155004407FFC00003EF802083E0820083E080000
+C452:000000000220022004400AA0155004407FFC00003EF802883E8820883EF80000
+C453:000000000220022004400AA0155004407FFC00003E8802883EF820883EF80000
+C454:000000000220022004400AA0155004407FFC00003E1002103E1020283EC40000
+C455:000000000220022004400AA0155004407FFC00003EF802803EF820803EF80000
+C456:000000000220022004400AA0155004407FFC00003EFC02483E4820483EFC0000
+C457:000000000220022004400AA0155004407FFC00003E2003FC3E7020883E700000
+C458:000000000220022004400AA0155004407FFC00001FF01010101010101FF00000
+C459:000000000220022004400AA0155004407FFC0000101010101FF010101FF00000
+C45A:000000000220022004400AA0155004407FFC0000222022203E2022503E880000
+C45B:000000000220022004400AA0155004407FFC000000000100010002800C400000
+C45C:000000000220022004400AA0155004407FFC00000000024002400DA033100000
+C45D:000000000220022004400AA0155004407FFC0000000007C00820082007C00000
+C45E:000000000220022004400AA0155004407FFC0000000007E00080014006200000
+C45F:000000000220022004400AA0155004407FFC0000008007E00080014006200000
+C460:000000000220022004400AA0155004407FFC00001FF000101FF0001000100000
+C461:000000000220022004400AA0155004407FFC00001FF010001FF010001FF00000
+C462:000000000220022004400AA0155004407FFC000000001FF0044004401FF00000
+C463:000000000220022004400AA0155004407FFC000001001FF007C0082007C00000
+C464:000000000220022002200640054008A0331000003FF801000100010001000000
+C465:000000000220022004400AA011107FFC010001001FF000100010001000100000
+C466:000000000220022004400AA011107FFC0100010000003EF80208020802080000
+C467:000000000220022004400AA011107FFC0100010000001E100210022802C40000
+C468:000000000220022004400AA0111000007FFC010001001100100010001FF00000
+C469:000000000220022004400AA011107FFC01000100000020F8201020303ECC0000
+C46A:000000000220022004400AA011107FFC01000100202021FC207020883E700000
+C46B:000000000220022004400AA011107FFC010001001FF01000100010001FF00000
+C46C:000000000220022004400AA011107FFC010001001FF000101FF010001FF00000
+C46D:000000000220022004400AA011107FFC010001003EF802083E0820083E080000
+C46E:000000000220022004400AA011107FFC010001003EF802883E8820883EF80000
+C46F:000000000220022004400AA011107FFC010001003E8802883EF820883EF80000
+C470:000000000220022004400AA011107FFC010001003E1002103E1020283EC40000
+C471:000000000220022004400AA011107FFC010001003EF802803EF820803EF80000
+C472:000000000220022004400AA011107FFC010001003EFC02483E4820483EFC0000
+C473:000000000220022004400AA011107FFC010001003E2003FC3E7020883E700000
+C474:000000000220022004400AA011107FFC010001001FF01010101010101FF00000
+C475:000000000220022004400AA011107FFC01000100101010101FF010101FF00000
+C476:000000000220022004400AA011107FFC01000100222022203E2022503E880000
+C477:000000000220022004400AA011107FFC0100010000000100010002800C400000
+C478:000000000220022004400AA011107FFC010001000000024002400DA033100000
+C479:000000000220022004400AA011107FFC01000100000007C00820082007C00000
+C47A:000000000220022004400AA011107FFC01000100000007E00080014006200000
+C47B:000000000220022004400AA011107FFC01000100008007E00080014006200000
+C47C:000000000220022004400AA011107FFC010001001FF000101FF0001000100000
+C47D:000000000220022004400AA011107FFC010001001FF010001FF010001FF00000
+C47E:000000000220022004400AA011107FFC0100010000001FF0044004401FF00000
+C47F:000000000220022004400AA011107FFC0100010001001FF007C0082007C00000
+C480:00000008088808880888190815082288CC4800087FE8040804F8040804080000
+C481:00080888088811082A8844487FE8027802080000000007F80008000800080000
+C482:00080888088811082A8844487FE802780208000000003EF80208020802080000
+C483:00080888088811082A8844487FE802780208000000001F080108011401620000
+C484:00080888088811082A88444800087FE80278020802081000100010001FF80000
+C485:00080888088811082A8844487FE8027802080000000020F8201020303ECC0000
+C486:00080888088811082A8844487FE8027802080000202021FC207020883E700000
+C487:00080888088811082A8844487FE802780208000003F802000200020003F80000
+C488:00080888088811082A8844487FE802780208000007F8000807F8040007F80000
+C489:00080888088811082A8844487FE80278020800003EF802083E0820083E080000
+C48A:00080888088811082A8844487FE80278020800003EF802883E8820883EF80000
+C48B:00080888088811082A8844487FE80278020800003E8802883EF820883EF80000
+C48C:00080888088811082A8844487FE80278020800000F8800880F8808140FA20000
+C48D:00080888088811082A8844487FE80278020800003EF802803EF820803EF80000
+C48E:00080888088811082A8844487FE80278020800003EFC02483E4820483EFC0000
+C48F:00080888088811082A8844487FE80278020800003E1002FE3E3820443E380000
+C490:00080888088811082A8844487FE802780208000003F802080208020803F80000
+C491:00080888088811082A8844487FE80278020800000208020803F8020803F80000
+C492:00080888088811082A8844487FE8027802080000210821083F0821143F620000
+C493:00080888088811082A8844487FE8027802080000001000100010006801840000
+C494:00080888088811082A8844487FE80278020800000048004800A8011406620000
+C495:00080888088811082A8844487FE8027802080000000003F00408040803F00000
+C496:00080888088811082A8844487FE802780208000003F80020002000D003080000
+C497:00080888088811082A8844487FE8027802080000004003F8004000A003180000
+C498:00080888088811082A8844487FE802780208000003F8000803F8000800080000
+C499:00080888088811082A8844487FE802780208000003F8020003F8020003F80000
+C49A:00080888088811082A8844487FE802780208000000000FF8022002200FF80000
+C49B:00080888088811082A8844487FE802780208000000800FF803E0041003E00000
+C49C:0000000A088A088A088A190A150A228ACC4A000A7FEA040A047A040A040A0000
+C49D:002808A808A811282AA844687FA805E804280000000007F80008000800080000
+C49E:002808A808A811282AA844687FA805E80428000000003EF80208020802080000
+C49F:002808A808A811282AA844687FA805E80428000000001F080108011401620000
+C4A0:002808A808A811282AA8446800287FA8042805E804281428100010001FF80000
+C4A1:002808A808A811282AA844687FA805E804280000000020F8201020303ECC0000
+C4A2:002808A808A811282AA844687FA805E804280000202021FC207020883E700000
+C4A3:002808A808A811282AA844687FA805E80428000003F802000200020003F80000
+C4A4:002808A808A811282AA844687FA805E80428000007F8000807F8040007F80000
+C4A5:002808A808A811282AA844687FA805E8042800003EF802083E0820083E080000
+C4A6:002808A808A811282AA844687FA805E8042800003EF802883E8820883EF80000
+C4A7:002808A808A811282AA844687FA805E8042800003E8802883EF820883EF80000
+C4A8:002808A808A811282AA844687FA805E8042800000F8800880F8808140FA20000
+C4A9:002808A808A811282AA844687FA805E8042800003EF802803EF820803EF80000
+C4AA:002808A808A811282AA844687FA805E8042800003EFC02483E4820483EFC0000
+C4AB:002808A808A811282AA844687FA805E8042800003E1002FE3E3820443E380000
+C4AC:002808A808A811282AA844687FA805E80428000003F802080208020803F80000
+C4AD:002808A808A811282AA844687FA805E8042800000208020803F8020803F80000
+C4AE:002808A808A811282AA844687FA805E804280000210821083F0821143F620000
+C4AF:002808A808A811282AA844687FA805E804280000001000100010006801840000
+C4B0:002808A808A811282AA844687FA805E8042800000048004800A8011406620000
+C4B1:002808A808A811282AA844687FA805E804280000000003F00408040803F00000
+C4B2:002808A808A811282AA844687FA805E80428000003F80020002000D003080000
+C4B3:002808A808A811282AA844687FA805E804280000004003F8004000A003180000
+C4B4:002808A808A811282AA844687FA805E80428000003F8000803F8000800080000
+C4B5:002808A808A811282AA844687FA805E80428000003F8020003F8020003F80000
+C4B6:002808A808A811282AA844687FA805E80428000000000FF8022002200FF80000
+C4B7:002808A808A811282AA844687FA805E80428000000800FF803E0041003E00000
+C4B8:00000008088808880888190815082288CC4800087FE804080408040804080000
+C4B9:00080888088811082A8844487FE8020802000000000007F80008000800080000
+C4BA:00080888088811082A8844487FE802080200000000003EF80208020802080000
+C4BB:00080888088811082A8844487FE802080200000000001F080108011401620000
+C4BC:00080888088811082A88444800087FE80208020802081008100010001FF80000
+C4BD:00080888088811082A8844487FE8020802000000000020F8201020303ECC0000
+C4BE:00080888088811082A8844487FE8020802000000202021FC207020883E700000
+C4BF:00080888088811082A8844487FE802080200000003F802000200020003F80000
+C4C0:00080888088811082A8844487FE802080200000007F8000807F8040007F80000
+C4C1:00080888088811082A8844487FE80208020000003EF802083E0820083E080000
+C4C2:00080888088811082A8844487FE80208020000003EF802883E8820883EF80000
+C4C3:00080888088811082A8844487FE80208020000003E8802883EF820883EF80000
+C4C4:00080888088811082A8844487FE80208020000000F8800880F8808140FA20000
+C4C5:00080888088811082A8844487FE80208020000003EF802803EF820803EF80000
+C4C6:00080888088811082A8844487FE80208020000003EFC02483E4820483EFC0000
+C4C7:00080888088811082A8844487FE80208020000003E1002FE3E3820443E380000
+C4C8:00080888088811082A8844487FE802080200000003F802080208020803F80000
+C4C9:00080888088811082A8844487FE80208020000000208020803F8020803F80000
+C4CA:00080888088811082A8844487FE8020802000000210821083F0821143F620000
+C4CB:00080888088811082A8844487FE8020802000000001000100010006801840000
+C4CC:00080888088811082A8844487FE80208020000000048004800A8011406620000
+C4CD:00080888088811082A8844487FE8020802000000000003F00408040803F00000
+C4CE:00080888088811082A8844487FE802080200000003F80020002000D003080000
+C4CF:00080888088811082A8844487FE8020802000000004003F8004000A003180000
+C4D0:00080888088811082A8844487FE802080200000003F8000803F8000800080000
+C4D1:00080888088811082A8844487FE802080200000003F8020003F8020003F80000
+C4D2:00080888088811082A8844487FE802080200000000000FF8022002200FF80000
+C4D3:00080888088811082A8844487FE802080200000000800FF803E0041003E00000
+C4D4:000000000220022002200640054008A0331000007FFC04400440044004400000
+C4D5:000000000220022004400AA011107FFC044004401FF000100010001000100000
+C4D6:000000000220022004400AA011107FFC0440044000003EF80208020802080000
+C4D7:000000000220022004400AA011107FFC0440044000001E100210022802C40000
+C4D8:000000000220022004400AA0111000007FFC044004401440100010001FF00000
+C4D9:000000000220022004400AA011107FFC04400440000020F8201020303ECC0000
+C4DA:000000000220022004400AA011107FFC04400440202021FC207020883E700000
+C4DB:000000000220022004400AA011107FFC044004401FF01000100010001FF00000
+C4DC:000000000220022004400AA011107FFC044004401FF000101FF010001FF00000
+C4DD:000000000220022004400AA011107FFC044004403EF802083E0820083E080000
+C4DE:000000000220022004400AA011107FFC044004403EF802883E8820883EF80000
+C4DF:000000000220022004400AA011107FFC044004403E8802883EF820883EF80000
+C4E0:000000000220022004400AA011107FFC044004403E1002103E1020283EC40000
+C4E1:000000000220022004400AA011107FFC044004403EF802803EF820803EF80000
+C4E2:000000000220022004400AA011107FFC044004403EFC02483E4820483EFC0000
+C4E3:000000000220022004400AA011107FFC044004403E2003FC3E7020883E700000
+C4E4:000000000220022004400AA011107FFC044004401FF01010101010101FF00000
+C4E5:000000000220022004400AA011107FFC04400440101010101FF010101FF00000
+C4E6:000000000220022004400AA011107FFC04400440222022203E2022503E880000
+C4E7:000000000220022004400AA011107FFC0440044000000100010002800C400000
+C4E8:000000000220022004400AA011107FFC044004400000024002400DA033100000
+C4E9:000000000220022004400AA011107FFC04400440000007C00820082007C00000
+C4EA:000000000220022004400AA011107FFC04400440000007E00080014006200000
+C4EB:000000000220022004400AA011107FFC04400440008007E00080014006200000
+C4EC:000000000220022004400AA011107FFC044004401FF000101FF0001000100000
+C4ED:000000000220022004400AA011107FFC044004401FF010001FF010001FF00000
+C4EE:000000000220022004400AA011107FFC0440044000001FF0044004401FF00000
+C4EF:000000000220022004400AA011107FFC0440044001001FF007C0082007C00000
+C4F0:0000000000000220022002200640054008A0331000007FFC0000000000000000
+C4F1:000000000220022004400AA0111000007FFC00001FF000100010001000100000
+C4F2:000000000220022004400AA0111000007FFC000000003EF80208020802080000
+C4F3:000000000220022004400AA0111000007FFC000000001E100210022802C40000
+C4F4:000000000220022004400AA0111000007FFC000000001000100010001FF00000
+C4F5:000000000220022004400AA0111000007FFC0000000020F8201020303ECC0000
+C4F6:000000000220022004400AA0111000007FFC0000202021FC207020883E700000
+C4F7:000000000220022004400AA0111000007FFC00001FF01000100010001FF00000
+C4F8:000000000220022004400AA0111000007FFC00001FF000101FF010001FF00000
+C4F9:000000000220022004400AA0111000007FFC00003EF802083E0820083E080000
+C4FA:000000000220022004400AA0111000007FFC00003EF802883E8820883EF80000
+C4FB:000000000220022004400AA0111000007FFC00003E8802883EF820883EF80000
+C4FC:000000000220022004400AA0111000007FFC00003E1002103E1020283EC40000
+C4FD:000000000220022004400AA0111000007FFC00003EF802803EF820803EF80000
+C4FE:000000000220022004400AA0111000007FFC00003EFC02483E4820483EFC0000
+C4FF:000000000220022004400AA0111000007FFC00003E2003FC3E7020883E700000
+C500:000000000220022004400AA0111000007FFC00001FF01010101010101FF00000
+C501:000000000220022004400AA0111000007FFC0000101010101FF010101FF00000
+C502:000000000220022004400AA0111000007FFC0000222022203E2022503E880000
+C503:000000000220022004400AA0111000007FFC000000000100010002800C400000
+C504:000000000220022004400AA0111000007FFC00000000024002400DA033100000
+C505:000000000220022004400AA0111000007FFC0000000007C00820082007C00000
+C506:000000000220022004400AA0111000007FFC0000000007E00080014006200000
+C507:000000000220022004400AA0111000007FFC0000008007E00080014006200000
+C508:000000000220022004400AA0111000007FFC00001FF000101FF0001000100000
+C509:000000000220022004400AA0111000007FFC00001FF010001FF010001FF00000
+C50A:000000000220022004400AA0111000007FFC000000001FF0044004401FF00000
+C50B:000000000220022004400AA0111000007FFC000001001FF007C0082007C00000
+C50C:000000080008088808880888190815082288CC4800087FE80008000800080000
+C50D:00000888088811082A884448000800087FE8000007F800080008000800080000
+C50E:00000888088811082A884448000800087FE8000000003EF80208020802080000
+C50F:00000888088811082A884448000800087FE8000000001F080108011401620000
+C510:00000888088811082A884448000800087FE8000008000800080008000FF80000
+C511:00000888088811082A884448000800087FE80000000010F8101010301ECC0000
+C512:00000888088811082A884448000800087FE800000808087F081C08220F9C0000
+C513:00000888088811082A884448000800087FE8000003F802000200020003F80000
+C514:00000888088811082A884448000800087FE8000007F8000807F8040007F80000
+C515:00000888088811082A884448000800087FE800003EF802083E0820083E080000
+C516:00000888088811082A884448000800087FE800003EF802883E8820883EF80000
+C517:00000888088811082A884448000800087FE800003E8802883EF820883EF80000
+C518:00000888088811082A884448000800087FE800001F0801081F0810141F620000
+C519:00000888088811082A884448000800087FE800003EF802803EF820803EF80000
+C51A:00000888088811082A884448000800087FE800003EFC02483E4820483EFC0000
+C51B:00000888088811082A884448000800087FE800001F08017F1F1C10221F1C0000
+C51C:00000888088811082A884448000800087FE8000003F802080208020803F80000
+C51D:00000888088811082A884448000800087FE800000208020803F8020803F80000
+C51E:00000888088811082A884448000800087FE80000110811081F0811141F620000
+C51F:00000888088811082A884448000800087FE80000001000100010006801840000
+C520:00000888088811082A884448000800087FE800000048004800A8011406620000
+C521:00000888088811082A884448000800087FE80000000003F00408040803F00000
+C522:00000888088811082A884448000800087FE8000003F80020002000D003080000
+C523:00000888088811082A884448000800087FE80000004003F8004000A003180000
+C524:00000888088811082A884448000800087FE8000003F8000803F8000800080000
+C525:00000888088811082A884448000800087FE8000003F8020003F8020003F80000
+C526:00000888088811082A884448000800087FE8000000000FF8022002200FF80000
+C527:00000888088811082A884448000800087FE8000000800FF803E0041003E00000
+C528:0000000000080008088808880888190815082288CC4800080008000800080000
+C529:0000000800081208120834082A08490800080000000007F80008000800080000
+C52A:0000000800081208120834082A0849080008000000003EF80208020802080000
+C52B:0000000800081208120834082A0849080008000000001F080108011401620000
+C52C:0000000800081208120834082A0849080008000800001000100010001FF80000
+C52D:0000000800081208120834082A08490800080000000020F8201020303ECC0000
+C52E:0000000800081208120834082A08490800080000202021FC207020883E700000
+C52F:0000000800081208120834082A0849080008000003F802000200020003F80000
+C530:0000000800081208120834082A0849080008000007F8000807F8040007F80000
+C531:0000000800081208120834082A084908000800003EF802083E0820083E080000
+C532:0000000800081208120834082A084908000800003EF802883E8820883EF80000
+C533:0000000800081208120834082A084908000800003E8802883EF820883EF80000
+C534:0000000800081208120834082A084908000800000F8800880F8808140FA20000
+C535:0000000800081208120834082A084908000800003EF802803EF820803EF80000
+C536:0000000800081208120834082A084908000800003EFC02483E4820483EFC0000
+C537:0000000800081208120834082A084908000800003E1002FE3E3820443E380000
+C538:0000000800081208120834082A0849080008000003F802080208020803F80000
+C539:0000000800081208120834082A084908000800000208020803F8020803F80000
+C53A:0000000800081208120834082A08490800080000210821083F0821143F620000
+C53B:0000000800081208120834082A08490800080000001000100010006801840000
+C53C:0000000800081208120834082A084908000800000048004800A8011406620000
+C53D:0000000800081208120834082A08490800080000000003F00408040803F00000
+C53E:0000000800081208120834082A0849080008000003F80020002000D003080000
+C53F:0000000800081208120834082A08490800080000004003F8004000A003180000
+C540:0000000800081208120834082A0849080008000003F8000803F8000800080000
+C541:0000000800081208120834082A0849080008000003F8020003F8020003F80000
+C542:0000000800081208120834082A0849080008000000000FF8022002200FF80000
+C543:0000000800081208120834082A0849080008000000800FF803E0041003E00000
+C544:00000000001000101E1021104090409E409021101E1000100010001000100000
+C545:000000081E0821082108210E21081E080008000007F800080008000800080000
+C546:000000081E0821082108210E21081E080008000000003EF80208020802080000
+C547:000000081E0821082108210E21081E080008000000001F080108011401620000
+C548:000000081E0821082108210E21081E080008000808000800080008000FF80000
+C549:000000081E0821082108210E21081E0800080000000010F8101010301ECC0000
+C54A:000000081E0821082108210E21081E08000800000808087F081C08220F9C0000
+C54B:000000081E0821082108210E21081E080008000003F802000200020003F80000
+C54C:000000081E0821082108210E21081E080008000007F8000807F8040007F80000
+C54D:000000081E0821082108210E21081E08000800003EF802083E0820083E080000
+C54E:000000081E0821082108210E21081E08000800003EF802883E8820883EF80000
+C54F:000000081E0821082108210E21081E08000800003E8802883EF820883EF80000
+C550:000000081E0821082108210E21081E08000800001F0801081F0810141F620000
+C551:000000081E0821082108210E21081E08000800003EF802803EF820803EF80000
+C552:000000081E0821082108210E21081E08000800003EFC02483E4820483EFC0000
+C553:000000081E0821082108210E21081E08000800001F08017F1F1C10221F1C0000
+C554:000000081E0821082108210E21081E080008000003F802080208020803F80000
+C555:000000081E0821082108210E21081E08000800000208020803F8020803F80000
+C556:000000081E0821082108210E21081E0800080000110811081F0811141F620000
+C557:000000081E0821082108210E21081E0800080000001000100010006801840000
+C558:000000081E0821082108210E21081E08000800000048004800A8011406620000
+C559:000000081E0821082108210E21081E0800080000000003F00408040803F00000
+C55A:000000081E0821082108210E21081E080008000003F80020002000D003080000
+C55B:000000081E0821082108210E21081E0800080000004003F8004000A003180000
+C55C:000000081E0821082108210E21081E080008000003F8000803F8000800080000
+C55D:000000081E0821082108210E21081E080008000003F8020003F8020003F80000
+C55E:000000081E0821082108210E21081E080008000000000FF8022002200FF80000
+C55F:000000081E0821082108210E21081E080008000000800FF803E0041003E00000
+C560:00000000001200121E1221124092409E409221121E1200120012001200120000
+C561:000000281E2821282128213821281E280028000007F800080008000800080000
+C562:000000281E2821282128213821281E280028000000003EF80208020802080000
+C563:000000281E2821282128213821281E280028000000003E100210022802C40000
+C564:000000281E2821282128213821281E280028002808000800080008000FF80000
+C565:000000281E2821282128213821281E2800280000000020F8201020303ECC0000
+C566:000000281E2821282128213821281E2800280000202021FC207020883E700000
+C567:000000281E2821282128213821281E280028000003F802000200020003F80000
+C568:000000281E2821282128213821281E280028000007F8000807F8040007F80000
+C569:000000281E2821282128213821281E28002800003EF802083E0820083E080000
+C56A:000000281E2821282128213821281E28002800003EF802883E8820883EF80000
+C56B:000000281E2821282128213821281E28002800003E8802883EF820883EF80000
+C56C:000000281E2821282128213821281E28002800001F0801081F0810141F620000
+C56D:000000281E2821282128213821281E28002800003EF802803EF820803EF80000
+C56E:000000281E2821282128213821281E28002800003EFC02483E4820483EFC0000
+C56F:000000281E2821282128213821281E28002800003E1002FE3E3820443E380000
+C570:000000281E2821282128213821281E280028000003F802080208020803F80000
+C571:000000281E2821282128213821281E28002800000208020803F8020803F80000
+C572:000000281E2821282128213821281E2800280000110811081F0811141F620000
+C573:000000281E2821282128213821281E2800280000000800080008003400C20000
+C574:000000281E2821282128213821281E28002800000048004800A8011406620000
+C575:000000281E2821282128213821281E2800280000000001F00208020801F00000
+C576:000000281E2821282128213821281E280028000003F80020002000D003080000
+C577:000000281E2821282128213821281E2800280000004003F8004000A003180000
+C578:000000281E2821282128213821281E280028000003F8000803F8000800080000
+C579:000000281E2821282128213821281E280028000003F8020003F8020003F80000
+C57A:000000281E2821282128213821281E280028000000000FF8022002200FF80000
+C57B:000000281E2821282128213821281E280028000000800FF803E0041003E00000
+C57C:00000000001000101E102110409E40904090211E1E1000100010001000100000
+C57D:000000081E082108210E2108210E1E080008000007F800080008000800080000
+C57E:000000081E082108210E2108210E1E080008000000003EF80208020802080000
+C57F:000000081E082108210E2108210E1E080008000000001F080108011401620000
+C580:000000081E082108210E2108210E1E080008000008000800080008000FF80000
+C581:000000081E082108210E2108210E1E0800080000000010F8101010301ECC0000
+C582:000000081E082108210E2108210E1E08000800000808087F081C08220F9C0000
+C583:000000081E082108210E2108210E1E080008000003F802000200020003F80000
+C584:000000081E082108210E2108210E1E080008000007F8000807F8040007F80000
+C585:000000081E082108210E2108210E1E08000800003EF802083E0820083E080000
+C586:000000081E082108210E2108210E1E08000800003EF802883E8820883EF80000
+C587:000000081E082108210E2108210E1E08000800003E8802883EF820883EF80000
+C588:000000081E082108210E2108210E1E08000800001F0801081F0810141F620000
+C589:000000081E082108210E2108210E1E08000800003EF802803EF820803EF80000
+C58A:000000081E082108210E2108210E1E08000800003EFC02483E4820483EFC0000
+C58B:000000081E082108210E2108210E1E08000800001F08017F1F1C10221F1C0000
+C58C:000000081E082108210E2108210E1E080008000003F802080208020803F80000
+C58D:000000081E082108210E2108210E1E08000800000208020803F8020803F80000
+C58E:000000081E082108210E2108210E1E0800080000110811081F0811141F620000
+C58F:000000081E082108210E2108210E1E0800080000001000100010006801840000
+C590:000000081E082108210E2108210E1E08000800000048004800A8011406620000
+C591:000000081E082108210E2108210E1E0800080000000003F00408040803F00000
+C592:000000081E082108210E2108210E1E080008000003F80020002000D003080000
+C593:000000081E082108210E2108210E1E0800080000004003F8004000A003180000
+C594:000000081E082108210E2108210E1E080008000003F8000803F8000800080000
+C595:000000081E082108210E2108210E1E080008000003F8020003F8020003F80000
+C596:000000081E082108210E2108210E1E080008000000000FF8022002200FF80000
+C597:000000081E082108210E2108210E1E080008000000800FF803E0041003E00000
+C598:00000000001200121E122112409E40924092211E1E1200120012001200120000
+C599:000000281E2821282138212821381E280028000007F800080008000800080000
+C59A:000000281E2821282138212821381E280028000000003EF80208020802080000
+C59B:000000281E2821282138212821381E280028000000003E100210022802C40000
+C59C:000000281E2821282138212821381E280028002808000800080008000FF80000
+C59D:000000281E2821282138212821381E2800280000000020F8201020303ECC0000
+C59E:000000281E2821282138212821381E2800280000202021FC207020883E700000
+C59F:000000281E2821282138212821381E280028000003F802000200020003F80000
+C5A0:000000281E2821282138212821381E280028000007F8000807F8040007F80000
+C5A1:000000281E2821282138212821381E28002800003EF802083E0820083E080000
+C5A2:000000281E2821282138212821381E28002800003EF802883E8820883EF80000
+C5A3:000000281E2821282138212821381E28002800003E8802883EF820883EF80000
+C5A4:000000281E2821282138212821381E28002800001F0801081F0810141F620000
+C5A5:000000281E2821282138212821381E28002800003EF802803EF820803EF80000
+C5A6:000000281E2821282138212821381E28002800003EFC02483E4820483EFC0000
+C5A7:000000281E2821282138212821381E28002800003E1002FE3E3820443E380000
+C5A8:000000281E2821282138212821381E280028000003F802080208020803F80000
+C5A9:000000281E2821282138212821381E28002800000208020803F8020803F80000
+C5AA:000000281E2821282138212821381E2800280000110811081F0811141F620000
+C5AB:000000281E2821282138212821381E2800280000000800080008003400C20000
+C5AC:000000281E2821282138212821381E28002800000048004800A8011406620000
+C5AD:000000281E2821282138212821381E2800280000000001F00208020801F00000
+C5AE:000000281E2821282138212821381E280028000003F80020002000D003080000
+C5AF:000000281E2821282138212821381E2800280000004003F8004000A003180000
+C5B0:000000281E2821282138212821381E280028000003F8000803F8000800080000
+C5B1:000000281E2821282138212821381E280028000003F8020003F8020003F80000
+C5B2:000000281E2821282138212821381E280028000000000FF8022002200FF80000
+C5B3:000000281E2821282138212821381E280028000000800FF803E0041003E00000
+C5B4:00000000000200021E0221024082409E408221021E0200020002000200020000
+C5B5:000000081E0821082108213821081E0800080000000007F80008000800080000
+C5B6:000000081E0821082108213821081E080008000000003EF80208020802080000
+C5B7:000000081E0821082108213821081E080008000000001F080108011401620000
+C5B8:000000081E0821082108213821081E080008000000001000100010001FF80000
+C5B9:000000081E0821082108213821081E0800080000000020F8201020303ECC0000
+C5BA:000000081E0821082108213821081E0800080000202021FC207020883E700000
+C5BB:000000081E0821082108213821081E080008000003F802000200020003F80000
+C5BC:000000081E0821082108213821081E080008000007F8000807F8040007F80000
+C5BD:000000081E0821082108213821081E08000800003EF802083E0820083E080000
+C5BE:000000081E0821082108213821081E08000800003EF802883E8820883EF80000
+C5BF:000000081E0821082108213821081E08000800003E8802883EF820883EF80000
+C5C0:000000081E0821082108213821081E08000800000F8800880F8808140FA20000
+C5C1:000000081E0821082108213821081E08000800003EF802803EF820803EF80000
+C5C2:000000081E0821082108213821081E08000800003EFC02483E4820483EFC0000
+C5C3:000000081E0821082108213821081E08000800003E1002FE3E3820443E380000
+C5C4:000000081E0821082108213821081E080008000003F802080208020803F80000
+C5C5:000000081E0821082108213821081E08000800000208020803F8020803F80000
+C5C6:000000081E0821082108213821081E0800080000210821083F0821143F620000
+C5C7:000000081E0821082108213821081E0800080000001000100010006801840000
+C5C8:000000081E0821082108213821081E08000800000048004800A8011406620000
+C5C9:000000081E0821082108213821081E0800080000000003F00408040803F00000
+C5CA:000000081E0821082108213821081E080008000003F80020002000D003080000
+C5CB:000000081E0821082108213821081E0800080000004003F8004000A003180000
+C5CC:000000081E0821082108213821081E080008000003F8000803F8000800080000
+C5CD:000000081E0821082108213821081E080008000003F8020003F8020003F80000
+C5CE:000000081E0821082108213821081E080008000000000FF8022002200FF80000
+C5CF:000000081E0821082108213821081E080008000000800FF803E0041003E00000
+C5D0:00000000000A000A1E0A210A408A40BA408A210A1E0A000A000A000A000A0000
+C5D1:000000281E282128212821E821281E280028000007F800080008000800080000
+C5D2:000000281E282128212821E821281E280028000000003EF80208020802080000
+C5D3:000000281E282128212821E821281E280028000000003E100210022802C40000
+C5D4:000000281E282128212821E821281E280028000008000800080008000FF80000
+C5D5:000000281E282128212821E821281E2800280000000020F8201020303ECC0000
+C5D6:000000281E282128212821E821281E2800280000202021FC207020883E700000
+C5D7:000000281E282128212821E821281E280028000003F802000200020003F80000
+C5D8:000000281E282128212821E821281E280028000007F8000807F8040007F80000
+C5D9:000000281E282128212821E821281E28002800003EF802083E0820083E080000
+C5DA:000000281E282128212821E821281E28002800003EF802883E8820883EF80000
+C5DB:000000281E282128212821E821281E28002800003E8802883EF820883EF80000
+C5DC:000000281E282128212821E821281E28002800001F0801081F0810141F620000
+C5DD:000000281E282128212821E821281E28002800003EF802803EF820803EF80000
+C5DE:000000281E282128212821E821281E28002800003EFC02483E4820483EFC0000
+C5DF:000000281E282128212821E821281E28002800003E1002FE3E3820443E380000
+C5E0:000000281E282128212821E821281E280028000003F802080208020803F80000
+C5E1:000000281E282128212821E821281E28002800000208020803F8020803F80000
+C5E2:000000281E282128212821E821281E2800280000110811081F0811141F620000
+C5E3:000000281E282128212821E821281E2800280000000800080008003400C20000
+C5E4:000000281E282128212821E821281E28002800000048004800A8011406620000
+C5E5:000000281E282128212821E821281E2800280000000001F00208020801F00000
+C5E6:000000281E282128212821E821281E280028000003F80020002000D003080000
+C5E7:000000281E282128212821E821281E2800280000004003F8004000A003180000
+C5E8:000000281E282128212821E821281E280028000003F8000803F8000800080000
+C5E9:000000281E282128212821E821281E280028000003F8020003F8020003F80000
+C5EA:000000281E282128212821E821281E280028000000000FF8022002200FF80000
+C5EB:000000281E282128212821E821281E280028000000800FF803E0041003E00000
+C5EC:00000000000200021E022102409E40824082211E1E0200020002000200020000
+C5ED:000000081E0821082138210821381E0800080000000007F80008000800080000
+C5EE:000000081E0821082138210821381E080008000000003EF80208020802080000
+C5EF:000000081E0821082138210821381E080008000000001F080108011401620000
+C5F0:000000081E0821082138210821381E080008000800001000100010001FF80000
+C5F1:000000081E0821082138210821381E0800080000000020F8201020303ECC0000
+C5F2:000000081E0821082138210821381E0800080000202021FC207020883E700000
+C5F3:000000081E0821082138210821381E080008000003F802000200020003F80000
+C5F4:000000081E0821082138210821381E080008000007F8000807F8040007F80000
+C5F5:000000081E0821082138210821381E08000800003EF802083E0820083E080000
+C5F6:000000081E0821082138210821381E08000800003EF802883E8820883EF80000
+C5F7:000000081E0821082138210821381E08000800003E8802883EF820883EF80000
+C5F8:000000081E0821082138210821381E08000800000F8800880F8808140FA20000
+C5F9:000000081E0821082138210821381E08000800003EF802803EF820803EF80000
+C5FA:000000081E0821082138210821381E08000800003EFC02483E4820483EFC0000
+C5FB:000000081E0821082138210821381E08000800003E1002FE3E3820443E380000
+C5FC:000000081E0821082138210821381E080008000003F802080208020803F80000
+C5FD:000000081E0821082138210821381E08000800000208020803F8020803F80000
+C5FE:000000081E0821082138210821381E0800080000210821083F0821143F620000
+C5FF:000000081E0821082138210821381E0800080000001000100010006801840000
+C600:000000081E0821082138210821381E08000800000048004800A8011406620000
+C601:000000081E0821082138210821381E0800080000000003F00408040803F00000
+C602:000000081E0821082138210821381E080008000003F80020002000D003080000
+C603:000000081E0821082138210821381E0800080000004003F8004000A003180000
+C604:000000081E0821082138210821381E080008000003F8000803F8000800080000
+C605:000000081E0821082138210821381E080008000003F8020003F8020003F80000
+C606:000000081E0821082138210821381E080008000000000FF8022002200FF80000
+C607:000000081E0821082138210821381E080008000000800FF803E0041003E00000
+C608:00000000000A000A1E0A210A40BA408A408A213A1E0A000A000A000A000A0000
+C609:000000281E28212821E8212821E81E280028000007F800080008000800080000
+C60A:000000281E28212821E8212821E81E280028000000003EF80208020802080000
+C60B:000000281E28212821E8212821E81E280028000000003E100210022802C40000
+C60C:000000281E28212821E8212821E81E280028002808000800080008000FF80000
+C60D:000000281E28212821E8212821E81E2800280000000020F8201020303ECC0000
+C60E:000000281E28212821E8212821E81E2800280000202021FC207020883E700000
+C60F:000000281E28212821E8212821E81E280028000003F802000200020003F80000
+C610:000000281E28212821E8212821E81E280028000007F8000807F8040007F80000
+C611:000000281E28212821E8212821E81E28002800003EF802083E0820083E080000
+C612:000000281E28212821E8212821E81E28002800003EF802883E8820883EF80000
+C613:000000281E28212821E8212821E81E28002800003E8802883EF820883EF80000
+C614:000000281E28212821E8212821E81E28002800001F0801081F0810141F620000
+C615:000000281E28212821E8212821E81E28002800003EF802803EF820803EF80000
+C616:000000281E28212821E8212821E81E28002800003EFC02483E4820483EFC0000
+C617:000000281E28212821E8212821E81E28002800003E1002FE3E3820443E380000
+C618:000000281E28212821E8212821E81E280028000003F802080208020803F80000
+C619:000000281E28212821E8212821E81E28002800000208020803F8020803F80000
+C61A:000000281E28212821E8212821E81E2800280000110811081F0811141F620000
+C61B:000000281E28212821E8212821E81E2800280000000800080008003400C20000
+C61C:000000281E28212821E8212821E81E28002800000048004800A8011406620000
+C61D:000000281E28212821E8212821E81E2800280000000001F00208020801F00000
+C61E:000000281E28212821E8212821E81E280028000003F80020002000D003080000
+C61F:000000281E28212821E8212821E81E2800280000004003F8004000A003180000
+C620:000000281E28212821E8212821E81E280028000003F8000803F8000800080000
+C621:000000281E28212821E8212821E81E280028000003F8020003F8020003F80000
+C622:000000281E28212821E8212821E81E280028000000000FF8022002200FF80000
+C623:000000281E28212821E8212821E81E280028000000800FF803E0041003E00000
+C624:000007C00820101010101010082007C0000000000100010001007FFC00000000
+C625:000007C008200820082007C0010001007FFC00001FF000100010001000100000
+C626:000007C008200820082007C0010001007FFC000000003EF80208020802080000
+C627:000007C008200820082007C0010001007FFC000000001E100210022802C40000
+C628:000007C008200820082007C0010001007FFC000000001000100010001FF00000
+C629:000007C008200820082007C0010001007FFC0000000020F8201020303ECC0000
+C62A:000007C008200820082007C0010001007FFC0000202021FC207020883E700000
+C62B:000007C008200820082007C0010001007FFC00001FF01000100010001FF00000
+C62C:000007C008200820082007C0010001007FFC00001FF000101FF010001FF00000
+C62D:000007C008200820082007C0010001007FFC00003EF802083E0820083E080000
+C62E:000007C008200820082007C0010001007FFC00003EF802883E8820883EF80000
+C62F:000007C008200820082007C0010001007FFC00003E8802883EF820883EF80000
+C630:000007C008200820082007C0010001007FFC00003E1002103E1020283EC40000
+C631:000007C008200820082007C0010001007FFC00003EF802803EF820803EF80000
+C632:000007C008200820082007C0010001007FFC00003EFC02483E4820483EFC0000
+C633:000007C008200820082007C0010001007FFC00003E2003FC3E7020883E700000
+C634:000007C008200820082007C0010001007FFC00001FF01010101010101FF00000
+C635:000007C008200820082007C0010001007FFC0000101010101FF010101FF00000
+C636:000007C008200820082007C0010001007FFC0000222022203E2022503E880000
+C637:000007C008200820082007C0010001007FFC000000000100010002800C400000
+C638:000007C008200820082007C0010001007FFC00000000024002400DA033100000
+C639:000007C008200820082007C0010001007FFC0000000007C00820082007C00000
+C63A:000007C008200820082007C0010001007FFC0000000007E00080014006200000
+C63B:000007C008200820082007C0010001007FFC0000008007E00080014006200000
+C63C:000007C008200820082007C0010001007FFC00001FF000101FF0001000100000
+C63D:000007C008200820082007C0010001007FFC00001FF010001FF010001FF00000
+C63E:000007C008200820082007C0010001007FFC000000001FF0044004401FF00000
+C63F:000007C008200820082007C0010001007FFC000001001FF007C0082007C00000
+C640:0000001000101F10209040504050405E20901F10041004107FD0001000100000
+C641:000000081F082088208E20881F0804087FE8000007F800080008000800080000
+C642:000000081F082088208E20881F0804087FE8000000003EF80208020802080000
+C643:000000081F082088208E20881F0804087FE8000000001F080108011401620000
+C644:000000081F082088208E20881F0804087FE8000008000800080008000FF80000
+C645:000000081F082088208E20881F0804087FE80000000010F8101010301ECC0000
+C646:000000081F082088208E20881F0804087FE800000808087F081C08220F9C0000
+C647:000000081F082088208E20881F0804087FE8000003F802000200020003F80000
+C648:000000081F082088208E20881F0804087FE8000007F8000807F8040007F80000
+C649:000000081F082088208E20881F0804087FE800003EF802083E0820083E080000
+C64A:000000081F082088208E20881F0804087FE800003EF802883E8820883EF80000
+C64B:000000081F082088208E20881F0804087FE800003E8802883EF820883EF80000
+C64C:000000081F082088208E20881F0804087FE800001F0801081F0810141F620000
+C64D:000000081F082088208E20881F0804087FE800003EF802803EF820803EF80000
+C64E:000000081F082088208E20881F0804087FE800003EFC02483E4820483EFC0000
+C64F:000000081F082088208E20881F0804087FE800001F08017F1F1C10221F1C0000
+C650:000000081F082088208E20881F0804087FE8000003F802080208020803F80000
+C651:000000081F082088208E20881F0804087FE800000208020803F8020803F80000
+C652:000000081F082088208E20881F0804087FE80000110811081F0811141F620000
+C653:000000081F082088208E20881F0804087FE80000001000100010006801840000
+C654:000000081F082088208E20881F0804087FE800000048004800A8011406620000
+C655:000000081F082088208E20881F0804087FE80000000003F00408040803F00000
+C656:000000081F082088208E20881F0804087FE8000003F80020002000D003080000
+C657:000000081F082088208E20881F0804087FE80000004003F8004000A003180000
+C658:000000081F082088208E20881F0804087FE8000003F8000803F8000800080000
+C659:000000081F082088208E20881F0804087FE8000003F8020003F8020003F80000
+C65A:000000081F082088208E20881F0804087FE8000000000FF8022002200FF80000
+C65B:000000081F082088208E20881F0804087FE8000000800FF803E0041003E00000
+C65C:0000001200121F12209240524052405E20921F12041204127FD2001200120000
+C65D:000000281F2820A820B820A81F2804287FA8000007F800080008000800080000
+C65E:000000281F2820A820B820A81F2804287FA8000000003EF80208020802080000
+C65F:000000281F2820A820B820A81F2804287FA8000000001F080108011401620000
+C660:000000281F2820A820B820A81F2804287FA8000008000800080008000FF80000
+C661:000000281F2820A820B820A81F2804287FA80000000010F8101010301ECC0000
+C662:000000281F2820A820B820A81F2804287FA800000808087F081C08220F9C0000
+C663:000000281F2820A820B820A81F2804287FA8000003F802000200020003F80000
+C664:000000281F2820A820B820A81F2804287FA8000007F8000807F8040007F80000
+C665:000000281F2820A820B820A81F2804287FA800003EF802083E0820083E080000
+C666:000000281F2820A820B820A81F2804287FA800003EF802883E8820883EF80000
+C667:000000281F2820A820B820A81F2804287FA800003E8802883EF820883EF80000
+C668:000000281F2820A820B820A81F2804287FA800001F0801081F0810141F620000
+C669:000000281F2820A820B820A81F2804287FA800003EF802803EF820803EF80000
+C66A:000000281F2820A820B820A81F2804287FA800003EFC02483E4820483EFC0000
+C66B:000000281F2820A820B820A81F2804287FA800001F08017F1F1C10221F1C0000
+C66C:000000281F2820A820B820A81F2804287FA8000003F802080208020803F80000
+C66D:000000281F2820A820B820A81F2804287FA800000208020803F8020803F80000
+C66E:000000281F2820A820B820A81F2804287FA80000110811081F0811141F620000
+C66F:000000281F2820A820B820A81F2804287FA80000001000100010006801840000
+C670:000000281F2820A820B820A81F2804287FA800000048004800A8011406620000
+C671:000000281F2820A820B820A81F2804287FA80000000003F00408040803F00000
+C672:000000281F2820A820B820A81F2804287FA8000003F80020002000D003080000
+C673:000000281F2820A820B820A81F2804287FA80000004003F8004000A003180000
+C674:000000281F2820A820B820A81F2804287FA8000003F8000803F8000800080000
+C675:000000281F2820A820B820A81F2804287FA8000003F8020003F8020003F80000
+C676:000000281F2820A820B820A81F2804287FA8000000000FF8022002200FF80000
+C677:000000281F2820A820B820A81F2804287FA8000000800FF803E0041003E00000
+C678:0000000800081F08208840484048404820881F08040804087FE8000800080000
+C679:000000081F082088208820881F0804087FE8000007F800080008000800080000
+C67A:000000081F082088208820881F0804087FE8000000003EF80208020802080000
+C67B:000000081F082088208820881F0804087FE8000000001F080108011401620000
+C67C:000000081F082088208820881F0804087FE8000008000800080008000FF80000
+C67D:000000081F082088208820881F0804087FE80000000010F8101010301ECC0000
+C67E:000000081F082088208820881F0804087FE800000808087F081C08220F9C0000
+C67F:000000081F082088208820881F0804087FE8000003F802000200020003F80000
+C680:000000081F082088208820881F0804087FE8000007F8000807F8040007F80000
+C681:000000081F082088208820881F0804087FE800003EF802083E0820083E080000
+C682:000000081F082088208820881F0804087FE800003EF802883E8820883EF80000
+C683:000000081F082088208820881F0804087FE800003E8802883EF820883EF80000
+C684:000000081F082088208820881F0804087FE800001F0801081F0810141F620000
+C685:000000081F082088208820881F0804087FE800003EF802803EF820803EF80000
+C686:000000081F082088208820881F0804087FE800003EFC02483E4820483EFC0000
+C687:000000081F082088208820881F0804087FE800001F08017F1F1C10221F1C0000
+C688:000000081F082088208820881F0804087FE8000003F802080208020803F80000
+C689:000000081F082088208820881F0804087FE800000208020803F8020803F80000
+C68A:000000081F082088208820881F0804087FE80000110811081F0811141F620000
+C68B:000000081F082088208820881F0804087FE80000001000100010006801840000
+C68C:000000081F082088208820881F0804087FE800000048004800A8011406620000
+C68D:000000081F082088208820881F0804087FE80000000003F00408040803F00000
+C68E:000000081F082088208820881F0804087FE8000003F80020002000D003080000
+C68F:000000081F082088208820881F0804087FE80000004003F8004000A003180000
+C690:000000081F082088208820881F0804087FE8000003F8000803F8000800080000
+C691:000000081F082088208820881F0804087FE8000003F8020003F8020003F80000
+C692:000000081F082088208820881F0804087FE8000000000FF8022002200FF80000
+C693:000000081F082088208820881F0804087FE8000000800FF803E0041003E00000
+C694:000007C00820101010101010082007C0000004400440044004407FFC00000000
+C695:000007C008200820082007C0044004407FFC00001FF000100010001000100000
+C696:000007C008200820082007C0044004407FFC000000003EF80208020802080000
+C697:000007C008200820082007C0044004407FFC000000001E100210022802C40000
+C698:000007C008200820082007C0044004407FFC000000001000100010001FF00000
+C699:000007C008200820082007C0044004407FFC0000000020F8201020303ECC0000
+C69A:000007C008200820082007C0044004407FFC0000202021FC207020883E700000
+C69B:000007C008200820082007C0044004407FFC00001FF01000100010001FF00000
+C69C:000007C008200820082007C0044004407FFC00001FF000101FF010001FF00000
+C69D:000007C008200820082007C0044004407FFC00003EF802083E0820083E080000
+C69E:000007C008200820082007C0044004407FFC00003EF802883E8820883EF80000
+C69F:000007C008200820082007C0044004407FFC00003E8802883EF820883EF80000
+C6A0:000007C008200820082007C0044004407FFC00003E1002103E1020283EC40000
+C6A1:000007C008200820082007C0044004407FFC00003EF802803EF820803EF80000
+C6A2:000007C008200820082007C0044004407FFC00003EFC02483E4820483EFC0000
+C6A3:000007C008200820082007C0044004407FFC00003E2003FC3E7020883E700000
+C6A4:000007C008200820082007C0044004407FFC00001FF01010101010101FF00000
+C6A5:000007C008200820082007C0044004407FFC0000101010101FF010101FF00000
+C6A6:000007C008200820082007C0044004407FFC0000222022203E2022503E880000
+C6A7:000007C008200820082007C0044004407FFC000000000100010002800C400000
+C6A8:000007C008200820082007C0044004407FFC00000000024002400DA033100000
+C6A9:000007C008200820082007C0044004407FFC0000000007C00820082007C00000
+C6AA:000007C008200820082007C0044004407FFC0000000007E00080014006200000
+C6AB:000007C008200820082007C0044004407FFC0000008007E00080014006200000
+C6AC:000007C008200820082007C0044004407FFC00001FF000101FF0001000100000
+C6AD:000007C008200820082007C0044004407FFC00001FF010001FF010001FF00000
+C6AE:000007C008200820082007C0044004407FFC000000001FF0044004401FF00000
+C6AF:000007C008200820082007C0044004407FFC000001001FF007C0082007C00000
+C6B0:0000000007C00820101010101010082007C000003FF801000100010001000000
+C6B1:000007C008200820082007C000007FFC010001001FF000100010001000100000
+C6B2:000007C008200820082007C000007FFC0100010000003EF80208020802080000
+C6B3:000007C008200820082007C000007FFC0100010000001E100210022802C40000
+C6B4:000007C008200820082007C0000000007FFC010001001100100010001FF00000
+C6B5:000007C008200820082007C000007FFC01000100000020F8201020303ECC0000
+C6B6:000007C008200820082007C000007FFC01000100202021FC207020883E700000
+C6B7:000007C008200820082007C000007FFC010001001FF01000100010001FF00000
+C6B8:000007C008200820082007C000007FFC010001001FF000101FF010001FF00000
+C6B9:000007C008200820082007C000007FFC010001003EF802083E0820083E080000
+C6BA:000007C008200820082007C000007FFC010001003EF802883E8820883EF80000
+C6BB:000007C008200820082007C000007FFC010001003E8802883EF820883EF80000
+C6BC:000007C008200820082007C000007FFC010001003E1002103E1020283EC40000
+C6BD:000007C008200820082007C000007FFC010001003EF802803EF820803EF80000
+C6BE:000007C008200820082007C000007FFC010001003EFC02483E4820483EFC0000
+C6BF:000007C008200820082007C000007FFC010001003E2003FC3E7020883E700000
+C6C0:000007C008200820082007C000007FFC010001001FF01010101010101FF00000
+C6C1:000007C008200820082007C000007FFC01000100101010101FF010101FF00000
+C6C2:000007C008200820082007C000007FFC01000100222022203E2022503E880000
+C6C3:000007C008200820082007C000007FFC0100010000000100010002800C400000
+C6C4:000007C008200820082007C000007FFC010001000000024002400DA033100000
+C6C5:000007C008200820082007C000007FFC01000100000007C00820082007C00000
+C6C6:000007C008200820082007C000007FFC01000100000007E00080014006200000
+C6C7:000007C008200820082007C000007FFC01000100008007E00080014006200000
+C6C8:000007C008200820082007C000007FFC010001001FF000101FF0001000100000
+C6C9:000007C008200820082007C000007FFC010001001FF010001FF010001FF00000
+C6CA:000007C008200820082007C000007FFC0100010000001FF0044004401FF00000
+C6CB:000007C008200820082007C000007FFC0100010001001FF007C0082007C00000
+C6CC:000000081F08208840484048404820881F0800087FE8040804F8040804080000
+C6CD:1F082088208820881F0800087FE8027802080000000007F80008000800080000
+C6CE:1F082088208820881F0800087FE802780208000000003EF80208020802080000
+C6CF:1F082088208820881F0800087FE802780208000000001F080108011401620000
+C6D0:1F082088208820881F08000800087FE80278020802081000100010001FF80000
+C6D1:1F082088208820881F0800087FE8027802080000000020F8201020303ECC0000
+C6D2:1F082088208820881F0800087FE8027802080000202021FC207020883E700000
+C6D3:1F082088208820881F0800087FE802780208000003F802000200020003F80000
+C6D4:1F082088208820881F0800087FE802780208000007F8000807F8040007F80000
+C6D5:1F082088208820881F0800087FE80278020800003EF802083E0820083E080000
+C6D6:1F082088208820881F0800087FE80278020800003EF802883E8820883EF80000
+C6D7:1F082088208820881F0800087FE80278020800003E8802883EF820883EF80000
+C6D8:1F082088208820881F0800087FE80278020800000F8800880F8808140FA20000
+C6D9:1F082088208820881F0800087FE80278020800003EF802803EF820803EF80000
+C6DA:1F082088208820881F0800087FE80278020800003EFC02483E4820483EFC0000
+C6DB:1F082088208820881F0800087FE80278020800003E1002FE3E3820443E380000
+C6DC:1F082088208820881F0800087FE802780208000003F802080208020803F80000
+C6DD:1F082088208820881F0800087FE80278020800000208020803F8020803F80000
+C6DE:1F082088208820881F0800087FE8027802080000210821083F0821143F620000
+C6DF:1F082088208820881F0800087FE8027802080000001000100010006801840000
+C6E0:1F082088208820881F0800087FE80278020800000048004800A8011406620000
+C6E1:1F082088208820881F0800087FE8027802080000000003F00408040803F00000
+C6E2:1F082088208820881F0800087FE802780208000003F80020002000D003080000
+C6E3:1F082088208820881F0800087FE8027802080000004003F8004000A003180000
+C6E4:1F082088208820881F0800087FE802780208000003F8000803F8000800080000
+C6E5:1F082088208820881F0800087FE802780208000003F8020003F8020003F80000
+C6E6:1F082088208820881F0800087FE802780208000000000FF8022002200FF80000
+C6E7:1F082088208820881F0800087FE802780208000000800FF803E0041003E00000
+C6E8:0000000A1F0A208A404A404A404A208A1F0A000A7FEA040A047A040A040A0000
+C6E9:1F2820A820A820A81F2800287FA805E804280000000007F80008000800080000
+C6EA:1F2820A820A820A81F2800287FA805E80428000000003EF80208020802080000
+C6EB:1F2820A820A820A81F2800287FA805E80428000000001F080108011401620000
+C6EC:1F2820A820A820A81F28002800287FA8042805E804281428100010001FF80000
+C6ED:1F2820A820A820A81F2800287FA805E804280000000020F8201020303ECC0000
+C6EE:1F2820A820A820A81F2800287FA805E804280000202021FC207020883E700000
+C6EF:1F2820A820A820A81F2800287FA805E80428000003F802000200020003F80000
+C6F0:1F2820A820A820A81F2800287FA805E80428000007F8000807F8040007F80000
+C6F1:1F2820A820A820A81F2800287FA805E8042800003EF802083E0820083E080000
+C6F2:1F2820A820A820A81F2800287FA805E8042800003EF802883E8820883EF80000
+C6F3:1F2820A820A820A81F2800287FA805E8042800003E8802883EF820883EF80000
+C6F4:1F2820A820A820A81F2800287FA805E8042800000F8800880F8808140FA20000
+C6F5:1F2820A820A820A81F2800287FA805E8042800003EF802803EF820803EF80000
+C6F6:1F2820A820A820A81F2800287FA805E8042800003EFC02483E4820483EFC0000
+C6F7:1F2820A820A820A81F2800287FA805E8042800003E1002FE3E3820443E380000
+C6F8:1F2820A820A820A81F2800287FA805E80428000003F802080208020803F80000
+C6F9:1F2820A820A820A81F2800287FA805E8042800000208020803F8020803F80000
+C6FA:1F2820A820A820A81F2800287FA805E804280000210821083F0821143F620000
+C6FB:1F2820A820A820A81F2800287FA805E804280000001000100010006801840000
+C6FC:1F2820A820A820A81F2800287FA805E8042800000048004800A8011406620000
+C6FD:1F2820A820A820A81F2800287FA805E804280000000003F00408040803F00000
+C6FE:1F2820A820A820A81F2800287FA805E80428000003F80020002000D003080000
+C6FF:1F2820A820A820A81F2800287FA805E804280000004003F8004000A003180000
+C700:1F2820A820A820A81F2800287FA805E80428000003F8000803F8000800080000
+C701:1F2820A820A820A81F2800287FA805E80428000003F8020003F8020003F80000
+C702:1F2820A820A820A81F2800287FA805E80428000000000FF8022002200FF80000
+C703:1F2820A820A820A81F2800287FA805E80428000000800FF803E0041003E00000
+C704:000000081F08208840484048404820881F0800087FE804080408040804080000
+C705:1F082088208820881F0800087FE8020802000000000007F80008000800080000
+C706:1F082088208820881F0800087FE802080200000000003EF80208020802080000
+C707:1F082088208820881F0800087FE802080200000000001F080108011401620000
+C708:1F082088208820881F08000800087FE80208020802081008100010001FF80000
+C709:1F082088208820881F0800087FE8020802000000000020F8201020303ECC0000
+C70A:1F082088208820881F0800087FE8020802000000202021FC207020883E700000
+C70B:1F082088208820881F0800087FE802080200000003F802000200020003F80000
+C70C:1F082088208820881F0800087FE802080200000007F8000807F8040007F80000
+C70D:1F082088208820881F0800087FE80208020000003EF802083E0820083E080000
+C70E:1F082088208820881F0800087FE80208020000003EF802883E8820883EF80000
+C70F:1F082088208820881F0800087FE80208020000003E8802883EF820883EF80000
+C710:1F082088208820881F0800087FE80208020000000F8800880F8808140FA20000
+C711:1F082088208820881F0800087FE80208020000003EF802803EF820803EF80000
+C712:1F082088208820881F0800087FE80208020000003EFC02483E4820483EFC0000
+C713:1F082088208820881F0800087FE80208020000003E1002FE3E3820443E380000
+C714:1F082088208820881F0800087FE802080200000003F802080208020803F80000
+C715:1F082088208820881F0800087FE80208020000000208020803F8020803F80000
+C716:1F082088208820881F0800087FE8020802000000210821083F0821143F620000
+C717:1F082088208820881F0800087FE8020802000000001000100010006801840000
+C718:1F082088208820881F0800087FE80208020000000048004800A8011406620000
+C719:1F082088208820881F0800087FE8020802000000000003F00408040803F00000
+C71A:1F082088208820881F0800087FE802080200000003F80020002000D003080000
+C71B:1F082088208820881F0800087FE8020802000000004003F8004000A003180000
+C71C:1F082088208820881F0800087FE802080200000003F8000803F8000800080000
+C71D:1F082088208820881F0800087FE802080200000003F8020003F8020003F80000
+C71E:1F082088208820881F0800087FE802080200000000000FF8022002200FF80000
+C71F:1F082088208820881F0800087FE802080200000000800FF803E0041003E00000
+C720:0000000007C00820101010101010082007C000007FFC04400440044004400000
+C721:000007C008200820082007C000007FFC044004401FF000100010001000100000
+C722:000007C008200820082007C000007FFC0440044000003EF80208020802080000
+C723:000007C008200820082007C000007FFC0440044000001E100210022802C40000
+C724:000007C008200820082007C0000000007FFC044004401440100010001FF00000
+C725:000007C008200820082007C000007FFC04400440000020F8201020303ECC0000
+C726:000007C008200820082007C000007FFC04400440202021FC207020883E700000
+C727:000007C008200820082007C000007FFC044004401FF01000100010001FF00000
+C728:000007C008200820082007C000007FFC044004401FF000101FF010001FF00000
+C729:000007C008200820082007C000007FFC044004403EF802083E0820083E080000
+C72A:000007C008200820082007C000007FFC044004403EF802883E8820883EF80000
+C72B:000007C008200820082007C000007FFC044004403E8802883EF820883EF80000
+C72C:000007C008200820082007C000007FFC044004403E1002103E1020283EC40000
+C72D:000007C008200820082007C000007FFC044004403EF802803EF820803EF80000
+C72E:000007C008200820082007C000007FFC044004403EFC02483E4820483EFC0000
+C72F:000007C008200820082007C000007FFC044004403E2003FC3E7020883E700000
+C730:000007C008200820082007C000007FFC044004401FF01010101010101FF00000
+C731:000007C008200820082007C000007FFC04400440101010101FF010101FF00000
+C732:000007C008200820082007C000007FFC04400440222022203E2022503E880000
+C733:000007C008200820082007C000007FFC0440044000000100010002800C400000
+C734:000007C008200820082007C000007FFC044004400000024002400DA033100000
+C735:000007C008200820082007C000007FFC04400440000007C00820082007C00000
+C736:000007C008200820082007C000007FFC04400440000007E00080014006200000
+C737:000007C008200820082007C000007FFC04400440008007E00080014006200000
+C738:000007C008200820082007C000007FFC044004401FF000101FF0001000100000
+C739:000007C008200820082007C000007FFC044004401FF010001FF010001FF00000
+C73A:000007C008200820082007C000007FFC0440044000001FF0044004401FF00000
+C73B:000007C008200820082007C000007FFC0440044001001FF007C0082007C00000
+C73C:000007C00820101010101010082007C00000000000007FFC0000000000000000
+C73D:000007C008200820082007C0000000007FFC00001FF000100010001000100000
+C73E:000007C008200820082007C0000000007FFC000000003EF80208020802080000
+C73F:000007C008200820082007C0000000007FFC000000001E100210022802C40000
+C740:000007C008200820082007C0000000007FFC000000001000100010001FF00000
+C741:000007C008200820082007C0000000007FFC0000000020F8201020303ECC0000
+C742:000007C008200820082007C0000000007FFC0000202021FC207020883E700000
+C743:000007C008200820082007C0000000007FFC00001FF01000100010001FF00000
+C744:000007C008200820082007C0000000007FFC00001FF000101FF010001FF00000
+C745:000007C008200820082007C0000000007FFC00003EF802083E0820083E080000
+C746:000007C008200820082007C0000000007FFC00003EF802883E8820883EF80000
+C747:000007C008200820082007C0000000007FFC00003E8802883EF820883EF80000
+C748:000007C008200820082007C0000000007FFC00003E1002103E1020283EC40000
+C749:000007C008200820082007C0000000007FFC00003EF802803EF820803EF80000
+C74A:000007C008200820082007C0000000007FFC00003EFC02483E4820483EFC0000
+C74B:000007C008200820082007C0000000007FFC00003E2003FC3E7020883E700000
+C74C:000007C008200820082007C0000000007FFC00001FF01010101010101FF00000
+C74D:000007C008200820082007C0000000007FFC0000101010101FF010101FF00000
+C74E:000007C008200820082007C0000000007FFC0000222022203E2022503E880000
+C74F:000007C008200820082007C0000000007FFC000000000100010002800C400000
+C750:000007C008200820082007C0000000007FFC00000000024002400DA033100000
+C751:000007C008200820082007C0000000007FFC0000000007C00820082007C00000
+C752:000007C008200820082007C0000000007FFC0000000007E00080014006200000
+C753:000007C008200820082007C0000000007FFC0000008007E00080014006200000
+C754:000007C008200820082007C0000000007FFC00001FF000101FF0001000100000
+C755:000007C008200820082007C0000000007FFC00001FF010001FF010001FF00000
+C756:000007C008200820082007C0000000007FFC000000001FF0044004401FF00000
+C757:000007C008200820082007C0000000007FFC000001001FF007C0082007C00000
+C758:0000000800081F08208840484048404820881F0800087FE80008000800080000
+C759:000000081F082088208820881F0800087FE8000007F800080008000800080000
+C75A:000000081F082088208820881F0800087FE8000000003EF80208020802080000
+C75B:000000081F082088208820881F0800087FE8000000001F080108011401620000
+C75C:000000081F082088208820881F0800087FE8000008000800080008000FF80000
+C75D:000000081F082088208820881F0800087FE80000000010F8101010301ECC0000
+C75E:000000081F082088208820881F0800087FE800000808087F081C08220F9C0000
+C75F:000000081F082088208820881F0800087FE8000003F802000200020003F80000
+C760:000000081F082088208820881F0800087FE8000007F8000807F8040007F80000
+C761:000000081F082088208820881F0800087FE800003EF802083E0820083E080000
+C762:000000081F082088208820881F0800087FE800003EF802883E8820883EF80000
+C763:000000081F082088208820881F0800087FE800003E8802883EF820883EF80000
+C764:000000081F082088208820881F0800087FE800001F0801081F0810141F620000
+C765:000000081F082088208820881F0800087FE800003EF802803EF820803EF80000
+C766:000000081F082088208820881F0800087FE800003EFC02483E4820483EFC0000
+C767:000000081F082088208820881F0800087FE800001F08017F1F1C10221F1C0000
+C768:000000081F082088208820881F0800087FE8000003F802080208020803F80000
+C769:000000081F082088208820881F0800087FE800000208020803F8020803F80000
+C76A:000000081F082088208820881F0800087FE80000110811081F0811141F620000
+C76B:000000081F082088208820881F0800087FE80000001000100010006801840000
+C76C:000000081F082088208820881F0800087FE800000048004800A8011406620000
+C76D:000000081F082088208820881F0800087FE80000000003F00408040803F00000
+C76E:000000081F082088208820881F0800087FE8000003F80020002000D003080000
+C76F:000000081F082088208820881F0800087FE80000004003F8004000A003180000
+C770:000000081F082088208820881F0800087FE8000003F8000803F8000800080000
+C771:000000081F082088208820881F0800087FE8000003F8020003F8020003F80000
+C772:000000081F082088208820881F0800087FE8000000000FF8022002200FF80000
+C773:000000081F082088208820881F0800087FE8000000800FF803E0041003E00000
+C774:00000000000800081E08210840884088408821081E0800080008000800080000
+C775:000000081E0821082108210821081E0800080000000007F80008000800080000
+C776:000000081E0821082108210821081E080008000000003EF80208020802080000
+C777:000000081E0821082108210821081E080008000000001F080108011401620000
+C778:000000081E0821082108210821081E080008000800001000100010001FF80000
+C779:000000081E0821082108210821081E0800080000000020F8201020303ECC0000
+C77A:000000081E0821082108210821081E0800080000202021FC207020883E700000
+C77B:000000081E0821082108210821081E080008000003F802000200020003F80000
+C77C:000000081E0821082108210821081E080008000007F8000807F8040007F80000
+C77D:000000081E0821082108210821081E08000800003EF802083E0820083E080000
+C77E:000000081E0821082108210821081E08000800003EF802883E8820883EF80000
+C77F:000000081E0821082108210821081E08000800003E8802883EF820883EF80000
+C780:000000081E0821082108210821081E08000800000F8800880F8808140FA20000
+C781:000000081E0821082108210821081E08000800003EF802803EF820803EF80000
+C782:000000081E0821082108210821081E08000800003EFC02483E4820483EFC0000
+C783:000000081E0821082108210821081E08000800003E1002FE3E3820443E380000
+C784:000000081E0821082108210821081E080008000003F802080208020803F80000
+C785:000000081E0821082108210821081E08000800000208020803F8020803F80000
+C786:000000081E0821082108210821081E0800080000210821083F0821143F620000
+C787:000000081E0821082108210821081E0800080000001000100010006801840000
+C788:000000081E0821082108210821081E08000800000048004800A8011406620000
+C789:000000081E0821082108210821081E0800080000000003F00408040803F00000
+C78A:000000081E0821082108210821081E080008000003F80020002000D003080000
+C78B:000000081E0821082108210821081E0800080000004003F8004000A003180000
+C78C:000000081E0821082108210821081E080008000003F8000803F8000800080000
+C78D:000000081E0821082108210821081E080008000003F8020003F8020003F80000
+C78E:000000081E0821082108210821081E080008000000000FF8022002200FF80000
+C78F:000000081E0821082108210821081E080008000000800FF803E0041003E00000
+C790:00000000001000103F9001100110021E06100910309000100010001000100000
+C791:0000000800087E080408040E1A0861080008000007F800080008000800080000
+C792:0000000800087E080408040E1A0861080008000000003EF80208020802080000
+C793:0000000800087E080408040E1A0861080008000000001F080108011401620000
+C794:0000000800087E080408040E1A0861080008000808000800080008000FF80000
+C795:0000000800087E080408040E1A08610800080000000010F8101010301ECC0000
+C796:0000000800087E080408040E1A086108000800000808087F081C08220F9C0000
+C797:0000000800087E080408040E1A0861080008000003F802000200020003F80000
+C798:0000000800087E080408040E1A0861080008000007F8000807F8040007F80000
+C799:0000000800087E080408040E1A086108000800003EF802083E0820083E080000
+C79A:0000000800087E080408040E1A086108000800003EF802883E8820883EF80000
+C79B:0000000800087E080408040E1A086108000800003E8802883EF820883EF80000
+C79C:0000000800087E080408040E1A086108000800001F0801081F0810141F620000
+C79D:0000000800087E080408040E1A086108000800003EF802803EF820803EF80000
+C79E:0000000800087E080408040E1A086108000800003EFC02483E4820483EFC0000
+C79F:0000000800087E080408040E1A086108000800001F08017F1F1C10221F1C0000
+C7A0:0000000800087E080408040E1A0861080008000003F802080208020803F80000
+C7A1:0000000800087E080408040E1A086108000800000208020803F8020803F80000
+C7A2:0000000800087E080408040E1A08610800080000110811081F0811141F620000
+C7A3:0000000800087E080408040E1A08610800080000001000100010006801840000
+C7A4:0000000800087E080408040E1A086108000800000048004800A8011406620000
+C7A5:0000000800087E080408040E1A08610800080000000003F00408040803F00000
+C7A6:0000000800087E080408040E1A0861080008000003F80020002000D003080000
+C7A7:0000000800087E080408040E1A08610800080000004003F8004000A003180000
+C7A8:0000000800087E080408040E1A0861080008000003F8000803F8000800080000
+C7A9:0000000800087E080408040E1A0861080008000003F8020003F8020003F80000
+C7AA:0000000800087E080408040E1A0861080008000000000FF8022002200FF80000
+C7AB:0000000800087E080408040E1A0861080008000000800FF803E0041003E00000
+C7AC:00000000001200123F9201120112021E06120912309200120012001200120000
+C7AD:0000002800287E28042804381A2861280028000007F800080008000800080000
+C7AE:0000002800287E28042804381A2861280028000000003EF80208020802080000
+C7AF:0000002800287E28042804381A2861280028000000003E100210022802C40000
+C7B0:0000002800287E28042804381A2861280028002808000800080008000FF80000
+C7B1:0000002800287E28042804381A28612800280000000020F8201020303ECC0000
+C7B2:0000002800287E28042804381A28612800280000202021FC207020883E700000
+C7B3:0000002800287E28042804381A2861280028000003F802000200020003F80000
+C7B4:0000002800287E28042804381A2861280028000007F8000807F8040007F80000
+C7B5:0000002800287E28042804381A286128002800003EF802083E0820083E080000
+C7B6:0000002800287E28042804381A286128002800003EF802883E8820883EF80000
+C7B7:0000002800287E28042804381A286128002800003E8802883EF820883EF80000
+C7B8:0000002800287E28042804381A286128002800001F0801081F0810141F620000
+C7B9:0000002800287E28042804381A286128002800003EF802803EF820803EF80000
+C7BA:0000002800287E28042804381A286128002800003EFC02483E4820483EFC0000
+C7BB:0000002800287E28042804381A286128002800003E1002FE3E3820443E380000
+C7BC:0000002800287E28042804381A2861280028000003F802080208020803F80000
+C7BD:0000002800287E28042804381A286128002800000208020803F8020803F80000
+C7BE:0000002800287E28042804381A28612800280000110811081F0811141F620000
+C7BF:0000002800287E28042804381A28612800280000000800080008003400C20000
+C7C0:0000002800287E28042804381A286128002800000048004800A8011406620000
+C7C1:0000002800287E28042804381A28612800280000000001F00208020801F00000
+C7C2:0000002800287E28042804381A2861280028000003F80020002000D003080000
+C7C3:0000002800287E28042804381A28612800280000004003F8004000A003180000
+C7C4:0000002800287E28042804381A2861280028000003F8000803F8000800080000
+C7C5:0000002800287E28042804381A2861280028000003F8020003F8020003F80000
+C7C6:0000002800287E28042804381A2861280028000000000FF8022002200FF80000
+C7C7:0000002800287E28042804381A2861280028000000800FF803E0041003E00000
+C7C8:00000000001000103F900110011E02100610091E309000100010001000100000
+C7C9:0000000800087E08040E04081A0E61080008000007F800080008000800080000
+C7CA:0000000800087E08040E04081A0E61080008000000003EF80208020802080000
+C7CB:0000000800087E08040E04081A0E61080008000000001F080108011401620000
+C7CC:0000000800087E08040E04081A0E61080008000008000800080008000FF80000
+C7CD:0000000800087E08040E04081A0E610800080000000010F8101010301ECC0000
+C7CE:0000000800087E08040E04081A0E6108000800000808087F081C08220F9C0000
+C7CF:0000000800087E08040E04081A0E61080008000003F802000200020003F80000
+C7D0:0000000800087E08040E04081A0E61080008000007F8000807F8040007F80000
+C7D1:0000000800087E08040E04081A0E6108000800003EF802083E0820083E080000
+C7D2:0000000800087E08040E04081A0E6108000800003EF802883E8820883EF80000
+C7D3:0000000800087E08040E04081A0E6108000800003E8802883EF820883EF80000
+C7D4:0000000800087E08040E04081A0E6108000800001F0801081F0810141F620000
+C7D5:0000000800087E08040E04081A0E6108000800003EF802803EF820803EF80000
+C7D6:0000000800087E08040E04081A0E6108000800003EFC02483E4820483EFC0000
+C7D7:0000000800087E08040E04081A0E6108000800001F08017F1F1C10221F1C0000
+C7D8:0000000800087E08040E04081A0E61080008000003F802080208020803F80000
+C7D9:0000000800087E08040E04081A0E6108000800000208020803F8020803F80000
+C7DA:0000000800087E08040E04081A0E610800080000110811081F0811141F620000
+C7DB:0000000800087E08040E04081A0E610800080000001000100010006801840000
+C7DC:0000000800087E08040E04081A0E6108000800000048004800A8011406620000
+C7DD:0000000800087E08040E04081A0E610800080000000003F00408040803F00000
+C7DE:0000000800087E08040E04081A0E61080008000003F80020002000D003080000
+C7DF:0000000800087E08040E04081A0E610800080000004003F8004000A003180000
+C7E0:0000000800087E08040E04081A0E61080008000003F8000803F8000800080000
+C7E1:0000000800087E08040E04081A0E61080008000003F8020003F8020003F80000
+C7E2:0000000800087E08040E04081A0E61080008000000000FF8022002200FF80000
+C7E3:0000000800087E08040E04081A0E61080008000000800FF803E0041003E00000
+C7E4:00000000001200123F920112011E02120612091E309200120012001200120000
+C7E5:0000002800287E28043804281A3861280028000007F800080008000800080000
+C7E6:0000002800287E28043804281A3861280028000000003EF80208020802080000
+C7E7:0000002800287E28043804281A3861280028000000003E100210022802C40000
+C7E8:0000002800287E28043804281A3861280028002808000800080008000FF80000
+C7E9:0000002800287E28043804281A38612800280000000020F8201020303ECC0000
+C7EA:0000002800287E28043804281A38612800280000202021FC207020883E700000
+C7EB:0000002800287E28043804281A3861280028000003F802000200020003F80000
+C7EC:0000002800287E28043804281A3861280028000007F8000807F8040007F80000
+C7ED:0000002800287E28043804281A386128002800003EF802083E0820083E080000
+C7EE:0000002800287E28043804281A386128002800003EF802883E8820883EF80000
+C7EF:0000002800287E28043804281A386128002800003E8802883EF820883EF80000
+C7F0:0000002800287E28043804281A386128002800001F0801081F0810141F620000
+C7F1:0000002800287E28043804281A386128002800003EF802803EF820803EF80000
+C7F2:0000002800287E28043804281A386128002800003EFC02483E4820483EFC0000
+C7F3:0000002800287E28043804281A386128002800003E1002FE3E3820443E380000
+C7F4:0000002800287E28043804281A3861280028000003F802080208020803F80000
+C7F5:0000002800287E28043804281A386128002800000208020803F8020803F80000
+C7F6:0000002800287E28043804281A38612800280000110811081F0811141F620000
+C7F7:0000002800287E28043804281A38612800280000000800080008003400C20000
+C7F8:0000002800287E28043804281A386128002800000048004800A8011406620000
+C7F9:0000002800287E28043804281A38612800280000000001F00208020801F00000
+C7FA:0000002800287E28043804281A3861280028000003F80020002000D003080000
+C7FB:0000002800287E28043804281A38612800280000004003F8004000A003180000
+C7FC:0000002800287E28043804281A3861280028000003F8000803F8000800080000
+C7FD:0000002800287E28043804281A3861280028000003F8020003F8020003F80000
+C7FE:0000002800287E28043804281A3861280028000000000FF8022002200FF80000
+C7FF:0000002800287E28043804281A3861280028000000800FF803E0041003E00000
+C800:00000000000200023F8201020102021E06020902308200020002000200020000
+C801:0000000800087E08040804381A08610800080000000007F80008000800080000
+C802:0000000800087E08040804381A0861080008000000003EF80208020802080000
+C803:0000000800087E08040804381A0861080008000000001F080108011401620000
+C804:0000000800087E08040804381A0861080008000000001000100010001FF80000
+C805:0000000800087E08040804381A08610800080000000020F8201020303ECC0000
+C806:0000000800087E08040804381A08610800080000202021FC207020883E700000
+C807:0000000800087E08040804381A0861080008000003F802000200020003F80000
+C808:0000000800087E08040804381A0861080008000007F8000807F8040007F80000
+C809:0000000800087E08040804381A086108000800003EF802083E0820083E080000
+C80A:0000000800087E08040804381A086108000800003EF802883E8820883EF80000
+C80B:0000000800087E08040804381A086108000800003E8802883EF820883EF80000
+C80C:0000000800087E08040804381A086108000800000F8800880F8808140FA20000
+C80D:0000000800087E08040804381A086108000800003EF802803EF820803EF80000
+C80E:0000000800087E08040804381A086108000800003EFC02483E4820483EFC0000
+C80F:0000000800087E08040804381A086108000800003E1002FE3E3820443E380000
+C810:0000000800087E08040804381A0861080008000003F802080208020803F80000
+C811:0000000800087E08040804381A086108000800000208020803F8020803F80000
+C812:0000000800087E08040804381A08610800080000210821083F0821143F620000
+C813:0000000800087E08040804381A08610800080000001000100010006801840000
+C814:0000000800087E08040804381A086108000800000048004800A8011406620000
+C815:0000000800087E08040804381A08610800080000000003F00408040803F00000
+C816:0000000800087E08040804381A0861080008000003F80020002000D003080000
+C817:0000000800087E08040804381A08610800080000004003F8004000A003180000
+C818:0000000800087E08040804381A0861080008000003F8000803F8000800080000
+C819:0000000800087E08040804381A0861080008000003F8020003F8020003F80000
+C81A:0000000800087E08040804381A0861080008000000000FF8022002200FF80000
+C81B:0000000800087E08040804381A0861080008000000800FF803E0041003E00000
+C81C:00000000000A000A3F8A010A010A023A060A090A308A000A000A000A000A0000
+C81D:0000002800287E28042804E81A2861280028000007F800080008000800080000
+C81E:0000002800287E28042804E81A2861280028000000003EF80208020802080000
+C81F:0000002800287E28042804E81A2861280028000000003E100210022802C40000
+C820:0000002800287E28042804E81A2861280028000008000800080008000FF80000
+C821:0000002800287E28042804E81A28612800280000000020F8201020303ECC0000
+C822:0000002800287E28042804E81A28612800280000202021FC207020883E700000
+C823:0000002800287E28042804E81A2861280028000003F802000200020003F80000
+C824:0000002800287E28042804E81A2861280028000007F8000807F8040007F80000
+C825:0000002800287E28042804E81A286128002800003EF802083E0820083E080000
+C826:0000002800287E28042804E81A286128002800003EF802883E8820883EF80000
+C827:0000002800287E28042804E81A286128002800003E8802883EF820883EF80000
+C828:0000002800287E28042804E81A286128002800001F0801081F0810141F620000
+C829:0000002800287E28042804E81A286128002800003EF802803EF820803EF80000
+C82A:0000002800287E28042804E81A286128002800003EFC02483E4820483EFC0000
+C82B:0000002800287E28042804E81A286128002800003E1002FE3E3820443E380000
+C82C:0000002800287E28042804E81A2861280028000003F802080208020803F80000
+C82D:0000002800287E28042804E81A286128002800000208020803F8020803F80000
+C82E:0000002800287E28042804E81A28612800280000110811081F0811141F620000
+C82F:0000002800287E28042804E81A28612800280000000800080008003400C20000
+C830:0000002800287E28042804E81A286128002800000048004800A8011406620000
+C831:0000002800287E28042804E81A28612800280000000001F00208020801F00000
+C832:0000002800287E28042804E81A2861280028000003F80020002000D003080000
+C833:0000002800287E28042804E81A28612800280000004003F8004000A003180000
+C834:0000002800287E28042804E81A2861280028000003F8000803F8000800080000
+C835:0000002800287E28042804E81A2861280028000003F8020003F8020003F80000
+C836:0000002800287E28042804E81A2861280028000000000FF8022002200FF80000
+C837:0000002800287E28042804E81A2861280028000000800FF803E0041003E00000
+C838:00000000000200023F820102011E02020602091E308200020002000200020000
+C839:0000000800087E08043804081A38610800080000000007F80008000800080000
+C83A:0000000800087E08043804081A3861080008000000003EF80208020802080000
+C83B:0000000800087E08043804081A3861080008000000001F080108011401620000
+C83C:0000000800087E08043804081A3861080008000800001000100010001FF80000
+C83D:0000000800087E08043804081A38610800080000000020F8201020303ECC0000
+C83E:0000000800087E08043804081A38610800080000202021FC207020883E700000
+C83F:0000000800087E08043804081A3861080008000003F802000200020003F80000
+C840:0000000800087E08043804081A3861080008000007F8000807F8040007F80000
+C841:0000000800087E08043804081A386108000800003EF802083E0820083E080000
+C842:0000000800087E08043804081A386108000800003EF802883E8820883EF80000
+C843:0000000800087E08043804081A386108000800003E8802883EF820883EF80000
+C844:0000000800087E08043804081A386108000800000F8800880F8808140FA20000
+C845:0000000800087E08043804081A386108000800003EF802803EF820803EF80000
+C846:0000000800087E08043804081A386108000800003EFC02483E4820483EFC0000
+C847:0000000800087E08043804081A386108000800003E1002FE3E3820443E380000
+C848:0000000800087E08043804081A3861080008000003F802080208020803F80000
+C849:0000000800087E08043804081A386108000800000208020803F8020803F80000
+C84A:0000000800087E08043804081A38610800080000210821083F0821143F620000
+C84B:0000000800087E08043804081A38610800080000001000100010006801840000
+C84C:0000000800087E08043804081A386108000800000048004800A8011406620000
+C84D:0000000800087E08043804081A38610800080000000003F00408040803F00000
+C84E:0000000800087E08043804081A3861080008000003F80020002000D003080000
+C84F:0000000800087E08043804081A38610800080000004003F8004000A003180000
+C850:0000000800087E08043804081A3861080008000003F8000803F8000800080000
+C851:0000000800087E08043804081A3861080008000003F8020003F8020003F80000
+C852:0000000800087E08043804081A3861080008000000000FF8022002200FF80000
+C853:0000000800087E08043804081A3861080008000000800FF803E0041003E00000
+C854:00000000000A000A3F8A010A013A020A060A093A308A000A000A000A000A0000
+C855:0000002800287E2804E804281AE861280028000007F800080008000800080000
+C856:0000002800287E2804E804281AE861280028000000003EF80208020802080000
+C857:0000002800287E2804E804281AE861280028000000003E100210022802C40000
+C858:0000002800287E2804E804281AE861280028002808000800080008000FF80000
+C859:0000002800287E2804E804281AE8612800280000000020F8201020303ECC0000
+C85A:0000002800287E2804E804281AE8612800280000202021FC207020883E700000
+C85B:0000002800287E2804E804281AE861280028000003F802000200020003F80000
+C85C:0000002800287E2804E804281AE861280028000007F8000807F8040007F80000
+C85D:0000002800287E2804E804281AE86128002800003EF802083E0820083E080000
+C85E:0000002800287E2804E804281AE86128002800003EF802883E8820883EF80000
+C85F:0000002800287E2804E804281AE86128002800003E8802883EF820883EF80000
+C860:0000002800287E2804E804281AE86128002800001F0801081F0810141F620000
+C861:0000002800287E2804E804281AE86128002800003EF802803EF820803EF80000
+C862:0000002800287E2804E804281AE86128002800003EFC02483E4820483EFC0000
+C863:0000002800287E2804E804281AE86128002800003E1002FE3E3820443E380000
+C864:0000002800287E2804E804281AE861280028000003F802080208020803F80000
+C865:0000002800287E2804E804281AE86128002800000208020803F8020803F80000
+C866:0000002800287E2804E804281AE8612800280000110811081F0811141F620000
+C867:0000002800287E2804E804281AE8612800280000000800080008003400C20000
+C868:0000002800287E2804E804281AE86128002800000048004800A8011406620000
+C869:0000002800287E2804E804281AE8612800280000000001F00208020801F00000
+C86A:0000002800287E2804E804281AE861280028000003F80020002000D003080000
+C86B:0000002800287E2804E804281AE8612800280000004003F8004000A003180000
+C86C:0000002800287E2804E804281AE861280028000003F8000803F8000800080000
+C86D:0000002800287E2804E804281AE861280028000003F8020003F8020003F80000
+C86E:0000002800287E2804E804281AE861280028000000000FF8022002200FF80000
+C86F:0000002800287E2804E804281AE861280028000000800FF803E0041003E00000
+C870:000000000FE0004000400080018002400C2000000100010001007FFC00000000
+C871:00000FC0008003400C200000010001007FFC00001FF000100010001000100000
+C872:00000FC0008003400C200000010001007FFC000000003EF80208020802080000
+C873:00000FC0008003400C200000010001007FFC000000001E100210022802C40000
+C874:00000FC0008003400C200000010001007FFC000000001000100010001FF00000
+C875:00000FC0008003400C200000010001007FFC0000000020F8201020303ECC0000
+C876:00000FC0008003400C200000010001007FFC0000202021FC207020883E700000
+C877:00000FC0008003400C200000010001007FFC00001FF01000100010001FF00000
+C878:00000FC0008003400C200000010001007FFC00001FF000101FF010001FF00000
+C879:00000FC0008003400C200000010001007FFC00003EF802083E0820083E080000
+C87A:00000FC0008003400C200000010001007FFC00003EF802883E8820883EF80000
+C87B:00000FC0008003400C200000010001007FFC00003E8802883EF820883EF80000
+C87C:00000FC0008003400C200000010001007FFC00003E1002103E1020283EC40000
+C87D:00000FC0008003400C200000010001007FFC00003EF802803EF820803EF80000
+C87E:00000FC0008003400C200000010001007FFC00003EFC02483E4820483EFC0000
+C87F:00000FC0008003400C200000010001007FFC00003E2003FC3E7020883E700000
+C880:00000FC0008003400C200000010001007FFC00001FF01010101010101FF00000
+C881:00000FC0008003400C200000010001007FFC0000101010101FF010101FF00000
+C882:00000FC0008003400C200000010001007FFC0000222022203E2022503E880000
+C883:00000FC0008003400C200000010001007FFC000000000100010002800C400000
+C884:00000FC0008003400C200000010001007FFC00000000024002400DA033100000
+C885:00000FC0008003400C200000010001007FFC0000000007C00820082007C00000
+C886:00000FC0008003400C200000010001007FFC0000000007E00080014006200000
+C887:00000FC0008003400C200000010001007FFC0000008007E00080014006200000
+C888:00000FC0008003400C200000010001007FFC00001FF000101FF0001000100000
+C889:00000FC0008003400C200000010001007FFC00001FF010001FF010001FF00000
+C88A:00000FC0008003400C200000010001007FFC000000001FF0044004401FF00000
+C88B:00000FC0008003400C200000010001007FFC000001001FF007C0082007C00000
+C88C:0000001000103F90011001100210061E09103090041004107FD0001000100000
+C88D:000000083F0802080D0E3088040804087FE8000007F800080008000800080000
+C88E:000000083F0802080D0E3088040804087FE8000000003EF80208020802080000
+C88F:000000083F0802080D0E3088040804087FE8000000001F080108011401620000
+C890:000000083F0802080D0E3088040804087FE8000008000800080008000FF80000
+C891:000000083F0802080D0E3088040804087FE80000000010F8101010301ECC0000
+C892:000000083F0802080D0E3088040804087FE800000808087F081C08220F9C0000
+C893:000000083F0802080D0E3088040804087FE8000003F802000200020003F80000
+C894:000000083F0802080D0E3088040804087FE8000007F8000807F8040007F80000
+C895:000000083F0802080D0E3088040804087FE800003EF802083E0820083E080000
+C896:000000083F0802080D0E3088040804087FE800003EF802883E8820883EF80000
+C897:000000083F0802080D0E3088040804087FE800003E8802883EF820883EF80000
+C898:000000083F0802080D0E3088040804087FE800001F0801081F0810141F620000
+C899:000000083F0802080D0E3088040804087FE800003EF802803EF820803EF80000
+C89A:000000083F0802080D0E3088040804087FE800003EFC02483E4820483EFC0000
+C89B:000000083F0802080D0E3088040804087FE800001F08017F1F1C10221F1C0000
+C89C:000000083F0802080D0E3088040804087FE8000003F802080208020803F80000
+C89D:000000083F0802080D0E3088040804087FE800000208020803F8020803F80000
+C89E:000000083F0802080D0E3088040804087FE80000110811081F0811141F620000
+C89F:000000083F0802080D0E3088040804087FE80000001000100010006801840000
+C8A0:000000083F0802080D0E3088040804087FE800000048004800A8011406620000
+C8A1:000000083F0802080D0E3088040804087FE80000000003F00408040803F00000
+C8A2:000000083F0802080D0E3088040804087FE8000003F80020002000D003080000
+C8A3:000000083F0802080D0E3088040804087FE80000004003F8004000A003180000
+C8A4:000000083F0802080D0E3088040804087FE8000003F8000803F8000800080000
+C8A5:000000083F0802080D0E3088040804087FE8000003F8020003F8020003F80000
+C8A6:000000083F0802080D0E3088040804087FE8000000000FF8022002200FF80000
+C8A7:000000083F0802080D0E3088040804087FE8000000800FF803E0041003E00000
+C8A8:0000001200123F92011201120212061E09123092041204127FD2001200120000
+C8A9:000000283F2802280D3830A8042804287FA8000007F800080008000800080000
+C8AA:000000283F2802280D3830A8042804287FA8000000003EF80208020802080000
+C8AB:000000283F2802280D3830A8042804287FA8000000001F080108011401620000
+C8AC:000000283F2802280D3830A8042804287FA8000008000800080008000FF80000
+C8AD:000000283F2802280D3830A8042804287FA80000000010F8101010301ECC0000
+C8AE:000000283F2802280D3830A8042804287FA800000808087F081C08220F9C0000
+C8AF:000000283F2802280D3830A8042804287FA8000003F802000200020003F80000
+C8B0:000000283F2802280D3830A8042804287FA8000007F8000807F8040007F80000
+C8B1:000000283F2802280D3830A8042804287FA800003EF802083E0820083E080000
+C8B2:000000283F2802280D3830A8042804287FA800003EF802883E8820883EF80000
+C8B3:000000283F2802280D3830A8042804287FA800003E8802883EF820883EF80000
+C8B4:000000283F2802280D3830A8042804287FA800001F0801081F0810141F620000
+C8B5:000000283F2802280D3830A8042804287FA800003EF802803EF820803EF80000
+C8B6:000000283F2802280D3830A8042804287FA800003EFC02483E4820483EFC0000
+C8B7:000000283F2802280D3830A8042804287FA800001F08017F1F1C10221F1C0000
+C8B8:000000283F2802280D3830A8042804287FA8000003F802080208020803F80000
+C8B9:000000283F2802280D3830A8042804287FA800000208020803F8020803F80000
+C8BA:000000283F2802280D3830A8042804287FA80000110811081F0811141F620000
+C8BB:000000283F2802280D3830A8042804287FA80000001000100010006801840000
+C8BC:000000283F2802280D3830A8042804287FA800000048004800A8011406620000
+C8BD:000000283F2802280D3830A8042804287FA80000000003F00408040803F00000
+C8BE:000000283F2802280D3830A8042804287FA8000003F80020002000D003080000
+C8BF:000000283F2802280D3830A8042804287FA80000004003F8004000A003180000
+C8C0:000000283F2802280D3830A8042804287FA8000003F8000803F8000800080000
+C8C1:000000283F2802280D3830A8042804287FA8000003F8020003F8020003F80000
+C8C2:000000283F2802280D3830A8042804287FA8000000000FF8022002200FF80000
+C8C3:000000283F2802280D3830A8042804287FA8000000800FF803E0041003E00000
+C8C4:0000000800083F88010801080208060809083088040804087FE8000800080000
+C8C5:000000083F0802080D083088040804087FE8000007F800080008000800080000
+C8C6:000000083F0802080D083088040804087FE8000000003EF80208020802080000
+C8C7:000000083F0802080D083088040804087FE8000000001F080108011401620000
+C8C8:000000083F0802080D083088040804087FE8000008000800080008000FF80000
+C8C9:000000083F0802080D083088040804087FE80000000010F8101010301ECC0000
+C8CA:000000083F0802080D083088040804087FE800000808087F081C08220F9C0000
+C8CB:000000083F0802080D083088040804087FE8000003F802000200020003F80000
+C8CC:000000083F0802080D083088040804087FE8000007F8000807F8040007F80000
+C8CD:000000083F0802080D083088040804087FE800003EF802083E0820083E080000
+C8CE:000000083F0802080D083088040804087FE800003EF802883E8820883EF80000
+C8CF:000000083F0802080D083088040804087FE800003E8802883EF820883EF80000
+C8D0:000000083F0802080D083088040804087FE800001F0801081F0810141F620000
+C8D1:000000083F0802080D083088040804087FE800003EF802803EF820803EF80000
+C8D2:000000083F0802080D083088040804087FE800003EFC02483E4820483EFC0000
+C8D3:000000083F0802080D083088040804087FE800001F08017F1F1C10221F1C0000
+C8D4:000000083F0802080D083088040804087FE8000003F802080208020803F80000
+C8D5:000000083F0802080D083088040804087FE800000208020803F8020803F80000
+C8D6:000000083F0802080D083088040804087FE80000110811081F0811141F620000
+C8D7:000000083F0802080D083088040804087FE80000001000100010006801840000
+C8D8:000000083F0802080D083088040804087FE800000048004800A8011406620000
+C8D9:000000083F0802080D083088040804087FE80000000003F00408040803F00000
+C8DA:000000083F0802080D083088040804087FE8000003F80020002000D003080000
+C8DB:000000083F0802080D083088040804087FE80000004003F8004000A003180000
+C8DC:000000083F0802080D083088040804087FE8000003F8000803F8000800080000
+C8DD:000000083F0802080D083088040804087FE8000003F8020003F8020003F80000
+C8DE:000000083F0802080D083088040804087FE8000000000FF8022002200FF80000
+C8DF:000000083F0802080D083088040804087FE8000000800FF803E0041003E00000
+C8E0:000000000FE0004000400080018002400C2004400440044004407FFC00000000
+C8E1:00000FC0008003400C200000044004407FFC00001FF000100010001000100000
+C8E2:00000FC0008003400C200000044004407FFC000000003EF80208020802080000
+C8E3:00000FC0008003400C200000044004407FFC000000001E100210022802C40000
+C8E4:00000FC0008003400C200000044004407FFC000000001000100010001FF00000
+C8E5:00000FC0008003400C200000044004407FFC0000000020F8201020303ECC0000
+C8E6:00000FC0008003400C200000044004407FFC0000202021FC207020883E700000
+C8E7:00000FC0008003400C200000044004407FFC00001FF01000100010001FF00000
+C8E8:00000FC0008003400C200000044004407FFC00001FF000101FF010001FF00000
+C8E9:00000FC0008003400C200000044004407FFC00003EF802083E0820083E080000
+C8EA:00000FC0008003400C200000044004407FFC00003EF802883E8820883EF80000
+C8EB:00000FC0008003400C200000044004407FFC00003E8802883EF820883EF80000
+C8EC:00000FC0008003400C200000044004407FFC00003E1002103E1020283EC40000
+C8ED:00000FC0008003400C200000044004407FFC00003EF802803EF820803EF80000
+C8EE:00000FC0008003400C200000044004407FFC00003EFC02483E4820483EFC0000
+C8EF:00000FC0008003400C200000044004407FFC00003E2003FC3E7020883E700000
+C8F0:00000FC0008003400C200000044004407FFC00001FF01010101010101FF00000
+C8F1:00000FC0008003400C200000044004407FFC0000101010101FF010101FF00000
+C8F2:00000FC0008003400C200000044004407FFC0000222022203E2022503E880000
+C8F3:00000FC0008003400C200000044004407FFC000000000100010002800C400000
+C8F4:00000FC0008003400C200000044004407FFC00000000024002400DA033100000
+C8F5:00000FC0008003400C200000044004407FFC0000000007C00820082007C00000
+C8F6:00000FC0008003400C200000044004407FFC0000000007E00080014006200000
+C8F7:00000FC0008003400C200000044004407FFC0000008007E00080014006200000
+C8F8:00000FC0008003400C200000044004407FFC00001FF000101FF0001000100000
+C8F9:00000FC0008003400C200000044004407FFC00001FF010001FF010001FF00000
+C8FA:00000FC0008003400C200000044004407FFC000000001FF0044004401FF00000
+C8FB:00000FC0008003400C200000044004407FFC000001001FF007C0082007C00000
+C8FC:000000000FE0004000400080018002400C2000003FF801000100010001000000
+C8FD:00000FC00080008003400C2000007FFC010001001FF000100010001000100000
+C8FE:00000FC00080008003400C2000007FFC0100010000003EF80208020802080000
+C8FF:00000FC00080008003400C2000007FFC0100010000001E100210022802C40000
+C900:00000FC00080008003400C20000000007FFC010001001100100010001FF00000
+C901:00000FC00080008003400C2000007FFC01000100000020F8201020303ECC0000
+C902:00000FC00080008003400C2000007FFC01000100202021FC207020883E700000
+C903:00000FC00080008003400C2000007FFC010001001FF01000100010001FF00000
+C904:00000FC00080008003400C2000007FFC010001001FF000101FF010001FF00000
+C905:00000FC00080008003400C2000007FFC010001003EF802083E0820083E080000
+C906:00000FC00080008003400C2000007FFC010001003EF802883E8820883EF80000
+C907:00000FC00080008003400C2000007FFC010001003E8802883EF820883EF80000
+C908:00000FC00080008003400C2000007FFC010001003E1002103E1020283EC40000
+C909:00000FC00080008003400C2000007FFC010001003EF802803EF820803EF80000
+C90A:00000FC00080008003400C2000007FFC010001003EFC02483E4820483EFC0000
+C90B:00000FC00080008003400C2000007FFC010001003E2003FC3E7020883E700000
+C90C:00000FC00080008003400C2000007FFC010001001FF01010101010101FF00000
+C90D:00000FC00080008003400C2000007FFC01000100101010101FF010101FF00000
+C90E:00000FC00080008003400C2000007FFC01000100222022203E2022503E880000
+C90F:00000FC00080008003400C2000007FFC0100010000000100010002800C400000
+C910:00000FC00080008003400C2000007FFC010001000000024002400DA033100000
+C911:00000FC00080008003400C2000007FFC01000100000007C00820082007C00000
+C912:00000FC00080008003400C2000007FFC01000100000007E00080014006200000
+C913:00000FC00080008003400C2000007FFC01000100008007E00080014006200000
+C914:00000FC00080008003400C2000007FFC010001001FF000101FF0001000100000
+C915:00000FC00080008003400C2000007FFC010001001FF010001FF010001FF00000
+C916:00000FC00080008003400C2000007FFC0100010000001FF0044004401FF00000
+C917:00000FC00080008003400C2000007FFC0100010001001FF007C0082007C00000
+C918:000000083F8801080108020806080908308800087FE8040804F8040804080000
+C919:3F08020802080D08308800087FE8027802080000000007F80008000800080000
+C91A:3F08020802080D08308800087FE802780208000000003EF80208020802080000
+C91B:3F08020802080D08308800087FE802780208000000001F080108011401620000
+C91C:3F08020802080D083088000800087FE80278020802081000100010001FF80000
+C91D:3F08020802080D08308800087FE8027802080000000020F8201020303ECC0000
+C91E:3F08020802080D08308800087FE8027802080000202021FC207020883E700000
+C91F:3F08020802080D08308800087FE802780208000003F802000200020003F80000
+C920:3F08020802080D08308800087FE802780208000007F8000807F8040007F80000
+C921:3F08020802080D08308800087FE80278020800003EF802083E0820083E080000
+C922:3F08020802080D08308800087FE80278020800003EF802883E8820883EF80000
+C923:3F08020802080D08308800087FE80278020800003E8802883EF820883EF80000
+C924:3F08020802080D08308800087FE80278020800000F8800880F8808140FA20000
+C925:3F08020802080D08308800087FE80278020800003EF802803EF820803EF80000
+C926:3F08020802080D08308800087FE80278020800003EFC02483E4820483EFC0000
+C927:3F08020802080D08308800087FE80278020800003E1002FE3E3820443E380000
+C928:3F08020802080D08308800087FE802780208000003F802080208020803F80000
+C929:3F08020802080D08308800087FE80278020800000208020803F8020803F80000
+C92A:3F08020802080D08308800087FE8027802080000210821083F0821143F620000
+C92B:3F08020802080D08308800087FE8027802080000001000100010006801840000
+C92C:3F08020802080D08308800087FE80278020800000048004800A8011406620000
+C92D:3F08020802080D08308800087FE8027802080000000003F00408040803F00000
+C92E:3F08020802080D08308800087FE802780208000003F80020002000D003080000
+C92F:3F08020802080D08308800087FE8027802080000004003F8004000A003180000
+C930:3F08020802080D08308800087FE802780208000003F8000803F8000800080000
+C931:3F08020802080D08308800087FE802780208000003F8020003F8020003F80000
+C932:3F08020802080D08308800087FE802780208000000000FF8022002200FF80000
+C933:3F08020802080D08308800087FE802780208000000800FF803E0041003E00000
+C934:0000000A3F8A010A010A020A060A090A308A000A7FEA040A047A040A040A0000
+C935:3F28022802280D2830A800287FA805E804280000000007F80008000800080000
+C936:3F28022802280D2830A800287FA805E80428000000003EF80208020802080000
+C937:3F28022802280D2830A800287FA805E80428000000001F080108011401620000
+C938:3F28022802280D2830A8002800287FA8042805E804281428100010001FF80000
+C939:3F28022802280D2830A800287FA805E804280000000020F8201020303ECC0000
+C93A:3F28022802280D2830A800287FA805E804280000202021FC207020883E700000
+C93B:3F28022802280D2830A800287FA805E80428000003F802000200020003F80000
+C93C:3F28022802280D2830A800287FA805E80428000007F8000807F8040007F80000
+C93D:3F28022802280D2830A800287FA805E8042800003EF802083E0820083E080000
+C93E:3F28022802280D2830A800287FA805E8042800003EF802883E8820883EF80000
+C93F:3F28022802280D2830A800287FA805E8042800003E8802883EF820883EF80000
+C940:3F28022802280D2830A800287FA805E8042800000F8800880F8808140FA20000
+C941:3F28022802280D2830A800287FA805E8042800003EF802803EF820803EF80000
+C942:3F28022802280D2830A800287FA805E8042800003EFC02483E4820483EFC0000
+C943:3F28022802280D2830A800287FA805E8042800003E1002FE3E3820443E380000
+C944:3F28022802280D2830A800287FA805E80428000003F802080208020803F80000
+C945:3F28022802280D2830A800287FA805E8042800000208020803F8020803F80000
+C946:3F28022802280D2830A800287FA805E804280000210821083F0821143F620000
+C947:3F28022802280D2830A800287FA805E804280000001000100010006801840000
+C948:3F28022802280D2830A800287FA805E8042800000048004800A8011406620000
+C949:3F28022802280D2830A800287FA805E804280000000003F00408040803F00000
+C94A:3F28022802280D2830A800287FA805E80428000003F80020002000D003080000
+C94B:3F28022802280D2830A800287FA805E804280000004003F8004000A003180000
+C94C:3F28022802280D2830A800287FA805E80428000003F8000803F8000800080000
+C94D:3F28022802280D2830A800287FA805E80428000003F8020003F8020003F80000
+C94E:3F28022802280D2830A800287FA805E80428000000000FF8022002200FF80000
+C94F:3F28022802280D2830A800287FA805E80428000000800FF803E0041003E00000
+C950:000000083F8801080108020806080908308800087FE804080408040804080000
+C951:3F08020802080D08308800087FE8020802000000000007F80008000800080000
+C952:3F08020802080D08308800087FE802080200000000003EF80208020802080000
+C953:3F08020802080D08308800087FE802080200000000001F080108011401620000
+C954:3F08020802080D083088000800087FE80208020802081008100010001FF80000
+C955:3F08020802080D08308800087FE8020802000000000020F8201020303ECC0000
+C956:3F08020802080D08308800087FE8020802000000202021FC207020883E700000
+C957:3F08020802080D08308800087FE802080200000003F802000200020003F80000
+C958:3F08020802080D08308800087FE802080200000007F8000807F8040007F80000
+C959:3F08020802080D08308800087FE80208020000003EF802083E0820083E080000
+C95A:3F08020802080D08308800087FE80208020000003EF802883E8820883EF80000
+C95B:3F08020802080D08308800087FE80208020000003E8802883EF820883EF80000
+C95C:3F08020802080D08308800087FE80208020000000F8800880F8808140FA20000
+C95D:3F08020802080D08308800087FE80208020000003EF802803EF820803EF80000
+C95E:3F08020802080D08308800087FE80208020000003EFC02483E4820483EFC0000
+C95F:3F08020802080D08308800087FE80208020000003E1002FE3E3820443E380000
+C960:3F08020802080D08308800087FE802080200000003F802080208020803F80000
+C961:3F08020802080D08308800087FE80208020000000208020803F8020803F80000
+C962:3F08020802080D08308800087FE8020802000000210821083F0821143F620000
+C963:3F08020802080D08308800087FE8020802000000001000100010006801840000
+C964:3F08020802080D08308800087FE80208020000000048004800A8011406620000
+C965:3F08020802080D08308800087FE8020802000000000003F00408040803F00000
+C966:3F08020802080D08308800087FE802080200000003F80020002000D003080000
+C967:3F08020802080D08308800087FE8020802000000004003F8004000A003180000
+C968:3F08020802080D08308800087FE802080200000003F8000803F8000800080000
+C969:3F08020802080D08308800087FE802080200000003F8020003F8020003F80000
+C96A:3F08020802080D08308800087FE802080200000000000FF8022002200FF80000
+C96B:3F08020802080D08308800087FE802080200000000800FF803E0041003E00000
+C96C:000000000FE0004000400080018002400C2000007FFC04400440044004400000
+C96D:00000FC00080008003400C2000007FFC044004401FF000100010001000100000
+C96E:00000FC00080008003400C2000007FFC0440044000003EF80208020802080000
+C96F:00000FC00080008003400C2000007FFC0440044000001E100210022802C40000
+C970:00000FC00080008003400C20000000007FFC044004401440100010001FF00000
+C971:00000FC00080008003400C2000007FFC04400440000020F8201020303ECC0000
+C972:00000FC00080008003400C2000007FFC04400440202021FC207020883E700000
+C973:00000FC00080008003400C2000007FFC044004401FF01000100010001FF00000
+C974:00000FC00080008003400C2000007FFC044004401FF000101FF010001FF00000
+C975:00000FC00080008003400C2000007FFC044004403EF802083E0820083E080000
+C976:00000FC00080008003400C2000007FFC044004403EF802883E8820883EF80000
+C977:00000FC00080008003400C2000007FFC044004403E8802883EF820883EF80000
+C978:00000FC00080008003400C2000007FFC044004403E1002103E1020283EC40000
+C979:00000FC00080008003400C2000007FFC044004403EF802803EF820803EF80000
+C97A:00000FC00080008003400C2000007FFC044004403EFC02483E4820483EFC0000
+C97B:00000FC00080008003400C2000007FFC044004403E2003FC3E7020883E700000
+C97C:00000FC00080008003400C2000007FFC044004401FF01010101010101FF00000
+C97D:00000FC00080008003400C2000007FFC04400440101010101FF010101FF00000
+C97E:00000FC00080008003400C2000007FFC04400440222022203E2022503E880000
+C97F:00000FC00080008003400C2000007FFC0440044000000100010002800C400000
+C980:00000FC00080008003400C2000007FFC044004400000024002400DA033100000
+C981:00000FC00080008003400C2000007FFC04400440000007C00820082007C00000
+C982:00000FC00080008003400C2000007FFC04400440000007E00080014006200000
+C983:00000FC00080008003400C2000007FFC04400440008007E00080014006200000
+C984:00000FC00080008003400C2000007FFC044004401FF000101FF0001000100000
+C985:00000FC00080008003400C2000007FFC044004401FF010001FF010001FF00000
+C986:00000FC00080008003400C2000007FFC0440044000001FF0044004401FF00000
+C987:00000FC00080008003400C2000007FFC0440044001001FF007C0082007C00000
+C988:000000000FE0004000400080018002400C20000000007FFC0000000000000000
+C989:00000FC0008003400C200000000000007FFC00001FF000100010001000100000
+C98A:00000FC0008003400C200000000000007FFC000000003EF80208020802080000
+C98B:00000FC0008003400C200000000000007FFC000000001E100210022802C40000
+C98C:00000FC0008003400C200000000000007FFC000000001000100010001FF00000
+C98D:00000FC0008003400C200000000000007FFC0000000020F8201020303ECC0000
+C98E:00000FC0008003400C200000000000007FFC0000202021FC207020883E700000
+C98F:00000FC0008003400C200000000000007FFC00001FF01000100010001FF00000
+C990:00000FC0008003400C200000000000007FFC00001FF000101FF010001FF00000
+C991:00000FC0008003400C200000000000007FFC00003EF802083E0820083E080000
+C992:00000FC0008003400C200000000000007FFC00003EF802883E8820883EF80000
+C993:00000FC0008003400C200000000000007FFC00003E8802883EF820883EF80000
+C994:00000FC0008003400C200000000000007FFC00003E1002103E1020283EC40000
+C995:00000FC0008003400C200000000000007FFC00003EF802803EF820803EF80000
+C996:00000FC0008003400C200000000000007FFC00003EFC02483E4820483EFC0000
+C997:00000FC0008003400C200000000000007FFC00003E2003FC3E7020883E700000
+C998:00000FC0008003400C200000000000007FFC00001FF01010101010101FF00000
+C999:00000FC0008003400C200000000000007FFC0000101010101FF010101FF00000
+C99A:00000FC0008003400C200000000000007FFC0000222022203E2022503E880000
+C99B:00000FC0008003400C200000000000007FFC000000000100010002800C400000
+C99C:00000FC0008003400C200000000000007FFC00000000024002400DA033100000
+C99D:00000FC0008003400C200000000000007FFC0000000007C00820082007C00000
+C99E:00000FC0008003400C200000000000007FFC0000000007E00080014006200000
+C99F:00000FC0008003400C200000000000007FFC0000008007E00080014006200000
+C9A0:00000FC0008003400C200000000000007FFC00001FF000101FF0001000100000
+C9A1:00000FC0008003400C200000000000007FFC00001FF010001FF010001FF00000
+C9A2:00000FC0008003400C200000000000007FFC000000001FF0044004401FF00000
+C9A3:00000FC0008003400C200000000000007FFC000001001FF007C0082007C00000
+C9A4:0000000800083F8801080108020806080908308800087FE80008000800080000
+C9A5:000000083F0802080D083088000800087FE8000007F800080008000800080000
+C9A6:000000083F0802080D083088000800087FE8000000003EF80208020802080000
+C9A7:000000083F0802080D083088000800087FE8000000001F080108011401620000
+C9A8:000000083F0802080D083088000800087FE8000008000800080008000FF80000
+C9A9:000000083F0802080D083088000800087FE80000000010F8101010301ECC0000
+C9AA:000000083F0802080D083088000800087FE800000808087F081C08220F9C0000
+C9AB:000000083F0802080D083088000800087FE8000003F802000200020003F80000
+C9AC:000000083F0802080D083088000800087FE8000007F8000807F8040007F80000
+C9AD:000000083F0802080D083088000800087FE800003EF802083E0820083E080000
+C9AE:000000083F0802080D083088000800087FE800003EF802883E8820883EF80000
+C9AF:000000083F0802080D083088000800087FE800003E8802883EF820883EF80000
+C9B0:000000083F0802080D083088000800087FE800001F0801081F0810141F620000
+C9B1:000000083F0802080D083088000800087FE800003EF802803EF820803EF80000
+C9B2:000000083F0802080D083088000800087FE800003EFC02483E4820483EFC0000
+C9B3:000000083F0802080D083088000800087FE800001F08017F1F1C10221F1C0000
+C9B4:000000083F0802080D083088000800087FE8000003F802080208020803F80000
+C9B5:000000083F0802080D083088000800087FE800000208020803F8020803F80000
+C9B6:000000083F0802080D083088000800087FE80000110811081F0811141F620000
+C9B7:000000083F0802080D083088000800087FE80000001000100010006801840000
+C9B8:000000083F0802080D083088000800087FE800000048004800A8011406620000
+C9B9:000000083F0802080D083088000800087FE80000000003F00408040803F00000
+C9BA:000000083F0802080D083088000800087FE8000003F80020002000D003080000
+C9BB:000000083F0802080D083088000800087FE80000004003F8004000A003180000
+C9BC:000000083F0802080D083088000800087FE8000003F8000803F8000800080000
+C9BD:000000083F0802080D083088000800087FE8000003F8020003F8020003F80000
+C9BE:000000083F0802080D083088000800087FE8000000000FF8022002200FF80000
+C9BF:000000083F0802080D083088000800087FE8000000800FF803E0041003E00000
+C9C0:00000000000800083F8801080108020806080908308800080008000800080000
+C9C1:0000000800087E08040804081A08610800080000000007F80008000800080000
+C9C2:0000000800087E08040804081A0861080008000000003EF80208020802080000
+C9C3:0000000800087E08040804081A0861080008000000001F080108011401620000
+C9C4:0000000800087E08040804081A0861080008000800001000100010001FF80000
+C9C5:0000000800087E08040804081A08610800080000000020F8201020303ECC0000
+C9C6:0000000800087E08040804081A08610800080000202021FC207020883E700000
+C9C7:0000000800087E08040804081A0861080008000003F802000200020003F80000
+C9C8:0000000800087E08040804081A0861080008000007F8000807F8040007F80000
+C9C9:0000000800087E08040804081A086108000800003EF802083E0820083E080000
+C9CA:0000000800087E08040804081A086108000800003EF802883E8820883EF80000
+C9CB:0000000800087E08040804081A086108000800003E8802883EF820883EF80000
+C9CC:0000000800087E08040804081A086108000800000F8800880F8808140FA20000
+C9CD:0000000800087E08040804081A086108000800003EF802803EF820803EF80000
+C9CE:0000000800087E08040804081A086108000800003EFC02483E4820483EFC0000
+C9CF:0000000800087E08040804081A086108000800003E1002FE3E3820443E380000
+C9D0:0000000800087E08040804081A0861080008000003F802080208020803F80000
+C9D1:0000000800087E08040804081A086108000800000208020803F8020803F80000
+C9D2:0000000800087E08040804081A08610800080000210821083F0821143F620000
+C9D3:0000000800087E08040804081A08610800080000001000100010006801840000
+C9D4:0000000800087E08040804081A086108000800000048004800A8011406620000
+C9D5:0000000800087E08040804081A08610800080000000003F00408040803F00000
+C9D6:0000000800087E08040804081A0861080008000003F80020002000D003080000
+C9D7:0000000800087E08040804081A08610800080000004003F8004000A003180000
+C9D8:0000000800087E08040804081A0861080008000003F8000803F8000800080000
+C9D9:0000000800087E08040804081A0861080008000003F8020003F8020003F80000
+C9DA:0000000800087E08040804081A0861080008000000000FF8022002200FF80000
+C9DB:0000000800087E08040804081A0861080008000000800FF803E0041003E00000
+C9DC:00000000001000107B9008900890191E15102290CC5000100010001000100000
+C9DD:00000008000877082208220E550888880008000007F800080008000800080000
+C9DE:00000008000877082208220E550888880008000000003EF80208020802080000
+C9DF:00000008000877082208220E550888880008000000001F080108011401620000
+C9E0:00000008000877082208220E550888880008000808000800080008000FF80000
+C9E1:00000008000877082208220E5508888800080000000010F8101010301ECC0000
+C9E2:00000008000877082208220E55088888000800000808087F081C08220F9C0000
+C9E3:00000008000877082208220E550888880008000003F802000200020003F80000
+C9E4:00000008000877082208220E550888880008000007F8000807F8040007F80000
+C9E5:00000008000877082208220E55088888000800003EF802083E0820083E080000
+C9E6:00000008000877082208220E55088888000800003EF802883E8820883EF80000
+C9E7:00000008000877082208220E55088888000800003E8802883EF820883EF80000
+C9E8:00000008000877082208220E55088888000800001F0801081F0810141F620000
+C9E9:00000008000877082208220E55088888000800003EF802803EF820803EF80000
+C9EA:00000008000877082208220E55088888000800003EFC02483E4820483EFC0000
+C9EB:00000008000877082208220E55088888000800001F08017F1F1C10221F1C0000
+C9EC:00000008000877082208220E550888880008000003F802080208020803F80000
+C9ED:00000008000877082208220E55088888000800000208020803F8020803F80000
+C9EE:00000008000877082208220E5508888800080000110811081F0811141F620000
+C9EF:00000008000877082208220E5508888800080000001000100010006801840000
+C9F0:00000008000877082208220E55088888000800000048004800A8011406620000
+C9F1:00000008000877082208220E5508888800080000000003F00408040803F00000
+C9F2:00000008000877082208220E550888880008000003F80020002000D003080000
+C9F3:00000008000877082208220E5508888800080000004003F8004000A003180000
+C9F4:00000008000877082208220E550888880008000003F8000803F8000800080000
+C9F5:00000008000877082208220E550888880008000003F8020003F8020003F80000
+C9F6:00000008000877082208220E550888880008000000000FF8022002200FF80000
+C9F7:00000008000877082208220E550888880008000000800FF803E0041003E00000
+C9F8:00000000001200127B9208920892191E15122292CC5200120012001200120000
+C9F9:000000280028772822282238552888A80028000007F800080008000800080000
+C9FA:000000280028772822282238552888A80028000000003EF80208020802080000
+C9FB:000000280028772822282238552888A80028000000003E100210022802C40000
+C9FC:000000280028772822282238552888A80028002808000800080008000FF80000
+C9FD:000000280028772822282238552888A800280000000020F8201020303ECC0000
+C9FE:000000280028772822282238552888A800280000202021FC207020883E700000
+C9FF:000000280028772822282238552888A80028000003F802000200020003F80000
+CA00:000000280028772822282238552888A80028000007F8000807F8040007F80000
+CA01:000000280028772822282238552888A8002800003EF802083E0820083E080000
+CA02:000000280028772822282238552888A8002800003EF802883E8820883EF80000
+CA03:000000280028772822282238552888A8002800003E8802883EF820883EF80000
+CA04:000000280028772822282238552888A8002800001F0801081F0810141F620000
+CA05:000000280028772822282238552888A8002800003EF802803EF820803EF80000
+CA06:000000280028772822282238552888A8002800003EFC02483E4820483EFC0000
+CA07:000000280028772822282238552888A8002800003E1002FE3E3820443E380000
+CA08:000000280028772822282238552888A80028000003F802080208020803F80000
+CA09:000000280028772822282238552888A8002800000208020803F8020803F80000
+CA0A:000000280028772822282238552888A800280000110811081F0811141F620000
+CA0B:000000280028772822282238552888A800280000000800080008003400C20000
+CA0C:000000280028772822282238552888A8002800000048004800A8011406620000
+CA0D:000000280028772822282238552888A800280000000001F00208020801F00000
+CA0E:000000280028772822282238552888A80028000003F80020002000D003080000
+CA0F:000000280028772822282238552888A800280000004003F8004000A003180000
+CA10:000000280028772822282238552888A80028000003F8000803F8000800080000
+CA11:000000280028772822282238552888A80028000003F8020003F8020003F80000
+CA12:000000280028772822282238552888A80028000000000FF8022002200FF80000
+CA13:000000280028772822282238552888A80028000000800FF803E0041003E00000
+CA14:00000000001000107B900890089E19101510229ECC5000100010001000100000
+CA15:0000000800087708220E2208550E88880008000007F800080008000800080000
+CA16:0000000800087708220E2208550E88880008000000003EF80208020802080000
+CA17:0000000800087708220E2208550E88880008000000001F080108011401620000
+CA18:0000000800087708220E2208550E88880008000008000800080008000FF80000
+CA19:0000000800087708220E2208550E888800080000000010F8101010301ECC0000
+CA1A:0000000800087708220E2208550E8888000800000808087F081C08220F9C0000
+CA1B:0000000800087708220E2208550E88880008000003F802000200020003F80000
+CA1C:0000000800087708220E2208550E88880008000007F8000807F8040007F80000
+CA1D:0000000800087708220E2208550E8888000800003EF802083E0820083E080000
+CA1E:0000000800087708220E2208550E8888000800003EF802883E8820883EF80000
+CA1F:0000000800087708220E2208550E8888000800003E8802883EF820883EF80000
+CA20:0000000800087708220E2208550E8888000800001F0801081F0810141F620000
+CA21:0000000800087708220E2208550E8888000800003EF802803EF820803EF80000
+CA22:0000000800087708220E2208550E8888000800003EFC02483E4820483EFC0000
+CA23:0000000800087708220E2208550E8888000800001F08017F1F1C10221F1C0000
+CA24:0000000800087708220E2208550E88880008000003F802080208020803F80000
+CA25:0000000800087708220E2208550E8888000800000208020803F8020803F80000
+CA26:0000000800087708220E2208550E888800080000110811081F0811141F620000
+CA27:0000000800087708220E2208550E888800080000001000100010006801840000
+CA28:0000000800087708220E2208550E8888000800000048004800A8011406620000
+CA29:0000000800087708220E2208550E888800080000000003F00408040803F00000
+CA2A:0000000800087708220E2208550E88880008000003F80020002000D003080000
+CA2B:0000000800087708220E2208550E888800080000004003F8004000A003180000
+CA2C:0000000800087708220E2208550E88880008000003F8000803F8000800080000
+CA2D:0000000800087708220E2208550E88880008000003F8020003F8020003F80000
+CA2E:0000000800087708220E2208550E88880008000000000FF8022002200FF80000
+CA2F:0000000800087708220E2208550E88880008000000800FF803E0041003E00000
+CA30:00000000001200127B920892089E19121512229ECC5200120012001200120000
+CA31:000000280028772822382228553888A80028000007F800080008000800080000
+CA32:000000280028772822382228553888A80028000000003EF80208020802080000
+CA33:000000280028772822382228553888A80028000000003E100210022802C40000
+CA34:000000280028772822382228553888A80028002808000800080008000FF80000
+CA35:000000280028772822382228553888A800280000000020F8201020303ECC0000
+CA36:000000280028772822382228553888A800280000202021FC207020883E700000
+CA37:000000280028772822382228553888A80028000003F802000200020003F80000
+CA38:000000280028772822382228553888A80028000007F8000807F8040007F80000
+CA39:000000280028772822382228553888A8002800003EF802083E0820083E080000
+CA3A:000000280028772822382228553888A8002800003EF802883E8820883EF80000
+CA3B:000000280028772822382228553888A8002800003E8802883EF820883EF80000
+CA3C:000000280028772822382228553888A8002800001F0801081F0810141F620000
+CA3D:000000280028772822382228553888A8002800003EF802803EF820803EF80000
+CA3E:000000280028772822382228553888A8002800003EFC02483E4820483EFC0000
+CA3F:000000280028772822382228553888A8002800003E1002FE3E3820443E380000
+CA40:000000280028772822382228553888A80028000003F802080208020803F80000
+CA41:000000280028772822382228553888A8002800000208020803F8020803F80000
+CA42:000000280028772822382228553888A800280000110811081F0811141F620000
+CA43:000000280028772822382228553888A800280000000800080008003400C20000
+CA44:000000280028772822382228553888A8002800000048004800A8011406620000
+CA45:000000280028772822382228553888A800280000000001F00208020801F00000
+CA46:000000280028772822382228553888A80028000003F80020002000D003080000
+CA47:000000280028772822382228553888A800280000004003F8004000A003180000
+CA48:000000280028772822382228553888A80028000003F8000803F8000800080000
+CA49:000000280028772822382228553888A80028000003F8020003F8020003F80000
+CA4A:000000280028772822382228553888A80028000000000FF8022002200FF80000
+CA4B:000000280028772822382228553888A80028000000800FF803E0041003E00000
+CA4C:00000000000200027B8208820882191E15022282CC4200020002000200020000
+CA4D:0000000800087708220822385508888800080000000007F80008000800080000
+CA4E:000000080008770822082238550888880008000000003EF80208020802080000
+CA4F:000000080008770822082238550888880008000000001F080108011401620000
+CA50:000000080008770822082238550888880008000000001000100010001FF80000
+CA51:0000000800087708220822385508888800080000000020F8201020303ECC0000
+CA52:0000000800087708220822385508888800080000202021FC207020883E700000
+CA53:000000080008770822082238550888880008000003F802000200020003F80000
+CA54:000000080008770822082238550888880008000007F8000807F8040007F80000
+CA55:00000008000877082208223855088888000800003EF802083E0820083E080000
+CA56:00000008000877082208223855088888000800003EF802883E8820883EF80000
+CA57:00000008000877082208223855088888000800003E8802883EF820883EF80000
+CA58:00000008000877082208223855088888000800000F8800880F8808140FA20000
+CA59:00000008000877082208223855088888000800003EF802803EF820803EF80000
+CA5A:00000008000877082208223855088888000800003EFC02483E4820483EFC0000
+CA5B:00000008000877082208223855088888000800003E1002FE3E3820443E380000
+CA5C:000000080008770822082238550888880008000003F802080208020803F80000
+CA5D:00000008000877082208223855088888000800000208020803F8020803F80000
+CA5E:0000000800087708220822385508888800080000210821083F0821143F620000
+CA5F:0000000800087708220822385508888800080000001000100010006801840000
+CA60:00000008000877082208223855088888000800000048004800A8011406620000
+CA61:0000000800087708220822385508888800080000000003F00408040803F00000
+CA62:000000080008770822082238550888880008000003F80020002000D003080000
+CA63:0000000800087708220822385508888800080000004003F8004000A003180000
+CA64:000000080008770822082238550888880008000003F8000803F8000800080000
+CA65:000000080008770822082238550888880008000003F8020003F8020003F80000
+CA66:000000080008770822082238550888880008000000000FF8022002200FF80000
+CA67:000000080008770822082238550888880008000000800FF803E0041003E00000
+CA68:00000000000A000A7B8A088A088A193A150A228ACC4A000A000A000A000A0000
+CA69:0000002800287728222822E8552888A80028000007F800080008000800080000
+CA6A:0000002800287728222822E8552888A80028000000003EF80208020802080000
+CA6B:0000002800287728222822E8552888A80028000000003E100210022802C40000
+CA6C:0000002800287728222822E8552888A80028000008000800080008000FF80000
+CA6D:0000002800287728222822E8552888A800280000000020F8201020303ECC0000
+CA6E:0000002800287728222822E8552888A800280000202021FC207020883E700000
+CA6F:0000002800287728222822E8552888A80028000003F802000200020003F80000
+CA70:0000002800287728222822E8552888A80028000007F8000807F8040007F80000
+CA71:0000002800287728222822E8552888A8002800003EF802083E0820083E080000
+CA72:0000002800287728222822E8552888A8002800003EF802883E8820883EF80000
+CA73:0000002800287728222822E8552888A8002800003E8802883EF820883EF80000
+CA74:0000002800287728222822E8552888A8002800001F0801081F0810141F620000
+CA75:0000002800287728222822E8552888A8002800003EF802803EF820803EF80000
+CA76:0000002800287728222822E8552888A8002800003EFC02483E4820483EFC0000
+CA77:0000002800287728222822E8552888A8002800003E1002FE3E3820443E380000
+CA78:0000002800287728222822E8552888A80028000003F802080208020803F80000
+CA79:0000002800287728222822E8552888A8002800000208020803F8020803F80000
+CA7A:0000002800287728222822E8552888A800280000110811081F0811141F620000
+CA7B:0000002800287728222822E8552888A800280000000800080008003400C20000
+CA7C:0000002800287728222822E8552888A8002800000048004800A8011406620000
+CA7D:0000002800287728222822E8552888A800280000000001F00208020801F00000
+CA7E:0000002800287728222822E8552888A80028000003F80020002000D003080000
+CA7F:0000002800287728222822E8552888A800280000004003F8004000A003180000
+CA80:0000002800287728222822E8552888A80028000003F8000803F8000800080000
+CA81:0000002800287728222822E8552888A80028000003F8020003F8020003F80000
+CA82:0000002800287728222822E8552888A80028000000000FF8022002200FF80000
+CA83:0000002800287728222822E8552888A80028000000800FF803E0041003E00000
+CA84:00000000000200027B820882089E19021502229ECC4200020002000200020000
+CA85:0000000800087708223822085538888800080000000007F80008000800080000
+CA86:000000080008770822382208553888880008000000003EF80208020802080000
+CA87:000000080008770822382208553888880008000000001F080108011401620000
+CA88:000000080008770822382208553888880008000800001000100010001FF80000
+CA89:0000000800087708223822085538888800080000000020F8201020303ECC0000
+CA8A:0000000800087708223822085538888800080000202021FC207020883E700000
+CA8B:000000080008770822382208553888880008000003F802000200020003F80000
+CA8C:000000080008770822382208553888880008000007F8000807F8040007F80000
+CA8D:00000008000877082238220855388888000800003EF802083E0820083E080000
+CA8E:00000008000877082238220855388888000800003EF802883E8820883EF80000
+CA8F:00000008000877082238220855388888000800003E8802883EF820883EF80000
+CA90:00000008000877082238220855388888000800000F8800880F8808140FA20000
+CA91:00000008000877082238220855388888000800003EF802803EF820803EF80000
+CA92:00000008000877082238220855388888000800003EFC02483E4820483EFC0000
+CA93:00000008000877082238220855388888000800003E1002FE3E3820443E380000
+CA94:000000080008770822382208553888880008000003F802080208020803F80000
+CA95:00000008000877082238220855388888000800000208020803F8020803F80000
+CA96:0000000800087708223822085538888800080000210821083F0821143F620000
+CA97:0000000800087708223822085538888800080000001000100010006801840000
+CA98:00000008000877082238220855388888000800000048004800A8011406620000
+CA99:0000000800087708223822085538888800080000000003F00408040803F00000
+CA9A:000000080008770822382208553888880008000003F80020002000D003080000
+CA9B:0000000800087708223822085538888800080000004003F8004000A003180000
+CA9C:000000080008770822382208553888880008000003F8000803F8000800080000
+CA9D:000000080008770822382208553888880008000003F8020003F8020003F80000
+CA9E:000000080008770822382208553888880008000000000FF8022002200FF80000
+CA9F:000000080008770822382208553888880008000000800FF803E0041003E00000
+CAA0:00000000000A000A7B8A088A08BA190A150A22BACC4A000A000A000A000A0000
+CAA1:000000280028772822E8222855E888A80028000007F800080008000800080000
+CAA2:000000280028772822E8222855E888A80028000000003EF80208020802080000
+CAA3:000000280028772822E8222855E888A80028000000003E100210022802C40000
+CAA4:000000280028772822E8222855E888A80028002808000800080008000FF80000
+CAA5:000000280028772822E8222855E888A800280000000020F8201020303ECC0000
+CAA6:000000280028772822E8222855E888A800280000202021FC207020883E700000
+CAA7:000000280028772822E8222855E888A80028000003F802000200020003F80000
+CAA8:000000280028772822E8222855E888A80028000007F8000807F8040007F80000
+CAA9:000000280028772822E8222855E888A8002800003EF802083E0820083E080000
+CAAA:000000280028772822E8222855E888A8002800003EF802883E8820883EF80000
+CAAB:000000280028772822E8222855E888A8002800003E8802883EF820883EF80000
+CAAC:000000280028772822E8222855E888A8002800001F0801081F0810141F620000
+CAAD:000000280028772822E8222855E888A8002800003EF802803EF820803EF80000
+CAAE:000000280028772822E8222855E888A8002800003EFC02483E4820483EFC0000
+CAAF:000000280028772822E8222855E888A8002800003E1002FE3E3820443E380000
+CAB0:000000280028772822E8222855E888A80028000003F802080208020803F80000
+CAB1:000000280028772822E8222855E888A8002800000208020803F8020803F80000
+CAB2:000000280028772822E8222855E888A800280000110811081F0811141F620000
+CAB3:000000280028772822E8222855E888A800280000000800080008003400C20000
+CAB4:000000280028772822E8222855E888A8002800000048004800A8011406620000
+CAB5:000000280028772822E8222855E888A800280000000001F00208020801F00000
+CAB6:000000280028772822E8222855E888A80028000003F80020002000D003080000
+CAB7:000000280028772822E8222855E888A800280000004003F8004000A003180000
+CAB8:000000280028772822E8222855E888A80028000003F8000803F8000800080000
+CAB9:000000280028772822E8222855E888A80028000003F8020003F8020003F80000
+CABA:000000280028772822E8222855E888A80028000000000FF8022002200FF80000
+CABB:000000280028772822E8222855E888A80028000000800FF803E0041003E00000
+CABC:0000000000001EE0022002200640054008A033100100010001007FFC00000000
+CABD:00003DE00440088015402220010001007FFC00001FF000100010001000100000
+CABE:00003DE00440088015402220010001007FFC000000003EF80208020802080000
+CABF:00003DE00440088015402220010001007FFC000000001E100210022802C40000
+CAC0:00003DE00440088015402220010001007FFC000000001000100010001FF00000
+CAC1:00003DE00440088015402220010001007FFC0000000020F8201020303ECC0000
+CAC2:00003DE00440088015402220010001007FFC0000202021FC207020883E700000
+CAC3:00003DE00440088015402220010001007FFC00001FF01000100010001FF00000
+CAC4:00003DE00440088015402220010001007FFC00001FF000101FF010001FF00000
+CAC5:00003DE00440088015402220010001007FFC00003EF802083E0820083E080000
+CAC6:00003DE00440088015402220010001007FFC00003EF802883E8820883EF80000
+CAC7:00003DE00440088015402220010001007FFC00003E8802883EF820883EF80000
+CAC8:00003DE00440088015402220010001007FFC00003E1002103E1020283EC40000
+CAC9:00003DE00440088015402220010001007FFC00003EF802803EF820803EF80000
+CACA:00003DE00440088015402220010001007FFC00003EFC02483E4820483EFC0000
+CACB:00003DE00440088015402220010001007FFC00003E2003FC3E7020883E700000
+CACC:00003DE00440088015402220010001007FFC00001FF01010101010101FF00000
+CACD:00003DE00440088015402220010001007FFC0000101010101FF010101FF00000
+CACE:00003DE00440088015402220010001007FFC0000222022203E2022503E880000
+CACF:00003DE00440088015402220010001007FFC000000000100010002800C400000
+CAD0:00003DE00440088015402220010001007FFC00000000024002400DA033100000
+CAD1:00003DE00440088015402220010001007FFC0000000007C00820082007C00000
+CAD2:00003DE00440088015402220010001007FFC0000000007E00080014006200000
+CAD3:00003DE00440088015402220010001007FFC0000008007E00080014006200000
+CAD4:00003DE00440088015402220010001007FFC00001FF000101FF0001000100000
+CAD5:00003DE00440088015402220010001007FFC00001FF010001FF010001FF00000
+CAD6:00003DE00440088015402220010001007FFC000000001FF0044004401FF00000
+CAD7:00003DE00440088015402220010001007FFC000001001FF007C0082007C00000
+CAD8:0000001000107B90089008901910151E2290CC50041004107FD0001000100000
+CAD9:00007BC8088811082A8E4448040804087FE8000007F800080008000800080000
+CADA:00007BC8088811082A8E4448040804087FE8000000003EF80208020802080000
+CADB:00007BC8088811082A8E4448040804087FE8000000001F080108011401620000
+CADC:00007BC8088811082A8E4448040804087FE8000008000800080008000FF80000
+CADD:00007BC8088811082A8E4448040804087FE80000000010F8101010301ECC0000
+CADE:00007BC8088811082A8E4448040804087FE800000808087F081C08220F9C0000
+CADF:00007BC8088811082A8E4448040804087FE8000003F802000200020003F80000
+CAE0:00007BC8088811082A8E4448040804087FE8000007F8000807F8040007F80000
+CAE1:00007BC8088811082A8E4448040804087FE800003EF802083E0820083E080000
+CAE2:00007BC8088811082A8E4448040804087FE800003EF802883E8820883EF80000
+CAE3:00007BC8088811082A8E4448040804087FE800003E8802883EF820883EF80000
+CAE4:00007BC8088811082A8E4448040804087FE800001F0801081F0810141F620000
+CAE5:00007BC8088811082A8E4448040804087FE800003EF802803EF820803EF80000
+CAE6:00007BC8088811082A8E4448040804087FE800003EFC02483E4820483EFC0000
+CAE7:00007BC8088811082A8E4448040804087FE800001F08017F1F1C10221F1C0000
+CAE8:00007BC8088811082A8E4448040804087FE8000003F802080208020803F80000
+CAE9:00007BC8088811082A8E4448040804087FE800000208020803F8020803F80000
+CAEA:00007BC8088811082A8E4448040804087FE80000110811081F0811141F620000
+CAEB:00007BC8088811082A8E4448040804087FE80000001000100010006801840000
+CAEC:00007BC8088811082A8E4448040804087FE800000048004800A8011406620000
+CAED:00007BC8088811082A8E4448040804087FE80000000003F00408040803F00000
+CAEE:00007BC8088811082A8E4448040804087FE8000003F80020002000D003080000
+CAEF:00007BC8088811082A8E4448040804087FE80000004003F8004000A003180000
+CAF0:00007BC8088811082A8E4448040804087FE8000003F8000803F8000800080000
+CAF1:00007BC8088811082A8E4448040804087FE8000003F8020003F8020003F80000
+CAF2:00007BC8088811082A8E4448040804087FE8000000000FF8022002200FF80000
+CAF3:00007BC8088811082A8E4448040804087FE8000000800FF803E0041003E00000
+CAF4:0000001200127B92089208921912151E2292CC52041204127FD2001200120000
+CAF5:00007BE808A811282AB84468042804287FA8000007F800080008000800080000
+CAF6:00007BE808A811282AB84468042804287FA8000000003EF80208020802080000
+CAF7:00007BE808A811282AB84468042804287FA8000000001F080108011401620000
+CAF8:00007BE808A811282AB84468042804287FA8000008000800080008000FF80000
+CAF9:00007BE808A811282AB84468042804287FA80000000010F8101010301ECC0000
+CAFA:00007BE808A811282AB84468042804287FA800000808087F081C08220F9C0000
+CAFB:00007BE808A811282AB84468042804287FA8000003F802000200020003F80000
+CAFC:00007BE808A811282AB84468042804287FA8000007F8000807F8040007F80000
+CAFD:00007BE808A811282AB84468042804287FA800003EF802083E0820083E080000
+CAFE:00007BE808A811282AB84468042804287FA800003EF802883E8820883EF80000
+CAFF:00007BE808A811282AB84468042804287FA800003E8802883EF820883EF80000
+CB00:00007BE808A811282AB84468042804287FA800001F0801081F0810141F620000
+CB01:00007BE808A811282AB84468042804287FA800003EF802803EF820803EF80000
+CB02:00007BE808A811282AB84468042804287FA800003EFC02483E4820483EFC0000
+CB03:00007BE808A811282AB84468042804287FA800001F08017F1F1C10221F1C0000
+CB04:00007BE808A811282AB84468042804287FA8000003F802080208020803F80000
+CB05:00007BE808A811282AB84468042804287FA800000208020803F8020803F80000
+CB06:00007BE808A811282AB84468042804287FA80000110811081F0811141F620000
+CB07:00007BE808A811282AB84468042804287FA80000001000100010006801840000
+CB08:00007BE808A811282AB84468042804287FA800000048004800A8011406620000
+CB09:00007BE808A811282AB84468042804287FA80000000003F00408040803F00000
+CB0A:00007BE808A811282AB84468042804287FA8000003F80020002000D003080000
+CB0B:00007BE808A811282AB84468042804287FA80000004003F8004000A003180000
+CB0C:00007BE808A811282AB84468042804287FA8000003F8000803F8000800080000
+CB0D:00007BE808A811282AB84468042804287FA8000003F8020003F8020003F80000
+CB0E:00007BE808A811282AB84468042804287FA8000000000FF8022002200FF80000
+CB0F:00007BE808A811282AB84468042804287FA8000000800FF803E0041003E00000
+CB10:0000000800087B8808880888190815082288CC48040804087FE8000800080000
+CB11:00007BC8088811082A884448040804087FE8000007F800080008000800080000
+CB12:00007BC8088811082A884448040804087FE8000000003EF80208020802080000
+CB13:00007BC8088811082A884448040804087FE8000000001F080108011401620000
+CB14:00007BC8088811082A884448040804087FE8000008000800080008000FF80000
+CB15:00007BC8088811082A884448040804087FE80000000010F8101010301ECC0000
+CB16:00007BC8088811082A884448040804087FE800000808087F081C08220F9C0000
+CB17:00007BC8088811082A884448040804087FE8000003F802000200020003F80000
+CB18:00007BC8088811082A884448040804087FE8000007F8000807F8040007F80000
+CB19:00007BC8088811082A884448040804087FE800003EF802083E0820083E080000
+CB1A:00007BC8088811082A884448040804087FE800003EF802883E8820883EF80000
+CB1B:00007BC8088811082A884448040804087FE800003E8802883EF820883EF80000
+CB1C:00007BC8088811082A884448040804087FE800001F0801081F0810141F620000
+CB1D:00007BC8088811082A884448040804087FE800003EF802803EF820803EF80000
+CB1E:00007BC8088811082A884448040804087FE800003EFC02483E4820483EFC0000
+CB1F:00007BC8088811082A884448040804087FE800001F08017F1F1C10221F1C0000
+CB20:00007BC8088811082A884448040804087FE8000003F802080208020803F80000
+CB21:00007BC8088811082A884448040804087FE800000208020803F8020803F80000
+CB22:00007BC8088811082A884448040804087FE80000110811081F0811141F620000
+CB23:00007BC8088811082A884448040804087FE80000001000100010006801840000
+CB24:00007BC8088811082A884448040804087FE800000048004800A8011406620000
+CB25:00007BC8088811082A884448040804087FE80000000003F00408040803F00000
+CB26:00007BC8088811082A884448040804087FE8000003F80020002000D003080000
+CB27:00007BC8088811082A884448040804087FE80000004003F8004000A003180000
+CB28:00007BC8088811082A884448040804087FE8000003F8000803F8000800080000
+CB29:00007BC8088811082A884448040804087FE8000003F8020003F8020003F80000
+CB2A:00007BC8088811082A884448040804087FE8000000000FF8022002200FF80000
+CB2B:00007BC8088811082A884448040804087FE8000000800FF803E0041003E00000
+CB2C:0000000000001EE0022002200640054008A037500440044004407FFC00000000
+CB2D:00003DE00440088015402220044004407FFC00001FF000100010001000100000
+CB2E:00003DE00440088015402220044004407FFC000000003EF80208020802080000
+CB2F:00003DE00440088015402220044004407FFC000000001E100210022802C40000
+CB30:00003DE00440088015402220044004407FFC000000001000100010001FF00000
+CB31:00003DE00440088015402220044004407FFC0000000020F8201020303ECC0000
+CB32:00003DE00440088015402220044004407FFC0000202021FC207020883E700000
+CB33:00003DE00440088015402220044004407FFC00001FF01000100010001FF00000
+CB34:00003DE00440088015402220044004407FFC00001FF000101FF010001FF00000
+CB35:00003DE00440088015402220044004407FFC00003EF802083E0820083E080000
+CB36:00003DE00440088015402220044004407FFC00003EF802883E8820883EF80000
+CB37:00003DE00440088015402220044004407FFC00003E8802883EF820883EF80000
+CB38:00003DE00440088015402220044004407FFC00003E1002103E1020283EC40000
+CB39:00003DE00440088015402220044004407FFC00003EF802803EF820803EF80000
+CB3A:00003DE00440088015402220044004407FFC00003EFC02483E4820483EFC0000
+CB3B:00003DE00440088015402220044004407FFC00003E2003FC3E7020883E700000
+CB3C:00003DE00440088015402220044004407FFC00001FF01010101010101FF00000
+CB3D:00003DE00440088015402220044004407FFC0000101010101FF010101FF00000
+CB3E:00003DE00440088015402220044004407FFC0000222022203E2022503E880000
+CB3F:00003DE00440088015402220044004407FFC000000000100010002800C400000
+CB40:00003DE00440088015402220044004407FFC00000000024002400DA033100000
+CB41:00003DE00440088015402220044004407FFC0000000007C00820082007C00000
+CB42:00003DE00440088015402220044004407FFC0000000007E00080014006200000
+CB43:00003DE00440088015402220044004407FFC0000008007E00080014006200000
+CB44:00003DE00440088015402220044004407FFC00001FF000101FF0001000100000
+CB45:00003DE00440088015402220044004407FFC00001FF010001FF010001FF00000
+CB46:00003DE00440088015402220044004407FFC000000001FF0044004401FF00000
+CB47:00003DE00440088015402220044004407FFC000001001FF007C0082007C00000
+CB48:000000001EE0022002200640054008A0331000003FF801000100010001000000
+CB49:00003DE0044008801540222000007FFC010001001FF000100010001000100000
+CB4A:00003DE0044008801540222000007FFC0100010000003EF80208020802080000
+CB4B:00003DE0044008801540222000007FFC0100010000001E100210022802C40000
+CB4C:00003DE00440088015402220000000007FFC010001001100100010001FF00000
+CB4D:00003DE0044008801540222000007FFC01000100000020F8201020303ECC0000
+CB4E:00003DE0044008801540222000007FFC01000100202021FC207020883E700000
+CB4F:00003DE0044008801540222000007FFC010001001FF01000100010001FF00000
+CB50:00003DE0044008801540222000007FFC010001001FF000101FF010001FF00000
+CB51:00003DE0044008801540222000007FFC010001003EF802083E0820083E080000
+CB52:00003DE0044008801540222000007FFC010001003EF802883E8820883EF80000
+CB53:00003DE0044008801540222000007FFC010001003E8802883EF820883EF80000
+CB54:00003DE0044008801540222000007FFC010001003E1002103E1020283EC40000
+CB55:00003DE0044008801540222000007FFC010001003EF802803EF820803EF80000
+CB56:00003DE0044008801540222000007FFC010001003EFC02483E4820483EFC0000
+CB57:00003DE0044008801540222000007FFC010001003E2003FC3E7020883E700000
+CB58:00003DE0044008801540222000007FFC010001001FF01010101010101FF00000
+CB59:00003DE0044008801540222000007FFC01000100101010101FF010101FF00000
+CB5A:00003DE0044008801540222000007FFC01000100222022203E2022503E880000
+CB5B:00003DE0044008801540222000007FFC0100010000000100010002800C400000
+CB5C:00003DE0044008801540222000007FFC010001000000024002400DA033100000
+CB5D:00003DE0044008801540222000007FFC01000100000007C00820082007C00000
+CB5E:00003DE0044008801540222000007FFC01000100000007E00080014006200000
+CB5F:00003DE0044008801540222000007FFC01000100008007E00080014006200000
+CB60:00003DE0044008801540222000007FFC010001001FF000101FF0001000100000
+CB61:00003DE0044008801540222000007FFC010001001FF010001FF010001FF00000
+CB62:00003DE0044008801540222000007FFC0100010000001FF0044004401FF00000
+CB63:00003DE0044008801540222000007FFC0100010001001FF007C0082007C00000
+CB64:000000087B8808880888190815082288CC4800087FE8040804F8040804080000
+CB65:7BC8088811082A88444800087FE8027802080000000007F80008000800080000
+CB66:7BC8088811082A88444800087FE802780208000000003EF80208020802080000
+CB67:7BC8088811082A88444800087FE802780208000000001F080108011401620000
+CB68:7BC8088811082A884448000800087FE80278020802081000100010001FF80000
+CB69:7BC8088811082A88444800087FE8027802080000000020F8201020303ECC0000
+CB6A:7BC8088811082A88444800087FE8027802080000202021FC207020883E700000
+CB6B:7BC8088811082A88444800087FE802780208000003F802000200020003F80000
+CB6C:7BC8088811082A88444800087FE802780208000007F8000807F8040007F80000
+CB6D:7BC8088811082A88444800087FE80278020800003EF802083E0820083E080000
+CB6E:7BC8088811082A88444800087FE80278020800003EF802883E8820883EF80000
+CB6F:7BC8088811082A88444800087FE80278020800003E8802883EF820883EF80000
+CB70:7BC8088811082A88444800087FE80278020800000F8800880F8808140FA20000
+CB71:7BC8088811082A88444800087FE80278020800003EF802803EF820803EF80000
+CB72:7BC8088811082A88444800087FE80278020800003EFC02483E4820483EFC0000
+CB73:7BC8088811082A88444800087FE80278020800003E1002FE3E3820443E380000
+CB74:7BC8088811082A88444800087FE802780208000003F802080208020803F80000
+CB75:7BC8088811082A88444800087FE80278020800000208020803F8020803F80000
+CB76:7BC8088811082A88444800087FE8027802080000210821083F0821143F620000
+CB77:7BC8088811082A88444800087FE8027802080000001000100010006801840000
+CB78:7BC8088811082A88444800087FE80278020800000048004800A8011406620000
+CB79:7BC8088811082A88444800087FE8027802080000000003F00408040803F00000
+CB7A:7BC8088811082A88444800087FE802780208000003F80020002000D003080000
+CB7B:7BC8088811082A88444800087FE8027802080000004003F8004000A003180000
+CB7C:7BC8088811082A88444800087FE802780208000003F8000803F8000800080000
+CB7D:7BC8088811082A88444800087FE802780208000003F8020003F8020003F80000
+CB7E:7BC8088811082A88444800087FE802780208000000000FF8022002200FF80000
+CB7F:7BC8088811082A88444800087FE802780208000000800FF803E0041003E00000
+CB80:0000000A7B8A088A088A190A150A228ACC4A000A7FEA040A047A040A040A0000
+CB81:7BE808A811282AA8446800287FA805E804280000000007F80008000800080000
+CB82:7BE808A811282AA8446800287FA805E80428000000003EF80208020802080000
+CB83:7BE808A811282AA8446800287FA805E80428000000001F080108011401620000
+CB84:7BE808A811282AA84468002800287FA8042805E804281428100010001FF80000
+CB85:7BE808A811282AA8446800287FA805E804280000000020F8201020303ECC0000
+CB86:7BE808A811282AA8446800287FA805E804280000202021FC207020883E700000
+CB87:7BE808A811282AA8446800287FA805E80428000003F802000200020003F80000
+CB88:7BE808A811282AA8446800287FA805E80428000007F8000807F8040007F80000
+CB89:7BE808A811282AA8446800287FA805E8042800003EF802083E0820083E080000
+CB8A:7BE808A811282AA8446800287FA805E8042800003EF802883E8820883EF80000
+CB8B:7BE808A811282AA8446800287FA805E8042800003E8802883EF820883EF80000
+CB8C:7BE808A811282AA8446800287FA805E8042800000F8800880F8808140FA20000
+CB8D:7BE808A811282AA8446800287FA805E8042800003EF802803EF820803EF80000
+CB8E:7BE808A811282AA8446800287FA805E8042800003EFC02483E4820483EFC0000
+CB8F:7BE808A811282AA8446800287FA805E8042800003E1002FE3E3820443E380000
+CB90:7BE808A811282AA8446800287FA805E80428000003F802080208020803F80000
+CB91:7BE808A811282AA8446800287FA805E8042800000208020803F8020803F80000
+CB92:7BE808A811282AA8446800287FA805E804280000210821083F0821143F620000
+CB93:7BE808A811282AA8446800287FA805E804280000001000100010006801840000
+CB94:7BE808A811282AA8446800287FA805E8042800000048004800A8011406620000
+CB95:7BE808A811282AA8446800287FA805E804280000000003F00408040803F00000
+CB96:7BE808A811282AA8446800287FA805E80428000003F80020002000D003080000
+CB97:7BE808A811282AA8446800287FA805E804280000004003F8004000A003180000
+CB98:7BE808A811282AA8446800287FA805E80428000003F8000803F8000800080000
+CB99:7BE808A811282AA8446800287FA805E80428000003F8020003F8020003F80000
+CB9A:7BE808A811282AA8446800287FA805E80428000000000FF8022002200FF80000
+CB9B:7BE808A811282AA8446800287FA805E80428000000800FF803E0041003E00000
+CB9C:000000087B8808880888190815082288CC4800087FE804080408040804080000
+CB9D:7BC8088811082A88444800087FE8020802000000000007F80008000800080000
+CB9E:7BC8088811082A88444800087FE802080200000000003EF80208020802080000
+CB9F:7BC8088811082A88444800087FE802080200000000001F080108011401620000
+CBA0:7BC8088811082A884448000800087FE80208020802081008100010001FF80000
+CBA1:7BC8088811082A88444800087FE8020802000000000020F8201020303ECC0000
+CBA2:7BC8088811082A88444800087FE8020802000000202021FC207020883E700000
+CBA3:7BC8088811082A88444800087FE802080200000003F802000200020003F80000
+CBA4:7BC8088811082A88444800087FE802080200000007F8000807F8040007F80000
+CBA5:7BC8088811082A88444800087FE80208020000003EF802083E0820083E080000
+CBA6:7BC8088811082A88444800087FE80208020000003EF802883E8820883EF80000
+CBA7:7BC8088811082A88444800087FE80208020000003E8802883EF820883EF80000
+CBA8:7BC8088811082A88444800087FE80208020000000F8800880F8808140FA20000
+CBA9:7BC8088811082A88444800087FE80208020000003EF802803EF820803EF80000
+CBAA:7BC8088811082A88444800087FE80208020000003EFC02483E4820483EFC0000
+CBAB:7BC8088811082A88444800087FE80208020000003E1002FE3E3820443E380000
+CBAC:7BC8088811082A88444800087FE802080200000003F802080208020803F80000
+CBAD:7BC8088811082A88444800087FE80208020000000208020803F8020803F80000
+CBAE:7BC8088811082A88444800087FE8020802000000210821083F0821143F620000
+CBAF:7BC8088811082A88444800087FE8020802000000001000100010006801840000
+CBB0:7BC8088811082A88444800087FE80208020000000048004800A8011406620000
+CBB1:7BC8088811082A88444800087FE8020802000000000003F00408040803F00000
+CBB2:7BC8088811082A88444800087FE802080200000003F80020002000D003080000
+CBB3:7BC8088811082A88444800087FE8020802000000004003F8004000A003180000
+CBB4:7BC8088811082A88444800087FE802080200000003F8000803F8000800080000
+CBB5:7BC8088811082A88444800087FE802080200000003F8020003F8020003F80000
+CBB6:7BC8088811082A88444800087FE802080200000000000FF8022002200FF80000
+CBB7:7BC8088811082A88444800087FE802080200000000800FF803E0041003E00000
+CBB8:000000001EE0022002200640054008A0331000007FFC04400440044004400000
+CBB9:00003DE0044008801540222000007FFC044004401FF000100010001000100000
+CBBA:00003DE0044008801540222000007FFC0440044000003EF80208020802080000
+CBBB:00003DE0044008801540222000007FFC0440044000001E100210022802C40000
+CBBC:00003DE00440088015402220000000007FFC044004401440100010001FF00000
+CBBD:00003DE0044008801540222000007FFC04400440000020F8201020303ECC0000
+CBBE:00003DE0044008801540222000007FFC04400440202021FC207020883E700000
+CBBF:00003DE0044008801540222000007FFC044004401FF01000100010001FF00000
+CBC0:00003DE0044008801540222000007FFC044004401FF000101FF010001FF00000
+CBC1:00003DE0044008801540222000007FFC044004403EF802083E0820083E080000
+CBC2:00003DE0044008801540222000007FFC044004403EF802883E8820883EF80000
+CBC3:00003DE0044008801540222000007FFC044004403E8802883EF820883EF80000
+CBC4:00003DE0044008801540222000007FFC044004403E1002103E1020283EC40000
+CBC5:00003DE0044008801540222000007FFC044004403EF802803EF820803EF80000
+CBC6:00003DE0044008801540222000007FFC044004403EFC02483E4820483EFC0000
+CBC7:00003DE0044008801540222000007FFC044004403E2003FC3E7020883E700000
+CBC8:00003DE0044008801540222000007FFC044004401FF01010101010101FF00000
+CBC9:00003DE0044008801540222000007FFC04400440101010101FF010101FF00000
+CBCA:00003DE0044008801540222000007FFC04400440222022203E2022503E880000
+CBCB:00003DE0044008801540222000007FFC0440044000000100010002800C400000
+CBCC:00003DE0044008801540222000007FFC044004400000024002400DA033100000
+CBCD:00003DE0044008801540222000007FFC04400440000007C00820082007C00000
+CBCE:00003DE0044008801540222000007FFC04400440000007E00080014006200000
+CBCF:00003DE0044008801540222000007FFC04400440008007E00080014006200000
+CBD0:00003DE0044008801540222000007FFC044004401FF000101FF0001000100000
+CBD1:00003DE0044008801540222000007FFC044004401FF010001FF010001FF00000
+CBD2:00003DE0044008801540222000007FFC0440044000001FF0044004401FF00000
+CBD3:00003DE0044008801540222000007FFC0440044001001FF007C0082007C00000
+CBD4:0000000000001EE0022002200640054008A0331000007FFC0000000000000000
+CBD5:00003DE00440088015402220000000007FFC00001FF000100010001000100000
+CBD6:00003DE00440088015402220000000007FFC000000003EF80208020802080000
+CBD7:00003DE00440088015402220000000007FFC000000001E100210022802C40000
+CBD8:00003DE00440088015402220000000007FFC000000001000100010001FF00000
+CBD9:00003DE00440088015402220000000007FFC0000000020F8201020303ECC0000
+CBDA:00003DE00440088015402220000000007FFC0000202021FC207020883E700000
+CBDB:00003DE00440088015402220000000007FFC00001FF01000100010001FF00000
+CBDC:00003DE00440088015402220000000007FFC00001FF000101FF010001FF00000
+CBDD:00003DE00440088015402220000000007FFC00003EF802083E0820083E080000
+CBDE:00003DE00440088015402220000000007FFC00003EF802883E8820883EF80000
+CBDF:00003DE00440088015402220000000007FFC00003E8802883EF820883EF80000
+CBE0:00003DE00440088015402220000000007FFC00003E1002103E1020283EC40000
+CBE1:00003DE00440088015402220000000007FFC00003EF802803EF820803EF80000
+CBE2:00003DE00440088015402220000000007FFC00003EFC02483E4820483EFC0000
+CBE3:00003DE00440088015402220000000007FFC00003E2003FC3E7020883E700000
+CBE4:00003DE00440088015402220000000007FFC00001FF01010101010101FF00000
+CBE5:00003DE00440088015402220000000007FFC0000101010101FF010101FF00000
+CBE6:00003DE00440088015402220000000007FFC0000222022203E2022503E880000
+CBE7:00003DE00440088015402220000000007FFC000000000100010002800C400000
+CBE8:00003DE00440088015402220000000007FFC00000000024002400DA033100000
+CBE9:00003DE00440088015402220000000007FFC0000000007C00820082007C00000
+CBEA:00003DE00440088015402220000000007FFC0000000007E00080014006200000
+CBEB:00003DE00440088015402220000000007FFC0000008007E00080014006200000
+CBEC:00003DE00440088015402220000000007FFC00001FF000101FF0001000100000
+CBED:00003DE00440088015402220000000007FFC00001FF010001FF010001FF00000
+CBEE:00003DE00440088015402220000000007FFC000000001FF0044004401FF00000
+CBEF:00003DE00440088015402220000000007FFC000001001FF007C0082007C00000
+CBF0:0000000800087B8808880888190815082288CC4800087FE80008000800080000
+CBF1:00007BC8088811082A884448000800087FE8000007F800080008000800080000
+CBF2:00007BC8088811082A884448000800087FE8000000003EF80208020802080000
+CBF3:00007BC8088811082A884448000800087FE8000000001F080108011401620000
+CBF4:00007BC8088811082A884448000800087FE8000008000800080008000FF80000
+CBF5:00007BC8088811082A884448000800087FE80000000010F8101010301ECC0000
+CBF6:00007BC8088811082A884448000800087FE800000808087F081C08220F9C0000
+CBF7:00007BC8088811082A884448000800087FE8000003F802000200020003F80000
+CBF8:00007BC8088811082A884448000800087FE8000007F8000807F8040007F80000
+CBF9:00007BC8088811082A884448000800087FE800003EF802083E0820083E080000
+CBFA:00007BC8088811082A884448000800087FE800003EF802883E8820883EF80000
+CBFB:00007BC8088811082A884448000800087FE800003E8802883EF820883EF80000
+CBFC:00007BC8088811082A884448000800087FE800001F0801081F0810141F620000
+CBFD:00007BC8088811082A884448000800087FE800003EF802803EF820803EF80000
+CBFE:00007BC8088811082A884448000800087FE800003EFC02483E4820483EFC0000
+CBFF:00007BC8088811082A884448000800087FE800001F08017F1F1C10221F1C0000
+CC00:00007BC8088811082A884448000800087FE8000003F802080208020803F80000
+CC01:00007BC8088811082A884448000800087FE800000208020803F8020803F80000
+CC02:00007BC8088811082A884448000800087FE80000110811081F0811141F620000
+CC03:00007BC8088811082A884448000800087FE80000001000100010006801840000
+CC04:00007BC8088811082A884448000800087FE800000048004800A8011406620000
+CC05:00007BC8088811082A884448000800087FE80000000003F00408040803F00000
+CC06:00007BC8088811082A884448000800087FE8000003F80020002000D003080000
+CC07:00007BC8088811082A884448000800087FE80000004003F8004000A003180000
+CC08:00007BC8088811082A884448000800087FE8000003F8000803F8000800080000
+CC09:00007BC8088811082A884448000800087FE8000003F8020003F8020003F80000
+CC0A:00007BC8088811082A884448000800087FE8000000000FF8022002200FF80000
+CC0B:00007BC8088811082A884448000800087FE8000000800FF803E0041003E00000
+CC0C:00000000000800087B8808880888190815082288CC4800080008000800080000
+CC0D:0000000800087708220822085508888800080000000007F80008000800080000
+CC0E:000000080008770822082208550888880008000000003EF80208020802080000
+CC0F:000000080008770822082208550888880008000000001F080108011401620000
+CC10:000000080008770822082208550888880008000800001000100010001FF80000
+CC11:0000000800087708220822085508888800080000000020F8201020303ECC0000
+CC12:0000000800087708220822085508888800080000202021FC207020883E700000
+CC13:000000080008770822082208550888880008000003F802000200020003F80000
+CC14:000000080008770822082208550888880008000007F8000807F8040007F80000
+CC15:00000008000877082208220855088888000800003EF802083E0820083E080000
+CC16:00000008000877082208220855088888000800003EF802883E8820883EF80000
+CC17:00000008000877082208220855088888000800003E8802883EF820883EF80000
+CC18:00000008000877082208220855088888000800000F8800880F8808140FA20000
+CC19:00000008000877082208220855088888000800003EF802803EF820803EF80000
+CC1A:00000008000877082208220855088888000800003EFC02483E4820483EFC0000
+CC1B:00000008000877082208220855088888000800003E1002FE3E3820443E380000
+CC1C:000000080008770822082208550888880008000003F802080208020803F80000
+CC1D:00000008000877082208220855088888000800000208020803F8020803F80000
+CC1E:0000000800087708220822085508888800080000210821083F0821143F620000
+CC1F:0000000800087708220822085508888800080000001000100010006801840000
+CC20:00000008000877082208220855088888000800000048004800A8011406620000
+CC21:0000000800087708220822085508888800080000000003F00408040803F00000
+CC22:000000080008770822082208550888880008000003F80020002000D003080000
+CC23:0000000800087708220822085508888800080000004003F8004000A003180000
+CC24:000000080008770822082208550888880008000003F8000803F8000800080000
+CC25:000000080008770822082208550888880008000003F8020003F8020003F80000
+CC26:000000080008770822082208550888880008000000000FF8022002200FF80000
+CC27:000000080008770822082208550888880008000000800FF803E0041003E00000
+CC28:000000000010041004103F900110021E06100910309000100010001000100000
+CC29:00000008000808087E08080E140862080008000007F800080008000800080000
+CC2A:00000008000808087E08080E140862080008000000003EF80208020802080000
+CC2B:00000008000808087E08080E140862080008000000001F080108011401620000
+CC2C:00000008000808087E08080E140862080008000808000800080008000FF80000
+CC2D:00000008000808087E08080E1408620800080000000010F8101010301ECC0000
+CC2E:00000008000808087E08080E14086208000800000808087F081C08220F9C0000
+CC2F:00000008000808087E08080E140862080008000003F802000200020003F80000
+CC30:00000008000808087E08080E140862080008000007F8000807F8040007F80000
+CC31:00000008000808087E08080E14086208000800003EF802083E0820083E080000
+CC32:00000008000808087E08080E14086208000800003EF802883E8820883EF80000
+CC33:00000008000808087E08080E14086208000800003E8802883EF820883EF80000
+CC34:00000008000808087E08080E14086208000800001F0801081F0810141F620000
+CC35:00000008000808087E08080E14086208000800003EF802803EF820803EF80000
+CC36:00000008000808087E08080E14086208000800003EFC02483E4820483EFC0000
+CC37:00000008000808087E08080E14086208000800001F08017F1F1C10221F1C0000
+CC38:00000008000808087E08080E140862080008000003F802080208020803F80000
+CC39:00000008000808087E08080E14086208000800000208020803F8020803F80000
+CC3A:00000008000808087E08080E1408620800080000110811081F0811141F620000
+CC3B:00000008000808087E08080E1408620800080000001000100010006801840000
+CC3C:00000008000808087E08080E14086208000800000048004800A8011406620000
+CC3D:00000008000808087E08080E1408620800080000000003F00408040803F00000
+CC3E:00000008000808087E08080E140862080008000003F80020002000D003080000
+CC3F:00000008000808087E08080E1408620800080000004003F8004000A003180000
+CC40:00000008000808087E08080E140862080008000003F8000803F8000800080000
+CC41:00000008000808087E08080E140862080008000003F8020003F8020003F80000
+CC42:00000008000808087E08080E140862080008000000000FF8022002200FF80000
+CC43:00000008000808087E08080E140862080008000000800FF803E0041003E00000
+CC44:000000000012041204123F920112021E06120912309200120012001200120000
+CC45:00000028002808287E280838142862280028000007F800080008000800080000
+CC46:00000028002808287E280838142862280028000000003EF80208020802080000
+CC47:00000028002808287E280838142862280028000000003E100210022802C40000
+CC48:00000028002808287E280838142862280028002808000800080008000FF80000
+CC49:00000028002808287E2808381428622800280000000020F8201020303ECC0000
+CC4A:00000028002808287E2808381428622800280000202021FC207020883E700000
+CC4B:00000028002808287E280838142862280028000003F802000200020003F80000
+CC4C:00000028002808287E280838142862280028000007F8000807F8040007F80000
+CC4D:00000028002808287E28083814286228002800003EF802083E0820083E080000
+CC4E:00000028002808287E28083814286228002800003EF802883E8820883EF80000
+CC4F:00000028002808287E28083814286228002800003E8802883EF820883EF80000
+CC50:00000028002808287E28083814286228002800001F0801081F0810141F620000
+CC51:00000028002808287E28083814286228002800003EF802803EF820803EF80000
+CC52:00000028002808287E28083814286228002800003EFC02483E4820483EFC0000
+CC53:00000028002808287E28083814286228002800003E1002FE3E3820443E380000
+CC54:00000028002808287E280838142862280028000003F802080208020803F80000
+CC55:00000028002808287E28083814286228002800000208020803F8020803F80000
+CC56:00000028002808287E2808381428622800280000110811081F0811141F620000
+CC57:00000028002808287E2808381428622800280000000800080008003400C20000
+CC58:00000028002808287E28083814286228002800000048004800A8011406620000
+CC59:00000028002808287E2808381428622800280000000001F00208020801F00000
+CC5A:00000028002808287E280838142862280028000003F80020002000D003080000
+CC5B:00000028002808287E2808381428622800280000004003F8004000A003180000
+CC5C:00000028002808287E280838142862280028000003F8000803F8000800080000
+CC5D:00000028002808287E280838142862280028000003F8020003F8020003F80000
+CC5E:00000028002808287E280838142862280028000000000FF8022002200FF80000
+CC5F:00000028002808287E280838142862280028000000800FF803E0041003E00000
+CC60:000000000010041004103F90011E02100610091E309000100010001000100000
+CC61:00000008000808087E0E0808140E62080008000007F800080008000800080000
+CC62:00000008000808087E0E0808140E62080008000000003EF80208020802080000
+CC63:00000008000808087E0E0808140E62080008000000001F080108011401620000
+CC64:00000008000808087E0E0808140E62080008000008000800080008000FF80000
+CC65:00000008000808087E0E0808140E620800080000000010F8101010301ECC0000
+CC66:00000008000808087E0E0808140E6208000800000808087F081C08220F9C0000
+CC67:00000008000808087E0E0808140E62080008000003F802000200020003F80000
+CC68:00000008000808087E0E0808140E62080008000007F8000807F8040007F80000
+CC69:00000008000808087E0E0808140E6208000800003EF802083E0820083E080000
+CC6A:00000008000808087E0E0808140E6208000800003EF802883E8820883EF80000
+CC6B:00000008000808087E0E0808140E6208000800003E8802883EF820883EF80000
+CC6C:00000008000808087E0E0808140E6208000800001F0801081F0810141F620000
+CC6D:00000008000808087E0E0808140E6208000800003EF802803EF820803EF80000
+CC6E:00000008000808087E0E0808140E6208000800003EFC02483E4820483EFC0000
+CC6F:00000008000808087E0E0808140E6208000800001F08017F1F1C10221F1C0000
+CC70:00000008000808087E0E0808140E62080008000003F802080208020803F80000
+CC71:00000008000808087E0E0808140E6208000800000208020803F8020803F80000
+CC72:00000008000808087E0E0808140E620800080000110811081F0811141F620000
+CC73:00000008000808087E0E0808140E620800080000001000100010006801840000
+CC74:00000008000808087E0E0808140E6208000800000048004800A8011406620000
+CC75:00000008000808087E0E0808140E620800080000000003F00408040803F00000
+CC76:00000008000808087E0E0808140E62080008000003F80020002000D003080000
+CC77:00000008000808087E0E0808140E620800080000004003F8004000A003180000
+CC78:00000008000808087E0E0808140E62080008000003F8000803F8000800080000
+CC79:00000008000808087E0E0808140E62080008000003F8020003F8020003F80000
+CC7A:00000008000808087E0E0808140E62080008000000000FF8022002200FF80000
+CC7B:00000008000808087E0E0808140E62080008000000800FF803E0041003E00000
+CC7C:000000000012041204123F92011E02120612091E309200120012001200120000
+CC7D:00000028002808287E380828143862280028000007F800080008000800080000
+CC7E:00000028002808287E380828143862280028000000003EF80208020802080000
+CC7F:00000028002808287E380828143862280028000000003E100210022802C40000
+CC80:00000028002808287E380828143862280028002808000800080008000FF80000
+CC81:00000028002808287E3808281438622800280000000020F8201020303ECC0000
+CC82:00000028002808287E3808281438622800280000202021FC207020883E700000
+CC83:00000028002808287E380828143862280028000003F802000200020003F80000
+CC84:00000028002808287E380828143862280028000007F8000807F8040007F80000
+CC85:00000028002808287E38082814386228002800003EF802083E0820083E080000
+CC86:00000028002808287E38082814386228002800003EF802883E8820883EF80000
+CC87:00000028002808287E38082814386228002800003E8802883EF820883EF80000
+CC88:00000028002808287E38082814386228002800001F0801081F0810141F620000
+CC89:00000028002808287E38082814386228002800003EF802803EF820803EF80000
+CC8A:00000028002808287E38082814386228002800003EFC02483E4820483EFC0000
+CC8B:00000028002808287E38082814386228002800003E1002FE3E3820443E380000
+CC8C:00000028002808287E380828143862280028000003F802080208020803F80000
+CC8D:00000028002808287E38082814386228002800000208020803F8020803F80000
+CC8E:00000028002808287E3808281438622800280000110811081F0811141F620000
+CC8F:00000028002808287E3808281438622800280000000800080008003400C20000
+CC90:00000028002808287E38082814386228002800000048004800A8011406620000
+CC91:00000028002808287E3808281438622800280000000001F00208020801F00000
+CC92:00000028002808287E380828143862280028000003F80020002000D003080000
+CC93:00000028002808287E3808281438622800280000004003F8004000A003180000
+CC94:00000028002808287E380828143862280028000003F8000803F8000800080000
+CC95:00000028002808287E380828143862280028000003F8020003F8020003F80000
+CC96:00000028002808287E380828143862280028000000000FF8022002200FF80000
+CC97:00000028002808287E380828143862280028000000800FF803E0041003E00000
+CC98:000000000002040204023F820102021E06020902308200020002000200020000
+CC99:00000008000808087E0808381408620800080000000007F80008000800080000
+CC9A:00000008000808087E080838140862080008000000003EF80208020802080000
+CC9B:00000008000808087E080838140862080008000000001F080108011401620000
+CC9C:00000008000808087E080838140862080008000000001000100010001FF80000
+CC9D:00000008000808087E0808381408620800080000000020F8201020303ECC0000
+CC9E:00000008000808087E0808381408620800080000202021FC207020883E700000
+CC9F:00000008000808087E080838140862080008000003F802000200020003F80000
+CCA0:00000008000808087E080838140862080008000007F8000807F8040007F80000
+CCA1:00000008000808087E08083814086208000800003EF802083E0820083E080000
+CCA2:00000008000808087E08083814086208000800003EF802883E8820883EF80000
+CCA3:00000008000808087E08083814086208000800003E8802883EF820883EF80000
+CCA4:00000008000808087E08083814086208000800000F8800880F8808140FA20000
+CCA5:00000008000808087E08083814086208000800003EF802803EF820803EF80000
+CCA6:00000008000808087E08083814086208000800003EFC02483E4820483EFC0000
+CCA7:00000008000808087E08083814086208000800003E1002FE3E3820443E380000
+CCA8:00000008000808087E080838140862080008000003F802080208020803F80000
+CCA9:00000008000808087E08083814086208000800000208020803F8020803F80000
+CCAA:00000008000808087E0808381408620800080000210821083F0821143F620000
+CCAB:00000008000808087E0808381408620800080000001000100010006801840000
+CCAC:00000008000808087E08083814086208000800000048004800A8011406620000
+CCAD:00000008000808087E0808381408620800080000000003F00408040803F00000
+CCAE:00000008000808087E080838140862080008000003F80020002000D003080000
+CCAF:00000008000808087E0808381408620800080000004003F8004000A003180000
+CCB0:00000008000808087E080838140862080008000003F8000803F8000800080000
+CCB1:00000008000808087E080838140862080008000003F8020003F8020003F80000
+CCB2:00000008000808087E080838140862080008000000000FF8022002200FF80000
+CCB3:00000008000808087E080838140862080008000000800FF803E0041003E00000
+CCB4:00000000000A040A040A3F8A010A023A060A090A308A000A000A000A000A0000
+CCB5:00000028002808287E2808E8142862280028000007F800080008000800080000
+CCB6:00000028002808287E2808E8142862280028000000003EF80208020802080000
+CCB7:00000028002808287E2808E8142862280028000000003E100210022802C40000
+CCB8:00000028002808287E2808E8142862280028000008000800080008000FF80000
+CCB9:00000028002808287E2808E81428622800280000000020F8201020303ECC0000
+CCBA:00000028002808287E2808E81428622800280000202021FC207020883E700000
+CCBB:00000028002808287E2808E8142862280028000003F802000200020003F80000
+CCBC:00000028002808287E2808E8142862280028000007F8000807F8040007F80000
+CCBD:00000028002808287E2808E814286228002800003EF802083E0820083E080000
+CCBE:00000028002808287E2808E814286228002800003EF802883E8820883EF80000
+CCBF:00000028002808287E2808E814286228002800003E8802883EF820883EF80000
+CCC0:00000028002808287E2808E814286228002800001F0801081F0810141F620000
+CCC1:00000028002808287E2808E814286228002800003EF802803EF820803EF80000
+CCC2:00000028002808287E2808E814286228002800003EFC02483E4820483EFC0000
+CCC3:00000028002808287E2808E814286228002800003E1002FE3E3820443E380000
+CCC4:00000028002808287E2808E8142862280028000003F802080208020803F80000
+CCC5:00000028002808287E2808E814286228002800000208020803F8020803F80000
+CCC6:00000028002808287E2808E81428622800280000110811081F0811141F620000
+CCC7:00000028002808287E2808E81428622800280000000800080008003400C20000
+CCC8:00000028002808287E2808E814286228002800000048004800A8011406620000
+CCC9:00000028002808287E2808E81428622800280000000001F00208020801F00000
+CCCA:00000028002808287E2808E8142862280028000003F80020002000D003080000
+CCCB:00000028002808287E2808E81428622800280000004003F8004000A003180000
+CCCC:00000028002808287E2808E8142862280028000003F8000803F8000800080000
+CCCD:00000028002808287E2808E8142862280028000003F8020003F8020003F80000
+CCCE:00000028002808287E2808E8142862280028000000000FF8022002200FF80000
+CCCF:00000028002808287E2808E8142862280028000000800FF803E0041003E00000
+CCD0:000000000002040204023F82011E02020602091E308200020002000200020000
+CCD1:00000008000808087E3808081438620800080000000007F80008000800080000
+CCD2:00000008000808087E380808143862080008000000003EF80208020802080000
+CCD3:00000008000808087E380808143862080008000000001F080108011401620000
+CCD4:00000008000808087E380808143862080008000800001000100010001FF80000
+CCD5:00000008000808087E3808081438620800080000000020F8201020303ECC0000
+CCD6:00000008000808087E3808081438620800080000202021FC207020883E700000
+CCD7:00000008000808087E380808143862080008000003F802000200020003F80000
+CCD8:00000008000808087E380808143862080008000007F8000807F8040007F80000
+CCD9:00000008000808087E38080814386208000800003EF802083E0820083E080000
+CCDA:00000008000808087E38080814386208000800003EF802883E8820883EF80000
+CCDB:00000008000808087E38080814386208000800003E8802883EF820883EF80000
+CCDC:00000008000808087E38080814386208000800000F8800880F8808140FA20000
+CCDD:00000008000808087E38080814386208000800003EF802803EF820803EF80000
+CCDE:00000008000808087E38080814386208000800003EFC02483E4820483EFC0000
+CCDF:00000008000808087E38080814386208000800003E1002FE3E3820443E380000
+CCE0:00000008000808087E380808143862080008000003F802080208020803F80000
+CCE1:00000008000808087E38080814386208000800000208020803F8020803F80000
+CCE2:00000008000808087E3808081438620800080000210821083F0821143F620000
+CCE3:00000008000808087E3808081438620800080000001000100010006801840000
+CCE4:00000008000808087E38080814386208000800000048004800A8011406620000
+CCE5:00000008000808087E3808081438620800080000000003F00408040803F00000
+CCE6:00000008000808087E380808143862080008000003F80020002000D003080000
+CCE7:00000008000808087E3808081438620800080000004003F8004000A003180000
+CCE8:00000008000808087E380808143862080008000003F8000803F8000800080000
+CCE9:00000008000808087E380808143862080008000003F8020003F8020003F80000
+CCEA:00000008000808087E380808143862080008000000000FF8022002200FF80000
+CCEB:00000008000808087E380808143862080008000000800FF803E0041003E00000
+CCEC:00000000000A040A040A3F8A013A020A060A093A308A000A000A000A000A0000
+CCED:00000028002808287EE8082814E862280028000007F800080008000800080000
+CCEE:00000028002808287EE8082814E862280028000000003EF80208020802080000
+CCEF:00000028002808287EE8082814E862280028000000003E100210022802C40000
+CCF0:00000028002808287EE8082814E862280028002808000800080008000FF80000
+CCF1:00000028002808287EE8082814E8622800280000000020F8201020303ECC0000
+CCF2:00000028002808287EE8082814E8622800280000202021FC207020883E700000
+CCF3:00000028002808287EE8082814E862280028000003F802000200020003F80000
+CCF4:00000028002808287EE8082814E862280028000007F8000807F8040007F80000
+CCF5:00000028002808287EE8082814E86228002800003EF802083E0820083E080000
+CCF6:00000028002808287EE8082814E86228002800003EF802883E8820883EF80000
+CCF7:00000028002808287EE8082814E86228002800003E8802883EF820883EF80000
+CCF8:00000028002808287EE8082814E86228002800001F0801081F0810141F620000
+CCF9:00000028002808287EE8082814E86228002800003EF802803EF820803EF80000
+CCFA:00000028002808287EE8082814E86228002800003EFC02483E4820483EFC0000
+CCFB:00000028002808287EE8082814E86228002800003E1002FE3E3820443E380000
+CCFC:00000028002808287EE8082814E862280028000003F802080208020803F80000
+CCFD:00000028002808287EE8082814E86228002800000208020803F8020803F80000
+CCFE:00000028002808287EE8082814E8622800280000110811081F0811141F620000
+CCFF:00000028002808287EE8082814E8622800280000000800080008003400C20000
+CD00:00000028002808287EE8082814E86228002800000048004800A8011406620000
+CD01:00000028002808287EE8082814E8622800280000000001F00208020801F00000
+CD02:00000028002808287EE8082814E862280028000003F80020002000D003080000
+CD03:00000028002808287EE8082814E8622800280000004003F8004000A003180000
+CD04:00000028002808287EE8082814E862280028000003F8000803F8000800080000
+CD05:00000028002808287EE8082814E862280028000003F8020003F8020003F80000
+CD06:00000028002808287EE8082814E862280028000000000FF8022002200FF80000
+CD07:00000028002808287EE8082814E862280028000000800FF803E0041003E00000
+CD08:0000010001000FE000400080018002400C2000000100010001007FFC00000000
+CD09:000001000FC0010002800C40010001007FFC00001FF000100010001000100000
+CD0A:000001000FC0010002800C40010001007FFC000000003EF80208020802080000
+CD0B:000001000FC0010002800C40010001007FFC000000001E100210022802C40000
+CD0C:000001000FC0010002800C40010001007FFC000000001000100010001FF00000
+CD0D:000001000FC0010002800C40010001007FFC0000000020F8201020303ECC0000
+CD0E:000001000FC0010002800C40010001007FFC0000202021FC207020883E700000
+CD0F:000001000FC0010002800C40010001007FFC00001FF01000100010001FF00000
+CD10:000001000FC0010002800C40010001007FFC00001FF000101FF010001FF00000
+CD11:000001000FC0010002800C40010001007FFC00003EF802083E0820083E080000
+CD12:000001000FC0010002800C40010001007FFC00003EF802883E8820883EF80000
+CD13:000001000FC0010002800C40010001007FFC00003E8802883EF820883EF80000
+CD14:000001000FC0010002800C40010001007FFC00003E1002103E1020283EC40000
+CD15:000001000FC0010002800C40010001007FFC00003EF802803EF820803EF80000
+CD16:000001000FC0010002800C40010001007FFC00003EFC02483E4820483EFC0000
+CD17:000001000FC0010002800C40010001007FFC00003E2003FC3E7020883E700000
+CD18:000001000FC0010002800C40010001007FFC00001FF01010101010101FF00000
+CD19:000001000FC0010002800C40010001007FFC0000101010101FF010101FF00000
+CD1A:000001000FC0010002800C40010001007FFC0000222022203E2022503E880000
+CD1B:000001000FC0010002800C40010001007FFC000000000100010002800C400000
+CD1C:000001000FC0010002800C40010001007FFC00000000024002400DA033100000
+CD1D:000001000FC0010002800C40010001007FFC0000000007C00820082007C00000
+CD1E:000001000FC0010002800C40010001007FFC0000000007E00080014006200000
+CD1F:000001000FC0010002800C40010001007FFC0000008007E00080014006200000
+CD20:000001000FC0010002800C40010001007FFC00001FF000101FF0001000100000
+CD21:000001000FC0010002800C40010001007FFC00001FF010001FF010001FF00000
+CD22:000001000FC0010002800C40010001007FFC000000001FF0044004401FF00000
+CD23:000001000FC0010002800C40010001007FFC000001001FF007C0082007C00000
+CD24:00000010041004103F9001100210061E09103090041004107FD0001000100000
+CD25:000002081F880208050E1888040804087FE8000007F800080008000800080000
+CD26:000002081F880208050E1888040804087FE8000000003EF80208020802080000
+CD27:000002081F880208050E1888040804087FE8000000001F080108011401620000
+CD28:000002081F880208050E1888040804087FE8000008000800080008000FF80000
+CD29:000002081F880208050E1888040804087FE80000000010F8101010301ECC0000
+CD2A:000002081F880208050E1888040804087FE800000808087F081C08220F9C0000
+CD2B:000002081F880208050E1888040804087FE8000003F802000200020003F80000
+CD2C:000002081F880208050E1888040804087FE8000007F8000807F8040007F80000
+CD2D:000002081F880208050E1888040804087FE800003EF802083E0820083E080000
+CD2E:000002081F880208050E1888040804087FE800003EF802883E8820883EF80000
+CD2F:000002081F880208050E1888040804087FE800003E8802883EF820883EF80000
+CD30:000002081F880208050E1888040804087FE800001F0801081F0810141F620000
+CD31:000002081F880208050E1888040804087FE800003EF802803EF820803EF80000
+CD32:000002081F880208050E1888040804087FE800003EFC02483E4820483EFC0000
+CD33:000002081F880208050E1888040804087FE800001F08017F1F1C10221F1C0000
+CD34:000002081F880208050E1888040804087FE8000003F802080208020803F80000
+CD35:000002081F880208050E1888040804087FE800000208020803F8020803F80000
+CD36:000002081F880208050E1888040804087FE80000110811081F0811141F620000
+CD37:000002081F880208050E1888040804087FE80000001000100010006801840000
+CD38:000002081F880208050E1888040804087FE800000048004800A8011406620000
+CD39:000002081F880208050E1888040804087FE80000000003F00408040803F00000
+CD3A:000002081F880208050E1888040804087FE8000003F80020002000D003080000
+CD3B:000002081F880208050E1888040804087FE80000004003F8004000A003180000
+CD3C:000002081F880208050E1888040804087FE8000003F8000803F8000800080000
+CD3D:000002081F880208050E1888040804087FE8000003F8020003F8020003F80000
+CD3E:000002081F880208050E1888040804087FE8000000000FF8022002200FF80000
+CD3F:000002081F880208050E1888040804087FE8000000800FF803E0041003E00000
+CD40:00000012041204123F9201120212061E09123092041204127FD2001200120000
+CD41:000002281FA80228053818A8042804287FA8000007F800080008000800080000
+CD42:000002281FA80228053818A8042804287FA8000000003EF80208020802080000
+CD43:000002281FA80228053818A8042804287FA8000000001F080108011401620000
+CD44:000002281FA80228053818A8042804287FA8000008000800080008000FF80000
+CD45:000002281FA80228053818A8042804287FA80000000010F8101010301ECC0000
+CD46:000002281FA80228053818A8042804287FA800000808087F081C08220F9C0000
+CD47:000002281FA80228053818A8042804287FA8000003F802000200020003F80000
+CD48:000002281FA80228053818A8042804287FA8000007F8000807F8040007F80000
+CD49:000002281FA80228053818A8042804287FA800003EF802083E0820083E080000
+CD4A:000002281FA80228053818A8042804287FA800003EF802883E8820883EF80000
+CD4B:000002281FA80228053818A8042804287FA800003E8802883EF820883EF80000
+CD4C:000002281FA80228053818A8042804287FA800001F0801081F0810141F620000
+CD4D:000002281FA80228053818A8042804287FA800003EF802803EF820803EF80000
+CD4E:000002281FA80228053818A8042804287FA800003EFC02483E4820483EFC0000
+CD4F:000002281FA80228053818A8042804287FA800001F08017F1F1C10221F1C0000
+CD50:000002281FA80228053818A8042804287FA8000003F802080208020803F80000
+CD51:000002281FA80228053818A8042804287FA800000208020803F8020803F80000
+CD52:000002281FA80228053818A8042804287FA80000110811081F0811141F620000
+CD53:000002281FA80228053818A8042804287FA80000001000100010006801840000
+CD54:000002281FA80228053818A8042804287FA800000048004800A8011406620000
+CD55:000002281FA80228053818A8042804287FA80000000003F00408040803F00000
+CD56:000002281FA80228053818A8042804287FA8000003F80020002000D003080000
+CD57:000002281FA80228053818A8042804287FA80000004003F8004000A003180000
+CD58:000002281FA80228053818A8042804287FA8000003F8000803F8000800080000
+CD59:000002281FA80228053818A8042804287FA8000003F8020003F8020003F80000
+CD5A:000002281FA80228053818A8042804287FA8000000000FF8022002200FF80000
+CD5B:000002281FA80228053818A8042804287FA8000000800FF803E0041003E00000
+CD5C:00000008040804083F8801080208060809083088040804087FE8000800080000
+CD5D:000002081F88020805081888040804087FE8000007F800080008000800080000
+CD5E:000002081F88020805081888040804087FE8000000003EF80208020802080000
+CD5F:000002081F88020805081888040804087FE8000000001F080108011401620000
+CD60:000002081F88020805081888040804087FE8000008000800080008000FF80000
+CD61:000002081F88020805081888040804087FE80000000010F8101010301ECC0000
+CD62:000002081F88020805081888040804087FE800000808087F081C08220F9C0000
+CD63:000002081F88020805081888040804087FE8000003F802000200020003F80000
+CD64:000002081F88020805081888040804087FE8000007F8000807F8040007F80000
+CD65:000002081F88020805081888040804087FE800003EF802083E0820083E080000
+CD66:000002081F88020805081888040804087FE800003EF802883E8820883EF80000
+CD67:000002081F88020805081888040804087FE800003E8802883EF820883EF80000
+CD68:000002081F88020805081888040804087FE800001F0801081F0810141F620000
+CD69:000002081F88020805081888040804087FE800003EF802803EF820803EF80000
+CD6A:000002081F88020805081888040804087FE800003EFC02483E4820483EFC0000
+CD6B:000002081F88020805081888040804087FE800001F08017F1F1C10221F1C0000
+CD6C:000002081F88020805081888040804087FE8000003F802080208020803F80000
+CD6D:000002081F88020805081888040804087FE800000208020803F8020803F80000
+CD6E:000002081F88020805081888040804087FE80000110811081F0811141F620000
+CD6F:000002081F88020805081888040804087FE80000001000100010006801840000
+CD70:000002081F88020805081888040804087FE800000048004800A8011406620000
+CD71:000002081F88020805081888040804087FE80000000003F00408040803F00000
+CD72:000002081F88020805081888040804087FE8000003F80020002000D003080000
+CD73:000002081F88020805081888040804087FE80000004003F8004000A003180000
+CD74:000002081F88020805081888040804087FE8000003F8000803F8000800080000
+CD75:000002081F88020805081888040804087FE8000003F8020003F8020003F80000
+CD76:000002081F88020805081888040804087FE8000000000FF8022002200FF80000
+CD77:000002081F88020805081888040804087FE8000000800FF803E0041003E00000
+CD78:0000010001000FE000400080018002400C2004400440044004407FFC00000000
+CD79:000001000FC0010002800C40044004407FFC00001FF000100010001000100000
+CD7A:000001000FC0010002800C40044004407FFC000000003EF80208020802080000
+CD7B:000001000FC0010002800C40044004407FFC000000001E100210022802C40000
+CD7C:000001000FC0010002800C40044004407FFC000000001000100010001FF00000
+CD7D:000001000FC0010002800C40044004407FFC0000000020F8201020303ECC0000
+CD7E:000001000FC0010002800C40044004407FFC0000202021FC207020883E700000
+CD7F:000001000FC0010002800C40044004407FFC00001FF01000100010001FF00000
+CD80:000001000FC0010002800C40044004407FFC00001FF000101FF010001FF00000
+CD81:000001000FC0010002800C40044004407FFC00003EF802083E0820083E080000
+CD82:000001000FC0010002800C40044004407FFC00003EF802883E8820883EF80000
+CD83:000001000FC0010002800C40044004407FFC00003E8802883EF820883EF80000
+CD84:000001000FC0010002800C40044004407FFC00003E1002103E1020283EC40000
+CD85:000001000FC0010002800C40044004407FFC00003EF802803EF820803EF80000
+CD86:000001000FC0010002800C40044004407FFC00003EFC02483E4820483EFC0000
+CD87:000001000FC0010002800C40044004407FFC00003E2003FC3E7020883E700000
+CD88:000001000FC0010002800C40044004407FFC00001FF01010101010101FF00000
+CD89:000001000FC0010002800C40044004407FFC0000101010101FF010101FF00000
+CD8A:000001000FC0010002800C40044004407FFC0000222022203E2022503E880000
+CD8B:000001000FC0010002800C40044004407FFC000000000100010002800C400000
+CD8C:000001000FC0010002800C40044004407FFC00000000024002400DA033100000
+CD8D:000001000FC0010002800C40044004407FFC0000000007C00820082007C00000
+CD8E:000001000FC0010002800C40044004407FFC0000000007E00080014006200000
+CD8F:000001000FC0010002800C40044004407FFC0000008007E00080014006200000
+CD90:000001000FC0010002800C40044004407FFC00001FF000101FF0001000100000
+CD91:000001000FC0010002800C40044004407FFC00001FF010001FF010001FF00000
+CD92:000001000FC0010002800C40044004407FFC000000001FF0044004401FF00000
+CD93:000001000FC0010002800C40044004407FFC000001001FF007C0082007C00000
+CD94:00000080008007F00020004000C00120061000003FF801000100010001000000
+CD95:000001000FC0010002800C4000007FFC010001001FF000100010001000100000
+CD96:000001000FC0010002800C4000007FFC0100010000003EF80208020802080000
+CD97:000001000FC0010002800C4000007FFC0100010000001E100210022802C40000
+CD98:000001000FC0010002800C40000000007FFC010001001100100010001FF00000
+CD99:000001000FC0010002800C4000007FFC01000100000020F8201020303ECC0000
+CD9A:000001000FC0010002800C4000007FFC01000100202021FC207020883E700000
+CD9B:000001000FC0010002800C4000007FFC010001001FF01000100010001FF00000
+CD9C:000001000FC0010002800C4000007FFC010001001FF000101FF010001FF00000
+CD9D:000001000FC0010002800C4000007FFC010001003EF802083E0820083E080000
+CD9E:000001000FC0010002800C4000007FFC010001003EF802883E8820883EF80000
+CD9F:000001000FC0010002800C4000007FFC010001003E8802883EF820883EF80000
+CDA0:000001000FC0010002800C4000007FFC010001003E1002103E1020283EC40000
+CDA1:000001000FC0010002800C4000007FFC010001003EF802803EF820803EF80000
+CDA2:000001000FC0010002800C4000007FFC010001003EFC02483E4820483EFC0000
+CDA3:000001000FC0010002800C4000007FFC010001003E2003FC3E7020883E700000
+CDA4:000001000FC0010002800C4000007FFC010001001FF01010101010101FF00000
+CDA5:000001000FC0010002800C4000007FFC01000100101010101FF010101FF00000
+CDA6:000001000FC0010002800C4000007FFC01000100222022203E2022503E880000
+CDA7:000001000FC0010002800C4000007FFC0100010000000100010002800C400000
+CDA8:000001000FC0010002800C4000007FFC010001000000024002400DA033100000
+CDA9:000001000FC0010002800C4000007FFC01000100000007C00820082007C00000
+CDAA:000001000FC0010002800C4000007FFC01000100000007E00080014006200000
+CDAB:000001000FC0010002800C4000007FFC01000100008007E00080014006200000
+CDAC:000001000FC0010002800C4000007FFC010001001FF000101FF0001000100000
+CDAD:000001000FC0010002800C4000007FFC010001001FF010001FF010001FF00000
+CDAE:000001000FC0010002800C4000007FFC0100010000001FF0044004401FF00000
+CDAF:000001000FC0010002800C4000007FFC0100010001001FF007C0082007C00000
+CDB0:0000040804083F880108020806080908308800087FE8040804F8040804080000
+CDB1:04083F0804080A08310800087FE8027802080000000007F80008000800080000
+CDB2:04083F0804080A08310800087FE802780208000000003EF80208020802080000
+CDB3:04083F0804080A08310800087FE802780208000000001F080108011401620000
+CDB4:04083F0804080A083108000800087FE80278020802081000100010001FF80000
+CDB5:04083F0804080A08310800087FE8027802080000000020F8201020303ECC0000
+CDB6:04083F0804080A08310800087FE8027802080000202021FC207020883E700000
+CDB7:04083F0804080A08310800087FE802780208000003F802000200020003F80000
+CDB8:04083F0804080A08310800087FE802780208000007F8000807F8040007F80000
+CDB9:04083F0804080A08310800087FE80278020800003EF802083E0820083E080000
+CDBA:04083F0804080A08310800087FE80278020800003EF802883E8820883EF80000
+CDBB:04083F0804080A08310800087FE80278020800003E8802883EF820883EF80000
+CDBC:04083F0804080A08310800087FE80278020800000F8800880F8808140FA20000
+CDBD:04083F0804080A08310800087FE80278020800003EF802803EF820803EF80000
+CDBE:04083F0804080A08310800087FE80278020800003EFC02483E4820483EFC0000
+CDBF:04083F0804080A08310800087FE80278020800003E1002FE3E3820443E380000
+CDC0:04083F0804080A08310800087FE802780208000003F802080208020803F80000
+CDC1:04083F0804080A08310800087FE80278020800000208020803F8020803F80000
+CDC2:04083F0804080A08310800087FE8027802080000210821083F0821143F620000
+CDC3:04083F0804080A08310800087FE8027802080000001000100010006801840000
+CDC4:04083F0804080A08310800087FE80278020800000048004800A8011406620000
+CDC5:04083F0804080A08310800087FE8027802080000000003F00408040803F00000
+CDC6:04083F0804080A08310800087FE802780208000003F80020002000D003080000
+CDC7:04083F0804080A08310800087FE8027802080000004003F8004000A003180000
+CDC8:04083F0804080A08310800087FE802780208000003F8000803F8000800080000
+CDC9:04083F0804080A08310800087FE802780208000003F8020003F8020003F80000
+CDCA:04083F0804080A08310800087FE802780208000000000FF8022002200FF80000
+CDCB:04083F0804080A08310800087FE802780208000000800FF803E0041003E00000
+CDCC:0000040A040A3F8A010A020A060A090A308A000A7FEA040A047A040A040A0000
+CDCD:04283F2804280A28312800287FA805E804280000000007F80008000800080000
+CDCE:04283F2804280A28312800287FA805E80428000000003EF80208020802080000
+CDCF:04283F2804280A28312800287FA805E80428000000001F080108011401620000
+CDD0:04283F2804280A283128002800287FA8042805E804281428100010001FF80000
+CDD1:04283F2804280A28312800287FA805E804280000000020F8201020303ECC0000
+CDD2:04283F2804280A28312800287FA805E804280000202021FC207020883E700000
+CDD3:04283F2804280A28312800287FA805E80428000003F802000200020003F80000
+CDD4:04283F2804280A28312800287FA805E80428000007F8000807F8040007F80000
+CDD5:04283F2804280A28312800287FA805E8042800003EF802083E0820083E080000
+CDD6:04283F2804280A28312800287FA805E8042800003EF802883E8820883EF80000
+CDD7:04283F2804280A28312800287FA805E8042800003E8802883EF820883EF80000
+CDD8:04283F2804280A28312800287FA805E8042800000F8800880F8808140FA20000
+CDD9:04283F2804280A28312800287FA805E8042800003EF802803EF820803EF80000
+CDDA:04283F2804280A28312800287FA805E8042800003EFC02483E4820483EFC0000
+CDDB:04283F2804280A28312800287FA805E8042800003E1002FE3E3820443E380000
+CDDC:04283F2804280A28312800287FA805E80428000003F802080208020803F80000
+CDDD:04283F2804280A28312800287FA805E8042800000208020803F8020803F80000
+CDDE:04283F2804280A28312800287FA805E804280000210821083F0821143F620000
+CDDF:04283F2804280A28312800287FA805E804280000001000100010006801840000
+CDE0:04283F2804280A28312800287FA805E8042800000048004800A8011406620000
+CDE1:04283F2804280A28312800287FA805E804280000000003F00408040803F00000
+CDE2:04283F2804280A28312800287FA805E80428000003F80020002000D003080000
+CDE3:04283F2804280A28312800287FA805E804280000004003F8004000A003180000
+CDE4:04283F2804280A28312800287FA805E80428000003F8000803F8000800080000
+CDE5:04283F2804280A28312800287FA805E80428000003F8020003F8020003F80000
+CDE6:04283F2804280A28312800287FA805E80428000000000FF8022002200FF80000
+CDE7:04283F2804280A28312800287FA805E80428000000800FF803E0041003E00000
+CDE8:0000040804083F880108020806080908308800087FE804080408040804080000
+CDE9:04083F0804080A08310800087FE8020802000000000007F80008000800080000
+CDEA:04083F0804080A08310800087FE802080200000000003EF80208020802080000
+CDEB:04083F0804080A08310800087FE802080200000000001F080108011401620000
+CDEC:04083F0804080A083108000800087FE80208020802081008100010001FF80000
+CDED:04083F0804080A08310800087FE8020802000000000020F8201020303ECC0000
+CDEE:04083F0804080A08310800087FE8020802000000202021FC207020883E700000
+CDEF:04083F0804080A08310800087FE802080200000003F802000200020003F80000
+CDF0:04083F0804080A08310800087FE802080200000007F8000807F8040007F80000
+CDF1:04083F0804080A08310800087FE80208020000003EF802083E0820083E080000
+CDF2:04083F0804080A08310800087FE80208020000003EF802883E8820883EF80000
+CDF3:04083F0804080A08310800087FE80208020000003E8802883EF820883EF80000
+CDF4:04083F0804080A08310800087FE80208020000000F8800880F8808140FA20000
+CDF5:04083F0804080A08310800087FE80208020000003EF802803EF820803EF80000
+CDF6:04083F0804080A08310800087FE80208020000003EFC02483E4820483EFC0000
+CDF7:04083F0804080A08310800087FE80208020000003E1002FE3E3820443E380000
+CDF8:04083F0804080A08310800087FE802080200000003F802080208020803F80000
+CDF9:04083F0804080A08310800087FE80208020000000208020803F8020803F80000
+CDFA:04083F0804080A08310800087FE8020802000000210821083F0821143F620000
+CDFB:04083F0804080A08310800087FE8020802000000001000100010006801840000
+CDFC:04083F0804080A08310800087FE80208020000000048004800A8011406620000
+CDFD:04083F0804080A08310800087FE8020802000000000003F00408040803F00000
+CDFE:04083F0804080A08310800087FE802080200000003F80020002000D003080000
+CDFF:04083F0804080A08310800087FE8020802000000004003F8004000A003180000
+CE00:04083F0804080A08310800087FE802080200000003F8000803F8000800080000
+CE01:04083F0804080A08310800087FE802080200000003F8020003F8020003F80000
+CE02:04083F0804080A08310800087FE802080200000000000FF8022002200FF80000
+CE03:04083F0804080A08310800087FE802080200000000800FF803E0041003E00000
+CE04:00000080008007F00020004000C00120061000007FFC04400440044004400000
+CE05:000001000FC0010002800C4000007FFC044004401FF000100010001000100000
+CE06:000001000FC0010002800C4000007FFC0440044000003EF80208020802080000
+CE07:000001000FC0010002800C4000007FFC0440044000001E100210022802C40000
+CE08:000001000FC0010002800C40000000007FFC044004401440100010001FF00000
+CE09:000001000FC0010002800C4000007FFC04400440000020F8201020303ECC0000
+CE0A:000001000FC0010002800C4000007FFC04400440202021FC207020883E700000
+CE0B:000001000FC0010002800C4000007FFC044004401FF01000100010001FF00000
+CE0C:000001000FC0010002800C4000007FFC044004401FF000101FF010001FF00000
+CE0D:000001000FC0010002800C4000007FFC044004403EF802083E0820083E080000
+CE0E:000001000FC0010002800C4000007FFC044004403EF802883E8820883EF80000
+CE0F:000001000FC0010002800C4000007FFC044004403E8802883EF820883EF80000
+CE10:000001000FC0010002800C4000007FFC044004403E1002103E1020283EC40000
+CE11:000001000FC0010002800C4000007FFC044004403EF802803EF820803EF80000
+CE12:000001000FC0010002800C4000007FFC044004403EFC02483E4820483EFC0000
+CE13:000001000FC0010002800C4000007FFC044004403E2003FC3E7020883E700000
+CE14:000001000FC0010002800C4000007FFC044004401FF01010101010101FF00000
+CE15:000001000FC0010002800C4000007FFC04400440101010101FF010101FF00000
+CE16:000001000FC0010002800C4000007FFC04400440222022203E2022503E880000
+CE17:000001000FC0010002800C4000007FFC0440044000000100010002800C400000
+CE18:000001000FC0010002800C4000007FFC044004400000024002400DA033100000
+CE19:000001000FC0010002800C4000007FFC04400440000007C00820082007C00000
+CE1A:000001000FC0010002800C4000007FFC04400440000007E00080014006200000
+CE1B:000001000FC0010002800C4000007FFC04400440008007E00080014006200000
+CE1C:000001000FC0010002800C4000007FFC044004401FF000101FF0001000100000
+CE1D:000001000FC0010002800C4000007FFC044004401FF010001FF010001FF00000
+CE1E:000001000FC0010002800C4000007FFC0440044000001FF0044004401FF00000
+CE1F:000001000FC0010002800C4000007FFC0440044001001FF007C0082007C00000
+CE20:0000010001000FE000400080018002400C20000000007FFC0000000000000000
+CE21:000001000FC0010002800C40000000007FFC00001FF000100010001000100000
+CE22:000001000FC0010002800C40000000007FFC000000003EF80208020802080000
+CE23:000001000FC0010002800C40000000007FFC000000001E100210022802C40000
+CE24:000001000FC0010002800C40000000007FFC000000001000100010001FF00000
+CE25:000001000FC0010002800C40000000007FFC0000000020F8201020303ECC0000
+CE26:000001000FC0010002800C40000000007FFC0000202021FC207020883E700000
+CE27:000001000FC0010002800C40000000007FFC00001FF01000100010001FF00000
+CE28:000001000FC0010002800C40000000007FFC00001FF000101FF010001FF00000
+CE29:000001000FC0010002800C40000000007FFC00003EF802083E0820083E080000
+CE2A:000001000FC0010002800C40000000007FFC00003EF802883E8820883EF80000
+CE2B:000001000FC0010002800C40000000007FFC00003E8802883EF820883EF80000
+CE2C:000001000FC0010002800C40000000007FFC00003E1002103E1020283EC40000
+CE2D:000001000FC0010002800C40000000007FFC00003EF802803EF820803EF80000
+CE2E:000001000FC0010002800C40000000007FFC00003EFC02483E4820483EFC0000
+CE2F:000001000FC0010002800C40000000007FFC00003E2003FC3E7020883E700000
+CE30:000001000FC0010002800C40000000007FFC00001FF01010101010101FF00000
+CE31:000001000FC0010002800C40000000007FFC0000101010101FF010101FF00000
+CE32:000001000FC0010002800C40000000007FFC0000222022203E2022503E880000
+CE33:000001000FC0010002800C40000000007FFC000000000100010002800C400000
+CE34:000001000FC0010002800C40000000007FFC00000000024002400DA033100000
+CE35:000001000FC0010002800C40000000007FFC0000000007C00820082007C00000
+CE36:000001000FC0010002800C40000000007FFC0000000007E00080014006200000
+CE37:000001000FC0010002800C40000000007FFC0000008007E00080014006200000
+CE38:000001000FC0010002800C40000000007FFC00001FF000101FF0001000100000
+CE39:000001000FC0010002800C40000000007FFC00001FF010001FF010001FF00000
+CE3A:000001000FC0010002800C40000000007FFC000000001FF0044004401FF00000
+CE3B:000001000FC0010002800C40000000007FFC000001001FF007C0082007C00000
+CE3C:00000008040804083F880108020806080908308800087FE80008000800080000
+CE3D:000002081F88020805081888000800087FE8000007F800080008000800080000
+CE3E:000002081F88020805081888000800087FE8000000003EF80208020802080000
+CE3F:000002081F88020805081888000800087FE8000000001F080108011401620000
+CE40:000002081F88020805081888000800087FE8000008000800080008000FF80000
+CE41:000002081F88020805081888000800087FE80000000010F8101010301ECC0000
+CE42:000002081F88020805081888000800087FE800000808087F081C08220F9C0000
+CE43:000002081F88020805081888000800087FE8000003F802000200020003F80000
+CE44:000002081F88020805081888000800087FE8000007F8000807F8040007F80000
+CE45:000002081F88020805081888000800087FE800003EF802083E0820083E080000
+CE46:000002081F88020805081888000800087FE800003EF802883E8820883EF80000
+CE47:000002081F88020805081888000800087FE800003E8802883EF820883EF80000
+CE48:000002081F88020805081888000800087FE800001F0801081F0810141F620000
+CE49:000002081F88020805081888000800087FE800003EF802803EF820803EF80000
+CE4A:000002081F88020805081888000800087FE800003EFC02483E4820483EFC0000
+CE4B:000002081F88020805081888000800087FE800001F08017F1F1C10221F1C0000
+CE4C:000002081F88020805081888000800087FE8000003F802080208020803F80000
+CE4D:000002081F88020805081888000800087FE800000208020803F8020803F80000
+CE4E:000002081F88020805081888000800087FE80000110811081F0811141F620000
+CE4F:000002081F88020805081888000800087FE80000001000100010006801840000
+CE50:000002081F88020805081888000800087FE800000048004800A8011406620000
+CE51:000002081F88020805081888000800087FE80000000003F00408040803F00000
+CE52:000002081F88020805081888000800087FE8000003F80020002000D003080000
+CE53:000002081F88020805081888000800087FE80000004003F8004000A003180000
+CE54:000002081F88020805081888000800087FE8000003F8000803F8000800080000
+CE55:000002081F88020805081888000800087FE8000003F8020003F8020003F80000
+CE56:000002081F88020805081888000800087FE8000000000FF8022002200FF80000
+CE57:000002081F88020805081888000800087FE8000000800FF803E0041003E00000
+CE58:000000000008040804083F880108020806080908308800080008000800080000
+CE59:00000008000808087E0808081408620800080000000007F80008000800080000
+CE5A:00000008000808087E080808140862080008000000003EF80208020802080000
+CE5B:00000008000808087E080808140862080008000000001F080108011401620000
+CE5C:00000008000808087E080808140862080008000800001000100010001FF80000
+CE5D:00000008000808087E0808081408620800080000000020F8201020303ECC0000
+CE5E:00000008000808087E0808081408620800080000202021FC207020883E700000
+CE5F:00000008000808087E080808140862080008000003F802000200020003F80000
+CE60:00000008000808087E080808140862080008000007F8000807F8040007F80000
+CE61:00000008000808087E08080814086208000800003EF802083E0820083E080000
+CE62:00000008000808087E08080814086208000800003EF802883E8820883EF80000
+CE63:00000008000808087E08080814086208000800003E8802883EF820883EF80000
+CE64:00000008000808087E08080814086208000800000F8800880F8808140FA20000
+CE65:00000008000808087E08080814086208000800003EF802803EF820803EF80000
+CE66:00000008000808087E08080814086208000800003EFC02483E4820483EFC0000
+CE67:00000008000808087E08080814086208000800003E1002FE3E3820443E380000
+CE68:00000008000808087E080808140862080008000003F802080208020803F80000
+CE69:00000008000808087E08080814086208000800000208020803F8020803F80000
+CE6A:00000008000808087E0808081408620800080000210821083F0821143F620000
+CE6B:00000008000808087E0808081408620800080000001000100010006801840000
+CE6C:00000008000808087E08080814086208000800000048004800A8011406620000
+CE6D:00000008000808087E0808081408620800080000000003F00408040803F00000
+CE6E:00000008000808087E080808140862080008000003F80020002000D003080000
+CE6F:00000008000808087E0808081408620800080000004003F8004000A003180000
+CE70:00000008000808087E080808140862080008000003F8000803F8000800080000
+CE71:00000008000808087E080808140862080008000003F8020003F8020003F80000
+CE72:00000008000808087E080808140862080008000000000FF8022002200FF80000
+CE73:00000008000808087E080808140862080008000000800FF803E0041003E00000
+CE74:00000000001000101F9000900090009E1F100110021004101810001000100000
+CE75:000000087E08020802087E0E040818086008000007F800080008000800080000
+CE76:000000087E08020802087E0E040818086008000000003EF80208020802080000
+CE77:000000087E08020802087E0E040818086008000000001F080108011401620000
+CE78:000000087E08020802087E0E040818086008000808000800080008000FF80000
+CE79:000000087E08020802087E0E0408180860080000000010F8101010301ECC0000
+CE7A:000000087E08020802087E0E04081808600800000808087F081C08220F9C0000
+CE7B:000000087E08020802087E0E040818086008000003F802000200020003F80000
+CE7C:000000087E08020802087E0E040818086008000007F8000807F8040007F80000
+CE7D:000000087E08020802087E0E04081808600800003EF802083E0820083E080000
+CE7E:000000087E08020802087E0E04081808600800003EF802883E8820883EF80000
+CE7F:000000087E08020802087E0E04081808600800003E8802883EF820883EF80000
+CE80:000000087E08020802087E0E04081808600800001F0801081F0810141F620000
+CE81:000000087E08020802087E0E04081808600800003EF802803EF820803EF80000
+CE82:000000087E08020802087E0E04081808600800003EFC02483E4820483EFC0000
+CE83:000000087E08020802087E0E04081808600800001F08017F1F1C10221F1C0000
+CE84:000000087E08020802087E0E040818086008000003F802080208020803F80000
+CE85:000000087E08020802087E0E04081808600800000208020803F8020803F80000
+CE86:000000087E08020802087E0E0408180860080000110811081F0811141F620000
+CE87:000000087E08020802087E0E0408180860080000001000100010006801840000
+CE88:000000087E08020802087E0E04081808600800000048004800A8011406620000
+CE89:000000087E08020802087E0E0408180860080000000003F00408040803F00000
+CE8A:000000087E08020802087E0E040818086008000003F80020002000D003080000
+CE8B:000000087E08020802087E0E0408180860080000004003F8004000A003180000
+CE8C:000000087E08020802087E0E040818086008000003F8000803F8000800080000
+CE8D:000000087E08020802087E0E040818086008000003F8020003F8020003F80000
+CE8E:000000087E08020802087E0E040818086008000000000FF8022002200FF80000
+CE8F:000000087E08020802087E0E040818086008000000800FF803E0041003E00000
+CE90:00000000001200121F9200920092009E1F120112021204121812001200120000
+CE91:000000287E28022802287E38042818286028000007F800080008000800080000
+CE92:000000287E28022802287E38042818286028000000003EF80208020802080000
+CE93:000000287E28022802287E38042818286028000000003E100210022802C40000
+CE94:000000287E28022802287E38042818286028002808000800080008000FF80000
+CE95:000000287E28022802287E380428182860280000000020F8201020303ECC0000
+CE96:000000287E28022802287E380428182860280000202021FC207020883E700000
+CE97:000000287E28022802287E38042818286028000003F802000200020003F80000
+CE98:000000287E28022802287E38042818286028000007F8000807F8040007F80000
+CE99:000000287E28022802287E3804281828602800003EF802083E0820083E080000
+CE9A:000000287E28022802287E3804281828602800003EF802883E8820883EF80000
+CE9B:000000287E28022802287E3804281828602800003E8802883EF820883EF80000
+CE9C:000000287E28022802287E3804281828602800001F0801081F0810141F620000
+CE9D:000000287E28022802287E3804281828602800003EF802803EF820803EF80000
+CE9E:000000287E28022802287E3804281828602800003EFC02483E4820483EFC0000
+CE9F:000000287E28022802287E3804281828602800003E1002FE3E3820443E380000
+CEA0:000000287E28022802287E38042818286028000003F802080208020803F80000
+CEA1:000000287E28022802287E3804281828602800000208020803F8020803F80000
+CEA2:000000287E28022802287E380428182860280000110811081F0811141F620000
+CEA3:000000287E28022802287E380428182860280000000800080008003400C20000
+CEA4:000000287E28022802287E3804281828602800000048004800A8011406620000
+CEA5:000000287E28022802287E380428182860280000000001F00208020801F00000
+CEA6:000000287E28022802287E38042818286028000003F80020002000D003080000
+CEA7:000000287E28022802287E380428182860280000004003F8004000A003180000
+CEA8:000000287E28022802287E38042818286028000003F8000803F8000800080000
+CEA9:000000287E28022802287E38042818286028000003F8020003F8020003F80000
+CEAA:000000287E28022802287E38042818286028000000000FF8022002200FF80000
+CEAB:000000287E28022802287E38042818286028000000800FF803E0041003E00000
+CEAC:00000000001000101F900090009E00901F10011E021004101810001000100000
+CEAD:000000087E080208020E7E08040E18086008000007F800080008000800080000
+CEAE:000000087E080208020E7E08040E18086008000000003EF80208020802080000
+CEAF:000000087E080208020E7E08040E18086008000000001F080108011401620000
+CEB0:000000087E080208020E7E08040E18086008000008000800080008000FF80000
+CEB1:000000087E080208020E7E08040E180860080000000010F8101010301ECC0000
+CEB2:000000087E080208020E7E08040E1808600800000808087F081C08220F9C0000
+CEB3:000000087E080208020E7E08040E18086008000003F802000200020003F80000
+CEB4:000000087E080208020E7E08040E18086008000007F8000807F8040007F80000
+CEB5:000000087E080208020E7E08040E1808600800003EF802083E0820083E080000
+CEB6:000000087E080208020E7E08040E1808600800003EF802883E8820883EF80000
+CEB7:000000087E080208020E7E08040E1808600800003E8802883EF820883EF80000
+CEB8:000000087E080208020E7E08040E1808600800001F0801081F0810141F620000
+CEB9:000000087E080208020E7E08040E1808600800003EF802803EF820803EF80000
+CEBA:000000087E080208020E7E08040E1808600800003EFC02483E4820483EFC0000
+CEBB:000000087E080208020E7E08040E1808600800001F08017F1F1C10221F1C0000
+CEBC:000000087E080208020E7E08040E18086008000003F802080208020803F80000
+CEBD:000000087E080208020E7E08040E1808600800000208020803F8020803F80000
+CEBE:000000087E080208020E7E08040E180860080000110811081F0811141F620000
+CEBF:000000087E080208020E7E08040E180860080000001000100010006801840000
+CEC0:000000087E080208020E7E08040E1808600800000048004800A8011406620000
+CEC1:000000087E080208020E7E08040E180860080000000003F00408040803F00000
+CEC2:000000087E080208020E7E08040E18086008000003F80020002000D003080000
+CEC3:000000087E080208020E7E08040E180860080000004003F8004000A003180000
+CEC4:000000087E080208020E7E08040E18086008000003F8000803F8000800080000
+CEC5:000000087E080208020E7E08040E18086008000003F8020003F8020003F80000
+CEC6:000000087E080208020E7E08040E18086008000000000FF8022002200FF80000
+CEC7:000000087E080208020E7E08040E18086008000000800FF803E0041003E00000
+CEC8:00000000001200121F920092009E00921F12011E021204121812001200120000
+CEC9:000000287E28022802387E28043818286028000007F800080008000800080000
+CECA:000000287E28022802387E28043818286028000000003EF80208020802080000
+CECB:000000287E28022802387E28043818286028000000003E100210022802C40000
+CECC:000000287E28022802387E28043818286028002808000800080008000FF80000
+CECD:000000287E28022802387E280438182860280000000020F8201020303ECC0000
+CECE:000000287E28022802387E280438182860280000202021FC207020883E700000
+CECF:000000287E28022802387E28043818286028000003F802000200020003F80000
+CED0:000000287E28022802387E28043818286028000007F8000807F8040007F80000
+CED1:000000287E28022802387E2804381828602800003EF802083E0820083E080000
+CED2:000000287E28022802387E2804381828602800003EF802883E8820883EF80000
+CED3:000000287E28022802387E2804381828602800003E8802883EF820883EF80000
+CED4:000000287E28022802387E2804381828602800001F0801081F0810141F620000
+CED5:000000287E28022802387E2804381828602800003EF802803EF820803EF80000
+CED6:000000287E28022802387E2804381828602800003EFC02483E4820483EFC0000
+CED7:000000287E28022802387E2804381828602800003E1002FE3E3820443E380000
+CED8:000000287E28022802387E28043818286028000003F802080208020803F80000
+CED9:000000287E28022802387E2804381828602800000208020803F8020803F80000
+CEDA:000000287E28022802387E280438182860280000110811081F0811141F620000
+CEDB:000000287E28022802387E280438182860280000000800080008003400C20000
+CEDC:000000287E28022802387E2804381828602800000048004800A8011406620000
+CEDD:000000287E28022802387E280438182860280000000001F00208020801F00000
+CEDE:000000287E28022802387E28043818286028000003F80020002000D003080000
+CEDF:000000287E28022802387E280438182860280000004003F8004000A003180000
+CEE0:000000287E28022802387E28043818286028000003F8000803F8000800080000
+CEE1:000000287E28022802387E28043818286028000003F8020003F8020003F80000
+CEE2:000000287E28022802387E28043818286028000000000FF8022002200FF80000
+CEE3:000000287E28022802387E28043818286028000000800FF803E0041003E00000
+CEE4:00000000000200021F8200820082009E1F020102020204021802000200020000
+CEE5:000000087E08020802087E380408180860080000000007F80008000800080000
+CEE6:000000087E08020802087E38040818086008000000003EF80208020802080000
+CEE7:000000087E08020802087E38040818086008000000001F080108011401620000
+CEE8:000000087E08020802087E38040818086008000000001000100010001FF80000
+CEE9:000000087E08020802087E380408180860080000000020F8201020303ECC0000
+CEEA:000000087E08020802087E380408180860080000202021FC207020883E700000
+CEEB:000000087E08020802087E38040818086008000003F802000200020003F80000
+CEEC:000000087E08020802087E38040818086008000007F8000807F8040007F80000
+CEED:000000087E08020802087E3804081808600800003EF802083E0820083E080000
+CEEE:000000087E08020802087E3804081808600800003EF802883E8820883EF80000
+CEEF:000000087E08020802087E3804081808600800003E8802883EF820883EF80000
+CEF0:000000087E08020802087E3804081808600800000F8800880F8808140FA20000
+CEF1:000000087E08020802087E3804081808600800003EF802803EF820803EF80000
+CEF2:000000087E08020802087E3804081808600800003EFC02483E4820483EFC0000
+CEF3:000000087E08020802087E3804081808600800003E1002FE3E3820443E380000
+CEF4:000000087E08020802087E38040818086008000003F802080208020803F80000
+CEF5:000000087E08020802087E3804081808600800000208020803F8020803F80000
+CEF6:000000087E08020802087E380408180860080000210821083F0821143F620000
+CEF7:000000087E08020802087E380408180860080000001000100010006801840000
+CEF8:000000087E08020802087E3804081808600800000048004800A8011406620000
+CEF9:000000087E08020802087E380408180860080000000003F00408040803F00000
+CEFA:000000087E08020802087E38040818086008000003F80020002000D003080000
+CEFB:000000087E08020802087E380408180860080000004003F8004000A003180000
+CEFC:000000087E08020802087E38040818086008000003F8000803F8000800080000
+CEFD:000000087E08020802087E38040818086008000003F8020003F8020003F80000
+CEFE:000000087E08020802087E38040818086008000000000FF8022002200FF80000
+CEFF:000000087E08020802087E38040818086008000000800FF803E0041003E00000
+CF00:00000000000A000A1F8A008A008A00BA1F0A010A020A040A180A000A000A0000
+CF01:000000287E28022802287EE8042818286028000007F800080008000800080000
+CF02:000000287E28022802287EE8042818286028000000003EF80208020802080000
+CF03:000000287E28022802287EE8042818286028000000003E100210022802C40000
+CF04:000000287E28022802287EE8042818286028000008000800080008000FF80000
+CF05:000000287E28022802287EE80428182860280000000020F8201020303ECC0000
+CF06:000000287E28022802287EE80428182860280000202021FC207020883E700000
+CF07:000000287E28022802287EE8042818286028000003F802000200020003F80000
+CF08:000000287E28022802287EE8042818286028000007F8000807F8040007F80000
+CF09:000000287E28022802287EE804281828602800003EF802083E0820083E080000
+CF0A:000000287E28022802287EE804281828602800003EF802883E8820883EF80000
+CF0B:000000287E28022802287EE804281828602800003E8802883EF820883EF80000
+CF0C:000000287E28022802287EE804281828602800001F0801081F0810141F620000
+CF0D:000000287E28022802287EE804281828602800003EF802803EF820803EF80000
+CF0E:000000287E28022802287EE804281828602800003EFC02483E4820483EFC0000
+CF0F:000000287E28022802287EE804281828602800003E1002FE3E3820443E380000
+CF10:000000287E28022802287EE8042818286028000003F802080208020803F80000
+CF11:000000287E28022802287EE804281828602800000208020803F8020803F80000
+CF12:000000287E28022802287EE80428182860280000110811081F0811141F620000
+CF13:000000287E28022802287EE80428182860280000000800080008003400C20000
+CF14:000000287E28022802287EE804281828602800000048004800A8011406620000
+CF15:000000287E28022802287EE80428182860280000000001F00208020801F00000
+CF16:000000287E28022802287EE8042818286028000003F80020002000D003080000
+CF17:000000287E28022802287EE80428182860280000004003F8004000A003180000
+CF18:000000287E28022802287EE8042818286028000003F8000803F8000800080000
+CF19:000000287E28022802287EE8042818286028000003F8020003F8020003F80000
+CF1A:000000287E28022802287EE8042818286028000000000FF8022002200FF80000
+CF1B:000000287E28022802287EE8042818286028000000800FF803E0041003E00000
+CF1C:00000000000200021F820082009E00821F02011E020204021802000200020000
+CF1D:000000087E08020802387E080438180860080000000007F80008000800080000
+CF1E:000000087E08020802387E08043818086008000000003EF80208020802080000
+CF1F:000000087E08020802387E08043818086008000000001F080108011401620000
+CF20:000000087E08020802387E08043818086008000800001000100010001FF80000
+CF21:000000087E08020802387E080438180860080000000020F8201020303ECC0000
+CF22:000000087E08020802387E080438180860080000202021FC207020883E700000
+CF23:000000087E08020802387E08043818086008000003F802000200020003F80000
+CF24:000000087E08020802387E08043818086008000007F8000807F8040007F80000
+CF25:000000087E08020802387E0804381808600800003EF802083E0820083E080000
+CF26:000000087E08020802387E0804381808600800003EF802883E8820883EF80000
+CF27:000000087E08020802387E0804381808600800003E8802883EF820883EF80000
+CF28:000000087E08020802387E0804381808600800000F8800880F8808140FA20000
+CF29:000000087E08020802387E0804381808600800003EF802803EF820803EF80000
+CF2A:000000087E08020802387E0804381808600800003EFC02483E4820483EFC0000
+CF2B:000000087E08020802387E0804381808600800003E1002FE3E3820443E380000
+CF2C:000000087E08020802387E08043818086008000003F802080208020803F80000
+CF2D:000000087E08020802387E0804381808600800000208020803F8020803F80000
+CF2E:000000087E08020802387E080438180860080000210821083F0821143F620000
+CF2F:000000087E08020802387E080438180860080000001000100010006801840000
+CF30:000000087E08020802387E0804381808600800000048004800A8011406620000
+CF31:000000087E08020802387E080438180860080000000003F00408040803F00000
+CF32:000000087E08020802387E08043818086008000003F80020002000D003080000
+CF33:000000087E08020802387E080438180860080000004003F8004000A003180000
+CF34:000000087E08020802387E08043818086008000003F8000803F8000800080000
+CF35:000000087E08020802387E08043818086008000003F8020003F8020003F80000
+CF36:000000087E08020802387E08043818086008000000000FF8022002200FF80000
+CF37:000000087E08020802387E08043818086008000000800FF803E0041003E00000
+CF38:00000000000A000A1F8A008A00BA008A1F0A013A020A040A180A000A000A0000
+CF39:000000287E28022802E87E2804E818286028000007F800080008000800080000
+CF3A:000000287E28022802E87E2804E818286028000000003EF80208020802080000
+CF3B:000000287E28022802E87E2804E818286028000000003E100210022802C40000
+CF3C:000000287E28022802E87E2804E818286028002808000800080008000FF80000
+CF3D:000000287E28022802E87E2804E8182860280000000020F8201020303ECC0000
+CF3E:000000287E28022802E87E2804E8182860280000202021FC207020883E700000
+CF3F:000000287E28022802E87E2804E818286028000003F802000200020003F80000
+CF40:000000287E28022802E87E2804E818286028000007F8000807F8040007F80000
+CF41:000000287E28022802E87E2804E81828602800003EF802083E0820083E080000
+CF42:000000287E28022802E87E2804E81828602800003EF802883E8820883EF80000
+CF43:000000287E28022802E87E2804E81828602800003E8802883EF820883EF80000
+CF44:000000287E28022802E87E2804E81828602800001F0801081F0810141F620000
+CF45:000000287E28022802E87E2804E81828602800003EF802803EF820803EF80000
+CF46:000000287E28022802E87E2804E81828602800003EFC02483E4820483EFC0000
+CF47:000000287E28022802E87E2804E81828602800003E1002FE3E3820443E380000
+CF48:000000287E28022802E87E2804E818286028000003F802080208020803F80000
+CF49:000000287E28022802E87E2804E81828602800000208020803F8020803F80000
+CF4A:000000287E28022802E87E2804E8182860280000110811081F0811141F620000
+CF4B:000000287E28022802E87E2804E8182860280000000800080008003400C20000
+CF4C:000000287E28022802E87E2804E81828602800000048004800A8011406620000
+CF4D:000000287E28022802E87E2804E8182860280000000001F00208020801F00000
+CF4E:000000287E28022802E87E2804E818286028000003F80020002000D003080000
+CF4F:000000287E28022802E87E2804E8182860280000004003F8004000A003180000
+CF50:000000287E28022802E87E2804E818286028000003F8000803F8000800080000
+CF51:000000287E28022802E87E2804E818286028000003F8020003F8020003F80000
+CF52:000000287E28022802E87E2804E818286028000000000FF8022002200FF80000
+CF53:000000287E28022802E87E2804E818286028000000800FF803E0041003E00000
+CF54:00000000000000003FF8000800083FF8000802080208020002007FFC00000000
+CF55:000000001FF000101FF00010011001007FFC00001FF000100010001000100000
+CF56:000000001FF000101FF00010011001007FFC000000003EF80208020802080000
+CF57:000000001FF000101FF00010011001007FFC000000001E100210022802C40000
+CF58:000000001FF000101FF00010011001007FFC000000001000100010001FF00000
+CF59:000000001FF000101FF00010011001007FFC0000000020F8201020303ECC0000
+CF5A:000000001FF000101FF00010011001007FFC0000202021FC207020883E700000
+CF5B:000000001FF000101FF00010011001007FFC00001FF01000100010001FF00000
+CF5C:000000001FF000101FF00010011001007FFC00001FF000101FF010001FF00000
+CF5D:000000001FF000101FF00010011001007FFC00003EF802083E0820083E080000
+CF5E:000000001FF000101FF00010011001007FFC00003EF802883E8820883EF80000
+CF5F:000000001FF000101FF00010011001007FFC00003E8802883EF820883EF80000
+CF60:000000001FF000101FF00010011001007FFC00003E1002103E1020283EC40000
+CF61:000000001FF000101FF00010011001007FFC00003EF802803EF820803EF80000
+CF62:000000001FF000101FF00010011001007FFC00003EFC02483E4820483EFC0000
+CF63:000000001FF000101FF00010011001007FFC00003E2003FC3E7020883E700000
+CF64:000000001FF000101FF00010011001007FFC00001FF01010101010101FF00000
+CF65:000000001FF000101FF00010011001007FFC0000101010101FF010101FF00000
+CF66:000000001FF000101FF00010011001007FFC0000222022203E2022503E880000
+CF67:000000001FF000101FF00010011001007FFC000000000100010002800C400000
+CF68:000000001FF000101FF00010011001007FFC00000000024002400DA033100000
+CF69:000000001FF000101FF00010011001007FFC0000000007C00820082007C00000
+CF6A:000000001FF000101FF00010011001007FFC0000000007E00080014006200000
+CF6B:000000001FF000101FF00010011001007FFC0000008007E00080014006200000
+CF6C:000000001FF000101FF00010011001007FFC00001FF000101FF0001000100000
+CF6D:000000001FF000101FF00010011001007FFC00001FF010001FF010001FF00000
+CF6E:000000001FF000101FF00010011001007FFC000000001FF0044004401FF00000
+CF6F:000000001FF000101FF00010011001007FFC000001001FF007C0082007C00000
+CF70:00000000001000103FD0005000503FDE0450045004107FD00010001000100000
+CF71:000000083F8800883F8E0088048804087FE8000007F800080008000800080000
+CF72:000000083F8800883F8E0088048804087FE8000000003EF80208020802080000
+CF73:000000083F8800883F8E0088048804087FE8000000001F080108011401620000
+CF74:000000083F8800883F8E0088048804087FE8000008000800080008000FF80000
+CF75:000000083F8800883F8E0088048804087FE80000000010F8101010301ECC0000
+CF76:000000083F8800883F8E0088048804087FE800000808087F081C08220F9C0000
+CF77:000000083F8800883F8E0088048804087FE8000003F802000200020003F80000
+CF78:000000083F8800883F8E0088048804087FE8000007F8000807F8040007F80000
+CF79:000000083F8800883F8E0088048804087FE800003EF802083E0820083E080000
+CF7A:000000083F8800883F8E0088048804087FE800003EF802883E8820883EF80000
+CF7B:000000083F8800883F8E0088048804087FE800003E8802883EF820883EF80000
+CF7C:000000083F8800883F8E0088048804087FE800001F0801081F0810141F620000
+CF7D:000000083F8800883F8E0088048804087FE800003EF802803EF820803EF80000
+CF7E:000000083F8800883F8E0088048804087FE800003EFC02483E4820483EFC0000
+CF7F:000000083F8800883F8E0088048804087FE800001F08017F1F1C10221F1C0000
+CF80:000000083F8800883F8E0088048804087FE8000003F802080208020803F80000
+CF81:000000083F8800883F8E0088048804087FE800000208020803F8020803F80000
+CF82:000000083F8800883F8E0088048804087FE80000110811081F0811141F620000
+CF83:000000083F8800883F8E0088048804087FE80000001000100010006801840000
+CF84:000000083F8800883F8E0088048804087FE800000048004800A8011406620000
+CF85:000000083F8800883F8E0088048804087FE80000000003F00408040803F00000
+CF86:000000083F8800883F8E0088048804087FE8000003F80020002000D003080000
+CF87:000000083F8800883F8E0088048804087FE80000004003F8004000A003180000
+CF88:000000083F8800883F8E0088048804087FE8000003F8000803F8000800080000
+CF89:000000083F8800883F8E0088048804087FE8000003F8020003F8020003F80000
+CF8A:000000083F8800883F8E0088048804087FE8000000000FF8022002200FF80000
+CF8B:000000083F8800883F8E0088048804087FE8000000800FF803E0041003E00000
+CF8C:00000000001200123FD2005200523FDE0452045204127FD20012001200120000
+CF8D:000000283FA800A83FB800A804A804287FA8000007F800080008000800080000
+CF8E:000000283FA800A83FB800A804A804287FA8000000003EF80208020802080000
+CF8F:000000283FA800A83FB800A804A804287FA8000000001F080108011401620000
+CF90:000000283FA800A83FB800A804A804287FA8000008000800080008000FF80000
+CF91:000000283FA800A83FB800A804A804287FA80000000010F8101010301ECC0000
+CF92:000000283FA800A83FB800A804A804287FA800000808087F081C08220F9C0000
+CF93:000000283FA800A83FB800A804A804287FA8000003F802000200020003F80000
+CF94:000000283FA800A83FB800A804A804287FA8000007F8000807F8040007F80000
+CF95:000000283FA800A83FB800A804A804287FA800003EF802083E0820083E080000
+CF96:000000283FA800A83FB800A804A804287FA800003EF802883E8820883EF80000
+CF97:000000283FA800A83FB800A804A804287FA800003E8802883EF820883EF80000
+CF98:000000283FA800A83FB800A804A804287FA800001F0801081F0810141F620000
+CF99:000000283FA800A83FB800A804A804287FA800003EF802803EF820803EF80000
+CF9A:000000283FA800A83FB800A804A804287FA800003EFC02483E4820483EFC0000
+CF9B:000000283FA800A83FB800A804A804287FA800001F08017F1F1C10221F1C0000
+CF9C:000000283FA800A83FB800A804A804287FA8000003F802080208020803F80000
+CF9D:000000283FA800A83FB800A804A804287FA800000208020803F8020803F80000
+CF9E:000000283FA800A83FB800A804A804287FA80000110811081F0811141F620000
+CF9F:000000283FA800A83FB800A804A804287FA80000001000100010006801840000
+CFA0:000000283FA800A83FB800A804A804287FA800000048004800A8011406620000
+CFA1:000000283FA800A83FB800A804A804287FA80000000003F00408040803F00000
+CFA2:000000283FA800A83FB800A804A804287FA8000003F80020002000D003080000
+CFA3:000000283FA800A83FB800A804A804287FA80000004003F8004000A003180000
+CFA4:000000283FA800A83FB800A804A804287FA8000003F8000803F8000800080000
+CFA5:000000283FA800A83FB800A804A804287FA8000003F8020003F8020003F80000
+CFA6:000000283FA800A83FB800A804A804287FA8000000000FF8022002200FF80000
+CFA7:000000283FA800A83FB800A804A804287FA8000000800FF803E0041003E00000
+CFA8:00000000000400043FC4004400443FC40444044404047FF40004000400040000
+CFA9:000000083F8800883F880088048804087FE8000007F800080008000800080000
+CFAA:000000083F8800883F880088048804087FE8000000003EF80208020802080000
+CFAB:000000083F8800883F880088048804087FE8000000001F080108011401620000
+CFAC:000000083F8800883F880088048804087FE8000008000800080008000FF80000
+CFAD:000000083F8800883F880088048804087FE80000000010F8101010301ECC0000
+CFAE:000000083F8800883F880088048804087FE800000808087F081C08220F9C0000
+CFAF:000000083F8800883F880088048804087FE8000003F802000200020003F80000
+CFB0:000000083F8800883F880088048804087FE8000007F8000807F8040007F80000
+CFB1:000000083F8800883F880088048804087FE800003EF802083E0820083E080000
+CFB2:000000083F8800883F880088048804087FE800003EF802883E8820883EF80000
+CFB3:000000083F8800883F880088048804087FE800003E8802883EF820883EF80000
+CFB4:000000083F8800883F880088048804087FE800001F0801081F0810141F620000
+CFB5:000000083F8800883F880088048804087FE800003EF802803EF820803EF80000
+CFB6:000000083F8800883F880088048804087FE800003EFC02483E4820483EFC0000
+CFB7:000000083F8800883F880088048804087FE800001F08017F1F1C10221F1C0000
+CFB8:000000083F8800883F880088048804087FE8000003F802080208020803F80000
+CFB9:000000083F8800883F880088048804087FE800000208020803F8020803F80000
+CFBA:000000083F8800883F880088048804087FE80000110811081F0811141F620000
+CFBB:000000083F8800883F880088048804087FE80000001000100010006801840000
+CFBC:000000083F8800883F880088048804087FE800000048004800A8011406620000
+CFBD:000000083F8800883F880088048804087FE80000000003F00408040803F00000
+CFBE:000000083F8800883F880088048804087FE8000003F80020002000D003080000
+CFBF:000000083F8800883F880088048804087FE80000004003F8004000A003180000
+CFC0:000000083F8800883F880088048804087FE8000003F8000803F8000800080000
+CFC1:000000083F8800883F880088048804087FE8000003F8020003F8020003F80000
+CFC2:000000083F8800883F880088048804087FE8000000000FF8022002200FF80000
+CFC3:000000083F8800883F880088048804087FE8000000800FF803E0041003E00000
+CFC4:00000000000000003FF8000800083FF8000808880888088008807FFC00000000
+CFC5:000000001FF000101FF00010049004807FFC00001FF000100010001000100000
+CFC6:000000001FF000101FF00010049004807FFC000000003EF80208020802080000
+CFC7:000000001FF000101FF00010049004807FFC000000001E100210022802C40000
+CFC8:000000001FF000101FF00010049004807FFC000000001000100010001FF00000
+CFC9:000000001FF000101FF00010049004807FFC0000000020F8201020303ECC0000
+CFCA:000000001FF000101FF00010049004807FFC0000202021FC207020883E700000
+CFCB:000000001FF000101FF00010049004807FFC00001FF01000100010001FF00000
+CFCC:000000001FF000101FF00010049004807FFC00001FF000101FF010001FF00000
+CFCD:000000001FF000101FF00010049004807FFC00003EF802083E0820083E080000
+CFCE:000000001FF000101FF00010049004807FFC00003EF802883E8820883EF80000
+CFCF:000000001FF000101FF00010049004807FFC00003E8802883EF820883EF80000
+CFD0:000000001FF000101FF00010049004807FFC00003E1002103E1020283EC40000
+CFD1:000000001FF000101FF00010049004807FFC00003EF802803EF820803EF80000
+CFD2:000000001FF000101FF00010049004807FFC00003EFC02483E4820483EFC0000
+CFD3:000000001FF000101FF00010049004807FFC00003E2003FC3E7020883E700000
+CFD4:000000001FF000101FF00010049004807FFC00001FF01010101010101FF00000
+CFD5:000000001FF000101FF00010049004807FFC0000101010101FF010101FF00000
+CFD6:000000001FF000101FF00010049004807FFC0000222022203E2022503E880000
+CFD7:000000001FF000101FF00010049004807FFC000000000100010002800C400000
+CFD8:000000001FF000101FF00010049004807FFC00000000024002400DA033100000
+CFD9:000000001FF000101FF00010049004807FFC0000000007C00820082007C00000
+CFDA:000000001FF000101FF00010049004807FFC0000000007E00080014006200000
+CFDB:000000001FF000101FF00010049004807FFC0000008007E00080014006200000
+CFDC:000000001FF000101FF00010049004807FFC00001FF000101FF0001000100000
+CFDD:000000001FF000101FF00010049004807FFC00001FF010001FF010001FF00000
+CFDE:000000001FF000101FF00010049004807FFC000000001FF0044004401FF00000
+CFDF:000000001FF000101FF00010049004807FFC000001001FF007C0082007C00000
+CFE0:0000000000003FF8000800083FF80008000800003FF801000100010001000000
+CFE1:000000001FF000101FF0001000107FFC010001001FF000100010001000100000
+CFE2:000000001FF000101FF0001000107FFC0100010000003EF80208020802080000
+CFE3:000000001FF000101FF0001000107FFC0100010000001E100210022802C40000
+CFE4:000000001FF000101FF00010001000007FFC010001001100100010001FF00000
+CFE5:000000001FF000101FF0001000107FFC01000100000020F8201020303ECC0000
+CFE6:000000001FF000101FF0001000107FFC01000100202021FC207020883E700000
+CFE7:000000001FF000101FF0001000107FFC010001001FF01000100010001FF00000
+CFE8:000000001FF000101FF0001000107FFC010001001FF000101FF010001FF00000
+CFE9:000000001FF000101FF0001000107FFC010001003EF802083E0820083E080000
+CFEA:000000001FF000101FF0001000107FFC010001003EF802883E8820883EF80000
+CFEB:000000001FF000101FF0001000107FFC010001003E8802883EF820883EF80000
+CFEC:000000001FF000101FF0001000107FFC010001003E1002103E1020283EC40000
+CFED:000000001FF000101FF0001000107FFC010001003EF802803EF820803EF80000
+CFEE:000000001FF000101FF0001000107FFC010001003EFC02483E4820483EFC0000
+CFEF:000000001FF000101FF0001000107FFC010001003E2003FC3E7020883E700000
+CFF0:000000001FF000101FF0001000107FFC010001001FF01010101010101FF00000
+CFF1:000000001FF000101FF0001000107FFC01000100101010101FF010101FF00000
+CFF2:000000001FF000101FF0001000107FFC01000100222022203E2022503E880000
+CFF3:000000001FF000101FF0001000107FFC0100010000000100010002800C400000
+CFF4:000000001FF000101FF0001000107FFC010001000000024002400DA033100000
+CFF5:000000001FF000101FF0001000107FFC01000100000007C00820082007C00000
+CFF6:000000001FF000101FF0001000107FFC01000100000007E00080014006200000
+CFF7:000000001FF000101FF0001000107FFC01000100008007E00080014006200000
+CFF8:000000001FF000101FF0001000107FFC010001001FF000101FF0001000100000
+CFF9:000000001FF000101FF0001000107FFC010001001FF010001FF010001FF00000
+CFFA:000000001FF000101FF0001000107FFC0100010000001FF0044004401FF00000
+CFFB:000000001FF000101FF0001000107FFC0100010001001FF007C0082007C00000
+CFFC:0000000800083FC8004800483FC80048004800087FE8040804F8040804080000
+CFFD:00083F8800883F88008800887FE8027802080000000007F80008000800080000
+CFFE:00083F8800883F88008800887FE802780208000000003EF80208020802080000
+CFFF:00083F8800883F88008800887FE802780208000000001F080108011401620000
+D000:00083F8800883F880088008800087FE80278020802081000100010001FF80000
+D001:00083F8800883F88008800887FE8027802080000000020F8201020303ECC0000
+D002:00083F8800883F88008800887FE8027802080000202021FC207020883E700000
+D003:00083F8800883F88008800887FE802780208000003F802000200020003F80000
+D004:00083F8800883F88008800887FE802780208000007F8000807F8040007F80000
+D005:00083F8800883F88008800887FE80278020800003EF802083E0820083E080000
+D006:00083F8800883F88008800887FE80278020800003EF802883E8820883EF80000
+D007:00083F8800883F88008800887FE80278020800003E8802883EF820883EF80000
+D008:00083F8800883F88008800887FE80278020800000F8800880F8808140FA20000
+D009:00083F8800883F88008800887FE80278020800003EF802803EF820803EF80000
+D00A:00083F8800883F88008800887FE80278020800003EFC02483E4820483EFC0000
+D00B:00083F8800883F88008800887FE80278020800003E1002FE3E3820443E380000
+D00C:00083F8800883F88008800887FE802780208000003F802080208020803F80000
+D00D:00083F8800883F88008800887FE80278020800000208020803F8020803F80000
+D00E:00083F8800883F88008800887FE8027802080000210821083F0821143F620000
+D00F:00083F8800883F88008800887FE8027802080000001000100010006801840000
+D010:00083F8800883F88008800887FE80278020800000048004800A8011406620000
+D011:00083F8800883F88008800887FE8027802080000000003F00408040803F00000
+D012:00083F8800883F88008800887FE802780208000003F80020002000D003080000
+D013:00083F8800883F88008800887FE8027802080000004003F8004000A003180000
+D014:00083F8800883F88008800887FE802780208000003F8000803F8000800080000
+D015:00083F8800883F88008800887FE802780208000003F8020003F8020003F80000
+D016:00083F8800883F88008800887FE802780208000000000FF8022002200FF80000
+D017:00083F8800883F88008800887FE802780208000000800FF803E0041003E00000
+D018:0000000A000A3FCA004A004A3FCA004A004A000A7FEA040A047A040A040A0000
+D019:00283FA800A83FA800A800A87FA805E804280000000007F80008000800080000
+D01A:00283FA800A83FA800A800A87FA805E80428000000003EF80208020802080000
+D01B:00283FA800A83FA800A800A87FA805E80428000000001F080108011401620000
+D01C:00283FA800A83FA800A800A800287FA8042805E804281428100010001FF80000
+D01D:00283FA800A83FA800A800A87FA805E804280000000020F8201020303ECC0000
+D01E:00283FA800A83FA800A800A87FA805E804280000202021FC207020883E700000
+D01F:00283FA800A83FA800A800A87FA805E80428000003F802000200020003F80000
+D020:00283FA800A83FA800A800A87FA805E80428000007F8000807F8040007F80000
+D021:00283FA800A83FA800A800A87FA805E8042800003EF802083E0820083E080000
+D022:00283FA800A83FA800A800A87FA805E8042800003EF802883E8820883EF80000
+D023:00283FA800A83FA800A800A87FA805E8042800003E8802883EF820883EF80000
+D024:00283FA800A83FA800A800A87FA805E8042800000F8800880F8808140FA20000
+D025:00283FA800A83FA800A800A87FA805E8042800003EF802803EF820803EF80000
+D026:00283FA800A83FA800A800A87FA805E8042800003EFC02483E4820483EFC0000
+D027:00283FA800A83FA800A800A87FA805E8042800003E1002FE3E3820443E380000
+D028:00283FA800A83FA800A800A87FA805E80428000003F802080208020803F80000
+D029:00283FA800A83FA800A800A87FA805E8042800000208020803F8020803F80000
+D02A:00283FA800A83FA800A800A87FA805E804280000210821083F0821143F620000
+D02B:00283FA800A83FA800A800A87FA805E804280000001000100010006801840000
+D02C:00283FA800A83FA800A800A87FA805E8042800000048004800A8011406620000
+D02D:00283FA800A83FA800A800A87FA805E804280000000003F00408040803F00000
+D02E:00283FA800A83FA800A800A87FA805E80428000003F80020002000D003080000
+D02F:00283FA800A83FA800A800A87FA805E804280000004003F8004000A003180000
+D030:00283FA800A83FA800A800A87FA805E80428000003F8000803F8000800080000
+D031:00283FA800A83FA800A800A87FA805E80428000003F8020003F8020003F80000
+D032:00283FA800A83FA800A800A87FA805E80428000000000FF8022002200FF80000
+D033:00283FA800A83FA800A800A87FA805E80428000000800FF803E0041003E00000
+D034:0000000800083FC8004800483FC80048004800087FE804080408040804080000
+D035:00083F8800883F88008800887FE8020802000000000007F80008000800080000
+D036:00083F8800883F88008800887FE802080200000000003EF80208020802080000
+D037:00083F8800883F88008800887FE802080200000000001F080108011401620000
+D038:00083F8800883F880088008800087FE80208020802081008100010001FF80000
+D039:00083F8800883F88008800887FE8020802000000000020F8201020303ECC0000
+D03A:00083F8800883F88008800887FE8020802000000202021FC207020883E700000
+D03B:00083F8800883F88008800887FE802080200000003F802000200020003F80000
+D03C:00083F8800883F88008800887FE802080200000007F8000807F8040007F80000
+D03D:00083F8800883F88008800887FE80208020000003EF802083E0820083E080000
+D03E:00083F8800883F88008800887FE80208020000003EF802883E8820883EF80000
+D03F:00083F8800883F88008800887FE80208020000003E8802883EF820883EF80000
+D040:00083F8800883F88008800887FE80208020000000F8800880F8808140FA20000
+D041:00083F8800883F88008800887FE80208020000003EF802803EF820803EF80000
+D042:00083F8800883F88008800887FE80208020000003EFC02483E4820483EFC0000
+D043:00083F8800883F88008800887FE80208020000003E1002FE3E3820443E380000
+D044:00083F8800883F88008800887FE802080200000003F802080208020803F80000
+D045:00083F8800883F88008800887FE80208020000000208020803F8020803F80000
+D046:00083F8800883F88008800887FE8020802000000210821083F0821143F620000
+D047:00083F8800883F88008800887FE8020802000000001000100010006801840000
+D048:00083F8800883F88008800887FE80208020000000048004800A8011406620000
+D049:00083F8800883F88008800887FE8020802000000000003F00408040803F00000
+D04A:00083F8800883F88008800887FE802080200000003F80020002000D003080000
+D04B:00083F8800883F88008800887FE8020802000000004003F8004000A003180000
+D04C:00083F8800883F88008800887FE802080200000003F8000803F8000800080000
+D04D:00083F8800883F88008800887FE802080200000003F8020003F8020003F80000
+D04E:00083F8800883F88008800887FE802080200000000000FF8022002200FF80000
+D04F:00083F8800883F88008800887FE802080200000000800FF803E0041003E00000
+D050:0000000000003FF8000800083FF80008000800007FFC04400440044004400000
+D051:000000001FF000101FF0001000107FFC044004401FF000100010001000100000
+D052:000000001FF000101FF0001000107FFC0440044000003EF80208020802080000
+D053:000000001FF000101FF0001000107FFC0440044000001E100210022802C40000
+D054:000000001FF000101FF00010001000007FFC044004401440100010001FF00000
+D055:000000001FF000101FF0001000107FFC04400440000020F8201020303ECC0000
+D056:000000001FF000101FF0001000107FFC04400440202021FC207020883E700000
+D057:000000001FF000101FF0001000107FFC044004401FF01000100010001FF00000
+D058:000000001FF000101FF0001000107FFC044004401FF000101FF010001FF00000
+D059:000000001FF000101FF0001000107FFC044004403EF802083E0820083E080000
+D05A:000000001FF000101FF0001000107FFC044004403EF802883E8820883EF80000
+D05B:000000001FF000101FF0001000107FFC044004403E8802883EF820883EF80000
+D05C:000000001FF000101FF0001000107FFC044004403E1002103E1020283EC40000
+D05D:000000001FF000101FF0001000107FFC044004403EF802803EF820803EF80000
+D05E:000000001FF000101FF0001000107FFC044004403EFC02483E4820483EFC0000
+D05F:000000001FF000101FF0001000107FFC044004403E2003FC3E7020883E700000
+D060:000000001FF000101FF0001000107FFC044004401FF01010101010101FF00000
+D061:000000001FF000101FF0001000107FFC04400440101010101FF010101FF00000
+D062:000000001FF000101FF0001000107FFC04400440222022203E2022503E880000
+D063:000000001FF000101FF0001000107FFC0440044000000100010002800C400000
+D064:000000001FF000101FF0001000107FFC044004400000024002400DA033100000
+D065:000000001FF000101FF0001000107FFC04400440000007C00820082007C00000
+D066:000000001FF000101FF0001000107FFC04400440000007E00080014006200000
+D067:000000001FF000101FF0001000107FFC04400440008007E00080014006200000
+D068:000000001FF000101FF0001000107FFC044004401FF000101FF0001000100000
+D069:000000001FF000101FF0001000107FFC044004401FF010001FF010001FF00000
+D06A:000000001FF000101FF0001000107FFC0440044000001FF0044004401FF00000
+D06B:000000001FF000101FF0001000107FFC0440044001001FF007C0082007C00000
+D06C:00000000000000003FF8000800083FF80008000800087FFC0000000000000000
+D06D:000000001FF000101FF00010001000007FFC00001FF000100010001000100000
+D06E:000000001FF000101FF00010001000007FFC000000003EF80208020802080000
+D06F:000000001FF000101FF00010001000007FFC000000001E100210022802C40000
+D070:000000001FF000101FF00010001000007FFC000000001000100010001FF00000
+D071:000000001FF000101FF00010001000007FFC0000000020F8201020303ECC0000
+D072:000000001FF000101FF00010001000007FFC0000202021FC207020883E700000
+D073:000000001FF000101FF00010001000007FFC00001FF01000100010001FF00000
+D074:000000001FF000101FF00010001000007FFC00001FF000101FF010001FF00000
+D075:000000001FF000101FF00010001000007FFC00003EF802083E0820083E080000
+D076:000000001FF000101FF00010001000007FFC00003EF802883E8820883EF80000
+D077:000000001FF000101FF00010001000007FFC00003E8802883EF820883EF80000
+D078:000000001FF000101FF00010001000007FFC00003E1002103E1020283EC40000
+D079:000000001FF000101FF00010001000007FFC00003EF802803EF820803EF80000
+D07A:000000001FF000101FF00010001000007FFC00003EFC02483E4820483EFC0000
+D07B:000000001FF000101FF00010001000007FFC00003E2003FC3E7020883E700000
+D07C:000000001FF000101FF00010001000007FFC00001FF01010101010101FF00000
+D07D:000000001FF000101FF00010001000007FFC0000101010101FF010101FF00000
+D07E:000000001FF000101FF00010001000007FFC0000222022203E2022503E880000
+D07F:000000001FF000101FF00010001000007FFC000000000100010002800C400000
+D080:000000001FF000101FF00010001000007FFC00000000024002400DA033100000
+D081:000000001FF000101FF00010001000007FFC0000000007C00820082007C00000
+D082:000000001FF000101FF00010001000007FFC0000000007E00080014006200000
+D083:000000001FF000101FF00010001000007FFC0000008007E00080014006200000
+D084:000000001FF000101FF00010001000007FFC00001FF000101FF0001000100000
+D085:000000001FF000101FF00010001000007FFC00001FF010001FF010001FF00000
+D086:000000001FF000101FF00010001000007FFC000000001FF0044004401FF00000
+D087:000000001FF000101FF00010001000007FFC000001001FF007C0082007C00000
+D088:00000000000800083FC8004800483FC80048004800087FE80008000800080000
+D089:000000083F8800883F880088008800087FE8000007F800080008000800080000
+D08A:000000083F8800883F880088008800087FE8000000003EF80208020802080000
+D08B:000000083F8800883F880088008800087FE8000000001F080108011401620000
+D08C:000000083F8800883F880088008800087FE8000008000800080008000FF80000
+D08D:000000083F8800883F880088008800087FE80000000010F8101010301ECC0000
+D08E:000000083F8800883F880088008800087FE800000808087F081C08220F9C0000
+D08F:000000083F8800883F880088008800087FE8000003F802000200020003F80000
+D090:000000083F8800883F880088008800087FE8000007F8000807F8040007F80000
+D091:000000083F8800883F880088008800087FE800003EF802083E0820083E080000
+D092:000000083F8800883F880088008800087FE800003EF802883E8820883EF80000
+D093:000000083F8800883F880088008800087FE800003E8802883EF820883EF80000
+D094:000000083F8800883F880088008800087FE800001F0801081F0810141F620000
+D095:000000083F8800883F880088008800087FE800003EF802803EF820803EF80000
+D096:000000083F8800883F880088008800087FE800003EFC02483E4820483EFC0000
+D097:000000083F8800883F880088008800087FE800001F08017F1F1C10221F1C0000
+D098:000000083F8800883F880088008800087FE8000003F802080208020803F80000
+D099:000000083F8800883F880088008800087FE800000208020803F8020803F80000
+D09A:000000083F8800883F880088008800087FE80000110811081F0811141F620000
+D09B:000000083F8800883F880088008800087FE80000001000100010006801840000
+D09C:000000083F8800883F880088008800087FE800000048004800A8011406620000
+D09D:000000083F8800883F880088008800087FE80000000003F00408040803F00000
+D09E:000000083F8800883F880088008800087FE8000003F80020002000D003080000
+D09F:000000083F8800883F880088008800087FE80000004003F8004000A003180000
+D0A0:000000083F8800883F880088008800087FE8000003F8000803F8000800080000
+D0A1:000000083F8800883F880088008800087FE8000003F8020003F8020003F80000
+D0A2:000000083F8800883F880088008800087FE8000000000FF8022002200FF80000
+D0A3:000000083F8800883F880088008800087FE8000000800FF803E0041003E00000
+D0A4:00000000000800081F880088008800881F080108020804081808000800080000
+D0A5:000000087E08020802087E080408180860080000000007F80008000800080000
+D0A6:000000087E08020802087E08040818086008000000003EF80208020802080000
+D0A7:000000087E08020802087E08040818086008000000001F080108011401620000
+D0A8:000000087E08020802087E08040818086008000800001000100010001FF80000
+D0A9:000000087E08020802087E080408180860080000000020F8201020303ECC0000
+D0AA:000000087E08020802087E080408180860080000202021FC207020883E700000
+D0AB:000000087E08020802087E08040818086008000003F802000200020003F80000
+D0AC:000000087E08020802087E08040818086008000007F8000807F8040007F80000
+D0AD:000000087E08020802087E0804081808600800003EF802083E0820083E080000
+D0AE:000000087E08020802087E0804081808600800003EF802883E8820883EF80000
+D0AF:000000087E08020802087E0804081808600800003E8802883EF820883EF80000
+D0B0:000000087E08020802087E0804081808600800000F8800880F8808140FA20000
+D0B1:000000087E08020802087E0804081808600800003EF802803EF820803EF80000
+D0B2:000000087E08020802087E0804081808600800003EFC02483E4820483EFC0000
+D0B3:000000087E08020802087E0804081808600800003E1002FE3E3820443E380000
+D0B4:000000087E08020802087E08040818086008000003F802080208020803F80000
+D0B5:000000087E08020802087E0804081808600800000208020803F8020803F80000
+D0B6:000000087E08020802087E080408180860080000210821083F0821143F620000
+D0B7:000000087E08020802087E080408180860080000001000100010006801840000
+D0B8:000000087E08020802087E0804081808600800000048004800A8011406620000
+D0B9:000000087E08020802087E080408180860080000000003F00408040803F00000
+D0BA:000000087E08020802087E08040818086008000003F80020002000D003080000
+D0BB:000000087E08020802087E080408180860080000004003F8004000A003180000
+D0BC:000000087E08020802087E08040818086008000003F8000803F8000800080000
+D0BD:000000087E08020802087E08040818086008000003F8020003F8020003F80000
+D0BE:000000087E08020802087E08040818086008000000000FF8022002200FF80000
+D0BF:000000087E08020802087E08040818086008000000800FF803E0041003E00000
+D0C0:00000000001000103F90201020103F9E201020103F9000100010001000100000
+D0C1:0000000800087E0840087E0E40087E080008000007F800080008000800080000
+D0C2:0000000800087E0840087E0E40087E080008000000003EF80208020802080000
+D0C3:0000000800087E0840087E0E40087E080008000000001F080108011401620000
+D0C4:0000000800087E0840087E0E40087E080008000808000800080008000FF80000
+D0C5:0000000800087E0840087E0E40087E0800080000000010F8101010301ECC0000
+D0C6:0000000800087E0840087E0E40087E08000800000808087F081C08220F9C0000
+D0C7:0000000800087E0840087E0E40087E080008000003F802000200020003F80000
+D0C8:0000000800087E0840087E0E40087E080008000007F8000807F8040007F80000
+D0C9:0000000800087E0840087E0E40087E08000800003EF802083E0820083E080000
+D0CA:0000000800087E0840087E0E40087E08000800003EF802883E8820883EF80000
+D0CB:0000000800087E0840087E0E40087E08000800003E8802883EF820883EF80000
+D0CC:0000000800087E0840087E0E40087E08000800001F0801081F0810141F620000
+D0CD:0000000800087E0840087E0E40087E08000800003EF802803EF820803EF80000
+D0CE:0000000800087E0840087E0E40087E08000800003EFC02483E4820483EFC0000
+D0CF:0000000800087E0840087E0E40087E08000800001F08017F1F1C10221F1C0000
+D0D0:0000000800087E0840087E0E40087E080008000003F802080208020803F80000
+D0D1:0000000800087E0840087E0E40087E08000800000208020803F8020803F80000
+D0D2:0000000800087E0840087E0E40087E0800080000110811081F0811141F620000
+D0D3:0000000800087E0840087E0E40087E0800080000001000100010006801840000
+D0D4:0000000800087E0840087E0E40087E08000800000048004800A8011406620000
+D0D5:0000000800087E0840087E0E40087E0800080000000003F00408040803F00000
+D0D6:0000000800087E0840087E0E40087E080008000003F80020002000D003080000
+D0D7:0000000800087E0840087E0E40087E0800080000004003F8004000A003180000
+D0D8:0000000800087E0840087E0E40087E080008000003F8000803F8000800080000
+D0D9:0000000800087E0840087E0E40087E080008000003F8020003F8020003F80000
+D0DA:0000000800087E0840087E0E40087E080008000000000FF8022002200FF80000
+D0DB:0000000800087E0840087E0E40087E080008000000800FF803E0041003E00000
+D0DC:00000000001200123F92201220123F9E201220123F9200120012001200120000
+D0DD:0000002800287E2840287E3840287E280028000007F800080008000800080000
+D0DE:0000002800287E2840287E3840287E280028000000003EF80208020802080000
+D0DF:0000002800287E2840287E3840287E280028000000003E100210022802C40000
+D0E0:0000002800287E2840287E3840287E280028002808000800080008000FF80000
+D0E1:0000002800287E2840287E3840287E2800280000000020F8201020303ECC0000
+D0E2:0000002800287E2840287E3840287E2800280000202021FC207020883E700000
+D0E3:0000002800287E2840287E3840287E280028000003F802000200020003F80000
+D0E4:0000002800287E2840287E3840287E280028000007F8000807F8040007F80000
+D0E5:0000002800287E2840287E3840287E28002800003EF802083E0820083E080000
+D0E6:0000002800287E2840287E3840287E28002800003EF802883E8820883EF80000
+D0E7:0000002800287E2840287E3840287E28002800003E8802883EF820883EF80000
+D0E8:0000002800287E2840287E3840287E28002800001F0801081F0810141F620000
+D0E9:0000002800287E2840287E3840287E28002800003EF802803EF820803EF80000
+D0EA:0000002800287E2840287E3840287E28002800003EFC02483E4820483EFC0000
+D0EB:0000002800287E2840287E3840287E28002800003E1002FE3E3820443E380000
+D0EC:0000002800287E2840287E3840287E280028000003F802080208020803F80000
+D0ED:0000002800287E2840287E3840287E28002800000208020803F8020803F80000
+D0EE:0000002800287E2840287E3840287E2800280000110811081F0811141F620000
+D0EF:0000002800287E2840287E3840287E2800280000000800080008003400C20000
+D0F0:0000002800287E2840287E3840287E28002800000048004800A8011406620000
+D0F1:0000002800287E2840287E3840287E2800280000000001F00208020801F00000
+D0F2:0000002800287E2840287E3840287E280028000003F80020002000D003080000
+D0F3:0000002800287E2840287E3840287E2800280000004003F8004000A003180000
+D0F4:0000002800287E2840287E3840287E280028000003F8000803F8000800080000
+D0F5:0000002800287E2840287E3840287E280028000003F8020003F8020003F80000
+D0F6:0000002800287E2840287E3840287E280028000000000FF8022002200FF80000
+D0F7:0000002800287E2840287E3840287E280028000000800FF803E0041003E00000
+D0F8:00000000001000103F902010201E3F902010201E3F9000100010001000100000
+D0F9:0000000800087E08400E7E08400E7E080008000007F800080008000800080000
+D0FA:0000000800087E08400E7E08400E7E080008000000003EF80208020802080000
+D0FB:0000000800087E08400E7E08400E7E080008000000001F080108011401620000
+D0FC:0000000800087E08400E7E08400E7E080008000008000800080008000FF80000
+D0FD:0000000800087E08400E7E08400E7E0800080000000010F8101010301ECC0000
+D0FE:0000000800087E08400E7E08400E7E08000800000808087F081C08220F9C0000
+D0FF:0000000800087E08400E7E08400E7E080008000003F802000200020003F80000
+D100:0000000800087E08400E7E08400E7E080008000007F8000807F8040007F80000
+D101:0000000800087E08400E7E08400E7E08000800003EF802083E0820083E080000
+D102:0000000800087E08400E7E08400E7E08000800003EF802883E8820883EF80000
+D103:0000000800087E08400E7E08400E7E08000800003E8802883EF820883EF80000
+D104:0000000800087E08400E7E08400E7E08000800001F0801081F0810141F620000
+D105:0000000800087E08400E7E08400E7E08000800003EF802803EF820803EF80000
+D106:0000000800087E08400E7E08400E7E08000800003EFC02483E4820483EFC0000
+D107:0000000800087E08400E7E08400E7E08000800001F08017F1F1C10221F1C0000
+D108:0000000800087E08400E7E08400E7E080008000003F802080208020803F80000
+D109:0000000800087E08400E7E08400E7E08000800000208020803F8020803F80000
+D10A:0000000800087E08400E7E08400E7E0800080000110811081F0811141F620000
+D10B:0000000800087E08400E7E08400E7E0800080000001000100010006801840000
+D10C:0000000800087E08400E7E08400E7E08000800000048004800A8011406620000
+D10D:0000000800087E08400E7E08400E7E0800080000000003F00408040803F00000
+D10E:0000000800087E08400E7E08400E7E080008000003F80020002000D003080000
+D10F:0000000800087E08400E7E08400E7E0800080000004003F8004000A003180000
+D110:0000000800087E08400E7E08400E7E080008000003F8000803F8000800080000
+D111:0000000800087E08400E7E08400E7E080008000003F8020003F8020003F80000
+D112:0000000800087E08400E7E08400E7E080008000000000FF8022002200FF80000
+D113:0000000800087E08400E7E08400E7E080008000000800FF803E0041003E00000
+D114:00000000001200123F922012201E3F922012201E3F9200120012001200120000
+D115:0000002800287E2840387E2840387E280028000007F800080008000800080000
+D116:0000002800287E2840387E2840387E280028000000003EF80208020802080000
+D117:0000002800287E2840387E2840387E280028000000003E100210022802C40000
+D118:0000002800287E2840387E2840387E280028002808000800080008000FF80000
+D119:0000002800287E2840387E2840387E2800280000000020F8201020303ECC0000
+D11A:0000002800287E2840387E2840387E2800280000202021FC207020883E700000
+D11B:0000002800287E2840387E2840387E280028000003F802000200020003F80000
+D11C:0000002800287E2840387E2840387E280028000007F8000807F8040007F80000
+D11D:0000002800287E2840387E2840387E28002800003EF802083E0820083E080000
+D11E:0000002800287E2840387E2840387E28002800003EF802883E8820883EF80000
+D11F:0000002800287E2840387E2840387E28002800003E8802883EF820883EF80000
+D120:0000002800287E2840387E2840387E28002800001F0801081F0810141F620000
+D121:0000002800287E2840387E2840387E28002800003EF802803EF820803EF80000
+D122:0000002800287E2840387E2840387E28002800003EFC02483E4820483EFC0000
+D123:0000002800287E2840387E2840387E28002800003E1002FE3E3820443E380000
+D124:0000002800287E2840387E2840387E280028000003F802080208020803F80000
+D125:0000002800287E2840387E2840387E28002800000208020803F8020803F80000
+D126:0000002800287E2840387E2840387E2800280000110811081F0811141F620000
+D127:0000002800287E2840387E2840387E2800280000000800080008003400C20000
+D128:0000002800287E2840387E2840387E28002800000048004800A8011406620000
+D129:0000002800287E2840387E2840387E2800280000000001F00208020801F00000
+D12A:0000002800287E2840387E2840387E280028000003F80020002000D003080000
+D12B:0000002800287E2840387E2840387E2800280000004003F8004000A003180000
+D12C:0000002800287E2840387E2840387E280028000003F8000803F8000800080000
+D12D:0000002800287E2840387E2840387E280028000003F8020003F8020003F80000
+D12E:0000002800287E2840387E2840387E280028000000000FF8022002200FF80000
+D12F:0000002800287E2840387E2840387E280028000000800FF803E0041003E00000
+D130:00000000000200023F82200220023F9E200220023F8200020002000200020000
+D131:0000000800087E0840087E3840087E0800080000000007F80008000800080000
+D132:0000000800087E0840087E3840087E080008000000003EF80208020802080000
+D133:0000000800087E0840087E3840087E080008000000001F080108011401620000
+D134:0000000800087E0840087E3840087E080008000000001000100010001FF80000
+D135:0000000800087E0840087E3840087E0800080000000020F8201020303ECC0000
+D136:0000000800087E0840087E3840087E0800080000202021FC207020883E700000
+D137:0000000800087E0840087E3840087E080008000003F802000200020003F80000
+D138:0000000800087E0840087E3840087E080008000007F8000807F8040007F80000
+D139:0000000800087E0840087E3840087E08000800003EF802083E0820083E080000
+D13A:0000000800087E0840087E3840087E08000800003EF802883E8820883EF80000
+D13B:0000000800087E0840087E3840087E08000800003E8802883EF820883EF80000
+D13C:0000000800087E0840087E3840087E08000800000F8800880F8808140FA20000
+D13D:0000000800087E0840087E3840087E08000800003EF802803EF820803EF80000
+D13E:0000000800087E0840087E3840087E08000800003EFC02483E4820483EFC0000
+D13F:0000000800087E0840087E3840087E08000800003E1002FE3E3820443E380000
+D140:0000000800087E0840087E3840087E080008000003F802080208020803F80000
+D141:0000000800087E0840087E3840087E08000800000208020803F8020803F80000
+D142:0000000800087E0840087E3840087E0800080000210821083F0821143F620000
+D143:0000000800087E0840087E3840087E0800080000001000100010006801840000
+D144:0000000800087E0840087E3840087E08000800000048004800A8011406620000
+D145:0000000800087E0840087E3840087E0800080000000003F00408040803F00000
+D146:0000000800087E0840087E3840087E080008000003F80020002000D003080000
+D147:0000000800087E0840087E3840087E0800080000004003F8004000A003180000
+D148:0000000800087E0840087E3840087E080008000003F8000803F8000800080000
+D149:0000000800087E0840087E3840087E080008000003F8020003F8020003F80000
+D14A:0000000800087E0840087E3840087E080008000000000FF8022002200FF80000
+D14B:0000000800087E0840087E3840087E080008000000800FF803E0041003E00000
+D14C:00000000000A000A3F8A200A200A3FBA200A200A3F8A000A000A000A000A0000
+D14D:0000002800287E2840287EE840287E280028000007F800080008000800080000
+D14E:0000002800287E2840287EE840287E280028000000003EF80208020802080000
+D14F:0000002800287E2840287EE840287E280028000000003E100210022802C40000
+D150:0000002800287E2840287EE840287E280028000008000800080008000FF80000
+D151:0000002800287E2840287EE840287E2800280000000020F8201020303ECC0000
+D152:0000002800287E2840287EE840287E2800280000202021FC207020883E700000
+D153:0000002800287E2840287EE840287E280028000003F802000200020003F80000
+D154:0000002800287E2840287EE840287E280028000007F8000807F8040007F80000
+D155:0000002800287E2840287EE840287E28002800003EF802083E0820083E080000
+D156:0000002800287E2840287EE840287E28002800003EF802883E8820883EF80000
+D157:0000002800287E2840287EE840287E28002800003E8802883EF820883EF80000
+D158:0000002800287E2840287EE840287E28002800001F0801081F0810141F620000
+D159:0000002800287E2840287EE840287E28002800003EF802803EF820803EF80000
+D15A:0000002800287E2840287EE840287E28002800003EFC02483E4820483EFC0000
+D15B:0000002800287E2840287EE840287E28002800003E1002FE3E3820443E380000
+D15C:0000002800287E2840287EE840287E280028000003F802080208020803F80000
+D15D:0000002800287E2840287EE840287E28002800000208020803F8020803F80000
+D15E:0000002800287E2840287EE840287E2800280000110811081F0811141F620000
+D15F:0000002800287E2840287EE840287E2800280000000800080008003400C20000
+D160:0000002800287E2840287EE840287E28002800000048004800A8011406620000
+D161:0000002800287E2840287EE840287E2800280000000001F00208020801F00000
+D162:0000002800287E2840287EE840287E280028000003F80020002000D003080000
+D163:0000002800287E2840287EE840287E2800280000004003F8004000A003180000
+D164:0000002800287E2840287EE840287E280028000003F8000803F8000800080000
+D165:0000002800287E2840287EE840287E280028000003F8020003F8020003F80000
+D166:0000002800287E2840287EE840287E280028000000000FF8022002200FF80000
+D167:0000002800287E2840287EE840287E280028000000800FF803E0041003E00000
+D168:00000000000200023F822002201E3F822002201E3F8200020002000200020000
+D169:0000000800087E0840387E0840387E0800080000000007F80008000800080000
+D16A:0000000800087E0840387E0840387E080008000000003EF80208020802080000
+D16B:0000000800087E0840387E0840387E080008000000001F080108011401620000
+D16C:0000000800087E0840387E0840387E080008000800001000100010001FF80000
+D16D:0000000800087E0840387E0840387E0800080000000020F8201020303ECC0000
+D16E:0000000800087E0840387E0840387E0800080000202021FC207020883E700000
+D16F:0000000800087E0840387E0840387E080008000003F802000200020003F80000
+D170:0000000800087E0840387E0840387E080008000007F8000807F8040007F80000
+D171:0000000800087E0840387E0840387E08000800003EF802083E0820083E080000
+D172:0000000800087E0840387E0840387E08000800003EF802883E8820883EF80000
+D173:0000000800087E0840387E0840387E08000800003E8802883EF820883EF80000
+D174:0000000800087E0840387E0840387E08000800000F8800880F8808140FA20000
+D175:0000000800087E0840387E0840387E08000800003EF802803EF820803EF80000
+D176:0000000800087E0840387E0840387E08000800003EFC02483E4820483EFC0000
+D177:0000000800087E0840387E0840387E08000800003E1002FE3E3820443E380000
+D178:0000000800087E0840387E0840387E080008000003F802080208020803F80000
+D179:0000000800087E0840387E0840387E08000800000208020803F8020803F80000
+D17A:0000000800087E0840387E0840387E0800080000210821083F0821143F620000
+D17B:0000000800087E0840387E0840387E0800080000001000100010006801840000
+D17C:0000000800087E0840387E0840387E08000800000048004800A8011406620000
+D17D:0000000800087E0840387E0840387E0800080000000003F00408040803F00000
+D17E:0000000800087E0840387E0840387E080008000003F80020002000D003080000
+D17F:0000000800087E0840387E0840387E0800080000004003F8004000A003180000
+D180:0000000800087E0840387E0840387E080008000003F8000803F8000800080000
+D181:0000000800087E0840387E0840387E080008000003F8020003F8020003F80000
+D182:0000000800087E0840387E0840387E080008000000000FF8022002200FF80000
+D183:0000000800087E0840387E0840387E080008000000800FF803E0041003E00000
+D184:00000000000A000A3F8A200A203A3F8A200A203A3F8A000A000A000A000A0000
+D185:0000002800287E2840E87E2840E87E280028000007F800080008000800080000
+D186:0000002800287E2840E87E2840E87E280028000000003EF80208020802080000
+D187:0000002800287E2840E87E2840E87E280028000000003E100210022802C40000
+D188:0000002800287E2840E87E2840E87E280028002808000800080008000FF80000
+D189:0000002800287E2840E87E2840E87E2800280000000020F8201020303ECC0000
+D18A:0000002800287E2840E87E2840E87E2800280000202021FC207020883E700000
+D18B:0000002800287E2840E87E2840E87E280028000003F802000200020003F80000
+D18C:0000002800287E2840E87E2840E87E280028000007F8000807F8040007F80000
+D18D:0000002800287E2840E87E2840E87E28002800003EF802083E0820083E080000
+D18E:0000002800287E2840E87E2840E87E28002800003EF802883E8820883EF80000
+D18F:0000002800287E2840E87E2840E87E28002800003E8802883EF820883EF80000
+D190:0000002800287E2840E87E2840E87E28002800001F0801081F0810141F620000
+D191:0000002800287E2840E87E2840E87E28002800003EF802803EF820803EF80000
+D192:0000002800287E2840E87E2840E87E28002800003EFC02483E4820483EFC0000
+D193:0000002800287E2840E87E2840E87E28002800003E1002FE3E3820443E380000
+D194:0000002800287E2840E87E2840E87E280028000003F802080208020803F80000
+D195:0000002800287E2840E87E2840E87E28002800000208020803F8020803F80000
+D196:0000002800287E2840E87E2840E87E2800280000110811081F0811141F620000
+D197:0000002800287E2840E87E2840E87E2800280000000800080008003400C20000
+D198:0000002800287E2840E87E2840E87E28002800000048004800A8011406620000
+D199:0000002800287E2840E87E2840E87E2800280000000001F00208020801F00000
+D19A:0000002800287E2840E87E2840E87E280028000003F80020002000D003080000
+D19B:0000002800287E2840E87E2840E87E2800280000004003F8004000A003180000
+D19C:0000002800287E2840E87E2840E87E280028000003F8000803F8000800080000
+D19D:0000002800287E2840E87E2840E87E280028000003F8020003F8020003F80000
+D19E:0000002800287E2840E87E2840E87E280028000000000FF8022002200FF80000
+D19F:0000002800287E2840E87E2840E87E280028000000800FF803E0041003E00000
+D1A0:00003FF8200020003FF8200020003FF8000000000100010001007FFC00000000
+D1A1:00001FF010001FF010001FF0010001007FFC00001FF000100010001000100000
+D1A2:00001FF010001FF010001FF0010001007FFC000000003EF80208020802080000
+D1A3:00001FF010001FF010001FF0010001007FFC000000001E100210022802C40000
+D1A4:00001FF010001FF010001FF0010001007FFC000000001000100010001FF00000
+D1A5:00001FF010001FF010001FF0010001007FFC0000000020F8201020303ECC0000
+D1A6:00001FF010001FF010001FF0010001007FFC0000202021FC207020883E700000
+D1A7:00001FF010001FF010001FF0010001007FFC00001FF01000100010001FF00000
+D1A8:00001FF010001FF010001FF0010001007FFC00001FF000101FF010001FF00000
+D1A9:00001FF010001FF010001FF0010001007FFC00003EF802083E0820083E080000
+D1AA:00001FF010001FF010001FF0010001007FFC00003EF802883E8820883EF80000
+D1AB:00001FF010001FF010001FF0010001007FFC00003E8802883EF820883EF80000
+D1AC:00001FF010001FF010001FF0010001007FFC00003E1002103E1020283EC40000
+D1AD:00001FF010001FF010001FF0010001007FFC00003EF802803EF820803EF80000
+D1AE:00001FF010001FF010001FF0010001007FFC00003EFC02483E4820483EFC0000
+D1AF:00001FF010001FF010001FF0010001007FFC00003E2003FC3E7020883E700000
+D1B0:00001FF010001FF010001FF0010001007FFC00001FF01010101010101FF00000
+D1B1:00001FF010001FF010001FF0010001007FFC0000101010101FF010101FF00000
+D1B2:00001FF010001FF010001FF0010001007FFC0000222022203E2022503E880000
+D1B3:00001FF010001FF010001FF0010001007FFC000000000100010002800C400000
+D1B4:00001FF010001FF010001FF0010001007FFC00000000024002400DA033100000
+D1B5:00001FF010001FF010001FF0010001007FFC0000000007C00820082007C00000
+D1B6:00001FF010001FF010001FF0010001007FFC0000000007E00080014006200000
+D1B7:00001FF010001FF010001FF0010001007FFC0000008007E00080014006200000
+D1B8:00001FF010001FF010001FF0010001007FFC00001FF000101FF0001000100000
+D1B9:00001FF010001FF010001FF0010001007FFC00001FF010001FF010001FF00000
+D1BA:00001FF010001FF010001FF0010001007FFC000000001FF0044004401FF00000
+D1BB:00001FF010001FF010001FF0010001007FFC000001001FF007C0082007C00000
+D1BC:000000103FD0201020103FD02010201E3FD00010041004107FD0001000100000
+D1BD:000000087F0840087F0E40087F0804087FE8000007F800080008000800080000
+D1BE:000000087F0840087F0E40087F0804087FE8000000003EF80208020802080000
+D1BF:000000087F0840087F0E40087F0804087FE8000000001F080108011401620000
+D1C0:000000087F0840087F0E40087F0804087FE8000008000800080008000FF80000
+D1C1:000000087F0840087F0E40087F0804087FE80000000010F8101010301ECC0000
+D1C2:000000087F0840087F0E40087F0804087FE800000808087F081C08220F9C0000
+D1C3:000000087F0840087F0E40087F0804087FE8000003F802000200020003F80000
+D1C4:000000087F0840087F0E40087F0804087FE8000007F8000807F8040007F80000
+D1C5:000000087F0840087F0E40087F0804087FE800003EF802083E0820083E080000
+D1C6:000000087F0840087F0E40087F0804087FE800003EF802883E8820883EF80000
+D1C7:000000087F0840087F0E40087F0804087FE800003E8802883EF820883EF80000
+D1C8:000000087F0840087F0E40087F0804087FE800001F0801081F0810141F620000
+D1C9:000000087F0840087F0E40087F0804087FE800003EF802803EF820803EF80000
+D1CA:000000087F0840087F0E40087F0804087FE800003EFC02483E4820483EFC0000
+D1CB:000000087F0840087F0E40087F0804087FE800001F08017F1F1C10221F1C0000
+D1CC:000000087F0840087F0E40087F0804087FE8000003F802080208020803F80000
+D1CD:000000087F0840087F0E40087F0804087FE800000208020803F8020803F80000
+D1CE:000000087F0840087F0E40087F0804087FE80000110811081F0811141F620000
+D1CF:000000087F0840087F0E40087F0804087FE80000001000100010006801840000
+D1D0:000000087F0840087F0E40087F0804087FE800000048004800A8011406620000
+D1D1:000000087F0840087F0E40087F0804087FE80000000003F00408040803F00000
+D1D2:000000087F0840087F0E40087F0804087FE8000003F80020002000D003080000
+D1D3:000000087F0840087F0E40087F0804087FE80000004003F8004000A003180000
+D1D4:000000087F0840087F0E40087F0804087FE8000003F8000803F8000800080000
+D1D5:000000087F0840087F0E40087F0804087FE8000003F8020003F8020003F80000
+D1D6:000000087F0840087F0E40087F0804087FE8000000000FF8022002200FF80000
+D1D7:000000087F0840087F0E40087F0804087FE8000000800FF803E0041003E00000
+D1D8:000000123FD2201220123FD22012201E3FD20012041204127FD2001200120000
+D1D9:000000287F2840287F3840287F2804287FA8000007F800080008000800080000
+D1DA:000000287F2840287F3840287F2804287FA8000000003EF80208020802080000
+D1DB:000000287F2840287F3840287F2804287FA8000000001F080108011401620000
+D1DC:000000287F2840287F3840287F2804287FA8000008000800080008000FF80000
+D1DD:000000287F2840287F3840287F2804287FA80000000010F8101010301ECC0000
+D1DE:000000287F2840287F3840287F2804287FA800000808087F081C08220F9C0000
+D1DF:000000287F2840287F3840287F2804287FA8000003F802000200020003F80000
+D1E0:000000287F2840287F3840287F2804287FA8000007F8000807F8040007F80000
+D1E1:000000287F2840287F3840287F2804287FA800003EF802083E0820083E080000
+D1E2:000000287F2840287F3840287F2804287FA800003EF802883E8820883EF80000
+D1E3:000000287F2840287F3840287F2804287FA800003E8802883EF820883EF80000
+D1E4:000000287F2840287F3840287F2804287FA800001F0801081F0810141F620000
+D1E5:000000287F2840287F3840287F2804287FA800003EF802803EF820803EF80000
+D1E6:000000287F2840287F3840287F2804287FA800003EFC02483E4820483EFC0000
+D1E7:000000287F2840287F3840287F2804287FA800001F08017F1F1C10221F1C0000
+D1E8:000000287F2840287F3840287F2804287FA8000003F802080208020803F80000
+D1E9:000000287F2840287F3840287F2804287FA800000208020803F8020803F80000
+D1EA:000000287F2840287F3840287F2804287FA80000110811081F0811141F620000
+D1EB:000000287F2840287F3840287F2804287FA80000001000100010006801840000
+D1EC:000000287F2840287F3840287F2804287FA800000048004800A8011406620000
+D1ED:000000287F2840287F3840287F2804287FA80000000003F00408040803F00000
+D1EE:000000287F2840287F3840287F2804287FA8000003F80020002000D003080000
+D1EF:000000287F2840287F3840287F2804287FA80000004003F8004000A003180000
+D1F0:000000287F2840287F3840287F2804287FA8000003F8000803F8000800080000
+D1F1:000000287F2840287F3840287F2804287FA8000003F8020003F8020003F80000
+D1F2:000000287F2840287F3840287F2804287FA8000000000FF8022002200FF80000
+D1F3:000000287F2840287F3840287F2804287FA8000000800FF803E0041003E00000
+D1F4:000000083FC8200820083FC8200820083FC80008040804087FE8000800080000
+D1F5:000000087F0840087F0840087F0804087FE8000007F800080008000800080000
+D1F6:000000087F0840087F0840087F0804087FE8000000003EF80208020802080000
+D1F7:000000087F0840087F0840087F0804087FE8000000001F080108011401620000
+D1F8:000000087F0840087F0840087F0804087FE8000008000800080008000FF80000
+D1F9:000000087F0840087F0840087F0804087FE80000000010F8101010301ECC0000
+D1FA:000000087F0840087F0840087F0804087FE800000808087F081C08220F9C0000
+D1FB:000000087F0840087F0840087F0804087FE8000003F802000200020003F80000
+D1FC:000000087F0840087F0840087F0804087FE8000007F8000807F8040007F80000
+D1FD:000000087F0840087F0840087F0804087FE800003EF802083E0820083E080000
+D1FE:000000087F0840087F0840087F0804087FE800003EF802883E8820883EF80000
+D1FF:000000087F0840087F0840087F0804087FE800003E8802883EF820883EF80000
+D200:000000087F0840087F0840087F0804087FE800001F0801081F0810141F620000
+D201:000000087F0840087F0840087F0804087FE800003EF802803EF820803EF80000
+D202:000000087F0840087F0840087F0804087FE800003EFC02483E4820483EFC0000
+D203:000000087F0840087F0840087F0804087FE800001F08017F1F1C10221F1C0000
+D204:000000087F0840087F0840087F0804087FE8000003F802080208020803F80000
+D205:000000087F0840087F0840087F0804087FE800000208020803F8020803F80000
+D206:000000087F0840087F0840087F0804087FE80000110811081F0811141F620000
+D207:000000087F0840087F0840087F0804087FE80000001000100010006801840000
+D208:000000087F0840087F0840087F0804087FE800000048004800A8011406620000
+D209:000000087F0840087F0840087F0804087FE80000000003F00408040803F00000
+D20A:000000087F0840087F0840087F0804087FE8000003F80020002000D003080000
+D20B:000000087F0840087F0840087F0804087FE80000004003F8004000A003180000
+D20C:000000087F0840087F0840087F0804087FE8000003F8000803F8000800080000
+D20D:000000087F0840087F0840087F0804087FE8000003F8020003F8020003F80000
+D20E:000000087F0840087F0840087F0804087FE8000000000FF8022002200FF80000
+D20F:000000087F0840087F0840087F0804087FE8000000800FF803E0041003E00000
+D210:00003FF8200020003FF8200020003FF8000004400440044004407FFC00000000
+D211:00001FF010001FF010001FF0044004407FFC00001FF000100010001000100000
+D212:00001FF010001FF010001FF0044004407FFC000000003EF80208020802080000
+D213:00001FF010001FF010001FF0044004407FFC000000001E100210022802C40000
+D214:00001FF010001FF010001FF0044004407FFC000000001000100010001FF00000
+D215:00001FF010001FF010001FF0044004407FFC0000000020F8201020303ECC0000
+D216:00001FF010001FF010001FF0044004407FFC0000202021FC207020883E700000
+D217:00001FF010001FF010001FF0044004407FFC00001FF01000100010001FF00000
+D218:00001FF010001FF010001FF0044004407FFC00001FF000101FF010001FF00000
+D219:00001FF010001FF010001FF0044004407FFC00003EF802083E0820083E080000
+D21A:00001FF010001FF010001FF0044004407FFC00003EF802883E8820883EF80000
+D21B:00001FF010001FF010001FF0044004407FFC00003E8802883EF820883EF80000
+D21C:00001FF010001FF010001FF0044004407FFC00003E1002103E1020283EC40000
+D21D:00001FF010001FF010001FF0044004407FFC00003EF802803EF820803EF80000
+D21E:00001FF010001FF010001FF0044004407FFC00003EFC02483E4820483EFC0000
+D21F:00001FF010001FF010001FF0044004407FFC00003E2003FC3E7020883E700000
+D220:00001FF010001FF010001FF0044004407FFC00001FF01010101010101FF00000
+D221:00001FF010001FF010001FF0044004407FFC0000101010101FF010101FF00000
+D222:00001FF010001FF010001FF0044004407FFC0000222022203E2022503E880000
+D223:00001FF010001FF010001FF0044004407FFC000000000100010002800C400000
+D224:00001FF010001FF010001FF0044004407FFC00000000024002400DA033100000
+D225:00001FF010001FF010001FF0044004407FFC0000000007C00820082007C00000
+D226:00001FF010001FF010001FF0044004407FFC0000000007E00080014006200000
+D227:00001FF010001FF010001FF0044004407FFC0000008007E00080014006200000
+D228:00001FF010001FF010001FF0044004407FFC00001FF000101FF0001000100000
+D229:00001FF010001FF010001FF0044004407FFC00001FF010001FF010001FF00000
+D22A:00001FF010001FF010001FF0044004407FFC000000001FF0044004401FF00000
+D22B:00001FF010001FF010001FF0044004407FFC000001001FF007C0082007C00000
+D22C:000000003FF8200020003FF8200020003FF800003FF801000100010001000000
+D22D:00001FF010001FF010001FF000007FFC010001001FF000100010001000100000
+D22E:00001FF010001FF010001FF000007FFC0100010000003EF80208020802080000
+D22F:00001FF010001FF010001FF000007FFC0100010000001E100210022802C40000
+D230:00001FF010001FF010001FF0000000007FFC010001001100100010001FF00000
+D231:00001FF010001FF010001FF000007FFC01000100000020F8201020303ECC0000
+D232:00001FF010001FF010001FF000007FFC01000100202021FC207020883E700000
+D233:00001FF010001FF010001FF000007FFC010001001FF01000100010001FF00000
+D234:00001FF010001FF010001FF000007FFC010001001FF000101FF010001FF00000
+D235:00001FF010001FF010001FF000007FFC010001003EF802083E0820083E080000
+D236:00001FF010001FF010001FF000007FFC010001003EF802883E8820883EF80000
+D237:00001FF010001FF010001FF000007FFC010001003E8802883EF820883EF80000
+D238:00001FF010001FF010001FF000007FFC010001003E1002103E1020283EC40000
+D239:00001FF010001FF010001FF000007FFC010001003EF802803EF820803EF80000
+D23A:00001FF010001FF010001FF000007FFC010001003EFC02483E4820483EFC0000
+D23B:00001FF010001FF010001FF000007FFC010001003E2003FC3E7020883E700000
+D23C:00001FF010001FF010001FF000007FFC010001001FF01010101010101FF00000
+D23D:00001FF010001FF010001FF000007FFC01000100101010101FF010101FF00000
+D23E:00001FF010001FF010001FF000007FFC01000100222022203E2022503E880000
+D23F:00001FF010001FF010001FF000007FFC0100010000000100010002800C400000
+D240:00001FF010001FF010001FF000007FFC010001000000024002400DA033100000
+D241:00001FF010001FF010001FF000007FFC01000100000007C00820082007C00000
+D242:00001FF010001FF010001FF000007FFC01000100000007E00080014006200000
+D243:00001FF010001FF010001FF000007FFC01000100008007E00080014006200000
+D244:00001FF010001FF010001FF000007FFC010001001FF000101FF0001000100000
+D245:00001FF010001FF010001FF000007FFC010001001FF010001FF010001FF00000
+D246:00001FF010001FF010001FF000007FFC0100010000001FF0044004401FF00000
+D247:00001FF010001FF010001FF000007FFC0100010001001FF007C0082007C00000
+D248:000000083FC8200820083FC8200820083FC800087FE8040804F8040804080000
+D249:7F8840087F8840087F8800087FE8027802080000000007F80008000800080000
+D24A:7F8840087F8840087F8800087FE802780208000000003EF80208020802080000
+D24B:7F8840087F8840087F8800087FE802780208000000001F080108011401620000
+D24C:7F8840087F8840087F88000800087FE80278020802081000100010001FF80000
+D24D:7F8840087F8840087F8800087FE8027802080000000020F8201020303ECC0000
+D24E:7F8840087F8840087F8800087FE8027802080000202021FC207020883E700000
+D24F:7F8840087F8840087F8800087FE802780208000003F802000200020003F80000
+D250:7F8840087F8840087F8800087FE802780208000007F8000807F8040007F80000
+D251:7F8840087F8840087F8800087FE80278020800003EF802083E0820083E080000
+D252:7F8840087F8840087F8800087FE80278020800003EF802883E8820883EF80000
+D253:7F8840087F8840087F8800087FE80278020800003E8802883EF820883EF80000
+D254:7F8840087F8840087F8800087FE80278020800000F8800880F8808140FA20000
+D255:7F8840087F8840087F8800087FE80278020800003EF802803EF820803EF80000
+D256:7F8840087F8840087F8800087FE80278020800003EFC02483E4820483EFC0000
+D257:7F8840087F8840087F8800087FE80278020800003E1002FE3E3820443E380000
+D258:7F8840087F8840087F8800087FE802780208000003F802080208020803F80000
+D259:7F8840087F8840087F8800087FE80278020800000208020803F8020803F80000
+D25A:7F8840087F8840087F8800087FE8027802080000210821083F0821143F620000
+D25B:7F8840087F8840087F8800087FE8027802080000001000100010006801840000
+D25C:7F8840087F8840087F8800087FE80278020800000048004800A8011406620000
+D25D:7F8840087F8840087F8800087FE8027802080000000003F00408040803F00000
+D25E:7F8840087F8840087F8800087FE802780208000003F80020002000D003080000
+D25F:7F8840087F8840087F8800087FE8027802080000004003F8004000A003180000
+D260:7F8840087F8840087F8800087FE802780208000003F8000803F8000800080000
+D261:7F8840087F8840087F8800087FE802780208000003F8020003F8020003F80000
+D262:7F8840087F8840087F8800087FE802780208000000000FF8022002200FF80000
+D263:7F8840087F8840087F8800087FE802780208000000800FF803E0041003E00000
+D264:0000000A3FCA200A200A3FCA200A200A3FCA000A7FEA040A047A040A040A0000
+D265:7FA840287FA840287FA800287FA805E804280000000007F80008000800080000
+D266:7FA840287FA840287FA800287FA805E80428000000003EF80208020802080000
+D267:7FA840287FA840287FA800287FA805E80428000000001F080108011401620000
+D268:7FA840287FA840287FA8002800287FA8042805E804281428100010001FF80000
+D269:7FA840287FA840287FA800287FA805E804280000000020F8201020303ECC0000
+D26A:7FA840287FA840287FA800287FA805E804280000202021FC207020883E700000
+D26B:7FA840287FA840287FA800287FA805E80428000003F802000200020003F80000
+D26C:7FA840287FA840287FA800287FA805E80428000007F8000807F8040007F80000
+D26D:7FA840287FA840287FA800287FA805E8042800003EF802083E0820083E080000
+D26E:7FA840287FA840287FA800287FA805E8042800003EF802883E8820883EF80000
+D26F:7FA840287FA840287FA800287FA805E8042800003E8802883EF820883EF80000
+D270:7FA840287FA840287FA800287FA805E8042800000F8800880F8808140FA20000
+D271:7FA840287FA840287FA800287FA805E8042800003EF802803EF820803EF80000
+D272:7FA840287FA840287FA800287FA805E8042800003EFC02483E4820483EFC0000
+D273:7FA840287FA840287FA800287FA805E8042800003E1002FE3E3820443E380000
+D274:7FA840287FA840287FA800287FA805E80428000003F802080208020803F80000
+D275:7FA840287FA840287FA800287FA805E8042800000208020803F8020803F80000
+D276:7FA840287FA840287FA800287FA805E804280000210821083F0821143F620000
+D277:7FA840287FA840287FA800287FA805E804280000001000100010006801840000
+D278:7FA840287FA840287FA800287FA805E8042800000048004800A8011406620000
+D279:7FA840287FA840287FA800287FA805E804280000000003F00408040803F00000
+D27A:7FA840287FA840287FA800287FA805E80428000003F80020002000D003080000
+D27B:7FA840287FA840287FA800287FA805E804280000004003F8004000A003180000
+D27C:7FA840287FA840287FA800287FA805E80428000003F8000803F8000800080000
+D27D:7FA840287FA840287FA800287FA805E80428000003F8020003F8020003F80000
+D27E:7FA840287FA840287FA800287FA805E80428000000000FF8022002200FF80000
+D27F:7FA840287FA840287FA800287FA805E80428000000800FF803E0041003E00000
+D280:000000083FC8200820083FC8200820083FC800087FE804080408040804080000
+D281:7F8840087F8840087F8800087FE8020802000000000007F80008000800080000
+D282:7F8840087F8840087F8800087FE802080200000000003EF80208020802080000
+D283:7F8840087F8840087F8800087FE802080200000000001F080108011401620000
+D284:7F8840087F8840087F88000800087FE80208020802081008100010001FF80000
+D285:7F8840087F8840087F8800087FE8020802000000000020F8201020303ECC0000
+D286:7F8840087F8840087F8800087FE8020802000000202021FC207020883E700000
+D287:7F8840087F8840087F8800087FE802080200000003F802000200020003F80000
+D288:7F8840087F8840087F8800087FE802080200000007F8000807F8040007F80000
+D289:7F8840087F8840087F8800087FE80208020000003EF802083E0820083E080000
+D28A:7F8840087F8840087F8800087FE80208020000003EF802883E8820883EF80000
+D28B:7F8840087F8840087F8800087FE80208020000003E8802883EF820883EF80000
+D28C:7F8840087F8840087F8800087FE80208020000000F8800880F8808140FA20000
+D28D:7F8840087F8840087F8800087FE80208020000003EF802803EF820803EF80000
+D28E:7F8840087F8840087F8800087FE80208020000003EFC02483E4820483EFC0000
+D28F:7F8840087F8840087F8800087FE80208020000003E1002FE3E3820443E380000
+D290:7F8840087F8840087F8800087FE802080200000003F802080208020803F80000
+D291:7F8840087F8840087F8800087FE80208020000000208020803F8020803F80000
+D292:7F8840087F8840087F8800087FE8020802000000210821083F0821143F620000
+D293:7F8840087F8840087F8800087FE8020802000000001000100010006801840000
+D294:7F8840087F8840087F8800087FE80208020000000048004800A8011406620000
+D295:7F8840087F8840087F8800087FE8020802000000000003F00408040803F00000
+D296:7F8840087F8840087F8800087FE802080200000003F80020002000D003080000
+D297:7F8840087F8840087F8800087FE8020802000000004003F8004000A003180000
+D298:7F8840087F8840087F8800087FE802080200000003F8000803F8000800080000
+D299:7F8840087F8840087F8800087FE802080200000003F8020003F8020003F80000
+D29A:7F8840087F8840087F8800087FE802080200000000000FF8022002200FF80000
+D29B:7F8840087F8840087F8800087FE802080200000000800FF803E0041003E00000
+D29C:000000003FF8200020003FF8200020003FF800007FFC04400440044004400000
+D29D:00001FF010001FF010001FF000007FFC044004401FF000100010001000100000
+D29E:00001FF010001FF010001FF000007FFC0440044000003EF80208020802080000
+D29F:00001FF010001FF010001FF000007FFC0440044000001E100210022802C40000
+D2A0:00001FF010001FF010001FF0000000007FFC044004401440100010001FF00000
+D2A1:00001FF010001FF010001FF000007FFC04400440000020F8201020303ECC0000
+D2A2:00001FF010001FF010001FF000007FFC04400440202021FC207020883E700000
+D2A3:00001FF010001FF010001FF000007FFC044004401FF01000100010001FF00000
+D2A4:00001FF010001FF010001FF000007FFC044004401FF000101FF010001FF00000
+D2A5:00001FF010001FF010001FF000007FFC044004403EF802083E0820083E080000
+D2A6:00001FF010001FF010001FF000007FFC044004403EF802883E8820883EF80000
+D2A7:00001FF010001FF010001FF000007FFC044004403E8802883EF820883EF80000
+D2A8:00001FF010001FF010001FF000007FFC044004403E1002103E1020283EC40000
+D2A9:00001FF010001FF010001FF000007FFC044004403EF802803EF820803EF80000
+D2AA:00001FF010001FF010001FF000007FFC044004403EFC02483E4820483EFC0000
+D2AB:00001FF010001FF010001FF000007FFC044004403E2003FC3E7020883E700000
+D2AC:00001FF010001FF010001FF000007FFC044004401FF01010101010101FF00000
+D2AD:00001FF010001FF010001FF000007FFC04400440101010101FF010101FF00000
+D2AE:00001FF010001FF010001FF000007FFC04400440222022203E2022503E880000
+D2AF:00001FF010001FF010001FF000007FFC0440044000000100010002800C400000
+D2B0:00001FF010001FF010001FF000007FFC044004400000024002400DA033100000
+D2B1:00001FF010001FF010001FF000007FFC04400440000007C00820082007C00000
+D2B2:00001FF010001FF010001FF000007FFC04400440000007E00080014006200000
+D2B3:00001FF010001FF010001FF000007FFC04400440008007E00080014006200000
+D2B4:00001FF010001FF010001FF000007FFC044004401FF000101FF0001000100000
+D2B5:00001FF010001FF010001FF000007FFC044004401FF010001FF010001FF00000
+D2B6:00001FF010001FF010001FF000007FFC0440044000001FF0044004401FF00000
+D2B7:00001FF010001FF010001FF000007FFC0440044001001FF007C0082007C00000
+D2B8:00003FF8200020003FF8200020003FF80000000000007FFC0000000000000000
+D2B9:00001FF010001FF010001FF0000000007FFC00001FF000100010001000100000
+D2BA:00001FF010001FF010001FF0000000007FFC000000003EF80208020802080000
+D2BB:00001FF010001FF010001FF0000000007FFC000000001E100210022802C40000
+D2BC:00001FF010001FF010001FF0000000007FFC000000001000100010001FF00000
+D2BD:00001FF010001FF010001FF0000000007FFC0000000020F8201020303ECC0000
+D2BE:00001FF010001FF010001FF0000000007FFC0000202021FC207020883E700000
+D2BF:00001FF010001FF010001FF0000000007FFC00001FF01000100010001FF00000
+D2C0:00001FF010001FF010001FF0000000007FFC00001FF000101FF010001FF00000
+D2C1:00001FF010001FF010001FF0000000007FFC00003EF802083E0820083E080000
+D2C2:00001FF010001FF010001FF0000000007FFC00003EF802883E8820883EF80000
+D2C3:00001FF010001FF010001FF0000000007FFC00003E8802883EF820883EF80000
+D2C4:00001FF010001FF010001FF0000000007FFC00003E1002103E1020283EC40000
+D2C5:00001FF010001FF010001FF0000000007FFC00003EF802803EF820803EF80000
+D2C6:00001FF010001FF010001FF0000000007FFC00003EFC02483E4820483EFC0000
+D2C7:00001FF010001FF010001FF0000000007FFC00003E2003FC3E7020883E700000
+D2C8:00001FF010001FF010001FF0000000007FFC00001FF01010101010101FF00000
+D2C9:00001FF010001FF010001FF0000000007FFC0000101010101FF010101FF00000
+D2CA:00001FF010001FF010001FF0000000007FFC0000222022203E2022503E880000
+D2CB:00001FF010001FF010001FF0000000007FFC000000000100010002800C400000
+D2CC:00001FF010001FF010001FF0000000007FFC00000000024002400DA033100000
+D2CD:00001FF010001FF010001FF0000000007FFC0000000007C00820082007C00000
+D2CE:00001FF010001FF010001FF0000000007FFC0000000007E00080014006200000
+D2CF:00001FF010001FF010001FF0000000007FFC0000008007E00080014006200000
+D2D0:00001FF010001FF010001FF0000000007FFC00001FF000101FF0001000100000
+D2D1:00001FF010001FF010001FF0000000007FFC00001FF010001FF010001FF00000
+D2D2:00001FF010001FF010001FF0000000007FFC000000001FF0044004401FF00000
+D2D3:00001FF010001FF010001FF0000000007FFC000001001FF007C0082007C00000
+D2D4:000000083FC8200820083FC8200820083FC8000800087FE80008000800080000
+D2D5:000000087F0840087F0840087F0800087FE8000007F800080008000800080000
+D2D6:000000087F0840087F0840087F0800087FE8000000003EF80208020802080000
+D2D7:000000087F0840087F0840087F0800087FE8000000001F080108011401620000
+D2D8:000000087F0840087F0840087F0800087FE8000008000800080008000FF80000
+D2D9:000000087F0840087F0840087F0800087FE80000000010F8101010301ECC0000
+D2DA:000000087F0840087F0840087F0800087FE800000808087F081C08220F9C0000
+D2DB:000000087F0840087F0840087F0800087FE8000003F802000200020003F80000
+D2DC:000000087F0840087F0840087F0800087FE8000007F8000807F8040007F80000
+D2DD:000000087F0840087F0840087F0800087FE800003EF802083E0820083E080000
+D2DE:000000087F0840087F0840087F0800087FE800003EF802883E8820883EF80000
+D2DF:000000087F0840087F0840087F0800087FE800003E8802883EF820883EF80000
+D2E0:000000087F0840087F0840087F0800087FE800001F0801081F0810141F620000
+D2E1:000000087F0840087F0840087F0800087FE800003EF802803EF820803EF80000
+D2E2:000000087F0840087F0840087F0800087FE800003EFC02483E4820483EFC0000
+D2E3:000000087F0840087F0840087F0800087FE800001F08017F1F1C10221F1C0000
+D2E4:000000087F0840087F0840087F0800087FE8000003F802080208020803F80000
+D2E5:000000087F0840087F0840087F0800087FE800000208020803F8020803F80000
+D2E6:000000087F0840087F0840087F0800087FE80000110811081F0811141F620000
+D2E7:000000087F0840087F0840087F0800087FE80000001000100010006801840000
+D2E8:000000087F0840087F0840087F0800087FE800000048004800A8011406620000
+D2E9:000000087F0840087F0840087F0800087FE80000000003F00408040803F00000
+D2EA:000000087F0840087F0840087F0800087FE8000003F80020002000D003080000
+D2EB:000000087F0840087F0840087F0800087FE80000004003F8004000A003180000
+D2EC:000000087F0840087F0840087F0800087FE8000003F8000803F8000800080000
+D2ED:000000087F0840087F0840087F0800087FE8000003F8020003F8020003F80000
+D2EE:000000087F0840087F0840087F0800087FE8000000000FF8022002200FF80000
+D2EF:000000087F0840087F0840087F0800087FE8000000800FF803E0041003E00000
+D2F0:00000000000800083F88200820083F88200820083F8800080008000800080000
+D2F1:0000000800087E0840087E0840087E0800080000000007F80008000800080000
+D2F2:0000000800087E0840087E0840087E080008000000003EF80208020802080000
+D2F3:0000000800087E0840087E0840087E080008000000001F080108011401620000
+D2F4:0000000800087E0840087E0840087E080008000800001000100010001FF80000
+D2F5:0000000800087E0840087E0840087E0800080000000020F8201020303ECC0000
+D2F6:0000000800087E0840087E0840087E0800080000202021FC207020883E700000
+D2F7:0000000800087E0840087E0840087E080008000003F802000200020003F80000
+D2F8:0000000800087E0840087E0840087E080008000007F8000807F8040007F80000
+D2F9:0000000800087E0840087E0840087E08000800003EF802083E0820083E080000
+D2FA:0000000800087E0840087E0840087E08000800003EF802883E8820883EF80000
+D2FB:0000000800087E0840087E0840087E08000800003E8802883EF820883EF80000
+D2FC:0000000800087E0840087E0840087E08000800000F8800880F8808140FA20000
+D2FD:0000000800087E0840087E0840087E08000800003EF802803EF820803EF80000
+D2FE:0000000800087E0840087E0840087E08000800003EFC02483E4820483EFC0000
+D2FF:0000000800087E0840087E0840087E08000800003E1002FE3E3820443E380000
+D300:0000000800087E0840087E0840087E080008000003F802080208020803F80000
+D301:0000000800087E0840087E0840087E08000800000208020803F8020803F80000
+D302:0000000800087E0840087E0840087E0800080000210821083F0821143F620000
+D303:0000000800087E0840087E0840087E0800080000001000100010006801840000
+D304:0000000800087E0840087E0840087E08000800000048004800A8011406620000
+D305:0000000800087E0840087E0840087E0800080000000003F00408040803F00000
+D306:0000000800087E0840087E0840087E080008000003F80020002000D003080000
+D307:0000000800087E0840087E0840087E0800080000004003F8004000A003180000
+D308:0000000800087E0840087E0840087E080008000003F8000803F8000800080000
+D309:0000000800087E0840087E0840087E080008000003F8020003F8020003F80000
+D30A:0000000800087E0840087E0840087E080008000000000FF8022002200FF80000
+D30B:0000000800087E0840087E0840087E080008000000800FF803E0041003E00000
+D30C:00000000001000107FD011101110111E111011107FD000100010001000100000
+D30D:0000000800087F881208120E12087F880008000007F800080008000800080000
+D30E:0000000800087F881208120E12087F880008000000003EF80208020802080000
+D30F:0000000800087F881208120E12087F880008000000001F080108011401620000
+D310:0000000800087F881208120E12087F880008000808000800080008000FF80000
+D311:0000000800087F881208120E12087F8800080000000010F8101010301ECC0000
+D312:0000000800087F881208120E12087F88000800000808087F081C08220F9C0000
+D313:0000000800087F881208120E12087F880008000003F802000200020003F80000
+D314:0000000800087F881208120E12087F880008000007F8000807F8040007F80000
+D315:0000000800087F881208120E12087F88000800003EF802083E0820083E080000
+D316:0000000800087F881208120E12087F88000800003EF802883E8820883EF80000
+D317:0000000800087F881208120E12087F88000800003E8802883EF820883EF80000
+D318:0000000800087F881208120E12087F88000800001F0801081F0810141F620000
+D319:0000000800087F881208120E12087F88000800003EF802803EF820803EF80000
+D31A:0000000800087F881208120E12087F88000800003EFC02483E4820483EFC0000
+D31B:0000000800087F881208120E12087F88000800001F08017F1F1C10221F1C0000
+D31C:0000000800087F881208120E12087F880008000003F802080208020803F80000
+D31D:0000000800087F881208120E12087F88000800000208020803F8020803F80000
+D31E:0000000800087F881208120E12087F8800080000110811081F0811141F620000
+D31F:0000000800087F881208120E12087F8800080000001000100010006801840000
+D320:0000000800087F881208120E12087F88000800000048004800A8011406620000
+D321:0000000800087F881208120E12087F8800080000000003F00408040803F00000
+D322:0000000800087F881208120E12087F880008000003F80020002000D003080000
+D323:0000000800087F881208120E12087F8800080000004003F8004000A003180000
+D324:0000000800087F881208120E12087F880008000003F8000803F8000800080000
+D325:0000000800087F881208120E12087F880008000003F8020003F8020003F80000
+D326:0000000800087F881208120E12087F880008000000000FF8022002200FF80000
+D327:0000000800087F881208120E12087F880008000000800FF803E0041003E00000
+D328:00000000001200127FD211121112111E111211127FD200120012001200120000
+D329:0000002800287FA81228123812287FA80028000007F800080008000800080000
+D32A:0000002800287FA81228123812287FA80028000000003EF80208020802080000
+D32B:0000002800287FA81228123812287FA80028000000003E100210022802C40000
+D32C:0000002800287FA81228123812287FA80028002808000800080008000FF80000
+D32D:0000002800287FA81228123812287FA800280000000020F8201020303ECC0000
+D32E:0000002800287FA81228123812287FA800280000202021FC207020883E700000
+D32F:0000002800287FA81228123812287FA80028000003F802000200020003F80000
+D330:0000002800287FA81228123812287FA80028000007F8000807F8040007F80000
+D331:0000002800287FA81228123812287FA8002800003EF802083E0820083E080000
+D332:0000002800287FA81228123812287FA8002800003EF802883E8820883EF80000
+D333:0000002800287FA81228123812287FA8002800003E8802883EF820883EF80000
+D334:0000002800287FA81228123812287FA8002800001F0801081F0810141F620000
+D335:0000002800287FA81228123812287FA8002800003EF802803EF820803EF80000
+D336:0000002800287FA81228123812287FA8002800003EFC02483E4820483EFC0000
+D337:0000002800287FA81228123812287FA8002800003E1002FE3E3820443E380000
+D338:0000002800287FA81228123812287FA80028000003F802080208020803F80000
+D339:0000002800287FA81228123812287FA8002800000208020803F8020803F80000
+D33A:0000002800287FA81228123812287FA800280000110811081F0811141F620000
+D33B:0000002800287FA81228123812287FA800280000000800080008003400C20000
+D33C:0000002800287FA81228123812287FA8002800000048004800A8011406620000
+D33D:0000002800287FA81228123812287FA800280000000001F00208020801F00000
+D33E:0000002800287FA81228123812287FA80028000003F80020002000D003080000
+D33F:0000002800287FA81228123812287FA800280000004003F8004000A003180000
+D340:0000002800287FA81228123812287FA80028000003F8000803F8000800080000
+D341:0000002800287FA81228123812287FA80028000003F8020003F8020003F80000
+D342:0000002800287FA81228123812287FA80028000000000FF8022002200FF80000
+D343:0000002800287FA81228123812287FA80028000000800FF803E0041003E00000
+D344:00000000001000107FD01110111E11101110111E7FD000100010001000100000
+D345:0000000800087F88120E1208120E7F880008000007F800080008000800080000
+D346:0000000800087F88120E1208120E7F880008000000003EF80208020802080000
+D347:0000000800087F88120E1208120E7F880008000000001F080108011401620000
+D348:0000000800087F88120E1208120E7F880008000008000800080008000FF80000
+D349:0000000800087F88120E1208120E7F8800080000000010F8101010301ECC0000
+D34A:0000000800087F88120E1208120E7F88000800000808087F081C08220F9C0000
+D34B:0000000800087F88120E1208120E7F880008000003F802000200020003F80000
+D34C:0000000800087F88120E1208120E7F880008000007F8000807F8040007F80000
+D34D:0000000800087F88120E1208120E7F88000800003EF802083E0820083E080000
+D34E:0000000800087F88120E1208120E7F88000800003EF802883E8820883EF80000
+D34F:0000000800087F88120E1208120E7F88000800003E8802883EF820883EF80000
+D350:0000000800087F88120E1208120E7F88000800001F0801081F0810141F620000
+D351:0000000800087F88120E1208120E7F88000800003EF802803EF820803EF80000
+D352:0000000800087F88120E1208120E7F88000800003EFC02483E4820483EFC0000
+D353:0000000800087F88120E1208120E7F88000800001F08017F1F1C10221F1C0000
+D354:0000000800087F88120E1208120E7F880008000003F802080208020803F80000
+D355:0000000800087F88120E1208120E7F88000800000208020803F8020803F80000
+D356:0000000800087F88120E1208120E7F8800080000110811081F0811141F620000
+D357:0000000800087F88120E1208120E7F8800080000001000100010006801840000
+D358:0000000800087F88120E1208120E7F88000800000048004800A8011406620000
+D359:0000000800087F88120E1208120E7F8800080000000003F00408040803F00000
+D35A:0000000800087F88120E1208120E7F880008000003F80020002000D003080000
+D35B:0000000800087F88120E1208120E7F8800080000004003F8004000A003180000
+D35C:0000000800087F88120E1208120E7F880008000003F8000803F8000800080000
+D35D:0000000800087F88120E1208120E7F880008000003F8020003F8020003F80000
+D35E:0000000800087F88120E1208120E7F880008000000000FF8022002200FF80000
+D35F:0000000800087F88120E1208120E7F880008000000800FF803E0041003E00000
+D360:00000000001200127FD21112111E11121112111E7FD200120012001200120000
+D361:0000002800287FA81238122812387FA80028000007F800080008000800080000
+D362:0000002800287FA81238122812387FA80028000000003EF80208020802080000
+D363:0000002800287FA81238122812387FA80028000000003E100210022802C40000
+D364:0000002800287FA81238122812387FA80028002808000800080008000FF80000
+D365:0000002800287FA81238122812387FA800280000000020F8201020303ECC0000
+D366:0000002800287FA81238122812387FA800280000202021FC207020883E700000
+D367:0000002800287FA81238122812387FA80028000003F802000200020003F80000
+D368:0000002800287FA81238122812387FA80028000007F8000807F8040007F80000
+D369:0000002800287FA81238122812387FA8002800003EF802083E0820083E080000
+D36A:0000002800287FA81238122812387FA8002800003EF802883E8820883EF80000
+D36B:0000002800287FA81238122812387FA8002800003E8802883EF820883EF80000
+D36C:0000002800287FA81238122812387FA8002800001F0801081F0810141F620000
+D36D:0000002800287FA81238122812387FA8002800003EF802803EF820803EF80000
+D36E:0000002800287FA81238122812387FA8002800003EFC02483E4820483EFC0000
+D36F:0000002800287FA81238122812387FA8002800003E1002FE3E3820443E380000
+D370:0000002800287FA81238122812387FA80028000003F802080208020803F80000
+D371:0000002800287FA81238122812387FA8002800000208020803F8020803F80000
+D372:0000002800287FA81238122812387FA800280000110811081F0811141F620000
+D373:0000002800287FA81238122812387FA800280000000800080008003400C20000
+D374:0000002800287FA81238122812387FA8002800000048004800A8011406620000
+D375:0000002800287FA81238122812387FA800280000000001F00208020801F00000
+D376:0000002800287FA81238122812387FA80028000003F80020002000D003080000
+D377:0000002800287FA81238122812387FA800280000004003F8004000A003180000
+D378:0000002800287FA81238122812387FA80028000003F8000803F8000800080000
+D379:0000002800287FA81238122812387FA80028000003F8020003F8020003F80000
+D37A:0000002800287FA81238122812387FA80028000000000FF8022002200FF80000
+D37B:0000002800287FA81238122812387FA80028000000800FF803E0041003E00000
+D37C:00000000000200027FC211021102111E110211027FC200020002000200020000
+D37D:0000000800087F881208123812087F8800080000000007F80008000800080000
+D37E:0000000800087F881208123812087F880008000000003EF80208020802080000
+D37F:0000000800087F881208123812087F880008000000001F080108011401620000
+D380:0000000800087F881208123812087F880008000000001000100010001FF80000
+D381:0000000800087F881208123812087F8800080000000020F8201020303ECC0000
+D382:0000000800087F881208123812087F8800080000202021FC207020883E700000
+D383:0000000800087F881208123812087F880008000003F802000200020003F80000
+D384:0000000800087F881208123812087F880008000007F8000807F8040007F80000
+D385:0000000800087F881208123812087F88000800003EF802083E0820083E080000
+D386:0000000800087F881208123812087F88000800003EF802883E8820883EF80000
+D387:0000000800087F881208123812087F88000800003E8802883EF820883EF80000
+D388:0000000800087F881208123812087F88000800000F8800880F8808140FA20000
+D389:0000000800087F881208123812087F88000800003EF802803EF820803EF80000
+D38A:0000000800087F881208123812087F88000800003EFC02483E4820483EFC0000
+D38B:0000000800087F881208123812087F88000800003E1002FE3E3820443E380000
+D38C:0000000800087F881208123812087F880008000003F802080208020803F80000
+D38D:0000000800087F881208123812087F88000800000208020803F8020803F80000
+D38E:0000000800087F881208123812087F8800080000210821083F0821143F620000
+D38F:0000000800087F881208123812087F8800080000001000100010006801840000
+D390:0000000800087F881208123812087F88000800000048004800A8011406620000
+D391:0000000800087F881208123812087F8800080000000003F00408040803F00000
+D392:0000000800087F881208123812087F880008000003F80020002000D003080000
+D393:0000000800087F881208123812087F8800080000004003F8004000A003180000
+D394:0000000800087F881208123812087F880008000003F8000803F8000800080000
+D395:0000000800087F881208123812087F880008000003F8020003F8020003F80000
+D396:0000000800087F881208123812087F880008000000000FF8022002200FF80000
+D397:0000000800087F881208123812087F880008000000800FF803E0041003E00000
+D398:00000000000A000A7FCA110A110A113A110A110A7FCA000A000A000A000A0000
+D399:0000002800287FA8122812E812287FA80028000007F800080008000800080000
+D39A:0000002800287FA8122812E812287FA80028000000003EF80208020802080000
+D39B:0000002800287FA8122812E812287FA80028000000003E100210022802C40000
+D39C:0000002800287FA8122812E812287FA80028000008000800080008000FF80000
+D39D:0000002800287FA8122812E812287FA800280000000020F8201020303ECC0000
+D39E:0000002800287FA8122812E812287FA800280000202021FC207020883E700000
+D39F:0000002800287FA8122812E812287FA80028000003F802000200020003F80000
+D3A0:0000002800287FA8122812E812287FA80028000007F8000807F8040007F80000
+D3A1:0000002800287FA8122812E812287FA8002800003EF802083E0820083E080000
+D3A2:0000002800287FA8122812E812287FA8002800003EF802883E8820883EF80000
+D3A3:0000002800287FA8122812E812287FA8002800003E8802883EF820883EF80000
+D3A4:0000002800287FA8122812E812287FA8002800001F0801081F0810141F620000
+D3A5:0000002800287FA8122812E812287FA8002800003EF802803EF820803EF80000
+D3A6:0000002800287FA8122812E812287FA8002800003EFC02483E4820483EFC0000
+D3A7:0000002800287FA8122812E812287FA8002800003E1002FE3E3820443E380000
+D3A8:0000002800287FA8122812E812287FA80028000003F802080208020803F80000
+D3A9:0000002800287FA8122812E812287FA8002800000208020803F8020803F80000
+D3AA:0000002800287FA8122812E812287FA800280000110811081F0811141F620000
+D3AB:0000002800287FA8122812E812287FA800280000000800080008003400C20000
+D3AC:0000002800287FA8122812E812287FA8002800000048004800A8011406620000
+D3AD:0000002800287FA8122812E812287FA800280000000001F00208020801F00000
+D3AE:0000002800287FA8122812E812287FA80028000003F80020002000D003080000
+D3AF:0000002800287FA8122812E812287FA800280000004003F8004000A003180000
+D3B0:0000002800287FA8122812E812287FA80028000003F8000803F8000800080000
+D3B1:0000002800287FA8122812E812287FA80028000003F8020003F8020003F80000
+D3B2:0000002800287FA8122812E812287FA80028000000000FF8022002200FF80000
+D3B3:0000002800287FA8122812E812287FA80028000000800FF803E0041003E00000
+D3B4:00000000000200027FC21102111E11021102111E7FC200020002000200020000
+D3B5:0000000800087F881238120812387F8800080000000007F80008000800080000
+D3B6:0000000800087F881238120812387F880008000000003EF80208020802080000
+D3B7:0000000800087F881238120812387F880008000000001F080108011401620000
+D3B8:0000000800087F881238120812387F880008000800001000100010001FF80000
+D3B9:0000000800087F881238120812387F8800080000000020F8201020303ECC0000
+D3BA:0000000800087F881238120812387F8800080000202021FC207020883E700000
+D3BB:0000000800087F881238120812387F880008000003F802000200020003F80000
+D3BC:0000000800087F881238120812387F880008000007F8000807F8040007F80000
+D3BD:0000000800087F881238120812387F88000800003EF802083E0820083E080000
+D3BE:0000000800087F881238120812387F88000800003EF802883E8820883EF80000
+D3BF:0000000800087F881238120812387F88000800003E8802883EF820883EF80000
+D3C0:0000000800087F881238120812387F88000800000F8800880F8808140FA20000
+D3C1:0000000800087F881238120812387F88000800003EF802803EF820803EF80000
+D3C2:0000000800087F881238120812387F88000800003EFC02483E4820483EFC0000
+D3C3:0000000800087F881238120812387F88000800003E1002FE3E3820443E380000
+D3C4:0000000800087F881238120812387F880008000003F802080208020803F80000
+D3C5:0000000800087F881238120812387F88000800000208020803F8020803F80000
+D3C6:0000000800087F881238120812387F8800080000210821083F0821143F620000
+D3C7:0000000800087F881238120812387F8800080000001000100010006801840000
+D3C8:0000000800087F881238120812387F88000800000048004800A8011406620000
+D3C9:0000000800087F881238120812387F8800080000000003F00408040803F00000
+D3CA:0000000800087F881238120812387F880008000003F80020002000D003080000
+D3CB:0000000800087F881238120812387F8800080000004003F8004000A003180000
+D3CC:0000000800087F881238120812387F880008000003F8000803F8000800080000
+D3CD:0000000800087F881238120812387F880008000003F8020003F8020003F80000
+D3CE:0000000800087F881238120812387F880008000000000FF8022002200FF80000
+D3CF:0000000800087F881238120812387F880008000000800FF803E0041003E00000
+D3D0:00000000000A000A7FCA110A113A110A110A113A7FCA000A000A000A000A0000
+D3D1:0000002800287FA812E8122812E87FA80028000007F800080008000800080000
+D3D2:0000002800287FA812E8122812E87FA80028000000003EF80208020802080000
+D3D3:0000002800287FA812E8122812E87FA80028000000003E100210022802C40000
+D3D4:0000002800287FA812E8122812E87FA80028002808000800080008000FF80000
+D3D5:0000002800287FA812E8122812E87FA800280000000020F8201020303ECC0000
+D3D6:0000002800287FA812E8122812E87FA800280000202021FC207020883E700000
+D3D7:0000002800287FA812E8122812E87FA80028000003F802000200020003F80000
+D3D8:0000002800287FA812E8122812E87FA80028000007F8000807F8040007F80000
+D3D9:0000002800287FA812E8122812E87FA8002800003EF802083E0820083E080000
+D3DA:0000002800287FA812E8122812E87FA8002800003EF802883E8820883EF80000
+D3DB:0000002800287FA812E8122812E87FA8002800003E8802883EF820883EF80000
+D3DC:0000002800287FA812E8122812E87FA8002800001F0801081F0810141F620000
+D3DD:0000002800287FA812E8122812E87FA8002800003EF802803EF820803EF80000
+D3DE:0000002800287FA812E8122812E87FA8002800003EFC02483E4820483EFC0000
+D3DF:0000002800287FA812E8122812E87FA8002800003E1002FE3E3820443E380000
+D3E0:0000002800287FA812E8122812E87FA80028000003F802080208020803F80000
+D3E1:0000002800287FA812E8122812E87FA8002800000208020803F8020803F80000
+D3E2:0000002800287FA812E8122812E87FA800280000110811081F0811141F620000
+D3E3:0000002800287FA812E8122812E87FA800280000000800080008003400C20000
+D3E4:0000002800287FA812E8122812E87FA8002800000048004800A8011406620000
+D3E5:0000002800287FA812E8122812E87FA800280000000001F00208020801F00000
+D3E6:0000002800287FA812E8122812E87FA80028000003F80020002000D003080000
+D3E7:0000002800287FA812E8122812E87FA800280000004003F8004000A003180000
+D3E8:0000002800287FA812E8122812E87FA80028000003F8000803F8000800080000
+D3E9:0000002800287FA812E8122812E87FA80028000003F8020003F8020003F80000
+D3EA:0000002800287FA812E8122812E87FA80028000000000FF8022002200FF80000
+D3EB:0000002800287FA812E8122812E87FA80028000000800FF803E0041003E00000
+D3EC:000000003FF808200820082008203FF8000000000100010001007FFC00000000
+D3ED:00001FF00440044004401FF0010001007FFC00001FF000100010001000100000
+D3EE:00001FF00440044004401FF0010001007FFC000000003EF80208020802080000
+D3EF:00001FF00440044004401FF0010001007FFC000000001E100210022802C40000
+D3F0:00001FF00440044004401FF0010001007FFC000000001000100010001FF00000
+D3F1:00001FF00440044004401FF0010001007FFC0000000020F8201020303ECC0000
+D3F2:00001FF00440044004401FF0010001007FFC0000202021FC207020883E700000
+D3F3:00001FF00440044004401FF0010001007FFC00001FF01000100010001FF00000
+D3F4:00001FF00440044004401FF0010001007FFC00001FF000101FF010001FF00000
+D3F5:00001FF00440044004401FF0010001007FFC00003EF802083E0820083E080000
+D3F6:00001FF00440044004401FF0010001007FFC00003EF802883E8820883EF80000
+D3F7:00001FF00440044004401FF0010001007FFC00003E8802883EF820883EF80000
+D3F8:00001FF00440044004401FF0010001007FFC00003E1002103E1020283EC40000
+D3F9:00001FF00440044004401FF0010001007FFC00003EF802803EF820803EF80000
+D3FA:00001FF00440044004401FF0010001007FFC00003EFC02483E4820483EFC0000
+D3FB:00001FF00440044004401FF0010001007FFC00003E2003FC3E7020883E700000
+D3FC:00001FF00440044004401FF0010001007FFC00001FF01010101010101FF00000
+D3FD:00001FF00440044004401FF0010001007FFC0000101010101FF010101FF00000
+D3FE:00001FF00440044004401FF0010001007FFC0000222022203E2022503E880000
+D3FF:00001FF00440044004401FF0010001007FFC000000000100010002800C400000
+D400:00001FF00440044004401FF0010001007FFC00000000024002400DA033100000
+D401:00001FF00440044004401FF0010001007FFC0000000007C00820082007C00000
+D402:00001FF00440044004401FF0010001007FFC0000000007E00080014006200000
+D403:00001FF00440044004401FF0010001007FFC0000008007E00080014006200000
+D404:00001FF00440044004401FF0010001007FFC00001FF000101FF0001000100000
+D405:00001FF00440044004401FF0010001007FFC00001FF010001FF010001FF00000
+D406:00001FF00440044004401FF0010001007FFC000000001FF0044004401FF00000
+D407:00001FF00440044004401FF0010001007FFC000001001FF007C0082007C00000
+D408:00000010001000107FD011101110111E11107FD0041004107FD0001000100000
+D409:000000083F881108110E3F88040804087FE8000007F800080008000800080000
+D40A:000000083F881108110E3F88040804087FE8000000003EF80208020802080000
+D40B:000000083F881108110E3F88040804087FE8000000001F080108011401620000
+D40C:000000083F881108110E3F88040804087FE8000008000800080008000FF80000
+D40D:000000083F881108110E3F88040804087FE80000000010F8101010301ECC0000
+D40E:000000083F881108110E3F88040804087FE800000808087F081C08220F9C0000
+D40F:000000083F881108110E3F88040804087FE8000003F802000200020003F80000
+D410:000000083F881108110E3F88040804087FE8000007F8000807F8040007F80000
+D411:000000083F881108110E3F88040804087FE800003EF802083E0820083E080000
+D412:000000083F881108110E3F88040804087FE800003EF802883E8820883EF80000
+D413:000000083F881108110E3F88040804087FE800003E8802883EF820883EF80000
+D414:000000083F881108110E3F88040804087FE800001F0801081F0810141F620000
+D415:000000083F881108110E3F88040804087FE800003EF802803EF820803EF80000
+D416:000000083F881108110E3F88040804087FE800003EFC02483E4820483EFC0000
+D417:000000083F881108110E3F88040804087FE800001F08017F1F1C10221F1C0000
+D418:000000083F881108110E3F88040804087FE8000003F802080208020803F80000
+D419:000000083F881108110E3F88040804087FE800000208020803F8020803F80000
+D41A:000000083F881108110E3F88040804087FE80000110811081F0811141F620000
+D41B:000000083F881108110E3F88040804087FE80000001000100010006801840000
+D41C:000000083F881108110E3F88040804087FE800000048004800A8011406620000
+D41D:000000083F881108110E3F88040804087FE80000000003F00408040803F00000
+D41E:000000083F881108110E3F88040804087FE8000003F80020002000D003080000
+D41F:000000083F881108110E3F88040804087FE80000004003F8004000A003180000
+D420:000000083F881108110E3F88040804087FE8000003F8000803F8000800080000
+D421:000000083F881108110E3F88040804087FE8000003F8020003F8020003F80000
+D422:000000083F881108110E3F88040804087FE8000000000FF8022002200FF80000
+D423:000000083F881108110E3F88040804087FE8000000800FF803E0041003E00000
+D424:00000012001200127FD211121112111E11127FD2041204127FD2001200120000
+D425:000000283FA8112811383FA8042804287FA8000007F800080008000800080000
+D426:000000283FA8112811383FA8042804287FA8000000003EF80208020802080000
+D427:000000283FA8112811383FA8042804287FA8000000001F080108011401620000
+D428:000000283FA8112811383FA8042804287FA8000008000800080008000FF80000
+D429:000000283FA8112811383FA8042804287FA80000000010F8101010301ECC0000
+D42A:000000283FA8112811383FA8042804287FA800000808087F081C08220F9C0000
+D42B:000000283FA8112811383FA8042804287FA8000003F802000200020003F80000
+D42C:000000283FA8112811383FA8042804287FA8000007F8000807F8040007F80000
+D42D:000000283FA8112811383FA8042804287FA800003EF802083E0820083E080000
+D42E:000000283FA8112811383FA8042804287FA800003EF802883E8820883EF80000
+D42F:000000283FA8112811383FA8042804287FA800003E8802883EF820883EF80000
+D430:000000283FA8112811383FA8042804287FA800001F0801081F0810141F620000
+D431:000000283FA8112811383FA8042804287FA800003EF802803EF820803EF80000
+D432:000000283FA8112811383FA8042804287FA800003EFC02483E4820483EFC0000
+D433:000000283FA8112811383FA8042804287FA800001F08017F1F1C10221F1C0000
+D434:000000283FA8112811383FA8042804287FA8000003F802080208020803F80000
+D435:000000283FA8112811383FA8042804287FA800000208020803F8020803F80000
+D436:000000283FA8112811383FA8042804287FA80000110811081F0811141F620000
+D437:000000283FA8112811383FA8042804287FA80000001000100010006801840000
+D438:000000283FA8112811383FA8042804287FA800000048004800A8011406620000
+D439:000000283FA8112811383FA8042804287FA80000000003F00408040803F00000
+D43A:000000283FA8112811383FA8042804287FA8000003F80020002000D003080000
+D43B:000000283FA8112811383FA8042804287FA80000004003F8004000A003180000
+D43C:000000283FA8112811383FA8042804287FA8000003F8000803F8000800080000
+D43D:000000283FA8112811383FA8042804287FA8000003F8020003F8020003F80000
+D43E:000000283FA8112811383FA8042804287FA8000000000FF8022002200FF80000
+D43F:000000283FA8112811383FA8042804287FA8000000800FF803E0041003E00000
+D440:00000008000800087FC811081108110811087FC8040804087FE8000800080000
+D441:000000083F88110811083F88040804087FE8000007F800080008000800080000
+D442:000000083F88110811083F88040804087FE8000000003EF80208020802080000
+D443:000000083F88110811083F88040804087FE8000000001F080108011401620000
+D444:000000083F88110811083F88040804087FE8000008000800080008000FF80000
+D445:000000083F88110811083F88040804087FE80000000010F8101010301ECC0000
+D446:000000083F88110811083F88040804087FE800000808087F081C08220F9C0000
+D447:000000083F88110811083F88040804087FE8000003F802000200020003F80000
+D448:000000083F88110811083F88040804087FE8000007F8000807F8040007F80000
+D449:000000083F88110811083F88040804087FE800003EF802083E0820083E080000
+D44A:000000083F88110811083F88040804087FE800003EF802883E8820883EF80000
+D44B:000000083F88110811083F88040804087FE800003E8802883EF820883EF80000
+D44C:000000083F88110811083F88040804087FE800001F0801081F0810141F620000
+D44D:000000083F88110811083F88040804087FE800003EF802803EF820803EF80000
+D44E:000000083F88110811083F88040804087FE800003EFC02483E4820483EFC0000
+D44F:000000083F88110811083F88040804087FE800001F08017F1F1C10221F1C0000
+D450:000000083F88110811083F88040804087FE8000003F802080208020803F80000
+D451:000000083F88110811083F88040804087FE800000208020803F8020803F80000
+D452:000000083F88110811083F88040804087FE80000110811081F0811141F620000
+D453:000000083F88110811083F88040804087FE80000001000100010006801840000
+D454:000000083F88110811083F88040804087FE800000048004800A8011406620000
+D455:000000083F88110811083F88040804087FE80000000003F00408040803F00000
+D456:000000083F88110811083F88040804087FE8000003F80020002000D003080000
+D457:000000083F88110811083F88040804087FE80000004003F8004000A003180000
+D458:000000083F88110811083F88040804087FE8000003F8000803F8000800080000
+D459:000000083F88110811083F88040804087FE8000003F8020003F8020003F80000
+D45A:000000083F88110811083F88040804087FE8000000000FF8022002200FF80000
+D45B:000000083F88110811083F88040804087FE8000000800FF803E0041003E00000
+D45C:000000003FF808200820082008203FF8000004400440044004407FFC00000000
+D45D:00001FF00440044004401FF0044004407FFC00001FF000100010001000100000
+D45E:00001FF00440044004401FF0044004407FFC000000003EF80208020802080000
+D45F:00001FF00440044004401FF0044004407FFC000000001E100210022802C40000
+D460:00001FF00440044004401FF0044004407FFC000000001000100010001FF00000
+D461:00001FF00440044004401FF0044004407FFC0000000020F8201020303ECC0000
+D462:00001FF00440044004401FF0044004407FFC0000202021FC207020883E700000
+D463:00001FF00440044004401FF0044004407FFC00001FF01000100010001FF00000
+D464:00001FF00440044004401FF0044004407FFC00001FF000101FF010001FF00000
+D465:00001FF00440044004401FF0044004407FFC00003EF802083E0820083E080000
+D466:00001FF00440044004401FF0044004407FFC00003EF802883E8820883EF80000
+D467:00001FF00440044004401FF0044004407FFC00003E8802883EF820883EF80000
+D468:00001FF00440044004401FF0044004407FFC00003E1002103E1020283EC40000
+D469:00001FF00440044004401FF0044004407FFC00003EF802803EF820803EF80000
+D46A:00001FF00440044004401FF0044004407FFC00003EFC02483E4820483EFC0000
+D46B:00001FF00440044004401FF0044004407FFC00003E2003FC3E7020883E700000
+D46C:00001FF00440044004401FF0044004407FFC00001FF01010101010101FF00000
+D46D:00001FF00440044004401FF0044004407FFC0000101010101FF010101FF00000
+D46E:00001FF00440044004401FF0044004407FFC0000222022203E2022503E880000
+D46F:00001FF00440044004401FF0044004407FFC000000000100010002800C400000
+D470:00001FF00440044004401FF0044004407FFC00000000024002400DA033100000
+D471:00001FF00440044004401FF0044004407FFC0000000007C00820082007C00000
+D472:00001FF00440044004401FF0044004407FFC0000000007E00080014006200000
+D473:00001FF00440044004401FF0044004407FFC0000008007E00080014006200000
+D474:00001FF00440044004401FF0044004407FFC00001FF000101FF0001000100000
+D475:00001FF00440044004401FF0044004407FFC00001FF010001FF010001FF00000
+D476:00001FF00440044004401FF0044004407FFC000000001FF0044004401FF00000
+D477:00001FF00440044004401FF0044004407FFC000001001FF007C0082007C00000
+D478:000000003FF808200820082008203FF8000000003FF801000100010001000000
+D479:00001FF00440044004401FF000007FFC010001001FF000100010001000100000
+D47A:00001FF00440044004401FF000007FFC0100010000003EF80208020802080000
+D47B:00001FF00440044004401FF000007FFC0100010000001E100210022802C40000
+D47C:00001FF00440044004401FF0000000007FFC010001001100100010001FF00000
+D47D:00001FF00440044004401FF000007FFC01000100000020F8201020303ECC0000
+D47E:00001FF00440044004401FF000007FFC01000100202021FC207020883E700000
+D47F:00001FF00440044004401FF000007FFC010001001FF01000100010001FF00000
+D480:00001FF00440044004401FF000007FFC010001001FF000101FF010001FF00000
+D481:00001FF00440044004401FF000007FFC010001003EF802083E0820083E080000
+D482:00001FF00440044004401FF000007FFC010001003EF802883E8820883EF80000
+D483:00001FF00440044004401FF000007FFC010001003E8802883EF820883EF80000
+D484:00001FF00440044004401FF000007FFC010001003E1002103E1020283EC40000
+D485:00001FF00440044004401FF000007FFC010001003EF802803EF820803EF80000
+D486:00001FF00440044004401FF000007FFC010001003EFC02483E4820483EFC0000
+D487:00001FF00440044004401FF000007FFC010001003E2003FC3E7020883E700000
+D488:00001FF00440044004401FF000007FFC010001001FF01010101010101FF00000
+D489:00001FF00440044004401FF000007FFC01000100101010101FF010101FF00000
+D48A:00001FF00440044004401FF000007FFC01000100222022203E2022503E880000
+D48B:00001FF00440044004401FF000007FFC0100010000000100010002800C400000
+D48C:00001FF00440044004401FF000007FFC010001000000024002400DA033100000
+D48D:00001FF00440044004401FF000007FFC01000100000007C00820082007C00000
+D48E:00001FF00440044004401FF000007FFC01000100000007E00080014006200000
+D48F:00001FF00440044004401FF000007FFC01000100008007E00080014006200000
+D490:00001FF00440044004401FF000007FFC010001001FF000101FF0001000100000
+D491:00001FF00440044004401FF000007FFC010001001FF010001FF010001FF00000
+D492:00001FF00440044004401FF000007FFC0100010000001FF0044004401FF00000
+D493:00001FF00440044004401FF000007FFC0100010001001FF007C0082007C00000
+D494:0000000800087FC811081108110811087FC800087FE8040804F8040804080000
+D495:00083F88110811083F8800087FE8027802080000000007F80008000800080000
+D496:00083F88110811083F8800087FE802780208000000003EF80208020802080000
+D497:00083F88110811083F8800087FE802780208000000001F080108011401620000
+D498:00083F88110811083F88000800087FE80278020802081000100010001FF80000
+D499:00083F88110811083F8800087FE8027802080000000020F8201020303ECC0000
+D49A:00083F88110811083F8800087FE8027802080000202021FC207020883E700000
+D49B:00083F88110811083F8800087FE802780208000003F802000200020003F80000
+D49C:00083F88110811083F8800087FE802780208000007F8000807F8040007F80000
+D49D:00083F88110811083F8800087FE80278020800003EF802083E0820083E080000
+D49E:00083F88110811083F8800087FE80278020800003EF802883E8820883EF80000
+D49F:00083F88110811083F8800087FE80278020800003E8802883EF820883EF80000
+D4A0:00083F88110811083F8800087FE80278020800000F8800880F8808140FA20000
+D4A1:00083F88110811083F8800087FE80278020800003EF802803EF820803EF80000
+D4A2:00083F88110811083F8800087FE80278020800003EFC02483E4820483EFC0000
+D4A3:00083F88110811083F8800087FE80278020800003E1002FE3E3820443E380000
+D4A4:00083F88110811083F8800087FE802780208000003F802080208020803F80000
+D4A5:00083F88110811083F8800087FE80278020800000208020803F8020803F80000
+D4A6:00083F88110811083F8800087FE8027802080000210821083F0821143F620000
+D4A7:00083F88110811083F8800087FE8027802080000001000100010006801840000
+D4A8:00083F88110811083F8800087FE80278020800000048004800A8011406620000
+D4A9:00083F88110811083F8800087FE8027802080000000003F00408040803F00000
+D4AA:00083F88110811083F8800087FE802780208000003F80020002000D003080000
+D4AB:00083F88110811083F8800087FE8027802080000004003F8004000A003180000
+D4AC:00083F88110811083F8800087FE802780208000003F8000803F8000800080000
+D4AD:00083F88110811083F8800087FE802780208000003F8020003F8020003F80000
+D4AE:00083F88110811083F8800087FE802780208000000000FF8022002200FF80000
+D4AF:00083F88110811083F8800087FE802780208000000800FF803E0041003E00000
+D4B0:0000000A000A7FCA110A110A110A110A7FCA000A7FEA040A047A040A040A0000
+D4B1:00283FA8112811283FA800287FA805E804280000000007F80008000800080000
+D4B2:00283FA8112811283FA800287FA805E80428000000003EF80208020802080000
+D4B3:00283FA8112811283FA800287FA805E80428000000001F080108011401620000
+D4B4:00283FA8112811283FA8002800287FA8042805E804281428100010001FF80000
+D4B5:00283FA8112811283FA800287FA805E804280000000020F8201020303ECC0000
+D4B6:00283FA8112811283FA800287FA805E804280000202021FC207020883E700000
+D4B7:00283FA8112811283FA800287FA805E80428000003F802000200020003F80000
+D4B8:00283FA8112811283FA800287FA805E80428000007F8000807F8040007F80000
+D4B9:00283FA8112811283FA800287FA805E8042800003EF802083E0820083E080000
+D4BA:00283FA8112811283FA800287FA805E8042800003EF802883E8820883EF80000
+D4BB:00283FA8112811283FA800287FA805E8042800003E8802883EF820883EF80000
+D4BC:00283FA8112811283FA800287FA805E8042800000F8800880F8808140FA20000
+D4BD:00283FA8112811283FA800287FA805E8042800003EF802803EF820803EF80000
+D4BE:00283FA8112811283FA800287FA805E8042800003EFC02483E4820483EFC0000
+D4BF:00283FA8112811283FA800287FA805E8042800003E1002FE3E3820443E380000
+D4C0:00283FA8112811283FA800287FA805E80428000003F802080208020803F80000
+D4C1:00283FA8112811283FA800287FA805E8042800000208020803F8020803F80000
+D4C2:00283FA8112811283FA800287FA805E804280000210821083F0821143F620000
+D4C3:00283FA8112811283FA800287FA805E804280000001000100010006801840000
+D4C4:00283FA8112811283FA800287FA805E8042800000048004800A8011406620000
+D4C5:00283FA8112811283FA800287FA805E804280000000003F00408040803F00000
+D4C6:00283FA8112811283FA800287FA805E80428000003F80020002000D003080000
+D4C7:00283FA8112811283FA800287FA805E804280000004003F8004000A003180000
+D4C8:00283FA8112811283FA800287FA805E80428000003F8000803F8000800080000
+D4C9:00283FA8112811283FA800287FA805E80428000003F8020003F8020003F80000
+D4CA:00283FA8112811283FA800287FA805E80428000000000FF8022002200FF80000
+D4CB:00283FA8112811283FA800287FA805E80428000000800FF803E0041003E00000
+D4CC:0000000800087FC811081108110811087FC800087FE804080408040804080000
+D4CD:00083F88110811083F8800087FE8020802000000000007F80008000800080000
+D4CE:00083F88110811083F8800087FE802080200000000003EF80208020802080000
+D4CF:00083F88110811083F8800087FE802080200000000001F080108011401620000
+D4D0:00083F88110811083F88000800087FE80208020802081008100010001FF80000
+D4D1:00083F88110811083F8800087FE8020802000000000020F8201020303ECC0000
+D4D2:00083F88110811083F8800087FE8020802000000202021FC207020883E700000
+D4D3:00083F88110811083F8800087FE802080200000003F802000200020003F80000
+D4D4:00083F88110811083F8800087FE802080200000007F8000807F8040007F80000
+D4D5:00083F88110811083F8800087FE80208020000003EF802083E0820083E080000
+D4D6:00083F88110811083F8800087FE80208020000003EF802883E8820883EF80000
+D4D7:00083F88110811083F8800087FE80208020000003E8802883EF820883EF80000
+D4D8:00083F88110811083F8800087FE80208020000000F8800880F8808140FA20000
+D4D9:00083F88110811083F8800087FE80208020000003EF802803EF820803EF80000
+D4DA:00083F88110811083F8800087FE80208020000003EFC02483E4820483EFC0000
+D4DB:00083F88110811083F8800087FE80208020000003E1002FE3E3820443E380000
+D4DC:00083F88110811083F8800087FE802080200000003F802080208020803F80000
+D4DD:00083F88110811083F8800087FE80208020000000208020803F8020803F80000
+D4DE:00083F88110811083F8800087FE8020802000000210821083F0821143F620000
+D4DF:00083F88110811083F8800087FE8020802000000001000100010006801840000
+D4E0:00083F88110811083F8800087FE80208020000000048004800A8011406620000
+D4E1:00083F88110811083F8800087FE8020802000000000003F00408040803F00000
+D4E2:00083F88110811083F8800087FE802080200000003F80020002000D003080000
+D4E3:00083F88110811083F8800087FE8020802000000004003F8004000A003180000
+D4E4:00083F88110811083F8800087FE802080200000003F8000803F8000800080000
+D4E5:00083F88110811083F8800087FE802080200000003F8020003F8020003F80000
+D4E6:00083F88110811083F8800087FE802080200000000000FF8022002200FF80000
+D4E7:00083F88110811083F8800087FE802080200000000800FF803E0041003E00000
+D4E8:000000003FF808200820082008203FF8000000007FFC04400440044004400000
+D4E9:00001FF00440044004401FF000007FFC044004401FF000100010001000100000
+D4EA:00001FF00440044004401FF000007FFC0440044000003EF80208020802080000
+D4EB:00001FF00440044004401FF000007FFC0440044000001E100210022802C40000
+D4EC:00001FF00440044004401FF0000000007FFC044004401440100010001FF00000
+D4ED:00001FF00440044004401FF000007FFC04400440000020F8201020303ECC0000
+D4EE:00001FF00440044004401FF000007FFC04400440202021FC207020883E700000
+D4EF:00001FF00440044004401FF000007FFC044004401FF01000100010001FF00000
+D4F0:00001FF00440044004401FF000007FFC044004401FF000101FF010001FF00000
+D4F1:00001FF00440044004401FF000007FFC044004403EF802083E0820083E080000
+D4F2:00001FF00440044004401FF000007FFC044004403EF802883E8820883EF80000
+D4F3:00001FF00440044004401FF000007FFC044004403E8802883EF820883EF80000
+D4F4:00001FF00440044004401FF000007FFC044004403E1002103E1020283EC40000
+D4F5:00001FF00440044004401FF000007FFC044004403EF802803EF820803EF80000
+D4F6:00001FF00440044004401FF000007FFC044004403EFC02483E4820483EFC0000
+D4F7:00001FF00440044004401FF000007FFC044004403E2003FC3E7020883E700000
+D4F8:00001FF00440044004401FF000007FFC044004401FF01010101010101FF00000
+D4F9:00001FF00440044004401FF000007FFC04400440101010101FF010101FF00000
+D4FA:00001FF00440044004401FF000007FFC04400440222022203E2022503E880000
+D4FB:00001FF00440044004401FF000007FFC0440044000000100010002800C400000
+D4FC:00001FF00440044004401FF000007FFC044004400000024002400DA033100000
+D4FD:00001FF00440044004401FF000007FFC04400440000007C00820082007C00000
+D4FE:00001FF00440044004401FF000007FFC04400440000007E00080014006200000
+D4FF:00001FF00440044004401FF000007FFC04400440008007E00080014006200000
+D500:00001FF00440044004401FF000007FFC044004401FF000101FF0001000100000
+D501:00001FF00440044004401FF000007FFC044004401FF010001FF010001FF00000
+D502:00001FF00440044004401FF000007FFC0440044000001FF0044004401FF00000
+D503:00001FF00440044004401FF000007FFC0440044001001FF007C0082007C00000
+D504:000000003FF808200820082008203FF80000000000007FFC0000000000000000
+D505:00001FF00440044004401FF0000000007FFC00001FF000100010001000100000
+D506:00001FF00440044004401FF0000000007FFC000000003EF80208020802080000
+D507:00001FF00440044004401FF0000000007FFC000000001E100210022802C40000
+D508:00001FF00440044004401FF0000000007FFC000000001000100010001FF00000
+D509:00001FF00440044004401FF0000000007FFC0000000020F8201020303ECC0000
+D50A:00001FF00440044004401FF0000000007FFC0000202021FC207020883E700000
+D50B:00001FF00440044004401FF0000000007FFC00001FF01000100010001FF00000
+D50C:00001FF00440044004401FF0000000007FFC00001FF000101FF010001FF00000
+D50D:00001FF00440044004401FF0000000007FFC00003EF802083E0820083E080000
+D50E:00001FF00440044004401FF0000000007FFC00003EF802883E8820883EF80000
+D50F:00001FF00440044004401FF0000000007FFC00003E8802883EF820883EF80000
+D510:00001FF00440044004401FF0000000007FFC00003E1002103E1020283EC40000
+D511:00001FF00440044004401FF0000000007FFC00003EF802803EF820803EF80000
+D512:00001FF00440044004401FF0000000007FFC00003EFC02483E4820483EFC0000
+D513:00001FF00440044004401FF0000000007FFC00003E2003FC3E7020883E700000
+D514:00001FF00440044004401FF0000000007FFC00001FF01010101010101FF00000
+D515:00001FF00440044004401FF0000000007FFC0000101010101FF010101FF00000
+D516:00001FF00440044004401FF0000000007FFC0000222022203E2022503E880000
+D517:00001FF00440044004401FF0000000007FFC000000000100010002800C400000
+D518:00001FF00440044004401FF0000000007FFC00000000024002400DA033100000
+D519:00001FF00440044004401FF0000000007FFC0000000007C00820082007C00000
+D51A:00001FF00440044004401FF0000000007FFC0000000007E00080014006200000
+D51B:00001FF00440044004401FF0000000007FFC0000008007E00080014006200000
+D51C:00001FF00440044004401FF0000000007FFC00001FF000101FF0001000100000
+D51D:00001FF00440044004401FF0000000007FFC00001FF010001FF010001FF00000
+D51E:00001FF00440044004401FF0000000007FFC000000001FF0044004401FF00000
+D51F:00001FF00440044004401FF0000000007FFC000001001FF007C0082007C00000
+D520:00000008000800087FC811081108110811087FC800087FE80008000800080000
+D521:000000083F88110811083F88000800087FE8000007F800080008000800080000
+D522:000000083F88110811083F88000800087FE8000000003EF80208020802080000
+D523:000000083F88110811083F88000800087FE8000000001F080108011401620000
+D524:000000083F88110811083F88000800087FE8000008000800080008000FF80000
+D525:000000083F88110811083F88000800087FE80000000010F8101010301ECC0000
+D526:000000083F88110811083F88000800087FE800000808087F081C08220F9C0000
+D527:000000083F88110811083F88000800087FE8000003F802000200020003F80000
+D528:000000083F88110811083F88000800087FE8000007F8000807F8040007F80000
+D529:000000083F88110811083F88000800087FE800003EF802083E0820083E080000
+D52A:000000083F88110811083F88000800087FE800003EF802883E8820883EF80000
+D52B:000000083F88110811083F88000800087FE800003E8802883EF820883EF80000
+D52C:000000083F88110811083F88000800087FE800001F0801081F0810141F620000
+D52D:000000083F88110811083F88000800087FE800003EF802803EF820803EF80000
+D52E:000000083F88110811083F88000800087FE800003EFC02483E4820483EFC0000
+D52F:000000083F88110811083F88000800087FE800001F08017F1F1C10221F1C0000
+D530:000000083F88110811083F88000800087FE8000003F802080208020803F80000
+D531:000000083F88110811083F88000800087FE800000208020803F8020803F80000
+D532:000000083F88110811083F88000800087FE80000110811081F0811141F620000
+D533:000000083F88110811083F88000800087FE80000001000100010006801840000
+D534:000000083F88110811083F88000800087FE800000048004800A8011406620000
+D535:000000083F88110811083F88000800087FE80000000003F00408040803F00000
+D536:000000083F88110811083F88000800087FE8000003F80020002000D003080000
+D537:000000083F88110811083F88000800087FE80000004003F8004000A003180000
+D538:000000083F88110811083F88000800087FE8000003F8000803F8000800080000
+D539:000000083F88110811083F88000800087FE8000003F8020003F8020003F80000
+D53A:000000083F88110811083F88000800087FE8000000000FF8022002200FF80000
+D53B:000000083F88110811083F88000800087FE8000000800FF803E0041003E00000
+D53C:00000000000800087FC8110811081108110811087FC800080008000800080000
+D53D:0000000800087F881208120812087F8800080000000007F80008000800080000
+D53E:0000000800087F881208120812087F880008000000003EF80208020802080000
+D53F:0000000800087F881208120812087F880008000000001F080108011401620000
+D540:0000000800087F881208120812087F880008000800001000100010001FF80000
+D541:0000000800087F881208120812087F8800080000000020F8201020303ECC0000
+D542:0000000800087F881208120812087F8800080000202021FC207020883E700000
+D543:0000000800087F881208120812087F880008000003F802000200020003F80000
+D544:0000000800087F881208120812087F880008000007F8000807F8040007F80000
+D545:0000000800087F881208120812087F88000800003EF802083E0820083E080000
+D546:0000000800087F881208120812087F88000800003EF802883E8820883EF80000
+D547:0000000800087F881208120812087F88000800003E8802883EF820883EF80000
+D548:0000000800087F881208120812087F88000800000F8800880F8808140FA20000
+D549:0000000800087F881208120812087F88000800003EF802803EF820803EF80000
+D54A:0000000800087F881208120812087F88000800003EFC02483E4820483EFC0000
+D54B:0000000800087F881208120812087F88000800003E1002FE3E3820443E380000
+D54C:0000000800087F881208120812087F880008000003F802080208020803F80000
+D54D:0000000800087F881208120812087F88000800000208020803F8020803F80000
+D54E:0000000800087F881208120812087F8800080000210821083F0821143F620000
+D54F:0000000800087F881208120812087F8800080000001000100010006801840000
+D550:0000000800087F881208120812087F88000800000048004800A8011406620000
+D551:0000000800087F881208120812087F8800080000000003F00408040803F00000
+D552:0000000800087F881208120812087F880008000003F80020002000D003080000
+D553:0000000800087F881208120812087F8800080000004003F8004000A003180000
+D554:0000000800087F881208120812087F880008000003F8000803F8000800080000
+D555:0000000800087F881208120812087F880008000003F8020003F8020003F80000
+D556:0000000800087F881208120812087F880008000000000FF8022002200FF80000
+D557:0000000800087F881208120812087F880008000000800FF803E0041003E00000
+D558:00000000041004103F900E101110209E2090209011100E100010001000100000
+D559:000008087F081C082208220E22081C080008000007F800080008000800080000
+D55A:000008087F081C082208220E22081C080008000000003EF80208020802080000
+D55B:000008087F081C082208220E22081C080008000000001F080108011401620000
+D55C:000008087F081C082208220E22081C080008000808000800080008000FF80000
+D55D:000008087F081C082208220E22081C0800080000000010F8101010301ECC0000
+D55E:000008087F081C082208220E22081C08000800000808087F081C08220F9C0000
+D55F:000008087F081C082208220E22081C080008000003F802000200020003F80000
+D560:000008087F081C082208220E22081C080008000007F8000807F8040007F80000
+D561:000008087F081C082208220E22081C08000800003EF802083E0820083E080000
+D562:000008087F081C082208220E22081C08000800003EF802883E8820883EF80000
+D563:000008087F081C082208220E22081C08000800003E8802883EF820883EF80000
+D564:000008087F081C082208220E22081C08000800001F0801081F0810141F620000
+D565:000008087F081C082208220E22081C08000800003EF802803EF820803EF80000
+D566:000008087F081C082208220E22081C08000800003EFC02483E4820483EFC0000
+D567:000008087F081C082208220E22081C08000800001F08017F1F1C10221F1C0000
+D568:000008087F081C082208220E22081C080008000003F802080208020803F80000
+D569:000008087F081C082208220E22081C08000800000208020803F8020803F80000
+D56A:000008087F081C082208220E22081C0800080000110811081F0811141F620000
+D56B:000008087F081C082208220E22081C0800080000001000100010006801840000
+D56C:000008087F081C082208220E22081C08000800000048004800A8011406620000
+D56D:000008087F081C082208220E22081C0800080000000003F00408040803F00000
+D56E:000008087F081C082208220E22081C080008000003F80020002000D003080000
+D56F:000008087F081C082208220E22081C0800080000004003F8004000A003180000
+D570:000008087F081C082208220E22081C080008000003F8000803F8000800080000
+D571:000008087F081C082208220E22081C080008000003F8020003F8020003F80000
+D572:000008087F081C082208220E22081C080008000000000FF8022002200FF80000
+D573:000008087F081C082208220E22081C080008000000800FF803E0041003E00000
+D574:00000000041204123F920E121112209E2092209211120E120012001200120000
+D575:000008287F281C282228223822281C280028000007F800080008000800080000
+D576:000008287F281C282228223822281C280028000000003EF80208020802080000
+D577:000008287F281C282228223822281C280028000000003E100210022802C40000
+D578:000008287F281C282228223822281C280028002808000800080008000FF80000
+D579:000008287F281C282228223822281C2800280000000020F8201020303ECC0000
+D57A:000008287F281C282228223822281C2800280000202021FC207020883E700000
+D57B:000008287F281C282228223822281C280028000003F802000200020003F80000
+D57C:000008287F281C282228223822281C280028000007F8000807F8040007F80000
+D57D:000008287F281C282228223822281C28002800003EF802083E0820083E080000
+D57E:000008287F281C282228223822281C28002800003EF802883E8820883EF80000
+D57F:000008287F281C282228223822281C28002800003E8802883EF820883EF80000
+D580:000008287F281C282228223822281C28002800001F0801081F0810141F620000
+D581:000008287F281C282228223822281C28002800003EF802803EF820803EF80000
+D582:000008287F281C282228223822281C28002800003EFC02483E4820483EFC0000
+D583:000008287F281C282228223822281C28002800003E1002FE3E3820443E380000
+D584:000008287F281C282228223822281C280028000003F802080208020803F80000
+D585:000008287F281C282228223822281C28002800000208020803F8020803F80000
+D586:000008287F281C282228223822281C2800280000110811081F0811141F620000
+D587:000008287F281C282228223822281C2800280000000800080008003400C20000
+D588:000008287F281C282228223822281C28002800000048004800A8011406620000
+D589:000008287F281C282228223822281C2800280000000001F00208020801F00000
+D58A:000008287F281C282228223822281C280028000003F80020002000D003080000
+D58B:000008287F281C282228223822281C2800280000004003F8004000A003180000
+D58C:000008287F281C282228223822281C280028000003F8000803F8000800080000
+D58D:000008287F281C282228223822281C280028000003F8020003F8020003F80000
+D58E:000008287F281C282228223822281C280028000000000FF8022002200FF80000
+D58F:000008287F281C282228223822281C280028000000800FF803E0041003E00000
+D590:00000000041004103F900E10111E20902090209E11100E100010001000100000
+D591:000008087F081C08220E2208220E1C080008000007F800080008000800080000
+D592:000008087F081C08220E2208220E1C080008000000003EF80208020802080000
+D593:000008087F081C08220E2208220E1C080008000000001F080108011401620000
+D594:000008087F081C08220E2208220E1C080008000008000800080008000FF80000
+D595:000008087F081C08220E2208220E1C0800080000000010F8101010301ECC0000
+D596:000008087F081C08220E2208220E1C08000800000808087F081C08220F9C0000
+D597:000008087F081C08220E2208220E1C080008000003F802000200020003F80000
+D598:000008087F081C08220E2208220E1C080008000007F8000807F8040007F80000
+D599:000008087F081C08220E2208220E1C08000800003EF802083E0820083E080000
+D59A:000008087F081C08220E2208220E1C08000800003EF802883E8820883EF80000
+D59B:000008087F081C08220E2208220E1C08000800003E8802883EF820883EF80000
+D59C:000008087F081C08220E2208220E1C08000800001F0801081F0810141F620000
+D59D:000008087F081C08220E2208220E1C08000800003EF802803EF820803EF80000
+D59E:000008087F081C08220E2208220E1C08000800003EFC02483E4820483EFC0000
+D59F:000008087F081C08220E2208220E1C08000800001F08017F1F1C10221F1C0000
+D5A0:000008087F081C08220E2208220E1C080008000003F802080208020803F80000
+D5A1:000008087F081C08220E2208220E1C08000800000208020803F8020803F80000
+D5A2:000008087F081C08220E2208220E1C0800080000110811081F0811141F620000
+D5A3:000008087F081C08220E2208220E1C0800080000001000100010006801840000
+D5A4:000008087F081C08220E2208220E1C08000800000048004800A8011406620000
+D5A5:000008087F081C08220E2208220E1C0800080000000003F00408040803F00000
+D5A6:000008087F081C08220E2208220E1C080008000003F80020002000D003080000
+D5A7:000008087F081C08220E2208220E1C0800080000004003F8004000A003180000
+D5A8:000008087F081C08220E2208220E1C080008000003F8000803F8000800080000
+D5A9:000008087F081C08220E2208220E1C080008000003F8020003F8020003F80000
+D5AA:000008087F081C08220E2208220E1C080008000000000FF8022002200FF80000
+D5AB:000008087F081C08220E2208220E1C080008000000800FF803E0041003E00000
+D5AC:00000000041204123F920E12111E20922092209E11120E120012001200120000
+D5AD:000008287F281C282238222822381C280028000007F800080008000800080000
+D5AE:000008287F281C282238222822381C280028000000003EF80208020802080000
+D5AF:000008287F281C282238222822381C280028000000003E100210022802C40000
+D5B0:000008287F281C282238222822381C280028002808000800080008000FF80000
+D5B1:000008287F281C282238222822381C2800280000000020F8201020303ECC0000
+D5B2:000008287F281C282238222822381C2800280000202021FC207020883E700000
+D5B3:000008287F281C282238222822381C280028000003F802000200020003F80000
+D5B4:000008287F281C282238222822381C280028000007F8000807F8040007F80000
+D5B5:000008287F281C282238222822381C28002800003EF802083E0820083E080000
+D5B6:000008287F281C282238222822381C28002800003EF802883E8820883EF80000
+D5B7:000008287F281C282238222822381C28002800003E8802883EF820883EF80000
+D5B8:000008287F281C282238222822381C28002800001F0801081F0810141F620000
+D5B9:000008287F281C282238222822381C28002800003EF802803EF820803EF80000
+D5BA:000008287F281C282238222822381C28002800003EFC02483E4820483EFC0000
+D5BB:000008287F281C282238222822381C28002800003E1002FE3E3820443E380000
+D5BC:000008287F281C282238222822381C280028000003F802080208020803F80000
+D5BD:000008287F281C282238222822381C28002800000208020803F8020803F80000
+D5BE:000008287F281C282238222822381C2800280000110811081F0811141F620000
+D5BF:000008287F281C282238222822381C2800280000000800080008003400C20000
+D5C0:000008287F281C282238222822381C28002800000048004800A8011406620000
+D5C1:000008287F281C282238222822381C2800280000000001F00208020801F00000
+D5C2:000008287F281C282238222822381C280028000003F80020002000D003080000
+D5C3:000008287F281C282238222822381C2800280000004003F8004000A003180000
+D5C4:000008287F281C282238222822381C280028000003F8000803F8000800080000
+D5C5:000008287F281C282238222822381C280028000003F8020003F8020003F80000
+D5C6:000008287F281C282238222822381C280028000000000FF8022002200FF80000
+D5C7:000008287F281C282238222822381C280028000000800FF803E0041003E00000
+D5C8:00000000040204023F820E021102209E2082208211020E020002000200020000
+D5C9:000008087F081C082208223822081C0800080000000007F80008000800080000
+D5CA:000008087F081C082208223822081C080008000000003EF80208020802080000
+D5CB:000008087F081C082208223822081C080008000000001F080108011401620000
+D5CC:000008087F081C082208223822081C080008000000001000100010001FF80000
+D5CD:000008087F081C082208223822081C0800080000000020F8201020303ECC0000
+D5CE:000008087F081C082208223822081C0800080000202021FC207020883E700000
+D5CF:000008087F081C082208223822081C080008000003F802000200020003F80000
+D5D0:000008087F081C082208223822081C080008000007F8000807F8040007F80000
+D5D1:000008087F081C082208223822081C08000800003EF802083E0820083E080000
+D5D2:000008087F081C082208223822081C08000800003EF802883E8820883EF80000
+D5D3:000008087F081C082208223822081C08000800003E8802883EF820883EF80000
+D5D4:000008087F081C082208223822081C08000800000F8800880F8808140FA20000
+D5D5:000008087F081C082208223822081C08000800003EF802803EF820803EF80000
+D5D6:000008087F081C082208223822081C08000800003EFC02483E4820483EFC0000
+D5D7:000008087F081C082208223822081C08000800003E1002FE3E3820443E380000
+D5D8:000008087F081C082208223822081C080008000003F802080208020803F80000
+D5D9:000008087F081C082208223822081C08000800000208020803F8020803F80000
+D5DA:000008087F081C082208223822081C0800080000210821083F0821143F620000
+D5DB:000008087F081C082208223822081C0800080000001000100010006801840000
+D5DC:000008087F081C082208223822081C08000800000048004800A8011406620000
+D5DD:000008087F081C082208223822081C0800080000000003F00408040803F00000
+D5DE:000008087F081C082208223822081C080008000003F80020002000D003080000
+D5DF:000008087F081C082208223822081C0800080000004003F8004000A003180000
+D5E0:000008087F081C082208223822081C080008000003F8000803F8000800080000
+D5E1:000008087F081C082208223822081C080008000003F8020003F8020003F80000
+D5E2:000008087F081C082208223822081C080008000000000FF8022002200FF80000
+D5E3:000008087F081C082208223822081C080008000000800FF803E0041003E00000
+D5E4:00000000040A040A3F8A0E0A110A20BA208A208A110A0E0A000A000A000A0000
+D5E5:000008287F281C28222822E822281C280028000007F800080008000800080000
+D5E6:000008287F281C28222822E822281C280028000000003EF80208020802080000
+D5E7:000008287F281C28222822E822281C280028000000003E100210022802C40000
+D5E8:000008287F281C28222822E822281C280028000008000800080008000FF80000
+D5E9:000008287F281C28222822E822281C2800280000000020F8201020303ECC0000
+D5EA:000008287F281C28222822E822281C2800280000202021FC207020883E700000
+D5EB:000008287F281C28222822E822281C280028000003F802000200020003F80000
+D5EC:000008287F281C28222822E822281C280028000007F8000807F8040007F80000
+D5ED:000008287F281C28222822E822281C28002800003EF802083E0820083E080000
+D5EE:000008287F281C28222822E822281C28002800003EF802883E8820883EF80000
+D5EF:000008287F281C28222822E822281C28002800003E8802883EF820883EF80000
+D5F0:000008287F281C28222822E822281C28002800001F0801081F0810141F620000
+D5F1:000008287F281C28222822E822281C28002800003EF802803EF820803EF80000
+D5F2:000008287F281C28222822E822281C28002800003EFC02483E4820483EFC0000
+D5F3:000008287F281C28222822E822281C28002800003E1002FE3E3820443E380000
+D5F4:000008287F281C28222822E822281C280028000003F802080208020803F80000
+D5F5:000008287F281C28222822E822281C28002800000208020803F8020803F80000
+D5F6:000008287F281C28222822E822281C2800280000110811081F0811141F620000
+D5F7:000008287F281C28222822E822281C2800280000000800080008003400C20000
+D5F8:000008287F281C28222822E822281C28002800000048004800A8011406620000
+D5F9:000008287F281C28222822E822281C2800280000000001F00208020801F00000
+D5FA:000008287F281C28222822E822281C280028000003F80020002000D003080000
+D5FB:000008287F281C28222822E822281C2800280000004003F8004000A003180000
+D5FC:000008287F281C28222822E822281C280028000003F8000803F8000800080000
+D5FD:000008287F281C28222822E822281C280028000003F8020003F8020003F80000
+D5FE:000008287F281C28222822E822281C280028000000000FF8022002200FF80000
+D5FF:000008287F281C28222822E822281C280028000000800FF803E0041003E00000
+D600:00000000040204023F820E02111E20822082209E11020E020002000200020000
+D601:000008087F081C082238220822381C0800080000000007F80008000800080000
+D602:000008087F081C082238220822381C080008000000003EF80208020802080000
+D603:000008087F081C082238220822381C080008000000001F080108011401620000
+D604:000008087F081C082238220822381C080008000800001000100010001FF80000
+D605:000008087F081C082238220822381C0800080000000020F8201020303ECC0000
+D606:000008087F081C082238220822381C0800080000202021FC207020883E700000
+D607:000008087F081C082238220822381C080008000003F802000200020003F80000
+D608:000008087F081C082238220822381C080008000007F8000807F8040007F80000
+D609:000008087F081C082238220822381C08000800003EF802083E0820083E080000
+D60A:000008087F081C082238220822381C08000800003EF802883E8820883EF80000
+D60B:000008087F081C082238220822381C08000800003E8802883EF820883EF80000
+D60C:000008087F081C082238220822381C08000800000F8800880F8808140FA20000
+D60D:000008087F081C082238220822381C08000800003EF802803EF820803EF80000
+D60E:000008087F081C082238220822381C08000800003EFC02483E4820483EFC0000
+D60F:000008087F081C082238220822381C08000800003E1002FE3E3820443E380000
+D610:000008087F081C082238220822381C080008000003F802080208020803F80000
+D611:000008087F081C082238220822381C08000800000208020803F8020803F80000
+D612:000008087F081C082238220822381C0800080000210821083F0821143F620000
+D613:000008087F081C082238220822381C0800080000001000100010006801840000
+D614:000008087F081C082238220822381C08000800000048004800A8011406620000
+D615:000008087F081C082238220822381C0800080000000003F00408040803F00000
+D616:000008087F081C082238220822381C080008000003F80020002000D003080000
+D617:000008087F081C082238220822381C0800080000004003F8004000A003180000
+D618:000008087F081C082238220822381C080008000003F8000803F8000800080000
+D619:000008087F081C082238220822381C080008000003F8020003F8020003F80000
+D61A:000008087F081C082238220822381C080008000000000FF8022002200FF80000
+D61B:000008087F081C082238220822381C080008000000800FF803E0041003E00000
+D61C:00000000040A040A3F8A0E0A113A208A208A20BA110A0E0A000A000A000A0000
+D61D:000008287F281C2822E8222822E81C280028000007F800080008000800080000
+D61E:000008287F281C2822E8222822E81C280028000000003EF80208020802080000
+D61F:000008287F281C2822E8222822E81C280028000000003E100210022802C40000
+D620:000008287F281C2822E8222822E81C280028002808000800080008000FF80000
+D621:000008287F281C2822E8222822E81C2800280000000020F8201020303ECC0000
+D622:000008287F281C2822E8222822E81C2800280000202021FC207020883E700000
+D623:000008287F281C2822E8222822E81C280028000003F802000200020003F80000
+D624:000008287F281C2822E8222822E81C280028000007F8000807F8040007F80000
+D625:000008287F281C2822E8222822E81C28002800003EF802083E0820083E080000
+D626:000008287F281C2822E8222822E81C28002800003EF802883E8820883EF80000
+D627:000008287F281C2822E8222822E81C28002800003E8802883EF820883EF80000
+D628:000008287F281C2822E8222822E81C28002800001F0801081F0810141F620000
+D629:000008287F281C2822E8222822E81C28002800003EF802803EF820803EF80000
+D62A:000008287F281C2822E8222822E81C28002800003EFC02483E4820483EFC0000
+D62B:000008287F281C2822E8222822E81C28002800003E1002FE3E3820443E380000
+D62C:000008287F281C2822E8222822E81C280028000003F802080208020803F80000
+D62D:000008287F281C2822E8222822E81C28002800000208020803F8020803F80000
+D62E:000008287F281C2822E8222822E81C2800280000110811081F0811141F620000
+D62F:000008287F281C2822E8222822E81C2800280000000800080008003400C20000
+D630:000008287F281C2822E8222822E81C28002800000048004800A8011406620000
+D631:000008287F281C2822E8222822E81C2800280000000001F00208020801F00000
+D632:000008287F281C2822E8222822E81C280028000003F80020002000D003080000
+D633:000008287F281C2822E8222822E81C2800280000004003F8004000A003180000
+D634:000008287F281C2822E8222822E81C280028000003F8000803F8000800080000
+D635:000008287F281C2822E8222822E81C280028000003F8020003F8020003F80000
+D636:000008287F281C2822E8222822E81C280028000000000FF8022002200FF80000
+D637:000008287F281C2822E8222822E81C280028000000800FF803E0041003E00000
+D638:0000010001000FE0000007C00820082007C000000100010001007FFC00000000
+D639:01000FE007C00820082007C0010001007FFC00001FF000100010001000100000
+D63A:01000FE007C00820082007C0010001007FFC000000003EF80208020802080000
+D63B:01000FE007C00820082007C0010001007FFC000000001E100210022802C40000
+D63C:01000FE007C00820082007C0010001007FFC000000001000100010001FF00000
+D63D:01000FE007C00820082007C0010001007FFC0000000020F8201020303ECC0000
+D63E:01000FE007C00820082007C0010001007FFC0000202021FC207020883E700000
+D63F:01000FE007C00820082007C0010001007FFC00001FF01000100010001FF00000
+D640:01000FE007C00820082007C0010001007FFC00001FF000101FF010001FF00000
+D641:01000FE007C00820082007C0010001007FFC00003EF802083E0820083E080000
+D642:01000FE007C00820082007C0010001007FFC00003EF802883E8820883EF80000
+D643:01000FE007C00820082007C0010001007FFC00003E8802883EF820883EF80000
+D644:01000FE007C00820082007C0010001007FFC00003E1002103E1020283EC40000
+D645:01000FE007C00820082007C0010001007FFC00003EF802803EF820803EF80000
+D646:01000FE007C00820082007C0010001007FFC00003EFC02483E4820483EFC0000
+D647:01000FE007C00820082007C0010001007FFC00003E2003FC3E7020883E700000
+D648:01000FE007C00820082007C0010001007FFC00001FF01010101010101FF00000
+D649:01000FE007C00820082007C0010001007FFC0000101010101FF010101FF00000
+D64A:01000FE007C00820082007C0010001007FFC0000222022203E2022503E880000
+D64B:01000FE007C00820082007C0010001007FFC000000000100010002800C400000
+D64C:01000FE007C00820082007C0010001007FFC00000000024002400DA033100000
+D64D:01000FE007C00820082007C0010001007FFC0000000007C00820082007C00000
+D64E:01000FE007C00820082007C0010001007FFC0000000007E00080014006200000
+D64F:01000FE007C00820082007C0010001007FFC0000008007E00080014006200000
+D650:01000FE007C00820082007C0010001007FFC00001FF000101FF0001000100000
+D651:01000FE007C00820082007C0010001007FFC00001FF010001FF010001FF00000
+D652:01000FE007C00820082007C0010001007FFC000000001FF0044004401FF00000
+D653:01000FE007C00820082007C0010001007FFC000001001FF007C0082007C00000
+D654:00000010041004103F9000101F10209E20901F10041004107FD0001000100000
+D655:000004083F880E08110E11080E0804087FE8000007F800080008000800080000
+D656:000004083F880E08110E11080E0804087FE8000000003EF80208020802080000
+D657:000004083F880E08110E11080E0804087FE8000000001F080108011401620000
+D658:000004083F880E08110E11080E0804087FE8000008000800080008000FF80000
+D659:000004083F880E08110E11080E0804087FE80000000010F8101010301ECC0000
+D65A:000004083F880E08110E11080E0804087FE800000808087F081C08220F9C0000
+D65B:000004083F880E08110E11080E0804087FE8000003F802000200020003F80000
+D65C:000004083F880E08110E11080E0804087FE8000007F8000807F8040007F80000
+D65D:000004083F880E08110E11080E0804087FE800003EF802083E0820083E080000
+D65E:000004083F880E08110E11080E0804087FE800003EF802883E8820883EF80000
+D65F:000004083F880E08110E11080E0804087FE800003E8802883EF820883EF80000
+D660:000004083F880E08110E11080E0804087FE800001F0801081F0810141F620000
+D661:000004083F880E08110E11080E0804087FE800003EF802803EF820803EF80000
+D662:000004083F880E08110E11080E0804087FE800003EFC02483E4820483EFC0000
+D663:000004083F880E08110E11080E0804087FE800001F08017F1F1C10221F1C0000
+D664:000004083F880E08110E11080E0804087FE8000003F802080208020803F80000
+D665:000004083F880E08110E11080E0804087FE800000208020803F8020803F80000
+D666:000004083F880E08110E11080E0804087FE80000110811081F0811141F620000
+D667:000004083F880E08110E11080E0804087FE80000001000100010006801840000
+D668:000004083F880E08110E11080E0804087FE800000048004800A8011406620000
+D669:000004083F880E08110E11080E0804087FE80000000003F00408040803F00000
+D66A:000004083F880E08110E11080E0804087FE8000003F80020002000D003080000
+D66B:000004083F880E08110E11080E0804087FE80000004003F8004000A003180000
+D66C:000004083F880E08110E11080E0804087FE8000003F8000803F8000800080000
+D66D:000004083F880E08110E11080E0804087FE8000003F8020003F8020003F80000
+D66E:000004083F880E08110E11080E0804087FE8000000000FF8022002200FF80000
+D66F:000004083F880E08110E11080E0804087FE8000000800FF803E0041003E00000
+D670:00000012041204123F9200121F12209E20921F12041204127FD2001200120000
+D671:000004283FA80E28113811280E2804287FA8000007F800080008000800080000
+D672:000004283FA80E28113811280E2804287FA8000000003EF80208020802080000
+D673:000004283FA80E28113811280E2804287FA8000000001F080108011401620000
+D674:000004283FA80E28113811280E2804287FA8000008000800080008000FF80000
+D675:000004283FA80E28113811280E2804287FA80000000010F8101010301ECC0000
+D676:000004283FA80E28113811280E2804287FA800000808087F081C08220F9C0000
+D677:000004283FA80E28113811280E2804287FA8000003F802000200020003F80000
+D678:000004283FA80E28113811280E2804287FA8000007F8000807F8040007F80000
+D679:000004283FA80E28113811280E2804287FA800003EF802083E0820083E080000
+D67A:000004283FA80E28113811280E2804287FA800003EF802883E8820883EF80000
+D67B:000004283FA80E28113811280E2804287FA800003E8802883EF820883EF80000
+D67C:000004283FA80E28113811280E2804287FA800001F0801081F0810141F620000
+D67D:000004283FA80E28113811280E2804287FA800003EF802803EF820803EF80000
+D67E:000004283FA80E28113811280E2804287FA800003EFC02483E4820483EFC0000
+D67F:000004283FA80E28113811280E2804287FA800001F08017F1F1C10221F1C0000
+D680:000004283FA80E28113811280E2804287FA8000003F802080208020803F80000
+D681:000004283FA80E28113811280E2804287FA800000208020803F8020803F80000
+D682:000004283FA80E28113811280E2804287FA80000110811081F0811141F620000
+D683:000004283FA80E28113811280E2804287FA80000001000100010006801840000
+D684:000004283FA80E28113811280E2804287FA800000048004800A8011406620000
+D685:000004283FA80E28113811280E2804287FA80000000003F00408040803F00000
+D686:000004283FA80E28113811280E2804287FA8000003F80020002000D003080000
+D687:000004283FA80E28113811280E2804287FA80000004003F8004000A003180000
+D688:000004283FA80E28113811280E2804287FA8000003F8000803F8000800080000
+D689:000004283FA80E28113811280E2804287FA8000003F8020003F8020003F80000
+D68A:000004283FA80E28113811280E2804287FA8000000000FF8022002200FF80000
+D68B:000004283FA80E28113811280E2804287FA8000000800FF803E0041003E00000
+D68C:00000008040804083F8800081F08208820881F08040804087FE8000800080000
+D68D:000004083F880E08110811080E0804087FE8000007F800080008000800080000
+D68E:000004083F880E08110811080E0804087FE8000000003EF80208020802080000
+D68F:000004083F880E08110811080E0804087FE8000000001F080108011401620000
+D690:000004083F880E08110811080E0804087FE8000008000800080008000FF80000
+D691:000004083F880E08110811080E0804087FE80000000010F8101010301ECC0000
+D692:000004083F880E08110811080E0804087FE800000808087F081C08220F9C0000
+D693:000004083F880E08110811080E0804087FE8000003F802000200020003F80000
+D694:000004083F880E08110811080E0804087FE8000007F8000807F8040007F80000
+D695:000004083F880E08110811080E0804087FE800003EF802083E0820083E080000
+D696:000004083F880E08110811080E0804087FE800003EF802883E8820883EF80000
+D697:000004083F880E08110811080E0804087FE800003E8802883EF820883EF80000
+D698:000004083F880E08110811080E0804087FE800001F0801081F0810141F620000
+D699:000004083F880E08110811080E0804087FE800003EF802803EF820803EF80000
+D69A:000004083F880E08110811080E0804087FE800003EFC02483E4820483EFC0000
+D69B:000004083F880E08110811080E0804087FE800001F08017F1F1C10221F1C0000
+D69C:000004083F880E08110811080E0804087FE8000003F802080208020803F80000
+D69D:000004083F880E08110811080E0804087FE800000208020803F8020803F80000
+D69E:000004083F880E08110811080E0804087FE80000110811081F0811141F620000
+D69F:000004083F880E08110811080E0804087FE80000001000100010006801840000
+D6A0:000004083F880E08110811080E0804087FE800000048004800A8011406620000
+D6A1:000004083F880E08110811080E0804087FE80000000003F00408040803F00000
+D6A2:000004083F880E08110811080E0804087FE8000003F80020002000D003080000
+D6A3:000004083F880E08110811080E0804087FE80000004003F8004000A003180000
+D6A4:000004083F880E08110811080E0804087FE8000003F8000803F8000800080000
+D6A5:000004083F880E08110811080E0804087FE8000003F8020003F8020003F80000
+D6A6:000004083F880E08110811080E0804087FE8000000000FF8022002200FF80000
+D6A7:000004083F880E08110811080E0804087FE8000000800FF803E0041003E00000
+D6A8:0000010001000FE0000007C00820082007C004400440044004407FFC00000000
+D6A9:01000FE007C00820082007C0044004407FFC00001FF000100010001000100000
+D6AA:01000FE007C00820082007C0044004407FFC000000003EF80208020802080000
+D6AB:01000FE007C00820082007C0044004407FFC000000001E100210022802C40000
+D6AC:01000FE007C00820082007C0044004407FFC000000001000100010001FF00000
+D6AD:01000FE007C00820082007C0044004407FFC0000000020F8201020303ECC0000
+D6AE:01000FE007C00820082007C0044004407FFC0000202021FC207020883E700000
+D6AF:01000FE007C00820082007C0044004407FFC00001FF01000100010001FF00000
+D6B0:01000FE007C00820082007C0044004407FFC00001FF000101FF010001FF00000
+D6B1:01000FE007C00820082007C0044004407FFC00003EF802083E0820083E080000
+D6B2:01000FE007C00820082007C0044004407FFC00003EF802883E8820883EF80000
+D6B3:01000FE007C00820082007C0044004407FFC00003E8802883EF820883EF80000
+D6B4:01000FE007C00820082007C0044004407FFC00003E1002103E1020283EC40000
+D6B5:01000FE007C00820082007C0044004407FFC00003EF802803EF820803EF80000
+D6B6:01000FE007C00820082007C0044004407FFC00003EFC02483E4820483EFC0000
+D6B7:01000FE007C00820082007C0044004407FFC00003E2003FC3E7020883E700000
+D6B8:01000FE007C00820082007C0044004407FFC00001FF01010101010101FF00000
+D6B9:01000FE007C00820082007C0044004407FFC0000101010101FF010101FF00000
+D6BA:01000FE007C00820082007C0044004407FFC0000222022203E2022503E880000
+D6BB:01000FE007C00820082007C0044004407FFC000000000100010002800C400000
+D6BC:01000FE007C00820082007C0044004407FFC00000000024002400DA033100000
+D6BD:01000FE007C00820082007C0044004407FFC0000000007C00820082007C00000
+D6BE:01000FE007C00820082007C0044004407FFC0000000007E00080014006200000
+D6BF:01000FE007C00820082007C0044004407FFC0000008007E00080014006200000
+D6C0:01000FE007C00820082007C0044004407FFC00001FF000101FF0001000100000
+D6C1:01000FE007C00820082007C0044004407FFC00001FF010001FF010001FF00000
+D6C2:01000FE007C00820082007C0044004407FFC000000001FF0044004401FF00000
+D6C3:01000FE007C00820082007C0044004407FFC000001001FF007C0082007C00000
+D6C4:0000010001000FE0000007C00820082007C000003FF801000100010001000000
+D6C5:01000FE007C00820082007C000007FFC010001001FF000100010001000100000
+D6C6:01000FE007C00820082007C000007FFC0100010000003EF80208020802080000
+D6C7:01000FE007C00820082007C000007FFC0100010000001E100210022802C40000
+D6C8:01000FE007C00820082007C0000000007FFC010001001100100010001FF00000
+D6C9:01000FE007C00820082007C000007FFC01000100000020F8201020303ECC0000
+D6CA:01000FE007C00820082007C000007FFC01000100202021FC207020883E700000
+D6CB:01000FE007C00820082007C000007FFC010001001FF01000100010001FF00000
+D6CC:01000FE007C00820082007C000007FFC010001001FF000101FF010001FF00000
+D6CD:01000FE007C00820082007C000007FFC010001003EF802083E0820083E080000
+D6CE:01000FE007C00820082007C000007FFC010001003EF802883E8820883EF80000
+D6CF:01000FE007C00820082007C000007FFC010001003E8802883EF820883EF80000
+D6D0:01000FE007C00820082007C000007FFC010001003E1002103E1020283EC40000
+D6D1:01000FE007C00820082007C000007FFC010001003EF802803EF820803EF80000
+D6D2:01000FE007C00820082007C000007FFC010001003EFC02483E4820483EFC0000
+D6D3:01000FE007C00820082007C000007FFC010001003E2003FC3E7020883E700000
+D6D4:01000FE007C00820082007C000007FFC010001001FF01010101010101FF00000
+D6D5:01000FE007C00820082007C000007FFC01000100101010101FF010101FF00000
+D6D6:01000FE007C00820082007C000007FFC01000100222022203E2022503E880000
+D6D7:01000FE007C00820082007C000007FFC0100010000000100010002800C400000
+D6D8:01000FE007C00820082007C000007FFC010001000000024002400DA033100000
+D6D9:01000FE007C00820082007C000007FFC01000100000007C00820082007C00000
+D6DA:01000FE007C00820082007C000007FFC01000100000007E00080014006200000
+D6DB:01000FE007C00820082007C000007FFC01000100008007E00080014006200000
+D6DC:01000FE007C00820082007C000007FFC010001001FF000101FF0001000100000
+D6DD:01000FE007C00820082007C000007FFC010001001FF010001FF010001FF00000
+D6DE:01000FE007C00820082007C000007FFC0100010000001FF0044004401FF00000
+D6DF:01000FE007C00820082007C000007FFC0100010001001FF007C0082007C00000
+D6E0:0000040804083F8800081F08208820881F0800087FE8040804F8040804080000
+D6E1:04083F880E0811080E0800087FE8027802080000000007F80008000800080000
+D6E2:04083F880E0811080E0800087FE802780208000000003EF80208020802080000
+D6E3:04083F880E0811080E0800087FE802780208000000001F080108011401620000
+D6E4:04083F880E0811080E08000800087FE80278020802081000100010001FF80000
+D6E5:04083F880E0811080E0800087FE8027802080000000020F8201020303ECC0000
+D6E6:04083F880E0811080E0800087FE8027802080000202021FC207020883E700000
+D6E7:04083F880E0811080E0800087FE802780208000003F802000200020003F80000
+D6E8:04083F880E0811080E0800087FE802780208000007F8000807F8040007F80000
+D6E9:04083F880E0811080E0800087FE80278020800003EF802083E0820083E080000
+D6EA:04083F880E0811080E0800087FE80278020800003EF802883E8820883EF80000
+D6EB:04083F880E0811080E0800087FE80278020800003E8802883EF820883EF80000
+D6EC:04083F880E0811080E0800087FE80278020800000F8800880F8808140FA20000
+D6ED:04083F880E0811080E0800087FE80278020800003EF802803EF820803EF80000
+D6EE:04083F880E0811080E0800087FE80278020800003EFC02483E4820483EFC0000
+D6EF:04083F880E0811080E0800087FE80278020800003E1002FE3E3820443E380000
+D6F0:04083F880E0811080E0800087FE802780208000003F802080208020803F80000
+D6F1:04083F880E0811080E0800087FE80278020800000208020803F8020803F80000
+D6F2:04083F880E0811080E0800087FE8027802080000210821083F0821143F620000
+D6F3:04083F880E0811080E0800087FE8027802080000001000100010006801840000
+D6F4:04083F880E0811080E0800087FE80278020800000048004800A8011406620000
+D6F5:04083F880E0811080E0800087FE8027802080000000003F00408040803F00000
+D6F6:04083F880E0811080E0800087FE802780208000003F80020002000D003080000
+D6F7:04083F880E0811080E0800087FE8027802080000004003F8004000A003180000
+D6F8:04083F880E0811080E0800087FE802780208000003F8000803F8000800080000
+D6F9:04083F880E0811080E0800087FE802780208000003F8020003F8020003F80000
+D6FA:04083F880E0811080E0800087FE802780208000000000FF8022002200FF80000
+D6FB:04083F880E0811080E0800087FE802780208000000800FF803E0041003E00000
+D6FC:0000040A040A3F8A000A1F0A208A208A1F0A000A7FEA040A047A040A040A0000
+D6FD:04283FA80E2811280E2800287FA805E804280000000007F80008000800080000
+D6FE:04283FA80E2811280E2800287FA805E80428000000003EF80208020802080000
+D6FF:04283FA80E2811280E2800287FA805E80428000000001F080108011401620000
+D700:04283FA80E2811280E28002800287FA8042805E804281428100010001FF80000
+D701:04283FA80E2811280E2800287FA805E804280000000020F8201020303ECC0000
+D702:04283FA80E2811280E2800287FA805E804280000202021FC207020883E700000
+D703:04283FA80E2811280E2800287FA805E80428000003F802000200020003F80000
+D704:04283FA80E2811280E2800287FA805E80428000007F8000807F8040007F80000
+D705:04283FA80E2811280E2800287FA805E8042800003EF802083E0820083E080000
+D706:04283FA80E2811280E2800287FA805E8042800003EF802883E8820883EF80000
+D707:04283FA80E2811280E2800287FA805E8042800003E8802883EF820883EF80000
+D708:04283FA80E2811280E2800287FA805E8042800000F8800880F8808140FA20000
+D709:04283FA80E2811280E2800287FA805E8042800003EF802803EF820803EF80000
+D70A:04283FA80E2811280E2800287FA805E8042800003EFC02483E4820483EFC0000
+D70B:04283FA80E2811280E2800287FA805E8042800003E1002FE3E3820443E380000
+D70C:04283FA80E2811280E2800287FA805E80428000003F802080208020803F80000
+D70D:04283FA80E2811280E2800287FA805E8042800000208020803F8020803F80000
+D70E:04283FA80E2811280E2800287FA805E804280000210821083F0821143F620000
+D70F:04283FA80E2811280E2800287FA805E804280000001000100010006801840000
+D710:04283FA80E2811280E2800287FA805E8042800000048004800A8011406620000
+D711:04283FA80E2811280E2800287FA805E804280000000003F00408040803F00000
+D712:04283FA80E2811280E2800287FA805E80428000003F80020002000D003080000
+D713:04283FA80E2811280E2800287FA805E804280000004003F8004000A003180000
+D714:04283FA80E2811280E2800287FA805E80428000003F8000803F8000800080000
+D715:04283FA80E2811280E2800287FA805E80428000003F8020003F8020003F80000
+D716:04283FA80E2811280E2800287FA805E80428000000000FF8022002200FF80000
+D717:04283FA80E2811280E2800287FA805E80428000000800FF803E0041003E00000
+D718:0000040804083F8800081F08208820881F0800087FE804080408040804080000
+D719:04083F880E0811080E0800087FE8020802000000000007F80008000800080000
+D71A:04083F880E0811080E0800087FE802080200000000003EF80208020802080000
+D71B:04083F880E0811080E0800087FE802080200000000001F080108011401620000
+D71C:04083F880E0811080E08000800087FE80208020802081008100010001FF80000
+D71D:04083F880E0811080E0800087FE8020802000000000020F8201020303ECC0000
+D71E:04083F880E0811080E0800087FE8020802000000202021FC207020883E700000
+D71F:04083F880E0811080E0800087FE802080200000003F802000200020003F80000
+D720:04083F880E0811080E0800087FE802080200000007F8000807F8040007F80000
+D721:04083F880E0811080E0800087FE80208020000003EF802083E0820083E080000
+D722:04083F880E0811080E0800087FE80208020000003EF802883E8820883EF80000
+D723:04083F880E0811080E0800087FE80208020000003E8802883EF820883EF80000
+D724:04083F880E0811080E0800087FE80208020000000F8800880F8808140FA20000
+D725:04083F880E0811080E0800087FE80208020000003EF802803EF820803EF80000
+D726:04083F880E0811080E0800087FE80208020000003EFC02483E4820483EFC0000
+D727:04083F880E0811080E0800087FE80208020000003E1002FE3E3820443E380000
+D728:04083F880E0811080E0800087FE802080200000003F802080208020803F80000
+D729:04083F880E0811080E0800087FE80208020000000208020803F8020803F80000
+D72A:04083F880E0811080E0800087FE8020802000000210821083F0821143F620000
+D72B:04083F880E0811080E0800087FE8020802000000001000100010006801840000
+D72C:04083F880E0811080E0800087FE80208020000000048004800A8011406620000
+D72D:04083F880E0811080E0800087FE8020802000000000003F00408040803F00000
+D72E:04083F880E0811080E0800087FE802080200000003F80020002000D003080000
+D72F:04083F880E0811080E0800087FE8020802000000004003F8004000A003180000
+D730:04083F880E0811080E0800087FE802080200000003F8000803F8000800080000
+D731:04083F880E0811080E0800087FE802080200000003F8020003F8020003F80000
+D732:04083F880E0811080E0800087FE802080200000000000FF8022002200FF80000
+D733:04083F880E0811080E0800087FE802080200000000800FF803E0041003E00000
+D734:0000010001000FE0000007C00820082007C000007FFC04400440044004400000
+D735:01000FE007C00820082007C000007FFC044004401FF000100010001000100000
+D736:01000FE007C00820082007C000007FFC0440044000003EF80208020802080000
+D737:01000FE007C00820082007C000007FFC0440044000001E100210022802C40000
+D738:01000FE007C00820082007C0000000007FFC044004401440100010001FF00000
+D739:01000FE007C00820082007C000007FFC04400440000020F8201020303ECC0000
+D73A:01000FE007C00820082007C000007FFC04400440202021FC207020883E700000
+D73B:01000FE007C00820082007C000007FFC044004401FF01000100010001FF00000
+D73C:01000FE007C00820082007C000007FFC044004401FF000101FF010001FF00000
+D73D:01000FE007C00820082007C000007FFC044004403EF802083E0820083E080000
+D73E:01000FE007C00820082007C000007FFC044004403EF802883E8820883EF80000
+D73F:01000FE007C00820082007C000007FFC044004403E8802883EF820883EF80000
+D740:01000FE007C00820082007C000007FFC044004403E1002103E1020283EC40000
+D741:01000FE007C00820082007C000007FFC044004403EF802803EF820803EF80000
+D742:01000FE007C00820082007C000007FFC044004403EFC02483E4820483EFC0000
+D743:01000FE007C00820082007C000007FFC044004403E2003FC3E7020883E700000
+D744:01000FE007C00820082007C000007FFC044004401FF01010101010101FF00000
+D745:01000FE007C00820082007C000007FFC04400440101010101FF010101FF00000
+D746:01000FE007C00820082007C000007FFC04400440222022203E2022503E880000
+D747:01000FE007C00820082007C000007FFC0440044000000100010002800C400000
+D748:01000FE007C00820082007C000007FFC044004400000024002400DA033100000
+D749:01000FE007C00820082007C000007FFC04400440000007C00820082007C00000
+D74A:01000FE007C00820082007C000007FFC04400440000007E00080014006200000
+D74B:01000FE007C00820082007C000007FFC04400440008007E00080014006200000
+D74C:01000FE007C00820082007C000007FFC044004401FF000101FF0001000100000
+D74D:01000FE007C00820082007C000007FFC044004401FF010001FF010001FF00000
+D74E:01000FE007C00820082007C000007FFC0440044000001FF0044004401FF00000
+D74F:01000FE007C00820082007C000007FFC0440044001001FF007C0082007C00000
+D750:0000010001000FE0000007C00820082007C0000000007FFC0000000000000000
+D751:01000FE007C00820082007C0000000007FFC00001FF000100010001000100000
+D752:01000FE007C00820082007C0000000007FFC000000003EF80208020802080000
+D753:01000FE007C00820082007C0000000007FFC000000001E100210022802C40000
+D754:01000FE007C00820082007C0000000007FFC000000001000100010001FF00000
+D755:01000FE007C00820082007C0000000007FFC0000000020F8201020303ECC0000
+D756:01000FE007C00820082007C0000000007FFC0000202021FC207020883E700000
+D757:01000FE007C00820082007C0000000007FFC00001FF01000100010001FF00000
+D758:01000FE007C00820082007C0000000007FFC00001FF000101FF010001FF00000
+D759:01000FE007C00820082007C0000000007FFC00003EF802083E0820083E080000
+D75A:01000FE007C00820082007C0000000007FFC00003EF802883E8820883EF80000
+D75B:01000FE007C00820082007C0000000007FFC00003E8802883EF820883EF80000
+D75C:01000FE007C00820082007C0000000007FFC00003E1002103E1020283EC40000
+D75D:01000FE007C00820082007C0000000007FFC00003EF802803EF820803EF80000
+D75E:01000FE007C00820082007C0000000007FFC00003EFC02483E4820483EFC0000
+D75F:01000FE007C00820082007C0000000007FFC00003E2003FC3E7020883E700000
+D760:01000FE007C00820082007C0000000007FFC00001FF01010101010101FF00000
+D761:01000FE007C00820082007C0000000007FFC0000101010101FF010101FF00000
+D762:01000FE007C00820082007C0000000007FFC0000222022203E2022503E880000
+D763:01000FE007C00820082007C0000000007FFC000000000100010002800C400000
+D764:01000FE007C00820082007C0000000007FFC00000000024002400DA033100000
+D765:01000FE007C00820082007C0000000007FFC0000000007C00820082007C00000
+D766:01000FE007C00820082007C0000000007FFC0000000007E00080014006200000
+D767:01000FE007C00820082007C0000000007FFC0000008007E00080014006200000
+D768:01000FE007C00820082007C0000000007FFC00001FF000101FF0001000100000
+D769:01000FE007C00820082007C0000000007FFC00001FF010001FF010001FF00000
+D76A:01000FE007C00820082007C0000000007FFC000000001FF0044004401FF00000
+D76B:01000FE007C00820082007C0000000007FFC000001001FF007C0082007C00000
+D76C:00000008040804083F8800081F08208820881F0800087FE80008000800080000
+D76D:000004083F880E08110811080E0800087FE8000007F800080008000800080000
+D76E:000004083F880E08110811080E0800087FE8000000003EF80208020802080000
+D76F:000004083F880E08110811080E0800087FE8000000001F080108011401620000
+D770:000004083F880E08110811080E0800087FE8000008000800080008000FF80000
+D771:000004083F880E08110811080E0800087FE80000000010F8101010301ECC0000
+D772:000004083F880E08110811080E0800087FE800000808087F081C08220F9C0000
+D773:000004083F880E08110811080E0800087FE8000003F802000200020003F80000
+D774:000004083F880E08110811080E0800087FE8000007F8000807F8040007F80000
+D775:000004083F880E08110811080E0800087FE800003EF802083E0820083E080000
+D776:000004083F880E08110811080E0800087FE800003EF802883E8820883EF80000
+D777:000004083F880E08110811080E0800087FE800003E8802883EF820883EF80000
+D778:000004083F880E08110811080E0800087FE800001F0801081F0810141F620000
+D779:000004083F880E08110811080E0800087FE800003EF802803EF820803EF80000
+D77A:000004083F880E08110811080E0800087FE800003EFC02483E4820483EFC0000
+D77B:000004083F880E08110811080E0800087FE800001F08017F1F1C10221F1C0000
+D77C:000004083F880E08110811080E0800087FE8000003F802080208020803F80000
+D77D:000004083F880E08110811080E0800087FE800000208020803F8020803F80000
+D77E:000004083F880E08110811080E0800087FE80000110811081F0811141F620000
+D77F:000004083F880E08110811080E0800087FE80000001000100010006801840000
+D780:000004083F880E08110811080E0800087FE800000048004800A8011406620000
+D781:000004083F880E08110811080E0800087FE80000000003F00408040803F00000
+D782:000004083F880E08110811080E0800087FE8000003F80020002000D003080000
+D783:000004083F880E08110811080E0800087FE80000004003F8004000A003180000
+D784:000004083F880E08110811080E0800087FE8000003F8000803F8000800080000
+D785:000004083F880E08110811080E0800087FE8000003F8020003F8020003F80000
+D786:000004083F880E08110811080E0800087FE8000000000FF8022002200FF80000
+D787:000004083F880E08110811080E0800087FE8000000800FF803E0041003E00000
+D788:00000000040804083F880E08110820882088208811080E080008000800080000
+D789:000008087F081C082208220822081C0800080000000007F80008000800080000
+D78A:000008087F081C082208220822081C080008000000003EF80208020802080000
+D78B:000008087F081C082208220822081C080008000000001F080108011401620000
+D78C:000008087F081C082208220822081C080008000800001000100010001FF80000
+D78D:000008087F081C082208220822081C0800080000000020F8201020303ECC0000
+D78E:000008087F081C082208220822081C0800080000202021FC207020883E700000
+D78F:000008087F081C082208220822081C080008000003F802000200020003F80000
+D790:000008087F081C082208220822081C080008000007F8000807F8040007F80000
+D791:000008087F081C082208220822081C08000800003EF802083E0820083E080000
+D792:000008087F081C082208220822081C08000800003EF802883E8820883EF80000
+D793:000008087F081C082208220822081C08000800003E8802883EF820883EF80000
+D794:000008087F081C082208220822081C08000800000F8800880F8808140FA20000
+D795:000008087F081C082208220822081C08000800003EF802803EF820803EF80000
+D796:000008087F081C082208220822081C08000800003EFC02483E4820483EFC0000
+D797:000008087F081C082208220822081C08000800003E1002FE3E3820443E380000
+D798:000008087F081C082208220822081C080008000003F802080208020803F80000
+D799:000008087F081C082208220822081C08000800000208020803F8020803F80000
+D79A:000008087F081C082208220822081C0800080000210821083F0821143F620000
+D79B:000008087F081C082208220822081C0800080000001000100010006801840000
+D79C:000008087F081C082208220822081C08000800000048004800A8011406620000
+D79D:000008087F081C082208220822081C0800080000000003F00408040803F00000
+D79E:000008087F081C082208220822081C080008000003F80020002000D003080000
+D79F:000008087F081C082208220822081C0800080000004003F8004000A003180000
+D7A0:000008087F081C082208220822081C080008000003F8000803F8000800080000
+D7A1:000008087F081C082208220822081C080008000003F8020003F8020003F80000
+D7A2:000008087F081C082208220822081C080008000000000FF8022002200FF80000
+D7A3:000008087F081C082208220822081C080008000000800FF803E0041003E00000
+D7A4:00007FFE63866DF66DEE6DDE63DE7FFE7FFE61B66DB661866DF66DF67FFE0000
+D7A5:00007FFE63866DF66DEE6DDE63DE7FFE7FFE61866DBE61866DF66D867FFE0000
+D7A6:00007FFE63866DF66DEE6DDE63DE7FFE7FFE61CE6DBE618E6DB66DCE7FFE0000
+D7A7:00007FFE63866DF66DEE6DDE63DE7FFE7FFE61866DF661EE6DDE6DDE7FFE0000
+D7A8:00007FFE63866DF66DEE6DDE63DE7FFE7FFE61CE6DB661CE6DB66DCE7FFE0000
+D7A9:00007FFE63866DF66DEE6DDE63DE7FFE7FFE61CE6DB661C66DF66DCE7FFE0000
+D7AA:00007FFE63866DF66DEE6DDE63DE7FFE7FFE61866DB661866DB66DB67FFE0000
+D7AB:00007FFE63866DF66DEE6DDE63DE7FFE7FFE618E6DB6618E6DB66D8E7FFE0000
+D7AC:00007FFE63866DF66DEE6DDE63DE7FFE7FFE61C66DBE61BE6DBE6DC67FFE0000
+D7AD:00007FFE63866DF66DEE6DDE63DE7FFE7FFE618E6DB661B66DB66D8E7FFE0000
+D7AE:00007FFE63866DF66DEE6DDE63DE7FFE7FFE61866DBE618E6DBE6D867FFE0000
+D7AF:00007FFE63866DF66DEE6DDE63DE7FFE7FFE61866DBE618E6DBE6DBE7FFE0000
+D7B0:0040003000100010001003F00110001003F0011000100C1004D0071078100000
+D7B1:00000000000000000000000000000000030001001FF001003FF8000003000100
+D7B2:004000300010001000100010001000100010001001900C9C04F0071078100000
+D7B3:0048003600120012001200120012001200120012031E191209F20F1278020000
+D7B4:00080006000200020002000200020002001E00020302193209C20F0278020000
+D7B5:0008000600020002000200020002000200023FF20202021E0202021E00020000
+D7B6:0010008C006400240024002400240024002400247FE404240424042400040000
+D7B7:00480036001200120012001200120012001E00127FF211121112111200020000
+D7B8:00000000000000000000000000000000000000003FF808200BA000803FFC0000
+D7B9:00800060002000200020002000200020003C00200020002000E0072078200000
+D7BA:00080006000200020002000200020002001E00020002000200E2070278020000
+D7BB:00480036001200120012001200120012007200120012001200D2071278020000
+D7BC:00000000000000000000000000000000000000003FF80000038000803FFC0000
+D7BD:00000040013000D000500050005C00500050005C005000500E1002003FFC0000
+D7BE:0090046C03240124013C01240124013C01240124012401240024000400000000
+D7BF:011000CC00440044005C00440044005C00440044004400440044000400000000
+D7C0:0410034C01340114011401740114011401740114011401140114001400040000
+D7C1:000000200018000800080008000800080008070801003FF80000070001000100
+D7C2:00000020001800080008000800080008000839C808403FF80000000000000000
+D7C3:000000200018000800080008000800080008000800003FF80840084000000000
+D7C4:0048003600120012001200120012001200120012001200120012001200020000
+D7C5:00800060002000200020002000200020003C0020302038200820002000200000
+D7C6:0010008C00640024002400240024002401E40024302438240824002400040000
+D7C7:00007FFE63866DF66DEE6DDE63DE7FFE7FFE71866FF66FEE6FDE71DE7FFE0000
+D7C8:00007FFE63866DF66DEE6DDE63DE7FFE7FFE71CE6FB66FCE6FB671CE7FFE0000
+D7C9:00007FFE63866DF66DEE6DDE63DE7FFE7FFE71CE6FB66FC66FF671CE7FFE0000
+D7CA:00007FFE63866DF66DEE6DDE63DE7FFE7FFE71866FB66F866FB671B67FFE0000
+D7CB:0000000000000000000000000000000060FE2002200220FE2080268038FE0000
+D7CC:000000000000000000000078C00043FE402040304C4871840000000000000000
+D7CD:000000000000000000000000000000000000FDF8208020802080268018780000
+D7CE:00000000000000000000000000000000FFB62212221E22122212265E19920000
+D7CF:00000000000000000000000000000000FD98208820F82088208826F818880000
+D7D0:0000000000000000000000000000000000007C38200820082018262438C20000
+D7D1:00000000000000000000000000000000000078EE2022202220622492390A0000
+D7D2:0000000000000000000000000000000000007C7E200820082018262438C20000
+D7D3:00000000000000000000000000000000003C7C00207E20082018262438C20000
+D7D4:00000000000000000000000000000000000000007EFC1040107C13400C3C0000
+D7D5:00000000000000000000000000000000000000003DDC04443C4420443C440000
+D7D6:0000000000000000000000000000001C3DC0047E04483C5C206220623C5C0000
+D7D7:00000000000000000000000000000000000000007BDC08447BDC42047BC40000
+D7D8:0000000000000000000000000000001C7BC00A7E0A487A5C426243E27A1C0000
+D7D9:000000000000000000000000000004807A5E0A480BC87A48424843C87A4E0000
+D7DA:0000000000000000000000000000049E7A440A420BD27A4A424243C47A5E0000
+D7DB:000000000000000000000000000000083C08041C04223C22202220223C1C0000
+D7DC:0000000000000000000000000000000EF780101F1304F48E84918491F30E0000
+D7DD:000000000000000000001FF800081FF810001FF8000003E00410041003E00000
+D7DE:0000000000000000000000000000000000007DC044404440444044407C3E4000
+D7DF:0000000000000000000000000000000000007B30491049104910491078CC4000
+D7E0:00000000000000000000000000000000000000003E7C2244224422443E7C2040
+D7E1:0000000000000000000000000000000000000480F4889784948C9492F7A18000
+D7E2:00000000000000000000000000000000000000003EFC2220223022483E842000
+D7E3:000000000000000000000000000000004400227C22203E20222022203E3C0000
+D7E4:0000000000000000000000000000000049DE244424523DCA250225043DDE0000
+D7E5:000000000000000000000000000000004400227C22443E44224422443E7C0040
+D7E6:000000000000000000000000000000004488224422443E7C224422443E7C0000
+D7E7:000000000000000000000000000000009000485E4848788849484A287A2E0000
+D7E8:000000000000000000000000000000004400220022FC3E20223022483E840000
+D7E9:000000000000000000000000000000004478220022FC3E20223022483E840000
+D7EA:0000000000000000000000000000000000000800047C04440C441244617C0040
+D7EB:00000000000000000000000000000044007C0844047C04000C38124461380000
+D7EC:000000000000000000000000000000000000123C0904090419042684CC440000
+D7ED:000000000000000000000000000000000000123E0910091019102690CC5E0000
+D7EE:00000000000000000000000000000000000010200810082818442482C2FE0000
+D7EF:000000000000000000000000000000000000000010FC082018302448C2840000
+D7F0:000000000000000000000000000000000078100008FC082018302448C2840000
+D7F1:000000000000000000000000000000000000100008FC0840187C2440C23C0000
+D7F2:000000000000000000000000000000380000107C0810083818442444C2380000
+D7F3:0000000000000000000000000000000001102088108828F844888288FEF80000
+D7F4:0000000000000000000000000210010801F8210811F8287044888270FE000000
+D7F5:000000000000000000000000000000000800087C1C442244224422441C7C0040
+D7F6:000000000000000000000000000000380800087C1C102238224422441C380000
+D7F7:00000000000000000000000000000000000000003F4404440C7C1244217C0040
+D7F8:000000000000000000000000000000000000000001297D2911EF292945EF0108
+D7F9:00000000000000000000000000000000000000007EFC08201830244842840000
+D7FA:000000000000000000000000000000007800104048202820086010907B080000
+D7FB:0000000000000000000000000000000078FC10404840287C08401040783C0000
+D7FC:00007FFE63866DF66DEE6DDE63DE7FFE7FFE61C66FBE63BE6FBE6FC67FFE0000
+D7FD:00007FFE63866DF66DEE6DDE63DE7FFE7FFE618E6FB663B66FB66F8E7FFE0000
+D7FE:00007FFE63866DF66DEE6DDE63DE7FFE7FFE61866FBE638E6FBE6F867FFE0000
+D7FF:00007FFE63866DF66DEE6DDE63DE7FFE7FFE61866FBE638E6FBE6FBE7FFE0000
+F900:0080108810881FF8100800007FFE00000FF008100FF00810042002447FFE0000
+F901:00047FFE008010841FFE10841FFC10841FFC10840880050003000CC0703E0000
+F902:010001047FFE010011081FFC11081FF811081FF8110801047FFE010001000000
+F903:FFFE04403FF824483FF800001FF010101FF010101FF010101FF00C60F01E0000
+F904:410821FC21080978894857FE540421F82108C1F8410841F8C108C13841100000
+F905:010001083FFC210821083FF8210801047FFE410441047FFC4104010001000000
+F906:0800080008041FFE200440041FC41044104410441FC410440044003800100000
+F907:08400FE0084010807FFC11447F7C05447F6C05547D6C05447F7E05027CFC0000
+F908:08400FE0084010807FFC11447F7C05447F6C05547D6C05447F7E05027CFC0000
+F909:080008027F7E08127F1208127F22084E098401007FFE020002C00C30700E0000
+F90A:0080018002400420081010086FF6010001083FFC01001118091009247FFE0000
+F90B:01029142FFE29112911297D29552955297D29552F39295420922111E01040000
+F90C:020002047FFE02400420181867E6000000083FFC00801890108C238441040000
+F90D:2214221E2FD42224B27EAFA2AABEAAA22FBE2222233E26A22A94222222422000
+F90E:010010841FFE92205FBC52481FBE12A232BEDFA2923E232226BE4A9492220000
+F90F:3FFC224422443FFC0844109024FE79900A9014FC7E9000FC34902A904AFE0000
+F910:04207FFE04201FF812481FF808A012903DFE0A9014FC7E9028FC549054FE0000
+F911:110411FE112455FC7F2455FC544455F87C2455FE109214101A94E37242220000
+F912:41FC21242924FDFC092411FC2524282073FEAC20247020A82126222220200000
+F913:07FE4492349217FE024804FE1748FAFE17C8107E15481AFE3040C80087FE0000
+F914:2108210847D05454E7F824485454FFFE45500104FFFE05200910310EC1040000
+F915:2100110811FC010842902C9028601198160661F821082108610861F821080000
+F916:1080108810FC108855505920523050C8930610FC18842484248440FC80840000
+F917:00800888FCFC1108129010601060FD98120611F815081908E10841F801080000
+F918:04407FFE0440244011F8150845902A600890110817FE6108210821F861080000
+F919:0420FE24283E2824FE44AAA8AA10AA28CE4482FEFE4482448244FE7C82440000
+F91A:44407E48487C48887F4848307E3048487E8643FC02845684AA84AAFC0C840000
+F91B:0720F92091204A20FF201420FFA092A0BDA080A0BEA094A28CA292A2A39E0000
+F91C:02002744387E224432442A542A54224C224426443A44225C0448084070400000
+F91D:13DE125213DEFE5213DE12223BFE562253FE92AA93FE1222127212AA13260000
+F91E:13DE125213DE125257DE5A2253FE522293FE12AA1BFE262222B2432E82240000
+F91F:04207FFE04207EFC42847EFC42847EFC41045FF44AA44FE441044544593C0000
+F920:1208110827D0783C2792783E2BA852940FE008200FF808000FFE292244940000
+F921:0080208420843FFC00003FF820282FC821082FE829282FEA410A41269FD20000
+F922:47D02510251407DE845057D85524252427C0C00047FC44A4C4A4C4A44FFE0000
+F923:04207FFE04203F0024243F3E21403F9024083F8800001FF8124812487FFE0000
+F924:43E822882A88FFCE0A5013E826842A8473E0A80027F822A822A822A827FE0000
+F925:100010401020FC2413FE1000140C1908F1085090109010909020702427FE0000
+F926:49247E484A4849244BFC7AA44A544BFC48407B684AD84B684ADABB6692420000
+F927:212422482248A924FFFCAAA4AA54ABFCF800AB6822D82B6836DAE26643420000
+F928:010020843FFE240022BE2FE428A42FA828A82FA428A229322BAC4CA088200000
+F929:10444A7E7F44424442447E7C424442447E444A7C44444A4452A4E11C42080000
+F92A:2080124813FC020842082BF82A08120813F86244224822306290670822060000
+F92B:00404C20292411FE310449FC890419FC294249448928091049483B8611020000
+F92C:1024093E3FA4212421283F28212821243F242122242222322D2C712020200000
+F92D:010001047FFE010011101110111029284384054009201110210C410401000000
+F92E:0040804060A02890090812461422282023FCC0084010402041C0402000100000
+F92F:04101554165824900A2811443FFE200241043FF8010802080488087030200000
+F930:107C124013FEFE4413FA124216FE1AA4F3FE52A412FC122095FE7842239C0000
+F931:109010F81110FFFC112411FC392455FC5554924A91FC110411FC110411FC0000
+F932:107C124013FE124457FA5A4252FE52A892F812A81AF8240025FC495497FE0000
+F933:011001F821003FFE21042FF8210223FE224823F822482FFC292449249FFE0000
+F934:01000100010C3FE8011001247FFE0080010006300CC017046404040603FC0000
+F935:04207FFE04A010F81FFE11041FF8110213FE124813F8124817F825285FFE0000
+F936:01F801003FFE21042FF0210227FE24483FFE244827F820802FFC41048E380000
+F937:00407C44447E448445487C305448108651025CFC508450845C84F0FC40840000
+F938:1FF841027FFE81043D7801403E7822483ED02B30084E2EF828887EF820880000
+F939:04400FE010883FFC51081FF811081FF8244422224FF208100FF008100FF00000
+F93A:3E7C22443EB808442EFA28887FF810101FF010101FFC10001FFE292244940000
+F93B:0044047CFE88108811F020103FFE6420A52224B4246827A43D2224E200400000
+F93C:208410FC1088FD0805F0081013FE3020592C94A8147010A8172612E210400000
+F93D:108810FC2088250845F0F81013FE2820FD2C44A8007028A8552656E280400000
+F93E:042004207FFE042003E0022007E000447FFE108808D006A00890738E21040000
+F93F:1044187C1444228840F8FC1011FE1020FF2694B4586851A81E26F0E240400000
+F940:010020843FFE222022243FFE22243FFC280428202FA4283829A25E22883E0000
+F941:202010201050FC88010602FA780003FE7A5202527BFE4A524A527A524A460000
+F942:087E7F40147C7F04227C3E40227C3E40227E2E42243E00801FF800847FFE0000
+F943:7FFC010001103FF8010001047FFE082008247FFE082008201020202040200000
+F944:10401F7E289045483F7E2240147C7F04227C3E40227C3E40227C2242263E0000
+F945:08807EFC14807FFC22043EFC22803EFE22827FFE08100FF008107FFE00100000
+F946:010020843FFE2004490809100FF81100210001047FFE01000100010001000000
+F947:00047FFE020007F00C10141067F002047F7E10201E3C326452A41E3C12240000
+F948:44807E8444FE44847D48463044487C86450244FC7C844484288444FC84840000
+F949:1FF841027FFE81043D7801003D78010020083FFC21083FF821083FF820080000
+F94A:1FF011101FF011101FF01010FEFE9292FEFE9292FEFE01103FF80104FFFE0000
+F94B:3FFC200420043FFC24883FFE24882FFC28842FFC21003FFE222041609F9E0000
+F94C:102011FC112413FEFD2411FC182035FC552451FC904097FE1090107017CE0000
+F94D:2080124413FE020442042BFC2A041228122463FE222024506488690632020000
+F94E:440427FE240407FC840057FE542027FE2622C73246AA4B32CAAAD2AA62260000
+F94F:1FFC10841FFC10841FFC1104022004601F8002083FFC108404A01B9861060000
+F950:1020102021FC252447FEF92413FE2A22FFFE442003FE288855905460839E0000
+F951:8804F9FE88109090A2FEA292929292928AAA8AC6CA82B29E8284820083FE0000
+F952:22202220FFA022243EFE08247F24492449247F240844FF44088408BC09080000
+F953:24203E202420242425FE3C242424242424243C242444244424A45D1C88080000
+F954:00408FFE60002BFC0A9412F4120423FC2000C3F840404FFE4248444408420000
+F955:0040804863FC2840084417FE11082204248AC1FC430844904860419E0E040000
+F956:04200E28F1FC102015FEFE481086194236785088914812301050118E16040000
+F957:102011FC2020242447FEF88811042A82FCF84508028828505460559886060000
+F958:042004207FFE05201FF801007FFE04201A1863F604201A4001800670780E0000
+F959:8848FBFC88409044A7FEA090910C928488F88988CA90B4A0806081988E060000
+F95A:202013FEFC2001FC00007BFE025203FE790401FC790449FC490479FC4B060000
+F95B:080408FE7F44122824101A2811C660381FC000881FFC00807FFE008007800000
+F95C:2108210847D05454E7F824485454FFFE45500104FFFE05200910310EC1040000
+F95D:2088108813FEFC8800A80020782403FE784000FC79844A844C8478FC48840000
+F95E:00100FF80810081009100890089008107FFE0810081010101090207040200000
+F95F:010020843FFE250454A827E400001FF812487FFE00003FFC0080078001000000
+F960:080008040BFE7E44124424481C300A48118660020500248824A6242243F00000
+F961:010000847FFE01042248179001001A5067EC452401007FFE0100010001000000
+F962:10081FFC11081FF811081FF8144804403FFC044004447FFE0420181860060000
+F963:088008800880088C0888F89008E008800880088008801884E8844886087C0000
+F964:000E09F0FC26212420A823FE3CA86524A62225FE252225FE3D2225FE21020000
+F965:100417FE1040244427FE244467FCA44427FC244422402140208021402E3E0000
+F966:190411FE220045FC990411FC210461FCA08021FC230824902060219826060000
+F967:00047FFE008000800100030005200910110C2106410201000100010001000000
+F968:20001040102404244488288828881290129464A224A220C061846284247E0000
+F969:08407F404940FFC4497E7FC808487F4849487F481028FF90222C1C46F3820000
+F96A:01083FFC010021043FFE210442281FC0011002083FF4008404A01B9861060000
+F96B:0100022007D0101024247B7E018202407CBC03001C4001981E6001801E000000
+F96C:010020823FFE42241FFC02201FFC02207FFE0490088817F6208200847FFE0000
+F96D:01000D10090811662142408001080FFC18086FF808080FF808080FF808080000
+F96E:04207FFE042009107FFE091009F008000FFC00807FFE02C004A0189860860000
+F96F:210810881090FE2001FC0104FD040104FDFC0154FC5084508492FD12860E0000
+F970:028842FC248818882688410E140012FCFF84104838485430922810C613020000
+F971:10041FFE1000101017F8100010041FFE124012481250222022904F0884060000
+F972:204010401040024443FE2A442C48104010406040204020A061226222241E0000
+F973:1040104010A0FD101208100615FA1800F10851FC11081108910871F821080000
+F974:042004207FFE04200420010001047FFE020004080FFC1408640807F804080000
+F975:104010201024FFFE100011FC15041904F1FC5124102011A8912472E224420000
+F976:008044847EFE54845548543054487C86550254FC54847C84448400FC00840000
+F977:020001047FFE00000FF008100FF000003FFE200247C4044004421842603E0000
+F978:00047FFE010001047FFE41045144492449245554659441044124411C40080000
+F979:00808040604427FE080013FC1204220423FCC22440204230452848E410440000
+F97A:10080BFC4048254C094A0A4A30B8131010847FFE02C004A00890108E60840000
+F97B:11FC110495FC550459FC1000FDFE112419FC352455FC902011FC102013FE0000
+F97C:010008900FF8081008100FF0081008100FF00900088C08700B203C1810060000
+F97D:204010201024FFFE000001FC7D0401047DFC01247CA844A445227EE244400000
+F97E:1FF010101FF010101FF000047FFE11101FF011101FF001003FF801007FFE0000
+F97F:7FD049107FD049125FFE52525FD252525FD242125FD2525253D29C6E90C40000
+F980:08100FF80810081008100FF00910010012081FFC1008100810081FF810080000
+F981:020003000200020002047FFE042004200820082010400E8001800670780E0000
+F982:21043FFE208020F828802FFE28842FF82A4A2BFE2A482FF82D285528AFFE0000
+F983:104008400844FEFE2080251C3EE024A624A424982490249024A85DC688820000
+F984:4048207C244007FE844457FA544225FE2524C5FC452445FCCA94CA8A44FA0000
+F985:03FE0A48FFFE224822FC22947AFCCA944AFC4A104AFE4A927AFA4C8608820000
+F986:7E7E42427E7E42427E7E400247E2442247E241024FF248124FF2481E40040000
+F987:89DCFC0093FE92AAFEAA9020FDFE9150FDFC855405FC5594AED8A49218EE0000
+F988:3E7C00003E7C2A542B5400803FFC22403FF822483FF828522F6248429F3E0000
+F989:0E407842087E7E920C221A42299E4A4404A01898649603E004903B8C11040000
+F98A:01000100010001083FFC01080108010801080208020804080888107060200000
+F98B:3FFE21082E7022143FFE221027382AD4329227F8240827F8240847F884080000
+F98C:20043FFE20842F7822103FFE221027382AD6321220402440247C44409FFE0000
+F98D:21242124FD7422DAFB74A954FAFAAF56F820A82423FEFEB02128222624220000
+F98E:0C0008080FFC1080208048880FFC0880088008847FFE00800080008000800000
+F98F:124C1148115017FE58D055485246920813BE14881AA8117E1108120814080000
+F990:1204110427C8701C23C84812FBFE5254AA6AABAA040025042492241243F80000
+F991:1210121413D2FA9012FE159012901990F12852461C8210009324749228920000
+F992:4020282427FE042081FC512455FC2F2425FCC42047FE4420C420DA2051FE0000
+F993:1020102413FE102057FE5A22532652AA93FE1222187024A82526422280200000
+F994:00101410FAFE2210207E2052207EFF52217E2152211039FEE1104690047E0000
+F995:002000F03F000104FFFE054009203118C0761F800108FFFC0100010001000000
+F996:102413FE202027FE4622FB2612AA2BFEFA224420007028A85526562280200000
+F997:0488FE88255227BC3C88255427DC3C22255427542D54F5DC4454049005100000
+F998:08103F7C08107F7E142822C440823FFE08880FF808880FF800807FFE00800000
+F999:04207FFE0420204017FC104003F8024873F8124813F8104017FC684047FE0000
+F99A:0040404437FE104003FC024413FCFA4413FC1244104017FE3040C84087FE0000
+F99B:1020182415FE222041FEFD2211A6116AFFFE9522587050A81F26F22240200000
+F99C:01027F820822082209220FA21122312249220A22042204020812100E60040000
+F99D:0100010019181106211A402001C00680188467FE0084010402240C1C30080000
+F99E:020293FEFA229222922293FA9222922292629252F28A930A020203FE02020000
+F99F:01047F84082408240FA41124312449240A04041C780800002444222242220000
+F9A0:01047FA408241F2431240A243D1C00887FFE028004480C50742007180C060000
+F9A1:210810881090FE2001FC0104FD040104FDFC0154FC5084508492FD12860E0000
+F9A2:21043FFE222021442FFE21402FF821483FFE21482FF8214023604550994C0000
+F9A3:01000280044008201110608C00000FE000200140048024842412441203F80000
+F9A4:102010201050FC881126121215FC1808F010501012C412A2928A7488207C0000
+F9A5:0420FE202050208825763E0225DC6554955415DC0800088810882156C2220000
+F9A6:10401F7E28907FFE24202FFC22402FF822483FFE22482FF826504A48B2460000
+F9A7:01244E482A48112433FC4A548AA41BFC28404B688AD80B6A4A5A3B6612420000
+F9A8:008001800240042009101088208640121FF8001000200640018000C000400000
+F9A9:20043FFE2104218422442524389C20042FF420442384208420843FFC20040000
+F9AA:010020843FFE250454A827E400001FF812487FFE00003FFC0080078001000000
+F9AB:108410841FFC00000BFE142022FC498404FC7F8402FC048438FC044805860000
+F9AC:1040104010A011105A0854465422902013FC1008101010A01060103010100000
+F9AD:00200860FC501088110412421022FC20100811FC14081810E0E0401000100000
+F9AE:08102A542C584890142822447FFE40043FF8010001001FF8012001147FFE0000
+F9AF:442024202850FE50108810A67D12101010FCFE04100810D02020401080100000
+F9B0:0220FF20245024503C88254626223C20240025FC2E08F4484430041004100000
+F9B1:10201820145022884106FE4210201020FE0495FE580850501E20F01040100000
+F9B2:1FF841027FFE81043D7801003D7806C01930E08E0FF000200040038000600000
+F9B3:1FF841027FFE81043D7801007BDE4A527BDE00007FFC091019302548FFFE0000
+F9B4:080409FE082014FC2284498484FC04847FFC0284248418FC0884085803860000
+F9B5:080008420FE21212125233F25452965219521092109211121102121E14040000
+F9B6:205011FC1154FDFC055409FC100033FE580095FC150411FC1088105013FE0000
+F9B7:0428FEFE28AA28FEFEAAAAFEAA00ABFECE0082FCFE8482FC8284FE4883FE0000
+F9B8:10201024FFFE18243424D3FE10247DFC0124FEA210B4586897A4B12210620000
+F9B9:00047FFE02403E7C200420043E7C02407FFE0000048024442452241243F80000
+F9BA:00083FFC00080010002000C00080008000800080008000800880078001000000
+F9BB:084008440FFE10A2151433F8560C9BFA120813F810401248144419C210420000
+F9BC:010020843FFE21045FFC24281FF028184FF608100FF000800CB0138C21040000
+F9BD:10041FFE100410041FFC104410401F4C1268125012502448244649C240800000
+F9BE:0808490849482A2828280A08FF4808280C281A0E2A3849C88888080808080000
+F9BF:2108210847D05454E7F824485454FFFE45500104FFFE05200910310EC1040000
+F9C0:1040104017FE14A2531455F85B0C55FA910811F818202528262444E288420000
+F9C1:008010441FFE90405FFE551413F8120C37FADA0893F82040225045C888860000
+F9C2:04207FFE042000007EFC12240E1C326403800C60771E00600F9800603F800000
+F9C3:0040404437FE1294010803FC150AF9F8110811F81128122634E2C84087FE0000
+F9C4:104008447F7E2240147C7F04007C3E40227C3E40227C3E40227E2E42243E0000
+F9C5:10101FF810101FF050127FFE81047FFC11101FF011101FF001007FFE01000000
+F9C6:44087DFC44004800500453FE48904890449044906490591242124412480E0000
+F9C7:180267C242524A525A5265929E122112DED204127F922492150217DE7C040000
+F9C8:100813FC10881088FC881088188837F854885088908890881088108817FE0000
+F9C9:104010D2131E1252FE5212521A523652525253D2925290561092111012100000
+F9CA:2080104417FE0040409029082BFC1004124862482248224A624A644A28460000
+F9CB:408025FE2612041284925562564E24842000C7FC444447FCC444C7FC44040000
+F9CC:00400824FDFE10201040108811FCFC041128112815281928E22A442A08260000
+F9CD:0200270438FE204422447D5C20881FF8108810881FF8108810881FF810080000
+F9CE:00400424FFFE1040108823FC3C846400A4A824A824A824A83D2A222A04260000
+F9CF:1000100423FE24444444F84410442844FDFC4484008428845484548487FE0000
+F9D0:49042AFE2A10087C7F441C442A7C49440A7C09447F44087C1444222842C60000
+F9D1:020001000180008000047FFE0000000004200420081008101008200640020000
+F9D2:F720112855243320552699F808201422E3A2082472280D12722A0C46F1820000
+F9D3:8840F8488BFC9040A044A7FE9090910C8A448840C848B3FC804080448FFE0000
+F9D4:0840086008901108121635FA500097FE1492149217FE14921492149214860000
+F9D5:0100210821083FF8210802800C60F7DE00003FF824483FF82448244824180000
+F9D6:204010C010A0011042082DF6280017FC14A464A427FC24A464A464BC24080000
+F9D7:10201020FE5010887D0656FA54007DFC55547D5455FC1154FF541154110C0000
+F9D8:184813FC204840489FFE104823F86048A04023FC2040204427FE204020400000
+F9D9:100417FE109013FE5A92569253FE9202102417FE102011B01128122614220000
+F9DA:00047FFE02401FF8124812481FF8108800847FFE02C004A00890108E60840000
+F9DB:010000847FFE01042248179001001A5067EC452401007FFE0100010001000000
+F9DC:8908FDFC8A089090A060A198960691F888008928CBFCB42081FC802087FE0000
+F9DD:010207827C1204120492FFD204120E1215122492449284020412040E04040000
+F9DE:008000847FFE008010841FFE108410841FFC108408800480030004C0783E0000
+F9DF:3FFC20043FFC208024FE298432FC228424FC2C40347C24C82530444885860000
+F9E0:08100FF808100FF008100FF0081004040FFE1124222444440884113802100000
+F9E1:010001047FFE05400920111861060FF0004000847FFE00800480038001000000
+F9E2:03043C2404247FA40C241624251C448800847FFE02C004A00890108E20840000
+F9E3:220413FE1204020443FC2A042A40124C124862502260244064426842303E0000
+F9E4:010409FEFD24112411FC11241124FDFC11241020142019FCE020402407FE0000
+F9E5:010010841FFE908051C25712111217D23112D192935225522902411E81040000
+F9E6:3FFC224422443FFC2044112011FE5B20552091FC112011FC1120112411FE0000
+F9E7:01047FFE00000FF808880FF808883FFC00807FFE028804501CA0651806060000
+F9E8:410421FE2924FD2409FC1124252429FC7124AC20242021FC2020202427FE0000
+F9E9:10081FFC110811081FF8110811081FF81108010001083FFC010001047FFE0000
+F9EA:10500848FFC8557E494849C8557E7F4808487F48497E55487B48417E47400000
+F9EB:40047FFE422042205FFC42A041045FFE420047F84A08520843F842087FFE0000
+F9EC:408227BE20820082879E5492541027BE28A2C4924186469AD8E2C71C42080000
+F9ED:010000847FFE08100420024001800E70700E1FF81008100810081FF810080000
+F9EE:1222112410A813FE54A859245222510891DE124819A824BE2508420884080000
+F9EF:02221124F8A823FE20A821242222FA0823BE228826A839FEE108420804080000
+F9F0:04207FFE04203E7C22443E7C22443E7C27E42C8437E4248427E4249C27E80000
+F9F1:8A4CF948895097FEA150A2489C4692088BBE8C88CAA8B13E8208840888080000
+F9F2:21243D2424A84BFCFCA8552456227D0855FE55487F4844E854BEAB08AA080000
+F9F3:08A444647F2854FE7F28556455A27F0454EE54A45D2456B4545E5D8497040000
+F9F4:08200820082008247FFE082008201CB02AA8292849244A240C22082208200000
+F9F5:42102210221002948FFE52105310229026B8CA5452525212C210C21042100000
+F9F6:8480FE8490FE910092F8FC88848884F88400FFDE925292529252FFDE82520000
+F9F7:02000100008000883FFC000008100810042004200240024000847FFE00000000
+F9F8:102010201F3E285044880100008000883FFC042004200240024000847FFE0000
+F9F9:104092209220540455FE1000FE84108418883448524852509010901013FE0000
+F9FA:044024502448244824403FFE045004507C502450244824482484450686020000
+F9FB:0200021007F80C203240088007000C807098089008A0114002200C1830060000
+F9FC:2110109013F4FD52015200907BFE00107BD202527BD44A484BCA7A5648220000
+F9FD:08400840084010401040304057FE904010401040104010401040104010400000
+F9FE:042004207FFE0420058002400420189860861FF8008004A00890108E60840000
+F9FF:08020882FFD208128892FFD2889288928B9288921C122A024992888E08040000
+FA00:2000200423FE204424442E44F044204422442444284430842144023804100000
+FA01:010020843FFE222022243FFE222023E0200027F82210212020C043309C0E0000
+FA02:1000100413FEFC4010401040148419FEF284548410841084908470FC20840000
+FA03:1040112495FE552059FC1124FDFE112419FC352055FC9284128414FC18840000
+FA04:020041087FFC4008809001C07E000410043807C0FC0004040404040603FC0000
+FA05:220413FE1204020446F42A042A0412F41294629422F422946204621C22080000
+FA06:1FF010101FF010101FF004403FFC04407FFE11102928474405C01930630C0000
+FA07:11FE1000FEFC10847C8454FC7C0055FE7D22552211FEFF22112211FE11020000
+FA08:180811FC200040000C040BFE1010301050109010101010101090107010200000
+FA09:44887CFC44884950502050504B8E482045FC44A065245BFE4020402040200000
+FA0A:00201FF0102010201FE0102010201FE0102010201FE014A408843086C07C0000
+FA0B:20843FFE22003FDE20122F9428942F9820143FD22112221A2F9442108E100000
+FA0C:0008FFFC08800880088008800880088008801080108420844086807C00000000
+FA0D:0848087C7F4808483F48008E7F0082FE3E4400443E28221022283E4622820000
+FA0E:10500848FEFE459026FC189008FC149024FEC0803FF00820044003800C60F01C
+FA0F:2090208821042240F84020A020902108220425FA21083908C108010801F80108
+FA10:120213FE1404100013FEFC401086174412A811301EE8E0A84124062200C00000
+FA11:204020202BFEA800A908A890AFFEA808ABC8AA48AA48BBC8CA48000800280010
+FA12:00204BFE7C2049FC48204FFE780049FC490449FC490479FC4904011C01080000
+FA13:1088108813FE1088FC8810443884357E51045324951411141104110411141108
+FA14:12441124108813FEFC9011083A1434E2502051F8902013FC1020102010A01040
+FA15:8BD46A9E2A940A941BD42A5C2A54CBD04A92529263EE00002444222242220000
+FA16:00404C40284611F4304848508BFE184029FC4B04890409FC490439FC11040000
+FA17:08300420024002447FFE04200810100C60041FF812481248124812487FFE0000
+FA18:00403E40004000407F4008402A402A402A402A404A404A4008420842083E0000
+FA19:202010201124FDFE0524092411FC31245924952415FC11241020102010200000
+FA1A:210C10881050FFFE04200820102031FC58209420142413FE1020102010200000
+FA1B:200413FE1000FCF80488088810F8300059FC952415FC1124112411FC11040000
+FA1C:202023FE102011FCFC2003FE440045FC290429FC11041DFCE104411C01080000
+FA1D:102413FE922054FC542011FEFE0010FC188434FC528492FC1084109C10880000
+FA1E:02047FFE0E1C121422244244060C0A14122422444284020412240E1C04080000
+FA1F:0440FFFE044004403EFC228422FC3E8422FC22403EFE232222D2428A4AF2840C
+FA20:0820FFFE08A01CF0F11012F810A8FCF810A831FC392455FC552491FC1022101E
+FA21:202021202120F9FCAA20AC20A820A820A9FCF820A820202028203820CBFE0000
+FA22:204010401044FDF4004800507BFE004079FC0284788448FC488478FC48840000
+FA23:100810481028FE08108810481008FE0E11F810085C085008500870088C0083FE
+FA24:000023FC10880888409020BC10840084F0C411481128121014282844448283FE
+FA25:011041F83110122407FE02441244FBFC106010A811261622301EC80087FE0000
+FA26:082408BE3EA409240A287FE8042809241FA431225F221132112C1F2011200000
+FA27:1020102029FE4424B82813FE10207C4010FC1308541039FE10101C10E0500020
+FA28:1020102029FC4420B82017FE11047C8811FC102054203BFE10201C20E0200020
+FA29:00407C8045F8490849F8510851F8490045FE450045FC5884449447F440044018
+FA2A:1008189C14E02A804884BEFE22A43EA422A83EA820A8249026A87B4622820000
+FA2B:100019FE14022A0248FABE0222F23E9222923E9220F2249226027A1E20040000
+FA2C:1020181014922AFE4904BEF822883E8822F83E8020FC248426847AFC20840000
+FA2D:1030102092FCFE84A2FC28847EFC4880FEFE48807EFE480248AA7F5641540000
+FA2E:0800087C7E44424842487E50424842487E4451444A4444684450524062404040
+FA2F:10201020FCFC102411FE7C2400FC7C200124FCA8107054A85324922210A03040
+FA30:090009040BFE140013F83288524892081FFE12881248120817FE100810700000
+FA31:09080890081013FE1222332652AA93FE100011FC110411FC110411FC11040000
+FA32:080008801FC0108021107FF8A210221022103FF02290048408843086C07C0000
+FA33:202022203F20222444FEFF24492449247F24494408441884291A480287FE0000
+FA34:2220FFA022203E2408FE7F2449247F240824FFA408447F4408A40F9CF1080000
+FA35:010022083FFC208820883FF821083FF82288048008847FFE0080008000800000
+FA36:020893FCFA0893F8920893F89288910293FE9622FA229252028A03F2001C0000
+FA37:011097FEF91091F0904097FC944497FC904097FCF0409FFE00A003180C060000
+FA38:22443F7E224422443E7C012002147FFE081012087F7E224422443E7C22440000
+FA39:11FE1102110211FEFD44112811FE1148154819FEE24842480488090800000000
+FA3A:10081FFC14A812A81FF800801FFC00807FFE144812A620821FF800847FFE0000
+FA3B:3FFC200420043FFC222421402FFC2A9429242FFC240827F8440847F884080000
+FA3C:010001000100210421042104210421043FFC21040100010002000C0070000000
+FA3D:1200120413FE14005BF85288524892481FFE12881248124817FE100810700000
+FA3E:200424BE278824A8B4A8AFA8A4A827FE24102518249825A82E4A248A210E0000
+FA3F:110C1088109013FE5A22572652AA93FE120211FC110411FC110411FC11040000
+FA40:0110355027D4405E97B4201467D4A10827D421262FC204842452241243F80000
+FA41:202021203FA02024407E3EC82A482A48FFC852284A304A107FA802460C820000
+FA42:44047EFE441044507C50449044947DFE4410401048304C505492E112420E0000
+FA43:0FF008100FF008100FF409081FF001207FFE008007F87C0807F8040807F80000
+FA44:1100110413FE1000FDFC11441924352457FE52889248924817FE100810700000
+FA45:4200220423FE0C008BF85288524822482FFEC48844484448C7FEC01040E00000
+FA46:00402040104403F8405028642FFE108011FC23046DFC2104210421FC21040000
+FA47:41102FFE211001F0804057FC544427FC2040C7FC40404FFEC080C3304C0E0000
+FA48:01000FEC010801107FFE008007F00C1017F0641007F004102444222242220000
+FA49:001000F83F00010C108808900820000000000000000000000000000000000000
+FA4A:00040BFEFC401080114C124812B07D2012B0106814A81924E222452008C00000
+FA4B:012405FEFF24112411FC21243D2465FCA5442490251427FE3C10241000100000
+FA4C:202010201020FC200420082811FC302058209420142010201020102413FE0000
+FA4D:202010201020FC2005200924113E312059209520152011201120112417FE0000
+FA4E:2008109C10E0FC800480088410FE308858889488148811081108120814080000
+FA4F:204010401044FDFE044008401080308459FE968414841084108410FC10840000
+FA50:210811FC1108FD080508090811F831085908950815F811081108110817FE0000
+FA51:210411FE1104FD040504090411FC3154585094501450105210921112120E0000
+FA52:208810FC1088FC8804B808A810A833FE5A0296F2129212F21292120E12040000
+FA53:20201024103EFC2005FC090411FC310459FC950415FC11041050108813060000
+FA54:0848FFFC08487F4800487F8E81003EFC00487E4808487F302A30494889860000
+FA55:010020843FFE200444481830614C012001047FFE0100028004401830600E0000
+FA56:104010401F7E289045083E7C22443E4422443E44224424442E5C734821400000
+FA57:102413FE202027FE4622FB2612AA2BFEFA224420007028A85526562280200000
+FA58:100413FE208824884552FBDE10002BFEFC0045FC010429FC550455FC81040000
+FA59:20203FBE55443FA415181FA6014202101FE002107FFC208400A01B9861060000
+FA5A:3FFC224422443FFC21041FE801107FFE008007F80C0837F8040807F804080000
+FA5B:020002083FC802100224FFFE010002100FF818102810CFF008100FF008100000
+FA5C:09100FF808100FF008100FF008100FF0082000947FFE014002200C1E70040000
+FA5D:000000000000042004207FFE0420042000000000000000000000000000000000
+FA5E:000000000000042004207FFE0420042000000000000000000000000000000000
+FA5F:042004207FFE052001081FD001207FFE010007F81C0867F8040807F804080000
+FA60:41FC210429FCFD0409FC1124244028FE7122AF222552218A210221F2200C0000
+FA61:21FC1104110405FC7F04090411FC3904550495FC1154105010521092170E0000
+FA62:210411FE1104FDFC010401FC794000FE792203227952498A490279F2480C0000
+FA63:2088108813FEFC8800F8002079FC012479FC00207BFE482049FC78204BFE0000
+FA64:21043FFE20045FF40510092031400FF078100FF008100FF008100FF0381C0000
+FA65:890CFC8888508BFEFA228B268AAAFBFE880089FCF90489FC510489FC89040000
+FA66:400030001000000000001000F80010001000100010003000C80087FE00000000
+FA67:011041F83110122407FE02441244FBFC106010A811261622301EC80087FE0000
+FA68:22A0FF9022903EFE09907E904A907EFC08907E9008FCFF90149422FE42800000
+FA69:111E27D27A5413D82A567A92135C60901FF804447FFE08100FF008100FF00000
+FA6A:080409FE28202EFC28842884FFFC088428FC288449848AFC0484185861860000
+FA6B:01300108FFFE01003FF8210821083FF8210821083FF80100258C24966632C3E0
+FA6C:00007F7E480248027F02417E41407F40484248427F7E00002488224442448004
+FA6D:102038202DFE67024102FCF810881088FEF8008000807CFC4484448444847CFC
+FA6E:00007FFE61866FB663866FB66FB67FFE7FFE73866FBE638E6DBE73867FFE0000
+FA6F:00007FFE61866FB663866FB66FB67FFE7FFE73866FBE638E6DBE73BE7FFE0000
+FA70:1010082004407FFC0440044004404444244414481450044004400440FFFE0000
+FA71:47F8240824080408040817F811202120E1202120222022222422281E10000000
+FA72:0100010002800440082010102FE8C106010001001FF00100010001007FFC0000
+FA73:10041FC414842494249464946494AFD424942494249424942484288428943088
+FA74:02000100FFFE04000400082010103FF80448044004400440084408441044603C
+FA75:04447C7804421C3EE4003FF821083FF821083FF804403FF80440FFFE10102008
+FA76:3FF0066001803FF821083FF821083FF82108220802007FF80408080810506020
+FA77:0800080010001FF8200840088008040802080108010800080008000800500020
+FA78:03F87A084BF84A084BF849004BFC4C444A447AA44A0403F40004002800100000
+FA79:0100010079FC4A044D0449E44A8448844FF448847AA44AA403E4000400280010
+FA7A:010001F8F20893F0901097FE90809144966890B0F128966800A4012206A00040
+FA7B:01F87908490849F84908490849F848004BFC7A944A940294029407FE00000000
+FA7C:200027FE2402280427FEF8802184224426A821303AF0E4A8412802240CA20040
+FA7D:102011FC1020108813FEFC8811FC110411FC110411FC1D04E1FC408801040202
+FA7E:020002007FFC044009203118DFF6111011101FF0111011101FF40104010400FC
+FA7F:020002007FFC044009203118CFE60100092008207FFC08200820102010202020
+FA80:1040108011FC1124FD2425FC2524254425FC4890291013FE2810441084100010
+FA81:2108209023FE2108F9084A524B9C49088A524BDE304010A42AAA4A8A84780000
+FA82:010000803FFE22102F90221E2FA422243FD4241427942488448848948AA41142
+FA83:010000803FFE200027FC244427FC244427FC211027FC21102FFE400042088404
+FA84:010007847804088844902522200204047F880C10162215022484440884100460
+FA85:0808083C13C020044A44092811FC3220502093FE102011241124112411FC1004
+FA86:100013FE1202128A1A5257FE5242522293FE12821282128212FA1202120A1204
+FA87:2040204027FC204033F8AA08A3F8A208A3F8220823F822082FFE211022082404
+FA88:010002800C6037D8C0063E0822483E4822483E482208261801004884481287F2
+FA89:11041088100013FE1A2256AA5272522293FE100011FC110411FC110411FC1104
+FA8A:21082108210827D0311EAF94A124AFD4A21423D422542248224824D424242842
+FA8B:22204AA08ABE1FC420A46F24A0282FA822102FA822442F8201004884481287F2
+FA8C:08207F280824FFFE00207F2049247F2449247F2822287F102212FFAA22464182
+FA8D:204020A021102208FDF6200023C42A543254E3D42254225423D42244A25442C8
+FA8E:10A0112C11241124FDAC1124112415FC182031FCD08810501020105050882306
+FA8F:200023FC22042204FBFC220022842A4832FCE248224823FE24482448A8885108
+FA90:0820082008207F3E08443E440844FFA410281E281210121022282A4844848102
+FA91:002000207BFE482049FC48204BFE780049FC490449FC490479FC490401140108
+FA92:1000087C7E44424442447E7C424442447E44407C484444445A84628441140208
+FA93:1000087CFF44207C2044267C3844209401087FFC010001003FF801000100FFFE
+FA94:1010101010101010FDFE10103010391055105490909010501020105011881606
+FA95:FFFE02000200040007F8080810102410422001400080010002000C0070000000
+FA96:040044782848104828484486920010FCFE441044582854289210122850442182
+FA97:0080204017FE10808110420847FC100410002248E24822482248224A244A0846
+FA98:0004203E17C0124481244128420013FC14402040EFFE20402444244427FC0004
+FA99:01082088109017FE810841084210129414A42738E1082210221024A427BC0084
+FA9A:0110211017FE111081F040404BF80A4813F81040E7FC20402FFE20A02110060C
+FA9B:022042202FB822480F90827C4F9450141FFE2894EF9428FC2F9428902A900930
+FA9C:020002083FD00220FFFE01000FF03810CFF0081008100FF00000488844448444
+FA9D:00A0009079FE49104B107DFE4910491079FE4910491049FE79004AA402520452
+FA9E:00FC7F00220811107FFC44447FFC00087E0842FE7E0842487E28480874284210
+FA9F:440029F81108290849088908090819282910490089020902090250FE20000000
+FAA0:0040884453F42048505097FE1040108031F85308950811F811081108A1F84108
+FAA1:00200020FBFE202021FC210421FCF90421FC210421FC3904E3FE408801040202
+FAA2:082004407FFC12483CF0082014503EF800007FFC08000FE0092010A41624181C
+FAA3:FFFE000000004FE4492449244FE44924492449244FE4400440047FFC00040000
+FAA4:008000401FFE100097FC54A454A417FC30405150924814442150224844448040
+FAA5:010000803FFE200027F8A40867F8240827F86000AFFC2924292449247FFE8000
+FAA6:101008200000FFFE000008201010200840043FF82448244824482448FFFE0000
+FAA7:009000883FFC208020883E48225022244A54448C81043FF824482448FFFE0000
+FAA8:010001007FFC01001FF0101010101FF010101FF010101FF010101010FFFE0000
+FAA9:00FC7C84448444FC7C0045FE45027D0245FE450245027DFE4502010A01040000
+FAAA:082004407FFC01003FF80200FFFE04000FF018102FF0C8100FF008100FF00810
+FAAB:00200020FBFE202021FC410479FC4904C9FC490449FC49047BFE488801040202
+FAAC:020001007FFE4822909411F822886870ABAE282029FC282028A8292422A42040
+FAAD:104010403F7E4890850800007E7C42447E4442447E44484444545A4862404040
+FAAE:01001110092001007FFC05400920111060080100FFFE0280044008203018C006
+FAAF:108010F811082290206065986646A48825F02420244825FC2020212422A22040
+FAB0:1020102023FE242045FCF92411AC21744924FDFC0420007054A8552482220020
+FAB1:208420483C0050FC90481048FE48104811FE5448544854485C48648804880108
+FAB2:020002083FD002200240FFFE010002000FF0181028104FF0881008100FF00810
+FAB3:08200820FFFE0A200100FFFE100010001FF8000011101110111021124112810E
+FAB4:04400440FFFE04407FFC11101110FFFE111011107FFC0100FFFE010001000100
+FAB5:100010F810887C8854F85488548854F87C0051FC115415541D54E55443FE0000
+FAB6:200013BE00A2F0A210BE238822086A3EB22A2BAA20AA20BE2088208A257E2202
+FAB7:FFFE04403FF824483FF8120027FC42088BF8120833F8510093F8151010E0171E
+FAB8:200011FC1104F90409FC1104110439FC5504950411FC1050109010921112120E
+FAB9:200011FC0124FD240174792401FC7904017479544954497449047A044A140408
+FABA:2020102201FAFC2400287BFE0020784000FC79844A8448FC4884788448FC0084
+FABB:2020102003FEFC2001FC782003FE780001FC790449FC490449FC790449140108
+FABC:200011FC1104FDFC01047DFC00807DFE02227D224552450245FA7C0244140008
+FABD:2088108803FEFC8800A8782003FE7840008078FC49844A844884788448FC0084
+FABE:204010A00110FA0805F6780003C47A5402547BD44A544A544BD47A444A5402C8
+FABF:2088108803FEFC8800F8782001FC792401FC78204BFE482049FC78204BFE0000
+FAC0:210447C88812F3BC20084B92F83E0380AAAAABAA08001FF8282007C01830E00E
+FAC1:0104788848004BFE7A224AAA4A727A224BFE480079FC010451FC490489FC0104
+FAC2:204020A02110FA0825F6F800ABC4FA54AA54FBD42254FA5423D42244225422C8
+FAC3:07FC440427FC242004A80470E4A8250424A024FC252024202BFE282050208FFE
+FAC4:0050FE9628922892FED6AA92AA92AAFEAE10C2FC8244FE4482288210FE2882C6
+FAC5:100213E22942254A414AB94A114A13EAFD4A114A954A594A51421E42E24A4444
+FAC6:00207C2245FA4824482853FE4820484044FC4584468468FC5084408440FC4084
+FAC7:22282224FF40227E3EC809487F7E49487F48087E7F480848FF48147E22404140
+FAC8:2020102013FEFC2001FC08208BFE880049FC490451FC51041DFCE10441140108
+FAC9:104410447DFE2444FE4401FE7C4044FE7D9212FE7C9210FE50927C9210921086
+FACA:110023DE7A5213D42A527BDA1294235001003FF80440FFFE10101FF010101FF0
+FACB:7EFE401040205EFC5284528452FC5A8454FC5084528454FC5848508481020000
+FACC:080008FE28102E2028FC2884FF8400FC08842AFC2A844C8484FC08483084C102
+FACD:3F042018FF62220C7F7001007FFC01001FF0101011101110FFFE082010102008
+FACE:04003FF820083EF802807A800AFCFE940AD47AA402A47AD40A94FEFC0A8279FE
+FACF:20CC273021103110AFFEA110A2A824282844210222902A482A543214221021F0
+FAD0:20CC273021103110AFFEA110A2A82428284423FA220823F82208220823F82208
+FAD1:10281024102013FEFC2010A838A834A850A850A89128112A122A142610201020
+FAD2:2000229E22522252F5522112229272526C32A3D2A25A22542250225023D02250
+FAD3:03FC789048904890789048904FFE789048904890489079104910021004100000
+FAD4:0020002078204BFE482078204924492479244AAA482048507850488801040202
+FAD5:02200220F47C94449DA8F510952895D6F51095FE95109538F454949204100410
+FAD6:10401F7E28904508BEF822883EF822883EF820082EE824482EE8244828482018
+FAD7:1044108813DEFC881088108813DEFC88108810885C885108520870008C0083FE
+FAD8:20007CFC44847CFC44847CFC0040FEFE9312FE9292AAFE8200FAFE0244148408
+FAD9:3FFE22202FBC2520223C3F84203C2FA028BC2FA028BC2FA048BC48A2899E0000
+FADA:00007FFE61866FB663866FB66FB67FFE7FFE63866DB66D866DB663B67FFE0000
+FADB:00007FFE61866FB663866FB66FB67FFE7FFE638E6DB66D8E6DB6638E7FFE0000
+FADC:00007FFE61866FB663866FB66FB67FFE7FFE63C66DBE6DBE6DBE63C67FFE0000
+FADD:00007FFE61866FB663866FB66FB67FFE7FFE638E6DB66DB66DB6638E7FFE0000
+FADE:00007FFE61866FB663866FB66FB67FFE7FFE63866DBE6D8E6DBE63867FFE0000
+FADF:00007FFE61866FB663866FB66FB67FFE7FFE63866DBE6D8E6DBE63BE7FFE0000
+FAE0:00007FFE61866FB663866FB66FB67FFE7FFE61CE6FB663B66FB661CE7FFE0000
+FAE1:00007FFE61866FB663866FB66FB67FFE7FFE61EE6FCE63EE6FEE61C67FFE0000
+FAE2:00007FFE61866FB663866FB66FB67FFE7FFE61866FF663866FBE61867FFE0000
+FAE3:00007FFE61866FB663866FB66FB67FFE7FFE618E6FF663C66FF6618E7FFE0000
+FAE4:00007FFE61866FB663866FB66FB67FFE7FFE61B66FB663866FF661F67FFE0000
+FAE5:00007FFE61866FB663866FB66FB67FFE7FFE61866FBE63866FF661867FFE0000
+FAE6:00007FFE61866FB663866FB66FB67FFE7FFE61CE6FBE638E6FB661CE7FFE0000
+FAE7:00007FFE61866FB663866FB66FB67FFE7FFE61866FF663EE6FDE61DE7FFE0000
+FAE8:00007FFE61866FB663866FB66FB67FFE7FFE61CE6FB663CE6FB661CE7FFE0000
+FAE9:00007FFE61866FB663866FB66FB67FFE7FFE61CE6FB663C66FF661CE7FFE0000
+FAEA:00007FFE61866FB663866FB66FB67FFE7FFE61866FB663866FB661B67FFE0000
+FAEB:00007FFE61866FB663866FB66FB67FFE7FFE618E6FB6638E6FB6618E7FFE0000
+FAEC:00007FFE61866FB663866FB66FB67FFE7FFE61C66FBE63BE6FBE61C67FFE0000
+FAED:00007FFE61866FB663866FB66FB67FFE7FFE618E6FB663B66FB6618E7FFE0000
+FAEE:00007FFE61866FB663866FB66FB67FFE7FFE61866FBE638E6FBE61867FFE0000
+FAEF:00007FFE61866FB663866FB66FB67FFE7FFE61866FBE638E6FBE61BE7FFE0000
+FAF0:00007FFE61866FB663866FB66FB67FFE7FFE61CE6FB663B66FB66FCE7FFE0000
+FAF1:00007FFE61866FB663866FB66FB67FFE7FFE61EE6FCE63EE6FEE6FC67FFE0000
+FAF2:00007FFE61866FB663866FB66FB67FFE7FFE61866FF663866FBE6F867FFE0000
+FAF3:00007FFE61866FB663866FB66FB67FFE7FFE618E6FF663C66FF66F8E7FFE0000
+FAF4:00007FFE61866FB663866FB66FB67FFE7FFE61B66FB663866FF66FF67FFE0000
+FAF5:00007FFE61866FB663866FB66FB67FFE7FFE61866FBE63866FF66F867FFE0000
+FAF6:00007FFE61866FB663866FB66FB67FFE7FFE61CE6FBE638E6FB66FCE7FFE0000
+FAF7:00007FFE61866FB663866FB66FB67FFE7FFE61866FF663EE6FDE6FDE7FFE0000
+FAF8:00007FFE61866FB663866FB66FB67FFE7FFE61CE6FB663CE6FB66FCE7FFE0000
+FAF9:00007FFE61866FB663866FB66FB67FFE7FFE61CE6FB663C66FF66FCE7FFE0000
+FAFA:00007FFE61866FB663866FB66FB67FFE7FFE61866FB663866FB66FB67FFE0000
+FAFB:00007FFE61866FB663866FB66FB67FFE7FFE618E6FB6638E6FB66F8E7FFE0000
+FAFC:00007FFE61866FB663866FB66FB67FFE7FFE61C66FBE63BE6FBE6FC67FFE0000
+FAFD:00007FFE61866FB663866FB66FB67FFE7FFE618E6FB663B66FB66F8E7FFE0000
+FAFE:00007FFE61866FB663866FB66FB67FFE7FFE61866FBE638E6FBE6F867FFE0000
+FAFF:00007FFE61866FB663866FB66FB67FFE7FFE61866FBE638E6FBE6FBE7FFE0000
+FB00:0000001B2424247E2424242424240000
+FB01:0000001A2220207E2222222222220000
+FB02:0000001E2222227A2222222222220000
+FB03:000000162A28287E2A2A2A2A2A2A0000
+FB04:0000001E2A2A2A7E2A2A2A2A2A2A0000
+FB05:000000384848485E4848484848460000
+FB06:0000001C242424364444241414620000
+FB07:00007FFE618E6FB6638E6FB66F8E7FFE7FFE73866DF66DEE6DDE73DE7FFE0000
+FB08:00007FFE618E6FB6638E6FB66F8E7FFE7FFE73CE6DB66DCE6DB673CE7FFE0000
+FB09:00007FFE618E6FB6638E6FB66F8E7FFE7FFE73CE6DB66DC66DF673CE7FFE0000
+FB0A:00007FFE618E6FB6638E6FB66F8E7FFE7FFE73866DB66D866DB673B67FFE0000
+FB0B:00007FFE618E6FB6638E6FB66F8E7FFE7FFE738E6DB66D8E6DB6738E7FFE0000
+FB0C:00007FFE618E6FB6638E6FB66F8E7FFE7FFE73C66DBE6DBE6DBE73C67FFE0000
+FB0D:00007FFE618E6FB6638E6FB66F8E7FFE7FFE738E6DB66DB66DB6738E7FFE0000
+FB0E:00007FFE618E6FB6638E6FB66F8E7FFE7FFE73866DBE6D8E6DBE73867FFE0000
+FB0F:00007FFE618E6FB6638E6FB66F8E7FFE7FFE73866DBE6D8E6DBE73BE7FFE0000
+FB10:00007FFE618E6FB6638E6FB66F8E7FFE7FFE7BCE73B67BB67BB671CE7FFE0000
+FB11:00007FFE618E6FB6638E6FB66F8E7FFE7FFE7BEE73CE7BEE7BEE71C67FFE0000
+FB12:00007FFE618E6FB6638E6FB66F8E7FFE7FFE7B8673F67B867BBE71867FFE0000
+FB13:000000000814305D5555555555330000
+FB14:000000000C1414575454555555360000
+FB15:000000000C1414565555555555350404
+FB16:00000000503C1455555555555533101C
+FB17:00000000182828ADADADADADAD6A0808
+FB18:00007FFE618E6FB6638E6FB66F8E7FFE7FFE7BCE73B67BCE7BB671CE7FFE0000
+FB19:00007FFE618E6FB6638E6FB66F8E7FFE7FFE7BCE73B67BC67BF671CE7FFE0000
+FB1A:00007FFE618E6FB6638E6FB66F8E7FFE7FFE7B8673B67B867BB671B67FFE0000
+FB1B:00007FFE618E6FB6638E6FB66F8E7FFE7FFE7B8E73B67B8E7BB6718E7FFE0000
+FB1C:00007FFE618E6FB6638E6FB66F8E7FFE7FFE7BC673BE7BBE7BBE71C67FFE0000
+FB1D:00000000001C04040400040000000000
+FB1E:0042423C000000000000000000000000
+FB1F:000000000077111111003E0000000000
+FB20:00000000001212121212121212FE0000
+FB21:00000000000000000000300C300C0C0C030C0CF030C03030300C300C00000000
+FB22:000000000000000000003FFC0030003000300030003000300030003000000000
+FB23:000000000000000000003FFC000C000C0C0C0C0C0C0C0C0C0C0C0C0C00000000
+FB24:000000000000000000003FFC000C000C000C000C000C000C000C3FF000000000
+FB25:0000000000000C000C000FFC000C000C000C000C0030003000C00F0000000000
+FB26:00000000000000000000FFFC0C0C0C0C0C0C0C0C0C0C0C0C0C0C0FFC00000000
+FB27:000000000000000000003FFC000C000C000C000C000C000C000C000C00000000
+FB28:000000000000000000000FFC0C0C0C0C0C0C0C0C0C0C0C0C0C0C3C0C00000000
+FB29:00000000000000080808087F00000000
+FB2A:000000010049494949494949497F0000
+FB2B:000000400049494949494949497F0000
+FB2C:0000000100494949494D4949497F0000
+FB2D:0000004000494949494D4949497F0000
+FB2E:0000000000464222122C484442411C00
+FB2F:0000000000464222122C484442411C08
+FB30:0000000000424222122C484442410800
+FB31:00000000007C040404240404047F0000
+FB32:000000000030080808440C1422420000
+FB33:00000000007E04040424040404040000
+FB34:00000000007E0202222A222222220000
+FB35:00000000003808080828080808080000
+FB36:0000000000300C0A0828080808080000
+FB37:00007FFE618E6FB6638E6FB66F8E7FFE7FFE63867DF671EE7DDE63DE7FFE0000
+FB38:0000000000464A4242524242427E0000
+FB39:00000000003808080820000000000000
+FB3A:00000000007E02020212020202020202
+FB3B:00000000007E020202120202027C0000
+FB3C:00000020203E02020212040408300000
+FB3D:00007FFE618E6FB6638E6FB66F8E7FFE7FFE638E7DB671B67DB6638E7FFE0000
+FB3E:00000000004E31214149414141470000
+FB3F:00007FFE618E6FB6638E6FB66F8E7FFE7FFE63867DBE718E7DBE63BE7FFE0000
+FB40:00000000001C040404240404043C0000
+FB41:00000000007E42424252424244780000
+FB42:00007FFE618E6FB6638E6FB66F8E7FFE7FFE6D866DF661867DBE7D867FFE0000
+FB43:00000000007E42424272020212020202
+FB44:00000000007E424242720212027E0000
+FB45:00007FFE618E6FB6638E6FB66F8E7FFE7FFE6D866DBE61867DF67D867FFE0000
+FB46:000000000042422418084402027E0000
+FB47:00000000007E222A2224282020202020
+FB48:00000000007E02020212020202020000
+FB49:0000000000494949494D4949497F0000
+FB4A:00000000003E2222222A222222620000
+FB4B:00000020003808080808080808080000
+FB4C:00000070007C040404040404047F0000
+FB4D:00000070007E020202020202027C0000
+FB4E:00000070007E424242720202027E0000
+FB4F:0000602020464222122C484442420000
+FB50:040A1E20080808080808080000000000
+FB51:102878802020202020201F0000000000
+FB52:000000000000000422423C0008000800
+FB53:000000000000000422423F0008000800
+FB54:00000000000000080404F80008000800
+FB55:00000000000000080404FF0008000800
+FB56:000000000000000422423C0014000800
+FB57:000000000000000422423F0014000800
+FB58:00000000000000080404F80014000800
+FB59:00000000000000080404FF0014000800
+FB5A:000000000000000422423C0014001400
+FB5B:000000000000000422423F0014001400
+FB5C:00000000000000080404F80014001400
+FB5D:00000000000000080404FF0014001400
+FB5E:000008000800000422423C0000000000
+FB5F:000008000800000422423F0000000000
+FB60:00000800080000080404F80000000000
+FB61:00000800080000080404FF0000000000
+FB62:000014001400000422423C0000000000
+FB63:000014001400000422423F0000000000
+FB64:00001400140000080404F80000000000
+FB65:00001400140000080404FF0000000000
+FB66:000020203838000422423C0000000000
+FB67:000020203838000422423F0000000000
+FB68:000010101C1C00080404F80000000000
+FB69:000010101C1C00080404FF0000000000
+FB6A:0008001200060A0642423C0000000000
+FB6B:0008001200060A0642423F0000000000
+FB6C:0010002400003824140CF80000000000
+FB6D:0010002400003824140CFB0000000000
+FB6E:000A000A00060A0642423C0000000000
+FB6F:000A000A00060A0642423F0000000000
+FB70:0028002800003824140CF80000000000
+FB71:0028002800003824140CFB0000000000
+FB72:00000000000000007E1020484048221C
+FB73:00000000000000007E1423484048211E
+FB74:0000000000000000700CFC0020002000
+FB75:0000000000000000700CFF0020002000
+FB76:00000000000000007E1020405440221C
+FB77:00000000000000007E1423405440211E
+FB78:0000000000000000700CFC0050000000
+FB79:0000000000000000700CFF0050000000
+FB7A:00000000000000007E2040544048221C
+FB7B:00000000000000007E2241544048211E
+FB7C:0000000000000000700CFC0028001000
+FB7D:0000000000000000700CFF0028001000
+FB7E:00000000000000007E2040544054221C
+FB7F:00000000000000007E2443544054211E
+FB80:0000000000000000700CFC0050005000
+FB81:0000000000000000700CFF0050005000
+FB82:000000000000080402427C0028000000
+FB83:000000000000080402427F0028000000
+FB84:000000280000080402427C0000000000
+FB85:000000280000080402427F0000000000
+FB86:000010002800080402427C0000000000
+FB87:000010002800080402427F0000000000
+FB88:002020383800080402427C0000000000
+FB89:002020383800080402427F0000000000
+FB8A:00000008001400000402020204483000
+FB8B:00000008001400000402030204483000
+FB8C:00000008080E0E000402020204483000
+FB8D:00000008080E0E000402030204483000
+FB8E:00000004081020403C827E0000000000
+FB8F:00000004081020403C827F0000000000
+FB90:00000004081020403C02FE0000000000
+FB91:00000004081020403C02FF0000000000
+FB92:00081024481020403C827E0000000000
+FB93:00081024481020403C827F0000000000
+FB94:00081024481020403C02FE0000000000
+FB95:00081024481020403C02FF0000000000
+FB96:00081024481020403C827E0010001000
+FB97:00081024481020403C827F0010001000
+FB98:00081024481020403C02FE0010001000
+FB99:00081024481020403C02FF0010001000
+FB9A:00500618620C30403C827E0000000000
+FB9B:00500618620C30403C827F0000000000
+FB9C:00500618620C30403C02FE0000000000
+FB9D:00500618620C30403C02FF0000000000
+FB9E:00000000000000000422424244380000
+FB9F:00000000000000000422434244380000
+FBA0:000010101C1C00000422424244380000
+FBA1:000010101C1C00000422434244380000
+FBA2:000010101C1C00080404F80000000000
+FBA3:000010101C1C00080404FB0000000000
+FBA4:001820182000101824243C0000000000
+FBA5:1820182004040C14243C070000000000
+FBA6:000000000000101824243C0000000000
+FBA7:000000000000000000102F4000000000
+FBA8:00000000000000000010F01010140800
+FBA9:00000000000000000010F31414140808
+FBAA:000000000000102C2A1A244000000000
+FBAB:000000000000102C2A1A274000000000
+FBAC:000000000000102C2A1AE40000000000
+FBAD:000000000000102C2A1AE70000000000
+FBAE:00000000000000000008141020407F00
+FBAF:000000000000000000000F1020407F00
+FBB0:00000000003040304008141020407F00
+FBB1:000000000030403040000F1020407F00
+FBB2:00001818000000000000000000000000
+FBB3:00000000000000000000000000001818
+FBB4:00000C6C600000000000000000000000
+FBB5:000000000000000000000000000C6C60
+FBB6:003030006C6C00000000000000000000
+FBB7:00000000000000000000003030006C6C
+FBB8:006C6C00181800000000000000000000
+FBB9:00000000000000000000006C6C001818
+FBBA:000C6C60031B18000000000000000000
+FBBB:000000000000000000000C6C60031B18
+FBBC:00000000000000000000000024241212
+FBBD:003030000C0C00000000000000000000
+FBBE:000000000000000000003030000C0C00
+FBBF:00000000000000000000000814242810
+FBC0:0010101C1C0000000000000000000000
+FBC1:00000000000000000000000010101C1C
+FBC2:00007FFE618E6FB6638E6FB66F8E7FFE7FFE71866FF66F866FBE71867FFE0000
+FBC3:00007FFE618E6FB6638E6FB66F8E7FFE7FFE718E6FF66FC66FF6718E7FFE0000
+FBC4:00007FFE618E6FB6638E6FB66F8E7FFE7FFE71B66FB66F866FF671F67FFE0000
+FBC5:00007FFE618E6FB6638E6FB66F8E7FFE7FFE71866FBE6F866FF671867FFE0000
+FBC6:00007FFE618E6FB6638E6FB66F8E7FFE7FFE71CE6FBE6F8E6FB671CE7FFE0000
+FBC7:00007FFE618E6FB6638E6FB66F8E7FFE7FFE71866FF66FEE6FDE71DE7FFE0000
+FBC8:00007FFE618E6FB6638E6FB66F8E7FFE7FFE71CE6FB66FCE6FB671CE7FFE0000
+FBC9:00007FFE618E6FB6638E6FB66F8E7FFE7FFE71CE6FB66FC66FF671CE7FFE0000
+FBCA:00007FFE618E6FB6638E6FB66F8E7FFE7FFE71866FB66F866FB671B67FFE0000
+FBCB:00007FFE618E6FB6638E6FB66F8E7FFE7FFE718E6FB66F8E6FB6718E7FFE0000
+FBCC:00007FFE618E6FB6638E6FB66F8E7FFE7FFE71C66FBE6FBE6FBE71C67FFE0000
+FBCD:00007FFE618E6FB6638E6FB66F8E7FFE7FFE718E6FB66FB66FB6718E7FFE0000
+FBCE:00007FFE618E6FB6638E6FB66F8E7FFE7FFE71866FBE6F8E6FBE71867FFE0000
+FBCF:00007FFE618E6FB6638E6FB66F8E7FFE7FFE71866FBE6F8E6FBE71BE7FFE0000
+FBD0:00007FFE618E6FB6638E6FB66F8E7FFE7FFE63CE6DB66DB66DB663CE7FFE0000
+FBD1:00007FFE618E6FB6638E6FB66F8E7FFE7FFE63EE6DCE6DEE6DEE63C67FFE0000
+FBD2:00007FFE618E6FB6638E6FB66F8E7FFE7FFE63866DF66D866DBE63867FFE0000
+FBD3:100028020A120A2242423C0000000000
+FBD4:100028020A120A2242423F0000000000
+FBD5:20005004081020403C02FE0000000000
+FBD6:20005004081020403C02FF0000000000
+FBD7:000018180810200C12121E0204483000
+FBD8:000018180810200C12121F0204483000
+FBD9:000000221408000C12121E0204483000
+FBDA:000000221408000C12121F0204483000
+FBDB:000000080404000C12121E0204483000
+FBDC:000000080404000C12121F0204483000
+FBDD:000033341324400C12121E0204483000
+FBDE:000008001200000C12121E0204483000
+FBDF:000008001200000C12121F0204483000
+FBE0:000000000000000C12121E021C483000
+FBE1:000000000000000C12121F021C483000
+FBE2:000000081422000C12121E0204483000
+FBE3:000000081422000C12121F0204483000
+FBE4:000000000000000C5248443800100010
+FBE5:00000000000000004C52493000100010
+FBE6:00000000000000080804F80008000800
+FBE7:00000000000000080804FB0008000800
+FBE8:00000000000000080804F80000000000
+FBE9:00000000000000080804FB0000000000
+FBEA:0000004C504C50404444380000000000
+FBEB:0000004C504C504044443B0000000000
+FBEC:000000060806080002122C4000000000
+FBED:000000060806080002122D4000000000
+FBEE:00000003040304102A2A3C0808106000
+FBEF:00000003040304102A2A3D0808106000
+FBF0:00003033142344102A2A3C0808106000
+FBF1:00003033142344102A2A3D0808106000
+FBF2:00008853242304102A2A3C0808106000
+FBF3:00008853242304102A2A3D0808106000
+FBF4:00000023141304102A2A3C0808106000
+FBF5:00000023141304102A2A3D0808106000
+FBF6:000C100C1004040C5048443800100010
+FBF7:00000C100C1000044C52493000100010
+FBF8:00000608060800222212EC0020002000
+FBF9:00000608060802020206484442423C00
+FBFA:00000608060800020205484442423C00
+FBFB:00000608060800222212EC0000000000
+FBFC:0000000000000000044A484442423C00
+FBFD:00000000000000000000434442423C00
+FBFE:00000000000000080804F80028000000
+FBFF:00000000000000080804FB0028000000
+FC00:0000006080608C30407E20404840221C
+FC01:0000006080608C30407E20404040221C
+FC02:000000182018230408083C4040404040
+FC03:000000304030440202224446221C0000
+FC04:000000304030440202224446221C0014
+FC05:0000000000000C30407E20424840221C
+FC06:0000000000000C30407E20424040221C
+FC07:0000000020000C30407E20424040221C
+FC08:000000000000030408083C4140404040
+FC09:000000000000040202224446221C0100
+FC0A:000000000000040202224446221C0114
+FC0B:0000000028000C30407E20424040221C
+FC0C:0000000028000C30407E20404040221C
+FC0D:0000000028008C30407E20404040221C
+FC0E:000000050000030408083C4040404040
+FC0F:000000001400040202224446221C0000
+FC10:000000001400040202224446221C0014
+FC11:0000004000A00C30407E20404840221C
+FC12:000000100028030408083C4040404040
+FC13:000000200050040202224446221C0000
+FC14:000000200050040202224446221C0014
+FC15:000000700C020C30407822404040221C
+FC16:000000300C02030408083C4140404040
+FC17:000000700C020C30407E20424040221C
+FC18:000000300C02030408083C4040404040
+FC19:000004700C020C30407E20404840221C
+FC1A:000004700C020C30407E20404040221C
+FC1B:000000310C02030408083C4040404040
+FC1C:000000000000255A407E20424040221C
+FC1D:000000000000255A407E20404040221C
+FC1E:000000004000255A407E20404040221C
+FC1F:00000000000000000000000001940268040004001E0020002000200020002000
+FC20:0000000006091E28407E20404040221C
+FC21:00000000000000000038004401F80240040004001E0020002000200020002000
+FC22:0000000026091E28407E20404840221C
+FC23:0000000026091E28407E20404040221C
+FC24:0000000026891E28407E20404040221C
+FC25:00000000000000000138004401F80240040004001E0020002000200020002000
+FC26:000000202C323C20407E20404040221C
+FC27:0000000808080E0916103C4040404040
+FC28:000000080A080E0916103C4040404040
+FC29:0000003040381020407E20404840221C
+FC2A:000000000C100F0408083C4040404040
+FC2B:0000803040381020407E20404840221C
+FC2C:000008000C100F0408083C4040404040
+FC2D:00008020503010207E1020404840211E
+FC2E:00008020503010207E1020404040211E
+FC2F:00008020503090207E1020404040211E
+FC30:00000040102818081020103840404040
+FC31:00000400000C0A0602464844423C0000
+FC32:00000400000C0A0602464844423C0028
+FC33:0000005000205030407E20404840221C
+FC34:00002800102818081020103840404040
+FC35:00001400000C0A0602464844423C0000
+FC36:00001400000C0A0602464844423C0028
+FC37:000000048890A0C0BC827C0000000000
+FC38:0000000008102010207E20404840221C
+FC39:0000000008102010207E20404040221C
+FC3A:0000000008102090207E20404040221C
+FC3B:000000101012141814121C9090909060
+FC3C:000000040810201008103C4040404040
+FC3D:0000000000000010002000400080008000400880110011800880070000000000
+FC3E:0000000000000010002000400080008000400880110011800880070000000500
+FC3F:00001010101010207E1020404840211E
+FC40:00001010101010207E1020404040211E
+FC41:00001010105010207E1020404040211E
+FC42:000000080808080808083C4040404040
+FC43:00000002020202020206484442423C00
+FC44:000000020202020202064844423C0028
+FC45:0000000000000C30407E20404840221C
+FC46:0000000000000C30407E20404040221C
+FC47:0000000000200C30407E20404040221C
+FC48:000000000000030408083C4040404040
+FC49:000000000000020204084442423C0000
+FC4A:000000000000020204084442423C0028
+FC4B:0000000008000C30407E20404840221C
+FC4C:0000000008000C30407E20404040221C
+FC4D:0000000008200C30407E20404040221C
+FC4E:000000020000030408083C4040404040
+FC4F:000000000800040202224446221C0000
+FC50:000000000800040202224446221C0014
+FC51:000000103854523C407E20404840221C
+FC52:000000201834543808103C4040404040
+FC53:00000000060D150E02224446221C0000
+FC54:00000000060D150E02224446221C0014
+FC55:0000000000000C30407E204A4048221C
+FC56:0000000000000C30407E204A4040221C
+FC57:0000000000200C30407E204A4040221C
+FC58:000000000000030408083C4144404040
+FC59:0000000000000402224446221C010400
+FC5A:0000000000000402224446221C010450
+FC5B:101010002000080402427C0000000000
+FC5C:00000008080808000402020204483000
+FC5D:0000000010101000040A4844423C0000
+FC5E:00046A241800547C0000000000000000
+FC5F:0054547C061866186000000000000000
+FC60:000006186000547C0000000000000000
+FC61:00040A047A00547C0000000000000000
+FC62:0054547C000618600000000000000000
+FC63:000008080800547C0000000000000000
+FC64:000018201822060A120A090808106000
+FC65:000018209822060A120A090808106000
+FC66:000000182018230408083C4040404040
+FC67:00000018209802060A2A454448300000
+FC68:000000000C100C1000064944423C0000
+FC69:000000000C100C1000064944423C0028
+FC6A:000000000002060A120A090808126000
+FC6B:000000000012060A120A090808126000
+FC6C:000000000000030408083D4040404040
+FC6D:00000000001002060A2A454448320000
+FC6E:000000000000000000064944423C0100
+FC6F:000000000000000000064944423C0128
+FC70:000005000002060A120A090808106000
+FC71:000005002002060A120A090808106000
+FC72:00000000000014000C12394040404040
+FC73:00000005001002060A2A454448300000
+FC74:000000000000050000064944423C0000
+FC75:000000000000050000064944423C0028
+FC76:000200050002060A120A090808106000
+FC77:000200050022060A120A090808106000
+FC78:00000000080014000C12394040404040
+FC79:00000200050012060A2A454448300000
+FC7A:000000000002000500064944423C0000
+FC7B:000000000002000500064944423C0028
+FC7C:000000000008000C0A46898C44380000
+FC7D:000000000008000C0A46898C44380028
+FC7E:000000000A00040A07224446221C0000
+FC7F:000000000A00040A07224446221C0014
+FC80:00002122242830282C12010000000000
+FC81:00002122242830A8ACB2410000000000
+FC82:00010204081008040A11081C20202020
+FC83:00000102040810080446898C44380000
+FC84:00000102040810080446898C44380028
+FC85:000000000002020202020F080C101010
+FC86:00000000000202020242858844380000
+FC87:00000000000202020242858844380028
+FC88:0000404040404040402027180E000000
+FC89:0000000000000000000047B8AE808080
+FC8A:000000020002060A120A090808106000
+FC8B:000000021002060A120A090808106000
+FC8C:00000000020002060A12798080808080
+FC8D:00000002100002060A2A454448300000
+FC8E:000000000000020000064944423C0000
+FC8F:000000000000020000064944423C0028
+FC90:000000000010101000064944423C0000
+FC91:000000000002060A120A090808106500
+FC92:000000002002060A120A090808106500
+FC93:000000000000030408083C404A404040
+FC94:00000000001002060A2A454448300500
+FC95:000000000000000000064944423C0104
+FC96:000000000000000000064944423C0154
+FC97:02040608000C1420780CF00010000000
+FC98:02040608000C1420780CF00000000000
+FC99:02040608004C1420780CF00000000000
+FC9A:00020406080006081010F80000000000
+FC9B:00000004080C10002669E82824140C00
+FC9C:00000000000C1420780CF00004200000
+FC9D:00000000000C1420780CF00004000000
+FC9E:00000000200C1420780CF00004000000
+FC9F:00000000000006081010F80004000000
+FCA0:00000000000000002669E82825140C00
+FCA1:00000A00000C1420780CF00000200000
+FCA2:00000A00000C1420780CF00000000000
+FCA3:00000A00200C1420780CF00000000000
+FCA4:0000000A000006081010F80000000000
+FCA5:00000000000A00002669E82824140C00
+FCA6:0004000A000006081010F80000000000
+FCA7:006058041E20407E1862800000000000
+FCA8:0000000000001C021F28D80008000000
+FCA9:006058041E20407E1860801000000000
+FCAA:0000000000001C031F28D80000000000
+FCAB:086058041E20407E1860801000000000
+FCAC:0000000800001C031F28D80000000000
+FCAD:00000000000000001F94209440687E0018006000800010000000000000000000
+FCAE:00000000000000001F94209440687E0018006000800000000000000000000000
+FCAF:00000000000040001F94209440687E0018006000800000000000000000000000
+FCB0:00000000000115153E40E00000000000
+FCB1:0000000804140A24114820F040407E0018006000800000000000000000000000
+FCB2:0000000844140A24114820F040407E0018006000800000000000000000000000
+FCB3:00000000000000200050009011202FC021004000E00000000000000000000000
+FCB4:0080000804140A24114820F040407E0018006000800008000000000000000000
+FCB5:0080000804140A24114820F040407E0018006000800000000000000000000000
+FCB6:0080000844140A24114820F040407E0018006000800000000000000000000000
+FCB7:00000000000004200050009011202FC021004000E00000000000000000000000
+FCB8:101016191E2078061860800000000000
+FCB9:00000000121016193E40F04830000000
+FCBA:000030424C30407E1860801000000000
+FCBB:000000000030404C3040F04830000000
+FCBC:200030424C30407E1860801000000000
+FCBD:000000200030404C3040F04830000000
+FCBE:401028380810203E0C30C00800000000
+FCBF:401028380810203E0C30C00000000000
+FCC0:00401028388810203E0CF00000000000
+FCC1:00100010283808102020F02810000000
+FCC2:28001028380810203E0CF00008000000
+FCC3:00280010283808102020F02810000000
+FCC4:020408103008107E1860800800000000
+FCC5:020408103008107E1860800000000000
+FCC6:020408103088107E1860800000000000
+FCC7:00024448506078444424D80000000000
+FCC8:00040810204020101020F02810000000
+FCC9:0000101010101020780CF00000200000
+FCCA:0000101010101020780CF00000000000
+FCCB:0000101050101020780CF00000000000
+FCCC:00000008080808080808FC0200000000
+FCCD:000004040404041C2A3AF60000000000
+FCCE:00000000040A1C20780CF00000200000
+FCCF:00000000040A1C20780CF00000000000
+FCD0:00000000240A1C20780CF00000000000
+FCD1:0000000000040A1E2020F00000000000
+FCD2:00000400000C1420780CF00000200000
+FCD3:00000400000C1420780CF00000000000
+FCD4:00000400200C1420780CF00000000000
+FCD5:00000004000006081010F80000000000
+FCD6:0000000000000400266AE82824140C00
+FCD7:003C1229293E407E1860801000000000
+FCD8:003C1229291E08102040E05020000000
+FCD9:202000782452523C2040800000000000
+FCDA:00000000000C1420780CF0000A200000
+FCDB:00000000000C1420780CF0000A000000
+FCDC:00000000200C1420780CF0000A000000
+FCDD:00000000000006081010F8000A000000
+FCDE:000000000000000C1250D55048281800
+FCDF:00000C100C3000102824D30000000000
+FCE0:0000000608061800246AE92824140C00
+FCE1:00000000000000102824D30008000000
+FCE2:0000000000000000246AE92825140C00
+FCE3:00000000001400102824D30000000000
+FCE4:0000000000140000246AE92824140C00
+FCE5:00000008001400102824D30000000000
+FCE6:0000000800140000246AE92824140C00
+FCE7:0000000000000000000000000000180024122212D1ED00000000000000000000
+FCE8:0000000000000000000000000000000026126912E8ED2800240014000C000000
+FCE9:0000000000000010000000280000180024122212D1ED00000000000000000000
+FCEA:0000000000000010000000280000000024126A12E9ED2800240014000C000000
+FCEB:00024448506070484C4AB10000000000
+FCEC:00040810204020101824F32810000000
+FCED:00000808080808081824F32810000000
+FCEE:00000000100000102824D30000000000
+FCEF:000000000800000C1252D15048281800
+FCF0:00000000000000102824D3000A000000
+FCF1:00000000000000000856D150482B1800
+FCF2:000C30022A1400000000FF0000000000
+FCF3:040A040A30022A140000FF0000000000
+FCF4:000A54200C3000000000FF0000000000
+FCF5:000000000808080E090E4844423C0000
+FCF6:000000000808080E090E4844423C0028
+FCF7:000000000000000608064844423C0000
+FCF8:000000000000000608064844423C0028
+FCF9:000000000008000608064844423C0000
+FCFA:000000000008000608064844423C0028
+FCFB:00000000000000000000000000000612091208EC4800440042003C0000000000
+FCFC:00000000000000000000000000000612091208EC4800440042003C0000002800
+FCFD:00000000001000000028000000000612091208EC4800440042003C0000000000
+FCFE:00000000001000000028000000000612091208EC4800440042003C0000002800
+FCFF:000000006058040E10380844423C0000
+FD00:000000006058040E38080844423C0028
+FD01:000000006058040E38090844423C0000
+FD02:000000006058040E38090844423C0028
+FD03:000000046058040E38080844423C0000
+FD04:000000026058040E38080844423C0028
+FD05:000000000205051E14100844423C0000
+FD06:000000000205051E14100844423C0028
+FD07:000000080205051E14100844423C0000
+FD08:000000080205051E14100844423C0028
+FD09:000004000A00255A407E20404840221C
+FD0A:000004000A00255A407E20404040221C
+FD0B:000004000A80255A407E20404040221C
+FD0C:000004000A00255A40603C4040404040
+FD0D:00000004000A00152A20202020408000
+FD0E:00000000000000152A20202020408000
+FD0F:0000000002050D162424202020408000
+FD10:0000000802050D162424202020408000
+FD11:000000000808080E090E4944423C0000
+FD12:000000000808080E090E4944423C0028
+FD13:000000000000000205064944423C0000
+FD14:000000000000000205064944423C0028
+FD15:000000000004000205064944423C0000
+FD16:000000000004000205064944423C0028
+FD17:000000000000000000000000000000000612091248ED440042003C0000000000
+FD18:000000000000000000000000000000000612091248ED440042003C0000002800
+FD19:000000000000001000000028000000000612091248ED440042003C0000000000
+FD1A:000000000000001000000028000000000612091248ED440042003C0000002800
+FD1B:000000000000000000000000000000000670090C08FF440042003C0000000000
+FD1C:000000000000000000000000000000000670090C08FF440042003C0000002800
+FD1D:000000000000000000000000000000000670090C08FF440042203C0000000000
+FD1E:000000000000000000000000000000000670090C08FF440042203C0000002800
+FD1F:000000000000000000000000004000000670090C08FF440042003C0000000000
+FD20:000000000000000000000000002000000670090C08FF440042003C0000002800
+FD21:0000000000040A0A3E29209088700000
+FD22:0000000000040A0A3E29209088700050
+FD23:0000000010040A0A3E29209088700000
+FD24:0000000010040A0A3E29209088700050
+FD25:000000001000280054AA81FC40904438
+FD26:000000001000280054AA81FC40804438
+FD27:000000001000A80054AA81FC40804438
+FD28:00000000080014004AB580C070808080
+FD29:00000000000004000A00152A20204080
+FD2A:00000000000000000000152A20204080
+FD2B:0000000000000002050D162424408000
+FD2C:0000000000000012050D162424408000
+FD2D:00200000005004000A2411D820007F8018006000800008000000000000000000
+FD2E:00200000005004000A2411D820007F8018006000800000000000000000000000
+FD2F:00200000005024000A2411D820007F8018006000800000000000000000000000
+FD30:0000000000200000005004000A2411D820007000880000000000000000000000
+FD31:0000000000000000000000000000002423D86400E8002800240014000C000000
+FD32:0000000000000020000000500000002423D86400E8002800240014000C000000
+FD33:00000010101016191E20D02000000000
+FD34:0000000000000000000000000000100028920492FFED00001000000000000000
+FD35:0000000000000000000000000000100028920492FFED00000000000000000000
+FD36:0000000000000000000010000000100028920492FFED00000000000000000000
+FD37:0000000000000000001000000028100028920492FFED00001000000000000000
+FD38:0000000000000000001000000028100028920492FFED00000000000000000000
+FD39:0000000000000000001010000028100028920492FFED00000000000000000000
+FD3A:00000010101016191E22D12000000000
+FD3B:00000010121016191E22D12000000000
+FD3C:010204111214101010100F0000000000
+FD3D:01020411121410101010100000000000
+FD3E:0000007E018C023004C00F000A0035806AC035800A000F0004C00230018C007E
+FD3F:00007E0031800C40032000F0005001AC035601AC005000F003200C4031807E00
+FD40:00007FFE618E6FB663B66FB66F8E7FFE7FFE6DCE6DB661B67DB67DCE7FFE0000
+FD41:00007FFE618E6FB663B66FB66F8E7FFE7FFE6DEE6DCE61EE7DEE7DC67FFE0000
+FD42:00007FFE618E6FB663B66FB66F8E7FFE7FFE6D866DF661867DBE7D867FFE0000
+FD43:00007FFE618E6FB663B66FB66F8E7FFE7FFE6D8E6DF661C67DF67D8E7FFE0000
+FD44:00007FFE618E6FB663B66FB66F8E7FFE7FFE6DB66DB661867DF67DF67FFE0000
+FD45:00007FFE618E6FB663B66FB66F8E7FFE7FFE6D866DBE61867DF67D867FFE0000
+FD46:00007FFE618E6FB663B66FB66F8E7FFE7FFE6DCE6DBE618E7DB67DCE7FFE0000
+FD47:00007FFE618E6FB663B66FB66F8E7FFE7FFE6D866DF661EE7DDE7DDE7FFE0000
+FD48:00007FFE618E6FB663B66FB66F8E7FFE7FFE6DCE6DB661CE7DB67DCE7FFE0000
+FD49:00007FFE618E6FB663B66FB66F8E7FFE7FFE6DCE6DB661C67DF67DCE7FFE0000
+FD4A:00007FFE618E6FB663B66FB66F8E7FFE7FFE6D866DB661867DB67DB67FFE0000
+FD4B:00007FFE618E6FB663B66FB66F8E7FFE7FFE6D8E6DB6618E7DB67D8E7FFE0000
+FD4C:00007FFE618E6FB663B66FB66F8E7FFE7FFE6DC66DBE61BE7DBE7DC67FFE0000
+FD4D:00007FFE618E6FB663B66FB66F8E7FFE7FFE6D8E6DB661B67DB67D8E7FFE0000
+FD4E:00007FFE618E6FB663B66FB66F8E7FFE7FFE6D866DBE618E7DBE7D867FFE0000
+FD4F:00007FFE618E6FB663B66FB66F8E7FFE7FFE6D866DBE618E7DBE7DBE7FFE0000
+FD50:0000000000000000000000000028020005040084FFFC50002100000000000000
+FD51:00000000000000000000000000141080294204220BFF10002400200012000C00
+FD52:0000000000000000000000000028210052840844FFFC00002000000000000000
+FD53:0000000000000000000000000028020005040084FFFC50002000000000000000
+FD54:0000000000000000000002000028020005040084FFFC28001000000000000000
+FD55:0000000000000000000000000028200050040804FFFC02802100000000000000
+FD56:0000000000000000000000000028200050040804FFFC02800100000000000000
+FD57:0000000000000000000000000028200050040804FFFC02802100000000000000
+FD58:000000000000000000000000000020085014080217FF21404088400024001800
+FD59:0000000000000000000000000000201050280804FFFC02800110000000000000
+FD5A:000000000000000000000000000000084814540253FF48A04440380000002800
+FD5B:000000000000000000000000000000084814540253FF48A04440380000000000
+FD5C:0000000000000000000000000000210052950855FFFF00002000000000000000
+FD5D:0000000000000000000000000000210052950855FFFF00000100000000000000
+FD5E:000000000000000000000000000001009295A855A7FF90008900700000000000
+FD5F:00000000000000000000000000004000A02A102A2FFF45008200800048003000
+FD60:00000000000000000000000000002000502A082AFFFE02800100000000000000
+FD61:00000000000000000000000000002000502A082AFFFE02802100000000000000
+FD62:00000000000000000000000000002000502A082A7FFF42804100400040000000
+FD63:00000000000000000000000000000000002A002AFFFE2A801100000000000000
+FD64:00000000000000000000000000004204A52A10AA2FD740008000800048003000
+FD65:0000000000000000000000000000210252950855FFEE00000000000000000000
+FD66:00000000000000000000000000002004502A082A7FD742804100400040000000
+FD67:00000000000000000008000000144200A52A10AAFFFF80008000800080000000
+FD68:00000000000000000008000000140200052A00AAFFFE28001000000000000000
+FD69:000000000000000000040000000A01009295A855A7FF90008900700000005000
+FD6A:00000000000000000008200000142000502A082A17FF22804100400024001800
+FD6B:00000000000000000008200000142000502A082AFFFE02800100000000000000
+FD6C:00000000000000000008000000142000502A082A7FFF42804100400040000000
+FD6D:00000000000000000008000000140000002A002AFFFE2A801100000000000000
+FD6E:000000000000000000000002000001029295A855A7EB90008800700000000000
+FD6F:00000000000000000000000400004204A52A10AAFFD780008000800080000000
+FD70:00000000000000000000020400000204052A00AAFFD428001000000000000000
+FD71:00000000000000000000002000202020502C083217FF22804100400024001800
+FD72:00000000000000000000002000202020502C0832FFFC02800100000000000000
+FD73:00000000000000000000002000200020002C0032FFFC2A801100000000000000
+FD74:00000000000000000000002000200020902CA832A7FF92808900700000005000
+FD75:0000000000000000000000000000211E5292084C7FF340004100400040000000
+FD76:0000000000000000000000000000101E2812040C3FF321402080200020000000
+FD77:00000000000000000000000000000000000C0010FFFE52802100000000000000
+FD78:0000000000000000000000000000001E9012A80CA7F391408880700000000000
+FD79:0000000000000000000000080000101E2812040C3FF321402080200020000000
+FD7A:0000000000000000000000080000001E9012A80CA7F391408880700000005000
+FD7B:0000000000000000000000080000001E9012A80CA7F391408880700000000000
+FD7C:00000000000000000000010800002108529408547FEF40004000400040000000
+FD7D:00000000000000000008010000080114028C0044FFFC28001000000000000000
+FD7E:00000000000000000000000A00002004500A080A17F721404080400024001800
+FD7F:00000000000000000000001400002008501408147FEF42804100400040000000
+FD80:0000000000000000000000020002084214A202121FFD10001000100010000000
+FD81:0000000000000000000000020002004224A22A1229FD240022001C0000001400
+FD82:0000000000000000000000020002004224A22A1229FD240022001C0000000000
+FD83:0000000000000000000000080008210852880848FFF000002100000000000000
+FD84:000000000000000000000002000220825142082217FD20004880400024001800
+FD85:00000000000000000000008200022082514208227FFD40004000400040000000
+FD86:0000000000000000000001040004010402840044FFF828001000000000000000
+FD87:00000000000000000000000200021002280204020BFD10A02040200012000C00
+FD88:0000000000000000000000080008200850080808FFF002800100000000000000
+FD89:0000000000000000000000000000210052800848FFF400142008000000000000
+FD8A:0000000000000000000000000000020005000088FFF450142008000000000000
+FD8B:000000000000000000000000000001009280A840A7FF90148808700000005000
+FD8C:0000000000000000000000000000210052800848FFF400140108000000000000
+FD8D:0000000000000000000000000000010002800048FFF428141108000000000000
+FD8E:0000000000000000000001000000210052800848FFF400142008000000000000
+FD8F:0000000000000000000001000000010002800048FFF428141008000000000000
+FD90:00007FFE618E6FB663B66FB66F8E7FFE7FFE73CE6DB671B67DB673CE7FFE0000
+FD91:00007FFE618E6FB663B66FB66F8E7FFE7FFE73EE6DCE71EE7DEE73C67FFE0000
+FD92:0000000000000000000020000000210052800848FFF400140108000000000000
+FD93:00000000000000000000001800042012502A082AFFDC02802100000000000000
+FD94:00000000000000000000001800040012002A002AFFDC2A801100000000000000
+FD95:0000000000000000000000000008010002880048FFF028001000000000000000
+FD96:000000000000000000000000000400804944542453FB48004400380000000000
+FD97:00000000000000000000000000042080514408247FFB40004080400040000000
+FD98:0000000000000000000000000008010002880048FFF028001100000000000000
+FD99:000000000000000000000000000400809144A824A7FB90008880700000000000
+FD9A:000000000000000000000000000400004804540453FB48A04440380000002800
+FD9B:000000000000000000000000000400004804540453FB48A04440380000000000
+FD9C:00000000000000000000000000000800140402041FFB10A0104A100010000000
+FD9D:0000000000000000000000000000000000020002FFFC29401094000000000000
+FD9E:000000000000000000000080000000809142A822A7FD90008804700000005000
+FD9F:000000000000000000000000000A00809142A822A7FD90008840700000005000
+FDA0:000000000000000000000000000A00809142A822A7FD90008880700000000000
+FDA1:000000000000000000000080000A00809142A822A7FD90008800700000005000
+FDA2:000000000000000000000080000A00809142A822A7FD90008800700000000000
+FDA3:000000000000000000000000000A00004802540253FD48A04440380000002800
+FDA4:000000000000000000000000000A00004802540253FD48A04440380000000000
+FDA5:000000000000000000000000000000089014A802A7FF91408888700000005000
+FDA6:000000000000000000000000000001089294A842A7FF90008808700000000000
+FDA7:000000000000000000000000000000089014A802A7FF91408888700000000000
+FDA8:000000000000000000000100000001009295A855A7FF90008800700000000000
+FDA9:000000000000000000000000000001029295A855A7EF90008800700000005000
+FDAA:000000000000000000040000000A01009295A855A7FF90008800700000005000
+FDAB:000000000000000000000002000001029295A855A7FF90008800700000005000
+FDAC:000000000000000000000004000400844944542453FB48004480380000002800
+FDAD:000000000000000000000004000400044804540453FB48A04440380000002800
+FDAE:000000000000000000000000000000804944542453FB4800440A380000002800
+FDAF:000000000000000000000000000000804944542453FB4800448A380000002800
+FDB0:000000000000000000000000000000004804540453FB48A0444A380000002800
+FDB1:000000000000000000000000000000004800540053FF48AA4444380000002800
+FDB2:00000000000000000000000A00000004480A540A53F748A04440380000002800
+FDB3:000000000000000000000000000400804944542453FB48004400380000002800
+FDB4:00000000000000000014000000082014500C0804FFFC02800100000000000000
+FDB5:0000000000000000000000080008010802880048FFF828001000000000000000
+FDB6:0000000000000000000000000000001E9012A80CA7F391408880700000005000
+FDB7:000000000000000000000006001800209018A80EA7F192808900700000005000
+FDB8:0000000000000000000000000008210052880848FFF800000100000000000000
+FDB9:000000000000000000000080000000809140A820A7FF900A8804700000005000
+FDBA:0000000000000000000000080008010802880048FFF828001100000000000000
+FDBB:000000000000000000000006001820205018080E7FF142804100400040000000
+FDBC:00000000000000000000000400042084514408247FFB40004080400040000000
+FDBD:0000000000000000000000000002104028A204120BFD10002040200012000C00
+FDBE:000000000000000000000000000001089294A842A7FF90008808700000005000
+FDBF:000000000000000000000000000001089294A842A7FF90008900700000005000
+FDC0:000000000000000000000000000000809140A820A7FF900A8844700000005000
+FDC1:00000000000000000000000400000004480A540A53F748A04440380000002800
+FDC2:000000000000000000000000000000809142A822A7FF90008804700000005000
+FDC3:000000000000000000000003000C001000080004FFF829401080000000000000
+FDC4:0000000000000000000000000000010002860048FFFF28001100000000000000
+FDC5:00000000000000000000000000000004002A002AFFDC55002200000000000000
+FDC6:000000000000000000000100000001009295A855A7FF90008800700000005000
+FDC7:000000000000000000000000000400809144A824A7FB90008880700000005000
+FDC8:00007FFE618E6FB663B66FB66F8E7FFE7FFE71CE6FB66FCE6FB671CE7FFE0000
+FDC9:00007FFE618E6FB663B66FB66F8E7FFE7FFE71CE6FB66FC66FF671CE7FFE0000
+FDCA:00007FFE618E6FB663B66FB66F8E7FFE7FFE71866FB66F866FB671B67FFE0000
+FDCB:00007FFE618E6FB663B66FB66F8E7FFE7FFE718E6FB66F8E6FB6718E7FFE0000
+FDCC:00007FFE618E6FB663B66FB66F8E7FFE7FFE71C66FBE6FBE6FBE71C67FFE0000
+FDCD:00007FFE618E6FB663B66FB66F8E7FFE7FFE718E6FB66FB66FB6718E7FFE0000
+FDCE:00007FFE618E6FB663B66FB66F8E7FFE7FFE71866FBE6F8E6FBE71867FFE0000
+FDCF:00007FFE618E6FB663B66FB66F8E7FFE7FFE71866FBE6F8E6FBE71BE7FFE0000
+FDD0:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE3CFEDB7EDB7EDB7E3CFFFFFFFFF
+FDD1:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE3DFED9FEDDFEDDFE38FFFFFFFFF
+FDD2:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE387EDF7ED87EDBFE387FFFFFFFF
+FDD3:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE38FEDF7EDC7EDF7E38FFFFFFFFF
+FDD4:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE3AFEDAFED87EDEFE3EFFFFFFFFF
+FDD5:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE387EDBFED87EDF7E387FFFFFFFF
+FDD6:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE3CFEDBFED8FEDB7E3CFFFFFFFFF
+FDD7:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE387EDF7EDEFEDDFE3DFFFFFFFFF
+FDD8:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE3CFEDB7EDCFEDB7E3CFFFFFFFFF
+FDD9:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE3CFEDB7EDC7EDF7E3CFFFFFFFFF
+FDDA:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE3CFEDB7ED87EDB7E3B7FFFFFFFF
+FDDB:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE38FEDB7ED8FEDB7E38FFFFFFFFF
+FDDC:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE3CFEDB7EDBFEDB7E3CFFFFFFFFF
+FDDD:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE38FEDB7EDB7EDB7E38FFFFFFFFF
+FDDE:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE387EDBFED8FEDBFE387FFFFFFFF
+FDDF:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE387EDBFED8FEDBFE3BFFFFFFFFF
+FDE0:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE1CFEFB7E3B7EFB7E1CFFFFFFFFF
+FDE1:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE1DFEF9FE3DFEFDFE18FFFFFFFFF
+FDE2:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE187EFF7E387EFBFE187FFFFFFFF
+FDE3:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE18FEFF7E3C7EFF7E18FFFFFFFFF
+FDE4:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE1AFEFAFE387EFEFE1EFFFFFFFFF
+FDE5:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE187EFBFE387EFF7E187FFFFFFFF
+FDE6:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE1CFEFBFE38FEFB7E1CFFFFFFFFF
+FDE7:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE187EFF7E3EFEFDFE1DFFFFFFFFF
+FDE8:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE1CFEFB7E3CFEFB7E1CFFFFFFFFF
+FDE9:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE1CFEFB7E3C7EFF7E1CFFFFFFFFF
+FDEA:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE1CFEFB7E387EFB7E1B7FFFFFFFF
+FDEB:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE18FEFB7E38FEFB7E18FFFFFFFFF
+FDEC:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE1CFEFB7E3BFEFB7E1CFFFFFFFFF
+FDED:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE18FEFB7E3B7EFB7E18FFFFFFFFF
+FDEE:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE187EFBFE38FEFBFE187FFFFFFFF
+FDEF:FFFFFFFFE18FEFB7E3B7EFB7EF8FFFFFFFFFE187EFBFE38FEFBFE1BFFFFFFFFF
+FDF0:00000000040004000400040C049204A20B7C3020400040003FF0000000000000
+FDF1:0000000002500200022002500230021005E01800200020001FF8000000000000
+FDF2:020002000240014205820602009208921892289218920F600000000000000000
+FDF3:0000000C003000C40104010400C412241E14121411E424004000000000000000
+FDF4:06081814010815140A60000001880614003808C0090005FC24181A6001800060
+FDF5:00000000040004000400240C549234A22B7C4020380014002800200020000000
+FDF6:0000000010001000100010009254955563A901020E1C00000000000000000000
+FDF7:000000000020002010203020502633280CDE0000050000000000000000000000
+FDF8:00000000100010001000100012A412AA2D464002300428185000400040000000
+FDF9:00000000040004000400040C049204A20B7C082050004C004200240018000000
+FDFA:2AA06AA0AAAA6A2D145680C480287FC82029602ABFD7440204553D035351A0A6
+FDFB:000008000804480A480137FF000002A412A032A452AA32210CDF000000040000
+FDFC:0000028002800280028002A002A0224222021CA2000C00000000000000000000
+FDFD:70A95FFF7000C5D5145515D5557D75C0C03B50295FFF7000758554957F9DC030
+FDFE:00007FFE618E6FB663B66FB66F8E7FFE7FFE61866FBE638E6FBE6F867FFE0000
+FDFF:00007FFE618E6FB663B66FB66F8E7FFE7FFE61866FBE638E6FBE6FBE7FFE0000
+FE00:AAAA00018000223DA2402239940408798000008181800281808003E180005555
+FE01:AAAA00018000223DA2402239940408798000038180400181820003C180005555
+FE02:AAAA00018000223DA24022399404087980000381804001818040038180005555
+FE03:AAAA00018000223DA24022399404087980000241824003C18040004180005555
+FE04:AAAA00018000223DA240223994040879800003C1820003818040038180005555
+FE05:AAAA00018000223DA240223994040879800001C1820003818240018180005555
+FE06:AAAA00018000223DA240223994040879800003C1804000818100010180005555
+FE07:AAAA00018000223DA24022399404087980000181824001818240018180005555
+FE08:AAAA00018000223DA24022399404087980000181824001C18040038180005555
+FE09:AAAA00018000223DA240223994040879800008319848284988483E3180005555
+FE0A:AAAA00018000223DA240223994040879800008119830285188103E7D80005555
+FE0B:AAAA00018000223DA240223994040879800008719808283188403E7980005555
+FE0C:AAAA00018000223DA240223994040879800008719808283188083E7180005555
+FE0D:AAAA00018000223DA240223994040879800008499848287988083E0980005555
+FE0E:AAAA00018000223DA240223994040879800008799840287188083E7180005555
+FE0F:AAAA00018000223DA240223994040879800008399840287188483E3180005555
+FE10:00000000000C0004000400080000000000000000000000000000000000000000
+FE11:0000000000200010000800080000000000000000000000000000000000000000
+FE12:0000000000000018002400240018000000000000000000000000000000000000
+FE13:00000000000C000C000000000000000C000C0000000000000000000000000000
+FE14:00000000000C000C000000000000000C00040004000800000000000000000000
+FE15:0000000000040004000400040004000400040000000400040000000000000000
+FE16:0000000000780084008400040008001000100000001000100000000000000000
+FE17:00000000000000000000000000007FFE400247E2581A60064002000000000000
+FE18:00000000000040026006581A47E240027FFE0000000000000000000000000000
+FE19:0000000001800180000000000000018001800000000000000180018000000000
+FE1A:00007FFE61866FBE638E6FBE6F867FFE7FFE7B8673B67B867BB671B67FFE0000
+FE1B:00007FFE61866FBE638E6FBE6F867FFE7FFE7B8E73B67B8E7BB6718E7FFE0000
+FE1C:00007FFE61866FBE638E6FBE6F867FFE7FFE7BC673BE7BBE7BBE71C67FFE0000
+FE1D:00007FFE61866FBE638E6FBE6F867FFE7FFE7B8E73B67BB67BB6718E7FFE0000
+FE1E:00007FFE61866FBE638E6FBE6F867FFE7FFE7B8673BE7B8E7BBE71867FFE0000
+FE1F:00007FFE61866FBE638E6FBE6F867FFE7FFE7B8673BE7B8E7BBE71BE7FFE0000
+FE20:000F3040000000000000000000000000
+FE21:00F00C02000000000000000000000000
+FE22:001E2140000000000000000000000000
+FE23:00028478000000000000000000000000
+FE24:00001F00000000000000000000000000
+FE25:0000F800000000000000000000000000
+FE26:0000FF00000000000000000000000000
+FE27:0000000000000000000000000040300F
+FE28:00000000000000000000000000020CF0
+FE29:00000000000000000000000000000F30
+FE2A:00000000000000000000000000000CF0
+FE2B:0000000000000000000000000000001F
+FE2C:000000000000000000000000000000F8
+FE2D:000000000000000000000000000000FF
+FE2E:001F1800000000000000000000000000
+FE2F:0018F800000000000000000000000000
+FE30:0000000000000000018001800000000000000000018001800000000000000000
+FE31:0000000000800080008000800080008000800080008000800080008000000000
+FE32:0000000000000000008000800080008000800080008000800000000000000000
+FE33:0000400040004000400040004000400040004000400040004000400040000000
+FE34:2000400040002000100010002000400040002000100010002000400040002000
+FE35:0000000000000000000000000000000000000FF0100820044002000000000000
+FE36:0000000000004002200410080FF0000000000000000000000000000000000000
+FE37:000000000000000000000000000000000000000001803E7C4002000000000000
+FE38:00000000000040023E7C01800000000000000000000000000000000000000000
+FE39:00000000000000000000000000000000000000001FF820044002000000000000
+FE3A:000000000000400220041FF80000000000000000000000000000000000000000
+FE3B:000000000000000000000000000000007FFE7FFE781E60064002000000000000
+FE3C:00000000000040026006781E7FFE7FFE00000000000000000000000000000000
+FE3D:0000000000000000000000000180066018186186066018186006000000000000
+FE3E:0000000000006006181806606186181806600180000000000000000000000000
+FE3F:0000000000000000000000000000000000000180066018186006000000000000
+FE40:0000000000006006181806600180000000000000000000000000000000000000
+FE41:000000000000000000000000000000000FFE0002000200020002000000000000
+FE42:00000000000040004000400040007FF000000000000000000000000000000000
+FE43:00000000000000000000000000000FFE08020FFA000A000A000E000000000000
+FE44:0000000000007000500050005FF040107FF00000000000000000000000000000
+FE45:0000000000700038001800180000000000000000000000000000000000000000
+FE46:00000000007800240014000C0000000000000000000000000000000000000000
+FE47:000000000000000000000000000000007FFE4002400240024002000000000000
+FE48:00000000000040024002400240027FFE00000000000000000000000000000000
+FE49:000039CE00000000000000000000000000000000000000000000000000000000
+FE4A:00007DBE00000000000000000000000000000000000000000000000000000000
+FE4B:0C30924961860000000000000000000000000000000000000000000000000000
+FE4C:0C30924961860C30924961860000000000000000000000000000000000000000
+FE4D:0000000000000000000000000000000000000000000000000000000039CE0000
+FE4E:000000000000000000000000000000000000000000000000000000007DBE0000
+FE4F:00000000000000000000000000000000000000000000000000000C3092496186
+FE50:0000000000000000000000000000000000000000000000000180010002000000
+FE51:0000000000000000000000000000000000000000000000000200010001800000
+FE52:0000000000000000000000000000000000000000000000000180018000000000
+FE53:00007FFE61866FBE638E6FBE6F867FFE7FFE618E6FF661C67DF6618E7FFE0000
+FE54:0000000000000000000000000000000000000180018000000180010002000000
+FE55:0000000000000000000000000000000000000180018000000180018000000000
+FE56:0000000000000000000000000000000001000280008001000000010000000000
+FE57:0000000000000000000000000000000000800080008000800000008000000000
+FE58:0000000000000000000000000000000000000000000007C00000000000000000
+FE59:0000000000000000000000000000000000800100010001000100008000000000
+FE5A:0000000000000000000000000000000001000080008000800080010000000000
+FE5B:0000000000000000000000000000000000400080018000800080004000000000
+FE5C:0000000000000000000000000000000002000100018001000100020000000000
+FE5D:0000000000000000000000000000000001C0010001000100010001C000000000
+FE5E:0000000000000000000000000000000003800080008000800080038000000000
+FE5F:000000000000000000000000000000000000028007C0028007C0028000000000
+FE60:0000000000000000000000000000000000000100028001000280014000000000
+FE61:0000000000000000000000000000000000000280010003800100028000000000
+FE62:0000000000000000000000000000000000000100010007C00100010000000000
+FE63:0000000000000000000000000000000000000000000003C00000000000000000
+FE64:0000000000000000000000000000000000000040008001000080004000000000
+FE65:0000000000000000000000000000000000000200010000800100020000000000
+FE66:000000000000000000000000000000000000000003C0000003C0000000000000
+FE67:00007FFE61866FBE638E6FBE6F867FFE7FFE73866FF663EE6DDE73DE7FFE0000
+FE68:0000000000000000000000000000000000000200010000800040000000000000
+FE69:0000000000000000000000000000000000000380050003800140038000000000
+FE6A:0000000000000000000000000000000002000240008001000240004000000000
+FE6B:000000000000000000000000000000000180024002C002C00200018000000000
+FE6C:00007FFE61866FBE638E6FBE6F867FFE7FFE73C66FBE63BE6DBE73C67FFE0000
+FE6D:00007FFE61866FBE638E6FBE6F867FFE7FFE738E6FB663B66DB6738E7FFE0000
+FE6E:00007FFE61866FBE638E6FBE6F867FFE7FFE73866FBE638E6DBE73867FFE0000
+FE6F:00007FFE61866FBE638E6FBE6F867FFE7FFE73866FBE638E6DBE73BE7FFE0000
+FE70:000C300C300000000000000000000000
+FE71:000C300C300000000000FF0000000000
+FE72:0C0C6428700000000000000000000000
+FE73:00000000000000000000020404040300
+FE74:000000000000000000000C300C300000
+FE75:00007FFE61866FBE638E6FBE6F867FFE7FFE61867DBE7B8677F677867FFE0000
+FE76:0000000C300000000000000000000000
+FE77:0000000C300000000000FF0000000000
+FE78:0C0E0810200000000000000000000000
+FE79:0C0E0810200000000000FF0000000000
+FE7A:00000000000000000000000000000C30
+FE7B:00000000000000000000FF0000000C30
+FE7C:00000004145860000000000000000000
+FE7D:00000004145860000000FF0000000000
+FE7E:00000018242418000000000000000000
+FE7F:00000018242418000000FF0000000000
+FE80:000000000000001C203C102000000000
+FE81:00013E40080808080808080000000000
+FE82:000870802020202020201F0000000000
+FE83:18201820080808080808080000000000
+FE84:304030402020202020201F0000000000
+FE85:00000C100C10000C12121E0204483000
+FE86:00000C100C10000C12121F0204483000
+FE87:0000000008080808080808000C100C10
+FE88:000000002020202020201F0030403040
+FE89:00000000304030400046484846423C00
+FE8A:000000003040304000404342423C0000
+FE8B:0000000C100C10000404F80000000000
+FE8C:0000000C100C10000404FB0000000000
+FE8D:00000008080808080808080000000000
+FE8E:000000202020202020201F0000000000
+FE8F:000000000000000422423C0000080000
+FE90:000000000000000422423F0000080000
+FE91:00000000000000080404FC0000100000
+FE92:00000000000000080404FF0000100000
+FE93:000000002400101824243C0000000000
+FE94:0000001200040C14243C070000000000
+FE95:000000001400000422423C0000000000
+FE96:000000001400000422423F0000000000
+FE97:00000000280000080404F80000000000
+FE98:00000000280000080404FF0000000000
+FE99:000010002400000422423C0000000000
+FE9A:000010002400000422423F0000000000
+FE9B:00002000480000080404F80000000000
+FE9C:00002000480000080404FF0000000000
+FE9D:00000000000000007E1020404840221C
+FE9E:00000000000000007E1423404840211E
+FE9F:00000000000000003806FE0010000000
+FEA0:00000000000000003806FF0010000000
+FEA1:00000000000000007E1020404040221C
+FEA2:00000000000000007E1423404040211E
+FEA3:0000000000000000700CFC0000000000
+FEA4:0000000000000000700CFF0000000000
+FEA5:00000000001000007E1020404040221C
+FEA6:00000000001000007E1423404040211E
+FEA7:0000000000200000700CFC0000000000
+FEA8:0000000000200000700CFF0000000000
+FEA9:000000000000080402427C0000000000
+FEAA:000000000000080402427F0000000000
+FEAB:000000002000080402427C0000000000
+FEAC:000000002000080402427F0000000000
+FEAD:00000000000000000402020204483000
+FEAE:00000000000000000402030204483000
+FEAF:00000000001000000402020204483000
+FEB0:00000000001000000402030204483000
+FEB1:000000000000000115155E4848300000
+FEB2:000000000000000115155F4848300000
+FEB3:00000000000000022A2AFC0000000000
+FEB4:00000000000000022A2AFF0000000000
+FEB5:00000008001200000115155E48483000
+FEB6:000000080012000115155F4848300000
+FEB7:00000010002400022A2AFC0000000000
+FEB8:00000010002400022A2AFF0000000000
+FEB9:000000000000000006194E4848300000
+FEBA:000000000000000006194F4848300000
+FEBB:00000000000000000C52FC0000000000
+FEBC:00000000000000000C52FF0000000000
+FEBD:000000000004000006194E4848300000
+FEBE:000000000004000006194F4848300000
+FEBF:00000000000800000C52FC0000000000
+FEC0:00000000000800000C52FF0000000000
+FEC1:000000202020202C32227C0000000000
+FEC2:000000202020202C32227F0000000000
+FEC3:000000202020202C3222FC0000000000
+FEC4:000000202020202C3222FF0000000000
+FEC5:000000202420202C32227C0000000000
+FEC6:000000202420202C32227F0000000000
+FEC7:000000202420202C3222FC0000000000
+FEC8:000000202420202C3222FF0000000000
+FEC9:000000000000001824201C204040423C
+FECA:000000000000000030301F204040423C
+FECB:00000000000000182420FE0000000000
+FECC:00000000000000181808F70000000000
+FECD:000000000800001824201C204040423C
+FECE:000000000010000030301F204040423C
+FECF:00000000080000182420FE0000000000
+FED0:00000000080000181808F70000000000
+FED1:0000000800060A0642423C0000000000
+FED2:0000000800060A0642423F0000000000
+FED3:0000001000003824140CF80000000000
+FED4:0000001000003824140CFB0000000000
+FED5:000000002400001C120A264244380000
+FED6:000000002400001C120A274244380000
+FED7:0000004800003824140CF80000000000
+FED8:0000004800003824140CFB0000000000
+FED9:000000020A120A2242423C0000000000
+FEDA:000000020A120A2242423F0000000000
+FEDB:00000004081020403C02FE0000000000
+FEDC:00000004081020403C02FF0000000000
+FEDD:000000020202020202224242443C0000
+FEDE:000000020202020202234242443C0000
+FEDF:00000004040404040404F80000000000
+FEE0:00000004040404040404FB0000000000
+FEE1:00000000000000001C061E2020202020
+FEE2:00000000000000001C061F2020202020
+FEE3:00000000000000081432EE0000000000
+FEE4:00000000000000081432EF0000000000
+FEE5:00000000001000000422424244380000
+FEE6:00000000001000000422434244380000
+FEE7:00000000100000080404F80000000000
+FEE8:00000000100000080404FB0000000000
+FEE9:000000000000101824243C0000000000
+FEEA:0000000004040C14243C070000000000
+FEEB:000000000010083C2A3AF60000000000
+FEEC:000000000000000C1414FF140C000000
+FEED:000000000000000C12121E0204483000
+FEEE:000000000000000C12121F0204483000
+FEEF:0000000000000000044A484442423C00
+FEF0:00000000000000000000434442423C00
+FEF1:0000000000000000044A4844423C0028
+FEF2:000000000000000000004344423C0028
+FEF3:00000000000000080804F80028000000
+FEF4:00000000000000080804FB0028000000
+FEF5:000008728222120A040C141C00000000
+FEF6:000008728222120A0E0A136000000000
+FEF7:000030423242120A040C141C00000000
+FEF8:000030423242120A0E0A136000000000
+FEF9:0000020222120A040C141C000C100C10
+FEFA:000000020222120A0E0A13600C100C10
+FEFB:000000020222120A040C141C00000000
+FEFC:000000020222120A0E0A136000000000
+FEFD:00007FFE61866FBE638E6FBE6F867FFE7FFE618E6FB663B66FB66F8E7FFE0000
+FEFE:00007FFE61866FBE638E6FBE6F867FFE7FFE61866FBE638E6FBE6F867FFE0000
+FEFF:AAAA0001F4511458A55546D2F4510001F1DE4A10F19E4851F390000180005555
+FF00:00007FFE61866FBE638E6FBE6FBE7FFE7FFE73CE6DB66DB66DB673CE7FFE0000
+FF01:0000000000000000018001800180018001800180018000000180018000000000
+FF02:000000000C300C300C300C300000000000000000000000000000000000000000
+FF03:0000000000000000030C030C030C3FFC0C300C303FFC30C030C030C000000000
+FF04:000000000000000001801FF8618661801F8001F8018661861FF8018000000000
+FF05:00000000000000001E06619861981E6001800180067819861986607800000000
+FF06:000000000000000007E018181818181807E01F866066601860781F8600000000
+FF07:0000000001800180018001800000000000000000000000000000000000000000
+FF08:000000000000003000C000C003000300030003000300030000C000C000300000
+FF09:0000000000000C000300030000C000C000C000C000C000C0030003000C000000
+FF0A:00000000000000000000000001806186199807E0199861860180000000000000
+FF0B:0000000000000000000000000180018001807FFE018001800180000000000000
+FF0C:00000000000000000000000000000000000000000000000003C000C000C00300
+FF0D:0000000000000000000000000000000000003FFC000000000000000000000000
+FF0E:00000000000000000000000000000000000000000000000003C003C000000000
+FF0F:0000000000000000000C000C003000C000C0030003000C003000300000000000
+FF10:000000000000000003C00C30300C303C30CC330C3C0C300C0C3003C000000000
+FF11:00000000000000000180078019800180018001800180018001801FF800000000
+FF12:00000000000000000FF0300C300C000C00F003000C00300030003FFC00000000
+FF13:00000000000000000FF0300C300C000C03F0000C000C300C300C0FF000000000
+FF14:0000000000000000003000F003300C30303030303FFC00300030003000000000
+FF15:00000000000000003FFC3000300030003FF0000C000C000C300C0FF000000000
+FF16:000000000000000003F00C00300030003FF0300C300C300C300C0FF000000000
+FF17:00000000000000003FFC000C000C00300030003000C000C000C000C000000000
+FF18:00000000000000000FF0300C300C300C0FF0300C300C300C300C0FF000000000
+FF19:00000000000000000FF0300C300C300C0FFC000C000C000C00300FC000000000
+FF1A:00000000000000000000000003C003C000000000000003C003C0000000000000
+FF1B:00000000000000000000000003C003C000000000000003C000C000C003000000
+FF1C:0000000000000000000000180060018006001800060001800060001800000000
+FF1D:00000000000000000000000000003FFC0000000000003FFC0000000000000000
+FF1E:0000000000000000000018000600018000600018006001800600180000000000
+FF1F:00000000000000000FF0300C300C000C003000C000C0000000C000C000000000
+FF20:000000000000000003F00C0C30CC333C330C330C330C30FC0C0003FC00000000
+FF21:000000000000000003C00C300C30300C300C3FFC300C300C300C300C00000000
+FF22:00000000000000003FF0300C300C300C3FF0300C300C300C300C3FF000000000
+FF23:00000000000000000FF0300C300C3000300030003000300C300C0FF000000000
+FF24:00000000000000003FC03030300C300C300C300C300C300C30303FC000000000
+FF25:00000000000000003FFC3000300030003FF030003000300030003FFC00000000
+FF26:00000000000000003FFC3000300030003FF03000300030003000300000000000
+FF27:00000000000000000FF0300C300C3000300030FC300C300C303C0FCC00000000
+FF28:0000000000000000300C300C300C300C3FFC300C300C300C300C300C00000000
+FF29:00000000000000001FF8018001800180018001800180018001801FF800000000
+FF2A:000000000000000007FE006000600060006000600060606060601F8000000000
+FF2B:0000000000000000300C303030C033003C003C00330030C03030300C00000000
+FF2C:00000000000000003000300030003000300030003000300030003FFC00000000
+FF2D:0000000000000000300C300C3C3C3C3C33CC33CC300C300C300C300C00000000
+FF2E:0000000000000000300C3C0C3C0C330C330C30CC30CC303C303C300C00000000
+FF2F:00000000000000000FF0300C300C300C300C300C300C300C300C0FF000000000
+FF30:00000000000000003FF0300C300C300C3FF03000300030003000300000000000
+FF31:00000000000000000FF0300C300C300C300C300C300C33CC3C3C0FF0000F0000
+FF32:00000000000000003FF0300C300C300C3FF030C030303030300C300C00000000
+FF33:00000000000000000FF0300C300C30000F0000F0000C300C300C0FF000000000
+FF34:00000000000000007FFE01800180018001800180018001800180018000000000
+FF35:0000000000000000300C300C300C300C300C300C300C300C300C0FF000000000
+FF36:0000000000000000600660066006181818181818066006600180018000000000
+FF37:0000000000000000300C300C300C300C33CC33CC3C3C3C3C300C300C00000000
+FF38:0000000000000000300C300C0C300C3003C003C00C300C30300C300C00000000
+FF39:0000000000000000600660061818181806600180018001800180018000000000
+FF3A:00000000000000003FFC000C000C003000C003000C00300030003FFC00000000
+FF3B:00000000000003F0030003000300030003000300030003000300030003F00000
+FF3C:0000000000000000300030000C000300030000C000C00030000C000C00000000
+FF3D:0000000000000FC000C000C000C000C000C000C000C000C000C000C00FC00000
+FF3E:0000000003C00C30300C00000000000000000000000000000000000000000000
+FF3F:000000000000000000000000000000000000000000000000000000007FFE0000
+FF40:0000060001800060000000000000000000000000000000000000000000000000
+FF41:0000000000000000000000000FF0300C000C0FFC300C300C303C0FCC00000000
+FF42:00000000000030003000300033F03C0C300C300C300C300C3C0C33F000000000
+FF43:0000000000000000000000000FF0300C3000300030003000300C0FF000000000
+FF44:000000000000000C000C000C0FCC303C300C300C300C300C303C0FCC00000000
+FF45:0000000000000000000000000FF0300C300C3FFC30003000300C0FF000000000
+FF46:00000000000000780180018001801FF801800180018001800180018000000000
+FF47:00000000000000000000000C0FCC3030303030300FC00C000FF0300C300C0FF0
+FF48:00000000000030003000300033F03C0C300C300C300C300C300C300C00000000
+FF49:00000000000001800180000007800180018001800180018001801FF800000000
+FF4A:00000000000000300030000000F0003000300030003000300030003030C00F00
+FF4B:000000000000300030003000303030C033003C00330030C03030300C00000000
+FF4C:00000000000007800180018001800180018001800180018001801FF800000000
+FF4D:0000000000000000000000007E78618661866186618661866186618600000000
+FF4E:00000000000000000000000033F03C0C300C300C300C300C300C300C00000000
+FF4F:0000000000000000000000000FF0300C300C300C300C300C300C0FF000000000
+FF50:00000000000000000000000033F03C0C300C300C300C300C3C0C33F030003000
+FF51:0000000000000000000000000FCC303C300C300C300C300C303C0FCC000C000C
+FF52:00000000000000000000000033F03C0C300C3000300030003000300000000000
+FF53:0000000000000000000000000FF0300C30000F0000F0000C300C0FF000000000
+FF54:00000000000000000180018001801FF801800180018001800180007800000000
+FF55:000000000000000000000000300C300C300C300C300C300C303C0FCC00000000
+FF56:000000000000000000000000300C300C300C0C300C300C3003C003C000000000
+FF57:00000000000000000000000060066186618661866186618661861E7800000000
+FF58:000000000000000000000000300C300C0C3003C003C00C30300C300C00000000
+FF59:000000000000000000000000300C300C300C300C300C0C3C03CC000C000C0FF0
+FF5A:0000000000000000000000003FFC000C003000C003000C0030003FFC00000000
+FF5B:00000000000000F00300030000C000C003000C00030000C000C00300030000F0
+FF5C:0000000001800180018001800180018001800180018001800180018001800180
+FF5D:0000000000000F0000C000C00300030000C0003000C00300030000C000C00F00
+FF5E:0000000000001E06618660780000000000000000000000000000000000000000
+FF5F:0000000000000186061806181860186018601860186018600618061801860000
+FF60:0000000000006180186018600618061806180618061806181860186061800000
+FF61:00000000000000000000000030484830
+FF62:3E202020202020202020200000000000
+FF63:0000000000020202020202020202023E
+FF64:00000000000000000000000000402010
+FF65:00000000000000181800000000000000
+FF66:00007E0202027E020202040408106000
+FF67:00000000007E02041408080810102000
+FF68:00000000000204081868080808080800
+FF69:000000000808087F4141010202041800
+FF6A:000000000000003E0808080808087F00
+FF6B:000000000004047F040C142444040C00
+FF6C:000000002020207F1112100808080800
+FF6D:000000000000003C040404047F000000
+FF6E:0000000000007E02027E02027E000000
+FF6F:00000000000000292929020204083000
+FF70:000000000000403F0000000000000000
+FF71:00007F01090A0A080808081010202000
+FF72:000101010202040C1464040404040400
+FF73:000808087F4141410101010202041800
+FF74:0000003E0808080808080808087F0000
+FF75:0004047F040C0C141414242444040C00
+FF76:000808087F0909090911111222224400
+FF77:001010101E7008080F78080804040400
+FF78:0008080F111121410202040408106000
+FF79:002020203F2424440404040808102000
+FF7A:0000007E0202020202020202027E0000
+FF7B:001212127F1212121204040408081000
+FF7C:00003800000071010102020408106000
+FF7D:0000007E020404040808141222214100
+FF7E:00101010101779111212101010080700
+FF7F:00014141210102020204040808102000
+FF80:0008080F111129450202040408106000
+FF81:00020C384808087F0808080810106000
+FF82:00005252524202040404080810204000
+FF83:00003E0000007F080808080810102000
+FF84:00202020202038242220202020202000
+FF85:00080808087F08080808081010204000
+FF86:0000003E0000000000000000007F0000
+FF87:00007F010101221A04060A0911214000
+FF88:000808087F0204040A19294808080800
+FF89:00000202020202040404080810204000
+FF8A:00001212121212111121212121414000
+FF8B:00404040404046784040404040201E00
+FF8C:00007F01010102020204040808102000
+FF8D:00001028284444040202020101010000
+FF8E:000808087F08082A2A2A494949080800
+FF8F:00007E02020204242418181008080800
+FF90:000038060100300C0200700C02010000
+FF91:00080808080810101012222127394100
+FF92:0001010102320A04060A091111204000
+FF93:00003E080808087F0808080808080700
+FF94:00202020277921121210100808080800
+FF95:000000003C04040404040404047F0000
+FF96:0000007E020202027E02020202027E00
+FF97:00003C0000007E020202040408102000
+FF98:00022222222222220204040408081000
+FF99:000008282828282929292A2A4C4C4800
+FF9A:00004040404040424242444448506000
+FF9B:0000007E42424242424242427E420000
+FF9C:00007E42424242020404040808102000
+FF9D:00006010000101010102020408106000
+FF9E:00001048241000000000000000000000
+FF9F:00003048483000000000000000000000
+FFA0:00000000000000000000000000000000
+FFA1:0000000000000000007E020202020000
+FFA2:0000000000000000006C242424240000
+FFA3:00000000000000007414141A11000000
+FFA4:000000000000000000404040407E0000
+FFA5:0000000000000000002424242A390000
+FFA6:000000000000000000222722253A0000
+FFA7:0000000000000000007E4040407E0000
+FFA8:0000000000000000006C4848486C0000
+FFA9:0000000000000000003C043C203C0000
+FFAA:00000000000000000076127242720000
+FFAB:000000000000000000EE2AEA8AEE0000
+FFAC:000000000000000000EA2AEE8AEE0000
+FFAD:000000000000000000E424E48AEA0000
+FFAE:000000000000000000EE28EE88EE0000
+FFAF:000000000000000000FF2AEA8AFF0000
+FFB0:000000000000000000E42EE48AE40000
+FFB1:0000000000000000007C4444447C0000
+FFB2:00000000000000000042427E427E0000
+FFB3:000000000000000000AAAAEEAAEE0000
+FFB4:0000000000000000005454745A710000
+FFB5:00000000000000000010101028440000
+FFB6:0000000000000000002424245A910000
+FFB7:00000000000000101038444444380000
+FFB8:0000000000000000007C101028440000
+FFB9:0000000000000000007E24245A910000
+FFBA:000000000000000038007C1028440000
+FFBB:0000000000000000007E027E02020000
+FFBC:0000000000000000007E407E407E0000
+FFBD:0000000000000000007E2424247E0000
+FFBE:00000000000000000038FE3844380000
+FFBF:00007FFE61866FBE638E6FBE6FBE7FFE7FFE63866DBE638E6DBE63BE7FFE0000
+FFC0:00007FFE61866FBE638E6FBE6FBE7FFE7FFE71CE6FB66FB66FB671CE7FFE0000
+FFC1:00007FFE61866FBE638E6FBE6FBE7FFE7FFE71EE6FCE6FEE6FEE71C67FFE0000
+FFC2:00000000000000000020203820200000
+FFC3:00000000000000000028283828280000
+FFC4:00000000000000000020382038200000
+FFC5:00000000000000000028382838280000
+FFC6:00000000000000000008083808080000
+FFC7:00000000000000000014147414140000
+FFC8:00007FFE61866FBE638E6FBE6FBE7FFE7FFE71CE6FB66FCE6FB671CE7FFE0000
+FFC9:00007FFE61866FBE638E6FBE6FBE7FFE7FFE71CE6FB66FC66FF671CE7FFE0000
+FFCA:00000000000000000008380838080000
+FFCB:00000000000000000014741474140000
+FFCC:000000000000000000101010107C0000
+FFCD:000000000000000000040414147E0000
+FFCE:0000000000000000000A0A2A2AFE0000
+FFCF:000000000000000000040414147C0000
+FFD0:00007FFE61866FBE638E6FBE6FBE7FFE7FFE63CE6DB66DB66DB663CE7FFE0000
+FFD1:00007FFE61866FBE638E6FBE6FBE7FFE7FFE63EE6DCE6DEE6DEE63C67FFE0000
+FFD2:000000000000000000282828287C0000
+FFD3:0000000000000000007C101010100000
+FFD4:0000000000000004043C141C14140000
+FFD5:000000000000000A0A7A2A3A2A2A0000
+FFD6:0000000000000004043C141414140000
+FFD7:0000000000000000007C282828280000
+FFD8:00007FFE61866FBE638E6FBE6FBE7FFE7FFE63CE6DB66DCE6DB663CE7FFE0000
+FFD9:00007FFE61866FBE638E6FBE6FBE7FFE7FFE63CE6DB66DC66DF663CE7FFE0000
+FFDA:00000000000000000000007E00000000
+FFDB:00000000000000000008081828080000
+FFDC:00000000000000000008080808080000
+FFDD:00007FFE61866FBE638E6FBE6FBE7FFE7FFE638E6DB66DB66DB6638E7FFE0000
+FFDE:00007FFE61866FBE638E6FBE6FBE7FFE7FFE63866DBE6D8E6DBE63867FFE0000
+FFDF:00007FFE61866FBE638E6FBE6FBE7FFE7FFE63866DBE6D8E6DBE63BE7FFE0000
+FFE0:0000000000000000018001801FF861866180618061861FF80180018000000000
+FFE1:000000000000000001F80600060006007FE00600060006001FF8780600000000
+FFE2:00000000000000000000000000000000000000003FFC000C000C000C00000000
+FFE3:000000003FFC0000000000000000000000000000000000000000000000000000
+FFE4:0000000000000000018001800180018000000000018001800180018000000000
+FFE5:000000000000000060061818066001807FFE01807FFE01800180018000000000
+FFE6:00000000000000001818181818187FFE19987FFE1E781E781818181800000000
+FFE7:00007FFE61866FBE638E6FBE6FBE7FFE7FFE61866FF663EE6FDE61DE7FFE0000
+FFE8:08080808080808080808080808080808
+FFE9:000000000010207E2010000000000000
+FFEA:0000000000081C2A0808080000000000
+FFEB:00000000000008047E04080000000000
+FFEC:00000000000808082A1C080000000000
+FFED:000000000000007E7E7E7E7E7E000000
+FFEE:00000000000018244242241800000000
+FFEF:00007FFE61866FBE638E6FBE6FBE7FFE7FFE61866FBE638E6FBE61BE7FFE0000
+FFF0:00007FFE61866FBE638E6FBE6FBE7FFE7FFE61CE6FB663B66FB66FCE7FFE0000
+FFF1:00007FFE61866FBE638E6FBE6FBE7FFE7FFE61EE6FCE63EE6FEE6FC67FFE0000
+FFF2:00007FFE61866FBE638E6FBE6FBE7FFE7FFE61866FF663866FBE6F867FFE0000
+FFF3:00007FFE61866FBE638E6FBE6FBE7FFE7FFE618E6FF663C66FF66F8E7FFE0000
+FFF4:00007FFE61866FBE638E6FBE6FBE7FFE7FFE61B66FB663866FF66FF67FFE0000
+FFF5:00007FFE61866FBE638E6FBE6FBE7FFE7FFE61866FBE63866FF66F867FFE0000
+FFF6:00007FFE61866FBE638E6FBE6FBE7FFE7FFE61CE6FBE638E6FB66FCE7FFE0000
+FFF7:00007FFE61866FBE638E6FBE6FBE7FFE7FFE61866FF663EE6FDE6FDE7FFE0000
+FFF8:00007FFE61866FBE638E6FBE6FBE7FFE7FFE61CE6FB663CE6FB66FCE7FFE0000
+FFF9:AAAA000180003E118828083988443E4580000081814001C18220022180005555
+FFFA:AAAA000180003E118828083988443E45800001E1820001C1802003C180005555
+FFFB:AAAA000180003E118828083988443E45800003E1808000818080008180005555
+FFFC:5555800000018000000180001185A9442985A94411998000000180000001AAAA
+FFFD:0000007E665A5A7A76767E76767E0000
diff --git a/Engine/lib/sdl/visualtest/Makefile.in b/Engine/lib/sdl/visualtest/Makefile.in
index 2efcdb1c8..3cf2f6df4 100644
--- a/Engine/lib/sdl/visualtest/Makefile.in
+++ b/Engine/lib/sdl/visualtest/Makefile.in
@@ -1,15 +1,20 @@
 # Makefile to build the SDL tests
+
 srcdir  = @srcdir@
 CC      = @CC@
 EXE	= @EXE@
 CFLAGS  = @CFLAGS@ -I../include -I./include
 LIBS	= @LIBS@
+
 TARGETS = \
 	testharness$(EXE) \
 	testquit$(EXE)
+
 all: Makefile $(TARGETS)
+
 Makefile: $(srcdir)/Makefile.in
 	$(SHELL) config.status $@
+
 testharness$(EXE): $(srcdir)/src/action_configparser.c \
 		   $(srcdir)/src/harness_argparser.c \
 		   $(srcdir)/src/rwhelper.c \
@@ -27,8 +32,10 @@ testharness$(EXE): $(srcdir)/src/action_configparser.c \
 		   $(srcdir)/src/windows/windows_process.c \
 		   $(srcdir)/src/windows/windows_screenshot.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
+
 testquit$(EXE): $(srcdir)/unittest/testquit.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
+
 clean:
 	rm -f $(TARGETS)
 distclean: clean
diff --git a/Engine/lib/sdl/visualtest/README.txt b/Engine/lib/sdl/visualtest/README.txt
index 46132def1..5a5539507 100644
--- a/Engine/lib/sdl/visualtest/README.txt
+++ b/Engine/lib/sdl/visualtest/README.txt
@@ -3,7 +3,7 @@
 \mainpage Visual and Interactive Test Automation for SDL 2.0
 
 \section license_sec License
-Check the file \c COPYING.txt for licensing information.
+Check the file \c LICENSE.txt for licensing information.
 
 \section intro_sec Introduction
 The goal of this GSoC project is to automate the testing of testsprite2.
diff --git a/Engine/lib/sdl/visualtest/acinclude.m4 b/Engine/lib/sdl/visualtest/acinclude.m4
index ead69e514..0fdf353ea 100644
--- a/Engine/lib/sdl/visualtest/acinclude.m4
+++ b/Engine/lib/sdl/visualtest/acinclude.m4
@@ -5,13 +5,13 @@
 # stolen from Manish Singh
 # Shamelessly stolen from Owen Taylor
 
-# serial 1
+# serial 2
 
-dnl AM_PATH_SDL([MINIMUM-VERSION, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]]])
+dnl AM_PATH_SDL2([MINIMUM-VERSION, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]]])
 dnl Test for SDL, and define SDL_CFLAGS and SDL_LIBS
 dnl
 AC_DEFUN([AM_PATH_SDL2],
-[dnl 
+[dnl
 dnl Get the cflags and libraries from the sdl2-config script
 dnl
 AC_ARG_WITH(sdl-prefix,[  --with-sdl-prefix=PFX   Prefix where SDL is installed (optional)],
@@ -21,7 +21,7 @@ AC_ARG_WITH(sdl-exec-prefix,[  --with-sdl-exec-prefix=PFX Exec prefix where SDL
 AC_ARG_ENABLE(sdltest, [  --disable-sdltest       Do not try to compile and run a test SDL program],
 		    , enable_sdltest=yes)
 
-  min_sdl_version=ifelse([$1], ,0.9.0,$1)
+  min_sdl_version=ifelse([$1], ,2.0.0,$1)
 
   if test "x$sdl_prefix$sdl_exec_prefix" = x ; then
     PKG_CHECK_MODULES([SDL], [sdl2 >= $min_sdl_version],
@@ -31,42 +31,42 @@ AC_ARG_ENABLE(sdltest, [  --disable-sdltest       Do not try to compile and run
     sdl_pc=no
     if test x$sdl_exec_prefix != x ; then
       sdl_config_args="$sdl_config_args --exec-prefix=$sdl_exec_prefix"
-      if test x${SDL_CONFIG+set} != xset ; then
-        SDL_CONFIG=$sdl_exec_prefix/bin/sdl2-config
+      if test x${SDL2_CONFIG+set} != xset ; then
+        SDL2_CONFIG=$sdl_exec_prefix/bin/sdl2-config
       fi
     fi
     if test x$sdl_prefix != x ; then
       sdl_config_args="$sdl_config_args --prefix=$sdl_prefix"
-      if test x${SDL_CONFIG+set} != xset ; then
-        SDL_CONFIG=$sdl_prefix/bin/sdl2-config
+      if test x${SDL2_CONFIG+set} != xset ; then
+        SDL2_CONFIG=$sdl_prefix/bin/sdl2-config
       fi
     fi
   fi
 
   if test "x$sdl_pc" = xyes ; then
     no_sdl=""
-    SDL_CONFIG="pkg-config sdl2"
+    SDL2_CONFIG="pkg-config sdl2"
   else
     as_save_PATH="$PATH"
     if test "x$prefix" != xNONE && test "$cross_compiling" != yes; then
       PATH="$prefix/bin:$prefix/usr/bin:$PATH"
     fi
-    AC_PATH_PROG(SDL_CONFIG, sdl2-config, no, [$PATH])
+    AC_PATH_PROG(SDL2_CONFIG, sdl2-config, no, [$PATH])
     PATH="$as_save_PATH"
     AC_MSG_CHECKING(for SDL - version >= $min_sdl_version)
     no_sdl=""
 
-    if test "$SDL_CONFIG" = "no" ; then
+    if test "$SDL2_CONFIG" = "no" ; then
       no_sdl=yes
     else
-      SDL_CFLAGS=`$SDL_CONFIG $sdl_config_args --cflags`
-      SDL_LIBS=`$SDL_CONFIG $sdl_config_args --libs`
+      SDL_CFLAGS=`$SDL2_CONFIG $sdl_config_args --cflags`
+      SDL_LIBS=`$SDL2_CONFIG $sdl_config_args --libs`
 
-      sdl_major_version=`$SDL_CONFIG $sdl_config_args --version | \
+      sdl_major_version=`$SDL2_CONFIG $sdl_config_args --version | \
              sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\1/'`
-      sdl_minor_version=`$SDL_CONFIG $sdl_config_args --version | \
+      sdl_minor_version=`$SDL2_CONFIG $sdl_config_args --version | \
              sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\2/'`
-      sdl_micro_version=`$SDL_CONFIG $sdl_config_args --version | \
+      sdl_micro_version=`$SDL2_CONFIG $sdl_config_args --version | \
              sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\3/'`
       if test "x$enable_sdltest" = "xyes" ; then
         ac_save_CFLAGS="$CFLAGS"
@@ -80,41 +80,19 @@ dnl Now check if the installed SDL is sufficiently new. (Also sanity
 dnl checks the results of sdl2-config to some extent
 dnl
       rm -f conf.sdltest
-      AC_TRY_RUN([
+      AC_RUN_IFELSE([AC_LANG_SOURCE([[
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
 #include "SDL.h"
 
-char*
-my_strdup (char *str)
-{
-  char *new_str;
-  
-  if (str)
-    {
-      new_str = (char *)malloc ((strlen (str) + 1) * sizeof(char));
-      strcpy (new_str, str);
-    }
-  else
-    new_str = NULL;
-  
-  return new_str;
-}
-
 int main (int argc, char *argv[])
 {
   int major, minor, micro;
-  char *tmp_version;
+  FILE *fp = fopen("conf.sdltest", "w");
 
-  /* This hangs on some systems (?)
-  system ("touch conf.sdltest");
-  */
-  { FILE *fp = fopen("conf.sdltest", "a"); if ( fp ) fclose(fp); }
+  if (fp) fclose(fp);
 
-  /* HP/UX 9 (%@#!) writes to sscanf strings */
-  tmp_version = my_strdup("$min_sdl_version");
-  if (sscanf(tmp_version, "%d.%d.%d", &major, &minor, &micro) != 3) {
+  if (sscanf("$min_sdl_version", "%d.%d.%d", &major, &minor, &micro) != 3) {
      printf("%s, bad version string\n", "$min_sdl_version");
      exit(1);
    }
@@ -130,14 +108,14 @@ int main (int argc, char *argv[])
       printf("\n*** 'sdl2-config --version' returned %d.%d.%d, but the minimum version\n", $sdl_major_version, $sdl_minor_version, $sdl_micro_version);
       printf("*** of SDL required is %d.%d.%d. If sdl2-config is correct, then it is\n", major, minor, micro);
       printf("*** best to upgrade to the required version.\n");
-      printf("*** If sdl2-config was wrong, set the environment variable SDL_CONFIG\n");
+      printf("*** If sdl2-config was wrong, set the environment variable SDL2_CONFIG\n");
       printf("*** to point to the correct copy of sdl2-config, and remove the file\n");
       printf("*** config.cache before re-running configure\n");
       return 1;
     }
 }
 
-],, no_sdl=yes,[echo $ac_n "cross compiling; assumed OK... $ac_c"])
+]])], [], [no_sdl=yes], [echo $ac_n "cross compiling; assumed OK... $ac_c"])
         CFLAGS="$ac_save_CFLAGS"
         CXXFLAGS="$ac_save_CXXFLAGS"
         LIBS="$ac_save_LIBS"
@@ -152,10 +130,10 @@ int main (int argc, char *argv[])
   if test "x$no_sdl" = x ; then
      ifelse([$2], , :, [$2])
   else
-     if test "$SDL_CONFIG" = "no" ; then
+     if test "$SDL2_CONFIG" = "no" ; then
        echo "*** The sdl2-config script installed by SDL could not be found"
        echo "*** If SDL was installed in PREFIX, make sure PREFIX/bin is in"
-       echo "*** your path, or set the SDL_CONFIG environment variable to the"
+       echo "*** your path, or set the SDL2_CONFIG environment variable to the"
        echo "*** full path to sdl2-config."
      else
        if test -f conf.sdltest ; then
@@ -165,7 +143,7 @@ int main (int argc, char *argv[])
           CFLAGS="$CFLAGS $SDL_CFLAGS"
           CXXFLAGS="$CXXFLAGS $SDL_CFLAGS"
           LIBS="$LIBS $SDL_LIBS"
-          AC_TRY_LINK([
+          AC_LINK_IFELSE([AC_LANG_PROGRAM([[
 #include <stdio.h>
 #include "SDL.h"
 
@@ -173,7 +151,7 @@ int main(int argc, char *argv[])
 { return 0; }
 #undef  main
 #define main K_and_R_C_main
-],      [ return 0; ],
+]], [[ return 0; ]])],
         [ echo "*** The test program compiled, but did not run. This usually means"
           echo "*** that the run-time linker is not finding SDL or finding the wrong"
           echo "*** version of SDL. If it is not finding SDL, you'll need to set your"
@@ -186,7 +164,7 @@ int main(int argc, char *argv[])
         [ echo "*** The test program failed to compile or link. See the file config.log for the"
           echo "*** exact error that occured. This usually means SDL was incorrectly installed"
           echo "*** or that you have moved SDL since it was installed. In the latter case, you"
-          echo "*** may want to edit the sdl2-config script: $SDL_CONFIG" ])
+          echo "*** may want to edit the sdl2-config script: $SDL2_CONFIG" ])
           CFLAGS="$ac_save_CFLAGS"
           CXXFLAGS="$ac_save_CXXFLAGS"
           LIBS="$ac_save_LIBS"
@@ -228,7 +206,7 @@ int main(int argc, char *argv[])
 # ----------------------------------
 AC_DEFUN([PKG_PROG_PKG_CONFIG],
 [m4_pattern_forbid([^_?PKG_[A-Z_]+$])
-m4_pattern_allow([^PKG_CONFIG(_PATH)?$])
+m4_pattern_allow([^PKG_CONFIG(_PATH|_LIBDIR)?$])
 AC_ARG_VAR([PKG_CONFIG], [path to pkg-config utility])
 AC_ARG_VAR([PKG_CONFIG_PATH], [directories to add to pkg-config's search path])
 AC_ARG_VAR([PKG_CONFIG_LIBDIR], [path overriding pkg-config's built-in search path])
@@ -309,7 +287,7 @@ AC_ARG_VAR([$1][_CFLAGS], [C compiler flags for $1, overriding pkg-config])dnl
 AC_ARG_VAR([$1][_LIBS], [linker flags for $1, overriding pkg-config])dnl
 
 pkg_failed=no
-AC_MSG_CHECKING([for $1])
+AC_MSG_CHECKING([for $2])
 
 _PKG_CONFIG([$1][_CFLAGS], [cflags], [$2])
 _PKG_CONFIG([$1][_LIBS], [libs], [$2])
@@ -337,7 +315,7 @@ $$1_PKG_ERRORS
 Consider adjusting the PKG_CONFIG_PATH environment variable if you
 installed software in a non-standard prefix.
 
-_PKG_TEXT])dnl
+_PKG_TEXT])[]dnl
         ])
 elif test $pkg_failed = untried; then
      	AC_MSG_RESULT([no])
@@ -348,7 +326,7 @@ path to pkg-config.
 
 _PKG_TEXT
 
-To get pkg-config, see <http://pkg-config.freedesktop.org/>.])dnl
+To get pkg-config, see <http://pkg-config.freedesktop.org/>.])[]dnl
         ])
 else
 	$1[]_CFLAGS=$pkg_cv_[]$1[]_CFLAGS
diff --git a/Engine/lib/sdl/visualtest/autogen.sh b/Engine/lib/sdl/visualtest/autogen.sh
index 939f34c0f..988d41760 100644
--- a/Engine/lib/sdl/visualtest/autogen.sh
+++ b/Engine/lib/sdl/visualtest/autogen.sh
@@ -1,12 +1,11 @@
 #!/bin/sh
-#
-# Regenerate configuration files
+
 cp acinclude.m4 aclocal.m4
-found=false
-for autoconf in autoconf autoconf259 autoconf-2.59
-do if which $autoconf >/dev/null 2>&1; then $autoconf && found=true; break; fi
-done
-if test x$found = xfalse; then
-    echo "Couldn't find autoconf, aborting"
-    exit 1
+
+if test "$AUTOCONF"x = x; then
+  AUTOCONF=autoconf
 fi
+
+$AUTOCONF || exit 1
+rm aclocal.m4
+rm -rf autom4te.cache
diff --git a/Engine/lib/sdl/visualtest/compile b/Engine/lib/sdl/visualtest/compile
deleted file mode 100644
index cf0edba28..000000000
--- a/Engine/lib/sdl/visualtest/compile
+++ /dev/null
@@ -1 +0,0 @@
-/usr/share/automake-1.11/compile
\ No newline at end of file
diff --git a/Engine/lib/sdl/visualtest/config.h b/Engine/lib/sdl/visualtest/config.h
deleted file mode 100644
index 2d6d5cfbc..000000000
--- a/Engine/lib/sdl/visualtest/config.h
+++ /dev/null
@@ -1,23 +0,0 @@
-/* config.h.  Generated from config.h.in by configure.  */
-/* config.h.in.  Generated from configure.in by autoheader.  */
-
-/* Define to the address where bug reports for this package should be sent. */
-#define PACKAGE_BUGREPORT "apoorvupreti@gmail.com"
-
-/* Define to the full name of this package. */
-#define PACKAGE_NAME "sdlvisualtest"
-
-/* Define to the full name and version of this package. */
-#define PACKAGE_STRING "sdlvisualtest 0.01"
-
-/* Define to the one symbol short name of this package. */
-#define PACKAGE_TARNAME "sdlvisualtest"
-
-/* Define to the home page for this package. */
-#define PACKAGE_URL ""
-
-/* Define to the version of this package. */
-#define PACKAGE_VERSION "0.01"
-
-/* Define to empty if `const' does not conform to ANSI C. */
-/* #undef const */
diff --git a/Engine/lib/sdl/visualtest/config.h.in b/Engine/lib/sdl/visualtest/config.h.in
deleted file mode 100644
index 40b5b8a29..000000000
--- a/Engine/lib/sdl/visualtest/config.h.in
+++ /dev/null
@@ -1,22 +0,0 @@
-/* config.h.in.  Generated from configure.in by autoheader.  */
-
-/* Define to the address where bug reports for this package should be sent. */
-#undef PACKAGE_BUGREPORT
-
-/* Define to the full name of this package. */
-#undef PACKAGE_NAME
-
-/* Define to the full name and version of this package. */
-#undef PACKAGE_STRING
-
-/* Define to the one symbol short name of this package. */
-#undef PACKAGE_TARNAME
-
-/* Define to the home page for this package. */
-#undef PACKAGE_URL
-
-/* Define to the version of this package. */
-#undef PACKAGE_VERSION
-
-/* Define to empty if `const' does not conform to ANSI C. */
-#undef const
diff --git a/Engine/lib/sdl/visualtest/configure b/Engine/lib/sdl/visualtest/configure
index 4d5c0a4d3..ca7c71eb0 100644
--- a/Engine/lib/sdl/visualtest/configure
+++ b/Engine/lib/sdl/visualtest/configure
@@ -1,8 +1,6 @@
 #! /bin/sh
 # Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.69 for sdlvisualtest 0.01.
-#
-# Report bugs to <apoorvupreti@gmail.com>.
+# Generated by GNU Autoconf 2.69.
 #
 #
 # Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
@@ -265,11 +263,10 @@ fi
     $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
     $as_echo "$0: be upgraded to zsh 4.3.4 or later."
   else
-    $as_echo "$0: Please tell bug-autoconf@gnu.org and
-$0: apoorvupreti@gmail.com about your system, including any
-$0: error possibly output before this message. Then install
-$0: a modern shell, or manually run the script under such a
-$0: shell if you do have one."
+    $as_echo "$0: Please tell bug-autoconf@gnu.org about your system,
+$0: including any error possibly output before this
+$0: message. Then install a modern shell, or manually run
+$0: the script under such a shell if you do have one."
   fi
   exit 1
 fi
@@ -577,32 +574,25 @@ MFLAGS=
 MAKEFLAGS=
 
 # Identity of this package.
-PACKAGE_NAME='sdlvisualtest'
-PACKAGE_TARNAME='sdlvisualtest'
-PACKAGE_VERSION='0.01'
-PACKAGE_STRING='sdlvisualtest 0.01'
-PACKAGE_BUGREPORT='apoorvupreti@gmail.com'
-PACKAGE_URL=''
+PACKAGE_NAME=
+PACKAGE_TARNAME=
+PACKAGE_VERSION=
+PACKAGE_STRING=
+PACKAGE_BUGREPORT=
+PACKAGE_URL=
 
+ac_unique_file="unittest/testquit.c"
 ac_subst_vars='LTLIBOBJS
 LIBOBJS
-SDL_TTF_LIB
-GLLIB
-CPP
-XMKMF
-SDL_CONFIG
+LIBUNWIND_LIBS
+LIBUNWIND_CFLAGS
+SDL2_CONFIG
 SDL_LIBS
 SDL_CFLAGS
 PKG_CONFIG_LIBDIR
 PKG_CONFIG_PATH
 PKG_CONFIG
-ISUNIX
-ISWINDOWS
-ISMACOSX
-EXTRALIB
-MATHLIB
 EXE
-OSMESA_CONFIG
 OBJEXT
 EXEEXT
 ac_ct_CC
@@ -662,7 +652,6 @@ enable_option_checking
 with_sdl_prefix
 with_sdl_exec_prefix
 enable_sdltest
-with_x
 '
       ac_precious_vars='build_alias
 host_alias
@@ -677,8 +666,8 @@ PKG_CONFIG_PATH
 PKG_CONFIG_LIBDIR
 SDL_CFLAGS
 SDL_LIBS
-XMKMF
-CPP'
+LIBUNWIND_CFLAGS
+LIBUNWIND_LIBS'
 
 
 # Initialize some variables set by options.
@@ -719,7 +708,7 @@ sharedstatedir='${prefix}/com'
 localstatedir='${prefix}/var'
 includedir='${prefix}/include'
 oldincludedir='/usr/include'
-docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
+docdir='${datarootdir}/doc/${PACKAGE}'
 infodir='${datarootdir}/info'
 htmldir='${docdir}'
 dvidir='${docdir}'
@@ -1219,7 +1208,7 @@ if test "$ac_init_help" = "long"; then
   # Omit some internal or obsolete options to make the list less imposing.
   # This message is too long to be a string in the A/UX 3.1 sh.
   cat <<_ACEOF
-\`configure' configures sdlvisualtest 0.01 to adapt to many kinds of systems.
+\`configure' configures this package to adapt to many kinds of systems.
 
 Usage: $0 [OPTION]... [VAR=VALUE]...
 
@@ -1267,7 +1256,7 @@ Fine tuning of the installation directories:
   --infodir=DIR           info documentation [DATAROOTDIR/info]
   --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
   --mandir=DIR            man documentation [DATAROOTDIR/man]
-  --docdir=DIR            documentation root [DATAROOTDIR/doc/sdlvisualtest]
+  --docdir=DIR            documentation root [DATAROOTDIR/doc/PACKAGE]
   --htmldir=DIR           html documentation [DOCDIR]
   --dvidir=DIR            dvi documentation [DOCDIR]
   --pdfdir=DIR            pdf documentation [DOCDIR]
@@ -1276,10 +1265,6 @@ _ACEOF
 
   cat <<\_ACEOF
 
-X features:
-  --x-includes=DIR    X include files are in DIR
-  --x-libraries=DIR   X library files are in DIR
-
 System types:
   --build=BUILD     configure for building on BUILD [guessed]
   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
@@ -1287,9 +1272,7 @@ _ACEOF
 fi
 
 if test -n "$ac_init_help"; then
-  case $ac_init_help in
-     short | recursive ) echo "Configuration of sdlvisualtest 0.01:";;
-   esac
+
   cat <<\_ACEOF
 
 Optional Features:
@@ -1303,7 +1286,6 @@ Optional Packages:
   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
   --with-sdl-prefix=PFX   Prefix where SDL is installed (optional)
   --with-sdl-exec-prefix=PFX Exec prefix where SDL is installed (optional)
-  --with-x                use the X Window System
 
 Some influential environment variables:
   CC          C compiler command
@@ -1320,13 +1302,15 @@ Some influential environment variables:
               path overriding pkg-config's built-in search path
   SDL_CFLAGS  C compiler flags for SDL, overriding pkg-config
   SDL_LIBS    linker flags for SDL, overriding pkg-config
-  XMKMF       Path to xmkmf, Makefile generator for X Window System
-  CPP         C preprocessor
+  LIBUNWIND_CFLAGS
+              C compiler flags for LIBUNWIND, overriding pkg-config
+  LIBUNWIND_LIBS
+              linker flags for LIBUNWIND, overriding pkg-config
 
 Use these variables to override the choices made by `configure' or to help
 it to find libraries and programs with nonstandard names/locations.
 
-Report bugs to <apoorvupreti@gmail.com>.
+Report bugs to the package provider.
 _ACEOF
 ac_status=$?
 fi
@@ -1389,7 +1373,7 @@ fi
 test -n "$ac_init_help" && exit $ac_status
 if $ac_init_version; then
   cat <<\_ACEOF
-sdlvisualtest configure 0.01
+configure
 generated by GNU Autoconf 2.69
 
 Copyright (C) 2012 Free Software Foundation, Inc.
@@ -1528,48 +1512,11 @@ fi
   as_fn_set_status $ac_retval
 
 } # ac_fn_c_try_link
-
-# ac_fn_c_try_cpp LINENO
-# ----------------------
-# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
-ac_fn_c_try_cpp ()
-{
-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-  if { { ac_try="$ac_cpp conftest.$ac_ext"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
-  ac_status=$?
-  if test -s conftest.err; then
-    grep -v '^ *+' conftest.err >conftest.er1
-    cat conftest.er1 >&5
-    mv -f conftest.er1 conftest.err
-  fi
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } > conftest.i && {
-	 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
-	 test ! -s conftest.err
-       }; then :
-  ac_retval=0
-else
-  $as_echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-    ac_retval=1
-fi
-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-  as_fn_set_status $ac_retval
-
-} # ac_fn_c_try_cpp
 cat >config.log <<_ACEOF
 This file contains any messages produced by compilers while
 running configure, to aid debugging if configure makes a mistake.
 
-It was created by sdlvisualtest $as_me 0.01, which was
+It was created by $as_me, which was
 generated by GNU Autoconf 2.69.  Invocation command line was
 
   $ $0 $@
@@ -1918,8 +1865,9 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
 
 
+
 ac_aux_dir=
-for ac_dir in $srcdir/../build-scripts; do
+for ac_dir in ../build-scripts "$srcdir"/../build-scripts; do
   if test -f "$ac_dir/install-sh"; then
     ac_aux_dir=$ac_dir
     ac_install_sh="$ac_aux_dir/install-sh -c"
@@ -1935,7 +1883,7 @@ for ac_dir in $srcdir/../build-scripts; do
   fi
 done
 if test -z "$ac_aux_dir"; then
-  as_fn_error $? "cannot find install-sh, install.sh, or shtool in $srcdir/../build-scripts" "$LINENO" 5
+  as_fn_error $? "cannot find install-sh, install.sh, or shtool in ../build-scripts \"$srcdir\"/../build-scripts" "$LINENO" 5
 fi
 
 # These three variables are undocumented and unsupported,
@@ -2019,7 +1967,6 @@ case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
 
 
 
-
 ac_ext=c
 ac_cpp='$CPP $CPPFLAGS'
 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
@@ -2810,200 +2757,18 @@ ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $
 ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
 
-
-
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for an ANSI C-conforming const" >&5
-$as_echo_n "checking for an ANSI C-conforming const... " >&6; }
-if ${ac_cv_c_const+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main ()
-{
-
-#ifndef __cplusplus
-  /* Ultrix mips cc rejects this sort of thing.  */
-  typedef int charset[2];
-  const charset cs = { 0, 0 };
-  /* SunOS 4.1.1 cc rejects this.  */
-  char const *const *pcpcc;
-  char **ppc;
-  /* NEC SVR4.0.2 mips cc rejects this.  */
-  struct point {int x, y;};
-  static struct point const zero = {0,0};
-  /* AIX XL C 1.02.0.0 rejects this.
-     It does not let you subtract one const X* pointer from another in
-     an arm of an if-expression whose if-part is not a constant
-     expression */
-  const char *g = "string";
-  pcpcc = &g + (g ? g-g : 0);
-  /* HPUX 7.0 cc rejects these. */
-  ++pcpcc;
-  ppc = (char**) pcpcc;
-  pcpcc = (char const *const *) ppc;
-  { /* SCO 3.2v4 cc rejects this sort of thing.  */
-    char tx;
-    char *t = &tx;
-    char const *s = 0 ? (char *) 0 : (char const *) 0;
-
-    *t++ = 0;
-    if (s) return 0;
-  }
-  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
-    int x[] = {25, 17};
-    const int *foo = &x[0];
-    ++foo;
-  }
-  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
-    typedef const int *iptr;
-    iptr p = 0;
-    ++p;
-  }
-  { /* AIX XL C 1.02.0.0 rejects this sort of thing, saying
-       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
-    struct s { int j; const int *ap[3]; } bx;
-    struct s *b = &bx; b->j = 5;
-  }
-  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
-    const int foo = 10;
-    if (!foo) return 0;
-  }
-  return !cs[0] && !zero.x;
-#endif
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"; then :
-  ac_cv_c_const=yes
-else
-  ac_cv_c_const=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_const" >&5
-$as_echo "$ac_cv_c_const" >&6; }
-if test $ac_cv_c_const = no; then
-
-$as_echo "#define const /**/" >>confdefs.h
-
-fi
-
-
-ISUNIX="false"
-ISWINDOWS="false"
-ISMACOSX="false"
-
 case "$host" in
-    *-*-cygwin* | *-*-mingw32*)
-        ISWINDOWS="true"
+    *-*-cygwin* | *-*-mingw*)
         EXE=".exe"
-        MATHLIB=""
         EXTRALIB="-lshlwapi"
-        SYS_GL_LIBS="-lopengl32"
-        ;;
-    *-*-haiku*)
-        EXE=""
-        MATHLIB=""
-        EXTRALIB=""
-        SYS_GL_LIBS="-lGL"
-        ;;
-    *-*-darwin* )
-        ISMACOSX="true"
-        EXE=""
-        MATHLIB=""
-        EXTRALIB=""
-
-        ;;
-    *-*-aix*)
-        ISUNIX="true"
-        EXE=""
-        if test x$ac_cv_c_compiler_gnu = xyes; then
-            CFLAGS="-mthreads"
-        fi
-        MATHLIB=""
-        EXTRALIB=""
-        SYS_GL_LIBS=""
-        ;;
-    *-*-mint*)
-        EXE=""
-        MATHLIB=""
-        EXTRALIB=""
-        # Extract the first word of "osmesa-config", so it can be a program name with args.
-set dummy osmesa-config; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_path_OSMESA_CONFIG+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  case $OSMESA_CONFIG in
-  [\\/]* | ?:[\\/]*)
-  ac_cv_path_OSMESA_CONFIG="$OSMESA_CONFIG" # Let the user override the test with a path.
-  ;;
-  *)
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_path_OSMESA_CONFIG="$as_dir/$ac_word$ac_exec_ext"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-  test -z "$ac_cv_path_OSMESA_CONFIG" && ac_cv_path_OSMESA_CONFIG="no"
-  ;;
-esac
-fi
-OSMESA_CONFIG=$ac_cv_path_OSMESA_CONFIG
-if test -n "$OSMESA_CONFIG"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OSMESA_CONFIG" >&5
-$as_echo "$OSMESA_CONFIG" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-        if test "x$OSMESA_CONFIG" = "xyes"; then
-            OSMESA_CFLAGS=`$OSMESA_CONFIG --cflags`
-            OSMESA_LIBS=`$OSMESA_CONFIG --libs`
-            CFLAGS="$CFLAGS $OSMESA_CFLAGS"
-            SYS_GL_LIBS="$OSMESA_LIBS"
-        else
-            SYS_GL_LIBS="-lOSMesa"
-        fi
-        ;;
-    *-*-qnx*)
-        EXE=""
-        MATHLIB=""
-        EXTRALIB=""
-        SYS_GL_LIBS="-lGLES_CM"
         ;;
     *)
-                ISUNIX="true"
         EXE=""
-        MATHLIB="-lm"
         EXTRALIB=""
-        SYS_GL_LIBS="-lGL"
         ;;
 esac
 
 
-
-
-
-
-
 SDL_VERSION=2.0.0
 
 
@@ -3125,6 +2890,7 @@ $as_echo "no" >&6; }
 	fi
 fi
 
+
 # Check whether --with-sdl-prefix was given.
 if test "${with_sdl_prefix+set}" = set; then :
   withval=$with_sdl_prefix; sdl_prefix="$withval"
@@ -3153,8 +2919,8 @@ fi
   if test "x$sdl_prefix$sdl_exec_prefix" = x ; then
 
 pkg_failed=no
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for SDL" >&5
-$as_echo_n "checking for SDL... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for sdl2 >= $min_sdl_version" >&5
+$as_echo_n "checking for sdl2 >= $min_sdl_version... " >&6; }
 
 if test -n "$SDL_CFLAGS"; then
     pkg_cv_SDL_CFLAGS="$SDL_CFLAGS"
@@ -3224,21 +2990,21 @@ fi
     sdl_pc=no
     if test x$sdl_exec_prefix != x ; then
       sdl_config_args="$sdl_config_args --exec-prefix=$sdl_exec_prefix"
-      if test x${SDL_CONFIG+set} != xset ; then
-        SDL_CONFIG=$sdl_exec_prefix/bin/sdl2-config
+      if test x${SDL2_CONFIG+set} != xset ; then
+        SDL2_CONFIG=$sdl_exec_prefix/bin/sdl2-config
       fi
     fi
     if test x$sdl_prefix != x ; then
       sdl_config_args="$sdl_config_args --prefix=$sdl_prefix"
-      if test x${SDL_CONFIG+set} != xset ; then
-        SDL_CONFIG=$sdl_prefix/bin/sdl2-config
+      if test x${SDL2_CONFIG+set} != xset ; then
+        SDL2_CONFIG=$sdl_prefix/bin/sdl2-config
       fi
     fi
   fi
 
   if test "x$sdl_pc" = xyes ; then
     no_sdl=""
-    SDL_CONFIG="pkg-config sdl2"
+    SDL2_CONFIG="pkg-config sdl2"
   else
     as_save_PATH="$PATH"
     if test "x$prefix" != xNONE && test "$cross_compiling" != yes; then
@@ -3248,12 +3014,12 @@ fi
 set dummy sdl2-config; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_path_SDL_CONFIG+:} false; then :
+if ${ac_cv_path_SDL2_CONFIG+:} false; then :
   $as_echo_n "(cached) " >&6
 else
-  case $SDL_CONFIG in
+  case $SDL2_CONFIG in
   [\\/]* | ?:[\\/]*)
-  ac_cv_path_SDL_CONFIG="$SDL_CONFIG" # Let the user override the test with a path.
+  ac_cv_path_SDL2_CONFIG="$SDL2_CONFIG" # Let the user override the test with a path.
   ;;
   *)
   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -3263,7 +3029,7 @@ do
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_path_SDL_CONFIG="$as_dir/$ac_word$ac_exec_ext"
+    ac_cv_path_SDL2_CONFIG="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -3271,14 +3037,14 @@ done
   done
 IFS=$as_save_IFS
 
-  test -z "$ac_cv_path_SDL_CONFIG" && ac_cv_path_SDL_CONFIG="no"
+  test -z "$ac_cv_path_SDL2_CONFIG" && ac_cv_path_SDL2_CONFIG="no"
   ;;
 esac
 fi
-SDL_CONFIG=$ac_cv_path_SDL_CONFIG
-if test -n "$SDL_CONFIG"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SDL_CONFIG" >&5
-$as_echo "$SDL_CONFIG" >&6; }
+SDL2_CONFIG=$ac_cv_path_SDL2_CONFIG
+if test -n "$SDL2_CONFIG"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SDL2_CONFIG" >&5
+$as_echo "$SDL2_CONFIG" >&6; }
 else
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
@@ -3290,17 +3056,17 @@ fi
 $as_echo_n "checking for SDL - version >= $min_sdl_version... " >&6; }
     no_sdl=""
 
-    if test "$SDL_CONFIG" = "no" ; then
+    if test "$SDL2_CONFIG" = "no" ; then
       no_sdl=yes
     else
-      SDL_CFLAGS=`$SDL_CONFIG $sdl_config_args --cflags`
-      SDL_LIBS=`$SDL_CONFIG $sdl_config_args --libs`
+      SDL_CFLAGS=`$SDL2_CONFIG $sdl_config_args --cflags`
+      SDL_LIBS=`$SDL2_CONFIG $sdl_config_args --libs`
 
-      sdl_major_version=`$SDL_CONFIG $sdl_config_args --version | \
+      sdl_major_version=`$SDL2_CONFIG $sdl_config_args --version | \
              sed 's/\([0-9]*\).\([0-9]*\).\([0-9]*\)/\1/'`
-      sdl_minor_version=`$SDL_CONFIG $sdl_config_args --version | \
+      sdl_minor_version=`$SDL2_CONFIG $sdl_config_args --version | \
              sed 's/\([0-9]*\).\([0-9]*\).\([0-9]*\)/\2/'`
-      sdl_micro_version=`$SDL_CONFIG $sdl_config_args --version | \
+      sdl_micro_version=`$SDL2_CONFIG $sdl_config_args --version | \
              sed 's/\([0-9]*\).\([0-9]*\).\([0-9]*\)/\3/'`
       if test "x$enable_sdltest" = "xyes" ; then
         ac_save_CFLAGS="$CFLAGS"
@@ -3318,38 +3084,16 @@ else
 
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
 #include "SDL.h"
 
-char*
-my_strdup (char *str)
-{
-  char *new_str;
-
-  if (str)
-    {
-      new_str = (char *)malloc ((strlen (str) + 1) * sizeof(char));
-      strcpy (new_str, str);
-    }
-  else
-    new_str = NULL;
-
-  return new_str;
-}
-
 int main (int argc, char *argv[])
 {
   int major, minor, micro;
-  char *tmp_version;
+  FILE *fp = fopen("conf.sdltest", "w");
 
-  /* This hangs on some systems (?)
-  system ("touch conf.sdltest");
-  */
-  { FILE *fp = fopen("conf.sdltest", "a"); if ( fp ) fclose(fp); }
+  if (fp) fclose(fp);
 
-  /* HP/UX 9 (%@#!) writes to sscanf strings */
-  tmp_version = my_strdup("$min_sdl_version");
-  if (sscanf(tmp_version, "%d.%d.%d", &major, &minor, &micro) != 3) {
+  if (sscanf("$min_sdl_version", "%d.%d.%d", &major, &minor, &micro) != 3) {
      printf("%s, bad version string\n", "$min_sdl_version");
      exit(1);
    }
@@ -3365,7 +3109,7 @@ int main (int argc, char *argv[])
       printf("\n*** 'sdl2-config --version' returned %d.%d.%d, but the minimum version\n", $sdl_major_version, $sdl_minor_version, $sdl_micro_version);
       printf("*** of SDL required is %d.%d.%d. If sdl2-config is correct, then it is\n", major, minor, micro);
       printf("*** best to upgrade to the required version.\n");
-      printf("*** If sdl2-config was wrong, set the environment variable SDL_CONFIG\n");
+      printf("*** If sdl2-config was wrong, set the environment variable SDL2_CONFIG\n");
       printf("*** to point to the correct copy of sdl2-config, and remove the file\n");
       printf("*** config.cache before re-running configure\n");
       return 1;
@@ -3399,10 +3143,10 @@ $as_echo "no" >&6; }
   if test "x$no_sdl" = x ; then
      :
   else
-     if test "$SDL_CONFIG" = "no" ; then
+     if test "$SDL2_CONFIG" = "no" ; then
        echo "*** The sdl2-config script installed by SDL could not be found"
        echo "*** If SDL was installed in PREFIX, make sure PREFIX/bin is in"
-       echo "*** your path, or set the SDL_CONFIG environment variable to the"
+       echo "*** your path, or set the SDL2_CONFIG environment variable to the"
        echo "*** full path to sdl2-config."
      else
        if test -f conf.sdltest ; then
@@ -3445,7 +3189,7 @@ else
    echo "*** The test program failed to compile or link. See the file config.log for the"
           echo "*** exact error that occured. This usually means SDL was incorrectly installed"
           echo "*** or that you have moved SDL since it was installed. In the latter case, you"
-          echo "*** may want to edit the sdl2-config script: $SDL_CONFIG"
+          echo "*** may want to edit the sdl2-config script: $SDL2_CONFIG"
 fi
 rm -f core conftest.err conftest.$ac_objext \
     conftest$ac_exeext conftest.$ac_ext
@@ -3466,466 +3210,78 @@ rm -f core conftest.err conftest.$ac_objext \
 CFLAGS="$CFLAGS $SDL_CFLAGS"
 LIBS="$LIBS -lSDL2_test $SDL_LIBS $EXTRALIB"
 
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
-$as_echo_n "checking how to run the C preprocessor... " >&6; }
-# On Suns, sometimes $CPP names a directory.
-if test -n "$CPP" && test -d "$CPP"; then
-  CPP=
-fi
-if test -z "$CPP"; then
-  if ${ac_cv_prog_CPP+:} false; then :
-  $as_echo_n "(cached) " >&6
+
+pkg_failed=no
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for libunwind" >&5
+$as_echo_n "checking for libunwind... " >&6; }
+
+if test -n "$LIBUNWIND_CFLAGS"; then
+    pkg_cv_LIBUNWIND_CFLAGS="$LIBUNWIND_CFLAGS"
+ elif test -n "$PKG_CONFIG"; then
+    if test -n "$PKG_CONFIG" && \
+    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libunwind\""; } >&5
+  ($PKG_CONFIG --exists --print-errors "libunwind") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+  pkg_cv_LIBUNWIND_CFLAGS=`$PKG_CONFIG --cflags "libunwind" 2>/dev/null`
 else
-      # Double quotes because CPP needs to be expanded
-    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
-    do
-      ac_preproc_ok=false
-for ac_c_preproc_warn_flag in '' yes
-do
-  # Use a header file that comes with gcc, so configuring glibc
-  # with a fresh cross-compiler works.
-  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-  # <limits.h> exists even on freestanding compilers.
-  # On the NeXT, cc -E runs the code through the compiler's parser,
-  # not just through cpp. "Syntax error" is here to catch this case.
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
-		     Syntax error
-_ACEOF
-if ac_fn_c_try_cpp "$LINENO"; then :
-
+  pkg_failed=yes
+fi
+ else
+    pkg_failed=untried
+fi
+if test -n "$LIBUNWIND_LIBS"; then
+    pkg_cv_LIBUNWIND_LIBS="$LIBUNWIND_LIBS"
+ elif test -n "$PKG_CONFIG"; then
+    if test -n "$PKG_CONFIG" && \
+    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libunwind\""; } >&5
+  ($PKG_CONFIG --exists --print-errors "libunwind") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+  pkg_cv_LIBUNWIND_LIBS=`$PKG_CONFIG --libs "libunwind" 2>/dev/null`
 else
-  # Broken: fails on valid input.
-continue
+  pkg_failed=yes
+fi
+ else
+    pkg_failed=untried
 fi
-rm -f conftest.err conftest.i conftest.$ac_ext
 
-  # OK, works on sane cases.  Now check whether nonexistent headers
-  # can be detected and how.
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <ac_nonexistent.h>
-_ACEOF
-if ac_fn_c_try_cpp "$LINENO"; then :
-  # Broken: success on invalid input.
-continue
+
+
+if test $pkg_failed = yes; then
+   	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+
+if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
+        _pkg_short_errors_supported=yes
 else
-  # Passes both tests.
-ac_preproc_ok=:
-break
+        _pkg_short_errors_supported=no
 fi
-rm -f conftest.err conftest.i conftest.$ac_ext
+        if test $_pkg_short_errors_supported = yes; then
+	        LIBUNWIND_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "libunwind" 2>&1`
+        else
+	        LIBUNWIND_PKG_ERRORS=`$PKG_CONFIG --print-errors "libunwind" 2>&1`
+        fi
+	# Put the nasty error message in config.log where it belongs
+	echo "$LIBUNWIND_PKG_ERRORS" >&5
 
-done
-# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
-rm -f conftest.i conftest.err conftest.$ac_ext
-if $ac_preproc_ok; then :
-  break
-fi
-
-    done
-    ac_cv_prog_CPP=$CPP
-
-fi
-  CPP=$ac_cv_prog_CPP
+	have_libunwind=no
+elif test $pkg_failed = untried; then
+     	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+	have_libunwind=no
 else
-  ac_cv_prog_CPP=$CPP
+	LIBUNWIND_CFLAGS=$pkg_cv_LIBUNWIND_CFLAGS
+	LIBUNWIND_LIBS=$pkg_cv_LIBUNWIND_LIBS
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+	have_libunwind=yes
 fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
-$as_echo "$CPP" >&6; }
-ac_preproc_ok=false
-for ac_c_preproc_warn_flag in '' yes
-do
-  # Use a header file that comes with gcc, so configuring glibc
-  # with a fresh cross-compiler works.
-  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-  # <limits.h> exists even on freestanding compilers.
-  # On the NeXT, cc -E runs the code through the compiler's parser,
-  # not just through cpp. "Syntax error" is here to catch this case.
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
-		     Syntax error
-_ACEOF
-if ac_fn_c_try_cpp "$LINENO"; then :
-
-else
-  # Broken: fails on valid input.
-continue
+if test x$have_libunwind = xyes ; then
+   LIBS="$LIBS $LIBUNWIND_LIBS"
 fi
-rm -f conftest.err conftest.i conftest.$ac_ext
-
-  # OK, works on sane cases.  Now check whether nonexistent headers
-  # can be detected and how.
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <ac_nonexistent.h>
-_ACEOF
-if ac_fn_c_try_cpp "$LINENO"; then :
-  # Broken: success on invalid input.
-continue
-else
-  # Passes both tests.
-ac_preproc_ok=:
-break
-fi
-rm -f conftest.err conftest.i conftest.$ac_ext
-
-done
-# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
-rm -f conftest.i conftest.err conftest.$ac_ext
-if $ac_preproc_ok; then :
-
-else
-  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
-See \`config.log' for more details" "$LINENO" 5; }
-fi
-
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-
-
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for X" >&5
-$as_echo_n "checking for X... " >&6; }
-
-
-# Check whether --with-x was given.
-if test "${with_x+set}" = set; then :
-  withval=$with_x;
-fi
-
-# $have_x is `yes', `no', `disabled', or empty when we do not yet know.
-if test "x$with_x" = xno; then
-  # The user explicitly disabled X.
-  have_x=disabled
-else
-  case $x_includes,$x_libraries in #(
-    *\'*) as_fn_error $? "cannot use X directory names containing '" "$LINENO" 5;; #(
-    *,NONE | NONE,*) if ${ac_cv_have_x+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  # One or both of the vars are not set, and there is no cached value.
-ac_x_includes=no ac_x_libraries=no
-rm -f -r conftest.dir
-if mkdir conftest.dir; then
-  cd conftest.dir
-  cat >Imakefile <<'_ACEOF'
-incroot:
-	@echo incroot='${INCROOT}'
-usrlibdir:
-	@echo usrlibdir='${USRLIBDIR}'
-libdir:
-	@echo libdir='${LIBDIR}'
-_ACEOF
-  if (export CC; ${XMKMF-xmkmf}) >/dev/null 2>/dev/null && test -f Makefile; then
-    # GNU make sometimes prints "make[1]: Entering ...", which would confuse us.
-    for ac_var in incroot usrlibdir libdir; do
-      eval "ac_im_$ac_var=\`\${MAKE-make} $ac_var 2>/dev/null | sed -n 's/^$ac_var=//p'\`"
-    done
-    # Open Windows xmkmf reportedly sets LIBDIR instead of USRLIBDIR.
-    for ac_extension in a so sl dylib la dll; do
-      if test ! -f "$ac_im_usrlibdir/libX11.$ac_extension" &&
-	 test -f "$ac_im_libdir/libX11.$ac_extension"; then
-	ac_im_usrlibdir=$ac_im_libdir; break
-      fi
-    done
-    # Screen out bogus values from the imake configuration.  They are
-    # bogus both because they are the default anyway, and because
-    # using them would break gcc on systems where it needs fixed includes.
-    case $ac_im_incroot in
-	/usr/include) ac_x_includes= ;;
-	*) test -f "$ac_im_incroot/X11/Xos.h" && ac_x_includes=$ac_im_incroot;;
-    esac
-    case $ac_im_usrlibdir in
-	/usr/lib | /usr/lib64 | /lib | /lib64) ;;
-	*) test -d "$ac_im_usrlibdir" && ac_x_libraries=$ac_im_usrlibdir ;;
-    esac
-  fi
-  cd ..
-  rm -f -r conftest.dir
-fi
-
-# Standard set of common directories for X headers.
-# Check X11 before X11Rn because it is often a symlink to the current release.
-ac_x_header_dirs='
-/usr/X11/include
-/usr/X11R7/include
-/usr/X11R6/include
-/usr/X11R5/include
-/usr/X11R4/include
-
-/usr/include/X11
-/usr/include/X11R7
-/usr/include/X11R6
-/usr/include/X11R5
-/usr/include/X11R4
-
-/usr/local/X11/include
-/usr/local/X11R7/include
-/usr/local/X11R6/include
-/usr/local/X11R5/include
-/usr/local/X11R4/include
-
-/usr/local/include/X11
-/usr/local/include/X11R7
-/usr/local/include/X11R6
-/usr/local/include/X11R5
-/usr/local/include/X11R4
-
-/usr/X386/include
-/usr/x386/include
-/usr/XFree86/include/X11
-
-/usr/include
-/usr/local/include
-/usr/unsupported/include
-/usr/athena/include
-/usr/local/x11r5/include
-/usr/lpp/Xamples/include
-
-/usr/openwin/include
-/usr/openwin/share/include'
-
-if test "$ac_x_includes" = no; then
-  # Guess where to find include files, by looking for Xlib.h.
-  # First, try using that file with no special directory specified.
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <X11/Xlib.h>
-_ACEOF
-if ac_fn_c_try_cpp "$LINENO"; then :
-  # We can compile using X headers with no special include directory.
-ac_x_includes=
-else
-  for ac_dir in $ac_x_header_dirs; do
-  if test -r "$ac_dir/X11/Xlib.h"; then
-    ac_x_includes=$ac_dir
-    break
-  fi
-done
-fi
-rm -f conftest.err conftest.i conftest.$ac_ext
-fi # $ac_x_includes = no
-
-if test "$ac_x_libraries" = no; then
-  # Check for the libraries.
-  # See if we find them without any special options.
-  # Don't add to $LIBS permanently.
-  ac_save_LIBS=$LIBS
-  LIBS="-lX11 $LIBS"
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <X11/Xlib.h>
-int
-main ()
-{
-XrmInitialize ()
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"; then :
-  LIBS=$ac_save_LIBS
-# We can link X programs with no special library path.
-ac_x_libraries=
-else
-  LIBS=$ac_save_LIBS
-for ac_dir in `$as_echo "$ac_x_includes $ac_x_header_dirs" | sed s/include/lib/g`
-do
-  # Don't even attempt the hair of trying to link an X program!
-  for ac_extension in a so sl dylib la dll; do
-    if test -r "$ac_dir/libX11.$ac_extension"; then
-      ac_x_libraries=$ac_dir
-      break 2
-    fi
-  done
-done
-fi
-rm -f core conftest.err conftest.$ac_objext \
-    conftest$ac_exeext conftest.$ac_ext
-fi # $ac_x_libraries = no
-
-case $ac_x_includes,$ac_x_libraries in #(
-  no,* | *,no | *\'*)
-    # Didn't find X, or a directory has "'" in its name.
-    ac_cv_have_x="have_x=no";; #(
-  *)
-    # Record where we found X for the cache.
-    ac_cv_have_x="have_x=yes\
-	ac_x_includes='$ac_x_includes'\
-	ac_x_libraries='$ac_x_libraries'"
-esac
-fi
-;; #(
-    *) have_x=yes;;
-  esac
-  eval "$ac_cv_have_x"
-fi # $with_x != no
-
-if test "$have_x" != yes; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_x" >&5
-$as_echo "$have_x" >&6; }
-  no_x=yes
-else
-  # If each of the values was on the command line, it overrides each guess.
-  test "x$x_includes" = xNONE && x_includes=$ac_x_includes
-  test "x$x_libraries" = xNONE && x_libraries=$ac_x_libraries
-  # Update the cache value to reflect the command line values.
-  ac_cv_have_x="have_x=yes\
-	ac_x_includes='$x_includes'\
-	ac_x_libraries='$x_libraries'"
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: libraries $x_libraries, headers $x_includes" >&5
-$as_echo "libraries $x_libraries, headers $x_includes" >&6; }
-fi
-
-if test x$have_x = xyes; then
-    if test x$ac_x_includes = xno || test x$ac_x_includes = x; then
-        :
-    else
-        CFLAGS="$CFLAGS -I$ac_x_includes"
-    fi
-    if test x$ac_x_libraries = xno || test x$ac_x_libraries = x; then
-        :
-    else
-        XPATH="-L$ac_x_libraries"
-    fi
-fi
-
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for OpenGL support" >&5
-$as_echo_n "checking for OpenGL support... " >&6; }
-have_opengl=no
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
- #include "SDL_opengl.h"
-
-int
-main ()
-{
-
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"; then :
-
-have_opengl=yes
-
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_opengl" >&5
-$as_echo "$have_opengl" >&6; }
-
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for OpenGL ES support" >&5
-$as_echo_n "checking for OpenGL ES support... " >&6; }
-have_opengles=no
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
- #if defined (__IPHONEOS__)
-    #include <OpenGLES/ES1/gl.h>
- #else
-    #include <GLES/gl.h>
- #endif /* __QNXNTO__ */
-
-int
-main ()
-{
-
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"; then :
-
-have_opengles=yes
-
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_opengles" >&5
-$as_echo "$have_opengles" >&6; }
-
-GLLIB=""
-if test x$have_opengles = xyes; then
-    CFLAGS="$CFLAGS -DHAVE_OPENGLES"
-    GLLIB="$XPATH -lGLESv1_CM"
-elif test x$have_opengl = xyes; then
-    CFLAGS="$CFLAGS -DHAVE_OPENGL"
-    GLLIB="$XPATH $SYS_GL_LIBS"
-else
-    GLLIB=""
-fi
-
-
-
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for TTF_Init in -lSDL2_ttf" >&5
-$as_echo_n "checking for TTF_Init in -lSDL2_ttf... " >&6; }
-if ${ac_cv_lib_SDL2_ttf_TTF_Init+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  ac_check_lib_save_LIBS=$LIBS
-LIBS="-lSDL2_ttf  $LIBS"
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-/* Override any GCC internal prototype to avoid an error.
-   Use char because int might match the return type of a GCC
-   builtin and then its argument prototype would still apply.  */
-#ifdef __cplusplus
-extern "C"
-#endif
-char TTF_Init ();
-int
-main ()
-{
-return TTF_Init ();
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"; then :
-  ac_cv_lib_SDL2_ttf_TTF_Init=yes
-else
-  ac_cv_lib_SDL2_ttf_TTF_Init=no
-fi
-rm -f core conftest.err conftest.$ac_objext \
-    conftest$ac_exeext conftest.$ac_ext
-LIBS=$ac_check_lib_save_LIBS
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_SDL2_ttf_TTF_Init" >&5
-$as_echo "$ac_cv_lib_SDL2_ttf_TTF_Init" >&6; }
-if test "x$ac_cv_lib_SDL2_ttf_TTF_Init" = xyes; then :
-  have_SDL_ttf=yes
-fi
-
-if test x$have_SDL_ttf = xyes; then
-    CFLAGS="$CFLAGS -DHAVE_SDL_TTF"
-    SDL_TTF_LIB="-lSDL2_ttf"
-fi
-
-
-ac_config_headers="$ac_config_headers config.h"
 
 ac_config_files="$ac_config_files Makefile"
 
@@ -4019,7 +3375,43 @@ test "x$prefix" = xNONE && prefix=$ac_default_prefix
 # Let make expand exec_prefix.
 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
 
-DEFS=-DHAVE_CONFIG_H
+# Transform confdefs.h into DEFS.
+# Protect against shell expansion while executing Makefile rules.
+# Protect against Makefile macro expansion.
+#
+# If the first sed substitution is executed (which looks for macros that
+# take arguments), then branch to the quote section.  Otherwise,
+# look for a macro that doesn't take arguments.
+ac_script='
+:mline
+/\\$/{
+ N
+ s,\\\n,,
+ b mline
+}
+t clear
+:clear
+s/^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 (][^	 (]*([^)]*)\)[	 ]*\(.*\)/-D\1=\2/g
+t quote
+s/^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 ][^	 ]*\)[	 ]*\(.*\)/-D\1=\2/g
+t quote
+b any
+:quote
+s/[	 `~#$^&*(){}\\|;'\''"<>?]/\\&/g
+s/\[/\\&/g
+s/\]/\\&/g
+s/\$/$$/g
+H
+:any
+${
+	g
+	s/^\n//
+	s/\n/ /g
+	p
+}
+'
+DEFS=`sed -n "$ac_script" confdefs.h`
+
 
 ac_libobjs=
 ac_ltlibobjs=
@@ -4435,7 +3827,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
 # report actual input values of CONFIG_FILES etc. instead of their
 # values after options handling.
 ac_log="
-This file was extended by sdlvisualtest $as_me 0.01, which was
+This file was extended by $as_me, which was
 generated by GNU Autoconf 2.69.  Invocation command line was
 
   CONFIG_FILES    = $CONFIG_FILES
@@ -4453,15 +3845,11 @@ case $ac_config_files in *"
 "*) set x $ac_config_files; shift; ac_config_files=$*;;
 esac
 
-case $ac_config_headers in *"
-"*) set x $ac_config_headers; shift; ac_config_headers=$*;;
-esac
 
 
 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 # Files that config.status was made for.
 config_files="$ac_config_files"
-config_headers="$ac_config_headers"
 
 _ACEOF
 
@@ -4482,22 +3870,17 @@ Usage: $0 [OPTION]... [TAG]...
       --recheck    update $as_me by reconfiguring in the same conditions
       --file=FILE[:TEMPLATE]
                    instantiate the configuration file FILE
-      --header=FILE[:TEMPLATE]
-                   instantiate the configuration header FILE
 
 Configuration files:
 $config_files
 
-Configuration headers:
-$config_headers
-
-Report bugs to <apoorvupreti@gmail.com>."
+Report bugs to the package provider."
 
 _ACEOF
 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
 ac_cs_version="\\
-sdlvisualtest config.status 0.01
+config.status
 configured by $0, generated by GNU Autoconf 2.69,
   with options \\"\$ac_cs_config\\"
 
@@ -4551,18 +3934,7 @@ do
     esac
     as_fn_append CONFIG_FILES " '$ac_optarg'"
     ac_need_defaults=false;;
-  --header | --heade | --head | --hea )
-    $ac_shift
-    case $ac_optarg in
-    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
-    esac
-    as_fn_append CONFIG_HEADERS " '$ac_optarg'"
-    ac_need_defaults=false;;
-  --he | --h)
-    # Conflict between --help and --header
-    as_fn_error $? "ambiguous option: \`$1'
-Try \`$0 --help' for more information.";;
-  --help | --hel | -h )
+  --he | --h |  --help | --hel | -h )
     $as_echo "$ac_cs_usage"; exit ;;
   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
   | -silent | --silent | --silen | --sile | --sil | --si | --s)
@@ -4618,7 +3990,6 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
 for ac_config_target in $ac_config_targets
 do
   case $ac_config_target in
-    "config.h") CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;
     "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
 
   *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
@@ -4632,7 +4003,6 @@ done
 # bizarre bug on SunOS 4.1.3.
 if $ac_need_defaults; then
   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
-  test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
 fi
 
 # Have a temporary directory for convenience.  Make it in the build tree
@@ -4820,116 +4190,8 @@ fi
 cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
 fi # test -n "$CONFIG_FILES"
 
-# Set up the scripts for CONFIG_HEADERS section.
-# No need to generate them if there are no CONFIG_HEADERS.
-# This happens for instance with `./config.status Makefile'.
-if test -n "$CONFIG_HEADERS"; then
-cat >"$ac_tmp/defines.awk" <<\_ACAWK ||
-BEGIN {
-_ACEOF
 
-# Transform confdefs.h into an awk script `defines.awk', embedded as
-# here-document in config.status, that substitutes the proper values into
-# config.h.in to produce config.h.
-
-# Create a delimiter string that does not exist in confdefs.h, to ease
-# handling of long lines.
-ac_delim='%!_!# '
-for ac_last_try in false false :; do
-  ac_tt=`sed -n "/$ac_delim/p" confdefs.h`
-  if test -z "$ac_tt"; then
-    break
-  elif $ac_last_try; then
-    as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5
-  else
-    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
-  fi
-done
-
-# For the awk script, D is an array of macro values keyed by name,
-# likewise P contains macro parameters if any.  Preserve backslash
-# newline sequences.
-
-ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]*
-sed -n '
-s/.\{148\}/&'"$ac_delim"'/g
-t rset
-:rset
-s/^[	 ]*#[	 ]*define[	 ][	 ]*/ /
-t def
-d
-:def
-s/\\$//
-t bsnl
-s/["\\]/\\&/g
-s/^ \('"$ac_word_re"'\)\(([^()]*)\)[	 ]*\(.*\)/P["\1"]="\2"\
-D["\1"]=" \3"/p
-s/^ \('"$ac_word_re"'\)[	 ]*\(.*\)/D["\1"]=" \2"/p
-d
-:bsnl
-s/["\\]/\\&/g
-s/^ \('"$ac_word_re"'\)\(([^()]*)\)[	 ]*\(.*\)/P["\1"]="\2"\
-D["\1"]=" \3\\\\\\n"\\/p
-t cont
-s/^ \('"$ac_word_re"'\)[	 ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p
-t cont
-d
-:cont
-n
-s/.\{148\}/&'"$ac_delim"'/g
-t clear
-:clear
-s/\\$//
-t bsnlc
-s/["\\]/\\&/g; s/^/"/; s/$/"/p
-d
-:bsnlc
-s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p
-b cont
-' <confdefs.h | sed '
-s/'"$ac_delim"'/"\\\
-"/g' >>$CONFIG_STATUS || ac_write_fail=1
-
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-  for (key in D) D_is_set[key] = 1
-  FS = ""
-}
-/^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ {
-  line = \$ 0
-  split(line, arg, " ")
-  if (arg[1] == "#") {
-    defundef = arg[2]
-    mac1 = arg[3]
-  } else {
-    defundef = substr(arg[1], 2)
-    mac1 = arg[2]
-  }
-  split(mac1, mac2, "(") #)
-  macro = mac2[1]
-  prefix = substr(line, 1, index(line, defundef) - 1)
-  if (D_is_set[macro]) {
-    # Preserve the white space surrounding the "#".
-    print prefix "define", macro P[macro] D[macro]
-    next
-  } else {
-    # Replace #undef with comments.  This is necessary, for example,
-    # in the case of _POSIX_SOURCE, which is predefined and required
-    # on some systems where configure will not decide to define it.
-    if (defundef == "undef") {
-      print "/*", prefix defundef, macro, "*/"
-      next
-    }
-  }
-}
-{ print }
-_ACAWK
-_ACEOF
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-  as_fn_error $? "could not setup config headers machinery" "$LINENO" 5
-fi # test -n "$CONFIG_HEADERS"
-
-
-eval set X "  :F $CONFIG_FILES  :H $CONFIG_HEADERS    "
+eval set X "  :F $CONFIG_FILES      "
 shift
 for ac_tag
 do
@@ -5137,30 +4399,7 @@ which seems to be undefined.  Please make sure it is defined" >&2;}
   esac \
   || as_fn_error $? "could not create $ac_file" "$LINENO" 5
  ;;
-  :H)
-  #
-  # CONFIG_HEADER
-  #
-  if test x"$ac_file" != x-; then
-    {
-      $as_echo "/* $configure_input  */" \
-      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs"
-    } >"$ac_tmp/config.h" \
-      || as_fn_error $? "could not create $ac_file" "$LINENO" 5
-    if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then
-      { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5
-$as_echo "$as_me: $ac_file is unchanged" >&6;}
-    else
-      rm -f "$ac_file"
-      mv "$ac_tmp/config.h" "$ac_file" \
-	|| as_fn_error $? "could not create $ac_file" "$LINENO" 5
-    fi
-  else
-    $as_echo "/* $configure_input  */" \
-      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \
-      || as_fn_error $? "could not create -" "$LINENO" 5
-  fi
- ;;
+
 
 
   esac
diff --git a/Engine/lib/sdl/visualtest/configure.ac b/Engine/lib/sdl/visualtest/configure.ac
new file mode 100644
index 000000000..3566bf0d8
--- /dev/null
+++ b/Engine/lib/sdl/visualtest/configure.ac
@@ -0,0 +1,41 @@
+dnl Process this file with autoconf to produce a configure script.
+AC_INIT
+AC_CONFIG_SRCDIR([unittest/testquit.c])
+
+dnl Detect the canonical build and host environments
+AC_CONFIG_AUX_DIR([../build-scripts])
+AC_CANONICAL_HOST
+
+dnl Check for tools
+AC_PROG_CC
+
+dnl Figure out which math or extra library to use
+case "$host" in
+    *-*-cygwin* | *-*-mingw*)
+        EXE=".exe"
+        EXTRALIB="-lshlwapi"
+        ;;
+    *)
+        EXE=""
+        EXTRALIB=""
+        ;;
+esac
+AC_SUBST(EXE)
+
+dnl Check for SDL
+SDL_VERSION=2.0.0
+AM_PATH_SDL2($SDL_VERSION,
+            :,
+	    AC_MSG_ERROR([*** SDL version $SDL_VERSION not found!])
+)
+CFLAGS="$CFLAGS $SDL_CFLAGS"
+LIBS="$LIBS -lSDL2_test $SDL_LIBS $EXTRALIB"
+
+PKG_CHECK_MODULES(LIBUNWIND, libunwind, have_libunwind=yes, have_libunwind=no)
+if test x$have_libunwind = xyes ; then
+   LIBS="$LIBS $LIBUNWIND_LIBS"
+fi
+
+dnl Finally create all the generated files
+AC_CONFIG_FILES([Makefile])
+AC_OUTPUT
diff --git a/Engine/lib/sdl/visualtest/configure.in b/Engine/lib/sdl/visualtest/configure.in
deleted file mode 100644
index 724a0ee38..000000000
--- a/Engine/lib/sdl/visualtest/configure.in
+++ /dev/null
@@ -1,166 +0,0 @@
-dnl Process this file with autoconf to produce a configure script.
-AC_INIT([sdlvisualtest], [0.01], [apoorvupreti@gmail.com])
-
-dnl Detect the canonical build and host environments
-AC_CONFIG_AUX_DIRS($srcdir/../build-scripts)
-AC_CANONICAL_HOST
-
-dnl Check for tools
-
-AC_PROG_CC
-
-dnl Check for compiler environment
-
-AC_C_CONST
-
-dnl We only care about this for building testnative at the moment, so these
-dnl  values shouldn't be considered absolute truth.
-dnl  (Haiku, for example, sets none of these.)
-ISUNIX="false"
-ISWINDOWS="false"
-ISMACOSX="false"
-
-dnl Figure out which math or extra library to use
-case "$host" in
-    *-*-cygwin* | *-*-mingw32*)
-        ISWINDOWS="true"
-        EXE=".exe"
-        MATHLIB=""
-        EXTRALIB="-lshlwapi"
-        SYS_GL_LIBS="-lopengl32"
-        ;;
-    *-*-haiku*)
-        EXE=""
-        MATHLIB=""
-        EXTRALIB=""
-        SYS_GL_LIBS="-lGL"
-        ;;
-    *-*-darwin* )
-        ISMACOSX="true"
-        EXE=""
-        MATHLIB=""
-        EXTRALIB=""
-
-        ;;
-    *-*-aix*)
-        ISUNIX="true"
-        EXE=""
-        if test x$ac_cv_prog_gcc = xyes; then
-            CFLAGS="-mthreads"
-        fi
-        MATHLIB=""
-        EXTRALIB=""
-        SYS_GL_LIBS=""
-        ;;
-    *-*-mint*)
-        EXE=""
-        MATHLIB=""
-        EXTRALIB=""
-        AC_PATH_PROG(OSMESA_CONFIG, osmesa-config, no)
-        if test "x$OSMESA_CONFIG" = "xyes"; then
-            OSMESA_CFLAGS=`$OSMESA_CONFIG --cflags`
-            OSMESA_LIBS=`$OSMESA_CONFIG --libs`
-            CFLAGS="$CFLAGS $OSMESA_CFLAGS"
-            SYS_GL_LIBS="$OSMESA_LIBS"
-        else
-            SYS_GL_LIBS="-lOSMesa"
-        fi
-        ;;
-    *-*-qnx*)
-        EXE=""
-        MATHLIB=""
-        EXTRALIB=""
-        SYS_GL_LIBS="-lGLES_CM"
-        ;;
-    *)
-        dnl Oh well, call it Unix...
-        ISUNIX="true"
-        EXE=""
-        MATHLIB="-lm"
-        EXTRALIB=""
-        SYS_GL_LIBS="-lGL"
-        ;;
-esac
-AC_SUBST(EXE)
-AC_SUBST(MATHLIB)
-AC_SUBST(EXTRALIB)
-AC_SUBST(ISMACOSX)
-AC_SUBST(ISWINDOWS)
-AC_SUBST(ISUNIX)
-
-dnl Check for SDL
-SDL_VERSION=2.0.0
-AM_PATH_SDL2($SDL_VERSION,
-            :,
-	    AC_MSG_ERROR([*** SDL version $SDL_VERSION not found!])
-)
-CFLAGS="$CFLAGS $SDL_CFLAGS"
-LIBS="$LIBS -lSDL2_test $SDL_LIBS $EXTRALIB"
-
-dnl Check for X11 path, needed for OpenGL on some systems
-AC_PATH_X
-if test x$have_x = xyes; then
-    if test x$ac_x_includes = xno || test x$ac_x_includes = x; then
-        :
-    else
-        CFLAGS="$CFLAGS -I$ac_x_includes"
-    fi
-    if test x$ac_x_libraries = xno || test x$ac_x_libraries = x; then
-        :
-    else
-        XPATH="-L$ac_x_libraries"
-    fi
-fi
-
-dnl Check for OpenGL
-AC_MSG_CHECKING(for OpenGL support)
-have_opengl=no
-AC_TRY_COMPILE([
- #include "SDL_opengl.h"
-],[
-],[
-have_opengl=yes
-])
-AC_MSG_RESULT($have_opengl)
-
-dnl Check for OpenGL ES
-AC_MSG_CHECKING(for OpenGL ES support)
-have_opengles=no
-AC_TRY_COMPILE([
- #if defined (__IPHONEOS__)
-    #include <OpenGLES/ES1/gl.h>
- #else
-    #include <GLES/gl.h>
- #endif /* __QNXNTO__ */
-],[
-],[
-have_opengles=yes
-])
-AC_MSG_RESULT($have_opengles)
-
-GLLIB=""
-if test x$have_opengles = xyes; then
-    CFLAGS="$CFLAGS -DHAVE_OPENGLES"
-    GLLIB="$XPATH -lGLESv1_CM"
-elif test x$have_opengl = xyes; then
-    CFLAGS="$CFLAGS -DHAVE_OPENGL"
-    GLLIB="$XPATH $SYS_GL_LIBS"
-else
-    GLLIB=""
-fi
-
-AC_SUBST(GLLIB)
-
-dnl Check for SDL_ttf
-AC_CHECK_LIB(SDL2_ttf, TTF_Init, have_SDL_ttf=yes)
-if test x$have_SDL_ttf = xyes; then
-    CFLAGS="$CFLAGS -DHAVE_SDL_TTF"
-    SDL_TTF_LIB="-lSDL2_ttf"
-fi
-AC_SUBST(SDL_TTF_LIB)
-
-dnl Finally create all the generated files
-dnl AC_OUTPUT([Makefile])
-AC_CONFIG_HEADERS([config.h])
-AC_CONFIG_FILES([Makefile])
-AC_OUTPUT()
diff --git a/Engine/lib/sdl/visualtest/depcomp b/Engine/lib/sdl/visualtest/depcomp
deleted file mode 100644
index b0ad20c05..000000000
--- a/Engine/lib/sdl/visualtest/depcomp
+++ /dev/null
@@ -1 +0,0 @@
-/usr/share/automake-1.11/depcomp
\ No newline at end of file
diff --git a/Engine/lib/sdl/visualtest/include/SDL_visualtest_action_configparser.h b/Engine/lib/sdl/visualtest/include/SDL_visualtest_action_configparser.h
index 340924852..40481f379 100644
--- a/Engine/lib/sdl/visualtest/include/SDL_visualtest_action_configparser.h
+++ b/Engine/lib/sdl/visualtest/include/SDL_visualtest_action_configparser.h
@@ -1,4 +1,4 @@
-/* See COPYING.txt for the full license governing this code. */
+/* See LICENSE.txt for the full license governing this code. */
 /**
  * \file SDL_visualtest_action_configparser.h
  *
@@ -137,7 +137,7 @@ int SDLVisualTest_InsertIntoActionQueue(SDLVisualTest_ActionQueue* queue,
  *
  * \return 1 on success, 0 on failure.
  */
-int SDLVisualTest_ParseActionConfig(char* file, SDLVisualTest_ActionQueue* queue);
+int SDLVisualTest_ParseActionConfig(const char* file, SDLVisualTest_ActionQueue* queue);
 
 /* Ends C function definitions when using C++ */
 #ifdef __cplusplus
diff --git a/Engine/lib/sdl/visualtest/include/SDL_visualtest_exhaustive_variator.h b/Engine/lib/sdl/visualtest/include/SDL_visualtest_exhaustive_variator.h
index 6fee88f8f..4637ce29e 100644
--- a/Engine/lib/sdl/visualtest/include/SDL_visualtest_exhaustive_variator.h
+++ b/Engine/lib/sdl/visualtest/include/SDL_visualtest_exhaustive_variator.h
@@ -1,4 +1,4 @@
-/* See COPYING.txt for the full license governing this code. */
+/* See LICENSE.txt for the full license governing this code. */
 /**
  * \file SDL_visualtest_exhaustive_variator.h
  *
diff --git a/Engine/lib/sdl/visualtest/include/SDL_visualtest_parsehelper.h b/Engine/lib/sdl/visualtest/include/SDL_visualtest_parsehelper.h
index 0a12c65c7..4558552c1 100644
--- a/Engine/lib/sdl/visualtest/include/SDL_visualtest_parsehelper.h
+++ b/Engine/lib/sdl/visualtest/include/SDL_visualtest_parsehelper.h
@@ -1,4 +1,4 @@
-/* See COPYING.txt for the full license governing this code. */
+/* See LICENSE.txt for the full license governing this code. */
 /**
  * \file SDL_visualtest_parsehelper.h
  *
diff --git a/Engine/lib/sdl/visualtest/include/SDL_visualtest_process.h b/Engine/lib/sdl/visualtest/include/SDL_visualtest_process.h
index b548690c2..26ce5a098 100644
--- a/Engine/lib/sdl/visualtest/include/SDL_visualtest_process.h
+++ b/Engine/lib/sdl/visualtest/include/SDL_visualtest_process.h
@@ -1,4 +1,4 @@
-/* See COPYING.txt for the full license governing this code. */
+/* See LICENSE.txt for the full license governing this code. */
 /**
  * \file SDL_visualtest_process.h
  *
@@ -8,8 +8,8 @@
 #include <SDL_platform.h>
 
 #if defined(__WIN32__)
-#include <Windows.h>
-#include <Shlwapi.h>
+#include <windows.h>
+#include <shlwapi.h>
 #elif defined(__LINUX__)
 #include <unistd.h>
 #else
diff --git a/Engine/lib/sdl/visualtest/include/SDL_visualtest_random_variator.h b/Engine/lib/sdl/visualtest/include/SDL_visualtest_random_variator.h
index 99a13c2e3..0514ce631 100644
--- a/Engine/lib/sdl/visualtest/include/SDL_visualtest_random_variator.h
+++ b/Engine/lib/sdl/visualtest/include/SDL_visualtest_random_variator.h
@@ -1,4 +1,4 @@
-/* See COPYING.txt for the full license governing this code. */
+/* See LICENSE.txt for the full license governing this code. */
 /**
  * \file SDL_visualtest_random_variator.h
  *
diff --git a/Engine/lib/sdl/visualtest/include/SDL_visualtest_rwhelper.h b/Engine/lib/sdl/visualtest/include/SDL_visualtest_rwhelper.h
index 2fbf10e14..bc3942594 100644
--- a/Engine/lib/sdl/visualtest/include/SDL_visualtest_rwhelper.h
+++ b/Engine/lib/sdl/visualtest/include/SDL_visualtest_rwhelper.h
@@ -1,4 +1,4 @@
-/* See COPYING.txt for the full license governing this code. */
+/* See LICENSE.txt for the full license governing this code. */
 /**
  * \file rwhelper.c
  *
diff --git a/Engine/lib/sdl/visualtest/include/SDL_visualtest_screenshot.h b/Engine/lib/sdl/visualtest/include/SDL_visualtest_screenshot.h
index 1900ea4e2..69411e99d 100644
--- a/Engine/lib/sdl/visualtest/include/SDL_visualtest_screenshot.h
+++ b/Engine/lib/sdl/visualtest/include/SDL_visualtest_screenshot.h
@@ -1,4 +1,4 @@
-/* See COPYING.txt for the full license governing this code. */
+/* See LICENSE.txt for the full license governing this code. */
 /**
  * \file SDL_visualtest_screenshot.h
  *
diff --git a/Engine/lib/sdl/visualtest/include/SDL_visualtest_sut_configparser.h b/Engine/lib/sdl/visualtest/include/SDL_visualtest_sut_configparser.h
index 42a108856..63506f5a0 100644
--- a/Engine/lib/sdl/visualtest/include/SDL_visualtest_sut_configparser.h
+++ b/Engine/lib/sdl/visualtest/include/SDL_visualtest_sut_configparser.h
@@ -1,4 +1,4 @@
-/* See COPYING.txt for the full license governing this code. */
+/* See LICENSE.txt for the full license governing this code. */
 /**
  * \file SDL_visualtest_sut_configparser.h
  *
diff --git a/Engine/lib/sdl/visualtest/include/SDL_visualtest_variator_common.h b/Engine/lib/sdl/visualtest/include/SDL_visualtest_variator_common.h
index 0b7c153e2..19a5b3782 100644
--- a/Engine/lib/sdl/visualtest/include/SDL_visualtest_variator_common.h
+++ b/Engine/lib/sdl/visualtest/include/SDL_visualtest_variator_common.h
@@ -1,4 +1,4 @@
-/* See COPYING.txt for the full license governing this code. */
+/* See LICENSE.txt for the full license governing this code. */
 /**
  * \file SDL_visualtest_variator_common.h
  *
diff --git a/Engine/lib/sdl/visualtest/include/SDL_visualtest_variators.h b/Engine/lib/sdl/visualtest/include/SDL_visualtest_variators.h
index ce1e785b5..e14f67d2a 100644
--- a/Engine/lib/sdl/visualtest/include/SDL_visualtest_variators.h
+++ b/Engine/lib/sdl/visualtest/include/SDL_visualtest_variators.h
@@ -1,4 +1,4 @@
-/* See COPYING.txt for the full license governing this code. */
+/* See LICENSE.txt for the full license governing this code. */
 /**
  * \file SDL_visualtest_variators.h
  *
diff --git a/Engine/lib/sdl/visualtest/install-sh b/Engine/lib/sdl/visualtest/install-sh
deleted file mode 100644
index 205f21c6b..000000000
--- a/Engine/lib/sdl/visualtest/install-sh
+++ /dev/null
@@ -1 +0,0 @@
-/usr/share/automake-1.11/install-sh
\ No newline at end of file
diff --git a/Engine/lib/sdl/visualtest/missing b/Engine/lib/sdl/visualtest/missing
deleted file mode 100644
index 20bc5b0ed..000000000
--- a/Engine/lib/sdl/visualtest/missing
+++ /dev/null
@@ -1 +0,0 @@
-/usr/share/automake-1.11/missing
\ No newline at end of file
diff --git a/Engine/lib/sdl/visualtest/src/action_configparser.c b/Engine/lib/sdl/visualtest/src/action_configparser.c
index bab7fc13e..f3b1afd73 100644
--- a/Engine/lib/sdl/visualtest/src/action_configparser.c
+++ b/Engine/lib/sdl/visualtest/src/action_configparser.c
@@ -1,4 +1,4 @@
-/* See COPYING.txt for the full license governing this code. */
+/* See LICENSE.txt for the full license governing this code. */
 /**
  * \file action_configparser.c
  *
@@ -36,6 +36,9 @@ FreeAction(SDLVisualTest_Action* action)
             action->extra.process.args = NULL;
         }
         break;
+
+      default:
+        break;
     }
 }
 
@@ -54,7 +57,7 @@ SDLVisualTest_EnqueueAction(SDLVisualTest_ActionQueue* queue,
                                       sizeof(SDLVisualTest_ActionNode));
     if(!node)
     {
-        SDLTest_LogError("malloc() failed");
+        SDLTest_LogError("SDL_malloc() failed");
         return 0;
     }
     node->action = action;
@@ -220,10 +223,10 @@ SDLVisualTest_InsertIntoActionQueue(SDLVisualTest_ActionQueue* queue,
         return 1;
     }
 
-    newnode = (SDLVisualTest_ActionNode*)malloc(sizeof(SDLVisualTest_ActionNode));
+    newnode = (SDLVisualTest_ActionNode*)SDL_malloc(sizeof(SDLVisualTest_ActionNode));
     if(!newnode)
     {
-        SDLTest_LogError("malloc() failed");
+        SDLTest_LogError("SDL_malloc() failed");
         return 0;
     }
     newnode->action = action;
@@ -256,7 +259,7 @@ SDLVisualTest_InsertIntoActionQueue(SDLVisualTest_ActionQueue* queue,
 }
 
 int
-SDLVisualTest_ParseActionConfig(char* file, SDLVisualTest_ActionQueue* queue)
+SDLVisualTest_ParseActionConfig(const char* file, SDLVisualTest_ActionQueue* queue)
 {
     char line[MAX_ACTION_LINE_LENGTH];
     SDLVisualTest_RWHelperBuffer buffer;
@@ -344,7 +347,7 @@ SDLVisualTest_ParseActionConfig(char* file, SDLVisualTest_ActionQueue* queue)
             path = (char*)SDL_malloc(sizeof(char) * (len + 1));
             if(!path)
             {
-                SDLTest_LogError("malloc() failed");
+                SDLTest_LogError("SDL_malloc() failed");
                 SDLVisualTest_EmptyActionQueue(queue);
                 SDL_RWclose(rw);
                 return 0;
@@ -358,7 +361,7 @@ SDLVisualTest_ParseActionConfig(char* file, SDLVisualTest_ActionQueue* queue)
                 args = (char*)SDL_malloc(sizeof(char) * (len + 1));
                 if(!args)
                 {
-                    SDLTest_LogError("malloc() failed");
+                    SDLTest_LogError("SDL_malloc() failed");
                     SDL_free(path);
                     SDLVisualTest_EmptyActionQueue(queue);
                     SDL_RWclose(rw);
@@ -393,4 +396,4 @@ SDLVisualTest_ParseActionConfig(char* file, SDLVisualTest_ActionQueue* queue)
 
     SDL_RWclose(rw);
     return 1;
-}
\ No newline at end of file
+}
diff --git a/Engine/lib/sdl/visualtest/src/harness_argparser.c b/Engine/lib/sdl/visualtest/src/harness_argparser.c
index 93cf614a3..8bc57064b 100644
--- a/Engine/lib/sdl/visualtest/src/harness_argparser.c
+++ b/Engine/lib/sdl/visualtest/src/harness_argparser.c
@@ -1,4 +1,4 @@
-/* See COPYING.txt for the full license governing this code. */
+/* See LICENSE.txt for the full license governing this code. */
 /**
  * \file harness_argparser.c
  *
@@ -19,7 +19,7 @@
 
 /* String compare s1 and s2 ignoring leading hyphens */
 static int
-StrCaseCmpIgnoreHyphen(char* s1, char* s2)
+StrCaseCmpIgnoreHyphen(const char* s1, const char* s2)
 {
     /* treat NULL pointer as empty strings */
     if(!s1)
@@ -199,7 +199,7 @@ ParseArg(char** argv, int index, SDLVisualTest_HarnessState* state)
 
 /* TODO: Trailing/leading spaces and spaces between equals sign not supported. */
 static int
-ParseConfig(char* file, SDLVisualTest_HarnessState* state)
+ParseConfig(const char* file, SDLVisualTest_HarnessState* state)
 {
     SDL_RWops* rw;
     SDLVisualTest_RWHelperBuffer buffer;
@@ -234,7 +234,7 @@ ParseConfig(char* file, SDLVisualTest_HarnessState* state)
         argv = (char**)SDL_malloc((num_params + 1) * sizeof(char*));
         if(!argv)
         {
-            SDLTest_LogError("malloc() failed.");
+            SDLTest_LogError("SDL_malloc() failed.");
             SDL_RWclose(rw);
             return 0;
         }
@@ -355,4 +355,4 @@ SDLVisualTest_FreeHarnessState(SDLVisualTest_HarnessState* state)
         SDLVisualTest_EmptyActionQueue(&state->action_queue);
         SDLVisualTest_FreeSUTConfig(&state->sut_config);
     }
-}
\ No newline at end of file
+}
diff --git a/Engine/lib/sdl/visualtest/src/linux/linux_process.c b/Engine/lib/sdl/visualtest/src/linux/linux_process.c
index f758981ca..b93f3407e 100644
--- a/Engine/lib/sdl/visualtest/src/linux/linux_process.c
+++ b/Engine/lib/sdl/visualtest/src/linux/linux_process.c
@@ -1,4 +1,4 @@
-/* See COPYING.txt for the full license governing this code. */
+/* See LICENSE.txt for the full license governing this code. */
 /**
  *  \file linux_process.c
  * 
@@ -8,23 +8,23 @@
 
 #include <SDL.h>
 #include <SDL_test.h>
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <unistd.h>
-#include <errno.h>
 
 #include "SDL_visualtest_process.h"
 #include "SDL_visualtest_harness_argparser.h"
 #include "SDL_visualtest_parsehelper.h"
 
 #if defined(__LINUX__)
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <errno.h>
 
 static void
-LogLastError(char* str)
+LogLastError(const char* str)
 {
-    char* error = (char*)strerror(errno);
+    const char* error = strerror(errno);
     if(!str || !error)
-    	return;
+        return;
     SDLTest_LogError("%s: %s", str, error);
 }
 
@@ -196,4 +196,13 @@ SDL_KillProcess(SDL_ProcessInfo* pinfo, SDL_ProcessExitStatus* ps)
     return 1;
 }
 
+/* each window of the process will have a screenshot taken. The file name will be
+   prefix-i.png for the i'th window. */
+int
+SDLVisualTest_ScreenshotProcess(SDL_ProcessInfo* pinfo, char* prefix)
+{
+    SDLTest_LogError("Screenshot process not implemented");
+    return 0;
+}
+
 #endif
diff --git a/Engine/lib/sdl/visualtest/src/mischelper.c b/Engine/lib/sdl/visualtest/src/mischelper.c
index 03e705eda..9684af6f6 100644
--- a/Engine/lib/sdl/visualtest/src/mischelper.c
+++ b/Engine/lib/sdl/visualtest/src/mischelper.c
@@ -1,5 +1,5 @@
 /**
- * \file mischelper.c 
+ * \file mischelper.c
  *
  * Source file with miscellaneous helper functions.
  */
@@ -25,4 +25,4 @@ SDLVisualTest_HashString(char* str, char hash[33])
     /* convert the md5 hash to an array of hexadecimal digits */
     for(i = 0; i < 16; i++)
         SDL_snprintf(hash + 2 * i, 33 - 2 * i, "%02x", (int)md5c.digest[i]);
-}
\ No newline at end of file
+}
diff --git a/Engine/lib/sdl/visualtest/src/parsehelper.c b/Engine/lib/sdl/visualtest/src/parsehelper.c
index 7d601179b..9d38cb2f2 100644
--- a/Engine/lib/sdl/visualtest/src/parsehelper.c
+++ b/Engine/lib/sdl/visualtest/src/parsehelper.c
@@ -1,4 +1,4 @@
-/* See COPYING.txt for the full license governing this code. */
+/* See LICENSE.txt for the full license governing this code. */
 /**
  * \file parsehelper.c
  *
@@ -18,7 +18,7 @@ CountTokens(char* args)
     int state; /* current state of the DFA */
 
     if(!args)
-    	return -1;
+        return -1;
 
     index = 0;
     state = 0;
@@ -96,7 +96,7 @@ TokenizeHelper(char* str, char** tokens, int num_tokens, int max_token_len)
         if(!tokens[index])
         {
             int i;
-            SDLTest_LogError("malloc() failed.");
+            SDLTest_LogError("SDL_malloc() failed.");
             for(i = 0; i < index; i++)
                 SDL_free(tokens[i]);
             return 0;
@@ -215,7 +215,7 @@ SDLVisualTest_ParseArgsToArgv(char* args)
     argv = (char**)SDL_malloc((num_tokens + 2) * sizeof(char*));
     if(!argv)
     {
-        SDLTest_LogError("malloc() failed.");
+        SDLTest_LogError("SDL_malloc() failed.");
         return NULL;
     }
 
diff --git a/Engine/lib/sdl/visualtest/src/rwhelper.c b/Engine/lib/sdl/visualtest/src/rwhelper.c
index a50254006..1ff9190ff 100644
--- a/Engine/lib/sdl/visualtest/src/rwhelper.c
+++ b/Engine/lib/sdl/visualtest/src/rwhelper.c
@@ -1,4 +1,4 @@
-/* See COPYING.txt for the full license governing this code. */
+/* See LICENSE.txt for the full license governing this code. */
 /**
  * \file rwhelper.c
  *
@@ -128,4 +128,4 @@ SDLVisualTest_RWHelperCountNonEmptyLines(SDL_RWops* rw,
                                          buffer, comment_char))
         num_lines++;
     return num_lines;
-}
\ No newline at end of file
+}
diff --git a/Engine/lib/sdl/visualtest/src/screenshot.c b/Engine/lib/sdl/visualtest/src/screenshot.c
index 7d19c7f88..be5e4df85 100644
--- a/Engine/lib/sdl/visualtest/src/screenshot.c
+++ b/Engine/lib/sdl/visualtest/src/screenshot.c
@@ -1,6 +1,6 @@
-/* See COPYING.txt for the full license governing this code. */
+/* See LICENSE.txt for the full license governing this code. */
 /**
- * \file screenshot.c 
+ * \file screenshot.c
  *
  * Source file for the screenshot API.
  */
@@ -48,7 +48,7 @@ SDLVisualTest_VerifyScreenshots(char* args, char* test_dir, char* verify_dir)
     verify_path = (char*)SDL_malloc(verify_len * sizeof(char));
     if(!verify_path)
     {
-        SDLTest_LogError("malloc() failed");
+        SDLTest_LogError("SDL_malloc() failed");
         return_code = -1;
         goto verifyscreenshots_cleanup_generic;
     }
@@ -78,7 +78,7 @@ SDLVisualTest_VerifyScreenshots(char* args, char* test_dir, char* verify_dir)
     test_path = (char*)SDL_malloc(test_len * sizeof(char));
     if(!test_path)
     {
-        SDLTest_LogError("malloc() failed");
+        SDLTest_LogError("SDL_malloc() failed");
         return_code = -1;
         goto verifyscreenshots_cleanup_verifybmp;
     }
diff --git a/Engine/lib/sdl/visualtest/src/sut_configparser.c b/Engine/lib/sdl/visualtest/src/sut_configparser.c
index cf18b6208..fa8c2d4bb 100644
--- a/Engine/lib/sdl/visualtest/src/sut_configparser.c
+++ b/Engine/lib/sdl/visualtest/src/sut_configparser.c
@@ -1,4 +1,4 @@
-/* See COPYING.txt for the full license governing this code. */
+/* See LICENSE.txt for the full license governing this code. */
 /**
  * \file sut_configparser.c
  *
@@ -61,7 +61,7 @@ SDLVisualTest_ParseSUTConfig(char* file, SDLVisualTest_SUTConfig* config)
                       sizeof(SDLVisualTest_SUTOption));
     if(!config->options)
     {
-        SDLTest_LogError("malloc() failed");
+        SDLTest_LogError("SDL_malloc() failed");
         SDL_RWclose(rw);
         return 0;
     }
diff --git a/Engine/lib/sdl/visualtest/src/testharness.c b/Engine/lib/sdl/visualtest/src/testharness.c
index 25e41a611..db3ca55b2 100644
--- a/Engine/lib/sdl/visualtest/src/testharness.c
+++ b/Engine/lib/sdl/visualtest/src/testharness.c
@@ -1,6 +1,6 @@
-/* See COPYING.txt for the full license governing this code. */
+/* See LICENSE.txt for the full license governing this code. */
 /**
- *  \file testharness.c 
+ *  \file testharness.c
  *
  *  Source file for the test harness.
  */
@@ -49,8 +49,8 @@ static SDLVisualTest_ActionNode* current; /* the current action being performed
 static SDL_TimerID action_timer, kill_timer;
 
 /* returns a char* to be passed as the format argument of a printf-style function. */
-static char*
-usage()
+static const char*
+usage(void)
 {
     return "Usage: \n%s --sutapp xyz"
            " [--sutargs abc | --parameter-config xyz.parameters"
@@ -82,10 +82,10 @@ ActionTimerCallback(Uint32 interval, void* param)
     Uint32 next_action_time;
 
     /* push an event to handle the action */
+    SDL_zero(userevent);
     userevent.type = SDL_USEREVENT;
     userevent.code = ACTION_TIMER_EVENT;
     userevent.data1 = &current->action;
-    userevent.data2 = NULL;
 
     event.type = SDL_USEREVENT;
     event.user = userevent;
@@ -110,10 +110,9 @@ KillTimerCallback(Uint32 interval, void* param)
     SDL_Event event;
     SDL_UserEvent userevent;
 
+    SDL_zero(userevent);
     userevent.type = SDL_USEREVENT;
     userevent.code = KILL_TIMER_EVENT;
-    userevent.data1 = NULL;
-    userevent.data2 = NULL;
 
     event.type = SDL_USEREVENT;
     event.user = userevent;
@@ -181,7 +180,7 @@ ProcessAction(SDLVisualTest_Action* action, int* sut_running, char* args)
             if(SDL_IsProcessRunning(&action_process) > 0)
             {
                 SDLTest_LogError("Process %s took too long too complete."
-                                    " Force killing...", action->extra);
+                                 " Force killing...", action->extra.process.path);
                 if(!SDL_KillProcess(&action_process, &ps))
                 {
                     SDLTest_LogError("SDL_KillProcess() failed");
@@ -463,7 +462,7 @@ main(int argc, char* argv[])
 
     if(state.sut_config.num_options > 0)
     {
-        char* variator_name = state.variator_type == SDL_VARIATOR_RANDOM ?
+        const char* variator_name = (state.variator_type == SDL_VARIATOR_RANDOM) ?
                               "RANDOM" : "EXHAUSTIVE";
         if(state.num_variations > 0)
             SDLTest_Log("Testing SUT with variator: %s for %d variations",
@@ -519,7 +518,7 @@ main(int argc, char* argv[])
         }
         goto cleanup_variator;
     }
- 
+
     goto cleanup_sdl;
 
 cleanup_variator:
diff --git a/Engine/lib/sdl/visualtest/src/variator_common.c b/Engine/lib/sdl/visualtest/src/variator_common.c
index dec3d8aac..e8444b317 100644
--- a/Engine/lib/sdl/visualtest/src/variator_common.c
+++ b/Engine/lib/sdl/visualtest/src/variator_common.c
@@ -1,4 +1,4 @@
-/* See COPYING.txt for the full license governing this code. */
+/* See LICENSE.txt for the full license governing this code. */
 /**
  * \file variator_common.c
  *
@@ -189,7 +189,7 @@ SDLVisualTest_InitVariation(SDLVisualTest_Variation* variation,
                      sizeof(SDLVisualTest_SUTOptionValue));
     if(!variation->vars)
     {
-        SDLTest_LogError("malloc() failed");
+        SDLTest_LogError("SDL_malloc() failed");
         return 0;
     }
     variation->num_vars = config->num_options;
@@ -222,4 +222,4 @@ SDLVisualTest_InitVariation(SDLVisualTest_Variation* variation,
         }
     }
     return 1;
-}
\ No newline at end of file
+}
diff --git a/Engine/lib/sdl/visualtest/src/variator_exhaustive.c b/Engine/lib/sdl/visualtest/src/variator_exhaustive.c
index 2a0ab35c7..1e6a79e0a 100644
--- a/Engine/lib/sdl/visualtest/src/variator_exhaustive.c
+++ b/Engine/lib/sdl/visualtest/src/variator_exhaustive.c
@@ -1,4 +1,4 @@
-/* See COPYING.txt for the full license governing this code. */
+/* See LICENSE.txt for the full license governing this code. */
 /**
  * \file variator_exhaustive.c
  *
@@ -39,6 +39,7 @@ NextVariation(SDLVisualTest_Variation* variation,
         return 0;
     if(carry == 0)
         return 1;
+
     SDLTest_LogError("NextVariation() failed");
     return -1;
 }
@@ -129,4 +130,4 @@ SDLVisualTest_FreeExhaustiveVariator(SDLVisualTest_ExhaustiveVariator* variator)
     }
     SDL_free(variator->variation.vars);
     variator->variation.vars = NULL;
-}
\ No newline at end of file
+}
diff --git a/Engine/lib/sdl/visualtest/src/variator_random.c b/Engine/lib/sdl/visualtest/src/variator_random.c
index 14b5d48a8..4da4161e1 100644
--- a/Engine/lib/sdl/visualtest/src/variator_random.c
+++ b/Engine/lib/sdl/visualtest/src/variator_random.c
@@ -1,4 +1,4 @@
-/* See COPYING.txt for the full license governing this code. */
+/* See LICENSE.txt for the full license governing this code. */
 /**
  * \file variator_random.c
  *
@@ -47,12 +47,13 @@ SDLVisualTest_GetNextRandomVariation(SDLVisualTest_RandomVariator* variator)
     SDLVisualTest_SUTOptionValue* vars;
     SDLVisualTest_SUTOption* options;
     int i;
+
     if(!variator)
     {
         SDLTest_LogError("variator argument cannot be NULL");
         return NULL;
     }
- 
+
     /* to save typing */
     vars = variator->variation.vars;
     options = variator->config.options;
@@ -106,6 +107,7 @@ void SDLVisualTest_FreeRandomVariator(SDLVisualTest_RandomVariator* variator)
         SDLTest_LogError("variator argument cannot be NULL");
         return;
     }
+
     SDL_free(variator->variation.vars);
     variator->variation.vars = NULL;
-}
\ No newline at end of file
+}
diff --git a/Engine/lib/sdl/visualtest/src/variators.c b/Engine/lib/sdl/visualtest/src/variators.c
index 2d63113c5..e9485c6f6 100644
--- a/Engine/lib/sdl/visualtest/src/variators.c
+++ b/Engine/lib/sdl/visualtest/src/variators.c
@@ -1,4 +1,4 @@
-/* See COPYING.txt for the full license governing this code. */
+/* See LICENSE.txt for the full license governing this code. */
 /**
  * \file variators.c
  *
@@ -53,6 +53,7 @@ SDLVisualTest_GetNextVariation(SDLVisualTest_Variator* variator)
         SDLTest_LogError("variator argument cannot be NULL");
         return NULL;
     }
+
     switch(variator->type)
     {
         case SDL_VARIATOR_EXHAUSTIVE:
@@ -77,6 +78,7 @@ void SDLVisualTest_FreeVariator(SDLVisualTest_Variator* variator)
         SDLTest_LogError("variator argument cannot be NULL");
         return;
     }
+
     switch(variator->type)
     {
         case SDL_VARIATOR_EXHAUSTIVE:
@@ -90,4 +92,4 @@ void SDLVisualTest_FreeVariator(SDLVisualTest_Variator* variator)
         default:
             SDLTest_LogError("Invalid value for variator type");
     }
-}
\ No newline at end of file
+}
diff --git a/Engine/lib/sdl/visualtest/src/windows/windows_process.c b/Engine/lib/sdl/visualtest/src/windows/windows_process.c
index ad0938951..e7e265c7c 100644
--- a/Engine/lib/sdl/visualtest/src/windows/windows_process.c
+++ b/Engine/lib/sdl/visualtest/src/windows/windows_process.c
@@ -1,11 +1,10 @@
-/* See COPYING.txt for the full license governing this code. */
+/* See LICENSE.txt for the full license governing this code. */
 /**
- * \file windows_process.c 
+ * \file windows_process.c
  *
  * Source file for the process API on windows.
  */
 
-
 #include <SDL.h>
 #include <SDL_test.h>
 #include <string.h>
@@ -16,7 +15,7 @@
 #if defined(__WIN32__)
 
 void
-LogLastError(char* str)
+LogLastError(const char* str)
 {
     LPVOID buffer;
     DWORD dw = GetLastError();
@@ -61,7 +60,7 @@ SDL_LaunchProcess(char* file, char* args, SDL_ProcessInfo* pinfo)
     working_directory = (char*)SDL_malloc(path_length + 1);
     if(!working_directory)
     {
-        SDLTest_LogError("Could not allocate working_directory - malloc() failed.");
+        SDLTest_LogError("Could not allocate working_directory - SDL_malloc() failed.");
         return 0;
     }
 
@@ -80,7 +79,7 @@ SDL_LaunchProcess(char* file, char* args, SDL_ProcessInfo* pinfo)
     command_line = (char*)SDL_malloc(path_length + args_length + 2);
     if(!command_line)
     {
-        SDLTest_LogError("Could not allocate command_line - malloc() failed.");
+        SDLTest_LogError("Could not allocate command_line - SDL_malloc() failed.");
         return 0;
     }
     SDL_memcpy(command_line, file, path_length);
@@ -175,7 +174,7 @@ CloseWindowCallback(HWND hwnd, LPARAM lparam)
     GetWindowThreadProcessId(hwnd, &pid);
     if(pid == pinfo->pi.dwProcessId)
     {
-        DWORD result;
+        DWORD_PTR result;
         if(!SendMessageTimeout(hwnd, WM_CLOSE, 0, 0, SMTO_BLOCK,
                                1000, &result))
         {
diff --git a/Engine/lib/sdl/visualtest/src/windows/windows_screenshot.c b/Engine/lib/sdl/visualtest/src/windows/windows_screenshot.c
index 785590359..6d9189dc4 100644
--- a/Engine/lib/sdl/visualtest/src/windows/windows_screenshot.c
+++ b/Engine/lib/sdl/visualtest/src/windows/windows_screenshot.c
@@ -1,6 +1,6 @@
-/* See COPYING.txt for the full license governing this code. */
+/* See LICENSE.txt for the full license governing this code. */
 /**
- * \file windows_screenshot.c 
+ * \file windows_screenshot.c
  *
  * Source file for the screenshot API on windows.
  */
@@ -14,9 +14,9 @@
 #endif
 
 #if defined(__WIN32__)
-#include <Windows.h>
+#include <windows.h>
 
-void LogLastError(char* str);
+void LogLastError(const char* str);
 
 static int img_num;
 static SDL_ProcessInfo screenshot_pinfo;
@@ -241,7 +241,7 @@ ScreenshotWindow(HWND hwnd, char* filename, SDL_bool only_client_area)
         goto screenshotwindow_cleanup_capturebitmap;
     }
 
-    /* free resources */
+    /* Free resources */
 
 screenshotwindow_cleanup_capturebitmap:
     if(!DeleteObject(capturebitmap))
@@ -297,7 +297,7 @@ ScreenshotHwnd(HWND hwnd, LPARAM lparam)
     filename = (char*)SDL_malloc(len * sizeof(char));
     if(!filename)
     {
-        SDLTest_LogError("malloc() failed");
+        SDLTest_LogError("SDL_malloc() failed");
         return FALSE;
     }
 
diff --git a/Engine/lib/sdl/visualtest/stamp-h1 b/Engine/lib/sdl/visualtest/stamp-h1
deleted file mode 100644
index 4547fe1b5..000000000
--- a/Engine/lib/sdl/visualtest/stamp-h1
+++ /dev/null
@@ -1 +0,0 @@
-timestamp for config.h
diff --git a/Engine/lib/sdl/visualtest/unittest/testquit.c b/Engine/lib/sdl/visualtest/unittest/testquit.c
index 6cf453672..04e3c5c5a 100644
--- a/Engine/lib/sdl/visualtest/unittest/testquit.c
+++ b/Engine/lib/sdl/visualtest/unittest/testquit.c
@@ -64,7 +64,7 @@ main(int argc, char** argv)
 
         if(consumed < 0)
         {
-            static const char *options = { "[--exit-code N]", "[--crash]", "[--hang]", NULL };
+            static const char *options[] = { "[--exit-code N]", "[--crash]", "[--hang]", NULL };
             SDLTest_CommonLogUsage(state, argv[0], options);
             SDLTest_CommonQuit(state);
             return 1;
diff --git a/Engine/lib/sdl/wayland-protocols/idle-inhibit-unstable-v1.xml b/Engine/lib/sdl/wayland-protocols/idle-inhibit-unstable-v1.xml
new file mode 100644
index 000000000..9c06cdcba
--- /dev/null
+++ b/Engine/lib/sdl/wayland-protocols/idle-inhibit-unstable-v1.xml
@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="idle_inhibit_unstable_v1">
+
+  <copyright>
+    Copyright © 2015 Samsung Electronics Co., Ltd
+
+    Permission is hereby granted, free of charge, to any person obtaining a
+    copy of this software and associated documentation files (the "Software"),
+    to deal in the Software without restriction, including without limitation
+    the rights to use, copy, modify, merge, publish, distribute, sublicense,
+    and/or sell copies of the Software, and to permit persons to whom the
+    Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice (including the next
+    paragraph) shall be included in all copies or substantial portions of the
+    Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+    DEALINGS IN THE SOFTWARE.
+  </copyright>
+
+  <interface name="zwp_idle_inhibit_manager_v1" version="1">
+    <description summary="control behavior when display idles">
+      This interface permits inhibiting the idle behavior such as screen
+      blanking, locking, and screensaving.  The client binds the idle manager
+      globally, then creates idle-inhibitor objects for each surface.
+
+      Warning! The protocol described in this file is experimental and
+      backward incompatible changes may be made. Backward compatible changes
+      may be added together with the corresponding interface version bump.
+      Backward incompatible changes are done by bumping the version number in
+      the protocol and interface names and resetting the interface version.
+      Once the protocol is to be declared stable, the 'z' prefix and the
+      version number in the protocol and interface names are removed and the
+      interface version number is reset.
+    </description>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the idle inhibitor object">
+	Destroy the inhibit manager.
+      </description>
+    </request>
+
+    <request name="create_inhibitor">
+      <description summary="create a new inhibitor object">
+	Create a new inhibitor object associated with the given surface.
+      </description>
+      <arg name="id" type="new_id" interface="zwp_idle_inhibitor_v1"/>
+      <arg name="surface" type="object" interface="wl_surface"
+	   summary="the surface that inhibits the idle behavior"/>
+    </request>
+
+  </interface>
+
+  <interface name="zwp_idle_inhibitor_v1" version="1">
+    <description summary="context object for inhibiting idle behavior">
+      An idle inhibitor prevents the output that the associated surface is
+      visible on from being set to a state where it is not visually usable due
+      to lack of user interaction (e.g. blanked, dimmed, locked, set to power
+      save, etc.)  Any screensaver processes are also blocked from displaying.
+
+      If the surface is destroyed, unmapped, becomes occluded, loses
+      visibility, or otherwise becomes not visually relevant for the user, the
+      idle inhibitor will not be honored by the compositor; if the surface
+      subsequently regains visibility the inhibitor takes effect once again.
+      Likewise, the inhibitor isn't honored if the system was already idled at
+      the time the inhibitor was established, although if the system later
+      de-idles and re-idles the inhibitor will take effect.
+    </description>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the idle inhibitor object">
+	Remove the inhibitor effect from the associated wl_surface.
+      </description>
+    </request>
+
+  </interface>
+</protocol>
diff --git a/Engine/lib/sdl/wayland-protocols/keyboard-shortcuts-inhibit-unstable-v1.xml b/Engine/lib/sdl/wayland-protocols/keyboard-shortcuts-inhibit-unstable-v1.xml
new file mode 100644
index 000000000..27748764d
--- /dev/null
+++ b/Engine/lib/sdl/wayland-protocols/keyboard-shortcuts-inhibit-unstable-v1.xml
@@ -0,0 +1,143 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="keyboard_shortcuts_inhibit_unstable_v1">
+
+  <copyright>
+    Copyright © 2017 Red Hat Inc.
+
+    Permission is hereby granted, free of charge, to any person obtaining a
+    copy of this software and associated documentation files (the "Software"),
+    to deal in the Software without restriction, including without limitation
+    the rights to use, copy, modify, merge, publish, distribute, sublicense,
+    and/or sell copies of the Software, and to permit persons to whom the
+    Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice (including the next
+    paragraph) shall be included in all copies or substantial portions of the
+    Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+    DEALINGS IN THE SOFTWARE.
+  </copyright>
+
+  <description summary="Protocol for inhibiting the compositor keyboard shortcuts">
+    This protocol specifies a way for a client to request the compositor
+    to ignore its own keyboard shortcuts for a given seat, so that all
+    key events from that seat get forwarded to a surface.
+
+    Warning! The protocol described in this file is experimental and
+    backward incompatible changes may be made. Backward compatible
+    changes may be added together with the corresponding interface
+    version bump.
+    Backward incompatible changes are done by bumping the version
+    number in the protocol and interface names and resetting the
+    interface version. Once the protocol is to be declared stable,
+    the 'z' prefix and the version number in the protocol and
+    interface names are removed and the interface version number is
+    reset.
+  </description>
+
+  <interface name="zwp_keyboard_shortcuts_inhibit_manager_v1" version="1">
+    <description summary="context object for keyboard grab_manager">
+      A global interface used for inhibiting the compositor keyboard shortcuts.
+    </description>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the keyboard shortcuts inhibitor object">
+	Destroy the keyboard shortcuts inhibitor manager.
+      </description>
+    </request>
+
+    <request name="inhibit_shortcuts">
+      <description summary="create a new keyboard shortcuts inhibitor object">
+	Create a new keyboard shortcuts inhibitor object associated with
+	the given surface for the given seat.
+
+	If shortcuts are already inhibited for the specified seat and surface,
+	a protocol error "already_inhibited" is raised by the compositor.
+      </description>
+      <arg name="id" type="new_id" interface="zwp_keyboard_shortcuts_inhibitor_v1"/>
+      <arg name="surface" type="object" interface="wl_surface"
+	   summary="the surface that inhibits the keyboard shortcuts behavior"/>
+      <arg name="seat" type="object" interface="wl_seat"
+	   summary="the wl_seat for which keyboard shortcuts should be disabled"/>
+    </request>
+
+    <enum name="error">
+      <entry name="already_inhibited"
+	     value="0"
+	     summary="the shortcuts are already inhibited for this surface"/>
+    </enum>
+  </interface>
+
+  <interface name="zwp_keyboard_shortcuts_inhibitor_v1" version="1">
+    <description summary="context object for keyboard shortcuts inhibitor">
+      A keyboard shortcuts inhibitor instructs the compositor to ignore
+      its own keyboard shortcuts when the associated surface has keyboard
+      focus. As a result, when the surface has keyboard focus on the given
+      seat, it will receive all key events originating from the specified
+      seat, even those which would normally be caught by the compositor for
+      its own shortcuts.
+
+      The Wayland compositor is however under no obligation to disable
+      all of its shortcuts, and may keep some special key combo for its own
+      use, including but not limited to one allowing the user to forcibly
+      restore normal keyboard events routing in the case of an unwilling
+      client. The compositor may also use the same key combo to reactivate
+      an existing shortcut inhibitor that was previously deactivated on
+      user request.
+
+      When the compositor restores its own keyboard shortcuts, an
+      "inactive" event is emitted to notify the client that the keyboard
+      shortcuts inhibitor is not effectively active for the surface and
+      seat any more, and the client should not expect to receive all
+      keyboard events.
+
+      When the keyboard shortcuts inhibitor is inactive, the client has
+      no way to forcibly reactivate the keyboard shortcuts inhibitor.
+
+      The user can chose to re-enable a previously deactivated keyboard
+      shortcuts inhibitor using any mechanism the compositor may offer,
+      in which case the compositor will send an "active" event to notify
+      the client.
+
+      If the surface is destroyed, unmapped, or loses the seat's keyboard
+      focus, the keyboard shortcuts inhibitor becomes irrelevant and the
+      compositor will restore its own keyboard shortcuts but no "inactive"
+      event is emitted in this case.
+    </description>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the keyboard shortcuts inhibitor object">
+	Remove the keyboard shortcuts inhibitor from the associated wl_surface.
+      </description>
+    </request>
+
+    <event name="active">
+      <description summary="shortcuts are inhibited">
+	This event indicates that the shortcut inhibitor is active.
+
+	The compositor sends this event every time compositor shortcuts
+	are inhibited on behalf of the surface. When active, the client
+	may receive input events normally reserved by the compositor
+	(see zwp_keyboard_shortcuts_inhibitor_v1).
+
+	This occurs typically when the initial request "inhibit_shortcuts"
+	first becomes active or when the user instructs the compositor to
+	re-enable and existing shortcuts inhibitor using any mechanism
+	offered by the compositor.
+      </description>
+    </event>
+
+    <event name="inactive">
+      <description summary="shortcuts are restored">
+	This event indicates that the shortcuts inhibitor is inactive,
+	normal shortcuts processing is restored by the compositor.
+       </description>
+    </event>
+  </interface>
+</protocol>
diff --git a/Engine/lib/sdl/wayland-protocols/org-kde-kwin-server-decoration-manager.xml b/Engine/lib/sdl/wayland-protocols/org-kde-kwin-server-decoration-manager.xml
deleted file mode 100644
index 8bc106c7c..000000000
--- a/Engine/lib/sdl/wayland-protocols/org-kde-kwin-server-decoration-manager.xml
+++ /dev/null
@@ -1,94 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<protocol name="server_decoration">
-  <copyright><![CDATA[
-    Copyright (C) 2015 Martin Gräßlin
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as published by
-    the Free Software Foundation, either version 2.1 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-  ]]></copyright>
-  <interface  name="org_kde_kwin_server_decoration_manager" version="1">
-      <description summary="Server side window decoration manager">
-        This interface allows to coordinate whether the server should create
-        a server-side window decoration around a wl_surface representing a
-        shell surface (wl_shell_surface or similar). By announcing support
-        for this interface the server indicates that it supports server
-        side decorations.
-      </description>
-      <request name="create">
-        <description summary="Create a server-side decoration object for a given surface">
-            When a client creates a server-side decoration object it indicates
-            that it supports the protocol. The client is supposed to tell the
-            server whether it wants server-side decorations or will provide
-            client-side decorations.
-
-            If the client does not create a server-side decoration object for
-            a surface the server interprets this as lack of support for this
-            protocol and considers it as client-side decorated. Nevertheless a
-            client-side decorated surface should use this protocol to indicate
-            to the server that it does not want a server-side deco.
-        </description>
-        <arg name="id" type="new_id" interface="org_kde_kwin_server_decoration"/>
-        <arg name="surface" type="object" interface="wl_surface"/>
-      </request>
-      <enum name="mode">
-            <description summary="Possible values to use in request_mode and the event mode."/>
-            <entry name="None" value="0" summary="Undecorated: The surface is not decorated at all, neither server nor client-side. An example is a popup surface which should not be decorated."/>
-            <entry name="Client" value="1" summary="Client-side decoration: The decoration is part of the surface and the client."/>
-            <entry name="Server" value="2" summary="Server-side decoration: The server embeds the surface into a decoration frame."/>
-      </enum>
-      <event name="default_mode">
-          <description summary="The default mode used on the server">
-              This event is emitted directly after binding the interface. It contains
-              the default mode for the decoration. When a new server decoration object
-              is created this new object will be in the default mode until the first
-              request_mode is requested.
-
-              The server may change the default mode at any time.
-          </description>
-          <arg name="mode" type="uint" summary="The default decoration mode applied to newly created server decorations."/>
-      </event>
-  </interface>
-  <interface name="org_kde_kwin_server_decoration" version="1">
-      <request name="release" type="destructor">
-        <description summary="release the server decoration object"/>
-      </request>
-      <enum name="mode">
-            <description summary="Possible values to use in request_mode and the event mode."/>
-            <entry name="None" value="0" summary="Undecorated: The surface is not decorated at all, neither server nor client-side. An example is a popup surface which should not be decorated."/>
-            <entry name="Client" value="1" summary="Client-side decoration: The decoration is part of the surface and the client."/>
-            <entry name="Server" value="2" summary="Server-side decoration: The server embeds the surface into a decoration frame."/>
-      </enum>
-      <request name="request_mode">
-          <description summary="The decoration mode the surface wants to use."/>
-          <arg name="mode" type="uint" summary="The mode this surface wants to use."/>
-      </request>
-      <event name="mode">
-          <description summary="The new decoration mode applied by the server">
-              This event is emitted directly after the decoration is created and
-              represents the base decoration policy by the server. E.g. a server
-              which wants all surfaces to be client-side decorated will send Client,
-              a server which wants server-side decoration will send Server.
-
-              The client can request a different mode through the decoration request.
-              The server will acknowledge this by another event with the same mode. So
-              even if a server prefers server-side decoration it's possible to force a
-              client-side decoration.
-
-              The server may emit this event at any time. In this case the client can
-              again request a different mode. It's the responsibility of the server to
-              prevent a feedback loop.
-          </description>
-          <arg name="mode" type="uint" summary="The decoration mode applied to the surface by the server."/>
-      </event>
-  </interface>
-</protocol>
diff --git a/Engine/lib/sdl/wayland-protocols/text-input-unstable-v3.xml b/Engine/lib/sdl/wayland-protocols/text-input-unstable-v3.xml
new file mode 100644
index 000000000..d5f6322b0
--- /dev/null
+++ b/Engine/lib/sdl/wayland-protocols/text-input-unstable-v3.xml
@@ -0,0 +1,452 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<protocol name="text_input_unstable_v3">
+  <copyright>
+    Copyright © 2012, 2013 Intel Corporation
+    Copyright © 2015, 2016 Jan Arne Petersen
+    Copyright © 2017, 2018 Red Hat, Inc.
+    Copyright © 2018       Purism SPC
+
+    Permission to use, copy, modify, distribute, and sell this
+    software and its documentation for any purpose is hereby granted
+    without fee, provided that the above copyright notice appear in
+    all copies and that both that copyright notice and this permission
+    notice appear in supporting documentation, and that the name of
+    the copyright holders not be used in advertising or publicity
+    pertaining to distribution of the software without specific,
+    written prior permission.  The copyright holders make no
+    representations about the suitability of this software for any
+    purpose.  It is provided "as is" without express or implied
+    warranty.
+
+    THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
+    SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+    FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
+    SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+    AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+    ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+    THIS SOFTWARE.
+  </copyright>
+
+  <description summary="Protocol for composing text">
+    This protocol allows compositors to act as input methods and to send text
+    to applications. A text input object is used to manage state of what are
+    typically text entry fields in the application.
+
+    This document adheres to the RFC 2119 when using words like "must",
+    "should", "may", etc.
+
+    Warning! The protocol described in this file is experimental and
+    backward incompatible changes may be made. Backward compatible changes
+    may be added together with the corresponding interface version bump.
+    Backward incompatible changes are done by bumping the version number in
+    the protocol and interface names and resetting the interface version.
+    Once the protocol is to be declared stable, the 'z' prefix and the
+    version number in the protocol and interface names are removed and the
+    interface version number is reset.
+  </description>
+
+  <interface name="zwp_text_input_v3" version="1">
+    <description summary="text input">
+      The zwp_text_input_v3 interface represents text input and input methods
+      associated with a seat. It provides enter/leave events to follow the
+      text input focus for a seat.
+
+      Requests are used to enable/disable the text-input object and set
+      state information like surrounding and selected text or the content type.
+      The information about the entered text is sent to the text-input object
+      via the preedit_string and commit_string events.
+
+      Text is valid UTF-8 encoded, indices and lengths are in bytes. Indices
+      must not point to middle bytes inside a code point: they must either
+      point to the first byte of a code point or to the end of the buffer.
+      Lengths must be measured between two valid indices.
+
+      Focus moving throughout surfaces will result in the emission of
+      zwp_text_input_v3.enter and zwp_text_input_v3.leave events. The focused
+      surface must commit zwp_text_input_v3.enable and
+      zwp_text_input_v3.disable requests as the keyboard focus moves across
+      editable and non-editable elements of the UI. Those two requests are not
+      expected to be paired with each other, the compositor must be able to
+      handle consecutive series of the same request.
+
+      State is sent by the state requests (set_surrounding_text,
+      set_content_type and set_cursor_rectangle) and a commit request. After an
+      enter event or disable request all state information is invalidated and
+      needs to be resent by the client.
+    </description>
+
+    <request name="destroy" type="destructor">
+      <description summary="Destroy the wp_text_input">
+        Destroy the wp_text_input object. Also disables all surfaces enabled
+        through this wp_text_input object.
+      </description>
+    </request>
+
+    <request name="enable">
+      <description summary="Request text input to be enabled">
+        Requests text input on the surface previously obtained from the enter
+        event.
+
+        This request must be issued every time the active text input changes
+        to a new one, including within the current surface. Use
+        zwp_text_input_v3.disable when there is no longer any input focus on
+        the current surface.
+
+        Clients must not enable more than one text input on the single seat
+        and should disable the current text input before enabling the new one.
+        At most one instance of text input may be in enabled state per instance,
+        Requests to enable the another text input when some text input is active
+        must be ignored by compositor.
+
+        This request resets all state associated with previous enable, disable,
+        set_surrounding_text, set_text_change_cause, set_content_type, and
+        set_cursor_rectangle requests, as well as the state associated with
+        preedit_string, commit_string, and delete_surrounding_text events.
+
+        The set_surrounding_text, set_content_type and set_cursor_rectangle
+        requests must follow if the text input supports the necessary
+        functionality.
+
+        State set with this request is double-buffered. It will get applied on
+        the next zwp_text_input_v3.commit request, and stay valid until the
+        next committed enable or disable request.
+
+        The changes must be applied by the compositor after issuing a
+        zwp_text_input_v3.commit request.
+      </description>
+    </request>
+
+    <request name="disable">
+      <description summary="Disable text input on a surface">
+        Explicitly disable text input on the current surface (typically when
+        there is no focus on any text entry inside the surface).
+
+        State set with this request is double-buffered. It will get applied on
+        the next zwp_text_input_v3.commit request.
+      </description>
+    </request>
+
+    <request name="set_surrounding_text">
+      <description summary="sets the surrounding text">
+        Sets the surrounding plain text around the input, excluding the preedit
+        text.
+
+        The client should notify the compositor of any changes in any of the
+        values carried with this request, including changes caused by handling
+        incoming text-input events as well as changes caused by other
+        mechanisms like keyboard typing.
+
+        If the client is unaware of the text around the cursor, it should not
+        issue this request, to signify lack of support to the compositor.
+
+        Text is UTF-8 encoded, and should include the cursor position, the
+        complete selection and additional characters before and after them.
+        There is a maximum length of wayland messages, so text can not be
+        longer than 4000 bytes.
+
+        Cursor is the byte offset of the cursor within text buffer.
+
+        Anchor is the byte offset of the selection anchor within text buffer.
+        If there is no selected text, anchor is the same as cursor.
+
+        If any preedit text is present, it is replaced with a cursor for the
+        purpose of this event.
+
+        Values set with this request are double-buffered. They will get applied
+        on the next zwp_text_input_v3.commit request, and stay valid until the
+        next committed enable or disable request.
+
+        The initial state for affected fields is empty, meaning that the text
+        input does not support sending surrounding text. If the empty values
+        get applied, subsequent attempts to change them may have no effect.
+      </description>
+      <arg name="text" type="string"/>
+      <arg name="cursor" type="int"/>
+      <arg name="anchor" type="int"/>
+    </request>
+
+    <enum name="change_cause">
+      <description summary="text change reason">
+        Reason for the change of surrounding text or cursor posision.
+      </description>
+      <entry name="input_method" value="0" summary="input method caused the change"/>
+      <entry name="other" value="1" summary="something else than the input method caused the change"/>
+    </enum>
+
+    <request name="set_text_change_cause">
+      <description summary="indicates the cause of surrounding text change">
+        Tells the compositor why the text surrounding the cursor changed.
+
+        Whenever the client detects an external change in text, cursor, or
+        anchor posision, it must issue this request to the compositor. This
+        request is intended to give the input method a chance to update the
+        preedit text in an appropriate way, e.g. by removing it when the user
+        starts typing with a keyboard.
+
+        cause describes the source of the change.
+
+        The value set with this request is double-buffered. It must be applied
+        and reset to initial at the next zwp_text_input_v3.commit request.
+
+        The initial value of cause is input_method.
+      </description>
+      <arg name="cause" type="uint" enum="change_cause"/>
+    </request>
+
+    <enum name="content_hint" bitfield="true">
+      <description summary="content hint">
+        Content hint is a bitmask to allow to modify the behavior of the text
+        input.
+      </description>
+      <entry name="none" value="0x0" summary="no special behavior"/>
+      <entry name="completion" value="0x1" summary="suggest word completions"/>
+      <entry name="spellcheck" value="0x2" summary="suggest word corrections"/>
+      <entry name="auto_capitalization" value="0x4" summary="switch to uppercase letters at the start of a sentence"/>
+      <entry name="lowercase" value="0x8" summary="prefer lowercase letters"/>
+      <entry name="uppercase" value="0x10" summary="prefer uppercase letters"/>
+      <entry name="titlecase" value="0x20" summary="prefer casing for titles and headings (can be language dependent)"/>
+      <entry name="hidden_text" value="0x40" summary="characters should be hidden"/>
+      <entry name="sensitive_data" value="0x80" summary="typed text should not be stored"/>
+      <entry name="latin" value="0x100" summary="just Latin characters should be entered"/>
+      <entry name="multiline" value="0x200" summary="the text input is multiline"/>
+    </enum>
+
+    <enum name="content_purpose">
+      <description summary="content purpose">
+        The content purpose allows to specify the primary purpose of a text
+        input.
+
+        This allows an input method to show special purpose input panels with
+        extra characters or to disallow some characters.
+      </description>
+      <entry name="normal" value="0" summary="default input, allowing all characters"/>
+      <entry name="alpha" value="1" summary="allow only alphabetic characters"/>
+      <entry name="digits" value="2" summary="allow only digits"/>
+      <entry name="number" value="3" summary="input a number (including decimal separator and sign)"/>
+      <entry name="phone" value="4" summary="input a phone number"/>
+      <entry name="url" value="5" summary="input an URL"/>
+      <entry name="email" value="6" summary="input an email address"/>
+      <entry name="name" value="7" summary="input a name of a person"/>
+      <entry name="password" value="8" summary="input a password (combine with sensitive_data hint)"/>
+      <entry name="pin" value="9" summary="input is a numeric password (combine with sensitive_data hint)"/>
+      <entry name="date" value="10" summary="input a date"/>
+      <entry name="time" value="11" summary="input a time"/>
+      <entry name="datetime" value="12" summary="input a date and time"/>
+      <entry name="terminal" value="13" summary="input for a terminal"/>
+    </enum>
+
+    <request name="set_content_type">
+      <description summary="set content purpose and hint">
+        Sets the content purpose and content hint. While the purpose is the
+        basic purpose of an input field, the hint flags allow to modify some of
+        the behavior.
+
+        Values set with this request are double-buffered. They will get applied
+        on the next zwp_text_input_v3.commit request.
+        Subsequent attempts to update them may have no effect. The values
+        remain valid until the next committed enable or disable request.
+
+        The initial value for hint is none, and the initial value for purpose
+        is normal.
+      </description>
+      <arg name="hint" type="uint" enum="content_hint"/>
+      <arg name="purpose" type="uint" enum="content_purpose"/>
+    </request>
+
+    <request name="set_cursor_rectangle">
+      <description summary="set cursor position">
+        Marks an area around the cursor as a x, y, width, height rectangle in
+        surface local coordinates.
+
+        Allows the compositor to put a window with word suggestions near the
+        cursor, without obstructing the text being input.
+
+        If the client is unaware of the position of edited text, it should not
+        issue this request, to signify lack of support to the compositor.
+
+        Values set with this request are double-buffered. They will get applied
+        on the next zwp_text_input_v3.commit request, and stay valid until the
+        next committed enable or disable request.
+
+        The initial values describing a cursor rectangle are empty. That means
+        the text input does not support describing the cursor area. If the
+        empty values get applied, subsequent attempts to change them may have
+        no effect.
+      </description>
+      <arg name="x" type="int"/>
+      <arg name="y" type="int"/>
+      <arg name="width" type="int"/>
+      <arg name="height" type="int"/>
+    </request>
+
+    <request name="commit">
+      <description summary="commit state">
+        Atomically applies state changes recently sent to the compositor.
+
+        The commit request establishes and updates the state of the client, and
+        must be issued after any changes to apply them.
+
+        Text input state (enabled status, content purpose, content hint,
+        surrounding text and change cause, cursor rectangle) is conceptually
+        double-buffered within the context of a text input, i.e. between a
+        committed enable request and the following committed enable or disable
+        request.
+
+        Protocol requests modify the pending state, as opposed to the current
+        state in use by the input method. A commit request atomically applies
+        all pending state, replacing the current state. After commit, the new
+        pending state is as documented for each related request.
+
+        Requests are applied in the order of arrival.
+
+        Neither current nor pending state are modified unless noted otherwise.
+
+        The compositor must count the number of commit requests coming from
+        each zwp_text_input_v3 object and use the count as the serial in done
+        events.
+      </description>
+    </request>
+
+    <event name="enter">
+      <description summary="enter event">
+        Notification that this seat's text-input focus is on a certain surface.
+
+        If client has created multiple text input objects, compositor must send
+        this event to all of them.
+
+        When the seat has the keyboard capability the text-input focus follows
+        the keyboard focus. This event sets the current surface for the
+        text-input object.
+      </description>
+      <arg name="surface" type="object" interface="wl_surface"/>
+    </event>
+
+    <event name="leave">
+      <description summary="leave event">
+        Notification that this seat's text-input focus is no longer on a
+        certain surface. The client should reset any preedit string previously
+        set.
+
+        The leave notification clears the current surface. It is sent before
+        the enter notification for the new focus. After leave event, compositor
+        must ignore requests from any text input instances until next enter
+        event.
+
+        When the seat has the keyboard capability the text-input focus follows
+        the keyboard focus.
+      </description>
+      <arg name="surface" type="object" interface="wl_surface"/>
+    </event>
+
+    <event name="preedit_string">
+      <description summary="pre-edit">
+        Notify when a new composing text (pre-edit) should be set at the
+        current cursor position. Any previously set composing text must be
+        removed. Any previously existing selected text must be removed.
+
+        The argument text contains the pre-edit string buffer.
+
+        The parameters cursor_begin and cursor_end are counted in bytes
+        relative to the beginning of the submitted text buffer. Cursor should
+        be hidden when both are equal to -1.
+
+        They could be represented by the client as a line if both values are
+        the same, or as a text highlight otherwise.
+
+        Values set with this event are double-buffered. They must be applied
+        and reset to initial on the next zwp_text_input_v3.done event.
+
+        The initial value of text is an empty string, and cursor_begin,
+        cursor_end and cursor_hidden are all 0.
+      </description>
+      <arg name="text" type="string" allow-null="true"/>
+      <arg name="cursor_begin" type="int"/>
+      <arg name="cursor_end" type="int"/>
+    </event>
+
+    <event name="commit_string">
+      <description summary="text commit">
+        Notify when text should be inserted into the editor widget. The text to
+        commit could be either just a single character after a key press or the
+        result of some composing (pre-edit).
+
+        Values set with this event are double-buffered. They must be applied
+        and reset to initial on the next zwp_text_input_v3.done event.
+
+        The initial value of text is an empty string.
+      </description>
+      <arg name="text" type="string" allow-null="true"/>
+    </event>
+
+    <event name="delete_surrounding_text">
+      <description summary="delete surrounding text">
+        Notify when the text around the current cursor position should be
+        deleted.
+
+        Before_length and after_length are the number of bytes before and after
+        the current cursor index (excluding the selection) to delete.
+
+        If a preedit text is present, in effect before_length is counted from
+        the beginning of it, and after_length from its end (see done event
+        sequence).
+
+        Values set with this event are double-buffered. They must be applied
+        and reset to initial on the next zwp_text_input_v3.done event.
+
+        The initial values of both before_length and after_length are 0.
+      </description>
+      <arg name="before_length" type="uint" summary="length of text before current cursor position"/>
+      <arg name="after_length" type="uint" summary="length of text after current cursor position"/>
+    </event>
+
+    <event name="done">
+      <description summary="apply changes">
+        Instruct the application to apply changes to state requested by the
+        preedit_string, commit_string and delete_surrounding_text events. The
+        state relating to these events is double-buffered, and each one
+        modifies the pending state. This event replaces the current state with
+        the pending state.
+
+        The application must proceed by evaluating the changes in the following
+        order:
+
+        1. Replace existing preedit string with the cursor.
+        2. Delete requested surrounding text.
+        3. Insert commit string with the cursor at its end.
+        4. Calculate surrounding text to send.
+        5. Insert new preedit text in cursor position.
+        6. Place cursor inside preedit text.
+
+        The serial number reflects the last state of the zwp_text_input_v3
+        object known to the compositor. The value of the serial argument must
+        be equal to the number of commit requests already issued on that object.
+        When the client receives a done event with a serial different than the
+        number of past commit requests, it must proceed as normal, except it
+        should not change the current state of the zwp_text_input_v3 object.
+      </description>
+      <arg name="serial" type="uint"/>
+    </event>
+  </interface>
+
+  <interface name="zwp_text_input_manager_v3" version="1">
+    <description summary="text input manager">
+      A factory for text-input objects. This object is a global singleton.
+    </description>
+
+    <request name="destroy" type="destructor">
+      <description summary="Destroy the wp_text_input_manager">
+        Destroy the wp_text_input_manager object.
+      </description>
+    </request>
+
+    <request name="get_text_input">
+      <description summary="create a new text input object">
+        Creates a new text-input object for a given seat.
+      </description>
+      <arg name="id" type="new_id" interface="zwp_text_input_v3"/>
+      <arg name="seat" type="object" interface="wl_seat"/>
+    </request>
+  </interface>
+</protocol>
diff --git a/Engine/lib/sdl/wayland-protocols/wayland.xml b/Engine/lib/sdl/wayland-protocols/wayland.xml
index 29b63be7d..471daf668 100644
--- a/Engine/lib/sdl/wayland-protocols/wayland.xml
+++ b/Engine/lib/sdl/wayland-protocols/wayland.xml
@@ -57,6 +57,12 @@
 	This request creates a registry object that allows the client
 	to list and bind the global objects available from the
 	compositor.
+
+	It should be noted that the server side resources consumed in
+	response to a get_registry request can only be released when the
+	client disconnects, not when the client side proxy is destroyed.
+	Therefore, clients should invoke get_registry as infrequently as
+	possible to avoid wasting memory.
       </description>
       <arg name="registry" type="new_id" interface="wl_registry"
 	   summary="global registry object"/>
@@ -85,18 +91,20 @@
       <entry name="invalid_object" value="0"
 	     summary="server couldn't find object"/>
       <entry name="invalid_method" value="1"
-	     summary="method doesn't exist on the specified interface"/>
+	     summary="method doesn't exist on the specified interface or malformed request"/>
       <entry name="no_memory" value="2"
 	     summary="server is out of memory"/>
+      <entry name="implementation" value="3"
+	     summary="implementation error in compositor"/>
     </enum>
 
     <event name="delete_id">
       <description summary="acknowledge object ID deletion">
 	This event is used internally by the object ID management
-	logic.  When a client deletes an object, the server will send
-	this event to acknowledge that it has seen the delete request.
-	When the client receives this event, it will know that it can
-	safely reuse the object ID.
+	logic. When a client deletes an object that it had created,
+	the server will send this event to acknowledge that it has
+	seen the delete request. When the client receives this event,
+	it will know that it can safely reuse the object ID.
       </description>
       <arg name="id" type="uint" summary="deleted object ID"/>
     </event>
@@ -285,10 +293,12 @@
 	formats are optional and may not be supported by the particular
 	renderer in use.
 
-	The drm format codes match the macros defined in drm_fourcc.h.
-	The formats actually supported by the compositor will be
-	reported by the format event.
+	The drm format codes match the macros defined in drm_fourcc.h, except
+	argb8888 and xrgb8888. The formats actually supported by the compositor
+	will be reported by the format event.
       </description>
+      <!-- Note to protocol writers: don't update this list manually, instead
+	   run the automated script that keeps it in sync with drm_fourcc.h. -->
       <entry name="argb8888" value="0" summary="32-bit ARGB format, [31:0] A:R:G:B 8:8:8:8 little endian"/>
       <entry name="xrgb8888" value="1" summary="32-bit RGB format, [31:0] x:R:G:B 8:8:8:8 little endian"/>
       <entry name="c8" value="0x20203843" summary="8-bit color index format, [7:0] C"/>
@@ -347,6 +357,52 @@
       <entry name="yvu422" value="0x36315659" summary="3 plane YCbCr format, 2x1 subsampled Cr (1) and Cb (2) planes"/>
       <entry name="yuv444" value="0x34325559" summary="3 plane YCbCr format, non-subsampled Cb (1) and Cr (2) planes"/>
       <entry name="yvu444" value="0x34325659" summary="3 plane YCbCr format, non-subsampled Cr (1) and Cb (2) planes"/>
+      <entry name="r8" value="0x20203852" summary="[7:0] R"/>
+      <entry name="r16" value="0x20363152" summary="[15:0] R little endian"/>
+      <entry name="rg88" value="0x38384752" summary="[15:0] R:G 8:8 little endian"/>
+      <entry name="gr88" value="0x38385247" summary="[15:0] G:R 8:8 little endian"/>
+      <entry name="rg1616" value="0x32334752" summary="[31:0] R:G 16:16 little endian"/>
+      <entry name="gr1616" value="0x32335247" summary="[31:0] G:R 16:16 little endian"/>
+      <entry name="xrgb16161616f" value="0x48345258" summary="[63:0] x:R:G:B 16:16:16:16 little endian"/>
+      <entry name="xbgr16161616f" value="0x48344258" summary="[63:0] x:B:G:R 16:16:16:16 little endian"/>
+      <entry name="argb16161616f" value="0x48345241" summary="[63:0] A:R:G:B 16:16:16:16 little endian"/>
+      <entry name="abgr16161616f" value="0x48344241" summary="[63:0] A:B:G:R 16:16:16:16 little endian"/>
+      <entry name="xyuv8888" value="0x56555958" summary="[31:0] X:Y:Cb:Cr 8:8:8:8 little endian"/>
+      <entry name="vuy888" value="0x34325556" summary="[23:0] Cr:Cb:Y 8:8:8 little endian"/>
+      <entry name="vuy101010" value="0x30335556" summary="Y followed by U then V, 10:10:10. Non-linear modifier only"/>
+      <entry name="y210" value="0x30313259" summary="[63:0] Cr0:0:Y1:0:Cb0:0:Y0:0 10:6:10:6:10:6:10:6 little endian per 2 Y pixels"/>
+      <entry name="y212" value="0x32313259" summary="[63:0] Cr0:0:Y1:0:Cb0:0:Y0:0 12:4:12:4:12:4:12:4 little endian per 2 Y pixels"/>
+      <entry name="y216" value="0x36313259" summary="[63:0] Cr0:Y1:Cb0:Y0 16:16:16:16 little endian per 2 Y pixels"/>
+      <entry name="y410" value="0x30313459" summary="[31:0] A:Cr:Y:Cb 2:10:10:10 little endian"/>
+      <entry name="y412" value="0x32313459" summary="[63:0] A:0:Cr:0:Y:0:Cb:0 12:4:12:4:12:4:12:4 little endian"/>
+      <entry name="y416" value="0x36313459" summary="[63:0] A:Cr:Y:Cb 16:16:16:16 little endian"/>
+      <entry name="xvyu2101010" value="0x30335658" summary="[31:0] X:Cr:Y:Cb 2:10:10:10 little endian"/>
+      <entry name="xvyu12_16161616" value="0x36335658" summary="[63:0] X:0:Cr:0:Y:0:Cb:0 12:4:12:4:12:4:12:4 little endian"/>
+      <entry name="xvyu16161616" value="0x38345658" summary="[63:0] X:Cr:Y:Cb 16:16:16:16 little endian"/>
+      <entry name="y0l0" value="0x304c3059" summary="[63:0]   A3:A2:Y3:0:Cr0:0:Y2:0:A1:A0:Y1:0:Cb0:0:Y0:0  1:1:8:2:8:2:8:2:1:1:8:2:8:2:8:2 little endian"/>
+      <entry name="x0l0" value="0x304c3058" summary="[63:0]   X3:X2:Y3:0:Cr0:0:Y2:0:X1:X0:Y1:0:Cb0:0:Y0:0  1:1:8:2:8:2:8:2:1:1:8:2:8:2:8:2 little endian"/>
+      <entry name="y0l2" value="0x324c3059" summary="[63:0]   A3:A2:Y3:Cr0:Y2:A1:A0:Y1:Cb0:Y0  1:1:10:10:10:1:1:10:10:10 little endian"/>
+      <entry name="x0l2" value="0x324c3058" summary="[63:0]   X3:X2:Y3:Cr0:Y2:X1:X0:Y1:Cb0:Y0  1:1:10:10:10:1:1:10:10:10 little endian"/>
+      <entry name="yuv420_8bit" value="0x38305559"/>
+      <entry name="yuv420_10bit" value="0x30315559"/>
+      <entry name="xrgb8888_a8" value="0x38415258"/>
+      <entry name="xbgr8888_a8" value="0x38414258"/>
+      <entry name="rgbx8888_a8" value="0x38415852"/>
+      <entry name="bgrx8888_a8" value="0x38415842"/>
+      <entry name="rgb888_a8" value="0x38413852"/>
+      <entry name="bgr888_a8" value="0x38413842"/>
+      <entry name="rgb565_a8" value="0x38413552"/>
+      <entry name="bgr565_a8" value="0x38413542"/>
+      <entry name="nv24" value="0x3432564e" summary="non-subsampled Cr:Cb plane"/>
+      <entry name="nv42" value="0x3234564e" summary="non-subsampled Cb:Cr plane"/>
+      <entry name="p210" value="0x30313250" summary="2x1 subsampled Cr:Cb plane, 10 bit per channel"/>
+      <entry name="p010" value="0x30313050" summary="2x2 subsampled Cr:Cb plane 10 bits per channel"/>
+      <entry name="p012" value="0x32313050" summary="2x2 subsampled Cr:Cb plane 12 bits per channel"/>
+      <entry name="p016" value="0x36313050" summary="2x2 subsampled Cr:Cb plane 16 bits per channel"/>
+      <entry name="axbxgxrx106106106106" value="0x30314241" summary="[63:0] A:x:B:x:G:x:R:x 10:6:10:6:10:6:10:6 little endian"/>
+      <entry name="nv15" value="0x3531564e" summary="2x2 subsampled Cr:Cb plane"/>
+      <entry name="q410" value="0x30313451"/>
+      <entry name="q401" value="0x31303451"/>
     </enum>
 
     <request name="create_pool">
@@ -501,6 +557,9 @@
 	this request after a NULL mime type has been set in
 	wl_data_offer.accept or no action was received through
 	wl_data_offer.action.
+
+	If wl_data_offer.finish request is received for a non drag and drop
+	operation, the invalid_finish protocol error is raised.
       </description>
     </request>
 
@@ -517,7 +576,7 @@
 
 	This request determines the final result of the drag-and-drop
 	operation. If the end result is that no action is accepted,
-	the drag source will receive wl_drag_source.cancelled.
+	the drag source will receive wl_data_source.cancelled.
 
 	The dnd_actions argument must contain only values expressed in the
 	wl_data_device_manager.dnd_actions enum, and the preferred_action
@@ -538,8 +597,10 @@
 	This request can only be made on drag-and-drop offers, a protocol error
 	will be raised otherwise.
       </description>
-      <arg name="dnd_actions" type="uint" summary="actions supported by the destination client"/>
-      <arg name="preferred_action" type="uint" summary="action preferred by the destination client"/>
+      <arg name="dnd_actions" type="uint" summary="actions supported by the destination client"
+	   enum="wl_data_device_manager.dnd_action"/>
+      <arg name="preferred_action" type="uint" summary="action preferred by the destination client"
+	   enum="wl_data_device_manager.dnd_action"/>
     </request>
 
     <event name="source_actions" since="3">
@@ -548,7 +609,8 @@
 	will be sent right after wl_data_device.enter, or anytime the source
 	side changes its offered actions through wl_data_source.set_actions.
       </description>
-      <arg name="source_actions" type="uint" summary="actions offered by the data source"/>
+      <arg name="source_actions" type="uint" summary="actions offered by the data source"
+	   enum="wl_data_device_manager.dnd_action"/>
     </event>
 
     <event name="action" since="3">
@@ -589,7 +651,8 @@
 	final wl_data_offer.set_actions and wl_data_offer.accept requests
 	must happen before the call to wl_data_offer.finish.
       </description>
-      <arg name="dnd_action" type="uint" summary="action selected by the compositor"/>
+      <arg name="dnd_action" type="uint" summary="action selected by the compositor"
+	   enum="wl_data_device_manager.dnd_action"/>
     </event>
   </interface>
 
@@ -686,7 +749,8 @@
 	wl_data_device.start_drag. Attempting to use the source other than
 	for drag-and-drop will raise a protocol error.
       </description>
-      <arg name="dnd_actions" type="uint" summary="actions supported by the data source"/>
+      <arg name="dnd_actions" type="uint" summary="actions supported by the data source"
+	   enum="wl_data_device_manager.dnd_action"/>
     </request>
 
     <event name="dnd_drop_performed" since="3">
@@ -742,7 +806,8 @@
 	Clients can trigger cursor surface changes from this point, so
 	they reflect the current action.
       </description>
-      <arg name="dnd_action" type="uint" summary="action selected by the compositor"/>
+      <arg name="dnd_action" type="uint" summary="action selected by the compositor"
+	   enum="wl_data_device_manager.dnd_action"/>
     </event>
   </interface>
 
@@ -768,7 +833,8 @@
 	for the eventual data transfer. If source is NULL, enter, leave
 	and motion events are sent only to the client that initiated the
 	drag and the client is expected to handle the data passing
-	internally.
+	internally. If source is destroyed, the drag-and-drop session will be
+	cancelled.
 
 	The origin surface is the surface where the drag originates and
 	the client must have an active implicit grab that matches the
@@ -970,6 +1036,9 @@
 
       It allows clients to associate a wl_shell_surface with
       a basic surface.
+
+      Note! This protocol is deprecated and not intended for production use.
+      For desktop-style user interfaces, use xdg_shell.
     </description>
 
     <enum name="error">
@@ -1265,8 +1334,10 @@
 
   <interface name="wl_surface" version="4">
     <description summary="an onscreen surface">
-      A surface is a rectangular area that is displayed on the screen.
-      It has a location, size and pixel contents.
+      A surface is a rectangular area that may be displayed on zero
+      or more outputs, and shown any number of times at the compositor's
+      discretion. They can present wl_buffers, receive user input, and
+      define a local coordinate system.
 
       The size of a surface (and relative positions on it) is described
       in surface-local coordinates, which may differ from the buffer
@@ -1312,6 +1383,7 @@
       </description>
       <entry name="invalid_scale" value="0" summary="buffer scale value is invalid"/>
       <entry name="invalid_transform" value="1" summary="buffer transform value is invalid"/>
+      <entry name="invalid_size" value="2" summary="buffer size is invalid"/>
     </enum>
 
     <request name="destroy" type="destructor">
@@ -1326,8 +1398,9 @@
 
 	The new size of the surface is calculated based on the buffer
 	size transformed by the inverse buffer_transform and the
-	inverse buffer_scale. This means that the supplied buffer
-	must be an integer multiple of the buffer_scale.
+	inverse buffer_scale. This means that at commit time the supplied
+	buffer size must be an integer multiple of the buffer_scale. If
+	that's not the case, an invalid_size error is sent.
 
 	The x and y arguments specify the location of the new pending
 	buffer's upper left corner, relative to the current buffer's upper
@@ -1354,6 +1427,12 @@
 	will not receive a release event, and is not used by the
 	compositor.
 
+	If a pending wl_buffer has been committed to more than one wl_surface,
+	the delivery of wl_buffer.release events becomes undefined. A well
+	behaved client should not rely on wl_buffer.release events in this
+	case. Alternatively, a client could create multiple wl_buffer objects
+	from the same backing storage or use wp_linux_buffer_release.
+
 	Destroying the wl_buffer after wl_buffer.release does not change
 	the surface contents. However, if the client destroys the
 	wl_buffer before receiving the wl_buffer.release event, the surface
@@ -1388,9 +1467,9 @@
 	and clears pending damage. The server will clear the current
 	damage as it repaints the surface.
 
-	Alternatively, damage can be posted with wl_surface.damage_buffer
-	which uses buffer coordinates instead of surface coordinates,
-	and is probably the preferred and intuitive way of doing this.
+	Note! New clients should not use this request. Instead damage can be
+	posted with wl_surface.damage_buffer which uses buffer coordinates
+	instead of surface coordinates.
       </description>
       <arg name="x" type="int" summary="surface-local x coordinate"/>
       <arg name="y" type="int" summary="surface-local y coordinate"/>
@@ -1534,6 +1613,12 @@
 	This is emitted whenever a surface's creation, movement, or resizing
 	results in it no longer having any part of it within the scanout region
 	of an output.
+
+	Clients should not use the number of outputs the surface is on for frame
+	throttling purposes. The surface might be hidden even if no leave event
+	has been sent, and the compositor might expect new surface content
+	updates even if no enter event has been sent. The frame event should be
+	used instead.
       </description>
       <arg name="output" type="object" interface="wl_output" summary="output left by the surface"/>
     </event>
@@ -1651,7 +1736,7 @@
     </request>
    </interface>
 
-  <interface name="wl_seat" version="6">
+  <interface name="wl_seat" version="7">
     <description summary="group of input devices">
       A seat is a group of keyboards, pointer and touch devices. This
       object is published as a global during start up, or when such a
@@ -1669,6 +1754,14 @@
       <entry name="touch" value="4" summary="the seat has touch devices"/>
     </enum>
 
+    <enum name="error">
+      <description summary="wl_seat error values">
+	These errors can be emitted in response to wl_seat requests.
+      </description>
+      <entry name="missing_capability" value="0"
+	     summary="get_pointer, get_keyboard or get_touch called on seat without the matching capability"/>
+    </enum>
+
     <event name="capabilities">
       <description summary="seat capabilities changed">
 	This is emitted whenever a seat gains or loses the pointer,
@@ -1707,7 +1800,8 @@
 	This request only takes effect if the seat has the pointer
 	capability, or has had the pointer capability in the past.
 	It is a protocol violation to issue this request on a seat that has
-	never had the pointer capability.
+	never had the pointer capability. The missing_capability error will
+	be sent in this case.
       </description>
       <arg name="id" type="new_id" interface="wl_pointer" summary="seat pointer"/>
     </request>
@@ -1720,7 +1814,8 @@
 	This request only takes effect if the seat has the keyboard
 	capability, or has had the keyboard capability in the past.
 	It is a protocol violation to issue this request on a seat that has
-	never had the keyboard capability.
+	never had the keyboard capability. The missing_capability error will
+	be sent in this case.
       </description>
       <arg name="id" type="new_id" interface="wl_keyboard" summary="seat keyboard"/>
     </request>
@@ -1733,7 +1828,8 @@
 	This request only takes effect if the seat has the touch
 	capability, or has had the touch capability in the past.
 	It is a protocol violation to issue this request on a seat that has
-	never had the touch capability.
+	never had the touch capability. The missing_capability error will
+	be sent in this case.
       </description>
       <arg name="id" type="new_id" interface="wl_touch" summary="seat touch interface"/>
     </request>
@@ -1760,7 +1856,7 @@
 
   </interface>
 
-  <interface name="wl_pointer" version="6">
+  <interface name="wl_pointer" version="7">
     <description summary="pointer input device">
       The wl_pointer interface represents one or more input devices,
       such as mice, which control the pointer location and pointer_focus
@@ -2083,7 +2179,7 @@
     </event>
   </interface>
 
-  <interface name="wl_keyboard" version="6">
+  <interface name="wl_keyboard" version="7">
     <description summary="keyboard input device">
       The wl_keyboard interface represents one or more keyboards
       associated with a seat.
@@ -2104,6 +2200,9 @@
       <description summary="keyboard mapping">
 	This event provides a file descriptor to the client which can be
 	memory-mapped to provide a keyboard mapping description.
+
+	From version 7 onwards, the fd must be mapped with MAP_PRIVATE by
+	the recipient, as MAP_SHARED may fail.
       </description>
       <arg name="format" type="uint" enum="keymap_format" summary="keymap format"/>
       <arg name="fd" type="fd" summary="keymap file descriptor"/>
@@ -2114,6 +2213,9 @@
       <description summary="enter event">
 	Notification that this seat's keyboard focus is on a certain
 	surface.
+
+	The compositor must send the wl_keyboard.modifiers event after this
+	event.
       </description>
       <arg name="serial" type="uint" summary="serial number of the enter event"/>
       <arg name="surface" type="object" interface="wl_surface" summary="surface gaining keyboard focus"/>
@@ -2127,6 +2229,9 @@
 
 	The leave notification is sent before the enter notification
 	for the new focus.
+
+	After this event client must assume that all keys, including modifiers,
+	are lifted and also it must stop key repeating if there's some going on.
       </description>
       <arg name="serial" type="uint" summary="serial number of the leave event"/>
       <arg name="surface" type="object" interface="wl_surface" summary="surface that lost keyboard focus"/>
@@ -2145,6 +2250,12 @@
 	A key was pressed or released.
 	The time argument is a timestamp with millisecond
 	granularity, with an undefined base.
+
+	The key is a platform-specific key code that can be interpreted
+	by feeding it to the keyboard mapping (see the keymap event).
+
+	If this event produces a change in modifiers, then the resulting
+	wl_keyboard.modifiers event must be sent after this event.
       </description>
       <arg name="serial" type="uint" summary="serial number of the key event"/>
       <arg name="time" type="uint" summary="timestamp with millisecond granularity"/>
@@ -2194,7 +2305,7 @@
     </event>
   </interface>
 
-  <interface name="wl_touch" version="6">
+  <interface name="wl_touch" version="7">
     <description summary="touchscreen input device">
       The wl_touch interface represents a touchscreen
       associated with a seat.
@@ -2390,6 +2501,16 @@
 	The geometry event describes geometric properties of the output.
 	The event is sent when binding to the output object and whenever
 	any of the properties change.
+
+	The physical size can be set to zero if it doesn't make sense for this
+	output (e.g. for projectors or virtual outputs).
+
+	Note: wl_output only advertises partial information about the output
+	position and identification. Some compositors, for instance those not
+	implementing a desktop-style output layout or those exposing virtual
+	outputs, might fake this information. Instead of using x and y, clients
+	should use xdg_output.logical_position. Instead of using make and model,
+	clients should use xdg_output.name and xdg_output.description.
       </description>
       <arg name="x" type="int"
 	   summary="x position within the global compositor space"/>
@@ -2430,11 +2551,28 @@
 	current.  In other words, the current mode is always the last
 	mode that was received with the current flag set.
 
+	Non-current modes are deprecated. A compositor can decide to only
+	advertise the current mode and never send other modes. Clients
+	should not rely on non-current modes.
+
 	The size of a mode is given in physical hardware units of
 	the output device. This is not necessarily the same as
 	the output size in the global compositor space. For instance,
 	the output may be scaled, as described in wl_output.scale,
-	or transformed, as described in wl_output.transform.
+	or transformed, as described in wl_output.transform. Clients
+	willing to retrieve the output size in the global compositor
+	space should use xdg_output.logical_size instead.
+
+	The vertical refresh rate can be set to zero if it doesn't make
+	sense for this output (e.g. for virtual outputs).
+
+	Clients should not use the refresh rate to schedule frames. Instead,
+	they should use the wl_surface.frame event or the presentation-time
+	protocol.
+
+	Note: this information is not always meaningful for all outputs. Some
+	compositors, such as those exposing virtual outputs, might fake the
+	refresh rate or the size.
       </description>
       <arg name="flags" type="uint" enum="mode" summary="bitfield of mode flags"/>
       <arg name="width" type="int" summary="width of the mode in hardware units"/>
@@ -2568,6 +2706,14 @@
 	The to-be sub-surface must not already have another role, and it
 	must not have an existing wl_subsurface object. Otherwise a protocol
 	error is raised.
+
+	Adding sub-surfaces to a parent is a double-buffered operation on the
+	parent (see wl_surface.commit). The effect of adding a sub-surface
+	becomes visible on the next time the state of the parent surface is
+	applied.
+
+	This request modifies the behaviour of wl_surface.commit request on
+	the sub-surface, see the documentation on wl_subsurface interface.
       </description>
       <arg name="id" type="new_id" interface="wl_subsurface"
 	   summary="the new sub-surface object ID"/>
@@ -2601,7 +2747,7 @@
       wl_surface state directly. A sub-surface is initially in the
       synchronized mode.
 
-      Sub-surfaces have also other kind of state, which is managed by
+      Sub-surfaces also have another kind of state, which is managed by
       wl_subsurface requests, as opposed to wl_surface requests. This
       state includes the sub-surface position relative to the parent
       surface (wl_subsurface.set_position), and the stacking order of
@@ -2637,7 +2783,7 @@
 	that was turned into a sub-surface with a
 	wl_subcompositor.get_subsurface request. The wl_surface's association
 	to the parent is deleted, and the wl_surface loses its role as
-	a sub-surface. The wl_surface is unmapped.
+	a sub-surface. The wl_surface is unmapped immediately.
       </description>
     </request>
 
diff --git a/Engine/lib/sdl/wayland-protocols/xdg-activation-v1.xml b/Engine/lib/sdl/wayland-protocols/xdg-activation-v1.xml
new file mode 100644
index 000000000..d87e63374
--- /dev/null
+++ b/Engine/lib/sdl/wayland-protocols/xdg-activation-v1.xml
@@ -0,0 +1,186 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="xdg_activation_v1">
+
+  <copyright>
+    Copyright © 2020 Aleix Pol Gonzalez &lt;aleixpol@kde.org&gt;
+    Copyright © 2020 Carlos Garnacho &lt;carlosg@gnome.org&gt;
+
+    Permission is hereby granted, free of charge, to any person obtaining a
+    copy of this software and associated documentation files (the "Software"),
+    to deal in the Software without restriction, including without limitation
+    the rights to use, copy, modify, merge, publish, distribute, sublicense,
+    and/or sell copies of the Software, and to permit persons to whom the
+    Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice (including the next
+    paragraph) shall be included in all copies or substantial portions of the
+    Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+    DEALINGS IN THE SOFTWARE.
+  </copyright>
+
+  <description summary="Protocol for requesting activation of surfaces">
+    The way for a client to pass focus to another toplevel is as follows.
+
+    The client that intends to activate another toplevel uses the
+    xdg_activation_v1.get_activation_token request to get an activation token.
+    This token is then passed to the client to be activated through a separate
+    band of communication. The client to be activated will then pass the token
+    it received to the xdg_activation_v1.activate request. The compositor can
+    then use this token to decide how to react to the activation request.
+
+    The token the activating client gets may be ineffective either already at
+    the time it receives it, for example if it was not focused, for focus
+    stealing prevention. The activating client will have no way to discover
+    the validity of the token, and may still forward it to the to be activated
+    client.
+
+    The created activation token may optionally get information attached to it
+    that can be used by the compositor to identify the application that we
+    intend to activate. This can for example be used to display a visual hint
+    about what application is being started.
+
+    Warning! The protocol described in this file is currently in the testing
+    phase. Backward compatible changes may be added together with the
+    corresponding interface version bump. Backward incompatible changes can
+    only be done by creating a new major version of the extension.
+  </description>
+
+  <interface name="xdg_activation_v1" version="1">
+    <description summary="interface for activating surfaces">
+      A global interface used for informing the compositor about applications
+      being activated or started, or for applications to request to be
+      activated.
+    </description>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the xdg_activation object">
+        Notify the compositor that the xdg_activation object will no longer be
+        used.
+
+        The child objects created via this interface are unaffected and should
+        be destroyed separately.
+      </description>
+    </request>
+
+    <request name="get_activation_token">
+      <description summary="requests a token">
+        Creates an xdg_activation_token_v1 object that will provide
+        the initiating client with a unique token for this activation. This
+        token should be offered to the clients to be activated.
+      </description>
+
+      <arg name="id" type="new_id" interface="xdg_activation_token_v1"/>
+    </request>
+
+    <request name="activate">
+      <description summary="notify new interaction being available">
+        Requests surface activation. It's up to the compositor to display
+        this information as desired, for example by placing the surface above
+        the rest.
+
+        The compositor may know who requested this by checking the activation
+        token and might decide not to follow through with the activation if it's
+        considered unwanted.
+
+        Compositors can ignore unknown presentation tokens when an invalid
+        token is passed.
+      </description>
+      <arg name="token" type="string" summary="the activation token of the initiating client"/>
+      <arg name="surface" type="object" interface="wl_surface"
+	   summary="the wl_surface to activate"/>
+    </request>
+  </interface>
+
+  <interface name="xdg_activation_token_v1" version="1">
+    <description summary="an exported activation handle">
+      An object for setting up a token and receiving a token handle that can
+      be passed as an activation token to another client.
+
+      The object is created using the xdg_activation_v1.get_activation_token
+      request. This object should then be populated with the app_id, surface
+      and serial information and committed. The compositor shall then issue a
+      done event with the token. In case the request's parameters are invalid,
+      the compositor will provide an invalid token.
+    </description>
+
+    <enum name="error">
+      <entry name="already_used" value="0"
+             summary="The token has already been used previously"/>
+    </enum>
+
+    <request name="set_serial">
+      <description summary="specifies the seat and serial of the activating event">
+        Provides information about the seat and serial event that requested the
+        token.
+
+        Must be sent before commit. This information is optional.
+      </description>
+      <arg name="serial" type="uint"
+           summary="the serial of the event that triggered the activation"/>
+      <arg name="seat" type="object" interface="wl_seat"
+           summary="the wl_seat of the event"/>
+    </request>
+
+    <request name="set_app_id">
+      <description summary="specifies the application being activated">
+        The requesting client can specify an app_id to associate the token
+        being created with it.
+
+        Must be sent before commit. This information is optional.
+      </description>
+      <arg name="app_id" type="string"
+           summary="the application id of the client being activated."/>
+    </request>
+
+    <request name="set_surface">
+      <description summary="specifies the application being activated">
+        The requesting client can specify a surface to associate the token
+        being created with it.
+
+        Must be triggered before commit. This information is optional.
+      </description>
+      <arg name="surface" type="object" interface="wl_surface"
+	   summary="the requesting surface"/>
+    </request>
+
+    <request name="commit">
+      <description summary="issues the token request">
+        Requests an activation token based on the different parameters that
+        have been offered through set_serial, set_surface and set_app_id.
+      </description>
+    </request>
+
+    <event name="done">
+      <description summary="the exported activation token">
+        The 'done' event contains the unique token of this activation request
+        and notifies that the provider is done.
+
+        Applications will typically receive the token through the
+        XDG_ACTIVATION_TOKEN environment variable as set by its launcher, and
+        should unset the environment variable right after this request, in
+        order to avoid propagating it to child processes.
+
+        Applications implementing the D-Bus interface org.freedesktop.Application
+        should get their token under XDG_ACTIVATION_TOKEN on their platform_data.
+
+        Presentation tokens may be transferred across clients through means not
+        described in this protocol.
+      </description>
+      <arg name="token" type="string" summary="the exported activation token"/>
+    </event>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the xdg_activation_token_v1 object">
+        Notify the compositor that the xdg_activation_token_v1 object will no
+        longer be used.
+      </description>
+    </request>
+  </interface>
+</protocol>
diff --git a/Engine/lib/sdl/wayland-protocols/xdg-shell-unstable-v6.xml b/Engine/lib/sdl/wayland-protocols/xdg-shell-unstable-v6.xml
deleted file mode 100644
index 1c0f92452..000000000
--- a/Engine/lib/sdl/wayland-protocols/xdg-shell-unstable-v6.xml
+++ /dev/null
@@ -1,1044 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<protocol name="xdg_shell_unstable_v6">
-
-  <copyright>
-    Copyright © 2008-2013 Kristian Høgsberg
-    Copyright © 2013      Rafael Antognolli
-    Copyright © 2013      Jasper St. Pierre
-    Copyright © 2010-2013 Intel Corporation
-
-    Permission is hereby granted, free of charge, to any person obtaining a
-    copy of this software and associated documentation files (the "Software"),
-    to deal in the Software without restriction, including without limitation
-    the rights to use, copy, modify, merge, publish, distribute, sublicense,
-    and/or sell copies of the Software, and to permit persons to whom the
-    Software is furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice (including the next
-    paragraph) shall be included in all copies or substantial portions of the
-    Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
-    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-    DEALINGS IN THE SOFTWARE.
-  </copyright>
-
-  <interface name="zxdg_shell_v6" version="1">
-    <description summary="create desktop-style surfaces">
-      xdg_shell allows clients to turn a wl_surface into a "real window"
-      which can be dragged, resized, stacked, and moved around by the
-      user. Everything about this interface is suited towards traditional
-      desktop environments.
-    </description>
-
-    <enum name="error">
-      <entry name="role" value="0" summary="given wl_surface has another role"/>
-      <entry name="defunct_surfaces" value="1"
-	     summary="xdg_shell was destroyed before children"/>
-      <entry name="not_the_topmost_popup" value="2"
-	     summary="the client tried to map or destroy a non-topmost popup"/>
-      <entry name="invalid_popup_parent" value="3"
-	     summary="the client specified an invalid popup parent surface"/>
-      <entry name="invalid_surface_state" value="4"
-	     summary="the client provided an invalid surface state"/>
-      <entry name="invalid_positioner" value="5"
-	     summary="the client provided an invalid positioner"/>
-    </enum>
-
-    <request name="destroy" type="destructor">
-      <description summary="destroy xdg_shell">
-	Destroy this xdg_shell object.
-
-	Destroying a bound xdg_shell object while there are surfaces
-	still alive created by this xdg_shell object instance is illegal
-	and will result in a protocol error.
-      </description>
-    </request>
-
-    <request name="create_positioner">
-      <description summary="create a positioner object">
-	Create a positioner object. A positioner object is used to position
-	surfaces relative to some parent surface. See the interface description
-	and xdg_surface.get_popup for details.
-      </description>
-      <arg name="id" type="new_id" interface="zxdg_positioner_v6"/>
-    </request>
-
-    <request name="get_xdg_surface">
-      <description summary="create a shell surface from a surface">
-	This creates an xdg_surface for the given surface. While xdg_surface
-	itself is not a role, the corresponding surface may only be assigned
-	a role extending xdg_surface, such as xdg_toplevel or xdg_popup.
-
-	This creates an xdg_surface for the given surface. An xdg_surface is
-	used as basis to define a role to a given surface, such as xdg_toplevel
-	or xdg_popup. It also manages functionality shared between xdg_surface
-	based surface roles.
-
-	See the documentation of xdg_surface for more details about what an
-	xdg_surface is and how it is used.
-      </description>
-      <arg name="id" type="new_id" interface="zxdg_surface_v6"/>
-      <arg name="surface" type="object" interface="wl_surface"/>
-    </request>
-
-    <request name="pong">
-      <description summary="respond to a ping event">
-	A client must respond to a ping event with a pong request or
-	the client may be deemed unresponsive. See xdg_shell.ping.
-      </description>
-      <arg name="serial" type="uint" summary="serial of the ping event"/>
-    </request>
-
-    <event name="ping">
-      <description summary="check if the client is alive">
-	The ping event asks the client if it's still alive. Pass the
-	serial specified in the event back to the compositor by sending
-	a "pong" request back with the specified serial. See xdg_shell.ping.
-
-	Compositors can use this to determine if the client is still
-	alive. It's unspecified what will happen if the client doesn't
-	respond to the ping request, or in what timeframe. Clients should
-	try to respond in a reasonable amount of time.
-
-	A compositor is free to ping in any way it wants, but a client must
-	always respond to any xdg_shell object it created.
-      </description>
-      <arg name="serial" type="uint" summary="pass this to the pong request"/>
-    </event>
-  </interface>
-
-  <interface name="zxdg_positioner_v6" version="1">
-    <description summary="child surface positioner">
-      The xdg_positioner provides a collection of rules for the placement of a
-      child surface relative to a parent surface. Rules can be defined to ensure
-      the child surface remains within the visible area's borders, and to
-      specify how the child surface changes its position, such as sliding along
-      an axis, or flipping around a rectangle. These positioner-created rules are
-      constrained by the requirement that a child surface must intersect with or
-      be at least partially adjacent to its parent surface.
-
-      See the various requests for details about possible rules.
-
-      At the time of the request, the compositor makes a copy of the rules
-      specified by the xdg_positioner. Thus, after the request is complete the
-      xdg_positioner object can be destroyed or reused; further changes to the
-      object will have no effect on previous usages.
-
-      For an xdg_positioner object to be considered complete, it must have a
-      non-zero size set by set_size, and a non-zero anchor rectangle set by
-      set_anchor_rect. Passing an incomplete xdg_positioner object when
-      positioning a surface raises an error.
-    </description>
-
-    <enum name="error">
-      <entry name="invalid_input" value="0" summary="invalid input provided"/>
-    </enum>
-
-    <request name="destroy" type="destructor">
-      <description summary="destroy the xdg_positioner object">
-	Notify the compositor that the xdg_positioner will no longer be used.
-      </description>
-    </request>
-
-    <request name="set_size">
-      <description summary="set the size of the to-be positioned rectangle">
-	Set the size of the surface that is to be positioned with the positioner
-	object. The size is in surface-local coordinates and corresponds to the
-	window geometry. See xdg_surface.set_window_geometry.
-
-	If a zero or negative size is set the invalid_input error is raised.
-      </description>
-      <arg name="width" type="int" summary="width of positioned rectangle"/>
-      <arg name="height" type="int" summary="height of positioned rectangle"/>
-    </request>
-
-    <request name="set_anchor_rect">
-      <description summary="set the anchor rectangle within the parent surface">
-	Specify the anchor rectangle within the parent surface that the child
-	surface will be placed relative to. The rectangle is relative to the
-	window geometry as defined by xdg_surface.set_window_geometry of the
-	parent surface. The rectangle must be at least 1x1 large.
-
-	When the xdg_positioner object is used to position a child surface, the
-	anchor rectangle may not extend outside the window geometry of the
-	positioned child's parent surface.
-
-	If a zero or negative size is set the invalid_input error is raised.
-      </description>
-      <arg name="x" type="int" summary="x position of anchor rectangle"/>
-      <arg name="y" type="int" summary="y position of anchor rectangle"/>
-      <arg name="width" type="int" summary="width of anchor rectangle"/>
-      <arg name="height" type="int" summary="height of anchor rectangle"/>
-    </request>
-
-    <enum name="anchor" bitfield="true">
-      <entry name="none" value="0"
-	     summary="the center of the anchor rectangle"/>
-      <entry name="top" value="1"
-	     summary="the top edge of the anchor rectangle"/>
-      <entry name="bottom" value="2"
-	     summary="the bottom edge of the anchor rectangle"/>
-      <entry name="left" value="4"
-	     summary="the left edge of the anchor rectangle"/>
-      <entry name="right" value="8"
-	     summary="the right edge of the anchor rectangle"/>
-    </enum>
-
-    <request name="set_anchor">
-      <description summary="set anchor rectangle anchor edges">
-	Defines a set of edges for the anchor rectangle. These are used to
-	derive an anchor point that the child surface will be positioned
-	relative to. If two orthogonal edges are specified (e.g. 'top' and
-	'left'), then the anchor point will be the intersection of the edges
-	(e.g. the top left position of the rectangle); otherwise, the derived
-	anchor point will be centered on the specified edge, or in the center of
-	the anchor rectangle if no edge is specified.
-
-	If two parallel anchor edges are specified (e.g. 'left' and 'right'),
-	the invalid_input error is raised.
-      </description>
-      <arg name="anchor" type="uint" enum="anchor"
-	   summary="bit mask of anchor edges"/>
-    </request>
-
-    <enum name="gravity" bitfield="true">
-      <entry name="none" value="0"
-	     summary="center over the anchor edge"/>
-      <entry name="top" value="1"
-	     summary="position above the anchor edge"/>
-      <entry name="bottom" value="2"
-	     summary="position below the anchor edge"/>
-      <entry name="left" value="4"
-	     summary="position to the left of the anchor edge"/>
-      <entry name="right" value="8"
-	     summary="position to the right of the anchor edge"/>
-    </enum>
-
-    <request name="set_gravity">
-      <description summary="set child surface gravity">
-	Defines in what direction a surface should be positioned, relative to
-	the anchor point of the parent surface. If two orthogonal gravities are
-	specified (e.g. 'bottom' and 'right'), then the child surface will be
-	placed in the specified direction; otherwise, the child surface will be
-	centered over the anchor point on any axis that had no gravity
-	specified.
-
-	If two parallel gravities are specified (e.g. 'left' and 'right'), the
-	invalid_input error is raised.
-      </description>
-      <arg name="gravity" type="uint" enum="gravity"
-	   summary="bit mask of gravity directions"/>
-    </request>
-
-    <enum name="constraint_adjustment" bitfield="true">
-      <description summary="constraint adjustments">
-	The constraint adjustment value define ways the compositor will adjust
-	the position of the surface, if the unadjusted position would result
-	in the surface being partly constrained.
-
-	Whether a surface is considered 'constrained' is left to the compositor
-	to determine. For example, the surface may be partly outside the
-	compositor's defined 'work area', thus necessitating the child surface's
-	position be adjusted until it is entirely inside the work area.
-
-	The adjustments can be combined, according to a defined precedence: 1)
-	Flip, 2) Slide, 3) Resize.
-      </description>
-      <entry name="none" value="0">
-	<description summary="don't move the child surface when constrained">
-	  Don't alter the surface position even if it is constrained on some
-	  axis, for example partially outside the edge of a monitor.
-	</description>
-      </entry>
-      <entry name="slide_x" value="1">
-	<description summary="move along the x axis until unconstrained">
-	  Slide the surface along the x axis until it is no longer constrained.
-
-	  First try to slide towards the direction of the gravity on the x axis
-	  until either the edge in the opposite direction of the gravity is
-	  unconstrained or the edge in the direction of the gravity is
-	  constrained.
-
-	  Then try to slide towards the opposite direction of the gravity on the
-	  x axis until either the edge in the direction of the gravity is
-	  unconstrained or the edge in the opposite direction of the gravity is
-	  constrained.
-	</description>
-      </entry>
-      <entry name="slide_y" value="2">
-	<description summary="move along the y axis until unconstrained">
-	  Slide the surface along the y axis until it is no longer constrained.
-
-	  First try to slide towards the direction of the gravity on the y axis
-	  until either the edge in the opposite direction of the gravity is
-	  unconstrained or the edge in the direction of the gravity is
-	  constrained.
-
-	  Then try to slide towards the opposite direction of the gravity on the
-	  y axis until either the edge in the direction of the gravity is
-	  unconstrained or the edge in the opposite direction of the gravity is
-	  constrained.
-	</description>
-      </entry>
-      <entry name="flip_x" value="4">
-	<description summary="invert the anchor and gravity on the x axis">
-	  Invert the anchor and gravity on the x axis if the surface is
-	  constrained on the x axis. For example, if the left edge of the
-	  surface is constrained, the gravity is 'left' and the anchor is
-	  'left', change the gravity to 'right' and the anchor to 'right'.
-
-	  If the adjusted position also ends up being constrained, the resulting
-	  position of the flip_x adjustment will be the one before the
-	  adjustment.
-	</description>
-      </entry>
-      <entry name="flip_y" value="8">
-	<description summary="invert the anchor and gravity on the y axis">
-	  Invert the anchor and gravity on the y axis if the surface is
-	  constrained on the y axis. For example, if the bottom edge of the
-	  surface is constrained, the gravity is 'bottom' and the anchor is
-	  'bottom', change the gravity to 'top' and the anchor to 'top'.
-
-	  If the adjusted position also ends up being constrained, the resulting
-	  position of the flip_y adjustment will be the one before the
-	  adjustment.
-	</description>
-      </entry>
-      <entry name="resize_x" value="16">
-	<description summary="horizontally resize the surface">
-	  Resize the surface horizontally so that it is completely
-	  unconstrained.
-	</description>
-      </entry>
-      <entry name="resize_y" value="32">
-	<description summary="vertically resize the surface">
-	  Resize the surface vertically so that it is completely unconstrained.
-	</description>
-      </entry>
-    </enum>
-
-    <request name="set_constraint_adjustment">
-      <description summary="set the adjustment to be done when constrained">
-	Specify how the window should be positioned if the originally intended
-	position caused the surface to be constrained, meaning at least
-	partially outside positioning boundaries set by the compositor. The
-	adjustment is set by constructing a bitmask describing the adjustment to
-	be made when the surface is constrained on that axis.
-
-	If no bit for one axis is set, the compositor will assume that the child
-	surface should not change its position on that axis when constrained.
-
-	If more than one bit for one axis is set, the order of how adjustments
-	are applied is specified in the corresponding adjustment descriptions.
-
-	The default adjustment is none.
-      </description>
-      <arg name="constraint_adjustment" type="uint"
-	   summary="bit mask of constraint adjustments"/>
-    </request>
-
-    <request name="set_offset">
-      <description summary="set surface position offset">
-	Specify the surface position offset relative to the position of the
-	anchor on the anchor rectangle and the anchor on the surface. For
-	example if the anchor of the anchor rectangle is at (x, y), the surface
-	has the gravity bottom|right, and the offset is (ox, oy), the calculated
-	surface position will be (x + ox, y + oy). The offset position of the
-	surface is the one used for constraint testing. See
-	set_constraint_adjustment.
-
-	An example use case is placing a popup menu on top of a user interface
-	element, while aligning the user interface element of the parent surface
-	with some user interface element placed somewhere in the popup surface.
-      </description>
-      <arg name="x" type="int" summary="surface position x offset"/>
-      <arg name="y" type="int" summary="surface position y offset"/>
-    </request>
-  </interface>
-
-  <interface name="zxdg_surface_v6" version="1">
-    <description summary="desktop user interface surface base interface">
-      An interface that may be implemented by a wl_surface, for
-      implementations that provide a desktop-style user interface.
-
-      It provides a base set of functionality required to construct user
-      interface elements requiring management by the compositor, such as
-      toplevel windows, menus, etc. The types of functionality are split into
-      xdg_surface roles.
-
-      Creating an xdg_surface does not set the role for a wl_surface. In order
-      to map an xdg_surface, the client must create a role-specific object
-      using, e.g., get_toplevel, get_popup. The wl_surface for any given
-      xdg_surface can have at most one role, and may not be assigned any role
-      not based on xdg_surface.
-
-      A role must be assigned before any other requests are made to the
-      xdg_surface object.
-
-      The client must call wl_surface.commit on the corresponding wl_surface
-      for the xdg_surface state to take effect.
-
-      Creating an xdg_surface from a wl_surface which has a buffer attached or
-      committed is a client error, and any attempts by a client to attach or
-      manipulate a buffer prior to the first xdg_surface.configure call must
-      also be treated as errors.
-
-      For a surface to be mapped by the compositor, the following conditions
-      must be met: (1) the client has assigned a xdg_surface based role to the
-      surface, (2) the client has set and committed the xdg_surface state and
-      the role dependent state to the surface and (3) the client has committed a
-      buffer to the surface.
-    </description>
-
-    <enum name="error">
-      <entry name="not_constructed" value="1"/>
-      <entry name="already_constructed" value="2"/>
-      <entry name="unconfigured_buffer" value="3"/>
-    </enum>
-
-    <request name="destroy" type="destructor">
-      <description summary="destroy the xdg_surface">
-	Destroy the xdg_surface object. An xdg_surface must only be destroyed
-	after its role object has been destroyed.
-      </description>
-    </request>
-
-    <request name="get_toplevel">
-      <description summary="assign the xdg_toplevel surface role">
-	This creates an xdg_toplevel object for the given xdg_surface and gives
-	the associated wl_surface the xdg_toplevel role.
-
-	See the documentation of xdg_toplevel for more details about what an
-	xdg_toplevel is and how it is used.
-      </description>
-      <arg name="id" type="new_id" interface="zxdg_toplevel_v6"/>
-    </request>
-
-    <request name="get_popup">
-      <description summary="assign the xdg_popup surface role">
-	This creates an xdg_popup object for the given xdg_surface and gives the
-	associated wl_surface the xdg_popup role.
-
-	See the documentation of xdg_popup for more details about what an
-	xdg_popup is and how it is used.
-      </description>
-      <arg name="id" type="new_id" interface="zxdg_popup_v6"/>
-      <arg name="parent" type="object" interface="zxdg_surface_v6"/>
-      <arg name="positioner" type="object" interface="zxdg_positioner_v6"/>
-    </request>
-
-    <request name="set_window_geometry">
-      <description summary="set the new window geometry">
-	The window geometry of a surface is its "visible bounds" from the
-	user's perspective. Client-side decorations often have invisible
-	portions like drop-shadows which should be ignored for the
-	purposes of aligning, placing and constraining windows.
-
-	The window geometry is double buffered, and will be applied at the
-	time wl_surface.commit of the corresponding wl_surface is called.
-
-	Once the window geometry of the surface is set, it is not possible to
-	unset it, and it will remain the same until set_window_geometry is
-	called again, even if a new subsurface or buffer is attached.
-
-	If never set, the value is the full bounds of the surface,
-	including any subsurfaces. This updates dynamically on every
-	commit. This unset is meant for extremely simple clients.
-
-	The arguments are given in the surface-local coordinate space of
-	the wl_surface associated with this xdg_surface.
-
-	The width and height must be greater than zero. Setting an invalid size
-	will raise an error. When applied, the effective window geometry will be
-	the set window geometry clamped to the bounding rectangle of the
-	combined geometry of the surface of the xdg_surface and the associated
-	subsurfaces.
-      </description>
-      <arg name="x" type="int"/>
-      <arg name="y" type="int"/>
-      <arg name="width" type="int"/>
-      <arg name="height" type="int"/>
-    </request>
-
-    <request name="ack_configure">
-      <description summary="ack a configure event">
-	When a configure event is received, if a client commits the
-	surface in response to the configure event, then the client
-	must make an ack_configure request sometime before the commit
-	request, passing along the serial of the configure event.
-
-	For instance, for toplevel surfaces the compositor might use this
-	information to move a surface to the top left only when the client has
-	drawn itself for the maximized or fullscreen state.
-
-	If the client receives multiple configure events before it
-	can respond to one, it only has to ack the last configure event.
-
-	A client is not required to commit immediately after sending
-	an ack_configure request - it may even ack_configure several times
-	before its next surface commit.
-
-	A client may send multiple ack_configure requests before committing, but
-	only the last request sent before a commit indicates which configure
-	event the client really is responding to.
-      </description>
-      <arg name="serial" type="uint" summary="the serial from the configure event"/>
-    </request>
-
-    <event name="configure">
-      <description summary="suggest a surface change">
-	The configure event marks the end of a configure sequence. A configure
-	sequence is a set of one or more events configuring the state of the
-	xdg_surface, including the final xdg_surface.configure event.
-
-	Where applicable, xdg_surface surface roles will during a configure
-	sequence extend this event as a latched state sent as events before the
-	xdg_surface.configure event. Such events should be considered to make up
-	a set of atomically applied configuration states, where the
-	xdg_surface.configure commits the accumulated state.
-
-	Clients should arrange their surface for the new states, and then send
-	an ack_configure request with the serial sent in this configure event at
-	some point before committing the new surface.
-
-	If the client receives multiple configure events before it can respond
-	to one, it is free to discard all but the last event it received.
-      </description>
-      <arg name="serial" type="uint" summary="serial of the configure event"/>
-    </event>
-  </interface>
-
-  <interface name="zxdg_toplevel_v6" version="1">
-    <description summary="toplevel surface">
-      This interface defines an xdg_surface role which allows a surface to,
-      among other things, set window-like properties such as maximize,
-      fullscreen, and minimize, set application-specific metadata like title and
-      id, and well as trigger user interactive operations such as interactive
-      resize and move.
-    </description>
-
-    <request name="destroy" type="destructor">
-      <description summary="destroy the xdg_toplevel">
-	Unmap and destroy the window. The window will be effectively
-	hidden from the user's point of view, and all state like
-	maximization, fullscreen, and so on, will be lost.
-      </description>
-    </request>
-
-    <request name="set_parent">
-      <description summary="set the parent of this surface">
-	Set the "parent" of this surface. This window should be stacked
-	above a parent. The parent surface must be mapped as long as this
-	surface is mapped.
-
-	Parent windows should be set on dialogs, toolboxes, or other
-	"auxiliary" surfaces, so that the parent is raised when the dialog
-	is raised.
-      </description>
-      <arg name="parent" type="object" interface="zxdg_toplevel_v6" allow-null="true"/>
-    </request>
-
-    <request name="set_title">
-      <description summary="set surface title">
-	Set a short title for the surface.
-
-	This string may be used to identify the surface in a task bar,
-	window list, or other user interface elements provided by the
-	compositor.
-
-	The string must be encoded in UTF-8.
-      </description>
-      <arg name="title" type="string"/>
-    </request>
-
-    <request name="set_app_id">
-      <description summary="set application ID">
-	Set an application identifier for the surface.
-
-	The app ID identifies the general class of applications to which
-	the surface belongs. The compositor can use this to group multiple
-	surfaces together, or to determine how to launch a new application.
-
-	For D-Bus activatable applications, the app ID is used as the D-Bus
-	service name.
-
-	The compositor shell will try to group application surfaces together
-	by their app ID. As a best practice, it is suggested to select app
-	ID's that match the basename of the application's .desktop file.
-	For example, "org.freedesktop.FooViewer" where the .desktop file is
-	"org.freedesktop.FooViewer.desktop".
-
-	See the desktop-entry specification [0] for more details on
-	application identifiers and how they relate to well-known D-Bus
-	names and .desktop files.
-
-	[0] http://standards.freedesktop.org/desktop-entry-spec/
-      </description>
-      <arg name="app_id" type="string"/>
-    </request>
-
-    <request name="show_window_menu">
-      <description summary="show the window menu">
-	Clients implementing client-side decorations might want to show
-	a context menu when right-clicking on the decorations, giving the
-	user a menu that they can use to maximize or minimize the window.
-
-	This request asks the compositor to pop up such a window menu at
-	the given position, relative to the local surface coordinates of
-	the parent surface. There are no guarantees as to what menu items
-	the window menu contains.
-
-	This request must be used in response to some sort of user action
-	like a button press, key press, or touch down event.
-      </description>
-      <arg name="seat" type="object" interface="wl_seat" summary="the wl_seat of the user event"/>
-      <arg name="serial" type="uint" summary="the serial of the user event"/>
-      <arg name="x" type="int" summary="the x position to pop up the window menu at"/>
-      <arg name="y" type="int" summary="the y position to pop up the window menu at"/>
-    </request>
-
-    <request name="move">
-      <description summary="start an interactive move">
-	Start an interactive, user-driven move of the surface.
-
-	This request must be used in response to some sort of user action
-	like a button press, key press, or touch down event. The passed
-	serial is used to determine the type of interactive move (touch,
-	pointer, etc).
-
-	The server may ignore move requests depending on the state of
-	the surface (e.g. fullscreen or maximized), or if the passed serial
-	is no longer valid.
-
-	If triggered, the surface will lose the focus of the device
-	(wl_pointer, wl_touch, etc) used for the move. It is up to the
-	compositor to visually indicate that the move is taking place, such as
-	updating a pointer cursor, during the move. There is no guarantee
-	that the device focus will return when the move is completed.
-      </description>
-      <arg name="seat" type="object" interface="wl_seat" summary="the wl_seat of the user event"/>
-      <arg name="serial" type="uint" summary="the serial of the user event"/>
-    </request>
-
-    <enum name="resize_edge">
-      <description summary="edge values for resizing">
-	These values are used to indicate which edge of a surface
-	is being dragged in a resize operation.
-      </description>
-      <entry name="none" value="0"/>
-      <entry name="top" value="1"/>
-      <entry name="bottom" value="2"/>
-      <entry name="left" value="4"/>
-      <entry name="top_left" value="5"/>
-      <entry name="bottom_left" value="6"/>
-      <entry name="right" value="8"/>
-      <entry name="top_right" value="9"/>
-      <entry name="bottom_right" value="10"/>
-    </enum>
-
-    <request name="resize">
-      <description summary="start an interactive resize">
-	Start a user-driven, interactive resize of the surface.
-
-	This request must be used in response to some sort of user action
-	like a button press, key press, or touch down event. The passed
-	serial is used to determine the type of interactive resize (touch,
-	pointer, etc).
-
-	The server may ignore resize requests depending on the state of
-	the surface (e.g. fullscreen or maximized).
-
-	If triggered, the client will receive configure events with the
-	"resize" state enum value and the expected sizes. See the "resize"
-	enum value for more details about what is required. The client
-	must also acknowledge configure events using "ack_configure". After
-	the resize is completed, the client will receive another "configure"
-	event without the resize state.
-
-	If triggered, the surface also will lose the focus of the device
-	(wl_pointer, wl_touch, etc) used for the resize. It is up to the
-	compositor to visually indicate that the resize is taking place,
-	such as updating a pointer cursor, during the resize. There is no
-	guarantee that the device focus will return when the resize is
-	completed.
-
-	The edges parameter specifies how the surface should be resized,
-	and is one of the values of the resize_edge enum. The compositor
-	may use this information to update the surface position for
-	example when dragging the top left corner. The compositor may also
-	use this information to adapt its behavior, e.g. choose an
-	appropriate cursor image.
-      </description>
-      <arg name="seat" type="object" interface="wl_seat" summary="the wl_seat of the user event"/>
-      <arg name="serial" type="uint" summary="the serial of the user event"/>
-      <arg name="edges" type="uint" summary="which edge or corner is being dragged"/>
-    </request>
-
-    <enum name="state">
-      <description summary="types of state on the surface">
-	The different state values used on the surface. This is designed for
-	state values like maximized, fullscreen. It is paired with the
-	configure event to ensure that both the client and the compositor
-	setting the state can be synchronized.
-
-	States set in this way are double-buffered. They will get applied on
-	the next commit.
-      </description>
-      <entry name="maximized" value="1" summary="the surface is maximized">
-	<description summary="the surface is maximized">
-	  The surface is maximized. The window geometry specified in the configure
-	  event must be obeyed by the client.
-	</description>
-      </entry>
-      <entry name="fullscreen" value="2" summary="the surface is fullscreen">
-	<description summary="the surface is fullscreen">
-	  The surface is fullscreen. The window geometry specified in the configure
-	  event must be obeyed by the client.
-	</description>
-      </entry>
-      <entry name="resizing" value="3" summary="the surface is being resized">
-	<description summary="the surface is being resized">
-	  The surface is being resized. The window geometry specified in the
-	  configure event is a maximum; the client cannot resize beyond it.
-	  Clients that have aspect ratio or cell sizing configuration can use
-	  a smaller size, however.
-	</description>
-      </entry>
-      <entry name="activated" value="4" summary="the surface is now activated">
-	<description summary="the surface is now activated">
-	  Client window decorations should be painted as if the window is
-	  active. Do not assume this means that the window actually has
-	  keyboard or pointer focus.
-	</description>
-      </entry>
-    </enum>
-
-    <request name="set_max_size">
-      <description summary="set the maximum size">
-	Set a maximum size for the window.
-
-	The client can specify a maximum size so that the compositor does
-	not try to configure the window beyond this size.
-
-	The width and height arguments are in window geometry coordinates.
-	See xdg_surface.set_window_geometry.
-
-	Values set in this way are double-buffered. They will get applied
-	on the next commit.
-
-	The compositor can use this information to allow or disallow
-	different states like maximize or fullscreen and draw accurate
-	animations.
-
-	Similarly, a tiling window manager may use this information to
-	place and resize client windows in a more effective way.
-
-	The client should not rely on the compositor to obey the maximum
-	size. The compositor may decide to ignore the values set by the
-	client and request a larger size.
-
-	If never set, or a value of zero in the request, means that the
-	client has no expected maximum size in the given dimension.
-	As a result, a client wishing to reset the maximum size
-	to an unspecified state can use zero for width and height in the
-	request.
-
-	Requesting a maximum size to be smaller than the minimum size of
-	a surface is illegal and will result in a protocol error.
-
-	The width and height must be greater than or equal to zero. Using
-	strictly negative values for width and height will result in a
-	protocol error.
-      </description>
-      <arg name="width" type="int"/>
-      <arg name="height" type="int"/>
-    </request>
-
-    <request name="set_min_size">
-      <description summary="set the minimum size">
-	Set a minimum size for the window.
-
-	The client can specify a minimum size so that the compositor does
-	not try to configure the window below this size.
-
-	The width and height arguments are in window geometry coordinates.
-	See xdg_surface.set_window_geometry.
-
-	Values set in this way are double-buffered. They will get applied
-	on the next commit.
-
-	The compositor can use this information to allow or disallow
-	different states like maximize or fullscreen and draw accurate
-	animations.
-
-	Similarly, a tiling window manager may use this information to
-	place and resize client windows in a more effective way.
-
-	The client should not rely on the compositor to obey the minimum
-	size. The compositor may decide to ignore the values set by the
-	client and request a smaller size.
-
-	If never set, or a value of zero in the request, means that the
-	client has no expected minimum size in the given dimension.
-	As a result, a client wishing to reset the minimum size
-	to an unspecified state can use zero for width and height in the
-	request.
-
-	Requesting a minimum size to be larger than the maximum size of
-	a surface is illegal and will result in a protocol error.
-
-	The width and height must be greater than or equal to zero. Using
-	strictly negative values for width and height will result in a
-	protocol error.
-      </description>
-      <arg name="width" type="int"/>
-      <arg name="height" type="int"/>
-    </request>
-
-    <request name="set_maximized">
-      <description summary="maximize the window">
-	Maximize the surface.
-
-	After requesting that the surface should be maximized, the compositor
-	will respond by emitting a configure event with the "maximized" state
-	and the required window geometry. The client should then update its
-	content, drawing it in a maximized state, i.e. without shadow or other
-	decoration outside of the window geometry. The client must also
-	acknowledge the configure when committing the new content (see
-	ack_configure).
-
-	It is up to the compositor to decide how and where to maximize the
-	surface, for example which output and what region of the screen should
-	be used.
-
-	If the surface was already maximized, the compositor will still emit
-	a configure event with the "maximized" state.
-      </description>
-    </request>
-
-    <request name="unset_maximized">
-      <description summary="unmaximize the window">
-	Unmaximize the surface.
-
-	After requesting that the surface should be unmaximized, the compositor
-	will respond by emitting a configure event without the "maximized"
-	state. If available, the compositor will include the window geometry
-	dimensions the window had prior to being maximized in the configure
-	request. The client must then update its content, drawing it in a
-	regular state, i.e. potentially with shadow, etc. The client must also
-	acknowledge the configure when committing the new content (see
-	ack_configure).
-
-	It is up to the compositor to position the surface after it was
-	unmaximized; usually the position the surface had before maximizing, if
-	applicable.
-
-	If the surface was already not maximized, the compositor will still
-	emit a configure event without the "maximized" state.
-      </description>
-    </request>
-
-    <request name="set_fullscreen">
-      <description summary="set the window as fullscreen on a monitor">
-	Make the surface fullscreen.
-
-	You can specify an output that you would prefer to be fullscreen.
-	If this value is NULL, it's up to the compositor to choose which
-	display will be used to map this surface.
-
-	If the surface doesn't cover the whole output, the compositor will
-	position the surface in the center of the output and compensate with
-	black borders filling the rest of the output.
-      </description>
-      <arg name="output" type="object" interface="wl_output" allow-null="true"/>
-    </request>
-    <request name="unset_fullscreen" />
-
-    <request name="set_minimized">
-      <description summary="set the window as minimized">
-	Request that the compositor minimize your surface. There is no
-	way to know if the surface is currently minimized, nor is there
-	any way to unset minimization on this surface.
-
-	If you are looking to throttle redrawing when minimized, please
-	instead use the wl_surface.frame event for this, as this will
-	also work with live previews on windows in Alt-Tab, Expose or
-	similar compositor features.
-      </description>
-    </request>
-
-    <event name="configure">
-      <description summary="suggest a surface change">
-	This configure event asks the client to resize its toplevel surface or
-	to change its state. The configured state should not be applied
-	immediately. See xdg_surface.configure for details.
-
-	The width and height arguments specify a hint to the window
-	about how its surface should be resized in window geometry
-	coordinates. See set_window_geometry.
-
-	If the width or height arguments are zero, it means the client
-	should decide its own window dimension. This may happen when the
-	compositor needs to configure the state of the surface but doesn't
-	have any information about any previous or expected dimension.
-
-	The states listed in the event specify how the width/height
-	arguments should be interpreted, and possibly how it should be
-	drawn.
-
-	Clients must send an ack_configure in response to this event. See
-	xdg_surface.configure and xdg_surface.ack_configure for details.
-      </description>
-      <arg name="width" type="int"/>
-      <arg name="height" type="int"/>
-      <arg name="states" type="array"/>
-    </event>
-
-    <event name="close">
-      <description summary="surface wants to be closed">
-	The close event is sent by the compositor when the user
-	wants the surface to be closed. This should be equivalent to
-	the user clicking the close button in client-side decorations,
-	if your application has any.
-
-	This is only a request that the user intends to close the
-	window. The client may choose to ignore this request, or show
-	a dialog to ask the user to save their data, etc.
-      </description>
-    </event>
-  </interface>
-
-  <interface name="zxdg_popup_v6" version="1">
-    <description summary="short-lived, popup surfaces for menus">
-      A popup surface is a short-lived, temporary surface. It can be used to
-      implement for example menus, popovers, tooltips and other similar user
-      interface concepts.
-
-      A popup can be made to take an explicit grab. See xdg_popup.grab for
-      details.
-
-      When the popup is dismissed, a popup_done event will be sent out, and at
-      the same time the surface will be unmapped. See the xdg_popup.popup_done
-      event for details.
-
-      Explicitly destroying the xdg_popup object will also dismiss the popup and
-      unmap the surface. Clients that want to dismiss the popup when another
-      surface of their own is clicked should dismiss the popup using the destroy
-      request.
-
-      The parent surface must have either the xdg_toplevel or xdg_popup surface
-      role.
-
-      A newly created xdg_popup will be stacked on top of all previously created
-      xdg_popup surfaces associated with the same xdg_toplevel.
-
-      The parent of an xdg_popup must be mapped (see the xdg_surface
-      description) before the xdg_popup itself.
-
-      The x and y arguments passed when creating the popup object specify
-      where the top left of the popup should be placed, relative to the
-      local surface coordinates of the parent surface. See
-      xdg_surface.get_popup. An xdg_popup must intersect with or be at least
-      partially adjacent to its parent surface.
-
-      The client must call wl_surface.commit on the corresponding wl_surface
-      for the xdg_popup state to take effect.
-    </description>
-
-    <enum name="error">
-      <entry name="invalid_grab" value="0"
-	     summary="tried to grab after being mapped"/>
-    </enum>
-
-    <request name="destroy" type="destructor">
-      <description summary="remove xdg_popup interface">
-	This destroys the popup. Explicitly destroying the xdg_popup
-	object will also dismiss the popup, and unmap the surface.
-
-	If this xdg_popup is not the "topmost" popup, a protocol error
-	will be sent.
-      </description>
-    </request>
-
-    <request name="grab">
-      <description summary="make the popup take an explicit grab">
-	This request makes the created popup take an explicit grab. An explicit
-	grab will be dismissed when the user dismisses the popup, or when the
-	client destroys the xdg_popup. This can be done by the user clicking
-	outside the surface, using the keyboard, or even locking the screen
-	through closing the lid or a timeout.
-
-	If the compositor denies the grab, the popup will be immediately
-	dismissed.
-
-	This request must be used in response to some sort of user action like a
-	button press, key press, or touch down event. The serial number of the
-	event should be passed as 'serial'.
-
-	The parent of a grabbing popup must either be an xdg_toplevel surface or
-	another xdg_popup with an explicit grab. If the parent is another
-	xdg_popup it means that the popups are nested, with this popup now being
-	the topmost popup.
-
-	Nested popups must be destroyed in the reverse order they were created
-	in, e.g. the only popup you are allowed to destroy at all times is the
-	topmost one.
-
-	When compositors choose to dismiss a popup, they may dismiss every
-	nested grabbing popup as well. When a compositor dismisses popups, it
-	will follow the same dismissing order as required from the client.
-
-	The parent of a grabbing popup must either be another xdg_popup with an
-	active explicit grab, or an xdg_popup or xdg_toplevel, if there are no
-	explicit grabs already taken.
-
-	If the topmost grabbing popup is destroyed, the grab will be returned to
-	the parent of the popup, if that parent previously had an explicit grab.
-
-	If the parent is a grabbing popup which has already been dismissed, this
-	popup will be immediately dismissed. If the parent is a popup that did
-	not take an explicit grab, an error will be raised.
-
-	During a popup grab, the client owning the grab will receive pointer
-	and touch events for all their surfaces as normal (similar to an
-	"owner-events" grab in X11 parlance), while the top most grabbing popup
-	will always have keyboard focus.
-      </description>
-      <arg name="seat" type="object" interface="wl_seat"
-	   summary="the wl_seat of the user event"/>
-      <arg name="serial" type="uint" summary="the serial of the user event"/>
-    </request>
-
-    <event name="configure">
-      <description summary="configure the popup surface">
-	This event asks the popup surface to configure itself given the
-	configuration. The configured state should not be applied immediately.
-	See xdg_surface.configure for details.
-
-	The x and y arguments represent the position the popup was placed at
-	given the xdg_positioner rule, relative to the upper left corner of the
-	window geometry of the parent surface.
-      </description>
-      <arg name="x" type="int"
-	   summary="x position relative to parent surface window geometry"/>
-      <arg name="y" type="int"
-	   summary="y position relative to parent surface window geometry"/>
-      <arg name="width" type="int" summary="window geometry width"/>
-      <arg name="height" type="int" summary="window geometry height"/>
-    </event>
-
-    <event name="popup_done">
-      <description summary="popup interaction is done">
-	The popup_done event is sent out when a popup is dismissed by the
-	compositor. The client should destroy the xdg_popup object at this
-	point.
-      </description>
-    </event>
-
-  </interface>
-</protocol>
diff --git a/Engine/lib/sdl/wayland-protocols/xdg-shell.xml b/Engine/lib/sdl/wayland-protocols/xdg-shell.xml
index d524ea9e2..be64354da 100644
--- a/Engine/lib/sdl/wayland-protocols/xdg-shell.xml
+++ b/Engine/lib/sdl/wayland-protocols/xdg-shell.xml
@@ -29,7 +29,7 @@
     DEALINGS IN THE SOFTWARE.
   </copyright>
 
-  <interface name="xdg_wm_base" version="1">
+  <interface name="xdg_wm_base" version="3">
     <description summary="create desktop-style surfaces">
       The xdg_wm_base interface is exposed as a global object enabling clients
       to turn their wl_surfaces into windows in a desktop environment. It
@@ -101,7 +101,7 @@
       <description summary="check if the client is alive">
 	The ping event asks the client if it's still alive. Pass the
 	serial specified in the event back to the compositor by sending
-	a "pong" request back with the specified serial. See xdg_wm_base.ping.
+	a "pong" request back with the specified serial. See xdg_wm_base.pong.
 
 	Compositors can use this to determine if the client is still
 	alive. It's unspecified what will happen if the client doesn't
@@ -115,7 +115,7 @@
     </event>
   </interface>
 
-  <interface name="xdg_positioner" version="1">
+  <interface name="xdg_positioner" version="3">
     <description summary="child surface positioner">
       The xdg_positioner provides a collection of rules for the placement of a
       child surface relative to a parent surface. Rules can be defined to ensure
@@ -357,9 +357,49 @@
       <arg name="x" type="int" summary="surface position x offset"/>
       <arg name="y" type="int" summary="surface position y offset"/>
     </request>
+
+    <!-- Version 3 additions -->
+
+    <request name="set_reactive" since="3">
+      <description summary="continuously reconstrain the surface">
+	When set reactive, the surface is reconstrained if the conditions used
+	for constraining changed, e.g. the parent window moved.
+
+	If the conditions changed and the popup was reconstrained, an
+	xdg_popup.configure event is sent with updated geometry, followed by an
+	xdg_surface.configure event.
+      </description>
+    </request>
+
+    <request name="set_parent_size" since="3">
+      <description summary="">
+	Set the parent window geometry the compositor should use when
+	positioning the popup. The compositor may use this information to
+	determine the future state the popup should be constrained using. If
+	this doesn't match the dimension of the parent the popup is eventually
+	positioned against, the behavior is undefined.
+
+	The arguments are given in the surface-local coordinate space.
+      </description>
+      <arg name="parent_width" type="int"
+	   summary="future window geometry width of parent"/>
+      <arg name="parent_height" type="int"
+	   summary="future window geometry height of parent"/>
+    </request>
+
+    <request name="set_parent_configure" since="3">
+      <description summary="set parent configure this is a response to">
+	Set the serial of a xdg_surface.configure event this positioner will be
+	used in response to. The compositor may use this information together
+	with set_parent_size to determine what future state the popup should be
+	constrained using.
+      </description>
+      <arg name="serial" type="uint"
+	   summary="serial of parent configure event"/>
+    </request>
   </interface>
 
-  <interface name="xdg_surface" version="1">
+  <interface name="xdg_surface" version="3">
     <description summary="desktop user interface surface base interface">
       An interface that may be implemented by a wl_surface, for
       implementations that provide a desktop-style user interface.
@@ -526,9 +566,10 @@
       </description>
       <arg name="serial" type="uint" summary="serial of the configure event"/>
     </event>
+
   </interface>
 
-  <interface name="xdg_toplevel" version="1">
+  <interface name="xdg_toplevel" version="3">
     <description summary="toplevel surface">
       This interface defines an xdg_surface role which allows a surface to,
       among other things, set window-like properties such as maximize,
@@ -604,6 +645,9 @@
 	For example, "org.freedesktop.FooViewer" where the .desktop file is
 	"org.freedesktop.FooViewer.desktop".
 
+	Like other properties, a set_app_id request can be sent after the
+	xdg_toplevel has been mapped to update the property.
+
 	See the desktop-entry specification [0] for more details on
 	application identifiers and how they relate to well-known D-Bus
 	names and .desktop files.
@@ -707,7 +751,7 @@
       </description>
       <arg name="seat" type="object" interface="wl_seat" summary="the wl_seat of the user event"/>
       <arg name="serial" type="uint" summary="the serial of the user event"/>
-      <arg name="edges" type="uint" summary="which edge or corner is being dragged"/>
+      <arg name="edges" type="uint" enum="resize_edge" summary="which edge or corner is being dragged"/>
     </request>
 
     <enum name="state">
@@ -724,6 +768,9 @@
 	<description summary="the surface is maximized">
 	  The surface is maximized. The window geometry specified in the configure
 	  event must be obeyed by the client.
+
+	  The client should draw without shadow or other
+	  decoration outside of the window geometry.
 	</description>
       </entry>
       <entry name="fullscreen" value="2" summary="the surface is fullscreen">
@@ -750,6 +797,30 @@
 	  keyboard or pointer focus.
 	</description>
       </entry>
+      <entry name="tiled_left" value="5" since="2">
+	<description summary="the surface is tiled">
+	  The window is currently in a tiled layout and the left edge is
+	  considered to be adjacent to another part of the tiling grid.
+	</description>
+      </entry>
+      <entry name="tiled_right" value="6" since="2">
+	<description summary="the surface is tiled">
+	  The window is currently in a tiled layout and the right edge is
+	  considered to be adjacent to another part of the tiling grid.
+	</description>
+      </entry>
+      <entry name="tiled_top" value="7" since="2">
+	<description summary="the surface is tiled">
+	  The window is currently in a tiled layout and the top edge is
+	  considered to be adjacent to another part of the tiling grid.
+	</description>
+      </entry>
+      <entry name="tiled_bottom" value="8" since="2">
+	<description summary="the surface is tiled">
+	  The window is currently in a tiled layout and the bottom edge is
+	  considered to be adjacent to another part of the tiling grid.
+	</description>
+      </entry>
     </enum>
 
     <request name="set_max_size">
@@ -839,12 +910,11 @@
 	Maximize the surface.
 
 	After requesting that the surface should be maximized, the compositor
-	will respond by emitting a configure event with the "maximized" state
-	and the required window geometry. The client should then update its
-	content, drawing it in a maximized state, i.e. without shadow or other
-	decoration outside of the window geometry. The client must also
-	acknowledge the configure when committing the new content (see
-	ack_configure).
+	will respond by emitting a configure event. Whether this configure
+	actually sets the window maximized is subject to compositor policies.
+	The client must then update its content, drawing in the configured
+	state. The client must also acknowledge the configure when committing
+	the new content (see ack_configure).
 
 	It is up to the compositor to decide how and where to maximize the
 	surface, for example which output and what region of the screen should
@@ -854,8 +924,8 @@
 	a configure event with the "maximized" state.
 
 	If the surface is in a fullscreen state, this request has no direct
-	effect. It will alter the state the surface is returned to when
-	unmaximized if not overridden by the compositor.
+	effect. It may alter the state the surface is returned to when
+	unmaximized unless overridden by the compositor.
       </description>
     </request>
 
@@ -864,13 +934,13 @@
 	Unmaximize the surface.
 
 	After requesting that the surface should be unmaximized, the compositor
-	will respond by emitting a configure event without the "maximized"
-	state. If available, the compositor will include the window geometry
-	dimensions the window had prior to being maximized in the configure
-	event. The client must then update its content, drawing it in a
-	regular state, i.e. potentially with shadow, etc. The client must also
-	acknowledge the configure when committing the new content (see
-	ack_configure).
+	will respond by emitting a configure event. Whether this actually
+	un-maximizes the window is subject to compositor policies.
+	If available and applicable, the compositor will include the window
+	geometry dimensions the window had prior to being maximized in the
+	configure event. The client must then update its content, drawing it in
+	the configured state. The client must also acknowledge the configure
+	when committing the new content (see ack_configure).
 
 	It is up to the compositor to position the surface after it was
 	unmaximized; usually the position the surface had before maximizing, if
@@ -880,8 +950,8 @@
 	emit a configure event without the "maximized" state.
 
 	If the surface is in a fullscreen state, this request has no direct
-	effect. It will alter the state the surface is returned to when
-	unmaximized if not overridden by the compositor.
+	effect. It may alter the state the surface is returned to when
+	unmaximized unless overridden by the compositor.
       </description>
     </request>
 
@@ -890,10 +960,10 @@
 	Make the surface fullscreen.
 
 	After requesting that the surface should be fullscreened, the
-	compositor will respond by emitting a configure event with the
-	"fullscreen" state and the fullscreen window geometry. The client must
-	also acknowledge the configure when committing the new content (see
-	ack_configure).
+	compositor will respond by emitting a configure event. Whether the
+	client is actually put into a fullscreen state is subject to compositor
+	policies. The client must also acknowledge the configure when
+	committing the new content (see ack_configure).
 
 	The output passed by the request indicates the client's preference as
 	to which display it should be set fullscreen on. If this value is NULL,
@@ -919,8 +989,9 @@
 	Make the surface no longer fullscreen.
 
 	After requesting that the surface should be unfullscreened, the
-	compositor will respond by emitting a configure event without the
-	"fullscreen" state.
+	compositor will respond by emitting a configure event.
+	Whether this actually removes the fullscreen state of the client is
+	subject to compositor policies.
 
 	Making a surface unfullscreen sets states for the surface based on the following:
 	* the state(s) it may have had before becoming fullscreen
@@ -989,7 +1060,7 @@
     </event>
   </interface>
 
-  <interface name="xdg_popup" version="1">
+  <interface name="xdg_popup" version="3">
     <description summary="short-lived, popup surfaces for menus">
       A popup surface is a short-lived, temporary surface. It can be used to
       implement for example menus, popovers, tooltips and other similar user
@@ -1007,21 +1078,12 @@
       surface of their own is clicked should dismiss the popup using the destroy
       request.
 
-      The parent surface must have either the xdg_toplevel or xdg_popup surface
-      role.
-
       A newly created xdg_popup will be stacked on top of all previously created
       xdg_popup surfaces associated with the same xdg_toplevel.
 
       The parent of an xdg_popup must be mapped (see the xdg_surface
       description) before the xdg_popup itself.
 
-      The x and y arguments passed when creating the popup object specify
-      where the top left of the popup should be placed, relative to the
-      local surface coordinates of the parent surface. See
-      xdg_surface.get_popup. An xdg_popup must intersect with or be at least
-      partially adjacent to its parent surface.
-
       The client must call wl_surface.commit on the corresponding wl_surface
       for the xdg_popup state to take effect.
     </description>
@@ -1099,6 +1161,11 @@
 	The x and y arguments represent the position the popup was placed at
 	given the xdg_positioner rule, relative to the upper left corner of the
 	window geometry of the parent surface.
+
+	For version 2 or older, the configure event for an xdg_popup is only
+	ever sent once for the initial configuration. Starting with version 3,
+	it may be sent again if the popup is setup with an xdg_positioner with
+	set_reactive requested, or in response to xdg_popup.reposition requests.
       </description>
       <arg name="x" type="int"
 	   summary="x position relative to parent surface window geometry"/>
@@ -1116,5 +1183,58 @@
       </description>
     </event>
 
+    <!-- Version 3 additions -->
+
+    <request name="reposition" since="3">
+      <description summary="recalculate the popup's location">
+	Reposition an already-mapped popup. The popup will be placed given the
+	details in the passed xdg_positioner object, and a
+	xdg_popup.repositioned followed by xdg_popup.configure and
+	xdg_surface.configure will be emitted in response. Any parameters set
+	by the previous positioner will be discarded.
+
+	The passed token will be sent in the corresponding
+	xdg_popup.repositioned event. The new popup position will not take
+	effect until the corresponding configure event is acknowledged by the
+	client. See xdg_popup.repositioned for details. The token itself is
+	opaque, and has no other special meaning.
+
+	If multiple reposition requests are sent, the compositor may skip all
+	but the last one.
+
+	If the popup is repositioned in response to a configure event for its
+	parent, the client should send an xdg_positioner.set_parent_configure
+	and possibly a xdg_positioner.set_parent_size request to allow the
+	compositor to properly constrain the popup.
+
+	If the popup is repositioned together with a parent that is being
+	resized, but not in response to a configure event, the client should
+	send a xdg_positioner.set_parent_size request.
+      </description>
+      <arg name="positioner" type="object" interface="xdg_positioner"/>
+      <arg name="token" type="uint" summary="reposition request token"/>
+    </request>
+
+    <event name="repositioned" since="3">
+      <description summary="signal the completion of a repositioned request">
+	The repositioned event is sent as part of a popup configuration
+	sequence, together with xdg_popup.configure and lastly
+	xdg_surface.configure to notify the completion of a reposition request.
+
+	The repositioned event is to notify about the completion of a
+	xdg_popup.reposition request. The token argument is the token passed
+	in the xdg_popup.reposition request.
+
+	Immediately after this event is emitted, xdg_popup.configure and
+	xdg_surface.configure will be sent with the updated size and position,
+	as well as a new configure serial.
+
+	The client should optionally update the content of the popup, but must
+	acknowledge the new popup configuration for the new position to take
+	effect. See xdg_surface.ack_configure for details.
+      </description>
+      <arg name="token" type="uint" summary="reposition request token"/>
+    </event>
+
   </interface>
 </protocol>

From 69d547fd72709fc9baf248c2fb7c90dc46c8c68a Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Sat, 26 Mar 2022 22:36:37 -0500
Subject: [PATCH 342/399] Adjusted handling for the bitmap and bitmapAsset
 fields for guiBitmapButtonCtrl to forcefully update the button states when
 changed, ensuring that the bitmaps refresh when changed via the field Added
 callback for onResize to guiWindowCtrl so controls - such as the EditorTree -
 can be properly resized in certain circumstances when the window is changed
 Added getIncrement() and getRange() to GuiGameSettingsCtrl to better
 facilitate options manipulation on the script side Corrected some of the
 console method documentation strings in GuiGameSettingsCtrl Removed some
 unneeded, extraneous files and their asset definitions that came from odd
 import conversions. Where applicable, created cleaned up versions to make
 naming conventions and references stable Fixed canvas mode update text typo:
 FSAA -> FXAA Added logic to DOF, Light Rays, SSAO and Vignette postFX's to
 check both the preset setting AND the user preference before enabling.
 Shifted initialization order so PostFX's are loaded before we configure the
 canvas, to ensure stuff like the FXAAPostFX exists and can be toggled on on
 load Fixed multiple issues with options menu:  When using gamepad, unable to
 navigate from categories to options. Fixed so can now traverse as normal 
 Input limitations on gamepad necessitated changing of how setting applying
 happens, is now done as a 'apply or discard' prompt when leaving the options
 menu  Added proper handling for adjusting settings with gamepad with
 left/right inputs  Fixed issue where the unapplied change for an option was
 sometimes being processed as an object name rather than an implicit string.
 Now made to be explicit strings to avoid issue.  Made the menu button input
 for "Select" to go from categories to options gamepad only, and hidden when
 in the options list  Fixed issue where changing window mode didn't correctly
 affect resolution option. Now set up so changing this field correctly
 refreshes the resolution option. Specifically, when on borderless, the
 resolution field does not show, preventing confusion as it is always full
 resolution  Generally have the options list refresh when changes happen to
 allow any and all fields to be able to dynamically respond to other options
 having changed improving flexibility.  Cleaned up old, unused, commented out
 functions Added ability on OKCancel message boxes to override the button text
 if needed Fixed issue with AssetBrowser where the shrink/grow icons next to
 the preview size slider were not anchored correctly. Adjusted callback logic
 so if preview slider is clicked on, rather than dragged, it will correctly
 update the zoom values Added sorting to Modules List dropdown for the
 AssetBrowser Improved standardization of double-clicking in AssetBrowser. Now
 defaults to editing action if regularly browsing and selecting if in select
 mode. Still allows regular per-type overrides as normal Moved definition of
 GuiDisabledTextEditProfile to gui profiles.ed.tscript file, removed
 duplicates to stop error spam Adjusted default settings value for
 double-click action in AB to be edit to prevent unstable behavior Removed old
 file refs from Load Recent list in the default settings

---
 .../gui/buttons/guiBitmapButtonCtrl.cpp       |   7 +-
 .../source/gui/buttons/guiBitmapButtonCtrl.h  |   8 +
 .../source/gui/containers/guiWindowCtrl.cpp   |   5 +
 Engine/source/gui/containers/guiWindowCtrl.h  |   1 +
 .../gui/controls/guiGameSettingsCtrl.cpp      |  35 +-
 .../source/gui/controls/guiGameSettingsCtrl.h |  10 +
 .../core/gameObjects/shapes/Camera.asset.taml |   1 -
 .../game/core/gui/scripts/canvas.tscript      |   2 +-
 .../DepthOfField/DepthOfFieldPostFX.tscript   |   4 +-
 .../scripts/LightRays/lightRays.tscript       |   4 +-
 .../postFX/scripts/SSAO/SSAOPostFx.tscript    |   4 +-
 .../scripts/Vignette/VignettePostFX.tscript   |   4 +-
 .../core/rendering/Core_Rendering.tscript     |   4 +-
 .../materials/moon_noglow.asset.taml          |   2 +-
 .../rendering/materials/moon_noglow.tscript   |   9 -
 .../materials/moon_noglowMat.asset.taml       |  14 -
 .../materials/moon_wcorona.asset.taml         |   2 +-
 .../materials/moon_wcoronaMat.asset.taml      |   2 +-
 .../rendering/materials/moon_wglow.tscript    |   9 -
 .../materials/moon_wglowMat.asset.taml        |  14 -
 .../rendering/shapes/noShapeMat.asset.taml    |   2 +-
 .../game/data/UI/guis/optionsMenu.gui         | 343 ++++--------------
 .../game/data/UI/guis/optionsMenu.tscript     | 230 ++++++------
 .../{groupborder.png => group_border.png}     | Bin
 .../UI/images/group_border_image.asset.taml   |   2 +-
 .../images/{nopreview.png => no_preview.png}  | Bin
 .../UI/images/no_preview_image.asset.taml     |   2 +-
 .../data/UI/images/nopreview_image.asset.taml |   3 -
 ...selectorbutton.png => selector_button.png} | Bin
 ...tonblank.png => selector_button_blank.png} | Bin
 .../selector_button_blank_image.asset.taml    |   2 +-
 ...uttondark.png => selector_button_dark.png} | Bin
 .../selector_button_dark_image.asset.taml     |   2 +-
 ...png => selector_button_highlight_only.png} | Bin
 ...tor_button_highlight_only_image.asset.taml |   2 +-
 .../images/selector_button_image.asset.taml   |   2 +-
 .../UI/images/selectorbutton_image.asset.taml |   3 -
 .../selectorbuttonblank_image.asset.taml      |   3 -
 .../selectorbuttondark_image.asset.taml       |   3 -
 ...lectorbuttonhighlightonly_image.asset.taml |   3 -
 .../images/{tabborder.png => tab_border.png}  | Bin
 .../UI/images/tab_border_image.asset.taml     |   2 +-
 .../data/UI/images/tabborder_image.asset.taml |   3 -
 .../data/UI/scripts/menuInputHandling.tscript |  54 ++-
 .../game/data/UI/scripts/messageBoxes.tscript |  16 +-
 .../tools/assetBrowser/guis/assetBrowser.gui  |   5 +-
 .../scripts/addModuleWindow.tscript           |   2 +
 .../assetBrowser/scripts/assetBrowser.tscript |  22 +-
 .../scripts/assetTypes/material.tscript       |   5 +
 .../tools/convexEditor/convexEditor.tscript   |  17 -
 .../game/tools/gui/profiles.ed.tscript        |  21 +-
 .../meshRoadEditor/meshRoadEditor.tscript     |  17 -
 Templates/BaseGame/game/tools/settings.xml    |   6 +-
 .../worldEditor/scripts/EditorGui.ed.tscript  |   6 +
 54 files changed, 382 insertions(+), 537 deletions(-)
 delete mode 100644 Templates/BaseGame/game/core/gameObjects/shapes/Camera.asset.taml
 delete mode 100644 Templates/BaseGame/game/core/rendering/materials/moon_noglow.tscript
 delete mode 100644 Templates/BaseGame/game/core/rendering/materials/moon_noglowMat.asset.taml
 delete mode 100644 Templates/BaseGame/game/core/rendering/materials/moon_wglow.tscript
 delete mode 100644 Templates/BaseGame/game/core/rendering/materials/moon_wglowMat.asset.taml
 rename Templates/BaseGame/game/data/UI/images/{groupborder.png => group_border.png} (100%)
 rename Templates/BaseGame/game/data/UI/images/{nopreview.png => no_preview.png} (100%)
 delete mode 100644 Templates/BaseGame/game/data/UI/images/nopreview_image.asset.taml
 rename Templates/BaseGame/game/data/UI/images/{selectorbutton.png => selector_button.png} (100%)
 rename Templates/BaseGame/game/data/UI/images/{selectorbuttonblank.png => selector_button_blank.png} (100%)
 rename Templates/BaseGame/game/data/UI/images/{selectorbuttondark.png => selector_button_dark.png} (100%)
 rename Templates/BaseGame/game/data/UI/images/{selectorbuttonhighlightonly.png => selector_button_highlight_only.png} (100%)
 delete mode 100644 Templates/BaseGame/game/data/UI/images/selectorbutton_image.asset.taml
 delete mode 100644 Templates/BaseGame/game/data/UI/images/selectorbuttonblank_image.asset.taml
 delete mode 100644 Templates/BaseGame/game/data/UI/images/selectorbuttondark_image.asset.taml
 delete mode 100644 Templates/BaseGame/game/data/UI/images/selectorbuttonhighlightonly_image.asset.taml
 rename Templates/BaseGame/game/data/UI/images/{tabborder.png => tab_border.png} (100%)
 delete mode 100644 Templates/BaseGame/game/data/UI/images/tabborder_image.asset.taml

diff --git a/Engine/source/gui/buttons/guiBitmapButtonCtrl.cpp b/Engine/source/gui/buttons/guiBitmapButtonCtrl.cpp
index 65672f4e6..c4b059ce8 100644
--- a/Engine/source/gui/buttons/guiBitmapButtonCtrl.cpp
+++ b/Engine/source/gui/buttons/guiBitmapButtonCtrl.cpp
@@ -138,10 +138,15 @@ void GuiBitmapButtonCtrl::initPersistFields()
 {
    addGroup( "Bitmap" );
 
-      INITPERSISTFIELD_IMAGEASSET(Bitmap, GuiBitmapButtonCtrl, "Texture file to display on this button.\n"
+      addProtectedField("Bitmap", TypeImageFilename, Offset(mBitmapName, GuiBitmapButtonCtrl), _setBitmapFieldData, &defaultProtectedGetFn, "Texture file to display on this button.\n"
+         "If useStates is false, this will be the file that renders on the control.  Otherwise, this will "
+         "specify the default texture name to which the various state and modifier suffixes are appended "
+         "to find the per-state and per-modifier (if enabled) textures.", AbstractClassRep::FIELD_HideInInspectors); \
+      addProtectedField("BitmapAsset", TypeImageAssetId, Offset(mBitmapAssetId, GuiBitmapButtonCtrl), _setBitmapFieldData, &defaultProtectedGetFn, "Texture file to display on this button.\n"
          "If useStates is false, this will be the file that renders on the control.  Otherwise, this will "
          "specify the default texture name to which the various state and modifier suffixes are appended "
          "to find the per-state and per-modifier (if enabled) textures.");
+
       addField("color", TypeColorI, Offset(mColor, GuiBitmapButtonCtrl), "color mul");
 
       addField( "bitmapMode", TYPEID< BitmapMode >(), Offset( mBitmapMode, GuiBitmapButtonCtrl ),
diff --git a/Engine/source/gui/buttons/guiBitmapButtonCtrl.h b/Engine/source/gui/buttons/guiBitmapButtonCtrl.h
index 910ff2400..e605b15b1 100644
--- a/Engine/source/gui/buttons/guiBitmapButtonCtrl.h
+++ b/Engine/source/gui/buttons/guiBitmapButtonCtrl.h
@@ -185,6 +185,14 @@ class GuiBitmapButtonCtrl : public GuiButtonCtrl
       DECLARE_CONOBJECT(GuiBitmapButtonCtrl);
       DECLARE_DESCRIPTION( "A button control rendered entirely from bitmaps.\n"
                            "The individual button states are represented with separate bitmaps." );
+
+      //Basically a wrapper function to do our special state handling setup when the fields change
+      static bool _setBitmapFieldData(void* obj, const char* index, const char* data)
+      {
+         GuiBitmapButtonCtrl* object = static_cast<GuiBitmapButtonCtrl*>(obj); 
+         object->setBitmap(StringTable->insert(data)); 
+         return false; 
+      }
 };
 
 typedef GuiBitmapButtonCtrl::BitmapMode GuiBitmapMode;
diff --git a/Engine/source/gui/containers/guiWindowCtrl.cpp b/Engine/source/gui/containers/guiWindowCtrl.cpp
index 74a155b9b..ddd11bd40 100644
--- a/Engine/source/gui/containers/guiWindowCtrl.cpp
+++ b/Engine/source/gui/containers/guiWindowCtrl.cpp
@@ -66,6 +66,9 @@ IMPLEMENT_CALLBACK( GuiWindowCtrl, onCollapse, void, (), (),
    "Called when the window is collapsed by clicking its title bar." );
 IMPLEMENT_CALLBACK( GuiWindowCtrl, onRestore, void, (), (),
    "Called when the window is restored from minimized, maximized, or collapsed state." );
+IMPLEMENT_CALLBACK(GuiWindowCtrl, onResize, void, (S32 posX, S32 posY, S32 width, S32 height), (0, 0, 0, 0),
+   "Called when the window is resized in a regular manner by mouse manipulation.");
+
 
 //-----------------------------------------------------------------------------
 
@@ -1557,6 +1560,8 @@ bool GuiWindowCtrl::resize(const Point2I &newPosition, const Point2I &newExtent)
    // Set the button coords
    positionButtons();
 
+   onResize_callback(newPosition.x, newPosition.y, newExtent.x, newExtent.y);
+
    return true;
 }
 
diff --git a/Engine/source/gui/containers/guiWindowCtrl.h b/Engine/source/gui/containers/guiWindowCtrl.h
index ef1b61751..d484973e6 100644
--- a/Engine/source/gui/containers/guiWindowCtrl.h
+++ b/Engine/source/gui/containers/guiWindowCtrl.h
@@ -201,6 +201,7 @@ class GuiWindowCtrl : public GuiContainer
       DECLARE_CALLBACK( void, onMaximize, () );
       DECLARE_CALLBACK( void, onCollapse, () );
       DECLARE_CALLBACK( void, onRestore, () );
+      DECLARE_CALLBACK(void, onResize, (S32 posX, S32 posY, S32 width, S32 height));
       
       /// @}
 
diff --git a/Engine/source/gui/controls/guiGameSettingsCtrl.cpp b/Engine/source/gui/controls/guiGameSettingsCtrl.cpp
index 1b6516e4a..f608ea83f 100644
--- a/Engine/source/gui/controls/guiGameSettingsCtrl.cpp
+++ b/Engine/source/gui/controls/guiGameSettingsCtrl.cpp
@@ -740,7 +740,7 @@ void GuiGameSettingsCtrl::changeOption(S32 delta)
    if (mScriptCallback != NULL && (mSelectedOption != NO_OPTION && mMode != GuiGameSettingsCtrl::Slider))
    {
       setThisControl();
-      StringTableEntry direction = NULL;
+      StringTableEntry direction = StringTable->EmptyString();
       if (delta < 0)
       {
          direction = LEFT;
@@ -749,7 +749,7 @@ void GuiGameSettingsCtrl::changeOption(S32 delta)
       {
          direction = RIGHT;
       }
-      if ((direction != NULL) && (Con::isFunction(mScriptCallback)))
+      if ((direction != StringTable->EmptyString()) && (Con::isFunction(mScriptCallback)))
       {
          Con::executef(mScriptCallback, direction);
       }
@@ -849,6 +849,16 @@ void GuiGameSettingsCtrl::setValue(F32 value)
    mValue = value;
 }
 
+F32 GuiGameSettingsCtrl::getIncrement()
+{
+   return mStepSize;
+}
+
+Point2F GuiGameSettingsCtrl::getRange()
+{
+   return mRange;
+}
+
 const char* GuiGameSettingsCtrl::getTooltip()
 {
    return mTooltip;
@@ -1100,22 +1110,31 @@ DefineEngineMethod(GuiGameSettingsCtrl, addOption, void, (const char* displayTex
 }
 
 DefineEngineMethod(GuiGameSettingsCtrl, getValue, F32, (), ,
-   "Sets the list of options on the given control.\n\n"
-   "@param optionsList A tab separated list of options for the control.")
+   "Gets the value of the slider on the given control.")
 {
    return object->getValue();
 }
 
 DefineEngineMethod(GuiGameSettingsCtrl, setValue, void, (F32 value), ,
-   "Sets the list of options on the given control.\n\n"
-   "@param optionsList A tab separated list of options for the control.")
+   "Sets the value of the slider on the given control.")
 {
    object->setValue(value);
 }
 
+DefineEngineMethod(GuiGameSettingsCtrl, getIncrement, F32, (), ,
+   "Gets the increment amount of the slider on a given control.")
+{
+   return object->getIncrement();
+}
+
+DefineEngineMethod(GuiGameSettingsCtrl, getRange, Point2F, (), ,
+   "Gets the min and max values for the range of the slider on a given control.")
+{
+   return object->getRange();
+}
+
 DefineEngineMethod(GuiGameSettingsCtrl, getTooltip, const char*, (), ,
-   "Sets the list of options on the given control.\n\n"
-   "@param optionsList A tab separated list of options for the control.")
+   "Gets the tooltip on the given control.")
 {
    return object->getTooltip();
 }
diff --git a/Engine/source/gui/controls/guiGameSettingsCtrl.h b/Engine/source/gui/controls/guiGameSettingsCtrl.h
index d8aac95e8..86a3465f1 100644
--- a/Engine/source/gui/controls/guiGameSettingsCtrl.h
+++ b/Engine/source/gui/controls/guiGameSettingsCtrl.h
@@ -214,6 +214,16 @@ public:
 
    Mode getMode() { return mMode; }
 
+   /// <summary>
+   /// Gets the incremenet amount
+   /// </summary>
+   F32 getIncrement();
+
+   /// <summary>
+   /// Gets range of values allowed
+   /// </summary>
+   Point2F getRange();
+
    /// Gets the tooltip
    const char* getTooltip();
 
diff --git a/Templates/BaseGame/game/core/gameObjects/shapes/Camera.asset.taml b/Templates/BaseGame/game/core/gameObjects/shapes/Camera.asset.taml
deleted file mode 100644
index 0f15637ff..000000000
--- a/Templates/BaseGame/game/core/gameObjects/shapes/Camera.asset.taml
+++ /dev/null
@@ -1 +0,0 @@
-    constuctorFileName="@assetFile=camera.tscript" />
diff --git a/Templates/BaseGame/game/core/gui/scripts/canvas.tscript b/Templates/BaseGame/game/core/gui/scripts/canvas.tscript
index 5a22d909a..94dde1d84 100644
--- a/Templates/BaseGame/game/core/gui/scripts/canvas.tscript
+++ b/Templates/BaseGame/game/core/gui/scripts/canvas.tscript
@@ -115,7 +115,7 @@ function configureCanvas()
       "--Screen Mode    : " @ %fsLabel NL
       "--Bits Per Pixel : " @ %bpp NL
       "--Refresh Rate   : " @ %rate NL
-      "--FSAA Level     : " @ %aa NL
+      "--FXAA Level     : " @ %aa NL
       "--------------");
 
    // Actually set the new video mode
diff --git a/Templates/BaseGame/game/core/postFX/scripts/DepthOfField/DepthOfFieldPostFX.tscript b/Templates/BaseGame/game/core/postFX/scripts/DepthOfField/DepthOfFieldPostFX.tscript
index 29e1bb117..74feb289d 100644
--- a/Templates/BaseGame/game/core/postFX/scripts/DepthOfField/DepthOfFieldPostFX.tscript
+++ b/Templates/BaseGame/game/core/postFX/scripts/DepthOfField/DepthOfFieldPostFX.tscript
@@ -474,7 +474,7 @@ function DepthOfFieldPostFX::populatePostFXSettings(%this)
 
 function PostEffectEditorInspector::toggleDepthOfFieldPostFX(%this)
 {
-   if($PostFX::DepthOfFieldPostFX::Enabled)
+   if($PostFX::DepthOfFieldPostFX::Enabled && $pref::PostFX::EnableDOF)
       DepthOfFieldPostFX.enable();
    else
       DepthOfFieldPostFX.disable();
@@ -482,7 +482,7 @@ function PostEffectEditorInspector::toggleDepthOfFieldPostFX(%this)
 
 function DepthOfFieldPostFX::applyFromPreset(%this)
 {
-   if($PostFX::DepthOfFieldPostFX::Enabled)
+   if($PostFX::DepthOfFieldPostFX::Enabled && $pref::PostFX::EnableDOF)
       DepthOfFieldPostFX.enable();
    else
       DepthOfFieldPostFX.disable();
diff --git a/Templates/BaseGame/game/core/postFX/scripts/LightRays/lightRays.tscript b/Templates/BaseGame/game/core/postFX/scripts/LightRays/lightRays.tscript
index 9d029b9b0..b6d34da3b 100644
--- a/Templates/BaseGame/game/core/postFX/scripts/LightRays/lightRays.tscript
+++ b/Templates/BaseGame/game/core/postFX/scripts/LightRays/lightRays.tscript
@@ -126,7 +126,7 @@ function LightRayPostFX::populatePostFXSettings(%this)
 
 function PostEffectEditorInspector::toggleLightRayPostFX(%this)
 {
-   if($PostFX::LightRayPostFX::Enabled)
+   if($PostFX::LightRayPostFX::Enabled && $pref::PostFX::EnableLightRays)
       LightRayPostFX.enable();
    else
       LightRayPostFX.disable();
@@ -134,7 +134,7 @@ function PostEffectEditorInspector::toggleLightRayPostFX(%this)
 
 function LightRayPostFX::applyFromPreset(%this)
 {
-   if($PostFX::LightRayPostFX::Enabled)
+   if($PostFX::LightRayPostFX::Enabled && $pref::PostFX::EnableLightRays)
       %this.enable();
    else
       %this.disable();
diff --git a/Templates/BaseGame/game/core/postFX/scripts/SSAO/SSAOPostFx.tscript b/Templates/BaseGame/game/core/postFX/scripts/SSAO/SSAOPostFx.tscript
index 8c95bff7a..c9a5bec3c 100644
--- a/Templates/BaseGame/game/core/postFX/scripts/SSAO/SSAOPostFx.tscript
+++ b/Templates/BaseGame/game/core/postFX/scripts/SSAO/SSAOPostFx.tscript
@@ -165,7 +165,7 @@ function SSAOPostFx::populatePostFXSettings(%this)
 
 function PostEffectEditorInspector::toggleSSAOPostFx(%this)
 {
-   if($PostFX::SSAOPostFx::Enabled)
+   if($PostFX::SSAOPostFx::Enabled && $pref::PostFX::EnableSSAO)
       SSAOPostFx.enable();
    else
       SSAOPostFx.disable();
@@ -173,7 +173,7 @@ function PostEffectEditorInspector::toggleSSAOPostFx(%this)
 
 function SSAOPostFx::applyFromPreset(%this)
 {
-   if($PostFXManager::PostFX::Enable)
+   if($PostFXManager::PostFX::Enable && $pref::PostFX::EnableSSAO)
       %this.enable();
    else
       %this.disable();
diff --git a/Templates/BaseGame/game/core/postFX/scripts/Vignette/VignettePostFX.tscript b/Templates/BaseGame/game/core/postFX/scripts/Vignette/VignettePostFX.tscript
index 014dc6524..414a3d2ef 100644
--- a/Templates/BaseGame/game/core/postFX/scripts/Vignette/VignettePostFX.tscript
+++ b/Templates/BaseGame/game/core/postFX/scripts/Vignette/VignettePostFX.tscript
@@ -91,7 +91,7 @@ function VignettePostFX::populatePostFXSettings(%this)
 //Allow us to easily toggle the postFX and have it respond immediately
 function PostEffectEditorInspector::toggleVignettePostFX(%this)
 {
-   if($PostFX::VignettePostFX::Enabled)
+   if($PostFX::VignettePostFX::Enabled && $pref::PostFX::EnableVignette)
       VignettePostFX.enable();
    else
       VignettePostFX.disable();
@@ -102,7 +102,7 @@ function PostEffectEditorInspector::toggleVignettePostFX(%this)
 //when rendering. This allows us to modify things but still leave room for reverting or temporarily applying them
 function VignettePostFX::applyFromPreset(%this)
 {
-   if($PostFX::VignettePostFX::Enabled)
+   if($PostFX::VignettePostFX::Enabled && $pref::PostFX::EnableVignette)
       %this.enable();
    else
       %this.disable();
diff --git a/Templates/BaseGame/game/core/rendering/Core_Rendering.tscript b/Templates/BaseGame/game/core/rendering/Core_Rendering.tscript
index eb18dfe8a..ae6168dea 100644
--- a/Templates/BaseGame/game/core/rendering/Core_Rendering.tscript
+++ b/Templates/BaseGame/game/core/rendering/Core_Rendering.tscript
@@ -56,11 +56,11 @@ function Core_Rendering::initClient(%this)
    %prefPath = getPrefpath();
    if ( isFile( %prefPath @ "/clientPrefs." @ $TorqueScriptFileExtension ) )
       exec( %prefPath @ "/clientPrefs." @ $TorqueScriptFileExtension );
+      
+   postFXInit();
    
    configureCanvas();
    
-   postFXInit();
-   
    //Autodetect settings if it's our first time
    if($pref::Video::autoDetect)
       AutodetectGraphics();
diff --git a/Templates/BaseGame/game/core/rendering/materials/moon_noglow.asset.taml b/Templates/BaseGame/game/core/rendering/materials/moon_noglow.asset.taml
index 76e9d5d00..b4a853da4 100644
--- a/Templates/BaseGame/game/core/rendering/materials/moon_noglow.asset.taml
+++ b/Templates/BaseGame/game/core/rendering/materials/moon_noglow.asset.taml
@@ -12,7 +12,7 @@
         <Material.Stages>
             <Stages_beginarray
                 DiffuseMapAsset="Core_Rendering:moon_noglow_image"
-                vertColor="1";/>
+                vertColor="1"/>
         </Material.Stages>
     </Material>
 </MaterialAsset>
\ No newline at end of file
diff --git a/Templates/BaseGame/game/core/rendering/materials/moon_noglow.tscript b/Templates/BaseGame/game/core/rendering/materials/moon_noglow.tscript
deleted file mode 100644
index b9e69c0da..000000000
--- a/Templates/BaseGame/game/core/rendering/materials/moon_noglow.tscript
+++ /dev/null
@@ -1,9 +0,0 @@
-//--- OBJECT WRITE BEGIN ---
-singleton Material(moon_noglow) {
-   mapTo="moon_noglow";
-   DiffuseMapAsset = "Core_Rendering:moon_noglow_image";
-   emissive = true;
-   translucent = true;
-   vertColor[ 0 ] = true;
-};
-//--- OBJECT WRITE END ---
diff --git a/Templates/BaseGame/game/core/rendering/materials/moon_noglowMat.asset.taml b/Templates/BaseGame/game/core/rendering/materials/moon_noglowMat.asset.taml
deleted file mode 100644
index afb79ab61..000000000
--- a/Templates/BaseGame/game/core/rendering/materials/moon_noglowMat.asset.taml
+++ /dev/null
@@ -1,14 +0,0 @@
-<MaterialAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="OccluderProxyMaterial"
-    materialDefinitionName="OccluderProxyMaterial"
-    VersionId="1">
-    <Material
-        Name="OccluderProxyMaterial">
-        <Material.Stages>
-            <Stages_beginarray
-                DiffuseMapAsset="ToolsModule:occluderProxyImage_image"/>
-        </Material.Stages>
-    </Material>
-</MaterialAsset>
\ No newline at end of file
diff --git a/Templates/BaseGame/game/core/rendering/materials/moon_wcorona.asset.taml b/Templates/BaseGame/game/core/rendering/materials/moon_wcorona.asset.taml
index d3b29de39..28589fb99 100644
--- a/Templates/BaseGame/game/core/rendering/materials/moon_wcorona.asset.taml
+++ b/Templates/BaseGame/game/core/rendering/materials/moon_wcorona.asset.taml
@@ -1,7 +1,7 @@
 <ImageAsset
     canSave="true"
     canSaveDynamicFields="true"
-    AssetName="moon_wcorona"
+    AssetName="moon_wcorona_image"
     imageFile="@assetFile=moon_wcorona.png"
     UseMips="true"
     isHDRImage="false"
diff --git a/Templates/BaseGame/game/core/rendering/materials/moon_wcoronaMat.asset.taml b/Templates/BaseGame/game/core/rendering/materials/moon_wcoronaMat.asset.taml
index 2db4a12c1..def47b584 100644
--- a/Templates/BaseGame/game/core/rendering/materials/moon_wcoronaMat.asset.taml
+++ b/Templates/BaseGame/game/core/rendering/materials/moon_wcoronaMat.asset.taml
@@ -12,7 +12,7 @@
         <Material.Stages>
             <Stages_beginarray
                 DiffuseMapAsset="Core_Rendering:moon_wcorona_image"
-                vertColor="1";/>
+                vertColor="1"/>
         </Material.Stages>
     </Material>
 </MaterialAsset>
\ No newline at end of file
diff --git a/Templates/BaseGame/game/core/rendering/materials/moon_wglow.tscript b/Templates/BaseGame/game/core/rendering/materials/moon_wglow.tscript
deleted file mode 100644
index ad87ba5a3..000000000
--- a/Templates/BaseGame/game/core/rendering/materials/moon_wglow.tscript
+++ /dev/null
@@ -1,9 +0,0 @@
-//--- OBJECT WRITE BEGIN ---
-singleton Material(moon_wglow) {
-   mapTo="moon_wglow";
-   DiffuseMapAsset = "Core_Rendering:moon_wglow_image";
-   emissive = true;
-   translucent = true;
-   vertColor[ 0 ] = true;
-};
-//--- OBJECT WRITE END ---
diff --git a/Templates/BaseGame/game/core/rendering/materials/moon_wglowMat.asset.taml b/Templates/BaseGame/game/core/rendering/materials/moon_wglowMat.asset.taml
deleted file mode 100644
index afb79ab61..000000000
--- a/Templates/BaseGame/game/core/rendering/materials/moon_wglowMat.asset.taml
+++ /dev/null
@@ -1,14 +0,0 @@
-<MaterialAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="OccluderProxyMaterial"
-    materialDefinitionName="OccluderProxyMaterial"
-    VersionId="1">
-    <Material
-        Name="OccluderProxyMaterial">
-        <Material.Stages>
-            <Stages_beginarray
-                DiffuseMapAsset="ToolsModule:occluderProxyImage_image"/>
-        </Material.Stages>
-    </Material>
-</MaterialAsset>
\ No newline at end of file
diff --git a/Templates/BaseGame/game/core/rendering/shapes/noShapeMat.asset.taml b/Templates/BaseGame/game/core/rendering/shapes/noShapeMat.asset.taml
index 0a2fb3cb1..d9d9b75e7 100644
--- a/Templates/BaseGame/game/core/rendering/shapes/noShapeMat.asset.taml
+++ b/Templates/BaseGame/game/core/rendering/shapes/noShapeMat.asset.taml
@@ -7,7 +7,7 @@
     <Material
         Name="NoShapeMat"
         mapTo="NoShape"
-        translucent="1";
+        translucent="1"
         translucentBlendOp="LerpAlpha";
         castShadows="0">
         <Material.Stages>
diff --git a/Templates/BaseGame/game/data/UI/guis/optionsMenu.gui b/Templates/BaseGame/game/data/UI/guis/optionsMenu.gui
index a8fc2fb1e..84c70072f 100644
--- a/Templates/BaseGame/game/data/UI/guis/optionsMenu.gui
+++ b/Templates/BaseGame/game/data/UI/guis/optionsMenu.gui
@@ -1,296 +1,160 @@
 //--- OBJECT WRITE BEGIN ---
 $guiContent = new GuiControl(OptionsMenu) {
-   position = "0 0";
    extent = "1024 768";
-   minExtent = "8 2";
-   horizSizing = "right";
-   vertSizing = "bottom";
    profile = "GuiDefaultProfile";
-   visible = "1";
-   active = "1";
    tooltipProfile = "GuiToolTipProfile";
-   hovertime = "1000";
    isContainer = "1";
-   canSave = "1";
    canSaveDynamicFields = "1";
+      currentCategory = "Display";
+      optionsCategories = "17177";
       pageTabIndex = "0";
       returnGui = "MainMenuGui";
       tamlReader = "20088";
       tile = "0";
+      unappliedChanges = "17178";
       useVariable = "0";
 
    new GuiControl() {
       position = "48 56";
       extent = "928 655";
-      minExtent = "8 2";
       horizSizing = "aspectCenter";
       vertSizing = "center";
       profile = "GuiDefaultProfile";
-      visible = "1";
-      active = "1";
       tooltipProfile = "GuiToolTipProfile";
-      hovertime = "1000";
       isContainer = "1";
-      canSave = "1";
-      canSaveDynamicFields = "0";
 
       new GuiBitmapBarCtrl() {
-         percent = "100";
-         vertical = "0";
-         flipClip = "0";
          BitmapAsset = "UI:panel_low_image";
-         color = "255 255 255 255";
          position = "0 40";
          extent = "927 618";
-         minExtent = "8 2";
          horizSizing = "width";
-         vertSizing = "bottom";
          profile = "GuiDefaultProfile";
-         visible = "1";
-         active = "1";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
       };
       new GuiBitmapBarCtrl() {
-         percent = "100";
-         vertical = "0";
-         flipClip = "0";
          BitmapAsset = "UI:panel_image";
-         color = "255 255 255 255";
-         position = "0 0";
          extent = "927 40";
-         minExtent = "8 2";
          horizSizing = "width";
-         vertSizing = "bottom";
          profile = "GuiDefaultProfile";
-         visible = "1";
-         active = "1";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
       };
       new GuiTextCtrl() {
          text = "OPTIONS";
-         maxLength = "1024";
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
          position = "22 7";
          extent = "120 28";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
          profile = "MenuHeaderText";
-         visible = "1";
-         active = "1";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
       };
       new GuiTextCtrl(OptionName) {
-         maxLength = "1024";
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
          position = "3 606";
          extent = "293 17";
-         minExtent = "8 2";
          horizSizing = "width";
-         vertSizing = "bottom";
          profile = "MenuSubHeaderText";
-         visible = "1";
-         active = "1";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
       };
       new GuiMLTextCtrl(OptionDescription) {
-         lineSpacing = "2";
-         allowColorChars = "0";
-         maxChars = "-1";
          text = "This is a placeholder text for an option.";
-         useURLMouseCursor = "0";
          position = "3 625";
          extent = "293 14";
-         minExtent = "8 2";
          horizSizing = "width";
-         vertSizing = "bottom";
          profile = "GuiMLTextProfile";
-         visible = "1";
-         active = "1";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
       };
       new GuiSplitContainer() {
-         orientation = "Vertical";
-         splitterSize = "2";
          splitPoint = "250 100";
          fixedPanel = "FirstPanel";
          fixedSize = "250";
-         docking = "None";
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
          position = "0 48";
          extent = "928 555";
-         minExtent = "64 64";
          horizSizing = "width";
-         vertSizing = "bottom";
          profile = "GuiMenuScrollProfile";
-         visible = "1";
-         active = "1";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
 
          new GuiPanel() {
             docking = "Client";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "0 0";
             extent = "248 555";
-            minExtent = "16 16";
-            horizSizing = "right";
-            vertSizing = "bottom";
             profile = "GuiOverlayProfile";
-            visible = "1";
-            active = "1";
             tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "1";
             internalName = "Panel1";
-            canSave = "1";
-            canSaveDynamicFields = "0";
 
             new GuiStackControl(OptionsMenuCategoryList) {
-               stackingType = "Vertical";
-               horizStacking = "Left to Right";
-               vertStacking = "Top to Bottom";
                padding = "10";
                dynamicSize = "0";
-               dynamicNonStackExtent = "0";
-               dynamicPos = "0";
-               changeChildSizeToFit = "1";
-               changeChildPosition = "1";
-               position = "0 0";
                extent = "248 555";
-               minExtent = "16 16";
                horizSizing = "width";
                vertSizing = "height";
                profile = "GuiDefaultProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "GuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "1";
                class = "MenuList";
-               canSave = "1";
-               canSaveDynamicFields = "0";
+
+               new GuiButtonCtrl() {
+                  text = "Display";
+                  extent = "248 35";
+                  profile = "GuiMenuButtonProfile";
+                  command = "populateDisplaySettingsList();";
+                  tooltipProfile = "GuiToolTipProfile";
+               };
+               new GuiButtonCtrl() {
+                  text = "Graphics";
+                  position = "0 45";
+                  extent = "248 35";
+                  profile = "GuiMenuButtonProfile";
+                  command = "populateGraphicsSettingsList();";
+                  tooltipProfile = "GuiToolTipProfile";
+               };
+               new GuiButtonCtrl() {
+                  text = "Audio";
+                  position = "0 90";
+                  extent = "248 35";
+                  profile = "GuiMenuButtonProfile";
+                  command = "populateAudioSettingsList();";
+                  tooltipProfile = "GuiToolTipProfile";
+               };
+               new GuiButtonCtrl() {
+                  text = "Keyboard & Mouse";
+                  position = "0 135";
+                  extent = "248 35";
+                  profile = "GuiMenuButtonProfile";
+                  command = "populateKeyboardMouseSettingsList();";
+                  tooltipProfile = "GuiToolTipProfile";
+               };
+               new GuiButtonCtrl() {
+                  text = "Gamepad";
+                  position = "0 180";
+                  extent = "248 35";
+                  profile = "GuiMenuButtonProfile";
+                  command = "populateGamepadSettingsList();";
+                  tooltipProfile = "GuiToolTipProfile";
+               };
             };
          };
          new GuiPanel() {
             docking = "Client";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
             position = "252 0";
             extent = "676 555";
-            minExtent = "16 16";
-            horizSizing = "right";
-            vertSizing = "bottom";
             profile = "GuiOverlayProfile";
-            visible = "1";
-            active = "1";
             tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "1";
             internalName = "panel2";
-            canSave = "1";
-            canSaveDynamicFields = "0";
 
             new GuiScrollCtrl() {
-               willFirstRespond = "1";
                hScrollBar = "alwaysOff";
                vScrollBar = "dynamic";
-               lockHorizScroll = "0";
-               lockVertScroll = "0";
-               constantThumbHeight = "0";
-               childMargin = "0 0";
-               mouseWheelScrollSpeed = "-1";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
-               anchorTop = "1";
-               anchorBottom = "0";
-               anchorLeft = "1";
-               anchorRight = "0";
-               position = "0 0";
                extent = "676 554";
-               minExtent = "8 2";
                horizSizing = "width";
                vertSizing = "height";
                profile = "GuiMenuScrollProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "GuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "1";
-               canSave = "1";
-               canSaveDynamicFields = "0";
 
                new GuiStackControl(OptionsMenuSettingsList) {
-                  stackingType = "Vertical";
-                  horizStacking = "Left to Right";
-                  vertStacking = "Top to Bottom";
                   padding = "5";
-                  dynamicSize = "1";
-                  dynamicNonStackExtent = "0";
-                  dynamicPos = "0";
                   changeChildSizeToFit = "0";
-                  changeChildPosition = "1";
                   position = "1 1";
                   extent = "661 30";
-                  minExtent = "16 16";
                   horizSizing = "width";
                   vertSizing = "height";
                   profile = "GuiDefaultProfile";
-                  visible = "1";
-                  active = "1";
                   tooltipProfile = "GuiToolTipProfile";
-                  hovertime = "1000";
-                  isContainer = "1";
                   class = "MenuList";
-                  canSave = "1";
-                  canSaveDynamicFields = "0";
                };
             };
          };
@@ -299,130 +163,67 @@ $guiContent = new GuiControl(OptionsMenu) {
    new GuiControl(OptionsButtonHolder) {
       position = "116 711";
       extent = "791 40";
-      minExtent = "8 2";
       horizSizing = "center";
       vertSizing = "top";
       profile = "GuiDefaultProfile";
-      visible = "1";
-      active = "1";
       tooltipProfile = "GuiToolTipProfile";
-      hovertime = "1000";
       isContainer = "1";
       class = "MenuInputButtonContainer";
-      canSave = "1";
-      canSaveDynamicFields = "0";
 
       new GuiIconButtonCtrl() {
-         buttonMargin = "4 4";
-         BitmapAsset = "UI:Keyboard_Black_Return_image";
-         iconLocation = "Left";
-         sizeIconToButton = "1";
-         makeIconSquare = "1";
-         textLocation = "Right";
-         textMargin = "4";
-         autoSize = "0";
-         text = "Apply";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "507 0";
-         extent = "140 40";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "OptionsMenu.apply();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "applyButton";
-         class = "MenuInputButton";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiIconButtonCtrl() {
-         buttonMargin = "4 4";
-         BitmapAsset = "UI:Keyboard_Black_Escape_image";
-         iconLocation = "Left";
-         sizeIconToButton = "1";
-         makeIconSquare = "1";
-         textLocation = "Right";
-         textMargin = "4";
-         autoSize = "0";
-         text = "Back";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "651 0";
-         extent = "140 40";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "OptionsMenu.backOut();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "backButton";
-         class = "MenuInputButton";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiIconButtonCtrl() {
-         buttonMargin = "4 4";
          BitmapAsset = "UI:Keyboard_Black_R_image";
-         iconLocation = "Left";
          sizeIconToButton = "1";
          makeIconSquare = "1";
          textLocation = "Right";
-         textMargin = "4";
-         autoSize = "0";
          text = "Reset";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "325 0";
+         position = "173 0";
          extent = "140 40";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
          profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
          command = "OptionsMenu.resetToDefaults();";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
          internalName = "resetButton";
          class = "MenuInputButton";
-         canSave = "1";
-         canSaveDynamicFields = "0";
+      };
+      new GuiIconButtonCtrl(OptionsMenuSelectButton) {
+         BitmapAsset = "UI:Keyboard_Black_Return_image";
+         sizeIconToButton = "1";
+         makeIconSquare = "1";
+         textLocation = "Right";
+         text = "Select";
+         position = "507 0";
+         extent = "140 40";
+         profile = "GuiMenuButtonProfile";
+         command = "";
+         tooltipProfile = "GuiToolTipProfile";
+         internalName = "SelectButton";
+         class = "MenuInputButton";
+      };
+      new GuiIconButtonCtrl() {
+         BitmapAsset = "UI:Keyboard_Black_Escape_image";
+         sizeIconToButton = "1";
+         makeIconSquare = "1";
+         textLocation = "Right";
+         text = "Back";
+         position = "651 0";
+         extent = "140 40";
+         profile = "GuiMenuButtonProfile";
+         command = "OptionsMenu.backOut();";
+         tooltipProfile = "GuiToolTipProfile";
+         internalName = "backButton";
+         class = "MenuInputButton";
       };
    };
    new GuiInputCtrl(OptionsMenuInputHandler) {
       sendAxisEvents = "1";
       sendBreakEvents = "1";
-      sendModifierEvents = "0";
       ignoreMouseEvents = "1";
-      lockMouse = "0";
       position = "-50 0";
       extent = "10 10";
-      minExtent = "8 2";
       horizSizing = "left";
       vertSizing = "top";
       profile = "GuiInputCtrlProfile";
-      visible = "1";
-      active = "1";
       tooltipProfile = "GuiToolTipProfile";
-      hovertime = "1000";
-      isContainer = "0";
       class = "MenuInputHandler";
-      canSave = "1";
-      canSaveDynamicFields = "0";
    };
 };
 //--- OBJECT WRITE END ---
diff --git a/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript b/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
index 23a09236e..7f36bfc0d 100644
--- a/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
+++ b/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
@@ -55,9 +55,11 @@ function OptionsMenu::onAdd(%this)
    
    if(!isObject(%this.unappliedChanges))
    {
-      %this.unappliedChanges = new ArrayObject();
+      %this.unappliedChanges = new ArrayObject(OptionsMenuUnappliedChanges);
    }  
    
+   %this.currentCategory = "";
+   
    addOptionsMenuCategory("Display", "populateDisplaySettingsList();");
    addOptionsMenuCategory("Graphics", "populateGraphicsSettingsList();");
    addOptionsMenuCategory("Audio", "populateAudioSettingsList();");
@@ -121,12 +123,33 @@ function OptionsMenu::onWake(%this)
 function OptionsButtonHolder::onWake(%this)
 {
    %this-->resetButton.set("btn_back", "R", "Reset", "OptionsMenu.resetToDefaults();");
-   %this-->applyButton.set("btn_start", "Return", "Apply", "OptionsMenu.apply();");
+   %this-->selectButton.set("btn_a", "Return", "Select", "OptionsMenu.select();", true);
    %this-->backButton.set("btn_b", "Escape", "Back", "OptionsMenu.backOut();");
    
    //OptionsMenuCategoryList.getObject(0).performClick();
 }
 
+function OptionsMenu::select(%this)
+{
+   if(OptionsMenuCategoryList.isActiveMenuList())
+   {
+      OptionsMenuSettingsList.setAsActiveMenuList();
+      %this.updateSelectButton();
+   }
+}
+
+function OptionsMenu::updateSelectButton(%this)
+{
+   if(OptionsMenuCategoryList.isActiveMenuList())
+   {
+      %this-->selectButton.setHidden(false);
+   }
+   else if(OptionsMenuSettingsList.isActiveMenuList())
+   {
+      %this-->selectButton.setHidden(true);
+   }
+}
+
 function OptionsMenu::apply(%this)
 {
    //Now we run through our list of unapplied changes and... apply them.
@@ -137,7 +160,7 @@ function OptionsMenu::apply(%this)
    for(%i=0; %i < %this.unappliedChanges.count(); %i++)
    {
       %targetVar = %this.unappliedChanges.getKey(%i);
-      %newValue = %this.unappliedChanges.getValue(%i);
+      %newValue = strReplace(%this.unappliedChanges.getValue(%i), "\"", "");
       
       //First, lets just check through our action map names, see if any match
       %wasKeybind = false;
@@ -245,6 +268,9 @@ function OptionsMenu::apply(%this)
    export("$pref::*", %prefPath @ "/clientPrefs." @ $TorqueScriptFileExtension, false);
    
    OptionsMenu.unappliedChanges.empty();
+   
+   //Now we can back out of the options menu
+   OptionsMenu.doOptionsMenuBackOut();
 }
 
 function OptionsMenu::resetToDefaults(%this)
@@ -252,6 +278,40 @@ function OptionsMenu::resetToDefaults(%this)
    MessageBoxOKCancel("", "This will set the graphical settings back to the auto-detected defaults. Do you wish to continue?", "AutodetectGraphics();", "");
 }
 
+function OptionsMenu::refresh(%this)
+{
+   if(%this.currentCategory !$= "")
+   {
+      %category = %this.optionsCategories.getKey(%this.currentCategory);
+      %command = %this.optionsCategories.getValue(%this.currentCategory);
+      eval(%command);
+   }
+}
+
+function OptionsMenu::getOptionVariableValue(%this, %variableName)
+{
+   %unappliedPrefIndex = %this.unappliedChanges.getIndexFromKey(%variableName);
+   if(%unappliedPrefIndex != -1)
+   {
+      %value = %this.unappliedChanges.getValue(%unappliedPrefIndex);
+      return strreplace(%value, "\"", "");
+   }  
+   
+   return getVariable(%variableName);
+}
+
+function OptionsMenuSelectButton::onVisible(%this, %state)
+{
+   //We're sorta cheating here.
+   //This button should only be displayed when we're in the categories list
+   //so whenever the status changes, such as automatically refreshing due to 
+   //navigation events, we'll just do a quick check to ensure we're 
+   //in the right visibility mode
+   if(%state && OptionsMenuSettingsList.isActiveMenuList())
+   {
+      %this.setHidden(true);
+   }
+}
 //
 //
 //
@@ -308,17 +368,16 @@ function populateDisplaySettingsList()
    else
       OptionsMenuSettingsList.setRowEnabled(1, false);
    
-   %mode = getField($Video::ModeTags, $pref::Video::deviceMode);
+   %mode = OptionsMenu.getOptionVariableValue("$pref::Video::deviceMode");
+   if(isInt(%mode))
+      %mode = getField($Video::ModeTags, $pref::Video::deviceMode);
    OptionsMenuSettingsList.addOptionRow("Window Mode", "$pref::Video::deviceMode", $Video::ModeTags, false, "", true, "", %mode);
    
-   %resolutionList = getScreenResolutionList($pref::Video::deviceId, $pref::Video::deviceMode);
-   OptionsMenuSettingsList.addOptionRow("Resolution", "$pref::Video::Resolution", %resolutionList, false, "onDisplayResChange",  true, "Resolution of the game window", _makePrettyResString( $pref::Video::mode ));
-   
-   //If they're doing borderless, the window resolution must match the display resolution
    if(%mode !$= "Borderless")
-      OptionsMenuSettingsList.setRowEnabled(3, true);
-   else
-      OptionsMenuSettingsList.setRowEnabled(3, false);
+   {
+      %resolutionList = getScreenResolutionList($pref::Video::deviceId, $pref::Video::deviceMode);
+      OptionsMenuSettingsList.addOptionRow("Resolution", "$pref::Video::Resolution", %resolutionList, false, "",  true, "Resolution of the game window", _makePrettyResString( $pref::Video::mode ));
+   }
    
    OptionsMenuSettingsList.addOptionRow("VSync", "$pref::Video::disableVerticalSync", "No\tYes", false, "",  true, "", convertBoolToYesNo(!$pref::Video::disableVerticalSync));
 
@@ -333,27 +392,6 @@ function populateDisplaySettingsList()
    OptionsMenuSettingsList.addSliderRow("Contrast", "", 0.5, 0.1, "0 1", "");
 }
 
-/*function OptionsMenu::applyDisplaySettings(%this)
-{
-	%newDevice = OptionsMenuSettingsList.getCurrentOption(0);
-							
-   // Change the device.
-   if ( %newDevice !$= $pref::Video::displayDevice )
-   {
-      $pref::Video::displayDevice = %newDevice;
-      if( %newDevice !$= getDisplayDeviceInformation() )
-         MessageBoxOK( "Change requires restart", "Please restart the game for a display device change to take effect." );
-         
-      $changingDisplayDevice = %newDevice;
-   }
-   
-   updateDisplaySettings();
-   
-   echo("Exporting client prefs");
-   %prefPath = getPrefpath();
-   export("$pref::*", %prefPath @ "/clientPrefs." @ $TorqueScriptFileExtension, false);
-}*/
-
 //
 //
 //
@@ -394,6 +432,20 @@ function updateDisplaySettings()
    //Update the display settings now
    %deviceName = getDisplayDeviceName();
    %newDeviceID = getWord(%deviceName, 0) - 1;
+   
+   if(!isInt($pref::Video::deviceMode))
+   {
+      //probably saved out as the mode name, so just translate it back
+      for(%i=0; %i < getFieldCount($Video::ModeTags); %i++)
+      {
+         if(getField($Video::ModeTags, %i) $= $pref::Video::deviceMode)
+         {
+            $pref::Video::deviceMode = %i;
+            break;
+         }
+      }
+   }
+   
    %deviceModeName = getField($Video::ModeTags, $pref::Video::deviceMode);
    %newDeviceMode = 0;
    foreach$(%modeName in $Video::ModeTags)
@@ -403,6 +455,14 @@ function updateDisplaySettings()
       else
          %newDeviceMode++;
    }
+   
+   if($pref::Video::deviceMode == $Video::ModeBorderless)
+   {
+      //if we're changing to borderless, we swap to the full resolution of the desktop  
+      $pref::Video::mode = Canvas.getBestCanvasRes($pref::Video::deviceId, $pref::Video::deviceMode);
+      
+      $pref::Video::Resolution = $pref::Video::mode.x SPC $pref::Video::mode.y;
+   }
 
    %newRes = $pref::Video::Resolution;
    %newBpp = 32; // ... its not 1997 anymore.
@@ -448,7 +508,7 @@ function updateDisplaySettings()
 function updatePostFXSettings()
 {
    PostFXManager.settingsEffectSetEnabled(SSAOPostFx, $pref::PostFX::EnableSSAO);
-   PostFXManager.settingsEffectSetEnabled(DOFPostEffect, $pref::PostFX::EnableDOF);
+   PostFXManager.settingsEffectSetEnabled(DepthOfFieldPostFX, $pref::PostFX::EnableDOF);
    PostFXManager.settingsEffectSetEnabled(LightRayPostFX, $pref::PostFX::EnableLightRays);
    PostFXManager.settingsEffectSetEnabled(vignettePostFX, $pref::PostFX::EnableVignette);
 }
@@ -583,13 +643,21 @@ function OptionsMenuList::activateRow(%this)
 
 function OptionsMenu::backOut(%this)
 {
-   if(%this.unappliedChanges.count() != 0)
+   if(OptionsMenuSettingsList.isActiveMenuList())
    {
-      MessageBoxOKCancel("Discard Changes?", "You have unapplied changes to your settings, do you wish to continue?", "OptionsMenu.doOptionsMenuBackOut();", "");
+      OptionsMenuCategoryList.setAsActiveMenuList();
+      %this.updateSelectButton();
    }
    else
    {
-      %this.doOptionsMenuBackOut();
+      if(%this.unappliedChanges.count() != 0)
+      {
+         MessageBoxOKCancel("Discard Changes?", "You have unapplied changes to your settings, do you wish to apply or discard them?", "OptionsMenu.apply();", "OptionsMenu.doOptionsMenuBackOut();", "Apply", "Discard");
+      }
+      else
+      {
+         %this.doOptionsMenuBackOut();
+      }
    }
 }
 
@@ -630,7 +698,7 @@ function OptionsMenuSettingsList::addOptionRow(%this, %label, %targetPrefVar, %o
       %enabled = true;
       
    %optionsRowSize = 30;
-   %optionColumnWidth = %this.extent.x - 450;//todo, calculate off longest option text?
+   %optionColumnWidth = %this.extent.x * 0.3;//todo, calculate off longest option text?
       
    %option = new GuiGameSettingsCtrl() { 
       class = "MenuOptionsButton";
@@ -723,6 +791,7 @@ function OptionsMenuSettingsList::addKeybindRow(%this, %label, %bitmapName, %cal
 //
 function OptionsMenuCategoryList::onNavigate(%this, %index)
 {
+   OptionsMenu.currentCategory = %index;
    %this.getObject(%index).performClick();
 }
 
@@ -750,83 +819,6 @@ function convertBoolToOnOff(%val)
       return "Off";
 }
 
-function onDisplayModeChange(%val)
-{  
-   // The display device (monitor) or screen mode has changed. Refill the
-   // resolution list with only available options.
-   %deviceName = OptionsMenuSettingsList.getCurrentOption(1);
-   %newDeviceID = getWord(%deviceName, 0) - 1;
-   %deviceModeName = OptionsMenuSettingsList.getCurrentOption(2);
-   %newDeviceMode = 0;
-   foreach$(%modeName in $Video::ModeTags)
-   {
-      if (%deviceModeName $= %modeName)
-         break;
-      else
-         %newDeviceMode++;
-   }
-   %resolutionList = getScreenResolutionList(%newDeviceID, %newDeviceMode);
-
-   if (%newDeviceMode == $Video::ModeBorderless)
-   {  // If we're switching to borderless, default to monitor res on Windows OS,
-      // monitor usable area for other platforms.
-      if ($platform $= "windows")
-         %newRes = getWords(Canvas.getMonitorRect(%newDeviceID), 2);
-      else
-         %newRes = getWords(Canvas.getMonitorUsableRect(%newDeviceID), 2);
-   }
-   else
-   {  // Otherwise, if our old resolution is still in the list, attempt to reset it.
-      %oldRes = getWord(OptionsMenuSettingsList.getCurrentOption(3), 0) SPC getWord(OptionsMenuSettingsList.getCurrentOption(3), 2);
-
-      %found = false;
-      %retCount = getFieldCount(%resolutionList);
-      for (%i = 0; %i < %retCount; %i++)
-      {
-         %existingEntry = getField(%resolutionList, %i);
-         if ((%existingEntry.x $= %oldRes.x) && (%existingEntry.z $= %oldRes.y))
-         {
-            %found = true;
-            %newRes = %oldRes;
-            break;  
-         }
-      }
-
-      if (!%found)
-      {  // Pick the best resoltion available for the device and mode
-         %newRes = Canvas.getBestCanvasRes(%newDeviceID, %newDeviceMode);
-      }
-   }
-   
-   if(%newDeviceMode == $Video::ModeBorderless)
-      OptionsMenuSettingsList.setRowEnabled(3, false);
-   else
-      OptionsMenuSettingsList.setRowEnabled(3, true);
-      
-   OptionsMenuSettingsList.setOptions(3, %resolutionList);
-   OptionsMenuSettingsList.selectOption(3, _makePrettyResString(%newRes));
-}
-
-function onDisplayResChange(%val)
-{  // The resolution has changed. Setup refresh rates available at this res.
-   %newRes = getWord(OptionsMenuSettingsList.getCurrentOption(3), 0) SPC getWord(OptionsMenuSettingsList.getCurrentOption(3), 2);
-   %refreshList = getScreenRefreshList(%newRes);
-
-   // If our old rate still exists, select it
-   %oldRate = OptionsMenuSettingsList.getCurrentOption(5);
-   %retCount = getFieldCount(%refreshList);
-   for (%i = 0; %i < %retCount; %i++)
-   {
-      %existingEntry = getField(%refreshList, %i);
-      %newRate = %existingEntry;
-      if (%existingEntry $= %oldRate)
-         break;  
-   }
-
-   OptionsMenuSettingsList.setOptions(5, %refreshList);
-   OptionsMenuSettingsList.selectOption(5, %newRate);
-}
-
 function getDisplayDeviceName()
 {
    %numDevices = Canvas.getMonitorCount();
@@ -880,10 +872,16 @@ function MenuOptionsButton::onChange(%this)
       
       %prefIndex = OptionsMenu.unappliedChanges.getIndexFromKey(%targetVar);
       if(%prefIndex == -1)
-         OptionsMenu.unappliedChanges.add(%targetVar, %saveReadyValue);
+      {
+         echo("Setting UnappliedChanges via add: key:" @ %targetVar @", value: " @ %saveReadyValue);
+         OptionsMenu.unappliedChanges.add(%targetVar, "\"" @ %saveReadyValue @ "\"" );
+      }
       else
-         OptionsMenu.unappliedChanges.setValue(%saveReadyValue, %prefIndex);
+         OptionsMenu.unappliedChanges.setValue("\"" @ %saveReadyValue @ "\"", %prefIndex);
    }
+   
+   //Update the UI in case there's responsive logic
+   schedule(32, OptionsMenu, "refresh");
 }
 
 function OptionsMenu::onKeybindChanged(%this, %actionMap, %keybind)
diff --git a/Templates/BaseGame/game/data/UI/images/groupborder.png b/Templates/BaseGame/game/data/UI/images/group_border.png
similarity index 100%
rename from Templates/BaseGame/game/data/UI/images/groupborder.png
rename to Templates/BaseGame/game/data/UI/images/group_border.png
diff --git a/Templates/BaseGame/game/data/UI/images/group_border_image.asset.taml b/Templates/BaseGame/game/data/UI/images/group_border_image.asset.taml
index 9b2972e84..47e0228bb 100644
--- a/Templates/BaseGame/game/data/UI/images/group_border_image.asset.taml
+++ b/Templates/BaseGame/game/data/UI/images/group_border_image.asset.taml
@@ -2,7 +2,7 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="group_border_image"
-    imageFile="@assetFile=group-border.png"
+    imageFile="@assetFile=group_border.png"
     UseMips="true"
     isHDRImage="false"
     imageType="Albedo" />
diff --git a/Templates/BaseGame/game/data/UI/images/nopreview.png b/Templates/BaseGame/game/data/UI/images/no_preview.png
similarity index 100%
rename from Templates/BaseGame/game/data/UI/images/nopreview.png
rename to Templates/BaseGame/game/data/UI/images/no_preview.png
diff --git a/Templates/BaseGame/game/data/UI/images/no_preview_image.asset.taml b/Templates/BaseGame/game/data/UI/images/no_preview_image.asset.taml
index 1546088dc..56778b0f1 100644
--- a/Templates/BaseGame/game/data/UI/images/no_preview_image.asset.taml
+++ b/Templates/BaseGame/game/data/UI/images/no_preview_image.asset.taml
@@ -2,7 +2,7 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="no_preview_image"
-    imageFile="@assetFile=no-preview.png"
+    imageFile="@assetFile=no_preview.png"
     UseMips="true"
     isHDRImage="false"
     imageType="Albedo" />
diff --git a/Templates/BaseGame/game/data/UI/images/nopreview_image.asset.taml b/Templates/BaseGame/game/data/UI/images/nopreview_image.asset.taml
deleted file mode 100644
index cda718e30..000000000
--- a/Templates/BaseGame/game/data/UI/images/nopreview_image.asset.taml
+++ /dev/null
@@ -1,3 +0,0 @@
-<ImageAsset
-    AssetName="nopreview_image"
-    imageFile="@assetFile=nopreview.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/selectorbutton.png b/Templates/BaseGame/game/data/UI/images/selector_button.png
similarity index 100%
rename from Templates/BaseGame/game/data/UI/images/selectorbutton.png
rename to Templates/BaseGame/game/data/UI/images/selector_button.png
diff --git a/Templates/BaseGame/game/data/UI/images/selectorbuttonblank.png b/Templates/BaseGame/game/data/UI/images/selector_button_blank.png
similarity index 100%
rename from Templates/BaseGame/game/data/UI/images/selectorbuttonblank.png
rename to Templates/BaseGame/game/data/UI/images/selector_button_blank.png
diff --git a/Templates/BaseGame/game/data/UI/images/selector_button_blank_image.asset.taml b/Templates/BaseGame/game/data/UI/images/selector_button_blank_image.asset.taml
index 058b3d4c4..0306109e8 100644
--- a/Templates/BaseGame/game/data/UI/images/selector_button_blank_image.asset.taml
+++ b/Templates/BaseGame/game/data/UI/images/selector_button_blank_image.asset.taml
@@ -2,7 +2,7 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="selector_button_blank_image"
-    imageFile="@assetFile=selector-button-blank.png"
+    imageFile="@assetFile=selector_button_blank.png"
     UseMips="true"
     isHDRImage="false"
     imageType="Albedo" />
diff --git a/Templates/BaseGame/game/data/UI/images/selectorbuttondark.png b/Templates/BaseGame/game/data/UI/images/selector_button_dark.png
similarity index 100%
rename from Templates/BaseGame/game/data/UI/images/selectorbuttondark.png
rename to Templates/BaseGame/game/data/UI/images/selector_button_dark.png
diff --git a/Templates/BaseGame/game/data/UI/images/selector_button_dark_image.asset.taml b/Templates/BaseGame/game/data/UI/images/selector_button_dark_image.asset.taml
index a669fe5d6..06a05c86a 100644
--- a/Templates/BaseGame/game/data/UI/images/selector_button_dark_image.asset.taml
+++ b/Templates/BaseGame/game/data/UI/images/selector_button_dark_image.asset.taml
@@ -2,7 +2,7 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="selector_button_dark_image"
-    imageFile="@assetFile=selector-button-dark.png"
+    imageFile="@assetFile=selector_button_dark.png"
     UseMips="true"
     isHDRImage="false"
     imageType="Albedo" />
diff --git a/Templates/BaseGame/game/data/UI/images/selectorbuttonhighlightonly.png b/Templates/BaseGame/game/data/UI/images/selector_button_highlight_only.png
similarity index 100%
rename from Templates/BaseGame/game/data/UI/images/selectorbuttonhighlightonly.png
rename to Templates/BaseGame/game/data/UI/images/selector_button_highlight_only.png
diff --git a/Templates/BaseGame/game/data/UI/images/selector_button_highlight_only_image.asset.taml b/Templates/BaseGame/game/data/UI/images/selector_button_highlight_only_image.asset.taml
index 96c16617a..b3ad92ca2 100644
--- a/Templates/BaseGame/game/data/UI/images/selector_button_highlight_only_image.asset.taml
+++ b/Templates/BaseGame/game/data/UI/images/selector_button_highlight_only_image.asset.taml
@@ -2,7 +2,7 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="selector_button_highlight_only_image"
-    imageFile="@assetFile=selector-button-highlight-only.png"
+    imageFile="@assetFile=selector_button_highlight_only.png"
     UseMips="true"
     isHDRImage="false"
     imageType="Albedo" />
diff --git a/Templates/BaseGame/game/data/UI/images/selector_button_image.asset.taml b/Templates/BaseGame/game/data/UI/images/selector_button_image.asset.taml
index ffe4338e5..2ddcbb752 100644
--- a/Templates/BaseGame/game/data/UI/images/selector_button_image.asset.taml
+++ b/Templates/BaseGame/game/data/UI/images/selector_button_image.asset.taml
@@ -2,7 +2,7 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="selector_button_image"
-    imageFile="@assetFile=selector-button.png"
+    imageFile="@assetFile=selector_button.png"
     UseMips="true"
     isHDRImage="false"
     imageType="Albedo" />
diff --git a/Templates/BaseGame/game/data/UI/images/selectorbutton_image.asset.taml b/Templates/BaseGame/game/data/UI/images/selectorbutton_image.asset.taml
deleted file mode 100644
index f53884267..000000000
--- a/Templates/BaseGame/game/data/UI/images/selectorbutton_image.asset.taml
+++ /dev/null
@@ -1,3 +0,0 @@
-<ImageAsset
-    AssetName="selectorbutton_image"
-    imageFile="@assetFile=selectorbutton.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/selectorbuttonblank_image.asset.taml b/Templates/BaseGame/game/data/UI/images/selectorbuttonblank_image.asset.taml
deleted file mode 100644
index c3f212a24..000000000
--- a/Templates/BaseGame/game/data/UI/images/selectorbuttonblank_image.asset.taml
+++ /dev/null
@@ -1,3 +0,0 @@
-<ImageAsset
-    AssetName="selectorbuttonblank_image"
-    imageFile="@assetFile=selectorbuttonblank.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/selectorbuttondark_image.asset.taml b/Templates/BaseGame/game/data/UI/images/selectorbuttondark_image.asset.taml
deleted file mode 100644
index 4a24af201..000000000
--- a/Templates/BaseGame/game/data/UI/images/selectorbuttondark_image.asset.taml
+++ /dev/null
@@ -1,3 +0,0 @@
-<ImageAsset
-    AssetName="selectorbuttondark_image"
-    imageFile="@assetFile=selectorbuttondark.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/selectorbuttonhighlightonly_image.asset.taml b/Templates/BaseGame/game/data/UI/images/selectorbuttonhighlightonly_image.asset.taml
deleted file mode 100644
index e359450c4..000000000
--- a/Templates/BaseGame/game/data/UI/images/selectorbuttonhighlightonly_image.asset.taml
+++ /dev/null
@@ -1,3 +0,0 @@
-<ImageAsset
-    AssetName="selectorbuttonhighlightonly_image"
-    imageFile="@assetFile=selectorbuttonhighlightonly.png"/>
diff --git a/Templates/BaseGame/game/data/UI/images/tabborder.png b/Templates/BaseGame/game/data/UI/images/tab_border.png
similarity index 100%
rename from Templates/BaseGame/game/data/UI/images/tabborder.png
rename to Templates/BaseGame/game/data/UI/images/tab_border.png
diff --git a/Templates/BaseGame/game/data/UI/images/tab_border_image.asset.taml b/Templates/BaseGame/game/data/UI/images/tab_border_image.asset.taml
index 9d4db0d2d..c5f250a2d 100644
--- a/Templates/BaseGame/game/data/UI/images/tab_border_image.asset.taml
+++ b/Templates/BaseGame/game/data/UI/images/tab_border_image.asset.taml
@@ -2,7 +2,7 @@
     canSave="true"
     canSaveDynamicFields="true"
     AssetName="tab_border_image"
-    imageFile="@assetFile=tab-border.png"
+    imageFile="@assetFile=tab_border.png"
     UseMips="true"
     isHDRImage="false"
     imageType="Albedo" />
diff --git a/Templates/BaseGame/game/data/UI/images/tabborder_image.asset.taml b/Templates/BaseGame/game/data/UI/images/tabborder_image.asset.taml
deleted file mode 100644
index 0e3102520..000000000
--- a/Templates/BaseGame/game/data/UI/images/tabborder_image.asset.taml
+++ /dev/null
@@ -1,3 +0,0 @@
-<ImageAsset
-    AssetName="tabborder_image"
-    imageFile="@assetFile=tabborder.png"/>
diff --git a/Templates/BaseGame/game/data/UI/scripts/menuInputHandling.tscript b/Templates/BaseGame/game/data/UI/scripts/menuInputHandling.tscript
index 074bb3675..66d6aaf39 100644
--- a/Templates/BaseGame/game/data/UI/scripts/menuInputHandling.tscript
+++ b/Templates/BaseGame/game/data/UI/scripts/menuInputHandling.tscript
@@ -412,6 +412,13 @@ function MenuInputHandler::onInputEvent(%this, %device, %action, %state)
 // Menu List processing
 // These functions manage the navigation and activation of the Menu Lists
 //==============================================================================
+function MenuList::isActiveMenuList(%this)
+{
+   if($activeMenuList == %this)
+      return true;
+   
+   return false;
+}
 
 function MenuList::setAsActiveMenuList(%this, %startPosition, %menuMode)
 {
@@ -485,8 +492,6 @@ function MenuList::navigateDown(%this)
 
 function MenuList::navigateLeft()
 {
-   echo("Menu list navigated left!"); 
-   
    //Atm, we're only handling specific control types, namely options entries, but
    //this could readily be expanded upon to handle grids like for inventory screens
    //or the like
@@ -494,17 +499,54 @@ function MenuList::navigateLeft()
    %btn = $activeMenuList.getObject($activeMenuListPosition.y);
    if(%btn.getClassName() $= "GuiGameSettingsCtrl" && %btn.isEnabled())
    {
-      warnf("MenuList::navigateLeft() - actioned the option" @ %btn @ " to the left");
+      %mode = %btn.getMode();
+      if(%mode == 0) //options list
+      {
+         %optionId = %btn.getCurrentOptionIndex() - 1;
+         %btn.selectOptionByIndex(%optionId);
+         %btn.onChange();
+      }
+      else if(%mode == 1) //slider
+      {
+         %value = %btn.getValue();
+         %adjustedValue = %value - %btn.getIncrement();
+         %minValue = %btn.getRange().x;
+         if(%adjustedValue < %minValue)
+            %adjustedValue = %minValue;
+            
+         %btn.setValue(%adjustedValue);
+         %btn.onChange();
+      }
    }
 }
 
 function MenuList::navigateRight()
 {
-   echo("Menu list navigated right!");  
-   
    %btn = $activeMenuList.getObject($activeMenuListPosition.y);
    if(%btn.getClassName() $= "GuiGameSettingsCtrl" && %btn.isEnabled())
    {
-      warnf("MenuList::navigateLeft() - actioned the option" @ %btn @ " to the left");
+      %mode = %btn.getMode();
+      if(%mode == 0) //options list
+      {
+         %optionId = %btn.getCurrentOptionIndex() + 1;
+         %btn.selectOptionByIndex(%optionId);
+         %btn.onChange();
+      }
+      else if(%mode == 1) //slider
+      {
+         %value = %btn.getValue();
+         %adjustedValue = %value + %btn.getIncrement();
+         %maxValue = %btn.getRange().y;
+         if(%adjustedValue > %maxValue)
+            %adjustedValue = %maxValue;
+            
+         %btn.setValue(%adjustedValue);
+         %btn.onChange();
+      }
    }
 }
+
+function MenuList::getActiveRow(%this)
+{
+   return $activeMenuListPosition.y;
+}
\ No newline at end of file
diff --git a/Templates/BaseGame/game/data/UI/scripts/messageBoxes.tscript b/Templates/BaseGame/game/data/UI/scripts/messageBoxes.tscript
index 403463695..f1c3db40e 100644
--- a/Templates/BaseGame/game/data/UI/scripts/messageBoxes.tscript
+++ b/Templates/BaseGame/game/data/UI/scripts/messageBoxes.tscript
@@ -116,7 +116,7 @@ function MessageBoxOKDlg::onSleep( %this )
    MessageBoxCtrl.originalMenuInputContainer.setActive();
 }
 
-function MessageBoxOKCancel(%title, %message, %callback, %cancelCallback)
+function MessageBoxOKCancel(%title, %message, %callback, %cancelCallback, %okLabelOverride, %cancelLabelOverride)
 {
    Canvas.pushDialog(MessageBoxDlg);
    MessageBoxTitleText.text = %title;
@@ -125,8 +125,18 @@ function MessageBoxOKCancel(%title, %message, %callback, %cancelCallback)
    MessageBoxYNCButtonHolder.hidden = true;
    MessageBoxOKButtonHolder.hidden = true;
    
-   MessageBoxOCButtonHolder-->OKButton.set("btn_a", "Return", "OK", "MessageCallback(MessageBoxDlg,MessageBoxDlg.callback);");
-   MessageBoxOCButtonHolder-->CancelButton.set("btn_b", "Escape", "Cancel", "MessageCallback(MessageBoxDlg,MessageBoxDlg.cancelCallback);");
+   if(%okLabelOverride $= "")
+      %okLabel = "OK";
+   else
+      %okLabel = %okLabelOverride;
+      
+   if(%cancelLabelOverride $= "")
+      %cancelLabel = "Cancel";
+   else
+      %cancelLabel = %cancelLabelOverride;
+   
+   MessageBoxOCButtonHolder-->OKButton.set("btn_a", "Return", %okLabel, "MessageCallback(MessageBoxDlg,MessageBoxDlg.callback);");
+   MessageBoxOCButtonHolder-->CancelButton.set("btn_b", "Escape", %cancelLabel, "MessageCallback(MessageBoxDlg,MessageBoxDlg.cancelCallback);");
 
    MessageBoxCtrl.originalMenuInputContainer = $activeMenuButtonContainer;
    MessageBoxOCButtonHolder.setActive();
diff --git a/Templates/BaseGame/game/tools/assetBrowser/guis/assetBrowser.gui b/Templates/BaseGame/game/tools/assetBrowser/guis/assetBrowser.gui
index e03d27ecb..29c282c5b 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/guis/assetBrowser.gui
+++ b/Templates/BaseGame/game/tools/assetBrowser/guis/assetBrowser.gui
@@ -1089,7 +1089,7 @@ $guiContent = new GuiControl(AssetBrowser) {
          position = "5 588";
          extent = "20 20";
          minExtent = "8 2";
-         horizSizing = "left";
+         horizSizing = "right";
          vertSizing = "top";
          profile = "ToolsGuiDefaultProfile";
          visible = "1";
@@ -1124,13 +1124,14 @@ $guiContent = new GuiControl(AssetBrowser) {
          class = "assetBrowserPreviewSlider";
          canSave = "1";
          canSaveDynamicFields = "0";
+         command = "AssetBrowser-->previewSlider.onMouseDragged();";
       };
       new GuiBitmapCtrl() {
          bitmapAsset = "ToolsModule:larger_image";
          position = "103 588";
          extent = "20 20";
          minExtent = "8 2";
-         horizSizing = "left";
+         horizSizing = "right";
          vertSizing = "top";
          profile = "ToolsGuiDefaultProfile";
          visible = "1";
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/addModuleWindow.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/addModuleWindow.tscript
index ff085835b..2b38b7459 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/addModuleWindow.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/addModuleWindow.tscript
@@ -127,6 +127,8 @@ function AssetBrowserModuleList::refresh(%this)
       %moduleName = %moduleDef.ModuleId;
       %this.add(%moduleName, %i);  
    }
+   
+   %this.sort();
 }
 
 function AssetBrowserSelModuleAddBtn::onClick(%this)
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
index 7d0c1e3da..fd71cba2f 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
@@ -360,6 +360,13 @@ function AssetBrowser::buildAssetPreview( %this, %asset, %moduleName )
    {
       %this.previewData = new ScriptObject();      
    }
+   else
+   {
+      %this.previewData.tooltip = "";
+      %this.previewData.assetName = "";
+      %this.previewData.previewImage = "";
+      %this.previewData.doubleClickCommand = "";
+   }
    
    AssetPreviewArray.empty();
    
@@ -493,8 +500,6 @@ function AssetBrowser::buildAssetPreview( %this, %asset, %moduleName )
    
    %tooltip = %assetName;
    
-   %doubleClickCommand = "AssetBrowser.editAsset( "@%assetDesc@" );";
-   
    %textBottomPad = 20;
    
    %previewButton = new GuiIconButtonCtrl()
@@ -535,6 +540,15 @@ function AssetBrowser::buildAssetPreview( %this, %asset, %moduleName )
    %previewButton.moduleName = %moduleName;
    %previewButton.assetType = %assetType;
    
+   if(%this.selectMode)
+   {
+      %doubleClickCommand = "AssetBrowser.selectAsset( AssetBrowser.selectedAsset );";
+   }
+   else
+   {
+      %doubleClickCommand = "AssetBrowser.editAsset( "@%assetDesc@" );";
+   }
+   
    //Build out the preview
    %buildCommand = %this @ ".build" @ %assetType @ "Preview(\"" @ %assetDesc @ "\"," @ %this.previewData @ ");";
    eval(%buildCommand);
@@ -543,7 +557,9 @@ function AssetBrowser::buildAssetPreview( %this, %asset, %moduleName )
    %tooltip = %this.previewData.tooltip;
    %assetName = %this.previewData.assetName;
    %previewImage = %this.previewData.previewImage;
-   %doubleClickCommand = %this.previewData.doubleClickCommand;
+   
+   if(%this.previewData.doubleClickCommand !$= "")
+      %doubleClickCommand = %this.previewData.doubleClickCommand;
    
    %previewButton.assetName = %assetName;
    %previewButton.moduleName = %moduleName;
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
index 880ff115e..53d102324 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
@@ -507,6 +507,11 @@ function AssetBrowser::buildMaterialAssetPreview(%this, %assetDef, %previewData)
                            "\nAsset Type: Material Asset" @  
                            "\nAsset Definition ID: " @  %assetDef @
                            "\nDefinition Path: " @ %assetDef.getScriptPath();
+                           
+   if(!%this.selectMode)
+   {
+      %previewData.doubleClickCommand = "AssetBrowser.editAsset( "@%assetDef@" );";
+   }
 }
 
 function AssetBrowser::onMaterialAssetEditorDropped(%this, %assetDef, %position)
diff --git a/Templates/BaseGame/game/tools/convexEditor/convexEditor.tscript b/Templates/BaseGame/game/tools/convexEditor/convexEditor.tscript
index deb211fbf..679b3a29d 100644
--- a/Templates/BaseGame/game/tools/convexEditor/convexEditor.tscript
+++ b/Templates/BaseGame/game/tools/convexEditor/convexEditor.tscript
@@ -27,20 +27,3 @@ singleton GuiControlProfile( ConvexEditorProfile )
    fillColor = "192 192 192 192";
    category = "Editor";
 };
-
-singleton GuiControlProfile (GuiDisabledTextEditProfile)
-{
-   opaque = false;   
-   border = 0;
-   bitmap = "./textEdit";
-   borderColor = "255 255 255 200";
-   fontColor = "0 0 0";
-   fontColorHL = "255 255 255";
-   fontColorNA = "128 128 128";
-   textOffset = "4 2";
-   autoSizeWidth = false;
-   autoSizeHeight = false;
-   tab = false;
-   canKeyFocus = false;   
-   category = "Editor";
-};
diff --git a/Templates/BaseGame/game/tools/gui/profiles.ed.tscript b/Templates/BaseGame/game/tools/gui/profiles.ed.tscript
index 2b2cec671..65d068e8a 100644
--- a/Templates/BaseGame/game/tools/gui/profiles.ed.tscript
+++ b/Templates/BaseGame/game/tools/gui/profiles.ed.tscript
@@ -39,7 +39,7 @@ new GuiControlProfile (ToolsGuiDefaultProfile)
    // fill color
    opaque = false;
    fillColor = EditorSettings.value("Theme/tabsColor");
-   fillColorHL = EditorSettings.value("Theme/tabsGLColor");
+   fillColorHL = EditorSettings.value("Theme/tabsHLColor");
    fillColorSEL = EditorSettings.value("Theme/tabsSELColor");
    fillColorNA = EditorSettings.value("Theme/tabsSELColor");
 
@@ -355,7 +355,7 @@ new GuiControlProfile( ToolsGuiButtonProfile )
    opaque = true;
    border = true;
    fillColor = EditorSettings.value("Theme/tabsColor");
-   fillColorHL = EditorSettings.value("Theme/tabsGLColor");
+   fillColorHL = EditorSettings.value("Theme/tabsHLColor");
    fillColorSEL = EditorSettings.value("Theme/tabsSELColor");
    fillColorNA = EditorSettings.value("Theme/tabsSELColor");
    
@@ -1238,3 +1238,20 @@ singleton GuiControlProfile (GuiSimpleBorderProfile)
    border = 1;   
    category = "Editor";
 };
+
+singleton GuiControlProfile (GuiDisabledTextEditProfile)
+{
+   opaque = false;   
+   border = 0;
+   bitmapAsset = "ToolsModule:textEdit_image";
+   borderColor = "255 255 255 200";
+   fontColor = "0 0 0";
+   fontColorHL = "255 255 255";
+   fontColorNA = "128 128 128";
+   textOffset = "4 2";
+   autoSizeWidth = false;
+   autoSizeHeight = false;
+   tab = false;
+   canKeyFocus = false;   
+   category = "Editor";
+};
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/meshRoadEditor/meshRoadEditor.tscript b/Templates/BaseGame/game/tools/meshRoadEditor/meshRoadEditor.tscript
index eee393d87..20561099f 100644
--- a/Templates/BaseGame/game/tools/meshRoadEditor/meshRoadEditor.tscript
+++ b/Templates/BaseGame/game/tools/meshRoadEditor/meshRoadEditor.tscript
@@ -26,21 +26,4 @@ singleton GuiControlProfile( MeshRoadEditorProfile )
    opaque = true;
    fillColor = "192 192 192 192";
    category = "Editor";
-};
-
-singleton GuiControlProfile (GuiDisabledTextEditProfile)
-{
-   opaque = false;   
-   border = 0;
-   bitmap = "./textEdit";
-   borderColor = "255 255 255 200";
-   fontColor = "0 0 0";
-   fontColorHL = "255 255 255";
-   fontColorNA = "128 128 128";
-   textOffset = "4 2";
-   autoSizeWidth = false;
-   autoSizeHeight = false;
-   tab = false;
-   canKeyFocus = false;   
-   category = "Editor";
 };
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/settings.xml b/Templates/BaseGame/game/tools/settings.xml
index b7103a680..08b21038a 100644
--- a/Templates/BaseGame/game/tools/settings.xml
+++ b/Templates/BaseGame/game/tools/settings.xml
@@ -38,6 +38,8 @@
             name="AutoImport">0</Setting>
         <Group
             name="Browser">
+            <Setting
+				name="doubleClickAction">Edit Asset</Setting>
             <Setting
                 name="previewTileSize">1</Setting>
             <Setting
@@ -363,14 +365,10 @@
             name="forceLoadDAE">0</Setting>
         <Setting
             name="forceSidebarToSide">1</Setting>
-        <Setting
-            name="lastEditedLevel">FPSGameplay:EmptyLevel</Setting>
         <Setting
             name="orthoFOV">4.60158</Setting>
         <Setting
             name="orthoShowGrid">1</Setting>
-        <Setting
-            name="recentLevelsList">FPSGameplay:EmptyLevel,FPSGameplay:EmptyTerrain,pbr:PbrMatTestLevel,TTR:DasBootLevel</Setting>
         <Setting
             name="startupMode">Blank Level</Setting>
         <Setting
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
index ef1b9292b..1d1b16bfc 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
@@ -1820,6 +1820,12 @@ function EditorTree::update( %this )
    %this.buildVisibleTree( false );
 }
 
+//------------------------------------------------------------------------------
+function EWTreeWindow::onResize(%this, %posX, %posY, %width, %height )
+{
+    EditorTree.extent.x = %this.extent.x;
+}
+
 //------------------------------------------------------------------------------
 
 // Tooltip for TSStatic

From dff83182e2da7a5655ee3e7b0c774117303fd5e6 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Sun, 27 Mar 2022 03:05:48 -0500
Subject: [PATCH 343/399] Added sanity check to ensure that the requested file
 to be scaled via saveScaledImage actually exists Shifts integration of other
 modules with the OptionsMenu so other modules can inject their own options
 categories to a callOnModules hook Updated ExampleModule to use new options
 menu integration angle to show example option Deleted unneeded
 dropdown_textEdit_image asset def from baseUI Fixed incorrect internal values
 for the terrainIcon_image asset def that made it present as a redundant
 terrain material asset Cleaned up old, bad loadFilters calls and replaced
 them with the proper refresh() calls. Removed old, bad calls for jumping
 through the asset browser's tree from when it was still hardcoded
 organization, which cuts down a lot of error spam Cleaned up some of the
 asset type's preview image assignment code to be more reliable Made terrain
 materials now use a similar preview proxy shape as regular materials Fixed
 erroneous duplicate GuiInspectorTypeShapeAssetPtr::onControlDropped, which
 was breaking drag-n-drop actions of shapeAssets into inspector fields Added
 proper logic for drag-n-drop actions of imageAssets into inspector fields Add
 sanity check after creating new asset to avoid redundant attempts at
 initialization of the new asset Fixed ConvexShape Editor tooling so you can
 now use the UI to apply the selected material to the selected surface Added
 tools menu to the menubar with the Project Importer entry so the PI can be
 launched from either tool Implemented ability to drag-n-drop imageAssets onto
 MaterialEditor map fields and have it work Implemented ability to drag-n-drop
 imageAssets onto TerrainMaterial Editor map fields and have it work Made the
 TerrainMaterial editor dialogue have a non-modal background so you can
 interact with the editor as normal while it's up Add sanity check to avoid
 attempting to mark EditorTree items if we couldn't find it's id renamed
 BaseMap references in terrain material editor to diffuseMap for consistency

---
 Engine/source/gfx/bitmap/gBitmap.cpp          |  5 ++
 .../worldEditor/guiConvexShapeEditorCtrl.cpp  |  2 +-
 .../data/ExampleModule/ExampleModule.tscript  | 11 ++-
 .../game/data/UI/guis/optionsMenu.tscript     |  7 +-
 .../images/dropdown_textEdit_image.asset.taml |  8 --
 .../art/terrainIcon_image.asset.taml          |  4 +-
 .../assetBrowser/scripts/assetBrowser.tscript |  8 +-
 .../scripts/assetTypes/component.tscript      |  7 +-
 .../scripts/assetTypes/cubemap.tscript        |  7 +-
 .../scripts/assetTypes/gameObject.tscript     | 13 +--
 .../scripts/assetTypes/gui.tscript            |  7 +-
 .../scripts/assetTypes/image.tscript          | 19 ++++-
 .../scripts/assetTypes/level.tscript          |  5 --
 .../scripts/assetTypes/material.tscript       | 23 +++---
 .../scripts/assetTypes/shape.tscript          | 17 ++--
 .../scripts/assetTypes/sound.tscript          |  2 +-
 .../scripts/assetTypes/stateMachine.tscript   | 20 +----
 .../assetTypes/terrainMaterial.tscript        | 74 ++++++++++++++++-
 .../assetBrowser/scripts/editAsset.tscript    |  4 +-
 .../assetBrowser/scripts/newAsset.tscript     | 13 +--
 .../convexEditor/convexEditorGui.tscript      |  2 +-
 .../scripts/guiEditorCanvas.ed.tscript        |  9 ++
 .../gui/guiMaterialPropertiesWindow.ed.gui    | 13 +++
 .../scripts/materialEditor.ed.tscript         | 82 ++++++++++++++++++-
 .../gui/guiTerrainMaterialDlg.ed.gui          | 12 +--
 .../worldEditor/scripts/EditorGui.ed.tscript  |  6 +-
 .../interfaces/terrainMaterialDlg.ed.tscript  | 58 +++++++++++--
 27 files changed, 311 insertions(+), 127 deletions(-)
 delete mode 100644 Templates/BaseGame/game/data/UI/images/dropdown_textEdit_image.asset.taml

diff --git a/Engine/source/gfx/bitmap/gBitmap.cpp b/Engine/source/gfx/bitmap/gBitmap.cpp
index ebd3741b1..21e1351f8 100644
--- a/Engine/source/gfx/bitmap/gBitmap.cpp
+++ b/Engine/source/gfx/bitmap/gBitmap.cpp
@@ -1373,6 +1373,11 @@ DefineEngineFunction(saveScaledImage, bool, (const char* bitmapSource, const cha
       return false;
    }
 
+   if (!Platform::isFile(bitmapSource))
+   {
+      return false;
+   }
+
    //First, gotta check the extension, as we have some extra work to do if it's
    //a DDS file
    const char* ret = dStrrchr(bitmapSource, '.');
diff --git a/Engine/source/gui/worldEditor/guiConvexShapeEditorCtrl.cpp b/Engine/source/gui/worldEditor/guiConvexShapeEditorCtrl.cpp
index 9350f39e0..ae1b90df8 100644
--- a/Engine/source/gui/worldEditor/guiConvexShapeEditorCtrl.cpp
+++ b/Engine/source/gui/worldEditor/guiConvexShapeEditorCtrl.cpp
@@ -204,7 +204,7 @@ void GuiConvexEditorCtrl::setVisible( bool val )
 			mConvexHL = NULL;			
 			mFaceHL = -1;
 
-         setSelection( NULL, -1 );
+            setSelection( NULL, -1 );
 
 			WorldEditor *wedit;
 			if ( Sim::findObject( "EWorldEditor", wedit ) )
diff --git a/Templates/BaseGame/game/data/ExampleModule/ExampleModule.tscript b/Templates/BaseGame/game/data/ExampleModule/ExampleModule.tscript
index 0f540c0d8..137067959 100644
--- a/Templates/BaseGame/game/data/ExampleModule/ExampleModule.tscript
+++ b/Templates/BaseGame/game/data/ExampleModule/ExampleModule.tscript
@@ -81,7 +81,6 @@ function ExampleModule::initClient(%this)
       exec(%prefPath @ "/keybinds." @ $TorqueScriptFileExtension);
       
    %this.queueExec("./scripts/inputCommands");
-   addOptionsMenuCategory("Example Options", "testExampleOptions();");
 }
 
 //This is called when a game session client successfuly connects to a game server. 
@@ -108,7 +107,17 @@ function ExampleModule::onDestroyClientConnection(%this)
    ExampleMoveMap.pop();
 }
 
+function ExampleModule::populateOptionsMenuCategories(%this)
+{
+   addOptionsMenuCategory("Example Options", "testExampleOptions();");
+}
+
 function testExampleOptions()
 {
+   OptionsMenuSettingsList.clear();
+   
+   OptionName.setText("");
+   OptionDescription.setText("");
+   
    addListOption("Test Option", "This is a test option", $testOptionValue, "OptionA\tOptionB");  
 }
\ No newline at end of file
diff --git a/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript b/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
index 23a09236e..7fb2cd43d 100644
--- a/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
+++ b/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
@@ -63,6 +63,8 @@ function OptionsMenu::onAdd(%this)
    addOptionsMenuCategory("Audio", "populateAudioSettingsList();");
    addOptionsMenuCategory("Keyboard & Mouse", "populateKeyboardMouseSettingsList();");
    addOptionsMenuCategory("Gamepad", "populateGamepadSettingsList();");
+   
+   callOnModules("populateOptionsMenuCategories", "Game");
 }
 
 function OptionsMenuSettingsList::onAdd(%this)
@@ -900,7 +902,10 @@ function OptionsMenu::onKeybindChanged(%this, %actionMap, %keybind)
 //
 function addOptionsMenuCategory(%categoryName, %selectCallback)
 {
-   OptionsMenu.optionsCategories.add(%categoryName, %selectCallback);
+   //Don't add duplicates!
+   %index = OptionsMenu.optionsCategories.getIndexFromKey(%categoryName);
+   if(%index == -1)
+      OptionsMenu.optionsCategories.add(%categoryName, %selectCallback);
 }
 
 function removeOptionsMenuCategory(%categoryName)
diff --git a/Templates/BaseGame/game/data/UI/images/dropdown_textEdit_image.asset.taml b/Templates/BaseGame/game/data/UI/images/dropdown_textEdit_image.asset.taml
deleted file mode 100644
index 63455e9dd..000000000
--- a/Templates/BaseGame/game/data/UI/images/dropdown_textEdit_image.asset.taml
+++ /dev/null
@@ -1,8 +0,0 @@
-<ImageAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="dropdown_textEdit_image"
-    imageFile="@assetFile=dropdown-textEdit.png"
-    UseMips="true"
-    isHDRImage="false"
-    imageType="Albedo" />
diff --git a/Templates/BaseGame/game/tools/assetBrowser/art/terrainIcon_image.asset.taml b/Templates/BaseGame/game/tools/assetBrowser/art/terrainIcon_image.asset.taml
index 4a6ef4a57..5b7fffc0c 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/art/terrainIcon_image.asset.taml
+++ b/Templates/BaseGame/game/tools/assetBrowser/art/terrainIcon_image.asset.taml
@@ -1,8 +1,8 @@
 <ImageAsset
     canSave="true"
     canSaveDynamicFields="true"
-    AssetName="terrainMaterialIcon_image"
-    imageFile="@assetFile=terrainMaterialIcon.png"
+    AssetName="terrainIcon_image"
+    imageFile="@assetFile=terrainIcon.png"
     UseMips="true"
     isHDRImage="false"
     imageType="Albedo" />
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
index 7d0c1e3da..c99602084 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
@@ -915,13 +915,7 @@ function AssetBrowser::deleteMaterial( %this, %materialName, %secondFilter, %sec
       AssetBrowserPerMan.saveDirty();
    }
       
-   AssetBrowser.preloadFilter();
-}
-
-function AssetBrowser::thumbnailCountUpdate(%this)
-{
-   $Pref::AssetBrowser::ThumbnailCountIndex = AssetBrowser-->materialPreviewCountPopup.getSelected();
-   AssetBrowser.LoadFilter( AssetBrowser.currentFilter, AssetBrowser.currentStaticFilter );
+   AssetBrowser.refresh();
 }
 
 function AssetBrowser::toggleTagFilterPopup(%this)
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/component.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/component.tscript
index 6488b319f..d443157ea 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/component.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/component.tscript
@@ -54,12 +54,7 @@ function AssetBrowser::createComponentAsset(%this)
 	%moduleDef = ModuleDatabase.findModule(%moduleName, 1);
 	AssetDatabase.addDeclaredAsset(%moduleDef, %tamlpath);
 
-	AssetBrowser.loadFilters();
-	
-	%treeItemId = AssetBrowserFilterTree.findItemByName(%moduleName);
-	%smItem = AssetBrowserFilterTree.findChildItemByName(%treeItemId, "ComponentAsset");
-	
-	AssetBrowserFilterTree.onSelect(%smItem);
+	AssetBrowser.refresh();
 	
 	return %tamlpath;
 }
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/cubemap.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/cubemap.tscript
index 78076654b..b050d37cd 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/cubemap.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/cubemap.tscript
@@ -28,12 +28,7 @@ function AssetBrowser::createCubemapAsset(%this)
 	%moduleDef = ModuleDatabase.findModule(%moduleName, 1);
 	AssetDatabase.addDeclaredAsset(%moduleDef, %tamlpath);
 
-	AssetBrowser.loadFilters();
-	
-	%treeItemId = AssetBrowserFilterTree.findItemByName(%moduleName);
-	%smItem = AssetBrowserFilterTree.findChildItemByName(%treeItemId, "CubemapAsset");
-	
-	AssetBrowserFilterTree.onSelect(%smItem);
+	AssetBrowser.refresh();
 	
 	return %tamlpath;
 }
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/gameObject.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/gameObject.tscript
index bdf079ad0..c25eda8f4 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/gameObject.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/gameObject.tscript
@@ -73,21 +73,10 @@ function AssetBrowser::duplicateGameObjectAsset(%this, %assetDef, %targetModule)
 	AssetDatabase.addDeclaredAsset(%moduleDef, %tamlPath);
 
    //Refresh the browser
-	AssetBrowser.loadFilters();
-	
-	//Ensure our context is set
-	%treeItemId = AssetBrowserFilterTree.findItemByName(%targetModule);
-	%smItem = AssetBrowserFilterTree.findChildItemByName(%treeItemId, "GameObjectAsset");
-	
-	AssetBrowserFilterTree.selectItem(%smItem);
+	AssetBrowser.refresh();
 	
 	//Rename it for convenience
 	AssetBrowser.performRenameAsset(%assetName, "New" @ %assetName);
-	
-	//Expand and refresh the target module
-   AssetBrowserFilterTree.expandItem(%treeItemId,true);
-	
-	AssetBrowserFilterTree.buildVisibleTree();
 }
 
 //not used
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/gui.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/gui.tscript
index 4660d56fc..dfebccb47 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/gui.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/gui.tscript
@@ -79,12 +79,7 @@ function AssetBrowser::createGUIAsset(%this)
 	%moduleDef = ModuleDatabase.findModule(%moduleName, 1);
 	AssetDatabase.addDeclaredAsset(%moduleDef, %tamlpath);
 
-	AssetBrowser.loadFilters();
-	
-	%treeItemId = AssetBrowserFilterTree.findItemByName(%moduleName);
-	%smItem = AssetBrowserFilterTree.findChildItemByName(%treeItemId, "GUIs");
-	
-	AssetBrowserFilterTree.onSelect(%smItem);
+	AssetBrowser.refresh();
 	
 	return %tamlpath;  
 }
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/image.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/image.tscript
index f39d35349..0dbebd39b 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/image.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/image.tscript
@@ -233,13 +233,17 @@ function AssetBrowser::buildImageAssetPreview(%this, %assetDef, %previewData)
    
    //Revalidate. If it didn't work, just use the default placeholder one
    if(!isFile(%previewFilePath))
-      %previewAssetName = "ToolsModule:genericAssetIcon_image";
+   {
+      %previewData.previewImage = "ToolsModule:genericAssetIcon_image";
+   }
+   else
+   {
+      %previewData.previewImage = %previewAssetName;
+   }
    
    %previewData.assetName = %assetDef.assetName;
    %previewData.assetPath = %assetDef.scriptFile;
    
-   %previewData.previewImage = %previewAssetName;
-   
    %previewData.assetFriendlyName = %assetDef.assetName;
    %previewData.assetDesc = %assetDef.description;
    
@@ -324,7 +328,14 @@ function GuiInspectorTypeImageAssetPtr::onControlDropped( %this, %payload, %posi
    
    if(%assetType $= "ImageAsset")
    {
-      echo("DROPPED A IMAGE ON AN IMAGE ASSET COMPONENT FIELD!");  
+      %module = %payload.moduleName;
+      %asset = %payload.assetName;
+      
+      %oldValue = %this.targetObject.bitmapAsset;
+      %arrayIndex = "";
+      
+      %targetObject = %this.targetObject;
+      %targetObject.bitmapAsset = %module @ ":" @ %asset; 
    }
    
    EWorldEditor.isDirty = true;
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/level.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/level.tscript
index e46e891c7..23be49e9f 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/level.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/level.tscript
@@ -61,11 +61,6 @@ function AssetBrowser::createLevelAsset(%this)
 
 	AssetBrowser.refresh();
 	
-	%treeItemId = AssetBrowserFilterTree.findItemByName(%moduleName);
-	%smItem = AssetBrowserFilterTree.findChildItemByName(%treeItemId, "Levels");
-	
-	AssetBrowserFilterTree.onSelect(%smItem);
-	
 	return %tamlpath;  
 }
 
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
index 880ff115e..fab16eb90 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
@@ -24,12 +24,7 @@ function AssetBrowser::createMaterialAsset(%this)
    %moduleDef = ModuleDatabase.findModule(%moduleName, 1);
 	AssetDatabase.addDeclaredAsset(%moduleDef, %tamlpath);
 
-	AssetBrowser.loadFilters();
-	
-	%treeItemId = AssetBrowserFilterTree.findItemByName(%moduleName);
-	%smItem = AssetBrowserFilterTree.findChildItemByName(%treeItemId, "Materials");
-	
-	AssetBrowserFilterTree.onSelect(%smItem);
+	AssetBrowser.refresh();
    
 	return %tamlpath;
 }
@@ -428,7 +423,7 @@ function AssetBrowser::importMaterialAsset(%this, %assetItem)
 
 function AssetBrowser::buildMaterialAssetPreview(%this, %assetDef, %previewData)
 {
-   %module = %this.dirHandler.getModuleFromAddress(makeRelativePath(filePath(%assetDef.getScriptPath())));
+   %module = %this.dirHandler.getModuleFromAddress(makeRelativePath(filePath(AssetDatabase.getAssetFilePath(%assetDef.getAssetId()))));
    %previewPath = "tools/resources/previewCache/" @ %module.moduleId @ "/";
 
    if(!IsDirectory(%previewPath))
@@ -460,8 +455,8 @@ function AssetBrowser::buildMaterialAssetPreview(%this, %assetDef, %previewData)
    {
       displayEditorLoadingGui("Generating Material Asset Preview...");
    
-   if(isObject(%assetDef.materialDefinitionName))
-   {
+      if(isObject(%assetDef.materialDefinitionName))
+      {
          %previewShapeDef = AssetDatabase.acquireAsset("ToolsModule:previewSphereShape");
          %generatedFilePath = %previewShapeDef.generateCachedPreviewImage(256, %assetDef.materialDefinitionName);
       
@@ -488,13 +483,17 @@ function AssetBrowser::buildMaterialAssetPreview(%this, %assetDef, %previewData)
    
    //Revalidate. If it didn't work, just use the default placeholder one
    if(!isFile(%previewFilePath))
-      %previewAssetName = "ToolsModule:materialIcon_image";
+   {
+      %previewData.previewImage = "ToolsModule:materialIcon_image";
+   }
+   else
+   {
+      %previewData.previewImage = "ToolsModule:" @ %previewAssetName;
+   }
       
    %previewData.assetName = %assetDef.assetName;
    %previewData.assetPath = %assetDef.scriptFile;
    
-   %previewData.previewImage = "ToolsModule:" @ %previewAssetName;//%assetDef.fileName;
-   
    %previewData.assetFriendlyName = %assetDef.assetName;
    %previewData.assetDesc = %assetDef.description;
 
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
index 7ce0acb1b..15c48079b 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
@@ -26,12 +26,7 @@ function AssetBrowser::createShapeAsset(%this)
 	%moduleDef = ModuleDatabase.findModule(%moduleName, 1);
 	AssetDatabase.addDeclaredAsset(%moduleDef, %tamlpath);
 
-	AssetBrowser.loadFilters();
-	
-	%treeItemId = AssetBrowserFilterTree.findItemByName(%moduleName);
-	%smItem = AssetBrowserFilterTree.findChildItemByName(%treeItemId, "ShapeAsset");
-	
-	AssetBrowserFilterTree.onSelect(%smItem);
+	AssetBrowser.refresh();
 	
 	return %tamlpath;
 }
@@ -302,12 +297,16 @@ function AssetBrowser::buildShapeAssetPreview(%this, %assetDef, %previewData)
    
    //Revalidate. If it didn't work, just use the default placeholder one
    if(!isFile(%previewFilePath))
-      %previewAssetName = "ToolsModule:genericAssetIcon_image";
+   {
+      %previewData.previewImage = "ToolsModule:genericAssetIcon_image";
+   }
+   else
+   {
+      %previewData.previewImage = "ToolsModule:" @ %previewAssetName;
+   }
    
    %previewData.assetName = %assetDef.assetName;
    %previewData.assetPath = %assetDef.fileName;
-
-   %previewData.previewImage = "ToolsModule:" @ %previewAssetName;//%assetDef.fileName;
    
    %previewData.assetFriendlyName = %assetDef.assetName;
    %previewData.assetDesc = %assetDef.description;
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/sound.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/sound.tscript
index 04ab8d508..8cc63bdf4 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/sound.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/sound.tscript
@@ -75,7 +75,7 @@ function AssetBrowser::onSoundAssetEditorDropped(%this, %assetDef, %position)
    
 }
 
-function GuiInspectorTypeShapeAssetPtr::onControlDropped( %this, %payload, %position )
+function GuiInspectorTypeSoundAssetPtr::onControlDropped( %this, %payload, %position )
 {
    Canvas.popDialog(EditorDragAndDropLayer);
    
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/stateMachine.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/stateMachine.tscript
index dff204024..0e9188a97 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/stateMachine.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/stateMachine.tscript
@@ -47,12 +47,7 @@ function AssetBrowser::createStateMachineAsset(%this)
    %moduleDef = ModuleDatabase.findModule(%moduleName, 1);
 	AssetDatabase.addDeclaredAsset(%moduleDef, %tamlpath);
 
-	AssetBrowser.loadFilters();
-	
-	%treeItemId = AssetBrowserFilterTree.findItemByName(%moduleName);
-	%smItem = AssetBrowserFilterTree.findChildItemByName(%treeItemId, "StateMachines");
-	
-	AssetBrowserFilterTree.onSelect(%smItem);
+	AssetBrowser.refresh();
    
 	return %tamlpath;
 }
@@ -123,21 +118,10 @@ function AssetBrowser::duplicateStateMachineAsset(%this, %assetDef)
 	AssetDatabase.addDeclaredAsset(%moduleDef, %tamlPath);
 
    //Refresh the browser
-	AssetBrowser.loadFilters();
-	
-	//Ensure our context is set
-	%treeItemId = AssetBrowserFilterTree.findItemByName(%targetModule);
-	%smItem = AssetBrowserFilterTree.findChildItemByName(%treeItemId, "StateMachineAsset");
-	
-	AssetBrowserFilterTree.selectItem(%smItem);
+	AssetBrowser.refresh();
 	
 	//Rename it for convenience
 	AssetBrowser.performRenameAsset(%assetName, "New" @ %assetName);
-	
-	//Expand and refresh the target module
-   AssetBrowserFilterTree.expandItem(%treeItemId,true);
-	
-	AssetBrowserFilterTree.buildVisibleTree();
 }
 
 function AssetBrowser::renameGameObjectAsset(%this, %assetDef, %newAssetId, %originalName, %newName)
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrainMaterial.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrainMaterial.tscript
index ad1212e11..8fc9e21f9 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrainMaterial.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrainMaterial.tscript
@@ -91,15 +91,85 @@ function AssetBrowser::deleteTerrainMaterialAsset(%this, %assetDef)
 
 function AssetBrowser::buildTerrainMaterialAssetPreview(%this, %assetDef, %previewData)
 {
+   %module = %this.dirHandler.getModuleFromAddress(makeRelativePath(filePath(AssetDatabase.getAssetFilePath(%assetDef.getAssetId()))));
+   %previewPath = "tools/resources/previewCache/" @ %module.moduleId @ "/";
+
+   if(!IsDirectory(%previewPath))
+   {
+      %this.dirHandler.createFolder(%previewPath);
+   }
+
+   %generatePreview = false;
+
+   %previewFilePath = %previewPath @ %assetDef.assetName @ "_Preview.dds";
+   if(!isFile(%previewFilePath))
+   {
+      %generatePreview = true;
+   }
+   else
+   {
+      if(isObject(%assetDef.materialDefinitionName))
+      {
+         if(compareFileTimes(%assetDef.materialDefinitionName.getDiffuseMap(), %previewFilePath) == 1 ||
+            compareFileTimes(%assetDef.materialDefinitionName.getFilename(), %previewFilePath) == 1)
+         %generatePreview = true;
+      }
+   }
+
+   %previewAssetName = %module.moduleId @ "_" @ %assetDef.assetName @ "_PreviewImage";
+                                   
+   if(%generatePreview)
+   {
+      displayEditorLoadingGui("Generating Material Asset Preview...");
+   
+      if(isObject(%assetDef.materialDefinitionName))
+      {
+         %previewShapeDef = AssetDatabase.acquireAsset("ToolsModule:previewSphereShape");
+         %generatedFilePath = %previewShapeDef.generateCachedPreviewImage(256, %assetDef.materialDefinitionName);
+      
+         pathCopy(%generatedFilePath, %previewFilePath);
+         fileDelete(%generatedFilePath);
+
+         %previewAsset = new ImageAsset()
+         {
+            assetName = %previewAssetName;
+            versionId = 1;
+            imageFile = fileName(%previewFilePath);
+         };
+         
+         %previewImgAssetPath = %previewPath @ %previewAsset.assetName @ ".asset.taml";
+         %assetImportSuccessful = TAMLWrite(%previewAsset, %previewImgAssetPath); 
+         
+         %toolsModuleDef = ModuleDatabase.findModule("ToolsModule",1);
+            
+         %success = AssetDatabase.addDeclaredAsset(%toolsModuleDef, %previewImgAssetPath);
+      }
+      
+      hideEditorLoadingGui();
+   }
+   
+   //Revalidate. If it didn't work, just use the default placeholder one
+   if(!isFile(%previewFilePath))
+   {
+      %previewData.previewImage = "ToolsModule:terrainMaterialIcon_image";
+   }
+   else
+   {
+      %previewData.previewImage = "ToolsModule:" @ %previewAssetName;
+   }
+      
    %previewData.assetName = %assetDef.assetName;
    %previewData.assetPath = "";
    %previewData.doubleClickCommand = "";
    
-   %previewData.previewImage = "ToolsModule:terrainMaterialIcon_image";
-   
    %previewData.assetFriendlyName = %assetDef.gameObjectName;
    %previewData.assetDesc = %assetDef.description;
    %previewData.tooltip = %assetDef.gameObjectName;
+   
+   %previewData.tooltip = "Asset Name: " @ %assetDef.assetName @ 
+                           "\nAsset Type: Terrain Material Asset" @  
+                           "\nAsset Definition ID: " @  %assetDef @
+                           "\nDefinition Path: " @ %assetDef.getScriptPath();
 }
 
 function GuiInspectorTypeTerrainMaterialAssetPtr::onClick( %this, %fieldName )
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/editAsset.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/editAsset.tscript
index 4b71d7660..2d088f27a 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/editAsset.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/editAsset.tscript
@@ -163,7 +163,7 @@ function AssetBrowser::performRenameAsset(%this, %originalAssetName, %newName)
    %ModuleItem = AssetBrowser-->filterTree.findItemByName(%moduleName);
 
    // TODO is this correct?
-   %assetType = %ModuleItem.getClassName();
+   /*%assetType = %ModuleItem.getClassName();
 
    %assetTypeId = AssetBrowser-->filterTree.findChildItemByName(%ModuleItem, %assetType);
    
@@ -172,7 +172,7 @@ function AssetBrowser::performRenameAsset(%this, %originalAssetName, %newName)
    %selectedItem = AssetBrowser-->filterTree.getSelectedItem();
    AssetBrowser-->filterTree.scrollVisibleByObjectId(%selectedItem);
    
-   AssetBrowser-->filterTree.buildVisibleTree(); 
+   AssetBrowser-->filterTree.buildVisibleTree();*/ 
 }
 
 function renameAssetFile(%assetDef, %newName)
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/newAsset.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/newAsset.tscript
index f22c6f73d..f2ea27660 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/newAsset.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/newAsset.tscript
@@ -182,11 +182,14 @@ function CreateNewAsset()
 	Canvas.popDialog(AssetBrowser_newAsset);
 	
 	//Load it
-	%moduleDef = ModuleDatabase.findModule(%moduleName,1);
-	AssetDatabase.addDeclaredAsset(%moduleDef, %assetFilePath);
-	//For utilities' sake, we'll acquire it immediately so it can be utilized 
-	//without delay if it's got any script/dependencies stuff
-	AssetDatabase.acquireAsset("\"" @ %moduleName @ ":" @ %assetName @ "\"");
+	if(!AssetDatabase.isDeclaredAsset(%moduleName @ ":" @ %assetName))
+	{
+      %moduleDef = ModuleDatabase.findModule(%moduleName,1);
+      AssetDatabase.addDeclaredAsset(%moduleDef, %assetFilePath);
+      //For utilities' sake, we'll acquire it immediately so it can be utilized 
+      //without delay if it's got any script/dependencies stuff
+      AssetDatabase.acquireAsset("\"" @ %moduleName @ ":" @ %assetName @ "\"");
+	}
 	
 	if(AssetBrowser_newAsset.callbackFunc !$= "")
 	{
diff --git a/Templates/BaseGame/game/tools/convexEditor/convexEditorGui.tscript b/Templates/BaseGame/game/tools/convexEditor/convexEditorGui.tscript
index 09215601a..0baf0eb70 100644
--- a/Templates/BaseGame/game/tools/convexEditor/convexEditorGui.tscript
+++ b/Templates/BaseGame/game/tools/convexEditor/convexEditorGui.tscript
@@ -179,7 +179,7 @@ function ConvexEditorMaterialBtn::gotMaterialName(%this, %name)
 
    ConvexEditorOptionsWindow-->matPreviewBtn.setBitmap(getAssetPreviewImage(%diffusemap));
 
-   ConvexEditorOptionsWindow.activeMaterial = %materialAsset.materialDefinitionName;
+   ConvexEditorOptionsWindow.activeMaterial = %materialAsset.getAssetId();
 }
 
 function ConvexEditorMaterialApplyBtn::onClick(%this)
diff --git a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorCanvas.ed.tscript b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorCanvas.ed.tscript
index f62fe12ea..59df87bd9 100644
--- a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorCanvas.ed.tscript
+++ b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorCanvas.ed.tscript
@@ -186,6 +186,15 @@ function GuiEditCanvas::onCreateMenu(%this)
          item[8] = "Show Guides" TAB "" TAB "GuiEditor.toggleDrawGuides();";
          item[9] = "Clear Guides" TAB "" TAB "GuiEditor.clearGuides();";
       };
+      
+      new PopupMenu()
+      {
+         superClass = "MenuBuilder";
+         barTitle = "Tools";
+         internalName = "ToolsMenu";
+
+         item[0] = "Project Importer" TAB "" TAB "ProjectImporter::beginProjectImport();";
+      };
 
       new PopupMenu()
       {
diff --git a/Templates/BaseGame/game/tools/materialEditor/gui/guiMaterialPropertiesWindow.ed.gui b/Templates/BaseGame/game/tools/materialEditor/gui/guiMaterialPropertiesWindow.ed.gui
index 0f71d8757..d1d46b2b1 100644
--- a/Templates/BaseGame/game/tools/materialEditor/gui/guiMaterialPropertiesWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/materialEditor/gui/guiMaterialPropertiesWindow.ed.gui
@@ -260,6 +260,7 @@ $guiContent = new GuiControl(MaterialEditorGui,EditorGuiGroup) {
                         position = "6 21";
                         Extent = "185 52";
                         HorizSizing = "width";
+                        className = "materialEditorDiffuseMapContainer";
 
                         new GuiBitmapCtrl() {
                            canSaveDynamicFields = "0";
@@ -412,6 +413,7 @@ $guiContent = new GuiControl(MaterialEditorGui,EditorGuiGroup) {
                         position = "6 79";
                         Extent = "185 52";
                         HorizSizing = "width";
+                        className = "materialEditorNormalMapContainer";
                         
                         new GuiBitmapCtrl() {
                            canSaveDynamicFields = "0";
@@ -764,6 +766,7 @@ $guiContent = new GuiControl(MaterialEditorGui,EditorGuiGroup) {
                         position = "6 364";
                         Extent = "185 52";
                         HorizSizing = "width";
+                        className = "materialEditorORMConfigMapContainer";
                         
                         new GuiBitmapCtrl() {
                            canSaveDynamicFields = "0";
@@ -985,6 +988,7 @@ $guiContent = new GuiControl(MaterialEditorGui,EditorGuiGroup) {
 					  isContainer = "1";
 					  canSave = "1";
 					  canSaveDynamicFields = "0";
+					  className = "materialEditorRoughnessMapContainer";
 
 					  new GuiBitmapCtrl() {
 						 bitmapAsset = "ToolsModule:unknownImage_image";
@@ -1221,6 +1225,7 @@ $guiContent = new GuiControl(MaterialEditorGui,EditorGuiGroup) {
 					  isContainer = "1";
 					  canSave = "1";
 					  canSaveDynamicFields = "0";
+					  className = "materialEditorAOMapContainer";
 
 					  new GuiBitmapCtrl() {
 						 bitmapAsset = "ToolsModule:unknownImage_image";
@@ -1457,6 +1462,7 @@ $guiContent = new GuiControl(MaterialEditorGui,EditorGuiGroup) {
 					  isContainer = "1";
 					  canSave = "1";
 					  canSaveDynamicFields = "0";
+					  className = "materialEditorMetalMapContainer";
 
 					  new GuiBitmapCtrl() {
 						 bitmapAsset = "ToolsModule:unknownImage_image";
@@ -1710,6 +1716,8 @@ $guiContent = new GuiControl(MaterialEditorGui,EditorGuiGroup) {
 					  isContainer = "1";
 					  canSave = "1";
 					  canSaveDynamicFields = "0";
+					  className = "materialEditorGlowMapContainer";
+					  
 					  new GuiBitmapCtrl() {
 						 bitmapAsset = "ToolsModule:unknownImage_image";
 						 wrap = "0";
@@ -1945,6 +1953,7 @@ $guiContent = new GuiControl(MaterialEditorGui,EditorGuiGroup) {
                         position = "6 193";
                         Extent = "185 52";
                         HorizSizing = "width";
+                        className = "materialEditorDetailMapContainer";
                         
                         new GuiBitmapCtrl() {
                            canSaveDynamicFields = "0";
@@ -2090,6 +2099,7 @@ $guiContent = new GuiControl(MaterialEditorGui,EditorGuiGroup) {
                         position = "6 136";
                         Extent = "185 52";
                         HorizSizing = "width";
+                        className = "materialEditorDetailNormalMapContainer";
                         
                         new GuiBitmapCtrl() {
                            canSaveDynamicFields = "0";
@@ -2235,6 +2245,7 @@ $guiContent = new GuiControl(MaterialEditorGui,EditorGuiGroup) {
                         position = "6 136";
                         Extent = "185 52";
                         HorizSizing = "width";
+                        className = "materialEditorOverlayMapContainer";
                         
                         new GuiBitmapCtrl() {
                            canSaveDynamicFields = "0";
@@ -2361,6 +2372,7 @@ $guiContent = new GuiControl(MaterialEditorGui,EditorGuiGroup) {
                         position = "6 250";
                         Extent = "185 52";
                         HorizSizing = "width";
+                        className = "materialEditorLightMapContainer";
                         
                         new GuiBitmapCtrl() {
                            canSaveDynamicFields = "0";
@@ -2487,6 +2499,7 @@ $guiContent = new GuiControl(MaterialEditorGui,EditorGuiGroup) {
                         position = "6 307";
                         Extent = "185 52";
                         HorizSizing = "width";
+                        className = "materialEditorToneMapContainer";
                         
                         new GuiBitmapCtrl() {
                            canSaveDynamicFields = "0";
diff --git a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
index d157c817a..de003fdc8 100644
--- a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
@@ -1174,8 +1174,8 @@ function MaterialEditorGui::updateTextureMap( %this, %type, %action )
 function MaterialEditorGui::doUpdateTextureMap( %this, %assetId )
 {
    if(%assetId !$= "")
-{
-   %layer = MaterialEditorGui.currentLayer;
+   {
+      %layer = MaterialEditorGui.currentLayer;
    
       %type = %this.updatingTextureType;
       
@@ -2419,4 +2419,82 @@ function MaterialEditorGui::swapMaterial(%this)
 function MaterialEditorGui::doSwapMaterial(%this, %materialAsset)
 {
    MaterialEditorGui.showMaterialChangeSaveDialog(%materialAsset);
+}
+
+//
+//
+function matEdDragNDropMapAssignment(%type, %payload)
+{
+   %assetType = %payload.assetType;
+   if(%assetType !$= "ImageAsset")
+      return;
+      
+   %module = %payload.moduleName;
+   %assetName = %payload.assetName;
+   %assetId = %module @ ":" @ %assetName;
+   
+   MaterialEditorGui.updatingTextureType = %type;
+   MaterialEditorGui.guiSync( materialEd_previewMaterial );
+   
+   MaterialEditorGui.doUpdateTextureMap( %assetId );
+}
+
+function materialEditorDiffuseMapContainer::onControlDropped( %this, %payload, %position )
+{
+   matEdDragNDropMapAssignment("Diffuse", %payload);
+}
+
+function materialEditorNormalMapContainer::onControlDropped( %this, %payload, %position )
+{
+   matEdDragNDropMapAssignment("Normal", %payload);
+}
+
+function materialEditorORMConfigMapContainer::onControlDropped( %this, %payload, %position )
+{
+   matEdDragNDropMapAssignment("ORMConfig", %payload);
+}
+
+function materialEditorRoughnessMapContainer::onControlDropped( %this, %payload, %position )
+{
+   matEdDragNDropMapAssignment("Roughness", %payload);
+}
+
+function materialEditorAOMapContainer::onControlDropped( %this, %payload, %position )
+{
+   matEdDragNDropMapAssignment("AO", %payload);
+}
+
+function materialEditorMetalMapContainer::onControlDropped( %this, %payload, %position )
+{
+   matEdDragNDropMapAssignment("Metal", %payload);
+}
+
+function materialEditorGlowMapContainer::onControlDropped( %this, %payload, %position )
+{
+   matEdDragNDropMapAssignment("Glow", %payload);
+}
+
+function materialEditorDetailMapContainer::onControlDropped( %this, %payload, %position )
+{
+   matEdDragNDropMapAssignment("Detail", %payload);
+}
+
+function materialEditorDetailNormalMapContainer::onControlDropped( %this, %payload, %position )
+{
+   matEdDragNDropMapAssignment("DetailNormal", %payload);
+}
+
+function materialEditorOverlayMapContainer::onControlDropped( %this, %payload, %position )
+{
+   matEdDragNDropMapAssignment("Overlay", %payload);
+}
+
+function materialEditorLightMapContainer::onControlDropped( %this, %payload, %position )
+{
+   matEdDragNDropMapAssignment("Light", %payload);
+}
+
+function materialEditorToneMapContainer::onControlDropped( %this, %payload, %position )
+{
+   matEdDragNDropMapAssignment("Tone", %payload);
 }
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainMaterialDlg.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainMaterialDlg.ed.gui
index 1a7d1caf1..4eef5308f 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainMaterialDlg.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainMaterialDlg.ed.gui
@@ -5,7 +5,7 @@ $guiContent = new GuiControl(TerrainMaterialDlg,EditorGuiGroup) {
    minExtent = "8 2";
    horizSizing = "right";
    vertSizing = "bottom";
-   profile = "ToolsGuiDefaultProfile";
+   profile = "ToolsGuiDefaultNonModalProfile";
    visible = "1";
    active = "1";
    tooltipProfile = "ToolsGuiToolTipProfile";
@@ -256,7 +256,7 @@ $guiContent = new GuiControl(TerrainMaterialDlg,EditorGuiGroup) {
             canSave = "1";
             canSaveDynamicFields = "0";
          };
-         new GuiContainer(BaseMapContainer) {
+         new GuiContainer(DiffuseMapContainer) {
             margin = "0 0 0 0";
             padding = "0 0 0 0";
             anchorTop = "1";
@@ -312,7 +312,7 @@ $guiContent = new GuiControl(TerrainMaterialDlg,EditorGuiGroup) {
                tooltipProfile = "ToolsGuiToolTipProfile";
                hovertime = "1000";
                isContainer = "0";
-               internalName = "texBaseMap";
+               internalName = "texDiffuseMap";
                canSave = "1";
                canSaveDynamicFields = "0";
             };
@@ -334,7 +334,7 @@ $guiContent = new GuiControl(TerrainMaterialDlg,EditorGuiGroup) {
                profile = "ToolsGuiDefaultProfile";
                visible = "1";
                active = "1";
-               command = "TerrainMaterialDlg.updateTextureMap(\"BaseMap\");";
+               command = "TerrainMaterialDlg.updateTextureMap(\"DiffuseMap\");";
                tooltipProfile = "ToolsGuiDefaultProfile";
                tooltip = "Change the Active Diffuse Map for this layer";
                hovertime = "1000";
@@ -402,7 +402,7 @@ $guiContent = new GuiControl(TerrainMaterialDlg,EditorGuiGroup) {
                profile = "ToolsGuiButtonProfile";
                visible = "1";
                active = "1";
-               command = "TerrainMaterialDlg.updateTextureMap(\"BaseMap\");";
+               command = "TerrainMaterialDlg.updateTextureMap(\"DiffuseMap\");";
                tooltipProfile = "ToolsGuiToolTipProfile";
                hovertime = "1000";
                isContainer = "0";
@@ -427,7 +427,7 @@ $guiContent = new GuiControl(TerrainMaterialDlg,EditorGuiGroup) {
                profile = "ToolsGuiDefaultProfile";
                visible = "1";
                active = "1";
-               command = "TerrainMaterialDlg.clearTextureMap(\"BaseMap\");";
+               command = "TerrainMaterialDlg.clearTextureMap(\"DiffuseMap\");";
                tooltipProfile = "ToolsGuiToolTipProfile";
                hovertime = "1000";
                isContainer = "0";
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
index ef1b9292b..54c7d22b4 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
@@ -2313,11 +2313,13 @@ function EWorldEditor::SetActiveScene(%this, %sceneObj)
    {
       $ActiveEditingScene.isEditing = false;
       %itemId = EditorTree.findItemByObjectId($ActiveScene);
-      EditorTree.markItem(%itemId);
+      if(%itemId != -1)
+         EditorTree.markItem(%itemId);
    }
       
    %itemId = EditorTree.findItemByObjectId(%sceneObj);
-   EditorTree.markItem(%itemId);
+   if(%itemId != -1)
+      EditorTree.markItem(%itemId);
    
    $ActiveEditingScene = %sceneObj;
    $ActiveEditingScene.isEditing = true;
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript
index b49cef39a..fd1063618 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript
@@ -269,27 +269,27 @@ function TerrainMaterialDlg::changeTerrainMatMapAsset(%this)
 
    %imgAsset = AssetBrowser.selectedAsset;
    if(%imgAsset !$= "")
-{   
+   {   
       %targetMap.asset = %imgAsset;
       %image = %imgAsset;
 
       if(%this.updateTargetMap $= "DetailMap")
-   {
+      {
          //show the supplemental maps
          NormalMapContainer.callOnChildren("setActive", true);  
          ORMMapContainer.callOnChildren("setActive", true);
          MacroMapContainer.callOnChildren("setActive", true);
+      }
    }
-}
-      else
+   else
    {
       %image = $TerrainMaterialEditor::emptyMaterialImage;
    }
 
    %targetMap.setBitmap( getAssetPreviewImage(%image) );  
 
-   %targetMapName = %targetMap @ "AssetId";
-   %targetMapName.setText(%imgAsset);
+   %targetMapNameText = %this.findObjectByInternalName(%this.updateTargetMap @ "AssetId", true);
+   %targetMapNameText.setText(%imgAsset);
 
    TerrainMaterialDlg.matDirty = true;
 }
@@ -412,7 +412,7 @@ function TerrainMaterialDlg::setActiveMaterial( %this, %mat )
       %imgPath = %mat.getDiffuseMap();
       %imgPathText = %imgPath !$= "" && %imgPath !$= $TerrainMaterialEditor::emptyMaterialImage ? %mat.getDiffuseMapAsset() : "None";
       %this-->diffuseMapAssetId.setText( %imgPathText );
-      %this-->texBaseMap.setBitmap( getAssetPreviewImage(%imgPath) );
+      %this-->texDiffuseMap.setBitmap( getAssetPreviewImage(%imgPath) );
 
       //
       %imgPath = %mat.getNormalMap();
@@ -487,7 +487,7 @@ function TerrainMaterialDlg::saveDirtyMaterial( %this, %mat )
    
    
    //---
-   %newDiffuse = %this-->texBaseMap.getBitmap();
+   %newDiffuse = %this-->texDiffuseMap.getBitmap();
    if(%newDiffuse $= $TerrainMaterialEditor::emptyMaterialImage || %newDiffuse $= %blankBitmap)
       %newDiffuse = "";
    
@@ -741,3 +741,45 @@ function TerrainMaterialDlgBlendHeightContrastTextEdit::onValidate(%this)
    TerrainMaterialDlg.activeMat.blendHeightContrast = %this.getText();
    TerrainMaterialDlg.matDirty = true;
 }
+
+//
+//
+function terrMatEdDragNDropMapAssignment(%mapName, %payload)
+{
+   %assetType = %payload.assetType;
+   if(%assetType !$= "ImageAsset")
+      return;
+      
+   %module = %payload.moduleName;
+   %assetName = %payload.assetName;
+   %assetId = %module @ ":" @ %assetName;
+   
+   TerrainMaterialDlg.updateTargetMap = %mapName;
+   AssetBrowser.selectedAsset = %assetId;
+   TerrainMaterialDlg.changeTerrainMatMapAsset();
+}
+
+function DiffuseMapContainer::onControlDropped( %this, %payload, %position )
+{
+   terrMatEdDragNDropMapAssignment("DiffuseMap", %payload);
+}
+
+function DetailMapContainer::onControlDropped( %this, %payload, %position )
+{
+   terrMatEdDragNDropMapAssignment("DetailMap", %payload);
+}
+
+function NormalMapContainer::onControlDropped( %this, %payload, %position )
+{
+   terrMatEdDragNDropMapAssignment("NormalMap", %payload);
+}
+
+function ORMMapContainer::onControlDropped( %this, %payload, %position )
+{
+   terrMatEdDragNDropMapAssignment("ORMMap", %payload);
+}
+
+function MacroMapContainer::onControlDropped( %this, %payload, %position )
+{
+   terrMatEdDragNDropMapAssignment("MacroMap", %payload);
+}

From f204a4c646b4a11e987cc2cb8ebef791326315ad Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Sun, 27 Mar 2022 14:09:41 -0500
Subject: [PATCH 344/399] Fixes issue where nested callOnModules would thrash
 the queued exec lists from other invokes Also removes unwanted reference ids
 from the OptionsMenu gui object and disabled the ability for dynamic fields
 to be saved on it to prevent it from happening again.

---
 .../game/core/utility/scripts/module.tscript  | 46 ++++++++++++-------
 .../game/data/UI/guis/optionsMenu.gui         | 10 +---
 2 files changed, 30 insertions(+), 26 deletions(-)

diff --git a/Templates/BaseGame/game/core/utility/scripts/module.tscript b/Templates/BaseGame/game/core/utility/scripts/module.tscript
index 2b102eb9e..ae7f0ce13 100644
--- a/Templates/BaseGame/game/core/utility/scripts/module.tscript
+++ b/Templates/BaseGame/game/core/utility/scripts/module.tscript
@@ -6,7 +6,8 @@ if (!isObject(ExecFilesList))
 function callOnModules(%functionName, %moduleGroup, %var0, %var1, %var2, %var3, %var4, %var5, %var6)
 {   
    //clear per module group file execution chain
-   ExecFilesList.empty();
+   %execArray = new ArrayObject("callOn" @ %functionName @ "_" @ %moduleGroup);
+   ExecFilesList.push_back(%execArray);
    //Get our modules so we can exec any specific client-side loading/handling
    %modulesList = ModuleDatabase.findModules(false);
    for(%i=0; %i < getWordCount(%modulesList); %i++)
@@ -23,12 +24,21 @@ function callOnModules(%functionName, %moduleGroup, %var0, %var1, %var2, %var3,
         %module.scopeSet.call(%functionName, %var0, %var1, %var2, %var3, %var4, %var5, %var6);
    }
    
-   %execFilecount = ExecFilesList.count();
+   %execFilecount = %execArray.count();
+   
+   if($traceModuleCalls)
+   {
+      error("ExecFilesList at actual exec point:");
+      %execArray.echo();
+   }
+   
    for (%i=0;%i<%execFilecount;%i++)
    {
-        %filename = ExecFilesList.getKey(%i);
+        %filename = %execArray.getKey(%i);
         exec(%filename);
    }
+   
+   ExecFilesList.pop_back(); //cleanup
 }
 
 function loadModuleMaterials(%moduleGroup)
@@ -213,7 +223,7 @@ function SimSet::queueExec(%scopeSet, %execFilePath, %isExclusive)
       return;
    }
    
-   if(!isObject(ExecFilesList))
+   if(!isObject(ExecFilesList) || ExecFilesList.count() == 0)
    {
       error("Module::queueExec() - ExecFilesList array object doesn't exist!");
       return;
@@ -225,10 +235,11 @@ function SimSet::queueExec(%scopeSet, %execFilePath, %isExclusive)
    %fullPath = pathConcat(%moduleDef.ModulePath, %execFilePath);
    ///go through all entries
    %locked = false;
-   %execFilecount = ExecFilesList.count();
+   %execFileList = ExecFilesList.getKey(ExecFilesList.count()-1);
+   %execFilecount = %execFileList.count();
    for (%i=0;%i<%execFilecount;%i++)
    {
-        %check = ExecFilesList.getKey(%i);
+        %check = %execFileList.getKey(%i);
         //look for a substring match
         %isMatch = strIsMatchExpr("*"@ strReplace(%execFilePath,"./","/"),%check );
         if (%isMatch)
@@ -237,13 +248,13 @@ function SimSet::queueExec(%scopeSet, %execFilePath, %isExclusive)
             //and kill off any duplicates
             //do note that doing it in this order means setting exclusive twice
             //allows one to override exclusive with exclusive
-            %locked = ExecFilesList.getValue(%i);
+            %locked = %execFileList.getValue(%i);
             if ((%locked && !%isExclusive)&&($reportModuleFileConflicts))
                 error("found" SPC %execFilePath SPC "duplicate file!");
             if (%isExclusive)
             { // Replacing an existing entry, update in-place
-                ExecFilesList.setKey(%fullPath, %i);
-                ExecFilesList.setValue(%isExclusive, %i);
+                %execFileList.setKey(%fullPath, %i);
+                %execFileList.setValue(%isExclusive, %i);
                 %locked = true; //Done, but don't return and bypass trace logging below
             }
             break;
@@ -251,9 +262,9 @@ function SimSet::queueExec(%scopeSet, %execFilePath, %isExclusive)
    }
    //if we're not locked, go ahead and add it to the pile
    if (!%locked)
-       ExecFilesList.add(%fullPath,%isExclusive);
+       %execFileList.add(%fullPath,%isExclusive);
    if ($traceModuleCalls)       
-      ExecFilesList.echo();
+      %execFileList.echo();
 }
 
 function SimSet::unQueueExec(%scopeSet, %execFilePath)
@@ -269,7 +280,7 @@ function SimSet::unQueueExec(%scopeSet, %execFilePath)
       return;
    }
    
-   if(!isObject(ExecFilesList))
+   if(!isObject(ExecFilesList) || ExecFilesList.count() == 0)
    {
       error("Module::unRegisterDatablock() - ExecFilesList array object doesn't exist!");
       return;
@@ -280,23 +291,24 @@ function SimSet::unQueueExec(%scopeSet, %execFilePath)
    %fullPath = pathConcat(%moduleDef.ModulePath, %relativePath);
    ///go through all entries
    %locked = false;
-   %execFilecount = ExecFilesList.count();
+   %execFileList = ExecFilesList.getKey(ExecFilesList.count()-1);
+   %execFilecount = %execFileList.count();
    for (%i=0;%i<%execFilecount;%i++)
    {
-        %check = ExecFilesList.getKey(%i);
+        %check = %execFileList.getKey(%i);
         //look for a substring match
         %isMatch = strIsMatchExpr("*"@ %execFilePath,%check );
         if (%isMatch)
         {
             //check if we're already locked in. if not, kill it.
-            %locked = ExecFilesList.getValue(%i);
+            %locked = %execFileList.getValue(%i);
             if (!%locked)
             {
-                ExecFilesList.erase(%i);
+                %execFileList.erase(%i);
             }
         }
    }
    if ($traceModuleCalls)
-      ExecFilesList.echo();
+      %execFileList.echo();
 }
 
diff --git a/Templates/BaseGame/game/data/UI/guis/optionsMenu.gui b/Templates/BaseGame/game/data/UI/guis/optionsMenu.gui
index 84c70072f..3b1999ed9 100644
--- a/Templates/BaseGame/game/data/UI/guis/optionsMenu.gui
+++ b/Templates/BaseGame/game/data/UI/guis/optionsMenu.gui
@@ -4,15 +4,7 @@ $guiContent = new GuiControl(OptionsMenu) {
    profile = "GuiDefaultProfile";
    tooltipProfile = "GuiToolTipProfile";
    isContainer = "1";
-   canSaveDynamicFields = "1";
-      currentCategory = "Display";
-      optionsCategories = "17177";
-      pageTabIndex = "0";
-      returnGui = "MainMenuGui";
-      tamlReader = "20088";
-      tile = "0";
-      unappliedChanges = "17178";
-      useVariable = "0";
+   canSaveDynamicFields = "0";
 
    new GuiControl() {
       position = "48 56";

From 81aa43a4bd5f1a8807796248ff07787fab7b3751 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Tue, 29 Mar 2022 01:40:07 -0500
Subject: [PATCH 345/399] Fixed formatting to match the standard for
 TerrainMaterialAsset inspector fields Added utility functions to
 TerrainMaterialAsset for getting the material and fx material definitions
 Fixed logical flaw with the initialization code that could cause the
 materialDefinition to be nulled in terrainmaterialassets Fixed layer handling
 in GroundCover to properly work with TerrainMaterialAssets Added logic to
 properly exit out of the onAdd in the event no internal name is assigned or
 if there is a collision. This prevents duplicates from appearing in the terr
 mat editor when creating a new material Fixed issue where going from a
 creator item in the AB to selecting a particular asset type would break the
 filtering because select mode removed collections and creator items, changing
 all the item ids and breaking references. Added sanity check to prevent
 attempting to acquire non-assets in the AB, such as creator entries, which
 would cause console spam Added optional field to provide an override new
 asset name to the New Asset window Added logic so in the event no FX Material
 is found when importing a terrain material, it will create a stub entry so it
 always has one defined Added logic to handle situations where a terrain has a
 reference to an assetId, but the asset does not exist for whatever reason.
 Will prompt to create the missing asset, then continue on with the regular
 saving/editing process as normal Fixed issue where the terrain material
 editor would try and reference the preview images being used in the display
 on the editor instead of the proper assetId itself

---
 .../T3D/assets/TerrainMaterialAsset.cpp       | 146 +++++++-----------
 .../source/T3D/assets/TerrainMaterialAsset.h  |  13 +-
 Engine/source/T3D/fx/groundCover.cpp          |   4 +-
 Engine/source/T3D/fx/groundCover.h            |   2 +-
 Engine/source/terrain/terrMaterial.cpp        |  14 +-
 .../assetBrowser/scripts/assetBrowser.tscript |  35 ++---
 .../assetBrowser/scripts/newAsset.tscript     |   8 +-
 .../pre40/T3Dpre4ProjectImporter.tscript      |   9 ++
 .../interfaces/terrainMaterialDlg.ed.tscript  |  45 ++++--
 9 files changed, 142 insertions(+), 134 deletions(-)

diff --git a/Engine/source/T3D/assets/TerrainMaterialAsset.cpp b/Engine/source/T3D/assets/TerrainMaterialAsset.cpp
index 3ef54d856..043ce6812 100644
--- a/Engine/source/T3D/assets/TerrainMaterialAsset.cpp
+++ b/Engine/source/T3D/assets/TerrainMaterialAsset.cpp
@@ -177,11 +177,6 @@ void TerrainMaterialAsset::initializeAsset()
       return;
    }
 
-   if (mMatDefinitionName == StringTable->insert("DetailBlue"))
-   {
-      bool asdfsd = true;
-   }
-
    if (size() != 0 && mScriptPath == StringTable->EmptyString())
    {
       mLoadedState = EmbeddedDefinition;
@@ -267,18 +262,20 @@ void TerrainMaterialAsset::loadMaterial()
       {
          for (U32 i = 0; i < size(); i++)
          {
-            mMaterialDefinition = dynamic_cast<TerrainMaterial*>(getObject(i));
-            if (mMaterialDefinition)
+            TerrainMaterial* terrMat =  dynamic_cast<TerrainMaterial*>(getObject(i));
+            if (terrMat)
             {
+               mMaterialDefinition = terrMat;
                mLoadedState = Ok;
                mMaterialDefinition->setInternalName(getAssetId());
                continue;
             }
 
             //Otherwise, check if it's our FX material
-            mFXMaterialDefinition = dynamic_cast<Material*>(getObject(i));
-            if (mFXMaterialDefinition)
+            Material* fxMat = dynamic_cast<Material*>(getObject(i));
+            if (fxMat)
             {
+               mFXMaterialDefinition = fxMat;
                //mMaterialDefinition->setInternalName(getAssetId());
                mFXMaterialDefinition->reload();
                continue;
@@ -286,6 +283,9 @@ void TerrainMaterialAsset::loadMaterial()
 
          }
       }
+
+      if(mLoadedState == Ok)
+         return;
    }
    else if ((mLoadedState == ScriptLoaded || mLoadedState == DefinitionAlreadyExists) && mMatDefinitionName != StringTable->EmptyString())
    {
@@ -460,6 +460,28 @@ DefineEngineMethod(TerrainMaterialAsset, getScriptPath, const char*, (), ,
 {
    return object->getScriptPath();
 }
+
+DefineEngineMethod(TerrainMaterialAsset, getMaterialDefinition, S32, (), ,
+   "Queries the Asset Database to see if any asset exists that is associated with the provided material name.\n"
+   "@return The AssetId of the associated asset, if any.")
+{
+   SimObjectPtr<TerrainMaterial> mat = object->getMaterialDefinition();
+   if (mat.isValid())
+      return mat->getId();
+   else
+      return 0;
+}
+
+DefineEngineMethod(TerrainMaterialAsset, getFXMaterialDefinition, S32, (), ,
+   "Queries the Asset Database to see if any asset exists that is associated with the provided material name.\n"
+   "@return The AssetId of the associated asset, if any.")
+{
+   SimObjectPtr<Material> mat = object->getFXMaterialDefinition();
+   if (mat.isValid())
+      return mat->getId();
+   else
+      return 0;
+}
 #endif
 //-----------------------------------------------------------------------------
 // GuiInspectorTypeAssetId
@@ -483,68 +505,36 @@ void GuiInspectorTypeTerrainMaterialAssetPtr::consoleInit()
 GuiControl* GuiInspectorTypeTerrainMaterialAssetPtr::constructEditControl()
 {
    // Create base filename edit controls
-   mUseHeightOverride = true;
-   mHeightOverride = 100;
-
-   mMatEdContainer = new GuiControl();
-   mMatEdContainer->registerObject();
-
-   addObject(mMatEdContainer);
-
-   // Create "Open in ShapeEditor" button
-   mMatPreviewButton = new GuiBitmapButtonCtrl();
-
-   const char* matAssetId = getData();
-
-   TerrainMaterialAsset* matAsset = AssetDatabase.acquireAsset< TerrainMaterialAsset>(matAssetId);
-
-   TerrainMaterial* materialDef = nullptr;
-
-   char bitmapName[512] = "ToolsModule:material_editor_n_image";
-
-   /*if (!Sim::findObject(matAsset->getMaterialDefinitionName(), materialDef))
-   {
-      Con::errorf("GuiInspectorTypeTerrainMaterialAssetPtr::constructEditControl() - unable to find material in asset");
-   }
-   else
-   {
-      mMatPreviewButton->setBitmap(materialDef->mDiffuseMapFilename[0]);
-   }*/
-
-   mMatPreviewButton->setPosition(0, 0);
-   mMatPreviewButton->setExtent(100,100);
+   GuiControl* retCtrl = Parent::constructEditControl();
+   if (retCtrl == NULL)
+      return retCtrl;
 
    // Change filespec
    char szBuffer[512];
-   dSprintf(szBuffer, sizeof(szBuffer), "AssetBrowser.showDialog(\"TerrainMaterialAsset\", \"AssetBrowser.changeAsset\", %d, %s);",
+   dSprintf(szBuffer, sizeof(szBuffer), "AssetBrowser.showDialog(\"TerrainMaterialAsset\", \"AssetBrowser.changeAsset\", %s, %s);",
       mInspector->getIdString(), mCaption);
-   mMatPreviewButton->setField("Command", szBuffer);
+   mBrowseButton->setField("Command", szBuffer);
 
-   mMatPreviewButton->setDataField(StringTable->insert("Profile"), NULL, "GuiButtonProfile");
-   mMatPreviewButton->setDataField(StringTable->insert("tooltipprofile"), NULL, "GuiToolTipProfile");
-   mMatPreviewButton->setDataField(StringTable->insert("hovertime"), NULL, "1000");
+   setDataField(StringTable->insert("targetObject"), NULL, mInspector->getInspectObject()->getIdString());
 
-   StringBuilder strbld;
-   strbld.append(matAsset->getMaterialDefinitionName());
-   strbld.append("\n");
-   strbld.append("Open this asset in the Material Editor");
+   // Create "Open in Editor" button
+   mEditButton = new GuiBitmapButtonCtrl();
 
-   mMatPreviewButton->setDataField(StringTable->insert("tooltip"), NULL, strbld.data());
+   dSprintf(szBuffer, sizeof(szBuffer), "AssetBrowser.editAsset(%d.getText());", retCtrl->getId());
+   mEditButton->setField("Command", szBuffer);
 
-   _registerEditControl(mMatPreviewButton);
-   //mMatPreviewButton->registerObject();
-   mMatEdContainer->addObject(mMatPreviewButton);
+   char bitmapName[512] = "ToolsModule:material_editor_n_image";
+   mEditButton->setBitmap(StringTable->insert(bitmapName));
 
-   mMatAssetIdTxt = new GuiTextEditCtrl();
-   mMatAssetIdTxt->registerObject();
-   mMatAssetIdTxt->setActive(false);
+   mEditButton->setDataField(StringTable->insert("Profile"), NULL, "GuiButtonProfile");
+   mEditButton->setDataField(StringTable->insert("tooltipprofile"), NULL, "GuiToolTipProfile");
+   mEditButton->setDataField(StringTable->insert("hovertime"), NULL, "1000");
+   mEditButton->setDataField(StringTable->insert("tooltip"), NULL, "Open this asset in the Terrain Material Editor");
 
-   mMatAssetIdTxt->setText(matAssetId);
+   mEditButton->registerObject();
+   addObject(mEditButton);
 
-   mMatAssetIdTxt->setBounds(100, 0, 150, 18);
-   mMatEdContainer->addObject(mMatAssetIdTxt);
-
-   return mMatEdContainer;
+   return retCtrl;
 }
 
 bool GuiInspectorTypeTerrainMaterialAssetPtr::updateRects()
@@ -558,45 +548,21 @@ bool GuiInspectorTypeTerrainMaterialAssetPtr::updateRects()
    mEditCtrlRect.set(fieldExtent.x - dividerPos + dividerMargin, 1, dividerPos - dividerMargin - 34, fieldExtent.y);
 
    bool resized = mEdit->resize(mEditCtrlRect.point, mEditCtrlRect.extent);
-
-   if (mMatEdContainer != nullptr)
+   if (mBrowseButton != NULL)
    {
-      mMatPreviewButton->resize(mEditCtrlRect.point, mEditCtrlRect.extent);
+      mBrowseRect.set(fieldExtent.x - 32, 2, 14, fieldExtent.y - 4);
+      resized |= mBrowseButton->resize(mBrowseRect.point, mBrowseRect.extent);
    }
 
-   if (mMatPreviewButton != nullptr)
+   if (mEditButton != NULL)
    {
-      mMatPreviewButton->resize(Point2I::Zero, Point2I(100, 100));
-   }
-
-   if (mMatAssetIdTxt != nullptr)
-   {
-      mMatAssetIdTxt->resize(Point2I(100, 0), Point2I(mEditCtrlRect.extent.x - 100, 18));
+      RectI shapeEdRect(fieldExtent.x - 16, 2, 14, fieldExtent.y - 4);
+      resized |= mEditButton->resize(shapeEdRect.point, shapeEdRect.extent);
    }
 
    return resized;
 }
 
-void GuiInspectorTypeTerrainMaterialAssetPtr::setMaterialAsset(String assetId)
-{
-   mTargetObject->setDataField(mCaption, "", assetId);
-
-   //force a refresh
-   SimObject* obj = mInspector->getInspectObject();
-   mInspector->inspectObject(obj);
-}
-
-DefineEngineMethod(GuiInspectorTypeTerrainMaterialAssetPtr, setMaterialAsset, void, (String assetId), (""),
-   "Gets a particular shape animation asset for this shape.\n"
-   "@param animation asset index.\n"
-   "@return Shape Animation Asset.\n")
-{
-   if (assetId == String::EmptyString)
-      return;
-
-   return object->setMaterialAsset(assetId);
-}
-
 IMPLEMENT_CONOBJECT(GuiInspectorTypeTerrainMaterialAssetId);
 
 ConsoleDocClass(GuiInspectorTypeTerrainMaterialAssetId,
diff --git a/Engine/source/T3D/assets/TerrainMaterialAsset.h b/Engine/source/T3D/assets/TerrainMaterialAsset.h
index dfa3c3ef1..86b6bc718 100644
--- a/Engine/source/T3D/assets/TerrainMaterialAsset.h
+++ b/Engine/source/T3D/assets/TerrainMaterialAsset.h
@@ -94,6 +94,8 @@ public:
    StringTableEntry getMaterialDefinitionName() { return mMatDefinitionName; }
    SimObjectPtr<TerrainMaterial> getMaterialDefinition() { return mMaterialDefinition; }
 
+   SimObjectPtr<Material> getFXMaterialDefinition() { return mFXMaterialDefinition; }
+
    void                    setScriptFile(const char* pScriptFile);
    inline StringTableEntry getScriptFile(void) const { return mScriptFile; };
 
@@ -127,26 +129,23 @@ protected:
 };
 
 DefineConsoleType(TypeTerrainMaterialAssetPtr, TerrainMaterialAsset)
-DefineConsoleType(TypeMaterialAssetId, String)
+DefineConsoleType(TypeTerrainMaterialAssetId, String)
 
 //-----------------------------------------------------------------------------
 // TypeAssetId GuiInspectorField Class
 //-----------------------------------------------------------------------------
-class GuiInspectorTypeTerrainMaterialAssetPtr : public GuiInspectorField
+class GuiInspectorTypeTerrainMaterialAssetPtr : public GuiInspectorTypeFileName
 {
-   typedef GuiInspectorField Parent;
+   typedef GuiInspectorTypeFileName Parent;
 public:
 
-   GuiControl*       mMatEdContainer;
-   GuiBitmapButtonCtrl  *mMatPreviewButton;
-   GuiTextEditCtrl *mMatAssetIdTxt;
+   GuiBitmapButtonCtrl* mEditButton;
 
    DECLARE_CONOBJECT(GuiInspectorTypeTerrainMaterialAssetPtr);
    static void consoleInit();
 
    virtual GuiControl* constructEditControl();
    virtual bool updateRects();
-   void setMaterialAsset(String assetId);
 };
 class GuiInspectorTypeTerrainMaterialAssetId : public GuiInspectorTypeTerrainMaterialAssetPtr
 {
diff --git a/Engine/source/T3D/fx/groundCover.cpp b/Engine/source/T3D/fx/groundCover.cpp
index a9c975eec..e6d354d76 100644
--- a/Engine/source/T3D/fx/groundCover.cpp
+++ b/Engine/source/T3D/fx/groundCover.cpp
@@ -50,6 +50,7 @@
 #include "renderInstance/renderDeferredMgr.h"
 #include "console/engineAPI.h"
 #include "T3D/assets/MaterialAsset.h"
+#include "T3D/assets/TerrainMaterialAsset.h"
 
 /// This is used for rendering ground cover billboards.
 GFXImplementVertexFormat( GCVertex )
@@ -564,7 +565,7 @@ void GroundCover::initPersistFields()
          addField("shapeFilename", TypeFilename, Offset(mShapeName, GroundCover), MAX_COVERTYPES, "The cover shape filename. [Optional]", AbstractClassRep::FIELD_HideInInspectors);
          INITPERSISTFIELD_SHAPEASSET_ARRAY(Shape, MAX_COVERTYPES, GroundCover, "The cover shape. [Optional]");
 
-         addField( "layer",         TypeTerrainMaterialName, Offset( mLayer, GroundCover ), MAX_COVERTYPES, "Terrain material name to limit coverage to, or blank to not limit." );
+         addField( "layer",         TypeTerrainMaterialAssetId, Offset( mLayer, GroundCover ), MAX_COVERTYPES,      "Terrain material assetId to limit coverage to, or blank to not limit." );
 
          addField( "invertLayer",   TypeBool,      Offset( mInvertLayer, GroundCover ), MAX_COVERTYPES,     "Indicates that the terrain material index given in 'layer' is an exclusion mask." );
 
@@ -1178,6 +1179,7 @@ GroundCoverCell* GroundCover::_generateCell( const Point2I& index,
       const bool typeIsShape = mShapeInstances[ type ] != NULL;
       const Box3F typeShapeBounds = typeIsShape ? mShapeInstances[ type ]->getShape()->mBounds : Box3F();
       const F32 typeWindScale = mWindScale[type];
+
       StringTableEntry typeLayer = mLayer[type];
       const bool typeInvertLayer = mInvertLayer[type];
 
diff --git a/Engine/source/T3D/fx/groundCover.h b/Engine/source/T3D/fx/groundCover.h
index aba467810..906a96a7e 100644
--- a/Engine/source/T3D/fx/groundCover.h
+++ b/Engine/source/T3D/fx/groundCover.h
@@ -312,7 +312,7 @@ protected:
    /// The maximum world space elevation for placement.
    F32 mMaxElevation[MAX_COVERTYPES];
 
-   /// Terrain material name to limit coverage to, or
+   /// Terrain material assetId to limit coverage to, or
    /// left empty to cover entire terrain.
    StringTableEntry mLayer[MAX_COVERTYPES];
 
diff --git a/Engine/source/terrain/terrMaterial.cpp b/Engine/source/terrain/terrMaterial.cpp
index 289c9a16f..b25cf02b9 100644
--- a/Engine/source/terrain/terrMaterial.cpp
+++ b/Engine/source/terrain/terrMaterial.cpp
@@ -137,13 +137,19 @@ bool TerrainMaterial::onAdd()
    SimSet *set = Sim::getTerrainMaterialSet();
 
    // Make sure we have an internal name set.
-   if ( !mInternalName || !mInternalName[0] )
-      Con::warnf( "TerrainMaterial::onAdd() - No internal name set!" );
+   if (!mInternalName || !mInternalName[0])
+   {
+      Con::warnf("TerrainMaterial::onAdd() - No internal name set!");
+      return false;
+   }
    else
    {
       SimObject *object = set->findObjectByInternalName( mInternalName );
-      if ( object )
-         Con::warnf( "TerrainMaterial::onAdd() - Internal name collision; '%s' already exists!", mInternalName );
+      if (object)
+      {
+         Con::warnf("TerrainMaterial::onAdd() - Internal name collision; '%s' already exists!", mInternalName);
+         return false;
+      }
    }  
 
    set->addObject( this );
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
index cf331ac74..fc3e3576c 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
@@ -639,9 +639,18 @@ function AssetBrowser::loadDirectories( %this )
    %dataItem = AssetBrowser-->filterTree.insertItem(AssetBrowser-->filterTree.modulesIdx, "data");
    AssetBrowser-->filterTree.tagsIdx = AssetBrowser-->filterTree.insertItem(1, "Tags");
    
-   if(!%this.selectMode)
       AssetBrowser-->filterTree.creatorIdx = AssetBrowser-->filterTree.insertItem(1, "Creator");
    
+   AssetBrowser-->filterTree.clearSelection();
+      
+   if(%this.selectMode)
+   {
+      AssetBrowser-->filterTree.addSelection(AssetBrowser-->filterTree.collectionsIdx);
+      AssetBrowser-->filterTree.addSelection(AssetBrowser-->filterTree.creatorIdx);
+      
+      AssetBrowser-->filterTree.hideSelection();
+   }
+   
    %this.dirHandler.loadFolders("data", %dataItem);
    
    %this.loadCollectionSets();
@@ -750,20 +759,6 @@ function AssetBrowser::loadDirectories( %this )
 
 function AssetBrowser::updateSelection( %this, %asset, %moduleName )
 {
-   /*%isAssetBorder = 0;
-   eval("%isAssetBorder = isObject(AssetBrowser-->"@%asset@"Border);");
-   if( %isAssetBorder )
-   {
-      eval( "AssetBrowser-->"@%asset@"Border.setStateOn(1);");
-   }
-      
-   %isAssetBorderPrevious = 0;
-   eval("%isAssetBorderPrevious = isObject(AssetBrowser-->"@%this.prevSelectedMaterialHL@"Border);");
-   if( %isAssetBorderPrevious )
-   {
-      eval( "AssetBrowser-->"@%this.prevSelectedMaterialHL@"Border.setStateOn(0);");
-   }*/
-   
    //If we had an existing selected assetDef, clear the reference
    if(isObject(AssetBrowser.selectedAssetDef))
       AssetDatabase.releaseAsset(AssetBrowser.selectedAssetDef.getAssetId());
@@ -775,11 +770,13 @@ function AssetBrowser::updateSelection( %this, %asset, %moduleName )
    if(strstr(%moduleName, "/") != -1)
       return;
       
-   //Otherwise, it's an asset so we'll select the definition while we're at it
+   //Check if this is an actual assetId, or if it's just a programmatic reference
+   //like what we use for the creator entries
+   if(AssetDatabase.isDeclaredAsset(AssetBrowser.selectedAsset))
+   {
+      //Looks good, it's an asset so we'll select the definition while we're at it
    AssetBrowser.selectedAssetDef = AssetDatabase.acquireAsset(AssetBrowser.selectedAsset);
-   //AssetBrowser.selectedPreviewImagePath = %previewImagePath;
-   
-   //%this.prevSelectedMaterialHL = %asset;
+   }
 }
 
 function AssetBrowser::loadCollectionSets(%this)
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/newAsset.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/newAsset.tscript
index f2ea27660..c402456cd 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/newAsset.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/newAsset.tscript
@@ -85,7 +85,7 @@ function NewAssetModuleBtn::onClick(%this)
    AssetBrowser_addModuleWindow.selectWindow();
 }
 
-function AssetBrowser::setupCreateNewAsset(%this, %assetType, %moduleName, %callback)
+function AssetBrowser::setupCreateNewAsset(%this, %assetType, %moduleName, %callback, %nameOverride)
 {
    Canvas.pushDialog(AssetBrowser_newAsset);
    
@@ -106,8 +106,12 @@ function AssetBrowser::setupCreateNewAsset(%this, %assetType, %moduleName, %call
    %this.newAssetSettings.assetType = %assetType;
    %this.newAssetSettings.moduleName = %moduleName;
    
+   %newAssetName = "New" @ %shortAssetTypeName;
+   if(%nameOverride !$= "")
+      %newAssetName = %nameOverride;
+   
    NewAssetPropertiesInspector.startGroup("General");
-   NewAssetPropertiesInspector.addField("assetName", "New Asset Name", "String",  "Name of the new asset", "New" @ %shortAssetTypeName, "", %this.newAssetSettings);
+   NewAssetPropertiesInspector.addField("assetName", "New Asset Name", "String",  "Name of the new asset", %newAssetName, "", %this.newAssetSettings);
    //NewAssetPropertiesInspector.addField("AssetType", "New Asset Type", "List",  "Type of the new asset", %assetType, "Component,Image,Material,Shape,Sound,State Machine", %newAssetSettings);
    
    //NewAssetPropertiesInspector.addField("friendlyName", "Friendly Name", "String",  "Human-readable name of new asset", "", "", %this.newAssetSettings);
diff --git a/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript
index 00f890cf1..7c50130b2 100644
--- a/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript
@@ -1244,6 +1244,15 @@ function T3Dpre4ProjectImporter::processTerrainMaterialObject(%this, %fileObject
          %fileObject.FXMaterial.processed = true;
          %fileObject.FXMaterial.skip = true;
       }  
+      else
+      {
+         //if after all that we still have no FXMaterial, just create a new one
+         %fxMat = new Material("TerrainFX_" @ %objectName)
+         {
+            mapTo = %objectName;  
+         };
+         %asset.add(%fxMat);
+      }
       
       %success = false;
       if(TamlWrite(%asset, %tamlpath))
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript
index fd1063618..1446d6d7d 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript
@@ -474,11 +474,36 @@ function TerrainMaterialDlg::setActiveMaterial( %this, %mat )
 
 function TerrainMaterialDlg::saveDirtyMaterial( %this, %mat )
 {
+   //If we happen to have been handed an assetId, process it
+   if(AssetDatabase.isDeclaredAsset(%mat))
+   {
+      %assetDef = AssetDatabase.acquireAsset(%mat);
+      %mat = %assetDef.getMaterialDefinition();
+   }
+   
    // Skip over obviously bad cases.
    if (  !isObject( %mat ) || 
          !%mat.isMemberOfClass( TerrainMaterial ) )
       return;
             
+   //Lets validate it wasn't a generated stub. if so, we need to add an intermediate
+   //step to create the asset
+   %assetDef = AssetDatabase.acquireAsset(%mat.internalName);
+   if(%assetDef $= "")
+   {
+      %moduleSplit = strpos(%mat.internalName, ":");
+      %moduleName = getSubStr(%mat.internalName, 0, %moduleSplit);
+      %assetName = getSubStr(%mat.internalName, %moduleSplit+1, -1);
+      if(ModuleDatabase.findModule(%moduleName) !$= "")
+      {
+         AssetBrowser.selectedModule = %moduleName;
+      }
+         
+      //we need to create an actual asset here
+      AssetBrowser.setupCreateNewAsset("TerrainMaterialAsset", AssetBrowser.selectedModule, "TerrainMaterialDlg.saveDirtyMaterial", %assetName); 
+      return;
+   }
+            
    // Read out properties from the dialog.
    
    %newName = %this-->matNameCtrl.getText(); 
@@ -487,28 +512,28 @@ function TerrainMaterialDlg::saveDirtyMaterial( %this, %mat )
    
    
    //---
-   %newDiffuse = %this-->texDiffuseMap.getBitmap();
-   if(%newDiffuse $= $TerrainMaterialEditor::emptyMaterialImage || %newDiffuse $= %blankBitmap)
+   %newDiffuse = %this-->diffuseMapAssetId.text;
+   if(%newDiffuse $= "None")
       %newDiffuse = "";
    
    //---
-   %newNormal = %this-->texNormalMap.getBitmap();
-   if(%newNormal $= $TerrainMaterialEditor::emptyMaterialImage || %newNormal $= %blankBitmap)
+   %newNormal = %this-->normalMapAssetId.text;
+   if(%newNormal $= "None")
       %newNormal = "";
    
    //---
-   %newormConfig = %this-->texORMConfigMap.getBitmap();
-   if(%newormConfig $= $TerrainMaterialEditor::emptyMaterialImage || %newormConfig $= %blankBitmap)
+   %newormConfig = %this-->ORMMapAssetId.text;
+   if(%newormConfig $= "None")
       %newormConfig = "";
    
    //---
-   %newDetail = %this-->texDetailMap.getBitmap();
-   if(%newDetail $= $TerrainMaterialEditor::emptyMaterialImage || %newDetail $= %blankBitmap)
+   %newDetail = %this-->detailMapAssetId.text;
+   if(%newDetail $= "None")
       %newDetail = "";
    
    //---
-   %newMacro = %this-->texMacroMap.getBitmap();
-   if(%newMacro $= $TerrainMaterialEditor::emptyMaterialImage || %newMacro $= %blankBitmap)
+   %newMacro = %this-->macroMapAssetId.text;
+   if(%newMacro $= "None")
       %newMacro = "";
    
    %detailSize = %this-->detSizeCtrl.getText();      

From 85bb4cbff3943387c4368c7bcaa9adc47a55c0f5 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Wed, 30 Mar 2022 01:38:15 -0500
Subject: [PATCH 346/399] Adds cleanup of material and terrain material objects
 when creating a new asset of the respective type to avoid collisions when we
 immediately properly init the asset on creation Reorganizes the
 terrainMaterialDlg to use a split container for better usability, fixed some
 minor layout issues, and added in FX material fields to be able to edit those
 directly via the terrain mat editor Updated the terrainMaterialDlg save logic
 to better sequence the steps for saving to allow stable in-place creation of
 asset for stub materials due to missing references Updated the
 terrainMaterialDlg save logic to properly save out all the material effects
 stuff like footstep flags, effect colors, or sounds.

---
 .../scripts/assetTypes/material.tscript       |    3 +
 .../assetTypes/terrainMaterial.tscript        |    4 +
 .../gui/guiTerrainMaterialDlg.ed.gui          | 1470 +++--------------
 .../interfaces/terrainMaterialDlg.ed.tscript  |  251 ++-
 4 files changed, 442 insertions(+), 1286 deletions(-)

diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
index fb6b8a4ad..27a3dc58d 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
@@ -21,6 +21,9 @@ function AssetBrowser::createMaterialAsset(%this)
    
    TamlWrite(%asset, %tamlpath);
    
+   //cleanup before proper init'ing
+   %assetName.delete();
+   
    %moduleDef = ModuleDatabase.findModule(%moduleName, 1);
 	AssetDatabase.addDeclaredAsset(%moduleDef, %tamlpath);
 
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrainMaterial.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrainMaterial.tscript
index 8fc9e21f9..c9c9ba83d 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrainMaterial.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrainMaterial.tscript
@@ -48,6 +48,10 @@ function AssetBrowser::createTerrainMaterialAsset(%this)
    
    TamlWrite(%asset, %tamlpath);
    
+   //cleanup before proper init'ing
+   %matDef.delete();
+   %fxMatDef.delete();
+   
    %moduleDef = ModuleDatabase.findModule(%moduleName, 1);
 	AssetDatabase.addDeclaredAsset(%moduleDef, %tamlpath);
 	
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainMaterialDlg.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainMaterialDlg.ed.gui
index 4eef5308f..014771aed 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainMaterialDlg.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainMaterialDlg.ed.gui
@@ -1,1922 +1,894 @@
 //--- OBJECT WRITE BEGIN ---
 $guiContent = new GuiControl(TerrainMaterialDlg,EditorGuiGroup) {
-   position = "0 0";
    extent = "1024 768";
-   minExtent = "8 2";
-   horizSizing = "right";
-   vertSizing = "bottom";
    profile = "ToolsGuiDefaultNonModalProfile";
-   visible = "1";
-   active = "1";
    tooltipProfile = "ToolsGuiToolTipProfile";
-   hovertime = "1000";
    isContainer = "1";
-   canSave = "1";
    canSaveDynamicFields = "1";
 
    new GuiWindowCtrl() {
       text = "Terrain Materials Editor";
-      resizeWidth = "1";
-      resizeHeight = "1";
-      canMove = "1";
-      canClose = "1";
       canMinimize = "0";
       canMaximize = "0";
-      canCollapse = "0";
       closeCommand = "TerrainMaterialDlg.dialogCancel();";
       edgeSnap = "0";
       docking = "None";
       margin = "4 4 4 4";
-      padding = "0 0 0 0";
       anchorTop = "0";
-      anchorBottom = "0";
       anchorLeft = "0";
-      anchorRight = "0";
-      position = "315 118";
-      extent = "394 532";
+      position = "222 59";
+      extent = "457 639";
       minExtent = "358 452";
       horizSizing = "center";
       vertSizing = "center";
       profile = "ToolsGuiWindowProfile";
-      visible = "1";
-      active = "1";
       tooltipProfile = "ToolsGuiToolTipProfile";
-      hovertime = "1000";
-      isContainer = "1";
-      canSave = "1";
-      canSaveDynamicFields = "0";
+
+      new GuiSplitContainer() {
+         splitPoint = "182 100";
+         position = "3 27";
+         extent = "450 579";
+         horizSizing = "width";
+         profile = "ToolsGuiDefaultProfile";
+         tooltipProfile = "GuiToolTipProfile";
+
+         new GuiPanel() {
+            docking = "Client";
+            extent = "180 579";
+            profile = "ToolsGuiDefaultProfile";
+            tooltipProfile = "GuiToolTipProfile";
+            internalName = "Panel1";
 
       new GuiContainer() {
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
-         position = "6 25";
-         extent = "189 64";
-         minExtent = "8 2";
+               position = "6 -2";
+               extent = "179 18";
          horizSizing = "width";
-         vertSizing = "bottom";
          profile = "inspectorStyleRolloutDarkProfile";
-         visible = "1";
-         active = "1";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
 
          new GuiTextCtrl() {
             text = "Terrain Materials";
-            maxLength = "1024";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
             position = "5 0";
             extent = "91 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
             profile = "ToolsGuiDefaultProfile";
-            visible = "1";
-            active = "1";
             tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "1";
-            canSave = "1";
-            canSaveDynamicFields = "0";
          };
          new GuiBitmapButtonCtrl() {
-            bitmapAsset = "ToolsModule:new_n_image";
-            bitmapMode = "Stretched";
-            autoFitExtents = "0";
-            useModifiers = "0";
-            useStates = "1";
-            masked = "0";
-            groupNum = "-1";
-            buttonType = "PushButton";
-            useMouseEvents = "0";
-            position = "160 2";
+                  BitmapAsset = "ToolsModule:new_n_image";
+                  position = "150 3";
             extent = "15 15";
-            minExtent = "8 2";
             horizSizing = "left";
             vertSizing = "top";
             profile = "ToolsGuiButtonProfile";
-            visible = "1";
-            active = "1";
             command = "TerrainMaterialDlg.newMat();";
             tooltipProfile = "ToolsGuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
          };
          new GuiBitmapButtonCtrl() {
-            bitmapAsset = "ToolsModule:delete_n_image";
-            bitmapMode = "Stretched";
-            autoFitExtents = "0";
-            useModifiers = "0";
-            useStates = "1";
-            masked = "0";
-            groupNum = "-1";
-            buttonType = "PushButton";
-            useMouseEvents = "0";
-            position = "173 2";
+                  BitmapAsset = "ToolsModule:delete_n_image";
+                  position = "163 3";
             extent = "15 15";
-            minExtent = "8 2";
             horizSizing = "left";
             vertSizing = "top";
             profile = "ToolsGuiButtonProfile";
-            visible = "1";
-            active = "1";
             command = "TerrainMaterialDlg.deleteMat();";
             tooltipProfile = "ToolsGuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
          };
       };
+            new GuiControl() {
+               position = "6 26";
+               extent = "177 545";
+               horizSizing = "width";
+               vertSizing = "height";
+               profile = "ToolsGuiDefaultProfile";
+               tooltipProfile = "ToolsGuiToolTipProfile";
+               isContainer = "1";
+
+               new GuiScrollCtrl() {
+                  hScrollBar = "dynamic";
+                  vScrollBar = "dynamic";
+                  extent = "174 549";
+                  horizSizing = "width";
+                  vertSizing = "height";
+                  profile = "ToolsGuiScrollProfile";
+                  tooltipProfile = "ToolsGuiToolTipProfile";
+
+                  new GuiTreeViewCtrl() {
+                     itemHeight = "21";
+                     mouseDragging = "0";
+                     multipleSelections = "0";
+                     deleteObjectAllowed = "0";
+                     dragToItemAllowed = "0";
+                     showRoot = "0";
+                     showObjectIds = "0";
+                     showClassNames = "0";
+                     showObjectNames = "0";
+                     position = "1 1";
+                     extent = "224 42";
+                     profile = "ToolsGuiTreeViewProfile";
+                     tooltipProfile = "ToolsGuiToolTipProfile";
+                     internalName = "matLibTree";
+                     class = "TerrainMaterialTreeCtrl";
+                  };
+               };
+            };
+         };
+         new GuiPanel() {
+            docking = "Client";
+            position = "184 0";
+            extent = "266 579";
+            profile = "ToolsGuiDefaultProfile";
+            tooltipProfile = "GuiToolTipProfile";
+            internalName = "panel2";
+
       new GuiContainer() {
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
-         position = "202 26";
-         extent = "185 463";
-         minExtent = "8 2";
-         horizSizing = "left";
+               position = "-7 0";
+               extent = "274 577";
+               horizSizing = "width";
          vertSizing = "height";
          profile = "inspectorStyleRolloutProfile";
-         visible = "1";
-         active = "1";
          tooltipProfile = "ToolsGuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "1";
          internalName = "matSettingsParent";
-         canSave = "1";
-         canSaveDynamicFields = "0";
 
          new GuiBitmapCtrl() {
-            bitmap = "ToolsModule:separator_v_image";
-            color = "White";
-            wrap = "0";
+                  BitmapAsset = "ToolsModule:separator_v_image";
             position = "1 0";
-            extent = "183 2";
-            minExtent = "8 2";
+                  extent = "271 2";
             horizSizing = "width";
-            vertSizing = "bottom";
             profile = "ToolsGuiDefaultProfile";
-            visible = "1";
-            active = "1";
             tooltipProfile = "ToolsGuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
          };
          new GuiTextCtrl() {
             text = "Name";
-            maxLength = "1024";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
             position = "8 22";
             extent = "44 17";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
             profile = "ToolsGuiTextProfile";
-            visible = "1";
-            active = "1";
             tooltipProfile = "ToolsGuiDefaultProfile";
-            hovertime = "1000";
             isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
          };
          new GuiTextEditCtrl() {
-            historySize = "0";
-            tabComplete = "0";
-            sinkAllKeyEvents = "0";
-            password = "0";
-            passwordMask = "*";
-            maxLength = "1024";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
             position = "39 21";
-            extent = "143 18";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
+                  extent = "227 18";
             profile = "ToolsGuiTextEditProfile";
-            visible = "1";
-            active = "1";
             altCommand = "TerrainMaterialDlg.setMaterialName( $ThisControl.getText() );";
             tooltipProfile = "ToolsGuiToolTipProfile";
-            hovertime = "1000";
             isContainer = "0";
             internalName = "matNameCtrl";
-            canSave = "1";
-            canSaveDynamicFields = "0";
          };
          new GuiTextCtrl() {
             text = "Material Properties";
-            maxLength = "1024";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
             position = "8 0";
             extent = "117 16";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
             profile = "ToolsGuiInspectorTitleTextProfile";
-            visible = "1";
-            active = "1";
             tooltipProfile = "ToolsGuiToolTipProfile";
-            hovertime = "1000";
             isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
          };
          new GuiContainer(DiffuseMapContainer) {
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
             position = "6 43";
-            extent = "185 75";
-            minExtent = "8 2";
+                  extent = "261 75";
             horizSizing = "width";
-            vertSizing = "bottom";
             profile = "ToolsGuiDefaultProfile";
-            visible = "1";
-            active = "1";
             tooltipProfile = "ToolsGuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "1";
-            canSave = "1";
-            canSaveDynamicFields = "0";
 
             new GuiCheckBoxCtrl() {
                text = " Use Side Projection";
-               groupNum = "-1";
-               buttonType = "ToggleButton";
-               useMouseEvents = "0";
                position = "55 54";
                extent = "119 16";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiCheckBoxProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
                internalName = "sideProjectionCtrl";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiBitmapCtrl() {
-               bitmapAsset = "ToolsModule:unknownImage_image";
-               color = "255 255 255 255";
-               wrap = "0";
+                     BitmapAsset = "ToolsModule:unknownImage_image";
                position = "1 1";
                extent = "47 47";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiDefaultProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
                internalName = "texDiffuseMap";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiBitmapButtonCtrl() {
-               bitmapAsset = "ToolsModule:cubemapBtnBorder_n_image";
-               bitmapMode = "Stretched";
-               autoFitExtents = "0";
-               useModifiers = "0";
-               useStates = "1";
-               masked = "0";
-               groupNum = "-1";
-               buttonType = "PushButton";
-               useMouseEvents = "0";
+                     BitmapAsset = "ToolsModule:cubemapBtnBorder_n_image";
                position = "1 1";
                extent = "48 48";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiDefaultProfile";
-               visible = "1";
-               active = "1";
                command = "TerrainMaterialDlg.updateTextureMap(\"DiffuseMap\");";
                tooltipProfile = "ToolsGuiDefaultProfile";
                tooltip = "Change the Active Diffuse Map for this layer";
-               hovertime = "1000";
-               isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiTextCtrl() {
                text = "Diffuse";
-               maxLength = "1024";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
-               anchorTop = "1";
-               anchorBottom = "0";
-               anchorLeft = "1";
-               anchorRight = "0";
                position = "56 -3";
                extent = "39 18";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "EditorTextProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
                isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiTextCtrl() {
                text = "None";
-               maxLength = "1024";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
-               anchorTop = "1";
-               anchorBottom = "0";
-               anchorLeft = "1";
-               anchorRight = "0";
                position = "56 16";
-               extent = "116 17";
-               minExtent = "8 2";
+                     extent = "205 17";
                horizSizing = "width";
-               vertSizing = "bottom";
                profile = "ToolsGuiTextProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
                isContainer = "0";
                internalName = "diffuseMapAssetId";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiButtonCtrl() {
                text = "Edit";
-               groupNum = "-1";
-               buttonType = "PushButton";
-               useMouseEvents = "0";
-               position = "116 0";
+                     position = "204 0";
                extent = "40 16";
-               minExtent = "8 2";
                horizSizing = "left";
-               vertSizing = "bottom";
                profile = "ToolsGuiButtonProfile";
-               visible = "1";
-               active = "1";
                command = "TerrainMaterialDlg.updateTextureMap(\"DiffuseMap\");";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiBitmapButtonCtrl() {
-               bitmapAsset = "ToolsModule:delete_n_image";
-               bitmapMode = "Stretched";
-               autoFitExtents = "0";
-               useModifiers = "0";
-               useStates = "1";
-               masked = "0";
-               groupNum = "-1";
-               buttonType = "PushButton";
-               useMouseEvents = "0";
-               position = "159 0";
+                     BitmapAsset = "ToolsModule:delete_n_image";
+                     position = "247 0";
                extent = "16 16";
-               minExtent = "8 2";
                horizSizing = "left";
-               vertSizing = "bottom";
                profile = "ToolsGuiDefaultProfile";
-               visible = "1";
-               active = "1";
                command = "TerrainMaterialDlg.clearTextureMap(\"DiffuseMap\");";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiTextCtrl() {
                text = "Size";
-               maxLength = "1024";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
                anchorTop = "0";
-               anchorBottom = "0";
                anchorLeft = "0";
-               anchorRight = "0";
                position = "132 35";
                extent = "39 16";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiTextProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
                isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiTextEditCtrl() {
-               historySize = "0";
-               tabComplete = "0";
-               sinkAllKeyEvents = "0";
-               password = "0";
-               passwordMask = "*";
                text = "200";
-               maxLength = "1024";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
                anchorTop = "0";
-               anchorBottom = "0";
                anchorLeft = "0";
-               anchorRight = "0";
                position = "94 34";
                extent = "34 18";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiTextEditProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
                isContainer = "0";
                internalName = "baseSizeCtrl";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
          };
          new GuiBitmapCtrl() {
-            bitmapAsset = "ToolsModule:separator_v_image";
-            color = "255 255 255 255";
-            wrap = "0";
+                  BitmapAsset = "ToolsModule:separator_v_image";
             position = "6 116";
-            extent = "175 2";
-            minExtent = "8 2";
+                  extent = "266 2";
             horizSizing = "width";
-            vertSizing = "bottom";
             profile = "ToolsGuiDefaultProfile";
-            visible = "1";
-            active = "1";
             tooltipProfile = "ToolsGuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
          };
          new GuiContainer(DetailMapContainer) {
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
             position = "6 122";
-            extent = "185 100";
-            minExtent = "8 2";
+                  extent = "261 75";
             horizSizing = "width";
-            vertSizing = "bottom";
             profile = "ToolsGuiDefaultProfile";
-            visible = "1";
-            active = "1";
             tooltipProfile = "ToolsGuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "1";
-            canSave = "1";
-            canSaveDynamicFields = "0";
 
             new GuiBitmapCtrl() {
-               bitmapAsset = "ToolsModule:unknownImage_image";
-               color = "255 255 255 255";
-               wrap = "0";
+                     BitmapAsset = "ToolsModule:unknownImage_image";
                position = "1 1";
                extent = "47 47";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiDefaultProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
                internalName = "texDetailMap";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiBitmapButtonCtrl() {
-               bitmapAsset = "ToolsModule:cubemapBtnBorder_n_image";
-               bitmapMode = "Stretched";
-               autoFitExtents = "0";
-               useModifiers = "0";
-               useStates = "1";
-               masked = "0";
-               groupNum = "-1";
-               buttonType = "PushButton";
-               useMouseEvents = "0";
+                     BitmapAsset = "ToolsModule:cubemapBtnBorder_n_image";
                position = "1 1";
                extent = "48 48";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiDefaultProfile";
-               visible = "1";
-               active = "1";
                command = "TerrainMaterialDlg.updateTextureMap(\"DetailMap\");";
                tooltipProfile = "ToolsGuiDefaultProfile";
                tooltip = "Change the active Detail Map for this layer.";
-               hovertime = "1000";
-               isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiTextCtrl() {
                text = "Detail";
-               maxLength = "1024";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
-               anchorTop = "1";
-               anchorBottom = "0";
-               anchorLeft = "1";
-               anchorRight = "0";
                position = "56 -3";
                extent = "30 18";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "EditorTextProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
                isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiTextCtrl() {
                text = "None";
-               maxLength = "1024";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
-               anchorTop = "1";
-               anchorBottom = "0";
-               anchorLeft = "1";
-               anchorRight = "0";
                position = "56 16";
-               extent = "116 17";
-               minExtent = "8 2";
+                     extent = "205 17";
                horizSizing = "width";
-               vertSizing = "bottom";
                profile = "ToolsGuiTextProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
                isContainer = "0";
                internalName = "detailMapAssetId";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiButtonCtrl() {
                text = "Edit";
-               groupNum = "-1";
-               buttonType = "PushButton";
-               useMouseEvents = "0";
-               position = "116 0";
+                     position = "204 0";
                extent = "40 16";
-               minExtent = "8 2";
                horizSizing = "left";
-               vertSizing = "bottom";
                profile = "ToolsGuiButtonProfile";
-               visible = "1";
-               active = "1";
                command = "TerrainMaterialDlg.updateTextureMap(\"DetailMap\");";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiBitmapButtonCtrl() {
-               bitmapAsset = "ToolsModule:delete_n_image";
-               bitmapMode = "Stretched";
-               autoFitExtents = "0";
-               useModifiers = "0";
-               useStates = "1";
-               masked = "0";
-               groupNum = "-1";
-               buttonType = "PushButton";
-               useMouseEvents = "0";
-               position = "159 0";
+                     BitmapAsset = "ToolsModule:delete_n_image";
+                     position = "247 0";
                extent = "16 16";
-               minExtent = "8 2";
                horizSizing = "left";
-               vertSizing = "bottom";
                profile = "ToolsGuiDefaultProfile";
-               visible = "1";
-               active = "1";
                command = "TerrainMaterialDlg.clearTextureMap(\"DetailMap\");";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiTextCtrl() {
                text = "Size";
-               maxLength = "1024";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
                anchorTop = "0";
-               anchorBottom = "0";
                anchorLeft = "0";
-               anchorRight = "0";
                position = "132 33";
                extent = "39 16";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiTextProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
                isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiTextEditCtrl() {
-               historySize = "0";
-               tabComplete = "0";
-               sinkAllKeyEvents = "0";
-               password = "0";
-               passwordMask = "*";
                text = "2";
-               maxLength = "1024";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
                anchorTop = "0";
-               anchorBottom = "0";
                anchorLeft = "0";
-               anchorRight = "0";
                position = "94 32";
                extent = "34 18";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiTextEditProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
                isContainer = "0";
                internalName = "detSizeCtrl";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiTextCtrl() {
                text = "Strength";
-               maxLength = "1024";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
                anchorTop = "0";
-               anchorBottom = "0";
                anchorLeft = "0";
-               anchorRight = "0";
                position = "39 54";
                extent = "46 16";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiTextProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
                isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiTextEditCtrl() {
-               historySize = "0";
-               tabComplete = "0";
-               sinkAllKeyEvents = "0";
-               password = "0";
-               passwordMask = "*";
                text = "1";
-               maxLength = "1024";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
                anchorTop = "0";
-               anchorBottom = "0";
                anchorLeft = "0";
-               anchorRight = "0";
                position = "1 53";
                extent = "34 18";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiTextEditProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
                isContainer = "0";
                internalName = "detStrengthCtrl";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiTextCtrl() {
                text = "Distance";
-               maxLength = "1024";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
                anchorTop = "0";
-               anchorBottom = "0";
                anchorLeft = "0";
-               anchorRight = "0";
                position = "132 54";
                extent = "45 16";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiTextProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
                isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiTextEditCtrl() {
-               historySize = "0";
-               tabComplete = "0";
-               sinkAllKeyEvents = "0";
-               password = "0";
-               passwordMask = "*";
                text = "50";
-               maxLength = "1024";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
                anchorTop = "0";
-               anchorBottom = "0";
                anchorLeft = "0";
-               anchorRight = "0";
                position = "94 53";
                extent = "34 18";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiTextEditProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
                isContainer = "0";
                internalName = "detDistanceCtrl";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
          };
          new GuiBitmapCtrl() {
-            bitmapAsset = "ToolsModule:separator_v_image";
-            color = "255 255 255 255";
-            wrap = "0";
+                  BitmapAsset = "ToolsModule:separator_v_image";
             position = "6 198";
-            extent = "175 2";
-            minExtent = "8 2";
+                  extent = "266 2";
             horizSizing = "width";
-            vertSizing = "bottom";
             profile = "ToolsGuiDefaultProfile";
-            visible = "1";
-            active = "1";
             tooltipProfile = "ToolsGuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
          };
          new GuiContainer(NormalMapContainer) {
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
             position = "6 205";
-            extent = "185 100";
-            minExtent = "8 2";
+                  extent = "261 100";
             horizSizing = "width";
-            vertSizing = "bottom";
             profile = "ToolsGuiDefaultProfile";
-            visible = "1";
-            active = "1";
             tooltipProfile = "ToolsGuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "1";
-            canSave = "1";
-            canSaveDynamicFields = "0";
 
             new GuiBitmapCtrl() {
-               bitmapAsset = "ToolsModule:unknownImage_image";
-               color = "255 255 255 255";
-               wrap = "0";
+                     BitmapAsset = "ToolsModule:unknownImage_image";
                position = "1 1";
                extent = "47 47";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiDefaultProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
                internalName = "texNormalMap";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiTextCtrl() {
                text = "Normal";
-               maxLength = "1024";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
-               anchorTop = "1";
-               anchorBottom = "0";
-               anchorLeft = "1";
-               anchorRight = "0";
                position = "56 -3";
                extent = "39 18";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "EditorTextProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
                isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiBitmapButtonCtrl() {
-               bitmapAsset = "ToolsModule:cubemapBtnBorder_n_image";
-               bitmapMode = "Stretched";
-               autoFitExtents = "0";
-               useModifiers = "0";
-               useStates = "1";
-               masked = "0";
-               groupNum = "-1";
-               buttonType = "PushButton";
-               useMouseEvents = "0";
+                     BitmapAsset = "ToolsModule:cubemapBtnBorder_n_image";
                position = "1 1";
                extent = "48 48";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiDefaultProfile";
-               visible = "1";
-               active = "1";
                command = "TerrainMaterialDlg.updateTextureMap(\"NormalMap\");";
                tooltipProfile = "ToolsGuiDefaultProfile";
                tooltip = "Change the active Normal Map for this layer.";
-               hovertime = "1000";
-               isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiTextCtrl() {
                text = "None";
-               maxLength = "1024";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
-               anchorTop = "1";
-               anchorBottom = "0";
-               anchorLeft = "1";
-               anchorRight = "0";
                position = "56 15";
-               extent = "116 17";
-               minExtent = "8 2";
+                     extent = "205 17";
                horizSizing = "width";
-               vertSizing = "bottom";
                profile = "ToolsGuiTextProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
                isContainer = "0";
                internalName = "normalMapAssetId";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiButtonCtrl() {
                text = "Edit";
-               groupNum = "-1";
-               buttonType = "PushButton";
-               useMouseEvents = "0";
-               position = "116 0";
+                     position = "204 0";
                extent = "40 16";
-               minExtent = "8 2";
                horizSizing = "left";
-               vertSizing = "bottom";
                profile = "ToolsGuiButtonProfile";
-               visible = "1";
-               active = "1";
                command = "TerrainMaterialDlg.updateTextureMap(\"NormalMap\");";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiBitmapButtonCtrl() {
-               bitmapAsset = "ToolsModule:delete_n_image";
-               bitmapMode = "Stretched";
-               autoFitExtents = "0";
-               useModifiers = "0";
-               useStates = "1";
-               masked = "0";
-               groupNum = "-1";
-               buttonType = "PushButton";
-               useMouseEvents = "0";
-               position = "159 0";
+                     BitmapAsset = "ToolsModule:delete_n_image";
+                     position = "247 0";
                extent = "16 16";
-               minExtent = "8 2";
                horizSizing = "left";
-               vertSizing = "bottom";
                profile = "ToolsGuiDefaultProfile";
-               visible = "1";
-               active = "1";
                command = "TerrainMaterialDlg.clearTextureMap(\"NormalMap\");";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiTextCtrl() {
                text = "Parallax Scale";
-               maxLength = "1024";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
-               anchorTop = "1";
-               anchorBottom = "0";
-               anchorLeft = "1";
-               anchorRight = "0";
                position = "92 34";
                extent = "77 16";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiTextProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
                isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiTextEditCtrl() {
-               historySize = "0";
-               tabComplete = "0";
-               sinkAllKeyEvents = "0";
-               password = "0";
-               passwordMask = "*";
                text = "0";
-               maxLength = "1024";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
                anchorTop = "0";
-               anchorBottom = "0";
                anchorLeft = "0";
-               anchorRight = "0";
                position = "55 33";
                extent = "34 18";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiTextEditProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
                isContainer = "0";
                internalName = "parallaxScaleCtrl";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiSliderCtrl(TerrainMaterialDlgBlendHeightBaseSlider) {
                range = "-0.5 0.5";
                ticks = "0";
-               snap = "0";
                value = "0";
-               useFillBar = "0";
-               fillBarColor = "255 255 255 255";
-               renderTicks = "1";
                position = "39 61";
                extent = "70 14";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiSliderProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
                internalName = "blendHeightBaseSliderCtrl";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiTextCtrl() {
                text = "Blend Height";
-               maxLength = "1024";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
-               anchorTop = "1";
-               anchorBottom = "0";
-               anchorLeft = "1";
-               anchorRight = "0";
                position = "115 61";
-               extent = "58 15";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
+                     extent = "68 15";
                profile = "ToolsGuiTextProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "1";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiTextEditCtrl(TerrainMaterialDlgBlendHeightBaseTextEdit) {
-               historySize = "0";
-               tabComplete = "0";
-               sinkAllKeyEvents = "0";
-               password = "0";
-               passwordMask = "*";
                text = "0";
-               maxLength = "1024";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
                anchorTop = "0";
-               anchorBottom = "0";
                anchorLeft = "0";
-               anchorRight = "0";
                position = "1 59";
                extent = "35 18";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiTextEditProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
                isContainer = "0";
                internalName = "blendHeightBaseTextEditCtrl";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiSliderCtrl(TerrainMaterialDlgBlendHeightContrastSlider) {
                range = "0 5";
                ticks = "0";
-               snap = "0";
                value = "1";
-               useFillBar = "0";
-               fillBarColor = "255 255 255 255";
-               renderTicks = "1";
                position = "39 81";
                extent = "70 14";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiSliderProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
                internalName = "blendHeightContrastSliderCtrl";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiTextCtrl() {
                text = "Blend Contrast";
-               maxLength = "1024";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
-               anchorTop = "1";
-               anchorBottom = "0";
-               anchorLeft = "1";
-               anchorRight = "0";
                position = "115 81";
-               extent = "58 15";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
+                     extent = "76 15";
                profile = "ToolsGuiTextProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "1";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiTextEditCtrl(TerrainMaterialDlgBlendHeightContrastTextEdit) {
-               historySize = "0";
-               tabComplete = "0";
-               sinkAllKeyEvents = "0";
-               password = "0";
-               passwordMask = "*";
                text = "1";
-               maxLength = "1024";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
                anchorTop = "0";
-               anchorBottom = "0";
                anchorLeft = "0";
-               anchorRight = "0";
                position = "1 79";
                extent = "35 18";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiTextEditProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
                isContainer = "0";
                internalName = "blendHeightContrastTextEditCtrl";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
          };
          new GuiBitmapCtrl() {
-            bitmapAsset = "ToolsModule:separator_v_image";
-            color = "255 255 255 255";
-            wrap = "0";
+                  BitmapAsset = "ToolsModule:separator_v_image";
             position = "6 307";
-            extent = "175 2";
-               minExtent = "8 2";
+                  extent = "266 2";
             horizSizing = "width";
-               vertSizing = "bottom";
             profile = "ToolsGuiDefaultProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
          new GuiContainer(ORMMapContainer) {
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
-               anchorTop = "1";
-               anchorBottom = "0";
-               anchorLeft = "1";
-               anchorRight = "0";
             position = "6 314";
-            extent = "185 64";
-               minExtent = "8 2";
+                  extent = "261 64";
                horizSizing = "width";
-               vertSizing = "bottom";
                profile = "ToolsGuiDefaultProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "1";
-               canSave = "1";
-               canSaveDynamicFields = "0";
 
                new GuiBitmapCtrl() {
-                  bitmapAsset = "ToolsModule:unknownImage_image";
-                  color = "255 255 255 255";
-                  wrap = "0";
+                     BitmapAsset = "ToolsModule:unknownImage_image";
                   position = "1 1";
                   extent = "47 47";
-                  minExtent = "8 2";
-                  horizSizing = "right";
-                  vertSizing = "bottom";
                   profile = "ToolsGuiDefaultProfile";
-                  visible = "1";
-                  active = "1";
                   tooltipProfile = "ToolsGuiToolTipProfile";
-                  hovertime = "1000";
-                  isContainer = "0";
                internalName = "texORMConfigMap";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiTextCtrl() {
                text = "ORM Config";
-               maxLength = "1024";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
-               anchorTop = "1";
-               anchorBottom = "0";
-               anchorLeft = "1";
-               anchorRight = "0";
                position = "56 -3";
                extent = "64 18";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "EditorTextProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
                isContainer = "0";
-                  canSave = "1";
-                  canSaveDynamicFields = "0";
                };
                new GuiBitmapButtonCtrl() {
-                  bitmapAsset = "ToolsModule:cubemapBtnBorder_n_image";
-                  bitmapMode = "Stretched";
-                  autoFitExtents = "0";
-                  useModifiers = "0";
-                  useStates = "1";
-                  masked = "0";
-                  groupNum = "-1";
-                  buttonType = "PushButton";
-                  useMouseEvents = "0";
+                     BitmapAsset = "ToolsModule:cubemapBtnBorder_n_image";
                   position = "1 1";
                   extent = "48 48";
-                  minExtent = "8 2";
-                  horizSizing = "right";
-                  vertSizing = "bottom";
                   profile = "ToolsGuiDefaultProfile";
-                  visible = "1";
-                  active = "1";
                command = "TerrainMaterialDlg.updateTextureMap(\"ORMConfigMap\");";
                   tooltipProfile = "ToolsGuiDefaultProfile";
                tooltip = "Change the active ORM Config Map for this layer.";
-                  hovertime = "1000";
-                  isContainer = "0";
-                  canSave = "1";
-                  canSaveDynamicFields = "0";
                };
                new GuiTextCtrl() {
                   text = "None";
-                  maxLength = "1024";
-                  margin = "0 0 0 0";
-                  padding = "0 0 0 0";
-                  anchorTop = "1";
-                  anchorBottom = "0";
-                  anchorLeft = "1";
-                  anchorRight = "0";
                position = "56 15";
-               extent = "116 17";
-                  minExtent = "8 2";
+                     extent = "205 17";
                   horizSizing = "width";
-                  vertSizing = "bottom";
                   profile = "ToolsGuiTextProfile";
-                  visible = "1";
-                  active = "1";
                   tooltipProfile = "ToolsGuiToolTipProfile";
-                  hovertime = "1000";
                   isContainer = "0";
                internalName = "ORMMapAssetId";
-                  canSave = "1";
-                  canSaveDynamicFields = "0";
                };
                new GuiButtonCtrl() {
                   text = "Edit";
-                  groupNum = "-1";
-                  buttonType = "PushButton";
-                  useMouseEvents = "0";
-               position = "116 0";
+                     position = "205 0";
                   extent = "40 16";
-                  minExtent = "8 2";
                   horizSizing = "left";
-                  vertSizing = "bottom";
                   profile = "ToolsGuiButtonProfile";
-                  visible = "1";
-                  active = "1";
                command = "TerrainMaterialDlg.updateTextureMap(\"OrmConfigMap\");";
                   tooltipProfile = "ToolsGuiToolTipProfile";
-                  hovertime = "1000";
-                  isContainer = "0";
-                  canSave = "1";
-                  canSaveDynamicFields = "0";
                };
                new GuiBitmapButtonCtrl() {
-                  bitmapAsset = "ToolsModule:delete_n_image";
-                  bitmapMode = "Stretched";
-                  autoFitExtents = "0";
-                  useModifiers = "0";
-                  useStates = "1";
-                  masked = "0";
-                  groupNum = "-1";
-                  buttonType = "PushButton";
-                  useMouseEvents = "0";
-               position = "159 0";
+                     BitmapAsset = "ToolsModule:delete_n_image";
+                     position = "248 0";
                   extent = "16 16";
-                  minExtent = "8 2";
                   horizSizing = "left";
-                  vertSizing = "bottom";
                   profile = "ToolsGuiDefaultProfile";
-                  visible = "1";
-                  active = "1";
                command = "TerrainMaterialDlg.clearTextureMap(\"ORMConfigMap\");";
                   tooltipProfile = "ToolsGuiToolTipProfile";
-                  hovertime = "1000";
-                  isContainer = "0";
-                  canSave = "1";
-                  canSaveDynamicFields = "0";
                };
             new GuiCheckBoxCtrl() {
                text = " Is sRGB";
-               groupNum = "-1";
-               buttonType = "ToggleButton";
-               useMouseEvents = "0";
                position = "55 32";
                extent = "119 16";
-                  minExtent = "8 2";
-               horizSizing = "right";
-                  vertSizing = "bottom";
                profile = "ToolsGuiCheckBoxProfile";
-                  visible = "1";
-                  active = "1";
                   tooltipProfile = "ToolsGuiToolTipProfile";
-                  hovertime = "1000";
-                  isContainer = "0";
-               internalName = "isSRGB";
-                  canSave = "1";
-                  canSaveDynamicFields = "0";
+                     internalName = "IsSRGB";
                };
             new GuiCheckBoxCtrl() {
                text = " Invert Roughness";
-               groupNum = "-1";
-               buttonType = "ToggleButton";
-               useMouseEvents = "0";
                position = "55 48";
                extent = "119 16";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiCheckBoxProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               internalName = "invertRoughness";
-               canSave = "1";
-               canSaveDynamicFields = "0";
+                     internalName = "InvertRoughness";
             };
          };
          new GuiBitmapCtrl() {
-            bitmapAsset = "ToolsModule:separator_v_image";
-            color = "255 255 255 255";
-            wrap = "0";
+                  BitmapAsset = "ToolsModule:separator_v_image";
             position = "6 381";
-            extent = "175 2";
-            minExtent = "8 2";
+                  extent = "266 2";
             horizSizing = "width";
-            vertSizing = "bottom";
             profile = "ToolsGuiDefaultProfile";
-            visible = "1";
-            active = "1";
             tooltipProfile = "ToolsGuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
          };
          new GuiContainer(MacroMapContainer) {
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
             position = "6 388";
-            extent = "185 72";
-            minExtent = "8 2";
+                  extent = "261 72";
             horizSizing = "width";
-            vertSizing = "bottom";
             profile = "ToolsGuiDefaultProfile";
-            visible = "1";
-            active = "1";
             tooltipProfile = "ToolsGuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "1";
-            canSave = "1";
-            canSaveDynamicFields = "0";
 
             new GuiBitmapCtrl() {
-               bitmapAsset = "ToolsModule:unknownImage_image";
-               color = "255 255 255 255";
-               wrap = "0";
+                     BitmapAsset = "ToolsModule:unknownImage_image";
                position = "1 1";
                extent = "47 47";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiDefaultProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
                internalName = "texMacroMap";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiBitmapButtonCtrl() {
-               bitmapAsset = "ToolsModule:cubemapBtnBorder_n_image";
-               bitmapMode = "Stretched";
-               autoFitExtents = "0";
-               useModifiers = "0";
-               useStates = "1";
-               masked = "0";
-               groupNum = "-1";
-               buttonType = "PushButton";
-               useMouseEvents = "0";
+                     BitmapAsset = "ToolsModule:cubemapBtnBorder_n_image";
                position = "1 1";
                extent = "48 48";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiDefaultProfile";
-               visible = "1";
-               active = "1";
                command = "TerrainMaterialDlg.updateTextureMap(\"MacroMap\");";
                tooltipProfile = "ToolsGuiDefaultProfile";
                tooltip = "Change the active Macro Map for this layer.";
-               hovertime = "1000";
-               isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiTextCtrl() {
                text = "Macro";
-               maxLength = "1024";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
-               anchorTop = "1";
-               anchorBottom = "0";
-               anchorLeft = "1";
-               anchorRight = "0";
                position = "56 -3";
                extent = "34 18";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "EditorTextProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
                isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiTextCtrl() {
                text = "None";
-               maxLength = "1024";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
-               anchorTop = "1";
-               anchorBottom = "0";
-               anchorLeft = "1";
-               anchorRight = "0";
                position = "56 17";
-               extent = "116 17";
-               minExtent = "8 2";
+                     extent = "192 17";
                horizSizing = "width";
-               vertSizing = "bottom";
                profile = "ToolsGuiTextProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
                isContainer = "0";
                internalName = "macroMapAssetId";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiButtonCtrl() {
                text = "Edit";
-               groupNum = "-1";
-               buttonType = "PushButton";
-               useMouseEvents = "0";
-               position = "116 0";
+                     position = "204 0";
                extent = "40 16";
-               minExtent = "8 2";
                horizSizing = "left";
-               vertSizing = "bottom";
                profile = "ToolsGuiButtonProfile";
-               visible = "1";
-               active = "1";
                command = "TerrainMaterialDlg.updateTextureMap(\"MacroMap\");";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiBitmapButtonCtrl() {
-               bitmapAsset = "ToolsModule:delete_n_image";
-               bitmapMode = "Stretched";
-               autoFitExtents = "0";
-               useModifiers = "0";
-               useStates = "1";
-               masked = "0";
-               groupNum = "-1";
-               buttonType = "PushButton";
-               useMouseEvents = "0";
-               position = "159 0";
+                     BitmapAsset = "ToolsModule:delete_n_image";
+                     position = "247 0";
                extent = "16 16";
-               minExtent = "8 2";
                horizSizing = "left";
-               vertSizing = "bottom";
                profile = "ToolsGuiDefaultProfile";
-               visible = "1";
-               active = "1";
                command = "TerrainMaterialDlg.clearTextureMap(\"MacroMap\");";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiTextCtrl() {
                text = "Size";
-               maxLength = "1024";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
                anchorTop = "0";
-               anchorBottom = "0";
                anchorLeft = "0";
-               anchorRight = "0";
                position = "132 33";
                extent = "39 16";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiTextProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
                isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiTextEditCtrl() {
-               historySize = "0";
-               tabComplete = "0";
-               sinkAllKeyEvents = "0";
-               password = "0";
-               passwordMask = "*";
                text = "200";
-               maxLength = "1024";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
                anchorTop = "0";
-               anchorBottom = "0";
                anchorLeft = "0";
-               anchorRight = "0";
                position = "94 32";
                extent = "34 18";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiTextEditProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
                isContainer = "0";
                internalName = "macroSizeCtrl";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiTextCtrl() {
                text = "Strength";
-               maxLength = "1024";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
                anchorTop = "0";
-               anchorBottom = "0";
                anchorLeft = "0";
-               anchorRight = "0";
                position = "39 54";
                extent = "46 16";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiTextProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
                isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiTextEditCtrl() {
-               historySize = "0";
-               tabComplete = "0";
-               sinkAllKeyEvents = "0";
-               password = "0";
-               passwordMask = "*";
                text = "0.7";
-               maxLength = "1024";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
                anchorTop = "0";
-               anchorBottom = "0";
                anchorLeft = "0";
-               anchorRight = "0";
                position = "1 53";
                extent = "34 18";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiTextEditProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
                isContainer = "0";
                internalName = "macroStrengthCtrl";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiTextCtrl() {
                text = "Distance";
-               maxLength = "1024";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
                anchorTop = "0";
-               anchorBottom = "0";
                anchorLeft = "0";
-               anchorRight = "0";
                position = "132 54";
                extent = "45 16";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiTextProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
                isContainer = "0";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
             new GuiTextEditCtrl() {
-               historySize = "0";
-               tabComplete = "0";
-               sinkAllKeyEvents = "0";
-               password = "0";
-               passwordMask = "*";
                text = "500";
-               maxLength = "1024";
-               margin = "0 0 0 0";
-               padding = "0 0 0 0";
                anchorTop = "0";
-               anchorBottom = "0";
                anchorLeft = "0";
-               anchorRight = "0";
                position = "94 53";
                extent = "34 18";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
                profile = "ToolsGuiTextEditProfile";
-               visible = "1";
-               active = "1";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
                isContainer = "0";
                internalName = "macroDistanceCtrl";
-               canSave = "1";
-               canSaveDynamicFields = "0";
             };
          };
+               new GuiContainer(TerrainEffectsContainer) {
+                  position = "6 460";
+                  extent = "265 97";
+                  horizSizing = "width";
+                  profile = "ToolsGuiDefaultProfile";
+                  tooltipProfile = "GuiToolTipProfile";
+
+                  new GuiBitmapCtrl() {
+                     BitmapAsset = "ToolsModule:separator_v_image";
+                     position = "2 2";
+                     extent = "276 2";
+                     horizSizing = "width";
+                     profile = "GuiDefaultProfile";
+                     tooltipProfile = "GuiToolTipProfile";
+                  };
+                  new GuiTextCtrl() {
+                     text = "Effect Colors[0:1]";
+                     position = "1 22";
+                     extent = "86 15";
+                     profile = "ToolsGuiDefaultProfile";
+                     tooltipProfile = "GuiToolTipProfile";
       };
-      new GuiControl() {
-         position = "6 42";
-         extent = "189 473";
-         minExtent = "8 2";
+                  new GuiSwatchButtonCtrl() {
+                     position = "89 22";
+                     extent = "16 16";
+                     tooltipProfile = "ToolsGuiToolTipProfile";
+                     command = "getColorF($ThisControl.color, \"TerrainMaterialDlg.updateEffectColor0\");";
+                     internalName = "effectColor0Swatch";
+                  };
+                  new GuiSwatchButtonCtrl() {
+                     position = "109 22";
+                     extent = "16 16";
+                     tooltipProfile = "ToolsGuiToolTipProfile";
+                     command = "getColorF($ThisControl.color, \"TerrainMaterialDlg.updateEffectColor1\");";
+                     internalName = "effectColor1Swatch";
+                  };
+                  new GuiCheckBoxCtrl() {
+                     text = "Show Footprints";
+                     position = "1 40";
+                     extent = "93 16";
+                     profile = "ToolsGuiCheckBoxProfile";
+                     tooltipProfile = "ToolsGuiDefaultProfile";
+                     tooltip = "Enables Player footprints on surfaces that use this Material.";
+                     internalName = "showFootprintsCheckbox";
+                  };
+                  new GuiCheckBoxCtrl() {
+                     text = "Show Dust";
+                     position = "110 40";
+                     extent = "68 16";
+                     profile = "ToolsGuiCheckBoxProfile";
+                     tooltipProfile = "ToolsGuiDefaultProfile";
+                     tooltip = "Enables dust particles on surfaces that use this Material.";
+                     internalName = "showDustCheckbox";
+                  };
+                  new GuiTextCtrl() {
+                     text = "Footstep sound";
+                     position = "1 59";
+                     extent = "77 15";
+                     profile = "ToolsGuiDefaultProfile";
+                     tooltipProfile = "GuiToolTipProfile";
+                  };
+                  new GuiPopUpMenuCtrl() {
+                     text = "None";
+                     position = "80 58";
+                     extent = "184 18";
          horizSizing = "width";
-         vertSizing = "height";
+                     profile = "ToolsGuiPopUpMenuProfile";
+                     tooltipProfile = "ToolsGuiToolTipProfile";
+                     tooltip = "Determines the footstep sound to use when the Player walks on this Material.";
+                     isContainer = "0";
+                     internalName = "footstepSoundPopup";
+                  };
+                  new GuiTextCtrl() {
+                     text = "Impact sound";
+                     position = "1 79";
+                     extent = "64 15";
          profile = "ToolsGuiDefaultProfile";
-         visible = "1";
-         active = "1";
-         tooltipProfile = "ToolsGuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-
-         new GuiScrollCtrl() {
-            willFirstRespond = "1";
-            hScrollBar = "dynamic";
-            vScrollBar = "dynamic";
-            lockHorizScroll = "0";
-            lockVertScroll = "0";
-            constantThumbHeight = "0";
-            childMargin = "0 0";
-            mouseWheelScrollSpeed = "-1";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "0 0";
-            extent = "189 454";
-            minExtent = "8 2";
+                     tooltipProfile = "GuiToolTipProfile";
+                  };
+                  new GuiPopUpMenuCtrl() {
+                     text = "None";
+                     position = "80 78";
+                     extent = "184 18";
             horizSizing = "width";
-            vertSizing = "height";
-            profile = "ToolsGuiScrollProfile";
-            visible = "1";
-            active = "1";
+                     profile = "ToolsGuiPopUpMenuProfile";
             tooltipProfile = "ToolsGuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "1";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-
-            new GuiTreeViewCtrl() {
-               tabSize = "16";
-               textOffset = "2";
-               fullRowSelect = "0";
-               itemHeight = "21";
-               destroyTreeOnSleep = "1";
-               mouseDragging = "0";
-               multipleSelections = "0";
-               deleteObjectAllowed = "0";
-               dragToItemAllowed = "0";
-               clearAllOnSingleSelection = "1";
-               showRoot = "0";
-               useInspectorTooltips = "0";
-               tooltipOnWidthOnly = "0";
-               showObjectIds = "0";
-               showClassNames = "0";
-               showObjectNames = "0";
-               showInternalNames = "1";
-               showClassNameForUnnamedObjects = "0";
-               compareToObjectID = "1";
-               canRenameObjects = "1";
-               renameInternal = "0";
-               position = "1 1";
-               extent = "136 147";
-               minExtent = "8 2";
-               horizSizing = "right";
-               vertSizing = "bottom";
-               profile = "ToolsGuiTreeViewProfile";
-               visible = "1";
-               active = "1";
+                     tooltip = "Determines the impact sound to use when an object collides with this Material.";
+                     isContainer = "0";
+                     internalName = "impactSoundPopup";
+                  };
+                  new GuiTextCtrl() {
+                     text = "Effects";
+                     position = "2 4";
+                     extent = "38 18";
+                     profile = "EditorTextProfile";
                tooltipProfile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
-               isContainer = "1";
-               internalName = "matLibTree";
-               class = "TerrainMaterialTreeCtrl";
-               canSave = "1";
-               canSaveDynamicFields = "0";
+                     isContainer = "0";
+                  };
+               };
             };
          };
       };
       new GuiButtonCtrl() {
          text = "Apply&Select";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "202 494";
+         position = "269 612";
          extent = "98 22";
-         minExtent = "8 2";
          horizSizing = "left";
          vertSizing = "top";
          profile = "ToolsGuiButtonProfile";
-         visible = "1";
-         active = "1";
          command = "TerrainMaterialDlg.dialogApply();";
          tooltipProfile = "ToolsGuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
       };
       new GuiButtonCtrl() {
          text = "Cancel";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "307 494";
+         position = "374 612";
          extent = "80 22";
-         minExtent = "8 2";
          horizSizing = "left";
          vertSizing = "top";
          profile = "ToolsGuiButtonProfile";
-         visible = "1";
-         active = "1";
          command = "TerrainMaterialDlg.dialogCancel();";
          tooltipProfile = "ToolsGuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
       };
       new GuiBitmapCtrl() {
-         bitmapAsset = "ToolsModule:inactive_overlay_image";
-         color = "255 255 255 255";
-         wrap = "0";
-         position = "199 23";
-         extent = "190 367";
-         minExtent = "8 2";
+         BitmapAsset = "ToolsModule:inactive_overlay_image";
+         position = "277 23";
+         extent = "190 474";
          horizSizing = "left";
          vertSizing = "height";
          profile = "ToolsGuiDefaultProfile";
          visible = "0";
-         active = "1";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
          isContainer = "1";
          internalName = "inactiveOverlay";
          hidden = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
 
          new GuiTextCtrl() {
             text = "Inactive";
-            maxLength = "1024";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
-            position = "0 151";
+            position = "0 205";
             extent = "190 64";
-            minExtent = "8 2";
             horizSizing = "width";
             vertSizing = "center";
             profile = "ToolsGuiTextCenterProfile";
-            visible = "1";
-            active = "1";
             tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "1";
             internalName = "inactiveOverlayDlg";
-            canSave = "1";
-            canSaveDynamicFields = "0";
          };
       };
    };
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript
index 1446d6d7d..745ee906a 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript
@@ -109,6 +109,31 @@ function TerrainMaterialDlg::onWake( %this )
    %item = %matLibTree.getFirstRootItem();
    %matLibTree.expandItem( %item );
    
+   //Sounds
+   %this-->footstepSoundPopup.clear();
+   %this-->impactSoundPopup.clear();
+
+   %sounds = "<None>" TAB "<Soft>" TAB "<Hard>" TAB "<Metal>" TAB "<Snow>";    // Default sounds
+
+   %assetQuery = new AssetQuery();
+   AssetDatabase.findAssetType(%assetQuery, "SoundAsset");
+   
+   %count = %assetQuery.getCount();   
+   // Get custom sound assets
+   for(%i=0; %i < %count; %i++)
+   {
+	   %assetId = %assetQuery.getAsset(%i);
+       %sounds = %sounds TAB %assetId;
+   }
+
+   %count = getFieldCount(%sounds);
+   for (%i = 0; %i < %count; %i++)
+   {
+      %name = getField(%sounds, %i);
+      %this-->footstepSoundPopup.add(%name);
+      %this-->impactSoundPopup.add(%name);
+   }
+   
    %this.activateMaterialCtrls( true );      
 }
 
@@ -150,18 +175,8 @@ function TerrainMaterialDlg::dialogApply( %this )
       %mat.delete();
    }
 
-   // Make sure we save any changes to the current selection.
-   %this.saveDirtyMaterial( %this.activeMat );
-   
-   // Delete the snapshot.
-   TerrainMaterialDlgSnapshot.delete();
 
-   // Remove ourselves from the canvas.
-   Canvas.popDialog( TerrainMaterialDlg ); 
-                            
-   call( %this.onApplyCallback, %this.activeMat, %this.matIndex );
-   
-   TerrainMaterialDlg.matDirty = false;
+   %this.prepSaveDirtyMaterial();
 }
 
 //-----------------------------------------------------------------------------
@@ -171,7 +186,7 @@ function TerrainMaterialDlg::dialogCancel( %this )
    if(TerrainMaterialDlg.matDirty)
    {
       toolsMessageBoxYesNo("Save Dirty Material?", "The current material has been modified. Do you wish save your changes?", 
-                           "TerrainMaterialDlg.saveDirtyMaterial(" @ %this-->matLibTree.getSelectedItem() @ ");TerrainMaterialDlg.closeDialog();", "TerrainMaterialDlg.closeDialog();");
+                           "TerrainMaterialDlg.prepSaveDirtyMaterial("@%this-->matLibTree.getSelectedItem()@");TerrainMaterialDlg.closeDialog();", "TerrainMaterialDlg.closeDialog();");
    }
    else
    {
@@ -380,13 +395,13 @@ function TerrainMaterialTreeCtrl::onSelect( %this, %item )
    if(TerrainMaterialDlg.matDirty)
    {
       toolsMessageBoxYesNo("Save Dirty Material?", "The current material has been modified. Do you wish save your changes?", 
-                           "TerrainMaterialDlg.saveDirtyMaterial(" @ TerrainMaterialDlg.previousMat @ ");TerrainMaterialDlg.setActiveMaterial(" @ %item @ ");", 
+                           "TerrainMaterialDlg.prepSaveDirtyMaterial(" @ TerrainMaterialDlg.previousMat @ ");TerrainMaterialDlg.setActiveMaterial(" @ %item @ ");", 
                            "TerrainMaterialDlg.setActiveMaterial(" @ %item @ ");");
    }
    else
    {
-   TerrainMaterialDlg.setActiveMaterial( %item );
-}
+      TerrainMaterialDlg.setActiveMaterial( %item );
+   }
 }
 
 //-----------------------------------------------------------------------------
@@ -461,6 +476,32 @@ function TerrainMaterialDlg::setActiveMaterial( %this, %mat )
       %this-->isSRGB.setValue( %mat.isSRGB );
       %this-->invertRoughness.setValue( %mat.invertRoughness );
             
+      //FX material stuffs
+      if(AssetDatabase.isDeclaredAsset(%mat.internalName))
+      {
+         %asset = AssetDatabase.acquireAsset(%mat.internalName);
+         %fxMat = %asset.getFXMaterialDefinition();
+         if(isObject(%fxMat))
+         {
+            %this-->effectColor0Swatch.color = %fxMat.effectColor[0];
+            %this-->effectColor1Swatch.color = %fxMat.effectColor[1];
+            
+            %this-->showFootprintsCheckbox.setValue(%fxMat.showFootprints);
+            %this-->showDustCheckbox.setValue(%fxMat.showDust);
+            %this.updateSoundPopup("Footstep", %fxMat.footstepSoundId, %fxMat.customFootstepSound);
+            %this.updateSoundPopup("Impact", %fxMat.impactSoundId, %fxMat.customImpactSound);
+         }
+         else
+         {
+            %this-->effectColor0Swatch.color = "1 1 1 1";
+            %this-->effectColor1Swatch.color = "1 1 1 1";
+            %this-->showFootprintsCheckbox.setValue(0);
+            %this-->showFootprintsCheckbox.setValue(0);
+            %this.updateSoundPopup("Footstep", 0, "");
+            %this.updateSoundPopup("Impact", 0, "");
+         }
+      }
+            
       %this.activateMaterialCtrls( true );      
    }
    else
@@ -470,40 +511,133 @@ function TerrainMaterialDlg::setActiveMaterial( %this, %mat )
    }
 }
 
-//-----------------------------------------------------------------------------
-
-function TerrainMaterialDlg::saveDirtyMaterial( %this, %mat )
+function TerrainMaterialDlg::updateSoundPopup(%this, %type, %defaultId, %customName)
 {
-   //If we happen to have been handed an assetId, process it
-   if(AssetDatabase.isDeclaredAsset(%mat))
+   %ctrl = TerrainMaterialDlg.findObjectByInternalName( %type @ "SoundPopup", true );
+
+   switch (%defaultId)
    {
-      %assetDef = AssetDatabase.acquireAsset(%mat);
-      %mat = %assetDef.getMaterialDefinition();
+      case 0:        %name = "<Soft>";
+      case 1:        %name = "<Hard>";
+      case 2:        %name = "<Metal>";
+      case 3:        %name = "<Snow>";
+      default:
+         if (%customName $= "")
+            %name = "<None>";
+         else
+            %name = %customName;
+   }
+
+   %r = %ctrl.findText(%name);
+   if (%r != -1)
+      %ctrl.setSelected(%r, false);
+   else
+      %ctrl.setText(%name);
+}
+
+function TerrainMaterialDlg::getBehaviorSound(%this, %type, %sound)
+{
+   %defaultId = -1;
+   %customName = "";
+
+   switch$ (%sound)
+   {
+      case "<Soft>":    %defaultId = 0;
+      case "<Hard>":    %defaultId = 1;
+      case "<Metal>":   %defaultId = 2;
+      case "<Snow>":    %defaultId = 3;
+      default:          %customName = %sound;
    }
    
-   // Skip over obviously bad cases.
-   if (  !isObject( %mat ) || 
-         !%mat.isMemberOfClass( TerrainMaterial ) )
-      return;
-            
-   //Lets validate it wasn't a generated stub. if so, we need to add an intermediate
-   //step to create the asset
-   %assetDef = AssetDatabase.acquireAsset(%mat.internalName);
-   if(%assetDef $= "")
+   return %defaultId TAB %customName;
+}
+
+function TerrainMaterialDlg::updateEffectColor0(%this, %color)
+{
+   %this-->effectColor0Swatch.color = %color;
+}
+
+function TerrainMaterialDlg::updateEffectColor1(%this, %color)
+{
+   %this-->effectColor1Swatch.color = %color;
+}
+//-----------------------------------------------------------------------------
+function TerrainMaterialDlg::prepSaveDirtyMaterial(%this, %material)
+{
+   if(%material $= "")
+      %material = %this.activeMat;
+      
+   if(!isObject(%material))
    {
-      %moduleSplit = strpos(%mat.internalName, ":");
-      %moduleName = getSubStr(%mat.internalName, 0, %moduleSplit);
-      %assetName = getSubStr(%mat.internalName, %moduleSplit+1, -1);
+      error("TerrainMaterialDlg::prepSaveDirtyMaterial() - active material is not a valid object");
+      return;
+   }
+   if(!AssetDatabase.isDeclaredAsset(%material.internalName))
+   {
+      //No valid asset, so we probably generated it as a stub due to a leftover
+      //reference. Let's generate a new asset
+      %assetId = %material.internalName;
+      
+      %moduleSplit = strpos(%material.internalName, ":");
+      %moduleName = getSubStr(%material.internalName, 0, %moduleSplit);
+      %assetName = getSubStr(%material.internalName, %moduleSplit+1, -1);
       if(ModuleDatabase.findModule(%moduleName) !$= "")
       {
          AssetBrowser.selectedModule = %moduleName;
       }
          
-      //we need to create an actual asset here
+      //Clear the stub
+      TerrainMaterialSet.remove(%material);
+      %material.delete();
+      
+      %oldMat = TerrainMaterialSet.findObjectByInternalName( %assetId );
+
       AssetBrowser.setupCreateNewAsset("TerrainMaterialAsset", AssetBrowser.selectedModule, "TerrainMaterialDlg.saveDirtyMaterial", %assetName); 
+   }
+   else
+   {
+      %assetDef = AssetDatabase.acquireAsset(%material.internalName);
+      
+      //If we somehow don't have an FX material, make one     
+      %fxMat = %assetDef.getFXMaterialDefinition();
+      if(!isObject(%fxMat))
+      {
+         %fxMat = new Material("TerrainFX_" @ %assetDef.assetName){
+            mapTo = %assetDef.assetName;
+         };
+         
+         %assetDef.add(%fxMat);
+      }
+   
+      // Make sure we save any changes to the current selection.
+      %this.saveDirtyMaterial( %material.internalName );
+   }
+}
+
+function TerrainMaterialDlg::saveDirtyMaterial( %this, %materialAssetId )
+{
+   %assetDef = "";
+   %mat = "";
+   
+   //If we happen to have been handed an assetId, process it
+   if(AssetDatabase.isDeclaredAsset(%materialAssetId))
+   {
+      %assetDef = AssetDatabase.acquireAsset(%materialAssetId);
+      %mat = %assetDef.getMaterialDefinition();
+   }
+   else
+   {
+      error("TerrainMaterialDlg::saveDirtyMaterial() - attempting to save invalid assetId: " @ %materialAssetId);
       return;
    }
             
+   // Skip over obviously bad cases.
+   if (  !isObject( %mat ) || 
+         !%mat.isMemberOfClass( TerrainMaterial ) )
+      return;
+      
+   %this.activeMat = %mat;
+            
    // Read out properties from the dialog.
    
    %newName = %this-->matNameCtrl.getText(); 
@@ -552,6 +686,17 @@ function TerrainMaterialDlg::saveDirtyMaterial( %this, %mat )
    %isSRGB = %this-->isSRGB.getValue(); 
    %invertRoughness = %this-->invertRoughness.getValue(); 
    
+   //Effects
+   %effectColor0 = %this-->effectColor0Swatch.color;
+   %effectColor1 = %this-->effectColor1Swatch.color;
+   %showFootsteps = %this-->showFootprintsCheckbox.getValue();
+   %showDust = %this-->showDustCheckbox.getValue();
+   
+   %footstepSound = %this.getBehaviorSound("Footstep", %this-->footstepSoundPopup.getText());
+   %impactSound = %this.getBehaviorSound("Impact", %this-->impactSoundPopup.getText());
+   
+   %fxMat = %assetDef.getFXMaterialDefinition();   
+   
    // If no properties of this materials have changed,
    // return.
 
@@ -573,7 +718,15 @@ function TerrainMaterialDlg::saveDirtyMaterial( %this, %mat )
          %mat.blendHeightBase == %blendHeightBase &&
          %mat.blendHeightContrast == %blendHeightContrast &&
          %mat.isSRGB == %isSRGB &&         
-         %mat.invertRoughness == %invertRoughness && false)               
+         %mat.invertRoughness == %invertRoughness &&
+         %fxMat.effectColor[0] == %effectColor0 &&
+         %fxMat.effectColor[1] == %effectColor1 &&
+         %fxMat.showFootprints == %showFootsteps &&
+         %fxMat.showDust == %showDust && 
+         %fxMat.footstepSoundId == getField(%footstepSound, 0) &&
+         %fxMat.customFootstepSound == getField(%footstepSound, 1) &&
+         %fxMat.impactSoundId == getField(%impactSound, 0) &&
+         %fxMat.customImpactSound == getField(%impactSound, 1) && false)               
       return;
    
    // Make sure the material name is unique.
@@ -614,11 +767,35 @@ function TerrainMaterialDlg::saveDirtyMaterial( %this, %mat )
    %mat.isSRGB = %isSRGB;
    %mat.invertRoughness = %invertRoughness;
    
+   //effects
+   %fxMat.effectColor[0] = %effectColor0;
+   %fxMat.effectColor[1] = %effectColor1;
+   %fxMat.showFootprints = %showFootsteps;
+   %fxMat.showDust = %showDust; 
+   %fxMat.footstepSoundId = getField(%footstepSound, 0);
+   %fxMat.customFootstepSound = getField(%footstepSound, 1);
+   %fxMat.impactSoundId = getField(%impactSound, 0);
+   %fxMat.customImpactSound = getField(%impactSound, 1);
+   
    //Save the material asset
-   %assetDef = AssetDatabase.acquireAsset(%mat.internalName);
    %assetDef.saveAsset();
+   %this.schedule(32, "cleanupDirtyMaterial");
 }
 
+function TerrainMaterialDlg::cleanupDirtyMaterial(%this)
+{
+   // Delete the snapshot.
+   TerrainMaterialDlgSnapshot.delete();
+
+   // Remove ourselves from the canvas.
+   Canvas.popDialog( TerrainMaterialDlg ); 
+                            
+   call( %this.onApplyCallback, %this.activeMat, %this.matIndex );
+   
+   TerrainMaterialDlg.matDirty = false;
+   
+   //%this.setActiveMaterial(%this.activeMat);
+}
 //-----------------------------------------------------------------------------
 
 function TerrainMaterialDlg::snapshotMaterials( %this )

From c2857efe281b89c32a554d1e21fc9f5a8ccfc602 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Thu, 31 Mar 2022 00:40:24 -0500
Subject: [PATCH 347/399] Adds logic to up-convert non-embedded terrain
 materials and materials to have embedded definitions

---
 .../scripts/materialEditor.ed.tscript         | 19 ++++++++++++++++-
 .../interfaces/terrainMaterialDlg.ed.tscript  | 21 ++++++++++++++++++-
 2 files changed, 38 insertions(+), 2 deletions(-)

diff --git a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
index de003fdc8..cf2afc7b3 100644
--- a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
@@ -1963,7 +1963,24 @@ function MaterialEditorGui::save( %this )
       MaterialEditorGui.copyMaterials( materialEd_previewMaterial, notDirtyMaterial );
       
       %assetDef = AssetDatabase.acquireAsset(MaterialEditorGui.currentMaterialAsset);
-      %assetDef.saveAsset(); //write it out
+      %didEmbed = false;
+      %matScriptFile = %assetDef.getScriptPath();
+      if(%matScriptFile !$= "")
+      {
+         //lets up-convert to embedded
+         %assetDef.add(%assetDef.materialDefinitionName);
+         %assetDef.scriptFile = "";
+         %didEmbed = true;
+      }
+      
+      //write it out
+      if(%assetDef.saveAsset())
+      {
+         if(%didEmbed)
+         {
+            fileDelete(%matScriptFile); //cleanup the old definition file  
+         }
+      }
    }
    else
    {
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript
index 745ee906a..e5fd3d27a 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript
@@ -778,7 +778,26 @@ function TerrainMaterialDlg::saveDirtyMaterial( %this, %materialAssetId )
    %fxMat.customImpactSound = getField(%impactSound, 1);
    
    //Save the material asset
-   %assetDef.saveAsset();
+   %didEmbed = false;
+   %matScriptFile = %assetDef.getScriptPath();
+   if(%matScriptFile !$= "")
+   {
+      //lets up-convert to embedded
+      %assetDef.add(%mat);
+      %assetDef.add(%fxMat);
+      %assetDef.scriptFile = "";
+      %didEmbed = true;
+   }
+   
+   //write it out
+   if(%assetDef.saveAsset())
+   {
+      if(%didEmbed)
+      {
+         fileDelete(%matScriptFile); //cleanup the old definition file  
+      }
+   }
+
    %this.schedule(32, "cleanupDirtyMaterial");
 }
 

From bae6a3f514cecf2f2e425b920fb2e409e9d83e02 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Thu, 31 Mar 2022 18:58:06 -0500
Subject: [PATCH 348/399] Fixes assignment of the mapTo field for terrain FX
 materials to point to the assetId rather than just the assetName, fixing the
 material mapping lookups Fixes project import to comply to above change Makes
 Material default mEffectColor to white instead of whatever default value it
 comes up with due to memset

---
 Engine/source/materials/materialDefinition.cpp              | 3 +++
 .../assetBrowser/scripts/assetTypes/terrainMaterial.tscript | 2 +-
 .../importers/pre40/T3Dpre4ProjectImporter.tscript          | 6 +++---
 .../scripts/interfaces/terrainMaterialDlg.ed.tscript        | 2 +-
 4 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/Engine/source/materials/materialDefinition.cpp b/Engine/source/materials/materialDefinition.cpp
index 7b3d2c7de..4204dfe63 100644
--- a/Engine/source/materials/materialDefinition.cpp
+++ b/Engine/source/materials/materialDefinition.cpp
@@ -229,6 +229,9 @@ Material::Material()
 
    dMemset(mEffectColor, 0, sizeof(mEffectColor));
 
+   mEffectColor[0] = LinearColorF::WHITE;
+   mEffectColor[1] = LinearColorF::WHITE;
+
    mFootstepSoundId = -1;     mImpactSoundId = -1;
    mImpactFXIndex = -1;
    INIT_ASSET(CustomFootstepSound);
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrainMaterial.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrainMaterial.tscript
index c9c9ba83d..8df0a1fa3 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrainMaterial.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrainMaterial.tscript
@@ -32,7 +32,7 @@ function AssetBrowser::createTerrainMaterialAsset(%this)
    
    %fxMatDef = new Material("TerrainFX_" @ %assetName)
    {
-      mapTo = %assetName;
+      mapTo = %moduleName @ ":" @ %assetName;
       footstepSoundId = 0;
       terrainMaterials = "1";
       ShowDust = "1";
diff --git a/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript b/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript
index 7c50130b2..798d2be01 100644
--- a/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript
+++ b/Templates/BaseGame/game/tools/projectImporter/importers/pre40/T3Dpre4ProjectImporter.tscript
@@ -1203,7 +1203,7 @@ function T3Dpre4ProjectImporter::processTerrainMaterialObject(%this, %fileObject
             {
                %fxMatObj = getField(%fxMatList, %i);
                %fxMatObjMapTo = findObjectField(%fxMatObj, "mapTo");
-               if(%fxMatObjMapTo $= %objectName)
+               if(%fxMatObjMapTo $= %objectName || %fxMatObjMapTo $= %assetName)
                {
                   %fileObject.FXMaterial = %fxMatObj;
                   break;
@@ -1215,7 +1215,7 @@ function T3Dpre4ProjectImporter::processTerrainMaterialObject(%this, %fileObject
       if(%fileObject.FXMaterial !$= "")
       {
          //Ensure our mapto is up to date for any name sanitize/tweaks
-         setObjectField(%fileObject.FXMaterial, "mapTo", %objectName);
+         setObjectField(%fileObject.FXMaterial, "mapTo", %moduleName @ ":" @ %assetName);
          
          //we associated to an FX material, so process that now
          %objectDefinition = "";
@@ -1249,7 +1249,7 @@ function T3Dpre4ProjectImporter::processTerrainMaterialObject(%this, %fileObject
          //if after all that we still have no FXMaterial, just create a new one
          %fxMat = new Material("TerrainFX_" @ %objectName)
          {
-            mapTo = %objectName;  
+            mapTo = %moduleName @ ":" @ %assetName;  
          };
          %asset.add(%fxMat);
       }
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript
index e5fd3d27a..1eb7af85d 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript
@@ -603,7 +603,7 @@ function TerrainMaterialDlg::prepSaveDirtyMaterial(%this, %material)
       if(!isObject(%fxMat))
       {
          %fxMat = new Material("TerrainFX_" @ %assetDef.assetName){
-            mapTo = %assetDef.assetName;
+            mapTo = %material.internalName;
          };
          
          %assetDef.add(%fxMat);

From d044ae0702406ea7614b0241db948a131079ef95 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Sun, 3 Apr 2022 20:00:30 -0500
Subject: [PATCH 349/399] Removed unneeded default irradiance and prefilter
 cubemaps, and their convars Added getGUIPath console function to guiAsset
 Corrected console function documentation for getScriptPath in MaterialAsset
 Added getter console functions to PostEffectAsset Added getAnimationPath
 console function to PostEffectAsset Fixes handling of mapto with the reskin
 usage when generating preview renders for ShapeAssets Standardizes
 getShapeFile to getShapePath on ShapeAsset to better match formatting of
 other getters on assets Adds sanity checking for getStringWidth to prevent
 crash if there's an issue with the font being ready at time of request(from
 Az) Earlies out on rendering of impostors if it's the deferred bin to prevent
 unneeded duplicate rendering messing up results(from Az) Fixed duplicate
 naming of quality levels on LightingQualityList Added check so if
 _makePrettyResString is handed a 'human formatted' resolution string(as in,
 has <width> x <height> it can handle that properly Shifted yes/no and on/off
 option lists to globals for ease and consistency of handling on options menu
 Improves check for unapplied graphics options on options menu and applies
 them all at once Add sanitizing of variable names so getVariable doesn't have
 issues when looking up array variables in optionsMenu logic Adds better
 tracking of what options menu category is shown so refreshes don't reset it
 Add better handling for changing resolution in options menu and getting it to
 apply properly Adds better utility functions for setting bools vs
 optionsLists vs quality lists and updates options fields to use the most
 appropriate Removes redundant setting of $pref::SFX::channelVolume vars in
 defaults.tscript Removed unneeded extra logging from asset browser
 drag-n-drop actions Adds item to RMB context menu in AB to regenerate preview
 images Fixes move command for asset types(needed to properly reference the
 full path of the associated files) and added it for shapes, animations and
 terrains Added logic so when the dropdown for selecting a target module on
 the Create New Asset window is changed, it forcefully updates the target path
 to point to the module to avoid erroneous paths being provided Adds proper
 clamping of values to Forest Editor's brush size in the editor bar. Could be
 set to below 1 even though it would visually clamp to 1. Temporarily disables
 fields and handling of 'open in Torsion'. Fixes bad pixel in
 gui/images/tab_border.png which was causing it to fail to generate bitmap
 array properly Makes the New GUI option from menubar in GUI Editor use same
 Create New Asset method as everything else Disables access to the CubemapDesc
 reflector field in the material editor as it's not nominally used now in
 favor of probes Adds proper loading of roughness and metalness fields in
 material editor Fixes the default ReflectProbePreviewMat to use a better base
 DiffuseMap (No Material) rather than the occluder Fixes disable display for
 some options in the advanced panel in the shape editor so they look more
 fitting to everything else Adds check to avoid spam of markItem errors in the
 event requested tree item is invalid Fixed remove material button and command
 in TerrainMaterial Editor

---
 Engine/source/T3D/assets/GUIAsset.cpp         |   7 +
 Engine/source/T3D/assets/MaterialAsset.cpp    |   3 +-
 Engine/source/T3D/assets/PostEffectAsset.cpp  |  18 ++
 .../source/T3D/assets/ShapeAnimationAsset.cpp |   6 +
 Engine/source/T3D/assets/ShapeAsset.cpp       |  11 +-
 Engine/source/gfx/gfxTextureManager.cpp       |  10 -
 Engine/source/gfx/gfxTextureManager.h         |   5 -
 Engine/source/gui/core/guiTypes.cpp           |   2 +-
 .../renderInstance/renderImposterMgr.cpp      |   1 +
 .../core/rendering/Core_Rendering.tscript     |   2 -
 .../rendering/images/default_irradiance.dds   | Bin 131192 -> 0 bytes
 .../default_irradiance_image.asset.taml       |   8 -
 .../rendering/images/default_prefilter.dds    | Bin 131192 -> 0 bytes
 .../images/default_prefilter_image.asset.taml |   8 -
 .../rendering/scripts/graphicsOptions.tscript |   7 +-
 .../game/data/UI/guis/optionsMenu.tscript     | 266 +++++++++++++-----
 Templates/BaseGame/game/data/defaults.tscript |   5 -
 .../assetBrowser/scripts/assetBrowser.tscript |  24 +-
 .../scripts/assetTypes/cpp.tscript            |   2 +-
 .../scripts/assetTypes/cubemap.tscript        |   2 +-
 .../scripts/assetTypes/gameObject.tscript     |   2 +-
 .../scripts/assetTypes/gui.tscript            |   6 +-
 .../scripts/assetTypes/image.tscript          |  38 +--
 .../scripts/assetTypes/level.tscript          |   8 +-
 .../scripts/assetTypes/material.tscript       |  51 ++--
 .../scripts/assetTypes/postFX.tscript         |   8 +-
 .../scripts/assetTypes/script.tscript         |  10 +-
 .../scripts/assetTypes/shape.tscript          |  55 ++--
 .../scripts/assetTypes/shapeAnimation.tscript |  18 +-
 .../scripts/assetTypes/sound.tscript          |  16 ++
 .../scripts/assetTypes/terrain.tscript        |  16 ++
 .../assetTypes/terrainMaterial.tscript        |  57 +++-
 .../assetBrowser/scripts/editAsset.tscript    |  12 +
 .../assetBrowser/scripts/newAsset.tscript     |  47 +++-
 .../assetBrowser/scripts/popupMenus.tscript   |  10 +-
 .../forestEditor/forestEditToolbar.ed.gui     |   2 +-
 .../forestEditor/forestEditorGui.tscript      |   2 +-
 .../tools/gui/editorSettingsWindow.ed.tscript |   2 +-
 .../game/tools/gui/images/tab_border.png      | Bin 276 -> 8877 bytes
 .../scripts/guiEditorCanvas.ed.tscript        |   8 +-
 .../gui/guiMaterialPropertiesWindow.ed.gui    |   1 +
 .../scripts/materialEditor.ed.tscript         |  42 ++-
 .../ReflectProbePreviewMat.asset.taml         |   2 +-
 .../gui/shapeEdAdvancedWindow.ed.gui          |   2 +
 .../scripts/shapeEditor.ed.tscript            |   6 +-
 .../scripts/editors/creator.ed.tscript        |   1 +
 .../scripts/editors/terrainEditor.ed.tscript  |   4 +-
 47 files changed, 576 insertions(+), 237 deletions(-)
 delete mode 100644 Templates/BaseGame/game/core/rendering/images/default_irradiance.dds
 delete mode 100644 Templates/BaseGame/game/core/rendering/images/default_irradiance_image.asset.taml
 delete mode 100644 Templates/BaseGame/game/core/rendering/images/default_prefilter.dds
 delete mode 100644 Templates/BaseGame/game/core/rendering/images/default_prefilter_image.asset.taml

diff --git a/Engine/source/T3D/assets/GUIAsset.cpp b/Engine/source/T3D/assets/GUIAsset.cpp
index a8f4fe0f3..7c1aa1d0a 100644
--- a/Engine/source/T3D/assets/GUIAsset.cpp
+++ b/Engine/source/T3D/assets/GUIAsset.cpp
@@ -226,6 +226,13 @@ DefineEngineMethod(GUIAsset, getScriptPath, const char*, (), ,
 {
    return object->getScriptPath();
 }
+
+DefineEngineMethod(GUIAsset, getGUIPath, const char*, (), ,
+   "Gets the GUI file path associated to this asset.\n"
+   "@return The full script file path.")
+{
+   return object->getGUIPath();
+}
 #endif
 
 //-----------------------------------------------------------------------------
diff --git a/Engine/source/T3D/assets/MaterialAsset.cpp b/Engine/source/T3D/assets/MaterialAsset.cpp
index 6eb4ea200..77b22cc24 100644
--- a/Engine/source/T3D/assets/MaterialAsset.cpp
+++ b/Engine/source/T3D/assets/MaterialAsset.cpp
@@ -449,8 +449,7 @@ DefineEngineStaticMethod(MaterialAsset, findMaterialDefinitionByAssetId, S32, (c
 
 
 DefineEngineMethod(MaterialAsset, getScriptPath, const char*, (), ,
-   "Queries the Asset Database to see if any asset exists that is associated with the provided material name.\n"
-   "@return The AssetId of the associated asset, if any.")
+   "Gets the script file path for the asset.")
 {
    return object->getScriptPath();
 }
diff --git a/Engine/source/T3D/assets/PostEffectAsset.cpp b/Engine/source/T3D/assets/PostEffectAsset.cpp
index e20aedef7..2b8a7091c 100644
--- a/Engine/source/T3D/assets/PostEffectAsset.cpp
+++ b/Engine/source/T3D/assets/PostEffectAsset.cpp
@@ -206,3 +206,21 @@ void PostEffectAsset::setGLSLShaderFile(const char* pShaderFile)
    // Refresh the asset.
    refreshAsset();
 }
+
+DefineEngineMethod(PostEffectAsset, getScriptPath, const char*, (), ,
+   "Gets the script file path for the asset.")
+{
+   return object->getScriptPath();
+}
+
+DefineEngineMethod(PostEffectAsset, getHLSLShaderPath, const char*, (), ,
+   "Gets the HLSL Shader file path for the asset.")
+{
+   return object->getHLSLShaderPath();
+}
+
+DefineEngineMethod(PostEffectAsset, getGLSLShaderPath, const char*, (), ,
+   "Gets the GLSL Shader file path for the asset.")
+{
+   return object->getGLSLShaderPath();
+}
diff --git a/Engine/source/T3D/assets/ShapeAnimationAsset.cpp b/Engine/source/T3D/assets/ShapeAnimationAsset.cpp
index f7e1b6aa5..649fc7bca 100644
--- a/Engine/source/T3D/assets/ShapeAnimationAsset.cpp
+++ b/Engine/source/T3D/assets/ShapeAnimationAsset.cpp
@@ -204,3 +204,9 @@ DefineEngineMethod(ShapeAnimationAsset, getAnimationCount, S32, (), ,
 {
    return object->getAnimationCount();
 }
+
+DefineEngineMethod(ShapeAnimationAsset, getAnimationPath, const char*, (), ,
+   "Gets the Animation file path associated to this asset.")
+{
+   return object->getAnimationPath();
+}
diff --git a/Engine/source/T3D/assets/ShapeAsset.cpp b/Engine/source/T3D/assets/ShapeAsset.cpp
index fb3be2341..231d42cb9 100644
--- a/Engine/source/T3D/assets/ShapeAsset.cpp
+++ b/Engine/source/T3D/assets/ShapeAsset.cpp
@@ -576,9 +576,12 @@ const char* ShapeAsset::generateCachedPreviewImage(S32 resolution, String overri
    // We need to create our own instance to render with.
    TSShapeInstance* shape = new TSShapeInstance(mShape, true);
 
-   if(overrideMaterial.isNotEmpty())
-      shape->reSkin(overrideMaterial, mShape->materialList->getMaterialName(0));
-
+   if (overrideMaterial.isNotEmpty())
+   {
+      Material *tMat = dynamic_cast<Material*>(Sim::findObject(overrideMaterial));
+      if (tMat)
+         shape->reSkin(tMat->mMapTo, mShape->materialList->getMaterialName(0));
+   }
    // Animate the shape once.
    shape->animate(0);
 
@@ -676,7 +679,7 @@ DefineEngineMethod(ShapeAsset, getAnimation, ShapeAnimationAsset*, (S32 index),
    return object->getAnimation(index);
 }
 
-DefineEngineMethod(ShapeAsset, getShapeFile, const char*, (), ,
+DefineEngineMethod(ShapeAsset, getShapePath, const char*, (), ,
    "Gets the shape's file path\n"
    "@return The filename of the shape file")
 {
diff --git a/Engine/source/gfx/gfxTextureManager.cpp b/Engine/source/gfx/gfxTextureManager.cpp
index 8341b1b6c..733f3ba7f 100644
--- a/Engine/source/gfx/gfxTextureManager.cpp
+++ b/Engine/source/gfx/gfxTextureManager.cpp
@@ -46,8 +46,6 @@ S32 GFXTextureManager::smTextureReductionLevel = 0;
 String GFXTextureManager::smMissingTexturePath(Con::getVariable("$Core::MissingTexturePath"));
 String GFXTextureManager::smUnavailableTexturePath(Con::getVariable("$Core::UnAvailableTexturePath"));
 String GFXTextureManager::smWarningTexturePath(Con::getVariable("$Core::WarningTexturePath"));
-String GFXTextureManager::smDefaultIrradianceCubemapPath(Con::getVariable("$Core::DefaultIrradianceCubemap"));
-String GFXTextureManager::smDefaultPrefilterCubemapPath(Con::getVariable("$Core::DefaultPrefilterCubemap"));
 String GFXTextureManager::smBRDFTexturePath(Con::getVariable("$Core::BRDFTexture"));
 
 GFXTextureManager::EventSignal GFXTextureManager::smEventSignal;
@@ -75,14 +73,6 @@ void GFXTextureManager::init()
       "The file path of the texture used to warn the developer.\n"
       "@ingroup GFX\n" );
 
-   Con::addVariable("$Core::DefaultIrradianceCubemap", TypeRealString, &smDefaultIrradianceCubemapPath,
-      "The file path of the texture used as the default irradiance cubemap for PBR.\n"
-      "@ingroup GFX\n");
-
-   Con::addVariable("$Core::DefaultPrefilterCubemap", TypeRealString, &smDefaultPrefilterCubemapPath,
-      "The file path of the texture used as the default specular cubemap for PBR.\n"
-      "@ingroup GFX\n");
-
    Con::addVariable("$Core::BRDFTexture", TypeRealString, &smBRDFTexturePath,
       "The file path of the texture used as the default irradiance cubemap for PBR.\n"
       "@ingroup GFX\n");
diff --git a/Engine/source/gfx/gfxTextureManager.h b/Engine/source/gfx/gfxTextureManager.h
index 5e4d7a070..90a8a4bc6 100644
--- a/Engine/source/gfx/gfxTextureManager.h
+++ b/Engine/source/gfx/gfxTextureManager.h
@@ -75,9 +75,6 @@ public:
    /// Provide the path to the texture used to warn the developer
    static const String& getWarningTexturePath() { return smWarningTexturePath; }
 
-   static const String& getDefaultIrradianceCubemapPath() { return smDefaultIrradianceCubemapPath; }
-   static const String& getDefaultPrefilterCubemapPath() { return smDefaultPrefilterCubemapPath; }
-
    static const String& getBRDFTexturePath() { return smBRDFTexturePath; }
 
    /// Update width and height based on available resources.
@@ -217,8 +214,6 @@ protected:
    /// File path to the warning texture
    static String smWarningTexturePath;
 
-   static String smDefaultIrradianceCubemapPath;
-   static String smDefaultPrefilterCubemapPath;
    static String smBRDFTexturePath;
 
    GFXTextureObject *mListHead;
diff --git a/Engine/source/gui/core/guiTypes.cpp b/Engine/source/gui/core/guiTypes.cpp
index 85032a2ed..dd5874ee9 100644
--- a/Engine/source/gui/core/guiTypes.cpp
+++ b/Engine/source/gui/core/guiTypes.cpp
@@ -735,7 +735,7 @@ DefineEngineMethod( GuiControlProfile, getStringWidth, S32, (const char* string)
    "@param string String to get the width of."
    "@return width of the string in pixels." )
 {
-   return object->mFont->getStrNWidth( string, dStrlen( string ) );
+   return (object->mFont) ? object->mFont->getStrNWidth( string, dStrlen( string ) ) : -1;
 }
 
 DefineEngineMethod(GuiControlProfile, getBitmap, const char*, (), , "get name")
diff --git a/Engine/source/renderInstance/renderImposterMgr.cpp b/Engine/source/renderInstance/renderImposterMgr.cpp
index e0b8b3156..ab547e4fc 100644
--- a/Engine/source/renderInstance/renderImposterMgr.cpp
+++ b/Engine/source/renderInstance/renderImposterMgr.cpp
@@ -133,6 +133,7 @@ void RenderImposterMgr::_renderDeferred( const SceneRenderState *state, RenderDe
 
 void RenderImposterMgr::_innerRender( const SceneRenderState *state, RenderDeferredMgr *deferredBin )
 {
+   if (deferredBin == NULL) return;
    PROFILE_SCOPE( RenderImposterMgr_InnerRender );
 
    // Capture the GFX stats for this render.
diff --git a/Templates/BaseGame/game/core/rendering/Core_Rendering.tscript b/Templates/BaseGame/game/core/rendering/Core_Rendering.tscript
index ae6168dea..955c9d3da 100644
--- a/Templates/BaseGame/game/core/rendering/Core_Rendering.tscript
+++ b/Templates/BaseGame/game/core/rendering/Core_Rendering.tscript
@@ -5,8 +5,6 @@ function Core_Rendering::onCreate(%this)
    $Core::UnAvailableTexturePath = "core/rendering/images/unavailable";
    $Core::WarningTexturePath = "core/rendering/images/warnMat";
    $Core::CommonShaderPath = "core/rendering/shaders";
-   $Core::DefaultIrradianceCubemap = "core/rendering/images/default_irradiance.dds";
-   $Core::DefaultPrefilterCubemap = "core/rendering/images/default_prefilter.dds";
    $Core::BRDFTexture = "core/rendering/images/brdfTexture.dds";
    
    $Core::NoImageAssetFallback = "Core_Rendering:missingTexture_image";
diff --git a/Templates/BaseGame/game/core/rendering/images/default_irradiance.dds b/Templates/BaseGame/game/core/rendering/images/default_irradiance.dds
deleted file mode 100644
index 4cd4bdc6e38dd1b4c541eab745ee60ee7d86740c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 131192
zcmeFa>6c{Jb>&C<i~Y^LmI$D#a)^kGdB}*!$a$=+ta+YMGYU1JFczi)h{8mG69_g4
zQWB}A)T>ERb4zWBa!YPewk*l5?v`b_Th@}*)>1F|Px0~I=iK|=eJ@@_W|7od{t#N)
z>qQPo)^DGE?wjvDaNvCYz0Z8+GymN``L92-i7oY+|4RS=Gye@gKf?dz@w@xn@ALC#
zJ|q7B^^5=ZpKN~SGyg9?#{ajxG$%{Y;^M3<EX>M0HQ$ptXm*a8ksdTNYwBX#?afF>
z)s=P+n(4~4YDQYvwr04Uk!IJ_z}Bmd&s5E;Gb2@1Pb!^QWqeL*R!W^vbNJe8UP@hR
zK~?T9N_mD_l5%fJD!pZ?%&w@abE{IFTa)Vin$+gkWqEnt@rNE5zxROrJ;zTULJ!*T
zK?UAvr-<Kq;MuwD=kI~v6!P<P%s-3I+p!ye86Frr_`zN#d&Ez6$g$TJHe?0-%S*8b
zeHm~$7@UD^_){Ku{(85E446DWx1k5dZ|np4weA`0Lu<dTwO9TX@Vg8wEruDG)gFj5
z(2M#&>yI2*4>*40z}KJKL<aD+&w%mwkb{69pS=f3{+K=H_nGI`=RVDEx!2myTJ|mX
z$=cUZ|J9WR%RtZv3m6M@9Kcwh{80va1IB@V4+imD5A1|L$xi-q)bGxNAEEZ_`Pu@t
zA@#+*vbMUQ9xwx0eL((X2F!!)GLYtPY6g19fw716XCG8u2CV+G=!5O}<JxP_r~2M{
zKCFE_=6QDGU)*s9de|ROGqbS=eLdj%pr7B^hw{S%a(h|Ly$^HA`tP{*Zp_1&Z?)fu
zYF}U4l=aocC<BAW!nyfbnGJhDJ#hPhtZ|^vgPt^Jz)uaU{|@-I2O{=)N!C8x-)&d>
zO=*ySZ3+B70}IhuxQMZE0pd6?7mNd82D-=r`(Stmj6LFq2h4tE{=0GQlliyWlfB%f
zeD<-g3v)kY%+IQQV`-mkfPa0B888oQUobC=dQ1clcs!*1Ss5UIPdd&6e=IPasQ+O8
z&;#v%@@IMw^0Ve%DgN~SK6R`U_r2A=vAj?Au9JVK888oY3~=K>n1KX8JZPcT6l<SV
z|0Mq`#z4pKJn&<_);*|wf`7&z?}XV;AM4q8AMqpitbJp73;fGb23C=Q73>eg4EP=h
zGtl1y%m4)DcCRPXP6PS-dcfEpjXzcUzU=oO>v6oVFUGZRf`4-Z{5#Enj)Swh5AYeV
z`g{JK9Sd*A-!}&CfZz3fqV{3$`|Kx<ceu|>?(aF~``R~GjNfO#j{%7cq{hKndf@ki
z*!J_&gX|3G_|Mw!xc*_^+qjqD-!A(&&NqJU^H_U`{OEhuzPYkr_U&Dfy-@}*1`g=~
z?gx|~`$AuT9t+qQ$ow07n!m6A6a2F{4;WPcLHs+(e%A3$vi6=os|T{i0NW2{kAc?z
zkH+uMe;$RO=efy!zCX_m&hw&ie^~bSOLO&rY@z;}8^{30!J+$s1$Qjqj)i`#`lt5)
z9QV9*{}+w_{q^_f`HB60)cb?ReH-`E*>915b2aV(zaPXo!N4)#5%>p={{#4w>~_8r
z@B92Q&#-en^7oJXwP@V8eICa>X1|YL_X8PYKsW~eWAnS?|Mb4!>h3*o*Li|#Ja(?@
z`7?SyG43P#D+iQ+zpH;d2H3ISk5>QSJXnu^>=-C9{`Kwq+_|62eAaQVUgwIAd9D7u
z))ijk>gOMP%){EV_gkw6<tN8)=K(whOdkK@8X(5|==iTM`~KWFKK75#`vza@DB&7k
zDXRanUFYI8zQowqzu)6A-*A3A7Jjt)C(nWU`EmUR9%P;S*>S(W?qwdt{JiEDco1cP
z`F|At&1k=$;9q-``X|qW{P-VU2Z@gVajnB&1LJiMyY^w%z|!Y_>FXXz_7s0~z3WHe
zx3SOjbL?yFh@aO4!}CD9F0TCU{MVlYhy01_AGq$DzW&#L&Brp}`QvNdLH!f_@BsNQ
z>2d#d`Dgt-KgT}T{{#8M{a?%<T?g>Tzc}yp>~`)GUjvQ!!Or^teb>I-HSh46Z+N{s
z<_|M~u}?j)@juCL`+oL+MX&F>@z3r1B7U-C?AP&c0Dt<Ls6Pkv*MV4je?2_G?{Xhy
zKVVPr<9<iY-S<dd@3m|Gr8bzous<wf3^2`O8;}1<eq_Lnf1baJYn*o6pRRw*A07X=
z^Wf+l$XyS$>p;Huk$r#ckJ{_K5RCU$`}jVP-UI4(QFqfIcHZ}?sNB7db`RWM=0OoY
z6x&JuBKCcDugCIVnz8&VKaPLW{572OM)hA#)_-f0$G^*Z9b}{LI#8T_JOB5+AKweJ
zYhN)t?}N1x>|JEPEA<X#b&qRr{N?tHl)+7T{vtjbJNeTdEQopF`RzW>&iP&cWB+f*
z|Hg0E!PxupJ(1|XV00Zkz87Zq0gc_?10;Kz-`KmzyvgqOfgRkG@y~#rG7pSD^q@Zj
zMcoH31!Ld}dLXF(yyf55zrM7k*L<S!5B&S~F3Tp4d-XbCbRCrU0&rhck9&jcC;GmN
z`=DK9Kd8N9_xug;QXzj8Usu~*a8qe^^B`t7{wdVoG$&K&e~tmg4l{uIdk=7ruiT6I
zD|72O_ur5z&ijo&=m9tWH^HCGeta(^aZk9f_Az@0dDq%^JE*&<iEXpf0edIGUIR1P
zJ%1UWDXsf7*r8&io=i<Uh5Q%`%meFzI0I>ZyY``DAoc-11Kj^NqJ04PgW9k8dtt8j
z%>Mj>zyIU!gB!cnUfDZ1)`2qEjlYB3L+wt2o%L7#Y4EE;_8G8K-h-h2j(<w)?=pa6
z0FHqrSN}v0xP5@<uaiF-0}lq{9&10Z_X7KCKV#1U=$IeZz71~5v$Oub?w-94Zn7JH
z2brh94ra>OyQsUDXAk-5L+HVLkby<?fsFyBbPwR#U$O`GVLxE}ngJXGa?D?M_W<qw
z5Bq*r7WKM+Q2T)0Y9F(EezG?^ZREZ!<W93!$v)iyx2cc4)s-m~*jqDFKn4oPfN2(6
zdVu^VGC+R6ABZ!+ePDVFs4bG;9S6D|(EDG={i^Qo!)HNy_8bVFeb8q>X1g+jv98<e
zNXON^je1Xa+tLCrxjlQMP5w4&ZmMEi1vA-`{2eK^I#L8PW$d;skl!oe!JHJ-17=`B
zMgC%64;X(%$H3Hn!1X`_$ANbLm${$QG2ixggW0=aSAKANcF#|4&+hrF(`0Xh+Z5Fv
z+{RA+4%n$Km_vCFk{KX>p=~{2<AC)*(T@S)ejwEYHPk=ufdf&`+y0KZ@5utj`}z5}
z?mex2N7C%msJUlvD*H6*ZmNNoO0c)uQie)S<c`@pQfN}(r{F_gHG?hHlf34DeP9_d
z510YZpBe{U4_F3lAK-gH$3gT!lzZ)Yu!EoMbId)sv)J3Ly|Pau^AMODj=MfR4Q^8v
zTdLBUR_-Kw8|-bFYEquvwt4W!3i#Cn8wcVHSPx9G2QUss8NhK+c{bSt{#YQ)z>4nc
zQ1`{{*xS+pcgWrXvuAIBvyUCzWH<h4)SUu1m?>j#quyQ}aC>d%f%QO?ffRqVFB~`y
zZV5B6jJk8YPt<)buKNu7y*m@KPowtJl4Ngzy@k4)s;!n#A$ytZO;Zuue)hKH8x;5{
z^`R>{%>pvebUolQkPmvGpyS}8OlkdxWneFk2RHRt$Y;Rzb?o^WnMda5z^=K+I6ngo
zW^bYPEop$6?8@)Bjh*~0DK||ayYa(=#<Ubvp53-N@J9kaJ;;Hd(s7_Qi?M+68OZK|
zQqOvzJa8P?a^u~0?9<Xl&8_an-2`)*y%yCS?2eoKC8r{`Meve4W}imADbL;pJLNq{
z^5<B8RmeXt$qXz<<3Ooz97twhySjI}N%j_M?%9>U)s&i3728VFRK_;J-XMDm+$O8L
zXSc0!r}^namIqlGU=Jk6!8il!!u^2X7gTXgfct_t^Bw60neSq(8_eEB?VC~$*}+>)
zus5aDFcq;)vbUsAZ%JMS_WHEsBDH0*?t~0Xs=C<5J&<emB*z}mKA4j{js-Xl_Ge%P
z=LD-VECbf>p1rO8o@8&yG-_^jH|_?w$?o~d?b%uXvg0Pdu{Tk7sNMuO<=JhU!`GgF
z5<W!y^dZv&@;eVO1|-J;Hx35-!bAq<k{OttjoD`~&Ucabxb8{zCTgBwZ#KYfs$g4b
zG{9~uVH>f7Ic9I7-c-m={ua2&?&Wik%)q1@2eUJ<ux$p)xGoU&0QLoz`L?9l+nqt|
z4b;6MHSkj8CwH2?R0lsa<z#jD?AX?tl2d`Z77F~eX_<fz6R1BmS<mtyodMSaZ95+1
zzHq7=jDyj>0Q^A)W_oG%7RGwd-jo(<?(5zF_qOcd_3TOh2AHXky$Mz-=AXdl3G%Cq
ze**jz#{koeSPrZQaxLot8wZ#H^Z@00pg5Bp2Yd!9^LtZuAH?23?!oSA?(1G{)KT|3
zG7r`3;5HSprL^{7E;t!~19hi7yWf)A%ky)a^kBk!fIgUX<Dia(Iu6WZEVLd_4}uI7
zaZY4o;hHGF%Yg6q4r-oV_n6)I>q2hNuKZc-HSj|Pm9M>LZ^&eo0y{Jj$@8Z&pdMHT
zBL0Tsk37i8fb!e%;Ghg}tc%%^_qNY`Lz<|$uY0{&N55yY``T;W9e2!LN9LhwU2-aT
zpzP+s1U|?7^r9u>6tXam9x!EPz<S`v$pCW@vQKZrUJL7vnv>huYf`G!qzFzb!4Bq_
z-8`_`lRH!s++N;;n14LXK)oxL1Is|{0W-iJ;8^I#0gi)%Ghmr-VjtgM_Xg_i>+ab#
z_w|}opfXgVl%4!Fu$v0iniL#+$UlkiQAzejz)lYwzvdvz1LL329tg()*8}Q-@edsb
zX4jQ_=j_Jq*_D4Fdku9r<*;S;Co8cg@Yw|RikGi{=s}Wy-0ce{Gy`CF<G^HdR*wmD
z(Kt9b14SMa>T%(kt2=sqI_`I0cdfl<zJ~EG#SU)PJyCnDIqRNcuhhU!8Gp=P57=W5
z#wtx2L+!oBtDy%SF%QBF^n!iC4l)q!57)4NZ>aoOmu9blo9xvf^W_2TQ(64r&PDt+
z)SR-~k7H{x_A%r@*~y>qAmnc=f9%1q44?;6<G>WI5prMPGeCZ0uS=4>CTVufJ=l%E
zirQDDSgp#GQvq8lPdV;>cJm-+uY;8$yO-my_zX-V3-kc&s-0v2<KVDyz-8dk*sEYS
zZqJ^{Um<@Lb*FsxUG2*?8IOeem%&a&?1M89dtm(IZa<*oV8eP~66b_G9*oC<I0J=_
z?F-@ztf2Ngt@{qx9e2!LMbDci!0Z+BE4%lg?CT$Tkj%hXA_Eu$+&F0a0(#)aLG@t!
z3^4Oi?$PJWyyhPLZarU>3Tn=}N3}=3S@%Tk!CA=SFM}VNP=&Rxq3)Ecziz<|5B4An
zd(i*XSgHq-{LDfBIJlz>=(*8~W3NfQj~(3gpCr3^;A?N}N&Y?XU=R7#1LGg;LC^zH
z23!vW8SuwLc3!Y(=SJ?lfPGMJJ{o%|U3*veMD0=QoU40W`zm^!vJAxh=7F(?{BZ{M
z49!5-Wnc!!g#LJNR^ki<J>d2Q(Kvt%46A!0_ux*lS7fSELFP?)Y$+Y{GT51a<FC5h
z`~25XZ*qIN`X@5bLN9O}u>Amg!1^G_0NBYt;m1ME0LDQ-4uCx?1Id1`qUSC1+3Xec
zyov0Y{AG9mvF`n~HxI^2Ne}iQ6ET070p9~D{%Qt))C0pakZ)TL_zc7|0gOJ492hw;
za$w}Z$bpdqBL_wfj2sv_Fmhnzz{r7-10x4U4vZWaIWTfy<iK_gOw@2qzJ_blyiUt&
z))flZaLc%!TWZSgQbTqZ>#~cQs>u^mRe7RNQ9Yh7%j5ZyJeH%1^4R2*e3qIhn8x$+
zQ{y?)*rfbaqzU<{J=D1Bv)F!i&se0#@Y%FS9^Yen0$XYqHMU1~JMF=i8XGr_V@pj;
zP-8Obl$#tAuY7J?r~;(-<jC(mi1^I|<%b8Jf0y!`2gVN%BK~5Me}eqZgE9E<Nc?-?
z!2o`I|3~G|!w1hE@#A`Y#LpbS1Kz{v&p<7afya@9L<S}uf0TiMpE-C$eqVcTe^T{N
z^YfXM9c7@e2f_>t>Vf~C@Q2wC>z^OjXL2U$=E0y0>`sgWE(3*-zZ{GKsUGn8PuG9U
z#sKU6xc`Use$@Zl<bT5Tf4cXr_Hq8FlpptDqYMOnkTnkUWdQm2J)mO%a^QQwkAaCX
zz>k4o{}K3g>;pTu?Eh%&bK_q$_HDz@zNeHQ&ty*GKIBd_;KxDR4}=*Q+ykE-kb%!)
z9}w5yGBB+Ep1*JG8_2&$$Ny;D*X)leyXVj0-YfYBX8>biIoKCuWgu_kV7wpf?}5*z
z_Jf~A{Z+c}Bm219=h?pRaqI*A_?H;_va&yr-}Zk=eye?g-+7?-q@#U72gd`+eL;F(
z=ra)YK;N-|I}Sh(Faz}9v)Bii{&D#yvHxfP=P1_QDa=0eulL-^uYJIAFg+I9F;Ra8
zwi^e-W1)b5hzE}a8SwS@wI4e6q5l27{|Nke?tsrC={VrV!f|(8xU&qT$3Y$oy5qrM
z9Mt*`;5T;b0b^(W$CCSfW<P7}+bMr8+51J*pU>PRGmteF#u?a+<6`!Kj)TSRGoZ)B
z>OocptOp*$Sg>P$u<mT^kH@|^`^G=z#(v|+vnHVj+!y?WGw|4u3@AJK$5{Ju)SU9Q
z&#3<n_^tQ%Wb}RpKcBTxe#=4B2Yur}8^^@SeZk-il!9}DDLpTu2ag5g;A7*HV5Z3K
z_~F6hRDyrZ&Uu1y-`9T(UQmhN$G(3Ue^~osege<jE`r~CfM<}RvC#Tp@Hi0kL2zCe
z?F(=`^thfA+Bo3(>A_<d158N|l-+so#29K%!HZqkW}fp6<+rgv%09+_-RA|_SAM*E
z<UPo_K8P|9^#RY1gZ*J}Jg{8`%mZeC^|uVf9)MqSFoC*LuKw71eq$fPk9sHSulqfh
zeeC-pemC~9{_K0I#QNhoTjd|p2Yham=LY@zg6s_N`hY(#B!AKa)IXJh$KiqTn+H!Q
zzj@&KcOwHn_u+AGf_*315BUod`rcjSLC^=90UQ$y91DXC*!7X*x$zV3+6b==s0TPF
zejFKi+-2Z#c<?y-K-tMZZW)N#$6f9%|HeNy{Fp!D&&vLoXzx4z66^2y`OXdBJ>m0q
z91Di^fo1^LiR}773;V)k2JHHXT_1`)unasNc>s3uPmn+M;0bu}1p2^xunRe0{XILk
zdsG?Md%(_XJ{<e>m@mwJ(EDNb%jCzi^?dhIGoT&>W1%}P;&YljE*v}-;u={gzD5>#
zfDAl=W8x=#26D`R&q3(Hq&$HPD8KW-*vUU0@f-UXu60qVzE9OYdCZ$pd-Oi}i!-a>
z4?JK7Fcu8UKzOY%`?$C&yWI5wX23is!UyEQ^J_2U<q2d!rTpf>E_kqO+_R_nmEAlT
z$7lAxo$m+N`ub{b{KZuEl^^dG@f{Opz~><9gI51B!QipbGN5At_J_>CF1=1l{?LOd
zc>*3h0sbe@115T488CM8n+Ln$1GNXNl+`}wpTPI1=voKQcT)Ue-}`Z&>{O|@rtjAb
z?E`mAu+y<{w;mUR-+8dh^XDxCPoNK!Kk~pbunQjSLJqtKp56G(1J7@@H}=GJUh?~M
zJ?;C!*{_fv@6{FQ0s9~v3wAIT#(m(gl`;c%y*%;&8Q4`Q3q9DSV*xz?f8;@4b|DA5
z&<7^-U^nV-BDZM_+dh8qdj6r~UX*>SJ8SRxOPG6y?^szMtVqF)hmX<+@jV0I2Q}Fp
z^nrO$QV(`v9M}c^U8uh)^k7nUBL}-DjDHV&Nb--P=h^qh?b!#N>xbFbeV!Zl$WE2<
zZZ$KI*#~Yc^yf$Y#{}Vh6PE$KZxUx<H+o?A6f@v+Ko1;$<N^36Ed#re1LL2RJ@7yU
z53KgAKlmr8B!Ay^j!Acok97}gAMjVFCc(c~O3s5v>Vx$8QFOhO_l@vg1onsQ0hRM$
zH~L_A!DS%wpdh=EgWcdakv|7+@|y=^@WJHSao+|WP?IVf^Q`Z2P9L!Q<K3*<D?jEH
zh%%7q0~`}X$3?+0L3Dl;-Z#Lzetq}O%!57jAmXopA0A*F*bROaGO#-rdI0vxkbly#
zPoU<Mc@XmFz)O)^*#rKt_B`JAeP1n13i&JZn^F!v$l4!d^+Dn~f%SoTfOlWe1Nv?l
zGO!2NOX<O$$OC2|^nm={gFM(N=fNb|y*&R!vi6QW!H>L$eb4heWe@qmUL!x|72(_x
znt^m51jj`-7P@OicyBSjUdZ?Q;`@i=t`F1$*9Xd9tf~ilFc$0q{~q+g9%R5YC3}zo
zQ|!SQd>Eq#(D<bBPap#m_&fpb$pP&CJlAS(>|yOIuJ*>iPd(T+1L<SqA$>5;_n%w_
z#^Ax2<^UN`55PY~{?G&P=VK4Xa(OUQ<j;Yf{N{nNPk`N&!#1it>h9U6ayYg{y`$Q5
ztk*H$a?k9OzlwR4Dhp7m4~C6}wm-nTo9>$NB;RME+&yG{2Rz{c-kU@ZjAdmY%E6S3
z!Gkg6K>6uGj_h8OsJSW0K7pQxz*}%4`&7U_sP@LcW&G%aL<Z7hA+HncAOoBO#q*Ez
zolv|R=QH3v7()-JkbyDqj}?kwr|1Fs&4Y1xFisDk3HT86Pip;h;H1dz`9t>YYF{tr
zq>4FKA3XznPm%BI1sT9xFFN-PGBAPrCXol|gK_l$87Nr>m;>{`^Lr001LN>OrTlrB
zAivXO4(w3QDP(8;S@-_hW1K_Jhkei5lfSmKAN)JZz*H&&dA_fRaUjtL<VOZ3us`HD
zzzmRIg>fMEz-0hqfn}g1<H*4{GGH<fCg6c72X2#R=Qi(Dz_yT|1p6d<-c-W23~tJ^
z`@Sc8#2;mV`+{U2#Nz<Z53L6{PXWh(tPF7eC*wB{CPELuKaLEHV=Nd)2F8mO83(@#
zeW3h-2NTGFDGzqa^XIhw5j!|NyXPl+$+7qGJN5?azkFbL2Hf#LbdKyY5P6W1f!G7g
ziG;Z^CQ=zN56B;SKz{RJ0v=2hrW|`gCgH<m9{f-)4|XUY$=E%ARC};{e$76|`YG^I
z1Ndzmh>r(2=T7q6C?f;l=iGKW#~H2{>zr4d|B5}pd9lz3%m6)@Kp#xt-C^a|95{ZL
zgNdmUxGBdE4~*UTbIMN-@)3UlK2TFC<R09VXV=<;ne58%*qQxCDX72pfEx!=J)q}C
zI6qEg0LO%!$B#V_@pHa6dVqbQ&VvRICduzIFoC%OyayBDpTN7t6Ue{>_$P{GnLsb7
z2UFxP$|U(!mI2S7SAO##<S!O-V9$ZwRK~Up?n(wfv)?G?F|X>uL=RMXED#<O^4u`B
zFZAP}&R4>5Ae8~m0U7Zl1Cz?1%z*KG56JI5K>d+}Nq8_Bc#ta;#4BF_J5*4i_TZ%Y
z_#M0FXYMWgd1Y^se<j7Q$3y)+z&UtW|Ds+e!`vJ=7Kr#=2J$!_(z#E;pJNZWK41pu
z!6bViD+8JX<DWzhCY3+-AcqW?3gGtg{CTjOLVnggQTu?sUL3%m*bm^Gz@HbO{>qPe
z**Ir0_X80>=dbeooa>Yxpa*j30rh}A;4<Jnn1lzD7zZZtF8w6>U=sY3CA^1^3@Cr(
zK~ZwZL2k<U^YFp*7vKZyAG7CC|Gbo@Ofi36s^Fz+5ZUXfJG1ZWU*|pm^X%8$7?AFP
zvb#Q#$N=^Okq1E!MEouTInIfw{BZ`1KlFh7kn(#EO5mnq5AyIqrR?M{#QfkcI(B+c
zhAK`w<B#`)nfyKj19~9J0P4^Ak98hc<ewSHAp^N61DHn-eUP02^B{-%n_>_0@WJyJ
z;6q^w{LqvW**!nmBmSWFT7Or2t$(?o{ogkRZZ`&SUMANAQ#cmV`CQQh1?&fPzF+X?
zS%04a$DiXE;Kl*v=Nwy6A6N!*=z|<`5PFa=mcUMa^T7D00`>yf3&=iY?8*=JO32Ug
zF5)jp)AK*V7+7NcLw?L>o#clH%mBs!^*}RV^=Ag?K@M~0<v0eoaUh3rK!qO2sbYR*
zC%^Nc01sk*^MLFze?iJcDrWb+Un`;BP=f;dPWU<hDvyIWKfBJu=ElIN{+!R78Ne8z
zbKNrot_R4UkNBMj5x;qmLk4olK+*&7YYxibrW}6}>`qhY0k4Q3+$Ci<4=VUvbt3zt
z@N@2QUKbk1A9*m0pL1hJ9-#i1D>BRgb6_603}7x6pMg9)$d_Ud3h*J~hYwRlcmNfh
z$ezjX*muHT!?_@jgSY2Tjsa6{Kgcnlp!-3~zt2D(`vJ{=*aNN)vNB-oj$b_>yBFC_
zo}Js0ljXmF-bekxP9^G(><`NSPWW{Uz;RGm|4e>24zdTxpZDXSW&rt*_>&pPBLjJi
z1EB{6c;NY`;6uz`)cSjNZp%&;$DYkUh5ny%<3IQRw*MQ-kNMfTR>4mA3*i`m9#DSu
zAk_nySJd}F9%DfsW1;e^2duwkK>6uGiR@lvH+lY;eM%~&Db(In!<MRpx#5)L=kX6T
zEdLq&MH~ln{A2y6xDUi!|IB|szs~^XP)85sF%ITge<+VJK-nYyqz46fkl?2W>O;t1
z)ch+yILZF#{OtX~{m-?Utp3ct<zM-A9}x1x1Ju9Z^RM+!@uLUGZz6x%1LU6>!2DFk
zAA6we&VynJ9zZ3hGPu3^_?dSnW}v_RF?%%r;hsQx|Ht*Kw&m9hU<~A%7~Bs=J>crE
z{N95se#<}s9uy)E%BZ`SWuOQjLVo&CRwXl_`5(s5?7Q<HvS;y^aSj;QAM^C$7;s?y
z9Y5E{N%C_Xqz7Q{%K-YHJ%D*A{WuWuI}c+1GPucZitF$Bi-{hnft?EL->7i>JAi8d
zZtM&AD_Dz8_x}Uy|Bt~R^Z-04U@SC#mjQS%n7<VCfO$|s4ybCGGJfxYj)CNl&iztj
zpYm_$x?I`$CqLG&;P@BxKi59<#{lgA%=%-#{3rwA7=V32G!BwqJs^9)A9zqiFU0jH
zzj<K!H};sni29rA*iwxOwh{l9uCb9m_Tjo@JoXKbf35#_$`22s{`dRAfPY927=JPY
zQ{-2X-OIDvHo>p8w+syA4|^YLjYPd49Q)hYkN(H`&yUQXH3p{nT?Psm2b4dRfdqdU
z{FK%`_MnWf=|KhTl;wX={gL~SU&p@w-jDZvX?{EZ@%#V&{0H@q_=k*vL-{d(aa4cI
z?dbWjEtSFVRK}L_`~y8e{{3~I#Bop5`|-Xn9Q%{?-x+^_>><C70d60_btZHiK>sKB
z`!g_zpI)T-Lk}`DK>o1ysqAa-V?8GA|6t!2@nh`c+NN52cl?)Gf9wOZ`Tc${$zOm6
zmj8esbGJ@m95mS&P(&7z888og{f*ypFqj|XUa;Tex@-QtHyryC_2+)y?fV~vUp?SC
zfNJm<n9XnF;7<6N1Mfja`+y#llH&l!eyx9U+&6yi_k!%}ac_L=Q&N80_x;59gC0<R
z%)y@+12GOxZIgkL_CPWNNq+M{_XCc9yZHe|KOZ?Ta$w}Z$bpdqBL_wfj2sv_Fmhnz
zz{r7-10x4U4vZWaIWTfy<iN;**a6O|s_%oj_ri4DQ++pp&xP_CX^QU*@Oeqf)&aF=
z=xi-ieWrx>7W5tit~I-B?!5OvmGK;o3fHD9sx@4*UXv>BS61guHQc|eEqLvfI<D>4
z7ej60>+KZ&zWW>aJMrK3e}7$S_}`^CR}9~UQ#lXl$0Xhv_Fg=i5AIq!?>EB-UVq=-
zhYT+ge(>K-j+jaPNqybV>3Okrynb7q$Nwh8c>(;|pV>ZeZFKV@_Q5jImj^yqr_UEL
z3k!O`UGKXO@&Wg$EDzXf9_T~b3tuZT1UykzQr}B)lGie3y!Q9~|IV7uBdi|idvNB(
zqxfJRr22yQ*B;4-mDmUNN5TvLZ}l8I*=DmE`zkz+WpgNF&N#jUr{ep7*_p6+Wx_mQ
zjL`9c&ymODgFai!XKd96=f$u*gkuE8iYOC)yuiOV+Y|3i);4DJyve`I|D6?E2bAx>
z>buZ3cV5B==S4ab>P6HS!+gMVcH8=3V?<ef2*ykG!v3Afe|yk3-lKtA|KDeAmu=o;
zoga!Gc$p7bnTUPBn5p9=^I)0KcS(F6bYEeausme>5RVZ$PU=`0coF%L@+9F)7FWji
zddpJD5a$ioxuZE3hKlcldmp$BGr=D5V+7xsqX&F<2>ev059kf&MdSl|Bf1Z-eG&V>
z@iOVfl9XpCc#!aep8Pn%-|Q{f95DLsKj(np8lm0?+orv+-f%v^3w?jo?LYM$D(8b{
z0sX;utn3;4EFb1#A243>{&XbWf6@yt<|3AP;=TFNx10k>1$IAYtj!6M^g`zdi28%?
z3j6WWycp~Q-z^#B1D-$A=Wyvm;6>;IKX)nbLuxyNuT|#FU|$xIpMLGa`@NhOF!F()
z@$PTJ3%m>JbFniYtT&=OAQSq2O`i{z34I37`+#leMX@s<XTtjeKT4{U7lS<V-=|Oh
zGqz=j>jbFOhrwRNnaK7+-ye_mp?HrJ&(Hfzm=88iBz<tb!FLe&3@YD8;4_Kd3(Z8F
z3-f}0q&$iI@V@MP%XyJ??kn9oFX)N$Bb|%LhhVI*OxT**gMGlebvjmtJ|Gu5J`D1~
zyx_CymI=T09%OGz@TY{VsJ8LO)`#HS;84N~`Vwcu<_Gd)h4o0}h3k)gA23e1OvHKE
z&IfoA<sr<(ES}kiqD+_<MSQK&OeFm<ALvDfy7(UC*T+b12YV6CljO$?&X=NMUzpSf
z>_^7<E<MIfp9y`x9M4nJ3%+yi^Puk>Vc)5}!Dq02CR%tNQTu{EK;#eAj{S&ypdX#2
zGWne+(YhF%_YHG=Bz<smLn0e-kGRk1kAxSI5A<Vz4|tDa92)2Yo;kGffgTL=p_k#q
zEOJ1(Jov5iqJ(XhxF(8;>!ZZ7c>w$U(7C}<eG>aXPkbKC2c1&|xv(s_Jg5h;50(YX
zgJr>d&}Z=j9}1cWmx*b5;N^S6dk}7Ye`ND>9(<ek)NM2Th`mVqk@jLY<_8G9u)cr~
z<oD8^FduZT0gMlvdqLkj)}Fw-XM6`wv%u$2eHJVau?I6Ug`S8#u+K&GhvlGuTS7ic
z9WV1k*TUi4$APl_U{1jA74(YvfH~t_E<zvn;GJ>rL%#=j$KGcl@&I1onM=Nl9eV&D
zGzWM#72Bi-@FB{9_n-$4sH6wVpYUMT=DWrmmo^7{(g*K}%?s@N#I{KvEEk~<I**#m
zgU+et#)mPyKk9wZ`DQrJK;!}5Irct89^e^N|2%TS1M^`DJ)xS8eJH{Ym3m-4MC{}b
zJkT|ez|Sq`fA3f9iJu=?^WpkL=SvMTp>rp4{y@x|WOK=}CorEF#!H_C?}5&<gLkRu
z!vvnGrVo>N#@>6N8PFVr9&{`NnuD&f2ObpRL&Q%XoChUrO^)Ar5Uu~@=Y7ZgeuKS$
zKb#jfRKf?$pNqaodf<FWc!0T;GzXYp1>?dvJkU8;QXb^++_{PT&VwfTV-KcU^uYO`
z?Bw?{{+Qi+z^#n~ef-`Bzl9$<A9y+&m<KQE1Lg{a7hdK8ywDub14unU7BD90+)D6Z
zoKk*xp!}F`Kr?`MkI@U>1LHRjjNd$n`MUwP=bv#k54r7g8F?sodTy-`tapHUP5b57
z1hK98ko4nm^&$4+3Cs<a_Fy;WiZOo7C+9p+e)^E%!6ba32m1cC%Rs(?XV8&>0_8F=
zg>8Z#If!cycI2Sc_KH1FcE|rynA6(i*L(=J8J^g@@ZJM%-8|7Q51cpId%!tlcVUho
zX2E-~2lFM+gE71_Ob^EK-k4>eZu70+eFEdh`=<1uj`uG3{zZb{JTQLqph$M*HxHCO
z!9ODrH`)96y$`mH*8hM%x*km6h0Y0&ufsg(T+uEI-h-GQb7*P?Fpr?}V?HtE$DB%z
ze**6ialV<!LHzKb01vGGZJBCPWbc5RBDbl8ZJNJ~9GGHu=09HNjO#rO^MF1;&WG3o
z^Fil}$5_FB(D{PV2Re7G%K+z6r3X5vBs|c0<=}zwV{Rek#~d5VkN2$cjsca|`Xd9%
zZXOuB@f*AIK)K28<(bplo>ah2CHeiDS8j{>oj<E`?3xAp{21na4LykYF;}+p!1&<<
z*&}|-z!*Iszw=-M?@Z7G^5>`&f1%OR`cJ_J&tF6aJbwuph`Eiw-0r%X$NUxKpwgi{
zzgyocTJJ9Dfv$fP`9MEH{@8=ZF$X3+(7CcPCn7!Ah57O5!EVeAMgBdQBZu>8j$xh*
z@+&*|C(r}rpHzO#uc7>Sze?-hlmaq9er0$3#%}z^PJZ*CjQXnre&vqXV-Iv~GtA>Z
zXdABq<+I?{!GI5z0jvpto-lsQkxmbkAM-^kKjw>7e$1cR$B%iW@SYSk>G*SamxlcL
zn(-Iv#y{oxo6}NMk-aS?m9dw>pJeY!1s+7~0e=-4ploeRTi-72LA34{{ISpGfvy9B
zOz65O=mT9Ffm>wY2@3qXDDdy5z`utA{}_e(k5iZ{K-nFC4jzy{Pl3Ncfq#lp{+45>
z2cDf<a)<KV;nsLPx8M48J=5EMcDMc!=C_Xdu@*+auk7I8h4~N3zZ-J_l7A28!Xp0|
z=EEVsv19%?<;NUS;8%9=8#~^oQuc;pH~u0#VC_p(i)u@mnx>4ug00ou*sG|&%GKL*
z`)$abT;C4sykR{DQ?T|EvhbMmK-UAooX7M)*G0g*r#d%y2EWdm3jT5B$GmZPADH};
zcrP%g{FpzXYW#(o@lVx_zu0JsvA2xf@hiLIS8in|f5(_3c6iXCW~7!<A2Zf;N_@|G
zpld#n-SO)hDCmL5!LREf&;#X%2jJgLq5gX))Svw0<i~s<6BPI-De~i8xjY5_0tNml
z)SvuCWZ(0bn&fYx=F?7Xsi5{IaD%_9>;XTxYmrj?-I-_|+i*?Wkl(nm-W7cC9vC~;
zfI$w7-8|Uk_>~>}$`1Z9@Q+jApTHa_<X3j^=fJP*;8%9=Pbq&L?BH)Sq=fpb$R6-l
z;DhI{!iSjMe5j%RF}we49@N23CAl-!^^LgW^^QEhu7QI3>sk=pf`2zfcIC&s$etf_
zKutLQNyneVJCK|+BwxXNA&!5lX8gsv@s}Kbx!E*!@GG~nPm6Ms-SO8@|432YyHdwz
zlW}M9$Lm@8HI1>w8aAwZV!bEK>+jcp*@Zd2l^^px?^a<x^c+QY%!!P7@2CmKKZ*KJ
z;+^*#lz03E@>lV`Fa`c1>QDX>>QDYM>QDZPvXj3hRq$7*WByvZ9dpxzP6xb{=XTpJ
zwyyTvW-?<PFaQ0=!EZ7To=|q<*R?;uuWKMUeq+a6;AD6F6OMlp9*|$z9lx@JU)jN5
zRQ?*+jlb;pE6NWKls)FJ!GjuVZ~SekgI$%u-vGO523wQo47Ywwx0v0nZ-yL@U)Q_g
zR@upqwI9GwaUO7;3*7N5JNS(qb3=kZPj;w)`WGsgBgXL;!CwM@sa}&Z_{$Bdfx1&o
zsZx&LxXBKo_Vq}<?j32sg9hrairAALgzHw@8m6|MpL&4W`?bw%8?b|4*Zoj-<JbA`
z!LRdxgMWfjcH_@suB*KAV{SOS<4yi4@E5^v?8aYq{1xz59KW$Qr3QZ0G`3)`QxSU`
ztdwVW+km}^&#`8(eqX$9xBtv_?2_DWT|2B}!rJRvH(1+2>+blC9rNCkAM^VfJLW+K
ze-3m0abD0o`7zf;fdc;&_>1JPR-{DLs!~S%$zMVJ$zKJ374;{7t>yT^URROb)PM)7
zfWHYJR0-y6{&4NmC$LtZ=l5&6?NWBE@8$USfM3@;!F={(DzY2@gyWyY9H+*Pd0@5n
zm<!YKPk~?A!LRJ#FOy%{!LRJ#2YZcD_NLUaHTIS?Q2Pe>O;-CR_#<xecd3xsKDY3_
z7RG=CH?lx>u3s2&qX)>oI}*7~y3UE?H+IbV5B5ol?2bQ=`jfu^O@V(3^PChNf64Ke
zYsO!xS5f;K>dxBNjUD{Tt?W&3lO1yGO>CQ}zp)4WU~fetZ=e}`hC+Vh_Wb67uIJ|1
zbzQ579qZeGUDvw6b^^7hlpXxa4t`_D{HMxp{6+FtFb9gVm!*u_SHNFE{j1=wHfmB+
zcH^%H{Eg|D-?+&RY2Dk>!d4Y=dk^~A$*=2FM>RKgTeI4&We0Y@o|mra1^zJ#>v_cN
z#y^R9+{vHA{LbXhV}4We7cjS>&i{z{&XgVeCGeNQU#^xNd&StnUvvERW?hWEAq~{t
z*qhQs?VD}N*jt_Hn4A1v%DAVoHFdFtz#Pig+?Z{>TK$~n#@Az5$B68@t_}EgeGjZ-
zFahaW2jJH^-@&hQUW4D*!B2L_U&4GAW%85V@mEoQ*524_;3j(=++;WYCTgz&drL)b
zueMBseH!dBvuDRP#qGcD<3<+tV4XT&bH9cc+5LJx<H~OQla4*7>{#PK*)h*M*`X<|
zJ?4B>cFcQ;+ABNwjlC=pyW_8;{>tw7o8b5C#_jmQJ{`%k$NX*7zCGjB#pix`e!otq
zXOFmD-MNMp`MH*ji8VLH?8aZfeBQ=x{6)-dSpvVY8-Jy0{MA}nYV`_Km3o7!Nux>C
zrP-p$-jEh*uR`6YsSXwMw^8?4U{0{pgMM~?FXDD}=UR;syE2nI$<DQWVs@-+g4*XP
z)V@Hm?ymMRJLWpn+GCz8uvd|LWk>GGZ|qgaUW?dU%5MDA?Ph|#4SrREy)7NoJgF|e
z4%EYEC*@aWzfPxHuP|Wex^2Ghp53qK60>7%2W7|n_Fyk!PU9lyxMl4zpIw<k-&c_P
zD*0J=SNpo-XWg5W*1e8;le;0)sJ&-zqwXfKcTFAeN9tpz7csBr_FJpBXXiSdzTWYg
zZGQbGW5@bk$i1#*gY{cj_X5^%Ao~<@AG2d_cb9vzSCk#|n`!M!%C6jCZy@)SvDc&p
ze&Z%Pgu1sW$KFBRJ76~%dv~TSrVh4FJ#10uVe<U8Hm|X3y;*ZtcjZRrbGbq6Sj$D(
zv95vE-LqqEXJt43BzsxNAF{Vv#y&k=ciau*273qWD#zW$wu`#Q-25DJZ_nQCVVziH
zU*+;1vQJ`7$|O71Y(wqyT6e7Bq;=0`FQfL#?rLAHV*WDJo|&)LJ$pr(TK6hyo@8&g
zjlI)}*}L5qn8^*fde301Lak>K>f-A_v-lio2A@ryy`S6Ib-g;R`v7*A`y%RJLhVbK
zv)$M+r*j{BN$TKlXx)?S)5tvQ-bUWZ-qD&jrHi^7x3SO6OdD^+-IgA>69Q*%pl0y1
zm_Ov^XRCRVJr90g_X29qx=%Tgdk}jSb9VZ=*K3{~{0(DoHLdQ`sD0b9cN}{cb@%Ku
zsJC%XOAp+=o>#y<+mTr?rxp8P+++{s`E^ZN&HI?H(dO&^W3gk*t0DIxdsEpfLUwXT
z?8@B$Gr1vTeMUv*n0prNv#7U9nKQWO;Dc%g+u`zS@v`n*lhSi@tn=(zbFDkp>&mJ-
za$iR7E10XC(z++uOUQf~y$){5vA12_t>(r)19szXIqqq&lG!u|=2%^s17}h*_<FcP
zPki1(cH;&=)*bikQ&^9$pB?MAWU$u)_6Bml9eWqGXU%82#@?GT_Sv4X&w<@D&x3y+
z%t_72{QP$6$=rOujN9rSaijKy40c_w32Rf8bgUc1j=6hX=F{xczV6dC>7d_P_im>l
zR`aIxkoQ?+o!rXoxQ*Gk7r?$SPt6Qa58sCtocI}<A0S`%ABVl_GGD`Z7qT}s^JUFE
z+1oA1v0KfJy@$H9=4799?DMm2A@{-@Wz37<UIe#l0b5lM+u@45@Sb2h@1*Onx?bmc
zl)mn|HlNG<z`A1}AF|iA?wG3>nct3mhIJ>m*1YAor@@@$HfC^xbtzI$mKM{R#rLwc
zi0>z~FpGSceBHCyJ$Esc`3lE6Xc&8|fx0&<;_Kdt>Rw0Q8{kf|&m-$(w|aL_<E|`G
zj(HjNS_X5hSy^7%nU?T-p*Nuy<oE1;Jw}do%8s$V<k-ttlZr~RW339#%blou33*Ru
zp6uOrUFF$lk@q<Yc~@?*FCyz9_cGYYyW$0o6=+p8C#%azt>Ei~mhd&SoYE4$RxRS4
zM3?zKcICFQZa6#mYd-TKdqw+w82h|uCpTpE?h3g>X60Q5H~7{<t<1|>hF0;t)#X?#
z_#7+gM?4e2=+nr7kpm+KMh=V|7&$O<VC2Bafsq3v2SyHz92hw;a$w}Z$bpdqBL_wf
zZ07*i>N4S;H=g%tP<Zx%YG$Z~`z0n^H^=h<3E>`6D^s|SisuMIHSx8|-DCFmn)!@{
zf6ips)<1)_{T9#X@fkfQ|IA{v<^50f!1(Dw+J{Upz}`&rhhGOi==~+$U-QhVtv+Lc
z?`3W6xg$Jl$7k+#AU>P7GvT>iJiF}IEUST=^89}5vk-0*xo|$vi*2PI@R<_#TuBDA
zf6i+7cBhQlzo*YF!zbP1+3qUj`Tf@OM_bnup%3wA@PMD92mbR;wtU8>j^_#^!IO~P
zp0~8;4!8g8m^|A~wvL}3R9yzV2U&Tj!w0XJpW_9%y#{z-tmMs>K4ZvdEVq$9gNxr8
zzJ(WjMm<Z;7kz#|<aZuq`QSa#JOmziFXAoO;6tA>n2pyxTZx~izvgq7!x^(Zu;=sr
zbNcqIKA+dm6qx;5hMIxE1Ntz`3-zSWiwt)7QQJoPj4gg=+b!ze&-W<bOZgD+dmnU7
zOULd#@LQjQzAb#vX9lC~aOQ0};e|ePK6DFizK@Y1zNevrU-rIAddv5hAn?cQnZ{XA
zF9vwvy-06EPxNQ-;wQryd%^b*vgLR^_fEC}zxScf3wXfipuN(}JNp{B#``1oyI{fR
z?WFIU@ST$^4fMd?&+)bQ?`jR*y84&#ep{9*`2KePR{MGEk@sq+TmO!QZ3i$1KIpqh
z_&Re7Z%Qino*r^AoS*BunzHz#@45f|oq6Fs>-Qwd%J+);#rKVp8o)Zp1N}a@@vbJt
zcNPc9v!}NacbE(3L1re0{;Z$Tb0;{FMZeZ`w2izl5Bz(GJKKVr{GrlbxZ0=r(_cq^
z4CNe<UFTuMl*Ji*Pv1Ah*Zo_(e~Q1A5dJ;Gy@>hw?lQg5cbMHa@way9MP}dO-=W{%
z(cg&c+|QWBZQtX2sC*B1sPOOLd&;qrydk^#fjJFqz3=R82|rH=zFA+TdU6NcX|D&d
z8z)(_v<-jSpH#j5JN$k-jJ@w?_*=}6A6NRe&Vzo=RA%ve{&%dFS)Bdfv-i;5yZHDU
z`cD3iwwSX4b@a^PHo5M7Mg|;nVhqXpUS^JBPVx@Tt^OQroNHiPJqo*<w*&t^oxg)y
z{QJFZ-FM7ofq88rVSW#;iC)Z<WniEmfe*2_gW0u)m|LZgsn`oY4?`ZmmnryXb97{F
z1NM{;%ItV`9rz#Xvm0yhzY()1KWAn(V9#V5#60Nx&WjwjCeB-w?ZJ=FY+331JAnt<
zd-yuJwG8isHwVriS?YoD(}T1Mn8(U%3ZEZM+3Y$$4sujLPsNJ)qdsI!Ft1eFgGXWY
za}y2TV%{n@cNOPv3PmqG`*zzbUk3j-;3mJ9^C6FIf}Q-%gB<>igSZE?xp}FOkL=%Z
z?BpNdK>_plJ(}XY4Car2C(n7(;DfOzw^0_Ao%|;Kw+>{AS#4f2&P|pj%vXoMm#H8J
zne3R;uCNnjdPm*?!rY1UA(tUzPSuMwix{#P2Yqh<cl5V7mmh_UW^!UKKg??wYiEAw
ze0cCApHS>Y4!)@1Lr#Uc6!C9}g!v`C51Dlf|NS~AWd(DzLHPbo75`nE%Q0pQd3W|X
z&$%D_<mN==yok<+9JaAy4<_M(DfVE3b8JS6>zK($cCQ_KP>tsD9EbP(_Yd{}^I7W8
zZQIY9#h?6M4*z}39{Zs4herIEQxu;~A%F01-2vYiekZM@Z{gpw&w0$>oGH#{x)Tlh
z@5!AO<_ykp-eBY*)CA_0j`_`pan84l9AwGQN1SHu|Ju*poW14W-kuTj`C@M8!OHLn
zp5*#ue(0RR>H&S=T<V-lnfzXUo@uvLA2<hjHp7qm{lQ$rn1}x?=jQ|0ZR~~4l?`8P
z>-p({^TE$A9&OEoX#R1|L9R-Au?OC4r+%O8Z)Nji4sXoouHt;&{LJkj`QLThB)^**
z9bQaw&47sCts}to1eD+A*5~~4I>)&4z|XxuhVdcv!PY16>lFCyc0Tyui~rWPY=fAG
zd|&6mhZj00ezf)LC3qjWrix!nfgW(35i0h<)}G)R6oGVYikKtYhn@dCSyRl}k2M^A
zT;=?F7`k=q0>B5qR)lTI9}4X7!>_YJAI2!Z7K?7VK1-lz9iN@^Cj3IChO+894qV5;
zi)*~>KnZ@gJ_^3awNg~h3$7)jaz1dqA(hJl*Woe6KKON;vVGt>K0B22F<PqvT!jJJ
z5p#wwIebsWHF8ve2lPVMU2`753tNB7c>phLjZ5zV);NS8F@L;<Rp`ZTaM_x8$!+9I
zm>+x|#9Y8yK7HakCT?99zs619mTLex`Sqb}YhL(uv}}uY=io!U-WWVc`7oC9K|N3(
zvc1@iK8Xbn=!aA2lm9%3QP=KqyzytO=Y;jXLPhI;`E|e&TU!q)>4RT;lWWVFxGrbt
zgL>e6;JT*jLF7ZrazGCvA7U?J_Rt6WoRyuJ&1xI6Wqyv<wc^@VZhb4a23#Ir5AuU+
z=S4z3Z2eKUReoEalwQ~x&u(2`<);T;<PYV1NO;ji&8gUfEOvfxIHOz3EnL@a2cP|#
zc!{lBYc}!#e%M;ou@|<sx%n`j@*(CQ<U=YKefeNU`lb9q9TRKVC0Mb(VYKF>U;A;$
zHds^FuPIAEa#Y~OWaI<=!20eK*5K3}&;#|sGBJknat!OZhF<JJE|Pf&voXLE?+v#7
zyfJ5D{k~`|KdfcQH6Go%mwx@rVcR@@H;?~5_5o|u!=KQL(1!`EJsSJaH4oB0q`Xic
z=*6~vB>mBv;@{HG8gqKy<a&<5y1;JDXs#XIC+CxSKp&ix-}`_qGBN3;{PZC9VH}yz
zEI1#=u#T_hA@ad;k?>&$e#G1<UaUzNuI(DFfgG)m?fJ2Oyk9>(*m7<8J}>a!=CPi#
zDfYs$U|vjOZSw7Xa9*ef^x+Y_@SeDBvbLTny#*uIDBWI*_#G<wy9Io0e)ugsNO_S%
zE^;lZ--n4t&t<_fVOgLDP6;2fyyzb{{1}p1SNwaUwVk8Si}+q3tjEiBj?<dL_adnm
z-jhWs;A@ljVZnR|ya;`mgco5Rw)G*=8>w8dPrP&tHBXFx2ycRM3A~S{Dg1sykq6ET
z^hrLF^+pao68kVGu@BZ86Bs8#FUB!WL|O2e;1;={tUvrV@Bx0rb#}Ggju-2i7k>mz
zb(i4-75h=>ECrcZ419nm>cOM=!0~dtKER7;|6!hZUo_JZbF#L!hWRqq>`rS1--EEW
z{V)~rJN<$O_<Nxj=0og7oQKc{c%kFNuso#4i9ue(<7b#>UCVyQtgB$(xr+GRBK!*d
zh<&hJ6p#&{i9Grw-wrYn<ss!mG)83ihV4TKjGO3@fy{~88fO^{<yo&ae9l%0-_MkK
zKp&i3KBlk@y%^?$jScLJ(1!t;NR1Pr7j}#Z{;1x`EGz3U-nn%t?@*=Lb@)LAzVy~&
zALxgA5c^QTSn(tKkjey)C(>i4_af}yBy*~^Db@<UuFP#DHNPQcFZ`^WQ0!OQk7DRW
z<O94=4~F{?kCV)VKZal)(wT^lt3of>!vk~en2pu(g0GU$UVJ@VW&FI~7vuqdKg`9C
z=fi^agdZo|SjjO{_n#S=U@okmgIXt;hp;YyS+$An4&*#CFPtAPAF&VCBcTsAHn1;t
znuozYWO<=u*c|vZ&#ZB}&aSp#t%9>pi}>E+zM;zWM>9bmpvZ@fL?(VLA9zgVv*5Qu
zCcGChcUWs<u4XY0WZi-XgOv2Avam0anK%>XMG1a{W5lEQz~k%0e$)Ao^dcT7bPS97
zIfFY@-x~O9OIsP*kM9i<e8GRCQjg4!3jS8;#V{X=*mvyQ2RoKBAHrh@%S7mfjb+Ss
zD&Ik!`<Wf*GPVgFz}IO7zvKML^diVa?1Sw?!aNN0!5v>G_nYA{W#B`Qi9y`MnCoD!
zgEOHOe62c|+`8XO`V!|P&IEgBP#(Mwet)qp2_I%wZG3cNq(9e)j~@p65RGT9-bwDb
z&I#s-ldO-fEH8HCLo`l$AAC=^W2r~*q2P|K{n*{dtu+qnoMLW(yRmv`$ExFZ>nl{?
zSE5(U>neIA_F_OD2KwNStNV{9{rOh<Tx)yo_}`n&d>9@;YeU4JM}h|#Uc{O3KKOkJ
zJkY*y#~AaQw$F6?&2Vhs@pU*x7LkYaadqT_JJ+(Y9RHhr^)~K)=9seyX44UDhpT~~
zM;`Tg5qli@pgH(ave17F<<B|O=UKcKvEBRtqo0o)7&$O<VC2Bafsq3v2SyHz92hw;
za$w}Z$bpdqBL_wfj2sv_FmhnzK<oh5rAw~SWowk#`ec*3Hd#5nJ{i{Kv-Qbrjj{&T
z>1x*f8eL_q%@(ZDg*D1%utr&8eX?FlxJK7Pv^JTo(Pis%*&1E87TIjHF4y|XoUCL0
ztw^i*tXjY}skM~_tlvf1I$pYNms`6lUaxCjma%?U$Y0d;*|z7eRbqZ+*LC@fKVrw4
zgxx;&Ce~#G`)th4waJzjx>%RYbN9e(+@5&@oTdfY3)a1Bp%!IhEv2*{_?mvKs<3_;
zyzo9u1@-s*QSGrFrPkinzgo7n`N&_d_Sb$I>(jNv+DCP7U=7BAea_aTGj?*%VC^~M
zUdK9Y<R<T4%CT;OadSP?624AqFTUQ3-`Sh;V|{f|GqRTOfqvlGVaH#@I;_U;*X9ee
zpL6RH<}n9tf9+c?`%&$uQTsM>->G9g!X*15*q7!zQO%Vb>+Y?i<{O?H%$pQg_E8&4
zvK46=pOe~$ue~<$d)^oIV{IwQhxxE5p$`$i%YMnNO<2Y{eTmw;bs4qxSevkc`iFh*
zYu^cS-@|&0vsjOj>k%%X-?P{~H*2lT;3l)@-M@EPr~{iTnc9!<tM;zQmMZjOS-r4a
zm=Ej727Opl;n{Cr{~`QUWw+YbUG^JTo3V*;kG1b-uSpNJpGEB>c8qnt?yJcA8uFfI
z-*Vi>yDSI6c5vT{9NM>P+QN2gEz-e#Yxw!9>HxL}HdoCH{CD(XAADmjHYx25dJy|S
z4><Pw?3dsHdtYmhZAJS&CrN&*J=t~4PxB-9F?$o^d`lKF-jRI;<D6&TSee!SX3fdH
zAGtk%e=nI2kr}Lq!FpsrwQf3qE#<yGjIC;GT|GI7-=`<^V!!jkd{{9L-~+R;LBR)R
zLD^mJC-}(@RZGTS!`P>_ciHc+eFfuvRrhtX$o(90AF-q7J^MQ9PWDaYecw9RHx|LY
z1ny<6@nLY2`6xJ#9oUd#2RG#S!M&zK*h0tfwbxPn{3w3!2t+RqQ7Ip`;ORc*!DS)z
zAW?hNKT&(-XYS+dv+tE1^`A!V+ZgjZ81uX6`x#gJIplsG<NX5buIwGHd&s^8cGldu
zSL6t|kK*4>=Hp;G0nU?$H%&+O$tkCk*s2cilN0#)@k1v1aTE%DU>*)256r?Ar9EL;
z*t@>0IY{y+vtJGP>lpW0|A=365B?_jTNRl>?R(&7?Ufz5Uz(eiW#oQ!u`6WX%et@4
zBkv1Z^FydP>wOgU4w=b%`skLNp^ojBvw`?Eb(+G@PaWA(KTg08dT}i619~IuiL?jg
z*W3raUva(9?AI{%`Rq5q-$eae18P5uF^{!h=ry(Hm*?BEik@Fzno;(Bt8+2?zGbcX
zG35Njp$$2OTAn_-53E~q?)ZK=f8qdiP%fOL4n;bT&;0&5=<M+Wat5Lor{D#1;eCj+
zuz`Mn2bu*N7u16d%R$H=XWzy?&tG@FueDF{cZ1r`fuFTsMD3T6`_+YxtYNI*yWA79
z??>GaqSp_D{pkKx)O;P>d*uxN-Q+$G7V<uM>X2MIeONA?IU<);N3lJMuc;&Q<mn@F
z@zi0tfZwAZ^dj`(1pc1S!jS`eF)qX&?8n&1Uf_7Z{X$fG*ZWrcNn!SDtUuYIWbKRS
z`x5%TjJ~f(57}q!=UwfW(Dy5-{Tgz=0rt(+S+LK8eNowuf&B#7PlNp|YJMK|z6fqI
zUjg6Mvq$CHxnpwu{BhHT6WE@RYxtVFil1FMdrbYH7Z>0KeK<=WjvYW2_G=c7BU9{$
z(1UP1pa-76oZ!cpul&Z&-cRy_9phdX;~x8d7Jbj!FU&M#3AJBA->;$e8_4}8dVUK%
ze-PvR5!9XRC&7N^$X+>jY@b|2&M%>kSHXQ9TsJNpmzx()%F|DtlBX}7l3SNftDeS|
zx{2@Kz|XJ46MAt4{|$3-kv;@jFb}qb9{653gd7}1FL)0;zp+n<)*ihd)gHYc)gHay
zLiVT8`)!PU<ezc1p94Q@zlgqHo^8o0YQK)!Z=&{F$o;{M1v#?0B*(T^j2(495B4Wd
z9*`@i4}trrJO%DsPo9+9mru*xD`(`Ht7qljwR2AA<r#dwd-a^$xpG!+T|T2;JOwZ4
z!&Ufj8JY1}@clp!d@s<0!`QcQ|H!ex_W|pltbNR15BaO$uYtc_1bYd!H~v}Ff1b4m
z{}T9DQTuh&elKdjh1wrL?hhmP$F`Q`<bgFgdw4@Gfc+BKubnw0Pl5f`#S?P(@+r9o
z=I5@TlNWAWkQZ-Wgr1ZapEkXK&(A+~QJ%%m?p;5xUfhNcH<1bEfmyhWo=AA0y|ATY
z;xX(Sj?jZt29zBh#I>K4n(KY?H_-ddsP<E+z46b0zlZv>_6y)&LiSfs`!&>lFKWMU
zc}5Pb&B<ZZ{@A`HIf>k#J+v+tj&9236Z_>l*l(UcDtDedA@{DFmgm9!(o+}Y<)<&n
ztG6%9Yj>{7Yj>$@x_uR2zkK_Oymafb(2M78Ttp_$YaZAaX%BQfIDSy~4JWaWJdXWi
zn1KT>10jD^vv2%$jD4E@fWM9Gcfj98{d?fo+Jk?wTbE_6eM>eL+OoOSmHjI{IkY|}
z$2J$`Bx-;5;F?@O&tE>VB{xnVlw0SH$TMJn{_1JDf8(6IiaI~Ib6MVe=9;|q><xMN
z+*9)K`J1Y@uzeF>Ke%^8Uc=8{xkDc=X&#t`JIIaqfW2@Dy>Jm@={bxC+%IS!fL}9!
z{ed3`_T$)y{FN!IKly7#i0qKnJ})iQe;U1S{3V$|?`!Rm{e@0VmXQ4w@UJ8Lo5=na
zYJUi0{?UzjIf>ezIj|}h4zJ6VW1Dj0)B(AD?y%gucwAmY-CqIwgIiC^ThCmTcb>Z;
z@4s+UKL64!`QYU{k>1DWcVD_KZ@>7od=6gFhgXq}`^duc$bx!+ae=+S@qlCElNe9A
zU*JB0#|N4L^nlNR9|w&eJ)f?9n0@fK!QVmsyBPbl_Q?J`_!q&yjO?!=`+Mi7W#3{)
z4zA3|5oG_w-UT^>+FwBJuN>VgH%@NJZRGyh3rFRpD<|c(8)xNnV1M`CRr%ogr{s(G
zZ^>6)y(=HReowyo;92?V8_&r{51x}Rzy7Rz@wI#M!7F#=-TSxY;R{d88^}oH0mcRP
z0>?#;i8dCv47h#bNgN;b^#JN$alIea9=)%%2Y(aUx7vdrV_z59pF#F#k^MRFFSM(&
zgx+5T{|5Lsk^KY6{^8Z097py~Bl{N)tjJ~5{>Jf5xpVq}Ja_)EynN}nJh*;F-oAA~
zKL5-W`O*tF<f|{=mQTR_>6_2XH{W_uzWMe`@{PCe%cl=tl27pU$8WwMUxpW7c=Z{1
z|NfoW1B?qVVa(vTc-QqolmYA$Z5&AVfb9o329RHC@3LR_{Oo(j-^SSAar`~UKR;cO
zMewhn_t%j9y>l(u0{@}qt{hvNl~a4?<^0x?Tt2ueH;!(|9n}8$vj^psi$~?ntEc3>
zo9E<<cQ47uFI<;TU%4ee^Ts{-_QMzCJMZ3?pMU=q`T5VkCjSij_WQ5N&%F1FeB+(_
z@=xKzN5}*{cn>+?xbWba>lha~CNcx(ECbjd=s1Amf~W`FzAzpGY(L0xUu&=Ys6F@_
z=zV1e|8$i7DVah2XTd**`Y(Wg8Drln_&316550d7**}WjKMDSGn+tMj|FYaTye4;!
z@0I6I@0V9m`?oG1m(SlgBVW05QNI5CRr%SMpO){u@r?Y7w_lK7eE((n{)ey0FMaV1
z`Tm#Ql<z_R0-t~W!w2x;Rr%&SFRKS%L2rDBUU&!N!JF&@WPtn0XE_$)*n!7LQ4e4Y
z;PHTs0d5RD$T86PGi&epD|u;yzk}ZIqW(R{Ki?|LB6@!Xy}v$Fm(AIx>__h(2LEyN
z{uyNd$$g7*9ofHqWL=&=xldk0?caX#sC?ntDf!y1bMn*AUY76Nzaigya7TXS;dAmE
zpT94^`Nh}ex4!bG{MJ|BlHdIJq5S$+AIh(M^p^VY3(f=f#MjUxUwVywzzjSkuVd`I
zkNv@OQ4iR05s!&@p0FK%Ey%vs9=+ev+Q<Ae82iXS*DT2b_?N-I3jPiB{yy*@1pm>c
zj+{d8U%<G371_UaXjPs&wjr;c-jcU39F{L$IWC{vJR{$}dr`jo;#K+8*PfPt_0~Q4
z!TT@D?|t!A`TdXHkpJ;(59Rkhc}M<-Pu`W^{-^KAZ+`7<`Bmq^&wucm{Or3g%h%s}
zLB4{q;scBsZ)1P)0Q<z3b${r`fNl77ABg&6{PWqbW51V`{SJDcwI@HbKacD$V(eQ%
z@2`P>6a4!z_8ms=pFr=QUF*pu^!`)(m*gI@|H_F?d3g4KeDTR6^6B-H@}1k~<d>ei
zEWh>24f)q^-jN@^`<(pI7haY>`RH}|ldpYF{`l)}%O8FEuKe&D@5%3f`kwp%UN8&4
z{AKjQhp)@ez4x+w<Kc_CfA|pl#dpB}#yuPpU<`O3$4@+N=6M6hz=8F5$H6=gNYoy^
z-$eGc_Nc#QzW{d2{v7xhz`q3kRq$_gYqGD`kb@Zej)MO*_%ERMuc7zv99WhYkFLv`
zr}oK*=MTy!SB}YdZl0E3dFF!r&P!M2hp#^^fBNtl`S+iHLH^=PugL%Y@dNpbPu`M0
z|MYG7vv0mDfAY=u<PX2`u4du4!T)RMi|>8mb@>kXzlm}3;|KTT3#k9Q<mWLF>yP{^
zKhF!?If3OL*9bWN=`oO9BjPmy&!4D$ioc8clYbW3p9lXU_?I#Et$}|p#=iaFKMelk
zi)}fJ-oLayD^KlPkY^9B$g9ZyyU6}mFCLa}T{|J)zjaoA`?)9O4`046fA+>L`OA0i
z$zOl?g8a>wUy;B0_;vZ~Pd+FA>C=bu7vFeC{vGtkpS~l1@X6cqgOA^m-}v$y@{1T7
zzw_RG`RTWwmych6M)}`C|G$C$e;LOS&)>j#0mi?laUP}PACG}}UaZG}?mPfvAJ2pQ
z^$^yd{0(1w^!~KgJ}(`NeO-)wJ@C&t{w46QfPWqQo8UhH{v-1(If=3FJov9}%*pMo
zMS1biioAJzLq0sSU%vk2VflsYC*(J7pOxQ#{*wIZE7#>O-+WsB=ACEc?>=~5{>zu{
z%in+XRr$Za_CWsTlQ-o*ejPdZ`a}8CPaet-(G$P>(VOxwzx29%|ASZLJMX+C-~8Nj
z^6_hT<-_|=<CyWfJh*#B?mvA|&z<hz{P8Bvr+EF~lAaUuIuWi9@f_fgJO1<MfVd74
z)xM7(<39Lj0{#Wme+gsXD)=|h`}@Fu5c|Gk82e6R?7O%+BiF%y7yS1z_C3UY@5^WR
z%TJ^CzYG3<1^z!k{r~L#Rrya3Zpwdt>yG@F_wLF6gADuwJ^1KV`CH`Rui(S~_O&<U
zfBpCk`Qb+o<afdT8y~(R-+S*R`DYKGmv7)$;iFe>%Lgyw909%m`t3`4?)2=nvvM1~
z{}j)Oc|MG>pV!KGy^z<&$j|Ge-1pfvfR(8BHtxs0Z?!l6S&V)2sQ)7Pm%+aV{=MMe
z!oKei#{T2rKLh?t;C~AI_rU+k;Z=F(#9sLd_<t7l|3&iOIwOB@?}Gf>7ca~Ifeid#
zZ`_o>e|Sg!0UrDVa`5+Gcv1fLOE1e`p&$PI%dg6xK!5PXSLAm-d|7_&{g-fz@VtEM
z&3p36Yj@<!sQr7W{pV17o;$sO^N43$_OG8mrq|6b@_Goe&+DYTR(y=v2RpBi^Ii$B
z1L~Ncu08Va`IFf%$qM+_vG3ai|9<cv2LB20p9TMA@ZSXgv*3S~{HXs&XSU>LE*_Ha
zUOg_qdGnO~{+)C3$Io7rKY#Ix{1rU-Tjb#H-nuP+_s(7U&+k1efBpIA<u5;YLH^wb
zFUlW5zlVL}Z@v41{1T24eje;U4fc<5%=96Sncv2F!voa*KF0m$Q2RStdt4tw?RhQD
z*PhptdEbEd3CPcTM!aXn`$N$_kK<m{`{?_u>|@`*N`Ce}_z!^p2>4He|6H0M{r?We
zzb~KOC*QnqQ2zPlqw=fBzz?22BR{-*PX3f0yl`3m<IC6N|9tI+{Pi18%U{8VzkGOC
z{{7p}$RA^D{5NkuE5H5lp8VS9aD4d2UHR5)I7hgDQ_mOP1N-Oh;99}W3-ZGCv+@l3
z{%Q0*uc2K&b6Bq@@;Y)@d)_w+YtQSSe%x#NV;*07$3Kg)kJ)GMFJtUm#lCL?{QI`y
ze+A?JL+t;)aB5RNId?#Q4n6Qa>;wPhjg#`bPoI__G6(2|Kf`$VA6~j5fBwof`48~n
z-y#qH3%vL@*gyQvgWK}!uiujIy>?4}?v<PJ=}R}{qvx;5=kHyShqs@U*TMc0*q_CD
z^le;AcnZ1abwpl2=Jj*lKj1wS)?WLbx%ai_y&&8N^ZZfmJwNt)J&b*xUwc2re-QOQ
znyUX(8?*8Z_J8-W|9|tyn!JxOfIaXH90Pm@<KQn|Jtn^a4}J&70>6*(@DHCkFaI;L
z@JI0Be?m|E0mjCEjZFOa*hl`_%Qxh^_pi&(y?9-|0q&2Uy&@mroayb`7v;gt^Ku{T
z&w-uSkZywg+Swy|E%gG}c|D!E=Y6Df?zfP8y&sDEf6?)7kp0BCAC7(C=h)}#pXR@W
z{of7j|L<(h%L_REdktg2!(;36;mJ+;D)xilR1Yi%zl!65-+bzn{5JaG2k_wschAf3
zAP>I<FMj>mC*}LkU6OzP>?QdY^!0m}<STcdln=oD_S5I(0mi!f*UrduxMp}aV84vI
zd-l_go%atl_c+$$J#=NqeK)-a2!7^1%s!9#`g$MvUqb#@9RFVAe+&61Kl@+DKOFx&
zxzd$uIR3qb<6n+}_YW@117zTB9tWTgK7t3I!h>(&c<2`}9()&B_$7=9zl=QmGV<_!
zc=25vBmDx-kG_rL<Zs+MFCRl+ditEakMrfXaJ}SpaNoajN}juPLhj%i(#><YSAc%M
zeCnWHOFxIY_p$4EZ|r=Q!n5<aA!YZq$8~-k_k-T&agXlz$?x}luK#2HmYf0q1swlg
z!TAsOfp^dY&mjXZV;p>NbPdM>8}dGK@Fn!Z#~2Sj#hCarJTAO+M7|9#zJ;;jXR(j?
zCUWr!&J(_R{giwO`aJYD&KcjpHG@}h&FDpN^V-?%^GD?-@_y~~A-T+ZWEks=eN!_Z
z)gAX2ecg@So)scHpN~q^-t(jHdECSOe#DQlKh4ka|1ge!j^p_EG>-qd4`2^mLl4|U
z2JX^>155G}Ja`p3coX}Bw=o{Pk8^@Azy}^1eFQH)LMFa);gEb8etZFA#OHCI{O+Zr
z^6=6zc>{X&$z$@;#bfduuAALGe?)GbJuEkH9qlS=ehIyP;rN!`M>>tMj{VMiioA!;
z=O%`+uj2Wym><`;P<Pw!<CwRPAIH6}{=WZ>zahuKe{#W&0WP2iE~5voV;sDRao`U6
z;2u199v-}e@!(Zt;Q_MnCVY4cd3YOMyp3~&hv<#Bpf_=@_yE@mUOjhE?w>m(FG9~k
zch4S@TVQ_b^g+3XYpA@2ei7W~asTYhkxe-T?i2bf0G^3J-V^K?=k=K=)ZEv770+3%
zEX_H7T;E0QjUU%Kz|P~IWc`!;di;aq-$Ok9#~8q4z|-h~bIUjmMh57?HT1y^c<?lG
za2vhw490_J;luOr;YH-(CF~#XBNO*=oOB<4ymVqyUcj}I=b&d#ZOPqJ`{g$D^vV6W
zcDi4#f%!6+pTzwWa-Rh^?;)N9_i@ym_tAMjozIZ)85%xA<j469vLo-zyk}otoYiyP
z7TEjwalW6(KhFD5e;)h$<DV^_|KR+e$AHYh31ooh0q1xgjAOwk;lX9(;3|6IIy`s^
zS-1%wZeibe8^;HC;KdzyafjE);KyzFaSPW9Z{k|<Q^)qobzCpM2JyQ2CEPc;2%X10
zgtK5ijeF+2j~H_ExtRlarhx41bv{4F=jReNN8Ok4ycyY-7JJ|~cD>GrXIpr!%g%W`
zKhF6v_UU<Vz|Z4<p8xCz{~?S4N5IeXpcBXdJva*w&cTBV@ZciGgC~)N%gDkN_;3Y2
zT&3W}HF!Z?g&$XOt@H}cn=T((lS{Z)bP?B$dEekXKJ(tu8R!(4PvAb<aXur1TJyOP
za`QP7UvoY`M()g-gMA6?iwiwf7Qf{m{22S^>Ph|;9RIE1_<sY}J~wgwgXcgz2j+Q@
zdVmbjgOl)p*F(;r7tUgza1K74gAeE7!+GT4JiNGo>m(O&o$x$`>t)nATr)kpe?`tv
zxNmYA;=QvI&~fOPGOyr1I-ZdNGoP8-k7o*)b#n80D&@xWMPb%gf|`?kVSYyC`P-;H
zrPn&~Y+Dc6_x%34ho1ZM+7I~I13m*=$iM+);1I5Z@mj!9cyJ6J9ES(ICUz2I;z?wI
z*9K3)hg0z36t0n;f)~6_PMyTPl9TY`1nwD}z`f$*xNk%q!#(q(&=Ig6h7RFpe1?M0
zO!4_4K0D^Q`D`qo8`VBX&aKbmtXs{EdmjArb6v|n#{KCOe{{VQ^(Vhx_rmedvg7CV
zA6^6CHK2XSz!oxa02$!5utV_RFnZw#_K8P%O&mTPg%2v^;V8T~3NMc0TA2!79EFbH
zUhxrJJLNr7>X2$tpB*@W=LhyX@%bS>JH}e`xygtb&yTK=8?_GWy`)(;Zq}XLbJVQo
z$9-+`qxXINJ^!rd$2~ue0lfCd>p#5yw~ii&J!q&0`{BU><bXc#n(!fbpn?yF;KL!@
zAL2cdgSbz?`(y`kpY$NSIDq?wD%>~Q9|_M&;n|6OPJDKX&&_#eJ}=8>g_Rl4&&J$6
z9ov%JUFBAGaL>+mRGNRV$Nad*hx{vl4fndh&+DG^;P=-)nSmAbfO>!oY#;;70j~w~
zdgwm%!WKN(f(N`Wpn?zkDfGn_yx4*lTkwM7y>b(tm4P27JRgbY2fXyzV0^s}+4JGx
zjhK5F&rP0r(e?KNo-Ze}=bm%iv%QY=pjO$~cgnwrXI_{AUjOGc@Kt1h*TL7puRg$o
zz3^ZY9`L@%CVbe051YI<3@<kEd;sqg?p5JA33#!==Y%MD!DnXpyqF2kgyXq6FFq?x
ztx%448P8WOEttr>2;Ky<=DdTfTfL3D4feLo%(QWT6VJ1y>fb^AyBPmwQ2!q4Zy6}-
zwf_b1^ZNf%tJ>$m8a$v6>+pd0MR;FK1s`~SbOS!{9=Qr$tiuaFFTrPpC_XR7=jBxJ
zV?|}p$CH!qM^F(je%JGodBN3re$IHam_0YyXJ)2T{CKtp>}h`W0QsMTc>g2v02yEo
zcpq>D;{Bji-VcTcYj`GL4IZfA1MiVitMI{#&q<l^eC%8s&q`8wHr|QP44aITtPw9*
z7r;qYFY?CBZJ9-l$*WRcWA1{x+ch<V`cH#B<nN;XGpK*a&wHQq$iM<Ju!s!sKH!q`
zfIck4gB5td`@$wX8v!3ocs>dqnDBfkpAm&0d|r;?bJC0YP7L3VXoD|Q%sCHEY7W2a
zMOH7*+jBK$ohi@EZKvB(#r$}lH{jQ29UQ-TfahIY2Ij!;Jy>uas1M*@^5Qc=Uhsm?
zh^XMjBA=0TT7U<k_+C&X_`!E&lo5P$PM*_md-!j9;G;aNZe5Lyy9ItQcVe~i+4Hw5
z#vgeA_73DTFjL1fFW{#K`uv0QU>-T32Mfr63C{z;gGlgT5#lpaD)_)>#rVA3d>7A%
z!v|_k)zbF`_|5<|tD43(mgn@_h!?Cg%4?itRo)C{a;w@+<!^#L&EF3A`OFLXlOEvN
zFL<DW2lMbi1s~?|-jfPG%tylWq40p>vyyXsMqZzj=Q|?yo(SI+p?Z;8_#A5npVRW3
z(Ke{B)w&5*C-AnNrm>~S?)h8DKkKg<aQvD9@JAk?{>*`90sOO0d>&>F9z=o<bMPS&
zeBiTkvv?;e5`5r0GNJgM+zkG`X?5|vEOqexw3IhsC9~&^w$u0?G?2fFXWRQcz%#GR
z0r>S9um+y}1wZ9|n1u%k!G~G+K=r)fLyzx<^{IjPrUJo>u2Tow1Sgm}DMnx0n709L
zXgXF4pF=fV{WSxqeVhT~4?XCBo%|~2!3;c@aUOUtdQH3w03Sll;OiOihvNHz-RXKP
z_|ZuS%=q_vwefk7LdNiO$eQ@vYDg0b`J0Zvh1yS3s6Y9=$nWJn=#t+HKF|vjc;SO`
zgPre(n84hM)qw}Gzz;v#Lo|(_nc|vy-UJ`(48Bm!RvpYqkw5f+^(TMmLBfZ?1I+_+
zKo1gv2Yfc%1aA01btw1{3+(WsouO%bZyNvBEVc0c?Ud$Bf8D^}P&xj{1MoK;zj}cB
zlRx$V?|8xk%4b2h@Su|=_`vsrlpXx-0Ww}PC)L8&{Yvtu*`lwTsI^lA+bq=se)RzC
z<PSY)1s+V-z)m?25?k=Mw-flMhp2_0wVGhgP!r$Vi5mF5?NygLelN*i!uw4zf7%1{
z0q=K%Uj+}QvwWz>K1{=pY{7>HSiO{+?4~BRN%gaD&lvlltPSv{h5E-HfWNZ62QAO<
zx6TK85ewY#ArgFO4HQ`6!yq;Av%vx*n7sP<(!8m!<Cy?PpGFRh92hw;a$w}Z$bpdq
zBL_wfj2sv_Fmhnzz{r7-10x4U4vZWaIWTfyI|phD8xpFH^$P2YX>H<r(9)(f655Ba
zvt+-=-`D?+|E&st7k|H|!v8MThpejBrK;<LVvYl>HCEwT$hv;4TRYgTCG6Lfp2Av`
zDy%nHP+@LVti{Ro7xP$)lhXC>n^^N6Yq3(3SnGZg>v*fMmbYK0*t7R@r+HJH%lKNg
zg>9BnzYm|1es~|S9pHnmA?tm>8iZU^x!9$!o;cPx_db{h@WOk5^?J<*@_Ts?Vjm{p
zLl$>jW5?iFo8auz3ck0pzh7AQE&SccBbS#t{cyRkJS2Uv^<pg#-UnS9ogSzUwx;^_
z9wf8CwRyuV#90rs9dm~aA!iHBu?|RUH4xS`Y&nJhjeZWZ;=M@uU_F7}@N4IyCn68H
zet0SigFVRV2e)3c>xX1tXK)AgRo;*@`g{=l2W2`CzmDa+2|aQ7&|F{**Q`8vAAA;c
zO=0wdt`Fbmf$ImXKk55H$Aio<A@(31)4=ZfS!*70N1Vnny$04uhwynPvj4_BvA@%V
zAC`&zHiiT~)Q}1Gg|4H@b#z@8Y;E|^gOzAZ;JSn9EcAPTesE&~d%=3$*rTkweokbX
zwGElq4@p~f7~7p`8owWV<@53XwRa}nZ6rq!{wsd=Xd%UY1*s9KU7|#4q1Mqlnz4QG
z#s2@7c0^=mRaT(^LiQDhdQAZk2k~WOW>s}*nhfS}(6gbzK@5z8F+fhp3ziR76OQm~
zb22avQ$BDn@EOg)K>Z7G&oOU(9=h?}d(9`%ee!hJTww5X8qR7R*I*HO5*${M8>__&
zcrJ2y0ng?%4tLNa@!WUTg_IBD3@ji1vR<E2Z2i&dB0WD#dx>|}oi(3A`{`L3TljhF
z^qGyje$}7rXY~2RVkQSNK&@OM2Rx_L81Oma!6117&$*A9pl5QTN47q22I=|4!C+i_
zA9Kbz#o9GXD|MFf96$TGhbu??Sy%rom;^WT#8Y_7{IG^vLO+-n9)ba$mFr&6Gi6IY
z;F;QZUM=fF<ij)ra45Mj#sL4O(Cb|F{Frw4c<9c0p>bQ|99JLram^!M*EKUC2V*hC
z0nf6%<s6g`&Or>24|={b@<Gqp76ap84D9)|oGa<Mv|`}TYWC+7M?OS<wpzESc8hJ+
zyL10yDB}Tse()lV`rbA^7k{t%!#Hf5oT)~v-+>?S3|xA_7~q-6sFC4?g&3eNl;_i?
zeBg83;~C9lK>bnYE#JM)h2K5Li^n6@im&T(t-H8tJbXFq_TvFw%S_0@S!}@<%#-Sc
zGvtHigyjP`@VU^L0dj&IS|6Ms7s3Zt6Ru(q+Sk<EqQ-l!H-1kshjzs}bZ4!PUJZLQ
z#_q#cg-h{=b0`d)1HG`0I!O*|^n&L@Wx(e-_YABi%x7RVA$-vIKKgm|GuCtEde%;F
zo4-qp8@;cGy~i`gBfRdP4Hi4_1zDIEE>JViht0%597Y-7x$t`KePV##aNVC@eGN5%
z&#nH&dqeAkU@$T7m)NH|&)8q7Jz{No_a9#l8c%Q?8~(odfW<CYki!oAV+@Q#W$=91
zKz&@N7o5Q@)dV~rozFYRbIzw3;CbE+18^t|{JGs;7x~O`_8R4Vj(zrh$#;u6zo+6J
zF-NSc<~Pv&W;oz@8sjZ~=CIfKzSw|8;UEU!055Fc&kW#&(=i5kJ~;BBFhFmpxxi<;
zFV3Lm{dnwEt5d#@YY)w#)vkwU?}iu$Pv1EQd(Sw$0RwQ57hb~$mBAM3!q&YDc<>w^
zs0`NR13nYIW6<P6&)@{PU_SVp`a<<Vs~>Yz#op&Bee6}|-18;wZJa}|UEf209>ybB
z>_2%czZio{<ipQ1SRL`fjYB-+{$Mc%>@PO2Pc^^fJ?Al9y`%5Pw3k>z?=u^dXCH<<
z4)JHb2POv`@WeiHgI?Hs{090fgKf`+t$Qzq&E$i1uLo;)&d?Xk2mcQPtwFdZDgEB-
z-ptsu)<u0|?BVCoo^?Nm_U9kRhd6+RI0S>Yg~854^8p!bp&pDgcs7v1tq}${y&f#$
zgQ}nFGh3&q=TU#madOR5Z=?P(?bKX#AD#a;^kah8CeJxO!VC1n2YF#1Uf4rE?79!g
zVEe%<3^KrQA8dF%SVv7*Kbgb8>%mnF8vP~r+3(H!+nVEWK8Icv-dAtS`sw$i{rqFq
zeer2H8X1%GPvUS04hQ(V`|v_$u!CIa8ElR)SQ}xm;=S=^&tU)VaIN%4tBF_X*F3G%
zz3@JIn0lJmclo}HyK6qa_&glHi17tKb9@Gq&%*?tA%{cwAsFmEfe#*=4>E%-_d(0x
ze4q~+2DhIKtOuFF4a^higX^q`iNP<JBQ307{eDb;AA5S<Vs5%!^UJTpaUS4sgfRh!
z!@}UBd_V@fWbo+CKnB~M3tPws=0aw$ehLOBErZoD2J8t~FZ2wq(l7rr{$u)8_d>tb
zI_0}!&zM8|%P+%i=)V2xTN%eMzlp`si?72(48DlLfqVc4Pv4^!7=xWT3^vdgSPwFT
zTV4~z;Mja{6Z1sof@*;naDHUDVExZ}U-W*?znlD@<^Nv4>RpQcl=kn#F*tA>fdR)v
z48Y-n3_cHJu>Y)MfSPDNxE!_~yvBGnY`PCJgEji#&a)viSRsR>M?=FP%?(07*IHNU
z=lsNapXWdHvyWTtL;Q>Wh<(KUJ7RAmv`^rP3H8Sy2Qm0m8Jv9>_TYtGcwq<mKrd`R
z9AR)be30@0K3K&Zv8@FUha2t#<pJi&jehk%>_znPNA0otZ~FH*hxhsy`dP=-*OdDs
z`d>5l-%HF7q4$v5U;RED`RmFDuLs2kKfz#KxnK;k2ZBN40j~u`Kjziif8l<V>*xHN
z>k+L{)&G)y&RsdD_xK;evspiDo9Z3oPVKKvC*ys9IPYIjKX|<Uf%h=P;4At<)I{dO
zC*;C!!(PW=JNw|i<-!Jf;|6@dTCnClAu~`OpfC0esDF)nkD3E|4s`S1Tm$FjfIQ&w
z&-#xM<IvBT??dAra-BcldH46>^!-1EJC{FHC#@%tLDYj_@Nw8pxsVxbjxk8JU=?#j
z*27W@CN&SFUuys`m{$Xk16-ele&s;&0Q)!fvzN1{Gmb~<cdU0Fe|Ug?KX~zN*h6f8
zz5F(u{rR8a@t1!Mci;Xo{L0#hys$igKkz#aR1=-S(+{Wx?@<e^9+1J7*8?#K56sAe
z6`vPm4{(36<N)=f25`@z<bd|4uqIFXceQrMnnn6+9s~o;?U2WerRqHO%L6}#qsu>r
z3H*Kt2CRkWKmI*D`t6^?>6_nCBQZw^{dj-E93g|}pOFWjkOv=84=aP>0n87gCp3BB
z^8)6<ln1;ghJMQd?6(#Dm4WuAI1ff23=fC_*KO_r&R-9Zrw6D5^Z@5H^f3EdFgPLu
z=x5He4lvFqm)|vhrFQs*uUTJYZ~O-RU*Q2VSTGOny&TA3UA17k7WN*{{_;<HU`P8E
z+`pmz#TZC0Yh2U<);`wAG&c_I(vSB;|Dp7cdtm3$+rjeSfAfIuv$+0g4`5Fkxx_xe
zbtvm#lLuU{iviZIBR*gc)7+LmKpd$@UZ8fwU;f}4Kx+Z>3O_TE_Rt?5fd0k<%!Bbd
zut5*pr3Ys8f>Z~%pDYis4`9Ba`%qmS*yR2^_oKwXa)4_y)<Wh%Wq`Gd_B61T^ISMU
z|Dty}w_`3F2b=5I+@JIR{GR!K@}k!tb%6b_uLIQsn?5(JIRFNz1Gju$*v^UUp29p2
zY;Z5Sc);cZ;Q{Sa$OD-Hyuh_QdKDS$<GU6H!GU_4fnEnT%yrg9d4Rdkp&A%9AacMM
zupjQs^gx;q%&LRDr-Hqb;sN+V_Zm1KfCp+V%nU3CrWklGaNWjS&^i|1uW&$JG!Etm
zdV+Ob{SEoe91pFB7omMzzs-p_ABbKM@wd4#d*Pxvu;Tg)gOUeTfAmA;L8%4UtLFX;
z_iT|1TB{cZ*vktBh>sZHyM`b5{lgP21NOU-!TJ|9aH<B_e4z9~tdGWXAgzm<bpg+=
z^&W^hVP;?+;9g{{hvN*mPSHLV*YM!LIz<LHEGM+a^V-ld$UZO@(vEzIdBAl1-=PP<
z1Dp#X7UTNs+OU}m@ZP%g_Y82)t;>U`1!BN`Ne;}5!Ux=^2p?$Oj^3bs3~>O1!U5|#
z)CJZCYGGX$1LcFoTKN!hZ(@&m5dIGTe)a!?`mtBm&xLs3WQFG}X5<0yH|YKo{x0(%
zGuWKLU?vCXuU_aFV1C!v1dBU)c<ht+NA)BBX2ySHO~iHKO`Xd${gnaEU*J97YqNTo
z8Q@-w_XO?BCkC8@nisHl3omTr`<NfFe-U0-lmWevhV}kB2h=>ctN&yEpSLEIeyoE>
z8DLIi40sNKxiE(T=9|g|?o;;+kdv7K_c7>!**>s*kY2_+2J^&y-^3oji@&p33#B>0
zO#NO1Z}4o@6a$>K;8}yrfcM=J1Ma)h2i$*?4>|_oKo4kS2H3|b3~EiJCJxmD*V_La
zpHbc;_OTY+?)9hju&o0|=7FJ~=ZOjf<bl`273yDz0q##G238Zy2R#GJ2j)V{fb$so
zS^FH$!L+i@`Fzh`Z?vb_^LI1%xj$%Y;k*vAIUx7R%brNl&oh=}z%ypdg`NTCNFzR2
z!#a`oU$PIl7pc8z)r87`-z$7Dj{&ufbFkM(wfC{l-pBVT@lSI=-ZP7N@O7Or_48B>
z1DrcUPcR>}3~qTYv<%D#nF04`=>Z#=0rzuzAFw9C)AY3l=60Olm0^CD=RNL`_ZIs)
z_v3%J>;u4?c8{c63w!)^ek>U9T-l-wz)<(%lMl=b<lsI)O%Q{^Av3^zjl@8EI$jsW
zfh?MVI!E2%d5?Rey~IB0=lzj<k0{?CK#!Ato}&u}T`usxLF)sYyHIb$`GdrOxyAoZ
zW>CF=dp3!I<pcFQgN6fZL(*C_Tb)<Td+o}5?t^xFq1}F{?ia(m^1t6By2dk<JX<`E
z0rQ~Ag{v8G?M)wyGeA!8JF6~K4(5lN7f~l$&A0~uUe@cQ=0SIfJ=T5jo%-Hf@7uir
zo|Br-0OzYv6SEI^Z;>9zKCqgAGYQEDnE}6()kb=u)&%1K2AC&=AEb{O$A;$kp*!|`
zEbg1W_f@qg?;}t9+RyKA`llK23{mY19Rr@bN(@*_bq+yw(HK+?_zuMj78~Y*MyieB
z2kqyQMH=y%U9HEd&nf0(+U-7o<-OIt#`|9TR&j5PXXJEV@CqOB-eLHF=PPvfj0}Q9
zVnEK+Um2h-6b8(R>;<qW9Ow(z=lM~%#Ou@?!#T?D^nCQY@cl^L<GHDPe^_S($w2ze
z2iKw=s3ue&%wkZzKp%t`z@Tujx~TiK9S5-pKj@nDh0eIDzInX)+3<VGclLXFzRvd;
z1NlDcUc?^W=l9mxK%SHAd@!4V&5?ArBKaUQsQF+y7hd3fDfI|`N7hEKj}gCGA3Q%A
zF7>teyj|`0NVmt`d~g2CzR$7O*+J>|e@n9f1Jwk~4>(8QnTlY*`zh348K5>6AE4jJ
z2ayx47fN1;h1YI*`Kq5oca6Dphv%7p?DZOcPOOVPzc0@N>dZW^&VXkHqc5;GTw@-1
zF3e?6I9P8`o)r$A7dRi4AIz^Me&LI_BB$k(_%p7W)5=5scimTU-&1~Tw8wncdS1ky
zHB9G%c_uPA{49f}F2V<eLG(!cHwy#vLavWGvk-Zqxf*lhiV>e1(>)b;kG;=#*z>}x
zML+&6oz8{+Bm<ryP%iLnP00tGHAxJ3zscqbS8-sznkPz~C|n|E>eXWHz0G?~<9Dxj
zP0sVXc%CXw_?~~I_82pKz;jZ{gOOYqXMpp_WKcMOxi}aD?mxzS!Sb`u4X<6HOKZ1I
zYk4o{Ie(A;Zsxl39oL9KXvezV^gn=poP`hl$p^}ZlnXrrs|h$qgn7~^1D?Hu{&`*~
z9LS^OtFyqLOW(*^F^}WAv&Py!Uv<0R7tqdmjQ)KP&%@7Rz_at>fb-Lx4_XGccC7ip
zGwCA?7=wrhb28!-o)C*^9z7rFWvolQXXwtJFL7sF?E78y{|8vUza+3Euq3b~uq3b~
juq3b~uq3b~uq3b~uq3b~uq3b~uq3b~uq3b~Pzn4Oe*F<l

diff --git a/Templates/BaseGame/game/core/rendering/images/default_irradiance_image.asset.taml b/Templates/BaseGame/game/core/rendering/images/default_irradiance_image.asset.taml
deleted file mode 100644
index 99da51304..000000000
--- a/Templates/BaseGame/game/core/rendering/images/default_irradiance_image.asset.taml
+++ /dev/null
@@ -1,8 +0,0 @@
-<ImageAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="default_irradiance_image"
-    imageFile="@assetFile=default_irradiance.dds"
-    UseMips="true"
-    isHDRImage="false"
-    imageType="Albedo" />
diff --git a/Templates/BaseGame/game/core/rendering/images/default_prefilter.dds b/Templates/BaseGame/game/core/rendering/images/default_prefilter.dds
deleted file mode 100644
index 0d9e4193941f96ead0dd024f3f4ce89c2f81b8bf..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 131192
zcmb5Xd2C&Gmgi?l-1mJaMR9)=AGgPS-#3#KNt0BIWQkIVYEeybq?X2t1Szrw8G-~0
z9y^8|!-iwS<G5{Lj7oVbg_=sCW>V>?Zgh7hJ*iAO-RL0sBS`)kOfpIS8cgcs^F8-n
zN^*AtiJ*)7_};zu_dEOfopXNYPEEa5egBnLUdhfm{>m6<9j_eo|F0zL^Z$>3)m%Fs
zzh0kTdBwv2{zppA*ekF6Rv(}L%gW5K)RbgPNlprmq$EpDO7tTsG0~FvoROMhsc9*e
zn2=zJi3yevKPU3L{!Y)%v;@w_Pn@vyyu9Eue<$)xeSeJakDoYhClZ45an8q%ANS*U
z{OrH+Ie}~Se4YEJ7OkYZ!OCl!ta*6W($X_+YID!(T6^v4!*^}!{Gt8l|Kq>0p0NeH
z``J${DLK`i{rHdU;^R;3?VtUb#U|!#=KO8@@R$Fsz4i6aEx#pZ+qWOv^y-$~`SeE?
ziS=4;R)&?76<eBc0PJaLseVr8vtUmW92`mft#e}hoSKo&cznk-IXPLDoSq7NaUA65
zTVhJ8!{=}Tug)ig2VgwH12_@Rgb#hMBfxE<rKF{UyCfT$U9w4FUc7k2x<+SgWO38F
z<~D3}e$^Ud16EbrXj5z3wsZTD4J@qL==q!W_}gFF;oBcuNlmle`|KCCa^s<0d-A?5
zU3+2|AAVqqm#*8)&Q)vZnX;nXY^w(T;=EkTf{vLS>B52dK{(-XJOHO)bsRu<%`*v}
zNQO6Zi-DKl1ixTB5vTPDeFx42<FVt%{16}Lv%@X;1$TIk!=IFt?9Xo>oV4}5Yc{xe
z7P?=uojY&Y^v<E3yY<AD_ip(yvwPE~FWj*Ctv&0STDP4y-nE1GzJ?x|wtn@tz47Tc
z_Sql*rDf(7+v<(CY<~Bu^UCt&n>Ncmzy0MG*3eiBpOriO)zOG$!V@`#`IafVf``<M
zG^ce+LCz8UqJ2_wfS)w*5UsB8-x6M+rQme<<Fs`d5WNL&9Oh%kz(xEX;mvs;Jht_X
z+P%-ev(+oNq5oz3=3o75TVU=N??16i58t=g_=3%!-?xFKE$bX#vgYnVYwVr0v*708
z*T1y=#~)fBzdiZpXLkS7Z*BI%9qT=F#dhyKwi_ROWw$=~*0ydwF#C7^okf7Twj*kl
zk$S6YYqtE7LdypB40J<IZkDA3e=7W)QCwiH{k`!yp0H&2MDiW*tYkzy5Xf%;W5Cza
z1A_B!J3_t>d0)@U$uF?UjSF`D{V$Q*pF($dd;OBN4$au=)jPI#|EWcX=j{BQ$JRe{
z#_oUojWu-iTWxIEuD$(<?Zf-6!wa?nz4sq~WY?bY_vEIn9o(_~Cm-7uva)gcz&gg4
z?YIB;Z|wE0MT>Mst-7VjN~+2&zqH8mz=7)m=AI0FQ^0|EJ)}>hw~NmwTrULQ#bx{j
z`o9R<@xKH95GT4;xD!ux4UO8>NAIG)7NPkSyYkli_SGN%6?FW@%4#FFv47jny$%lg
zMr{4yu1%l4WZiR{);+Ocw?F#YvI~kWI=un>Z`eCO`!)QrY~8bGt)+k5_MUzM9GQ0Y
z>3?ElJGX3Zpvy*EBi2@1Z8g=EmY1Jr#Whuy0d4cq3Bo~UUXEp!6gWRf&n2Q0bWY-&
z0L{e%Nh#=yOmr51hj2^BAASD+0Ke>s;BP@MU%LCqW;S+h>+p`X^-tK`xy!cu=p&om
zzG`LIggNxr5d1y9writ{8+PHryU;1qZh!F;Te|hO#b(dhg*V=@-G}ekmA5~&shtCB
z?isV5>1Au^owl^BJn;H~{lWDMR$EqLwN;f?fbJV_X|Upsh~*aLTX|c=;g>CNeJ_~d
z2kE-x)MUqz;{f<YJAEI@Lnz<JrR%^$Naw%pEZ&g46a2}*zkK1qdZw1`?2QMu1@HGy
zpRo%!?%CP9??C4b>zG`%ty^ze@A3ufnq0Os`*$ohb;dSsJ+`xVo?!D1t*L9w<tExQ
zWS2kqsm*L(v4x9=mQz$}JC8nvUg_}8ZD`+Y&6VZWSyycp#YNV{=OTC@9onV>YfgCy
zwg7tbS@JCyrSD`f^|`FO)nOO>FXBL-|8BVDn7r~5P68bwe<R6yW>;-|>%eBuU$fgE
ze`^!#=WPw1pWE5DG4#ULtw*+a`IbHS@)x##>n-fyApXI;oxA%K`lMQP?2N7K-9Xnp
zwRUh78JxF~l`VAOHJiJ1$9A87X$S9qWs7?^t*yQm-Cb$-&dgc?`mPL~uPQ0BNJXjT
z=EMKUd^X=n7bd5q1oVgA@{z>rjtB8SpB?^mbOdyC-49I#*AdNS1CI%A4#Dr<S%3@S
zO13j2x4?Sm*YHjHZ0O9k-Tv@fyN$kHym09DYWd17=6xHwFWB^@yEXwnx@I=5d1&6Q
zJo(5PVxtzF+qN(N?62K+$ac<S?_-nL2=v9`;ZvKs@vfaYxMx%FL`7kNH8nL@O-Zqp
zLHFKBgO%mxSOI=P4t7w!p>#khcnEnwG!oxum6xI$^5S+cumgcENCE!imV~_Iloz9q
z0-sR$aa_D|4El4tfD4CTJOmC>Qq%1m^8EPoZ>=9*I0Nlt)2rCHVLNy8O{;D0vWCtf
zTe^JL2A9s+!0Hw2Tt2X?&pxy9jeXm=`?lT1zdOsdm60ABgMTC!wb5>S{fnR3&Ch>k
z!z(-3lPO#6?Xc_fV-|z|%W`wAkVE{Rm6>VTSy>!`KO{PbKB3NOMR}Gt60_Wja?6D`
z5|Ihlh44W-e3MmEX+=vTmd58)Y-uh$CA_^zbC&^lB9sNmzkH}>XdfG%vc5CB*xf7}
zm{|e#A)Cg}>z&8{8=r@c_w4{%R$NhS!>bo;{rVf$(lg??y8iCxc9X+>gQ+#^om;m)
z@YuI?$0m1g+Ya_qHe+(@vf01=bNlUo{jEito2(q!&x6+mb7p#)A9?UX3E$<(H-w(z
z0m;4QnuXseeVq!f+>gdiq-1AUc~`sD_Ox3rwzR0c%$m>4SrvL>WO>eYLhtmrWrO4F
zoE)cj2)|&L>?HEcuE}|8Xl}F3YxnHn@%vWU7`671S!~(^>zr7!Rq+IPxc=lr8$Ej!
zop;@$6RTDo?X``Y4{ZT?8Ccl0A#B4CK6A^^0_%m_cKF^`_`V0&)oWH+AF+S`>0@hb
zZnRSLeHnH@@XF`O#Fk~?<EL}vfR7aTKUH!79+J@gnFaX)|D!WgbFwW1e5Jq#B~48h
z*;%#B;zBEGsI|Nb{KB*}{L3m!<e4XcF9UhVM86ydUOguPzR1eU$EIc=SAqU0EGq}k
z$(CDKY}Jh|HhJNe)wXoo;`uB1jtSN=y@`!G>-zuUZ+>gN*tM#TaqLvK9U=!Y^j`1E
z6?}qun?-N-ES|SH{QrgB0~<WEW!>19rkNePFgIa!_<gH`T~>?lC;eAmS?2y<Hu5hY
zSUNDTsK9Mgum(!BmhV2W%-T9D=<me;FSe$^F)LY}w!u%IS#DXWRgKOb+5Y5=OxFkL
z;CF8Cf@KtzSXE2J5>wNx416V~rvp<U`_dcYfu$?gt$lF9CeNI+ZeSZnfA`F;+xdfA
z{GNo(U&lW8;qxOK==<tupUrGt!QcNeux>dIbhG|jyZH!TXbYTtZDZ%I+0vz(@XCSv
zPBFe8?{2pUzHbq9Z@~_fcQjiGK0qe4%w}DqHKEqXS>QspKkx&St^WQM>;LRMEA8vG
z`r$#VYHzi^^%cwQZ@28GS}Sg7v6QSFhpW7!$LTKE(zA0dJuBO~)|M<)&j%;j@K6T&
zS8$0J(vYX#nPt{>=d7f%+V<`}f&bDh4cbnv@7m0{J&O*`;?IoO=)$_y#73;LA!@h(
z^0!X+%7#{aoGIl0tc|W;uy*{vp))(SefJ6e(s`T0m#XcZwc!o)Ccb|IaOc9~w-+be
z|1Iupwj$Ou8GI+Zmj-XABNJK+R=&PxCF27YdE>e@-o0#<hZigx-C5AxW?6MrR^8U(
zI!wHsfghTI{MQdn`gi+ZzHbG6?UsaX8U5}<E8SbOWOPPadAU`_+HL;+Enr8Mii$0-
zxXcQxYQbBQjbR6eH}@Ss%{{|`FLUtFF2DYO=O(&e*U;8wz3_PV@}4bUx^4Z-=i&1U
z)(jrjFCSWTXcjxLi(j>9)7ZTk`~W?(8b7}SSZf=qtysDay;Rg(Z^h_B_y2)eYhl;@
z*m>7|$%$5e>w;CDnX<~(7OUA_wRF~x3FrmsfP$K8OKU*hSu+%m^;vN&Y8m*KNf{X)
z3pv4csRg-~m<>)VOOb<gbOiUsI<0Q@47%%@b;A4UIeGAP%*K(|v9kxR%VNmYj_g`v
zt3{#z_VxSL!MZoMsLYmk_w5?Ga$;@As<DwB<Eys!=sg?QJj6ac@-^e;;XP}g-?o**
zx2$Vq()yblTz5~i2B>bTclwv}SvEU|^`2mt{0FuVJb;gynK3I~7_qur`<97+m{nI}
z`Lzv}fPOq78wa0D=cQu%#0Ss)pCIOw&syVnYLcCRua3zlK;Ctau1!Km_MN>5o#t)g
z>;<R);KGKrVXL(c$N(o>tlc}XkG1Xn7Mnr8Z(X+!zWCO!?L|jKSNHgR+WBIPSkK79
zrVXCIZ|is8^L5hV;oI1P>-_z`wMQGRud9_cMTHe$qjTZMeC%3QeBCR(mr-71g~Oee
z)75O{yR4<|9$4k<xRt-YYYE^-_Ae=w^)WJ>1Wl_)r|krKJdy7le&GWe9|J!99l5w+
z8Ko80ySrn@fjt4AH6aN<ld&S`>nOCJMbB5(MI5H?$wliJnzrf9i#B!XhShftBAYp^
zf#+SHcZ@9o?~L7k^weH|`jN}T{Pw=Z2F7js8tZ;!p=EFZf9W1EkS8{@e%VIO=(`zY
zzucP9dE);8);k68WtMCnGMZmsWtEqftgySq3MYE3cxA#G54WxJ*I!uK*;Q+Qc*F9W
z>VOG97rKkTbHxYADeytE!*&8&UNbRlsd)vK08X;2sx4Xi4!<)AU05|S;rd^=(UHM-
zik<ahw|C!tX2sQY#Qz$hb)Plj^L0-x;R8N|A7<UBPs_}*QRKKEeL0U_Q_SPP_|xAw
zKC2?FHoJMj<}Y5y-zc&C@*0aRoVWR_kI(@JHn4GEjeDDRabe6FD$v95p3VjEKsquy
zd2P?iH>WK(f<9jzx1z~j%Zk=p4u3BlUbDJb2Xx1_Gfo=tqyb}OYQ_ex-?7s6ZmS!e
zLO#l@EY{|99KEn>-~I1@ZCS;o)-pE5x!mO?0bC7i>{uDTOA9_u8SqN>lh6ry6%D}N
zZ5N+@YQxyV2Jo;=+-7j)g6$Cl&B)HfJ}%kd{5o?<cN;mhdDZT`^O61g-~QIejgHLO
z0<_OBtG2$yZS2QI8z!Fe&X+$m`;)KC{+Q#}Uz&YHJm^=STX(F*-rYIF8mPpo=SOYn
z^?fVoZ9xu-Eu{oM1^lEG=J9Oel-c-j=;$=)w)Nn#<yO}N6aGK;{5ZN<*XZ}$f+BQ#
zmPO8Qum)dn-pDSkb-pR->a(+Ne_<KmPx2w1E?bz2El38Yg?pb^1blVRuJMdq+k5A8
zJJ0$+{<~zLvaQ$cT6BETD(ai<3^u-@XTtg8KmE^sip|dUXO3b=p8e#{Y;bPX%Icbl
zk$!6S#S{C#K6>bI3wHa}XZG~kwne+6_M-<^Eqa#N&}ffUL^}e1tfUN{Y_O8S9xG^W
zL1*`1y9QY2RM^bZcYsU!51j`5Iy%s0$-t3>yb2G;6Lcgp?+NRC;}+k;@5swBd^#Qa
zEw>2&C=zu!5=}>l-A$g|v$m0W8(!KZ?ss6F@cI1KMO(s;9VI?o)f}^d*%fOc4k#O1
z(>`jw_(r|kH|^p3pV)8V1?iX=`mv#J$`-HOvFg?V`_+@1Hhz2841dmk@rl_lKd~=w
zUa-lX9V_2hwDPqX>%V;2&fb30X%bsG%b7R@@zoyqy8u5YllkU1MQxhcdSXhN(?2;U
zH?Hpz`Mr#_V5a53f5J~*WsMDNZDJ$j_XTiE|Le#m_7@wO!0*iU7<eMOv5IF$Csu5M
z*w4n*yUqhz$6dPjmR%wy)P<i{hfZwh>_ZPuA`h!p-#1~~w;tjf67T7rfaWXqkN@d^
zWi^ow@Q`e4hmVLK-?nSO9T^)m`}xOquyw|sKD=f3p4_mxfB7TJXI)S=I$*o_j;W#_
zyeXeNjnB1H3sy5YW&On8YN4gzC_)c7??Zpl(P26!xK3CtYqYH!H&`2%;v;|?u1~?=
zmu=LwemMQ%e{iH2p6<)5s<Wg#>{5BXMSI6=k@#n{Z_H-#<Lf#Hh-=-jR`mbk&IKF6
zFO=WZHjYn>TnwW_YukG8!^&;^(tYb(*|QHm|Jr#W2|7u}{^%L=pBS|N=l%Qk+aJGg
z=WblHLSjPI_#!2dCL4SFDQnkqE5R0};m0R1*D7r5;@7_jVDvdNe|TN~d`bpBO=gbk
zBJplIxC-bT{4Sj)xWotIiC4gnuMeazcvc`c${BEQO?qA-e%uD~Rc-C8dAhKVb&)pw
z+(oD3-s8{k^|q}a{PyApHFpnKc~i_<$sN=KdvouI72`)X_0L*<MV)nz&)L}Ow*BTW
z|JvSq=R+%BpTdVAE_!&?s%NL|V0!}{R%_)GqZYxwMW+{S_{j(Ew=4IPgkLlB$ydN0
z=UdHLyz6rhzDocPf<tu7tf;YC;&&0&;CVIJb7U~!jpsZf95~!@z8Sf_Z&}q5OGc+A
zqq|b_3-PToTqoq0*I7f?2=R;a&JRs1>$d*-L(h>dT)BteKjATu7&)=n<Qcw?*p+v`
z@VKGYfX$;T79Cx*?v+dS`L{o|jQkucn;o(7uRq7vgyz7W56{KMr!BgB*-DzD9=Ax#
z%?F-D8zdg-^9Q~F?%=#hPNI5X`X#)GhABDu4x4yF*QY@9V=fZ`%&)-zFCHoQPwD8@
z2>PyL_t5g8wboIo`K*tSy{4&EOXHa}u?d?eewT&Kh!OXeofu+$mtS7%pGTI@!UGeQ
zR$O6I7w_WBR*^efXYF$Z_!q1ker{j7Xl2dKLEaDE9=>tc{anQ*a?tbg>lBYwtV24l
z1YK9zJ_HTpIv#onmf^z(mfz4!JfzaHv47$P@qAfqh&6k=^G+b&#I^)KxRY(xck+|;
zydu_lx^IxUMTFR%_^W<)F^=m5$5At}-~CU1jjUg>-i0l46qTOy=tZ|xgQp#IVHGig
z%h0=HY?k;#)atsY@ikV7y_~g9eC6oC1na3yE04sirnS!^&^Hx5ltrv7j~GN6{4JQ%
z!ACNFSR!+D_?eq<;4%sw(^$i%;_v0KmXEUDP9ttP|L&*6yUH9s!6F!vl*a_d6zLB9
zzcl=n>Hp(@AU0G@oS@PQv87e4aRQqO{3{#&tPE_1Y>D#<a}bX-k>~2dcg-rU^!3cU
z<Tf^Mk>mL3uWb^4ZfNbItv~p{X2}h%z5WjV*_gFVZdmKcqK&eKieRS)Srg}1Hre3n
zMXT(b#plSyKFP-~u~Oz##Ua>pu|vv#JM5y9^b>FgxlHMFaFClv3}TG+YS{~RU-}>}
z8(bqD5Xwn9d@KBAqT40&&J(gJzAg-Gzu<KrLNda*u2*=T;1}N%Hq=|w$O^hP!zzjS
z_N}s}#V;Cw2Gz}-Hc8A}{@|^@A{H>WV|DF=#0<{k@1L`N;>t<#t%;Gg5hJc?8zjzy
zj|II`@Ii8rGsXJTn9q}6{@PX^Ji^YWVe^PfFqa@_E4`KAK2H|9A`^S#`T$r1xPcuQ
z!_Og%!h_Zb!i8W7?{T<zp8NlC{ipkLs*wlBqi`uX3+~A(Dz|C$LP=Y@U4H+kHhcND
z!+qnk@2nQRc=q1gR#ewQtb5ubvX|E$5mPU+bBA}WpuCd!_z3d949zP&R+>q!UTa(7
zAUraV`|8dZx|cO9{E-B1WGmBkExI8AoJbcsT?Myv;R`T_FoyHjwQes22iH06byoae
zbmnscbP+COLsO9@eRkX&;XwS7V0qOoR^CdydhwjKj-MeOyk#@MSl>C~>xE?WY#!?z
z#S3?CKe4igcDwQJCwBLP&+PKkkHHBswcQ)U>?-gXy8}N9xfBjkk^O4cZzatUa)pDe
z=hCgHvB9z{D_IW{!)HCK7*rxQOg?%*mw=x7?DG{o9Kqb<=kV`1o}9m(rr~v3Kc)n6
z@FPBo^ONwZ`~3Uk_`RE~{bq>yUSS=3-t}HLzF1^v(W3Z0Ib~JWJhE)ftZhpoy|(xE
zSJsBVa+P)QNB`pAlK;7F_1$CS0=igdPg^#zr`nD#*3-y=_yAm#5X(}mK5slmya9T%
z#+U9o!CWN2N3b7fZgKiK%posuKC<bWJG6A3@O;m6x(4*uZ-Os`@q3>IfA~AknLU3M
z-A;@ESj+42i;1mGZd|lpeE+^HhxU{I(`@4ML+e|^KWyu^&N=)9?EbljpV-dB&n?nF
zO)h24x>yIFqXwXY^-FG5mBXFQ8cnoMht|o&u@cGY7M3D29WnQPUH)AU1bBEp|A1B=
z$9LG3=h6|UVH_VvI1xNfSHZ?LA&eoNLw<=r%kR^(c&6-@e7|vG_!k~L@%3+Qj5x>r
zcWi{%<~%-qGqC~X(Q>hm^&Qkj^h}WhoFaB|$L2P7@gcDz<i`g$t~#A-2Zt<^IBa1}
ztrZXt%_06>+13jDDXf`GpTo{Pk2Ckc1_Fa%)cpA_#D(Vivg`)D5aheK{s`6pcGrVP
z-^F>r@uuenM<`3WSJ&52|5U(QYU$FU$GAH1iKfo&du_lVIir@bMXTu;wt@K#eA`VM
z+9Vfx^Db+@O{f3X!%tZkt>Q-x6SwWOeC)4cvWi`%kdH`44<z9e$liM%7rKOS>nyqk
z`aAGT9A@P+x$Y&{1y>w4ho78ZNN>ks_<MNPvz_Lm^>f%mzLNe+W4)}HsM`~Ca?8w?
zWuo6@=bwJ}bL(2(M;GAxR5gH`A=`fRF*@KgTcs{$<>pgs>YlVN@S=Qa1@=KPs}yWt
zBC*R9;u8tjfkfh+N!S3b^^V|Y?7;p36Lb&g4Q)ju<}V-4VRxM#|2+<`Un6}P$B)Z1
zpMx{cll=?-77mW^5%5l9N3UhW&%(KMkKzT2?^m=ATN81P`HKhG_f322e>NN4I<z*{
zydA9l6-O+O4v|MZZ|yT@(Umc)ATE5C_}Rs$pIJrM0BeYTOU3^Y+zI6O#0S~ay><ef
zCz!mZOR$H$C^{d(FI^VQ@wmq@SmTLrux0MIGiQAce4qd>r{xiRaU3|^U-;~}5d9@r
z$87ET!y}xu5zDG-=`q!BMFwWAx?{+isO>4KZ6@auWu1GE97GTCvwVIVwl@6TCj5eG
zV#U??#{DaoZ4h1AiQUY>PUaHx%p`x6T1gz6Sa{ybh$ZF-2Jj*N=SW8<<}3^c^m>Ue
zLpp<#INcKB@sC&HFa<mj;)%1vBpg2HahHjs=L(;Jo(OeGDzVE5>)B~)8V2T9ECOHm
zu$F0?A%B8B&ab9!37<!PPILb#@DF<Kr<rw5bxS8S@37JBTlmA^p|!`BE?&b%uGrwt
zZHKY!*`ei<^H6?LKAOW$+(o=5IZZ}BvL^@agyQ@1XW<9UF@ZIgcsl`qIZ5l(TxzD!
zxuUt&ed1Tw6Fft(JlAId&*Ts{QXI)~=W-w5=|z6gJwwX%wRTyIcvI*2tk*^~b`6p5
z9<oAw-q<X@{otI}^{k@X6qB9bBTh21fREGRYpkT?G^>IB+jpLl1O6JFc+JK)uUO__
zr_GZeN+C`g=sRN2#KScQ%{^xs9YJn5f!xq>aHIKDj!yV`{76nE*P+~l7x!<tH<as8
zKRR872jPS3(}~kn;)f`n7$u+KIAx63<Q($6!EZedYi&yh`JNWbstEF7x<ACN>|81_
zmm1ckStZq0Sl5PrNVSju`M)CWHSTf27`{Nq<O*@*0qZ1ZtXN>r(k?XwZ@JtjvF_7)
zHG!I-4C*8m8%ibKAUmLOPALDw@9q6V0c^-bR%IQ&agoni^LF@=)zYR8;s>=(Q>Qub
z2D(3}bMb5ayH^-H6<Zd2iATz68mM_)q^76Wsv4VJ=T@@LP+mauDvPhLL%tI4_#B~E
zdHaN|Tz|`Bzftlb(vf9#=!A_Ok6~rAP8-=EcZz-NT-vvlJ0C!E>X*^=fu0N2I9lr!
z5^s_(US3=8@vKaAgZTXfdM>NH%JCrhQd!GM<`d!LG-8$xpYw8@-=)hq#FLt*bhqMS
zslcNge{Q94g*|l{3FKb&k8Tg*_m;3GJ@PrY?m6EDawr@W5$Dl!I+xD7k6%eXylH&h
zF1$<a=Z&Yn2G4|EozzI=6I*KM?D+v?S+L8ts_sH@8u__N)Y8@BXDJ3>5AP(93--8&
z=EQgzCB%t{p=S|~DnYO0v2MsBZ=v{q5$mi{XeO8oi6vD~XQ7z3;{Vmn#7Lo4RYN1V
zC(a41MWyAg55*^Xws08IBR9Xuzti`EFE|Ht2(NYgfm`9InY!3&{6W#Wmb$Q3)&cX^
zp4jHY5ABdO&=9$>R^Vx!T&Gs>J7Q|UK+acjOVLH~m_+oMY`x$eTwk@E`UaPMkLxjx
z;u*?uWkb8;d>(m1UYppj>p-3p(B}kkhJbF*X?MaZ;iu;?9JddC`b(d8aYfY;?}Tt_
z4(Z@b_v^?e2ItQfF8EtEM7Rphsvk|X*4b^VCNCT%COo*l=dtu!)`m^Q=FZ%DY75xX
zOX$DOg>8IkYByMCtKKT`ZCHoF1OAz3mGtylep}R9i5uilhoam?Ch<1OfZ~zu)ZpY|
zbB{qs@vFX1C0;AJIMU&vEckqnS()NoqGNpiwUHL*gAhl7e$ZM!&~bUJNnF-}*{{)k
z;pgx<oEw3!oj80yHSkezP{6#JR&Ls@@BYM^2gX>tSGW%Bz#mrqd~6;$=^3|7_)mQ3
z<MAAa-Ot#8q9SSm+KA(Iv+j<dU(2nXx-rdNbQipe(PYK*8p^xq`_guDL&!#wctLYy
zz9C$ppBKU#{C(UCu;G3kGT=1jKAknMYV@FVk*-y~cy@Qsua#^{C-xHW5&x#bx04rd
zSrPe?G~%U2wZ#91S8WbosgD|f2yw7|eBm|fCzTUkffod?%Rl3Ze{!)W<<0H>y?nW<
z-XUVd$ZkOyx@CiSX$(IBKN<R;U~Ks_4b$rmxA3CB-TuYtbVO^$3E&bPPuR#Dxg~T&
zj2eVybbS`<%oB;p4wpYic#yBj^PJwyO?;qxuiSrxZ$D^*ifKY~)k;>AFPq!H>v{7w
zYLW7g&0g}tQx|XA)b4fSj1kV)@QW91<E_t$fn1}e;*$HdNz^*X*B^$@CG*MDBbB44
zs#y0HMcOT=qTZ6xLnRYuEK7gKW3@g{**^GPv~d~>kKo1U&3F1<y25n^W9Ynl=RP^g
ztG0acvX!A5GqER~?B{qfE)v`y=w;#1`4gOKo~!$}h|kYb3w_Zhmew5h2>6Kf4wLT~
zwpwgzJ9wQVAJ;l}$$H5ZD(-rZ`tkC%QEM1pvazjw@+qtC_i9Zic~u^!hPZ$CA+eR4
zSFPtFwLZj3nu)j7Qje>6b_iPttJ`+q7mU>lD^@f%YFZ0q5>wEe1&5w3yvn{@dE=p-
zyLQ96msTtfn(2GVSd_d>Am@R+q!5FsB(@<t)IcsnK28QYsJXk}`pE?kOwF+l?4Z8?
z8FdZUY;v8tgyC`EA0nRIX^rH_YCHR_gV;v{xu2e;3+xG)x6Q*h><|9*f5PXAAQPA2
zrvyF|$ArH#TceiSNlc6w(&Y7f<n|sC2g$Wc_<rr}e}oMrhXD`H-~EpQTE}HItDGEt
z&!n|ozHSj>F_ryi{5ru?&`9oIbO-kPpMP#+OJ{6i>jF888Tbqt0yhP+-ONMR3!m8~
z6;?rvD-ZuK6__*OJv~D?_6qE5B|d!@ux=c(_vPGq>&0Kp!Vghww`*+Db0Ypco?T7;
zp%$4v!+wD__C!n(FCE73-DV$<{DE}V3@OyRsQyUyyXW;c7`Khs&^Ok+Ow9PhudQW$
zADLG^7yW>*8uGpDPLv!|UN!Y2)Lvw>POTcB^qfRM%RqL;D_$Q${4ftc;Pv-E#+RS)
zc;yJb-smbhWqd*LN`6TdwloI+)KO1Sj0`FciBCd&P&}q*EraJLUwmUX-}%5g=9Z{|
zt#Uj{wnR_KQQ%7)cY8Ikyy?&R>`(t!>p61~yT@7r8_+l!)T0(scj0*$;cH>py3X%f
z9<j4Z@^+)-7i+06I<EL6^Ya6^<#)@!FQKNmmVFA%>?J57*O)9D&2_SsA)cfkG_UHG
zRx59z7L0p4@THai6rP;!T;qBKSs#4(H8O#oh38Y`Ut*tM<PTlnC_Yt8Rxrn(AzlhT
z2eAmvql^6InX9+FK5K#4VGFVEY3hDeFL3i8|ApJWaGl#sj-c=Hef)=U@?71-K(f*M
zB~EwgAdh2k&Zcffu&3phBP--q*>6yfPD+Kgk|Xg+D(gSRqBU>7*Y){x|LzDk==cbG
z`*e@=|J;S!R?;`a{5oBa1i0ik;1qnKzuOe%;b)#7=$8Nwx?YFVADqUfS6EB*+4T9#
zmRVTF`j?tf>Zuoq6IP>l<m)GA=MyU?XFyHt3i~QXsI897!IS9mU@a#<J8s7{F8AaT
zJ5c>ZEp-Wv<XrNJr6iK4)w(wcSxE;+E-Szltc|q(3D-%A`-k?8I(gPsK5t;jN0vJF
z9=SZEBcH;FYR5tt1H5St;FWoVH23=%OL+8W>-ikwJLN}j{m1{%BIwTHv)66&!Kb!(
z_apKsSHUZBe_z9}W-lnP!U(Yr);_J&%$>mJkp6I92B$8g&^;g97+u`4c52DXh_4h(
z&hTBQ72tQgqL?_mpB&ef0sZ5)F+Qgd55jFhT%Tl;)04fJzw^G849vTKA%4>#p4M~3
z0|ET35BU5d4ntlzc0%xjpE$h&ehBQR_L7#s_mRORyZ+f9+TN4T9e;`NX`0t(XIt~Z
zbxVei^*qT|dTBLdkrRMdG++7j(Y348LycKIdDyf{YUE~@EgPH&ZqYrUjp)Oi(aFw_
z4m<EDPQW3V&Mc}RPFd&k?I-UkThlOvU88n84cfaN1Md!h$k)In_`>Jttmkk42M^-o
z==VU*9Cq<Z{N671%GI(~D}u)+h?AwDSEW-+`&cg#FKvS6dBo9%h$m|9TC3_=+2m;}
zsjWHt)-%g%X!7;-r9b)&`z+qFkxREM%AV7b$yv+Beu!tJBb`nzD}hfK(#p>~Q~6@W
z>q34_g$9-6&_&lG^nWOC?pN_VhuL9&L53Xm0AAtB@fD}L>ndQ-c**#yZM$!Hp1GCv
zVM#-qtvvj~nu&>Ojq3gxG8nsX6T4II_?FCxAC&{sS!=zjwtjNztQX-``N86gGT<&p
zzLJ=~VgRxe4tspAAszyn1v2TlWn8a?iO*5_wW*EmBN}S`qU&Ddosf<p4#l7P?7WVQ
zxSUG<<9HVj`|s$9boS~9KT&FenyI5*y7@M-@;#q};7`FnlsyXT)H2||T;fg2+e^n3
zP**3tmXceHuL`f?H{{^k)UY0^mH*E*M|2PA6!Jm%w|HN36FvFdLM?L$lXyIYOV@av
z49|2N#N}UOI6jY_7sn@mhw|_63hpDG;Tj(^z(w`I5PnoXwIb{nnWDbFcNAUD-ZylY
zXsFm_Fel`n&*I0Z;01QsgX~g#^>a5Zr<Pift_iE9madjqviMl`&c|i!T<HPLA)H6t
zR}5$q=)>x+QLkmmgXjEv;7EW5iL&dyc0`VNuIAzL@FG9FfXfhvFP<HjA+B|noujr_
zv~Gj%({k`ZSOd1TG}<ZZ|BKnLqP;&^+V{&I7wzc}k2K=KDa3xYH$^_Y_VWe@Idk|}
z`x)}7mpO$FY$uMXy+%XqI~!fyv2pevsCIGo2fxSu!|V3yrQc`&+AVwahrjQ2xsxN*
zyb@ch(q19z&2y+N)t(cd12Ly`?LR;Uwb%G)e61xol$TE-MyXoCV)SwZ8{9{1f0Vr<
zW3Qd}u_rcv==&Y!u+gvn@J28;b68+M{oIAWXJ=RDY>+)*4GlF`Mh!?lb*<UNdNqf1
z#!q8>?f-she21TX@!&)I^i_jYS=VG8Bh%EJo@2i@>oV2>;~c^GzYF{aHqUs1TjOeP
z;|$;ZaEsjCXrHx0hm$8OtPncnP&c1R9wtM3Z<vGjo~BT9;B!!Jirj?gpz&3^lU-2g
zYrw9FS8a^ie~mxRzCevX&c6A{bHB^J`QP&~XIaZllRKTFmU3$As$JRLu=$B0>!9YZ
zhJC*!rR=?6J)9*vaAXksPlFdyH4hHu2vrl3j4v<RE9Q_xjOHZrqdn=`XDPamuKoZT
zTwuTE51GRrd(HNJ4jNaVCmCDE-}~JyTbvoOuJ+Sb$G!lkfp9=hDw}f_=S=34!G3(z
zjAxLa%z!>=)QPD+OLa)fTPwz>nm^^i2iOy%eUIAXH{x>;4zBpP<7Y411fM6!m+JiY
z4|Z+k)d}l~wOW1sDc}242p{B;1J2XF7-*t>Y`Ikx!~xhBrTse8`D@QkrshLUNH+Ub
zN^7XgiLu^9r)h6hFEu&+%wcHtybZ5iuu<?ZwsFai@w2~cI>uOk{{Gb+TU}({?3Zg`
z-%vSY7I73d)>skyu?kN&vWBd~e?Mh8>><gaUO{^f^Z1<0kxkwrkJ{r>)`j)#Gm294
z-@&@3OLLfe&H7$FOa0^ybJ!(6&R*$t<^es%h=c3+y^HI%#Qw)#WT5dhYfJX>lz@j~
z_JEYIH>#+;h1#|{eA$zh&A2)=Zr-VrmdidD&8gs2ja9IguOsfIddoIq@5<5l%&-TI
zISefRj_+k1W*$C=*Dm_l6Th=>*Dr0@%EGt}493`paGEuJqwl*eqXwgtITf-`EVt%V
zP=iudMy##WagfJ+@=h^6wJG_;$1Bl2b->@mKFM%=#{qP3USKUdObyrw^cW4thX>xg
zK^^_MC3|&l#CnFgzpv9yLW>H<E@K~KVWf$=P4a{%tD!ycGlzmxr>vy0(ei;i7yqxI
zy2eV8|Ekk%R!@ytD>eKYTXk8&LI3<~%wf}O&_<|1ACYXVU$n{J`Ca=5_kYj+!^87-
zX=lY|;e!tLR@HQOfP)tHp`9j{*JOqD#MLWLlBb0CN}+evNn(5O1mourYtJQqlwWbu
zici(sDRQ66eQ1r-_v!}qL9baipL@~CgRe4&m2K)@(aW#x`W)W;`+Ii#8soDkWp;I*
z{J;pcm7VxEr&$x7rrr$riH~HV-_y}^s`bugy{&q8%_W01PX;m69O}UG*^64vKFvnr
z&mH5hS`W1EWnY5k5@Vmba52DMo)Ks<vGxNS2M;?xShJ0@?A>6GsP=_6_4g6qh=O1C
zqQKL+==E&&%A^wmQ4Om04rUXF%|zxiRIiBcR~=q9IfT3_WTpl^N}rbqK2AIP0b-1)
zHDD*>>*&@Tz{3c<pg9ao4qNv~zqR(nte!o56-|v+bV@a_qBk-RZgaq`kI$YA;Xp@r
zNvY)lziMUDfnW0!o>bdj*4Rofj&bU+U$sugj*+L0&A#Sy>Eg5S(hnYnsYPsL?_urf
zCSttmb5mo5>=(@;ADxL#&m{Jvn6ql^QW;zEIUOn4*amnZi^JjPH(jg!cA4NuHI=pG
zN86}#>A|P(K?n38gWa!k;LG$-i`>I}`k+lEvR#IJ=_nx=kXKqtJ|v&~Ie6tzo+=q%
zME<a9ptLtfxkA;4_@U3lj&x0m;syATxx~+ugO82@zu@N3S>yLDQL9ZnvWI=l-F#Pq
z4k<cWMV<&bMz;v|4EA8B;<GE~=>9q5%GcFeH8_Ges=ia*nAWAL71cUgG4WjZrMk77
z8n9__K&}rti~+Oa{)&YTtep3G^emi()+en%`b=Y^*R>xvjapcZEm#$|^D*%~eGTqs
z#VX=|$LA2_^{|JGuO15($U#Flc^K*yI>m#+0d-g1z}-u&X78))Yvpr3uuGq3V|QiW
z(x^8}!LF&!T=)*))*ONu;!AS@AC3e3Ak9^|bmeDqi652{Q#{4Kn5KT>k`v3;PCbau
zo$y~5y+XPeTXV`ii4DQ7WwQ4z4LhrPN7ciqE=D;A`JOuT+5cv&kPd>`@y>4=Tk%Pa
zT}%$JoLXtgVNJ&XvDgVaP3*OWe0-~Nuhc7v7Mep2c2zn(qlnr8;hq>os`7E*AqgH(
z4kF++{9^GSV+v-Ct@x?-V(7?3Hwf?ftW}H1KWpDu$ti3J>!?$#+Zy{O8GoMfC6m}C
zc(H$Z2l*1-3z1=Xp0oCzrWb+>@R-UoQ;;pKjZ}j!7{z1aNsX<&yct}hv+$mc45}Vl
zN4Cz$Z9zp1I<d{_@bypAv!;#QW9JNd5&93phw^9A(PPpf((hT=m`v$fo|VosGI&NB
zaxM8!!PoKq708-k&XV5Mb&M~*(|6i8ra5JjhtnML%1)AFV2>*MW15LAw7~~4@UA`5
z{nQ1iUzcFd1nz9vk}CWRbXgWMoPq91_wm`|E?fu)=$};P;e5t?bNOB41^Yhmnd7*~
zM+OUdP6;-tlG^lI#&04QEBIsc=p*z%@A40Pe2txhP0=1wtuyoJ_my3F%EuNC(hEx+
z2TqIl*oD|b?Nun?zASJcJ(UWb(wU3spx;gs(>sY@P~Fl&eFXaliE~7$A@5`lR1f>$
zG=2uO&gK~f^-WgXg1>W``i1(_)LNVZ{tC+^FO`K|QI1Br%~W(^F1o+Gt^paVce|@x
zv+s2ly|7c+*vJz2Pq}Wz7*)Gb1rBQ3dx<@frxgFAdxV2bo~8XJMO<4<-lCA}bC92`
z@{`Pg8hLP$3r;fmTYD%4r{F8poMoG!Q5H1Nx-_#GJIT6T`{?qphoz?^19iy5DVGV!
zWF0wi$w3D^*tPIG(76KtrXD{hiqF|%xu>Z2WnAH3bSPln8b2Le2>*(uXfIU2WAe?h
zQLJ^dSwpK1UVN(G#fMqgXw~?L53`ZY0-jk({!F&9Rk{crAl&CN$9%6HsDt<9=dz!e
z{TZS~Ax92#O5+)dDazJJ1{If(zR7?l+FzDM-BB92*IqlxsSe46_))cB&KJy~h-aOo
z2C7N60a?h#w&#fFIs7x@=i@^Z19vg{tDvcsT9;E!d*yRo54x?PZjkw;0jKsTrIT+>
zC9a?tiu9DOQ$2y^;kjAi1iHvJmV)P6dYPQ2K1+K>R8Qi2M>yvpFGc)b0^G_y=Ap;M
zhtfgH(YQXAz2n)kx5BmNkwRUhV3%!{PIjG*-j=Qk?X!4C{y_o!R!Kco1F_pt_P4cn
z;ybg(@U;hVqC9kBE;5;qe^U%zs+dm$xgG5t>12&5zqViNisda^n4h%1{%-FfcCrp1
zqLO{o=<~c1#(}p=@ujNqizD*ONAOGWi{*C=ECp+V*Vb6Gjt^QJbEswic^URtK2SdE
z9PxM=I-v%+h_J3`XI;~cKh=ltG(g{%L44`0-&wKg*)i+ti&+D;yOs6Q{XB#GV-Y@k
zSsn3>`2B6H&AQ0x$S2jBMDzc__L|MVI%PdW*vj@Ouo5H27b@i5BK&&YFa6QT{9Aop
zgHPq_s!gB6_PG_CTbO+5{$kb#g(sQAN$|n^E2#~sCl}em`c!_g{9(;OYqQtZ7HndA
z)H?gRtUh|0b!;7TKZ#zEKZIX&k~y%pJq5iY#Hw1sLFmWo8B^@V?-^j-#oSM_H>5=C
zB5X(wdyKV*DNptgT_hb`FWF}wc{_7Zzo;(!lHP%CJB<%|iXK3v+?&t(CY!p4O#FKJ
zppx5sbdUDS*5FS>q(kv(+VL$rdB*9ER`yh4XN9x4|E8J>=?D4e%1g>0E0Nrt?(~{t
z`DLx}zMdi9x1tW3;RogU*vfZuKle(H`Tg*J(Mjrv@T*;q6MH{RjjwEZCHN{~9az9R
zELZC@Y?7}HG=J%0_+9%KrF-NP$tS5Nj~yA9ay?ke+D?3uulu#80cVmCJwtXyy4=?`
z;Gh^7Dw?Fnu_eqwb>>CTx`6w&Cd<WsY8{dZ&fItB{w$s)9Ohz23ejt&;IRrk)G-J7
zW`+3NT5IHC&twC&*3tbLTHi2#*ROg8IzEp%6v?;3w^SWxefQ||v2{P=`+9-vwJwvs
zk$%)?%_9dq3J)dVp^~~t`DO!y$TjPp8rD508{l>9Kt1dD)8x<FSjUc!6C3L4u=>-@
zc9J#ODP*~UIEQ$-eQe&QCPysRi|nyh)$fw^=f5um`i1*zSw~l3Gb<ZUQ-?@hBYe~f
zAN3%&5%|8U4mxTbjU5R2<TQNJ0$-m(CQGZ~FJKfe%eNK{nxH|Qo?DCkbeX{>iq6;$
z(OEdI5`Tc>0^~`upfzep$5U<eS?Z2iQ!BDT|Bxnni*)yL=I=WGc6sY)LpFe&ni$o~
z*Ha5DIAlvD4{cpB@{9e}6lG4Vd5CKhdJXa~x#&O1T^4p(>xIB?4fC}@ekjOq1o>gl
zU6X52EZ7g?!ACK1p83*e<qdSiW6U0F)-^}>zIc5+9<JZ?Ok%<6-Q&3zKEJ}4$Ebt!
z7_?&T<nWH3!|z_l$~DL7`*bu1dR2PNUHv=s8}O+%NpNbdpNIX>nk5gpN~1@>06G4o
zbn1q*hSRmWNAc|N%-n=GeIJaWIR{6Gqoc9oFdV@z7zDe{!iS#WutJA0X6|u#;e>I3
zQP=x#%*FrK^?rXiZv0uq?Y%CE-}0!F(3qNYLVmU-RF_$D4Luy_d38*1X>EkfRS&8=
zfACMRBN5h7nYRBA|B2T`$X65miq{5v!j#vH=Wu<V0UtOlK3~n1@iZ^N=W_<%A<Z3E
z@%ic+zmC8C+W7bJ`vSW2JdMK~bR?!_1=lKP8;4&s)Ogze<Ie+r{hdcVGME>0<lf_~
zO;6-dyUq2<#Hanc4Duzcmy6k>Hg)-d`$8H|aU1PNuSb4Fd-V(x?IjP+1AG?UkKl^K
zaRfJW3qFUi#d+JWi+?`C&x`yc-UKg#K{V$a;30wDOV!pewE@qvwoYVEHivT8f?3y|
zP%cOKmON;F%sIe6`#y=kC@wA9s5bgUCi?-izyUc5?UCzPxahd8Y8`aEDz_yctd<_7
zTDOY!syWm;+UFyl)ZuW(=`DH)rtloXCpeD23uqk5zUJxo__h3|9Fbtw`517;@fzIE
zc#=cnC&#IcPr@&C+2NYpvU=x_SD2@+b=okl`uiLw_mM%*BGLUgc?dt~eRrIA#R=BL
zs()->yhx51KY=|~+AA2~O?hl`%J`<vYnr3aOXq;c<g0of&}kr80=xt?i_3t+5aLBR
zisLDM7K|Z2!r#Pm{w(1q)C0nyju1!TeByJGK0Jnw)7+)UoYw3MQT<^8u@TYwxM*KY
zU3zV$rM5O&GP!{SVmEozL|>)OQgoK@As%-eXpTJp<^40j!Wf#fuJd@8VjTGKE~|VO
z%0YP6^?uI_xN!a!z8o&$N^=hm=U?R2pC|Z3ygSUnv-~?fPyGnv&wqXv{{*^Ocu8cR
zPy(`^R90w-75FI4b<P(F@PPEk!sBnLB@OhU)}dZE?Q;>FqA6p9d>N;`=&nQhQMtX4
z7oBdB;TP%U^W-^>*XJ-E;VY!Ej}w;xzSBHHn1Xws&qMs|zX5-c%MN)ZpqbN+am5po
zffM8erSn|==@sO4wCD)&iuzX7Q4<gyT4IkT`;v%9`Cb}e@O@Ow%jx927vR?M64!xx
zmjBLKI1z0nJN`M&O933hL5Q2+EI!hqJs`S9^`gS1Y`S1}y`32R=FbS}AY2_Cahx%(
ze<$3B^pjj@p5V)STp<T(<f~HXpLK%#U;^=xUivDulUuv+^*_gdEwLLP|0A2C-b!(M
z_0UtjvGah&3vm$VNvENBL}NPqx|Y9nkIRDSqWN&I&VC5?I3D;upsjx6yO7s)X719t
z3CZMiSz|a&!)IxX5SNmBeGcarj-_Y2zXLvj-)q37`<PoIIZ^L}g$zWrKl$Qq8@zaE
z+fTk^{YWh#et+N0y!R8(bJbViNKYN%AkL2(FT}UcOZr1N33P<h*sqDh>afS>>-Py3
z@WuB>W5lnQy~`%g9>At?LVj1xh4kbx>T(+36F!IY;+ciSh=rek_OgeXKlk7#B#<B0
zz0RZHxQD&P>MyT;l<K?EPJhNG`qC<A?RMW`XO0>>q)|9lcow|iRrC#ILpYF5^|?Eo
z&+!z{UpR>KhU7%g(ipOFvbWf|oC58$5Uk9_WeZr~;iOdgLb^A8KlcUxLVzRb#SnJq
z{X%-%A@|A;BocQ~pLZR})%4zG@5QZee?=ZOYTd+Hn+ND)|Ms`^+}ihjOscn(j0;}@
zEE-EPr&_M(<A-)5ye8BO-?sz7ebB~vmivWM!LMief$n2(mwyjjiK#)~9r-<O=i>8l
zd#CF|8pQGUihTXJpD)-GD^;6D?_+Yrfgg(x%h(C>gOU<#jNW>)`){z{{3G9syK(K7
zjj;c)in?3%;>u=CDnBTM=eaEi=;eH?`9q6<hvU4!+(Uj2`TIF9#9<BT=D3K{PC5?%
zC!i<SaZN%J{;i%T9*EodmuVl+Bh&-BMz~VX!bEyQ3VzW~dR;p0xPC(>v~RX!`7*JM
zbz%f_#L0_n;ouEoR^)sZc05m!TiFoYhdl~(A<qu^j=AdD@{L2fyH6UYt*#T^TrT1=
z?$<et&*2UDC{9b^B#ukrpsIE_;5F%Y@ruR{c`>BD-@{y>ljBKafdkpR)Q%SB5XfS%
zo<oKNKk^_Pw6V`*=i$5bo`?}=B)&kbVCU|emeUY%d!#)I@_$uBqP`-kA#oYkn2hhT
z0gO&-%`eW!!na??-@=dlx_}P?njZ0l^R2!Mj{yGgZ#^S5v)Z5K-|6{rczrD4QaILJ
zSo5A>o^FHXL!k%c<7utu?`;6?gk0jy=>25+;}vYrd*9uKx4y8;&pxrq)pPW??eZR#
z;~VGQztNr@)vPFYldO0)YetuaIQ*KQ<SNv+zUCA@LiqVC-R1CuA6<V$Bfb~j^m_<z
z0NV>NI;??g`89D^Lp=NSaX(NxEsc5`$-V0U!O#8}-=7DsCl*tiPtWtTX7>Bx7i!)y
z_LlbTu-~|MhF(1Eqd@O%-=i<-<u@JHVron)$#bZNdWb%Rsy+Swx*(*b+W_V(UFi7W
zEZBltK=CfWiFd()?s1(C-Tlnp;_rZuUVvZp6^>LZEZB98pY;rmM1F&h6N#y(k=w|m
zZq9Kp{znhGuE*{tv;LJIm{>v%pbeRZSCVSWZ3_QSeHR)Ah<DSAbnzbjnAvyRj9<`3
z9meDD{!8!Y8zYWA!M^=m#S2*@yDktd<1%<OC!b%O_nD{50I&r%H=wuU!F@g5FPy~V
z8lpA#hdki;6s-DQc#w<$SHSn^Jm{Ow+E%&PBytV`UZrya*u?{h#q@r}|4$|MkpvD>
z>&iW69oWDm8({6<PEG&ph0E5=KGTlHOSVD1t@akH7gZg-TH3)+2|iH;@iFOwOaGEy
zmEv8OS<Nl3fAzO$CH@nQo!51a)77u%8sKp{3od;p9Pr%du=6{%DS$t28+D!V`MtPS
z7IB@xCIt3azL4uaVAr}wcu&O!YTXm~G_rrtLkGNAKT5BC`m>Cz?NM_??HPN~+lPt$
z6Yrk8^1x!7x2gZSMqHVAF?pjHb=f7=jeb10iHt2eIgR2liH@QbxN%sSkN+LQ9O5F5
zBdt?jfyZ;2s@?Y$UIHA&@h7?A8M12u4`>|l2JfeovL{^YUFmiH)?5;@wB|t{P?vZj
zBgOi6=sBvjFwc?w58-cM-7`fmZtr8vJ7=cpWjlTDqCNicFRg=|cYWUiy$i=|=E_}s
zMQXC>+cHR9Qhp`9Rf$uFbPnK;(?Gl-S_vl(ui|pDyW$JsfkS7(F1+ZhzvI{XImDlI
zn_sUpxB#XQuPKsszH8mzvbwDWODJPM56_bwsOw^%5WG-!Z4<wby|6QFR&;U3b$V#C
zPB8A>kAF-ZQq;OO4yiG`gg(4v<9iRNIiX)WzVXtX4{e-%F5UCztdZUn3zu(LOWz1J
zMD@g+$DM~>n)ml%5FNp}`yjwCn;gg~{4HAQdhw0(0cZakdD1zAJI*@^)b^%!;O_%p
zQKZgwU-%65xpMml&mT_?VxC3hDm->2noIvzvqvRPfA5dRm@(?gm0Q|;{fYNl)LzrY
z3s=a6X4^i!>D7z-o4@#X)Z-6ehjXlNj()6>9?vnBkZ)BFd&g&-exb~Zo&j&f=^NrD
z)R#v#FM!kcf^d&|dmQ1@aT3UV0&&X(^mtMQdzQr${3czHj6K&lg8ewQK=ml1yAJVs
z*e4=*$59~j!hwF%ytTJ{h~63<(0%)(U)$~XK4P!lJv;pL=dR<_>reX-ruOJhik`Uq
z>`V8Ha<pfiJYS}I>Y__D2aOfXow@OB*|;NELb`^!($8^vJDdSb&fCnbdwV6|4_ycS
z6N<3w$aZQKHDmO_@bxkHI7V-7$8#F+LgTdN8s|01cnG85)EtAq1Gq!_UwG?tWPIAX
z@B>yJehHoXsFPnn-run4D{oqC{RVr`F4-#YHu;em^{7{@tfh;5{IdH8N%Xc;3`pxk
z%|q~pa_{~+u(-^JFot}fvv|h8m;49!x-E%cqdd8umx9ewe|GsU88PY{=<S_A96ys-
zp8Gk_TJJM*UtDWkYNDJc;yf7eCp^L!`W*ZQjrhBtzVq6HUeh^BEhY81tJkc5|7|<`
z=GQh%T%;9Wpr7^7`n~t)&A_{@cJBN8IJB>1X#b(_50y_GJeOyO@QH5zISw1+`rqQ+
zQ1>6ny<m^SuY2OSa9hXq@@X>$qLyAm-DX>p>%es6q$t|tH3Y&zY7gIsc9&;~*0S+V
zbLm9!gW%^o*+JI>T(fY<zGHf_H1yM_Y?dDU9DN(?`CWz|*ju-8_nAc&cde1%t6Tf=
z1$%An{zqP;z4hQjYopJr;#Ye1kv||9LOvH<4p02-@ay*%kMH3sjsxj7>CTi|`W8at
z>Ww+{F1;r6@Z}1#tbDka{;}9~#WGpXCcq=lc`z=6f>}H$y7OGsE0$4*tnaiQ>R_Mv
z@ZOuetL&z=FSF149qb-8XItok!Si=)?FK#o@xk+~k*2ObMmFe8OAi6PpR0`hq*^bk
zf0g^W@iAV8J<j98fsT+5LL6~+9Uk(FUk7gVEOc6EA3eqs$K7#sd=)*flZb_g_6g)T
z^2nL0&L)sQ(L(abp|j5`;CJ`U`A)j3sk7Gx*hf0Jb<-AZeMp~)3$}Xgt{w88mbquY
zvi6PJ*0Xn?{?hC(KX=>vRSd8`xbx5c7v4v9+YWyIzmcb|wB^Hx<RR#vfxHEL!2ErD
z;DyeCKHxLo1u`H!JpcPhPsVZJzMps(A6Yytys58|;|Z7)yXe`YU&<%XTo%M5PWSlz
z;_)Qxp}sph7+d{0yzfN|{bJx*t>vQhnp3~(rjb>D50&=aKKbSs;NT<My!+Hf;f)UV
z;PlgnQ$4yms8d#b%mhAy;zjEHtR838<hb?zD2JP|)Qe0y_(;}6`IgQL@eqE;-@cZS
ze<PmPSu$NpA2DR#c>(_K-a6-Nn1srFi(THfp}TwZJ3;QnGx28$*IL_%_8Lb#BAUB>
z<hKO*gK<5PL@nV2Yr1jXRkVEbnO%M3nRPDi(Q9wtde?cU0XlK|;V&(UZ#2vradc(V
z+UZNzK0`l>YY)hg^--VHXoK`Euf~Q*rW}6e6Y5!qRdfjt!5*iR^Mz;x%zhvCJJc2W
zu40y)95Slj%Ez@{C5M&4K9dA+kyl$4=PPg>_o@6D;K6Aw9KL`P#jxB~FrNBHrm;sQ
zFUmd?`f|3d(1(ruSKs;pxiESU;^S_;!TY(!H|WE0#(PpsVGnEBL#Cc2pa0ok@y?q&
z^k-i37-0c*<f`FJl#eSMiyx0@{2bn+e2w52+%5yqj?a1Q)pLA^XZT&8eccSL)aOk(
zrWAVo`!hmZIvxYu3Rb_Lan%deaS+FKz#l=ZM*Dw+FXcs(Sr4cOlyrZ?2sQwCqjU7;
zM*q(P-#qWBlAPT5{HOLSY<~x~a2P)*O3%7y{C#l$EovsI!K9v0`-`T}U3H#!-$QUP
zzQZV91V-lt(Ix&l;Q4^|iNw17ciC+55!WdG?KI<_MB+Hdm5+?$=LnZC!5HwoKS$q-
z{&5@ydXW9wiU$F|=SPu~#*S|M*$!)__onK#BKU&?@bkd-A#1<8)<R#Vc6|S;rcRr=
z@wWBSx43`%y0tA`@t(8|ojvS>E2K`R(R;)n(VzJr!HF!pjuPyezkbtqaXk3n;b-Qp
zJZ%Vr`Wxx@1l4j<|0_Eqm;zY~a2h^G`D|Sq>Rf%V^@h$K`{Z}UM4Y!ctDly9vwUh9
zEAZ)L+opD|(@%HQnnu^Hn;2*Z`k<5k!vh=FZ2!G)ta1DtI%3!JM!md~s7iI?@jj)w
z^n(zd-M<D-jT;;x{K42hN6piJ59V+po|_5j?Q2EpDV`%(<;w^sdY;az-Ef;5*Jb`&
zh+kbN+o>~$_TDMqsd{MH2E8B8V_&=j$>#^3=vg)Ja&beu_3c0A-Mn{f>h>45aPzV4
ze)Z?J!8<Qv_=@wy$``J^h2D!G2kgVS`UXBohYiCs8?Qg}T#;;`WZ(#XefGbF2kB<v
zMe@OQ&?K~9ISmb73#z>-!cC9|QS2R`jroVL3ogf@;FG-Q;F^HP1G!6}S9}6>`LYAT
zrR;!u2CD8{wIIGm;`>_aqC($I&#9wNO9}9_q7P?y_ewAQ=%V<CW7nSgd(4Jbd4K5w
z@A2E>y-jPEd0*iz>a}WZeE$*eW>|K=LhAwdH=&!(f>ZE&3_!B2`NP9*>wr`JCj^gj
zzUoyZ9!SvMMQY;Y)4izQ{a&Y6oF9Z&u9wU>9(jKFT+!Hh2VPJNKz!+Y5zwU`|KdLB
zchO$Ih4j)ow}L(6QEEeC@P0v66Z`D%c@5#gJD<{<YKb1LZ`cO?50-f^k@n~}kVo2j
z{G};gs=lXr<Sc_e+`$@DV;s$oah*4TIiPdEtIAL7`;;o)-9pUDaZsxDu4MXU8ydzF
z^i1(d5^+HB(uu5~=30AuLj9_<;7b9w!m;jEEwa8ZZ|?KBb~XKLD%r~~dO058ryA<$
z%A31<FM?u&5pshMe*Ne8Iz!+Eo;ZJ(-jqxD1n5VuQ@vg`Jw;mR@2Fmv#Z8062k5IM
z`b&O+Lv`7qpP*VT$BXj_GOhdt*BnnHSC>oPx2?`?{t04Rj)NEZUi1>rLtE7`DX&@5
z(&oN`^k543PsP7+UBtEOhv_`PJd_6%?9zp@Wli+i7EGh(Z*V=l@`8-2rnv;XJRm>N
zHg}GCp&e@Gc!$$0`!vrU+6eFZ()+23sbf@)y54;?ym6V@Yu<B*Zp<QPScHF&tQak8
zk6f-RE2;6h2fQx6Q2d&8v|{(nRrWrS*j8Gk%4^qLR)j;2fd7$uXefE|K6sLC=@Id{
z;v}vcwZ0Mm)6Y;iVhq)Z$v4z@%7N(jMf!`^@~&O=<?7)bja@6(sGS_ON@6>q4pV$u
z_942kYj1q}CpOM{xD8+6{CnTwEAYNj>_HKHufA^8@Jy82>xtdl-j}6}nu-Yfd6Yj;
zpEdDnGVkls+(jqXgK=Fbn8fp`)F_DNp06f%>+c?gFI<O0Kj(SDp_(S}rM(rY>_<+e
zmc1$-lXE*K{m7xXk$5@<y(j(eI#Dt~Jf)r<JL*9`uz4MNUh#f}t*n7N+4~|rDE{?6
z%FMAw^~j^@#XLq|rhRLj*(O)8X&v)B{!T~L7!R>N>SF&|4BgmGf5!>pC2iE+#&|Dc
zpbG;ZrGRGzK09zh8_7jsW1agYY1H+r&y(9eaN>F&J+8k+f5myyfmQx+a#b0zk1Tqf
z)msMp^Kz+Qary#lqUzkBwc|o|K)k@ZNbd$uWDTXy=idLP^kZg!0K7avKk5nIJyVAd
z+_G>5f0ur5yq7LY9lC1bG!MnYBo9sVyvu<8yfNfKz3bM{gAwARt*oUc_wTcweA|1N
zYX4k>cN)q!cD*7xa)hue*RB01lKs*M`zNT&(!Pvr;E>F_o|X>-y*&Oax}hgCSodet
z&<l*3RlVcd<r&&0!VijjJDs`K*T5Q6_rWvTtCvC!NT2iZ|2t;sxjuc)M(Dp7q0e;t
z?5@W|58nRV23hm!y9WA&H4n_ux1h%7E_+<o+-)QDn#v*$*fg+UEfegG#xL*~Der5!
z`w8!HrmjTqZYZX<^hmEV7uR{hfzM0)DBB1>Gk@{3+jGwTPCCVEh~=xlq2wctz3j=v
zIMa#$X7Vn);C&SG6#~8%oY~|=0=<VF1vjF#&RUa7=G7-9hj*i8@jkgp@;|NQd}16?
z_8M(G`_ASLp4u?`^1IlNxkO*J$WT!K-^regi~?lS^&|4YUWsD*vvjUdLx^pN(5p`G
zX>X%ebBT8tPG7$7wq=_5faW7R?yw!fEnF~f4!39gE<K(iJqV8FqbJL*F?aXh$YrI}
zvxlmM_rTEaAb()c;R&9t=g1EV^t$ss>q)H@Gwamn82b<G;Ze|1@4U7C=o9K)mpsq0
zeEm(EyZV54QStu8u~}l>YpxsAv;Ncn<}ZBhU)`nN#eqH(ALo$|l;5oPIIBO~JnwJ4
z^5CiG5c}|z9)9)DY-szo=MW`B4zFyiY?tdj<QjZRAL=`=SA)N`A1aGDmGiv#g1M)~
zs9S7g-`_m%4dY#yL0t^L@jUgv_x!%-3*PjdjvxjY;6e5;4SlL}680t&JsV?xn{r+C
z^xy4RxP%{joA>SQ(-VSs&{7B1F@4s?@NGxv%hpcsZt?WW)qB>(zC88o_1HJ_79VJ@
zNXMBQ#0hw(C3XLbt#okR>h%ZIlXTGUV=0h>5PqHG^bhS?n7@+0kN_TJ4<zsM15>Ei
zDVYKGR`$4~_XJyt>KK4ocy&AgyYmCTiQn^qQ_oaxAc3=VMP_XU`BLpqrT(3FR4vep
zGPZEp-#xp+=ULuKw?yBQQQqY?d-#mJD1CUy57+aK8oh_Gm70i&n_qz&*308-?0X7g
zFj@;YbP+?ITC*|s&2L<}X`7F}0DlMG-y%<aGX<~14}COm@x0~?{gTNgDAu7mbjA8T
zw}&s7%6{7f^mziX6b}zr623vO#(>wQ<8;7_L5?G!yKr%2=fH#d<fqXuB~`sbz+DD9
zBD1>0&OQEwT>m3KHeP?5_fuT3IbvX{3F=rU?#H?>hTo$af!dx0?}-tkcS>w_gP0gL
z6Fo7+-qdpH=+m%a`N%_MbkO?QyQO{mOZ((c(F46p?BAun#%qbh@5J`Brk760Z))+g
ze6~XQ&*Yx7u``PC7cCCa(}KPd&AjV(X~N%W=&*$_gU^7+p+9gs&&PQ|f9oBvl7}St
zNB&Rn4%ABW=6N<xEL}a;`q1+;tZ&Y}{usL7up!=CGKw8k&!O%!mx=joP$!Rn$2*9J
z*vF<Gy^Gh8@zEJ;CvMO}+@y15-)%@OH8hgr+QCKob{=qGSM|Ol;t6@wZL7vp`=T9w
zt?8Jf-a9_BxPlH{c0G_q9cDUv>csQO?C~xJ_FQtUndt1w;SQJc08V^5)-r-qzM<O?
z=q~#toP_?aXrI%_yOPR^ERWvt+2n|_BlHq3$l)DKpII0F+Z3^zQQ%hZiwSy;cn^rP
zH*I473AIq0*2g<6^?vVR`nbmM1Ec8sw!Tqp#ar~WB!^Cqdhtc`*qZA#)%=vRh8kk;
z-}0p!=#87~0plG=JV*1?dS7*z^4+W0Z=8#bET-RCK4+~XWLNXrBMxh3Eqjdy`|1DR
zz}{x9AL6{tS$I$^I|Etv&(K@XmwrntQEdc!tjU}BJKvG1lsxufA_IDNZCY7@4HNtB
zIg8FC2R=sJZ-SmPGrV`EYxx3l9K4g`U(<tqlDO9ty^)52N9)2)Xr=db#dwE>^qqRO
zD>mGRpI6$beY5Z?v{7t$Xzh|s^KM(kR3|RoahsTgjjNg%^WJgw{qzqdj;ePF<wsk6
z-)SOtFo*rd`OOjdhCOu+4fsXq3Fs<$*ZZ#gEdCb`fI9<zas7r}Pc32X!?l7tjdxdP
z@LfLdLRHKs1>B^vCng(y7&v>2nE!q6H8M$$-EMjgbZ^}BIA1URVBgMN)82?4dc@3a
z?eRX!1#}{DF!q)9(Vue;y2@{yCr_~Z_zQnuQ*3OGT8drPi>qE!Cm*_-_W{hTZL!zn
z9`ABIpm!qs2)nzeS5iC@x?u0}fioGMP}bi?j<MB!&GMlk`l>X0>>^39yB|zEkbCrg
z^MJ>(joRA-KV-4@Mel3Y`X);?{?J_Si%AC`>J62u^#$<fH`UO`s+2x28^piWUuD-i
z+4I`W+I8;r_btXcsGD4O7rnR7knif5<Q;v;`|QCZ)=2pH*o_#nKZmXC-hRUdxOVj1
zq3zw|UHAA&<Md5hJ4A<~JN2HwG-3+d^!Q!i{ZFgpmutr-=||d(Zj!&l-e_cA`>Km#
zG4JDDSl@uIV{dvN?++$cdprU820p=@1sr+UgA#0cE57{sScLa|Q|AIbMej25q8EFk
z?B8RbKJQ0g;gI~7u?JwPpFZN$Jw2M}wFjeJ_TZzh=yipTl8p17wU+5^>V9}134Yul
z?<;%fH~)s7IN%6>V1V~9bgbQGeYZqzklgU<O<PANw9W1E?t0$yL(in~t5574?{ypC
zS$)`#zOy$xhSEHG27XL(o1phS)PobP1ykr(t^L>P$)f%dS?mQ)k<6n1a@gxG8>KxA
z>Sa|+{CkwW8x=L|g9nz@C~%?28+ae`XKR!8HSdRPCSLOK;;2pXKIDAl{|dSCQLcMR
zF5&Iz0egqz?Wuly!ux?AgM%4*OLw8a<m>5u#4CH(u+`hvy?Ws9Yw6vjZ}0kf`ad6{
z6R4G6zV5OxyaK;K|5@nY!TMpIzSV=^aP;DvHpKlgdXo0B1{|etlwxL`<VgppFB1;d
zs3D2cUm~n))_1wA-=w#-|6S|%0^~gno=qSYBD*EoZpUU9@(z^h9(ol-YAnK$2mIN*
z^P-@EJ+Vc(wt;{2`I&M1jCWytwlroR^X~7D=7;TrxgmQO9E9*co$Pb?yRp;ad%b7*
z4E%cb?qlNqPuSa9%lxm|Dltv*y5wDZdS|cjZc^%_+R2&k+<Qh&^a=jrHFAiz@b$LQ
z343lc+lYs?XidPr*AeQ7<U{t-LqIx1`rzEdkI_~5snXTNigF|9c5GdK13iq`r>x!{
z$>>1IxB7==(bp@VHIMuA(7zDdP>B4Nu)nDZy_Q=+zv<Qn`wBkzl6PMV2cIsDI{Y8b
z4cq&`{vOA>GXwT)x*s0sa~{z9%6rh+i})$6*!S_PZ`s8Ueqx>QdB^fKe^2iSd(Yd6
zgYSO$bM)m6d?0umy*LBy+gKm#on8m;d_}yc%WhLoG<ESle)Wp)9Uq~8(;)9WUBI7I
zFSRrK_oyKvw?c1c`GU&pWZ>r~6Wh;VFMScdj%sy0R)ehPpts#tkqcB$z~c61-cL{O
z5%T|e{FaSwufnER^ZS>ZGxp8;w0*TYX<vv3;`IM;e#qX3{(}D<;CCK?{^EfSdH{~m
zTWgZo$NZJsHUht@*KBm^tet`9`>BB(;63-^@d!Rm&(tD%;XG^qE9ixFo9BHMz3S71
zj@aDconGjYVSJ<^WWSj`>;w3Q@___<AH76Ycn9yw!9CUvEpFTW9X$9a*_}=3zgo9h
z^4BtfP4-JM8}UFMdsb42X&1+ut)R8Z(%^OZ0-5N6nx3c)(vz&cx6Qs44x9(Z?Q>+{
z6L{bwWZ(ngVD`BTJVOVF2Rg7-QF1)Z)H(Jn(nA}6w~Kc%c44!7@N?u3OE)Y+w<+k|
z$v$iKCtn3_!9Ton$Nk?{d?EE{TamwuEs-xdLND?@WPSqQZ|pqra$+GXH{SAo#!KM3
ztiRXob+CTL20~wbR-e3N{1e%9)i-6M&y%rPMd-0q`7d0TUyr^-=NGVsE2S?_34d2{
zT@}}SyD@dd11<xLBlclj2fQo;{lqDk$!p;I0h@fcR>4fKKlwsKz$bXL7VIYXvCUdp
zwPNy(XD{5aethTa@AA$*;$Wh4^Y~d?zV;?C(~};a@1<69fO@hecztU37J20ZaJK`0
z9b!Ko+T^Xfyc@DPkOOF(M4Uo2*O7&c%a&<fE1x}=nq}GWZ15nSC`0E9AGyQ?a#+t)
zV9z(9=})$1fq(jl2c!o-0sfD8CzN!c^nmMtnSR#;(a9a`8gX3SNvwX`wH@?<LJypM
z_!YK_{#W!U+`9F^*Lhv^v*@Q6OxrX(O|M4vsE-jdUA;*i5Hd7EO@!Wa8zWzM4qHD!
z9B5*Px)OAM3$ejQcuep4iLstgTv&ZhGO^hytaGx;=~n}Pr$bxOJq`aX1OHU8ro-#H
zPBgDa-c|dT4j&Yw_ZoQr(e6mMeX>4j@1gg8wmoOxot<$Ue6>36df@v!Ao!&R-bN30
zqp!E90qcN<trNVPbn}3I7wB>7yY7Acht@^CQ<Qvv7i+yfU{^2hF7`}#-$eXo*^UnC
zV_JE)+ZpJ*`|gkM0m%svSD1wFl^4h<EF*?AXP4i2$NG48zzF^H+Sq4MMb4p^exjAV
z#Ieu;;`!>~ZhYb#_f3niiTUWZ64q(i9_LK6W?;_2u9sl@_JH>u`tH9!Shs(1dBy(l
z;<EjGXWo8tZq|PE0uO|GK(<hF5b{9wXw-X76%uPyUm*3tQLiZFyk(nZmxKI-eC`(y
z)*txXFCSWeYCX?=THn2N=sOO@u{;+^E&~5l>z`B9ji}Fr`bDS*hWudf3Bx|9aQq-<
z6psJ>al^mAH@@ca;t`Gyo)vFUy=WqFK<)jlAU2~K2KAj#UPw8GaE&S-?PVN<<9+`e
zA79rquHWaM^|xYgs>xIw@A=po|Mcjq;GmyA56~DIs85jMWTHX1Z^ZG6UVKi2zd5$Y
z&V+xBiBIA8=o}t@$M|j2uX*00lAh?QV^F_;^#SsJa>8F6{+H(vj{m}(m|rkffUn^C
z?~N}S2>*`zfc~A>#1?#|TKZq8*GD$}vlRRDy~QC9gzy~UARIqDKgaz`^9^C={5S9)
zpF@nkQf<hp-Z@nDx8UGKIdGVc<RBbd=Kv4N6M0VW2xppCfERy9VF-JCZ22`Ya>*St
z>vo!cbLw%TJ`6eZ;86ZjeDItP<1`hG|Bg9meqm10#|_8+8?-0)!PrUY-Po&J=<DY=
zP##otQ2&)w^0?kd?{CmSYws6me*}M=4w|D5^tk6HLz#p3#q%0hdokqS3jQwY>ct1@
zw<bEM*GVaT;1mN%Rv(VIJ_=<~&wgoq!FhBruIR3@kvHiW)z13aVP;(XCXFq9+XehR
zOFwYC+{IkP3lZh<s0+~h!1Vrh*9YH|1&`Z?aL30B$MqOCwp)DeurgMF?_lf{jgK8y
z{;8X>d+{y$SuZNy&`qy5*^UPK#i$ov7V;o@bUrxZtC!*Taq%Anuj?4Wt1*RV9U4op
z>l}V&O({Q9IlA7}A6oxwmpOR<4t_unz2@{@)@ovT1@xAaPLfXc^_pM>*8%<m-q+tw
z=l_?lH;>Wl$`boBEs?daELM?47Fn#linXt-DpnPXJ1H(jic528E<>_O4#^=yMT}%=
zDA8182@({^f&`&uMLmsnTaBdA?s20%?&)a^#-8?MW-=HX4LCNO$v7}<2MO%Nj{gbZ
zzWM#md#|e0vHi!x_kHhs@7{Zsd+xdCo<-RveOa4Jv9*@4p08yb`dtJKq(8jiwU)~q
z(c?$J{Sy6S8=5(Do6oN^hO5{O&Z2K0z_(<Gb%A;@&V@p*eyM+KVA5WC+cxmIPbfoA
zD91LSP9e<JOpUW3c|uz=ze^eG*mLM<>`!OU{u+7Ku>)|fISD?-pu-@w4Yn~S%}Z!r
zv@g@3nDaUB75&p@3Fp`4>`ANHuWNtvyeX?wiLDzM7_bwUW{&D%Z0OQp2DoR1AK$|r
zCx4aNFV;bQK60@H9~LxN=7Ci_uY804Ay?Tem*C^5j_f&SDc{AndkD`*{Iq{zxBous
z><sPYy!N?^IUQ~=7I^_2u%GWB4@wicDfRC&m))1wq-?H*Y_)yyAM*_!p#Av1x^Mb7
z7kl*2bLI-~;4HakmOaRxlWEj3fcqWrqCB8X=$_t-Zc802V%wxatV>}(R@QPU+rVkm
zyjHicKQGr>?-y|AuxlSI;r~+jznpo}Mords;=Q|P90PezpZi+q`V;8wqsYZ<ZK4jv
z)~?7;<rqR9uy>Ds8B3<ifE!@)OyB#<ILXH*&#mTrbEMmUH)m<)+Y}Go*g>@!*zW}U
zgbC`F3~`pyMc)1vY{~1%y{|mT^4yxc&vQ-qT3rgdJLkh+NI4+f_Q`+J!a89Q_bK0V
zmF4{#|80HYZu;n?K5q|W7{qsDgmeATgRTqD$2?R|YNICS#*Xc&mUA5CqW)x&Ul%{h
zwb&@u%4_tM(SW&5AKEiZ`OiGDjzPGiZ)8Fx^Kz7V?i?7zzh*nJxYo&a-fy3OE^yJ0
zow?ud3rCjMNOiU7Up;{_l(=6s4=lNG?LXESc-wpChmHRE9Xt=ttr1Yg`cs3Pn!?WQ
z{F{LH#)Oyi`+nv`4?ca}Ts@3u``mNf2Pe?Ne2|UgELKmF7sP>iCQHo2>m{t{?`57f
zG55>BiLn{-y0rl+>>E1OB9|JlUCk(WiM^YK?~Oguw`_zO749L#MK^xMy_~&iPqKFQ
z0J-SQOR26XAE+-!u2s&?JU2G}N4Zyl9nf<XbMi;O^j%5c)%0Bl-0SJPnLX7`WX?|f
z7<W479Rs)+Xa6?J9!*?q2N!+Nqo2LrFni^p#iQ`SbmT5G-&+Ow+RXn};bl%*^Ah8`
zQOWsi1$d~W|0;O18d}$a^L6yyNZ*_2yAAu*JaSiG68oRQ<}l4!`i{T@dWpUz@ZS)&
zSo;@tbMl(c&b)H<oRid&CoOW(VLPujCm%WHYw#a2Z$u6K*CC4==(7oYZ-geB**moo
z``op)ISpVhm_K_Pf2FUdozP(xI?OVL8O~^?T$flICeTgHL2ON0`yNDJ?<ZcggPheH
zyS7IjZ*8~cJU73)`H}0ex7X8uBWu7WKDR-OZq|Z6_HYB(bw=oSvU6*iW6wS(?w_aM
z;tCvKb0Pl3YuZm_!6Z3&$2dzKh7TQsHR4;y^|+3li}r19_d4=f)|3090eis)t}XQ0
zLx1D=dCvE2OM9^)9N^slFz0ATu@#;e#;*^&&$8~X?tcavNC!W&3;hJ0U;<rv3|&=R
z^kWBVrS4b*IWz6M7TaANxL*hEHxQ$;1$$K|aE@Yk-%Ed|v0Gi5=ucO%RTbAY?N-1W
zm+<=?9-Q&AZ$4*P2WFv%_LU+JwRkXBwl(t_@lUJAW?qNAypF!tZzkU@eRp(hO#|R}
zmcEz9x2Nkf!|DFqX!<X?9_$=V_hv`ZU9RZM{)%z%xqL6i0qpcWEe(L*JlOg-4P!I!
zBnRI{@(8XYe`XzcU&pn98Vv2&DTcuH+)#HqLf>Db?_cMv;ibjN^q08)>s=G+;rv*-
z$5>|2J-p<-f(Hxur-9qKFoiB+-{YJ)kD(KoqkD+{yNJWww4GeI<g;8yZtV5+-6GuE
zJJKTfetu>sU0WDS4|dZpw!X()zk%KVWybK3@!X;RP1v*>w{}J@Z1XR=|Bd}0Yl~}b
zT&!vO4Y~fCKh3j<GUP}Fb8E}?G4dex0sFStKf7;HCb~v0zi&Hv8?grPzI8e(d0$!L
z`fjdB_Z$_<RpmN;{pa7O?h5aBvUZwZ(*1&CFo%!(mat>|M__RLo_|#!m#rD%y4OB7
z7jU=-k1?>e#X9d87<XK(nd<Apu1vMwiSos@%6#2z)c!Mf_Bz%k<zj|M*2TaZxO4p#
zZ@gQ<8ez>8>&LjxX&dTdUD=Aht*=z<|FFdv&*Xcn-wnLccQx<VBj5X3Cv2mKH9|Pl
zmje&jQXGSA80S#xIzYeCH}BW-egit9=UleYhkW&%ZmTva^gZ=0?Q><UD`l)}tKY4$
zZ^qt)Jk{SVYvV}l-P%WY1|D3a%_VAH)C$k{@WrlTeX?GS?>4eFDjSEfKe+G9^bqiX
zo)PrKCKUd(<TR}|w=4dmwY;;At4X=a`qIieqyFIjIo54)$(r3EJ=x1|pgy<0{p+X`
z(7?LXNZ$D7jg4sw?|GKigFJT6SFAIG;9@(paE&)-=Vo&oo0pn=oz2MB7ILYyA=|pP
zZc5vcF+*)F=nbq7=xd{lVOThn&E#t}e{IyW=RCulpRM>NcD8LzeeGM*AlE1|ViFtf
z%KN8d-{%^$o!sN*<8LFcr+L9!ySh?GXM5`FYEQ$Q?@myAWg0u+ESKw(XKh9Q=9x7Y
zsdX*dsf)O6`ye?%se{(tmHNq9Jcdni2R6mo?VV|k%QG$Kzxf``lWr{qYu41FN2~{5
zTRGD)7p=Y<+UNXVI@U=CaH-A0`5QJw>}QqKn5c%{>xeIE2G3pi*1C@j8y{=6`6TP0
zWg~G+TaeZ6wF`Qgi@$*!Z0n)bCf3k)&b-XUZ%%&cVQ%u~R_eE~&bDIn@7~q|?~3nz
zktcT>d8oG%54NqXEp>qJUVLJuM<4&257k<;+j_RAw$9Gf)zOx=chVN~Wj%RV8}K#Q
z41KLbVE*4G){|Dw7CQ0i+)Cbu7V4K+^QRkljC*eD0;klYXh9Fzx~-LZGE=Fet6M*H
zTsx`d39i<ekArz^jJUbI=Q%%aMUOYnS|xbw!tX;G9lvoe-TdeW>F!&f5^wohy7T@Q
zQ5$#9*<0aTtpCyCl^4?F$$O~}xj%$X+>S3+2Yh<=)lWIAzn%_Xyn$~9F$?7L=q8tm
zI>YdOWA=A(Ub!Dz_V1_DuY5$j>r-knzrdPvod~9set~btT5TKpP+(W7Lw<T@*~J{{
zA_rt2@a`ZlM8w2#4zwRXj=OJulrBAbl9urAdgb%)$C>6)&a@Xf11P8Vn6=Z*g{(cy
z_<Q$`$|3V|Z-$r5w_Ha)nYzYJ*tRF}6@EZ2fw|O!PIdU=UF!Drleha6{&&>9I&*>A
z*SqnX!Df!E=^<Z(wZIlUuOKh)olm|?4V{C$JD;vUdOdu3cT?YWp0P9$li52u5jsQ%
zdp!4gqs*5+_~{gF52NE2I51{IUp{l4mEe=mi7$>dNyZlTV22q1j*@id#_e?Y!u53V
z#n;luKlu~RKyIZu)^2kM)M4Yl^y)k5B>n)_`OweFHrHai3jcq2qLOvR*a-b~3O}uN
z%&P-e?xTZq-oBSwFE?IJhcDft-ZOd+=W&a`vUJBYwM%IaXHI)B+)QU45r>Vx?oO^&
z#yNZRRN8{g><E5)=4F^9mVJ!cO8Vt=0P_U3BWAcdN9Q75@AhkNljG`9I&<eG_CA*b
z2mcRz5V;a^91L?NY%R3ooYfAJ6Kop)j_KV8(&ZP4iGenI$q8}equ-&nz(6_!&)$0X
z^K|3QkJBN>u8m-dxZ1`x&oi|LbI!|W5f@X!{!|;LxmBGT;>y|#{ga%PgNth~QU8~7
zIBmh6nYQCoD4!ai(N67wJ0E-}U3u-p)XJVvd*J}%dz+jrcbG%YsYT8j55N3AvTc|%
z7<{iT-eJzcQ~0oa@RL7FAN}l~ra$^ODW2PV<|_8CtAT^Z?|c|@z`3x6+KKa=;mu=@
zIe?Gwr3a7G2S56IX%B6?H#29>sT=pxgAc!%u0DP@-FW(8_z~^rY)@GA_s{Z8X>;M6
zKl~H1m+7ab{R%&JKZEc1)IY`;!VT>M_y;`zuf1vX5<V8xVd=#Gdhd<bQV($^*Z=k}
zIHQ{-CI=lJUro;!kK>OT@??no)a2@)Kwcccm+1h$yq(~#f%xpDt9OtupQN++t?1+T
zBIDk}dENf=_+%0HVJwq4-hcE&jLW$&#9CxNyiwwR4-n&V@Ww0T!9J2kW*5^{Vr6eV
z{eYOSH`1k7-b(EQ<LUiB_-EwICnl8nU0Q8@3(gXNE3+5oF+ck6gWn>TUV#^JVcci~
zdC`>v7vK4UJl7NHji3A+`viMX?Bk`_K_{2)q*J#aq2sfE;cRw*v*=5Y-%F?Pw_Z4Z
zH+*y4FOS35%E&R+<Rxm*fBM6}mo8H;_v4@bNqYAOzn7L?LWaHc7WT(0%!{4)ejkm!
zpg7pVnk|1i9%K4u$bsK~@G7-9N77MzL$5!1k9l!FE#UvwIXnwL9E<k{#__HA(I0V^
zg%1yK7xa&q1#Q;)JHrQ=|G)7J_`nm_RN%n=l)){?Klk?=rVa#6tT#JM4vzNO!|CjU
zSJ>a-`$FxmP0R;vhSu&d9_jSM*VEg-^|Oe#=qE<|G`>8Y<gTixtv&cHfAMF3fsf1E
z__Vywd&IRN|2(%H$9M0+hhK1xeJbrDZbckavR;KhA!BL>#`|x60?t0+ESvLwd|oH$
z@BSx$D`La?CT7y(&%U1?y!%;t<&!V+Ij@~Ki`A6Z3phg-=5ai6e#n2}r%OM9ryM`Z
z$YZa(AGK8WA`{!S(~)mLKZQN`(XHRolg_{QTg04w0sp<n^=`m&?ddnt2({RI$EVYI
z)+puX?h_Z%(Q9|pDPkE95u4FL9P<qG=@{Re+xn<Mcn$qxHl5)dc<Ji>wD0;Wfdlga
zXE<0x{OcgGp?A<J2dJfR9{;GjX(#o(-}ugtkbkeI+fU!8#sD@<Y*~fO6P}<oG#38s
z5*Hah{EWGQPoH*5pD$vLig%SI*6QnH4Q$3oa*!B>jtTPJV~1(L{?X1_Hq5$s0N=z>
zbc5Z*=AM7?^_Yj7kYS#?kK)sDfH{5?zpJ~S{2-0;u5#_xD{qGEz5etg;<+ECgZMmO
zdh$uyvgc4*y!vwB!2ZR7^@tbokySq(U|sx2@W|uOzL(D3e>vTG`Y|{;iypUt++*&@
z>%1fEL3`;hF7i*muf8%It^99)@=1mp;v+eec3*e(rKhpi>_xY>HkP@IJJ6qY<HOjB
zP0aiR`WB30w;x1D+5-$T2bY+u57UV|FB6+^leM23Anf5Qn4gc{`!wBr@<Dq0J3mZs
z{r5j*EhiTWdHxUIdn=uPfRD$m*8>N}dq|hf)MwI{ZH9aR7azWgzsLz<h3Bwe-NC<q
zC|#k(@PiM(mBs2Q?{l6GSe@szQGEAP7>m#1d%+vxq>u~c>^m#i2P%^yj}3CfG3j?U
z&$@o?32~Ujp&qz^%s+P}ow{{DYH9YMAD;f;hs5#RO)q`)Y5MS|{}7+dSJT<MkI;z^
zq$}t#pa1NiAP?RQJ@u7u{vdtwqd!cqe(T5JX)nIOx6*$6J(UN-;+$N+xg+qjAANKY
z-;NUY`M2KskavDNefFn+o_65llgT*gpPkKQe2~E!@C!Te1?<5m*|QlA^7{qvfH(Oj
z(@{C|pv`EH_hQXpOaqhby`fDjK1j;Ir@#NdqvPI9f5EE$$q#?Vx^R#6;Wh5vW^Gy@
zy6*@&@rC=ZhX3}*KmJqdoD$#t<lXphhPbW~=14a(R)3Fu$jra<kN#QU-~P9dBX@Lu
zFS^j{>CW4qrt9cEvqvwaJ*@q+_<@DYP^V^WnT%8BXXDObX8rd!^pA5i^Bo7j^St+h
zH&*6DfwOow-pStew|zM#aZ$q@8AK;Kbr;!&Pfjmq>Vxb>&%W{jIW6C0EhNt;_T1yF
z3k&!y??0W{7H5|(!!s|XGwct}-+UomfG<8`z5M+5{xs&oG;8Ux7v4)xKKd;9KpnYt
z0GWim3p@Gvu4Jv7lk}-Bw+vUnQoth){GNRp{}%Hbo;J7PG9Gd~6*SK9l)+ixCh$=3
z5AC>aIyXw;MSUyV8P61J_Q8Aj=Hs{7Or4O{o<8(r^7>%AGtR4ly{I<i4aBUB;EOYW
zJ<}Mtpa1)mKKTAmSnoc>uZ<X2@`KDn+Y_&TmiFF%JDp}7k**D#flOhK+t`XP9<oFq
z*{hG=!XNCLL380NWMDzR_{})8`_M4H``fcTa1gLV&*l5hpPYyMFP9$$ZVG<zQ~6|V
zHfiH^?cO8ywH^3j;hzXx7ug#fAdl71G-plhagEJwK<8GcR(ACr#GcCfdYm;vd#m&K
z`r~)fgZI9fUi<6^>EK26jIng-jZf43;gf;$_3T}y(D#<Evc8}<Op`z4GW~pM%+efq
zToa2qu+00w<g;Gcn(29>`vupW?49C&b*X^c_HsT7Jb~u|zpk&@Gx&*nE=OD10{60K
zJAUsmH2nZOHu3C?dxlu7R_Xv7->jXgow!}=$qY@+Qg;cTz+H#a5p?DQ>~p5!nfX&!
zg17sqEr0XfZ=pAIg|4=a+C@9r2Ohw`btCo*_f!FY&c_kwx$1kw`sFY$!{&J=WA%JF
zctQH-xRK^rdl??%KK~1Qz;D~~TF!47Ph|3SMJ_Z&oX)xXkMS4Ja{P-Q;oppopuXOM
z?Q(d6{8rc|>Nv}3#uwjQDb}std-7tsjchyxZ*=w(+cAv&_`|;*`nbGi{;xgg9rNrr
z_p|0k?z>p~a@xdPE#$qhG54Wo&{-Qn0YCen@T&-X<!fcYmCcU=Uthuj{REBzXDhs6
zAFh@1fNQ0>j@&<#VUMlF*SOewxj%OwYHk2?LzHRrWo*W-G-InM#}@5AcsJ{bI*{;w
z?+^X~d4sN_>;8>szk+85utjt*f9@hTT>paZ%**VP-@ugdg5QCkcBEO*78=L=V7&3J
zv}Mf2^C2h118sP&T)b2G!(?;I_@`oy!4oltoDXatJc$csrQeko#eTy*M|QC%&tZ36
z(Ow}g;$pmw)T>$|-^UndBnQZmd5AcnH-Ga7(QX5_`?C+8M$Uv~m>Ki(+$?b6xM*AW
zGx*#Stz5zy{NpF@#BZKAMsyh;1<kpa`CP4noA(MCQ1l)ABJS*${)0Di9C)v|)Ncx0
zl%S6be?R)Q^@xw$c`Ypv8};$`e=ps7^)1%F31TAdrZcx+PEWu1-N0oldjxYIWc>>J
zFTo#h3O{2cmL;C!UIsJc62=@C#dkjooMd^@GhBI3*!|4%9WeIb4em#qdHdo}nB!Af
zQRocLkBkQj_=7KaHp4?^oAA3lUyWUN3o>CGfAKw6??p{|Z4_mkE!1PD`EP&c9|R6u
z|Aj#tknqQvB~0{N&@W&te)}m;#FfG3cjZ9jii>ww{SUm64~+ZE{2#hjh6`zJpV4o?
zn(=+c6SQmF-sjUx*qw(34q{H^^F+R{r^cFg%RY4JJ@|w_`Qpdu1ee+O??|WbypS$k
zzn9+p?oY@edndj3gFlG5kc}U@2?K3^#acb`LV*YRjo-n?`G5W&xX8!OxS}0-MVNfn
z_VRawFXRnj$l;Imqky0LnOuYx$hX*g+CJBR3>VT~yaXQj?x%Eb1b){`YwS(4F3u4P
za_iMMsb4sjZt}T=PW{gJf136Z`*i-^%V~uDQ}iL7gtve-U|$8Jzk`+;Ou^#;KhFp|
z-{o)dl+l#&6>UnhylwBr|Kd6Dk^L7i@?6+ppkv_H_PMhEcwQLs+lu+(`_b+Se~1rp
zP~gOvL;0hG^-3G}-qYm0*n61xUSeCYF=#8UN2khQR(2Ke({Jqm^ZxPgUxr1z+i&24
zPx^?tFF)isD|k70AcuQpZqQFIBQjhRc*s9#$9$KuuN3wIe(o>xL4H4*6O4i1#rK#a
zj4{>?#wjk83FWN$8~VwEJ35K2uP*Y#w@~|W>DCJw{PG{;%4nR!#d|@AWw<gP$!ICA
zc&@+)bP3uAZoHr4#dpP(;}3qYpPUDZ-+B8P?_|$q>uE;&;DG`cIX;BbaTGk{-X!>8
z6>e7W0&aQ!S#go$#=INyidWEIzGpm+t&~`<kXgVKI6?ORO3vGkv7mEN3oh`H-w)oV
zP3vD3JQH-b?Y#YXCVtbdp8<cyYXzPP_zV7D!GZV@?hIb{HqHlst2fCb;vx7T+D6_K
z&#r=h84vJw&=|alhu|@u&*(~<<jalxRJ<EF$j2J_k))|S<9h*{{qvl-jL!_dz?pQh
zUEdGb#fQ(@ZnlpIp3mQp_HtSm<BPFzFXHBfDZdI`T74;lKf_I-PZ#%>`2jnw_%Z*0
zIkhvI`Y8@FJgk<#fqVD7j$Jwj+~AGz$A6AFV9GxOhWxwu@%g}yFt3^m${2Aczeqbj
zea^9oE8lZW`4#Z{yqCD+zB*(^_e^$rU!HK@uYSJZiRGLNv|)ViGvL7I3VKCf`M8RH
zV}8(A@6o;K<`2FRzM2^wfxj3_PTLq)j4dA{@HocEjq3e?Zv{8cXtPCkEA-@yuYo=A
zmdU?tOn#?LFZ*OXaq&HHm47;K!tXfn2d{_^z8j+z^1*lGS?5e9A2a%7v@Gm-h5TK{
zhyC%Mzcasac&!+tFxj8*(Prq%_EX>lehBy-dvPzG=N+Ca@*tW!L0XDa&tGG1*rqY$
z%AkPV-_kgHH=dy_VGBO@8NQ2$;Bm*}|6a5kd=US0-+90lyv~0aZ?EuMCg=DqKLEFv
zZI=@Zuiti&_feWY!#+)!;643rYKUXbaFXGB_50oz#%xbPyU};nzI$Z-WBsoh-vVKe
zewRNBdV>eX68t1QJikKU4E`_CImc1RLg~(BZUNtk{$st*ZT`!+$Z@0ne;NJ^?`!c(
zY{0)GU;*d;|95`zFT$TQ>NSdg){m&GjZaeaQM8-m(=j_n=_-!nyT2K$SE>7Jab8^c
zvjKO=9C;zbZ@}++#r>QoS8$R)C$8ekXdmzk8|`E~pTq3E0`BO8z8tT8fH!$%i?w=~
z+vWI&`dhvBS^W6Tf#Vn#9$s6<TL!;#jP~>P;vT<+!TZIhJ{TFz>638;&Fq^ti#Z>2
zK{%WTe8xJ6-WboseQ_(DSNI}>JHuJ5A<91CjLR{I2gVrm$?*_4DE^~9Cq9Gr;j>j+
z$mj03a(tN2P8h22laeo^y_~ONT>0G2`pa-0^aFPHgs}$DcHme#azFBr(O2y8$PE$y
z@jKw>|ImMYhyEgWs&XR#ZJr8ouuSjbKgL+#LYWY_cf1AMfd}r33%_#}a;ew{ua(A*
z5%_m~^WE@WFUNnhiCE7KC-;XQAMHh(ncN84J9gWp-=a;wyI&1l$X|}%d-&W)d%yc^
zcAx)jLw=FR`7g%7bMj*37RurG`QVHA4;kfW-d?l;{gne5PdX;$Qb9N2&Uiro5c^t#
zy=nRX=>HjV98<3}`eR(IW6~%1TYToY%RX0)*KrrLpq)B==6uF>T9B>EjZAi6X9Vs>
ze4V}oXS|#7ZqOYXWb0?qF8?XpY{yT>C!Y9R{?6}gT@Y?@kii>k8vkXuD0qN;=Gfcp
zD|m{0b@IBk?`rU|vLE9YHj%euc}~;Ufve>IrryIc9&A^<<^8SMKs^-4<;C;HTewdC
z<A3Y<m1AX${P*QC)35)D1K;y|4r9Q>_Y!hYl~k6cx&xEc6XIMvr+d7!8W-ND4dEBI
z3=fVmo14nNXRK`}ZI<_BISk<3Ik1K`J8JmYhP(wXY^#hIsEt!Q!>>Q)rTyeIR#vNL
zuILXL9D~&Rmgk%BGZfF|*lPL)hE{MSE`&RWy}*OdhRzp!kkS0v2K;o4-Ow*UIHi65
zS>QbGx&F)NK@;g9-{y0I`;pU{_SMm1{GNT$jxxS=jC^YN*_!iR`o*5fKH%9B_Ly-m
zhud7QRrtTg{0Lr?-|df!XKY6pwBb0;(+}@)R#`^<_OX1v^E}TjU*fX(&G(GPz-TT-
z#=3^OD^>V(dw<!^7GraKIX)P3%>Nwr-~(`*&GDRG@RMU+Pt1UGtOg%T>v5T*v(mMW
zyq^Pmc9QdKU1}Rg=K+5Kw=hCuX}#&&k5k2DU#glN$Y>WZOaGi_%$-Ibz87<r@5Tbj
zo2y~`()XMPviw54=QwHC_p9*Xw^pL#Rrhx7DCnQ@iT`EtP(4!mo7czBH5K?EL)&$I
z{Q<W!O}Sb@zK(i)V1w85u{O4m@0B>AkOko5(4{kxGqwbOQsr|ok7C@wrcCmCE&im!
zZrzjek?!=(pZ_c!{N4vqFGc;Yp4<T9<H_gW$Y`I#wStd~_J#f$JVe`3Bart>sH-HL
zQA3SS=SM;F*z@=-{R_MG70u`3T>r{iYu7r*+_Om^-UY77$M}fh(_l?bW5xV0oAdZO
zkPn~~+`RJ54}#X_&9!b@!TSZxvi36gqh18OVZOKwH?04R(MvjR+R~QEKKX&)J`*yw
zfP;G>6UB>sAU_p2;=gk8?v%4GMVsNfx3Ufj^Rv)i-8b}K-p_3E=A(9w)24as+3%{m
zO8d3sZR#B!jyOr@f^k!o=zMF4)2Sh+rZrC5-h4<r8+mf!+k)<~4i-F2KiPfo>KrAW
zuaP_uK^NL|ZPu2*V}3DUkFhaE;W9Q*c)eGSA9$t%LW3OszybLZLk^mYnRP@t;yF>=
z<GVJsh-HMH74WzB%avhWo%CTpoQpNLGp~vF!vCsw=Pvd!RjK#H$yAGfSS>X9-k<$x
z`rZHcUq{UDzFXJvd+m%|Sms8n-vKP}n)r#iEZpES+UEPSo5&fiO!yW2N_ggP{^DP!
z`g`Xx+5%h9#rJ(j-Yc#gf5LAL^i3~c3E!iP_w7p_VeN#EE6Fh-zt$1AV;-^48FRi8
zzv86eGjmk=j`_J<$A5)-tu^?q8Otx-V;yHs7{_Z)Ph&@<t#y2iS*|-co95qqms}rN
zO*Lacj9<<8Ipf(<a`u@UTbvYo*x2U;UuQ7K+MV-tq3ad&4ZhCdcdWuDo&sju;J^6o
z90%UD<R7WsJ<j-9OMI64OI17ad@bSu{H<l|;>O%+5$6oAC?nTk=W>p<PweG?^E^A}
zGF~=Lvzq)|#w9DmN`ccp>RQ+b6KDOKfBd_|Pm|vi9t-%@1$ZuUoH7n+syvT5%KZxB
z>N5JQ;uYQzE@`%!_L<x!4>IjoAFzs8xR6~w%kRijK%386Yl`^1wdP{ij^OjLrt%-S
zTc$hTm3fZ8f*6z6$w5}EcaC{|TN`a<b*vn36=&`0FT?v6LawbF8-m}!0XPYn7Cg;d
zgvKj6C~yIX^H4b`JTWKaY3a$cA=ltrbB4;x>WMK|z*Q|ekoV-7;Cr4o2D!1d4gd50
z%+D?Ir~(_GA<v*~tjR4+X$`f<HaxzPDmG`i`ksZ?L*9Wi`CT4Z!+Q;rqp5Rd9$aLx
zr@}7{>&TrM<L3Da{EuQTFz)63a1KYr&+@#m39qyeS0(B>$`sxS9K`d$4oo4d{G_j-
zGw%jY#F0FZzbB2eIi9_ftylEn_@QyE<Mik6I^s*zoz0(ZuG#e$_XiFdACep4kN<kA
zAg^Bh4}U8Is)*C5CKg4W5FhH})@XW0eH`A;?De_LM|wfSLZ&MZ9Czqc+z(#>V35aJ
zcF&|LVl-@T4eLXuf8@GH&=XjkxAy68@gm&3FTV!=Gp68a+vd5jQ*$rI$}{S8!dW%i
zOMYF~IOdr$-)G=~vH{@Ycf;jFsdBtK)t#7&JcD%|<X<|pkSdwSt*_ld&#p=>_#)az
z$S3$P)@A9Dk1^IS=n?dHtT`_H3|Y_T`mUZhgRdrD%6rDEOPgxzU17h`Ca0VVS!KJ@
zl|JI0eBgiFbL|WN2W7N#C+=nXNyv&Ez7p~*J<D9FAx<#x!?>LTA<v!jJXcP>#EMOg
zX~UJ1Y13=?!7!%w_wXedA0h`Cv3mS2Xa0NkVQl?ZkR5CK%-zgfWgPNswpL~IDdxF&
zi8ITbZuP|5Wbz5z0mm9}n(3Fc!Mvy>N18I-E8qvFIGY3K!OylA_+TH6d@Sf4XI9|d
z@p*=4JpglunHRi<I3#@@<Xg}DYZpd??!h12U(0h<)BV}={9j4ja^&7*4AEZxjPk_a
z_GxWG=YGHmO~ixqIMy!U3O@BSzk*-=pZ8<l3m@+Yr?hj=?)(@eCwI_No&Zki5Ofum
zcrNE}zB?}?_b;C%{$@PFEsUkCRSk!y$<u*fExJaDIYPt<SKl9eo+`+tXnS$N`{pY#
z_iD7q`vtzDO`fx!jJl7%y$V`Ky;fjUrWE(Wwz7-^@FH&FnQUGMJy*dl+-upl>A$1S
zRrqJbJf>aoo#`FYRhaXOXG0ffyg@Hu^LGinT?*YR(KV~#x5|-@RO++9QC!i6zkQx(
zg{_Ww-DnS-m%v;0<?~hGrBwKX|G_cs2du#4r(=EwKax!T!`C5?bGZ2~e+#2DE_gd=
z?0v^zU%+3C$xrV&hJYRTtz{MW8G|}%T#l1*mH0b{y_9<+vpeu{V%=xnnt#Gvie=mv
zh64Wh^qsiYrfOovtI0#}?@D4u<)PKjmT=#gp6vN-uan6->dOobuF&3jE^h;?ISVqF
z*O1$=E92`N=8VqS{0g`WnB@b$8z&?D@~7jdCf2YN8^7a<OL+J{F7B1a<-HQ@OT^@n
z3!oC3O0x=cGVobSyI#Ulz!C5gt6ByR_^!X@1%1fk8Tu~z6n~D#->&N++ZgXA>{;sB
zu|By*#oR9DcShrar<dm(Hml-$@R{)Em-H;9U9W})X~G(XU8agXvbo^P;Ky?2t7A0A
zxg1=TGj?+@l=ENJrUuq`@_g}sHTH%Ic%WSV<(V?ZUS|7zme6iFZHk{J^wTnVPCW9g
z{8R9i&pCgBe{$S~y@b9qI~Z~-U*ij1y;#RXzA4*sIT!S#t%BEsk8`+%QyLo!(71_w
zkdD#uO1pea^0U73<>01<*i++7D|km*R|0!8`3CCHBf7^%Q}YBh-PvE(pj#QoU1eU5
z91oSWS<c$0UR_I@=If|HpRpbN@GG#RMgPDn&I<lg&U!!Ad**g=ZV~zbGA(oyctAhI
z)pLCfI0)E<l{QxRk2&l;a3a1l+LsbrNuE6Er7WXA$0ILS0=qd?%#~XWOy=IG!6xGP
zg|C{cp7}ob;mfHOJ4+2$HSew`&vG5~+CWTiJ@5Ez1D_Q+K8(Ari8d-zGrC?S-|au<
zy>wv=F+RRKUU^;FS7W|f#w7d|>><1#a06pT`&DbGa26NsiGz&BD{$LKV;A|`iT|yn
zJ^4<(%RB&e{H`eA2M6oXVXJ^Ga3ZfmyBgqXLU(N)>?7{+aH<2wb*z6IID2bCzHMYa
zHPKEp{O<i)-l?X|df=_4&3f)N!dI2d3Fl1648|J#FAjvC&jNnsT#*Y<Id83!SnJir
z{GH1%eMf@Vr9CjIPX%ssnk!p__WtG_^Vh`XT<3e=z(C|z5mxg8?EJ>t#4`<~24cml
zfYF>UHNYZ`>%i9*YQgtCyqMMlXCrf@jac>#%!5{9u3M?KunAnW6JOoLe~rLAGtiq_
zfV-ag(#Sit<`H0yDJx>_i1Fp{D+93k3A_6w_xRec<bx7&qo}v6_=@DbF7AYz&y4po
zJZALI)-ZDx`FmvPZ0xnAxpTJ`ey$@9T{s)5iCKp|r=D}8-rMKNf89u)17IdMavjgs
zF((?ZtG3@d$-bPJ0M6T*h;!e-`qAFHC2isPUgE}w`g+p9DE{E&GuaI957DlC(TGld
ziy91dtheG*9uR)#o;py_ANbYl!cN5ev{tJ*(dwvAYc7aPCq;MTxkBEphTA!yojQY^
z@3ddWZ`ZOa{QE1hL))jdYZ|EoT@PJaU%ru=#|MZL9U;F$O&WXc5%(KY4gI#>K7$;j
zRt$7phwR(&kN;NceR7NVdfqc%3Gi<OCw;x-2k`3eO?^FGX<&f5Rm8}*6N}#lUu*&o
zo2Vz&iyg2Td^snooNxL3h&2@YC<|hrsUD7>TouokvIds+k*^n+^$$@;R3^o~S$>i4
zfiIi?8Luz%zw-><Fn7}caev}j*=GLd)^kV6%SzpdJ#*wEYEB(T_ooJEwPj|Mxr$7H
z_U6ctXV(K`BRL~BcDAIRd&Gd>Ajcj!+)O>8cHsQmPamc}^ucjx-`m-q&hJ}DV?zVv
z>}g5u<|2SMI;c7Ium0M9le*}mkuk^v%FjA*>-t&91@k4C6J--|oaSoUN{*BcV%E$X
zG)kPzBr!tPl$au)Y+TQMmHaa2BTu&VHRhJS7CDEFOFVq>R$97pCoK_Iec;qZ>SUZw
zv(IrI{c6Og?0WtRwJW|(jPtLhgTx;ly7KFhug-i8>&RPY{=UYo9psztOWOvCpPVLl
zIk|JpW9&F4iG`bV9E@Rx*oayBH($50FS}1)B^Lb-`Pv^6<8dz?A&z4A(z&$rxl@ec
zOys%VMJ`+WKk&6X(f1+ZC(YMq{sZIwtEhQmE`U06AvBU_b_@70H^tDxA>#CofsYdr
z<7{4?zybZv;$tcv^t(U$s}G1tc_AGkKI`xW`XOF>f!Ok$N2tZhbHcyptJJI@KII@j
z`p@yac~7iErR~x9azD+#5IGsZi}@Ei$sN>79x3tBPyT?By-Puh8QQe}Ibs?1(ysVC
zc!~HH@<Sga_WmGa*mwF0vA@*JqQ1+*iLX&F<X0mX`ay7Y`0B4S&&k<BEK+u%EArj*
zPIJmskRPWO8<@D*41a9hK1vPB9n^@Uwk~v;I`llTl(dbnv2g7*J{vsjBM-pAuifTM
z1UjGpI=-ijf&S;0E>ODx9Qcf5WUTI~fBDMlJtKn|TN%Eq#(X#q^A9+d7V>~}jm`vJ
zrorvP^OuPs{M8tT^#FE*_kHwR;9>t)ucyW5$&oD|ii;c%@<RBKVW-GGwV5Lay%^WZ
zIMAcPhcOrCQme&A-n6wnZ6hvekl4HleD0@+GoB=VYm68p^YqWa_lqaLmW<io4gAKN
zOq0KUio6tlns;4X#JaoO|9^TM<`>eYB5mZ6D#o#nxUS9274vy)pV^)Ixw_z$F5-Ur
z;9F~eO)?&10*o!2WL)Ngo;24t<C7lIziWSS6=MMh;j5j0F5_g?IK)RazSfSzx=M~^
zLn}TI;AT@>ciKu0l=l8nVuEMVAaQG>yADPEe#c>+_E~5bdrb7tunQGq@Kf8-sw?QT
znl|}3O3|^6X_H6H2_s&r`K)11TkorpxMSmlx~P9W46Ve6{fmPg<cTQyU;cE@vw9rG
zcjUg~Ssq95N5LbkfiZ8$HwDi+CgY4Mz)uZwrICEm##?MB2iFKWxXnX8L2mwW>a;BP
z>t36_vx{|^e!adlmR}mfGOreR;nV%7aZnLM#8~wGu7O64o41lHV0-EyuT0+r@}2lo
zujqeOzlB}rOa1=m#!=v8)u(p9$SJ}&-2aM;O8lB?$)mEK^Q4XN$R^@5^ub=~U;MJ>
zqEi$(DVN6*aQ_l6iZSK?h3$=d*<QuHs&;?zv4RWdu(<-N;T3V>c*53^<39RlZHyeK
z=rP4OiqEi%*<aDOpR3?rv5PPcVObsn<4|XSXT^s+Vk}Cz=g01~@~g0|c|M{4g1(WF
zPYZo<EzfJ4%+47cL(Zr61I}W8in~=fSQ$fsivl0TSTf&*qJMcWZ~zb4zdjyi=nECv
zEYMN>EiN+nvpE}m*gyAU3<0-vSiwOyzWf>6UUe<wKV(3TPuoKO%<@x`AJ_d8{X3@U
zKc|6x+i!tWb<wcL6l3r+_$luj+Qv9-AKlNrd%=GJleC0q+y~hITJUaOPRCK=ci@lQ
zt+tuNte&hrqn0x;>8brIY-G_l{nJn6ca^4Iww?Fy7>a)7E%VSz^T>lrUqw#P<^CCm
zzNe9wJ@`}~7xNd9qX^x%npi<|mIe;gUt^5)58p&iWA-+YAC55;GzfU@7v5ZB-Z##-
z%|j~A%b|NEHs=cT>G1bqOl#Pe6*-c#-2dz``M-KSvR69MM%a3V+lzgL_W8)^O#e~e
zjqzxMR*!y$GZ*U|n;W&1Jxe9+R13>SYN(kTlRQ@y+>1F$JMPnjMO(h(b8Hp*Qh*2R
zMU?=*dGqWia@g88I4g2!m+)>p!*k-wnkLpV67F*Ifi<E3vG=Pbhnjs`kIFd^^N}_^
zXVb^me#_9;?JL@Iu5v}rKE_t$Qq^8<Efnj8SkKI}!>H-Sn6%FY?Dh}ul(JVVhlUl<
zQ#@3$zpdoE`S9#h{*ji#7BF%z@L1rJPxH4{ftMQg#pRBJKCMku&c3poa}nzbmU|DJ
znHR9&H)$WT200_2$9U+sRDQ63;FK@J4j}KX>eKIGzhzwJE0iB<*uVH$4(t`!EGoBd
zOjXngsbtTq?~u0H;#^&roL64azHJMm{3w3C921{mUtiU?bKd=S<m%Pd08EwiS;Zcz
z%6{<Q&|jkx*sIuwd4}v+eI>MWUmiKgl?$t6!}1skngX|by12l3(O>k*{m5Ah+}f$D
zfvXxE$ERc9dlh)le(6=kSgLr&XT^Wkzp$^!rVPj6Am9WK0bjOe$m8;j=hqeRQYCy}
zMLX^@>!5i(c&`J#I(WdmciO{h8AEYthlo9?W0n5meHs7E)tm-lx95J~7nohI%*SZH
zJ#$f3(@u@;0%I+GnL~Cx^_`l?H`qu%SMwK|H_!cS>}mPbo>9+u3j2mRCFQ^Dg7)+m
zb2j>=?}D!2IC4R<|Mv{6b|dy3_UaAT_sk=@p8a$qS2OuUTd*Uw;G4CD`&+oT1-n5D
za%3}OGEd(I#|56&GiEPkX~^aLGv=`KxaeD+6360^_pNQTzH1vbO**N2*G*2-E^@AI
zW1rSa{=qKt5225fv#<;Q_-@XFd)TjcV^iqdwl#HNx7o&+%_ZoVyp$`k*2er(Hp%z$
z8#tHN@-uzcF#dJqVr(3srrP9CYMmZSZL<^9QyONk+)KUdZt@1AV^TA2U~DiA4{cAQ
z*bc`A`NU2#+}E9kwV5!ko{nv)n=|2VKFu}OLQcf3>}A@C6YV0ORUh%;){!0|ufRC_
z1@{lr?DeME<G6R3L2q|Y?`1B<CeB2(A()@hTn!zx(?d?ke)9efvv;;;n|q>cA98}6
zHY;tJyR(k{gY`Vz+ih&?frbOIw{nlyw_{ftWGurA2gwCQT|eysd3zJ&%`gwFdu8iz
zx-YYCt2q)kk{8r=+Q{|go~VZ$Q`@H&$iKFm9DKA#4vi7^BeDO+U(>n))^oGH!UkZ@
zq7CFp*v$T6EBbpIdzlV$0J@*)Lzmx<{%r16bI`h9wzju>Guv`MQq8zx-|CoXOTBk9
zamZWo8_U`nXO6ojx?Z`C6m1dvPh0M<taIbOrUpBD9r+uqpWZ|sWpg@g?&x8@z&}MB
zzOVewFXL#kc9b>99BgvS?T~|dJ$r&8*X@ez2Nu?%$iqrIWqdDZ4X9vk%JQNj%c%WY
zyWa6+^#F@^T_>{jB3m<x{IQj>))em}f1JnIuhp3XZu;?Eb(u1C4?g94*Y%J!=oRr!
zyr;ZDzOgpeQD@sV!SQDAU^`J?<*F=Xl)8~}5xJp_bse&!!Hc=Po-6VL)3@tk_8xsX
z-;|&EJIb>S$dQfA-DYgf&B&JG62{0kt6U73n7@b3GGvl@j>)Ck%3Nz>?sar~b)<H_
z`}<4pI!^4v%Cn8+3vKZoYNvN??@rs9%Y)d-hew#(Ttg$&Y#!<ldF*&=eb+u6BXVLZ
z=NX*?J!v~}DkIohr)DP7&bjHdurQN$EzG8c`RTNCCpj*eBU{NU(*|E>bAMOVf_Bag
zvR~F7w}HL<Ciaf4<SgwVpGG(K!Cv^k7aN1~*EyHX75JMyUGVpSb7eeu*Ldt2b7&Hu
zy?(R%KkP{z+6Vfev2#V9lCJBa4QmKzCY!cxOD*lxltj0d_R?E=SwF31TPyg){=)f+
z>s$kLjXd7qS={#a12=Nds}Wjn0w-<YvJV+Kf^3}HF_xym$ByZVkXhT15!%?g$7jJk
zbDli9Td8y0J}{EjZ<Ov^pjB7u>hEV=X-VDmF$66}#)gqG{lwRkyO#0v4-Xkf@?UiB
zCAXn<zp=r#<B#|fwJWRlji<W(lc{R5E0v9rlYi#`d9}yWQSw`l9zPO3wQIVYp(DCx
zPjmQ&J+rPVK3$)}R}6i+f-~U~beM>@K*#rfIW=>?f?rJe6uDp*NAds8eGxsw)_*}C
z1=jUa_{y3KWz5|*=tKIQS0Q)D@zvNu-o_ey`kqCWtwolVLDLp;x4DmteW5mj!bgkt
z!WV))oBu2S>Uu}hdg=tWQh&XuSyqnUXBD*{8xBmQ+JneC{A@}my3!@iHd~JGroJ)j
z(-+@JHTW%6?HSH|pn)fRWPvq&%J}UW?Xz{6k77}4+k5&X``OBx_*eeNzp;#?nj<^1
zJvC#FvwiIQP2|g|?Z?iI{iAiqR4T(i^I3EteK#u_@Es%<tahU+<b4x7UV<HI0Nb7W
zZ1;$TZ(8iT18(mX{vc~<A6}p~NCUZ?SJ$t6aTjx-gS-U#UM-H3^O?NB1Na%%Q%`8D
zCza2VlYK{jDj8@^|JDESSJN}q#Qz0sz$bmHpgmUux?cF23v<vNoZt`Tv(MDQC!G1#
zoS)C&=FDPwPtW(YtP9Ochf@jjYJFF4=v!Z559)cJ`@a_IzE!u7o1S&9l$-$Bo=iIy
z^_$rfyGIS$^O@NlR`3z~e{fWeFYG4dLK$mt)b1<l_vJPGo|4PGoH1G-&^kN%8LaJv
zADda1<_5ywNP4$UPG<1)Y{ZiQYrxHa;iHDn+poaup3&*Er*E-)=ipJ=te782YgwPd
zjwXHB*FK}Y1^j!)y#^gM_?{fn)-#?U-(Vg2l$x<`w<5Ei!H!psEOJd*M{PRWscc|=
z@#%hAK8QKtTwrbm53twQ7gk)Au<l#K)f$G@^2~6tQqS}f=U^LJnS0Pw9PBuDg7cOg
zsdL}1s2eYT8$;=5@EvW}A%m<FA`PA)<|6(RFFpfr2dv;lzx*}$|JO3##Bn8hXZ^rn
z8n}2Fzxd7R-rxKi?0uS3X@5I?SELr|)kNJYbPQ=+L!Q=2^2aJGjAi`_@}UfUNFK}R
zpYgnSSe7fmZ2yhuf7&k`^QYAGwT`1T{JsGmmg_m<H+^CXJntS!rGw-hB|gdX&VA=D
z#=crv*2MnEzTFo!aGtg0$f2}_b*qfCFa6Yh1;1J0ewIB{jKSZ~xs!9W;1`~0qLyms
z<<rz8AC20?`lwIeyG?usXNL#&A~!he^Nfdl{=#M6*Jg6^t%2X`u}j+Sx`Dp<bdGpm
zelwp`33WT<0r^4OV%U#(z8c*s;OD+|EI&KCuzY=!?@`w>>Uz%d9OH*p(tiznuK#B(
zv?>{HUFLOtp4&Ow({@ph+_tWGM(51t6}Tt|_u_;;>%mVQ>uS>gbrM<2hA-U%zM&YC
z@krI=JZePVwxHiDKOA=%=R1vE!^nH`;}7kOTA{V9f1R9NwsFq1Wo{u=F;DdQUduUk
zCHm`HbmS&<Q0IWWA2a}m;&JSq--vd<y_D6md>h)ob!;Kk&JR)F794QN3(r=#*M-kZ
zfrb55DSM}9knhj70Rw*QAs>))bqml3_`XufUJ$>Jn1krL!SeyP@k*?3@P0eBaVwEQ
zJFeVJSAX=srkkJscG^I`bnPqUoatG&+xcm%Lq@Y_QVqIKGkL?Sx1dY2&uQJYC)J`;
zm$42!i%)zdy2!K8eyuv>1hu$#PU2VH9&<&W({ChV76N{KB$=Pg4QtwZeP@Y$O!(}c
zp}s{Gu`)Nu`vdMh_%yAjhN$sVYp_++5gX+`w5gAJ(d^5FxduI_!FWhucV4I?WiiO$
zTAqjIfrnfUXcw(S_SR4b&RpnaoMlS)GWJDb;|m$i7>%*W$NnsQFHTOp@i}?H&wz){
z)W`W)RaaNMQ`6m<Hk~+-O3}O4AP;@El6{Oe;-I^2iGSL&Ci)uf{OA_ebhW1E_wcX(
z9`Q`#qR-d_=JbZK?%@5GsqfnYUbJmmgH0QRbQFIfXXzvORCy1K#vlp5wgO>)mNjpg
z55Sjojh=zlj>Fgm<+*u{JufqcRp0G~)`85QnK7H&!(1?t!~2u(GXHwhhT)y5249P*
z3%7$u>d>=m$T_!`HN)7ZwdnW7nT&8te|-bH$<bH=-G<H{OS^78N<TVpUDpFq+x7cr
z_N5<i{T8*3$B0qTH|HJXz{l`L*oN8f3*S2G9aIs!R5v|DTuD9o^5^(JTkAKHPdacT
zj^umiUC4d;A09+Lhl~a<`sK@q4b0;b{P*Q`=`Y=lZwi0z82eXJ>+GS_M?KvwoFO|$
zYVb8H>+MR%zW1F}H$D>m7!PBA4LfI`JMGY(a0l<x&)vWJQR>`5%`tR`Gar7QHjGZD
zpIkZ|wOxPv0`*<Ng*9G(2tK^5cYBU{_l?Ajg|DHsZKhTRcG7ZiQ`gD9w6{C*6V@=F
zor~7mF2QybbDgn!78>ypd}jI`V{$%-7x1x$z3RftZ_!>|n&WJGV0u?JUdAqNT9Iva
z=)GmgGW|XpI4`Y3?zf&lliE+8O_k7c-Oe%Uc~i5A{ZlocYp~0fP+uhIp3~mFYdJRJ
zjpSIJMc&q<1ODaT`Jbq5do=z2l_Tl*xPF@B;>X}Zd|2~$A8of2f3bl*UC1|ZVEkSK
zKI)~tThPVOO`)0cPTp99ex1=<+@o_a=8TS+{EP3vp3#K3JnRm`$g>Lc7HtFSXc4~w
z>=DBN9!k)6)r+L(TGoL|{H!+56E8r`3)e9(=W`>vN$b*?RL*{~w2PQ8>L-cA`nJw=
zjJ)Tkp1zBZ+75I-Y6P>Mwo@bSPi`!wKe~QA{o%D^>1SL8J_=lnu^+9&f2EFC-&nJO
zv6K4M^?Mi78uqeluva_BtpV47O)2&PJfqyncrTlK1s?_vtm4Z>azK_fZjQQ`#XMbp
z7T(o9CETIc(oZ92!)?2$H-LXZIeSI*pEdAKJ+_)Ebgy#ibhJ~?YYTa;kG=WL^v1vX
z1v%DFVdLIH9{<n5F}%zCDM#jB{rq>M#_`W@pG-f;ck9n?o``zKe{utSTtAjxL@(Y#
z9qkRo57&Xy8t@)*#OMNjH?O3oU98W@N$DNy9XOB{!3#N$$2`vGpnj^WVXI;fcjOW|
zfvNNCocGLe<^N1p3%fLovnSg2chkVGv|;yrDhJ*QWPtOouBQime0N&ciVq@n#fGRq
zGe}*x(h6-f?7O?Eb%^b6hCJ&H13S>E*fUb&=+7UVOMia<Z2G77&ZPhO?rHFGI{p04
z$@CAwNi%wA>*N@F{0*sLtRHy;&hb&IWp7=9O;z1aeZGNpOx{>e47B5SJ~+R#yhAzt
ze+l+B>=jkmDmG#pJ5Fvd<$LJmt9T<|&uL%R-X3kL=a#bvEMbi;t-)U1Ka`r;18!zd
zTc-aec~{Hp$xF()y}D98b&qQ72YxSQpSTHoU?qM;<r}w<d-Fm1^M~itzkKmR`sXj4
zkLxeM$6q`+oBj#-=)i8<)ZLNRf#W*%gO$_-U%xn=){l&Z{%&1R_0tme;4xPDUf7X2
z*_F+CaZ&2L#mB+t#8DUL`q>#Zv69q@J_a9T`4w{6kFU4Sc`ofbCLcY^K0)21ZGIm)
z%8_&UAZY_=Bv)`1w5=kK`!K#;8@iZ>$p1R%;{LEic+sJ&v1R((JpYZ@Sk;yP)ytRD
zzkBsc`oCYfoc;~p|BpwP(!YFkA$@^N*uuQuK#jM0;4bU$NG15VZ9Kl8^%GqeJD+;L
zbdU9n&yWwmuI>?hoXcM06ayCcSKjEO{$%seY({hTa7)y{*hQXW?XNLkggyAhIl$as
z#S`XAH+O2p_i%rWdJ#H<d)bODt?_;x`{Qz8u2n|B=jG&NF6X<j+g=ItL0zj1J{h0}
z`hR$OBmIXb*W>#4uU$+3?(tQ0&F<7dZlH#-k<@x%Z>q&USG~Zz8KQq|Q|gGqYi&qB
z!#AHfFPzH5h*4tR#&_;jLyI!xPP6qtUi>iazV~+O*g*|OYp)$Sllt)6lh(`fB8T7K
z&i}Y?dtT_p`mNYkW*0y%<UHc<y3K9y26kCt1TVpxc^d&gdO{mMHR9-hd5wBK@7zu4
z?b|86c`N-X^k3LFlj^Y3tQ#FnTXrw9-n6I63F4<&1IxRxXYbz)%+STXrgDxk2Heug
zaR=QCxo_MUyuowA*NRQYwcNe;v+Qdp;nxN7g%99gbM)RTF>h>Zbqr(d1sp%^1~1t@
z{g{(WJu>0};(z2M_twBu?g`9o5%ZC86*w?A_d00M1Rr^C4ju9ma{d<|JWNlnpH7=O
z6B=f1ubyGuqt4xy*=hDt`2S7}r>cS8khj&?C0mXkjI-a6bBrbElJk4OpMS4{?#=iD
zIu6(KM)U>$4|xt=X3%+VQ19d>wLe;2>xwqSL0r&Z{003oyr?6WRyQpFpXJ2hKi{=&
z=b3vV_+TybqZ-*DtlC#>$Nk_sa(H{M8a=lO`tBnRX%n%E8@jr&_4VTSJ45Y7&U;u-
z+fE-Rh7r3lYfde8&@Rr28po!B{y|&%tRkLOeu(`>;9H($E~w|xpJS9K*CKP`UOe+G
zcH^G33*XPP4<DzSZ@eG=N6S1!y9M21e$ht8{~0}nwfJ4|U$JL=1{+TqI#mN_RGvA>
zE6a0BS&A%hU(rA;dL40TO(Vb#zqhcDZDM_EKev=Nj$wb?vnTcvCHV9<&*P&F?=<6A
z*+tE*Uh11f|ME6EfqFp3yDM`bWFg~Judijj4|s$foQS)1*xASD_K;8gY1(_~cGRXT
z=pJ*QXM_K9d}X-I=p22o!invvLz*X{n*G1_pyobwWBS!@QpuTJ(YA9|9IPL}4m}9X
z$;D9*jM`gU59~nCCTICYa+x0`fBXGQspHOB@^y5fJ4~SyVIPK<m8YJeWil?)_0>az
z4~^9TZuS30eAI=db!0y0dvGN@{NIa>W0Z43&jY8AoC-g`prvpDPvFTluz<h#EdDRx
z=Tlp_;}R}$Va=*F=+5r1wJl_@J5Quj#yidEHFb02(6o>74TB^6S<rRs2dM?@IrzTm
zR5#2S0Qfm_{XVi4pL1b$9JWz>(q;*3e2ksGGuq|+z&vQAW<mw=Mcxm33LEdLEAC`Z
zcL-nP1Jqq|+`kNe^x^Zxxbt`A>4FEMUD{IidBr}G=N+SaOaCt}+k2L0?8i7n<1no)
zT#fCj1byCklGvjguZ+#Bq!GI>a=&lK9P_s-)sx@7XsZ~jpK&iAV>XAOi9USHnR3o3
zf-gdDt21Zts}FSHKfZ_$`uO4jd<MvKo3~ZSjts_(UPXVIoGk7Mo4LQVM_>cY;V<%G
zwIElsoWG87)rFp6ysrL9jhuaywlq=;YdSTOH>U+VPZjif2K=b!Sr4{rVUan~8Ftt#
z?k-#BV@&cwzUPTK51f&g0UocT4nhsGc$t3E1zJgKuXb$l3rpwI4t$K|-(rk~4jJ^P
zo$NE?-RP5h86AKfxV6QIPrpZ=HvYH$>^tw-ukH8=5BRR}$nNdda@MpSou&qz-+g@p
zwx1ecRmZPqPu+F+NP71l{h#>DP<x)U<Py%iGaV;uZ+Tq?zlDw8y-3uuM)s7#2O+PW
zFTwXY{Y%Qz7HWgud-v0{o4w!>>V*Vt!C!_4+h2h_)?0Zw*N@}VXZam)Gbe;uT_a>6
zpP@tN{f7MXefgAkYKZe`pkDDt_WAYH_1%n}s}b0>^Oi7X&)`~)5)X3X4Es)M6Ytoc
zwGWPCEYct!OV;)({sI>x=y%$$v$?T?t4vO3IJo`6=lExw4jB-+F>SNp(`Y-#LC`Mm
z&-;150XuLO?*zRI90$$ix2&(=L1E8vP{$rxKb|ev_{>98&Hk?c^8VDkIKm#A{Stc6
zy3tYgQ`i=v`3esf{bys%cssk-xVS51Tm>>+f4ySe%Xn5EBvwn=#T@Ya0KORummj7h
z_g|;Z+TM)bF-F_VXe+LzYw$+kCc|ampuh#6>L1ZI@7s29Ww^@U5q2*5r3O2md)w+Z
z_D7s|wNlrn1pTxDUmM#}*0&nJfd9E`T_#hC{rC#b3tru{c#v_b3oyTFzmm1Lj+(XE
zyvzE}zSBldGwYxaP*<@Z`D)&8#~k#@c_8GVu*ky&OzKqyPxD#yA9e`jfS)lB<kR3A
zaUt(y^U8OtS<5y}kE7#GGR}=@mO494*z@%7X~CA%FiZ_*V-%>L*mvN3jMp=TZ2g2b
zjL-3iN87c{fXREgy-(ko?70H=j3(Z5zwf(U_%o=djNmgg!9GZz9O2LCojo5oq1_D5
ztnX;IzyZ7wZ7TcoIUoPWI~l!;^<dw*OW|wOfzOnF6Z$R9oxPd5PMsv5*g$IMtgVD|
z#X;hg#;D`ow`(blQ4df$=;ssb7~?O;cWoILIbI{bEPXa$bEsp_sa-U1#F&<8SI~p8
zJJvB`l{QoNp?hqaxRj;*Iq|iEvoFJv!=Lw=%>nlytm~oYf?M>R%np;u+rXbVbsXTz
zJ(&9V=|^u;d-4wTxTxLw^mX<+?by-=;w-L~b3$#8jo1^)pkoC#8e>M{?2NHHrh-pH
z=F5}7ZXfGdJG4<Wk&kMbPXnGpUSu@!d21=_m$r^IvStIhO7nIK_=`T`Qy$LeZ`S_`
zFUW(gpBY~{2UrJk{x6<&omw6bFdQQO>*l+k5i@ouO`Rk*j5@38I5q6k#t#vTbN`Lh
zz&Vre2!FiGm>pZ;XJFgHEWQi7L<?~~?bMBH!H-QFO(w_kHLakV?;$H3r~W*`Z5tVX
zWwc*`-MN<YL(c2=>v&c_<Grw><?R-7AfrFHioR(le{b?Q`+aJz?KpjtdZm}rrdiJZ
znSZU+K0R>ZYMP)nthTC7=7_pvz?{#`0;k2N`iI}E;rlH+_oo_cvW?8^rs4UOG1~v~
zm5pCpMj^9fehHU21|LP+e#SlIn()SVc_D`<o?BiIGg&0QR^Ip76@D%5@4;_m_S6k(
zx!p<osN;1A9eme?dua+^18aS^pu6q4PQ762Fo`qIQHysodSqh>xff&n3h}cusf9gV
z-@c2f1%J#I>PFV!YgN2g%vXQ=UIX()xMO``%~_^%(5T>VX$F6=w=d*Rte-p+&&RlO
zc=Poz!(p~&WU$i~IC0-rP7UL)aHcTG+I#fkjkJfFJ9{`6IY{lwDe68?9lMhDKYTY$
z6F2$vxBfmns%&8`0r#P!@Tu%7&Xt8jnXi9r1#_qC^d;awotlYjYsM~IiEXkN_c9)G
z`gk_4tT3KYztZe~VOgPHf$PG);4>@mxmM(GazEp*3~#<y=)XSi7(6dnLmgRdg2vws
z;2*b}GgWJr=@)B$IsM*@A=NHz8^USat$uNS54arzmuEJ$<l<^4PR=%K@L#IoEMD0&
zMEq&%-s7B;4WmnV-Y36st%eO6x>nS2?yn!{GJgbb3y-j5?*(r1HsU+a6m4dBE8t%>
z&wMxdBbQUqX{|AdoIShu=%ps(7&hf*)~vhle-<_Crm5rI#vGnLewBKR_tNIR32Gwa
z`{o=7T)VetjRAJgZ9T(mVP9w*rhEQ+Y_3hvvSslY{u$^P?0+ZmNnSnHpa-xyuY6Db
zvTfneuDZOo7BuyfE8dIm8IMSVW!U{*$QQqBlL;K<@}%ew+oL?Y0sGM0xjXE?E~N=-
zFV3I28EgH1>hFwDk5nINeR^lupS}Czzt0#m-AXtd?>gp@_xffR(iZ66h2GQyKOMl9
z(=&gHy5UE$$zP{N;$iA~Ux~3to~DBSIsF{V=6?Lou-V#nIX)Bt6W=qKGrVN57xRM8
z;{Skq6&^TS4LtaN@g3Nmv+|R?=|0&yi(9b84^bn0@x(>=U_W{ob?V^R7JN<XfUlPM
zAdJQa>H}?k;8OI0N_?`6v335A;4`jIRwL`U>)9l8p$2=m=Mb&vHDmj%d&wCLZ3GYG
z@W*#$7?(a2Z4>*`I%?;x#SgWDIaI(`$O50su51ks905=EDbHtcdse#)zq~I`fQ#T=
z+Hj1n^Rr9W@bj~-?<_n%PM%GC<B|EsQ#WyT)Qap{pf1xSboAVzh5tJ^gVaZR&y|<b
z(hX!L@!{67pXAKV`5}%EUcQCj2xn}_{rMyMzBdMc^rGhn%%MXFLk5R>fU)K4kdyLE
zE&Vj&|GtiK32%%)=X3S9a&Xf;y*qo~`OSYZ4+8!SAFdC9KVknR{;*AXVCvZA)IGHu
z`j)2NxkJgigU$NB<707<+OO7kKmE#w>E$2%JYAq3@=<EB9ewylnx(Gy&3C9>dFu(a
z3}4`x_p#xhN}Kw2P`CCne!%OACmyEW;U4NhFTn#dsgoLC>SyaY?^;bmX(9isca+F8
z@R(!so__Y3ZU7(Wa0Jd6e?2mHZ6)@-T6_p|90Z&Ntohsu{N=bS_(U3n-bJ0=$s?Dd
z9$Qn_P#QaMhM4s0X?W+})B`^^BiC+y{?n+%eB}14=>hWb5IGADp(~t!_1*Nr&;BCq
zr;hZsx4xOC&p%4@=k8G>^}TfBwa>%Px_5FmO)p*GyrwEG66dd+_uNI;j9)0?59Lew
zrVP317=u3icC8-Uw-oy$$GnUK;4k*{<{)UtF40C^^9|5VSuc+C^$mD^uYiB`ckt73
z@IG`qnRX!OyQyJ3I5wI3sm(ro_;MOXe|26AQ`>U{+8w+5BrQFDpL(3P$R}`?nDk53
zuz!?xvp!t;?6;|3b~E)a9H)-+sq}4X<hG7dC;iB^G<o(>8a_b&1?pT69z2bHK&~I;
zhVWY_vWYd<@v7TA%Nn_sHMbg@iT9+Dz7OsXl{p~?q^t0A4p#7v{zJ9Q*GXz+jm}}G
zXCGmWPX8Al&P#2cjp!NTS^g52yRW}W-MPo)8MvIfSl>Jw86F-<UEt!xgSXP)?vrWf
z`Io56yD!bLADBBtO>Atnlf<*^XWw+};XCP_-~X5C;*(FweX*3zF;{x$kEBn4fAs3@
zG=K4hwEzA)_$2Jcws<6M1}D4kzZX2P1-oY#^P->p9S5i(?p$4qj9JIJxe?vjI``VG
z<D3gQ8nA$qOcpZd12$zDYZ5SJxInIvC$tVea!oDfN)tILoJZ!(DE1uUaBN|Jdi1TI
z;wx}E4ex>O#M_iGr@Ds7mvG=hdhx^W0P88_;AF^(QFPfQ_C&icy_8P9^dWUyzeR21
zD^dUX47{<Id>N--emk9c`GYim<Z4=a^nN=1>L;mh{#e>cz34;uYYpxJcj%ezLsQrr
z#;9@nQW`k>6r1a@nEP$ay9U+~&*|&2Q5g4GO)bEJmckVJknr<eJY?{TgKU3W;3oUb
ze146!7iQa$2Yhz~K0o^4oz%O)yubaFe9FgC&#sfeKb87-pWy%V$o?Z~h<Q9f?e`({
z<xQMf?SJ?|I!ykOG5#9^KaalolXT^yAHYiws3CqajUKv`&OZ4Tz8ELiU))SfZ+#2<
zF8d4S%gMWsQw#WP#s8*n;TY>aIUx3)PyN)zUc7iW4Rb!;J_)^`{S;>+C7kmYFa|ur
zpRaiZeKXqUusb)zi=WFrlq>Qg{<95a<`^`;^5moR@bjOfg_}>(+?B`Vu(}kyGBP@m
zdUu~qU9-T*S=WhIK20MBFTyM4G&!AiQmb_A;N>)iEErx~O2hk3Q3Lu8bDcA7>?Jop
z{$ZM+2K25=kJ4*D{pV?vcW0?%IeP3S-!H)XyV7y?7&Dh2M_u@q{wZ=%vJYo1ojP^{
z`G9{Z>xDL<=}YXtl#9#}#~*T#`5Uq_hb4o#fIG*5JW^cZ!|#EY?EBo6SJRP4AEs0A
z=q!FsBYV!VUY(*YBk>f>xuL;fXlcFXTj?0JI;Y@=!98cv=nQ#$uvHFoO|gd_IRYN`
zolNJbhdp)jHge%zWGeYn$Yaxke(~UopE94D(&-o9CBBY0J@!~5;6VST&G_c@?L3%z
z=8mxE98aVB$%l$e?7`<xnHaVR_U85YH8}RwuxIcq-?M9(?m_<y_LwWYm(8CXAO6of
zOZY(UFc%8)ePrP%y8qGCzZ3r{^!)+&zo~PGJ<?P<bmuK{vXH+AJ#G>^xVmyT^Rypb
zcb*!B3*?bGdgoPQ5f7zfw;!b|Z+?~zKmI%&W1gGqXFq$(@uOF%ZHc^n;R&!`N_%N@
z5Wczi!56GwyJDUkefb-y9sR236z7fWnz2j0!5mqNJw_M!>0?aooIl3;9qXKXGhkyM
zQs8142dn5DG+)IB&VTWt%$_-MGo5_vyYT9*G_dyqb(*Qm%G~asT14NiB-bQ!6+K~K
zc7IwteLW2<A}bGFjdgARg&W9$N9pXNH^_f<Je|1nD82Jre=nVR^}}@a!|#H(*FyK-
zedhz}Mc-kKIhu|?re^x$k+kpT>*@T{Ptp|qcd>ro`Szcs`LlP@F0L0p{(hP`b~Vmz
zyO0wD)L(ba>SJx~pWI3O=OnR_tk1016T1&EUs=zB2h{zTBf?(5%ct^jneSKOW%%d~
z=IZs-J+V7YpG6Mu!JmA1Azgj)A@soZIlC`pYA=2p{rkypMV<G4*2aZPFT<b5(viFG
zq}$*A!?g6uCutrV(&g9Q#-;{7AH1H9-h33Y@b+7uU`rz})p7DXUA)OWdI?+8<urZz
zUYcBDzjf?Zn!oxQu@wtx?!qJX*<<O*y*Gnj-uUBxi%dR%{rPh0nc52+<m^H>AB5*-
zkDQ<`{l3&cF%$5IT*zg_G7fS)EW;oAPmUkvz|j5+?0rs0UGg2w$)n_%I)t7!cJg8B
zng-V0OR1MwA^iq>2bibu-vT}x!@PI$)sNEbxrfNBdud?bg*1R4@cGw1Ah*%wbnoMD
zu|B?+<}W?Kzw;Ej#Ovh1x|Ck{&X3Wrj-`FqAEg(*^~2CRCh2#Ey+j8&-6ycSbWQ9@
z^VgrI$rCqH$IO1}VNSCz=q0bz-q3-XuuJWJ^<(O<Uyiu9R$^k@UxsW5J@1!fK|z1_
z?Oq`-k)_<<L2dO}@<PqwOTL?NpMK$8?ESluM@Q1giF>L00J`zvOPtY7rN)k7&T7Zf
zDEjiD2k#>1%nNlh4YQ{innBm&>_feIh&|*U&N7c92iit<rY`iM+u!(UI(6wXb-Z6l
zBlu42L@$~^rk#E8N;>xF9pwK@%)c9H2-!Na|6H0qaSa{gK|1Tc0{ZmJ1IU*3ZT;Bk
zUP2c3uzoDypUD1oY(DmBG4F*fUl*2nK=|{ku$cuvATwV4?1$<02j5K(&~v8ouWp|>
z$Ucbm?aYHT_vj<+|BuqldFV_3%9(C_CR@=Bj=uUCHQ8T*e=epz_O&CxJ;vI#4_UW(
z=^=XGOYqS3)W3L^wdK7u2fRavF0+<gh;?#k_pz|63^Jd`p}`<A&U<gX%3QpbPCs}F
zo>_|Zb%<E%3opE$uA^VOW)2`P=Rf<u(n<DUldRL#O|9wRhkuyvfBIYaFU-UqJ@yIm
zfp~De1a_~mohkR#hm{9hZ~x7|OPzW9KL$N+ut#|my4nHgJI%U0gbW%*R<~lC7{o51
ze$|W4+KLa1{L!=T5;5M#(%`-`=mO{9<JZ#A`NttscCwBizWFk8?v>DocHMX@e7xWO
zy`M9uj;1~5Z>Rmxa)R}CXxCBvvXK|erNdY6uqWM{b}U_qHMF^RhC1-j09;*q>r-US
zH#k>4m!AHezl*J@A}yY~g}!ts?P3n~K_~a1=3vYALD;GE+b?)u*ujN<!`|y>&pUVY
zY}#}4HTe2U>Oudz_5OFUcXJ;;9fw|{&_LN^Jo*6gKz-a?SsmP)x&BTXKXW@xUw9qc
z(G6gI%>MYzGz08A$#Zw_{coq%{RdgIX44(UzU$2ObnK<KQv2vm{5`-GyzV+X$G&lR
z&xzE@+&}i>2hid&a{#|M<mMLQG;e?M{q&E2@e9tC`qIUBzep!(V>4~+zV>oD`u>kN
zYdAozh1PWPH~$5`-8<QD?@h;$#dVy&7^~1chJQ41Ecz(O2gc32=bU8C>tj7T{qA?u
zID5b`bhIPbyZhM3jiUcg9K$}ca3bhAgibreeyFCAcs%yp%AFzBj(O(C{`=_rv^BZ+
z7&gPp=`eeog&X)ZoxPF<kq;yAx98`lUw$X;zWNIC@-+6u1I#UG&Rm<qcCs70f&M@P
z=pi#p*d1@McA{Gkpo8{tCN~D3U3%k_)HSs)4X_q95({+w<KH3oY&XA8r!I7;5%koy
zolC4wFQi3yZ|wZ#)OKip>bh{0eJ3%D#G>fq(uCi!c<7irkFD-zI)3lf;KlL7SFl^-
z?=*ig4Zve_$i~5gSK-$~Y2fhn)H6Pp`mwtx3p%Ip2N)cOMwimzdvB%v*ntkC@65ut
zqkG96ckWT@2cD7H#faM-M?Svz$#>zACux*^?tc6|@O?hk{zIHQ?KyKXU3mLj=^#4K
z(HA~U`yRfQ$wKx`1IR`3HNZN!m;c+5eTVPA#rk|OwK0ZyY<D}*QTsWoY-N2IW{qis
z2kKk<@q=w;e{mok{_p-;ntpOSExvSzT$VeCEv`#PuH9uVdOhau<e`(`5x5Usi*-Bn
zLe6Ao(2K{eFupr)lS}bJ=*H^$%7QLz4z1`%y^ANYmmUv0!5-`Zqv#dd4@TH8j&TOC
zlXI3M*Y3xD^YEh&(%Hu!rMu{TH$MJRtlgvF>?yXC5pXnz3{kdDvkw|SafjIT-RZz>
zd;<=%w?J1|y!bH9;5WJtowB8GHtoB3i+qMRusLnOerin|YG-3>n1+W2*jrDN&#!mS
zY2rxQiQPOxji~0d^JUIAK1UBbbS2GEV|*4{#`xh2$iF+0_b*__FYP3BaXlE=dyX||
zf9U#i=U*UBWs!Z*sn|zav)wcDJ?MgC7oK7Z_$>8tc0SGAHGiD&@4(-78a#SE{NOvp
zKrW^yKm0j!?pnaVaPC@q@a-R`6Zc;Y+2<M3HRMI_p_}m3E6kIJX)k9qt}VSgu}dRQ
z8sU3&x65yQoPOtD{~~C3lyj<S>~Zx?o73?t_u-A1G>1%T$Bx;F+;%N%CkANg8?U0<
z_h4&08@jl1X@ND{`K#^PIGj1wuO0C4;*HnS%!QZXt&^<PA7a}*#aRhF#u}!*q>Qr^
zb7ZKu4-#M1%bAKgfpG}4<{;r3Kxg%=y%jr-Ywn$QznKo-d4j%6>?3>p9fwb*Q!hT@
z41!wU$OzYi{dXTRw)3e2-AX-Wj<fhH_{koHk0viXh<(NY@j>Oy_$pq<hX(#1*nbw;
zeIQ+euYUBu{RiagZQ>X3>tWuSH*^3w*)@$Wv2>7g?U8hC=SVtB9M^M`{b?7zKT{(;
z<YVbhJ=@7C+D?2EvG=vac$udtaxs}B$^1a%NUAnR(w1h<%E^~R4yxL1+lWc+z;~oO
zt;g=W4jE&dXEk{gDzU4U6R%Uwp4O|991F&4{`&k_x;i_OmWZ?8MIDNffzH%}ul+Xs
zQk%DJ;(Wn;4CI-@KQHoB;j33pJZ&X;1*-AYsv>8Feb;Q=8vWO{G6r%Y)YEtUwodXG
zZzC_(X7X|o13;{G8L_YS@9!$kvK}o?q`Qpa;*P;|0N6+H1@6Gtv89vzHNaN4ksK?;
zb5#&eS4RASxw*{mRzbdvYVs@8wsU5We^|s{@mbTdHPw+*GWzE{skW8%2RnELK4azN
zMJeEq{_*vDm00tKyC%}F&J3qx;C}+R+wnna-i8kv`KM~hkre$CZ(!b$5@Jxz?^a<>
z5@2rV>H)`X`0lg-Cpo}2LI?V9AjYkMJQ#K4rKo01mHbzXp@6*xx;)uGo&M6^sdRg8
zG@TsZo@TZalS%yS#;wixBV_%X*Q=bkWb;~?+sph~WyGk~fY*BHTPuC>^QZtmV?65c
zeP|@sqM?WLLU^HiD>T3dwi3BxOm_`qt!Iq##~Z|1KjnH6JY0Yecj1fMLvEyv<Yrp8
znVf1HXcJ!)bFD;9En<w!V`uIb<2UQb3sZ}&uM!{Ua(px@@z1Me&97%}*ORlOwv!qQ
z@I*DS5#m99Xdr&BiL<&5oOAr;!#mSkN9NLR9Gpql7sk_`vF)jcyiDdasmC|0npkCX
ztVdok`i-1)*rhzntb&Ku(OxY$x9?J7?t-_#K@In7w!!<rUITq<;l*{>&DKMcCi3&x
z_Xf_FUO6<I{t9u&kDr@M*LF{)#YyZQ<YwAPTwk4bV)Dn7k!#KzH(5SB&MuARBMx30
zr|Y;miR0{mv!xR3r{Svto~!u33f~gPQb+#{^dA?t)%Bg*8OuQWb?E;aN9WTc`ae(Z
zkLjr)a-rx44_`B{%i(+TtBG^ZHTA2}4^I2^dg$CtPLZZ<*eZeFvkL81`p!Cra?h}!
zM<w%IpNP0NZG~62;tvYmwsxem%)OfjX3~}YGwC38=7z};)k;37Mq*5B$YWzZJ9GAA
zcn5ZD`sMiU7~9g+&iNGUZ%ZHkrSxO}p2>Qy=X3f)>!;~{xeQyf=MEA3hVEB^J=GZG
zY3RL|IG0_sV`*&1D1InIX*0QM8u0_GC6|hP9{J>m<rQ{goyx#{C2g!jZhPj?F)|hB
zy`DFC)~=6De0o02JI1AI*Dl6U%J}`RPiPx4b=}~*o7l|`<4w4l2m7H7zNpNT=wG;2
z_s_f1zXm?@%(<O0nA1jI)2x4UZ|0Y03XDU1=mT$@wRIHz?YK6;XU*jFZzc~|Gr4;<
z_CtH(AJ%Pai}@uj*T8SW?q}eWzCCa7{9+?>X&Y;61M@KY2X^f=amK*@N*kg!JZWNo
z*6{MXV{)wP$qU~|ZlOkU2TAkBo^Iv_`PZ2@<;ZIDfh_k8e5Lg57^H*e1NPsJ{$(C5
z&sOa#Y+LkQ?0FqeoUKTkf<EGf%en{p{56rE+`gN7@Y(6=p_U-Hhd$0V;g*-ASH$k{
zU0R!i%X~xfz;gdN>_y-4DIUBZSJtoN5U$PGS2uIsvWd@){mO-Y_Bg~>BTt=Y&L?po
z%<`RA@HS&IW_TTQ$$UqCdd8+5tg!8^9z)P0AA|gv<+7?y-LvGMz;>|>AEzxNlhg(#
zHxBc;iuq)|G2!&GUu(=&AZNwBzADn&TxRy|e#$n5aiw2vu9@BSKh^)xUhJ*JfA(<h
z(t!=M6&=cXT}@xgH2qH<hwF;I=e6iE%9g+jxbck3vow8&luy4*`<1a|XCB2kia9aD
z+2Sx~{R7w|d(m$@$OYF-jFfra<ZpRQT)2;HL~gI=ziR$-T#i8;NC!Wo{{sK3`0xKW
z2A)~&pT5;22X{Tk-hDs&-}$s<yM6?nF$QJ3a<+-}yqWc46TT$tk>jp+(!r}-S(5Wg
z@P9sr3>Pc5AIGr*Km5n|&Cfoxh~0aE_<C%e-PjE}*|TZyh#dQTZbQG<=F^5R>^80z
z#uw+f%2oQU08i#JaBj$(D|1X)s2o}?53;$C&Bt<ljGjl=JrcR%JqHvI!|Zd1*n4;$
zH-@e~OdRia^y)tJ=N@bj+wj|I!f(ZVFycX<5!a(iWO_OD5+}=R0OOHP;j81EcP!!`
z`RF|GynC4QIB_5yJp0%|&4B6SUrRfmCnx?_wPV~!J5FA~PW?5`cAn>a^ANFW)5uQN
zP|oS<@o{#K=@{e{Z3895d4<enEaIr(myl(vWYFYu=VJ^b?3ca9IXkj$z%+gbbDS@^
zAKP`|ZdzbJH}9T~d!xM5k1eVLzlAnze_MuT(#Gx~=B+-rTLT}?3&#-imobzg^Zg$3
zOj(Tlm0x#YgPeR0zZdXe|D&AYjB`dkMISSqUCjaeuJgYZW7x&Mb{;>$nbTj#Htjjs
z^J)9yapvxGF&1s48__8|zpauMu5+$A^q=*uEO#v_`Y(??>eSJ%L1*@1wC5Pcuw_i}
zd+Nvq&L*z1N4gp3g2pS0i#g5-r%zssbGp$(=dmH32|IN+dz)>eJMm)~OO5QK^r`dQ
zG#iKTXYo<N4~#(><{o(pJK_ZATEPqSKP(;?!=(M6Bv(KE?*{jKF5L$g(BZ4M(@yTq
z;5RwN`{PHxhJEiG<2a4o=m;`o5&pmjlDV^yJoC;K{a?&s^Cf&hj~VQ|`j~0U90QhN
z>_S7>!A7tzOgzWF54*t3NpbLX&X|5J`krS`HwRzN;;S|N{B_O}t}q5@$nzuMEo}Dl
z&vDj*PsG?<+C<LGb;!*c=Lm9I9W~Yx_;U978)=#`L>te2E$l}__(Kdqi&1Pz<KSfq
z9+`Rm8uQ@m*fG8yzT(k8zo)q`4kodAO+d%E7>hhQ2n>DLvN|}wX~DmH12F~b@U3yb
zP|e=UJ>U#`Z2Q;WGVq8EHN!zZ2H=^Xy&d!+EyTsnQ`f);^OCX12Rq;q|DR$E`tXXg
zNv<*IH_RTqA0CxA+9&W)3t#&oa)9(OmiFj-dg)hr7hhlO`r1H7SB*hC&)C7Q^52E9
z2~8mzX0VkwFXqHQW7@&_|Mc=0kQ4OnrG0-4JV=v4c*;53;~Il);s0ap&7<qSs=MzO
z;!(C{S(2?GvgRvmzMAKGie@A^8Y0O^!V<C~RmQ@?ifm!mwXtjLx;CzZv1?3l3dST&
zQwSkV(-6`$grO<W07(id0Rn`;%Ri-Lzn|}sWDKj%v)0>IYn^om-Ftt(z0aQaK6|Ss
zERy`8U@z?8H*^o+Ah%`6a@YsalddgVSf)qf<nX0rLjkfuxX^wSkW*2<J-_uH2fvFM
z>t0x@ZPtF|aPQu`dd=H(x07F~$kt@yk&3~TrY7L?CE$0)SsJ}!HG}0&{OSl+_;ze;
zdclUpGV26CH#Cl!rLnOVf}bC9Cw)g)#rP_Pd_Nl-GKJnqvG`4q_)THN8bj#|wB=6e
zFZ@(|;}HBXeJ3dTPGsitDx@cEKHtye`$=(k+MW3G;rM-9=tme5As;Z3g)c@g53NA?
z*U-=E%H{hxtTgqi<ol8MOri7u3JPb@|0*bg^IZ780b5x-%4hxEiee^FqNTHv>2t6h
zTXZXDeuMe0`h^DJud0_-0JQ3dJtmvXEn*qIEI)j#By7h-?8dmnc-QMOlzY~91Nf|J
zWrOeybp~Ryd?Cdh^vK#QUm0GE^>}Q1a<WC^r)~v5A-Z3FTi?-j1LZrRQ#Q$;!Unsw
zc&*>tzJortDfB2zVm3}Ju@~V-F#x{j7WXLIOtz}*S?MCTcrKqcPW>RsY2CRa6FZVx
zBy7Je^3CxlB)9Y%vhidG$sYT?@AI39xuwotQ0yxP+a!vZc!d00<lYwiJIP?l9besp
zenT*<_%C{$Lf>5vwf4!(X-TB!L-tP`wX(7|BB&XbEf|7638Y_z^u1=_NS12pTyt9a
zT`P-RC4En{c9b?^C)8LRF|RwRGuei2l)WGssNV@7Ht5f9X-W4lFY(#$mU2BQ{7#~D
zY&NzrvV0roK=eE6_YsW$D%i4#&r4UhM|5}g%F3#Hm#g#H!Tlv8hvRdxv9TGVm|3)q
z+6LiAza_n=`VnvA-7AmFuk}0njSTKD75m6TY+v<haXIAru*Y;ik>Dqnyn%FAE^;P^
z=Wgk@kbC+K$&L)-(rNsL;7Km31*S@HT<Y#;2fkMdE18wRicN^Kn1pzXrpHAj{GP<?
zL{@Cvc8lK5c`5jKD=UoHlU6)_YHUJ+MI#rs@;VeA4Z(K`hK{vjJ@jHF4ig!l$k`cW
z2Y#YzqeY`yam4Op@gMIL-6%E!{e|Gm1>sX@C9;Q(#-It=p;5&4x1vXcJJs6CW|iHX
zLT!TZ6VK;GJNlgHQ1p=w?1Dd)-c%mJ51lFhw4Ki-CnZ`EbGZ^&u{@7U<{UKsUj%W?
zZSYe(zMb+5ItQWqOU6D<27d`$N8eAxSB+;Sa7J!Bx`mwM|D&1-)yK;xxdXp_BQwL+
z(N}(Xwk|!4=#{0}Wa^2o8Fj1kUDr{wtC?NP^Z$6{Gj7%<Jx@})dYRGXV*x3OH!@$0
zxK;9F=k4IRa~6)A)j95?<j2CYQ>^xpYnHJvZo$OuQix|n(Hm}?&i2vEB$AkBa!0id
z{OBJo4Y?PMtc)YhQo-ju?7xRz56Sd0EYHcdg8UpSEvG)7*U8LmOQG*y2WRD?>E9bl
zJZ=m9y8?*`Y8IzvJBAUXjp59A0J1~5N1d;7=Ou_8$q!sd9Cdk49kq_Yx;(Fr&+%OA
z){I8s0N6F7O*1H6FMFPAMwu_T+(vJzKwwF@al*<Uy=;q@F1R^`dFLOn=I=jm-Um)u
z0y;?Z1`|1>rvAIRoz!y^uO41nKu^S2S1Y|oIQO0aY#u(7MjS-&rK1OO>8Dr@>|W?0
zJ1N03p!alWSC7f)hgfDlXl`3LaluG%r&)&noRbZtC)hS{a0l_xJBZi0m?Sbrw6F%>
zc)fbKD~_{{v$?=0_#Nz=L3T5Md35tQ$<5xP0Y1Bdv$%f5WP_PS7estCjJ|~N4;-?@
zhfY|`6!mG3U8Gk-s#Sjf1#5WWQG0Oj2y}@)qGv?}aq<}Y*TfK8PR`G=s#$V*?D4{A
zFZqrp2lHrKz18J=EtCDvA_h}gkYm@Uv9pK+WrMrS*f=YrAFbdo^HL85%_O3qg|A3x
zAs9Lif(`<JI|!Q4T*8fs<QIWYGsKl=)Xa39n_CZlTpxd6y)|Rl!B3A>`if~TbTIqj
zW;KciSn36?*@K(ty%&G|q(vXzZDGU=bDnvC^HrQnKfB+e>0gvsS7BpId&!@5SpxK)
zhE35|U5xyphc&oJCeA$njmK@Ej(T2t8l~}m1~Au`<XH`Umh<UNU+T@YVqhGsDz#kt
z(C46=bI{Q_^aaU^kGC{%mxVk`!ybwwKAObuMnTsR<O6!EitWO9Kj&xFCpN>Ke_idn
zD!*I(vo*g^b2;1`bkV(F2gZ%W^)>5$-6n9PM`VO%{%L+gP+Gi$J^I|dMNDz72>K47
zC-7eAUcHH<von!}$l8KJJ2}*8b@b~>gwK;$Io0*nb8xREU>7CQv#RLyoSmB;vm#(D
zqPLZ3y*N9=is|c9K_9(y3$s>2zwRPpki}UUR+yf~BYFlLWCOPsdRU@2i0~kpp!t27
z*iGr+(O!SXetYG(>s{;m{%Zf}gW+%htU4d(=pLBWD|B6u;#JG=Yri+pXJI{kCVlA*
z?gLJJ=$RYbTw>vSdn|!oR2hwxmN?c;?;3h)cURN1gn0(scLetvh71gYzq-ok6VBdy
z*q3O2Cyt&TN!W&Ee8xkMi_)hr+uQ%~uMX}aWL#HGnN{W!chB)!1HEqc^>$b_c&YSe
zSp|Gh!TUuS>6QmC6cHOO0AF5cM||OhS3F$T9==Gm^Y>Y=vR;Dj>HC1JmaMyD9dNJU
zLG!w`|Eqhxj{djmhrW&;6KkP~jZwsO;H53dlmP7UEuB@^XyiHQog7wA-;vQa^FRZ!
z6TRk{>9^#)oHKy$V#rZxCZlA08*%Iy&N9aUdnz(54m&&%T!>E7!C?#iU2^DSR7*eg
zU2TolU0Z1#wbi^|YCSbo)>TzuT@_{4*-&det&P@PS`2QotpS`Y^|hJiIC{~QLoM~z
z%J1cZ1GAS|uQ~YN{?C7L@Vk9y@9$7gP~ia?=;p-(|ML70@Bp2wHp8Di(hQYN+`mr}
zx~#g$Lg+K5e(F)DXDzydI_bfBi~srq*xb}+Un3WOW{w`Ndzl%kS;EW#<?MbwIIAzn
zV8&{MMWJu=B^!9|!7oXLb{ihMWR->JH2R}9SC?6LeYNfCpwHdtuub)M+uTqetJfAs
z2JGDFV|HMC#C8JbB>jK(bvDBX>2B|bkRSHKBf$GJmSF!e>venk?SF%hQkH3+y>>Xz
zBXqClf?s;y&2!q~&uk285MuBXI?LRgBK^-F8L@$!OGv4g{0BPw)Lz^B;QbcXKtG}+
zX4j$nVovX|q+{b2LoGwZM2~GnP6Z=(6Jn#FRnFVc%Oi&GiU*SM=hE1tZ2IX=zx<T7
z)l{(e1=ibKZ}#>N?bQAmyK(W1-8_BR9=mYbp1XD#Sbq0+`M?Zty=~>}|J9i>8vt)+
zzhV7~^(IR=c%Ai{?M9CzB4<<^;^wr9?pfk{^+j~_FCO5%4b)z&W6w6QPaEmM<Vy~w
z5SwKqw62~ke#jHeA`Ybg=2m)f1)#^`fHjc*>yG!ym1*y_g3$}1;7qerVu3jUxg3Y?
z_n@Cd_ww=bGSjW3AlI6a>;3HI{O&=!e)hP%{_N9cZ*l*>eFJb<|Ha=hd~h8ZYHxje
z<-fn>@z<=kSb|^s|C-ezV_NCeFF4gdb|blR>Az*T)t7<zs}?;)G;1m}&0}lfTklYp
zdmY1luJff|5PR&4eG~o3Bk;r)_L+K>ON+Mcz>q~Pj^Kx5$I*`{@1ctp0_-7NCzKrd
zHf$sDdpfc`2D$7l%0bSjnHQN=fE;UVuC(EvHaoruEH6H7zy9X4-1mRyZxw#g!0P_L
zYH$DNzgj*pt<D{HvQGOB%o~}1;dGwpe>3t<bp+)4{m>(_2?7TiY<QafuISl~(8ZQv
z`qV~qX6*7|OT2i<A`gyO^7#exoTV-mJ`M!#AaEDNXTzum*am$>L;o@Gdrx`3vuQKP
zspVtW7NFB>u>)@2f5HyVjN5NtU){(54($4l;9uQ)(Z1yVckS8Zb5;ufYX*Y)VY$6t
z*?*mL(ww5T+^_iGKc4d`)a8Xi_rCPsS|7c|79M`cV(7!Zk^ZuQ$i(o*LW{+g@rOr(
z3Ot-c;5_y?zTk7$nURak<8vY4Ac@aL(4$hh#5DT1_0p#=3A|>o7e%#Y*0QtBx?Ahb
z-gwcz@r2~o|MXA%FWwj3OYb2Ae+y1ueiE_p4M)p@JqR0g84v0WzzSim3VD0Y3W{M)
z{95>2%O5=((CD=&^w}2pRd!%#4SoJS<hQ$PED+n(A9;~DJ?Lhrr#yGr^(Kx$ZV3KV
zY{PBX4zbt;Y3KkC{2`vt!QL&c%;Wz4H~+NvqI=1TRoGtw{%;}@zQMn~=H!}eykLB^
zH9^>X)Sx=u$G)%SJ~!eoxLE{}6Mp2BvH3Qm2SZy+ZF6FTC4AwG`DQV9vbBtvoaET}
zP9(iq!^zc)?&EG8vuI>NBDFcu;3a-5eQLG_GeZg)$%>_BCJmhA=VvlICD*#T8vhp&
zpuHE*FY9~zEwKLv*n!*LV!io1dyf6eJ_|<80K7x`z%BeB<)D!N&h7*5HP{ETef;UI
zAA-Es+y%eXSlbjseGWL;2rY=mBaci{KM`ReMbvE!)G~J)y$}88F)JY&n;;@An3+|~
zs)i4e@bfb0WmJGKT#X)m>-h)&m*Bsh?w5Jq(fzMq1ojs|%X9YjkDj)*G0Qb8f>UzN
z*?+Qu)@rTlgEcmD^d#{^<OOu$!T-u)&yuj^g6Y2%ME|Xg;KB#o_`oB+{7y`5F}^%K
z*?@IxCH)FJD=dn-EzOYM$t<lH<U|~{pLBjU^k2+-_4Km5a`E8*68xfj@jS3=-$nEA
z`!ej$T1#o3m7{ND^9JIxIhx1skv?#?F!qmTvwO0<Zr|ktcngc!f1Smq7ZLEMVW(;C
zyAM8OAogG=wP)K3(p;ayG~`<}`yCjD?_Ghspl5sh*}b+E8#;<Uelg4=N<=0kQMZ=O
ze6cEeHO`IpaKDn(|I@!efc-b@xnO^jeShOwd;98fOQMD%99`siTXZg(7wo|7<R3Co
zkFx*OH$bvcIzapH!yI?bQ458iHz6N4W7llt^=9@v3_mvJ+?)kq<0O3Qg!wUZL$n`=
z&9?>l7tZ_9)QLrK?I?IZ5q*+{9x&0pc+$zL{|Wqm0K4Se3cU;V8Ro@jA$zCmO05vS
z)4tzY;&s8lviz{sHv{uJaIjADA0JS5Z#c1qaN-Kucg1`nh`|Yd{ZDbA$i38`&JR;x
z7i#{%><{gzKYb8#AQ&0B4W5WahQuho1-^=Nv&_EzImlHuj(Alv>%a4No359RbM*c^
zKgaLBj_vpwI`7rTQU6@)rAO@TFI{!}t(ed6;XtxLI#B!oOb&ixL5gok7Rol*O#N68
zGd+W<^DLyT5MO}W3vi(soZ-l}@}Xu6rWa$xSc~~08ypUx71{pb@JTGZ-(6K`eYMn(
z!~bsoU*_JB$+AzDb@u;X90+g1A4_sxbnjq)3ibEI?_mEncEyVi*#ndG0Fb_O`@TZ|
z!i8SL6N+zbW?zL1&0o!e{}uC5ENEjSwWieiZNpy+hL$&>L;Uz`^zmt8_v8@hO<9Ue
zkD^X%8#a%Y;*XK+eFpY&263+6oY`-7?U)@K>M(oin%UQG0QzGqIFQbg{1QF?-~P1c
z`diWQPR=dsHpzJVG5h{H@W0IOzVxWsHy?Je+cVd!YjJV~_7$EN-HV0=GkYXHNJdVl
zA=}(6OI|y>ko^>$i!L;~(L=l;x{@CI+o*Tq`(bUR<P4(hg}sCJ-T4uF{UE)HXNT>H
zxe>d6u+8l3yqV<u)gxxtPnbP)*6gwSP4{Hqc!<5?e#HyYRnBLX-MUKKtB=Bqblj?K
zBl`w9FZzMc?Z?mjZqEh#w*@=<{*9aX!w=eTA3SAt^Q@D5qI1bVXZKQ<<>FcJY7jm3
zHX!Sr9}G=69&x;}5(ff)$;b8Rbl>t+3*Xa$?2oZ%@YPUPY%lE_vTx4~+v|(t_A~sV
zpB<jGUmcq<J2huUY{c$AWOfA{Jb0403^;iFlG(G@xj*PY^5C@<JP0Q7v*U}`RvyJ8
zEb+MPnP0O+^V)0ixL{u4b9<3J7hXkQlC!L9=N9byrw#x!u`FsU{K=QC%KoTi`fCEa
z4|aPZ^cq2|P;*M1e!w<x@o;!x9loK@3Vzn3`!}HvG=HL>IYH0i^Sv<DXD`k|1N(Q`
z_ZP<OjiqsW>&PDa&2ex*Y|qXeSjNHCqu_x35Dp%@2rpb+#)I}sG%KEv{1QE{=rG6E
z!i#7`{}X>peh6l_*TAdqYpueKFJixWgFeAU7ROA42f>Txk~-f<`|I`={jQt`yege9
z+f+Jl8*}9aw`_xOXhSp+g`E>j48Rv17mBUxM?55u7)dB|X!f;M+Oxy}Zs7nrc<sO_
zbTDDRIyz;)B_3p_;eYnQ(SdLvUbuP2?9mHmPe2P#g9q)G_D*{!xK`!&>i$ZWiKlOe
z^>%m#^Ro{uucxnp+spPmerir%yS>ddoNkByCF3+JP%y58CN!Vc`M}V({Qr&EIf0T3
zz<rD!+_}j3QEH%1w3Iu){(+qhc4MH~!lzno4|d$+qaF6t?(SPS_$GAlGIa17bg+zr
z>EGc1U-|cN@F~&4IkV3}3y(`KaR0jZ=fK4(Y<d)*2tUuQz;`>G?mOV`sVjE>iFtcu
z@2KOo-#m838mBn7N$fFxXAANU`d7^^w7zWjpznxJYYu^<ckm&ZxJvWu(cg;SDF&#R
zx8UDLP5csbXCCZrv>W|R_7He@bXS`_KGI=N?(VW@S9sx@dxz}1bMV3{9UKuI%&zdl
z3JxwUAs1I@;l^oXBlPgdd2n$XO|XZKM?@dMXHP;aPw<{-Ml$3{o(pfRg^2+>^2X~{
zFvA(EG0xUZ58Hp<zeL|ud=t(wgj16(xHn<zgwa1md%XeKt~pxrW#j`m{|Elwh`*-i
z8}adk57qbkhBKFq9Nm?!TD#U$Z`VZ!!ogsRJv!WGkNp7-UYr>~F2V~=9!ww)z`=2F
zAekt=AX<=axODh;co01Z7m^R6iASIf@rYaC=F!`i-WR@BKF4=riN&{*Z}HZbTk06~
zXg$=n0DnYvfo<aaL{@z(K5c}Xg{c0@%kls@2M#u}$I5Z|1aqzfns+uZuLGI&7KTsj
zi<~^&R%!RI;NWU^on7z!KjYwQQ~f4hSfvB$hBpsS*{_j_zdb3La2p;(3-GF2*N!6}
zSi-}n&=)tPzgFmj$FE&HvP>(IANq`Y<TL1&x}`<V2r*xDcEsWut1JRM#OBd!Ty+_o
z&G5xf^~W!B@lRx+V&IAa>kNsn<~ahd`p#}f*RMw=iXSv%d^7&*8D#xAWZi|^aNy_w
z96Z>!Ob3q)wK`sSVzkqqnLsb>>9cRF(80^H4;FVj{U}<HZn%X9=?Brns(cVGq%W_*
z9}gT`S<83<Q_J`fj*z2IAKz=gy>QSx-Nbo&nk;5#BYCH2i(>9pR0XvSHFfkWVP+z7
z-p##d4yxc>2Tf~st!P`Xb&kZ3b2jR^teJA_$ocqS8%fvs;^SvBAMY$UIPY*!<>=rt
zyl@p>kW3T~Zb}}k^1@h`Jw4uoT-<5jm>w`E6ZVhTtH^{OV<$Nq!N~>gf0Z6&CkhuA
zR%FEe;t$aV3w*qEZprE%K@af!#Qrh+^@%w<duGYbL2C&;9hNx1+oD@)sU0T=<)to!
z*z(r;Qs=X-Wsd`Z)#ZU?+rr<P6So1sM>2mS^zDnxTMu7ohL7@IqWvKJN6lb6-B@O)
znMZiGx!lgRtk6MwwO#522VHfyaB!o)*&ZHhv(N2n|DA5Y{(fP4nIFE5On4bQ$WB<b
zm)^u)`t>pNgzzBwuxc}$7cN-XPi?<4%eZ*nJgrSOaN>~7Elyd=;RBq3Cx<-I&pALZ
zaoRZY{^Y2LHH6}82I~A5w5(annrkJyPI^H75Y;PO{O|k%>|OD@aN~3zJm7=8+W<cH
zaQ@~5eV9)+l-j8k9Gn3MqJ<0OIWIaK)Yui|!7@Lf8=wQpMd857MQGs}XyG~VAb!wt
zcz`FQBVN0WFMcIFNLL6C<XMcIl8G)ZF51rNNt+z(u%%C3wu=MpmUHxod8pHGD9E%R
z<W>MSd=fLrJcp+_%ZrYtw#Wy2&MkP^<$hLpUa+pgo(bZNnezRTf0`+%xQ8$Lzz>;s
zw5HIG)fU=uY~16_Aw7XTaFW?;r&yu~(SrCvIJmz996$%FICu~`5Dp$$p#|wj@q^^T
z^Vo}DBUdP!@!R``oV_4=aCm?gWIKu;ezS@T=;Ak`30B&X1sh`}jiTE-+U*4SzxZ+L
zZ67$zx$qi`BySp#mTr;g0)O^DG={hx^UPYPDU=QCd|=?!e*3}?&gX>=6dzhoELgf=
z19sm&&K)h*6xd<bQE+e!TgTx6TsS;H58{V2&C4?3{uLao%7kk@k_nA=6C8*i9$le@
zC!AcsUcy#*e$O&JNKZICKo61+!owTbkKzm2kS(9OWN+b5B+N{3wzSR;&+f6#fiA20
z=6C7oKrf7$X^R=?wy3clW;t`NyrbE+6>GLZm^-VpL3v;HSN5yR1F_F~^nqTq6zh~P
z=*ylf*A)-0!s)?Yirugu-6<R#ffgJdI1_cu(Ze!NoPiGR2M1S?3Flj@?A(e>5I;O1
zI{_R>CTKl^Y;^V#HskN%0eTQmIDLuj`0D&9@<DP^c#uyu;q-=N=9|dO;Zysq^1%z7
zmoBp8v&Sswd*8wzT~BRUjYW;p-?g9f@W=tpKhyi`@q3)yWB(P;l1;P9>zifokn0Jd
z*Z8Iwa(?K+aN>DE#H)N{1M>b7v~XB>aJVRRxHt?Bj=~R~ZsY(sh+<~)KIWDlLqDEh
zr3J}G^pb2P=?B?M52GWcBbMc3r?Z`(!GCxTT9Axf<_TovyznrB{WNN?OI9xIc6wvy
zFg>4Me1iFc%*dXZA@|yC;Vn(f5~FqxSrCxOys5%U{8?bfwpV?Y4>26&`~<gRnv#3U
z-)laM<Xteb-j5iSZz5;&m?yP~_tkq`G2caU6-#dA-@?NZcsRh?2QBy((qnZWeS!L_
zZEtg#Eg=)m+$Iw)b=H7`+vI}7gLFizeQrcLVi^Zdk1z9taIgrzDzLS4$r*dc=zq)^
z*ci?LhEr#xx}ms(bGC(?aW?xNl#^$nP4yO(S7XIf)9f|0EE$ijEC1eyd~0Tx&czew
zRgM!r(D~hs_;DMA2V#~!%JmZ8@xwM;&uiHPe#Gs<$OSHNAB&vFJqQjCRtg6Nw#2zm
z!M_W>IK}JG>;#94{m{cvWWs6q;oPczz+RM&T(z5*Z3X1Qiml*$2V}xiPCj-cAK_ta
zRmIi^Fm;+)dL0BEZp|U)oW{AlYv<XcDDzKEvFN@oi>_^S`>Z&YV%dUQ@awta7K&%x
z9^;oU92mh_TFz4n-i^or&CHa~w-J7bB^D5d{!1cnwFvynILP}QEx-@L!#QIA;Z@nT
z2rg#&T5JIwaRj+|vI!bk(UHqGW0hS350Z_N3$mFm!56{AXG1mXhyAz=KAsrsbaG)c
z`bRN|;9}^Dy0*M0K4)8t@;NgaVL4Ac%K2{eI{T{L5!>iB6i6MfVAZ}0HpMI*{Jai~
zXWkNLlbwIVXLM$GGxnel@p{EFRMX?mi<75T?*$)tp`Li2;sFQH{aS+mz-@RCEl3s|
z1rNu0oJBTH3Mc4@{E1dOf_^+9Isgy1+l<S4QuF|=QXA)wd=6#4lk%z&)JTLVPe@*I
zE3!xRb&5G}L>Kv?$2>Q$Sk5C4S@!XxoTuje2ysZsHSM{t;KiQb2<*#y4(;<?%ZIs}
ze%MIL{mI7FnPunaZe*|F0e|d1#lHQ3J(_$)B73r5aFeH)=N#+-tra}1;$m4Q<l710
zjw$0@S_|?3-pE=SAb%cXi{b;(f$W48S`Zza$6mUCY}AS(r{seS3c|Jwga(4hqxgc4
zZQvsa861k=F$B;1;)i&zU9r%X77M|D3!s+4Pc;envFkZ2BX~nOGod=R)f~U01zrc_
zXE8s8+&z2j$8T;VX0;mYScfi5N9KvnWEbowCpRj6$D`n0U4nleTnHZy{uO$VEI7*E
zZw&Ucu!BS9TSiZh!7B4BPqUcjeA~zQ?PJ)D``Rj&X+d%knIPGC7CoU{iD)pG{g(bw
zJY98Fq0By0&dCq|BLexegzOmYqE57|+B|zEExfrA+XcG?`~+}5b(PKqyL=p->5~7p
ziGAFbmS)ZKbKo|aI0iWk_IiCt0QHg7CXkzn<8hGd%?sw+mcs$B^|=4{a3Pvl#>2r1
z^aAxRvX|ETvk&A<rs$cV^U0fY<Eb$wrVcKGhHEWkuE#>#ik)2Oq~0;VG}AJn`3>Y+
zR70v5%Q|Rq6LLttmM^wPkm_sLv!wb8ONIAC8apf)`U%YDZ0fEdWR+yxvV0TlIs+m3
zwGN(%N~h;Fu??RL<}Xu=w+_4pAVZx$3k_(VR3P-e6?(rNZax1!*l)vu@Sx@B030lo
z=h`^0<vWIfN5QMynIAK%wy^?gvzbM~8NhmG>qSEADdY%&XN3I>sL!#J(1W{wzOQ*l
zy5G&xL+qPyqWM1&!=v;qk9W0|fynx(eG}%F1w7D;bi4RlwC?C09Bd9Gk56pRhx%9X
zy7bsuJ(7#@jfK{cvwh^>)z6`YGyQ^hx+MD+4%~j@N3G()y<Wx1ZFC^s5d4yhl7+f|
z)ztaoTL-i;qokdja9yr#DoU{$9s`G~ZF5Nqb7_euLDy@7$dU0sUuZybS+m;xk$s!7
zKVpgD1@L~_D^Hu}#C~ck2Q3hJ5;MKmLa2ugNJ-(0igXpW95fwFUBAxQuV;?5-cy`Y
zwH#?xRh&JEbw0n#Z$e+i@S5NiTq!&koCjEX{6m=k@bxWR0Q)UESdoh<(Ca(FK@9zj
z!WW0kzb=cs3N<Cnqu-FuOwb5=1Av!x<W1fQovhKUc7O7!$N>3Vg5Qriv4Fx%+eG~+
zlMih(GcW_V*P^%SwTEvLP|A6FW?)C|9b;dqG2=YWs;t);q)mb3ao`8px31P_HNWL@
z-D^2}0DjTyiP%s9<ZNP~uT}VO$HD&*Zg8}UgH_qM%o90|?$>$POX|edQzNl9n7C;y
zaVB8(DMFrO7p#dQ_s;*<1Z=XHxNXEG^06H`gF$>e@tFtBpPGS9^utOzy=aNlt_Bjn
z3a2h?T?9S~=L<5v@CoLXF^8Ud4E26jA9EkhajwPQ+kmaMf%<067<X|E=)mRnc=UlT
zG%p|p{?|;wVAW!Pg9Yuq=$Lgo{HrkjSC4ZmI1rAs_ObS|Hs;V5p{vMza^lU0{T6-S
z0i6DA`RrqytqJ3NQwBYbc~3amK#j>A{@CX9&{#vQjpjYBhi5lY9~atIM;*;He$8>q
ze*Jm+Vxhm0tLxDf>r}tbK06x+c_%whw7&rzueipczxt%3e;3bQ&GkBepK~9`{muAy
zf=hbrpk&wz?1KOIaDWVO@avH^ciURUOLTFn2_Jzi`Hsee##@**iC-Cltp#o0K@3fF
zAA%noIDp&+|J(5K0zLHQfcMs7djvAiP<8if*(1%l^P?tuOEvK-^mZ`zL*m&53n7mf
zR^&xLAj{Abj+X_ua?{e^<fi?wog~|(3va=WJajeQ<b4(Qke%CteqRLcMc~(?;QvD$
z2;N(;1D{~m>p#T7M)rBL&b`3v8<Fik%wb-Gd|S(2uh~kC_?|Y~1bqkgS2ClQvoUE|
z=G}YLqPx*!`Sh>HXHy(1s=S0bhOrj5v)Q&bS6L|j&wAn&KG13aHsw0(aM8G8b!*Aj
zs9&;P`*R-9okdYE68W^iE*v<zM+T|~lwuujfdlz^{lIZhd%ptz;tKrYg;hK_{uj)v
zi~p_C!0MxLu@~8N2eG1!$;{(J_KDBeIvK#Znoa91ptINlhic5P5qqtr$ij~7B0f80
z;k&xXyKwerbSJajJj^X`=R6&?Mbv5N>|7-H*hpS2xUboQsI%M1d7X%fQQJuUjAXmw
zlfLnZ%#8=<=!wL<9C%<Eez*6~`|oNT=(mplD>^t>kz-3*z^=871Mh!H2dn&jiw>kS
zR`4;$^L;#@g(n4nkSEgZ`8$278w;m?w8UfUlBhRkFBD%}PwiYVa&0|!&06%Z^u&7d
z3!!C&7C<fCR%+S9>3gLfIcasx=1+df4_O~dJ|~3uxj+7%A7|Fo^F;7(qV7n2S7a~A
z1`Nc9+Ze2Q4_psj>gs&t=YuEFgkFmVj>u<WEupjBLVvH~;1(a;CJ%lO2lQe39sJ9@
zp#ArWq6W0J#PR#O=q<K3lJlII_>{b_Sr5L{3fvLkV_{3fJg1LM2|7^mrY*!<IK!&B
zr0c1R3#MO8P<RwEiggx9O`#vUEwYR{L-^jeD%aMNXWxL&wt>fW$ofs_vMBk<*mjEP
zi|=Lkt@6J3-NC*h18>0(?1xw3m+i7b2ZCR`pmn<(biA-a|I4(nj0e&Gy2v2A1KIsf
zbobg&_8r-JM;JZ0N~kqM&nbSsHVU6IlQ>i&`6TRnoj=pu59MDpmv#-ZJB;}x>!}OZ
z{;LOsFLv(+VlYv;1(w#@jV(mav(8p0Cw-82&W@LThs}|(Yo|NYyOubW@-}Yosc%@u
zgW^4k`7X;r`KsFgTkwky;0H$oJeN%TJvsmvw`gF6_8ktu#}sx-J#;8}|4!__%_W*W
zkI&MCJsgUEiCwS!n$C`F#2<8a0eqkysCQr+h&G%L3QdP_rX!-am6>;y^nvnV+l6qB
zG?zMiY6`cJlc!Hc2EFQ1hK6hdbzHvq{yMWaeCh=8zbgENSgr-GrAN>U@^539^QB%I
z>SwfC%OUuWtm1%p&N2`D0S<203Ae$23lG4)9vf~Gbs!P=QsVKreDW-u`CNlekEkzP
z*6+|l+E_a>n=_a2yLA3$^rd>6>Kxh~+~*p8Lv*kKxfVn1;b!KZ2ZS>ZojvnG{^`6$
z5NDr#(QoPvv6b`GTARVa2F?;xEnQ@GLBG|E&g0{AmJ?st)iPlt#8lS+H!^_ufO@s4
zugNiB7Y-a9+|CCpJRteFtQVyVe&042D#^1s@ZpoHy+qdH?`a>k|Ld`9*5Hc^&dIY&
z&JS2i%tE%WA2M%Kexie4^sfD1&-o(%=3EQf$$oQYHl7{`y3etx{mcB1T<{Bn&w)9S
zJ~-=;5oJsCCg(iy7Vx1yGYK^{>^;2#nS&8T4;sz0luhh(ANw9if3cLx8h8TVo;kZ~
z*84bLeVGRGeqR<M2bX2y3j8a)AY3dF-<ks#`|$M@KY1teUN-!?Xze||rykjN#|OZ_
zR`MR2-$I-!pugNgd+1m1M+^qMNlv)=wBTXgR$@=sz=510ce5opr@on-{CZ$jolbV&
zFmN*Kp1wYwp()~@d7L}OkKq5F;!2AsC`azo(<CK}m}Meol9qe&uLF-hd}g_iMFjda
z5xfLgGBGm6sgAK$ao}Wu(+PrKd_at=waL-Is!Wi5zq6{$*~yaaYvQo!@iD~D@8I#B
z_^w*-*uZnyAF@M`h4ODUV7DmNpwCGrNInS%0sZU?IMh6uptJ(V6C2R`+00svDJbTA
zJ@xVQYu`wGvSr~M{Z4x6={`d&Aca}z1+GuX8fe1@eW5;P(exkQ7@~L>a);NlgQY9g
zo5?>S0oxedU_&TYbwuzJyH#94F>J-Pg@-wG%x2C;HgK*d2|cyI-fNAP)5A-$8~zQ8
zr%x?1e~sIF`ZTlug6;Md*i&q=#DvwyIFq=S_&~BwIP<~Z75z&G1auZ6xA5bsFI8W_
z&Cq;gE42#sZ8pMr;c#Lcp~%E7^cQcW$4dw^A2-pXKs}744@4uuDVY}AKk9f}{q!VD
z)^na${}aC_Ktt<^f$9Bl{y*4K=4M8Rrlr~jWVJ7~+|9-5b{Ltkw;Vm25@kNQ^jPbw
zr2i)83)%Zw>ZkHJ6LE+38F+h`$tzgaW8bXBFOmFv2TT7GKD7VpWh}kuSB&gJ|F8FQ
zzsL*m|9WiX^;_t*5E-{D3!v3?*e>f?;l%Odn6(;HQH6gRWA*e?QU4}q*KR=1V$X&{
z_rk4Yq<W8q(67Yxv2r?Z+2)nqD?OOP{O-WSR7VebZ&M+)>*!f8eI<SK>1{zh?g94K
z<#xb<U|fsb-pE<5fK2+qv=ZCPj<b!0^mIx9-qn34PpDdOmrp}aJKh%#;D1N|*k;<}
z5Ny++mQp+Ph0EsOn(y9QA4`7@d~etDo6o2>`X=c#>J_$lu_^dYM1HYV%uQGT=UmI^
zpSv*tyMjI4NN<iv=E6i~V=qDv%f0i}H(a?a7QeT=mS1ajVI(?Lz4hXl2O(c$Epl3M
zQx`jBuXKieqvDR(rJK<=e$=W55{KAA>|tARwr!_oH?gkVJjCEUoMBD!rqc^L-7-pY
zEw8G`3eXG1#AHh4&*anZm|Bx!&NUTfXIOq_s^w<vAcw<wC;A8K+N;-BTuSk&4fr&Q
zd2XVv)|Yr>fck6F>oc7B#!=+g;_jla0eReXRz^AYP+pd0ael0j^Fvj{2Wo1{tf8uu
zbCc!PT2sL}x^ip4f2c1jvO4VR`tl-ct}VBYrs|dJFZT&`*CxlH__wR?AQtUUZ&A&f
z4$Vz<^+I>vRnF|dQse>iWw>@$AwBl-OAE>htcDtkws+lS-R*bTz`NRP*Uop@$lYC>
zW9zhgI@@fZv&9C9*^Ui#+r96($EL>mm+{XY$X8Qsjk`AS81)X&wF8s3LjyZ(D{?rB
zv-C0K5o2qZ&qZ!O4Ib3lfjq8X0nF{hMRpDM+RVg=ec+Gw*azP~YezmXXG`zjYxm9G
zYYV)0cz)LY^p6kNsXsYj2j4&GuD{wRReeL%uU7H)0D8JA))<_g$hj~2U2ujyx|M$V
z#HwSFjS1O1-1)5>_P(?@&stg=Y?PSX!4K@U^QVs4CqDWS`}D^z+l>dV+Jk?2$v%GZ
zoIUWdkMR1EedhW{?dtu1YJYNY*1_#yXYbv<bA3N-`e4CLzIh8dmvCfGB=O-p+v!!s
zIi*<a%mipLom!4UU~izdYh+iy9sS^fUBCKK`@7HmwLSOrllH>1U$U?K<1_Z$m;T<K
zed>$$k57M*=a1RnKmHl}%qKr$r~hQ$)%%F<RP&>ry_<+3`T@UkP+`P_!pJ*>Q|B0g
zZFncw-p;wEIB3Dc|FW}oSOw=udcpf2fAD~P_R|m8KYjTr``3T@y1o3JZ`-Ti`wr_R
zdxhuUd+9~{&bPm6-}>h-+4IjlVxPPDQTvMzFS<R~zU%rv(7iA4`@?U+@Vs(hq3QI~
zBi|a4pK5oO(YG0yoW%9hk-2%^RI7*ICdclvYacsr&p-PQ_VP>LvLF87Rr~P|e_%g(
z{WZ6K{KN0t>#u#+e(>r)+xNcxCHvYx{<VGn=0*F+$qy`FA08CX`>_AM#E=8&51@X!
zq0m4WIqz`Kc8em{8jBuGz`ozXV-7S~mY-ogEj4zOxYQT_=CABK-~5`r{)1QSr$734
z`#Cj-KY!y#?(t_o`GLLh`giR0fBUMv@~tQBt51L09{$9K?N1MpmxcDVHn4oafiHXD
zFB=!W-$G0-oO{^DUTnu#_7r76^Qq<~PE<yIqK&iGvqSH)8yEh>{^iSmYd`$nKif}#
z_^Q46lYh5g{PcBu>u0a?`0u>to__eE{pjT{+bduHTl>o6AGe1uAGb4y?nO5en`G&n
zo6fTMq8t5%1N70BZRDNsL+?!9ZaZ@5vw`k!fe*WR96=5pBo^_P)K>iyao8V#(>K2J
zoW1$lx9zPTzhb}q$-l8)<@tB*O|JdZSD&@lzxBAi{M={ktDpOreg5i)>|@9Gxoh8o
zUDsCrhS*III0(Zhj)o4@-@24~ocF;0$M0^m3xln8otl|1&X3twPrct>y?)Am@^_!G
zH^2I~_SQ>J+b{p^EB4DDe2w*0`^CTgll}a=|6o7)m(Sa4|MVIA&XXUv=N~$6kACc^
zee6SX4(}V;`%T(=a328d!CX5W__rg2l<zFgOaf-F9U(t?{oNh*1!@xhY3|+juhcDm
z|Ma~5_{vfH`Df4BFTQxye);UD?U!Hu8~f!yf6m@wz4`UOu{WN-X+QkZb^9(l?<+UY
z+2`rIaOKno>_hkMaWQ%A`|9-te+WFFGeQ~ceLeDLm^j1xf&JXhdi%_~+wF<TyX`CQ
z8@87gC+sz9N8g}^`sdukFaGMo_SRotu(uxjnEm33tM>E1yJ~NI@rwQX=P%iJ9{z|u
z2cB+T_@JHn<M-M8`^Ic+>~3@%vR-@-?`;<C>H5GP4eVK*)98lY-cOy+N#yQFsXzD>
z^$DMU4|QAj_S-kW!OMr<Yd_RI{Mo$yoU^}g{^e17^OGm+XP^48{rJ<T?bT16u@^si
z%AUP^%s%^P3-%%E({{i29_#3Bv#RDAr(;*I@9<B4KNR^NOYFB0{vSft-A6seDb-F;
zNA(HnBtAP#eFU}DUtYO~@7y<TKR9x){fL<PPpAp|$@%;2b?)W6A3b7U`sh*n?70ux
zmE&{v$NR@^1ehD%)nxhT$~1K5GVYhpaQUHgb(STPd{8>Ia(7W@@m_q}gIxavdhaax
z*^iQ+f1v*^yU9H~1|I%_Sk&{>DZNPT-b>W7z5-3WdhCzvyC?VA^B<n4{PY8Mj6Nr`
z?;E$ik-M#yYv*unPa(aO(s#JJ<4wq4)s_XIcXfs?7QQbbhT2bDb_QO%Pc}MdjX#9$
zIYYg`UvLi}2M?cy4;~rmv@gI5Pf;uMEcfyJ``>LZ9C(jCcksRT*wU0;gvQ>tZ`|&l
z+{L^*`qEJ+<-rEnjx7?2ALOo${M9+FVCDYU_XOy!1bd^8>rdn7?Z*zB2M40T`?!Y_
z;Nc_e#btQ$6X4>npo!1G7k>>t9(nIhy9rJ{aqm5LVS31x_6*wa_&rvGUiPB@lkuCj
z=hE+q+-o>B2%CZ354sBi@8b6;U{8kUO6e;v`0oY(??d0t;FpY{gZFR`i{uDD1U>#4
zwRIn%cH%s>6K7Z-rhejdFTNVJuH*gK8-wq%ww<k3*2PS`X8N^a14Uy$ZUyd8dSq?c
zPA^>W9t6#WL37c>(2|ii`NZT~&@UtOr??m1n`I9sxrZTqq#<G%@1+m;JooWI?&FWa
z$9>c^jDn*cWMeP)*+vaWc})qu|LQHPjTr;A^bpJgW^$G4%@;zSy<mD71<{jUaED`m
zZ|B+>$l7vfzMX3i1N(c6GF@J78vQ@YeYBQlS#3qO-Bp=Gubey^<z6P(mm#iOML+l~
zzL$Z$ke-)e>BY>z!6r(otFk+(eGd2FH^<PYE0S|q_>k&X9>_gx#m0+=*Szq09echr
z%VY26+7sw}<*k($+{3zu*Olm?EH5($3b0>G(ygdG%gReK(SvE0PELM1c4BmTvTdg(
zIIg<H60l2RDoSiCc5X2E)^+`<TXAb^I5igZe$cfO?zCELot@nKh~NhAQ^0;N*VjEv
zV1M;<jdJ90at6Ksa;bY_ZO==Aj_K)4J?@?8h;6C#<pcIe>bs*`>#!HAi6a--mNfDW
z_!9o)|NY3t`l{wzi+=6tz+J(2yH?<K*GA^ti><9S$<jHGF7j{%S@h55`r&EVCFHNd
zyx2$BCSk-~!@ylAHCSPs<K5O+VcW0^!s%lWLQjLhB>X1gbAG_=M{fo7$lpY4POBK4
zwQ0YRvlD`wYfp1cttr+xuLpp=4&3kH+S_(ulj1K1^E@Pn-tg@E7V<n>(&$&80e$7s
zhYz156uT&dvv+~ig!n_}{_MMIhSZ~e6L~Qoa%?{22Ak0@gE^@-j(!!+r`=k<_ItVZ
z2ywh_%^JWC+wQp&zn>g@60;OI_Z<X2f`K`h*lb8D*H0%7m6c{&@|lUrwS)0-0+Q$h
zP0t~JXie}dj_Cv3%PYw4;kU<E_FFK!J?9=Kx%L?E4}h1u*!N6ge-ZJ-#N&w}C2&54
z`|wYpUq8I+AIGeKgjn#xee7VC0`c!H@OemjD!vPSb`#>6t-#y`aIhKtZ^EzM#F=M3
zu3meU)+V|3IBRs}+L8kW*ne@<nT3&`QN39J@jHL+#g`bRdI9+2pZNo0a1#9(J?upa
z`;f{#utJE>1Sf(gdPWA&OVc-8z3jCQEFSkj-;=Cy)_b__2x|~}yBj`eh9(QScEWb@
z!ko7Z!VeE1zU|Lz#SnGoeiN@Z<0tvW!rKX&<p2%tpyys{x`poG9+J5}a~*=1EfK(6
z1>ddQFL6ZI6O)?Q_cBvt6#g2-w(Jv~LkF!~yB-^}5E-oV+1qq&;#Pj-T6NyT?@s6#
zJS<-yc!<BNH%MSSJU|b@aIPJmN*_mJ_#yOe4P>^0KiAgW3(XeM{0YtT@Y@<`Bfxz(
z*X`uGP4JlHSSi=eg)Wm4>6Z?C!MZjvvrSsM2k_u093U@M8?q^q`VjalfZnGe;5sw~
z_=yQ?u1OI6*;nU^=-Qflu{!(0k3OTm*n0k3=vju(u?0A`LQ8j2Tao}TrNX;8*a)Q+
z#a35eY0c=6_SQzXT6x~oP|caKKynTARl{cr<J?pfIm<YFvmN-Rxx@o1k-@EP4c6D&
zY40BDwK4p(5p?0uK#$$s-A2AXh;zgt^pOh3){e66)O&gGYrLG#sz8Rew>P@a&)&P+
z4$Mv4eea*acH3h!dq#QxZVTZ1!Ptu7)TKtp(}R)Poh)it%J2<Z@2axV!ERf4-=zI1
zwc%$^9JW9E(2{-V@I1dWWm6MF7KE)A%J(DqejIW*9lx#=K5VTkv61d3TbLZSKR+^W
zAOG{?_Q{JMw!b`o!p@yMWJm7%Bb(uWvK6I6be1~>Kcx_wZK03FXiJqXP?P`X``*KG
zl>6+Vzc^u^z4T%G<VTL%M|ges15-9VF^IhrjJ<`;0S|eRg>}fHLG<T->VZy=Fq?U9
z%pUraIs2PGJH&C-!*=yg@3Rjdnzi|vQ5zkmpAxu>0rxwwS&G43JFt&qFCF6h=Y~7%
z8g|Hy4@}snmuBqh2mi><9N1$E)9<$T@ZGM?CW{32cwo;&4^)D?9{B#f=<oyBn<wsW
zvU9sS?Jwxzb^hK#J3cjJ@88{LBLf}Q(Oz%W*m2vrb_zB_9<bLji>DhpemDAfiW;}~
z^BW7;NeB3yIqE>)OYE|rK7P%2Ra<#gvE^U`CPBZM*gGZE`7|PHI^n&Y@I)`aaSt)m
zd+@V*iMMn$mRmD=rMiZ5`=$BJ-pFEZ6SIV%nF3-3)#%SA;U4~J;y3EJk7{H|CGo1V
z65^Kl>3J;0Yj$|)3yAHxof^QrgcvJFf7QWnx_%wMQO?TKd>!<027YcTXT{W;GMSaY
zHDj@3?!<<QM6T+-tGIS8bW_bL<9Bj+or*q8<S`!I5KFFhJGvnTJsiEm<Lu6De0M7{
zxtz~cqPK<n5<Z{9z3jl>j0dI|cqxi_WF)=tB9ZM8tZm5HaK0PHcSD(bQO<YDSek|7
z#dg}kKE$(^(b(@1@WZzF?erj}-zhzR!;z0+l2JMfLto@A^ze<KzG6E(pF&^aTzIw|
z+}6Rf^~A?&s_EBG&LW9k%U)s~)#%j@_O6#0S5N0%)^b-ZJ**-v9UPQlcf6|(JFut4
zChj5T)!S|z*ndgvPYykk8w#^*kUgBbyT$elblPBdi?v{%?BLo3z~4wbtCzUeu9j-M
zryV&%9Ipzwlb*2M{l5yC(12alM8Bk3&To|xW6Z^-%mhcd{C)v;R{{5!$6k5a-}J0>
zOJR@GsU68go@H=eDHU75vm?opc91K={*FaACi45<Ok^%{uB14h{$ugPEHkYM*;83g
zjF0b?ftM<-S6IOOI1loL{meqQr)3a_NlmhR?nC{Hva$2jQ?-8dAbVcmW@%5Hx?=k;
z++<GQ6#X7gF`K;F&FA(MGkcF2SdIP6;iFG}1bt;a%$1GHDz>sVV${UAH)ux1n&tDj
z>T9MyeW$W_(n^>$P(QKc=74t29A-Y(5i4ij?a=-s*0Jxjr4uu6-L=Qk^NH2c&o`}(
z8HHWDnG3Ls+6jNF-Z{p7<XTPpkhN)c7jrushNtP}J;033YgXAcNT0%Z=IPN_oqSs)
zIoL2}_+^wbr!G2~8F%#bPtS96>vHQl_)YbWA>TvnI?-E6Pw!DX^Tdlbb>gB;U3$od
z4ji?*ox7kvVwSbcV&k&~%n(guCSJ?LqSY~H&&!Oqp1nsnuhHY?)$6xhe>P&+s%Ks}
za?FH>1@13AhJDN_r&liX$;ovl6n9wr*sK+kD=DmNvBtr1t7z+?UjcIim{-=nXRl>5
z4>E%O%5~&N8g~vc|97vo?q)t*Ua>XsUI{ZK-Rr6zJ9_Cl=R*7K;w%5@=EC`gMp^yN
zL299kZ0{$&WToU0H0Re#&*MCL;a31}baI9b9X?GT<8C|h&@;Ah`KIkXbH(b3*SC(%
zxVr4j+MUb{o}$ljJ8`@UdZOc(?$X>gX3@<o*y)F!u>Pq7mQqk{dCa2|{BBkXbf9{M
z7;0jKgSViCeCF|H(@Q>^nF0r|Jk0E7W)E~Qx0~9TQf84i?4-AR)1dv`5C4<ddX4ms
z?z9s(zs!E`r`IvFd&m{G4o_P7&@{eDjP;DqT08&qFt=1Qt|OT%oyn}wf#VM{_oalH
z9y!c6U9encUN?@+S{1YupUw;v@|Bf6yR3hD9y;)~s{TDTb@rNd^IO$Bnf=$l+s(Aw
z8kcH~dk&i?x7^KzO=LD+anF=J@SUGBdlG%Nbi(@Qj@rQdao~BxqS>n;deZs^hFS)F
z=vB|E+Q!Y~@mBevXa5=N8fCV7(-8Qq1b%Yg-Ges1bkfy1v;$L4+obC|t=S0?N%(BL
z4zNeeIPRQePCWDPDwtzV|NF&jPq>*DnYF!+4>PMZ1F*+3pi|BDQ;+_gduHi@KWO{T
zT(VSp@24;aq;+Nq_&8t3^)=sP&&m63j(lC)$h37#%v%$W{?Q50Y74(xZYj`gJpA4~
zbAtJ!Cv4y_pTBs+9(eXe+r4zg`t}{R_FWU!w|GB2s^ggVK~HRGaWlD_<(gjVIic%S
z9C%yVXYkiEOCQLymzfLL;^amWeWT;D=uw`9{@j0-eQULjz2FOZ(J^z}YM9yUfd)M}
zg_hFNV5yu9EQOxZnMc_(f6j{9n9~6LY(oyD6*JcwTCdwZZ}ae<W<C^vkM!~e=7t}z
z!GmY5Vf>&KHniF4$G^rt9=4w8gVr*(m)LfI<Hekg32PiZVD*z+f8m0q(BHadbkPnx
z@R*%?gt^qn$iC?V%sA)lS|R<z)AKC``Jn#Q!PG014eoV&x?0<;J_X0mUT}DrI(E^j
z+WV}$XVQHpBH3&8{ZsbU|9IPGj-6qS{UmaL*#;H#K(Ft$@-}AuGEXxug+7@joEbv)
zXs+bKjVCRGTzWP*%wfht3iBzuuYL>tOMGK|8lK4K931|ALx+_xQ=@u#&dsk)sp+(_
zOOM;hr+<J9J7lFTJ#L0(PDLFyIXbC>>$fwz0(n{|ejl2%_Wc)Z_~2<f@x(Xn<fk69
zu8BEjT2Ij{hF<jK`Gcd-QSe<j^Fb2nCmz8ZU-4QH^IHVFbc19<G@lnOoVj*``HZpj
zUuX7cX)X3iiZwI0v0x|HLucf+?;&T^WbrBV%B^KKd{u)TJagI2uq^D`&m0%#TJ-co
z6UEd?G%>Sb+y)j-SV`xwWz-M2d#@*d+&slB$WG>opl@nNHRl8!25x(%7p;%aS0M|k
zS)ItSu*3{_U@!fgtF2~euT=wke(R7`O`f!|gD33D^Do=}^Ve<H!IQu~X`$q#{i3Kv
zrtf_kbgy}$P2-Cek&tG|k{g42ER){oUglP(k-uE+Tcw&;;oxU){mQm^@{pgk);zud
z{W9+Yxvsh4-g4#?H+Iu|5FN1RD8F6lbVXe^x?p_H9{TzZ;I(#Z9htO|eaw=kzNl;d
z7&9!<qsWWqJxkm>bB?>2sWLEcWkUyu_vBdvyc*1&G_ZH|^VhAUwb$y0r>M!Kwj6r&
zqEoY(jnQ}b0oOym`}jlF$@OMVUa--HlXmjqr!1$e2K_|OdwS+)psTBxnc6UQf?2Ws
z$i<6R%FOjyX4LEd(%YIflR~floU&S5qdYe{QgvOcGQq>_-^AQn>Vm_pcIUW7dzcwl
zQEz$G#N()sX&+%8bauX_u-CFns;R-$e1-J(DdhT2W`Qyf1v<)L-tj(UQw8%wG$*Eh
z@{n~OIB7?3JYm_rGZsbftFoR6D<3~jpZ*GJvZky8+aZmdyk-GQKUVcmBb%$?hgo#Z
zoDD4;XRr5IL*J;)96yiDqaRro^`O)>wCz7_v-dx4EzDfk4CSa)&e6q@Z{m0Q7tT1j
z-pK6Mn$7`BDr~d}`g9~BdnFfL-)<h8x^~)s@LkQB3CC_pqYwU1cwGU{*P<J|mB3X1
z9`Vh)_Mb$CHQO#``PNVEwfMXm>}>MZgR{u=9A}fI)%05-_$cpWjy*h~e#tS|X_Mz3
zLT(P*?gK~M%;WK!udq+Yt+IRAYKLd7W#4%lUOel5Bc-UGS{CNxU?&XiTe27a-?tqs
z%>%#!{b}!_QVOjdTj=YUdUX?rn8OU6BYztQr|j5`#~qCp)pt1kmJ1Af&OGRJ_-1BS
zsD?y!z^=9#TJWd7MYN#bFM`)gkXN0P^d6^HDxY39F^L{)MaH*H9kj&KHcPMS<~}Pq
z-%G#fw%yEKZ9v}*+u-R3Ehf8)*~_iuCxhLb_!9WIsB@e%$Ng4;-IB;WgX&$=cIl<J
zZPx;Gj<Fq*(JRvz9(HqhdyhS66Xzeb(PP)Fhk7pQ#@3;68{@OJ*o3kLy{)6xkM0|o
zUqa7xF~8^lb8woi2s^8o8m}Jgf@x@F@#<q%hHaCand5AiXyztFAd@vyM>x=IFjwz@
z?YPPhyZ0Yt2Js%?tFf5mOh+$C`NXD~q2*zQcuF}v!kO7Tj{Z-kHlhUkEIy}_-VPPW
zedetmzJ@$)u+EuzX3{X%y}AWIFrQi2@H>2-*Rh-Ws|IL$FLR}_rI|%kGqBu?xC%PT
z>Dpseyk8CNH4IMJ(EJhGwRqgw!?MMTduMI<<PEo9+06COT&r~CPy(_~Gl@Ld+%u;y
zbIyO>dXcFOz0BKg??pdQC(RsrFLRiL!&c@A`%^2pp1FmR2g|gu#{T|aUa=EbZZa!-
zr=4Suijf`Pfi{YonZFBPYOb;NTlQg9AM>hu=~s>3@?_>Y+jtn;y`rt(2Imi1E}tDc
zdD&u^t6koMFTx!4q88>3p|fRI=fiWUrJ7yQz}dkFW=uCDHxD~qP>U_t2t9V}o@H+Q
z9!HDmz?+AR_O^}@1Jc}`B%8eWq>Y|>kU2)Y-@o75MyIU`-1T7}*TRE~=Po;YE(RY<
zGm2IBvn3*yJjWRGxjFZVEOxc7D>6a#G;zekmd;;s^HZ|g_CUYPae@ytTSIf*HA_9W
zdj?u=wj5>-mF?Q^=r9ZUnp@q3|H8QobV&Iiy#}Dq`n@O6k?1F2ZCp6-{HiqgA-=c;
zpToy`v3<M^{nmT<ikoTGfo>mW9(oUZm{Z-1EdmXfR6F@Qcn~>p=B6FK_Bb-L+sPlz
zc&ZpbY8_+KR_9<pV0Asv4}MDwenwJhhnttZhMASJ2Ws&-_n&_deY1xcd$g1B9_G~e
zG4D=uEyNqDeLa2u6{q*J;kP8_s+9GPlZPUI(LmpXQe^eWeruS&;OvA>?pgEDqp%|+
z&y&jAtbg$oe&@W^pj!)So3L{_sX3$fJTfe;g_-owep&@I%$`Ohai*+sr!C!l27D~w
z*X~3&_Ask@2)PCyVOtf#J4Lk}HhuCuIx5@FJjPrI<a<_QzqR9=?ZkGd?&`N)b4ymk
zW47uX6Vk2g^glRx*MZ#0#-=IaIv!+q{gE3sb?iK`{SYg~ehrUF=G-qeY4C&aAb)EA
z(Nk8%eQREIF}f?4nN&FywalF;V}?t)C6+Ve5Z;%}@0vXbe~*Hn0qQ=goey0(JdZyO
zEbw~__J2A0H4NQ1xO5u1eT4fQwx-$B&SpIK_&03)%yrwj{}?_FbIGt#{X;po3vbIV
z5DsFPjg!%`hZ*$^&hJZO)>S+9K?nA55AbXMoBKzwkLjh398SP@5RJuiO&{iY$D|c9
zV|xJ_+->6rPdRx%eeA5YPA<Yv)Y7KHBWtMn7Y?8U@q_H&qQ*}1)a;}eQZaMvdfcpd
z&0demF11p8oZ&@gc9cRF-g08OWz<~mvif}&_$+$8ZJe2DJMn**%Ym#)M0eB-j9VSD
zN%Q7n@C%0zU*NqxHh%QH)yfCPR*Ysgjb{Bc<A-Q&V;a|MMLraDPht;@S<iv9R*6il
zZbyc8^kEavT7A#3jV~Orw2nQ<Jo<G|6Caaa>}=uTqt`5{q|NgC4%qmSbCz3)9B%G*
zGu#Ur+ATS+j?X1P+Z|3u-j0K9%&OEik_&6Cc=!-9ycwHz7TI6nbWtevbVb<3dC+y!
z&=~yRiQTu~*~Owy4|~ysKh(-T6>$IIIVEoP-pr*Z?bM^s*%LoAo4@v$o6+7dG)b*P
zfP+7!7`p|%l8tP1IK(HByqEuzjQq&2X|h~w!MZNyDnf(3&_G&QGjb%`^=xX}OHUJK
zzlTP9ER%ci;)h;+?q!=khR@bMYOTZpYPxq>73T!<(Lb_>y};oq>!QYiIk40QOE-ug
zBs<&thAahJIviP=kXel1H)P2b-BvoZ-*WJMM~+>v{`tf7twr8uS2L4|++s=|_U}Bn
z;k(F%6m&;AGCY>pPe^2fRiOW7PG6-b%@bD3{xuHlhVQAlxc)s$DQmT6Y~_yq*hct(
z`At1`;E|UcZxs-`$*-(q54)_Cv%S0K4l!3O8vQV0TgaLC1~X@X*^RLo#I@j8>FUSd
zFk8HI!*Yw5lR(U&ocLLJ*O0|#aaJ&n8Pz4ski#CytY>B+GrZ#SYq7)WeZL|T-to>g
z)b4c<Govn{vV*$DVeGpq<Q+5ZkOgsEr}y9mD@JZr@VSP`gI3CZmtdQRCFf%!cUkM)
zS+}QI=#o-=121|_@wYT=q2>v60W!aO{4n#T;;g8Dj$C*tI%u~QQ^PFSvRfyJ_taYn
zv6~WL&qX(Rsn6Eju{3JoqsZfwb&W7fiaabd*Z{AUxAxo2l_!yt=+nV5n>}^Oyy&hL
zXifG>BEG`twdb4+kAoj&gQ_lE^TJ{>OI=N{lZz`dAu%fl-?z$Av2jwcJqz)3vUcvb
zxWYPOCFtvnGGYkWO6WlkH0*5|h5uWK3n4#{=T)PJuqSG*eVRU0kNq>X`Ot6glocXh
z2Nq6QdEX>4%1P!B?#9M{#M-#;{-yKI=PKk3e-=JaN^XhMkHzqAEjlHmcF;=7sJTop
z!iQ?ZZ#(X6>XfoJJNd|S&W38j?ieE8&_(=j@!IF`VUa`l<+a1a{D>tAkJ0!Mxxi4`
z-p|~{QRuE7y$)R<`(!IPxd=aOqAs?eik@NME;OSQdag!~^iem0%{6)2QmfH3?5Scw
z9&Cz4=A<Q-^;lNRn5)OmC&se-{6pB5)c0U3w9T9ZN6mKPsaLQ~Tk&7#n9rpezDjEv
zJ79;Oe8XybnTyGO>wa?Z&vKAqvb}0{E!xnoQRlbG7e09Nc^9WW_v{;%+X0MyyRD4a
zru>aQ?224s7V@{_io4j8JnAp#e^u6kuUump=#<J~&Pz0p5-(kFeq%5`wq`wQ23R1o
z_f~PB+UbIF#i?`1GmyiCW>cA+m(@Pb-uL56Gsg)ZIyDX60tXrJQ~_~m%~Y+NIAx`S
z)69^oMc(;iV-$jiS!}*(Y=b_Vzx1H<o5JGA54Hg}vm?u>@y`YB0(_fHY@&SlAQ$^*
z>DX~6XVU87yYUlF2F7@6u`i%Mez%L5>L@nV(7r>&80IV+x>j7<Q$NTaHCnW{1fJF0
zOXv>0TQ@LEUb7GxP)Sawz{SQD7fI%v#U}jZ5MrRKa#1=mrwkdub&@0#h*kEUx`Dl&
zW4ZZ-mdxyH`JE}?H?L`wS#0Dd@Y&?Y$nVI=DRPe|uYZ9YPNw6Nsy=*c?6l&6IU6|n
zpn1x>Exoi3U4;y%hC2tDUxdt)Onv1SKgYh=KwOzQso-tk$OFWh_B)@y2Oppl*kjP8
zdfr5=+l!A-)Hi6c_$_(p$=&#Eefy8Xm)K>sqgDhz<n+u^KUr*9d^VR@i0C4xwA$vc
zJnG`Ofh&IGs;wk?h#=ma1dn(sJK-DVj&g6?IG^K1)<*Nc6mXoDmO-v1+wwY@xw~`H
z1{P1dSoi*;@C*A8UjPllhgIl=TJEC~JZN5MNh@{)wC)zLmqG_#?){heCW1YqrkA;b
zJ<dPxT0Cz9$F5uV%p$sD4>n(;9lZPyb_KDg+IB0(Pe^8uV$%z;9S6w0oQ6)A$;@@d
zo7w$~F19awR{p>2y;R~L8<?}JxJ4v-ZyWKDEm5(~MpRsBl^@n~uEYbqL=$&ODMUuq
z3|Pq^v)RyfUhX5!TV#Jtj9oIt%e8dYq!zzOy4yqCE0=p{9-Ct=*wE5BH{-RBn2zLh
zHv3-DKS^AMx;WyaXD(lJ*UusznV82t)(u!EdeV#Rs>WAV{HL9G_tN!8U5s_)Fm@Dt
znt+WKhwYk=yq&uEDEtGjvS%H{ueuj5K_`n=NNyy%1fLR`&ceP;U|!(B5p)J}T)BwA
zBro+*^wuB`m4FQtL;Up?KY)*PXeSCAAr<)_m70ehgC6;<Ok#s&{n#kr+f&i${8*hw
zt|3-e-qentKs=XNRT92gG`8y8_2-?=EAJk&;<`5S^+n9H?zExtJ@CwWD?#2W4^`4N
zh0MhN#lG8p^c-<NW<U|ouYi|ZhKU~yO;`+kmYk78TzSUg@Htb+-Q?m2)=eJAmTGdm
zQ`y>!PGv?Vu;(LVv+?P&n4w;aKJMOs9($mHd0qG<(BMNqB<6&CPDDN@qKo`FgQU39
zJKpgQXE&#KnQevrol-~shrCZ2@#|RVA}Asrc|DJe*-f5km&3sZ&Y8tz7h7B3F5+Zq
z#9xV-qQf5hr6IG&h^L~Ph_h-|b!}6tvrkhB>(RUTG>yy#?jx_!JY*xXqkBi-+iG%L
zGuBMbCbfVXEAlg2sqsk4ufdmrSFpcQuw~0f=Ey06J90ji=$op}LHK01m6IDPM6W7W
zlU&yBeA&}ayo7u}r=ib1d^Z!@J}D2Kw{rr2q=ufbtNgI+KS?fzawbjoQ#^E1g8d?0
z)OYMMv(brHwG9&!nQ`>2_)`G(i{zo?lW-?{N;Hy7{xTU@>&e|^5_6G%k^y{i(DA;D
z597;BSVk+njjSwf?jcsuL#$}Tc0unY?Zg;r(8<6UNsUcj4{^KVawmH$u~{`E)!RH`
zNkz?0er6Pw<I6E$6dhR7LJpu|(7Fzs$Jadw-ums}gU?~p9kRv8U&UsD4v1mY!eg<_
zV@)PMkb<1>=Umxpd`)uU4(K!y+K<5ZO(A9)!+obz({E5QC2|)zHOsQ+$rrxiXkjg%
zm&{9phW$gBd&E7a5c7=YEK(}D70q1@#ZU1PSF336woz<n>C1grAGbz)+=-Kyu&1xM
zd|Ehpu`=RGlb4?&UeQLqPbT}xtQ~kMtpRxtj;luSOR$H^$V1dala1Jm@{RI4Ml1(8
zp5DZ3=xp}USFP>v4d>&f5PN7_dcdZZ&RX%vQFJnM<~f5Ji(XG9-V;ZxJ0-trnIB{`
zI+;*p+t6>x__0aI3{QCvH9++7A>JLyeWoEBuH1Nd83)8C6-SGSPo@sG*Q$Dl9c^e%
zZg?zpTM6(Tai|XB51HuHz5^$0^ymdQ=YDwcB)T5|rf=FR$rUTd+I!%f!?$E!9A^N-
z(T8>2<ml#!6_SJNogz*_T)PlIw}|*>05(pl^dIrEB4E$!o3pONH?avvn916JY|F<V
z8?;VxP*wQw8RW&1spInE6Dlt+8^D7u^y6IZvW{Gq35moaHN!QHm`5}Ao|n9BGO>u#
z?mh6~gv<Ap)wkTjK>#_;D(p5-Hg&1gg~esT%h=^T_!!}dUU+n;b<Q4f_EZ&mq=(o^
z{UG@x;!8Eer8?)xF%zH5#&>Qb=QnZnY0KkUW&N|zRhP};uPOi3Jt^Kn?qSo%lCw%?
zf9fWWT46u5ar6=A(=-gt;O8*M9(?8xE`fjIqQq0u#H+~GRPHe=2Va6d70KxOWOSTn
z%M1S7ed%EGHkz9*|1VLnBR?Xr6GTJOEvfKCHuv!lU->#`Etb#ZR+2wb4kw!&!}-U)
zN-Uc*O~j6d$ce;ytI#jdJvon>{t0Rtj$`|FSUfs9F}KRn(Tnx7m#lX8AzQltGC1y~
zhN9HT?n-=L$$P~OBr}C)<uknP;1J(Qx%TUf6zG{gioM-Q4u|*#wu_heMl!x>5w>`B
z4>6x?&a+`BWtCtj6%zlzUQH|lH%;hmd?cMuUQ3QgGI3cZke^34c<cJ%%SK|K#8gXb
z;b;7y-S`3637S`b?Z!j!#3N4Lmy&ZVAnzK<yyo2}scT529|C!e&V!dM8rhP>et3zG
zr8qyInyrKPQ|r*o@59UJbLC3Yuum)4d({*aK<oLnE#xYO9SxM@@5m<<9VD;lb=lb-
z_*L>=wsrCNNpj-&sK}=dVn*HML~2JC(aZRC$n7lr;;qCGQpiiyke8{)-c(IVIeVNz
z+&nRx^OmczC1gU&zB87OEQ*0AJisjZseMo`Tj$YJ@R8ex#~nW?{t!<bG8?<UpZvra
zd6+cp_abz-a=F^`dh#FrM{lwZ(ho&eL~fuOJ6inOgx=q|cn*BD+T?>T;GcpM;*#>C
zQt(;EiHT+dLmobMDsoYiBodjyoI~w|?Ddq2omPe(P#(Ggz3J^C?+4EowDegzvRX1T
zihb}9qdEQT&+v8X$f2Khc7FnN9)tgv)x4V;$Zfac3A>R~ikB+SrnpK}67^$wCC;YJ
zqBlWo7JaLTu?a_C`1>zAn@8vIOBy;|J|`C)l!A{{P}fKtGt|oPTQZQ%iVY`{w@88p
zbBUo<Bje-92^XU?YKP!|Vs_ckoA6x(y>BB2u2^$nKRNdUH?056Lsr?(EJkpsctZ+)
z)X^tiCO^E#Y8zX*XU<f@^ZBY1f(MfEK?@tPVaq$n-&R=#wuEfl9PGse^nV((9FxJd
z6t8ILc4uxS6Qpm`v9r?(D}cMq)jBj0%PsAlcCgA`%7g|*-|5JNy$6qwr`+P~-b{Ec
zP4m@}HHz~@QE%hP#aF>D$t0dzfZgrI7w^Q5&d1kMY;xxQhn-)aDZd6=GYNYzA&c4p
zWOix)jEl!K!t2raZaMI<Y_!IOtIjqmXjZHUIfR{=o{cWYhW0{drPwv~;50gm*~`es
zT<E6=dMt*|vK5;j*z58f1*#!w#_ocjG}l|P##rQRCUEI~Qn4W$pwT4u-xnAavsK(v
zamOlh;hDA6P*9IBJUwUA<inK5$-zd9@?_(mmXTYXcJz{j%*#e^Whk$U52D;aA-NbY
zHfS}rUEAaV7dOy#3&`uFR1YGnTd2b#PFvZ6eLHNa$bmG;2y}&V6Gg*^ovbY+AD>l%
zEC4@VzMo%<3?$B@SXc&rNGY~zBKkU|ZqTY`&N-P>K`f+`Ty0E#r*%!vGxHKX#(ix|
zrG~Dn&!UJK$!8LOD<2~nq51F$<lCZ=L-Ms_@YOQFbrN~!G;Ez(^3IPu{<zzFpMWjU
z5A*bNo*&z(e(WH+;0C#*BTj#pO`HSgjV^xBuxr+8v2Vn4HRP1D(bs9%n6kwxcOS7R
zeEvLYAd-o>E9Q`mZ&chfV<n@<$Xg$#K5Mt-;tPAJnJXn0DIa0v;g{iqY3G+nZ>T<^
zSh}Nk%+Zj1;cRT1ine9nqJ8!hw%a5#yDwU_Vn@UWV$fCc*W$1lobQYe7soy-hN+$=
zN$^(;byyL^Y&`H+68Xto^!nK3w99#K4pvO&4&+FQi^FsxmqW;NNv`Uzw0k$XZDN+v
zHTZK`)I<~lS1EQ)zGOT)Bd6~Ww!tLz8+|Uf-9VjSGJaBV`>^FhKh+}()HEHid};%V
z(IrLFC)gFa<PwI?J>l@ExOfV_q~w5bUO+yx5xaeuoLCM1d<}Y5^ioYuzKr-q0<t(B
zy`}yXUVI$YkX28dbUtG#zCj{#SujMAi&p+tag6ZTWJ@AG?Q$Ub%zbTcvk-F83B+DE
zV=sG<-M&H0e@EWP*VSJU_mPf|<H1i!MQ&Bf4#fV*RUV337u6T$kV7mdPOZ4Q;>AVq
zwQ>#Z_`}@?sH@;R%28%wgSSuM&lcB{%i2wxe~$PWwF1bUTy({?pS}&Q7R^)DN8KGc
zPw-nq4+iCPE67QfqvLakGo~T~Jj8>WCa~G2=B#&i(baIIga1JK8>ly395zBCdoTSU
z{ix?!8+?Q5QOWsva#E>^BU4LNL~Ug>_TfhIJgVpNKu^kh##4(?p%?`Djl53!d_za6
zjl19@;zitZHgH#Rzp;6()CUr?!^X<MCrYXAcQPS|{Z@Ti&)f-Dx1|_o5jpf4<VrsI
z->T`0&i72KAG0>>@o4fb6~v#UXKUrJqDM;5F~v>T9_`?STB3Grhcsd~slYG#m^k%-
zHNmfn6~rUYQ_AaIeAkmltOB1UCIy>P_8hi*0d`^vayF72M>;VS$(<x(yjjH+*49oh
z<CG%iQG~cSnrtqA>M>Jg!|)x^Ney{`ENoxN?QC!@JthCr+cR&)<TH*u^(y}2UYFx`
zat=LN1g|$>S65-{Nq!f%4&ZwdQ<^$$6Q`-!9T=tN?0}0`7b;c>Zz#Vxi7!?L%<`pG
zt5<{_R*yU%JaV3U-s$k)NIX6VJ6`sBJvLL{;u&;z1O6FsViQzQdlyGdmugI6k%!xm
z2XX9a3Uad^x>8+&{OXu&_!}CLkGwgIGbG#M$Y~&3;Ga0`55bwh-nhIgvFU>Uud6c+
zvGY97FtoUK($dt8>!h)*$kOP{cJ_TgGv~~9X3=OgT4p58j7E#4u_bFP*%J#3*}}$1
z$QTJ>BOHW-BaBUHO`T#yC|yDbA$1|4rTtfG`oH~=e=YRub-iaqN`8EdN7gy-_AK{v
zKll3y|1WX&_Rr(wiptuX=uS3*)^I;PiZ&cTj&sPtfmm19d1lwqaGky$J@~Kx!B5`~
z{9^~q)n30sy*d}I-+mBHUw9Yo-y3M5HlrF?a+Kaw7yfDjE@2v7k6ID+5cY=T{IrDz
zyu+DyKIZ-V%ha7<lucvk7I#Lzg&o5u6C0l4y)NIuo)28U6E(nma<l5>64=lXx)gEo
z5O|<3RgCiW5$=xtDYnnQH}~xwfxq+pNcQ0S;ORZT7T6_D4qv_V1wH6fVEs3u16%L%
zU9;5DmjZ_+zA9k<;@~oUH2IdnF*G}CSEJSUej4TXZ$_{E^w&{-`Y3hwHF#yTv=`q4
zH*8Qx?hBlPwr_21uc>+PBz<f!#DOjP74)cQ(LeE-p~-df*G_a>9}`ol$F8a2xEAe0
z*V$S=7ySr+L|h%`{cgL;<Z7_Ulk_RFa5;~EXIHeB7&Uh3PN*OI(Y_6$8<lsp1{GJy
zL0D7BRW6);m2;=|=e*QS6sZ{oCeKFKKmX?tv(=Mj$Zy(yiky*eWAAA8x|i+-F7wbi
z_=FGs8jcjrF8bKnEp*H0-;EAl|16qBe|HgWLIVwm@ot>HOcAcEi`^9Al=p7lh)%*I
z?%jHyys{ouS=%(6rG7tm{_SXT^Hy{StT3{0oZ5o3K-)Y7ZZU3;5^rjJuYHuA^jpLQ
z=ilbv8pRLN=%tR`{FMIJM8JZ5d3$pEz?alwb^7%1RDVD&O~Os6X%XxF9PLz&zSCfH
zAv%8R0h-vGyqlxL`x4OCTgz9$ci^%LXFoz-ND{9K#0&Rr|BWxARdhy2u74aIx^_SG
zZaU}hfNx$!e{vkn8o3p$JGpi~^jOs#RgPYb@&~t~!`Su$IH*H^Y6t633%qvuCL9~S
zMUKo;U(Rk`BbK1|;`jACp9ij>L;s;mFMI)vC@<8H?Z(QJQ5ya)RvhI$8`Z$$<-i+p
z`w-ZHx}XI4zC?{9z7i{H505<hbuc4)OP*f4gpR6;rVxCUVC_R-EPGP@;F2OXFQ!v(
zKSp0AH;!JB-rbRFKLEen4z*Qr?qsl|7CpyN{CJ9*Pn%a)KZzfhkGt1Cjn3cw6by9>
ztaL8)&yT_#shcfwb}jhOG<Z|)Ve-;@#E2tN_k}Cyu+Y@tFRRSaTqDLeZcO7F_CcOb
z)QH{ak;^0aeJRwbu_Ty21x^IxO&nN_Ha`42_=sw_=kUnac;^^CU=H7n)*&MgiC!ax
zU1;mqfA$~n5a1g2AqLh6y%KtxZEC&-wNZ{9*r_`|#y>xT&%J?W=c9lV+MLZaT7)Jw
z^dy>;Q8=M7a{Uy2y9RoJ%Iq>akM~1;Z%@E}cxgYJG`P0Q8Sj8AABEd*@VTMsOXw%i
z7|}y(p|NSNfl<*%7Ql>s)PnmizaNdRpM@u(H;qO-LA)QNcIac>yUCNTJ%%mh+1DE%
z+~+>VK-lwsVr>kZ-N(7R2Woy2CGP)PKTv<k$MiSgcF?*c;6dW-*&%SG53a(QoC>}7
zw;udEvF1J;68dZEgDUlJx-}Je*Y3u(Xc_%Vf^p{2nB@<>7Tx&O|1#&hV5GHZKU$~)
z=fD5WPuTZW`a7qi3bo=HbRS*#sS4Q0zRUpq^Z|1E-1+O&X6UXOlk{`1Gv;Q<>(zNU
zaWwh`>RB}|#<^IMf2WNc8Ry(%<VkszL1MX@fC3tf7<tlu^#FX;AUNW8e)kcu!$Gvn
zXtzuBXQ+9SVlpsvt~rVR@@zE!%Dd4oSo_BPU&2>YztOjtzxq*h{==U{-K~4@%d5n6
zv~1MlUE*EfljtGHsdmm>i7vv)%E?q0PDkr#n2W^g5qP>X7-1CcO9@{c>MWC+<y%*y
z%1QK;<u0`&`IP;+_E*0Q9M&utNnWvrp6K!?pMzc7p+DPC?HZ$o^`|&#7aX^B<q>*c
z-h~*bc0(+%W|dEBEK|#qFL%Z>>{;*KS876%^zip!KdX2CCTgGOEH-cBcju!oIe7cR
zeT9i=>cVaM!dF-qTC=x4hi^g4aPBJW;EoKqrH=lxL+opj=e6a|x!chd`p~C{%kmHF
z_vq!I&s0xV*ncW$f9)q7`?G%qS5T9Il`F(awE*Y8|5@Os=U)9V@Qh6`(gZr$G42B#
zd;K<=jv}?fLGHMT4dIkIe{0Ccc#q#G98F^XLNrhPATF1aP7)7u@E}>V*(r1{gXEPM
zxWc&b$YcDw!%sdHIG}IRzt)yc-TFK_{q{ZV`vQH7jd15^4((BeK0+Pe9XtC5nsM+N
z^`v&wBCof}btCw19$u(PKVF<vr@m^ey&g4RfHMTM)W84}>g>sd)}sC7DRpFO;H_uu
zb1q-I8*P2@Pl2E8$5+KlN$S%w*i_wOg*aR0&*Wxz(K8x5{Z_Dn$G`nl4?DyC^i#tW
z(Vy3rd%ZR>lDv$%o3YcxPH?jvj{U$Gwb!HDcd`=n=i|hLabo-ncOOLa7p}vF&4oH~
z?e+JfDSU7WyPjZgyZCpL^-huF+SJ8a^2`Jnp-o?<LToF`%kg(p)PrSo9kbxJ>MDH{
z`e8MCKNE0hyU_+bHIRww=nclG6Uy+Bul(p&)Zb{PZ`>iy-=I$6o)W#{dGg6EYO5Ny
zR^hw9K|X&P&ea;!I;tNo-F{RV?nvGJZsNE)^k;Y%XmNTOEx%grtzbuW>be-(o&;QT
zlD=^ty!<XSd&b2Cu_i%2DS+SA&C9Wt;dE-t`t;kqI^f6#XLdYrNOEaqdIoLqqw#z4
z+&j_9dp|+rlPB&Tk1o=~>=5Vj;O!}5`3U*6%Gr&htuSuyAs>&ZrKM)DUfC^vB`@wG
zuI(vLqZ3BkM}J~q-z<02E=R9_@*wmO#_<L7S9*lr3v2ijYMTM-_yYV!dyPI<1)T`K
zoyB(Sl~v#`VrVebtlG~`u}0&6obl7stHc+2Sm+znbQG{P|KH`m{Fmt9ReFl_Y_oG`
z(PbVD*w(vR_Ac6R9A)}txdZf%PQ4v<sP{VOZeoXEP;lA4O=86soH4v)ynP7Y$It1T
zl!$LtdK6Rix|{6DAail;S$eC>uUr8Syg}V~nwXS}N@#>;FTKfm(6fR&*hwFA4;<0c
zaHR=iP#R6d4*K*dIM^8c^A512In8`5z8iuoNzkVlK!dTHJO1_&)N9AZdBn~bIA`G^
z*d4vXPWo2;<_7j4GjTBF))+pvaqs6LhnDF@j<M!&SB*2R6YE=O6l%v_<L@7fKBOmH
zI|5%sjX8_2SgXjjXNbMtUrSPVWwHMZ>ueJ<<Pg+YsS{g8vvB(MUr?W?=|LXCmdBzt
zai)IcT+qFB;YDLDZ1FUjbLzoxCvWREG4Zu%0KCvV0G9!OvT$ZAI`qmlIKKJl)%!n-
zp2^Zn-`yYW=^u>x$PYuQ9Cvx)*?4!hnw&QGY1D7clY?{Q$z8<1-Q<GD(D45eoSNMB
z<LH0laBSA>4fwPv_|6*V?j6$75wIJ*#OD5WG)tTG4(OTBUkLGO<Kth1o`3E5RdV?i
zc=OG`OR90u4tLNuePZVz*b4nHIQ#b={eAR^$H80NQ$2Yp_>eW5x{Wwkw113$lbu@7
zp0s_5I=S}`pWxqm=)yC@m&R)QqE&h$3omSOSMWbWP5i_&v1oT+4BK6c;;em$cTEfq
zatBw8$7kdj#hZIK-wM3>?Z5vj#El*BBwt7C6Ji4PX&u@}jPQO_iaav5ag*mAeC-M`
ziJzNy@m2Z);K|IwC4L@38$pk&egMtw8=U10dP;AG`#O2nA@5c~bMy>#-TPmD75(rZ
zzKSyNNl&0dKKkYdK`Wf29u^m=&l+qU4R@MK<j4dzV=u%W+}P<?qrKO^fY&~Zz6U-4
zjpg2RuLm0tcg}GqVK?_zydx6hofm_g?H{Ax`NrelM1%Y$_<+72wqAv=mJe>jS6^oj
zQedndVB{U(!d_hD9u+uQUr$q`su^h>SMz+98u0z-z|B7=-oqgfcc<2<8R*M*So86>
z?qCa-sPkXNx54qOI}e8=E=th*zWCwa2H&lN2_~qg%!l?a_MO?J_64utBbf>6iL>|^
zHn3-EGP?WYFN3ap^88y-cjGdBVED!5Gtud*H_6MdW3${Xzy5vh>7I_}_&rXq?&+s@
zQ1i5i1FQ*u$j+UiH_X|9VQbi51)ejrAACYAl($Sbr+9DVv9JgBv&D<aakyf1SZ(6m
z7*ClzSA_GM2B#YTtK@roFL}PZvvDJ;9KJ;V;XY$<hwIi4LhqpnPbX$b!@+)wc&nyv
z_AJ;2{qsrIufC;9?RV=R|2sMW{#?K=tp#_W;fRCv<D6q0`<uh}6a06Z`w3&zS?c9{
zkFWiZHvB~fzHMiIBHRg$ky8fA?cpvQb<Pl6=wa&aA$0sx=+9H&f~R6>Fz6}rm%UET
zhn{589Kjy#%v8{cvIoRP`vM8>dwCDCd+timLC7PH!vS>BEd>n~aj35dhgV0Z$9;i~
z8~4zOufe&jhkJD;dPO;FOX~b^=N!&aZORz9B8N?=#k42-;NN~7Ex+?w)ID=G>VOZj
z^e1xMDK?*ZKWhQKOLFoQz5*XaTrI)}$yq1B{<CK<6NlmDh&}F|IlU6_5Pctfr_P>U
zya)F~U$c)Mz#e-?#BT4edWTrv!XBA-!t4+3gi{r3evO#mJqo|?N$#Ko{C4a@(7{i$
z2YLJ^$2^{)Hf_>3ut##3`aTDbQsGWvi=OiwJeYTEy2mdBj$r)Q^HFE%Ik3S=FywmF
zT3icS()tYC(exsBS<o?|U7cGwi}w9Fu*V6wWMb~VqiCSGYX+ZHp$;qK@8ub|J)hYn
z>K=TX9#I@jGeC_KE6`&jpFQh+S$b>sODEA@jURoUTz)2MFQEqq+l<pk@3?p1)iOD^
zO8;>b&E3q>dbD?ieyBMRY$K=T{r1Mb6)+uhAddFNK1^K&*E_QW?nWC821&x5C&|OZ
z*v=riq@VeW!(Wauc1JwL6L@m=Wcma>HEg;CpHRkD3fM}SnAw_HjJn)ynL*=Z&)%L&
zlbW%KZG}Bx{T0?;nOo|O&+pzV$<cGnO)ipq_v7>MLd+-5T+|D6z+N5hwv17;Os>5c
zILeumFGZ6p&xf<9u?{g#iG6Smb#O>$9zOWsO4NbNwP)XC{Z;nczgL+-gT!aN6J6rZ
zitIsghIveL9z1#GlVv{X@x?H1o3UN{_zF6;?X`E0zZgxdus6(Y<lqVRp?B65>dXRm
zl!yC}^Kb8kSKPZ4HNhb@Vz+x$X8f@C*h2x{uE5xiU*v3xV6MV!@5#;3SLDpYzO#16
z*B+*@he^hsz$UfJHonzaqHX~5)fpo<Iur7M{lh|-2R!He5_&22oUzNS_u)G2>G<D{
zUt;Vcc3RxK5+3i;jPl*uo9C__xZVzP@~7iFw>Ey^_}aW{6!Rv%Zz@hF9;&%0aW3WV
zVi;e&SeASd^xTfme)|sa(r=BOXCFpfo8w~#+P-yM^8mg@-f$lJq)(f%<ur@fP}&$o
zjw^D8S+s%X#6jXilDLs!Z~Xr$__H)zk@r_T?{EgJw=lN?wm-^)CXM~q=G=GJ-lDfq
zCmz;#8eplG^T5aCl3EKZkug(UdwyaOUt1+cz@K94Y3x`HdLJ>mAB-ZeGmP%scTPBm
zobTnJ{&Boee}gG<{O&VO&e7(bN9)jY#6<R(@tsE<o3^H}&*4+x(LA|NErBt63OgBR
ze~dleL3BLh_-?q_UBs3>#L5AD+}bfUhTky<pNw&xTE(B)siof8Gj<2P{|I-Z<Qg0F
z*z5c7XU46uzA83V>SEK_Pjm4^h*e!`BJ+K9ekGi*++n;q1NKBSVQd@D!V#1MFKQoB
zO}zX^3ay#_t+aEZz8hhWJ@XOPJ^~-pWc)gNAJ&dN8~;3a=i~p=SB;Hh%g=E}^f9pI
zg8S<F@aNEDEW)Lw&?A83zdH;k7xrR28fJdZ(L2Q6pUica=mj1P-|wEvBQ;sOXY1OH
z?IXlLbwAC6&qbq4jEi5mZpSV&c4gs2xX<c4Db!VDv_0&>`1&mC-$C!^yTj=6sDu0A
zh^=R}iwtwk!^PO+2{D{l)#N+1yBb*2^ERH<`E%_-+t5Gs1?!Abh$W1_h+dpIRM{Wz
z=IDFH8EgVONf7Ui@jJoz)??3duSA}DxG}wL6HDApJxUBcN(`enj;+;*StW8-9&A`3
zZ`gZoa-Vz@9B8a+a9$<+NZZwyDscIZ?VQbhVz>ref$y)8A5`Dj&w1>G18^UnO>qYU
zPJFn@doHnoI`-upyd!R|HO6PfX3V`n?5HooX$K#b<9I&2$Dzua9ow__o=tO+p0>G{
zd3oo%35KXrPkH~}zFra?;{aT|{GB@KXH&eByTDms3nli;cLy|Q4@J!xatC=<9h~pc
zDH1oUVf{VZtYaG$G?{g3gc|lx#!ejD+$+xao_`A+Tx0n~`nKErC~MFrv`g>wxc|G*
zulqQM0`V+QJ}iK_O5^m9!RG28OJG!eu83_HiC6My+E@_|*FCR!?$~7*m$<5pcuq~Y
zvKng_ua@C>{Ctl1kRcA~a|zxTGEm{&MfBHqu^-j|>Z{Z87}U1n;v#s-J;=7H^~lq{
z(<DoMVvo)DLHNBj?9?8ZHZNE1c(t%E#H2&dGavkdc{_d{KU4dXhYPS@rvG~f+q-*d
z;%Rb3pG2z%-dA&);%Dd!Fs~H9`|gn>ajby9cpg>i$O>yNk<;u~=4bFd&bo-!r?N;4
zr6+HXslxab=IVQU<l@wIxPJxKq5paJIZG_hum|RgL~AA*t`R5b#i$LC&k$#;_ZY@+
zGt_(yebd|#@(MoS*k~Ah9HUAN)!<H(JYk(P^1U3MhyGAqgm+?JD$KvczW8n>b)w<|
z@sV?gGv+Xww_(PQV>1b37O`Ev)Lxu(N^yp1_At+$+Pf*D4XNzc9`QxKJH#sbA?=ly
zqR|!J<A4sgxx{@c<`w2dj&UD7H|?fk?7(;O*t`27K9ds(4`Ugxj9UZvv3K*lo9}yP
z3XER?XIB^T2ll;+eOCFN2J7xH_9X9*@&1zUT^Z#*$;gs9))>zj$)n;+Rmb<NLL61+
z!hW(J#;;zkz&@})&q_OR4+e>8>gB~1_B3jK5AmSP{A<Pp_Pn$DGCCx9QXc#Ioz<6k
zw*~LJSY{4OFR&lP68@f?Zh3qB3UyqCy(wWc=4)-lJ<u*Z18p<lXXasiPhqz?_N$0}
zm$AhPxJz!)wU3|Ret~13_#R_(FM8!dc-qt{qdam}4d&r`OPqzALRs5j4*p(bJ?=pg
zZc)6hJtUb&ir;&CF%j;!xDOd}ul#DAbxfcUo;vwG_MZFqC(%Z)UL=0L$e1q%dkDYt
zXCuU^CVHA8=T$VeFlL#xyBB57q=Zf6*kAQ%jvsgJ#xd<;+a{cocWks%@9wAx@I6K2
z$6pS8)6Uw<jC}!a^&I0lhfQ>RjLrVEj=abj@SYoE2y<{B%FaQ1Ft$)nWF4RU5og^=
z@f>kXt-A3j<+(7fa}fLJJH|+LRxNCOgzq0=k6ZYG{rfN;e$b+S)eK{!!6a5{^Ugs`
z9Ol5dW%6*5yqhKdru7Hxz<QzQAJkIr0rASb63&FN9be2_AouErHGJK<G>AnFeUH61
zFSzHPyD`c<;`io$YYrtb75U6R_YpUGPUai2toSxbj5HRgx%HfUGVG5&W2`RB5R><T
zC5bzAw2*alqjmCfow?Kxn@67uIV5HLCkN)N8Hh#hfqUV9doI0wG3V%~?2B=W_>d+x
zXE+;Udx1D&j<Ub=Fm9M@#5bjRY?}B`<<6mxv9L}YsxiLrbr=S(C&_)z!E@-1FHYYc
z8=KG`j1k(0`;g~ctZA)l#2fC5wN2h!%YJAd#ti2me`ky=5vNM@oz#AWIBfnjmy0cZ
z0`?)_Q{RXOtYwN|ksNu@+?XIH4^e0IKdj%um*0h(YfyVWe0tvl4&Xb~;+Cxy<x<G0
zVnR89A^IKSp*=b7tAf?NA0vKv`1l<)>p1J(Nj@LuK)h$aljP^P`H1+_56<2LrV$^C
zm4EYjV!HK$nB6_)e6zg&ulITCM)M1HJBZ&55KF~v@&@61#F{?rMFs3x7Edw<Yo1gX
z-_NrSo?(1XUNGPfY&Cq3-^Ekie#C<X&MM0s(!powdjt&b=X>Ab7{*P%NB*Su*<<{~
z-p!5Xczi_s(#z3&hw<2l?<!6$2D~cv^_^j267MjVw?7|na=;1l{`4yFj}X&|qrT%U
z;9NKfaah1I0drBSYKz!(@9EjMSVP~krn9G@jmhok4?bck^MTmF+*BYY>lY=lDp)vZ
z3h)VQ72nBbJ(LDxr8ytJM}G<rHf$aiyNY@Ie8^MerGNqPw=kFBZ`c+XO&s-`hwlmB
z!8`QvPv7$*4l>8u-}SqSv(&-N&%R919E<a|<Cs6i?Zy-N1AX2+>t`Q+$HRGOOY%6@
z8o~FszvtoS&0%35JQH(m@K@L29FBz=b<q5VUB<V+<NuHE=X>?LF;L9k!@&>7--AA}
zAD_~m{f;mX=deA0KkphsoMIilSmk*VV~Ew_%)lA&Glk}0xQc(`<JQsgbJ^`$z<NMG
zO5uaU`k%T;-sj_=<+ts}pPr++L4A1)KhJQ!+J$wQ_N9HeH`=cEEd9F~zC(<z-8fh6
zRQn2kM%*#Sq&bst9{wF3|J(hx-gYc8iu<OY`1z0v_}%yMSp)ia{60V9-Z%&U+x3cf
rUC%ChTJ~PeFUASulz2GB@8&#lfNSb~m;T?2iE^6WqZ6O`PSyVdiR=)V

diff --git a/Templates/BaseGame/game/core/rendering/images/default_prefilter_image.asset.taml b/Templates/BaseGame/game/core/rendering/images/default_prefilter_image.asset.taml
deleted file mode 100644
index 5a87d27d0..000000000
--- a/Templates/BaseGame/game/core/rendering/images/default_prefilter_image.asset.taml
+++ /dev/null
@@ -1,8 +0,0 @@
-<ImageAsset
-    canSave="true"
-    canSaveDynamicFields="true"
-    AssetName="default_prefilter_image"
-    imageFile="@assetFile=default_prefilter.dds"
-    UseMips="true"
-    isHDRImage="false"
-    imageType="Albedo" />
diff --git a/Templates/BaseGame/game/core/rendering/scripts/graphicsOptions.tscript b/Templates/BaseGame/game/core/rendering/scripts/graphicsOptions.tscript
index a03745ccb..9284af583 100644
--- a/Templates/BaseGame/game/core/rendering/scripts/graphicsOptions.tscript
+++ b/Templates/BaseGame/game/core/rendering/scripts/graphicsOptions.tscript
@@ -453,7 +453,7 @@ new SimGroup( LightingQualityList )
       class = "GraphicsQualityLevel";
       caseSensitive = true;
       
-      displayName = "High";
+      displayName = "Highest";
       
       key["$pref::maximumNumOfLights"] = -1;
       key["$pref::useLightFade"] = false;
@@ -821,6 +821,11 @@ function _makePrettyResString( %resString, %giveAspectRation )
    %width = getWord( %resString, $WORD::RES_X );
    %height = getWord( %resString, $WORD::RES_Y );
    
+   //If it's an x, it means we've got the human-readable 'x' in the middle
+   //so skip it
+   if(%height $= "x")
+      %height = getWord( %resString, 2 ); 
+   
    %aspect = %width / %height;
    %aspect = mRound( %aspect * 100 ) * 0.01;            
    
diff --git a/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript b/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
index 8851d1990..2dd1d7f10 100644
--- a/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
+++ b/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
@@ -46,6 +46,9 @@
 //headbob
 //FOV
 
+$yesNoList = "No\tYes";
+$onOffList = "Off\tOn";
+
 function OptionsMenu::onAdd(%this)
 {
    if(!isObject(%this.optionsCategories))
@@ -159,6 +162,7 @@ function OptionsMenu::apply(%this)
    %hasVideoChanges = false;
    %hasPostFXChanges = false;
    %hasAudioChanges = false;
+   %hasGraphicsChanges = false;
    for(%i=0; %i < %this.unappliedChanges.count(); %i++)
    {
       %targetVar = %this.unappliedChanges.getKey(%i);
@@ -184,7 +188,10 @@ function OptionsMenu::apply(%this)
       
       if(!%wasKeybind)
       {
-         %currentValue = getVariable(%targetVar);
+         %sanitizedVar = strReplace(%targetVar, "[", "");
+         %sanitizedVar = strReplace(%sanitizedVar, "]", "");
+         %sanitizedVar = strReplace(%sanitizedVar, ",", "_");
+         %currentValue = getVariable(%sanitizedVar);
          if(%currentValue !$= %newValue)
          {
             setVariable(%targetVar, %newValue);
@@ -195,22 +202,6 @@ function OptionsMenu::apply(%this)
             {
                MessageBoxOK( "Change requires restart", "Please restart the game for a display device change to take effect." );
             }
-            else if(startsWith(%targetVar, "$pref::Graphics::"))
-            {
-               //isolate the quality group name, like $pref::Graphics::LightingQuality
-               //we grab LightingQuality
-               %qualityGroupName = getSubStr(%targetVar, 17);
-               if(isObject(%qualityGroupName @ "List"))
-               {
-                  //yep, it's a quality group, so apply it 
-                  (%qualityGroupName @ "List").applySetting(%newValue); 
-               }
-               
-               if(%qualityGroupName $= "TextureQuality")
-               {
-                  reloadTextures();  
-               }
-            }
             else if(startsWith(%targetVar, "$pref::PostFX::"))
             {
                %hasPostFXChanges = true;
@@ -218,11 +209,26 @@ function OptionsMenu::apply(%this)
             else if(startsWith(%targetVar, "$pref::Video::"))
             {
                %hasVideoChanges = true;
+               
+               //if it's the resolution, it's possible we got the human-friendly
+               //version stored off. if so, reprocess into the usable state
+               if(%targetVar $= "$pref::Video::Resolution")
+               {
+                  if(strpos(%newValue, " x ") != -1)
+                  {
+                     %newValue = strreplace(%newValue, " x ", " ");
+                     setVariable(%targetVar, %newValue);
+                  }
+               }
             }
             else if(startsWith(%targetVar, "$pref::SFX::"))
             {
                %hasAudioChanges = true;
             }
+            else if(startsWith(%targetVar, "$pref::Graphics::"))
+            {
+               %hasGraphicsChanges = true;
+            }
          }
       }
    }
@@ -265,6 +271,11 @@ function OptionsMenu::apply(%this)
       updateAudioSettings();
    }
    
+   if(%hasGraphicsChanges)
+   {
+      updateGraphicsSettings();  
+   }
+   
    //Finally, write our prefs to file
    %prefPath = getPrefpath();
    export("$pref::*", %prefPath @ "/clientPrefs." @ $TorqueScriptFileExtension, false);
@@ -282,8 +293,17 @@ function OptionsMenu::resetToDefaults(%this)
 
 function OptionsMenu::refresh(%this)
 {
+   %cat = %this.currentCategory;
    if(%this.currentCategory !$= "")
    {
+      if(!isInt(%this.currentCategory))
+      {
+         %this.currentCategory = getOptionsCategoryIndexByName(%this.currentCategory);  
+      }
+      
+      if(%this.currentCategory == -1)
+         return;
+         
       %category = %this.optionsCategories.getKey(%this.currentCategory);
       %command = %this.optionsCategories.getValue(%this.currentCategory);
       eval(%command);
@@ -299,7 +319,10 @@ function OptionsMenu::getOptionVariableValue(%this, %variableName)
       return strreplace(%value, "\"", "");
    }  
    
-   return getVariable(%variableName);
+   %sanitizedVar = strReplace(%variableName, "[", "");
+   %sanitizedVar = strReplace(%sanitizedVar, "]", "");
+   %sanitizedVar = strReplace(%sanitizedVar, ",", "_");
+   return getVariable(%sanitizedVar);
 }
 
 function OptionsMenuSelectButton::onVisible(%this, %state)
@@ -321,6 +344,8 @@ function populateDisplaySettingsList()
 {
    OptionsMenuSettingsList.clear();
    
+   OptionsMenu.currentCategory = "Display";
+   
    OptionName.setText("");
    OptionDescription.setText("");
    
@@ -378,20 +403,26 @@ function populateDisplaySettingsList()
    if(%mode !$= "Borderless")
    {
       %resolutionList = getScreenResolutionList($pref::Video::deviceId, $pref::Video::deviceMode);
-      OptionsMenuSettingsList.addOptionRow("Resolution", "$pref::Video::Resolution", %resolutionList, false, "",  true, "Resolution of the game window", _makePrettyResString( $pref::Video::mode ));
+      %resolution = OptionsMenu.getOptionVariableValue("$pref::Video::Resolution");
+      if(%resolution $= "")
+         %resolution =  $pref::Video::mode;
+         
+      %resolution = _makePrettyResString(%resolution);
+   
+      OptionsMenuSettingsList.addOptionRow("Resolution", "$pref::Video::Resolution", %resolutionList, false, "",  true, "Resolution of the game window", %resolution);
    }
    
-   OptionsMenuSettingsList.addOptionRow("VSync", "$pref::Video::disableVerticalSync", "No\tYes", false, "",  true, "", convertBoolToYesNo(!$pref::Video::disableVerticalSync));
+   OptionsMenuSettingsList.addOptionBoolRow("VSync", "$pref::Video::disableVerticalSync", $yesNoList, false, "",  true, "");
 
 
    %refreshList = getScreenRefreshList($pref::Video::mode);
-   OptionsMenuSettingsList.addOptionRow("Refresh Rate", "$pref::Video::RefreshRate", %refreshList, false, "",  true, "", $pref::Video::RefreshRate);
+   OptionsMenuSettingsList.addOptionRow("Refresh Rate", "$pref::Video::RefreshRate", %refreshList, false, "",  true, "", OptionsMenu.getOptionVariableValue("$pref::Video::RefreshRate"));
    
    //move to gameplay tab
-   OptionsMenuSettingsList.addSliderRow("Field of View", "", 75, 5, "65 100", "");
+   //OptionsMenuSettingsList.addSliderRow("Field of View", "", 75, 5, "65 100", "");
    
-   OptionsMenuSettingsList.addSliderRow("Brightness", "", 0.5, 0.1, "0 1", "");
-   OptionsMenuSettingsList.addSliderRow("Contrast", "", 0.5, 0.1, "0 1", "");
+   //OptionsMenuSettingsList.addSliderRow("Brightness", "", 0.5, 0.1, "0 1", "");
+   //OptionsMenuSettingsList.addSliderRow("Contrast", "", 0.5, 0.1, "0 1", "");
 }
 
 //
@@ -401,32 +432,76 @@ function populateGraphicsSettingsList()
 {
    OptionsMenuSettingsList.clear();
    
+   OptionsMenu.currentCategory = "Graphics";
+   
    OptionName.setText("");
    OptionDescription.setText("");
    
    %yesNoList = "No\tYes";
    %onOffList = "Off\tOn";
-   %highMedLow = "Low\tMedium\tHigh";
    %anisoFilter = "Off\t4\t8\t16";
    %aaFilter = "Off\t1\t2\t4";
-   OptionsMenuSettingsList.addOptionRow("Lighting Quality", "$pref::Graphics::LightingQuality", getQualityLevels(LightingQualityList), false, "",  true, "Amount and drawdistance of local lights", getCurrentQualityLevel(LightingQualityList));
-   OptionsMenuSettingsList.addOptionRow("Shadow Quality", "$pref::Graphics::ShadowQuality", getQualityLevels(ShadowQualityList), false, "",  true, "Shadow revolution quality", getCurrentQualityLevel(ShadowQualityList));
-   OptionsMenuSettingsList.addOptionRow("Soft Shadow Quality", "$pref::Graphics::SoftShadowQuality", getQualityLevels(SoftShadowList), false, "",  true, "Amount of softening applied to shadowmaps", getCurrentQualityLevel(SoftShadowList));
-   OptionsMenuSettingsList.addOptionRow("Mesh Quality", "$pref::Graphics::MeshQuality", getQualityLevels(MeshQualityGroup), false, "",  true, "Fidelity of rendering of mesh objects", getCurrentQualityLevel(MeshQualityGroup));
-   OptionsMenuSettingsList.addOptionRow("Object Draw Distance", "$pref::Graphics::ObjectDrawDistance", getQualityLevels(MeshDrawDistQualityGroup), false, "",  true, "Dictates if and when static objects fade out in the distance", getCurrentQualityLevel(MeshDrawDistQualityGroup));
-   OptionsMenuSettingsList.addOptionRow("Texture Quality", "$pref::Graphics::TextureQuality", getQualityLevels(TextureQualityGroup), false, "",  true, "Fidelity of textures", getCurrentQualityLevel(TextureQualityGroup));
-   OptionsMenuSettingsList.addOptionRow("Terrain Quality", "$pref::Graphics::TerrainQuality", getQualityLevels(TerrainQualityGroup), false, "",  true, "Quality level of terrain objects", getCurrentQualityLevel(TerrainQualityGroup));
-   OptionsMenuSettingsList.addOptionRow("Decal Lifetime", "$pref::Graphics::DecalLifetime", getQualityLevels(DecalLifetimeGroup), false, "",  true, "How long decals are rendered", getCurrentQualityLevel(DecalLifetimeGroup));
-   OptionsMenuSettingsList.addOptionRow("Ground Cover Density", "$pref::Graphics::GroundCoverDensity", getQualityLevels(GroundCoverDensityGroup), false, "",  true, "Density of ground cover items, such as grass", getCurrentQualityLevel(GroundCoverDensityGroup));
-   OptionsMenuSettingsList.addOptionRow("Shader Quality", "$pref::Graphics::ShaderQuality", getQualityLevels(ShaderQualityGroup), false, "",  true, "Dictates the overall shader quality level, adjusting what features are enabled.", getCurrentQualityLevel(ShaderQualityGroup));
-   OptionsMenuSettingsList.addOptionRow("Anisotropic Filtering", "$pref::Video::defaultAnisotropy", %anisoFilter, false, "",  true, "Amount of Anisotropic Filtering on textures, which dictates their sharpness at a distance", $pref::Video::defaultAnisotropy);
-   OptionsMenuSettingsList.addOptionRow("Anti-Aliasing", "$pref::Video::AA", %aaFilter, false, "",  true, "Amount of Post-Processing Anti-Aliasing applied to rendering", $pref::Video::AA);
-   OptionsMenuSettingsList.addOptionRow("Parallax", "$pref::Video::disableParallaxMapping", %onOffList, false, "",  true, "Whether the surface parallax shader effect is enabled", convertBoolToOnOff(!$pref::Video::disableParallaxMapping));
-   OptionsMenuSettingsList.addOptionRow("Water Reflections", "$pref::Water::disableTrueReflections", %onOffList, false, "",  true, "Whether water reflections are enabled", convertBoolToOnOff(!$pref::Water::disableTrueReflections));
-   OptionsMenuSettingsList.addOptionRow("SSAO", "$pref::PostFX::EnableSSAO", %onOffList, false, "",  true, "Whether Screen-Space Ambient Occlusion is enabled", convertBoolToOnOff($pref::PostFX::EnableSSAO));
-   OptionsMenuSettingsList.addOptionRow("Depth of Field", "$pref::PostFX::EnableDOF", %onOffList, false, "",  true, "Whether the Depth of Field effect is enabled", convertBoolToOnOff($pref::PostFX::EnableDOF));
-   OptionsMenuSettingsList.addOptionRow("Vignette", "$pref::PostFX::EnableVignette", %onOffList, false, "",  true, "Whether the vignette effect is enabled", convertBoolToOnOff($pref::PostFX::EnableVignette));
-   OptionsMenuSettingsList.addOptionRow("Light Rays", "$pref::PostFX::EnableLightRays", %onOffList, false, "",  true, "Whether the light rays effect is enabled", convertBoolToOnOff($pref::PostFX::EnableLightRays));
+   OptionsMenuSettingsList.addOptionQualityLevelRow("Lighting Quality", "$pref::Graphics::LightingQuality", 
+      LightingQualityList, false, "",  true, "Amount and drawdistance of local lights");
+   OptionsMenuSettingsList.addOptionQualityLevelRow("Shadow Quality", "$pref::Graphics::ShadowQuality", 
+      ShadowQualityList, false, "",  true, "Shadow revolution quality");
+   
+   %shadowQuality = OptionsMenu.getOptionVariableValue("$pref::Graphics::ShadowQuality");
+   if(%shadowQuality !$= "None")
+   {
+      OptionsMenuSettingsList.addOptionQualityLevelRow("Soft Shadow Quality", "$pref::Graphics::SoftShadowQuality", 
+         SoftShadowList, false, "",  true, "Amount of softening applied to shadowmaps");
+   }
+   
+   OptionsMenuSettingsList.addOptionQualityLevelRow("Mesh Quality", "$pref::Graphics::MeshQuality", 
+      MeshQualityGroup, false, "",  true, "Fidelity of rendering of mesh objects");
+   OptionsMenuSettingsList.addOptionQualityLevelRow("Object Draw Distance", "$pref::Graphics::ObjectDrawDistance", 
+      MeshDrawDistQualityGroup, false, "",  true, "Dictates if and when static objects fade out in the distance");
+   OptionsMenuSettingsList.addOptionQualityLevelRow("Texture Quality", "$pref::Graphics::TextureQuality", 
+      TextureQualityGroup, false, "",  true, "Fidelity of textures");
+   OptionsMenuSettingsList.addOptionQualityLevelRow("Terrain Quality", "$pref::Graphics::TerrainQuality", 
+      TerrainQualityGroup, false, "",  true, "Quality level of terrain objects");
+   OptionsMenuSettingsList.addOptionQualityLevelRow("Decal Lifetime", "$pref::Graphics::DecalLifetime", 
+      DecalLifetimeGroup, false, "",  true, "How long decals are rendered");
+   OptionsMenuSettingsList.addOptionQualityLevelRow("Ground Cover Density", "$pref::Graphics::GroundCoverDensity", 
+      GroundCoverDensityGroup, false, "",  true, "Density of ground cover items, such as grass");
+   OptionsMenuSettingsList.addOptionQualityLevelRow("Shader Quality", "$pref::Graphics::ShaderQuality", 
+      ShaderQualityGroup, false, "",  true, "Dictates the overall shader quality level, adjusting what features are enabled.");
+   OptionsMenuSettingsList.addOptionRow("Anisotropic Filtering", "$pref::Video::defaultAnisotropy", %anisoFilter, false, "",  true, "Amount of Anisotropic Filtering on textures, which dictates their sharpness at a distance");
+   OptionsMenuSettingsList.addOptionRow("Anti-Aliasing", "$pref::Video::AA", %aaFilter, false, "",  true, "Amount of Post-Processing Anti-Aliasing applied to rendering");
+   OptionsMenuSettingsList.addOptionBoolRow("Parallax", "$pref::Video::disableParallaxMapping", %onOffList, false, "",  true, "Whether the surface parallax shader effect is enabled");
+   OptionsMenuSettingsList.addOptionBoolRow("Water Reflections", "$pref::Water::disableTrueReflections", %onOffList, false, "",  true, "Whether water reflections are enabled");
+   OptionsMenuSettingsList.addOptionBoolRow("SSAO", "$pref::PostFX::EnableSSAO", %onOffList, false, "",  true, "Whether Screen-Space Ambient Occlusion is enabled");
+   OptionsMenuSettingsList.addOptionBoolRow("Depth of Field", "$pref::PostFX::EnableDOF", %onOffList, false, "",  true, "Whether the Depth of Field effect is enabled");
+   OptionsMenuSettingsList.addOptionBoolRow("Vignette", "$pref::PostFX::EnableVignette", %onOffList, false, "",  true, "Whether the vignette effect is enabled");
+   OptionsMenuSettingsList.addOptionBoolRow("Light Rays", "$pref::PostFX::EnableLightRays", %onOffList, false, "",  true, "Whether the light rays effect is enabled");
+}
+
+function updateGraphicsSettings()
+{
+   if($pref::Graphics::LightingQuality !$= getCurrentQualityLevel(LightingQualityList))
+      LightingQualityList.applySetting($pref::Graphics::LightingQuality);
+   if($pref::Graphics::ShadowQuality !$= getCurrentQualityLevel(ShadowQualityList))
+      ShadowQualityList.applySetting($pref::Graphics::ShadowQuality);
+   if($pref::Graphics::SoftShadowQuality !$= getCurrentQualityLevel(SoftShadowList))
+      SoftShadowList.applySetting($pref::Graphics::SoftShadowQuality);
+      
+   if($pref::Graphics::MeshQuality !$= getCurrentQualityLevel(MeshQualityGroup))
+      MeshQualityGroup.applySetting($pref::Graphics::MeshQuality);
+   if($pref::Graphics::ObjectDrawDistance !$= getCurrentQualityLevel(MeshDrawDistQualityGroup))
+      MeshDrawDistQualityGroup.applySetting($pref::Graphics::ObjectDrawDistance);
+   if($pref::Graphics::TextureQuality !$= getCurrentQualityLevel(TextureQualityGroup))
+   {
+      TextureQualityGroup.applySetting($pref::Graphics::TextureQuality);
+      
+      reloadTextures();
+   }
+   if($pref::Graphics::TerrainQuality !$= getCurrentQualityLevel(TerrainQualityGroup))
+      TerrainQualityGroup.applySetting($pref::Graphics::TerrainQuality);
+   if($pref::Graphics::DecalLifetime !$= getCurrentQualityLevel(DecalLifetimeGroup))
+      DecalLifetimeGroup.applySetting($pref::Graphics::DecalLifetime);
+   if($pref::Graphics::GroundCoverDensity !$= getCurrentQualityLevel(GroundCoverDensityGroup))
+      GroundCoverDensityGroup.applySetting($pref::Graphics::GroundCoverDensity);
 }
 
 function updateDisplaySettings()
@@ -522,6 +597,8 @@ function populateAudioSettingsList()
 {
    OptionsMenuSettingsList.clear();
    
+   OptionsMenu.currentCategory = "Audio";
+   
    OptionName.setText("");
    OptionDescription.setText("");
    
@@ -557,13 +634,13 @@ function populateAudioSettingsList()
       }
    }
    
-   OptionsMenuSettingsList.addOptionRow("Audio Provider", "$pref::SFX::AudioProvider", %audioProviderList, false, "audioProviderChanged", true, "", $currentAudioProvider);
-   OptionsMenuSettingsList.addOptionRow("Audio Device", "$pref::SFX::device", %audioDeviceList, false, "", true, $pref::SFX::device);
+   OptionsMenuSettingsList.addOptionRow("Audio Provider", "$pref::SFX::AudioProvider", %audioProviderList, false, "audioProviderChanged", true, "");
+   OptionsMenuSettingsList.addOptionRow("Audio Device", "$pref::SFX::device", %audioDeviceList, false, "", true);
    
-   OptionsMenuSettingsList.addSliderRow("Master Volume", "$pref::SFX::masterVolume", $pref::SFX::masterVolume, 0.1, "0 1", "");
-   OptionsMenuSettingsList.addSliderRow("GUI Volume", "$pref::SFX::channelVolume[ $GuiAudioType]", $pref::SFX::channelVolume[ $GuiAudioType], 0.1, "0 1", "");
-   OptionsMenuSettingsList.addSliderRow("Effects Volume", "$pref::SFX::channelVolume[ $SimAudioType ]", $pref::SFX::channelVolume[ $SimAudioType ], 0.1, "0 1", "");
-   OptionsMenuSettingsList.addSliderRow("Music Volume", "$pref::SFX::channelVolume[ $MusicAudioType ]", $pref::SFX::channelVolume[ $MusicAudioType ], 0.1, "0 1", "");
+   OptionsMenuSettingsList.addSliderRow("Master Volume", "$pref::SFX::masterVolume", 0.1, "0 1", "");
+   OptionsMenuSettingsList.addSliderRow("GUI Volume", "$pref::SFX::channelVolume[" @ $GuiAudioType @ "]", 0.1, "0 1", "");
+   OptionsMenuSettingsList.addSliderRow("Effects Volume", "$pref::SFX::channelVolume[" @ $SimAudioType @ "]", 0.1, "0 1", "");
+   OptionsMenuSettingsList.addSliderRow("Music Volume", "$pref::SFX::channelVolume[" @ $MusicAudioType @ "]", 0.1, "0 1", "");
 }
 
 function audioProviderChanged()
@@ -613,6 +690,8 @@ function populateKeyboardMouseSettingsList()
 {
    OptionsMenuSettingsList.clear();
    
+   OptionsMenu.currentCategory = "Keyboard & Mouse";
+   
    OptionName.setText("");
    OptionDescription.setText("");
    
@@ -626,6 +705,8 @@ function populateGamepadSettingsList()
 {
    OptionsMenuSettingsList.clear();
    
+   OptionsMenu.currentCategory = "Gamepad";
+   
    OptionName.setText("");
    OptionDescription.setText("");
    
@@ -717,21 +798,57 @@ function OptionsMenuSettingsList::addOptionRow(%this, %label, %targetPrefVar, %o
    
    %option.targetPrefVar = %targetPrefVar; //create a var-option association
    
-   //now some override trickery, if we have a value cached for unapplied changes, swapsies the defaultValue out
-   //with the unapplied, allowing us to change options categories without losing changes
-   %unappliedPrefIndex = OptionsMenu.unappliedChanges.getIndexFromValue(%targetPrefVar);
-   if(%unappliedPrefIndex != -1)
-   {
-      %unappliedValue = OptionsMenu.unappliedChanges.getValue(%unappliedPrefIndex);
-      %defaultValue = %unappliedValue;
-   }
-   
    %option.setListSetting(%label, %optionsList, %wrapOptions, %callback, %enabled, %description, %defaultValue);
 
    %this.add(%option);
 }
 
-function OptionsMenuSettingsList::addSliderRow(%this, %label, %targetPrefVar, %defaultValue, %increment, %range, %callback, %enabled, %description)
+function OptionsMenuSettingsList::addOptionQualityLevelRow(%this, %label, %targetPrefVar, %qualityLevelList, %wrapOptions, %callback, %enabled, %description, %defaultValue)
+{
+   if(%defaultValue $= "")
+   {
+      %unappliedPrefIndex = OptionsMenu.unappliedChanges.getIndexFromKey(%targetPrefVar);
+   if(%unappliedPrefIndex != -1)
+   {
+         %value = OptionsMenu.unappliedChanges.getValue(%unappliedPrefIndex);
+         %defaultValue = strreplace(%value, "\"", "");
+   }
+   
+      if(%defaultValue $= "")
+      {
+         %sanitizedVar = strReplace(%targetPrefVar, "[", "");
+         %sanitizedVar = strReplace(%sanitizedVar, "]", "");
+         %sanitizedVar = strReplace(%sanitizedVar, ",", "_");
+         %defaultValue = getVariable(%sanitizedVar);
+      }
+         
+      if(%defaultValue $= "")
+         %defaultValue = getCurrentQualityLevel(%qualityLevelList);
+   }
+   
+   return %this.addOptionRow(%label, %targetPrefVar, getQualityLevels(%qualityLevelList), 
+      %wrapOptions, %callback, %enabled, %description, %defaultValue);
+}
+
+function OptionsMenuSettingsList::addOptionBoolRow(%this, %label, %targetPrefVar, %qualityLevelList, %wrapOptions, %callback, %enabled, %description, %defaultValue)
+{
+   if(%defaultValue $= "")
+      %defaultValue = OptionsMenu.getOptionVariableValue(%targetPrefVar);
+      
+   if(%qualityLevelList $= $yesNoList && isInt(%defaultValue))
+   {
+      %defaultValue = convertBoolToYesNo(!%defaultValue);
+   }
+   else if(%qualityLevelList $= $onOffList && isInt(%defaultValue))
+   {
+      %defaultValue = convertBoolToOnOff(!%defaultValue);
+   }
+
+   return %this.addOptionRow(%label, %targetPrefVar, %qualityLevelList, 
+      %wrapOptions, %callback, %enabled, %description, %defaultValue);
+}
+
+function OptionsMenuSettingsList::addSliderRow(%this, %label, %targetPrefVar, %increment, %range, %callback, %enabled, %description, %defaultValue)
 {
    if(%enabled $= "")
       %enabled = true;
@@ -752,14 +869,8 @@ function OptionsMenuSettingsList::addSliderRow(%this, %label, %targetPrefVar, %d
    
    %option.targetPrefVar = %targetPrefVar; //create a var-option association
    
-   //now some override trickery, if we have a value cached for unapplied changes, swapsies the defaultValue out
-   //with the unapplied, allowing us to change options categories without losing changes
-   %unappliedPrefIndex = OptionsMenu.unappliedChanges.getIndexFromValue(%targetPrefVar);
-   if(%unappliedPrefIndex != -1)
-   {
-      %unappliedValue = OptionsMenu.unappliedChanges.getValue(%unappliedPrefIndex);
-      %defaultValue = %unappliedValue;
-   }
+   if(%defaultValue $= "")
+      %defaultValue = OptionsMenu.getOptionVariableValue(%targetPrefVar);
    
    %option.setSliderSetting(%label, %defaultValue, %increment, %range, %callback, %enabled, %description);
 
@@ -809,16 +920,20 @@ function convertBoolToYesNo(%val)
 {
    if(%val == 1)
       return "Yes";
-   else 
+   else if(%val == 0)
       return "No";
+      
+   return %val;
 }
 
 function convertBoolToOnOff(%val)
 {
    if(%val == 1)
       return "On";
-   else 
+   else if(%val == 0)
       return "Off";
+      
+   return %val;
 }
 
 function getDisplayDeviceName()
@@ -883,7 +998,7 @@ function MenuOptionsButton::onChange(%this)
    }
    
    //Update the UI in case there's responsive logic
-   schedule(32, OptionsMenu, "refresh");
+   OptionsMenu.schedule(32, "refresh");
 }
 
 function OptionsMenu::onKeybindChanged(%this, %actionMap, %keybind)
@@ -913,6 +1028,17 @@ function removeOptionsMenuCategory(%categoryName)
       OptionsMenu.optionsCategories.erase(%index);
 }
 
+function getOptionsCategoryIndexByName(%categoryName)
+{
+   for(%i=0; %i < OptionsMenu.optionsCategories.count(); %i++)
+   {
+      if(OptionsMenu.optionsCategories.getKey(%i) $= %categoryName)
+         return %i;
+   }
+   
+   return -1;
+}
+
 function addListOption(%label, %description, %targetPrefVar, %optionsList, %wrapOptions, %callback, %enabled)
 {
    if(%wrapOptions $= "")
diff --git a/Templates/BaseGame/game/data/defaults.tscript b/Templates/BaseGame/game/data/defaults.tscript
index d45116ff9..acd2a0f43 100644
--- a/Templates/BaseGame/game/data/defaults.tscript
+++ b/Templates/BaseGame/game/data/defaults.tscript
@@ -125,11 +125,6 @@ $pref::SFX::channelVolume6 = 1;
 $pref::SFX::channelVolume7 = 1;
 $pref::SFX::channelVolume8 = 1;
 
-$pref::SFX::channelVolume[1] = 1;
-$pref::SFX::channelVolume[2] = 1;
-$pref::SFX::channelVolume[3] = 1;
-$pref::SFX::channelVolume[4] = 1;
-
 $pref::PostEffect::PreferedHDRFormat = "GFXFormatR8G8B8A8";
 
 /// This is an scalar which can be used to reduce the 
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
index fc3e3576c..eca3729f7 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
@@ -1088,7 +1088,7 @@ function AssetBrowserPreviewButton::onRightClick(%this)
    
    //Do some enabling/disabling of options depending on asset type
    EditAssetPopup.enableItem(0, true);
-   EditAssetPopup.enableItem(7, true);
+   EditAssetPopup.enableItem(9, true);
    
    //Is it an editable type?
    if(%assetType $= "ImageAsset" /*|| %assetType $= "GameObjectAsset"*/ || %assetType $= "CppAsset")
@@ -1101,9 +1101,18 @@ function AssetBrowserPreviewButton::onRightClick(%this)
        || %assetType $= "MaterialAsset" || %assetType $= "ParticleAsset"  || %assetType $= "PostEffectAsset" || %assetType $= "ScriptAsset"
        || %assetType $= "StateMachineAsset")
    {
-      EditAssetPopup.enableItem(7, false);
+      EditAssetPopup.enableItem(9, false);
    }
    
+   %assetDef = AssetDatabase.acquireAsset(EditAssetPopup.assetId);
+   if(%assetDef.originalFilePath $= "" || !isFile(%assetDef.originalFilePath))
+   {
+      //if we have no noted original import file path or it's invalid
+      //we can't reimport either
+      EditAssetPopup.enableItem(9, false);
+   }
+   AssetDatabase.releaseAsset(EditAssetPopup.assetId);
+   
    if(%assetType $= "LevelAsset")
    {
       EditLevelAssetPopup.showPopup(Canvas);  
@@ -2403,19 +2412,14 @@ function AssetBrowserFilterTree::onControlDropped( %this, %payload, %position )
    %assetName = %payload.assetName;
    %moduleName = %payload.moduleName;
    
-   echo("DROPPED A " @ %assetType @ " ON THE ASSET BROWSER NAVIGATION TREE!");
-   
    %item = %this.getItemAtPosition(%position);
    
-   echo("DROPPED IT ON ITEM " @ %item);
-   
    %parent = %this.getParentItem(%item);
    
    if(%item != 1)
    {
       //we're a folder entry, cool
       %path = %this.getItemValue(%item) @ "/" @ %this.getItemText(%item);
-      echo("DROPPED IT ON PATH " @ %path);  
       
       if(%path !$= AssetBrowser.dirHandler.CurrentAddress)
       {
@@ -2430,7 +2434,11 @@ function AssetBrowserFilterTree::onControlDropped( %this, %payload, %position )
             
             //Do any cleanup required given the type
             if(AssetBrowser.isMethod("moveFolder"))
+            {
                eval(AssetBrowser @ ".moveFolder(\""@%originFolder@"\",\""@%path@"\");");
+               
+               AssetBrowser.refresh();
+            }
          }
          else
          {
@@ -2443,6 +2451,8 @@ function AssetBrowserFilterTree::onControlDropped( %this, %payload, %position )
             {
                %command = AssetBrowser @ ".move" @ %assetType @ "(" @ %assetDef @ ",\"" @ %path @ "\");";
                eval(AssetBrowser @ ".move" @ %assetType @ "(" @ %assetDef @ ",\"" @ %path @ "\");");
+               
+               AssetBrowser.refresh();
             }
          }
       }
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/cpp.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/cpp.tscript
index 66f7cb64a..a42431bfd 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/cpp.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/cpp.tscript
@@ -204,7 +204,7 @@ function AssetBrowser::deleteCpp(%this, %assetDef)
 function AssetBrowser::moveCpp(%this, %assetDef, %destination)
 {
    %currentModule = AssetDatabase.getAssetModule(%assetDef.getAssetId());
-   %targetModule = AssetBrowser.getModuleFromAddress(%destination);
+   %targetModule = AssetBrowser.dirHandler.getModuleFromAddress(%destination);
    
    %newAssetPath = moveAssetFile(%assetDef, %destination);
    
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/cubemap.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/cubemap.tscript
index b050d37cd..c2a5429f3 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/cubemap.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/cubemap.tscript
@@ -69,7 +69,7 @@ function AssetBrowser::deleteCubemapAsset(%this, %assetDef)
 function AssetBrowser::moveCubemapAsset(%this, %assetDef, %destination)
 {
    /*%currentModule = AssetDatabase.getAssetModule(%assetDef.getAssetId());
-   %targetModule = AssetBrowser.getModuleFromAddress(%destination);
+   %targetModule = AssetBrowser.dirHandler.getModuleFromAddress(%destination);
    
    %newAssetPath = moveAssetFile(%assetDef, %destination);
    
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/gameObject.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/gameObject.tscript
index c25eda8f4..7cff48ba5 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/gameObject.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/gameObject.tscript
@@ -233,7 +233,7 @@ function AssetBrowser::deleteGameObjectAsset(%this, %assetDef)
 function AssetBrowser::moveGameObjectAsset(%this, %assetDef, %destination)
 {
    %currentModule = AssetDatabase.getAssetModule(%assetDef.getAssetId());
-   %targetModule = AssetBrowser.getModuleFromAddress(%destination);
+   %targetModule = AssetBrowser.dirHandler.getModuleFromAddress(%destination);
    
    %newAssetPath = moveAssetFile(%assetDef, %destination);
    
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/gui.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/gui.tscript
index dfebccb47..7a5f66a64 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/gui.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/gui.tscript
@@ -145,15 +145,15 @@ function AssetBrowser::deleteGUIAsset(%this, %assetDef)
 function AssetBrowser::moveGUIAsset(%this, %assetDef, %destination)
 {
    %currentModule = AssetDatabase.getAssetModule(%assetDef.getAssetId());
-   %targetModule = AssetBrowser.getModuleFromAddress(%destination);
+   %targetModule = AssetBrowser.dirHandler.getModuleFromAddress(%destination);
    
    %newAssetPath = moveAssetFile(%assetDef, %destination);
    
    if(%newAssetPath $= "")
       return false;
 
-   moveAssetLooseFile(%assetDef.guifile, %destination);
-   moveAssetLooseFile(%assetDef.scriptFile, %destination);
+   moveAssetLooseFile(%assetDef.getGUIPath(), %destination);
+   moveAssetLooseFile(%assetDef.getScriptPath(), %destination);
    
    AssetDatabase.removeDeclaredAsset(%assetDef.getAssetId());
    AssetDatabase.addDeclaredAsset(%targetModule, %newAssetPath);
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/image.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/image.tscript
index 0dbebd39b..df8b2467c 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/image.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/image.tscript
@@ -175,8 +175,11 @@ function AssetBrowser::importImageAsset(%this, %assetItem)
       AssetDatabase.refreshAsset(%assetId);
 }
 
-function AssetBrowser::buildImageAssetPreview(%this, %assetDef, %previewData)
+function AssetBrowser::buildImageAssetPreview(%this, %assetDef, %previewData, %forcePreviewRegenerate)
 {
+   if(%forcePreviewRegenerate $= "")
+      %forcePreviewRegenerate = false;
+      
    %module = %this.dirHandler.getModuleFromAddress(makeRelativePath(filePath(%assetDef.getImagePath())));
    %previewPath = "tools/resources/previewCache/" @ %module.moduleId @ "/";
    
@@ -195,7 +198,7 @@ function AssetBrowser::buildImageAssetPreview(%this, %assetDef, %previewData)
    
    %previewAssetName = %module.moduleId @ "_" @ %assetDef.assetName @ "_PreviewImage";
    
-   if(%generatePreview)
+   if(%generatePreview || %forcePreviewRegenerate)
    {
       displayEditorLoadingGui("Generating Image Asset Preview...");
       
@@ -203,20 +206,23 @@ function AssetBrowser::buildImageAssetPreview(%this, %assetDef, %previewData)
       
       if(%success)
       {
-         %previewAsset = new ImageAsset()
+         if(!AssetDatabase.isDeclaredAsset("ToolsModule:" @ %previewAssetName))
          {
-            assetName = %previewAssetName;
-            versionId = 1;
-            imageFile = fileName(%previewFilePath);
-         };
-      
-         %previewAssetName = "ToolsModule:" @ %previewAssetName;
-         %previewImgAssetPath = %previewPath @ %previewAsset.assetName @ ".asset.taml";
-         %assetImportSuccessful = TAMLWrite(%previewAsset, %previewImgAssetPath); 
-      
-         %toolsModuleDef = ModuleDatabase.findModule("ToolsModule",1);
+            %previewAsset = new ImageAsset()
+            {
+               assetName = %previewAssetName;
+               versionId = 1;
+               imageFile = fileName(%previewFilePath);
+            };
          
-         %success = AssetDatabase.addDeclaredAsset(%toolsModuleDef, %previewImgAssetPath);
+            %previewAssetName = "ToolsModule:" @ %previewAssetName;
+            %previewImgAssetPath = %previewPath @ %previewAsset.assetName @ ".asset.taml";
+            %assetImportSuccessful = TAMLWrite(%previewAsset, %previewImgAssetPath); 
+         
+            %toolsModuleDef = ModuleDatabase.findModule("ToolsModule",1);
+            
+            %success = AssetDatabase.addDeclaredAsset(%toolsModuleDef, %previewImgAssetPath);
+         }
       }
       else
       {
@@ -303,14 +309,14 @@ function AssetBrowser::deleteImageAsset(%this, %assetDef)
 function AssetBrowser::moveImageAsset(%this, %assetDef, %destination)
 {
    %currentModule = AssetDatabase.getAssetModule(%assetDef.getAssetId());
-   %targetModule = AssetBrowser.getModuleFromAddress(%destination);
+   %targetModule = AssetBrowser.dirHandler.getModuleFromAddress(%destination);
    
    %newAssetPath = moveAssetFile(%assetDef, %destination);
    
    if(%newAssetPath $= "")
       return false;
 
-   moveAssetLooseFile(%assetDef.imageFile, %destination);
+   moveAssetLooseFile(%assetDef.getImagePath(), %destination);
    
    AssetDatabase.removeDeclaredAsset(%assetDef.getAssetId());
    AssetDatabase.addDeclaredAsset(%targetModule, %newAssetPath);
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/level.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/level.tscript
index 23be49e9f..07ce53fce 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/level.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/level.tscript
@@ -113,14 +113,18 @@ function AssetBrowser::deleteLevelAsset(%this, %assetDef)
 function AssetBrowser::moveLevelAsset(%this, %assetDef, %destination)
 {
    %currentModule = AssetDatabase.getAssetModule(%assetDef.getAssetId());
-   %targetModule = AssetBrowser.getModuleFromAddress(%destination);
+   %targetModule = AssetBrowser.dirHandler.getModuleFromAddress(%destination);
    
    %newAssetPath = moveAssetFile(%assetDef, %destination);
    
    if(%newAssetPath $= "")
       return false;
 
-   moveAssetLooseFile(%assetDef.LevelFile, %destination);
+   moveAssetLooseFile(%assetDef.getLevelPath(), %destination);
+   moveAssetLooseFile(%assetDef.getLevelPath(), %destination);
+   moveAssetLooseFile(%assetDef.getPreviewImagePath(), %destination);
+   moveAssetLooseFile(%assetDef.getPostFXPresetPath(), %destination);
+   moveAssetLooseFile(%assetDef.getDecalsPath(), %destination);
    
    AssetDatabase.removeDeclaredAsset(%assetDef.getAssetId());
    AssetDatabase.addDeclaredAsset(%targetModule, %newAssetPath);
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
index 27a3dc58d..debcaffd8 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
@@ -69,14 +69,14 @@ function AssetBrowser::deleteMaterialAsset(%this, %assetDef)
 function AssetBrowser::moveMaterialAsset(%this, %assetDef, %destination)
 {
    %currentModule = AssetDatabase.getAssetModule(%assetDef.getAssetId());
-   %targetModule = AssetBrowser.getModuleFromAddress(%destination);
+   %targetModule = AssetBrowser.dirHandler.getModuleFromAddress(%destination);
    
    %newAssetPath = moveAssetFile(%assetDef, %destination);
    
    if(%newAssetPath $= "")
       return false;
 
-   moveAssetLooseFile(%assetDef.scriptPath, %destination);
+   moveAssetLooseFile(%assetDef.getScriptPath(), %destination);
    
    AssetDatabase.removeDeclaredAsset(%assetDef.getAssetId());
    AssetDatabase.addDeclaredAsset(%targetModule, %newAssetPath);
@@ -424,8 +424,11 @@ function AssetBrowser::importMaterialAsset(%this, %assetItem)
       AssetDatabase.refreshAsset(%assetId);
 }
 
-function AssetBrowser::buildMaterialAssetPreview(%this, %assetDef, %previewData)
-{
+function AssetBrowser::buildMaterialAssetPreview(%this, %assetDef, %previewData, %forcePreviewRegenerate)
+{   
+   if(%forcePreviewRegenerate $= "")
+      %forcePreviewRegenerate = false;
+      
    %module = %this.dirHandler.getModuleFromAddress(makeRelativePath(filePath(AssetDatabase.getAssetFilePath(%assetDef.getAssetId()))));
    %previewPath = "tools/resources/previewCache/" @ %module.moduleId @ "/";
 
@@ -447,14 +450,13 @@ function AssetBrowser::buildMaterialAssetPreview(%this, %assetDef, %previewData)
       {
          if(compareFileTimes(%assetDef.materialDefinitionName.getDiffuseMap(0), %previewFilePath) == 1 ||
             compareFileTimes(%assetDef.materialDefinitionName.getFilename(), %previewFilePath) == 1)
-      %generatePreview = true;
-         
+            %generatePreview = true;
       }
    }
 
    %previewAssetName = %module.moduleId @ "_" @ %assetDef.assetName @ "_PreviewImage";
                                    
-   if(%generatePreview)
+   if(%generatePreview || %forcePreviewRegenerate)
    {
       displayEditorLoadingGui("Generating Material Asset Preview...");
    
@@ -466,19 +468,26 @@ function AssetBrowser::buildMaterialAssetPreview(%this, %assetDef, %previewData)
          pathCopy(%generatedFilePath, %previewFilePath);
          fileDelete(%generatedFilePath);
 
-         %previewAsset = new ImageAsset()
+         if(!AssetDatabase.isDeclaredAsset("ToolsModule:" @ %previewAssetName))
          {
-            assetName = %previewAssetName;
-            versionId = 1;
-            imageFile = fileName(%previewFilePath);
-         };
-         
-         %previewImgAssetPath = %previewPath @ %previewAsset.assetName @ ".asset.taml";
-         %assetImportSuccessful = TAMLWrite(%previewAsset, %previewImgAssetPath); 
-         
-         %toolsModuleDef = ModuleDatabase.findModule("ToolsModule",1);
+            %previewAsset = new ImageAsset()
+            {
+               assetName = %previewAssetName;
+               versionId = 1;
+               imageFile = fileName(%previewFilePath);
+            };
             
-         %success = AssetDatabase.addDeclaredAsset(%toolsModuleDef, %previewImgAssetPath);
+            %previewImgAssetPath = %previewPath @ %previewAsset.assetName @ ".asset.taml";
+            %assetImportSuccessful = TAMLWrite(%previewAsset, %previewImgAssetPath); 
+            
+            %toolsModuleDef = ModuleDatabase.findModule("ToolsModule",1);
+               
+            %success = AssetDatabase.addDeclaredAsset(%toolsModuleDef, %previewImgAssetPath);
+         }
+      }
+      else
+      {
+         error("Failed to generate preview for material: " @ %assetDef.materialDefinitionName);
       }
       
       hideEditorLoadingGui();
@@ -504,11 +513,15 @@ function AssetBrowser::buildMaterialAssetPreview(%this, %assetDef, %previewData)
       %previewData.doubleClickCommand = "AssetBrowser.selectAsset( AssetBrowser.selectedAsset );";
    else
       %previewData.doubleClickCommand = "AssetBrowser.editAsset( "@%assetDef@" );";
+      
+   %definitionPath = %assetDef.getScriptPath();
+   if(%definitionPath $= "")
+      %definitionPath = %assetDef.getFilename();
    
    %previewData.tooltip = "Asset Name: " @ %assetDef.assetName @ 
                            "\nAsset Type: Material Asset" @  
                            "\nAsset Definition ID: " @  %assetDef @
-                           "\nDefinition Path: " @ %assetDef.getScriptPath();
+                           "\nDefinition Path: " @ %definitionPath;
                            
    if(!%this.selectMode)
    {
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/postFX.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/postFX.tscript
index 704a6ddf2..a51390370 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/postFX.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/postFX.tscript
@@ -140,16 +140,16 @@ function AssetBrowser::deletePostEffectAsset(%this, %assetDef)
 function AssetBrowser::movePostEffectAsset(%this, %assetDef, %destination)
 {
    %currentModule = AssetDatabase.getAssetModule(%assetDef.getAssetId());
-   %targetModule = AssetBrowser.getModuleFromAddress(%destination);
+   %targetModule = AssetBrowser.dirHandler.getModuleFromAddress(%destination);
    
    %newAssetPath = moveAssetFile(%assetDef, %destination);
    
    if(%newAssetPath $= "")
       return false;
 
-   moveAssetLooseFile(%assetDef.scriptPath, %destination);
-   moveAssetLooseFile(%assetDef.hlslShader, %destination);
-   moveAssetLooseFile(%assetDef.glslShader, %destination);
+   moveAssetLooseFile(%assetDef.getScriptPath(), %destination);
+   moveAssetLooseFile(%assetDef.getHLSLShaderPath(), %destination);
+   moveAssetLooseFile(%assetDef.getGLSLShaderPath(), %destination);
    
    AssetDatabase.removeDeclaredAsset(%assetDef.getAssetId());
    AssetDatabase.addDeclaredAsset(%targetModule, %newAssetPath);
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/script.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/script.tscript
index 1bf590f80..7b308b624 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/script.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/script.tscript
@@ -36,7 +36,7 @@ function AssetBrowser::editScriptAsset(%this, %assetDef)
 {
    %scriptFile = %assetDef.scriptFile;
    
-   EditorOpenFileInTorsion(makeFullPath(%scriptFile), 0);
+   //EditorOpenFileInTorsion(makeFullPath(%scriptFile), 0);
 }
 
 function AssetBrowser::duplicateScriptAsset(%this, %assetDef, %targetModule)
@@ -76,14 +76,14 @@ function AssetBrowser::deleteScriptAsset(%this, %assetDef)
 function AssetBrowser::moveScriptAsset(%this, %assetDef, %destination)
 {
    %currentModule = AssetDatabase.getAssetModule(%assetDef.getAssetId());
-   %targetModule = AssetBrowser.getModuleFromAddress(%destination);
+   %targetModule = AssetBrowser.dirHandler.getModuleFromAddress(%destination);
    
    %newAssetPath = moveAssetFile(%assetDef, %destination);
    
    if(%newAssetPath $= "")
       return false;
 
-   moveAssetLooseFile(%assetDef.scriptFile, %destination);
+   moveAssetLooseFile(%assetDef.getScriptPath(), %destination);
    
    AssetDatabase.removeDeclaredAsset(%assetDef.getAssetId());
    AssetDatabase.addDeclaredAsset(%targetModule, %newAssetPath);
@@ -93,7 +93,7 @@ function AssetBrowser::buildScriptAssetPreview(%this, %assetDef, %previewData)
 {
    %previewData.assetName = %assetDef.assetName;
    %previewData.assetPath = %assetDef.scriptFile;
-   %previewData.doubleClickCommand = "EditorOpenFileInTorsion( \""@%previewData.assetPath@"\", 0 );";
+   //%previewData.doubleClickCommand = "EditorOpenFileInTorsion( \""@%previewData.assetPath@"\", 0 );";
    
    if(%assetDef.isServerSide)
       %previewData.previewImage = "ToolsModule:serverScriptIcon_image";
@@ -109,7 +109,7 @@ function AssetBrowser::buildTScriptPreview(%this, %assetDef, %previewData)
 {
    %previewData.assetName = %assetDef.assetName;
    %previewData.assetPath = %assetDef.scriptFile;
-   %previewData.doubleClickCommand = "EditorOpenFileInTorsion( \""@%previewData.assetPath@"\", 0 );";
+   //%previewData.doubleClickCommand = "EditorOpenFileInTorsion( \""@%previewData.assetPath@"\", 0 );";
    
    if(%assetDef.isServerSide)
       %previewData.previewImage = "ToolsModule:serverScriptIcon_image";
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
index 15c48079b..250e7c6ac 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
@@ -46,6 +46,23 @@ function AssetBrowser::deleteShapeAsset(%this, %assetDef)
    
 }
 
+function AssetBrowser::moveShapeAsset(%this, %assetDef, %destination)
+{
+   %currentModule = AssetDatabase.getAssetModule(%assetDef.getAssetId());
+   %targetModule = AssetBrowser.dirHandler.getModuleFromAddress(%destination);
+   
+   %newAssetPath = moveAssetFile(%assetDef, %destination);
+   
+   if(%newAssetPath $= "")
+      return false;
+
+   moveAssetLooseFile(%assetDef.getShapePath(), %destination);
+   moveAssetLooseFile(%assetDef.getShapeConstructorFilePath(), %destination);
+   
+   AssetDatabase.removeDeclaredAsset(%assetDef.getAssetId());
+   AssetDatabase.addDeclaredAsset(%targetModule, %newAssetPath);
+}
+
 function AssetBrowser::prepareImportShapeAsset(%this, %assetItem)
 {
    ImportActivityLog.add("Preparing Shape for Import: " @ %assetItem.assetName);
@@ -246,9 +263,12 @@ function AssetBrowser::importShapeAsset(%this, %assetItem)
       AssetDatabase.refreshAsset(%assetId);
 }
 
-function AssetBrowser::buildShapeAssetPreview(%this, %assetDef, %previewData)
+function AssetBrowser::buildShapeAssetPreview(%this, %assetDef, %previewData, %forcePreviewRegenerate)
 {
-   %module = %this.dirHandler.getModuleFromAddress(makeRelativePath(filePath(%assetDef.getShapeFile())));
+   if(%forcePreviewRegenerate $= "")
+      %forcePreviewRegenerate = false;
+      
+   %module = %this.dirHandler.getModuleFromAddress(makeRelativePath(filePath(%assetDef.getShapePath())));
    %previewPath = "tools/resources/previewCache/" @ %module.moduleId @ "/";
    
    if(!IsDirectory(%previewPath))
@@ -259,14 +279,14 @@ function AssetBrowser::buildShapeAssetPreview(%this, %assetDef, %previewData)
    %generatePreview = false;
    
    %previewFilePath = %previewPath @ %assetDef.assetName @ "_Preview.dds";
-   if(!isFile(%previewFilePath) || (compareFileTimes(%assetDef.getShapeFile(), %previewFilePath) == 1))
+   if(!isFile(%previewFilePath) || (compareFileTimes(%assetDef.getShapePath(), %previewFilePath) == 1))
    {
       %generatePreview = true;
    }
    
    %previewAssetName = %module.moduleId @ "_" @ %assetDef.assetName @ "_PreviewImage";
    
-   if(%generatePreview)
+   if(%generatePreview || %forcePreviewRegenerate)
    {
       displayEditorLoadingGui("Generating Shape Asset Preview...");
       
@@ -278,19 +298,22 @@ function AssetBrowser::buildShapeAssetPreview(%this, %assetDef, %previewData)
       pathCopy(%filePath, %previewFilePath);
       fileDelete(%filePath); //cleanup
       
-      %previewAsset = new ImageAsset()
+      if(!AssetDatabase.isDeclaredAsset("ToolsModule:" @ %previewAssetName))
       {
-         assetName = %previewAssetName;
-         versionId = 1;
-         imageFile = fileName(%previewFilePath);
-      };
-      
-      %previewImgAssetPath = %previewPath @ %previewAsset.assetName @ ".asset.taml";
-      %assetImportSuccessful = TAMLWrite(%previewAsset, %previewImgAssetPath); 
-      
-      %toolsModuleDef = ModuleDatabase.findModule("ToolsModule",1);
+         %previewAsset = new ImageAsset()
+         {
+            assetName = %previewAssetName;
+            versionId = 1;
+            imageFile = fileName(%previewFilePath);
+         };
          
-      %success = AssetDatabase.addDeclaredAsset(%toolsModuleDef, %previewImgAssetPath);
+         %previewImgAssetPath = %previewPath @ %previewAsset.assetName @ ".asset.taml";
+         %assetImportSuccessful = TAMLWrite(%previewAsset, %previewImgAssetPath); 
+         
+         %toolsModuleDef = ModuleDatabase.findModule("ToolsModule",1);
+            
+         %success = AssetDatabase.addDeclaredAsset(%toolsModuleDef, %previewImgAssetPath);
+      }
       
       hideEditorLoadingGui();
    }
@@ -313,7 +336,7 @@ function AssetBrowser::buildShapeAssetPreview(%this, %assetDef, %previewData)
    %previewData.tooltip = "Asset Name: " @ %assetDef.assetName @ "\n" @ 
                            "Asset Type: Shape Asset\n" @ 
                            "Asset Definition ID: " @  %assetDef @ "\n" @ 
-                           "Shape File path: " @ %assetDef.getShapeFile();
+                           "Shape File path: " @ %assetDef.getShapePath();
                            
    if(%this.selectMode)
    {
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shapeAnimation.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shapeAnimation.tscript
index 5e43c126e..bb76e40d0 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shapeAnimation.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shapeAnimation.tscript
@@ -31,6 +31,22 @@ function AssetBrowser::editShapeAnimationAsset(%this, %assetDef)
    ShapeEditorPlugin.openShapeAsset(%assetDef);   
 }
 
+function AssetBrowser::moveShapeAnimationAsset(%this, %assetDef, %destination)
+{
+   %currentModule = AssetDatabase.getAssetModule(%assetDef.getAssetId());
+   %targetModule = AssetBrowser.dirHandler.getModuleFromAddress(%destination);
+   
+   %newAssetPath = moveAssetFile(%assetDef, %destination);
+   
+   if(%newAssetPath $= "")
+      return false;
+
+   moveAssetLooseFile(%assetDef.getAnimationPath(), %destination);
+   
+   AssetDatabase.removeDeclaredAsset(%assetDef.getAssetId());
+   AssetDatabase.addDeclaredAsset(%targetModule, %newAssetPath);
+}
+
 function AssetBrowser::buildShapeAnimationAssetPreview(%this, %assetDef, %previewData)
 {
    %previewData.assetName = %assetDef.animationName;
@@ -51,5 +67,5 @@ function AssetBrowser::buildShapeAnimationAssetPreview(%this, %assetDef, %previe
    
    %previewData.assetFriendlyName = %assetDef.assetName;
    %previewData.assetDesc = %assetDef.description;
-   %previewData.tooltip = %assetDef.friendlyName @ "\n" @ %assetDef @ "\nShape File path: " @ %assetDef.getShapeFile();
+   %previewData.tooltip = %assetDef.friendlyName @ "\n" @ %assetDef @ "\nShape File path: " @ %assetDef.getShapePath();
 }
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/sound.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/sound.tscript
index 8cc63bdf4..1730e5882 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/sound.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/sound.tscript
@@ -11,6 +11,22 @@ function AssetBrowser::onSoundAssetChanged(%this, %assetDef)
         sfxStop($PreviewSoundSource);
 }
 
+function AssetBrowser::moveSoundAsset(%this, %assetDef, %destination)
+{
+   %currentModule = AssetDatabase.getAssetModule(%assetDef.getAssetId());
+   %targetModule = AssetBrowser.dirHandler.getModuleFromAddress(%destination);
+   
+   %newAssetPath = moveAssetFile(%assetDef, %destination);
+   
+   if(%newAssetPath $= "")
+      return false;
+
+   moveAssetLooseFile(%assetDef.getSoundPath(), %destination);
+   
+   AssetDatabase.removeDeclaredAsset(%assetDef.getAssetId());
+   AssetDatabase.addDeclaredAsset(%targetModule, %newAssetPath);
+}
+
 function AssetBrowser::buildSoundAssetPreview(%this, %assetDef, %previewData)
 {
    %previewData.assetName = %assetDef.assetName;
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrain.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrain.tscript
index c7e8fe92e..9d5d3c5b8 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrain.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrain.tscript
@@ -161,6 +161,22 @@ function AssetBrowser::deleteTerrainAsset(%this, %assetDef)
 {
 }
 
+function AssetBrowser::moveTerrainAsset(%this, %assetDef, %destination)
+{
+   %currentModule = AssetDatabase.getAssetModule(%assetDef.getAssetId());
+   %targetModule = AssetBrowser.dirHandler.getModuleFromAddress(%destination);
+   
+   %newAssetPath = moveAssetFile(%assetDef, %destination);
+   
+   if(%newAssetPath $= "")
+      return false;
+
+   moveAssetLooseFile(%assetDef.getTerrainFilePath(), %destination);
+   
+   AssetDatabase.removeDeclaredAsset(%assetDef.getAssetId());
+   AssetDatabase.addDeclaredAsset(%targetModule, %newAssetPath);
+}
+
 function AssetBrowser::buildTerrainAssetPreview(%this, %assetDef, %previewData)
 {
    %previewData.assetName = %assetDef.assetName;
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrainMaterial.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrainMaterial.tscript
index 8df0a1fa3..8176d0da0 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrainMaterial.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrainMaterial.tscript
@@ -93,8 +93,27 @@ function AssetBrowser::deleteTerrainMaterialAsset(%this, %assetDef)
 {
 }
 
-function AssetBrowser::buildTerrainMaterialAssetPreview(%this, %assetDef, %previewData)
+function AssetBrowser::moveTerrainMaterialAsset(%this, %assetDef, %destination)
 {
+   %currentModule = AssetDatabase.getAssetModule(%assetDef.getAssetId());
+   %targetModule = AssetBrowser.dirHandler.getModuleFromAddress(%destination);
+   
+   %newAssetPath = moveAssetFile(%assetDef, %destination);
+   
+   if(%newAssetPath $= "")
+      return false;
+
+   moveAssetLooseFile(%assetDef.getScriptPath(), %destination);
+   
+   AssetDatabase.removeDeclaredAsset(%assetDef.getAssetId());
+   AssetDatabase.addDeclaredAsset(%targetModule, %newAssetPath);
+}
+
+function AssetBrowser::buildTerrainMaterialAssetPreview(%this, %assetDef, %previewData, %forcePreviewRegenerate)
+{
+   if(%forcePreviewRegenerate $= "")
+      %forcePreviewRegenerate = false;
+      
    %module = %this.dirHandler.getModuleFromAddress(makeRelativePath(filePath(AssetDatabase.getAssetFilePath(%assetDef.getAssetId()))));
    %previewPath = "tools/resources/previewCache/" @ %module.moduleId @ "/";
 
@@ -122,31 +141,35 @@ function AssetBrowser::buildTerrainMaterialAssetPreview(%this, %assetDef, %previ
 
    %previewAssetName = %module.moduleId @ "_" @ %assetDef.assetName @ "_PreviewImage";
                                    
-   if(%generatePreview)
+   if(%generatePreview || %forcePreviewRegenerate)
    {
       displayEditorLoadingGui("Generating Material Asset Preview...");
    
       if(isObject(%assetDef.materialDefinitionName))
       {
          %previewShapeDef = AssetDatabase.acquireAsset("ToolsModule:previewSphereShape");
-         %generatedFilePath = %previewShapeDef.generateCachedPreviewImage(256, %assetDef.materialDefinitionName);
+         %generatedFilePath = %previewShapeDef.generateCachedPreviewImage(256, DummyTerrMatPreview);
       
          pathCopy(%generatedFilePath, %previewFilePath);
          fileDelete(%generatedFilePath);
 
-         %previewAsset = new ImageAsset()
+
+         if(!AssetDatabase.isDeclaredAsset("ToolsModule:" @ %previewAssetName))
          {
-            assetName = %previewAssetName;
-            versionId = 1;
-            imageFile = fileName(%previewFilePath);
-         };
-         
-         %previewImgAssetPath = %previewPath @ %previewAsset.assetName @ ".asset.taml";
-         %assetImportSuccessful = TAMLWrite(%previewAsset, %previewImgAssetPath); 
-         
-         %toolsModuleDef = ModuleDatabase.findModule("ToolsModule",1);
+            %previewAsset = new ImageAsset()
+            {
+               assetName = %previewAssetName;
+               versionId = 1;
+               imageFile = fileName(%previewFilePath);
+            };
             
-         %success = AssetDatabase.addDeclaredAsset(%toolsModuleDef, %previewImgAssetPath);
+            %previewImgAssetPath = %previewPath @ %previewAsset.assetName @ ".asset.taml";
+            %assetImportSuccessful = TAMLWrite(%previewAsset, %previewImgAssetPath); 
+            
+            %toolsModuleDef = ModuleDatabase.findModule("ToolsModule",1);
+               
+            %success = AssetDatabase.addDeclaredAsset(%toolsModuleDef, %previewImgAssetPath);
+         }
       }
       
       hideEditorLoadingGui();
@@ -170,10 +193,14 @@ function AssetBrowser::buildTerrainMaterialAssetPreview(%this, %assetDef, %previ
    %previewData.assetDesc = %assetDef.description;
    %previewData.tooltip = %assetDef.gameObjectName;
    
+   %definitionPath = %assetDef.getScriptPath();
+   if(%definitionPath $= "")
+      %definitionPath = %assetDef.getFilename();
+   
    %previewData.tooltip = "Asset Name: " @ %assetDef.assetName @ 
                            "\nAsset Type: Terrain Material Asset" @  
                            "\nAsset Definition ID: " @  %assetDef @
-                           "\nDefinition Path: " @ %assetDef.getScriptPath();
+                           "\nDefinition Path: " @ %definitionPath;
 }
 
 function GuiInspectorTypeTerrainMaterialAssetPtr::onClick( %this, %fieldName )
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/editAsset.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/editAsset.tscript
index 2d088f27a..6267462ee 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/editAsset.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/editAsset.tscript
@@ -111,7 +111,19 @@ function AssetBrowser::refreshAsset(%this, %assetId)
 }
 
 //------------------------------------------------------------
+function AssetBrowser::regeneratePreviewImage(%this)
+{
+   %assetDef = AssetDatabase.acquireAsset(EditAssetPopup.assetId);
+   %dummyObj = new ScriptObject();
+   %regenCommand = "AssetBrowser.build" @ EditAssetPopup.assetType @ 
+                     "Preview(" @%assetDef @ "," @ %dummyObj @ ", true);";
+   eval(%regenCommand);
 
+   %dummyObj.delete();
+   AssetDatabase.releaseAsset(EditAssetPopup.assetId);
+}
+
+//------------------------------------------------------------
 function AssetBrowser::renameAsset(%this)
 {
    //Find out what type it is
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/newAsset.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/newAsset.tscript
index c402456cd..e3a813862 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/newAsset.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/newAsset.tscript
@@ -139,6 +139,19 @@ function newAssetUpdatePath(%newPath)
    NewAssetTargetModule.text = AssetBrowser.dirHandler.getModuleFromAddress(AssetBrowser.dirHandler.currentAddress).ModuleId;
 }
 
+//
+function NewAssetTargetModule::onSelect(%this, %idx, %idy)
+{
+   %newModuleName = %this.getText();
+   
+   %currentTargetPath = NewAssetTargetAddress.getText();
+   if(!startsWith(%currentTargetPath, "data/" @ %newModuleName @ "/"))
+   {
+      NewAssetTargetAddress.setText("data/" @ %newModuleName @ "/");
+   }
+}
+
+//
 //We do a quick validation that mandatory fields are filled in before passing along to the asset-type specific function
 function CreateNewAsset()
 {
@@ -172,9 +185,41 @@ function CreateNewAsset()
 		return;
 	}
 	
+	//First, we need to make sure we're not creating a conflicting asset
+	if(AssetDatabase.isDeclaredAsset(%moduleName @ ":" @ %assetName))
+	{
+	   toolsMessageBoxOK( "Error", "An asset with the ID: " @ %moduleName @ ":" @ %assetName 
+	                        @ " already exists! Please review and rename.");
+		return;
+	}
+	
+	%assetType = AssetBrowser.newAssetSettings.assetType;
+	
+	if(%assetType $= "MaterialAsset" || %assetType $= "TerrainMaterialAsset" || 
+	   %assetType $= "GUIAsset")
+	{
+	   if(isObject(%assetName))
+	   {
+         toolsMessageBoxOK( "Error", "Attempted to create a new asset that requires " @
+                                    "a unique name, as the object definition must be unique. " @
+                                    "Please use a new name.");
+         return;
+	   }
+	}
+	
+	%currentTargetPath = NewAssetTargetAddress.getText();
+	%modulePath = makeRelativePath(ModuleDatabase.findModule(%moduleName).ModulePath);
+	
+	if(!startsWith(%currentTargetPath, %modulePath))
+   {
+      toolsMessageBoxOK( "Error", "Attempting to create a new asset in an invalid path. " @ 
+                                    "Please set the target path to be within the target module folder.");
+      return;
+   }
+      
+	
 	AssetBrowser.newAssetSettings.moduleName = %moduleName;
 	
-   %assetType = AssetBrowser.newAssetSettings.assetType;
 	if(%assetType $= "")
 	{
 	   toolsMessageBoxOK( "Error", "Attempted to make a new asset with no type!");
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/popupMenus.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/popupMenus.tscript
index 3294387b0..c4f0cca7b 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/popupMenus.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/popupMenus.tscript
@@ -28,11 +28,13 @@ function AssetBrowser::buildPopupMenus(%this)
          item[ 2 ] = "Reload Asset" TAB "" TAB "AssetBrowser.refreshAsset();";
          item[ 3 ] = "Asset Properties" TAB "" TAB "AssetBrowser.editAssetInfo();";
          item[ 4 ] = "-";
-         Item[ 5 ] = "Duplicate Asset" TAB "" TAB "AssetBrowser.duplicateAsset();";
+         item[ 5 ] = "Duplicate Asset" TAB "" TAB "AssetBrowser.duplicateAsset();";
          item[ 6 ] = "-";
-         item[ 7 ] = "Re-Import Asset" TAB "" TAB "AssetBrowser.reImportAsset();";
+         item[ 7 ] = "Regenerate Preview Image" TAB "" TAB "AssetBrowser.regeneratePreviewImage();";
          item[ 8 ] = "-";
-         item[ 9 ] = "Delete Asset" TAB "" TAB "AssetBrowser.deleteAsset();";
+         item[ 9 ] = "Re-Import Asset" TAB "" TAB "AssetBrowser.reImportAsset();";
+         item[ 10 ] = "-";
+         item[ 11 ] = "Delete Asset" TAB "" TAB "AssetBrowser.deleteAsset();";
 
          jumpFileName = "";
          jumpLineNumber = "";
@@ -182,7 +184,7 @@ function AssetBrowser::buildPopupMenus(%this)
          item[9] = "-";
          item[10] = "Create New Module" TAB "" TAB "AssetBrowser.CreateNewModule();";
          item[11] = "-";
-         item[12] = "Import Loose Files" TAB "" TAB "AssetBrowser.importLooseFiles();";
+         item[12] = "View Loose Files" TAB "" TAB "AssetBrowser.importLooseFiles();";
       
       };
    }
diff --git a/Templates/BaseGame/game/tools/forestEditor/forestEditToolbar.ed.gui b/Templates/BaseGame/game/tools/forestEditor/forestEditToolbar.ed.gui
index 5590f016e..d5e204bcb 100644
--- a/Templates/BaseGame/game/tools/forestEditor/forestEditToolbar.ed.gui
+++ b/Templates/BaseGame/game/tools/forestEditor/forestEditToolbar.ed.gui
@@ -110,7 +110,7 @@ $guiContent = new GuiControl(ForestEditToolbar,EditorGuiGroup) {
             MinExtent = "8 16";
             canSave = "1";
             Visible = "1";
-            AltCommand = "ForestTools->BrushTool.size = $ThisControl.getValue();";
+            AltCommand = "ForestTools->BrushTool.size = mClamp($ThisControl.getValue(), 1, getWord(ETerrainEditor.maxBrushSize, 0));";
             validate = "ForestEditorGui.validateBrushSize();";
             tooltipprofile = "ToolsGuiToolTipProfile";
             hovertime = "1000";
diff --git a/Templates/BaseGame/game/tools/forestEditor/forestEditorGui.tscript b/Templates/BaseGame/game/tools/forestEditor/forestEditorGui.tscript
index dd88668a1..d039d1c86 100644
--- a/Templates/BaseGame/game/tools/forestEditor/forestEditorGui.tscript
+++ b/Templates/BaseGame/game/tools/forestEditor/forestEditorGui.tscript
@@ -220,7 +220,7 @@ function selectNewForestMesh(%selectedShapeAssetId)
    //%str = "datablock TSForestItemData( " @ %name @ " ) { shapeFile = \"" @ %fullPath @ "\"; };";            
    //eval( %str );
    
-   //%fullPath = AssetDatabase.acquireAsset(%selectedShapeAssetId).getShapeFile();
+   //%fullPath = AssetDatabase.acquireAsset(%selectedShapeAssetId).getShapePath();
    
    new TSForestItemData(%name) {
       shapeAsset = %selectedShapeAssetId;
diff --git a/Templates/BaseGame/game/tools/gui/editorSettingsWindow.ed.tscript b/Templates/BaseGame/game/tools/gui/editorSettingsWindow.ed.tscript
index 848a625aa..52f7ff309 100644
--- a/Templates/BaseGame/game/tools/gui/editorSettingsWindow.ed.tscript
+++ b/Templates/BaseGame/game/tools/gui/editorSettingsWindow.ed.tscript
@@ -300,7 +300,7 @@ function ESettingsWindow::getGeneralSettings(%this)
    SettingsInspector.endGroup();
    
    SettingsInspector.startGroup("Paths");
-   SettingsInspector.addSettingsField("WorldEditor/torsionPath", "Torsion Path", "filename", "");
+   //SettingsInspector.addSettingsField("WorldEditor/torsionPath", "Torsion Path", "filename", "");
    SettingsInspector.endGroup();
    
    SettingsInspector.startGroup("Theme");
diff --git a/Templates/BaseGame/game/tools/gui/images/tab_border.png b/Templates/BaseGame/game/tools/gui/images/tab_border.png
index 59703d1597d3a95f5d064787822094ae20b5b790..3261e6d8bfbd95acccd804b0c13fae51f14dd435 100644
GIT binary patch
literal 8877
zcmeHLXEfZ~*H)uNjS?bEh#<ifqs-`KwCE)|8DlWYV2qj&k?1W#L=e$Q)F=_XBx(>6
zy%Qn21R+}9A-VT|?|T1V?pp8r?ar)UIs5GW?7g3}&so27!gaM(X{kA=iHL}3)zy^s
z3D2u17v&kkz4c9}IT6vhGk%69czvWdzzyeWhjB&&@V;(n0NMv*M?~Z^Hko3I`wWN=
zo;F1Q6}n3~+rp+4fQ^l0ll?U!wa0#69Hg8rd8r<9YNwGEw*5TZHT>CXd{$g=5k(EV
ze-HTBQaqS`X~Y_RG!$yyIQ&>}QRZl@cwOSGR${^Aom@BBJ5Iy9bl-C}JLNnR#(c9H
zraIPF<?220bhZedH=zMu3GZVHM<upL6<~a{u+~MvftMwV2j;Yg0zZsgi;i#at+}%G
zTkS@nqS<eZ-<uvvBQf~_?qZdFy>r3S<cG*NhQ_D$S}eg9OH0R(;v6FK*S}@36->x2
zt$6KVh3$J)S5qFoIr1AVu4sJKrGNCXL*(hRZl_xjH7?;(6+k(U@6h4YCkS_9qfih1
zs^^6|(#GtHA==daEsQ_D;u(j%7o=tfX^p?AN?o1SvUdRu4`_Q^ZV#X=Q?OxQx^=I7
zYfiFTb<`A3c1|8)DEL~G7cM@IJ*R?wx7wRrE96I;5}P~Z5FS^%pqI6z8EJj^-Tdf#
zFbq*;#=TU0Z62bM5PjYT_M-=7qWs?Ad4S;F_oHJzuS%1?$V5J6NJLR><nj(F)heXo
zv%-7N_Vk#eRU#H}h3a{imqa%{4y~leI%p1XAg-J>WSBIuzslM-l@jxy&GbU476bw<
zQLg6_o9Zicpy<9_>|Dw?Zfg!o^x*m#E;6gsYQ9mo+pPNR_IJLKnIQU0Zvp8hnbFz^
zZlx%2E9dpHPQGV~5rR3X8seiQ$+DrG9$m1<ElI&?G_Gu10y)W!1qD`vx+pEN;SX-l
z7Lr{vS`*E%IVo7Fy?&)wnVpGueWb=5*gZxSPRzXCm16OtWb8h>T`Fe5bp3`@&;I8F
zwi_Sw2D{4=q|a~M$P#NaXEU358`%R&($hwL6}Zxr5k0c1HU{HOJeP8Dl!0Xmkj<9j
zDa`sN2<z}EuVGaCiHqLLi95CuER&Iw-P2~;;Y$IS>JqQoGPB3ffy7oX<_LZI>)W&e
z#>O>IdB4q+@@c!-$6#NiI4<064SXF}oxn(I;4JuK&acRbpFtpc$@1x7I}G<QFLW)6
zeX{^ICe+}~*Au`YrSZAf8LX`dQF+T<wl3Hkh-1IdT)i@sZpB+of7azz0_!A8kmK~;
zwT`;N#06HyGCZ3xuc=Y8F)zE1SUa|D=E;-Tj(AbpZ^_qRRteJ2LUtq<55+&T?Q{$z
z2ECXMThBqvGMz&JiT%}U{lz|nLrdC<LJer!YlfanmCM=n6!1cWtfzCM{B1v&wGFMC
z$+>GaW_?^58)7IYb5ymgF+XSOo$W8NuvE%<=WJPLzWWHgykC?Dbd`M#jM~`@n{aGi
zuAHkaQk-*!JCA51KRx=o<q#)unK!Dq%q1r{j!I~bY|ULR^o{M|mtvNcNEg{iRITzp
z%_|1R*#(~B@m!np>h#=xg4(xBJiUv+8&q78L5lgR%c4>JX0V_=CmN&AIMJDcqd*3l
zZil7*8Vi?UmjN>SO?3(2_H&bq8oWa|>n_=r$f2~Oc~-SK)ZC5n=X83>78{OAm}|;?
zDfLm=-t=X{);}J+ez4Cbds!s=IG8@1=D7sA?k+XZQuBv8eSvyHR`y^_6nzgJ-Ke(^
zF-=2y_zdYi*$k?e-&X~14H@^%Mt|&JFfZ`4v!1o$CD~z-9%a>gcUdaiI$D9^T3Re&
zMzn7}h?*K>?2v2AwrG>QYATWf_X~8G?cQW8BMotU$*UMU)H_t?9gjWZ*N!P7okLMB
zgt3yXN9Wn>D#Z4Z%DVtNVgnp?*xBC+p^{lWdUBNLc|-veyWcv+TwfWyXV1WnTPTjB
z&wm~2(bv!vt2~Mgv=+)aCf|&__u>xmAq2St4E*^M-<P<M-W~%{^fCJWiknpUt&W{5
zGc;gq2?uFmoKdaJ4XHP1F}N3}m@nU_74&7kKeXIev2~SrRB-fQpzdy>&Y~T{vtdq%
zwTdwx4WCl>A=hIpq<0Zyt#2y1qG+mHb8y$nBXmg$7`*qm;9GTk#hGmPYZJS5g$qso
z)*2Vs$vM`%d=g$ZCw2uE25X;Z;Th)%Fr?1hlvJqUIS#DNn5a2BiQp}@I$S<Du&Nw%
zlPruYopNjLF0SfG6Tp00f!-dQ%r+{c26Af$>mLk8%QuLC)ViHiryE*q&zu2&z4FxS
zdQC!N*+Cr5{Q*8OD2(L6gQ!at`AYYCgzsWLXyko-(z^RP+IXp2imV_rnFP(3Ct!0B
zwvt?yJA-~YzqU-Jxf<5wcAL>4!u*@JbWP2q()ReI(t2d}x3_?h<mUZuYUL>A{c^?N
zJb~fd2|H_rlBtQDvB9Mj*CX{l`FfQ*Njfd%?K9fy0<0R9eBC*K@VtnKMYUe$ZEui;
zsFZDGAJQq3I#033gxV!jSM3a!8QcEtx)ffrw7ULr5ZYAONoZz*)o?Fci><}Le1<Z9
zhWv7VNY`x_gAZYu?||Jpra14CT94-+Yt#IlV2SdS+Onxhj;|U#q|GkyeQ7vKYoQpb
zKC<+u4Lo1;I(0^porH1x<z4!#qpNG;iT(|112vIyy}UFZF6Hmi0xma;Ff&Bc5n-&V
zThGns+w=Ry?eN^NX0ZR%bJ4}H*nW>{#`*ORYVi`2t*Fc1oO=9y7E{|asDKdAGP#X-
zj1Y5m);ojo3uSdP5jBvbHs<C$4v8i!SYk!WxkM$s@dTYso|&@JV2V3;MV6%~m!5rH
zq^ZfjP^X5e?_0m0R6>Qh)E%*R?Y`c$yyo=O(S0zG@=c%4`K*S(Zc-a72D{G{MPn3Q
z(v!y4+&-kq+?i4Pq}_Gt-QIK=4SsJ$Ck_Quo_3zSmk&%YAJ`+t%i6>wtN`=Bk-)ea
zmhQqP8na@?O3UTjvm7Xg(jB5N?aVy<$XwXkeDl)tmVt^8M&UA!A$h$(z8`@x0*0c}
z)I+V^o}z~R{af<)iPj_L1Ff|##oJx0q3dv<xvrEU63`{p6vj-ZzQ;}Pl`+e77A5lR
z+V?ExeNToR&xCn5l5Qr!yhO{~CH;X8juxJ!gd@w$u;n9gR1GJ;!WTBt23pb>jVC{P
zKpG44{uZ(*^U(&;EgVTtcYb7cF(>Ps(7@>J^BOX-pWkp4Y<mc`c<JqKgmR2A!^c>X
ztb0Vo&!}CjYI4Lz7X@3o#@x9rnrh7YK#f^3UCx~|NT_t?%>6j2pq{lrhgu$AZ(5<D
zt-Kq%`Ng48^e@IBe7uqdnsCi`ZOqi<5_7Wxtx8l}GP)XG(#*8?c{L6nf{)Hq1|NtY
zRw)l&y`L5|#Koct5!OQ}e~MwHdoHn`uX?!JZva;>PE4;6V!nv*D&>^tO~Hg~+eU}m
zEbd9?+%!niXF!ck(F~M~X!^3q6G6Z%f}UR;#J0EjO9I@9cSOAprpVhCMwxt^WcbyW
z_N(IZj+v+BqNR5@{O)l3E=$zxiF_MqHQ@sc_rtNwUqx0N0rpi(K^I-I$CN-Z?zE{;
zDwakL_(&6giHnyd7q-m85&mqDH<ZgJEW*&)c1eTD&wFY`g#6mfTGzlC(3P0%1Tps9
zILZd+Sra2i1BfDBR-e)~-Bt=?XnMuDv$11RHdk!ZE(cP~k%jC$!O1)%x#x+DX)AQ@
zsr@#cmifI!L2|IBv$_0DAv*1x?JGg`@!s)j9Aq^JZy4?<=5%5Da`FZzQ45uAAs782
zrBe!+W2gdiOeI)VYu%$jYf*5MH9xQZoo__vJ#K!1Oj(+)0g?HH{htV3xDU&ANa^H#
zPNg%K&K-dquUX9qa+qe2@}t8$t4Ic##ma>2l;vG#%$o<vh&M(!?IRiYgIw)Q`z}w9
zBd~5qD!HLtR6Da&f;6nxAPF?>HWC~pvTI~YPXe2^e2v<(W(~fY%H6m$lv!jEs-hYm
zM-(R%yRN99THnFHEL3LOLj(BIeyixphvAHG=iSSz7VN?1vV!Uz$|Wt4-DWj?<&Lu<
zw7s0JF3bI4=k&q;rrfj_>A8G8OD{H6y}C_x!55ff%i?C_J|FY-xmx#TR)v_Pg0m`I
z?p<8$%1T+k8HF>V{(`#n!k}6icG7u&WW@@lKOCtk*`IsN7D+<~9K3WB=*||I)@BxN
zQfT3jr#fyx4UfWZs?4RTHdZ^Gk$kL4rc-APvMG$=ecD1=digk#%BNF5?rir2dP@bm
z?_f~S-yB3-u9K*~gVfC31=(vF-Eb^QL$vxNSS~eTuge?>RGO|D%lXxh4RBq`PU}9`
zGMS|F$|AC=eQ#nVMrg;((~@F%C3DUoP^R_qKF3WQ!?H)1%zB!FS6kA))`L#JnPJd)
z(K5Wx%Go0%xvsSGwdOvDqu!(<t?`d{H^&3>0|LY3sKq_2-{R;iBd;F72WrO1H|hAm
zTZnxB*9T0FOh=9M(D2?W-Rt&!vO#Mf#NRi2U3Bc@psH-7tDrdhA_bG*l~pb_-(pel
z?uO6XOIrd?@j=^lSNN!s>6374WliMjy<^&y5`JpgeJv`<RY@3O<5YZR>!Y0N2RSSE
zG*?~DcaYK1J{oEA5@Ma5uwyKB;T38L|F-f}<4e3o2iNu0g;$q6<BjTRYJKh}*s&?5
z8P4ged20N4;0`{#PW)atoQA?G%|HGi!3^(g+x}4j`J6I^D7Xi<H}Qf72kM3vR8tv$
zAFAln8n`6bRjuaET5%Kcsu;Qlw%U5C^BBc!X|u&A1@jyl6Nq?Cl0JW*8<hvn9w`5s
zm1>CDUULbj!>-zN5~aLB8PUAKYiP&&$2mS^WP?t*9Ol;RC<$;s-xJ_3=QM8G4LsX5
zvbRDvXz3tBrDWP9h}PwsAED@2B_qW$v-89J(R%ZHbvEfDsfuKp8*`TH3mwPH?J;%k
z0beY%sBvS_4?}V6#RVl4>Whix`y@M7F}$71`Cfr*vt`=y?hl<MN;L&V<nOAg`G%x<
z0$#N1v6NhXUfM>x!#nt%8+>_u%&CB#K9;!Xb9RNc(;bFS8y`ti7T-6_>4@V)cM#U=
z(=#925Sov>-j?sC35<qk0+mOXEy(U*onk#ka~>OI=v$^vi5e64-0x3a{dl9haep7F
zQ<hSiF<;5gvLSP1um4=^-7|G^@{Ik$c_RKH;nGm~wvNzTdA&BwQ^5w`<&^9%lwk@Z
zP9vI+NNHpq_B$5>TC<5lqA!zm%zk;LYf1sp)G4|+mc4+_nzIqty+<GaA~wg-v;IcU
z<+>{=KlBSZ??&pkFQpbvCy{H`3CbUJi-2B*keE4d-NOuQ$SjOOmv^~5)<DY}hkIHt
zieGY!T`a4b4ceM%_-fi~RD%y}WjeeWmHTM!)>1O%FqvS6U94^Dr6p4vpZryNQ%e&=
zlUF)CzNr@I`L#!?5#zqu)rhoC-p$R3FByugXKoZR4=7clC_m5T-D@wq+Mume=ojEz
zx6;R1|K8E!^(_Vwi*iWQ`|bibTVYiETWVm<7bhUXe_4xthO$q3>ej<^$Bl8<AL+;(
z>0e<HxmDI&6Qknvs%V#8hPm4@69nUmybpYzp1?ZxfY+Os>BzLVA~+c?DHRH|rD@Ac
z8u5%ydtlUgwv645f_-!!@cdka>4&}>z1I<H%HrFG?D(k4ILG6PxP6@0y_&W{naew_
z;;oxmcgh8?sLK4@(t7Fn2r<q0%tpDa_*Lz3V{2z}rgE2zw#9AwYdd+b$11&~b*5q-
z7?Vs!dc9p6Sz^D>IpzQ2S<P{ll0)<M=v4$QiuL&o*Tg1+A(dx^72?<{#yZb3kc=q;
z6vf%8XcgGhRp}l5IZL)xCDxmhKc^9iDa2!S!gqZ>4aY?a(0E&Q-W`p+_#Ntfu`11~
zHrKsGd2cItcT#WXt6H0@m+D<X&#il|6HVIu>l`nX>mOIUis~w@QV*L=5728n98#JL
zG)iV%A}n8Q{LuNpkkiKtuH+K-u|{xu+IbK;Y5Ip+VEpjahf@V=-(rC)!L*Rlxaz5<
zf#Hpg3ye#;-~hyGv2iDl!K>+7C$E=2uoa2UpU(suBIQ6bK5ikD^6ni=t!XW$$1OrH
zQsGqd&mHJTKaJYoE+Vpc*y797&E!(uDW{TO@W`{}gMu{~JVb2e4#=%9_f0j-)9=xw
zY`lRrnsw*#l9T=QnAWah4rRmddwG+gdg#fs6xmi4^PlS3;y!0PF^RZ+cQulFAJh@l
zv%H_PNRBJ<pS~5aqqkGjX0i=)nBvbs_epnb1mEv1nz>89$kdv~_-(f%Y&nf-*Rj3b
z=nm{=dUU)8)nL->e8QW2TpE`<gGs&PCztvaVn3}g(=dr>X=WxJM1JU%?>4!EBl(No
zMHZS*GM@Pvmz=4mcdMFp@83$aY8=t+ne<I<)E+m<{bKc022NaJ(a}lf<V-vS&ACl?
z<e>k^8`b9=^qtkj=cmY2$i1OM`BlCh?Rf4-#dF5HQpYN@%T8pL0;xQ*2ODq9)o(AV
ztY81+5X2@n##NpHuV8cD{?x2fsS}V1{$V`yliaC))$U^NcmNR*aWF<nNmpG->5mgJ
z!Z}!~f1H%s8(rp*pSi*jhMcQ_%m*28QwD2E4VK8885JyMo}lU_nq=r@L6Mjsr{?B%
zo5AK*Q)3Ea1%}&!l5m({javBPm0(sd*XxPcpJ_iAr#y%=^pG#u&r=xoK=i*RCG`|V
zSe8&Wg#tpr!e9fPY&Ox&!jfCdIW>{rgf<%F3XD5b&TfXk_0W_Mnxmb2qIG?-PKVQu
zPyLcCKbPp2ptrFWk1Yc}S>R1(o*;SSllke+MYhr<N+mry`^YCkGBcm!GmYtEmR|GJ
zL5=9j^-k;aT~609#UD8oIj^e$s2CxR0$C(9dShbxn%Q5Z7iPKfhw8Y_`K$NhP{c<0
z4>;xaxDV5cOp{XG;uXPwJ)3cEUio2>zQXbEyDwcNbclY6y5&?J4W0oVsQc9yAz}g>
zTxRBKiaKvKeWn9#W?v7PR|_yx%pj_J)-Uln@Yp=vzUQg=3TGa@e287;ZBkB7k}O1*
z)vk}X_u|Cy8m4E10-uJ<KPX!tCLCR!#}JMvO|&%OC|4H|q^+wBTExf2jc|lXL?kWe
z<Ay{zq45A4v^@qZ!?RJ_$OFLG%J3MAX@Rudl+X?sH9s8Mz)#x{<>!Qg+49KAQcL^5
z2>>o=JQCpJ;*9lx`^fN|;=&2<Ct@HE;8X?gB*SB(r3+AU#i0RE5vT}A7~zBQg7C;v
z1Eg`bc5r=VmERDAmJE*r9`6PR0=>PxMZ85tTyge5FboC*f*?Q$M3|r<?BR>WBYlLi
z9=s<Izc7^19w;2f4Ucif0!}cIHm;s{86F-&Kj4q}T->y@{)ESR{APi`2ha!U1_X<M
zfG#e;zgl?U5ncq4-vRws3lBrWNiR?z?cwT)L!l8~Xe^%huMoDVKkeN-an7gd*rI@F
zXS54J)q~&_{5O}X>RP&gTAWZ|k8yE3wIY!HH%&ao?muMxEw+=M({%nC2*LbM+`no6
zk^8AKK}$;uuI!5PJPA)-S%&AtKit+8g|UU7zKWx5Q4&xav@i&SvJ-}iBay<AP>`sw
ztt1ixLyOr!U@+0YK&fLr@JK8QeF8-Q7r_v4By6Ej7!+nBjFbS`2t#d9AYn-)6e27p
zhJt{Q;xHr%W&0Nh9UO*Gl}P8mMs)&Zdjcg66&Dqg5EVv)#l(f7wh|HqC<!}Zu*69q
zC<qh=vpI#bMZr~EaV|*0aAI7L_Gq9R*8a5PgmAcmuDT2lL<IC7iLNseZ$~g7%mED6
z*45kNKV60x7qkH$dBP`H94aXR1B0MqFbN4!$zO?|BHlpbJP5UTf(izSi2g!885lSr
z9Rjt;lS(B3oWc^afh*zANW3e~(ACvhhUWwVaAJ8{-~j1g!=i@qAZYlW)co(NH$c1p
zYW<o7&Y06K0N}K6;YidkCmu*I^e;jQcE7q%4oIv$nlQtEm((9}%zqg!TbPZQq^-E5
zup|l!C2&j_I7v|m;bsE{L6D+okhmo5G>t#eJzVYZ-bfr;!Jd#QAsa#oon`|N_)VtZ
z-}Sv6&?iiR2=f~R6$XI~K_Iv&2o4qF0sc-FcrvH|$W|Kozxa?oRrt#yK(PBIBP=e2
zwF>y>V)dJ^6AJ$yf4|4!|Iq^h`d=sih~Izd`j@VM#K1pN{<pgRrRyIt@Q;-Lt*-ww
zx~TuN-9cjsUqIf3%}lnalQ3Z;bjIeosxpz<$^Wr-{fUIiP0iGUh=}g($wmC=8r=ng
zkOHr+g`ij<BPQn(9!iId6GR^B$_j=iZ`OvIshU7%mGpA(OrAgEmW?LZUnn|su+2O8
z+*E>^ISM~O9*Auhe?U7eq%t{_k&i#cmgLA*s0EUcQ!@+nJ$v-fXzb&*{zF+Tvw&{8
x{9Te9nYF>RhF2ngw4-q<KmCmc80TQ>^uW)WTuS=I?F9Ek>IiM+V#S+5{{yx6HuwMl

delta 249
zcmZ4MI)!P1ay<h}v6E*A2N2Y7q;xPaFmM)lL>4nJ@ErkR#;MwT(m+AU64!{5;QX|b
z^2DN4hVt@qz0ADq;^f4FRK5J7^x5xhq=1Shdb&7<M6|x0agg(X0T1)kORSrktP9z5
z!V2SM6}mhOUmWnC$Xx3Z#nj2PrDKLz?Xd%*hDCpGc=7dUTy}C%xgEz;X>ibf!wRYH
zRU0A1tguwuTzS<uQ&-+wl%=!k7?e2G@#tM`rp}vPxvx9V)~;Ud^HnS~InWeJ6f+&k
hKPhp=Z9y?Z-2J(8>o0rv0{z3l;OXk;vd$@?2>@P{V6p%J

diff --git a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorCanvas.ed.tscript b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorCanvas.ed.tscript
index 59df87bd9..f7c373ed7 100644
--- a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorCanvas.ed.tscript
+++ b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorCanvas.ed.tscript
@@ -254,9 +254,13 @@ function GuiEditCanvas::onWindowClose(%this)
 
 function GuiEditCanvas::create( %this )
 {
-   GuiEditorNewGuiDialog.init( "NewGui", "GuiControl" );
+   AssetBrowser.setupCreateNewAsset("GUIAsset", AssetBrowser.selectedModule, "GuiEditCanvas.finishCreateNewGUI");
+}
       
-   Canvas.pushDialog( GuiEditorNewGuiDialog );
+function GuiEditCanvas::finishCreateNewGUI(%this, %newGUIAssetId)
+{
+   %assetDef = AssetDatabase.acquireAsset(%newGUIAssetId);
+   AssetBrowser.editAsset(%assetDef);
 }
 
 //---------------------------------------------------------------------------------------------
diff --git a/Templates/BaseGame/game/tools/materialEditor/gui/guiMaterialPropertiesWindow.ed.gui b/Templates/BaseGame/game/tools/materialEditor/gui/guiMaterialPropertiesWindow.ed.gui
index d1d46b2b1..43351bc82 100644
--- a/Templates/BaseGame/game/tools/materialEditor/gui/guiMaterialPropertiesWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/materialEditor/gui/guiMaterialPropertiesWindow.ed.gui
@@ -4445,6 +4445,7 @@ $guiContent = new GuiControl(MaterialEditorGui,EditorGuiGroup) {
                         VertSizing = "bottom";
                         Position = "0 95";
                         Extent = "212 25";
+                        visible = "0";
                         
                         new GuiBitmapCtrl(){
                            position="2 2";
diff --git a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
index cf2afc7b3..cb093ea21 100644
--- a/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/materialEditor/scripts/materialEditor.ed.tscript
@@ -38,25 +38,34 @@ function MaterialEditorGui::establishMaterials(%this)
    };
    
    //Material used to preview other materials in the editor.
-   singleton Material(materialEd_previewMaterial)
+   if(!isObject(materialEd_previewMaterial))
    {
-      mapTo = "matEd_mappedMat";
-      diffuseMapAsset[0] = "ToolsModule:matEd_mappedMat_image";
-   };
+      singleton Material(materialEd_previewMaterial)
+      {
+         mapTo = "matEd_mappedMat";
+         diffuseMapAsset[0] = "ToolsModule:matEd_mappedMat_image";
+      };
+   }
 
-   singleton CustomMaterial( materialEd_justAlphaMaterial )
+   if(!isObject(materialEd_previewMaterial))
    {
-      mapTo = "matEd_mappedMatB";
-      texture[0] = materialEd_previewMaterial.getdiffuseMap(0);
-   };
+      singleton CustomMaterial( materialEd_justAlphaMaterial )
+      {
+         mapTo = "matEd_mappedMatB";
+         texture[0] = materialEd_previewMaterial.getdiffuseMap(0);
+      };
+   }
 
-   //Custom shader to allow the display of just the alpha channel. 
-   singleton ShaderData( materialEd_justAlphaShader )
+   if(!isObject(materialEd_previewMaterial))
    {
-      DXVertexShaderFile 	= "shaders/alphaOnlyV.hlsl";
-      DXPixelShaderFile 	= "shaders/alphaOnlyP.hlsl";
-      pixVersion = 1.0;
-   };
+      //Custom shader to allow the display of just the alpha channel. 
+      singleton ShaderData( materialEd_justAlphaShader )
+      {
+         DXVertexShaderFile 	= "shaders/alphaOnlyV.hlsl";
+         DXPixelShaderFile 	= "shaders/alphaOnlyP.hlsl";
+         pixVersion = 1.0;
+      };
+   }
 }
 
 function MaterialEditorGui::open(%this)
@@ -843,6 +852,11 @@ function MaterialEditorGui::guiSync( %this, %material )
       MaterialEditorPropertiesWindow-->isSRGBCheckbox.setValue((%material).isSRGB[%layer]);
       MaterialEditorPropertiesWindow-->invertRoughnessCheckbox.setValue((%material).invertRoughness[%layer]);
    }
+   else
+   {
+      MaterialEditorPropertiesWindow-->RoughnessSlider.setValue((%material).roughness, true);
+      MaterialEditorPropertiesWindow-->MetalnessSlider.setValue((%material).metalness, true);
+   }
       
    MaterialEditorPropertiesWindow-->isSRGBCheckbox.setVisible(%hasOrmMap);
    MaterialEditorPropertiesWindow-->invertRoughnessCheckbox.setVisible(%hasOrmMap);
diff --git a/Templates/BaseGame/game/tools/resources/ReflectProbePreviewMat.asset.taml b/Templates/BaseGame/game/tools/resources/ReflectProbePreviewMat.asset.taml
index e136ff6b4..746181b76 100644
--- a/Templates/BaseGame/game/tools/resources/ReflectProbePreviewMat.asset.taml
+++ b/Templates/BaseGame/game/tools/resources/ReflectProbePreviewMat.asset.taml
@@ -9,7 +9,7 @@
         mapTo="ReflectProbePreviewMat">
         <Material.Stages>
             <Stages_beginarray
-                DiffuseMapAsset="ToolsModule:occluderProxyImage_image"
+                DiffuseMapAsset="Core_Rendering:NoMaterial"
                 diffuseColor="1 1 1 1"
                 roughness="0"
                 metalness="1"/>
diff --git a/Templates/BaseGame/game/tools/shapeEditor/gui/shapeEdAdvancedWindow.ed.gui b/Templates/BaseGame/game/tools/shapeEditor/gui/shapeEdAdvancedWindow.ed.gui
index 5ea1e4072..c98aa777f 100644
--- a/Templates/BaseGame/game/tools/shapeEditor/gui/shapeEdAdvancedWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/shapeEditor/gui/shapeEdAdvancedWindow.ed.gui
@@ -164,6 +164,7 @@ $guiContent = new GuiWindowCollapseCtrl(ShapeEdAdvancedWindow, EditorGuiGroup) {
                   hovertime = "500";
                   isContainer = true;
                   internalName = "levelsInactive";
+                  color = "128 128 128 255";
                };
                new GuiTextCtrl() {
                   text = "0";
@@ -691,6 +692,7 @@ $guiContent = new GuiWindowCollapseCtrl(ShapeEdAdvancedWindow, EditorGuiGroup) {
                };
                new GuiBitmapCtrl(){
                   bitmapAsset = "ToolsModule:inactive_overlay_image";
+                  color = "128 128 128 255";
                   position = "4 18";
                   Extent = "193 64";
                   tooltip = "Imposters must be enabled, and an imposter detail level selected to edit these properties";
diff --git a/Templates/BaseGame/game/tools/shapeEditor/scripts/shapeEditor.ed.tscript b/Templates/BaseGame/game/tools/shapeEditor/scripts/shapeEditor.ed.tscript
index f7181fd69..2be4dd630 100644
--- a/Templates/BaseGame/game/tools/shapeEditor/scripts/shapeEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/shapeEditor/scripts/shapeEditor.ed.tscript
@@ -1784,7 +1784,7 @@ function ShapeEdSeqFromMenu::onBrowseSelect( %this, %assetId )
    %this.setText( %assetId );
    
    %assetDef = AssetDatabase.acquireAsset(%assetId);
-   %shapePath = %assetDef.getShapeFile();
+   %shapePath = %assetDef.getShapePath();
    AssetDatabase.releaseAsset(%assetId);
    
    ShapeEdSequences.onEditSequenceSource( %shapePath );
@@ -3010,7 +3010,7 @@ function ShapeEditor::autoAddDetails( %this, %dest )
    // Determine the base name of the input file (MyShape_LOD in the example above)
    // and use that to find any other shapes in the set.
    %assetDef = AssetDatabase.acquireAsset(%dest.baseShapeAsset);
-   %shapeFile = %assetDef.getShapeFile();
+   %shapeFile = %assetDef.getShapePath();
    AssetDatabase.releaseAsset(%dest.baseShapeAsset);
    
    %base = fileBase( %shapeFile );
@@ -3058,7 +3058,7 @@ function ShapeEditor::addLODFromFile( %this, %dest, %assetId, %size, %allowUnmat
 {
    %assetDef = AssetDatabase.acquireAsset(%assetId);
    %csPath = %assetDef.getShapeConstructorFilePath();
-   %filename = %assetDef.getShapeFile();
+   %filename = %assetDef.getShapePath();
    AssetDatabase.releaseAsset(%assetId);
    
    // Get (or create) a TSShapeConstructor object for the source shape. Need to
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/editors/creator.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/editors/creator.ed.tscript
index fc047c19b..6f57ffd0f 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/editors/creator.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/editors/creator.ed.tscript
@@ -82,6 +82,7 @@ function ObjectCreator::setNewObjectGroup( %this, %group )
    %group = %group.getID();
    %this.objectGroup = %group;
    %itemId = EditorTree.findItemByObjectId( %group );
+   if(%itemId != -1)
    EditorTree.markItem( %itemId );
 }
 
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/editors/terrainEditor.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/editors/terrainEditor.ed.tscript
index 68d03f4e8..b570d3c59 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/editors/terrainEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/editors/terrainEditor.ed.tscript
@@ -136,7 +136,7 @@ function EPainter::updateLayers( %this, %matIndex )
             VertSizing = "bottom";
             position = ( %listwidth - 20 ) SPC "26";
             Extent = "17 17";
-            command = "EPainter.showMaterialDeleteDlg( " @ %matInternalName @ " );";
+            command = "EPainter.showMaterialDeleteDlg( \"" @ %matInternalName @ "\" );";
          };
       };
 
@@ -193,7 +193,7 @@ function EPainter::showMaterialDeleteDlg( %this, %matInternalName )
 {
    toolsMessageBoxYesNo( "Confirmation",
       "Really remove material '" @ %matInternalName @ "' from the terrain?",
-      %this @ ".removeMaterial( " @ %matInternalName @ " );", "" );
+      %this @ ".removeMaterial( \"" @ %matInternalName @ "\" );", "" );
 }
 
 function EPainter::removeMaterial( %this, %matInternalName )

From 5a83897edeafcb391ce58bab1187b2c50321a834 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Mon, 4 Apr 2022 01:41:40 -0500
Subject: [PATCH 350/399] Fixes names so assignment of ORM config map on
 terrain materials works properly again

---
 .../gui/guiTerrainMaterialDlg.ed.gui           |  6 +++---
 .../interfaces/terrainMaterialDlg.ed.tscript   | 18 +++++++++---------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainMaterialDlg.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainMaterialDlg.ed.gui
index 014771aed..5a7dc5102 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainMaterialDlg.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainMaterialDlg.ed.gui
@@ -536,7 +536,7 @@ $guiContent = new GuiControl(TerrainMaterialDlg,EditorGuiGroup) {
             profile = "ToolsGuiDefaultProfile";
                tooltipProfile = "ToolsGuiToolTipProfile";
             };
-         new GuiContainer(ORMMapContainer) {
+         new GuiContainer(ORMConfigMapContainer) {
             position = "6 314";
                   extent = "261 64";
                horizSizing = "width";
@@ -576,7 +576,7 @@ $guiContent = new GuiControl(TerrainMaterialDlg,EditorGuiGroup) {
                   profile = "ToolsGuiTextProfile";
                   tooltipProfile = "ToolsGuiToolTipProfile";
                   isContainer = "0";
-               internalName = "ORMMapAssetId";
+               internalName = "ORMConfigMapAssetId";
                };
                new GuiButtonCtrl() {
                   text = "Edit";
@@ -584,7 +584,7 @@ $guiContent = new GuiControl(TerrainMaterialDlg,EditorGuiGroup) {
                   extent = "40 16";
                   horizSizing = "left";
                   profile = "ToolsGuiButtonProfile";
-               command = "TerrainMaterialDlg.updateTextureMap(\"OrmConfigMap\");";
+               command = "TerrainMaterialDlg.updateTextureMap(\"ORMConfigMap\");";
                   tooltipProfile = "ToolsGuiToolTipProfile";
                };
                new GuiBitmapButtonCtrl() {
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript
index 1eb7af85d..4a7338c24 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/interfaces/terrainMaterialDlg.ed.tscript
@@ -262,8 +262,8 @@ function TerrainMaterialDlg::clearTextureMap(%this, %mapName)
       NormalMapContainer.callOnChildren("setActive", false);  
       %this.clearTextureMap("NormalMap");
       
-      ORMMapContainer.callOnChildren("setActive", false);
-      %this.clearTextureMap("ORMMap");
+      ORMConfigMapContainer.callOnChildren("setActive", false);
+      %this.clearTextureMap("ORMConfigMap");
       
       MacroMapContainer.callOnChildren("setActive", false);
       %this.clearTextureMap("MacroMap");
@@ -292,7 +292,7 @@ function TerrainMaterialDlg::changeTerrainMatMapAsset(%this)
       {
          //show the supplemental maps
          NormalMapContainer.callOnChildren("setActive", true);  
-         ORMMapContainer.callOnChildren("setActive", true);
+         ORMConfigMapContainer.callOnChildren("setActive", true);
          MacroMapContainer.callOnChildren("setActive", true);
       }
    }
@@ -377,13 +377,13 @@ function TerrainMaterialDlg::activateMaterialCtrls( %this, %active )
    if(%this-->texDetailMap.getBitmap() $= "" || %this-->texDetailMap.getBitmap() $= $TerrainMaterialEditor::emptyMaterialImage)
    {
       NormalMapContainer.callOnChildren("setActive", false);  
-      ORMMapContainer.callOnChildren("setActive", false);
+      ORMConfigMapContainer.callOnChildren("setActive", false);
       MacroMapContainer.callOnChildren("setActive", false);
    }
    else
    {
       NormalMapContainer.callOnChildren("setActive", true);  
-      ORMMapContainer.callOnChildren("setActive", true);
+      ORMConfigMapContainer.callOnChildren("setActive", true);
       MacroMapContainer.callOnChildren("setActive", true); 
    }
 }
@@ -438,7 +438,7 @@ function TerrainMaterialDlg::setActiveMaterial( %this, %mat )
       //
       %imgPath = %mat.getORMConfigMap();
       %imgPathText = %imgPath !$= "" && %imgPath !$= $TerrainMaterialEditor::emptyMaterialImage ? %mat.getORMConfigMapAsset() : "None";
-      %this-->ORMMapAssetId.setText( %imgPathText );
+      %this-->ORMConfigMapAssetId.setText( %imgPathText );
       %this-->texORMConfigMap.setBitmap( getAssetPreviewImage(%imgPath) );
        
       //
@@ -656,7 +656,7 @@ function TerrainMaterialDlg::saveDirtyMaterial( %this, %materialAssetId )
       %newNormal = "";
    
    //---
-   %newormConfig = %this-->ORMMapAssetId.text;
+   %newormConfig = %this-->ORMConfigMapAssetId.text;
    if(%newormConfig $= "None")
       %newormConfig = "";
    
@@ -995,9 +995,9 @@ function NormalMapContainer::onControlDropped( %this, %payload, %position )
    terrMatEdDragNDropMapAssignment("NormalMap", %payload);
 }
 
-function ORMMapContainer::onControlDropped( %this, %payload, %position )
+function ORMConfigMapContainer::onControlDropped( %this, %payload, %position )
 {
-   terrMatEdDragNDropMapAssignment("ORMMap", %payload);
+   terrMatEdDragNDropMapAssignment("ORMConfigMap", %payload);
 }
 
 function MacroMapContainer::onControlDropped( %this, %payload, %position )

From 6b28f1f15117333238ff4b4828f4b6a54342cf6e Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Tue, 5 Apr 2022 00:29:58 -0500
Subject: [PATCH 351/399] Fleshes out remaining missing editor settings
 entries/categories Makes GUIAssets exec scripts before the gui file to allow
 onAdd methods to work Adds missing getForestPath and getNavmeshPath methods
 and updates asset move logic to utilize them

---
 Engine/source/T3D/assets/GUIAsset.cpp         | 20 +++++++++---------
 Engine/source/T3D/assets/LevelAsset.cpp       | 14 +++++++++++++
 .../scripts/assetTypes/level.tscript          |  3 ++-
 .../convexEditor/convexEditorGui.tscript      | 10 ++++++++-
 .../tools/gui/editorSettingsWindow.ed.tscript | 21 +++++++++----------
 .../game/tools/meshRoadEditor/main.tscript    |  2 ++
 .../meshRoadEditor/meshRoadEditorGui.tscript  | 18 ++++++++++++++++
 .../game/tools/riverEditor/main.tscript       |  2 ++
 .../tools/riverEditor/riverEditorGui.tscript  | 14 +++++++++++++
 .../game/tools/roadEditor/main.tscript        |  2 ++
 .../tools/roadEditor/roadEditorGui.tscript    | 14 +++++++++++++
 .../worldEditor/scripts/EditorGui.ed.tscript  |  2 +-
 .../scripts/editors/terrainEditor.ed.tscript  | 14 +++++++++++++
 13 files changed, 112 insertions(+), 24 deletions(-)

diff --git a/Engine/source/T3D/assets/GUIAsset.cpp b/Engine/source/T3D/assets/GUIAsset.cpp
index 7c1aa1d0a..0ecff34ad 100644
--- a/Engine/source/T3D/assets/GUIAsset.cpp
+++ b/Engine/source/T3D/assets/GUIAsset.cpp
@@ -115,28 +115,28 @@ void GUIAsset::copyTo(SimObject* object)
 
 void GUIAsset::initializeAsset()
 {
-   mGUIPath = getOwned() ? expandAssetFilePath(mGUIFile) : mGUIPath;
-
-   if (Torque::FS::IsScriptFile(mGUIPath))
-      Con::executeFile(mGUIPath, false, false);
-
    mScriptPath = getOwned() ? expandAssetFilePath(mScriptFile) : mScriptPath;
 
    if (Torque::FS::IsScriptFile(mScriptPath))
       Con::executeFile(mScriptPath, false, false);
+
+   mGUIPath = getOwned() ? expandAssetFilePath(mGUIFile) : mGUIPath;
+
+   if (Torque::FS::IsScriptFile(mGUIPath))
+      Con::executeFile(mGUIPath, false, false);
 }
 
 void GUIAsset::onAssetRefresh()
 {
-   mGUIPath = getOwned() ? expandAssetFilePath(mGUIFile) : mGUIPath;
-
-   if (Torque::FS::IsScriptFile(mGUIPath))
-      Con::executeFile(mGUIPath, false, false);
-
    mScriptPath = getOwned() ? expandAssetFilePath(mScriptFile) : mScriptPath;
 
    if (Torque::FS::IsScriptFile(mScriptPath))
       Con::executeFile(mScriptPath, false, false);
+
+   mGUIPath = getOwned() ? expandAssetFilePath(mGUIFile) : mGUIPath;
+
+   if (Torque::FS::IsScriptFile(mGUIPath))
+      Con::executeFile(mGUIPath, false, false);
 }
 
 void GUIAsset::setGUIFile(const char* pScriptFile)
diff --git a/Engine/source/T3D/assets/LevelAsset.cpp b/Engine/source/T3D/assets/LevelAsset.cpp
index ab22c7488..f1dc398b0 100644
--- a/Engine/source/T3D/assets/LevelAsset.cpp
+++ b/Engine/source/T3D/assets/LevelAsset.cpp
@@ -391,6 +391,20 @@ DefineEngineMethod(LevelAsset, getDecalsPath, const char*, (), ,
    return object->getDecalsPath();
 }
 
+DefineEngineMethod(LevelAsset, getForestPath, const char*, (), ,
+   "Gets the full path of the asset's defined forest file.\n"
+   "@return The string result of the forest path")
+{
+   return object->getForestPath();
+}
+
+DefineEngineMethod(LevelAsset, getNavmeshPath, const char*, (), ,
+   "Gets the full path of the asset's defined navmesh file.\n"
+   "@return The string result of the navmesh path")
+{
+   return object->getNavmeshPath();
+}
+
 DefineEngineMethod(LevelAsset, loadDependencies, void, (), ,
    "Initiates the loading of asset dependencies for this level.")
 {
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/level.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/level.tscript
index 07ce53fce..479f3cf87 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/level.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/level.tscript
@@ -120,11 +120,12 @@ function AssetBrowser::moveLevelAsset(%this, %assetDef, %destination)
    if(%newAssetPath $= "")
       return false;
 
-   moveAssetLooseFile(%assetDef.getLevelPath(), %destination);
    moveAssetLooseFile(%assetDef.getLevelPath(), %destination);
    moveAssetLooseFile(%assetDef.getPreviewImagePath(), %destination);
    moveAssetLooseFile(%assetDef.getPostFXPresetPath(), %destination);
    moveAssetLooseFile(%assetDef.getDecalsPath(), %destination);
+   moveAssetLooseFile(%assetDef.getForestPath(), %destination);
+   moveAssetLooseFile(%assetDef.getNavmeshPath(), %destination);
    
    AssetDatabase.removeDeclaredAsset(%assetDef.getAssetId());
    AssetDatabase.addDeclaredAsset(%targetModule, %newAssetPath);
diff --git a/Templates/BaseGame/game/tools/convexEditor/convexEditorGui.tscript b/Templates/BaseGame/game/tools/convexEditor/convexEditorGui.tscript
index 0baf0eb70..bc067c746 100644
--- a/Templates/BaseGame/game/tools/convexEditor/convexEditorGui.tscript
+++ b/Templates/BaseGame/game/tools/convexEditor/convexEditorGui.tscript
@@ -247,4 +247,12 @@ function ConvexEditorDefaultMaterialBtn::gotMaterialName(%this, %name)
    ConvexEditorOptionsWindow.activeShape.setMaterial(%name);
 
    ConvexEditorGui.updateShape();
-}
\ No newline at end of file
+}
+
+function ESettingsWindow::getConvexEditorSettings(%this)
+{
+   SettingsInspector.startGroup("Defaults");
+   SettingsInspector.addSettingsField("ConvexEditor/MaterialName", "Default Material", "string", 
+                           "The default material when creating a convexShape");
+   SettingsInspector.endGroup();
+}
diff --git a/Templates/BaseGame/game/tools/gui/editorSettingsWindow.ed.tscript b/Templates/BaseGame/game/tools/gui/editorSettingsWindow.ed.tscript
index 52f7ff309..e104dea65 100644
--- a/Templates/BaseGame/game/tools/gui/editorSettingsWindow.ed.tscript
+++ b/Templates/BaseGame/game/tools/gui/editorSettingsWindow.ed.tscript
@@ -19,12 +19,14 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
-
-function ESettingsWindow::startup( %this )
+function ESettingsWindow::onAdd(%this)
 {
    new ArrayObject(EditorSettingsPageList);
    new ArrayObject(GameSettingsPageList);
+}
    
+function ESettingsWindow::startup( %this )
+{
    %this.addEditorSettingsPage("Axis", "Axis Gizmo");
    %this.addEditorSettingsPage("General", "General Settings");
    %this.addEditorSettingsPage("Camera", "Camera Settings");
@@ -303,13 +305,6 @@ function ESettingsWindow::getGeneralSettings(%this)
    //SettingsInspector.addSettingsField("WorldEditor/torsionPath", "Torsion Path", "filename", "");
    SettingsInspector.endGroup();
    
-   SettingsInspector.startGroup("Theme");
-   SettingsInspector.addSettingsField("WorldEditor/Theme/backgroundColor", "Background Color", "colorI", "");
-   SettingsInspector.addSettingsField("WorldEditor/Theme/windowTitleBGColor", "Window Title Color", "colorI", "");
-   SettingsInspector.addSettingsField("WorldEditor/Theme/windowTitleFontColor", "Window Title Text Color", "colorI", "");
-   SettingsInspector.addSettingsField("WorldEditor/Theme/mainTextColor", "Main Text Color", "colorI", "");
-   SettingsInspector.endGroup();
-   
    SettingsInspector.startGroup("Layout");
    /*SettingsInspector.addSettingsField("WorldEditor/Layout/LayoutMode", "Editor Layout Mode", "list", "This dictates which layout style the editor should use." @
                                                                                                       "WARNING - Modern layout is highlight experimental." @
@@ -327,7 +322,7 @@ function ESettingsWindow::getCameraSettings(%this)
    //Based on currently loaded level(rootScene)
    SettingsInspector.startGroup(EditorSettings.value("WorldEditor/newLevelFile") @ " Camera");
    SettingsInspector.addSettingsField("Camera/cameraMinSpeed", "Camera Speed Min", "float", "");
-   SettingsInspector.addSettingsField("Camera/cameraMaxSpeed", "Camera Speed Max", "200", "");
+   SettingsInspector.addSettingsField("Camera/cameraMaxSpeed", "Camera Speed Max", "float", "");
    SettingsInspector.endGroup();
 }  
 
@@ -365,7 +360,8 @@ function ESettingsWindow::getSceneEditorSettings(%this)
    
    SettingsInspector.startGroup("Misc");
    //SettingsInspector.addSettingsField("WorldEditor/forceLoadDAE", "Force Load DAE", "bool", "");
-   SettingsInspector.addSettingsField("WorldEditor/forceLoadDAE", "Force Load DAE", "bool", "");
+   SettingsInspector.addSettingsField("WorldEditor/Tools/dropAtScreenCenterScalar", "Screen Center Scalar", "string", "");
+   SettingsInspector.addSettingsField("WorldEditor/Tools/dropAtScreenCenterMax", "Screen Center Max", "string", "");
    SettingsInspector.endGroup();
    
    SettingsInspector.startGroup("Layout");
@@ -444,6 +440,9 @@ function ESettingsWindow::getPostFXSettings(%this)
    SettingsInspector.endGroup();
 }
 
+function ESettingsWindow::getObjectEditorSettings(%this)
+{
+}
 //
 // COMMON GAME SETTINGS
 //
diff --git a/Templates/BaseGame/game/tools/meshRoadEditor/main.tscript b/Templates/BaseGame/game/tools/meshRoadEditor/main.tscript
index 438133bef..1ff15ebde 100644
--- a/Templates/BaseGame/game/tools/meshRoadEditor/main.tscript
+++ b/Templates/BaseGame/game/tools/meshRoadEditor/main.tscript
@@ -82,6 +82,8 @@ function MeshRoadEditorPlugin::onWorldEditorStartup( %this )
    // Add ourselves to the Editor Settings window
    exec( "./meshRoadEditorSettingsTab.gui" );
    //ESettingsWindow.addTabPage( EMeshRoadEditorSettingsPage );
+   
+   ESettingsWindow.addEditorSettingsPage("MeshRoadEditor", "Mesh Road Editor");
 }
 
 function MeshRoadEditorPlugin::onActivated( %this )
diff --git a/Templates/BaseGame/game/tools/meshRoadEditor/meshRoadEditorGui.tscript b/Templates/BaseGame/game/tools/meshRoadEditor/meshRoadEditorGui.tscript
index 0c8533875..070f7eac1 100644
--- a/Templates/BaseGame/game/tools/meshRoadEditor/meshRoadEditorGui.tscript
+++ b/Templates/BaseGame/game/tools/meshRoadEditor/meshRoadEditorGui.tscript
@@ -211,6 +211,24 @@ function MeshRoadEditorGui::prepSelectionMode( %this )
    ToolsPaletteArray-->MeshRoadEditorSelectMode.setStateOn(1);
 }
 
+//------------------------------------------------------------------------------
+function ESettingsWindow::getMeshRoadEditorSettings(%this)
+{
+   SettingsInspector.startGroup("Defaults");
+   SettingsInspector.addSettingsField("MeshRoadEditor/DefaultWidth", "Width", "string", "");
+   SettingsInspector.addSettingsField("MeshRoadEditor/DefaultDepth", "Depth", "string", "");
+   SettingsInspector.addSettingsField("MeshRoadEditor/DefaultNormal", "Normal", "string", "");
+   
+   SettingsInspector.addSettingsField("MeshRoadEditor/TopMaterialName", "Top Material", "string", "");
+   SettingsInspector.addSettingsField("MeshRoadEditor/BottomMaterialName", "Bottom Material", "string", "");
+   SettingsInspector.addSettingsField("MeshRoadEditor/SideMaterialName", "Side Material", "string", "");
+   SettingsInspector.endGroup();
+   
+   SettingsInspector.startGroup("Colors");
+   SettingsInspector.addSettingsField("MeshRoadEditor/HoverSplineColor", "Hover Spline", "colorI", "");
+   SettingsInspector.addSettingsField("MeshRoadEditor/SelectedSplineColor", "Selected Spline", "colorI", "");
+   SettingsInspector.endGroup();
+}
 //------------------------------------------------------------------------------
 function EMeshRoadEditorSelectModeBtn::onClick(%this)
 {
diff --git a/Templates/BaseGame/game/tools/riverEditor/main.tscript b/Templates/BaseGame/game/tools/riverEditor/main.tscript
index b8be4ede9..3911b048c 100644
--- a/Templates/BaseGame/game/tools/riverEditor/main.tscript
+++ b/Templates/BaseGame/game/tools/riverEditor/main.tscript
@@ -82,6 +82,8 @@ function RiverEditorPlugin::onWorldEditorStartup( %this )
    // Add ourselves to the Editor Settings window
    exec( "./RiverEditorSettingsTab.gui" );
    //ESettingsWindow.addTabPage( ERiverEditorSettingsPage );
+   
+   ESettingsWindow.addEditorSettingsPage("RiverEditor", "River Editor");
 }
 
 function RiverEditorPlugin::onActivated( %this )
diff --git a/Templates/BaseGame/game/tools/riverEditor/riverEditorGui.tscript b/Templates/BaseGame/game/tools/riverEditor/riverEditorGui.tscript
index bb0f40037..e70c02bbf 100644
--- a/Templates/BaseGame/game/tools/riverEditor/riverEditorGui.tscript
+++ b/Templates/BaseGame/game/tools/riverEditor/riverEditorGui.tscript
@@ -214,6 +214,20 @@ function RiverEditorGui::prepSelectionMode( %this )
    ToolsPaletteArray-->RiverEditorSelectMode.setStateOn(1);
 }
 
+//------------------------------------------------------------------------------
+function ESettingsWindow::getRiverEditorSettings(%this)
+{
+   SettingsInspector.startGroup("Defaults");
+   SettingsInspector.addSettingsField("RiverEditor/DefaultWidth", "Width", "string", "");
+   SettingsInspector.addSettingsField("RiverEditor/DefaultDepth", "Depth", "string", "");
+   SettingsInspector.addSettingsField("RiverEditor/DefaultNormal", "Normal", "string", "");
+   SettingsInspector.endGroup();
+   
+   SettingsInspector.startGroup("Colors");
+   SettingsInspector.addSettingsField("RiverEditor/HoverSplineColor", "Hover Spline", "colorI", "");
+   SettingsInspector.addSettingsField("RiverEditor/SelectedSplineColor", "Selected Spline", "colorI", "");
+   SettingsInspector.endGroup();
+}
 //------------------------------------------------------------------------------
 function ERiverEditorSelectModeBtn::onClick(%this)
 {
diff --git a/Templates/BaseGame/game/tools/roadEditor/main.tscript b/Templates/BaseGame/game/tools/roadEditor/main.tscript
index 4f9e7ad7a..60a0fe538 100644
--- a/Templates/BaseGame/game/tools/roadEditor/main.tscript
+++ b/Templates/BaseGame/game/tools/roadEditor/main.tscript
@@ -81,6 +81,8 @@ function RoadEditorPlugin::onWorldEditorStartup( %this )
    // Add ourselves to the Editor Settings window
    exec( "./RoadEditorSettingsTab.gui" );
    //ESettingsWindow.addTabPage( ERoadEditorSettingsPage );
+   
+   ESettingsWindow.addEditorSettingsPage("RoadEditor", "Road Editor");
 }
 
 function RoadEditorPlugin::onActivated( %this )
diff --git a/Templates/BaseGame/game/tools/roadEditor/roadEditorGui.tscript b/Templates/BaseGame/game/tools/roadEditor/roadEditorGui.tscript
index 115da9d5c..5861fb164 100644
--- a/Templates/BaseGame/game/tools/roadEditor/roadEditorGui.tscript
+++ b/Templates/BaseGame/game/tools/roadEditor/roadEditorGui.tscript
@@ -212,6 +212,20 @@ function RoadEditorGui::prepSelectionMode( %this )
    %this.setMode( "RoadEditorSelectMode" );
    ToolsPaletteArray-->RoadEditorSelectMode.setStateOn(1);
 }
+
+//------------------------------------------------------------------------------
+function ESettingsWindow::getRoadEditorSettings(%this)
+{
+   SettingsInspector.startGroup("Defaults");
+   SettingsInspector.addSettingsField("RoadEditor/DefaultWidth", "Width", "string", "");
+   SettingsInspector.addSettingsField("RoadEditor/MaterialName", "Material", "string", "");
+   SettingsInspector.endGroup();
+   
+   SettingsInspector.startGroup("Colors");
+   SettingsInspector.addSettingsField("RoadEditor/HoverSplineColor", "Hover Spline", "colorI", "");
+   SettingsInspector.addSettingsField("RoadEditor/SelectedSplineColor", "Selected Spline", "colorI", "");
+   SettingsInspector.endGroup();
+}
 //------------------------------------------------------------------------------
 function ERoadEditorSelectModeBtn::onClick(%this)
 {
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
index 11b3b06d4..a10c44c87 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
@@ -156,8 +156,8 @@ function EditorGui::init(%this)
    // Editor Settings Window
    if( !isObject( %this-->EditorSettingsWindow ) )
    {
-      exec("tools/gui/EditorSettingsWindow.ed.gui");
       exec("tools/gui/editorSettingsWindow.ed." @ $TorqueScriptFileExtension);
+      exec("tools/gui/EditorSettingsWindow.ed.gui");
       
       // Start the standard settings tabs pages
       /*exec( "~/worldEditor/gui/GeneralSettingsTab.ed.gui" );
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/editors/terrainEditor.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/editors/terrainEditor.ed.tscript
index b570d3c59..4cc998f6a 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/editors/terrainEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/editors/terrainEditor.ed.tscript
@@ -29,6 +29,8 @@ function TerrainEditor::init( %this )
    %this.setBrushSize( 9, 9 );
 
    new PersistenceManager( ETerrainPersistMan );
+   
+   ESettingsWindow.addEditorSettingsPage("TerrainEditor", "Terrain Editor");
 }
 
 ///
@@ -356,6 +358,18 @@ function TerrainEditor::onMaterialUndo( %this )
    EPainter.updateLayers();
 }
 
+function ESettingsWindow::getTerrainEditorSettings(%this)
+{
+   SettingsInspector.startGroup("Tool Values");
+   SettingsInspector.addSettingsField("TerrainEditor/ActionValues/adjustHeightVal", "Raise/Lower Height", "string", 
+                           "The amount of height adjustment for raising/lowering terrain");
+   SettingsInspector.addSettingsField("TerrainEditor/ActionValues/smoothFactor", "Smooth Factor", "string", 
+                           "The amount of smoothing when raising/lowering terrain");
+   SettingsInspector.addSettingsField("TerrainEditor/ActionValues/noiseFactor", "Noise Factor", "string", 
+                           "The amount of noise when raising/lowering terrain");
+   SettingsInspector.endGroup();
+}
+
 //------------------------------------------------------------------------------
 // Functions
 //------------------------------------------------------------------------------

From ed33c70a23e6dbcf08c0e2bb1c2a4ecd757b0dac Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Tue, 5 Apr 2022 18:54:09 -0500
Subject: [PATCH 352/399] display the item to be spawned given a valid
 datablock name, use that meshes shape to display the spawnsphere mesh, rather
 than the default one

---
 Engine/source/T3D/missionMarker.cpp | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/Engine/source/T3D/missionMarker.cpp b/Engine/source/T3D/missionMarker.cpp
index 005ec3491..27785d627 100644
--- a/Engine/source/T3D/missionMarker.cpp
+++ b/Engine/source/T3D/missionMarker.cpp
@@ -433,7 +433,23 @@ void SpawnSphere::unpackUpdate(NetConnection * con, BitStream * stream)
       mSpawnTransform = stream->readFlag();
 
       stream->read(&mSpawnClass);
+
+      String oldSDB = mSpawnDataBlock;
       stream->read(&mSpawnDataBlock);
+      if (oldSDB != mSpawnDataBlock)
+      {
+         ShapeBaseData *spawnedDatablock = dynamic_cast<ShapeBaseData *>(Sim::findObject(mSpawnDataBlock.c_str()));
+         if (spawnedDatablock)
+         {
+            delete mShapeInstance;
+            mShapeInstance = new TSShapeInstance(spawnedDatablock->mShape);
+         }
+         else
+         {
+            delete mShapeInstance;
+            mShapeInstance = new TSShapeInstance(mDataBlock->mShape);
+         }
+      }
       stream->read(&mSpawnName);
       stream->read(&mSpawnProperties);
       stream->read(&mSpawnScript);

From e1a127715e7b32c639066d714e8930bfadab68ec Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Tue, 5 Apr 2022 20:17:51 -0500
Subject: [PATCH 353/399] sanity checks

---
 Engine/source/T3D/missionMarker.cpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/Engine/source/T3D/missionMarker.cpp b/Engine/source/T3D/missionMarker.cpp
index 27785d627..1bd19ae68 100644
--- a/Engine/source/T3D/missionMarker.cpp
+++ b/Engine/source/T3D/missionMarker.cpp
@@ -438,16 +438,16 @@ void SpawnSphere::unpackUpdate(NetConnection * con, BitStream * stream)
       stream->read(&mSpawnDataBlock);
       if (oldSDB != mSpawnDataBlock)
       {
+         delete mShapeInstance;
          ShapeBaseData *spawnedDatablock = dynamic_cast<ShapeBaseData *>(Sim::findObject(mSpawnDataBlock.c_str()));
-         if (spawnedDatablock)
+         if (spawnedDatablock && spawnedDatablock->mShape)
          {
-            delete mShapeInstance;
-            mShapeInstance = new TSShapeInstance(spawnedDatablock->mShape);
+               mShapeInstance = new TSShapeInstance(spawnedDatablock->mShape);
          }
-         else
+         else if (mDataBlock)
          {
-            delete mShapeInstance;
-            mShapeInstance = new TSShapeInstance(mDataBlock->mShape);
+            if (mDataBlock->mShape)
+               mShapeInstance = new TSShapeInstance(mDataBlock->mShape);
          }
       }
       stream->read(&mSpawnName);

From 976c0bca7915623e764a050da0eb0166db09c335 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Wed, 6 Apr 2022 01:08:20 -0500
Subject: [PATCH 354/399] Fixed uninitialized values for renderMeshExample and
 renderShapeExample which would cause a crash on creation Added utility method
 to prefab to be able to get the internal simGroup that contains it's children
 Adjusted logic for mounting items in GuiShapeEdPreview to utilize assetIds
 for the shapes Moved the Asset and AssetBrowser editor settings populate
 functions to the AssetBrowser script to better organize things Fixed command
 usage for General, Player and Observer spawn point creator entries to use the
 correct callback commands Fixed logic for creator callback commands that
 don't just route through the class name based structure Added RMB context
 menu actions for opening asset file or folder locations in OS file explorer
 Fixed lookup of animation assets when editing a shape's animations in the
 shape editor so it provides the assetId of the anim if it exists Fixes
 handling of mounting in the shape editor so it utilizes assets and the asset
 browser like everything else

---
 .../source/T3D/examples/renderMeshExample.cpp |  1 +
 .../T3D/examples/renderShapeExample.cpp       |  1 +
 Engine/source/T3D/prefab.cpp                  |  6 ++
 Engine/source/T3D/prefab.h                    |  7 ++
 .../source/gui/editor/guiShapeEdPreview.cpp   | 20 +++--
 .../assetBrowser/scripts/assetBrowser.tscript | 80 +++++++++++++++++++
 .../assetBrowser/scripts/creator.tscript      | 15 ++--
 .../assetBrowser/scripts/editAsset.tscript    | 50 ++++++++++++
 .../assetBrowser/scripts/popupMenus.tscript   | 29 ++++---
 .../tools/gui/editorSettingsWindow.ed.tscript | 77 ------------------
 .../scripts/shapeEditor.ed.tscript            | 31 ++++---
 .../scripts/shapeEditorActions.ed.tscript     |  1 -
 12 files changed, 207 insertions(+), 111 deletions(-)

diff --git a/Engine/source/T3D/examples/renderMeshExample.cpp b/Engine/source/T3D/examples/renderMeshExample.cpp
index fe1d099eb..343075358 100644
--- a/Engine/source/T3D/examples/renderMeshExample.cpp
+++ b/Engine/source/T3D/examples/renderMeshExample.cpp
@@ -60,6 +60,7 @@ RenderMeshExample::RenderMeshExample()
    mTypeMask |= StaticObjectType | StaticShapeObjectType;
 
    INIT_ASSET(Material);
+   mMaterialInst = NULL;
 }
 
 RenderMeshExample::~RenderMeshExample()
diff --git a/Engine/source/T3D/examples/renderShapeExample.cpp b/Engine/source/T3D/examples/renderShapeExample.cpp
index b8aad1ebf..a4a92d572 100644
--- a/Engine/source/T3D/examples/renderShapeExample.cpp
+++ b/Engine/source/T3D/examples/renderShapeExample.cpp
@@ -59,6 +59,7 @@ RenderShapeExample::RenderShapeExample()
    mTypeMask |= StaticObjectType | StaticShapeObjectType;
 
    // Make sure to initialize our TSShapeInstance to NULL
+   INIT_ASSET(Shape);
    mShapeInstance = NULL;
 }
 
diff --git a/Engine/source/T3D/prefab.cpp b/Engine/source/T3D/prefab.cpp
index 0bebb443f..a211a41e5 100644
--- a/Engine/source/T3D/prefab.cpp
+++ b/Engine/source/T3D/prefab.cpp
@@ -616,3 +616,9 @@ void ExplodePrefabUndoAction::redo()
    name = Sim::getUniqueName( name );
    mGroup->assignName( name );   
 }
+
+DefineEngineMethod(Prefab, getChildGroup, S32, (),,
+   "")
+{
+   return object->getChildGroup();
+}
diff --git a/Engine/source/T3D/prefab.h b/Engine/source/T3D/prefab.h
index def70857e..d6cde3e69 100644
--- a/Engine/source/T3D/prefab.h
+++ b/Engine/source/T3D/prefab.h
@@ -102,6 +102,13 @@ public:
 
    virtual void getUtilizedAssets(Vector<StringTableEntry>* usedAssetsList);
 
+   S32 getChildGroup() {
+      if (mChildGroup.isValid())
+         return mChildGroup->getId();
+
+      return 0;
+   }
+
 protected:
 
    void _closeFile( bool removeFileNotify );
diff --git a/Engine/source/gui/editor/guiShapeEdPreview.cpp b/Engine/source/gui/editor/guiShapeEdPreview.cpp
index eba775edb..d5dc8c5bf 100644
--- a/Engine/source/gui/editor/guiShapeEdPreview.cpp
+++ b/Engine/source/gui/editor/guiShapeEdPreview.cpp
@@ -557,16 +557,20 @@ void GuiShapeEdPreview::refreshThreadSequences()
 //-----------------------------------------------------------------------------
 // MOUNTING
 
-bool GuiShapeEdPreview::mountShape(const char* modelName, const char* nodeName, const char* mountType, S32 slot)
+bool GuiShapeEdPreview::mountShape(const char* shapeAssetId, const char* nodeName, const char* mountType, S32 slot)
 {
-   if ( !modelName || !modelName[0] )
+   if ( !shapeAssetId || !shapeAssetId[0] )
       return false;
 
-   Resource<TSShape> model = ResourceManager::get().load( modelName );
-   if ( !bool( model ) )
+   if (!AssetDatabase.isDeclaredAsset(shapeAssetId))
       return false;
 
-   TSShapeInstance* tsi = new TSShapeInstance( model, true );
+   ShapeAsset* model = AssetDatabase.acquireAsset<ShapeAsset>(shapeAssetId);
+
+   if (model == nullptr || !model->getShapeResource())
+      return false;
+
+   TSShapeInstance* tsi = new TSShapeInstance(model->getShapeResource(), true );
 
    if ( slot == -1 )
    {
@@ -1864,14 +1868,14 @@ DefineEngineMethod( GuiShapeEdPreview, refreshThreadSequences, void, (),,
 
 //-----------------------------------------------------------------------------
 // Mounting
-DefineEngineMethod( GuiShapeEdPreview, mountShape, bool, ( const char* shapePath, const char* nodeName, const char* type, S32 slot ),,
+DefineEngineMethod( GuiShapeEdPreview, mountShape, bool, ( const char* shapeAssetId, const char* nodeName, const char* type, S32 slot ),,
    "Mount a shape onto the main shape at the specified node\n\n"
-   "@param shapePath path to the shape to mount\n"
+   "@param shapeAssetId AssetId of the shape to mount\n"
    "@param nodeName name of the node on the main shape to mount to\n"
    "@param type type of mounting to use (Object, Image or Wheel)\n"
    "@param slot mount slot\n" )
 {
-   return object->mountShape( shapePath, nodeName, type, slot );
+   return object->mountShape(shapeAssetId, nodeName, type, slot );
 }
 
 DefineEngineMethod( GuiShapeEdPreview, setMountNode, void, ( S32 slot, const char* nodeName ),,
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
index eca3729f7..fd3a7b213 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
@@ -1212,6 +1212,86 @@ function AssetBrowser::openAssetSettings(%this)
    ESettingsWindowList.setSelectedRow( %assetEditIndex );
 }
 
+function ESettingsWindow::getAssetManagementSettings(%this)
+{
+   SettingsInspector.startGroup("Modules");
+   SettingsInspector.addSettingsField("AssetManagement/Modules/coreModulePath", "Core Module Path", "string", "");
+   SettingsInspector.addSettingsField("AssetManagement/Modules/gameDataModulePath", "Game Data Module Path", "string", "");
+   SettingsInspector.addSettingsField("AssetManagement/Modules/moduleExtension", "Module Extension", "string", "");
+   
+   %moduleList = ModuleDatabase.findModules(true);
+   %moduleList = strreplace(%moduleList, " ", ",");
+   
+   SettingsInspector.addSettingsField("AssetManagement/Modules/DefaultModule", "Default Module", "list", %moduleList);
+   SettingsInspector.endGroup();
+   
+   SettingsInspector.startGroup("Assets");
+   SettingsInspector.addSettingsField("AssetManagement/Assets/assetExtension", "Asset Extension", "string", "");
+   SettingsInspector.addSettingsField("AssetManagement/Assets/datablockCaching", "Cache Datablocks", "bool", "");
+   //SettingsInspector.addSettingsField("AssetManagement/Assets/moduleExtension", "Module Extension", "string", "");
+   
+   SettingsInspector.endGroup();
+} 
+
+function ESettingsWindow::getAssetEditingSettings(%this)
+{
+   ImportAssetWindow::reloadImportOptionConfigs();
+   
+   //First, get our list of modules
+   %moduleList = ModuleDatabase.findModules();
+   %formattedModuleList = "";
+   
+   %count = getWordCount(%moduleList);
+   for(%i=0; %i < %count; %i++)
+   {
+      %module = getWord(%moduleList, %i);
+      if(%module.group !$= "Tools" && %module.group !$= "Core")
+      {
+         if(%formattedModuleList $= "")
+            %formattedModuleList = %module.moduleId;
+         else
+            %formattedModuleList = %formattedModuleList @ "," @ %module.moduleId;  
+      }
+   }
+   
+   SettingsInspector.startGroup("Asset Creation");
+   SettingsInspector.addSettingsField("Assets/New/defaultModule", "Default Module", "list", "Default Module for new assets to be created into", %formattedModuleList); 
+   SettingsInspector.addSettingsField("Assets/New/alwaysPromptModuleTarget", "Always Prompt Target Module", "bool", "If off, use the default module"); 
+   SettingsInspector.endGroup();
+   
+   %formattedConfigList = "";
+   for(%i=0; %i < ImportAssetWindow.importConfigsList.Count(); %i++)
+   {
+      %configName = ImportAssetWindow.importConfigsList.getKey(%i);
+      %formattedConfigList = %i == 0 ? %configName : %formattedConfigList @ "," @ %configName;
+   }
+   
+   SettingsInspector.startGroup("Assets Importing");
+   SettingsInspector.addField("Edit Import Configs", "Edit Asset Import Configs", "button", "Open Asset Import Config Editor", "", "Canvas.pushDialog(AssetImportConfigEditor);");
+   SettingsInspector.addSettingsField("Assets/AssetImporDefaultConfig", "Default Asset Import Config", "list", "", %formattedConfigList); 
+   SettingsInspector.addSettingsField("Assets/AutoImport", "Automatically Import using default config", "bool", "If on, the asset importing process" @
+                                                                                                                        "will attempt to automatically import any inbound assets"@
+                                                                                                                        "using the default config, without prompting the import window."@
+                                                                                                                        "The window will still display if any issues are detected", ""); 
+   SettingsInspector.addSettingsField("Assets/AutoImportLooseFiles", "Automatically Import Loose Files", "bool", "If on, will automatically import unassociated loose files in assets when navigating the Asset Browser.", ""); 
+   SettingsInspector.endGroup();
+   
+   SettingsInspector.startGroup("Asset Browser");
+   SettingsInspector.addSettingsField("Assets/Browser/showCoreModule", "Show Core Module in Asset Browser", "bool", ""); 
+   SettingsInspector.addSettingsField("Assets/Browser/showToolsModule", "Show Tools Module in Asset Browser", "bool", ""); 
+   SettingsInspector.addSettingsField("Assets/Browser/showOnlyPopulatedModule", "Show Only Modules with Assets in Asset Browser", "bool", "");
+   SettingsInspector.addSettingsField("Assets/Browser/showFolders", "Show Folders in Tiles view in Asset Browser", "bool", "");
+   SettingsInspector.addSettingsField("Assets/Browser/showEmptyFolders", "Show Empty Folders in Tiles view in Asset Browser", "bool", "");
+   SettingsInspector.addSettingsField("Assets/Browser/showLooseFiles", "Show Loose Files when viewing in Asset Browser", "bool", "");
+   SettingsInspector.addSettingsField("AssetManagement/Assets/promptOnRename", "Prompt on Rename", "bool", "");
+   SettingsInspector.addSettingsField("Assets/Browser/doubleClickAction", "Double Click Action", "list", "Dictates what sort of action double clicking on an asset in the Browser will invoke", "Edit Asset,Spawn Asset");
+   SettingsInspector.addSettingsField("AssetManagement/Assets/closeBrowserOnDragAction", "Close Browser on Drag Action", "bool", "If on, the Asset Browser will automatically close after dragging an asset from it to the editor interface.");
+   SettingsInspector.endGroup();
+}
+//
+//
+//
+
 function AssetBrowser::showVisibiltyOptions(%this)
 {
    BrowserVisibilityPopup.showPopup(Canvas);
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript
index 803a5933a..c6b279d35 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript
@@ -50,9 +50,9 @@ function AssetBrowser::loadCreatorClasses(%this)
       %this.addCreatorClass("MissionArea",  "Mission Area" );
       %this.addCreatorClass("NotesObject",         "Note" );
       %this.addCreatorClass("Path" );
-      %this.addCreatorClass("SpawnSphere",  "General Spawn Sphere" );
-      %this.addCreatorClass("SpawnSphere",  "Player Spawn Sphere"/*, "PlayerDropPoint"*/ );
-      %this.addCreatorClass("SpawnSphere",  "Observer Spawn Sphere"/*, "ObserverDropPoint"*/ );
+      %this.addCreatorClass("SpawnSphere",  "General Spawn Sphere", "GeneralDropPoint"  );
+      %this.addCreatorClass("SpawnSphere",  "Player Spawn Sphere", "PlayerDropPoint" );
+      %this.addCreatorClass("SpawnSphere",  "Observer Spawn Sphere", "ObserverDropPoint" );
       %this.addCreatorClass("VPath",        "Verve Path" );
    %this.endCreatorGroup();
    
@@ -168,6 +168,7 @@ function AssetBrowser::addCreatorClass(%this, %class, %name, %buildfunc)
       return;  
    }
    
+   %cmd = "";
    if(%buildfunc $= "")
    {
       %method = "build" @ %buildfunc;
@@ -178,9 +179,13 @@ function AssetBrowser::addCreatorClass(%this, %class, %name, %buildfunc)
          %cmd = "new " @ %class @ "();";
       else
          %cmd = "ObjectBuilderGui." @ %method @ "();";
-
-      %buildfunc = "ObjectBuilderGui.newObjectCallback = \"AssetBrowser.onFinishCreateObject\"; ObjectCreator.createObject( \"" @ %cmd @ "\" );";
    }
+   else
+   {
+      %cmd = "ObjectBuilderGui.build" @ %buildfunc @ "();";
+   }
+
+   %buildfunc = "ObjectBuilderGui.newObjectCallback = \"AssetBrowser.onFinishCreateObject\"; ObjectCreator.createObject( \"" @ %cmd @ "\" );";
    
    %args = new ScriptObject();
    %args.val[0] = %class;
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/editAsset.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/editAsset.tscript
index 6267462ee..ffa4abd3b 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/editAsset.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/editAsset.tscript
@@ -476,4 +476,54 @@ function AssetBrowser::updateAssetReference(%this, %targetPath, %oldAssetId, %ne
    
    lineCache.delete();
    %fileObj.delete();
+}
+
+function AssetBrowser::openFileLocation(%this)
+{
+   %filePath = "";
+   if(EditAssetPopup.assetId !$= "")
+   {
+      %filePath = AssetDatabase.getAssetPath(EditAssetPopup.assetId);
+   }
+   else if(EditLevelAssetPopup.assetId !$= "")
+   {
+      %filePath = AssetDatabase.getAssetPath(EditAssetPopup.assetId);
+   }
+   else if(EditTerrainAssetPopup.assetId !$= "")
+   {
+      %filePath = AssetDatabase.getAssetPath(EditAssetPopup.assetId);
+   }
+   
+   if(%filePath !$= "")
+   {
+      if($platform $= "windows")
+      {
+         %cmd = "cd \"" @ makeFullPath(%filePath) @ "\" && start .";
+         systemCommand(%cmd);
+      }
+      else
+      {
+         %cmd = "open \"" @ makeFullPath(%filePath) @ "\"";
+         systemCommand(%cmd);
+      }
+   }
+}
+
+function AssetBrowser::openFolderLocation(%this)
+{
+   %filePath = AssetBrowser.dirHandler.currentAddress;
+   
+   if(%filePath !$= "")
+   {
+      if($platform $= "windows")
+      {
+         %cmd = "cd \"" @ makeFullPath(%filePath) @ "\" && start .";
+         systemCommand(%cmd);
+      }
+      else
+      {
+         %cmd = "open \"" @ makeFullPath(%filePath) @ "\"";
+         systemCommand(%cmd);
+      }
+   }
 }
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/popupMenus.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/popupMenus.tscript
index c4f0cca7b..808649d86 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/popupMenus.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/popupMenus.tscript
@@ -34,7 +34,9 @@ function AssetBrowser::buildPopupMenus(%this)
          item[ 8 ] = "-";
          item[ 9 ] = "Re-Import Asset" TAB "" TAB "AssetBrowser.reImportAsset();";
          item[ 10 ] = "-";
-         item[ 11 ] = "Delete Asset" TAB "" TAB "AssetBrowser.deleteAsset();";
+         item[ 11 ] = "Open File Location" TAB "" TAB "AssetBrowser.openFileLocation();";
+         item[ 12 ] = "-";
+         item[ 13 ] = "Delete Asset" TAB "" TAB "AssetBrowser.deleteAsset();";
 
          jumpFileName = "";
          jumpLineNumber = "";
@@ -57,9 +59,9 @@ function AssetBrowser::buildPopupMenus(%this)
          item[ 5 ] = "-";
          Item[ 6 ] = "Duplicate Asset" TAB "" TAB "AssetBrowser.duplicateAsset();";
          item[ 7 ] = "-";
-         //item[ 8 ] = "Re-Import Asset" TAB "" TAB "AssetBrowser.reImportAsset();";
-         //item[ 9 ] = "-";
-         item[ 8 ] = "Delete Asset" TAB "" TAB "AssetBrowser.deleteAsset();";
+         item[ 8 ] = "Open File Location" TAB "" TAB "AssetBrowser.openFileLocation();";
+         item[ 9 ] = "-";
+         item[ 10 ] = "Delete Asset" TAB "" TAB "AssetBrowser.deleteAsset();";
 
          jumpFileName = "";
          jumpLineNumber = "";
@@ -80,7 +82,9 @@ function AssetBrowser::buildPopupMenus(%this)
          item[ 3 ] = "-";
          Item[ 4 ] = "Duplicate Asset" TAB "" TAB "AssetBrowser.duplicateAsset();";
          item[ 5 ] = "-";
-         item[ 6 ] = "Delete Asset" TAB "" TAB "AssetBrowser.deleteAsset();";
+         item[ 6 ] = "Open File Location" TAB "" TAB "AssetBrowser.openFileLocation();";
+         item[ 7 ] = "-";
+         item[ 8 ] = "Delete Asset" TAB "" TAB "AssetBrowser.deleteAsset();";
 
          jumpFileName = "";
          jumpLineNumber = "";
@@ -185,6 +189,9 @@ function AssetBrowser::buildPopupMenus(%this)
          item[10] = "Create New Module" TAB "" TAB "AssetBrowser.CreateNewModule();";
          item[11] = "-";
          item[12] = "View Loose Files" TAB "" TAB "AssetBrowser.importLooseFiles();";
+         Item[ 13 ] = "-";
+         item[ 14 ] = "Open Folder Location" TAB "" TAB "AssetBrowser.openFolderLocation();";
+         
       
       };
    }
@@ -203,11 +210,13 @@ function AssetBrowser::buildPopupMenus(%this)
          Item[ 3 ] = "-";
          Item[ 4 ] = "Module Properties" TAB "" TAB "AssetBrowser.editModuleInfo();";
          Item[ 5 ] = "-";
-         Item[ 6 ] = "Duplicate Module" TAB "" TAB "AssetBrowser.copyModule();";
-         Item[ 7 ] = "-";
-         Item[ 8 ] = "Delete Module" TAB "" TAB "AssetBrowser.deleteModule();";
-         item[ 9 ] = "-";
-         item[ 10 ] = "Import Loose Files" TAB "" TAB "AssetBrowser.importLooseFiles();";
+         item[ 6 ] = "Open Folder Location" TAB "" TAB "AssetBrowser.openFolderLocation();";
+         item[ 7 ] = "-";
+         Item[ 8 ] = "Duplicate Module" TAB "" TAB "AssetBrowser.copyModule();";
+         Item[ 9 ] = "-";
+         Item[ 10 ] = "Delete Module" TAB "" TAB "AssetBrowser.deleteModule();";
+         item[ 11 ] = "-";
+         item[ 12 ] = "Import Loose Files" TAB "" TAB "AssetBrowser.importLooseFiles();";
       };
    }
    
diff --git a/Templates/BaseGame/game/tools/gui/editorSettingsWindow.ed.tscript b/Templates/BaseGame/game/tools/gui/editorSettingsWindow.ed.tscript
index e104dea65..c9b589caa 100644
--- a/Templates/BaseGame/game/tools/gui/editorSettingsWindow.ed.tscript
+++ b/Templates/BaseGame/game/tools/gui/editorSettingsWindow.ed.tscript
@@ -473,83 +473,6 @@ function ESettingsWindow::getUISettings(%this)
    SettingsInspector.endGroup();
 } 
 
-function ESettingsWindow::getAssetManagementSettings(%this)
-{
-   SettingsInspector.startGroup("Modules");
-   SettingsInspector.addSettingsField("AssetManagement/Modules/coreModulePath", "Core Module Path", "string", "");
-   SettingsInspector.addSettingsField("AssetManagement/Modules/gameDataModulePath", "Game Data Module Path", "string", "");
-   SettingsInspector.addSettingsField("AssetManagement/Modules/moduleExtension", "Module Extension", "string", "");
-   
-   %moduleList = ModuleDatabase.findModules(true);
-   %moduleList = strreplace(%moduleList, " ", ",");
-   
-   SettingsInspector.addSettingsField("AssetManagement/Modules/DefaultModule", "Default Module", "list", %moduleList);
-   SettingsInspector.endGroup();
-   
-   SettingsInspector.startGroup("Assets");
-   SettingsInspector.addSettingsField("AssetManagement/Assets/assetExtension", "Asset Extension", "string", "");
-   SettingsInspector.addSettingsField("AssetManagement/Assets/datablockCaching", "Cache Datablocks", "bool", "");
-   //SettingsInspector.addSettingsField("AssetManagement/Assets/moduleExtension", "Module Extension", "string", "");
-   
-   SettingsInspector.endGroup();
-} 
-
-function ESettingsWindow::getAssetEditingSettings(%this)
-{
-   ImportAssetWindow::reloadImportOptionConfigs();
-   
-   //First, get our list of modules
-   %moduleList = ModuleDatabase.findModules();
-   %formattedModuleList = "";
-   
-   %count = getWordCount(%moduleList);
-   for(%i=0; %i < %count; %i++)
-   {
-      %module = getWord(%moduleList, %i);
-      if(%module.group !$= "Tools" && %module.group !$= "Core")
-      {
-         if(%formattedModuleList $= "")
-            %formattedModuleList = %module.moduleId;
-         else
-            %formattedModuleList = %formattedModuleList @ "," @ %module.moduleId;  
-      }
-   }
-   
-   SettingsInspector.startGroup("Asset Creation");
-   SettingsInspector.addSettingsField("Assets/New/defaultModule", "Default Module", "list", "Default Module for new assets to be created into", %formattedModuleList); 
-   SettingsInspector.addSettingsField("Assets/New/alwaysPromptModuleTarget", "Always Prompt Target Module", "bool", "If off, use the default module"); 
-   SettingsInspector.endGroup();
-   
-   %formattedConfigList = "";
-   for(%i=0; %i < ImportAssetWindow.importConfigsList.Count(); %i++)
-   {
-      %configName = ImportAssetWindow.importConfigsList.getKey(%i);
-      %formattedConfigList = %i == 0 ? %configName : %formattedConfigList @ "," @ %configName;
-   }
-   
-   SettingsInspector.startGroup("Assets Importing");
-   SettingsInspector.addField("Edit Import Configs", "Edit Asset Import Configs", "button", "Open Asset Import Config Editor", "", "Canvas.pushDialog(AssetImportConfigEditor);");
-   SettingsInspector.addSettingsField("Assets/AssetImporDefaultConfig", "Default Asset Import Config", "list", "", %formattedConfigList); 
-   SettingsInspector.addSettingsField("Assets/AutoImport", "Automatically Import using default config", "bool", "If on, the asset importing process" @
-                                                                                                                        "will attempt to automatically import any inbound assets"@
-                                                                                                                        "using the default config, without prompting the import window."@
-                                                                                                                        "The window will still display if any issues are detected", ""); 
-   SettingsInspector.addSettingsField("Assets/AutoImportLooseFiles", "Automatically Import Loose Files", "bool", "If on, will automatically import unassociated loose files in assets when navigating the Asset Browser.", ""); 
-   SettingsInspector.endGroup();
-   
-   SettingsInspector.startGroup("Asset Browser");
-   SettingsInspector.addSettingsField("Assets/Browser/showCoreModule", "Show Core Module in Asset Browser", "bool", ""); 
-   SettingsInspector.addSettingsField("Assets/Browser/showToolsModule", "Show Tools Module in Asset Browser", "bool", ""); 
-   SettingsInspector.addSettingsField("Assets/Browser/showOnlyPopulatedModule", "Show Only Modules with Assets in Asset Browser", "bool", "");
-   SettingsInspector.addSettingsField("Assets/Browser/showFolders", "Show Folders in Tiles view in Asset Browser", "bool", "");
-   SettingsInspector.addSettingsField("Assets/Browser/showEmptyFolders", "Show Empty Folders in Tiles view in Asset Browser", "bool", "");
-   SettingsInspector.addSettingsField("Assets/Browser/showLooseFiles", "Show Loose Files when viewing in Asset Browser", "bool", "");
-   SettingsInspector.addSettingsField("AssetManagement/Assets/promptOnRename", "Prompt on Rename", "bool", "");
-   SettingsInspector.addSettingsField("Assets/Browser/doubleClickAction", "Double Click Action", "list", "Dictates what sort of action double clicking on an asset in the Browser will invoke", "Edit Asset,Spawn Asset");
-   SettingsInspector.addSettingsField("AssetManagement/Assets/closeBrowserOnDragAction", "Close Browser on Drag Action", "bool", "If on, the Asset Browser will automatically close after dragging an asset from it to the editor interface.");
-   SettingsInspector.endGroup();
-}
-
 function ESettingsWindow::getGameplaySettings(%this)
 {
    SettingsInspector.startGroup("Game Modes");
diff --git a/Templates/BaseGame/game/tools/shapeEditor/scripts/shapeEditor.ed.tscript b/Templates/BaseGame/game/tools/shapeEditor/scripts/shapeEditor.ed.tscript
index 2be4dd630..b53e1edaa 100644
--- a/Templates/BaseGame/game/tools/shapeEditor/scripts/shapeEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/shapeEditor/scripts/shapeEditor.ed.tscript
@@ -1581,8 +1581,19 @@ function ShapeEdSequences::onEditSequenceSource( %this, %from )
          %from = rtrim( getFields( %oldSource, 0, 0 ) );
 
       if ( getFields( %oldSource, 0, 3 ) !$= ( %from TAB "" TAB %start TAB %end ) )
+      {
+         %aq = new AssetQuery();
+         %foundAssets = AssetDatabase.findAssetLooseFile(%aq, %from);
+         if(%foundAssets != 0)
+         {
+            //if we have an assetId associated to the file, we're gunna just pass that
+            //through for the edit actions
+            %from = %aq.getAsset(0);
+         }
+         %aq.delete();
          ShapeEditor.doEditSeqSource( %seqName, %from, %start, %end );
    }
+   }
 }
 
 function ShapeEdSequences::onToggleCyclic( %this )
@@ -3339,8 +3350,9 @@ function ShapeEdMountShapeMenu::onSelect( %this, %id, %text )
 {
    if ( %text $= "Browse..." )
    {
-      // Allow the user to browse for an external model file
-      getLoadFormatFilename( %this @ ".onBrowseSelect", %this.lastPath );
+      if(%this.lastPath !$= "")
+         AssetBrowser.dirHandler.currentAddress = %this.lastPath;
+      AssetBrowser.showDialog("ShapeAsset", %this @ ".onBrowseSelect");
    }
    else
    {
@@ -3349,15 +3361,14 @@ function ShapeEdMountShapeMenu::onSelect( %this, %id, %text )
    }
 }
 
-function ShapeEdMountShapeMenu::onBrowseSelect( %this, %path )
+function ShapeEdMountShapeMenu::onBrowseSelect( %this, %shapeAssetId )
 {
-   %path = makeRelativePath( %path, getMainDotCSDir() );
-   %this.lastPath = %path;
-   %this.setText( %path );
+   %this.lastPath = AssetBrowser.dirHandler.currentAddress;
+   %this.setText( %shapeAssetId );
 
    // Add entry if unique
-   if ( %this.findText( %path ) == -1 )
-      %this.add( %path );
+   if ( %this.findText( %shapeAssetId ) == -1 )
+      %this.add( %shapeAssetId );
 
    ShapeEdMountWindow.updateSelectedMount();
 }
@@ -3369,11 +3380,11 @@ function ShapeEdMountWindow::mountShape( %this, %slot )
    %type = %this-->mountType.getText();
 
    if ( %model $= "Browse..." )
-      %model = "core/gameObjects/shapes/octahedron.dts";
+      %model = "Core_GameObjects:octahedron.dts";
 
    if ( ShapeEdShapeView.mountShape( %model, %node, %type, %slot ) )
    {
-      %rowText = %model TAB fileName( %model ) TAB %node TAB %type;
+      %rowText = %model TAB %node TAB %type;
       if ( %slot == -1 )
       {
          %id = %this.mounts++;
diff --git a/Templates/BaseGame/game/tools/shapeEditor/scripts/shapeEditorActions.ed.tscript b/Templates/BaseGame/game/tools/shapeEditor/scripts/shapeEditorActions.ed.tscript
index 55d6f9483..656871086 100644
--- a/Templates/BaseGame/game/tools/shapeEditor/scripts/shapeEditorActions.ed.tscript
+++ b/Templates/BaseGame/game/tools/shapeEditor/scripts/shapeEditorActions.ed.tscript
@@ -301,7 +301,6 @@ function ActionEditNodeTransform::undo( %this )
 // Add sequence
 function onAddAnimationAssetShapeEditor(%selectedAnimation)
 {
-   echo("SELECTED MUH ASSET");
    ShapeEditor.doAddSequence(%selectedAnimation, 0, 0, 0);
 }
 

From bfe3d4d02b80877115ca457ac68b125c245ddbfd Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Thu, 7 Apr 2022 18:19:13 -0500
Subject: [PATCH 355/399] Shifts handling of forest brush and item elements
 into standard simsets for consistency Updates the forest editor tooling to
 utilize the new sets, and adjusts the creation of new Brushes in the forest
 editor to have user select a target module first. This ensures all a module's
 brushes are grouped into the new ForestBrushGroup class which auto-registers
 into the ForestBrushSet, thus allowing modules to have their own sets of
 brushes that automatically hook into the editor workflow.

---
 Engine/source/console/sim.cpp                 |  2 +
 Engine/source/console/sim.h                   |  2 +
 Engine/source/console/simManager.cpp          |  2 +
 .../forest/editor/forestBrushElement.cpp      | 76 ++++++++++++++++++-
 .../source/forest/editor/forestBrushElement.h | 25 +++++-
 .../source/forest/editor/forestBrushTool.cpp  |  9 ++-
 .../source/forest/editor/forestEditorCtrl.cpp | 12 ++-
 .../templateFiles/module.tscript.template     |  2 +
 .../game/tools/forestEditor/brushes.tscript   | 26 -------
 .../forestEditor/forestEditorGui.tscript      | 66 ++++++++--------
 .../game/tools/forestEditor/main.tscript      | 43 +++++------
 11 files changed, 177 insertions(+), 88 deletions(-)
 delete mode 100644 Templates/BaseGame/game/tools/forestEditor/brushes.tscript

diff --git a/Engine/source/console/sim.cpp b/Engine/source/console/sim.cpp
index b03e5c15a..48e3b627f 100644
--- a/Engine/source/console/sim.cpp
+++ b/Engine/source/console/sim.cpp
@@ -68,6 +68,8 @@ namespace Sim
    ImplementNamedSet(SFXAmbienceSet)
    ImplementNamedSet(TerrainMaterialSet)
    ImplementNamedSet(DataBlockSet);
+   ImplementNamedSet(ForestBrushSet);
+   ImplementNamedSet(ForestItemDataSet);
    ImplementNamedGroup(ActionMapGroup)
    ImplementNamedGroup(ClientGroup)
    ImplementNamedGroup(GuiGroup)
diff --git a/Engine/source/console/sim.h b/Engine/source/console/sim.h
index 61ff469e0..001ace64e 100644
--- a/Engine/source/console/sim.h
+++ b/Engine/source/console/sim.h
@@ -107,6 +107,8 @@ namespace Sim
    DeclareNamedSet(SFXAmbienceSet);
    DeclareNamedSet(TerrainMaterialSet);
    DeclareNamedSet(DataBlockSet);
+   DeclareNamedSet(ForestBrushSet);
+   DeclareNamedSet(ForestItemDataSet);
    DeclareNamedGroup(ActionMapGroup)
    DeclareNamedGroup(ClientGroup)
    DeclareNamedGroup(GuiGroup)
diff --git a/Engine/source/console/simManager.cpp b/Engine/source/console/simManager.cpp
index c8fb60c7f..94b407a25 100644
--- a/Engine/source/console/simManager.cpp
+++ b/Engine/source/console/simManager.cpp
@@ -565,6 +565,8 @@ void init()
    InstantiateNamedSet(SFXAmbienceSet);
    InstantiateNamedSet(TerrainMaterialSet);
    InstantiateNamedSet(DataBlockSet);
+   InstantiateNamedSet(ForestBrushSet); 
+   InstantiateNamedSet(ForestItemDataSet);
    InstantiateNamedGroup(ActionMapGroup);
    InstantiateNamedGroup(ClientGroup);
    InstantiateNamedGroup(GuiGroup);
diff --git a/Engine/source/forest/editor/forestBrushElement.cpp b/Engine/source/forest/editor/forestBrushElement.cpp
index 86e89e3d6..8c41cc969 100644
--- a/Engine/source/forest/editor/forestBrushElement.cpp
+++ b/Engine/source/forest/editor/forestBrushElement.cpp
@@ -197,4 +197,78 @@ DefineEngineMethod( ForestBrush, containsItemData, bool, ( const char * obj ), ,
    }
 
    return object->containsItemData( data );
-}
\ No newline at end of file
+}
+
+//-------------------------------------------------------------------------
+// ForestBrushGroupSet
+//-------------------------------------------------------------------------
+
+IMPLEMENT_CONOBJECT(ForestBrushGroup);
+
+ConsoleDocClass(ForestBrushGroup,
+   "@brief Container class for ForestBrushes\n\n"
+   "Editor use only.\n\n"
+   "@internal"
+);
+
+ForestBrushGroup::ForestBrushGroup()
+{
+
+}
+
+bool ForestBrushGroup::onAdd()
+{
+   if (!Parent::onAdd())
+      return false;
+
+   SimSet* forestBrushSet;
+   if (!Sim::findObject("ForestBrushSet", forestBrushSet))
+   {
+      Con::errorf("ForestBrushGroup::onAdd() - failed to find ForestBrushSet to add new ForestBrushGroup to!");
+   }
+
+   forestBrushSet->addObject(this);
+
+   return true;
+}
+
+void ForestBrushGroup::addObject(SimObject* inObj)
+{
+   ForestBrush* ele = dynamic_cast<ForestBrush*>(inObj);
+   if (!ele)
+      return;
+
+   //if ( containsItemData( ele->mData ) )
+   //   return;
+
+   Parent::addObject(inObj);
+}
+
+bool ForestBrushGroup::containsBrushData(const ForestBrush* inData)
+{
+   SimObjectList::iterator iter = mObjectList.begin();
+   for (; iter != mObjectList.end(); iter++)
+   {
+      ForestBrush* pElement = dynamic_cast<ForestBrush*>(*iter);
+
+      if (!pElement)
+         continue;
+
+      if (pElement == inData)
+         return true;
+   }
+
+   return false;
+}
+
+DefineEngineMethod(ForestBrushGroup, containsBrushData, bool, (const char* obj), , "( ForestBrush obj )")
+{
+   ForestBrush* data = NULL;
+   if (!Sim::findObject(obj, data))
+   {
+      Con::warnf("ForestBrush::containsBrushData - invalid object passed");
+      return false;
+   }
+
+   return object->containsBrushData(data);
+}
diff --git a/Engine/source/forest/editor/forestBrushElement.h b/Engine/source/forest/editor/forestBrushElement.h
index be6a37cc0..6a7d98973 100644
--- a/Engine/source/forest/editor/forestBrushElement.h
+++ b/Engine/source/forest/editor/forestBrushElement.h
@@ -121,5 +121,28 @@ protected:
    static SimObjectPtr<SimGroup> smGroup;
 };
 
+//-------------------------------------------------------------------------
+// ForestBrushGroup
+//-------------------------------------------------------------------------
 
-#endif // _FOREST_EDITOR_BRUSHELEMENT_H_
\ No newline at end of file
+class ForestBrushGroup : public SimGroup
+{
+   typedef SimGroup Parent;
+
+public:
+
+   ForestBrushGroup();
+
+   DECLARE_CONOBJECT(ForestBrushGroup);
+
+   virtual bool onAdd();
+
+   virtual void addObject(SimObject*);
+
+   bool containsBrushData(const ForestBrush* inData);
+protected:
+
+   static SimObjectPtr<SimGroup> smGroup;
+};
+
+#endif // _FOREST_EDITOR_BRUSHELEMENT_H_
diff --git a/Engine/source/forest/editor/forestBrushTool.cpp b/Engine/source/forest/editor/forestBrushTool.cpp
index 5b9278ea6..06a75ea1d 100644
--- a/Engine/source/forest/editor/forestBrushTool.cpp
+++ b/Engine/source/forest/editor/forestBrushTool.cpp
@@ -610,9 +610,14 @@ void ForestBrushTool::_collectElements()
    }
 
    // Find all ForestBrushElements that are directly or indirectly selected.
+   SimSet* brushSet;
+   if (!Sim::findObject("ForestBrushSet", brushSet))
+   {
+      Con::errorf("ForestBrushTool::_collectElements() - could not find ForestBrushSet!");
+      return;
+   }
 
-   SimGroup *brushGroup = ForestBrush::getGroup();
-   brushGroup->findObjectByCallback( findSelectedElements, mElements );
+   brushSet->findObjectByCallback( findSelectedElements, mElements );
 
    // We just needed to flag these objects as selected for the benefit of our
    // findSelectedElements callback, we can now mark them un-selected again.
diff --git a/Engine/source/forest/editor/forestEditorCtrl.cpp b/Engine/source/forest/editor/forestEditorCtrl.cpp
index db8a58f3c..bf88f0b4c 100644
--- a/Engine/source/forest/editor/forestEditorCtrl.cpp
+++ b/Engine/source/forest/editor/forestEditorCtrl.cpp
@@ -328,10 +328,16 @@ void ForestEditorCtrl::deleteMeshSafe( ForestItemData *mesh )
    }
 
    // Find ForestBrushElement(s) referencing this datablock.
-   SimGroup *brushGroup = ForestBrush::getGroup();
+   SimSet* brushSet;
+   if (!Sim::findObject("ForestBrushSet", brushSet))
+   {
+      Con::errorf("ForestBrushTool::_collectElements() - could not find ForestBrushSet!");
+      return;
+   }
+
    sKey = mesh;
    Vector<SimObject*> foundElements;   
-   brushGroup->findObjectByCallback( &findMeshReferences, foundElements );   
+   brushSet->findObjectByCallback( &findMeshReferences, foundElements );
 
    // Add UndoAction to delete the ForestBrushElement(s) and the ForestItemData.
    MEDeleteUndoAction *elementAction = new MEDeleteUndoAction();
@@ -408,4 +414,4 @@ DefineEngineMethod(ForestEditorCtrl, setActiveForest, void, (const char * obj),
       return;
 
    object->setActiveForest(forestObject);
-}
\ No newline at end of file
+}
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/templateFiles/module.tscript.template b/Templates/BaseGame/game/tools/assetBrowser/scripts/templateFiles/module.tscript.template
index 4a9eafc7d..37a2feab9 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/templateFiles/module.tscript.template
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/templateFiles/module.tscript.template
@@ -21,6 +21,8 @@ function @@::onCreateGameServer(%this)
         %this.registerDatablock("./scripts/managedData/managedDatablocks");
     if(isFile("./scripts/managedData/managedForestItemData." @ $TorqueScriptFileExtension))
         %this.registerDatablock("./scripts/managedData/managedForestItemData");
+    if(isFile("./scripts/managedData/managedForestBrushData." @ $TorqueScriptFileExtension))
+        %this.registerDatablock("./scripts/managedData/managedForestBrushData");
     if(isFile("./scripts/managedData/managedParticleEmitterData." @ $TorqueScriptFileExtension))
         %this.registerDatablock("./scripts/managedData/managedParticleEmitterData");
     if(isFile("./scripts/managedData/managedParticleData." @ $TorqueScriptFileExtension))
diff --git a/Templates/BaseGame/game/tools/forestEditor/brushes.tscript b/Templates/BaseGame/game/tools/forestEditor/brushes.tscript
deleted file mode 100644
index 6860a8813..000000000
--- a/Templates/BaseGame/game/tools/forestEditor/brushes.tscript
+++ /dev/null
@@ -1,26 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-$forestBrushesGroup = new SimGroup( ForestBrushGroup )
-{
-};
-//--- OBJECT WRITE END ---
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/forestEditor/forestEditorGui.tscript b/Templates/BaseGame/game/tools/forestEditor/forestEditorGui.tscript
index d039d1c86..3ae57e612 100644
--- a/Templates/BaseGame/game/tools/forestEditor/forestEditorGui.tscript
+++ b/Templates/BaseGame/game/tools/forestEditor/forestEditorGui.tscript
@@ -110,17 +110,45 @@ function ForestEditorGui::createForest( %this )
 
 function ForestEditorGui::newBrush( %this )
 {   
-   %internalName = getUniqueInternalName( "Brush", ForestBrushGroup, true );
+   AssetBrowser_SelectModule.showDialog("ForestEditorGui.pickedNewBrushTargetModule");
+   AssetBrowser_SelectModuleWindow.selectWindow();
+}
+
+function ForestEditorGui::pickedNewBrushTargetModule(%this, %module)
+{   
+   %moduleDef = ModuleDatabase.findModule(%module);
+   
+   ForestEditorGui.forestBrushPath = %moduleDef.ModulePath @ "/scripts/managedData/managedForestBrushData." @ $TorqueScriptFileExtension;
+   
+   if(!isDirectory(filePath(ForestEditorGui.forestItemDataPath)))
+   {
+      AssetBrowser.dirHandler.createFolder(filePath(ForestEditorGui.forestItemDataPath));
+   }
+   
+   %group = ForestBrushSet.findObjectByInternalName(%module @ "ForestBrushGroup");
+   if(!isObject(%group))
+   {
+      %group = new ForestBrushGroup() {
+         internalName = %module @ "ForestBrushGroup";
+      };
+      
+      %group.setFilename(ForestEditorGui.forestBrushPath);
+   }
+   
+   %internalName = getUniqueInternalName( "Brush", ForestBrushSet, true );
          
    %brush = new ForestBrush()
    {
+      class = "ForestBrushGroup";
       internalName = %internalName;
-      parentGroup = ForestBrushGroup; 
+      parentGroup = ForestBrushSet; 
    };   
    
+   %group.add(%brush);
+   
    MECreateUndoAction::submit( %brush );
    
-   ForestEditBrushTree.open( ForestBrushGroup );
+   ForestEditBrushTree.open( ForestBrushSet );
    ForestEditBrushTree.buildVisibleTree(true);
    %item = ForestEditBrushTree.findItemByObjectId( %brush );
    ForestEditBrushTree.clearSelection();
@@ -135,7 +163,7 @@ function ForestEditorGui::newElement( %this )
    %sel = ForestEditBrushTree.getSelectedObject();
    
    if ( !isObject( %sel ) )
-      %parentGroup = ForestBrushGroup;
+      %parentGroup = ForestBrushSet;
    else
    {
       if ( %sel.getClassName() $= "ForestBrushElement" )  
@@ -144,7 +172,7 @@ function ForestEditorGui::newElement( %this )
          %parentGroup = %sel;
    }
       
-   %internalName = getUniqueInternalName( "Element", ForestBrushGroup, true );   
+   %internalName = getUniqueInternalName( "Element", ForestBrushSet, true );   
    
    %element = new ForestBrushElement()
    {
@@ -191,37 +219,11 @@ function ForestEditorGui::pickedNewMeshTargetModule(%this, %module)
 
 function selectNewForestMesh(%selectedShapeAssetId)
 {
-   /*%spec = "All Mesh Files|*.dts;*.dae|DTS|*.dts|DAE|*.dae";
-   
-   %dlg = new OpenFileDialog()
-   {
-      Filters        = %spec;
-      DefaultPath    = $Pref::WorldEditor::LastPath;
-      DefaultFile    = "";
-      ChangePath     = true;
-   };
-         
-   %ret = %dlg.Execute();
-   
-   if ( %ret )
-   {
-      $Pref::WorldEditor::LastPath = filePath( %dlg.FileName );
-      %fullPath = makeRelativePath( %dlg.FileName, getMainDotCSDir() );
-      %file = fileBase( %fullPath );
-   }   
-   
-   %dlg.delete();*/
-   
    if ( %selectedShapeAssetId $= "")
       return;
          
    %name = getUniqueName( AssetDatabase.getAssetName(%selectedShapeAssetId) );
       
-   //%str = "datablock TSForestItemData( " @ %name @ " ) { shapeFile = \"" @ %fullPath @ "\"; };";            
-   //eval( %str );
-   
-   //%fullPath = AssetDatabase.acquireAsset(%selectedShapeAssetId).getShapePath();
-   
    new TSForestItemData(%name) {
       shapeAsset = %selectedShapeAssetId;
    };
@@ -418,7 +420,7 @@ function ForestEditBrushTree::handleRenameObject( %this, %name, %obj )
 {   
    if ( %name !$= "" )
    {       
-      %found = ForestBrushGroup.findObjectByInternalName( %name );
+      %found = ForestBrushSet.findObjectByInternalName( %name );
       if ( isObject( %found ) && %found.getId() != %obj.getId() )
       {
          toolsMessageBoxOK( "Error", "Brush or Element with that name already exists.", "" );   
diff --git a/Templates/BaseGame/game/tools/forestEditor/main.tscript b/Templates/BaseGame/game/tools/forestEditor/main.tscript
index be2814baa..a2e057def 100644
--- a/Templates/BaseGame/game/tools/forestEditor/main.tscript
+++ b/Templates/BaseGame/game/tools/forestEditor/main.tscript
@@ -91,25 +91,7 @@ function ForestEditorPlugin::onWorldEditorStartup( %this )
 {       
    new PersistenceManager( ForestDataManager );
    
-   %brushPath = "tools/forestEditor/brushes." @ $TorqueScriptFileExtension;
-   
-   if ( !isFile( %brushPath ) )   
-      %successfulFile = createPath( %brushPath );       
-      
-   // This creates the ForestBrushGroup, all brushes, and elements.
-   exec( %brushpath );         
-   
-   if ( !isObject( ForestBrushGroup ) )
-   {
-      new SimGroup( ForestBrushGroup );
-      %this.showError = true;      
-   }
-      
-   ForestEditBrushTree.open( ForestBrushGroup );   
-            
-   if ( !isObject( ForestItemDataSet ) )
-      new SimSet( ForestItemDataSet );
-      
+   ForestEditBrushTree.open( ForestBrushSet );   
    ForestEditMeshTree.open( ForestItemDataSet );
 
    // Add ourselves to the window menu.
@@ -126,8 +108,8 @@ function ForestEditorPlugin::onWorldEditorStartup( %this )
 
 function ForestEditorPlugin::onWorldEditorShutdown( %this )
 {
-   if ( isObject( ForestBrushGroup ) )   
-      ForestBrushGroup.delete();
+   if ( isObject( ForestBrushSet ) )   
+      ForestBrushSet.delete();
    if ( isObject( ForestDataManager ) )
       ForestDataManager.delete();
 }
@@ -153,7 +135,7 @@ function ForestEditorPlugin::onActivated( %this )
    %this.map.push();
    Parent::onActivated(%this);   
    
-   ForestEditBrushTree.open( ForestBrushGroup );   
+   ForestEditBrushTree.open( ForestBrushSet );   
    ForestEditMeshTree.open( ForestItemDataSet );
    
    // Open the Brush tab.
@@ -224,12 +206,26 @@ function ForestEditorPlugin::onDeactivated( %this )
    
    // Also take this opportunity to save.
    ForestDataManager.saveDirty();
+   %this.saveBrushSet();
    
    %this.map.pop();
    
    Parent::onDeactivated(%this);
 }
 
+function ForestEditorPlugin::saveBrushSet(%this)
+{
+   for(%i=0; %i < ForestBrushSet.getCount(); %i++)
+   {
+      %group = ForestBrushSet.getObject(%i);
+      if(%group.isMemberOfClass("ForestBrushGroup"))
+      {
+         %fileName = %group.getFileName();
+         %group.save(%group.getFileName());  
+      }
+   }
+}
+
 function ForestEditorPlugin::isDirty( %this )
 {
    %dirty = %this.dirty || ForestEditorGui.isDirty();
@@ -266,7 +262,8 @@ function ForestEditorPlugin::onSaveMission( %this, %missionFile )
       }
    }
       
-   ForestBrushGroup.save( "tools/forestEditor/brushes." @ $TorqueScriptFileExtension );
+   //Make sure our data is up to date too
+   %this.saveBrushSet();
 }
 
 function ForestEditorPlugin::onEditorSleep( %this )

From bcc7f2f6cf4981e076a5074d41ee25894efba116 Mon Sep 17 00:00:00 2001
From: Tony <1414927+zfbx@users.noreply.github.com>
Date: Thu, 7 Apr 2022 20:30:25 -0400
Subject: [PATCH 356/399] Add funding/sponsor options for support

More options can be seen here https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/displaying-a-sponsor-button-in-your-repository
---
 .github/FUNDING.yml | 2 ++
 1 file changed, 2 insertions(+)
 create mode 100644 .github/FUNDING.yml

diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 000000000..3253c4ca2
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1,2 @@
+github: [Areloch, Azaezel]
+patreon: Areloch

From 4e78800ae07305aebddc8038584cc1044ff0e451 Mon Sep 17 00:00:00 2001
From: Tony <1414927+zfbx@users.noreply.github.com>
Date: Thu, 7 Apr 2022 20:54:57 -0400
Subject: [PATCH 357/399] Updated readme with new links

The release, downloads and tag will update once a tag is created and a release is pushed
---
 README.md | 34 +++++++++++++++++++++-------------
 1 file changed, 21 insertions(+), 13 deletions(-)

diff --git a/README.md b/README.md
index 03b9870b8..9049918d5 100644
--- a/README.md
+++ b/README.md
@@ -1,28 +1,36 @@
-# Torque 3D
+# Torque3D
 
-MIT Licensed Open Source version of [Torque 3D](http://torque3d.org) from [GarageGames](http://www.garagegames.com)
+MIT Licensed Open Source version of [Torque3D](https://torque3d.org) from [GarageGames](http://www.garagegames.com)
 
-[![GitHub tag](https://img.shields.io/github/tag/GarageGames/Torque3D.svg)](https://github.com/GarageGames/Torque3D/tags)
-[![GitHub release](https://img.shields.io/github/release/GarageGames/Torque3D.svg)](https://github.com/GarageGames/Torque3D/releases/latest)
-[![Github All Releases](https://img.shields.io/github/downloads/GarageGames/Torque3D/total.svg)](https://github.com/GarageGames/Torque3D/releases/latest)
+[![GitHub tag](https://img.shields.io/github/tag/TorqueGameEngines/Torque3D.svg)](https://github.com/TorqueGameEngines/Torque3D/tags)
+[![GitHub release](https://img.shields.io/github/release/TorqueGameEngines/Torque3D.svg)](https://github.com/TorqueGameEngines/Torque3D/releases/latest)
+[![Github All Releases](https://img.shields.io/github/downloads/TorqueGameEngines/Torque3D/total.svg)](https://github.com/TorqueGameEngines/Torque3D/releases/latest)
 
-[![Discord](https://img.shields.io/badge/Discord%20-%237289DA.svg?&logo=discord&logoColor=white)](https://discord.com/invite/qdAZxT4) [![IRC](https://img.shields.io/badge/irc-%23garagegames-green.svg)](https://kiwiirc.com/client/irc.maxgaming.net/?nick=wiki_user|?#garagegames) 
+[![Discord](https://img.shields.io/badge/Discord%20-%237289DA.svg?&logo=discord&logoColor=white)](https://discord.com/invite/qdAZxT4)
+[![IRC](https://img.shields.io/badge/irc-%23garagegames-green.svg)](https://kiwiirc.com/client/irc.maxgaming.net/?nick=wiki_user|?#garagegames) 
 
 ## More Information
 
-* [Homepage](http://torque3d.org)
+* [Homepage](https://torque3d.org)
 * [Torque 3D wiki](http://wiki.torque3d.org)
-* [Community forum](http://forums.torque3d.org)
-* [GarageGames forum](http://www.garagegames.com/community/forums)
-* [GarageGames professional services](http://services.garagegames.com/)
+* [Community forum](https://torque3d.org/forums)
+* [Binaries](https://github.com/TorqueGameEngines/Torque3D-Binaries)
+* [Guide Docs](https://torque3d.org/docs/t3d/)
+* [Reference Docs](https://reference.torque3d.org/)
+* [Work Blog](https://torque3d.org/blogs/blog/1-work-blog/)
+
+**Extras:**
+[Torque3D Resources](https://github.com/Torque3DResources) | [Awesome Torque3D](https://github.com/TorqueGameEngines/awesome-torque3d)
 
 ## Pre-compiled Version
 
 In addition to GitHub we also have a couple of pre-packaged files for you to download if you would prefer to not compile the code yourself.
-They are available from the [downloads](http://wiki.torque3d.org/main:downloads) page on the wiki.
-
-## Related repositories
+They are available from the [Torque3D Binaries](https://github.com/TorqueGameEngines/Torque3D-Binaries) repo.
 
+### Legacy Links
+* [Legacy Repository](https://github.com/GarageGames/Torque3D)
+* [GarageGames forum](http://www.garagegames.com/community/forums)
+* [GarageGames professional services](http://services.garagegames.com/)
 * [Project Manager repository](https://github.com/GarageGames/Torque3D-ProjectManager)
 * [Offline documentation repository](https://github.com/Torque3D-GameEngine/Torque3D-Documentation)
 

From 20a29027a10b738e7aef9011a21e032c8c08f24a Mon Sep 17 00:00:00 2001
From: Tony <1414927+zfbx@users.noreply.github.com>
Date: Fri, 8 Apr 2022 18:03:37 -0400
Subject: [PATCH 358/399] add roadmap link

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

diff --git a/README.md b/README.md
index 9049918d5..5576d323c 100644
--- a/README.md
+++ b/README.md
@@ -14,6 +14,7 @@ MIT Licensed Open Source version of [Torque3D](https://torque3d.org) from [Garag
 * [Homepage](https://torque3d.org)
 * [Torque 3D wiki](http://wiki.torque3d.org)
 * [Community forum](https://torque3d.org/forums)
+* [Roadmap](https://github.com/orgs/TorqueGameEngines/projects/1)
 * [Binaries](https://github.com/TorqueGameEngines/Torque3D-Binaries)
 * [Guide Docs](https://torque3d.org/docs/t3d/)
 * [Reference Docs](https://reference.torque3d.org/)

From 7cb438550d5401d996f1b7e5ab8231e608a5ea0a Mon Sep 17 00:00:00 2001
From: Tony <1414927+zfbx@users.noreply.github.com>
Date: Fri, 8 Apr 2022 18:04:21 -0400
Subject: [PATCH 359/399] Update FUNDING.yml

---
 .github/FUNDING.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
index 3253c4ca2..1d6713a29 100644
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -1,2 +1,2 @@
-github: [Areloch, Azaezel]
+github: Areloch
 patreon: Areloch

From 5c8d8fab005a15a071002d91b0063ebe1750d725 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Sun, 10 Apr 2022 01:40:15 -0500
Subject: [PATCH 360/399] Changes behavior with suffix appending of asset
 importer so it doesn't contaminate the original "clean" name, which is used
 for setting the mapTo value of material definitions Also adds a sanity check
 when applying the type suffix to see if it's already there to avoid needless
 doubleups Fixes offsetting/positioning behavior on icon buttons to actually
 respect the icon position variable Adds sanity checks to ensure we're not
 trying to utilize a in-process-of-deleting decoy dummy Fixes handling of
 sliders in option menus to properly store and test unapplied values Fixes
 handling of display device setting to properly store and test unapplied
 values Adds additional logic to creation of shape and material asset previews
 to attempt to force-load dependencies to improve likelihood that they'll
 actually be loaded when we go to generate the preview. Temp disables creating
 cubemap 'assets' via the RMB context menu in the AB

---
 Engine/source/T3D/assets/assetImporter.cpp    | 30 +++++++--------
 Engine/source/console/fileSystemFunctions.cpp | 16 ++++++++
 .../source/gui/buttons/guiIconButtonCtrl.cpp  | 37 ++++++++++++++++---
 Engine/source/gui/controls/guiDecoyCtrl.cpp   |  6 ++-
 .../game/data/UI/guis/optionsMenu.tscript     | 29 +++++++++++----
 .../scripts/assetTypes/material.tscript       |  9 ++++-
 .../scripts/assetTypes/shape.tscript          | 11 +++++-
 .../assetBrowser/scripts/popupMenus.tscript   |  1 +
 8 files changed, 108 insertions(+), 31 deletions(-)

diff --git a/Engine/source/T3D/assets/assetImporter.cpp b/Engine/source/T3D/assets/assetImporter.cpp
index d0b498d26..de19bc983 100644
--- a/Engine/source/T3D/assets/assetImporter.cpp
+++ b/Engine/source/T3D/assets/assetImporter.cpp
@@ -1633,7 +1633,7 @@ void AssetImporter::processImageAsset(AssetImportObject* assetItem)
          {
             String diffuseToken = StringUnit::getUnit(activeImportConfig->DiffuseTypeSuffixes, 0, ",;\t");
             assetItem->assetName = assetItem->assetName + diffuseToken;
-            assetItem->cleanAssetName = assetItem->assetName;
+            //assetItem->cleanAssetName = assetItem->assetName;
          }
          else
          {
@@ -1642,7 +1642,7 @@ void AssetImporter::processImageAsset(AssetImportObject* assetItem)
             if ((materialAsset && materialAsset->assetName.compare(assetItem->assetName) == 0) || activeImportConfig->AlwaysAddImageSuffix)
             {
                assetItem->assetName = assetItem->assetName + activeImportConfig->AddedImageSuffix;
-               assetItem->cleanAssetName = assetItem->assetName;
+               //assetItem->cleanAssetName = assetItem->assetName;
             }
          }
 
@@ -1673,8 +1673,8 @@ void AssetImporter::processImageAsset(AssetImportObject* assetItem)
 
    if(assetItem->assetName == assetItem->cleanAssetName && activeImportConfig->AlwaysAddImageSuffix)
    {
-      assetItem->assetName = assetItem->assetName + activeImportConfig->AddedImageSuffix;
-      assetItem->cleanAssetName = assetItem->assetName;
+      if (!assetItem->assetName.endsWith(activeImportConfig->AddedImageSuffix.c_str()))
+         assetItem->assetName = assetItem->assetName + activeImportConfig->AddedImageSuffix;
    }
 
    assetItem->importStatus = AssetImportObject::Processed;
@@ -1752,8 +1752,8 @@ void AssetImporter::processMaterialAsset(AssetImportObject* assetItem)
    {
       if (activeImportConfig->AlwaysAddMaterialSuffix) //we only opt to force on the suffix if we're not obligating using the original material defs
       {
-         assetItem->assetName += activeImportConfig->AddedMaterialSuffix;
-         assetItem->cleanAssetName = assetItem->assetName;
+         if(!assetItem->assetName.endsWith(activeImportConfig->AddedMaterialSuffix.c_str()))
+            assetItem->assetName += activeImportConfig->AddedMaterialSuffix;
       }
 
       if (activeImportConfig->PopulateMaterialMaps)
@@ -1936,7 +1936,7 @@ void AssetImporter::processMaterialAsset(AssetImportObject* assetItem)
                      if (newImageAssetObj->assetName == assetItem->assetName)
                      {
                         newImageAssetObj->assetName += StringUnit::getUnit(suffixList.c_str(), 0, ",;\t");
-                        newImageAssetObj->cleanAssetName = newImageAssetObj->assetName;
+                        //newImageAssetObj->cleanAssetName = newImageAssetObj->assetName;
                      }
 
                      newImageAssetObj->imageSuffixType = ImageAsset::getImageTypeNameFromType(ImageAsset::ImageTypes::Albedo);
@@ -1954,7 +1954,7 @@ void AssetImporter::processMaterialAsset(AssetImportObject* assetItem)
                if (matchedImageTypes[t]->assetName == assetItem->assetName)
                {
                   matchedImageTypes[t]->assetName += StringUnit::getUnit(suffixList.c_str(), 0, ",;\t");
-                  matchedImageTypes[t]->cleanAssetName = matchedImageTypes[t]->assetName;
+                  //matchedImageTypes[t]->cleanAssetName = matchedImageTypes[t]->assetName;
                }
             }
          }
@@ -2000,8 +2000,8 @@ void AssetImporter::processShapeAsset(AssetImportObject* assetItem)
 
    if (activeImportConfig->AlwaysAddShapeSuffix)
    {
-      assetItem->assetName += activeImportConfig->AddedShapeSuffix;
-      assetItem->cleanAssetName = assetItem->assetName;
+      if(!assetItem->assetName.endsWith(activeImportConfig->AddedShapeSuffix.c_str()))
+         assetItem->assetName += activeImportConfig->AddedShapeSuffix;
    }
 
    S32 meshCount = dAtoi(assetItem->shapeInfo->getDataField(StringTable->insert("_meshCount"), nullptr));
@@ -2094,8 +2094,8 @@ void AssetImporter::processShapeAnimationAsset(AssetImportObject* assetItem)
 
    if (activeImportConfig->AlwaysAddShapeAnimationSuffix)
    {
-      assetItem->assetName += activeImportConfig->AddedShapeAnimationSuffix;
-      assetItem->cleanAssetName = assetItem->assetName;
+      if (!assetItem->assetName.endsWith(activeImportConfig->AddedShapeAnimationSuffix.c_str()))
+         assetItem->assetName += activeImportConfig->AddedShapeAnimationSuffix;
    }
 
    S32 animCount = dAtoi(assetItem->shapeInfo->getDataField(StringTable->insert("_animCount"), nullptr));
@@ -2237,8 +2237,8 @@ void AssetImporter::processSoundAsset(AssetImportObject* assetItem)
 
    if (activeImportConfig->AlwaysAddSoundSuffix)
    {
-      assetItem->assetName += activeImportConfig->AddedSoundSuffix;
-      assetItem->cleanAssetName = assetItem->assetName;
+      if (!assetItem->assetName.endsWith(activeImportConfig->AddedSoundSuffix.c_str()))
+         assetItem->assetName += activeImportConfig->AddedSoundSuffix;
    }
 
    assetItem->importStatus = AssetImportObject::Processed;
@@ -2916,7 +2916,7 @@ Torque::Path AssetImporter::importMaterialAsset(AssetImportObject* assetItem)
    {
       Material* newMat = new Material();
       newMat->registerObject(assetName);
-      newMat->mMapTo = assetName;
+      newMat->mMapTo = assetItem->cleanAssetName;
 
       bool hasRoughness = false;
       for (U32 i = 0; i < assetItem->childAssetItems.size(); i++)
diff --git a/Engine/source/console/fileSystemFunctions.cpp b/Engine/source/console/fileSystemFunctions.cpp
index 010147af2..3f43e962d 100644
--- a/Engine/source/console/fileSystemFunctions.cpp
+++ b/Engine/source/console/fileSystemFunctions.cpp
@@ -892,4 +892,20 @@ DefineEngineFunction( createPath, bool, ( const char* path ),,
    return Platform::createPath( pathName );
 }
 
+DefineEngineFunction(deleteDirectory, bool, (const char* path), ,
+   "@brief Delete a directory from the hard drive\n\n"
+
+   "@param path Name and path of the folder to delete\n"
+   "@note THERE IS NO RECOVERY FROM THIS. Deleted files are gone for good.\n"
+   "@return True if file was successfully deleted\n"
+   "@ingroup FileSystem")
+{
+   static char fileName[1024];
+   static char sandboxFileName[1024];
+
+   Con::expandScriptFilename(fileName, sizeof(fileName), path);
+   Platform::makeFullPathName(fileName, sandboxFileName, sizeof(sandboxFileName));
+
+   return Platform::deleteDirectory(sandboxFileName);
+}
 #endif // TORQUE_TOOLS
diff --git a/Engine/source/gui/buttons/guiIconButtonCtrl.cpp b/Engine/source/gui/buttons/guiIconButtonCtrl.cpp
index 57f9f9123..32b5be36b 100644
--- a/Engine/source/gui/buttons/guiIconButtonCtrl.cpp
+++ b/Engine/source/gui/buttons/guiIconButtonCtrl.cpp
@@ -240,10 +240,15 @@ void GuiIconButtonCtrl::renderButton( Point2I &offset, const RectI& updateRect )
    {
       // If there is a bitmap array then render using it.  
       // Otherwise use a standard fill.
-      if(mProfile->mUseBitmapArray && mProfile->mBitmapArrayRects.size())
+      if (mProfile->mUseBitmapArray && mProfile->mBitmapArrayRects.size())
+      {
          renderBitmapArray(boundsRect, stateMouseOver);
+      }
       else
-         renderSlightlyRaisedBox(boundsRect, mProfile);
+      {
+         drawer->drawRectFill(boundsRect, mProfile->mFillColorHL);
+         drawer->drawRect(boundsRect, mProfile->mBorderColorHL);
+      }
    }
    else
    {
@@ -258,8 +263,16 @@ void GuiIconButtonCtrl::renderButton( Point2I &offset, const RectI& updateRect )
       }
       else
       {
-         drawer->drawRectFill(boundsRect, mProfile->mFillColorNA);
-         drawer->drawRect(boundsRect, mProfile->mBorderColorNA);
+         if (mActive)
+         {
+            drawer->drawRectFill(boundsRect, mProfile->mFillColor);
+            drawer->drawRect(boundsRect, mProfile->mBorderColor);
+         }
+         else
+         {
+            drawer->drawRectFill(boundsRect, mProfile->mFillColorNA);
+            drawer->drawRect(boundsRect, mProfile->mBorderColorNA);
+         }
       }
    }
 
@@ -302,7 +315,7 @@ void GuiIconButtonCtrl::renderButton( Point2I &offset, const RectI& updateRect )
       } 
       else
       {
-         iconRect.set( offset + mButtonMargin, getExtent() - (mButtonMargin * 2) );
+         iconRect.set( offset + mButtonMargin, getExtent() - (Point2I(mAbs(mButtonMargin.x), mAbs(mButtonMargin.y)) * 2) );
          
          if ( mMakeIconSquare )
          {
@@ -313,6 +326,20 @@ void GuiIconButtonCtrl::renderButton( Point2I &offset, const RectI& updateRect )
                iconRect.extent.x = iconRect.extent.y;            
          }
 
+         if (mIconLocation == IconLocRight)
+         {
+            iconRect.point.x = (offset.x + getWidth()) - iconRect.extent.x + mButtonMargin.x;
+         }
+         else if (mIconLocation == IconLocLeft)
+         {
+            //default state presumes left positioning
+         }
+         else if (mIconLocation == IconLocCenter)
+         {
+            iconRect.point.x = offset.x + (getWidth() / 2) - (iconRect.extent.x / 2) + mButtonMargin.x;
+            iconRect.point.y = offset.y + (getHeight() / 2) - (iconRect.extent.y / 2) + mButtonMargin.y;
+         }
+
          drawer->drawBitmapStretch( mBitmap, iconRect );
       }
    }
diff --git a/Engine/source/gui/controls/guiDecoyCtrl.cpp b/Engine/source/gui/controls/guiDecoyCtrl.cpp
index 61b489995..54ca105ae 100644
--- a/Engine/source/gui/controls/guiDecoyCtrl.cpp
+++ b/Engine/source/gui/controls/guiDecoyCtrl.cpp
@@ -146,12 +146,14 @@ void GuiDecoyCtrl::onMouseMove(const GuiEvent &event)
 		GuiControl *tempControl = parent->findHitControl(localPoint);
 
 		//the decoy control has the responsibility of keeping track of the decoyed controls status
-		if(mMouseOverDecoy == false && mDecoyReference != NULL)
+		if(mMouseOverDecoy == false && mDecoyReference != NULL &&
+               !mDecoyReference->isDeleted() && !mDecoyReference->isRemoved())
 		{
 			tempControl->onMouseEnter(event);
 			mMouseOverDecoy = true;
 		}
-		else if(tempControl != mDecoyReference && mDecoyReference != NULL)
+		else if(tempControl != mDecoyReference && mDecoyReference != NULL &&
+               !mDecoyReference->isDeleted() && !mDecoyReference->isRemoved())
 		{
 			mDecoyReference->onMouseLeave(event);
 			mMouseOverDecoy = false;
diff --git a/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript b/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
index 2dd1d7f10..aa343f81f 100644
--- a/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
+++ b/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
@@ -200,7 +200,7 @@ function OptionsMenu::apply(%this)
             //for updates
             if ( %targetVar $= "$pref::Video::displayDevice" )
             {
-               MessageBoxOK( "Change requires restart", "Please restart the game for a display device change to take effect." );
+               schedule(32, 0, "MessageBoxOK", "Change requires restart", "Please restart the game for a display device change to take effect.");
             }
             else if(startsWith(%targetVar, "$pref::PostFX::"))
             {
@@ -349,11 +349,6 @@ function populateDisplaySettingsList()
    OptionName.setText("");
    OptionDescription.setText("");
    
-   //First, lets double-check the active device is accurate. Sometimes the default value in our prefs doesn't match the active one
-   %displayDevice = getDisplayDeviceType();
-   if($changingDisplayDevice !$= "")
-      %displayDevice = $changingDisplayDevice;
-      
    %apiList = "";
    %apiCount = GFXInit::getAdapterCount();
    %apiIdx = 0;
@@ -374,7 +369,11 @@ function populateDisplaySettingsList()
    
    trim(%apiList);
    
-   OptionsMenuSettingsList.addOptionRow("Display API", "$pref::Video::DisplayAPI", %apiList, false, "",  true, "The display API used for rendering.", %displayDevice);
+   %displayDevice = OptionsMenu.getOptionVariableValue("$pref::Video::displayDevice");
+   if(%displayDevice $= "")
+      %displayDevice = getDisplayDeviceType();
+   
+   OptionsMenuSettingsList.addOptionRow("Display API", "$pref::Video::displayDevice", %apiList, false, "",  true, "The display API used for rendering.", %displayDevice);
    
    %numDevices = Canvas.getMonitorCount();
    %devicesList = "";
@@ -977,6 +976,8 @@ function MenuOptionsButton::onChange(%this)
    OptionName.setText(%optionName);
    OptionDescription.setText(%tooltipText);
    
+   if(%optionMode == 0)
+   {
    %currentValue = %this.getCurrentOption();
    if(%currentValue !$= "")
    {
@@ -995,6 +996,20 @@ function MenuOptionsButton::onChange(%this)
       }
       else
          OptionsMenu.unappliedChanges.setValue("\"" @ %saveReadyValue @ "\"", %prefIndex);
+      }
+   }
+   else if(%optionMode == 1)
+   {
+      %currentValue = %this.getValue();
+      
+      %prefIndex = OptionsMenu.unappliedChanges.getIndexFromKey(%targetVar);
+      if(%prefIndex == -1)
+      {
+         echo("Setting UnappliedChanges via add: key:" @ %targetVar @", value: " @ %currentValue);
+         OptionsMenu.unappliedChanges.add(%targetVar, "\"" @ %currentValue @ "\"" );
+      }
+      else
+         OptionsMenu.unappliedChanges.setValue("\"" @ %currentValue @ "\"", %prefIndex);
    }
    
    //Update the UI in case there's responsive logic
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
index debcaffd8..d6d48819c 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
@@ -462,10 +462,17 @@ function AssetBrowser::buildMaterialAssetPreview(%this, %assetDef, %previewData,
    
       if(isObject(%assetDef.materialDefinitionName))
       {
+         //real fast, we'll be 100% sure that the image resource we need is loaded
+         %diffuseMapAssetId = %assetDef.materialDefinitionName.getDiffuseMapAsset(0);
+         if(AssetDatabase.isDeclaredAsset(%diffuseMapAssetId))
+         {
+            %diffuseMapAsset = AssetDatabase.acquireAsset(%diffuseMapAssetId);
+            AssetDatabase.releaseAsset(%diffuseMapAssetId);
+         }
          %previewShapeDef = AssetDatabase.acquireAsset("ToolsModule:previewSphereShape");
          %generatedFilePath = %previewShapeDef.generateCachedPreviewImage(256, %assetDef.materialDefinitionName);
       
-         pathCopy(%generatedFilePath, %previewFilePath);
+         pathCopy(%generatedFilePath, %previewFilePath, false);
          fileDelete(%generatedFilePath);
 
          if(!AssetDatabase.isDeclaredAsset("ToolsModule:" @ %previewAssetName))
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
index 250e7c6ac..c70750e90 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
@@ -290,12 +290,21 @@ function AssetBrowser::buildShapeAssetPreview(%this, %assetDef, %previewData, %f
    {
       displayEditorLoadingGui("Generating Shape Asset Preview...");
       
+      //real fast, we'll be 100% sure that the image resource we need is loaded
+      
+      %matSlot0AssetId = %assetDef.materialSlot0;
+      if(AssetDatabase.isDeclaredAsset(%matSlot0AssetId))
+      {
+         %matAsset = AssetDatabase.acquireAsset(%matSlot0AssetId);
+         AssetDatabase.releaseAsset(%matSlot0AssetId);
+      }
+      
       //This is slightly hacky, but we're going to utilize the imposter/last detail system
       //to generate our previews for us and then clean up the unneeded bits
       
       %filePath = %assetDef.generateCachedPreviewImage();
       
-      pathCopy(%filePath, %previewFilePath);
+      pathCopy(%filePath, %previewFilePath, false);
       fileDelete(%filePath); //cleanup
       
       if(!AssetDatabase.isDeclaredAsset("ToolsModule:" @ %previewAssetName))
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/popupMenus.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/popupMenus.tscript
index 808649d86..27d198e8e 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/popupMenus.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/popupMenus.tscript
@@ -237,6 +237,7 @@ function AssetBrowser::buildPopupMenus(%this)
    AddNewArtAssetPopup.enableItem(7, false); //shape animation
    AddNewArtAssetPopup.enableItem(13, false); //sound asset
    AddNewArtAssetPopup.enableItem(15, false); //particle effect
+   AddNewArtAssetPopup.enableItem(17, false); //cubemap
    
    if( !isObject( EditFolderPopup ) )
    {

From 0136af477f8989f90794b6cd86d4065b8f31ab54 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Sun, 10 Apr 2022 17:29:55 -0500
Subject: [PATCH 361/399] getAssetIdByFilename loaded state fix
 getAssetIdByFilename should set the <type>Asset->mLoadedState =
 AssetErrCode::BadFileReference; so we know we're using a fallback

---
 Engine/source/T3D/assets/ImageAsset.cpp | 5 +++++
 Engine/source/T3D/assets/ShapeAsset.cpp | 5 +++++
 2 files changed, 10 insertions(+)

diff --git a/Engine/source/T3D/assets/ImageAsset.cpp b/Engine/source/T3D/assets/ImageAsset.cpp
index d49cfbf85..78515d877 100644
--- a/Engine/source/T3D/assets/ImageAsset.cpp
+++ b/Engine/source/T3D/assets/ImageAsset.cpp
@@ -219,6 +219,11 @@ StringTableEntry ImageAsset::getAssetIdByFilename(StringTableEntry fileName)
       //acquire and bind the asset, and return it out
       imageAssetId = query.mAssetList[0];
    }
+   else
+   {
+      AssetPtr<ImageAsset> imageAsset = imageAssetId;
+      imageAsset->mLoadedState = AssetErrCode::BadFileReference;
+   }
 
    return imageAssetId;
 }
diff --git a/Engine/source/T3D/assets/ShapeAsset.cpp b/Engine/source/T3D/assets/ShapeAsset.cpp
index 231d42cb9..a3aafe055 100644
--- a/Engine/source/T3D/assets/ShapeAsset.cpp
+++ b/Engine/source/T3D/assets/ShapeAsset.cpp
@@ -473,6 +473,11 @@ StringTableEntry ShapeAsset::getAssetIdByFilename(StringTableEntry fileName)
       //acquire and bind the asset, and return it out
       shapeAssetId = query.mAssetList[0];
    }
+   else
+   {
+      AssetPtr<ShapeAsset> shapeAsset = shapeAssetId;
+      shapeAsset->mLoadedState = AssetErrCode::BadFileReference;
+   }
 
    return shapeAssetId;
 }

From 1c7c32baa6c271dc35106ca3988f7e71d19c6ad5 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Sun, 10 Apr 2022 19:41:37 -0500
Subject: [PATCH 362/399] Separates out acquireAsset call for importing assets
 until after all assets have been imported, then runs it as a post step to
 ensure all assets are properly loaded before they're used

---
 Engine/source/T3D/assets/MaterialAsset.cpp    |  5 ---
 Engine/source/T3D/assets/assetImporter.cpp    | 37 ++++++++++++++++---
 Engine/source/T3D/assets/assetImporter.h      |  6 +++
 .../T3D/assets/assetImporter_ScriptBinding.h  |  4 +-
 4 files changed, 41 insertions(+), 11 deletions(-)

diff --git a/Engine/source/T3D/assets/MaterialAsset.cpp b/Engine/source/T3D/assets/MaterialAsset.cpp
index 77b22cc24..6153cd3e8 100644
--- a/Engine/source/T3D/assets/MaterialAsset.cpp
+++ b/Engine/source/T3D/assets/MaterialAsset.cpp
@@ -174,11 +174,6 @@ void MaterialAsset::initializeAsset()
       return;
    }
 
-   if (mMatDefinitionName == StringTable->insert("DetailBlue"))
-   {
-      bool asdfsd = true;
-   }
-
    if (size() != 0 && mScriptPath == StringTable->EmptyString())
    {
       mLoadedState = EmbeddedDefinition;
diff --git a/Engine/source/T3D/assets/assetImporter.cpp b/Engine/source/T3D/assets/assetImporter.cpp
index de19bc983..865af276f 100644
--- a/Engine/source/T3D/assets/assetImporter.cpp
+++ b/Engine/source/T3D/assets/assetImporter.cpp
@@ -1727,7 +1727,8 @@ void AssetImporter::processMaterialAsset(AssetImportObject* assetItem)
 
       //If there was no existing assetId, then lets see if it already exists in a legacy file, like a materials.cs or materials.tscript
       //If it does, we'll just make our asset point to that instead of a new file
-      Material* mat = MATMGR->getMaterialDefinitionByName(assetName);
+      Material* mat;
+      Sim::findObject(assetName, mat);
 
       if (!mat)
          mat = MATMGR->getMaterialDefinitionByMapTo(assetName);
@@ -2618,6 +2619,8 @@ StringTableEntry AssetImporter::autoImportFile(Torque::Path filePath, String typ
    else
    {
       importAssets();
+
+      acquireAssets();
    }
 
    dumpActivityLog();
@@ -2729,10 +2732,6 @@ void AssetImporter::importAssets(AssetImportObject* assetItem)
                      tss->setShapeAssetId(assetId);
                }
             }
-
-            //Go ahead and force the asset to load now just to kick it for immediate use
-            AssetBase* assetDef = AssetDatabase.acquireAsset<AssetBase>(assetId);
-            AssetDatabase.releaseAsset(assetId);
          }
          else
          {
@@ -2757,6 +2756,34 @@ void AssetImporter::importAssets(AssetImportObject* assetItem)
    dumpActivityLog();
 }
 
+void AssetImporter::acquireAssets(AssetImportObject* assetItem)
+{
+   Vector<AssetImportObject*> itemList = importingAssets;
+   if (assetItem != nullptr)
+      itemList = assetItem->childAssetItems;
+
+   for (U32 i = 0; i < itemList.size(); i++)
+   {
+      AssetImportObject* item = itemList[i];
+      if (item->importStatus == AssetImportObject::Skipped ||
+         item->importStatus == AssetImportObject::NotProcessed ||
+         item->importStatus == AssetImportObject::Error)
+         continue;
+
+      //recurse if needed, we want to process child items first for dependency reasons
+      acquireAssets(item);
+
+      //Go ahead and force the asset to load now just to kick it for immediate use
+      String assetId = item->moduleName + ":" + item->assetName;
+
+      if (AssetDatabase.isDeclaredAsset(assetId))
+      {
+         AssetBase* assetDef = AssetDatabase.acquireAsset<AssetBase>(assetId);
+         AssetDatabase.releaseAsset(assetId);
+      }
+   }
+}
+
 //
 // Type-specific import logic
 //
diff --git a/Engine/source/T3D/assets/assetImporter.h b/Engine/source/T3D/assets/assetImporter.h
index 4e2fc53aa..6e77ef965 100644
--- a/Engine/source/T3D/assets/assetImporter.h
+++ b/Engine/source/T3D/assets/assetImporter.h
@@ -914,6 +914,12 @@ public:
    /// </summary>
    Torque::Path importShapeAnimationAsset(AssetImportObject* assetItem);
 
+   /// <summary>
+   /// Iterates over all the items in the current session and acquires them, which jumpstarts the loading/init'ng process on them, making the available for use immediately
+   /// <para>@param assetItem, if null, will loop over and recurse the main import asset items, if a specific AssetImportObject is passed in, it will recurse it's children</para>
+   /// </summary>
+   void acquireAssets(AssetImportObject* assetItem = nullptr);
+
    //
    /// <summary>
    /// Gets the currently active import configuration
diff --git a/Engine/source/T3D/assets/assetImporter_ScriptBinding.h b/Engine/source/T3D/assets/assetImporter_ScriptBinding.h
index aa50c82de..a9a94672b 100644
--- a/Engine/source/T3D/assets/assetImporter_ScriptBinding.h
+++ b/Engine/source/T3D/assets/assetImporter_ScriptBinding.h
@@ -92,7 +92,9 @@ DefineEngineMethod(AssetImporter, resolveAssetItemIssues, void, (AssetImportObje
 DefineEngineMethod(AssetImporter, importAssets, void, (),,
    "Runs the actual import action on the items.")
 {
-   return object->importAssets();
+   object->importAssets();
+
+   object->acquireAssets();
 }
 
 DefineEngineMethod(AssetImporter, getAssetItemCount, S32, (),,

From 880ac5a264b86e7b52c052f5e2652889e5716c1c Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Tue, 12 Apr 2022 19:46:19 -0500
Subject: [PATCH 363/399] bump down saveScaledImage default to 256 also add a
 "Assets/Browser/PreviewImageSize" value lookup, which if left blank defaults
 to 256

---
 Engine/source/gfx/bitmap/gBitmap.cpp                          | 4 ++--
 .../game/tools/assetBrowser/scripts/assetTypes/image.tscript  | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Engine/source/gfx/bitmap/gBitmap.cpp b/Engine/source/gfx/bitmap/gBitmap.cpp
index 21e1351f8..281ee7a5d 100644
--- a/Engine/source/gfx/bitmap/gBitmap.cpp
+++ b/Engine/source/gfx/bitmap/gBitmap.cpp
@@ -1362,7 +1362,7 @@ DefineEngineFunction( getBitmapInfo, String, ( const char *filename ),,
                                           image->getFormat());
 }
 
-DefineEngineFunction(saveScaledImage, bool, (const char* bitmapSource, const char* bitmapDest, S32 resolutionSize), ("", "", 512),
+DefineEngineFunction(saveScaledImage, bool, (const char* bitmapSource, const char* bitmapDest, S32 resolutionSize), ("", "", 256),
    "Loads an image from the source path, and scales it down to the target resolution before"
    "Saving it out to the destination path.\n")
 {
@@ -1419,7 +1419,7 @@ DefineEngineFunction(saveScaledImage, bool, (const char* bitmapSource, const cha
       image->extrudeMipLevels();
 
    U32 mipCount = image->getNumMipLevels();
-   U32 targetMips = mFloor(mLog2((F32)resolutionSize)) + 1;
+   U32 targetMips = mFloor(mLog2((F32)(resolutionSize ? resolutionSize : 256))) + 1;
 
    if (mipCount > targetMips)
    {
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/image.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/image.tscript
index df8b2467c..167b3f197 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/image.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/image.tscript
@@ -202,7 +202,7 @@ function AssetBrowser::buildImageAssetPreview(%this, %assetDef, %previewData, %f
    {
       displayEditorLoadingGui("Generating Image Asset Preview...");
       
-      %success = saveScaledImage(%assetDef.getImagePath(), %previewFilePath);
+      %success = saveScaledImage(%assetDef.getImagePath(), %previewFilePath, EditorSettings.value("Assets/Browser/PreviewImageSize"));
       
       if(%success)
       {

From 496f28224967d2c9548fdeb98964b6b833674d67 Mon Sep 17 00:00:00 2001
From: Areloch <areloch@gmail.com>
Date: Sat, 16 Apr 2022 16:00:34 -0500
Subject: [PATCH 364/399] Create CODE_OF_CONDUCT.md

Didn't have one of these for consistent comprehension of expectations of community behavior
---
 CODE_OF_CONDUCT.md | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 CODE_OF_CONDUCT.md

diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
new file mode 100644
index 000000000..ae27c522a
--- /dev/null
+++ b/CODE_OF_CONDUCT.md
@@ -0,0 +1,13 @@
+# Torque Game Engines Community Code of Conduct
+
+- We, as a community, are committed to providing a friendly, safe and welcoming environment for all, regardless of experience, background, history or characteristic.
+- Please avoid using any overly sexual, offensive, or insulting alias or nicknames for yourself or others that would otherwise detract from a friendly, safe and welcoming environment.
+- Please be kind and courteous. There's no need to be rude.
+- Respect that people have differences of opinion, and that every design, implementation, or choice carries considerations, trade-offs, and costs. There is rarely ever a perfect answer.
+- Please keep critiques constructive. If you are going to critique someone's work, ideas, or decisions, do it with topical and specific feedback so that they can improve. Unconstructive critiques don't help anyone better their work.
+- Insulting, demeaning or harassing anyone is not welcome behavior, whether in public or private conversations. If you feel you have been subjected to any of this behavior, please contact any moderator or admin immediately. Whether you're a regular or a newcomer, we care about making this community a safe place for you. If you have any lack of clarity about what might fall under those concepts, feel free to ask for clarification from the moderation team.
+- Likewise, any spamming, trolling, flaming, baiting or other attention-stealing/seeking behavior is not welcome.
+- Do not insult or deride other users. 'You're an idiot' is not a useful comment. Do not do this.
+- If feedback is being provided, it needs to be constructive. Just simply calling something a bad idea is not helpful in correcting the core issues of that idea. Take the time to explain what is wrong with the idea and how it could be improved upon.
+- In discussions, under normal circumstances if the OP of a thread requests a post to be removed because they feel it is inflammatory, or off topic or the like, the mods will review it and in most cases, remove it per OP's request. It's their thread, so they get nearly final say in how the thread's topic should flow. MODGRU of course gets the actual final say, but will listen to the thread OPs reasoning, and if it makes sense, will generally abide the request.
+- If any user has a problem with something on any community site, such as content posted, or another user's behavior, they need to contact someone in MODGRU. Moderation cannot be expected to happen in a concise, timely manner if they are not informed about it. Rather than engaging in the negative behavior, users are heavily encouraged to report it and move on. Engaging in bad behavior in response only sets both parties up to be in trouble with moderation.

From b795776b2351d5b714d55f20da542080fb2c7470 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Sun, 17 Apr 2022 13:03:44 -0500
Subject: [PATCH 365/399] requested feature: large number display origional
 author: Peter Simard

---
 Engine/source/math/mathTypes.cpp | 34 ++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/Engine/source/math/mathTypes.cpp b/Engine/source/math/mathTypes.cpp
index 70ac9adf7..21a8d0bf5 100644
--- a/Engine/source/math/mathTypes.cpp
+++ b/Engine/source/math/mathTypes.cpp
@@ -1247,4 +1247,38 @@ DefineEngineFunction(getRandom, F32, (S32 a, S32 b), (S32_MAX, S32_MAX),
    return gRandGen.randF();
 }
 
+DefineEngineFunction(mAddS32, const char *, (S32 v1, S32 v2), , "Add 2 large numbers")
+{
+   S32 res = v1 + v2;
+   char *ret = Con::getReturnBuffer(64);
+   dSprintf(ret, 64, "%i", res);
+
+   return ret;
+}
+DefineEngineFunction(mSubS32, const char *, (S32 v1, S32 v2), , "Subtract 2 large numbers")
+{
+   S32 res = v1 - v2;
+   char *ret = Con::getReturnBuffer(64);
+   dSprintf(ret, 64, "%i", res);
+
+   return ret;
+}
+
+DefineEngineFunction(mMulS32, const char *, (S32 v1, S32 v2), , "Multiply 2 large numbers")
+{
+   S32 res = v1 * v2;
+   char *ret = Con::getReturnBuffer(64);
+   dSprintf(ret, 64, "%i", res);
+
+   return ret;
+}
+
+DefineEngineFunction(mDivS32, const char *, (S32 v1, S32 v2), , "Divide 2 large numbers")
+{
+   S32 res = v1 / v2;
+   char *ret = Con::getReturnBuffer(64);
+   dSprintf(ret, 64, "%i", res);
+
+   return ret;
+}
 //------------------------------------------------------------------------------

From 6d2c108cbd960d2f6baba99683d6978e4ae90aec Mon Sep 17 00:00:00 2001
From: Lukas Aldershaab <lpjoergensen@gmail.com>
Date: Wed, 20 Apr 2022 00:20:19 +0200
Subject: [PATCH 366/399] Fix TAML schema for array groups

---
 Engine/source/persistence/taml/taml.cpp | 296 ++++++++++++++++--------
 1 file changed, 194 insertions(+), 102 deletions(-)

diff --git a/Engine/source/persistence/taml/taml.cpp b/Engine/source/persistence/taml/taml.cpp
index a623ba8b1..cd02e1ab4 100644
--- a/Engine/source/persistence/taml/taml.cpp
+++ b/Engine/source/persistence/taml/taml.cpp
@@ -1055,6 +1055,115 @@ ImplementEnumType(_TamlFormatMode,
 
    //-----------------------------------------------------------------------------
 
+   tinyxml2::XMLElement* g__write_schema_attribute_element(const AbstractClassRep::Field& field, AbstractClassRep* pType,
+                                                          tinyxml2::XMLDocument& schemaDocument)
+   {
+      // Skip if not a data field.
+      if (field.type == AbstractClassRep::DeprecatedFieldType ||
+         field.type == AbstractClassRep::StartGroupFieldType ||
+         field.type == AbstractClassRep::EndGroupFieldType)
+         return NULL;
+
+      // Skip if the field root is not this type.
+      if (pType->findFieldRoot(field.pFieldname) != pType)
+         return NULL;
+
+      // Add attribute element.
+      tinyxml2::XMLElement* pAttributeElement = schemaDocument.NewElement("xs:attribute");
+      pAttributeElement->SetAttribute("name", field.pFieldname);
+
+      // Handle the console type appropriately.
+      const S32 fieldType = (S32)field.type;
+
+      /*
+      // Is the field an enumeration?
+      if ( fieldType == TypeEnum )
+      {
+      // Yes, so add attribute type.
+      tinyxml2::XMLElement* pAttributeSimpleTypeElement = schemaDocument.NewElement( "xs:simpleType" );
+      pAttributeElement->LinkEndChild( pAttributeSimpleTypeElement );
+
+      // Add restriction element.
+      tinyxml2::XMLElement* pAttributeRestrictionElement = schemaDocument.NewElement( "xs:restriction" );
+      pAttributeRestrictionElement->SetAttribute( "base", "xs:string" );
+      pAttributeSimpleTypeElement->LinkEndChild( pAttributeRestrictionElement );
+
+      // Yes, so fetch enumeration count.
+      const S32 enumCount = field.table->size;
+
+      // Iterate enumeration.
+      for( S32 index = 0; index < enumCount; ++index )
+      {
+      // Add enumeration element.
+      tinyxml2::XMLElement* pAttributeEnumerationElement = schemaDocument.NewElement( "xs:enumeration" );
+      pAttributeEnumerationElement->SetAttribute( "value", field.table->table[index].label );
+      pAttributeRestrictionElement->LinkEndChild( pAttributeEnumerationElement );
+      }
+      }
+      else
+      {*/
+      // No, so assume it's a string type initially.
+      const char* pFieldTypeDescription = "xs:string";
+
+      // Handle known types.
+      if (fieldType == TypeF32)
+      {
+         pFieldTypeDescription = "xs:float";
+      }
+      else if (fieldType == TypeS8 || fieldType == TypeS32)
+      {
+         pFieldTypeDescription = "xs:int";
+      }
+      else if (fieldType == TypeBool || fieldType == TypeFlag)
+      {
+         pFieldTypeDescription = "xs:boolean";
+      }
+      else if (fieldType == TypePoint2F)
+      {
+         pFieldTypeDescription = "Point2F_ConsoleType";
+      }
+      else if (fieldType == TypePoint2I)
+      {
+         pFieldTypeDescription = "Point2I_ConsoleType";
+      }
+      else if (fieldType == TypeRectI)
+      {
+         pFieldTypeDescription = "RectI_ConsoleType";
+      }
+      else if (fieldType == TypeRectF)
+      {
+         pFieldTypeDescription = "RectF_ConsoleType";
+      }
+      else if (fieldType == TypeColorF)
+      {
+         pFieldTypeDescription = "ColorF_ConsoleType";
+      }
+      else if (fieldType == TypeColorI)
+      {
+         pFieldTypeDescription = "ColorI_ConsoleType";
+      }
+      else if (fieldType == TypeAssetId/* ||
+                                       fieldType == TypeImageAssetPtr ||
+                                       fieldType == TypeAnimationAssetPtr ||
+                                       fieldType == TypeAudioAssetPtr*/)
+      {
+         pFieldTypeDescription = "AssetId_ConsoleType";
+      }
+
+      // Set attribute type.
+      pAttributeElement->SetAttribute("type", pFieldTypeDescription);
+      //}
+
+      pAttributeElement->SetAttribute("use", "optional");
+      return pAttributeElement;
+   }
+
+   String g_sanitize_schema_element_name(String buffer)
+   {
+      return buffer.replace("(", "")
+         .replace(")", "");
+   }
+
    bool Taml::generateTamlSchema()
    {
       // Fetch any TAML Schema file reference.
@@ -1298,8 +1407,8 @@ ImplementEnumType(_TamlFormatMode,
          pSchemaElement->LinkEndChild(pComplexTypeElement);
 
          // Add sequence.
-         tinyxml2::XMLElement* pSequenceElement = schemaDocument.NewElement("xs:sequence");
-         pComplexTypeElement->LinkEndChild(pSequenceElement);
+         tinyxml2::XMLElement* pAllElement = schemaDocument.NewElement("xs:all");
+         pComplexTypeElement->LinkEndChild(pAllElement);
 
          // Fetch container child class.
          AbstractClassRep* pContainerChildClass = pType->getContainerChildClass(true);
@@ -1311,7 +1420,7 @@ ImplementEnumType(_TamlFormatMode,
             tinyxml2::XMLElement* pChoiceElement = schemaDocument.NewElement("xs:choice");
             pChoiceElement->SetAttribute("minOccurs", 0);
             pChoiceElement->SetAttribute("maxOccurs", "unbounded");
-            pSequenceElement->LinkEndChild(pChoiceElement);
+            pAllElement->LinkEndChild(pChoiceElement);
 
             // Find child group.
             HashTable<AbstractClassRep*, StringTableEntry>::Iterator childGroupItr = childGroups.find(pContainerChildClass);
@@ -1369,7 +1478,74 @@ ImplementEnumType(_TamlFormatMode,
                continue;
 
             // Call schema generation function.
-            customSchemaFn(pType, pSequenceElement);
+            customSchemaFn(pType, pAllElement);
+         }
+
+         // Fetch field list.
+         const AbstractClassRep::FieldList& fields = pType->mFieldList;
+
+         // Fetch field count.
+         const S32 fieldCount = fields.size();
+
+         // Generate array attribute groups
+         for (S32 index = 0; index < fieldCount; ++index)
+         {
+            // Fetch field.
+            const AbstractClassRep::Field& field = fields[index];
+
+            if (field.type == AbstractClassRep::StartArrayFieldType)
+            {
+               // Add the top-level array identifier
+               tinyxml2::XMLElement* pArrayElement = schemaDocument.NewElement("xs:element");
+               dSprintf(buffer, sizeof(buffer), "%s.%s", pType->getClassName(), g_sanitize_schema_element_name(field.pGroupname).c_str());
+               pArrayElement->SetAttribute("name", buffer);
+               pArrayElement->SetAttribute("minOccurs", 0);
+               pAllElement->LinkEndChild(pArrayElement);
+
+               // Inline type specification
+               tinyxml2::XMLElement* pArrayComplexTypeElement = schemaDocument.NewElement("xs:complexType");
+               pArrayElement->LinkEndChild(pArrayComplexTypeElement);
+
+               // Add the actual (repeating) array elements
+               tinyxml2::XMLElement* pInnerArrayElement = schemaDocument.NewElement("xs:element");
+               pInnerArrayElement->SetAttribute("name", g_sanitize_schema_element_name(field.pFieldname).c_str());
+               pInnerArrayElement->SetAttribute("minOccurs", 0);
+               pInnerArrayElement->SetAttribute("maxOccurs", field.elementCount);
+               pArrayComplexTypeElement->LinkEndChild(pInnerArrayElement);
+
+               // Inline type specification
+               tinyxml2::XMLElement* pInnerComplexTypeElement = schemaDocument.NewElement("xs:complexType");
+               pInnerArrayElement->LinkEndChild(pInnerComplexTypeElement);
+
+               // Add a reference to the attribute group for the array
+               tinyxml2::XMLElement* pInnerAttributeGroupElement = schemaDocument.NewElement("xs:attributeGroup");
+               dSprintf(buffer, sizeof(buffer), "%s_%s_Array_Fields", pType->getClassName(), g_sanitize_schema_element_name(field.pFieldname).c_str());
+               pInnerAttributeGroupElement->SetAttribute("ref", buffer);
+               pInnerComplexTypeElement->LinkEndChild(pInnerAttributeGroupElement);
+
+               // Add the attribute group itself
+               tinyxml2::XMLElement* pFieldAttributeGroupElement = schemaDocument.NewElement("xs:attributeGroup");
+               pFieldAttributeGroupElement->SetAttribute("name", buffer);
+               pSchemaElement->LinkEndChild(pFieldAttributeGroupElement);
+
+               // Keep adding fields to attribute group until we hit the end of the array
+               for (; index < fieldCount; ++index)
+               {
+                  const AbstractClassRep::Field& array_field = fields[index];
+                  if (array_field.type == AbstractClassRep::EndArrayFieldType)
+                  {
+                     break;
+                  }
+                  
+                  tinyxml2::XMLElement* pAttributeElement = g__write_schema_attribute_element(array_field, pType, schemaDocument);
+                  if (pAttributeElement == NULL)
+                  {
+                     continue;
+                  }
+
+                  pFieldAttributeGroupElement->LinkEndChild(pAttributeElement);
+               }
+            }
          }
 
          // Generate field attribute group.
@@ -1378,115 +1554,31 @@ ImplementEnumType(_TamlFormatMode,
          pFieldAttributeGroupElement->SetAttribute("name", buffer);
          pSchemaElement->LinkEndChild(pFieldAttributeGroupElement);
 
-         // Fetch field list.
-         const AbstractClassRep::FieldList& fields = pType->mFieldList;
-
-         // Fetcj field count.
-         const S32 fieldCount = fields.size();
-
          // Iterate static fields (in reverse as most types are organized from the root-fields up).
          for (S32 index = fieldCount - 1; index > 0; --index)
          {
             // Fetch field.
             const AbstractClassRep::Field& field = fields[index];
 
-            // Skip if not a data field.
-            if (field.type == AbstractClassRep::DeprecatedFieldType ||
-               field.type == AbstractClassRep::StartGroupFieldType ||
-               field.type == AbstractClassRep::EndGroupFieldType)
+            // Skip fields inside arrays
+            if (field.type == AbstractClassRep::EndArrayFieldType)
+            {
+               for (; index > 0; --index)
+               {
+                  if (field.type == AbstractClassRep::StartArrayFieldType)
+                  {
+                     break;
+                  }
+               }
                continue;
+            }
 
-            // Skip if the field root is not this type.
-            if (pType->findFieldRoot(field.pFieldname) != pType)
+            tinyxml2::XMLElement* pAttributeElement = g__write_schema_attribute_element(field, pType, schemaDocument);
+            if (pAttributeElement == NULL)
+            {
                continue;
-
-            // Add attribute element.
-            tinyxml2::XMLElement* pAttributeElement = schemaDocument.NewElement("xs:attribute");
-            pAttributeElement->SetAttribute("name", field.pFieldname);
-
-            // Handle the console type appropriately.
-            const S32 fieldType = (S32)field.type;
-
-            /*
-            // Is the field an enumeration?
-            if ( fieldType == TypeEnum )
-            {
-            // Yes, so add attribute type.
-            tinyxml2::XMLElement* pAttributeSimpleTypeElement = schemaDocument.NewElement( "xs:simpleType" );
-            pAttributeElement->LinkEndChild( pAttributeSimpleTypeElement );
-
-            // Add restriction element.
-            tinyxml2::XMLElement* pAttributeRestrictionElement = schemaDocument.NewElement( "xs:restriction" );
-            pAttributeRestrictionElement->SetAttribute( "base", "xs:string" );
-            pAttributeSimpleTypeElement->LinkEndChild( pAttributeRestrictionElement );
-
-            // Yes, so fetch enumeration count.
-            const S32 enumCount = field.table->size;
-
-            // Iterate enumeration.
-            for( S32 index = 0; index < enumCount; ++index )
-            {
-            // Add enumeration element.
-            tinyxml2::XMLElement* pAttributeEnumerationElement = schemaDocument.NewElement( "xs:enumeration" );
-            pAttributeEnumerationElement->SetAttribute( "value", field.table->table[index].label );
-            pAttributeRestrictionElement->LinkEndChild( pAttributeEnumerationElement );
-            }
-            }
-            else
-            {*/
-            // No, so assume it's a string type initially.
-            const char* pFieldTypeDescription = "xs:string";
-
-            // Handle known types.
-            if (fieldType == TypeF32)
-            {
-               pFieldTypeDescription = "xs:float";
-            }
-            else if (fieldType == TypeS8 || fieldType == TypeS32)
-            {
-               pFieldTypeDescription = "xs:int";
-            }
-            else if (fieldType == TypeBool || fieldType == TypeFlag)
-            {
-               pFieldTypeDescription = "xs:boolean";
-            }
-            else if (fieldType == TypePoint2F)
-            {
-               pFieldTypeDescription = "Point2F_ConsoleType";
-            }
-            else if (fieldType == TypePoint2I)
-            {
-               pFieldTypeDescription = "Point2I_ConsoleType";
-            }
-            else if (fieldType == TypeRectI)
-            {
-               pFieldTypeDescription = "RectI_ConsoleType";
-            }
-            else if (fieldType == TypeRectF)
-            {
-               pFieldTypeDescription = "RectF_ConsoleType";
-            }
-            else if (fieldType == TypeColorF)
-            {
-               pFieldTypeDescription = "ColorF_ConsoleType";
-            }
-            else if (fieldType == TypeColorI)
-            {
-               pFieldTypeDescription = "ColorI_ConsoleType";
-            }
-            else if (fieldType == TypeAssetId/* ||
-                                             fieldType == TypeImageAssetPtr ||
-                                             fieldType == TypeAnimationAssetPtr ||
-                                             fieldType == TypeAudioAssetPtr*/)
-            {
-               pFieldTypeDescription = "AssetId_ConsoleType";
             }
 
-            // Set attribute type.
-            pAttributeElement->SetAttribute("type", pFieldTypeDescription);
-            //}
-
-            pAttributeElement->SetAttribute("use", "optional");
             pFieldAttributeGroupElement->LinkEndChild(pAttributeElement);
          }
 

From c14c9b78c01a526d8a540ecdcecb9f5c267c0732 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Wed, 20 Apr 2022 15:53:29 -0500
Subject: [PATCH 367/399] drop the prior requirement for a createcomposite to
 have a minimum of roughness and metalness. also kick it off if it's got just
 an ao map.

---
 Engine/source/gfx/gfxTextureManager.cpp       | 2 +-
 Engine/source/materials/processedMaterial.cpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Engine/source/gfx/gfxTextureManager.cpp b/Engine/source/gfx/gfxTextureManager.cpp
index 733f3ba7f..53ebf801c 100644
--- a/Engine/source/gfx/gfxTextureManager.cpp
+++ b/Engine/source/gfx/gfxTextureManager.cpp
@@ -1238,7 +1238,7 @@ GFXTextureObject *GFXTextureManager::createCompositeTexture(GBitmap*bmp[4], U32
          if (bmp[2])
             bChan = bmp[2]->getChanelValueAt(x, y, inputKey[2]);
          else
-            bChan = 255;
+            bChan = 0;
 
          if (bmp[3])
             aChan = bmp[3]->getChanelValueAt(x, y, inputKey[3]);
diff --git a/Engine/source/materials/processedMaterial.cpp b/Engine/source/materials/processedMaterial.cpp
index 63150fd94..8fa7d7e28 100644
--- a/Engine/source/materials/processedMaterial.cpp
+++ b/Engine/source/materials/processedMaterial.cpp
@@ -491,7 +491,7 @@ void ProcessedMaterial::_setStageData()
       }
       else
       {
-         if ((mMaterial->getRoughMap(i) != StringTable->EmptyString()) && (mMaterial->getMetalMap(i) != StringTable->EmptyString()))
+         if ((mMaterial->getAOMap(i) != StringTable->EmptyString()) || (mMaterial->getRoughMap(i) != StringTable->EmptyString()) || (mMaterial->getMetalMap(i) != StringTable->EmptyString()))
          {
             U32 inputKey[4];
             inputKey[0] = mMaterial->mAOChan[i];

From 70a70dfc102e2763420735e075381c504277bcec Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Sat, 23 Apr 2022 16:07:36 -0500
Subject: [PATCH 368/399] Fixes issue with some of the On/Off options not
 properly toggling in the OptionsMenu Adds staged loading/generation of
 preview images for image, shape, material and terrain material types to
 improve navigation responsiveness Disabled lookup of bitmap info of image
 assets for tooltip metadata as it was causing major hangs when the images
 were high resolution Added function so Import new File button on AB interface
 will correctly prompt to find and then import in a new file Fixed theming of
 AssetBrowser preview card profiles to improve readability Fixed theming of
 ToolsGuiTextListProfile to improve readability Fixed issue where trying to
 import in a splat map for importing terrain data could fail due to not having
 full path when trying to load the bitmap's channel data Corrected Import
 Terrain Heightmap item in menubar to prompt creation of a new terrain asset
 in addition to opening the import terraindata window to avoid missed steps
 foc creation

---
 .../game/data/UI/guis/optionsMenu.tscript     |  8 +-
 .../tools/assetBrowser/guis/assetBrowser.gui  |  1 +
 .../assetBrowser/scripts/assetBrowser.tscript | 34 ++++++-
 .../scripts/assetTypes/image.tscript          | 91 +++++++++--------
 .../scripts/assetTypes/material.tscript       | 97 +++++++++++--------
 .../scripts/assetTypes/shape.tscript          | 83 ++++++++++------
 .../assetTypes/terrainMaterial.tscript        | 71 ++++++++------
 .../assetBrowser/scripts/newAsset.tscript     | 27 ++++++
 .../assetBrowser/scripts/profiles.tscript     | 31 +++---
 .../game/tools/gui/profiles.ed.tscript        |  6 ++
 .../worldEditor/gui/guiTerrainImportGui.gui   |  2 +-
 .../worldEditor/scripts/menus.ed.tscript      |  2 +-
 12 files changed, 288 insertions(+), 165 deletions(-)

diff --git a/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript b/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
index aa343f81f..40540c1ab 100644
--- a/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
+++ b/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
@@ -836,11 +836,11 @@ function OptionsMenuSettingsList::addOptionBoolRow(%this, %label, %targetPrefVar
       
    if(%qualityLevelList $= $yesNoList && isInt(%defaultValue))
    {
-      %defaultValue = convertBoolToYesNo(!%defaultValue);
+      %defaultValue = convertBoolToYesNo(%defaultValue);
    }
    else if(%qualityLevelList $= $onOffList && isInt(%defaultValue))
    {
-      %defaultValue = convertBoolToOnOff(!%defaultValue);
+      %defaultValue = convertBoolToOnOff(%defaultValue);
    }
 
    return %this.addOptionRow(%label, %targetPrefVar, %qualityLevelList, 
@@ -995,9 +995,11 @@ function MenuOptionsButton::onChange(%this)
          OptionsMenu.unappliedChanges.add(%targetVar, "\"" @ %saveReadyValue @ "\"" );
       }
       else
+         {
          OptionsMenu.unappliedChanges.setValue("\"" @ %saveReadyValue @ "\"", %prefIndex);
       }
    }
+   }
    else if(%optionMode == 1)
    {
       %currentValue = %this.getValue();
@@ -1009,7 +1011,9 @@ function MenuOptionsButton::onChange(%this)
          OptionsMenu.unappliedChanges.add(%targetVar, "\"" @ %currentValue @ "\"" );
       }
       else
+      {
          OptionsMenu.unappliedChanges.setValue("\"" @ %currentValue @ "\"", %prefIndex);
+      }
    }
    
    //Update the UI in case there's responsive logic
diff --git a/Templates/BaseGame/game/tools/assetBrowser/guis/assetBrowser.gui b/Templates/BaseGame/game/tools/assetBrowser/guis/assetBrowser.gui
index 29c282c5b..c4df19d95 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/guis/assetBrowser.gui
+++ b/Templates/BaseGame/game/tools/assetBrowser/guis/assetBrowser.gui
@@ -276,6 +276,7 @@ $guiContent = new GuiControl(AssetBrowser) {
             hovertime = "1000";
             isContainer = "0";
             internalName = "ImportAssetButton";
+            command="AssetBrowser.importNewFile();";
             canSave = "1";
             canSaveDynamicFields = "0";
          };
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
index fd3a7b213..3dd7b881d 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
@@ -368,8 +368,6 @@ function AssetBrowser::buildAssetPreview( %this, %asset, %moduleName )
       %this.previewData.doubleClickCommand = "";
    }
    
-   AssetPreviewArray.empty();
-   
    %previewImage = "core/art/warnmat";
    
    if(/*%moduleName !$= "" && */ModuleDatabase.findModule(%moduleName, 1) !$= "")
@@ -512,6 +510,7 @@ function AssetBrowser::buildAssetPreview( %this, %asset, %moduleName )
       textLocation = "Bottom";
       extent = %previewSize.x SPC %previewSize.y + %textBottomPad;
       buttonType = "RadioButton";
+      buttonMargin = "0 -10";
       profile = ToolsGuiDefaultProfile;
    };
    
@@ -528,11 +527,15 @@ function AssetBrowser::buildAssetPreview( %this, %asset, %moduleName )
       %previewButton.iconLocation = "Left";
       %previewButton.textLocation = "Right";
       %previewButton.setextent(120,20);
+      
+      AssetBrowser.previewListMode = true;
    }
    else
    {
       %size = %previewSize.x * %previewScaleSize;
       %previewButton.setextent(%size,%size + %textBottomPad);
+      
+      AssetBrowser.previewListMode = false;
    }
    
    //%previewButton.extent = %previewSize.x + %previewBounds SPC %previewSize.y + %previewBounds + 24;
@@ -549,6 +552,8 @@ function AssetBrowser::buildAssetPreview( %this, %asset, %moduleName )
       %doubleClickCommand = "AssetBrowser.editAsset( "@%assetDesc@" );";
    }
    
+   %this.previewData.previewLoaded = true;
+   
    //Build out the preview
    %buildCommand = %this @ ".build" @ %assetType @ "Preview(\"" @ %assetDesc @ "\"," @ %this.previewData @ ");";
    eval(%buildCommand);
@@ -579,7 +584,8 @@ function AssetBrowser::buildAssetPreview( %this, %asset, %moduleName )
    AssetBrowser-->assetList.add(%previewButton);
    
    // add to the array object for reference later
-   AssetPreviewArray.add( %previewButton, %this.previewData.previewImage );
+   if(%this.previewData.previewLoaded == false)
+      AssetPreviewArray.add( %previewButton );
 }
 
 function AssetBrowser::refresh(%this)
@@ -607,6 +613,25 @@ function AssetBrowser::doRefresh(%this)
       %this.dirty = false;
    }
 }
+
+function AssetBrowser::populatePreviewImages(%this)
+{
+   echo("AssetBrowser::populatePreviewImages() - Previews to generate: " @ AssetPreviewArray.count());
+   for(%i=0; %i < AssetPreviewArray.count(); %i++)
+   {
+      %previewButton = AssetPreviewArray.getKey(%i);
+      %type = %previewButton.assetType;
+      
+      echo("   - Generating preview for asset: " @ %previewButton.moduleName @ ":" @ %previewButton.assetName);
+      
+      AssetBrowser.call("generate" @ %previewButton.assetType @ "PreviewImage", %previewButton);
+      AssetPreviewArray.erase(%i);
+      
+      echo("   - done, scheduling another pass");
+      AssetBrowser.schedule(32, "populatePreviewImages");
+      return;
+   }
+}
 //
 //
 /*function AssetPreviewButton::onClick(%this)
@@ -716,7 +741,6 @@ function AssetBrowser::loadDirectories( %this )
       //}
   // }
    
-   AssetPreviewArray.empty();
    
    AssetBrowser-->filterTree.buildVisibleTree(true);
    
@@ -1776,6 +1800,8 @@ function AssetBrowser::doRebuildAssetArray(%this)
 	
    for(%i=0; %i < $AssetBrowser::AssetArray.count(); %i++)
 		AssetBrowser.buildAssetPreview( $AssetBrowser::AssetArray.getValue(%i), $AssetBrowser::AssetArray.getKey(%i) );  
+   //Queue population of any non-Type Card preview images
+   AssetBrowser.schedule(32, "populatePreviewImages");
 		
    AssetBrowser_FooterText.text = %finalAssetCount @ " Assets";
    
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/image.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/image.tscript
index 167b3f197..f118fc078 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/image.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/image.tscript
@@ -175,20 +175,48 @@ function AssetBrowser::importImageAsset(%this, %assetItem)
       AssetDatabase.refreshAsset(%assetId);
 }
 
-function AssetBrowser::buildImageAssetPreview(%this, %assetDef, %previewData, %forcePreviewRegenerate)
+function AssetBrowser::buildImageAssetPreview(%this, %assetDef, %previewData)
 {
-   if(%forcePreviewRegenerate $= "")
-      %forcePreviewRegenerate = false;
+   //%module = %this.dirHandler.getModuleFromAddress(makeRelativePath(filePath(%assetDef.getImagePath())));
       
-   %module = %this.dirHandler.getModuleFromAddress(makeRelativePath(filePath(%assetDef.getImagePath())));
-   %previewPath = "tools/resources/previewCache/" @ %module.moduleId @ "/";
+   %previewData.previewImage = "ToolsModule:genericAssetIcon_image";
+   %previewData.previewLoaded = false; //this marks it for loading progressively later
+   
+   %previewData.assetName = %assetDef.assetName;
+   %previewData.assetPath = %assetDef.scriptFile;
+   
+   %previewData.assetFriendlyName = %assetDef.assetName;
+   %previewData.assetDesc = %assetDef.description;
+   
+   //image info
+   //%info = %assetDef.getImageInfo();
+   
+   %previewData.tooltip = "Asset Name: " @ %assetDef.assetName @ "\n" @
+      "Asset Type: Image Asset\n" @ 
+      "Asset Definition ID: " @ %assetDef @ "\n" @ 
+      "Image Type: " @ %assetDef.imageType @ "\n" @ 
+     /* "Format: " @ getWord(%info, 0) @ "\n" @ 
+      "Height: " @ getWord(%info, 1) @ "\n" @ 
+      "Width: " @ getWord(%info, 2) @ "\n" @ 
+      "Depth: " @ getWord(%info, 3) @ "\n" @ */
+      "Image File path: " @ %assetDef.getImagePath();
+}
+
+function AssetBrowser::generateImageAssetPreviewImage(%this, %previewButton, %forceRegenerate)
+{
+   if(%forceRegenerate $= "")
+      %forceRegenerate = false;
+      
+   %previewPath = "tools/resources/previewCache/" @ %previewButton.moduleName @ "/";
    
    if(!IsDirectory(%previewPath))
    {
       %this.dirHandler.createFolder(%previewPath);
    }
    
-   %generatePreview = false;
+   %assetId = %previewButton.moduleName @ ":" @ %previewButton.assetName;
+      
+   %assetDef = AssetDatabase.acquireAsset(%assetId);
    
    %previewFilePath = %previewPath @ %assetDef.assetName @ "_Preview.png";
    if(!isFile(%previewFilePath) || (compareFileTimes(%assetDef.getImagePath(), %previewFilePath) == 1))
@@ -196,12 +224,10 @@ function AssetBrowser::buildImageAssetPreview(%this, %assetDef, %previewData, %f
       %generatePreview = true;
    }
    
-   %previewAssetName = %module.moduleId @ "_" @ %assetDef.assetName @ "_PreviewImage";
+   %previewAssetName = %previewButton.moduleName @ "_" @ %assetDef.assetName @ "_PreviewImage";
    
-   if(%generatePreview || %forcePreviewRegenerate)
+   if(%generatePreview || %forceRegenerate)
    {
-      displayEditorLoadingGui("Generating Image Asset Preview...");
-      
       %success = saveScaledImage(%assetDef.getImagePath(), %previewFilePath, EditorSettings.value("Assets/Browser/PreviewImageSize"));
       
       if(%success)
@@ -222,49 +248,28 @@ function AssetBrowser::buildImageAssetPreview(%this, %assetDef, %previewData, %f
             %toolsModuleDef = ModuleDatabase.findModule("ToolsModule",1);
             
             %success = AssetDatabase.addDeclaredAsset(%toolsModuleDef, %previewImgAssetPath);
+            
+            if(!%success)
+            {
+               return false; //failed to register the preview image for some reason?
          }
       }
-      else
-      {
-         %previewFilePath = %assetDef.getImagePath();
-         %previewAssetName = %module.moduleId @ ":" @ %assetDef.assetName;  
+         
+         %previewButton.bitmapAsset = %previewAssetName;
+         return true;
       }
-      
-      hideEditorLoadingGui();
    }
    else
    {
-      %previewAssetName = "ToolsModule:" @ %previewAssetName;
-   }
-   
-   //Revalidate. If it didn't work, just use the default placeholder one
-   if(!isFile(%previewFilePath))
+      //just map the existing one then
+      if(AssetDatabase.isDeclaredAsset("ToolsModule:" @ %previewAssetName))
    {
-      %previewData.previewImage = "ToolsModule:genericAssetIcon_image";
+         %previewButton.bitmapAsset = "ToolsModule:" @ %previewAssetName;
+         return true;
    }
-   else
-   {
-      %previewData.previewImage = %previewAssetName;
    }
    
-   %previewData.assetName = %assetDef.assetName;
-   %previewData.assetPath = %assetDef.scriptFile;
-   
-   %previewData.assetFriendlyName = %assetDef.assetName;
-   %previewData.assetDesc = %assetDef.description;
-   
-   //image info
-   %info = %assetDef.getImageInfo();
-   
-   %previewData.tooltip = "Asset Name: " @ %assetDef.assetName @ "\n" @
-      "Asset Type: Image Asset\n" @ 
-      "Asset Definition ID: " @ %assetDef @ "\n" @ 
-      "Image Type: " @ %assetDef.imageType @ "\n" @ 
-      "Format: " @ getWord(%info, 0) @ "\n" @ 
-      "Height: " @ getWord(%info, 1) @ "\n" @ 
-      "Width: " @ getWord(%info, 2) @ "\n" @ 
-      "Depth: " @ getWord(%info, 3) @ "\n" @ 
-      "Image File path: " @ %assetDef.getImagePath(); 
+   return false;
 }
 
 //Renames the asset
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
index d6d48819c..12c6d4e3d 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
@@ -426,8 +426,43 @@ function AssetBrowser::importMaterialAsset(%this, %assetItem)
 
 function AssetBrowser::buildMaterialAssetPreview(%this, %assetDef, %previewData, %forcePreviewRegenerate)
 {   
-   if(%forcePreviewRegenerate $= "")
-      %forcePreviewRegenerate = false;
+   %previewData.previewImage = "ToolsModule:genericAssetIcon_image";
+   %previewData.previewLoaded = false; //this marks it for loading progressively later
+      
+   %previewData.assetName = %assetDef.assetName;
+   %previewData.assetPath = %assetDef.scriptFile;
+   
+   %previewData.assetFriendlyName = %assetDef.assetName;
+   %previewData.assetDesc = %assetDef.description;
+
+   if(%this.selectMode)
+      %previewData.doubleClickCommand = "AssetBrowser.selectAsset( AssetBrowser.selectedAsset );";
+   else
+      %previewData.doubleClickCommand = "AssetBrowser.editAsset( "@%assetDef@" );";
+      
+   %definitionPath = %assetDef.getScriptPath();
+   if(%definitionPath $= "")
+      %definitionPath = %assetDef.getFilename();
+   
+   %previewData.tooltip = "Asset Name: " @ %assetDef.assetName @ 
+                           "\nAsset Type: Material Asset" @  
+                           "\nAsset Definition ID: " @  %assetDef @
+                           "\nDefinition Path: " @ %definitionPath;
+                           
+   if(!%this.selectMode)
+   {
+      %previewData.doubleClickCommand = "AssetBrowser.editAsset( "@%assetDef@" );";
+   }
+}
+
+function AssetBrowser::generateMaterialAssetPreviewImage(%this, %previewButton, %forceRegenerate)
+{
+   if(%forceRegenerate $= "")
+      %forceRegenerate = false;
+      
+   %assetId = %previewButton.moduleName @ ":" @ %previewButton.assetName;
+      
+   %assetDef = AssetDatabase.acquireAsset(%assetId);
       
    %module = %this.dirHandler.getModuleFromAddress(makeRelativePath(filePath(AssetDatabase.getAssetFilePath(%assetDef.getAssetId()))));
    %previewPath = "tools/resources/previewCache/" @ %module.moduleId @ "/";
@@ -456,10 +491,8 @@ function AssetBrowser::buildMaterialAssetPreview(%this, %assetDef, %previewData,
 
    %previewAssetName = %module.moduleId @ "_" @ %assetDef.assetName @ "_PreviewImage";
                                    
-   if(%generatePreview || %forcePreviewRegenerate)
+   if(%generatePreview || %forceRegenerate)
    {
-      displayEditorLoadingGui("Generating Material Asset Preview...");
-   
       if(isObject(%assetDef.materialDefinitionName))
       {
          //real fast, we'll be 100% sure that the image resource we need is loaded
@@ -490,50 +523,28 @@ function AssetBrowser::buildMaterialAssetPreview(%this, %assetDef, %previewData,
             %toolsModuleDef = ModuleDatabase.findModule("ToolsModule",1);
                
             %success = AssetDatabase.addDeclaredAsset(%toolsModuleDef, %previewImgAssetPath);
+            
+            if(!%success)
+            {
+               return false; //failed to register the preview image for some reason?
          }
       }
-      else
+      
+         %previewButton.bitmapAsset = %previewAssetName;
+         return true;
+   }
+   }
+   else
+   {
+      //just map the existing one then
+      if(AssetDatabase.isDeclaredAsset("ToolsModule:" @ %previewAssetName))
       {
-         error("Failed to generate preview for material: " @ %assetDef.materialDefinitionName);
+         %previewButton.bitmapAsset = "ToolsModule:" @ %previewAssetName;
+         return true;
       }
-      
-      hideEditorLoadingGui();
-   }
-   
-   //Revalidate. If it didn't work, just use the default placeholder one
-   if(!isFile(%previewFilePath))
-   {
-      %previewData.previewImage = "ToolsModule:materialIcon_image";
-   }
-   else
-   {
-      %previewData.previewImage = "ToolsModule:" @ %previewAssetName;
    }
       
-   %previewData.assetName = %assetDef.assetName;
-   %previewData.assetPath = %assetDef.scriptFile;
-   
-   %previewData.assetFriendlyName = %assetDef.assetName;
-   %previewData.assetDesc = %assetDef.description;
-
-   if(%this.selectMode)
-      %previewData.doubleClickCommand = "AssetBrowser.selectAsset( AssetBrowser.selectedAsset );";
-   else
-      %previewData.doubleClickCommand = "AssetBrowser.editAsset( "@%assetDef@" );";
-      
-   %definitionPath = %assetDef.getScriptPath();
-   if(%definitionPath $= "")
-      %definitionPath = %assetDef.getFilename();
-   
-   %previewData.tooltip = "Asset Name: " @ %assetDef.assetName @ 
-                           "\nAsset Type: Material Asset" @  
-                           "\nAsset Definition ID: " @  %assetDef @
-                           "\nDefinition Path: " @ %definitionPath;
-                           
-   if(!%this.selectMode)
-   {
-      %previewData.doubleClickCommand = "AssetBrowser.editAsset( "@%assetDef@" );";
-   }
+   return false;
 }
 
 function AssetBrowser::onMaterialAssetEditorDropped(%this, %assetDef, %position)
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
index c70750e90..4195cf1b9 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
@@ -265,8 +265,44 @@ function AssetBrowser::importShapeAsset(%this, %assetItem)
 
 function AssetBrowser::buildShapeAssetPreview(%this, %assetDef, %previewData, %forcePreviewRegenerate)
 {
-   if(%forcePreviewRegenerate $= "")
-      %forcePreviewRegenerate = false;
+   %previewData.previewImage = "ToolsModule:genericAssetIcon_image";
+   %previewData.previewLoaded = false; //this marks it for loading progressively later
+   
+   %previewData.assetName = %assetDef.assetName;
+   %previewData.assetPath = %assetDef.fileName;
+   
+   %previewData.assetFriendlyName = %assetDef.assetName;
+   %previewData.assetDesc = %assetDef.description;
+   %previewData.tooltip = "Asset Name: " @ %assetDef.assetName @ "\n" @ 
+                           "Asset Type: Shape Asset\n" @ 
+                           "Asset Definition ID: " @  %assetDef @ "\n" @ 
+                           "Shape File path: " @ %assetDef.getShapePath();
+                           
+   if(%this.selectMode)
+   {
+      %previewData.doubleClickCommand = "AssetBrowser.selectAsset( AssetBrowser.selectedAsset );";
+   }
+   else
+   {
+      if(EditorSettings.value("Assets/Browser/doubleClickAction", "Edit Asset") $= "Edit Asset")
+      {
+         %previewData.doubleClickCommand = "AssetBrowser.editAsset( "@%assetDef@" );";
+      }
+      else
+      {
+         %previewData.doubleClickCommand = "AssetBrowser.onShapeAssetEditorDropped( "@%assetDef@" );";
+      }
+   }
+}
+
+function AssetBrowser::generateShapeAssetPreviewImage(%this, %previewButton, %forceRegenerate)
+{
+   if(%forceRegenerate $= "")
+      %forceRegenerate = false;
+      
+   %assetId = %previewButton.moduleName @ ":" @ %previewButton.assetName;
+      
+   %assetDef = AssetDatabase.acquireAsset(%assetId);
       
    %module = %this.dirHandler.getModuleFromAddress(makeRelativePath(filePath(%assetDef.getShapePath())));
    %previewPath = "tools/resources/previewCache/" @ %module.moduleId @ "/";
@@ -286,10 +322,8 @@ function AssetBrowser::buildShapeAssetPreview(%this, %assetDef, %previewData, %f
    
    %previewAssetName = %module.moduleId @ "_" @ %assetDef.assetName @ "_PreviewImage";
    
-   if(%generatePreview || %forcePreviewRegenerate)
+   if(%generatePreview || %forceRegenerate)
    {
-      displayEditorLoadingGui("Generating Shape Asset Preview...");
-      
       //real fast, we'll be 100% sure that the image resource we need is loaded
       
       %matSlot0AssetId = %assetDef.materialSlot0;
@@ -322,46 +356,31 @@ function AssetBrowser::buildShapeAssetPreview(%this, %assetDef, %previewData, %f
          %toolsModuleDef = ModuleDatabase.findModule("ToolsModule",1);
             
          %success = AssetDatabase.addDeclaredAsset(%toolsModuleDef, %previewImgAssetPath);
-      }
       
-      hideEditorLoadingGui();
+         if(!%success)
+         {
+            return false; //failed to register the preview image for some reason?
    }
-   
-   //Revalidate. If it didn't work, just use the default placeholder one
-   if(!isFile(%previewFilePath))
-   {
-      %previewData.previewImage = "ToolsModule:genericAssetIcon_image";
    }
    else
    {
-      %previewData.previewImage = "ToolsModule:" @ %previewAssetName;
+         %previewAssetName = "ToolsModule:" @ %previewAssetName;
    }
    
-   %previewData.assetName = %assetDef.assetName;
-   %previewData.assetPath = %assetDef.fileName;
-   
-   %previewData.assetFriendlyName = %assetDef.assetName;
-   %previewData.assetDesc = %assetDef.description;
-   %previewData.tooltip = "Asset Name: " @ %assetDef.assetName @ "\n" @ 
-                           "Asset Type: Shape Asset\n" @ 
-                           "Asset Definition ID: " @  %assetDef @ "\n" @ 
-                           "Shape File path: " @ %assetDef.getShapePath();
-                           
-   if(%this.selectMode)
-   {
-      %previewData.doubleClickCommand = "AssetBrowser.selectAsset( AssetBrowser.selectedAsset );";
+      %previewButton.bitmapAsset = %previewAssetName;
+      return true;
    }
    else
    {
-      if(EditorSettings.value("Assets/Browser/doubleClickAction", "Edit Asset") $= "Edit Asset")
+      //just map the existing one then
+      if(AssetDatabase.isDeclaredAsset("ToolsModule:" @ %previewAssetName))
       {
-         %previewData.doubleClickCommand = "AssetBrowser.editAsset( "@%assetDef@" );";
-      }
-      else
-      {
-         %previewData.doubleClickCommand = "AssetBrowser.onShapeAssetEditorDropped( "@%assetDef@" );";
+         %previewButton.bitmapAsset = "ToolsModule:" @ %previewAssetName;
+         return true;
       }
    }
+   
+   return false;
 }
 
 function AssetBrowser::onShapeAssetEditorDropped(%this, %assetDef, %position)
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrainMaterial.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrainMaterial.tscript
index 8176d0da0..ded898e9f 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrainMaterial.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrainMaterial.tscript
@@ -111,8 +111,35 @@ function AssetBrowser::moveTerrainMaterialAsset(%this, %assetDef, %destination)
 
 function AssetBrowser::buildTerrainMaterialAssetPreview(%this, %assetDef, %previewData, %forcePreviewRegenerate)
 {
-   if(%forcePreviewRegenerate $= "")
-      %forcePreviewRegenerate = false;
+   %previewData.previewImage = "ToolsModule:genericAssetIcon_image";
+   %previewData.previewLoaded = false; //this marks it for loading progressively later
+      
+   %previewData.assetName = %assetDef.assetName;
+   %previewData.assetPath = "";
+   %previewData.doubleClickCommand = "";
+   
+   %previewData.assetFriendlyName = %assetDef.gameObjectName;
+   %previewData.assetDesc = %assetDef.description;
+   %previewData.tooltip = %assetDef.gameObjectName;
+   
+   %definitionPath = %assetDef.getScriptPath();
+   if(%definitionPath $= "")
+      %definitionPath = %assetDef.getFilename();
+   
+   %previewData.tooltip = "Asset Name: " @ %assetDef.assetName @ 
+                           "\nAsset Type: Terrain Material Asset" @  
+                           "\nAsset Definition ID: " @  %assetDef @
+                           "\nDefinition Path: " @ %definitionPath;
+}
+
+function AssetBrowser::generateTerrainMaterialAssetPreviewImage(%this, %previewButton, %forceRegenerate)
+{
+   if(%forceRegenerate $= "")
+      %forceRegenerate = false;
+      
+   %assetId = %previewButton.moduleName @ ":" @ %previewButton.assetName;
+      
+   %assetDef = AssetDatabase.acquireAsset(%assetId);
       
    %module = %this.dirHandler.getModuleFromAddress(makeRelativePath(filePath(AssetDatabase.getAssetFilePath(%assetDef.getAssetId()))));
    %previewPath = "tools/resources/previewCache/" @ %module.moduleId @ "/";
@@ -141,10 +168,8 @@ function AssetBrowser::buildTerrainMaterialAssetPreview(%this, %assetDef, %previ
 
    %previewAssetName = %module.moduleId @ "_" @ %assetDef.assetName @ "_PreviewImage";
                                    
-   if(%generatePreview || %forcePreviewRegenerate)
+   if(%generatePreview || %forceRegenerate)
    {
-      displayEditorLoadingGui("Generating Material Asset Preview...");
-   
       if(isObject(%assetDef.materialDefinitionName))
       {
          %previewShapeDef = AssetDatabase.acquireAsset("ToolsModule:previewSphereShape");
@@ -169,38 +194,28 @@ function AssetBrowser::buildTerrainMaterialAssetPreview(%this, %assetDef, %previ
             %toolsModuleDef = ModuleDatabase.findModule("ToolsModule",1);
                
             %success = AssetDatabase.addDeclaredAsset(%toolsModuleDef, %previewImgAssetPath);
+            
+            if(!%success)
+            {
+               return false; //failed to register the preview image for some reason?
          }
       }
       
-      hideEditorLoadingGui();
+         %previewButton.bitmapAsset = %previewAssetName;
+         return true;
    }
-   
-   //Revalidate. If it didn't work, just use the default placeholder one
-   if(!isFile(%previewFilePath))
-   {
-      %previewData.previewImage = "ToolsModule:terrainMaterialIcon_image";
    }
    else
    {
-      %previewData.previewImage = "ToolsModule:" @ %previewAssetName;
+      //just map the existing one then
+      if(AssetDatabase.isDeclaredAsset("ToolsModule:" @ %previewAssetName))
+      {
+         %previewButton.bitmapAsset = "ToolsModule:" @ %previewAssetName;
+         return true;
+      }
    }
       
-   %previewData.assetName = %assetDef.assetName;
-   %previewData.assetPath = "";
-   %previewData.doubleClickCommand = "";
-   
-   %previewData.assetFriendlyName = %assetDef.gameObjectName;
-   %previewData.assetDesc = %assetDef.description;
-   %previewData.tooltip = %assetDef.gameObjectName;
-   
-   %definitionPath = %assetDef.getScriptPath();
-   if(%definitionPath $= "")
-      %definitionPath = %assetDef.getFilename();
-   
-   %previewData.tooltip = "Asset Name: " @ %assetDef.assetName @ 
-                           "\nAsset Type: Terrain Material Asset" @  
-                           "\nAsset Definition ID: " @  %assetDef @
-                           "\nDefinition Path: " @ %definitionPath;
+   return false;
 }
 
 function GuiInspectorTypeTerrainMaterialAssetPtr::onClick( %this, %fieldName )
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/newAsset.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/newAsset.tscript
index e3a813862..c4fe9b537 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/newAsset.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/newAsset.tscript
@@ -139,6 +139,33 @@ function newAssetUpdatePath(%newPath)
    NewAssetTargetModule.text = AssetBrowser.dirHandler.getModuleFromAddress(AssetBrowser.dirHandler.currentAddress).ModuleId;
 }
 
+//
+function AssetBrowser::importNewFile(%this)
+{
+   %importingPath = "";
+   
+   %dlg = new OpenFileDialog()
+   {
+      Filters = "(All Files (*.*)|*.*|";
+      DefaultFile = "";
+      ChangePath = false;
+      MustExist = true;
+      MultipleFiles = false;
+      forceRelativePath = false;
+   };
+      
+   if ( %dlg.Execute() )
+   {
+      %importingPath = makeFullPath(%dlg.FileName);
+   }
+   
+   %dlg.delete();
+   
+   AssetBrowser.onBeginDropFiles();
+   AssetBrowser.onDropFile(%importingPath);
+   AssetBrowser.onEndDropFiles();
+}
+
 //
 function NewAssetTargetModule::onSelect(%this, %idx, %idy)
 {
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/profiles.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/profiles.tscript
index b8825155e..5c3f03ba7 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/profiles.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/profiles.tscript
@@ -1,7 +1,7 @@
 singleton GuiControlProfile(AssetBrowserPreviewImageAsset : ToolsGuiDefaultProfile)
 {
-   fillColor = "128 128 128 255"; //hovered/selected
-   //fillColorNA = "230 126 0 255"; //fill color default
+   fillcolor = EditorSettings.value("Theme/windowBackgroundColor");
+   fillColorHL = EditorSettings.value("Theme/fieldBGHLColor");
    
    border = true;
    borderColor   = "230 126 0 255";
@@ -10,7 +10,8 @@ singleton GuiControlProfile(AssetBrowserPreviewImageAsset : ToolsGuiDefaultProfi
 
 singleton GuiControlProfile(AssetBrowserPreviewMaterialAsset : ToolsGuiDefaultProfile)
 {
-   fillColor = "128 128 128 255"; //hovered/selected
+   fillcolor = EditorSettings.value("Theme/windowBackgroundColor");
+   fillColorHL = EditorSettings.value("Theme/fieldBGHLColor");
    
    border = true;
    borderColor   = "0 100 0 255";
@@ -19,7 +20,8 @@ singleton GuiControlProfile(AssetBrowserPreviewMaterialAsset : ToolsGuiDefaultPr
 
 singleton GuiControlProfile(AssetBrowserPreviewShapeAsset : ToolsGuiDefaultProfile)
 {
-   fillColor = "128 128 128 255"; //hovered/selected
+   fillcolor = EditorSettings.value("Theme/windowBackgroundColor");
+   fillColorHL = EditorSettings.value("Theme/fieldBGHLColor");
    
    border = true;
    borderColor   = "0 0 200 255";
@@ -28,7 +30,8 @@ singleton GuiControlProfile(AssetBrowserPreviewShapeAsset : ToolsGuiDefaultProfi
 
 singleton GuiControlProfile(AssetBrowserPreviewShapeAnimationAsset : ToolsGuiDefaultProfile)
 {
-   fillColor = "128 128 128 255"; //hovered/selected
+   fillcolor = EditorSettings.value("Theme/windowBackgroundColor");
+   fillColorHL = EditorSettings.value("Theme/fieldBGHLColor");
    
    border = true;
    borderColor   = "0 0 200 255";
@@ -37,7 +40,8 @@ singleton GuiControlProfile(AssetBrowserPreviewShapeAnimationAsset : ToolsGuiDef
 
 singleton GuiControlProfile(AssetBrowserPreviewSoundAsset : ToolsGuiDefaultProfile)
 {
-   fillColor = "128 128 128 255"; //hovered/selected
+   fillcolor = EditorSettings.value("Theme/windowBackgroundColor");
+   fillColorHL = EditorSettings.value("Theme/fieldBGHLColor");
    
    border = true;
    borderColor   = "75 101 135 255";
@@ -46,7 +50,8 @@ singleton GuiControlProfile(AssetBrowserPreviewSoundAsset : ToolsGuiDefaultProfi
 
 singleton GuiControlProfile(AssetBrowserPreviewTerrainAsset : ToolsGuiDefaultProfile)
 {
-   fillColor = "128 128 128 255"; //hovered/selected
+   fillcolor = EditorSettings.value("Theme/windowBackgroundColor");
+   fillColorHL = EditorSettings.value("Theme/fieldBGHLColor");
    
    border = true;
    borderColor   = "200 198 198 255";
@@ -55,7 +60,8 @@ singleton GuiControlProfile(AssetBrowserPreviewTerrainAsset : ToolsGuiDefaultPro
 
 singleton GuiControlProfile(AssetBrowserPreviewTerrainMaterialAsset : ToolsGuiDefaultProfile)
 {
-   fillColor = "128 128 128 255"; //hovered/selected
+   fillcolor = EditorSettings.value("Theme/windowBackgroundColor");
+   fillColorHL = EditorSettings.value("Theme/fieldBGHLColor");
    
    border = true;
    borderColor   = "200 198 198 255";
@@ -64,7 +70,8 @@ singleton GuiControlProfile(AssetBrowserPreviewTerrainMaterialAsset : ToolsGuiDe
 
 singleton GuiControlProfile(AssetBrowserPreviewStateMachineAsset : ToolsGuiDefaultProfile)
 {
-   fillColor = "128 128 128 255"; //hovered/selected
+   fillcolor = EditorSettings.value("Theme/windowBackgroundColor");
+   fillColorHL = EditorSettings.value("Theme/fieldBGHLColor");
    
    border = true;
    borderColor   = "0 76 135 255";
@@ -73,7 +80,8 @@ singleton GuiControlProfile(AssetBrowserPreviewStateMachineAsset : ToolsGuiDefau
 
 singleton GuiControlProfile(AssetBrowserPreviewGUIAsset : ToolsGuiDefaultProfile)
 {
-   fillColor = "128 128 128 255"; //hovered/selected
+   fillcolor = EditorSettings.value("Theme/windowBackgroundColor");
+   fillColorHL = EditorSettings.value("Theme/fieldBGHLColor");
    
    border = true;
    borderColor   = "17 5 44 255";
@@ -82,7 +90,8 @@ singleton GuiControlProfile(AssetBrowserPreviewGUIAsset : ToolsGuiDefaultProfile
 
 singleton GuiControlProfile(AssetBrowserPreviewLevelAsset : ToolsGuiDefaultProfile)
 {
-   fillColor = "128 128 128 255"; //hovered/selected
+   fillcolor = EditorSettings.value("Theme/windowBackgroundColor");
+   fillColorHL = EditorSettings.value("Theme/fieldBGHLColor");
    
    border = true;
    borderColor   = "0 208 186 255";
diff --git a/Templates/BaseGame/game/tools/gui/profiles.ed.tscript b/Templates/BaseGame/game/tools/gui/profiles.ed.tscript
index 65d068e8a..478c15ce7 100644
--- a/Templates/BaseGame/game/tools/gui/profiles.ed.tscript
+++ b/Templates/BaseGame/game/tools/gui/profiles.ed.tscript
@@ -285,6 +285,12 @@ new GuiControlProfile( ToolsGuiTextArrayProfile : ToolsGuiTextProfile )
 if( !isObject( ToolsGuiTextListProfile ) )
 new GuiControlProfile( ToolsGuiTextListProfile : ToolsGuiTextProfile ) 
 {
+   fontColor = EditorSettings.value("Theme/fieldTextColor");
+   fontColorHL = EditorSettings.value("Theme/fieldTextHLColor");
+   fontColorSEL = EditorSettings.value("Theme/fieldTextSELColor");
+   fillColor = EditorSettings.value("Theme/fieldBGColor");
+   fillColorHL = EditorSettings.value("Theme/fieldBGHLColor");
+   fillColorSEL = EditorSettings.value("Theme/fieldBGSELColor");
    tab = true;
    canKeyFocus = true;
    category = "Tools";
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainImportGui.gui b/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainImportGui.gui
index ae0342a2a..3576e8734 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainImportGui.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/guiTerrainImportGui.gui
@@ -586,7 +586,7 @@ function TerrainImportGuiAddOpacityMap( %name )
    // once per channel in the file
    // currently it works with just grayscale.   
    %channelsTxt = "R" TAB "G" TAB "B" TAB "A";
-   %bitmapInfo = getBitmapinfo( %name );
+   %bitmapInfo = getBitmapinfo( makeFullPath(%name) );
    
    %channelCount = getWord( %bitmapInfo, 2 );   
    
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/menus.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/menus.ed.tscript
index 48cb8c5d5..0fd609019 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/menus.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/menus.ed.tscript
@@ -158,7 +158,7 @@ function EditorGui::buildMenus(%this)
    //%fileMenu.appendItem("Create Blank Terrain" TAB "" TAB "Canvas.pushDialog( CreateNewTerrainGui );");
    %fileMenu.appendItem("Create Blank Terrain" TAB "" TAB "AssetBrowser.setupCreateNewAsset(\"TerrainAsset\", AssetBrowser.selectedModule, createTerrainBlock);");         
      
-   %fileMenu.appendItem("Import Terrain Heightmap" TAB "" TAB "Canvas.pushDialog( TerrainImportGui );");
+   %fileMenu.appendItem("Import Terrain Heightmap" TAB "" TAB "AssetBrowser.setupCreateNewAsset(\"TerrainAsset\", AssetBrowser.selectedModule, createTerrainBlock); Canvas.pushDialog( TerrainImportGui );");
    
    %fileMenu.appendItem("Export Terrain Heightmap" TAB "" TAB "Canvas.pushDialog( TerrainExportGui );");
    %fileMenu.appendItem("-");

From 1ef41d85457977b725dcdf358e5a5bb2349aeaed Mon Sep 17 00:00:00 2001
From: Tony zfbx <1414927+zfbx@users.noreply.github.com>
Date: Sat, 23 Apr 2022 21:23:26 -0700
Subject: [PATCH 369/399] add .vs directory to gitignore

---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index 0ddf3aba2..c5ee6c610 100644
--- a/.gitignore
+++ b/.gitignore
@@ -183,3 +183,4 @@ My Projects/
 Project Manager.exe
 projects.xml
 Qt*.dll
+.vs

From 4f3d6c918bcbad23c15967a0602b84ac9feeffd3 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Sun, 24 Apr 2022 12:16:22 -0500
Subject: [PATCH 370/399] Fixes issue where storing of AB position and extent
 wasn't applying correctly Changes ShapeEditor's Library tab to an "Assets"
 tab and opens the AB with the shapeAsset filter on Adds Asset tab to world
 editor scenetree window that opens the assetBrowser Fixes issue where opening
 default scene in worldEditor would activate the saveAs dirty flag, then if
 you exit the level and open a new one, you can only saveAs and not save the
 existing level asset

---
 .../tools/assetBrowser/guis/assetBrowser.gui  |   4 +-
 .../game/tools/assetBrowser/main.tscript      |   9 +
 .../gui/shapeEdSelectWindow.ed.gui            | 122 +--------
 .../game/tools/shapeEditor/main.tscript       |   1 -
 .../scripts/shapeEditor.ed.tscript            | 234 +-----------------
 .../gui/WorldEditorTreeWindow.ed.gui          |  23 ++
 .../worldEditor/scripts/EditorGui.ed.tscript  |   2 +
 .../worldEditor/scripts/editor.ed.tscript     |   1 +
 8 files changed, 49 insertions(+), 347 deletions(-)

diff --git a/Templates/BaseGame/game/tools/assetBrowser/guis/assetBrowser.gui b/Templates/BaseGame/game/tools/assetBrowser/guis/assetBrowser.gui
index c4df19d95..1d3209b90 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/guis/assetBrowser.gui
+++ b/Templates/BaseGame/game/tools/assetBrowser/guis/assetBrowser.gui
@@ -157,8 +157,8 @@ $guiContent = new GuiControl(AssetBrowser) {
       position = "204 80";
       extent = "615 608";
       minExtent = "383 274";
-      horizSizing = "center";
-      vertSizing = "center";
+      horizSizing = "windowRelative";
+      vertSizing = "windowRelative";
       profile = "ToolsGuiWindowProfile";
       visible = "1";
       active = "1";
diff --git a/Templates/BaseGame/game/tools/assetBrowser/main.tscript b/Templates/BaseGame/game/tools/assetBrowser/main.tscript
index 8f6ca92dd..c912f2ee3 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/main.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/main.tscript
@@ -169,6 +169,15 @@ function AssetBrowserPlugin::onWorldEditorStartup( %this )
 { 
 }
 
+function AssetBrowserPlugin::onWorldEditorShutdown( %this )
+{
+   //force close us real fast to save off current settings/configs
+   if(AssetBrowser.isAwake())
+   {
+      AssetBrowser.hideDialog();
+   }
+}
+
 function AssetBrowserPlugin::initSettings( %this )
 {
    EditorSettings.beginGroup( "Assets", true );
diff --git a/Templates/BaseGame/game/tools/shapeEditor/gui/shapeEdSelectWindow.ed.gui b/Templates/BaseGame/game/tools/shapeEditor/gui/shapeEdSelectWindow.ed.gui
index 1311e16ea..c92f2ac3b 100644
--- a/Templates/BaseGame/game/tools/shapeEditor/gui/shapeEdSelectWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/shapeEditor/gui/shapeEdSelectWindow.ed.gui
@@ -45,7 +45,7 @@ $guiContent = new GuiControl() {
       EdgeSnap = "1";
       text = "Shapes";
 
-      new GuiTabBookCtrl() {
+      new GuiTabBookCtrl(ShapeEditorTabbook) {
          internalName = "tabBook";
          canSaveDynamicFields = "0";
          isContainer = "1";
@@ -175,126 +175,8 @@ $guiContent = new GuiControl() {
             AnchorBottom = "0";
             AnchorLeft = "1";
             AnchorRight = "0";
-            text = "Library";
+            text = "Assets";
             maxLength = "1024";
-
-            new GuiContainer() {
-               isContainer = "1";
-               HorizSizing = "width";
-               VertSizing = "height";
-               position = "0 0";
-               Extent = "202 146";
-               MinExtent = "0 -500";
-               Profile = "GuiInspectorProfile";
-            };
-            new GuiBitmapBorderCtrl() {
-               isContainer = "1";
-               HorizSizing = "width";
-               VertSizing = "height";
-               position = "0 0";
-               Extent = "202 146";
-               MinExtent = "0 -500";
-               Profile = "ToolsGuiTabBorderProfile";
-            };
-            new GuiBitmapButtonCtrl() {
-               canSaveDynamicFields = "0";
-               isContainer = "0";
-               Profile = "ToolsGuiButtonProfile";
-               HorizSizing = "right";
-               VertSizing = "bottom";
-               position = "3 4";
-               Extent = "20 19";
-               MinExtent = "8 2";
-               canSave = "1";
-               Visible = "1";
-               Command = "ShapeEdSelectWindow.navigateUp();";
-               tooltipprofile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
-               groupNum = "0";
-               buttonType = "PushButton";
-               useMouseEvents = "0";
-               bitmapAsset = "ToolsModule:folderUp_image";
-            };
-            new GuiPopUpMenuCtrl(ShapeEdSelectMenu) {
-               canSaveDynamicFields = "0";
-               isContainer = "0";
-               Profile = "ToolsGuiPopUpMenuProfile";
-               HorizSizing = "width";
-               VertSizing = "bottom";
-               position = "26 4";
-               Extent = "172 18";
-               MinExtent = "8 2";
-               canSave = "1";
-               Visible = "1";
-               tooltipprofile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
-               Margin = "0 0 0 0";
-               Padding = "0 0 0 0";
-               AnchorTop = "1";
-               AnchorBottom = "0";
-               AnchorLeft = "1";
-               AnchorRight = "0";
-               text = "art";
-               maxLength = "1024";
-               maxPopupHeight = "200";
-               sbUsesNAColor = "0";
-               reverseTextList = "0";
-               bitmapBounds = "16 16";
-            };
-            new GuiScrollCtrl() {
-               canSaveDynamicFields = "0";
-               isContainer = "1";
-               Profile = "ToolsGuiScrollProfile";
-               HorizSizing = "width";
-               VertSizing = "height";
-               position = "0 24";
-               Extent = "202 122";
-               MinExtent = "8 -500";
-               canSave = "1";
-               Visible = "1";
-               tooltipprofile = "ToolsGuiToolTipProfile";
-               hovertime = "1000";
-               Margin = "0 0 0 0";
-               Padding = "0 0 0 0";
-               AnchorTop = "1";
-               AnchorBottom = "0";
-               AnchorLeft = "1";
-               AnchorRight = "0";
-               willFirstRespond = "1";
-               hScrollBar = "dynamic";
-               vScrollBar = "dynamic";
-               lockHorizScroll = false;
-               lockVertScroll = "false";
-               constantThumbHeight = "0";
-               childMargin = "0 0";
-               mouseWheelScrollSpeed = "-1";
-
-               new GuiDynamicCtrlArrayControl() {
-                  internalName = "shapeLibrary";
-                  canSaveDynamicFields = "0";
-                  isContainer = "1";
-                  Profile = "ToolsGuiTransparentProfile";
-                  HorizSizing = "right";
-                  VertSizing = "bottom";
-                  position = "1 1";
-                  Extent = "189 42";
-                  MinExtent = "8 11";
-                  canSave = "1";
-                  Visible = "1";
-                  tooltipprofile = "ToolsGuiToolTipProfile";
-                  hovertime = "1000";
-                  colCount = "1";
-                  colSize = "64";
-                  rowCount = "0";
-                  RowSize = "64";
-                  rowSpacing = "4";
-                  colSpacing = "4";
-                  frozen = "0";
-                  autoCellSize = "1";
-                  fillRowFirst = "1";
-                  dynamicSize = "1";
-               };
-            };
          };
 
          //---------------------------------------------------------------
diff --git a/Templates/BaseGame/game/tools/shapeEditor/main.tscript b/Templates/BaseGame/game/tools/shapeEditor/main.tscript
index 1fa7626c4..958d609f6 100644
--- a/Templates/BaseGame/game/tools/shapeEditor/main.tscript
+++ b/Templates/BaseGame/game/tools/shapeEditor/main.tscript
@@ -127,7 +127,6 @@ function ShapeEditorPlugin::onWorldEditorStartup(%this)
    ShapeEdSeqNodeTabBook.selectPage(0);
    ShapeEdAdvancedWindow-->tabBook.selectPage(0);
    ShapeEdSelectWindow-->tabBook.selectPage(0);
-   ShapeEdSelectWindow.navigate("");
 
    SetToggleButtonValue( ShapeEditorToolbar-->orbitNodeBtn, 0 );
    SetToggleButtonValue( ShapeEditorToolbar-->ghostMode, 0 );
diff --git a/Templates/BaseGame/game/tools/shapeEditor/scripts/shapeEditor.ed.tscript b/Templates/BaseGame/game/tools/shapeEditor/scripts/shapeEditor.ed.tscript
index b53e1edaa..4d60f1f9e 100644
--- a/Templates/BaseGame/game/tools/shapeEditor/scripts/shapeEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/shapeEditor/scripts/shapeEditor.ed.tscript
@@ -366,230 +366,6 @@ function ShapeEdShapeTreeView::onSelect( %this, %obj )
    ShapeEdHintMenu.setSelected( %hintId );
 }
 
-// Find all DTS or COLLADA models. Note: most of this section was shamelessly
-// stolen from creater.ed.tscript => great work whoever did the original!
-function ShapeEdSelectWindow::navigate( %this, %address )
-{
-   // Freeze the icon array so it doesn't update until we've added all of the
-   // icons
-   %this-->shapeLibrary.frozen = true;
-   %this-->shapeLibrary.clear();
-   ShapeEdSelectMenu.clear();
-
-   %filePatterns = getFormatExtensions();
-   %fullPath = findFirstFileMultiExpr( %filePatterns );
-
-   while ( %fullPath !$= "" )
-   {
-      // Ignore cached DTS files
-      if ( endswith( %fullPath, "cached.dts" ) )
-      {
-         %fullPath = findNextFileMultiExpr( %filePatterns );
-         continue;
-      }
-
-      // Ignore assets in the tools folder
-      %fullPath = makeRelativePath( %fullPath, getMainDotCSDir() );
-      %splitPath = strreplace( %fullPath, " ", "_" );
-      %splitPath = strreplace( %splitPath, "/", " " );
-      if ( getWord( %splitPath, 0 ) $= "tools" )
-      {
-         %fullPath = findNextFileMultiExpr( %filePatterns );
-         continue;
-      }
-
-      %dirCount = getWordCount( %splitPath ) - 1;
-      %pathFolders = getWords( %splitPath, 0, %dirCount - 1 );
-
-      // Add this file's path ( parent folders ) to the
-      // popup menu if it isn't there yet.
-      %temp = strreplace( %pathFolders, " ", "/" );
-      %temp = strreplace( %temp, "_", " " );
-      %r = ShapeEdSelectMenu.findText( %temp );
-      if ( %r == -1 )
-         ShapeEdSelectMenu.add( %temp );
-
-      // Is this file in the current folder?
-      if ( stricmp( %pathFolders, %address ) == 0 )
-      {
-         %this.addShapeIcon( %fullPath );
-      }
-      // Then is this file in a subfolder we need to add
-      // a folder icon for?
-      else
-      {
-         %wordIdx = 0;
-         %add = false;
-
-         if ( %address $= "" )
-         {
-            %add = true;
-            %wordIdx = 0;
-         }
-         else
-         {
-            for ( ; %wordIdx < %dirCount; %wordIdx++ )
-            {
-               %temp = getWords( %splitPath, 0, %wordIdx );
-               if ( stricmp( %temp, %address ) == 0 )
-               {
-                  %add = true;
-                  %wordIdx++;
-                  break;
-               }
-            }
-         }
-
-         if ( %add == true )
-         {
-            %folder = getWord( %splitPath, %wordIdx );
-
-            // Add folder icon if not already present
-            %ctrl = %this.findIconCtrl( %folder );
-            if ( %ctrl == -1 )
-               %this.addFolderIcon( %folder );
-         }
-      }
-
-      %fullPath = findNextFileMultiExpr( %filePatterns );
-   }
-
-   %this-->shapeLibrary.sort( "alphaIconCompare" );
-   for ( %i = 0; %i < %this-->shapeLibrary.getCount(); %i++ )
-      %this-->shapeLibrary.getObject( %i ).autoSize = false;
-
-   %this-->shapeLibrary.frozen = false;
-   %this-->shapeLibrary.refresh();
-   %this.address = %address;
-
-   ShapeEdSelectMenu.sort();
-
-   %str = strreplace( %address, " ", "/" );
-   %r = ShapeEdSelectMenu.findText( %str );
-   if ( %r != -1 )
-      ShapeEdSelectMenu.setSelected( %r, false );
-   else
-      ShapeEdSelectMenu.setText( %str );
-}
-
-function ShapeEdSelectWindow::navigateDown( %this, %folder )
-{
-   if ( %this.address $= "" )
-      %address = %folder;
-   else
-      %address = %this.address SPC %folder;
-
-   // Because this is called from an IconButton::onClick command
-   // we have to wait a tick before actually calling navigate, else
-   // we would delete the button out from under itself.
-   %this.schedule( 1, "navigate", %address );
-}
-
-function ShapeEdSelectWindow::navigateUp( %this )
-{
-   %count = getWordCount( %this.address );
-
-   if ( %count == 0 )
-      return;
-
-   if ( %count == 1 )
-      %address = "";
-   else
-      %address = getWords( %this.address, 0, %count - 2 );
-
-   %this.navigate( %address );
-}
-
-function ShapeEdSelectWindow::findIconCtrl( %this, %name )
-{
-   for ( %i = 0; %i < %this-->shapeLibrary.getCount(); %i++ )
-   {
-      %ctrl = %this-->shapeLibrary.getObject( %i );
-      if ( %ctrl.text $= %name )
-         return %ctrl;
-   }
-   return -1;
-}
-
-function ShapeEdSelectWindow::createIcon( %this )
-{
-   %ctrl = new GuiIconButtonCtrl()
-   {
-      profile = "GuiCreatorIconButtonProfile";
-      iconLocation = "Left";
-      textLocation = "Right";
-      extent = "348 19";
-      textMargin = 8;
-      buttonMargin = "2 2";
-      autoSize = false;
-      sizeIconToButton = true;
-      makeIconSquare = true;
-      buttonType = "radioButton";
-      groupNum = "-1";   
-   };
-
-   return %ctrl;
-}
-
-function ShapeEdSelectWindow::addFolderIcon( %this, %text )
-{
-   %ctrl = %this.createIcon();
-
-   %ctrl.altCommand = "ShapeEdSelectWindow.navigateDown( \"" @ %text @ "\" );";
-   %ctrl.iconBitmap = "tools/gui/images/folder.png";
-   %ctrl.text = %text;
-   %ctrl.tooltip = %text;
-   %ctrl.class = "CreatorFolderIconBtn";
-   
-   %ctrl.buttonType = "radioButton";
-   %ctrl.groupNum = "-1";
-   
-   %this-->shapeLibrary.addGuiControl( %ctrl );
-}
-
-function ShapeEdSelectWindow::addShapeIcon( %this, %fullPath )
-{
-   %ctrl = %this.createIcon();
-
-   %ext = fileExt( %fullPath );
-   %file = fileBase( %fullPath );
-   %fileLong = %file @ %ext;
-   %tip = %fileLong NL
-          "Size: " @ fileSize( %fullPath ) / 1000.0 SPC "KB" NL
-          "Date Created: " @ fileCreatedTime( %fullPath ) NL
-          "Last Modified: " @ fileModifiedTime( %fullPath );
-
-   %ctrl.altCommand = "ShapeEdSelectWindow.onSelect( \"" @ %fullPath @ "\" );";
-   %ctrl.iconBitmap = ( ( %ext $= ".dts" ) ? EditorIconRegistry::findIconByClassName( "TSStatic" ) : "tools/gui/images/iconCollada" );
-   %ctrl.text = %file;
-   %ctrl.class = "CreatorStaticIconBtn";
-   %ctrl.tooltip = %tip;
-   
-   %ctrl.buttonType = "radioButton";
-   %ctrl.groupNum = "-1";
-
-   // Check if a shape specific icon is available
-   %formats = ".png .jpg .dds .bmp .gif .jng .tga";
-   %count = getWordCount( %formats );
-   for ( %i = 0; %i < %count; %i++ )
-   {
-      %ext = getWord( %formats, %i );
-      if ( isFile( %fullPath @ %ext ) )
-      {
-         %ctrl.iconBitmap = %fullPath @ %ext;
-         break;
-      }
-   }
-
-   %this-->shapeLibrary.addGuiControl( %ctrl );
-}
-
-function ShapeEdSelectMenu::onSelect( %this, %id, %text )
-{
-   %split = strreplace( %text, "/", " " );
-   ShapeEdSelectWindow.navigate( %split );
-}
-
 // Update the GUI in response to the shape selection changing
 function ShapeEdPropWindow::update_onShapeSelectionChanged( %this )
 {
@@ -3444,3 +3220,13 @@ function showShapeEditorPreview()
    %visible = ShapeEditorToolbar-->showPreview.getValue();
    ShapeEdPreviewGui.setVisible( %visible );
 }
+
+//
+function ShapeEditorTabbook::onTabSelected( %this )
+{
+   if( EditorTreeTabBook.getSelectedPage() == 1)
+   {
+      AssetBrowser.toggleDialog();
+      AssetBrowser.toggleAssetTypeFilter(12); //show only shapeAssets
+   }
+}
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/worldEditor/gui/WorldEditorTreeWindow.ed.gui b/Templates/BaseGame/game/tools/worldEditor/gui/WorldEditorTreeWindow.ed.gui
index 45bc34cae..bcf9fbf44 100644
--- a/Templates/BaseGame/game/tools/worldEditor/gui/WorldEditorTreeWindow.ed.gui
+++ b/Templates/BaseGame/game/tools/worldEditor/gui/WorldEditorTreeWindow.ed.gui
@@ -176,6 +176,29 @@ $guiContent = new GuiControl() {
                };
             };
          };
+      
+         new GuiTabPageCtrl() {
+            canSaveDynamicFields = "0";
+            Enabled = "1";
+            isContainer = "1";
+            Profile = "ToolsGuiEditorTabPage";
+            HorizSizing = "width";
+            VertSizing = "height";
+            position = "0 19";
+            Extent = "197 271";
+            MinExtent = "8 2";
+            canSave = "1";
+            Visible = "1";
+            hovertime = "1000";
+            Margin = "0 0 0 0";
+            Padding = "0 0 0 0";
+            AnchorTop = "1";
+            AnchorBottom = "0";
+            AnchorLeft = "1";
+            AnchorRight = "0";
+            text = "Assets";
+            maxLength = "1024";
+         };
       };
       new GuiBitmapButtonCtrl() {
          canSaveDynamicFields = "0";
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
index a10c44c87..74a4e30a7 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
@@ -1932,6 +1932,8 @@ function EditorTreeTabBook::onTabSelected( %this )
    }
    else
    {
+      AssetBrowser.toggleDialog();
+      EditorTreeTabBook.selectPage(0);
       EWTreeWindow-->DeleteSelection.visible = false;
       EWTreeWindow-->LockSelection.visible = false;
       EWTreeWindow-->AddSimGroup.visible = false;
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/editor.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/editor.ed.tscript
index cdd34c3d2..ff5696dd5 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/editor.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/editor.ed.tscript
@@ -191,6 +191,7 @@ package EditorDisconnectOverride
    {
       if ( isObject( Editor ) && Editor.isEditorEnabled() )
       {
+         EditorGui.saveAs = false; //whatever edits we were doing are irrelevent now
          %mainMenuGUI = ProjectSettings.value("UI/mainMenuName");
          if (isObject( %mainMenuGUI ))
             Editor.close( %mainMenuGUI );

From 81eec1dcb4a0d9f7b19d8825000be9c48bcfaa42 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Sun, 24 Apr 2022 13:03:33 -0500
Subject: [PATCH 371/399] Added multi type filter support to AB select mode
 Adjusted logic for World Editor's Assets tab to filter by ShapeAssets and
 Datablocks Improved ShapeEditor's Assets tab filter and select logic Added
 ability for AB search to work on creator section Fixed icon display of AB on
 preview cards when in list mode

---
 .../tools/assetBrowser/guis/assetBrowser.gui  |  2 +-
 .../assetBrowser/scripts/assetBrowser.tscript | 29 +++++++++++++++++--
 .../scripts/shapeEditor.ed.tscript            | 11 +++++--
 .../worldEditor/scripts/EditorGui.ed.tscript  |  5 +---
 4 files changed, 37 insertions(+), 10 deletions(-)

diff --git a/Templates/BaseGame/game/tools/assetBrowser/guis/assetBrowser.gui b/Templates/BaseGame/game/tools/assetBrowser/guis/assetBrowser.gui
index 1d3209b90..5a7aade06 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/guis/assetBrowser.gui
+++ b/Templates/BaseGame/game/tools/assetBrowser/guis/assetBrowser.gui
@@ -771,7 +771,7 @@ $guiContent = new GuiControl(AssetBrowser) {
                   position = "0 0";
                   extent = "23 23";
                   minExtent = "8 2";
-                  horizSizing = "left";
+                  horizSizing = "right";
                   vertSizing = "bottom";
                   profile = "ToolsGuiSolidDefaultProfile";
                   visible = "1";
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
index 3dd7b881d..0c7270d10 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
@@ -527,6 +527,7 @@ function AssetBrowser::buildAssetPreview( %this, %asset, %moduleName )
       %previewButton.iconLocation = "Left";
       %previewButton.textLocation = "Right";
       %previewButton.setextent(120,20);
+      %previewButton.buttonMargin = "0 0";
       
       AssetBrowser.previewListMode = true;
    }
@@ -1519,7 +1520,11 @@ function AssetBrowser::doRebuildAssetArray(%this)
          {
             if(AssetBrowser.assetTypeFilter !$= "")
             {
-               if(AssetBrowser.assetTypeFilter $= %assetType)
+               %filtersCount = getWordCount(AssetBrowser.assetTypeFilter);
+               for(%fltrIdx = 0; %fltrIdx < %filtersCount; %fltrIdx++)
+               {
+                  %fltr = getWord(AssetBrowser.assetTypeFilter, %fltrIdx);
+                  if(%fltr $= %assetType)
                {
                   $AssetBrowser::AssetArray.add( %moduleName, %assetId );
                   
@@ -1527,6 +1532,7 @@ function AssetBrowser::doRebuildAssetArray(%this)
                      %finalAssetCount++;
                }
             }
+            }
             else
             {
                //got it.	
@@ -1574,7 +1580,22 @@ function AssetBrowser::doRebuildAssetArray(%this)
    }
 
    //Add Non-Asset Scripted Objects. Datablock, etc based
-   if(AssetBrowser.assetTypeFilter $= "" && %breadcrumbPath !$= "" && isDirectory(%breadcrumbPath))
+   %hasDBFilter = true;
+   if(AssetBrowser.assetTypeFilter !$= "")
+   {
+      %hasDBFilter = false;
+      %filterCount = getWordCount(AssetBrowser.assetTypeFilter);
+      for(%fltrIdx = 0; %fltrIdx < %filterCount; %fltrIdx++)
+      {
+         %fltr = getWord(AssetBrowser.assetTypeFilter, %fltrIdx);
+         if(%fltr $= "Datablock" || %fltr $= "Datablocks")
+         {
+            %hasDBFilter = true;
+            break;  
+         }
+      }
+   }
+   if(%hasDBFilter && %breadcrumbPath !$= "" && isDirectory(%breadcrumbPath))
    {
       %category = getWord( %breadcrumbPath, 1 );                  
       %dataGroup = "DataBlockGroup";
@@ -1792,6 +1813,10 @@ function AssetBrowser::doRebuildAssetArray(%this)
             %name = %creatorObj.val[1];
             %func = %creatorObj.val[2];
             
+               %searchActive = AssetSearchTerms.count() != 0;
+               if(%searchActive && !matchesSearch(%name, "Creator"))
+                  continue;
+                     
             $AssetBrowser::AssetArray.add( %name, "Creator" TAB %creatorObj );
          }               
       }   
diff --git a/Templates/BaseGame/game/tools/shapeEditor/scripts/shapeEditor.ed.tscript b/Templates/BaseGame/game/tools/shapeEditor/scripts/shapeEditor.ed.tscript
index 4d60f1f9e..929fc510e 100644
--- a/Templates/BaseGame/game/tools/shapeEditor/scripts/shapeEditor.ed.tscript
+++ b/Templates/BaseGame/game/tools/shapeEditor/scripts/shapeEditor.ed.tscript
@@ -3224,9 +3224,14 @@ function showShapeEditorPreview()
 //
 function ShapeEditorTabbook::onTabSelected( %this )
 {
-   if( EditorTreeTabBook.getSelectedPage() == 1)
+   if( ShapeEditorTabbook.getSelectedPage() == 1)
    {
-      AssetBrowser.toggleDialog();
-      AssetBrowser.toggleAssetTypeFilter(12); //show only shapeAssets
+      AssetBrowser.showDialog("ShapeAsset", "openShapeInShapeEditor");
    }
+}
+
+function openShapeInShapeEditor(%shapeAssetId)
+{
+   %assetDef = AssetDatabase.acquireAsset(%shapeAssetId);
+   AssetBrowser.editShapeAsset(%assetDef);  
 }
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript b/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
index 74a4e30a7..58686e20e 100644
--- a/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
+++ b/Templates/BaseGame/game/tools/worldEditor/scripts/EditorGui.ed.tscript
@@ -1932,11 +1932,8 @@ function EditorTreeTabBook::onTabSelected( %this )
    }
    else
    {
-      AssetBrowser.toggleDialog();
+      AssetBrowser.showDialog("ShapeAsset Datablock");
       EditorTreeTabBook.selectPage(0);
-      EWTreeWindow-->DeleteSelection.visible = false;
-      EWTreeWindow-->LockSelection.visible = false;
-      EWTreeWindow-->AddSimGroup.visible = false;
    }
 }
 

From bd1bbdc258a92f5b935f9706920d464a6cee4beb Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Mon, 25 Apr 2022 13:28:32 -0500
Subject: [PATCH 372/399] correct mac compilation SDL now leverages
 https://cmake.org/cmake/help/v3.10/command/enable_language.html

---
 Tools/CMake/basics.cmake | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/Tools/CMake/basics.cmake b/Tools/CMake/basics.cmake
index c0fc10426..6719036db 100644
--- a/Tools/CMake/basics.cmake
+++ b/Tools/CMake/basics.cmake
@@ -467,6 +467,19 @@ if(WIN32)
         ENDFOREACH()
     endif()
 else()
+    if(${CMAKE_VERSION} VERSION_LESS "3.16.0")
+        macro(CHECK_OBJC_SOURCE_COMPILES SOURCE VAR)
+            set(PREV_REQUIRED_DEFS "${CMAKE_REQUIRED_DEFINITIONS}")
+            set(CMAKE_REQUIRED_DEFINITIONS "-x objective-c ${PREV_REQUIRED_DEFS}")
+            CHECK_C_SOURCE_COMPILES(${SOURCE} ${VAR})
+            set(CMAKE_REQUIRED_DEFINITIONS "${PREV_REQUIRED_DEFS}")
+        endmacro()
+    else()
+        include(CheckOBJCSourceCompiles)
+        if (APPLE)
+            enable_language(OBJC)
+        endif()
+    endif()
     # TODO: improve default settings on other platforms
     set(TORQUE_CXX_FLAGS_EXECUTABLES "" CACHE STRING "")
     mark_as_advanced(TORQUE_CXX_FLAGS_EXECUTABLES)

From 39952a490f4aa4f9d50506fcd1e968cd7b1f2336 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Mon, 25 Apr 2022 18:23:15 -0400
Subject: [PATCH 373/399] * Cleanup: Resolve several compiler warnings
 associated with TORQUE_DEBUG.

---
 Engine/source/T3D/assets/TerrainAsset.cpp     | 2 +-
 Engine/source/gfx/gfxCardProfile.cpp          | 4 ++--
 Engine/source/gfx/gl/gfxGLTextureObject.cpp   | 4 ++--
 Engine/source/gfx/gl/gfxGLTextureObject.h     | 4 ++--
 Engine/source/gfx/gl/gfxGLUtils.h             | 2 +-
 Engine/source/persistence/taml/tamlCustom.cpp | 2 +-
 Engine/source/persistence/taml/tamlCustom.h   | 4 ++--
 7 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/Engine/source/T3D/assets/TerrainAsset.cpp b/Engine/source/T3D/assets/TerrainAsset.cpp
index 2887cea2d..4e03f4c20 100644
--- a/Engine/source/T3D/assets/TerrainAsset.cpp
+++ b/Engine/source/T3D/assets/TerrainAsset.cpp
@@ -247,7 +247,7 @@ bool TerrainAsset::getAssetByFilename(StringTableEntry fileName, AssetPtr<Terrai
    {
       //Didn't find any assets
       //If possible, see if we can run an in-place import and the get the asset from that
-#if TORQUE_DEBUG
+#ifdef TORQUE_DEBUG
       Con::warnf("TerrainAsset::getAssetByFilename - Attempted to in-place import a terrainFile(%s) that had no associated asset", fileName);
 #endif
 
diff --git a/Engine/source/gfx/gfxCardProfile.cpp b/Engine/source/gfx/gfxCardProfile.cpp
index 525d3264c..38ad5c1ea 100644
--- a/Engine/source/gfx/gfxCardProfile.cpp
+++ b/Engine/source/gfx/gfxCardProfile.cpp
@@ -46,7 +46,7 @@ void GFXCardProfiler::loadProfileScript(const char* aScriptName)
 
    if(data == NULL)
    {
-#if TORQUE_DEBUG
+#ifdef TORQUE_DEBUG
       Con::warnf("      - No card profile %s exists", scriptName.c_str());
 #endif
       return;
@@ -54,7 +54,7 @@ void GFXCardProfiler::loadProfileScript(const char* aScriptName)
 
    const char  *script = static_cast<const char *>(data);
 
-#if TORQUE_DEBUG
+#ifdef TORQUE_DEBUG
    Con::printf("      - Loaded card profile %s", scriptName.c_str());
 #endif
 
diff --git a/Engine/source/gfx/gl/gfxGLTextureObject.cpp b/Engine/source/gfx/gl/gfxGLTextureObject.cpp
index e7dd88d4e..ea40a2e78 100644
--- a/Engine/source/gfx/gl/gfxGLTextureObject.cpp
+++ b/Engine/source/gfx/gl/gfxGLTextureObject.cpp
@@ -45,7 +45,7 @@ GFXGLTextureObject::GFXGLTextureObject(GFXDevice * aDevice, GFXTextureProfile *p
    mFrameAllocatorPtr(NULL)
 {
 
-#if TORQUE_DEBUG
+#ifdef TORQUE_DEBUG
    mFrameAllocatorMarkGuard = FrameAllocator::getWaterMark();
 #endif
 
@@ -90,7 +90,7 @@ GFXLockedRect* GFXGLTextureObject::lock(U32 mipLevel, RectI *inRect)
    mFrameAllocatorMark = FrameAllocator::getWaterMark();
    mFrameAllocatorPtr = (U8*)FrameAllocator::alloc( size );
    mLockedRect.bits = mFrameAllocatorPtr;
-#if TORQUE_DEBUG
+#ifdef TORQUE_DEBUG
    mFrameAllocatorMarkGuard = FrameAllocator::getWaterMark();
 #endif
    
diff --git a/Engine/source/gfx/gl/gfxGLTextureObject.h b/Engine/source/gfx/gl/gfxGLTextureObject.h
index 90d748bab..f07cb9138 100644
--- a/Engine/source/gfx/gl/gfxGLTextureObject.h
+++ b/Engine/source/gfx/gl/gfxGLTextureObject.h
@@ -102,10 +102,10 @@ private:
 
    //FrameAllocator
    U32 mFrameAllocatorMark;
-#if TORQUE_DEBUG
+#ifdef TORQUE_DEBUG
    U32 mFrameAllocatorMarkGuard;
 #endif
    U8 *mFrameAllocatorPtr;
 };
 
-#endif
\ No newline at end of file
+#endif
diff --git a/Engine/source/gfx/gl/gfxGLUtils.h b/Engine/source/gfx/gl/gfxGLUtils.h
index 8d235d6b9..2218836b0 100644
--- a/Engine/source/gfx/gl/gfxGLUtils.h
+++ b/Engine/source/gfx/gl/gfxGLUtils.h
@@ -208,7 +208,7 @@ GFXGLPreserveInteger TORQUE_CONCAT(preserve_, __LINE__) (GL_READ_FRAMEBUFFER, GL
 GFXGLPreserveInteger TORQUE_CONCAT(preserve2_, __LINE__) (GL_DRAW_FRAMEBUFFER, GL_DRAW_FRAMEBUFFER_BINDING, (GFXGLPreserveInteger::BindFn)glBindFramebuffer)
 
 
-#if TORQUE_DEBUG
+#ifdef TORQUE_DEBUG
 
     // Handy macro for checking the status of a framebuffer.  Framebuffers can fail in 
     // all sorts of interesting ways, these are just the most common.  Further, no existing GL profiling 
diff --git a/Engine/source/persistence/taml/tamlCustom.cpp b/Engine/source/persistence/taml/tamlCustom.cpp
index e45984dd4..1c0df2c13 100644
--- a/Engine/source/persistence/taml/tamlCustom.cpp
+++ b/Engine/source/persistence/taml/tamlCustom.cpp
@@ -42,7 +42,7 @@ void TamlCustomField::set( const char* pFieldName, const char* pFieldValue )
     // Set field name.
     mFieldName = StringTable->insert( pFieldName );
 
-#if TORQUE_DEBUG
+#ifdef TORQUE_DEBUG
     // Is the field value too big?
     if ( dStrlen(pFieldValue) >= sizeof(mFieldValue) )
     {
diff --git a/Engine/source/persistence/taml/tamlCustom.h b/Engine/source/persistence/taml/tamlCustom.h
index 2f3ba857e..6dacc099d 100644
--- a/Engine/source/persistence/taml/tamlCustom.h
+++ b/Engine/source/persistence/taml/tamlCustom.h
@@ -640,7 +640,7 @@ public:
 private:
     inline TamlCustomField* registerField( TamlCustomField* pCustomField )
     {
-#if TORQUE_DEBUG
+#ifdef TORQUE_DEBUG
         // Ensure a field name conflict does not exist.
         for( Vector<TamlCustomField*>::iterator nodeFieldItr = mFields.begin(); nodeFieldItr != mFields.end(); ++nodeFieldItr )
         {
@@ -724,7 +724,7 @@ public:
         // Set ignore-empty flag.
         pCustomNode->setIgnoreEmpty( ignoreEmpty );
 
-#if TORQUE_DEBUG
+#ifdef TORQUE_DEBUG
         // Ensure a node name conflict does not exist.
         for( TamlCustomNodeVector::iterator nodeItr = mNodes.begin(); nodeItr != mNodes.end(); ++nodeItr )
         {

From cbf758e0890b7bc23204f42c8aebd970a146cf65 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Mon, 25 Apr 2022 23:53:40 -0500
Subject: [PATCH 374/399] Removes the BGRA inversion when displaying vertex
 colors on materials

---
 Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp b/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
index d4e3acda4..360f8f918 100644
--- a/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
+++ b/Engine/source/shaderGen/HLSL/shaderFeatureHLSL.cpp
@@ -1250,7 +1250,7 @@ void DiffuseVertColorFeatureHLSL::processVert(  Vector< ShaderComponent* >& comp
       outColor->setStructName( "OUT" );
       outColor->setType( "float4" );
 
-      output = new GenOp( "   @ = @.bgra;\r\n", outColor, inColor );
+      output = new GenOp( "   @ = @;\r\n", outColor, inColor );
    }
    else
       output = NULL; // Nothing we need to do.

From 4ae7d7ce3f59f078499b7dc20b2e09641a05499a Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Tue, 26 Apr 2022 02:00:34 -0500
Subject: [PATCH 375/399] from higuy: "PATH_MAX is defined there on macos"

---
 Engine/source/platformPOSIX/POSIXFileio.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/Engine/source/platformPOSIX/POSIXFileio.cpp b/Engine/source/platformPOSIX/POSIXFileio.cpp
index c21e427ba..c9bfdd49c 100644
--- a/Engine/source/platformPOSIX/POSIXFileio.cpp
+++ b/Engine/source/platformPOSIX/POSIXFileio.cpp
@@ -46,6 +46,9 @@
 #if defined(__FreeBSD__)
 #include <sys/types.h>
 #endif
+#if defined(__APPLE__)
+#include <sys/syslimits.h>
+#endif
 #include <utime.h>
 
 /* these are for reading directors, getting stats, etc. */

From e5fba24778ea2809809444cc7c1cd6733aa21e24 Mon Sep 17 00:00:00 2001
From: Glenn Smith <couleeapps@gmail.com>
Date: Tue, 26 Apr 2022 03:51:13 -0400
Subject: [PATCH 376/399] Github actions CI

Using cmake + ninja
---
 .github/workflows/cmake.yml | 55 +++++++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)
 create mode 100644 .github/workflows/cmake.yml

diff --git a/.github/workflows/cmake.yml b/.github/workflows/cmake.yml
new file mode 100644
index 000000000..f25be008a
--- /dev/null
+++ b/.github/workflows/cmake.yml
@@ -0,0 +1,55 @@
+name: CMake
+
+on:
+  push:
+    branches: [ Preview4_0 ]
+  pull_request:
+    branches: [ Preview4_0 ]
+
+env:
+  # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
+  BUILD_TYPE: Release
+
+jobs:
+  build:
+    # The CMake configure and build commands are platform agnostic and should work equally well on Windows or Mac.
+    # You can convert this to a matrix build if you need cross-platform coverage.
+    # See: https://docs.github.com/en/free-pro-team@latest/actions/learn-github-actions/managing-complex-workflows#using-a-build-matrix
+    runs-on: ${{matrix.os}}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+
+    steps:
+    - uses: actions/checkout@v3
+    - uses: seanmiddleditch/gha-setup-ninja@master
+    - uses: ilammy/msvc-dev-cmd@v1
+    - name: Setup Environment
+      run:   |
+             if [ "$RUNNER_OS" == "Linux" ]; then
+                  sudo apt-get install -y \
+                    build-essential \
+                    nasm \
+                    libogg-dev \
+                    libxft-dev \
+                    libx11-dev \
+                    libxxf86vm-dev \
+                    libopenal-dev \
+                    libfreetype6-dev \
+                    libxcursor-dev \
+                    libxinerama-dev \
+                    libxi-dev \
+                    libxrandr-dev \
+                    libxss-dev \
+                    libglu1-mesa-dev \
+                    libgtk-3-dev
+             fi
+      shell: bash
+    - name: Configure CMake
+      # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
+      # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
+      run: cmake -B ${{github.workspace}}/build -G Ninja -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DTORQUE_APP_NAME=Torque3D
+
+    - name: Build
+      # Build your program with the given configuration
+      run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}

From d4307ea41306d12bb33e634f19de7adad9a01192 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Tue, 26 Apr 2022 09:17:21 -0500
Subject: [PATCH 377/399] update sdl to release 2.0.22

---
 Engine/lib/sdl/CMakeLists.txt                 |  254 ++--
 Engine/lib/sdl/Makefile.in                    |    1 +
 Engine/lib/sdl/Makefile.os2                   |    6 +-
 Engine/lib/sdl/WhatsNew.txt                   |   30 +
 Engine/lib/sdl/Xcode/SDL/Info-Framework.plist |    4 +-
 .../Xcode/SDL/SDL.xcodeproj/project.pbxproj   |   46 +-
 Engine/lib/sdl/build-scripts/os2-buildbot.sh  |   41 -
 Engine/lib/sdl/build-scripts/winrtbuild.ps1   |    2 +-
 Engine/lib/sdl/cmake/sdlchecks.cmake          |    6 +-
 Engine/lib/sdl/configure                      |  136 +-
 Engine/lib/sdl/configure.ac                   |   44 +-
 Engine/lib/sdl/docs/README-directfb.md        |   42 +-
 Engine/lib/sdl/docs/README-visualc.md         |    2 +-
 Engine/lib/sdl/docs/README-vita.md            |    3 +
 Engine/lib/sdl/docs/README-windows.md         |   81 +-
 Engine/lib/sdl/include/SDL_blendmode.h        |   10 +-
 Engine/lib/sdl/include/SDL_config.h.cmake     |    2 +
 Engine/lib/sdl/include/SDL_config.h.in        |    1 +
 .../lib/sdl/include/SDL_config_emscripten.h   |    1 +
 Engine/lib/sdl/include/SDL_config_windows.h   |    1 +
 Engine/lib/sdl/include/SDL_config_winrt.h     |    2 +
 Engine/lib/sdl/include/SDL_hints.h            |   76 +-
 Engine/lib/sdl/include/SDL_metal.h            |    1 +
 Engine/lib/sdl/include/SDL_rect.h             |   38 +-
 Engine/lib/sdl/include/SDL_render.h           |   13 +
 Engine/lib/sdl/include/SDL_stdinc.h           |   17 +-
 Engine/lib/sdl/include/SDL_syswm.h            |    2 +
 Engine/lib/sdl/include/SDL_version.h          |    2 +-
 Engine/lib/sdl/include/SDL_video.h            |    1 +
 Engine/lib/sdl/include/begin_code.h           |    2 +-
 Engine/lib/sdl/src/SDL.c                      |    2 +
 Engine/lib/sdl/src/SDL_hints.c                |    5 +
 Engine/lib/sdl/src/SDL_list.c                 |   93 ++
 Engine/lib/sdl/src/SDL_list.h                 |   39 +
 Engine/lib/sdl/src/audio/SDL_audio.c          |    2 +-
 Engine/lib/sdl/src/audio/SDL_audiocvt.c       |    2 +-
 Engine/lib/sdl/src/audio/SDL_wave.c           |    2 +-
 .../audio/emscripten/SDL_emscriptenaudio.c    |   16 +-
 Engine/lib/sdl/src/audio/vita/SDL_vitaaudio.c |   85 +-
 Engine/lib/sdl/src/audio/vita/SDL_vitaaudio.h |    4 +-
 Engine/lib/sdl/src/audio/wasapi/SDL_wasapi.c  |    4 +
 Engine/lib/sdl/src/core/linux/SDL_fcitx.c     |    8 +-
 Engine/lib/sdl/src/core/linux/SDL_fcitx.h     |    2 +-
 Engine/lib/sdl/src/core/linux/SDL_ibus.c      |   11 +-
 Engine/lib/sdl/src/core/linux/SDL_ibus.h      |    2 +-
 Engine/lib/sdl/src/core/linux/SDL_ime.c       |    6 +-
 Engine/lib/sdl/src/core/linux/SDL_ime.h       |    2 +-
 Engine/lib/sdl/src/core/windows/SDL_windows.c |  117 +-
 Engine/lib/sdl/src/core/windows/SDL_windows.h |    9 +
 .../lib/sdl/src/dynapi/SDL_dynapi_overrides.h |    1 +
 Engine/lib/sdl/src/dynapi/SDL_dynapi_procs.h  |    1 +
 Engine/lib/sdl/src/events/SDL_keyboard.c      |    1 +
 Engine/lib/sdl/src/events/SDL_mouse.c         |  109 +-
 Engine/lib/sdl/src/events/SDL_mouse_c.h       |    8 +
 Engine/lib/sdl/src/events/SDL_touch.c         |    5 +
 .../filesystem/windows/SDL_sysfilesystem.c    |   20 +-
 Engine/lib/sdl/src/hidapi/SDL_hidapi.c        |   10 +-
 Engine/lib/sdl/src/hidapi/libusb/hid.c        |    1 +
 Engine/lib/sdl/src/hidapi/mac/hid.c           |   22 +-
 .../sdl/src/joystick/SDL_gamecontrollerdb.h   |    3 +-
 Engine/lib/sdl/src/joystick/SDL_joystick.c    |   13 +-
 .../sdl/src/joystick/hidapi/SDL_hidapi_ps5.c  |   11 +-
 .../src/joystick/hidapi/SDL_hidapijoystick.c  |    2 +-
 .../src/joystick/iphoneos/SDL_mfijoystick.m   |   13 +
 .../sdl/src/joystick/linux/SDL_sysjoystick.c  |  119 +-
 .../joystick/windows/SDL_rawinputjoystick.c   |   24 +-
 .../windows/SDL_windows_gaming_input.c        |   63 +-
 .../lib/sdl/src/locale/vita/SDL_syslocale.c   |   71 +
 Engine/lib/sdl/src/main/windows/version.rc    |    8 +-
 Engine/lib/sdl/src/render/SDL_render.c        |   99 +-
 Engine/lib/sdl/src/render/SDL_sysrender.h     |   25 +-
 .../sdl/src/render/direct3d/SDL_render_d3d.c  |   44 +-
 .../src/render/direct3d11/SDL_render_d3d11.c  |   10 +
 .../lib/sdl/src/render/opengl/SDL_render_gl.c |   28 +-
 .../src/render/vitagxm/SDL_render_vita_gxm.c  |  287 +++-
 .../vitagxm/SDL_render_vita_gxm_memory.c      |   76 +-
 .../vitagxm/SDL_render_vita_gxm_memory.h      |   16 +-
 .../vitagxm/SDL_render_vita_gxm_tools.c       |  152 ++-
 .../vitagxm/SDL_render_vita_gxm_tools.h       |    7 +-
 .../vitagxm/SDL_render_vita_gxm_types.h       |   13 +-
 Engine/lib/sdl/src/test/SDL_test_common.c     |    2 +
 Engine/lib/sdl/src/thread/os2/SDL_sysmutex.c  |   10 +-
 Engine/lib/sdl/src/timer/os2/SDL_systimer.c   |   13 +-
 Engine/lib/sdl/src/video/SDL_bmp.c            |    6 +
 Engine/lib/sdl/src/video/SDL_egl.c            |    7 +-
 Engine/lib/sdl/src/video/SDL_pixels.c         |   41 +-
 Engine/lib/sdl/src/video/SDL_sysvideo.h       |    1 +
 Engine/lib/sdl/src/video/SDL_video.c          |   56 +-
 .../sdl/src/video/android/SDL_androidvideo.c  |    1 +
 .../sdl/src/video/android/SDL_androidwindow.c |    6 +
 .../sdl/src/video/android/SDL_androidwindow.h |    1 +
 .../lib/sdl/src/video/dummy/SDL_nullvideo.c   |    3 +-
 .../emscripten/SDL_emscriptenframebuffer.c    |   38 +-
 .../video/emscripten/SDL_emscriptenmouse.c    |   56 +-
 .../video/emscripten/SDL_emscriptenvideo.c    |    4 +-
 .../sdl/src/video/uikit/SDL_uikitmessagebox.m |   24 +-
 .../sdl/src/video/vita/SDL_vitaframebuffer.c  |    2 +-
 .../lib/sdl/src/video/vita/SDL_vitagl_pvr.c   |   65 +-
 .../lib/sdl/src/video/vita/SDL_vitagl_pvr_c.h |    9 +-
 .../vita/{SDL_vitagl.c => SDL_vitagles.c}     |   24 +-
 .../vita/{SDL_vitagl_c.h => SDL_vitagles_c.h} |   24 +-
 .../lib/sdl/src/video/vita/SDL_vitagles_pvr.c |  103 ++
 .../sdl/src/video/vita/SDL_vitagles_pvr_c.h   |   35 +
 Engine/lib/sdl/src/video/vita/SDL_vitavideo.c |   61 +-
 Engine/lib/sdl/src/video/vita/SDL_vitavideo.h |   21 +-
 .../sdl/src/video/wayland/SDL_waylanddyn.h    |   11 +-
 .../sdl/src/video/wayland/SDL_waylandevents.c |  445 ++++++-
 .../src/video/wayland/SDL_waylandevents_c.h   |   44 +
 .../src/video/wayland/SDL_waylandopengles.c   |    4 +-
 .../sdl/src/video/wayland/SDL_waylandsym.h    |   16 +-
 .../sdl/src/video/wayland/SDL_waylandvideo.c  |  400 +++++-
 .../sdl/src/video/wayland/SDL_waylandvideo.h  |   17 +-
 .../sdl/src/video/wayland/SDL_waylandvulkan.c |    4 +-
 .../sdl/src/video/wayland/SDL_waylandwindow.c |  669 +++++++++-
 .../sdl/src/video/wayland/SDL_waylandwindow.h |   18 +-
 .../sdl/src/video/windows/SDL_windowsevents.c |   16 +-
 .../sdl/src/video/windows/SDL_windowswindow.c |   11 +-
 Engine/lib/sdl/src/video/x11/SDL_x11events.c  |   74 +-
 Engine/lib/sdl/src/video/x11/SDL_x11events.h  |    1 +
 .../lib/sdl/src/video/x11/SDL_x11keyboard.c   |    2 +
 .../lib/sdl/src/video/x11/SDL_x11messagebox.c |   16 +-
 Engine/lib/sdl/src/video/x11/SDL_x11modes.c   |    8 +-
 Engine/lib/sdl/src/video/x11/SDL_x11opengl.c  |    5 -
 Engine/lib/sdl/src/video/x11/SDL_x11sym.h     |    1 -
 Engine/lib/sdl/src/video/x11/SDL_x11window.c  |  108 +-
 .../sdl/src/video/yuv2rgb/yuv_rgb_sse_func.h  |   19 +-
 Engine/lib/sdl/test/Makefile.in               |    1 +
 Engine/lib/sdl/test/testautomation_rect.c     |   98 +-
 Engine/lib/sdl/test/testevdev.c               |   36 +-
 Engine/lib/sdl/test/testgles2.c               |   63 +-
 Engine/lib/sdl/test/testmouse.c               |   34 +
 Engine/lib/sdl/test/testshader.c              |   49 +-
 .../wayland-protocols/tablet-unstable-v2.xml  | 1178 +++++++++++++++++
 .../lib/sdl/wayland-protocols/viewporter.xml  |  186 +++
 .../xdg-output-unstable-v1.xml                |  220 +++
 135 files changed, 5746 insertions(+), 1161 deletions(-)
 delete mode 100644 Engine/lib/sdl/build-scripts/os2-buildbot.sh
 create mode 100644 Engine/lib/sdl/src/SDL_list.c
 create mode 100644 Engine/lib/sdl/src/SDL_list.h
 create mode 100644 Engine/lib/sdl/src/locale/vita/SDL_syslocale.c
 rename Engine/lib/sdl/src/video/vita/{SDL_vitagl.c => SDL_vitagles.c} (91%)
 rename Engine/lib/sdl/src/video/vita/{SDL_vitagl_c.h => SDL_vitagles_c.h} (67%)
 create mode 100644 Engine/lib/sdl/src/video/vita/SDL_vitagles_pvr.c
 create mode 100644 Engine/lib/sdl/src/video/vita/SDL_vitagles_pvr_c.h
 create mode 100644 Engine/lib/sdl/wayland-protocols/tablet-unstable-v2.xml
 create mode 100644 Engine/lib/sdl/wayland-protocols/viewporter.xml
 create mode 100644 Engine/lib/sdl/wayland-protocols/xdg-output-unstable-v1.xml

diff --git a/Engine/lib/sdl/CMakeLists.txt b/Engine/lib/sdl/CMakeLists.txt
index 59bacf0f5..644715aae 100644
--- a/Engine/lib/sdl/CMakeLists.txt
+++ b/Engine/lib/sdl/CMakeLists.txt
@@ -66,12 +66,12 @@ include(${SDL2_SOURCE_DIR}/cmake/sdlchecks.cmake)
 # set SDL_BINARY_AGE and SDL_INTERFACE_AGE to 0.
 set(SDL_MAJOR_VERSION 2)
 set(SDL_MINOR_VERSION 0)
-set(SDL_MICRO_VERSION 21)
-set(SDL_INTERFACE_AGE 3)
-set(SDL_BINARY_AGE 21)
+set(SDL_MICRO_VERSION 22)
+set(SDL_INTERFACE_AGE 0)
+set(SDL_BINARY_AGE 22)
 set(SDL_VERSION "${SDL_MAJOR_VERSION}.${SDL_MINOR_VERSION}.${SDL_MICRO_VERSION}")
 # the following should match the versions in Xcode project file:
-set(DYLIB_CURRENT_VERSION 19.3.0)
+set(DYLIB_CURRENT_VERSION 23.0.0)
 set(DYLIB_COMPATIBILITY_VERSION 1.0.0)
 
 # Set defaults preventing destination file conflicts
@@ -372,6 +372,7 @@ endforeach()
 
 # Allow some projects to be built conditionally.
 set_option(SDL2_DISABLE_SDL2MAIN   "Disable building/installation of SDL2main" OFF)
+set_option(SDL2_DISABLE_INSTALL    "Disable installation of SDL2" OFF)
 set_option(SDL2_DISABLE_UNINSTALL  "Disable uninstallation of SDL2" OFF)
 
 option_string(SDL_ASSERTIONS "Enable internal sanity checks (auto/disabled/release/enabled/paranoid)" "auto")
@@ -1600,6 +1601,7 @@ elseif(WINDOWS)
 
   # headers needed elsewhere
   check_include_file(tpcshrd.h HAVE_TPCSHRD_H)
+  check_include_file(roapi.h HAVE_ROAPI_H)
   check_include_file(mmdeviceapi.h HAVE_MMDEVICEAPI_H)
   check_include_file(audioclient.h HAVE_AUDIOCLIENT_H)
   check_include_file(sensorsapi.h HAVE_SENSORSAPI_H)
@@ -2279,6 +2281,11 @@ elseif(VITA)
       ${SDL2_SOURCE_DIR}/src/thread/generic/SDL_systls.c)
     set(HAVE_SDL_THREADS TRUE)
   endif()
+  if(SDL_LOCALE)
+    file(GLOB LOCALE_SOURCES ${SDL2_SOURCE_DIR}/src/locale/vita/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${LOCALE_SOURCES})
+    set(HAVE_SDL_LOCALE TRUE)
+  endif()
   if(SDL_TIMERS)
     set(SDL_TIMER_VITA 1)
     file(GLOB TIMER_SOURCES ${SDL2_SOURCE_DIR}/src/timer/vita/*.c)
@@ -2305,10 +2312,10 @@ elseif(VITA)
         list(APPEND EXTRA_LIBS
           pib
         )
-        set(HAVE_VITA_PIB ON)
+        set(HAVE_VIDEO_VITA_PIB ON)
         set(SDL_VIDEO_VITA_PIB 1)
       else()
-        set(HAVE_VITA_PIB OFF)
+        set(HAVE_VIDEO_VITA_PIB OFF)
       endif()
     endif()
 
@@ -2316,6 +2323,7 @@ elseif(VITA)
       check_include_file(gpu_es4/psp2_pvr_hint.h HAVE_PVR_H)
       if(HAVE_PVR_H)
         target_compile_definitions(sdl-build-options INTERFACE "-D__psp2__")
+        check_include_file(gl4esinit.h HAVE_GL4ES_H)
         set(SDL_VIDEO_OPENGL_EGL 1)
         set(HAVE_OPENGLES TRUE)
         set(SDL_VIDEO_OPENGL_ES 1)
@@ -2327,10 +2335,20 @@ elseif(VITA)
           libgpu_es4_ext_stub_weak
           libIMGEGL_stub_weak
         )
-        set(HAVE_VITA_PVR ON)
+
+        set(HAVE_VIDEO_VITA_PVR ON)
         set(SDL_VIDEO_VITA_PVR 1)
+
+        if(HAVE_GL4ES_H)
+          set(HAVE_OPENGL TRUE)
+          set(SDL_VIDEO_OPENGL 1)
+          set(SDL_VIDEO_RENDER_OGL 1)
+          list(APPEND EXTRA_LIBS libGL_stub)
+          set(SDL_VIDEO_VITA_PVR_OGL 1)
+        endif()
+
       else()
-        set(HAVE_VITA_PVR OFF)
+        set(HAVE_VIDEO_VITA_PVR OFF)
       endif()
     endif()
 
@@ -2342,6 +2360,7 @@ elseif(VITA)
       SceCtrl_stub
       SceAppMgr_stub
       SceAudio_stub
+      SceAudioIn_stub
       SceSysmodule_stub
       SceDisplay_stub
       SceCtrl_stub
@@ -2950,122 +2969,125 @@ if(SDL_TEST)
 endif()
 
 ##### Installation targets #####
-if(SDL_SHARED)
-  install(TARGETS SDL2 EXPORT SDL2Targets
-    LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
-    ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
-    RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
-endif()
-
-if(NOT WINDOWS_STORE AND NOT SDL2_DISABLE_SDL2MAIN)
-  install(TARGETS SDL2main EXPORT SDL2mainTargets
-    LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
-    ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
-    RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
-endif()
-
-if(SDL_STATIC)
-  install(TARGETS SDL2-static EXPORT SDL2staticTargets
-    LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
-    ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
-    RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
-endif()
-
-##### Export files #####
-if (WINDOWS AND NOT MINGW)
-  set(PKG_PREFIX "cmake")
-else ()
-  set(PKG_PREFIX "${CMAKE_INSTALL_LIBDIR}/cmake/SDL2")
-endif ()
-
-include(CMakePackageConfigHelpers)
-write_basic_package_version_file("${CMAKE_BINARY_DIR}/SDL2ConfigVersion.cmake"
-  VERSION ${SDL_VERSION}
-  COMPATIBILITY AnyNewerVersion
-)
-
-if(SDL_SHARED)
-  install(EXPORT SDL2Targets
-    FILE SDL2Targets.cmake
-    NAMESPACE SDL2::
-    DESTINATION ${PKG_PREFIX}
-  )
-endif()
-
-if(NOT WINDOWS_STORE AND NOT SDL2_DISABLE_SDL2MAIN)
-  install(EXPORT SDL2mainTargets
-    FILE SDL2mainTargets.cmake
-    NAMESPACE SDL2::
-    DESTINATION ${PKG_PREFIX}
-  )
-endif()
-
-if(SDL_STATIC)
-  install(EXPORT SDL2staticTargets
-    FILE SDL2staticTargets.cmake
-    NAMESPACE SDL2::
-    DESTINATION ${PKG_PREFIX}
-  )
-endif()
-
-install(
-  FILES
-    ${CMAKE_CURRENT_SOURCE_DIR}/SDL2Config.cmake
-    ${CMAKE_BINARY_DIR}/SDL2ConfigVersion.cmake
-  DESTINATION ${PKG_PREFIX}
-  COMPONENT Devel
-)
-
-file(GLOB INCLUDE_FILES ${SDL2_SOURCE_DIR}/include/*.h)
-file(GLOB BIN_INCLUDE_FILES ${SDL2_BINARY_DIR}/include/*.h)
-foreach(_FNAME ${BIN_INCLUDE_FILES})
-  get_filename_component(_INCNAME ${_FNAME} NAME)
-  list(REMOVE_ITEM INCLUDE_FILES ${SDL2_SOURCE_DIR}/include/${_INCNAME})
-endforeach()
-list(APPEND INCLUDE_FILES ${BIN_INCLUDE_FILES})
-install(FILES ${INCLUDE_FILES} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/SDL2)
-
-string(TOUPPER "${CMAKE_BUILD_TYPE}" UPPER_BUILD_TYPE)
-if (UPPER_BUILD_TYPE MATCHES DEBUG)
-  set(SOPOSTFIX "${SDL_CMAKE_DEBUG_POSTFIX}")
-else()
-  set(SOPOSTFIX "")
-endif()
-
-if(NOT (WINDOWS OR CYGWIN) OR MINGW)
+if(NOT SDL2_DISABLE_INSTALL)
   if(SDL_SHARED)
-    set(SOEXT ${CMAKE_SHARED_LIBRARY_SUFFIX}) # ".so", ".dylib", etc.
-    get_target_property(SONAME SDL2 OUTPUT_NAME)
-    if(NOT ANDROID AND NOT MINGW AND NOT OS2)
-        install(CODE "
-          execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink
-            \"lib${SONAME}${SOPOSTFIX}${SOEXT}\" \"libSDL2${SOPOSTFIX}${SOEXT}\"
-            WORKING_DIRECTORY \"${SDL2_BINARY_DIR}\")")
-        install(FILES ${SDL2_BINARY_DIR}/libSDL2${SOPOSTFIX}${SOEXT} DESTINATION "${CMAKE_INSTALL_LIBDIR}")
-    endif()
+    install(TARGETS SDL2 EXPORT SDL2Targets
+      LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+      ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+      RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
   endif()
-  if(FREEBSD)
-    # FreeBSD uses ${PREFIX}/libdata/pkgconfig
-    install(FILES ${SDL2_BINARY_DIR}/sdl2.pc DESTINATION "libdata/pkgconfig")
+
+  if(NOT WINDOWS_STORE AND NOT SDL2_DISABLE_SDL2MAIN)
+    install(TARGETS SDL2main EXPORT SDL2mainTargets
+      LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+      ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+      RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
+  endif()
+
+  if(SDL_STATIC)
+    install(TARGETS SDL2-static EXPORT SDL2staticTargets
+      LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+      ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+      RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
+  endif()
+
+  ##### Export files #####
+  if (WINDOWS AND NOT MINGW)
+    set(PKG_PREFIX "cmake")
+  else ()
+    set(PKG_PREFIX "${CMAKE_INSTALL_LIBDIR}/cmake/SDL2")
+  endif ()
+
+  include(CMakePackageConfigHelpers)
+  write_basic_package_version_file("${CMAKE_BINARY_DIR}/SDL2ConfigVersion.cmake"
+    VERSION ${SDL_VERSION}
+    COMPATIBILITY AnyNewerVersion
+  )
+
+  if(SDL_SHARED)
+    install(EXPORT SDL2Targets
+      FILE SDL2Targets.cmake
+      NAMESPACE SDL2::
+      DESTINATION ${PKG_PREFIX}
+    )
+  endif()
+
+  if(NOT WINDOWS_STORE AND NOT SDL2_DISABLE_SDL2MAIN)
+    install(EXPORT SDL2mainTargets
+      FILE SDL2mainTargets.cmake
+      NAMESPACE SDL2::
+      DESTINATION ${PKG_PREFIX}
+    )
+  endif()
+
+  if(SDL_STATIC)
+    install(EXPORT SDL2staticTargets
+      FILE SDL2staticTargets.cmake
+      NAMESPACE SDL2::
+      DESTINATION ${PKG_PREFIX}
+    )
+  endif()
+
+  install(
+    FILES
+      ${CMAKE_CURRENT_SOURCE_DIR}/SDL2Config.cmake
+      ${CMAKE_BINARY_DIR}/SDL2ConfigVersion.cmake
+    DESTINATION ${PKG_PREFIX}
+    COMPONENT Devel
+  )
+
+  file(GLOB INCLUDE_FILES ${SDL2_SOURCE_DIR}/include/*.h)
+  file(GLOB BIN_INCLUDE_FILES ${SDL2_BINARY_DIR}/include/*.h)
+  foreach(_FNAME ${BIN_INCLUDE_FILES})
+    get_filename_component(_INCNAME ${_FNAME} NAME)
+    list(REMOVE_ITEM INCLUDE_FILES ${SDL2_SOURCE_DIR}/include/${_INCNAME})
+  endforeach()
+  list(APPEND INCLUDE_FILES ${BIN_INCLUDE_FILES})
+  install(FILES ${INCLUDE_FILES} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/SDL2)
+
+  string(TOUPPER "${CMAKE_BUILD_TYPE}" UPPER_BUILD_TYPE)
+  if (UPPER_BUILD_TYPE MATCHES DEBUG)
+    set(SOPOSTFIX "${SDL_CMAKE_DEBUG_POSTFIX}")
   else()
-    install(FILES ${SDL2_BINARY_DIR}/sdl2.pc
-      DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
+    set(SOPOSTFIX "")
+  endif()
+
+  if(NOT (WINDOWS OR CYGWIN) OR MINGW)
+    if(SDL_SHARED)
+      set(SOEXT ${CMAKE_SHARED_LIBRARY_SUFFIX}) # ".so", ".dylib", etc.
+      get_target_property(SONAME SDL2 OUTPUT_NAME)
+      if(NOT ANDROID AND NOT MINGW AND NOT OS2)
+          install(CODE "
+            execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink
+              \"lib${SONAME}${SOPOSTFIX}${SOEXT}\" \"libSDL2${SOPOSTFIX}${SOEXT}\"
+              WORKING_DIRECTORY \"${SDL2_BINARY_DIR}\")")
+          install(FILES ${SDL2_BINARY_DIR}/libSDL2${SOPOSTFIX}${SOEXT} DESTINATION "${CMAKE_INSTALL_LIBDIR}")
+      endif()
+    endif()
+    if(FREEBSD)
+      # FreeBSD uses ${PREFIX}/libdata/pkgconfig
+      install(FILES ${SDL2_BINARY_DIR}/sdl2.pc DESTINATION "libdata/pkgconfig")
+    else()
+      install(FILES ${SDL2_BINARY_DIR}/sdl2.pc
+        DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
+    endif()
+    install(PROGRAMS ${SDL2_BINARY_DIR}/sdl2-config DESTINATION "${CMAKE_INSTALL_BINDIR}")
+    # TODO: what about the .spec file? Is it only needed for RPM creation?
+    install(FILES "${SDL2_SOURCE_DIR}/sdl2.m4" DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/aclocal")
   endif()
-  install(PROGRAMS ${SDL2_BINARY_DIR}/sdl2-config DESTINATION "${CMAKE_INSTALL_BINDIR}")
-  # TODO: what about the .spec file? Is it only needed for RPM creation?
-  install(FILES "${SDL2_SOURCE_DIR}/sdl2.m4" DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/aclocal")
 endif()
 
 ##### Uninstall target #####
 
 if(NOT SDL2_DISABLE_UNINSTALL)
-if(NOT TARGET uninstall)
-  configure_file(
-      "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in"
-      "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
-      IMMEDIATE @ONLY)
+  if(NOT TARGET uninstall)
+    configure_file(
+        "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in"
+        "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
+        IMMEDIATE @ONLY)
 
-  add_custom_target(uninstall
-      COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
+    add_custom_target(uninstall
+        COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
+  endif()
 endif()
-endif(NOT SDL2_DISABLE_UNINSTALL)
+
diff --git a/Engine/lib/sdl/Makefile.in b/Engine/lib/sdl/Makefile.in
index 81c56fd3a..69f5cb1e2 100644
--- a/Engine/lib/sdl/Makefile.in
+++ b/Engine/lib/sdl/Makefile.in
@@ -19,6 +19,7 @@ distfile = $(distdir).tar.gz
 @SET_MAKE@
 SHELL	= @SHELL@
 CC      = @CC@
+CXX     = @CXX@
 INCLUDE = @INCLUDE@
 CFLAGS  = @BUILD_CFLAGS@
 EXTRA_CFLAGS = @EXTRA_CFLAGS@
diff --git a/Engine/lib/sdl/Makefile.os2 b/Engine/lib/sdl/Makefile.os2
index eb34494c5..cfd0d6562 100644
--- a/Engine/lib/sdl/Makefile.os2
+++ b/Engine/lib/sdl/Makefile.os2
@@ -11,7 +11,7 @@
 # wmake -f Makefile.os2 HIDAPI=1
 
 LIBNAME = SDL2
-VERSION = 2.0.21
+VERSION = 2.0.22
 DESCRIPTION = Simple DirectMedia Layer 2
 
 LIBICONV=0
@@ -60,7 +60,7 @@ CFLAGS_DLL+= -DHAVE_LIBUSB_H=1
 # building SDL itself (for DECLSPEC):
 CFLAGS_DLL+= -DBUILD_SDL
 
-SRCS = SDL.c SDL_assert.c SDL_error.c SDL_log.c SDL_dataqueue.c SDL_hints.c
+SRCS = SDL.c SDL_assert.c SDL_error.c SDL_log.c SDL_dataqueue.c SDL_hints.c SDL_list.c
 SRCS+= SDL_getenv.c SDL_iconv.c SDL_malloc.c SDL_qsort.c SDL_stdlib.c SDL_string.c SDL_strtokr.c SDL_crc32.c
 SRCS+= SDL_cpuinfo.c SDL_atomic.c SDL_spinlock.c SDL_thread.c SDL_timer.c
 SRCS+= SDL_rwops.c SDL_power.c
@@ -140,9 +140,11 @@ SDL_blendpoint.obj: SDL_blendpoint.c
     wcc386 $(CFLAGS_DLL) -wcd=200 -fo=$^@ $<
 SDL_RLEaccel.obj: SDL_RLEaccel.c
     wcc386 $(CFLAGS_DLL) -wcd=201 -fo=$^@ $<
+!ifeq HIDAPI 1
 # c99 mode needed because of structs with flexible array members in libusb.h
 SDL_hidapi.obj: SDL_hidapi.c
     wcc386 $(CFLAGS_DLL) -za99 -fo=$^@ $<
+!endif
 
 $(LIBICONV_LIB):  "src/core/os2/iconv2.lbc"
     @echo * Creating: $@
diff --git a/Engine/lib/sdl/WhatsNew.txt b/Engine/lib/sdl/WhatsNew.txt
index 33382ecea..fa6cbe11a 100644
--- a/Engine/lib/sdl/WhatsNew.txt
+++ b/Engine/lib/sdl/WhatsNew.txt
@@ -6,8 +6,38 @@ This is a list of major changes in SDL's version history.
 ---------------------------------------------------------------------------
 
 General:
+* Added SDL_RenderGetWindow() to get the window associated with a renderer
+* Added floating point rectangle functions:
+    * SDL_PointInFRect()
+    * SDL_FRectEmpty()
+    * SDL_FRectEquals()
+    * SDL_FRectEqualsEpsilon()
+    * SDL_HasIntersectionF()
+    * SDL_IntersectFRect()
+    * SDL_UnionFRect()
+    * SDL_EncloseFPoints()
+    * SDL_IntersectFRectAndLine()
+* Added SDL_IsTextInputShown() which returns whether the IME window is currently shown
+* Added SDL_ClearComposition() to dismiss the composition window without disabling IME input
+* Added SDL_TEXTEDITING_EXT event for handling long composition text, and a hint SDL_HINT_IME_SUPPORT_EXTENDED_TEXT to enable it
+* Added the hint SDL_HINT_MOUSE_RELATIVE_MODE_CENTER to control whether the mouse should be constrained to the whole window or the center of the window when relative mode is enabled
+* The mouse is now automatically captured when mouse buttons are pressed, and the hint SDL_HINT_MOUSE_AUTO_CAPTURE allows you to control this behavior
+* Added the hint SDL_HINT_VIDEO_FOREIGN_WINDOW_OPENGL to let SDL know that a foreign window will be used with OpenGL
+* Added the hint SDL_HINT_VIDEO_FOREIGN_WINDOW_VULKAN to let SDL know that a foreign window will be used with Vulkan
+* Added the hint SDL_HINT_QUIT_ON_LAST_WINDOW_CLOSE to specify whether an SDL_QUIT event will be delivered when the last application window is closed
 * Added the hint SDL_HINT_JOYSTICK_ROG_CHAKRAM to control whether ROG Chakram mice show up as joysticks
 
+Windows:
+* Added support for SDL_BLENDOPERATION_MINIMUM and SDL_BLENDOPERATION_MAXIMUM to the D3D9 renderer
+
+Linux:
+* Compiling with Wayland support requires libwayland-client version 1.18.0 or later
+* Added the hint SDL_HINT_X11_WINDOW_TYPE to specify the _NET_WM_WINDOW_TYPE of SDL windows
+* Added the hint SDL_HINT_VIDEO_WAYLAND_PREFER_LIBDECOR to allow using libdecor with compositors that support xdg-decoration
+
+Android:
+* Added SDL_AndroidSendMessage() to send a custom command to the SDL java activity
+
 
 ---------------------------------------------------------------------------
 2.0.20:
diff --git a/Engine/lib/sdl/Xcode/SDL/Info-Framework.plist b/Engine/lib/sdl/Xcode/SDL/Info-Framework.plist
index 19049bd46..49a711322 100644
--- a/Engine/lib/sdl/Xcode/SDL/Info-Framework.plist
+++ b/Engine/lib/sdl/Xcode/SDL/Info-Framework.plist
@@ -19,10 +19,10 @@
 	<key>CFBundlePackageType</key>
 	<string>FMWK</string>
 	<key>CFBundleShortVersionString</key>
-	<string>2.0.21</string>
+	<string>2.0.22</string>
 	<key>CFBundleSignature</key>
 	<string>SDLX</string>
 	<key>CFBundleVersion</key>
-	<string>2.0.21</string>
+	<string>2.0.22</string>
 </dict>
 </plist>
diff --git a/Engine/lib/sdl/Xcode/SDL/SDL.xcodeproj/project.pbxproj b/Engine/lib/sdl/Xcode/SDL/SDL.xcodeproj/project.pbxproj
index cd8affb60..8858cfdd9 100644
--- a/Engine/lib/sdl/Xcode/SDL/SDL.xcodeproj/project.pbxproj
+++ b/Engine/lib/sdl/Xcode/SDL/SDL.xcodeproj/project.pbxproj
@@ -111,6 +111,24 @@
 		A1626A582617008D003F1973 /* SDL_triangle.h in Headers */ = {isa = PBXBuildFile; fileRef = A1626A512617008C003F1973 /* SDL_triangle.h */; };
 		A1626A592617008D003F1973 /* SDL_triangle.h in Headers */ = {isa = PBXBuildFile; fileRef = A1626A512617008C003F1973 /* SDL_triangle.h */; };
 		A1626A5A2617008D003F1973 /* SDL_triangle.h in Headers */ = {isa = PBXBuildFile; fileRef = A1626A512617008C003F1973 /* SDL_triangle.h */; };
+		A1BB8B6327F6CF330057CFA8 /* SDL_list.c in Sources */ = {isa = PBXBuildFile; fileRef = A1BB8B6127F6CF320057CFA8 /* SDL_list.c */; };
+		A1BB8B6427F6CF330057CFA8 /* SDL_list.c in Sources */ = {isa = PBXBuildFile; fileRef = A1BB8B6127F6CF320057CFA8 /* SDL_list.c */; };
+		A1BB8B6527F6CF330057CFA8 /* SDL_list.c in Sources */ = {isa = PBXBuildFile; fileRef = A1BB8B6127F6CF320057CFA8 /* SDL_list.c */; };
+		A1BB8B6627F6CF330057CFA8 /* SDL_list.c in Sources */ = {isa = PBXBuildFile; fileRef = A1BB8B6127F6CF320057CFA8 /* SDL_list.c */; };
+		A1BB8B6727F6CF330057CFA8 /* SDL_list.c in Sources */ = {isa = PBXBuildFile; fileRef = A1BB8B6127F6CF320057CFA8 /* SDL_list.c */; };
+		A1BB8B6827F6CF330057CFA8 /* SDL_list.c in Sources */ = {isa = PBXBuildFile; fileRef = A1BB8B6127F6CF320057CFA8 /* SDL_list.c */; };
+		A1BB8B6927F6CF330057CFA8 /* SDL_list.c in Sources */ = {isa = PBXBuildFile; fileRef = A1BB8B6127F6CF320057CFA8 /* SDL_list.c */; };
+		A1BB8B6A27F6CF330057CFA8 /* SDL_list.c in Sources */ = {isa = PBXBuildFile; fileRef = A1BB8B6127F6CF320057CFA8 /* SDL_list.c */; };
+		A1BB8B6B27F6CF330057CFA8 /* SDL_list.c in Sources */ = {isa = PBXBuildFile; fileRef = A1BB8B6127F6CF320057CFA8 /* SDL_list.c */; };
+		A1BB8B6C27F6CF330057CFA8 /* SDL_list.h in Headers */ = {isa = PBXBuildFile; fileRef = A1BB8B6227F6CF330057CFA8 /* SDL_list.h */; };
+		A1BB8B6D27F6CF330057CFA8 /* SDL_list.h in Headers */ = {isa = PBXBuildFile; fileRef = A1BB8B6227F6CF330057CFA8 /* SDL_list.h */; };
+		A1BB8B6E27F6CF330057CFA8 /* SDL_list.h in Headers */ = {isa = PBXBuildFile; fileRef = A1BB8B6227F6CF330057CFA8 /* SDL_list.h */; };
+		A1BB8B6F27F6CF330057CFA8 /* SDL_list.h in Headers */ = {isa = PBXBuildFile; fileRef = A1BB8B6227F6CF330057CFA8 /* SDL_list.h */; };
+		A1BB8B7027F6CF330057CFA8 /* SDL_list.h in Headers */ = {isa = PBXBuildFile; fileRef = A1BB8B6227F6CF330057CFA8 /* SDL_list.h */; };
+		A1BB8B7127F6CF330057CFA8 /* SDL_list.h in Headers */ = {isa = PBXBuildFile; fileRef = A1BB8B6227F6CF330057CFA8 /* SDL_list.h */; };
+		A1BB8B7227F6CF330057CFA8 /* SDL_list.h in Headers */ = {isa = PBXBuildFile; fileRef = A1BB8B6227F6CF330057CFA8 /* SDL_list.h */; };
+		A1BB8B7327F6CF330057CFA8 /* SDL_list.h in Headers */ = {isa = PBXBuildFile; fileRef = A1BB8B6227F6CF330057CFA8 /* SDL_list.h */; };
+		A1BB8B7427F6CF330057CFA8 /* SDL_list.h in Headers */ = {isa = PBXBuildFile; fileRef = A1BB8B6227F6CF330057CFA8 /* SDL_list.h */; };
 		A7381E961D8B69D600B177DD /* CoreAudio.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = A7381E951D8B69D600B177DD /* CoreAudio.framework */; };
 		A7381E971D8B6A0300B177DD /* AudioToolbox.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = A7381E931D8B69C300B177DD /* AudioToolbox.framework */; };
 		A75FCCFD23E25AB700529352 /* SDL_shaders_metal_tvos.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8E323E2514000DCD162 /* SDL_shaders_metal_tvos.h */; };
@@ -3574,6 +3592,8 @@
 		75E09159241EA924004729E1 /* SDL_virtualjoystick_c.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_virtualjoystick_c.h; sourceTree = "<group>"; };
 		A1626A3D2617006A003F1973 /* SDL_triangle.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_triangle.c; sourceTree = "<group>"; };
 		A1626A512617008C003F1973 /* SDL_triangle.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_triangle.h; sourceTree = "<group>"; };
+		A1BB8B6127F6CF320057CFA8 /* SDL_list.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_list.c; sourceTree = "<group>"; };
+		A1BB8B6227F6CF330057CFA8 /* SDL_list.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_list.h; sourceTree = "<group>"; };
 		A7381E931D8B69C300B177DD /* AudioToolbox.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = AudioToolbox.framework; path = System/Library/Frameworks/AudioToolbox.framework; sourceTree = SDKROOT; };
 		A7381E951D8B69D600B177DD /* CoreAudio.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreAudio.framework; path = System/Library/Frameworks/CoreAudio.framework; sourceTree = SDKROOT; };
 		A75FCEB323E25AB700529352 /* libSDL2.dylib */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.dylib"; includeInIndex = 0; path = libSDL2.dylib; sourceTree = BUILT_PRODUCTS_DIR; };
@@ -4304,6 +4324,8 @@
 				A7D8A5AB23E2513D00DCD162 /* SDL_hints.c */,
 				A7D8A58323E2513D00DCD162 /* SDL_internal.h */,
 				A7D8A5DD23E2513D00DCD162 /* SDL_log.c */,
+				A1BB8B6127F6CF320057CFA8 /* SDL_list.c */,
+				A1BB8B6227F6CF330057CFA8 /* SDL_list.h */,
 				A7D8A57123E2513D00DCD162 /* SDL.c */,
 			);
 			name = "Library Source";
@@ -5284,6 +5306,7 @@
 				A75FCD4523E25AB700529352 /* SDL_gesture_c.h in Headers */,
 				A75FCD4623E25AB700529352 /* SDL_shaders_gl.h in Headers */,
 				A75FCD4723E25AB700529352 /* SDL_systhread_c.h in Headers */,
+				A1BB8B7327F6CF330057CFA8 /* SDL_list.h in Headers */,
 				A75FCD4823E25AB700529352 /* SDL_keycode.h in Headers */,
 				5616CA63252BB35F005D5928 /* SDL_sysurl.h in Headers */,
 				A75FCD4A23E25AB700529352 /* SDL_cocoakeyboard.h in Headers */,
@@ -5509,6 +5532,7 @@
 				A75FCEFE23E25AC700529352 /* SDL_gesture_c.h in Headers */,
 				A75FCEFF23E25AC700529352 /* SDL_shaders_gl.h in Headers */,
 				A75FCF0023E25AC700529352 /* SDL_systhread_c.h in Headers */,
+				A1BB8B7427F6CF330057CFA8 /* SDL_list.h in Headers */,
 				A75FCF0123E25AC700529352 /* SDL_keycode.h in Headers */,
 				5616CA66252BB361005D5928 /* SDL_sysurl.h in Headers */,
 				A75FCF0323E25AC700529352 /* SDL_cocoakeyboard.h in Headers */,
@@ -5707,6 +5731,7 @@
 				A769B0C623E259AE00872273 /* SDL_windowevents_c.h in Headers */,
 				A769B0C823E259AE00872273 /* SDL_cocoavideo.h in Headers */,
 				5605721C2473688D00B46B66 /* SDL_syslocale.h in Headers */,
+				A1BB8B7127F6CF330057CFA8 /* SDL_list.h in Headers */,
 				A769B0CA23E259AE00872273 /* SDL_uikitevents.h in Headers */,
 				A769B0CB23E259AE00872273 /* SDL_gesture_c.h in Headers */,
 				A769B0CC23E259AE00872273 /* SDL_shaders_gl.h in Headers */,
@@ -5955,6 +5980,7 @@
 				A7D8A98E23E2514000DCD162 /* SDL_sensor_c.h in Headers */,
 				A7D8BA7423E2514400DCD162 /* SDL_shaders_gl.h in Headers */,
 				A7D8BA5023E2514400DCD162 /* SDL_shaders_gles2.h in Headers */,
+				A1BB8B6D27F6CF330057CFA8 /* SDL_list.h in Headers */,
 				A7D8B98D23E2514400DCD162 /* SDL_shaders_metal_ios.h in Headers */,
 				A7D8B99C23E2514400DCD162 /* SDL_shaders_metal_osx.h in Headers */,
 				A7D8B9A223E2514400DCD162 /* SDL_shaders_metal_tvos.h in Headers */,
@@ -6185,6 +6211,7 @@
 				A7D8A98F23E2514000DCD162 /* SDL_sensor_c.h in Headers */,
 				A7D8BA7523E2514400DCD162 /* SDL_shaders_gl.h in Headers */,
 				A7D8BA5123E2514400DCD162 /* SDL_shaders_gles2.h in Headers */,
+				A1BB8B6E27F6CF330057CFA8 /* SDL_list.h in Headers */,
 				A7D8B98E23E2514400DCD162 /* SDL_shaders_metal_ios.h in Headers */,
 				A7D8B99D23E2514400DCD162 /* SDL_shaders_metal_osx.h in Headers */,
 				A7D8B9A323E2514400DCD162 /* SDL_shaders_metal_tvos.h in Headers */,
@@ -6332,6 +6359,7 @@
 				A7D8BBAF23E2514500DCD162 /* SDL_windowevents_c.h in Headers */,
 				A7D8AF0423E2514100DCD162 /* SDL_cocoavideo.h in Headers */,
 				5605721A2473688C00B46B66 /* SDL_syslocale.h in Headers */,
+				A1BB8B7027F6CF330057CFA8 /* SDL_list.h in Headers */,
 				A7D8ACC123E2514100DCD162 /* SDL_uikitevents.h in Headers */,
 				A7D8BB3D23E2514500DCD162 /* SDL_gesture_c.h in Headers */,
 				A7D8BA7723E2514400DCD162 /* SDL_shaders_gl.h in Headers */,
@@ -6580,6 +6608,7 @@
 				A7D8A98D23E2514000DCD162 /* SDL_sensor_c.h in Headers */,
 				A7D8BA7323E2514400DCD162 /* SDL_shaders_gl.h in Headers */,
 				A7D8BA4F23E2514400DCD162 /* SDL_shaders_gles2.h in Headers */,
+				A1BB8B6C27F6CF330057CFA8 /* SDL_list.h in Headers */,
 				A7D8B98C23E2514400DCD162 /* SDL_shaders_metal_ios.h in Headers */,
 				A7D8B99B23E2514400DCD162 /* SDL_shaders_metal_osx.h in Headers */,
 				A7D8B9A123E2514400DCD162 /* SDL_shaders_metal_tvos.h in Headers */,
@@ -6796,6 +6825,7 @@
 				A7D8B29F23E2514200DCD162 /* vulkan_xlib.h in Headers */,
 				A7D8B25D23E2514200DCD162 /* vulkan_vi.h in Headers */,
 				A7D8B29923E2514200DCD162 /* vulkan_mir.h in Headers */,
+				A1BB8B6F27F6CF330057CFA8 /* SDL_list.h in Headers */,
 				A7D8BB4E23E2514500DCD162 /* default_cursor.h in Headers */,
 				A7D8B9FE23E2514400DCD162 /* SDL_render_sw_c.h in Headers */,
 				A7D8BBED23E2574800DCD162 /* SDL_uikitappdelegate.h in Headers */,
@@ -6918,6 +6948,7 @@
 				A7D8BB3E23E2514500DCD162 /* SDL_gesture_c.h in Headers */,
 				A7D8BA7823E2514400DCD162 /* SDL_shaders_gl.h in Headers */,
 				A7D8B42D23E2514300DCD162 /* SDL_systhread_c.h in Headers */,
+				A1BB8B7227F6CF330057CFA8 /* SDL_list.h in Headers */,
 				DB313FDB17554B71006C0E22 /* SDL_keycode.h in Headers */,
 				A7D8AE9323E2514100DCD162 /* SDL_cocoakeyboard.h in Headers */,
 				A7D8ACE623E2514100DCD162 /* SDL_uikitvulkan.h in Headers */,
@@ -7554,6 +7585,7 @@
 				A75FCE8423E25AB700529352 /* e_exp.c in Sources */,
 				A75FCE8523E25AB700529352 /* SDL_quit.c in Sources */,
 				A75FCE8623E25AB700529352 /* SDL_cocoawindow.m in Sources */,
+				A1BB8B6A27F6CF330057CFA8 /* SDL_list.c in Sources */,
 				A75FCE8723E25AB700529352 /* SDL_sysmutex.c in Sources */,
 				A75FCE8823E25AB700529352 /* SDL_syshaptic.c in Sources */,
 				F3F07D61269640160074468B /* SDL_hidapi_luna.c in Sources */,
@@ -7741,6 +7773,7 @@
 				A75FD03D23E25AC700529352 /* e_exp.c in Sources */,
 				A75FD03E23E25AC700529352 /* SDL_quit.c in Sources */,
 				A75FD03F23E25AC700529352 /* SDL_cocoawindow.m in Sources */,
+				A1BB8B6B27F6CF330057CFA8 /* SDL_list.c in Sources */,
 				A75FD04023E25AC700529352 /* SDL_sysmutex.c in Sources */,
 				A75FD04123E25AC700529352 /* SDL_syshaptic.c in Sources */,
 				F3F07D62269640160074468B /* SDL_hidapi_luna.c in Sources */,
@@ -7927,6 +7960,7 @@
 				A769B20F23E259AE00872273 /* SDL_syshaptic.c in Sources */,
 				A769B21023E259AE00872273 /* e_exp.c in Sources */,
 				F395C1A12569C68F00942BFF /* SDL_iokitjoystick.c in Sources */,
+				A1BB8B6827F6CF330057CFA8 /* SDL_list.c in Sources */,
 				A769B21123E259AE00872273 /* SDL_quit.c in Sources */,
 				A769B21223E259AE00872273 /* SDL_cocoawindow.m in Sources */,
 				A769B21323E259AE00872273 /* SDL_sysmutex.c in Sources */,
@@ -8116,6 +8150,7 @@
 				A7D8B43B23E2514300DCD162 /* SDL_sysmutex.c in Sources */,
 				A7D8AAB123E2514100DCD162 /* SDL_syshaptic.c in Sources */,
 				A7D8B5CA23E2514300DCD162 /* SDL_rwopsbundlesupport.m in Sources */,
+				A1BB8B6427F6CF330057CFA8 /* SDL_list.c in Sources */,
 				A7D8AC1023E2514100DCD162 /* SDL_video.c in Sources */,
 				560572062473687700B46B66 /* SDL_syslocale.m in Sources */,
 				F3F07D5B269640160074468B /* SDL_hidapi_luna.c in Sources */,
@@ -8303,6 +8338,7 @@
 				A7D8B43C23E2514300DCD162 /* SDL_sysmutex.c in Sources */,
 				A7D8AAB223E2514100DCD162 /* SDL_syshaptic.c in Sources */,
 				A7D8B5CB23E2514300DCD162 /* SDL_rwopsbundlesupport.m in Sources */,
+				A1BB8B6527F6CF330057CFA8 /* SDL_list.c in Sources */,
 				A7D8AC1123E2514100DCD162 /* SDL_video.c in Sources */,
 				560572072473687800B46B66 /* SDL_syslocale.m in Sources */,
 				F3F07D5C269640160074468B /* SDL_hidapi_luna.c in Sources */,
@@ -8489,6 +8525,7 @@
 				A7D8AADE23E2514100DCD162 /* SDL_syshaptic.c in Sources */,
 				A7D8BAE923E2514500DCD162 /* e_exp.c in Sources */,
 				F395C1A02569C68F00942BFF /* SDL_iokitjoystick.c in Sources */,
+				A1BB8B6727F6CF330057CFA8 /* SDL_list.c in Sources */,
 				A7D8BB8523E2514500DCD162 /* SDL_quit.c in Sources */,
 				A7D8AEAA23E2514100DCD162 /* SDL_cocoawindow.m in Sources */,
 				A7D8B43E23E2514300DCD162 /* SDL_sysmutex.c in Sources */,
@@ -8665,6 +8702,7 @@
 				A7D8B55123E2514300DCD162 /* SDL_hidapi_switch.c in Sources */,
 				A7D8B96223E2514400DCD162 /* SDL_strtokr.c in Sources */,
 				A7D8BB7523E2514500DCD162 /* SDL_clipboardevents.c in Sources */,
+				A1BB8B6327F6CF330057CFA8 /* SDL_list.c in Sources */,
 				A7D8BAB523E2514400DCD162 /* k_cos.c in Sources */,
 				A7D8B54523E2514300DCD162 /* SDL_hidapijoystick.c in Sources */,
 				A7D8B97423E2514400DCD162 /* SDL_malloc.c in Sources */,
@@ -8850,6 +8888,7 @@
 				A7D8B96523E2514400DCD162 /* SDL_strtokr.c in Sources */,
 				A7D8BB7823E2514500DCD162 /* SDL_clipboardevents.c in Sources */,
 				A7D8BAB823E2514400DCD162 /* k_cos.c in Sources */,
+				A1BB8B6627F6CF330057CFA8 /* SDL_list.c in Sources */,
 				A7D8B54823E2514300DCD162 /* SDL_hidapijoystick.c in Sources */,
 				A7D8B97723E2514400DCD162 /* SDL_malloc.c in Sources */,
 				A7D8BBF023E2574800DCD162 /* SDL_uikitclipboard.m in Sources */,
@@ -9035,6 +9074,7 @@
 				A7D8B96723E2514400DCD162 /* SDL_strtokr.c in Sources */,
 				A7D8BB7A23E2514500DCD162 /* SDL_clipboardevents.c in Sources */,
 				A7D8BABA23E2514400DCD162 /* k_cos.c in Sources */,
+				A1BB8B6927F6CF330057CFA8 /* SDL_list.c in Sources */,
 				A7D8B54A23E2514300DCD162 /* SDL_hidapijoystick.c in Sources */,
 				A7D8B97923E2514400DCD162 /* SDL_malloc.c in Sources */,
 				A7D8B8CB23E2514400DCD162 /* SDL_audio.c in Sources */,
@@ -9111,7 +9151,7 @@
 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
 				DEPLOYMENT_POSTPROCESSING = YES;
 				DYLIB_COMPATIBILITY_VERSION = 1.0.0;
-				DYLIB_CURRENT_VERSION = 19.3.0;
+				DYLIB_CURRENT_VERSION = 23.0.0;
 				DYLIB_INSTALL_NAME_BASE = "@rpath";
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
 				GCC_ALTIVEC_EXTENSIONS = YES;
@@ -9195,7 +9235,7 @@
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
 				DEBUG_INFORMATION_FORMAT = dwarf;
 				DYLIB_COMPATIBILITY_VERSION = 1.0.0;
-				DYLIB_CURRENT_VERSION = 19.3.0;
+				DYLIB_CURRENT_VERSION = 23.0.0;
 				DYLIB_INSTALL_NAME_BASE = "@rpath";
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
 				ENABLE_TESTABILITY = YES;
@@ -9387,6 +9427,7 @@
 			buildSettings = {
 				CLANG_ENABLE_OBJC_ARC = YES;
 				CLANG_LINK_OBJC_RUNTIME = NO;
+				GCC_PREPROCESSOR_DEFINITIONS = GLES_SILENCE_DEPRECATION;
 				GCC_SYMBOLS_PRIVATE_EXTERN = YES;
 				SKIP_INSTALL = YES;
 				SUPPORTED_PLATFORMS = "iphonesimulator iphoneos";
@@ -9398,6 +9439,7 @@
 			buildSettings = {
 				CLANG_ENABLE_OBJC_ARC = YES;
 				CLANG_LINK_OBJC_RUNTIME = NO;
+				GCC_PREPROCESSOR_DEFINITIONS = GLES_SILENCE_DEPRECATION;
 				GCC_SYMBOLS_PRIVATE_EXTERN = YES;
 				SKIP_INSTALL = YES;
 				SUPPORTED_PLATFORMS = "iphonesimulator iphoneos";
diff --git a/Engine/lib/sdl/build-scripts/os2-buildbot.sh b/Engine/lib/sdl/build-scripts/os2-buildbot.sh
deleted file mode 100644
index abe0350d0..000000000
--- a/Engine/lib/sdl/build-scripts/os2-buildbot.sh
+++ /dev/null
@@ -1,41 +0,0 @@
-#!/bin/bash
-
-# This is the script buildbot.libsdl.org uses to cross-compile SDL2 from
-#  x86 Linux to OS/2, using OpenWatcom.
-
-# The final zipfile can be unpacked on any machine that supports OpenWatcom
-#  (Windows, Linux, OS/2, etc). Point the compiler at the include directory
-#  and link against the SDL2.lib file. Ship the SDL2.dll with your app.
-
-if [ -z "$WATCOM" ]; then
-    echo "This script expects \$WATCOM to be set to the OpenWatcom install dir." 1>&2
-    echo "This is often something like '/usr/local/share/watcom'" 1>&2
-    exit 1
-fi
-export PATH="$WATCOM/binl64:$PATH"
-
-ZIPFILE="$1"
-if [ -z $1 ]; then
-    ZIPFILE=sdl-os2.zip
-fi
-ZIPDIR=buildbot/SDL
-
-set -e
-set -x
-
-cd `dirname "$0"`
-cd ..
-
-rm -f $ZIPFILE
-wmake -f Makefile.os2
-rm -rf $ZIPDIR
-mkdir -p $ZIPDIR
-chmod 644 SDL2.dll SDL2.lib SDL2test.lib
-mv SDL2.dll SDL2.lib SDL2test.lib $ZIPDIR/
-cp -R include $ZIPDIR/
-zip -9r "buildbot/$ZIPFILE" $ZIPDIR
-
-wmake -f Makefile.os2 distclean
-
-set +x
-echo "All done. Final installable is in $ZIPFILE ...";
diff --git a/Engine/lib/sdl/build-scripts/winrtbuild.ps1 b/Engine/lib/sdl/build-scripts/winrtbuild.ps1
index 1da76abb1..892658014 100644
--- a/Engine/lib/sdl/build-scripts/winrtbuild.ps1
+++ b/Engine/lib/sdl/build-scripts/winrtbuild.ps1
@@ -39,7 +39,7 @@
 #
 
 # Base version of SDL, used for packaging purposes
-$SDLVersion = "2.0.21"
+$SDLVersion = "2.0.22"
 
 # Gets the .bat file that sets up an MSBuild environment, given one of
 # Visual Studio's, "PlatformToolset"s.
diff --git a/Engine/lib/sdl/cmake/sdlchecks.cmake b/Engine/lib/sdl/cmake/sdlchecks.cmake
index c9feffb69..8dcb39265 100644
--- a/Engine/lib/sdl/cmake/sdlchecks.cmake
+++ b/Engine/lib/sdl/cmake/sdlchecks.cmake
@@ -632,7 +632,7 @@ endmacro()
 # - HAVE_SDL_LOADSO opt
 macro(CheckWayland)
   if(SDL_WAYLAND)
-    pkg_check_modules(WAYLAND wayland-client wayland-egl wayland-cursor egl "xkbcommon>=0.5.0")
+    pkg_check_modules(WAYLAND "wayland-client>=1.18" wayland-egl wayland-cursor egl "xkbcommon>=0.5.0")
 
     if(WAYLAND_FOUND)
       find_program(WAYLAND_SCANNER NAMES wayland-scanner REQUIRED)
@@ -792,7 +792,9 @@ macro(CheckVivante)
       set(SDL_VIDEO_DRIVER_VIVANTE 1)
       if(HAVE_VIVANTE_VDK)
         set(SDL_VIDEO_DRIVER_VIVANTE_VDK 1)
-        list(APPEND EXTRA_LIBS VDK VIVANTE)
+        find_library(VIVANTE_LIBRARY REQUIRED NAMES VIVANTE vivante drm_vivante)
+        find_library(VIVANTE_VDK_LIBRARY VDK REQUIRED)
+        list(APPEND EXTRA_LIBS ${VIVANTE_LIBRARY} ${VIVANTE_VDK_LIBRARY})
       else()
         set(SDL_CFLAGS "${SDL_CFLAGS} -DLINUX -DEGL_API_FB")
         list(APPEND EXTRA_LIBS EGL)
diff --git a/Engine/lib/sdl/configure b/Engine/lib/sdl/configure
index df73ab0cb..f3ea813eb 100755
--- a/Engine/lib/sdl/configure
+++ b/Engine/lib/sdl/configure
@@ -673,6 +673,8 @@ X_CFLAGS
 XMKMF
 RPI_LIBS
 RPI_CFLAGS
+DECOR_LIBS
+DECOR_CFLAGS
 FUSIONSOUND_LIBS
 FUSIONSOUND_CFLAGS
 ARTSCONFIG
@@ -944,6 +946,8 @@ PULSEAUDIO_CFLAGS
 PULSEAUDIO_LIBS
 FUSIONSOUND_CFLAGS
 FUSIONSOUND_LIBS
+DECOR_CFLAGS
+DECOR_LIBS
 RPI_CFLAGS
 RPI_LIBS
 XMKMF
@@ -1779,6 +1783,9 @@ Some influential environment variables:
               C compiler flags for FUSIONSOUND, overriding pkg-config
   FUSIONSOUND_LIBS
               linker flags for FUSIONSOUND, overriding pkg-config
+  DECOR_CFLAGS
+              C compiler flags for DECOR, overriding pkg-config
+  DECOR_LIBS  linker flags for DECOR, overriding pkg-config
   RPI_CFLAGS  C compiler flags for RPI, overriding pkg-config
   RPI_LIBS    linker flags for RPI, overriding pkg-config
   XMKMF       Path to xmkmf, Makefile generator for X Window System
@@ -2859,9 +2866,9 @@ orig_CFLAGS="$CFLAGS"
 #
 SDL_MAJOR_VERSION=2
 SDL_MINOR_VERSION=0
-SDL_MICRO_VERSION=21
-SDL_INTERFACE_AGE=3
-SDL_BINARY_AGE=21
+SDL_MICRO_VERSION=22
+SDL_INTERFACE_AGE=0
+SDL_BINARY_AGE=22
 SDL_VERSION=$SDL_MAJOR_VERSION.$SDL_MINOR_VERSION.$SDL_MICRO_VERSION
 
 
@@ -20572,7 +20579,7 @@ $as_echo_n "checking for Wayland support... " >&6; }
         video_wayland=no
         if  test x$video_opengl_egl = xyes && \
             test x$video_opengles_v2 = xyes; then
-            if $PKG_CONFIG --exists wayland-client wayland-scanner wayland-egl wayland-cursor egl 'xkbcommon >= 0.5.0'; then
+            if $PKG_CONFIG --exists 'wayland-client >= 1.18' wayland-scanner wayland-egl wayland-cursor egl 'xkbcommon >= 0.5.0'; then
                 WAYLAND_CFLAGS=`$PKG_CONFIG --cflags wayland-client wayland-egl wayland-cursor xkbcommon`
                 WAYLAND_LIBS=`$PKG_CONFIG --libs wayland-client wayland-egl wayland-cursor xkbcommon`
                 WAYLAND_SCANNER=`$PKG_CONFIG --variable=wayland_scanner wayland-scanner`
@@ -20676,17 +20683,79 @@ else
 fi
 
             if test x$enable_libdecor = xyes; then
-                { $as_echo "$as_me:${as_lineno-$LINENO}: checking for libdecor support" >&5
-$as_echo_n "checking for libdecor support... " >&6; }
-                if $PKG_CONFIG --exists libdecor-0; then :
-  video_libdecor=yes
+
+pkg_failed=no
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for libdecor-0" >&5
+$as_echo_n "checking for libdecor-0... " >&6; }
+
+if test -n "$DECOR_CFLAGS"; then
+    pkg_cv_DECOR_CFLAGS="$DECOR_CFLAGS"
+ elif test -n "$PKG_CONFIG"; then
+    if test -n "$PKG_CONFIG" && \
+    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libdecor-0\""; } >&5
+  ($PKG_CONFIG --exists --print-errors "libdecor-0") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+  pkg_cv_DECOR_CFLAGS=`$PKG_CONFIG --cflags "libdecor-0" 2>/dev/null`
+		      test "x$?" != "x0" && pkg_failed=yes
 else
-  video_libdecor=no
+  pkg_failed=yes
+fi
+ else
+    pkg_failed=untried
+fi
+if test -n "$DECOR_LIBS"; then
+    pkg_cv_DECOR_LIBS="$DECOR_LIBS"
+ elif test -n "$PKG_CONFIG"; then
+    if test -n "$PKG_CONFIG" && \
+    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libdecor-0\""; } >&5
+  ($PKG_CONFIG --exists --print-errors "libdecor-0") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+  pkg_cv_DECOR_LIBS=`$PKG_CONFIG --libs "libdecor-0" 2>/dev/null`
+		      test "x$?" != "x0" && pkg_failed=yes
+else
+  pkg_failed=yes
+fi
+ else
+    pkg_failed=untried
+fi
+
+
+
+if test $pkg_failed = yes; then
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+
+if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
+        _pkg_short_errors_supported=yes
+else
+        _pkg_short_errors_supported=no
+fi
+        if test $_pkg_short_errors_supported = yes; then
+	        DECOR_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "libdecor-0" 2>&1`
+        else
+	        DECOR_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "libdecor-0" 2>&1`
+        fi
+	# Put the nasty error message in config.log where it belongs
+	echo "$DECOR_PKG_ERRORS" >&5
+
+	video_libdecor=no
+elif test $pkg_failed = untried; then
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+	video_libdecor=no
+else
+	DECOR_CFLAGS=$pkg_cv_DECOR_CFLAGS
+	DECOR_LIBS=$pkg_cv_DECOR_LIBS
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+	video_libdecor=yes
 fi
-                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $video_libdecor" >&5
-$as_echo "$video_libdecor" >&6; }
                 if test x$video_libdecor = xyes; then
-                    EXTRA_CFLAGS="$EXTRA_CFLAGS `$PKG_CONFIG --cflags libdecor-0`"
+                    EXTRA_CFLAGS="$EXTRA_CFLAGS $DECOR_CFLAGS"
 
 $as_echo "#define HAVE_LIBDECOR_H 1" >>confdefs.h
 
@@ -20699,18 +20768,16 @@ else
 fi
 
 
+                    decor_lib=`find_lib "libdecor-0.so.*" "$DECOR_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`
+
                     if test x$enable_wayland_shared != xyes; then
                        enable_libdecor_shared=no
                     fi
-
-                    decor_lib=`find_lib "libdecor-0.so.*" "" | sed 's/.*\/\(.*\)/\1/; q'`
-
                     if test x$have_loadso != xyes && \
                        test x$enable_libdecor_shared = xyes; then
                         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: You must have SDL_LoadObject() support for dynamic libdecor loading" >&5
 $as_echo "$as_me: WARNING: You must have SDL_LoadObject() support for dynamic libdecor loading" >&2;}
                     fi
-
                     if test x$have_loadso = xyes && \
                        test x$enable_libdecor_shared = xyes && test x$decor_lib != x; then
                         echo "-- dynamic libdecor -> $decor_lib"
@@ -20720,7 +20787,7 @@ cat >>confdefs.h <<_ACEOF
 _ACEOF
 
                     else
-                        EXTRA_LDFLAGS="$EXTRA_LDFLAGS `$PKG_CONFIG --libs libdecor-0`"
+                        EXTRA_LDFLAGS="$EXTRA_LDFLAGS $DECOR_LIBS"
                     fi
                 fi
             fi
@@ -24712,6 +24779,30 @@ $as_echo "$have_wince" >&6; }
 
     # This fixes Windows stack alignment with newer GCC
     CheckStackBoundary
+
+    # headers needed elsewhere
+    ac_fn_c_check_header_mongrel "$LINENO" "tpcshrd.h" "ac_cv_header_tpcshrd_h" "$ac_includes_default"
+if test "x$ac_cv_header_tpcshrd_h" = xyes; then :
+  have_tpcshrd_h=yes
+fi
+
+
+    if test x$have_tpcshrd_h = xyes; then
+
+$as_echo "#define HAVE_TPCSHRD_H 1" >>confdefs.h
+
+    fi
+    ac_fn_c_check_header_mongrel "$LINENO" "roapi.h" "ac_cv_header_roapi_h" "$ac_includes_default"
+if test "x$ac_cv_header_roapi_h" = xyes; then :
+  have_roapi_h=yes
+fi
+
+
+    if test x$have_roapi_h = xyes; then
+
+$as_echo "#define HAVE_ROAPI_H 1" >>confdefs.h
+
+    fi
 }
 
 CheckOS2()
@@ -26188,17 +26279,6 @@ $as_echo "#define SDL_HAPTIC_DINPUT 1" >>confdefs.h
                 have_haptic=yes
             fi
         fi
-        ac_fn_c_check_header_mongrel "$LINENO" "tpcshrd.h" "ac_cv_header_tpcshrd_h" "$ac_includes_default"
-if test "x$ac_cv_header_tpcshrd_h" = xyes; then :
-  have_tpcshrd_h=yes
-fi
-
-
-        if test x$have_tpcshrd_h = xyes; then
-
-$as_echo "#define HAVE_TPCSHRD_H 1" >>confdefs.h
-
-        fi
         # Set up files for the sensor library
         ac_fn_c_check_header_mongrel "$LINENO" "sensorsapi.h" "ac_cv_header_sensorsapi_h" "$ac_includes_default"
 if test "x$ac_cv_header_sensorsapi_h" = xyes; then :
diff --git a/Engine/lib/sdl/configure.ac b/Engine/lib/sdl/configure.ac
index 28d620d94..2209c04d7 100644
--- a/Engine/lib/sdl/configure.ac
+++ b/Engine/lib/sdl/configure.ac
@@ -22,9 +22,9 @@ dnl Set various version strings - taken gratefully from the GTk sources
 #
 SDL_MAJOR_VERSION=2
 SDL_MINOR_VERSION=0
-SDL_MICRO_VERSION=21
-SDL_INTERFACE_AGE=3
-SDL_BINARY_AGE=21
+SDL_MICRO_VERSION=22
+SDL_INTERFACE_AGE=0
+SDL_BINARY_AGE=22
 SDL_VERSION=$SDL_MAJOR_VERSION.$SDL_MINOR_VERSION.$SDL_MICRO_VERSION
 
 AC_SUBST(SDL_MAJOR_VERSION)
@@ -1555,7 +1555,7 @@ CheckWayland()
         video_wayland=no
         if  test x$video_opengl_egl = xyes && \
             test x$video_opengles_v2 = xyes; then
-            if $PKG_CONFIG --exists wayland-client wayland-scanner wayland-egl wayland-cursor egl 'xkbcommon >= 0.5.0'; then
+            if $PKG_CONFIG --exists 'wayland-client >= 1.18' wayland-scanner wayland-egl wayland-cursor egl 'xkbcommon >= 0.5.0'; then
                 WAYLAND_CFLAGS=`$PKG_CONFIG --cflags wayland-client wayland-egl wayland-cursor xkbcommon`
                 WAYLAND_LIBS=`$PKG_CONFIG --libs wayland-client wayland-egl wayland-cursor xkbcommon`
                 WAYLAND_SCANNER=`$PKG_CONFIG --variable=wayland_scanner wayland-scanner`
@@ -1626,39 +1626,31 @@ dnl FIXME: Do BSD and OS X need special cases?
 
 dnl See if libdecor is available
             AC_ARG_ENABLE(libdecor,
-[AS_HELP_STRING([--enable-libdecor], [use libdecor for Wayland client-side decorations [default=yes]])],
-                          , enable_libdecor=yes)
+[AS_HELP_STRING([--enable-libdecor], [use libdecor for Wayland client-side decorations [default=yes]])],, enable_libdecor=yes)
             if test x$enable_libdecor = xyes; then
-                AC_MSG_CHECKING(for libdecor support)
-                AS_IF([$PKG_CONFIG --exists libdecor-0],
-                      [video_libdecor=yes],
-                      [video_libdecor=no])
-                AC_MSG_RESULT($video_libdecor)
+                PKG_CHECK_MODULES([DECOR], [libdecor-0], video_libdecor=yes, video_libdecor=no)
                 if test x$video_libdecor = xyes; then
-                    EXTRA_CFLAGS="$EXTRA_CFLAGS `$PKG_CONFIG --cflags libdecor-0`"
+                    EXTRA_CFLAGS="$EXTRA_CFLAGS $DECOR_CFLAGS"
                     AC_DEFINE(HAVE_LIBDECOR_H, 1, [ ])
 
                     AC_ARG_ENABLE(libdecor-shared,
-[AS_HELP_STRING([--enable-libdecor-shared], [dynamically load libdecor [default=yes]])],
-                         , enable_libdecor_shared=yes)
+[AS_HELP_STRING([--enable-libdecor-shared], [dynamically load libdecor [default=yes]])],, enable_libdecor_shared=yes)
+
+                    decor_lib=[`find_lib "libdecor-0.so.*" "$DECOR_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`]
 
                     if test x$enable_wayland_shared != xyes; then
                        enable_libdecor_shared=no
                     fi
-
-                    decor_lib=[`find_lib "libdecor-0.so.*" "" | sed 's/.*\/\(.*\)/\1/; q'`]
-
                     if test x$have_loadso != xyes && \
                        test x$enable_libdecor_shared = xyes; then
                         AC_MSG_WARN([You must have SDL_LoadObject() support for dynamic libdecor loading])
                     fi
-
                     if test x$have_loadso = xyes && \
                        test x$enable_libdecor_shared = xyes && test x$decor_lib != x; then
                         echo "-- dynamic libdecor -> $decor_lib"
                         AC_DEFINE_UNQUOTED(SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_LIBDECOR, "$decor_lib", [ ])
                     else
-                        EXTRA_LDFLAGS="$EXTRA_LDFLAGS `$PKG_CONFIG --libs libdecor-0`"
+                        EXTRA_LDFLAGS="$EXTRA_LDFLAGS $DECOR_LIBS"
                     fi
                 fi
             fi
@@ -3206,6 +3198,16 @@ CheckWINDOWS()
 
     # This fixes Windows stack alignment with newer GCC
     CheckStackBoundary
+
+    # headers needed elsewhere
+    AC_CHECK_HEADER(tpcshrd.h,have_tpcshrd_h=yes)
+    if test x$have_tpcshrd_h = xyes; then
+        AC_DEFINE(HAVE_TPCSHRD_H, 1, [ ])
+    fi
+    AC_CHECK_HEADER(roapi.h,have_roapi_h=yes)
+    if test x$have_roapi_h = xyes; then
+        AC_DEFINE(HAVE_ROAPI_H, 1, [ ])
+    fi
 }
 
 dnl Determine whether the compiler can produce OS/2 executables
@@ -4007,10 +4009,6 @@ case "$host" in
                 have_haptic=yes
             fi
         fi
-        AC_CHECK_HEADER(tpcshrd.h,have_tpcshrd_h=yes)
-        if test x$have_tpcshrd_h = xyes; then
-            AC_DEFINE(HAVE_TPCSHRD_H, 1, [ ])
-        fi
         # Set up files for the sensor library
         AC_CHECK_HEADER(sensorsapi.h,have_winsensors=yes,have_winsensors=no)
         if test x$have_winsensors = xyes; then
diff --git a/Engine/lib/sdl/docs/README-directfb.md b/Engine/lib/sdl/docs/README-directfb.md
index 67b64fb61..6672fa40e 100644
--- a/Engine/lib/sdl/docs/README-directfb.md
+++ b/Engine/lib/sdl/docs/README-directfb.md
@@ -15,29 +15,34 @@ What you need:
 * Kernel-Framebuffer support: required: vesafb, radeonfb .... 
 * Mesa 7.0.x	   - optional for OpenGL
 
-/etc/directfbrc
-
-This file should contain the following lines to make
+The `/etc/directfbrc` file should contain the following lines to make
 your joystick work and avoid crashes:
-------------------------
+
+```
 disable-module=joystick
 disable-module=cle266
 disable-module=cyber5k
 no-linux-input-grab
-------------------------
+```
 
 To disable to use x11 backend when DISPLAY variable is found use
 
+```
 export SDL_DIRECTFB_X11_CHECK=0
+```
 
 To disable the use of linux input devices, i.e. multimice/multikeyboard support,
 use
 
+```
 export SDL_DIRECTFB_LINUX_INPUT=0
+```
 
 To use hardware accelerated YUV-overlays for YUV-textures, use:
 
+```
 export SDL_DIRECTFB_YUV_DIRECT=1
+```
 
 This is disabled by default. It will only support one 
 YUV texture, namely the first. Every other YUV texture will be
@@ -45,7 +50,9 @@ rendered in software.
 
 In addition, you may use (directfb-1.2.x)
 
+```
 export SDL_DIRECTFB_YUV_UNDERLAY=1
+```
 
 to make the YUV texture an underlay. This will make the cursor to
 be shown.
@@ -54,14 +61,18 @@ Simple Window Manager
 =====================
 
 The driver has support for a very, very basic window manager you may
-want to use when running with "wm=default". Use
+want to use when running with `wm=default`. Use
 
+```
 export SDL_DIRECTFB_WM=1
+```
 
 to enable basic window borders. In order to have the window title rendered,
 you need to have the following font installed:
 
+```
 /usr/share/fonts/truetype/freefont/FreeSans.ttf
+```
 
 OpenGL Support
 ==============
@@ -71,21 +82,25 @@ works at least on all directfb supported platforms.
 
 As of this writing 20100802 you need to pull Mesa from git and do the following:
 
-------------------------
+```
 git clone git://anongit.freedesktop.org/git/mesa/mesa
 cd mesa 
 git checkout 2c9fdaf7292423c157fc79b5ce43f0f199dd753a
-------------------------
+```
 
-Edit configs/linux-directfb so that the Directories-section looks like
-------------------------
+Edit `configs/linux-directfb` so that the Directories-section looks like this:
+
+```
 # Directories
 SRC_DIRS     = mesa glu 
 GLU_DIRS     = sgi
 DRIVER_DIRS  = directfb
 PROGRAM_DIRS = 
-------------------------
+```
 
+Then do the following:
+
+```
 make linux-directfb
 make
 
@@ -95,13 +110,14 @@ sudo make install INSTALL_DIR=/usr/local/dfb_GL
 cd src/mesa/drivers/directfb
 make
 sudo make install INSTALL_DIR=/usr/local/dfb_GL
-------------------------
+```
 
 To run the SDL - testprograms:
 
+```
 export SDL_VIDEODRIVER=directfb
 export LD_LIBRARY_PATH=/usr/local/dfb_GL/lib
 export LD_PRELOAD=/usr/local/dfb_GL/libGL.so.7
 
 ./testgl
-
+```
diff --git a/Engine/lib/sdl/docs/README-visualc.md b/Engine/lib/sdl/docs/README-visualc.md
index ea2bc1852..759752a56 100644
--- a/Engine/lib/sdl/docs/README-visualc.md
+++ b/Engine/lib/sdl/docs/README-visualc.md
@@ -1,7 +1,7 @@
 Using SDL with Microsoft Visual C++
 ===================================
 
-### by [Lion Kimbro](mailto:snowlion@sprynet.com) with additions by [James Turk](mailto:james@conceptofzero.net)
+### by Lion Kimbro with additions by James Turk
 
 You can either use the precompiled libraries from the [SDL](https://www.libsdl.org/download.php) web site, or you can build SDL
 yourself.
diff --git a/Engine/lib/sdl/docs/README-vita.md b/Engine/lib/sdl/docs/README-vita.md
index 535b4034c..503fef7d5 100644
--- a/Engine/lib/sdl/docs/README-vita.md
+++ b/Engine/lib/sdl/docs/README-vita.md
@@ -22,6 +22,9 @@ Notes
 * gles1/gles2 support and renderers are disabled by default and can be enabled by configuring with `-DVIDEO_VITA_PVR=ON`
   These renderers support 720p and 1080i resolutions. These can be specified with: 
   `SDL_setenv("VITA_RESOLUTION", "720", 1);` and `SDL_setenv("VITA_RESOLUTION", "1080", 1);`
+* Desktop GL 1.X and 2.X support and renderers are also disabled by default and also can be enabled with `-DVIDEO_VITA_PVR=ON` as long as gl4es4vita is present in your SDK.
+  They support the same resolutions as the gles1/gles2 backends and require specifying `SDL_setenv("VITA_PVR_OGL", "1", 1);`
+  anytime before video subsystem initialization.
 * gles2 support via PIB is disabled by default and can be enabled by configuring with `-DVIDEO_VITA_PIB=ON`
 * By default SDL emits mouse events for touch events on every touchscreen.  
   Vita has two touchscreens, so it's recommended to use `SDL_SetHint(SDL_HINT_TOUCH_MOUSE_EVENTS, "0");` and handle touch events instead.
diff --git a/Engine/lib/sdl/docs/README-windows.md b/Engine/lib/sdl/docs/README-windows.md
index 71f968eeb..ed0c93e2c 100644
--- a/Engine/lib/sdl/docs/README-windows.md
+++ b/Engine/lib/sdl/docs/README-windows.md
@@ -1,45 +1,58 @@
-Windows
-================================================================================
+# Windows
 
-================================================================================
-OpenGL ES 2.x support
-================================================================================
+## LLVM and Intel C++ compiler support
 
-SDL has support for OpenGL ES 2.x under Windows via two alternative 
-implementations. 
-The most straightforward method consists in running your app in a system with 
-a graphic card paired with a relatively recent (as of November of 2013) driver 
-which supports the WGL_EXT_create_context_es2_profile extension. Vendors known 
+SDL will build with the Visual Studio project files with LLVM-based compilers, such as the Intel oneAPI C++
+compiler, but you'll have to manually add the "-msse3" command line option
+to at least the SDL_audiocvt.c source file, and possibly others. This may
+not be necessary if you build SDL with CMake instead of the included Visual
+Studio solution.
+
+Details are here: https://github.com/libsdl-org/SDL/issues/5186
+
+
+## OpenGL ES 2.x support
+
+SDL has support for OpenGL ES 2.x under Windows via two alternative
+implementations.
+
+The most straightforward method consists in running your app in a system with
+a graphic card paired with a relatively recent (as of November of 2013) driver
+which supports the WGL_EXT_create_context_es2_profile extension. Vendors known
 to ship said extension on Windows currently include nVidia and Intel.
 
-The other method involves using the ANGLE library (https://code.google.com/p/angleproject/)
-If an OpenGL ES 2.x context is requested and no WGL_EXT_create_context_es2_profile
-extension is found, SDL will try to load the libEGL.dll library provided by
-ANGLE.
+The other method involves using the
+[ANGLE library](https://code.google.com/p/angleproject/). If an OpenGL ES 2.x
+context is requested and no WGL_EXT_create_context_es2_profile extension is
+found, SDL will try to load the libEGL.dll library provided by ANGLE.
+
 To obtain the ANGLE binaries, you can either compile from source from
-https://chromium.googlesource.com/angle/angle or copy the relevant binaries from
-a recent Chrome/Chromium install for Windows. The files you need are:
-    
-    * libEGL.dll
-    * libGLESv2.dll
-    * d3dcompiler_46.dll (supports Windows Vista or later, better shader compiler)
-    or...
-    * d3dcompiler_43.dll (supports Windows XP or later)
+https://chromium.googlesource.com/angle/angle or copy the relevant binaries
+from a recent Chrome/Chromium install for Windows. The files you need are:
+
+- libEGL.dll
+- libGLESv2.dll
+- d3dcompiler_46.dll (supports Windows Vista or later, better shader
+  compiler) *or* d3dcompiler_43.dll (supports Windows XP or later)
     
 If you compile ANGLE from source, you can configure it so it does not need the
-d3dcompiler_* DLL at all (for details on this, see their documentation). 
+d3dcompiler_* DLL at all (for details on this, see their documentation).
 However, by default SDL will try to preload the d3dcompiler_46.dll to
-comply with ANGLE's requirements. If you wish SDL to preload d3dcompiler_43.dll (to
-support Windows XP) or to skip this step at all, you can use the 
-SDL_HINT_VIDEO_WIN_D3DCOMPILER hint (see SDL_hints.h for more details).
+comply with ANGLE's requirements. If you wish SDL to preload
+d3dcompiler_43.dll (to support Windows XP) or to skip this step at all, you
+can use the SDL_HINT_VIDEO_WIN_D3DCOMPILER hint (see SDL_hints.h for more
+details).
 
 Known Bugs:
-    
-    * SDL_GL_SetSwapInterval is currently a no op when using ANGLE. It appears
-      that there's a bug in the library which prevents the window contents from
-      refreshing if this is set to anything other than the default value.
-     
-Vulkan Surface Support
-==============
 
-Support for creating Vulkan surfaces is configured on by default. To disable it change the value of `SDL_VIDEO_VULKAN` to 0 in `SDL_config_windows.h`. You must install the [Vulkan SDK](https://www.lunarg.com/vulkan-sdk/) in order to use Vulkan graphics in your application.
+- SDL_GL_SetSwapInterval is currently a no op when using ANGLE. It appears
+  that there's a bug in the library which prevents the window contents from
+  refreshing if this is set to anything other than the default value.
+  
+## Vulkan Surface Support
+
+Support for creating Vulkan surfaces is configured on by default. To disable
+it change the value of `SDL_VIDEO_VULKAN` to 0 in `SDL_config_windows.h`. You
+must install the [Vulkan SDK](https://www.lunarg.com/vulkan-sdk/) in order to
+use Vulkan graphics in your application.
+
diff --git a/Engine/lib/sdl/include/SDL_blendmode.h b/Engine/lib/sdl/include/SDL_blendmode.h
index b6d140dbb..08c9f9dd6 100644
--- a/Engine/lib/sdl/include/SDL_blendmode.h
+++ b/Engine/lib/sdl/include/SDL_blendmode.h
@@ -67,9 +67,8 @@ typedef enum
     SDL_BLENDOPERATION_ADD              = 0x1,  /**< dst + src: supported by all renderers */
     SDL_BLENDOPERATION_SUBTRACT         = 0x2,  /**< dst - src : supported by D3D9, D3D11, OpenGL, OpenGLES */
     SDL_BLENDOPERATION_REV_SUBTRACT     = 0x3,  /**< src - dst : supported by D3D9, D3D11, OpenGL, OpenGLES */
-    SDL_BLENDOPERATION_MINIMUM          = 0x4,  /**< min(dst, src) : supported by D3D11 */
-    SDL_BLENDOPERATION_MAXIMUM          = 0x5   /**< max(dst, src) : supported by D3D11 */
-
+    SDL_BLENDOPERATION_MINIMUM          = 0x4,  /**< min(dst, src) : supported by D3D9, D3D11 */
+    SDL_BLENDOPERATION_MAXIMUM          = 0x5   /**< max(dst, src) : supported by D3D9, D3D11 */
 } SDL_BlendOperation;
 
 /**
@@ -87,7 +86,6 @@ typedef enum
     SDL_BLENDFACTOR_ONE_MINUS_DST_COLOR = 0x8,  /**< 1-dstR, 1-dstG, 1-dstB, 1-dstA */
     SDL_BLENDFACTOR_DST_ALPHA           = 0x9,  /**< dstA, dstA, dstA, dstA */
     SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA = 0xA   /**< 1-dstA, 1-dstA, 1-dstA, 1-dstA */
-
 } SDL_BlendFactor;
 
 /**
@@ -135,10 +133,10 @@ typedef enum
  * SDL 2.0.6. All renderers support the four blend modes listed in the
  * SDL_BlendMode enumeration.
  *
- * - **direct3d**: Supports `SDL_BLENDOPERATION_ADD` with all factors.
- * - **direct3d11**: Supports all operations with all factors. However, some
+ * - **direct3d**: Supports all operations with all factors. However, some
  *   factors produce unexpected results with `SDL_BLENDOPERATION_MINIMUM` and
  *   `SDL_BLENDOPERATION_MAXIMUM`.
+ * - **direct3d11**: Same as Direct3D 9.
  * - **opengl**: Supports the `SDL_BLENDOPERATION_ADD` operation with all
  *   factors. OpenGL versions 1.1, 1.2, and 1.3 do not work correctly with SDL
  *   2.0.6.
diff --git a/Engine/lib/sdl/include/SDL_config.h.cmake b/Engine/lib/sdl/include/SDL_config.h.cmake
index 9a1bf6758..fcd18e57d 100644
--- a/Engine/lib/sdl/include/SDL_config.h.cmake
+++ b/Engine/lib/sdl/include/SDL_config.h.cmake
@@ -253,6 +253,7 @@
 #cmakedefine HAVE_AUDIOCLIENT_H @HAVE_AUDIOCLIENT_H@
 #cmakedefine HAVE_TPCSHRD_H @HAVE_TPCSHRD_H@
 #cmakedefine HAVE_SENSORSAPI_H @HAVE_SENSORSAPI_H@
+#cmakedefine HAVE_ROAPI_H @HAVE_ROAPI_H@
 
 #cmakedefine HAVE_XINPUT_GAMEPAD_EX @HAVE_XINPUT_GAMEPAD_EX@
 #cmakedefine HAVE_XINPUT_STATE_EX @HAVE_XINPUT_STATE_EX@
@@ -520,6 +521,7 @@
 
 #cmakedefine SDL_VIDEO_VITA_PIB @SDL_VIDEO_VITA_PIB@
 #cmakedefine SDL_VIDEO_VITA_PVR @SDL_VIDEO_VITA_PVR@
+#cmakedefine SDL_VIDEO_VITA_PVR_OGL @SDL_VIDEO_VITA_PVR_OGL@
 
 #if !defined(__WIN32__) && !defined(__WINRT__)
 #  if !defined(_STDINT_H_) && !defined(_STDINT_H) && !defined(HAVE_STDINT_H) && !defined(_HAVE_STDINT_H)
diff --git a/Engine/lib/sdl/include/SDL_config.h.in b/Engine/lib/sdl/include/SDL_config.h.in
index 195b9887e..f912e4112 100644
--- a/Engine/lib/sdl/include/SDL_config.h.in
+++ b/Engine/lib/sdl/include/SDL_config.h.in
@@ -242,6 +242,7 @@
 #undef HAVE_AUDIOCLIENT_H
 #undef HAVE_TPCSHRD_H
 #undef HAVE_SENSORSAPI_H
+#undef HAVE_ROAPI_H
 
 /* SDL internal assertion support */
 #undef SDL_DEFAULT_ASSERT_LEVEL
diff --git a/Engine/lib/sdl/include/SDL_config_emscripten.h b/Engine/lib/sdl/include/SDL_config_emscripten.h
index 7efe32373..028777df1 100644
--- a/Engine/lib/sdl/include/SDL_config_emscripten.h
+++ b/Engine/lib/sdl/include/SDL_config_emscripten.h
@@ -185,6 +185,7 @@
 /* Enable various threading systems */
 #ifdef __EMSCRIPTEN_PTHREADS__
 #define SDL_THREAD_PTHREAD 1
+#define SDL_THREAD_PTHREAD_RECURSIVE_MUTEX 1
 #endif
 
 /* Enable various timer systems */
diff --git a/Engine/lib/sdl/include/SDL_config_windows.h b/Engine/lib/sdl/include/SDL_config_windows.h
index efb246da9..770b19039 100644
--- a/Engine/lib/sdl/include/SDL_config_windows.h
+++ b/Engine/lib/sdl/include/SDL_config_windows.h
@@ -104,6 +104,7 @@ typedef unsigned int uintptr_t;
 #endif
 #if defined(_WIN32_MAXVER) && _WIN32_MAXVER >= 0x0602  /* Windows 8 SDK */
 #define HAVE_D3D11_H 1
+#define HAVE_ROAPI_H 1
 #endif
 #define HAVE_MMDEVICEAPI_H 1
 #define HAVE_AUDIOCLIENT_H 1
diff --git a/Engine/lib/sdl/include/SDL_config_winrt.h b/Engine/lib/sdl/include/SDL_config_winrt.h
index c548fd695..f3901a597 100644
--- a/Engine/lib/sdl/include/SDL_config_winrt.h
+++ b/Engine/lib/sdl/include/SDL_config_winrt.h
@@ -195,6 +195,8 @@ typedef unsigned int uintptr_t;
 #define HAVE_TRUNCF 1
 #define HAVE__FSEEKI64 1
 
+#define HAVE_ROAPI_H  1
+
 /* Enable various audio drivers */
 #define SDL_AUDIO_DRIVER_WASAPI 1
 #define SDL_AUDIO_DRIVER_DISK   1
diff --git a/Engine/lib/sdl/include/SDL_hints.h b/Engine/lib/sdl/include/SDL_hints.h
index 133f68769..ea819c85d 100644
--- a/Engine/lib/sdl/include/SDL_hints.h
+++ b/Engine/lib/sdl/include/SDL_hints.h
@@ -1354,6 +1354,18 @@ extern "C" {
  */
 #define SDL_HINT_TOUCH_MOUSE_EVENTS    "SDL_TOUCH_MOUSE_EVENTS"
 
+/**
+ *  \brief  A variable controlling which touchpad should generate synthetic mouse events
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Only front touchpad should generate mouse events. Default
+ *    "1"       - Only back touchpad should generate mouse events.
+ *    "2"       - Both touchpads should generate mouse events.
+ *
+ *  By default SDL will generate mouse events for all touch devices
+ */
+#define SDL_HINT_VITA_TOUCH_MOUSE_DEVICE    "SDL_HINT_VITA_TOUCH_MOUSE_DEVICE"
+
 /**
  *  \brief  A variable controlling whether the Android / tvOS remotes
  *  should be listed as joystick devices, instead of sending keyboard events.
@@ -1463,6 +1475,20 @@ extern "C" {
  */
 #define SDL_HINT_VIDEO_WAYLAND_ALLOW_LIBDECOR "SDL_VIDEO_WAYLAND_ALLOW_LIBDECOR"
 
+/**
+ *  \brief  A variable controlling whether the libdecor Wayland backend is preferred over native decrations.
+ *
+ *  When this hint is set, libdecor will be used to provide window decorations, even if xdg-decoration is
+ *  available. (Note that, by default, libdecor will use xdg-decoration itself if available).
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - libdecor is enabled only if server-side decorations are unavailable.
+ *    "1"       - libdecor is always enabled if available.
+ *
+ *  libdecor is used over xdg-shell when xdg-decoration protocol is unavailable.
+ */
+#define SDL_HINT_VIDEO_WAYLAND_PREFER_LIBDECOR "SDL_VIDEO_WAYLAND_PREFER_LIBDECOR"
+
 /**
 *  \brief  A variable that is the address of another SDL_Window* (as a hex string formatted with "%p").
 *  
@@ -1938,8 +1964,7 @@ extern "C" {
  *  If not set or set to "", this hint is ignored. This hint must be set
  *  before the SDL_CreateWindow() call that it is intended to affect.
  *
- *  This hint is available since SDL 2.0.22. Before then, virtual devices are
- *  always ignored.
+ *  This hint is available since SDL 2.0.22.
  */
 #define SDL_HINT_X11_WINDOW_TYPE "SDL_X11_WINDOW_TYPE"
 
@@ -1968,6 +1993,53 @@ extern "C" {
 #define SDL_HINT_QUIT_ON_LAST_WINDOW_CLOSE "SDL_QUIT_ON_LAST_WINDOW_CLOSE"
 
 
+/**
+ *  \brief  A variable that decides what video backend to use.
+ *
+ *  By default, SDL will try all available video backends in a reasonable
+ *  order until it finds one that can work, but this hint allows the app
+ *  or user to force a specific target, such as "x11" if, say, you are
+ *  on Wayland but want to try talking to the X server instead.
+ *
+ *  This functionality has existed since SDL 2.0.0 (indeed, before that)
+ *  but before 2.0.22 this was an environment variable only. In 2.0.22,
+ *  it was upgraded to a full SDL hint, so you can set the environment
+ *  variable as usual or programatically set the hint with SDL_SetHint,
+ *  which won't propagate to child processes.
+ *
+ *  The default value is unset, in which case SDL will try to figure out
+ *  the best video backend on your behalf. This hint needs to be set
+ *  before SDL_Init() is called to be useful.
+ *
+ *  This hint is available since SDL 2.0.22. Before then, you could set
+ *  the environment variable to get the same effect.
+ */
+#define SDL_HINT_VIDEODRIVER "SDL_VIDEODRIVER"
+
+/**
+ *  \brief  A variable that decides what audio backend to use.
+ *
+ *  By default, SDL will try all available audio backends in a reasonable
+ *  order until it finds one that can work, but this hint allows the app
+ *  or user to force a specific target, such as "alsa" if, say, you are
+ *  on PulseAudio but want to try talking to the lower level instead.
+ *
+ *  This functionality has existed since SDL 2.0.0 (indeed, before that)
+ *  but before 2.0.22 this was an environment variable only. In 2.0.22,
+ *  it was upgraded to a full SDL hint, so you can set the environment
+ *  variable as usual or programatically set the hint with SDL_SetHint,
+ *  which won't propagate to child processes.
+ *
+ *  The default value is unset, in which case SDL will try to figure out
+ *  the best audio backend on your behalf. This hint needs to be set
+ *  before SDL_Init() is called to be useful.
+ *
+ *  This hint is available since SDL 2.0.22. Before then, you could set
+ *  the environment variable to get the same effect.
+ */
+#define SDL_HINT_AUDIODRIVER "SDL_AUDIODRIVER"
+
+
 /**
  *  \brief  An enumeration of hint priorities
  */
diff --git a/Engine/lib/sdl/include/SDL_metal.h b/Engine/lib/sdl/include/SDL_metal.h
index 9ecaa8151..eb3082879 100644
--- a/Engine/lib/sdl/include/SDL_metal.h
+++ b/Engine/lib/sdl/include/SDL_metal.h
@@ -92,6 +92,7 @@ extern DECLSPEC void *SDLCALL SDL_Metal_GetLayer(SDL_MetalView view);
  *
  * \param window SDL_Window from which the drawable size should be queried
  * \param w Pointer to variable for storing the width in pixels, may be NULL
+ * \param h Pointer to variable for storing the height in pixels, may be NULL
  *
  * \since This function is available since SDL 2.0.14.
  *
diff --git a/Engine/lib/sdl/include/SDL_rect.h b/Engine/lib/sdl/include/SDL_rect.h
index 55a6473f2..b678c7a34 100644
--- a/Engine/lib/sdl/include/SDL_rect.h
+++ b/Engine/lib/sdl/include/SDL_rect.h
@@ -54,11 +54,6 @@ typedef struct SDL_Point
 /**
  * The structure that defines a point (floating point)
  *
- * \sa SDL_FRectEmpty
- * \sa SDL_FRectEquals
- * \sa SDL_HasIntersectionF
- * \sa SDL_IntersectFRect
- * \sa SDL_UnionFRect
  * \sa SDL_EncloseFPoints
  * \sa SDL_PointInFRect
  */
@@ -76,6 +71,7 @@ typedef struct SDL_FPoint
  * \sa SDL_RectEquals
  * \sa SDL_HasIntersection
  * \sa SDL_IntersectRect
+ * \sa SDL_IntersectRectAndLine
  * \sa SDL_UnionRect
  * \sa SDL_EnclosePoints
  */
@@ -88,6 +84,16 @@ typedef struct SDL_Rect
 
 /**
  * A rectangle, with the origin at the upper left (floating point).
+ *
+ * \sa SDL_FRectEmpty
+ * \sa SDL_FRectEquals
+ * \sa SDL_FRectEqualsEpsilon
+ * \sa SDL_HasIntersectionF
+ * \sa SDL_IntersectFRect
+ * \sa SDL_IntersectFRectAndLine
+ * \sa SDL_UnionFRect
+ * \sa SDL_EncloseFPoints
+ * \sa SDL_PointInFRect
  */
 typedef struct SDL_FRect
 {
@@ -239,12 +245,28 @@ SDL_FORCE_INLINE SDL_bool SDL_FRectEmpty(const SDL_FRect *r)
 }
 
 /**
- * Returns true if the two rectangles are equal.
+ * Returns true if the two rectangles are equal, within some given epsilon.
+ *
+ * \since This function is available since SDL 2.0.22.
+ */
+SDL_FORCE_INLINE SDL_bool SDL_FRectEqualsEpsilon(const SDL_FRect *a, const SDL_FRect *b, const float epsilon)
+{
+    return (a && b && ((a == b) ||
+            ((SDL_fabs(a->x - b->x) <= epsilon) &&
+            (SDL_fabs(a->y - b->y) <= epsilon) &&
+            (SDL_fabs(a->w - b->w) <= epsilon) &&
+            (SDL_fabs(a->h - b->h) <= epsilon))))
+            ? SDL_TRUE : SDL_FALSE;
+}
+
+/**
+ * Returns true if the two rectangles are equal, using a default epsilon.
+ *
+ * \since This function is available since SDL 2.0.22.
  */
 SDL_FORCE_INLINE SDL_bool SDL_FRectEquals(const SDL_FRect *a, const SDL_FRect *b)
 {
-    return (a && b && (a->x == b->x) && (a->y == b->y) &&
-            (a->w == b->w) && (a->h == b->h)) ? SDL_TRUE : SDL_FALSE;
+    return SDL_FRectEqualsEpsilon(a, b, SDL_FLT_EPSILON);
 }
 
 /**
diff --git a/Engine/lib/sdl/include/SDL_render.h b/Engine/lib/sdl/include/SDL_render.h
index 88620336b..d859e3fd6 100644
--- a/Engine/lib/sdl/include/SDL_render.h
+++ b/Engine/lib/sdl/include/SDL_render.h
@@ -261,6 +261,17 @@ extern DECLSPEC SDL_Renderer * SDLCALL SDL_CreateSoftwareRenderer(SDL_Surface *
  */
 extern DECLSPEC SDL_Renderer * SDLCALL SDL_GetRenderer(SDL_Window * window);
 
+/**
+ * Get the window associated with a renderer.
+ *
+ * \param renderer the renderer to query
+ * \returns the window on success or NULL on failure; call SDL_GetError() for
+ *          more information.
+ *
+ * \since This function is available since SDL 2.0.22.
+ */
+extern DECLSPEC SDL_Window * SDLCALL SDL_RenderGetWindow(SDL_Renderer *renderer);
+
 /**
  * Get information about a rendering context.
  *
@@ -1607,6 +1618,7 @@ extern DECLSPEC int SDLCALL SDL_RenderCopyExF(SDL_Renderer * renderer,
  * vertex array Color and alpha modulation is done per vertex
  * (SDL_SetTextureColorMod and SDL_SetTextureAlphaMod are ignored).
  *
+ * \param renderer The rendering context.
  * \param texture (optional) The SDL texture to use.
  * \param vertices Vertices.
  * \param num_vertices Number of vertices.
@@ -1631,6 +1643,7 @@ extern DECLSPEC int SDLCALL SDL_RenderGeometry(SDL_Renderer *renderer,
  * vertex arrays Color and alpha modulation is done per vertex
  * (SDL_SetTextureColorMod and SDL_SetTextureAlphaMod are ignored).
  *
+ * \param renderer The rendering context.
  * \param texture (optional) The SDL texture to use.
  * \param xy Vertex positions
  * \param xy_stride Byte size to move from one element to the next element
diff --git a/Engine/lib/sdl/include/SDL_stdinc.h b/Engine/lib/sdl/include/SDL_stdinc.h
index 4554f9e71..449e6445c 100644
--- a/Engine/lib/sdl/include/SDL_stdinc.h
+++ b/Engine/lib/sdl/include/SDL_stdinc.h
@@ -234,6 +234,19 @@ typedef uint64_t Uint64;
 
 /* @} *//* Basic data types */
 
+/**
+ *  \name Floating-point constants
+ */
+/* @{ */
+
+#ifdef FLT_EPSILON
+#define SDL_FLT_EPSILON FLT_EPSILON
+#else
+#define SDL_FLT_EPSILON 1.1920928955078125e-07F /* 0x0.000002p0 */
+#endif
+
+/* @} *//* Floating-point constants */
+
 /* Make sure we have macros for printing width-based integers.
  * <stdint.h> should define these but this is not true all platforms.
  * (for example win32) */
@@ -355,9 +368,9 @@ typedef uint64_t Uint64;
 #endif /* SDL_DISABLE_ANALYZE_MACROS */
 
 #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
-#define SDL_COMPILE_TIME_ASSERT(name, x) _Static_assert(x, #x);
+#define SDL_COMPILE_TIME_ASSERT(name, x) _Static_assert(x, #x)
 #elif defined(__cplusplus) && (__cplusplus >= 201103L)
-#define SDL_COMPILE_TIME_ASSERT(name, x)  static_assert(x, #x);
+#define SDL_COMPILE_TIME_ASSERT(name, x)  static_assert(x, #x)
 #else /* universal, but may trigger -Wunused-local-typedefs */
 #define SDL_COMPILE_TIME_ASSERT(name, x)               \
        typedef int SDL_compile_time_assert_ ## name[(x) * 2 - 1]
diff --git a/Engine/lib/sdl/include/SDL_syswm.h b/Engine/lib/sdl/include/SDL_syswm.h
index f7cd670cd..45f8e7540 100644
--- a/Engine/lib/sdl/include/SDL_syswm.h
+++ b/Engine/lib/sdl/include/SDL_syswm.h
@@ -298,6 +298,8 @@ struct SDL_SysWMinfo
             struct wl_egl_window *egl_window;       /**< Wayland EGL window (native window) */
             struct xdg_surface *xdg_surface;        /**< Wayland xdg surface (window manager handle) */
             struct xdg_toplevel *xdg_toplevel;      /**< Wayland xdg toplevel role */
+            struct xdg_popup *xdg_popup;            /**< Wayland xdg popup role */
+            struct xdg_positioner *xdg_positioner;  /**< Wayland xdg positioner, for popup */
         } wl;
 #endif
 #if defined(SDL_VIDEO_DRIVER_MIR)  /* no longer available, left for API/ABI compatibility. Remove in 2.1! */
diff --git a/Engine/lib/sdl/include/SDL_version.h b/Engine/lib/sdl/include/SDL_version.h
index a925dc432..3df4e041a 100644
--- a/Engine/lib/sdl/include/SDL_version.h
+++ b/Engine/lib/sdl/include/SDL_version.h
@@ -59,7 +59,7 @@ typedef struct SDL_version
 */
 #define SDL_MAJOR_VERSION   2
 #define SDL_MINOR_VERSION   0
-#define SDL_PATCHLEVEL      21
+#define SDL_PATCHLEVEL      22
 
 /**
  * Macro to determine SDL version program was compiled against.
diff --git a/Engine/lib/sdl/include/SDL_video.h b/Engine/lib/sdl/include/SDL_video.h
index e43cb27ec..c62e0891a 100644
--- a/Engine/lib/sdl/include/SDL_video.h
+++ b/Engine/lib/sdl/include/SDL_video.h
@@ -1337,6 +1337,7 @@ extern DECLSPEC void SDLCALL SDL_SetWindowKeyboardGrab(SDL_Window * window,
  * Mouse grab confines the mouse cursor to the window.
  *
  * \param window The window for which the mouse grab mode should be set.
+ * \param grabbed This is SDL_TRUE to grab mouse, and SDL_FALSE to release.
  *
  * \since This function is available since SDL 2.0.16.
  *
diff --git a/Engine/lib/sdl/include/begin_code.h b/Engine/lib/sdl/include/begin_code.h
index 63f064b6f..b1b1a3a9b 100644
--- a/Engine/lib/sdl/include/begin_code.h
+++ b/Engine/lib/sdl/include/begin_code.h
@@ -107,7 +107,7 @@
 #ifdef __BORLANDC__
 #pragma nopackwarning
 #endif
-#ifdef _M_X64
+#ifdef _WIN64
 /* Use 8-byte alignment on 64-bit architectures, so pointers are aligned */
 #pragma pack(push,8)
 #else
diff --git a/Engine/lib/sdl/src/SDL.c b/Engine/lib/sdl/src/SDL.c
index dfc4572f4..68a4f5da2 100644
--- a/Engine/lib/sdl/src/SDL.c
+++ b/Engine/lib/sdl/src/SDL.c
@@ -316,6 +316,8 @@ SDL_InitSubSystem(Uint32 flags)
 #endif
     }
 
+    (void) flags_initialized;  /* make static analysis happy, since this only gets used in error cases. */
+
     return (0);
 
 quit_and_error:
diff --git a/Engine/lib/sdl/src/SDL_hints.c b/Engine/lib/sdl/src/SDL_hints.c
index 2eea5501e..d3fc8ab46 100644
--- a/Engine/lib/sdl/src/SDL_hints.c
+++ b/Engine/lib/sdl/src/SDL_hints.c
@@ -178,6 +178,11 @@ SDL_AddHintCallback(const char *name, SDL_HintCallback callback, void *userdata)
             return;
         }
         hint->name = SDL_strdup(name);
+        if (!hint->name) {
+            SDL_free(hint);
+            SDL_OutOfMemory();
+            return;
+        }
         hint->value = NULL;
         hint->priority = SDL_HINT_DEFAULT;
         hint->callbacks = NULL;
diff --git a/Engine/lib/sdl/src/SDL_list.c b/Engine/lib/sdl/src/SDL_list.c
new file mode 100644
index 000000000..af9f8bf81
--- /dev/null
+++ b/Engine/lib/sdl/src/SDL_list.c
@@ -0,0 +1,93 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "./SDL_internal.h"
+
+#include "SDL.h"
+#include "./SDL_list.h"
+
+/* Push */
+int
+SDL_ListAdd(SDL_ListNode **head, void *ent)
+{
+    SDL_ListNode *node = SDL_malloc(sizeof (*node));
+
+    if (node == NULL) {
+        return SDL_OutOfMemory();
+    }
+
+    node->entry = ent;
+    node->next = *head;
+    *head = node;
+    return 0;
+}
+
+/* Pop from end as a FIFO (if add with SDL_ListAdd) */
+void
+SDL_ListPop(SDL_ListNode **head, void **ent)
+{
+    SDL_ListNode **ptr = head;
+
+    /* Invalid or empty */
+    if (head == NULL || *head == NULL) {
+        return;
+    }
+
+    while ((*ptr)->next) {
+        ptr = &(*ptr)->next;
+    }
+
+    if (ent) {
+       *ent = (*ptr)->entry;
+    }
+
+    SDL_free(*ptr);
+    *ptr = NULL;
+}
+
+void
+SDL_ListRemove(SDL_ListNode **head, void *ent)
+{
+    SDL_ListNode **ptr = head;
+
+    while (*ptr) {
+        if ((*ptr)->entry == ent) {
+            SDL_ListNode *tmp = *ptr;
+            *ptr = (*ptr)->next;
+            SDL_free(tmp);
+            return;
+        }
+        ptr = &(*ptr)->next;
+    }
+}
+
+void
+SDL_ListClear(SDL_ListNode **head)
+{
+    SDL_ListNode *l = *head;
+    *head = NULL;
+    while (l) {
+        SDL_ListNode *tmp = l;
+        l = l->next;
+        SDL_free(tmp);
+    }
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/SDL_list.h b/Engine/lib/sdl/src/SDL_list.h
new file mode 100644
index 000000000..a7ead1dcd
--- /dev/null
+++ b/Engine/lib/sdl/src/SDL_list.h
@@ -0,0 +1,39 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_list_h_
+#define SDL_list_h_
+
+typedef struct SDL_ListNode
+{
+    void *entry;
+    struct SDL_ListNode *next;
+} SDL_ListNode;
+
+
+int SDL_ListAdd(SDL_ListNode **head, void *ent);
+void SDL_ListPop(SDL_ListNode **head, void **ent);
+void SDL_ListRemove(SDL_ListNode **head, void *ent);
+void SDL_ListClear(SDL_ListNode **head);
+
+#endif /* SDL_list_h_ */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/audio/SDL_audio.c b/Engine/lib/sdl/src/audio/SDL_audio.c
index 3a841450c..fb363f771 100644
--- a/Engine/lib/sdl/src/audio/SDL_audio.c
+++ b/Engine/lib/sdl/src/audio/SDL_audio.c
@@ -936,7 +936,7 @@ SDL_AudioInit(const char *driver_name)
 
     /* Select the proper audio driver */
     if (driver_name == NULL) {
-        driver_name = SDL_getenv("SDL_AUDIODRIVER");
+        driver_name = SDL_GetHint(SDL_HINT_AUDIODRIVER);
     }
 
     if (driver_name != NULL && *driver_name != 0) {
diff --git a/Engine/lib/sdl/src/audio/SDL_audiocvt.c b/Engine/lib/sdl/src/audio/SDL_audiocvt.c
index bd49ab008..539900d84 100644
--- a/Engine/lib/sdl/src/audio/SDL_audiocvt.c
+++ b/Engine/lib/sdl/src/audio/SDL_audiocvt.c
@@ -80,7 +80,7 @@ SDL_ConvertStereoToMono_SSE3(SDL_AudioCVT * cvt, SDL_AudioFormat format)
        Just use unaligned load/stores, if the memory at runtime is
        aligned it'll be just as fast on modern processors */
     while (i >= 4) {   /* 4 * float32 */
-        _mm_storeu_ps(dst, _mm_mul_ps(_mm_hadd_ps(_mm_load_ps(src), _mm_loadu_ps(src+4)), divby2));
+        _mm_storeu_ps(dst, _mm_mul_ps(_mm_hadd_ps(_mm_loadu_ps(src), _mm_loadu_ps(src+4)), divby2));
         i -= 4; src += 8; dst += 4;
     }
 
diff --git a/Engine/lib/sdl/src/audio/SDL_wave.c b/Engine/lib/sdl/src/audio/SDL_wave.c
index 07eb10147..e49b55068 100644
--- a/Engine/lib/sdl/src/audio/SDL_wave.c
+++ b/Engine/lib/sdl/src/audio/SDL_wave.c
@@ -685,7 +685,7 @@ MS_ADPCM_Decode(WaveFile *file, Uint8 **audio_buf, Uint32 *audio_len)
 
     state.output.pos = 0;
     state.output.size = outputsize / sizeof(Sint16);
-    state.output.data = (Sint16 *)SDL_malloc(outputsize);
+    state.output.data = (Sint16 *)SDL_calloc(1, outputsize);
     if (state.output.data == NULL) {
         return SDL_OutOfMemory();
     }
diff --git a/Engine/lib/sdl/src/audio/emscripten/SDL_emscriptenaudio.c b/Engine/lib/sdl/src/audio/emscripten/SDL_emscriptenaudio.c
index bc2a0e10d..722f5d0fa 100644
--- a/Engine/lib/sdl/src/audio/emscripten/SDL_emscriptenaudio.c
+++ b/Engine/lib/sdl/src/audio/emscripten/SDL_emscriptenaudio.c
@@ -32,7 +32,7 @@ static void
 FeedAudioDevice(_THIS, const void *buf, const int buflen)
 {
     const int framelen = (SDL_AUDIO_BITSIZE(this->spec.format) / 8) * this->spec.channels;
-    EM_ASM_ARGS({
+    MAIN_THREAD_EM_ASM({
         var SDL2 = Module['SDL2'];
         var numChannels = SDL2.audio.currentOutputBuffer['numberOfChannels'];
         for (var c = 0; c < numChannels; ++c) {
@@ -101,7 +101,7 @@ HandleCaptureProcess(_THIS)
         return;
     }
 
-    EM_ASM_ARGS({
+    MAIN_THREAD_EM_ASM({
         var SDL2 = Module['SDL2'];
         var numChannels = SDL2.capture.currentCaptureBuffer.numberOfChannels;
         for (var c = 0; c < numChannels; ++c) {
@@ -147,7 +147,7 @@ HandleCaptureProcess(_THIS)
 static void
 EMSCRIPTENAUDIO_CloseDevice(_THIS)
 {
-    EM_ASM_({
+    MAIN_THREAD_EM_ASM({
         var SDL2 = Module['SDL2'];
         if ($0) {
             if (SDL2.capture.silenceTimer !== undefined) {
@@ -201,7 +201,7 @@ EMSCRIPTENAUDIO_OpenDevice(_THIS, const char *devname)
     /* based on parts of library_sdl.js */
 
     /* create context */
-    result = EM_ASM_INT({
+    result = MAIN_THREAD_EM_ASM_INT({
         if(typeof(Module['SDL2']) === 'undefined') {
             Module['SDL2'] = {};
         }
@@ -280,7 +280,7 @@ EMSCRIPTENAUDIO_OpenDevice(_THIS, const char *devname)
            feels like it's a pretty inefficient tapdance in similar ways,
            to be honest. */
 
-        EM_ASM_({
+        MAIN_THREAD_EM_ASM({
             var SDL2 = Module['SDL2'];
             var have_microphone = function(stream) {
                 //console.log('SDL audio capture: we have a microphone! Replacing silence callback.');
@@ -323,7 +323,7 @@ EMSCRIPTENAUDIO_OpenDevice(_THIS, const char *devname)
         }, this->spec.channels, this->spec.samples, HandleCaptureProcess, this);
     } else {
         /* setup a ScriptProcessorNode */
-        EM_ASM_ARGS({
+        MAIN_THREAD_EM_ASM({
             var SDL2 = Module['SDL2'];
             SDL2.audio.scriptProcessorNode = SDL2.audioContext['createScriptProcessor']($1, 0, $0);
             SDL2.audio.scriptProcessorNode['onaudioprocess'] = function (e) {
@@ -359,7 +359,7 @@ EMSCRIPTENAUDIO_Init(SDL_AudioDriverImpl * impl)
     impl->ProvidesOwnCallbackThread = SDL_TRUE;
 
     /* check availability */
-    available = EM_ASM_INT_V({
+    available = MAIN_THREAD_EM_ASM_INT({
         if (typeof(AudioContext) !== 'undefined') {
             return true;
         } else if (typeof(webkitAudioContext) !== 'undefined') {
@@ -372,7 +372,7 @@ EMSCRIPTENAUDIO_Init(SDL_AudioDriverImpl * impl)
         SDL_SetError("No audio context available");
     }
 
-    capture_available = available && EM_ASM_INT_V({
+    capture_available = available && MAIN_THREAD_EM_ASM_INT({
         if ((typeof(navigator.mediaDevices) !== 'undefined') && (typeof(navigator.mediaDevices.getUserMedia) !== 'undefined')) {
             return true;
         } else if (typeof(navigator.webkitGetUserMedia) !== 'undefined') {
diff --git a/Engine/lib/sdl/src/audio/vita/SDL_vitaaudio.c b/Engine/lib/sdl/src/audio/vita/SDL_vitaaudio.c
index 524124e80..88f4a3285 100644
--- a/Engine/lib/sdl/src/audio/vita/SDL_vitaaudio.c
+++ b/Engine/lib/sdl/src/audio/vita/SDL_vitaaudio.c
@@ -37,18 +37,35 @@
 
 #include <psp2/kernel/threadmgr.h>
 #include <psp2/audioout.h>
+#include <psp2/audioin.h>
 
 #define SCE_AUDIO_SAMPLE_ALIGN(s)   (((s) + 63) & ~63)
 #define SCE_AUDIO_MAX_VOLUME    0x8000
 
-/* The tag name used by VITA audio */
-#define VITAAUD_DRIVER_NAME     "vita"
+static int
+VITAAUD_OpenCaptureDevice(_THIS)
+{
+    this->spec.freq = 16000;
+    this->spec.samples = 512;
+    this->spec.channels = 1;
+
+    SDL_CalculateAudioSpec(&this->spec);
+
+    this->hidden->port = sceAudioInOpenPort(SCE_AUDIO_IN_PORT_TYPE_VOICE , 512, 16000, SCE_AUDIO_IN_PARAM_FORMAT_S16_MONO);
+
+    if (this->hidden->port < 0) {
+        return SDL_SetError("Couldn't open audio in port: %x", this->hidden->port);
+    }
+
+    return 0;
+}
 
 static int
 VITAAUD_OpenDevice(_THIS, const char *devname)
 {
     int format, mixlen, i, port = SCE_AUDIO_OUT_PORT_TYPE_MAIN;
     int vols[2] = {SCE_AUDIO_MAX_VOLUME, SCE_AUDIO_MAX_VOLUME};
+    SDL_AudioFormat test_format;
 
     this->hidden = (struct SDL_PrivateAudioData *)
         SDL_malloc(sizeof(*this->hidden));
@@ -56,13 +73,20 @@ VITAAUD_OpenDevice(_THIS, const char *devname)
         return SDL_OutOfMemory();
     }
     SDL_memset(this->hidden, 0, sizeof(*this->hidden));
-    switch (this->spec.format & 0xff) {
-        case 8:
-        case 16:
-            this->spec.format = AUDIO_S16LSB;
+
+    for (test_format = SDL_FirstAudioFormat(this->spec.format); test_format; test_format = SDL_NextAudioFormat()) {
+        if (test_format == AUDIO_S16LSB) {
+            this->spec.format = test_format;
             break;
-        default:
-            return SDL_SetError("Unsupported audio format");
+        }
+    }
+
+    if(!test_format) {
+        return SDL_SetError("Unsupported audio format");
+    }
+
+    if (this->iscapture) {
+        return VITAAUD_OpenCaptureDevice(this);
     }
 
     /* The sample count must be a multiple of 64. */
@@ -91,14 +115,14 @@ VITAAUD_OpenDevice(_THIS, const char *devname)
         port = SCE_AUDIO_OUT_PORT_TYPE_BGM;
     }
 
-    this->hidden->channel = sceAudioOutOpenPort(port, this->spec.samples, this->spec.freq, format);
-    if (this->hidden->channel < 0) {
+    this->hidden->port = sceAudioOutOpenPort(port, this->spec.samples, this->spec.freq, format);
+    if (this->hidden->port < 0) {
         free(this->hidden->rawbuf);
         this->hidden->rawbuf = NULL;
-        return SDL_SetError("Couldn't reserve hardware channel");
+        return SDL_SetError("Couldn't open audio out port: %x", this->hidden->port);
     }
 
-    sceAudioOutSetVolume(this->hidden->channel, SCE_AUDIO_VOLUME_FLAG_L_CH|SCE_AUDIO_VOLUME_FLAG_R_CH, vols);
+    sceAudioOutSetVolume(this->hidden->port, SCE_AUDIO_VOLUME_FLAG_L_CH|SCE_AUDIO_VOLUME_FLAG_R_CH, vols);
 
     SDL_memset(this->hidden->rawbuf, 0, mixlen);
     for (i = 0; i < NUM_BUFFERS; i++) {
@@ -113,7 +137,7 @@ static void VITAAUD_PlayDevice(_THIS)
 {
     Uint8 *mixbuf = this->hidden->mixbufs[this->hidden->next_buffer];
 
-    sceAudioOutOutput(this->hidden->channel, mixbuf);
+    sceAudioOutOutput(this->hidden->port, mixbuf);
 
     this->hidden->next_buffer = (this->hidden->next_buffer + 1) % NUM_BUFFERS;
 }
@@ -123,6 +147,7 @@ static void VITAAUD_WaitDevice(_THIS)
 {
     /* Because we block when sending audio, there's no need for this function to do anything. */
 }
+
 static Uint8 *VITAAUD_GetDeviceBuf(_THIS)
 {
     return this->hidden->mixbufs[this->hidden->next_buffer];
@@ -130,17 +155,32 @@ static Uint8 *VITAAUD_GetDeviceBuf(_THIS)
 
 static void VITAAUD_CloseDevice(_THIS)
 {
-    if (this->hidden->channel >= 0) {
-        sceAudioOutReleasePort(this->hidden->channel);
-        this->hidden->channel = -1;
+    if (this->hidden->port >= 0) {
+        if (this->iscapture) {
+            sceAudioInReleasePort(this->hidden->port);
+        } else {
+            sceAudioOutReleasePort(this->hidden->port);
+        }
+        this->hidden->port = -1;
     }
 
-    if (this->hidden->rawbuf != NULL) {
+    if (!this->iscapture && this->hidden->rawbuf != NULL) {
         free(this->hidden->rawbuf);         /* this uses memalign(), not SDL_malloc(). */
         this->hidden->rawbuf = NULL;
     }
 }
 
+static int VITAAUD_CaptureFromDevice(_THIS, void *buffer, int buflen)
+{
+    int ret;
+    SDL_assert(buflen == this->spec.size);
+    ret = sceAudioInInput(this->hidden->port, buffer);
+    if (ret < 0) {
+        return SDL_SetError("Failed to capture from device: %x", ret);
+    }
+    return this->spec.size;
+}
+
 static void VITAAUD_ThreadInit(_THIS)
 {
     /* Increase the priority of this audio thread by 1 to put it
@@ -165,12 +205,13 @@ VITAAUD_Init(SDL_AudioDriverImpl * impl)
     impl->CloseDevice = VITAAUD_CloseDevice;
     impl->ThreadInit = VITAAUD_ThreadInit;
 
-    /* VITA audio device */
-    impl->OnlyHasDefaultOutputDevice = SDL_TRUE;
-    /*
+    impl->CaptureFromDevice = VITAAUD_CaptureFromDevice;
+
+    /* and the capabilities */
     impl->HasCaptureSupport = SDL_TRUE;
-    impl->OnlyHasDefaultInputDevice = SDL_TRUE;
-    */
+    impl->OnlyHasDefaultOutputDevice = SDL_TRUE;
+    impl->OnlyHasDefaultCaptureDevice = SDL_TRUE;
+
     return SDL_TRUE;   /* this audio target is available. */
 }
 
diff --git a/Engine/lib/sdl/src/audio/vita/SDL_vitaaudio.h b/Engine/lib/sdl/src/audio/vita/SDL_vitaaudio.h
index 73870759b..a5601b28c 100644
--- a/Engine/lib/sdl/src/audio/vita/SDL_vitaaudio.h
+++ b/Engine/lib/sdl/src/audio/vita/SDL_vitaaudio.h
@@ -30,8 +30,8 @@
 #define NUM_BUFFERS 2
 
 struct SDL_PrivateAudioData {
-    /* The hardware output channel. */
-    int     channel;
+    /* The hardware input/output port. */
+    int     port;
     /* The raw allocated mixing buffer. */
     Uint8   *rawbuf;
     /* Individual mixing buffers. */
diff --git a/Engine/lib/sdl/src/audio/wasapi/SDL_wasapi.c b/Engine/lib/sdl/src/audio/wasapi/SDL_wasapi.c
index e7d640c12..862ed9f5e 100644
--- a/Engine/lib/sdl/src/audio/wasapi/SDL_wasapi.c
+++ b/Engine/lib/sdl/src/audio/wasapi/SDL_wasapi.c
@@ -558,12 +558,16 @@ WASAPI_PrepDevice(_THIS, const SDL_bool updatestream)
         return WIN_SetErrorFromHRESULT("WASAPI can't determine minimum device period", ret);
     }
 
+#if 1  /* we're getting reports that WASAPI's resampler introduces distortions, so it's disabled for now. --ryan. */
+    this->spec.freq = waveformat->nSamplesPerSec;  /* force sampling rate so our resampler kicks in, if necessary. */
+#else
     /* favor WASAPI's resampler over our own */
     if (this->spec.freq != waveformat->nSamplesPerSec) {
         streamflags |= (AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM | AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY);
         waveformat->nSamplesPerSec = this->spec.freq;
         waveformat->nAvgBytesPerSec = waveformat->nSamplesPerSec * waveformat->nChannels * (waveformat->wBitsPerSample / 8);
     }
+#endif
 
     streamflags |= AUDCLNT_STREAMFLAGS_EVENTCALLBACK;
     ret = IAudioClient_Initialize(client, sharemode, streamflags, 0, 0, waveformat, NULL);
diff --git a/Engine/lib/sdl/src/core/linux/SDL_fcitx.c b/Engine/lib/sdl/src/core/linux/SDL_fcitx.c
index 3f0794736..bab5e88f3 100644
--- a/Engine/lib/sdl/src/core/linux/SDL_fcitx.c
+++ b/Engine/lib/sdl/src/core/linux/SDL_fcitx.c
@@ -339,11 +339,11 @@ SDL_Fcitx_Reset(void)
 }
 
 SDL_bool
-SDL_Fcitx_ProcessKeyEvent(Uint32 keysym, Uint32 keycode)
+SDL_Fcitx_ProcessKeyEvent(Uint32 keysym, Uint32 keycode, Uint8 state)
 {
-    Uint32 state = Fcitx_ModState();
+    Uint32 mod_state = Fcitx_ModState();
     Uint32 handled = SDL_FALSE;
-    Uint32 is_release = SDL_FALSE;
+    Uint32 is_release = (state == SDL_RELEASED);
     Uint32 event_time = 0;
 
     if (!fcitx_client.ic_path) {
@@ -351,7 +351,7 @@ SDL_Fcitx_ProcessKeyEvent(Uint32 keysym, Uint32 keycode)
     }
 
     if (SDL_DBus_CallMethod(FCITX_DBUS_SERVICE, fcitx_client.ic_path, FCITX_IC_DBUS_INTERFACE, "ProcessKeyEvent",
-            DBUS_TYPE_UINT32, &keysym, DBUS_TYPE_UINT32, &keycode, DBUS_TYPE_UINT32, &state, DBUS_TYPE_BOOLEAN, &is_release, DBUS_TYPE_UINT32, &event_time, DBUS_TYPE_INVALID,
+            DBUS_TYPE_UINT32, &keysym, DBUS_TYPE_UINT32, &keycode, DBUS_TYPE_UINT32, &mod_state, DBUS_TYPE_BOOLEAN, &is_release, DBUS_TYPE_UINT32, &event_time, DBUS_TYPE_INVALID,
             DBUS_TYPE_BOOLEAN, &handled, DBUS_TYPE_INVALID)) {
         if (handled) {
             SDL_Fcitx_UpdateTextRect(NULL);
diff --git a/Engine/lib/sdl/src/core/linux/SDL_fcitx.h b/Engine/lib/sdl/src/core/linux/SDL_fcitx.h
index f7884ea43..c3cea523d 100644
--- a/Engine/lib/sdl/src/core/linux/SDL_fcitx.h
+++ b/Engine/lib/sdl/src/core/linux/SDL_fcitx.h
@@ -31,7 +31,7 @@ extern SDL_bool SDL_Fcitx_Init(void);
 extern void SDL_Fcitx_Quit(void);
 extern void SDL_Fcitx_SetFocus(SDL_bool focused);
 extern void SDL_Fcitx_Reset(void);
-extern SDL_bool SDL_Fcitx_ProcessKeyEvent(Uint32 keysym, Uint32 keycode);
+extern SDL_bool SDL_Fcitx_ProcessKeyEvent(Uint32 keysym, Uint32 keycode, Uint8 state);
 extern void SDL_Fcitx_UpdateTextRect(SDL_Rect *rect);
 extern void SDL_Fcitx_PumpEvents(void);
 
diff --git a/Engine/lib/sdl/src/core/linux/SDL_ibus.c b/Engine/lib/sdl/src/core/linux/SDL_ibus.c
index a7bafda35..60af0ba29 100644
--- a/Engine/lib/sdl/src/core/linux/SDL_ibus.c
+++ b/Engine/lib/sdl/src/core/linux/SDL_ibus.c
@@ -503,15 +503,20 @@ SDL_IBus_Reset(void)
 }
 
 SDL_bool
-SDL_IBus_ProcessKeyEvent(Uint32 keysym, Uint32 keycode)
+SDL_IBus_ProcessKeyEvent(Uint32 keysym, Uint32 keycode, Uint8 state)
 { 
     Uint32 result = 0;
     SDL_DBusContext *dbus = SDL_DBus_GetContext();
-    
+
+
     if (IBus_CheckConnection(dbus)) {
         Uint32 mods = IBus_ModState();
+        Uint32 ibus_keycode = keycode - 8;
+        if (state == SDL_RELEASED) {
+            mods |= (1 << 30); // IBUS_RELEASE_MASK
+        }
         if (!SDL_DBus_CallMethodOnConnection(ibus_conn, IBUS_SERVICE, input_ctx_path, IBUS_INPUT_INTERFACE, "ProcessKeyEvent",
-                DBUS_TYPE_UINT32, &keysym, DBUS_TYPE_UINT32, &keycode, DBUS_TYPE_UINT32, &mods, DBUS_TYPE_INVALID,
+                DBUS_TYPE_UINT32, &keysym, DBUS_TYPE_UINT32, &ibus_keycode, DBUS_TYPE_UINT32, &mods, DBUS_TYPE_INVALID,
                 DBUS_TYPE_BOOLEAN, &result, DBUS_TYPE_INVALID)) {
             result = 0;
         }
diff --git a/Engine/lib/sdl/src/core/linux/SDL_ibus.h b/Engine/lib/sdl/src/core/linux/SDL_ibus.h
index 73a9f1b8b..71d1f2d30 100644
--- a/Engine/lib/sdl/src/core/linux/SDL_ibus.h
+++ b/Engine/lib/sdl/src/core/linux/SDL_ibus.h
@@ -41,7 +41,7 @@ extern void SDL_IBus_Reset(void);
 /* Sends a keypress event to IBus, returns SDL_TRUE if IBus used this event to
    update its candidate list or change input methods. PumpEvents should be
    called some time after this, to recieve the TextInput / TextEditing event back. */
-extern SDL_bool SDL_IBus_ProcessKeyEvent(Uint32 keysym, Uint32 keycode);
+extern SDL_bool SDL_IBus_ProcessKeyEvent(Uint32 keysym, Uint32 keycode, Uint8 state);
 
 /* Update the position of IBus' candidate list. If rect is NULL then this will 
    just reposition it relative to the focused window's new position. */
diff --git a/Engine/lib/sdl/src/core/linux/SDL_ime.c b/Engine/lib/sdl/src/core/linux/SDL_ime.c
index 84c461f8b..9c0cb80f0 100644
--- a/Engine/lib/sdl/src/core/linux/SDL_ime.c
+++ b/Engine/lib/sdl/src/core/linux/SDL_ime.c
@@ -27,7 +27,7 @@ typedef SDL_bool (*_SDL_IME_Init)(void);
 typedef void (*_SDL_IME_Quit)(void);
 typedef void (*_SDL_IME_SetFocus)(SDL_bool);
 typedef void (*_SDL_IME_Reset)(void);
-typedef SDL_bool (*_SDL_IME_ProcessKeyEvent)(Uint32, Uint32);
+typedef SDL_bool (*_SDL_IME_ProcessKeyEvent)(Uint32, Uint32, Uint8 state);
 typedef void (*_SDL_IME_UpdateTextRect)(SDL_Rect *);
 typedef void (*_SDL_IME_PumpEvents)(void);
 
@@ -127,10 +127,10 @@ SDL_IME_Reset(void)
 }
 
 SDL_bool
-SDL_IME_ProcessKeyEvent(Uint32 keysym, Uint32 keycode)
+SDL_IME_ProcessKeyEvent(Uint32 keysym, Uint32 keycode, Uint8 state)
 {
     if (SDL_IME_ProcessKeyEvent_Real)
-        return SDL_IME_ProcessKeyEvent_Real(keysym, keycode);
+        return SDL_IME_ProcessKeyEvent_Real(keysym, keycode, state);
 
     return SDL_FALSE;
 }
diff --git a/Engine/lib/sdl/src/core/linux/SDL_ime.h b/Engine/lib/sdl/src/core/linux/SDL_ime.h
index a28a4b430..cc5b105f0 100644
--- a/Engine/lib/sdl/src/core/linux/SDL_ime.h
+++ b/Engine/lib/sdl/src/core/linux/SDL_ime.h
@@ -31,7 +31,7 @@ extern SDL_bool SDL_IME_Init(void);
 extern void SDL_IME_Quit(void);
 extern void SDL_IME_SetFocus(SDL_bool focused);
 extern void SDL_IME_Reset(void);
-extern SDL_bool SDL_IME_ProcessKeyEvent(Uint32 keysym, Uint32 keycode);
+extern SDL_bool SDL_IME_ProcessKeyEvent(Uint32 keysym, Uint32 keycode, Uint8 state);
 extern void SDL_IME_UpdateTextRect(SDL_Rect *rect);
 extern void SDL_IME_PumpEvents(void);
 
diff --git a/Engine/lib/sdl/src/core/windows/SDL_windows.c b/Engine/lib/sdl/src/core/windows/SDL_windows.c
index fcbf8e847..50e128fcc 100644
--- a/Engine/lib/sdl/src/core/windows/SDL_windows.c
+++ b/Engine/lib/sdl/src/core/windows/SDL_windows.c
@@ -25,7 +25,15 @@
 #include "SDL_windows.h"
 #include "SDL_error.h"
 
-#include <objbase.h>  /* for CoInitialize/CoUninitialize (Win32 only) */
+#include <objbase.h>    /* for CoInitialize/CoUninitialize (Win32 only) */
+#if defined(HAVE_ROAPI_H)
+#include <roapi.h>      /* For RoInitialize/RoUninitialize (Win32 only) */
+#else
+typedef enum RO_INIT_TYPE {
+  RO_INIT_SINGLETHREADED = 0,
+  RO_INIT_MULTITHREADED  = 1
+} RO_INIT_TYPE;
+#endif
 
 #ifndef _WIN32_WINNT_VISTA
 #define _WIN32_WINNT_VISTA  0x0600
@@ -37,6 +45,10 @@
 #define _WIN32_WINNT_WIN8   0x0602
 #endif
 
+#ifndef LOAD_LIBRARY_SEARCH_SYSTEM32
+#define LOAD_LIBRARY_SEARCH_SYSTEM32 0x00000800
+#endif
+
 
 /* Sets an error message based on an HRESULT */
 int
@@ -104,51 +116,66 @@ void
 WIN_CoUninitialize(void)
 {
 #ifndef __WINRT__
-    /* Don't uninitialize COM because of what appears to be a bug in Microsoft WGI reference counting.
-     *
-     * If you plug in a non-Xbox controller and let the application run for 30 seconds, then it crashes in CoUninitialize()
-     * with this stack trace:
+    CoUninitialize();
+#endif
+}
 
-        Windows.Gaming.Input.dll!GameController::~GameController(void)	Unknown
-        Windows.Gaming.Input.dll!GameController::`vector deleting destructor'(unsigned int)	Unknown
-        Windows.Gaming.Input.dll!Microsoft::WRL::Details::RuntimeClassImpl<struct Microsoft::WRL::RuntimeClassFlags<1>,1,1,0,struct Windows::Gaming::Input::IGameController,struct Windows::Gaming::Input::IGameControllerBatteryInfo,struct Microsoft::WRL::CloakedIid<struct Windows::Gaming::Input::Internal::IGameControllerPrivate>,class Microsoft::WRL::FtmBase>::Release(void)	Unknown
-        Windows.Gaming.Input.dll!Windows::Gaming::Input::Custom::Details::AggregableRuntimeClass<struct Windows::Gaming::Input::IGamepad,struct Windows::Gaming::Input::IGamepad2,struct Microsoft::WRL::CloakedIid<struct Windows::Gaming::Input::Custom::IGameControllerInputSink>,struct Microsoft::WRL::CloakedIid<struct Windows::Gaming::Input::Custom::IGipGameControllerInputSink>,struct Microsoft::WRL::CloakedIid<struct Windows::Gaming::Input::Custom::IHidGameControllerInputSink>,struct Microsoft::WRL::CloakedIid<struct Windows::Gaming::Input::Custom::IXusbGameControllerInputSink>,class Microsoft::WRL::Details::Nil,class Microsoft::WRL::Details::Nil,class Microsoft::WRL::Details::Nil>::Release(void)	Unknown
-        Windows.Gaming.Input.dll!Microsoft::WRL::ComPtr<`WaitForCompletion<Windows::Foundation::IAsyncOperationWithProgressCompletedHandler<Windows::Storage::Streams::IBuffer *,unsigned int>,Windows::Foundation::IAsyncOperationWithProgress<Windows::Storage::Streams::IBuffer *,unsigned int>>'::`2'::FTMEventDelegate>::~ComPtr<`WaitForCompletion<Windows::Foundation::IAsyncOperationWithProgressCompletedHandler<Windows::Storage::Streams::IBuffer *,unsigned int>,Windows::Foundation::IAsyncOperationWithProgress<Windows::Storage::Streams::IBuffer *,unsigned int>>'::`2'::FTMEventDelegate>()	Unknown
-        Windows.Gaming.Input.dll!`eh vector destructor iterator'(void *,unsigned int,int,void (*)(void *))	Unknown
-        Windows.Gaming.Input.dll!Windows::Gaming::Input::Custom::Details::GameControllerCollection<class Windows::Gaming::Input::RawGameController,struct Windows::Gaming::Input::IRawGameController>::~GameControllerCollection<class Windows::Gaming::Input::RawGameController,struct Windows::Gaming::Input::IRawGameController>(void)	Unknown
-        Windows.Gaming.Input.dll!Windows::Gaming::Input::Custom::Details::GameControllerCollection<class Windows::Gaming::Input::RawGameController,struct Windows::Gaming::Input::IRawGameController>::`vector deleting destructor'(unsigned int)	Unknown
-        Windows.Gaming.Input.dll!Microsoft::WRL::Details::RuntimeClassImpl<struct Microsoft::WRL::RuntimeClassFlags<1>,1,1,0,struct Windows::Foundation::Collections::IIterable<class Windows::Gaming::Input::ArcadeStick *>,struct Windows::Foundation::Collections::IVectorView<class Windows::Gaming::Input::ArcadeStick *>,class Microsoft::WRL::FtmBase>::Release(void)	Unknown
-        Windows.Gaming.Input.dll!Windows::Gaming::Input::Custom::Details::CustomGameControllerFactoryBase<class Windows::Gaming::Input::FlightStick,class Windows::Gaming::Input::FlightStick,struct Windows::Gaming::Input::IFlightStick,struct Windows::Gaming::Input::IFlightStickStatics,class Microsoft::WRL::Details::Nil>::~CustomGameControllerFactoryBase<class Windows::Gaming::Input::FlightStick,class Windows::Gaming::Input::FlightStick,struct Windows::Gaming::Input::IFlightStick,struct Windows::Gaming::Input::IFlightStickStatics,class Microsoft::WRL::Details::Nil>(void)	Unknown
-        Windows.Gaming.Input.dll!Windows::Gaming::Input::Custom::Details::CustomGameControllerFactoryBase<class Windows::Gaming::Input::FlightStick,class Windows::Gaming::Input::FlightStick,struct Windows::Gaming::Input::IFlightStick,struct Windows::Gaming::Input::IFlightStickStatics,class Microsoft::WRL::Details::Nil>::`vector deleting destructor'(unsigned int)	Unknown
-        Windows.Gaming.Input.dll!Microsoft::WRL::ActivationFactory<struct Microsoft::WRL::Implements<class Microsoft::WRL::FtmBase,struct Microsoft::WRL::CloakedIid<struct Windows::Gaming::Input::Custom::ICustomGameControllerFactory> >,struct Windows::Gaming::Input::IFlightStickStatics,class Microsoft::WRL::Details::Nil,0>::Release(void)	Unknown
-        Windows.Gaming.Input.dll!Microsoft::WRL::ComPtr<`WaitForCompletion<Windows::Foundation::IAsyncOperationWithProgressCompletedHandler<Windows::Storage::Streams::IBuffer *,unsigned int>,Windows::Foundation::IAsyncOperationWithProgress<Windows::Storage::Streams::IBuffer *,unsigned int>>'::`2'::FTMEventDelegate>::~ComPtr<`WaitForCompletion<Windows::Foundation::IAsyncOperationWithProgressCompletedHandler<Windows::Storage::Streams::IBuffer *,unsigned int>,Windows::Foundation::IAsyncOperationWithProgress<Windows::Storage::Streams::IBuffer *,unsigned int>>'::`2'::FTMEventDelegate>()	Unknown
-        Windows.Gaming.Input.dll!NtList<struct FactoryManager::FactoryListEntry>::~NtList<struct FactoryManager::FactoryListEntry>(void)	Unknown
-        Windows.Gaming.Input.dll!FactoryManager::`vector deleting destructor'(unsigned int)	Unknown
-        Windows.Gaming.Input.dll!Microsoft::WRL::ActivationFactory<struct Microsoft::WRL::Implements<class Microsoft::WRL::FtmBase,struct Windows::Gaming::Input::Custom::IGameControllerFactoryManagerStatics>,struct Windows::Gaming::Input::Custom::IGameControllerFactoryManagerStatics2,struct Microsoft::WRL::CloakedIid<struct Windows::Gaming::Input::Internal::IGameControllerFactoryManagerStaticsPrivate>,0>::Release(void)	Unknown
-        Windows.Gaming.Input.dll!Microsoft::WRL::Details::TerminateMap(class Microsoft::WRL::Details::ModuleBase *,unsigned short const *,bool)	Unknown
-        Windows.Gaming.Input.dll!Microsoft::WRL::Module<1,class Microsoft::WRL::Details::DefaultModule<1> >::~Module<1,class Microsoft::WRL::Details::DefaultModule<1> >(void)	Unknown
-        Windows.Gaming.Input.dll!Microsoft::WRL::Details::DefaultModule<1>::`vector deleting destructor'(unsigned int)	Unknown
-        Windows.Gaming.Input.dll!`dynamic atexit destructor for 'Microsoft::WRL::Details::StaticStorage<Microsoft::WRL::Details::DefaultModule<1>,0,int>::instance_''()	Unknown
-        Windows.Gaming.Input.dll!__CRT_INIT@12()	Unknown
-        Windows.Gaming.Input.dll!__DllMainCRTStartup()	Unknown
-        ntdll.dll!_LdrxCallInitRoutine@16()	Unknown
-        ntdll.dll!LdrpCallInitRoutine()	Unknown
-        ntdll.dll!LdrpProcessDetachNode()	Unknown
-        ntdll.dll!LdrpUnloadNode()	Unknown
-        ntdll.dll!LdrpDecrementModuleLoadCountEx()	Unknown
-        ntdll.dll!LdrUnloadDll()	Unknown
-        KernelBase.dll!FreeLibrary()	Unknown
-        combase.dll!FreeLibraryWithLogging(LoadOrFreeWhy why, HINSTANCE__ * hMod, const wchar_t * pswzOptionalFileName) Line 193	C++
-        combase.dll!CClassCache::CDllPathEntry::CFinishObject::Finish() Line 3311	C++
-        combase.dll!CClassCache::CFinishComposite::Finish() Line 3421	C++
-        combase.dll!CClassCache::CleanUpDllsForProcess() Line 7009	C++
-        [Inline Frame] combase.dll!CCCleanUpDllsForProcess() Line 8773	C++
-        combase.dll!ProcessUninitialize() Line 2243	C++
-        combase.dll!DecrementProcessInitializeCount() Line 993	C++
-        combase.dll!wCoUninitialize(COleTls & Tls, int fHostThread) Line 4126	C++
-        combase.dll!CoUninitialize() Line 3945	C++
-    */
-    /*CoUninitialize();*/
+#ifndef __WINRT__
+void *
+WIN_LoadComBaseFunction(const char *name)
+{
+    static SDL_bool s_bLoaded;
+    static HMODULE s_hComBase;
+   
+    if (!s_bLoaded) {
+       s_hComBase = LoadLibraryEx(TEXT("combase.dll"), NULL, LOAD_LIBRARY_SEARCH_SYSTEM32);
+       s_bLoaded = SDL_TRUE;
+    }
+    if (s_hComBase) {
+        return GetProcAddress(s_hComBase, name);
+    } else {
+        return NULL;
+    }
+}
+#endif
+
+HRESULT
+WIN_RoInitialize(void)
+{
+#ifdef __WINRT__
+    return S_OK;
+#else
+    typedef HRESULT (WINAPI *RoInitialize_t)(RO_INIT_TYPE initType);
+    RoInitialize_t RoInitializeFunc = (RoInitialize_t)WIN_LoadComBaseFunction("RoInitialize");
+    if (RoInitializeFunc) {
+        /* RO_INIT_SINGLETHREADED is equivalent to COINIT_APARTMENTTHREADED */
+        HRESULT hr = RoInitializeFunc(RO_INIT_SINGLETHREADED);
+        if (hr == RPC_E_CHANGED_MODE) {
+            hr = RoInitializeFunc(RO_INIT_MULTITHREADED);
+        }
+
+        /* S_FALSE means success, but someone else already initialized. */
+        /* You still need to call RoUninitialize in this case! */
+        if (hr == S_FALSE) {
+            return S_OK;
+        }
+
+        return hr;
+    } else {
+        return E_NOINTERFACE;
+    }
+#endif
+}
+
+void
+WIN_RoUninitialize(void)
+{
+#ifndef __WINRT__
+    typedef void (WINAPI *RoUninitialize_t)(void);
+    RoUninitialize_t RoUninitializeFunc = (RoUninitialize_t)WIN_LoadComBaseFunction("RoUninitialize");
+    if (RoUninitializeFunc) {
+        RoUninitializeFunc();
+    }
 #endif
 }
 
diff --git a/Engine/lib/sdl/src/core/windows/SDL_windows.h b/Engine/lib/sdl/src/core/windows/SDL_windows.h
index 221c3bd87..917a8256f 100644
--- a/Engine/lib/sdl/src/core/windows/SDL_windows.h
+++ b/Engine/lib/sdl/src/core/windows/SDL_windows.h
@@ -63,10 +63,19 @@ extern int WIN_SetErrorFromHRESULT(const char *prefix, HRESULT hr);
 /* Sets an error message based on GetLastError(). Always return -1. */
 extern int WIN_SetError(const char *prefix);
 
+#if !defined(__WINRT__)
+/* Load a function from combase.dll */
+void *WIN_LoadComBaseFunction(const char *name);
+#endif
+
 /* Wrap up the oddities of CoInitialize() into a common function. */
 extern HRESULT WIN_CoInitialize(void);
 extern void WIN_CoUninitialize(void);
 
+/* Wrap up the oddities of RoInitialize() into a common function. */
+extern HRESULT WIN_RoInitialize(void);
+extern void WIN_RoUninitialize(void);
+
 /* Returns SDL_TRUE if we're running on Windows Vista and newer */
 extern BOOL WIN_IsWindowsVistaOrGreater(void);
 
diff --git a/Engine/lib/sdl/src/dynapi/SDL_dynapi_overrides.h b/Engine/lib/sdl/src/dynapi/SDL_dynapi_overrides.h
index 299dde303..526513ad5 100644
--- a/Engine/lib/sdl/src/dynapi/SDL_dynapi_overrides.h
+++ b/Engine/lib/sdl/src/dynapi/SDL_dynapi_overrides.h
@@ -864,3 +864,4 @@
 #define SDL_UnionFRect SDL_UnionFRect_REAL
 #define SDL_EncloseFPoints SDL_EncloseFPoints_REAL
 #define SDL_IntersectFRectAndLine SDL_IntersectFRectAndLine_REAL
+#define SDL_RenderGetWindow SDL_RenderGetWindow_REAL
diff --git a/Engine/lib/sdl/src/dynapi/SDL_dynapi_procs.h b/Engine/lib/sdl/src/dynapi/SDL_dynapi_procs.h
index 2c0d5b03e..22bf870d9 100644
--- a/Engine/lib/sdl/src/dynapi/SDL_dynapi_procs.h
+++ b/Engine/lib/sdl/src/dynapi/SDL_dynapi_procs.h
@@ -935,3 +935,4 @@ SDL_DYNAPI_PROC(SDL_bool,SDL_IntersectFRect,(const SDL_FRect *a, const SDL_FRect
 SDL_DYNAPI_PROC(void,SDL_UnionFRect,(const SDL_FRect *a, const SDL_FRect *b, SDL_FRect *c),(a,b,c),)
 SDL_DYNAPI_PROC(SDL_bool,SDL_EncloseFPoints,(const SDL_FPoint *a, int b, const SDL_FRect *c, SDL_FRect *d),(a,b,c,d),return)
 SDL_DYNAPI_PROC(SDL_bool,SDL_IntersectFRectAndLine,(const SDL_FRect *a, float *b, float *c, float *d, float *e),(a,b,c,d,e),return)
+SDL_DYNAPI_PROC(SDL_Window*,SDL_RenderGetWindow,(SDL_Renderer *a),(a),return)
diff --git a/Engine/lib/sdl/src/events/SDL_keyboard.c b/Engine/lib/sdl/src/events/SDL_keyboard.c
index cd150fab6..14e79ca49 100644
--- a/Engine/lib/sdl/src/events/SDL_keyboard.c
+++ b/Engine/lib/sdl/src/events/SDL_keyboard.c
@@ -638,6 +638,7 @@ SDL_SetKeyboardFocus(SDL_Window * window)
         /* old window must lose an existing mouse capture. */
         if (keyboard->focus->flags & SDL_WINDOW_MOUSE_CAPTURE) {
             SDL_CaptureMouse(SDL_FALSE);  /* drop the capture. */
+            SDL_UpdateMouseCapture(SDL_TRUE);
             SDL_assert(!(keyboard->focus->flags & SDL_WINDOW_MOUSE_CAPTURE));
         }
 
diff --git a/Engine/lib/sdl/src/events/SDL_mouse.c b/Engine/lib/sdl/src/events/SDL_mouse.c
index 2e88ee714..254182cc5 100644
--- a/Engine/lib/sdl/src/events/SDL_mouse.c
+++ b/Engine/lib/sdl/src/events/SDL_mouse.c
@@ -109,6 +109,28 @@ SDL_TouchMouseEventsChanged(void *userdata, const char *name, const char *oldVal
     mouse->touch_mouse_events = SDL_GetStringBoolean(hint, SDL_TRUE);
 }
 
+#if defined(__vita__)
+static void SDLCALL
+SDL_VitaTouchMouseDeviceChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
+{
+    SDL_Mouse *mouse = (SDL_Mouse *)userdata;
+    if (hint) {
+        switch(*hint) {
+        default:
+        case '0':
+            mouse->vita_touch_mouse_device = 0;
+            break;
+        case '1':
+            mouse->vita_touch_mouse_device = 1;
+            break;
+        case '2':
+            mouse->vita_touch_mouse_device = 2;
+            break;
+        }
+    }
+}
+#endif
+
 static void SDLCALL
 SDL_MouseTouchEventsChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
 {
@@ -134,12 +156,8 @@ SDL_MouseAutoCaptureChanged(void *userdata, const char *name, const char *oldVal
     SDL_bool auto_capture = SDL_GetStringBoolean(hint, SDL_TRUE);
 
     if (auto_capture != mouse->auto_capture) {
-        /* Turn off mouse capture if it's currently active because of button presses */
-        if (!auto_capture && SDL_GetMouseState(NULL, NULL) != 0) {
-            SDL_CaptureMouse(SDL_FALSE);
-        }
-
         mouse->auto_capture = auto_capture;
+        SDL_UpdateMouseCapture(SDL_FALSE);
     }
 }
 
@@ -166,6 +184,11 @@ SDL_MouseInit(void)
     SDL_AddHintCallback(SDL_HINT_TOUCH_MOUSE_EVENTS,
                         SDL_TouchMouseEventsChanged, mouse);
 
+#if defined(__vita__)
+    SDL_AddHintCallback(SDL_HINT_VITA_TOUCH_MOUSE_DEVICE,
+                        SDL_VitaTouchMouseDeviceChanged, mouse);
+#endif
+
     SDL_AddHintCallback(SDL_HINT_MOUSE_TOUCH_EVENTS,
                         SDL_MouseTouchEventsChanged, mouse);
 
@@ -384,12 +407,9 @@ SDL_PrivateSendMouseMotion(SDL_Window * window, SDL_MouseID mouseID, int relativ
 
     /* Ignore relative motion when first positioning the mouse */
     if (!mouse->has_position) {
-        xrel = 0;
-        yrel = 0;
         mouse->x = x;
         mouse->y = y;
         mouse->has_position = SDL_TRUE;
-        return 0;
     } else if (!xrel && !yrel) {  /* Drop events that don't change state */
 #ifdef DEBUG_MOUSE
         SDL_Log("Mouse event didn't change state - dropped!\n");
@@ -540,7 +560,6 @@ SDL_PrivateSendMouseButton(SDL_Window * window, SDL_MouseID mouseID, Uint8 state
     Uint32 type;
     Uint32 buttonstate;
     SDL_MouseInputSource *source;
-    SDL_bool had_buttons_pressed = (SDL_GetMouseState(NULL, NULL) ? SDL_TRUE : SDL_FALSE);
 
     source = GetMouseInputSource(mouse, mouseID);
     if (!source) {
@@ -643,10 +662,7 @@ SDL_PrivateSendMouseButton(SDL_Window * window, SDL_MouseID mouseID, Uint8 state
 
     /* Automatically capture the mouse while buttons are pressed */
     if (mouse->auto_capture) {
-        SDL_bool has_buttons_pressed = (SDL_GetMouseState(NULL, NULL) ? SDL_TRUE : SDL_FALSE);
-        if (has_buttons_pressed != had_buttons_pressed) {
-            SDL_CaptureMouse(has_buttons_pressed);
-        }
+        SDL_UpdateMouseCapture(SDL_FALSE);
     }
 
     return posted;
@@ -743,6 +759,7 @@ SDL_MouseQuit(void)
 
     if (mouse->CaptureMouse) {
         SDL_CaptureMouse(SDL_FALSE);
+        SDL_UpdateMouseCapture(SDL_TRUE);
     }
     SDL_SetRelativeMouseMode(SDL_FALSE);
     SDL_ShowCursor(1);
@@ -947,6 +964,8 @@ SDL_SetRelativeMouseMode(SDL_bool enabled)
         if (!enabled) {
             SDL_WarpMouseInWindow(focusWindow, mouse->x, mouse->y);
         }
+
+        SDL_UpdateMouseCapture(SDL_FALSE);
     }
 
     if (!enabled) {
@@ -968,39 +987,59 @@ SDL_GetRelativeMouseMode()
     return mouse->relative_mode;
 }
 
+int
+SDL_UpdateMouseCapture(SDL_bool force_release)
+{
+    SDL_Mouse *mouse = SDL_GetMouse();
+    SDL_Window *capture_window = NULL;
+
+    if (!mouse->CaptureMouse) {
+        return 0;
+    }
+
+    if (!force_release) {
+        if (mouse->capture_desired || (mouse->auto_capture && SDL_GetMouseState(NULL, NULL) != 0)) {
+            if (!mouse->relative_mode) {
+                capture_window = SDL_GetKeyboardFocus();
+            }
+        }
+    }
+
+    if (capture_window != mouse->capture_window) {
+        if (mouse->capture_window) {
+            mouse->CaptureMouse(NULL);
+            mouse->capture_window->flags &= ~SDL_WINDOW_MOUSE_CAPTURE;
+            mouse->capture_window = NULL;
+        }
+
+        if (capture_window) {
+            if (mouse->CaptureMouse(capture_window) < 0) {
+                /* CaptureMouse() will have set an error */
+                return -1;
+            }
+            capture_window->flags |= SDL_WINDOW_MOUSE_CAPTURE;
+        }
+
+        mouse->capture_window = capture_window;
+    }
+    return 0;
+}
+
 int
 SDL_CaptureMouse(SDL_bool enabled)
 {
     SDL_Mouse *mouse = SDL_GetMouse();
-    SDL_Window *focusWindow;
-    SDL_bool isCaptured;
 
     if (!mouse->CaptureMouse) {
         return SDL_Unsupported();
     }
 
-    focusWindow = SDL_GetKeyboardFocus();
-
-    isCaptured = focusWindow && (focusWindow->flags & SDL_WINDOW_MOUSE_CAPTURE);
-    if (isCaptured == enabled) {
-        return 0;  /* already done! */
+    if (enabled && SDL_GetKeyboardFocus() == NULL) {
+        return SDL_SetError("No window has focus");
     }
+    mouse->capture_desired = enabled;
 
-    if (enabled) {
-        if (!focusWindow) {
-            return SDL_SetError("No window has focus");
-        } else if (mouse->CaptureMouse(focusWindow) == -1) {
-            return -1;  /* CaptureMouse() should call SetError */
-        }
-        focusWindow->flags |= SDL_WINDOW_MOUSE_CAPTURE;
-    } else {
-        if (mouse->CaptureMouse(NULL) == -1) {
-            return -1;  /* CaptureMouse() should call SetError */
-        }
-        focusWindow->flags &= ~SDL_WINDOW_MOUSE_CAPTURE;
-    }
-
-    return 0;
+    return SDL_UpdateMouseCapture(SDL_FALSE);
 }
 
 SDL_Cursor *
diff --git a/Engine/lib/sdl/src/events/SDL_mouse_c.h b/Engine/lib/sdl/src/events/SDL_mouse_c.h
index 7b020447a..f06934b6f 100644
--- a/Engine/lib/sdl/src/events/SDL_mouse_c.h
+++ b/Engine/lib/sdl/src/events/SDL_mouse_c.h
@@ -100,7 +100,12 @@ typedef struct
     SDL_bool touch_mouse_events;
     SDL_bool mouse_touch_events;
     SDL_bool was_touch_mouse_events; /* Was a touch-mouse event pending? */
+#if defined(__vita__)
+    Uint8 vita_touch_mouse_device;
+#endif
     SDL_bool auto_capture;
+    SDL_bool capture_desired;
+    SDL_Window *capture_window;
 
     /* Data for input source state */
     int num_sources;
@@ -132,6 +137,9 @@ extern void SDL_SetDefaultCursor(SDL_Cursor * cursor);
 /* Set the mouse focus window */
 extern void SDL_SetMouseFocus(SDL_Window * window);
 
+/* Update the mouse capture window */
+extern int SDL_UpdateMouseCapture(SDL_bool force_release);
+
 /* Send a mouse motion event */
 extern int SDL_SendMouseMotion(SDL_Window * window, SDL_MouseID mouseID, int relative, int x, int y);
 
diff --git a/Engine/lib/sdl/src/events/SDL_touch.c b/Engine/lib/sdl/src/events/SDL_touch.c
index c3534f00e..ebf26e091 100644
--- a/Engine/lib/sdl/src/events/SDL_touch.c
+++ b/Engine/lib/sdl/src/events/SDL_touch.c
@@ -265,8 +265,13 @@ SDL_SendTouch(SDL_TouchID id, SDL_FingerID fingerid, SDL_Window * window,
 
 #if SYNTHESIZE_TOUCH_TO_MOUSE
     /* SDL_HINT_TOUCH_MOUSE_EVENTS: controlling whether touch events should generate synthetic mouse events */
+    /* SDL_HINT_VITA_TOUCH_MOUSE_DEVICE: controlling which touchpad should generate synthetic mouse events, PSVita-only */
     {
+#if defined(__vita__)
+        if (mouse->touch_mouse_events && ((mouse->vita_touch_mouse_device == id) || (mouse->vita_touch_mouse_device == 2)) ) {
+#else
         if (mouse->touch_mouse_events) {
+#endif
             /* FIXME: maybe we should only restrict to a few SDL_TouchDeviceType */
             if (id != SDL_MOUSE_TOUCHID) {
                 if (window) {
diff --git a/Engine/lib/sdl/src/filesystem/windows/SDL_sysfilesystem.c b/Engine/lib/sdl/src/filesystem/windows/SDL_sysfilesystem.c
index d50fb511b..b57546c67 100644
--- a/Engine/lib/sdl/src/filesystem/windows/SDL_sysfilesystem.c
+++ b/Engine/lib/sdl/src/filesystem/windows/SDL_sysfilesystem.c
@@ -35,39 +35,23 @@
 char *
 SDL_GetBasePath(void)
 {
-    typedef DWORD (WINAPI *GetModuleFileNameExW_t)(HANDLE, HMODULE, LPWSTR, DWORD);
-    GetModuleFileNameExW_t pGetModuleFileNameExW;
     DWORD buflen = 128;
     WCHAR *path = NULL;
-    HANDLE psapi = LoadLibrary(TEXT("psapi.dll"));
     char *retval = NULL;
     DWORD len = 0;
     int i;
 
-    if (!psapi) {
-        WIN_SetError("Couldn't load psapi.dll");
-        return NULL;
-    }
-
-    pGetModuleFileNameExW = (GetModuleFileNameExW_t)GetProcAddress(psapi, "GetModuleFileNameExW");
-    if (!pGetModuleFileNameExW) {
-        WIN_SetError("Couldn't find GetModuleFileNameExW");
-        FreeLibrary(psapi);
-        return NULL;
-    }
-
     while (SDL_TRUE) {
         void *ptr = SDL_realloc(path, buflen * sizeof (WCHAR));
         if (!ptr) {
             SDL_free(path);
-            FreeLibrary(psapi);
             SDL_OutOfMemory();
             return NULL;
         }
 
         path = (WCHAR *) ptr;
 
-        len = pGetModuleFileNameExW(GetCurrentProcess(), NULL, path, buflen);
+        len = GetModuleFileNameW(NULL, path, buflen);
         /* if it truncated, then len >= buflen - 1 */
         /* if there was enough room (or failure), len < buflen - 1 */
         if (len < buflen - 1) {
@@ -78,8 +62,6 @@ SDL_GetBasePath(void)
         buflen *= 2;
     }
 
-    FreeLibrary(psapi);
-
     if (len == 0) {
         SDL_free(path);
         WIN_SetError("Couldn't locate our .exe");
diff --git a/Engine/lib/sdl/src/hidapi/SDL_hidapi.c b/Engine/lib/sdl/src/hidapi/SDL_hidapi.c
index aacff63bf..369b616f5 100644
--- a/Engine/lib/sdl/src/hidapi/SDL_hidapi.c
+++ b/Engine/lib/sdl/src/hidapi/SDL_hidapi.c
@@ -951,6 +951,7 @@ DeleteHIDDeviceWrapper(SDL_hid_device *device)
     }
 
 #if !SDL_HIDAPI_DISABLED
+#if HAVE_PLATFORM_BACKEND || HAVE_DRIVER_BACKEND || defined(SDL_LIBUSB_DYNAMIC)
 
 #define COPY_IF_EXISTS(var) \
     if (pSrc->var != NULL) { \
@@ -987,6 +988,7 @@ CopyHIDDeviceInfo(struct SDL_hid_device_info *pSrc, struct SDL_hid_device_info *
 #undef COPY_IF_EXISTS
 #undef WCOPY_IF_EXISTS
 
+#endif /* HAVE_PLATFORM_BACKEND || HAVE_DRIVER_BACKEND || SDL_LIBUSB_DYNAMIC */
 #endif /* !SDL_HIDAPI_DISABLED */
 
 static int SDL_hidapi_refcount = 0;
@@ -1185,9 +1187,9 @@ struct SDL_hid_device_info *SDL_hid_enumerate(unsigned short vendor_id, unsigned
 #ifdef SDL_LIBUSB_DYNAMIC
     if (libusb_ctx.libhandle) {
         usb_devs = LIBUSB_hid_enumerate(vendor_id, product_id);
-  #ifdef DEBUG_HIDAPI
+#ifdef DEBUG_HIDAPI
         SDL_Log("libusb devices found:");
-  #endif
+#endif
         for (usb_dev = usb_devs; usb_dev; usb_dev = usb_dev->next) {
             new_dev = (struct SDL_hid_device_info*) SDL_malloc(sizeof(struct SDL_hid_device_info));
             if (!new_dev) {
@@ -1197,11 +1199,11 @@ struct SDL_hid_device_info *SDL_hid_enumerate(unsigned short vendor_id, unsigned
                 return NULL;
             }
             CopyHIDDeviceInfo(usb_dev, new_dev);
-  #ifdef DEBUG_HIDAPI
+#ifdef DEBUG_HIDAPI
             SDL_Log(" - %ls %ls 0x%.4hx 0x%.4hx",
                     usb_dev->manufacturer_string, usb_dev->product_string,
                     usb_dev->vendor_id, usb_dev->product_id);
-  #endif
+#endif
 
             if (last != NULL) {
                 last->next = new_dev;
diff --git a/Engine/lib/sdl/src/hidapi/libusb/hid.c b/Engine/lib/sdl/src/hidapi/libusb/hid.c
index c54746e4d..9cb597fa8 100644
--- a/Engine/lib/sdl/src/hidapi/libusb/hid.c
+++ b/Engine/lib/sdl/src/hidapi/libusb/hid.c
@@ -1497,6 +1497,7 @@ void HID_API_EXPORT hid_close(hid_device *dev)
 
 	/* Clean up the Transfer objects allocated in read_thread(). */
 	free(dev->transfer->buffer);
+	dev->transfer->buffer = NULL;
 	libusb_free_transfer(dev->transfer);
 
 	/* release the interface */
diff --git a/Engine/lib/sdl/src/hidapi/mac/hid.c b/Engine/lib/sdl/src/hidapi/mac/hid.c
index a9a85b1f7..ec7ffaf16 100644
--- a/Engine/lib/sdl/src/hidapi/mac/hid.c
+++ b/Engine/lib/sdl/src/hidapi/mac/hid.c
@@ -572,8 +572,7 @@ struct hid_device_info  HID_API_EXPORT *hid_enumerate(unsigned short vendor_id,
 		if ((vendor_id == 0x0 && product_id == 0x0) ||
 		    (vendor_id == dev_vid && product_id == dev_pid)) {
 			struct hid_device_info *tmp;
-			size_t len;
-			
+
 			/* VID/PID match. Create the record. */
 			tmp = (struct hid_device_info *)calloc(1, sizeof(struct hid_device_info));
 			if (cur_dev) {
@@ -590,7 +589,7 @@ struct hid_device_info  HID_API_EXPORT *hid_enumerate(unsigned short vendor_id,
 			
 			/* Fill out the record */
 			cur_dev->next = NULL;
-			len = make_path(dev, cbuf, sizeof(cbuf));
+			make_path(dev, cbuf, sizeof(cbuf));
 			cur_dev->path = strdup(cbuf);
 			
 			/* Serial Number */
@@ -817,10 +816,9 @@ hid_device * HID_API_EXPORT hid_open_path(const char *path, int bExclusive)
 	CFSetGetValues(device_set, (const void **) device_array);	
 	for (i = 0; i < num_devices; i++) {
 		char cbuf[BUF_LEN];
-		size_t len;
 		IOHIDDeviceRef os_dev = device_array[i];
 		
-		len = make_path(os_dev, cbuf, sizeof(cbuf));
+		make_path(os_dev, cbuf, sizeof(cbuf));
 		if (!strcmp(cbuf, path)) {
 			// Matched Paths. Open this Device.
 			IOReturn ret = IOHIDDeviceOpen(os_dev, kIOHIDOptionsTypeNone);
@@ -833,6 +831,7 @@ hid_device * HID_API_EXPORT hid_open_path(const char *path, int bExclusive)
 				
 				/* Create the buffers for receiving data */
 				dev->max_input_report_len = (CFIndex) get_max_report_length(os_dev);
+				SDL_assert(dev->max_input_report_len > 0);
 				dev->input_report_buf = (uint8_t *)calloc(dev->max_input_report_len, sizeof(uint8_t));
 				
 				/* Create the Run Loop Mode for this device.
@@ -936,11 +935,14 @@ static int return_data(hid_device *dev, unsigned char *data, size_t length)
 	/* Copy the data out of the linked list item (rpt) into the
 	 return buffer (data), and delete the liked list item. */
 	struct input_report *rpt = dev->input_reports;
-	size_t len = (length < rpt->len)? length: rpt->len;
-	memcpy(data, rpt->data, len);
-	dev->input_reports = rpt->next;
-	free(rpt->data);
-	free(rpt);
+	size_t len = 0;
+	if (rpt != NULL) {
+		len = (length < rpt->len)? length: rpt->len;
+		memcpy(data, rpt->data, len);
+		dev->input_reports = rpt->next;
+		free(rpt->data);
+		free(rpt);
+	}
 	return (int)len;
 }
 
diff --git a/Engine/lib/sdl/src/joystick/SDL_gamecontrollerdb.h b/Engine/lib/sdl/src/joystick/SDL_gamecontrollerdb.h
index 2aa9ca6e8..9dab7cbba 100644
--- a/Engine/lib/sdl/src/joystick/SDL_gamecontrollerdb.h
+++ b/Engine/lib/sdl/src/joystick/SDL_gamecontrollerdb.h
@@ -501,7 +501,7 @@ static const char *s_ControllerMappings [] =
     "03000000830500006020000000010000,iBuffalo SNES Controller,a:b1,b:b0,back:b6,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,start:b7,x:b3,y:b2,hint:!SDL_GAMECONTROLLER_USE_BUTTON_LABELS:=1,",
     "03000000830500006020000000000000,iBuffalo USB 2-axis 8-button Gamepad,a:b1,b:b0,back:b6,leftshoulder:b4,leftx:a0,lefty:a1,rightshoulder:b5,start:b7,x:b3,y:b2,",
 #endif
-#if defined(__LINUX__)
+#ifdef SDL_JOYSTICK_LINUX
     "xinput,*,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
     "03000000c82d00000090000011010000,8BitDo FC30 Pro,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a5,rightx:a2,righty:a3,start:b11,x:b3,y:b4,hint:SDL_GAMECONTROLLER_USE_BUTTON_LABELS:=1,",
     "03000000c82d00000090000011010000,8BitDo FC30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a5,rightx:a2,righty:a3,start:b11,x:b4,y:b3,hint:!SDL_GAMECONTROLLER_USE_BUTTON_LABELS:=1,",
@@ -762,6 +762,7 @@ static const char *s_ControllerMappings [] =
     "0300000000f00000f100000000010000,Super RetroPort,a:b1,b:b5,back:b2,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b3,x:b0,y:b4,",
     "030000004f0400000ed0000011010000,ThrustMaster eSwap PRO Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,",
     "030000004f04000020b3000010010000,Thrustmaster 2 in 1 DT,a:b0,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b1,y:b3,",
+    "030000004f04000015b3000001010000,Thrustmaster Dual Analog 3.2,a:b0,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b1,y:b3,",
     "030000004f04000015b3000010010000,Thrustmaster Dual Analog 4,a:b0,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b1,y:b3,",
     "030000004f04000023b3000000010000,Thrustmaster Dual Trigger 3-in-1,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,",
     "030000004f04000000b3000010010000,Thrustmaster Firestorm Dual Power,a:b0,b:b2,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b11,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b12,righttrigger:b7,rightx:a2,righty:a3,start:b10,x:b1,y:b3,",
diff --git a/Engine/lib/sdl/src/joystick/SDL_joystick.c b/Engine/lib/sdl/src/joystick/SDL_joystick.c
index 3f3482b7d..ae4591223 100644
--- a/Engine/lib/sdl/src/joystick/SDL_joystick.c
+++ b/Engine/lib/sdl/src/joystick/SDL_joystick.c
@@ -1590,11 +1590,13 @@ SDL_JoystickUpdate(void)
 
     for (joystick = SDL_joysticks; joystick; joystick = joystick->next) {
         if (joystick->attached) {
-            /* This should always be true, but seeing a crash in the wild...? */
-            if (joystick->driver) {
-                joystick->driver->Update(joystick);
+            /* This driver should always be != NULL, but seeing a crash in the wild...? */
+            if (!joystick->driver) {
+                continue;  /* nothing we can do, and other things use joystick->driver below here. */
             }
 
+            joystick->driver->Update(joystick);
+
             if (joystick->delayed_guide_button) {
                 SDL_GameControllerHandleDelayedGuideButton(joystick);
             }
@@ -2158,7 +2160,10 @@ static SDL_bool SDL_IsJoystickProductWheel(Uint32 vidpid)
         MAKE_VIDPID(0x044f, 0xb65d),    /* Thrustmaster Wheel FFB */
         MAKE_VIDPID(0x044f, 0xb66d),    /* Thrustmaster Wheel FFB */
         MAKE_VIDPID(0x044f, 0xb677),    /* Thrustmaster T150 */
-        MAKE_VIDPID(0x044f, 0xb66e),    /* Thrustmaster T300RS */
+        MAKE_VIDPID(0x044f, 0xb696),    /* Thrustmaster T248 */
+        MAKE_VIDPID(0x044f, 0xb66e),    /* Thrustmaster T300RS (normal mode) */
+        MAKE_VIDPID(0x044f, 0xb66f),    /* Thrustmaster T300RS (advanced mode) */
+        MAKE_VIDPID(0x044f, 0xb66d),    /* Thrustmaster T300RS (PS4 mode) */
         MAKE_VIDPID(0x044f, 0xb65e),    /* Thrustmaster T500RS */
         MAKE_VIDPID(0x044f, 0xb664),    /* Thrustmaster TX (initial mode) */
         MAKE_VIDPID(0x044f, 0xb669),    /* Thrustmaster TX (active mode) */
diff --git a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_ps5.c b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_ps5.c
index 6d7f87d59..2549c2afd 100644
--- a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_ps5.c
+++ b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_ps5.c
@@ -747,7 +747,11 @@ HIDAPI_DriverPS5_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joy
         }
     }
 
-    return SDL_HIDAPI_SendRumbleAndUnlock(device, data, report_size);
+    if (SDL_HIDAPI_SendRumbleAndUnlock(device, data, report_size) != report_size) {
+        return -1;
+    }
+
+    return 0;
 }
 
 static int
@@ -957,7 +961,10 @@ HIDAPI_DriverPS5_HandleStatePacket(SDL_Joystick *joystick, SDL_hid_device *dev,
     axis = ((int)packet->ucRightJoystickY * 257) - 32768;
     SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_RIGHTY, axis);
 
-    if (packet->ucBatteryLevel & 0x10) {
+    /* A check of packet->ucBatteryLevel & 0x10 should work as a check for BT vs USB but doesn't
+     * seem to always work. Possibly related to being 100% charged?
+     */
+    if (!ctx->is_bluetooth) {
         /* 0x20 set means fully charged */
         SDL_PrivateJoystickBatteryLevel(joystick, SDL_JOYSTICK_POWER_WIRED);
     } else {
diff --git a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapijoystick.c b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapijoystick.c
index 55d9a1353..f54b3c3f2 100644
--- a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapijoystick.c
+++ b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapijoystick.c
@@ -227,7 +227,7 @@ HIDAPI_CleanupDeviceDriver(SDL_HIDAPI_Device *device)
     }
 
     /* Disconnect any joysticks */
-    while (device->num_joysticks) {
+    while (device->num_joysticks && device->joysticks) {
         HIDAPI_JoystickDisconnected(device, device->joysticks[0]);
     }
 
diff --git a/Engine/lib/sdl/src/joystick/iphoneos/SDL_mfijoystick.m b/Engine/lib/sdl/src/joystick/iphoneos/SDL_mfijoystick.m
index c75fbbae2..38ab3fe60 100644
--- a/Engine/lib/sdl/src/joystick/iphoneos/SDL_mfijoystick.m
+++ b/Engine/lib/sdl/src/joystick/iphoneos/SDL_mfijoystick.m
@@ -330,6 +330,19 @@ IOS_AddMFIJoystickDevice(SDL_JoystickDeviceItem *device, GCController *controlle
             subtype = 1;
         }
 
+        if (SDL_strcmp(name, "Backbone One") == 0) {
+            /* The Backbone app uses the guide and share buttons */
+            if ((device->button_mask & (1 << SDL_CONTROLLER_BUTTON_GUIDE)) != 0) {
+                device->button_mask &= ~(1 << SDL_CONTROLLER_BUTTON_GUIDE);
+                --nbuttons;
+            }
+            if ((device->button_mask & (1 << SDL_CONTROLLER_BUTTON_MISC1)) != 0) {
+                device->button_mask &= ~(1 << SDL_CONTROLLER_BUTTON_MISC1);
+                --nbuttons;
+                device->has_xbox_share_button = SDL_FALSE;
+            }
+        }
+
         device->naxes = 6; /* 2 thumbsticks and 2 triggers */
         device->nhats = 1; /* d-pad */
         device->nbuttons = nbuttons;
diff --git a/Engine/lib/sdl/src/joystick/linux/SDL_sysjoystick.c b/Engine/lib/sdl/src/joystick/linux/SDL_sysjoystick.c
index 851448acd..a268c0d9b 100644
--- a/Engine/lib/sdl/src/joystick/linux/SDL_sysjoystick.c
+++ b/Engine/lib/sdl/src/joystick/linux/SDL_sysjoystick.c
@@ -109,6 +109,7 @@ typedef struct SDL_joylist_item
     /* Steam Controller support */
     SDL_bool m_bSteamController;
 
+    SDL_bool checked_mapping;
     SDL_GamepadMapping *mapping;
 } SDL_joylist_item;
 
@@ -605,6 +606,26 @@ LINUX_InotifyJoystickDetect(void)
 }
 #endif /* HAVE_INOTIFY */
 
+static int get_event_joystick_index(int event)
+{
+    int joystick_index = -1;
+    int i, count;
+    struct dirent **entries = NULL;
+    char path[PATH_MAX];
+
+    SDL_snprintf(path, SDL_arraysize(path), "/sys/class/input/event%d/device", event);
+    count = scandir(path, &entries, NULL, alphasort);
+    for (i = 0; i < count; ++i) {
+        if (SDL_strncmp(entries[i]->d_name, "js", 2) == 0) {
+            joystick_index = SDL_atoi(entries[i]->d_name+2);
+        }
+        free(entries[i]); /* This should NOT be SDL_free() */
+    }
+    free(entries); /* This should NOT be SDL_free() */
+
+    return joystick_index;
+}
+
 /* Detect devices by reading /dev/input. In the inotify code path we
  * have to do this the first time, to detect devices that already existed
  * before we started; in the non-inotify code path we do this repeatedly
@@ -615,12 +636,39 @@ filter_entries(const struct dirent *entry)
     return IsJoystickDeviceNode(entry->d_name);
 }
 static int
-sort_entries(const struct dirent **a, const struct dirent **b)
+sort_entries(const void *_a, const void *_b)
 {
-    int numA = SDL_atoi((*a)->d_name+5);
-    int numB = SDL_atoi((*b)->d_name+5);
+    const struct dirent **a = (const struct dirent **)_a;
+    const struct dirent **b = (const struct dirent **)_b;
+    int numA, numB;
+    int offset;
+
+    if (SDL_classic_joysticks) {
+        offset = 2; /* strlen("js") */
+        numA = SDL_atoi((*a)->d_name+offset);
+        numB = SDL_atoi((*b)->d_name+offset);
+    } else {
+        offset = 5; /* strlen("event") */
+        numA = SDL_atoi((*a)->d_name+offset);
+        numB = SDL_atoi((*b)->d_name+offset);
+
+        /* See if we can get the joystick ordering */
+        {
+            int jsA = get_event_joystick_index(numA);
+            int jsB = get_event_joystick_index(numB);
+            if (jsA >= 0 && jsB >= 0) {
+                numA = jsA;
+                numB = jsB;
+            } else if (jsA >= 0) {
+                return -1;
+            } else if (jsB >= 0) {
+                return 1;
+            }
+        }
+    }
     return (numA - numB);
 }
+
 static void
 LINUX_FallbackJoystickDetect(void)
 {
@@ -633,10 +681,13 @@ LINUX_FallbackJoystickDetect(void)
         /* Opening input devices can generate synchronous device I/O, so avoid it if we can */
         if (stat("/dev/input", &sb) == 0 && sb.st_mtime != last_input_dir_mtime) {
             int i, count;
-            struct dirent **entries;
+            struct dirent **entries = NULL;
             char path[PATH_MAX];
 
-            count = scandir("/dev/input", &entries, filter_entries, sort_entries);
+            count = scandir("/dev/input", &entries, filter_entries, NULL);
+            if (count > 1) {
+                qsort(entries, count, sizeof(*entries), sort_entries);
+            }
             for (i = 0; i < count; ++i) {
                 SDL_snprintf(path, SDL_arraysize(path), "/dev/input/%s", entries[i]->d_name);
                 MaybeAddDevice(path);
@@ -683,29 +734,7 @@ LINUX_JoystickInit(void)
 
     SDL_classic_joysticks = SDL_GetHintBoolean(SDL_HINT_LINUX_JOYSTICK_CLASSIC, SDL_FALSE);
 
-#if SDL_USE_LIBUDEV
-    if (enumeration_method == ENUMERATION_UNSET) {
-        if (SDL_GetHintBoolean("SDL_JOYSTICK_DISABLE_UDEV", SDL_FALSE)) {
-            SDL_LogDebug(SDL_LOG_CATEGORY_INPUT,
-                         "udev disabled by SDL_JOYSTICK_DISABLE_UDEV");
-            enumeration_method = ENUMERATION_FALLBACK;
-
-        } else if (access("/.flatpak-info", F_OK) == 0
-                 || access("/run/host/container-manager", F_OK) == 0) {
-            /* Explicitly check `/.flatpak-info` because, for old versions of
-             * Flatpak, this was the only available way to tell if we were in
-             * a Flatpak container. */
-            SDL_LogDebug(SDL_LOG_CATEGORY_INPUT,
-                         "Container detected, disabling udev integration");
-            enumeration_method = ENUMERATION_FALLBACK;
-
-        } else {
-            SDL_LogDebug(SDL_LOG_CATEGORY_INPUT,
-                         "Using udev for joystick device discovery");
-            enumeration_method = ENUMERATION_LIBUDEV;
-        }
-    }
-#endif
+    enumeration_method = ENUMERATION_UNSET;
 
     /* First see if the user specified one or more joysticks to use */
     if (devices != NULL) {
@@ -734,6 +763,28 @@ LINUX_JoystickInit(void)
     LINUX_JoystickDetect();
 
 #if SDL_USE_LIBUDEV
+    if (enumeration_method == ENUMERATION_UNSET) {
+        if (SDL_GetHintBoolean("SDL_JOYSTICK_DISABLE_UDEV", SDL_FALSE)) {
+            SDL_LogDebug(SDL_LOG_CATEGORY_INPUT,
+                         "udev disabled by SDL_JOYSTICK_DISABLE_UDEV");
+            enumeration_method = ENUMERATION_FALLBACK;
+
+        } else if (access("/.flatpak-info", F_OK) == 0
+                 || access("/run/host/container-manager", F_OK) == 0) {
+            /* Explicitly check `/.flatpak-info` because, for old versions of
+             * Flatpak, this was the only available way to tell if we were in
+             * a Flatpak container. */
+            SDL_LogDebug(SDL_LOG_CATEGORY_INPUT,
+                         "Container detected, disabling udev integration");
+            enumeration_method = ENUMERATION_FALLBACK;
+
+        } else {
+            SDL_LogDebug(SDL_LOG_CATEGORY_INPUT,
+                         "Using udev for joystick device discovery");
+            enumeration_method = ENUMERATION_LIBUDEV;
+        }
+    }
+
     if (enumeration_method == ENUMERATION_LIBUDEV) {
         if (SDL_UDEV_Init() < 0) {
             return SDL_SetError("Could not initialize UDEV");
@@ -1573,9 +1624,13 @@ LINUX_JoystickGetGamepadMapping(int device_index, SDL_GamepadMapping *out)
     SDL_Joystick *joystick;
     SDL_joylist_item *item = JoystickByDevIndex(device_index);
 
-    if (item->mapping) {
-        SDL_memcpy(out, item->mapping, sizeof(*out));
-        return SDL_TRUE;
+    if (item->checked_mapping) {
+        if (item->mapping) {
+            SDL_memcpy(out, item->mapping, sizeof(*out));
+            return SDL_TRUE;
+        } else {
+            return SDL_FALSE;
+        }
     }
 
     /* We temporarily open the device to check how it's configured. Make
@@ -1595,6 +1650,8 @@ LINUX_JoystickGetGamepadMapping(int device_index, SDL_GamepadMapping *out)
         return SDL_FALSE;
     }
 
+    item->checked_mapping = SDL_TRUE;
+
     if (PrepareJoystickHwdata(joystick, item) == -1) {
         SDL_free(joystick->hwdata);
         SDL_free(joystick);
diff --git a/Engine/lib/sdl/src/joystick/windows/SDL_rawinputjoystick.c b/Engine/lib/sdl/src/joystick/windows/SDL_rawinputjoystick.c
index 32b637827..df40232df 100644
--- a/Engine/lib/sdl/src/joystick/windows/SDL_rawinputjoystick.c
+++ b/Engine/lib/sdl/src/joystick/windows/SDL_rawinputjoystick.c
@@ -62,6 +62,7 @@ typedef struct WindowsGamingInputGamepadState WindowsGamingInputGamepadState;
 #define GamepadButtons_GUIDE 0x40000000
 #define COBJMACROS
 #include "windows.gaming.input.h"
+#include <roapi.h>
 #endif
 
 #if defined(SDL_JOYSTICK_RAWINPUT_XINPUT) || defined(SDL_JOYSTICK_RAWINPUT_WGI)
@@ -565,22 +566,24 @@ RAWINPUT_InitWindowsGamingInput(RAWINPUT_DeviceContext *ctx)
     if (!wgi_state.initialized) {
         static const IID SDL_IID_IGamepadStatics = { 0x8BBCE529, 0xD49C, 0x39E9, { 0x95, 0x60, 0xE4, 0x7D, 0xDE, 0x96, 0xB7, 0xC8 } };
         HRESULT hr;
-        HMODULE hModule;
 
-        /* I think this takes care of RoInitialize() in a way that is compatible with the rest of SDL */
-        if (FAILED(WIN_CoInitialize())) {
+        if (FAILED(WIN_RoInitialize())) {
             return;
         }
         wgi_state.initialized = SDL_TRUE;
         wgi_state.dirty = SDL_TRUE;
 
-        hModule = LoadLibraryA("combase.dll");
-        if (hModule != NULL) {
+        {
             typedef HRESULT (WINAPI *WindowsCreateStringReference_t)(PCWSTR sourceString, UINT32 length, HSTRING_HEADER *hstringHeader, HSTRING* string);
             typedef HRESULT (WINAPI *RoGetActivationFactory_t)(HSTRING activatableClassId, REFIID iid, void** factory);
 
-            WindowsCreateStringReference_t WindowsCreateStringReferenceFunc = (WindowsCreateStringReference_t)GetProcAddress(hModule, "WindowsCreateStringReference");
-            RoGetActivationFactory_t RoGetActivationFactoryFunc = (RoGetActivationFactory_t)GetProcAddress(hModule, "RoGetActivationFactory");
+#ifdef __WINRT__
+            WindowsCreateStringReference_t WindowsCreateStringReferenceFunc = WindowsCreateStringReference;
+            RoGetActivationFactory_t RoGetActivationFactoryFunc = RoGetActivationFactory;
+#else
+            WindowsCreateStringReference_t WindowsCreateStringReferenceFunc = (WindowsCreateStringReference_t)WIN_LoadComBaseFunction("WindowsCreateStringReference");
+            RoGetActivationFactory_t RoGetActivationFactoryFunc = (RoGetActivationFactory_t)WIN_LoadComBaseFunction("RoGetActivationFactory");
+#endif
             if (WindowsCreateStringReferenceFunc && RoGetActivationFactoryFunc) {
                 PCWSTR pNamespace = L"Windows.Gaming.Input.Gamepad";
                 HSTRING_HEADER hNamespaceStringHeader;
@@ -591,7 +594,6 @@ RAWINPUT_InitWindowsGamingInput(RAWINPUT_DeviceContext *ctx)
                     RoGetActivationFactoryFunc(hNamespaceString, &SDL_IID_IGamepadStatics, (void **)&wgi_state.gamepad_statics);
                 }
             }
-            FreeLibrary(hModule);
         }
     }
 }
@@ -657,7 +659,7 @@ RAWINPUT_QuitWindowsGamingInput(RAWINPUT_DeviceContext *ctx)
             __x_ABI_CWindows_CGaming_CInput_CIGamepadStatics_Release(wgi_state.gamepad_statics);
             wgi_state.gamepad_statics = NULL;
         }
-        WIN_CoUninitialize();
+        WIN_RoUninitialize();
         wgi_state.initialized = SDL_FALSE;
     }
 }
@@ -1320,8 +1322,10 @@ RAWINPUT_JoystickRumbleTriggers(SDL_Joystick *joystick, Uint16 left_rumble, Uint
         if (!SUCCEEDED(hr)) {
             return SDL_SetError("Setting vibration failed: 0x%lx\n", hr);
         }
+        return 0;
+    } else {
+        return SDL_SetError("Controller isn't correlated yet, try hitting a button first");
     }
-    return 0;
 #else
     return SDL_Unsupported();
 #endif
diff --git a/Engine/lib/sdl/src/joystick/windows/SDL_windows_gaming_input.c b/Engine/lib/sdl/src/joystick/windows/SDL_windows_gaming_input.c
index a731dad63..6c5ec5528 100644
--- a/Engine/lib/sdl/src/joystick/windows/SDL_windows_gaming_input.c
+++ b/Engine/lib/sdl/src/joystick/windows/SDL_windows_gaming_input.c
@@ -68,6 +68,7 @@ static struct {
     EventRegistrationToken controller_added_token;
     EventRegistrationToken controller_removed_token;
     int controller_count;
+    SDL_bool ro_initialized;
     WindowsGamingInputControllerState *controllers;
 } wgi;
 
@@ -260,10 +261,9 @@ static HRESULT STDMETHODCALLTYPE IEventHandler_CRawGameControllerVtbl_InvokeAdde
             WindowsGetStringRawBufferFunc = WindowsGetStringRawBuffer;
             WindowsDeleteStringFunc = WindowsDeleteString;
 #else
-            HMODULE hModule = LoadLibraryA("combase.dll");
-            if (hModule != NULL) {
-                WindowsGetStringRawBufferFunc = (WindowsGetStringRawBuffer_t)GetProcAddress(hModule, "WindowsGetStringRawBuffer");
-                WindowsDeleteStringFunc = (WindowsDeleteString_t)GetProcAddress(hModule, "WindowsDeleteString");
+            {
+                WindowsGetStringRawBufferFunc = (WindowsGetStringRawBuffer_t)WIN_LoadComBaseFunction("WindowsGetStringRawBuffer");
+                WindowsDeleteStringFunc = (WindowsDeleteString_t)WIN_LoadComBaseFunction("WindowsDeleteString");
             }
 #endif /* __WINRT__ */
             if (WindowsGetStringRawBufferFunc && WindowsDeleteStringFunc) {
@@ -277,11 +277,6 @@ static HRESULT STDMETHODCALLTYPE IEventHandler_CRawGameControllerVtbl_InvokeAdde
                     WindowsDeleteStringFunc(hString);
                 }
             }
-#ifndef __WINRT__
-            if (hModule != NULL) {
-                FreeLibrary(hModule);
-            }
-#endif
             __x_ABI_CWindows_CGaming_CInput_CIRawGameController2_Release(controller2);
         }
         if (!name) {
@@ -444,23 +439,43 @@ WGI_JoystickInit(void)
 
     WindowsCreateStringReference_t WindowsCreateStringReferenceFunc = NULL;
     RoGetActivationFactory_t RoGetActivationFactoryFunc = NULL;
-#ifndef __WINRT__
-    HMODULE hModule;
-#endif
     HRESULT hr;
 
-    if (FAILED(WIN_CoInitialize())) {
-        return SDL_SetError("CoInitialize() failed");
+    if (FAILED(WIN_RoInitialize())) {
+        return SDL_SetError("RoInitialize() failed");
     }
+    wgi.ro_initialized = SDL_TRUE;
+
+#ifndef __WINRT__
+    {
+        /* There seems to be a bug in Windows where a dependency of WGI can be unloaded from memory prior to WGI itself.
+         * This results in Windows_Gaming_Input!GameController::~GameController() invoking an unloaded DLL and crashing.
+         * As a workaround, we will keep a reference to the MTA to prevent COM from unloading DLLs later.
+         * See https://github.com/libsdl-org/SDL/issues/5552 for more details.
+         */
+        static PVOID cookie = NULL;
+        if (!cookie) {
+            typedef HRESULT (WINAPI *CoIncrementMTAUsage_t)(PVOID* pCookie);
+            CoIncrementMTAUsage_t CoIncrementMTAUsageFunc = (CoIncrementMTAUsage_t)WIN_LoadComBaseFunction("CoIncrementMTAUsage");
+            if (CoIncrementMTAUsageFunc) {
+                if (FAILED(CoIncrementMTAUsageFunc(&cookie))) {
+                    return SDL_SetError("CoIncrementMTAUsage() failed");
+                }
+            } else {
+                /* CoIncrementMTAUsage() is present since Win8, so we should never make it here. */
+                return SDL_SetError("CoIncrementMTAUsage() not found");
+            }
+        }
+    }
+#endif
 
 #ifdef __WINRT__
     WindowsCreateStringReferenceFunc = WindowsCreateStringReference;
     RoGetActivationFactoryFunc = RoGetActivationFactory;
 #else
-    hModule = LoadLibraryA("combase.dll");
-    if (hModule != NULL) {
-        WindowsCreateStringReferenceFunc = (WindowsCreateStringReference_t)GetProcAddress(hModule, "WindowsCreateStringReference");
-        RoGetActivationFactoryFunc = (RoGetActivationFactory_t)GetProcAddress(hModule, "RoGetActivationFactory");
+    {
+        WindowsCreateStringReferenceFunc = (WindowsCreateStringReference_t)WIN_LoadComBaseFunction("WindowsCreateStringReference");
+        RoGetActivationFactoryFunc = (RoGetActivationFactory_t)WIN_LoadComBaseFunction("RoGetActivationFactory");
     }
 #endif /* __WINRT__ */
     if (WindowsCreateStringReferenceFunc && RoGetActivationFactoryFunc) {
@@ -519,11 +534,6 @@ WGI_JoystickInit(void)
             }
         }
     }
-#ifndef __WINRT__
-    if (hModule != NULL) {
-        FreeLibrary(hModule);
-    }
-#endif
 
     if (wgi.statics) {
         __FIVectorView_1_Windows__CGaming__CInput__CRawGameController *controllers;
@@ -863,9 +873,12 @@ WGI_JoystickQuit(void)
         __x_ABI_CWindows_CGaming_CInput_CIRawGameControllerStatics_remove_RawGameControllerRemoved(wgi.statics, wgi.controller_removed_token);
         __x_ABI_CWindows_CGaming_CInput_CIRawGameControllerStatics_Release(wgi.statics);
     }
-    SDL_zero(wgi);
 
-    WIN_CoUninitialize();
+    if (wgi.ro_initialized) {
+        WIN_RoUninitialize();
+    }
+
+    SDL_zero(wgi);
 }
 
 static SDL_bool
diff --git a/Engine/lib/sdl/src/locale/vita/SDL_syslocale.c b/Engine/lib/sdl/src/locale/vita/SDL_syslocale.c
new file mode 100644
index 000000000..0a057cbfa
--- /dev/null
+++ b/Engine/lib/sdl/src/locale/vita/SDL_syslocale.c
@@ -0,0 +1,71 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "../../SDL_internal.h"
+#include "../SDL_syslocale.h"
+
+#include <psp2/apputil.h>
+#include <psp2/system_param.h>
+
+void
+SDL_SYS_GetPreferredLocales(char *buf, size_t buflen)
+{
+    const char *vita_locales[] = {
+        "ja_JP",
+        "en_US",
+        "fr_FR",
+        "es_ES",
+        "de_DE",
+        "it_IT",
+        "nl_NL",
+        "pt_PT",
+        "ru_RU",
+        "ko_KR",
+        "zh_TW",
+        "zh_CN",
+        "fi_FI",
+        "sv_SE",
+        "da_DK",
+        "no_NO",
+        "pl_PL",
+        "pt_BR",
+        "en_GB",
+        "tr_TR",
+    };
+
+    Sint32 language = SCE_SYSTEM_PARAM_LANG_ENGLISH_US;
+    SceAppUtilInitParam initParam;
+    SceAppUtilBootParam bootParam;
+    SDL_zero(initParam);
+    SDL_zero(bootParam);
+    sceAppUtilInit(&initParam, &bootParam);
+    sceAppUtilSystemParamGetInt(SCE_SYSTEM_PARAM_ID_LANG, &language);
+
+    if (language < 0 || language > SCE_SYSTEM_PARAM_LANG_TURKISH)
+        language = SCE_SYSTEM_PARAM_LANG_ENGLISH_US; // default to english
+
+    SDL_strlcpy(buf, vita_locales[language], buflen);
+
+    sceAppUtilShutdown();
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
+
diff --git a/Engine/lib/sdl/src/main/windows/version.rc b/Engine/lib/sdl/src/main/windows/version.rc
index 36ff39f12..11e1394f8 100644
--- a/Engine/lib/sdl/src/main/windows/version.rc
+++ b/Engine/lib/sdl/src/main/windows/version.rc
@@ -9,8 +9,8 @@ LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
 //
 
 VS_VERSION_INFO VERSIONINFO
- FILEVERSION 2,0,21,0
- PRODUCTVERSION 2,0,21,0
+ FILEVERSION 2,0,22,0
+ PRODUCTVERSION 2,0,22,0
  FILEFLAGSMASK 0x3fL
  FILEFLAGS 0x0L
  FILEOS 0x40004L
@@ -23,12 +23,12 @@ BEGIN
         BEGIN
             VALUE "CompanyName", "\0"
             VALUE "FileDescription", "SDL\0"
-            VALUE "FileVersion", "2, 0, 21, 0\0"
+            VALUE "FileVersion", "2, 0, 22, 0\0"
             VALUE "InternalName", "SDL\0"
             VALUE "LegalCopyright", "Copyright (C) 2022 Sam Lantinga\0"
             VALUE "OriginalFilename", "SDL2.dll\0"
             VALUE "ProductName", "Simple DirectMedia Layer\0"
-            VALUE "ProductVersion", "2, 0, 21, 0\0"
+            VALUE "ProductVersion", "2, 0, 22, 0\0"
         END
     END
     BLOCK "VarFileInfo"
diff --git a/Engine/lib/sdl/src/render/SDL_render.c b/Engine/lib/sdl/src/render/SDL_render.c
index 441badbc6..58cda3d60 100644
--- a/Engine/lib/sdl/src/render/SDL_render.c
+++ b/Engine/lib/sdl/src/render/SDL_render.c
@@ -356,7 +356,7 @@ QueueCmdSetViewport(SDL_Renderer *renderer)
         if (cmd != NULL) {
             cmd->command = SDL_RENDERCMD_SETVIEWPORT;
             cmd->data.viewport.first = 0;  /* render backend will fill this in. */
-            /* Convert SDL_FRect to SDL_Rect */
+            /* Convert SDL_DRect to SDL_Rect */
             cmd->data.viewport.rect.x = (int)SDL_floor(renderer->viewport.x);
             cmd->data.viewport.rect.y = (int)SDL_floor(renderer->viewport.y);
             cmd->data.viewport.rect.w = (int)SDL_floor(renderer->viewport.w);
@@ -386,7 +386,7 @@ QueueCmdSetClipRect(SDL_Renderer *renderer)
         } else {
             cmd->command = SDL_RENDERCMD_SETCLIPRECT;
             cmd->data.cliprect.enabled = renderer->clipping_enabled;
-            /* Convert SDL_FRect to SDL_Rect */
+            /* Convert SDL_DRect to SDL_Rect */
             cmd->data.cliprect.rect.x = (int)SDL_floor(renderer->clip_rect.x);
             cmd->data.cliprect.rect.y = (int)SDL_floor(renderer->clip_rect.y);
             cmd->data.cliprect.rect.w = (int)SDL_floor(renderer->clip_rect.w);
@@ -580,10 +580,10 @@ QueueCmdFillRects(SDL_Renderer *renderer, const SDL_FRect * rects, const int cou
                 if (retval < 0) {
                     cmd->command = SDL_RENDERCMD_NO_OP;
                 }
-
-                SDL_small_free(xy, isstack1);
-                SDL_small_free(indices, isstack2);
             }
+            SDL_small_free(xy, isstack1);
+            SDL_small_free(indices, isstack2);
+            
         } else {
             retval = renderer->QueueFillRects(renderer, cmd, rects, count);
             if (retval < 0) {
@@ -676,7 +676,7 @@ SDL_GetRenderDriverInfo(int index, SDL_RendererInfo * info)
 #endif
 }
 
-static void GetWindowViewportValues(SDL_Renderer *renderer, int *logical_w, int *logical_h, SDL_FRect *viewport, SDL_FPoint *scale)
+static void GetWindowViewportValues(SDL_Renderer *renderer, int *logical_w, int *logical_h, SDL_DRect *viewport, SDL_FPoint *scale)
 {
     SDL_LockMutex(renderer->target_mutex);
     *logical_w = renderer->target ? renderer->logical_w_backup : renderer->logical_w;
@@ -698,7 +698,17 @@ SDL_RendererEventWatch(void *userdata, SDL_Event *event)
                 renderer->WindowEvent(renderer, &event->window);
             }
 
-            if (event->window.event == SDL_WINDOWEVENT_SIZE_CHANGED) {
+            /* In addition to size changes, we also want to do this block for
+             * moves as well, for two reasons:
+             *
+             * 1. The window could be moved to a new display, which has a new
+             *    DPI and therefore a new window/drawable ratio
+             * 2. For whatever reason, the viewport can get messed up during
+             *    window movement (this has been observed on macOS), so this is
+             *    also a good opportunity to force viewport updates
+             */
+            if (event->window.event == SDL_WINDOWEVENT_SIZE_CHANGED ||
+                event->window.event == SDL_WINDOWEVENT_MOVED) {
                 /* Make sure we're operating on the default render target */
                 SDL_Texture *saved_target = SDL_GetRenderTarget(renderer);
                 if (saved_target) {
@@ -728,10 +738,10 @@ SDL_RendererEventWatch(void *userdata, SDL_Event *event)
                         SDL_GetWindowSize(renderer->window, &w, &h);
                     }
 
-                    renderer->viewport.x = 0;
-                    renderer->viewport.y = 0;
-                    renderer->viewport.w = (float) w;
-                    renderer->viewport.h = (float) h;
+                    renderer->viewport.x = (double)0;
+                    renderer->viewport.y = (double)0;
+                    renderer->viewport.w = (double)w;
+                    renderer->viewport.h = (double)h;
                     QueueCmdSetViewport(renderer);
                     FlushRenderCommandsIfNotBatching(renderer);
                 }
@@ -758,7 +768,7 @@ SDL_RendererEventWatch(void *userdata, SDL_Event *event)
         SDL_Window *window = SDL_GetWindowFromID(event->motion.windowID);
         if (window == renderer->window) {
             int logical_w, logical_h;
-            SDL_FRect viewport;
+            SDL_DRect viewport;
             SDL_FPoint scale;
             GetWindowViewportValues(renderer, &logical_w, &logical_h, &viewport, &scale);
             if (logical_w) {
@@ -785,7 +795,7 @@ SDL_RendererEventWatch(void *userdata, SDL_Event *event)
         SDL_Window *window = SDL_GetWindowFromID(event->button.windowID);
         if (window == renderer->window) {
             int logical_w, logical_h;
-            SDL_FRect viewport;
+            SDL_DRect viewport;
             SDL_FPoint scale;
             GetWindowViewportValues(renderer, &logical_w, &logical_h, &viewport, &scale);
             if (logical_w) {
@@ -800,7 +810,7 @@ SDL_RendererEventWatch(void *userdata, SDL_Event *event)
                event->type == SDL_FINGERMOTION) {
         int logical_w, logical_h;
         float physical_w, physical_h;
-        SDL_FRect viewport;
+        SDL_DRect viewport;
         SDL_FPoint scale;
         GetWindowViewportValues(renderer, &logical_w, &logical_h, &viewport, &scale);
 
@@ -1095,6 +1105,13 @@ SDL_GetRenderer(SDL_Window * window)
     return (SDL_Renderer *)SDL_GetWindowData(window, SDL_WINDOWRENDERDATA);
 }
 
+SDL_Window *
+SDL_RenderGetWindow(SDL_Renderer *renderer)
+{
+    CHECK_RENDERER_MAGIC(renderer, NULL);
+    return renderer->window;
+}
+
 int
 SDL_GetRendererInfo(SDL_Renderer * renderer, SDL_RendererInfo * info)
 {
@@ -1585,10 +1602,11 @@ SDL_SetTextureScaleMode(SDL_Texture * texture, SDL_ScaleMode scaleMode)
     CHECK_TEXTURE_MAGIC(texture, -1);
 
     renderer = texture->renderer;
-    renderer->SetTextureScaleMode(renderer, texture, scaleMode);
     texture->scaleMode = scaleMode;
     if (texture->native) {
         return SDL_SetTextureScaleMode(texture->native, scaleMode);
+    } else {
+        renderer->SetTextureScaleMode(renderer, texture, scaleMode);
     }
     return 0;
 }
@@ -2210,10 +2228,10 @@ SDL_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
     }
 
     if (texture) {
-        renderer->viewport.x = 0.0f;
-        renderer->viewport.y = 0.0f;
-        renderer->viewport.w = (float) texture->w;
-        renderer->viewport.h = (float) texture->h;
+        renderer->viewport.x = (double)0;
+        renderer->viewport.y = (double)0;
+        renderer->viewport.w = (double)texture->w;
+        renderer->viewport.h = (double)texture->h;
         SDL_zero(renderer->clip_rect);
         renderer->clipping_enabled = SDL_FALSE;
         renderer->scale.x = 1.0f;
@@ -2245,6 +2263,8 @@ SDL_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
 SDL_Texture *
 SDL_GetRenderTarget(SDL_Renderer *renderer)
 {
+    CHECK_RENDERER_MAGIC(renderer, NULL);
+
     return renderer->target;
 }
 
@@ -2420,19 +2440,19 @@ SDL_RenderSetViewport(SDL_Renderer * renderer, const SDL_Rect * rect)
     CHECK_RENDERER_MAGIC(renderer, -1);
 
     if (rect) {
-        renderer->viewport.x = rect->x * renderer->scale.x;
-        renderer->viewport.y = rect->y * renderer->scale.y;
-        renderer->viewport.w = rect->w * renderer->scale.x;
-        renderer->viewport.h = rect->h * renderer->scale.y;
+        renderer->viewport.x = (double)rect->x * renderer->scale.x;
+        renderer->viewport.y = (double)rect->y * renderer->scale.y;
+        renderer->viewport.w = (double)rect->w * renderer->scale.x;
+        renderer->viewport.h = (double)rect->h * renderer->scale.y;
     } else {
         int w, h;
         if (SDL_GetRendererOutputSize(renderer, &w, &h) < 0) {
             return -1;
         }
-        renderer->viewport.x = 0.0f;
-        renderer->viewport.y = 0.0f;
-        renderer->viewport.w = (float) w;
-        renderer->viewport.h = (float) h;
+        renderer->viewport.x = (double)0;
+        renderer->viewport.y = (double)0;
+        renderer->viewport.w = (double)w;
+        renderer->viewport.h = (double)h;
     }
     retval = QueueCmdSetViewport(renderer);
     return retval < 0 ? retval : FlushRenderCommandsIfNotBatching(renderer);
@@ -2456,8 +2476,8 @@ RenderGetViewportSize(SDL_Renderer * renderer, SDL_FRect * rect)
 {
     rect->x = 0.0f;
     rect->y = 0.0f;
-    rect->w = renderer->viewport.w / renderer->scale.x;
-    rect->h = renderer->viewport.h / renderer->scale.y;
+    rect->w = (float)(renderer->viewport.w / renderer->scale.x);
+    rect->h = (float)(renderer->viewport.h / renderer->scale.y);
 }
 
 int
@@ -2468,10 +2488,10 @@ SDL_RenderSetClipRect(SDL_Renderer * renderer, const SDL_Rect * rect)
 
     if (rect) {
         renderer->clipping_enabled = SDL_TRUE;
-        renderer->clip_rect.x = rect->x * renderer->scale.x;
-        renderer->clip_rect.y = rect->y * renderer->scale.y;
-        renderer->clip_rect.w = rect->w * renderer->scale.x;
-        renderer->clip_rect.h = rect->h * renderer->scale.y;
+        renderer->clip_rect.x = (double)rect->x * renderer->scale.x;
+        renderer->clip_rect.y = (double)rect->y * renderer->scale.y;
+        renderer->clip_rect.w = (double)rect->w * renderer->scale.x;
+        renderer->clip_rect.h = (double)rect->h * renderer->scale.y;
     } else {
         renderer->clipping_enabled = SDL_FALSE;
         SDL_zero(renderer->clip_rect);
@@ -2535,10 +2555,10 @@ SDL_RenderWindowToLogical(SDL_Renderer * renderer, int windowX, int windowY, flo
     window_physical_y = ((float) windowY) / renderer->dpi_scale.y;
 
     if (logicalX) {
-        *logicalX = (window_physical_x - renderer->viewport.x) / renderer->scale.x;
+        *logicalX = (float)((window_physical_x - renderer->viewport.x) / renderer->scale.x);
     }
     if (logicalY) {
-        *logicalY = (window_physical_y - renderer->viewport.y) / renderer->scale.y;
+        *logicalY = (float)((window_physical_y - renderer->viewport.y) / renderer->scale.y);
     }
 }
 
@@ -2549,8 +2569,8 @@ SDL_RenderLogicalToWindow(SDL_Renderer * renderer, float logicalX, float logical
 
     CHECK_RENDERER_MAGIC(renderer, );
 
-    window_physical_x = (logicalX * renderer->scale.x) + renderer->viewport.x;
-    window_physical_y = (logicalY * renderer->scale.y) + renderer->viewport.y;
+    window_physical_x = (float)((logicalX * renderer->scale.x) + renderer->viewport.x);
+    window_physical_y = (float)((logicalY * renderer->scale.y) + renderer->viewport.y);
 
     if (windowX) {
         *windowX = (int)(window_physical_x * renderer->dpi_scale.x);
@@ -3138,10 +3158,11 @@ SDL_RenderDrawLinesF(SDL_Renderer * renderer,
                     num_vertices, indices, num_indices, size_indices,
                     1.0f, 1.0f);
 
-            SDL_small_free(xy, isstack1);
-            SDL_small_free(indices, isstack2);
         }
 
+        SDL_small_free(xy, isstack1);
+        SDL_small_free(indices, isstack2);
+
     } else if (renderer->scale.x != 1.0f || renderer->scale.y != 1.0f) {
         retval = RenderDrawLinesWithRectsF(renderer, points, count);
     } else {
diff --git a/Engine/lib/sdl/src/render/SDL_sysrender.h b/Engine/lib/sdl/src/render/SDL_sysrender.h
index 5d92f6a26..7aeb46710 100644
--- a/Engine/lib/sdl/src/render/SDL_sysrender.h
+++ b/Engine/lib/sdl/src/render/SDL_sysrender.h
@@ -28,6 +28,19 @@
 #include "SDL_mutex.h"
 #include "SDL_yuv_sw_c.h"
 
+
+/**
+ * A rectangle, with the origin at the upper left (double precision).
+ */
+typedef struct SDL_DRect
+{
+    double x;
+    double y;
+    double w;
+    double h;
+} SDL_DRect;
+
+
 /* The SDL 2D rendering system */
 
 typedef struct SDL_RenderDriver SDL_RenderDriver;
@@ -201,12 +214,12 @@ struct SDL_Renderer
     SDL_bool integer_scale;
 
     /* The drawable area within the window */
-    SDL_FRect viewport;
-    SDL_FRect viewport_backup;
+    SDL_DRect viewport;
+    SDL_DRect viewport_backup;
 
     /* The clip rectangle within the window */
-    SDL_FRect clip_rect;
-    SDL_FRect clip_rect_backup;
+    SDL_DRect clip_rect;
+    SDL_DRect clip_rect_backup;
 
     /* Wether or not the clipping rectangle is used. */
     SDL_bool clipping_enabled;
@@ -244,8 +257,8 @@ struct SDL_Renderer
     SDL_RenderCommand *render_commands_pool;
     Uint32 render_command_generation;
     Uint32 last_queued_color;
-    SDL_FRect last_queued_viewport;
-    SDL_FRect last_queued_cliprect;
+    SDL_DRect last_queued_viewport;
+    SDL_DRect last_queued_cliprect;
     SDL_bool last_queued_cliprect_enabled;
     SDL_bool color_queued;
     SDL_bool viewport_queued;
diff --git a/Engine/lib/sdl/src/render/direct3d/SDL_render_d3d.c b/Engine/lib/sdl/src/render/direct3d/SDL_render_d3d.c
index b267fb23e..477f4e975 100644
--- a/Engine/lib/sdl/src/render/direct3d/SDL_render_d3d.c
+++ b/Engine/lib/sdl/src/render/direct3d/SDL_render_d3d.c
@@ -347,7 +347,8 @@ D3D_WindowEvent(SDL_Renderer * renderer, const SDL_WindowEvent *event)
     }
 }
 
-static D3DBLEND GetBlendFunc(SDL_BlendFactor factor)
+static D3DBLEND
+GetBlendFunc(SDL_BlendFactor factor)
 {
     switch (factor) {
     case SDL_BLENDFACTOR_ZERO:
@@ -370,9 +371,28 @@ static D3DBLEND GetBlendFunc(SDL_BlendFactor factor)
         return D3DBLEND_DESTALPHA;
     case SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA:
         return D3DBLEND_INVDESTALPHA;
-    default:
-        return (D3DBLEND)0;
+    default: break;
     }
+    return (D3DBLEND) 0;
+}
+
+static D3DBLENDOP
+GetBlendEquation(SDL_BlendOperation operation)
+{
+    switch (operation) {
+    case SDL_BLENDOPERATION_ADD:
+        return D3DBLENDOP_ADD;
+    case SDL_BLENDOPERATION_SUBTRACT:
+        return D3DBLENDOP_SUBTRACT;
+    case SDL_BLENDOPERATION_REV_SUBTRACT:
+        return D3DBLENDOP_REVSUBTRACT;
+    case SDL_BLENDOPERATION_MINIMUM:
+        return D3DBLENDOP_MIN;
+    case SDL_BLENDOPERATION_MAXIMUM:
+        return D3DBLENDOP_MAX;
+    default: break;
+    }
+    return (D3DBLENDOP) 0;
 }
 
 static SDL_bool
@@ -387,14 +407,16 @@ D3D_SupportsBlendMode(SDL_Renderer * renderer, SDL_BlendMode blendMode)
     SDL_BlendOperation alphaOperation = SDL_GetBlendModeAlphaOperation(blendMode);
 
     if (!GetBlendFunc(srcColorFactor) || !GetBlendFunc(srcAlphaFactor) ||
-        !GetBlendFunc(dstColorFactor) || !GetBlendFunc(dstAlphaFactor)) {
+        !GetBlendEquation(colorOperation) ||
+        !GetBlendFunc(dstColorFactor) || !GetBlendFunc(dstAlphaFactor) ||
+        !GetBlendEquation(alphaOperation)) {
         return SDL_FALSE;
     }
-    if ((srcColorFactor != srcAlphaFactor || dstColorFactor != dstAlphaFactor) && !data->enableSeparateAlphaBlend) {
-        return SDL_FALSE;
-    }
-    if (colorOperation != SDL_BLENDOPERATION_ADD || alphaOperation != SDL_BLENDOPERATION_ADD) {
-        return SDL_FALSE;
+
+    if (!data->enableSeparateAlphaBlend) {
+        if ((srcColorFactor != srcAlphaFactor) || (dstColorFactor != dstAlphaFactor) || (colorOperation != alphaOperation)) {
+            return SDL_FALSE;
+        }
     }
     return SDL_TRUE;
 }
@@ -1040,11 +1062,15 @@ SetDrawState(D3D_RenderData *data, const SDL_RenderCommand *cmd)
                                             GetBlendFunc(SDL_GetBlendModeSrcColorFactor(blend)));
             IDirect3DDevice9_SetRenderState(data->device, D3DRS_DESTBLEND,
                                             GetBlendFunc(SDL_GetBlendModeDstColorFactor(blend)));
+            IDirect3DDevice9_SetRenderState(data->device, D3DRS_BLENDOP,
+                                            GetBlendEquation(SDL_GetBlendModeColorOperation(blend)));
             if (data->enableSeparateAlphaBlend) {
                 IDirect3DDevice9_SetRenderState(data->device, D3DRS_SRCBLENDALPHA,
                                                 GetBlendFunc(SDL_GetBlendModeSrcAlphaFactor(blend)));
                 IDirect3DDevice9_SetRenderState(data->device, D3DRS_DESTBLENDALPHA,
                                                 GetBlendFunc(SDL_GetBlendModeDstAlphaFactor(blend)));
+                IDirect3DDevice9_SetRenderState(data->device, D3DRS_BLENDOPALPHA,
+                                                GetBlendEquation(SDL_GetBlendModeAlphaOperation(blend)));
             }
         }
 
diff --git a/Engine/lib/sdl/src/render/direct3d11/SDL_render_d3d11.c b/Engine/lib/sdl/src/render/direct3d11/SDL_render_d3d11.c
index 89e2ee544..714ca2e77 100644
--- a/Engine/lib/sdl/src/render/direct3d11/SDL_render_d3d11.c
+++ b/Engine/lib/sdl/src/render/direct3d11/SDL_render_d3d11.c
@@ -998,6 +998,16 @@ D3D11_CreateWindowSizeDependentResources(SDL_Renderer * renderer)
         goto done;
     }
 
+    /* Set the swap chain target immediately, so that a target is always set
+     * even before we get to SetDrawState. Without this it's possible to hit
+     * null references in places like ReadPixels!
+     */
+    ID3D11DeviceContext_OMSetRenderTargets(data->d3dContext,
+        1,
+        &data->mainRenderTargetView,
+        NULL
+        );
+
     data->viewportDirty = SDL_TRUE;
 
 done:
diff --git a/Engine/lib/sdl/src/render/opengl/SDL_render_gl.c b/Engine/lib/sdl/src/render/opengl/SDL_render_gl.c
index b5df73ace..b5af52af3 100644
--- a/Engine/lib/sdl/src/render/opengl/SDL_render_gl.c
+++ b/Engine/lib/sdl/src/render/opengl/SDL_render_gl.c
@@ -30,6 +30,11 @@
 #include <OpenGL/OpenGL.h>
 #endif
 
+#ifdef SDL_VIDEO_VITA_PVR_OGL
+#include <GL/gl.h>
+#include <GL/glext.h>
+#endif
+
 /* To prevent unnecessary window recreation, 
  * these should match the defaults selected in SDL_GL_ResetAttributes 
  */
@@ -319,6 +324,20 @@ GL_GetFBO(GL_RenderData *data, Uint32 w, Uint32 h)
     return result;
 }
 
+static void
+GL_WindowEvent(SDL_Renderer * renderer, const SDL_WindowEvent *event)
+{
+    /* If the window x/y/w/h changed at all, assume the viewport has been
+     * changed behind our backs. x/y changes might seem weird but viewport
+     * resets have been observed on macOS at minimum!
+     */
+    if (event->event == SDL_WINDOWEVENT_SIZE_CHANGED ||
+        event->event == SDL_WINDOWEVENT_MOVED) {
+        GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
+        data->drawstate.viewport_dirty = SDL_TRUE;
+    }
+}
+
 static int
 GL_GetOutputSize(SDL_Renderer * renderer, int *w, int *h)
 {
@@ -1212,9 +1231,9 @@ GL_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertic
     }
 
 #ifdef __MACOSX__
-    // On macOS, moving the window seems to invalidate the OpenGL viewport state,
-    // so don't bother trying to persist it across frames; always reset it.
-    // Workaround for: https://github.com/libsdl-org/SDL/issues/1504
+    // On macOS on older systems, the OpenGL view change and resize events aren't
+    // necessarily synchronized, so just always reset it.
+    // Workaround for: https://discourse.libsdl.org/t/sdl-2-0-22-prerelease/35306/6
     data->drawstate.viewport_dirty = SDL_TRUE;
 #endif
 
@@ -1733,6 +1752,7 @@ GL_CreateRenderer(SDL_Window * window, Uint32 flags)
     SDL_GL_GetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, &major);
     SDL_GL_GetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, &minor);
 
+#ifndef SDL_VIDEO_VITA_PVR_OGL
     window_flags = SDL_GetWindowFlags(window);
     if (!(window_flags & SDL_WINDOW_OPENGL) ||
         profile_mask == SDL_GL_CONTEXT_PROFILE_ES || major != RENDERER_CONTEXT_MAJOR || minor != RENDERER_CONTEXT_MINOR) {
@@ -1746,6 +1766,7 @@ GL_CreateRenderer(SDL_Window * window, Uint32 flags)
             goto error;
         }
     }
+#endif
 
     renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
     if (!renderer) {
@@ -1760,6 +1781,7 @@ GL_CreateRenderer(SDL_Window * window, Uint32 flags)
         goto error;
     }
 
+    renderer->WindowEvent = GL_WindowEvent;
     renderer->GetOutputSize = GL_GetOutputSize;
     renderer->SupportsBlendMode = GL_SupportsBlendMode;
     renderer->CreateTexture = GL_CreateTexture;
diff --git a/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm.c b/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm.c
index 8a8877849..98b03e629 100644
--- a/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm.c
+++ b/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm.c
@@ -61,6 +61,11 @@ static int VITA_GXM_UpdateTextureYUV(SDL_Renderer * renderer, SDL_Texture * text
     const Uint8 *Uplane, int Upitch,
     const Uint8 *Vplane, int Vpitch);
 
+static int VITA_GXM_UpdateTextureNV(SDL_Renderer * renderer, SDL_Texture * texture,
+    const SDL_Rect * rect,
+    const Uint8 *Yplane, int Ypitch,
+    const Uint8 *UVplane, int UVpitch);
+
 static int VITA_GXM_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture,
     const SDL_Rect *rect, void **pixels, int *pitch);
 
@@ -105,12 +110,16 @@ SDL_RenderDriver VITA_GXM_RenderDriver = {
     .info = {
         .name = "VITA gxm",
         .flags = SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_TARGETTEXTURE,
-        .num_texture_formats = 4,
+        .num_texture_formats = 8,
         .texture_formats = {
             [0] = SDL_PIXELFORMAT_ABGR8888,
             [1] = SDL_PIXELFORMAT_ARGB8888,
             [2] = SDL_PIXELFORMAT_RGB565,
-            [3] = SDL_PIXELFORMAT_BGR565
+            [3] = SDL_PIXELFORMAT_BGR565,
+            [4] = SDL_PIXELFORMAT_YV12,
+            [5] = SDL_PIXELFORMAT_IYUV,
+            [6] = SDL_PIXELFORMAT_NV12,
+            [7] = SDL_PIXELFORMAT_NV21,
         },
         .max_texture_width = 4096,
         .max_texture_height = 4096,
@@ -133,6 +142,15 @@ PixelFormatToVITAFMT(Uint32 format)
         return SCE_GXM_TEXTURE_FORMAT_U5U6U5_RGB;
     case SDL_PIXELFORMAT_BGR565:
         return SCE_GXM_TEXTURE_FORMAT_U5U6U5_BGR;
+    case SDL_PIXELFORMAT_YV12:
+        return SCE_GXM_TEXTURE_FORMAT_YVU420P3_CSC0;
+    case SDL_PIXELFORMAT_IYUV:
+        return SCE_GXM_TEXTURE_FORMAT_YUV420P3_CSC0;
+    // should be the other way around. looks like SCE bug.
+    case SDL_PIXELFORMAT_NV12:
+        return SCE_GXM_TEXTURE_FORMAT_YVU420P2_CSC0;
+    case SDL_PIXELFORMAT_NV21:
+        return SCE_GXM_TEXTURE_FORMAT_YUV420P2_CSC0;
     default:
         return SCE_GXM_TEXTURE_FORMAT_U8U8U8U8_ABGR;
     }
@@ -228,6 +246,7 @@ VITA_GXM_CreateRenderer(SDL_Window *window, Uint32 flags)
     renderer->UpdateTexture = VITA_GXM_UpdateTexture;
 #if SDL_HAVE_YUV
     renderer->UpdateTextureYUV = VITA_GXM_UpdateTextureYUV;
+    renderer->UpdateTextureNV = VITA_GXM_UpdateTextureNV;
 #endif
     renderer->LockTexture = VITA_GXM_LockTexture;
     renderer->UnlockTexture = VITA_GXM_UnlockTexture;
@@ -295,7 +314,17 @@ VITA_GXM_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture)
         return SDL_OutOfMemory();
     }
 
-    vita_texture->tex = create_gxm_texture(data, texture->w, texture->h, PixelFormatToVITAFMT(texture->format), (texture->access == SDL_TEXTUREACCESS_TARGET));
+    vita_texture->tex = create_gxm_texture(
+        data,
+        texture->w,
+        texture->h,
+        PixelFormatToVITAFMT(texture->format),
+        (texture->access == SDL_TEXTUREACCESS_TARGET),
+        &(vita_texture->w),
+        &(vita_texture->h),
+        &(vita_texture->pitch),
+        &(vita_texture->wscale)
+    );
 
     if (!vita_texture->tex) {
         SDL_free(vita_texture);
@@ -306,38 +335,129 @@ VITA_GXM_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture)
 
     VITA_GXM_SetTextureScaleMode(renderer, texture, texture->scaleMode);
 
-    vita_texture->w = gxm_texture_get_width(vita_texture->tex);
-    vita_texture->h = gxm_texture_get_height(vita_texture->tex);
-    vita_texture->pitch = gxm_texture_get_stride(vita_texture->tex);
+#if SDL_HAVE_YUV
+    vita_texture->yuv = ((texture->format == SDL_PIXELFORMAT_IYUV) || (texture->format == SDL_PIXELFORMAT_YV12));
+    vita_texture->nv12 = ((texture->format == SDL_PIXELFORMAT_NV12) || (texture->format == SDL_PIXELFORMAT_NV21));
+#endif
 
     return 0;
 }
 
+static void VITA_GXM_SetYUVProfile(SDL_Renderer * renderer, SDL_Texture *texture)
+{
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
+    int ret = 0;
+    switch (SDL_GetYUVConversionModeForResolution(texture->w, texture->h)) {
+    case SDL_YUV_CONVERSION_BT601:
+        ret = sceGxmSetYuvProfile(data->gxm_context, 0, SCE_GXM_YUV_PROFILE_BT601_STANDARD);
+        break;
+    case SDL_YUV_CONVERSION_BT709:
+        ret = sceGxmSetYuvProfile(data->gxm_context, 0, SCE_GXM_YUV_PROFILE_BT709_STANDARD);
+        break;
+    case SDL_YUV_CONVERSION_JPEG:
+    default:
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "Unsupported YUV profile: %d\n", SDL_GetYUVConversionModeForResolution(texture->w, texture->h));
+        break;
+  }
+
+  if (ret < 0) {
+      SDL_LogError(SDL_LOG_CATEGORY_RENDER, "Setting YUV profile failed: %x\n", ret);
+  }
+}
 
 static int
 VITA_GXM_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture,
     const SDL_Rect *rect, const void *pixels, int pitch)
 {
-    const Uint8 *src;
+    VITA_GXM_TextureData *vita_texture = (VITA_GXM_TextureData *) texture->driverdata;
     Uint8 *dst;
-    int row, length,dpitch;
-    src = pixels;
+    int row, length, dpitch;
+
+#if SDL_HAVE_YUV
+    if (vita_texture->yuv || vita_texture->nv12) {
+        VITA_GXM_SetYUVProfile(renderer, texture);
+    }
+#endif
 
     VITA_GXM_LockTexture(renderer, texture, rect, (void **)&dst, &dpitch);
     length = rect->w * SDL_BYTESPERPIXEL(texture->format);
     if (length == pitch && length == dpitch) {
-        SDL_memcpy(dst, src, length*rect->h);
+        SDL_memcpy(dst, pixels, length*rect->h);
     } else {
         for (row = 0; row < rect->h; ++row) {
-            SDL_memcpy(dst, src, length);
-            src += pitch;
+            SDL_memcpy(dst, pixels, length);
+            pixels += pitch;
             dst += dpitch;
         }
     }
 
+#if SDL_HAVE_YUV
+    if (vita_texture->yuv) {
+        void *Udst;
+        void *Vdst;
+        int uv_pitch = (dpitch+1) / 2;
+        int uv_src_pitch = (pitch+1) / 2;
+        SDL_Rect UVrect = {rect->x / 2, rect->y / 2, (rect->w + 1) / 2, (rect->h + 1) / 2};
+
+        // skip Y plane
+        Uint8 *Dpixels = gxm_texture_get_datap(vita_texture->tex) + (vita_texture->pitch * vita_texture->h);
+
+        Udst = Dpixels + (UVrect.y * uv_pitch) + UVrect.x;
+        Vdst = Dpixels + (uv_pitch * ((vita_texture->h + 1) / 2)) + (UVrect.y * uv_pitch) + UVrect.x;
+
+        length = UVrect.w;
+
+        // U plane
+        if (length == uv_src_pitch && length == uv_pitch) {
+            SDL_memcpy(Udst, pixels, length*UVrect.h);
+        } else {
+            for (row = 0; row < UVrect.h; ++row) {
+                SDL_memcpy(Udst, pixels, length);
+                pixels += uv_src_pitch;
+                Udst += uv_pitch;
+            }
+        }
+
+        // V plane
+        if (length == uv_src_pitch && length == uv_pitch) {
+            SDL_memcpy(Vdst, pixels, length*UVrect.h);
+        } else {
+            for (row = 0; row < UVrect.h; ++row) {
+                SDL_memcpy(Vdst, pixels, length);
+                pixels += uv_src_pitch;
+                Vdst += uv_pitch;
+            }
+        }
+
+    } else if (vita_texture->nv12) {
+        void *UVdst;
+        int uv_pitch = 2 * ((dpitch+1) / 2);
+        int uv_src_pitch = 2 * ((pitch+1) / 2);
+        SDL_Rect UVrect = {rect->x / 2, rect->y / 2, (rect->w + 1) / 2 , (rect->h + 1) / 2};
+
+        // skip Y plane
+        void *Dpixels = (void *) ((Uint8 *) gxm_texture_get_datap(vita_texture->tex) + (vita_texture->pitch * vita_texture->h));
+        UVdst = Dpixels + (UVrect.y * uv_pitch) + UVrect.x;
+
+        length = UVrect.w*2;
+
+        // UV plane
+        if (length == uv_src_pitch && length == uv_pitch) {
+            SDL_memcpy(UVdst, pixels, length*UVrect.h);
+        } else {
+            for (row = 0; row < UVrect.h; ++row) {
+                SDL_memcpy(UVdst, pixels, length);
+                pixels += uv_src_pitch;
+                UVdst += uv_pitch;
+            }
+        }
+    }
+#endif
+
     return 0;
 }
 
+#if SDL_HAVE_YUV
 static int
 VITA_GXM_UpdateTextureYUV(SDL_Renderer * renderer, SDL_Texture * texture,
     const SDL_Rect * rect,
@@ -345,9 +465,133 @@ VITA_GXM_UpdateTextureYUV(SDL_Renderer * renderer, SDL_Texture * texture,
     const Uint8 *Uplane, int Upitch,
     const Uint8 *Vplane, int Vpitch)
 {
+    Uint8 *dst;
+    int row, length, dpitch;
+    SDL_Rect UVrect = {rect->x / 2, rect->y / 2, (rect->w + 1) / 2, (rect->h + 1) / 2};
+
+    VITA_GXM_SetYUVProfile(renderer, texture);
+
+    // copy Y plane
+    // obtain pixels via locking so that texture is flushed
+    VITA_GXM_LockTexture(renderer, texture, rect, (void **)&dst, &dpitch);
+
+    length = rect->w;
+
+    if (length == Ypitch && length == dpitch) {
+        SDL_memcpy(dst, Yplane, length*rect->h);
+    } else {
+        for (row = 0; row < rect->h; ++row) {
+            SDL_memcpy(dst, Yplane, length);
+            Yplane += Ypitch;
+            dst += dpitch;
+        }
+    }
+
+    // U/V planes
+    {
+        void *Udst;
+        void *Vdst;
+        VITA_GXM_TextureData *vita_texture = (VITA_GXM_TextureData *) texture->driverdata;
+        int uv_pitch = (dpitch+1) / 2;
+
+        // skip Y plane
+        void *pixels = (void *) ((Uint8 *) gxm_texture_get_datap(vita_texture->tex) + (vita_texture->pitch * vita_texture->h));
+
+        if (texture->format == SDL_PIXELFORMAT_YV12) { // YVU
+            Vdst = pixels + (UVrect.y * uv_pitch) + UVrect.x;
+            Udst = pixels + (uv_pitch * ((vita_texture->h + 1) / 2)) + (UVrect.y * uv_pitch) + UVrect.x;
+        } else { // YUV
+            Udst = pixels + (UVrect.y * uv_pitch) + UVrect.x;
+            Vdst = pixels + (uv_pitch * ((vita_texture->h + 1) / 2)) + (UVrect.y * uv_pitch) + UVrect.x;
+        }
+
+        length = UVrect.w;
+
+        // U plane
+        if (length == Upitch && length == uv_pitch) {
+            SDL_memcpy(Udst, Uplane, length*UVrect.h);
+        } else {
+            for (row = 0; row < UVrect.h; ++row) {
+                SDL_memcpy(Udst, Uplane, length);
+                Uplane += Upitch;
+                Udst += uv_pitch;
+            }
+        }
+
+        // V plane
+        if (length == Vpitch && length == uv_pitch) {
+            SDL_memcpy(Vdst, Vplane, length*UVrect.h);
+        } else {
+            for (row = 0; row < UVrect.h; ++row) {
+                SDL_memcpy(Vdst, Vplane, length);
+                Vplane += Vpitch;
+                Vdst += uv_pitch;
+            }
+        }
+
+    }
+
     return 0;
 }
 
+static int
+VITA_GXM_UpdateTextureNV(SDL_Renderer * renderer, SDL_Texture * texture,
+    const SDL_Rect * rect,
+    const Uint8 *Yplane, int Ypitch,
+    const Uint8 *UVplane, int UVpitch)
+{
+
+    Uint8 *dst;
+    int row, length, dpitch;
+    SDL_Rect UVrect = {rect->x / 2, rect->y / 2, (rect->w + 1) / 2, (rect->h + 1) / 2};
+
+    VITA_GXM_SetYUVProfile(renderer, texture);
+
+    // copy Y plane
+    VITA_GXM_LockTexture(renderer, texture, rect, (void **)&dst, &dpitch);
+
+    length = rect->w * SDL_BYTESPERPIXEL(texture->format);
+
+    if (length == Ypitch && length == dpitch) {
+      SDL_memcpy(dst, Yplane, length*rect->h);
+    } else {
+        for (row = 0; row < rect->h; ++row) {
+          SDL_memcpy(dst, Yplane, length);
+            Yplane += Ypitch;
+            dst += dpitch;
+        }
+    }
+
+    // UV plane
+    {
+        void *UVdst;
+        VITA_GXM_TextureData *vita_texture = (VITA_GXM_TextureData *) texture->driverdata;
+        int uv_pitch = 2 * ((dpitch+1) / 2);
+
+        // skip Y plane
+        void *pixels = (void *) ((Uint8 *) gxm_texture_get_datap(vita_texture->tex) + (vita_texture->pitch * vita_texture->h));
+
+        UVdst = pixels + (UVrect.y * uv_pitch) + UVrect.x;
+
+        length = UVrect.w * 2;
+
+        // UV plane
+        if (length == UVpitch && length == uv_pitch) {
+            SDL_memcpy(UVdst, UVplane, length*UVrect.h);
+        } else {
+            for (row = 0; row < UVrect.h; ++row) {
+                SDL_memcpy(UVdst, UVplane, length);
+                UVplane += UVpitch;
+                UVdst += uv_pitch;
+            }
+        }
+    }
+
+    return 0;
+}
+
+#endif
+
 static int
 VITA_GXM_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture,
     const SDL_Rect *rect, void **pixels, int *pitch)
@@ -519,6 +763,7 @@ VITA_GXM_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Textu
     size_indices = indices ? size_indices : 0;
 
     if (texture) {
+        VITA_GXM_TextureData* vita_texture = (VITA_GXM_TextureData*) texture->driverdata;
         texture_vertex *vertices;
 
         vertices = (texture_vertex *)pool_malloc(
@@ -551,7 +796,7 @@ VITA_GXM_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Textu
 
             vertices[i].x = xy_[0] * scale_x;
             vertices[i].y = xy_[1] * scale_y;
-            vertices[i].u = uv_[0];
+            vertices[i].u = uv_[0] * vita_texture->wscale;
             vertices[i].v = uv_[1];
             vertices[i].color = col_;
         }
@@ -730,14 +975,6 @@ SetDrawState(VITA_GXM_RenderData *data, const SDL_RenderCommand *cmd)
     return 0;
 }
 
-static int
-SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd)
-{
-    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
-
-    return SetDrawState(data, cmd);
-}
-
 static int
 VITA_GXM_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
 {
@@ -824,11 +1061,7 @@ VITA_GXM_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *
                     nextcmd = nextcmd->next;
                 }
 
-                if (thistexture) {
-                    ret = SetCopyState(renderer, cmd);
-                } else {
-                    ret = SetDrawState(data, cmd);
-                }
+                ret = SetDrawState(data, cmd);
 
                 if (ret == 0) {
                     int op = SCE_GXM_PRIMITIVE_TRIANGLES;
@@ -1013,7 +1246,7 @@ VITA_GXM_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture)
 
     sceGxmFinish(data->gxm_context);
 
-    free_gxm_texture(vita_texture->tex);
+    free_gxm_texture(data, vita_texture->tex);
 
     SDL_free(vita_texture);
 
diff --git a/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_memory.c b/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_memory.c
index d3322730a..85d682ad7 100644
--- a/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_memory.c
+++ b/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_memory.c
@@ -26,7 +26,7 @@
 #include "SDL_render_vita_gxm_memory.h"
 
 void *
-mem_gpu_alloc(SceKernelMemBlockType type, unsigned int size, unsigned int alignment, unsigned int attribs, SceUID *uid)
+vita_mem_alloc(unsigned int type, unsigned int size, unsigned int alignment, unsigned int attribs, SceUID *uid)
 {
     void *mem;
 
@@ -51,7 +51,7 @@ mem_gpu_alloc(SceKernelMemBlockType type, unsigned int size, unsigned int alignm
 }
 
 void
-mem_gpu_free(SceUID uid)
+vita_mem_free(SceUID uid)
 {
     void *mem = NULL;
     if (sceKernelGetMemBlockBase(uid, &mem) < 0)
@@ -61,7 +61,71 @@ mem_gpu_free(SceUID uid)
 }
 
 void *
-mem_vertex_usse_alloc(unsigned int size, SceUID *uid, unsigned int *usse_offset)
+vita_gpu_mem_alloc(VITA_GXM_RenderData *data, unsigned int size)
+{
+    void *mem;
+
+    if (data->texturePool == NULL) {
+        int poolsize;
+        int ret;
+        SceKernelFreeMemorySizeInfo info;
+        info.size = sizeof(SceKernelFreeMemorySizeInfo);
+        sceKernelGetFreeMemorySize(&info);
+
+        poolsize = ALIGN(info.size_cdram, 256*1024);
+        if (poolsize > info.size_cdram) {
+            poolsize = ALIGN(info.size_cdram - 256*1024, 256*1024);
+        }
+        data->texturePoolUID = sceKernelAllocMemBlock("gpu_texture_pool", SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW, poolsize, NULL);
+        if (data->texturePoolUID < 0) {
+            return NULL;
+        }
+
+        ret = sceKernelGetMemBlockBase(data->texturePoolUID, &mem);
+        if ( ret < 0)
+        {
+            return NULL;
+        }
+        data->texturePool = sceClibMspaceCreate(mem, poolsize);
+
+        if (data->texturePool == NULL) {
+            return NULL;
+        }
+        ret = sceGxmMapMemory(mem, poolsize, SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE);
+        if (ret < 0)
+        {
+            return NULL;
+        }
+    }
+    return sceClibMspaceMemalign(data->texturePool, SCE_GXM_TEXTURE_ALIGNMENT, size);
+}
+
+void
+vita_gpu_mem_free(VITA_GXM_RenderData *data, void* ptr)
+{
+    if (data->texturePool != NULL)
+    {
+        sceClibMspaceFree(data->texturePool, ptr);
+    }
+}
+
+void
+vita_gpu_mem_destroy(VITA_GXM_RenderData *data)
+{
+    void *mem = NULL;
+    if (data->texturePool != NULL)
+    {
+        sceClibMspaceDestroy(data->texturePool);
+        data->texturePool = NULL;
+        if (sceKernelGetMemBlockBase(data->texturePoolUID, &mem) < 0)
+            return;
+        sceGxmUnmapMemory(mem);
+        sceKernelFreeMemBlock(data->texturePoolUID);
+    }
+}
+
+void *
+vita_mem_vertex_usse_alloc(unsigned int size, SceUID *uid, unsigned int *usse_offset)
 {
     void *mem = NULL;
 
@@ -77,7 +141,7 @@ mem_vertex_usse_alloc(unsigned int size, SceUID *uid, unsigned int *usse_offset)
 }
 
 void
-mem_vertex_usse_free(SceUID uid)
+vita_mem_vertex_usse_free(SceUID uid)
 {
     void *mem = NULL;
     if (sceKernelGetMemBlockBase(uid, &mem) < 0)
@@ -87,7 +151,7 @@ mem_vertex_usse_free(SceUID uid)
 }
 
 void *
-mem_fragment_usse_alloc(unsigned int size, SceUID *uid, unsigned int *usse_offset)
+vita_mem_fragment_usse_alloc(unsigned int size, SceUID *uid, unsigned int *usse_offset)
 {
     void *mem = NULL;
 
@@ -103,7 +167,7 @@ mem_fragment_usse_alloc(unsigned int size, SceUID *uid, unsigned int *usse_offse
 }
 
 void
-mem_fragment_usse_free(SceUID uid)
+vita_mem_fragment_usse_free(SceUID uid)
 {
     void *mem = NULL;
     if (sceKernelGetMemBlockBase(uid, &mem) < 0)
diff --git a/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_memory.h b/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_memory.h
index 51bc8a80a..93b9f3498 100644
--- a/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_memory.h
+++ b/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_memory.h
@@ -25,15 +25,19 @@
 #include <psp2/gxm.h>
 #include <psp2/types.h>
 #include <psp2/kernel/sysmem.h>
+#include "SDL_render_vita_gxm_types.h"
 
 #define ALIGN(x, a) (((x) + ((a) - 1)) & ~((a) - 1))
 
-void *mem_gpu_alloc(SceKernelMemBlockType type, unsigned int size, unsigned int alignment, unsigned int attribs, SceUID *uid);
-void mem_gpu_free(SceUID uid);
-void *mem_vertex_usse_alloc(unsigned int size, SceUID *uid, unsigned int *usse_offset);
-void mem_vertex_usse_free(SceUID uid);
-void *mem_fragment_usse_alloc(unsigned int size, SceUID *uid, unsigned int *usse_offset);
-void mem_fragment_usse_free(SceUID uid);
+void *vita_mem_alloc(unsigned int type, unsigned int size, unsigned int alignment, unsigned int attribs, SceUID *uid);
+void vita_mem_free(SceUID uid);
+void *vita_gpu_mem_alloc(VITA_GXM_RenderData *data, unsigned int size);
+void vita_gpu_mem_free(VITA_GXM_RenderData *data, void* ptr);
+void vita_gpu_mem_destroy(VITA_GXM_RenderData *data);
+void *vita_mem_vertex_usse_alloc(unsigned int size, SceUID *uid, unsigned int *usse_offset);
+void vita_mem_vertex_usse_free(SceUID uid);
+void *vita_mem_fragment_usse_alloc(unsigned int size, SceUID *uid, unsigned int *usse_offset);
+void vita_mem_fragment_usse_free(SceUID uid);
 
 #endif /* SDL_RENDER_VITA_GXM_MEMORY_H */
 
diff --git a/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_tools.c b/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_tools.c
index e043b55ab..035e8a63c 100644
--- a/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_tools.c
+++ b/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_tools.c
@@ -117,6 +117,8 @@ tex_format_to_bytespp(SceGxmTextureFormat format)
     case SCE_GXM_TEXTURE_BASE_FORMAT_U8:
     case SCE_GXM_TEXTURE_BASE_FORMAT_S8:
     case SCE_GXM_TEXTURE_BASE_FORMAT_P8:
+    case SCE_GXM_TEXTURE_BASE_FORMAT_YUV420P2: // YUV actually uses 12 bits per pixel. UV planes bits/mem are handled elsewhere
+    case SCE_GXM_TEXTURE_BASE_FORMAT_YUV420P3:
         return 1;
     case SCE_GXM_TEXTURE_BASE_FORMAT_U4U4U4U4:
     case SCE_GXM_TEXTURE_BASE_FORMAT_U8U3U3U2:
@@ -414,28 +416,28 @@ gxm_init(SDL_Renderer *renderer)
     }
 
     // allocate ring buffer memory using default sizes
-    vdmRingBuffer = mem_gpu_alloc(
+    vdmRingBuffer = vita_mem_alloc(
         SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
         SCE_GXM_DEFAULT_VDM_RING_BUFFER_SIZE,
         4,
         SCE_GXM_MEMORY_ATTRIB_READ,
         &data->vdmRingBufferUid);
 
-    vertexRingBuffer = mem_gpu_alloc(
+    vertexRingBuffer = vita_mem_alloc(
         SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
         SCE_GXM_DEFAULT_VERTEX_RING_BUFFER_SIZE,
         4,
         SCE_GXM_MEMORY_ATTRIB_READ,
         &data->vertexRingBufferUid);
 
-    fragmentRingBuffer = mem_gpu_alloc(
+    fragmentRingBuffer = vita_mem_alloc(
         SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
         SCE_GXM_DEFAULT_FRAGMENT_RING_BUFFER_SIZE,
         4,
         SCE_GXM_MEMORY_ATTRIB_READ,
         &data->fragmentRingBufferUid);
 
-    fragmentUsseRingBuffer = mem_fragment_usse_alloc(
+    fragmentUsseRingBuffer = vita_mem_fragment_usse_alloc(
         SCE_GXM_DEFAULT_FRAGMENT_USSE_RING_BUFFER_SIZE,
         &data->fragmentUsseRingBufferUid,
         &fragmentUsseRingBufferOffset);
@@ -480,7 +482,7 @@ gxm_init(SDL_Renderer *renderer)
     for (i = 0; i < VITA_GXM_BUFFERS; i++) {
 
         // allocate memory for display
-        data->displayBufferData[i] = mem_gpu_alloc(
+        data->displayBufferData[i] = vita_mem_alloc(
             SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW,
             4 * VITA_GXM_SCREEN_STRIDE * VITA_GXM_SCREEN_HEIGHT,
             SCE_GXM_COLOR_SURFACE_ALIGNMENT,
@@ -525,7 +527,7 @@ gxm_init(SDL_Renderer *renderer)
 
 
     // allocate the depth buffer
-    data->depthBufferData = mem_gpu_alloc(
+    data->depthBufferData = vita_mem_alloc(
         SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
         4 * sampleCount,
         SCE_GXM_DEPTHSTENCIL_SURFACE_ALIGNMENT,
@@ -533,7 +535,7 @@ gxm_init(SDL_Renderer *renderer)
         &data->depthBufferUid);
 
     // allocate the stencil buffer
-    data->stencilBufferData = mem_gpu_alloc(
+    data->stencilBufferData = vita_mem_alloc(
         SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
         4 * sampleCount,
         SCE_GXM_DEPTHSTENCIL_SURFACE_ALIGNMENT,
@@ -565,19 +567,19 @@ gxm_init(SDL_Renderer *renderer)
 
 
     // allocate memory for buffers and USSE code
-    patcherBuffer = mem_gpu_alloc(
+    patcherBuffer = vita_mem_alloc(
         SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
         patcherBufferSize,
         4,
         SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE,
         &data->patcherBufferUid);
 
-    patcherVertexUsse = mem_vertex_usse_alloc(
+    patcherVertexUsse = vita_mem_vertex_usse_alloc(
         patcherVertexUsseSize,
         &data->patcherVertexUsseUid,
         &patcherVertexUsseOffset);
 
-    patcherFragmentUsse = mem_fragment_usse_alloc(
+    patcherFragmentUsse = vita_mem_fragment_usse_alloc(
         patcherFragmentUsseSize,
         &data->patcherFragmentUsseUid,
         &patcherFragmentUsseOffset);
@@ -728,7 +730,7 @@ gxm_init(SDL_Renderer *renderer)
         }
 
         // create the clear triangle vertex/index data
-        data->clearVertices = (clear_vertex *)mem_gpu_alloc(
+        data->clearVertices = (clear_vertex *)vita_mem_alloc(
             SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
             3*sizeof(clear_vertex),
             4,
@@ -740,7 +742,7 @@ gxm_init(SDL_Renderer *renderer)
     // Allocate a 64k * 2 bytes = 128 KiB buffer and store all possible
     // 16-bit indices in linear ascending order, so we can use this for
     // all drawing operations where we don't want to use indexing.
-    data->linearIndices = (uint16_t *)mem_gpu_alloc(
+    data->linearIndices = (uint16_t *)vita_mem_alloc(
         SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
         UINT16_MAX*sizeof(uint16_t),
         sizeof(uint16_t),
@@ -871,7 +873,7 @@ gxm_init(SDL_Renderer *renderer)
     data->textureWvpParam = (SceGxmProgramParameter *)sceGxmProgramFindParameterByName(textureVertexProgramGxp, "wvp");
 
     // Allocate memory for the memory pool
-    data->pool_addr[0] = mem_gpu_alloc(
+    data->pool_addr[0] = vita_mem_alloc(
         SCE_KERNEL_MEMBLOCK_TYPE_USER_RW,
         VITA_GXM_POOL_SIZE,
         sizeof(void *),
@@ -879,7 +881,7 @@ gxm_init(SDL_Renderer *renderer)
         &data->poolUid[0]
     );
 
-    data->pool_addr[1] = mem_gpu_alloc(
+    data->pool_addr[1] = vita_mem_alloc(
         SCE_KERNEL_MEMBLOCK_TYPE_USER_RW,
         VITA_GXM_POOL_SIZE,
         sizeof(void *),
@@ -918,28 +920,28 @@ void gxm_finish(SDL_Renderer *renderer)
     free_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_mod);
     free_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_mul);
 
-    mem_gpu_free(data->linearIndicesUid);
-    mem_gpu_free(data->clearVerticesUid);
+    vita_mem_free(data->linearIndicesUid);
+    vita_mem_free(data->clearVerticesUid);
 
     // wait until display queue is finished before deallocating display buffers
     sceGxmDisplayQueueFinish();
 
     // clean up display queue
-    mem_gpu_free(data->depthBufferUid);
+    vita_mem_free(data->depthBufferUid);
 
     for (size_t i = 0; i < VITA_GXM_BUFFERS; i++)
     {
         // clear the buffer then deallocate
         SDL_memset(data->displayBufferData[i], 0, VITA_GXM_SCREEN_HEIGHT * VITA_GXM_SCREEN_STRIDE * 4);
-        mem_gpu_free(data->displayBufferUid[i]);
+        vita_mem_free(data->displayBufferUid[i]);
 
         // destroy the sync object
         sceGxmSyncObjectDestroy(data->displayBufferSync[i]);
     }
 
     // Free the depth and stencil buffer
-    mem_gpu_free(data->depthBufferUid);
-    mem_gpu_free(data->stencilBufferUid);
+    vita_mem_free(data->depthBufferUid);
+    vita_mem_free(data->stencilBufferUid);
 
     // unregister programs and destroy shader patcher
     sceGxmShaderPatcherUnregisterProgram(data->shaderPatcher, data->clearFragmentProgramId);
@@ -950,23 +952,24 @@ void gxm_finish(SDL_Renderer *renderer)
     sceGxmShaderPatcherUnregisterProgram(data->shaderPatcher, data->textureVertexProgramId);
 
     sceGxmShaderPatcherDestroy(data->shaderPatcher);
-    mem_fragment_usse_free(data->patcherFragmentUsseUid);
-    mem_vertex_usse_free(data->patcherVertexUsseUid);
-    mem_gpu_free(data->patcherBufferUid);
+    vita_mem_fragment_usse_free(data->patcherFragmentUsseUid);
+    vita_mem_vertex_usse_free(data->patcherVertexUsseUid);
+    vita_mem_free(data->patcherBufferUid);
 
     // destroy the render target
     sceGxmDestroyRenderTarget(data->renderTarget);
 
     // destroy the gxm context
     sceGxmDestroyContext(data->gxm_context);
-    mem_fragment_usse_free(data->fragmentUsseRingBufferUid);
-    mem_gpu_free(data->fragmentRingBufferUid);
-    mem_gpu_free(data->vertexRingBufferUid);
-    mem_gpu_free(data->vdmRingBufferUid);
+    vita_mem_fragment_usse_free(data->fragmentUsseRingBufferUid);
+    vita_mem_free(data->fragmentRingBufferUid);
+    vita_mem_free(data->vertexRingBufferUid);
+    vita_mem_free(data->vdmRingBufferUid);
     SDL_free(data->contextParams.hostMem);
 
-    mem_gpu_free(data->poolUid[0]);
-    mem_gpu_free(data->poolUid[1]);
+    vita_mem_free(data->poolUid[0]);
+    vita_mem_free(data->poolUid[1]);
+    vita_gpu_mem_destroy(data);
 
     // terminate libgxm
     sceGxmTerminate();
@@ -975,16 +978,20 @@ void gxm_finish(SDL_Renderer *renderer)
 // textures
 
 void
-free_gxm_texture(gxm_texture *texture)
+free_gxm_texture(VITA_GXM_RenderData *data, gxm_texture *texture)
 {
     if (texture) {
         if (texture->gxm_rendertarget) {
             sceGxmDestroyRenderTarget(texture->gxm_rendertarget);
         }
         if (texture->depth_UID) {
-            mem_gpu_free(texture->depth_UID);
+            vita_mem_free(texture->depth_UID);
+        }
+        if (texture->cdram) {
+            vita_gpu_mem_free(data, sceGxmTextureGetData(&texture->gxm_tex));
+        } else {
+            vita_mem_free(texture->data_UID);
         }
-        mem_gpu_free(texture->data_UID);
         SDL_free(texture);
     }
 }
@@ -995,25 +1002,6 @@ gxm_texture_get_format(const gxm_texture *texture)
     return sceGxmTextureGetFormat(&texture->gxm_tex);
 }
 
-unsigned int
-gxm_texture_get_width(const gxm_texture *texture)
-{
-    return sceGxmTextureGetWidth(&texture->gxm_tex);
-}
-
-unsigned int
-gxm_texture_get_height(const gxm_texture *texture)
-{
-    return sceGxmTextureGetHeight(&texture->gxm_tex);
-}
-
-unsigned int
-gxm_texture_get_stride(const gxm_texture *texture)
-{
-    return ((gxm_texture_get_width(texture) + 7) & ~7)
-        * tex_format_to_bytespp(gxm_texture_get_format(texture));
-}
-
 void *
 gxm_texture_get_datap(const gxm_texture *texture)
 {
@@ -1021,34 +1009,53 @@ gxm_texture_get_datap(const gxm_texture *texture)
 }
 
 gxm_texture *
-create_gxm_texture(VITA_GXM_RenderData *data, unsigned int w, unsigned int h, SceGxmTextureFormat format, unsigned int isRenderTarget)
+create_gxm_texture(VITA_GXM_RenderData *data, unsigned int w, unsigned int h, SceGxmTextureFormat format, unsigned int isRenderTarget, unsigned int *return_w, unsigned int *return_h, unsigned int *return_pitch, float *return_wscale)
 {
     gxm_texture *texture = SDL_calloc(1, sizeof(gxm_texture));
-    const int tex_size =  ((w + 7) & ~ 7) * h * tex_format_to_bytespp(format);
+    int aligned_w = ALIGN(w, 8);
+    int texture_w = w;
+    int tex_size =  aligned_w * h * tex_format_to_bytespp(format);
     void *texture_data;
+    int ret;
+
+    *return_wscale = 1.0f;
+
+    // SCE_GXM_TEXTURE_BASE_FORMAT_YUV420P3/P2 based formats require width aligned to 16
+    if ( (format & 0x9f000000U) == SCE_GXM_TEXTURE_BASE_FORMAT_YUV420P3 || (format & 0x9f000000U) == SCE_GXM_TEXTURE_BASE_FORMAT_YUV420P2) {
+        aligned_w = ALIGN(w, 16);
+        texture_w = aligned_w;
+        tex_size =  aligned_w * h * tex_format_to_bytespp(format);
+        *return_wscale = (float) (w) / texture_w;
+        // add storage for UV planes
+        tex_size += (((aligned_w + 1) / 2) * ((h + 1) / 2)) * 2;
+    }
 
     if (!texture)
         return NULL;
 
+    *return_w = w;
+    *return_h = h;
+    *return_pitch = aligned_w * tex_format_to_bytespp(format);
+
     /* Allocate a GPU buffer for the texture */
-    texture_data = mem_gpu_alloc(
-        SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW,
-        tex_size,
-        SCE_GXM_TEXTURE_ALIGNMENT,
-        SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE,
-        &texture->data_UID
+    texture_data = vita_gpu_mem_alloc(
+        data,
+        tex_size
     );
 
     /* Try SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE in case we're out of VRAM */
     if (!texture_data) {
         SDL_LogWarn(SDL_LOG_CATEGORY_RENDER, "CDRAM texture allocation failed\n");
-        texture_data = mem_gpu_alloc(
+        texture_data = vita_mem_alloc(
             SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
             tex_size,
             SCE_GXM_TEXTURE_ALIGNMENT,
             SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE,
             &texture->data_UID
         );
+        texture->cdram = 0;
+    } else {
+        texture->cdram = 1;
     }
 
     if (!texture_data) {
@@ -1060,7 +1067,12 @@ create_gxm_texture(VITA_GXM_RenderData *data, unsigned int w, unsigned int h, Sc
     SDL_memset(texture_data, 0, tex_size);
 
     /* Create the gxm texture */
-    sceGxmTextureInitLinear( &texture->gxm_tex, texture_data, format, w, h, 0);
+    ret = sceGxmTextureInitLinear( &texture->gxm_tex, texture_data, format, texture_w, h, 0);
+    if (ret < 0) {
+      free_gxm_texture(data, texture);
+      SDL_LogError(SDL_LOG_CATEGORY_RENDER, "texture init failed: %x\n", ret);
+      return NULL;
+    }
 
     if (isRenderTarget) {
         void *depthBufferData;
@@ -1083,13 +1095,13 @@ create_gxm_texture(VITA_GXM_RenderData *data, unsigned int w, unsigned int h, Sc
         );
 
         if (err < 0) {
-            free_gxm_texture(texture);
-            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "color surface init failed: %d\n", err);
+            free_gxm_texture(data, texture);
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "color surface init failed: %x\n", err);
             return NULL;
         }
 
         // allocate it
-        depthBufferData = mem_gpu_alloc(
+        depthBufferData = vita_mem_alloc(
             SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
             4*sampleCount,
             SCE_GXM_DEPTHSTENCIL_SURFACE_ALIGNMENT,
@@ -1106,8 +1118,8 @@ create_gxm_texture(VITA_GXM_RenderData *data, unsigned int w, unsigned int h, Sc
             NULL);
 
         if (err < 0) {
-            free_gxm_texture(texture);
-            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "depth stencil init failed: %d\n", err);
+            free_gxm_texture(data, texture);
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "depth stencil init failed: %x\n", err);
             return NULL;
         }
 
@@ -1131,8 +1143,8 @@ create_gxm_texture(VITA_GXM_RenderData *data, unsigned int w, unsigned int h, Sc
             texture->gxm_rendertarget = tgt;
 
             if (err < 0) {
-                free_gxm_texture(texture);
-                SDL_LogError(SDL_LOG_CATEGORY_RENDER, "create render target failed: %d\n", err);
+                free_gxm_texture(data, texture);
+                SDL_LogError(SDL_LOG_CATEGORY_RENDER, "create render target failed: %x\n", err);
                 return NULL;
             }
         }
@@ -1181,7 +1193,7 @@ void gxm_init_for_common_dialog(void)
     for (int i = 0; i < VITA_GXM_BUFFERS; i += 1)
     {
         buffer_for_common_dialog[i].displayData.wait_vblank = SDL_TRUE;
-        buffer_for_common_dialog[i].displayData.address = mem_gpu_alloc(
+        buffer_for_common_dialog[i].displayData.address = vita_mem_alloc(
             SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW,
             4 * VITA_GXM_SCREEN_STRIDE * VITA_GXM_SCREEN_HEIGHT,
             SCE_GXM_COLOR_SURFACE_ALIGNMENT,
@@ -1229,7 +1241,7 @@ void gxm_term_for_common_dialog(void)
     sceGxmDisplayQueueFinish();
     for (int i = 0; i < VITA_GXM_BUFFERS; i += 1)
     {
-        mem_gpu_free(buffer_for_common_dialog[i].uid);
+        vita_mem_free(buffer_for_common_dialog[i].uid);
         sceGxmSyncObjectDestroy(buffer_for_common_dialog[i].sync);
     }
 }
diff --git a/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_tools.h b/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_tools.h
index 351bdc2e6..67659889d 100644
--- a/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_tools.h
+++ b/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_tools.h
@@ -48,15 +48,12 @@ void unset_clip_rectangle(VITA_GXM_RenderData *data);
 int gxm_init(SDL_Renderer *renderer);
 void gxm_finish(SDL_Renderer *renderer);
 
-gxm_texture *create_gxm_texture(VITA_GXM_RenderData *data, unsigned int w, unsigned int h, SceGxmTextureFormat format, unsigned int isRenderTarget);
-void free_gxm_texture(gxm_texture *texture);
+gxm_texture *create_gxm_texture(VITA_GXM_RenderData *data, unsigned int w, unsigned int h, SceGxmTextureFormat format, unsigned int isRenderTarget, unsigned int *return_w, unsigned int *return_h, unsigned int *return_pitch, float *return_wscale);
+void free_gxm_texture(VITA_GXM_RenderData *data, gxm_texture *texture);
 
 void gxm_texture_set_filters(gxm_texture *texture, SceGxmTextureFilter min_filter, SceGxmTextureFilter mag_filter);
 SceGxmTextureFormat gxm_texture_get_format(const gxm_texture *texture);
 
-unsigned int gxm_texture_get_width(const gxm_texture *texture);
-unsigned int gxm_texture_get_height(const gxm_texture *texture);
-unsigned int gxm_texture_get_stride(const gxm_texture *texture);
 void *gxm_texture_get_datap(const gxm_texture *texture);
 
 void gxm_minimal_init_for_common_dialog(void);
diff --git a/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_types.h b/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_types.h
index 898a92d9c..c5cbf5898 100644
--- a/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_types.h
+++ b/Engine/lib/sdl/src/render/vitagxm/SDL_render_vita_gxm_types.h
@@ -33,6 +33,7 @@
 #include <psp2/gxm.h>
 #include <psp2/types.h>
 #include <psp2/kernel/sysmem.h>
+#include <psp2/kernel/clib.h>
 
 #include <string.h>
 
@@ -79,6 +80,7 @@ typedef struct gxm_texture {
     SceGxmColorSurface gxm_colorsurface;
     SceGxmDepthStencilSurface gxm_depthstencil;
     SceUID depth_UID;
+    SDL_bool cdram;
 } gxm_texture;
 
 typedef struct fragment_programs {
@@ -186,14 +188,19 @@ typedef struct
     blend_fragment_programs blendFragmentPrograms;
 
     gxm_drawstate_cache drawstate;
+    SceClibMspace texturePool;
+    SceUID texturePoolUID;
 } VITA_GXM_RenderData;
 
 typedef struct
 {
     gxm_texture  *tex;
-    unsigned int    pitch;
-    unsigned int    w;
-    unsigned int    h;
+    unsigned int pitch;
+    unsigned int w;
+    unsigned int h;
+    float wscale;
+    SDL_bool     yuv;
+    SDL_bool     nv12;
 } VITA_GXM_TextureData;
 
 #endif /* SDL_RENDER_VITA_GXM_TYPES_H */
diff --git a/Engine/lib/sdl/src/test/SDL_test_common.c b/Engine/lib/sdl/src/test/SDL_test_common.c
index 48c6c72f0..93a0e7c74 100644
--- a/Engine/lib/sdl/src/test/SDL_test_common.c
+++ b/Engine/lib/sdl/src/test/SDL_test_common.c
@@ -1464,10 +1464,12 @@ default: return "???";
 static void
 SDLTest_PrintEvent(SDL_Event * event)
 {
+#ifndef VERBOSE_MOTION_EVENTS
     if ((event->type == SDL_MOUSEMOTION) || (event->type == SDL_FINGERMOTION)) {
         /* Mouse and finger motion are really spammy */
         return;
     }
+#endif
 
     switch (event->type) {
     case SDL_DISPLAYEVENT:
diff --git a/Engine/lib/sdl/src/thread/os2/SDL_sysmutex.c b/Engine/lib/sdl/src/thread/os2/SDL_sysmutex.c
index 984ae10fe..d3fc7a3bd 100644
--- a/Engine/lib/sdl/src/thread/os2/SDL_sysmutex.c
+++ b/Engine/lib/sdl/src/thread/os2/SDL_sysmutex.c
@@ -56,12 +56,12 @@ SDL_CreateMutex(void)
 void
 SDL_DestroyMutex(SDL_mutex * mutex)
 {
-    ULONG ulRC;
     HMTX  hMtx = (HMTX)mutex;
-
-    ulRC = DosCloseMutexSem(hMtx);
-    if (ulRC != NO_ERROR) {
-        debug_os2("DosCloseMutexSem(), rc = %u", ulRC);
+    if (hMtx != NULLHANDLE) {
+        const ULONG ulRC = DosCloseMutexSem(hMtx);
+        if (ulRC != NO_ERROR) {
+            debug_os2("DosCloseMutexSem(), rc = %u", ulRC);
+        }
     }
 }
 
diff --git a/Engine/lib/sdl/src/timer/os2/SDL_systimer.c b/Engine/lib/sdl/src/timer/os2/SDL_systimer.c
index c5bcf64b7..8a8425d29 100644
--- a/Engine/lib/sdl/src/timer/os2/SDL_systimer.c
+++ b/Engine/lib/sdl/src/timer/os2/SDL_systimer.c
@@ -39,6 +39,7 @@
 
 typedef unsigned long long  ULLONG;
 
+static SDL_bool ticks_started = SDL_FALSE;
 static ULONG    ulTmrFreq = 0;
 static ULLONG   ullTmrStart = 0;
 
@@ -46,7 +47,14 @@ void
 SDL_TicksInit(void)
 {
     ULONG ulTmrStart;  /* for 32-bit fallback. */
-    ULONG ulRC = DosTmrQueryFreq(&ulTmrFreq);
+    ULONG ulRC;
+
+    if (ticks_started) {
+        return;
+    }
+    ticks_started = SDL_TRUE;
+
+    ulRC = DosTmrQueryFreq(&ulTmrFreq);
     if (ulRC != NO_ERROR) {
         debug_os2("DosTmrQueryFreq() failed, rc = %u", ulRC);
     } else {
@@ -65,6 +73,7 @@ SDL_TicksInit(void)
 void
 SDL_TicksQuit(void)
 {
+    ticks_started = SDL_FALSE;
 }
 
 Uint64
@@ -73,7 +82,7 @@ SDL_GetTicks64(void)
     Uint64 ui64Result;
     ULLONG ullTmrNow;
 
-    if (ulTmrFreq == 0) { /* Was not initialized. */
+    if (!ticks_started) {
         SDL_TicksInit();
     }
 
diff --git a/Engine/lib/sdl/src/video/SDL_bmp.c b/Engine/lib/sdl/src/video/SDL_bmp.c
index 0987f5435..cb220440a 100644
--- a/Engine/lib/sdl/src/video/SDL_bmp.c
+++ b/Engine/lib/sdl/src/video/SDL_bmp.c
@@ -412,6 +412,12 @@ SDL_LoadBMP_RW(SDL_RWops * src, int freesrc)
             goto done;
         }
 
+        if (biBitCount >= 32) {  /* we shift biClrUsed by this value later. */
+            SDL_SetError("Unsupported or incorrect biBitCount field");
+            was_error = SDL_TRUE;
+            goto done;
+        }
+
         if (biClrUsed == 0) {
             biClrUsed = 1 << biBitCount;
         }
diff --git a/Engine/lib/sdl/src/video/SDL_egl.c b/Engine/lib/sdl/src/video/SDL_egl.c
index c9fb476b0..e62fe9931 100644
--- a/Engine/lib/sdl/src/video/SDL_egl.c
+++ b/Engine/lib/sdl/src/video/SDL_egl.c
@@ -27,7 +27,6 @@
 #endif
 #if SDL_VIDEO_DRIVER_ANDROID
 #include <android/native_window.h>
-#include "../core/android/SDL_android.h"
 #include "../video/android/SDL_androidvideo.h"
 #endif
 #if SDL_VIDEO_DRIVER_RPI
@@ -99,7 +98,7 @@
 #define DEFAULT_OGL_ES "libGLESv1_CM.so.1"
 #endif /* SDL_VIDEO_DRIVER_RPI */
 
-#if SDL_VIDEO_OPENGL
+#if SDL_VIDEO_OPENGL && !SDL_VIDEO_VITA_PVR_OGL
 #include "SDL_opengl.h"
 #endif
 
@@ -530,7 +529,7 @@ SDL_EGL_LoadLibrary(_THIS, const char *egl_path, NativeDisplayType native_displa
     }
 #endif
     /* Try the implementation-specific eglGetDisplay even if eglGetPlatformDisplay fails */
-    if (_this->egl_data->egl_display == EGL_NO_DISPLAY) {
+    if ((_this->egl_data->egl_display == EGL_NO_DISPLAY) && (_this->egl_data->eglGetDisplay != NULL)) {
         _this->egl_data->egl_display = _this->egl_data->eglGetDisplay(native_display);
     }
     if (_this->egl_data->egl_display == EGL_NO_DISPLAY) {
@@ -1062,7 +1061,7 @@ SDL_EGL_CreateContext(_THIS, EGLSurface egl_surface)
             if (SDL_GL_ExtensionSupported("GL_OES_surfaceless_context")) {
                 _this->gl_allow_no_surface = SDL_TRUE;
             }
-#if SDL_VIDEO_OPENGL
+#if SDL_VIDEO_OPENGL && !defined(SDL_VIDEO_DRIVER_VITA)
         } else {
             /* Desktop OpenGL supports it by default from version 3.0 on. */
             void (APIENTRY * glGetIntegervFunc) (GLenum pname, GLint * params);
diff --git a/Engine/lib/sdl/src/video/SDL_pixels.c b/Engine/lib/sdl/src/video/SDL_pixels.c
index b76161d03..858ccba7b 100644
--- a/Engine/lib/sdl/src/video/SDL_pixels.c
+++ b/Engine/lib/sdl/src/video/SDL_pixels.c
@@ -28,6 +28,7 @@
 #include "SDL_blit.h"
 #include "SDL_pixels_c.h"
 #include "SDL_RLEaccel_c.h"
+#include "../SDL_list.h"
 
 
 /* Lookup tables to expand partial bytes to the full 0..255 range */
@@ -1024,12 +1025,6 @@ SDL_AllocBlitMap(void)
 }
 
 
-typedef struct SDL_ListNode
-{
-    void *entry;
-    struct SDL_ListNode *next;
-} SDL_ListNode;
-
 void
 SDL_InvalidateAllBlitMap(SDL_Surface *surface)
 {
@@ -1045,40 +1040,6 @@ SDL_InvalidateAllBlitMap(SDL_Surface *surface)
     }
 }
 
-static void SDL_ListAdd(SDL_ListNode **head, void *ent);
-static void SDL_ListRemove(SDL_ListNode **head, void *ent);
-
-void
-SDL_ListAdd(SDL_ListNode **head, void *ent)
-{
-    SDL_ListNode *node = SDL_malloc(sizeof (*node));
-
-    if (node == NULL) {
-        SDL_OutOfMemory();
-        return;
-    }
-
-    node->entry = ent;
-    node->next = *head;
-    *head = node;
-}
-
-void
-SDL_ListRemove(SDL_ListNode **head, void *ent)
-{
-    SDL_ListNode **ptr = head;
-
-    while (*ptr) {
-        if ((*ptr)->entry == ent) {
-            SDL_ListNode *tmp = *ptr;
-            *ptr = (*ptr)->next;
-            SDL_free(tmp);
-            return;
-        }
-        ptr = &(*ptr)->next;
-    }
-}
-
 void
 SDL_InvalidateMap(SDL_BlitMap * map)
 {
diff --git a/Engine/lib/sdl/src/video/SDL_sysvideo.h b/Engine/lib/sdl/src/video/SDL_sysvideo.h
index e2a65045b..2384a64ac 100644
--- a/Engine/lib/sdl/src/video/SDL_sysvideo.h
+++ b/Engine/lib/sdl/src/video/SDL_sysvideo.h
@@ -345,6 +345,7 @@ struct SDL_VideoDevice
     Uint32 next_object_id;
     char *clipboard_text;
     SDL_bool setting_display_mode;
+    SDL_bool disable_display_mode_switching;
 
     /* * * */
     /* Data used by the GL drivers */
diff --git a/Engine/lib/sdl/src/video/SDL_video.c b/Engine/lib/sdl/src/video/SDL_video.c
index 3be98806d..93c803e70 100644
--- a/Engine/lib/sdl/src/video/SDL_video.c
+++ b/Engine/lib/sdl/src/video/SDL_video.c
@@ -61,12 +61,12 @@ static VideoBootStrap *bootstrap[] = {
 #if SDL_VIDEO_DRIVER_COCOA
     &COCOA_bootstrap,
 #endif
-#if SDL_VIDEO_DRIVER_WAYLAND
-    &Wayland_bootstrap,
-#endif
 #if SDL_VIDEO_DRIVER_X11
     &X11_bootstrap,
 #endif
+#if SDL_VIDEO_DRIVER_WAYLAND
+    &Wayland_bootstrap,
+#endif
 #if SDL_VIDEO_DRIVER_VIVANTE
     &VIVANTE_bootstrap,
 #endif
@@ -261,6 +261,7 @@ SDL_CreateWindowTexture(SDL_VideoDevice *_this, SDL_Window * window, Uint32 * fo
                                       SDL_TEXTUREACCESS_STREAMING,
                                       window->w, window->h);
     if (!data->texture) {
+        /* codechecker_false_positive [Malloc] Static analyzer doesn't realize allocated `data` is saved to SDL_WINDOWTEXTUREDATA and not leaked here. */
         return -1;
     }
 
@@ -424,7 +425,7 @@ SDL_VideoInit(const char *driver_name)
     i = index = 0;
     video = NULL;
     if (driver_name == NULL) {
-        driver_name = SDL_getenv("SDL_VIDEODRIVER");
+        driver_name = SDL_GetHint(SDL_HINT_VIDEODRIVER);
     }
     if (driver_name != NULL && *driver_name != 0) {
         const char *driver_attempt = driver_name;
@@ -1184,6 +1185,7 @@ SDL_GetWindowDisplayMode(SDL_Window * window, SDL_DisplayMode * mode)
     } else if (!SDL_GetClosestDisplayModeForDisplay(SDL_GetDisplayForWindow(window),
                                              &fullscreen_mode,
                                              &fullscreen_mode)) {
+        SDL_zerop(mode);
         return SDL_SetError("Couldn't find display mode match");
     }
 
@@ -1337,14 +1339,17 @@ SDL_UpdateFullscreenMode(SDL_Window * window, SDL_bool fullscreen)
                     resized = SDL_FALSE;
                 }
 
-                /* only do the mode change if we want exclusive fullscreen */
-                if ((window->flags & SDL_WINDOW_FULLSCREEN_DESKTOP) != SDL_WINDOW_FULLSCREEN_DESKTOP) {
-                    if (SDL_SetDisplayModeForDisplay(display, &fullscreen_mode) < 0) {
-                        return -1;
-                    }
-                } else {
-                    if (SDL_SetDisplayModeForDisplay(display, NULL) < 0) {
-                        return -1;
+                /* Don't try to change the display mode if the driver doesn't want it. */
+                if (_this->disable_display_mode_switching == SDL_FALSE) {
+                    /* only do the mode change if we want exclusive fullscreen */
+                    if ((window->flags & SDL_WINDOW_FULLSCREEN_DESKTOP) != SDL_WINDOW_FULLSCREEN_DESKTOP) {
+                        if (SDL_SetDisplayModeForDisplay(display, &fullscreen_mode) < 0) {
+                            return -1;
+                        }
+                    } else {
+                        if (SDL_SetDisplayModeForDisplay(display, NULL) < 0) {
+                            return -1;
+                        }
                     }
                 }
 
@@ -3055,7 +3060,8 @@ ShouldMinimizeOnFocusLoss(SDL_Window * window)
     /* Real fullscreen windows should minimize on focus loss so the desktop video mode is restored */
     hint = SDL_GetHint(SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS);
     if (!hint || !*hint || SDL_strcasecmp(hint, "auto") == 0) {
-        if ((window->flags & SDL_WINDOW_FULLSCREEN_DESKTOP) == SDL_WINDOW_FULLSCREEN_DESKTOP) {
+        if ((window->flags & SDL_WINDOW_FULLSCREEN_DESKTOP) == SDL_WINDOW_FULLSCREEN_DESKTOP ||
+            _this->disable_display_mode_switching == SDL_TRUE) {
             return SDL_FALSE;
         } else {
             return SDL_TRUE;
@@ -3919,6 +3925,10 @@ SDL_GL_MakeCurrent(SDL_Window * window, SDL_GLContext ctx)
 {
     int retval;
 
+    if (!_this) {
+        return SDL_UninitializedVideo();
+    }
+
     if (window == SDL_GL_GetCurrentWindow() &&
         ctx == SDL_GL_GetCurrentContext()) {
         /* We're already current. */
@@ -4262,12 +4272,12 @@ SDL_IsScreenKeyboardShown(SDL_Window *window)
 #if SDL_VIDEO_DRIVER_UIKIT
 #include "uikit/SDL_uikitmessagebox.h"
 #endif
-#if SDL_VIDEO_DRIVER_WAYLAND
-#include "wayland/SDL_waylandmessagebox.h"
-#endif
 #if SDL_VIDEO_DRIVER_X11
 #include "x11/SDL_x11messagebox.h"
 #endif
+#if SDL_VIDEO_DRIVER_WAYLAND
+#include "wayland/SDL_waylandmessagebox.h"
+#endif
 #if SDL_VIDEO_DRIVER_HAIKU
 #include "haiku/SDL_bmessagebox.h"
 #endif
@@ -4375,13 +4385,6 @@ SDL_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid)
         retval = 0;
     }
 #endif
-#if SDL_VIDEO_DRIVER_WAYLAND
-    if (retval == -1 &&
-        SDL_MessageboxValidForDriver(messageboxdata, SDL_SYSWM_WAYLAND) &&
-        Wayland_ShowMessageBox(messageboxdata, buttonid) == 0) {
-        retval = 0;
-    }
-#endif
 #if SDL_VIDEO_DRIVER_X11
     if (retval == -1 &&
         SDL_MessageboxValidForDriver(messageboxdata, SDL_SYSWM_X11) &&
@@ -4389,6 +4392,13 @@ SDL_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid)
         retval = 0;
     }
 #endif
+#if SDL_VIDEO_DRIVER_WAYLAND
+    if (retval == -1 &&
+        SDL_MessageboxValidForDriver(messageboxdata, SDL_SYSWM_WAYLAND) &&
+        Wayland_ShowMessageBox(messageboxdata, buttonid) == 0) {
+        retval = 0;
+    }
+#endif
 #if SDL_VIDEO_DRIVER_HAIKU
     if (retval == -1 &&
         SDL_MessageboxValidForDriver(messageboxdata, SDL_SYSWM_HAIKU) &&
diff --git a/Engine/lib/sdl/src/video/android/SDL_androidvideo.c b/Engine/lib/sdl/src/video/android/SDL_androidvideo.c
index 61b9a87e9..9555ea078 100644
--- a/Engine/lib/sdl/src/video/android/SDL_androidvideo.c
+++ b/Engine/lib/sdl/src/video/android/SDL_androidvideo.c
@@ -122,6 +122,7 @@ Android_CreateDevice(int devindex)
     device->SetWindowTitle = Android_SetWindowTitle;
     device->SetWindowFullscreen = Android_SetWindowFullscreen;
     device->MinimizeWindow = Android_MinimizeWindow;
+    device->SetWindowResizable = Android_SetWindowResizable;
     device->DestroyWindow = Android_DestroyWindow;
     device->GetWindowWMInfo = Android_GetWindowWMInfo;
 
diff --git a/Engine/lib/sdl/src/video/android/SDL_androidwindow.c b/Engine/lib/sdl/src/video/android/SDL_androidwindow.c
index c5f8919ea..f9ae3f10c 100644
--- a/Engine/lib/sdl/src/video/android/SDL_androidwindow.c
+++ b/Engine/lib/sdl/src/video/android/SDL_androidwindow.c
@@ -167,6 +167,12 @@ Android_MinimizeWindow(_THIS, SDL_Window *window)
     Android_JNI_MinizeWindow();
 }
 
+void Android_SetWindowResizable(_THIS, SDL_Window *window, SDL_bool resizable)
+{
+    /* Set orientation */
+    Android_JNI_SetOrientation(window->w, window->h, window->flags & SDL_WINDOW_RESIZABLE, SDL_GetHint(SDL_HINT_ORIENTATIONS));
+}
+
 void
 Android_DestroyWindow(_THIS, SDL_Window *window)
 {
diff --git a/Engine/lib/sdl/src/video/android/SDL_androidwindow.h b/Engine/lib/sdl/src/video/android/SDL_androidwindow.h
index e78d5068e..58e459006 100644
--- a/Engine/lib/sdl/src/video/android/SDL_androidwindow.h
+++ b/Engine/lib/sdl/src/video/android/SDL_androidwindow.h
@@ -30,6 +30,7 @@ extern int Android_CreateWindow(_THIS, SDL_Window *window);
 extern void Android_SetWindowTitle(_THIS, SDL_Window *window);
 extern void Android_SetWindowFullscreen(_THIS, SDL_Window *window, SDL_VideoDisplay *display, SDL_bool fullscreen);
 extern void Android_MinimizeWindow(_THIS, SDL_Window *window);
+extern void Android_SetWindowResizable(_THIS, SDL_Window *window, SDL_bool resizable);
 
 extern void Android_DestroyWindow(_THIS, SDL_Window *window);
 extern SDL_bool Android_GetWindowWMInfo(_THIS, SDL_Window *window, struct SDL_SysWMinfo *info);
diff --git a/Engine/lib/sdl/src/video/dummy/SDL_nullvideo.c b/Engine/lib/sdl/src/video/dummy/SDL_nullvideo.c
index aafed848d..a7fb1aac2 100644
--- a/Engine/lib/sdl/src/video/dummy/SDL_nullvideo.c
+++ b/Engine/lib/sdl/src/video/dummy/SDL_nullvideo.c
@@ -46,6 +46,7 @@
 #include "SDL_nullvideo.h"
 #include "SDL_nullevents_c.h"
 #include "SDL_nullframebuffer_c.h"
+#include "SDL_hints.h"
 
 #define DUMMYVID_DRIVER_NAME "dummy"
 
@@ -59,7 +60,7 @@ static void DUMMY_VideoQuit(_THIS);
 static int
 DUMMY_Available(void)
 {
-    const char *envr = SDL_getenv("SDL_VIDEODRIVER");
+    const char *envr = SDL_GetHint(SDL_HINT_VIDEODRIVER);
     if ((envr) && (SDL_strcmp(envr, DUMMYVID_DRIVER_NAME) == 0)) {
         return (1);
     }
diff --git a/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenframebuffer.c b/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenframebuffer.c
index d4e9cb8e8..372c6f5ac 100644
--- a/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenframebuffer.c
+++ b/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenframebuffer.c
@@ -26,6 +26,8 @@
 #include "SDL_emscriptenframebuffer.h"
 #include "SDL_hints.h"
 
+#include <emscripten/threading.h>
+
 
 int Emscripten_CreateWindowFramebuffer(_THIS, SDL_Window * window, Uint32 * format, void ** pixels, int *pitch)
 {
@@ -57,18 +59,9 @@ int Emscripten_CreateWindowFramebuffer(_THIS, SDL_Window * window, Uint32 * form
     return 0;
 }
 
-int Emscripten_UpdateWindowFramebuffer(_THIS, SDL_Window * window, const SDL_Rect * rects, int numrects)
+static void
+Emscripten_UpdateWindowFramebufferWorker(SDL_Surface* surface)
 {
-    SDL_Surface *surface;
-
-    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
-    surface = data->surface;
-    if (!surface) {
-        return SDL_SetError("Couldn't find framebuffer surface for window");
-    }
-
-    /* Send the data to the display */
-
     EM_ASM_INT({
         var w = $0;
         var h = $1;
@@ -156,6 +149,29 @@ int Emscripten_UpdateWindowFramebuffer(_THIS, SDL_Window * window, const SDL_Rec
         SDL2.ctx.putImageData(SDL2.image, 0, 0);
         return 0;
     }, surface->w, surface->h, surface->pixels);
+}
+
+int Emscripten_UpdateWindowFramebuffer(_THIS, SDL_Window * window, const SDL_Rect * rects, int numrects)
+{
+    SDL_Surface *surface;
+
+    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
+    surface = data->surface;
+    if (!surface) {
+        return SDL_SetError("Couldn't find framebuffer surface for window");
+    }
+
+    /* Send the data to the display */
+
+    if (emscripten_is_main_runtime_thread()) {
+        Emscripten_UpdateWindowFramebufferWorker(surface);
+    } else {
+        emscripten_sync_run_in_main_runtime_thread(
+            EM_FUNC_SIG_VI,
+            Emscripten_UpdateWindowFramebufferWorker,
+            (uint32_t)surface
+        );
+    }
 
     if (emscripten_has_asyncify() && SDL_GetHintBoolean(SDL_HINT_EMSCRIPTEN_ASYNCIFY, SDL_TRUE)) {
         /* give back control to browser for screen refresh */
diff --git a/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenmouse.c b/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenmouse.c
index e73072590..e41480725 100644
--- a/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenmouse.c
+++ b/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenmouse.c
@@ -24,6 +24,7 @@
 
 #include <emscripten/emscripten.h>
 #include <emscripten/html5.h>
+#include <emscripten/threading.h>
 
 #include "SDL_emscriptenmouse.h"
 #include "SDL_emscriptenvideo.h"
@@ -62,19 +63,10 @@ Emscripten_CreateDefaultCursor()
     return Emscripten_CreateCursorFromString("default", SDL_FALSE);
 }
 
-static SDL_Cursor*
-Emscripten_CreateCursor(SDL_Surface* surface, int hot_x, int hot_y)
+static const char*
+Emscripten_GetCursorUrl(int w, int h, int hot_x, int hot_y, void* pixels)
 {
-    const char *cursor_url = NULL;
-    SDL_Surface *conv_surf;
-
-    conv_surf = SDL_ConvertSurfaceFormat(surface, SDL_PIXELFORMAT_ABGR8888, 0);
-
-    if (!conv_surf) {
-        return NULL;
-    }
-
-    cursor_url = (const char *)EM_ASM_INT({
+    return (const char *)EM_ASM_INT({
         var w = $0;
         var h = $1;
         var hot_x = $2;
@@ -122,7 +114,40 @@ Emscripten_CreateCursor(SDL_Surface* surface, int hot_x, int hot_y)
         stringToUTF8(url, urlBuf, url.length + 1);
 
         return urlBuf;
-    }, surface->w, surface->h, hot_x, hot_y, conv_surf->pixels);
+    }, w, h, hot_x, hot_y, pixels);
+}
+
+static SDL_Cursor*
+Emscripten_CreateCursor(SDL_Surface* surface, int hot_x, int hot_y)
+{
+    const char *cursor_url = NULL;
+    SDL_Surface *conv_surf;
+
+    conv_surf = SDL_ConvertSurfaceFormat(surface, SDL_PIXELFORMAT_ABGR8888, 0);
+
+    if (!conv_surf) {
+        return NULL;
+    }
+
+    if (emscripten_is_main_runtime_thread()) {
+        cursor_url = Emscripten_GetCursorUrl(
+            surface->w,
+            surface->h,
+            hot_x,
+            hot_y,
+            conv_surf->pixels
+        );
+    } else {
+        cursor_url = (const char *)emscripten_sync_run_in_main_runtime_thread(
+            EM_FUNC_SIG_IIIIIII,
+            Emscripten_GetCursorUrl,
+            surface->w,
+            surface->h,
+            hot_x,
+            hot_y,
+            conv_surf->pixels
+        );
+    }
 
     SDL_FreeSurface(conv_surf);
 
@@ -206,16 +231,15 @@ Emscripten_ShowCursor(SDL_Cursor* cursor)
             curdata = (Emscripten_CursorData *) cursor->driverdata;
 
             if(curdata->system_cursor) {
-                EM_ASM_INT({
+                MAIN_THREAD_EM_ASM({
                     if (Module['canvas']) {
                         Module['canvas'].style['cursor'] = UTF8ToString($0);
                     }
-                    return 0;
                 }, curdata->system_cursor);
             }
         }
         else {
-            EM_ASM(
+            MAIN_THREAD_EM_ASM(
                 if (Module['canvas']) {
                     Module['canvas'].style['cursor'] = 'none';
                 }
diff --git a/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenvideo.c b/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenvideo.c
index f6ee1e7e5..4c6038f09 100644
--- a/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenvideo.c
+++ b/Engine/lib/sdl/src/video/emscripten/SDL_emscriptenvideo.c
@@ -174,10 +174,10 @@ Emscripten_GetDisplayUsableBounds(_THIS, SDL_VideoDisplay * display, SDL_Rect *
     if (rect) {
         rect->x = 0;
         rect->y = 0;
-        rect->w = EM_ASM_INT_V({
+        rect->w = MAIN_THREAD_EM_ASM_INT({
             return window.innerWidth;
         });
-        rect->h = EM_ASM_INT_V({
+        rect->h = MAIN_THREAD_EM_ASM_INT({
             return window.innerHeight;
         });
     }
diff --git a/Engine/lib/sdl/src/video/uikit/SDL_uikitmessagebox.m b/Engine/lib/sdl/src/video/uikit/SDL_uikitmessagebox.m
index fdc20c086..b6d56f350 100644
--- a/Engine/lib/sdl/src/video/uikit/SDL_uikitmessagebox.m
+++ b/Engine/lib/sdl/src/video/uikit/SDL_uikitmessagebox.m
@@ -186,8 +186,8 @@ UIKit_ShowMessageBoxAlertView(const SDL_MessageBoxData *messageboxdata, int *but
 #endif /* __IPHONE_OS_VERSION_MIN_REQUIRED < 80000 */
 }
 
-int
-UIKit_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid)
+static void
+UIKit_ShowMessageBoxImpl(const SDL_MessageBoxData *messageboxdata, int *buttonid, int *returnValue)
 {
     BOOL success = NO;
 
@@ -199,12 +199,26 @@ UIKit_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid)
     }
 
     if (!success) {
-        return SDL_SetError("Could not show message box.");
+        *returnValue = SDL_SetError("Could not show message box.");
+    } else {
+        *returnValue = 0;
     }
-
-    return 0;
 }
 
+int
+UIKit_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid)
+{ @autoreleasepool
+{
+    __block int returnValue = 0;
+
+    if ([NSThread isMainThread]) {
+        UIKit_ShowMessageBoxImpl(messageboxdata, buttonid, &returnValue);
+    } else {
+        dispatch_sync(dispatch_get_main_queue(), ^{ UIKit_ShowMessageBoxImpl(messageboxdata, buttonid, &returnValue); });
+    }
+    return returnValue;
+}}
+
 #endif /* SDL_VIDEO_DRIVER_UIKIT */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/vita/SDL_vitaframebuffer.c b/Engine/lib/sdl/src/video/vita/SDL_vitaframebuffer.c
index 992c7af84..1c558486b 100644
--- a/Engine/lib/sdl/src/video/vita/SDL_vitaframebuffer.c
+++ b/Engine/lib/sdl/src/video/vita/SDL_vitaframebuffer.c
@@ -31,7 +31,7 @@
 #define ALIGN(x, a)     (((x) + ((a) - 1)) & ~((a) - 1))
 #define DISPLAY_PIXEL_FORMAT SCE_DISPLAY_PIXELFORMAT_A8B8G8R8
 
-void *vita_gpu_alloc(SceKernelMemBlockType type, unsigned int size, SceUID *uid)
+void *vita_gpu_alloc(unsigned int type, unsigned int size, SceUID *uid)
 {
     void *mem;
 
diff --git a/Engine/lib/sdl/src/video/vita/SDL_vitagl_pvr.c b/Engine/lib/sdl/src/video/vita/SDL_vitagl_pvr.c
index 3b7fb7477..d51150c03 100644
--- a/Engine/lib/sdl/src/video/vita/SDL_vitagl_pvr.c
+++ b/Engine/lib/sdl/src/video/vita/SDL_vitagl_pvr.c
@@ -20,11 +20,12 @@
 */
 #include "../../SDL_internal.h"
 
-#if SDL_VIDEO_DRIVER_VITA && SDL_VIDEO_VITA_PVR
+#if SDL_VIDEO_DRIVER_VITA && SDL_VIDEO_VITA_PVR && SDL_VIDEO_VITA_PVR_OGL
 #include <stdlib.h>
 #include <string.h>
 #include <psp2/kernel/modulemgr.h>
 #include <gpu_es4/psp2_pvr_hint.h>
+#include <gl4esinit.h>
 
 #include "SDL_error.h"
 #include "SDL_log.h"
@@ -34,6 +35,16 @@
 
 #define MAX_PATH 256 // vita limits are somehow wrong
 
+/* Defaults */
+int FB_WIDTH = 960;
+int FB_HEIGHT = 544;
+
+void getFBSize(int *width, int *height)
+{
+    *width = FB_WIDTH;
+    *height = FB_HEIGHT;
+}
+
 int
 VITA_GL_LoadLibrary(_THIS, const char *path)
 {
@@ -53,6 +64,9 @@ VITA_GL_LoadLibrary(_THIS, const char *path)
         sceKernelLoadStartModule("vs0:sys/external/libfios2.suprx", 0, NULL, 0, NULL, NULL);
         sceKernelLoadStartModule("vs0:sys/external/libc.suprx", 0, NULL, 0, NULL, NULL);
 
+        SDL_snprintf(target_path, MAX_PATH, "%s/%s", default_path, "libGL.suprx");
+        sceKernelLoadStartModule(target_path, 0, NULL, 0, NULL, NULL);
+
         SDL_snprintf(target_path, MAX_PATH, "%s/%s", default_path, "libgpu_es4_ext.suprx");
         sceKernelLoadStartModule(target_path, 0, NULL, 0, NULL, NULL);
 
@@ -74,30 +88,45 @@ VITA_GL_LoadLibrary(_THIS, const char *path)
 SDL_GLContext
 VITA_GL_CreateContext(_THIS, SDL_Window * window)
 {
-    return SDL_EGL_CreateContext(_this, ((SDL_WindowData *) window->driverdata)->egl_surface);
-}
+    char gl_version[3];
+    SDL_GLContext context = NULL;
+    int temp_major = _this->gl_config.major_version;
+    int temp_minor = _this->gl_config.minor_version;
+    int temp_profile = _this->gl_config.profile_mask;
 
-int
-VITA_GL_MakeCurrent(_THIS, SDL_Window * window, SDL_GLContext context)
-{
-    if (window && context) {
-        return SDL_EGL_MakeCurrent(_this, ((SDL_WindowData *) window->driverdata)->egl_surface, context);
-    } else {
-        return SDL_EGL_MakeCurrent(_this, NULL, NULL);
+    /* Set version to 2.0 and PROFILE to ES */
+    _this->gl_config.major_version = 2;
+    _this->gl_config.minor_version = 0;
+    _this->gl_config.profile_mask = SDL_GL_CONTEXT_PROFILE_ES;
+
+    context = SDL_EGL_CreateContext(_this, ((SDL_WindowData *) window->driverdata)->egl_surface);
+
+    if (context != NULL)
+    {
+        FB_WIDTH = window->w;
+        FB_HEIGHT = window->h;
+        set_getprocaddress((void *(*)(const char *))eglGetProcAddress);
+        set_getmainfbsize(getFBSize);
+        SDL_snprintf(gl_version, 3, "%d%d", temp_major, temp_minor);
+        gl4es_setenv("LIBGL_NOTEXRECT", "1", 1); /* Currently broken in driver */
+        gl4es_setenv("LIBGL_GL", gl_version, 1);
+        initialize_gl4es();
     }
+
+    /* Restore gl_config */
+    _this->gl_config.major_version = temp_major;
+    _this->gl_config.minor_version = temp_minor;
+    _this->gl_config.profile_mask = temp_profile;
+
+    return context;
 }
 
-int
-VITA_GL_SwapWindow(_THIS, SDL_Window * window)
+void *
+VITA_GL_GetProcAddress(_THIS, const char *proc)
 {
-    SDL_VideoData *videodata = (SDL_VideoData *)_this->driverdata;
-    if (videodata->ime_active) {
-        sceImeUpdate();
-    }
-    return SDL_EGL_SwapBuffers(_this, ((SDL_WindowData *) window->driverdata)->egl_surface);
+    return gl4es_GetProcAddress(proc);
 }
 
-
 #endif /* SDL_VIDEO_DRIVER_VITA && SDL_VIDEO_VITA_PVR */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/vita/SDL_vitagl_pvr_c.h b/Engine/lib/sdl/src/video/vita/SDL_vitagl_pvr_c.h
index 670eaebb0..2329d472b 100644
--- a/Engine/lib/sdl/src/video/vita/SDL_vitagl_pvr_c.h
+++ b/Engine/lib/sdl/src/video/vita/SDL_vitagl_pvr_c.h
@@ -19,17 +19,16 @@
   3. This notice may not be removed or altered from any source distribution.
 */
 
-#ifndef SDL_vitagl_c_h_
-#define SDL_vitagl_c_h_
+#ifndef SDL_vitagl_pvr_c_h_
+#define SDL_vitagl_pvr_c_h_
 
 #include "SDL_vitavideo.h"
 
-extern int VITA_GL_MakeCurrent(_THIS,SDL_Window * window, SDL_GLContext context);
-extern int VITA_GL_SwapWindow(_THIS, SDL_Window * window);
 extern SDL_GLContext VITA_GL_CreateContext(_THIS, SDL_Window * window);
 extern int VITA_GL_LoadLibrary(_THIS, const char *path);
+extern void *VITA_GL_GetProcAddress(_THIS, const char *proc);
 
 
-#endif /* SDL_vitagl_c_h_ */
+#endif /* SDL_vitagl_pvr_c_h_ */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/vita/SDL_vitagl.c b/Engine/lib/sdl/src/video/vita/SDL_vitagles.c
similarity index 91%
rename from Engine/lib/sdl/src/video/vita/SDL_vitagl.c
rename to Engine/lib/sdl/src/video/vita/SDL_vitagles.c
index f65022865..18ca7d57b 100644
--- a/Engine/lib/sdl/src/video/vita/SDL_vitagl.c
+++ b/Engine/lib/sdl/src/video/vita/SDL_vitagles.c
@@ -27,7 +27,7 @@
 #include "SDL_error.h"
 #include "SDL_log.h"
 #include "SDL_vitavideo.h"
-#include "SDL_vitagl_c.h"
+#include "SDL_vitagles_c.h"
 
 /*****************************************************************************/
 /* SDL OpenGL/OpenGL ES functions                                            */
@@ -45,7 +45,7 @@
     } while (0)
 
 void 
-VITA_GL_KeyboardCallback(ScePigletPreSwapData *data)
+VITA_GLES_KeyboardCallback(ScePigletPreSwapData *data)
 {
     SceCommonDialogUpdateParam commonDialogParam;
     SDL_zero(commonDialogParam);
@@ -62,20 +62,20 @@ VITA_GL_KeyboardCallback(ScePigletPreSwapData *data)
 }
 
 int
-VITA_GL_LoadLibrary(_THIS, const char *path)
+VITA_GLES_LoadLibrary(_THIS, const char *path)
 {
   pibInit(PIB_SHACCCG | PIB_GET_PROC_ADDR_CORE);
   return 0;
 }
 
 void *
-VITA_GL_GetProcAddress(_THIS, const char *proc)
+VITA_GLES_GetProcAddress(_THIS, const char *proc)
 {
     return eglGetProcAddress(proc);
 }
 
 void
-VITA_GL_UnloadLibrary(_THIS)
+VITA_GLES_UnloadLibrary(_THIS)
 {
     eglTerminate(_this->gl_data->display);
 }
@@ -84,7 +84,7 @@ static EGLint width = 960;
 static EGLint height = 544;
 
 SDL_GLContext
-VITA_GL_CreateContext(_THIS, SDL_Window * window)
+VITA_GLES_CreateContext(_THIS, SDL_Window * window)
 {
 
     SDL_WindowData *wdata = (SDL_WindowData *) window->driverdata;
@@ -159,13 +159,13 @@ VITA_GL_CreateContext(_THIS, SDL_Window * window)
     _this->gl_data->surface = surface;
 
     preSwapCallback = (PFNEGLPIGLETVITASETPRESWAPCALLBACKSCEPROC) eglGetProcAddress("eglPigletVitaSetPreSwapCallbackSCE");
-    preSwapCallback(VITA_GL_KeyboardCallback);
+    preSwapCallback(VITA_GLES_KeyboardCallback);
 
     return context;
 }
 
 int
-VITA_GL_MakeCurrent(_THIS, SDL_Window * window, SDL_GLContext context)
+VITA_GLES_MakeCurrent(_THIS, SDL_Window * window, SDL_GLContext context)
 {
         if (!eglMakeCurrent(_this->gl_data->display, _this->gl_data->surface,
                           _this->gl_data->surface, _this->gl_data->context))
@@ -176,7 +176,7 @@ VITA_GL_MakeCurrent(_THIS, SDL_Window * window, SDL_GLContext context)
 }
 
 int
-VITA_GL_SetSwapInterval(_THIS, int interval)
+VITA_GLES_SetSwapInterval(_THIS, int interval)
 {
     EGLBoolean status;
     status = eglSwapInterval(_this->gl_data->display, interval);
@@ -190,13 +190,13 @@ VITA_GL_SetSwapInterval(_THIS, int interval)
 }
 
 int
-VITA_GL_GetSwapInterval(_THIS)
+VITA_GLES_GetSwapInterval(_THIS)
 {
     return _this->gl_data->swapinterval;
 }
 
 int
-VITA_GL_SwapWindow(_THIS, SDL_Window * window)
+VITA_GLES_SwapWindow(_THIS, SDL_Window * window)
 {
     if (!eglSwapBuffers(_this->gl_data->display, _this->gl_data->surface)) {
         return SDL_SetError("eglSwapBuffers() failed");
@@ -205,7 +205,7 @@ VITA_GL_SwapWindow(_THIS, SDL_Window * window)
 }
 
 void
-VITA_GL_DeleteContext(_THIS, SDL_GLContext context)
+VITA_GLES_DeleteContext(_THIS, SDL_GLContext context)
 {
     SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;
     EGLBoolean status;
diff --git a/Engine/lib/sdl/src/video/vita/SDL_vitagl_c.h b/Engine/lib/sdl/src/video/vita/SDL_vitagles_c.h
similarity index 67%
rename from Engine/lib/sdl/src/video/vita/SDL_vitagl_c.h
rename to Engine/lib/sdl/src/video/vita/SDL_vitagles_c.h
index 272653d70..10fd8533a 100644
--- a/Engine/lib/sdl/src/video/vita/SDL_vitagl_c.h
+++ b/Engine/lib/sdl/src/video/vita/SDL_vitagles_c.h
@@ -19,8 +19,8 @@
   3. This notice may not be removed or altered from any source distribution.
 */
 
-#ifndef SDL_vitagl_c_h_
-#define SDL_vitagl_c_h_
+#ifndef SDL_vitagles_c_h_
+#define SDL_vitagles_c_h_
 
 
 #include <pib.h>
@@ -39,19 +39,19 @@ typedef struct SDL_GLDriverData {
     uint32_t swapinterval;
 }SDL_GLDriverData;
 
-extern void * VITA_GL_GetProcAddress(_THIS, const char *proc);
-extern int VITA_GL_MakeCurrent(_THIS,SDL_Window * window, SDL_GLContext context);
-extern void VITA_GL_SwapBuffers(_THIS);
+extern void * VITA_GLES_GetProcAddress(_THIS, const char *proc);
+extern int VITA_GLES_MakeCurrent(_THIS,SDL_Window * window, SDL_GLContext context);
+extern void VITA_GLES_SwapBuffers(_THIS);
 
-extern int VITA_GL_SwapWindow(_THIS, SDL_Window * window);
-extern SDL_GLContext VITA_GL_CreateContext(_THIS, SDL_Window * window);
+extern int VITA_GLES_SwapWindow(_THIS, SDL_Window * window);
+extern SDL_GLContext VITA_GLES_CreateContext(_THIS, SDL_Window * window);
 
-extern int VITA_GL_LoadLibrary(_THIS, const char *path);
-extern void VITA_GL_UnloadLibrary(_THIS);
-extern int VITA_GL_SetSwapInterval(_THIS, int interval);
-extern int VITA_GL_GetSwapInterval(_THIS);
+extern int VITA_GLES_LoadLibrary(_THIS, const char *path);
+extern void VITA_GLES_UnloadLibrary(_THIS);
+extern int VITA_GLES_SetSwapInterval(_THIS, int interval);
+extern int VITA_GLES_GetSwapInterval(_THIS);
 
 
-#endif /* SDL_vitagl_c_h_ */
+#endif /* SDL_vitagles_c_h_ */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/vita/SDL_vitagles_pvr.c b/Engine/lib/sdl/src/video/vita/SDL_vitagles_pvr.c
new file mode 100644
index 000000000..bb06d2946
--- /dev/null
+++ b/Engine/lib/sdl/src/video/vita/SDL_vitagles_pvr.c
@@ -0,0 +1,103 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if SDL_VIDEO_DRIVER_VITA && SDL_VIDEO_VITA_PVR
+#include <stdlib.h>
+#include <string.h>
+#include <psp2/kernel/modulemgr.h>
+#include <gpu_es4/psp2_pvr_hint.h>
+
+#include "SDL_error.h"
+#include "SDL_log.h"
+#include "SDL_vitavideo.h"
+#include "../SDL_egl_c.h"
+#include "SDL_vitagles_pvr_c.h"
+
+#define MAX_PATH 256 // vita limits are somehow wrong
+
+int
+VITA_GLES_LoadLibrary(_THIS, const char *path)
+{
+    PVRSRV_PSP2_APPHINT hint;
+    char* override = SDL_getenv("VITA_MODULE_PATH");
+    char* skip_init = SDL_getenv("VITA_PVR_SKIP_INIT");
+    char* default_path = "app0:module";
+    char target_path[MAX_PATH];
+
+    if (skip_init == NULL) // we don't care about actual value
+    {
+        if (override != NULL)
+        {
+          default_path = override;
+        }
+
+        sceKernelLoadStartModule("vs0:sys/external/libfios2.suprx", 0, NULL, 0, NULL, NULL);
+        sceKernelLoadStartModule("vs0:sys/external/libc.suprx", 0, NULL, 0, NULL, NULL);
+
+        SDL_snprintf(target_path, MAX_PATH, "%s/%s", default_path, "libgpu_es4_ext.suprx");
+        sceKernelLoadStartModule(target_path, 0, NULL, 0, NULL, NULL);
+
+        SDL_snprintf(target_path, MAX_PATH, "%s/%s", default_path, "libIMGEGL.suprx");
+        sceKernelLoadStartModule(target_path, 0, NULL, 0, NULL, NULL);
+
+        PVRSRVInitializeAppHint(&hint);
+
+        SDL_snprintf(hint.szGLES1, MAX_PATH, "%s/%s", default_path, "libGLESv1_CM.suprx");
+        SDL_snprintf(hint.szGLES2, MAX_PATH, "%s/%s", default_path, "libGLESv2.suprx");
+        SDL_snprintf(hint.szWindowSystem, MAX_PATH, "%s/%s", default_path, "libpvrPSP2_WSEGL.suprx");
+
+        PVRSRVCreateVirtualAppHint(&hint);
+    }
+
+    return SDL_EGL_LoadLibrary(_this, path, (NativeDisplayType) 0, 0);
+}
+
+SDL_GLContext
+VITA_GLES_CreateContext(_THIS, SDL_Window * window)
+{
+    return SDL_EGL_CreateContext(_this, ((SDL_WindowData *) window->driverdata)->egl_surface);
+}
+
+int
+VITA_GLES_MakeCurrent(_THIS, SDL_Window * window, SDL_GLContext context)
+{
+    if (window && context) {
+        return SDL_EGL_MakeCurrent(_this, ((SDL_WindowData *) window->driverdata)->egl_surface, context);
+    } else {
+        return SDL_EGL_MakeCurrent(_this, NULL, NULL);
+    }
+}
+
+int
+VITA_GLES_SwapWindow(_THIS, SDL_Window * window)
+{
+    SDL_VideoData *videodata = (SDL_VideoData *)_this->driverdata;
+    if (videodata->ime_active) {
+        sceImeUpdate();
+    }
+    return SDL_EGL_SwapBuffers(_this, ((SDL_WindowData *) window->driverdata)->egl_surface);
+}
+
+
+#endif /* SDL_VIDEO_DRIVER_VITA && SDL_VIDEO_VITA_PVR */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/vita/SDL_vitagles_pvr_c.h b/Engine/lib/sdl/src/video/vita/SDL_vitagles_pvr_c.h
new file mode 100644
index 000000000..c3a13c436
--- /dev/null
+++ b/Engine/lib/sdl/src/video/vita/SDL_vitagles_pvr_c.h
@@ -0,0 +1,35 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_vitagles_pvr_c_h_
+#define SDL_vitagles_pvr_c_h_
+
+#include "SDL_vitavideo.h"
+
+extern int VITA_GLES_MakeCurrent(_THIS,SDL_Window * window, SDL_GLContext context);
+extern int VITA_GLES_SwapWindow(_THIS, SDL_Window * window);
+extern SDL_GLContext VITA_GLES_CreateContext(_THIS, SDL_Window * window);
+extern int VITA_GLES_LoadLibrary(_THIS, const char *path);
+
+
+#endif /* SDL_vitagles_pvr_c_h_ */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/vita/SDL_vitavideo.c b/Engine/lib/sdl/src/video/vita/SDL_vitavideo.c
index 778a87073..60bd18f45 100644
--- a/Engine/lib/sdl/src/video/vita/SDL_vitavideo.c
+++ b/Engine/lib/sdl/src/video/vita/SDL_vitavideo.c
@@ -41,15 +41,17 @@
 #include "SDL_vitaframebuffer.h"
 
 #if defined(SDL_VIDEO_VITA_PIB)
-  #include "SDL_vitagl_c.h"
+  #include "SDL_vitagles_c.h"
 #elif defined(SDL_VIDEO_VITA_PVR)
+  #include "SDL_vitagles_pvr_c.h"
+#if defined(SDL_VIDEO_VITA_PVR_OGL)
   #include "SDL_vitagl_pvr_c.h"
-  #include "../SDL_egl_c.h"
-  #define VITA_GL_GetProcAddress SDL_EGL_GetProcAddress
-  #define VITA_GL_UnloadLibrary SDL_EGL_UnloadLibrary
-  #define VITA_GL_SetSwapInterval SDL_EGL_SetSwapInterval
-  #define VITA_GL_GetSwapInterval SDL_EGL_GetSwapInterval
-  #define VITA_GL_DeleteContext SDL_EGL_DeleteContext
+#endif
+  #define VITA_GLES_GetProcAddress SDL_EGL_GetProcAddress
+  #define VITA_GLES_UnloadLibrary SDL_EGL_UnloadLibrary
+  #define VITA_GLES_SetSwapInterval SDL_EGL_SetSwapInterval
+  #define VITA_GLES_GetSwapInterval SDL_EGL_GetSwapInterval
+  #define VITA_GLES_DeleteContext SDL_EGL_DeleteContext
 #endif
 
 SDL_Window *Vita_Window;
@@ -140,15 +142,26 @@ VITA_Create()
 */
 
 #if defined(SDL_VIDEO_VITA_PIB) || defined(SDL_VIDEO_VITA_PVR)
+#if defined(SDL_VIDEO_VITA_PVR_OGL)
+if(SDL_getenv("VITA_PVR_OGL") != NULL) {
     device->GL_LoadLibrary = VITA_GL_LoadLibrary;
-    device->GL_GetProcAddress = VITA_GL_GetProcAddress;
-    device->GL_UnloadLibrary = VITA_GL_UnloadLibrary;
     device->GL_CreateContext = VITA_GL_CreateContext;
-    device->GL_MakeCurrent = VITA_GL_MakeCurrent;
-    device->GL_SetSwapInterval = VITA_GL_SetSwapInterval;
-    device->GL_GetSwapInterval = VITA_GL_GetSwapInterval;
-    device->GL_SwapWindow = VITA_GL_SwapWindow;
-    device->GL_DeleteContext = VITA_GL_DeleteContext;
+    device->GL_GetProcAddress = VITA_GL_GetProcAddress;
+} else {
+#endif
+    device->GL_LoadLibrary = VITA_GLES_LoadLibrary;
+    device->GL_CreateContext = VITA_GLES_CreateContext;
+    device->GL_GetProcAddress = VITA_GLES_GetProcAddress;
+#if defined(SDL_VIDEO_VITA_PVR_OGL)
+}
+#endif
+
+    device->GL_UnloadLibrary = VITA_GLES_UnloadLibrary;
+    device->GL_MakeCurrent = VITA_GLES_MakeCurrent;
+    device->GL_SetSwapInterval = VITA_GLES_SetSwapInterval;
+    device->GL_GetSwapInterval = VITA_GLES_GetSwapInterval;
+    device->GL_SwapWindow = VITA_GLES_SwapWindow;
+    device->GL_DeleteContext = VITA_GLES_DeleteContext;
 #endif
 
     device->HasScreenKeyboardSupport = VITA_HasScreenKeyboardSupport;
@@ -245,6 +258,9 @@ VITA_CreateWindow(_THIS, SDL_Window * window)
     SDL_WindowData *wdata;
 #if defined(SDL_VIDEO_VITA_PVR)
     Psp2NativeWindow win;
+    int temp_major = 2;
+    int temp_minor = 1;
+    int temp_profile = 0;
 #endif
 
     /* Allocate window internal data */
@@ -282,11 +298,26 @@ VITA_CreateWindow(_THIS, SDL_Window * window)
         win.windowSize = PSP2_WINDOW_960X544;
     }
     if ((window->flags & SDL_WINDOW_OPENGL) != 0) {
-      wdata->egl_surface = SDL_EGL_CreateSurface(_this, &win);
+      if(SDL_getenv("VITA_PVR_OGL") != NULL) {
+        /* Set version to 2.1 and PROFILE to ES */
+        temp_major = _this->gl_config.major_version;
+        temp_minor = _this->gl_config.minor_version;
+        temp_profile = _this->gl_config.profile_mask;
 
+        _this->gl_config.major_version = 2;
+        _this->gl_config.minor_version = 1;
+        _this->gl_config.profile_mask = SDL_GL_CONTEXT_PROFILE_ES;
+      }
+      wdata->egl_surface = SDL_EGL_CreateSurface(_this, &win);
       if (wdata->egl_surface == EGL_NO_SURFACE) {
           return SDL_SetError("Could not create GLES window surface");
       }
+      if(SDL_getenv("VITA_PVR_OGL") != NULL) {
+        /* Revert */
+        _this->gl_config.major_version = temp_major;
+        _this->gl_config.minor_version = temp_minor;
+        _this->gl_config.profile_mask = temp_profile;
+      }
     }
 #endif
 
diff --git a/Engine/lib/sdl/src/video/vita/SDL_vitavideo.h b/Engine/lib/sdl/src/video/vita/SDL_vitavideo.h
index 04488dde3..9fdf7e69c 100644
--- a/Engine/lib/sdl/src/video/vita/SDL_vitavideo.h
+++ b/Engine/lib/sdl/src/video/vita/SDL_vitavideo.h
@@ -90,16 +90,23 @@ SDL_bool VITA_GetWindowWMInfo(_THIS, SDL_Window * window,
                              struct SDL_SysWMinfo *info);
 
 #if SDL_VIDEO_DRIVER_VITA
+#if defined(SDL_VIDEO_VITA_PVR_OGL)
 /* OpenGL functions */
 int VITA_GL_LoadLibrary(_THIS, const char *path);
-void *VITA_GL_GetProcAddress(_THIS, const char *proc);
-void VITA_GL_UnloadLibrary(_THIS);
 SDL_GLContext VITA_GL_CreateContext(_THIS, SDL_Window * window);
-int VITA_GL_MakeCurrent(_THIS, SDL_Window * window, SDL_GLContext context);
-int VITA_GL_SetSwapInterval(_THIS, int interval);
-int VITA_GL_GetSwapInterval(_THIS);
-int VITA_GL_SwapWindow(_THIS, SDL_Window * window);
-void VITA_GL_DeleteContext(_THIS, SDL_GLContext context);
+void *VITA_GL_GetProcAddress(_THIS, const char *proc);
+#endif
+
+/* OpenGLES functions */
+int VITA_GLES_LoadLibrary(_THIS, const char *path);
+void *VITA_GLES_GetProcAddress(_THIS, const char *proc);
+void VITA_GLES_UnloadLibrary(_THIS);
+SDL_GLContext VITA_GLES_CreateContext(_THIS, SDL_Window * window);
+int VITA_GLES_MakeCurrent(_THIS, SDL_Window * window, SDL_GLContext context);
+int VITA_GLES_SetSwapInterval(_THIS, int interval);
+int VITA_GLES_GetSwapInterval(_THIS);
+int VITA_GLES_SwapWindow(_THIS, SDL_Window * window);
+void VITA_GLES_DeleteContext(_THIS, SDL_GLContext context);
 #endif
 
 /* VITA on screen keyboard */
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylanddyn.h b/Engine/lib/sdl/src/video/wayland/SDL_waylanddyn.h
index c867ec001..3d8d973cc 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylanddyn.h
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylanddyn.h
@@ -52,6 +52,14 @@ enum libdecor_window_state;
 #include "xkbcommon/xkbcommon.h"
 #include "xkbcommon/xkbcommon-compose.h"
 
+/* Must be included before our #defines, see Bugzilla #4957 */
+#include "wayland-client-core.h"
+
+#define SDL_WAYLAND_CHECK_VERSION(x, y, z) \
+  (WAYLAND_VERSION_MAJOR > x || \
+   (WAYLAND_VERSION_MAJOR == x && WAYLAND_VERSION_MINOR > y) || \
+   (WAYLAND_VERSION_MAJOR == x && WAYLAND_VERSION_MINOR == y && WAYLAND_VERSION_MICRO >= z))
+
 #ifdef __cplusplus
 extern "C"
 {
@@ -71,9 +79,6 @@ void SDL_WAYLAND_UnloadSymbols(void);
 }
 #endif
 
-/* Must be included before our #defines, see Bugzilla #4957 */
-#include "wayland-client-core.h"
-
 #ifdef SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC
 
 #if defined(_WAYLAND_CLIENT_H) || defined(WAYLAND_CLIENT_H)
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandevents.c b/Engine/lib/sdl/src/video/wayland/SDL_waylandevents.c
index 55893201b..e515d9d6f 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandevents.c
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandevents.c
@@ -40,6 +40,7 @@
 #include "xdg-shell-client-protocol.h"
 #include "keyboard-shortcuts-inhibit-unstable-v1-client-protocol.h"
 #include "text-input-unstable-v3-client-protocol.h"
+#include "tablet-unstable-v2-client-protocol.h"
 
 #ifdef HAVE_LIBDECOR_H
 #include <libdecor.h>
@@ -83,6 +84,7 @@ static const struct {
     { XKB_KEY_Super_R, SDLK_RGUI },
     { XKB_KEY_Hyper_L, SDLK_LGUI },
     { XKB_KEY_Hyper_R, SDLK_RGUI },
+    { XKB_KEY_BackSpace, SDLK_BACKSPACE },
 };
 
 struct SDL_WaylandTouchPoint {
@@ -387,8 +389,10 @@ pointer_handle_motion(void *data, struct wl_pointer *pointer,
     input->sx_w = sx_w;
     input->sy_w = sy_w;
     if (input->pointer_focus) {
-        const int sx = wl_fixed_to_int(sx_w);
-        const int sy = wl_fixed_to_int(sy_w);
+        const float sx_f = (float)wl_fixed_to_double(sx_w);
+        const float sy_f = (float)wl_fixed_to_double(sy_w);
+        const int   sx   = (int)SDL_floorf(sx_f * window->pointer_scale_x);
+        const int   sy   = (int)SDL_floorf(sy_f * window->pointer_scale_y);
         SDL_SendMouseMotion(window->sdlwindow, 0, 0, sx, sy);
     }
 }
@@ -472,6 +476,9 @@ ProcessHitTest(struct SDL_WaylandInput *input, uint32_t serial)
         const uint32_t *directions_libdecor = directions;
 #endif
 
+        /* Hit tests shouldn't apply to xdg_popups, right? */
+        SDL_assert(!WINDOW_IS_XDG_POPUP(window));
+
         switch (rc) {
             case SDL_HITTEST_DRAGGABLE:
 #ifdef HAVE_LIBDECOR_H
@@ -715,8 +722,8 @@ touch_handler_down(void *data, struct wl_touch *touch, unsigned int serial,
                    int id, wl_fixed_t fx, wl_fixed_t fy)
 {
     SDL_WindowData *window_data = (SDL_WindowData *)wl_surface_get_user_data(surface);
-    const double dblx = wl_fixed_to_double(fx);
-    const double dbly = wl_fixed_to_double(fy);
+    const double dblx = wl_fixed_to_double(fx) * window_data->pointer_scale_x;
+    const double dbly = wl_fixed_to_double(fy) * window_data->pointer_scale_y;
     const float x = dblx / window_data->sdlwindow->w;
     const float y = dbly / window_data->sdlwindow->h;
 
@@ -748,8 +755,8 @@ touch_handler_motion(void *data, struct wl_touch *touch, unsigned int timestamp,
                      int id, wl_fixed_t fx, wl_fixed_t fy)
 {
     SDL_WindowData *window_data = (SDL_WindowData *)wl_surface_get_user_data(touch_surface(id));
-    const double dblx = wl_fixed_to_double(fx);
-    const double dbly = wl_fixed_to_double(fy);
+    const double dblx = wl_fixed_to_double(fx) * window_data->pointer_scale_x;
+    const double dbly = wl_fixed_to_double(fy) * window_data->pointer_scale_y;
     const float x = dblx / window_data->sdlwindow->w;
     const float y = dbly / window_data->sdlwindow->h;
 
@@ -815,6 +822,16 @@ keyboard_handle_keymap(void *data, struct wl_keyboard *keyboard,
         return;
     }
 
+    #define GET_MOD_INDEX(mod) \
+        WAYLAND_xkb_keymap_mod_get_index(input->xkb.keymap, XKB_MOD_NAME_##mod)
+    input->xkb.idx_shift = 1 << GET_MOD_INDEX(SHIFT);
+    input->xkb.idx_ctrl = 1 << GET_MOD_INDEX(CTRL);
+    input->xkb.idx_alt = 1 << GET_MOD_INDEX(ALT);
+    input->xkb.idx_gui = 1 << GET_MOD_INDEX(LOGO);
+    input->xkb.idx_num = 1 << GET_MOD_INDEX(NUM);
+    input->xkb.idx_caps = 1 << GET_MOD_INDEX(CAPS);
+    #undef GET_MOD_INDEX
+
     input->xkb.state = WAYLAND_xkb_state_new(input->xkb.keymap);
     if (!input->xkb.state) {
         fprintf(stderr, "failed to create XKB state\n");
@@ -829,10 +846,14 @@ keyboard_handle_keymap(void *data, struct wl_keyboard *keyboard,
      */
 
     /* Look up the preferred locale, falling back to "C" as default */
-    if (!(locale = SDL_getenv("LC_ALL")))
-        if (!(locale = SDL_getenv("LC_CTYPE")))
-            if (!(locale = SDL_getenv("LANG")))
+    if (!(locale = SDL_getenv("LC_ALL"))) {
+        if (!(locale = SDL_getenv("LC_CTYPE"))) {
+            if (!(locale = SDL_getenv("LANG"))) {
                 locale = "C";
+            }
+        }
+    }
+
     /* Set up XKB compose table */
     input->xkb.compose_table = WAYLAND_xkb_compose_table_new_from_locale(input->display->xkb_context,
                                               locale, XKB_COMPOSE_COMPILE_NO_FLAGS);
@@ -903,7 +924,7 @@ keyboard_handle_leave(void *data, struct wl_keyboard *keyboard,
 }
 
 static SDL_bool
-keyboard_input_get_text(char text[8], const struct SDL_WaylandInput *input, uint32_t key, SDL_bool *handled_by_ime)
+keyboard_input_get_text(char text[8], const struct SDL_WaylandInput *input, uint32_t key, Uint8 state, SDL_bool *handled_by_ime)
 {
     SDL_WindowData *window = input->keyboard_focus;
     const xkb_keysym_t *syms;
@@ -920,12 +941,16 @@ keyboard_input_get_text(char text[8], const struct SDL_WaylandInput *input, uint
     sym = syms[0];
 
 #ifdef SDL_USE_IME
-    if (SDL_IME_ProcessKeyEvent(sym, key + 8)) {
+    if (SDL_IME_ProcessKeyEvent(sym, key + 8, state)) {
         *handled_by_ime = SDL_TRUE;
         return SDL_TRUE;
     }
 #endif
 
+    if (state == SDL_RELEASED) {
+        return SDL_FALSE;
+    }
+
     if (input->xkb.compose_state && WAYLAND_xkb_compose_state_feed(input->xkb.compose_state, sym) == XKB_COMPOSE_FEED_ACCEPTED) {
         switch(WAYLAND_xkb_compose_state_get_status(input->xkb.compose_state)) {
             case XKB_COMPOSE_COMPOSING:
@@ -959,7 +984,7 @@ keyboard_handle_key(void *data, struct wl_keyboard *keyboard,
     SDL_bool handled_by_ime = SDL_FALSE;
 
     if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
-        has_text = keyboard_input_get_text(text, input, key, &handled_by_ime);
+        has_text = keyboard_input_get_text(text, input, key, SDL_PRESSED, &handled_by_ime);
     } else {
         if (keyboard_repeat_is_set(&input->keyboard_repeat)) {
             // Send any due key repeat events before stopping the repeat and generating the key up event
@@ -969,6 +994,7 @@ keyboard_handle_key(void *data, struct wl_keyboard *keyboard,
             keyboard_repeat_handle(&input->keyboard_repeat, time - input->keyboard_repeat.wl_press_time);
             keyboard_repeat_clear(&input->keyboard_repeat);
         }
+        keyboard_input_get_text(text, input, key, SDL_RELEASED, &handled_by_ime);
     }
 
     if (!handled_by_ime && key < SDL_arraysize(xfree86_scancode_table2)) {
@@ -1054,10 +1080,24 @@ keyboard_handle_modifiers(void *data, struct wl_keyboard *keyboard,
 {
     struct SDL_WaylandInput *input = data;
     Wayland_Keymap keymap;
+    uint32_t modstate = (mods_depressed | mods_latched | mods_locked);
 
     WAYLAND_xkb_state_update_mask(input->xkb.state, mods_depressed, mods_latched,
                           mods_locked, 0, 0, group);
 
+    SDL_ToggleModState(KMOD_SHIFT, modstate & input->xkb.idx_shift);
+    SDL_ToggleModState(KMOD_CTRL, modstate & input->xkb.idx_ctrl);
+    SDL_ToggleModState(KMOD_ALT, modstate & input->xkb.idx_alt);
+    SDL_ToggleModState(KMOD_GUI, modstate & input->xkb.idx_gui);
+    SDL_ToggleModState(KMOD_NUM, modstate & input->xkb.idx_num);
+    SDL_ToggleModState(KMOD_CAPS, modstate & input->xkb.idx_caps);
+
+    if (group == input->xkb.current_group) {
+        return;
+    }
+
+    /* The layout changed, remap and fire an event */
+    input->xkb.current_group = group;
     keymap.layout = group;
     SDL_GetDefaultKeymap(keymap.keymap);
     WAYLAND_xkb_keymap_key_for_each(input->xkb.keymap,
@@ -1646,6 +1686,363 @@ Wayland_add_text_input_manager(SDL_VideoData *d, uint32_t id, uint32_t version)
     }
 }
 
+static void
+tablet_tool_handle_type(void* data, struct zwp_tablet_tool_v2* tool, uint32_t type)
+{
+    /* unimplemented */
+}
+
+static void
+tablet_tool_handle_hardware_serial(void* data, struct zwp_tablet_tool_v2* tool, uint32_t serial_hi, uint32_t serial_lo)
+{
+    /* unimplemented */
+}
+
+static void
+tablet_tool_handle_hardware_id_wacom(void* data, struct zwp_tablet_tool_v2* tool, uint32_t id_hi, uint32_t id_lo)
+{
+    /* unimplemented */
+}
+
+static void
+tablet_tool_handle_capability(void* data, struct zwp_tablet_tool_v2* tool, uint32_t capability)
+{
+    /* unimplemented */
+}
+
+static void
+tablet_tool_handle_done(void* data, struct zwp_tablet_tool_v2* tool)
+{
+    /* unimplemented */
+}
+
+static void
+tablet_tool_handle_removed(void* data, struct zwp_tablet_tool_v2* tool)
+{
+    /* unimplemented */
+}
+
+static void
+tablet_tool_handle_proximity_in(void* data, struct zwp_tablet_tool_v2* tool, uint32_t serial, struct zwp_tablet_v2* tablet, struct wl_surface* surface)
+{
+    struct SDL_WaylandTabletInput* input = data;
+    SDL_WindowData* window;
+
+    if (!surface) {
+        return;
+    }
+
+    if (!SDL_WAYLAND_own_surface(surface)) {
+        return;
+    }
+
+    window = (SDL_WindowData*)wl_surface_get_user_data(surface);
+
+    if (window) {
+        input->tool_focus = window;
+        input->tool_prox_serial = serial;
+
+        input->is_down = SDL_FALSE;
+
+        input->btn_stylus = SDL_FALSE;
+        input->btn_stylus2 = SDL_FALSE;
+        input->btn_stylus3 = SDL_FALSE;
+
+        SDL_SetMouseFocus(window->sdlwindow);
+        SDL_SetCursor(NULL);
+    }
+}
+
+static void
+tablet_tool_handle_proximity_out(void* data, struct zwp_tablet_tool_v2* tool)
+{
+    struct SDL_WaylandTabletInput* input = data;
+
+    if (input->tool_focus) {
+        SDL_SetMouseFocus(NULL);
+        input->tool_focus = NULL;
+    }
+}
+
+uint32_t
+tablet_tool_btn_to_sdl_button(struct SDL_WaylandTabletInput* input)
+{
+    unsigned int tool_btn = input->btn_stylus3 << 2 | input->btn_stylus2 << 1 | input->btn_stylus << 0;
+    switch (tool_btn) {
+        case 0b000:
+            return SDL_BUTTON_LEFT;
+        case 0b001:
+            return SDL_BUTTON_RIGHT;
+        case 0b010:
+            return SDL_BUTTON_MIDDLE;
+        case 0b100:
+            return SDL_BUTTON_X1;
+        default:
+            return SDL_BUTTON_LEFT;
+    }
+}
+
+static void
+tablet_tool_handle_down(void* data, struct zwp_tablet_tool_v2* tool, uint32_t serial)
+{
+    struct SDL_WaylandTabletInput* input = data;
+    SDL_WindowData* window = input->tool_focus;
+    input->is_down = SDL_TRUE;
+    if (!window) {
+        /* tablet_tool_handle_proximity_out gets called when moving over the libdecoration csd.
+         * that sets input->tool_focus (window) to NULL, but handle_{down,up} events are still
+         * received. To prevent SIGSEGV this returns when this is the case.
+         */
+        return;
+    }
+
+    SDL_SendMouseButton(window->sdlwindow, 0, SDL_PRESSED, tablet_tool_btn_to_sdl_button(input));
+}
+
+static void
+tablet_tool_handle_up(void* data, struct zwp_tablet_tool_v2* tool)
+{
+    struct SDL_WaylandTabletInput* input = data;
+    SDL_WindowData* window = input->tool_focus;
+
+    input->is_down = SDL_FALSE;
+
+    if (!window) {
+        /* tablet_tool_handle_proximity_out gets called when moving over the libdecoration csd.
+         * that sets input->tool_focus (window) to NULL, but handle_{down,up} events are still
+         * received. To prevent SIGSEGV this returns when this is the case.
+         */
+        return;
+    }
+
+    SDL_SendMouseButton(window->sdlwindow, 0, SDL_RELEASED, tablet_tool_btn_to_sdl_button(input));
+}
+
+static void
+tablet_tool_handle_motion(void* data, struct zwp_tablet_tool_v2* tool, wl_fixed_t sx_w, wl_fixed_t sy_w)
+{
+    struct SDL_WaylandTabletInput* input = data;
+    SDL_WindowData* window = input->tool_focus;
+
+    input->sx_w = sx_w;
+    input->sy_w = sy_w;
+    if (input->tool_focus) {
+        const float sx_f = (float)wl_fixed_to_double(sx_w);
+        const float sy_f = (float)wl_fixed_to_double(sy_w);
+        const int   sx   = (int)SDL_floorf(sx_f * window->pointer_scale_x);
+        const int   sy   = (int)SDL_floorf(sy_f * window->pointer_scale_y);
+        SDL_SendMouseMotion(window->sdlwindow, 0, 0, sx, sy);
+    }
+}
+
+static void
+tablet_tool_handle_pressure(void* data, struct zwp_tablet_tool_v2* tool, uint32_t pressure)
+{
+    /* unimplemented */
+}
+
+static void
+tablet_tool_handle_distance(void* data, struct zwp_tablet_tool_v2* tool, uint32_t distance)
+{
+    /* unimplemented */
+}
+
+static void
+tablet_tool_handle_tilt(void* data, struct zwp_tablet_tool_v2* tool, wl_fixed_t xtilt, wl_fixed_t ytilt)
+{
+    /* unimplemented */
+}
+
+static void
+tablet_tool_handle_button(void* data, struct zwp_tablet_tool_v2* tool, uint32_t serial, uint32_t button, uint32_t state)
+{
+    struct SDL_WaylandTabletInput* input = data;
+
+    if (input->is_down) {
+        tablet_tool_handle_up(data, tool);
+        input->is_down = SDL_TRUE;
+    }
+
+    switch (button) {
+        /* see %{_includedir}/linux/input-event-codes.h */
+        case 0x14b: /* BTN_STYLUS */
+            input->btn_stylus = state == ZWP_TABLET_PAD_V2_BUTTON_STATE_PRESSED ? SDL_TRUE : SDL_FALSE;
+            break;
+        case 0x14c: /* BTN_STYLUS2 */
+            input->btn_stylus2 = state == ZWP_TABLET_PAD_V2_BUTTON_STATE_PRESSED ? SDL_TRUE : SDL_FALSE;
+            break;
+        case 0x149: /* BTN_STYLUS3 */
+            input->btn_stylus3 = state == ZWP_TABLET_PAD_V2_BUTTON_STATE_PRESSED ? SDL_TRUE : SDL_FALSE;
+            break;
+    }
+
+    if (input->is_down) {
+        tablet_tool_handle_down(data, tool, serial);
+    }
+}
+
+static void
+tablet_tool_handle_rotation(void* data, struct zwp_tablet_tool_v2* tool, wl_fixed_t degrees)
+{
+    /* unimplemented */
+}
+
+static void
+tablet_tool_handle_slider(void* data, struct zwp_tablet_tool_v2* tool, int32_t position)
+{
+    /* unimplemented */
+}
+
+static void
+tablet_tool_handle_wheel(void* data, struct zwp_tablet_tool_v2* tool, int32_t degrees, int32_t clicks)
+{
+    /* unimplemented */
+}
+
+static void
+tablet_tool_handle_frame(void* data, struct zwp_tablet_tool_v2* tool, uint32_t time)
+{
+    /* unimplemented */
+}
+
+
+static const struct zwp_tablet_tool_v2_listener tablet_tool_listener = {
+    tablet_tool_handle_type,
+    tablet_tool_handle_hardware_serial,
+    tablet_tool_handle_hardware_id_wacom,
+    tablet_tool_handle_capability,
+    tablet_tool_handle_done,
+    tablet_tool_handle_removed,
+    tablet_tool_handle_proximity_in,
+    tablet_tool_handle_proximity_out,
+    tablet_tool_handle_down,
+    tablet_tool_handle_up,
+    tablet_tool_handle_motion,
+    tablet_tool_handle_pressure,
+    tablet_tool_handle_distance,
+    tablet_tool_handle_tilt,
+    tablet_tool_handle_rotation,
+    tablet_tool_handle_slider,
+    tablet_tool_handle_wheel,
+    tablet_tool_handle_button,
+    tablet_tool_handle_frame
+};
+
+struct SDL_WaylandTabletObjectListNode*
+tablet_object_list_new_node(void* object)
+{
+    struct SDL_WaylandTabletObjectListNode* node;
+
+    node = SDL_calloc(1, sizeof *node);
+    if (node == NULL) {
+        return NULL;
+    }
+
+    node->next = NULL;
+    node->object = object;
+
+    return node;
+}
+
+void tablet_object_list_append(struct SDL_WaylandTabletObjectListNode* head, void* object)
+{
+    if (head->object == NULL) {
+        head->object = object;
+        return;
+    }
+
+    while (head->next) {
+        head = head->next;
+    }
+
+    head->next = tablet_object_list_new_node(object);
+}
+
+void tablet_object_list_destroy(struct SDL_WaylandTabletObjectListNode* head, void (*deleter)(void* object))
+{
+    while (head) {
+        struct SDL_WaylandTabletObjectListNode* next = head->next;
+        if (head->object) {
+            (*deleter)(head->object);
+        }
+        SDL_free(head);
+        head = next;
+    }
+}
+
+
+static void
+tablet_seat_handle_tablet_added(void* data, struct zwp_tablet_seat_v2* seat, struct zwp_tablet_v2* tablet)
+{
+    struct SDL_WaylandTabletInput* input = data;
+
+    tablet_object_list_append(input->tablets, tablet);
+}
+
+static void
+tablet_seat_handle_tool_added(void* data, struct zwp_tablet_seat_v2* seat, struct zwp_tablet_tool_v2* tool)
+{
+    struct SDL_WaylandTabletInput* input = data;
+
+    zwp_tablet_tool_v2_add_listener(tool, &tablet_tool_listener, data);
+    zwp_tablet_tool_v2_set_user_data(tool, data);
+
+    tablet_object_list_append(input->tools, tool);
+}
+
+static void
+tablet_seat_handle_pad_added(void* data, struct zwp_tablet_seat_v2* seat, struct zwp_tablet_pad_v2* pad)
+{
+    struct SDL_WaylandTabletInput* input = data;
+
+    tablet_object_list_append(input->pads, pad);
+}
+
+static const struct zwp_tablet_seat_v2_listener tablet_seat_listener = {
+    tablet_seat_handle_tablet_added,
+    tablet_seat_handle_tool_added,
+    tablet_seat_handle_pad_added
+};
+
+void
+Wayland_input_add_tablet(struct SDL_WaylandInput *input, struct SDL_WaylandTabletManager* tablet_manager)
+{
+    struct SDL_WaylandTabletInput* tablet_input;
+
+    if (!tablet_manager || !input || !input->seat) {
+        return;
+    }
+
+    tablet_input = SDL_calloc(1, sizeof *tablet_input);
+    if (tablet_input == NULL) {
+        return;
+    }
+
+    input->tablet = tablet_input;
+
+    tablet_input->seat = (struct SDL_WaylandTabletSeat*)zwp_tablet_manager_v2_get_tablet_seat((struct zwp_tablet_manager_v2*)tablet_manager, input->seat);
+
+    tablet_input->tablets = tablet_object_list_new_node(NULL);
+    tablet_input->tools = tablet_object_list_new_node(NULL);
+    tablet_input->pads = tablet_object_list_new_node(NULL);
+
+    zwp_tablet_seat_v2_add_listener((struct zwp_tablet_seat_v2*)tablet_input->seat, &tablet_seat_listener, tablet_input);
+}
+
+#define TABLET_OBJECT_LIST_DELETER(fun) (void (*)(void*))fun
+void
+Wayland_input_destroy_tablet(struct SDL_WaylandInput* input)
+{
+    tablet_object_list_destroy(input->tablet->pads, TABLET_OBJECT_LIST_DELETER(zwp_tablet_pad_v2_destroy));
+    tablet_object_list_destroy(input->tablet->tools, TABLET_OBJECT_LIST_DELETER(zwp_tablet_tool_v2_destroy));
+    tablet_object_list_destroy(input->tablet->tablets, TABLET_OBJECT_LIST_DELETER(zwp_tablet_v2_destroy));
+
+    zwp_tablet_seat_v2_destroy((struct zwp_tablet_seat_v2*)input->tablet->seat);
+
+    SDL_free(input->tablet);
+    input->tablet = NULL;
+}
+
 void
 Wayland_display_add_input(SDL_VideoData *d, uint32_t id, uint32_t version)
 {
@@ -1659,6 +2056,7 @@ Wayland_display_add_input(SDL_VideoData *d, uint32_t id, uint32_t version)
     input->seat = wl_registry_bind(d->registry, id, &wl_seat_interface, SDL_min(5, version));
     input->sx_w = wl_fixed_from_int(0);
     input->sy_w = wl_fixed_from_int(0);
+    input->xkb.current_group = ~0;
     d->input = input;
 
     if (d->data_device_manager != NULL) {
@@ -1671,6 +2069,10 @@ Wayland_display_add_input(SDL_VideoData *d, uint32_t id, uint32_t version)
     wl_seat_add_listener(input->seat, &seat_listener, input);
     wl_seat_set_user_data(input->seat, input);
 
+    if (d->tablet_manager) {
+        Wayland_input_add_tablet(input, d->tablet_manager);
+    }
+
     WAYLAND_wl_display_flush(d->display);
 }
 
@@ -1711,6 +2113,10 @@ void Wayland_display_destroy_input(SDL_VideoData *d)
         wl_touch_destroy(input->touch);
     }
 
+    if (input->tablet) {
+        Wayland_input_destroy_tablet(input);
+    }
+
     if (input->seat)
         wl_seat_destroy(input->seat);
 
@@ -1951,12 +2357,19 @@ int Wayland_input_confine_pointer(struct SDL_WaylandInput *input, SDL_Window *wi
     if (SDL_RectEmpty(&window->mouse_rect)) {
         confine_rect = NULL;
     } else {
+        SDL_Rect scaled_mouse_rect;
+
+        scaled_mouse_rect.x = (int)SDL_floorf((float)window->mouse_rect.x / w->pointer_scale_x);
+        scaled_mouse_rect.y = (int)SDL_floorf((float)window->mouse_rect.y / w->pointer_scale_y);
+        scaled_mouse_rect.w = (int)SDL_ceilf((float)window->mouse_rect.w / w->pointer_scale_x);
+        scaled_mouse_rect.h = (int)SDL_ceilf((float)window->mouse_rect.h / w->pointer_scale_y);
+
         confine_rect = wl_compositor_create_region(d->compositor);
         wl_region_add(confine_rect,
-                      window->mouse_rect.x,
-                      window->mouse_rect.y,
-                      window->mouse_rect.w,
-                      window->mouse_rect.h);
+                      scaled_mouse_rect.x,
+                      scaled_mouse_rect.y,
+                      scaled_mouse_rect.w,
+                      scaled_mouse_rect.h);
     }
 
     confined_pointer =
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandevents_c.h b/Engine/lib/sdl/src/video/wayland/SDL_waylandevents_c.h
index 24256a7d0..59dc0c8af 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandevents_c.h
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandevents_c.h
@@ -29,6 +29,34 @@
 #include "SDL_waylanddatamanager.h"
 #include "SDL_waylandkeyboard.h"
 
+struct SDL_WaylandTabletSeat;
+
+struct SDL_WaylandTabletObjectListNode {
+    void* object;
+    struct SDL_WaylandTabletObjectListNode* next;
+};
+
+struct SDL_WaylandTabletInput {
+    struct SDL_WaylandTabletSeat* seat;
+
+    struct SDL_WaylandTabletObjectListNode* tablets;
+    struct SDL_WaylandTabletObjectListNode* tools;
+    struct SDL_WaylandTabletObjectListNode* pads;
+
+    SDL_WindowData *tool_focus;
+    uint32_t tool_prox_serial;
+
+    /* Last motion location */
+    wl_fixed_t sx_w;
+    wl_fixed_t sy_w;
+
+    SDL_bool is_down;
+
+    SDL_bool btn_stylus;
+    SDL_bool btn_stylus2;
+    SDL_bool btn_stylus3;
+};
+
 typedef struct {
     // repeat_rate in range of [1, 1000]
     int32_t repeat_rate;
@@ -68,6 +96,17 @@ struct SDL_WaylandInput {
         struct xkb_state *state;
         struct xkb_compose_table *compose_table;
         struct xkb_compose_state *compose_state;
+
+        /* Keyboard layout "group" */
+        uint32_t current_group;
+
+        /* Modifier bitshift values */
+        uint32_t idx_shift;
+        uint32_t idx_ctrl;
+        uint32_t idx_alt;
+        uint32_t idx_gui;
+        uint32_t idx_num;
+        uint32_t idx_caps;
     } xkb;
 
     /* information about axis events on current frame */
@@ -80,6 +119,8 @@ struct SDL_WaylandInput {
     } pointer_curr_axis_info;
 
     SDL_WaylandKeyboardRepeat keyboard_repeat;
+
+    struct SDL_WaylandTabletInput* tablet;
 };
 
 extern void Wayland_PumpEvents(_THIS);
@@ -107,6 +148,9 @@ extern void Wayland_display_destroy_relative_pointer_manager(SDL_VideoData *d);
 extern int Wayland_input_grab_keyboard(SDL_Window *window, struct SDL_WaylandInput *input);
 extern int Wayland_input_ungrab_keyboard(SDL_Window *window);
 
+extern void Wayland_input_add_tablet(struct SDL_WaylandInput *input, struct SDL_WaylandTabletManager* tablet_manager);
+extern void Wayland_input_destroy_tablet(struct SDL_WaylandInput *input);
+
 #endif /* SDL_waylandevents_h_ */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandopengles.c b/Engine/lib/sdl/src/video/wayland/SDL_waylandopengles.c
index 6b10cbee7..4c834fd86 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandopengles.c
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandopengles.c
@@ -205,11 +205,11 @@ Wayland_GLES_GetDrawableSize(_THIS, SDL_Window * window, int * w, int * h)
         data = (SDL_WindowData *) window->driverdata;
 
         if (w) {
-            *w = window->w * data->scale_factor;
+            *w = data->drawable_width;
         }
 
         if (h) {
-            *h = window->h * data->scale_factor;
+            *h = data->drawable_height;
         }
     }
 }
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandsym.h b/Engine/lib/sdl/src/video/wayland/SDL_waylandsym.h
index fa29bedb1..6891325c7 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandsym.h
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandsym.h
@@ -72,21 +72,19 @@ SDL_WAYLAND_SYM(void, wl_list_remove, (struct wl_list *))
 SDL_WAYLAND_SYM(int, wl_list_length, (const struct wl_list *))
 SDL_WAYLAND_SYM(int, wl_list_empty, (const struct wl_list *))
 SDL_WAYLAND_SYM(void, wl_list_insert_list, (struct wl_list *, struct wl_list *))
-
-/* These functions are available in Wayland >= 1.4 */
-SDL_WAYLAND_MODULE(WAYLAND_CLIENT_1_4)
 SDL_WAYLAND_SYM(struct wl_proxy *, wl_proxy_marshal_constructor, (struct wl_proxy *, uint32_t opcode, const struct wl_interface *interface, ...))
-
-SDL_WAYLAND_MODULE(WAYLAND_CLIENT_1_10)
 SDL_WAYLAND_SYM(struct wl_proxy *, wl_proxy_marshal_constructor_versioned, (struct wl_proxy *proxy, uint32_t opcode, const struct wl_interface *interface, uint32_t version, ...))
-
-SDL_WAYLAND_MODULE(WAYLAND_CLIENT_1_18)
 SDL_WAYLAND_SYM(void, wl_proxy_set_tag, (struct wl_proxy *, const char * const *))
 SDL_WAYLAND_SYM(const char * const *, wl_proxy_get_tag, (struct wl_proxy *))
 
-SDL_WAYLAND_MODULE(WAYLAND_CLIENT_1_20)
+#if SDL_WAYLAND_CHECK_VERSION(1, 20, 0)
+/* wayland-scanner 1.20 generates code that will call these, so these are
+ * non-optional when we are compiling against Wayland 1.20. We don't
+ * explicitly call them ourselves, though, so if we are only compiling
+ * against Wayland 1.18, they're unnecessary. */
 SDL_WAYLAND_SYM(struct wl_proxy*, wl_proxy_marshal_flags, (struct wl_proxy *proxy, uint32_t opcode, const struct wl_interface *interfac, uint32_t version, uint32_t flags, ...))
 SDL_WAYLAND_SYM(struct wl_proxy*, wl_proxy_marshal_array_flags, (struct wl_proxy *proxy, uint32_t opcode, const struct wl_interface *interface, uint32_t version,  uint32_t flags, union wl_argument *args))
+#endif
 
 SDL_WAYLAND_INTERFACE(wl_seat_interface)
 SDL_WAYLAND_INTERFACE(wl_surface_interface)
@@ -149,6 +147,8 @@ SDL_WAYLAND_SYM(int, xkb_keymap_key_get_syms_by_level, (struct xkb_keymap *,
                                                         xkb_layout_index_t,
                                                         const xkb_keysym_t **) )
 SDL_WAYLAND_SYM(uint32_t, xkb_keysym_to_utf32, (xkb_keysym_t) )
+SDL_WAYLAND_SYM(uint32_t, xkb_keymap_mod_get_index, (struct xkb_keymap *,
+                                                      const char *) )
 
 #ifdef HAVE_LIBDECOR_H
 SDL_WAYLAND_MODULE(WAYLAND_LIBDECOR)
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandvideo.c b/Engine/lib/sdl/src/video/wayland/SDL_waylandvideo.c
index 61940cca4..0305c46a1 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandvideo.c
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandvideo.c
@@ -52,6 +52,9 @@
 #include "idle-inhibit-unstable-v1-client-protocol.h"
 #include "xdg-activation-v1-client-protocol.h"
 #include "text-input-unstable-v3-client-protocol.h"
+#include "tablet-unstable-v2-client-protocol.h"
+#include "xdg-output-unstable-v1-client-protocol.h"
+#include "viewporter-client-protocol.h"
 
 #ifdef HAVE_LIBDECOR_H
 #include <libdecor.h>
@@ -59,6 +62,9 @@
 
 #define WAYLANDVID_DRIVER_NAME "wayland"
 
+static void
+display_handle_done(void *data, struct wl_output *output);
+
 /* Initialization/Query functions */
 static int
 Wayland_VideoInit(_THIS);
@@ -133,32 +139,22 @@ static const char *SDL_WAYLAND_output_tag = "sdl-output";
 
 void SDL_WAYLAND_register_surface(struct wl_surface *surface)
 {
-    if (SDL_WAYLAND_HAVE_WAYLAND_CLIENT_1_18) {
-        wl_proxy_set_tag((struct wl_proxy *)surface, &SDL_WAYLAND_surface_tag);
-    }
+    wl_proxy_set_tag((struct wl_proxy *)surface, &SDL_WAYLAND_surface_tag);
 }
 
 void SDL_WAYLAND_register_output(struct wl_output *output)
 {
-    if (SDL_WAYLAND_HAVE_WAYLAND_CLIENT_1_18) {
-        wl_proxy_set_tag((struct wl_proxy *)output, &SDL_WAYLAND_output_tag);
-    }
+    wl_proxy_set_tag((struct wl_proxy *)output, &SDL_WAYLAND_output_tag);
 }
 
 SDL_bool SDL_WAYLAND_own_surface(struct wl_surface *surface)
 {
-    if (SDL_WAYLAND_HAVE_WAYLAND_CLIENT_1_18) {
-        return wl_proxy_get_tag((struct wl_proxy *) surface) == &SDL_WAYLAND_surface_tag;
-    }
-    return SDL_TRUE; /* For older clients we have to assume this is us... */
+    return wl_proxy_get_tag((struct wl_proxy *) surface) == &SDL_WAYLAND_surface_tag;
 }
 
 SDL_bool SDL_WAYLAND_own_output(struct wl_output *output)
 {
-    if (SDL_WAYLAND_HAVE_WAYLAND_CLIENT_1_18) {
-        return wl_proxy_get_tag((struct wl_proxy *) output) == &SDL_WAYLAND_output_tag;
-    }
-    return SDL_TRUE; /* For older clients we have to assume this is us... */
+    return wl_proxy_get_tag((struct wl_proxy *) output) == &SDL_WAYLAND_output_tag;
 }
 
 static void
@@ -283,6 +279,8 @@ Wayland_CreateDevice(int devindex)
 
     device->free = Wayland_DeleteDevice;
 
+    device->disable_display_mode_switching = SDL_TRUE;
+
     return device;
 }
 
@@ -291,6 +289,155 @@ VideoBootStrap Wayland_bootstrap = {
     Wayland_CreateDevice
 };
 
+static void
+xdg_output_handle_logical_position(void *data, struct zxdg_output_v1 *xdg_output,
+                                   int32_t x, int32_t y)
+{
+    SDL_WaylandOutputData* driverdata = data;
+
+    driverdata->x = x;
+    driverdata->y = y;
+    driverdata->has_logical_position = SDL_TRUE;
+}
+
+static void
+xdg_output_handle_logical_size(void *data, struct zxdg_output_v1 *xdg_output,
+                               int32_t width, int32_t height)
+{
+    SDL_WaylandOutputData* driverdata = data;
+
+    if (driverdata->width != 0 && driverdata->height != 0) {
+        /* FIXME: GNOME has a bug where the logical size does not account for
+         * scale, resulting in bogus viewport sizes.
+         *
+         * Until this is fixed, validate that _some_ kind of scaling is being
+         * done (we can't match exactly because fractional scaling can't be
+         * detected otherwise), then override if necessary.
+         * -flibit
+         */
+        const float scale = (float) driverdata->width / (float) width;
+        if ((scale == 1.0f) && (driverdata->scale_factor != 1.0f)) {
+            SDL_LogWarn(
+                SDL_LOG_CATEGORY_VIDEO,
+                "xdg_output scale did not match, overriding with wl_output scale"
+            );
+            return;
+        }
+    }
+
+    driverdata->width = width;
+    driverdata->height = height;
+    driverdata->has_logical_size = SDL_TRUE;
+}
+
+static void
+xdg_output_handle_done(void *data, struct zxdg_output_v1 *xdg_output)
+{
+    SDL_WaylandOutputData* driverdata = data;
+
+    /*
+     * xdg-output.done events are deprecated and only apply below version 3 of the protocol.
+     * A wl-output.done event will be emitted in version 3 or higher.
+     */
+    if (zxdg_output_v1_get_version(driverdata->xdg_output) < 3) {
+        display_handle_done(data, driverdata->output);
+    }
+}
+
+static void
+xdg_output_handle_name(void *data, struct zxdg_output_v1 *xdg_output,
+                       const char *name)
+{
+}
+
+static void
+xdg_output_handle_description(void *data, struct zxdg_output_v1 *xdg_output,
+                              const char *description)
+{
+}
+
+static const struct zxdg_output_v1_listener xdg_output_listener = {
+        xdg_output_handle_logical_position,
+        xdg_output_handle_logical_size,
+        xdg_output_handle_done,
+        xdg_output_handle_name,
+        xdg_output_handle_description,
+};
+
+static void
+AddEmulatedModes(SDL_VideoDisplay *dpy, SDL_bool rot_90)
+{
+    struct EmulatedMode
+    {
+        int w;
+        int h;
+    };
+
+    /* Resolution lists courtesy of XWayland */
+    const struct EmulatedMode mode_list[] = {
+        /* 16:9 (1.77) */
+        { 7680, 4320 },
+        { 6144, 3160 },
+        { 5120, 2880 },
+        { 4096, 2304 },
+        { 3840, 2160 },
+        { 3200, 1800 },
+        { 2880, 1620 },
+        { 2560, 1440 },
+        { 2048, 1152 },
+        { 1920, 1080 },
+        { 1600, 900 },
+        { 1368, 768 },
+        { 1280, 720 },
+        { 864, 486 },
+
+        /* 16:10 (1.6) */
+        { 2560, 1600 },
+        { 1920, 1200 },
+        { 1680, 1050 },
+        { 1440, 900 },
+        { 1280, 800 },
+
+        /* 3:2 (1.5) */
+        { 720, 480 },
+
+        /* 4:3 (1.33) */
+        { 2048, 1536 },
+        { 1920, 1440 },
+        { 1600, 1200 },
+        { 1440, 1080 },
+        { 1400, 1050 },
+        { 1280, 1024 },
+        { 1280, 960 },
+        { 1152, 864 },
+        { 1024, 768 },
+        { 800, 600 },
+        { 640, 480 }
+    };
+
+    int i;
+    const int native_width  = dpy->display_modes->w;
+    const int native_height = dpy->display_modes->h;
+
+    for (i = 0; i < SDL_arraysize(mode_list); ++i) {
+        /* Only add modes that are smaller than the native mode */
+        if ((mode_list[i].w < native_width && mode_list[i].h < native_height) ||
+            (mode_list[i].w < native_width && mode_list[i].h == native_height)) {
+            SDL_DisplayMode mode = *dpy->display_modes;
+
+            if (rot_90) {
+                mode.w = mode_list[i].h;
+                mode.h = mode_list[i].w;
+            } else {
+                mode.w = mode_list[i].w;
+                mode.h = mode_list[i].h;
+            }
+
+            SDL_AddDisplayMode(dpy, &mode);
+        }
+    }
+}
+
 static void
 display_handle_geometry(void *data,
                         struct wl_output *output,
@@ -307,7 +454,7 @@ display_handle_geometry(void *data,
     SDL_VideoDisplay *display;
     int i;
 
-    if (driverdata->done) {
+    if (driverdata->wl_output_done_count) {
         /* Clear the wl_output ref so Reset doesn't free it */
         display = SDL_GetDisplay(driverdata->index);
         for (i = 0; i < display->num_display_modes; i += 1) {
@@ -318,11 +465,14 @@ display_handle_geometry(void *data,
         SDL_ResetDisplayModes(driverdata->index);
 
         /* The display has officially started over. */
-        driverdata->done = SDL_FALSE;
+        driverdata->wl_output_done_count = 0;
     }
 
-    driverdata->x = x;
-    driverdata->y = y;
+    /* Apply the change from wl-output only if xdg-output is not supported */
+    if (!driverdata->has_logical_position) {
+        driverdata->x = x;
+        driverdata->y = y;
+    }
     driverdata->physical_width = physical_width;
     driverdata->physical_height = physical_height;
     if (driverdata->index == -1) {
@@ -369,36 +519,21 @@ display_handle_mode(void *data,
                     int refresh)
 {
     SDL_WaylandOutputData* driverdata = data;
-    SDL_DisplayMode mode;
 
     if (flags & WL_OUTPUT_MODE_CURRENT) {
-        /* Don't rotate this yet, handle_done will do it later */
-        driverdata->width = width;
-        driverdata->height = height;
-        driverdata->refresh = refresh;
-    }
+        driverdata->native_width  = width;
+        driverdata->native_height = height;
 
-    /* Note that the width/height are NOT multiplied by scale_factor!
-     * This is intentional and is designed to get the unscaled modes, which is
-     * important for high-DPI games intending to use the display mode as the
-     * target drawable size. The scaled desktop mode will be added at the end
-     * when display_handle_done is called (see below).
-     */
-    SDL_zero(mode);
-    mode.format = SDL_PIXELFORMAT_RGB888;
-    if (driverdata->transform & WL_OUTPUT_TRANSFORM_90) {
-        mode.w = height;
-        mode.h = width;
-    } else {
-        mode.w = width;
-        mode.h = height;
-    }
-    mode.refresh_rate = (int)SDL_round(refresh / 1000.0); /* mHz to Hz */
-    mode.driverdata = driverdata->output;
-    if (driverdata->index > -1) {
-        SDL_AddDisplayMode(SDL_GetDisplay(driverdata->index), &mode);
-    } else {
-        SDL_AddDisplayMode(&driverdata->placeholder, &mode);
+        /*
+         * Don't rotate this yet, wl-output coordinates are transformed in
+         * handle_done and xdg-output coordinates are pre-transformed.
+         */
+        if (!driverdata->has_logical_size) {
+            driverdata->width  = width;
+            driverdata->height = height;
+        }
+
+        driverdata->refresh = refresh;
     }
 }
 
@@ -407,20 +542,73 @@ display_handle_done(void *data,
                     struct wl_output *output)
 {
     SDL_WaylandOutputData* driverdata = data;
-    SDL_DisplayMode mode;
+    SDL_VideoData* video = driverdata->videodata;
+    SDL_DisplayMode native_mode, desktop_mode;
     SDL_VideoDisplay *dpy;
 
-    if (driverdata->done)
+    /*
+     * When using xdg-output, two wl-output.done events will be emitted:
+     * one at the completion of wl-display and one at the completion of xdg-output.
+     *
+     * All required events must be received before proceeding.
+     */
+    const int event_await_count = 1 + (driverdata->xdg_output != NULL);
+
+    driverdata->wl_output_done_count = SDL_min(driverdata->wl_output_done_count + 1, event_await_count + 1);
+
+    if (driverdata->wl_output_done_count != event_await_count) {
         return;
+    }
 
-    driverdata->done = SDL_TRUE;
+    /* The native display resolution */
+    SDL_zero(native_mode);
+    native_mode.format = SDL_PIXELFORMAT_RGB888;
 
-    SDL_zero(mode);
-    mode.format = SDL_PIXELFORMAT_RGB888;
     if (driverdata->transform & WL_OUTPUT_TRANSFORM_90) {
-        mode.w = driverdata->height / driverdata->scale_factor;
-        mode.h = driverdata->width / driverdata->scale_factor;
+        native_mode.w = driverdata->native_height;
+        native_mode.h = driverdata->native_width;
+    } else {
+        native_mode.w = driverdata->native_width;
+        native_mode.h = driverdata->native_height;
+    }
+    native_mode.refresh_rate = (int)SDL_round(driverdata->refresh / 1000.0); /* mHz to Hz */
+    native_mode.driverdata   = driverdata->output;
 
+    /* The scaled desktop mode */
+    SDL_zero(desktop_mode);
+    desktop_mode.format = SDL_PIXELFORMAT_RGB888;
+
+    /* Scale the desktop coordinates, if xdg-output isn't present */
+    if (!driverdata->has_logical_size) {
+        driverdata->width /= driverdata->scale_factor;
+        driverdata->height /= driverdata->scale_factor;
+    }
+
+    /* xdg-output dimensions are already transformed, so no need to rotate. */
+    if (driverdata->has_logical_size || !(driverdata->transform & WL_OUTPUT_TRANSFORM_90)) {
+        desktop_mode.w = driverdata->width;
+        desktop_mode.h = driverdata->height;
+    } else {
+        desktop_mode.w = driverdata->height;
+        desktop_mode.h = driverdata->width;
+    }
+    desktop_mode.refresh_rate = (int)SDL_round(driverdata->refresh / 1000.0); /* mHz to Hz */
+    desktop_mode.driverdata = driverdata->output;
+
+    /*
+     * The native display mode is only exposed separately from the desktop size if:
+     * the desktop is scaled and the wp_viewporter protocol is supported.
+     */
+    if (driverdata->scale_factor > 1.0f && video->viewporter != NULL) {
+        if (driverdata->index > -1) {
+            SDL_AddDisplayMode(SDL_GetDisplay(driverdata->index), &native_mode);
+        } else {
+            SDL_AddDisplayMode(&driverdata->placeholder, &native_mode);
+        }
+    }
+
+    /* Calculate the display DPI */
+    if (driverdata->transform & WL_OUTPUT_TRANSFORM_90) {
         driverdata->hdpi = driverdata->physical_height ?
             (((float) driverdata->height) * 25.4f / driverdata->physical_height) :
             0.0f;
@@ -432,9 +620,6 @@ display_handle_done(void *data,
                                                   ((float) driverdata->physical_height) / 25.4f,
                                                   ((float) driverdata->physical_width) / 25.4f);
     } else {
-        mode.w = driverdata->width / driverdata->scale_factor;
-        mode.h = driverdata->height / driverdata->scale_factor;
-
         driverdata->hdpi = driverdata->physical_width ?
             (((float) driverdata->width) * 25.4f / driverdata->physical_width) :
             0.0f;
@@ -446,8 +631,6 @@ display_handle_done(void *data,
                                                   ((float) driverdata->physical_width) / 25.4f,
                                                   ((float) driverdata->physical_height) / 25.4f);
     }
-    mode.refresh_rate = (int)SDL_round(driverdata->refresh / 1000.0); /* mHz to Hz */
-    mode.driverdata = driverdata->output;
 
     if (driverdata->index > -1) {
         dpy = SDL_GetDisplay(driverdata->index);
@@ -455,9 +638,14 @@ display_handle_done(void *data,
         dpy = &driverdata->placeholder;
     }
 
-    SDL_AddDisplayMode(dpy, &mode);
-    SDL_SetCurrentDisplayMode(dpy, &mode);
-    SDL_SetDesktopDisplayMode(dpy, &mode);
+    SDL_AddDisplayMode(dpy, &desktop_mode);
+    SDL_SetCurrentDisplayMode(dpy, &desktop_mode);
+    SDL_SetDesktopDisplayMode(dpy, &desktop_mode);
+
+    /* Add emulated modes if wp_viewporter is supported. */
+    if (video->viewporter) {
+        AddEmulatedModes(dpy, (driverdata->transform & WL_OUTPUT_TRANSFORM_90) != 0);
+    }
 
     if (driverdata->index == -1) {
         /* First time getting display info, create the VideoDisplay */
@@ -504,11 +692,29 @@ Wayland_add_display(SDL_VideoData *d, uint32_t id)
     data->videodata = d;
     data->output = output;
     data->registry_id = id;
-    data->scale_factor = 1.0;
+    data->scale_factor = 1.0f;
     data->index = -1;
 
     wl_output_add_listener(output, &output_listener, data);
     SDL_WAYLAND_register_output(output);
+
+    /* Keep a list of outputs for deferred xdg-output initialization. */
+    if (d->output_list != NULL) {
+        SDL_WaylandOutputData *node = (SDL_WaylandOutputData*)d->output_list;
+
+        while (node->next != NULL) {
+            node = (SDL_WaylandOutputData*)node->next;
+        }
+
+        node->next = (struct SDL_WaylandOutputData*)data;
+    } else {
+        d->output_list = (struct SDL_WaylandOutputData*)data;
+    }
+
+    if (data->videodata->xdg_output_manager) {
+        data->xdg_output = zxdg_output_manager_v1_get_xdg_output(data->videodata->xdg_output_manager, output);
+        zxdg_output_v1_add_listener(data->xdg_output, &xdg_output_listener, data);
+    }
 }
 
 static void
@@ -524,6 +730,9 @@ Wayland_free_display(uint32_t id)
         data = (SDL_WaylandOutputData *) display->driverdata;
         if (data->registry_id == id) {
             SDL_DelVideoDisplay(i);
+            if (data->xdg_output) {
+                zxdg_output_v1_destroy(data->xdg_output);
+            }
             wl_output_destroy(data->output);
             SDL_free(data);
 
@@ -540,6 +749,16 @@ Wayland_free_display(uint32_t id)
     }
 }
 
+static void
+Wayland_init_xdg_output(SDL_VideoData *d)
+{
+    SDL_WaylandOutputData *node;
+    for (node = d->output_list; node != NULL; node = node->next) {
+        node->xdg_output = zxdg_output_manager_v1_get_xdg_output(node->videodata->xdg_output_manager, node->output);
+        zxdg_output_v1_add_listener(node->xdg_output, &xdg_output_listener, node);
+    }
+}
+
 #ifdef SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH
 static void
 windowmanager_hints(void *data, struct qt_windowmanager *qt_windowmanager,
@@ -600,7 +819,7 @@ display_handle_global(void *data, struct wl_registry *registry, uint32_t id,
     } else if (SDL_strcmp(interface, "wl_seat") == 0) {
         Wayland_display_add_input(d, id, version);
     } else if (SDL_strcmp(interface, "xdg_wm_base") == 0) {
-        d->shell.xdg = wl_registry_bind(d->registry, id, &xdg_wm_base_interface, 1);
+        d->shell.xdg = wl_registry_bind(d->registry, id, &xdg_wm_base_interface, SDL_min(version, 3));
         xdg_wm_base_add_listener(d->shell.xdg, &shell_listener_xdg, NULL);
     } else if (SDL_strcmp(interface, "wl_shm") == 0) {
         d->shm = wl_registry_bind(registry, id, &wl_shm_interface, 1);
@@ -620,6 +839,17 @@ display_handle_global(void *data, struct wl_registry *registry, uint32_t id,
         Wayland_add_data_device_manager(d, id, version);
     } else if (SDL_strcmp(interface, "zxdg_decoration_manager_v1") == 0) {
         d->decoration_manager = wl_registry_bind(d->registry, id, &zxdg_decoration_manager_v1_interface, 1);
+    } else if (SDL_strcmp(interface, "zwp_tablet_manager_v2") == 0) {
+        d->tablet_manager = wl_registry_bind(d->registry, id, &zwp_tablet_manager_v2_interface, 1);
+        if (d->input) {
+            Wayland_input_add_tablet(d->input, d->tablet_manager);
+        }
+    } else if (SDL_strcmp(interface, "zxdg_output_manager_v1") == 0) {
+        version = SDL_min(version, 3); /* Versions 1 through 3 are supported. */
+        d->xdg_output_manager = wl_registry_bind(d->registry, id, &zxdg_output_manager_v1_interface, version);
+        Wayland_init_xdg_output(d);
+    } else if (SDL_strcmp(interface, "wp_viewporter") == 0) {
+        d->viewporter = wl_registry_bind(d->registry, id, &wp_viewporter_interface, 1);
 
 #ifdef SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH
     } else if (SDL_strcmp(interface, "qt_touch_extension") == 0) {
@@ -646,6 +876,29 @@ static const struct wl_registry_listener registry_listener = {
     display_handle_global,
     display_remove_global
 };
+ 
+#ifdef HAVE_LIBDECOR_H
+static SDL_bool should_use_libdecor(SDL_VideoData *data)
+{
+    if (!SDL_WAYLAND_HAVE_WAYLAND_LIBDECOR) {
+        return SDL_FALSE;
+    }
+
+    if (!SDL_GetHintBoolean(SDL_HINT_VIDEO_WAYLAND_ALLOW_LIBDECOR, SDL_TRUE)) {
+        return SDL_FALSE;
+    }
+
+    if (SDL_GetHintBoolean(SDL_HINT_VIDEO_WAYLAND_PREFER_LIBDECOR, SDL_FALSE)) {
+        return SDL_TRUE;
+    }
+
+    if (data->decoration_manager) {
+        return SDL_FALSE;
+    }
+
+    return SDL_TRUE;
+}
+#endif
 
 int
 Wayland_VideoInit(_THIS)
@@ -669,14 +922,8 @@ Wayland_VideoInit(_THIS)
 
 #ifdef HAVE_LIBDECOR_H
     /* Don't have server-side decorations? Try client-side instead. */
-    if (!data->decoration_manager && SDL_WAYLAND_HAVE_WAYLAND_LIBDECOR && SDL_GetHintBoolean(SDL_HINT_VIDEO_WAYLAND_ALLOW_LIBDECOR, SDL_TRUE)) {
+    if (should_use_libdecor(data)) {
         data->shell.libdecor = libdecor_new(data->display, &libdecor_interface);
-
-        /* If libdecor works, we don't need xdg-shell anymore. */
-        if (data->shell.libdecor && data->shell.xdg) {
-            xdg_wm_base_destroy(data->shell.xdg);
-            data->shell.xdg = NULL;
-        }
     }
 #endif
 
@@ -737,6 +984,10 @@ Wayland_VideoQuit(_THIS)
     for (i = 0; i < _this->num_displays; ++i) {
         SDL_VideoDisplay *display = &_this->displays[i];
 
+        if (((SDL_WaylandOutputData*)display->driverdata)->xdg_output) {
+            zxdg_output_v1_destroy(((SDL_WaylandOutputData*)display->driverdata)->xdg_output);
+        }
+
         wl_output_destroy(((SDL_WaylandOutputData*)display->driverdata)->output);
         SDL_free(display->driverdata);
         display->driverdata = NULL;
@@ -779,6 +1030,9 @@ Wayland_VideoQuit(_THIS)
     Wayland_touch_destroy(data);
 #endif /* SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH */
 
+    if (data->tablet_manager)
+        zwp_tablet_manager_v2_destroy((struct zwp_tablet_manager_v2*)data->tablet_manager);
+
     if (data->data_device_manager)
         wl_data_device_manager_destroy(data->data_device_manager);
 
@@ -798,6 +1052,14 @@ Wayland_VideoQuit(_THIS)
     }
 #endif
 
+    if (data->xdg_output_manager) {
+        zxdg_output_manager_v1_destroy(data->xdg_output_manager);
+    }
+
+    if (data->viewporter) {
+        wp_viewporter_destroy(data->viewporter);
+    }
+
     if (data->compositor)
         wl_compositor_destroy(data->compositor);
 
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandvideo.h b/Engine/lib/sdl/src/video/wayland/SDL_waylandvideo.h
index 31168a9d5..6f941db80 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandvideo.h
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandvideo.h
@@ -34,6 +34,7 @@
 
 struct xkb_context;
 struct SDL_WaylandInput;
+struct SDL_WaylandTabletManager;
 
 #ifdef SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH
 struct SDL_WaylandTouch;
@@ -46,6 +47,8 @@ typedef struct {
     int size;
 } SDL_WaylandCursorTheme;
 
+typedef struct SDL_WaylandOutputData SDL_WaylandOutputData;
+
 typedef struct {
     SDL_bool initializing;
     struct wl_display *display;
@@ -70,6 +73,8 @@ typedef struct {
     struct zwp_idle_inhibit_manager_v1 *idle_inhibit_manager;
     struct xdg_activation_v1 *activation_manager;
     struct zwp_text_input_manager_v3 *text_input_manager;
+    struct zxdg_output_manager_v1 *xdg_output_manager;
+    struct wp_viewporter *viewporter;
 
     EGLDisplay edpy;
     EGLContext context;
@@ -77,6 +82,8 @@ typedef struct {
 
     struct xkb_context *xkb_context;
     struct SDL_WaylandInput *input;
+    struct SDL_WaylandTabletManager *tablet_manager;
+    SDL_WaylandOutputData *output_list;
 
 #ifdef SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH
     struct SDL_WaylandTouch *touch;
@@ -89,19 +96,23 @@ typedef struct {
     int relative_mouse_mode;
 } SDL_VideoData;
 
-typedef struct {
+struct SDL_WaylandOutputData {
     SDL_VideoData *videodata;
     struct wl_output *output;
+    struct zxdg_output_v1 *xdg_output;
     uint32_t registry_id;
     float scale_factor;
+    int native_width, native_height;
     int x, y, width, height, refresh, transform;
     SDL_DisplayOrientation orientation;
     int physical_width, physical_height;
     float ddpi, hdpi, vdpi;
+    SDL_bool has_logical_position, has_logical_size;
     int index;
     SDL_VideoDisplay placeholder;
-    SDL_bool done;
-} SDL_WaylandOutputData;
+    int wl_output_done_count;
+    SDL_WaylandOutputData *next;
+};
 
 /* Needed here to get wl_surface declaration, fixes GitHub#4594 */
 #include "SDL_waylanddyn.h"
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandvulkan.c b/Engine/lib/sdl/src/video/wayland/SDL_waylandvulkan.c
index eb4435131..90b318fc8 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandvulkan.c
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandvulkan.c
@@ -139,11 +139,11 @@ void Wayland_Vulkan_GetDrawableSize(_THIS, SDL_Window *window, int *w, int *h)
         data = (SDL_WindowData *) window->driverdata;
 
         if (w) {
-            *w = window->w * data->scale_factor;
+            *w = data->drawable_width;
         }
 
         if (h) {
-            *h = window->h * data->scale_factor;
+            *h = data->drawable_height;
         }
     }
 }
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandwindow.c b/Engine/lib/sdl/src/video/wayland/SDL_waylandwindow.c
index 635546af4..0bbae4691 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandwindow.c
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandwindow.c
@@ -25,22 +25,294 @@
 
 #include "../SDL_sysvideo.h"
 #include "../../events/SDL_windowevents_c.h"
+#include "../../events/SDL_mouse_c.h"
 #include "../SDL_egl_c.h"
 #include "SDL_waylandevents_c.h"
 #include "SDL_waylandwindow.h"
 #include "SDL_waylandvideo.h"
 #include "SDL_waylandtouch.h"
 #include "SDL_hints.h"
+#include "SDL_events.h"
 
 #include "xdg-shell-client-protocol.h"
 #include "xdg-decoration-unstable-v1-client-protocol.h"
 #include "idle-inhibit-unstable-v1-client-protocol.h"
 #include "xdg-activation-v1-client-protocol.h"
+#include "viewporter-client-protocol.h"
 
 #ifdef HAVE_LIBDECOR_H
 #include <libdecor.h>
 #endif
 
+static void
+GetFullScreenDimensions(SDL_Window *window, int *width, int *height, int *drawable_width, int *drawable_height)
+{
+    SDL_WaylandOutputData *output = (SDL_WaylandOutputData *)SDL_GetDisplayForWindow(window)->driverdata;
+
+    int fs_width, fs_height;
+    int buf_width, buf_height;
+
+    /*
+     * Fullscreen desktop mandates a desktop sized window, so that's what applications will get.
+     * If the application is DPI aware, it will need to handle the transformations between the
+     * differently sized window and backbuffer spaces on its own.
+     */
+    if ((window->flags & SDL_WINDOW_FULLSCREEN_DESKTOP) == SDL_WINDOW_FULLSCREEN_DESKTOP) {
+        fs_width  = output->width;
+        fs_height = output->height;
+
+        /* If the application is DPI aware, we can expose the true backbuffer size */
+        if (window->flags & SDL_WINDOW_ALLOW_HIGHDPI) {
+            buf_width  = output->native_width;
+            buf_height = output->native_height;
+        } else {
+            buf_width  = fs_width;
+            buf_height = fs_height;
+        }
+    } else {
+        /*
+         * If a mode was set, use it, otherwise use the native resolution
+         * for DPI aware apps and the desktop size for legacy apps.
+         */
+        if (window->fullscreen_mode.w != 0 && window->fullscreen_mode.h != 0) {
+            fs_width  = window->fullscreen_mode.w;
+            fs_height = window->fullscreen_mode.h;
+        } else if (window->flags & SDL_WINDOW_ALLOW_HIGHDPI) {
+            fs_width  = output->native_width;
+            fs_height = output->native_height;
+        } else {
+            fs_width  = output->width;
+            fs_height = output->height;
+        }
+
+        buf_width  = fs_width;
+        buf_height = fs_height;
+    }
+
+    if (width) {
+        *width = fs_width;
+    }
+    if (height) {
+        *height = fs_height;
+    }
+    if (drawable_width) {
+        *drawable_width = buf_width;
+    }
+    if (drawable_height) {
+        *drawable_height = buf_height;
+    }
+}
+
+static inline SDL_bool
+DesktopIsScaled(SDL_Window *window)
+{
+    SDL_WindowData *data = window->driverdata;
+
+    return data->scale_factor != 1.0f;
+}
+
+static inline SDL_bool
+DesktopIsFractionalScaled(SDL_Window *window)
+{
+    SDL_WindowData        *data   = window->driverdata;
+    SDL_WaylandOutputData *output = (SDL_WaylandOutputData *)SDL_GetDisplayForWindow(window)->driverdata;
+
+    if ((output->native_width != (int)(output->width * data->scale_factor) ||
+         output->native_height != (int)(output->height * data->scale_factor))) {
+        return SDL_TRUE;
+    }
+
+    return SDL_FALSE;
+}
+
+static SDL_bool
+NeedFullscreenViewport(SDL_Window *window)
+{
+    SDL_WindowData        *data   = window->driverdata;
+    SDL_VideoData         *video  = data->waylandData;
+    SDL_WaylandOutputData *output = (SDL_WaylandOutputData *)SDL_GetDisplayForWindow(window)->driverdata;
+
+    int fs_width, fs_height;
+
+    GetFullScreenDimensions(window, &fs_width, &fs_height, NULL, NULL);
+
+    /*
+     * Fullscreen needs a viewport:
+     *  - If the desktop uses fractional scaling
+     *    - Fullscreen desktop was not requested OR the window is DPI aware
+     *
+     *  - The desktop uses non-fractional scaling
+     *    - Fullscreen desktop was NOT requested
+     *
+     *  - The desktop is not scaled
+     *    - A non-native fullscreen mode was explicitly set by the client
+     */
+    if (video->viewporter != NULL && (window->flags & SDL_WINDOW_FULLSCREEN)) {
+        if (DesktopIsFractionalScaled(window)) {
+            if ((window->flags & SDL_WINDOW_FULLSCREEN_DESKTOP) != SDL_WINDOW_FULLSCREEN_DESKTOP ||
+                (window->flags & SDL_WINDOW_ALLOW_HIGHDPI)) {
+                return SDL_TRUE;
+            }
+        } else if (DesktopIsScaled(window)) {
+            if ((window->flags & SDL_WINDOW_FULLSCREEN_DESKTOP) != SDL_WINDOW_FULLSCREEN_DESKTOP) {
+                return SDL_TRUE;
+            }
+        } else if (fs_width != output->native_width && fs_height != output->native_height) {
+            return SDL_TRUE;
+        }
+    }
+
+    return SDL_FALSE;
+}
+
+static inline SDL_bool
+NeedWindowedViewport(SDL_Window *window)
+{
+    SDL_WindowData *data  = window->driverdata;
+    SDL_VideoData  *video = data->waylandData;
+
+    return !(window->flags & SDL_WINDOW_FULLSCREEN) && (video->viewporter != NULL) &&
+           DesktopIsFractionalScaled(window) && (window->flags & SDL_WINDOW_ALLOW_HIGHDPI);
+}
+
+/* Never set a fullscreen window size larger than the desktop. */
+SDL_FORCE_INLINE int
+GetWindowWidth(SDL_Window *window)
+{
+    return NeedFullscreenViewport(window) ? ((SDL_WaylandOutputData *)SDL_GetDisplayForWindow(window)->driverdata)->width : window->w;
+}
+
+SDL_FORCE_INLINE int
+GetWindowHeight(SDL_Window *window)
+{
+    return NeedFullscreenViewport(window) ? ((SDL_WaylandOutputData *)SDL_GetDisplayForWindow(window)->driverdata)->height : window->h;
+}
+
+static void
+GetWindowBufferSize(SDL_Window *window, int *width, int *height)
+{
+    SDL_WindowData        *data   = window->driverdata;
+    SDL_WaylandOutputData *output = (SDL_WaylandOutputData *)SDL_GetDisplayForWindow(window)->driverdata;
+    int                    buf_width;
+    int                    buf_height;
+
+    if (NeedWindowedViewport(window)) {
+        const float frac_scale_x = (float)output->native_width / (float)output->width;
+        const float frac_scale_y = (float)output->native_height / (float)output->height;
+
+        buf_width  = (int)SDL_lroundf(window->w * frac_scale_x);
+        buf_height = (int)SDL_lroundf(window->h * frac_scale_y);
+    } else { /* Windowed or fullscreen with no viewport */
+        buf_width  = window->w * data->scale_factor;
+        buf_height = window->h * data->scale_factor;
+    }
+
+    if (width) {
+        *width = buf_width;
+    }
+    if (height) {
+        *height = buf_height;
+    }
+}
+
+static void
+SetViewport(SDL_Window *window, int src_width, int src_height, int dst_width, int dst_height)
+{
+    SDL_WindowData *wind  = window->driverdata;
+    SDL_VideoData  *video = wind->waylandData;
+
+    if (video->viewporter) {
+        if (wind->viewport == NULL) {
+            wind->viewport = wp_viewporter_get_viewport(video->viewporter, wind->surface);
+        }
+
+        wp_viewport_set_source(wind->viewport, wl_fixed_from_int(0), wl_fixed_from_int(0), wl_fixed_from_int(src_width), wl_fixed_from_int(src_height));
+        wp_viewport_set_destination(wind->viewport, dst_width, dst_height);
+    }
+}
+
+static void
+UnsetViewport(SDL_Window *window)
+{
+    SDL_WindowData *wind = window->driverdata;
+
+    if (wind->viewport) {
+        wp_viewport_destroy(wind->viewport);
+        wind->viewport = NULL;
+    }
+}
+
+static void
+ConfigureViewport(SDL_Window *window)
+{
+    SDL_WindowData        *data    = window->driverdata;
+    SDL_VideoData         *viddata = data->waylandData;
+    SDL_WaylandOutputData *output  = (SDL_WaylandOutputData *)SDL_GetDisplayForWindow(window)->driverdata;
+
+    if (NeedFullscreenViewport(window)) {
+        int fs_width, fs_height;
+        int src_width, src_height;
+
+        GetFullScreenDimensions(window, &fs_width, &fs_height, &src_width, &src_height);
+        SetViewport(window, src_width, src_height, output->width, output->height);
+
+        data->damage_region.x = 0;
+        data->damage_region.y = 0;
+        data->damage_region.w = output->width;
+        data->damage_region.h = output->height;
+
+        data->pointer_scale_x = (float)fs_width / (float)output->width;
+        data->pointer_scale_y = (float)fs_height / (float)output->height;
+    } else {
+        if (NeedWindowedViewport(window)) {
+            int src_width, src_height;
+
+            GetWindowBufferSize(window, &src_width, &src_height);
+            SetViewport(window, src_width, src_height, window->w, window->h);
+        } else {
+            UnsetViewport(window);
+        }
+
+        SDL_zero(data->damage_region);
+
+        data->pointer_scale_x = 1.0f;
+        data->pointer_scale_y = 1.0f;
+    }
+
+    /*
+     * If mouse_rect is not empty, re-create the confinement region with the new scale value.
+     * If the pointer is locked to the general surface with unspecified coordinates, it will
+     * be confined to the viewport region, so no update is required.
+     */
+    if (!SDL_RectEmpty(&window->mouse_rect)) {
+        Wayland_input_confine_pointer(viddata->input, window);
+    }
+}
+
+static void
+SetDrawScale(SDL_Window *window)
+{
+    SDL_WindowData *data = window->driverdata;
+
+    if (NeedFullscreenViewport(window)) {
+        int fs_width, fs_height;
+
+        GetFullScreenDimensions(window, &fs_width, &fs_height, &data->drawable_width, &data->drawable_height);
+
+        /* Set the buffer scale to 1 since a viewport will be used. */
+        wl_surface_set_buffer_scale(data->surface, 1);
+    } else {
+        GetWindowBufferSize(window, &data->drawable_width, &data->drawable_height);
+
+        if (NeedWindowedViewport(window)) {
+            /* Set the buffer scale to 1 since a viewport will be used. */
+            wl_surface_set_buffer_scale(data->surface, 1);
+        } else {
+            wl_surface_set_buffer_scale(data->surface, (int32_t)data->scale_factor);
+        }
+    }
+}
+
 static void
 SetMinMaxDimensions(SDL_Window *window, SDL_bool commit)
 {
@@ -48,6 +320,15 @@ SetMinMaxDimensions(SDL_Window *window, SDL_bool commit)
     SDL_VideoData *viddata = wind->waylandData;
     int min_width, min_height, max_width, max_height;
 
+    /* Pop-ups don't get to change size */
+    if (WINDOW_IS_XDG_POPUP(window)) {
+        /* ... but we still want to commit, particularly for ShowWindow */
+        if (commit) {
+            wl_surface_commit(wind->surface);
+        }
+        return;
+    }
+
     if (window->flags & SDL_WINDOW_FULLSCREEN) {
         min_width = 0;
         min_height = 0;
@@ -66,7 +347,7 @@ SetMinMaxDimensions(SDL_Window *window, SDL_bool commit)
     }
 
 #ifdef HAVE_LIBDECOR_H
-    if (viddata->shell.libdecor) {
+    if (WINDOW_IS_LIBDECOR(viddata, window)) {
         if (wind->shell_surface.libdecor.frame == NULL) {
             return; /* Can't do anything yet, wait for ShowWindow */
         }
@@ -100,13 +381,22 @@ SetFullscreen(SDL_Window *window, struct wl_output *output, SDL_bool commit)
     SDL_WindowData *wind = window->driverdata;
     SDL_VideoData *viddata = wind->waylandData;
 
+    /* Pop-ups don't get to be fullscreened */
+    if (WINDOW_IS_XDG_POPUP(window)) {
+        /* ... but we still want to commit, particularly for ShowWindow */
+        if (commit) {
+            wl_surface_commit(wind->surface);
+        }
+        return;
+    }
+
     /* The desktop may try to enforce min/max sizes here, so turn them off for
      * fullscreen and on (if applicable) for windowed
      */
     SetMinMaxDimensions(window, SDL_FALSE);
 
 #ifdef HAVE_LIBDECOR_H
-    if (viddata->shell.libdecor) {
+    if (WINDOW_IS_LIBDECOR(viddata, window)) {
         if (wind->shell_surface.libdecor.frame == NULL) {
             return; /* Can't do anything yet, wait for ShowWindow */
         }
@@ -150,6 +440,11 @@ handle_surface_frame_done(void *data, struct wl_callback *cb, uint32_t time)
     SDL_WindowData *wind = (SDL_WindowData *) data;
     SDL_AtomicSet(&wind->swap_interval_ready, 1);  /* mark window as ready to present again. */
 
+    if (!SDL_RectEmpty(&wind->damage_region)) {
+        wl_surface_damage(wind->surface, wind->damage_region.x, wind->damage_region.y,
+                          wind->damage_region.w, wind->damage_region.h);
+    }
+
     /* reset this callback to fire again once a new frame was presented and compositor wants the next one. */
     wind->frame_callback = wl_surface_frame(wind->frame_surface_wrapper);
     wl_callback_destroy(cb);
@@ -303,9 +598,14 @@ handle_configure_xdg_toplevel(void *data,
          * UPDATE: Nope, sure enough a compositor sends 0,0. This is a known bug:
          * https://bugs.kde.org/show_bug.cgi?id=444962
          */
-        if (width != 0 && height != 0 && (window->w != width || window->h != height)) {
-            window->w = width;
-            window->h = height;
+        if (!NeedFullscreenViewport(window)) {
+            if (width != 0 && height != 0 && (window->w != width || window->h != height)) {
+                window->w = width;
+                window->h = height;
+                wind->needs_resize_event = SDL_TRUE;
+            }
+        } else {
+            GetFullScreenDimensions(window, &window->w, &window->h, NULL, NULL);
             wind->needs_resize_event = SDL_TRUE;
         }
 
@@ -329,6 +629,60 @@ static const struct xdg_toplevel_listener toplevel_listener_xdg = {
     handle_close_xdg_toplevel
 };
 
+static void
+handle_configure_xdg_popup(void *data,
+                           struct xdg_popup *xdg_popup,
+                           int32_t x,
+                           int32_t y,
+                           int32_t width,
+                           int32_t height)
+{
+    /* No-op, we don't use x/y and width/height are fixed-size */
+}
+
+static void
+handle_done_xdg_popup(void *data, struct xdg_popup *xdg_popup)
+{
+    SDL_WindowData *window = (SDL_WindowData *)data;
+    SDL_SendWindowEvent(window->sdlwindow, SDL_WINDOWEVENT_CLOSE, 0, 0);
+}
+
+static void
+handle_repositioned_xdg_popup(void *data,
+                              struct xdg_popup *xdg_popup,
+                              uint32_t token)
+{
+    /* No-op, configure does all the work we care about */
+}
+
+static const struct xdg_popup_listener popup_listener_xdg = {
+    handle_configure_xdg_popup,
+    handle_done_xdg_popup,
+    handle_repositioned_xdg_popup
+};
+
+#define TOOLTIP_CURSOR_OFFSET 8 /* FIXME: Arbitrary, eyeballed from X tooltip */
+
+static int
+Wayland_PopupWatch(void *data, SDL_Event *event)
+{
+    if (event->type == SDL_MOUSEMOTION) {
+        SDL_Window *window = (SDL_Window *) data;
+        SDL_WindowData *wind = window->driverdata;
+
+        /* Coordinates might be relative to the popup, which we don't want */
+        if (event->motion.windowID == wind->shell_surface.xdg.roleobj.popup.parentID) {
+            xdg_positioner_set_offset(wind->shell_surface.xdg.roleobj.popup.positioner,
+                                      event->motion.x + TOOLTIP_CURSOR_OFFSET,
+                                      event->motion.y + TOOLTIP_CURSOR_OFFSET);
+            xdg_popup_reposition(wind->shell_surface.xdg.roleobj.popup.popup,
+                                 wind->shell_surface.xdg.roleobj.popup.positioner,
+                                 0);
+        }
+    }
+    return 1;
+}
+
 #ifdef HAVE_LIBDECOR_H
 static void
 decoration_frame_configure(struct libdecor_frame *frame,
@@ -399,17 +753,23 @@ decoration_frame_configure(struct libdecor_frame *frame,
      * Always assume the configure is wrong.
      */
     if (fullscreen) {
-        /* FIXME: We have been explicitly told to respect the fullscreen size
-         * parameters here, even though they are known to be wrong on GNOME at
-         * bare minimum. If this is wrong, don't blame us, we were explicitly
-         * told to do this.
-         */
-        if (!libdecor_configuration_get_content_size(configuration, frame,
-                                                     &width, &height)) {
-            width = window->w;
-            height = window->h;
+        if (!NeedFullscreenViewport(window)) {
+            /* FIXME: We have been explicitly told to respect the fullscreen size
+             * parameters here, even though they are known to be wrong on GNOME at
+             * bare minimum. If this is wrong, don't blame us, we were explicitly
+             * told to do this.
+             */
+            if (!libdecor_configuration_get_content_size(configuration, frame,
+                                                         &width, &height)) {
+                width  = window->w;
+                height = window->h;
+            }
+        } else {
+            GetFullScreenDimensions(window, &width, &height, NULL, NULL);
         }
 
+        wind->needs_resize_event = SDL_TRUE;
+
         /* This part is good though. */
         if (window->flags & SDL_WINDOW_ALLOW_HIGHDPI) {
             scale_factor = driverdata->scale_factor;
@@ -445,7 +805,7 @@ decoration_frame_configure(struct libdecor_frame *frame,
     wind->shell_surface.libdecor.initial_configure_seen = SDL_TRUE;
 
     /* ... then commit the changes on the libdecor side. */
-    state = libdecor_state_new(width, height);
+    state = libdecor_state_new(GetWindowWidth(window), GetWindowHeight(window));
     libdecor_frame_commit(frame, state, configuration);
     libdecor_state_free(state);
 
@@ -554,9 +914,28 @@ Wayland_move_window(SDL_Window *window,
     int i, numdisplays = SDL_GetNumVideoDisplays();
     for (i = 0; i < numdisplays; i += 1) {
         if (SDL_GetDisplay(i)->driverdata == driverdata) {
-            SDL_SendWindowEvent(window, SDL_WINDOWEVENT_MOVED,
-                                SDL_WINDOWPOS_CENTERED_DISPLAY(i),
-                                SDL_WINDOWPOS_CENTERED_DISPLAY(i));
+            /* We want to send a very very specific combination here:
+             *
+             * 1. A coordinate that tells the application what display we're on
+             * 2. Exactly (0, 0)
+             *
+             * Part 1 is useful information but is also really important for
+             * ensuring we end up on the right display for fullscreen, while
+             * part 2 is important because numerous applications use a specific
+             * combination of GetWindowPosition and GetGlobalMouseState, and of
+             * course neither are supported by Wayland. Since global mouse will
+             * fall back to just GetMouseState, we need the window position to
+             * be zero so the cursor math works without it going off in some
+             * random direction. See UE5 Editor for a notable example of this!
+             *
+             * This may be an issue some day if we're ever able to implement
+             * SDL_GetDisplayUsableBounds!
+             *
+             * -flibit
+             */
+            SDL_Rect bounds;
+            SDL_GetDisplayBounds(i, &bounds);
+            SDL_SendWindowEvent(window, SDL_WINDOWEVENT_MOVED, bounds.x, bounds.y);
             break;
         }
     }
@@ -624,6 +1003,19 @@ static const struct wl_surface_listener surface_listener = {
     handle_surface_leave
 };
 
+static void
+Wayland_FillEmptyShellInfo(SDL_SysWMinfo * info, const Uint32 version)
+{
+    info->info.wl.xdg_surface = NULL;
+    if (version >= SDL_VERSIONNUM(2, 0, 17)) {
+        info->info.wl.xdg_toplevel = NULL;
+        if (version >= SDL_VERSIONNUM(2, 0, 22)) {
+            info->info.wl.xdg_popup = NULL;
+            info->info.wl.xdg_positioner = NULL;
+        }
+    }
+}
+
 SDL_bool
 Wayland_GetWindowWMInfo(_THIS, SDL_Window * window, SDL_SysWMinfo * info)
 {
@@ -656,23 +1048,40 @@ Wayland_GetWindowWMInfo(_THIS, SDL_Window * window, SDL_SysWMinfo * info)
         info->info.wl.egl_window = data->egl_window;
 
 #ifdef HAVE_LIBDECOR_H
-        if (viddata->shell.libdecor && data->shell_surface.libdecor.frame != NULL) {
-            info->info.wl.xdg_surface = libdecor_frame_get_xdg_surface(data->shell_surface.libdecor.frame);
-            if (version >= SDL_VERSIONNUM(2, 0, 17)) {
-                info->info.wl.xdg_toplevel = libdecor_frame_get_xdg_toplevel(data->shell_surface.libdecor.frame);
+        if (WINDOW_IS_LIBDECOR(viddata, window)) {
+            if (data->shell_surface.libdecor.frame != NULL) {
+                info->info.wl.xdg_surface = libdecor_frame_get_xdg_surface(data->shell_surface.libdecor.frame);
+                if (version >= SDL_VERSIONNUM(2, 0, 17)) {
+                    info->info.wl.xdg_toplevel = libdecor_frame_get_xdg_toplevel(data->shell_surface.libdecor.frame);
+                    if (version >= SDL_VERSIONNUM(2, 0, 22)) {
+                        info->info.wl.xdg_popup = NULL;
+                        info->info.wl.xdg_positioner = NULL;
+                    }
+                }
+            } else {
+                /* Not mapped yet */
+                Wayland_FillEmptyShellInfo(info, version);
             }
         } else
 #endif
         if (viddata->shell.xdg && data->shell_surface.xdg.surface != NULL) {
             info->info.wl.xdg_surface = data->shell_surface.xdg.surface;
             if (version >= SDL_VERSIONNUM(2, 0, 17)) {
-                info->info.wl.xdg_toplevel = data->shell_surface.xdg.roleobj.toplevel;
+                SDL_bool popup = WINDOW_IS_XDG_POPUP(window);
+                info->info.wl.xdg_toplevel = popup ? NULL : data->shell_surface.xdg.roleobj.toplevel;
+                if (version >= SDL_VERSIONNUM(2, 0, 22)) {
+                    if (popup) {
+                        info->info.wl.xdg_popup = data->shell_surface.xdg.roleobj.popup.popup;
+                        info->info.wl.xdg_positioner = data->shell_surface.xdg.roleobj.popup.positioner;
+                    } else {
+                        info->info.wl.xdg_popup = NULL;
+                        info->info.wl.xdg_positioner = NULL;
+                    }
+                }
             }
         } else {
-            info->info.wl.xdg_surface = NULL;
-            if (version >= SDL_VERSIONNUM(2, 0, 17)) {
-                info->info.wl.xdg_toplevel = NULL;
-            }
+            /* Either it's not mapped yet or we don't have a shell protocol */
+            Wayland_FillEmptyShellInfo(info, version);
         }
     }
 
@@ -697,6 +1106,10 @@ Wayland_SetWindowModalFor(_THIS, SDL_Window *modal_window, SDL_Window *parent_wi
     SDL_WindowData *modal_data = modal_window->driverdata;
     SDL_WindowData *parent_data = parent_window->driverdata;
 
+    if (WINDOW_IS_XDG_POPUP(modal_window) || WINDOW_IS_XDG_POPUP(parent_window)) {
+        return SDL_SetError("Modal/Parent was a popup, not a toplevel");
+    }
+
 #ifdef HAVE_LIBDECOR_H
     if (viddata->shell.libdecor) {
         if (modal_data->shell_surface.libdecor.frame == NULL) {
@@ -731,9 +1144,26 @@ void Wayland_ShowWindow(_THIS, SDL_Window *window)
     SDL_VideoData *c = _this->driverdata;
     SDL_WindowData *data = window->driverdata;
 
-    /* Create the shell surface and map the toplevel */
+    /* Detach any previous buffers before resetting everything, otherwise when
+     * calling this a second time you'll get an annoying protocol error!
+     *
+     * FIXME: This was originally moved to HideWindow, which _should_ make
+     * sense, but for whatever reason UE5's popups require that this actually
+     * be in both places at once? Possibly from renderers making commits? I can't
+     * fully remember if this location caused crashes or if I was fixing a pair
+     * of Hide/Show calls. In any case, UE gives us a pretty good test and having
+     * both detach calls passes. This bug may be relevant if I'm wrong:
+     *
+     * https://bugs.kde.org/show_bug.cgi?id=448856
+     *
+     * -flibit
+     */
+    wl_surface_attach(data->surface, NULL, 0, 0);
+    wl_surface_commit(data->surface);
+
+    /* Create the shell surface and map the toplevel/popup */
 #ifdef HAVE_LIBDECOR_H
-    if (c->shell.libdecor) {
+    if (WINDOW_IS_LIBDECOR(c, window)) {
         data->shell_surface.libdecor.frame = libdecor_decorate(c->shell.libdecor,
                                                                data->surface,
                                                                &libdecor_frame_interface,
@@ -751,10 +1181,42 @@ void Wayland_ShowWindow(_THIS, SDL_Window *window)
         xdg_surface_set_user_data(data->shell_surface.xdg.surface, data);
         xdg_surface_add_listener(data->shell_surface.xdg.surface, &shell_surface_listener_xdg, data);
 
-        /* !!! FIXME: add popup role */
-        data->shell_surface.xdg.roleobj.toplevel = xdg_surface_get_toplevel(data->shell_surface.xdg.surface);
-        xdg_toplevel_set_app_id(data->shell_surface.xdg.roleobj.toplevel, c->classname);
-        xdg_toplevel_add_listener(data->shell_surface.xdg.roleobj.toplevel, &toplevel_listener_xdg, data);
+        if (WINDOW_IS_XDG_POPUP(window)) {
+            SDL_Mouse *mouse = SDL_GetMouse();
+            SDL_Window *focused = SDL_GetMouseFocus();
+            SDL_WindowData *focuseddata = focused->driverdata;
+
+            /* This popup may be a child of another popup! */
+            data->shell_surface.xdg.roleobj.popup.parentID = SDL_GetWindowID(focused);
+            data->shell_surface.xdg.roleobj.popup.child = NULL;
+            if (WINDOW_IS_XDG_POPUP(focused)) {
+                SDL_assert(focuseddata->shell_surface.xdg.roleobj.popup.child == NULL);
+                focuseddata->shell_surface.xdg.roleobj.popup.child = window;
+            }
+
+            /* Set up the positioner for the popup */
+            data->shell_surface.xdg.roleobj.popup.positioner = xdg_wm_base_create_positioner(c->shell.xdg);
+            xdg_positioner_set_offset(data->shell_surface.xdg.roleobj.popup.positioner,
+                                      mouse->x + TOOLTIP_CURSOR_OFFSET,
+                                      mouse->y + TOOLTIP_CURSOR_OFFSET);
+
+            /* Assign the popup role */
+            data->shell_surface.xdg.roleobj.popup.popup = xdg_surface_get_popup(data->shell_surface.xdg.surface,
+                                                                                focuseddata->shell_surface.xdg.surface,
+                                                                                data->shell_surface.xdg.roleobj.popup.positioner);
+            xdg_popup_add_listener(data->shell_surface.xdg.roleobj.popup.popup, &popup_listener_xdg, data);
+
+            /* For tooltips, track mouse motion so it follows the cursor */
+            if (window->flags & SDL_WINDOW_TOOLTIP) {
+                if (xdg_popup_get_version(data->shell_surface.xdg.roleobj.popup.popup) >= 3) {
+                    SDL_AddEventWatch(Wayland_PopupWatch, window);
+                }
+            }
+        } else {
+            data->shell_surface.xdg.roleobj.toplevel = xdg_surface_get_toplevel(data->shell_surface.xdg.surface);
+            xdg_toplevel_set_app_id(data->shell_surface.xdg.roleobj.toplevel, c->classname);
+            xdg_toplevel_add_listener(data->shell_surface.xdg.roleobj.toplevel, &toplevel_listener_xdg, data);
+        }
     }
 
     /* Restore state that was set prior to this call */
@@ -770,7 +1232,7 @@ void Wayland_ShowWindow(_THIS, SDL_Window *window)
      * this surface will fail. This is a new rule for xdg_shell.
      */
 #ifdef HAVE_LIBDECOR_H
-    if (c->shell.libdecor) {
+    if (WINDOW_IS_LIBDECOR(c, window)) {
         if (data->shell_surface.libdecor.frame) {
             while (!data->shell_surface.libdecor.initial_configure_seen) {
                 WAYLAND_wl_display_flush(c->display);
@@ -794,7 +1256,7 @@ void Wayland_ShowWindow(_THIS, SDL_Window *window)
         }
 
         /* Create the window decorations */
-        if (data->shell_surface.xdg.roleobj.toplevel && c->decoration_manager) {
+        if (!WINDOW_IS_XDG_POPUP(window) && data->shell_surface.xdg.roleobj.toplevel && c->decoration_manager) {
             data->server_decoration = zxdg_decoration_manager_v1_get_toplevel_decoration(c->decoration_manager, data->shell_surface.xdg.roleobj.toplevel);
         }
     } else {
@@ -807,11 +1269,11 @@ void Wayland_ShowWindow(_THIS, SDL_Window *window)
      * them immediately afterward.
      */
 #ifdef HAVE_LIBDECOR_H
-    if (c->shell.libdecor) {
+    if (WINDOW_IS_LIBDECOR(c, window)) {
         /* ... but don't call it redundantly for libdecor, the decorator
          * may not interpret a redundant call nicely and cause weird stuff to happen
          */
-        if (window->flags & SDL_WINDOW_BORDERLESS) {
+        if (data->shell_surface.libdecor.frame && window->flags & SDL_WINDOW_BORDERLESS) {
             Wayland_SetWindowBordered(_this, window, SDL_FALSE);
         }
     } else
@@ -837,6 +1299,42 @@ void Wayland_ShowWindow(_THIS, SDL_Window *window)
     }
 }
 
+static void
+Wayland_ReleasePopup(_THIS, SDL_Window *popup)
+{
+    SDL_WindowData *popupdata;
+
+    /* Basic sanity checks to weed out the weird popup closures */
+    if (popup == NULL || popup->magic != &_this->window_magic) {
+        return;
+    }
+    popupdata = popup->driverdata;
+    if (popupdata == NULL) {
+        return;
+    }
+
+    /* This may already be freed by a parent popup! */
+    if (popupdata->shell_surface.xdg.roleobj.popup.popup == NULL) {
+        return;
+    }
+
+    /* Release the child _first_, otherwise a protocol error triggers */
+    if (popupdata->shell_surface.xdg.roleobj.popup.child != NULL) {
+        Wayland_ReleasePopup(_this, popupdata->shell_surface.xdg.roleobj.popup.child);
+        popupdata->shell_surface.xdg.roleobj.popup.child = NULL;
+    }
+
+    if (popup->flags & SDL_WINDOW_TOOLTIP) {
+        if (xdg_popup_get_version(popupdata->shell_surface.xdg.roleobj.popup.popup) >= 3) {
+            SDL_DelEventWatch(Wayland_PopupWatch, popup);
+        }
+    }
+    xdg_popup_destroy(popupdata->shell_surface.xdg.roleobj.popup.popup);
+    xdg_positioner_destroy(popupdata->shell_surface.xdg.roleobj.popup.positioner);
+    popupdata->shell_surface.xdg.roleobj.popup.popup = NULL;
+    popupdata->shell_surface.xdg.roleobj.popup.positioner = NULL;
+}
+
 void Wayland_HideWindow(_THIS, SDL_Window *window)
 {
     SDL_VideoData *data = _this->driverdata;
@@ -848,7 +1346,7 @@ void Wayland_HideWindow(_THIS, SDL_Window *window)
     }
 
 #ifdef HAVE_LIBDECOR_H
-    if (data->shell.libdecor) {
+    if (WINDOW_IS_LIBDECOR(data, window)) {
         if (wind->shell_surface.libdecor.frame) {
             libdecor_frame_unref(wind->shell_surface.libdecor.frame);
             wind->shell_surface.libdecor.frame = NULL;
@@ -856,7 +1354,9 @@ void Wayland_HideWindow(_THIS, SDL_Window *window)
     } else
 #endif
     if (data->shell.xdg) {
-        if (wind->shell_surface.xdg.roleobj.toplevel) {
+        if (WINDOW_IS_XDG_POPUP(window)) {
+            Wayland_ReleasePopup(_this, window);
+        } else if (wind->shell_surface.xdg.roleobj.toplevel) {
             xdg_toplevel_destroy(wind->shell_surface.xdg.roleobj.toplevel);
             wind->shell_surface.xdg.roleobj.toplevel = NULL;
         }
@@ -1073,13 +1573,17 @@ Wayland_RestoreWindow(_THIS, SDL_Window * window)
     SDL_WindowData *wind = window->driverdata;
     SDL_VideoData *viddata = (SDL_VideoData *) _this->driverdata;
 
+    if (WINDOW_IS_XDG_POPUP(window)) {
+        return;
+    }
+
     /* Set this flag now even if we never actually maximized, eventually
      * ShowWindow will take care of it along with the other window state.
      */
     window->flags &= ~SDL_WINDOW_MAXIMIZED;
 
 #ifdef HAVE_LIBDECOR_H
-    if (viddata->shell.libdecor) {
+    if (WINDOW_IS_LIBDECOR(viddata, window)) {
         if (wind->shell_surface.libdecor.frame == NULL) {
             return; /* Can't do anything yet, wait for ShowWindow */
         }
@@ -1102,8 +1606,13 @@ Wayland_SetWindowBordered(_THIS, SDL_Window * window, SDL_bool bordered)
 {
     SDL_WindowData *wind = window->driverdata;
     const SDL_VideoData *viddata = (const SDL_VideoData *) _this->driverdata;
+
+    if (WINDOW_IS_XDG_POPUP(window)) {
+        return;
+    }
+
 #ifdef HAVE_LIBDECOR_H
-    if (viddata->shell.libdecor) {
+    if (WINDOW_IS_LIBDECOR(viddata, window)) {
         if (wind->shell_surface.libdecor.frame) {
             libdecor_frame_set_visibility(wind->shell_surface.libdecor.frame, bordered);
         }
@@ -1122,7 +1631,7 @@ Wayland_SetWindowResizable(_THIS, SDL_Window * window, SDL_bool resizable)
     SDL_VideoData *data = _this->driverdata;
     const SDL_WindowData *wind = window->driverdata;
 
-    if (data->shell.libdecor) {
+    if (WINDOW_IS_LIBDECOR(data, window)) {
         if (wind->shell_surface.libdecor.frame == NULL) {
             return; /* Can't do anything yet, wait for ShowWindow */
         }
@@ -1144,6 +1653,10 @@ Wayland_MaximizeWindow(_THIS, SDL_Window * window)
     SDL_WindowData *wind = window->driverdata;
     SDL_VideoData *viddata = (SDL_VideoData *) _this->driverdata;
 
+    if (WINDOW_IS_XDG_POPUP(window)) {
+        return;
+    }
+
     if (!(window->flags & SDL_WINDOW_RESIZABLE)) {
         return;
     }
@@ -1154,7 +1667,7 @@ Wayland_MaximizeWindow(_THIS, SDL_Window * window)
     window->flags |= SDL_WINDOW_MAXIMIZED;
 
 #ifdef HAVE_LIBDECOR_H
-    if (viddata->shell.libdecor) {
+    if (WINDOW_IS_LIBDECOR(viddata, window)) {
         if (wind->shell_surface.libdecor.frame == NULL) {
             return; /* Can't do anything yet, wait for ShowWindow */
         }
@@ -1177,8 +1690,12 @@ Wayland_MinimizeWindow(_THIS, SDL_Window * window)
     SDL_WindowData *wind = window->driverdata;
     SDL_VideoData *viddata = (SDL_VideoData *) _this->driverdata;
 
+    if (WINDOW_IS_XDG_POPUP(window)) {
+        return;
+    }
+
 #ifdef HAVE_LIBDECOR_H
-    if (viddata->shell.libdecor) {
+    if (WINDOW_IS_LIBDECOR(viddata, window)) {
         if (wind->shell_surface.libdecor.frame == NULL) {
             return; /* Can't do anything yet, wait for ShowWindow */
         }
@@ -1269,7 +1786,9 @@ int Wayland_CreateWindow(_THIS, SDL_Window *window)
     data->waylandData = c;
     data->sdlwindow = window;
 
-    data->scale_factor = 1.0;
+    data->scale_factor = 1.0f;
+    data->pointer_scale_x = 1.0f;
+    data->pointer_scale_y = 1.0f;
 
     if (window->flags & SDL_WINDOW_ALLOW_HIGHDPI) {
         int i;
@@ -1316,16 +1835,18 @@ int Wayland_CreateWindow(_THIS, SDL_Window *window)
     }
 #endif /* SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH */
 
+    data->drawable_width = window->w * data->scale_factor;
+    data->drawable_height = window->h * data->scale_factor;
+
     if (window->flags & SDL_WINDOW_OPENGL) {
-        data->egl_window = WAYLAND_wl_egl_window_create(data->surface,
-                                            window->w * data->scale_factor, window->h * data->scale_factor);
+        data->egl_window = WAYLAND_wl_egl_window_create(data->surface, data->drawable_width, data->drawable_height);
 
 #if SDL_VIDEO_OPENGL_EGL
         /* Create the GLES window surface */
         data->egl_surface = SDL_EGL_CreateSurface(_this, (NativeWindowType) data->egl_window);
 
         if (data->egl_surface == EGL_NO_SURFACE) {
-            return SDL_SetError("failed to create an EGL window surface");
+            return -1;    /* SDL_EGL_CreateSurface should have set error */
         }
 #endif
     }
@@ -1375,12 +1896,13 @@ Wayland_HandleResize(SDL_Window *window, int width, int height, float scale)
         data->needs_resize_event = SDL_FALSE;
     }
 
-    wl_surface_set_buffer_scale(data->surface, data->scale_factor);
+    /* Configure the backbuffer size and scale factors */
+    SetDrawScale(window);
 
     if (data->egl_window) {
         WAYLAND_wl_egl_window_resize(data->egl_window,
-                                        window->w * data->scale_factor,
-                                        window->h * data->scale_factor,
+                                        data->drawable_width,
+                                        data->drawable_height,
                                         0, 0);
     }
 
@@ -1394,9 +1916,18 @@ Wayland_HandleResize(SDL_Window *window, int width, int height, float scale)
      * It doesn't fix the first frames after resize being glitched visually,
      * but at least lets us not be terminated by the compositor.
      * Can be removed once SDL's resize logic becomes compliant. */
-    if (viddata->shell.xdg && data->shell_surface.xdg.surface) {
-       xdg_surface_set_window_geometry(data->shell_surface.xdg.surface, 0, 0, window->w, window->h);
+    if (
+#ifdef HAVE_LIBDECOR_H
+        !WINDOW_IS_LIBDECOR(viddata, window) &&
+#endif
+        viddata->shell.xdg &&
+        data->shell_surface.xdg.surface) {
+        xdg_surface_set_window_geometry(data->shell_surface.xdg.surface, 0, 0,
+                                        GetWindowWidth(window), GetWindowHeight(window));
     }
+
+    /* Update the viewport */
+    ConfigureViewport(window);
 }
 
 void
@@ -1422,7 +1953,7 @@ void Wayland_SetWindowSize(_THIS, SDL_Window * window)
 
 #ifdef HAVE_LIBDECOR_H
     /* we must not resize the window while we have a static (non-floating) size */
-    if (data->shell.libdecor &&
+    if (WINDOW_IS_LIBDECOR(data, window) &&
         wind->shell_surface.libdecor.frame &&
         !libdecor_frame_is_floating(wind->shell_surface.libdecor.frame)) {
             /* Commit the resize when we re-enter floating state */
@@ -1431,18 +1962,18 @@ void Wayland_SetWindowSize(_THIS, SDL_Window * window)
     }
 #endif
 
-    wl_surface_set_buffer_scale(wind->surface, wind->scale_factor);
+    SetDrawScale(window);
 
     if (wind->egl_window) {
         WAYLAND_wl_egl_window_resize(wind->egl_window,
-                                     window->w * wind->scale_factor,
-                                     window->h * wind->scale_factor,
+                                     wind->drawable_width,
+                                     wind->drawable_height,
                                      0, 0);
     }
 
 #ifdef HAVE_LIBDECOR_H
-    if (data->shell.libdecor && wind->shell_surface.libdecor.frame) {
-        state = libdecor_state_new(window->w, window->h);
+    if (WINDOW_IS_LIBDECOR(data, window) && wind->shell_surface.libdecor.frame) {
+        state = libdecor_state_new(GetWindowWidth(window), GetWindowHeight(window));
         libdecor_frame_commit(wind->shell_surface.libdecor.frame, state, NULL);
         libdecor_state_free(state);
     }
@@ -1458,8 +1989,14 @@ void Wayland_SetWindowSize(_THIS, SDL_Window * window)
     wl_region_destroy(region);
 
     /* Update the geometry which may have been set by a hack in Wayland_HandleResize */
-    if (data->shell.xdg && wind->shell_surface.xdg.surface) {
-       xdg_surface_set_window_geometry(wind->shell_surface.xdg.surface, 0, 0, window->w, window->h);
+    if (
+#ifdef HAVE_LIBDECOR_H
+        !WINDOW_IS_LIBDECOR(data, window) &&
+#endif
+        data->shell.xdg &&
+        wind->shell_surface.xdg.surface) {
+        xdg_surface_set_window_geometry(wind->shell_surface.xdg.surface, 0, 0,
+                                        GetWindowWidth(window), GetWindowHeight(window));
     }
 }
 
@@ -1468,9 +2005,13 @@ void Wayland_SetWindowTitle(_THIS, SDL_Window * window)
     SDL_WindowData *wind = window->driverdata;
     SDL_VideoData *viddata = _this->driverdata;
 
+    if (WINDOW_IS_XDG_POPUP(window)) {
+        return;
+    }
+
     if (window->title != NULL) {
 #ifdef HAVE_LIBDECOR_H
-        if (viddata->shell.libdecor) {
+        if (WINDOW_IS_LIBDECOR(viddata, window)) {
             if (wind->shell_surface.libdecor.frame == NULL) {
                 return; /* Can't do anything yet, wait for ShowWindow */
             }
@@ -1549,6 +2090,10 @@ void Wayland_DestroyWindow(_THIS, SDL_Window *window)
             xdg_activation_token_v1_destroy(wind->activation_token);
         }
 
+        if (wind->viewport) {
+            wp_viewport_destroy(wind->viewport);
+        }
+
         SDL_free(wind->outputs);
 
         if (wind->frame_callback) {
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandwindow.h b/Engine/lib/sdl/src/video/wayland/SDL_waylandwindow.h
index 90e4d8cf6..b1ba98cf9 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandwindow.h
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandwindow.h
@@ -36,16 +36,27 @@ typedef struct {
     struct xdg_surface *surface;
     union {
         struct xdg_toplevel *toplevel;
-        struct xdg_popup *popup;
+        struct {
+            struct xdg_popup *popup;
+            struct xdg_positioner *positioner;
+            Uint32 parentID;
+            SDL_Window *child;
+        } popup;
     } roleobj;
     SDL_bool initial_configure_seen;
 } SDL_xdg_shell_surface;
 
+#define WINDOW_IS_XDG_POPUP(window) \
+    (window->flags & (SDL_WINDOW_TOOLTIP | SDL_WINDOW_POPUP_MENU))
+
 #ifdef HAVE_LIBDECOR_H
 typedef struct {
     struct libdecor_frame *frame;
     SDL_bool initial_configure_seen;
 } SDL_libdecor_surface;
+
+#define WINDOW_IS_LIBDECOR(viddata, window) \
+    (viddata->shell.libdecor && !WINDOW_IS_XDG_POPUP(window))
 #endif
 
 typedef struct {
@@ -72,6 +83,7 @@ typedef struct {
     struct zwp_keyboard_shortcuts_inhibitor_v1 *key_inhibitor;
     struct zwp_idle_inhibitor_v1 *idle_inhibitor;
     struct xdg_activation_token_v1 *activation_token;
+    struct wp_viewport *viewport;
 
     /* floating dimensions for restoring from maximized and fullscreen */
     int floating_width, floating_height;
@@ -86,6 +98,10 @@ typedef struct {
     int num_outputs;
 
     float scale_factor;
+    float pointer_scale_x;
+    float pointer_scale_y;
+    int drawable_width, drawable_height;
+    SDL_Rect damage_region;
     SDL_bool needs_resize_event;
     SDL_bool floating_resize_pending;
 } SDL_WindowData;
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowsevents.c b/Engine/lib/sdl/src/video/windows/SDL_windowsevents.c
index 0619f67dd..ebd0dd1f9 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowsevents.c
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowsevents.c
@@ -378,14 +378,14 @@ WIN_CheckAsyncMouseRelease(SDL_WindowData *data)
 }
 
 static void
-WIN_UpdateFocus(SDL_Window *window)
+WIN_UpdateFocus(SDL_Window *window, SDL_bool expect_focus)
 {
     SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
     HWND hwnd = data->hwnd;
     SDL_bool had_focus = (SDL_GetKeyboardFocus() == window) ? SDL_TRUE : SDL_FALSE;
     SDL_bool has_focus = (GetForegroundWindow() == hwnd) ? SDL_TRUE : SDL_FALSE;
 
-    if (had_focus == has_focus) {
+    if (had_focus == has_focus || has_focus != expect_focus) {
         return;
     }
 
@@ -686,7 +686,7 @@ WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
             /* Update the focus here, since it's possible to get WM_ACTIVATE and WM_SETFOCUS without
                actually being the foreground window, but this appears to get called in all cases where
                the global foreground window changes to and from this window. */
-            WIN_UpdateFocus(data->window);
+            WIN_UpdateFocus(data->window, !!wParam);
             WIN_CheckICMProfileChanged(data->window);
         }
         break;
@@ -694,16 +694,22 @@ WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
     case WM_ACTIVATE:
         {
             /* Update the focus in case we changed focus to a child window and then away from the application */
-            WIN_UpdateFocus(data->window);
+            WIN_UpdateFocus(data->window, !!LOWORD(wParam));
         }
         break;
 
     case WM_SETFOCUS:
+        {
+            /* Update the focus in case it's changing between top-level windows in the same application */
+            WIN_UpdateFocus(data->window, SDL_TRUE);
+        }
+        break;
+
     case WM_KILLFOCUS:
     case WM_ENTERIDLE:
         {
             /* Update the focus in case it's changing between top-level windows in the same application */
-            WIN_UpdateFocus(data->window);
+            WIN_UpdateFocus(data->window, SDL_FALSE);
         }
         break;
 
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowswindow.c b/Engine/lib/sdl/src/video/windows/SDL_windowswindow.c
index 890d790ea..6dcea5bf2 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowswindow.c
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowswindow.c
@@ -158,7 +158,7 @@ WIN_SetWindowPositionInternal(_THIS, SDL_Window * window, UINT flags)
     int w, h;
 
     /* Figure out what the window area will be */
-    if (SDL_ShouldAllowTopmost() && ((window->flags & (SDL_WINDOW_FULLSCREEN|SDL_WINDOW_INPUT_FOCUS)) == (SDL_WINDOW_FULLSCREEN|SDL_WINDOW_INPUT_FOCUS) || (window->flags & SDL_WINDOW_ALWAYS_ON_TOP))) {
+    if (SDL_ShouldAllowTopmost() && (window->flags & SDL_WINDOW_ALWAYS_ON_TOP)) {
         top = HWND_TOPMOST;
     } else {
         top = HWND_NOTOPMOST;
@@ -734,7 +734,14 @@ WIN_SetWindowFullscreen(_THIS, SDL_Window * window, SDL_VideoDisplay * display,
     int x, y;
     int w, h;
 
-    if (SDL_ShouldAllowTopmost() && ((window->flags & (SDL_WINDOW_FULLSCREEN|SDL_WINDOW_INPUT_FOCUS)) == (SDL_WINDOW_FULLSCREEN|SDL_WINDOW_INPUT_FOCUS) || window->flags & SDL_WINDOW_ALWAYS_ON_TOP)) {
+    if (!fullscreen && (window->flags & (SDL_WINDOW_FULLSCREEN|SDL_WINDOW_FULLSCREEN_DESKTOP)) != 0) {
+        /* Resizing the window on hide causes problems restoring it in Wine, and it's unnecessary.
+         * Also, Windows would preview the minimized window with the wrong size.
+         */
+        return;
+    }
+
+    if (SDL_ShouldAllowTopmost() && (window->flags & SDL_WINDOW_ALWAYS_ON_TOP)) {
         top = HWND_TOPMOST;
     } else {
         top = HWND_NOTOPMOST;
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11events.c b/Engine/lib/sdl/src/video/x11/SDL_x11events.c
index c1260215d..63091fe98 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11events.c
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11events.c
@@ -380,7 +380,7 @@ X11_GetScrollLockModifierMask(_THIS)
     return num_mask;
 }
 
-static void
+void
 X11_ReconcileKeyboardState(_THIS)
 {
     SDL_VideoData *viddata = (SDL_VideoData *) _this->driverdata;
@@ -408,7 +408,22 @@ X11_ReconcileKeyboardState(_THIS)
         SDL_bool sdlKeyPressed = keyboardState[scancode] == SDL_PRESSED;
 
         if (x11KeyPressed && !sdlKeyPressed) {
-            SDL_SendKeyboardKey(SDL_PRESSED, scancode);
+            /* Only update modifier state for keys that are pressed in another application */
+            switch (SDL_GetKeyFromScancode(scancode)) {
+            case SDLK_LCTRL:
+            case SDLK_RCTRL:
+            case SDLK_LSHIFT:
+            case SDLK_RSHIFT:
+            case SDLK_LALT:
+            case SDLK_RALT:
+            case SDLK_LGUI:
+            case SDLK_RGUI:
+            case SDLK_MODE:
+                SDL_SendKeyboardKey(SDL_PRESSED, scancode);
+                break;
+            default:
+                break;
+            }
         } else if (!x11KeyPressed && sdlKeyPressed) {
             SDL_SendKeyboardKey(SDL_RELEASED, scancode);
         }
@@ -718,7 +733,6 @@ static void
 X11_DispatchEvent(_THIS, XEvent *xevent)
 {
     SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;
-    XkbEvent* xkbEvent = (XkbEvent*) xevent;
     Display *display;
     SDL_WindowData *data;
     int orig_event_type;
@@ -805,11 +819,13 @@ X11_DispatchEvent(_THIS, XEvent *xevent)
     if (!data) {
         /* The window for KeymapNotify, etc events is 0 */
         if (xevent->type == KeymapNotify) {
+#ifdef DEBUG_XEVENTS
+            printf("window %p: KeymapNotify!\n", data);
+#endif
             if (SDL_GetKeyboardFocus() != NULL) {
                 X11_ReconcileKeyboardState(_this);
             }
-        } else if (xevent->type == MappingNotify ||
-                   (xevent->type == videodata->xkb_event && xkbEvent->any.xkb_type == XkbStateNotify)) {
+        } else if (xevent->type == MappingNotify) {
             /* Has the keyboard layout changed? */
             const int request = xevent->xmapping.request;
 
@@ -996,8 +1012,9 @@ X11_DispatchEvent(_THIS, XEvent *xevent)
         }
         break;
 
-        /* Key press? */
-    case KeyPress:{
+        /* Key press/release? */
+    case KeyPress:
+    case KeyRelease: {
             KeyCode keycode = xevent->xkey.keycode;
             KeySym keysym = NoSymbol;
             char text[SDL_TEXTINPUTEVENT_TEXT_SIZE];
@@ -1005,7 +1022,7 @@ X11_DispatchEvent(_THIS, XEvent *xevent)
             SDL_bool handled_by_ime = SDL_FALSE;
 
 #ifdef DEBUG_XEVENTS
-            printf("window %p: KeyPress (X11 keycode = 0x%X)\n", data, xevent->xkey.keycode);
+            printf("window %p: %s (X11 keycode = 0x%X)\n", data, (xevent->type == KeyPress ? "KeyPress" : "KeyRelease"), xevent->xkey.keycode);
 #endif
 #if 1
             if (videodata->key_layout[keycode] == SDL_SCANCODE_UNKNOWN && keycode) {
@@ -1021,7 +1038,7 @@ X11_DispatchEvent(_THIS, XEvent *xevent)
             /* */
             SDL_zeroa(text);
 #ifdef X_HAVE_UTF8_STRING
-            if (data->ic) {
+            if (data->ic && xevent->type == KeyPress) {
                 X11_Xutf8LookupString(data->ic, &xevent->xkey, text, sizeof(text),
                                   &keysym, &status);
             } else {
@@ -1033,35 +1050,30 @@ X11_DispatchEvent(_THIS, XEvent *xevent)
 
 #ifdef SDL_USE_IME
             if(SDL_GetEventState(SDL_TEXTINPUT) == SDL_ENABLE){
-                handled_by_ime = SDL_IME_ProcessKeyEvent(keysym, keycode);
+                handled_by_ime = SDL_IME_ProcessKeyEvent(keysym, keycode, (xevent->type == KeyPress ? SDL_PRESSED : SDL_RELEASED));
             }
 #endif
             if (!handled_by_ime) {
-                /* Don't send the key if it looks like a duplicate of a filtered key sent by an IME */
-                if (xevent->xkey.keycode != videodata->filter_code || xevent->xkey.time != videodata->filter_time) {
-                    SDL_SendKeyboardKey(SDL_PRESSED, videodata->key_layout[keycode]);
-                }
-                if(*text) {
-                    SDL_SendKeyboardText(text);
+                if (xevent->type == KeyPress) {
+                    /* Don't send the key if it looks like a duplicate of a filtered key sent by an IME */
+                    if (xevent->xkey.keycode != videodata->filter_code || xevent->xkey.time != videodata->filter_time) {
+                        SDL_SendKeyboardKey(SDL_PRESSED, videodata->key_layout[keycode]);
+                    }
+                    if(*text) {
+                        SDL_SendKeyboardText(text);
+                    }
+                } else {
+                    if (X11_KeyRepeat(display, xevent)) {
+                        /* We're about to get a repeated key down, ignore the key up */
+                        break;
+                    }
+                    SDL_SendKeyboardKey(SDL_RELEASED, videodata->key_layout[keycode]);
                 }
             }
 
-            X11_UpdateUserTime(data, xevent->xkey.time);
-        }
-        break;
-
-        /* Key release? */
-    case KeyRelease:{
-            KeyCode keycode = xevent->xkey.keycode;
-
-#ifdef DEBUG_XEVENTS
-            printf("window %p: KeyRelease (X11 keycode = 0x%X)\n", data, xevent->xkey.keycode);
-#endif
-            if (X11_KeyRepeat(display, xevent)) {
-                /* We're about to get a repeated key down, ignore the key up */
-                break;
+            if (xevent->type == KeyPress) {
+                X11_UpdateUserTime(data, xevent->xkey.time);
             }
-            SDL_SendKeyboardKey(SDL_RELEASED, videodata->key_layout[keycode]);
         }
         break;
 
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11events.h b/Engine/lib/sdl/src/video/x11/SDL_x11events.h
index fc8a57ae2..de89110d0 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11events.h
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11events.h
@@ -27,6 +27,7 @@ extern void X11_PumpEvents(_THIS);
 extern int  X11_WaitEventTimeout(_THIS, int timeout);
 extern void X11_SendWakeupEvent(_THIS, SDL_Window *window);
 extern void X11_SuspendScreenSaver(_THIS);
+extern void X11_ReconcileKeyboardState(_THIS);
 
 #endif /* SDL_x11events_h_ */
 
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11keyboard.c b/Engine/lib/sdl/src/video/x11/SDL_x11keyboard.c
index c82570c62..c84bcc798 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11keyboard.c
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11keyboard.c
@@ -409,6 +409,8 @@ X11_InitKeyboard(_THIS)
     SDL_IME_Init();
 #endif
 
+    X11_ReconcileKeyboardState(_this);
+
     return 0;
 }
 
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11messagebox.c b/Engine/lib/sdl/src/video/x11/SDL_x11messagebox.c
index aafccca9b..9bc9702c0 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11messagebox.c
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11messagebox.c
@@ -830,10 +830,11 @@ X11_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid)
         int exitcode = 0;
         close(fds[0]);
         status = X11_ShowMessageBoxImpl(messageboxdata, buttonid);
-        if (write(fds[1], &status, sizeof (int)) != sizeof (int))
+        if (write(fds[1], &status, sizeof (int)) != sizeof (int)) {
             exitcode = 1;
-        else if (write(fds[1], buttonid, sizeof (int)) != sizeof (int))
+        } else if (write(fds[1], buttonid, sizeof (int)) != sizeof (int)) {
             exitcode = 1;
+        }
         close(fds[1]);
         _exit(exitcode);  /* don't run atexit() stuff, static destructors, etc. */
     } else {  /* we're the parent */
@@ -846,13 +847,12 @@ X11_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid)
         SDL_assert(rc == pid);  /* not sure what to do if this fails. */
 
         if ((rc == -1) || (!WIFEXITED(status)) || (WEXITSTATUS(status) != 0)) {
-            return SDL_SetError("msgbox child process failed");
+            status = SDL_SetError("msgbox child process failed");
+        } else if ( (read(fds[0], &status, sizeof (int)) != sizeof (int)) ||
+                    (read(fds[0], buttonid, sizeof (int)) != sizeof (int)) ) {
+            status = SDL_SetError("read from msgbox child process failed");
+            *buttonid = 0;
         }
-
-        if (read(fds[0], &status, sizeof (int)) != sizeof (int))
-            status = -1;
-        else if (read(fds[0], buttonid, sizeof (int)) != sizeof (int))
-            status = -1;
         close(fds[0]);
 
         return status;
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11modes.c b/Engine/lib/sdl/src/video/x11/SDL_x11modes.c
index c1efe243c..f2cbdb45f 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11modes.c
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11modes.c
@@ -1011,7 +1011,13 @@ static int (*PreXRRSetScreenSizeErrorHandler)(Display *, XErrorEvent *) = NULL;
 static int
 SDL_XRRSetScreenSizeErrHandler(Display *d, XErrorEvent *e)
 {
-    return (e->error_code == BadMatch) ? 0 : PreXRRSetScreenSizeErrorHandler(d, e);
+    /* BadMatch: https://github.com/libsdl-org/SDL/issues/4561 */
+    /* BadValue: https://github.com/libsdl-org/SDL/issues/4840 */
+    if ((e->error_code == BadMatch) || (e->error_code == BadValue)) {
+        return 0;
+    }
+
+    return PreXRRSetScreenSizeErrorHandler(d, e);
 }
 
 int
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11opengl.c b/Engine/lib/sdl/src/video/x11/SDL_x11opengl.c
index 64b06340a..3e17e97ff 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11opengl.c
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11opengl.c
@@ -247,11 +247,6 @@ X11_GL_LoadLibrary(_THIS, const char *path)
         X11_GL_UseEGL(_this) ) {
 #if SDL_VIDEO_OPENGL_EGL
         X11_GL_UnloadLibrary(_this);
-        /* Better avoid conflicts! */
-        if (_this->gl_config.dll_handle != NULL ) {
-            GL_UnloadObject(_this->gl_config.dll_handle);
-            _this->gl_config.dll_handle = NULL;
-        }
         _this->GL_LoadLibrary = X11_GLES_LoadLibrary;
         _this->GL_GetProcAddress = X11_GLES_GetProcAddress;
         _this->GL_UnloadLibrary = X11_GLES_UnloadLibrary;
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11sym.h b/Engine/lib/sdl/src/video/x11/SDL_x11sym.h
index 67b0a793a..762a86596 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11sym.h
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11sym.h
@@ -185,7 +185,6 @@ SDL_X11_SYM(XkbDescPtr,XkbGetMap,(Display* a,unsigned int b,unsigned int c),(a,b
 SDL_X11_SYM(void,XkbFreeClientMap,(XkbDescPtr a,unsigned int b, Bool c),(a,b,c),)
 SDL_X11_SYM(void,XkbFreeKeyboard,(XkbDescPtr a,unsigned int b, Bool c),(a,b,c),)
 SDL_X11_SYM(Bool,XkbSetDetectableAutoRepeat,(Display* a, Bool b, Bool* c),(a,b,c),return)
-SDL_X11_SYM(Bool,XkbSelectEvents,(Display* a, unsigned int b, unsigned int c, unsigned int d),(a,b,c,d),return)
 #endif
 
 #if NeedWidePrototypes
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11window.c b/Engine/lib/sdl/src/video/x11/SDL_x11window.c
index a6bd91d72..d31ac012a 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11window.c
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11window.c
@@ -678,8 +678,6 @@ X11_CreateWindow(_THIS, SDL_Window * window)
     /* For _ICC_PROFILE. */
     X11_XSelectInput(display, RootWindow(display, screen), PropertyChangeMask);
 
-    X11_XkbSelectEvents(display, XkbUseCoreKbd, XkbStateNotifyMask, XkbStateNotifyMask);
-
     X11_XFlush(display);
 
     return 0;
@@ -782,11 +780,22 @@ X11_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon)
     X11_XFlush(display);
 }
 
+static SDL_bool caught_x11_error = SDL_FALSE;
+static int
+X11_CatchAnyError(Display * d, XErrorEvent * e)
+{
+    /* this may happen during tumultuous times when we are polling anyhow,
+        so just note we had an error and return control. */
+    caught_x11_error = SDL_TRUE;
+    return 0;
+}
+
 void
 X11_SetWindowPosition(_THIS, SDL_Window * window)
 {
     SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
     Display *display = data->videodata->display;
+    int (*prev_handler) (Display *, XErrorEvent *) = NULL;
     unsigned int childCount;
     Window childReturn, root, parent;
     Window* children;
@@ -805,20 +814,27 @@ X11_SetWindowPosition(_THIS, SDL_Window * window)
 
     /* Wait a brief time to see if the window manager decided to let this move happen.
        If the window changes at all, even to an unexpected value, we break out. */
+    X11_XSync(display, False);
+    prev_handler = X11_XSetErrorHandler(X11_CatchAnyError);
+
     timeout = SDL_GetTicks() + 100;
     while (SDL_TRUE) {
         int x, y;
+
+        caught_x11_error = SDL_FALSE;
         X11_XSync(display, False);
         X11_XGetWindowAttributes(display, data->xwindow, &attrs);
         X11_XTranslateCoordinates(display, parent, DefaultRootWindow(display),
                                   attrs.x, attrs.y, &x, &y, &childReturn);
 
-        if ((x != orig_x) || (y != orig_y)) {
-            window->x = x;
-            window->y = y;
-            break;  /* window moved, time to go. */
-        } else if ((x == window->x) && (y == window->y)) {
-            break;  /* we're at the place we wanted to be anyhow, drop out. */
+        if (!caught_x11_error) {
+            if ((x != orig_x) || (y != orig_y)) {
+                window->x = x;
+                window->y = y;
+                break;  /* window moved, time to go. */
+            } else if ((x == window->x) && (y == window->y)) {
+                break;  /* we're at the place we wanted to be anyhow, drop out. */
+            }
         }
 
         if (SDL_TICKS_PASSED(SDL_GetTicks(), timeout)) {
@@ -827,6 +843,9 @@ X11_SetWindowPosition(_THIS, SDL_Window * window)
 
         SDL_Delay(10);
     }
+
+    X11_XSetErrorHandler(prev_handler);
+    caught_x11_error = SDL_FALSE;
 }
 
 void
@@ -892,6 +911,7 @@ X11_SetWindowSize(_THIS, SDL_Window * window)
 {
     SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
     Display *display = data->videodata->display;
+    int (*prev_handler) (Display *, XErrorEvent *) = NULL;
     XWindowAttributes attrs;
     int orig_w, orig_h;
     Uint32 timeout;
@@ -943,19 +963,25 @@ X11_SetWindowSize(_THIS, SDL_Window * window)
         X11_XResizeWindow(display, data->xwindow, window->w, window->h);
     }
 
+    X11_XSync(display, False);
+    prev_handler = X11_XSetErrorHandler(X11_CatchAnyError);
+
     /* Wait a brief time to see if the window manager decided to let this resize happen.
        If the window changes at all, even to an unexpected value, we break out. */
     timeout = SDL_GetTicks() + 100;
     while (SDL_TRUE) {
+        caught_x11_error = SDL_FALSE;
         X11_XSync(display, False);
         X11_XGetWindowAttributes(display, data->xwindow, &attrs);
 
-        if ((attrs.width != orig_w) || (attrs.height != orig_h)) {
-            window->w = attrs.width;
-            window->h = attrs.height;
-            break;  /* window changed, time to go. */
-        } else if ((attrs.width == window->w) && (attrs.height == window->h)) {
-            break;  /* we're at the place we wanted to be anyhow, drop out. */
+        if (!caught_x11_error) {
+            if ((attrs.width != orig_w) || (attrs.height != orig_h)) {
+                window->w = attrs.width;
+                window->h = attrs.height;
+                break;  /* window changed, time to go. */
+            } else if ((attrs.width == window->w) && (attrs.height == window->h)) {
+                break;  /* we're at the place we wanted to be anyhow, drop out. */
+            }
         }
 
         if (SDL_TICKS_PASSED(SDL_GetTicks(), timeout)) {
@@ -964,6 +990,9 @@ X11_SetWindowSize(_THIS, SDL_Window * window)
 
         SDL_Delay(10);
     }
+
+    X11_XSetErrorHandler(prev_handler);
+    caught_x11_error = SDL_FALSE;
 }
 
 int
@@ -1281,6 +1310,22 @@ X11_SetWindowFullscreenViaWM(_THIS, SDL_Window * window, SDL_VideoDisplay * _dis
 
     if (X11_IsWindowMapped(_this, window)) {
         XEvent e;
+        /* !!! FIXME: most of this waiting code is copy/pasted from elsewhere. */
+        int (*prev_handler) (Display *, XErrorEvent *) = NULL;
+        unsigned int childCount;
+        Window childReturn, root, parent;
+        Window* children;
+        XWindowAttributes attrs;
+        int orig_w, orig_h, orig_x, orig_y;
+        Uint64 timeout;
+
+        X11_XSync(display, False);
+        X11_XQueryTree(display, data->xwindow, &root, &parent, &children, &childCount);
+        X11_XGetWindowAttributes(display, data->xwindow, &attrs);
+        X11_XTranslateCoordinates(display, parent, DefaultRootWindow(display),
+                                  attrs.x, attrs.y, &orig_x, &orig_y, &childReturn);
+        orig_w = attrs.width;
+        orig_h = attrs.height;
 
         if (!(window->flags & SDL_WINDOW_RESIZABLE)) {
             /* Compiz refuses fullscreen toggle if we're not resizable, so update the hints so we
@@ -1330,6 +1375,41 @@ X11_SetWindowFullscreenViaWM(_THIS, SDL_Window * window, SDL_VideoDisplay * _dis
             X11_XSendEvent(display, RootWindow(display, displaydata->screen), 0,
                    SubstructureNotifyMask | SubstructureRedirectMask, &e);
         }
+
+        /* Wait a brief time to see if the window manager decided to let this happen.
+           If the window changes at all, even to an unexpected value, we break out. */
+        X11_XSync(display, False);
+        prev_handler = X11_XSetErrorHandler(X11_CatchAnyError);
+
+        timeout = SDL_GetTicks64() + 100;
+        while (SDL_TRUE) {
+            int x, y;
+
+            caught_x11_error = SDL_FALSE;
+            X11_XSync(display, False);
+            X11_XGetWindowAttributes(display, data->xwindow, &attrs);
+            X11_XTranslateCoordinates(display, parent, DefaultRootWindow(display),
+                                      attrs.x, attrs.y, &x, &y, &childReturn);
+
+            if (!caught_x11_error) {
+                if ((x != orig_x) || (y != orig_y) || (attrs.width != orig_w) || (attrs.height != orig_h)) {
+                    window->x = x;
+                    window->y = y;
+                    window->w = attrs.width;
+                    window->h = attrs.height;
+                    break;  /* window moved, time to go. */
+                }
+            }
+
+            if (SDL_GetTicks64() >= timeout) {
+                break;
+            }
+
+            SDL_Delay(10);
+        }
+
+        X11_XSetErrorHandler(prev_handler);
+        caught_x11_error = SDL_FALSE;
     } else {
         Uint32 flags;
 
diff --git a/Engine/lib/sdl/src/video/yuv2rgb/yuv_rgb_sse_func.h b/Engine/lib/sdl/src/video/yuv2rgb/yuv_rgb_sse_func.h
index 3c5ee0db4..f541017a4 100644
--- a/Engine/lib/sdl/src/video/yuv2rgb/yuv_rgb_sse_func.h
+++ b/Engine/lib/sdl/src/video/yuv2rgb/yuv_rgb_sse_func.h
@@ -426,9 +426,17 @@ void SSE_FUNCTION_NAME(uint32_t width, uint32_t height,
 	const int fix_read_nv12 = 0;
 #endif
 
+#if YUV_FORMAT == YUV_FORMAT_422
+	/* Avoid invalid read on last line */
+	const int fix_read_422 = 1;
+#else
+	const int fix_read_422 = 0;
+#endif
+
+
 	if (width >= 32) {
 		uint32_t xpos, ypos;
-		for(ypos=0; ypos<(height-(uv_y_sample_interval-1)); ypos+=uv_y_sample_interval)
+		for(ypos=0; ypos<(height-(uv_y_sample_interval-1)) - fix_read_422; ypos+=uv_y_sample_interval)
 		{
 			const uint8_t *y_ptr1=Y+ypos*Y_stride,
 				*y_ptr2=Y+(ypos+1)*Y_stride,
@@ -459,6 +467,15 @@ void SSE_FUNCTION_NAME(uint32_t width, uint32_t height,
 			}
 		}
 
+		if (fix_read_422) {
+			const uint8_t *y_ptr=Y+ypos*Y_stride,
+				*u_ptr=U+(ypos/uv_y_sample_interval)*UV_stride,
+				*v_ptr=V+(ypos/uv_y_sample_interval)*UV_stride;
+			uint8_t *rgb_ptr=RGB+ypos*RGB_stride;
+			STD_FUNCTION_NAME(width, 1, y_ptr, u_ptr, v_ptr, Y_stride, UV_stride, rgb_ptr, RGB_stride, yuv_type);
+			ypos += uv_y_sample_interval;
+		}
+
 		/* Catch the last line, if needed */
 		if (uv_y_sample_interval == 2 && ypos == (height-1))
 		{
diff --git a/Engine/lib/sdl/test/Makefile.in b/Engine/lib/sdl/test/Makefile.in
index d29dc6ecf..f724618c6 100644
--- a/Engine/lib/sdl/test/Makefile.in
+++ b/Engine/lib/sdl/test/Makefile.in
@@ -364,6 +364,7 @@ DATA = \
 	testgles2_sdf_img_sdf.bmp \
 	testyuv.bmp \
 	unifont-13.0.06.hex \
+	utf8.txt \
 	$(NULL)
 
 ifneq ($(srcdir), .)
diff --git a/Engine/lib/sdl/test/testautomation_rect.c b/Engine/lib/sdl/test/testautomation_rect.c
index 26f03e9bb..cd8f65c34 100644
--- a/Engine/lib/sdl/test/testautomation_rect.c
+++ b/Engine/lib/sdl/test/testautomation_rect.c
@@ -408,6 +408,32 @@ void _validateRectEqualsResults(
         refRectB->x, refRectB->y, refRectB->w, refRectB->h);
 }
 
+/* !
+ * \brief Private helper to check SDL_FRectEquals results
+ */
+void _validateFRectEqualsResults(
+    SDL_bool equals, SDL_bool expectedEquals,
+    SDL_FRect *rectA, SDL_FRect *rectB, SDL_FRect *refRectA, SDL_FRect *refRectB)
+{
+    int cmpRes;
+    SDLTest_AssertCheck(equals == expectedEquals,
+        "Check for correct equals result: expected %s, got %s testing (%f,%f,%f,%f) and (%f,%f,%f,%f)",
+        (expectedEquals == SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE",
+        (equals == SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE",
+        rectA->x, rectA->y, rectA->w, rectA->h,
+        rectB->x, rectB->y, rectB->w, rectB->h);
+    cmpRes = SDL_memcmp(rectA, refRectA, sizeof(*rectA));
+    SDLTest_AssertCheck(cmpRes == 0,
+        "Check that source rectangle A was not modified: got (%f,%f,%f,%f) expected (%f,%f,%f,%f)",
+        rectA->x, rectA->y, rectA->w, rectA->h,
+        refRectA->x, refRectA->y, refRectA->w, refRectA->h);
+    cmpRes = SDL_memcmp(rectB, refRectB, sizeof(*rectB));
+    SDLTest_AssertCheck(cmpRes == 0,
+        "Check that source rectangle B was not modified: got (%f,%f,%f,%f) expected (%f,%f,%f,%f)",
+        rectB->x, rectB->y, rectB->w, rectB->h,
+        refRectB->x, refRectB->y, refRectB->w, refRectB->h);
+}
+
 /* !
  * \brief Tests SDL_IntersectRect() with B fully inside A
  *
@@ -1574,6 +1600,69 @@ int rect_testRectEqualsParam(void *arg)
     return TEST_COMPLETED;
 }
 
+/* !
+ * \brief Tests SDL_FRectEquals() with various inputs
+ *
+ * \sa
+ * http://wiki.libsdl.org/SDL_FRectEquals
+ */
+int rect_testFRectEquals(void *arg)
+{
+    SDL_FRect refRectA;
+    SDL_FRect refRectB;
+    SDL_FRect rectA;
+    SDL_FRect rectB;
+    SDL_bool expectedResult;
+    SDL_bool result;
+
+    /* Equals */
+    refRectA.x=(float)SDLTest_RandomIntegerInRange(-1024, 1024);
+    refRectA.y=(float)SDLTest_RandomIntegerInRange(-1024, 1024);
+    refRectA.w=(float)SDLTest_RandomIntegerInRange(1, 1024);
+    refRectA.h=(float)SDLTest_RandomIntegerInRange(1, 1024);
+    refRectB = refRectA;
+    expectedResult = SDL_TRUE;
+    rectA = refRectA;
+    rectB = refRectB;
+    result = (SDL_bool)SDL_FRectEquals((const SDL_FRect *)&rectA, (const SDL_FRect *)&rectB);
+    _validateFRectEqualsResults(result, expectedResult, &rectA, &rectB, &refRectA, &refRectB);
+
+    return TEST_COMPLETED;
+}
+
+/* !
+ * \brief Negative tests against SDL_FRectEquals() with invalid parameters
+ *
+ * \sa
+ * http://wiki.libsdl.org/SDL_FRectEquals
+ */
+int rect_testFRectEqualsParam(void *arg)
+{
+    SDL_FRect rectA;
+    SDL_FRect rectB;
+    SDL_bool result;
+
+    /* data setup -- For the purpose of this test, the values don't matter. */
+    rectA.x=SDLTest_RandomFloat();
+    rectA.y=SDLTest_RandomFloat();
+    rectA.w=SDLTest_RandomFloat();
+    rectA.h=SDLTest_RandomFloat();
+    rectB.x=SDLTest_RandomFloat();
+    rectB.y=SDLTest_RandomFloat();
+    rectB.w=SDLTest_RandomFloat();
+    rectB.h=SDLTest_RandomFloat();
+
+    /* invalid parameter combinations */
+    result = (SDL_bool)SDL_FRectEquals((const SDL_FRect *)NULL, (const SDL_FRect *)&rectB);
+    SDLTest_AssertCheck(result == SDL_FALSE, "Check that function returns SDL_FALSE when 1st parameter is NULL");
+    result = (SDL_bool)SDL_FRectEquals((const SDL_FRect *)&rectA, (const SDL_FRect *)NULL);
+    SDLTest_AssertCheck(result == SDL_FALSE, "Check that function returns SDL_FALSE when 2nd parameter is NULL");
+    result = (SDL_bool)SDL_FRectEquals((const SDL_FRect *)NULL, (const SDL_FRect *)NULL);
+    SDLTest_AssertCheck(result == SDL_FALSE, "Check that function returns SDL_FALSE when 1st and 2nd parameter are NULL");
+
+    return TEST_COMPLETED;
+}
+
 /* ================= Test References ================== */
 
 /* Rect test cases */
@@ -1673,6 +1762,13 @@ static const SDLTest_TestCaseReference rectTest28 =
 static const SDLTest_TestCaseReference rectTest29 =
         { (SDLTest_TestCaseFp)rect_testRectEqualsParam, "rect_testRectEqualsParam", "Negative tests against SDL_RectEquals with invalid parameters", TEST_ENABLED };
 
+/* SDL_FRectEquals */
+
+static const SDLTest_TestCaseReference rectTest30 =
+        { (SDLTest_TestCaseFp)rect_testFRectEquals, "rect_testFRectEquals", "Tests SDL_FRectEquals with various inputs", TEST_ENABLED };
+
+static const SDLTest_TestCaseReference rectTest31 =
+        { (SDLTest_TestCaseFp)rect_testFRectEqualsParam, "rect_testFRectEqualsParam", "Negative tests against SDL_FRectEquals with invalid parameters", TEST_ENABLED };
 
 /* !
  * \brief Sequence of Rect test cases; functions that handle simple rectangles including overlaps and merges.
@@ -1683,7 +1779,7 @@ static const SDLTest_TestCaseReference rectTest29 =
 static const SDLTest_TestCaseReference *rectTests[] =  {
     &rectTest1, &rectTest2, &rectTest3, &rectTest4, &rectTest5, &rectTest6, &rectTest7, &rectTest8, &rectTest9, &rectTest10, &rectTest11, &rectTest12, &rectTest13, &rectTest14,
     &rectTest15, &rectTest16, &rectTest17, &rectTest18, &rectTest19, &rectTest20, &rectTest21, &rectTest22, &rectTest23, &rectTest24, &rectTest25, &rectTest26, &rectTest27,
-    &rectTest28, &rectTest29, NULL
+    &rectTest28, &rectTest29, &rectTest30, &rectTest31, NULL
 };
 
 
diff --git a/Engine/lib/sdl/test/testevdev.c b/Engine/lib/sdl/test/testevdev.c
index 572c60a05..76a12ef7e 100644
--- a/Engine/lib/sdl/test/testevdev.c
+++ b/Engine/lib/sdl/test/testevdev.c
@@ -41,6 +41,7 @@ static const struct
     CLS(SOUND),
     CLS(TOUCHSCREEN),
     CLS(ACCELEROMETER),
+    CLS(TOUCHPAD),
 #undef CLS
     { 0, NULL }
 };
@@ -185,9 +186,7 @@ static const GuessTest guess_tests[] =
       .bus_type = 0x0003,
       .vendor_id = 0x054c,
       .product_id = 0x09cc,
-      /* TODO: Should this be MOUSE? That's what it most closely
-       * resembles */
-      .expected = SDL_UDEV_DEVICE_UNKNOWN,
+      .expected = SDL_UDEV_DEVICE_TOUCHPAD,
       /* SYN, KEY, ABS */
       .ev = { 0x0b },
       /* X, Y, multitouch */
@@ -596,7 +595,7 @@ static const GuessTest guess_tests[] =
        * to the arrow, page up and page down keys, so it's a joystick
        * with a subset of a keyboard attached. */
       /* TODO: Should this be JOYSTICK, or even JOYSTICK|KEYBOARD? */
-      .expected = SDL_UDEV_DEVICE_UNKNOWN,
+      .expected = SDL_UDEV_DEVICE_KEYBOARD,
       /* SYN, KEY */
       .ev = { 0x03 },
       .keys = {
@@ -608,7 +607,7 @@ static const GuessTest guess_tests[] =
           /* BTN_1, BTN_2, BTN_A, BTN_B, BTN_MODE */
           /* 0x100 */ 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x10,
           /* 0x140 */ ZEROx8,
-          /* next, previous */
+          /* next (keyboard page down), previous (keyboard page up) */
           /* 0x180 */ 0x00, 0x00, 0x80, 0x10, ZEROx4,
       },
     },
@@ -659,7 +658,7 @@ static const GuessTest guess_tests[] =
       .name = "Wiimote - Classic Controller",
       /* TODO: Should this be JOYSTICK, or maybe JOYSTICK|KEYBOARD?
        * It's unusual in the same ways as the Wiimote */
-      .expected = SDL_UDEV_DEVICE_UNKNOWN,
+      .expected = SDL_UDEV_DEVICE_KEYBOARD,
       /* SYN, KEY, ABS */
       .ev = { 0x0b },
       /* Hat 1-3 */
@@ -673,7 +672,7 @@ static const GuessTest guess_tests[] =
           /* A, B, X, Y, MODE, TL, TL2, TR, TR2 */
           /* 0x100 */ ZEROx4, 0x00, 0x13, 0xdb, 0x10,
           /* 0x140 */ ZEROx8,
-          /* next, previous */
+          /* next (keyboard page down), previous (keyboard page up) */
           /* 0x180 */ 0x00, 0x00, 0x80, 0x10, ZEROx4,
       },
     },
@@ -718,9 +717,7 @@ static const GuessTest guess_tests[] =
       .vendor_id = 0x06cb,
       .product_id = 0x0000,
       .version = 0x0000,
-      /* TODO: Should this be MOUSE? That's what it most closely
-       * resembles */
-      .expected = SDL_UDEV_DEVICE_UNKNOWN,
+      .expected = SDL_UDEV_DEVICE_TOUCHPAD,
       /* SYN, KEY, ABS */
       .ev = { 0x0b },
       /* X, Y, pressure, multitouch */
@@ -756,7 +753,8 @@ static const GuessTest guess_tests[] =
     },
     {
       .name = "Thinkpad ACPI buttons",
-      .expected = SDL_UDEV_DEVICE_UNKNOWN,
+      /* SDL treats this as a keyboard because it has a power button */
+      .expected = SDL_UDEV_DEVICE_KEYBOARD,
       /* SYN, KEY, MSC, SW */
       .ev = { 0x33 },
       .keys = {
@@ -815,7 +813,8 @@ static const GuessTest guess_tests[] =
       .vendor_id = 0x0000,
       .product_id = 0x0003,
       .version = 0x0000,
-      .expected = SDL_UDEV_DEVICE_UNKNOWN,
+      /* SDL treats KEY_SLEEP as indicating a keyboard */
+      .expected = SDL_UDEV_DEVICE_KEYBOARD,
       /* SYN, KEY */
       .ev = { 0x03 },
       .keys = {
@@ -841,7 +840,8 @@ static const GuessTest guess_tests[] =
       .vendor_id = 0x0000,
       .product_id = 0x0001,
       .version = 0x0000,
-      .expected = SDL_UDEV_DEVICE_UNKNOWN,
+      /* SDL treats KEY_POWER as indicating a keyboard */
+      .expected = SDL_UDEV_DEVICE_KEYBOARD,
       /* SYN, KEY */
       .ev = { 0x03 },
       .keys = {
@@ -856,7 +856,8 @@ static const GuessTest guess_tests[] =
       .vendor_id = 0x0000,
       .product_id = 0x0006,
       .version = 0x0000,
-      .expected = SDL_UDEV_DEVICE_UNKNOWN,
+      /* SDL treats brightness control, etc. as keyboard keys */
+      .expected = SDL_UDEV_DEVICE_KEYBOARD,
       /* SYN, KEY */
       .ev = { 0x03 },
       .keys = {
@@ -873,7 +874,7 @@ static const GuessTest guess_tests[] =
       .vendor_id = 0x17aa,
       .product_id = 0x5054,
       .version = 0x4101,
-      .expected = SDL_UDEV_DEVICE_UNKNOWN,
+      .expected = SDL_UDEV_DEVICE_KEYBOARD,
       /* SYN, KEY */
       .ev = { 0x03 },
       .keys = {
@@ -911,9 +912,8 @@ static const GuessTest guess_tests[] =
       .product_id = 0x6009,
       /* For some reason the special keys like mute and wlan toggle
        * show up here instead of, or in addition to, as part of
-       * the keyboard - so udev reports this as having keys too.
-       * SDL currently doesn't. */
-      .expected = SDL_UDEV_DEVICE_MOUSE,
+       * the keyboard - so both udev and SDL report this as having keys too. */
+      .expected = SDL_UDEV_DEVICE_MOUSE | SDL_UDEV_DEVICE_KEYBOARD,
       /* SYN, KEY, REL, MSC, LED */
       .ev = { 0x17, 0x00, 0x02 },
       /* X, Y */
diff --git a/Engine/lib/sdl/test/testgles2.c b/Engine/lib/sdl/test/testgles2.c
index 153ebe499..c42835ebb 100644
--- a/Engine/lib/sdl/test/testgles2.c
+++ b/Engine/lib/sdl/test/testgles2.c
@@ -38,6 +38,18 @@ typedef struct GLES2_Context
 #undef SDL_PROC
 } GLES2_Context;
 
+typedef struct shader_data
+{
+    GLuint shader_program, shader_frag, shader_vert;
+
+    GLint attr_position;
+    GLint attr_color, attr_mvp;
+
+    int angle_x, angle_y, angle_z;
+
+    GLuint position_buffer;
+    GLuint color_buffer;
+} shader_data;
 
 static SDLTest_CommonState *state;
 static SDL_GLContext *context = NULL;
@@ -197,13 +209,13 @@ multiply_matrix(float *lhs, float *rhs, float *r)
  * source: Passed-in shader source code.
  * shader_type: Passed to GL, e.g. GL_VERTEX_SHADER.
  */
-void 
+static void
 process_shader(GLuint *shader, const char * source, GLint shader_type)
 {
     GLint status = GL_FALSE;
     const char *shaders[1] = { NULL };
     char buffer[1024];
-    GLsizei length;
+    GLsizei length = 0;
 
     /* Create shader and load into GL. */
     *shader = GL_CHECK(ctx.glCreateShader(shader_type));
@@ -221,13 +233,35 @@ process_shader(GLuint *shader, const char * source, GLint shader_type)
 
     /* Dump debug info (source and log) if compilation failed. */
     if(status != GL_TRUE) {
-        ctx.glGetProgramInfoLog(*shader, sizeof(buffer), &length, &buffer[0]);
+        ctx.glGetShaderInfoLog(*shader, sizeof(buffer), &length, &buffer[0]);
         buffer[length] = '\0';
-        SDL_Log("Shader compilation failed: %s", buffer);fflush(stderr);
+        SDL_Log("Shader compilation failed: %s", buffer);
+        fflush(stderr);
         quit(-1);
     }
 }
 
+static void
+link_program(struct shader_data *data)
+{
+    GLint status = GL_FALSE;
+    char buffer[1024];
+    GLsizei length = 0;
+
+    GL_CHECK(ctx.glAttachShader(data->shader_program, data->shader_vert));
+    GL_CHECK(ctx.glAttachShader(data->shader_program, data->shader_frag));
+    GL_CHECK(ctx.glLinkProgram(data->shader_program));
+    GL_CHECK(ctx.glGetProgramiv(data->shader_program, GL_LINK_STATUS, &status));
+
+    if(status != GL_TRUE) {
+         ctx.glGetProgramInfoLog(data->shader_program, sizeof(buffer), &length, &buffer[0]);
+         buffer[length] = '\0';
+         SDL_Log("Program linking failed: %s", buffer);
+         fflush(stderr);
+         quit(-1);
+    }
+}
+
 /* 3D data. Vertex range -0.5..0.5 in all axes.
 * Z -0.5 is near, 0.5 is far. */
 const float _vertices[] =
@@ -363,19 +397,6 @@ const char* _shader_frag_src =
 "    gl_FragColor = vec4(vv3color, 1.0); "
 " } ";
 
-typedef struct shader_data
-{
-    GLuint shader_program, shader_frag, shader_vert;
-
-    GLint attr_position;
-    GLint attr_color, attr_mvp;
-
-    int angle_x, angle_y, angle_z;
-
-    GLuint position_buffer;
-    GLuint color_buffer;
-} shader_data;
-
 static void
 Render(unsigned int width, unsigned int height, shader_data* data)
 {
@@ -672,9 +693,7 @@ main(int argc, char *argv[])
         data->shader_program = GL_CHECK(ctx.glCreateProgram());
 
         /* Attach shaders and link shader_program */
-        GL_CHECK(ctx.glAttachShader(data->shader_program, data->shader_vert));
-        GL_CHECK(ctx.glAttachShader(data->shader_program, data->shader_frag));
-        GL_CHECK(ctx.glLinkProgram(data->shader_program));
+        link_program(data);
 
         /* Get attribute locations of non-fixed attributes like color and texture coordinates. */
         data->attr_position = GL_CHECK(ctx.glGetAttribLocation(data->shader_program, "av4position"));
@@ -693,13 +712,13 @@ main(int argc, char *argv[])
 
         GL_CHECK(ctx.glGenBuffers(1, &data->position_buffer));
         GL_CHECK(ctx.glBindBuffer(GL_ARRAY_BUFFER, data->position_buffer));
-        GL_CHECK(ctx.glBufferData(GL_ARRAY_BUFFER, sizeof(_vertices) * 4, _vertices, GL_STATIC_DRAW));
+        GL_CHECK(ctx.glBufferData(GL_ARRAY_BUFFER, sizeof(_vertices), _vertices, GL_STATIC_DRAW));
         GL_CHECK(ctx.glVertexAttribPointer(data->attr_position, 3, GL_FLOAT, GL_FALSE, 0, 0));
         GL_CHECK(ctx.glBindBuffer(GL_ARRAY_BUFFER, 0));
 
         GL_CHECK(ctx.glGenBuffers(1, &data->color_buffer));
         GL_CHECK(ctx.glBindBuffer(GL_ARRAY_BUFFER, data->color_buffer));
-        GL_CHECK(ctx.glBufferData(GL_ARRAY_BUFFER, sizeof(_colors) * 4, _colors, GL_STATIC_DRAW));
+        GL_CHECK(ctx.glBufferData(GL_ARRAY_BUFFER, sizeof(_colors), _colors, GL_STATIC_DRAW));
         GL_CHECK(ctx.glVertexAttribPointer(data->attr_color, 3, GL_FLOAT, GL_FALSE, 0, 0));
         GL_CHECK(ctx.glBindBuffer(GL_ARRAY_BUFFER, 0));
 
diff --git a/Engine/lib/sdl/test/testmouse.c b/Engine/lib/sdl/test/testmouse.c
index c73adca51..11a176066 100644
--- a/Engine/lib/sdl/test/testmouse.c
+++ b/Engine/lib/sdl/test/testmouse.c
@@ -39,6 +39,11 @@ static Line *active = NULL;
 static Line *lines = NULL;
 static int buttons = 0;
 
+static SDL_bool wheel_x_active = SDL_FALSE;
+static SDL_bool wheel_y_active = SDL_FALSE;
+static float wheel_x = SCREEN_WIDTH * 0.5f;
+static float wheel_y = SCREEN_HEIGHT * 0.5f;
+
 static SDL_bool done = SDL_FALSE;
 
 void
@@ -81,6 +86,25 @@ loop(void *arg)
     /* Check for events */
     while (SDL_PollEvent(&event)) {
         switch (event.type) {
+        case SDL_MOUSEWHEEL:
+                if (event.wheel.direction == SDL_MOUSEWHEEL_FLIPPED) {
+                        event.wheel.preciseX *= -1.0f;
+                        event.wheel.preciseY *= -1.0f;
+                        event.wheel.x *= -1;
+                        event.wheel.y *= -1;
+                }
+                if (event.wheel.preciseX != 0.0f) {
+                        wheel_x_active = SDL_TRUE;
+                        /* "positive to the right and negative to the left"  */
+                        wheel_x += event.wheel.preciseX * 10.0f;
+                }
+                if (event.wheel.preciseY != 0.0f) {
+                        wheel_y_active = SDL_TRUE;
+                        /* "positive away from the user and negative towards the user" */
+                        wheel_y -= event.wheel.preciseY * 10.0f;
+                }
+                break;
+
         case SDL_MOUSEMOTION:
             if (!active)
                 break;
@@ -134,6 +158,16 @@ loop(void *arg)
     SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
     SDL_RenderClear(renderer);
 
+    /* Mouse wheel */
+    SDL_SetRenderDrawColor(renderer, 0, 255, 128, 255);
+    if (wheel_x_active) {
+            SDL_RenderDrawLine(renderer, wheel_x, 0, wheel_x, SCREEN_HEIGHT);
+    }
+    if (wheel_y_active) {
+            SDL_RenderDrawLine(renderer, 0, wheel_y, SCREEN_WIDTH, wheel_y);
+    }
+
+    /* Lines from mouse clicks */
     DrawLines(renderer);
     if (active)
         DrawLine(renderer, active);
diff --git a/Engine/lib/sdl/test/testshader.c b/Engine/lib/sdl/test/testshader.c
index 2cee7d9b3..3c2da590f 100644
--- a/Engine/lib/sdl/test/testshader.c
+++ b/Engine/lib/sdl/test/testshader.c
@@ -126,21 +126,52 @@ static PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObjectARB;
 
 static SDL_bool CompileShader(GLhandleARB shader, const char *source)
 {
-    GLint status;
+    GLint status = 0;
 
     glShaderSourceARB(shader, 1, &source, NULL);
     glCompileShaderARB(shader);
     glGetObjectParameterivARB(shader, GL_OBJECT_COMPILE_STATUS_ARB, &status);
     if (status == 0) {
-        GLint length;
+        GLint length = 0;
         char *info;
 
         glGetObjectParameterivARB(shader, GL_OBJECT_INFO_LOG_LENGTH_ARB, &length);
-        info = SDL_stack_alloc(char, length+1);
-        glGetInfoLogARB(shader, length, NULL, info);
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to compile shader:\n%s\n%s", source, info);
-        SDL_stack_free(info);
+        info = (char *) SDL_malloc(length + 1);
+        if (!info) {
+            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Out of memory!");
+        } else {
+            glGetInfoLogARB(shader, length, NULL, info);
+            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to compile shader:\n%s\n%s", source, info);
+            SDL_free(info);
+        }
+        return SDL_FALSE;
+    } else {
+        return SDL_TRUE;
+    }
+}
 
+static SDL_bool LinkProgram(ShaderData *data)
+{
+    GLint status = 0;
+
+    glAttachObjectARB(data->program, data->vert_shader);
+    glAttachObjectARB(data->program, data->frag_shader);
+    glLinkProgramARB(data->program);
+
+    glGetObjectParameterivARB(data->program, GL_OBJECT_LINK_STATUS_ARB, &status);
+    if (status == 0) {
+        GLint length = 0;
+        char *info;
+
+        glGetObjectParameterivARB(data->program, GL_OBJECT_INFO_LOG_LENGTH_ARB, &length);
+        info = (char *) SDL_malloc(length + 1);
+        if (!info) {
+            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Out of memory!");
+        } else {
+            glGetInfoLogARB(data->program, length, NULL, info);
+            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to link program:\n%s", info);
+            SDL_free(info);
+        }
         return SDL_FALSE;
     } else {
         return SDL_TRUE;
@@ -171,9 +202,9 @@ static SDL_bool CompileShaderProgram(ShaderData *data)
     }
 
     /* ... and in the darkness bind them */
-    glAttachObjectARB(data->program, data->vert_shader);
-    glAttachObjectARB(data->program, data->frag_shader);
-    glLinkProgramARB(data->program);
+    if (!LinkProgram(data)) {
+        return SDL_FALSE;
+    }
 
     /* Set up some uniform variables */
     glUseProgramObjectARB(data->program);
diff --git a/Engine/lib/sdl/wayland-protocols/tablet-unstable-v2.xml b/Engine/lib/sdl/wayland-protocols/tablet-unstable-v2.xml
new file mode 100644
index 000000000..b286d964a
--- /dev/null
+++ b/Engine/lib/sdl/wayland-protocols/tablet-unstable-v2.xml
@@ -0,0 +1,1178 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="tablet_unstable_v2">
+
+  <copyright>
+    Copyright 2014 © Stephen "Lyude" Chandler Paul
+    Copyright 2015-2016 © Red Hat, Inc.
+
+    Permission is hereby granted, free of charge, to any person
+    obtaining a copy of this software and associated documentation files
+    (the "Software"), to deal in the Software without restriction,
+    including without limitation the rights to use, copy, modify, merge,
+    publish, distribute, sublicense, and/or sell copies of the Software,
+    and to permit persons to whom the Software is furnished to do so,
+    subject to the following conditions:
+
+    The above copyright notice and this permission notice (including the
+    next paragraph) shall be included in all copies or substantial
+    portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+    BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+    ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+    CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
+  </copyright>
+
+  <description summary="Wayland protocol for graphics tablets">
+    This description provides a high-level overview of the interplay between
+    the interfaces defined this protocol. For details, see the protocol
+    specification.
+
+    More than one tablet may exist, and device-specifics matter. Tablets are
+    not represented by a single virtual device like wl_pointer. A client
+    binds to the tablet manager object which is just a proxy object. From
+    that, the client requests wp_tablet_manager.get_tablet_seat(wl_seat)
+    and that returns the actual interface that has all the tablets. With
+    this indirection, we can avoid merging wp_tablet into the actual Wayland
+    protocol, a long-term benefit.
+
+    The wp_tablet_seat sends a "tablet added" event for each tablet
+    connected. That event is followed by descriptive events about the
+    hardware; currently that includes events for name, vid/pid and
+    a wp_tablet.path event that describes a local path. This path can be
+    used to uniquely identify a tablet or get more information through
+    libwacom. Emulated or nested tablets can skip any of those, e.g. a
+    virtual tablet may not have a vid/pid. The sequence of descriptive
+    events is terminated by a wp_tablet.done event to signal that a client
+    may now finalize any initialization for that tablet.
+
+    Events from tablets require a tool in proximity. Tools are also managed
+    by the tablet seat; a "tool added" event is sent whenever a tool is new
+    to the compositor. That event is followed by a number of descriptive
+    events about the hardware; currently that includes capabilities,
+    hardware id and serial number, and tool type. Similar to the tablet
+    interface, a wp_tablet_tool.done event is sent to terminate that initial
+    sequence.
+
+    Any event from a tool happens on the wp_tablet_tool interface. When the
+    tool gets into proximity of the tablet, a proximity_in event is sent on
+    the wp_tablet_tool interface, listing the tablet and the surface. That
+    event is followed by a motion event with the coordinates. After that,
+    it's the usual motion, axis, button, etc. events. The protocol's
+    serialisation means events are grouped by wp_tablet_tool.frame events.
+
+    Two special events (that don't exist in X) are down and up. They signal
+    "tip touching the surface". For tablets without real proximity
+    detection, the sequence is: proximity_in, motion, down, frame.
+
+    When the tool leaves proximity, a proximity_out event is sent. If any
+    button is still down, a button release event is sent before this
+    proximity event. These button events are sent in the same frame as the
+    proximity event to signal to the client that the buttons were held when
+    the tool left proximity.
+
+    If the tool moves out of the surface but stays in proximity (i.e.
+    between windows), compositor-specific grab policies apply. This usually
+    means that the proximity-out is delayed until all buttons are released.
+
+    Moving a tool physically from one tablet to the other has no real effect
+    on the protocol, since we already have the tool object from the "tool
+    added" event. All the information is already there and the proximity
+    events on both tablets are all a client needs to reconstruct what
+    happened.
+
+    Some extra axes are normalized, i.e. the client knows the range as
+    specified in the protocol (e.g. [0, 65535]), the granularity however is
+    unknown. The current normalized axes are pressure, distance, and slider.
+
+    Other extra axes are in physical units as specified in the protocol.
+    The current extra axes with physical units are tilt, rotation and
+    wheel rotation.
+
+    Since tablets work independently of the pointer controlled by the mouse,
+    the focus handling is independent too and controlled by proximity.
+    The wp_tablet_tool.set_cursor request sets a tool-specific cursor.
+    This cursor surface may be the same as the mouse cursor, and it may be
+    the same across tools but it is possible to be more fine-grained. For
+    example, a client may set different cursors for the pen and eraser.
+
+    Tools are generally independent of tablets and it is
+    compositor-specific policy when a tool can be removed. Common approaches
+    will likely include some form of removing a tool when all tablets the
+    tool was used on are removed.
+
+    Warning! The protocol described in this file is experimental and
+    backward incompatible changes may be made. Backward compatible changes
+    may be added together with the corresponding interface version bump.
+    Backward incompatible changes are done by bumping the version number in
+    the protocol and interface names and resetting the interface version.
+    Once the protocol is to be declared stable, the 'z' prefix and the
+    version number in the protocol and interface names are removed and the
+    interface version number is reset.
+  </description>
+
+  <interface name="zwp_tablet_manager_v2" version="1">
+    <description summary="controller object for graphic tablet devices">
+      An object that provides access to the graphics tablets available on this
+      system. All tablets are associated with a seat, to get access to the
+      actual tablets, use wp_tablet_manager.get_tablet_seat.
+    </description>
+
+    <request name="get_tablet_seat">
+      <description summary="get the tablet seat">
+	Get the wp_tablet_seat object for the given seat. This object
+	provides access to all graphics tablets in this seat.
+      </description>
+      <arg name="tablet_seat" type="new_id" interface="zwp_tablet_seat_v2"/>
+      <arg name="seat" type="object" interface="wl_seat" summary="The wl_seat object to retrieve the tablets for" />
+    </request>
+
+    <request name="destroy" type="destructor">
+      <description summary="release the memory for the tablet manager object">
+	Destroy the wp_tablet_manager object. Objects created from this
+	object are unaffected and should be destroyed separately.
+      </description>
+    </request>
+  </interface>
+
+  <interface name="zwp_tablet_seat_v2" version="1">
+    <description summary="controller object for graphic tablet devices of a seat">
+      An object that provides access to the graphics tablets available on this
+      seat. After binding to this interface, the compositor sends a set of
+      wp_tablet_seat.tablet_added and wp_tablet_seat.tool_added events.
+    </description>
+
+    <request name="destroy" type="destructor">
+      <description summary="release the memory for the tablet seat object">
+	Destroy the wp_tablet_seat object. Objects created from this
+	object are unaffected and should be destroyed separately.
+      </description>
+    </request>
+
+    <event name="tablet_added">
+      <description summary="new device notification">
+	This event is sent whenever a new tablet becomes available on this
+	seat. This event only provides the object id of the tablet, any
+	static information about the tablet (device name, vid/pid, etc.) is
+	sent through the wp_tablet interface.
+      </description>
+      <arg name="id" type="new_id" interface="zwp_tablet_v2" summary="the newly added graphics tablet"/>
+    </event>
+
+    <event name="tool_added">
+      <description summary="a new tool has been used with a tablet">
+	This event is sent whenever a tool that has not previously been used
+	with a tablet comes into use. This event only provides the object id
+	of the tool; any static information about the tool (capabilities,
+	type, etc.) is sent through the wp_tablet_tool interface.
+      </description>
+      <arg name="id" type="new_id" interface="zwp_tablet_tool_v2" summary="the newly added tablet tool"/>
+    </event>
+
+    <event name="pad_added">
+      <description summary="new pad notification">
+	This event is sent whenever a new pad is known to the system. Typically,
+	pads are physically attached to tablets and a pad_added event is
+	sent immediately after the wp_tablet_seat.tablet_added.
+	However, some standalone pad devices logically attach to tablets at
+	runtime, and the client must wait for wp_tablet_pad.enter to know
+	the tablet a pad is attached to.
+
+	This event only provides the object id of the pad. All further
+	features (buttons, strips, rings) are sent through the wp_tablet_pad
+	interface.
+      </description>
+      <arg name="id" type="new_id" interface="zwp_tablet_pad_v2" summary="the newly added pad"/>
+    </event>
+  </interface>
+
+  <interface name="zwp_tablet_tool_v2" version="1">
+    <description summary="a physical tablet tool">
+      An object that represents a physical tool that has been, or is
+      currently in use with a tablet in this seat. Each wp_tablet_tool
+      object stays valid until the client destroys it; the compositor
+      reuses the wp_tablet_tool object to indicate that the object's
+      respective physical tool has come into proximity of a tablet again.
+
+      A wp_tablet_tool object's relation to a physical tool depends on the
+      tablet's ability to report serial numbers. If the tablet supports
+      this capability, then the object represents a specific physical tool
+      and can be identified even when used on multiple tablets.
+
+      A tablet tool has a number of static characteristics, e.g. tool type,
+      hardware_serial and capabilities. These capabilities are sent in an
+      event sequence after the wp_tablet_seat.tool_added event before any
+      actual events from this tool. This initial event sequence is
+      terminated by a wp_tablet_tool.done event.
+
+      Tablet tool events are grouped by wp_tablet_tool.frame events.
+      Any events received before a wp_tablet_tool.frame event should be
+      considered part of the same hardware state change.
+    </description>
+
+    <request name="set_cursor">
+      <description summary="set the tablet tool's surface">
+	Sets the surface of the cursor used for this tool on the given
+	tablet. This request only takes effect if the tool is in proximity
+	of one of the requesting client's surfaces or the surface parameter
+	is the current pointer surface. If there was a previous surface set
+	with this request it is replaced. If surface is NULL, the cursor
+	image is hidden.
+
+	The parameters hotspot_x and hotspot_y define the position of the
+	pointer surface relative to the pointer location. Its top-left corner
+	is always at (x, y) - (hotspot_x, hotspot_y), where (x, y) are the
+	coordinates of the pointer location, in surface-local coordinates.
+
+	On surface.attach requests to the pointer surface, hotspot_x and
+	hotspot_y are decremented by the x and y parameters passed to the
+	request. Attach must be confirmed by wl_surface.commit as usual.
+
+	The hotspot can also be updated by passing the currently set pointer
+	surface to this request with new values for hotspot_x and hotspot_y.
+
+	The current and pending input regions of the wl_surface are cleared,
+	and wl_surface.set_input_region is ignored until the wl_surface is no
+	longer used as the cursor. When the use as a cursor ends, the current
+	and pending input regions become undefined, and the wl_surface is
+	unmapped.
+
+	This request gives the surface the role of a wp_tablet_tool cursor. A
+	surface may only ever be used as the cursor surface for one
+	wp_tablet_tool. If the surface already has another role or has
+	previously been used as cursor surface for a different tool, a
+	protocol error is raised.
+      </description>
+      <arg name="serial" type="uint" summary="serial of the enter event"/>
+      <arg name="surface" type="object" interface="wl_surface" allow-null="true"/>
+      <arg name="hotspot_x" type="int" summary="surface-local x coordinate"/>
+      <arg name="hotspot_y" type="int" summary="surface-local y coordinate"/>
+    </request>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the tool object">
+	This destroys the client's resource for this tool object.
+      </description>
+    </request>
+
+    <enum name="type">
+      <description summary="a physical tool type">
+	Describes the physical type of a tool. The physical type of a tool
+	generally defines its base usage.
+
+	The mouse tool represents a mouse-shaped tool that is not a relative
+	device but bound to the tablet's surface, providing absolute
+	coordinates.
+
+	The lens tool is a mouse-shaped tool with an attached lens to
+	provide precision focus.
+      </description>
+      <entry name="pen" value="0x140" summary="Pen"/>
+      <entry name="eraser" value="0x141" summary="Eraser"/>
+      <entry name="brush" value="0x142" summary="Brush"/>
+      <entry name="pencil" value="0x143" summary="Pencil"/>
+      <entry name="airbrush" value="0x144" summary="Airbrush"/>
+      <entry name="finger" value="0x145" summary="Finger"/>
+      <entry name="mouse" value="0x146" summary="Mouse"/>
+      <entry name="lens" value="0x147" summary="Lens"/>
+    </enum>
+
+    <event name="type">
+      <description summary="tool type">
+	The tool type is the high-level type of the tool and usually decides
+	the interaction expected from this tool.
+
+	This event is sent in the initial burst of events before the
+	wp_tablet_tool.done event.
+      </description>
+      <arg name="tool_type" type="uint" enum="type" summary="the physical tool type"/>
+    </event>
+
+    <event name="hardware_serial">
+      <description summary="unique hardware serial number of the tool">
+	If the physical tool can be identified by a unique 64-bit serial
+	number, this event notifies the client of this serial number.
+
+	If multiple tablets are available in the same seat and the tool is
+	uniquely identifiable by the serial number, that tool may move
+	between tablets.
+
+	Otherwise, if the tool has no serial number and this event is
+	missing, the tool is tied to the tablet it first comes into
+	proximity with. Even if the physical tool is used on multiple
+	tablets, separate wp_tablet_tool objects will be created, one per
+	tablet.
+
+	This event is sent in the initial burst of events before the
+	wp_tablet_tool.done event.
+      </description>
+      <arg name="hardware_serial_hi" type="uint" summary="the unique serial number of the tool, most significant bits"/>
+      <arg name="hardware_serial_lo" type="uint" summary="the unique serial number of the tool, least significant bits"/>
+    </event>
+
+    <event name="hardware_id_wacom">
+      <description summary="hardware id notification in Wacom's format">
+	This event notifies the client of a hardware id available on this tool.
+
+	The hardware id is a device-specific 64-bit id that provides extra
+	information about the tool in use, beyond the wl_tool.type
+	enumeration. The format of the id is specific to tablets made by
+	Wacom Inc. For example, the hardware id of a Wacom Grip
+	Pen (a stylus) is 0x802.
+
+	This event is sent in the initial burst of events before the
+	wp_tablet_tool.done event.
+      </description>
+      <arg name="hardware_id_hi" type="uint" summary="the hardware id, most significant bits"/>
+      <arg name="hardware_id_lo" type="uint" summary="the hardware id, least significant bits"/>
+    </event>
+
+    <enum name="capability">
+      <description summary="capability flags for a tool">
+	Describes extra capabilities on a tablet.
+
+	Any tool must provide x and y values, extra axes are
+	device-specific.
+      </description>
+      <entry name="tilt" value="1" summary="Tilt axes"/>
+      <entry name="pressure" value="2" summary="Pressure axis"/>
+      <entry name="distance" value="3" summary="Distance axis"/>
+      <entry name="rotation" value="4" summary="Z-rotation axis"/>
+      <entry name="slider" value="5" summary="Slider axis"/>
+      <entry name="wheel" value="6" summary="Wheel axis"/>
+    </enum>
+
+    <event name="capability">
+      <description summary="tool capability notification">
+	This event notifies the client of any capabilities of this tool,
+	beyond the main set of x/y axes and tip up/down detection.
+
+	One event is sent for each extra capability available on this tool.
+
+	This event is sent in the initial burst of events before the
+	wp_tablet_tool.done event.
+      </description>
+      <arg name="capability" type="uint" enum="capability" summary="the capability"/>
+    </event>
+
+    <event name="done">
+      <description summary="tool description events sequence complete">
+	This event signals the end of the initial burst of descriptive
+	events. A client may consider the static description of the tool to
+	be complete and finalize initialization of the tool.
+      </description>
+    </event>
+
+    <event name="removed">
+      <description summary="tool removed">
+	This event is sent when the tool is removed from the system and will
+	send no further events. Should the physical tool come back into
+	proximity later, a new wp_tablet_tool object will be created.
+
+	It is compositor-dependent when a tool is removed. A compositor may
+	remove a tool on proximity out, tablet removal or any other reason.
+	A compositor may also keep a tool alive until shutdown.
+
+	If the tool is currently in proximity, a proximity_out event will be
+	sent before the removed event. See wp_tablet_tool.proximity_out for
+	the handling of any buttons logically down.
+
+	When this event is received, the client must wp_tablet_tool.destroy
+	the object.
+      </description>
+    </event>
+
+    <event name="proximity_in">
+      <description summary="proximity in event">
+	Notification that this tool is focused on a certain surface.
+
+	This event can be received when the tool has moved from one surface to
+	another, or when the tool has come back into proximity above the
+	surface.
+
+	If any button is logically down when the tool comes into proximity,
+	the respective button event is sent after the proximity_in event but
+	within the same frame as the proximity_in event.
+      </description>
+      <arg name="serial" type="uint"/>
+      <arg name="tablet" type="object" interface="zwp_tablet_v2" summary="The tablet the tool is in proximity of"/>
+      <arg name="surface" type="object" interface="wl_surface" summary="The current surface the tablet tool is over"/>
+    </event>
+
+    <event name="proximity_out">
+      <description summary="proximity out event">
+	Notification that this tool has either left proximity, or is no
+	longer focused on a certain surface.
+
+	When the tablet tool leaves proximity of the tablet, button release
+	events are sent for each button that was held down at the time of
+	leaving proximity. These events are sent before the proximity_out
+	event but within the same wp_tablet.frame.
+
+	If the tool stays within proximity of the tablet, but the focus
+	changes from one surface to another, a button release event may not
+	be sent until the button is actually released or the tool leaves the
+	proximity of the tablet.
+      </description>
+    </event>
+
+    <event name="down">
+      <description summary="tablet tool is making contact">
+	Sent whenever the tablet tool comes in contact with the surface of the
+	tablet.
+
+	If the tool is already in contact with the tablet when entering the
+	input region, the client owning said region will receive a
+	wp_tablet.proximity_in event, followed by a wp_tablet.down
+	event and a wp_tablet.frame event.
+
+	Note that this event describes logical contact, not physical
+	contact. On some devices, a compositor may not consider a tool in
+	logical contact until a minimum physical pressure threshold is
+	exceeded.
+      </description>
+      <arg name="serial" type="uint"/>
+    </event>
+
+    <event name="up">
+      <description summary="tablet tool is no longer making contact">
+	Sent whenever the tablet tool stops making contact with the surface of
+	the tablet, or when the tablet tool moves out of the input region
+	and the compositor grab (if any) is dismissed.
+
+	If the tablet tool moves out of the input region while in contact
+	with the surface of the tablet and the compositor does not have an
+	ongoing grab on the surface, the client owning said region will
+	receive a wp_tablet.up event, followed by a wp_tablet.proximity_out
+	event and a wp_tablet.frame event. If the compositor has an ongoing
+	grab on this device, this event sequence is sent whenever the grab
+	is dismissed in the future.
+
+	Note that this event describes logical contact, not physical
+	contact. On some devices, a compositor may not consider a tool out
+	of logical contact until physical pressure falls below a specific
+	threshold.
+      </description>
+    </event>
+
+    <event name="motion">
+      <description summary="motion event">
+	Sent whenever a tablet tool moves.
+      </description>
+      <arg name="x" type="fixed" summary="surface-local x coordinate"/>
+      <arg name="y" type="fixed" summary="surface-local y coordinate"/>
+    </event>
+
+    <event name="pressure">
+      <description summary="pressure change event">
+	Sent whenever the pressure axis on a tool changes. The value of this
+	event is normalized to a value between 0 and 65535.
+
+	Note that pressure may be nonzero even when a tool is not in logical
+	contact. See the down and up events for more details.
+      </description>
+      <arg name="pressure" type="uint" summary="The current pressure value"/>
+    </event>
+
+    <event name="distance">
+      <description summary="distance change event">
+	Sent whenever the distance axis on a tool changes. The value of this
+	event is normalized to a value between 0 and 65535.
+
+	Note that distance may be nonzero even when a tool is not in logical
+	contact. See the down and up events for more details.
+      </description>
+      <arg name="distance" type="uint" summary="The current distance value"/>
+    </event>
+
+    <event name="tilt">
+      <description summary="tilt change event">
+	Sent whenever one or both of the tilt axes on a tool change. Each tilt
+	value is in degrees, relative to the z-axis of the tablet.
+	The angle is positive when the top of a tool tilts along the
+	positive x or y axis.
+      </description>
+      <arg name="tilt_x" type="fixed" summary="The current value of the X tilt axis"/>
+      <arg name="tilt_y" type="fixed" summary="The current value of the Y tilt axis"/>
+    </event>
+
+    <event name="rotation">
+      <description summary="z-rotation change event">
+	Sent whenever the z-rotation axis on the tool changes. The
+	rotation value is in degrees clockwise from the tool's
+	logical neutral position.
+      </description>
+      <arg name="degrees" type="fixed" summary="The current rotation of the Z axis"/>
+    </event>
+
+    <event name="slider">
+      <description summary="Slider position change event">
+	Sent whenever the slider position on the tool changes. The
+	value is normalized between -65535 and 65535, with 0 as the logical
+	neutral position of the slider.
+
+	The slider is available on e.g. the Wacom Airbrush tool.
+      </description>
+      <arg name="position" type="int" summary="The current position of slider"/>
+    </event>
+
+    <event name="wheel">
+      <description summary="Wheel delta event">
+	Sent whenever the wheel on the tool emits an event. This event
+	contains two values for the same axis change. The degrees value is
+	in the same orientation as the wl_pointer.vertical_scroll axis. The
+	clicks value is in discrete logical clicks of the mouse wheel. This
+	value may be zero if the movement of the wheel was less
+	than one logical click.
+
+	Clients should choose either value and avoid mixing degrees and
+	clicks. The compositor may accumulate values smaller than a logical
+	click and emulate click events when a certain threshold is met.
+	Thus, wl_tablet_tool.wheel events with non-zero clicks values may
+	have different degrees values.
+      </description>
+      <arg name="degrees" type="fixed" summary="The wheel delta in degrees"/>
+      <arg name="clicks" type="int" summary="The wheel delta in discrete clicks"/>
+    </event>
+
+    <enum name="button_state">
+      <description summary="physical button state">
+	Describes the physical state of a button that produced the button event.
+      </description>
+      <entry name="released" value="0" summary="button is not pressed"/>
+      <entry name="pressed" value="1" summary="button is pressed"/>
+    </enum>
+
+    <event name="button">
+      <description summary="button event">
+	Sent whenever a button on the tool is pressed or released.
+
+	If a button is held down when the tool moves in or out of proximity,
+	button events are generated by the compositor. See
+	wp_tablet_tool.proximity_in and wp_tablet_tool.proximity_out for
+	details.
+      </description>
+      <arg name="serial" type="uint"/>
+      <arg name="button" type="uint" summary="The button whose state has changed"/>
+      <arg name="state" type="uint" enum="button_state" summary="Whether the button was pressed or released"/>
+    </event>
+
+    <event name="frame">
+      <description summary="frame event">
+	Marks the end of a series of axis and/or button updates from the
+	tablet. The Wayland protocol requires axis updates to be sent
+	sequentially, however all events within a frame should be considered
+	one hardware event.
+      </description>
+      <arg name="time" type="uint" summary="The time of the event with millisecond granularity"/>
+    </event>
+
+    <enum name="error">
+      <entry name="role" value="0" summary="given wl_surface has another role"/>
+    </enum>
+  </interface>
+
+  <interface name="zwp_tablet_v2" version="1">
+    <description summary="graphics tablet device">
+      The wp_tablet interface represents one graphics tablet device. The
+      tablet interface itself does not generate events; all events are
+      generated by wp_tablet_tool objects when in proximity above a tablet.
+
+      A tablet has a number of static characteristics, e.g. device name and
+      pid/vid. These capabilities are sent in an event sequence after the
+      wp_tablet_seat.tablet_added event. This initial event sequence is
+      terminated by a wp_tablet.done event.
+    </description>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the tablet object">
+	This destroys the client's resource for this tablet object.
+      </description>
+    </request>
+
+    <event name="name">
+      <description summary="tablet device name">
+	This event is sent in the initial burst of events before the
+	wp_tablet.done event.
+      </description>
+      <arg name="name" type="string" summary="the device name"/>
+    </event>
+
+    <event name="id">
+      <description summary="tablet device USB vendor/product id">
+	This event is sent in the initial burst of events before the
+	wp_tablet.done event.
+      </description>
+      <arg name="vid" type="uint" summary="USB vendor id"/>
+      <arg name="pid" type="uint" summary="USB product id"/>
+    </event>
+
+    <event name="path">
+      <description summary="path to the device">
+	A system-specific device path that indicates which device is behind
+	this wp_tablet. This information may be used to gather additional
+	information about the device, e.g. through libwacom.
+
+	A device may have more than one device path. If so, multiple
+	wp_tablet.path events are sent. A device may be emulated and not
+	have a device path, and in that case this event will not be sent.
+
+	The format of the path is unspecified, it may be a device node, a
+	sysfs path, or some other identifier. It is up to the client to
+	identify the string provided.
+
+	This event is sent in the initial burst of events before the
+	wp_tablet.done event.
+      </description>
+      <arg name="path" type="string" summary="path to local device"/>
+    </event>
+
+    <event name="done">
+      <description summary="tablet description events sequence complete">
+	This event is sent immediately to signal the end of the initial
+	burst of descriptive events. A client may consider the static
+	description of the tablet to be complete and finalize initialization
+	of the tablet.
+      </description>
+    </event>
+
+    <event name="removed">
+      <description summary="tablet removed event">
+	Sent when the tablet has been removed from the system. When a tablet
+	is removed, some tools may be removed.
+
+	When this event is received, the client must wp_tablet.destroy
+	the object.
+      </description>
+    </event>
+  </interface>
+
+  <interface name="zwp_tablet_pad_ring_v2" version="1">
+    <description summary="pad ring">
+      A circular interaction area, such as the touch ring on the Wacom Intuos
+      Pro series tablets.
+
+      Events on a ring are logically grouped by the wl_tablet_pad_ring.frame
+      event.
+    </description>
+
+    <request name="set_feedback">
+      <description summary="set compositor feedback">
+	Request that the compositor use the provided feedback string
+	associated with this ring. This request should be issued immediately
+	after a wp_tablet_pad_group.mode_switch event from the corresponding
+	group is received, or whenever the ring is mapped to a different
+	action. See wp_tablet_pad_group.mode_switch for more details.
+
+	Clients are encouraged to provide context-aware descriptions for
+	the actions associated with the ring; compositors may use this
+	information to offer visual feedback about the button layout
+	(eg. on-screen displays).
+
+	The provided string 'description' is a UTF-8 encoded string to be
+	associated with this ring, and is considered user-visible; general
+	internationalization rules apply.
+
+	The serial argument will be that of the last
+	wp_tablet_pad_group.mode_switch event received for the group of this
+	ring. Requests providing other serials than the most recent one will be
+	ignored.
+      </description>
+      <arg name="description" type="string" summary="ring description"/>
+      <arg name="serial" type="uint" summary="serial of the mode switch event"/>
+    </request>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the ring object">
+	This destroys the client's resource for this ring object.
+      </description>
+    </request>
+
+    <enum name="source">
+      <description summary="ring axis source">
+	Describes the source types for ring events. This indicates to the
+	client how a ring event was physically generated; a client may
+	adjust the user interface accordingly. For example, events
+	from a "finger" source may trigger kinetic scrolling.
+      </description>
+      <entry name="finger" value="1" summary="finger"/>
+    </enum>
+
+    <event name="source">
+      <description summary="ring event source">
+	Source information for ring events.
+
+	This event does not occur on its own. It is sent before a
+	wp_tablet_pad_ring.frame event and carries the source information
+	for all events within that frame.
+
+	The source specifies how this event was generated. If the source is
+	wp_tablet_pad_ring.source.finger, a wp_tablet_pad_ring.stop event
+	will be sent when the user lifts the finger off the device.
+
+	This event is optional. If the source is unknown for an interaction,
+	no event is sent.
+      </description>
+      <arg name="source" type="uint" enum="source" summary="the event source"/>
+    </event>
+
+    <event name="angle">
+      <description summary="angle changed">
+	Sent whenever the angle on a ring changes.
+
+	The angle is provided in degrees clockwise from the logical
+	north of the ring in the pad's current rotation.
+      </description>
+      <arg name="degrees" type="fixed" summary="the current angle in degrees"/>
+    </event>
+
+    <event name="stop">
+      <description summary="interaction stopped">
+	Stop notification for ring events.
+
+	For some wp_tablet_pad_ring.source types, a wp_tablet_pad_ring.stop
+	event is sent to notify a client that the interaction with the ring
+	has terminated. This enables the client to implement kinetic scrolling.
+	See the wp_tablet_pad_ring.source documentation for information on
+	when this event may be generated.
+
+	Any wp_tablet_pad_ring.angle events with the same source after this
+	event should be considered as the start of a new interaction.
+      </description>
+    </event>
+
+    <event name="frame">
+      <description summary="end of a ring event sequence">
+	Indicates the end of a set of ring events that logically belong
+	together. A client is expected to accumulate the data in all events
+	within the frame before proceeding.
+
+	All wp_tablet_pad_ring events before a wp_tablet_pad_ring.frame event belong
+	logically together. For example, on termination of a finger interaction
+	on a ring the compositor will send a wp_tablet_pad_ring.source event,
+	a wp_tablet_pad_ring.stop event and a wp_tablet_pad_ring.frame event.
+
+	A wp_tablet_pad_ring.frame event is sent for every logical event
+	group, even if the group only contains a single wp_tablet_pad_ring
+	event. Specifically, a client may get a sequence: angle, frame,
+	angle, frame, etc.
+      </description>
+      <arg name="time" type="uint" summary="timestamp with millisecond granularity"/>
+    </event>
+  </interface>
+
+  <interface name="zwp_tablet_pad_strip_v2" version="1">
+    <description summary="pad strip">
+      A linear interaction area, such as the strips found in Wacom Cintiq
+      models.
+
+      Events on a strip are logically grouped by the wl_tablet_pad_strip.frame
+      event.
+    </description>
+
+    <request name="set_feedback">
+      <description summary="set compositor feedback">
+	Requests the compositor to use the provided feedback string
+	associated with this strip. This request should be issued immediately
+	after a wp_tablet_pad_group.mode_switch event from the corresponding
+	group is received, or whenever the strip is mapped to a different
+	action. See wp_tablet_pad_group.mode_switch for more details.
+
+	Clients are encouraged to provide context-aware descriptions for
+	the actions associated with the strip, and compositors may use this
+	information to offer visual feedback about the button layout
+	(eg. on-screen displays).
+
+	The provided string 'description' is a UTF-8 encoded string to be
+	associated with this ring, and is considered user-visible; general
+	internationalization rules apply.
+
+	The serial argument will be that of the last
+	wp_tablet_pad_group.mode_switch event received for the group of this
+	strip. Requests providing other serials than the most recent one will be
+	ignored.
+      </description>
+      <arg name="description" type="string" summary="strip description"/>
+      <arg name="serial" type="uint" summary="serial of the mode switch event"/>
+    </request>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the strip object">
+	This destroys the client's resource for this strip object.
+      </description>
+    </request>
+
+    <enum name="source">
+      <description summary="strip axis source">
+	Describes the source types for strip events. This indicates to the
+	client how a strip event was physically generated; a client may
+	adjust the user interface accordingly. For example, events
+	from a "finger" source may trigger kinetic scrolling.
+      </description>
+      <entry name="finger" value="1" summary="finger"/>
+    </enum>
+
+    <event name="source">
+      <description summary="strip event source">
+	Source information for strip events.
+
+	This event does not occur on its own. It is sent before a
+	wp_tablet_pad_strip.frame event and carries the source information
+	for all events within that frame.
+
+	The source specifies how this event was generated. If the source is
+	wp_tablet_pad_strip.source.finger, a wp_tablet_pad_strip.stop event
+	will be sent when the user lifts their finger off the device.
+
+	This event is optional. If the source is unknown for an interaction,
+	no event is sent.
+      </description>
+      <arg name="source" type="uint" enum="source" summary="the event source"/>
+    </event>
+
+    <event name="position">
+      <description summary="position changed">
+	Sent whenever the position on a strip changes.
+
+	The position is normalized to a range of [0, 65535], the 0-value
+	represents the top-most and/or left-most position of the strip in
+	the pad's current rotation.
+      </description>
+      <arg name="position" type="uint" summary="the current position"/>
+    </event>
+
+    <event name="stop">
+      <description summary="interaction stopped">
+	Stop notification for strip events.
+
+	For some wp_tablet_pad_strip.source types, a wp_tablet_pad_strip.stop
+	event is sent to notify a client that the interaction with the strip
+	has terminated. This enables the client to implement kinetic
+	scrolling. See the wp_tablet_pad_strip.source documentation for
+	information on when this event may be generated.
+
+	Any wp_tablet_pad_strip.position events with the same source after this
+	event should be considered as the start of a new interaction.
+      </description>
+    </event>
+
+    <event name="frame">
+      <description summary="end of a strip event sequence">
+	Indicates the end of a set of events that represent one logical
+	hardware strip event. A client is expected to accumulate the data
+	in all events within the frame before proceeding.
+
+	All wp_tablet_pad_strip events before a wp_tablet_pad_strip.frame event belong
+	logically together. For example, on termination of a finger interaction
+	on a strip the compositor will send a wp_tablet_pad_strip.source event,
+	a wp_tablet_pad_strip.stop event and a wp_tablet_pad_strip.frame
+	event.
+
+	A wp_tablet_pad_strip.frame event is sent for every logical event
+	group, even if the group only contains a single wp_tablet_pad_strip
+	event. Specifically, a client may get a sequence: position, frame,
+	position, frame, etc.
+      </description>
+      <arg name="time" type="uint" summary="timestamp with millisecond granularity"/>
+    </event>
+  </interface>
+
+  <interface name="zwp_tablet_pad_group_v2" version="1">
+    <description summary="a set of buttons, rings and strips">
+      A pad group describes a distinct (sub)set of buttons, rings and strips
+      present in the tablet. The criteria of this grouping is usually positional,
+      eg. if a tablet has buttons on the left and right side, 2 groups will be
+      presented. The physical arrangement of groups is undisclosed and may
+      change on the fly.
+
+      Pad groups will announce their features during pad initialization. Between
+      the corresponding wp_tablet_pad.group event and wp_tablet_pad_group.done, the
+      pad group will announce the buttons, rings and strips contained in it,
+      plus the number of supported modes.
+
+      Modes are a mechanism to allow multiple groups of actions for every element
+      in the pad group. The number of groups and available modes in each is
+      persistent across device plugs. The current mode is user-switchable, it
+      will be announced through the wp_tablet_pad_group.mode_switch event both
+      whenever it is switched, and after wp_tablet_pad.enter.
+
+      The current mode logically applies to all elements in the pad group,
+      although it is at clients' discretion whether to actually perform different
+      actions, and/or issue the respective .set_feedback requests to notify the
+      compositor. See the wp_tablet_pad_group.mode_switch event for more details.
+    </description>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the pad object">
+	Destroy the wp_tablet_pad_group object. Objects created from this object
+	are unaffected and should be destroyed separately.
+      </description>
+    </request>
+
+    <event name="buttons">
+      <description summary="buttons announced">
+	Sent on wp_tablet_pad_group initialization to announce the available
+	buttons in the group. Button indices start at 0, a button may only be
+	in one group at a time.
+
+	This event is first sent in the initial burst of events before the
+	wp_tablet_pad_group.done event.
+
+	Some buttons are reserved by the compositor. These buttons may not be
+	assigned to any wp_tablet_pad_group. Compositors may broadcast this
+	event in the case of changes to the mapping of these reserved buttons.
+	If the compositor happens to reserve all buttons in a group, this event
+	will be sent with an empty array.
+      </description>
+      <arg name="buttons" type="array" summary="buttons in this group"/>
+    </event>
+
+    <event name="ring">
+      <description summary="ring announced">
+	Sent on wp_tablet_pad_group initialization to announce available rings.
+	One event is sent for each ring available on this pad group.
+
+	This event is sent in the initial burst of events before the
+	wp_tablet_pad_group.done event.
+      </description>
+      <arg name="ring" type="new_id" interface="zwp_tablet_pad_ring_v2"/>
+    </event>
+
+    <event name="strip">
+      <description summary="strip announced">
+	Sent on wp_tablet_pad initialization to announce available strips.
+	One event is sent for each strip available on this pad group.
+
+	This event is sent in the initial burst of events before the
+	wp_tablet_pad_group.done event.
+      </description>
+      <arg name="strip" type="new_id" interface="zwp_tablet_pad_strip_v2"/>
+    </event>
+
+    <event name="modes">
+      <description summary="mode-switch ability announced">
+	Sent on wp_tablet_pad_group initialization to announce that the pad
+	group may switch between modes. A client may use a mode to store a
+	specific configuration for buttons, rings and strips and use the
+	wl_tablet_pad_group.mode_switch event to toggle between these
+	configurations. Mode indices start at 0.
+
+	Switching modes is compositor-dependent. See the
+	wp_tablet_pad_group.mode_switch event for more details.
+
+	This event is sent in the initial burst of events before the
+	wp_tablet_pad_group.done event. This event is only sent when more than
+	more than one mode is available.
+      </description>
+      <arg name="modes" type="uint" summary="the number of modes"/>
+    </event>
+
+    <event name="done">
+      <description summary="tablet group description events sequence complete">
+	This event is sent immediately to signal the end of the initial
+	burst of descriptive events. A client may consider the static
+	description of the tablet to be complete and finalize initialization
+	of the tablet group.
+      </description>
+    </event>
+
+    <event name="mode_switch">
+      <description summary="mode switch event">
+	Notification that the mode was switched.
+
+	A mode applies to all buttons, rings and strips in a group
+	simultaneously, but a client is not required to assign different actions
+	for each mode. For example, a client may have mode-specific button
+	mappings but map the ring to vertical scrolling in all modes. Mode
+	indices start at 0.
+
+	Switching modes is compositor-dependent. The compositor may provide
+	visual cues to the client about the mode, e.g. by toggling LEDs on
+	the tablet device. Mode-switching may be software-controlled or
+	controlled by one or more physical buttons. For example, on a Wacom
+	Intuos Pro, the button inside the ring may be assigned to switch
+	between modes.
+
+	The compositor will also send this event after wp_tablet_pad.enter on
+	each group in order to notify of the current mode. Groups that only
+	feature one mode will use mode=0 when emitting this event.
+
+	If a button action in the new mode differs from the action in the
+	previous mode, the client should immediately issue a
+	wp_tablet_pad.set_feedback request for each changed button.
+
+	If a ring or strip action in the new mode differs from the action
+	in the previous mode, the client should immediately issue a
+	wp_tablet_ring.set_feedback or wp_tablet_strip.set_feedback request
+	for each changed ring or strip.
+      </description>
+      <arg name="time" type="uint" summary="the time of the event with millisecond granularity"/>
+      <arg name="serial" type="uint"/>
+      <arg name="mode" type="uint" summary="the new mode of the pad"/>
+    </event>
+  </interface>
+
+  <interface name="zwp_tablet_pad_v2" version="1">
+    <description summary="a set of buttons, rings and strips">
+      A pad device is a set of buttons, rings and strips
+      usually physically present on the tablet device itself. Some
+      exceptions exist where the pad device is physically detached, e.g. the
+      Wacom ExpressKey Remote.
+
+      Pad devices have no axes that control the cursor and are generally
+      auxiliary devices to the tool devices used on the tablet surface.
+
+      A pad device has a number of static characteristics, e.g. the number
+      of rings. These capabilities are sent in an event sequence after the
+      wp_tablet_seat.pad_added event before any actual events from this pad.
+      This initial event sequence is terminated by a wp_tablet_pad.done
+      event.
+
+      All pad features (buttons, rings and strips) are logically divided into
+      groups and all pads have at least one group. The available groups are
+      notified through the wp_tablet_pad.group event; the compositor will
+      emit one event per group before emitting wp_tablet_pad.done.
+
+      Groups may have multiple modes. Modes allow clients to map multiple
+      actions to a single pad feature. Only one mode can be active per group,
+      although different groups may have different active modes.
+    </description>
+
+    <request name="set_feedback">
+      <description summary="set compositor feedback">
+	Requests the compositor to use the provided feedback string
+	associated with this button. This request should be issued immediately
+	after a wp_tablet_pad_group.mode_switch event from the corresponding
+	group is received, or whenever a button is mapped to a different
+	action. See wp_tablet_pad_group.mode_switch for more details.
+
+	Clients are encouraged to provide context-aware descriptions for
+	the actions associated with each button, and compositors may use
+	this information to offer visual feedback on the button layout
+	(e.g. on-screen displays).
+
+	Button indices start at 0. Setting the feedback string on a button
+	that is reserved by the compositor (i.e. not belonging to any
+	wp_tablet_pad_group) does not generate an error but the compositor
+	is free to ignore the request.
+
+	The provided string 'description' is a UTF-8 encoded string to be
+	associated with this ring, and is considered user-visible; general
+	internationalization rules apply.
+
+	The serial argument will be that of the last
+	wp_tablet_pad_group.mode_switch event received for the group of this
+	button. Requests providing other serials than the most recent one will
+	be ignored.
+      </description>
+      <arg name="button" type="uint" summary="button index"/>
+      <arg name="description" type="string" summary="button description"/>
+      <arg name="serial" type="uint" summary="serial of the mode switch event"/>
+    </request>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the pad object">
+	Destroy the wp_tablet_pad object. Objects created from this object
+	are unaffected and should be destroyed separately.
+      </description>
+    </request>
+
+    <event name="group">
+      <description summary="group announced">
+	Sent on wp_tablet_pad initialization to announce available groups.
+	One event is sent for each pad group available.
+
+	This event is sent in the initial burst of events before the
+	wp_tablet_pad.done event. At least one group will be announced.
+      </description>
+      <arg name="pad_group" type="new_id" interface="zwp_tablet_pad_group_v2"/>
+    </event>
+
+    <event name="path">
+      <description summary="path to the device">
+	A system-specific device path that indicates which device is behind
+	this wp_tablet_pad. This information may be used to gather additional
+	information about the device, e.g. through libwacom.
+
+	The format of the path is unspecified, it may be a device node, a
+	sysfs path, or some other identifier. It is up to the client to
+	identify the string provided.
+
+	This event is sent in the initial burst of events before the
+	wp_tablet_pad.done event.
+      </description>
+      <arg name="path" type="string" summary="path to local device"/>
+    </event>
+
+    <event name="buttons">
+      <description summary="buttons announced">
+	Sent on wp_tablet_pad initialization to announce the available
+	buttons.
+
+	This event is sent in the initial burst of events before the
+	wp_tablet_pad.done event. This event is only sent when at least one
+	button is available.
+      </description>
+      <arg name="buttons" type="uint" summary="the number of buttons"/>
+    </event>
+
+    <event name="done">
+      <description summary="pad description event sequence complete">
+	This event signals the end of the initial burst of descriptive
+	events. A client may consider the static description of the pad to
+	be complete and finalize initialization of the pad.
+      </description>
+    </event>
+
+    <enum name="button_state">
+      <description summary="physical button state">
+	Describes the physical state of a button that caused the button
+	event.
+      </description>
+      <entry name="released" value="0" summary="the button is not pressed"/>
+      <entry name="pressed" value="1" summary="the button is pressed"/>
+    </enum>
+
+    <event name="button">
+      <description summary="physical button state">
+	Sent whenever the physical state of a button changes.
+      </description>
+      <arg name="time" type="uint" summary="the time of the event with millisecond granularity"/>
+      <arg name="button" type="uint" summary="the index of the button that changed state"/>
+      <arg name="state" type="uint" enum="button_state"/>
+    </event>
+
+    <event name="enter">
+      <description summary="enter event">
+	Notification that this pad is focused on the specified surface.
+      </description>
+      <arg name="serial" type="uint" summary="serial number of the enter event"/>
+      <arg name="tablet" type="object" interface="zwp_tablet_v2" summary="the tablet the pad is attached to"/>
+      <arg name="surface" type="object" interface="wl_surface" summary="surface the pad is focused on"/>
+    </event>
+
+    <event name="leave">
+      <description summary="enter event">
+	Notification that this pad is no longer focused on the specified
+	surface.
+      </description>
+      <arg name="serial" type="uint" summary="serial number of the leave event"/>
+      <arg name="surface" type="object" interface="wl_surface" summary="surface the pad is no longer focused on"/>
+    </event>
+
+    <event name="removed">
+      <description summary="pad removed event">
+	Sent when the pad has been removed from the system. When a tablet
+	is removed its pad(s) will be removed too.
+
+	When this event is received, the client must destroy all rings, strips
+	and groups that were offered by this pad, and issue wp_tablet_pad.destroy
+	the pad itself.
+      </description>
+    </event>
+  </interface>
+</protocol>
diff --git a/Engine/lib/sdl/wayland-protocols/viewporter.xml b/Engine/lib/sdl/wayland-protocols/viewporter.xml
new file mode 100644
index 000000000..c732d8c35
--- /dev/null
+++ b/Engine/lib/sdl/wayland-protocols/viewporter.xml
@@ -0,0 +1,186 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="viewporter">
+
+  <copyright>
+    Copyright © 2013-2016 Collabora, Ltd.
+
+    Permission is hereby granted, free of charge, to any person obtaining a
+    copy of this software and associated documentation files (the "Software"),
+    to deal in the Software without restriction, including without limitation
+    the rights to use, copy, modify, merge, publish, distribute, sublicense,
+    and/or sell copies of the Software, and to permit persons to whom the
+    Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice (including the next
+    paragraph) shall be included in all copies or substantial portions of the
+    Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+    DEALINGS IN THE SOFTWARE.
+  </copyright>
+
+  <interface name="wp_viewporter" version="1">
+    <description summary="surface cropping and scaling">
+      The global interface exposing surface cropping and scaling
+      capabilities is used to instantiate an interface extension for a
+      wl_surface object. This extended interface will then allow
+      cropping and scaling the surface contents, effectively
+      disconnecting the direct relationship between the buffer and the
+      surface size.
+    </description>
+
+    <request name="destroy" type="destructor">
+      <description summary="unbind from the cropping and scaling interface">
+	Informs the server that the client will not be using this
+	protocol object anymore. This does not affect any other objects,
+	wp_viewport objects included.
+      </description>
+    </request>
+
+    <enum name="error">
+      <entry name="viewport_exists" value="0"
+             summary="the surface already has a viewport object associated"/>
+    </enum>
+
+    <request name="get_viewport">
+      <description summary="extend surface interface for crop and scale">
+	Instantiate an interface extension for the given wl_surface to
+	crop and scale its content. If the given wl_surface already has
+	a wp_viewport object associated, the viewport_exists
+	protocol error is raised.
+      </description>
+      <arg name="id" type="new_id" interface="wp_viewport"
+           summary="the new viewport interface id"/>
+      <arg name="surface" type="object" interface="wl_surface"
+           summary="the surface"/>
+    </request>
+  </interface>
+
+  <interface name="wp_viewport" version="1">
+    <description summary="crop and scale interface to a wl_surface">
+      An additional interface to a wl_surface object, which allows the
+      client to specify the cropping and scaling of the surface
+      contents.
+
+      This interface works with two concepts: the source rectangle (src_x,
+      src_y, src_width, src_height), and the destination size (dst_width,
+      dst_height). The contents of the source rectangle are scaled to the
+      destination size, and content outside the source rectangle is ignored.
+      This state is double-buffered, and is applied on the next
+      wl_surface.commit.
+
+      The two parts of crop and scale state are independent: the source
+      rectangle, and the destination size. Initially both are unset, that
+      is, no scaling is applied. The whole of the current wl_buffer is
+      used as the source, and the surface size is as defined in
+      wl_surface.attach.
+
+      If the destination size is set, it causes the surface size to become
+      dst_width, dst_height. The source (rectangle) is scaled to exactly
+      this size. This overrides whatever the attached wl_buffer size is,
+      unless the wl_buffer is NULL. If the wl_buffer is NULL, the surface
+      has no content and therefore no size. Otherwise, the size is always
+      at least 1x1 in surface local coordinates.
+
+      If the source rectangle is set, it defines what area of the wl_buffer is
+      taken as the source. If the source rectangle is set and the destination
+      size is not set, then src_width and src_height must be integers, and the
+      surface size becomes the source rectangle size. This results in cropping
+      without scaling. If src_width or src_height are not integers and
+      destination size is not set, the bad_size protocol error is raised when
+      the surface state is applied.
+
+      The coordinate transformations from buffer pixel coordinates up to
+      the surface-local coordinates happen in the following order:
+        1. buffer_transform (wl_surface.set_buffer_transform)
+        2. buffer_scale (wl_surface.set_buffer_scale)
+        3. crop and scale (wp_viewport.set*)
+      This means, that the source rectangle coordinates of crop and scale
+      are given in the coordinates after the buffer transform and scale,
+      i.e. in the coordinates that would be the surface-local coordinates
+      if the crop and scale was not applied.
+
+      If src_x or src_y are negative, the bad_value protocol error is raised.
+      Otherwise, if the source rectangle is partially or completely outside of
+      the non-NULL wl_buffer, then the out_of_buffer protocol error is raised
+      when the surface state is applied. A NULL wl_buffer does not raise the
+      out_of_buffer error.
+
+      The x, y arguments of wl_surface.attach are applied as normal to
+      the surface. They indicate how many pixels to remove from the
+      surface size from the left and the top. In other words, they are
+      still in the surface-local coordinate system, just like dst_width
+      and dst_height are.
+
+      If the wl_surface associated with the wp_viewport is destroyed,
+      all wp_viewport requests except 'destroy' raise the protocol error
+      no_surface.
+
+      If the wp_viewport object is destroyed, the crop and scale
+      state is removed from the wl_surface. The change will be applied
+      on the next wl_surface.commit.
+    </description>
+
+    <request name="destroy" type="destructor">
+      <description summary="remove scaling and cropping from the surface">
+	The associated wl_surface's crop and scale state is removed.
+	The change is applied on the next wl_surface.commit.
+      </description>
+    </request>
+
+    <enum name="error">
+      <entry name="bad_value" value="0"
+	     summary="negative or zero values in width or height"/>
+      <entry name="bad_size" value="1"
+	     summary="destination size is not integer"/>
+      <entry name="out_of_buffer" value="2"
+	     summary="source rectangle extends outside of the content area"/>
+      <entry name="no_surface" value="3"
+	     summary="the wl_surface was destroyed"/>
+    </enum>
+
+    <request name="set_source">
+      <description summary="set the source rectangle for cropping">
+	Set the source rectangle of the associated wl_surface. See
+	wp_viewport for the description, and relation to the wl_buffer
+	size.
+
+	If all of x, y, width and height are -1.0, the source rectangle is
+	unset instead. Any other set of values where width or height are zero
+	or negative, or x or y are negative, raise the bad_value protocol
+	error.
+
+	The crop and scale state is double-buffered state, and will be
+	applied on the next wl_surface.commit.
+      </description>
+      <arg name="x" type="fixed" summary="source rectangle x"/>
+      <arg name="y" type="fixed" summary="source rectangle y"/>
+      <arg name="width" type="fixed" summary="source rectangle width"/>
+      <arg name="height" type="fixed" summary="source rectangle height"/>
+    </request>
+
+    <request name="set_destination">
+      <description summary="set the surface size for scaling">
+	Set the destination size of the associated wl_surface. See
+	wp_viewport for the description, and relation to the wl_buffer
+	size.
+
+	If width is -1 and height is -1, the destination size is unset
+	instead. Any other pair of values for width and height that
+	contains zero or negative values raises the bad_value protocol
+	error.
+
+	The crop and scale state is double-buffered state, and will be
+	applied on the next wl_surface.commit.
+      </description>
+      <arg name="width" type="int" summary="surface width"/>
+      <arg name="height" type="int" summary="surface height"/>
+    </request>
+  </interface>
+
+</protocol>
diff --git a/Engine/lib/sdl/wayland-protocols/xdg-output-unstable-v1.xml b/Engine/lib/sdl/wayland-protocols/xdg-output-unstable-v1.xml
new file mode 100644
index 000000000..9a5b79000
--- /dev/null
+++ b/Engine/lib/sdl/wayland-protocols/xdg-output-unstable-v1.xml
@@ -0,0 +1,220 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="xdg_output_unstable_v1">
+
+  <copyright>
+    Copyright © 2017 Red Hat Inc.
+
+    Permission is hereby granted, free of charge, to any person obtaining a
+    copy of this software and associated documentation files (the "Software"),
+    to deal in the Software without restriction, including without limitation
+    the rights to use, copy, modify, merge, publish, distribute, sublicense,
+    and/or sell copies of the Software, and to permit persons to whom the
+    Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice (including the next
+    paragraph) shall be included in all copies or substantial portions of the
+    Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+    DEALINGS IN THE SOFTWARE.
+  </copyright>
+
+  <description summary="Protocol to describe output regions">
+    This protocol aims at describing outputs in a way which is more in line
+    with the concept of an output on desktop oriented systems.
+
+    Some information are more specific to the concept of an output for
+    a desktop oriented system and may not make sense in other applications,
+    such as IVI systems for example.
+
+    Typically, the global compositor space on a desktop system is made of
+    a contiguous or overlapping set of rectangular regions.
+
+    Some of the information provided in this protocol might be identical
+    to their counterparts already available from wl_output, in which case
+    the information provided by this protocol should be preferred to their
+    equivalent in wl_output. The goal is to move the desktop specific
+    concepts (such as output location within the global compositor space,
+    the connector name and types, etc.) out of the core wl_output protocol.
+
+    Warning! The protocol described in this file is experimental and
+    backward incompatible changes may be made. Backward compatible
+    changes may be added together with the corresponding interface
+    version bump.
+    Backward incompatible changes are done by bumping the version
+    number in the protocol and interface names and resetting the
+    interface version. Once the protocol is to be declared stable,
+    the 'z' prefix and the version number in the protocol and
+    interface names are removed and the interface version number is
+    reset.
+  </description>
+
+  <interface name="zxdg_output_manager_v1" version="3">
+    <description summary="manage xdg_output objects">
+      A global factory interface for xdg_output objects.
+    </description>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the xdg_output_manager object">
+	Using this request a client can tell the server that it is not
+	going to use the xdg_output_manager object anymore.
+
+	Any objects already created through this instance are not affected.
+      </description>
+    </request>
+
+    <request name="get_xdg_output">
+      <description summary="create an xdg output from a wl_output">
+	This creates a new xdg_output object for the given wl_output.
+      </description>
+      <arg name="id" type="new_id" interface="zxdg_output_v1"/>
+      <arg name="output" type="object" interface="wl_output"/>
+    </request>
+  </interface>
+
+  <interface name="zxdg_output_v1" version="3">
+    <description summary="compositor logical output region">
+      An xdg_output describes part of the compositor geometry.
+
+      This typically corresponds to a monitor that displays part of the
+      compositor space.
+
+      For objects version 3 onwards, after all xdg_output properties have been
+      sent (when the object is created and when properties are updated), a
+      wl_output.done event is sent. This allows changes to the output
+      properties to be seen as atomic, even if they happen via multiple events.
+    </description>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the xdg_output object">
+	Using this request a client can tell the server that it is not
+	going to use the xdg_output object anymore.
+      </description>
+    </request>
+
+    <event name="logical_position">
+      <description summary="position of the output within the global compositor space">
+	The position event describes the location of the wl_output within
+	the global compositor space.
+
+	The logical_position event is sent after creating an xdg_output
+	(see xdg_output_manager.get_xdg_output) and whenever the location
+	of the output changes within the global compositor space.
+      </description>
+      <arg name="x" type="int"
+	   summary="x position within the global compositor space"/>
+      <arg name="y" type="int"
+	   summary="y position within the global compositor space"/>
+    </event>
+
+    <event name="logical_size">
+      <description summary="size of the output in the global compositor space">
+	The logical_size event describes the size of the output in the
+	global compositor space.
+
+	For example, a surface without any buffer scale, transformation
+	nor rotation set, with the size matching the logical_size will
+	have the same size as the corresponding output when displayed.
+
+	Most regular Wayland clients should not pay attention to the
+	logical size and would rather rely on xdg_shell interfaces.
+
+	Some clients such as Xwayland, however, need this to configure
+	their surfaces in the global compositor space as the compositor
+	may apply a different scale from what is advertised by the output
+	scaling property (to achieve fractional scaling, for example).
+
+	For example, for a wl_output mode 3840×2160 and a scale factor 2:
+
+	- A compositor not scaling the surface buffers will advertise a
+	  logical size of 3840×2160,
+
+	- A compositor automatically scaling the surface buffers will
+	  advertise a logical size of 1920×1080,
+
+	- A compositor using a fractional scale of 1.5 will advertise a
+	  logical size of 2560×1440.
+
+	For example, for a wl_output mode 1920×1080 and a 90 degree rotation,
+	the compositor will advertise a logical size of 1080x1920.
+
+	The logical_size event is sent after creating an xdg_output
+	(see xdg_output_manager.get_xdg_output) and whenever the logical
+	size of the output changes, either as a result of a change in the
+	applied scale or because of a change in the corresponding output
+	mode(see wl_output.mode) or transform (see wl_output.transform).
+      </description>
+      <arg name="width" type="int"
+	   summary="width in global compositor space"/>
+      <arg name="height" type="int"
+	   summary="height in global compositor space"/>
+    </event>
+
+    <event name="done">
+      <description summary="all information about the output have been sent">
+	This event is sent after all other properties of an xdg_output
+	have been sent.
+
+	This allows changes to the xdg_output properties to be seen as
+	atomic, even if they happen via multiple events.
+
+	For objects version 3 onwards, this event is deprecated. Compositors
+	are not required to send it anymore and must send wl_output.done
+	instead.
+      </description>
+    </event>
+
+    <!-- Version 2 additions -->
+
+    <event name="name" since="2">
+      <description summary="name of this output">
+	Many compositors will assign names to their outputs, show them to the
+	user, allow them to be configured by name, etc. The client may wish to
+	know this name as well to offer the user similar behaviors.
+
+	The naming convention is compositor defined, but limited to
+	alphanumeric characters and dashes (-). Each name is unique among all
+	wl_output globals, but if a wl_output global is destroyed the same name
+	may be reused later. The names will also remain consistent across
+	sessions with the same hardware and software configuration.
+
+	Examples of names include 'HDMI-A-1', 'WL-1', 'X11-1', etc. However, do
+	not assume that the name is a reflection of an underlying DRM
+	connector, X11 connection, etc.
+
+	The name event is sent after creating an xdg_output (see
+	xdg_output_manager.get_xdg_output). This event is only sent once per
+	xdg_output, and the name does not change over the lifetime of the
+	wl_output global.
+      </description>
+      <arg name="name" type="string" summary="output name"/>
+    </event>
+
+    <event name="description" since="2">
+      <description summary="human-readable description of this output">
+	Many compositors can produce human-readable descriptions of their
+	outputs.  The client may wish to know this description as well, to
+	communicate the user for various purposes.
+
+	The description is a UTF-8 string with no convention defined for its
+	contents. Examples might include 'Foocorp 11" Display' or 'Virtual X11
+	output via :1'.
+
+	The description event is sent after creating an xdg_output (see
+	xdg_output_manager.get_xdg_output) and whenever the description
+	changes. The description is optional, and may not be sent at all.
+
+	For objects of version 2 and lower, this event is only sent once per
+	xdg_output, and the description does not change over the lifetime of
+	the wl_output global.
+      </description>
+      <arg name="description" type="string" summary="output description"/>
+    </event>
+
+  </interface>
+</protocol>

From bea7d6f4a1023194064e445aac49475ea8f7a7b8 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Tue, 26 Apr 2022 11:06:15 -0500
Subject: [PATCH 378/399] Adds a conditional to the github workflow file so it
 only runs on the main repo

---
 .github/workflows/cmake.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/cmake.yml b/.github/workflows/cmake.yml
index f25be008a..d6d2a3f54 100644
--- a/.github/workflows/cmake.yml
+++ b/.github/workflows/cmake.yml
@@ -12,6 +12,7 @@ env:
 
 jobs:
   build:
+    if: github.repository == 'TorqueGameEngines/Torque3D'
     # The CMake configure and build commands are platform agnostic and should work equally well on Windows or Mac.
     # You can convert this to a matrix build if you need cross-platform coverage.
     # See: https://docs.github.com/en/free-pro-team@latest/actions/learn-github-actions/managing-complex-workflows#using-a-build-matrix

From f29747609281939acf42fc31ae3809b9012a298f Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Tue, 26 Apr 2022 11:56:24 -0500
Subject: [PATCH 379/399] update assimp to 5.2.3 Bugfix-Release

---
 Engine/lib/assimp/CHANGES                     |   607 +
 Engine/lib/assimp/CREDITS                     |   183 +
 Engine/lib/assimp/LICENSE                     |    78 +
 Engine/lib/assimp/Readme.md                   |   120 +
 Engine/lib/assimp/code/3DS/3DSHelper.h        |   652 -
 Engine/lib/assimp/code/3MF/3MFXmlTags.h       |   104 -
 Engine/lib/assimp/code/3MF/D3MFImporter.cpp   |   483 -
 Engine/lib/assimp/code/3MF/D3MFOpcPackage.cpp |   207 -
 Engine/lib/assimp/code/AMF/AMFImporter.cpp    |   705 -
 Engine/lib/assimp/code/AMF/AMFImporter.hpp    |   432 -
 .../assimp/code/AMF/AMFImporter_Geometry.cpp  |   357 -
 .../lib/assimp/code/AMF/AMFImporter_Macro.hpp |   166 -
 .../lib/assimp/code/AMF/AMFImporter_Node.hpp  |   340 -
 .../code/AMF/AMFImporter_Postprocess.cpp      |   978 --
 .../lib/assimp/code/Assbin/AssbinExporter.cpp |   846 -
 .../code/{ => AssetLib}/3DS/3DSConverter.cpp  |   560 +-
 .../code/{ => AssetLib}/3DS/3DSExporter.cpp   |   312 +-
 .../code/{ => AssetLib}/3DS/3DSExporter.h     |     4 +-
 .../lib/assimp/code/AssetLib/3DS/3DSHelper.h  |   702 +
 .../code/{ => AssetLib}/3DS/3DSLoader.cpp     |   820 +-
 .../code/{ => AssetLib}/3DS/3DSLoader.h       |    27 +-
 .../lib/assimp/code/AssetLib/3MF/3MFTypes.h   |   165 +
 .../lib/assimp/code/AssetLib/3MF/3MFXmlTags.h |   117 +
 .../code/{ => AssetLib}/3MF/D3MFExporter.cpp  |   291 +-
 .../code/{ => AssetLib}/3MF/D3MFExporter.h    |    23 +-
 .../assimp/code/AssetLib/3MF/D3MFImporter.cpp |   130 +
 .../assimp/code/AssetLib/3MF/D3MFImporter.h   |    91 +
 .../code/AssetLib/3MF/D3MFOpcPackage.cpp      |   256 +
 .../code/{ => AssetLib}/3MF/D3MFOpcPackage.h  |    27 +-
 .../code/AssetLib/3MF/XmlSerializer.cpp       |   593 +
 .../assimp/code/AssetLib/3MF/XmlSerializer.h  |    96 +
 .../code/{ => AssetLib}/AC/ACLoader.cpp       |   765 +-
 .../assimp/code/{ => AssetLib}/AC/ACLoader.h  |   134 +-
 .../assimp/code/AssetLib/AMF/AMFImporter.cpp  |   524 +
 .../assimp/code/AssetLib/AMF/AMFImporter.hpp  |   310 +
 .../AssetLib/AMF/AMFImporter_Geometry.cpp     |   284 +
 .../AMF/AMFImporter_Material.cpp              |   312 +-
 .../code/AssetLib/AMF/AMFImporter_Node.hpp    |   305 +
 .../AssetLib/AMF/AMFImporter_Postprocess.cpp  |   894 ++
 .../code/{ => AssetLib}/ASE/ASELoader.cpp     |   774 +-
 .../code/{ => AssetLib}/ASE/ASELoader.h       |    27 +-
 .../code/{ => AssetLib}/ASE/ASEParser.cpp     |  1416 +-
 .../code/{ => AssetLib}/ASE/ASEParser.h       |   235 +-
 .../code/AssetLib/Assbin/AssbinExporter.cpp   |    68 +
 .../{ => AssetLib}/Assbin/AssbinExporter.h    |     8 +-
 .../code/AssetLib/Assbin/AssbinFileWriter.cpp |   833 +
 .../Assbin/AssbinFileWriter.h}                |    38 +-
 .../{ => AssetLib}/Assbin/AssbinLoader.cpp    |   459 +-
 .../code/{ => AssetLib}/Assbin/AssbinLoader.h |    19 +-
 .../code/{ => AssetLib}/Assjson/cencode.c     |    28 +-
 .../code/{ => AssetLib}/Assjson/cencode.h     |     4 +
 .../{ => AssetLib}/Assjson/json_exporter.cpp  |   221 +-
 .../{ => AssetLib}/Assjson/mesh_splitter.cpp  |    21 +-
 .../{ => AssetLib}/Assjson/mesh_splitter.h    |    37 +-
 .../code/AssetLib/Assxml/AssxmlExporter.cpp   |    68 +
 .../{ => AssetLib}/Assxml/AssxmlExporter.h    |     3 +-
 .../code/AssetLib/Assxml/AssxmlFileWriter.cpp |   662 +
 .../code/AssetLib/Assxml/AssxmlFileWriter.h   |    64 +
 .../assimp/code/AssetLib/B3D/B3DImporter.cpp  |   744 +
 .../code/{ => AssetLib}/B3D/B3DImporter.h     |    28 +-
 .../assimp/code/AssetLib/BVH/BVHLoader.cpp    |   528 +
 .../code/{ => AssetLib}/BVH/BVHLoader.h       |    56 +-
 .../{ => AssetLib}/Blender/BlenderBMesh.cpp   |   146 +-
 .../{ => AssetLib}/Blender/BlenderBMesh.h     |     2 +-
 .../AssetLib/Blender/BlenderCustomData.cpp    |   181 +
 .../Blender/BlenderCustomData.h               |     0
 .../{ => AssetLib}/Blender/BlenderDNA.cpp     |   174 +-
 .../code/{ => AssetLib}/Blender/BlenderDNA.h  |   394 +-
 .../{ => AssetLib}/Blender/BlenderDNA.inl     |    67 +-
 .../Blender/BlenderIntermediate.h             |     2 +-
 .../{ => AssetLib}/Blender/BlenderLoader.cpp  |   931 +-
 .../code/AssetLib/Blender/BlenderLoader.h     |   198 +
 .../Blender/BlenderModifier.cpp               |   178 +-
 .../{ => AssetLib}/Blender/BlenderModifier.h  |    22 +-
 .../code/AssetLib/Blender/BlenderScene.cpp    |   891 ++
 .../{ => AssetLib}/Blender/BlenderScene.h     |   550 +-
 .../{ => AssetLib}/Blender/BlenderSceneGen.h  |     8 +-
 .../Blender/BlenderTessellator.cpp            |    10 +-
 .../Blender/BlenderTessellator.h              |     2 +-
 .../code/{ => AssetLib}/C4D/C4DImporter.cpp   |    69 +-
 .../code/{ => AssetLib}/C4D/C4DImporter.h     |    39 +-
 .../code/{ => AssetLib}/COB/COBLoader.cpp     |   886 +-
 .../lib/assimp/code/AssetLib/COB/COBLoader.h  |   152 +
 .../assimp/code/{ => AssetLib}/COB/COBScene.h |    15 +-
 .../code/{ => AssetLib}/CSM/CSMLoader.cpp     |    23 +-
 .../code/{ => AssetLib}/CSM/CSMLoader.h       |    30 +-
 .../code/AssetLib/Collada/ColladaExporter.cpp |  1748 +++
 .../code/AssetLib/Collada/ColladaExporter.h   |   257 +
 .../code/AssetLib/Collada/ColladaHelper.cpp   |    99 +
 .../code/AssetLib/Collada/ColladaHelper.h     |   679 +
 .../{ => AssetLib}/Collada/ColladaLoader.cpp  |  1089 +-
 .../{ => AssetLib}/Collada/ColladaLoader.h    |   150 +-
 .../code/AssetLib/Collada/ColladaParser.cpp   |  2402 +++
 .../code/AssetLib/Collada/ColladaParser.h     |   348 +
 .../code/{ => AssetLib}/DXF/DXFHelper.h       |     4 +-
 .../code/{ => AssetLib}/DXF/DXFLoader.cpp     |    54 +-
 .../code/{ => AssetLib}/DXF/DXFLoader.h       |    19 +-
 .../code/{ => AssetLib}/FBX/FBXAnimation.cpp  |   171 +-
 .../{ => AssetLib}/FBX/FBXBinaryTokenizer.cpp |    31 +-
 .../code/{ => AssetLib}/FBX/FBXCommon.h       |    61 +-
 .../{ => AssetLib}/FBX/FBXCompileConfig.h     |    18 +-
 .../assimp/code/AssetLib/FBX/FBXConverter.cpp |  3679 +++++
 .../code/{ => AssetLib}/FBX/FBXConverter.h    |   120 +-
 .../code/{ => AssetLib}/FBX/FBXDeformer.cpp   |     2 +-
 .../code/{ => AssetLib}/FBX/FBXDocument.cpp   |   171 +-
 .../code/{ => AssetLib}/FBX/FBXDocument.h     |    74 +-
 .../{ => AssetLib}/FBX/FBXDocumentUtil.cpp    |    16 +-
 .../code/{ => AssetLib}/FBX/FBXDocumentUtil.h |     2 +-
 .../code/{ => AssetLib}/FBX/FBXExportNode.cpp |    78 +-
 .../code/{ => AssetLib}/FBX/FBXExportNode.h   |     9 +-
 .../{ => AssetLib}/FBX/FBXExportProperty.cpp  |     2 +-
 .../{ => AssetLib}/FBX/FBXExportProperty.h    |     2 +-
 .../code/{ => AssetLib}/FBX/FBXExporter.cpp   |   395 +-
 .../code/{ => AssetLib}/FBX/FBXExporter.h     |    23 +-
 .../{ => AssetLib}/FBX/FBXImportSettings.h    |    44 +-
 .../assimp/code/AssetLib/FBX/FBXImporter.cpp  |   200 +
 .../code/{ => AssetLib}/FBX/FBXImporter.h     |    50 +-
 .../code/{ => AssetLib}/FBX/FBXMaterial.cpp   |   168 +-
 .../{ => AssetLib}/FBX/FBXMeshGeometry.cpp    |    83 +-
 .../code/{ => AssetLib}/FBX/FBXMeshGeometry.h |    16 +-
 .../code/{ => AssetLib}/FBX/FBXModel.cpp      |    82 +-
 .../{ => AssetLib}/FBX/FBXNodeAttribute.cpp   |     2 +-
 .../code/{ => AssetLib}/FBX/FBXParser.cpp     |   151 +-
 .../code/{ => AssetLib}/FBX/FBXParser.h       |    10 +-
 .../code/{ => AssetLib}/FBX/FBXProperties.cpp |    71 +-
 .../code/{ => AssetLib}/FBX/FBXProperties.h   |    10 +-
 .../code/{ => AssetLib}/FBX/FBXTokenizer.cpp  |    12 +-
 .../code/{ => AssetLib}/FBX/FBXTokenizer.h    |     3 +-
 .../code/{ => AssetLib}/FBX/FBXUtil.cpp       |    22 +-
 .../assimp/code/{ => AssetLib}/FBX/FBXUtil.h  |    23 +-
 .../code/{ => AssetLib}/HMP/HMPFileData.h     |     2 +-
 .../code/{ => AssetLib}/HMP/HMPLoader.cpp     |   412 +-
 .../code/{ => AssetLib}/HMP/HMPLoader.h       |    57 +-
 .../{ => AssetLib}/HMP/HalfLifeFileData.h     |     2 +-
 .../{Importer => AssetLib}/IFC/IFCBoolean.cpp |   426 +-
 .../{Importer => AssetLib}/IFC/IFCCurve.cpp   |    32 +-
 .../IFC/IFCGeometry.cpp                       |   112 +-
 .../{Importer => AssetLib}/IFC/IFCLoader.cpp  |   613 +-
 .../{Importer => AssetLib}/IFC/IFCLoader.h    |    94 +-
 .../IFC/IFCMaterial.cpp                       |    12 +-
 .../IFC/IFCOpenings.cpp                       |   403 +-
 .../{Importer => AssetLib}/IFC/IFCProfile.cpp |    10 +-
 .../IFC/IFCReaderGen1_2x3.cpp                 |   897 +-
 .../IFC/IFCReaderGen2_2x3.cpp                 |   173 +-
 .../IFC/IFCReaderGen_2x3.h                    |    13 +-
 .../IFC/IFCReaderGen_4.cpp                    |   394 +-
 .../IFC/IFCReaderGen_4.h                      |    28 +-
 .../{Importer => AssetLib}/IFC/IFCUtil.cpp    |    42 +-
 .../code/{Importer => AssetLib}/IFC/IFCUtil.h |    26 +-
 .../assimp/code/AssetLib/IQM/IQMImporter.cpp  |   322 +
 .../assimp/code/AssetLib/IQM/IQMImporter.h    |    78 +
 Engine/lib/assimp/code/AssetLib/IQM/iqm.h     |   134 +
 .../assimp/code/AssetLib/Irr/IRRLoader.cpp    |  1359 ++
 .../code/{ => AssetLib}/Irr/IRRLoader.h       |    48 +-
 .../code/AssetLib/Irr/IRRMeshLoader.cpp       |   502 +
 .../code/{ => AssetLib}/Irr/IRRMeshLoader.h   |    27 +-
 .../assimp/code/AssetLib/Irr/IRRShared.cpp    |   387 +
 .../code/{ => AssetLib}/Irr/IRRShared.h       |    91 +-
 .../code/{ => AssetLib}/LWO/LWOAnimation.cpp  |   441 +-
 .../code/{ => AssetLib}/LWO/LWOAnimation.h    |     8 +-
 .../code/{ => AssetLib}/LWO/LWOBLoader.cpp    |     6 +-
 .../assimp/code/AssetLib/LWO/LWOFileData.h    |   715 +
 .../assimp/code/AssetLib/LWO/LWOLoader.cpp    |  1618 ++
 .../code/{ => AssetLib}/LWO/LWOLoader.h       |   248 +-
 .../assimp/code/AssetLib/LWO/LWOMaterial.cpp  |  1155 ++
 .../code/{ => AssetLib}/LWS/LWSLoader.cpp     |   534 +-
 .../code/{ => AssetLib}/LWS/LWSLoader.h       |   136 +-
 .../assimp/code/AssetLib/M3D/M3DExporter.cpp  |   442 +
 .../M3D/M3DExporter.h}                        |    86 +-
 .../assimp/code/AssetLib/M3D/M3DImporter.cpp  |   789 +
 .../assimp/code/AssetLib/M3D/M3DImporter.h    |   105 +
 .../assimp/code/AssetLib/M3D/M3DMaterials.h   |   106 +
 .../assimp/code/AssetLib/M3D/M3DWrapper.cpp   |   152 +
 .../lib/assimp/code/AssetLib/M3D/M3DWrapper.h |   134 +
 Engine/lib/assimp/code/AssetLib/M3D/m3d.h     |  4902 ++++++
 .../code/{ => AssetLib}/MD2/MD2FileData.h     |     2 +-
 .../code/{ => AssetLib}/MD2/MD2Loader.cpp     |    72 +-
 .../code/{ => AssetLib}/MD2/MD2Loader.h       |    40 +-
 .../code/{ => AssetLib}/MD2/MD2NormalTable.h  |     4 +-
 .../code/{ => AssetLib}/MD3/MD3FileData.h     |     4 +-
 .../code/{ => AssetLib}/MD3/MD3Loader.cpp     |   572 +-
 .../code/{ => AssetLib}/MD3/MD3Loader.h       |   113 +-
 .../code/{ => AssetLib}/MD4/MD4FileData.h     |     2 +-
 .../code/{ => AssetLib}/MD5/MD5Loader.cpp     |   513 +-
 .../code/{ => AssetLib}/MD5/MD5Loader.h       |    74 +-
 .../code/{ => AssetLib}/MD5/MD5Parser.cpp     |   345 +-
 .../code/{ => AssetLib}/MD5/MD5Parser.h       |     2 +-
 .../code/{ => AssetLib}/MDC/MDCFileData.h     |     6 +-
 .../code/{ => AssetLib}/MDC/MDCLoader.cpp     |   373 +-
 .../code/{ => AssetLib}/MDC/MDCLoader.h       |    36 +-
 .../code/{ => AssetLib}/MDC/MDCNormalTable.h  |     2 +-
 .../code/AssetLib/MDL/HalfLife/HL1FileData.h  |   600 +
 .../MDL/HalfLife/HL1ImportDefinitions.h       |    64 +
 .../AssetLib/MDL/HalfLife/HL1ImportSettings.h |    85 +
 .../AssetLib/MDL/HalfLife/HL1MDLLoader.cpp    |  1353 ++
 .../code/AssetLib/MDL/HalfLife/HL1MDLLoader.h |   243 +
 .../AssetLib/MDL/HalfLife/HL1MeshTrivert.h    |   127 +
 .../MDL/HalfLife/HalfLifeMDLBaseHeader.h}     |    38 +-
 .../code/AssetLib/MDL/HalfLife/LogFunctions.h |    95 +
 .../MDL/HalfLife/UniqueNameGenerator.cpp      |   180 +
 .../MDL/HalfLife/UniqueNameGenerator.h        |    81 +
 .../{ => AssetLib}/MDL/MDLDefaultColorMap.h   |     2 +-
 .../code/{ => AssetLib}/MDL/MDLFileData.h     |     8 +-
 .../code/{ => AssetLib}/MDL/MDLLoader.cpp     |  1392 +-
 .../code/{ => AssetLib}/MDL/MDLLoader.h       |    34 +-
 .../{ => AssetLib}/MDL/MDLMaterialLoader.cpp  |   559 +-
 .../assimp/code/{ => AssetLib}/MMD/MMDCpp14.h |     2 +-
 .../assimp/code/AssetLib/MMD/MMDImporter.cpp  |   368 +
 .../code/{ => AssetLib}/MMD/MMDImporter.h     |    12 +-
 .../code/{ => AssetLib}/MMD/MMDPmdParser.h    |     8 +-
 .../code/{ => AssetLib}/MMD/MMDPmxParser.cpp  |    23 +-
 .../code/{ => AssetLib}/MMD/MMDPmxParser.h    |     2 +-
 .../code/{ => AssetLib}/MMD/MMDVmdParser.h    |    10 +-
 .../code/{ => AssetLib}/MS3D/MS3DLoader.cpp   |    91 +-
 .../code/{ => AssetLib}/MS3D/MS3DLoader.h     |    66 +-
 .../code/{ => AssetLib}/NDO/NDOLoader.cpp     |    29 +-
 .../code/{ => AssetLib}/NDO/NDOLoader.h       |    52 +-
 .../code/{ => AssetLib}/NFF/NFFLoader.cpp     |   976 +-
 .../code/{ => AssetLib}/NFF/NFFLoader.h       |   130 +-
 .../code/{ => AssetLib}/OFF/OFFLoader.cpp     |    33 +-
 .../code/{ => AssetLib}/OFF/OFFLoader.h       |    28 +-
 .../Ogre/OgreBinarySerializer.cpp             |   556 +-
 .../code/AssetLib/Ogre/OgreBinarySerializer.h |   415 +
 .../code/{ => AssetLib}/Ogre/OgreImporter.cpp |    79 +-
 .../code/{ => AssetLib}/Ogre/OgreImporter.h   |    44 +-
 .../code/{ => AssetLib}/Ogre/OgreMaterial.cpp |   364 +-
 .../{ => AssetLib}/Ogre/OgreParsingUtils.h    |    67 +-
 .../code/{ => AssetLib}/Ogre/OgreStructs.cpp  |   834 +-
 .../code/{ => AssetLib}/Ogre/OgreStructs.h    |     4 +-
 .../code/AssetLib/Ogre/OgreXmlSerializer.cpp  |   755 +
 .../{ => AssetLib}/Ogre/OgreXmlSerializer.h   |    82 +-
 .../OpenGEX/OpenGEXExporter.cpp               |     2 +-
 .../{ => AssetLib}/OpenGEX/OpenGEXExporter.h  |     4 +-
 .../code/AssetLib/OpenGEX/OpenGEXImporter.cpp |  1326 ++
 .../{ => AssetLib}/OpenGEX/OpenGEXImporter.h  |    33 +-
 .../{ => AssetLib}/OpenGEX/OpenGEXStructs.h   |     2 +-
 .../code/{ => AssetLib}/Ply/PlyExporter.cpp   |    11 +-
 .../code/{ => AssetLib}/Ply/PlyExporter.h     |     2 +-
 .../code/{ => AssetLib}/Ply/PlyLoader.cpp     |   657 +-
 .../code/{ => AssetLib}/Ply/PlyLoader.h       |    51 +-
 .../assimp/code/AssetLib/Ply/PlyParser.cpp    |   963 ++
 .../code/{ => AssetLib}/Ply/PlyParser.h       |     5 +-
 .../code/{ => AssetLib}/Q3BSP/Q3BSPFileData.h |     6 +-
 .../code/AssetLib/Q3BSP/Q3BSPFileImporter.cpp |   680 +
 .../{ => AssetLib}/Q3BSP/Q3BSPFileImporter.h  |    17 +-
 .../{ => AssetLib}/Q3BSP/Q3BSPFileParser.cpp  |     4 +-
 .../{ => AssetLib}/Q3BSP/Q3BSPFileParser.h    |     7 +-
 .../assimp/code/AssetLib/Q3D/Q3DLoader.cpp    |   575 +
 .../code/{ => AssetLib}/Q3D/Q3DLoader.h       |    50 +-
 .../code/{ => AssetLib}/Raw/RawLoader.cpp     |   247 +-
 .../code/{ => AssetLib}/Raw/RawLoader.h       |    35 +-
 .../code/{ => AssetLib}/SIB/SIBImporter.cpp   |   443 +-
 .../code/{ => AssetLib}/SIB/SIBImporter.h     |    33 +-
 .../code/{ => AssetLib}/SMD/SMDLoader.cpp     |    53 +-
 .../code/{ => AssetLib}/SMD/SMDLoader.h       |    59 +-
 .../STEPParser/STEPFileEncoding.cpp           |     4 +-
 .../STEPParser/STEPFileEncoding.h             |     2 +-
 .../STEPParser/STEPFileReader.cpp             |    48 +-
 .../STEPParser/STEPFileReader.h               |     4 +-
 .../code/{ => AssetLib}/STL/STLExporter.cpp   |    16 +-
 .../code/{ => AssetLib}/STL/STLExporter.h     |    21 +-
 .../code/{ => AssetLib}/STL/STLLoader.cpp     |   381 +-
 .../code/{ => AssetLib}/STL/STLLoader.h       |    18 +-
 .../lib/assimp/code/AssetLib/Step/STEPFile.h  |   971 ++
 .../code/{ => AssetLib}/Step/StepExporter.cpp |   138 +-
 .../code/{ => AssetLib}/Step/StepExporter.h   |     2 +-
 .../Terragen/TerragenLoader.cpp               |   169 +-
 .../{ => AssetLib}/Terragen/TerragenLoader.h  |    51 +-
 .../{ => AssetLib}/Unreal/UnrealLoader.cpp    |   364 +-
 .../code/{ => AssetLib}/Unreal/UnrealLoader.h |   135 +-
 .../code/{ => AssetLib}/X/XFileExporter.cpp   |    12 +-
 .../code/{ => AssetLib}/X/XFileExporter.h     |     8 +-
 .../code/{ => AssetLib}/X/XFileHelper.h       |   119 +-
 .../code/{ => AssetLib}/X/XFileImporter.cpp   |    73 +-
 .../code/{ => AssetLib}/X/XFileImporter.h     |    15 +-
 .../code/{ => AssetLib}/X/XFileParser.cpp     |  1248 +-
 .../code/{ => AssetLib}/X/XFileParser.h       |     7 +-
 .../assimp/code/AssetLib/X3D/X3DExporter.cpp  |   675 +
 .../assimp/code/AssetLib/X3D/X3DExporter.hpp  |   250 +
 .../assimp/code/AssetLib/X3D/X3DGeoHelper.cpp |   531 +
 .../assimp/code/AssetLib/X3D/X3DGeoHelper.h   |    39 +
 .../assimp/code/AssetLib/X3D/X3DImporter.cpp  |   488 +
 .../assimp/code/AssetLib/X3D/X3DImporter.hpp  |   383 +
 .../AssetLib/X3D/X3DImporter_Geometry2D.cpp   |   467 +
 .../AssetLib/X3D/X3DImporter_Geometry3D.cpp   |   918 ++
 .../{ => AssetLib}/X3D/X3DImporter_Group.cpp  |   289 +-
 .../code/AssetLib/X3D/X3DImporter_Light.cpp   |   270 +
 .../code/AssetLib/X3D/X3DImporter_Macro.hpp   |   121 +
 .../AssetLib/X3D/X3DImporter_Metadata.cpp     |   255 +
 .../X3D/X3DImporter_Networking.cpp            |   100 +-
 .../code/AssetLib/X3D/X3DImporter_Node.hpp    |   463 +
 .../AssetLib/X3D/X3DImporter_Postprocess.cpp  |   731 +
 .../AssetLib/X3D/X3DImporter_Rendering.cpp    |   993 ++
 .../code/AssetLib/X3D/X3DImporter_Shape.cpp   |   241 +
 .../AssetLib/X3D/X3DImporter_Texturing.cpp    |   179 +
 .../assimp/code/AssetLib/X3D/X3DXmlHelper.cpp |   294 +
 .../assimp/code/AssetLib/X3D/X3DXmlHelper.h   |    30 +
 .../assimp/code/AssetLib/XGL/XGLLoader.cpp    |   787 +
 .../code/{ => AssetLib}/XGL/XGLLoader.h       |   139 +-
 .../lib/assimp/code/AssetLib/glTF/glTFAsset.h |  1017 ++
 .../assimp/code/AssetLib/glTF/glTFAsset.inl   |  1316 ++
 .../{ => AssetLib}/glTF/glTFAssetWriter.h     |     4 +-
 .../{ => AssetLib}/glTF/glTFAssetWriter.inl   |    67 +-
 .../code/{ => AssetLib}/glTF/glTFCommon.cpp   |   106 +-
 .../assimp/code/AssetLib/glTF/glTFCommon.h    |   520 +
 .../code/{ => AssetLib}/glTF/glTFExporter.cpp |   185 +-
 .../assimp/code/AssetLib/glTF/glTFExporter.h  |   118 +
 .../code/{ => AssetLib}/glTF/glTFImporter.cpp |   453 +-
 .../code/{ => AssetLib}/glTF/glTFImporter.h   |    41 +-
 .../assimp/code/AssetLib/glTF2/glTF2Asset.h   |  1242 ++
 .../assimp/code/AssetLib/glTF2/glTF2Asset.inl |  2069 +++
 .../{ => AssetLib}/glTF2/glTF2AssetWriter.h   |     9 +-
 .../{ => AssetLib}/glTF2/glTF2AssetWriter.inl |   312 +-
 .../code/AssetLib/glTF2/glTF2Exporter.cpp     |  1542 ++
 .../code/AssetLib/glTF2/glTF2Exporter.h       |   147 +
 .../code/AssetLib/glTF2/glTF2Importer.cpp     |  1638 ++
 .../code/{ => AssetLib}/glTF2/glTF2Importer.h |    45 +-
 .../lib/assimp/code/Assxml/AssxmlExporter.cpp |   655 -
 Engine/lib/assimp/code/B3D/B3DImporter.cpp    |   740 -
 Engine/lib/assimp/code/BVH/BVHLoader.cpp      |   578 -
 .../assimp/code/Blender/BlenderCustomData.cpp |   189 -
 .../lib/assimp/code/Blender/BlenderLoader.h   |   240 -
 .../lib/assimp/code/Blender/BlenderScene.cpp  |   875 --
 Engine/lib/assimp/code/CApi/AssimpCExport.cpp |    72 +-
 .../assimp/code/CApi/CInterfaceIOWrapper.cpp  |    53 +-
 .../assimp/code/CApi/CInterfaceIOWrapper.h    |    47 +-
 Engine/lib/assimp/code/CMakeLists.txt         |  1045 +-
 Engine/lib/assimp/code/COB/COBLoader.h        |   156 -
 .../assimp/code/Collada/ColladaExporter.cpp   |  1675 --
 .../lib/assimp/code/Collada/ColladaExporter.h |   222 -
 .../lib/assimp/code/Collada/ColladaHelper.h   |   701 -
 .../lib/assimp/code/Collada/ColladaParser.cpp |  3409 ----
 .../lib/assimp/code/Collada/ColladaParser.h   |   393 -
 .../lib/assimp/code/Common/AssertHandler.cpp  |    72 +
 Engine/lib/assimp/code/Common/AssertHandler.h |    75 +
 Engine/lib/assimp/code/Common/Assimp.cpp      |  1092 +-
 Engine/lib/assimp/code/Common/Base64.cpp      |   179 +
 .../lib/assimp/code/Common/BaseImporter.cpp   |   397 +-
 Engine/lib/assimp/code/Common/BaseProcess.cpp |    41 +-
 Engine/lib/assimp/code/Common/BaseProcess.h   |   137 +-
 Engine/lib/assimp/code/Common/Bitmap.cpp      |   195 +-
 Engine/lib/assimp/code/Common/Compression.cpp |   214 +
 Engine/lib/assimp/code/Common/Compression.h   |   121 +
 .../lib/assimp/code/Common/CreateAnimMesh.cpp |    40 +-
 .../assimp/code/Common/DefaultIOStream.cpp    |   100 +-
 .../assimp/code/Common/DefaultIOSystem.cpp    |    89 +-
 .../lib/assimp/code/Common/DefaultLogger.cpp  |   256 +-
 .../code/Common/DefaultProgressHandler.h      |    19 +-
 .../Macros.h => code/Common/Exceptional.cpp}  |    19 +-
 Engine/lib/assimp/code/Common/Exporter.cpp    |   210 +-
 Engine/lib/assimp/code/Common/FileLogStream.h |    43 +-
 .../lib/assimp/code/Common/FileSystemFilter.h |    15 +-
 Engine/lib/assimp/code/Common/IFF.h           |    29 +
 Engine/lib/assimp/code/Common/IOSystem.cpp    |    53 +
 Engine/lib/assimp/code/Common/Importer.cpp    |   477 +-
 Engine/lib/assimp/code/Common/Importer.h      |    71 +-
 .../assimp/code/Common/ImporterRegistry.cpp   |   264 +-
 Engine/lib/assimp/code/Common/PolyTools.h     |    41 +-
 .../assimp/code/Common/PostStepRegistry.cpp   |    11 +-
 .../lib/assimp/code/Common/RemoveComments.cpp |    60 +-
 .../lib/assimp/code/Common/SGSpatialSort.cpp  |     6 +-
 .../lib/assimp/code/Common/SceneCombiner.cpp  |  1024 +-
 .../assimp/code/Common/ScenePreprocessor.cpp  |   176 +-
 .../assimp/code/Common/ScenePreprocessor.h    |    35 +-
 Engine/lib/assimp/code/Common/ScenePrivate.h  |     2 +-
 .../code/Common/SkeletonMeshBuilder.cpp       |   210 +-
 Engine/lib/assimp/code/Common/SpatialSort.cpp |   266 +-
 .../lib/assimp/code/Common/StandardShapes.cpp |   434 +-
 .../assimp/code/Common/StdOStreamLogStream.h  |     2 +-
 Engine/lib/assimp/code/Common/Subdivision.cpp |   666 +-
 .../assimp/code/Common/TargetAnimation.cpp    |   152 +-
 .../lib/assimp/code/Common/TargetAnimation.h  |    84 +-
 Engine/lib/assimp/code/Common/Version.cpp     |   117 +-
 .../code/Common/VertexTriangleAdjacency.cpp   |    59 +-
 .../code/Common/VertexTriangleAdjacency.h     |     2 +-
 .../assimp/code/Common/Win32DebugLogStream.h  |    10 +-
 .../assimp/code/Common/ZipArchiveIOSystem.cpp |   866 +-
 Engine/lib/assimp/code/Common/assbin_chunks.h |     2 +-
 Engine/lib/assimp/code/Common/material.cpp    |   100 +
 Engine/lib/assimp/code/Common/scene.cpp       |    67 +-
 Engine/lib/assimp/code/Common/simd.cpp        |     4 +-
 Engine/lib/assimp/code/Common/simd.h          |     2 +-
 Engine/lib/assimp/code/FBX/FBXConverter.cpp   |  3615 -----
 Engine/lib/assimp/code/FBX/FBXImporter.cpp    |   206 -
 .../code/Importer/StepFile/StepFileGen1.cpp   |  2195 ---
 .../code/Importer/StepFile/StepFileGen2.cpp   |  3067 ----
 .../code/Importer/StepFile/StepFileGen3.cpp   |  5746 -------
 .../Importer/StepFile/StepFileImporter.cpp    |   114 -
 .../code/Importer/StepFile/StepReaderGen.h    |  7288 ---------
 Engine/lib/assimp/code/Irr/IRRLoader.cpp      |  1488 --
 Engine/lib/assimp/code/Irr/IRRMeshLoader.cpp  |   536 -
 Engine/lib/assimp/code/Irr/IRRShared.cpp      |   501 -
 Engine/lib/assimp/code/LWO/LWOFileData.h      |   703 -
 Engine/lib/assimp/code/LWO/LWOLoader.cpp      |  1490 --
 Engine/lib/assimp/code/LWO/LWOMaterial.cpp    |   898 --
 Engine/lib/assimp/code/MMD/MMDImporter.cpp    |   372 -
 .../assimp/code/Material/MaterialSystem.cpp   |   477 +-
 .../lib/assimp/code/Material/MaterialSystem.h |     2 +-
 Engine/lib/assimp/code/Obj/ObjExporter.cpp    |   414 -
 Engine/lib/assimp/code/Obj/ObjExporter.h      |   190 -
 Engine/lib/assimp/code/Obj/ObjFileData.h      |   339 -
 .../lib/assimp/code/Obj/ObjFileImporter.cpp   |   784 -
 Engine/lib/assimp/code/Obj/ObjFileImporter.h  |   123 -
 .../assimp/code/Obj/ObjFileMtlImporter.cpp    |   494 -
 .../lib/assimp/code/Obj/ObjFileMtlImporter.h  |   117 -
 Engine/lib/assimp/code/Obj/ObjFileParser.cpp  |   880 --
 Engine/lib/assimp/code/Obj/ObjFileParser.h    |   165 -
 Engine/lib/assimp/code/Obj/ObjTools.h         |   308 -
 .../assimp/code/Ogre/OgreBinarySerializer.h   |   423 -
 .../assimp/code/Ogre/OgreXmlSerializer.cpp    |  1002 --
 .../assimp/code/OpenGEX/OpenGEXImporter.cpp   |  1326 --
 Engine/lib/assimp/code/Pbrt/PbrtExporter.cpp  |   947 ++
 Engine/lib/assimp/code/Pbrt/PbrtExporter.h    |   135 +
 Engine/lib/assimp/code/Ply/PlyParser.cpp      |  1142 --
 .../code/PostProcessing/ArmaturePopulate.cpp  |   265 +
 .../code/PostProcessing/ArmaturePopulate.h    |   112 +
 .../PostProcessing/CalcTangentsProcess.cpp    |   180 +-
 .../code/PostProcessing/CalcTangentsProcess.h |     2 +-
 .../ComputeUVMappingProcess.cpp               |     8 +-
 .../PostProcessing/ComputeUVMappingProcess.h  |     2 +-
 .../PostProcessing/ConvertToLHProcess.cpp     |   190 +-
 .../code/PostProcessing/ConvertToLHProcess.h  |     7 +-
 .../code/PostProcessing/DeboneProcess.cpp     |     7 +-
 .../code/PostProcessing/DeboneProcess.h       |     2 +-
 .../PostProcessing/DropFaceNormalsProcess.cpp |    14 +-
 .../PostProcessing/DropFaceNormalsProcess.h   |     2 +-
 .../PostProcessing/EmbedTexturesProcess.cpp   |    51 +-
 .../PostProcessing/EmbedTexturesProcess.h     |     7 +-
 .../code/PostProcessing/FindDegenerates.cpp   |    94 +-
 .../code/PostProcessing/FindDegenerates.h     |     2 +-
 .../PostProcessing/FindInstancesProcess.cpp   |    10 +-
 .../PostProcessing/FindInstancesProcess.h     |     2 +-
 .../PostProcessing/FindInvalidDataProcess.cpp |   197 +-
 .../PostProcessing/FindInvalidDataProcess.h   |    19 +-
 .../code/PostProcessing/FixNormalsStep.cpp    |     4 +-
 .../code/PostProcessing/FixNormalsStep.h      |     2 +-
 .../GenBoundingBoxesProcess.cpp               |     2 +-
 .../PostProcessing/GenBoundingBoxesProcess.h  |     2 +-
 .../PostProcessing/GenFaceNormalsProcess.cpp  |    63 +-
 .../PostProcessing/GenFaceNormalsProcess.h    |     3 +-
 .../GenVertexNormalsProcess.cpp               |   108 +-
 .../PostProcessing/GenVertexNormalsProcess.h  |     3 +-
 .../PostProcessing/ImproveCacheLocality.cpp   |     6 +-
 .../PostProcessing/ImproveCacheLocality.h     |     2 +-
 .../PostProcessing/JoinVerticesProcess.cpp    |    12 +-
 .../code/PostProcessing/JoinVerticesProcess.h |     2 +-
 .../LimitBoneWeightsProcess.cpp               |   141 +-
 .../PostProcessing/LimitBoneWeightsProcess.h  |     2 +-
 .../code/PostProcessing/MakeVerboseFormat.cpp |   136 +-
 .../code/PostProcessing/MakeVerboseFormat.h   |     4 +-
 .../code/PostProcessing/OptimizeGraph.cpp     |   431 +-
 .../code/PostProcessing/OptimizeGraph.h       |     8 +-
 .../code/PostProcessing/OptimizeMeshes.cpp    |     4 +-
 .../code/PostProcessing/OptimizeMeshes.h      |     2 +-
 .../PostProcessing/PretransformVertices.cpp   |  1040 +-
 .../PostProcessing/PretransformVertices.h     |   144 +-
 .../code/PostProcessing/ProcessHelper.cpp     |   260 +-
 .../code/PostProcessing/ProcessHelper.h       |   364 +-
 .../RemoveRedundantMaterials.cpp              |    11 +-
 .../PostProcessing/RemoveRedundantMaterials.h |     4 +-
 .../code/PostProcessing/RemoveVCProcess.cpp   |   160 +-
 .../code/PostProcessing/RemoveVCProcess.h     |     2 +-
 .../code/PostProcessing/ScaleProcess.cpp      |    42 +-
 .../assimp/code/PostProcessing/ScaleProcess.h |     8 +-
 .../PostProcessing/SortByPTypeProcess.cpp     |   308 +-
 .../code/PostProcessing/SortByPTypeProcess.h  |     2 +-
 .../SplitByBoneCountProcess.cpp               |   121 +-
 .../SplitByBoneCountProcess.h                 |     4 +-
 .../code/PostProcessing/SplitLargeMeshes.cpp  |    13 +-
 .../code/PostProcessing/SplitLargeMeshes.h    |     2 +-
 .../code/PostProcessing/TextureTransform.cpp  |    31 +-
 .../code/PostProcessing/TextureTransform.h    |     2 +-
 .../PostProcessing/TriangulateProcess.cpp     |   120 +-
 .../code/PostProcessing/TriangulateProcess.h  |     2 +-
 .../PostProcessing/ValidateDataStructure.cpp  |   841 +-
 .../PostProcessing/ValidateDataStructure.h    |    10 +-
 .../assimp/code/Q3BSP/Q3BSPFileImporter.cpp   |   706 -
 Engine/lib/assimp/code/Q3D/Q3DLoader.cpp      |   619 -
 Engine/lib/assimp/code/Step/STEPFile.h        |  1016 --
 Engine/lib/assimp/code/X3D/FIReader.cpp       |  1838 ---
 Engine/lib/assimp/code/X3D/FIReader.hpp       |   192 -
 Engine/lib/assimp/code/X3D/X3DExporter.cpp    |   735 -
 Engine/lib/assimp/code/X3D/X3DExporter.hpp    |   235 -
 Engine/lib/assimp/code/X3D/X3DImporter.cpp    |  1735 --
 Engine/lib/assimp/code/X3D/X3DImporter.hpp    |   834 -
 .../code/X3D/X3DImporter_Geometry2D.cpp       |   522 -
 .../code/X3D/X3DImporter_Geometry3D.cpp       |   999 --
 .../lib/assimp/code/X3D/X3DImporter_Light.cpp |   290 -
 .../lib/assimp/code/X3D/X3DImporter_Macro.hpp |   195 -
 .../assimp/code/X3D/X3DImporter_Metadata.cpp  |   277 -
 .../lib/assimp/code/X3D/X3DImporter_Node.hpp  |   780 -
 .../code/X3D/X3DImporter_Postprocess.cpp      |   827 -
 .../assimp/code/X3D/X3DImporter_Rendering.cpp |  1071 --
 .../lib/assimp/code/X3D/X3DImporter_Shape.cpp |   250 -
 .../assimp/code/X3D/X3DImporter_Texturing.cpp |   197 -
 Engine/lib/assimp/code/X3D/X3DVocabulary.cpp  |  1676 --
 Engine/lib/assimp/code/XGL/XGLLoader.cpp      |   956 --
 Engine/lib/assimp/code/glTF/glTFAsset.h       |  1146 --
 Engine/lib/assimp/code/glTF/glTFAsset.inl     |  1481 --
 Engine/lib/assimp/code/glTF/glTFCommon.h      |   248 -
 Engine/lib/assimp/code/glTF2/glTF2Asset.h     |  1101 --
 Engine/lib/assimp/code/glTF2/glTF2Asset.inl   |  1519 --
 .../lib/assimp/code/glTF2/glTF2Exporter.cpp   |  1100 --
 Engine/lib/assimp/code/glTF2/glTF2Exporter.h  |   131 -
 .../lib/assimp/code/glTF2/glTF2Importer.cpp   |  1265 --
 Engine/lib/assimp/code/res/assimp.rc          |     2 +-
 Engine/lib/assimp/contrib/CMakeLists.txt      |     4 -
 .../contrib/Open3DGC/o3dgcArithmeticCodec.cpp |     5 +-
 .../contrib/Open3DGC/o3dgcArithmeticCodec.h   |     1 +
 .../contrib/Open3DGC/o3dgcSC3DMCDecoder.h     |     2 +-
 .../contrib/Open3DGC/o3dgcSC3DMCDecoder.inl   |    27 +-
 .../contrib/Open3DGC/o3dgcSC3DMCEncoder.inl   |    19 +-
 .../lib/assimp/contrib/Open3DGC/o3dgcTimer.h  |     2 +
 .../Open3DGC/o3dgcTriangleListEncoder.inl     |     4 +-
 .../assimp/contrib/Open3DGC/o3dgcVector.inl   |     4 +-
 .../assimp/contrib/android-cmake/README.md    |     2 +-
 .../android-cmake/android.toolchain.cmake     |     1 +
 Engine/lib/assimp/contrib/draco/.clang-format |     5 +
 .../lib/assimp/contrib/draco/.cmake-format.py |   102 +
 Engine/lib/assimp/contrib/draco/AUTHORS       |     7 +
 Engine/lib/assimp/contrib/draco/BUILDING.md   |   301 +
 Engine/lib/assimp/contrib/draco/CMAKE.md      |   106 +
 .../lib/assimp/contrib/draco/CMakeLists.txt   |   952 ++
 .../lib/assimp/contrib/draco/CONTRIBUTING.md  |    27 +
 Engine/lib/assimp/contrib/draco/LICENSE       |   252 +
 Engine/lib/assimp/contrib/draco/README.md     |   478 +
 .../contrib/draco/cmake/DracoConfig.cmake     |     3 +
 .../contrib/draco/cmake/FindDraco.cmake       |    56 +
 .../contrib/draco/cmake/compiler_flags.cmake  |   220 +
 .../contrib/draco/cmake/compiler_tests.cmake  |   103 +
 .../draco/cmake/draco-config.cmake.template   |     2 +
 .../contrib/draco/cmake/draco.pc.template     |    11 +
 .../draco/cmake/draco_build_definitions.cmake |   124 +
 .../draco/cmake/draco_cpu_detection.cmake     |    28 +
 .../draco/cmake/draco_emscripten.cmake        |   185 +
 .../contrib/draco/cmake/draco_flags.cmake     |   247 +
 .../contrib/draco/cmake/draco_helpers.cmake   |   110 +
 .../contrib/draco/cmake/draco_install.cmake   |    79 +
 .../draco/cmake/draco_intrinsics.cmake        |    96 +
 .../contrib/draco/cmake/draco_options.cmake   |   239 +
 .../contrib/draco/cmake/draco_sanitizer.cmake |    32 +
 .../contrib/draco/cmake/draco_targets.cmake   |   355 +
 .../draco/cmake/draco_test_config.h.cmake     |    13 +
 .../contrib/draco/cmake/draco_tests.cmake     |   133 +
 .../contrib/draco/cmake/draco_variables.cmake |    64 +
 .../contrib/draco/cmake/sanitizers.cmake      |    19 +
 .../cmake/toolchains/aarch64-linux-gnu.cmake  |    14 +
 .../cmake/toolchains/android-ndk-common.cmake |    23 +
 .../draco/cmake/toolchains/android.cmake      |    39 +
 .../cmake/toolchains/arm-ios-common.cmake     |    17 +
 .../toolchains/arm-linux-gnueabihf.cmake      |    15 +
 .../toolchains/arm64-android-ndk-libcpp.cmake |    16 +
 .../draco/cmake/toolchains/arm64-ios.cmake    |    14 +
 .../cmake/toolchains/arm64-linux-gcc.cmake    |    18 +
 .../toolchains/armv7-android-ndk-libcpp.cmake |    16 +
 .../draco/cmake/toolchains/armv7-ios.cmake    |    14 +
 .../cmake/toolchains/armv7-linux-gcc.cmake    |    24 +
 .../draco/cmake/toolchains/armv7s-ios.cmake   |    14 +
 .../draco/cmake/toolchains/i386-ios.cmake     |    15 +
 .../toolchains/x86-android-ndk-libcpp.cmake   |    16 +
 .../x86_64-android-ndk-libcpp.cmake           |    16 +
 .../draco/cmake/toolchains/x86_64-ios.cmake   |    15 +
 .../lib/assimp/contrib/draco/cmake/util.cmake |    79 +
 .../src/draco/animation/keyframe_animation.cc |    54 +
 .../src/draco/animation/keyframe_animation.h  |   107 +
 .../animation/keyframe_animation_decoder.cc   |    30 +
 .../animation/keyframe_animation_decoder.h    |    34 +
 .../animation/keyframe_animation_encoder.cc   |    28 +
 .../animation/keyframe_animation_encoder.h    |    39 +
 .../keyframe_animation_encoding_test.cc       |   168 +
 .../animation/keyframe_animation_test.cc      |   102 +
 .../attribute_octahedron_transform.cc         |   145 +
 .../attribute_octahedron_transform.h          |    81 +
 .../attribute_quantization_transform.cc       |   260 +
 .../attribute_quantization_transform.h        |   102 +
 .../draco/attributes/attribute_transform.cc   |    40 +
 .../draco/attributes/attribute_transform.h    |    76 +
 .../attributes/attribute_transform_data.h     |    71 +
 .../attributes/attribute_transform_type.h     |    30 +
 .../draco/attributes/geometry_attribute.cc    |   102 +
 .../src/draco/attributes/geometry_attribute.h |   350 +
 .../src/draco/attributes/geometry_indices.h   |    54 +
 .../src/draco/attributes/point_attribute.cc   |   225 +
 .../src/draco/attributes/point_attribute.h    |   190 +
 .../draco/attributes/point_attribute_test.cc  |   128 +
 .../attributes/attributes_decoder.cc          |   127 +
 .../attributes/attributes_decoder.h           |    97 +
 .../attributes/attributes_decoder_interface.h |    62 +
 .../attributes/attributes_encoder.cc          |    49 +
 .../attributes/attributes_encoder.h           |   154 +
 .../attributes/kd_tree_attributes_decoder.cc  |   556 +
 .../attributes/kd_tree_attributes_decoder.h   |    46 +
 .../attributes/kd_tree_attributes_encoder.cc  |   305 +
 .../attributes/kd_tree_attributes_encoder.h   |    51 +
 .../attributes/kd_tree_attributes_shared.h    |    28 +
 .../compression/attributes/linear_sequencer.h |    51 +
 .../mesh_attribute_indices_encoding_data.h    |    58 +
 .../attributes/normal_compression_utils.h     |   360 +
 .../compression/attributes/point_d_vector.h   |   279 +
 .../attributes/point_d_vector_test.cc         |   360 +
 .../compression/attributes/points_sequencer.h |    63 +
 ..._constrained_multi_parallelogram_decoder.h |   231 +
 ..._constrained_multi_parallelogram_encoder.h |   414 +
 ...e_constrained_multi_parallelogram_shared.h |    34 +
 .../mesh_prediction_scheme_data.h             |    72 +
 .../mesh_prediction_scheme_decoder.h          |    46 +
 .../mesh_prediction_scheme_encoder.h          |    46 +
 ...ediction_scheme_geometric_normal_decoder.h |   172 +
 ...ediction_scheme_geometric_normal_encoder.h |   180 +
 ...n_scheme_geometric_normal_predictor_area.h |   117 +
 ...n_scheme_geometric_normal_predictor_base.h |    96 +
 ...ction_scheme_multi_parallelogram_decoder.h |   126 +
 ...ction_scheme_multi_parallelogram_encoder.h |   133 +
 ..._prediction_scheme_parallelogram_decoder.h |    98 +
 ..._prediction_scheme_parallelogram_encoder.h |   111 +
 ...h_prediction_scheme_parallelogram_shared.h |    78 +
 ...esh_prediction_scheme_tex_coords_decoder.h |   344 +
 ...esh_prediction_scheme_tex_coords_encoder.h |   318 +
 ...ction_scheme_tex_coords_portable_decoder.h |   143 +
 ...ction_scheme_tex_coords_portable_encoder.h |   133 +
 ...ion_scheme_tex_coords_portable_predictor.h |   263 +
 .../prediction_scheme_decoder.h               |    90 +
 .../prediction_scheme_decoder_factory.h       |   194 +
 .../prediction_scheme_decoder_interface.h     |    53 +
 .../prediction_scheme_decoding_transform.h    |    65 +
 .../prediction_scheme_delta_decoder.h         |    65 +
 .../prediction_scheme_delta_encoder.h         |    69 +
 .../prediction_scheme_encoder.h               |    90 +
 .../prediction_scheme_encoder_factory.cc      |    85 +
 .../prediction_scheme_encoder_factory.h       |   129 +
 .../prediction_scheme_encoder_interface.h     |    55 +
 .../prediction_scheme_encoding_transform.h    |    77 +
 .../prediction_scheme_factory.h               |    85 +
 .../prediction_scheme_interface.h             |    60 +
 ...ahedron_canonicalized_decoding_transform.h |   118 +
 ...ahedron_canonicalized_encoding_transform.h |   116 +
 ..._octahedron_canonicalized_transform_base.h |   102 +
 ...octahedron_canonicalized_transform_test.cc |   192 +
 ...eme_normal_octahedron_decoding_transform.h |   103 +
 ...eme_normal_octahedron_encoding_transform.h |   105 +
 ..._scheme_normal_octahedron_transform_base.h |    90 +
 ...scheme_normal_octahedron_transform_test.cc |    71 +
 ...rediction_scheme_wrap_decoding_transform.h |    88 +
 ...rediction_scheme_wrap_encoding_transform.h |    81 +
 .../prediction_scheme_wrap_transform_base.h   |   120 +
 .../sequential_attribute_decoder.cc           |   118 +
 .../attributes/sequential_attribute_decoder.h |    86 +
 ...equential_attribute_decoders_controller.cc |   149 +
 ...sequential_attribute_decoders_controller.h |    61 +
 .../sequential_attribute_encoder.cc           |   108 +
 .../attributes/sequential_attribute_encoder.h |   134 +
 ...equential_attribute_encoders_controller.cc |   159 +
 ...sequential_attribute_encoders_controller.h |   115 +
 .../sequential_integer_attribute_decoder.cc   |   240 +
 .../sequential_integer_attribute_decoder.h    |    76 +
 .../sequential_integer_attribute_encoder.cc   |   233 +
 .../sequential_integer_attribute_encoder.h    |    67 +
 ...uential_integer_attribute_encoding_test.cc |    64 +
 .../sequential_normal_attribute_decoder.cc    |    76 +
 .../sequential_normal_attribute_decoder.h     |    83 +
 .../sequential_normal_attribute_encoder.cc    |    57 +
 .../sequential_normal_attribute_encoder.h     |    82 +
 ...quential_quantization_attribute_decoder.cc |    88 +
 ...equential_quantization_attribute_decoder.h |    52 +
 ...quential_quantization_attribute_encoder.cc |    86 +
 ...equential_quantization_attribute_encoder.h |    52 +
 .../adaptive_rans_bit_coding_shared.h         |    43 +
 .../bit_coders/adaptive_rans_bit_decoder.cc   |    70 +
 .../bit_coders/adaptive_rans_bit_decoder.h    |    54 +
 .../bit_coders/adaptive_rans_bit_encoder.cc   |    59 +
 .../bit_coders/adaptive_rans_bit_encoder.h    |    61 +
 .../bit_coders/direct_bit_decoder.cc          |    54 +
 .../bit_coders/direct_bit_decoder.h           |    90 +
 .../bit_coders/direct_bit_encoder.cc          |    39 +
 .../bit_coders/direct_bit_encoder.h           |    89 +
 .../bit_coders/folded_integer_bit_decoder.h   |    77 +
 .../bit_coders/folded_integer_bit_encoder.h   |    82 +
 .../bit_coders/rans_bit_decoder.cc            |    82 +
 .../compression/bit_coders/rans_bit_decoder.h |    55 +
 .../bit_coders/rans_bit_encoder.cc            |   125 +
 .../compression/bit_coders/rans_bit_encoder.h |    57 +
 .../bit_coders/rans_coding_test.cc            |     9 +
 .../bit_coders/symbol_bit_decoder.cc          |    49 +
 .../bit_coders/symbol_bit_decoder.h           |    36 +
 .../bit_coders/symbol_bit_encoder.cc          |    30 +
 .../bit_coders/symbol_bit_encoder.h           |    36 +
 .../compression/config/compression_shared.h   |   155 +
 .../compression/config/decoder_options.h      |    34 +
 .../config/decoder_options_test.cc            |    67 +
 .../draco/compression/config/draco_options.h  |   249 +
 .../compression/config/encoder_options.h      |    97 +
 .../compression/config/encoding_features.h    |    39 +
 .../draco/src/draco/compression/decode.cc     |   135 +
 .../draco/src/draco/compression/decode.h      |    80 +
 .../src/draco/compression/decode_test.cc      |   169 +
 .../draco/src/draco/compression/encode.cc     |    96 +
 .../draco/src/draco/compression/encode.h      |   140 +
 .../draco/src/draco/compression/encode_base.h |   131 +
 .../src/draco/compression/encode_test.cc      |   407 +
 .../draco/src/draco/compression/entropy/ans.h |   527 +
 .../compression/entropy/rans_symbol_coding.h  |    53 +
 .../compression/entropy/rans_symbol_decoder.h |   164 +
 .../compression/entropy/rans_symbol_encoder.h |   290 +
 .../compression/entropy/shannon_entropy.cc    |   147 +
 .../compression/entropy/shannon_entropy.h     |   110 +
 .../entropy/shannon_entropy_test.cc           |    58 +
 .../compression/entropy/symbol_coding_test.cc |   170 +
 .../compression/entropy/symbol_decoding.cc    |   181 +
 .../compression/entropy/symbol_decoding.h     |    29 +
 .../compression/entropy/symbol_encoding.cc    |   376 +
 .../compression/entropy/symbol_encoding.h     |    47 +
 .../src/draco/compression/expert_encode.cc    |   182 +
 .../src/draco/compression/expert_encode.h     |   147 +
 .../draco/compression/mesh/mesh_decoder.cc    |    37 +
 .../src/draco/compression/mesh/mesh_decoder.h |    68 +
 .../mesh/mesh_edgebreaker_decoder.cc          |    70 +
 .../mesh/mesh_edgebreaker_decoder.h           |    54 +
 .../mesh/mesh_edgebreaker_decoder_impl.cc     |  1231 ++
 .../mesh/mesh_edgebreaker_decoder_impl.h      |   228 +
 .../mesh_edgebreaker_decoder_impl_interface.h |    47 +
 .../mesh/mesh_edgebreaker_encoder.cc          |   195 +
 .../mesh/mesh_edgebreaker_encoder.h           |    73 +
 .../mesh/mesh_edgebreaker_encoder_impl.cc     |   854 +
 .../mesh/mesh_edgebreaker_encoder_impl.h      |   210 +
 .../mesh_edgebreaker_encoder_impl_interface.h |    57 +
 .../mesh/mesh_edgebreaker_encoding_test.cc    |   247 +
 .../mesh/mesh_edgebreaker_shared.h            |   131 +
 .../mesh/mesh_edgebreaker_traversal_decoder.h |   201 +
 .../mesh/mesh_edgebreaker_traversal_encoder.h |   139 +
 ...edgebreaker_traversal_predictive_decoder.h |   134 +
 ...edgebreaker_traversal_predictive_encoder.h |   172 +
 ...sh_edgebreaker_traversal_valence_decoder.h |   215 +
 ...sh_edgebreaker_traversal_valence_encoder.h |   226 +
 .../draco/compression/mesh/mesh_encoder.cc    |    34 +
 .../src/draco/compression/mesh/mesh_encoder.h |    84 +
 .../compression/mesh/mesh_encoder_test.cc     |   116 +
 .../mesh/mesh_sequential_decoder.cc           |   169 +
 .../mesh/mesh_sequential_decoder.h            |    39 +
 .../mesh/mesh_sequential_encoder.cc           |   132 +
 .../mesh/mesh_sequential_encoder.h            |    57 +
 .../mesh/traverser/depth_first_traverser.h    |   172 +
 .../max_prediction_degree_traverser.h         |   226 +
 ...mesh_attribute_indices_encoding_observer.h |    76 +
 .../mesh/traverser/mesh_traversal_sequencer.h |   113 +
 .../mesh/traverser/traverser_base.h           |    87 +
 .../dynamic_integer_points_kd_tree_decoder.cc |    26 +
 .../dynamic_integer_points_kd_tree_decoder.h  |   330 +
 .../dynamic_integer_points_kd_tree_encoder.cc |    26 +
 .../dynamic_integer_points_kd_tree_encoder.h  |   371 +
 .../algorithms/float_points_tree_decoder.cc   |   152 +
 .../algorithms/float_points_tree_decoder.h    |   141 +
 .../algorithms/float_points_tree_encoder.cc   |    94 +
 .../algorithms/float_points_tree_encoder.h    |   126 +
 .../integer_points_kd_tree_decoder.cc         |    45 +
 .../integer_points_kd_tree_decoder.h          |   314 +
 .../integer_points_kd_tree_encoder.cc         |    45 +
 .../integer_points_kd_tree_encoder.h          |   404 +
 .../point_cloud_compression_method.h          |    34 +
 .../algorithms/point_cloud_types.h            |    76 +
 .../algorithms/quantize_points_3.h            |    84 +
 .../point_cloud/algorithms/queuing_policy.h   |    75 +
 .../point_cloud/point_cloud_decoder.cc        |   199 +
 .../point_cloud/point_cloud_decoder.h         |   118 +
 .../point_cloud/point_cloud_encoder.cc        |   306 +
 .../point_cloud/point_cloud_encoder.h         |   158 +
 .../point_cloud_kd_tree_decoder.cc            |    40 +
 .../point_cloud/point_cloud_kd_tree_decoder.h |    31 +
 .../point_cloud_kd_tree_encoder.cc            |    43 +
 .../point_cloud/point_cloud_kd_tree_encoder.h |    45 +
 .../point_cloud_kd_tree_encoding_test.cc      |   458 +
 .../point_cloud_sequential_decoder.cc         |    42 +
 .../point_cloud_sequential_decoder.h          |    33 +
 .../point_cloud_sequential_encoder.cc         |    49 +
 .../point_cloud_sequential_encoder.h          |    43 +
 .../point_cloud_sequential_encoding_test.cc   |    92 +
 .../contrib/draco/src/draco/core/bit_utils.cc |    36 +
 .../contrib/draco/src/draco/core/bit_utils.h  |   124 +
 .../draco/src/draco/core/bounding_box.cc      |    30 +
 .../draco/src/draco/core/bounding_box.h       |    72 +
 .../src/draco/core/buffer_bit_coding_test.cc  |   115 +
 .../draco/src/draco/core/cycle_timer.cc       |    49 +
 .../draco/src/draco/core/cycle_timer.h        |    51 +
 .../draco/src/draco/core/data_buffer.cc       |    61 +
 .../draco/src/draco/core/data_buffer.h        |    82 +
 .../draco/src/draco/core/decoder_buffer.cc    |    72 +
 .../draco/src/draco/core/decoder_buffer.h     |   216 +
 .../contrib/draco/src/draco/core/divide.cc    |    88 +
 .../contrib/draco/src/draco/core/divide.h     |    42 +
 .../draco/src/draco/core/draco_index_type.h   |   183 +
 .../src/draco/core/draco_index_type_vector.h  |    83 +
 .../draco/src/draco/core/draco_test_base.h    |    11 +
 .../draco/src/draco/core/draco_test_utils.cc  |    80 +
 .../draco/src/draco/core/draco_test_utils.h   |    93 +
 .../draco/src/draco/core/draco_types.cc       |    61 +
 .../draco/src/draco/core/draco_types.h        |    52 +
 .../draco/src/draco/core/draco_version.h      |    27 +
 .../draco/src/draco/core/encoder_buffer.cc    |    93 +
 .../draco/src/draco/core/encoder_buffer.h     |   152 +
 .../draco/src/draco/core/hash_utils.cc        |    58 +
 .../contrib/draco/src/draco/core/hash_utils.h |    64 +
 .../contrib/draco/src/draco/core/macros.h     |   119 +
 .../contrib/draco/src/draco/core/math_utils.h |    55 +
 .../draco/src/draco/core/math_utils_test.cc   |    22 +
 .../contrib/draco/src/draco/core/options.cc   |    94 +
 .../contrib/draco/src/draco/core/options.h    |   150 +
 .../src/draco/core/quantization_utils.cc      |    42 +
 .../draco/src/draco/core/quantization_utils.h |    82 +
 .../src/draco/core/quantization_utils_test.cc |    91 +
 .../contrib/draco/src/draco/core/status.h     |    77 +
 .../contrib/draco/src/draco/core/status_or.h  |    81 +
 .../draco/src/draco/core/status_test.cc       |    38 +
 .../draco/src/draco/core/varint_decoding.h    |    81 +
 .../draco/src/draco/core/varint_encoding.h    |    61 +
 .../contrib/draco/src/draco/core/vector_d.h   |   355 +
 .../draco/src/draco/core/vector_d_test.cc     |   306 +
 .../draco/src/draco/io/file_reader_factory.cc |    45 +
 .../draco/src/draco/io/file_reader_factory.h  |    34 +
 .../src/draco/io/file_reader_factory_test.cc  |    85 +
 .../src/draco/io/file_reader_interface.h      |    32 +
 .../src/draco/io/file_reader_test_common.h    |    13 +
 .../contrib/draco/src/draco/io/file_utils.cc  |   110 +
 .../contrib/draco/src/draco/io/file_utils.h   |    73 +
 .../draco/src/draco/io/file_utils_test.cc     |    69 +
 .../draco/src/draco/io/file_writer_factory.cc |    45 +
 .../draco/src/draco/io/file_writer_factory.h  |    34 +
 .../src/draco/io/file_writer_factory_test.cc  |    70 +
 .../src/draco/io/file_writer_interface.h      |    26 +
 .../draco/src/draco/io/file_writer_utils.cc   |    57 +
 .../draco/src/draco/io/file_writer_utils.h    |    38 +
 .../contrib/draco/src/draco/io/mesh_io.cc     |    87 +
 .../contrib/draco/src/draco/io/mesh_io.h      |   107 +
 .../contrib/draco/src/draco/io/obj_decoder.cc |   708 +
 .../contrib/draco/src/draco/io/obj_decoder.h  |   129 +
 .../draco/src/draco/io/obj_decoder_test.cc    |   193 +
 .../contrib/draco/src/draco/io/obj_encoder.cc |   346 +
 .../contrib/draco/src/draco/io/obj_encoder.h  |    92 +
 .../draco/src/draco/io/obj_encoder_test.cc    |   110 +
 .../draco/src/draco/io/parser_utils.cc        |   261 +
 .../contrib/draco/src/draco/io/parser_utils.h |    66 +
 .../contrib/draco/src/draco/io/ply_decoder.cc |   320 +
 .../contrib/draco/src/draco/io/ply_decoder.h  |    69 +
 .../draco/src/draco/io/ply_decoder_test.cc    |    93 +
 .../contrib/draco/src/draco/io/ply_encoder.cc |   211 +
 .../contrib/draco/src/draco/io/ply_encoder.h  |    54 +
 .../draco/src/draco/io/ply_property_reader.h  |    96 +
 .../draco/src/draco/io/ply_property_writer.h  |    94 +
 .../contrib/draco/src/draco/io/ply_reader.cc  |   312 +
 .../contrib/draco/src/draco/io/ply_reader.h   |   155 +
 .../draco/src/draco/io/ply_reader_test.cc     |   143 +
 .../draco/src/draco/io/point_cloud_io.cc      |    58 +
 .../draco/src/draco/io/point_cloud_io.h       |    89 +
 .../draco/src/draco/io/point_cloud_io_test.cc |   115 +
 .../draco/src/draco/io/stdio_file_reader.cc   |   103 +
 .../draco/src/draco/io/stdio_file_reader.h    |    48 +
 .../src/draco/io/stdio_file_reader_test.cc    |    49 +
 .../draco/src/draco/io/stdio_file_writer.cc   |    59 +
 .../draco/src/draco/io/stdio_file_writer.h    |    42 +
 .../src/draco/io/stdio_file_writer_test.cc    |    38 +
 .../animation_decoder_webidl_wrapper.cc       |   101 +
 .../animation_decoder_webidl_wrapper.h        |    73 +
 .../animation_encoder_webidl_wrapper.cc       |    89 +
 .../animation_encoder_webidl_wrapper.h        |    66 +
 .../emscripten/decoder_functions.js           |    33 +
 .../emscripten/decoder_webidl_wrapper.cc      |   363 +
 .../emscripten/decoder_webidl_wrapper.h       |   330 +
 .../draco_animation_decoder_glue_wrapper.cc   |    28 +
 .../draco_animation_encoder_glue_wrapper.cc   |    25 +
 .../draco_animation_web_decoder.idl           |    52 +
 .../draco_animation_web_encoder.idl           |    34 +
 .../emscripten/draco_decoder_glue_wrapper.cc  |    28 +
 .../emscripten/draco_encoder_glue_wrapper.cc  |    25 +
 .../emscripten/draco_web_decoder.idl          |   283 +
 .../emscripten/draco_web_encoder.idl          |   208 +
 .../emscripten/encoder_webidl_wrapper.cc      |   359 +
 .../emscripten/encoder_webidl_wrapper.h       |   186 +
 .../draco/javascript/emscripten/finalize.js   |    22 +
 .../javascript/emscripten/prepareCallbacks.js |    38 +
 .../draco/javascript/emscripten/version.js    |    29 +
 .../draco/src/draco/maya/draco_maya_plugin.cc |   265 +
 .../draco/src/draco/maya/draco_maya_plugin.h  |    81 +
 .../draco/src/draco/mesh/corner_table.cc      |   441 +
 .../draco/src/draco/mesh/corner_table.h       |   396 +
 .../src/draco/mesh/corner_table_iterators.h   |   289 +
 .../contrib/draco/src/draco/mesh/mesh.cc      |    40 +
 .../contrib/draco/src/draco/mesh/mesh.h       |   152 +
 .../src/draco/mesh/mesh_are_equivalent.cc     |   205 +
 .../src/draco/mesh/mesh_are_equivalent.h      |    71 +
 .../draco/mesh/mesh_are_equivalent_test.cc    |    98 +
 .../draco/mesh/mesh_attribute_corner_table.cc |   211 +
 .../draco/mesh/mesh_attribute_corner_table.h  |   196 +
 .../draco/src/draco/mesh/mesh_cleanup.cc      |   251 +
 .../draco/src/draco/mesh/mesh_cleanup.h       |    65 +
 .../draco/src/draco/mesh/mesh_cleanup_test.cc |   192 +
 .../src/draco/mesh/mesh_misc_functions.cc     |    63 +
 .../src/draco/mesh/mesh_misc_functions.h      |    98 +
 .../draco/src/draco/mesh/mesh_stripifier.cc   |   102 +
 .../draco/src/draco/mesh/mesh_stripifier.h    |   260 +
 .../draco/mesh/triangle_soup_mesh_builder.cc  |    89 +
 .../draco/mesh/triangle_soup_mesh_builder.h   |    63 +
 .../mesh/triangle_soup_mesh_builder_test.cc   |   197 +
 .../draco/src/draco/mesh/valence_cache.h      |   142 +
 .../src/draco/metadata/geometry_metadata.cc   |    44 +
 .../src/draco/metadata/geometry_metadata.h    |   140 +
 .../draco/src/draco/metadata/metadata.cc      |   132 +
 .../draco/src/draco/metadata/metadata.h       |   208 +
 .../src/draco/metadata/metadata_decoder.cc    |   148 +
 .../src/draco/metadata/metadata_decoder.h     |    42 +
 .../src/draco/metadata/metadata_encoder.cc    |    97 +
 .../src/draco/metadata/metadata_encoder.h     |    41 +
 .../draco/metadata/metadata_encoder_test.cc   |   167 +
 .../draco/src/draco/metadata/metadata_test.cc |   157 +
 .../src/draco/point_cloud/point_cloud.cc      |   275 +
 .../draco/src/draco/point_cloud/point_cloud.h |   244 +
 .../draco/point_cloud/point_cloud_builder.cc  |    76 +
 .../draco/point_cloud/point_cloud_builder.h   |    80 +
 .../point_cloud/point_cloud_builder_test.cc   |   171 +
 .../src/draco/point_cloud/point_cloud_test.cc |   132 +
 .../draco/src/draco/tools/draco_decoder.cc    |   168 +
 .../draco/src/draco/tools/draco_encoder.cc    |   369 +
 .../draco/src/draco/tools/fuzz/build.sh       |    35 +
 .../tools/fuzz/draco_mesh_decoder_fuzzer.cc   |    29 +
 ...h_decoder_without_dequantization_fuzzer.cc |    30 +
 .../tools/fuzz/draco_pc_decoder_fuzzer.cc     |    29 +
 ...c_decoder_without_dequantization_fuzzer.cc |    30 +
 .../src/draco/unity/draco_unity_plugin.cc     |   407 +
 .../src/draco/unity/draco_unity_plugin.h      |   154 +
 .../draco/unity/draco_unity_plugin_test.cc    |   243 +
 .../lib/assimp/contrib/gtest/CMakeLists.txt   |     2 +-
 .../contrib/gtest/docs/Documentation.md       |     2 +-
 .../contrib/gtest/docs/V1_5_Documentation.md  |     2 +-
 .../contrib/gtest/docs/V1_5_PumpManual.md     |     2 +-
 .../contrib/gtest/docs/V1_5_XcodeGuide.md     |     2 +-
 .../contrib/gtest/docs/V1_6_Documentation.md  |     2 +-
 .../contrib/gtest/docs/V1_6_XcodeGuide.md     |     2 +-
 .../contrib/gtest/docs/V1_7_Documentation.md  |     2 +-
 .../contrib/gtest/docs/V1_7_XcodeGuide.md     |     2 +-
 .../assimp/contrib/gtest/docs/XcodeGuide.md   |     2 +-
 .../include/gtest/internal/gtest-internal.h   |     2 +-
 .../include/gtest/internal/gtest-param-util.h |     2 +-
 .../gtest/include/gtest/internal/gtest-port.h |    14 +
 .../assimp/contrib/gtest/src/gtest-port.cc    |     3 +-
 .../CMakeDirectoryInformation.cmake           |    16 -
 .../CMakeFiles/IrrXML.dir/DependInfo.cmake    |    19 -
 .../irrXML/CMakeFiles/IrrXML.dir/build.make   |   111 -
 .../CMakeFiles/IrrXML.dir/cmake_clean.cmake   |    11 -
 .../IrrXML.dir/cmake_clean_target.cmake       |     3 -
 .../IrrXML.dir/compiler_depend.make           |     2 -
 .../CMakeFiles/IrrXML.dir/compiler_depend.ts  |     2 -
 .../irrXML/CMakeFiles/IrrXML.dir/depend.make  |     2 -
 .../irrXML/CMakeFiles/IrrXML.dir/flags.make   |    10 -
 .../irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o |   Bin 295872 -> 0 bytes
 .../CMakeFiles/IrrXML.dir/irrXML.cpp.o.d      |    50 -
 .../irrXML/CMakeFiles/IrrXML.dir/link.txt     |     2 -
 .../CMakeFiles/IrrXML.dir/progress.make       |     3 -
 .../contrib/irrXML/CMakeFiles/progress.marks  |     1 -
 .../lib/assimp/contrib/irrXML/CMakeLists.txt  |    29 -
 .../assimp/contrib/irrXML/CXMLReaderImpl.h    |   813 -
 Engine/lib/assimp/contrib/irrXML/Makefile     |   231 -
 .../assimp/contrib/irrXML/cmake_install.cmake |    48 -
 Engine/lib/assimp/contrib/irrXML/heapsort.h   |    73 -
 Engine/lib/assimp/contrib/irrXML/irrArray.h   |   443 -
 Engine/lib/assimp/contrib/irrXML/irrString.h  |   664 -
 Engine/lib/assimp/contrib/irrXML/irrTypes.h   |   108 -
 Engine/lib/assimp/contrib/irrXML/irrXML.cpp   |   151 -
 Engine/lib/assimp/contrib/irrXML/irrXML.h     |   546 -
 Engine/lib/assimp/contrib/irrXML_note.txt     |     6 -
 .../contrib/openddlparser/CMakeLists.txt      |    26 +-
 .../contrib/openddlparser/code/DDLNode.cpp    |   144 +-
 .../openddlparser/code/OpenDDLCommon.cpp      |   144 +-
 .../openddlparser/code/OpenDDLExport.cpp      |   339 +-
 .../openddlparser/code/OpenDDLParser.cpp      |  1032 +-
 .../openddlparser/code/OpenDDLStream.cpp      |    30 +-
 .../contrib/openddlparser/code/Value.cpp      |   393 +-
 .../include/openddlparser/DDLNode.h           |    38 +-
 .../include/openddlparser/OpenDDLCommon.h     |   149 +-
 .../include/openddlparser/OpenDDLExport.h     |    26 +-
 .../include/openddlparser/OpenDDLParser.h     |   117 +-
 .../openddlparser/OpenDDLParserUtils.h        |   451 +-
 .../include/openddlparser/OpenDDLStream.h     |     8 +-
 .../include/openddlparser/TPoolAllocator.h    |   226 +
 .../include/openddlparser/Value.h             |     4 +-
 Engine/lib/assimp/contrib/poly2tri/README     |     4 +-
 .../poly2tri/poly2tri/common/shapes.cc        |     2 +-
 .../contrib/poly2tri/poly2tri/common/shapes.h |     2 +-
 .../contrib/poly2tri/poly2tri/poly2tri.h      |     2 +-
 .../poly2tri/sweep/advancing_front.cc         |     2 +-
 .../poly2tri/poly2tri/sweep/advancing_front.h |     2 +-
 .../contrib/poly2tri/poly2tri/sweep/cdt.cc    |     2 +-
 .../contrib/poly2tri/poly2tri/sweep/cdt.h     |     2 +-
 .../contrib/poly2tri/poly2tri/sweep/sweep.cc  |    16 +-
 .../contrib/poly2tri/poly2tri/sweep/sweep.h   |     2 +-
 .../lib/assimp/contrib/pugixml/CMakeLists.txt |    87 +
 .../contrib/pugixml/contrib/foreach.hpp       |    63 +
 Engine/lib/assimp/contrib/pugixml/readme.txt  |    50 +
 .../assimp/contrib/pugixml/src/pugiconfig.hpp |    77 +
 .../assimp/contrib/pugixml/src/pugixml.cpp    | 13020 ++++++++++++++++
 .../assimp/contrib/pugixml/src/pugixml.hpp    |  1499 ++
 .../rapidjson/include/rapidjson/allocators.h  |    25 +-
 .../include/rapidjson/cursorstreamwrapper.h   |    78 +
 .../rapidjson/include/rapidjson/document.h    |   254 +-
 .../include/rapidjson/encodedstream.h         |     2 +-
 .../rapidjson/include/rapidjson/encodings.h   |    62 +-
 .../rapidjson/include/rapidjson/error/en.h    |    50 +-
 .../rapidjson/include/rapidjson/error/error.h |    57 +-
 .../include/rapidjson/filereadstream.h        |     6 +-
 .../include/rapidjson/filewritestream.h       |     6 +-
 .../contrib/rapidjson/include/rapidjson/fwd.h |     4 +-
 .../include/rapidjson/internal/biginteger.h   |     6 +-
 .../include/rapidjson/internal/clzll.h        |    71 +
 .../include/rapidjson/internal/diyfp.h        |    53 +-
 .../include/rapidjson/internal/dtoa.h         |     2 +-
 .../include/rapidjson/internal/ieee754.h      |     2 +-
 .../include/rapidjson/internal/itoa.h         |    84 +-
 .../include/rapidjson/internal/meta.h         |    11 +-
 .../include/rapidjson/internal/pow10.h        |     2 +-
 .../include/rapidjson/internal/regex.h        |    45 +-
 .../include/rapidjson/internal/stack.h        |     9 +-
 .../include/rapidjson/internal/strfunc.h      |     2 +-
 .../include/rapidjson/internal/strtod.h       |    99 +-
 .../include/rapidjson/internal/swap.h         |     2 +-
 .../include/rapidjson/istreamwrapper.h        |    89 +-
 .../include/rapidjson/memorybuffer.h          |     2 +-
 .../include/rapidjson/memorystream.h          |     2 +-
 .../include/rapidjson/ostreamwrapper.h        |     2 +-
 .../rapidjson/include/rapidjson/pointer.h     |    91 +-
 .../include/rapidjson/prettywriter.h          |    30 +-
 .../rapidjson/include/rapidjson/rapidjson.h   |   100 +-
 .../rapidjson/include/rapidjson/reader.h      |   175 +-
 .../rapidjson/include/rapidjson/schema.h      |   950 +-
 .../rapidjson/include/rapidjson/stream.h      |    54 +-
 .../include/rapidjson/stringbuffer.h          |     2 +-
 .../rapidjson/include/rapidjson/writer.h      |    41 +-
 .../contrib/{stb_image => stb}/stb_image.h    |   648 +-
 Engine/lib/assimp/contrib/unzip/crypt.c       |   171 +
 Engine/lib/assimp/contrib/unzip/crypt.h       |   159 +-
 Engine/lib/assimp/contrib/unzip/ioapi.c       |   408 +-
 Engine/lib/assimp/contrib/unzip/ioapi.h       |   144 +-
 Engine/lib/assimp/contrib/unzip/unzip.c       |  2959 ++--
 Engine/lib/assimp/contrib/unzip/unzip.h       |   500 +-
 .../contrib/utf8cpp/source/utf8/checked.h     |    62 +-
 .../assimp/contrib/utf8cpp/source/utf8/core.h |    43 +-
 .../contrib/utf8cpp/source/utf8/cpp11.h       |   103 +
 .../contrib/utf8cpp/source/utf8/unchecked.h   |    78 +-
 Engine/lib/assimp/contrib/zip/.travis.sh      |     2 +-
 Engine/lib/assimp/contrib/zip/.travis.yml     |     2 +-
 Engine/lib/assimp/contrib/zip/CMakeLists.txt  |   115 +-
 Engine/lib/assimp/contrib/zip/README.md       |   208 +-
 Engine/lib/assimp/contrib/zip/src/miniz.h     |   531 +-
 Engine/lib/assimp/contrib/zip/src/zip.c       |  1175 +-
 Engine/lib/assimp/contrib/zip/src/zip.h       |   551 +-
 .../assimp/contrib/zip/test/CMakeLists.txt    |    51 +-
 Engine/lib/assimp/contrib/zip/test/test.c     |    42 +-
 .../lib/assimp/contrib/zip/test/test_miniz.c  |    25 +-
 Engine/lib/assimp/contrib/zlib/CMakeLists.txt |    15 +-
 .../contrib/zlib/contrib/blast/test.txt       |     2 +-
 .../zlib/contrib/dotzlib/LICENSE_1_0.txt      |     2 +-
 .../zlib/contrib/testzlib/testzlib.txt        |     2 +-
 Engine/lib/assimp/contrib/zlib_note.txt       |     2 +-
 Engine/lib/assimp/include/assimp/Base64.hpp   |    68 +
 .../lib/assimp/include/assimp/BaseImporter.h  |   242 +-
 Engine/lib/assimp/include/assimp/Bitmap.h     |    62 +-
 .../lib/assimp/include/assimp/BlobIOSystem.h  |   237 +-
 .../lib/assimp/include/assimp/ByteSwapper.h   |    41 +-
 .../assimp/{Defines.h => ColladaMetaData.h}   |    21 +-
 .../assimp/include/assimp/Compiler/poppack1.h |     6 +-
 .../include/assimp/Compiler/pushpack1.h       |     6 +-
 .../assimp/include/assimp/CreateAnimMesh.h    |    29 +-
 .../assimp/include/assimp/DefaultIOStream.h   |    67 +-
 .../assimp/include/assimp/DefaultIOSystem.h   |    22 +-
 .../assimp/include/assimp/DefaultLogger.hpp   |    71 +-
 .../lib/assimp/include/assimp/Exceptional.h   |   127 +-
 Engine/lib/assimp/include/assimp/Exporter.hpp |   142 +-
 .../assimp/include/assimp/GenericProperty.h   |    46 +-
 .../lib/assimp/include/assimp/GltfMaterial.h  |    74 +
 Engine/lib/assimp/include/assimp/Hash.h       |    18 +-
 Engine/lib/assimp/include/assimp/IOStream.hpp |    16 +-
 .../assimp/include/assimp/IOStreamBuffer.h    |   227 +-
 Engine/lib/assimp/include/assimp/IOSystem.hpp |    71 +-
 Engine/lib/assimp/include/assimp/Importer.hpp |   238 +-
 .../lib/assimp/include/assimp/LineSplitter.h  |    68 +-
 Engine/lib/assimp/include/assimp/LogAux.h     |    70 +-
 .../lib/assimp/include/assimp/LogStream.hpp   |    31 +-
 Engine/lib/assimp/include/assimp/Logger.hpp   |   158 +-
 .../lib/assimp/include/assimp/MathFunctions.h |    47 +-
 .../assimp/include/assimp/MemoryIOWrapper.h   |    16 +-
 .../lib/assimp/include/assimp/NullLogger.hpp  |    14 +-
 .../lib/assimp/include/assimp/ObjMaterial.h   |    84 +
 .../lib/assimp/include/assimp/ParsingUtils.h  |   163 +-
 Engine/lib/assimp/include/assimp/Profiler.h   |    20 +-
 .../assimp/include/assimp/ProgressHandler.hpp |    13 +-
 .../assimp/include/assimp/RemoveComments.h    |    10 +-
 .../lib/assimp/include/assimp/SGSpatialSort.h |     7 +-
 .../lib/assimp/include/assimp/SceneCombiner.h |   206 +-
 .../include/assimp/SkeletonMeshBuilder.h      |    43 +-
 .../lib/assimp/include/assimp/SmallVector.h   |   164 +
 .../assimp/include/assimp/SmoothingGroups.h   |     8 +-
 .../assimp/include/assimp/SmoothingGroups.inl |    31 +-
 .../lib/assimp/include/assimp/SpatialSort.h   |    76 +-
 .../assimp/include/assimp/StandardShapes.h    |    10 +-
 .../lib/assimp/include/assimp/StreamReader.h  |   181 +-
 .../lib/assimp/include/assimp/StreamWriter.h  |    10 +-
 .../assimp/include/assimp/StringComparison.h  |   103 +-
 .../lib/assimp/include/assimp/StringUtils.h   |   224 +-
 .../lib/assimp/include/assimp/Subdivision.h   |     7 +-
 .../lib/assimp/include/assimp/TinyFormatter.h |    71 +-
 Engine/lib/assimp/include/assimp/Vertex.h     |    79 +-
 Engine/lib/assimp/include/assimp/XMLTools.h   |     7 +-
 Engine/lib/assimp/include/assimp/XmlParser.h  |   493 +
 .../include/assimp/ZipArchiveIOSystem.h       |    59 +-
 Engine/lib/assimp/include/assimp/aabb.h       |    33 +-
 Engine/lib/assimp/include/assimp/ai_assert.h  |    35 +-
 Engine/lib/assimp/include/assimp/anim.h       |   277 +-
 Engine/lib/assimp/include/assimp/camera.h     |    49 +-
 Engine/lib/assimp/include/assimp/cexport.h    |   126 +-
 Engine/lib/assimp/include/assimp/cfileio.h    |    13 +-
 Engine/lib/assimp/include/assimp/cimport.h    |   836 +-
 Engine/lib/assimp/include/assimp/color4.h     |    17 +-
 Engine/lib/assimp/include/assimp/color4.inl   |    98 +-
 .../assimp/include/assimp/commonMetaData.h    |    69 +
 Engine/lib/assimp/include/assimp/config.h     |  1018 --
 Engine/lib/assimp/include/assimp/config.h.in  |   123 +-
 Engine/lib/assimp/include/assimp/defs.h       |   256 +-
 Engine/lib/assimp/include/assimp/fast_atof.h  |    40 +-
 .../lib/assimp/include/assimp/importerdesc.h  |    38 +-
 .../lib/assimp/include/assimp/irrXMLWrapper.h |   149 -
 Engine/lib/assimp/include/assimp/light.h      |    23 +-
 Engine/lib/assimp/include/assimp/material.h   |  1079 +-
 Engine/lib/assimp/include/assimp/material.inl |   310 +-
 Engine/lib/assimp/include/assimp/matrix3x3.h  |    29 +-
 .../lib/assimp/include/assimp/matrix3x3.inl   |    76 +-
 Engine/lib/assimp/include/assimp/matrix4x4.h  |    24 +-
 .../lib/assimp/include/assimp/matrix4x4.inl   |   172 +-
 Engine/lib/assimp/include/assimp/mesh.h       |   450 +-
 Engine/lib/assimp/include/assimp/metadata.h   |   441 +-
 .../lib/assimp/include/assimp/pbrmaterial.h   |    66 +-
 .../port/AndroidJNI/AndroidJNIIOSystem.h      |    26 +-
 .../port/AndroidJNI/BundledAssetIOSystem.h    |    93 +
 .../lib/assimp/include/assimp/postprocess.h   |    38 +-
 Engine/lib/assimp/include/assimp/qnan.h       |    33 +-
 Engine/lib/assimp/include/assimp/quaternion.h |    18 +-
 .../lib/assimp/include/assimp/quaternion.inl  |    30 +-
 Engine/lib/assimp/include/assimp/revision.h   |    28 -
 Engine/lib/assimp/include/assimp/scene.h      |    96 +-
 Engine/lib/assimp/include/assimp/texture.h    |    37 +-
 Engine/lib/assimp/include/assimp/types.h      |   295 +-
 Engine/lib/assimp/include/assimp/vector2.h    |    10 +-
 Engine/lib/assimp/include/assimp/vector2.inl  |    22 +-
 Engine/lib/assimp/include/assimp/vector3.h    |    49 +-
 Engine/lib/assimp/include/assimp/vector3.inl  |   101 +-
 Engine/lib/assimp/include/assimp/version.h    |    19 +-
 1150 files changed, 165834 insertions(+), 112019 deletions(-)
 create mode 100644 Engine/lib/assimp/CHANGES
 create mode 100644 Engine/lib/assimp/CREDITS
 create mode 100644 Engine/lib/assimp/LICENSE
 create mode 100644 Engine/lib/assimp/Readme.md
 delete mode 100644 Engine/lib/assimp/code/3DS/3DSHelper.h
 delete mode 100644 Engine/lib/assimp/code/3MF/3MFXmlTags.h
 delete mode 100644 Engine/lib/assimp/code/3MF/D3MFImporter.cpp
 delete mode 100644 Engine/lib/assimp/code/3MF/D3MFOpcPackage.cpp
 delete mode 100644 Engine/lib/assimp/code/AMF/AMFImporter.cpp
 delete mode 100644 Engine/lib/assimp/code/AMF/AMFImporter.hpp
 delete mode 100644 Engine/lib/assimp/code/AMF/AMFImporter_Geometry.cpp
 delete mode 100644 Engine/lib/assimp/code/AMF/AMFImporter_Macro.hpp
 delete mode 100644 Engine/lib/assimp/code/AMF/AMFImporter_Node.hpp
 delete mode 100644 Engine/lib/assimp/code/AMF/AMFImporter_Postprocess.cpp
 delete mode 100644 Engine/lib/assimp/code/Assbin/AssbinExporter.cpp
 rename Engine/lib/assimp/code/{ => AssetLib}/3DS/3DSConverter.cpp (58%)
 rename Engine/lib/assimp/code/{ => AssetLib}/3DS/3DSExporter.cpp (65%)
 rename Engine/lib/assimp/code/{ => AssetLib}/3DS/3DSExporter.h (96%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/3DS/3DSHelper.h
 rename Engine/lib/assimp/code/{ => AssetLib}/3DS/3DSLoader.cpp (67%)
 rename Engine/lib/assimp/code/{ => AssetLib}/3DS/3DSLoader.h (92%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/3MF/3MFTypes.h
 create mode 100644 Engine/lib/assimp/code/AssetLib/3MF/3MFXmlTags.h
 rename Engine/lib/assimp/code/{ => AssetLib}/3MF/D3MFExporter.cpp (50%)
 rename Engine/lib/assimp/code/{ => AssetLib}/3MF/D3MFExporter.h (89%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/3MF/D3MFImporter.cpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/3MF/D3MFImporter.h
 create mode 100644 Engine/lib/assimp/code/AssetLib/3MF/D3MFOpcPackage.cpp
 rename Engine/lib/assimp/code/{ => AssetLib}/3MF/D3MFOpcPackage.h (83%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/3MF/XmlSerializer.cpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/3MF/XmlSerializer.h
 rename Engine/lib/assimp/code/{ => AssetLib}/AC/ACLoader.cpp (52%)
 rename Engine/lib/assimp/code/{ => AssetLib}/AC/ACLoader.h (73%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/AMF/AMFImporter.cpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/AMF/AMFImporter.hpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/AMF/AMFImporter_Geometry.cpp
 rename Engine/lib/assimp/code/{ => AssetLib}/AMF/AMFImporter_Material.cpp (50%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/AMF/AMFImporter_Node.hpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/AMF/AMFImporter_Postprocess.cpp
 rename Engine/lib/assimp/code/{ => AssetLib}/ASE/ASELoader.cpp (63%)
 rename Engine/lib/assimp/code/{ => AssetLib}/ASE/ASELoader.h (96%)
 rename Engine/lib/assimp/code/{ => AssetLib}/ASE/ASEParser.cpp (58%)
 rename Engine/lib/assimp/code/{ => AssetLib}/ASE/ASEParser.h (81%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/Assbin/AssbinExporter.cpp
 rename Engine/lib/assimp/code/{ => AssetLib}/Assbin/AssbinExporter.h (95%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/Assbin/AssbinFileWriter.cpp
 rename Engine/lib/assimp/code/{3MF/D3MFImporter.h => AssetLib/Assbin/AssbinFileWriter.h} (74%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Assbin/AssbinLoader.cpp (56%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Assbin/AssbinLoader.h (90%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Assjson/cencode.c (87%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Assjson/cencode.h (91%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Assjson/json_exporter.cpp (77%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Assjson/mesh_splitter.cpp (96%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Assjson/mesh_splitter.h (59%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/Assxml/AssxmlExporter.cpp
 rename Engine/lib/assimp/code/{ => AssetLib}/Assxml/AssxmlExporter.h (97%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/Assxml/AssxmlFileWriter.cpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/Assxml/AssxmlFileWriter.h
 create mode 100644 Engine/lib/assimp/code/AssetLib/B3D/B3DImporter.cpp
 rename Engine/lib/assimp/code/{ => AssetLib}/B3D/B3DImporter.h (85%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/BVH/BVHLoader.cpp
 rename Engine/lib/assimp/code/{ => AssetLib}/BVH/BVHLoader.h (80%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Blender/BlenderBMesh.cpp (54%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Blender/BlenderBMesh.h (98%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/Blender/BlenderCustomData.cpp
 rename Engine/lib/assimp/code/{ => AssetLib}/Blender/BlenderCustomData.h (100%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Blender/BlenderDNA.cpp (69%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Blender/BlenderDNA.h (74%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Blender/BlenderDNA.inl (93%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Blender/BlenderIntermediate.h (99%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Blender/BlenderLoader.cpp (57%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/Blender/BlenderLoader.h
 rename Engine/lib/assimp/code/{ => AssetLib}/Blender/BlenderModifier.cpp (56%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Blender/BlenderModifier.h (93%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/Blender/BlenderScene.cpp
 rename Engine/lib/assimp/code/{ => AssetLib}/Blender/BlenderScene.h (66%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Blender/BlenderSceneGen.h (97%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Blender/BlenderTessellator.cpp (98%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Blender/BlenderTessellator.h (99%)
 rename Engine/lib/assimp/code/{ => AssetLib}/C4D/C4DImporter.cpp (92%)
 rename Engine/lib/assimp/code/{ => AssetLib}/C4D/C4DImporter.h (73%)
 rename Engine/lib/assimp/code/{ => AssetLib}/COB/COBLoader.cpp (51%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/COB/COBLoader.h
 rename Engine/lib/assimp/code/{ => AssetLib}/COB/COBScene.h (98%)
 rename Engine/lib/assimp/code/{ => AssetLib}/CSM/CSMLoader.cpp (95%)
 rename Engine/lib/assimp/code/{ => AssetLib}/CSM/CSMLoader.h (85%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/Collada/ColladaExporter.cpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/Collada/ColladaExporter.h
 create mode 100644 Engine/lib/assimp/code/AssetLib/Collada/ColladaHelper.cpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/Collada/ColladaHelper.h
 rename Engine/lib/assimp/code/{ => AssetLib}/Collada/ColladaLoader.cpp (69%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Collada/ColladaLoader.h (57%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/Collada/ColladaParser.cpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/Collada/ColladaParser.h
 rename Engine/lib/assimp/code/{ => AssetLib}/DXF/DXFHelper.h (97%)
 rename Engine/lib/assimp/code/{ => AssetLib}/DXF/DXFLoader.cpp (95%)
 rename Engine/lib/assimp/code/{ => AssetLib}/DXF/DXFLoader.h (93%)
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXAnimation.cpp (59%)
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXBinaryTokenizer.cpp (94%)
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXCommon.h (61%)
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXCompileConfig.h (85%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/FBX/FBXConverter.cpp
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXConverter.h (82%)
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXDeformer.cpp (99%)
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXDocument.cpp (89%)
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXDocument.h (95%)
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXDocumentUtil.cpp (91%)
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXDocumentUtil.h (99%)
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXExportNode.cpp (88%)
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXExportNode.h (98%)
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXExportProperty.cpp (99%)
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXExportProperty.h (99%)
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXExporter.cpp (88%)
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXExporter.h (93%)
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXImportSettings.h (88%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/FBX/FBXImporter.cpp
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXImporter.h (77%)
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXMaterial.cpp (83%)
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXMeshGeometry.cpp (90%)
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXMeshGeometry.h (96%)
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXModel.cpp (64%)
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXNodeAttribute.cpp (99%)
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXParser.cpp (92%)
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXParser.h (96%)
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXProperties.cpp (78%)
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXProperties.h (98%)
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXTokenizer.cpp (95%)
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXTokenizer.h (98%)
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXUtil.cpp (88%)
 rename Engine/lib/assimp/code/{ => AssetLib}/FBX/FBXUtil.h (78%)
 rename Engine/lib/assimp/code/{ => AssetLib}/HMP/HMPFileData.h (99%)
 rename Engine/lib/assimp/code/{ => AssetLib}/HMP/HMPLoader.cpp (53%)
 rename Engine/lib/assimp/code/{ => AssetLib}/HMP/HMPLoader.h (83%)
 rename Engine/lib/assimp/code/{ => AssetLib}/HMP/HalfLifeFileData.h (99%)
 rename Engine/lib/assimp/code/{Importer => AssetLib}/IFC/IFCBoolean.cpp (72%)
 rename Engine/lib/assimp/code/{Importer => AssetLib}/IFC/IFCCurve.cpp (96%)
 rename Engine/lib/assimp/code/{Importer => AssetLib}/IFC/IFCGeometry.cpp (88%)
 rename Engine/lib/assimp/code/{Importer => AssetLib}/IFC/IFCLoader.cpp (56%)
 rename Engine/lib/assimp/code/{Importer => AssetLib}/IFC/IFCLoader.h (74%)
 rename Engine/lib/assimp/code/{Importer => AssetLib}/IFC/IFCMaterial.cpp (95%)
 rename Engine/lib/assimp/code/{Importer => AssetLib}/IFC/IFCOpenings.cpp (82%)
 rename Engine/lib/assimp/code/{Importer => AssetLib}/IFC/IFCProfile.cpp (96%)
 rename Engine/lib/assimp/code/{Importer => AssetLib}/IFC/IFCReaderGen1_2x3.cpp (91%)
 rename Engine/lib/assimp/code/{Importer => AssetLib}/IFC/IFCReaderGen2_2x3.cpp (98%)
 rename Engine/lib/assimp/code/{Importer => AssetLib}/IFC/IFCReaderGen_2x3.h (99%)
 rename Engine/lib/assimp/code/{Importer => AssetLib}/IFC/IFCReaderGen_4.cpp (98%)
 rename Engine/lib/assimp/code/{Importer => AssetLib}/IFC/IFCReaderGen_4.h (99%)
 rename Engine/lib/assimp/code/{Importer => AssetLib}/IFC/IFCUtil.cpp (96%)
 rename Engine/lib/assimp/code/{Importer => AssetLib}/IFC/IFCUtil.h (96%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/IQM/IQMImporter.cpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/IQM/IQMImporter.h
 create mode 100644 Engine/lib/assimp/code/AssetLib/IQM/iqm.h
 create mode 100644 Engine/lib/assimp/code/AssetLib/Irr/IRRLoader.cpp
 rename Engine/lib/assimp/code/{ => AssetLib}/Irr/IRRLoader.h (90%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/Irr/IRRMeshLoader.cpp
 rename Engine/lib/assimp/code/{ => AssetLib}/Irr/IRRMeshLoader.h (89%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/Irr/IRRShared.cpp
 rename Engine/lib/assimp/code/{ => AssetLib}/Irr/IRRShared.h (51%)
 rename Engine/lib/assimp/code/{ => AssetLib}/LWO/LWOAnimation.cpp (55%)
 rename Engine/lib/assimp/code/{ => AssetLib}/LWO/LWOAnimation.h (98%)
 rename Engine/lib/assimp/code/{ => AssetLib}/LWO/LWOBLoader.cpp (99%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/LWO/LWOFileData.h
 create mode 100644 Engine/lib/assimp/code/AssetLib/LWO/LWOLoader.cpp
 rename Engine/lib/assimp/code/{ => AssetLib}/LWO/LWOLoader.h (72%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/LWO/LWOMaterial.cpp
 rename Engine/lib/assimp/code/{ => AssetLib}/LWS/LWSLoader.cpp (63%)
 rename Engine/lib/assimp/code/{ => AssetLib}/LWS/LWSLoader.h (72%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/M3D/M3DExporter.cpp
 rename Engine/lib/assimp/code/{glTF/glTFExporter.h => AssetLib/M3D/M3DExporter.h} (54%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/M3D/M3DImporter.cpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/M3D/M3DImporter.h
 create mode 100644 Engine/lib/assimp/code/AssetLib/M3D/M3DMaterials.h
 create mode 100644 Engine/lib/assimp/code/AssetLib/M3D/M3DWrapper.cpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/M3D/M3DWrapper.h
 create mode 100644 Engine/lib/assimp/code/AssetLib/M3D/m3d.h
 rename Engine/lib/assimp/code/{ => AssetLib}/MD2/MD2FileData.h (99%)
 rename Engine/lib/assimp/code/{ => AssetLib}/MD2/MD2Loader.cpp (89%)
 rename Engine/lib/assimp/code/{ => AssetLib}/MD2/MD2Loader.h (86%)
 rename Engine/lib/assimp/code/{ => AssetLib}/MD2/MD2NormalTable.h (99%)
 rename Engine/lib/assimp/code/{ => AssetLib}/MD3/MD3FileData.h (98%)
 rename Engine/lib/assimp/code/{ => AssetLib}/MD3/MD3Loader.cpp (63%)
 rename Engine/lib/assimp/code/{ => AssetLib}/MD3/MD3Loader.h (81%)
 rename Engine/lib/assimp/code/{ => AssetLib}/MD4/MD4FileData.h (99%)
 rename Engine/lib/assimp/code/{ => AssetLib}/MD5/MD5Loader.cpp (60%)
 rename Engine/lib/assimp/code/{ => AssetLib}/MD5/MD5Loader.h (81%)
 rename Engine/lib/assimp/code/{ => AssetLib}/MD5/MD5Parser.cpp (53%)
 rename Engine/lib/assimp/code/{ => AssetLib}/MD5/MD5Parser.h (99%)
 rename Engine/lib/assimp/code/{ => AssetLib}/MDC/MDCFileData.h (98%)
 rename Engine/lib/assimp/code/{ => AssetLib}/MDC/MDCLoader.cpp (52%)
 rename Engine/lib/assimp/code/{ => AssetLib}/MDC/MDCLoader.h (86%)
 rename Engine/lib/assimp/code/{ => AssetLib}/MDC/MDCNormalTable.h (99%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/MDL/HalfLife/HL1FileData.h
 create mode 100644 Engine/lib/assimp/code/AssetLib/MDL/HalfLife/HL1ImportDefinitions.h
 create mode 100644 Engine/lib/assimp/code/AssetLib/MDL/HalfLife/HL1ImportSettings.h
 create mode 100644 Engine/lib/assimp/code/AssetLib/MDL/HalfLife/HL1MDLLoader.cpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/MDL/HalfLife/HL1MDLLoader.h
 create mode 100644 Engine/lib/assimp/code/AssetLib/MDL/HalfLife/HL1MeshTrivert.h
 rename Engine/lib/assimp/code/{Importer/StepFile/StepFileImporter.h => AssetLib/MDL/HalfLife/HalfLifeMDLBaseHeader.h} (74%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/MDL/HalfLife/LogFunctions.h
 create mode 100644 Engine/lib/assimp/code/AssetLib/MDL/HalfLife/UniqueNameGenerator.cpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/MDL/HalfLife/UniqueNameGenerator.h
 rename Engine/lib/assimp/code/{ => AssetLib}/MDL/MDLDefaultColorMap.h (99%)
 rename Engine/lib/assimp/code/{ => AssetLib}/MDL/MDLFileData.h (99%)
 rename Engine/lib/assimp/code/{ => AssetLib}/MDL/MDLLoader.cpp (56%)
 rename Engine/lib/assimp/code/{ => AssetLib}/MDL/MDLLoader.h (95%)
 rename Engine/lib/assimp/code/{ => AssetLib}/MDL/MDLMaterialLoader.cpp (59%)
 rename Engine/lib/assimp/code/{ => AssetLib}/MMD/MMDCpp14.h (98%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/MMD/MMDImporter.cpp
 rename Engine/lib/assimp/code/{ => AssetLib}/MMD/MMDImporter.h (94%)
 rename Engine/lib/assimp/code/{ => AssetLib}/MMD/MMDPmdParser.h (98%)
 rename Engine/lib/assimp/code/{ => AssetLib}/MMD/MMDPmxParser.cpp (97%)
 rename Engine/lib/assimp/code/{ => AssetLib}/MMD/MMDPmxParser.h (99%)
 rename Engine/lib/assimp/code/{ => AssetLib}/MMD/MMDVmdParser.h (97%)
 rename Engine/lib/assimp/code/{ => AssetLib}/MS3D/MS3DLoader.cpp (90%)
 rename Engine/lib/assimp/code/{ => AssetLib}/MS3D/MS3DLoader.h (78%)
 rename Engine/lib/assimp/code/{ => AssetLib}/NDO/NDOLoader.cpp (94%)
 rename Engine/lib/assimp/code/{ => AssetLib}/NDO/NDOLoader.h (84%)
 rename Engine/lib/assimp/code/{ => AssetLib}/NFF/NFFLoader.cpp (54%)
 rename Engine/lib/assimp/code/{ => AssetLib}/NFF/NFFLoader.h (68%)
 rename Engine/lib/assimp/code/{ => AssetLib}/OFF/OFFLoader.cpp (94%)
 rename Engine/lib/assimp/code/{ => AssetLib}/OFF/OFFLoader.h (86%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Ogre/OgreBinarySerializer.cpp (66%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/Ogre/OgreBinarySerializer.h
 rename Engine/lib/assimp/code/{ => AssetLib}/Ogre/OgreImporter.cpp (68%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Ogre/OgreImporter.h (87%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Ogre/OgreMaterial.cpp (60%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Ogre/OgreParsingUtils.h (57%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Ogre/OgreStructs.cpp (57%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Ogre/OgreStructs.h (99%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/Ogre/OgreXmlSerializer.cpp
 rename Engine/lib/assimp/code/{ => AssetLib}/Ogre/OgreXmlSerializer.h (54%)
 rename Engine/lib/assimp/code/{ => AssetLib}/OpenGEX/OpenGEXExporter.cpp (98%)
 rename Engine/lib/assimp/code/{ => AssetLib}/OpenGEX/OpenGEXExporter.h (97%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/OpenGEX/OpenGEXImporter.cpp
 rename Engine/lib/assimp/code/{ => AssetLib}/OpenGEX/OpenGEXImporter.h (91%)
 rename Engine/lib/assimp/code/{ => AssetLib}/OpenGEX/OpenGEXStructs.h (99%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Ply/PlyExporter.cpp (98%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Ply/PlyExporter.h (98%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Ply/PlyLoader.cpp (57%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Ply/PlyLoader.h (77%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/Ply/PlyParser.cpp
 rename Engine/lib/assimp/code/{ => AssetLib}/Ply/PlyParser.h (99%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Q3BSP/Q3BSPFileData.h (98%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/Q3BSP/Q3BSPFileImporter.cpp
 rename Engine/lib/assimp/code/{ => AssetLib}/Q3BSP/Q3BSPFileImporter.h (91%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Q3BSP/Q3BSPFileParser.cpp (99%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Q3BSP/Q3BSPFileParser.h (95%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/Q3D/Q3DLoader.cpp
 rename Engine/lib/assimp/code/{ => AssetLib}/Q3D/Q3DLoader.h (84%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Raw/RawLoader.cpp (56%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Raw/RawLoader.h (87%)
 rename Engine/lib/assimp/code/{ => AssetLib}/SIB/SIBImporter.cpp (70%)
 rename Engine/lib/assimp/code/{ => AssetLib}/SIB/SIBImporter.h (86%)
 rename Engine/lib/assimp/code/{ => AssetLib}/SMD/SMDLoader.cpp (97%)
 rename Engine/lib/assimp/code/{ => AssetLib}/SMD/SMDLoader.h (94%)
 rename Engine/lib/assimp/code/{Importer => AssetLib}/STEPParser/STEPFileEncoding.cpp (99%)
 rename Engine/lib/assimp/code/{Importer => AssetLib}/STEPParser/STEPFileEncoding.h (98%)
 rename Engine/lib/assimp/code/{Importer => AssetLib}/STEPParser/STEPFileReader.cpp (94%)
 rename Engine/lib/assimp/code/{Importer => AssetLib}/STEPParser/STEPFileReader.h (97%)
 rename Engine/lib/assimp/code/{ => AssetLib}/STL/STLExporter.cpp (97%)
 rename Engine/lib/assimp/code/{ => AssetLib}/STL/STLExporter.h (86%)
 rename Engine/lib/assimp/code/{ => AssetLib}/STL/STLLoader.cpp (60%)
 rename Engine/lib/assimp/code/{ => AssetLib}/STL/STLLoader.h (92%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/Step/STEPFile.h
 rename Engine/lib/assimp/code/{ => AssetLib}/Step/StepExporter.cpp (76%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Step/StepExporter.h (98%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Terragen/TerragenLoader.cpp (58%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Terragen/TerragenLoader.h (75%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Unreal/UnrealLoader.cpp (53%)
 rename Engine/lib/assimp/code/{ => AssetLib}/Unreal/UnrealLoader.h (52%)
 rename Engine/lib/assimp/code/{ => AssetLib}/X/XFileExporter.cpp (99%)
 rename Engine/lib/assimp/code/{ => AssetLib}/X/XFileExporter.h (96%)
 rename Engine/lib/assimp/code/{ => AssetLib}/X/XFileHelper.h (72%)
 rename Engine/lib/assimp/code/{ => AssetLib}/X/XFileImporter.cpp (93%)
 rename Engine/lib/assimp/code/{ => AssetLib}/X/XFileImporter.h (95%)
 rename Engine/lib/assimp/code/{ => AssetLib}/X/XFileParser.cpp (50%)
 rename Engine/lib/assimp/code/{ => AssetLib}/X/XFileParser.h (96%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/X3D/X3DExporter.cpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/X3D/X3DExporter.hpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/X3D/X3DGeoHelper.cpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/X3D/X3DGeoHelper.h
 create mode 100644 Engine/lib/assimp/code/AssetLib/X3D/X3DImporter.cpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/X3D/X3DImporter.hpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Geometry2D.cpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Geometry3D.cpp
 rename Engine/lib/assimp/code/{ => AssetLib}/X3D/X3DImporter_Group.cpp (50%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Light.cpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Macro.hpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Metadata.cpp
 rename Engine/lib/assimp/code/{ => AssetLib}/X3D/X3DImporter_Networking.cpp (52%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Node.hpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Postprocess.cpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Rendering.cpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Shape.cpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Texturing.cpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/X3D/X3DXmlHelper.cpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/X3D/X3DXmlHelper.h
 create mode 100644 Engine/lib/assimp/code/AssetLib/XGL/XGLLoader.cpp
 rename Engine/lib/assimp/code/{ => AssetLib}/XGL/XGLLoader.h (63%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/glTF/glTFAsset.h
 create mode 100644 Engine/lib/assimp/code/AssetLib/glTF/glTFAsset.inl
 rename Engine/lib/assimp/code/{ => AssetLib}/glTF/glTFAssetWriter.h (95%)
 rename Engine/lib/assimp/code/{ => AssetLib}/glTF/glTFAssetWriter.inl (92%)
 rename Engine/lib/assimp/code/{ => AssetLib}/glTF/glTFCommon.cpp (53%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/glTF/glTFCommon.h
 rename Engine/lib/assimp/code/{ => AssetLib}/glTF/glTFExporter.cpp (89%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/glTF/glTFExporter.h
 rename Engine/lib/assimp/code/{ => AssetLib}/glTF/glTFImporter.cpp (55%)
 rename Engine/lib/assimp/code/{ => AssetLib}/glTF/glTFImporter.h (74%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/glTF2/glTF2Asset.h
 create mode 100644 Engine/lib/assimp/code/AssetLib/glTF2/glTF2Asset.inl
 rename Engine/lib/assimp/code/{ => AssetLib}/glTF2/glTF2AssetWriter.h (90%)
 rename Engine/lib/assimp/code/{ => AssetLib}/glTF2/glTF2AssetWriter.inl (68%)
 create mode 100644 Engine/lib/assimp/code/AssetLib/glTF2/glTF2Exporter.cpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/glTF2/glTF2Exporter.h
 create mode 100644 Engine/lib/assimp/code/AssetLib/glTF2/glTF2Importer.cpp
 rename Engine/lib/assimp/code/{ => AssetLib}/glTF2/glTF2Importer.h (67%)
 delete mode 100644 Engine/lib/assimp/code/Assxml/AssxmlExporter.cpp
 delete mode 100644 Engine/lib/assimp/code/B3D/B3DImporter.cpp
 delete mode 100644 Engine/lib/assimp/code/BVH/BVHLoader.cpp
 delete mode 100644 Engine/lib/assimp/code/Blender/BlenderCustomData.cpp
 delete mode 100644 Engine/lib/assimp/code/Blender/BlenderLoader.h
 delete mode 100644 Engine/lib/assimp/code/Blender/BlenderScene.cpp
 delete mode 100644 Engine/lib/assimp/code/COB/COBLoader.h
 delete mode 100644 Engine/lib/assimp/code/Collada/ColladaExporter.cpp
 delete mode 100644 Engine/lib/assimp/code/Collada/ColladaExporter.h
 delete mode 100644 Engine/lib/assimp/code/Collada/ColladaHelper.h
 delete mode 100644 Engine/lib/assimp/code/Collada/ColladaParser.cpp
 delete mode 100644 Engine/lib/assimp/code/Collada/ColladaParser.h
 create mode 100644 Engine/lib/assimp/code/Common/AssertHandler.cpp
 create mode 100644 Engine/lib/assimp/code/Common/AssertHandler.h
 create mode 100644 Engine/lib/assimp/code/Common/Base64.cpp
 create mode 100644 Engine/lib/assimp/code/Common/Compression.cpp
 create mode 100644 Engine/lib/assimp/code/Common/Compression.h
 rename Engine/lib/assimp/{include/assimp/Macros.h => code/Common/Exceptional.cpp} (86%)
 create mode 100644 Engine/lib/assimp/code/Common/IOSystem.cpp
 create mode 100644 Engine/lib/assimp/code/Common/material.cpp
 delete mode 100644 Engine/lib/assimp/code/FBX/FBXConverter.cpp
 delete mode 100644 Engine/lib/assimp/code/FBX/FBXImporter.cpp
 delete mode 100644 Engine/lib/assimp/code/Importer/StepFile/StepFileGen1.cpp
 delete mode 100644 Engine/lib/assimp/code/Importer/StepFile/StepFileGen2.cpp
 delete mode 100644 Engine/lib/assimp/code/Importer/StepFile/StepFileGen3.cpp
 delete mode 100644 Engine/lib/assimp/code/Importer/StepFile/StepFileImporter.cpp
 delete mode 100644 Engine/lib/assimp/code/Importer/StepFile/StepReaderGen.h
 delete mode 100644 Engine/lib/assimp/code/Irr/IRRLoader.cpp
 delete mode 100644 Engine/lib/assimp/code/Irr/IRRMeshLoader.cpp
 delete mode 100644 Engine/lib/assimp/code/Irr/IRRShared.cpp
 delete mode 100644 Engine/lib/assimp/code/LWO/LWOFileData.h
 delete mode 100644 Engine/lib/assimp/code/LWO/LWOLoader.cpp
 delete mode 100644 Engine/lib/assimp/code/LWO/LWOMaterial.cpp
 delete mode 100644 Engine/lib/assimp/code/MMD/MMDImporter.cpp
 delete mode 100644 Engine/lib/assimp/code/Obj/ObjExporter.cpp
 delete mode 100644 Engine/lib/assimp/code/Obj/ObjExporter.h
 delete mode 100644 Engine/lib/assimp/code/Obj/ObjFileData.h
 delete mode 100644 Engine/lib/assimp/code/Obj/ObjFileImporter.cpp
 delete mode 100644 Engine/lib/assimp/code/Obj/ObjFileImporter.h
 delete mode 100644 Engine/lib/assimp/code/Obj/ObjFileMtlImporter.cpp
 delete mode 100644 Engine/lib/assimp/code/Obj/ObjFileMtlImporter.h
 delete mode 100644 Engine/lib/assimp/code/Obj/ObjFileParser.cpp
 delete mode 100644 Engine/lib/assimp/code/Obj/ObjFileParser.h
 delete mode 100644 Engine/lib/assimp/code/Obj/ObjTools.h
 delete mode 100644 Engine/lib/assimp/code/Ogre/OgreBinarySerializer.h
 delete mode 100644 Engine/lib/assimp/code/Ogre/OgreXmlSerializer.cpp
 delete mode 100644 Engine/lib/assimp/code/OpenGEX/OpenGEXImporter.cpp
 create mode 100644 Engine/lib/assimp/code/Pbrt/PbrtExporter.cpp
 create mode 100644 Engine/lib/assimp/code/Pbrt/PbrtExporter.h
 delete mode 100644 Engine/lib/assimp/code/Ply/PlyParser.cpp
 create mode 100644 Engine/lib/assimp/code/PostProcessing/ArmaturePopulate.cpp
 create mode 100644 Engine/lib/assimp/code/PostProcessing/ArmaturePopulate.h
 rename Engine/lib/assimp/code/{Common => PostProcessing}/SplitByBoneCountProcess.cpp (79%)
 rename Engine/lib/assimp/code/{Common => PostProcessing}/SplitByBoneCountProcess.h (98%)
 delete mode 100644 Engine/lib/assimp/code/Q3BSP/Q3BSPFileImporter.cpp
 delete mode 100644 Engine/lib/assimp/code/Q3D/Q3DLoader.cpp
 delete mode 100644 Engine/lib/assimp/code/Step/STEPFile.h
 delete mode 100644 Engine/lib/assimp/code/X3D/FIReader.cpp
 delete mode 100644 Engine/lib/assimp/code/X3D/FIReader.hpp
 delete mode 100644 Engine/lib/assimp/code/X3D/X3DExporter.cpp
 delete mode 100644 Engine/lib/assimp/code/X3D/X3DExporter.hpp
 delete mode 100644 Engine/lib/assimp/code/X3D/X3DImporter.cpp
 delete mode 100644 Engine/lib/assimp/code/X3D/X3DImporter.hpp
 delete mode 100644 Engine/lib/assimp/code/X3D/X3DImporter_Geometry2D.cpp
 delete mode 100644 Engine/lib/assimp/code/X3D/X3DImporter_Geometry3D.cpp
 delete mode 100644 Engine/lib/assimp/code/X3D/X3DImporter_Light.cpp
 delete mode 100644 Engine/lib/assimp/code/X3D/X3DImporter_Macro.hpp
 delete mode 100644 Engine/lib/assimp/code/X3D/X3DImporter_Metadata.cpp
 delete mode 100644 Engine/lib/assimp/code/X3D/X3DImporter_Node.hpp
 delete mode 100644 Engine/lib/assimp/code/X3D/X3DImporter_Postprocess.cpp
 delete mode 100644 Engine/lib/assimp/code/X3D/X3DImporter_Rendering.cpp
 delete mode 100644 Engine/lib/assimp/code/X3D/X3DImporter_Shape.cpp
 delete mode 100644 Engine/lib/assimp/code/X3D/X3DImporter_Texturing.cpp
 delete mode 100644 Engine/lib/assimp/code/X3D/X3DVocabulary.cpp
 delete mode 100644 Engine/lib/assimp/code/XGL/XGLLoader.cpp
 delete mode 100644 Engine/lib/assimp/code/glTF/glTFAsset.h
 delete mode 100644 Engine/lib/assimp/code/glTF/glTFAsset.inl
 delete mode 100644 Engine/lib/assimp/code/glTF/glTFCommon.h
 delete mode 100644 Engine/lib/assimp/code/glTF2/glTF2Asset.h
 delete mode 100644 Engine/lib/assimp/code/glTF2/glTF2Asset.inl
 delete mode 100644 Engine/lib/assimp/code/glTF2/glTF2Exporter.cpp
 delete mode 100644 Engine/lib/assimp/code/glTF2/glTF2Exporter.h
 delete mode 100644 Engine/lib/assimp/code/glTF2/glTF2Importer.cpp
 delete mode 100644 Engine/lib/assimp/contrib/CMakeLists.txt
 create mode 100644 Engine/lib/assimp/contrib/draco/.clang-format
 create mode 100644 Engine/lib/assimp/contrib/draco/.cmake-format.py
 create mode 100644 Engine/lib/assimp/contrib/draco/AUTHORS
 create mode 100644 Engine/lib/assimp/contrib/draco/BUILDING.md
 create mode 100644 Engine/lib/assimp/contrib/draco/CMAKE.md
 create mode 100644 Engine/lib/assimp/contrib/draco/CMakeLists.txt
 create mode 100644 Engine/lib/assimp/contrib/draco/CONTRIBUTING.md
 create mode 100644 Engine/lib/assimp/contrib/draco/LICENSE
 create mode 100644 Engine/lib/assimp/contrib/draco/README.md
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/DracoConfig.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/FindDraco.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/compiler_flags.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/compiler_tests.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/draco-config.cmake.template
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/draco.pc.template
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/draco_build_definitions.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/draco_cpu_detection.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/draco_emscripten.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/draco_flags.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/draco_helpers.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/draco_install.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/draco_intrinsics.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/draco_options.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/draco_sanitizer.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/draco_targets.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/draco_test_config.h.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/draco_tests.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/draco_variables.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/sanitizers.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/toolchains/aarch64-linux-gnu.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/toolchains/android-ndk-common.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/toolchains/android.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/toolchains/arm-ios-common.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/toolchains/arm-linux-gnueabihf.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/toolchains/arm64-android-ndk-libcpp.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/toolchains/arm64-ios.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/toolchains/arm64-linux-gcc.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/toolchains/armv7-android-ndk-libcpp.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/toolchains/armv7-ios.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/toolchains/armv7-linux-gcc.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/toolchains/armv7s-ios.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/toolchains/i386-ios.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/toolchains/x86-android-ndk-libcpp.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/toolchains/x86_64-android-ndk-libcpp.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/toolchains/x86_64-ios.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/cmake/util.cmake
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation_decoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation_encoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation_encoding_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_octahedron_transform.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_octahedron_transform.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_quantization_transform.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_quantization_transform.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_transform.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_transform.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_transform_data.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_transform_type.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/attributes/geometry_attribute.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/attributes/geometry_attribute.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/attributes/geometry_indices.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/attributes/point_attribute.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/attributes/point_attribute.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/attributes/point_attribute_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/attributes_decoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/attributes_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/attributes_decoder_interface.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/attributes_encoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/attributes_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_decoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_encoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_shared.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/linear_sequencer.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/mesh_attribute_indices_encoding_data.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/normal_compression_utils.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/point_d_vector.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/point_d_vector_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/points_sequencer.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_shared.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_data.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_area.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_base.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_predictor.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_factory.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_interface.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoding_transform.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_delta_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_delta_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_interface.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoding_transform.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_factory.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_interface.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_decoding_transform.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_encoding_transform.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_base.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_decoding_transform.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_encoding_transform.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_base.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_decoding_transform.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_encoding_transform.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_transform_base.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_decoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_decoders_controller.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_decoders_controller.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_encoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_encoders_controller.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_encoders_controller.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_decoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_encoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_encoding_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_decoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_encoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_decoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_encoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_coding_shared.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_decoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_encoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/direct_bit_decoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/direct_bit_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/direct_bit_encoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/direct_bit_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/folded_integer_bit_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/folded_integer_bit_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/rans_bit_decoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/rans_bit_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/rans_bit_encoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/rans_bit_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/rans_coding_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/symbol_bit_decoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/symbol_bit_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/symbol_bit_encoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/symbol_bit_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/config/compression_shared.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/config/decoder_options.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/config/decoder_options_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/config/draco_options.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/config/encoder_options.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/config/encoding_features.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/decode.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/decode.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/decode_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/encode.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/encode.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/encode_base.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/encode_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/ans.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/rans_symbol_coding.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/rans_symbol_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/rans_symbol_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/shannon_entropy.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/shannon_entropy.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/shannon_entropy_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/symbol_coding_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/symbol_decoding.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/symbol_decoding.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/symbol_encoding.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/symbol_encoding.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/expert_encode.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/expert_encode.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_decoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder_impl.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder_impl.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder_impl_interface.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder_impl.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder_impl.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder_impl_interface.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoding_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_shared.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_predictive_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_predictive_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_valence_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_valence_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_encoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_encoder_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_sequential_decoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_sequential_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_sequential_encoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_sequential_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/traverser/depth_first_traverser.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/traverser/max_prediction_degree_traverser.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/traverser/mesh_attribute_indices_encoding_observer.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/traverser/mesh_traversal_sequencer.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/traverser/traverser_base.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_decoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_encoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_decoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_encoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_decoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_encoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/point_cloud_compression_method.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/point_cloud_types.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/quantize_points_3.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/queuing_policy.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_decoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_encoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_decoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_encoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_encoding_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_decoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_encoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_encoding_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/bit_utils.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/bit_utils.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/bounding_box.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/bounding_box.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/buffer_bit_coding_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/cycle_timer.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/cycle_timer.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/data_buffer.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/data_buffer.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/decoder_buffer.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/decoder_buffer.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/divide.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/divide.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/draco_index_type.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/draco_index_type_vector.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/draco_test_base.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/draco_test_utils.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/draco_test_utils.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/draco_types.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/draco_types.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/draco_version.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/encoder_buffer.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/encoder_buffer.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/hash_utils.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/hash_utils.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/macros.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/math_utils.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/math_utils_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/options.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/options.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/quantization_utils.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/quantization_utils.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/quantization_utils_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/status.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/status_or.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/status_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/varint_decoding.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/varint_encoding.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/vector_d.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/core/vector_d_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/file_reader_factory.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/file_reader_factory.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/file_reader_factory_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/file_reader_interface.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/file_reader_test_common.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/file_utils.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/file_utils.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/file_utils_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/file_writer_factory.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/file_writer_factory.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/file_writer_factory_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/file_writer_interface.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/file_writer_utils.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/file_writer_utils.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/mesh_io.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/mesh_io.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/obj_decoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/obj_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/obj_decoder_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/obj_encoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/obj_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/obj_encoder_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/parser_utils.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/parser_utils.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/ply_decoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/ply_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/ply_decoder_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/ply_encoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/ply_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/ply_property_reader.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/ply_property_writer.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/ply_reader.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/ply_reader.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/ply_reader_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/point_cloud_io.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/point_cloud_io.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/point_cloud_io_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/stdio_file_reader.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/stdio_file_reader.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/stdio_file_reader_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/stdio_file_writer.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/stdio_file_writer.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/io/stdio_file_writer_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/animation_decoder_webidl_wrapper.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/animation_decoder_webidl_wrapper.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/animation_encoder_webidl_wrapper.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/animation_encoder_webidl_wrapper.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/decoder_functions.js
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/decoder_webidl_wrapper.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/decoder_webidl_wrapper.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_animation_decoder_glue_wrapper.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_animation_encoder_glue_wrapper.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_animation_web_decoder.idl
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_animation_web_encoder.idl
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_decoder_glue_wrapper.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_encoder_glue_wrapper.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_web_decoder.idl
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_web_encoder.idl
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/encoder_webidl_wrapper.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/encoder_webidl_wrapper.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/finalize.js
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/prepareCallbacks.js
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/version.js
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/maya/draco_maya_plugin.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/maya/draco_maya_plugin.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/mesh/corner_table.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/mesh/corner_table.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/mesh/corner_table_iterators.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_are_equivalent.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_are_equivalent.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_are_equivalent_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_attribute_corner_table.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_attribute_corner_table.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_cleanup.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_cleanup.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_cleanup_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_misc_functions.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_misc_functions.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_stripifier.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_stripifier.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/mesh/triangle_soup_mesh_builder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/mesh/triangle_soup_mesh_builder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/mesh/triangle_soup_mesh_builder_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/mesh/valence_cache.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/metadata/geometry_metadata.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/metadata/geometry_metadata.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata_decoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata_decoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata_encoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata_encoder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata_encoder_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/point_cloud/point_cloud.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/point_cloud/point_cloud.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/point_cloud/point_cloud_builder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/point_cloud/point_cloud_builder.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/point_cloud/point_cloud_builder_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/point_cloud/point_cloud_test.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/tools/draco_decoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/tools/draco_encoder.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/tools/fuzz/build.sh
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/tools/fuzz/draco_mesh_decoder_fuzzer.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/tools/fuzz/draco_mesh_decoder_without_dequantization_fuzzer.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/tools/fuzz/draco_pc_decoder_fuzzer.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/tools/fuzz/draco_pc_decoder_without_dequantization_fuzzer.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/unity/draco_unity_plugin.cc
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/unity/draco_unity_plugin.h
 create mode 100644 Engine/lib/assimp/contrib/draco/src/draco/unity/draco_unity_plugin_test.cc
 delete mode 100644 Engine/lib/assimp/contrib/irrXML/CMakeFiles/CMakeDirectoryInformation.cmake
 delete mode 100644 Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/DependInfo.cmake
 delete mode 100644 Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/build.make
 delete mode 100644 Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/cmake_clean.cmake
 delete mode 100644 Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/cmake_clean_target.cmake
 delete mode 100644 Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/compiler_depend.make
 delete mode 100644 Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/compiler_depend.ts
 delete mode 100644 Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/depend.make
 delete mode 100644 Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/flags.make
 delete mode 100644 Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o
 delete mode 100644 Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o.d
 delete mode 100644 Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/link.txt
 delete mode 100644 Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/progress.make
 delete mode 100644 Engine/lib/assimp/contrib/irrXML/CMakeFiles/progress.marks
 delete mode 100644 Engine/lib/assimp/contrib/irrXML/CMakeLists.txt
 delete mode 100644 Engine/lib/assimp/contrib/irrXML/CXMLReaderImpl.h
 delete mode 100644 Engine/lib/assimp/contrib/irrXML/Makefile
 delete mode 100644 Engine/lib/assimp/contrib/irrXML/cmake_install.cmake
 delete mode 100644 Engine/lib/assimp/contrib/irrXML/heapsort.h
 delete mode 100644 Engine/lib/assimp/contrib/irrXML/irrArray.h
 delete mode 100644 Engine/lib/assimp/contrib/irrXML/irrString.h
 delete mode 100644 Engine/lib/assimp/contrib/irrXML/irrTypes.h
 delete mode 100644 Engine/lib/assimp/contrib/irrXML/irrXML.cpp
 delete mode 100644 Engine/lib/assimp/contrib/irrXML/irrXML.h
 delete mode 100644 Engine/lib/assimp/contrib/irrXML_note.txt
 create mode 100644 Engine/lib/assimp/contrib/openddlparser/include/openddlparser/TPoolAllocator.h
 create mode 100644 Engine/lib/assimp/contrib/pugixml/CMakeLists.txt
 create mode 100644 Engine/lib/assimp/contrib/pugixml/contrib/foreach.hpp
 create mode 100644 Engine/lib/assimp/contrib/pugixml/readme.txt
 create mode 100644 Engine/lib/assimp/contrib/pugixml/src/pugiconfig.hpp
 create mode 100644 Engine/lib/assimp/contrib/pugixml/src/pugixml.cpp
 create mode 100644 Engine/lib/assimp/contrib/pugixml/src/pugixml.hpp
 create mode 100644 Engine/lib/assimp/contrib/rapidjson/include/rapidjson/cursorstreamwrapper.h
 create mode 100644 Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/clzll.h
 rename Engine/lib/assimp/contrib/{stb_image => stb}/stb_image.h (92%)
 create mode 100644 Engine/lib/assimp/contrib/unzip/crypt.c
 create mode 100644 Engine/lib/assimp/contrib/utf8cpp/source/utf8/cpp11.h
 create mode 100644 Engine/lib/assimp/include/assimp/Base64.hpp
 rename Engine/lib/assimp/include/assimp/{Defines.h => ColladaMetaData.h} (83%)
 create mode 100644 Engine/lib/assimp/include/assimp/GltfMaterial.h
 create mode 100644 Engine/lib/assimp/include/assimp/ObjMaterial.h
 create mode 100644 Engine/lib/assimp/include/assimp/SmallVector.h
 create mode 100644 Engine/lib/assimp/include/assimp/XmlParser.h
 create mode 100644 Engine/lib/assimp/include/assimp/commonMetaData.h
 delete mode 100644 Engine/lib/assimp/include/assimp/config.h
 delete mode 100644 Engine/lib/assimp/include/assimp/irrXMLWrapper.h
 create mode 100644 Engine/lib/assimp/include/assimp/port/AndroidJNI/BundledAssetIOSystem.h
 delete mode 100644 Engine/lib/assimp/include/assimp/revision.h

diff --git a/Engine/lib/assimp/CHANGES b/Engine/lib/assimp/CHANGES
new file mode 100644
index 000000000..c0c73b98c
--- /dev/null
+++ b/Engine/lib/assimp/CHANGES
@@ -0,0 +1,607 @@
+----------------------------------------------------------------------
+CHANGELOG
+----------------------------------------------------------------------
+4.1.0 (2017-12):
+- FEATURES:
+ - Export 3MF ( experimental )
+ - Import / Export glTF 2
+ - Introduce new zib-lib to eb able to export zip-archives
+- FIXES/HOUSEKEEPING:
+ - Added missing include to stdlib.h and remove load library call
+ - Fix install for builds with MSVC compiler and NMake.
+ - Update list of supported file formats.
+ - Add TriLib to the official list of supported ports.
+ - Re-enabling PACK_STRUCT for MDL files.
+ - Use std.::unique_ptr
+ - Update D3MFExporter.h
+ - Update MD3Loader.cpp, using index
+ - Fix all warnings on MSVC14
+ - Copy assimp dll to unit folder on windows
+ - Update jvm port supported formats
+ - Add support for building Mac OS X Framework bundles
+ - Check for nullptr dereferencing before copying scene data
+ - Update ValidateDataStructure.h, typo
+ - Enable data structure validation in cases where it doesn't cause failures
+ - Remove some dead assignments
+ - fast_atof: Silence some uninitialized variable warnings
+ - Check for area test if the face is a triangle.
+ - Set mNumUVComponents to 0 when deleting texture coordinate sets
+ - Only scale the root node because this will rescale all children nodes as well.
+ - Issue 1514: Fix frame pointer arithmetic
+ - Prevent failing stringstream to crash the export process
+ - powf -> pow
+ - add Defines.h to include folder for install.
+ - Android:
+  - Fix android build
+  - Fix assimp for cross compile for android
+  - Use define for D_FILE_OFFSET_BITS only for not-android systems.
+ - FBX:
+  - Fix handling with embedded textures
+  - FBX 7500 Binary reading
+  - Remove dead assignment
+  - Fix export of deleted meshes; Add LazyDict::Remove method
+  - Log an error instead of letting the fbx-importer crash. ( issue 213 )
+  - Replace bad pointer casting with memcpy
+  - Remove useless const qualifier from return value
+  - Add explicit instantiation of log_prefix so other FBX source files can see it
+  - add missing inversion of postrotation matrix for fbx.
+  - FIReader: Silence uninitialized variable warning
+  - Update version check in FBX reader to check for version >= 7500
+  - Use actual min/max of anim keys when start/stop time is missing
+- GLTF1:
+ - Fix output of glTF 1 version string
+ - Fix delete / delete[] mismatch in glTFAsset
+ - Don’t ignore rgba(1,1,1,1) color properties
+ - glTF2 primitives fixes
+ - Don’t ignore rgba(1,1,1,1) color properties
+ - Fix delete / delete[] mismatch in glTFAsset
+ - Remove KHR_binary_glTF code
+ - glTF nodes can only hold one mesh. this simply assigns to and check’s a Node’s Mesh
+ - version in glb header is stored as uint32_t
+- GLTF2:
+ - node name conflict fix
+ - Fix transform matrices multiplication order
+ - Preserve node names when importing
+ - Add support for tangents in import
+ - Fix typo on gltf2 camera parameters
+ - Moved byteStride from accessor to bufferView
+ - Implemented reading binary glTF2 (glb) files
+ - Fix signed/unsigned warning
+ - Add postprocess step for scaling
+ - Fix shininess to roughness conversion
+ - Prefer “BLEND� over “MASK� as an alphaMode default
+ - Approximate specularity / glossiness in metallicRoughness materials
+ - Diffuse color and diffuse texture import and export improvements
+ - Addressed some mismatched news/deletes caused by the new glTF2 sources.
+ - Fix delete / delete[] mismatches in glTF2 importer
+ - use correct name of exporter to gltf2
+ - Fix possible infinite loop when exporting to gltf2
+ - Fix glTF2::Asset::FindUniqueID() when the input string is >= 256 chars
+ - Fix glTF2 alphaMode storage and reading
+ - Fix glTF 2.0 multi-primitive support
+ - Load gltf .bin files from correct directory
+ - Add support for importing both glTF and glTF2 files
+ - ampler improvements; Add new LazyDict method
+ - Changes to GLTF2 materials
+ - Remove Light, Technique references
+ - Start removing materials common, and adding pbrSpecularGlossiness
+ - Use !ObjectEmpty() vs. MemberCount() > 0
+ - Working read, import, export, and write of gltf2 (pbr) material
+ - Check in gltf2 models to test directory
+ - Remove un-needed test models
+ - Start managing and importing gltf2 pbr materials
+ - Update glTF2 Asset to use indexes
+ - Duplicate gltfImporter as gltf2Importer; Include glTF2 importer in CMake List
+ - glTF2: Fix animation export
+ - use opacity for diffuse alpha + alphaMode
+- STL:
+ - Restore import of multi mesh binary STLs
+- Blender:
+ - Silence warning about uninitialized member
+- MDLImporter:
+ - Don't take address of packed struct member
+- assimp_cmd:
+ - Fix strict-aliasing warnings
+- Open3DGC:
+ - Fix strict-aliasing warnings
+ - Add assertions to silence static analyzer warnings
+ - Remove redundant const qualifiers from return types
+ - Fix some uninitialized variable warnings
+ - Remove OPEN3DGC and compression references
+- unzip:
+ - Remove dead assignment
+ - Bail on bad compression method
+ - Fix possibly uninitialized variables
+- clipper:
+ - Add assertion to silence a static analyzer warning
+- OpenDDLExport:
+ - Reduce scope of a variable
+ - Remove dead variable
+ - Remove dead assignment
+ - Fix another potential memory leak
+- X3DImporter:
+ - Add assertions to silence static analyzer warnings
+ - Add missing unittest
+ - Workaround for buggy Android NDK (issue #1361)
+- TerragenLoader:
+ - Remove unused variable
+- SIBImporter:
+ - Add assertions to silence static analyzer warnings
+- IFC:
+ - Remove dead code
+ - Add explicit instantiation of log_prefix so IFCMaterial.cpp can see it
+- PLY:
+ - Remove dead assignment and reduce scope of a variable
+ - fix vertex attribute lookup.
+- OpenGEX:
+ - Add assertion to silence a static analyzer warning
+ - Fix for TextureFile with number in file name
+ - Return early when element is TextureFile
+- NFF:
+ - Add assertions to silence static analyzer warnings
+ - Split up some complicated assignments
+- Raw: Fix misleading indentation warning
+ - Reduce scope of a variable
+- LWO
+ - Reduce scope of a variable
+- IRRLoader:
+ - Fix confusing boolean casting
+- AssbinExporter:
+ - Add assertion to silence a static analyzer warning
+- ASE:
+ - Add assertion to silence a static analyzer warning
+- AMFImporter:
+ - Add assertion to silence a static analyzer warning
+ - Add a block
+- OptimizeGraph:
+ - Fix possible null pointer dereference
+ - RemoveRedundantMaterials:
+ - Add assertion to silence a static analyzer warning
+- ImproveCacheLocality:
+ - Add assertion to silence a static analyzer warning
+- RemoveRedundantMaterials:
+ - Set pointer to nullptr after deleting it
+- Travis:
+ - Disable unit tests in scan-build config
+ - Move slower builds earlier to improve parallelization
+ - Add static analysis to build
+ - Remove unused branch rule for travis.
+ - Add Clang UBSan build configuration
+ - Treat warnings as errors, without typos this time
+- Unittests:
+ - Add VS-based source groups for the unittests.
+- Collada:
+ - export <library_animations> tag
+ - Update ColladaExporter.cpp
+ - Silence uninitialized variable warning
+ - Add support for line strip primitives
+- Obj Wavefront:
+ - check in exporting against out-of-bounds-access .
+ - Issue 1351: use correct name for obj-meshname export for groups.
+ - fix mem-lead: face will be not released in case of an error.
+ - Anatoscope obj exporter nomtl
+ - Raise exception when obj file contains invalid face indices
+ - Added alternative displacement texture token in OBJ MTL material.
+ - Obj: rename attribute from exporter.
+ - Fix OBJ discarding all material names if the material library is missing
+- Step:
+ - use correct lookup for utf32
+- MD2:
+ - Fix MD2 frames containing garbage
+- STL
+ - add missing const.
+ - Fix memory-alignment bug.
+ - Fix issue 104: deal with more solids in one STL file.
+- CMake
+ - Fix issue 213: use correct include folder for assimp
+- Doxygen
+ - Fix issue 1513: put irrXML onto exclucde list for doxygen run
+- PyAssimp:
+ - Search for libassimp.so in LD_LIBRARY_PATH if available.
+ - Fix operator precedence issue in header check
+ - Split setup.py into multiple lines
+ - Detect if Anaconda and fixed 3d_viewer for Python 3
+ - created a python3 version of the 3dviewer and fixed the / = float in py3
+- Blender:
+ - Fix invalid access to mesh array when the array is empty.
+ - Fix short overflow.
+ - Silence warning about inline function which is declared but not defined
+- JAssimp
+ - Changed license header for IHMC contributions from Apache 2.0 to BSD
+ - Add Node metadata to the Jassmip Java API
+ - Added supported for custom IO Systems in Java. Implemented ClassLoader IO System
+ - Added a link to pure jvm assimp port
+- Clang sanitizer:
+ - Undefined Behavior sanitizer
+ - Fixed a divide by zero error in IFCBoolean that was latent, but nevertheless a bug
+- B3DImporter:
+ - Replace bad pointer casting with memcpy
+- AppVeyor:
+ - Cleanup and Addition of VS 2017 and running Tests
+ - Fixed File Size reported as 0 in tests that use temporary files
+ - x86 isn't a valid VS platform. Win32 it is, then.
+ - Replaced the worker image name, which doesn't work as generator name, with a manually created generator name.
+ - Cleaned up appveyor setup, added VS 2017 to the build matrix and attempted to add running of tests.
+ - Treat warnings as errors on Appveyor
+ - Disable warning 4351 on MSVC 2013
+- OpenGEXImporter:
+ - Copy materials to scene
+ - Store RefInfo in unique_ptr so they get automatically cleaned up
+ - Fix IOStream leak
+ - Store ChildInfo in unique_ptr so they get automatically cleaned up
+ - improve logging to be able to detect error-prone situations.
+-  AMFImporter:
+ - Fix memory leak
+- UnrealLoader:
+ - Fix IOStream leak
+- Upgrade RapidJSON to get rid of a clang warning
+- zlib:
+ - Update zlib contribution
+ - Removed unnecessary files from zlib contribution
+ - Replaced unsigned long for the crc table to z_crc_t, to match what is returned by get-crc_table
+- MakeVerboseFormat:
+  - Fix delete / delete[] mismatches in MakeVerboseFormat
+- MaterialSystem:
+ - Fix out-of-bounds read in MaterialSystem unit test
+- SIB:
+ - Added support for SIB models from Silo 2.5
+- AssbinExporter:
+ - Fix strict aliasing violation
+ - Add Write specialization for aiColor3D
+- DefaultLogger:
+ - Whitespace cleanup to fix GCC misleading indentation warning
+- MDP:
+ - Fix encoding issues.
+ - PreTransformVertices:
+ - fix name lost in mesh and nodes when load with flag
+- C4D:
+ - Fixes for C4D importer
+- Unzip:
+ - Latest greatest.
+
+4.0.1 (2017-07-28)
+    - FIXES/HOUSEKEEPING:
+    - fix version test.
+    - Not compiling when using ASSIMP_DOUBLE_PRECISION
+    - Added support for python3
+    - Check if cmake is installed with brew
+    - Low performance in OptimizeMeshesProcess::ProcessNode with huge numbers of meshes
+    - Elapsed seconds not shown correctly
+    - StreamReader: fix out-of-range exception
+    - PPdPmdParser: fix compilation for clang
+
+
+4.0.0 (2017-07-18)
+
+FEATURES:
+    - Double precision support provided ( available via cmake option )
+	- QT-Widget based assimp-viewer ( works for windows, linux, osx )
+	- Open3DGC codec supported by glFT-importer
+	- glTF: Read and write transparency values
+	- Add Triangulate post-processing step to glTF exporters
+	- Update rapidjson to v1.0.2
+	- Added method to append new metadata to structure
+	- Unittests: intoduce a prototype model differ
+	- X3D support
+	- AMF support
+	- Lugdunum3D support
+	- Obj-Importer: obj-homogeneous_coords support
+	- Obj-Importer: new streaming handling
+	- Added support for 64 bit version header introduced in FbxSdk2016
+	- Travis: enable coverall support.
+	- PyAssimp: New version of the pyASSIMP 3D viewer, with much improved 3D controls
+    - Morph animation support for collada	
+	- Added support for parameters Ni and Tf in OBJ/MTL file format
+	- aiScene: add method to add children
+	- Added new option to IFC importer to control tessellation angle + removed unused IFC option
+	- aiMetaData: introduce aiMetaData::Dealloc
+	- Samples: add a DX11 example
+	- travis ci: test on OXS ( XCode 6.3 ) as well
+	- travis ci: enable sudo support.
+	- openddlparser: integrate release v0.4.0
+	- aiMetaData: Added support for metadata in assbin format
+	
+FIXES/HOUSEKEEPING:
+    - Introduce usage of #pragma statement
+	- Put cmake-scripts into their own folder
+	- Fix install pathes ( issue 938 )
+	- Fix object_compare in blender importer( issue 946 )
+	- Fix OSX compilation error
+	- Fix unzip path when no other version was found ( issue 967 )
+	- Set _FILE_OFFSET_BITS=64 for 32-bit linux ( issue 975 )
+	- Fix constructor for radjson on OSX
+	- Use Assimp namespace to fix build for big-endian architectures
+	- Add -fPIC to C Flags for 64bit linux Shared Object builds
+	- MDLLoader: fix resource leak.
+	- MakeVerboseFormat: fix invalid delete statement
+	- IFC: fix possible use after free access bug
+	- ComputeUVMappingprocess: add missing initialization for scalar value
+    - Fix invalid release of mat + mesh
+	- IrrImporter: Fix release functions
+	- Split mesh before exporting gltf ( issue 995 )
+	- 3MFImporter: add source group for visual studio
+	- IFC: Switch generated file to 2 files to fix issue related to <mingw4.9 ( Thanks Qt! )
+	- ObjImporter: fix test for vertices import
+    - export scene combiner ( issues177 )
+	- FBX: make lookup test less strict ( issues 994 )
+	- OpenGEX-Importer: add import of vertex colors ( issue 954 )
+	- fix bug when exporting mRotationKeys data
+	- fix mingw build (mingw supports stat64 nowadays)
+	- cfileio: fix leaks by not closing files in the destructor
+	- Fix OBJ parser mtllib statement parsing bug.
+	- Q3BSP-Importer: remove dead code
+	- Fix BlenderDNA for clang cross compiler.
+	- ScenePreprocessor: fix invalid index counter.
+	- Fix compiler warnings ( issue 957 )
+	- Fix obj .mtl file loading
+	- Fixed a compile error on MSVC14 x64 caused by the /bigobj flag failing to be set for the 1 and 2-suffixed versions introduced in commit 0a25b076b8968b7ea2aa96d7d1b4381be2d72ce6
+	- Fixed build warnings on MSVC14 x64
+	- Remove scaling of specular exponent in OBJFileImporter.cpp
+	- use ai_assert instead of assert ( issue 1076 )
+	- Added a preprocessor definition for MSVC to silence safety warnings regarding C library functions. This addresses all warnings for MSVC x86 and x64 when building zlib, tools and viewer as a static lib
+	- fix parsing of texture name ( issue 899 )
+	- add warning when detecting invalid mat definition ( issue 1111 )
+	- copy aiTexture type declaration instead of using decltype for declaration to fix iOS build( issue 1101 )
+	- FBX: Add additional material properties
+	- FBX: Correct camera position and clip planes
+    - FBX: Add correct light locations and falloff values
+	- fix typo ( issue 1141 )
+	- Fix collada export. Don't duplicate TEXCOORD/NORMALS/COLORS in <vertices> and <polylist> ( issue 1084 )
+	- OBJParser: set material index when changing current material
+	- OBJ: check for null mesh before updating material index
+	- add vertex color export support ( issue 809 )
+	- Fix memory leak in Collada importer ( issue 1169 )
+	- add stp to the list of supported extensions for step-files ( issue 1183 )
+	- fix clang build ( Issue-1169 ) 
+	- fix for FreeBSD
+	- Import FindPkgMacros to main CMake Configuration
+	- Extended support for tessellation parameter to more IFC shapes
+	- defensice handling of utf-8 decode issues ( issue 1211 )
+	- Fixed compiler error on clang 4.0 running on OSX
+	- use test extension for exported test files ( issue 1228 )
+	- Set UVW index material properties for OBJ files
+	- Fixed no member named 'atop' in global namespace issue for Android NDK compilation
+	- Apply mechanism to decide use for IrrXML external or internal
+	- Fix static init ordering bug in OpenGEX importer
+	- GLTF exporter: ensure animation accessors have same count
+	- GLTF exporter: convert animation time from ticks to seconds
+	- Add support for reading texture coordinates from PLY meshes with properties named 'texture_u' and 'texture_v'
+	- Added TokensForSearch in BlenderLoader to allow CanRead return true for in-memory files.
+	- fix wrong delete ( issue 1266 )
+	- OpenGEX: fix invalid handling with color4 token ( issue 1262 )
+	- LWOLoader: fix link in loader description
+	- Fix error when custom CMAKE_C_FLAGS is specified
+	- Fast-atof: log overflow errors
+	- Obj-Importer: do not break when detecting an overflow ( issue 1244 )
+	- Obj-Importer: fix parsing of multible line data definitions
+	- Fixed bug where IFC models with multiple IFCSite only loaded 1 site instead of the complete model
+	- PLYImporter: - optimize memory and speed on ply importer / change parser to use a file stream - manage texture path in ply 
+	  import - manage texture coords on faces in ply import - correction on point cloud faces generation
+	- Utf8: integrate new lib ( issue 1158 )
+	- fixed CMAKE_MODULE_PATH overwriting previous values
+	- OpenGEX: Fixed bug in material color processing ( issue 1271 )
+	- SceneCombiner: move header for scenecombiner to public folder.
+	- GLTF exporter: ensure buffer view byte offsets are correctly aligned
+	- X3D importer: Added EXPORT and IMPORT to the list of ignored XML tags
+    - X3D Exporter: fixed missing attributes
+    - X3D importer: Fixed import of normals for the single index / normal per vertex case
+    - X3D importer: Fixed handling of inlined files
+    - X3D importer: fixed whitespace handling (issue 1202)
+	- X3D importer: Fixed iterator on MSVC 2015
+    - X3D importer: Fixed problems with auto, override and regex on older compilers
+    - X3D importer: Fixed missing header file
+    - X3D importer: Fixed path handling
+	- X3D importer: Implemented support for binary X3D files
+    - fix build without 3DS ( issue 1319 )
+	- pyassimp: Fixed indices for IndexedTriangleFanSet, IndexedTriangleSet and IndexedTriangleStripSet
+	- Fixes parameters to pyassimp.load
+	- Obj-Importe: Fixed texture bug due simultaneously using 'usemtl' and 'usemap' attributes
+	- check if all exporters are disabled ( issue 1320 )
+	- Remove std functions deprecated by C++11.
+	- X-Importer: make it deal with lines
+	- use correct path for compilers ( issue 1335 )
+	- Collada: add workaround to deal with polygon with holes 
+	- update python readme
+	- Use unique node names when loading Collada files
+	- Fixed many FBX bugs
+
+API COMPATIBILITY:
+    - Changed ABI-compatibility to v3.3.1, please rebuild your precompiled libraries ( see issue 1182 )
+	- VS2010 outdated
+
+3.3.1 (2016-07-08)
+
+FIXES/HOUSEKEEPING:
+    - Setup of default precision for 17 exporters
+    - Fix xcode project files
+    - Fix BlenderTesselator: offsetof operator
+    - Invalid version in cmake file
+    - Update pstdint.h to latest greatest
+
+
+3.3.0 (2016-07-05)
+
+FEATURES:
+    - C++11 support enabled
+    - New regression-test-UI
+    - Experimental glTF-importer support
+    - OpenGEX: add support for cameras and lights
+    - C4D: update to latest Melange-SDK
+    - Add a gitter channel
+    - Coverity check enabled
+    - Switch to <...> include brackets for public headers 
+    - Enable export by pyAssimp
+    - CI: check windows build
+    - Add functionality to perform a singlepost-processing step
+    - many more, just check the history
+
+FIXES/HOUSEKEEPING:
+    - Fix of many resource leaks in unittests and main lib
+    - Fix iOS-buildfor X64
+    - Choosing zlib manually for cmake
+    - many more, just check the history
+
+
+3.2.1 (2016-010-10)
+
+FEATURES:
+  - Updated glTF exporter to meet 1.0 specification.
+
+FIXES/HOUSEKEEPING:
+  - Fixed glTF Validator errors for exported glTF format.
+
+ISSUES:
+  - Hard coded sampler setting for
+    - magFilter
+    - minFilter
+  - void* in ExportData for accessor max and min.
+
+
+3.2.0 (2015-11-03)
+
+FEATURES:
+  - OpenDDL-Parser is part of contrib-source.
+  - Experimental OpenGEX-support
+  - CI-check for linux and windows
+  - Coverity check added
+  - New regression testsuite.
+
+FIXES/HOUSEKEEPING:
+  - Hundreds of bugfixes  in all parts of the library
+  - Unified line endings
+
+
+API COMPATIBILITY:
+  - Removed precompiled header to increase build speed for linux
+
+
+3.1.1 (2014-06-15)
+
+FEATURES:
+   - Support for FBX 2013 and newer, binary and ASCII (this is partly
+     work from Google Summer of Code 2012)
+   - Support for OGRE binary mesh and skeleton format
+   - Updated BLEND support for newer Blender versions
+   - Support for arbitrary meta data, used to hold FBX and DAE metadata
+   - OBJ Export now produces smaller files
+   - Meshes can now have names, this is supported by the major importers
+   - Improved IFC geometry generation
+   - M3 support has been removed
+
+FIXES/HOUSEKEEPING:
+    - Hundreds of bugfixes in all parts of the library
+    - CMake is now the primary build system
+
+API COMPATIBILITY:
+    - 3.1.1 is not binary compatible to 3.0 due to aiNode::mMetaData
+      and aiMesh::mName
+    - Export interface has been cleaned up and unified
+    - Other than that no relevant changes
+
+
+3.0 (2012-07-07)
+
+FEATURES:
+   - new export interface similar to the import API.
+   - Supported export formats: Collada, OBJ, PLY and STL
+   - added new import formats: XGL/ZGL, M3 (experimental)
+   - new postprocessing steps: Debone
+   - vastly improved IFC (Industry Foundation Classes) support
+   - introduced API to query importer meta information (such as supported
+       format versions, full name, maintainer info).
+   - reworked Ogre XML import
+   - C-API now supports per-import properties
+
+FIXES/HOUSEKEEPING:
+
+   - hundreds of bugfixes in all parts of the library
+   - unified naming and cleanup of public headers
+   - improved CMake build system
+   - templatized math library
+   - reduce dependency on boost.thread, only remaining spot
+     is synchronization for the C logging API
+
+API COMPATIBILITY:
+   - renamed headers, export interface, C API properties and meta data
+     prevent compatibility with code written for 2.0, but in
+     most cases these can be easily resolved
+   - Note: 3.0 is not binary compatible with 2.0
+
+
+2.0 (2010-11-21)
+
+FEATURES:
+   - Add support for static Blender (*.blend) scenes
+   - Add support for Q3BSP scenes
+   - Add a windows-based OpenGL sample featuring texturing & basic materials
+   - Add an experimental progress feedback interface.
+   - Vastly improved performance (up to 500%, depending on mesh size and
+     spatial structure) in some expensive postprocessing steps
+   - AssimpView now uses a reworked layout which leaves more space
+     to the scene hierarchy window
+
+   - Add C# bindings ('Assimp.NET')
+   - Keep BSD-licensed and otherwise free test files in separate
+     folders (./test/models and ./test/models-nonbsd).
+
+FIXES:
+   - Many Collada bugfixes, improve fault tolerance
+   - Fix possible crashes in the Obj loader
+   - Improve the Ogre XML loader
+   - OpenGL-sample now works with MinGW
+   - Fix Importer::FindLoader failing on uppercase file extensions
+   - Fix flawed path handling when locating external files
+   - Limit the maximum number of vertices, faces, face indices and
+     weights that Assimp is able to handle. This is to avoid
+     crashes due to overflowing counters.
+
+   - Updated XCode project files
+   - Further CMAKE build improvements
+
+
+API CHANGES:
+   - Add data structures for vertex-based animations (These are not
+     currently used, however ...)
+   - Some Assimp::Importer methods are const now.
+
+   
+1.1 (2010-04-17)
+This is the list of relevant changes from the 1.0 (r412) release to 1.1 (r700).
+
+FEATURES:
+  - Vastly improved Collada support
+  - Add MS3D (Milkshape 3D) support
+  - Add support for Ogre XML static meshes
+  - Add experimental COB (TrueSpace) support
+  - Automatic test suite to quickly locate regressions
+  - D bindings (`dAssimp`)
+  - Python 2.n bindings (`PyAssimp`)
+  - Add basic support for Unicode input files (utf8, utf16 and utf32)
+  - Add further utilities to the `assimp` tool (xml/binary dumps, quick file stats)
+  - Switch to a CMAKE-based build system including an install target for unix'es
+  - Automatic evaluation of subdivision surfaces for some formats.
+  - Add `Importer::ReadFileFromMemory` and the corresponding C-API `aiReadFileFromMemory`
+  - Expose further math utilities via the C-API (i.e. `aiMultiplyMatrix4`)
+
+  - Move noboost files away from the public include directory
+  - Many, many bugfixes and improvements in existing loaders and postprocessing steps
+  - Documentation improved and clarified in many places.
+  - Add a sample on using Assimp in conjunction with OpenGL
+
+  - Distribution/packaging: comfortable SDK installer for Windows
+  - Distribution/packaging: improved release packages for other architectures
+
+CRITICAL FIXES:
+  - Resolve problems with clashing heap managers, STL ABIs and runtime libraries (win32)
+  - Fix automatic detection of file type if no file extension is given
+  - Improved exception safety and robustness, prevent leaking of exceptions through the C interface
+  - Fix possible heap corruption due to material properties pulled in incorrectly
+  - Avoid leaking in certain error scenarios
+  - Fix 64 bit compatibility problems in some loaders (i.e. MDL)
+
+BREAKING API CHANGES:
+  - None -
+
+MINOR API BEHAVIOUR CHANGES:
+ - Change quaternion orientation to suit to the more common convention (-w).
+ - aiString is utf8 now. Not yet consistent, however.
diff --git a/Engine/lib/assimp/CREDITS b/Engine/lib/assimp/CREDITS
new file mode 100644
index 000000000..26e21d2f4
--- /dev/null
+++ b/Engine/lib/assimp/CREDITS
@@ -0,0 +1,183 @@
+===============================================================
+Open Asset Import Library (Assimp)
+Developers and Contributors
+===============================================================
+
+The following is a non-exhaustive list of all constributors over the years.
+If you think your name should be listed here, drop us a line and we'll add you.
+
+- Alexander Gessler,
+3DS-, BLEND-, ASE-, DXF-, HMP-, MDL-, MD2-, MD3-, MD5-, MDC-, NFF-, PLY-, STL-, RAW-, OFF-, MS3D-, Q3D- and LWO-Loader, Assimp-Viewer, assimp-cmd, -noboost, Website (Design).
+
+- Thomas Schulze,
+X-, Collada-, BVH-Loader, Postprocessing framework. Data structure & Interface design, documentation.
+
+- Kim Kulling,
+Obj-, Q3BSD-, OpenGEX-Loader, Logging system, CMake-build-environment, Linux-build, Website ( Admin ), Coverity ( Admin ), Glitter ( Admin ).
+
+- R.Schmidt,
+Linux build, eclipse support.
+
+- Matthias Gubisch,
+Assimp.net
+Visual Studio 9 support, bugfixes.
+
+- Mark Sibly
+B3D-Loader, Assimp testing
+
+- Jonathan Klein
+Ogre Loader, VC2010 fixes and CMake fixes.
+
+- Sebastian Hempel,
+PyAssimp (first version)
+Compile-Bugfixes for mingw, add environment for static library support in make.
+
+- Jonathan Pokrass
+Supplied a bugfix concerning the scaling in the md3 loader.
+
+- Andrew Galante,
+Submitted patches to make Assimp compile with GCC-4, a makefile and the xcode3 workspace.
+
+- Andreas Nagel
+First Assimp testing & verification under Windows Vista 64 Bit.
+
+- Marius Schr�der
+Allowed us to use many of his models for screenshots and testing.
+
+- Christian Schubert
+Supplied various XFiles for testing purposes.
+
+- Tizian Wieland
+Searched the web for hundreds of test models for internal use
+
+- John Connors
+Supplied patches for linux and SCons.
+
+- T. R.
+The GUY who performed some of the CSM mocaps.
+
+- Andy Maloney
+Contributed fixes for the documentation and the doxygen markup
+
+- Zhao Lei
+Contributed several bugfixes fixing memory leaks and improving float parsing 
+
+- sueastside
+Updated PyAssimp to the latest Assimp data structures and provided a script to keep the Python binding up-to-date.
+
+- Tobias Rittig
+Collada testing with Cinema 4D
+
+- Brad Grantham
+Improvements in OpenGL-Sample.
+
+- Robert Ramirez
+Add group loading feature to Obj-Loader.
+
+- Chris Maiwald
+Many bugreports, improving Assimp's portability, regular testing & feedback.
+
+- Stepan Hrbek
+Bugreport and fix for a obj-materialloader crash.
+
+- David Nadlinger
+D bindings, CMake install support.
+
+- Dario Accornero
+Contributed several patches regarding Mac OS/XCode targets, bug reports.
+
+- Martin Walser (Samhayne)
+Contributed the 'SimpleTexturedOpenGl' sample.
+
+- Matthias Fauconneau
+Contributed a fix for the Q3-BSP loader.
+
+- Jørgen P. Tjernø
+Contributed updated and improved xcode workspaces
+
+- drparallax
+Contributed the /samples/SimpleAssimpViewX sample
+
+- Carsten Fuchs
+Contributed a fix for the Normalize method in aiQuaternion.
+
+- dbburgess
+Contributes a Android-specific build issue: log the hardware architecture for ARM.
+
+- alfiereinre7
+Contributes a obj-fileparser fix: missing tokens in the obj-token list.
+
+- Roman Kharitonov
+Contributes a fix for the configure script environment.
+
+- Ed Diana
+Contributed AssimpDelphi (/port/AssimpDelphi).
+
+- rdb
+Contributes a bundle of fixes and improvements for the bsp-importer.
+
+- Mick P
+For contributing the De-bone postprocessing step and filing various bug reports.
+
+- Rosen Diankov
+Contributed patches to build assimp debian packages using cmake.
+
+- Mark Page
+Contributed a patch to fix the VertexTriangleAdjacency postprocessing step.
+
+- IOhannes
+Contributed the Debian build fixes ( architecture macro ).
+
+- gellule
+Several LWO and LWS fixes (pivoting). 
+
+- Marcel Metz
+GCC/Linux fixes for the SimpleOpenGL sample.
+
+- Brian Miller
+Bugfix for a compiler fix for iOS on arm.
+
+- Séverin Lemaignan
+Rewrite of PyAssimp, distutils and Python3 support
+
+- albert-wang
+Bugfixes for the collada parser
+
+- Ya ping Jin
+Bugfixes for uv-tanget calculation.
+
+- Jonne Nauha
+Ogre Binary format support
+
+- Filip Wasil, Tieto Poland Sp. z o.o.
+Android JNI asset extraction support
+
+- Richard Steffen
+Contributed ExportProperties interface
+Contributed X File exporter
+Contributed Step (stp) exporter
+
+- Thomas Iorns (mesilliac)
+Initial FBX Export support
+
+For a more detailed list just check: https://github.com/assimp/assimp/network/members
+
+
+========
+Patreons
+========
+
+Huge thanks to our Patreons!
+
+- migenius
+- Marcus
+- Cort
+- elect
+- Steffen
+
+
+===================
+Commercial Sponsors
+===================
+
+- MyDidimo (mydidimo.com): Sponsored development of FBX Export support
diff --git a/Engine/lib/assimp/LICENSE b/Engine/lib/assimp/LICENSE
new file mode 100644
index 000000000..acaaf016e
--- /dev/null
+++ b/Engine/lib/assimp/LICENSE
@@ -0,0 +1,78 @@
+Open Asset Import Library (assimp)
+
+Copyright (c) 2006-2021, assimp team
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+
+******************************************************************************
+
+AN EXCEPTION applies to all files in the ./test/models-nonbsd folder.
+These are 3d models for testing purposes, from various free sources
+on the internet. They are - unless otherwise stated - copyright of
+their respective creators, which may impose additional requirements
+on the use of their work. For any of these models, see
+<model-name>.source.txt for more legal information. Contact us if you
+are a copyright holder and believe that we credited you inproperly or
+if you don't want your files to appear in the repository.
+
+
+******************************************************************************
+
+Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
+http://code.google.com/p/poly2tri/
+
+All rights reserved.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice,
+  this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+* Neither the name of Poly2Tri nor the names of its contributors may be
+  used to endorse or promote products derived from this software without specific
+  prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/Engine/lib/assimp/Readme.md b/Engine/lib/assimp/Readme.md
new file mode 100644
index 000000000..f4167c9f2
--- /dev/null
+++ b/Engine/lib/assimp/Readme.md
@@ -0,0 +1,120 @@
+Open Asset Import Library (assimp)
+==================================
+A library to import and export various 3d-model-formats including scene-post-processing to generate missing render data.
+### Current project status ###
+[![Financial Contributors on Open Collective](https://opencollective.com/assimp/all/badge.svg?label=financial+contributors)](https://opencollective.com/assimp) 
+![C/C++ CI](https://github.com/assimp/assimp/workflows/C/C++%20CI/badge.svg)
+<a href="https://scan.coverity.com/projects/5607">
+  <img alt="Coverity Scan Build Status"
+       src="https://scan.coverity.com/projects/5607/badge.svg"/>
+</a>
+[![Codacy Badge](https://app.codacy.com/project/badge/Grade/9973693b7bdd4543b07084d5d9cf4745)](https://www.codacy.com/gh/assimp/assimp/dashboard?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=assimp/assimp&amp;utm_campaign=Badge_Grade)
+[![Coverage Status](https://coveralls.io/repos/github/assimp/assimp/badge.svg?branch=master)](https://coveralls.io/github/assimp/assimp?branch=master)
+[![Join the chat at https://gitter.im/assimp/assimp](https://badges.gitter.im/assimp/assimp.svg)](https://gitter.im/assimp/assimp?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Average time to resolve an issue](http://isitmaintained.com/badge/resolution/assimp/assimp.svg)](http://isitmaintained.com/project/assimp/assimp "Average time to resolve an issue")
+[![Total alerts](https://img.shields.io/lgtm/alerts/g/assimp/assimp.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/assimp/assimp/alerts/)
+<br>
+
+APIs are provided for C and C++. There are various bindings to other languages (C#, Java, Python, Delphi, D). Assimp also runs on Android and iOS.
+Additionally, assimp features various __mesh post processing tools__: normals and tangent space generation, triangulation, vertex cache locality optimization, removal of degenerate primitives and duplicate vertices, sorting by primitive type, merging of redundant materials and many more.
+
+### Latest Doc's ###
+Please check the latest documents at [Asset-Importer-Lib-Doc](https://assimp-docs.readthedocs.io/en/latest/). 
+
+### Get involved ###
+This is the development repo containing the latest features and bugfixes. For productive use though, we recommend one of the stable releases available from [Github Assimp Releases](https://github.com/assimp/assimp/releases).
+<br>
+You find a bug in the docs? Use [Doc-Repo](https://github.com/assimp/assimp-docs).
+<br>
+Please check our Wiki as well: https://github.com/assimp/assimp/wiki
+
+If you want to check our Model-Database, use the following repo: https://github.com/assimp/assimp-mdb
+
+#### Supported file formats ####
+You can find the complete list of supported file-formats [here](https://github.com/assimp/assimp/blob/master/doc/Fileformats.md)
+
+### Building ###
+Take a look into the https://github.com/assimp/assimp/blob/master/Build.md file. We are available in vcpkg, and our build system is CMake; if you used CMake before there is a good chance you know what to do.
+
+### Ports ###
+* [Android](port/AndroidJNI/README.md)
+* [Python](port/PyAssimp/README.md)
+* [.NET](https://bitbucket.org/Starnick/assimpnet/src/master/)
+* [Pascal](port/AssimpPascal/Readme.md)
+* [Javascript (Alpha)](https://github.com/makc/assimp2json)
+* [Javascript/Node.js Interface](https://github.com/kovacsv/assimpjs)
+* [Unity 3d Plugin](https://ricardoreis.net/trilib-2/)
+* [Unreal Engine Plugin](https://github.com/irajsb/UE4_Assimp/)
+* [JVM](https://github.com/kotlin-graphics/assimp) Full jvm port (current [status](https://github.com/kotlin-graphics/assimp/wiki/Status))
+* [HAXE-Port](https://github.com/longde123/assimp-haxe) The Assimp-HAXE-port.
+* [Rust](https://github.com/jkvargas/russimp)
+
+### Other tools ###
+[open3mod](https://github.com/acgessler/open3mod) is a powerful 3D model viewer based on Assimp's import and export abilities.
+
+#### Repository structure ####
+Open Asset Import Library is implemented in C++. The directory structure looks like:
+
+	/code		Source code
+	/contrib	Third-party libraries
+	/doc		Documentation (doxysource and pre-compiled docs)
+	/include	Public header C and C++ header files
+	/scripts 	Scripts used to generate the loading code for some formats
+	/port		Ports to other languages and scripts to maintain those.
+	/test		Unit- and regression tests, test suite of models
+	/tools		Tools (old assimp viewer, command line `assimp`)
+	/samples	A small number of samples to illustrate possible
+                        use cases for Assimp
+
+The source code is organized in the following way:
+
+	code/Common			The base implementation for importers and the infrastructure
+	code/PostProcessing		The post-processing steps
+	code/AssetLib/<FormatName>	Implementation for import and export for the format
+
+### Where to get help ###
+For more information, visit [our website](http://assimp.org/). Or check out the `./doc`- folder, which contains the official documentation in HTML format.
+(CHMs for Windows are included in some release packages and should be located right here in the root folder).
+
+If the docs don't solve your problem, ask on [StackOverflow with the assimp-tag](http://stackoverflow.com/questions/tagged/assimp?sort=newest). If you think you found a bug, please open an issue on Github.
+
+Open Asset Import Library is a library to load various 3d file formats into a shared, in-memory format. It supports more than __40 file formats__ for import and a growing selection of file formats for export.
+
+And we also have a Gitter-channel:Gitter [![Join the chat at https://gitter.im/assimp/assimp](https://badges.gitter.im/assimp/assimp.svg)](https://gitter.im/assimp/assimp?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)<br>
+
+### Contributing ###
+Contributions to assimp are highly appreciated. The easiest way to get involved is to submit
+a pull request with your changes against the main repository's `master` branch.
+
+## Contributors
+
+### Code Contributors
+
+This project exists thanks to all the people who contribute. [[Contribute](CONTRIBUTING.md)].
+
+<a href="https://github.com/assimp/assimp/graphs/contributors"><img src="https://opencollective.com/assimp/contributors.svg?width=890&button=false" /></a>
+
+### Financial Contributors
+
+Become a financial contributor and help us sustain our community. [[Contribute](https://opencollective.com/assimp/contribute)]
+
+#### Individuals
+
+<a href="https://opencollective.com/assimp"><img src="https://opencollective.com/assimp/individuals.svg?width=890"></a>
+
+
+#### Organizations
+
+Support this project with your organization. Your logo will show up here with a link to your website. [[Contribute](https://opencollective.com/assimp/contribute)]
+
+<a href="https://opencollective.com/assimp/organization/0/website"><img src="https://opencollective.com/assimp/organization/0/avatar.svg"></a>
+
+### License ###
+Our license is based on the modified, __3-clause BSD__-License.
+
+An _informal_ summary is: do whatever you want, but include Assimp's license text with your product -
+and don't sue us if our code doesn't work. Note that, unlike LGPLed code, you may link statically to Assimp.
+For the legal details, see the `LICENSE` file.
+
+### Why this name ###
+Sorry, we're germans :-), no english native speakers ...
diff --git a/Engine/lib/assimp/code/3DS/3DSHelper.h b/Engine/lib/assimp/code/3DS/3DSHelper.h
deleted file mode 100644
index 8eb4cd97c..000000000
--- a/Engine/lib/assimp/code/3DS/3DSHelper.h
+++ /dev/null
@@ -1,652 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file Defines helper data structures for the import of 3DS files */
-
-#ifndef AI_3DSFILEHELPER_H_INC
-#define AI_3DSFILEHELPER_H_INC
-
-#include <assimp/SpatialSort.h>
-#include <assimp/SmoothingGroups.h>
-#include <assimp/StringUtils.h>
-#include <assimp/qnan.h>
-#include <assimp/material.h>
-#include <assimp/camera.h>
-#include <assimp/light.h>
-#include <assimp/anim.h>
-#include <stdio.h> //sprintf
-
-namespace Assimp    {
-namespace D3DS  {
-
-#include <assimp/Compiler/pushpack1.h>
-
-// ---------------------------------------------------------------------------
-/** Discreet3DS class: Helper class for loading 3ds files. Defines chunks
-*  and data structures.
-*/
-class Discreet3DS {
-private:
-    Discreet3DS() AI_NO_EXCEPT {
-        // empty
-    }
-
-    ~Discreet3DS() {
-        // empty
-    }
-
-public:
-    //! data structure for a single chunk in a .3ds file
-    struct Chunk {
-        uint16_t    Flag;
-        uint32_t    Size;
-    } PACK_STRUCT;
-
-
-    //! Used for shading field in material3ds structure
-    //! From AutoDesk 3ds SDK
-    typedef enum
-    {
-        // translated to gouraud shading with wireframe active
-        Wire = 0x0,
-
-        // if this material is set, no vertex normals will
-        // be calculated for the model. Face normals + gouraud
-        Flat = 0x1,
-
-        // standard gouraud shading
-        Gouraud = 0x2,
-
-        // phong shading
-        Phong = 0x3,
-
-        // cooktorrance or anistropic phong shading ...
-        // the exact meaning is unknown, if you know it
-        // feel free to tell me ;-)
-        Metal = 0x4,
-
-        // required by the ASE loader
-        Blinn = 0x5
-    } shadetype3ds;
-
-    // Flags for animated keys
-    enum
-    {
-        KEY_USE_TENS         = 0x1,
-        KEY_USE_CONT         = 0x2,
-        KEY_USE_BIAS         = 0x4,
-        KEY_USE_EASE_TO      = 0x8,
-        KEY_USE_EASE_FROM    = 0x10
-    } ;
-
-    enum
-    {
-
-        // ********************************************************************
-        // Basic chunks which can be found everywhere in the file
-        CHUNK_VERSION   = 0x0002,
-        CHUNK_RGBF      = 0x0010,       // float4 R; float4 G; float4 B
-        CHUNK_RGBB      = 0x0011,       // int1 R; int1 G; int B
-
-        // Linear color values (gamma = 2.2?)
-        CHUNK_LINRGBF      = 0x0013,    // float4 R; float4 G; float4 B
-        CHUNK_LINRGBB      = 0x0012,    // int1 R; int1 G; int B
-
-        CHUNK_PERCENTW  = 0x0030,       // int2   percentage
-        CHUNK_PERCENTF  = 0x0031,       // float4  percentage
-        CHUNK_PERCENTD  = 0x0032,       // float8  percentage
-        // ********************************************************************
-
-        // Prj master chunk
-        CHUNK_PRJ       = 0xC23D,
-
-        // MDLI master chunk
-        CHUNK_MLI       = 0x3DAA,
-
-        // Primary main chunk of the .3ds file
-        CHUNK_MAIN      = 0x4D4D,
-
-        // Mesh main chunk
-        CHUNK_OBJMESH   = 0x3D3D,
-
-        // Specifies the background color of the .3ds file
-        // This is passed through the material system for
-        // viewing purposes.
-        CHUNK_BKGCOLOR  = 0x1200,
-
-        // Specifies the ambient base color of the scene.
-        // This is added to all materials in the file
-        CHUNK_AMBCOLOR  = 0x2100,
-
-        // Specifies the background image for the whole scene
-        // This value is passed through the material system
-        // to the viewer
-        CHUNK_BIT_MAP   = 0x1100,
-        CHUNK_BIT_MAP_EXISTS  = 0x1101,
-
-        // ********************************************************************
-        // Viewport related stuff. Ignored
-        CHUNK_DEFAULT_VIEW = 0x3000,
-        CHUNK_VIEW_TOP = 0x3010,
-        CHUNK_VIEW_BOTTOM = 0x3020,
-        CHUNK_VIEW_LEFT = 0x3030,
-        CHUNK_VIEW_RIGHT = 0x3040,
-        CHUNK_VIEW_FRONT = 0x3050,
-        CHUNK_VIEW_BACK = 0x3060,
-        CHUNK_VIEW_USER = 0x3070,
-        CHUNK_VIEW_CAMERA = 0x3080,
-        // ********************************************************************
-
-        // Mesh chunks
-        CHUNK_OBJBLOCK  = 0x4000,
-        CHUNK_TRIMESH   = 0x4100,
-        CHUNK_VERTLIST  = 0x4110,
-        CHUNK_VERTFLAGS = 0x4111,
-        CHUNK_FACELIST  = 0x4120,
-        CHUNK_FACEMAT   = 0x4130,
-        CHUNK_MAPLIST   = 0x4140,
-        CHUNK_SMOOLIST  = 0x4150,
-        CHUNK_TRMATRIX  = 0x4160,
-        CHUNK_MESHCOLOR = 0x4165,
-        CHUNK_TXTINFO   = 0x4170,
-        CHUNK_LIGHT     = 0x4600,
-        CHUNK_CAMERA    = 0x4700,
-        CHUNK_HIERARCHY = 0x4F00,
-
-        // Specifies the global scaling factor. This is applied
-        // to the root node's transformation matrix
-        CHUNK_MASTER_SCALE    = 0x0100,
-
-        // ********************************************************************
-        // Material chunks
-        CHUNK_MAT_MATERIAL  = 0xAFFF,
-
-            // asciiz containing the name of the material
-            CHUNK_MAT_MATNAME   = 0xA000,
-            CHUNK_MAT_AMBIENT   = 0xA010, // followed by color chunk
-            CHUNK_MAT_DIFFUSE   = 0xA020, // followed by color chunk
-            CHUNK_MAT_SPECULAR  = 0xA030, // followed by color chunk
-
-            // Specifies the shininess of the material
-            // followed by percentage chunk
-            CHUNK_MAT_SHININESS  = 0xA040,
-            CHUNK_MAT_SHININESS_PERCENT  = 0xA041 ,
-
-            // Specifies the shading mode to be used
-            // followed by a short
-            CHUNK_MAT_SHADING  = 0xA100,
-
-            // NOTE: Emissive color (self illumination) seems not
-            // to be a color but a single value, type is unknown.
-            // Make the parser accept both of them.
-            // followed by percentage chunk (?)
-            CHUNK_MAT_SELF_ILLUM = 0xA080,
-
-            // Always followed by percentage chunk  (?)
-            CHUNK_MAT_SELF_ILPCT = 0xA084,
-
-            // Always followed by percentage chunk
-            CHUNK_MAT_TRANSPARENCY = 0xA050,
-
-            // Diffuse texture channel 0
-            CHUNK_MAT_TEXTURE   = 0xA200,
-
-            // Contains opacity information for each texel
-            CHUNK_MAT_OPACMAP = 0xA210,
-
-            // Contains a reflection map to be used to reflect
-            // the environment. This is partially supported.
-            CHUNK_MAT_REFLMAP = 0xA220,
-
-            // Self Illumination map (emissive colors)
-            CHUNK_MAT_SELFIMAP = 0xA33d,
-
-            // Bumpmap. Not specified whether it is a heightmap
-            // or a normal map. Assme it is a heightmap since
-            // artist normally prefer this format.
-            CHUNK_MAT_BUMPMAP = 0xA230,
-
-            // Specular map. Seems to influence the specular color
-            CHUNK_MAT_SPECMAP = 0xA204,
-
-            // Holds shininess data.
-            CHUNK_MAT_MAT_SHINMAP = 0xA33C,
-
-            // Scaling in U/V direction.
-            // (need to gen separate UV coordinate set
-            // and do this by hand)
-            CHUNK_MAT_MAP_USCALE      = 0xA354,
-            CHUNK_MAT_MAP_VSCALE      = 0xA356,
-
-            // Translation in U/V direction.
-            // (need to gen separate UV coordinate set
-            // and do this by hand)
-            CHUNK_MAT_MAP_UOFFSET     = 0xA358,
-            CHUNK_MAT_MAP_VOFFSET     = 0xA35a,
-
-            // UV-coordinates rotation around the z-axis
-            // Assumed to be in radians.
-            CHUNK_MAT_MAP_ANG = 0xA35C,
-
-            // Tiling flags for 3DS files
-            CHUNK_MAT_MAP_TILING = 0xa351,
-
-            // Specifies the file name of a texture
-            CHUNK_MAPFILE   = 0xA300,
-
-            // Specifies whether a materail requires two-sided rendering
-            CHUNK_MAT_TWO_SIDE = 0xA081,
-        // ********************************************************************
-
-        // Main keyframer chunk. Contains translation/rotation/scaling data
-        CHUNK_KEYFRAMER     = 0xB000,
-
-        // Supported sub chunks
-        CHUNK_TRACKINFO     = 0xB002,
-        CHUNK_TRACKOBJNAME  = 0xB010,
-        CHUNK_TRACKDUMMYOBJNAME  = 0xB011,
-        CHUNK_TRACKPIVOT    = 0xB013,
-        CHUNK_TRACKPOS      = 0xB020,
-        CHUNK_TRACKROTATE   = 0xB021,
-        CHUNK_TRACKSCALE    = 0xB022,
-
-        // ********************************************************************
-        // Keyframes for various other stuff in the file
-        // Partially ignored
-        CHUNK_AMBIENTKEY    = 0xB001,
-        CHUNK_TRACKMORPH    = 0xB026,
-        CHUNK_TRACKHIDE     = 0xB029,
-        CHUNK_OBJNUMBER     = 0xB030,
-        CHUNK_TRACKCAMERA   = 0xB003,
-        CHUNK_TRACKFOV      = 0xB023,
-        CHUNK_TRACKROLL     = 0xB024,
-        CHUNK_TRACKCAMTGT   = 0xB004,
-        CHUNK_TRACKLIGHT    = 0xB005,
-        CHUNK_TRACKLIGTGT   = 0xB006,
-        CHUNK_TRACKSPOTL    = 0xB007,
-        CHUNK_FRAMES        = 0xB008,
-        // ********************************************************************
-
-        // light sub-chunks
-        CHUNK_DL_OFF                 = 0x4620,
-        CHUNK_DL_OUTER_RANGE         = 0x465A,
-        CHUNK_DL_INNER_RANGE         = 0x4659,
-        CHUNK_DL_MULTIPLIER          = 0x465B,
-        CHUNK_DL_EXCLUDE             = 0x4654,
-        CHUNK_DL_ATTENUATE           = 0x4625,
-        CHUNK_DL_SPOTLIGHT           = 0x4610,
-
-        // camera sub-chunks
-        CHUNK_CAM_RANGES             = 0x4720
-    };
-};
-
-// ---------------------------------------------------------------------------
-/** Helper structure representing a 3ds mesh face */
-struct Face : public FaceWithSmoothingGroup
-{
-};
-
-// ---------------------------------------------------------------------------
-/** Helper structure representing a texture */
-struct Texture {
-    //! Default constructor
-    Texture() AI_NO_EXCEPT
-    : mOffsetU  (0.0)
-    , mOffsetV  (0.0)
-    , mScaleU   (1.0)
-    , mScaleV   (1.0)
-    , mRotation (0.0)
-    , mMapMode  (aiTextureMapMode_Wrap)
-    , bPrivate()
-    , iUVSrc    (0) {
-        mTextureBlend = get_qnan();
-    }
-
-    //! Specifies the blend factor for the texture
-    ai_real mTextureBlend;
-
-    //! Specifies the filename of the texture
-    std::string mMapName;
-
-    //! Specifies texture coordinate offsets/scaling/rotations
-    ai_real mOffsetU;
-    ai_real mOffsetV;
-    ai_real mScaleU;
-    ai_real mScaleV;
-    ai_real mRotation;
-
-    //! Specifies the mapping mode to be used for the texture
-    aiTextureMapMode mMapMode;
-
-    //! Used internally
-    bool bPrivate;
-    int iUVSrc;
-};
-
-#include <assimp/Compiler/poppack1.h>
-
-// ---------------------------------------------------------------------------
-/** Helper structure representing a 3ds material */
-struct Material
-{
-    //! Default constructor has been deleted
-    Material() = delete;
-
-
-    //! Constructor with explicit name
-    explicit Material(const std::string &name)
-    : mName(name)
-    , mDiffuse            ( ai_real( 0.6 ), ai_real( 0.6 ), ai_real( 0.6 ) ) // FIX ... we won't want object to be black
-    , mSpecularExponent   ( ai_real( 0.0 ) )
-    , mShininessStrength  ( ai_real( 1.0 ) )
-    , mShading(Discreet3DS::Gouraud)
-    , mTransparency       ( ai_real( 1.0 ) )
-    , mBumpHeight         ( ai_real( 1.0 ) )
-    , mTwoSided           (false)
-    {
-    }
-
-
-    Material(const Material &other)            = default;
-    Material &operator=(const Material &other) = default;
-
-
-    //! Move constructor. This is explicitly written because MSVC doesn't support defaulting it
-    Material(Material &&other) AI_NO_EXCEPT
-    : mName(std::move(other.mName))
-    , mDiffuse(std::move(other.mDiffuse))
-    , mSpecularExponent(std::move(other.mSpecularExponent))
-    , mShininessStrength(std::move(other.mShininessStrength))
-    , mSpecular(std::move(other.mSpecular))
-    , mAmbient(std::move(other.mAmbient))
-    , mShading(std::move(other.mShading))
-    , mTransparency(std::move(other.mTransparency))
-    , sTexDiffuse(std::move(other.sTexDiffuse))
-    , sTexOpacity(std::move(other.sTexOpacity))
-    , sTexSpecular(std::move(other.sTexSpecular))
-    , sTexReflective(std::move(other.sTexReflective))
-    , sTexBump(std::move(other.sTexBump))
-    , sTexEmissive(std::move(other.sTexEmissive))
-    , sTexShininess(std::move(other.sTexShininess))
-    , mBumpHeight(std::move(other.mBumpHeight))
-    , mEmissive(std::move(other.mEmissive))
-    , sTexAmbient(std::move(other.sTexAmbient))
-    , mTwoSided(std::move(other.mTwoSided))
-    {
-    }
-
-
-    Material &operator=(Material &&other) AI_NO_EXCEPT {
-        if (this == &other) {
-            return *this;
-        }
-
-        mName = std::move(other.mName);
-        mDiffuse = std::move(other.mDiffuse);
-        mSpecularExponent = std::move(other.mSpecularExponent);
-        mShininessStrength = std::move(other.mShininessStrength),
-        mSpecular = std::move(other.mSpecular);
-        mAmbient = std::move(other.mAmbient);
-        mShading = std::move(other.mShading);
-        mTransparency = std::move(other.mTransparency);
-        sTexDiffuse = std::move(other.sTexDiffuse);
-        sTexOpacity = std::move(other.sTexOpacity);
-        sTexSpecular = std::move(other.sTexSpecular);
-        sTexReflective = std::move(other.sTexReflective);
-        sTexBump = std::move(other.sTexBump);
-        sTexEmissive = std::move(other.sTexEmissive);
-        sTexShininess = std::move(other.sTexShininess);
-        mBumpHeight = std::move(other.mBumpHeight);
-        mEmissive = std::move(other.mEmissive);
-        sTexAmbient = std::move(other.sTexAmbient);
-        mTwoSided = std::move(other.mTwoSided);
-
-        return *this;
-    }
-
-
-    virtual ~Material() {}
-
-
-    //! Name of the material
-    std::string mName;
-    //! Diffuse color of the material
-    aiColor3D mDiffuse;
-    //! Specular exponent
-    ai_real mSpecularExponent;
-    //! Shininess strength, in percent
-    ai_real mShininessStrength;
-    //! Specular color of the material
-    aiColor3D mSpecular;
-    //! Ambient color of the material
-    aiColor3D mAmbient;
-    //! Shading type to be used
-    Discreet3DS::shadetype3ds mShading;
-    //! Opacity of the material
-    ai_real mTransparency;
-    //! Diffuse texture channel
-    Texture sTexDiffuse;
-    //! Opacity texture channel
-    Texture sTexOpacity;
-    //! Specular texture channel
-    Texture sTexSpecular;
-    //! Reflective texture channel
-    Texture sTexReflective;
-    //! Bump texture channel
-    Texture sTexBump;
-    //! Emissive texture channel
-    Texture sTexEmissive;
-    //! Shininess texture channel
-    Texture sTexShininess;
-    //! Scaling factor for the bump values
-    ai_real mBumpHeight;
-    //! Emissive color
-    aiColor3D mEmissive;
-    //! Ambient texture channel
-    //! (used by the ASE format)
-    Texture sTexAmbient;
-    //! True if the material must be rendered from two sides
-    bool mTwoSided;
-};
-
-// ---------------------------------------------------------------------------
-/** Helper structure to represent a 3ds file mesh */
-struct Mesh : public MeshWithSmoothingGroups<D3DS::Face>
-{
-    //! Default constructor has been deleted
-    Mesh() = delete;
-
-    //! Constructor with explicit name
-    explicit Mesh(const std::string &name)
-    : mName(name)
-    {
-    }
-
-
-    //! Name of the mesh
-    std::string mName;
-
-    //! Texture coordinates
-    std::vector<aiVector3D> mTexCoords;
-
-    //! Face materials
-    std::vector<unsigned int> mFaceMaterials;
-
-    //! Local transformation matrix
-    aiMatrix4x4 mMat;
-};
-
-// ---------------------------------------------------------------------------
-/** Float key - quite similar to aiVectorKey and aiQuatKey. Both are in the
-    C-API, so it would be difficult to make them a template. */
-struct aiFloatKey
-{
-    double mTime;      ///< The time of this key
-    ai_real mValue;   ///< The value of this key
-
-#ifdef __cplusplus
-
-    // time is not compared
-    bool operator == (const aiFloatKey& o) const
-        {return o.mValue == this->mValue;}
-
-    bool operator != (const aiFloatKey& o) const
-        {return o.mValue != this->mValue;}
-
-    // Only time is compared. This operator is defined
-    // for use with std::sort
-    bool operator < (const aiFloatKey& o) const
-        {return mTime < o.mTime;}
-
-    bool operator > (const aiFloatKey& o) const
-        {return mTime > o.mTime;}
-
-#endif
-};
-
-// ---------------------------------------------------------------------------
-/** Helper structure to represent a 3ds file node */
-struct Node
-{
-    Node() = delete;
-
-    explicit Node(const std::string &name)
-    : mParent(NULL)
-    , mName(name)
-    , mInstanceNumber(0)
-    , mHierarchyPos       (0)
-    , mHierarchyIndex     (0)
-    , mInstanceCount      (1)
-    {
-        aRotationKeys.reserve (20);
-        aPositionKeys.reserve (20);
-        aScalingKeys.reserve  (20);
-    }
-
-
-    ~Node()
-    {
-        for (unsigned int i = 0; i < mChildren.size();++i)
-            delete mChildren[i];
-    }
-
-    //! Pointer to the parent node
-    Node* mParent;
-
-    //! Holds all child nodes
-    std::vector<Node*> mChildren;
-
-    //! Name of the node
-    std::string mName;
-
-    //! InstanceNumber of the node
-    int32_t mInstanceNumber;
-
-    //! Dummy nodes: real name to be combined with the $$$DUMMY
-    std::string mDummyName;
-
-    //! Position of the node in the hierarchy (tree depth)
-    int16_t mHierarchyPos;
-
-    //! Index of the node
-    int16_t mHierarchyIndex;
-
-    //! Rotation keys loaded from the file
-    std::vector<aiQuatKey> aRotationKeys;
-
-    //! Position keys loaded from the file
-    std::vector<aiVectorKey> aPositionKeys;
-
-    //! Scaling keys loaded from the file
-    std::vector<aiVectorKey> aScalingKeys;
-
-
-    // For target lights (spot lights and directional lights):
-    // The position of the target
-    std::vector< aiVectorKey > aTargetPositionKeys;
-
-    // For cameras: the camera roll angle
-    std::vector< aiFloatKey > aCameraRollKeys;
-
-    //! Pivot position loaded from the file
-    aiVector3D vPivot;
-
-    //instance count, will be kept only for the first node
-    int32_t mInstanceCount;
-
-    //! Add a child node, setup the right parent node for it
-    //! \param pc Node to be 'adopted'
-    inline Node& push_back(Node* pc)
-    {
-        mChildren.push_back(pc);
-        pc->mParent = this;
-        return *this;
-    }
-};
-// ---------------------------------------------------------------------------
-/** Helper structure analogue to aiScene */
-struct Scene
-{
-    //! List of all materials loaded
-    //! NOTE: 3ds references materials globally
-    std::vector<Material> mMaterials;
-
-    //! List of all meshes loaded
-    std::vector<Mesh> mMeshes;
-
-    //! List of all cameras loaded
-    std::vector<aiCamera*> mCameras;
-
-    //! List of all lights loaded
-    std::vector<aiLight*> mLights;
-
-    //! Pointer to the root node of the scene
-    // --- moved to main class
-    // Node* pcRootNode;
-};
-
-
-} // end of namespace D3DS
-} // end of namespace Assimp
-
-#endif // AI_XFILEHELPER_H_INC
diff --git a/Engine/lib/assimp/code/3MF/3MFXmlTags.h b/Engine/lib/assimp/code/3MF/3MFXmlTags.h
deleted file mode 100644
index ea6aeede0..000000000
--- a/Engine/lib/assimp/code/3MF/3MFXmlTags.h
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-#pragma once
-
-namespace Assimp {
-namespace D3MF {
-
-namespace XmlTag {
-    // Meta-data
-    static const std::string meta = "metadata";
-    static const std::string meta_name = "name";
-
-    // Model-data specific tags
-    static const std::string model = "model";
-    static const std::string model_unit = "unit";
-    static const std::string metadata = "metadata";
-    static const std::string resources = "resources";
-    static const std::string object = "object";
-    static const std::string mesh = "mesh";
-    static const std::string vertices = "vertices";
-    static const std::string vertex = "vertex";
-    static const std::string triangles = "triangles";
-    static const std::string triangle = "triangle";
-    static const std::string x = "x";
-    static const std::string y = "y";
-    static const std::string z = "z";
-    static const std::string v1 = "v1";
-    static const std::string v2 = "v2";
-    static const std::string v3 = "v3";
-    static const std::string id = "id";
-    static const std::string pid = "pid";
-    static const std::string p1 = "p1";
-    static const std::string name = "name";
-    static const std::string type = "type";
-    static const std::string build = "build";
-    static const std::string item = "item";
-    static const std::string objectid = "objectid";
-    static const std::string transform = "transform";
-
-    // Material definitions
-    static const std::string basematerials = "basematerials";
-    static const std::string basematerials_id = "id";
-    static const std::string basematerials_base = "base";
-    static const std::string basematerials_name = "name";
-    static const std::string basematerials_displaycolor = "displaycolor";
-
-    // Meta info tags
-    static const std::string CONTENT_TYPES_ARCHIVE = "[Content_Types].xml";
-    static const std::string ROOT_RELATIONSHIPS_ARCHIVE = "_rels/.rels";
-    static const std::string SCHEMA_CONTENTTYPES = "http://schemas.openxmlformats.org/package/2006/content-types";
-    static const std::string SCHEMA_RELATIONSHIPS = "http://schemas.openxmlformats.org/package/2006/relationships";
-    static const std::string RELS_RELATIONSHIP_CONTAINER = "Relationships";
-    static const std::string RELS_RELATIONSHIP_NODE = "Relationship";
-    static const std::string RELS_ATTRIB_TARGET = "Target";
-    static const std::string RELS_ATTRIB_TYPE = "Type";
-    static const std::string RELS_ATTRIB_ID = "Id";
-    static const std::string PACKAGE_START_PART_RELATIONSHIP_TYPE = "http://schemas.microsoft.com/3dmanufacturing/2013/01/3dmodel";
-    static const std::string PACKAGE_PRINT_TICKET_RELATIONSHIP_TYPE = "http://schemas.microsoft.com/3dmanufacturing/2013/01/printticket";
-    static const std::string PACKAGE_TEXTURE_RELATIONSHIP_TYPE = "http://schemas.microsoft.com/3dmanufacturing/2013/01/3dtexture";
-    static const std::string PACKAGE_CORE_PROPERTIES_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties";
-    static const std::string PACKAGE_THUMBNAIL_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/thumbnail";
-}
-
-} // Namespace D3MF
-} // Namespace Assimp
diff --git a/Engine/lib/assimp/code/3MF/D3MFImporter.cpp b/Engine/lib/assimp/code/3MF/D3MFImporter.cpp
deleted file mode 100644
index 682de684a..000000000
--- a/Engine/lib/assimp/code/3MF/D3MFImporter.cpp
+++ /dev/null
@@ -1,483 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-#ifndef ASSIMP_BUILD_NO_3MF_IMPORTER
-
-#include "D3MFImporter.h"
-
-#include <assimp/scene.h>
-#include <assimp/IOSystem.hpp>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/importerdesc.h>
-#include <assimp/StringComparison.h>
-#include <assimp/StringUtils.h>
-#include <assimp/ZipArchiveIOSystem.h>
-
-#include <string>
-#include <vector>
-#include <map>
-#include <cassert>
-#include <memory>
-
-#include "D3MFOpcPackage.h"
-#include <assimp/irrXMLWrapper.h>
-#include "3MFXmlTags.h"
-#include <assimp/fast_atof.h>
-
-#include <iomanip>
-
-namespace Assimp {
-namespace D3MF {
-
-class XmlSerializer {
-public:
-    using MatArray = std::vector<aiMaterial*>;
-    using MatId2MatArray = std::map<unsigned int, std::vector<unsigned int>>;
-
-    XmlSerializer(XmlReader* xmlReader)
-    : mMeshes()
-    , mMatArray()
-    , mActiveMatGroup( 99999999 )
-    , mMatId2MatArray()
-    , xmlReader(xmlReader){
-		// empty
-    }
-
-    ~XmlSerializer() {
-        // empty
-    }
-
-    void ImportXml(aiScene* scene) {
-        if ( nullptr == scene ) {
-            return;
-        }
-
-        scene->mRootNode = new aiNode();
-        std::vector<aiNode*> children;
-
-        std::string nodeName;
-        while(ReadToEndElement(D3MF::XmlTag::model)) {
-            nodeName = xmlReader->getNodeName();
-            if( nodeName == D3MF::XmlTag::object) {
-                children.push_back(ReadObject(scene));
-            } else if( nodeName == D3MF::XmlTag::build) {
-                // 
-            } else if ( nodeName == D3MF::XmlTag::basematerials ) {
-                ReadBaseMaterials();
-            } else if ( nodeName == D3MF::XmlTag::meta ) {
-                ReadMetadata();
-            }
-        }
-
-        if ( scene->mRootNode->mName.length == 0 ) {
-            scene->mRootNode->mName.Set( "3MF" );
-        }
-
-        // import the metadata
-        if ( !mMetaData.empty() ) {
-            const size_t numMeta( mMetaData.size() );
-            scene->mMetaData = aiMetadata::Alloc(static_cast<unsigned int>( numMeta ) );
-            for ( size_t i = 0; i < numMeta; ++i ) {
-                aiString val( mMetaData[ i ].value );
-                scene->mMetaData->Set(static_cast<unsigned int>( i ), mMetaData[ i ].name, val );
-            }
-        }
-
-        // import the meshes
-        scene->mNumMeshes = static_cast<unsigned int>( mMeshes.size());
-        scene->mMeshes = new aiMesh*[scene->mNumMeshes]();
-        std::copy( mMeshes.begin(), mMeshes.end(), scene->mMeshes);
-
-        // import the materials
-        scene->mNumMaterials = static_cast<unsigned int>( mMatArray.size() );
-        if ( 0 != scene->mNumMaterials ) {
-            scene->mMaterials = new aiMaterial*[ scene->mNumMaterials ];
-            std::copy( mMatArray.begin(), mMatArray.end(), scene->mMaterials );
-        }
-
-        // create the scenegraph
-        scene->mRootNode->mNumChildren = static_cast<unsigned int>(children.size());
-        scene->mRootNode->mChildren = new aiNode*[scene->mRootNode->mNumChildren]();
-        std::copy(children.begin(), children.end(), scene->mRootNode->mChildren);
-    }
-
-private:
-    aiNode* ReadObject(aiScene* scene) {
-        std::unique_ptr<aiNode> node(new aiNode());
-
-        std::vector<unsigned long> meshIds;
-
-        const char *attrib( nullptr );
-        std::string name, type;
-        attrib = xmlReader->getAttributeValue( D3MF::XmlTag::id.c_str() );
-        if ( nullptr != attrib ) {
-            name = attrib;
-        }
-        attrib = xmlReader->getAttributeValue( D3MF::XmlTag::type.c_str() );
-        if ( nullptr != attrib ) {
-            type = attrib;
-        }
-
-        node->mParent = scene->mRootNode;
-        node->mName.Set(name);
-
-        size_t meshIdx = mMeshes.size();
-
-        while(ReadToEndElement(D3MF::XmlTag::object)) {
-            if(xmlReader->getNodeName() == D3MF::XmlTag::mesh) {
-                auto mesh = ReadMesh();
-
-                mesh->mName.Set(name);
-                mMeshes.push_back(mesh);
-                meshIds.push_back(static_cast<unsigned long>(meshIdx));
-                ++meshIdx;
-            }
-        }
-
-        node->mNumMeshes = static_cast<unsigned int>(meshIds.size());
-
-        node->mMeshes = new unsigned int[node->mNumMeshes];
-
-        std::copy(meshIds.begin(), meshIds.end(), node->mMeshes);
-
-        return node.release();
-    }
-
-    aiMesh *ReadMesh() {
-        aiMesh* mesh = new aiMesh();
-        while(ReadToEndElement(D3MF::XmlTag::mesh)) {
-            if(xmlReader->getNodeName() == D3MF::XmlTag::vertices) {
-                ImportVertices(mesh);
-            } else if(xmlReader->getNodeName() == D3MF::XmlTag::triangles) {
-                ImportTriangles(mesh);
-            }
-        }
-
-        return mesh;
-    }
-
-    void ReadMetadata() {
-        const std::string name = xmlReader->getAttributeValue( D3MF::XmlTag::meta_name.c_str() );
-        xmlReader->read();
-        const std::string value = xmlReader->getNodeData();
-
-        if ( name.empty() ) {
-            return;
-        }
-
-        MetaEntry entry;
-        entry.name = name;
-        entry.value = value;
-        mMetaData.push_back( entry );
-    }
-
-    void ImportVertices(aiMesh* mesh) {
-        std::vector<aiVector3D> vertices;
-        while(ReadToEndElement(D3MF::XmlTag::vertices)) {
-            if(xmlReader->getNodeName() == D3MF::XmlTag::vertex) {
-                vertices.push_back(ReadVertex());
-            }
-        }
-        mesh->mNumVertices = static_cast<unsigned int>(vertices.size());
-        mesh->mVertices = new aiVector3D[mesh->mNumVertices];
-
-        std::copy(vertices.begin(), vertices.end(), mesh->mVertices);
-    }
-
-    aiVector3D ReadVertex() {
-        aiVector3D vertex;
-
-        vertex.x = ai_strtof(xmlReader->getAttributeValue(D3MF::XmlTag::x.c_str()), nullptr);
-        vertex.y = ai_strtof(xmlReader->getAttributeValue(D3MF::XmlTag::y.c_str()), nullptr);
-        vertex.z = ai_strtof(xmlReader->getAttributeValue(D3MF::XmlTag::z.c_str()), nullptr);
-
-        return vertex;
-    }
-
-    void ImportTriangles(aiMesh* mesh) {
-         std::vector<aiFace> faces;
-
-         while(ReadToEndElement(D3MF::XmlTag::triangles)) {
-             const std::string nodeName( xmlReader->getNodeName() );
-             if(xmlReader->getNodeName() == D3MF::XmlTag::triangle) {
-                 faces.push_back(ReadTriangle());
-                 const char *pidToken( xmlReader->getAttributeValue( D3MF::XmlTag::p1.c_str() ) );
-                 if ( nullptr != pidToken ) {
-                     int matIdx( std::atoi( pidToken ) );
-                     mesh->mMaterialIndex = matIdx;
-                 }
-             }
-         }
-
-        mesh->mNumFaces = static_cast<unsigned int>(faces.size());
-        mesh->mFaces = new aiFace[mesh->mNumFaces];
-        mesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
-
-        std::copy(faces.begin(), faces.end(), mesh->mFaces);
-    }
-
-    aiFace ReadTriangle() {
-        aiFace face;
-
-        face.mNumIndices = 3;
-        face.mIndices = new unsigned int[face.mNumIndices];
-        face.mIndices[0] = static_cast<unsigned int>(std::atoi(xmlReader->getAttributeValue(D3MF::XmlTag::v1.c_str())));
-        face.mIndices[1] = static_cast<unsigned int>(std::atoi(xmlReader->getAttributeValue(D3MF::XmlTag::v2.c_str())));
-        face.mIndices[2] = static_cast<unsigned int>(std::atoi(xmlReader->getAttributeValue(D3MF::XmlTag::v3.c_str())));
-
-        return face;
-    }
-
-    void ReadBaseMaterials() {
-        std::vector<unsigned int> MatIdArray;
-        const char *baseMaterialId( xmlReader->getAttributeValue( D3MF::XmlTag::basematerials_id.c_str() ) );
-        if ( nullptr != baseMaterialId ) {
-            unsigned int id = std::atoi( baseMaterialId );
-            const size_t newMatIdx( mMatArray.size() );
-            if ( id != mActiveMatGroup ) {
-                mActiveMatGroup = id;
-                MatId2MatArray::const_iterator it( mMatId2MatArray.find( id ) );
-                if ( mMatId2MatArray.end() == it ) {
-                    MatIdArray.clear();
-                    mMatId2MatArray[ id ] = MatIdArray;
-                } else {
-                    MatIdArray = it->second;
-                }
-            }
-            MatIdArray.push_back( static_cast<unsigned int>( newMatIdx ) );
-            mMatId2MatArray[ mActiveMatGroup ] = MatIdArray;
-        }
-
-        while ( ReadToEndElement( D3MF::XmlTag::basematerials ) ) {
-            mMatArray.push_back( readMaterialDef() );
-        }
-    }
-
-    bool parseColor( const char *color, aiColor4D &diffuse ) {
-        if ( nullptr == color ) {
-            return false;
-        }
-
-        //format of the color string: #RRGGBBAA or #RRGGBB (3MF Core chapter 5.1.1)
-        const size_t len( strlen( color ) );
-        if ( 9 != len && 7 != len) {
-            return false;
-        }
-
-        const char *buf( color );
-        if ( '#' != *buf ) {
-            return false;
-        }
-        ++buf;
-        char comp[ 3 ] = { 0,0,'\0' };
-
-        comp[ 0 ] = *buf;
-        ++buf;
-        comp[ 1 ] = *buf;
-        ++buf;
-        diffuse.r = static_cast<ai_real>( strtol( comp, NULL, 16 ) ) / ai_real(255.0);
-
-
-        comp[ 0 ] = *buf;
-        ++buf;
-        comp[ 1 ] = *buf;
-        ++buf;
-        diffuse.g = static_cast< ai_real >( strtol( comp, NULL, 16 ) ) / ai_real(255.0);
-
-        comp[ 0 ] = *buf;
-        ++buf;
-        comp[ 1 ] = *buf;
-        ++buf;
-        diffuse.b = static_cast< ai_real >( strtol( comp, NULL, 16 ) ) / ai_real(255.0);
-
-        if(7 == len)
-            return true;
-        comp[ 0 ] = *buf;
-        ++buf;
-        comp[ 1 ] = *buf;
-        ++buf;
-        diffuse.a = static_cast< ai_real >( strtol( comp, NULL, 16 ) ) / ai_real(255.0);
-
-        return true;
-    }
-
-    void assignDiffuseColor( aiMaterial *mat ) {
-        const char *color = xmlReader->getAttributeValue( D3MF::XmlTag::basematerials_displaycolor.c_str() );
-        aiColor4D diffuse;
-        if ( parseColor( color, diffuse ) ) {
-            mat->AddProperty<aiColor4D>( &diffuse, 1, AI_MATKEY_COLOR_DIFFUSE );
-        }
-
-    }
-    aiMaterial *readMaterialDef() {
-        aiMaterial *mat( nullptr );
-        const char *name( nullptr );
-        const std::string nodeName( xmlReader->getNodeName() );
-        if ( nodeName == D3MF::XmlTag::basematerials_base ) {
-            name = xmlReader->getAttributeValue( D3MF::XmlTag::basematerials_name.c_str() );
-            std::string stdMatName;
-            aiString matName;
-            std::string strId( to_string( mActiveMatGroup ) );
-            stdMatName += "id";
-            stdMatName += strId;
-            stdMatName += "_";
-            if ( nullptr != name ) {
-                stdMatName += std::string( name );
-            } else {
-                stdMatName += "basemat";
-            }
-            matName.Set( stdMatName );
-
-            mat = new aiMaterial;
-            mat->AddProperty( &matName, AI_MATKEY_NAME );
-
-            assignDiffuseColor( mat );
-        }
-
-        return mat;
-    }
-
-private:
-    bool ReadToStartElement(const std::string& startTag) {
-        while(xmlReader->read()) {
-            const std::string &nodeName( xmlReader->getNodeName() );
-            if (xmlReader->getNodeType() == irr::io::EXN_ELEMENT && nodeName == startTag) {
-                return true;
-            } else if (xmlReader->getNodeType() == irr::io::EXN_ELEMENT_END && nodeName == startTag) {
-                return false;
-            }
-        }
-
-        return false;
-    }
-
-    bool ReadToEndElement(const std::string& closeTag) {
-        while(xmlReader->read()) {
-            const std::string &nodeName( xmlReader->getNodeName() );
-            if (xmlReader->getNodeType() == irr::io::EXN_ELEMENT) {
-                return true;
-            } else if (xmlReader->getNodeType() == irr::io::EXN_ELEMENT_END && nodeName == closeTag) {
-                return false;
-            }
-        }
-        ASSIMP_LOG_ERROR("unexpected EOF, expected closing <" + closeTag + "> tag");
-
-        return false;
-    }
-
-private:
-    struct MetaEntry {
-        std::string name;
-        std::string value;
-    };
-    std::vector<MetaEntry> mMetaData;
-    std::vector<aiMesh*> mMeshes;
-    MatArray mMatArray;
-    unsigned int mActiveMatGroup;
-    MatId2MatArray mMatId2MatArray;
-    XmlReader* xmlReader;
-};
-
-} //namespace D3MF
-
-static const aiImporterDesc desc = {
-    "3mf Importer",
-    "",
-    "",
-    "http://3mf.io/",
-    aiImporterFlags_SupportBinaryFlavour | aiImporterFlags_SupportCompressedFlavour,
-    0,
-    0,
-    0,
-    0,
-    "3mf"
-};
-
-D3MFImporter::D3MFImporter()
-: BaseImporter() {
-    // empty
-}
-
-D3MFImporter::~D3MFImporter() {
-    // empty
-}
-
-bool D3MFImporter::CanRead(const std::string &filename, IOSystem *pIOHandler, bool checkSig) const {
-    const std::string extension( GetExtension( filename ) );
-    if(extension == desc.mFileExtensions ) {
-        return true;
-    } else if ( !extension.length() || checkSig ) {
-        if ( nullptr == pIOHandler ) {
-            return false;
-        }
-        if ( !ZipArchiveIOSystem::isZipArchive( pIOHandler, filename ) ) {
-            return false;
-        }
-        D3MF::D3MFOpcPackage opcPackage( pIOHandler, filename );
-        return opcPackage.validate();
-    }
-
-    return false;
-}
-
-void D3MFImporter::SetupProperties(const Importer * /*pImp*/) {
-    // empty
-}
-
-const aiImporterDesc *D3MFImporter::GetInfo() const {
-    return &desc;
-}
-
-void D3MFImporter::InternReadFile( const std::string &filename, aiScene *pScene, IOSystem *pIOHandler ) {
-    D3MF::D3MFOpcPackage opcPackage(pIOHandler, filename);
-
-    std::unique_ptr<CIrrXML_IOStreamReader> xmlStream(new CIrrXML_IOStreamReader(opcPackage.RootStream()));
-    std::unique_ptr<D3MF::XmlReader> xmlReader(irr::io::createIrrXMLReader(xmlStream.get()));
-
-    D3MF::XmlSerializer xmlSerializer(xmlReader.get());
-
-    xmlSerializer.ImportXml(pScene);
-}
-
-} // Namespace Assimp
-
-#endif // ASSIMP_BUILD_NO_3MF_IMPORTER
diff --git a/Engine/lib/assimp/code/3MF/D3MFOpcPackage.cpp b/Engine/lib/assimp/code/3MF/D3MFOpcPackage.cpp
deleted file mode 100644
index 873ba8ee8..000000000
--- a/Engine/lib/assimp/code/3MF/D3MFOpcPackage.cpp
+++ /dev/null
@@ -1,207 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-#ifndef ASSIMP_BUILD_NO_3MF_IMPORTER
-
-#include "D3MFOpcPackage.h"
-#include <assimp/Exceptional.h>
-
-#include <assimp/IOStream.hpp>
-#include <assimp/IOSystem.hpp>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/ai_assert.h>
-#include <assimp/ZipArchiveIOSystem.h>
-
-#include <cstdlib>
-#include <memory>
-#include <vector>
-#include <map>
-#include <algorithm>
-#include <cassert>
-#include "3MFXmlTags.h"
-
-namespace Assimp {
-
-namespace D3MF {
-// ------------------------------------------------------------------------------------------------
-
-typedef std::shared_ptr<OpcPackageRelationship> OpcPackageRelationshipPtr;
-
-class OpcPackageRelationshipReader {
-public:
-    OpcPackageRelationshipReader(XmlReader* xmlReader) {        
-        while(xmlReader->read()) {
-            if(xmlReader->getNodeType() == irr::io::EXN_ELEMENT &&
-               xmlReader->getNodeName() == XmlTag::RELS_RELATIONSHIP_CONTAINER)
-            {
-                ParseRootNode(xmlReader);
-            }
-        }
-    }
-
-    void ParseRootNode(XmlReader* xmlReader)
-    {       
-        ParseAttributes(xmlReader);
-
-        while(xmlReader->read())
-        {
-            if(xmlReader->getNodeType() == irr::io::EXN_ELEMENT &&
-               xmlReader->getNodeName() == XmlTag::RELS_RELATIONSHIP_NODE)
-            {
-                ParseChildNode(xmlReader);
-            }
-        }
-    }
-
-    void ParseAttributes(XmlReader*) {
-        // empty
-    }
-
-    bool validateRels( OpcPackageRelationshipPtr &relPtr ) {
-        if ( relPtr->id.empty() || relPtr->type.empty() || relPtr->target.empty() ) {
-            return false;
-        }
-        return true;
-    }
-
-    void ParseChildNode(XmlReader* xmlReader) {        
-        OpcPackageRelationshipPtr relPtr(new OpcPackageRelationship());
-
-        relPtr->id = xmlReader->getAttributeValueSafe(XmlTag::RELS_ATTRIB_ID.c_str());
-        relPtr->type = xmlReader->getAttributeValueSafe(XmlTag::RELS_ATTRIB_TYPE.c_str());
-        relPtr->target = xmlReader->getAttributeValueSafe(XmlTag::RELS_ATTRIB_TARGET.c_str());
-        if ( validateRels( relPtr ) ) {
-            m_relationShips.push_back( relPtr );
-        }
-    }
-
-    std::vector<OpcPackageRelationshipPtr> m_relationShips;
-};
-
-// ------------------------------------------------------------------------------------------------
-D3MFOpcPackage::D3MFOpcPackage(IOSystem* pIOHandler, const std::string& rFile)
-: mRootStream(nullptr)
-, mZipArchive() {    
-    mZipArchive.reset( new ZipArchiveIOSystem( pIOHandler, rFile ) );
-    if(!mZipArchive->isOpen()) {
-        throw DeadlyImportError("Failed to open file " + rFile+ ".");
-    }
-
-    std::vector<std::string> fileList;
-    mZipArchive->getFileList(fileList);
-
-    for (auto& file: fileList) {
-        if(file == D3MF::XmlTag::ROOT_RELATIONSHIPS_ARCHIVE) {
-            //PkgRelationshipReader pkgRelReader(file, archive);
-            ai_assert(mZipArchive->Exists(file.c_str()));
-
-            IOStream *fileStream = mZipArchive->Open(file.c_str());
-
-            ai_assert(fileStream != nullptr);
-
-            std::string rootFile = ReadPackageRootRelationship(fileStream);
-            if ( rootFile.size() > 0 && rootFile[ 0 ] == '/' ) {
-                rootFile = rootFile.substr( 1 );
-                if ( rootFile[ 0 ] == '/' ) {
-                    // deal with zip-bug
-                    rootFile = rootFile.substr( 1 );
-                }
-            }
-
-            ASSIMP_LOG_DEBUG(rootFile);
-
-            mZipArchive->Close(fileStream);
-
-            mRootStream = mZipArchive->Open(rootFile.c_str());
-            ai_assert( mRootStream != nullptr );
-            if ( nullptr == mRootStream ) {
-                throw DeadlyExportError( "Cannot open root-file in archive : " + rootFile );
-            }
-
-        } else if( file == D3MF::XmlTag::CONTENT_TYPES_ARCHIVE) {
-            ASSIMP_LOG_WARN_F("Ignored file of unsupported type CONTENT_TYPES_ARCHIVES",file);
-        } else {
-            ASSIMP_LOG_WARN_F("Ignored file of unknown type: ",file);
-        }
-
-    }
-}
-
-D3MFOpcPackage::~D3MFOpcPackage() {
-    mZipArchive->Close(mRootStream);
-}
-
-IOStream* D3MFOpcPackage::RootStream() const {
-    return mRootStream;
-}
-
-static const std::string ModelRef = "3D/3dmodel.model";
-
-bool D3MFOpcPackage::validate() {
-    if ( nullptr == mRootStream || nullptr == mZipArchive ) {
-        return false;
-    }
-
-    return mZipArchive->Exists( ModelRef.c_str() );
-}
-
-std::string D3MFOpcPackage::ReadPackageRootRelationship(IOStream* stream) {
-    std::unique_ptr<CIrrXML_IOStreamReader> xmlStream(new CIrrXML_IOStreamReader(stream));
-    std::unique_ptr<XmlReader> xml(irr::io::createIrrXMLReader(xmlStream.get()));
-
-    OpcPackageRelationshipReader reader(xml.get());
-
-    auto itr = std::find_if(reader.m_relationShips.begin(), reader.m_relationShips.end(), [](const OpcPackageRelationshipPtr& rel){
-        return rel->type == XmlTag::PACKAGE_START_PART_RELATIONSHIP_TYPE;
-    });
-
-    if ( itr == reader.m_relationShips.end() ) {
-        throw DeadlyImportError( "Cannot find " + XmlTag::PACKAGE_START_PART_RELATIONSHIP_TYPE );
-    }
-
-    return (*itr)->target;
-}
-
-} // Namespace D3MF
-} // Namespace Assimp
-
-#endif //ASSIMP_BUILD_NO_3MF_IMPORTER
diff --git a/Engine/lib/assimp/code/AMF/AMFImporter.cpp b/Engine/lib/assimp/code/AMF/AMFImporter.cpp
deleted file mode 100644
index dedb6dcdd..000000000
--- a/Engine/lib/assimp/code/AMF/AMFImporter.cpp
+++ /dev/null
@@ -1,705 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-/// \file AMFImporter.cpp
-/// \brief AMF-format files importer for Assimp: main algorithm implementation.
-/// \date 2016
-/// \author smal.root@gmail.com
-
-#ifndef ASSIMP_BUILD_NO_AMF_IMPORTER
-
-// Header files, Assimp.
-#include "AMFImporter.hpp"
-#include "AMFImporter_Macro.hpp"
-
-#include <assimp/fast_atof.h>
-#include <assimp/DefaultIOSystem.h>
-
-// Header files, stdlib.
-#include <memory>
-
-namespace Assimp
-{
-
-/// \var aiImporterDesc AMFImporter::Description
-/// Conastant which hold importer description
-const aiImporterDesc AMFImporter::Description = {
-	"Additive manufacturing file format(AMF) Importer",
-	"smalcom",
-	"",
-	"See documentation in source code. Chapter: Limitations.",
-	aiImporterFlags_SupportTextFlavour | aiImporterFlags_LimitedSupport | aiImporterFlags_Experimental,
-	0,
-	0,
-	0,
-	0,
-	"amf"
-};
-
-void AMFImporter::Clear()
-{
-	mNodeElement_Cur = nullptr;
-	mUnit.clear();
-	mMaterial_Converted.clear();
-	mTexture_Converted.clear();
-	// Delete all elements
-	if(!mNodeElement_List.empty())
-	{
-		for(CAMFImporter_NodeElement* ne: mNodeElement_List) { delete ne; }
-
-		mNodeElement_List.clear();
-	}
-}
-
-AMFImporter::~AMFImporter()
-{
-	if(mReader != nullptr) delete mReader;
-	// Clear() is accounting if data already is deleted. So, just check again if all data is deleted.
-	Clear();
-}
-
-/*********************************************************************************************************************************************/
-/************************************************************ Functions: find set ************************************************************/
-/*********************************************************************************************************************************************/
-
-bool AMFImporter::Find_NodeElement(const std::string& pID, const CAMFImporter_NodeElement::EType pType, CAMFImporter_NodeElement** pNodeElement) const
-{
-	for(CAMFImporter_NodeElement* ne: mNodeElement_List)
-	{
-		if((ne->ID == pID) && (ne->Type == pType))
-		{
-			if(pNodeElement != nullptr) *pNodeElement = ne;
-
-			return true;
-		}
-	}// for(CAMFImporter_NodeElement* ne: mNodeElement_List)
-
-	return false;
-}
-
-bool AMFImporter::Find_ConvertedNode(const std::string& pID, std::list<aiNode*>& pNodeList, aiNode** pNode) const
-{
-aiString node_name(pID.c_str());
-
-	for(aiNode* node: pNodeList)
-	{
-		if(node->mName == node_name)
-		{
-			if(pNode != nullptr) *pNode = node;
-
-			return true;
-		}
-	}// for(aiNode* node: pNodeList)
-
-	return false;
-}
-
-bool AMFImporter::Find_ConvertedMaterial(const std::string& pID, const SPP_Material** pConvertedMaterial) const
-{
-	for(const SPP_Material& mat: mMaterial_Converted)
-	{
-		if(mat.ID == pID)
-		{
-			if(pConvertedMaterial != nullptr) *pConvertedMaterial = &mat;
-
-			return true;
-		}
-	}// for(const SPP_Material& mat: mMaterial_Converted)
-
-	return false;
-}
-
-/*********************************************************************************************************************************************/
-/************************************************************ Functions: throw set ***********************************************************/
-/*********************************************************************************************************************************************/
-
-void AMFImporter::Throw_CloseNotFound(const std::string& pNode)
-{
-	throw DeadlyImportError("Close tag for node <" + pNode + "> not found. Seems file is corrupt.");
-}
-
-void AMFImporter::Throw_IncorrectAttr(const std::string& pAttrName)
-{
-	throw DeadlyImportError("Node <" + std::string(mReader->getNodeName()) + "> has incorrect attribute \"" + pAttrName + "\".");
-}
-
-void AMFImporter::Throw_IncorrectAttrValue(const std::string& pAttrName)
-{
-	throw DeadlyImportError("Attribute \"" + pAttrName + "\" in node <" + std::string(mReader->getNodeName()) + "> has incorrect value.");
-}
-
-void AMFImporter::Throw_MoreThanOnceDefined(const std::string& pNodeType, const std::string& pDescription)
-{
-	throw DeadlyImportError("\"" + pNodeType + "\" node can be used only once in " + mReader->getNodeName() + ". Description: " + pDescription);
-}
-
-void AMFImporter::Throw_ID_NotFound(const std::string& pID) const
-{
-	throw DeadlyImportError("Not found node with name \"" + pID + "\".");
-}
-
-/*********************************************************************************************************************************************/
-/************************************************************* Functions: XML set ************************************************************/
-/*********************************************************************************************************************************************/
-
-void AMFImporter::XML_CheckNode_MustHaveChildren()
-{
-	if(mReader->isEmptyElement()) throw DeadlyImportError(std::string("Node <") + mReader->getNodeName() + "> must have children.");
-}
-
-void AMFImporter::XML_CheckNode_SkipUnsupported(const std::string& pParentNodeName)
-{
-    static const size_t Uns_Skip_Len = 3;
-    const char* Uns_Skip[Uns_Skip_Len] = { "composite", "edge", "normal" };
-
-    static bool skipped_before[Uns_Skip_Len] = { false, false, false };
-
-    std::string nn(mReader->getNodeName());
-    bool found = false;
-    bool close_found = false;
-    size_t sk_idx;
-
-	for(sk_idx = 0; sk_idx < Uns_Skip_Len; sk_idx++)
-	{
-		if(nn != Uns_Skip[sk_idx]) continue;
-
-		found = true;
-		if(mReader->isEmptyElement())
-		{
-			close_found = true;
-
-			goto casu_cres;
-		}
-
-		while(mReader->read())
-		{
-			if((mReader->getNodeType() == irr::io::EXN_ELEMENT_END) && (nn == mReader->getNodeName()))
-			{
-				close_found = true;
-
-				goto casu_cres;
-			}
-		}
-	}// for(sk_idx = 0; sk_idx < Uns_Skip_Len; sk_idx++)
-
-casu_cres:
-
-	if(!found) throw DeadlyImportError("Unknown node \"" + nn + "\" in " + pParentNodeName + ".");
-	if(!close_found) Throw_CloseNotFound(nn);
-
-	if(!skipped_before[sk_idx])
-	{
-		skipped_before[sk_idx] = true;
-        ASSIMP_LOG_WARN_F("Skipping node \"", nn, "\" in ", pParentNodeName, ".");
-	}
-}
-
-bool AMFImporter::XML_SearchNode(const std::string& pNodeName)
-{
-	while(mReader->read())
-	{
-		if((mReader->getNodeType() == irr::io::EXN_ELEMENT) && XML_CheckNode_NameEqual(pNodeName)) return true;
-	}
-
-	return false;
-}
-
-bool AMFImporter::XML_ReadNode_GetAttrVal_AsBool(const int pAttrIdx)
-{
-    std::string val(mReader->getAttributeValue(pAttrIdx));
-
-	if((val == "false") || (val == "0"))
-		return false;
-	else if((val == "true") || (val == "1"))
-		return true;
-	else
-		throw DeadlyImportError("Bool attribute value can contain \"false\"/\"0\" or \"true\"/\"1\" not the \"" + val + "\"");
-}
-
-float AMFImporter::XML_ReadNode_GetAttrVal_AsFloat(const int pAttrIdx)
-{
-    std::string val;
-    float tvalf;
-
-	ParseHelper_FixTruncatedFloatString(mReader->getAttributeValue(pAttrIdx), val);
-	fast_atoreal_move(val.c_str(), tvalf, false);
-
-	return tvalf;
-}
-
-uint32_t AMFImporter::XML_ReadNode_GetAttrVal_AsU32(const int pAttrIdx)
-{
-	return strtoul10(mReader->getAttributeValue(pAttrIdx));
-}
-
-float AMFImporter::XML_ReadNode_GetVal_AsFloat()
-{
-    std::string val;
-    float tvalf;
-
-	if(!mReader->read()) throw DeadlyImportError("XML_ReadNode_GetVal_AsFloat. No data, seems file is corrupt.");
-	if(mReader->getNodeType() != irr::io::EXN_TEXT) throw DeadlyImportError("XML_ReadNode_GetVal_AsFloat. Invalid type of XML element, seems file is corrupt.");
-
-	ParseHelper_FixTruncatedFloatString(mReader->getNodeData(), val);
-	fast_atoreal_move(val.c_str(), tvalf, false);
-
-	return tvalf;
-}
-
-uint32_t AMFImporter::XML_ReadNode_GetVal_AsU32()
-{
-	if(!mReader->read()) throw DeadlyImportError("XML_ReadNode_GetVal_AsU32. No data, seems file is corrupt.");
-	if(mReader->getNodeType() != irr::io::EXN_TEXT) throw DeadlyImportError("XML_ReadNode_GetVal_AsU32. Invalid type of XML element, seems file is corrupt.");
-
-	return strtoul10(mReader->getNodeData());
-}
-
-void AMFImporter::XML_ReadNode_GetVal_AsString(std::string& pValue)
-{
-	if(!mReader->read()) throw DeadlyImportError("XML_ReadNode_GetVal_AsString. No data, seems file is corrupt.");
-	if(mReader->getNodeType() != irr::io::EXN_TEXT)
-		throw DeadlyImportError("XML_ReadNode_GetVal_AsString. Invalid type of XML element, seems file is corrupt.");
-
-	pValue = mReader->getNodeData();
-}
-
-/*********************************************************************************************************************************************/
-/************************************************************ Functions: parse set ***********************************************************/
-/*********************************************************************************************************************************************/
-
-void AMFImporter::ParseHelper_Node_Enter(CAMFImporter_NodeElement* pNode)
-{
-	mNodeElement_Cur->Child.push_back(pNode);// add new element to current element child list.
-	mNodeElement_Cur = pNode;// switch current element to new one.
-}
-
-void AMFImporter::ParseHelper_Node_Exit()
-{
-	// check if we can walk up.
-	if(mNodeElement_Cur != nullptr) mNodeElement_Cur = mNodeElement_Cur->Parent;
-}
-
-void AMFImporter::ParseHelper_FixTruncatedFloatString(const char* pInStr, std::string& pOutString)
-{
-    size_t instr_len;
-
-	pOutString.clear();
-	instr_len = strlen(pInStr);
-	if(!instr_len) return;
-
-	pOutString.reserve(instr_len * 3 / 2);
-	// check and correct floats in format ".x". Must be "x.y".
-	if(pInStr[0] == '.') pOutString.push_back('0');
-
-	pOutString.push_back(pInStr[0]);
-	for(size_t ci = 1; ci < instr_len; ci++)
-	{
-		if((pInStr[ci] == '.') && ((pInStr[ci - 1] == ' ') || (pInStr[ci - 1] == '-') || (pInStr[ci - 1] == '+') || (pInStr[ci - 1] == '\t')))
-		{
-			pOutString.push_back('0');
-			pOutString.push_back('.');
-		}
-		else
-		{
-			pOutString.push_back(pInStr[ci]);
-		}
-	}
-}
-
-static bool ParseHelper_Decode_Base64_IsBase64(const char pChar)
-{
-	return (isalnum(pChar) || (pChar == '+') || (pChar == '/'));
-}
-
-void AMFImporter::ParseHelper_Decode_Base64(const std::string& pInputBase64, std::vector<uint8_t>& pOutputData) const
-{
-    // With help from
-    // René Nyffenegger http://www.adp-gmbh.ch/cpp/common/base64.html
-    const std::string base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
-    uint8_t tidx = 0;
-    uint8_t arr4[4], arr3[3];
-
-	// check input data
-	if(pInputBase64.size() % 4) throw DeadlyImportError("Base64-encoded data must have size multiply of four.");
-	// prepare output place
-	pOutputData.clear();
-	pOutputData.reserve(pInputBase64.size() / 4 * 3);
-
-	for(size_t in_len = pInputBase64.size(), in_idx = 0; (in_len > 0) && (pInputBase64[in_idx] != '='); in_len--)
-	{
-		if(ParseHelper_Decode_Base64_IsBase64(pInputBase64[in_idx]))
-		{
-			arr4[tidx++] = pInputBase64[in_idx++];
-			if(tidx == 4)
-			{
-				for(tidx = 0; tidx < 4; tidx++) arr4[tidx] = (uint8_t)base64_chars.find(arr4[tidx]);
-
-				arr3[0] = (arr4[0] << 2) + ((arr4[1] & 0x30) >> 4);
-				arr3[1] = ((arr4[1] & 0x0F) << 4) + ((arr4[2] & 0x3C) >> 2);
-				arr3[2] = ((arr4[2] & 0x03) << 6) + arr4[3];
-				for(tidx = 0; tidx < 3; tidx++) pOutputData.push_back(arr3[tidx]);
-
-				tidx = 0;
-			}// if(tidx == 4)
-		}// if(ParseHelper_Decode_Base64_IsBase64(pInputBase64[in_idx]))
-		else
-		{
-			in_idx++;
-		}// if(ParseHelper_Decode_Base64_IsBase64(pInputBase64[in_idx])) else
-	}
-
-	if(tidx)
-	{
-		for(uint8_t i = tidx; i < 4; i++) arr4[i] = 0;
-		for(uint8_t i = 0; i < 4; i++) arr4[i] = (uint8_t)(base64_chars.find(arr4[i]));
-
-		arr3[0] = (arr4[0] << 2) + ((arr4[1] & 0x30) >> 4);
-		arr3[1] = ((arr4[1] & 0x0F) << 4) + ((arr4[2] & 0x3C) >> 2);
-		arr3[2] = ((arr4[2] & 0x03) << 6) + arr4[3];
-		for(uint8_t i = 0; i < (tidx - 1); i++) pOutputData.push_back(arr3[i]);
-	}
-}
-
-void AMFImporter::ParseFile(const std::string& pFile, IOSystem* pIOHandler)
-{
-    irr::io::IrrXMLReader* OldReader = mReader;// store current XMLreader.
-    std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));
-
-	// Check whether we can read from the file
-	if(file.get() == NULL) throw DeadlyImportError("Failed to open AMF file " + pFile + ".");
-
-	// generate a XML reader for it
-	std::unique_ptr<CIrrXML_IOStreamReader> mIOWrapper(new CIrrXML_IOStreamReader(file.get()));
-	mReader = irr::io::createIrrXMLReader(mIOWrapper.get());
-	if(!mReader) throw DeadlyImportError("Failed to create XML reader for file" + pFile + ".");
-	//
-	// start reading
-	// search for root tag <amf>
-	if(XML_SearchNode("amf"))
-		ParseNode_Root();
-	else
-		throw DeadlyImportError("Root node \"amf\" not found.");
-
-	delete mReader;
-	// restore old XMLreader
-	mReader = OldReader;
-}
-
-// <amf
-// unit="" - The units to be used. May be "inch", "millimeter", "meter", "feet", or "micron".
-// version="" - Version of file format.
-// >
-// </amf>
-// Root XML element.
-// Multi elements - No.
-void AMFImporter::ParseNode_Root()
-{
-    std::string unit, version;
-    CAMFImporter_NodeElement *ne( nullptr );
-
-	// Read attributes for node <amf>.
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECK_RET("unit", unit, mReader->getAttributeValue);
-		MACRO_ATTRREAD_CHECK_RET("version", version, mReader->getAttributeValue);
-	MACRO_ATTRREAD_LOOPEND_WSKIP;
-
-	// Check attributes
-	if(!mUnit.empty())
-	{
-		if((mUnit != "inch") && (mUnit != "millimeter") && (mUnit != "meter") && (mUnit != "feet") && (mUnit != "micron")) Throw_IncorrectAttrValue("unit");
-	}
-
-	// create root node element.
-	ne = new CAMFImporter_NodeElement_Root(nullptr);
-	mNodeElement_Cur = ne;// set first "current" element
-	// and assign attribute's values
-	((CAMFImporter_NodeElement_Root*)ne)->Unit = unit;
-	((CAMFImporter_NodeElement_Root*)ne)->Version = version;
-
-	// Check for child nodes
-	if(!mReader->isEmptyElement())
-	{
-		MACRO_NODECHECK_LOOPBEGIN("amf");
-			if(XML_CheckNode_NameEqual("object")) { ParseNode_Object(); continue; }
-			if(XML_CheckNode_NameEqual("material")) { ParseNode_Material(); continue; }
-			if(XML_CheckNode_NameEqual("texture")) { ParseNode_Texture(); continue; }
-			if(XML_CheckNode_NameEqual("constellation")) { ParseNode_Constellation(); continue; }
-			if(XML_CheckNode_NameEqual("metadata")) { ParseNode_Metadata(); continue; }
-		MACRO_NODECHECK_LOOPEND("amf");
-		mNodeElement_Cur = ne;// force restore "current" element
-	}// if(!mReader->isEmptyElement())
-
-	mNodeElement_List.push_back(ne);// add to node element list because its a new object in graph.
-}
-
-// <constellation
-// id="" - The Object ID of the new constellation being defined.
-// >
-// </constellation>
-// A collection of objects or constellations with specific relative locations.
-// Multi elements - Yes.
-// Parent element - <amf>.
-void AMFImporter::ParseNode_Constellation()
-{
-    std::string id;
-    CAMFImporter_NodeElement* ne( nullptr );
-
-	// Read attributes for node <constellation>.
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECK_RET("id", id, mReader->getAttributeValue);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// create and if needed - define new grouping object.
-	ne = new CAMFImporter_NodeElement_Constellation(mNodeElement_Cur);
-
-	CAMFImporter_NodeElement_Constellation& als = *((CAMFImporter_NodeElement_Constellation*)ne);// alias for convenience
-
-	if(!id.empty()) als.ID = id;
-	// Check for child nodes
-	if(!mReader->isEmptyElement())
-	{
-		ParseHelper_Node_Enter(ne);
-		MACRO_NODECHECK_LOOPBEGIN("constellation");
-			if(XML_CheckNode_NameEqual("instance")) { ParseNode_Instance(); continue; }
-			if(XML_CheckNode_NameEqual("metadata")) { ParseNode_Metadata(); continue; }
-		MACRO_NODECHECK_LOOPEND("constellation");
-		ParseHelper_Node_Exit();
-	}// if(!mReader->isEmptyElement())
-	else
-	{
-		mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element
-	}// if(!mReader->isEmptyElement()) else
-
-	mNodeElement_List.push_back(ne);// and to node element list because its a new object in graph.
-}
-
-// <instance
-// objectid="" - The Object ID of the new constellation being defined.
-// >
-// </instance>
-// A collection of objects or constellations with specific relative locations.
-// Multi elements - Yes.
-// Parent element - <amf>.
-void AMFImporter::ParseNode_Instance()
-{
-    std::string objectid;
-    CAMFImporter_NodeElement* ne( nullptr );
-
-	// Read attributes for node <constellation>.
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECK_RET("objectid", objectid, mReader->getAttributeValue);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// used object id must be defined, check that.
-	if(objectid.empty()) throw DeadlyImportError("\"objectid\" in <instance> must be defined.");
-	// create and define new grouping object.
-	ne = new CAMFImporter_NodeElement_Instance(mNodeElement_Cur);
-
-	CAMFImporter_NodeElement_Instance& als = *((CAMFImporter_NodeElement_Instance*)ne);// alias for convenience
-
-	als.ObjectID = objectid;
-	// Check for child nodes
-	if(!mReader->isEmptyElement())
-	{
-		bool read_flag[6] = { false, false, false, false, false, false };
-
-		als.Delta.Set(0, 0, 0);
-		als.Rotation.Set(0, 0, 0);
-		ParseHelper_Node_Enter(ne);
-		MACRO_NODECHECK_LOOPBEGIN("instance");
-			MACRO_NODECHECK_READCOMP_F("deltax", read_flag[0], als.Delta.x);
-			MACRO_NODECHECK_READCOMP_F("deltay", read_flag[1], als.Delta.y);
-			MACRO_NODECHECK_READCOMP_F("deltaz", read_flag[2], als.Delta.z);
-			MACRO_NODECHECK_READCOMP_F("rx", read_flag[3], als.Rotation.x);
-			MACRO_NODECHECK_READCOMP_F("ry", read_flag[4], als.Rotation.y);
-			MACRO_NODECHECK_READCOMP_F("rz", read_flag[5], als.Rotation.z);
-		MACRO_NODECHECK_LOOPEND("instance");
-		ParseHelper_Node_Exit();
-		// also convert degrees to radians.
-		als.Rotation.x = AI_MATH_PI_F * als.Rotation.x / 180.0f;
-		als.Rotation.y = AI_MATH_PI_F * als.Rotation.y / 180.0f;
-		als.Rotation.z = AI_MATH_PI_F * als.Rotation.z / 180.0f;
-	}// if(!mReader->isEmptyElement())
-	else
-	{
-		mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element
-	}// if(!mReader->isEmptyElement()) else
-
-	mNodeElement_List.push_back(ne);// and to node element list because its a new object in graph.
-}
-
-// <object
-// id="" - A unique ObjectID for the new object being defined.
-// >
-// </object>
-// An object definition.
-// Multi elements - Yes.
-// Parent element - <amf>.
-void AMFImporter::ParseNode_Object()
-{
-    std::string id;
-    CAMFImporter_NodeElement* ne( nullptr );
-
-	// Read attributes for node <object>.
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECK_RET("id", id, mReader->getAttributeValue);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// create and if needed - define new geometry object.
-	ne = new CAMFImporter_NodeElement_Object(mNodeElement_Cur);
-
-	CAMFImporter_NodeElement_Object& als = *((CAMFImporter_NodeElement_Object*)ne);// alias for convenience
-
-	if(!id.empty()) als.ID = id;
-	// Check for child nodes
-	if(!mReader->isEmptyElement())
-	{
-		bool col_read = false;
-
-		ParseHelper_Node_Enter(ne);
-		MACRO_NODECHECK_LOOPBEGIN("object");
-			if(XML_CheckNode_NameEqual("color"))
-			{
-				// Check if color already defined for object.
-				if(col_read) Throw_MoreThanOnceDefined("color", "Only one color can be defined for <object>.");
-				// read data and set flag about it
-				ParseNode_Color();
-				col_read = true;
-
-				continue;
-			}
-
-			if(XML_CheckNode_NameEqual("mesh")) { ParseNode_Mesh(); continue; }
-			if(XML_CheckNode_NameEqual("metadata")) { ParseNode_Metadata(); continue; }
-		MACRO_NODECHECK_LOOPEND("object");
-		ParseHelper_Node_Exit();
-	}// if(!mReader->isEmptyElement())
-	else
-	{
-		mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element
-	}// if(!mReader->isEmptyElement()) else
-
-	mNodeElement_List.push_back(ne);// and to node element list because its a new object in graph.
-}
-
-// <metadata
-// type="" - The type of the attribute.
-// >
-// </metadata>
-// Specify additional information about an entity.
-// Multi elements - Yes.
-// Parent element - <amf>, <object>, <volume>, <material>, <vertex>.
-//
-// Reserved types are:
-// "Name" - The alphanumeric label of the entity, to be used by the interpreter if interacting with the user.
-// "Description" - A description of the content of the entity
-// "URL" - A link to an external resource relating to the entity
-// "Author" - Specifies the name(s) of the author(s) of the entity
-// "Company" - Specifying the company generating the entity
-// "CAD" - specifies the name of the originating CAD software and version
-// "Revision" - specifies the revision of the entity
-// "Tolerance" - specifies the desired manufacturing tolerance of the entity in entity's unit system
-// "Volume" - specifies the total volume of the entity, in the entity's unit system, to be used for verification (object and volume only)
-void AMFImporter::ParseNode_Metadata()
-{
-    std::string type, value;
-    CAMFImporter_NodeElement* ne( nullptr );
-
-	// read attribute
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECK_RET("type", type, mReader->getAttributeValue);
-	MACRO_ATTRREAD_LOOPEND;
-	// and value of node.
-	value = mReader->getNodeData();
-	// Create node element and assign read data.
-	ne = new CAMFImporter_NodeElement_Metadata(mNodeElement_Cur);
-	((CAMFImporter_NodeElement_Metadata*)ne)->Type = type;
-	((CAMFImporter_NodeElement_Metadata*)ne)->Value = value;
-	mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element
-	mNodeElement_List.push_back(ne);// and to node element list because its a new object in graph.
-}
-
-/*********************************************************************************************************************************************/
-/******************************************************** Functions: BaseImporter set ********************************************************/
-/*********************************************************************************************************************************************/
-
-bool AMFImporter::CanRead(const std::string& pFile, IOSystem* pIOHandler, bool pCheckSig) const
-{
-    const std::string extension = GetExtension(pFile);
-
-    if ( extension == "amf" ) {
-        return true;
-    }
-
-	if(!extension.length() || pCheckSig)
-	{
-		const char* tokens[] = { "<amf" };
-
-		return SearchFileHeaderForToken( pIOHandler, pFile, tokens, 1 );
-	}
-
-	return false;
-}
-
-void AMFImporter::GetExtensionList(std::set<std::string>& pExtensionList)
-{
-	pExtensionList.insert("amf");
-}
-
-const aiImporterDesc* AMFImporter::GetInfo () const
-{
-	return &Description;
-}
-
-void AMFImporter::InternReadFile(const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler)
-{
-	Clear();// delete old graph.
-	ParseFile(pFile, pIOHandler);
-	Postprocess_BuildScene(pScene);
-	// scene graph is ready, exit.
-}
-
-}// namespace Assimp
-
-#endif // !ASSIMP_BUILD_NO_AMF_IMPORTER
diff --git a/Engine/lib/assimp/code/AMF/AMFImporter.hpp b/Engine/lib/assimp/code/AMF/AMFImporter.hpp
deleted file mode 100644
index 2b8086a06..000000000
--- a/Engine/lib/assimp/code/AMF/AMFImporter.hpp
+++ /dev/null
@@ -1,432 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-/// \file AMFImporter.hpp
-/// \brief AMF-format files importer for Assimp.
-/// \date 2016
-/// \author smal.root@gmail.com
-// Thanks to acorn89 for support.
-
-#pragma once
-#ifndef INCLUDED_AI_AMF_IMPORTER_H
-#define INCLUDED_AI_AMF_IMPORTER_H
-
-#include "AMFImporter_Node.hpp"
-
-// Header files, Assimp.
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/importerdesc.h>
-#include "assimp/types.h"
-#include <assimp/BaseImporter.h>
-#include <assimp/irrXMLWrapper.h>
-
-// Header files, stdlib.
-#include <set>
-
-namespace Assimp {
-
-/// \class AMFImporter
-/// Class that holding scene graph which include: geometry, metadata, materials etc.
-///
-/// Implementing features.
-///
-/// Limitations.
-///
-/// 1. When for texture mapping used set of source textures (r, g, b, a) not only one then attribute "tiled" for all set will be true if it true in any of
-///    source textures.
-///    Example. Triangle use for texture mapping three textures. Two of them has "tiled" set to false and one - set to true. In scene all three textures
-///    will be tiled.
-///
-/// Unsupported features:
-/// 1. Node <composite>, formulas in <composite> and <color>. For implementing this feature can be used expression parser "muParser" like in project
-///    "amf_tools".
-/// 2. Attribute "profile" in node <color>.
-/// 3. Curved geometry: <edge>, <normal> and children nodes of them.
-/// 4. Attributes: "unit" and "version" in <amf> read but do nothing.
-/// 5. <metadata> stored only for root node <amf>.
-/// 6. Color averaging of vertices for which <triangle>'s set different colors.
-///
-/// Supported nodes:
-///    General:
-///        <amf>; <constellation>; <instance> and children <deltax>, <deltay>, <deltaz>, <rx>, <ry>, <rz>; <metadata>;
-///
-///    Geometry:
-///        <object>; <mesh>; <vertices>; <vertex>; <coordinates> and children <x>, <y>, <z>; <volume>; <triangle> and children <v1>, <v2>, <v3>;
-///
-///    Material:
-///        <color> and children <r>, <g>, <b>, <a>; <texture>; <material>;
-///        two variants of texture coordinates:
-///            new - <texmap> and children <utex1>, <utex2>, <utex3>, <vtex1>, <vtex2>, <vtex3>
-///            old - <map> and children <u1>, <u2>, <u3>, <v1>, <v2>, <v3>
-///
-class AMFImporter : public BaseImporter {
-private:
-    struct SPP_Material;// forward declaration
-
-                        /// \struct SPP_Composite
-                        /// Data type for post-processing step. More suitable container for part of material's composition.
-    struct SPP_Composite {
-        SPP_Material* Material;///< Pointer to material - part of composition.
-        std::string Formula;///< Formula for calculating ratio of \ref Material.
-    };
-
-    /// \struct SPP_Material
-    /// Data type for post-processing step. More suitable container for material.
-    struct SPP_Material {
-        std::string ID;///< Material ID.
-        std::list<CAMFImporter_NodeElement_Metadata*> Metadata;///< Metadata of material.
-        CAMFImporter_NodeElement_Color* Color;///< Color of material.
-        std::list<SPP_Composite> Composition;///< List of child materials if current material is composition of few another.
-
-        /// Return color calculated for specified coordinate.
-        /// \param [in] pX - "x" coordinate.
-        /// \param [in] pY - "y" coordinate.
-        /// \param [in] pZ - "z" coordinate.
-        /// \return calculated color.
-        aiColor4D GetColor(const float pX, const float pY, const float pZ) const;
-    };
-
-    /// Data type for post-processing step. More suitable container for texture.
-    struct SPP_Texture {
-        std::string ID;
-        size_t      Width, Height, Depth;
-        bool        Tiled;
-        char        FormatHint[9];// 8 for string + 1 for terminator.
-        uint8_t    *Data;
-    };
-
-    /// Data type for post-processing step. Contain face data.
-    struct SComplexFace {
-        aiFace Face;///< Face vertices.
-        const CAMFImporter_NodeElement_Color* Color;///< Face color. Equal to nullptr if color is not set for the face.
-        const CAMFImporter_NodeElement_TexMap* TexMap;///< Face texture mapping data. Equal to nullptr if texture mapping is not set for the face.
-    };
-
-	/// Clear all temporary data.
-	void Clear();
-
-	/***********************************************/
-	/************* Functions: find set *************/
-	/***********************************************/
-
-	/// Find specified node element in node elements list ( \ref mNodeElement_List).
-	/// \param [in] pID - ID(name) of requested node element.
-	/// \param [in] pType - type of node element.
-	/// \param [out] pNode - pointer to pointer to item found.
-	/// \return true - if the node element is found, else - false.
-	bool Find_NodeElement(const std::string& pID, const CAMFImporter_NodeElement::EType pType, CAMFImporter_NodeElement** pNodeElement) const;
-
-	/// Find requested aiNode in node list.
-	/// \param [in] pID - ID(name) of requested node.
-	/// \param [in] pNodeList - list of nodes where to find the node.
-	/// \param [out] pNode - pointer to pointer to item found.
-	/// \return true - if the node is found, else - false.
-	bool Find_ConvertedNode(const std::string& pID, std::list<aiNode*>& pNodeList, aiNode** pNode) const;
-
-	/// Find material in list for converted materials. Use at postprocessing step.
-	/// \param [in] pID - material ID.
-	/// \param [out] pConvertedMaterial - pointer to found converted material (\ref SPP_Material).
-	/// \return true - if the material is found, else - false.
-	bool Find_ConvertedMaterial(const std::string& pID, const SPP_Material** pConvertedMaterial) const;
-
-    /// Find texture in list of converted textures. Use at postprocessing step,
-	/// \param [in] pID_R - ID of source "red" texture.
-	/// \param [in] pID_G - ID of source "green" texture.
-	/// \param [in] pID_B - ID of source "blue" texture.
-	/// \param [in] pID_A - ID of source "alpha" texture. Use empty string to find RGB-texture.
-	/// \param [out] pConvertedTextureIndex - pointer where index in list of found texture will be written. If equivalent to nullptr then nothing will be
-	/// written.
-	/// \return true - if the texture is found, else - false.
-	bool Find_ConvertedTexture(const std::string& pID_R, const std::string& pID_G, const std::string& pID_B, const std::string& pID_A,
-								uint32_t* pConvertedTextureIndex = nullptr) const;
-
-
-	/// Get data stored in <vertices> and place it to arrays.
-	/// \param [in] pNodeElement - reference to node element which kept <object> data.
-	/// \param [in] pVertexCoordinateArray - reference to vertices coordinates kept in <vertices>.
-	/// \param [in] pVertexColorArray - reference to vertices colors for all <vertex's. If color for vertex is not set then corresponding member of array
-	/// contain nullptr.
-	void PostprocessHelper_CreateMeshDataArray(const CAMFImporter_NodeElement_Mesh& pNodeElement, std::vector<aiVector3D>& pVertexCoordinateArray,
-												std::vector<CAMFImporter_NodeElement_Color*>& pVertexColorArray) const;
-
-	/// Return converted texture ID which related to specified source textures ID's. If converted texture does not exist then it will be created and ID on new
-	/// converted texture will be returned. Conversion: set of textures from \ref CAMFImporter_NodeElement_Texture to one \ref SPP_Texture and place it
-	/// to converted textures list.
-	/// Any of source ID's can be absent(empty string) or even one ID only specified. But at least one ID must be specified.
-	/// \param [in] pID_R - ID of source "red" texture.
-	/// \param [in] pID_G - ID of source "green" texture.
-	/// \param [in] pID_B - ID of source "blue" texture.
-	/// \param [in] pID_A - ID of source "alpha" texture.
-	/// \return index of the texture in array of the converted textures.
-	size_t PostprocessHelper_GetTextureID_Or_Create(const std::string& pID_R, const std::string& pID_G, const std::string& pID_B, const std::string& pID_A);
-
-	/// Separate input list by texture IDs. This step is needed because aiMesh can contain mesh which is use only one texture (or set: diffuse, bump etc).
-	/// \param [in] pInputList - input list with faces. Some of them can contain color or texture mapping, or both of them, or nothing. Will be cleared after
-	/// processing.
-	/// \param [out] pOutputList_Separated - output list of the faces lists. Separated faces list by used texture IDs. Will be cleared before processing.
-	void PostprocessHelper_SplitFacesByTextureID(std::list<SComplexFace>& pInputList, std::list<std::list<SComplexFace> >& pOutputList_Separated);
-
-	/// Check if child elements of node element is metadata and add it to scene node.
-	/// \param [in] pMetadataList - reference to list with collected metadata.
-	/// \param [out] pSceneNode - scene node in which metadata will be added.
-	void Postprocess_AddMetadata(const std::list<CAMFImporter_NodeElement_Metadata*>& pMetadataList, aiNode& pSceneNode) const;
-
-	/// To create aiMesh and aiNode for it from <object>.
-	/// \param [in] pNodeElement - reference to node element which kept <object> data.
-	/// \param [out] pMeshList - reference to a list with all aiMesh of the scene.
-	/// \param [out] pSceneNode - pointer to place where new aiNode will be created.
-	void Postprocess_BuildNodeAndObject(const CAMFImporter_NodeElement_Object& pNodeElement, std::list<aiMesh*>& pMeshList, aiNode** pSceneNode);
-
-	/// Create mesh for every <volume> in <mesh>.
-	/// \param [in] pNodeElement - reference to node element which kept <mesh> data.
-	/// \param [in] pVertexCoordinateArray - reference to vertices coordinates for all <volume>'s.
-	/// \param [in] pVertexColorArray - reference to vertices colors for all <volume>'s. If color for vertex is not set then corresponding member of array
-	/// contain nullptr.
-	/// \param [in] pObjectColor - pointer to colors for <object>. If color is not set then argument contain nullptr.
-	/// \param [in] pMaterialList - reference to a list with defined materials.
-	/// \param [out] pMeshList - reference to a list with all aiMesh of the scene.
-	/// \param [out] pSceneNode - reference to aiNode which will own new aiMesh's.
-	void Postprocess_BuildMeshSet(const CAMFImporter_NodeElement_Mesh& pNodeElement, const std::vector<aiVector3D>& pVertexCoordinateArray,
-									const std::vector<CAMFImporter_NodeElement_Color*>& pVertexColorArray, const CAMFImporter_NodeElement_Color* pObjectColor,
-									std::list<aiMesh*>& pMeshList, aiNode& pSceneNode);
-
-	/// Convert material from \ref CAMFImporter_NodeElement_Material to \ref SPP_Material.
-	/// \param [in] pMaterial - source CAMFImporter_NodeElement_Material.
-	void Postprocess_BuildMaterial(const CAMFImporter_NodeElement_Material& pMaterial);
-
-	/// Create and add to aiNode's list new part of scene graph defined by <constellation>.
-	/// \param [in] pConstellation - reference to <constellation> node.
-	/// \param [out] pNodeList - reference to aiNode's list.
-	void Postprocess_BuildConstellation(CAMFImporter_NodeElement_Constellation& pConstellation, std::list<aiNode*>& pNodeList) const;
-
-	/// Build Assimp scene graph in aiScene from collected data.
-	/// \param [out] pScene - pointer to aiScene where tree will be built.
-	void Postprocess_BuildScene(aiScene* pScene);
-
-
-	/// Call that function when close tag of node not found and exception must be raised.
-	/// E.g.:
-	/// <amf>
-	///     <object>
-	/// </amf> <!--- object not closed --->
-	/// \throw DeadlyImportError.
-	/// \param [in] pNode - node name in which exception happened.
-	void Throw_CloseNotFound(const std::string& pNode);
-
-	/// Call that function when attribute name is incorrect and exception must be raised.
-	/// \param [in] pAttrName - attribute name.
-	/// \throw DeadlyImportError.
-	void Throw_IncorrectAttr(const std::string& pAttrName);
-
-	/// Call that function when attribute value is incorrect and exception must be raised.
-	/// \param [in] pAttrName - attribute name.
-	/// \throw DeadlyImportError.
-	void Throw_IncorrectAttrValue(const std::string& pAttrName);
-
-	/// Call that function when some type of nodes are defined twice or more when must be used only once and exception must be raised.
-	/// E.g.:
-	/// <object>
-	///     <color>...    <!--- color defined --->
-	///     <color>...    <!--- color defined again --->
-	/// </object>
-	/// \throw DeadlyImportError.
-	/// \param [in] pNodeType - type of node which defined one more time.
-	/// \param [in] pDescription - message about error. E.g. what the node defined while exception raised.
-	void Throw_MoreThanOnceDefined(const std::string& pNodeType, const std::string& pDescription);
-
-	/// Call that function when referenced element ID are not found in graph and exception must be raised.
-	/// \param [in] pID - ID of of element which not found.
-	/// \throw DeadlyImportError.
-	void Throw_ID_NotFound(const std::string& pID) const;
-
-	/// Check if current node have children: <node>...</node>. If not then exception will throwed.
-	void XML_CheckNode_MustHaveChildren();
-
-	/// Check if current node name is equal to pNodeName.
-	/// \param [in] pNodeName - name for checking.
-	/// return true if current node name is equal to pNodeName, else - false.
-	bool XML_CheckNode_NameEqual(const std::string& pNodeName) { return mReader->getNodeName() == pNodeName; }
-
-	/// Skip unsupported node and report about that. Depend on node name can be skipped begin tag of node all whole node.
-	/// \param [in] pParentNodeName - parent node name. Used for reporting.
-	void XML_CheckNode_SkipUnsupported(const std::string& pParentNodeName);
-
-	/// Search for specified node in file. XML file read pointer(mReader) will point to found node or file end after search is end.
-	/// \param [in] pNodeName - requested node name.
-	/// return true - if node is found, else - false.
-	bool XML_SearchNode(const std::string& pNodeName);
-
-	/// Read attribute value.
-	/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
-	/// \return read data.
-	bool XML_ReadNode_GetAttrVal_AsBool(const int pAttrIdx);
-
-	/// Read attribute value.
-	/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
-	/// \return read data.
-	float XML_ReadNode_GetAttrVal_AsFloat(const int pAttrIdx);
-
-	/// Read attribute value.
-	/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
-	/// \return read data.
-	uint32_t XML_ReadNode_GetAttrVal_AsU32(const int pAttrIdx);
-
-	/// Read node value.
-	/// \return read data.
-	float XML_ReadNode_GetVal_AsFloat();
-
-	/// Read node value.
-	/// \return read data.
-	uint32_t XML_ReadNode_GetVal_AsU32();
-
-	/// Read node value.
-	/// \return read data.
-	void XML_ReadNode_GetVal_AsString(std::string& pValue);
-
-	/// Make pNode as current and enter deeper for parsing child nodes. At end \ref ParseHelper_Node_Exit must be called.
-	/// \param [in] pNode - new current node.
-	void ParseHelper_Node_Enter(CAMFImporter_NodeElement* pNode);
-
-	/// This function must be called when exiting from grouping node. \ref ParseHelper_Group_Begin.
-	void ParseHelper_Node_Exit();
-
-	/// Attribute values of floating point types can take form ".x"(without leading zero). irrXMLReader can not read this form of values and it
-	/// must be converted to right form - "0.xxx".
-	/// \param [in] pInStr - pointer to input string which can contain incorrect form of values.
-	/// \param [out[ pOutString - output string with right form of values.
-	void ParseHelper_FixTruncatedFloatString(const char* pInStr, std::string& pOutString);
-
-	/// Decode Base64-encoded data.
-	/// \param [in] pInputBase64 - reference to input Base64-encoded string.
-	/// \param [out] pOutputData - reference to output array for decoded data.
-	void ParseHelper_Decode_Base64(const std::string& pInputBase64, std::vector<uint8_t>& pOutputData) const;
-
-	/// Parse <AMF> node of the file.
-	void ParseNode_Root();
-
-	/// Parse <constellation> node of the file.
-	void ParseNode_Constellation();
-
-	/// Parse <instance> node of the file.
-	void ParseNode_Instance();
-
-	/// Parse <material> node of the file.
-	void ParseNode_Material();
-
-	/// Parse <metadata> node.
-	void ParseNode_Metadata();
-
-	/// Parse <object> node of the file.
-	void ParseNode_Object();
-
-	/// Parse <texture> node of the file.
-	void ParseNode_Texture();
-
-	/// Parse <coordinates> node of the file.
-	void ParseNode_Coordinates();
-
-	/// Parse <edge> node of the file.
-	void ParseNode_Edge();
-
-	/// Parse <mesh> node of the file.
-	void ParseNode_Mesh();
-
-	/// Parse <triangle> node of the file.
-	void ParseNode_Triangle();
-
-	/// Parse <vertex> node of the file.
-	void ParseNode_Vertex();
-
-	/// Parse <vertices> node of the file.
-	void ParseNode_Vertices();
-
-	/// Parse <volume> node of the file.
-	void ParseNode_Volume();
-
-	/// Parse <color> node of the file.
-	void ParseNode_Color();
-
-	/// Parse <texmap> of <map> node of the file.
-	/// \param [in] pUseOldName - if true then use old name of node(and children) - <map>, instead of new name - <texmap>.
-	void ParseNode_TexMap(const bool pUseOldName = false);
-
-public:
-	/// Default constructor.
-	AMFImporter() AI_NO_EXCEPT
-    : mNodeElement_Cur(nullptr)
-    , mReader(nullptr) {
-        // empty
-    }
-
-	/// Default destructor.
-	~AMFImporter();
-
-	/// Parse AMF file and fill scene graph. The function has no return value. Result can be found by analyzing the generated graph.
-	/// Also exception can be thrown if trouble will found.
-	/// \param [in] pFile - name of file to be parsed.
-	/// \param [in] pIOHandler - pointer to IO helper object.
-	void ParseFile(const std::string& pFile, IOSystem* pIOHandler);
-
-	bool CanRead(const std::string& pFile, IOSystem* pIOHandler, bool pCheckSig) const;
-	void GetExtensionList(std::set<std::string>& pExtensionList);
-	void InternReadFile(const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler);
-	const aiImporterDesc* GetInfo ()const;
-
-    AMFImporter(const AMFImporter& pScene) = delete;
-    AMFImporter& operator=(const AMFImporter& pScene) = delete;
-
-private:
-    static const aiImporterDesc Description;
-
-    CAMFImporter_NodeElement* mNodeElement_Cur;///< Current element.
-    std::list<CAMFImporter_NodeElement*> mNodeElement_List;///< All elements of scene graph.
-    irr::io::IrrXMLReader* mReader;///< Pointer to XML-reader object
-    std::string mUnit;
-    std::list<SPP_Material> mMaterial_Converted;///< List of converted materials for postprocessing step.
-    std::list<SPP_Texture> mTexture_Converted;///< List of converted textures for postprocessing step.
-
-};
-
-}// namespace Assimp
-
-#endif // INCLUDED_AI_AMF_IMPORTER_H
diff --git a/Engine/lib/assimp/code/AMF/AMFImporter_Geometry.cpp b/Engine/lib/assimp/code/AMF/AMFImporter_Geometry.cpp
deleted file mode 100644
index f1538e3fb..000000000
--- a/Engine/lib/assimp/code/AMF/AMFImporter_Geometry.cpp
+++ /dev/null
@@ -1,357 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-/// \file AMFImporter_Geometry.cpp
-/// \brief Parsing data from geometry nodes.
-/// \date 2016
-/// \author smal.root@gmail.com
-
-#ifndef ASSIMP_BUILD_NO_AMF_IMPORTER
-
-#include "AMFImporter.hpp"
-#include "AMFImporter_Macro.hpp"
-
-namespace Assimp
-{
-
-// <mesh>
-// </mesh>
-// A 3D mesh hull.
-// Multi elements - Yes.
-// Parent element - <object>.
-void AMFImporter::ParseNode_Mesh()
-{
-CAMFImporter_NodeElement* ne;
-
-	// create new mesh object.
-	ne = new CAMFImporter_NodeElement_Mesh(mNodeElement_Cur);
-	// Check for child nodes
-	if(!mReader->isEmptyElement())
-	{
-		bool vert_read = false;
-
-		ParseHelper_Node_Enter(ne);
-		MACRO_NODECHECK_LOOPBEGIN("mesh");
-			if(XML_CheckNode_NameEqual("vertices"))
-			{
-				// Check if data already defined.
-				if(vert_read) Throw_MoreThanOnceDefined("vertices", "Only one vertices set can be defined for <mesh>.");
-				// read data and set flag about it
-				ParseNode_Vertices();
-				vert_read = true;
-
-				continue;
-			}
-
-			if(XML_CheckNode_NameEqual("volume")) { ParseNode_Volume(); continue; }
-		MACRO_NODECHECK_LOOPEND("mesh");
-		ParseHelper_Node_Exit();
-	}// if(!mReader->isEmptyElement())
-	else
-	{
-		mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element
-	}// if(!mReader->isEmptyElement()) else
-
-	mNodeElement_List.push_back(ne);// and to node element list because its a new object in graph.
-}
-
-// <vertices>
-// </vertices>
-// The list of vertices to be used in defining triangles.
-// Multi elements - No.
-// Parent element - <mesh>.
-void AMFImporter::ParseNode_Vertices()
-{
-CAMFImporter_NodeElement* ne;
-
-	// create new mesh object.
-	ne = new CAMFImporter_NodeElement_Vertices(mNodeElement_Cur);
-	// Check for child nodes
-	if(!mReader->isEmptyElement())
-	{
-		ParseHelper_Node_Enter(ne);
-		MACRO_NODECHECK_LOOPBEGIN("vertices");
-			if(XML_CheckNode_NameEqual("vertex")) { ParseNode_Vertex(); continue; }
-		MACRO_NODECHECK_LOOPEND("vertices");
-		ParseHelper_Node_Exit();
-	}// if(!mReader->isEmptyElement())
-	else
-	{
-		mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element
-	}// if(!mReader->isEmptyElement()) else
-
-	mNodeElement_List.push_back(ne);// and to node element list because its a new object in graph.
-}
-
-// <vertex>
-// </vertex>
-// A vertex to be referenced in triangles.
-// Multi elements - Yes.
-// Parent element - <vertices>.
-void AMFImporter::ParseNode_Vertex()
-{
-CAMFImporter_NodeElement* ne;
-
-	// create new mesh object.
-	ne = new CAMFImporter_NodeElement_Vertex(mNodeElement_Cur);
-	// Check for child nodes
-	if(!mReader->isEmptyElement())
-	{
-		bool col_read = false;
-		bool coord_read = false;
-
-		ParseHelper_Node_Enter(ne);
-		MACRO_NODECHECK_LOOPBEGIN("vertex");
-			if(XML_CheckNode_NameEqual("color"))
-			{
-				// Check if data already defined.
-				if(col_read) Throw_MoreThanOnceDefined("color", "Only one color can be defined for <vertex>.");
-				// read data and set flag about it
-				ParseNode_Color();
-				col_read = true;
-
-				continue;
-			}
-
-			if(XML_CheckNode_NameEqual("coordinates"))
-			{
-				// Check if data already defined.
-				if(coord_read) Throw_MoreThanOnceDefined("coordinates", "Only one coordinates set can be defined for <vertex>.");
-				// read data and set flag about it
-				ParseNode_Coordinates();
-				coord_read = true;
-
-				continue;
-			}
-
-			if(XML_CheckNode_NameEqual("metadata")) { ParseNode_Metadata(); continue; }
-		MACRO_NODECHECK_LOOPEND("vertex");
-		ParseHelper_Node_Exit();
-	}// if(!mReader->isEmptyElement())
-	else
-	{
-		mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element
-	}// if(!mReader->isEmptyElement()) else
-
-	mNodeElement_List.push_back(ne);// and to node element list because its a new object in graph.
-}
-
-// <coordinates>
-// </coordinates>
-// Specifies the 3D location of this vertex.
-// Multi elements - No.
-// Parent element - <vertex>.
-//
-// Children elements:
-//   <x>, <y>, <z>
-//   Multi elements - No.
-//   X, Y, or Z coordinate, respectively, of a vertex position in space.
-void AMFImporter::ParseNode_Coordinates()
-{
-CAMFImporter_NodeElement* ne;
-
-	// create new color object.
-	ne = new CAMFImporter_NodeElement_Coordinates(mNodeElement_Cur);
-
-	CAMFImporter_NodeElement_Coordinates& als = *((CAMFImporter_NodeElement_Coordinates*)ne);// alias for convenience
-
-	// Check for child nodes
-	if(!mReader->isEmptyElement())
-	{
-		bool read_flag[3] = { false, false, false };
-
-		ParseHelper_Node_Enter(ne);
-		MACRO_NODECHECK_LOOPBEGIN("coordinates");
-			MACRO_NODECHECK_READCOMP_F("x", read_flag[0], als.Coordinate.x);
-			MACRO_NODECHECK_READCOMP_F("y", read_flag[1], als.Coordinate.y);
-			MACRO_NODECHECK_READCOMP_F("z", read_flag[2], als.Coordinate.z);
-		MACRO_NODECHECK_LOOPEND("coordinates");
-		ParseHelper_Node_Exit();
-		// check that all components was defined
-		if((read_flag[0] && read_flag[1] && read_flag[2]) == 0) throw DeadlyImportError("Not all coordinate's components are defined.");
-
-	}// if(!mReader->isEmptyElement())
-	else
-	{
-		mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element
-	}// if(!mReader->isEmptyElement()) else
-
-	mNodeElement_List.push_back(ne);// and to node element list because its a new object in graph.
-}
-
-// <volume
-// materialid="" - Which material to use.
-// type=""       - What this volume describes can be “region� or “support�. If none specified, “object� is assumed. If support, then the geometric
-//                 requirements 1-8 listed in section 5 do not need to be maintained.
-// >
-// </volume>
-// Defines a volume from the established vertex list.
-// Multi elements - Yes.
-// Parent element - <mesh>.
-void AMFImporter::ParseNode_Volume()
-{
-std::string materialid;
-std::string type;
-CAMFImporter_NodeElement* ne;
-
-	// Read attributes for node <color>.
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECK_RET("materialid", materialid, mReader->getAttributeValue);
-		MACRO_ATTRREAD_CHECK_RET("type", type, mReader->getAttributeValue);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// create new object.
-	ne = new CAMFImporter_NodeElement_Volume(mNodeElement_Cur);
-	// and assign read data
-	((CAMFImporter_NodeElement_Volume*)ne)->MaterialID = materialid;
-	((CAMFImporter_NodeElement_Volume*)ne)->Type = type;
-	// Check for child nodes
-	if(!mReader->isEmptyElement())
-	{
-		bool col_read = false;
-
-		ParseHelper_Node_Enter(ne);
-		MACRO_NODECHECK_LOOPBEGIN("volume");
-			if(XML_CheckNode_NameEqual("color"))
-			{
-				// Check if data already defined.
-				if(col_read) Throw_MoreThanOnceDefined("color", "Only one color can be defined for <volume>.");
-				// read data and set flag about it
-				ParseNode_Color();
-				col_read = true;
-
-				continue;
-			}
-
-			if(XML_CheckNode_NameEqual("triangle")) { ParseNode_Triangle(); continue; }
-			if(XML_CheckNode_NameEqual("metadata")) { ParseNode_Metadata(); continue; }
-		MACRO_NODECHECK_LOOPEND("volume");
-		ParseHelper_Node_Exit();
-	}// if(!mReader->isEmptyElement())
-	else
-	{
-		mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element
-	}// if(!mReader->isEmptyElement()) else
-
-	mNodeElement_List.push_back(ne);// and to node element list because its a new object in graph.
-}
-
-// <triangle>
-// </triangle>
-// Defines a 3D triangle from three vertices, according to the right-hand rule (counter-clockwise when looking from the outside).
-// Multi elements - Yes.
-// Parent element - <volume>.
-//
-// Children elements:
-//   <v1>, <v2>, <v3>
-//   Multi elements - No.
-//   Index of the desired vertices in a triangle or edge.
-void AMFImporter::ParseNode_Triangle()
-{
-CAMFImporter_NodeElement* ne;
-
-	// create new color object.
-	ne = new CAMFImporter_NodeElement_Triangle(mNodeElement_Cur);
-
-	CAMFImporter_NodeElement_Triangle& als = *((CAMFImporter_NodeElement_Triangle*)ne);// alias for convenience
-
-	// Check for child nodes
-	if(!mReader->isEmptyElement())
-	{
-		bool col_read = false, tex_read = false;
-		bool read_flag[3] = { false, false, false };
-
-		ParseHelper_Node_Enter(ne);
-		MACRO_NODECHECK_LOOPBEGIN("triangle");
-			if(XML_CheckNode_NameEqual("color"))
-			{
-				// Check if data already defined.
-				if(col_read) Throw_MoreThanOnceDefined("color", "Only one color can be defined for <triangle>.");
-				// read data and set flag about it
-				ParseNode_Color();
-				col_read = true;
-
-				continue;
-			}
-
-			if(XML_CheckNode_NameEqual("texmap"))// new name of node: "texmap".
-			{
-				// Check if data already defined.
-				if(tex_read) Throw_MoreThanOnceDefined("texmap", "Only one texture coordinate can be defined for <triangle>.");
-				// read data and set flag about it
-				ParseNode_TexMap();
-				tex_read = true;
-
-				continue;
-			}
-			else if(XML_CheckNode_NameEqual("map"))// old name of node: "map".
-			{
-				// Check if data already defined.
-				if(tex_read) Throw_MoreThanOnceDefined("map", "Only one texture coordinate can be defined for <triangle>.");
-				// read data and set flag about it
-				ParseNode_TexMap(true);
-				tex_read = true;
-
-				continue;
-			}
-
-			MACRO_NODECHECK_READCOMP_U32("v1", read_flag[0], als.V[0]);
-			MACRO_NODECHECK_READCOMP_U32("v2", read_flag[1], als.V[1]);
-			MACRO_NODECHECK_READCOMP_U32("v3", read_flag[2], als.V[2]);
-		MACRO_NODECHECK_LOOPEND("triangle");
-		ParseHelper_Node_Exit();
-		// check that all components was defined
-		if((read_flag[0] && read_flag[1] && read_flag[2]) == 0) throw DeadlyImportError("Not all vertices of the triangle are defined.");
-
-	}// if(!mReader->isEmptyElement())
-	else
-	{
-		mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element
-	}// if(!mReader->isEmptyElement()) else
-
-	mNodeElement_List.push_back(ne);// and to node element list because its a new object in graph.
-}
-
-}// namespace Assimp
-
-#endif // !ASSIMP_BUILD_NO_AMF_IMPORTER
diff --git a/Engine/lib/assimp/code/AMF/AMFImporter_Macro.hpp b/Engine/lib/assimp/code/AMF/AMFImporter_Macro.hpp
deleted file mode 100644
index f60c5fbbb..000000000
--- a/Engine/lib/assimp/code/AMF/AMFImporter_Macro.hpp
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-/// \file AMFImporter_Macro.hpp
-/// \brief Useful macrodefines.
-/// \date 2016
-/// \author smal.root@gmail.com
-
-#pragma once
-#ifndef AMFIMPORTER_MACRO_HPP_INCLUDED
-#define AMFIMPORTER_MACRO_HPP_INCLUDED
-
-/// \def MACRO_ATTRREAD_LOOPBEG
-/// Begin of loop that read attributes values.
-#define MACRO_ATTRREAD_LOOPBEG \
-	for(int idx = 0, idx_end = mReader->getAttributeCount(); idx < idx_end; idx++) \
-	{ \
-		std::string an(mReader->getAttributeName(idx));
-
-/// \def MACRO_ATTRREAD_LOOPEND
-/// End of loop that read attributes values.
-#define MACRO_ATTRREAD_LOOPEND \
-		Throw_IncorrectAttr(an); \
-	}
-
-/// \def MACRO_ATTRREAD_LOOPEND_WSKIP
-/// End of loop that read attributes values. Difference from \ref MACRO_ATTRREAD_LOOPEND in that: current macro skip unknown attributes, but
-/// \ref MACRO_ATTRREAD_LOOPEND throw an exception.
-#define MACRO_ATTRREAD_LOOPEND_WSKIP \
-		continue; \
-	}
-
-/// \def MACRO_ATTRREAD_CHECK_REF
-/// Check current attribute name and if it equal to requested then read value. Result write to output variable by reference. If result was read then
-/// "continue" will called.
-/// \param [in] pAttrName - attribute name.
-/// \param [out] pVarName - output variable name.
-/// \param [in] pFunction - function which read attribute value and write it to pVarName.
-#define MACRO_ATTRREAD_CHECK_REF(pAttrName, pVarName, pFunction) \
-	if(an == pAttrName) \
-	{ \
-		pFunction(idx, pVarName); \
-		continue; \
-	}
-
-/// \def MACRO_ATTRREAD_CHECK_RET
-/// Check current attribute name and if it equal to requested then read value. Result write to output variable using return value of \ref pFunction.
-/// If result was read then  "continue" will called.
-/// \param [in] pAttrName - attribute name.
-/// \param [out] pVarName - output variable name.
-/// \param [in] pFunction - function which read attribute value and write it to pVarName.
-#define MACRO_ATTRREAD_CHECK_RET(pAttrName, pVarName, pFunction) \
-	if(an == pAttrName) \
-	{ \
-		pVarName = pFunction(idx); \
-		continue; \
-	}
-
-/// \def MACRO_NODECHECK_LOOPBEGIN(pNodeName)
-/// Begin of loop of parsing child nodes. Do not add ';' at end.
-/// \param [in] pNodeName - current node name.
-#define MACRO_NODECHECK_LOOPBEGIN(pNodeName) \
-	do { \
-	bool close_found = false; \
-	 \
-	while(mReader->read()) \
-	{ \
-		if(mReader->getNodeType() == irr::io::EXN_ELEMENT) \
-		{
-
-/// \def MACRO_NODECHECK_LOOPEND(pNodeName)
-/// End of loop of parsing child nodes.
-/// \param [in] pNodeName - current node name.
-#define MACRO_NODECHECK_LOOPEND(pNodeName) \
-			XML_CheckNode_SkipUnsupported(pNodeName); \
-		}/* if(mReader->getNodeType() == irr::io::EXN_ELEMENT) */ \
-		else if(mReader->getNodeType() == irr::io::EXN_ELEMENT_END) \
-		{ \
-			if(XML_CheckNode_NameEqual(pNodeName)) \
-			{ \
-				close_found = true; \
-	 \
-				break; \
-			} \
-		}/* else if(mReader->getNodeType() == irr::io::EXN_ELEMENT_END) */ \
-	}/* while(mReader->read()) */ \
-	 \
-	if(!close_found) Throw_CloseNotFound(pNodeName); \
-	 \
-	} while(false)
-
-/// \def MACRO_NODECHECK_READCOMP_F
-/// Check current node name and if it equal to requested then read value. Result write to output variable of type "float".
-/// If result was read then  "continue" will called. Also check if node data already read then raise exception.
-/// \param [in] pNodeName - node name.
-/// \param [in, out] pReadFlag - read flag.
-/// \param [out] pVarName - output variable name.
-#define MACRO_NODECHECK_READCOMP_F(pNodeName, pReadFlag, pVarName) \
-	if(XML_CheckNode_NameEqual(pNodeName)) \
-	{ \
-		/* Check if field already read before. */ \
-		if(pReadFlag) Throw_MoreThanOnceDefined(pNodeName, "Only one component can be defined."); \
-		/* Read color component and assign it to object. */ \
-		pVarName = XML_ReadNode_GetVal_AsFloat(); \
-		pReadFlag = true; \
-		continue; \
-	}
-
-/// \def MACRO_NODECHECK_READCOMP_U32
-/// Check current node name and if it equal to requested then read value. Result write to output variable of type "uint32_t".
-/// If result was read then  "continue" will called. Also check if node data already read then raise exception.
-/// \param [in] pNodeName - node name.
-/// \param [in, out] pReadFlag - read flag.
-/// \param [out] pVarName - output variable name.
-#define MACRO_NODECHECK_READCOMP_U32(pNodeName, pReadFlag, pVarName) \
-	if(XML_CheckNode_NameEqual(pNodeName)) \
-	{ \
-		/* Check if field already read before. */ \
-		if(pReadFlag) Throw_MoreThanOnceDefined(pNodeName, "Only one component can be defined."); \
-		/* Read color component and assign it to object. */ \
-		pVarName = XML_ReadNode_GetVal_AsU32(); \
-		pReadFlag = true; \
-		continue; \
-	}
-
-#endif // AMFIMPORTER_MACRO_HPP_INCLUDED
diff --git a/Engine/lib/assimp/code/AMF/AMFImporter_Node.hpp b/Engine/lib/assimp/code/AMF/AMFImporter_Node.hpp
deleted file mode 100644
index a1bf9f008..000000000
--- a/Engine/lib/assimp/code/AMF/AMFImporter_Node.hpp
+++ /dev/null
@@ -1,340 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-/// \file AMFImporter_Node.hpp
-/// \brief Elements of scene graph.
-/// \date 2016
-/// \author smal.root@gmail.com
-
-#pragma once
-#ifndef INCLUDED_AI_AMF_IMPORTER_NODE_H
-#define INCLUDED_AI_AMF_IMPORTER_NODE_H
-
-// Header files, stdlib.
-#include <list>
-#include <string>
-#include <vector>
-
-// Header files, Assimp.
-#include "assimp/types.h"
-#include "assimp/scene.h"
-
-/// \class CAMFImporter_NodeElement
-/// Base class for elements of nodes.
-class CAMFImporter_NodeElement {
-public:
-	/// Define what data type contain node element.
-	enum EType {
-		ENET_Color,        ///< Color element: <color>.
-		ENET_Constellation,///< Grouping element: <constellation>.
-		ENET_Coordinates,  ///< Coordinates element: <coordinates>.
-		ENET_Edge,         ///< Edge element: <edge>.
-		ENET_Instance,     ///< Grouping element: <constellation>.
-		ENET_Material,     ///< Material element: <material>.
-		ENET_Metadata,     ///< Metadata element: <metadata>.
-		ENET_Mesh,         ///< Metadata element: <mesh>.
-		ENET_Object,       ///< Element which hold object: <object>.
-		ENET_Root,         ///< Root element: <amf>.
-		ENET_Triangle,     ///< Triangle element: <triangle>.
-		ENET_TexMap,       ///< Texture coordinates element: <texmap> or <map>.
-		ENET_Texture,      ///< Texture element: <texture>.
-		ENET_Vertex,       ///< Vertex element: <vertex>.
-		ENET_Vertices,     ///< Vertex element: <vertices>.
-		ENET_Volume,       ///< Volume element: <volume>.
-
-		ENET_Invalid       ///< Element has invalid type and possible contain invalid data.
-	};
-
-	const EType Type;///< Type of element.
-	std::string ID;///< ID of element.
-	CAMFImporter_NodeElement* Parent;///< Parent element. If nullptr then this node is root.
-	std::list<CAMFImporter_NodeElement*> Child;///< Child elements.
-
-public:                                               /// Destructor, virtual..
-    virtual ~CAMFImporter_NodeElement() {
-        // empty
-    }
-
-	/// Disabled copy constructor and co.
-	CAMFImporter_NodeElement(const CAMFImporter_NodeElement& pNodeElement) = delete;
-    CAMFImporter_NodeElement(CAMFImporter_NodeElement&&) = delete;
-    CAMFImporter_NodeElement& operator=(const CAMFImporter_NodeElement& pNodeElement) = delete;
-	CAMFImporter_NodeElement() = delete;
-
-protected:
-	/// In constructor inheritor must set element type.
-	/// \param [in] pType - element type.
-	/// \param [in] pParent - parent element.
-	CAMFImporter_NodeElement(const EType pType, CAMFImporter_NodeElement* pParent)
-	: Type(pType)
-    , ID()
-    , Parent(pParent)
-    , Child() {
-        // empty
-    }
-};// class IAMFImporter_NodeElement
-
-/// \struct CAMFImporter_NodeElement_Constellation
-/// A collection of objects or constellations with specific relative locations.
-struct CAMFImporter_NodeElement_Constellation : public CAMFImporter_NodeElement {
-	/// Constructor.
-	/// \param [in] pParent - pointer to parent node.
-	CAMFImporter_NodeElement_Constellation(CAMFImporter_NodeElement* pParent)
-		: CAMFImporter_NodeElement(ENET_Constellation, pParent)
-	{}
-
-};// struct CAMFImporter_NodeElement_Constellation
-
-/// \struct CAMFImporter_NodeElement_Instance
-/// Part of constellation.
-struct CAMFImporter_NodeElement_Instance : public CAMFImporter_NodeElement {
-
-	std::string ObjectID;///< ID of object for instantiation.
-	/// \var Delta - The distance of translation in the x, y, or z direction, respectively, in the referenced object's coordinate system, to
-	/// create an instance of the object in the current constellation.
-	aiVector3D Delta;
-
-	/// \var Rotation - The rotation, in degrees, to rotate the referenced object about its x, y, and z axes, respectively, to create an
-	/// instance of the object in the current constellation. Rotations shall be executed in order of x first, then y, then z.
-	aiVector3D Rotation;
-
-	/// Constructor.
-	/// \param [in] pParent - pointer to parent node.
-	CAMFImporter_NodeElement_Instance(CAMFImporter_NodeElement* pParent)
-		: CAMFImporter_NodeElement(ENET_Instance, pParent)
-	{}
-};
-
-/// \struct CAMFImporter_NodeElement_Metadata
-/// Structure that define metadata node.
-struct CAMFImporter_NodeElement_Metadata : public CAMFImporter_NodeElement {
-
-	std::string Type;///< Type of "Value". 
-	std::string Value;///< Value.
-
-	/// Constructor.
-	/// \param [in] pParent - pointer to parent node.
-	CAMFImporter_NodeElement_Metadata(CAMFImporter_NodeElement* pParent)
-		: CAMFImporter_NodeElement(ENET_Metadata, pParent)
-	{}
-};
-
-/// \struct CAMFImporter_NodeElement_Root
-/// Structure that define root node.
-struct CAMFImporter_NodeElement_Root : public CAMFImporter_NodeElement {
-
-	std::string Unit;///< The units to be used. May be "inch", "millimeter", "meter", "feet", or "micron".
-	std::string Version;///< Version of format.
-
-	/// Constructor.
-	/// \param [in] pParent - pointer to parent node.
-	CAMFImporter_NodeElement_Root(CAMFImporter_NodeElement* pParent)
-		: CAMFImporter_NodeElement(ENET_Root, pParent)
-	{}
-};
-
-/// \struct CAMFImporter_NodeElement_Color
-/// Structure that define object node.
-struct CAMFImporter_NodeElement_Color : public CAMFImporter_NodeElement {
-	bool Composed;                  ///< Type of color stored: if true then look for formula in \ref Color_Composed[4], else - in \ref Color.
-	std::string Color_Composed[4];  ///< By components formulas of composed color. [0..3] - RGBA.
-	aiColor4D Color;                ///< Constant color.
-	std::string Profile;            ///< The ICC color space used to interpret the three color channels r, g and b..
-
-	/// @brief  Constructor.
-	/// @param [in] pParent - pointer to parent node.
-	CAMFImporter_NodeElement_Color(CAMFImporter_NodeElement* pParent)
-	: CAMFImporter_NodeElement(ENET_Color, pParent)
-    , Composed( false )
-    , Color()
-    , Profile() {
-        // empty
-    }
-};
-
-/// \struct CAMFImporter_NodeElement_Material
-/// Structure that define material node.
-struct CAMFImporter_NodeElement_Material : public CAMFImporter_NodeElement {
-	
-	/// Constructor.
-	/// \param [in] pParent - pointer to parent node.
-	CAMFImporter_NodeElement_Material(CAMFImporter_NodeElement* pParent)
-		: CAMFImporter_NodeElement(ENET_Material, pParent)
-	{}
-
-};
-
-/// \struct CAMFImporter_NodeElement_Object
-/// Structure that define object node.
-struct CAMFImporter_NodeElement_Object : public CAMFImporter_NodeElement {
-
-    /// Constructor.
-	/// \param [in] pParent - pointer to parent node.
-	CAMFImporter_NodeElement_Object(CAMFImporter_NodeElement* pParent)
-		: CAMFImporter_NodeElement(ENET_Object, pParent)
-	{}
-};
-
-/// \struct CAMFImporter_NodeElement_Mesh
-/// Structure that define mesh node.
-struct CAMFImporter_NodeElement_Mesh : public CAMFImporter_NodeElement {
-	/// Constructor.
-	/// \param [in] pParent - pointer to parent node.
-	CAMFImporter_NodeElement_Mesh(CAMFImporter_NodeElement* pParent)
-		: CAMFImporter_NodeElement(ENET_Mesh, pParent)
-	{}
-};
-
-/// \struct CAMFImporter_NodeElement_Vertex
-/// Structure that define vertex node.
-struct CAMFImporter_NodeElement_Vertex : public CAMFImporter_NodeElement {
-	/// Constructor.
-	/// \param [in] pParent - pointer to parent node.
-	CAMFImporter_NodeElement_Vertex(CAMFImporter_NodeElement* pParent)
-		: CAMFImporter_NodeElement(ENET_Vertex, pParent)
-	{}
-};
-
-/// \struct CAMFImporter_NodeElement_Edge
-/// Structure that define edge node.
-struct CAMFImporter_NodeElement_Edge : public CAMFImporter_NodeElement {
-	/// Constructor.
-	/// \param [in] pParent - pointer to parent node.
-	CAMFImporter_NodeElement_Edge(CAMFImporter_NodeElement* pParent)
-		: CAMFImporter_NodeElement(ENET_Edge, pParent)
-	{}
-
-};
-
-/// \struct CAMFImporter_NodeElement_Vertices
-/// Structure that define vertices node.
-struct CAMFImporter_NodeElement_Vertices : public CAMFImporter_NodeElement {
-	/// Constructor.
-	/// \param [in] pParent - pointer to parent node.
-	CAMFImporter_NodeElement_Vertices(CAMFImporter_NodeElement* pParent)
-		: CAMFImporter_NodeElement(ENET_Vertices, pParent)
-	{}
-};
-
-/// \struct CAMFImporter_NodeElement_Volume
-/// Structure that define volume node.
-struct CAMFImporter_NodeElement_Volume : public CAMFImporter_NodeElement {
-	std::string MaterialID;///< Which material to use.
-	std::string Type;///< What this volume describes can be “region� or “support�. If none specified, “object� is assumed.
-
-	/// Constructor.
-	/// \param [in] pParent - pointer to parent node.
-	CAMFImporter_NodeElement_Volume(CAMFImporter_NodeElement* pParent)
-		: CAMFImporter_NodeElement(ENET_Volume, pParent)
-	{}
-};
-
-/// \struct CAMFImporter_NodeElement_Coordinates
-/// Structure that define coordinates node.
-struct CAMFImporter_NodeElement_Coordinates : public CAMFImporter_NodeElement
-{
-	aiVector3D Coordinate;///< Coordinate.
-
-	/// Constructor.
-	/// \param [in] pParent - pointer to parent node.
-	CAMFImporter_NodeElement_Coordinates(CAMFImporter_NodeElement* pParent)
-		: CAMFImporter_NodeElement(ENET_Coordinates, pParent)
-	{}
-
-};
-
-/// \struct CAMFImporter_NodeElement_TexMap
-/// Structure that define texture coordinates node.
-struct CAMFImporter_NodeElement_TexMap : public CAMFImporter_NodeElement {
-	aiVector3D TextureCoordinate[3];///< Texture coordinates.
-	std::string TextureID_R;///< Texture ID for red color component.
-	std::string TextureID_G;///< Texture ID for green color component.
-	std::string TextureID_B;///< Texture ID for blue color component.
-	std::string TextureID_A;///< Texture ID for alpha color component.
-
-	/// Constructor.
-	/// \param [in] pParent - pointer to parent node.
-	CAMFImporter_NodeElement_TexMap(CAMFImporter_NodeElement* pParent)
-	: CAMFImporter_NodeElement(ENET_TexMap, pParent)
-    , TextureCoordinate{}
-    , TextureID_R()
-    , TextureID_G()
-    , TextureID_B()
-    , TextureID_A()	{
-        // empty
-    }
-};
-
-/// \struct CAMFImporter_NodeElement_Triangle
-/// Structure that define triangle node.
-struct CAMFImporter_NodeElement_Triangle : public CAMFImporter_NodeElement {
-	size_t V[3];///< Triangle vertices.
-
-	/// Constructor.
-	/// \param [in] pParent - pointer to parent node.
-	CAMFImporter_NodeElement_Triangle(CAMFImporter_NodeElement* pParent)
-	: CAMFImporter_NodeElement(ENET_Triangle, pParent) {
-        // empty
-    }
-};
-
-/// Structure that define texture node.
-struct CAMFImporter_NodeElement_Texture : public CAMFImporter_NodeElement {
-	size_t Width, Height, Depth;///< Size of the texture.
-	std::vector<uint8_t> Data;///< Data of the texture.
-	bool Tiled;
-
-	/// Constructor.
-	/// \param [in] pParent - pointer to parent node.
-	CAMFImporter_NodeElement_Texture(CAMFImporter_NodeElement* pParent)
-	: CAMFImporter_NodeElement(ENET_Texture, pParent)
-    , Width( 0 )
-    , Height( 0 )
-    , Depth( 0 )
-    , Data()
-    , Tiled( false ){
-        // empty
-    }
-};
-
-#endif // INCLUDED_AI_AMF_IMPORTER_NODE_H
diff --git a/Engine/lib/assimp/code/AMF/AMFImporter_Postprocess.cpp b/Engine/lib/assimp/code/AMF/AMFImporter_Postprocess.cpp
deleted file mode 100644
index 79b5e15e2..000000000
--- a/Engine/lib/assimp/code/AMF/AMFImporter_Postprocess.cpp
+++ /dev/null
@@ -1,978 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-/// \file AMFImporter_Postprocess.cpp
-/// \brief Convert built scenegraph and objects to Assimp scenegraph.
-/// \date 2016
-/// \author smal.root@gmail.com
-
-#ifndef ASSIMP_BUILD_NO_AMF_IMPORTER
-
-#include "AMFImporter.hpp"
-
-// Header files, Assimp.
-#include <assimp/SceneCombiner.h>
-#include <assimp/StandardShapes.h>
-#include <assimp/StringUtils.h>
-
-// Header files, stdlib.
-#include <iterator>
-
-namespace Assimp
-{
-
-aiColor4D AMFImporter::SPP_Material::GetColor(const float /*pX*/, const float /*pY*/, const float /*pZ*/) const
-{
-    aiColor4D tcol;
-
-	// Check if stored data are supported.
-	if(!Composition.empty())
-	{
-		throw DeadlyImportError("IME. GetColor for composition");
-	}
-	else if(Color->Composed)
-	{
-		throw DeadlyImportError("IME. GetColor, composed color");
-	}
-	else
-	{
-		tcol = Color->Color;
-	}
-
-	// Check if default color must be used
-	if((tcol.r == 0) && (tcol.g == 0) && (tcol.b == 0) && (tcol.a == 0))
-	{
-		tcol.r = 0.5f;
-		tcol.g = 0.5f;
-		tcol.b = 0.5f;
-		tcol.a = 1;
-	}
-
-	return tcol;
-}
-
-void AMFImporter::PostprocessHelper_CreateMeshDataArray(const CAMFImporter_NodeElement_Mesh& pNodeElement, std::vector<aiVector3D>& pVertexCoordinateArray,
-														std::vector<CAMFImporter_NodeElement_Color*>& pVertexColorArray) const
-{
-    CAMFImporter_NodeElement_Vertices* vn = nullptr;
-    size_t col_idx;
-
-	// All data stored in "vertices", search for it.
-	for(CAMFImporter_NodeElement* ne_child: pNodeElement.Child)
-	{
-		if(ne_child->Type == CAMFImporter_NodeElement::ENET_Vertices) vn = (CAMFImporter_NodeElement_Vertices*)ne_child;
-	}
-
-	// If "vertices" not found then no work for us.
-	if(vn == nullptr) return;
-
-	pVertexCoordinateArray.reserve(vn->Child.size());// all coordinates stored as child and we need to reserve space for future push_back's.
-	pVertexColorArray.resize(vn->Child.size());// colors count equal vertices count.
-	col_idx = 0;
-	// Inside vertices collect all data and place to arrays
-	for(CAMFImporter_NodeElement* vn_child: vn->Child)
-	{
-		// vertices, colors
-		if(vn_child->Type == CAMFImporter_NodeElement::ENET_Vertex)
-		{
-			// by default clear color for current vertex
-			pVertexColorArray[col_idx] = nullptr;
-
-			for(CAMFImporter_NodeElement* vtx: vn_child->Child)
-			{
-				if(vtx->Type == CAMFImporter_NodeElement::ENET_Coordinates)
-				{
-					pVertexCoordinateArray.push_back(((CAMFImporter_NodeElement_Coordinates*)vtx)->Coordinate);
-
-					continue;
-				}
-
-				if(vtx->Type == CAMFImporter_NodeElement::ENET_Color)
-				{
-					pVertexColorArray[col_idx] = (CAMFImporter_NodeElement_Color*)vtx;
-
-					continue;
-				}
-			}// for(CAMFImporter_NodeElement* vtx: vn_child->Child)
-
-			col_idx++;
-		}// if(vn_child->Type == CAMFImporter_NodeElement::ENET_Vertex)
-	}// for(CAMFImporter_NodeElement* vn_child: vn->Child)
-}
-
-size_t AMFImporter::PostprocessHelper_GetTextureID_Or_Create(const std::string& pID_R, const std::string& pID_G, const std::string& pID_B,
-																const std::string& pID_A)
-{
-    size_t TextureConverted_Index;
-    std::string TextureConverted_ID;
-
-	// check input data
-	if(pID_R.empty() && pID_G.empty() && pID_B.empty() && pID_A.empty())
-		throw DeadlyImportError("PostprocessHelper_GetTextureID_Or_Create. At least one texture ID must be defined.");
-
-	// Create ID
-	TextureConverted_ID = pID_R + "_" + pID_G + "_" + pID_B + "_" + pID_A;
-	// Check if texture specified by set of IDs is converted already.
-	TextureConverted_Index = 0;
-	for(const SPP_Texture& tex_convd: mTexture_Converted)
-	{
-        if ( tex_convd.ID == TextureConverted_ID ) {
-            return TextureConverted_Index;
-        } else {
-            ++TextureConverted_Index;
-        }
-	}
-
-	//
-	// Converted texture not found, create it.
-	//
-	CAMFImporter_NodeElement_Texture* src_texture[4]{nullptr};
-	std::vector<CAMFImporter_NodeElement_Texture*> src_texture_4check;
-	SPP_Texture converted_texture;
-
-	{// find all specified source textures
-		CAMFImporter_NodeElement* t_tex;
-
-		// R
-		if(!pID_R.empty())
-		{
-			if(!Find_NodeElement(pID_R, CAMFImporter_NodeElement::ENET_Texture, &t_tex)) Throw_ID_NotFound(pID_R);
-
-			src_texture[0] = (CAMFImporter_NodeElement_Texture*)t_tex;
-			src_texture_4check.push_back((CAMFImporter_NodeElement_Texture*)t_tex);
-		}
-		else
-		{
-			src_texture[0] = nullptr;
-		}
-
-		// G
-		if(!pID_G.empty())
-		{
-			if(!Find_NodeElement(pID_G, CAMFImporter_NodeElement::ENET_Texture, &t_tex)) Throw_ID_NotFound(pID_G);
-
-			src_texture[1] = (CAMFImporter_NodeElement_Texture*)t_tex;
-			src_texture_4check.push_back((CAMFImporter_NodeElement_Texture*)t_tex);
-		}
-		else
-		{
-			src_texture[1] = nullptr;
-		}
-
-		// B
-		if(!pID_B.empty())
-		{
-			if(!Find_NodeElement(pID_B, CAMFImporter_NodeElement::ENET_Texture, &t_tex)) Throw_ID_NotFound(pID_B);
-
-			src_texture[2] = (CAMFImporter_NodeElement_Texture*)t_tex;
-			src_texture_4check.push_back((CAMFImporter_NodeElement_Texture*)t_tex);
-		}
-		else
-		{
-			src_texture[2] = nullptr;
-		}
-
-		// A
-		if(!pID_A.empty())
-		{
-			if(!Find_NodeElement(pID_A, CAMFImporter_NodeElement::ENET_Texture, &t_tex)) Throw_ID_NotFound(pID_A);
-
-			src_texture[3] = (CAMFImporter_NodeElement_Texture*)t_tex;
-			src_texture_4check.push_back((CAMFImporter_NodeElement_Texture*)t_tex);
-		}
-		else
-		{
-			src_texture[3] = nullptr;
-		}
-	}// END: find all specified source textures
-
-	// check that all textures has same size
-	if(src_texture_4check.size() > 1)
-	{
-		for (size_t i = 0, i_e = (src_texture_4check.size() - 1); i < i_e; i++)
-		{
-			if((src_texture_4check[i]->Width != src_texture_4check[i + 1]->Width) || (src_texture_4check[i]->Height != src_texture_4check[i + 1]->Height) ||
-				(src_texture_4check[i]->Depth != src_texture_4check[i + 1]->Depth))
-			{
-				throw DeadlyImportError("PostprocessHelper_GetTextureID_Or_Create. Source texture must has the same size.");
-			}
-		}
-	}// if(src_texture_4check.size() > 1)
-
-	// set texture attributes
-	converted_texture.Width = src_texture_4check[0]->Width;
-	converted_texture.Height = src_texture_4check[0]->Height;
-	converted_texture.Depth = src_texture_4check[0]->Depth;
-	// if one of source texture is tiled then converted texture is tiled too.
-	converted_texture.Tiled = false;
-	for(uint8_t i = 0; i < src_texture_4check.size(); i++) converted_texture.Tiled |= src_texture_4check[i]->Tiled;
-
-	// Create format hint.
-	strcpy(converted_texture.FormatHint, "rgba0000");// copy initial string.
-	if(!pID_R.empty()) converted_texture.FormatHint[4] = '8';
-	if(!pID_G.empty()) converted_texture.FormatHint[5] = '8';
-	if(!pID_B.empty()) converted_texture.FormatHint[6] = '8';
-	if(!pID_A.empty()) converted_texture.FormatHint[7] = '8';
-
-	//
-	// Сopy data of textures.
-	//
-	size_t tex_size = 0;
-	size_t step = 0;
-	size_t off_g = 0;
-	size_t off_b = 0;
-
-	// Calculate size of the target array and rule how data will be copied.
-    if(!pID_R.empty() && nullptr != src_texture[ 0 ] ) {
-        tex_size += src_texture[0]->Data.size(); step++, off_g++, off_b++;
-    }
-    if(!pID_G.empty() && nullptr != src_texture[ 1 ] ) {
-        tex_size += src_texture[1]->Data.size(); step++, off_b++;
-    }
-    if(!pID_B.empty() && nullptr != src_texture[ 2 ] ) {
-        tex_size += src_texture[2]->Data.size(); step++;
-    }
-    if(!pID_A.empty() && nullptr != src_texture[ 3 ] ) {
-        tex_size += src_texture[3]->Data.size(); step++;
-    }
-
-    // Create target array.
-	converted_texture.Data = new uint8_t[tex_size];
-	// And copy data
-	auto CopyTextureData = [&](const std::string& pID, const size_t pOffset, const size_t pStep, const uint8_t pSrcTexNum) -> void
-	{
-		if(!pID.empty())
-		{
-			for(size_t idx_target = pOffset, idx_src = 0; idx_target < tex_size; idx_target += pStep, idx_src++) {
-				CAMFImporter_NodeElement_Texture* tex = src_texture[pSrcTexNum];
-				ai_assert(tex);
-				converted_texture.Data[idx_target] = tex->Data.at(idx_src);
-			}
-		}
-	};// auto CopyTextureData = [&](const size_t pOffset, const size_t pStep, const uint8_t pSrcTexNum) -> void
-
-	CopyTextureData(pID_R, 0, step, 0);
-	CopyTextureData(pID_G, off_g, step, 1);
-	CopyTextureData(pID_B, off_b, step, 2);
-	CopyTextureData(pID_A, step - 1, step, 3);
-
-	// Store new converted texture ID
-	converted_texture.ID = TextureConverted_ID;
-	// Store new converted texture
-	mTexture_Converted.push_back(converted_texture);
-
-	return TextureConverted_Index;
-}
-
-void AMFImporter::PostprocessHelper_SplitFacesByTextureID(std::list<SComplexFace>& pInputList, std::list<std::list<SComplexFace> >& pOutputList_Separated)
-{
-    auto texmap_is_equal = [](const CAMFImporter_NodeElement_TexMap* pTexMap1, const CAMFImporter_NodeElement_TexMap* pTexMap2) -> bool
-    {
-	    if((pTexMap1 == nullptr) && (pTexMap2 == nullptr)) return true;
-	    if(pTexMap1 == nullptr) return false;
-	    if(pTexMap2 == nullptr) return false;
-
-	    if(pTexMap1->TextureID_R != pTexMap2->TextureID_R) return false;
-	    if(pTexMap1->TextureID_G != pTexMap2->TextureID_G) return false;
-	    if(pTexMap1->TextureID_B != pTexMap2->TextureID_B) return false;
-	    if(pTexMap1->TextureID_A != pTexMap2->TextureID_A) return false;
-
-	    return true;
-    };
-
-	pOutputList_Separated.clear();
-	if(pInputList.empty()) return;
-
-	do
-	{
-		SComplexFace face_start = pInputList.front();
-		std::list<SComplexFace> face_list_cur;
-
-		for(std::list<SComplexFace>::iterator it = pInputList.begin(), it_end = pInputList.end(); it != it_end;)
-		{
-			if(texmap_is_equal(face_start.TexMap, it->TexMap))
-			{
-				auto it_old = it;
-
-				++it;
-				face_list_cur.push_back(*it_old);
-				pInputList.erase(it_old);
-			}
-			else
-			{
-				++it;
-			}
-		}
-
-		if(!face_list_cur.empty()) pOutputList_Separated.push_back(face_list_cur);
-
-	} while(!pInputList.empty());
-}
-
-void AMFImporter::Postprocess_AddMetadata(const std::list<CAMFImporter_NodeElement_Metadata*>& metadataList, aiNode& sceneNode) const
-{
-	if ( !metadataList.empty() )
-	{
-		if(sceneNode.mMetaData != nullptr) throw DeadlyImportError("Postprocess. MetaData member in node are not nullptr. Something went wrong.");
-
-		// copy collected metadata to output node.
-        sceneNode.mMetaData = aiMetadata::Alloc( static_cast<unsigned int>(metadataList.size()) );
-		size_t meta_idx( 0 );
-
-		for(const CAMFImporter_NodeElement_Metadata& metadata: metadataList)
-		{
-			sceneNode.mMetaData->Set(static_cast<unsigned int>(meta_idx++), metadata.Type, aiString(metadata.Value));
-		}
-	}// if(!metadataList.empty())
-}
-
-void AMFImporter::Postprocess_BuildNodeAndObject(const CAMFImporter_NodeElement_Object& pNodeElement, std::list<aiMesh*>& pMeshList, aiNode** pSceneNode)
-{
-CAMFImporter_NodeElement_Color* object_color = nullptr;
-
-	// create new aiNode and set name as <object> has.
-	*pSceneNode = new aiNode;
-	(*pSceneNode)->mName = pNodeElement.ID;
-	// read mesh and color
-	for(const CAMFImporter_NodeElement* ne_child: pNodeElement.Child)
-	{
-		std::vector<aiVector3D> vertex_arr;
-		std::vector<CAMFImporter_NodeElement_Color*> color_arr;
-
-		// color for object
-		if(ne_child->Type == CAMFImporter_NodeElement::ENET_Color) object_color = (CAMFImporter_NodeElement_Color*)ne_child;
-
-		if(ne_child->Type == CAMFImporter_NodeElement::ENET_Mesh)
-		{
-			// Create arrays from children of mesh: vertices.
-			PostprocessHelper_CreateMeshDataArray(*((CAMFImporter_NodeElement_Mesh*)ne_child), vertex_arr, color_arr);
-			// Use this arrays as a source when creating every aiMesh
-			Postprocess_BuildMeshSet(*((CAMFImporter_NodeElement_Mesh*)ne_child), vertex_arr, color_arr, object_color, pMeshList, **pSceneNode);
-		}
-	}// for(const CAMFImporter_NodeElement* ne_child: pNodeElement)
-}
-
-void AMFImporter::Postprocess_BuildMeshSet(const CAMFImporter_NodeElement_Mesh& pNodeElement, const std::vector<aiVector3D>& pVertexCoordinateArray,
-											const std::vector<CAMFImporter_NodeElement_Color*>& pVertexColorArray,
-											const CAMFImporter_NodeElement_Color* pObjectColor, std::list<aiMesh*>& pMeshList, aiNode& pSceneNode)
-{
-std::list<unsigned int> mesh_idx;
-
-	// all data stored in "volume", search for it.
-	for(const CAMFImporter_NodeElement* ne_child: pNodeElement.Child)
-	{
-		const CAMFImporter_NodeElement_Color* ne_volume_color = nullptr;
-		const SPP_Material* cur_mat = nullptr;
-
-		if(ne_child->Type == CAMFImporter_NodeElement::ENET_Volume)
-		{
-			/******************* Get faces *******************/
-			const CAMFImporter_NodeElement_Volume* ne_volume = reinterpret_cast<const CAMFImporter_NodeElement_Volume*>(ne_child);
-
-			std::list<SComplexFace> complex_faces_list;// List of the faces of the volume.
-			std::list<std::list<SComplexFace> > complex_faces_toplist;// List of the face list for every mesh.
-
-			// check if volume use material
-			if(!ne_volume->MaterialID.empty())
-			{
-				if(!Find_ConvertedMaterial(ne_volume->MaterialID, &cur_mat)) Throw_ID_NotFound(ne_volume->MaterialID);
-			}
-
-			// inside "volume" collect all data and place to arrays or create new objects
-			for(const CAMFImporter_NodeElement* ne_volume_child: ne_volume->Child)
-			{
-				// color for volume
-				if(ne_volume_child->Type == CAMFImporter_NodeElement::ENET_Color)
-				{
-					ne_volume_color = reinterpret_cast<const CAMFImporter_NodeElement_Color*>(ne_volume_child);
-				}
-				else if(ne_volume_child->Type == CAMFImporter_NodeElement::ENET_Triangle)// triangles, triangles colors
-				{
-					const CAMFImporter_NodeElement_Triangle& tri_al = *reinterpret_cast<const CAMFImporter_NodeElement_Triangle*>(ne_volume_child);
-
-					SComplexFace complex_face;
-
-					// initialize pointers
-					complex_face.Color = nullptr;
-					complex_face.TexMap = nullptr;
-					// get data from triangle children: color, texture coordinates.
-					if(tri_al.Child.size())
-					{
-						for(const CAMFImporter_NodeElement* ne_triangle_child: tri_al.Child)
-						{
-							if(ne_triangle_child->Type == CAMFImporter_NodeElement::ENET_Color)
-								complex_face.Color = reinterpret_cast<const CAMFImporter_NodeElement_Color*>(ne_triangle_child);
-							else if(ne_triangle_child->Type == CAMFImporter_NodeElement::ENET_TexMap)
-								complex_face.TexMap = reinterpret_cast<const CAMFImporter_NodeElement_TexMap*>(ne_triangle_child);
-						}
-					}// if(tri_al.Child.size())
-
-					// create new face and store it.
-					complex_face.Face.mNumIndices = 3;
-					complex_face.Face.mIndices = new unsigned int[3];
-					complex_face.Face.mIndices[0] = static_cast<unsigned int>(tri_al.V[0]);
-					complex_face.Face.mIndices[1] = static_cast<unsigned int>(tri_al.V[1]);
-					complex_face.Face.mIndices[2] = static_cast<unsigned int>(tri_al.V[2]);
-					complex_faces_list.push_back(complex_face);
-				}
-			}// for(const CAMFImporter_NodeElement* ne_volume_child: ne_volume->Child)
-
-			/**** Split faces list: one list per mesh ****/
-			PostprocessHelper_SplitFacesByTextureID(complex_faces_list, complex_faces_toplist);
-
-			/***** Create mesh for every faces list ******/
-			for(std::list<SComplexFace>& face_list_cur: complex_faces_toplist)
-			{
-				auto VertexIndex_GetMinimal = [](const std::list<SComplexFace>& pFaceList, const size_t* pBiggerThan) -> size_t
-				{
-					size_t rv;
-
-					if(pBiggerThan != nullptr)
-					{
-						bool found = false;
-
-						for(const SComplexFace& face: pFaceList)
-						{
-							for(size_t idx_vert = 0; idx_vert < face.Face.mNumIndices; idx_vert++)
-							{
-								if(face.Face.mIndices[idx_vert] > *pBiggerThan)
-								{
-									rv = face.Face.mIndices[idx_vert];
-									found = true;
-
-									break;
-								}
-							}
-
-							if(found) break;
-						}
-
-						if(!found) return *pBiggerThan;
-					}
-					else
-					{
-						rv = pFaceList.front().Face.mIndices[0];
-					}// if(pBiggerThan != nullptr) else
-
-					for(const SComplexFace& face: pFaceList)
-					{
-						for(size_t vi = 0; vi < face.Face.mNumIndices; vi++)
-						{
-							if(face.Face.mIndices[vi] < rv)
-							{
-								if(pBiggerThan != nullptr)
-								{
-									if(face.Face.mIndices[vi] > *pBiggerThan) rv = face.Face.mIndices[vi];
-								}
-								else
-								{
-									rv = face.Face.mIndices[vi];
-								}
-							}
-						}
-					}// for(const SComplexFace& face: pFaceList)
-
-					return rv;
-				};// auto VertexIndex_GetMinimal = [](const std::list<SComplexFace>& pFaceList, const size_t* pBiggerThan) -> size_t
-
-				auto VertexIndex_Replace = [](std::list<SComplexFace>& pFaceList, const size_t pIdx_From, const size_t pIdx_To) -> void
-				{
-					for(const SComplexFace& face: pFaceList)
-					{
-						for(size_t vi = 0; vi < face.Face.mNumIndices; vi++)
-						{
-							if(face.Face.mIndices[vi] == pIdx_From) face.Face.mIndices[vi] = static_cast<unsigned int>(pIdx_To);
-						}
-					}
-				};// auto VertexIndex_Replace = [](std::list<SComplexFace>& pFaceList, const size_t pIdx_From, const size_t pIdx_To) -> void
-
-				auto Vertex_CalculateColor = [&](const size_t pIdx) -> aiColor4D
-				{
-					// Color priorities(In descending order):
-					// 1. triangle color;
-					// 2. vertex color;
-					// 3. volume color;
-					// 4. object color;
-					// 5. material;
-					// 6. default - invisible coat.
-					//
-					// Fill vertices colors in color priority list above that's points from 1 to 6.
-					if((pIdx < pVertexColorArray.size()) && (pVertexColorArray[pIdx] != nullptr))// check for vertex color
-					{
-						if(pVertexColorArray[pIdx]->Composed)
-							throw DeadlyImportError("IME: vertex color composed");
-						else
-							return pVertexColorArray[pIdx]->Color;
-					}
-					else if(ne_volume_color != nullptr)// check for volume color
-					{
-						if(ne_volume_color->Composed)
-							throw DeadlyImportError("IME: volume color composed");
-						else
-							return ne_volume_color->Color;
-					}
-					else if(pObjectColor != nullptr)// check for object color
-					{
-						if(pObjectColor->Composed)
-							throw DeadlyImportError("IME: object color composed");
-						else
-							return pObjectColor->Color;
-					}
-					else if(cur_mat != nullptr)// check for material
-					{
-						return cur_mat->GetColor(pVertexCoordinateArray.at(pIdx).x, pVertexCoordinateArray.at(pIdx).y, pVertexCoordinateArray.at(pIdx).z);
-					}
-					else// set default color.
-					{
-						return {0, 0, 0, 0};
-					}// if((vi < pVertexColorArray.size()) && (pVertexColorArray[vi] != nullptr)) else
-
-				};// auto Vertex_CalculateColor = [&](const size_t pIdx) -> aiColor4D
-
-				aiMesh* tmesh = new aiMesh;
-
-				tmesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;// Only triangles is supported by AMF.
-				//
-				// set geometry and colors (vertices)
-				//
-				// copy faces/triangles
-				tmesh->mNumFaces = static_cast<unsigned int>(face_list_cur.size());
-				tmesh->mFaces = new aiFace[tmesh->mNumFaces];
-
-				// Create vertices list and optimize indices. Optimisation mean following.In AMF all volumes use one big list of vertices. And one volume
-				// can use only part of vertices list, for example: vertices list contain few thousands of vertices and volume use vertices 1, 3, 10.
-				// Do you need all this thousands of garbage? Of course no. So, optimisation step transformate sparse indices set to continuous.
-				size_t VertexCount_Max = tmesh->mNumFaces * 3;// 3 - triangles.
-				std::vector<aiVector3D> vert_arr, texcoord_arr;
-				std::vector<aiColor4D> col_arr;
-
-				vert_arr.reserve(VertexCount_Max * 2);// "* 2" - see below TODO.
-				col_arr.reserve(VertexCount_Max * 2);
-
-				{// fill arrays
-					size_t vert_idx_from, vert_idx_to;
-
-					// first iteration.
-					vert_idx_to = 0;
-					vert_idx_from = VertexIndex_GetMinimal(face_list_cur, nullptr);
-					vert_arr.push_back(pVertexCoordinateArray.at(vert_idx_from));
-					col_arr.push_back(Vertex_CalculateColor(vert_idx_from));
-					if(vert_idx_from != vert_idx_to) VertexIndex_Replace(face_list_cur, vert_idx_from, vert_idx_to);
-
-					// rest iterations
-					do
-					{
-						vert_idx_from = VertexIndex_GetMinimal(face_list_cur, &vert_idx_to);
-						if(vert_idx_from == vert_idx_to) break;// all indices are transferred,
-
-						vert_arr.push_back(pVertexCoordinateArray.at(vert_idx_from));
-						col_arr.push_back(Vertex_CalculateColor(vert_idx_from));
-						vert_idx_to++;
-						if(vert_idx_from != vert_idx_to) VertexIndex_Replace(face_list_cur, vert_idx_from, vert_idx_to);
-
-					} while(true);
-				}// fill arrays. END.
-
-				//
-				// check if triangle colors are used and create additional faces if needed.
-				//
-				for(const SComplexFace& face_cur: face_list_cur)
-				{
-					if(face_cur.Color != nullptr)
-					{
-						aiColor4D face_color;
-						size_t vert_idx_new = vert_arr.size();
-
-						if(face_cur.Color->Composed)
-							throw DeadlyImportError("IME: face color composed");
-						else
-							face_color = face_cur.Color->Color;
-
-						for(size_t idx_ind = 0; idx_ind < face_cur.Face.mNumIndices; idx_ind++)
-						{
-							vert_arr.push_back(vert_arr.at(face_cur.Face.mIndices[idx_ind]));
-							col_arr.push_back(face_color);
-							face_cur.Face.mIndices[idx_ind] = static_cast<unsigned int>(vert_idx_new++);
-						}
-					}// if(face_cur.Color != nullptr)
-				}// for(const SComplexFace& face_cur: face_list_cur)
-
-				//
-				// if texture is used then copy texture coordinates too.
-				//
-				if(face_list_cur.front().TexMap != nullptr)
-				{
-					size_t idx_vert_new = vert_arr.size();
-					///TODO: clean unused vertices. "* 2": in certain cases - mesh full of triangle colors - vert_arr will contain duplicated vertices for
-					/// colored triangles and initial vertices (for colored vertices) which in real became unused. This part need more thinking about
-					/// optimisation.
-					bool* idx_vert_used;
-
-					idx_vert_used = new bool[VertexCount_Max * 2];
-					for(size_t i = 0, i_e = VertexCount_Max * 2; i < i_e; i++) idx_vert_used[i] = false;
-
-					// This ID's will be used when set materials ID in scene.
-					tmesh->mMaterialIndex = static_cast<unsigned int>(PostprocessHelper_GetTextureID_Or_Create(face_list_cur.front().TexMap->TextureID_R,
-																						face_list_cur.front().TexMap->TextureID_G,
-																						face_list_cur.front().TexMap->TextureID_B,
-																						face_list_cur.front().TexMap->TextureID_A));
-					texcoord_arr.resize(VertexCount_Max * 2);
-					for(const SComplexFace& face_cur: face_list_cur)
-					{
-						for(size_t idx_ind = 0; idx_ind < face_cur.Face.mNumIndices; idx_ind++)
-						{
-							const size_t idx_vert = face_cur.Face.mIndices[idx_ind];
-
-							if(!idx_vert_used[idx_vert])
-							{
-								texcoord_arr.at(idx_vert) = face_cur.TexMap->TextureCoordinate[idx_ind];
-								idx_vert_used[idx_vert] = true;
-							}
-							else if(texcoord_arr.at(idx_vert) != face_cur.TexMap->TextureCoordinate[idx_ind])
-							{
-								// in that case one vertex is shared with many texture coordinates. We need to duplicate vertex with another texture
-								// coordinates.
-								vert_arr.push_back(vert_arr.at(idx_vert));
-								col_arr.push_back(col_arr.at(idx_vert));
-								texcoord_arr.at(idx_vert_new) = face_cur.TexMap->TextureCoordinate[idx_ind];
-								face_cur.Face.mIndices[idx_ind] = static_cast<unsigned int>(idx_vert_new++);
-							}
-						}// for(size_t idx_ind = 0; idx_ind < face_cur.Face.mNumIndices; idx_ind++)
-					}// for(const SComplexFace& face_cur: face_list_cur)
-
-					delete [] idx_vert_used;
-					// shrink array
-					texcoord_arr.resize(idx_vert_new);
-				}// if(face_list_cur.front().TexMap != nullptr)
-
-				//
-				// copy collected data to mesh
-				//
-				tmesh->mNumVertices = static_cast<unsigned int>(vert_arr.size());
-				tmesh->mVertices = new aiVector3D[tmesh->mNumVertices];
-				tmesh->mColors[0] = new aiColor4D[tmesh->mNumVertices];
-
-				memcpy(tmesh->mVertices, vert_arr.data(), tmesh->mNumVertices * sizeof(aiVector3D));
-				memcpy(tmesh->mColors[0], col_arr.data(), tmesh->mNumVertices * sizeof(aiColor4D));
-				if(texcoord_arr.size() > 0)
-				{
-					tmesh->mTextureCoords[0] = new aiVector3D[tmesh->mNumVertices];
-					memcpy(tmesh->mTextureCoords[0], texcoord_arr.data(), tmesh->mNumVertices * sizeof(aiVector3D));
-					tmesh->mNumUVComponents[0] = 2;// U and V stored in "x", "y" of aiVector3D.
-				}
-
-				size_t idx_face = 0;
-				for(const SComplexFace& face_cur: face_list_cur) tmesh->mFaces[idx_face++] = face_cur.Face;
-
-				// store new aiMesh
-				mesh_idx.push_back(static_cast<unsigned int>(pMeshList.size()));
-				pMeshList.push_back(tmesh);
-			}// for(const std::list<SComplexFace>& face_list_cur: complex_faces_toplist)
-		}// if(ne_child->Type == CAMFImporter_NodeElement::ENET_Volume)
-	}// for(const CAMFImporter_NodeElement* ne_child: pNodeElement.Child)
-
-	// if meshes was created then assign new indices with current aiNode
-	if(!mesh_idx.empty())
-	{
-		std::list<unsigned int>::const_iterator mit = mesh_idx.begin();
-
-		pSceneNode.mNumMeshes = static_cast<unsigned int>(mesh_idx.size());
-		pSceneNode.mMeshes = new unsigned int[pSceneNode.mNumMeshes];
-		for(size_t i = 0; i < pSceneNode.mNumMeshes; i++) pSceneNode.mMeshes[i] = *mit++;
-	}// if(mesh_idx.size() > 0)
-}
-
-void AMFImporter::Postprocess_BuildMaterial(const CAMFImporter_NodeElement_Material& pMaterial)
-{
-SPP_Material new_mat;
-
-	new_mat.ID = pMaterial.ID;
-	for(const CAMFImporter_NodeElement* mat_child: pMaterial.Child)
-	{
-		if(mat_child->Type == CAMFImporter_NodeElement::ENET_Color)
-		{
-			new_mat.Color = (CAMFImporter_NodeElement_Color*)mat_child;
-		}
-		else if(mat_child->Type == CAMFImporter_NodeElement::ENET_Metadata)
-		{
-			new_mat.Metadata.push_back((CAMFImporter_NodeElement_Metadata*)mat_child);
-		}
-	}// for(const CAMFImporter_NodeElement* mat_child; pMaterial.Child)
-
-	// place converted material to special list
-	mMaterial_Converted.push_back(new_mat);
-}
-
-void AMFImporter::Postprocess_BuildConstellation(CAMFImporter_NodeElement_Constellation& pConstellation, std::list<aiNode*>& pNodeList) const
-{
-aiNode* con_node;
-std::list<aiNode*> ch_node;
-
-	// We will build next hierarchy:
-	// aiNode as parent (<constellation>) for set of nodes as a children
-	//  |- aiNode for transformation (<instance> -> <delta...>, <r...>) - aiNode for pointing to object ("objectid")
-	//  ...
-	//  \_ aiNode for transformation (<instance> -> <delta...>, <r...>) - aiNode for pointing to object ("objectid")
-	con_node = new aiNode;
-	con_node->mName = pConstellation.ID;
-	// Walk through children and search for instances of another objects, constellations.
-	for(const CAMFImporter_NodeElement* ne: pConstellation.Child)
-	{
-		aiMatrix4x4 tmat;
-		aiNode* t_node;
-		aiNode* found_node;
-
-		if(ne->Type == CAMFImporter_NodeElement::ENET_Metadata) continue;
-		if(ne->Type != CAMFImporter_NodeElement::ENET_Instance) throw DeadlyImportError("Only <instance> nodes can be in <constellation>.");
-
-		// create alias for conveniance
-		CAMFImporter_NodeElement_Instance& als = *((CAMFImporter_NodeElement_Instance*)ne);
-		// find referenced object
-		if(!Find_ConvertedNode(als.ObjectID, pNodeList, &found_node)) Throw_ID_NotFound(als.ObjectID);
-
-		// create node for applying transformation
-		t_node = new aiNode;
-		t_node->mParent = con_node;
-		// apply transformation
-		aiMatrix4x4::Translation(als.Delta, tmat), t_node->mTransformation *= tmat;
-		aiMatrix4x4::RotationX(als.Rotation.x, tmat), t_node->mTransformation *= tmat;
-		aiMatrix4x4::RotationY(als.Rotation.y, tmat), t_node->mTransformation *= tmat;
-		aiMatrix4x4::RotationZ(als.Rotation.z, tmat), t_node->mTransformation *= tmat;
-		// create array for one child node
-		t_node->mNumChildren = 1;
-		t_node->mChildren = new aiNode*[t_node->mNumChildren];
-		SceneCombiner::Copy(&t_node->mChildren[0], found_node);
-		t_node->mChildren[0]->mParent = t_node;
-		ch_node.push_back(t_node);
-	}// for(const CAMFImporter_NodeElement* ne: pConstellation.Child)
-
-	// copy found aiNode's as children
-	if(ch_node.empty()) throw DeadlyImportError("<constellation> must have at least one <instance>.");
-
-	size_t ch_idx = 0;
-
-	con_node->mNumChildren = static_cast<unsigned int>(ch_node.size());
-	con_node->mChildren = new aiNode*[con_node->mNumChildren];
-	for(aiNode* node: ch_node) con_node->mChildren[ch_idx++] = node;
-
-	// and place "root" of <constellation> node to node list
-	pNodeList.push_back(con_node);
-}
-
-void AMFImporter::Postprocess_BuildScene(aiScene* pScene)
-{
-std::list<aiNode*> node_list;
-std::list<aiMesh*> mesh_list;
-std::list<CAMFImporter_NodeElement_Metadata*> meta_list;
-
-	//
-	// Because for AMF "material" is just complex colors mixing so aiMaterial will not be used.
-	// For building aiScene we are must to do few steps:
-	// at first creating root node for aiScene.
-	pScene->mRootNode = new aiNode;
-	pScene->mRootNode->mParent = nullptr;
-	pScene->mFlags |= AI_SCENE_FLAGS_ALLOW_SHARED;
-	// search for root(<amf>) element
-	CAMFImporter_NodeElement* root_el = nullptr;
-
-	for(CAMFImporter_NodeElement* ne: mNodeElement_List)
-	{
-		if(ne->Type != CAMFImporter_NodeElement::ENET_Root) continue;
-
-		root_el = ne;
-
-		break;
-	}// for(const CAMFImporter_NodeElement* ne: mNodeElement_List)
-
-	// Check if root element are found.
-	if(root_el == nullptr) throw DeadlyImportError("Root(<amf>) element not found.");
-
-	// after that walk through children of root and collect data. Five types of nodes can be placed at top level - in <amf>: <object>, <material>, <texture>,
-	// <constellation> and <metadata>. But at first we must read <material> and <texture> because they will be used in <object>. <metadata> can be read
-	// at any moment.
-	//
-	// 1. <material>
-	// 2. <texture> will be converted later when processing triangles list. \sa Postprocess_BuildMeshSet
-	for(const CAMFImporter_NodeElement* root_child: root_el->Child)
-	{
-		if(root_child->Type == CAMFImporter_NodeElement::ENET_Material) Postprocess_BuildMaterial(*((CAMFImporter_NodeElement_Material*)root_child));
-	}
-
-	// After "appearance" nodes we must read <object> because it will be used in <constellation> -> <instance>.
-	//
-	// 3. <object>
-	for(const CAMFImporter_NodeElement* root_child: root_el->Child)
-	{
-		if(root_child->Type == CAMFImporter_NodeElement::ENET_Object)
-		{
-			aiNode* tnode = nullptr;
-
-			// for <object> mesh and node must be built: object ID assigned to aiNode name and will be used in future for <instance>
-			Postprocess_BuildNodeAndObject(*((CAMFImporter_NodeElement_Object*)root_child), mesh_list, &tnode);
-			if(tnode != nullptr) node_list.push_back(tnode);
-
-		}
-	}// for(const CAMFImporter_NodeElement* root_child: root_el->Child)
-
-	// And finally read rest of nodes.
-	//
-	for(const CAMFImporter_NodeElement* root_child: root_el->Child)
-	{
-		// 4. <constellation>
-		if(root_child->Type == CAMFImporter_NodeElement::ENET_Constellation)
-		{
-			// <object> and <constellation> at top of self abstraction use aiNode. So we can use only aiNode list for creating new aiNode's.
-			Postprocess_BuildConstellation(*((CAMFImporter_NodeElement_Constellation*)root_child), node_list);
-		}
-
-		// 5, <metadata>
-		if(root_child->Type == CAMFImporter_NodeElement::ENET_Metadata) meta_list.push_back((CAMFImporter_NodeElement_Metadata*)root_child);
-	}// for(const CAMFImporter_NodeElement* root_child: root_el->Child)
-
-	// at now we can add collected metadata to root node
-	Postprocess_AddMetadata(meta_list, *pScene->mRootNode);
-	//
-	// Check constellation children
-	//
-	// As said in specification:
-	// "When multiple objects and constellations are defined in a single file, only the top level objects and constellations are available for printing."
-	// What that means? For example: if some object is used in constellation then you must show only constellation but not original object.
-	// And at this step we are checking that relations.
-nl_clean_loop:
-
-	if(node_list.size() > 1)
-	{
-		// walk through all nodes
-		for(std::list<aiNode*>::iterator nl_it = node_list.begin(); nl_it != node_list.end(); ++nl_it)
-		{
-			// and try to find them in another top nodes.
-			std::list<aiNode*>::const_iterator next_it = nl_it;
-
-			++next_it;
-			for(; next_it != node_list.end(); ++next_it)
-			{
-				if((*next_it)->FindNode((*nl_it)->mName) != nullptr)
-				{
-					// if current top node(nl_it) found in another top node then erase it from node_list and restart search loop.
-					node_list.erase(nl_it);
-
-					goto nl_clean_loop;
-				}
-			}// for(; next_it != node_list.end(); next_it++)
-		}// for(std::list<aiNode*>::const_iterator nl_it = node_list.begin(); nl_it != node_list.end(); nl_it++)
-	}
-
-	//
-	// move created objects to aiScene
-	//
-	//
-	// Nodes
-	if(!node_list.empty())
-	{
-		std::list<aiNode*>::const_iterator nl_it = node_list.begin();
-
-		pScene->mRootNode->mNumChildren = static_cast<unsigned int>(node_list.size());
-		pScene->mRootNode->mChildren = new aiNode*[pScene->mRootNode->mNumChildren];
-		for(size_t i = 0; i < pScene->mRootNode->mNumChildren; i++)
-		{
-			// Objects and constellation that must be showed placed at top of hierarchy in <amf> node. So all aiNode's in node_list must have
-			// mRootNode only as parent.
-			(*nl_it)->mParent = pScene->mRootNode;
-			pScene->mRootNode->mChildren[i] = *nl_it++;
-		}
-	}// if(node_list.size() > 0)
-
-	//
-	// Meshes
-	if(!mesh_list.empty())
-	{
-		std::list<aiMesh*>::const_iterator ml_it = mesh_list.begin();
-
-		pScene->mNumMeshes = static_cast<unsigned int>(mesh_list.size());
-		pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];
-		for(size_t i = 0; i < pScene->mNumMeshes; i++) pScene->mMeshes[i] = *ml_it++;
-	}// if(mesh_list.size() > 0)
-
-	//
-	// Textures
-	pScene->mNumTextures = static_cast<unsigned int>(mTexture_Converted.size());
-	if(pScene->mNumTextures > 0)
-	{
-		size_t idx;
-
-		idx = 0;
-		pScene->mTextures = new aiTexture*[pScene->mNumTextures];
-		for(const SPP_Texture& tex_convd: mTexture_Converted)
-		{
-			pScene->mTextures[idx] = new aiTexture;
-			pScene->mTextures[idx]->mWidth = static_cast<unsigned int>(tex_convd.Width);
-			pScene->mTextures[idx]->mHeight = static_cast<unsigned int>(tex_convd.Height);
-			pScene->mTextures[idx]->pcData = (aiTexel*)tex_convd.Data;
-			// texture format description.
-			strcpy(pScene->mTextures[idx]->achFormatHint, tex_convd.FormatHint);
-			idx++;
-		}// for(const SPP_Texture& tex_convd: mTexture_Converted)
-
-		// Create materials for embedded textures.
-		idx = 0;
-		pScene->mNumMaterials = static_cast<unsigned int>(mTexture_Converted.size());
-		pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials];
-		for(const SPP_Texture& tex_convd: mTexture_Converted)
-		{
-			const aiString texture_id(AI_EMBEDDED_TEXNAME_PREFIX + to_string(idx));
-			const int mode = aiTextureOp_Multiply;
-			const int repeat = tex_convd.Tiled ? 1 : 0;
-
-			pScene->mMaterials[idx] = new aiMaterial;
-			pScene->mMaterials[idx]->AddProperty(&texture_id, AI_MATKEY_TEXTURE_DIFFUSE(0));
-			pScene->mMaterials[idx]->AddProperty(&mode, 1, AI_MATKEY_TEXOP_DIFFUSE(0));
-			pScene->mMaterials[idx]->AddProperty(&repeat, 1, AI_MATKEY_MAPPINGMODE_U_DIFFUSE(0));
-			pScene->mMaterials[idx]->AddProperty(&repeat, 1, AI_MATKEY_MAPPINGMODE_V_DIFFUSE(0));
-			idx++;
-		}
-	}// if(pScene->mNumTextures > 0)
-}// END: after that walk through children of root and collect data
-
-}// namespace Assimp
-
-#endif // !ASSIMP_BUILD_NO_AMF_IMPORTER
diff --git a/Engine/lib/assimp/code/Assbin/AssbinExporter.cpp b/Engine/lib/assimp/code/Assbin/AssbinExporter.cpp
deleted file mode 100644
index 76c823f82..000000000
--- a/Engine/lib/assimp/code/Assbin/AssbinExporter.cpp
+++ /dev/null
@@ -1,846 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-/** @file  AssbinExporter.cpp
- *  ASSBIN exporter main code
- */
-
-#ifndef ASSIMP_BUILD_NO_EXPORT
-#ifndef ASSIMP_BUILD_NO_ASSBIN_EXPORTER
-
-#include "Common/assbin_chunks.h"
-#include "PostProcessing/ProcessHelper.h"
-
-#include <assimp/version.h>
-#include <assimp/IOStream.hpp>
-#include <assimp/IOSystem.hpp>
-#include <assimp/Exporter.hpp>
-#include <assimp/Exceptional.h>
-
-#ifdef ASSIMP_BUILD_NO_OWN_ZLIB
-#   include <zlib.h>
-#else
-#   include "../contrib/zlib/zlib.h"
-#endif
-
-#include <time.h>
-
-namespace Assimp {
-
-template <typename T>
-size_t Write(IOStream * stream, const T& v) {
-    return stream->Write( &v, sizeof(T), 1 );
-}
-
-// -----------------------------------------------------------------------------------
-// Serialize an aiString
-template <>
-inline
-size_t Write<aiString>(IOStream * stream, const aiString& s) {
-    const size_t s2 = (uint32_t)s.length;
-    stream->Write(&s,4,1);
-    stream->Write(s.data,s2,1);
-
-    return s2+4;
-}
-
-// -----------------------------------------------------------------------------------
-// Serialize an unsigned int as uint32_t
-template <>
-inline
-size_t Write<unsigned int>(IOStream * stream, const unsigned int& w) {
-    const uint32_t t = (uint32_t)w;
-    if (w > t) {
-        // this shouldn't happen, integers in Assimp data structures never exceed 2^32
-        throw DeadlyExportError("loss of data due to 64 -> 32 bit integer conversion");
-    }
-
-    stream->Write(&t,4,1);
-
-    return 4;
-}
-
-// -----------------------------------------------------------------------------------
-// Serialize an unsigned int as uint16_t
-template <>
-inline
-size_t Write<uint16_t>(IOStream * stream, const uint16_t& w) {
-    static_assert(sizeof(uint16_t)==2, "sizeof(uint16_t)==2");
-    stream->Write(&w,2,1);
-
-    return 2;
-}
-
-// -----------------------------------------------------------------------------------
-// Serialize a float
-template <>
-inline
-size_t Write<float>(IOStream * stream, const float& f) {
-    static_assert(sizeof(float)==4, "sizeof(float)==4");
-    stream->Write(&f,4,1);
-
-    return 4;
-}
-
-// -----------------------------------------------------------------------------------
-// Serialize a double
-template <>
-inline
-size_t Write<double>(IOStream * stream, const double& f) {
-    static_assert(sizeof(double)==8, "sizeof(double)==8");
-    stream->Write(&f,8,1);
-
-    return 8;
-}
-
-// -----------------------------------------------------------------------------------
-// Serialize a vec3
-template <>
-inline
-size_t Write<aiVector3D>(IOStream * stream, const aiVector3D& v) {
-    size_t t = Write<float>(stream,v.x);
-    t += Write<float>(stream,v.y);
-    t += Write<float>(stream,v.z);
-
-    return t;
-}
-
-// -----------------------------------------------------------------------------------
-// Serialize a color value
-template <>
-inline
-size_t Write<aiColor3D>(IOStream * stream, const aiColor3D& v) {
-    size_t t = Write<float>(stream,v.r);
-    t += Write<float>(stream,v.g);
-    t += Write<float>(stream,v.b);
-
-    return t;
-}
-
-// -----------------------------------------------------------------------------------
-// Serialize a color value
-template <>
-inline
-size_t Write<aiColor4D>(IOStream * stream, const aiColor4D& v) {
-    size_t t = Write<float>(stream,v.r);
-    t += Write<float>(stream,v.g);
-    t += Write<float>(stream,v.b);
-    t += Write<float>(stream,v.a);
-
-    return t;
-}
-
-// -----------------------------------------------------------------------------------
-// Serialize a quaternion
-template <>
-inline
-size_t Write<aiQuaternion>(IOStream * stream, const aiQuaternion& v) {
-    size_t t = Write<float>(stream,v.w);
-    t += Write<float>(stream,v.x);
-    t += Write<float>(stream,v.y);
-    t += Write<float>(stream,v.z);
-    ai_assert(t == 16);
-
-    return 16;
-}
-
-// -----------------------------------------------------------------------------------
-// Serialize a vertex weight
-template <>
-inline
-size_t Write<aiVertexWeight>(IOStream * stream, const aiVertexWeight& v) {
-    size_t t = Write<unsigned int>(stream,v.mVertexId);
-
-    return t+Write<float>(stream,v.mWeight);
-}
-
-// -----------------------------------------------------------------------------------
-// Serialize a mat4x4
-template <>
-inline
-size_t Write<aiMatrix4x4>(IOStream * stream, const aiMatrix4x4& m) {
-    for (unsigned int i = 0; i < 4;++i) {
-        for (unsigned int i2 = 0; i2 < 4;++i2) {
-            Write<float>(stream,m[i][i2]);
-        }
-    }
-
-    return 64;
-}
-
-// -----------------------------------------------------------------------------------
-// Serialize an aiVectorKey
-template <>
-inline
-size_t Write<aiVectorKey>(IOStream * stream, const aiVectorKey& v) {
-    const size_t t = Write<double>(stream,v.mTime);
-    return t + Write<aiVector3D>(stream,v.mValue);
-}
-
-// -----------------------------------------------------------------------------------
-// Serialize an aiQuatKey
-template <>
-inline
-size_t Write<aiQuatKey>(IOStream * stream, const aiQuatKey& v) {
-    const size_t t = Write<double>(stream,v.mTime);
-    return t + Write<aiQuaternion>(stream,v.mValue);
-}
-
-template <typename T>
-inline
-size_t WriteBounds(IOStream * stream, const T* in, unsigned int size) {
-    T minc, maxc;
-    ArrayBounds(in,size,minc,maxc);
-
-    const size_t t = Write<T>(stream,minc);
-    return t + Write<T>(stream,maxc);
-}
-
-// We use this to write out non-byte arrays so that we write using the specializations.
-// This way we avoid writing out extra bytes that potentially come from struct alignment.
-template <typename T>
-inline
-size_t WriteArray(IOStream * stream, const T* in, unsigned int size) {
-    size_t n = 0;
-    for (unsigned int i=0; i<size; i++) n += Write<T>(stream,in[i]);
-
-    return n;
-}
-
-// ----------------------------------------------------------------------------------
-/** @class  AssbinChunkWriter
- *  @brief  Chunk writer mechanism for the .assbin file structure
- *
- *  This is a standard in-memory IOStream (most of the code is based on BlobIOStream),
- *  the difference being that this takes another IOStream as a "container" in the
- *  constructor, and when it is destroyed, it appends the magic number, the chunk size,
- *  and the chunk contents to the container stream. This allows relatively easy chunk
- *  chunk construction, even recursively.
- */
-class AssbinChunkWriter : public IOStream
-{
-private:
-
-    uint8_t* buffer;
-    uint32_t magic;
-    IOStream * container;
-    size_t cur_size, cursor, initial;
-
-private:
-    // -------------------------------------------------------------------
-    void Grow(size_t need = 0)
-    {
-        size_t new_size = std::max(initial, std::max( need, cur_size+(cur_size>>1) ));
-
-        const uint8_t* const old = buffer;
-        buffer = new uint8_t[new_size];
-
-        if (old) {
-            memcpy(buffer,old,cur_size);
-            delete[] old;
-        }
-
-        cur_size = new_size;
-    }
-
-public:
-
-    AssbinChunkWriter( IOStream * container, uint32_t magic, size_t initial = 4096)
-        : buffer(NULL), magic(magic), container(container), cur_size(0), cursor(0), initial(initial)
-    {
-    }
-
-    virtual ~AssbinChunkWriter()
-    {
-        if (container) {
-            container->Write( &magic, sizeof(uint32_t), 1 );
-            container->Write( &cursor, sizeof(uint32_t), 1 );
-            container->Write( buffer, 1, cursor );
-        }
-        if (buffer) delete[] buffer;
-    }
-
-    void * GetBufferPointer() { return buffer; }
-
-    // -------------------------------------------------------------------
-    virtual size_t Read(void* /*pvBuffer*/, size_t /*pSize*/, size_t /*pCount*/) {
-        return 0;
-    }
-    virtual aiReturn Seek(size_t /*pOffset*/, aiOrigin /*pOrigin*/) {
-        return aiReturn_FAILURE;
-    }
-    virtual size_t Tell() const {
-        return cursor;
-    }
-    virtual void Flush() {
-        // not implemented
-    }
-
-    virtual size_t FileSize() const {
-        return cursor;
-    }
-
-    // -------------------------------------------------------------------
-    virtual size_t Write(const void* pvBuffer, size_t pSize, size_t pCount) {
-        pSize *= pCount;
-        if (cursor + pSize > cur_size) {
-            Grow(cursor + pSize);
-        }
-
-        memcpy(buffer+cursor, pvBuffer, pSize);
-        cursor += pSize;
-
-        return pCount;
-    }
-
-};
-
-// ----------------------------------------------------------------------------------
-/** @class  AssbinExport
- *  @brief  Assbin exporter class
- *
- *  This class performs the .assbin exporting, and is responsible for the file layout.
- */
-class AssbinExport
-{
-private:
-    bool shortened;
-    bool compressed;
-
-protected:
-    // -----------------------------------------------------------------------------------
-    void WriteBinaryNode( IOStream * container, const aiNode* node)
-    {
-        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AINODE );
-
-        unsigned int nb_metadata = (node->mMetaData != NULL ? node->mMetaData->mNumProperties : 0);
-
-        Write<aiString>(&chunk,node->mName);
-        Write<aiMatrix4x4>(&chunk,node->mTransformation);
-        Write<unsigned int>(&chunk,node->mNumChildren);
-        Write<unsigned int>(&chunk,node->mNumMeshes);
-        Write<unsigned int>(&chunk,nb_metadata);
-
-        for (unsigned int i = 0; i < node->mNumMeshes;++i) {
-            Write<unsigned int>(&chunk,node->mMeshes[i]);
-        }
-
-        for (unsigned int i = 0; i < node->mNumChildren;++i) {
-            WriteBinaryNode( &chunk, node->mChildren[i] );
-        }
-
-        for (unsigned int i = 0; i < nb_metadata; ++i) {
-            const aiString& key = node->mMetaData->mKeys[i];
-            aiMetadataType type = node->mMetaData->mValues[i].mType;
-            void* value = node->mMetaData->mValues[i].mData;
-
-            Write<aiString>(&chunk, key);
-            Write<uint16_t>(&chunk, type);
-
-            switch (type) {
-                case AI_BOOL:
-                    Write<bool>(&chunk, *((bool*) value));
-                    break;
-                case AI_INT32:
-                    Write<int32_t>(&chunk, *((int32_t*) value));
-                    break;
-                case AI_UINT64:
-                    Write<uint64_t>(&chunk, *((uint64_t*) value));
-                    break;
-                case AI_FLOAT:
-                    Write<float>(&chunk, *((float*) value));
-                    break;
-                case AI_DOUBLE:
-                    Write<double>(&chunk, *((double*) value));
-                    break;
-                case AI_AISTRING:
-                    Write<aiString>(&chunk, *((aiString*) value));
-                    break;
-                case AI_AIVECTOR3D:
-                    Write<aiVector3D>(&chunk, *((aiVector3D*) value));
-                    break;
-#ifdef SWIG
-                case FORCE_32BIT:
-#endif // SWIG
-                default:
-                    break;
-            }
-        }
-    }
-
-    // -----------------------------------------------------------------------------------
-    void WriteBinaryTexture(IOStream * container, const aiTexture* tex)
-    {
-        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AITEXTURE );
-
-        Write<unsigned int>(&chunk,tex->mWidth);
-        Write<unsigned int>(&chunk,tex->mHeight);
-        chunk.Write( tex->achFormatHint, sizeof(char), 4 );
-
-        if(!shortened) {
-            if (!tex->mHeight) {
-                chunk.Write(tex->pcData,1,tex->mWidth);
-            }
-            else {
-                chunk.Write(tex->pcData,1,tex->mWidth*tex->mHeight*4);
-            }
-        }
-
-    }
-
-    // -----------------------------------------------------------------------------------
-    void WriteBinaryBone(IOStream * container, const aiBone* b)
-    {
-        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIBONE );
-
-        Write<aiString>(&chunk,b->mName);
-        Write<unsigned int>(&chunk,b->mNumWeights);
-        Write<aiMatrix4x4>(&chunk,b->mOffsetMatrix);
-
-        // for the moment we write dumb min/max values for the bones, too.
-        // maybe I'll add a better, hash-like solution later
-        if (shortened) {
-            WriteBounds(&chunk,b->mWeights,b->mNumWeights);
-        } // else write as usual
-        else WriteArray<aiVertexWeight>(&chunk,b->mWeights,b->mNumWeights);
-    }
-
-    // -----------------------------------------------------------------------------------
-    void WriteBinaryMesh(IOStream * container, const aiMesh* mesh)
-    {
-        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIMESH );
-
-        Write<unsigned int>(&chunk,mesh->mPrimitiveTypes);
-        Write<unsigned int>(&chunk,mesh->mNumVertices);
-        Write<unsigned int>(&chunk,mesh->mNumFaces);
-        Write<unsigned int>(&chunk,mesh->mNumBones);
-        Write<unsigned int>(&chunk,mesh->mMaterialIndex);
-
-        // first of all, write bits for all existent vertex components
-        unsigned int c = 0;
-        if (mesh->mVertices) {
-            c |= ASSBIN_MESH_HAS_POSITIONS;
-        }
-        if (mesh->mNormals) {
-            c |= ASSBIN_MESH_HAS_NORMALS;
-        }
-        if (mesh->mTangents && mesh->mBitangents) {
-            c |= ASSBIN_MESH_HAS_TANGENTS_AND_BITANGENTS;
-        }
-        for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n) {
-            if (!mesh->mTextureCoords[n]) {
-                break;
-            }
-            c |= ASSBIN_MESH_HAS_TEXCOORD(n);
-        }
-        for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS;++n) {
-            if (!mesh->mColors[n]) {
-                break;
-            }
-            c |= ASSBIN_MESH_HAS_COLOR(n);
-        }
-        Write<unsigned int>(&chunk,c);
-
-        aiVector3D minVec, maxVec;
-        if (mesh->mVertices) {
-            if (shortened) {
-                WriteBounds(&chunk,mesh->mVertices,mesh->mNumVertices);
-            } // else write as usual
-            else WriteArray<aiVector3D>(&chunk,mesh->mVertices,mesh->mNumVertices);
-        }
-        if (mesh->mNormals) {
-            if (shortened) {
-                WriteBounds(&chunk,mesh->mNormals,mesh->mNumVertices);
-            } // else write as usual
-            else WriteArray<aiVector3D>(&chunk,mesh->mNormals,mesh->mNumVertices);
-        }
-        if (mesh->mTangents && mesh->mBitangents) {
-            if (shortened) {
-                WriteBounds(&chunk,mesh->mTangents,mesh->mNumVertices);
-                WriteBounds(&chunk,mesh->mBitangents,mesh->mNumVertices);
-            } // else write as usual
-            else {
-                WriteArray<aiVector3D>(&chunk,mesh->mTangents,mesh->mNumVertices);
-                WriteArray<aiVector3D>(&chunk,mesh->mBitangents,mesh->mNumVertices);
-            }
-        }
-        for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS;++n) {
-            if (!mesh->mColors[n])
-                break;
-
-            if (shortened) {
-                WriteBounds(&chunk,mesh->mColors[n],mesh->mNumVertices);
-            } // else write as usual
-            else WriteArray<aiColor4D>(&chunk,mesh->mColors[n],mesh->mNumVertices);
-        }
-        for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n) {
-            if (!mesh->mTextureCoords[n])
-                break;
-
-            // write number of UV components
-            Write<unsigned int>(&chunk,mesh->mNumUVComponents[n]);
-
-            if (shortened) {
-                WriteBounds(&chunk,mesh->mTextureCoords[n],mesh->mNumVertices);
-            } // else write as usual
-            else WriteArray<aiVector3D>(&chunk,mesh->mTextureCoords[n],mesh->mNumVertices);
-        }
-
-        // write faces. There are no floating-point calculations involved
-        // in these, so we can write a simple hash over the face data
-        // to the dump file. We generate a single 32 Bit hash for 512 faces
-        // using Assimp's standard hashing function.
-        if (shortened) {
-            unsigned int processed = 0;
-            for (unsigned int job;(job = std::min(mesh->mNumFaces-processed,512u));processed += job) {
-
-                uint32_t hash = 0;
-                for (unsigned int a = 0; a < job;++a) {
-
-                    const aiFace& f = mesh->mFaces[processed+a];
-                    uint32_t tmp = f.mNumIndices;
-                    hash = SuperFastHash(reinterpret_cast<const char*>(&tmp),sizeof tmp,hash);
-                    for (unsigned int i = 0; i < f.mNumIndices; ++i) {
-                        static_assert(AI_MAX_VERTICES <= 0xffffffff, "AI_MAX_VERTICES <= 0xffffffff");
-                        tmp = static_cast<uint32_t>( f.mIndices[i] );
-                        hash = SuperFastHash(reinterpret_cast<const char*>(&tmp),sizeof tmp,hash);
-                    }
-                }
-                Write<unsigned int>(&chunk,hash);
-            }
-        }
-        else // else write as usual
-        {
-            // if there are less than 2^16 vertices, we can simply use 16 bit integers ...
-            for (unsigned int i = 0; i < mesh->mNumFaces;++i) {
-                const aiFace& f = mesh->mFaces[i];
-
-                static_assert(AI_MAX_FACE_INDICES <= 0xffff, "AI_MAX_FACE_INDICES <= 0xffff");
-                Write<uint16_t>(&chunk,f.mNumIndices);
-
-                for (unsigned int a = 0; a < f.mNumIndices;++a) {
-                    if (mesh->mNumVertices < (1u<<16)) {
-                        Write<uint16_t>(&chunk,f.mIndices[a]);
-                    }
-                    else Write<unsigned int>(&chunk,f.mIndices[a]);
-                }
-            }
-        }
-
-        // write bones
-        if (mesh->mNumBones) {
-            for (unsigned int a = 0; a < mesh->mNumBones;++a) {
-                const aiBone* b = mesh->mBones[a];
-                WriteBinaryBone(&chunk,b);
-            }
-        }
-    }
-
-    // -----------------------------------------------------------------------------------
-    void WriteBinaryMaterialProperty(IOStream * container, const aiMaterialProperty* prop)
-    {
-        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIMATERIALPROPERTY );
-
-        Write<aiString>(&chunk,prop->mKey);
-        Write<unsigned int>(&chunk,prop->mSemantic);
-        Write<unsigned int>(&chunk,prop->mIndex);
-
-        Write<unsigned int>(&chunk,prop->mDataLength);
-        Write<unsigned int>(&chunk,(unsigned int)prop->mType);
-        chunk.Write(prop->mData,1,prop->mDataLength);
-    }
-
-    // -----------------------------------------------------------------------------------
-    void WriteBinaryMaterial(IOStream * container, const aiMaterial* mat)
-    {
-        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIMATERIAL);
-
-        Write<unsigned int>(&chunk,mat->mNumProperties);
-        for (unsigned int i = 0; i < mat->mNumProperties;++i) {
-            WriteBinaryMaterialProperty( &chunk, mat->mProperties[i]);
-        }
-    }
-
-    // -----------------------------------------------------------------------------------
-    void WriteBinaryNodeAnim(IOStream * container, const aiNodeAnim* nd)
-    {
-        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AINODEANIM );
-
-        Write<aiString>(&chunk,nd->mNodeName);
-        Write<unsigned int>(&chunk,nd->mNumPositionKeys);
-        Write<unsigned int>(&chunk,nd->mNumRotationKeys);
-        Write<unsigned int>(&chunk,nd->mNumScalingKeys);
-        Write<unsigned int>(&chunk,nd->mPreState);
-        Write<unsigned int>(&chunk,nd->mPostState);
-
-        if (nd->mPositionKeys) {
-            if (shortened) {
-                WriteBounds(&chunk,nd->mPositionKeys,nd->mNumPositionKeys);
-
-            } // else write as usual
-            else WriteArray<aiVectorKey>(&chunk,nd->mPositionKeys,nd->mNumPositionKeys);
-        }
-        if (nd->mRotationKeys) {
-            if (shortened) {
-                WriteBounds(&chunk,nd->mRotationKeys,nd->mNumRotationKeys);
-
-            } // else write as usual
-            else WriteArray<aiQuatKey>(&chunk,nd->mRotationKeys,nd->mNumRotationKeys);
-        }
-        if (nd->mScalingKeys) {
-            if (shortened) {
-                WriteBounds(&chunk,nd->mScalingKeys,nd->mNumScalingKeys);
-
-            } // else write as usual
-            else WriteArray<aiVectorKey>(&chunk,nd->mScalingKeys,nd->mNumScalingKeys);
-        }
-    }
-
-
-    // -----------------------------------------------------------------------------------
-    void WriteBinaryAnim( IOStream * container, const aiAnimation* anim )
-    {
-        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIANIMATION );
-
-        Write<aiString>(&chunk,anim->mName);
-        Write<double>(&chunk,anim->mDuration);
-        Write<double>(&chunk,anim->mTicksPerSecond);
-        Write<unsigned int>(&chunk,anim->mNumChannels);
-
-        for (unsigned int a = 0; a < anim->mNumChannels;++a) {
-            const aiNodeAnim* nd = anim->mChannels[a];
-            WriteBinaryNodeAnim(&chunk,nd);
-        }
-    }
-
-    // -----------------------------------------------------------------------------------
-    void WriteBinaryLight( IOStream * container, const aiLight* l )
-    {
-        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AILIGHT );
-
-        Write<aiString>(&chunk,l->mName);
-        Write<unsigned int>(&chunk,l->mType);
-
-        if (l->mType != aiLightSource_DIRECTIONAL) {
-            Write<float>(&chunk,l->mAttenuationConstant);
-            Write<float>(&chunk,l->mAttenuationLinear);
-            Write<float>(&chunk,l->mAttenuationQuadratic);
-        }
-
-        Write<aiColor3D>(&chunk,l->mColorDiffuse);
-        Write<aiColor3D>(&chunk,l->mColorSpecular);
-        Write<aiColor3D>(&chunk,l->mColorAmbient);
-
-        if (l->mType == aiLightSource_SPOT) {
-            Write<float>(&chunk,l->mAngleInnerCone);
-            Write<float>(&chunk,l->mAngleOuterCone);
-        }
-
-    }
-
-    // -----------------------------------------------------------------------------------
-    void WriteBinaryCamera( IOStream * container, const aiCamera* cam )
-    {
-        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AICAMERA );
-
-        Write<aiString>(&chunk,cam->mName);
-        Write<aiVector3D>(&chunk,cam->mPosition);
-        Write<aiVector3D>(&chunk,cam->mLookAt);
-        Write<aiVector3D>(&chunk,cam->mUp);
-        Write<float>(&chunk,cam->mHorizontalFOV);
-        Write<float>(&chunk,cam->mClipPlaneNear);
-        Write<float>(&chunk,cam->mClipPlaneFar);
-        Write<float>(&chunk,cam->mAspect);
-    }
-
-    // -----------------------------------------------------------------------------------
-    void WriteBinaryScene( IOStream * container, const aiScene* scene)
-    {
-        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AISCENE );
-
-        // basic scene information
-        Write<unsigned int>(&chunk,scene->mFlags);
-        Write<unsigned int>(&chunk,scene->mNumMeshes);
-        Write<unsigned int>(&chunk,scene->mNumMaterials);
-        Write<unsigned int>(&chunk,scene->mNumAnimations);
-        Write<unsigned int>(&chunk,scene->mNumTextures);
-        Write<unsigned int>(&chunk,scene->mNumLights);
-        Write<unsigned int>(&chunk,scene->mNumCameras);
-
-        // write node graph
-        WriteBinaryNode( &chunk, scene->mRootNode );
-
-        // write all meshes
-        for (unsigned int i = 0; i < scene->mNumMeshes;++i) {
-            const aiMesh* mesh = scene->mMeshes[i];
-            WriteBinaryMesh( &chunk,mesh);
-        }
-
-        // write materials
-        for (unsigned int i = 0; i< scene->mNumMaterials; ++i) {
-            const aiMaterial* mat = scene->mMaterials[i];
-            WriteBinaryMaterial(&chunk,mat);
-        }
-
-        // write all animations
-        for (unsigned int i = 0; i < scene->mNumAnimations;++i) {
-            const aiAnimation* anim = scene->mAnimations[i];
-            WriteBinaryAnim(&chunk,anim);
-        }
-
-
-        // write all textures
-        for (unsigned int i = 0; i < scene->mNumTextures;++i) {
-            const aiTexture* mesh = scene->mTextures[i];
-            WriteBinaryTexture(&chunk,mesh);
-        }
-
-        // write lights
-        for (unsigned int i = 0; i < scene->mNumLights;++i) {
-            const aiLight* l = scene->mLights[i];
-            WriteBinaryLight(&chunk,l);
-        }
-
-        // write cameras
-        for (unsigned int i = 0; i < scene->mNumCameras;++i) {
-            const aiCamera* cam = scene->mCameras[i];
-            WriteBinaryCamera(&chunk,cam);
-        }
-
-    }
-
-public:
-    AssbinExport()
-        : shortened(false), compressed(false) // temporary settings until properties are introduced for exporters
-    {
-    }
-
-    // -----------------------------------------------------------------------------------
-    // Write a binary model dump
-    void WriteBinaryDump(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene)
-    {
-        IOStream * out = pIOSystem->Open( pFile, "wb" );
-        if (!out) return;
-
-        time_t tt = time(NULL);
-#if _WIN32
-        tm* p     = gmtime(&tt);
-#else
-        struct tm now;
-        tm* p = gmtime_r(&tt, &now);
-#endif
-
-        // header
-        char s[64];
-        memset( s, 0, 64 );
-#if _MSC_VER >= 1400
-        sprintf_s(s,"ASSIMP.binary-dump.%s",asctime(p));
-#else
-        ai_snprintf(s,64,"ASSIMP.binary-dump.%s",asctime(p));
-#endif
-        out->Write( s, 44, 1 );
-        // == 44 bytes
-
-        Write<unsigned int>( out, ASSBIN_VERSION_MAJOR );
-        Write<unsigned int>( out, ASSBIN_VERSION_MINOR );
-        Write<unsigned int>( out, aiGetVersionRevision() );
-        Write<unsigned int>( out, aiGetCompileFlags() );
-        Write<uint16_t>( out, shortened );
-        Write<uint16_t>( out, compressed );
-        // ==  20 bytes
-
-        char buff[256];
-        strncpy(buff,pFile,256);
-        out->Write(buff,sizeof(char),256);
-
-        char cmd[] = "\0";
-        strncpy(buff,cmd,128);
-        out->Write(buff,sizeof(char),128);
-
-        // leave 64 bytes free for future extensions
-        memset(buff,0xcd,64);
-        out->Write(buff,sizeof(char),64);
-        // == 435 bytes
-
-        // ==== total header size: 512 bytes
-        ai_assert( out->Tell() == ASSBIN_HEADER_LENGTH );
-
-        // Up to here the data is uncompressed. For compressed files, the rest
-        // is compressed using standard DEFLATE from zlib.
-        if (compressed)
-        {
-            AssbinChunkWriter uncompressedStream( NULL, 0 );
-            WriteBinaryScene( &uncompressedStream, pScene );
-
-            uLongf uncompressedSize = static_cast<uLongf>(uncompressedStream.Tell());
-            uLongf compressedSize = (uLongf)compressBound(uncompressedSize);
-            uint8_t* compressedBuffer = new uint8_t[ compressedSize ];
-
-            int res = compress2( compressedBuffer, &compressedSize, (const Bytef*)uncompressedStream.GetBufferPointer(), uncompressedSize, 9 );
-            if(res != Z_OK)
-            {
-                delete [] compressedBuffer;
-                pIOSystem->Close(out);
-                throw DeadlyExportError("Compression failed.");
-            }
-
-            out->Write( &uncompressedSize, sizeof(uint32_t), 1 );
-            out->Write( compressedBuffer, sizeof(char), compressedSize );
-
-            delete[] compressedBuffer;
-        }
-        else
-        {
-            WriteBinaryScene( out, pScene );
-        }
-
-        pIOSystem->Close( out );
-    }
-};
-
-void ExportSceneAssbin(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/) {
-    AssbinExport exporter;
-    exporter.WriteBinaryDump( pFile, pIOSystem, pScene );
-}
-} // end of namespace Assimp
-
-#endif // ASSIMP_BUILD_NO_ASSBIN_EXPORTER
-#endif // ASSIMP_BUILD_NO_EXPORT
diff --git a/Engine/lib/assimp/code/3DS/3DSConverter.cpp b/Engine/lib/assimp/code/AssetLib/3DS/3DSConverter.cpp
similarity index 58%
rename from Engine/lib/assimp/code/3DS/3DSConverter.cpp
rename to Engine/lib/assimp/code/AssetLib/3DS/3DSConverter.cpp
index 2176b75fc..5a01429e4 100644
--- a/Engine/lib/assimp/code/3DS/3DSConverter.cpp
+++ b/Engine/lib/assimp/code/AssetLib/3DS/3DSConverter.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,17 +41,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** @file Implementation of the 3ds importer class */
 
-
 #ifndef ASSIMP_BUILD_NO_3DS_IMPORTER
 
 // internal headers
 #include "3DSLoader.h"
 #include "Common/TargetAnimation.h"
+#include <assimp/StringComparison.h>
 #include <assimp/scene.h>
 #include <assimp/DefaultLogger.hpp>
-#include <assimp/StringComparison.h>
-#include <memory>
 #include <cctype>
+#include <memory>
 
 using namespace Assimp;
 
@@ -61,75 +58,61 @@ static const unsigned int NotSet = 0xcdcdcdcd;
 
 // ------------------------------------------------------------------------------------------------
 // Setup final material indices, generae a default material if necessary
-void Discreet3DSImporter::ReplaceDefaultMaterial()
-{
+void Discreet3DSImporter::ReplaceDefaultMaterial() {
     // Try to find an existing material that matches the
     // typical default material setting:
     // - no textures
     // - diffuse color (in grey!)
     // NOTE: This is here to workaround the fact that some
     // exporters are writing a default material, too.
-    unsigned int idx( NotSet );
-    for (unsigned int i = 0; i < mScene->mMaterials.size();++i)
-    {
-        std::string &s = mScene->mMaterials[i].mName;
-        for ( std::string::iterator it = s.begin(); it != s.end(); ++it ) {
-            *it = static_cast< char >( ::tolower( *it ) );
+    unsigned int idx(NotSet);
+    for (unsigned int i = 0; i < mScene->mMaterials.size(); ++i) {
+        std::string s = mScene->mMaterials[i].mName;
+        for (char & it : s) {
+            it = static_cast<char>(::tolower(static_cast<unsigned char>(it)));
         }
 
-        if (std::string::npos == s.find("default"))continue;
+        if (std::string::npos == s.find("default")) continue;
 
         if (mScene->mMaterials[i].mDiffuse.r !=
-            mScene->mMaterials[i].mDiffuse.g ||
-            mScene->mMaterials[i].mDiffuse.r !=
-            mScene->mMaterials[i].mDiffuse.b)continue;
+                        mScene->mMaterials[i].mDiffuse.g ||
+                mScene->mMaterials[i].mDiffuse.r !=
+                        mScene->mMaterials[i].mDiffuse.b) continue;
 
-        if (mScene->mMaterials[i].sTexDiffuse.mMapName.length()   != 0  ||
-            mScene->mMaterials[i].sTexBump.mMapName.length()      != 0  ||
-            mScene->mMaterials[i].sTexOpacity.mMapName.length()   != 0  ||
-            mScene->mMaterials[i].sTexEmissive.mMapName.length()  != 0  ||
-            mScene->mMaterials[i].sTexSpecular.mMapName.length()  != 0  ||
-            mScene->mMaterials[i].sTexShininess.mMapName.length() != 0 )
-        {
+        if (ContainsTextures(i)) {
             continue;
         }
         idx = i;
     }
-    if ( NotSet == idx ) {
-        idx = ( unsigned int )mScene->mMaterials.size();
+    if (NotSet == idx) {
+        idx = (unsigned int)mScene->mMaterials.size();
     }
 
     // now iterate through all meshes and through all faces and
     // find all faces that are using the default material
     unsigned int cnt = 0;
     for (std::vector<D3DS::Mesh>::iterator
-        i =  mScene->mMeshes.begin();
-        i != mScene->mMeshes.end();++i)
-    {
+                    i = mScene->mMeshes.begin();
+            i != mScene->mMeshes.end(); ++i) {
         for (std::vector<unsigned int>::iterator
-            a =  (*i).mFaceMaterials.begin();
-            a != (*i).mFaceMaterials.end();++a)
-        {
+                        a = (*i).mFaceMaterials.begin();
+                a != (*i).mFaceMaterials.end(); ++a) {
             // NOTE: The additional check seems to be necessary,
             // some exporters seem to generate invalid data here
-            if (0xcdcdcdcd == (*a))
-            {
+            if (0xcdcdcdcd == (*a)) {
                 (*a) = idx;
                 ++cnt;
-            }
-            else if ( (*a) >= mScene->mMaterials.size())
-            {
+            } else if ((*a) >= mScene->mMaterials.size()) {
                 (*a) = idx;
                 ASSIMP_LOG_WARN("Material index overflow in 3DS file. Using default material");
                 ++cnt;
             }
         }
     }
-    if (cnt && idx == mScene->mMaterials.size())
-    {
+    if (cnt && idx == mScene->mMaterials.size()) {
         // We need to create our own default material
         D3DS::Material sMat("%%%DEFAULT");
-        sMat.mDiffuse = aiColor3D(0.3f,0.3f,0.3f);
+        sMat.mDiffuse = aiColor3D(0.3f, 0.3f, 0.3f);
         mScene->mMaterials.push_back(sMat);
 
         ASSIMP_LOG_INFO("3DS: Generating default material");
@@ -138,22 +121,17 @@ void Discreet3DSImporter::ReplaceDefaultMaterial()
 
 // ------------------------------------------------------------------------------------------------
 // Check whether all indices are valid. Otherwise we'd crash before the validation step is reached
-void Discreet3DSImporter::CheckIndices(D3DS::Mesh& sMesh)
-{
-    for (std::vector< D3DS::Face >::iterator i =  sMesh.mFaces.begin(); i != sMesh.mFaces.end();++i)
-    {
+void Discreet3DSImporter::CheckIndices(D3DS::Mesh &sMesh) {
+    for (std::vector<D3DS::Face>::iterator i = sMesh.mFaces.begin(); i != sMesh.mFaces.end(); ++i) {
         // check whether all indices are in range
-        for (unsigned int a = 0; a < 3;++a)
-        {
-            if ((*i).mIndices[a] >= sMesh.mPositions.size())
-            {
+        for (unsigned int a = 0; a < 3; ++a) {
+            if ((*i).mIndices[a] >= sMesh.mPositions.size()) {
                 ASSIMP_LOG_WARN("3DS: Vertex index overflow)");
-                (*i).mIndices[a] = (uint32_t)sMesh.mPositions.size()-1;
+                (*i).mIndices[a] = (uint32_t)sMesh.mPositions.size() - 1;
             }
-            if ( !sMesh.mTexCoords.empty() && (*i).mIndices[a] >= sMesh.mTexCoords.size())
-            {
+            if (!sMesh.mTexCoords.empty() && (*i).mIndices[a] >= sMesh.mTexCoords.size()) {
                 ASSIMP_LOG_WARN("3DS: Texture coordinate index overflow)");
-                (*i).mIndices[a] = (uint32_t)sMesh.mTexCoords.size()-1;
+                (*i).mIndices[a] = (uint32_t)sMesh.mTexCoords.size() - 1;
             }
         }
     }
@@ -161,24 +139,21 @@ void Discreet3DSImporter::CheckIndices(D3DS::Mesh& sMesh)
 
 // ------------------------------------------------------------------------------------------------
 // Generate out unique verbose format representation
-void Discreet3DSImporter::MakeUnique(D3DS::Mesh& sMesh)
-{
+void Discreet3DSImporter::MakeUnique(D3DS::Mesh &sMesh) {
     // TODO: really necessary? I don't think. Just a waste of memory and time
     // to do it now in a separate buffer.
 
     // Allocate output storage
-    std::vector<aiVector3D> vNew  (sMesh.mFaces.size() * 3);
+    std::vector<aiVector3D> vNew(sMesh.mFaces.size() * 3);
     std::vector<aiVector3D> vNew2;
     if (sMesh.mTexCoords.size())
         vNew2.resize(sMesh.mFaces.size() * 3);
 
-    for (unsigned int i = 0, base = 0; i < sMesh.mFaces.size();++i)
-    {
-        D3DS::Face& face = sMesh.mFaces[i];
+    for (unsigned int i = 0, base = 0; i < sMesh.mFaces.size(); ++i) {
+        D3DS::Face &face = sMesh.mFaces[i];
 
         // Positions
-        for (unsigned int a = 0; a < 3;++a,++base)
-        {
+        for (unsigned int a = 0; a < 3; ++a, ++base) {
             vNew[base] = sMesh.mPositions[face.mIndices[a]];
             if (sMesh.mTexCoords.size())
                 vNew2[base] = sMesh.mTexCoords[face.mIndices[a]];
@@ -192,26 +167,24 @@ void Discreet3DSImporter::MakeUnique(D3DS::Mesh& sMesh)
 
 // ------------------------------------------------------------------------------------------------
 // Convert a 3DS texture to texture keys in an aiMaterial
-void CopyTexture(aiMaterial& mat, D3DS::Texture& texture, aiTextureType type)
-{
+void CopyTexture(aiMaterial &mat, D3DS::Texture &texture, aiTextureType type) {
     // Setup the texture name
     aiString tex;
-    tex.Set( texture.mMapName);
-    mat.AddProperty( &tex, AI_MATKEY_TEXTURE(type,0));
+    tex.Set(texture.mMapName);
+    mat.AddProperty(&tex, AI_MATKEY_TEXTURE(type, 0));
 
     // Setup the texture blend factor
     if (is_not_qnan(texture.mTextureBlend))
-        mat.AddProperty<ai_real>( &texture.mTextureBlend, 1, AI_MATKEY_TEXBLEND(type,0));
+        mat.AddProperty<ai_real>(&texture.mTextureBlend, 1, AI_MATKEY_TEXBLEND(type, 0));
 
     // Setup the texture mapping mode
     int mapMode = static_cast<int>(texture.mMapMode);
-    mat.AddProperty<int>(&mapMode,1,AI_MATKEY_MAPPINGMODE_U(type,0));
-    mat.AddProperty<int>(&mapMode,1,AI_MATKEY_MAPPINGMODE_V(type,0));
+    mat.AddProperty<int>(&mapMode, 1, AI_MATKEY_MAPPINGMODE_U(type, 0));
+    mat.AddProperty<int>(&mapMode, 1, AI_MATKEY_MAPPINGMODE_V(type, 0));
 
     // Mirroring - double the scaling values
     // FIXME: this is not really correct ...
-    if (texture.mMapMode == aiTextureMapMode_Mirror)
-    {
+    if (texture.mMapMode == aiTextureMapMode_Mirror) {
         texture.mScaleU *= 2.0;
         texture.mScaleV *= 2.0;
         texture.mOffsetU /= 2.0;
@@ -219,24 +192,22 @@ void CopyTexture(aiMaterial& mat, D3DS::Texture& texture, aiTextureType type)
     }
 
     // Setup texture UV transformations
-    mat.AddProperty<ai_real>(&texture.mOffsetU,5,AI_MATKEY_UVTRANSFORM(type,0));
+    mat.AddProperty<ai_real>(&texture.mOffsetU, 5, AI_MATKEY_UVTRANSFORM(type, 0));
 }
 
 // ------------------------------------------------------------------------------------------------
 // Convert a 3DS material to an aiMaterial
-void Discreet3DSImporter::ConvertMaterial(D3DS::Material& oldMat,
-    aiMaterial& mat)
-{
+void Discreet3DSImporter::ConvertMaterial(D3DS::Material &oldMat,
+        aiMaterial &mat) {
     // NOTE: Pass the background image to the viewer by bypassing the
     // material system. This is an evil hack, never do it again!
-    if (0 != mBackgroundImage.length() && bHasBG)
-    {
+    if (0 != mBackgroundImage.length() && bHasBG) {
         aiString tex;
-        tex.Set( mBackgroundImage);
-        mat.AddProperty( &tex, AI_MATKEY_GLOBAL_BACKGROUND_IMAGE);
+        tex.Set(mBackgroundImage);
+        mat.AddProperty(&tex, AI_MATKEY_GLOBAL_BACKGROUND_IMAGE);
 
         // Be sure this is only done for the first material
-        mBackgroundImage = std::string("");
+        mBackgroundImage = std::string();
     }
 
     // At first add the base ambient color of the scene to the material
@@ -245,143 +216,138 @@ void Discreet3DSImporter::ConvertMaterial(D3DS::Material& oldMat,
     oldMat.mAmbient.b += mClrAmbient.b;
 
     aiString name;
-    name.Set( oldMat.mName);
-    mat.AddProperty( &name, AI_MATKEY_NAME);
+    name.Set(oldMat.mName);
+    mat.AddProperty(&name, AI_MATKEY_NAME);
 
     // Material colors
-    mat.AddProperty( &oldMat.mAmbient, 1, AI_MATKEY_COLOR_AMBIENT);
-    mat.AddProperty( &oldMat.mDiffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
-    mat.AddProperty( &oldMat.mSpecular, 1, AI_MATKEY_COLOR_SPECULAR);
-    mat.AddProperty( &oldMat.mEmissive, 1, AI_MATKEY_COLOR_EMISSIVE);
+    mat.AddProperty(&oldMat.mAmbient, 1, AI_MATKEY_COLOR_AMBIENT);
+    mat.AddProperty(&oldMat.mDiffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
+    mat.AddProperty(&oldMat.mSpecular, 1, AI_MATKEY_COLOR_SPECULAR);
+    mat.AddProperty(&oldMat.mEmissive, 1, AI_MATKEY_COLOR_EMISSIVE);
 
     // Phong shininess and shininess strength
     if (D3DS::Discreet3DS::Phong == oldMat.mShading ||
-        D3DS::Discreet3DS::Metal == oldMat.mShading)
-    {
-        if (!oldMat.mSpecularExponent || !oldMat.mShininessStrength)
-        {
+            D3DS::Discreet3DS::Metal == oldMat.mShading) {
+        if (!oldMat.mSpecularExponent || !oldMat.mShininessStrength) {
             oldMat.mShading = D3DS::Discreet3DS::Gouraud;
-        }
-        else
-        {
-            mat.AddProperty( &oldMat.mSpecularExponent, 1, AI_MATKEY_SHININESS);
-            mat.AddProperty( &oldMat.mShininessStrength, 1, AI_MATKEY_SHININESS_STRENGTH);
+        } else {
+            mat.AddProperty(&oldMat.mSpecularExponent, 1, AI_MATKEY_SHININESS);
+            mat.AddProperty(&oldMat.mShininessStrength, 1, AI_MATKEY_SHININESS_STRENGTH);
         }
     }
 
     // Opacity
-    mat.AddProperty<ai_real>( &oldMat.mTransparency,1,AI_MATKEY_OPACITY);
+    mat.AddProperty<ai_real>(&oldMat.mTransparency, 1, AI_MATKEY_OPACITY);
 
     // Bump height scaling
-    mat.AddProperty<ai_real>( &oldMat.mBumpHeight,1,AI_MATKEY_BUMPSCALING);
+    mat.AddProperty<ai_real>(&oldMat.mBumpHeight, 1, AI_MATKEY_BUMPSCALING);
 
     // Two sided rendering?
-    if (oldMat.mTwoSided)
-    {
+    if (oldMat.mTwoSided) {
         int i = 1;
-        mat.AddProperty<int>(&i,1,AI_MATKEY_TWOSIDED);
+        mat.AddProperty<int>(&i, 1, AI_MATKEY_TWOSIDED);
     }
 
     // Shading mode
     aiShadingMode eShading = aiShadingMode_NoShading;
-    switch (oldMat.mShading)
-    {
-        case D3DS::Discreet3DS::Flat:
-            eShading = aiShadingMode_Flat; break;
+    switch (oldMat.mShading) {
+    case D3DS::Discreet3DS::Flat:
+        eShading = aiShadingMode_Flat;
+        break;
 
-        // I don't know what "Wire" shading should be,
-        // assume it is simple lambertian diffuse shading
-        case D3DS::Discreet3DS::Wire:
-            {
-                // Set the wireframe flag
-                unsigned int iWire = 1;
-                mat.AddProperty<int>( (int*)&iWire,1,AI_MATKEY_ENABLE_WIREFRAME);
-            }
+    // I don't know what "Wire" shading should be,
+    // assume it is simple lambertian diffuse shading
+    case D3DS::Discreet3DS::Wire: {
+        // Set the wireframe flag
+        unsigned int iWire = 1;
+        mat.AddProperty<int>((int *)&iWire, 1, AI_MATKEY_ENABLE_WIREFRAME);
+    }
 
-        case D3DS::Discreet3DS::Gouraud:
-            eShading = aiShadingMode_Gouraud; break;
+    case D3DS::Discreet3DS::Gouraud:
+        eShading = aiShadingMode_Gouraud;
+        break;
 
-        // assume cook-torrance shading for metals.
-        case D3DS::Discreet3DS::Phong :
-            eShading = aiShadingMode_Phong; break;
+    // assume cook-torrance shading for metals.
+    case D3DS::Discreet3DS::Phong:
+        eShading = aiShadingMode_Phong;
+        break;
 
-        case D3DS::Discreet3DS::Metal :
-            eShading = aiShadingMode_CookTorrance; break;
+    case D3DS::Discreet3DS::Metal:
+        eShading = aiShadingMode_CookTorrance;
+        break;
 
-            // FIX to workaround a warning with GCC 4 who complained
-            // about a missing case Blinn: here - Blinn isn't a valid
-            // value in the 3DS Loader, it is just needed for ASE
-        case D3DS::Discreet3DS::Blinn :
-            eShading = aiShadingMode_Blinn; break;
+        // FIX to workaround a warning with GCC 4 who complained
+        // about a missing case Blinn: here - Blinn isn't a valid
+        // value in the 3DS Loader, it is just needed for ASE
+    case D3DS::Discreet3DS::Blinn:
+        eShading = aiShadingMode_Blinn;
+        break;
     }
     int eShading_ = static_cast<int>(eShading);
     mat.AddProperty<int>(&eShading_, 1, AI_MATKEY_SHADING_MODEL);
 
     // DIFFUSE texture
-    if( oldMat.sTexDiffuse.mMapName.length() > 0)
-        CopyTexture(mat,oldMat.sTexDiffuse, aiTextureType_DIFFUSE);
+    if (oldMat.sTexDiffuse.mMapName.length() > 0)
+        CopyTexture(mat, oldMat.sTexDiffuse, aiTextureType_DIFFUSE);
 
     // SPECULAR texture
-    if( oldMat.sTexSpecular.mMapName.length() > 0)
-        CopyTexture(mat,oldMat.sTexSpecular, aiTextureType_SPECULAR);
+    if (oldMat.sTexSpecular.mMapName.length() > 0)
+        CopyTexture(mat, oldMat.sTexSpecular, aiTextureType_SPECULAR);
 
     // OPACITY texture
-    if( oldMat.sTexOpacity.mMapName.length() > 0)
-        CopyTexture(mat,oldMat.sTexOpacity, aiTextureType_OPACITY);
+    if (oldMat.sTexOpacity.mMapName.length() > 0)
+        CopyTexture(mat, oldMat.sTexOpacity, aiTextureType_OPACITY);
 
     // EMISSIVE texture
-    if( oldMat.sTexEmissive.mMapName.length() > 0)
-        CopyTexture(mat,oldMat.sTexEmissive, aiTextureType_EMISSIVE);
+    if (oldMat.sTexEmissive.mMapName.length() > 0)
+        CopyTexture(mat, oldMat.sTexEmissive, aiTextureType_EMISSIVE);
 
     // BUMP texture
-    if( oldMat.sTexBump.mMapName.length() > 0)
-        CopyTexture(mat,oldMat.sTexBump, aiTextureType_HEIGHT);
+    if (oldMat.sTexBump.mMapName.length() > 0)
+        CopyTexture(mat, oldMat.sTexBump, aiTextureType_HEIGHT);
 
     // SHININESS texture
-    if( oldMat.sTexShininess.mMapName.length() > 0)
-        CopyTexture(mat,oldMat.sTexShininess, aiTextureType_SHININESS);
+    if (oldMat.sTexShininess.mMapName.length() > 0)
+        CopyTexture(mat, oldMat.sTexShininess, aiTextureType_SHININESS);
 
     // REFLECTION texture
-    if( oldMat.sTexReflective.mMapName.length() > 0)
-        CopyTexture(mat,oldMat.sTexReflective, aiTextureType_REFLECTION);
+    if (oldMat.sTexReflective.mMapName.length() > 0)
+        CopyTexture(mat, oldMat.sTexReflective, aiTextureType_REFLECTION);
 
     // Store the name of the material itself, too
-    if( oldMat.mName.length())  {
+    if (oldMat.mName.length()) {
         aiString tex;
-        tex.Set( oldMat.mName);
-        mat.AddProperty( &tex, AI_MATKEY_NAME);
+        tex.Set(oldMat.mName);
+        mat.AddProperty(&tex, AI_MATKEY_NAME);
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Split meshes by their materials and generate output aiMesh'es
-void Discreet3DSImporter::ConvertMeshes(aiScene* pcOut)
-{
-    std::vector<aiMesh*> avOutMeshes;
+void Discreet3DSImporter::ConvertMeshes(aiScene *pcOut) {
+    std::vector<aiMesh *> avOutMeshes;
     avOutMeshes.reserve(mScene->mMeshes.size() * 2);
 
-    unsigned int iFaceCnt = 0,num = 0;
+    unsigned int iFaceCnt = 0, num = 0;
     aiString name;
 
     // we need to split all meshes by their materials
-    for (std::vector<D3DS::Mesh>::iterator i =  mScene->mMeshes.begin(); i != mScene->mMeshes.end();++i)    {
-        std::unique_ptr< std::vector<unsigned int>[] > aiSplit(new std::vector<unsigned int>[mScene->mMaterials.size()]);
+    for (std::vector<D3DS::Mesh>::iterator i = mScene->mMeshes.begin(); i != mScene->mMeshes.end(); ++i) {
+        std::unique_ptr<std::vector<unsigned int>[]> aiSplit(new std::vector<unsigned int>[mScene->mMaterials.size()]);
 
-        name.length = ASSIMP_itoa10(name.data,num++);
+        name.length = ASSIMP_itoa10(name.data, num++);
 
         unsigned int iNum = 0;
-        for (std::vector<unsigned int>::const_iterator a =  (*i).mFaceMaterials.begin();
-            a != (*i).mFaceMaterials.end();++a,++iNum)
-        {
+        for (std::vector<unsigned int>::const_iterator a = (*i).mFaceMaterials.begin();
+                a != (*i).mFaceMaterials.end(); ++a, ++iNum) {
             aiSplit[*a].push_back(iNum);
         }
         // now generate submeshes
-        for (unsigned int p = 0; p < mScene->mMaterials.size();++p)
-        {
+        for (unsigned int p = 0; p < mScene->mMaterials.size(); ++p) {
             if (aiSplit[p].empty()) {
                 continue;
             }
-            aiMesh* meshOut = new aiMesh();
+            aiMesh *meshOut = new aiMesh();
             meshOut->mName = name;
             meshOut->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
 
@@ -389,36 +355,33 @@ void Discreet3DSImporter::ConvertMeshes(aiScene* pcOut)
             meshOut->mMaterialIndex = p;
 
             // use the color data as temporary storage
-            meshOut->mColors[0] = (aiColor4D*)(&*i);
+            meshOut->mColors[0] = (aiColor4D *)(&*i);
             avOutMeshes.push_back(meshOut);
 
             // convert vertices
             meshOut->mNumFaces = (unsigned int)aiSplit[p].size();
-            meshOut->mNumVertices = meshOut->mNumFaces*3;
+            meshOut->mNumVertices = meshOut->mNumFaces * 3;
 
             // allocate enough storage for faces
             meshOut->mFaces = new aiFace[meshOut->mNumFaces];
             iFaceCnt += meshOut->mNumFaces;
 
             meshOut->mVertices = new aiVector3D[meshOut->mNumVertices];
-            meshOut->mNormals  = new aiVector3D[meshOut->mNumVertices];
-            if ((*i).mTexCoords.size())
-            {
+            meshOut->mNormals = new aiVector3D[meshOut->mNumVertices];
+            if ((*i).mTexCoords.size()) {
                 meshOut->mTextureCoords[0] = new aiVector3D[meshOut->mNumVertices];
             }
-            for (unsigned int q = 0, base = 0; q < aiSplit[p].size();++q)
-            {
+            for (unsigned int q = 0, base = 0; q < aiSplit[p].size(); ++q) {
                 unsigned int index = aiSplit[p][q];
-                aiFace& face = meshOut->mFaces[q];
+                aiFace &face = meshOut->mFaces[q];
 
                 face.mIndices = new unsigned int[3];
                 face.mNumIndices = 3;
 
-                for (unsigned int a = 0; a < 3;++a,++base)
-                {
+                for (unsigned int a = 0; a < 3; ++a, ++base) {
                     unsigned int idx = (*i).mFaces[index].mIndices[a];
-                    meshOut->mVertices[base]  = (*i).mPositions[idx];
-                    meshOut->mNormals [base]  = (*i).mNormals[idx];
+                    meshOut->mVertices[base] = (*i).mPositions[idx];
+                    meshOut->mNormals[base] = (*i).mNormals[idx];
 
                     if ((*i).mTexCoords.size())
                         meshOut->mTextureCoords[0][base] = (*i).mTexCoords[idx];
@@ -431,8 +394,8 @@ void Discreet3DSImporter::ConvertMeshes(aiScene* pcOut)
 
     // Copy them to the output array
     pcOut->mNumMeshes = (unsigned int)avOutMeshes.size();
-    pcOut->mMeshes = new aiMesh*[pcOut->mNumMeshes]();
-    for (unsigned int a = 0; a < pcOut->mNumMeshes;++a) {
+    pcOut->mMeshes = new aiMesh *[pcOut->mNumMeshes]();
+    for (unsigned int a = 0; a < pcOut->mNumMeshes; ++a) {
         pcOut->mMeshes[a] = avOutMeshes[a];
     }
 
@@ -444,47 +407,44 @@ void Discreet3DSImporter::ConvertMeshes(aiScene* pcOut)
 
 // ------------------------------------------------------------------------------------------------
 // Add a node to the scenegraph and setup its final transformation
-void Discreet3DSImporter::AddNodeToGraph(aiScene* pcSOut,aiNode* pcOut,
-    D3DS::Node* pcIn, aiMatrix4x4& /*absTrafo*/)
-{
+void Discreet3DSImporter::AddNodeToGraph(aiScene *pcSOut, aiNode *pcOut,
+        D3DS::Node *pcIn, aiMatrix4x4 & /*absTrafo*/) {
     std::vector<unsigned int> iArray;
     iArray.reserve(3);
 
     aiMatrix4x4 abs;
 
     // Find all meshes with the same name as the node
-    for (unsigned int a = 0; a < pcSOut->mNumMeshes;++a)
-    {
-        const D3DS::Mesh* pcMesh = (const D3DS::Mesh*)pcSOut->mMeshes[a]->mColors[0];
-        ai_assert(NULL != pcMesh);
+    for (unsigned int a = 0; a < pcSOut->mNumMeshes; ++a) {
+        const D3DS::Mesh *pcMesh = (const D3DS::Mesh *)pcSOut->mMeshes[a]->mColors[0];
+        ai_assert(nullptr != pcMesh);
 
         if (pcIn->mName == pcMesh->mName)
             iArray.push_back(a);
     }
-    if (!iArray.empty())
-    {
+    if (!iArray.empty()) {
         // The matrix should be identical for all meshes with the
         // same name. It HAS to be identical for all meshes .....
-        D3DS::Mesh* imesh = ((D3DS::Mesh*)pcSOut->mMeshes[iArray[0]]->mColors[0]);
+        D3DS::Mesh *imesh = ((D3DS::Mesh *)pcSOut->mMeshes[iArray[0]]->mColors[0]);
 
         // Compute the inverse of the transformation matrix to move the
         // vertices back to their relative and local space
         aiMatrix4x4 mInv = imesh->mMat, mInvTransposed = imesh->mMat;
-        mInv.Inverse();mInvTransposed.Transpose();
+        mInv.Inverse();
+        mInvTransposed.Transpose();
         aiVector3D pivot = pcIn->vPivot;
 
         pcOut->mNumMeshes = (unsigned int)iArray.size();
         pcOut->mMeshes = new unsigned int[iArray.size()];
-        for (unsigned int i = 0;i < iArray.size();++i)  {
+        for (unsigned int i = 0; i < iArray.size(); ++i) {
             const unsigned int iIndex = iArray[i];
-            aiMesh* const mesh = pcSOut->mMeshes[iIndex];
+            aiMesh *const mesh = pcSOut->mMeshes[iIndex];
 
-            if (mesh->mColors[1] == NULL)
-            {
+            if (mesh->mColors[1] == nullptr) {
                 // Transform the vertices back into their local space
                 // fixme: consider computing normals after this, so we don't need to transform them
-                const aiVector3D* const pvEnd = mesh->mVertices + mesh->mNumVertices;
-                aiVector3D* pvCurrent = mesh->mVertices, *t2 = mesh->mNormals;
+                const aiVector3D *const pvEnd = mesh->mVertices + mesh->mNumVertices;
+                aiVector3D *pvCurrent = mesh->mVertices, *t2 = mesh->mNormals;
 
                 for (; pvCurrent != pvEnd; ++pvCurrent, ++t2) {
                     *pvCurrent = mInv * (*pvCurrent);
@@ -492,8 +452,7 @@ void Discreet3DSImporter::AddNodeToGraph(aiScene* pcSOut,aiNode* pcOut,
                 }
 
                 // Handle negative transformation matrix determinant -> invert vertex x
-                if (imesh->mMat.Determinant() < 0.0f)
-                {
+                if (imesh->mMat.Determinant() < 0.0f) {
                     /* we *must* have normals */
                     for (pvCurrent = mesh->mVertices, t2 = mesh->mNormals; pvCurrent != pvEnd; ++pvCurrent, ++t2) {
                         pvCurrent->x *= -1.f;
@@ -503,17 +462,15 @@ void Discreet3DSImporter::AddNodeToGraph(aiScene* pcSOut,aiNode* pcOut,
                 }
 
                 // Handle pivot point
-                if (pivot.x || pivot.y || pivot.z)
-                {
-                    for (pvCurrent = mesh->mVertices; pvCurrent != pvEnd; ++pvCurrent)  {
+                if (pivot.x || pivot.y || pivot.z) {
+                    for (pvCurrent = mesh->mVertices; pvCurrent != pvEnd; ++pvCurrent) {
                         *pvCurrent -= pivot;
                     }
                 }
 
-                mesh->mColors[1] = (aiColor4D*)1;
-            }
-            else
-                mesh->mColors[1] = (aiColor4D*)1;
+                mesh->mColors[1] = (aiColor4D *)1;
+            } else
+                mesh->mColors[1] = (aiColor4D *)1;
 
             // Setup the mesh index
             pcOut->mMeshes[i] = iIndex;
@@ -522,84 +479,81 @@ void Discreet3DSImporter::AddNodeToGraph(aiScene* pcSOut,aiNode* pcOut,
 
     // Setup the name of the node
     // First instance keeps its name otherwise something might break, all others will be postfixed with their instance number
-    if (pcIn->mInstanceNumber > 1)
-    {
+    if (pcIn->mInstanceNumber > 1) {
         char tmp[12];
         ASSIMP_itoa10(tmp, pcIn->mInstanceNumber);
         std::string tempStr = pcIn->mName + "_inst_";
         tempStr += tmp;
         pcOut->mName.Set(tempStr);
-    }
-    else
+    } else
         pcOut->mName.Set(pcIn->mName);
 
     // Now build the transformation matrix of the node
     // ROTATION
-    if (pcIn->aRotationKeys.size()){
+    if (pcIn->aRotationKeys.size()) {
 
         // FIX to get to Assimp's quaternion conventions
         for (std::vector<aiQuatKey>::iterator it = pcIn->aRotationKeys.begin(); it != pcIn->aRotationKeys.end(); ++it) {
             (*it).mValue.w *= -1.f;
         }
 
-        pcOut->mTransformation = aiMatrix4x4( pcIn->aRotationKeys[0].mValue.GetMatrix() );
-    }
-    else if (pcIn->aCameraRollKeys.size())
-    {
-        aiMatrix4x4::RotationZ(AI_DEG_TO_RAD(- pcIn->aCameraRollKeys[0].mValue),
-            pcOut->mTransformation);
+        pcOut->mTransformation = aiMatrix4x4(pcIn->aRotationKeys[0].mValue.GetMatrix());
+    } else if (pcIn->aCameraRollKeys.size()) {
+        aiMatrix4x4::RotationZ(AI_DEG_TO_RAD(-pcIn->aCameraRollKeys[0].mValue),
+                pcOut->mTransformation);
     }
 
     // SCALING
-    aiMatrix4x4& m = pcOut->mTransformation;
-    if (pcIn->aScalingKeys.size())
-    {
-        const aiVector3D& v = pcIn->aScalingKeys[0].mValue;
-        m.a1 *= v.x; m.b1 *= v.x; m.c1 *= v.x;
-        m.a2 *= v.y; m.b2 *= v.y; m.c2 *= v.y;
-        m.a3 *= v.z; m.b3 *= v.z; m.c3 *= v.z;
+    aiMatrix4x4 &m = pcOut->mTransformation;
+    if (pcIn->aScalingKeys.size()) {
+        const aiVector3D &v = pcIn->aScalingKeys[0].mValue;
+        m.a1 *= v.x;
+        m.b1 *= v.x;
+        m.c1 *= v.x;
+        m.a2 *= v.y;
+        m.b2 *= v.y;
+        m.c2 *= v.y;
+        m.a3 *= v.z;
+        m.b3 *= v.z;
+        m.c3 *= v.z;
     }
 
     // TRANSLATION
-    if (pcIn->aPositionKeys.size())
-    {
-        const aiVector3D& v = pcIn->aPositionKeys[0].mValue;
+    if (pcIn->aPositionKeys.size()) {
+        const aiVector3D &v = pcIn->aPositionKeys[0].mValue;
         m.a4 += v.x;
         m.b4 += v.y;
         m.c4 += v.z;
     }
 
     // Generate animation channels for the node
-    if (pcIn->aPositionKeys.size()  > 1  || pcIn->aRotationKeys.size()   > 1 ||
-        pcIn->aScalingKeys.size()   > 1  || pcIn->aCameraRollKeys.size() > 1 ||
-        pcIn->aTargetPositionKeys.size() > 1)
-    {
-        aiAnimation* anim = pcSOut->mAnimations[0];
+    if (pcIn->aPositionKeys.size() > 1 || pcIn->aRotationKeys.size() > 1 ||
+            pcIn->aScalingKeys.size() > 1 || pcIn->aCameraRollKeys.size() > 1 ||
+            pcIn->aTargetPositionKeys.size() > 1) {
+        aiAnimation *anim = pcSOut->mAnimations[0];
         ai_assert(nullptr != anim);
 
-        if (pcIn->aCameraRollKeys.size() > 1)
-        {
-            ASSIMP_LOG_DEBUG("3DS: Converting camera roll track ...");
+        if (pcIn->aCameraRollKeys.size() > 1) {
+            ASSIMP_LOG_VERBOSE_DEBUG("3DS: Converting camera roll track ...");
 
             // Camera roll keys - in fact they're just rotations
             // around the camera's z axis. The angles are given
             // in degrees (and they're clockwise).
             pcIn->aRotationKeys.resize(pcIn->aCameraRollKeys.size());
-            for (unsigned int i = 0; i < pcIn->aCameraRollKeys.size();++i)
-            {
-                aiQuatKey&  q = pcIn->aRotationKeys[i];
-                aiFloatKey& f = pcIn->aCameraRollKeys[i];
+            for (unsigned int i = 0; i < pcIn->aCameraRollKeys.size(); ++i) {
+                aiQuatKey &q = pcIn->aRotationKeys[i];
+                aiFloatKey &f = pcIn->aCameraRollKeys[i];
 
-                q.mTime  = f.mTime;
+                q.mTime = f.mTime;
 
                 // FIX to get to Assimp quaternion conventions
-                q.mValue = aiQuaternion(0.f,0.f,AI_DEG_TO_RAD( /*-*/ f.mValue));
+                q.mValue = aiQuaternion(0.f, 0.f, AI_DEG_TO_RAD(/*-*/ f.mValue));
             }
         }
 #if 0
         if (pcIn->aTargetPositionKeys.size() > 1)
         {
-            ASSIMP_LOG_DEBUG("3DS: Converting target track ...");
+            ASSIMP_LOG_VERBOSE_DEBUG("3DS: Converting target track ...");
 
             // Camera or spot light - need to convert the separate
             // target position channel to our representation
@@ -639,102 +593,93 @@ void Discreet3DSImporter::AddNodeToGraph(aiScene* pcSOut,aiNode* pcOut,
         // Cameras or lights define their transformation in their parent node and in the
         // corresponding light or camera chunks. However, we read and process the latter
         // to to be able to return valid cameras/lights even if no scenegraph is given.
-        for (unsigned int n = 0; n < pcSOut->mNumCameras;++n)   {
+        for (unsigned int n = 0; n < pcSOut->mNumCameras; ++n) {
             if (pcSOut->mCameras[n]->mName == pcOut->mName) {
-                pcSOut->mCameras[n]->mLookAt = aiVector3D(0.f,0.f,1.f);
+                pcSOut->mCameras[n]->mLookAt = aiVector3D(0.f, 0.f, 1.f);
             }
         }
-        for (unsigned int n = 0; n < pcSOut->mNumLights;++n)    {
+        for (unsigned int n = 0; n < pcSOut->mNumLights; ++n) {
             if (pcSOut->mLights[n]->mName == pcOut->mName) {
-                pcSOut->mLights[n]->mDirection = aiVector3D(0.f,0.f,1.f);
+                pcSOut->mLights[n]->mDirection = aiVector3D(0.f, 0.f, 1.f);
             }
         }
 
         // Allocate a new node anim and setup its name
-        aiNodeAnim* nda = anim->mChannels[anim->mNumChannels++] = new aiNodeAnim();
+        aiNodeAnim *nda = anim->mChannels[anim->mNumChannels++] = new aiNodeAnim();
         nda->mNodeName.Set(pcIn->mName);
 
         // POSITION keys
-        if (pcIn->aPositionKeys.size()  > 0)
-        {
+        if (pcIn->aPositionKeys.size() > 0) {
             nda->mNumPositionKeys = (unsigned int)pcIn->aPositionKeys.size();
             nda->mPositionKeys = new aiVectorKey[nda->mNumPositionKeys];
-            ::memcpy(nda->mPositionKeys,&pcIn->aPositionKeys[0],
-                sizeof(aiVectorKey)*nda->mNumPositionKeys);
+            ::memcpy(nda->mPositionKeys, &pcIn->aPositionKeys[0],
+                    sizeof(aiVectorKey) * nda->mNumPositionKeys);
         }
 
         // ROTATION keys
-        if (pcIn->aRotationKeys.size()  > 0)
-        {
+        if (pcIn->aRotationKeys.size() > 0) {
             nda->mNumRotationKeys = (unsigned int)pcIn->aRotationKeys.size();
             nda->mRotationKeys = new aiQuatKey[nda->mNumRotationKeys];
 
             // Rotations are quaternion offsets
             aiQuaternion abs1;
-            for (unsigned int n = 0; n < nda->mNumRotationKeys;++n)
-            {
-                const aiQuatKey& q = pcIn->aRotationKeys[n];
+            for (unsigned int n = 0; n < nda->mNumRotationKeys; ++n) {
+                const aiQuatKey &q = pcIn->aRotationKeys[n];
 
                 abs1 = (n ? abs1 * q.mValue : q.mValue);
-                nda->mRotationKeys[n].mTime  = q.mTime;
+                nda->mRotationKeys[n].mTime = q.mTime;
                 nda->mRotationKeys[n].mValue = abs1.Normalize();
             }
         }
 
         // SCALING keys
-        if (pcIn->aScalingKeys.size()  > 0)
-        {
+        if (pcIn->aScalingKeys.size() > 0) {
             nda->mNumScalingKeys = (unsigned int)pcIn->aScalingKeys.size();
             nda->mScalingKeys = new aiVectorKey[nda->mNumScalingKeys];
-            ::memcpy(nda->mScalingKeys,&pcIn->aScalingKeys[0],
-                sizeof(aiVectorKey)*nda->mNumScalingKeys);
+            ::memcpy(nda->mScalingKeys, &pcIn->aScalingKeys[0],
+                    sizeof(aiVectorKey) * nda->mNumScalingKeys);
         }
     }
 
     // Allocate storage for children
     pcOut->mNumChildren = (unsigned int)pcIn->mChildren.size();
-    pcOut->mChildren = new aiNode*[pcIn->mChildren.size()];
+    pcOut->mChildren = new aiNode *[pcIn->mChildren.size()];
 
     // Recursively process all children
     const unsigned int size = static_cast<unsigned int>(pcIn->mChildren.size());
-    for (unsigned int i = 0; i < size;++i)
-    {
+    for (unsigned int i = 0; i < size; ++i) {
         pcOut->mChildren[i] = new aiNode();
         pcOut->mChildren[i]->mParent = pcOut;
-        AddNodeToGraph(pcSOut,pcOut->mChildren[i],pcIn->mChildren[i],abs);
+        AddNodeToGraph(pcSOut, pcOut->mChildren[i], pcIn->mChildren[i], abs);
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Find out how many node animation channels we'll have finally
-void CountTracks(D3DS::Node* node, unsigned int& cnt)
-{
+void CountTracks(D3DS::Node *node, unsigned int &cnt) {
     //////////////////////////////////////////////////////////////////////////////
     // We will never generate more than one channel for a node, so
     // this is rather easy here.
 
-    if (node->aPositionKeys.size()  > 1  || node->aRotationKeys.size()   > 1   ||
-        node->aScalingKeys.size()   > 1  || node->aCameraRollKeys.size() > 1 ||
-        node->aTargetPositionKeys.size()  > 1)
-    {
+    if (node->aPositionKeys.size() > 1 || node->aRotationKeys.size() > 1 ||
+            node->aScalingKeys.size() > 1 || node->aCameraRollKeys.size() > 1 ||
+            node->aTargetPositionKeys.size() > 1) {
         ++cnt;
 
         // account for the additional channel for the camera/spotlight target position
-        if (node->aTargetPositionKeys.size()  > 1)++cnt;
+        if (node->aTargetPositionKeys.size() > 1) ++cnt;
     }
 
     // Recursively process all children
-    for (unsigned int i = 0; i < node->mChildren.size();++i)
-        CountTracks(node->mChildren[i],cnt);
+    for (unsigned int i = 0; i < node->mChildren.size(); ++i)
+        CountTracks(node->mChildren[i], cnt);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Generate the output node graph
-void Discreet3DSImporter::GenerateNodeGraph(aiScene* pcOut)
-{
+void Discreet3DSImporter::GenerateNodeGraph(aiScene *pcOut) {
     pcOut->mRootNode = new aiNode();
-    if (0 == mRootNode->mChildren.size())
-    {
+    if (0 == mRootNode->mChildren.size()) {
         //////////////////////////////////////////////////////////////////////////////
         // It seems the file is so messed up that it has not even a hierarchy.
         // generate a flat hiearachy which looks like this:
@@ -748,29 +693,27 @@ void Discreet3DSImporter::GenerateNodeGraph(aiScene* pcOut)
         ASSIMP_LOG_WARN("No hierarchy information has been found in the file. ");
 
         pcOut->mRootNode->mNumChildren = pcOut->mNumMeshes +
-            static_cast<unsigned int>(mScene->mCameras.size() + mScene->mLights.size());
+                                         static_cast<unsigned int>(mScene->mCameras.size() + mScene->mLights.size());
 
-        pcOut->mRootNode->mChildren = new aiNode* [ pcOut->mRootNode->mNumChildren ];
+        pcOut->mRootNode->mChildren = new aiNode *[pcOut->mRootNode->mNumChildren];
         pcOut->mRootNode->mName.Set("<3DSDummyRoot>");
 
         // Build dummy nodes for all meshes
         unsigned int a = 0;
-        for (unsigned int i = 0; i < pcOut->mNumMeshes;++i,++a)
-        {
-            aiNode* pcNode = pcOut->mRootNode->mChildren[a] = new aiNode();
+        for (unsigned int i = 0; i < pcOut->mNumMeshes; ++i, ++a) {
+            aiNode *pcNode = pcOut->mRootNode->mChildren[a] = new aiNode();
             pcNode->mParent = pcOut->mRootNode;
             pcNode->mMeshes = new unsigned int[1];
             pcNode->mMeshes[0] = i;
             pcNode->mNumMeshes = 1;
 
             // Build a name for the node
-            pcNode->mName.length = ai_snprintf(pcNode->mName.data, MAXLEN, "3DSMesh_%u",i);
+            pcNode->mName.length = ai_snprintf(pcNode->mName.data, MAXLEN, "3DSMesh_%u", i);
         }
 
         // Build dummy nodes for all cameras
-        for (unsigned int i = 0; i < (unsigned int )mScene->mCameras.size();++i,++a)
-        {
-            aiNode* pcNode = pcOut->mRootNode->mChildren[a] = new aiNode();
+        for (unsigned int i = 0; i < (unsigned int)mScene->mCameras.size(); ++i, ++a) {
+            aiNode *pcNode = pcOut->mRootNode->mChildren[a] = new aiNode();
             pcNode->mParent = pcOut->mRootNode;
 
             // Build a name for the node
@@ -778,75 +721,68 @@ void Discreet3DSImporter::GenerateNodeGraph(aiScene* pcOut)
         }
 
         // Build dummy nodes for all lights
-        for (unsigned int i = 0; i < (unsigned int )mScene->mLights.size();++i,++a)
-        {
-            aiNode* pcNode = pcOut->mRootNode->mChildren[a] = new aiNode();
+        for (unsigned int i = 0; i < (unsigned int)mScene->mLights.size(); ++i, ++a) {
+            aiNode *pcNode = pcOut->mRootNode->mChildren[a] = new aiNode();
             pcNode->mParent = pcOut->mRootNode;
 
             // Build a name for the node
             pcNode->mName = mScene->mLights[i]->mName;
         }
-    }
-    else
-    {
+    } else {
         // First of all: find out how many scaling, rotation and translation
         // animation tracks we'll have afterwards
         unsigned int numChannel = 0;
-        CountTracks(mRootNode,numChannel);
+        CountTracks(mRootNode, numChannel);
 
-        if (numChannel)
-        {
+        if (numChannel) {
             // Allocate a primary animation channel
             pcOut->mNumAnimations = 1;
-            pcOut->mAnimations    = new aiAnimation*[1];
-            aiAnimation* anim     = pcOut->mAnimations[0] = new aiAnimation();
+            pcOut->mAnimations = new aiAnimation *[1];
+            aiAnimation *anim = pcOut->mAnimations[0] = new aiAnimation();
 
             anim->mName.Set("3DSMasterAnim");
 
             // Allocate enough storage for all node animation channels,
             // but don't set the mNumChannels member - we'll use it to
             // index into the array
-            anim->mChannels = new aiNodeAnim*[numChannel];
+            anim->mChannels = new aiNodeAnim *[numChannel];
         }
 
         aiMatrix4x4 m;
-        AddNodeToGraph(pcOut,  pcOut->mRootNode, mRootNode,m);
+        AddNodeToGraph(pcOut, pcOut->mRootNode, mRootNode, m);
     }
 
     // We used the first and second vertex color set to store some temporary values so we need to cleanup here
-    for (unsigned int a = 0; a < pcOut->mNumMeshes; ++a)
-    {
-        pcOut->mMeshes[a]->mColors[0] = NULL;
-        pcOut->mMeshes[a]->mColors[1] = NULL;
+    for (unsigned int a = 0; a < pcOut->mNumMeshes; ++a) {
+        pcOut->mMeshes[a]->mColors[0] = nullptr;
+        pcOut->mMeshes[a]->mColors[1] = nullptr;
     }
 
     pcOut->mRootNode->mTransformation = aiMatrix4x4(
-        1.f,0.f,0.f,0.f,
-        0.f,0.f,1.f,0.f,
-        0.f,-1.f,0.f,0.f,
-        0.f,0.f,0.f,1.f) * pcOut->mRootNode->mTransformation;
+                                                1.f, 0.f, 0.f, 0.f,
+                                                0.f, 0.f, 1.f, 0.f,
+                                                0.f, -1.f, 0.f, 0.f,
+                                                0.f, 0.f, 0.f, 1.f) *
+                                        pcOut->mRootNode->mTransformation;
 
     // If the root node is unnamed name it "<3DSRoot>"
-    if (::strstr( pcOut->mRootNode->mName.data, "UNNAMED" ) ||
-        (pcOut->mRootNode->mName.data[0] == '$' && pcOut->mRootNode->mName.data[1] == '$') )
-    {
+    if (::strstr(pcOut->mRootNode->mName.data, "UNNAMED") ||
+            (pcOut->mRootNode->mName.data[0] == '$' && pcOut->mRootNode->mName.data[1] == '$')) {
         pcOut->mRootNode->mName.Set("<3DSRoot>");
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Convert all meshes in the scene and generate the final output scene.
-void Discreet3DSImporter::ConvertScene(aiScene* pcOut)
-{
+void Discreet3DSImporter::ConvertScene(aiScene *pcOut) {
     // Allocate enough storage for all output materials
     pcOut->mNumMaterials = (unsigned int)mScene->mMaterials.size();
-    pcOut->mMaterials    = new aiMaterial*[pcOut->mNumMaterials];
+    pcOut->mMaterials = new aiMaterial *[pcOut->mNumMaterials];
 
     //  ... and convert the 3DS materials to aiMaterial's
-    for (unsigned int i = 0; i < pcOut->mNumMaterials;++i)
-    {
-        aiMaterial* pcNew = new aiMaterial();
-        ConvertMaterial(mScene->mMaterials[i],*pcNew);
+    for (unsigned int i = 0; i < pcOut->mNumMaterials; ++i) {
+        aiMaterial *pcNew = new aiMaterial();
+        ConvertMaterial(mScene->mMaterials[i], *pcNew);
         pcOut->mMaterials[i] = pcNew;
     }
 
@@ -855,18 +791,16 @@ void Discreet3DSImporter::ConvertScene(aiScene* pcOut)
 
     // Now copy all light sources to the output scene
     pcOut->mNumLights = (unsigned int)mScene->mLights.size();
-    if (pcOut->mNumLights)
-    {
-        pcOut->mLights = new aiLight*[pcOut->mNumLights];
-        ::memcpy(pcOut->mLights,&mScene->mLights[0],sizeof(void*)*pcOut->mNumLights);
+    if (pcOut->mNumLights) {
+        pcOut->mLights = new aiLight *[pcOut->mNumLights];
+        ::memcpy(pcOut->mLights, &mScene->mLights[0], sizeof(void *) * pcOut->mNumLights);
     }
 
     // Now copy all cameras to the output scene
     pcOut->mNumCameras = (unsigned int)mScene->mCameras.size();
-    if (pcOut->mNumCameras)
-    {
-        pcOut->mCameras = new aiCamera*[pcOut->mNumCameras];
-        ::memcpy(pcOut->mCameras,&mScene->mCameras[0],sizeof(void*)*pcOut->mNumCameras);
+    if (pcOut->mNumCameras) {
+        pcOut->mCameras = new aiCamera *[pcOut->mNumCameras];
+        ::memcpy(pcOut->mCameras, &mScene->mCameras[0], sizeof(void *) * pcOut->mNumCameras);
     }
 }
 
diff --git a/Engine/lib/assimp/code/3DS/3DSExporter.cpp b/Engine/lib/assimp/code/AssetLib/3DS/3DSExporter.cpp
similarity index 65%
rename from Engine/lib/assimp/code/3DS/3DSExporter.cpp
rename to Engine/lib/assimp/code/AssetLib/3DS/3DSExporter.cpp
index 1117a52ef..71588f935 100644
--- a/Engine/lib/assimp/code/3DS/3DSExporter.cpp
+++ b/Engine/lib/assimp/code/AssetLib/3DS/3DSExporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -43,120 +43,118 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_EXPORT
 #ifndef ASSIMP_BUILD_NO_3DS_EXPORTER
 
-#include "3DS/3DSExporter.h"
-#include "3DS/3DSLoader.h"
-#include "3DS/3DSHelper.h"
+#include "AssetLib/3DS/3DSExporter.h"
+#include "AssetLib/3DS/3DSHelper.h"
+#include "AssetLib/3DS/3DSLoader.h"
 #include "PostProcessing/SplitLargeMeshes.h"
 
 #include <assimp/SceneCombiner.h>
 #include <assimp/StringComparison.h>
-#include <assimp/IOSystem.hpp>
 #include <assimp/DefaultLogger.hpp>
 #include <assimp/Exporter.hpp>
+#include <assimp/IOSystem.hpp>
 
 #include <memory>
 
-using namespace Assimp;
-namespace Assimp    {
+namespace Assimp {
+
 using namespace D3DS;
 
 namespace {
 
-    //////////////////////////////////////////////////////////////////////////////////////
-    // Scope utility to write a 3DS file chunk.
-    //
-    // Upon construction, the chunk header is written with the chunk type (flags)
-    // filled out, but the chunk size left empty. Upon destruction, the correct chunk
-    // size based on the then-position of the output stream cursor is filled in.
-    class ChunkWriter {
-        enum {
-              CHUNK_SIZE_NOT_SET = 0xdeadbeef
-            , SIZE_OFFSET        = 2
-        };
-    public:
-
-        ChunkWriter(StreamWriterLE& writer, uint16_t chunk_type)
-            : writer(writer)
-        {
-            chunk_start_pos = writer.GetCurrentPos();
-            writer.PutU2(chunk_type);
-            writer.PutU4(CHUNK_SIZE_NOT_SET);
-        }
-
-        ~ChunkWriter() {
-            std::size_t head_pos = writer.GetCurrentPos();
-
-            ai_assert(head_pos > chunk_start_pos);
-            const std::size_t chunk_size = head_pos - chunk_start_pos;
-
-            writer.SetCurrentPos(chunk_start_pos + SIZE_OFFSET);
-            writer.PutU4(static_cast<uint32_t>(chunk_size));
-            writer.SetCurrentPos(head_pos);
-        }
-
-    private:
-        StreamWriterLE& writer;
-        std::size_t chunk_start_pos;
+//////////////////////////////////////////////////////////////////////////////////////
+// Scope utility to write a 3DS file chunk.
+//
+// Upon construction, the chunk header is written with the chunk type (flags)
+// filled out, but the chunk size left empty. Upon destruction, the correct chunk
+// size based on the then-position of the output stream cursor is filled in.
+class ChunkWriter {
+    enum {
+        CHUNK_SIZE_NOT_SET = 0xdeadbeef,
+        SIZE_OFFSET = 2
     };
 
-
-    // Return an unique name for a given |mesh| attached to |node| that
-    // preserves the mesh's given name if it has one. |index| is the index
-    // of the mesh in |aiScene::mMeshes|.
-    std::string GetMeshName(const aiMesh& mesh, unsigned int index, const aiNode& node) {
-        static const std::string underscore = "_";
-        char postfix[10] = {0};
-        ASSIMP_itoa10(postfix, index);
-
-        std::string result = node.mName.C_Str();
-        if (mesh.mName.length > 0) {
-            result += underscore + mesh.mName.C_Str();
-        }
-        return result + underscore + postfix;
+public:
+    ChunkWriter(StreamWriterLE &writer, uint16_t chunk_type) :
+            writer(writer) {
+        chunk_start_pos = writer.GetCurrentPos();
+        writer.PutU2(chunk_type);
+        writer.PutU4((uint32_t)CHUNK_SIZE_NOT_SET);
     }
 
-    // Return an unique name for a given |mat| with original position |index|
-    // in |aiScene::mMaterials|. The name preserves the original material
-    // name if possible.
-    std::string GetMaterialName(const aiMaterial& mat, unsigned int index) {
-        static const std::string underscore = "_";
-        char postfix[10] = {0};
-        ASSIMP_itoa10(postfix, index);
+    ~ChunkWriter() {
+        std::size_t head_pos = writer.GetCurrentPos();
 
-        aiString mat_name;
-        if (AI_SUCCESS == mat.Get(AI_MATKEY_NAME, mat_name)) {
-            return mat_name.C_Str() + underscore + postfix;
-        }
+        ai_assert(head_pos > chunk_start_pos);
+        const std::size_t chunk_size = head_pos - chunk_start_pos;
 
-        return "Material" + underscore + postfix;
+        writer.SetCurrentPos(chunk_start_pos + SIZE_OFFSET);
+        writer.PutU4(static_cast<uint32_t>(chunk_size));
+        writer.SetCurrentPos(head_pos);
     }
 
-    // Collect world transformations for each node
-    void CollectTrafos(const aiNode* node, std::map<const aiNode*, aiMatrix4x4>& trafos) {
-        const aiMatrix4x4& parent = node->mParent ? trafos[node->mParent] : aiMatrix4x4();
-        trafos[node] = parent * node->mTransformation;
-        for (unsigned int i = 0; i < node->mNumChildren; ++i) {
-            CollectTrafos(node->mChildren[i], trafos);
-        }
+private:
+    StreamWriterLE &writer;
+    std::size_t chunk_start_pos;
+};
+
+// Return an unique name for a given |mesh| attached to |node| that
+// preserves the mesh's given name if it has one. |index| is the index
+// of the mesh in |aiScene::mMeshes|.
+std::string GetMeshName(const aiMesh &mesh, unsigned int index, const aiNode &node) {
+    static const char underscore = '_';
+    char postfix[10] = { 0 };
+    ASSIMP_itoa10(postfix, index);
+
+    std::string result = node.mName.C_Str();
+    if (mesh.mName.length > 0) {
+        result += underscore;
+        result += mesh.mName.C_Str();
+    }
+    return result + underscore + postfix;
+}
+
+// Return an unique name for a given |mat| with original position |index|
+// in |aiScene::mMaterials|. The name preserves the original material
+// name if possible.
+std::string GetMaterialName(const aiMaterial &mat, unsigned int index) {
+    static const std::string underscore = "_";
+    char postfix[10] = { 0 };
+    ASSIMP_itoa10(postfix, index);
+
+    aiString mat_name;
+    if (AI_SUCCESS == mat.Get(AI_MATKEY_NAME, mat_name)) {
+        return mat_name.C_Str() + underscore + postfix;
     }
 
-    // Generate a flat list of the meshes (by index) assigned to each node
-    void CollectMeshes(const aiNode* node, std::multimap<const aiNode*, unsigned int>& meshes) {
-        for (unsigned int i = 0; i < node->mNumMeshes; ++i) {
-            meshes.insert(std::make_pair(node, node->mMeshes[i]));
-        }
-        for (unsigned int i = 0; i < node->mNumChildren; ++i) {
-            CollectMeshes(node->mChildren[i], meshes);
-        }
+    return "Material" + underscore + postfix;
+}
+
+// Collect world transformations for each node
+void CollectTrafos(const aiNode *node, std::map<const aiNode *, aiMatrix4x4> &trafos) {
+    const aiMatrix4x4 &parent = node->mParent ? trafos[node->mParent] : aiMatrix4x4();
+    trafos[node] = parent * node->mTransformation;
+    for (unsigned int i = 0; i < node->mNumChildren; ++i) {
+        CollectTrafos(node->mChildren[i], trafos);
     }
 }
 
+// Generate a flat list of the meshes (by index) assigned to each node
+void CollectMeshes(const aiNode *node, std::multimap<const aiNode *, unsigned int> &meshes) {
+    for (unsigned int i = 0; i < node->mNumMeshes; ++i) {
+        meshes.insert(std::make_pair(node, node->mMeshes[i]));
+    }
+    for (unsigned int i = 0; i < node->mNumChildren; ++i) {
+        CollectMeshes(node->mChildren[i], meshes);
+    }
+}
+} // namespace
+
 // ------------------------------------------------------------------------------------------------
 // Worker function for exporting a scene to 3DS. Prototyped and registered in Exporter.cpp
-void ExportScene3DS(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/)
-{
-    std::shared_ptr<IOStream> outfile (pIOSystem->Open(pFile, "wb"));
-    if(!outfile) {
+void ExportScene3DS(const char *pFile, IOSystem *pIOSystem, const aiScene *pScene, const ExportProperties * /*pProperties*/) {
+    std::shared_ptr<IOStream> outfile(pIOSystem->Open(pFile, "wb"));
+    if (!outfile) {
         throw DeadlyExportError("Could not open output .3ds file: " + std::string(pFile));
     }
 
@@ -167,8 +165,8 @@ void ExportScene3DS(const char* pFile, IOSystem* pIOSystem, const aiScene* pScen
     // SplitLargeMeshes can do this, but it requires the correct limit to be set
     // which is not possible with the current way of specifying preprocess steps
     // in |Exporter::ExportFormatEntry|.
-    aiScene* scenecopy_tmp;
-    SceneCombiner::CopyScene(&scenecopy_tmp,pScene);
+    aiScene *scenecopy_tmp;
+    SceneCombiner::CopyScene(&scenecopy_tmp, pScene);
     std::unique_ptr<aiScene> scenecopy(scenecopy_tmp);
 
     SplitLargeMeshesProcess_Triangle tri_splitter;
@@ -186,28 +184,26 @@ void ExportScene3DS(const char* pFile, IOSystem* pIOSystem, const aiScene* pScen
 } // end of namespace Assimp
 
 // ------------------------------------------------------------------------------------------------
-Discreet3DSExporter:: Discreet3DSExporter(std::shared_ptr<IOStream> &outfile, const aiScene* scene)
-: scene(scene)
-, writer(outfile)
-{
+Discreet3DSExporter::Discreet3DSExporter(std::shared_ptr<IOStream> &outfile, const aiScene *scene) :
+        scene(scene), writer(outfile) {
     CollectTrafos(scene->mRootNode, trafos);
     CollectMeshes(scene->mRootNode, meshes);
 
-    ChunkWriter chunk(writer, Discreet3DS::CHUNK_MAIN);
+    ChunkWriter curRootChunk(writer, Discreet3DS::CHUNK_MAIN);
 
     {
-        ChunkWriter chunk(writer, Discreet3DS::CHUNK_OBJMESH);
+        ChunkWriter curChunk(writer, Discreet3DS::CHUNK_OBJMESH);
         WriteMaterials();
         WriteMeshes();
 
         {
-            ChunkWriter chunk(writer, Discreet3DS::CHUNK_MASTER_SCALE);
+            ChunkWriter curChunk1(writer, Discreet3DS::CHUNK_MASTER_SCALE);
             writer.PutF4(1.0f);
         }
     }
 
     {
-        ChunkWriter chunk(writer, Discreet3DS::CHUNK_KEYFRAMER);
+        ChunkWriter curChunk(writer, Discreet3DS::CHUNK_KEYFRAMER);
         WriteHierarchy(*scene->mRootNode, -1, -1);
     }
 }
@@ -217,15 +213,13 @@ Discreet3DSExporter::~Discreet3DSExporter() {
     // empty
 }
 
-
 // ------------------------------------------------------------------------------------------------
-int Discreet3DSExporter::WriteHierarchy(const aiNode& node, int seq, int sibling_level)
-{
+int Discreet3DSExporter::WriteHierarchy(const aiNode &node, int seq, int sibling_level) {
     // 3DS scene hierarchy is serialized as in http://www.martinreddy.net/gfx/3d/3DS.spec
     {
-        ChunkWriter chunk(writer, Discreet3DS::CHUNK_TRACKINFO);
+        ChunkWriter curRootChunk(writer, Discreet3DS::CHUNK_TRACKINFO);
         {
-            ChunkWriter chunk(writer, Discreet3DS::CHUNK_TRACKOBJNAME);
+            ChunkWriter curChunk(writer, Discreet3DS::CHUNK_TRACKOBJNAME);
 
             // Assimp node names are unique and distinct from all mesh-node
             // names we generate; thus we can use them as-is
@@ -237,7 +231,7 @@ int Discreet3DSExporter::WriteHierarchy(const aiNode& node, int seq, int sibling
 
             int16_t hierarchy_pos = static_cast<int16_t>(seq);
             if (sibling_level != -1) {
-                hierarchy_pos = sibling_level;
+                hierarchy_pos = (uint16_t)sibling_level;
             }
 
             // Write the hierarchy position
@@ -260,9 +254,9 @@ int Discreet3DSExporter::WriteHierarchy(const aiNode& node, int seq, int sibling
         const bool first_child = node.mNumChildren == 0 && i == 0;
 
         const unsigned int mesh_idx = node.mMeshes[i];
-        const aiMesh& mesh = *scene->mMeshes[mesh_idx];
+        const aiMesh &mesh = *scene->mMeshes[mesh_idx];
 
-        ChunkWriter chunk(writer, Discreet3DS::CHUNK_TRACKINFO);
+        ChunkWriter curChunk(writer, Discreet3DS::CHUNK_TRACKINFO);
         {
             ChunkWriter chunk(writer, Discreet3DS::CHUNK_TRACKOBJNAME);
             WriteString(GetMeshName(mesh, mesh_idx, node));
@@ -276,36 +270,41 @@ int Discreet3DSExporter::WriteHierarchy(const aiNode& node, int seq, int sibling
 }
 
 // ------------------------------------------------------------------------------------------------
-void Discreet3DSExporter::WriteMaterials()
-{
+void Discreet3DSExporter::WriteMaterials() {
     for (unsigned int i = 0; i < scene->mNumMaterials; ++i) {
-        ChunkWriter chunk(writer, Discreet3DS::CHUNK_MAT_MATERIAL);
-        const aiMaterial& mat = *scene->mMaterials[i];
+        ChunkWriter curRootChunk(writer, Discreet3DS::CHUNK_MAT_MATERIAL);
+        const aiMaterial &mat = *scene->mMaterials[i];
 
         {
             ChunkWriter chunk(writer, Discreet3DS::CHUNK_MAT_MATNAME);
-            const std::string& name = GetMaterialName(mat, i);
+            const std::string &name = GetMaterialName(mat, i);
             WriteString(name);
         }
 
         aiColor3D color;
         if (mat.Get(AI_MATKEY_COLOR_DIFFUSE, color) == AI_SUCCESS) {
-            ChunkWriter chunk(writer, Discreet3DS::CHUNK_MAT_DIFFUSE);
+            ChunkWriter curChunk(writer, Discreet3DS::CHUNK_MAT_DIFFUSE);
             WriteColor(color);
         }
 
         if (mat.Get(AI_MATKEY_COLOR_SPECULAR, color) == AI_SUCCESS) {
-            ChunkWriter chunk(writer, Discreet3DS::CHUNK_MAT_SPECULAR);
+            ChunkWriter curChunk(writer, Discreet3DS::CHUNK_MAT_SPECULAR);
             WriteColor(color);
         }
 
         if (mat.Get(AI_MATKEY_COLOR_AMBIENT, color) == AI_SUCCESS) {
-            ChunkWriter chunk(writer, Discreet3DS::CHUNK_MAT_AMBIENT);
+            ChunkWriter curChunk(writer, Discreet3DS::CHUNK_MAT_AMBIENT);
             WriteColor(color);
         }
 
+        float f;
+        if (mat.Get(AI_MATKEY_OPACITY, f) == AI_SUCCESS) {
+            ChunkWriter chunk(writer, Discreet3DS::CHUNK_MAT_TRANSPARENCY);
+            WritePercentChunk(1.0f - f);
+        }
+
         if (mat.Get(AI_MATKEY_COLOR_EMISSIVE, color) == AI_SUCCESS) {
-            ChunkWriter chunk(writer, Discreet3DS::CHUNK_MAT_SELF_ILLUM);
+            ChunkWriter curChunk(writer, Discreet3DS::CHUNK_MAT_SELF_ILLUM);
             WriteColor(color);
         }
 
@@ -314,7 +313,7 @@ void Discreet3DSExporter::WriteMaterials()
             ChunkWriter chunk(writer, Discreet3DS::CHUNK_MAT_SHADING);
 
             Discreet3DS::shadetype3ds shading_mode_out;
-            switch(shading_mode) {
+            switch (shading_mode) {
             case aiShadingMode_Flat:
             case aiShadingMode_NoShading:
                 shading_mode_out = Discreet3DS::Flat;
@@ -331,6 +330,7 @@ void Discreet3DSExporter::WriteMaterials()
             case aiShadingMode_Blinn:
             case aiShadingMode_CookTorrance:
             case aiShadingMode_Fresnel:
+            case aiShadingMode_PBR_BRDF: // Possibly should be Discreet3DS::Metal in some cases but this is undocumented
                 shading_mode_out = Discreet3DS::Phong;
                 break;
 
@@ -341,8 +341,6 @@ void Discreet3DSExporter::WriteMaterials()
             writer.PutU2(static_cast<uint16_t>(shading_mode_out));
         }
 
-
-        float f;
         if (mat.Get(AI_MATKEY_SHININESS, f) == AI_SUCCESS) {
             ChunkWriter chunk(writer, Discreet3DS::CHUNK_MAT_SHININESS);
             WritePercentChunk(f);
@@ -359,7 +357,10 @@ void Discreet3DSExporter::WriteMaterials()
             writer.PutI2(1);
         }
 
-        WriteTexture(mat, aiTextureType_DIFFUSE, Discreet3DS::CHUNK_MAT_TEXTURE);
+        // Fallback to BASE_COLOR if no DIFFUSE
+        if (!WriteTexture(mat, aiTextureType_DIFFUSE, Discreet3DS::CHUNK_MAT_TEXTURE))
+            WriteTexture(mat, aiTextureType_BASE_COLOR, Discreet3DS::CHUNK_MAT_TEXTURE);
+
         WriteTexture(mat, aiTextureType_HEIGHT, Discreet3DS::CHUNK_MAT_BUMPMAP);
         WriteTexture(mat, aiTextureType_OPACITY, Discreet3DS::CHUNK_MAT_OPACMAP);
         WriteTexture(mat, aiTextureType_SHININESS, Discreet3DS::CHUNK_MAT_MAT_SHINMAP);
@@ -370,48 +371,47 @@ void Discreet3DSExporter::WriteMaterials()
 }
 
 // ------------------------------------------------------------------------------------------------
-void Discreet3DSExporter::WriteTexture(const aiMaterial& mat, aiTextureType type, uint16_t chunk_flags)
-{
+// returns true if the texture existed
+bool Discreet3DSExporter::WriteTexture(const aiMaterial &mat, aiTextureType type, uint16_t chunk_flags) {
     aiString path;
     aiTextureMapMode map_mode[2] = {
         aiTextureMapMode_Wrap, aiTextureMapMode_Wrap
     };
     ai_real blend = 1.0;
-    if (mat.GetTexture(type, 0, &path, NULL, NULL, &blend, NULL, map_mode) != AI_SUCCESS || !path.length) {
-        return;
+    if (mat.GetTexture(type, 0, &path, nullptr, nullptr, &blend, nullptr, map_mode) != AI_SUCCESS || !path.length) {
+        return false;
     }
 
     // TODO: handle embedded textures properly
     if (path.data[0] == '*') {
-        ASSIMP_LOG_ERROR("Ignoring embedded texture for export: " + std::string(path.C_Str()));
-        return;
+        ASSIMP_LOG_ERROR("Ignoring embedded texture for export: ", path.C_Str());
+        return false;
     }
 
     ChunkWriter chunk(writer, chunk_flags);
     {
-        ChunkWriter chunk(writer, Discreet3DS::CHUNK_MAPFILE);
+        ChunkWriter curChunk(writer, Discreet3DS::CHUNK_MAPFILE);
         WriteString(path);
     }
 
     WritePercentChunk(blend);
 
     {
-        ChunkWriter chunk(writer, Discreet3DS::CHUNK_MAT_MAP_TILING);
+        ChunkWriter curChunk(writer, Discreet3DS::CHUNK_MAT_MAP_TILING);
         uint16_t val = 0; // WRAP
         if (map_mode[0] == aiTextureMapMode_Mirror) {
             val = 0x2;
-        }
-        else if (map_mode[0] == aiTextureMapMode_Decal) {
+        } else if (map_mode[0] == aiTextureMapMode_Decal) {
             val = 0x10;
         }
         writer.PutU2(val);
     }
     // TODO: export texture transformation (i.e. UV offset, scale, rotation)
+    return true;
 }
 
 // ------------------------------------------------------------------------------------------------
-void Discreet3DSExporter::WriteMeshes()
-{
+void Discreet3DSExporter::WriteMeshes() {
     // NOTE: 3DS allows for instances. However:
     //   i)  not all importers support reading them
     //   ii) instances are not as flexible as they are in assimp, in particular,
@@ -423,36 +423,35 @@ void Discreet3DSExporter::WriteMeshes()
     // Furthermore, the TRIMESH is transformed into world space so that it will
     // appear correctly if importers don't read the scene hierarchy at all.
     for (MeshesByNodeMap::const_iterator it = meshes.begin(); it != meshes.end(); ++it) {
-        const aiNode& node = *(*it).first;
+        const aiNode &node = *(*it).first;
         const unsigned int mesh_idx = (*it).second;
 
-        const aiMesh& mesh = *scene->mMeshes[mesh_idx];
+        const aiMesh &mesh = *scene->mMeshes[mesh_idx];
 
         // This should not happen if the SLM step is correctly executed
         // before the scene is handed to the exporter
         ai_assert(mesh.mNumVertices <= 0xffff);
         ai_assert(mesh.mNumFaces <= 0xffff);
 
-        const aiMatrix4x4& trafo = trafos[&node];
+        const aiMatrix4x4 &trafo = trafos[&node];
 
         ChunkWriter chunk(writer, Discreet3DS::CHUNK_OBJBLOCK);
 
         // Mesh name is tied to the node it is attached to so it can later be referenced
-        const std::string& name = GetMeshName(mesh, mesh_idx, node);
+        const std::string &name = GetMeshName(mesh, mesh_idx, node);
         WriteString(name);
 
-
         // TRIMESH chunk
         ChunkWriter chunk2(writer, Discreet3DS::CHUNK_TRIMESH);
 
         // Vertices in world space
         {
-            ChunkWriter chunk(writer, Discreet3DS::CHUNK_VERTLIST);
+            ChunkWriter curChunk(writer, Discreet3DS::CHUNK_VERTLIST);
 
             const uint16_t count = static_cast<uint16_t>(mesh.mNumVertices);
             writer.PutU2(count);
             for (unsigned int i = 0; i < mesh.mNumVertices; ++i) {
-                const aiVector3D& v = trafo * mesh.mVertices[i];
+                const aiVector3D &v = mesh.mVertices[i];
                 writer.PutF4(v.x);
                 writer.PutF4(v.y);
                 writer.PutF4(v.z);
@@ -461,12 +460,12 @@ void Discreet3DSExporter::WriteMeshes()
 
         // UV coordinates
         if (mesh.HasTextureCoords(0)) {
-            ChunkWriter chunk(writer, Discreet3DS::CHUNK_MAPLIST);
+            ChunkWriter curChunk(writer, Discreet3DS::CHUNK_MAPLIST);
             const uint16_t count = static_cast<uint16_t>(mesh.mNumVertices);
             writer.PutU2(count);
 
             for (unsigned int i = 0; i < mesh.mNumVertices; ++i) {
-                const aiVector3D& v = mesh.mTextureCoords[0][i];
+                const aiVector3D &v = mesh.mTextureCoords[0][i];
                 writer.PutF4(v.x);
                 writer.PutF4(v.y);
             }
@@ -474,14 +473,14 @@ void Discreet3DSExporter::WriteMeshes()
 
         // Faces (indices)
         {
-            ChunkWriter chunk(writer, Discreet3DS::CHUNK_FACELIST);
+            ChunkWriter curChunk(writer, Discreet3DS::CHUNK_FACELIST);
 
             ai_assert(mesh.mNumFaces <= 0xffff);
 
             // Count triangles, discard lines and points
             uint16_t count = 0;
             for (unsigned int i = 0; i < mesh.mNumFaces; ++i) {
-                const aiFace& f = mesh.mFaces[i];
+                const aiFace &f = mesh.mFaces[i];
                 if (f.mNumIndices < 3) {
                     continue;
                 }
@@ -492,7 +491,7 @@ void Discreet3DSExporter::WriteMeshes()
 
             writer.PutU2(count);
             for (unsigned int i = 0; i < mesh.mNumFaces; ++i) {
-                const aiFace& f = mesh.mFaces[i];
+                const aiFace &f = mesh.mFaces[i];
                 if (f.mNumIndices < 3) {
                     continue;
                 }
@@ -513,21 +512,25 @@ void Discreet3DSExporter::WriteMeshes()
 
         // Transformation matrix by which the mesh vertices have been pre-transformed with.
         {
-            ChunkWriter chunk(writer, Discreet3DS::CHUNK_TRMATRIX);
-            for (unsigned int r = 0; r < 4; ++r) {
+            ChunkWriter curChunk(writer, Discreet3DS::CHUNK_TRMATRIX);
+            // Store rotation 3x3 matrix row wise
+            for (unsigned int r = 0; r < 3; ++r) {
                 for (unsigned int c = 0; c < 3; ++c) {
                     writer.PutF4(trafo[r][c]);
                 }
             }
+            // Store translation sub vector column wise
+            for (unsigned int r = 0; r < 3; ++r) {
+                writer.PutF4(trafo[r][3]);
+            }
         }
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void Discreet3DSExporter::WriteFaceMaterialChunk(const aiMesh& mesh)
-{
-    ChunkWriter chunk(writer, Discreet3DS::CHUNK_FACEMAT);
-    const std::string& name = GetMaterialName(*scene->mMaterials[mesh.mMaterialIndex], mesh.mMaterialIndex);
+void Discreet3DSExporter::WriteFaceMaterialChunk(const aiMesh &mesh) {
+    ChunkWriter curChunk(writer, Discreet3DS::CHUNK_FACEMAT);
+    const std::string &name = GetMaterialName(*scene->mMaterials[mesh.mMaterialIndex], mesh.mMaterialIndex);
     WriteString(name);
 
     // Because assimp splits meshes by material, only a single
@@ -542,7 +545,7 @@ void Discreet3DSExporter::WriteFaceMaterialChunk(const aiMesh& mesh)
 }
 
 // ------------------------------------------------------------------------------------------------
-void Discreet3DSExporter::WriteString(const std::string& s) {
+void Discreet3DSExporter::WriteString(const std::string &s) {
     for (std::string::const_iterator it = s.begin(); it != s.end(); ++it) {
         writer.PutI1(*it);
     }
@@ -550,7 +553,7 @@ void Discreet3DSExporter::WriteString(const std::string& s) {
 }
 
 // ------------------------------------------------------------------------------------------------
-void Discreet3DSExporter::WriteString(const aiString& s) {
+void Discreet3DSExporter::WriteString(const aiString &s) {
     for (std::size_t i = 0; i < s.length; ++i) {
         writer.PutI1(s.data[i]);
     }
@@ -558,8 +561,8 @@ void Discreet3DSExporter::WriteString(const aiString& s) {
 }
 
 // ------------------------------------------------------------------------------------------------
-void Discreet3DSExporter::WriteColor(const aiColor3D& color) {
-    ChunkWriter chunk(writer, Discreet3DS::CHUNK_RGBF);
+void Discreet3DSExporter::WriteColor(const aiColor3D &color) {
+    ChunkWriter curChunk(writer, Discreet3DS::CHUNK_RGBF);
     writer.PutF4(color.r);
     writer.PutF4(color.g);
     writer.PutF4(color.b);
@@ -567,16 +570,15 @@ void Discreet3DSExporter::WriteColor(const aiColor3D& color) {
 
 // ------------------------------------------------------------------------------------------------
 void Discreet3DSExporter::WritePercentChunk(float f) {
-    ChunkWriter chunk(writer, Discreet3DS::CHUNK_PERCENTF);
+    ChunkWriter curChunk(writer, Discreet3DS::CHUNK_PERCENTF);
     writer.PutF4(f);
 }
 
 // ------------------------------------------------------------------------------------------------
 void Discreet3DSExporter::WritePercentChunk(double f) {
-    ChunkWriter chunk(writer, Discreet3DS::CHUNK_PERCENTD);
+    ChunkWriter ccurChunkhunk(writer, Discreet3DS::CHUNK_PERCENTD);
     writer.PutF8(f);
 }
 
-
 #endif // ASSIMP_BUILD_NO_3DS_EXPORTER
 #endif // ASSIMP_BUILD_NO_EXPORT
diff --git a/Engine/lib/assimp/code/3DS/3DSExporter.h b/Engine/lib/assimp/code/AssetLib/3DS/3DSExporter.h
similarity index 96%
rename from Engine/lib/assimp/code/3DS/3DSExporter.h
rename to Engine/lib/assimp/code/AssetLib/3DS/3DSExporter.h
index 035b562cf..82ec3512f 100644
--- a/Engine/lib/assimp/code/3DS/3DSExporter.h
+++ b/Engine/lib/assimp/code/AssetLib/3DS/3DSExporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -73,7 +73,7 @@ public:
 private:
     void WriteMeshes();
     void WriteMaterials();
-    void WriteTexture(const aiMaterial& mat, aiTextureType type, uint16_t chunk_flags);
+    bool WriteTexture(const aiMaterial& mat, aiTextureType type, uint16_t chunk_flags);
     void WriteFaceMaterialChunk(const aiMesh& mesh);
     int WriteHierarchy(const aiNode& node, int level, int sibling_level);
     void WriteString(const std::string& s);
diff --git a/Engine/lib/assimp/code/AssetLib/3DS/3DSHelper.h b/Engine/lib/assimp/code/AssetLib/3DS/3DSHelper.h
new file mode 100644
index 000000000..dc1098035
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/3DS/3DSHelper.h
@@ -0,0 +1,702 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file Defines helper data structures for the import of 3DS files */
+
+#ifndef AI_3DSFILEHELPER_H_INC
+#define AI_3DSFILEHELPER_H_INC
+
+#include <assimp/SmoothingGroups.h>
+#include <assimp/SpatialSort.h>
+#include <assimp/StringUtils.h>
+#include <assimp/anim.h>
+#include <assimp/camera.h>
+#include <assimp/light.h>
+#include <assimp/material.h>
+#include <assimp/qnan.h>
+#include <cstdio> //sprintf
+
+namespace Assimp {
+namespace D3DS {
+
+#include <assimp/Compiler/pushpack1.h>
+
+// ---------------------------------------------------------------------------
+/** Defines chunks and data structures.
+*/
+namespace Discreet3DS {
+
+    //! data structure for a single chunk in a .3ds file
+    struct Chunk {
+        uint16_t Flag;
+        uint32_t Size;
+    } PACK_STRUCT;
+
+    //! Used for shading field in material3ds structure
+    //! From AutoDesk 3ds SDK
+    typedef enum {
+        // translated to gouraud shading with wireframe active
+        Wire = 0x0,
+
+        // if this material is set, no vertex normals will
+        // be calculated for the model. Face normals + gouraud
+        Flat = 0x1,
+
+        // standard gouraud shading
+        Gouraud = 0x2,
+
+        // phong shading
+        Phong = 0x3,
+
+        // cooktorrance or anistropic phong shading ...
+        // the exact meaning is unknown, if you know it
+        // feel free to tell me ;-)
+        Metal = 0x4,
+
+        // required by the ASE loader
+        Blinn = 0x5
+    } shadetype3ds;
+
+    // Flags for animated keys
+    enum {
+        KEY_USE_TENS = 0x1,
+        KEY_USE_CONT = 0x2,
+        KEY_USE_BIAS = 0x4,
+        KEY_USE_EASE_TO = 0x8,
+        KEY_USE_EASE_FROM = 0x10
+    };
+
+    enum {
+
+        // ********************************************************************
+        // Basic chunks which can be found everywhere in the file
+        CHUNK_VERSION = 0x0002,
+        CHUNK_RGBF = 0x0010, // float4 R; float4 G; float4 B
+        CHUNK_RGBB = 0x0011, // int1 R; int1 G; int B
+
+        // Linear color values (gamma = 2.2?)
+        CHUNK_LINRGBF = 0x0013, // float4 R; float4 G; float4 B
+        CHUNK_LINRGBB = 0x0012, // int1 R; int1 G; int B
+
+        CHUNK_PERCENTW = 0x0030, // int2   percentage
+        CHUNK_PERCENTF = 0x0031, // float4  percentage
+        CHUNK_PERCENTD = 0x0032, // float8  percentage
+        // ********************************************************************
+
+        // Prj master chunk
+        CHUNK_PRJ = 0xC23D,
+
+        // MDLI master chunk
+        CHUNK_MLI = 0x3DAA,
+
+        // Primary main chunk of the .3ds file
+        CHUNK_MAIN = 0x4D4D,
+
+        // Mesh main chunk
+        CHUNK_OBJMESH = 0x3D3D,
+
+        // Specifies the background color of the .3ds file
+        // This is passed through the material system for
+        // viewing purposes.
+        CHUNK_BKGCOLOR = 0x1200,
+
+        // Specifies the ambient base color of the scene.
+        // This is added to all materials in the file
+        CHUNK_AMBCOLOR = 0x2100,
+
+        // Specifies the background image for the whole scene
+        // This value is passed through the material system
+        // to the viewer
+        CHUNK_BIT_MAP = 0x1100,
+        CHUNK_BIT_MAP_EXISTS = 0x1101,
+
+        // ********************************************************************
+        // Viewport related stuff. Ignored
+        CHUNK_DEFAULT_VIEW = 0x3000,
+        CHUNK_VIEW_TOP = 0x3010,
+        CHUNK_VIEW_BOTTOM = 0x3020,
+        CHUNK_VIEW_LEFT = 0x3030,
+        CHUNK_VIEW_RIGHT = 0x3040,
+        CHUNK_VIEW_FRONT = 0x3050,
+        CHUNK_VIEW_BACK = 0x3060,
+        CHUNK_VIEW_USER = 0x3070,
+        CHUNK_VIEW_CAMERA = 0x3080,
+        // ********************************************************************
+
+        // Mesh chunks
+        CHUNK_OBJBLOCK = 0x4000,
+        CHUNK_TRIMESH = 0x4100,
+        CHUNK_VERTLIST = 0x4110,
+        CHUNK_VERTFLAGS = 0x4111,
+        CHUNK_FACELIST = 0x4120,
+        CHUNK_FACEMAT = 0x4130,
+        CHUNK_MAPLIST = 0x4140,
+        CHUNK_SMOOLIST = 0x4150,
+        CHUNK_TRMATRIX = 0x4160,
+        CHUNK_MESHCOLOR = 0x4165,
+        CHUNK_TXTINFO = 0x4170,
+        CHUNK_LIGHT = 0x4600,
+        CHUNK_CAMERA = 0x4700,
+        CHUNK_HIERARCHY = 0x4F00,
+
+        // Specifies the global scaling factor. This is applied
+        // to the root node's transformation matrix
+        CHUNK_MASTER_SCALE = 0x0100,
+
+        // ********************************************************************
+        // Material chunks
+        CHUNK_MAT_MATERIAL = 0xAFFF,
+
+        // asciiz containing the name of the material
+        CHUNK_MAT_MATNAME = 0xA000,
+        CHUNK_MAT_AMBIENT = 0xA010, // followed by color chunk
+        CHUNK_MAT_DIFFUSE = 0xA020, // followed by color chunk
+        CHUNK_MAT_SPECULAR = 0xA030, // followed by color chunk
+
+        // Specifies the shininess of the material
+        // followed by percentage chunk
+        CHUNK_MAT_SHININESS = 0xA040,
+        CHUNK_MAT_SHININESS_PERCENT = 0xA041,
+
+        // Specifies the shading mode to be used
+        // followed by a short
+        CHUNK_MAT_SHADING = 0xA100,
+
+        // NOTE: Emissive color (self illumination) seems not
+        // to be a color but a single value, type is unknown.
+        // Make the parser accept both of them.
+        // followed by percentage chunk (?)
+        CHUNK_MAT_SELF_ILLUM = 0xA080,
+
+        // Always followed by percentage chunk  (?)
+        CHUNK_MAT_SELF_ILPCT = 0xA084,
+
+        // Always followed by percentage chunk
+        CHUNK_MAT_TRANSPARENCY = 0xA050,
+
+        // Diffuse texture channel 0
+        CHUNK_MAT_TEXTURE = 0xA200,
+
+        // Contains opacity information for each texel
+        CHUNK_MAT_OPACMAP = 0xA210,
+
+        // Contains a reflection map to be used to reflect
+        // the environment. This is partially supported.
+        CHUNK_MAT_REFLMAP = 0xA220,
+
+        // Self Illumination map (emissive colors)
+        CHUNK_MAT_SELFIMAP = 0xA33d,
+
+        // Bumpmap. Not specified whether it is a heightmap
+        // or a normal map. Assme it is a heightmap since
+        // artist normally prefer this format.
+        CHUNK_MAT_BUMPMAP = 0xA230,
+
+        // Specular map. Seems to influence the specular color
+        CHUNK_MAT_SPECMAP = 0xA204,
+
+        // Holds shininess data.
+        CHUNK_MAT_MAT_SHINMAP = 0xA33C,
+
+        // Scaling in U/V direction.
+        // (need to gen separate UV coordinate set
+        // and do this by hand)
+        CHUNK_MAT_MAP_USCALE = 0xA354,
+        CHUNK_MAT_MAP_VSCALE = 0xA356,
+
+        // Translation in U/V direction.
+        // (need to gen separate UV coordinate set
+        // and do this by hand)
+        CHUNK_MAT_MAP_UOFFSET = 0xA358,
+        CHUNK_MAT_MAP_VOFFSET = 0xA35a,
+
+        // UV-coordinates rotation around the z-axis
+        // Assumed to be in radians.
+        CHUNK_MAT_MAP_ANG = 0xA35C,
+
+        // Tiling flags for 3DS files
+        CHUNK_MAT_MAP_TILING = 0xa351,
+
+        // Specifies the file name of a texture
+        CHUNK_MAPFILE = 0xA300,
+
+        // Specifies whether a material requires two-sided rendering
+        CHUNK_MAT_TWO_SIDE = 0xA081,
+        // ********************************************************************
+
+        // Main keyframer chunk. Contains translation/rotation/scaling data
+        CHUNK_KEYFRAMER = 0xB000,
+
+        // Supported sub chunks
+        CHUNK_TRACKINFO = 0xB002,
+        CHUNK_TRACKOBJNAME = 0xB010,
+        CHUNK_TRACKDUMMYOBJNAME = 0xB011,
+        CHUNK_TRACKPIVOT = 0xB013,
+        CHUNK_TRACKPOS = 0xB020,
+        CHUNK_TRACKROTATE = 0xB021,
+        CHUNK_TRACKSCALE = 0xB022,
+
+        // ********************************************************************
+        // Keyframes for various other stuff in the file
+        // Partially ignored
+        CHUNK_AMBIENTKEY = 0xB001,
+        CHUNK_TRACKMORPH = 0xB026,
+        CHUNK_TRACKHIDE = 0xB029,
+        CHUNK_OBJNUMBER = 0xB030,
+        CHUNK_TRACKCAMERA = 0xB003,
+        CHUNK_TRACKFOV = 0xB023,
+        CHUNK_TRACKROLL = 0xB024,
+        CHUNK_TRACKCAMTGT = 0xB004,
+        CHUNK_TRACKLIGHT = 0xB005,
+        CHUNK_TRACKLIGTGT = 0xB006,
+        CHUNK_TRACKSPOTL = 0xB007,
+        CHUNK_FRAMES = 0xB008,
+        // ********************************************************************
+
+        // light sub-chunks
+        CHUNK_DL_OFF = 0x4620,
+        CHUNK_DL_OUTER_RANGE = 0x465A,
+        CHUNK_DL_INNER_RANGE = 0x4659,
+        CHUNK_DL_MULTIPLIER = 0x465B,
+        CHUNK_DL_EXCLUDE = 0x4654,
+        CHUNK_DL_ATTENUATE = 0x4625,
+        CHUNK_DL_SPOTLIGHT = 0x4610,
+
+        // camera sub-chunks
+        CHUNK_CAM_RANGES = 0x4720
+    };
+}
+
+// ---------------------------------------------------------------------------
+/** Helper structure representing a 3ds mesh face */
+struct Face : public FaceWithSmoothingGroup {
+};
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4315)
+#endif // _MSC_VER
+
+// ---------------------------------------------------------------------------
+/** Helper structure representing a texture */
+struct Texture {
+    //! Default constructor
+    Texture() AI_NO_EXCEPT
+            : mTextureBlend(0.0f),
+              mMapName(),
+              mOffsetU(0.0),
+              mOffsetV(0.0),
+              mScaleU(1.0),
+              mScaleV(1.0),
+              mRotation(0.0),
+              mMapMode(aiTextureMapMode_Wrap),
+              bPrivate(),
+              iUVSrc(0) {
+        mTextureBlend = get_qnan();
+    }
+
+    Texture(const Texture &other) :
+            mTextureBlend(other.mTextureBlend),
+            mMapName(other.mMapName),
+            mOffsetU(other.mOffsetU),
+            mOffsetV(other.mOffsetV),
+            mScaleU(other.mScaleU),
+            mScaleV(other.mScaleV),
+            mRotation(other.mRotation),
+            mMapMode(other.mMapMode),
+            bPrivate(other.bPrivate),
+            iUVSrc(other.iUVSrc) {
+        // empty
+    }
+
+    Texture(Texture &&other) AI_NO_EXCEPT : mTextureBlend(other.mTextureBlend),
+                                            mMapName(std::move(other.mMapName)),
+                                            mOffsetU(other.mOffsetU),
+                                            mOffsetV(other.mOffsetV),
+                                            mScaleU(other.mScaleU),
+                                            mScaleV(other.mScaleV),
+                                            mRotation(other.mRotation),
+                                            mMapMode(other.mMapMode),
+                                            bPrivate(other.bPrivate),
+                                            iUVSrc(other.iUVSrc) {
+        // empty
+    }
+
+    Texture &operator=(Texture &&other) AI_NO_EXCEPT {
+        if (this == &other) {
+            return *this;
+        }
+
+        mTextureBlend = other.mTextureBlend;
+        mMapName = std::move(other.mMapName);
+        mOffsetU = other.mOffsetU;
+        mOffsetV = other.mOffsetV;
+        mScaleU = other.mScaleU;
+        mScaleV = other.mScaleV;
+        mRotation = other.mRotation;
+        mMapMode = other.mMapMode;
+        bPrivate = other.bPrivate;
+        iUVSrc = other.iUVSrc;
+
+        return *this;
+    }
+
+    //! Specifies the blend factor for the texture
+    ai_real mTextureBlend;
+
+    //! Specifies the filename of the texture
+    std::string mMapName;
+
+    //! Specifies texture coordinate offsets/scaling/rotations
+    ai_real mOffsetU;
+    ai_real mOffsetV;
+    ai_real mScaleU;
+    ai_real mScaleV;
+    ai_real mRotation;
+
+    //! Specifies the mapping mode to be used for the texture
+    aiTextureMapMode mMapMode;
+
+    //! Used internally
+    bool bPrivate;
+    int iUVSrc;
+};
+
+#include <assimp/Compiler/poppack1.h>
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif // _MSC_VER
+
+// ---------------------------------------------------------------------------
+/** Helper structure representing a 3ds material */
+struct Material {
+    //! Default constructor has been deleted
+    Material() :
+            mName(),
+            mDiffuse(ai_real(0.6), ai_real(0.6), ai_real(0.6)),
+            mSpecularExponent(ai_real(0.0)),
+            mShininessStrength(ai_real(1.0)),
+            mShading(Discreet3DS::Gouraud),
+            mTransparency(ai_real(1.0)),
+            mBumpHeight(ai_real(1.0)),
+            mTwoSided(false) {
+        // empty
+    }
+
+    //! Constructor with explicit name
+    explicit Material(const std::string &name) :
+            mName(name),
+            mDiffuse(ai_real(0.6), ai_real(0.6), ai_real(0.6)),
+            mSpecularExponent(ai_real(0.0)),
+            mShininessStrength(ai_real(1.0)),
+            mShading(Discreet3DS::Gouraud),
+            mTransparency(ai_real(1.0)),
+            mBumpHeight(ai_real(1.0)),
+            mTwoSided(false) {
+        // empty
+    }
+
+    Material(const Material &other) :
+            mName(other.mName),
+            mDiffuse(other.mDiffuse),
+            mSpecularExponent(other.mSpecularExponent),
+            mShininessStrength(other.mShininessStrength),
+            mSpecular(other.mSpecular),
+            mAmbient(other.mAmbient),
+            mShading(other.mShading),
+            mTransparency(other.mTransparency),
+            sTexDiffuse(other.sTexDiffuse),
+            sTexOpacity(other.sTexOpacity),
+            sTexSpecular(other.sTexSpecular),
+            sTexReflective(other.sTexReflective),
+            sTexBump(other.sTexBump),
+            sTexEmissive(other.sTexEmissive),
+            sTexShininess(other.sTexShininess),
+            mBumpHeight(other.mBumpHeight),
+            mEmissive(other.mEmissive),
+            sTexAmbient(other.sTexAmbient),
+            mTwoSided(other.mTwoSided) {
+        // empty
+    }
+
+    //! Move constructor. This is explicitly written because MSVC doesn't support defaulting it
+    Material(Material &&other) AI_NO_EXCEPT : mName(std::move(other.mName)),
+                                              mDiffuse(other.mDiffuse),
+                                              mSpecularExponent(other.mSpecularExponent),
+                                              mShininessStrength(other.mShininessStrength),
+                                              mSpecular(other.mSpecular),
+                                              mAmbient(other.mAmbient),
+                                              mShading(other.mShading),
+                                              mTransparency(other.mTransparency),
+                                              sTexDiffuse(std::move(other.sTexDiffuse)),
+                                              sTexOpacity(std::move(other.sTexOpacity)),
+                                              sTexSpecular(std::move(other.sTexSpecular)),
+                                              sTexReflective(std::move(other.sTexReflective)),
+                                              sTexBump(std::move(other.sTexBump)),
+                                              sTexEmissive(std::move(other.sTexEmissive)),
+                                              sTexShininess(std::move(other.sTexShininess)),
+                                              mBumpHeight(other.mBumpHeight),
+                                              mEmissive(other.mEmissive),
+                                              sTexAmbient(std::move(other.sTexAmbient)),
+                                              mTwoSided(other.mTwoSided) {
+        // empty
+    }
+
+    Material &operator=(Material &&other) AI_NO_EXCEPT {
+        if (this == &other) {
+            return *this;
+        }
+
+        mName = std::move(other.mName);
+        mDiffuse = other.mDiffuse;
+        mSpecularExponent = other.mSpecularExponent;
+        mShininessStrength = other.mShininessStrength,
+        mSpecular = other.mSpecular;
+        mAmbient = other.mAmbient;
+        mShading = other.mShading;
+        mTransparency = other.mTransparency;
+        sTexDiffuse = std::move(other.sTexDiffuse);
+        sTexOpacity = std::move(other.sTexOpacity);
+        sTexSpecular = std::move(other.sTexSpecular);
+        sTexReflective = std::move(other.sTexReflective);
+        sTexBump = std::move(other.sTexBump);
+        sTexEmissive = std::move(other.sTexEmissive);
+        sTexShininess = std::move(other.sTexShininess);
+        mBumpHeight = other.mBumpHeight;
+        mEmissive = other.mEmissive;
+        sTexAmbient = std::move(other.sTexAmbient);
+        mTwoSided = other.mTwoSided;
+
+        return *this;
+    }
+
+    virtual ~Material() {
+        // empty
+    }
+
+    //! Name of the material
+    std::string mName;
+    //! Diffuse color of the material
+    aiColor3D mDiffuse;
+    //! Specular exponent
+    ai_real mSpecularExponent;
+    //! Shininess strength, in percent
+    ai_real mShininessStrength;
+    //! Specular color of the material
+    aiColor3D mSpecular;
+    //! Ambient color of the material
+    aiColor3D mAmbient;
+    //! Shading type to be used
+    Discreet3DS::shadetype3ds mShading;
+    //! Opacity of the material
+    ai_real mTransparency;
+    //! Diffuse texture channel
+    Texture sTexDiffuse;
+    //! Opacity texture channel
+    Texture sTexOpacity;
+    //! Specular texture channel
+    Texture sTexSpecular;
+    //! Reflective texture channel
+    Texture sTexReflective;
+    //! Bump texture channel
+    Texture sTexBump;
+    //! Emissive texture channel
+    Texture sTexEmissive;
+    //! Shininess texture channel
+    Texture sTexShininess;
+    //! Scaling factor for the bump values
+    ai_real mBumpHeight;
+    //! Emissive color
+    aiColor3D mEmissive;
+    //! Ambient texture channel
+    //! (used by the ASE format)
+    Texture sTexAmbient;
+    //! True if the material must be rendered from two sides
+    bool mTwoSided;
+};
+
+// ---------------------------------------------------------------------------
+/** Helper structure to represent a 3ds file mesh */
+struct Mesh : public MeshWithSmoothingGroups<D3DS::Face> {
+    //! Default constructor has been deleted
+    Mesh() = delete;
+
+    //! Constructor with explicit name
+    explicit Mesh(const std::string &name) :
+            mName(name) {
+    }
+
+    //! Name of the mesh
+    std::string mName;
+
+    //! Texture coordinates
+    std::vector<aiVector3D> mTexCoords;
+
+    //! Face materials
+    std::vector<unsigned int> mFaceMaterials;
+
+    //! Local transformation matrix
+    aiMatrix4x4 mMat;
+};
+
+// ---------------------------------------------------------------------------
+/** Float key - quite similar to aiVectorKey and aiQuatKey. Both are in the
+    C-API, so it would be difficult to make them a template. */
+struct aiFloatKey {
+    double mTime; ///< The time of this key
+    ai_real mValue; ///< The value of this key
+
+#ifdef __cplusplus
+
+    // time is not compared
+    bool operator==(const aiFloatKey &o) const { return o.mValue == this->mValue; }
+
+    bool operator!=(const aiFloatKey &o) const { return o.mValue != this->mValue; }
+
+    // Only time is compared. This operator is defined
+    // for use with std::sort
+    bool operator<(const aiFloatKey &o) const { return mTime < o.mTime; }
+
+    bool operator>(const aiFloatKey &o) const { return mTime > o.mTime; }
+
+#endif
+};
+
+// ---------------------------------------------------------------------------
+/** Helper structure to represent a 3ds file node */
+struct Node {
+    Node() = delete;
+
+    explicit Node(const std::string &name) :
+            mParent(nullptr),
+            mName(name),
+            mInstanceNumber(0),
+            mHierarchyPos(0),
+            mHierarchyIndex(0),
+            mInstanceCount(1) {
+        aRotationKeys.reserve(20);
+        aPositionKeys.reserve(20);
+        aScalingKeys.reserve(20);
+    }
+
+    ~Node() {
+        for (unsigned int i = 0; i < mChildren.size(); ++i)
+            delete mChildren[i];
+    }
+
+    //! Pointer to the parent node
+    Node *mParent;
+
+    //! Holds all child nodes
+    std::vector<Node *> mChildren;
+
+    //! Name of the node
+    std::string mName;
+
+    //! InstanceNumber of the node
+    int32_t mInstanceNumber;
+
+    //! Dummy nodes: real name to be combined with the $$$DUMMY
+    std::string mDummyName;
+
+    //! Position of the node in the hierarchy (tree depth)
+    int16_t mHierarchyPos;
+
+    //! Index of the node
+    int16_t mHierarchyIndex;
+
+    //! Rotation keys loaded from the file
+    std::vector<aiQuatKey> aRotationKeys;
+
+    //! Position keys loaded from the file
+    std::vector<aiVectorKey> aPositionKeys;
+
+    //! Scaling keys loaded from the file
+    std::vector<aiVectorKey> aScalingKeys;
+
+    // For target lights (spot lights and directional lights):
+    // The position of the target
+    std::vector<aiVectorKey> aTargetPositionKeys;
+
+    // For cameras: the camera roll angle
+    std::vector<aiFloatKey> aCameraRollKeys;
+
+    //! Pivot position loaded from the file
+    aiVector3D vPivot;
+
+    //instance count, will be kept only for the first node
+    int32_t mInstanceCount;
+
+    //! Add a child node, setup the right parent node for it
+    //! \param pc Node to be 'adopted'
+    inline Node &push_back(Node *pc) {
+        mChildren.push_back(pc);
+        pc->mParent = this;
+        return *this;
+    }
+};
+// ---------------------------------------------------------------------------
+/** Helper structure analogue to aiScene */
+struct Scene {
+    //! List of all materials loaded
+    //! NOTE: 3ds references materials globally
+    std::vector<Material> mMaterials;
+
+    //! List of all meshes loaded
+    std::vector<Mesh> mMeshes;
+
+    //! List of all cameras loaded
+    std::vector<aiCamera *> mCameras;
+
+    //! List of all lights loaded
+    std::vector<aiLight *> mLights;
+
+    //! Pointer to the root node of the scene
+    // --- moved to main class
+    // Node* pcRootNode;
+};
+
+} // end of namespace D3DS
+} // end of namespace Assimp
+
+#endif // AI_XFILEHELPER_H_INC
diff --git a/Engine/lib/assimp/code/3DS/3DSLoader.cpp b/Engine/lib/assimp/code/AssetLib/3DS/3DSLoader.cpp
similarity index 67%
rename from Engine/lib/assimp/code/3DS/3DSLoader.cpp
rename to Engine/lib/assimp/code/AssetLib/3DS/3DSLoader.cpp
index 96b80c962..0ec8b872a 100644
--- a/Engine/lib/assimp/code/3DS/3DSLoader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/3DS/3DSLoader.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -47,17 +45,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  http://www.the-labs.com/Blender/3DS-details.html
  */
 
-
 #ifndef ASSIMP_BUILD_NO_3DS_IMPORTER
 
-// internal headers
 #include "3DSLoader.h"
-#include <assimp/Macros.h>
-#include <assimp/IOSystem.hpp>
+#include <assimp/StringComparison.h>
+#include <assimp/importerdesc.h>
 #include <assimp/scene.h>
 #include <assimp/DefaultLogger.hpp>
-#include <assimp/importerdesc.h>
-#include <assimp/StringComparison.h>
+#include <assimp/IOSystem.hpp>
 
 using namespace Assimp;
 
@@ -71,27 +66,25 @@ static const aiImporterDesc desc = {
     0,
     0,
     0,
-	"3ds prj"
+    "3ds prj"
 };
 
-
 // ------------------------------------------------------------------------------------------------
 // Begins a new parsing block
 // - Reads the current chunk and validates it
 // - computes its length
-#define ASSIMP_3DS_BEGIN_CHUNK()                                         \
-    while (true) {                                                       \
-    if (stream->GetRemainingSizeToLimit() < sizeof(Discreet3DS::Chunk)){ \
-        return;                                                          \
-    }                                                                    \
-    Discreet3DS::Chunk chunk;                                            \
-    ReadChunk(&chunk);                                                   \
-    int chunkSize = chunk.Size-sizeof(Discreet3DS::Chunk);               \
-    if(chunkSize <= 0)                                                   \
-        continue;                                                        \
-    const unsigned int oldReadLimit = stream->SetReadLimit(              \
-        stream->GetCurrentPos() + chunkSize);                            \
-
+#define ASSIMP_3DS_BEGIN_CHUNK()                                              \
+    while (true) {                                                            \
+        if (stream->GetRemainingSizeToLimit() < sizeof(Discreet3DS::Chunk)) { \
+            return;                                                           \
+        }                                                                     \
+        Discreet3DS::Chunk chunk;                                             \
+        ReadChunk(&chunk);                                                    \
+        int chunkSize = chunk.Size - sizeof(Discreet3DS::Chunk);              \
+        if (chunkSize <= 0)                                                   \
+            continue;                                                         \
+        const unsigned int oldReadLimit = stream->SetReadLimit(               \
+                stream->GetCurrentPos() + chunkSize);
 
 // ------------------------------------------------------------------------------------------------
 // End a parsing block
@@ -105,15 +98,8 @@ static const aiImporterDesc desc = {
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-Discreet3DSImporter::Discreet3DSImporter()
-: stream()
-, mLastNodeIndex()
-, mCurrentNode()
-, mRootNode()
-, mScene()
-, mMasterScale()
-, bHasBG()
-, bIsPrj() {
+Discreet3DSImporter::Discreet3DSImporter() :
+        stream(), mLastNodeIndex(), mCurrentNode(), mRootNode(), mScene(), mMasterScale(), bHasBG(), bIsPrj() {
     // empty
 }
 
@@ -125,48 +111,40 @@ Discreet3DSImporter::~Discreet3DSImporter() {
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool Discreet3DSImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const {
-    std::string extension = GetExtension(pFile);
-	if(extension == "3ds" || extension == "prj") {
-        return true;
-    }
-
-    if (!extension.length() || checkSig) {
-        uint16_t token[3];
-        token[0] = 0x4d4d;
-        token[1] = 0x3dc2;
-        //token[2] = 0x3daa;
-        return CheckMagicToken(pIOHandler,pFile,token,2,0,2);
-    }
-    return false;
+bool Discreet3DSImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
+    static const uint16_t token[] = { 0x4d4d, 0x3dc2 /*, 0x3daa */ };
+    return CheckMagicToken(pIOHandler, pFile, token, AI_COUNT_OF(token), 0, sizeof token[0]);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Loader registry entry
-const aiImporterDesc* Discreet3DSImporter::GetInfo () const
-{
+const aiImporterDesc *Discreet3DSImporter::GetInfo() const {
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup configuration properties
-void Discreet3DSImporter::SetupProperties(const Importer* /*pImp*/)
-{
+void Discreet3DSImporter::SetupProperties(const Importer * /*pImp*/) {
     // nothing to be done for the moment
 }
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void Discreet3DSImporter::InternReadFile( const std::string& pFile,
-    aiScene* pScene, IOSystem* pIOHandler)
-{
-    StreamReaderLE stream(pIOHandler->Open(pFile,"rb"));
+void Discreet3DSImporter::InternReadFile(const std::string &pFile,
+        aiScene *pScene, IOSystem *pIOHandler) {
+
+    auto theFile = pIOHandler->Open(pFile, "rb");
+    if (!theFile) {
+        throw DeadlyImportError("3DS: Could not open ", pFile);
+    }
+
+    StreamReaderLE theStream(theFile);
 
     // We should have at least one chunk
-    if (stream.GetRemainingSize() < 16) {
-        throw DeadlyImportError("3DS file is either empty or corrupt: " + pFile);
+    if (theStream.GetRemainingSize() < 16) {
+        throw DeadlyImportError("3DS file is either empty or corrupt: ", pFile);
     }
-    this->stream = &stream;
+    this->stream = &theStream;
 
     // Allocate our temporary 3DS representation
     D3DS::Scene _scene;
@@ -174,16 +152,16 @@ void Discreet3DSImporter::InternReadFile( const std::string& pFile,
 
     // Initialize members
     D3DS::Node _rootNode("UNNAMED");
-    mLastNodeIndex             = -1;
-    mCurrentNode               = &_rootNode;
-    mRootNode                  = mCurrentNode;
-    mRootNode->mHierarchyPos   = -1;
+    mLastNodeIndex = -1;
+    mCurrentNode = &_rootNode;
+    mRootNode = mCurrentNode;
+    mRootNode->mHierarchyPos = -1;
     mRootNode->mHierarchyIndex = -1;
-    mRootNode->mParent         = NULL;
-    mMasterScale               = 1.0f;
-    mBackgroundImage           = "";
-    bHasBG                     = false;
-    bIsPrj                     = false;
+    mRootNode->mParent = nullptr;
+    mMasterScale = 1.0f;
+    mBackgroundImage = std::string();
+    bHasBG = false;
+    bIsPrj = false;
 
     // Parse the file
     ParseMainChunk();
@@ -194,15 +172,15 @@ void Discreet3DSImporter::InternReadFile( const std::string& pFile,
     // vectors from the smoothing groups we read from the
     // file.
     for (auto &mesh : mScene->mMeshes) {
-        if (mesh.mFaces.size() > 0 && mesh.mPositions.size() == 0)  {
-            throw DeadlyImportError("3DS file contains faces but no vertices: " + pFile);
+        if (mesh.mFaces.size() > 0 && mesh.mPositions.size() == 0) {
+            throw DeadlyImportError("3DS file contains faces but no vertices: ", pFile);
         }
         CheckIndices(mesh);
-        MakeUnique  (mesh);
+        MakeUnique(mesh);
         ComputeNormalsWithSmoothingsGroups<D3DS::Face>(mesh);
     }
 
-    // Replace all occurences of the default material with a
+    // Replace all occurrences of the default material with a
     // valid material. Generate it if no material containing
     // DEFAULT in its name has been found in the file
     ReplaceDefaultMaterial();
@@ -229,26 +207,26 @@ void Discreet3DSImporter::InternReadFile( const std::string& pFile,
 
 // ------------------------------------------------------------------------------------------------
 // Applies a master-scaling factor to the imported scene
-void Discreet3DSImporter::ApplyMasterScale(aiScene* pScene)
-{
+void Discreet3DSImporter::ApplyMasterScale(aiScene *pScene) {
     // There are some 3DS files with a zero scaling factor
-    if (!mMasterScale)mMasterScale = 1.0f;
-    else mMasterScale = 1.0f / mMasterScale;
+    if (!mMasterScale)
+        mMasterScale = 1.0f;
+    else
+        mMasterScale = 1.0f / mMasterScale;
 
     // Construct an uniform scaling matrix and multiply with it
     pScene->mRootNode->mTransformation *= aiMatrix4x4(
-        mMasterScale,0.0f, 0.0f, 0.0f,
-        0.0f, mMasterScale,0.0f, 0.0f,
-        0.0f, 0.0f, mMasterScale,0.0f,
-        0.0f, 0.0f, 0.0f, 1.0f);
+            mMasterScale, 0.0f, 0.0f, 0.0f,
+            0.0f, mMasterScale, 0.0f, 0.0f,
+            0.0f, 0.0f, mMasterScale, 0.0f,
+            0.0f, 0.0f, 0.0f, 1.0f);
 
     // Check whether a scaling track is assigned to the root node.
 }
 
 // ------------------------------------------------------------------------------------------------
 // Reads a new chunk from the file
-void Discreet3DSImporter::ReadChunk(Discreet3DS::Chunk* pcOut)
-{
+void Discreet3DSImporter::ReadChunk(Discreet3DS::Chunk *pcOut) {
     ai_assert(pcOut != nullptr);
 
     pcOut->Flag = stream->GetI2();
@@ -265,27 +243,25 @@ void Discreet3DSImporter::ReadChunk(Discreet3DS::Chunk* pcOut)
 
 // ------------------------------------------------------------------------------------------------
 // Skip a chunk
-void Discreet3DSImporter::SkipChunk()
-{
+void Discreet3DSImporter::SkipChunk() {
     Discreet3DS::Chunk psChunk;
     ReadChunk(&psChunk);
 
-    stream->IncPtr(psChunk.Size-sizeof(Discreet3DS::Chunk));
+    stream->IncPtr(psChunk.Size - sizeof(Discreet3DS::Chunk));
     return;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Process the primary chunk of the file
-void Discreet3DSImporter::ParseMainChunk()
-{
+void Discreet3DSImporter::ParseMainChunk() {
     ASSIMP_3DS_BEGIN_CHUNK();
 
     // get chunk type
-    switch (chunk.Flag)
-    {
+    switch (chunk.Flag) {
 
     case Discreet3DS::CHUNK_PRJ:
         bIsPrj = true;
+        break;
     case Discreet3DS::CHUNK_MAIN:
         ParseEditorChunk();
         break;
@@ -297,13 +273,11 @@ void Discreet3DSImporter::ParseMainChunk()
 }
 
 // ------------------------------------------------------------------------------------------------
-void Discreet3DSImporter::ParseEditorChunk()
-{
+void Discreet3DSImporter::ParseEditorChunk() {
     ASSIMP_3DS_BEGIN_CHUNK();
 
     // get chunk type
-    switch (chunk.Flag)
-    {
+    switch (chunk.Flag) {
     case Discreet3DS::CHUNK_OBJMESH:
 
         ParseObjectChunk();
@@ -316,41 +290,36 @@ void Discreet3DSImporter::ParseEditorChunk()
         ParseKeyframeChunk();
         break;
 
-    case Discreet3DS::CHUNK_VERSION:
-        {
+    case Discreet3DS::CHUNK_VERSION: {
         // print the version number
         char buff[10];
-        ASSIMP_itoa10(buff,stream->GetI2());
-        ASSIMP_LOG_INFO_F(std::string("3DS file format version: "), buff);
-        }
-        break;
+        ASSIMP_itoa10(buff, stream->GetI2());
+        ASSIMP_LOG_INFO("3DS file format version: ", buff);
+    } break;
     };
     ASSIMP_3DS_END_CHUNK();
 }
 
 // ------------------------------------------------------------------------------------------------
-void Discreet3DSImporter::ParseObjectChunk()
-{
+void Discreet3DSImporter::ParseObjectChunk() {
     ASSIMP_3DS_BEGIN_CHUNK();
 
     // get chunk type
-    switch (chunk.Flag)
-    {
-    case Discreet3DS::CHUNK_OBJBLOCK:
-        {
+    switch (chunk.Flag) {
+    case Discreet3DS::CHUNK_OBJBLOCK: {
         unsigned int cnt = 0;
-        const char* sz = (const char*)stream->GetPtr();
+        const char *sz = (const char *)stream->GetPtr();
 
         // Get the name of the geometry object
-        while (stream->GetI1())++cnt;
-        ParseChunk(sz,cnt);
-        }
-        break;
+        while (stream->GetI1())
+            ++cnt;
+        ParseChunk(sz, cnt);
+    } break;
 
     case Discreet3DS::CHUNK_MAT_MATERIAL:
 
         // Add a new material to the list
-        mScene->mMaterials.push_back(D3DS::Material(std::string("UNNAMED_" + to_string(mScene->mMaterials.size()))));
+        mScene->mMaterials.push_back(D3DS::Material(std::string("UNNAMED_" + ai_to_string(mScene->mMaterials.size()))));
         ParseMaterialChunk();
         break;
 
@@ -358,25 +327,23 @@ void Discreet3DSImporter::ParseObjectChunk()
 
         // This is the ambient base color of the scene.
         // We add it to the ambient color of all materials
-        ParseColorChunk(&mClrAmbient,true);
-        if (is_qnan(mClrAmbient.r))
-        {
+        ParseColorChunk(&mClrAmbient, true);
+        if (is_qnan(mClrAmbient.r)) {
             // We failed to read the ambient base color.
             ASSIMP_LOG_ERROR("3DS: Failed to read ambient base color");
             mClrAmbient.r = mClrAmbient.g = mClrAmbient.b = 0.0f;
         }
         break;
 
-    case Discreet3DS::CHUNK_BIT_MAP:
-        {
+    case Discreet3DS::CHUNK_BIT_MAP: {
         // Specifies the background image. The string should already be
         // properly 0 terminated but we need to be sure
         unsigned int cnt = 0;
-        const char* sz = (const char*)stream->GetPtr();
-        while (stream->GetI1())++cnt;
-        mBackgroundImage = std::string(sz,cnt);
-        }
-        break;
+        const char *sz = (const char *)stream->GetPtr();
+        while (stream->GetI1())
+            ++cnt;
+        mBackgroundImage = std::string(sz, cnt);
+    } break;
 
     case Discreet3DS::CHUNK_BIT_MAP_EXISTS:
         bHasBG = true;
@@ -391,8 +358,7 @@ void Discreet3DSImporter::ParseObjectChunk()
 }
 
 // ------------------------------------------------------------------------------------------------
-void Discreet3DSImporter::ParseChunk(const char* name, unsigned int num)
-{
+void Discreet3DSImporter::ParseChunk(const char *name, unsigned int num) {
     ASSIMP_3DS_BEGIN_CHUNK();
 
     // IMPLEMENTATION NOTE;
@@ -401,22 +367,18 @@ void Discreet3DSImporter::ParseChunk(const char* name, unsigned int num)
     // to to be able to return valid cameras/lights even if no scenegraph is given.
 
     // get chunk type
-    switch (chunk.Flag)
-    {
-    case Discreet3DS::CHUNK_TRIMESH:
-        {
+    switch (chunk.Flag) {
+    case Discreet3DS::CHUNK_TRIMESH: {
         // this starts a new triangle mesh
         mScene->mMeshes.push_back(D3DS::Mesh(std::string(name, num)));
 
         // Read mesh chunks
         ParseMeshChunk();
-        }
-        break;
+    } break;
 
-    case Discreet3DS::CHUNK_LIGHT:
-        {
+    case Discreet3DS::CHUNK_LIGHT: {
         // This starts a new light
-        aiLight* light = new aiLight();
+        aiLight *light = new aiLight();
         mScene->mLights.push_back(light);
 
         light->mName.Set(std::string(name, num));
@@ -426,7 +388,7 @@ void Discreet3DSImporter::ParseChunk(const char* name, unsigned int num)
         light->mPosition.y = stream->GetF4();
         light->mPosition.z = stream->GetF4();
 
-        light->mColorDiffuse = aiColor3D(1.f,1.f,1.f);
+        light->mColorDiffuse = aiColor3D(1.f, 1.f, 1.f);
 
         // Now check for further subchunks
         if (!bIsPrj) /* fixme */
@@ -435,19 +397,17 @@ void Discreet3DSImporter::ParseChunk(const char* name, unsigned int num)
         // The specular light color is identical the the diffuse light color. The ambient light color
         // is equal to the ambient base color of the whole scene.
         light->mColorSpecular = light->mColorDiffuse;
-        light->mColorAmbient  = mClrAmbient;
+        light->mColorAmbient = mClrAmbient;
 
-        if (light->mType == aiLightSource_UNDEFINED)
-        {
+        if (light->mType == aiLightSource_UNDEFINED) {
             // It must be a point light
             light->mType = aiLightSource_POINT;
-        }}
-        break;
+        }
+    } break;
 
-    case Discreet3DS::CHUNK_CAMERA:
-        {
+    case Discreet3DS::CHUNK_CAMERA: {
         // This starts a new camera
-        aiCamera* camera = new aiCamera();
+        aiCamera *camera = new aiCamera();
         mScene->mCameras.push_back(camera);
         camera->mName.Set(std::string(name, num));
 
@@ -465,40 +425,38 @@ void Discreet3DSImporter::ParseChunk(const char* name, unsigned int num)
 
             // There are some files with lookat == position. Don't know why or whether it's ok or not.
             ASSIMP_LOG_ERROR("3DS: Unable to read proper camera look-at vector");
-            camera->mLookAt = aiVector3D(0.0,1.0,0.0);
+            camera->mLookAt = aiVector3D(0.0, 1.0, 0.0);
 
-        }
-        else camera->mLookAt /= len;
+        } else
+            camera->mLookAt /= len;
 
         // And finally - the camera rotation angle, in counter clockwise direction
-        const ai_real angle =  AI_DEG_TO_RAD( stream->GetF4() );
-        aiQuaternion quat(camera->mLookAt,angle);
-        camera->mUp = quat.GetMatrix() * aiVector3D(0.0,1.0,0.0);
+        const ai_real angle = AI_DEG_TO_RAD(stream->GetF4());
+        aiQuaternion quat(camera->mLookAt, angle);
+        camera->mUp = quat.GetMatrix() * aiVector3D(0.0, 1.0, 0.0);
 
         // Read the lense angle
-        camera->mHorizontalFOV = AI_DEG_TO_RAD ( stream->GetF4() );
-        if (camera->mHorizontalFOV < 0.001f)  {
-            camera->mHorizontalFOV = AI_DEG_TO_RAD(45.f);
+        camera->mHorizontalFOV = AI_DEG_TO_RAD(stream->GetF4());
+        if (camera->mHorizontalFOV < 0.001f) {
+            camera->mHorizontalFOV = float(AI_DEG_TO_RAD(45.f));
         }
 
         // Now check for further subchunks
         if (!bIsPrj) /* fixme */ {
             ParseCameraChunk();
-        }}
-        break;
+        }
+    } break;
     };
     ASSIMP_3DS_END_CHUNK();
 }
 
 // ------------------------------------------------------------------------------------------------
-void Discreet3DSImporter::ParseLightChunk()
-{
+void Discreet3DSImporter::ParseLightChunk() {
     ASSIMP_3DS_BEGIN_CHUNK();
-    aiLight* light = mScene->mLights.back();
+    aiLight *light = mScene->mLights.back();
 
     // get chunk type
-    switch (chunk.Flag)
-    {
+    switch (chunk.Flag) {
     case Discreet3DS::CHUNK_DL_SPOTLIGHT:
         // Now we can be sure that the light is a spot light
         light->mType = aiLightSource_SPOT;
@@ -510,10 +468,10 @@ void Discreet3DSImporter::ParseLightChunk()
         light->mDirection.Normalize();
 
         // Now the hotspot and falloff angles - in degrees
-        light->mAngleInnerCone = AI_DEG_TO_RAD( stream->GetF4() );
+        light->mAngleInnerCone = AI_DEG_TO_RAD(stream->GetF4());
 
         // FIX: the falloff angle is just an offset
-        light->mAngleOuterCone = light->mAngleInnerCone+AI_DEG_TO_RAD( stream->GetF4() );
+        light->mAngleOuterCone = light->mAngleInnerCone + AI_DEG_TO_RAD(stream->GetF4());
         break;
 
         // intensity multiplier
@@ -539,18 +497,16 @@ void Discreet3DSImporter::ParseLightChunk()
 }
 
 // ------------------------------------------------------------------------------------------------
-void Discreet3DSImporter::ParseCameraChunk()
-{
+void Discreet3DSImporter::ParseCameraChunk() {
     ASSIMP_3DS_BEGIN_CHUNK();
-    aiCamera* camera = mScene->mCameras.back();
+    aiCamera *camera = mScene->mCameras.back();
 
     // get chunk type
-    switch (chunk.Flag)
-    {
+    switch (chunk.Flag) {
         // near and far clip plane
     case Discreet3DS::CHUNK_CAM_RANGES:
         camera->mClipPlaneNear = stream->GetF4();
-        camera->mClipPlaneFar  = stream->GetF4();
+        camera->mClipPlaneFar = stream->GetF4();
         break;
     }
 
@@ -558,13 +514,11 @@ void Discreet3DSImporter::ParseCameraChunk()
 }
 
 // ------------------------------------------------------------------------------------------------
-void Discreet3DSImporter::ParseKeyframeChunk()
-{
+void Discreet3DSImporter::ParseKeyframeChunk() {
     ASSIMP_3DS_BEGIN_CHUNK();
 
     // get chunk type
-    switch (chunk.Flag)
-    {
+    switch (chunk.Flag) {
     case Discreet3DS::CHUNK_TRACKCAMTGT:
     case Discreet3DS::CHUNK_TRACKSPOTL:
     case Discreet3DS::CHUNK_TRACKCAMERA:
@@ -582,49 +536,49 @@ void Discreet3DSImporter::ParseKeyframeChunk()
 
 // ------------------------------------------------------------------------------------------------
 // Little helper function for ParseHierarchyChunk
-void Discreet3DSImporter::InverseNodeSearch(D3DS::Node* pcNode,D3DS::Node* pcCurrent)
-{
+void Discreet3DSImporter::InverseNodeSearch(D3DS::Node *pcNode, D3DS::Node *pcCurrent) {
     if (!pcCurrent) {
         mRootNode->push_back(pcNode);
         return;
     }
 
-    if (pcCurrent->mHierarchyPos == pcNode->mHierarchyPos)  {
-        if(pcCurrent->mParent) {
+    if (pcCurrent->mHierarchyPos == pcNode->mHierarchyPos) {
+        if (pcCurrent->mParent) {
             pcCurrent->mParent->push_back(pcNode);
-        }
-        else pcCurrent->push_back(pcNode);
+        } else
+            pcCurrent->push_back(pcNode);
         return;
     }
-    return InverseNodeSearch(pcNode,pcCurrent->mParent);
+    return InverseNodeSearch(pcNode, pcCurrent->mParent);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Find a node with a specific name in the import hierarchy
-D3DS::Node* FindNode(D3DS::Node* root, const std::string& name)
-{
-    if (root->mName == name)
+D3DS::Node *FindNode(D3DS::Node *root, const std::string &name) {
+    if (root->mName == name) {
         return root;
-    for (std::vector<D3DS::Node*>::iterator it = root->mChildren.begin();it != root->mChildren.end(); ++it) {
-        D3DS::Node* nd;
-        if (( nd = FindNode(*it,name)))
-            return nd;
     }
-    return NULL;
+
+    for (std::vector<D3DS::Node *>::iterator it = root->mChildren.begin(); it != root->mChildren.end(); ++it) {
+        D3DS::Node *nd = FindNode(*it, name);
+        if (nullptr != nd) {
+            return nd;
+        }
+    }
+
+    return nullptr;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Binary predicate for std::unique()
 template <class T>
-bool KeyUniqueCompare(const T& first, const T& second)
-{
+bool KeyUniqueCompare(const T &first, const T &second) {
     return first.mTime == second.mTime;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Skip some additional import data.
-void Discreet3DSImporter::SkipTCBInfo()
-{
+void Discreet3DSImporter::SkipTCBInfo() {
     unsigned int flags = stream->GetI2();
 
     if (!flags) {
@@ -654,73 +608,68 @@ void Discreet3DSImporter::SkipTCBInfo()
 
 // ------------------------------------------------------------------------------------------------
 // Read hierarchy and keyframe info
-void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent)
-{
+void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent) {
     ASSIMP_3DS_BEGIN_CHUNK();
 
     // get chunk type
-    switch (chunk.Flag)
-    {
+    switch (chunk.Flag) {
     case Discreet3DS::CHUNK_TRACKOBJNAME:
 
         // This is the name of the object to which the track applies. The chunk also
         // defines the position of this object in the hierarchy.
         {
 
-        // First of all: get the name of the object
-        unsigned int cnt = 0;
-        const char* sz = (const char*)stream->GetPtr();
+            // First of all: get the name of the object
+            unsigned int cnt = 0;
+            const char *sz = (const char *)stream->GetPtr();
 
-        while (stream->GetI1())++cnt;
-        std::string name = std::string(sz,cnt);
+            while (stream->GetI1())
+                ++cnt;
+            std::string name = std::string(sz, cnt);
 
-        // Now find out whether we have this node already (target animation channels
-        // are stored with a separate object ID)
-        D3DS::Node* pcNode = FindNode(mRootNode,name);
-        int instanceNumber = 1;
+            // Now find out whether we have this node already (target animation channels
+            // are stored with a separate object ID)
+            D3DS::Node *pcNode = FindNode(mRootNode, name);
+            int instanceNumber = 1;
 
-        if ( pcNode)
-        {
-            // if the source is not a CHUNK_TRACKINFO block it won't be an object instance
-            if (parent != Discreet3DS::CHUNK_TRACKINFO)
-            {
-                mCurrentNode = pcNode;
-                break;
+            if (pcNode) {
+                // if the source is not a CHUNK_TRACKINFO block it won't be an object instance
+                if (parent != Discreet3DS::CHUNK_TRACKINFO) {
+                    mCurrentNode = pcNode;
+                    break;
+                }
+                pcNode->mInstanceCount++;
+                instanceNumber = pcNode->mInstanceCount;
             }
-            pcNode->mInstanceCount++;
-            instanceNumber = pcNode->mInstanceCount;
-        }
-        pcNode = new D3DS::Node(name);
-        pcNode->mInstanceNumber = instanceNumber;
+            pcNode = new D3DS::Node(name);
+            pcNode->mInstanceNumber = instanceNumber;
 
-        // There are two unknown values which we can safely ignore
-        stream->IncPtr(4);
+            // There are two unknown values which we can safely ignore
+            stream->IncPtr(4);
 
-        // Now read the hierarchy position of the object
-        uint16_t hierarchy = stream->GetI2() + 1;
-        pcNode->mHierarchyPos   = hierarchy;
-        pcNode->mHierarchyIndex = mLastNodeIndex;
+            // Now read the hierarchy position of the object
+            uint16_t hierarchy = stream->GetI2() + 1;
+            pcNode->mHierarchyPos = hierarchy;
+            pcNode->mHierarchyIndex = mLastNodeIndex;
 
-        // And find a proper position in the graph for it
-        if (mCurrentNode && mCurrentNode->mHierarchyPos == hierarchy)   {
+            // And find a proper position in the graph for it
+            if (mCurrentNode && mCurrentNode->mHierarchyPos == hierarchy) {
 
-            // add to the parent of the last touched node
-            mCurrentNode->mParent->push_back(pcNode);
-            mLastNodeIndex++;
-        }
-        else if(hierarchy >= mLastNodeIndex)    {
+                // add to the parent of the last touched node
+                mCurrentNode->mParent->push_back(pcNode);
+                mLastNodeIndex++;
+            } else if (hierarchy >= mLastNodeIndex) {
 
-            // place it at the current position in the hierarchy
-            mCurrentNode->push_back(pcNode);
-            mLastNodeIndex = hierarchy;
-        }
-        else    {
-            // need to go back to the specified position in the hierarchy.
-            InverseNodeSearch(pcNode,mCurrentNode);
-            mLastNodeIndex++;
-        }
-        // Make this node the current node
-        mCurrentNode = pcNode;
+                // place it at the current position in the hierarchy
+                mCurrentNode->push_back(pcNode);
+                mLastNodeIndex = hierarchy;
+            } else {
+                // need to go back to the specified position in the hierarchy.
+                InverseNodeSearch(pcNode, mCurrentNode);
+                mLastNodeIndex++;
+            }
+            // Make this node the current node
+            mCurrentNode = pcNode;
         }
         break;
 
@@ -728,11 +677,12 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent)
 
         // This is the "real" name of a $$$DUMMY object
         {
-            const char* sz = (const char*) stream->GetPtr();
-            while (stream->GetI1());
+            const char *sz = (const char *)stream->GetPtr();
+            while (stream->GetI1())
+                ;
 
             // If object name is DUMMY, take this one instead
-            if (mCurrentNode->mName == "$$$DUMMY")  {
+            if (mCurrentNode->mName == "$$$DUMMY") {
                 mCurrentNode->mName = std::string(sz);
                 break;
             }
@@ -741,8 +691,7 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent)
 
     case Discreet3DS::CHUNK_TRACKPIVOT:
 
-        if ( Discreet3DS::CHUNK_TRACKINFO != parent)
-        {
+        if (Discreet3DS::CHUNK_TRACKINFO != parent) {
             ASSIMP_LOG_WARN("3DS: Skipping pivot subchunk for non usual object");
             break;
         }
@@ -753,25 +702,23 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent)
         mCurrentNode->vPivot.z = stream->GetF4();
         break;
 
-
         // ////////////////////////////////////////////////////////////////////
         // POSITION KEYFRAME
-    case Discreet3DS::CHUNK_TRACKPOS:
-        {
+    case Discreet3DS::CHUNK_TRACKPOS: {
         stream->IncPtr(10);
         const unsigned int numFrames = stream->GetI4();
         bool sortKeys = false;
 
         // This could also be meant as the target position for
         // (targeted) lights and cameras
-        std::vector<aiVectorKey>* l;
-        if ( Discreet3DS::CHUNK_TRACKCAMTGT == parent || Discreet3DS::CHUNK_TRACKLIGTGT == parent)  {
-            l = & mCurrentNode->aTargetPositionKeys;
-        }
-        else l = & mCurrentNode->aPositionKeys;
+        std::vector<aiVectorKey> *l;
+        if (Discreet3DS::CHUNK_TRACKCAMTGT == parent || Discreet3DS::CHUNK_TRACKLIGTGT == parent) {
+            l = &mCurrentNode->aTargetPositionKeys;
+        } else
+            l = &mCurrentNode->aPositionKeys;
 
         l->reserve(numFrames);
-        for (unsigned int i = 0; i < numFrames;++i) {
+        for (unsigned int i = 0; i < numFrames; ++i) {
             const unsigned int fidx = stream->GetI4();
 
             // Setup a new position key
@@ -792,29 +739,29 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent)
         }
 
         // Sort all keys with ascending time values and remove duplicates?
-        if (sortKeys)   {
-            std::stable_sort(l->begin(),l->end());
-            l->erase ( std::unique (l->begin(),l->end(),&KeyUniqueCompare<aiVectorKey>), l->end() );
-        }}
+        if (sortKeys) {
+            std::stable_sort(l->begin(), l->end());
+            l->erase(std::unique(l->begin(), l->end(), &KeyUniqueCompare<aiVectorKey>), l->end());
+        }
+    }
 
-        break;
+    break;
 
         // ////////////////////////////////////////////////////////////////////
         // CAMERA ROLL KEYFRAME
-    case Discreet3DS::CHUNK_TRACKROLL:
-        {
+    case Discreet3DS::CHUNK_TRACKROLL: {
         // roll keys are accepted for cameras only
-        if (parent != Discreet3DS::CHUNK_TRACKCAMERA)   {
+        if (parent != Discreet3DS::CHUNK_TRACKCAMERA) {
             ASSIMP_LOG_WARN("3DS: Ignoring roll track for non-camera object");
             break;
         }
         bool sortKeys = false;
-        std::vector<aiFloatKey>* l = &mCurrentNode->aCameraRollKeys;
+        std::vector<aiFloatKey> *l = &mCurrentNode->aCameraRollKeys;
 
         stream->IncPtr(10);
         const unsigned int numFrames = stream->GetI4();
         l->reserve(numFrames);
-        for (unsigned int i = 0; i < numFrames;++i) {
+        for (unsigned int i = 0; i < numFrames; ++i) {
             const unsigned int fidx = stream->GetI4();
 
             // Setup a new position key
@@ -834,35 +781,30 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent)
         }
 
         // Sort all keys with ascending time values and remove duplicates?
-        if (sortKeys)   {
-            std::stable_sort(l->begin(),l->end());
-            l->erase ( std::unique (l->begin(),l->end(),&KeyUniqueCompare<aiFloatKey>), l->end() );
-        }}
-        break;
-
+        if (sortKeys) {
+            std::stable_sort(l->begin(), l->end());
+            l->erase(std::unique(l->begin(), l->end(), &KeyUniqueCompare<aiFloatKey>), l->end());
+        }
+    } break;
 
         // ////////////////////////////////////////////////////////////////////
         // CAMERA FOV KEYFRAME
-    case Discreet3DS::CHUNK_TRACKFOV:
-        {
-            ASSIMP_LOG_ERROR("3DS: Skipping FOV animation track. "
-                "This is not supported");
-        }
-        break;
-
+    case Discreet3DS::CHUNK_TRACKFOV: {
+        ASSIMP_LOG_ERROR("3DS: Skipping FOV animation track. "
+                         "This is not supported");
+    } break;
 
         // ////////////////////////////////////////////////////////////////////
         // ROTATION KEYFRAME
-    case Discreet3DS::CHUNK_TRACKROTATE:
-        {
+    case Discreet3DS::CHUNK_TRACKROTATE: {
         stream->IncPtr(10);
         const unsigned int numFrames = stream->GetI4();
 
         bool sortKeys = false;
-        std::vector<aiQuatKey>* l = &mCurrentNode->aRotationKeys;
+        std::vector<aiQuatKey> *l = &mCurrentNode->aRotationKeys;
         l->reserve(numFrames);
 
-        for (unsigned int i = 0; i < numFrames;++i) {
+        for (unsigned int i = 0; i < numFrames; ++i) {
             const unsigned int fidx = stream->GetI4();
             SkipTCBInfo();
 
@@ -880,7 +822,7 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent)
                 axis.y = 1.f;
 
             // Construct a rotation quaternion from the axis-angle pair
-            v.mValue = aiQuaternion(axis,rad);
+            v.mValue = aiQuaternion(axis, rad);
 
             // Check whether we'll need to sort the keys
             if (!l->empty() && v.mTime <= l->back().mTime)
@@ -890,25 +832,24 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent)
             l->push_back(v);
         }
         // Sort all keys with ascending time values and remove duplicates?
-        if (sortKeys)   {
-            std::stable_sort(l->begin(),l->end());
-            l->erase ( std::unique (l->begin(),l->end(),&KeyUniqueCompare<aiQuatKey>), l->end() );
-        }}
-        break;
+        if (sortKeys) {
+            std::stable_sort(l->begin(), l->end());
+            l->erase(std::unique(l->begin(), l->end(), &KeyUniqueCompare<aiQuatKey>), l->end());
+        }
+    } break;
 
         // ////////////////////////////////////////////////////////////////////
         // SCALING KEYFRAME
-    case Discreet3DS::CHUNK_TRACKSCALE:
-        {
+    case Discreet3DS::CHUNK_TRACKSCALE: {
         stream->IncPtr(10);
         const unsigned int numFrames = stream->GetI2();
         stream->IncPtr(2);
 
         bool sortKeys = false;
-        std::vector<aiVectorKey>* l = &mCurrentNode->aScalingKeys;
+        std::vector<aiVectorKey> *l = &mCurrentNode->aScalingKeys;
         l->reserve(numFrames);
 
-        for (unsigned int i = 0; i < numFrames;++i) {
+        for (unsigned int i = 0; i < numFrames; ++i) {
             const unsigned int fidx = stream->GetI4();
             SkipTCBInfo();
 
@@ -933,11 +874,11 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent)
             l->push_back(v);
         }
         // Sort all keys with ascending time values and remove duplicates?
-        if (sortKeys)   {
-            std::stable_sort(l->begin(),l->end());
-            l->erase ( std::unique (l->begin(),l->end(),&KeyUniqueCompare<aiVectorKey>), l->end() );
-        }}
-        break;
+        if (sortKeys) {
+            std::stable_sort(l->begin(), l->end());
+            l->erase(std::unique(l->begin(), l->end(), &KeyUniqueCompare<aiVectorKey>), l->end());
+        }
+    } break;
     };
 
     ASSIMP_3DS_END_CHUNK();
@@ -945,92 +886,85 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent)
 
 // ------------------------------------------------------------------------------------------------
 // Read a face chunk - it contains smoothing groups and material assignments
-void Discreet3DSImporter::ParseFaceChunk()
-{
+void Discreet3DSImporter::ParseFaceChunk() {
     ASSIMP_3DS_BEGIN_CHUNK();
 
     // Get the mesh we're currently working on
-    D3DS::Mesh& mMesh = mScene->mMeshes.back();
+    D3DS::Mesh &mMesh = mScene->mMeshes.back();
 
     // Get chunk type
-    switch (chunk.Flag)
-    {
-    case Discreet3DS::CHUNK_SMOOLIST:
-        {
+    switch (chunk.Flag) {
+    case Discreet3DS::CHUNK_SMOOLIST: {
         // This is the list of smoothing groups - a bitfield for every face.
         // Up to 32 smoothing groups assigned to a single face.
-        unsigned int num = chunkSize/4, m = 0;
-        if (num > mMesh.mFaces.size())  {
+        unsigned int num = chunkSize / 4, m = 0;
+        if (num > mMesh.mFaces.size()) {
             throw DeadlyImportError("3DS: More smoothing groups than faces");
         }
-        for (std::vector<D3DS::Face>::iterator i =  mMesh.mFaces.begin(); m != num;++i, ++m)    {
+        for (std::vector<D3DS::Face>::iterator i = mMesh.mFaces.begin(); m != num; ++i, ++m) {
             // nth bit is set for nth smoothing group
             (*i).iSmoothGroup = stream->GetI4();
-        }}
-        break;
+        }
+    } break;
 
-    case Discreet3DS::CHUNK_FACEMAT:
-        {
+    case Discreet3DS::CHUNK_FACEMAT: {
         // at fist an asciiz with the material name
-        const char* sz = (const char*)stream->GetPtr();
-        while (stream->GetI1());
+        const char *sz = (const char *)stream->GetPtr();
+        while (stream->GetI1())
+            ;
 
         // find the index of the material
         unsigned int idx = 0xcdcdcdcd, cnt = 0;
-        for (std::vector<D3DS::Material>::const_iterator i =  mScene->mMaterials.begin();i != mScene->mMaterials.end();++i,++cnt)   {
+        for (std::vector<D3DS::Material>::const_iterator i = mScene->mMaterials.begin(); i != mScene->mMaterials.end(); ++i, ++cnt) {
             // use case independent comparisons. hopefully it will work.
             if ((*i).mName.length() && !ASSIMP_stricmp(sz, (*i).mName.c_str())) {
                 idx = cnt;
                 break;
             }
         }
-        if (0xcdcdcdcd == idx)  {
-            ASSIMP_LOG_ERROR_F( "3DS: Unknown material: ", sz);
+        if (0xcdcdcdcd == idx) {
+            ASSIMP_LOG_ERROR("3DS: Unknown material: ", sz);
         }
 
         // Now continue and read all material indices
         cnt = (uint16_t)stream->GetI2();
-        for (unsigned int i = 0; i < cnt;++i)   {
+        for (unsigned int i = 0; i < cnt; ++i) {
             unsigned int fidx = (uint16_t)stream->GetI2();
 
             // check range
-            if (fidx >= mMesh.mFaceMaterials.size())    {
+            if (fidx >= mMesh.mFaceMaterials.size()) {
                 ASSIMP_LOG_ERROR("3DS: Invalid face index in face material list");
-            }
-            else mMesh.mFaceMaterials[fidx] = idx;
-        }}
-        break;
+            } else
+                mMesh.mFaceMaterials[fidx] = idx;
+        }
+    } break;
     };
     ASSIMP_3DS_END_CHUNK();
 }
 
 // ------------------------------------------------------------------------------------------------
 // Read a mesh chunk. Here's the actual mesh data
-void Discreet3DSImporter::ParseMeshChunk()
-{
+void Discreet3DSImporter::ParseMeshChunk() {
     ASSIMP_3DS_BEGIN_CHUNK();
 
     // Get the mesh we're currently working on
-    D3DS::Mesh& mMesh = mScene->mMeshes.back();
+    D3DS::Mesh &mMesh = mScene->mMeshes.back();
 
     // get chunk type
-    switch (chunk.Flag)
-    {
-    case Discreet3DS::CHUNK_VERTLIST:
-        {
+    switch (chunk.Flag) {
+    case Discreet3DS::CHUNK_VERTLIST: {
         // This is the list of all vertices in the current mesh
         int num = (int)(uint16_t)stream->GetI2();
         mMesh.mPositions.reserve(num);
-        while (num-- > 0)   {
+        while (num-- > 0) {
             aiVector3D v;
             v.x = stream->GetF4();
             v.y = stream->GetF4();
             v.z = stream->GetF4();
             mMesh.mPositions.push_back(v);
-        }}
-        break;
-    case Discreet3DS::CHUNK_TRMATRIX:
-        {
+        }
+    } break;
+    case Discreet3DS::CHUNK_TRMATRIX: {
         // This is the RLEATIVE transformation matrix of the current mesh. Vertices are
         // pretransformed by this matrix wonder.
         mMesh.mMat.a1 = stream->GetF4();
@@ -1045,31 +979,28 @@ void Discreet3DSImporter::ParseMeshChunk()
         mMesh.mMat.a4 = stream->GetF4();
         mMesh.mMat.b4 = stream->GetF4();
         mMesh.mMat.c4 = stream->GetF4();
-        }
-        break;
+    } break;
 
-    case Discreet3DS::CHUNK_MAPLIST:
-        {
+    case Discreet3DS::CHUNK_MAPLIST: {
         // This is the list of all UV coords in the current mesh
         int num = (int)(uint16_t)stream->GetI2();
         mMesh.mTexCoords.reserve(num);
-        while (num-- > 0)   {
+        while (num-- > 0) {
             aiVector3D v;
             v.x = stream->GetF4();
             v.y = stream->GetF4();
             mMesh.mTexCoords.push_back(v);
-        }}
-        break;
+        }
+    } break;
 
-    case Discreet3DS::CHUNK_FACELIST:
-        {
+    case Discreet3DS::CHUNK_FACELIST: {
         // This is the list of all faces in the current mesh
         int num = (int)(uint16_t)stream->GetI2();
         mMesh.mFaces.reserve(num);
-        while (num-- > 0)   {
+        while (num-- > 0) {
             // 3DS faces are ALWAYS triangles
             mMesh.mFaces.push_back(D3DS::Face());
-            D3DS::Face& sFace = mMesh.mFaces.back();
+            D3DS::Face &sFace = mMesh.mFaces.back();
 
             sFace.mIndices[0] = (uint16_t)stream->GetI2();
             sFace.mIndices[1] = (uint16_t)stream->GetI2();
@@ -1080,103 +1011,93 @@ void Discreet3DSImporter::ParseMeshChunk()
 
         // Resize the material array (0xcdcdcdcd marks the default material; so if a face is
         // not referenced by a material, $$DEFAULT will be assigned to it)
-        mMesh.mFaceMaterials.resize(mMesh.mFaces.size(),0xcdcdcdcd);
+        mMesh.mFaceMaterials.resize(mMesh.mFaces.size(), 0xcdcdcdcd);
 
         // Larger 3DS files could have multiple FACE chunks here
-        chunkSize = stream->GetRemainingSizeToLimit();
-        if ( chunkSize > (int) sizeof(Discreet3DS::Chunk ) )
+        chunkSize = (int)stream->GetRemainingSizeToLimit();
+        if (chunkSize > (int)sizeof(Discreet3DS::Chunk))
             ParseFaceChunk();
-        }
-        break;
+    } break;
     };
     ASSIMP_3DS_END_CHUNK();
 }
 
 // ------------------------------------------------------------------------------------------------
 // Read a 3DS material chunk
-void Discreet3DSImporter::ParseMaterialChunk()
-{
+void Discreet3DSImporter::ParseMaterialChunk() {
     ASSIMP_3DS_BEGIN_CHUNK();
-    switch (chunk.Flag)
-    {
+    switch (chunk.Flag) {
     case Discreet3DS::CHUNK_MAT_MATNAME:
 
-        {
+    {
         // The material name string is already zero-terminated, but we need to be sure ...
-        const char* sz = (const char*)stream->GetPtr();
+        const char *sz = (const char *)stream->GetPtr();
         unsigned int cnt = 0;
         while (stream->GetI1())
             ++cnt;
 
-        if (!cnt)   {
+        if (!cnt) {
             // This may not be, we use the default name instead
             ASSIMP_LOG_ERROR("3DS: Empty material name");
-        }
-        else mScene->mMaterials.back().mName = std::string(sz,cnt);
-        }
-        break;
+        } else
+            mScene->mMaterials.back().mName = std::string(sz, cnt);
+    } break;
 
-    case Discreet3DS::CHUNK_MAT_DIFFUSE:
-        {
+    case Discreet3DS::CHUNK_MAT_DIFFUSE: {
         // This is the diffuse material color
-        aiColor3D* pc = &mScene->mMaterials.back().mDiffuse;
+        aiColor3D *pc = &mScene->mMaterials.back().mDiffuse;
         ParseColorChunk(pc);
         if (is_qnan(pc->r)) {
             // color chunk is invalid. Simply ignore it
             ASSIMP_LOG_ERROR("3DS: Unable to read DIFFUSE chunk");
             pc->r = pc->g = pc->b = 1.0f;
-        }}
-        break;
+        }
+    } break;
 
-    case Discreet3DS::CHUNK_MAT_SPECULAR:
-        {
+    case Discreet3DS::CHUNK_MAT_SPECULAR: {
         // This is the specular material color
-        aiColor3D* pc = &mScene->mMaterials.back().mSpecular;
+        aiColor3D *pc = &mScene->mMaterials.back().mSpecular;
         ParseColorChunk(pc);
         if (is_qnan(pc->r)) {
             // color chunk is invalid. Simply ignore it
             ASSIMP_LOG_ERROR("3DS: Unable to read SPECULAR chunk");
             pc->r = pc->g = pc->b = 1.0f;
-        }}
-        break;
+        }
+    } break;
 
-    case Discreet3DS::CHUNK_MAT_AMBIENT:
-        {
+    case Discreet3DS::CHUNK_MAT_AMBIENT: {
         // This is the ambient material color
-        aiColor3D* pc = &mScene->mMaterials.back().mAmbient;
+        aiColor3D *pc = &mScene->mMaterials.back().mAmbient;
         ParseColorChunk(pc);
         if (is_qnan(pc->r)) {
             // color chunk is invalid. Simply ignore it
             ASSIMP_LOG_ERROR("3DS: Unable to read AMBIENT chunk");
             pc->r = pc->g = pc->b = 0.0f;
-        }}
-        break;
+        }
+    } break;
 
-    case Discreet3DS::CHUNK_MAT_SELF_ILLUM:
-        {
+    case Discreet3DS::CHUNK_MAT_SELF_ILLUM: {
         // This is the emissive material color
-        aiColor3D* pc = &mScene->mMaterials.back().mEmissive;
+        aiColor3D *pc = &mScene->mMaterials.back().mEmissive;
         ParseColorChunk(pc);
         if (is_qnan(pc->r)) {
             // color chunk is invalid. Simply ignore it
             ASSIMP_LOG_ERROR("3DS: Unable to read EMISSIVE chunk");
             pc->r = pc->g = pc->b = 0.0f;
-        }}
-        break;
-
-    case Discreet3DS::CHUNK_MAT_TRANSPARENCY:
-        {
-            // This is the material's transparency
-            ai_real* pcf = &mScene->mMaterials.back().mTransparency;
-            *pcf = ParsePercentageChunk();
-
-            // NOTE: transparency, not opacity
-            if (is_qnan(*pcf))
-                *pcf = ai_real( 1.0 );
-            else 
-                *pcf = ai_real( 1.0 ) - *pcf * (ai_real)0xFFFF / ai_real( 100.0 );
         }
-        break;
+    } break;
+
+    case Discreet3DS::CHUNK_MAT_TRANSPARENCY: {
+        // This is the material's transparency
+        ai_real *pcf = &mScene->mMaterials.back().mTransparency;
+        *pcf = ParsePercentageChunk();
+
+        // NOTE: transparency, not opacity
+        if (is_qnan(*pcf))
+            *pcf = ai_real(1.0);
+        else
+            *pcf = ai_real(1.0) - *pcf * (ai_real)0xFFFF / ai_real(100.0);
+    } break;
 
     case Discreet3DS::CHUNK_MAT_SHADING:
         // This is the material shading mode
@@ -1188,37 +1109,32 @@ void Discreet3DSImporter::ParseMaterialChunk()
         mScene->mMaterials.back().mTwoSided = true;
         break;
 
-    case Discreet3DS::CHUNK_MAT_SHININESS:
-        { // This is the shininess of the material
-        ai_real* pcf = &mScene->mMaterials.back().mSpecularExponent;
+    case Discreet3DS::CHUNK_MAT_SHININESS: { // This is the shininess of the material
+        ai_real *pcf = &mScene->mMaterials.back().mSpecularExponent;
         *pcf = ParsePercentageChunk();
         if (is_qnan(*pcf))
             *pcf = 0.0;
-        else *pcf *= (ai_real)0xFFFF;
-        }
-        break;
+        else
+            *pcf *= (ai_real)0xFFFF;
+    } break;
 
-    case Discreet3DS::CHUNK_MAT_SHININESS_PERCENT:
-        { // This is the shininess strength of the material
-            ai_real* pcf = &mScene->mMaterials.back().mShininessStrength;
-            *pcf = ParsePercentageChunk();
-            if (is_qnan(*pcf))
-                *pcf = ai_real( 0.0 );
-            else 
-                *pcf *= (ai_real)0xffff / ai_real( 100.0 );
-        }
-        break;
+    case Discreet3DS::CHUNK_MAT_SHININESS_PERCENT: { // This is the shininess strength of the material
+        ai_real *pcf = &mScene->mMaterials.back().mShininessStrength;
+        *pcf = ParsePercentageChunk();
+        if (is_qnan(*pcf))
+            *pcf = ai_real(0.0);
+        else
+            *pcf *= (ai_real)0xffff / ai_real(100.0);
+    } break;
 
-    case Discreet3DS::CHUNK_MAT_SELF_ILPCT:
-        { // This is the self illumination strength of the material
-            ai_real f = ParsePercentageChunk();
-            if (is_qnan(f))
-                f = ai_real( 0.0 );
-            else 
-                f *= (ai_real)0xFFFF / ai_real( 100.0 );
-            mScene->mMaterials.back().mEmissive = aiColor3D(f,f,f);
-        }
-        break;
+    case Discreet3DS::CHUNK_MAT_SELF_ILPCT: { // This is the self illumination strength of the material
+        ai_real f = ParsePercentageChunk();
+        if (is_qnan(f))
+            f = ai_real(0.0);
+        else
+            f *= (ai_real)0xFFFF / ai_real(100.0);
+        mScene->mMaterials.back().mEmissive = aiColor3D(f, f, f);
+    } break;
 
     // Parse texture chunks
     case Discreet3DS::CHUNK_MAT_TEXTURE:
@@ -1254,28 +1170,23 @@ void Discreet3DSImporter::ParseMaterialChunk()
 }
 
 // ------------------------------------------------------------------------------------------------
-void Discreet3DSImporter::ParseTextureChunk(D3DS::Texture* pcOut)
-{
+void Discreet3DSImporter::ParseTextureChunk(D3DS::Texture *pcOut) {
     ASSIMP_3DS_BEGIN_CHUNK();
 
     // get chunk type
-    switch (chunk.Flag)
-    {
-    case Discreet3DS::CHUNK_MAPFILE:
-        {
+    switch (chunk.Flag) {
+    case Discreet3DS::CHUNK_MAPFILE: {
         // The material name string is already zero-terminated, but we need to be sure ...
-        const char* sz = (const char*)stream->GetPtr();
+        const char *sz = (const char *)stream->GetPtr();
         unsigned int cnt = 0;
         while (stream->GetI1())
             ++cnt;
-        pcOut->mMapName = std::string(sz,cnt);
-        }
-        break;
-
+        pcOut->mMapName = std::string(sz, cnt);
+    } break;
 
     case Discreet3DS::CHUNK_PERCENTD:
         // Manually parse the blend factor
-        pcOut->mTextureBlend = ai_real( stream->GetF8() );
+        pcOut->mTextureBlend = ai_real(stream->GetF8());
         break;
 
     case Discreet3DS::CHUNK_PERCENTF:
@@ -1285,14 +1196,13 @@ void Discreet3DSImporter::ParseTextureChunk(D3DS::Texture* pcOut)
 
     case Discreet3DS::CHUNK_PERCENTW:
         // Manually parse the blend factor
-        pcOut->mTextureBlend = (ai_real)((uint16_t)stream->GetI2()) / ai_real( 100.0 );
+        pcOut->mTextureBlend = (ai_real)((uint16_t)stream->GetI2()) / ai_real(100.0);
         break;
 
     case Discreet3DS::CHUNK_MAT_MAP_USCALE:
         // Texture coordinate scaling in the U direction
         pcOut->mScaleU = stream->GetF4();
-        if (0.0f == pcOut->mScaleU)
-        {
+        if (0.0f == pcOut->mScaleU) {
             ASSIMP_LOG_WARN("Texture coordinate scaling in the x direction is zero. Assuming 1.");
             pcOut->mScaleU = 1.0f;
         }
@@ -1300,8 +1210,7 @@ void Discreet3DSImporter::ParseTextureChunk(D3DS::Texture* pcOut)
     case Discreet3DS::CHUNK_MAT_MAP_VSCALE:
         // Texture coordinate scaling in the V direction
         pcOut->mScaleV = stream->GetF4();
-        if (0.0f == pcOut->mScaleV)
-        {
+        if (0.0f == pcOut->mScaleV) {
             ASSIMP_LOG_WARN("Texture coordinate scaling in the y direction is zero. Assuming 1.");
             pcOut->mScaleV = 1.0f;
         }
@@ -1319,11 +1228,10 @@ void Discreet3DSImporter::ParseTextureChunk(D3DS::Texture* pcOut)
 
     case Discreet3DS::CHUNK_MAT_MAP_ANG:
         // Texture coordinate rotation, CCW in DEGREES
-        pcOut->mRotation = -AI_DEG_TO_RAD( stream->GetF4() );
+        pcOut->mRotation = -AI_DEG_TO_RAD(stream->GetF4());
         break;
 
-    case Discreet3DS::CHUNK_MAT_MAP_TILING:
-        {
+    case Discreet3DS::CHUNK_MAT_MAP_TILING: {
         const uint16_t iFlags = stream->GetI2();
 
         // Get the mapping mode (for both axes)
@@ -1334,9 +1242,9 @@ void Discreet3DSImporter::ParseTextureChunk(D3DS::Texture* pcOut)
             pcOut->mMapMode = aiTextureMapMode_Decal;
 
         // wrapping in all remaining cases
-        else pcOut->mMapMode = aiTextureMapMode_Wrap;
-        }
-        break;
+        else
+            pcOut->mMapMode = aiTextureMapMode_Wrap;
+    } break;
     };
 
     ASSIMP_3DS_END_CHUNK();
@@ -1359,13 +1267,12 @@ ai_real Discreet3DSImporter::ParsePercentageChunk() {
 
 // ------------------------------------------------------------------------------------------------
 // Read a color chunk. If a percentage chunk is found instead it is read as a grayscale color
-void Discreet3DSImporter::ParseColorChunk( aiColor3D* out, bool acceptPercent )
-{
-    ai_assert(out != NULL);
+void Discreet3DSImporter::ParseColorChunk(aiColor3D *out, bool acceptPercent) {
+    ai_assert(out != nullptr);
 
     // error return value
     const ai_real qnan = get_qnan();
-    static const aiColor3D clrError = aiColor3D(qnan,qnan,qnan);
+    static const aiColor3D clrError = aiColor3D(qnan, qnan, qnan);
 
     Discreet3DS::Chunk chunk;
     ReadChunk(&chunk);
@@ -1374,13 +1281,12 @@ void Discreet3DSImporter::ParseColorChunk( aiColor3D* out, bool acceptPercent )
     bool bGamma = false;
 
     // Get the type of the chunk
-    switch(chunk.Flag)
-    {
+    switch (chunk.Flag) {
     case Discreet3DS::CHUNK_LINRGBF:
         bGamma = true;
 
     case Discreet3DS::CHUNK_RGBF:
-        if (sizeof(float) * 3 > diff)   {
+        if (sizeof(float) * 3 > diff) {
             *out = clrError;
             return;
         }
@@ -1391,18 +1297,16 @@ void Discreet3DSImporter::ParseColorChunk( aiColor3D* out, bool acceptPercent )
 
     case Discreet3DS::CHUNK_LINRGBB:
         bGamma = true;
-    case Discreet3DS::CHUNK_RGBB:
-        {
-            if ( sizeof( char ) * 3 > diff ) {
-                *out = clrError;
-                return;
-            }
-            const ai_real invVal = ai_real( 1.0 ) / ai_real( 255.0 );
-            out->r = ( ai_real ) ( uint8_t ) stream->GetI1() * invVal;
-            out->g = ( ai_real ) ( uint8_t ) stream->GetI1() * invVal;
-            out->b = ( ai_real ) ( uint8_t ) stream->GetI1() * invVal;
+    case Discreet3DS::CHUNK_RGBB: {
+        if (sizeof(char) * 3 > diff) {
+            *out = clrError;
+            return;
         }
-        break;
+        const ai_real invVal = ai_real(1.0) / ai_real(255.0);
+        out->r = (ai_real)(uint8_t)stream->GetI1() * invVal;
+        out->g = (ai_real)(uint8_t)stream->GetI1() * invVal;
+        out->b = (ai_real)(uint8_t)stream->GetI1() * invVal;
+    } break;
 
     // Percentage chunks are accepted, too.
     case Discreet3DS::CHUNK_PERCENTF:
@@ -1415,7 +1319,7 @@ void Discreet3DSImporter::ParseColorChunk( aiColor3D* out, bool acceptPercent )
 
     case Discreet3DS::CHUNK_PERCENTW:
         if (acceptPercent && 1 <= diff) {
-            out->g = out->b = out->r = (ai_real)(uint8_t)stream->GetI1() / ai_real( 255.0 );
+            out->g = out->b = out->r = (ai_real)(uint8_t)stream->GetI1() / ai_real(255.0);
             break;
         }
         *out = clrError;
@@ -1424,7 +1328,7 @@ void Discreet3DSImporter::ParseColorChunk( aiColor3D* out, bool acceptPercent )
     default:
         stream->IncPtr(diff);
         // Skip unknown chunks, hope this won't cause any problems.
-        return ParseColorChunk(out,acceptPercent);
+        return ParseColorChunk(out, acceptPercent);
     };
     (void)bGamma;
 }
diff --git a/Engine/lib/assimp/code/3DS/3DSLoader.h b/Engine/lib/assimp/code/AssetLib/3DS/3DSLoader.h
similarity index 92%
rename from Engine/lib/assimp/code/3DS/3DSLoader.h
rename to Engine/lib/assimp/code/AssetLib/3DS/3DSLoader.h
index f57e6a8e3..f47fcfef9 100644
--- a/Engine/lib/assimp/code/3DS/3DSLoader.h
+++ b/Engine/lib/assimp/code/AssetLib/3DS/3DSLoader.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -46,11 +46,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #ifndef AI_3DSIMPORTER_H_INC
 #define AI_3DSIMPORTER_H_INC
+#ifndef ASSIMP_BUILD_NO_3DS_IMPORTER
 
 #include <assimp/BaseImporter.h>
 #include <assimp/types.h>
 
-#ifndef ASSIMP_BUILD_NO_3DS_IMPORTER
 
 #include "3DSHelper.h"
 #include <assimp/StreamReader.h>
@@ -65,28 +65,24 @@ using namespace D3DS;
 // ---------------------------------------------------------------------------------
 /** Importer class for 3D Studio r3 and r4 3DS files
  */
-class Discreet3DSImporter : public BaseImporter
-{
+class Discreet3DSImporter : public BaseImporter {
 public:
-
     Discreet3DSImporter();
     ~Discreet3DSImporter();
 
-public:
-
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
      * See BaseImporter::CanRead() for details.
      */
     bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
+        bool checkSig) const override;
 
     // -------------------------------------------------------------------
     /** Called prior to ReadFile().
      * The function is a request to the importer to update its configuration
      * basing on the Importer's configuration property list.
      */
-    void SetupProperties(const Importer* pImp);
+    void SetupProperties(const Importer* pImp) override;
 
 protected:
 
@@ -94,14 +90,14 @@ protected:
     /** Return importer meta information.
      * See #BaseImporter::GetInfo for the details
      */
-    const aiImporterDesc* GetInfo () const;
+    const aiImporterDesc* GetInfo () const override;
 
     // -------------------------------------------------------------------
     /** Imports the given file into the given scene structure.
      * See BaseImporter::InternReadFile() for details
      */
     void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
+        IOSystem* pIOHandler) override;
 
     // -------------------------------------------------------------------
     /** Converts a temporary material to the outer representation
@@ -212,6 +208,15 @@ protected:
     */
     void ReplaceDefaultMaterial();
 
+    bool ContainsTextures(unsigned int i) const {
+        return !mScene->mMaterials[i].sTexDiffuse.mMapName.empty() ||
+               !mScene->mMaterials[i].sTexBump.mMapName.empty() ||
+               !mScene->mMaterials[i].sTexOpacity.mMapName.empty() ||
+               !mScene->mMaterials[i].sTexEmissive.mMapName.empty() ||
+               !mScene->mMaterials[i].sTexSpecular.mMapName.empty() ||
+               !mScene->mMaterials[i].sTexShininess.mMapName.empty() ;
+    }
+
     // -------------------------------------------------------------------
     /** Convert the whole scene
     */
diff --git a/Engine/lib/assimp/code/AssetLib/3MF/3MFTypes.h b/Engine/lib/assimp/code/AssetLib/3MF/3MFTypes.h
new file mode 100644
index 000000000..987cdf613
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/3MF/3MFTypes.h
@@ -0,0 +1,165 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+#pragma once
+
+#include <assimp/vector3.h>
+#include <assimp/matrix4x4.h>
+#include <assimp/ParsingUtils.h>
+#include <vector>
+#include <string>
+
+struct aiMaterial;
+struct aiMesh;
+
+namespace Assimp {
+namespace D3MF {
+
+enum class ResourceType {
+    RT_Object,
+    RT_BaseMaterials,
+    RT_EmbeddedTexture2D,
+    RT_Texture2DGroup,
+    RT_Unknown
+}; // To be extended with other resource types (eg. material extension resources like Texture2d, Texture2dGroup...)
+
+class Resource {
+public:
+    int mId;
+
+    Resource(int id) :
+            mId(id) {
+        // empty
+    }
+
+    virtual ~Resource() {
+        // empty
+    }
+
+    virtual ResourceType getType() const {
+        return ResourceType::RT_Unknown;
+    }
+};
+
+class EmbeddedTexture : public Resource {
+public:
+    std::string mPath;
+    std::string mContentType;
+    std::string mTilestyleU;
+    std::string mTilestyleV;
+    std::vector<char> mBuffer;
+
+    EmbeddedTexture(int id) :
+            Resource(id),
+            mPath(),
+            mContentType(),
+            mTilestyleU(),
+            mTilestyleV() {
+        // empty
+    }
+
+    ~EmbeddedTexture() = default;
+
+    ResourceType getType() const override {
+        return ResourceType::RT_EmbeddedTexture2D;
+    }
+};
+
+class Texture2DGroup : public Resource {
+public:
+    std::vector<aiVector2D> mTex2dCoords;
+    int mTexId;
+    Texture2DGroup(int id) :
+            Resource(id),
+            mTexId(-1) {
+        // empty
+    }
+
+    ~Texture2DGroup() = default;
+
+    ResourceType getType() const override {
+        return ResourceType::RT_Texture2DGroup;
+    }
+};
+
+class BaseMaterials : public Resource {
+public:
+    std::vector<unsigned int> mMaterialIndex;
+
+    BaseMaterials(int id) :
+            Resource(id),
+            mMaterialIndex() {
+        // empty
+    }
+
+    ~BaseMaterials() = default;
+
+    ResourceType getType() const override {
+        return ResourceType::RT_BaseMaterials;
+    }
+};
+
+struct Component {
+    int mObjectId;
+    aiMatrix4x4 mTransformation;
+};
+
+class Object : public Resource {
+public:
+    std::vector<aiMesh *> mMeshes;
+    std::vector<unsigned int> mMeshIndex;
+    std::vector<Component> mComponents;
+    std::string mName;
+
+    Object(int id) :
+            Resource(id),
+            mName(std::string("Object_") + ai_to_string(id)) {
+        // empty
+    }
+
+    ~Object() = default;
+
+    ResourceType getType() const override {
+        return ResourceType::RT_Object;
+    }
+};
+
+} // namespace D3MF
+} // namespace Assimp
diff --git a/Engine/lib/assimp/code/AssetLib/3MF/3MFXmlTags.h b/Engine/lib/assimp/code/AssetLib/3MF/3MFXmlTags.h
new file mode 100644
index 000000000..63f18b455
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/3MF/3MFXmlTags.h
@@ -0,0 +1,117 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+#pragma once
+
+namespace Assimp {
+namespace D3MF {
+
+namespace XmlTag {
+    // Root tag
+    const char* const RootTag = "3MF";
+
+    // Meta-data
+    const char* const meta = "metadata";
+    const char* const meta_name = "name";
+
+    // Model-data specific tags
+    const char* const model = "model";
+    const char* const model_unit = "unit";
+    const char* const metadata = "metadata";
+    const char* const resources = "resources";
+    const char* const object = "object";
+    const char* const mesh = "mesh";
+    const char* const components = "components";
+    const char* const component = "component";
+    const char* const vertices = "vertices";
+    const char* const vertex = "vertex";
+    const char* const triangles = "triangles";
+    const char* const triangle = "triangle";
+    const char* const x = "x";
+    const char* const y = "y";
+    const char* const z = "z";
+    const char* const v1 = "v1";
+    const char* const v2 = "v2";
+    const char* const v3 = "v3";
+    const char* const id = "id";
+    const char* const pid = "pid";
+    const char* const pindex = "pindex";
+    const char* const p1 = "p1";
+    const char* const name = "name";
+    const char* const type = "type";
+    const char* const build = "build";
+    const char* const item = "item";
+    const char* const objectid = "objectid";
+    const char* const transform = "transform";
+    const char *const path = "path";
+
+    // Material definitions
+    const char* const basematerials = "basematerials";
+    const char* const basematerials_base = "base";
+    const char* const basematerials_name = "name";
+    const char* const basematerials_displaycolor = "displaycolor";
+    const char* const texture_2d = "m:texture2d";
+    const char *const texture_group = "m:texture2dgroup";
+    const char *const texture_content_type = "contenttype";
+    const char *const texture_tilestyleu = "tilestyleu";
+    const char *const texture_tilestylev = "tilestylev";
+    const char *const texture_2d_coord = "m:tex2coord";
+    const char *const texture_cuurd_u = "u";
+    const char *const texture_cuurd_v = "v";
+
+    // Meta info tags
+    const char* const CONTENT_TYPES_ARCHIVE = "[Content_Types].xml";
+    const char* const ROOT_RELATIONSHIPS_ARCHIVE = "_rels/.rels";
+    const char* const SCHEMA_CONTENTTYPES = "http://schemas.openxmlformats.org/package/2006/content-types";
+    const char* const SCHEMA_RELATIONSHIPS = "http://schemas.openxmlformats.org/package/2006/relationships";
+    const char* const RELS_RELATIONSHIP_CONTAINER = "Relationships";
+    const char* const RELS_RELATIONSHIP_NODE = "Relationship";
+    const char* const RELS_ATTRIB_TARGET = "Target";
+    const char* const RELS_ATTRIB_TYPE = "Type";
+    const char* const RELS_ATTRIB_ID = "Id";
+    const char* const PACKAGE_START_PART_RELATIONSHIP_TYPE = "http://schemas.microsoft.com/3dmanufacturing/2013/01/3dmodel";
+    const char* const PACKAGE_PRINT_TICKET_RELATIONSHIP_TYPE = "http://schemas.microsoft.com/3dmanufacturing/2013/01/printticket";
+    const char* const PACKAGE_TEXTURE_RELATIONSHIP_TYPE = "http://schemas.microsoft.com/3dmanufacturing/2013/01/3dtexture";
+    const char* const PACKAGE_CORE_PROPERTIES_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties";
+    const char* const PACKAGE_THUMBNAIL_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/thumbnail";
+}
+
+} // Namespace D3MF
+} // Namespace Assimp
diff --git a/Engine/lib/assimp/code/3MF/D3MFExporter.cpp b/Engine/lib/assimp/code/AssetLib/3MF/D3MFExporter.cpp
similarity index 50%
rename from Engine/lib/assimp/code/3MF/D3MFExporter.cpp
rename to Engine/lib/assimp/code/AssetLib/3MF/D3MFExporter.cpp
index 1f388ad3e..42cd991e6 100644
--- a/Engine/lib/assimp/code/3MF/D3MFExporter.cpp
+++ b/Engine/lib/assimp/code/AssetLib/3MF/D3MFExporter.cpp
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -44,81 +43,74 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "D3MFExporter.h"
 
-#include <assimp/scene.h>
-#include <assimp/IOSystem.hpp>
-#include <assimp/IOStream.hpp>
-#include <assimp/Exporter.hpp>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/StringUtils.h>
 #include <assimp/Exceptional.h>
+#include <assimp/StringUtils.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/Exporter.hpp>
+#include <assimp/IOStream.hpp>
+#include <assimp/IOSystem.hpp>
 
 #include "3MFXmlTags.h"
 #include "D3MFOpcPackage.h"
 
 #ifdef ASSIMP_USE_HUNTER
-#  include <zip/zip.h>
+#include <zip/zip.h>
 #else
-#  include <contrib/zip/src/zip.h>
+#include <contrib/zip/src/zip.h>
 #endif
 
 namespace Assimp {
 
-void ExportScene3MF( const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/ ) {
-    if ( nullptr == pIOSystem ) {
-        throw DeadlyExportError( "Could not export 3MP archive: " + std::string( pFile ) );
+void ExportScene3MF(const char *pFile, IOSystem *pIOSystem, const aiScene *pScene, const ExportProperties * /*pProperties*/) {
+    if (nullptr == pIOSystem) {
+        throw DeadlyExportError("Could not export 3MP archive: " + std::string(pFile));
     }
-    D3MF::D3MFExporter myExporter( pFile, pScene );
-    if ( myExporter.validate() ) {
-        if ( pIOSystem->Exists( pFile ) ) {
-            if ( !pIOSystem->DeleteFile( pFile ) ) {
-                throw DeadlyExportError( "File exists, cannot override : " + std::string( pFile ) );
+    D3MF::D3MFExporter myExporter(pFile, pScene);
+    if (myExporter.validate()) {
+        if (pIOSystem->Exists(pFile)) {
+            if (!pIOSystem->DeleteFile(pFile)) {
+                throw DeadlyExportError("File exists, cannot override : " + std::string(pFile));
             }
         }
         bool ok = myExporter.exportArchive(pFile);
-        if ( !ok ) {
-            throw DeadlyExportError( "Could not export 3MP archive: " + std::string( pFile ) );
+        if (!ok) {
+            throw DeadlyExportError("Could not export 3MP archive: " + std::string(pFile));
         }
     }
 }
 
 namespace D3MF {
 
-D3MFExporter::D3MFExporter( const char* pFile, const aiScene* pScene )
-: mArchiveName( pFile )
-, m_zipArchive( nullptr )
-, mScene( pScene )
-, mModelOutput()
-, mRelOutput()
-, mContentOutput()
-, mBuildItems()
-, mRelations() {
+D3MFExporter::D3MFExporter(const char *pFile, const aiScene *pScene) :
+        mArchiveName(pFile), m_zipArchive(nullptr), mScene(pScene), mModelOutput(), mRelOutput(), mContentOutput(), mBuildItems(), mRelations() {
     // empty
 }
 
 D3MFExporter::~D3MFExporter() {
-    for ( size_t i = 0; i < mRelations.size(); ++i ) {
-        delete mRelations[ i ];
+    for (size_t i = 0; i < mRelations.size(); ++i) {
+        delete mRelations[i];
     }
     mRelations.clear();
 }
 
 bool D3MFExporter::validate() {
-    if ( mArchiveName.empty() ) {
+    if (mArchiveName.empty()) {
         return false;
     }
 
-    if ( nullptr == mScene ) {
+    if (nullptr == mScene) {
         return false;
     }
 
     return true;
 }
 
-bool D3MFExporter::exportArchive( const char *file ) {
-    bool ok( true );
+bool D3MFExporter::exportArchive(const char *file) {
+    bool ok(true);
 
-    m_zipArchive = zip_open( file, ZIP_DEFAULT_COMPRESSION_LEVEL, 'w' );
-    if ( nullptr == m_zipArchive ) {
+    m_zipArchive = zip_open(file, ZIP_DEFAULT_COMPRESSION_LEVEL, 'w');
+    if (nullptr == m_zipArchive) {
         return false;
     }
 
@@ -126,7 +118,7 @@ bool D3MFExporter::exportArchive( const char *file ) {
     ok |= export3DModel();
     ok |= exportRelations();
 
-    zip_close( m_zipArchive );
+    zip_close(m_zipArchive);
     m_zipArchive = nullptr;
 
     return ok;
@@ -145,7 +137,7 @@ bool D3MFExporter::exportContentTypes() {
     mContentOutput << std::endl;
     mContentOutput << "</Types>";
     mContentOutput << std::endl;
-    exportContentTyp( XmlTag::CONTENT_TYPES_ARCHIVE );
+    zipContentType(XmlTag::CONTENT_TYPES_ARCHIVE);
 
     return true;
 }
@@ -157,20 +149,20 @@ bool D3MFExporter::exportRelations() {
     mRelOutput << std::endl;
     mRelOutput << "<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">";
 
-    for ( size_t i = 0; i < mRelations.size(); ++i ) {
-        if ( mRelations[ i ]->target[ 0 ] == '/' ) {
-            mRelOutput << "<Relationship Target=\"" << mRelations[ i ]->target << "\" ";
+    for (size_t i = 0; i < mRelations.size(); ++i) {
+        if (mRelations[i]->target[0] == '/') {
+            mRelOutput << "<Relationship Target=\"" << mRelations[i]->target << "\" ";
         } else {
-            mRelOutput << "<Relationship Target=\"/" << mRelations[ i ]->target << "\" ";
+            mRelOutput << "<Relationship Target=\"/" << mRelations[i]->target << "\" ";
         }
         mRelOutput << "Id=\"" << mRelations[i]->id << "\" ";
-        mRelOutput << "Type=\"" << mRelations[ i ]->type << "\" />";
+        mRelOutput << "Type=\"" << mRelations[i]->type << "\" />";
         mRelOutput << std::endl;
     }
     mRelOutput << "</Relationships>";
     mRelOutput << std::endl;
 
-    writeRelInfoToFile( "_rels", ".rels" );
+    zipRelInfo("_rels", ".rels");
     mRelOutput.flush();
 
     return true;
@@ -181,8 +173,8 @@ bool D3MFExporter::export3DModel() {
 
     writeHeader();
     mModelOutput << "<" << XmlTag::model << " " << XmlTag::model_unit << "=\"millimeter\""
-            << "xmlns=\"http://schemas.microsoft.com/3dmanufacturing/core/2015/02\">"
-            << std::endl;
+                 << " xmlns=\"http://schemas.microsoft.com/3dmanufacturing/core/2015/02\">"
+                 << std::endl;
     mModelOutput << "<" << XmlTag::resources << ">";
     mModelOutput << std::endl;
 
@@ -192,7 +184,6 @@ bool D3MFExporter::export3DModel() {
 
     writeObjects();
 
-
     mModelOutput << "</" << XmlTag::resources << ">";
     mModelOutput << std::endl;
     writeBuild();
@@ -203,36 +194,36 @@ bool D3MFExporter::export3DModel() {
     info->id = "rel0";
     info->target = "/3D/3DModel.model";
     info->type = XmlTag::PACKAGE_START_PART_RELATIONSHIP_TYPE;
-    mRelations.push_back( info );
+    mRelations.push_back(info);
 
-    writeModelToArchive( "3D", "3DModel.model" );
+    zipModel("3D", "3DModel.model");
     mModelOutput.flush();
 
     return true;
 }
 
 void D3MFExporter::writeHeader() {
-    mModelOutput << "<?xml version=\"1.0\" encoding=\"UTF - 8\"?>";
+    mModelOutput << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
     mModelOutput << std::endl;
 }
 
 void D3MFExporter::writeMetaData() {
-    if ( nullptr == mScene->mMetaData ) {
+    if (nullptr == mScene->mMetaData) {
         return;
     }
 
-    const unsigned int numMetaEntries( mScene->mMetaData->mNumProperties );
-    if ( 0 == numMetaEntries ) {
+    const unsigned int numMetaEntries(mScene->mMetaData->mNumProperties);
+    if (0 == numMetaEntries) {
         return;
     }
 
-	const aiString *key = nullptr;
+    const aiString *key = nullptr;
     const aiMetadataEntry *entry(nullptr);
-    for ( size_t i = 0; i < numMetaEntries; ++i ) {
-        mScene->mMetaData->Get( i, key, entry );
-        std::string k( key->C_Str() );
+    for (size_t i = 0; i < numMetaEntries; ++i) {
+        mScene->mMetaData->Get(i, key, entry);
+        std::string k(key->C_Str());
         aiString value;
-        mScene->mMetaData->Get(  k, value );
+        mScene->mMetaData->Get(k, value);
         mModelOutput << "<" << XmlTag::meta << " " << XmlTag::meta_name << "=\"" << key->C_Str() << "\">";
         mModelOutput << value.C_Str();
         mModelOutput << "</" << XmlTag::meta << ">" << std::endl;
@@ -241,159 +232,169 @@ void D3MFExporter::writeMetaData() {
 
 void D3MFExporter::writeBaseMaterials() {
     mModelOutput << "<basematerials id=\"1\">\n";
-    std::string strName, hexDiffuseColor , tmp;
-    for ( size_t i = 0; i < mScene->mNumMaterials; ++i ) {
-        aiMaterial *mat = mScene->mMaterials[ i ];
+    std::string strName, hexDiffuseColor, tmp;
+    for (size_t i = 0; i < mScene->mNumMaterials; ++i) {
+        aiMaterial *mat = mScene->mMaterials[i];
         aiString name;
-        if ( mat->Get( AI_MATKEY_NAME, name ) != aiReturn_SUCCESS ) {
-            strName = "basemat_" + to_string( i );
+        if (mat->Get(AI_MATKEY_NAME, name) != aiReturn_SUCCESS) {
+            strName = "basemat_" + ai_to_string(i);
         } else {
             strName = name.C_Str();
         }
         aiColor4D color;
-        if ( mat->Get( AI_MATKEY_COLOR_DIFFUSE, color ) == aiReturn_SUCCESS ) {
+        if (mat->Get(AI_MATKEY_COLOR_DIFFUSE, color) == aiReturn_SUCCESS) {
             hexDiffuseColor.clear();
             tmp.clear();
-            hexDiffuseColor = "#";
-            
-            tmp = DecimalToHexa( color.r );
-            hexDiffuseColor += tmp;
-            tmp = DecimalToHexa( color.g );
-            hexDiffuseColor += tmp;
-            tmp = DecimalToHexa( color.b );
-            hexDiffuseColor += tmp;
-            tmp = DecimalToHexa( color.a );
-            hexDiffuseColor += tmp;
+            // rgbs %
+            if (color.r <= 1 && color.g <= 1 && color.b <= 1 && color.a <= 1) {
+
+                hexDiffuseColor = ai_rgba2hex(
+                        (int)((ai_real)color.r) * 255,
+                        (int)((ai_real)color.g) * 255,
+                        (int)((ai_real)color.b) * 255,
+                        (int)((ai_real)color.a) * 255,
+                        true);
+
+            } else {
+                hexDiffuseColor = "#";
+                tmp = ai_decimal_to_hexa((ai_real)color.r);
+                hexDiffuseColor += tmp;
+                tmp = ai_decimal_to_hexa((ai_real)color.g);
+                hexDiffuseColor += tmp;
+                tmp = ai_decimal_to_hexa((ai_real)color.b);
+                hexDiffuseColor += tmp;
+                tmp = ai_decimal_to_hexa((ai_real)color.a);
+                hexDiffuseColor += tmp;
+            }
         } else {
             hexDiffuseColor = "#FFFFFFFF";
         }
 
-        mModelOutput << "<base name=\""+strName+"\" "+" displaycolor=\""+hexDiffuseColor+"\" />\n";
+        mModelOutput << "<base name=\"" + strName + "\" " + " displaycolor=\"" + hexDiffuseColor + "\" />\n";
     }
     mModelOutput << "</basematerials>\n";
 }
 
 void D3MFExporter::writeObjects() {
-    if ( nullptr == mScene->mRootNode ) {
+    if (nullptr == mScene->mRootNode) {
         return;
     }
 
     aiNode *root = mScene->mRootNode;
-    for ( unsigned int i = 0; i < root->mNumChildren; ++i ) {
-        aiNode *currentNode( root->mChildren[ i ] );
-        if ( nullptr == currentNode ) {
+    for (unsigned int i = 0; i < root->mNumChildren; ++i) {
+        aiNode *currentNode(root->mChildren[i]);
+        if (nullptr == currentNode) {
             continue;
         }
-        mModelOutput << "<" << XmlTag::object << " id=\"" << currentNode->mName.C_Str() << "\" type=\"model\">";
+        mModelOutput << "<" << XmlTag::object << " id=\"" << i + 2 << "\" type=\"model\">";
         mModelOutput << std::endl;
-        for ( unsigned int j = 0; j < currentNode->mNumMeshes; ++j ) {
-            aiMesh *currentMesh = mScene->mMeshes[ currentNode->mMeshes[ j ] ];
-            if ( nullptr == currentMesh ) {
+        for (unsigned int j = 0; j < currentNode->mNumMeshes; ++j) {
+            aiMesh *currentMesh = mScene->mMeshes[currentNode->mMeshes[j]];
+            if (nullptr == currentMesh) {
                 continue;
             }
-            writeMesh( currentMesh );
+            writeMesh(currentMesh);
         }
-        mBuildItems.push_back( i );
+        mBuildItems.push_back(i);
 
         mModelOutput << "</" << XmlTag::object << ">";
         mModelOutput << std::endl;
     }
 }
 
-void D3MFExporter::writeMesh( aiMesh *mesh ) {
-    if ( nullptr == mesh ) {
+void D3MFExporter::writeMesh(aiMesh *mesh) {
+    if (nullptr == mesh) {
         return;
     }
 
-    mModelOutput << "<" << XmlTag::mesh << ">" << std::endl;
-    mModelOutput << "<" << XmlTag::vertices << ">" << std::endl;
-    for ( unsigned int i = 0; i < mesh->mNumVertices; ++i ) {
-        writeVertex( mesh->mVertices[ i ] );
+    mModelOutput << "<"
+                 << XmlTag::mesh
+                 << ">" << "\n";
+    mModelOutput << "<"
+                 << XmlTag::vertices
+                 << ">" << "\n";
+    for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
+        writeVertex(mesh->mVertices[i]);
     }
-    mModelOutput << "</" << XmlTag::vertices << ">" << std::endl;
+    mModelOutput << "</"
+                 << XmlTag::vertices << ">"
+                 << "\n";
 
-    const unsigned int matIdx( mesh->mMaterialIndex );
+    const unsigned int matIdx(mesh->mMaterialIndex);
 
-    writeFaces( mesh, matIdx );
+    writeFaces(mesh, matIdx);
 
-    mModelOutput << "</" << XmlTag::mesh << ">" << std::endl;
+    mModelOutput << "</"
+                 << XmlTag::mesh << ">"
+                 << "\n";
 }
 
-void D3MFExporter::writeVertex( const aiVector3D &pos ) {
+void D3MFExporter::writeVertex(const aiVector3D &pos) {
     mModelOutput << "<" << XmlTag::vertex << " x=\"" << pos.x << "\" y=\"" << pos.y << "\" z=\"" << pos.z << "\" />";
     mModelOutput << std::endl;
 }
 
-void D3MFExporter::writeFaces( aiMesh *mesh, unsigned int matIdx ) {
-    if ( nullptr == mesh ) {
+void D3MFExporter::writeFaces(aiMesh *mesh, unsigned int matIdx) {
+    if (nullptr == mesh) {
         return;
     }
 
-    if ( !mesh->HasFaces() ) {
+    if (!mesh->HasFaces()) {
         return;
     }
-    mModelOutput << "<" << XmlTag::triangles << ">" << std::endl;
-    for ( unsigned int i = 0; i < mesh->mNumFaces; ++i ) {
-        aiFace &currentFace = mesh->mFaces[ i ];
-        mModelOutput << "<" << XmlTag::triangle << " v1=\"" << currentFace.mIndices[ 0 ] << "\" v2=\""
-                << currentFace.mIndices[ 1 ] << "\" v3=\"" << currentFace.mIndices[ 2 ]
-                << "\" pid=\"1\" p1=\""+to_string(matIdx)+"\" />";
-        mModelOutput << std::endl;
+    mModelOutput << "<"
+                 << XmlTag::triangles << ">"
+                 << "\n";
+    for (unsigned int i = 0; i < mesh->mNumFaces; ++i) {
+        aiFace &currentFace = mesh->mFaces[i];
+        mModelOutput << "<" << XmlTag::triangle << " v1=\"" << currentFace.mIndices[0] << "\" v2=\""
+                     << currentFace.mIndices[1] << "\" v3=\"" << currentFace.mIndices[2]
+                     << "\" pid=\"1\" p1=\"" + ai_to_string(matIdx) + "\" />";
+        mModelOutput << "\n";
     }
-    mModelOutput << "</" << XmlTag::triangles << ">";
-    mModelOutput << std::endl;
+    mModelOutput << "</"
+                 << XmlTag::triangles
+                 << ">";
+    mModelOutput << "\n";
 }
 
 void D3MFExporter::writeBuild() {
-    mModelOutput << "<" << XmlTag::build << ">" << std::endl;
+    mModelOutput << "<"
+                 << XmlTag::build
+                 << ">"
+                 << "\n";
 
-    for ( size_t i = 0; i < mBuildItems.size(); ++i ) {
-        mModelOutput << "<" << XmlTag::item << " objectid=\"" << i + 1 << "\"/>";
-        mModelOutput << std::endl;
+    for (size_t i = 0; i < mBuildItems.size(); ++i) {
+        mModelOutput << "<" << XmlTag::item << " objectid=\"" << i + 2 << "\"/>";
+        mModelOutput << "\n";
     }
     mModelOutput << "</" << XmlTag::build << ">";
-    mModelOutput << std::endl;
+    mModelOutput << "\n";
 }
 
-void D3MFExporter::exportContentTyp( const std::string &filename ) {
-    if ( nullptr == m_zipArchive ) {
-        throw DeadlyExportError( "3MF-Export: Zip archive not valid, nullptr." );
-    }
-    const std::string entry = filename;
-    zip_entry_open( m_zipArchive, entry.c_str() );
-
-    const std::string &exportTxt( mContentOutput.str() );
-    zip_entry_write( m_zipArchive, exportTxt.c_str(), exportTxt.size() );
-
-    zip_entry_close( m_zipArchive );
+void D3MFExporter::zipContentType(const std::string &filename) {
+    addFileInZip(filename, mContentOutput.str());
 }
 
-void D3MFExporter::writeModelToArchive( const std::string &folder, const std::string &modelName ) {
-    if ( nullptr == m_zipArchive ) {
-        throw DeadlyExportError( "3MF-Export: Zip archive not valid, nullptr." );
-    }
+void D3MFExporter::zipModel(const std::string &folder, const std::string &modelName) {
     const std::string entry = folder + "/" + modelName;
-    zip_entry_open( m_zipArchive, entry.c_str() );
-
-    const std::string &exportTxt( mModelOutput.str() );
-    zip_entry_write( m_zipArchive, exportTxt.c_str(), exportTxt.size() );
-
-    zip_entry_close( m_zipArchive );
+    addFileInZip(entry, mModelOutput.str());
 }
 
-void D3MFExporter::writeRelInfoToFile( const std::string &folder, const std::string &relName ) {
-    if ( nullptr == m_zipArchive ) {
-        throw DeadlyExportError( "3MF-Export: Zip archive not valid, nullptr." );
-    }
+void D3MFExporter::zipRelInfo(const std::string &folder, const std::string &relName) {
     const std::string entry = folder + "/" + relName;
-    zip_entry_open( m_zipArchive, entry.c_str() );
-
-    const std::string &exportTxt( mRelOutput.str() );
-    zip_entry_write( m_zipArchive, exportTxt.c_str(), exportTxt.size() );
-
-    zip_entry_close( m_zipArchive );
+    addFileInZip(entry, mRelOutput.str());
 }
 
+void D3MFExporter::addFileInZip(const std::string& entry, const std::string& content) {
+    if (nullptr == m_zipArchive) {
+        throw DeadlyExportError("3MF-Export: Zip archive not valid, nullptr.");
+    }
+
+    zip_entry_open(m_zipArchive, entry.c_str());
+    zip_entry_write(m_zipArchive, content.c_str(), content.size());
+    zip_entry_close(m_zipArchive);
+}
 
 } // Namespace D3MF
 } // Namespace Assimp
diff --git a/Engine/lib/assimp/code/3MF/D3MFExporter.h b/Engine/lib/assimp/code/AssetLib/3MF/D3MFExporter.h
similarity index 89%
rename from Engine/lib/assimp/code/3MF/D3MFExporter.h
rename to Engine/lib/assimp/code/AssetLib/3MF/D3MFExporter.h
index e82120247..680d54f91 100644
--- a/Engine/lib/assimp/code/3MF/D3MFExporter.h
+++ b/Engine/lib/assimp/code/AssetLib/3MF/D3MFExporter.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -41,6 +40,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 #pragma once
 
+#ifndef ASSIMP_BUILD_NO_EXPORT
+#ifndef ASSIMP_BUILD_NO_3MF_EXPORTER
+
 #include <memory>
 #include <sstream>
 #include <vector>
@@ -59,8 +61,6 @@ class IOStream;
 
 namespace D3MF {
 
-#ifndef ASSIMP_BUILD_NO_EXPORT
-#ifndef ASSIMP_BUILD_NO_3MF_EXPORTER
 
 struct OpcPackageRelationship;
 
@@ -83,9 +83,12 @@ protected:
     void writeVertex( const aiVector3D &pos );
     void writeFaces( aiMesh *mesh, unsigned int matIdx );
     void writeBuild();
-    void exportContentTyp( const std::string &filename );
-    void writeModelToArchive( const std::string &folder, const std::string &modelName );
-    void writeRelInfoToFile( const std::string &folder, const std::string &relName );
+
+    // Zip the data
+    void zipContentType( const std::string &filename );
+    void zipModel( const std::string &folder, const std::string &modelName );
+    void zipRelInfo( const std::string &folder, const std::string &relName );
+    void addFileInZip( const std::string &entry, const std::string &content );
 
 private:
     std::string mArchiveName;
@@ -98,9 +101,11 @@ private:
     std::vector<OpcPackageRelationship*> mRelations;
 };
 
-#endif // ASSIMP_BUILD_NO_3MF_EXPORTER
-#endif // ASSIMP_BUILD_NO_EXPORT
 
 } // Namespace D3MF
 } // Namespace Assimp
 
+#endif // ASSIMP_BUILD_NO_3MF_EXPORTER
+#endif // ASSIMP_BUILD_NO_EXPORT
+
+
diff --git a/Engine/lib/assimp/code/AssetLib/3MF/D3MFImporter.cpp b/Engine/lib/assimp/code/AssetLib/3MF/D3MFImporter.cpp
new file mode 100644
index 000000000..5b0f34c3a
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/3MF/D3MFImporter.cpp
@@ -0,0 +1,130 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#ifndef ASSIMP_BUILD_NO_3MF_IMPORTER
+
+#include "D3MFImporter.h"
+#include "3MFXmlTags.h"
+#include "D3MFOpcPackage.h"
+#include "XmlSerializer.h"
+
+#include <assimp/StringComparison.h>
+#include <assimp/StringUtils.h>
+#include <assimp/XmlParser.h>
+#include <assimp/ZipArchiveIOSystem.h>
+#include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOSystem.hpp>
+#include <assimp/fast_atof.h>
+
+#include <cassert>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+#include <iomanip>
+#include <cstring>
+
+namespace Assimp {
+
+using namespace D3MF;
+
+static const aiImporterDesc desc = {
+    "3mf Importer",
+    "",
+    "",
+    "http://3mf.io/",
+    aiImporterFlags_SupportBinaryFlavour | aiImporterFlags_SupportCompressedFlavour,
+    0,
+    0,
+    0,
+    0,
+    "3mf"
+};
+
+D3MFImporter::D3MFImporter() :
+        BaseImporter() {
+    // empty
+}
+
+D3MFImporter::~D3MFImporter() {
+    // empty
+}
+
+bool D3MFImporter::CanRead(const std::string &filename, IOSystem *pIOHandler, bool /*checkSig*/) const {
+    if (!ZipArchiveIOSystem::isZipArchive(pIOHandler, filename)) {
+        return false;
+    }
+    D3MF::D3MFOpcPackage opcPackage(pIOHandler, filename);
+    return opcPackage.validate();
+}
+
+void D3MFImporter::SetupProperties(const Importer*) {
+    // empty
+}
+
+const aiImporterDesc *D3MFImporter::GetInfo() const {
+    return &desc;
+}
+
+void D3MFImporter::InternReadFile(const std::string &filename, aiScene *pScene, IOSystem *pIOHandler) {
+    D3MFOpcPackage opcPackage(pIOHandler, filename);
+
+    XmlParser xmlParser;
+    if (xmlParser.parse(opcPackage.RootStream())) {
+        XmlSerializer xmlSerializer(&xmlParser);
+        xmlSerializer.ImportXml(pScene);
+
+        const std::vector<aiTexture*> &tex =  opcPackage.GetEmbeddedTextures();
+        if (!tex.empty()) {
+            pScene->mNumTextures = static_cast<unsigned int>(tex.size());
+            pScene->mTextures = new aiTexture *[pScene->mNumTextures];
+            for (unsigned int i = 0; i < pScene->mNumTextures; ++i) {
+                pScene->mTextures[i] = tex[i];
+            }
+        }
+    }
+}
+
+} // Namespace Assimp
+
+#endif // ASSIMP_BUILD_NO_3MF_IMPORTER
diff --git a/Engine/lib/assimp/code/AssetLib/3MF/D3MFImporter.h b/Engine/lib/assimp/code/AssetLib/3MF/D3MFImporter.h
new file mode 100644
index 000000000..a39ae790f
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/3MF/D3MFImporter.h
@@ -0,0 +1,91 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#ifndef AI_D3MFLOADER_H_INCLUDED
+#define AI_D3MFLOADER_H_INCLUDED
+
+#ifndef ASSIMP_BUILD_NO_3MF_IMPORTER
+
+#include <assimp/BaseImporter.h>
+
+namespace Assimp {
+
+// ---------------------------------------------------------------------------
+/// @brief  The 3MF-importer class.
+///
+/// Implements the basic topology import and embedded textures.
+// ---------------------------------------------------------------------------
+class D3MFImporter : public BaseImporter {
+public:
+    /// @brief The default class constructor.
+    D3MFImporter();
+
+    ///	@brief  The class destructor.
+    ~D3MFImporter() override;
+
+    /// @brief Performs the data format detection.
+    /// @param pFile        The filename to check.
+    /// @param pIOHandler   The used IO-System.
+    /// @param checkSig     true for signature checking.
+    /// @return true for can be loaded, false for not.
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const override;
+
+    /// @brief  Not used
+    /// @param pImp Not used
+    void SetupProperties(const Importer *pImp) override;
+
+    /// @brief The importer description getter.
+    /// @return The info
+    const aiImporterDesc *GetInfo() const override;
+
+protected:
+    /// @brief Internal read function, performs the file parsing.
+    /// @param pFile        The filename
+    /// @param pScene       The scene to load in.
+    /// @param pIOHandler   The io-system
+    void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) override;
+};
+
+} // Namespace Assimp
+
+#endif // #ifndef ASSIMP_BUILD_NO_3MF_IMPORTER
+
+#endif // AI_D3MFLOADER_H_INCLUDED
diff --git a/Engine/lib/assimp/code/AssetLib/3MF/D3MFOpcPackage.cpp b/Engine/lib/assimp/code/AssetLib/3MF/D3MFOpcPackage.cpp
new file mode 100644
index 000000000..f88039ae8
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/3MF/D3MFOpcPackage.cpp
@@ -0,0 +1,256 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#ifndef ASSIMP_BUILD_NO_3MF_IMPORTER
+
+#include "D3MFOpcPackage.h"
+#include <assimp/Exceptional.h>
+#include <assimp/XmlParser.h>
+#include <assimp/ZipArchiveIOSystem.h>
+#include <assimp/ai_assert.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOStream.hpp>
+#include <assimp/IOSystem.hpp>
+#include <assimp/texture.h>
+#include "3MFXmlTags.h"
+
+#include <algorithm>
+#include <cassert>
+#include <cstdlib>
+#include <map>
+#include <vector>
+
+namespace Assimp {
+
+namespace D3MF {
+// ------------------------------------------------------------------------------------------------
+
+using OpcPackageRelationshipPtr = std::shared_ptr<OpcPackageRelationship>;
+
+class OpcPackageRelationshipReader {
+public:
+    OpcPackageRelationshipReader(XmlParser &parser) :
+            m_relationShips() {
+        XmlNode root = parser.getRootNode();
+        ParseRootNode(root);
+    }
+
+    void ParseRootNode(XmlNode &node) {
+        ParseAttributes(node);
+        for (XmlNode currentNode = node.first_child(); currentNode; currentNode = currentNode.next_sibling()) {
+            std::string name = currentNode.name();
+            if (name == "Relationships") {
+                ParseRelationsNode(currentNode);
+            }
+        }
+    }
+
+    void ParseAttributes(XmlNode & /*node*/) {
+        // empty
+    }
+
+    bool validateRels(OpcPackageRelationshipPtr &relPtr) {
+        if (relPtr->id.empty() || relPtr->type.empty() || relPtr->target.empty()) {
+            return false;
+        }
+
+        return true;
+    }
+
+    void ParseRelationsNode(XmlNode &node) {
+        if (node.empty()) {
+            return;
+        }
+
+        for (XmlNode currentNode = node.first_child(); currentNode; currentNode = currentNode.next_sibling()) {
+            const std::string name = currentNode.name();
+            if (name == "Relationship") {
+                OpcPackageRelationshipPtr relPtr(new OpcPackageRelationship());
+                relPtr->id = currentNode.attribute(XmlTag::RELS_ATTRIB_ID).as_string();
+                relPtr->type = currentNode.attribute(XmlTag::RELS_ATTRIB_TYPE).as_string();
+                relPtr->target = currentNode.attribute(XmlTag::RELS_ATTRIB_TARGET).as_string();
+                if (validateRels(relPtr)) {
+                    m_relationShips.push_back(relPtr);
+                }
+            }
+        }
+    }
+
+    std::vector<OpcPackageRelationshipPtr> m_relationShips;
+};
+
+static bool IsEmbeddedTexture( const std::string &filename ) {
+    const std::string extension = BaseImporter::GetExtension(filename);
+    if (extension == "jpg" || extension == "png") {
+        std::string::size_type pos = filename.find("thumbnail");
+        if (pos == std::string::npos) {
+            return false;
+        }
+        return true;
+    }
+
+    return false;
+}
+// ------------------------------------------------------------------------------------------------
+D3MFOpcPackage::D3MFOpcPackage(IOSystem *pIOHandler, const std::string &rFile) :
+        mRootStream(nullptr),
+        mZipArchive() {
+    mZipArchive = new ZipArchiveIOSystem(pIOHandler, rFile);
+    if (!mZipArchive->isOpen()) {
+        throw DeadlyImportError("Failed to open file ", rFile, ".");
+    }
+
+    std::vector<std::string> fileList;
+    mZipArchive->getFileList(fileList);
+
+    for (auto &file : fileList) {
+        if (file == D3MF::XmlTag::ROOT_RELATIONSHIPS_ARCHIVE) {
+            if (!mZipArchive->Exists(file.c_str())) {
+                continue;
+            }
+
+            IOStream *fileStream = mZipArchive->Open(file.c_str());
+            if (nullptr == fileStream) {
+                ASSIMP_LOG_ERROR("Filestream is nullptr.");
+                continue;
+            }
+
+            std::string rootFile = ReadPackageRootRelationship(fileStream);
+            if (!rootFile.empty() && rootFile[0] == '/') {
+                rootFile = rootFile.substr(1);
+                if (rootFile[0] == '/') {
+                    // deal with zip-bug
+                    rootFile = rootFile.substr(1);
+                }
+            } 
+
+            ASSIMP_LOG_VERBOSE_DEBUG(rootFile);
+
+            mZipArchive->Close(fileStream);
+
+            mRootStream = mZipArchive->Open(rootFile.c_str());
+            ai_assert(mRootStream != nullptr);
+            if (nullptr == mRootStream) {
+                throw DeadlyImportError("Cannot open root-file in archive : " + rootFile);
+            }
+        } else if (file == D3MF::XmlTag::CONTENT_TYPES_ARCHIVE) {
+            ASSIMP_LOG_WARN("Ignored file of unsupported type CONTENT_TYPES_ARCHIVES", file);
+        } else if (IsEmbeddedTexture(file)) {
+            IOStream *fileStream = mZipArchive->Open(file.c_str());
+            LoadEmbeddedTextures(fileStream, file);
+            mZipArchive->Close(fileStream);
+        } else {
+            ASSIMP_LOG_WARN("Ignored file of unknown type: ", file);
+        }
+    }
+}
+
+D3MFOpcPackage::~D3MFOpcPackage() {
+    mZipArchive->Close(mRootStream);
+    delete mZipArchive;
+}
+
+IOStream *D3MFOpcPackage::RootStream() const {
+    return mRootStream;
+}
+
+const std::vector<aiTexture *> &D3MFOpcPackage::GetEmbeddedTextures() const {
+    return mEmbeddedTextures;
+}
+
+static const char *const ModelRef = "3D/3dmodel.model";
+
+bool D3MFOpcPackage::validate() {
+    if (nullptr == mRootStream || nullptr == mZipArchive) {
+        return false;
+    }
+
+    return mZipArchive->Exists(ModelRef);
+}
+
+std::string D3MFOpcPackage::ReadPackageRootRelationship(IOStream *stream) {
+    XmlParser xmlParser;
+    if (!xmlParser.parse(stream)) {
+        return std::string();
+    }
+
+    OpcPackageRelationshipReader reader(xmlParser);
+
+    auto itr = std::find_if(reader.m_relationShips.begin(), reader.m_relationShips.end(), [](const OpcPackageRelationshipPtr &rel) {
+        return rel->type == XmlTag::PACKAGE_START_PART_RELATIONSHIP_TYPE;
+    });
+
+    if (itr == reader.m_relationShips.end()) {
+        throw DeadlyImportError("Cannot find ", XmlTag::PACKAGE_START_PART_RELATIONSHIP_TYPE);
+    }
+
+    return (*itr)->target;
+}
+
+void D3MFOpcPackage::LoadEmbeddedTextures(IOStream *fileStream, const std::string &filename) {
+    if (nullptr == fileStream) {
+        return;
+    }
+
+    const size_t size = fileStream->FileSize();
+    if (0 == size) {
+        return;
+    }
+
+    unsigned char *data = new unsigned char[size];
+    fileStream->Read(data, 1, size);
+    aiTexture *texture = new aiTexture;
+    std::string embName = "*" + filename;
+    texture->mFilename.Set(embName.c_str());
+    texture->mWidth = static_cast<unsigned int>(size);
+    texture->mHeight = 0;
+    texture->achFormatHint[0] = 'p';
+    texture->achFormatHint[1] = 'n';
+    texture->achFormatHint[2] = 'g';
+    texture->achFormatHint[3] = '\0';
+    texture->pcData = (aiTexel*) data;
+    mEmbeddedTextures.emplace_back(texture);
+}
+
+} // Namespace D3MF
+} // Namespace Assimp
+
+#endif //ASSIMP_BUILD_NO_3MF_IMPORTER
diff --git a/Engine/lib/assimp/code/3MF/D3MFOpcPackage.h b/Engine/lib/assimp/code/AssetLib/3MF/D3MFOpcPackage.h
similarity index 83%
rename from Engine/lib/assimp/code/3MF/D3MFOpcPackage.h
rename to Engine/lib/assimp/code/AssetLib/3MF/D3MFOpcPackage.h
index 87d172116..f6803a0ef 100644
--- a/Engine/lib/assimp/code/3MF/D3MFOpcPackage.h
+++ b/Engine/lib/assimp/code/AssetLib/3MF/D3MFOpcPackage.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,19 +42,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef D3MFOPCPACKAGE_H
 #define D3MFOPCPACKAGE_H
 
-#include <memory>
-
 #include <assimp/IOSystem.hpp>
-#include <assimp/irrXMLWrapper.h>
+#include <memory>
+#include <string>
+
+struct aiTexture;
 
 namespace Assimp {
-    class ZipArchiveIOSystem;
+
+class ZipArchiveIOSystem;
 
 namespace D3MF {
 
-using XmlReader = irr::io::IrrXMLReader ;
-using XmlReaderPtr = std::shared_ptr<XmlReader> ;
-
 struct OpcPackageRelationship {
     std::string id;
     std::string type;
@@ -64,20 +62,23 @@ struct OpcPackageRelationship {
 
 class D3MFOpcPackage {
 public:
-    D3MFOpcPackage( IOSystem* pIOHandler, const std::string& rFile );
+    D3MFOpcPackage( IOSystem* pIOHandler, const std::string& file );
     ~D3MFOpcPackage();
     IOStream* RootStream() const;
     bool validate();
+    const std::vector<aiTexture*> &GetEmbeddedTextures() const;
 
 protected:
     std::string ReadPackageRootRelationship(IOStream* stream);
+    void LoadEmbeddedTextures(IOStream *fileStream, const std::string &filename);
 
 private:
     IOStream* mRootStream;
-    std::unique_ptr<ZipArchiveIOSystem> mZipArchive;
+    ZipArchiveIOSystem *mZipArchive;
+    std::vector<aiTexture *> mEmbeddedTextures;
 };
 
-} // Namespace D3MF
-} // Namespace Assimp
+} // namespace D3MF
+} // namespace Assimp
 
 #endif // D3MFOPCPACKAGE_H
diff --git a/Engine/lib/assimp/code/AssetLib/3MF/XmlSerializer.cpp b/Engine/lib/assimp/code/AssetLib/3MF/XmlSerializer.cpp
new file mode 100644
index 000000000..9bd1c5bb0
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/3MF/XmlSerializer.cpp
@@ -0,0 +1,593 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+#include "XmlSerializer.h"
+#include "D3MFOpcPackage.h"
+#include "3MFXmlTags.h"
+#include "3MFTypes.h"
+#include <assimp/scene.h>
+
+namespace Assimp {
+namespace D3MF {
+
+static const int IdNotSet = -1;
+
+namespace {
+
+static const size_t ColRGBA_Len = 9;
+static const size_t ColRGB_Len = 7;
+
+// format of the color string: #RRGGBBAA or #RRGGBB (3MF Core chapter 5.1.1)
+bool validateColorString(const char *color) {
+    const size_t len = strlen(color);
+    if (ColRGBA_Len != len && ColRGB_Len != len) {
+        return false;
+    }
+
+    return true;
+}
+
+aiFace ReadTriangle(XmlNode &node) {
+    aiFace face;
+
+    face.mNumIndices = 3;
+    face.mIndices = new unsigned int[face.mNumIndices];
+    face.mIndices[0] = static_cast<unsigned int>(std::atoi(node.attribute(XmlTag::v1).as_string()));
+    face.mIndices[1] = static_cast<unsigned int>(std::atoi(node.attribute(XmlTag::v2).as_string()));
+    face.mIndices[2] = static_cast<unsigned int>(std::atoi(node.attribute(XmlTag::v3).as_string()));
+
+    return face;
+}
+
+aiVector3D ReadVertex(XmlNode &node) {
+    aiVector3D vertex;
+    vertex.x = ai_strtof(node.attribute(XmlTag::x).as_string(), nullptr);
+    vertex.y = ai_strtof(node.attribute(XmlTag::y).as_string(), nullptr);
+    vertex.z = ai_strtof(node.attribute(XmlTag::z).as_string(), nullptr);
+
+    return vertex;
+}
+
+bool getNodeAttribute(const XmlNode &node, const std::string &attribute, std::string &value) {
+    pugi::xml_attribute objectAttribute = node.attribute(attribute.c_str());
+    if (!objectAttribute.empty()) {
+        value = objectAttribute.as_string();
+        return true;
+    }
+
+    return false;
+}
+
+bool getNodeAttribute(const XmlNode &node, const std::string &attribute, int &value) {
+    std::string strValue;
+    const bool ret = getNodeAttribute(node, attribute, strValue);
+    if (ret) {
+        value = std::atoi(strValue.c_str());
+        return true;
+    }
+
+    return false;
+}
+
+aiMatrix4x4 parseTransformMatrix(std::string matrixStr) {
+    // split the string
+    std::vector<float> numbers;
+    std::string currentNumber;
+    for (char c : matrixStr) {
+        if (c == ' ') {
+            if (!currentNumber.empty()) {
+                float f = std::stof(currentNumber);
+                numbers.push_back(f);
+                currentNumber.clear();
+            }
+        } else {
+            currentNumber.push_back(c);
+        }
+    }
+    if (!currentNumber.empty()) {
+        const float f = std::stof(currentNumber);
+        numbers.push_back(f);
+    }
+
+    aiMatrix4x4 transformMatrix;
+    transformMatrix.a1 = numbers[0];
+    transformMatrix.b1 = numbers[1];
+    transformMatrix.c1 = numbers[2];
+    transformMatrix.d1 = 0;
+
+    transformMatrix.a2 = numbers[3];
+    transformMatrix.b2 = numbers[4];
+    transformMatrix.c2 = numbers[5];
+    transformMatrix.d2 = 0;
+
+    transformMatrix.a3 = numbers[6];
+    transformMatrix.b3 = numbers[7];
+    transformMatrix.c3 = numbers[8];
+    transformMatrix.d3 = 0;
+
+    transformMatrix.a4 = numbers[9];
+    transformMatrix.b4 = numbers[10];
+    transformMatrix.c4 = numbers[11];
+    transformMatrix.d4 = 1;
+
+    return transformMatrix;
+}
+
+bool parseColor(const char *color, aiColor4D &diffuse) {
+    if (nullptr == color) {
+        return false;
+    }
+
+    if (!validateColorString(color)) {
+        return false;
+    }
+
+    if ('#' != color[0]) {
+        return false;
+    }
+
+    char r[3] = { color[1], color[2], '\0' };
+    diffuse.r = static_cast<ai_real>(strtol(r, nullptr, 16)) / ai_real(255.0);
+
+    char g[3] = { color[3], color[4], '\0' };
+    diffuse.g = static_cast<ai_real>(strtol(g, nullptr, 16)) / ai_real(255.0);
+
+    char b[3] = { color[5], color[6], '\0' };
+    diffuse.b = static_cast<ai_real>(strtol(b, nullptr, 16)) / ai_real(255.0);
+    const size_t len = strlen(color);
+    if (ColRGB_Len == len) {
+        return true;
+    }
+
+    char a[3] = { color[7], color[8], '\0' };
+    diffuse.a = static_cast<ai_real>(strtol(a, nullptr, 16)) / ai_real(255.0);
+
+    return true;
+}
+
+void assignDiffuseColor(XmlNode &node, aiMaterial *mat) {
+    const char *color = node.attribute(XmlTag::basematerials_displaycolor).as_string();
+    aiColor4D diffuse;
+    if (parseColor(color, diffuse)) {
+        mat->AddProperty<aiColor4D>(&diffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
+    }
+}
+
+} // namespace
+
+XmlSerializer::XmlSerializer(XmlParser *xmlParser) :
+        mResourcesDictionnary(),
+        mMeshCount(0),
+        mXmlParser(xmlParser) {
+    ai_assert(nullptr != xmlParser);
+}
+
+XmlSerializer::~XmlSerializer() {
+    for (auto &it : mResourcesDictionnary) {
+        delete it.second;
+    }
+}
+
+void XmlSerializer::ImportXml(aiScene *scene) {
+    if (nullptr == scene) {
+        return;
+    }
+    
+    scene->mRootNode = new aiNode(XmlTag::RootTag);
+    XmlNode node = mXmlParser->getRootNode().child(XmlTag::model);
+    if (node.empty()) {
+        return;
+    }
+
+    XmlNode resNode = node.child(XmlTag::resources);
+    for (auto &currentNode : resNode.children()) {
+        const std::string currentNodeName = currentNode.name();
+        if (currentNodeName == XmlTag::texture_2d) {
+            ReadEmbeddecTexture(currentNode);
+        } else if (currentNodeName == XmlTag::texture_group) {
+            ReadTextureGroup(currentNode);
+        } else if (currentNodeName == XmlTag::object) {
+            ReadObject(currentNode);
+        } else if (currentNodeName == XmlTag::basematerials) {
+            ReadBaseMaterials(currentNode);
+        } else if (currentNodeName == XmlTag::meta) {
+            ReadMetadata(currentNode);
+        }
+    }
+    StoreMaterialsInScene(scene);
+    XmlNode buildNode = node.child(XmlTag::build);
+    if (buildNode.empty()) {
+        return;
+    }
+
+    for (auto &currentNode : buildNode.children()) {
+        const std::string currentNodeName = currentNode.name();
+        if (currentNodeName == XmlTag::item) {
+            int objectId = IdNotSet;
+            std::string transformationMatrixStr;
+            aiMatrix4x4 transformationMatrix;
+            getNodeAttribute(currentNode, D3MF::XmlTag::objectid, objectId);
+            bool hasTransform = getNodeAttribute(currentNode, D3MF::XmlTag::transform, transformationMatrixStr);
+
+            auto it = mResourcesDictionnary.find(objectId);
+            if (it != mResourcesDictionnary.end() && it->second->getType() == ResourceType::RT_Object) {
+                Object *obj = static_cast<Object *>(it->second);
+                if (hasTransform) {
+                    transformationMatrix = parseTransformMatrix(transformationMatrixStr);
+                }
+
+                addObjectToNode(scene->mRootNode, obj, transformationMatrix);
+            }
+        }
+    }
+
+    // import the metadata
+    if (!mMetaData.empty()) {
+        const size_t numMeta = mMetaData.size();
+        scene->mMetaData = aiMetadata::Alloc(static_cast<unsigned int>(numMeta));
+        for (size_t i = 0; i < numMeta; ++i) {
+            aiString val(mMetaData[i].value);
+            scene->mMetaData->Set(static_cast<unsigned int>(i), mMetaData[i].name, val);
+        }
+    }
+
+    // import the meshes, materials are already stored
+    scene->mNumMeshes = static_cast<unsigned int>(mMeshCount);
+    if (scene->mNumMeshes != 0) {
+        scene->mMeshes = new aiMesh *[scene->mNumMeshes]();
+        for (auto &it : mResourcesDictionnary) {
+            if (it.second->getType() == ResourceType::RT_Object) {
+                Object *obj = static_cast<Object *>(it.second);
+                ai_assert(nullptr != obj);
+                for (unsigned int i = 0; i < obj->mMeshes.size(); ++i) {
+                    scene->mMeshes[obj->mMeshIndex[i]] = obj->mMeshes[i];
+                }
+            }
+        }
+    }
+}
+
+void XmlSerializer::addObjectToNode(aiNode *parent, Object *obj, aiMatrix4x4 nodeTransform) {
+    ai_assert(nullptr != obj);
+
+    aiNode *sceneNode = new aiNode(obj->mName);
+    sceneNode->mNumMeshes = static_cast<unsigned int>(obj->mMeshes.size());
+    sceneNode->mMeshes = new unsigned int[sceneNode->mNumMeshes];
+    std::copy(obj->mMeshIndex.begin(), obj->mMeshIndex.end(), sceneNode->mMeshes);
+
+    sceneNode->mTransformation = nodeTransform;
+    if (nullptr != parent) {
+        parent->addChildren(1, &sceneNode);
+    }
+
+    for (Assimp::D3MF::Component c : obj->mComponents) {
+        auto it = mResourcesDictionnary.find(c.mObjectId);
+        if (it != mResourcesDictionnary.end() && it->second->getType() == ResourceType::RT_Object) {
+            addObjectToNode(sceneNode, static_cast<Object *>(it->second), c.mTransformation);
+        }
+    }
+}
+
+void XmlSerializer::ReadObject(XmlNode &node) {
+    int id = IdNotSet, pid = IdNotSet, pindex = IdNotSet;
+    bool hasId = getNodeAttribute(node, XmlTag::id, id);
+    if (!hasId) {
+        return;
+    }
+
+    bool hasPid = getNodeAttribute(node, XmlTag::pid, pid);
+    bool hasPindex = getNodeAttribute(node, XmlTag::pindex, pindex);
+
+    Object *obj = new Object(id);
+    for (XmlNode &currentNode : node.children()) {
+        const std::string currentName = currentNode.name();
+        if (currentName == D3MF::XmlTag::mesh) {
+            auto mesh = ReadMesh(currentNode);
+            mesh->mName.Set(ai_to_string(id));
+
+            if (hasPid) {
+                auto it = mResourcesDictionnary.find(pid);
+                if (hasPindex && it != mResourcesDictionnary.end() && it->second->getType() == ResourceType::RT_BaseMaterials) {
+                    BaseMaterials *materials = static_cast<BaseMaterials *>(it->second);
+                    mesh->mMaterialIndex = materials->mMaterialIndex[pindex];
+                }
+            }
+
+            obj->mMeshes.push_back(mesh);
+            obj->mMeshIndex.push_back(mMeshCount);
+            mMeshCount++;
+        } else if (currentName == D3MF::XmlTag::components) {
+            for (XmlNode &currentSubNode : currentNode.children()) {
+                const std::string subNodeName = currentSubNode.name();
+                if (subNodeName == D3MF::XmlTag::component) {
+                    int objectId = IdNotSet;
+                    std::string componentTransformStr;
+                    aiMatrix4x4 componentTransform;
+                    if (getNodeAttribute(currentSubNode, D3MF::XmlTag::transform, componentTransformStr)) {
+                        componentTransform = parseTransformMatrix(componentTransformStr);
+                    }
+
+                    if (getNodeAttribute(currentSubNode, D3MF::XmlTag::objectid, objectId)) {
+                        obj->mComponents.push_back({ objectId, componentTransform });
+                    }
+                }
+            }
+        }
+    }
+
+    mResourcesDictionnary.insert(std::make_pair(id, obj));
+}
+
+aiMesh *XmlSerializer::ReadMesh(XmlNode &node) {
+    if (node.empty()) {
+        return nullptr;
+    }
+
+    aiMesh *mesh = new aiMesh();
+    for (XmlNode &currentNode : node.children()) {
+        const std::string currentName = currentNode.name();
+        if (currentName == XmlTag::vertices) {
+            ImportVertices(currentNode, mesh);
+        } else if (currentName == XmlTag::triangles) {
+            ImportTriangles(currentNode, mesh);
+        }
+    }
+
+    return mesh;
+}
+
+void XmlSerializer::ReadMetadata(XmlNode &node) {
+    pugi::xml_attribute attribute = node.attribute(D3MF::XmlTag::meta_name);
+    const std::string name = attribute.as_string();
+    const std::string value = node.value();
+    if (name.empty()) {
+        return;
+    }
+
+    MetaEntry entry;
+    entry.name = name;
+    entry.value = value;
+    mMetaData.push_back(entry);
+}
+
+void XmlSerializer::ImportVertices(XmlNode &node, aiMesh *mesh) {
+    ai_assert(nullptr != mesh);
+
+    std::vector<aiVector3D> vertices;
+    for (XmlNode &currentNode : node.children()) {
+        const std::string currentName = currentNode.name();
+        if (currentName == XmlTag::vertex) {
+            vertices.push_back(ReadVertex(currentNode));
+        }
+    }
+
+    mesh->mNumVertices = static_cast<unsigned int>(vertices.size());
+    mesh->mVertices = new aiVector3D[mesh->mNumVertices];
+    std::copy(vertices.begin(), vertices.end(), mesh->mVertices);
+}
+
+void XmlSerializer::ImportTriangles(XmlNode &node, aiMesh *mesh) {
+    std::vector<aiFace> faces;
+    for (XmlNode &currentNode : node.children()) {
+        const std::string currentName = currentNode.name();
+        if (currentName == XmlTag::triangle) {
+            int pid = IdNotSet, p1 = IdNotSet;
+            bool hasPid = getNodeAttribute(currentNode, D3MF::XmlTag::pid, pid);
+            bool hasP1 = getNodeAttribute(currentNode, D3MF::XmlTag::p1, p1);
+
+            if (hasPid && hasP1) {
+                auto it = mResourcesDictionnary.find(pid);
+                if (it != mResourcesDictionnary.end()) {
+                    if (it->second->getType() == ResourceType::RT_BaseMaterials) {
+                        BaseMaterials *baseMaterials = static_cast<BaseMaterials *>(it->second);
+                        mesh->mMaterialIndex = baseMaterials->mMaterialIndex[p1];
+                    } else if (it->second->getType() == ResourceType::RT_Texture2DGroup) {
+                        if (mesh->mTextureCoords[0] == nullptr) {
+                            Texture2DGroup *group = static_cast<Texture2DGroup *>(it->second);
+                            const std::string name = ai_to_string(group->mTexId);
+                            for (size_t i = 0; i < mMaterials.size(); ++i) {
+                                if (name == mMaterials[i]->GetName().C_Str()) {
+                                    mesh->mMaterialIndex = static_cast<unsigned int>(i);
+                                }
+                            }
+                            mesh->mTextureCoords[0] = new aiVector3D[group->mTex2dCoords.size()];
+                            for (unsigned int i = 0; i < group->mTex2dCoords.size(); ++i) {
+                                mesh->mTextureCoords[0][i] = aiVector3D(group->mTex2dCoords[i].x, group->mTex2dCoords[i].y, 0);
+                            }
+                        }
+                    } 
+                }
+            }
+
+            aiFace face = ReadTriangle(currentNode);
+            faces.push_back(face);
+        }
+    }
+
+    mesh->mNumFaces = static_cast<unsigned int>(faces.size());
+    mesh->mFaces = new aiFace[mesh->mNumFaces];
+    mesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
+
+    std::copy(faces.begin(), faces.end(), mesh->mFaces);
+}
+
+void XmlSerializer::ReadBaseMaterials(XmlNode &node) {
+    int id = IdNotSet;
+    if (getNodeAttribute(node, D3MF::XmlTag::id, id)) {
+        BaseMaterials *baseMaterials = new BaseMaterials(id);
+
+        for (XmlNode &currentNode : node.children()) {
+            const std::string currentName = currentNode.name();
+            if (currentName == XmlTag::basematerials_base) {
+                baseMaterials->mMaterialIndex.push_back(static_cast<unsigned int>(mMaterials.size()));
+                mMaterials.push_back(readMaterialDef(currentNode, id));
+            }
+        }
+
+        mResourcesDictionnary.insert(std::make_pair(id, baseMaterials));
+    }
+}
+
+void XmlSerializer::ReadEmbeddecTexture(XmlNode &node) {
+    if (node.empty()) {
+        return;
+    }
+
+    std::string value;
+    EmbeddedTexture *tex2D = nullptr;
+    if (XmlParser::getStdStrAttribute(node, XmlTag::id, value)) {
+        tex2D = new EmbeddedTexture(atoi(value.c_str()));
+    }
+    if (nullptr == tex2D) {
+        return;
+    }
+
+    if (XmlParser::getStdStrAttribute(node, XmlTag::path, value)) {
+        tex2D->mPath = value;
+    }
+    if (XmlParser::getStdStrAttribute(node, XmlTag::texture_content_type, value)) {
+        tex2D->mContentType = value;
+    }
+    if (XmlParser::getStdStrAttribute(node, XmlTag::texture_tilestyleu, value)) {
+        tex2D->mTilestyleU = value;
+    }
+    if (XmlParser::getStdStrAttribute(node, XmlTag::texture_tilestylev, value)) {
+        tex2D->mTilestyleV = value;
+    }
+    mEmbeddedTextures.emplace_back(tex2D);
+    StoreEmbeddedTexture(tex2D);
+}
+
+void XmlSerializer::StoreEmbeddedTexture(EmbeddedTexture *tex) {
+    aiMaterial *mat = new aiMaterial;
+    aiString s;
+    s.Set(ai_to_string(tex->mId).c_str());
+    mat->AddProperty(&s, AI_MATKEY_NAME);
+    const std::string name = "*" + tex->mPath;
+    s.Set(name);
+    mat->AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(0));
+
+    aiColor3D col;
+    mat->AddProperty<aiColor3D>(&col, 1, AI_MATKEY_COLOR_DIFFUSE);
+    mat->AddProperty<aiColor3D>(&col, 1, AI_MATKEY_COLOR_AMBIENT);
+    mat->AddProperty<aiColor3D>(&col, 1, AI_MATKEY_COLOR_EMISSIVE);
+    mat->AddProperty<aiColor3D>(&col, 1, AI_MATKEY_COLOR_SPECULAR);
+    mMaterials.emplace_back(mat);
+}
+
+void XmlSerializer::ReadTextureCoords2D(XmlNode &node, Texture2DGroup *tex2DGroup) {
+    if (node.empty() || nullptr == tex2DGroup) {
+        return;
+    }
+
+    int id = IdNotSet;
+    if (XmlParser::getIntAttribute(node, "texid", id)) {
+        tex2DGroup->mTexId = id;
+    }
+
+    double value = 0.0;
+    for (XmlNode currentNode : node.children()) {
+        const std::string currentName = currentNode.name();
+        aiVector2D texCoord;
+        if (currentName == XmlTag::texture_2d_coord) {
+            XmlParser::getDoubleAttribute(currentNode, XmlTag::texture_cuurd_u, value);
+            texCoord.x = (ai_real)value;
+            XmlParser::getDoubleAttribute(currentNode, XmlTag::texture_cuurd_v, value);
+            texCoord.y = (ai_real)value;
+            tex2DGroup->mTex2dCoords.push_back(texCoord);
+        }
+    }
+}
+
+void XmlSerializer::ReadTextureGroup(XmlNode &node) {
+    if (node.empty()) {
+        return;
+    }
+
+    int id = IdNotSet;
+    if (!XmlParser::getIntAttribute(node, XmlTag::id, id)) {
+        return;
+    }
+
+    Texture2DGroup *group = new Texture2DGroup(id);
+    ReadTextureCoords2D(node, group);
+    mResourcesDictionnary.insert(std::make_pair(id, group));
+}
+
+aiMaterial *XmlSerializer::readMaterialDef(XmlNode &node, unsigned int basematerialsId) {
+    aiMaterial *material = new aiMaterial();
+    material->mNumProperties = 0;
+    std::string name;
+    bool hasName = getNodeAttribute(node, D3MF::XmlTag::basematerials_name, name);
+
+    std::string stdMaterialName;
+    const std::string strId(ai_to_string(basematerialsId));
+    stdMaterialName += "id";
+    stdMaterialName += strId;
+    stdMaterialName += "_";
+    if (hasName) {
+        stdMaterialName += std::string(name);
+    } else {
+        stdMaterialName += "basemat_";
+        stdMaterialName += ai_to_string(mMaterials.size());
+    }
+
+    aiString assimpMaterialName(stdMaterialName);
+    material->AddProperty(&assimpMaterialName, AI_MATKEY_NAME);
+
+    assignDiffuseColor(node, material);
+
+    return material;
+}
+
+void XmlSerializer::StoreMaterialsInScene(aiScene *scene) {
+    if (nullptr == scene || mMaterials.empty()) {
+        return;
+    }
+
+    scene->mNumMaterials = static_cast<unsigned int>(mMaterials.size());
+    scene->mMaterials = new aiMaterial *[scene->mNumMaterials];
+    for (size_t i = 0; i < mMaterials.size(); ++i) {
+        scene->mMaterials[i] = mMaterials[i];
+    }
+}
+
+} // namespace D3MF
+} // namespace Assimp
diff --git a/Engine/lib/assimp/code/AssetLib/3MF/XmlSerializer.h b/Engine/lib/assimp/code/AssetLib/3MF/XmlSerializer.h
new file mode 100644
index 000000000..6cf6a70a9
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/3MF/XmlSerializer.h
@@ -0,0 +1,96 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+#pragma once
+
+#include <assimp/XmlParser.h>
+#include <assimp/mesh.h>
+#include <vector>
+#include <map>
+
+struct aiNode;
+struct aiMesh;
+struct aiMaterial;
+
+namespace Assimp {
+namespace D3MF {
+
+class Resource;
+class D3MFOpcPackage;
+class Object;
+class Texture2DGroup;
+class EmbeddedTexture;
+
+class XmlSerializer {
+public:
+    XmlSerializer(XmlParser *xmlParser);
+    ~XmlSerializer();
+    void ImportXml(aiScene *scene);
+
+private:
+    void addObjectToNode(aiNode *parent, Object *obj, aiMatrix4x4 nodeTransform);
+    void ReadObject(XmlNode &node);
+    aiMesh *ReadMesh(XmlNode &node);
+    void ReadMetadata(XmlNode &node);
+    void ImportVertices(XmlNode &node, aiMesh *mesh);
+    void ImportTriangles(XmlNode &node, aiMesh *mesh);
+    void ReadBaseMaterials(XmlNode &node);
+    void ReadEmbeddecTexture(XmlNode &node);
+    void StoreEmbeddedTexture(EmbeddedTexture *tex);
+    void ReadTextureCoords2D(XmlNode &node, Texture2DGroup *tex2DGroup);
+    void ReadTextureGroup(XmlNode &node);
+    aiMaterial *readMaterialDef(XmlNode &node, unsigned int basematerialsId);
+    void StoreMaterialsInScene(aiScene *scene);
+
+private:
+    struct MetaEntry {
+        std::string name;
+        std::string value;
+    };
+    std::vector<MetaEntry> mMetaData;
+    std::vector<EmbeddedTexture *> mEmbeddedTextures;
+    std::vector<aiMaterial *> mMaterials;
+    std::map<unsigned int, Resource *> mResourcesDictionnary;
+    unsigned int mMeshCount;
+    XmlParser *mXmlParser;
+};
+
+} // namespace D3MF
+} // namespace Assimp
diff --git a/Engine/lib/assimp/code/AC/ACLoader.cpp b/Engine/lib/assimp/code/AssetLib/AC/ACLoader.cpp
similarity index 52%
rename from Engine/lib/assimp/code/AC/ACLoader.cpp
rename to Engine/lib/assimp/code/AssetLib/AC/ACLoader.cpp
index d4c4bd1a6..e93624b3e 100644
--- a/Engine/lib/assimp/code/AC/ACLoader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/AC/ACLoader.cpp
@@ -1,12 +1,9 @@
-
 /*
 ---------------------------------------------------------------------------
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -44,25 +41,23 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** @file Implementation of the AC3D importer class */
 
-
-
 #ifndef ASSIMP_BUILD_NO_AC_IMPORTER
 
 // internal headers
 #include "ACLoader.h"
-#include <assimp/ParsingUtils.h>
-#include <assimp/fast_atof.h>
-#include <assimp/Subdivision.h>
 #include "Common/Importer.h"
 #include <assimp/BaseImporter.h>
-#include <assimp/Importer.hpp>
+#include <assimp/ParsingUtils.h>
+#include <assimp/Subdivision.h>
+#include <assimp/config.h>
+#include <assimp/fast_atof.h>
+#include <assimp/importerdesc.h>
 #include <assimp/light.h>
-#include <assimp/DefaultLogger.hpp>
 #include <assimp/material.h>
 #include <assimp/scene.h>
-#include <assimp/config.h>
+#include <assimp/DefaultLogger.hpp>
 #include <assimp/IOSystem.hpp>
-#include <assimp/importerdesc.h>
+#include <assimp/Importer.hpp>
 #include <memory>
 
 using namespace Assimp;
@@ -82,116 +77,103 @@ static const aiImporterDesc desc = {
 
 // ------------------------------------------------------------------------------------------------
 // skip to the next token
-#define AI_AC_SKIP_TO_NEXT_TOKEN() \
-    if (!SkipSpaces(&buffer)) \
-    { \
-        ASSIMP_LOG_ERROR("AC3D: Unexpected EOF/EOL"); \
-        continue; \
+inline const char *AcSkipToNextToken(const char *buffer) {
+    if (!SkipSpaces(&buffer)) {
+        ASSIMP_LOG_ERROR("AC3D: Unexpected EOF/EOL");
     }
+    return buffer;
+}
 
 // ------------------------------------------------------------------------------------------------
 // read a string (may be enclosed in double quotation marks). buffer must point to "
-#define AI_AC_GET_STRING(out) \
-    if (*buffer == '\0') { \
-        throw DeadlyImportError("AC3D: Unexpected EOF in string"); \
-    } \
-    ++buffer; \
-    const char* sz = buffer; \
-    while ('\"' != *buffer) \
-    { \
-        if (IsLineEnd( *buffer )) \
-        { \
-            ASSIMP_LOG_ERROR("AC3D: Unexpected EOF/EOL in string"); \
-            out = "ERROR"; \
-            break; \
-        } \
-        ++buffer; \
-    } \
-    if (IsLineEnd( *buffer ))continue; \
-    out = std::string(sz,(unsigned int)(buffer-sz)); \
+inline const char *AcGetString(const char *buffer, std::string &out) {
+    if (*buffer == '\0') {
+        throw DeadlyImportError("AC3D: Unexpected EOF in string");
+    }
+    ++buffer;
+    const char *sz = buffer;
+    while ('\"' != *buffer) {
+        if (IsLineEnd(*buffer)) {
+            ASSIMP_LOG_ERROR("AC3D: Unexpected EOF/EOL in string");
+            out = "ERROR";
+            break;
+        }
+        ++buffer;
+    }
+    if (IsLineEnd(*buffer)) {
+        return buffer;
+    }
+    out = std::string(sz, (unsigned int)(buffer - sz));
     ++buffer;
 
+    return buffer;
+}
 
 // ------------------------------------------------------------------------------------------------
 // read 1 to n floats prefixed with an optional predefined identifier
-#define AI_AC_CHECKED_LOAD_FLOAT_ARRAY(name,name_length,num,out) \
-    AI_AC_SKIP_TO_NEXT_TOKEN(); \
-    if (name_length) \
-    { \
-        if (strncmp(buffer,name,name_length) || !IsSpace(buffer[name_length])) \
-        { \
-            ASSIMP_LOG_ERROR("AC3D: Unexpexted token. " name " was expected."); \
-            continue; \
-        } \
-        buffer += name_length+1; \
-    } \
-    for (unsigned int i = 0; i < num;++i) \
-    { \
-        AI_AC_SKIP_TO_NEXT_TOKEN(); \
-        buffer = fast_atoreal_move<float>(buffer,((float*)out)[i]); \
+template <class T>
+inline const char *TAcCheckedLoadFloatArray(const char *buffer, const char *name, size_t name_length, size_t num, T *out) {
+    buffer = AcSkipToNextToken(buffer);
+    if (0 != name_length) {
+        if (0 != strncmp(buffer, name, name_length) || !IsSpace(buffer[name_length])) {
+            ASSIMP_LOG_ERROR("AC3D: Unexpected token. ", name, " was expected.");
+            return buffer;
+        }
+        buffer += name_length + 1;
+    }
+    for (unsigned int _i = 0; _i < num; ++_i) {
+        buffer = AcSkipToNextToken(buffer);
+        buffer = fast_atoreal_move<float>(buffer, ((float *)out)[_i]);
     }
 
+    return buffer;
+}
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-AC3DImporter::AC3DImporter()
-    : buffer(),
-    configSplitBFCull(),
-    configEvalSubdivision(),
-    mNumMeshes(),
-    mLights(),
-    lights(),
-    groups(),
-    polys(),
-    worlds()
-{
+AC3DImporter::AC3DImporter() :
+        buffer(),
+        configSplitBFCull(),
+        configEvalSubdivision(),
+        mNumMeshes(),
+        mLights(),
+        mLightsCounter(0),
+        mGroupsCounter(0),
+        mPolysCounter(0),
+        mWorldsCounter(0) {
     // nothing to be done here
 }
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-AC3DImporter::~AC3DImporter()
-{
+AC3DImporter::~AC3DImporter() {
     // nothing to be done here
 }
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool AC3DImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
-{
-    std::string extension = GetExtension(pFile);
-
-    // fixme: are acc and ac3d *really* used? Some sources say they are
-    if(extension == "ac" || extension == "ac3d" || extension == "acc") {
-        return true;
-    }
-    if (!extension.length() || checkSig) {
-        uint32_t token = AI_MAKE_MAGIC("AC3D");
-        return CheckMagicToken(pIOHandler,pFile,&token,1,0);
-    }
-    return false;
+bool AC3DImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
+    static const uint32_t tokens[] = { AI_MAKE_MAGIC("AC3D") };
+    return CheckMagicToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------
 // Loader meta information
-const aiImporterDesc* AC3DImporter::GetInfo () const
-{
+const aiImporterDesc *AC3DImporter::GetInfo() const {
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get a pointer to the next line from the file
-bool AC3DImporter::GetNextLine( )
-{
+bool AC3DImporter::GetNextLine() {
     SkipLine(&buffer);
     return SkipSpaces(&buffer);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Parse an object section in an AC file
-void AC3DImporter::LoadObjectSection(std::vector<Object>& objects)
-{
-    if (!TokenMatch(buffer,"OBJECT",6))
+void AC3DImporter::LoadObjectSection(std::vector<Object> &objects) {
+    if (!TokenMatch(buffer, "OBJECT", 6))
         return;
 
     SkipSpaces(&buffer);
@@ -199,147 +181,111 @@ void AC3DImporter::LoadObjectSection(std::vector<Object>& objects)
     ++mNumMeshes;
 
     objects.push_back(Object());
-    Object& obj = objects.back();
+    Object &obj = objects.back();
 
-    aiLight* light = NULL;
-    if (!ASSIMP_strincmp(buffer,"light",5))
-    {
+    aiLight *light = nullptr;
+    if (!ASSIMP_strincmp(buffer, "light", 5)) {
         // This is a light source. Add it to the list
         mLights->push_back(light = new aiLight());
 
         // Return a point light with no attenuation
         light->mType = aiLightSource_POINT;
-        light->mColorDiffuse = light->mColorSpecular = aiColor3D(1.f,1.f,1.f);
+        light->mColorDiffuse = light->mColorSpecular = aiColor3D(1.f, 1.f, 1.f);
         light->mAttenuationConstant = 1.f;
 
         // Generate a default name for both the light source and the node
         // FIXME - what's the right way to print a size_t? Is 'zu' universally available? stick with the safe version.
-        light->mName.length = ::ai_snprintf(light->mName.data, MAXLEN, "ACLight_%i",static_cast<unsigned int>(mLights->size())-1);
-        obj.name = std::string( light->mName.data );
+        light->mName.length = ::ai_snprintf(light->mName.data, MAXLEN, "ACLight_%i", static_cast<unsigned int>(mLights->size()) - 1);
+        obj.name = std::string(light->mName.data);
 
-        ASSIMP_LOG_DEBUG("AC3D: Light source encountered");
+        ASSIMP_LOG_VERBOSE_DEBUG("AC3D: Light source encountered");
         obj.type = Object::Light;
-    }
-    else if (!ASSIMP_strincmp(buffer,"group",5))
-    {
+    } else if (!ASSIMP_strincmp(buffer, "group", 5)) {
         obj.type = Object::Group;
-    }
-    else if (!ASSIMP_strincmp(buffer,"world",5))
-    {
+    } else if (!ASSIMP_strincmp(buffer, "world", 5)) {
         obj.type = Object::World;
-    }
-    else obj.type = Object::Poly;
-    while (GetNextLine())
-    {
-        if (TokenMatch(buffer,"kids",4))
-        {
+    } else
+        obj.type = Object::Poly;
+    while (GetNextLine()) {
+        if (TokenMatch(buffer, "kids", 4)) {
             SkipSpaces(&buffer);
-            unsigned int num = strtoul10(buffer,&buffer);
+            unsigned int num = strtoul10(buffer, &buffer);
             GetNextLine();
-            if (num)
-            {
+            if (num) {
                 // load the children of this object recursively
                 obj.children.reserve(num);
                 for (unsigned int i = 0; i < num; ++i)
                     LoadObjectSection(obj.children);
             }
             return;
-        }
-        else if (TokenMatch(buffer,"name",4))
-        {
+        } else if (TokenMatch(buffer, "name", 4)) {
             SkipSpaces(&buffer);
-            AI_AC_GET_STRING(obj.name);
+            buffer = AcGetString(buffer, obj.name);
 
             // If this is a light source, we'll also need to store
             // the name of the node in it.
-            if (light)
-            {
+            if (light) {
                 light->mName.Set(obj.name);
             }
-        }
-        else if (TokenMatch(buffer,"texture",7))
-        {
+        } else if (TokenMatch(buffer, "texture", 7)) {
             SkipSpaces(&buffer);
-            AI_AC_GET_STRING(obj.texture);
-        }
-        else if (TokenMatch(buffer,"texrep",6))
-        {
+            buffer = AcGetString(buffer, obj.texture);
+        } else if (TokenMatch(buffer, "texrep", 6)) {
             SkipSpaces(&buffer);
-            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("",0,2,&obj.texRepeat);
+            buffer = TAcCheckedLoadFloatArray(buffer, "", 0, 2, &obj.texRepeat);
             if (!obj.texRepeat.x || !obj.texRepeat.y)
-                obj.texRepeat = aiVector2D (1.f,1.f);
-        }
-        else if (TokenMatch(buffer,"texoff",6))
-        {
+                obj.texRepeat = aiVector2D(1.f, 1.f);
+        } else if (TokenMatch(buffer, "texoff", 6)) {
             SkipSpaces(&buffer);
-            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("",0,2,&obj.texOffset);
-        }
-        else if (TokenMatch(buffer,"rot",3))
-        {
+            buffer = TAcCheckedLoadFloatArray(buffer, "", 0, 2, &obj.texOffset);
+        } else if (TokenMatch(buffer, "rot", 3)) {
             SkipSpaces(&buffer);
-            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("",0,9,&obj.rotation);
-        }
-        else if (TokenMatch(buffer,"loc",3))
-        {
+            buffer = TAcCheckedLoadFloatArray(buffer, "", 0, 9, &obj.rotation);
+        } else if (TokenMatch(buffer, "loc", 3)) {
             SkipSpaces(&buffer);
-            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("",0,3,&obj.translation);
-        }
-        else if (TokenMatch(buffer,"subdiv",6))
-        {
+            buffer = TAcCheckedLoadFloatArray(buffer, "", 0, 3, &obj.translation);
+        } else if (TokenMatch(buffer, "subdiv", 6)) {
             SkipSpaces(&buffer);
-            obj.subDiv = strtoul10(buffer,&buffer);
-        }
-        else if (TokenMatch(buffer,"crease",6))
-        {
+            obj.subDiv = strtoul10(buffer, &buffer);
+        } else if (TokenMatch(buffer, "crease", 6)) {
             SkipSpaces(&buffer);
             obj.crease = fast_atof(buffer);
-        }
-        else if (TokenMatch(buffer,"numvert",7))
-        {
+        } else if (TokenMatch(buffer, "numvert", 7)) {
             SkipSpaces(&buffer);
 
-            unsigned int t = strtoul10(buffer,&buffer);
+            unsigned int t = strtoul10(buffer, &buffer);
             if (t >= AI_MAX_ALLOC(aiVector3D)) {
                 throw DeadlyImportError("AC3D: Too many vertices, would run out of memory");
             }
             obj.vertices.reserve(t);
-            for (unsigned int i = 0; i < t;++i)
-            {
-                if (!GetNextLine())
-                {
+            for (unsigned int i = 0; i < t; ++i) {
+                if (!GetNextLine()) {
                     ASSIMP_LOG_ERROR("AC3D: Unexpected EOF: not all vertices have been parsed yet");
                     break;
-                }
-                else if (!IsNumeric(*buffer))
-                {
+                } else if (!IsNumeric(*buffer)) {
                     ASSIMP_LOG_ERROR("AC3D: Unexpected token: not all vertices have been parsed yet");
                     --buffer; // make sure the line is processed a second time
                     break;
                 }
                 obj.vertices.push_back(aiVector3D());
-                aiVector3D& v = obj.vertices.back();
-                AI_AC_CHECKED_LOAD_FLOAT_ARRAY("",0,3,&v.x);
+                aiVector3D &v = obj.vertices.back();
+                buffer = TAcCheckedLoadFloatArray(buffer, "", 0, 3, &v.x);
             }
-        }
-        else if (TokenMatch(buffer,"numsurf",7))
-        {
+        } else if (TokenMatch(buffer, "numsurf", 7)) {
             SkipSpaces(&buffer);
 
             bool Q3DWorkAround = false;
 
-            const unsigned int t = strtoul10(buffer,&buffer);
+            const unsigned int t = strtoul10(buffer, &buffer);
             obj.surfaces.reserve(t);
-            for (unsigned int i = 0; i < t;++i)
-            {
+            for (unsigned int i = 0; i < t; ++i) {
                 GetNextLine();
-                if (!TokenMatch(buffer,"SURF",4))
-                {
+                if (!TokenMatch(buffer, "SURF", 4)) {
                     // FIX: this can occur for some files - Quick 3D for
                     // example writes no surf chunks
-                    if (!Q3DWorkAround)
-                    {
+                    if (!Q3DWorkAround) {
                         ASSIMP_LOG_WARN("AC3D: SURF token was expected");
-                        ASSIMP_LOG_DEBUG("Continuing with Quick3D Workaround enabled");
+                        ASSIMP_LOG_VERBOSE_DEBUG("Continuing with Quick3D Workaround enabled");
                     }
                     --buffer; // make sure the line is processed a second time
                     // break; --- see fix notes above
@@ -348,27 +294,20 @@ void AC3DImporter::LoadObjectSection(std::vector<Object>& objects)
                 }
                 SkipSpaces(&buffer);
                 obj.surfaces.push_back(Surface());
-                Surface& surf = obj.surfaces.back();
+                Surface &surf = obj.surfaces.back();
                 surf.flags = strtoul_cppstyle(buffer);
 
-                while (1)
-                {
-                    if(!GetNextLine())
-                    {
+                while (1) {
+                    if (!GetNextLine()) {
                         throw DeadlyImportError("AC3D: Unexpected EOF: surface is incomplete");
                     }
-                    if (TokenMatch(buffer,"mat",3))
-                    {
+                    if (TokenMatch(buffer, "mat", 3)) {
                         SkipSpaces(&buffer);
                         surf.mat = strtoul10(buffer);
-                    }
-                    else if (TokenMatch(buffer,"refs",4))
-                    {
+                    } else if (TokenMatch(buffer, "refs", 4)) {
                         // --- see fix notes above
-                        if (Q3DWorkAround)
-                        {
-                            if (!surf.entries.empty())
-                            {
+                        if (Q3DWorkAround) {
+                            if (!surf.entries.empty()) {
                                 buffer -= 6;
                                 break;
                             }
@@ -380,24 +319,19 @@ void AC3DImporter::LoadObjectSection(std::vector<Object>& objects)
 
                         obj.numRefs += m;
 
-                        for (unsigned int k = 0; k < m; ++k)
-                        {
-                            if(!GetNextLine())
-                            {
+                        for (unsigned int k = 0; k < m; ++k) {
+                            if (!GetNextLine()) {
                                 ASSIMP_LOG_ERROR("AC3D: Unexpected EOF: surface references are incomplete");
                                 break;
                             }
                             surf.entries.push_back(Surface::SurfaceEntry());
-                            Surface::SurfaceEntry& entry = surf.entries.back();
+                            Surface::SurfaceEntry &entry = surf.entries.back();
 
-                            entry.first = strtoul10(buffer,&buffer);
+                            entry.first = strtoul10(buffer, &buffer);
                             SkipSpaces(&buffer);
-                            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("",0,2,&entry.second);
+                            buffer = TAcCheckedLoadFloatArray(buffer, "", 0, 2, &entry.second);
                         }
-                    }
-                    else
-                    {
-
+                    } else {
                         --buffer; // make sure the line is processed a second time
                         break;
                     }
@@ -410,65 +344,58 @@ void AC3DImporter::LoadObjectSection(std::vector<Object>& objects)
 
 // ------------------------------------------------------------------------------------------------
 // Convert a material from AC3DImporter::Material to aiMaterial
-void AC3DImporter::ConvertMaterial(const Object& object,
-    const Material& matSrc,
-    aiMaterial& matDest)
-{
+void AC3DImporter::ConvertMaterial(const Object &object,
+        const Material &matSrc,
+        aiMaterial &matDest) {
     aiString s;
 
-    if (matSrc.name.length())
-    {
+    if (matSrc.name.length()) {
         s.Set(matSrc.name);
-        matDest.AddProperty(&s,AI_MATKEY_NAME);
+        matDest.AddProperty(&s, AI_MATKEY_NAME);
     }
-    if (object.texture.length())
-    {
+    if (object.texture.length()) {
         s.Set(object.texture);
-        matDest.AddProperty(&s,AI_MATKEY_TEXTURE_DIFFUSE(0));
+        matDest.AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(0));
 
         // UV transformation
         if (1.f != object.texRepeat.x || 1.f != object.texRepeat.y ||
-            object.texOffset.x        || object.texOffset.y)
-        {
+                object.texOffset.x || object.texOffset.y) {
             aiUVTransform transform;
             transform.mScaling = object.texRepeat;
             transform.mTranslation = object.texOffset;
-            matDest.AddProperty(&transform,1,AI_MATKEY_UVTRANSFORM_DIFFUSE(0));
+            matDest.AddProperty(&transform, 1, AI_MATKEY_UVTRANSFORM_DIFFUSE(0));
         }
     }
 
-    matDest.AddProperty<aiColor3D>(&matSrc.rgb,1, AI_MATKEY_COLOR_DIFFUSE);
-    matDest.AddProperty<aiColor3D>(&matSrc.amb,1, AI_MATKEY_COLOR_AMBIENT);
-    matDest.AddProperty<aiColor3D>(&matSrc.emis,1,AI_MATKEY_COLOR_EMISSIVE);
-    matDest.AddProperty<aiColor3D>(&matSrc.spec,1,AI_MATKEY_COLOR_SPECULAR);
+    matDest.AddProperty<aiColor3D>(&matSrc.rgb, 1, AI_MATKEY_COLOR_DIFFUSE);
+    matDest.AddProperty<aiColor3D>(&matSrc.amb, 1, AI_MATKEY_COLOR_AMBIENT);
+    matDest.AddProperty<aiColor3D>(&matSrc.emis, 1, AI_MATKEY_COLOR_EMISSIVE);
+    matDest.AddProperty<aiColor3D>(&matSrc.spec, 1, AI_MATKEY_COLOR_SPECULAR);
 
-    int n;
-    if (matSrc.shin)
-    {
+    int n = -1;
+    if (matSrc.shin) {
         n = aiShadingMode_Phong;
-        matDest.AddProperty<float>(&matSrc.shin,1,AI_MATKEY_SHININESS);
+        matDest.AddProperty<float>(&matSrc.shin, 1, AI_MATKEY_SHININESS);
+    } else {
+        n = aiShadingMode_Gouraud;
     }
-    else n = aiShadingMode_Gouraud;
-    matDest.AddProperty<int>(&n,1,AI_MATKEY_SHADING_MODEL);
+    matDest.AddProperty<int>(&n, 1, AI_MATKEY_SHADING_MODEL);
 
     float f = 1.f - matSrc.trans;
-    matDest.AddProperty<float>(&f,1,AI_MATKEY_OPACITY);
+    matDest.AddProperty<float>(&f, 1, AI_MATKEY_OPACITY);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Converts the loaded data to the internal verbose representation
-aiNode* AC3DImporter::ConvertObjectSection(Object& object,
-    std::vector<aiMesh*>& meshes,
-    std::vector<aiMaterial*>& outMaterials,
-    const std::vector<Material>& materials,
-    aiNode* parent)
-{
-    aiNode* node = new aiNode();
+aiNode *AC3DImporter::ConvertObjectSection(Object &object,
+        std::vector<aiMesh *> &meshes,
+        std::vector<aiMaterial *> &outMaterials,
+        const std::vector<Material> &materials,
+        aiNode *parent) {
+    aiNode *node = new aiNode();
     node->mParent = parent;
-    if (object.vertices.size())
-    {
-        if (!object.surfaces.size() || !object.numRefs)
-        {
+    if (object.vertices.size()) {
+        if (!object.surfaces.size() || !object.numRefs) {
             /* " An object with 7 vertices (no surfaces, no materials defined).
                  This is a good way of getting point data into AC3D.
                  The Vertex->create convex-surface/object can be used on these
@@ -479,17 +406,16 @@ aiNode* AC3DImporter::ConvertObjectSection(Object& object,
              */
 
             ASSIMP_LOG_INFO("AC3D: No surfaces defined in object definition, "
-                "a point list is returned");
+                            "a point list is returned");
 
             meshes.push_back(new aiMesh());
-            aiMesh* mesh = meshes.back();
+            aiMesh *mesh = meshes.back();
 
             mesh->mNumFaces = mesh->mNumVertices = (unsigned int)object.vertices.size();
-            aiFace* faces = mesh->mFaces = new aiFace[mesh->mNumFaces];
-            aiVector3D* verts = mesh->mVertices = new aiVector3D[mesh->mNumVertices];
+            aiFace *faces = mesh->mFaces = new aiFace[mesh->mNumFaces];
+            aiVector3D *verts = mesh->mVertices = new aiVector3D[mesh->mNumVertices];
 
-            for (unsigned int i = 0; i < mesh->mNumVertices;++i,++faces,++verts)
-            {
+            for (unsigned int i = 0; i < mesh->mNumVertices; ++i, ++faces, ++verts) {
                 *verts = object.vertices[i];
                 faces->mNumIndices = 1;
                 faces->mIndices = new unsigned int[1];
@@ -502,89 +428,88 @@ aiNode* AC3DImporter::ConvertObjectSection(Object& object,
             mesh->mMaterialIndex = 0;
             outMaterials.push_back(new aiMaterial());
             ConvertMaterial(object, materials[0], *outMaterials.back());
-        }
-        else
-        {
+        } else {
             // need to generate one or more meshes for this object.
             // find out how many different materials we have
-            typedef std::pair< unsigned int, unsigned int > IntPair;
-            typedef std::vector< IntPair > MatTable;
-            MatTable needMat(materials.size(),IntPair(0,0));
+            typedef std::pair<unsigned int, unsigned int> IntPair;
+            typedef std::vector<IntPair> MatTable;
+            MatTable needMat(materials.size(), IntPair(0, 0));
 
-            std::vector<Surface>::iterator it,end = object.surfaces.end();
-            std::vector<Surface::SurfaceEntry>::iterator it2,end2;
+            std::vector<Surface>::iterator it, end = object.surfaces.end();
+            std::vector<Surface::SurfaceEntry>::iterator it2, end2;
 
-            for (it = object.surfaces.begin(); it != end; ++it)
-            {
+            for (it = object.surfaces.begin(); it != end; ++it) {
                 unsigned int idx = (*it).mat;
-                if (idx >= needMat.size())
-                {
+                if (idx >= needMat.size()) {
                     ASSIMP_LOG_ERROR("AC3D: material index is out of range");
                     idx = 0;
                 }
-                if ((*it).entries.empty())
-                {
+                if ((*it).entries.empty()) {
                     ASSIMP_LOG_WARN("AC3D: surface her zero vertex references");
                 }
 
                 // validate all vertex indices to make sure we won't crash here
-                for (it2  = (*it).entries.begin(),
-                     end2 = (*it).entries.end(); it2 != end2; ++it2)
-                {
-                    if ((*it2).first >= object.vertices.size())
-                    {
+                for (it2 = (*it).entries.begin(),
+                    end2 = (*it).entries.end();
+                        it2 != end2; ++it2) {
+                    if ((*it2).first >= object.vertices.size()) {
                         ASSIMP_LOG_WARN("AC3D: Invalid vertex reference");
                         (*it2).first = 0;
                     }
                 }
 
-                if (!needMat[idx].first)++node->mNumMeshes;
+                if (!needMat[idx].first) {
+                    ++node->mNumMeshes;
+                }
 
-                switch ((*it).flags & 0xf)
-                {
+                switch ((*it).GetType()) {
                     // closed line
-                case 0x1:
-
-                    needMat[idx].first  += (unsigned int)(*it).entries.size();
-                    needMat[idx].second += (unsigned int)(*it).entries.size()<<1u;
+                case Surface::ClosedLine:
+                    needMat[idx].first += (unsigned int)(*it).entries.size();
+                    needMat[idx].second += (unsigned int)(*it).entries.size() << 1u;
                     break;
 
                     // unclosed line
-                case 0x2:
-
-                    needMat[idx].first  += (unsigned int)(*it).entries.size()-1;
-                    needMat[idx].second += ((unsigned int)(*it).entries.size()-1)<<1u;
+                case Surface::OpenLine:
+                    needMat[idx].first += (unsigned int)(*it).entries.size() - 1;
+                    needMat[idx].second += ((unsigned int)(*it).entries.size() - 1) << 1u;
+                    break;
+
+                    // triangle strip
+                case Surface::TriangleStrip:
+                    needMat[idx].first += (unsigned int)(*it).entries.size() - 2;
+                    needMat[idx].second += ((unsigned int)(*it).entries.size() - 2) * 3;
                     break;
 
-                    // 0 == polygon, else unknown
                 default:
+                    // Coerce unknowns to a polygon and warn
+                    ASSIMP_LOG_WARN("AC3D: The type flag of a surface is unknown: ", (*it).flags);
+                    (*it).flags &= ~(Surface::Mask);
+                    // fallthrough
 
-                    if ((*it).flags & 0xf)
-                    {
-                        ASSIMP_LOG_WARN("AC3D: The type flag of a surface is unknown");
-                        (*it).flags &= ~(0xf);
-                    }
-
+                    // polygon
+                case Surface::Polygon:
                     // the number of faces increments by one, the number
                     // of vertices by surface.numref.
                     needMat[idx].first++;
                     needMat[idx].second += (unsigned int)(*it).entries.size();
                 };
             }
-            unsigned int* pip = node->mMeshes = new unsigned int[node->mNumMeshes];
+            unsigned int *pip = node->mMeshes = new unsigned int[node->mNumMeshes];
             unsigned int mat = 0;
             const size_t oldm = meshes.size();
             for (MatTable::const_iterator cit = needMat.begin(), cend = needMat.end();
-                cit != cend; ++cit, ++mat)
-            {
-                if (!(*cit).first)continue;
+                    cit != cend; ++cit, ++mat) {
+                if (!(*cit).first) {
+                    continue;
+                }
 
                 // allocate a new aiMesh object
                 *pip++ = (unsigned int)meshes.size();
-                aiMesh* mesh = new aiMesh();
+                aiMesh *mesh = new aiMesh();
                 meshes.push_back(mesh);
 
-                mesh->mMaterialIndex = (unsigned int)outMaterials.size();
+                mesh->mMaterialIndex = static_cast<unsigned int>(outMaterials.size());
                 outMaterials.push_back(new aiMaterial());
                 ConvertMaterial(object, materials[mat], *outMaterials.back());
 
@@ -595,7 +520,7 @@ aiNode* AC3DImporter::ConvertObjectSection(Object& object,
                 } else if (mesh->mNumFaces > AI_MAX_ALLOC(aiFace)) {
                     throw DeadlyImportError("AC3D: Too many faces, would run out of memory");
                 }
-                aiFace* faces = mesh->mFaces = new aiFace[mesh->mNumFaces];
+                aiFace *faces = mesh->mFaces = new aiFace[mesh->mNumFaces];
 
                 mesh->mNumVertices = (*cit).second;
                 if (mesh->mNumVertices == 0) {
@@ -603,35 +528,30 @@ aiNode* AC3DImporter::ConvertObjectSection(Object& object,
                 } else if (mesh->mNumVertices > AI_MAX_ALLOC(aiVector3D)) {
                     throw DeadlyImportError("AC3D: Too many vertices, would run out of memory");
                 }
-                aiVector3D* vertices = mesh->mVertices = new aiVector3D[mesh->mNumVertices];
+                aiVector3D *vertices = mesh->mVertices = new aiVector3D[mesh->mNumVertices];
                 unsigned int cur = 0;
 
                 // allocate UV coordinates, but only if the texture name for the
                 // surface is not empty
-                aiVector3D* uv = NULL;
-                if(object.texture.length())
-                {
+                aiVector3D *uv = nullptr;
+                if (object.texture.length()) {
                     uv = mesh->mTextureCoords[0] = new aiVector3D[mesh->mNumVertices];
                     mesh->mNumUVComponents[0] = 2;
                 }
 
-                for (it = object.surfaces.begin(); it != end; ++it)
-                {
-                    if (mat == (*it).mat)
-                    {
-                        const Surface& src = *it;
+                for (it = object.surfaces.begin(); it != end; ++it) {
+                    if (mat == (*it).mat) {
+                        const Surface &src = *it;
 
                         // closed polygon
-                        unsigned int type = (*it).flags & 0xf;
-                        if (!type)
-                        {
-                            aiFace& face = *faces++;
-                            if((face.mNumIndices = (unsigned int)src.entries.size()))
-                            {
+                        uint8_t type = (*it).GetType();
+                        if (type == Surface::Polygon) {
+                            aiFace &face = *faces++;
+                            face.mNumIndices = (unsigned int)src.entries.size();
+                            if (0 != face.mNumIndices) {
                                 face.mIndices = new unsigned int[face.mNumIndices];
-                                for (unsigned int i = 0; i < face.mNumIndices;++i,++vertices)
-                                {
-                                    const Surface::SurfaceEntry& entry = src.entries[i];
+                                for (unsigned int i = 0; i < face.mNumIndices; ++i, ++vertices) {
+                                    const Surface::SurfaceEntry &entry = src.entries[i];
                                     face.mIndices[i] = cur++;
 
                                     // copy vertex positions
@@ -640,28 +560,81 @@ aiNode* AC3DImporter::ConvertObjectSection(Object& object,
                                     }
                                     *vertices = object.vertices[entry.first] + object.translation;
 
-
                                     // copy texture coordinates
-                                    if (uv)
-                                    {
-                                        uv->x =  entry.second.x;
-                                        uv->y =  entry.second.y;
+                                    if (uv) {
+                                        uv->x = entry.second.x;
+                                        uv->y = entry.second.y;
                                         ++uv;
                                     }
                                 }
                             }
-                        }
-                        else
-                        {
+                        } else if (type == Surface::TriangleStrip) {
+                            for (unsigned int i = 0; i < (unsigned int)src.entries.size() - 2; ++i) {
+                                const Surface::SurfaceEntry &entry1 = src.entries[i];
+                                const Surface::SurfaceEntry &entry2 = src.entries[i + 1];
+                                const Surface::SurfaceEntry &entry3 = src.entries[i + 2];
 
-                            it2  = (*it).entries.begin();
+                                // skip degenerate triangles
+                                if (object.vertices[entry1.first] == object.vertices[entry2.first] ||
+                                        object.vertices[entry1.first] == object.vertices[entry3.first] ||
+                                        object.vertices[entry2.first] == object.vertices[entry3.first]) {
+                                    mesh->mNumFaces--;
+                                    mesh->mNumVertices -= 3;
+                                    continue;
+                                }
+
+                                aiFace &face = *faces++;
+                                face.mNumIndices = 3;
+                                face.mIndices = new unsigned int[face.mNumIndices];
+                                face.mIndices[0] = cur++;
+                                face.mIndices[1] = cur++;
+                                face.mIndices[2] = cur++;
+                                if (!(i & 1)) {
+                                    *vertices++ = object.vertices[entry1.first] + object.translation;
+                                    if (uv) {
+                                        uv->x = entry1.second.x;
+                                        uv->y = entry1.second.y;
+                                        ++uv;
+                                    }
+                                    *vertices++ = object.vertices[entry2.first] + object.translation;
+                                    if (uv) {
+                                        uv->x = entry2.second.x;
+                                        uv->y = entry2.second.y;
+                                        ++uv;
+                                    }
+                                } else {
+                                    *vertices++ = object.vertices[entry2.first] + object.translation;
+                                    if (uv) {
+                                        uv->x = entry2.second.x;
+                                        uv->y = entry2.second.y;
+                                        ++uv;
+                                    }
+                                    *vertices++ = object.vertices[entry1.first] + object.translation;
+                                    if (uv) {
+                                        uv->x = entry1.second.x;
+                                        uv->y = entry1.second.y;
+                                        ++uv;
+                                    }
+                                }
+                                if (static_cast<unsigned>(vertices - mesh->mVertices) >= mesh->mNumVertices) {
+                                    throw DeadlyImportError("AC3D: Invalid number of vertices");
+                                }
+                                *vertices++ = object.vertices[entry3.first] + object.translation;
+                                if (uv) {
+                                    uv->x = entry3.second.x;
+                                    uv->y = entry3.second.y;
+                                    ++uv;
+                                }
+                            }
+                        } else {
+
+                            it2 = (*it).entries.begin();
 
                             // either a closed or an unclosed line
                             unsigned int tmp = (unsigned int)(*it).entries.size();
-                            if (0x2 == type)--tmp;
-                            for (unsigned int m = 0; m < tmp;++m)
-                            {
-                                aiFace& face = *faces++;
+                            if (Surface::OpenLine == type) --tmp;
+                            for (unsigned int m = 0; m < tmp; ++m) {
+                                aiFace &face = *faces++;
 
                                 face.mNumIndices = 2;
                                 face.mIndices = new unsigned int[2];
@@ -669,35 +642,31 @@ aiNode* AC3DImporter::ConvertObjectSection(Object& object,
                                 face.mIndices[1] = cur++;
 
                                 // copy vertex positions
-                                if (it2 == (*it).entries.end() ) {
+                                if (it2 == (*it).entries.end()) {
                                     throw DeadlyImportError("AC3D: Bad line");
                                 }
                                 ai_assert((*it2).first < object.vertices.size());
                                 *vertices++ = object.vertices[(*it2).first];
 
                                 // copy texture coordinates
-                                if (uv)
-                                {
-                                    uv->x =  (*it2).second.x;
-                                    uv->y =  (*it2).second.y;
+                                if (uv) {
+                                    uv->x = (*it2).second.x;
+                                    uv->y = (*it2).second.y;
                                     ++uv;
                                 }
 
-
-                                if (0x1 == type && tmp-1 == m)
-                                {
+                                if (Surface::ClosedLine == type && tmp - 1 == m) {
                                     // if this is a closed line repeat its beginning now
-                                    it2  = (*it).entries.begin();
-                                }
-                                else ++it2;
+                                    it2 = (*it).entries.begin();
+                                } else
+                                    ++it2;
 
                                 // second point
                                 *vertices++ = object.vertices[(*it2).first];
 
-                                if (uv)
-                                {
-                                    uv->x =  (*it2).second.x;
-                                    uv->y =  (*it2).second.y;
+                                if (uv) {
+                                    uv->x = (*it2).second.x;
+                                    uv->y = (*it2).second.y;
                                     ++uv;
                                 }
                             }
@@ -709,20 +678,18 @@ aiNode* AC3DImporter::ConvertObjectSection(Object& object,
             // Now apply catmull clark subdivision if necessary. We split meshes into
             // materials which is not done by AC3D during smoothing, so we need to
             // collect all meshes using the same material group.
-            if (object.subDiv)  {
+            if (object.subDiv) {
                 if (configEvalSubdivision) {
                     std::unique_ptr<Subdivider> div(Subdivider::Create(Subdivider::CATMULL_CLARKE));
-                    ASSIMP_LOG_INFO("AC3D: Evaluating subdivision surface: "+object.name);
+                    ASSIMP_LOG_INFO("AC3D: Evaluating subdivision surface: ", object.name);
 
-                    std::vector<aiMesh*> cpy(meshes.size()-oldm,NULL);
-                    div->Subdivide(&meshes[oldm],cpy.size(),&cpy.front(),object.subDiv,true);
-                    std::copy(cpy.begin(),cpy.end(),meshes.begin()+oldm);
+                    std::vector<aiMesh *> cpy(meshes.size() - oldm, nullptr);
+                    div->Subdivide(&meshes[oldm], cpy.size(), &cpy.front(), object.subDiv, true);
+                    std::copy(cpy.begin(), cpy.end(), meshes.begin() + oldm);
 
                     // previous meshes are deleted vy Subdivide().
-                }
-                else {
-                    ASSIMP_LOG_INFO("AC3D: Letting the subdivision surface untouched due to my configuration: "
-                        +object.name);
+                } else {
+                    ASSIMP_LOG_INFO("AC3D: Letting the subdivision surface untouched due to my configuration: ", object.name);
                 }
             }
         }
@@ -730,48 +697,42 @@ aiNode* AC3DImporter::ConvertObjectSection(Object& object,
 
     if (object.name.length())
         node->mName.Set(object.name);
-    else
-    {
+    else {
         // generate a name depending on the type of the node
-        switch (object.type)
-        {
+        switch (object.type) {
         case Object::Group:
-            node->mName.length = ::ai_snprintf(node->mName.data, MAXLEN, "ACGroup_%i",groups++);
+            node->mName.length = ::ai_snprintf(node->mName.data, MAXLEN, "ACGroup_%i", mGroupsCounter++);
             break;
         case Object::Poly:
-            node->mName.length = ::ai_snprintf(node->mName.data, MAXLEN, "ACPoly_%i",polys++);
+            node->mName.length = ::ai_snprintf(node->mName.data, MAXLEN, "ACPoly_%i", mPolysCounter++);
             break;
         case Object::Light:
-            node->mName.length = ::ai_snprintf(node->mName.data, MAXLEN, "ACLight_%i",lights++);
+            node->mName.length = ::ai_snprintf(node->mName.data, MAXLEN, "ACLight_%i", mLightsCounter++);
             break;
 
             // there shouldn't be more than one world, but we don't care
         case Object::World:
-            node->mName.length = ::ai_snprintf(node->mName.data, MAXLEN, "ACWorld_%i",worlds++);
+            node->mName.length = ::ai_snprintf(node->mName.data, MAXLEN, "ACWorld_%i", mWorldsCounter++);
             break;
         }
     }
 
-
     // setup the local transformation matrix of the object
     // compute the transformation offset to the parent node
-    node->mTransformation = aiMatrix4x4 ( object.rotation );
+    node->mTransformation = aiMatrix4x4(object.rotation);
 
-    if (object.type == Object::Group || !object.numRefs)
-    {
+    if (object.type == Object::Group || !object.numRefs) {
         node->mTransformation.a4 = object.translation.x;
         node->mTransformation.b4 = object.translation.y;
         node->mTransformation.c4 = object.translation.z;
     }
 
     // add children to the object
-    if (object.children.size())
-    {
+    if (object.children.size()) {
         node->mNumChildren = (unsigned int)object.children.size();
-        node->mChildren = new aiNode*[node->mNumChildren];
-        for (unsigned int i = 0; i < node->mNumChildren;++i)
-        {
-            node->mChildren[i] = ConvertObjectSection(object.children[i],meshes,outMaterials,materials,node);
+        node->mChildren = new aiNode *[node->mNumChildren];
+        for (unsigned int i = 0; i < node->mNumChildren; ++i) {
+            node->mChildren[i] = ConvertObjectSection(object.children[i], meshes, outMaterials, materials, node);
         }
     }
 
@@ -779,41 +740,40 @@ aiNode* AC3DImporter::ConvertObjectSection(Object& object,
 }
 
 // ------------------------------------------------------------------------------------------------
-void AC3DImporter::SetupProperties(const Importer* pImp)
-{
-    configSplitBFCull = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_AC_SEPARATE_BFCULL,1) ? true : false;
-    configEvalSubdivision =  pImp->GetPropertyInteger(AI_CONFIG_IMPORT_AC_EVAL_SUBDIVISION,1) ? true : false;
+void AC3DImporter::SetupProperties(const Importer *pImp) {
+    configSplitBFCull = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_AC_SEPARATE_BFCULL, 1) ? true : false;
+    configEvalSubdivision = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_AC_EVAL_SUBDIVISION, 1) ? true : false;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void AC3DImporter::InternReadFile( const std::string& pFile,
-    aiScene* pScene, IOSystem* pIOHandler)
-{
-    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));
+void AC3DImporter::InternReadFile(const std::string &pFile,
+        aiScene *pScene, IOSystem *pIOHandler) {
+    std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));
 
     // Check whether we can read from the file
-    if( file.get() == NULL)
-        throw DeadlyImportError( "Failed to open AC3D file " + pFile + ".");
+    if (file.get() == nullptr) {
+        throw DeadlyImportError("Failed to open AC3D file ", pFile, ".");
+    }
 
     // allocate storage and copy the contents of the file to a memory buffer
     std::vector<char> mBuffer2;
-    TextFileToBuffer(file.get(),mBuffer2);
+    TextFileToBuffer(file.get(), mBuffer2);
 
     buffer = &mBuffer2[0];
     mNumMeshes = 0;
 
-    lights = polys = worlds = groups = 0;
+    mLightsCounter = mPolysCounter = mWorldsCounter = mGroupsCounter = 0;
 
-    if (::strncmp(buffer,"AC3D",4)) {
+    if (::strncmp(buffer, "AC3D", 4)) {
         throw DeadlyImportError("AC3D: No valid AC3D file, magic sequence not found");
     }
 
     // print the file format version to the console
-    unsigned int version = HexDigitToDecimal( buffer[4] );
+    unsigned int version = HexDigitToDecimal(buffer[4]);
     char msg[3];
-    ASSIMP_itoa10(msg,3,version);
-    ASSIMP_LOG_INFO_F("AC3D file format version: ", msg);
+    ASSIMP_itoa10(msg, 3, version);
+    ASSIMP_LOG_INFO("AC3D file format version: ", msg);
 
     std::vector<Material> materials;
     materials.reserve(5);
@@ -821,89 +781,84 @@ void AC3DImporter::InternReadFile( const std::string& pFile,
     std::vector<Object> rootObjects;
     rootObjects.reserve(5);
 
-    std::vector<aiLight*> lights;
-    mLights = & lights;
+    std::vector<aiLight *> lights;
+    mLights = &lights;
 
-    while (GetNextLine())
-    {
-        if (TokenMatch(buffer,"MATERIAL",8))
-        {
+    while (GetNextLine()) {
+        if (TokenMatch(buffer, "MATERIAL", 8)) {
             materials.push_back(Material());
-            Material& mat = materials.back();
+            Material &mat = materials.back();
 
             // manually parse the material ... sscanf would use the buldin atof ...
             // Format: (name) rgb %f %f %f  amb %f %f %f  emis %f %f %f  spec %f %f %f  shi %d  trans %f
 
-            AI_AC_SKIP_TO_NEXT_TOKEN();
-            if ('\"' == *buffer)
-            {
-                AI_AC_GET_STRING(mat.name);
-                AI_AC_SKIP_TO_NEXT_TOKEN();
+            buffer = AcSkipToNextToken(buffer);
+            if ('\"' == *buffer) {
+                buffer = AcGetString(buffer, mat.name);
+                buffer = AcSkipToNextToken(buffer);
             }
 
-            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("rgb",3,3,&mat.rgb);
-            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("amb",3,3,&mat.amb);
-            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("emis",4,3,&mat.emis);
-            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("spec",4,3,&mat.spec);
-            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("shi",3,1,&mat.shin);
-            AI_AC_CHECKED_LOAD_FLOAT_ARRAY("trans",5,1,&mat.trans);
+            buffer = TAcCheckedLoadFloatArray(buffer, "rgb", 3, 3, &mat.rgb);
+            buffer = TAcCheckedLoadFloatArray(buffer, "amb", 3, 3, &mat.amb);
+            buffer = TAcCheckedLoadFloatArray(buffer, "emis", 4, 3, &mat.emis);
+            buffer = TAcCheckedLoadFloatArray(buffer, "spec", 4, 3, &mat.spec);
+            buffer = TAcCheckedLoadFloatArray(buffer, "shi", 3, 1, &mat.shin);
+            buffer = TAcCheckedLoadFloatArray(buffer, "trans", 5, 1, &mat.trans);
         }
         LoadObjectSection(rootObjects);
     }
 
-    if (rootObjects.empty() || !mNumMeshes)
-    {
+    if (rootObjects.empty() || !mNumMeshes) {
         throw DeadlyImportError("AC3D: No meshes have been loaded");
     }
-    if (materials.empty())
-    {
+    if (materials.empty()) {
         ASSIMP_LOG_WARN("AC3D: No material has been found");
         materials.push_back(Material());
     }
 
-    mNumMeshes += (mNumMeshes>>2u) + 1;
-    std::vector<aiMesh*> meshes;
+    mNumMeshes += (mNumMeshes >> 2u) + 1;
+    std::vector<aiMesh *> meshes;
     meshes.reserve(mNumMeshes);
 
-    std::vector<aiMaterial*> omaterials;
+    std::vector<aiMaterial *> omaterials;
     materials.reserve(mNumMeshes);
 
     // generate a dummy root if there are multiple objects on the top layer
-    Object* root;
+    Object *root;
     if (1 == rootObjects.size())
         root = &rootObjects[0];
-    else
-    {
+    else {
         root = new Object();
     }
 
     // now convert the imported stuff to our output data structure
-    pScene->mRootNode = ConvertObjectSection(*root,meshes,omaterials,materials);
-    if (1 != rootObjects.size())delete root;
+    pScene->mRootNode = ConvertObjectSection(*root, meshes, omaterials, materials);
+    if (1 != rootObjects.size()) {
+        delete root;
+    }
 
-    if (!::strncmp( pScene->mRootNode->mName.data, "Node", 4))
+    if (!::strncmp(pScene->mRootNode->mName.data, "Node", 4)) {
         pScene->mRootNode->mName.Set("<AC3DWorld>");
+    }
 
     // copy meshes
-    if (meshes.empty())
-    {
+    if (meshes.empty()) {
         throw DeadlyImportError("An unknown error occurred during converting");
     }
     pScene->mNumMeshes = (unsigned int)meshes.size();
-    pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];
-    ::memcpy(pScene->mMeshes,&meshes[0],pScene->mNumMeshes*sizeof(void*));
+    pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
+    ::memcpy(pScene->mMeshes, &meshes[0], pScene->mNumMeshes * sizeof(void *));
 
     // copy materials
     pScene->mNumMaterials = (unsigned int)omaterials.size();
-    pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials];
-    ::memcpy(pScene->mMaterials,&omaterials[0],pScene->mNumMaterials*sizeof(void*));
+    pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials];
+    ::memcpy(pScene->mMaterials, &omaterials[0], pScene->mNumMaterials * sizeof(void *));
 
     // copy lights
     pScene->mNumLights = (unsigned int)lights.size();
-    if (lights.size())
-    {
-        pScene->mLights = new aiLight*[lights.size()];
-        ::memcpy(pScene->mLights,&lights[0],lights.size()*sizeof(void*));
+    if (lights.size()) {
+        pScene->mLights = new aiLight *[lights.size()];
+        ::memcpy(pScene->mLights, &lights[0], lights.size() * sizeof(void *));
     }
 }
 
diff --git a/Engine/lib/assimp/code/AC/ACLoader.h b/Engine/lib/assimp/code/AssetLib/AC/ACLoader.h
similarity index 73%
rename from Engine/lib/assimp/code/AC/ACLoader.h
rename to Engine/lib/assimp/code/AssetLib/AC/ACLoader.h
index cab2c3ae5..aabc114e3 100644
--- a/Engine/lib/assimp/code/AC/ACLoader.h
+++ b/Engine/lib/assimp/code/AssetLib/AC/ACLoader.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -56,29 +55,23 @@ struct aiMesh;
 struct aiMaterial;
 struct aiLight;
 
-
-namespace Assimp    {
+namespace Assimp {
 
 // ---------------------------------------------------------------------------
 /** AC3D (*.ac) importer class
 */
-class AC3DImporter : public BaseImporter
-{
+class AC3DImporter : public BaseImporter {
 public:
     AC3DImporter();
-    ~AC3DImporter();
-
-
+    ~AC3DImporter() override;
 
     // Represents an AC3D material
-    struct Material
-    {
-        Material()
-            :   rgb     (0.6f,0.6f,0.6f)
-            ,   spec    (1.f,1.f,1.f)
-            ,   shin    (0.f)
-            ,   trans   (0.f)
-        {}
+    struct Material {
+        Material() :
+                rgb(0.6f, 0.6f, 0.6f),
+                spec(1.f, 1.f, 1.f),
+                shin(0.f),
+                trans(0.f) {}
 
         // base color of the material
         aiColor3D rgb;
@@ -103,43 +96,50 @@ public:
     };
 
     // Represents an AC3D surface
-    struct Surface
-    {
-        Surface()
-            :   mat     (0)
-            ,   flags   (0)
-        {}
+    struct Surface {
+        Surface() :
+                mat(0),
+                flags(0) {}
 
-        unsigned int mat,flags;
+        unsigned int mat, flags;
 
-        typedef std::pair<unsigned int, aiVector2D > SurfaceEntry;
-        std::vector< SurfaceEntry > entries;
+        typedef std::pair<unsigned int, aiVector2D> SurfaceEntry;
+        std::vector<SurfaceEntry> entries;
+
+        // Type is low nibble of flags
+        enum Type : uint8_t {
+            Polygon = 0x0,
+            ClosedLine = 0x1,
+            OpenLine = 0x2,
+            TriangleStrip = 0x4, // ACC extension (TORCS and Speed Dreams)
+
+            Mask = 0xf,
+        };
+
+        inline uint8_t GetType() const { return (flags & Mask); }
     };
 
     // Represents an AC3D object
-    struct Object
-    {
-        Object()
-            :   type    (World)
-            ,   name( "" )
-            ,   children()
-            ,   texture( "" )
-            ,   texRepeat( 1.f, 1.f )
-            ,   texOffset( 0.0f, 0.0f )
-            ,   rotation()
-            ,   translation()
-            ,   vertices()
-            ,   surfaces()
-            ,   numRefs (0)
-            ,   subDiv  (0)
-            ,   crease()
-        {}
+    struct Object {
+        Object() :
+                type(World),
+                name(),
+                children(),
+                texture(),
+                texRepeat(1.f, 1.f),
+                texOffset(0.0f, 0.0f),
+                rotation(),
+                translation(),
+                vertices(),
+                surfaces(),
+                numRefs(0),
+                subDiv(0),
+                crease() {}
 
         // Type description
-        enum Type
-        {
+        enum Type {
             World = 0x0,
-            Poly  = 0x1,
+            Poly = 0x1,
             Group = 0x2,
             Light = 0x4
         } type;
@@ -179,37 +179,33 @@ public:
         float crease;
     };
 
-
 public:
-
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
      * See BaseImporter::CanRead() for details.
      */
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
+            bool checkSig) const override;
 
 protected:
-
     // -------------------------------------------------------------------
     /** Return importer meta information.
      * See #BaseImporter::GetInfo for the details */
-    const aiImporterDesc* GetInfo () const;
+    const aiImporterDesc *GetInfo() const override;
 
     // -------------------------------------------------------------------
     /** Imports the given file into the given scene structure.
      * See BaseImporter::InternReadFile() for details*/
-    void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
+    void InternReadFile(const std::string &pFile, aiScene *pScene,
+            IOSystem *pIOHandler) override;
 
     // -------------------------------------------------------------------
     /** Called prior to ReadFile().
     * The function is a request to the importer to update its configuration
     * basing on the Importer's configuration property list.*/
-    void SetupProperties(const Importer* pImp);
+    void SetupProperties(const Importer *pImp) override;
 
 private:
-
     // -------------------------------------------------------------------
     /** Get the next line from the file.
      *  @return false if the end of the file was reached*/
@@ -220,7 +216,7 @@ private:
      *  load subobjects, the method returns after a 'kids 0' was
      *  encountered.
      *  @objects List of output objects*/
-    void LoadObjectSection(std::vector<Object>& objects);
+    void LoadObjectSection(std::vector<Object> &objects);
 
     // -------------------------------------------------------------------
     /** Convert all objects into meshes and nodes.
@@ -229,26 +225,24 @@ private:
      *  @param outMaterials List of output materials
      *  @param materials Material list
      *  @param Scenegraph node for the object */
-    aiNode* ConvertObjectSection(Object& object,
-        std::vector<aiMesh*>& meshes,
-        std::vector<aiMaterial*>& outMaterials,
-        const std::vector<Material>& materials,
-        aiNode* parent = NULL);
+    aiNode *ConvertObjectSection(Object &object,
+            std::vector<aiMesh *> &meshes,
+            std::vector<aiMaterial *> &outMaterials,
+            const std::vector<Material> &materials,
+            aiNode *parent = nullptr);
 
     // -------------------------------------------------------------------
     /** Convert a material
      *  @param object Current object
      *  @param matSrc Source material description
      *  @param matDest Destination material to be filled */
-    void ConvertMaterial(const Object& object,
-        const Material& matSrc,
-        aiMaterial& matDest);
+    void ConvertMaterial(const Object &object,
+            const Material &matSrc,
+            aiMaterial &matDest);
 
 private:
-
-
     // points to the next data line
-    const char* buffer;
+    const char *buffer;
 
     // Configuration option: if enabled, up to two meshes
     // are generated per material: those faces who have
@@ -265,10 +259,10 @@ private:
     unsigned int mNumMeshes;
 
     // current list of light sources
-    std::vector<aiLight*>* mLights;
+    std::vector<aiLight *> *mLights;
 
     // name counters
-    unsigned int lights, groups, polys, worlds;
+    unsigned int mLightsCounter, mGroupsCounter, mPolysCounter, mWorldsCounter;
 };
 
 } // end of namespace Assimp
diff --git a/Engine/lib/assimp/code/AssetLib/AMF/AMFImporter.cpp b/Engine/lib/assimp/code/AssetLib/AMF/AMFImporter.cpp
new file mode 100644
index 000000000..4103dcdf4
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/AMF/AMFImporter.cpp
@@ -0,0 +1,524 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+#ifndef ASSIMP_BUILD_NO_AMF_IMPORTER
+
+// Header files, Assimp.
+#include "AMFImporter.hpp"
+
+#include <assimp/DefaultIOSystem.h>
+#include <assimp/fast_atof.h>
+#include <assimp/StringUtils.h>
+
+// Header files, stdlib.
+#include <memory>
+
+namespace Assimp {
+
+const aiImporterDesc AMFImporter::Description = {
+    "Additive manufacturing file format(AMF) Importer",
+    "smalcom",
+    "",
+    "See documentation in source code. Chapter: Limitations.",
+    aiImporterFlags_SupportTextFlavour | aiImporterFlags_LimitedSupport | aiImporterFlags_Experimental,
+    0,
+    0,
+    0,
+    0,
+    "amf"
+};
+
+void AMFImporter::Clear() {
+    mNodeElement_Cur = nullptr;
+    mUnit.clear();
+    mMaterial_Converted.clear();
+    mTexture_Converted.clear();
+    // Delete all elements
+    if (!mNodeElement_List.empty()) {
+        for (AMFNodeElementBase *ne : mNodeElement_List) {
+            delete ne;
+        }
+
+        mNodeElement_List.clear();
+    }
+}
+
+AMFImporter::AMFImporter() AI_NO_EXCEPT :
+        mNodeElement_Cur(nullptr),
+        mXmlParser(nullptr),
+        mUnit(),
+        mVersion(),
+        mMaterial_Converted(),
+        mTexture_Converted() {
+    // empty
+}
+
+AMFImporter::~AMFImporter() {
+    delete mXmlParser;
+    // Clear() is accounting if data already is deleted. So, just check again if all data is deleted.
+    Clear();
+}
+
+/*********************************************************************************************************************************************/
+/************************************************************ Functions: find set ************************************************************/
+/*********************************************************************************************************************************************/
+
+bool AMFImporter::Find_NodeElement(const std::string &pID, const AMFNodeElementBase::EType pType, AMFNodeElementBase **pNodeElement) const {
+    for (AMFNodeElementBase *ne : mNodeElement_List) {
+        if ((ne->ID == pID) && (ne->Type == pType)) {
+            if (pNodeElement != nullptr) {
+                *pNodeElement = ne;
+            }
+
+            return true;
+        }
+    } // for(CAMFImporter_NodeElement* ne: mNodeElement_List)
+
+    return false;
+}
+
+bool AMFImporter::Find_ConvertedNode(const std::string &pID, NodeArray &nodeArray, aiNode **pNode) const {
+    aiString node_name(pID.c_str());
+    for (aiNode *node : nodeArray) {
+        if (node->mName == node_name) {
+            if (pNode != nullptr) {
+                *pNode = node;
+            }
+
+            return true;
+        }
+    } // for(aiNode* node: pNodeList)
+
+    return false;
+}
+
+bool AMFImporter::Find_ConvertedMaterial(const std::string &pID, const SPP_Material **pConvertedMaterial) const {
+    for (const SPP_Material &mat : mMaterial_Converted) {
+        if (mat.ID == pID) {
+            if (pConvertedMaterial != nullptr) {
+                *pConvertedMaterial = &mat;
+            }
+
+            return true;
+        }
+    } // for(const SPP_Material& mat: mMaterial_Converted)
+
+    return false;
+}
+
+/*********************************************************************************************************************************************/
+/************************************************************ Functions: throw set ***********************************************************/
+/*********************************************************************************************************************************************/
+
+void AMFImporter::Throw_CloseNotFound(const std::string &nodeName) {
+    throw DeadlyImportError("Close tag for node <" + nodeName + "> not found. Seems file is corrupt.");
+}
+
+void AMFImporter::Throw_IncorrectAttr(const std::string &nodeName, const std::string &attrName) {
+    throw DeadlyImportError("Node <" + nodeName + "> has incorrect attribute \"" + attrName + "\".");
+}
+
+void AMFImporter::Throw_IncorrectAttrValue(const std::string &nodeName, const std::string &attrName) {
+    throw DeadlyImportError("Attribute \"" + attrName + "\" in node <" + nodeName + "> has incorrect value.");
+}
+
+void AMFImporter::Throw_MoreThanOnceDefined(const std::string &nodeName, const std::string &pNodeType, const std::string &pDescription) {
+    throw DeadlyImportError("\"" + pNodeType + "\" node can be used only once in " + nodeName + ". Description: " + pDescription);
+}
+
+void AMFImporter::Throw_ID_NotFound(const std::string &pID) const {
+    throw DeadlyImportError("Not found node with name \"", pID, "\".");
+}
+
+/*********************************************************************************************************************************************/
+/************************************************************* Functions: XML set ************************************************************/
+/*********************************************************************************************************************************************/
+
+void AMFImporter::XML_CheckNode_MustHaveChildren(pugi::xml_node &node) {
+    if (node.children().begin() == node.children().end()) {
+        throw DeadlyImportError(std::string("Node <") + node.name() + "> must have children.");
+    }
+}
+
+bool AMFImporter::XML_SearchNode(const std::string &nodeName) {
+    return nullptr != mXmlParser->findNode(nodeName);
+}
+
+void AMFImporter::ParseHelper_FixTruncatedFloatString(const char *pInStr, std::string &pOutString) {
+    size_t instr_len;
+
+    pOutString.clear();
+    instr_len = strlen(pInStr);
+    if (!instr_len) return;
+
+    pOutString.reserve(instr_len * 3 / 2);
+    // check and correct floats in format ".x". Must be "x.y".
+    if (pInStr[0] == '.') pOutString.push_back('0');
+
+    pOutString.push_back(pInStr[0]);
+    for (size_t ci = 1; ci < instr_len; ci++) {
+        if ((pInStr[ci] == '.') && ((pInStr[ci - 1] == ' ') || (pInStr[ci - 1] == '-') || (pInStr[ci - 1] == '+') || (pInStr[ci - 1] == '\t'))) {
+            pOutString.push_back('0');
+            pOutString.push_back('.');
+        } else {
+            pOutString.push_back(pInStr[ci]);
+        }
+    }
+}
+
+static bool ParseHelper_Decode_Base64_IsBase64(const char pChar) {
+    return (isalnum((unsigned char)pChar) || (pChar == '+') || (pChar == '/'));
+}
+
+void AMFImporter::ParseHelper_Decode_Base64(const std::string &pInputBase64, std::vector<uint8_t> &pOutputData) const {
+    // With help from
+    // René Nyffenegger http://www.adp-gmbh.ch/cpp/common/base64.html
+    const std::string base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+    uint8_t tidx = 0;
+    uint8_t arr4[4], arr3[3];
+
+    // check input data
+    if (pInputBase64.size() % 4) throw DeadlyImportError("Base64-encoded data must have size multiply of four.");
+    // prepare output place
+    pOutputData.clear();
+    pOutputData.reserve(pInputBase64.size() / 4 * 3);
+
+    for (size_t in_len = pInputBase64.size(), in_idx = 0; (in_len > 0) && (pInputBase64[in_idx] != '='); in_len--) {
+        if (ParseHelper_Decode_Base64_IsBase64(pInputBase64[in_idx])) {
+            arr4[tidx++] = pInputBase64[in_idx++];
+            if (tidx == 4) {
+                for (tidx = 0; tidx < 4; tidx++)
+                    arr4[tidx] = (uint8_t)base64_chars.find(arr4[tidx]);
+
+                arr3[0] = (arr4[0] << 2) + ((arr4[1] & 0x30) >> 4);
+                arr3[1] = ((arr4[1] & 0x0F) << 4) + ((arr4[2] & 0x3C) >> 2);
+                arr3[2] = ((arr4[2] & 0x03) << 6) + arr4[3];
+                for (tidx = 0; tidx < 3; tidx++)
+                    pOutputData.push_back(arr3[tidx]);
+
+                tidx = 0;
+            } // if(tidx == 4)
+        } // if(ParseHelper_Decode_Base64_IsBase64(pInputBase64[in_idx]))
+        else {
+            in_idx++;
+        } // if(ParseHelper_Decode_Base64_IsBase64(pInputBase64[in_idx])) else
+    }
+
+    if (tidx) {
+        for (uint8_t i = tidx; i < 4; i++)
+            arr4[i] = 0;
+        for (uint8_t i = 0; i < 4; i++)
+            arr4[i] = (uint8_t)(base64_chars.find(arr4[i]));
+
+        arr3[0] = (arr4[0] << 2) + ((arr4[1] & 0x30) >> 4);
+        arr3[1] = ((arr4[1] & 0x0F) << 4) + ((arr4[2] & 0x3C) >> 2);
+        arr3[2] = ((arr4[2] & 0x03) << 6) + arr4[3];
+        for (uint8_t i = 0; i < (tidx - 1); i++)
+            pOutputData.push_back(arr3[i]);
+    }
+}
+
+void AMFImporter::ParseFile(const std::string &pFile, IOSystem *pIOHandler) {
+    std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));
+
+    // Check whether we can read from the file
+    if (file.get() == nullptr) {
+        throw DeadlyImportError("Failed to open AMF file ", pFile, ".");
+    }
+
+    mXmlParser = new XmlParser();
+    if (!mXmlParser->parse(file.get())) {
+        delete mXmlParser;
+        mXmlParser = nullptr;
+        throw DeadlyImportError("Failed to create XML reader for file ", pFile, ".");
+    }
+
+    // Start reading, search for root tag <amf>
+    if (!mXmlParser->hasNode("amf")) {
+        throw DeadlyImportError("Root node \"amf\" not found.");
+    }
+    ParseNode_Root();
+} // namespace Assimp
+
+void AMFImporter::ParseHelper_Node_Enter(AMFNodeElementBase *node) {
+    mNodeElement_Cur->Child.push_back(node); // add new element to current element child list.
+    mNodeElement_Cur = node;
+}
+
+void AMFImporter::ParseHelper_Node_Exit() {
+    if (mNodeElement_Cur != nullptr) mNodeElement_Cur = mNodeElement_Cur->Parent;
+}
+
+// <amf
+// unit="" - The units to be used. May be "inch", "millimeter", "meter", "feet", or "micron".
+// version="" - Version of file format.
+// >
+// </amf>
+// Root XML element.
+// Multi elements - No.
+void AMFImporter::ParseNode_Root() {
+    AMFNodeElementBase *ne = nullptr;
+    XmlNode *root = mXmlParser->findNode("amf");
+    if (nullptr == root) {
+        throw DeadlyImportError("Root node \"amf\" not found.");
+    }
+    XmlNode node = *root;
+    mUnit = ai_tolower(std::string(node.attribute("unit").as_string()));
+
+    mVersion = node.attribute("version").as_string();
+
+    // Read attributes for node <amf>.
+    // Check attributes
+    if (!mUnit.empty()) {
+        if ((mUnit != "inch") && (mUnit != "millimeters") && (mUnit != "millimeter") && (mUnit != "meter") && (mUnit != "feet") && (mUnit != "micron")) {
+            Throw_IncorrectAttrValue("unit", mUnit);
+        }
+    }
+
+    // create root node element.
+    ne = new AMFRoot(nullptr);
+
+    mNodeElement_Cur = ne; // set first "current" element
+    // and assign attribute's values
+    ((AMFRoot *)ne)->Unit = mUnit;
+    ((AMFRoot *)ne)->Version = mVersion;
+
+    // Check for child nodes
+    for (XmlNode &currentNode : node.children() ) {
+        const std::string currentName = currentNode.name();
+        if (currentName == "object") {
+            ParseNode_Object(currentNode);
+        } else if (currentName == "material") {
+            ParseNode_Material(currentNode);
+        } else if (currentName == "texture") {
+            ParseNode_Texture(currentNode);
+        } else if (currentName == "constellation") {
+            ParseNode_Constellation(currentNode);
+        } else if (currentName == "metadata") {
+            ParseNode_Metadata(currentNode);
+        }
+        mNodeElement_Cur = ne;
+    }
+    mNodeElement_Cur = ne; // force restore "current" element
+    mNodeElement_List.push_back(ne); // add to node element list because its a new object in graph.
+}
+
+// <constellation
+// id="" - The Object ID of the new constellation being defined.
+// >
+// </constellation>
+// A collection of objects or constellations with specific relative locations.
+// Multi elements - Yes.
+// Parent element - <amf>.
+void AMFImporter::ParseNode_Constellation(XmlNode &node) {
+    std::string id;
+    id = node.attribute("id").as_string();
+
+    // create and if needed - define new grouping object.
+    AMFNodeElementBase *ne = new AMFConstellation(mNodeElement_Cur);
+
+    AMFConstellation &als = *((AMFConstellation *)ne); // alias for convenience
+
+    if (!id.empty()) {
+        als.ID = id;
+    }
+
+    // Check for child nodes
+    if (!node.empty()) {
+        ParseHelper_Node_Enter(ne);
+        for (XmlNode currentNode = node.first_child(); currentNode; currentNode = currentNode.next_sibling()) {
+            std::string name = currentNode.name();
+            if (name == "instance") {
+                ParseNode_Instance(currentNode);
+            } else if (name == "metadata") {
+                ParseNode_Metadata(currentNode);
+            }
+        }
+        ParseHelper_Node_Exit();
+    } else {
+        mNodeElement_Cur->Child.push_back(ne);
+    }
+    mNodeElement_List.push_back(ne); // and to node element list because its a new object in graph.
+}
+
+// <instance
+// objectid="" - The Object ID of the new constellation being defined.
+// >
+// </instance>
+// A collection of objects or constellations with specific relative locations.
+// Multi elements - Yes.
+// Parent element - <amf>.
+void AMFImporter::ParseNode_Instance(XmlNode &node) {
+    AMFNodeElementBase *ne(nullptr);
+
+    // Read attributes for node <constellation>.
+    std::string objectid = node.attribute("objectid").as_string();
+
+    // used object id must be defined, check that.
+    if (objectid.empty()) {
+        throw DeadlyImportError("\"objectid\" in <instance> must be defined.");
+    }
+    // create and define new grouping object.
+    ne = new AMFInstance(mNodeElement_Cur);
+    AMFInstance &als = *((AMFInstance *)ne);
+    als.ObjectID = objectid;
+
+    if (!node.empty()) {
+        ParseHelper_Node_Enter(ne);
+        for (auto &currentNode : node.children()) {
+            const std::string &currentName = currentNode.name();
+            if (currentName == "deltax") {
+                XmlParser::getValueAsFloat(currentNode, als.Delta.x);
+            } else if (currentName == "deltay") {
+                XmlParser::getValueAsFloat(currentNode, als.Delta.y);
+            } else if (currentName == "deltaz") {
+                XmlParser::getValueAsFloat(currentNode, als.Delta.z);
+            } else if (currentName == "rx") {
+                XmlParser::getValueAsFloat(currentNode, als.Delta.x);
+            } else if (currentName == "ry") {
+                XmlParser::getValueAsFloat(currentNode, als.Delta.y);
+            } else if (currentName == "rz") {
+                XmlParser::getValueAsFloat(currentNode, als.Delta.z);
+            }
+        }
+        ParseHelper_Node_Exit();
+    } else {
+        mNodeElement_Cur->Child.push_back(ne);
+    }
+
+    mNodeElement_List.push_back(ne); // and to node element list because its a new object in graph.
+}
+
+// <object
+// id="" - A unique ObjectID for the new object being defined.
+// >
+// </object>
+// An object definition.
+// Multi elements - Yes.
+// Parent element - <amf>.
+void AMFImporter::ParseNode_Object(XmlNode &node) {
+    AMFNodeElementBase *ne = nullptr;
+
+    // Read attributes for node <object>.
+    std::string id = node.attribute("id").as_string();
+
+    // create and if needed - define new geometry object.
+    ne = new AMFObject(mNodeElement_Cur);
+
+    AMFObject &als = *((AMFObject *)ne); // alias for convenience
+
+    if (!id.empty()) {
+        als.ID = id;
+    }
+
+    // Check for child nodes
+    if (!node.empty()) {
+        ParseHelper_Node_Enter(ne);
+        for (auto &currentNode : node.children()) {
+            const std::string &currentName = currentNode.name();
+            if (currentName == "color") {
+                ParseNode_Color(currentNode);
+            } else if (currentName == "mesh") {
+                ParseNode_Mesh(currentNode);
+            } else if (currentName == "metadata") {
+                ParseNode_Metadata(currentNode);
+            }
+        }
+        ParseHelper_Node_Exit();
+    } else {
+        mNodeElement_Cur->Child.push_back(ne); // Add element to child list of current element
+    }
+
+    mNodeElement_List.push_back(ne); // and to node element list because its a new object in graph.
+}
+
+// <metadata
+// type="" - The type of the attribute.
+// >
+// </metadata>
+// Specify additional information about an entity.
+// Multi elements - Yes.
+// Parent element - <amf>, <object>, <volume>, <material>, <vertex>.
+//
+// Reserved types are:
+// "Name" - The alphanumeric label of the entity, to be used by the interpreter if interacting with the user.
+// "Description" - A description of the content of the entity
+// "URL" - A link to an external resource relating to the entity
+// "Author" - Specifies the name(s) of the author(s) of the entity
+// "Company" - Specifying the company generating the entity
+// "CAD" - specifies the name of the originating CAD software and version
+// "Revision" - specifies the revision of the entity
+// "Tolerance" - specifies the desired manufacturing tolerance of the entity in entity's unit system
+// "Volume" - specifies the total volume of the entity, in the entity's unit system, to be used for verification (object and volume only)
+void AMFImporter::ParseNode_Metadata(XmlNode &node) {
+    AMFNodeElementBase *ne = nullptr;
+
+    std::string type = node.attribute("type").as_string(), value;
+    XmlParser::getValueAsString(node, value);
+
+    // read attribute
+    ne = new AMFMetadata(mNodeElement_Cur);
+    ((AMFMetadata *)ne)->Type = type;
+    ((AMFMetadata *)ne)->Value = value;
+    mNodeElement_Cur->Child.push_back(ne); // Add element to child list of current element
+    mNodeElement_List.push_back(ne); // and to node element list because its a new object in graph.
+}
+
+bool AMFImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*pCheckSig*/) const {
+    static const char *tokens[] = { "<amf" };
+    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
+}
+
+const aiImporterDesc *AMFImporter::GetInfo() const {
+    return &Description;
+}
+
+void AMFImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
+    Clear(); // delete old graph.
+    ParseFile(pFile, pIOHandler);
+    Postprocess_BuildScene(pScene);
+    // scene graph is ready, exit.
+}
+
+} // namespace Assimp
+
+#endif // !ASSIMP_BUILD_NO_AMF_IMPORTER
diff --git a/Engine/lib/assimp/code/AssetLib/AMF/AMFImporter.hpp b/Engine/lib/assimp/code/AssetLib/AMF/AMFImporter.hpp
new file mode 100644
index 000000000..601eae4e4
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/AMF/AMFImporter.hpp
@@ -0,0 +1,310 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/// \file AMFImporter.hpp
+/// \brief AMF-format files importer for Assimp.
+/// \date 2016
+/// \author smal.root@gmail.com
+// Thanks to acorn89 for support.
+
+#pragma once
+#ifndef INCLUDED_AI_AMF_IMPORTER_H
+#define INCLUDED_AI_AMF_IMPORTER_H
+
+#include "AMFImporter_Node.hpp"
+
+// Header files, Assimp.
+#include "assimp/types.h"
+#include <assimp/BaseImporter.h>
+#include <assimp/XmlParser.h>
+#include <assimp/importerdesc.h>
+#include <assimp/DefaultLogger.hpp>
+
+// Header files, stdlib.
+#include <set>
+
+namespace Assimp {
+
+/// \class AMFImporter
+/// Class that holding scene graph which include: geometry, metadata, materials etc.
+///
+/// Implementing features.
+///
+/// Limitations.
+///
+/// 1. When for texture mapping used set of source textures (r, g, b, a) not only one then attribute "tiled" for all set will be true if it true in any of
+///    source textures.
+///    Example. Triangle use for texture mapping three textures. Two of them has "tiled" set to false and one - set to true. In scene all three textures
+///    will be tiled.
+///
+/// Unsupported features:
+/// 1. Node <composite>, formulas in <composite> and <color>. For implementing this feature can be used expression parser "muParser" like in project
+///    "amf_tools".
+/// 2. Attribute "profile" in node <color>.
+/// 3. Curved geometry: <edge>, <normal> and children nodes of them.
+/// 4. Attributes: "unit" and "version" in <amf> read but do nothing.
+/// 5. <metadata> stored only for root node <amf>.
+/// 6. Color averaging of vertices for which <triangle>'s set different colors.
+///
+/// Supported nodes:
+///    General:
+///        <amf>; <constellation>; <instance> and children <deltax>, <deltay>, <deltaz>, <rx>, <ry>, <rz>; <metadata>;
+///
+///    Geometry:
+///        <object>; <mesh>; <vertices>; <vertex>; <coordinates> and children <x>, <y>, <z>; <volume>; <triangle> and children <v1>, <v2>, <v3>;
+///
+///    Material:
+///        <color> and children <r>, <g>, <b>, <a>; <texture>; <material>;
+///        two variants of texture coordinates:
+///            new - <texmap> and children <utex1>, <utex2>, <utex3>, <vtex1>, <vtex2>, <vtex3>
+///            old - <map> and children <u1>, <u2>, <u3>, <v1>, <v2>, <v3>
+///
+class AMFImporter : public BaseImporter {
+private:
+    struct SPP_Material; // forward declaration
+
+    /// Data type for post-processing step. More suitable container for part of material's composition.
+    struct SPP_Composite {
+        SPP_Material *Material; ///< Pointer to material - part of composition.
+        std::string Formula; ///< Formula for calculating ratio of \ref Material.
+    };
+
+    /// \struct SPP_Material
+    /// Data type for post-processing step. More suitable container for material.
+    struct SPP_Material {
+        std::string ID; ///< Material ID.
+        std::list<AMFMetadata *> Metadata; ///< Metadata of material.
+        AMFColor *Color; ///< Color of material.
+        std::list<SPP_Composite> Composition; ///< List of child materials if current material is composition of few another.
+
+        /// Return color calculated for specified coordinate.
+        /// \param [in] pX - "x" coordinate.
+        /// \param [in] pY - "y" coordinate.
+        /// \param [in] pZ - "z" coordinate.
+        /// \return calculated color.
+        aiColor4D GetColor(const float pX, const float pY, const float pZ) const;
+    };
+
+    /// Data type for post-processing step. More suitable container for texture.
+    struct SPP_Texture {
+        std::string ID;
+        size_t Width, Height, Depth;
+        bool Tiled;
+        char FormatHint[9]; // 8 for string + 1 for terminator.
+        uint8_t *Data;
+    };
+
+    /// Data type for post-processing step. Contain face data.
+    struct SComplexFace {
+        aiFace Face; ///< Face vertices.
+        const AMFColor *Color; ///< Face color. Equal to nullptr if color is not set for the face.
+        const AMFTexMap *TexMap; ///< Face texture mapping data. Equal to nullptr if texture mapping is not set for the face.
+    };
+
+    using AMFMetaDataArray = std::vector<AMFMetadata*>;
+    using MeshArray = std::vector<aiMesh*>;
+    using NodeArray = std::vector<aiNode*>;
+
+    /// Clear all temporary data.
+    void Clear();
+
+    /// Get data stored in <vertices> and place it to arrays.
+    /// \param [in] pNodeElement - reference to node element which kept <object> data.
+    /// \param [in] pVertexCoordinateArray - reference to vertices coordinates kept in <vertices>.
+    /// \param [in] pVertexColorArray - reference to vertices colors for all <vertex's. If color for vertex is not set then corresponding member of array
+    /// contain nullptr.
+    void PostprocessHelper_CreateMeshDataArray(const AMFMesh &pNodeElement, std::vector<aiVector3D> &pVertexCoordinateArray,
+            std::vector<AMFColor *> &pVertexColorArray) const;
+
+    /// Return converted texture ID which related to specified source textures ID's. If converted texture does not exist then it will be created and ID on new
+    /// converted texture will be returned. Conversion: set of textures from \ref CAMFImporter_NodeElement_Texture to one \ref SPP_Texture and place it
+    /// to converted textures list.
+    /// Any of source ID's can be absent(empty string) or even one ID only specified. But at least one ID must be specified.
+    /// \param [in] pID_R - ID of source "red" texture.
+    /// \param [in] pID_G - ID of source "green" texture.
+    /// \param [in] pID_B - ID of source "blue" texture.
+    /// \param [in] pID_A - ID of source "alpha" texture.
+    /// \return index of the texture in array of the converted textures.
+    size_t PostprocessHelper_GetTextureID_Or_Create(const std::string &pID_R, const std::string &pID_G, const std::string &pID_B, const std::string &pID_A);
+
+    /// Separate input list by texture IDs. This step is needed because aiMesh can contain mesh which is use only one texture (or set: diffuse, bump etc).
+    /// \param [in] pInputList - input list with faces. Some of them can contain color or texture mapping, or both of them, or nothing. Will be cleared after
+    /// processing.
+    /// \param [out] pOutputList_Separated - output list of the faces lists. Separated faces list by used texture IDs. Will be cleared before processing.
+    void PostprocessHelper_SplitFacesByTextureID(std::list<SComplexFace> &pInputList, std::list<std::list<SComplexFace>> &pOutputList_Separated);
+
+    /// Check if child elements of node element is metadata and add it to scene node.
+    /// \param [in] pMetadataList - reference to list with collected metadata.
+    /// \param [out] pSceneNode - scene node in which metadata will be added.
+    void Postprocess_AddMetadata(const AMFMetaDataArray &pMetadataList, aiNode &pSceneNode) const;
+
+    /// To create aiMesh and aiNode for it from <object>.
+    /// \param [in] pNodeElement - reference to node element which kept <object> data.
+    /// \param [out] meshList    - reference to a list with all aiMesh of the scene.
+    /// \param [out] pSceneNode  - pointer to place where new aiNode will be created.
+    void Postprocess_BuildNodeAndObject(const AMFObject &pNodeElement, MeshArray &meshList, aiNode **pSceneNode);
+
+    /// Create mesh for every <volume> in <mesh>.
+    /// \param [in] pNodeElement - reference to node element which kept <mesh> data.
+    /// \param [in] pVertexCoordinateArray - reference to vertices coordinates for all <volume>'s.
+    /// \param [in] pVertexColorArray - reference to vertices colors for all <volume>'s. If color for vertex is not set then corresponding member of array
+    /// contain nullptr.
+    /// \param [in] pObjectColor - pointer to colors for <object>. If color is not set then argument contain nullptr.
+    /// \param [in] pMaterialList - reference to a list with defined materials.
+    /// \param [out] pMeshList - reference to a list with all aiMesh of the scene.
+    /// \param [out] pSceneNode - reference to aiNode which will own new aiMesh's.
+    void Postprocess_BuildMeshSet(const AMFMesh &pNodeElement, const std::vector<aiVector3D> &pVertexCoordinateArray,
+            const std::vector<AMFColor *> &pVertexColorArray, const AMFColor *pObjectColor,
+            MeshArray &pMeshList, aiNode &pSceneNode);
+
+    /// Convert material from \ref CAMFImporter_NodeElement_Material to \ref SPP_Material.
+    /// \param [in] pMaterial - source CAMFImporter_NodeElement_Material.
+    void Postprocess_BuildMaterial(const AMFMaterial &pMaterial);
+
+    /// Create and add to aiNode's list new part of scene graph defined by <constellation>.
+    /// \param [in] pConstellation - reference to <constellation> node.
+    /// \param [out] nodeArray     - reference to aiNode's list.
+    void Postprocess_BuildConstellation(AMFConstellation &pConstellation, NodeArray &nodeArray) const;
+
+    /// Build Assimp scene graph in aiScene from collected data.
+    /// \param [out] pScene - pointer to aiScene where tree will be built.
+    void Postprocess_BuildScene(aiScene *pScene);
+
+    /// Decode Base64-encoded data.
+    /// \param [in] pInputBase64 - reference to input Base64-encoded string.
+    /// \param [out] pOutputData - reference to output array for decoded data.
+    void ParseHelper_Decode_Base64(const std::string &pInputBase64, std::vector<uint8_t> &pOutputData) const;
+
+    /// Parse <AMF> node of the file.
+    void ParseNode_Root();
+
+    /// Parse <constellation> node of the file.
+    void ParseNode_Constellation(XmlNode &node);
+
+    /// Parse <instance> node of the file.
+    void ParseNode_Instance(XmlNode &node);
+
+    /// Parse <material> node of the file.
+    void ParseNode_Material(XmlNode &node);
+
+    /// Parse <metadata> node.
+    void ParseNode_Metadata(XmlNode &node);
+
+    /// Parse <object> node of the file.
+    void ParseNode_Object(XmlNode &node);
+
+    /// Parse <texture> node of the file.
+    void ParseNode_Texture(XmlNode &node);
+
+    /// Parse <coordinates> node of the file.
+    void ParseNode_Coordinates(XmlNode &node);
+
+    /// Parse <edge> node of the file.
+    void ParseNode_Edge(XmlNode &node);
+
+    /// Parse <mesh> node of the file.
+    void ParseNode_Mesh(XmlNode &node);
+
+    /// Parse <triangle> node of the file.
+    void ParseNode_Triangle(XmlNode &node);
+
+    /// Parse <vertex> node of the file.
+    void ParseNode_Vertex(XmlNode &node);
+
+    /// Parse <vertices> node of the file.
+    void ParseNode_Vertices(XmlNode &node);
+
+    /// Parse <volume> node of the file.
+    void ParseNode_Volume(XmlNode &node);
+
+    /// Parse <color> node of the file.
+    void ParseNode_Color(XmlNode &node);
+
+    /// Parse <texmap> of <map> node of the file.
+    /// \param [in] pUseOldName - if true then use old name of node(and children) - <map>, instead of new name - <texmap>.
+    void ParseNode_TexMap(XmlNode &node, const bool pUseOldName = false);
+
+public:
+    /// Default constructor.
+    AMFImporter() AI_NO_EXCEPT;
+
+    /// Default destructor.
+    ~AMFImporter() override;
+
+    /// Parse AMF file and fill scene graph. The function has no return value. Result can be found by analyzing the generated graph.
+    /// Also exception can be thrown if trouble will found.
+    /// \param [in] pFile - name of file to be parsed.
+    /// \param [in] pIOHandler - pointer to IO helper object.
+    void ParseFile(const std::string &pFile, IOSystem *pIOHandler);
+    void ParseHelper_Node_Enter(AMFNodeElementBase *child);
+    void ParseHelper_Node_Exit();
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool pCheckSig) const override;
+    void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) override;
+    const aiImporterDesc *GetInfo() const override;
+    bool Find_NodeElement(const std::string &pID, const AMFNodeElementBase::EType pType, AMFNodeElementBase **pNodeElement) const;
+    bool Find_ConvertedNode(const std::string &pID, NodeArray &nodeArray, aiNode **pNode) const;
+    bool Find_ConvertedMaterial(const std::string &pID, const SPP_Material **pConvertedMaterial) const;
+    void Throw_CloseNotFound(const std::string &nodeName);
+    void Throw_IncorrectAttr(const std::string &nodeName, const std::string &pAttrName);
+    void Throw_IncorrectAttrValue(const std::string &nodeName, const std::string &pAttrName);
+    void Throw_MoreThanOnceDefined(const std::string &nodeName, const std::string &pNodeType, const std::string &pDescription);
+    void Throw_ID_NotFound(const std::string &pID) const;
+    void XML_CheckNode_MustHaveChildren(pugi::xml_node &node);
+    bool XML_SearchNode(const std::string &nodeName);
+    void ParseHelper_FixTruncatedFloatString(const char *pInStr, std::string &pOutString);
+    AMFImporter(const AMFImporter &pScene) = delete;
+    AMFImporter &operator=(const AMFImporter &pScene) = delete;
+
+private:
+    static const aiImporterDesc Description;
+
+    AMFNodeElementBase *mNodeElement_Cur; ///< Current element.
+    std::list<AMFNodeElementBase *> mNodeElement_List; ///< All elements of scene graph.
+    XmlParser *mXmlParser;
+    std::string mUnit;
+    std::string mVersion;
+    std::list<SPP_Material> mMaterial_Converted; ///< List of converted materials for postprocessing step.
+    std::list<SPP_Texture> mTexture_Converted; ///< List of converted textures for postprocessing step.
+};
+
+} // namespace Assimp
+
+#endif // INCLUDED_AI_AMF_IMPORTER_H
diff --git a/Engine/lib/assimp/code/AssetLib/AMF/AMFImporter_Geometry.cpp b/Engine/lib/assimp/code/AssetLib/AMF/AMFImporter_Geometry.cpp
new file mode 100644
index 000000000..341999f56
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/AMF/AMFImporter_Geometry.cpp
@@ -0,0 +1,284 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+#ifndef ASSIMP_BUILD_NO_AMF_IMPORTER
+
+#include "AMFImporter.hpp"
+#include <assimp/ParsingUtils.h>
+
+namespace Assimp {
+
+// <mesh>
+// </mesh>
+// A 3D mesh hull.
+// Multi elements - Yes.
+// Parent element - <object>.
+void AMFImporter::ParseNode_Mesh(XmlNode &node) {
+    AMFNodeElementBase *ne = nullptr;
+
+    // Check for child nodes
+    if (0 != ASSIMP_stricmp(node.name(), "mesh")) {
+        return;
+    }
+    // create new mesh object.
+    ne = new AMFMesh(mNodeElement_Cur);
+    bool found_verts = false, found_volumes = false;
+    if (!node.empty()) {
+        ParseHelper_Node_Enter(ne);
+        pugi::xml_node vertNode = node.child("vertices");
+        if (!vertNode.empty()) {
+            ParseNode_Vertices(vertNode);
+            found_verts = true;
+        }
+
+        pugi::xml_node volumeNode = node.child("volume");
+        if (!volumeNode.empty()) {
+            ParseNode_Volume(volumeNode);
+            found_volumes = true;
+        }
+        ParseHelper_Node_Exit();
+    }
+
+    if (!found_verts && !found_volumes) {
+        mNodeElement_Cur->Child.push_back(ne);
+    } // if(!mReader->isEmptyElement()) else
+
+    // and to node element list because its a new object in graph.
+    mNodeElement_List.push_back(ne);
+}
+
+// <vertices>
+// </vertices>
+// The list of vertices to be used in defining triangles.
+// Multi elements - No.
+// Parent element - <mesh>.
+void AMFImporter::ParseNode_Vertices(XmlNode &node) {
+    AMFNodeElementBase *ne = nullptr;
+
+    // create new mesh object.
+    ne = new AMFVertices(mNodeElement_Cur);
+    // Check for child nodes
+    if (node.empty()) {
+        mNodeElement_Cur->Child.push_back(ne); // Add element to child list of current element
+        return;
+    }
+    ParseHelper_Node_Enter(ne);
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "vertex") {
+            ParseNode_Vertex(currentNode);
+        }
+    }
+    ParseHelper_Node_Exit();
+    mNodeElement_List.push_back(ne); // and to node element list because its a new object in graph.
+}
+
+// <vertex>
+// </vertex>
+// A vertex to be referenced in triangles.
+// Multi elements - Yes.
+// Parent element - <vertices>.
+void AMFImporter::ParseNode_Vertex(XmlNode &node) {
+    AMFNodeElementBase *ne = nullptr;
+
+    // create new mesh object.
+    ne = new AMFVertex(mNodeElement_Cur);
+
+    // Check for child nodes
+    pugi::xml_node colorNode = node.child("color");
+    bool col_read = false;
+    bool coord_read = false;
+    if (!node.empty()) {
+        ParseHelper_Node_Enter(ne);
+        if (!colorNode.empty()) {
+            ParseNode_Color(colorNode);
+            col_read = true;
+        }
+        pugi::xml_node coordNode = node.child("coordinates");
+        if (!coordNode.empty()) {
+            ParseNode_Coordinates(coordNode);
+            coord_read = true;
+        }
+        ParseHelper_Node_Exit();
+    }
+
+    if (!coord_read && !col_read) {
+        mNodeElement_Cur->Child.push_back(ne); // Add element to child list of current element
+    }
+
+    mNodeElement_List.push_back(ne); // and to node element list because its a new object in graph.
+}
+
+// <coordinates>
+// </coordinates>
+// Specifies the 3D location of this vertex.
+// Multi elements - No.
+// Parent element - <vertex>.
+//
+// Children elements:
+//   <x>, <y>, <z>
+//   Multi elements - No.
+//   X, Y, or Z coordinate, respectively, of a vertex position in space.
+void AMFImporter::ParseNode_Coordinates(XmlNode &node) {
+    AMFNodeElementBase *ne = nullptr;
+    if (!node.empty()) {
+        ne = new AMFCoordinates(mNodeElement_Cur);
+        ParseHelper_Node_Enter(ne);
+        for (XmlNode &currentNode : node.children()) {
+            // create new color object.
+            AMFCoordinates &als = *((AMFCoordinates *)ne); // alias for convenience
+            const std::string &currentName = ai_tolower(currentNode.name());
+            if (currentName == "x") {
+                XmlParser::getValueAsFloat(currentNode, als.Coordinate.x);
+            } else if (currentName == "y") {
+                XmlParser::getValueAsFloat(currentNode, als.Coordinate.y);
+            } else if (currentName == "z") {
+                XmlParser::getValueAsFloat(currentNode, als.Coordinate.z);
+            }
+        }
+        ParseHelper_Node_Exit();
+
+    } else {
+        mNodeElement_Cur->Child.push_back(new AMFCoordinates(mNodeElement_Cur));
+    }
+
+    mNodeElement_List.push_back(ne); // and to node element list because its a new object in graph.
+}
+
+// <volume
+// materialid="" - Which material to use.
+// type=""       - What this volume describes can be "region" or "support". If none specified, "object" is assumed. If support, then the geometric
+//                 requirements 1-8 listed in section 5 do not need to be maintained.
+// >
+// </volume>
+// Defines a volume from the established vertex list.
+// Multi elements - Yes.
+// Parent element - <mesh>.
+void AMFImporter::ParseNode_Volume(XmlNode &node) {
+    std::string materialid;
+    std::string type;
+    AMFNodeElementBase *ne = new AMFVolume(mNodeElement_Cur);
+
+    // Read attributes for node <color>.
+    // and assign read data
+
+    ((AMFVolume *)ne)->MaterialID = node.attribute("materialid").as_string();
+
+    ((AMFVolume *)ne)->Type = type;
+    // Check for child nodes
+    bool col_read = false;
+    if (!node.empty()) {
+        ParseHelper_Node_Enter(ne);
+        for (auto &currentNode : node.children()) {
+            const std::string currentName = currentNode.name();
+            if (currentName == "color") {
+                if (col_read) Throw_MoreThanOnceDefined(currentName, "color", "Only one color can be defined for <volume>.");
+                ParseNode_Color(currentNode);
+                col_read = true;
+            } else if (currentName == "triangle") {
+                ParseNode_Triangle(currentNode);
+            } else if (currentName == "metadata") {
+                ParseNode_Metadata(currentNode);
+            } else if (currentName == "volume") {
+                ParseNode_Metadata(currentNode);
+            }
+        }
+        ParseHelper_Node_Exit();
+    } else {
+        mNodeElement_Cur->Child.push_back(ne); // Add element to child list of current element
+    }
+
+    mNodeElement_List.push_back(ne); // and to node element list because its a new object in graph.
+}
+
+// <triangle>
+// </triangle>
+// Defines a 3D triangle from three vertices, according to the right-hand rule (counter-clockwise when looking from the outside).
+// Multi elements - Yes.
+// Parent element - <volume>.
+//
+// Children elements:
+//   <v1>, <v2>, <v3>
+//   Multi elements - No.
+//   Index of the desired vertices in a triangle or edge.
+void AMFImporter::ParseNode_Triangle(XmlNode &node) {
+    AMFNodeElementBase *ne = new AMFTriangle(mNodeElement_Cur);
+
+    // create new triangle object.
+
+    AMFTriangle &als = *((AMFTriangle *)ne); // alias for convenience
+
+    bool col_read = false;
+    if (!node.empty()) {
+        ParseHelper_Node_Enter(ne);
+        std::string v;
+        for (auto &currentNode : node.children()) {
+            const std::string currentName = currentNode.name();
+            if (currentName == "color") {
+                if (col_read) Throw_MoreThanOnceDefined(currentName, "color", "Only one color can be defined for <triangle>.");
+                ParseNode_Color(currentNode);
+                col_read = true;
+            } else if (currentName == "texmap") {
+                ParseNode_TexMap(currentNode);
+            } else if (currentName == "map") {
+                ParseNode_TexMap(currentNode, true);
+            } else if (currentName == "v1") {
+                XmlParser::getValueAsString(currentNode, v);
+                als.V[0] = std::atoi(v.c_str());
+            } else if (currentName == "v2") {
+                XmlParser::getValueAsString(currentNode, v);
+                als.V[1] = std::atoi(v.c_str());
+            } else if (currentName == "v3") {
+                XmlParser::getValueAsString(currentNode, v);
+                als.V[2] = std::atoi(v.c_str());
+            }
+        }
+        ParseHelper_Node_Exit();
+    } else {
+        mNodeElement_Cur->Child.push_back(ne); // Add element to child list of current element
+    }
+
+    mNodeElement_List.push_back(ne); // and to node element list because its a new object in graph.
+}
+
+} // namespace Assimp
+
+#endif // !ASSIMP_BUILD_NO_AMF_IMPORTER
diff --git a/Engine/lib/assimp/code/AMF/AMFImporter_Material.cpp b/Engine/lib/assimp/code/AssetLib/AMF/AMFImporter_Material.cpp
similarity index 50%
rename from Engine/lib/assimp/code/AMF/AMFImporter_Material.cpp
rename to Engine/lib/assimp/code/AssetLib/AMF/AMFImporter_Material.cpp
index 2f36df061..676e74856 100644
--- a/Engine/lib/assimp/code/AMF/AMFImporter_Material.cpp
+++ b/Engine/lib/assimp/code/AssetLib/AMF/AMFImporter_Material.cpp
@@ -1,11 +1,9 @@
-/*
+/*
 ---------------------------------------------------------------------------
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -49,10 +47,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_AMF_IMPORTER
 
 #include "AMFImporter.hpp"
-#include "AMFImporter_Macro.hpp"
 
-namespace Assimp
-{
+namespace Assimp {
 
 // <color
 // profile="" - The ICC color space used to interpret the three color channels <r>, <g> and <b>.
@@ -68,51 +64,46 @@ namespace Assimp
 //   Multi elements - No.
 //   Red, Greed, Blue and Alpha (transparency) component of a color in sRGB space, values ranging from 0 to 1. The
 //   values can be specified as constants, or as a formula depending on the coordinates.
-void AMFImporter::ParseNode_Color() {
-    std::string profile;
-    CAMFImporter_NodeElement* ne;
+void AMFImporter::ParseNode_Color(XmlNode &node) {
+    if (node.empty()) {
+        return;
+    }
 
-	// Read attributes for node <color>.
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECK_RET("profile", profile, mReader->getAttributeValue);
-	MACRO_ATTRREAD_LOOPEND;
+    const std::string &profile = node.attribute("profile").as_string();
+    bool read_flag[4] = { false, false, false, false };
+    AMFNodeElementBase *ne = new AMFColor(mNodeElement_Cur);
+    AMFColor &als = *((AMFColor *)ne); // alias for convenience
+    ParseHelper_Node_Enter(ne);
+    for (pugi::xml_node &child : node.children()) {
+        // create new color object.
+        als.Profile = profile;
 
-	// create new color object.
-	ne = new CAMFImporter_NodeElement_Color(mNodeElement_Cur);
-
-	CAMFImporter_NodeElement_Color& als = *((CAMFImporter_NodeElement_Color*)ne);// alias for convenience
-
-	als.Profile = profile;
-	// Check for child nodes
-	if(!mReader->isEmptyElement())
-	{
-		bool read_flag[4] = { false, false, false, false };
-
-		ParseHelper_Node_Enter(ne);
-		MACRO_NODECHECK_LOOPBEGIN("color");
-			MACRO_NODECHECK_READCOMP_F("r", read_flag[0], als.Color.r);
-			MACRO_NODECHECK_READCOMP_F("g", read_flag[1], als.Color.g);
-			MACRO_NODECHECK_READCOMP_F("b", read_flag[2], als.Color.b);
-			MACRO_NODECHECK_READCOMP_F("a", read_flag[3], als.Color.a);
-		MACRO_NODECHECK_LOOPEND("color");
-		ParseHelper_Node_Exit();
-		// check that all components was defined
-        if (!(read_flag[0] && read_flag[1] && read_flag[2])) {
-            throw DeadlyImportError("Not all color components are defined.");
+        const std::string &name = child.name();
+        if ( name == "r") {
+			read_flag[0] = true;
+            XmlParser::getValueAsFloat(child, als.Color.r);
+        } else if (name == "g") {
+			read_flag[1] = true;
+            XmlParser::getValueAsFloat(child, als.Color.g);
+        } else if (name == "b") {
+			read_flag[2] = true;
+            XmlParser::getValueAsFloat(child, als.Color.b);
+        } else if (name == "a") {
+			read_flag[3] = true;
+            XmlParser::getValueAsFloat(child, als.Color.a);
         }
-
         // check if <a> is absent. Then manually add "a == 1".
         if (!read_flag[3]) {
             als.Color.a = 1;
         }
+    }
+    als.Composed = false;
+    mNodeElement_List.push_back(ne); // and to node element list because its a new object in graph.
+    ParseHelper_Node_Exit();
+    // check that all components was defined
+	if (!(read_flag[0] && read_flag[1] && read_flag[2])) {
+		throw DeadlyImportError("Not all color components are defined.");
 	}
-	else
-	{
-		mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element
-	}
-
-	als.Composed = false;
-	mNodeElement_List.push_back(ne);// and to node element list because its a new object in graph.
 }
 
 // <material
@@ -122,45 +113,25 @@ void AMFImporter::ParseNode_Color() {
 // An available material.
 // Multi elements - Yes.
 // Parent element - <amf>.
-void AMFImporter::ParseNode_Material() {
-    std::string id;
-    CAMFImporter_NodeElement* ne;
-
-	// Read attributes for node <color>.
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECK_RET("id", id, mReader->getAttributeValue);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// create new object.
-	ne = new CAMFImporter_NodeElement_Material(mNodeElement_Cur);
-
-    // and assign read data
-	((CAMFImporter_NodeElement_Material*)ne)->ID = id;
+void AMFImporter::ParseNode_Material(XmlNode &node) {
+    // create new object and assign read data
+	std::string id = node.attribute("id").as_string();
+	AMFNodeElementBase *ne = new AMFMaterial(mNodeElement_Cur);
+	((AMFMaterial*)ne)->ID = id;
 
     // Check for child nodes
-	if(!mReader->isEmptyElement())
-	{
-		bool col_read = false;
-
-		ParseHelper_Node_Enter(ne);
-		MACRO_NODECHECK_LOOPBEGIN("material");
-			if(XML_CheckNode_NameEqual("color"))
-			{
-				// Check if data already defined.
-				if(col_read) Throw_MoreThanOnceDefined("color", "Only one color can be defined for <material>.");
-				// read data and set flag about it
-				ParseNode_Color();
-				col_read = true;
-
-				continue;
+	if (!node.empty()) {
+        ParseHelper_Node_Enter(ne);
+        for (pugi::xml_node &child : node.children()) {
+            const std::string name = child.name();
+            if (name == "color") {
+				ParseNode_Color(child);
+            } else if (name == "metadata") {
+				ParseNode_Metadata(child);
 			}
-
-			if(XML_CheckNode_NameEqual("metadata")) { ParseNode_Metadata(); continue; }
-		MACRO_NODECHECK_LOOPEND("material");
-		ParseHelper_Node_Exit();
-	}
-	else
-	{
+		}
+        ParseHelper_Node_Exit();
+	} else {
 		mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element
 	}
 
@@ -183,51 +154,39 @@ void AMFImporter::ParseNode_Material() {
 // then layer by layer.
 // Multi elements - Yes.
 // Parent element - <amf>.
-void AMFImporter::ParseNode_Texture()
-{
-    std::string id;
-    uint32_t width = 0;
-    uint32_t height = 0;
-    uint32_t depth = 1;
-    std::string type;
-    bool tiled = false;
-    std::string enc64_data;
+void AMFImporter::ParseNode_Texture(XmlNode &node) {
+    const std::string id = node.attribute("id").as_string();
+	const uint32_t width = node.attribute("width").as_uint();
+    const uint32_t height = node.attribute("height").as_uint();
+    uint32_t depth = node.attribute("depth").as_uint();
+    const std::string type = node.attribute("type").as_string();
+	bool tiled = node.attribute("tiled").as_bool();
 
-	// Read attributes for node <color>.
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECK_RET("id", id, mReader->getAttributeValue);
-		MACRO_ATTRREAD_CHECK_RET("width", width, XML_ReadNode_GetAttrVal_AsU32);
-		MACRO_ATTRREAD_CHECK_RET("height", height, XML_ReadNode_GetAttrVal_AsU32);
-		MACRO_ATTRREAD_CHECK_RET("depth", depth, XML_ReadNode_GetAttrVal_AsU32);
-		MACRO_ATTRREAD_CHECK_RET("type", type, mReader->getAttributeValue);
-		MACRO_ATTRREAD_CHECK_RET("tiled", tiled, XML_ReadNode_GetAttrVal_AsBool);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// create new texture object.
-    CAMFImporter_NodeElement *ne = new CAMFImporter_NodeElement_Texture(mNodeElement_Cur);
-
-	CAMFImporter_NodeElement_Texture& als = *((CAMFImporter_NodeElement_Texture*)ne);// alias for convenience
-
-	// Check for child nodes
-    if (!mReader->isEmptyElement()) {
-        XML_ReadNode_GetVal_AsString(enc64_data);
+    if (node.empty()) {
+		return;
     }
 
+    // create new texture object.
+    AMFNodeElementBase *ne = new AMFTexture(mNodeElement_Cur);
+
+	AMFTexture& als = *((AMFTexture*)ne);// alias for convenience
+
+    std::string enc64_data;
+    XmlParser::getValueAsString(node, enc64_data);
+    // Check for child nodes
+
 	// check that all components was defined
     if (id.empty()) {
-        throw DeadlyImportError("ID for texture must be defined.");
+		throw DeadlyImportError("ID for texture must be defined.");
     }
     if (width < 1) {
-        Throw_IncorrectAttrValue("width");
+		throw DeadlyImportError("Invalid width for texture.");
     }
     if (height < 1) {
-        Throw_IncorrectAttrValue("height");
-    }
-    if (depth < 1) {
-        Throw_IncorrectAttrValue("depth");
-    }
+		throw DeadlyImportError("Invalid height for texture.");
+	}
     if (type != "grayscale") {
-        Throw_IncorrectAttrValue("type");
+		throw DeadlyImportError("Invalid type for texture.");
     }
     if (enc64_data.empty()) {
         throw DeadlyImportError("Texture data not defined.");
@@ -239,7 +198,9 @@ void AMFImporter::ParseNode_Texture()
 	als.Depth = depth;
 	als.Tiled = tiled;
 	ParseHelper_Decode_Base64(enc64_data, als.Data);
-
+    if (depth == 0) {
+        depth = (uint32_t)(als.Data.size() / (width * height));
+    }
     // check data size
     if ((width * height * depth) != als.Data.size()) {
         throw DeadlyImportError("Texture has incorrect data size.");
@@ -263,57 +224,94 @@ void AMFImporter::ParseNode_Texture()
 //   <utex1>, <utex2>, <utex3>, <vtex1>, <vtex2>, <vtex3>. Old name: <u1>, <u2>, <u3>, <v1>, <v2>, <v3>.
 //   Multi elements - No.
 //   Texture coordinates for every vertex of triangle.
-void AMFImporter::ParseNode_TexMap(const bool pUseOldName) {
-    std::string rtexid, gtexid, btexid, atexid;
-
+void AMFImporter::ParseNode_TexMap(XmlNode &node, const bool pUseOldName) {
 	// Read attributes for node <color>.
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECK_RET("rtexid", rtexid, mReader->getAttributeValue);
-		MACRO_ATTRREAD_CHECK_RET("gtexid", gtexid, mReader->getAttributeValue);
-		MACRO_ATTRREAD_CHECK_RET("btexid", btexid, mReader->getAttributeValue);
-		MACRO_ATTRREAD_CHECK_RET("atexid", atexid, mReader->getAttributeValue);
-	MACRO_ATTRREAD_LOOPEND;
+    AMFNodeElementBase *ne = new AMFTexMap(mNodeElement_Cur);
+    AMFTexMap &als = *((AMFTexMap *)ne); //
+    std::string rtexid, gtexid, btexid, atexid;
+    if (!node.empty()) {
+        for (pugi::xml_attribute &attr : node.attributes()) {
+            const std::string &currentAttr = attr.name();
+            if (currentAttr == "rtexid") {
+                rtexid = attr.as_string();
+            } else if (currentAttr == "gtexid") {
+                gtexid = attr.as_string();
+            } else if (currentAttr == "btexid") {
+                btexid = attr.as_string();
+            } else if (currentAttr == "atexid") {
+                atexid = attr.as_string();
+            }
+        }
+    }
 
-	// create new texture coordinates object.
-    CAMFImporter_NodeElement *ne = new CAMFImporter_NodeElement_TexMap(mNodeElement_Cur);
-
-	CAMFImporter_NodeElement_TexMap& als = *((CAMFImporter_NodeElement_TexMap*)ne);// alias for convenience
+	// create new texture coordinates object, alias for convenience
 	// check data
-	if(rtexid.empty() && gtexid.empty() && btexid.empty()) throw DeadlyImportError("ParseNode_TexMap. At least one texture ID must be defined.");
+	if (rtexid.empty() && gtexid.empty() && btexid.empty()) {
+		throw DeadlyImportError("ParseNode_TexMap. At least one texture ID must be defined.");
+	}
+
 	// Check for children nodes
-	XML_CheckNode_MustHaveChildren();
+	if (node.children().begin() == node.children().end()) {
+		throw DeadlyImportError("Invalid children definition.");
+	}
 	// read children nodes
 	bool read_flag[6] = { false, false, false, false, false, false };
 
-	ParseHelper_Node_Enter(ne);
-	if(!pUseOldName)
-	{
-		MACRO_NODECHECK_LOOPBEGIN("texmap");
-			MACRO_NODECHECK_READCOMP_F("utex1", read_flag[0], als.TextureCoordinate[0].x);
-			MACRO_NODECHECK_READCOMP_F("utex2", read_flag[1], als.TextureCoordinate[1].x);
-			MACRO_NODECHECK_READCOMP_F("utex3", read_flag[2], als.TextureCoordinate[2].x);
-			MACRO_NODECHECK_READCOMP_F("vtex1", read_flag[3], als.TextureCoordinate[0].y);
-			MACRO_NODECHECK_READCOMP_F("vtex2", read_flag[4], als.TextureCoordinate[1].y);
-			MACRO_NODECHECK_READCOMP_F("vtex3", read_flag[5], als.TextureCoordinate[2].y);
-		MACRO_NODECHECK_LOOPEND("texmap");
-	}
-	else
-	{
-		MACRO_NODECHECK_LOOPBEGIN("map");
-			MACRO_NODECHECK_READCOMP_F("u1", read_flag[0], als.TextureCoordinate[0].x);
-			MACRO_NODECHECK_READCOMP_F("u2", read_flag[1], als.TextureCoordinate[1].x);
-			MACRO_NODECHECK_READCOMP_F("u3", read_flag[2], als.TextureCoordinate[2].x);
-			MACRO_NODECHECK_READCOMP_F("v1", read_flag[3], als.TextureCoordinate[0].y);
-			MACRO_NODECHECK_READCOMP_F("v2", read_flag[4], als.TextureCoordinate[1].y);
-			MACRO_NODECHECK_READCOMP_F("v3", read_flag[5], als.TextureCoordinate[2].y);
-		MACRO_NODECHECK_LOOPEND("map");
-	}// if(!pUseOldName) else
+	if (!pUseOldName) {
+        ParseHelper_Node_Enter(ne);
+        for ( XmlNode &currentNode : node.children()) {
+            const std::string &name = currentNode.name();
+            if (name == "utex1") {
+				read_flag[0] = true;
+                XmlParser::getValueAsFloat(node, als.TextureCoordinate[0].x);
+            } else if (name == "utex2") {
+				read_flag[1] = true;
+                XmlParser::getValueAsFloat(node, als.TextureCoordinate[1].x);
+            } else if (name == "utex3") {
+				read_flag[2] = true;
+                XmlParser::getValueAsFloat(node, als.TextureCoordinate[2].x);
+            } else if (name == "vtex1") {
+				read_flag[3] = true;
+                XmlParser::getValueAsFloat(node, als.TextureCoordinate[0].y);
+            } else if (name == "vtex2") {
+				read_flag[4] = true;
+                XmlParser::getValueAsFloat(node, als.TextureCoordinate[1].y);
+            } else if (name == "vtex3") {
+				read_flag[5] = true;
+                XmlParser::getValueAsFloat(node, als.TextureCoordinate[2].y);
+			}
+		}
+        ParseHelper_Node_Exit();
 
-	ParseHelper_Node_Exit();
+	} else {
+		for (pugi::xml_attribute &attr : node.attributes()) {
+            const std::string name = attr.name();
+            if (name == "u") {
+				read_flag[0] = true;
+				als.TextureCoordinate[0].x = attr.as_float();
+            } else if (name == "u2") {
+				read_flag[1] = true;
+				als.TextureCoordinate[1].x = attr.as_float();
+            } else if (name == "u3") {
+				read_flag[2] = true;
+				als.TextureCoordinate[2].x = attr.as_float();
+            } else if (name == "v1") {
+				read_flag[3] = true;
+				als.TextureCoordinate[0].y = attr.as_float();
+            } else if (name == "v2") {
+				read_flag[4] = true;
+				als.TextureCoordinate[1].y = attr.as_float();
+            } else if (name == "v3") {
+				read_flag[5] = true;
+				als.TextureCoordinate[0].y = attr.as_float();
+			}
+		}
+	}
 
 	// check that all components was defined
-	if(!(read_flag[0] && read_flag[1] && read_flag[2] && read_flag[3] && read_flag[4] && read_flag[5]))
+	if (!(read_flag[0] && read_flag[1] && read_flag[2] && read_flag[3] && read_flag[4] && read_flag[5])) {
 		throw DeadlyImportError("Not all texture coordinates are defined.");
+	}
 
 	// copy attributes data
 	als.TextureID_R = rtexid;
@@ -321,7 +319,7 @@ void AMFImporter::ParseNode_TexMap(const bool pUseOldName) {
 	als.TextureID_B = btexid;
 	als.TextureID_A = atexid;
 
-	mNodeElement_List.push_back(ne);// add to node element list because its a new object in graph.
+	mNodeElement_List.push_back(ne);
 }
 
 }// namespace Assimp
diff --git a/Engine/lib/assimp/code/AssetLib/AMF/AMFImporter_Node.hpp b/Engine/lib/assimp/code/AssetLib/AMF/AMFImporter_Node.hpp
new file mode 100644
index 000000000..c827533a6
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/AMF/AMFImporter_Node.hpp
@@ -0,0 +1,305 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/// \file AMFImporter_Node.hpp
+/// \brief Elements of scene graph.
+/// \date 2016
+/// \author smal.root@gmail.com
+
+#pragma once
+#ifndef INCLUDED_AI_AMF_IMPORTER_NODE_H
+#define INCLUDED_AI_AMF_IMPORTER_NODE_H
+
+// Header files, Assimp.
+#include <assimp/scene.h>
+#include <assimp/types.h>
+
+#include <list>
+#include <string>
+#include <vector>
+
+/// \class CAMFImporter_NodeElement
+/// Base class for elements of nodes.
+class AMFNodeElementBase {
+public:
+	/// Define what data type contain node element.
+	enum EType {
+		ENET_Color, ///< Color element: <color>.
+		ENET_Constellation, ///< Grouping element: <constellation>.
+		ENET_Coordinates, ///< Coordinates element: <coordinates>.
+		ENET_Edge, ///< Edge element: <edge>.
+		ENET_Instance, ///< Grouping element: <constellation>.
+		ENET_Material, ///< Material element: <material>.
+		ENET_Metadata, ///< Metadata element: <metadata>.
+		ENET_Mesh, ///< Metadata element: <mesh>.
+		ENET_Object, ///< Element which hold object: <object>.
+		ENET_Root, ///< Root element: <amf>.
+		ENET_Triangle, ///< Triangle element: <triangle>.
+		ENET_TexMap, ///< Texture coordinates element: <texmap> or <map>.
+		ENET_Texture, ///< Texture element: <texture>.
+		ENET_Vertex, ///< Vertex element: <vertex>.
+		ENET_Vertices, ///< Vertex element: <vertices>.
+		ENET_Volume, ///< Volume element: <volume>.
+
+		ENET_Invalid ///< Element has invalid type and possible contain invalid data.
+	};
+
+	const EType Type; ///< Type of element.
+	std::string ID; ///< ID of element.
+	AMFNodeElementBase *Parent; ///< Parent element. If nullptr then this node is root.
+	std::list<AMFNodeElementBase *> Child; ///< Child elements.
+
+public: /// Destructor, virtual..
+	virtual ~AMFNodeElementBase() {
+		// empty
+	}
+
+	/// Disabled copy constructor and co.
+	AMFNodeElementBase(const AMFNodeElementBase &pNodeElement) = delete;
+	AMFNodeElementBase(AMFNodeElementBase &&) = delete;
+	AMFNodeElementBase &operator=(const AMFNodeElementBase &pNodeElement) = delete;
+	AMFNodeElementBase() = delete;
+
+protected:
+	/// In constructor inheritor must set element type.
+	/// \param [in] pType - element type.
+	/// \param [in] pParent - parent element.
+	AMFNodeElementBase(const EType pType, AMFNodeElementBase *pParent) :
+			Type(pType), ID(), Parent(pParent), Child() {
+		// empty
+	}
+}; // class IAMFImporter_NodeElement
+
+/// \struct CAMFImporter_NodeElement_Constellation
+/// A collection of objects or constellations with specific relative locations.
+struct AMFConstellation : public AMFNodeElementBase {
+	/// Constructor.
+	/// \param [in] pParent - pointer to parent node.
+	AMFConstellation(AMFNodeElementBase *pParent) :
+			AMFNodeElementBase(ENET_Constellation, pParent) {}
+
+}; // struct CAMFImporter_NodeElement_Constellation
+
+/// \struct CAMFImporter_NodeElement_Instance
+/// Part of constellation.
+struct AMFInstance : public AMFNodeElementBase {
+
+	std::string ObjectID; ///< ID of object for instantiation.
+	/// \var Delta - The distance of translation in the x, y, or z direction, respectively, in the referenced object's coordinate system, to
+	/// create an instance of the object in the current constellation.
+	aiVector3D Delta;
+
+	/// \var Rotation - The rotation, in degrees, to rotate the referenced object about its x, y, and z axes, respectively, to create an
+	/// instance of the object in the current constellation. Rotations shall be executed in order of x first, then y, then z.
+	aiVector3D Rotation;
+
+	/// Constructor.
+	/// \param [in] pParent - pointer to parent node.
+	AMFInstance(AMFNodeElementBase *pParent) :
+			AMFNodeElementBase(ENET_Instance, pParent) {}
+};
+
+/// \struct CAMFImporter_NodeElement_Metadata
+/// Structure that define metadata node.
+struct AMFMetadata : public AMFNodeElementBase {
+
+	std::string Type; ///< Type of "Value".
+	std::string Value; ///< Value.
+
+	/// Constructor.
+	/// \param [in] pParent - pointer to parent node.
+	AMFMetadata(AMFNodeElementBase *pParent) :
+			AMFNodeElementBase(ENET_Metadata, pParent) {}
+};
+
+/// \struct CAMFImporter_NodeElement_Root
+/// Structure that define root node.
+struct AMFRoot : public AMFNodeElementBase {
+
+	std::string Unit; ///< The units to be used. May be "inch", "millimeter", "meter", "feet", or "micron".
+	std::string Version; ///< Version of format.
+
+	/// Constructor.
+	/// \param [in] pParent - pointer to parent node.
+	AMFRoot(AMFNodeElementBase *pParent) :
+			AMFNodeElementBase(ENET_Root, pParent) {}
+};
+
+/// \struct CAMFImporter_NodeElement_Color
+/// Structure that define object node.
+struct AMFColor : public AMFNodeElementBase {
+	bool Composed; ///< Type of color stored: if true then look for formula in \ref Color_Composed[4], else - in \ref Color.
+	std::string Color_Composed[4]; ///< By components formulas of composed color. [0..3] - RGBA.
+	aiColor4D Color; ///< Constant color.
+	std::string Profile; ///< The ICC color space used to interpret the three color channels r, g and b..
+
+	/// @brief  Constructor.
+	/// @param [in] pParent - pointer to parent node.
+	AMFColor(AMFNodeElementBase *pParent) :
+			AMFNodeElementBase(ENET_Color, pParent), Composed(false), Color(), Profile() {
+		// empty
+	}
+};
+
+/// \struct CAMFImporter_NodeElement_Material
+/// Structure that define material node.
+struct AMFMaterial : public AMFNodeElementBase {
+
+	/// Constructor.
+	/// \param [in] pParent - pointer to parent node.
+	AMFMaterial(AMFNodeElementBase *pParent) :
+			AMFNodeElementBase(ENET_Material, pParent) {}
+};
+
+/// \struct CAMFImporter_NodeElement_Object
+/// Structure that define object node.
+struct AMFObject : public AMFNodeElementBase {
+
+	/// Constructor.
+	/// \param [in] pParent - pointer to parent node.
+	AMFObject(AMFNodeElementBase *pParent) :
+			AMFNodeElementBase(ENET_Object, pParent) {}
+};
+
+/// \struct CAMFImporter_NodeElement_Mesh
+/// Structure that define mesh node.
+struct AMFMesh : public AMFNodeElementBase {
+	/// Constructor.
+	/// \param [in] pParent - pointer to parent node.
+	AMFMesh(AMFNodeElementBase *pParent) :
+			AMFNodeElementBase(ENET_Mesh, pParent) {}
+};
+
+/// \struct CAMFImporter_NodeElement_Vertex
+/// Structure that define vertex node.
+struct AMFVertex : public AMFNodeElementBase {
+	/// Constructor.
+	/// \param [in] pParent - pointer to parent node.
+	AMFVertex(AMFNodeElementBase *pParent) :
+			AMFNodeElementBase(ENET_Vertex, pParent) {}
+};
+
+/// \struct CAMFImporter_NodeElement_Edge
+/// Structure that define edge node.
+struct AMFEdge : public AMFNodeElementBase {
+	/// Constructor.
+	/// \param [in] pParent - pointer to parent node.
+	AMFEdge(AMFNodeElementBase *pParent) :
+			AMFNodeElementBase(ENET_Edge, pParent) {}
+};
+
+/// \struct CAMFImporter_NodeElement_Vertices
+/// Structure that define vertices node.
+struct AMFVertices : public AMFNodeElementBase {
+	/// Constructor.
+	/// \param [in] pParent - pointer to parent node.
+	AMFVertices(AMFNodeElementBase *pParent) :
+			AMFNodeElementBase(ENET_Vertices, pParent) {}
+};
+
+/// \struct CAMFImporter_NodeElement_Volume
+/// Structure that define volume node.
+struct AMFVolume : public AMFNodeElementBase {
+	std::string MaterialID; ///< Which material to use.
+	std::string Type; ///< What this volume describes can be "region" or "support". If none specified, "object" is assumed.
+
+	/// Constructor.
+	/// \param [in] pParent - pointer to parent node.
+	AMFVolume(AMFNodeElementBase *pParent) :
+			AMFNodeElementBase(ENET_Volume, pParent) {}
+};
+
+/// \struct CAMFImporter_NodeElement_Coordinates
+/// Structure that define coordinates node.
+struct AMFCoordinates : public AMFNodeElementBase {
+	aiVector3D Coordinate; ///< Coordinate.
+
+	/// Constructor.
+	/// \param [in] pParent - pointer to parent node.
+	AMFCoordinates(AMFNodeElementBase *pParent) :
+			AMFNodeElementBase(ENET_Coordinates, pParent) {}
+};
+
+/// \struct CAMFImporter_NodeElement_TexMap
+/// Structure that define texture coordinates node.
+struct AMFTexMap : public AMFNodeElementBase {
+	aiVector3D TextureCoordinate[3]; ///< Texture coordinates.
+	std::string TextureID_R; ///< Texture ID for red color component.
+	std::string TextureID_G; ///< Texture ID for green color component.
+	std::string TextureID_B; ///< Texture ID for blue color component.
+	std::string TextureID_A; ///< Texture ID for alpha color component.
+
+	/// Constructor.
+	/// \param [in] pParent - pointer to parent node.
+	AMFTexMap(AMFNodeElementBase *pParent) :
+			AMFNodeElementBase(ENET_TexMap, pParent), TextureCoordinate{}, TextureID_R(), TextureID_G(), TextureID_B(), TextureID_A() {
+		// empty
+	}
+};
+
+/// \struct CAMFImporter_NodeElement_Triangle
+/// Structure that define triangle node.
+struct AMFTriangle : public AMFNodeElementBase {
+	size_t V[3]; ///< Triangle vertices.
+
+	/// Constructor.
+	/// \param [in] pParent - pointer to parent node.
+	AMFTriangle(AMFNodeElementBase *pParent) :
+			AMFNodeElementBase(ENET_Triangle, pParent) {
+		// empty
+	}
+};
+
+/// Structure that define texture node.
+struct AMFTexture : public AMFNodeElementBase {
+	size_t Width, Height, Depth; ///< Size of the texture.
+	std::vector<uint8_t> Data; ///< Data of the texture.
+	bool Tiled;
+
+	/// Constructor.
+	/// \param [in] pParent - pointer to parent node.
+	AMFTexture(AMFNodeElementBase *pParent) :
+			AMFNodeElementBase(ENET_Texture, pParent), Width(0), Height(0), Depth(0), Data(), Tiled(false) {
+		// empty
+	}
+};
+
+#endif // INCLUDED_AI_AMF_IMPORTER_NODE_H
diff --git a/Engine/lib/assimp/code/AssetLib/AMF/AMFImporter_Postprocess.cpp b/Engine/lib/assimp/code/AssetLib/AMF/AMFImporter_Postprocess.cpp
new file mode 100644
index 000000000..a65f9260e
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/AMF/AMFImporter_Postprocess.cpp
@@ -0,0 +1,894 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/// \file AMFImporter_Postprocess.cpp
+/// \brief Convert built scenegraph and objects to Assimp scenegraph.
+/// \date 2016
+/// \author smal.root@gmail.com
+
+#ifndef ASSIMP_BUILD_NO_AMF_IMPORTER
+
+#include "AMFImporter.hpp"
+
+#include <assimp/SceneCombiner.h>
+#include <assimp/StandardShapes.h>
+#include <assimp/StringUtils.h>
+
+#include <iterator>
+
+namespace Assimp {
+
+aiColor4D AMFImporter::SPP_Material::GetColor(const float /*pX*/, const float /*pY*/, const float /*pZ*/) const {
+    aiColor4D tcol;
+
+    // Check if stored data are supported.
+    if (!Composition.empty()) {
+        throw DeadlyImportError("IME. GetColor for composition");
+    }
+
+    if (Color->Composed) {
+        throw DeadlyImportError("IME. GetColor, composed color");
+    }
+
+    tcol = Color->Color;
+
+    // Check if default color must be used
+    if ((tcol.r == 0) && (tcol.g == 0) && (tcol.b == 0) && (tcol.a == 0)) {
+        tcol.r = 0.5f;
+        tcol.g = 0.5f;
+        tcol.b = 0.5f;
+        tcol.a = 1;
+    }
+
+    return tcol;
+}
+
+void AMFImporter::PostprocessHelper_CreateMeshDataArray(const AMFMesh &nodeElement, std::vector<aiVector3D> &vertexCoordinateArray,
+        std::vector<AMFColor *> &pVertexColorArray) const {
+    AMFVertices  *vn = nullptr;
+    size_t col_idx;
+
+    // All data stored in "vertices", search for it.
+    for (AMFNodeElementBase *ne_child : nodeElement.Child) {
+        if (ne_child->Type == AMFNodeElementBase::ENET_Vertices) {
+            vn = (AMFVertices*)ne_child;
+        }
+    }
+
+    // If "vertices" not found then no work for us.
+    if (vn == nullptr) {
+        return;
+    }
+
+    // all coordinates stored as child and we need to reserve space for future push_back's.
+    vertexCoordinateArray.reserve(vn->Child.size());
+
+    // colors count equal vertices count.
+    pVertexColorArray.resize(vn->Child.size());
+    col_idx = 0;
+
+    // Inside vertices collect all data and place to arrays
+    for (AMFNodeElementBase *vn_child : vn->Child) {
+        // vertices, colors
+        if (vn_child->Type == AMFNodeElementBase::ENET_Vertex) {
+            // by default clear color for current vertex
+            pVertexColorArray[col_idx] = nullptr;
+
+            for (AMFNodeElementBase *vtx : vn_child->Child) {
+                if (vtx->Type == AMFNodeElementBase::ENET_Coordinates) {
+                    vertexCoordinateArray.push_back(((AMFCoordinates *)vtx)->Coordinate);
+                    continue;
+                }
+
+                if (vtx->Type == AMFNodeElementBase::ENET_Color) {
+                    pVertexColorArray[col_idx] = (AMFColor *)vtx;
+                    continue;
+                }
+            }
+
+            ++col_idx;
+        }
+    }
+}
+
+size_t AMFImporter::PostprocessHelper_GetTextureID_Or_Create(const std::string &r, const std::string &g, const std::string &b, const std::string &a) {
+    if (r.empty() && g.empty() && b.empty() && a.empty()) {
+        throw DeadlyImportError("PostprocessHelper_GetTextureID_Or_Create. At least one texture ID must be defined.");
+    }
+
+    std::string TextureConverted_ID = r + "_" + g + "_" + b + "_" + a;
+    size_t TextureConverted_Index = 0;
+    for (const SPP_Texture &tex_convd : mTexture_Converted) {
+        if (tex_convd.ID == TextureConverted_ID) {
+            return TextureConverted_Index;
+        } else {
+            ++TextureConverted_Index;
+        }
+    }
+
+    // Converted texture not found, create it.
+    AMFTexture *src_texture[4] {
+        nullptr
+    };
+    std::vector<AMFTexture *> src_texture_4check;
+    SPP_Texture converted_texture;
+
+    { // find all specified source textures
+        AMFNodeElementBase *t_tex = nullptr;
+
+        // R
+        if (!r.empty()) {
+            if (!Find_NodeElement(r, AMFNodeElementBase::EType::ENET_Texture, &t_tex)) {
+                Throw_ID_NotFound(r);
+            }
+
+            src_texture[0] = (AMFTexture *)t_tex;
+            src_texture_4check.push_back((AMFTexture *)t_tex);
+        } else {
+            src_texture[0] = nullptr;
+        }
+
+        // G
+        if (!g.empty()) {
+            if (!Find_NodeElement(g, AMFNodeElementBase::ENET_Texture, &t_tex)) {
+                Throw_ID_NotFound(g);
+            }
+
+            src_texture[1] = (AMFTexture *)t_tex;
+            src_texture_4check.push_back((AMFTexture *)t_tex);
+        } else {
+            src_texture[1] = nullptr;
+        }
+
+        // B
+        if (!b.empty()) {
+            if (!Find_NodeElement(b, AMFNodeElementBase::ENET_Texture, &t_tex)) {
+                Throw_ID_NotFound(b);
+            }
+
+            src_texture[2] = (AMFTexture *)t_tex;
+            src_texture_4check.push_back((AMFTexture *)t_tex);
+        } else {
+            src_texture[2] = nullptr;
+        }
+
+        // A
+        if (!a.empty()) {
+            if (!Find_NodeElement(a, AMFNodeElementBase::ENET_Texture, &t_tex)) {
+                Throw_ID_NotFound(a);
+            }
+
+            src_texture[3] = (AMFTexture *)t_tex;
+            src_texture_4check.push_back((AMFTexture *)t_tex);
+        } else {
+            src_texture[3] = nullptr;
+        }
+    } // END: find all specified source textures
+
+    // check that all textures has same size
+    if (src_texture_4check.size() > 1) {
+        for (size_t i = 0, i_e = (src_texture_4check.size() - 1); i < i_e; i++) {
+            if ((src_texture_4check[i]->Width != src_texture_4check[i + 1]->Width) || (src_texture_4check[i]->Height != src_texture_4check[i + 1]->Height) ||
+                    (src_texture_4check[i]->Depth != src_texture_4check[i + 1]->Depth)) {
+                throw DeadlyImportError("PostprocessHelper_GetTextureID_Or_Create. Source texture must has the same size.");
+            }
+        }
+    } // if(src_texture_4check.size() > 1)
+
+    // set texture attributes
+    converted_texture.Width = src_texture_4check[0]->Width;
+    converted_texture.Height = src_texture_4check[0]->Height;
+    converted_texture.Depth = src_texture_4check[0]->Depth;
+    // if one of source texture is tiled then converted texture is tiled too.
+    converted_texture.Tiled = false;
+    for (uint8_t i = 0; i < src_texture_4check.size(); ++i) {
+        converted_texture.Tiled |= src_texture_4check[i]->Tiled;
+    }
+
+    // Create format hint.
+    strcpy(converted_texture.FormatHint, "rgba0000"); // copy initial string.
+    if (!r.empty()) converted_texture.FormatHint[4] = '8';
+    if (!g.empty()) converted_texture.FormatHint[5] = '8';
+    if (!b.empty()) converted_texture.FormatHint[6] = '8';
+    if (!a.empty()) converted_texture.FormatHint[7] = '8';
+
+    // Сopy data of textures.
+    size_t tex_size = 0;
+    size_t step = 0;
+    size_t off_g = 0;
+    size_t off_b = 0;
+
+    // Calculate size of the target array and rule how data will be copied.
+    if (!r.empty() && nullptr != src_texture[0]) {
+        tex_size += src_texture[0]->Data.size();
+        step++, off_g++, off_b++;
+    }
+    if (!g.empty() && nullptr != src_texture[1]) {
+        tex_size += src_texture[1]->Data.size();
+        step++, off_b++;
+    }
+    if (!b.empty() && nullptr != src_texture[2]) {
+        tex_size += src_texture[2]->Data.size();
+        step++;
+    }
+    if (!a.empty() && nullptr != src_texture[3]) {
+        tex_size += src_texture[3]->Data.size();
+        step++;
+    }
+
+    // Create target array.
+    converted_texture.Data = new uint8_t[tex_size];
+    // And copy data
+    auto CopyTextureData = [&](const std::string &pID, const size_t pOffset, const size_t pStep, const uint8_t pSrcTexNum) -> void {
+        if (!pID.empty()) {
+            for (size_t idx_target = pOffset, idx_src = 0; idx_target < tex_size; idx_target += pStep, idx_src++) {
+                AMFTexture *tex = src_texture[pSrcTexNum];
+                ai_assert(tex);
+                converted_texture.Data[idx_target] = tex->Data.at(idx_src);
+            }
+        }
+    }; // auto CopyTextureData = [&](const size_t pOffset, const size_t pStep, const uint8_t pSrcTexNum) -> void
+
+    CopyTextureData(r, 0, step, 0);
+    CopyTextureData(g, off_g, step, 1);
+    CopyTextureData(b, off_b, step, 2);
+    CopyTextureData(a, step - 1, step, 3);
+
+    // Store new converted texture ID
+    converted_texture.ID = TextureConverted_ID;
+    // Store new converted texture
+    mTexture_Converted.push_back(converted_texture);
+
+    return TextureConverted_Index;
+}
+
+void AMFImporter::PostprocessHelper_SplitFacesByTextureID(std::list<SComplexFace> &pInputList, std::list<std::list<SComplexFace>> &pOutputList_Separated) {
+    auto texmap_is_equal = [](const AMFTexMap *pTexMap1, const AMFTexMap *pTexMap2) -> bool {
+        if ((pTexMap1 == nullptr) && (pTexMap2 == nullptr)) return true;
+        if (pTexMap1 == nullptr) return false;
+        if (pTexMap2 == nullptr) return false;
+
+        if (pTexMap1->TextureID_R != pTexMap2->TextureID_R) return false;
+        if (pTexMap1->TextureID_G != pTexMap2->TextureID_G) return false;
+        if (pTexMap1->TextureID_B != pTexMap2->TextureID_B) return false;
+        if (pTexMap1->TextureID_A != pTexMap2->TextureID_A) return false;
+
+        return true;
+    };
+
+    pOutputList_Separated.clear();
+    if (pInputList.empty()) return;
+
+    do {
+        SComplexFace face_start = pInputList.front();
+        std::list<SComplexFace> face_list_cur;
+
+        for (std::list<SComplexFace>::iterator it = pInputList.begin(), it_end = pInputList.end(); it != it_end;) {
+            if (texmap_is_equal(face_start.TexMap, it->TexMap)) {
+                auto it_old = it;
+
+                ++it;
+                face_list_cur.push_back(*it_old);
+                pInputList.erase(it_old);
+            } else {
+                ++it;
+            }
+        }
+
+        if (!face_list_cur.empty()) pOutputList_Separated.push_back(face_list_cur);
+
+    } while (!pInputList.empty());
+}
+
+void AMFImporter::Postprocess_AddMetadata(const AMFMetaDataArray &metadataList, aiNode &sceneNode) const {
+    if (metadataList.empty()) {
+        return;
+    }
+
+    if (sceneNode.mMetaData != nullptr) {
+        throw DeadlyImportError("Postprocess. MetaData member in node are not nullptr. Something went wrong.");
+    }
+
+    // copy collected metadata to output node.
+    sceneNode.mMetaData = aiMetadata::Alloc(static_cast<unsigned int>(metadataList.size()));
+    size_t meta_idx(0);
+
+    for (const AMFMetadata *metadata : metadataList) {
+        sceneNode.mMetaData->Set(static_cast<unsigned int>(meta_idx++), metadata->Type, aiString(metadata->Value));
+    }
+}
+
+void AMFImporter::Postprocess_BuildNodeAndObject(const AMFObject &pNodeElement, MeshArray &meshList, aiNode **pSceneNode) {
+    AMFColor *object_color = nullptr;
+
+    // create new aiNode and set name as <object> has.
+    *pSceneNode = new aiNode;
+    (*pSceneNode)->mName = pNodeElement.ID;
+    // read mesh and color
+    for (const AMFNodeElementBase *ne_child : pNodeElement.Child) {
+        std::vector<aiVector3D> vertex_arr;
+        std::vector<AMFColor *> color_arr;
+
+        // color for object
+        if (ne_child->Type == AMFNodeElementBase::ENET_Color) {
+            object_color = (AMFColor *) ne_child;
+        }
+
+        if (ne_child->Type == AMFNodeElementBase::ENET_Mesh) {
+            // Create arrays from children of mesh: vertices.
+            PostprocessHelper_CreateMeshDataArray(*((AMFMesh *)ne_child), vertex_arr, color_arr);
+            // Use this arrays as a source when creating every aiMesh
+            Postprocess_BuildMeshSet(*((AMFMesh *)ne_child), vertex_arr, color_arr, object_color, meshList, **pSceneNode);
+        }
+    } // for(const CAMFImporter_NodeElement* ne_child: pNodeElement)
+}
+
+void AMFImporter::Postprocess_BuildMeshSet(const AMFMesh &pNodeElement, const std::vector<aiVector3D> &pVertexCoordinateArray,
+        const std::vector<AMFColor *> &pVertexColorArray, const AMFColor *pObjectColor, MeshArray &pMeshList, aiNode &pSceneNode) {
+    std::list<unsigned int> mesh_idx;
+
+    // all data stored in "volume", search for it.
+    for (const AMFNodeElementBase *ne_child : pNodeElement.Child) {
+        const AMFColor *ne_volume_color = nullptr;
+        const SPP_Material *cur_mat = nullptr;
+
+        if (ne_child->Type == AMFNodeElementBase::ENET_Volume) {
+            /******************* Get faces *******************/
+            const AMFVolume *ne_volume = reinterpret_cast<const AMFVolume *>(ne_child);
+
+            std::list<SComplexFace> complex_faces_list; // List of the faces of the volume.
+            std::list<std::list<SComplexFace>> complex_faces_toplist; // List of the face list for every mesh.
+
+            // check if volume use material
+            if (!ne_volume->MaterialID.empty()) {
+                if (!Find_ConvertedMaterial(ne_volume->MaterialID, &cur_mat)) {
+                    Throw_ID_NotFound(ne_volume->MaterialID);
+                }
+            }
+
+            // inside "volume" collect all data and place to arrays or create new objects
+            for (const AMFNodeElementBase *ne_volume_child : ne_volume->Child) {
+                // color for volume
+                if (ne_volume_child->Type == AMFNodeElementBase::ENET_Color) {
+                    ne_volume_color = reinterpret_cast<const AMFColor *>(ne_volume_child);
+                } else if (ne_volume_child->Type == AMFNodeElementBase::ENET_Triangle) // triangles, triangles colors
+                {
+                    const AMFTriangle &tri_al = *reinterpret_cast<const AMFTriangle *>(ne_volume_child);
+
+                    SComplexFace complex_face;
+
+                    // initialize pointers
+                    complex_face.Color = nullptr;
+                    complex_face.TexMap = nullptr;
+                    // get data from triangle children: color, texture coordinates.
+                    if (tri_al.Child.size()) {
+                        for (const AMFNodeElementBase *ne_triangle_child : tri_al.Child) {
+                            if (ne_triangle_child->Type == AMFNodeElementBase::ENET_Color)
+                                complex_face.Color = reinterpret_cast<const AMFColor *>(ne_triangle_child);
+                            else if (ne_triangle_child->Type == AMFNodeElementBase::ENET_TexMap)
+                                complex_face.TexMap = reinterpret_cast<const AMFTexMap *>(ne_triangle_child);
+                        }
+                    } // if(tri_al.Child.size())
+
+                    // create new face and store it.
+                    complex_face.Face.mNumIndices = 3;
+                    complex_face.Face.mIndices = new unsigned int[3];
+                    complex_face.Face.mIndices[0] = static_cast<unsigned int>(tri_al.V[0]);
+                    complex_face.Face.mIndices[1] = static_cast<unsigned int>(tri_al.V[1]);
+                    complex_face.Face.mIndices[2] = static_cast<unsigned int>(tri_al.V[2]);
+                    complex_faces_list.push_back(complex_face);
+                }
+            } // for(const CAMFImporter_NodeElement* ne_volume_child: ne_volume->Child)
+
+            /**** Split faces list: one list per mesh ****/
+            PostprocessHelper_SplitFacesByTextureID(complex_faces_list, complex_faces_toplist);
+
+            /***** Create mesh for every faces list ******/
+            for (std::list<SComplexFace> &face_list_cur : complex_faces_toplist) {
+                auto VertexIndex_GetMinimal = [](const std::list<SComplexFace> &pFaceList, const size_t *pBiggerThan) -> size_t {
+                    size_t rv = 0;
+
+                    if (pBiggerThan != nullptr) {
+                        bool found = false;
+                        const size_t biggerThan = *pBiggerThan;
+                        for (const SComplexFace &face : pFaceList) {
+                            for (size_t idx_vert = 0; idx_vert < face.Face.mNumIndices; idx_vert++) {
+                                if (face.Face.mIndices[idx_vert] > biggerThan) {
+                                    rv = face.Face.mIndices[idx_vert];
+                                    found = true;
+                                    break;
+                                }
+                            }
+
+                            if (found) {
+                                break;
+                            }
+                        }
+
+                        if (!found) {
+                            return *pBiggerThan;
+                        }
+                    } else {
+                        rv = pFaceList.front().Face.mIndices[0];
+                    } // if(pBiggerThan != nullptr) else
+
+                    for (const SComplexFace &face : pFaceList) {
+                        for (size_t vi = 0; vi < face.Face.mNumIndices; vi++) {
+                            if (face.Face.mIndices[vi] < rv) {
+                                if (pBiggerThan != nullptr) {
+                                    if (face.Face.mIndices[vi] > *pBiggerThan) rv = face.Face.mIndices[vi];
+                                } else {
+                                    rv = face.Face.mIndices[vi];
+                                }
+                            }
+                        }
+                    } // for(const SComplexFace& face: pFaceList)
+
+                    return rv;
+                }; // auto VertexIndex_GetMinimal = [](const std::list<SComplexFace>& pFaceList, const size_t* pBiggerThan) -> size_t
+
+                auto VertexIndex_Replace = [](std::list<SComplexFace> &pFaceList, const size_t pIdx_From, const size_t pIdx_To) -> void {
+                    for (const SComplexFace &face : pFaceList) {
+                        for (size_t vi = 0; vi < face.Face.mNumIndices; vi++) {
+                            if (face.Face.mIndices[vi] == pIdx_From) face.Face.mIndices[vi] = static_cast<unsigned int>(pIdx_To);
+                        }
+                    }
+                }; // auto VertexIndex_Replace = [](std::list<SComplexFace>& pFaceList, const size_t pIdx_From, const size_t pIdx_To) -> void
+
+                auto Vertex_CalculateColor = [&](const size_t pIdx) -> aiColor4D {
+                    // Color priorities(In descending order):
+                    // 1. triangle color;
+                    // 2. vertex color;
+                    // 3. volume color;
+                    // 4. object color;
+                    // 5. material;
+                    // 6. default - invisible coat.
+                    //
+                    // Fill vertices colors in color priority list above that's points from 1 to 6.
+                    if ((pIdx < pVertexColorArray.size()) && (pVertexColorArray[pIdx] != nullptr)) // check for vertex color
+                    {
+                        if (pVertexColorArray[pIdx]->Composed)
+                            throw DeadlyImportError("IME: vertex color composed");
+                        else
+                            return pVertexColorArray[pIdx]->Color;
+                    } else if (ne_volume_color != nullptr) // check for volume color
+                    {
+                        if (ne_volume_color->Composed)
+                            throw DeadlyImportError("IME: volume color composed");
+                        else
+                            return ne_volume_color->Color;
+                    } else if (pObjectColor != nullptr) // check for object color
+                    {
+                        if (pObjectColor->Composed)
+                            throw DeadlyImportError("IME: object color composed");
+                        else
+                            return pObjectColor->Color;
+                    } else if (cur_mat != nullptr) // check for material
+                    {
+                        return cur_mat->GetColor(pVertexCoordinateArray.at(pIdx).x, pVertexCoordinateArray.at(pIdx).y, pVertexCoordinateArray.at(pIdx).z);
+                    } else // set default color.
+                    {
+                        return { 0, 0, 0, 0 };
+                    } // if((vi < pVertexColorArray.size()) && (pVertexColorArray[vi] != nullptr)) else
+                }; // auto Vertex_CalculateColor = [&](const size_t pIdx) -> aiColor4D
+
+                aiMesh *tmesh = new aiMesh;
+
+                tmesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE; // Only triangles is supported by AMF.
+                //
+                // set geometry and colors (vertices)
+                //
+                // copy faces/triangles
+                tmesh->mNumFaces = static_cast<unsigned int>(face_list_cur.size());
+                tmesh->mFaces = new aiFace[tmesh->mNumFaces];
+
+                // Create vertices list and optimize indices. Optimization mean following.In AMF all volumes use one big list of vertices. And one volume
+                // can use only part of vertices list, for example: vertices list contain few thousands of vertices and volume use vertices 1, 3, 10.
+                // Do you need all this thousands of garbage? Of course no. So, optimization step transform sparse indices set to continuous.
+                size_t VertexCount_Max = tmesh->mNumFaces * 3; // 3 - triangles.
+                std::vector<aiVector3D> vert_arr, texcoord_arr;
+                std::vector<aiColor4D> col_arr;
+
+                vert_arr.reserve(VertexCount_Max * 2); // "* 2" - see below TODO.
+                col_arr.reserve(VertexCount_Max * 2);
+
+                { // fill arrays
+                    size_t vert_idx_from, vert_idx_to;
+
+                    // first iteration.
+                    vert_idx_to = 0;
+                    vert_idx_from = VertexIndex_GetMinimal(face_list_cur, nullptr);
+                    vert_arr.push_back(pVertexCoordinateArray.at(vert_idx_from));
+                    col_arr.push_back(Vertex_CalculateColor(vert_idx_from));
+                    if (vert_idx_from != vert_idx_to) VertexIndex_Replace(face_list_cur, vert_idx_from, vert_idx_to);
+
+                    // rest iterations
+                    do {
+                        vert_idx_from = VertexIndex_GetMinimal(face_list_cur, &vert_idx_to);
+                        if (vert_idx_from == vert_idx_to) break; // all indices are transferred,
+
+                        vert_arr.push_back(pVertexCoordinateArray.at(vert_idx_from));
+                        col_arr.push_back(Vertex_CalculateColor(vert_idx_from));
+                        vert_idx_to++;
+                        if (vert_idx_from != vert_idx_to) VertexIndex_Replace(face_list_cur, vert_idx_from, vert_idx_to);
+
+                    } while (true);
+                } // fill arrays. END.
+
+                //
+                // check if triangle colors are used and create additional faces if needed.
+                //
+                for (const SComplexFace &face_cur : face_list_cur) {
+                    if (face_cur.Color != nullptr) {
+                        aiColor4D face_color;
+                        size_t vert_idx_new = vert_arr.size();
+
+                        if (face_cur.Color->Composed)
+                            throw DeadlyImportError("IME: face color composed");
+                        else
+                            face_color = face_cur.Color->Color;
+
+                        for (size_t idx_ind = 0; idx_ind < face_cur.Face.mNumIndices; idx_ind++) {
+                            vert_arr.push_back(vert_arr.at(face_cur.Face.mIndices[idx_ind]));
+                            col_arr.push_back(face_color);
+                            face_cur.Face.mIndices[idx_ind] = static_cast<unsigned int>(vert_idx_new++);
+                        }
+                    } // if(face_cur.Color != nullptr)
+                } // for(const SComplexFace& face_cur: face_list_cur)
+
+                //
+                // if texture is used then copy texture coordinates too.
+                //
+                if (face_list_cur.front().TexMap != nullptr) {
+                    size_t idx_vert_new = vert_arr.size();
+                    ///TODO: clean unused vertices. "* 2": in certain cases - mesh full of triangle colors - vert_arr will contain duplicated vertices for
+                    /// colored triangles and initial vertices (for colored vertices) which in real became unused. This part need more thinking about
+                    /// optimization.
+                    bool *idx_vert_used;
+
+                    idx_vert_used = new bool[VertexCount_Max * 2];
+                    for (size_t i = 0, i_e = VertexCount_Max * 2; i < i_e; i++)
+                        idx_vert_used[i] = false;
+
+                    // This ID's will be used when set materials ID in scene.
+                    tmesh->mMaterialIndex = static_cast<unsigned int>(PostprocessHelper_GetTextureID_Or_Create(face_list_cur.front().TexMap->TextureID_R,
+                            face_list_cur.front().TexMap->TextureID_G,
+                            face_list_cur.front().TexMap->TextureID_B,
+                            face_list_cur.front().TexMap->TextureID_A));
+                    texcoord_arr.resize(VertexCount_Max * 2);
+                    for (const SComplexFace &face_cur : face_list_cur) {
+                        for (size_t idx_ind = 0; idx_ind < face_cur.Face.mNumIndices; idx_ind++) {
+                            const size_t idx_vert = face_cur.Face.mIndices[idx_ind];
+
+                            if (!idx_vert_used[idx_vert]) {
+                                texcoord_arr.at(idx_vert) = face_cur.TexMap->TextureCoordinate[idx_ind];
+                                idx_vert_used[idx_vert] = true;
+                            } else if (texcoord_arr.at(idx_vert) != face_cur.TexMap->TextureCoordinate[idx_ind]) {
+                                // in that case one vertex is shared with many texture coordinates. We need to duplicate vertex with another texture
+                                // coordinates.
+                                vert_arr.push_back(vert_arr.at(idx_vert));
+                                col_arr.push_back(col_arr.at(idx_vert));
+                                texcoord_arr.at(idx_vert_new) = face_cur.TexMap->TextureCoordinate[idx_ind];
+                                face_cur.Face.mIndices[idx_ind] = static_cast<unsigned int>(idx_vert_new++);
+                            }
+                        } // for(size_t idx_ind = 0; idx_ind < face_cur.Face.mNumIndices; idx_ind++)
+                    } // for(const SComplexFace& face_cur: face_list_cur)
+
+                    delete[] idx_vert_used;
+                    // shrink array
+                    texcoord_arr.resize(idx_vert_new);
+                } // if(face_list_cur.front().TexMap != nullptr)
+
+                //
+                // copy collected data to mesh
+                //
+                tmesh->mNumVertices = static_cast<unsigned int>(vert_arr.size());
+                tmesh->mVertices = new aiVector3D[tmesh->mNumVertices];
+                tmesh->mColors[0] = new aiColor4D[tmesh->mNumVertices];
+
+                memcpy(tmesh->mVertices, vert_arr.data(), tmesh->mNumVertices * sizeof(aiVector3D));
+                memcpy(tmesh->mColors[0], col_arr.data(), tmesh->mNumVertices * sizeof(aiColor4D));
+                if (texcoord_arr.size() > 0) {
+                    tmesh->mTextureCoords[0] = new aiVector3D[tmesh->mNumVertices];
+                    memcpy(tmesh->mTextureCoords[0], texcoord_arr.data(), tmesh->mNumVertices * sizeof(aiVector3D));
+                    tmesh->mNumUVComponents[0] = 2; // U and V stored in "x", "y" of aiVector3D.
+                }
+
+                size_t idx_face = 0;
+                for (const SComplexFace &face_cur : face_list_cur)
+                    tmesh->mFaces[idx_face++] = face_cur.Face;
+
+                // store new aiMesh
+                mesh_idx.push_back(static_cast<unsigned int>(pMeshList.size()));
+                pMeshList.push_back(tmesh);
+            } // for(const std::list<SComplexFace>& face_list_cur: complex_faces_toplist)
+        } // if(ne_child->Type == CAMFImporter_NodeElement::ENET_Volume)
+    } // for(const CAMFImporter_NodeElement* ne_child: pNodeElement.Child)
+
+    // if meshes was created then assign new indices with current aiNode
+    if (!mesh_idx.empty()) {
+        std::list<unsigned int>::const_iterator mit = mesh_idx.begin();
+
+        pSceneNode.mNumMeshes = static_cast<unsigned int>(mesh_idx.size());
+        pSceneNode.mMeshes = new unsigned int[pSceneNode.mNumMeshes];
+        for (size_t i = 0; i < pSceneNode.mNumMeshes; i++)
+            pSceneNode.mMeshes[i] = *mit++;
+    } // if(mesh_idx.size() > 0)
+}
+
+void AMFImporter::Postprocess_BuildMaterial(const AMFMaterial &pMaterial) {
+    SPP_Material new_mat;
+
+    new_mat.ID = pMaterial.ID;
+    for (const AMFNodeElementBase *mat_child : pMaterial.Child) {
+        if (mat_child->Type == AMFNodeElementBase::ENET_Color) {
+            new_mat.Color = (AMFColor*)mat_child;
+        } else if (mat_child->Type == AMFNodeElementBase::ENET_Metadata) {
+            new_mat.Metadata.push_back((AMFMetadata *)mat_child);
+        }
+    } // for(const CAMFImporter_NodeElement* mat_child; pMaterial.Child)
+
+    // place converted material to special list
+    mMaterial_Converted.push_back(new_mat);
+}
+
+void AMFImporter::Postprocess_BuildConstellation(AMFConstellation &pConstellation, NodeArray &nodeArray) const {
+    aiNode *con_node;
+    std::list<aiNode *> ch_node;
+
+    // We will build next hierarchy:
+    // aiNode as parent (<constellation>) for set of nodes as a children
+    //  |- aiNode for transformation (<instance> -> <delta...>, <r...>) - aiNode for pointing to object ("objectid")
+    //  ...
+    //  \_ aiNode for transformation (<instance> -> <delta...>, <r...>) - aiNode for pointing to object ("objectid")
+    con_node = new aiNode;
+    con_node->mName = pConstellation.ID;
+    // Walk through children and search for instances of another objects, constellations.
+    for (const AMFNodeElementBase *ne : pConstellation.Child) {
+        aiMatrix4x4 tmat;
+        aiNode *t_node;
+        aiNode *found_node;
+
+        if (ne->Type == AMFNodeElementBase::ENET_Metadata) continue;
+        if (ne->Type != AMFNodeElementBase::ENET_Instance) throw DeadlyImportError("Only <instance> nodes can be in <constellation>.");
+
+        // create alias for convenience
+        AMFInstance &als = *((AMFInstance *)ne);
+        // find referenced object
+        if (!Find_ConvertedNode(als.ObjectID, nodeArray, &found_node)) Throw_ID_NotFound(als.ObjectID);
+
+        // create node for applying transformation
+        t_node = new aiNode;
+        t_node->mParent = con_node;
+        // apply transformation
+        aiMatrix4x4::Translation(als.Delta, tmat), t_node->mTransformation *= tmat;
+        aiMatrix4x4::RotationX(als.Rotation.x, tmat), t_node->mTransformation *= tmat;
+        aiMatrix4x4::RotationY(als.Rotation.y, tmat), t_node->mTransformation *= tmat;
+        aiMatrix4x4::RotationZ(als.Rotation.z, tmat), t_node->mTransformation *= tmat;
+        // create array for one child node
+        t_node->mNumChildren = 1;
+        t_node->mChildren = new aiNode *[t_node->mNumChildren];
+        SceneCombiner::Copy(&t_node->mChildren[0], found_node);
+        t_node->mChildren[0]->mParent = t_node;
+        ch_node.push_back(t_node);
+    } // for(const CAMFImporter_NodeElement* ne: pConstellation.Child)
+
+    // copy found aiNode's as children
+    if (ch_node.empty()) throw DeadlyImportError("<constellation> must have at least one <instance>.");
+
+    size_t ch_idx = 0;
+
+    con_node->mNumChildren = static_cast<unsigned int>(ch_node.size());
+    con_node->mChildren = new aiNode *[con_node->mNumChildren];
+    for (aiNode *node : ch_node)
+        con_node->mChildren[ch_idx++] = node;
+
+    // and place "root" of <constellation> node to node list
+    nodeArray.push_back(con_node);
+}
+
+void AMFImporter::Postprocess_BuildScene(aiScene *pScene) {
+    NodeArray nodeArray;
+    MeshArray mesh_list;
+    AMFMetaDataArray meta_list;
+
+    //
+    // Because for AMF "material" is just complex colors mixing so aiMaterial will not be used.
+    // For building aiScene we are must to do few steps:
+    // at first creating root node for aiScene.
+    pScene->mRootNode = new aiNode;
+    pScene->mRootNode->mParent = nullptr;
+    pScene->mFlags |= AI_SCENE_FLAGS_ALLOW_SHARED;
+    // search for root(<amf>) element
+    AMFNodeElementBase *root_el = nullptr;
+
+    for (AMFNodeElementBase *ne : mNodeElement_List) {
+        if (ne->Type != AMFNodeElementBase::ENET_Root) {
+            continue;
+        }
+
+        root_el = ne;
+        break;
+    } // for(const CAMFImporter_NodeElement* ne: mNodeElement_List)
+
+    // Check if root element are found.
+    if (root_el == nullptr) {
+        throw DeadlyImportError("Root(<amf>) element not found.");
+    }
+
+    // after that walk through children of root and collect data. Five types of nodes can be placed at top level - in <amf>: <object>, <material>, <texture>,
+    // <constellation> and <metadata>. But at first we must read <material> and <texture> because they will be used in <object>. <metadata> can be read
+    // at any moment.
+    //
+    // 1. <material>
+    // 2. <texture> will be converted later when processing triangles list. \sa Postprocess_BuildMeshSet
+    for (const AMFNodeElementBase *root_child : root_el->Child) {
+        if (root_child->Type == AMFNodeElementBase::ENET_Material) {
+            Postprocess_BuildMaterial(*((AMFMaterial *)root_child));
+        }
+    }
+
+    // After "appearance" nodes we must read <object> because it will be used in <constellation> -> <instance>.
+    //
+    // 3. <object>
+    for (const AMFNodeElementBase *root_child : root_el->Child) {
+        if (root_child->Type == AMFNodeElementBase::ENET_Object) {
+            aiNode *tnode = nullptr;
+
+            // for <object> mesh and node must be built: object ID assigned to aiNode name and will be used in future for <instance>
+            Postprocess_BuildNodeAndObject(*((AMFObject *)root_child), mesh_list, &tnode);
+            if (tnode != nullptr) {
+                nodeArray.push_back(tnode);
+            }
+        }
+    } // for(const CAMFImporter_NodeElement* root_child: root_el->Child)
+
+    // And finally read rest of nodes.
+    //
+    for (const AMFNodeElementBase *root_child : root_el->Child) {
+        // 4. <constellation>
+        if (root_child->Type == AMFNodeElementBase::ENET_Constellation) {
+            // <object> and <constellation> at top of self abstraction use aiNode. So we can use only aiNode list for creating new aiNode's.
+            Postprocess_BuildConstellation(*((AMFConstellation *)root_child), nodeArray);
+        }
+
+        // 5, <metadata>
+        if (root_child->Type == AMFNodeElementBase::ENET_Metadata) meta_list.push_back((AMFMetadata *)root_child);
+    } // for(const CAMFImporter_NodeElement* root_child: root_el->Child)
+
+    // at now we can add collected metadata to root node
+    Postprocess_AddMetadata(meta_list, *pScene->mRootNode);
+    //
+    // Check constellation children
+    //
+    // As said in specification:
+    // "When multiple objects and constellations are defined in a single file, only the top level objects and constellations are available for printing."
+    // What that means? For example: if some object is used in constellation then you must show only constellation but not original object.
+    // And at this step we are checking that relations.
+nl_clean_loop:
+
+    if (nodeArray.size() > 1) {
+        // walk through all nodes
+        for (NodeArray::iterator nl_it = nodeArray.begin(); nl_it != nodeArray.end(); ++nl_it) {
+            // and try to find them in another top nodes.
+            NodeArray::const_iterator next_it = nl_it;
+
+            ++next_it;
+            for (; next_it != nodeArray.end(); ++next_it) {
+                if ((*next_it)->FindNode((*nl_it)->mName) != nullptr) {
+                    // if current top node(nl_it) found in another top node then erase it from node_list and restart search loop.
+                    nodeArray.erase(nl_it);
+
+                    goto nl_clean_loop;
+                }
+            } // for(; next_it != node_list.end(); next_it++)
+        } // for(std::list<aiNode*>::const_iterator nl_it = node_list.begin(); nl_it != node_list.end(); nl_it++)
+    }
+
+    //
+    // move created objects to aiScene
+    //
+    //
+    // Nodes
+    if (!nodeArray.empty()) {
+        NodeArray::const_iterator nl_it = nodeArray.begin();
+
+        pScene->mRootNode->mNumChildren = static_cast<unsigned int>(nodeArray.size());
+        pScene->mRootNode->mChildren = new aiNode *[pScene->mRootNode->mNumChildren];
+        for (size_t i = 0; i < pScene->mRootNode->mNumChildren; i++) {
+            // Objects and constellation that must be showed placed at top of hierarchy in <amf> node. So all aiNode's in node_list must have
+            // mRootNode only as parent.
+            (*nl_it)->mParent = pScene->mRootNode;
+            pScene->mRootNode->mChildren[i] = *nl_it++;
+        }
+    } // if(node_list.size() > 0)
+
+    //
+    // Meshes
+    if (!mesh_list.empty()) {
+        MeshArray::const_iterator ml_it = mesh_list.begin();
+
+        pScene->mNumMeshes = static_cast<unsigned int>(mesh_list.size());
+        pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
+        for (size_t i = 0; i < pScene->mNumMeshes; i++)
+            pScene->mMeshes[i] = *ml_it++;
+    } // if(mesh_list.size() > 0)
+
+    //
+    // Textures
+    pScene->mNumTextures = static_cast<unsigned int>(mTexture_Converted.size());
+    if (pScene->mNumTextures > 0) {
+        size_t idx;
+
+        idx = 0;
+        pScene->mTextures = new aiTexture *[pScene->mNumTextures];
+        for (const SPP_Texture &tex_convd : mTexture_Converted) {
+            pScene->mTextures[idx] = new aiTexture;
+            pScene->mTextures[idx]->mWidth = static_cast<unsigned int>(tex_convd.Width);
+            pScene->mTextures[idx]->mHeight = static_cast<unsigned int>(tex_convd.Height);
+            pScene->mTextures[idx]->pcData = (aiTexel *)tex_convd.Data;
+            // texture format description.
+            strcpy(pScene->mTextures[idx]->achFormatHint, tex_convd.FormatHint);
+            idx++;
+        } // for(const SPP_Texture& tex_convd: mTexture_Converted)
+
+        // Create materials for embedded textures.
+        idx = 0;
+        pScene->mNumMaterials = static_cast<unsigned int>(mTexture_Converted.size());
+        pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials];
+        for (const SPP_Texture &tex_convd : mTexture_Converted) {
+            const aiString texture_id(AI_EMBEDDED_TEXNAME_PREFIX + ai_to_string(idx));
+            const int mode = aiTextureOp_Multiply;
+            const int repeat = tex_convd.Tiled ? 1 : 0;
+
+            pScene->mMaterials[idx] = new aiMaterial;
+            pScene->mMaterials[idx]->AddProperty(&texture_id, AI_MATKEY_TEXTURE_DIFFUSE(0));
+            pScene->mMaterials[idx]->AddProperty(&mode, 1, AI_MATKEY_TEXOP_DIFFUSE(0));
+            pScene->mMaterials[idx]->AddProperty(&repeat, 1, AI_MATKEY_MAPPINGMODE_U_DIFFUSE(0));
+            pScene->mMaterials[idx]->AddProperty(&repeat, 1, AI_MATKEY_MAPPINGMODE_V_DIFFUSE(0));
+            idx++;
+        }
+    } // if(pScene->mNumTextures > 0)
+} // END: after that walk through children of root and collect data
+
+} // namespace Assimp
+
+#endif // !ASSIMP_BUILD_NO_AMF_IMPORTER
diff --git a/Engine/lib/assimp/code/ASE/ASELoader.cpp b/Engine/lib/assimp/code/AssetLib/ASE/ASELoader.cpp
similarity index 63%
rename from Engine/lib/assimp/code/ASE/ASELoader.cpp
rename to Engine/lib/assimp/code/AssetLib/ASE/ASELoader.cpp
index 8e99214a8..caa708961 100644
--- a/Engine/lib/assimp/code/ASE/ASELoader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/ASE/ASELoader.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -51,15 +49,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // internal headers
 #include "ASELoader.h"
-#include <assimp/StringComparison.h>
-#include <assimp/SkeletonMeshBuilder.h>
 #include "Common/TargetAnimation.h"
+#include <assimp/SkeletonMeshBuilder.h>
+#include <assimp/StringComparison.h>
 
-#include <assimp/Importer.hpp>
-#include <assimp/IOSystem.hpp>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/scene.h>
 #include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOSystem.hpp>
+#include <assimp/Importer.hpp>
 
 #include <memory>
 
@@ -84,12 +82,8 @@ static const aiImporterDesc desc = {
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-ASEImporter::ASEImporter()
-: mParser()
-, mBuffer()
-, pcScene()
-, configRecomputeNormals()
-, noSkeletonMesh() {
+ASEImporter::ASEImporter() :
+        mParser(), mBuffer(), pcScene(), configRecomputeNormals(), noSkeletonMesh() {
     // empty
 }
 
@@ -101,50 +95,42 @@ ASEImporter::~ASEImporter() {
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool ASEImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool cs) const {
-    // check file extension
-    const std::string extension = GetExtension(pFile);
-
-    if (extension == "ase" || extension == "ask") {
-        return true;
-    }
-
-    if ((!extension.length() || cs) && pIOHandler) {
-        const char* tokens[] = {"*3dsmax_asciiexport"};
-        return SearchFileHeaderForToken(pIOHandler,pFile,tokens,1);
-    }
-    return false;
+bool ASEImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
+    static const char *tokens[] = { "*3dsmax_asciiexport" };
+    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------
 // Loader meta information
-const aiImporterDesc* ASEImporter::GetInfo () const {
+const aiImporterDesc *ASEImporter::GetInfo() const {
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup configuration options
-void ASEImporter::SetupProperties(const Importer* pImp) {
+void ASEImporter::SetupProperties(const Importer *pImp) {
     configRecomputeNormals = (pImp->GetPropertyInteger(
-        AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS,1) ? true : false);
+                                      AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS, 1) ?
+                                      true :
+                                      false);
 
-    noSkeletonMesh = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_NO_SKELETON_MESHES,0) != 0;
+    noSkeletonMesh = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_NO_SKELETON_MESHES, 0) != 0;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void ASEImporter::InternReadFile( const std::string& pFile,
-    aiScene* pScene, IOSystem* pIOHandler) {
-    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));
+void ASEImporter::InternReadFile(const std::string &pFile,
+        aiScene *pScene, IOSystem *pIOHandler) {
+    std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));
 
     // Check whether we can read from the file
-    if( file.get() == nullptr) {
-        throw DeadlyImportError( "Failed to open ASE file " + pFile + ".");
+    if (file.get() == nullptr) {
+        throw DeadlyImportError("Failed to open ASE file ", pFile, ".");
     }
 
     // Allocate storage and copy the contents of the file to a memory buffer
     std::vector<char> mBuffer2;
-    TextFileToBuffer(file.get(),mBuffer2);
+    TextFileToBuffer(file.get(), mBuffer2);
 
     this->mBuffer = &mBuffer2[0];
     this->pcScene = pScene;
@@ -155,8 +141,8 @@ void ASEImporter::InternReadFile( const std::string& pFile,
     // ASE is the actual version 200 (that is currently written by max)
     // ------------------------------------------------------------------
     unsigned int defaultFormat;
-    std::string::size_type s = pFile.length()-1;
-    switch (pFile.c_str()[s])   {
+    std::string::size_type s = pFile.length() - 1;
+    switch (pFile.c_str()[s]) {
 
     case 'C':
     case 'c':
@@ -167,7 +153,7 @@ void ASEImporter::InternReadFile( const std::string& pFile,
     };
 
     // Construct an ASE parser and parse the file
-    ASE::Parser parser(mBuffer,defaultFormat);
+    ASE::Parser parser(mBuffer, defaultFormat);
     mParser = &parser;
     mParser->Parse();
 
@@ -175,7 +161,7 @@ void ASEImporter::InternReadFile( const std::string& pFile,
     // Check whether we god at least one mesh. If we did - generate
     // materials and copy meshes.
     // ------------------------------------------------------------------
-    if ( !mParser->m_vMeshes.empty())   {
+    if (!mParser->m_vMeshes.empty()) {
 
         // If absolutely no material has been loaded from the file
         // we need to generate a default material
@@ -183,32 +169,32 @@ void ASEImporter::InternReadFile( const std::string& pFile,
 
         // process all meshes
         bool tookNormals = false;
-        std::vector<aiMesh*> avOutMeshes;
-        avOutMeshes.reserve(mParser->m_vMeshes.size()*2);
-        for (std::vector<ASE::Mesh>::iterator i =  mParser->m_vMeshes.begin();i != mParser->m_vMeshes.end();++i)    {
+        std::vector<aiMesh *> avOutMeshes;
+        avOutMeshes.reserve(mParser->m_vMeshes.size() * 2);
+        for (std::vector<ASE::Mesh>::iterator i = mParser->m_vMeshes.begin(); i != mParser->m_vMeshes.end(); ++i) {
             if ((*i).bSkip) {
                 continue;
             }
             BuildUniqueRepresentation(*i);
 
             // Need to generate proper vertex normals if necessary
-            if(GenerateNormals(*i)) {
+            if (GenerateNormals(*i)) {
                 tookNormals = true;
             }
 
             // Convert all meshes to aiMesh objects
-            ConvertMeshes(*i,avOutMeshes);
+            ConvertMeshes(*i, avOutMeshes);
         }
-        if (tookNormals)    {
+        if (tookNormals) {
             ASSIMP_LOG_DEBUG("ASE: Taking normals from the file. Use "
-                "the AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS setting if you "
-                "experience problems");
+                             "the AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS setting if you "
+                             "experience problems");
         }
 
         // Now build the output mesh list. Remove dummies
         pScene->mNumMeshes = (unsigned int)avOutMeshes.size();
-        aiMesh** pp = pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];
-        for (std::vector<aiMesh*>::const_iterator i =  avOutMeshes.begin();i != avOutMeshes.end();++i) {
+        aiMesh **pp = pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
+        for (std::vector<aiMesh *>::const_iterator i = avOutMeshes.begin(); i != avOutMeshes.end(); ++i) {
             if (!(*i)->mNumFaces) {
                 continue;
             }
@@ -225,18 +211,21 @@ void ASEImporter::InternReadFile( const std::string& pFile,
     // Copy all scene graph nodes - lights, cameras, dummies and meshes
     // into one huge list.
     //------------------------------------------------------------------
-    std::vector<BaseNode*> nodes;
-    nodes.reserve(mParser->m_vMeshes.size() +mParser->m_vLights.size()
-        + mParser->m_vCameras.size() + mParser->m_vDummies.size());
+    std::vector<BaseNode *> nodes;
+    nodes.reserve(mParser->m_vMeshes.size() + mParser->m_vLights.size() + mParser->m_vCameras.size() + mParser->m_vDummies.size());
 
     // Lights
-    for (auto &light : mParser->m_vLights)nodes.push_back(&light);
+    for (auto &light : mParser->m_vLights)
+        nodes.push_back(&light);
     // Cameras
-    for (auto &camera : mParser->m_vCameras)nodes.push_back(&camera);
+    for (auto &camera : mParser->m_vCameras)
+        nodes.push_back(&camera);
     // Meshes
-    for (auto &mesh : mParser->m_vMeshes)nodes.push_back(&mesh);
+    for (auto &mesh : mParser->m_vMeshes)
+        nodes.push_back(&mesh);
     // Dummies
-    for (auto &dummy : mParser->m_vDummies)nodes.push_back(&dummy);
+    for (auto &dummy : mParser->m_vDummies)
+        nodes.push_back(&dummy);
 
     // build the final node graph
     BuildNodes(nodes);
@@ -255,7 +244,7 @@ void ASEImporter::InternReadFile( const std::string& pFile,
     // to build a mesh for the animation skeleton
     // FIXME: very strange results
     // ------------------------------------------------------------------
-    if (!pScene->mNumMeshes)    {
+    if (!pScene->mNumMeshes) {
         pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
         if (!noSkeletonMesh) {
             SkeletonMeshBuilder skeleton(pScene);
@@ -263,82 +252,80 @@ void ASEImporter::InternReadFile( const std::string& pFile,
     }
 }
 // ------------------------------------------------------------------------------------------------
-void ASEImporter::GenerateDefaultMaterial()
-{
-    ai_assert(NULL != mParser);
+void ASEImporter::GenerateDefaultMaterial() {
+    ai_assert(nullptr != mParser);
 
     bool bHas = false;
-    for (std::vector<ASE::Mesh>::iterator i =  mParser->m_vMeshes.begin();i != mParser->m_vMeshes.end();++i) {
-        if ((*i).bSkip)continue;
+    for (std::vector<ASE::Mesh>::iterator i = mParser->m_vMeshes.begin(); i != mParser->m_vMeshes.end(); ++i) {
+        if ((*i).bSkip) continue;
         if (ASE::Face::DEFAULT_MATINDEX == (*i).iMaterialIndex) {
             (*i).iMaterialIndex = (unsigned int)mParser->m_vMaterials.size();
             bHas = true;
         }
     }
-    if (bHas || mParser->m_vMaterials.empty())  {
+    if (bHas || mParser->m_vMaterials.empty()) {
         // add a simple material without submaterials to the parser's list
-        mParser->m_vMaterials.push_back ( ASE::Material(AI_DEFAULT_MATERIAL_NAME) );
-        ASE::Material& mat = mParser->m_vMaterials.back();
+        mParser->m_vMaterials.push_back(ASE::Material(AI_DEFAULT_MATERIAL_NAME));
+        ASE::Material &mat = mParser->m_vMaterials.back();
 
-        mat.mDiffuse  = aiColor3D(0.6f,0.6f,0.6f);
-        mat.mSpecular = aiColor3D(1.0f,1.0f,1.0f);
-        mat.mAmbient  = aiColor3D(0.05f,0.05f,0.05f);
-        mat.mShading  = Discreet3DS::Gouraud;
+        mat.mDiffuse = aiColor3D(0.6f, 0.6f, 0.6f);
+        mat.mSpecular = aiColor3D(1.0f, 1.0f, 1.0f);
+        mat.mAmbient = aiColor3D(0.05f, 0.05f, 0.05f);
+        mat.mShading = Discreet3DS::Gouraud;
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void ASEImporter::BuildAnimations(const std::vector<BaseNode*>& nodes)
-{
+void ASEImporter::BuildAnimations(const std::vector<BaseNode *> &nodes) {
     // check whether we have at least one mesh which has animations
-    std::vector<ASE::BaseNode*>::const_iterator i =  nodes.begin();
+    std::vector<ASE::BaseNode *>::const_iterator i = nodes.begin();
     unsigned int iNum = 0;
-    for (;i != nodes.end();++i) {
+    for (; i != nodes.end(); ++i) {
 
         // TODO: Implement Bezier & TCB support
         if ((*i)->mAnim.mPositionType != ASE::Animation::TRACK) {
             ASSIMP_LOG_WARN("ASE: Position controller uses Bezier/TCB keys. "
-                "This is not supported.");
+                            "This is not supported.");
         }
         if ((*i)->mAnim.mRotationType != ASE::Animation::TRACK) {
             ASSIMP_LOG_WARN("ASE: Rotation controller uses Bezier/TCB keys. "
-                "This is not supported.");
+                            "This is not supported.");
         }
-        if ((*i)->mAnim.mScalingType != ASE::Animation::TRACK)  {
+        if ((*i)->mAnim.mScalingType != ASE::Animation::TRACK) {
             ASSIMP_LOG_WARN("ASE: Position controller uses Bezier/TCB keys. "
-                "This is not supported.");
+                            "This is not supported.");
         }
 
         // We compare against 1 here - firstly one key is not
         // really an animation and secondly MAX writes dummies
         // that represent the node transformation.
-        if ((*i)->mAnim.akeyPositions.size()>1 || (*i)->mAnim.akeyRotations.size()>1 || (*i)->mAnim.akeyScaling.size()>1){
+        if ((*i)->mAnim.akeyPositions.size() > 1 || (*i)->mAnim.akeyRotations.size() > 1 || (*i)->mAnim.akeyScaling.size() > 1) {
             ++iNum;
         }
-        if ((*i)->mTargetAnim.akeyPositions.size() > 1 && is_not_qnan( (*i)->mTargetPosition.x )) {
+        if ((*i)->mTargetAnim.akeyPositions.size() > 1 && is_not_qnan((*i)->mTargetPosition.x)) {
             ++iNum;
         }
     }
-    if (iNum)   {
+    if (iNum) {
         // Generate a new animation channel and setup everything for it
         pcScene->mNumAnimations = 1;
-        pcScene->mAnimations    = new aiAnimation*[1];
-        aiAnimation* pcAnim     = pcScene->mAnimations[0] = new aiAnimation();
-        pcAnim->mNumChannels    = iNum;
-        pcAnim->mChannels       = new aiNodeAnim*[iNum];
+        pcScene->mAnimations = new aiAnimation *[1];
+        aiAnimation *pcAnim = pcScene->mAnimations[0] = new aiAnimation();
+        pcAnim->mNumChannels = iNum;
+        pcAnim->mChannels = new aiNodeAnim *[iNum];
         pcAnim->mTicksPerSecond = mParser->iFrameSpeed * mParser->iTicksPerFrame;
 
         iNum = 0;
 
         // Now iterate through all meshes and collect all data we can find
-        for (i =  nodes.begin();i != nodes.end();++i)   {
+        for (i = nodes.begin(); i != nodes.end(); ++i) {
 
-            ASE::BaseNode* me = *i;
-            if ( me->mTargetAnim.akeyPositions.size() > 1 && is_not_qnan( me->mTargetPosition.x ))  {
+            ASE::BaseNode *me = *i;
+            if (me->mTargetAnim.akeyPositions.size() > 1 && is_not_qnan(me->mTargetPosition.x)) {
                 // Generate an extra channel for the camera/light target.
                 // BuildNodes() does also generate an extra node, named
                 // <baseName>.Target.
-                aiNodeAnim* nd = pcAnim->mChannels[iNum++] = new aiNodeAnim();
+                aiNodeAnim *nd = pcAnim->mChannels[iNum++] = new aiNodeAnim();
                 nd->mNodeName.Set(me->mName + ".Target");
 
                 // If there is no input position channel we will need
@@ -357,32 +344,31 @@ void ASEImporter::BuildAnimations(const std::vector<BaseNode*>& nodes)
                 helper.Process(&me->mTargetAnim.akeyPositions);*/
 
                 // Allocate the key array and fill it
-                nd->mNumPositionKeys = (unsigned int) me->mTargetAnim.akeyPositions.size();
+                nd->mNumPositionKeys = (unsigned int)me->mTargetAnim.akeyPositions.size();
                 nd->mPositionKeys = new aiVectorKey[nd->mNumPositionKeys];
 
-                ::memcpy(nd->mPositionKeys,&me->mTargetAnim.akeyPositions[0],
-                    nd->mNumPositionKeys * sizeof(aiVectorKey));
+                ::memcpy(nd->mPositionKeys, &me->mTargetAnim.akeyPositions[0],
+                        nd->mNumPositionKeys * sizeof(aiVectorKey));
             }
 
-            if (me->mAnim.akeyPositions.size() > 1 || me->mAnim.akeyRotations.size() > 1 || me->mAnim.akeyScaling.size() > 1)   {
+            if (me->mAnim.akeyPositions.size() > 1 || me->mAnim.akeyRotations.size() > 1 || me->mAnim.akeyScaling.size() > 1) {
                 // Begin a new node animation channel for this node
-                aiNodeAnim* nd = pcAnim->mChannels[iNum++] = new aiNodeAnim();
+                aiNodeAnim *nd = pcAnim->mChannels[iNum++] = new aiNodeAnim();
                 nd->mNodeName.Set(me->mName);
 
                 // copy position keys
-                if (me->mAnim.akeyPositions.size() > 1 )
-                {
+                if (me->mAnim.akeyPositions.size() > 1) {
                     // Allocate the key array and fill it
-                    nd->mNumPositionKeys = (unsigned int) me->mAnim.akeyPositions.size();
+                    nd->mNumPositionKeys = (unsigned int)me->mAnim.akeyPositions.size();
                     nd->mPositionKeys = new aiVectorKey[nd->mNumPositionKeys];
 
-                    ::memcpy(nd->mPositionKeys,&me->mAnim.akeyPositions[0],
-                        nd->mNumPositionKeys * sizeof(aiVectorKey));
+                    ::memcpy(nd->mPositionKeys, &me->mAnim.akeyPositions[0],
+                            nd->mNumPositionKeys * sizeof(aiVectorKey));
                 }
                 // copy rotation keys
-                if (me->mAnim.akeyRotations.size() > 1 )    {
+                if (me->mAnim.akeyRotations.size() > 1) {
                     // Allocate the key array and fill it
-                    nd->mNumRotationKeys = (unsigned int) me->mAnim.akeyRotations.size();
+                    nd->mNumRotationKeys = (unsigned int)me->mAnim.akeyRotations.size();
                     nd->mRotationKeys = new aiQuatKey[nd->mNumRotationKeys];
 
                     // --------------------------------------------------------------------
@@ -395,11 +381,11 @@ void ASEImporter::BuildAnimations(const std::vector<BaseNode*>& nodes)
                     // --------------------------------------------------------------------
 
                     aiQuaternion cur;
-                    for (unsigned int a = 0; a < nd->mNumRotationKeys;++a)  {
+                    for (unsigned int a = 0; a < nd->mNumRotationKeys; ++a) {
                         aiQuatKey q = me->mAnim.akeyRotations[a];
 
                         if (mParser->iFileFormat > 110) {
-                            cur = (a ? cur*q.mValue : q.mValue);
+                            cur = (a ? cur * q.mValue : q.mValue);
                             q.mValue = cur.Normalize();
                         }
                         nd->mRotationKeys[a] = q;
@@ -409,13 +395,13 @@ void ASEImporter::BuildAnimations(const std::vector<BaseNode*>& nodes)
                     }
                 }
                 // copy scaling keys
-                if (me->mAnim.akeyScaling.size() > 1 )  {
+                if (me->mAnim.akeyScaling.size() > 1) {
                     // Allocate the key array and fill it
-                    nd->mNumScalingKeys = (unsigned int) me->mAnim.akeyScaling.size();
+                    nd->mNumScalingKeys = (unsigned int)me->mAnim.akeyScaling.size();
                     nd->mScalingKeys = new aiVectorKey[nd->mNumScalingKeys];
 
-                    ::memcpy(nd->mScalingKeys,&me->mAnim.akeyScaling[0],
-                        nd->mNumScalingKeys * sizeof(aiVectorKey));
+                    ::memcpy(nd->mScalingKeys, &me->mAnim.akeyScaling[0],
+                            nd->mNumScalingKeys * sizeof(aiVectorKey));
                 }
             }
         }
@@ -424,18 +410,17 @@ void ASEImporter::BuildAnimations(const std::vector<BaseNode*>& nodes)
 
 // ------------------------------------------------------------------------------------------------
 // Build output cameras
-void ASEImporter::BuildCameras()
-{
-    if (!mParser->m_vCameras.empty())   {
+void ASEImporter::BuildCameras() {
+    if (!mParser->m_vCameras.empty()) {
         pcScene->mNumCameras = (unsigned int)mParser->m_vCameras.size();
-        pcScene->mCameras = new aiCamera*[pcScene->mNumCameras];
+        pcScene->mCameras = new aiCamera *[pcScene->mNumCameras];
 
-        for (unsigned int i = 0; i < pcScene->mNumCameras;++i)  {
-            aiCamera* out = pcScene->mCameras[i] = new aiCamera();
-            ASE::Camera& in = mParser->m_vCameras[i];
+        for (unsigned int i = 0; i < pcScene->mNumCameras; ++i) {
+            aiCamera *out = pcScene->mCameras[i] = new aiCamera();
+            ASE::Camera &in = mParser->m_vCameras[i];
 
             // copy members
-            out->mClipPlaneFar  = in.mFar;
+            out->mClipPlaneFar = in.mFar;
             out->mClipPlaneNear = (in.mNear ? in.mNear : 0.1f);
             out->mHorizontalFOV = in.mFOV;
 
@@ -446,24 +431,22 @@ void ASEImporter::BuildCameras()
 
 // ------------------------------------------------------------------------------------------------
 // Build output lights
-void ASEImporter::BuildLights()
-{
-    if (!mParser->m_vLights.empty())    {
+void ASEImporter::BuildLights() {
+    if (!mParser->m_vLights.empty()) {
         pcScene->mNumLights = (unsigned int)mParser->m_vLights.size();
-        pcScene->mLights    = new aiLight*[pcScene->mNumLights];
+        pcScene->mLights = new aiLight *[pcScene->mNumLights];
 
-        for (unsigned int i = 0; i < pcScene->mNumLights;++i)   {
-            aiLight* out = pcScene->mLights[i] = new aiLight();
-            ASE::Light& in = mParser->m_vLights[i];
+        for (unsigned int i = 0; i < pcScene->mNumLights; ++i) {
+            aiLight *out = pcScene->mLights[i] = new aiLight();
+            ASE::Light &in = mParser->m_vLights[i];
 
             // The direction is encoded in the transformation matrix of the node.
             // In 3DS MAX the light source points into negative Z direction if
             // the node transformation is the identity.
-            out->mDirection = aiVector3D(0.f,0.f,-1.f);
+            out->mDirection = aiVector3D(0.f, 0.f, -1.f);
 
             out->mName.Set(in.mName);
-            switch (in.mLightType)
-            {
+            switch (in.mLightType) {
             case ASE::Light::TARGET:
                 out->mType = aiLightSource_SPOT;
                 out->mAngleInnerCone = AI_DEG_TO_RAD(in.mAngle);
@@ -475,7 +458,7 @@ void ASEImporter::BuildLights()
                 break;
 
             default:
-            //case ASE::Light::OMNI:
+                //case ASE::Light::OMNI:
                 out->mType = aiLightSource_POINT;
                 break;
             };
@@ -485,57 +468,55 @@ void ASEImporter::BuildLights()
 }
 
 // ------------------------------------------------------------------------------------------------
-void ASEImporter::AddNodes(const std::vector<BaseNode*>& nodes,
-    aiNode* pcParent,const char* szName)
-{
+void ASEImporter::AddNodes(const std::vector<BaseNode *> &nodes,
+        aiNode *pcParent, const char *szName) {
     aiMatrix4x4 m;
-    AddNodes(nodes,pcParent,szName,m);
+    AddNodes(nodes, pcParent, szName, m);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Add meshes to a given node
-void ASEImporter::AddMeshes(const ASE::BaseNode* snode,aiNode* node)
-{
-    for (unsigned int i = 0; i < pcScene->mNumMeshes;++i)   {
+void ASEImporter::AddMeshes(const ASE::BaseNode *snode, aiNode *node) {
+    for (unsigned int i = 0; i < pcScene->mNumMeshes; ++i) {
         // Get the name of the mesh (the mesh instance has been temporarily stored in the third vertex color)
-        const aiMesh* pcMesh  = pcScene->mMeshes[i];
-        const ASE::Mesh* mesh = (const ASE::Mesh*)pcMesh->mColors[2];
+        const aiMesh *pcMesh = pcScene->mMeshes[i];
+        const ASE::Mesh *mesh = (const ASE::Mesh *)pcMesh->mColors[2];
 
         if (mesh == snode) {
             ++node->mNumMeshes;
         }
     }
 
-    if(node->mNumMeshes)    {
+    if (node->mNumMeshes) {
         node->mMeshes = new unsigned int[node->mNumMeshes];
-        for (unsigned int i = 0, p = 0; i < pcScene->mNumMeshes;++i)    {
+        for (unsigned int i = 0, p = 0; i < pcScene->mNumMeshes; ++i) {
 
-            const aiMesh* pcMesh  = pcScene->mMeshes[i];
-            const ASE::Mesh* mesh = (const ASE::Mesh*)pcMesh->mColors[2];
-            if (mesh == snode)  {
+            const aiMesh *pcMesh = pcScene->mMeshes[i];
+            const ASE::Mesh *mesh = (const ASE::Mesh *)pcMesh->mColors[2];
+            if (mesh == snode) {
                 node->mMeshes[p++] = i;
 
                 // Transform all vertices of the mesh back into their local space ->
                 // at the moment they are pretransformed
-                aiMatrix4x4 m  = mesh->mTransform;
+                aiMatrix4x4 m = mesh->mTransform;
                 m.Inverse();
 
-                aiVector3D* pvCurPtr = pcMesh->mVertices;
-                const aiVector3D* pvEndPtr = pvCurPtr + pcMesh->mNumVertices;
-                while (pvCurPtr != pvEndPtr)    {
+                aiVector3D *pvCurPtr = pcMesh->mVertices;
+                const aiVector3D *pvEndPtr = pvCurPtr + pcMesh->mNumVertices;
+                while (pvCurPtr != pvEndPtr) {
                     *pvCurPtr = m * (*pvCurPtr);
                     pvCurPtr++;
                 }
 
                 // Do the same for the normal vectors, if we have them.
                 // As always, inverse transpose.
-                if (pcMesh->mNormals)   {
-                    aiMatrix3x3 m3 = aiMatrix3x3( mesh->mTransform );
+                if (pcMesh->mNormals) {
+                    aiMatrix3x3 m3 = aiMatrix3x3(mesh->mTransform);
                     m3.Transpose();
 
                     pvCurPtr = pcMesh->mNormals;
                     pvEndPtr = pvCurPtr + pcMesh->mNumVertices;
-                    while (pvCurPtr != pvEndPtr)    {
+                    while (pvCurPtr != pvEndPtr) {
                         *pvCurPtr = m3 * (*pvCurPtr);
                         pvCurPtr++;
                     }
@@ -547,68 +528,65 @@ void ASEImporter::AddMeshes(const ASE::BaseNode* snode,aiNode* node)
 
 // ------------------------------------------------------------------------------------------------
 // Add child nodes to a given parent node
-void ASEImporter::AddNodes (const std::vector<BaseNode*>& nodes,
-    aiNode* pcParent, const char* szName,
-    const aiMatrix4x4& mat)
-{
+void ASEImporter::AddNodes(const std::vector<BaseNode *> &nodes,
+        aiNode *pcParent, const char *szName,
+        const aiMatrix4x4 &mat) {
     const size_t len = szName ? ::strlen(szName) : 0;
     ai_assert(4 <= AI_MAX_NUMBER_OF_COLOR_SETS);
 
     // Receives child nodes for the pcParent node
-    std::vector<aiNode*> apcNodes;
+    std::vector<aiNode *> apcNodes;
 
     // Now iterate through all nodes in the scene and search for one
     // which has *us* as parent.
-    for (std::vector<BaseNode*>::const_iterator it = nodes.begin(), end = nodes.end(); it != end; ++it) {
-        const BaseNode* snode = *it;
+    for (std::vector<BaseNode *>::const_iterator it = nodes.begin(), end = nodes.end(); it != end; ++it) {
+        const BaseNode *snode = *it;
         if (szName) {
-            if (len != snode->mParent.length() || ::strcmp(szName,snode->mParent.c_str()))
+            if (len != snode->mParent.length() || ::strcmp(szName, snode->mParent.c_str()))
                 continue;
-        }
-        else if (snode->mParent.length())
+        } else if (snode->mParent.length())
             continue;
 
         (*it)->mProcessed = true;
 
         // Allocate a new node and add it to the output data structure
         apcNodes.push_back(new aiNode());
-        aiNode* node = apcNodes.back();
+        aiNode *node = apcNodes.back();
 
         node->mName.Set((snode->mName.length() ? snode->mName.c_str() : "Unnamed_Node"));
         node->mParent = pcParent;
 
         // Setup the transformation matrix of the node
-        aiMatrix4x4 mParentAdjust  = mat;
+        aiMatrix4x4 mParentAdjust = mat;
         mParentAdjust.Inverse();
-        node->mTransformation = mParentAdjust*snode->mTransform;
+        node->mTransformation = mParentAdjust * snode->mTransform;
 
         // Add sub nodes - prevent stack overflow due to recursive parenting
-        if (node->mName != node->mParent->mName && node->mName != node->mParent->mParent->mName ) {
-            AddNodes(nodes,node,node->mName.data,snode->mTransform);
+        if (node->mName != node->mParent->mName && node->mName != node->mParent->mParent->mName) {
+            AddNodes(nodes, node, node->mName.data, snode->mTransform);
         }
 
         // Further processing depends on the type of the node
-        if (snode->mType == ASE::BaseNode::Mesh)    {
+        if (snode->mType == ASE::BaseNode::Mesh) {
             // If the type of this node is "Mesh" we need to search
             // the list of output meshes in the data structure for
             // all those that belonged to this node once. This is
             // slightly inconvinient here and a better solution should
             // be used when this code is refactored next.
-            AddMeshes(snode,node);
-        }
-        else if (is_not_qnan( snode->mTargetPosition.x ))   {
+            AddMeshes(snode, node);
+        } else if (is_not_qnan(snode->mTargetPosition.x)) {
             // If this is a target camera or light we generate a small
             // child node which marks the position of the camera
             // target (the direction information is contained in *this*
             // node's animation track but the exact target position
             // would be lost otherwise)
-            if (!node->mNumChildren)    {
-                node->mChildren = new aiNode*[1];
+            if (!node->mNumChildren) {
+                node->mChildren = new aiNode *[1];
             }
 
-            aiNode* nd = new aiNode();
+            aiNode *nd = new aiNode();
 
-            nd->mName.Set ( snode->mName + ".Target" );
+            nd->mName.Set(snode->mName + ".Target");
 
             nd->mTransformation.a4 = snode->mTargetPosition.x - snode->mTransform.a4;
             nd->mTransformation.b4 = snode->mTargetPosition.y - snode->mTransform.b4;
@@ -617,14 +595,14 @@ void ASEImporter::AddNodes (const std::vector<BaseNode*>& nodes,
             nd->mParent = node;
 
             // The .Target node is always the first child node
-            for (unsigned int m = 0; m < node->mNumChildren;++m)
-                node->mChildren[m+1] = node->mChildren[m];
+            for (unsigned int m = 0; m < node->mNumChildren; ++m)
+                node->mChildren[m + 1] = node->mChildren[m];
 
             node->mChildren[0] = nd;
             node->mNumChildren++;
 
             // What we did is so great, it is at least worth a debug message
-            ASSIMP_LOG_DEBUG("ASE: Generating separate target node ("+snode->mName+")");
+            ASSIMP_LOG_VERBOSE_DEBUG("ASE: Generating separate target node (", snode->mName, ")");
         }
     }
 
@@ -632,10 +610,10 @@ void ASEImporter::AddNodes (const std::vector<BaseNode*>& nodes,
     // We allocate one slot more  in case this is a target camera/light
     pcParent->mNumChildren = (unsigned int)apcNodes.size();
     if (pcParent->mNumChildren) {
-        pcParent->mChildren = new aiNode*[apcNodes.size()+1 /* PLUS ONE !!! */];
+        pcParent->mChildren = new aiNode *[apcNodes.size() + 1 /* PLUS ONE !!! */];
 
         // now build all nodes for our nice new children
-        for (unsigned int p = 0; p < apcNodes.size();++p)
+        for (unsigned int p = 0; p < apcNodes.size(); ++p)
             pcParent->mChildren[p] = apcNodes[p];
     }
     return;
@@ -643,32 +621,32 @@ void ASEImporter::AddNodes (const std::vector<BaseNode*>& nodes,
 
 // ------------------------------------------------------------------------------------------------
 // Build the output node graph
-void ASEImporter::BuildNodes(std::vector<BaseNode*>& nodes) {
-    ai_assert(NULL != pcScene);
+void ASEImporter::BuildNodes(std::vector<BaseNode *> &nodes) {
+    ai_assert(nullptr != pcScene);
 
     // allocate the one and only root node
-    aiNode* root = pcScene->mRootNode = new aiNode();
+    aiNode *root = pcScene->mRootNode = new aiNode();
     root->mName.Set("<ASERoot>");
 
     // Setup the coordinate system transformation
     pcScene->mRootNode->mNumChildren = 1;
-    pcScene->mRootNode->mChildren = new aiNode*[1];
-    aiNode* ch = pcScene->mRootNode->mChildren[0] = new aiNode();
+    pcScene->mRootNode->mChildren = new aiNode *[1];
+    aiNode *ch = pcScene->mRootNode->mChildren[0] = new aiNode();
     ch->mParent = root;
 
     // Change the transformation matrix of all nodes
     for (BaseNode *node : nodes) {
-        aiMatrix4x4& m = node->mTransform;
+        aiMatrix4x4 &m = node->mTransform;
         m.Transpose(); // row-order vs column-order
     }
 
     // add all nodes
-    AddNodes(nodes,ch,NULL);
+    AddNodes(nodes, ch, nullptr);
 
     // now iterate through al nodes and find those that have not yet
     // been added to the nodegraph (= their parent could not be recognized)
-    std::vector<const BaseNode*> aiList;
-    for (std::vector<BaseNode*>::iterator it = nodes.begin(), end = nodes.end();it != end; ++it)    {
+    std::vector<const BaseNode *> aiList;
+    for (std::vector<BaseNode *>::iterator it = nodes.begin(), end = nodes.end(); it != end; ++it) {
         if ((*it)->mProcessed) {
             continue;
         }
@@ -678,54 +656,54 @@ void ASEImporter::BuildNodes(std::vector<BaseNode*>& nodes) {
 
         // search the list another time, starting *here* and try to find out whether
         // there is a node that references *us* as a parent
-        for (std::vector<BaseNode*>::const_iterator it2 = nodes.begin();it2 != end; ++it2) {
+        for (std::vector<BaseNode *>::const_iterator it2 = nodes.begin(); it2 != end; ++it2) {
             if (it2 == it) {
                 continue;
             }
 
-            if ((*it2)->mName == (*it)->mParent)    {
+            if ((*it2)->mName == (*it)->mParent) {
                 bKnowParent = true;
                 break;
             }
         }
-        if (!bKnowParent)   {
+        if (!bKnowParent) {
             aiList.push_back(*it);
         }
     }
 
-    // Are there ane orphaned nodes?
-    if (!aiList.empty())    {
-        std::vector<aiNode*> apcNodes;
+    // Are there any orphaned nodes?
+    if (!aiList.empty()) {
+        std::vector<aiNode *> apcNodes;
         apcNodes.reserve(aiList.size() + pcScene->mRootNode->mNumChildren);
 
-        for (unsigned int i = 0; i < pcScene->mRootNode->mNumChildren;++i)
+        for (unsigned int i = 0; i < pcScene->mRootNode->mNumChildren; ++i)
             apcNodes.push_back(pcScene->mRootNode->mChildren[i]);
 
         delete[] pcScene->mRootNode->mChildren;
-        for (std::vector<const BaseNode*>::/*const_*/iterator i =  aiList.begin();i != aiList.end();++i)    {
-            const ASE::BaseNode* src = *i;
+        for (std::vector<const BaseNode *>::/*const_*/ iterator i = aiList.begin(); i != aiList.end(); ++i) {
+            const ASE::BaseNode *src = *i;
 
             // The parent is not known, so we can assume that we must add
             // this node to the root node of the whole scene
-            aiNode* pcNode = new aiNode();
+            aiNode *pcNode = new aiNode();
             pcNode->mParent = pcScene->mRootNode;
             pcNode->mName.Set(src->mName);
-            AddMeshes(src,pcNode);
-            AddNodes(nodes,pcNode,pcNode->mName.data);
+            AddMeshes(src, pcNode);
+            AddNodes(nodes, pcNode, pcNode->mName.data);
             apcNodes.push_back(pcNode);
         }
 
         // Regenerate our output array
-        pcScene->mRootNode->mChildren = new aiNode*[apcNodes.size()];
-        for (unsigned int i = 0; i < apcNodes.size();++i)
+        pcScene->mRootNode->mChildren = new aiNode *[apcNodes.size()];
+        for (unsigned int i = 0; i < apcNodes.size(); ++i)
             pcScene->mRootNode->mChildren[i] = apcNodes[i];
 
         pcScene->mRootNode->mNumChildren = (unsigned int)apcNodes.size();
     }
 
-    // Reset the third color set to NULL - we used this field to store a temporary pointer
-    for (unsigned int i = 0; i < pcScene->mNumMeshes;++i)
-        pcScene->mMeshes[i]->mColors[2] = NULL;
+    // Reset the third color set to nullptr - we used this field to store a temporary pointer
+    for (unsigned int i = 0; i < pcScene->mNumMeshes; ++i)
+        pcScene->mMeshes[i]->mColors[2] = nullptr;
 
     // The root node should not have at least one child or the file is valid
     if (!pcScene->mRootNode->mNumChildren) {
@@ -733,17 +711,17 @@ void ASEImporter::BuildNodes(std::vector<BaseNode*>& nodes) {
     }
 
     // Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system
-    pcScene->mRootNode->mTransformation = aiMatrix4x4(1.f,0.f,0.f,0.f,
-        0.f,0.f,1.f,0.f,0.f,-1.f,0.f,0.f,0.f,0.f,0.f,1.f);
+    pcScene->mRootNode->mTransformation = aiMatrix4x4(1.f, 0.f, 0.f, 0.f,
+            0.f, 0.f, 1.f, 0.f, 0.f, -1.f, 0.f, 0.f, 0.f, 0.f, 0.f, 1.f);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Convert the imported data to the internal verbose representation
-void ASEImporter::BuildUniqueRepresentation(ASE::Mesh& mesh)    {
+void ASEImporter::BuildUniqueRepresentation(ASE::Mesh &mesh) {
     // allocate output storage
     std::vector<aiVector3D> mPositions;
     std::vector<aiVector3D> amTexCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS];
-    std::vector<aiColor4D>  mVertexColors;
+    std::vector<aiColor4D> mVertexColors;
     std::vector<aiVector3D> mNormals;
     std::vector<BoneVertex> mBoneVertices;
 
@@ -751,13 +729,13 @@ void ASEImporter::BuildUniqueRepresentation(ASE::Mesh& mesh)    {
     mPositions.resize(iSize);
 
     // optional texture coordinates
-    for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS;++i)    {
-        if (!mesh.amTexCoords[i].empty())   {
+    for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
+        if (!mesh.amTexCoords[i].empty()) {
             amTexCoords[i].resize(iSize);
         }
     }
     // optional vertex colors
-    if (!mesh.mVertexColors.empty())    {
+    if (!mesh.mVertexColors.empty()) {
         mVertexColors.resize(iSize);
     }
 
@@ -766,38 +744,37 @@ void ASEImporter::BuildUniqueRepresentation(ASE::Mesh& mesh)    {
         mNormals.resize(iSize);
     }
     // bone vertices. There is no need to change the bone list
-    if (!mesh.mBoneVertices.empty())    {
+    if (!mesh.mBoneVertices.empty()) {
         mBoneVertices.resize(iSize);
     }
 
     // iterate through all faces in the mesh
     unsigned int iCurrent = 0, fi = 0;
-    for (std::vector<ASE::Face>::iterator i =  mesh.mFaces.begin();i != mesh.mFaces.end();++i,++fi) {
-        for (unsigned int n = 0; n < 3;++n,++iCurrent)
-        {
+    for (std::vector<ASE::Face>::iterator i = mesh.mFaces.begin(); i != mesh.mFaces.end(); ++i, ++fi) {
+        for (unsigned int n = 0; n < 3; ++n, ++iCurrent) {
             mPositions[iCurrent] = mesh.mPositions[(*i).mIndices[n]];
 
             // add texture coordinates
-            for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS;++c)    {
-                if (mesh.amTexCoords[c].empty())break;
+            for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++c) {
+                if (mesh.amTexCoords[c].empty()) break;
                 amTexCoords[c][iCurrent] = mesh.amTexCoords[c][(*i).amUVIndices[c][n]];
             }
             // add vertex colors
-            if (!mesh.mVertexColors.empty())    {
+            if (!mesh.mVertexColors.empty()) {
                 mVertexColors[iCurrent] = mesh.mVertexColors[(*i).mColorIndices[n]];
             }
             // add normal vectors
             if (!mesh.mNormals.empty()) {
-                mNormals[iCurrent] = mesh.mNormals[fi*3+n];
+                mNormals[iCurrent] = mesh.mNormals[fi * 3 + n];
                 mNormals[iCurrent].Normalize();
             }
 
             // handle bone vertices
-            if ((*i).mIndices[n] < mesh.mBoneVertices.size())   {
+            if ((*i).mIndices[n] < mesh.mBoneVertices.size()) {
                 // (sometimes this will cause bone verts to be duplicated
                 //  however, I' quite sure Schrompf' JoinVerticesStep
                 //  will fix that again ...)
-                mBoneVertices[iCurrent] =  mesh.mBoneVertices[(*i).mIndices[n]];
+                mBoneVertices[iCurrent] = mesh.mBoneVertices[(*i).mIndices[n]];
             }
             (*i).mIndices[n] = iCurrent;
         }
@@ -808,31 +785,29 @@ void ASEImporter::BuildUniqueRepresentation(ASE::Mesh& mesh)    {
     mesh.mPositions = mPositions;
     mesh.mVertexColors = mVertexColors;
 
-    for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS;++c)
+    for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++c)
         mesh.amTexCoords[c] = amTexCoords[c];
 }
 
 // ------------------------------------------------------------------------------------------------
 // Copy a texture from the ASE structs to the output material
-void CopyASETexture(aiMaterial& mat, ASE::Texture& texture, aiTextureType type)
-{
+void CopyASETexture(aiMaterial &mat, ASE::Texture &texture, aiTextureType type) {
     // Setup the texture name
     aiString tex;
-    tex.Set( texture.mMapName);
-    mat.AddProperty( &tex, AI_MATKEY_TEXTURE(type,0));
+    tex.Set(texture.mMapName);
+    mat.AddProperty(&tex, AI_MATKEY_TEXTURE(type, 0));
 
     // Setup the texture blend factor
     if (is_not_qnan(texture.mTextureBlend))
-        mat.AddProperty<ai_real>( &texture.mTextureBlend, 1, AI_MATKEY_TEXBLEND(type,0));
+        mat.AddProperty<ai_real>(&texture.mTextureBlend, 1, AI_MATKEY_TEXBLEND(type, 0));
 
     // Setup texture UV transformations
-    mat.AddProperty<ai_real>(&texture.mOffsetU,5,AI_MATKEY_UVTRANSFORM(type,0));
+    mat.AddProperty<ai_real>(&texture.mOffsetU, 5, AI_MATKEY_UVTRANSFORM(type, 0));
 }
 
 // ------------------------------------------------------------------------------------------------
 // Convert from ASE material to output material
-void ASEImporter::ConvertMaterial(ASE::Material& mat)
-{
+void ASEImporter::ConvertMaterial(ASE::Material &mat) {
     // LARGE TODO: Much code her is copied from 3DS ... join them maybe?
 
     // Allocate the output material
@@ -845,135 +820,134 @@ void ASEImporter::ConvertMaterial(ASE::Material& mat)
     mat.mAmbient.b += mParser->m_clrAmbient.b;
 
     aiString name;
-    name.Set( mat.mName);
-    mat.pcInstance->AddProperty( &name, AI_MATKEY_NAME);
+    name.Set(mat.mName);
+    mat.pcInstance->AddProperty(&name, AI_MATKEY_NAME);
 
     // material colors
-    mat.pcInstance->AddProperty( &mat.mAmbient, 1, AI_MATKEY_COLOR_AMBIENT);
-    mat.pcInstance->AddProperty( &mat.mDiffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
-    mat.pcInstance->AddProperty( &mat.mSpecular, 1, AI_MATKEY_COLOR_SPECULAR);
-    mat.pcInstance->AddProperty( &mat.mEmissive, 1, AI_MATKEY_COLOR_EMISSIVE);
+    mat.pcInstance->AddProperty(&mat.mAmbient, 1, AI_MATKEY_COLOR_AMBIENT);
+    mat.pcInstance->AddProperty(&mat.mDiffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
+    mat.pcInstance->AddProperty(&mat.mSpecular, 1, AI_MATKEY_COLOR_SPECULAR);
+    mat.pcInstance->AddProperty(&mat.mEmissive, 1, AI_MATKEY_COLOR_EMISSIVE);
 
     // shininess
-    if (0.0f != mat.mSpecularExponent && 0.0f != mat.mShininessStrength)
-    {
-        mat.pcInstance->AddProperty( &mat.mSpecularExponent, 1, AI_MATKEY_SHININESS);
-        mat.pcInstance->AddProperty( &mat.mShininessStrength, 1, AI_MATKEY_SHININESS_STRENGTH);
+    if (0.0f != mat.mSpecularExponent && 0.0f != mat.mShininessStrength) {
+        mat.pcInstance->AddProperty(&mat.mSpecularExponent, 1, AI_MATKEY_SHININESS);
+        mat.pcInstance->AddProperty(&mat.mShininessStrength, 1, AI_MATKEY_SHININESS_STRENGTH);
     }
     // If there is no shininess, we can disable phong lighting
     else if (D3DS::Discreet3DS::Metal == mat.mShading ||
-        D3DS::Discreet3DS::Phong == mat.mShading ||
-        D3DS::Discreet3DS::Blinn == mat.mShading)
-    {
+             D3DS::Discreet3DS::Phong == mat.mShading ||
+             D3DS::Discreet3DS::Blinn == mat.mShading) {
         mat.mShading = D3DS::Discreet3DS::Gouraud;
     }
 
     // opacity
-    mat.pcInstance->AddProperty<ai_real>( &mat.mTransparency,1,AI_MATKEY_OPACITY);
+    mat.pcInstance->AddProperty<ai_real>(&mat.mTransparency, 1, AI_MATKEY_OPACITY);
 
     // Two sided rendering?
-    if (mat.mTwoSided)
-    {
+    if (mat.mTwoSided) {
         int i = 1;
-        mat.pcInstance->AddProperty<int>(&i,1,AI_MATKEY_TWOSIDED);
+        mat.pcInstance->AddProperty<int>(&i, 1, AI_MATKEY_TWOSIDED);
     }
 
     // shading mode
     aiShadingMode eShading = aiShadingMode_NoShading;
-    switch (mat.mShading)
-    {
-        case D3DS::Discreet3DS::Flat:
-            eShading = aiShadingMode_Flat; break;
-        case D3DS::Discreet3DS::Phong :
-            eShading = aiShadingMode_Phong; break;
-        case D3DS::Discreet3DS::Blinn :
-            eShading = aiShadingMode_Blinn; break;
+    switch (mat.mShading) {
+    case D3DS::Discreet3DS::Flat:
+        eShading = aiShadingMode_Flat;
+        break;
+    case D3DS::Discreet3DS::Phong:
+        eShading = aiShadingMode_Phong;
+        break;
+    case D3DS::Discreet3DS::Blinn:
+        eShading = aiShadingMode_Blinn;
+        break;
 
-            // I don't know what "Wire" shading should be,
-            // assume it is simple lambertian diffuse (L dot N) shading
-        case D3DS::Discreet3DS::Wire:
-            {
-                // set the wireframe flag
-                unsigned int iWire = 1;
-                mat.pcInstance->AddProperty<int>( (int*)&iWire,1,AI_MATKEY_ENABLE_WIREFRAME);
-            }
-        case D3DS::Discreet3DS::Gouraud:
-            eShading = aiShadingMode_Gouraud; break;
-        case D3DS::Discreet3DS::Metal :
-            eShading = aiShadingMode_CookTorrance; break;
+        // I don't know what "Wire" shading should be,
+        // assume it is simple lambertian diffuse (L dot N) shading
+    case D3DS::Discreet3DS::Wire: {
+        // set the wireframe flag
+        unsigned int iWire = 1;
+        mat.pcInstance->AddProperty<int>((int *)&iWire, 1, AI_MATKEY_ENABLE_WIREFRAME);
     }
-    mat.pcInstance->AddProperty<int>( (int*)&eShading,1,AI_MATKEY_SHADING_MODEL);
+    case D3DS::Discreet3DS::Gouraud:
+        eShading = aiShadingMode_Gouraud;
+        break;
+    case D3DS::Discreet3DS::Metal:
+        eShading = aiShadingMode_CookTorrance;
+        break;
+    }
+    mat.pcInstance->AddProperty<int>((int *)&eShading, 1, AI_MATKEY_SHADING_MODEL);
 
     // DIFFUSE texture
-    if( mat.sTexDiffuse.mMapName.length() > 0)
-        CopyASETexture(*mat.pcInstance,mat.sTexDiffuse, aiTextureType_DIFFUSE);
+    if (mat.sTexDiffuse.mMapName.length() > 0)
+        CopyASETexture(*mat.pcInstance, mat.sTexDiffuse, aiTextureType_DIFFUSE);
 
     // SPECULAR texture
-    if( mat.sTexSpecular.mMapName.length() > 0)
-        CopyASETexture(*mat.pcInstance,mat.sTexSpecular, aiTextureType_SPECULAR);
+    if (mat.sTexSpecular.mMapName.length() > 0)
+        CopyASETexture(*mat.pcInstance, mat.sTexSpecular, aiTextureType_SPECULAR);
 
     // AMBIENT texture
-    if( mat.sTexAmbient.mMapName.length() > 0)
-        CopyASETexture(*mat.pcInstance,mat.sTexAmbient, aiTextureType_AMBIENT);
+    if (mat.sTexAmbient.mMapName.length() > 0)
+        CopyASETexture(*mat.pcInstance, mat.sTexAmbient, aiTextureType_AMBIENT);
 
     // OPACITY texture
-    if( mat.sTexOpacity.mMapName.length() > 0)
-        CopyASETexture(*mat.pcInstance,mat.sTexOpacity, aiTextureType_OPACITY);
+    if (mat.sTexOpacity.mMapName.length() > 0)
+        CopyASETexture(*mat.pcInstance, mat.sTexOpacity, aiTextureType_OPACITY);
 
     // EMISSIVE texture
-    if( mat.sTexEmissive.mMapName.length() > 0)
-        CopyASETexture(*mat.pcInstance,mat.sTexEmissive, aiTextureType_EMISSIVE);
+    if (mat.sTexEmissive.mMapName.length() > 0)
+        CopyASETexture(*mat.pcInstance, mat.sTexEmissive, aiTextureType_EMISSIVE);
 
     // BUMP texture
-    if( mat.sTexBump.mMapName.length() > 0)
-        CopyASETexture(*mat.pcInstance,mat.sTexBump, aiTextureType_HEIGHT);
+    if (mat.sTexBump.mMapName.length() > 0)
+        CopyASETexture(*mat.pcInstance, mat.sTexBump, aiTextureType_HEIGHT);
 
     // SHININESS texture
-    if( mat.sTexShininess.mMapName.length() > 0)
-        CopyASETexture(*mat.pcInstance,mat.sTexShininess, aiTextureType_SHININESS);
+    if (mat.sTexShininess.mMapName.length() > 0)
+        CopyASETexture(*mat.pcInstance, mat.sTexShininess, aiTextureType_SHININESS);
 
     // store the name of the material itself, too
-    if( mat.mName.length() > 0) {
-        aiString tex;tex.Set( mat.mName);
-        mat.pcInstance->AddProperty( &tex, AI_MATKEY_NAME);
+    if (mat.mName.length() > 0) {
+        aiString tex;
+        tex.Set(mat.mName);
+        mat.pcInstance->AddProperty(&tex, AI_MATKEY_NAME);
     }
     return;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Build output meshes
-void ASEImporter::ConvertMeshes(ASE::Mesh& mesh, std::vector<aiMesh*>& avOutMeshes)
-{
+void ASEImporter::ConvertMeshes(ASE::Mesh &mesh, std::vector<aiMesh *> &avOutMeshes) {
     // validate the material index of the mesh
-    if (mesh.iMaterialIndex >= mParser->m_vMaterials.size())    {
-        mesh.iMaterialIndex = (unsigned int)mParser->m_vMaterials.size()-1;
+    if (mesh.iMaterialIndex >= mParser->m_vMaterials.size()) {
+        mesh.iMaterialIndex = (unsigned int)mParser->m_vMaterials.size() - 1;
         ASSIMP_LOG_WARN("Material index is out of range");
     }
 
     // If the material the mesh is assigned to is consisting of submeshes, split it
     if (!mParser->m_vMaterials[mesh.iMaterialIndex].avSubMaterials.empty()) {
-        std::vector<ASE::Material> vSubMaterials = mParser->
-            m_vMaterials[mesh.iMaterialIndex].avSubMaterials;
+        std::vector<ASE::Material> vSubMaterials = mParser->m_vMaterials[mesh.iMaterialIndex].avSubMaterials;
 
-        std::vector<unsigned int>* aiSplit = new std::vector<unsigned int>[vSubMaterials.size()];
+        std::vector<unsigned int> *aiSplit = new std::vector<unsigned int>[vSubMaterials.size()];
 
         // build a list of all faces per sub-material
-        for (unsigned int i = 0; i < mesh.mFaces.size();++i)    {
+        for (unsigned int i = 0; i < mesh.mFaces.size(); ++i) {
             // check range
             if (mesh.mFaces[i].iMaterial >= vSubMaterials.size()) {
                 ASSIMP_LOG_WARN("Submaterial index is out of range");
 
                 // use the last material instead
-                aiSplit[vSubMaterials.size()-1].push_back(i);
-            }
-            else aiSplit[mesh.mFaces[i].iMaterial].push_back(i);
+                aiSplit[vSubMaterials.size() - 1].push_back(i);
+            } else
+                aiSplit[mesh.mFaces[i].iMaterial].push_back(i);
         }
 
         // now generate submeshes
-        for (unsigned int p = 0; p < vSubMaterials.size();++p)  {
-            if (!aiSplit[p].empty())    {
+        for (unsigned int p = 0; p < vSubMaterials.size(); ++p) {
+            if (!aiSplit[p].empty()) {
 
-                aiMesh* p_pcOut = new aiMesh();
+                aiMesh *p_pcOut = new aiMesh();
                 p_pcOut->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
 
                 // let the sub material index
@@ -983,55 +957,55 @@ void ASEImporter::ConvertMeshes(ASE::Mesh& mesh, std::vector<aiMesh*>& avOutMesh
                 mParser->m_vMaterials[mesh.iMaterialIndex].avSubMaterials[p].bNeed = true;
 
                 // store the real index here ... color channel 3
-                p_pcOut->mColors[3] = (aiColor4D*)(uintptr_t)mesh.iMaterialIndex;
+                p_pcOut->mColors[3] = (aiColor4D *)(uintptr_t)mesh.iMaterialIndex;
 
                 // store a pointer to the mesh in color channel 2
-                p_pcOut->mColors[2] = (aiColor4D*) &mesh;
+                p_pcOut->mColors[2] = (aiColor4D *)&mesh;
                 avOutMeshes.push_back(p_pcOut);
 
                 // convert vertices
-                p_pcOut->mNumVertices = (unsigned int)aiSplit[p].size()*3;
+                p_pcOut->mNumVertices = (unsigned int)aiSplit[p].size() * 3;
                 p_pcOut->mNumFaces = (unsigned int)aiSplit[p].size();
 
                 // receive output vertex weights
-                std::vector<std::pair<unsigned int, float> > *avOutputBones = NULL;
-                if (!mesh.mBones.empty())   {
-                    avOutputBones = new std::vector<std::pair<unsigned int, float> >[mesh.mBones.size()];
+                std::vector<std::pair<unsigned int, float>> *avOutputBones = nullptr;
+                if (!mesh.mBones.empty()) {
+                    avOutputBones = new std::vector<std::pair<unsigned int, float>>[mesh.mBones.size()];
                 }
 
                 // allocate enough storage for faces
                 p_pcOut->mFaces = new aiFace[p_pcOut->mNumFaces];
 
-                unsigned int iBase = 0,iIndex;
-                if (p_pcOut->mNumVertices)  {
+                unsigned int iBase = 0, iIndex;
+                if (p_pcOut->mNumVertices) {
                     p_pcOut->mVertices = new aiVector3D[p_pcOut->mNumVertices];
-                    p_pcOut->mNormals  = new aiVector3D[p_pcOut->mNumVertices];
-                    for (unsigned int q = 0; q < aiSplit[p].size();++q) {
+                    p_pcOut->mNormals = new aiVector3D[p_pcOut->mNumVertices];
+                    for (unsigned int q = 0; q < aiSplit[p].size(); ++q) {
 
                         iIndex = aiSplit[p][q];
 
                         p_pcOut->mFaces[q].mIndices = new unsigned int[3];
                         p_pcOut->mFaces[q].mNumIndices = 3;
 
-                        for (unsigned int t = 0; t < 3;++t, ++iBase)    {
+                        for (unsigned int t = 0; t < 3; ++t, ++iBase) {
                             const uint32_t iIndex2 = mesh.mFaces[iIndex].mIndices[t];
 
-                            p_pcOut->mVertices[iBase] = mesh.mPositions [iIndex2];
-                            p_pcOut->mNormals [iBase] = mesh.mNormals   [iIndex2];
+                            p_pcOut->mVertices[iBase] = mesh.mPositions[iIndex2];
+                            p_pcOut->mNormals[iBase] = mesh.mNormals[iIndex2];
 
                             // convert bones, if existing
                             if (!mesh.mBones.empty()) {
                                 ai_assert(avOutputBones);
                                 // check whether there is a vertex weight for this vertex index
-                                if (iIndex2 < mesh.mBoneVertices.size())    {
+                                if (iIndex2 < mesh.mBoneVertices.size()) {
 
-                                    for (std::vector<std::pair<int,float> >::const_iterator
-                                        blubb =  mesh.mBoneVertices[iIndex2].mBoneWeights.begin();
-                                        blubb != mesh.mBoneVertices[iIndex2].mBoneWeights.end();++blubb)    {
+                                    for (std::vector<std::pair<int, float>>::const_iterator
+                                                    blubb = mesh.mBoneVertices[iIndex2].mBoneWeights.begin();
+                                            blubb != mesh.mBoneVertices[iIndex2].mBoneWeights.end(); ++blubb) {
 
                                         // NOTE: illegal cases have already been filtered out
                                         avOutputBones[(*blubb).first].push_back(std::pair<unsigned int, float>(
-                                            iBase,(*blubb).second));
+                                                iBase, (*blubb).second));
                                     }
                                 }
                             }
@@ -1040,14 +1014,13 @@ void ASEImporter::ConvertMeshes(ASE::Mesh& mesh, std::vector<aiMesh*>& avOutMesh
                     }
                 }
                 // convert texture coordinates (up to AI_MAX_NUMBER_OF_TEXTURECOORDS sets supported)
-                for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS;++c) {
-                    if (!mesh.amTexCoords[c].empty())
-                    {
+                for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++c) {
+                    if (!mesh.amTexCoords[c].empty()) {
                         p_pcOut->mTextureCoords[c] = new aiVector3D[p_pcOut->mNumVertices];
                         iBase = 0;
-                        for (unsigned int q = 0; q < aiSplit[p].size();++q) {
+                        for (unsigned int q = 0; q < aiSplit[p].size(); ++q) {
                             iIndex = aiSplit[p][q];
-                            for (unsigned int t = 0; t < 3;++t) {
+                            for (unsigned int t = 0; t < 3; ++t) {
                                 p_pcOut->mTextureCoords[c][iBase++] = mesh.amTexCoords[c][mesh.mFaces[iIndex].mIndices[t]];
                             }
                         }
@@ -1057,38 +1030,36 @@ void ASEImporter::ConvertMeshes(ASE::Mesh& mesh, std::vector<aiMesh*>& avOutMesh
                 }
 
                 // Convert vertex colors (only one set supported)
-                if (!mesh.mVertexColors.empty()){
+                if (!mesh.mVertexColors.empty()) {
                     p_pcOut->mColors[0] = new aiColor4D[p_pcOut->mNumVertices];
                     iBase = 0;
-                    for (unsigned int q = 0; q < aiSplit[p].size();++q) {
+                    for (unsigned int q = 0; q < aiSplit[p].size(); ++q) {
                         iIndex = aiSplit[p][q];
-                        for (unsigned int t = 0; t < 3;++t) {
+                        for (unsigned int t = 0; t < 3; ++t) {
                             p_pcOut->mColors[0][iBase++] = mesh.mVertexColors[mesh.mFaces[iIndex].mIndices[t]];
                         }
                     }
                 }
                 // Copy bones
-                if (!mesh.mBones.empty())   {
+                if (!mesh.mBones.empty()) {
                     p_pcOut->mNumBones = 0;
-                    for (unsigned int mrspock = 0; mrspock < mesh.mBones.size();++mrspock)
-                        if (!avOutputBones[mrspock].empty())p_pcOut->mNumBones++;
+                    for (unsigned int mrspock = 0; mrspock < mesh.mBones.size(); ++mrspock)
+                        if (!avOutputBones[mrspock].empty()) p_pcOut->mNumBones++;
 
-                    p_pcOut->mBones = new aiBone* [ p_pcOut->mNumBones ];
-                    aiBone** pcBone = p_pcOut->mBones;
-                    for (unsigned int mrspock = 0; mrspock < mesh.mBones.size();++mrspock)
-                    {
-                        if (!avOutputBones[mrspock].empty())    {
+                    p_pcOut->mBones = new aiBone *[p_pcOut->mNumBones];
+                    aiBone **pcBone = p_pcOut->mBones;
+                    for (unsigned int mrspock = 0; mrspock < mesh.mBones.size(); ++mrspock) {
+                        if (!avOutputBones[mrspock].empty()) {
                             // we will need this bone. add it to the output mesh and
                             // add all per-vertex weights
-                            aiBone* pc = *pcBone = new aiBone();
+                            aiBone *pc = *pcBone = new aiBone();
                             pc->mName.Set(mesh.mBones[mrspock].mName);
 
                             pc->mNumWeights = (unsigned int)avOutputBones[mrspock].size();
                             pc->mWeights = new aiVertexWeight[pc->mNumWeights];
 
-                            for (unsigned int captainkirk = 0; captainkirk < pc->mNumWeights;++captainkirk)
-                            {
-                                const std::pair<unsigned int,float>& ref = avOutputBones[mrspock][captainkirk];
+                            for (unsigned int captainkirk = 0; captainkirk < pc->mNumWeights; ++captainkirk) {
+                                const std::pair<unsigned int, float> &ref = avOutputBones[mrspock][captainkirk];
                                 pc->mWeights[captainkirk].mVertexId = ref.first;
                                 pc->mWeights[captainkirk].mWeight = ref.second;
                             }
@@ -1102,15 +1073,13 @@ void ASEImporter::ConvertMeshes(ASE::Mesh& mesh, std::vector<aiMesh*>& avOutMesh
         }
         // delete storage
         delete[] aiSplit;
-    }
-    else
-    {
+    } else {
         // Otherwise we can simply copy the data to one output mesh
         // This codepath needs less memory and uses fast memcpy()s
         // to do the actual copying. So I think it is worth the
         // effort here.
 
-        aiMesh* p_pcOut = new aiMesh();
+        aiMesh *p_pcOut = new aiMesh();
         p_pcOut->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
 
         // set an empty sub material index
@@ -1118,10 +1087,10 @@ void ASEImporter::ConvertMeshes(ASE::Mesh& mesh, std::vector<aiMesh*>& avOutMesh
         mParser->m_vMaterials[mesh.iMaterialIndex].bNeed = true;
 
         // store the real index here ... in color channel 3
-        p_pcOut->mColors[3] = (aiColor4D*)(uintptr_t)mesh.iMaterialIndex;
+        p_pcOut->mColors[3] = (aiColor4D *)(uintptr_t)mesh.iMaterialIndex;
 
         // store a pointer to the mesh in color channel 2
-        p_pcOut->mColors[2] = (aiColor4D*) &mesh;
+        p_pcOut->mColors[2] = (aiColor4D *)&mesh;
         avOutMeshes.push_back(p_pcOut);
 
         // If the mesh hasn't faces or vertices, there are two cases
@@ -1140,20 +1109,20 @@ void ASEImporter::ConvertMeshes(ASE::Mesh& mesh, std::vector<aiMesh*>& avOutMesh
 
         // copy vertices
         p_pcOut->mVertices = new aiVector3D[mesh.mPositions.size()];
-        memcpy(p_pcOut->mVertices,&mesh.mPositions[0],
-            mesh.mPositions.size() * sizeof(aiVector3D));
+        memcpy(p_pcOut->mVertices, &mesh.mPositions[0],
+                mesh.mPositions.size() * sizeof(aiVector3D));
 
         // copy normals
         p_pcOut->mNormals = new aiVector3D[mesh.mNormals.size()];
-        memcpy(p_pcOut->mNormals,&mesh.mNormals[0],
-            mesh.mNormals.size() * sizeof(aiVector3D));
+        memcpy(p_pcOut->mNormals, &mesh.mNormals[0],
+                mesh.mNormals.size() * sizeof(aiVector3D));
 
         // copy texture coordinates
-        for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS;++c)    {
-            if (!mesh.amTexCoords[c].empty())   {
+        for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++c) {
+            if (!mesh.amTexCoords[c].empty()) {
                 p_pcOut->mTextureCoords[c] = new aiVector3D[mesh.amTexCoords[c].size()];
-                memcpy(p_pcOut->mTextureCoords[c],&mesh.amTexCoords[c][0],
-                    mesh.amTexCoords[c].size() * sizeof(aiVector3D));
+                memcpy(p_pcOut->mTextureCoords[c], &mesh.amTexCoords[c][0],
+                        mesh.amTexCoords[c].size() * sizeof(aiVector3D));
 
                 // setup the number of valid vertex components
                 p_pcOut->mNumUVComponents[c] = mesh.mNumUVComponents[c];
@@ -1161,14 +1130,14 @@ void ASEImporter::ConvertMeshes(ASE::Mesh& mesh, std::vector<aiMesh*>& avOutMesh
         }
 
         // copy vertex colors
-        if (!mesh.mVertexColors.empty())    {
+        if (!mesh.mVertexColors.empty()) {
             p_pcOut->mColors[0] = new aiColor4D[mesh.mVertexColors.size()];
-            memcpy(p_pcOut->mColors[0],&mesh.mVertexColors[0],
-                mesh.mVertexColors.size() * sizeof(aiColor4D));
+            memcpy(p_pcOut->mColors[0], &mesh.mVertexColors[0],
+                    mesh.mVertexColors.size() * sizeof(aiColor4D));
         }
 
         // copy faces
-        for (unsigned int iFace = 0; iFace < p_pcOut->mNumFaces;++iFace)    {
+        for (unsigned int iFace = 0; iFace < p_pcOut->mNumFaces; ++iFace) {
             p_pcOut->mFaces[iFace].mNumIndices = 3;
             p_pcOut->mFaces[iFace].mIndices = new unsigned int[3];
 
@@ -1179,18 +1148,17 @@ void ASEImporter::ConvertMeshes(ASE::Mesh& mesh, std::vector<aiMesh*>& avOutMesh
         }
 
         // copy vertex bones
-        if (!mesh.mBones.empty() && !mesh.mBoneVertices.empty())    {
-            std::vector<std::vector<aiVertexWeight> > avBonesOut( mesh.mBones.size() );
+        if (!mesh.mBones.empty() && !mesh.mBoneVertices.empty()) {
+            std::vector<std::vector<aiVertexWeight>> avBonesOut(mesh.mBones.size());
 
             // find all vertex weights for this bone
             unsigned int quak = 0;
-            for (std::vector<BoneVertex>::const_iterator harrypotter =  mesh.mBoneVertices.begin();
-                harrypotter != mesh.mBoneVertices.end();++harrypotter,++quak)   {
+            for (std::vector<BoneVertex>::const_iterator harrypotter = mesh.mBoneVertices.begin();
+                    harrypotter != mesh.mBoneVertices.end(); ++harrypotter, ++quak) {
 
-                for (std::vector<std::pair<int,float> >::const_iterator
-                    ronaldweasley  = (*harrypotter).mBoneWeights.begin();
-                    ronaldweasley != (*harrypotter).mBoneWeights.end();++ronaldweasley)
-                {
+                for (std::vector<std::pair<int, float>>::const_iterator
+                                ronaldweasley = (*harrypotter).mBoneWeights.begin();
+                        ronaldweasley != (*harrypotter).mBoneWeights.end(); ++ronaldweasley) {
                     aiVertexWeight weight;
                     weight.mVertexId = quak;
                     weight.mWeight = (*ronaldweasley).second;
@@ -1200,19 +1168,19 @@ void ASEImporter::ConvertMeshes(ASE::Mesh& mesh, std::vector<aiMesh*>& avOutMesh
 
             // now build a final bone list
             p_pcOut->mNumBones = 0;
-            for (unsigned int jfkennedy = 0; jfkennedy < mesh.mBones.size();++jfkennedy)
-                if (!avBonesOut[jfkennedy].empty())p_pcOut->mNumBones++;
+            for (unsigned int jfkennedy = 0; jfkennedy < mesh.mBones.size(); ++jfkennedy)
+                if (!avBonesOut[jfkennedy].empty()) p_pcOut->mNumBones++;
 
-            p_pcOut->mBones = new aiBone*[p_pcOut->mNumBones];
-            aiBone** pcBone = p_pcOut->mBones;
-            for (unsigned int jfkennedy = 0; jfkennedy < mesh.mBones.size();++jfkennedy)    {
+            p_pcOut->mBones = new aiBone *[p_pcOut->mNumBones];
+            aiBone **pcBone = p_pcOut->mBones;
+            for (unsigned int jfkennedy = 0; jfkennedy < mesh.mBones.size(); ++jfkennedy) {
                 if (!avBonesOut[jfkennedy].empty()) {
-                    aiBone* pc = *pcBone = new aiBone();
+                    aiBone *pc = *pcBone = new aiBone();
                     pc->mName.Set(mesh.mBones[jfkennedy].mName);
                     pc->mNumWeights = (unsigned int)avBonesOut[jfkennedy].size();
                     pc->mWeights = new aiVertexWeight[pc->mNumWeights];
-                    ::memcpy(pc->mWeights,&avBonesOut[jfkennedy][0],
-                        sizeof(aiVertexWeight) * pc->mNumWeights);
+                    ::memcpy(pc->mWeights, &avBonesOut[jfkennedy][0],
+                            sizeof(aiVertexWeight) * pc->mNumWeights);
                     ++pcBone;
                 }
             }
@@ -1222,23 +1190,20 @@ void ASEImporter::ConvertMeshes(ASE::Mesh& mesh, std::vector<aiMesh*>& avOutMesh
 
 // ------------------------------------------------------------------------------------------------
 // Setup proper material indices and build output materials
-void ASEImporter::BuildMaterialIndices()
-{
-    ai_assert(NULL != pcScene);
+void ASEImporter::BuildMaterialIndices() {
+    ai_assert(nullptr != pcScene);
 
     // iterate through all materials and check whether we need them
-    for (unsigned int iMat = 0; iMat < mParser->m_vMaterials.size();++iMat)
-    {
-        ASE::Material& mat = mParser->m_vMaterials[iMat];
-        if (mat.bNeed)  {
+    for (unsigned int iMat = 0; iMat < mParser->m_vMaterials.size(); ++iMat) {
+        ASE::Material &mat = mParser->m_vMaterials[iMat];
+        if (mat.bNeed) {
             // Convert it to the aiMaterial layout
             ConvertMaterial(mat);
             ++pcScene->mNumMaterials;
         }
-        for (unsigned int iSubMat = 0; iSubMat < mat.avSubMaterials.size();++iSubMat)
-        {
-            ASE::Material& submat = mat.avSubMaterials[iSubMat];
-            if (submat.bNeed)   {
+        for (unsigned int iSubMat = 0; iSubMat < mat.avSubMaterials.size(); ++iSubMat) {
+            ASE::Material &submat = mat.avSubMaterials[iSubMat];
+            if (submat.bNeed) {
                 // Convert it to the aiMaterial layout
                 ConvertMaterial(submat);
                 ++pcScene->mNumMaterials;
@@ -1247,15 +1212,14 @@ void ASEImporter::BuildMaterialIndices()
     }
 
     // allocate the output material array
-    pcScene->mMaterials = new aiMaterial*[pcScene->mNumMaterials];
-    D3DS::Material** pcIntMaterials = new D3DS::Material*[pcScene->mNumMaterials];
+    pcScene->mMaterials = new aiMaterial *[pcScene->mNumMaterials];
+    D3DS::Material **pcIntMaterials = new D3DS::Material *[pcScene->mNumMaterials];
 
     unsigned int iNum = 0;
-    for (unsigned int iMat = 0; iMat < mParser->m_vMaterials.size();++iMat) {
-        ASE::Material& mat = mParser->m_vMaterials[iMat];
-        if (mat.bNeed)
-        {
-            ai_assert(NULL != mat.pcInstance);
+    for (unsigned int iMat = 0; iMat < mParser->m_vMaterials.size(); ++iMat) {
+        ASE::Material &mat = mParser->m_vMaterials[iMat];
+        if (mat.bNeed) {
+            ai_assert(nullptr != mat.pcInstance);
             pcScene->mMaterials[iNum] = mat.pcInstance;
 
             // Store the internal material, too
@@ -1263,22 +1227,20 @@ void ASEImporter::BuildMaterialIndices()
 
             // Iterate through all meshes and search for one which is using
             // this top-level material index
-            for (unsigned int iMesh = 0; iMesh < pcScene->mNumMeshes;++iMesh)
-            {
-                aiMesh* mesh = pcScene->mMeshes[iMesh];
+            for (unsigned int iMesh = 0; iMesh < pcScene->mNumMeshes; ++iMesh) {
+                aiMesh *mesh = pcScene->mMeshes[iMesh];
                 if (ASE::Face::DEFAULT_MATINDEX == mesh->mMaterialIndex &&
-                    iMat == (uintptr_t)mesh->mColors[3])
-                {
+                        iMat == (uintptr_t)mesh->mColors[3]) {
                     mesh->mMaterialIndex = iNum;
-                    mesh->mColors[3] = NULL;
+                    mesh->mColors[3] = nullptr;
                 }
             }
             iNum++;
         }
-        for (unsigned int iSubMat = 0; iSubMat < mat.avSubMaterials.size();++iSubMat)   {
-            ASE::Material& submat = mat.avSubMaterials[iSubMat];
-            if (submat.bNeed)   {
-                ai_assert(NULL != submat.pcInstance);
+        for (unsigned int iSubMat = 0; iSubMat < mat.avSubMaterials.size(); ++iSubMat) {
+            ASE::Material &submat = mat.avSubMaterials[iSubMat];
+            if (submat.bNeed) {
+                ai_assert(nullptr != submat.pcInstance);
                 pcScene->mMaterials[iNum] = submat.pcInstance;
 
                 // Store the internal material, too
@@ -1286,12 +1248,12 @@ void ASEImporter::BuildMaterialIndices()
 
                 // Iterate through all meshes and search for one which is using
                 // this sub-level material index
-                for (unsigned int iMesh = 0; iMesh < pcScene->mNumMeshes;++iMesh)   {
-                    aiMesh* mesh = pcScene->mMeshes[iMesh];
+                for (unsigned int iMesh = 0; iMesh < pcScene->mNumMeshes; ++iMesh) {
+                    aiMesh *mesh = pcScene->mMeshes[iMesh];
 
                     if (iSubMat == mesh->mMaterialIndex && iMat == (uintptr_t)mesh->mColors[3]) {
                         mesh->mMaterialIndex = iNum;
-                        mesh->mColors[3]     = NULL;
+                        mesh->mColors[3] = nullptr;
                     }
                 }
                 iNum++;
@@ -1305,15 +1267,13 @@ void ASEImporter::BuildMaterialIndices()
 
 // ------------------------------------------------------------------------------------------------
 // Generate normal vectors basing on smoothing groups
-bool ASEImporter::GenerateNormals(ASE::Mesh& mesh)  {
+bool ASEImporter::GenerateNormals(ASE::Mesh &mesh) {
 
-    if (!mesh.mNormals.empty() && !configRecomputeNormals)
-    {
+    if (!mesh.mNormals.empty() && !configRecomputeNormals) {
         // Check whether there are only uninitialized normals. If there are
         // some, skip all normals from the file and compute them on our own
-        for (std::vector<aiVector3D>::const_iterator qq =  mesh.mNormals.begin();qq != mesh.mNormals.end();++qq) {
-            if ((*qq).x || (*qq).y || (*qq).z)
-            {
+        for (std::vector<aiVector3D>::const_iterator qq = mesh.mNormals.begin(); qq != mesh.mNormals.end(); ++qq) {
+            if ((*qq).x || (*qq).y || (*qq).z) {
                 return true;
             }
         }
diff --git a/Engine/lib/assimp/code/ASE/ASELoader.h b/Engine/lib/assimp/code/AssetLib/ASE/ASELoader.h
similarity index 96%
rename from Engine/lib/assimp/code/ASE/ASELoader.h
rename to Engine/lib/assimp/code/AssetLib/ASE/ASELoader.h
index b497aa48b..cd9123556 100644
--- a/Engine/lib/assimp/code/ASE/ASELoader.h
+++ b/Engine/lib/assimp/code/AssetLib/ASE/ASELoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -62,42 +62,37 @@ namespace Assimp {
 class ASEImporter : public BaseImporter {
 public:
     ASEImporter();
-    ~ASEImporter();
+    ~ASEImporter() override;
 
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
      * See BaseImporter::CanRead() for details.
      */
     bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
+        bool checkSig) const override;
 
 protected:
-
     // -------------------------------------------------------------------
     /** Return importer meta information.
      * See #BaseImporter::GetInfo for the details
      */
-    const aiImporterDesc* GetInfo () const;
-
+    const aiImporterDesc* GetInfo () const override;
 
     // -------------------------------------------------------------------
     /** Imports the given file into the given scene structure.
     * See BaseImporter::InternReadFile() for details
     */
     void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
-
+        IOSystem* pIOHandler) override;
 
     // -------------------------------------------------------------------
     /** Called prior to ReadFile().
     * The function is a request to the importer to update its configuration
     * basing on the Importer's configuration property list.
     */
-    void SetupProperties(const Importer* pImp);
-
+    void SetupProperties(const Importer* pImp) override;
 
 private:
-
     // -------------------------------------------------------------------
     /** Generate normal vectors basing on smoothing groups
      * (in some cases the normal are already contained in the file)
@@ -106,7 +101,6 @@ private:
      */
     bool GenerateNormals(ASE::Mesh& mesh);
 
-
     // -------------------------------------------------------------------
     /** Create valid vertex/normal/UV/color/face lists.
      *  All elements are unique, faces have only one set of indices
@@ -115,51 +109,43 @@ private:
      */
     void BuildUniqueRepresentation(ASE::Mesh& mesh);
 
-
     /** Create one-material-per-mesh meshes ;-)
      * \param mesh Mesh to work with
      *  \param Receives the list of all created meshes
      */
     void ConvertMeshes(ASE::Mesh& mesh, std::vector<aiMesh*>& avOut);
 
-
     // -------------------------------------------------------------------
     /** Convert a material to a aiMaterial object
      * \param mat Input material
      */
     void ConvertMaterial(ASE::Material& mat);
 
-
     // -------------------------------------------------------------------
     /** Setup the final material indices for each mesh
      */
     void BuildMaterialIndices();
 
-
     // -------------------------------------------------------------------
     /** Build the node graph
      */
     void BuildNodes(std::vector<ASE::BaseNode*>& nodes);
 
-
     // -------------------------------------------------------------------
     /** Build output cameras
      */
     void BuildCameras();
 
-
     // -------------------------------------------------------------------
     /** Build output lights
      */
     void BuildLights();
 
-
     // -------------------------------------------------------------------
     /** Build output animations
      */
     void BuildAnimations(const std::vector<ASE::BaseNode*>& nodes);
 
-
     // -------------------------------------------------------------------
     /** Add sub nodes to a node
      *  \param pcParent parent node to be filled
@@ -183,7 +169,6 @@ private:
     void GenerateDefaultMaterial();
 
 protected:
-
     /** Parser instance */
     ASE::Parser* mParser;
 
diff --git a/Engine/lib/assimp/code/ASE/ASEParser.cpp b/Engine/lib/assimp/code/AssetLib/ASE/ASEParser.cpp
similarity index 58%
rename from Engine/lib/assimp/code/ASE/ASEParser.cpp
rename to Engine/lib/assimp/code/AssetLib/ASE/ASEParser.cpp
index 913e7b118..14eb720f4 100644
--- a/Engine/lib/assimp/code/ASE/ASEParser.cpp
+++ b/Engine/lib/assimp/code/AssetLib/ASE/ASEParser.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -49,8 +47,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_3DS_IMPORTER
 
 // internal headers
-#include "PostProcessing/TextureTransform.h"
 #include "ASELoader.h"
+#include "PostProcessing/TextureTransform.h"
 
 #include <assimp/fast_atof.h>
 #include <assimp/DefaultLogger.hpp>
@@ -67,26 +65,23 @@ using namespace Assimp::ASE;
 // ------------------------------------------------------------------------------------------------
 // Handle a "top-level" section in the file. EOF is no error in this case.
 
-#define AI_ASE_HANDLE_TOP_LEVEL_SECTION() \
-    else if ('{' == *filePtr)iDepth++; \
-    else if ('}' == *filePtr) \
-    { \
-        if (0 == --iDepth) \
-        { \
-            ++filePtr; \
-            SkipToNextToken(); \
-            return; \
-        } \
-    } \
-    else if ('\0' == *filePtr) \
-    { \
-        return; \
-    } \
-    if(IsLineEnd(*filePtr) && !bLastWasEndLine) \
-    { \
-        ++iLineNumber; \
-        bLastWasEndLine = true; \
-    } else bLastWasEndLine = false; \
+#define AI_ASE_HANDLE_TOP_LEVEL_SECTION()          \
+    else if ('{' == *filePtr) iDepth++;            \
+    else if ('}' == *filePtr) {                    \
+        if (0 == --iDepth) {                       \
+            ++filePtr;                             \
+            SkipToNextToken();                     \
+            return;                                \
+        }                                          \
+    }                                              \
+    else if ('\0' == *filePtr) {                   \
+        return;                                    \
+    }                                              \
+    if (IsLineEnd(*filePtr) && !bLastWasEndLine) { \
+        ++iLineNumber;                             \
+        bLastWasEndLine = true;                    \
+    } else                                         \
+        bLastWasEndLine = false;                   \
     ++filePtr;
 
 // ------------------------------------------------------------------------------------------------
@@ -94,59 +89,55 @@ using namespace Assimp::ASE;
 // @param level "Depth" of the section
 // @param msg Full name of the section (including the asterisk)
 
-#define AI_ASE_HANDLE_SECTION(level, msg) \
-    if ('{' == *filePtr)iDepth++; \
-    else if ('}' == *filePtr) \
-    { \
-        if (0 == --iDepth) \
-        { \
-            ++filePtr; \
-            SkipToNextToken(); \
-            return; \
-        } \
-    } \
-    else if ('\0' == *filePtr) \
-    { \
+#define AI_ASE_HANDLE_SECTION(level, msg)                          \
+    if ('{' == *filePtr)                                           \
+        iDepth++;                                                  \
+    else if ('}' == *filePtr) {                                    \
+        if (0 == --iDepth) {                                       \
+            ++filePtr;                                             \
+            SkipToNextToken();                                     \
+            return;                                                \
+        }                                                          \
+    } else if ('\0' == *filePtr) {                                 \
         LogError("Encountered unexpected EOL while parsing a " msg \
-        " chunk (Level " level ")"); \
-    } \
-    if(IsLineEnd(*filePtr) && !bLastWasEndLine) \
-        { \
-        ++iLineNumber; \
-        bLastWasEndLine = true; \
-    } else bLastWasEndLine = false; \
+                 " chunk (Level " level ")");                      \
+    }                                                              \
+    if (IsLineEnd(*filePtr) && !bLastWasEndLine) {                 \
+        ++iLineNumber;                                             \
+        bLastWasEndLine = true;                                    \
+    } else                                                         \
+        bLastWasEndLine = false;                                   \
     ++filePtr;
 
 // ------------------------------------------------------------------------------------------------
-Parser::Parser (const char* szFile, unsigned int fileFormatDefault)
-{
-    ai_assert(NULL != szFile);
+Parser::Parser(const char *szFile, unsigned int fileFormatDefault) {
+    ai_assert(nullptr != szFile);
+
     filePtr = szFile;
     iFileFormat = fileFormatDefault;
 
     // make sure that the color values are invalid
     m_clrBackground.r = get_qnan();
-    m_clrAmbient.r    = get_qnan();
+    m_clrAmbient.r = get_qnan();
 
     // setup some default values
     iLineNumber = 0;
     iFirstFrame = 0;
     iLastFrame = 0;
-    iFrameSpeed = 30;        // use 30 as default value for this property
-    iTicksPerFrame = 1;      // use 1 as default value for this property
+    iFrameSpeed = 30; // use 30 as default value for this property
+    iTicksPerFrame = 1; // use 1 as default value for this property
     bLastWasEndLine = false; // need to handle \r\n seqs due to binary file mapping
 }
 
 // ------------------------------------------------------------------------------------------------
-void Parser::LogWarning(const char* szWarn)
-{
-    ai_assert(NULL != szWarn);
+void Parser::LogWarning(const char *szWarn) {
+    ai_assert(nullptr != szWarn);
 
-    char szTemp[1024];
+    char szTemp[2048];
 #if _MSC_VER >= 1400
-    sprintf_s(szTemp, "Line %u: %s",iLineNumber,szWarn);
+    sprintf_s(szTemp, "Line %u: %s", iLineNumber, szWarn);
 #else
-    ai_snprintf(szTemp,1024,"Line %u: %s",iLineNumber,szWarn);
+    ai_snprintf(szTemp, sizeof(szTemp), "Line %u: %s", iLineNumber, szWarn);
 #endif
 
     // output the warning to the logger ...
@@ -154,15 +145,14 @@ void Parser::LogWarning(const char* szWarn)
 }
 
 // ------------------------------------------------------------------------------------------------
-void Parser::LogInfo(const char* szWarn)
-{
-    ai_assert(NULL != szWarn);
+void Parser::LogInfo(const char *szWarn) {
+    ai_assert(nullptr != szWarn);
 
     char szTemp[1024];
 #if _MSC_VER >= 1400
-    sprintf_s(szTemp,"Line %u: %s",iLineNumber,szWarn);
+    sprintf_s(szTemp, "Line %u: %s", iLineNumber, szWarn);
 #else
-    ai_snprintf(szTemp,1024,"Line %u: %s",iLineNumber,szWarn);
+    ai_snprintf(szTemp, 1024, "Line %u: %s", iLineNumber, szWarn);
 #endif
 
     // output the information to the logger ...
@@ -170,15 +160,14 @@ void Parser::LogInfo(const char* szWarn)
 }
 
 // ------------------------------------------------------------------------------------------------
-AI_WONT_RETURN void Parser::LogError(const char* szWarn)
-{
-    ai_assert(NULL != szWarn);
+AI_WONT_RETURN void Parser::LogError(const char *szWarn) {
+    ai_assert(nullptr != szWarn);
 
     char szTemp[1024];
 #if _MSC_VER >= 1400
-    sprintf_s(szTemp,"Line %u: %s",iLineNumber,szWarn);
+    sprintf_s(szTemp, "Line %u: %s", iLineNumber, szWarn);
 #else
-    ai_snprintf(szTemp,1024,"Line %u: %s",iLineNumber,szWarn);
+    ai_snprintf(szTemp, 1024, "Line %u: %s", iLineNumber, szWarn);
 #endif
 
     // throw an exception
@@ -186,76 +175,60 @@ AI_WONT_RETURN void Parser::LogError(const char* szWarn)
 }
 
 // ------------------------------------------------------------------------------------------------
-bool Parser::SkipToNextToken()
-{
-    while (true)
-    {
+bool Parser::SkipToNextToken() {
+    while (true) {
         char me = *filePtr;
 
         // increase the line number counter if necessary
-        if (IsLineEnd(me) && !bLastWasEndLine)
-        {
+        if (IsLineEnd(me) && !bLastWasEndLine) {
             ++iLineNumber;
             bLastWasEndLine = true;
-        }
-        else bLastWasEndLine = false;
-        if ('*' == me || '}' == me || '{' == me)return true;
-        if ('\0' == me)return false;
+        } else
+            bLastWasEndLine = false;
+        if ('*' == me || '}' == me || '{' == me) return true;
+        if ('\0' == me) return false;
 
         ++filePtr;
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-bool Parser::SkipSection()
-{
+bool Parser::SkipSection() {
     // must handle subsections ...
     int iCnt = 0;
-    while (true)
-    {
-        if ('}' == *filePtr)
-        {
+    while (true) {
+        if ('}' == *filePtr) {
             --iCnt;
-            if (0 == iCnt)
-            {
+            if (0 == iCnt) {
                 // go to the next valid token ...
                 ++filePtr;
                 SkipToNextToken();
                 return true;
             }
-        }
-        else if ('{' == *filePtr)
-        {
+        } else if ('{' == *filePtr) {
             ++iCnt;
-        }
-        else if ('\0' == *filePtr)
-        {
+        } else if ('\0' == *filePtr) {
             LogWarning("Unable to parse block: Unexpected EOF, closing bracket \'}\' was expected [#1]");
             return false;
-        }
-        else if(IsLineEnd(*filePtr))++iLineNumber;
+        } else if (IsLineEnd(*filePtr))
+            ++iLineNumber;
         ++filePtr;
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void Parser::Parse()
-{
+void Parser::Parse() {
     AI_ASE_PARSER_INIT();
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             // Version should be 200. Validate this ...
-            if (TokenMatch(filePtr,"3DSMAX_ASCIIEXPORT",18))
-            {
+            if (TokenMatch(filePtr, "3DSMAX_ASCIIEXPORT", 18)) {
                 unsigned int fmt;
                 ParseLV4MeshLong(fmt);
 
-                if (fmt > 200)
-                {
+                if (fmt > 200) {
                     LogWarning("Unknown file format version: *3DSMAX_ASCIIEXPORT should \
                                be <= 200");
                 }
@@ -266,32 +239,29 @@ void Parser::Parse()
                 // at the file extension (ASE, ASK, ASC)
                 // *************************************************************
 
-                if ( fmt ) {
+                if (fmt) {
                     iFileFormat = fmt;
                 }
                 continue;
             }
             // main scene information
-            if (TokenMatch(filePtr,"SCENE",5))
-            {
+            if (TokenMatch(filePtr, "SCENE", 5)) {
                 ParseLV1SceneBlock();
                 continue;
             }
             // "group" - no implementation yet, in facte
             // we're just ignoring them for the moment
-            if (TokenMatch(filePtr,"GROUP",5))
-            {
+            if (TokenMatch(filePtr, "GROUP", 5)) {
                 Parse();
                 continue;
             }
             // material list
-            if (TokenMatch(filePtr,"MATERIAL_LIST",13))
-            {
+            if (TokenMatch(filePtr, "MATERIAL_LIST", 13)) {
                 ParseLV1MaterialListBlock();
                 continue;
             }
             // geometric object (mesh)
-            if (TokenMatch(filePtr,"GEOMOBJECT",10))
+            if (TokenMatch(filePtr, "GEOMOBJECT", 10))
 
             {
                 m_vMeshes.push_back(Mesh("UNNAMED"));
@@ -299,7 +269,7 @@ void Parser::Parse()
                 continue;
             }
             // helper object = dummy in the hierarchy
-            if (TokenMatch(filePtr,"HELPEROBJECT",12))
+            if (TokenMatch(filePtr, "HELPEROBJECT", 12))
 
             {
                 m_vDummies.push_back(Dummy());
@@ -307,7 +277,7 @@ void Parser::Parse()
                 continue;
             }
             // light object
-            if (TokenMatch(filePtr,"LIGHTOBJECT",11))
+            if (TokenMatch(filePtr, "LIGHTOBJECT", 11))
 
             {
                 m_vLights.push_back(Light("UNNAMED"));
@@ -315,23 +285,20 @@ void Parser::Parse()
                 continue;
             }
             // camera object
-            if (TokenMatch(filePtr,"CAMERAOBJECT",12))
-            {
+            if (TokenMatch(filePtr, "CAMERAOBJECT", 12)) {
                 m_vCameras.push_back(Camera("UNNAMED"));
                 ParseLV1ObjectBlock(m_vCameras.back());
                 continue;
             }
             // comment - print it on the console
-            if (TokenMatch(filePtr,"COMMENT",7))
-            {
+            if (TokenMatch(filePtr, "COMMENT", 7)) {
                 std::string out = "<unknown>";
-                ParseString(out,"*COMMENT");
+                ParseString(out, "*COMMENT");
                 LogInfo(("Comment: " + out).c_str());
                 continue;
             }
             // ASC bone weights
-            if (AI_ASE_IS_OLD_FILE_FORMAT() && TokenMatch(filePtr,"MESH_SOFTSKINVERTS",18))
-            {
+            if (AI_ASE_IS_OLD_FILE_FORMAT() && TokenMatch(filePtr, "MESH_SOFTSKINVERTS", 18)) {
                 ParseLV1SoftSkinBlock();
             }
         }
@@ -341,8 +308,7 @@ void Parser::Parse()
 }
 
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV1SoftSkinBlock()
-{
+void Parser::ParseLV1SoftSkinBlock() {
     // TODO: fix line counting here
 
     // **************************************************************
@@ -364,80 +330,77 @@ void Parser::ParseLV1SoftSkinBlock()
     FORMAT END
     */
     // **************************************************************
-    while (true)
-    {
-        if (*filePtr == '}'      )  {++filePtr;return;}
-        else if (*filePtr == '\0')  return;
-        else if (*filePtr == '{' )  ++filePtr;
+    while (true) {
+        if (*filePtr == '}') {
+            ++filePtr;
+            return;
+        } else if (*filePtr == '\0')
+            return;
+        else if (*filePtr == '{')
+            ++filePtr;
 
         else // if (!IsSpace(*filePtr) && !IsLineEnd(*filePtr))
         {
-            ASE::Mesh* curMesh      = NULL;
-            unsigned int numVerts   = 0;
+            ASE::Mesh *curMesh = nullptr;
+            unsigned int numVerts = 0;
 
-            const char* sz = filePtr;
-            while (!IsSpaceOrNewLine(*filePtr))++filePtr;
+            const char *sz = filePtr;
+            while (!IsSpaceOrNewLine(*filePtr))
+                ++filePtr;
 
-            const unsigned int diff = (unsigned int)(filePtr-sz);
-            if (diff)
-            {
-                std::string name = std::string(sz,diff);
+            const unsigned int diff = (unsigned int)(filePtr - sz);
+            if (diff) {
+                std::string name = std::string(sz, diff);
                 for (std::vector<ASE::Mesh>::iterator it = m_vMeshes.begin();
-                    it != m_vMeshes.end(); ++it)
-                {
-                    if ((*it).mName == name)
-                    {
-                        curMesh = & (*it);
+                        it != m_vMeshes.end(); ++it) {
+                    if ((*it).mName == name) {
+                        curMesh = &(*it);
                         break;
                     }
                 }
-                if (!curMesh)
-                {
+                if (!curMesh) {
                     LogWarning("Encountered unknown mesh in *MESH_SOFTSKINVERTS section");
 
                     // Skip the mesh data - until we find a new mesh
                     // or the end of the *MESH_SOFTSKINVERTS section
-                    while (true)
-                    {
+                    while (true) {
                         SkipSpacesAndLineEnd(&filePtr);
-                        if (*filePtr == '}')
-                            {++filePtr;return;}
-                        else if (!IsNumeric(*filePtr))
+                        if (*filePtr == '}') {
+                            ++filePtr;
+                            return;
+                        } else if (!IsNumeric(*filePtr))
                             break;
 
                         SkipLine(&filePtr);
                     }
-                }
-                else
-                {
+                } else {
                     SkipSpacesAndLineEnd(&filePtr);
                     ParseLV4MeshLong(numVerts);
 
                     // Reserve enough storage
                     curMesh->mBoneVertices.reserve(numVerts);
 
-                    for (unsigned int i = 0; i < numVerts;++i)
-                    {
+                    for (unsigned int i = 0; i < numVerts; ++i) {
                         SkipSpacesAndLineEnd(&filePtr);
                         unsigned int numWeights;
                         ParseLV4MeshLong(numWeights);
 
                         curMesh->mBoneVertices.push_back(ASE::BoneVertex());
-                        ASE::BoneVertex& vert = curMesh->mBoneVertices.back();
+                        ASE::BoneVertex &vert = curMesh->mBoneVertices.back();
 
                         // Reserve enough storage
                         vert.mBoneWeights.reserve(numWeights);
 
                         std::string bone;
-                        for (unsigned int w = 0; w < numWeights;++w) {
+                        for (unsigned int w = 0; w < numWeights; ++w) {
                             bone.clear();
-                            ParseString(bone,"*MESH_SOFTSKINVERTS.Bone");
+                            ParseString(bone, "*MESH_SOFTSKINVERTS.Bone");
 
                             // Find the bone in the mesh's list
-                            std::pair<int,ai_real> me;
+                            std::pair<int, ai_real> me;
                             me.first = -1;
 
-                            for (unsigned int n = 0; n < curMesh->mBones.size();++n) {
+                            for (unsigned int n = 0; n < curMesh->mBones.size(); ++n) {
                                 if (curMesh->mBones[n].mName == bone) {
                                     me.first = n;
                                     break;
@@ -445,10 +408,10 @@ void Parser::ParseLV1SoftSkinBlock()
                             }
                             if (-1 == me.first) {
                                 // We don't have this bone yet, so add it to the list
-                                me.first = static_cast<int>( curMesh->mBones.size() );
-                                curMesh->mBones.push_back( ASE::Bone( bone ) );
+                                me.first = static_cast<int>(curMesh->mBones.size());
+                                curMesh->mBones.push_back(ASE::Bone(bone));
                             }
-                            ParseLV4MeshFloat( me.second );
+                            ParseLV4MeshFloat(me.second);
 
                             // Add the new bone weight to list
                             vert.mBoneWeights.push_back(me);
@@ -463,45 +426,38 @@ void Parser::ParseLV1SoftSkinBlock()
 }
 
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV1SceneBlock()
-{
+void Parser::ParseLV1SceneBlock() {
     AI_ASE_PARSER_INIT();
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
-            if (TokenMatch(filePtr,"SCENE_BACKGROUND_STATIC",23))
+            if (TokenMatch(filePtr, "SCENE_BACKGROUND_STATIC", 23))
 
             {
                 // parse a color triple and assume it is really the bg color
-                ParseLV4MeshFloatTriple( &m_clrBackground.r );
+                ParseLV4MeshFloatTriple(&m_clrBackground.r);
                 continue;
             }
-            if (TokenMatch(filePtr,"SCENE_AMBIENT_STATIC",20))
+            if (TokenMatch(filePtr, "SCENE_AMBIENT_STATIC", 20))
 
             {
                 // parse a color triple and assume it is really the bg color
-                ParseLV4MeshFloatTriple( &m_clrAmbient.r );
+                ParseLV4MeshFloatTriple(&m_clrAmbient.r);
                 continue;
             }
-            if (TokenMatch(filePtr,"SCENE_FIRSTFRAME",16))
-            {
+            if (TokenMatch(filePtr, "SCENE_FIRSTFRAME", 16)) {
                 ParseLV4MeshLong(iFirstFrame);
                 continue;
             }
-            if (TokenMatch(filePtr,"SCENE_LASTFRAME",15))
-            {
+            if (TokenMatch(filePtr, "SCENE_LASTFRAME", 15)) {
                 ParseLV4MeshLong(iLastFrame);
                 continue;
             }
-            if (TokenMatch(filePtr,"SCENE_FRAMESPEED",16))
-            {
+            if (TokenMatch(filePtr, "SCENE_FRAMESPEED", 16)) {
                 ParseLV4MeshLong(iFrameSpeed);
                 continue;
             }
-            if (TokenMatch(filePtr,"SCENE_TICKSPERFRAME",19))
-            {
+            if (TokenMatch(filePtr, "SCENE_TICKSPERFRAME", 19)) {
                 ParseLV4MeshLong(iTicksPerFrame);
                 continue;
             }
@@ -511,103 +467,87 @@ void Parser::ParseLV1SceneBlock()
 }
 
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV1MaterialListBlock()
-{
+void Parser::ParseLV1MaterialListBlock() {
     AI_ASE_PARSER_INIT();
 
     unsigned int iMaterialCount = 0;
     unsigned int iOldMaterialCount = (unsigned int)m_vMaterials.size();
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
-            if (TokenMatch(filePtr,"MATERIAL_COUNT",14))
-            {
+            if (TokenMatch(filePtr, "MATERIAL_COUNT", 14)) {
                 ParseLV4MeshLong(iMaterialCount);
 
                 // now allocate enough storage to hold all materials
-                m_vMaterials.resize(iOldMaterialCount+iMaterialCount, Material("INVALID"));
+                m_vMaterials.resize(iOldMaterialCount + iMaterialCount, Material("INVALID"));
                 continue;
             }
-            if (TokenMatch(filePtr,"MATERIAL",8))
-            {
+            if (TokenMatch(filePtr, "MATERIAL", 8)) {
                 unsigned int iIndex = 0;
                 ParseLV4MeshLong(iIndex);
 
-                if (iIndex >= iMaterialCount)
-                {
+                if (iIndex >= iMaterialCount) {
                     LogWarning("Out of range: material index is too large");
-                    iIndex = iMaterialCount-1;
+                    iIndex = iMaterialCount - 1;
+                    return;
                 }
 
                 // get a reference to the material
-                Material& sMat = m_vMaterials[iIndex+iOldMaterialCount];
+                Material &sMat = m_vMaterials[iIndex + iOldMaterialCount];
                 // parse the material block
                 ParseLV2MaterialBlock(sMat);
                 continue;
             }
+            if( iDepth == 1 ){
+                // CRUDE HACK: support missing brace after "Ascii Scene Exporter v2.51"
+                LogWarning("Missing closing brace in material list");
+                --filePtr;
+                return;
+            }
         }
         AI_ASE_HANDLE_TOP_LEVEL_SECTION();
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV2MaterialBlock(ASE::Material& mat)
-{
+void Parser::ParseLV2MaterialBlock(ASE::Material &mat) {
     AI_ASE_PARSER_INIT();
 
     unsigned int iNumSubMaterials = 0;
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
-            if (TokenMatch(filePtr,"MATERIAL_NAME",13))
-            {
-                if (!ParseString(mat.mName,"*MATERIAL_NAME"))
+            if (TokenMatch(filePtr, "MATERIAL_NAME", 13)) {
+                if (!ParseString(mat.mName, "*MATERIAL_NAME"))
                     SkipToNextToken();
                 continue;
             }
             // ambient material color
-            if (TokenMatch(filePtr,"MATERIAL_AMBIENT",16))
-            {
+            if (TokenMatch(filePtr, "MATERIAL_AMBIENT", 16)) {
                 ParseLV4MeshFloatTriple(&mat.mAmbient.r);
                 continue;
             }
             // diffuse material color
-            if (TokenMatch(filePtr,"MATERIAL_DIFFUSE",16) )
-            {
+            if (TokenMatch(filePtr, "MATERIAL_DIFFUSE", 16)) {
                 ParseLV4MeshFloatTriple(&mat.mDiffuse.r);
                 continue;
             }
             // specular material color
-            if (TokenMatch(filePtr,"MATERIAL_SPECULAR",17))
-            {
+            if (TokenMatch(filePtr, "MATERIAL_SPECULAR", 17)) {
                 ParseLV4MeshFloatTriple(&mat.mSpecular.r);
                 continue;
             }
             // material shading type
-            if (TokenMatch(filePtr,"MATERIAL_SHADING",16))
-            {
-                if (TokenMatch(filePtr,"Blinn",5))
-                {
+            if (TokenMatch(filePtr, "MATERIAL_SHADING", 16)) {
+                if (TokenMatch(filePtr, "Blinn", 5)) {
                     mat.mShading = Discreet3DS::Blinn;
-                }
-                else if (TokenMatch(filePtr,"Phong",5))
-                {
+                } else if (TokenMatch(filePtr, "Phong", 5)) {
                     mat.mShading = Discreet3DS::Phong;
-                }
-                else if (TokenMatch(filePtr,"Flat",4))
-                {
+                } else if (TokenMatch(filePtr, "Flat", 4)) {
                     mat.mShading = Discreet3DS::Flat;
-                }
-                else if (TokenMatch(filePtr,"Wire",4))
-                {
+                } else if (TokenMatch(filePtr, "Wire", 4)) {
                     mat.mShading = Discreet3DS::Wire;
-                }
-                else
-                {
+                } else {
                     // assume gouraud shading
                     mat.mShading = Discreet3DS::Gouraud;
                     SkipToNextToken();
@@ -615,15 +555,13 @@ void Parser::ParseLV2MaterialBlock(ASE::Material& mat)
                 continue;
             }
             // material transparency
-            if (TokenMatch(filePtr,"MATERIAL_TRANSPARENCY",21))
-            {
+            if (TokenMatch(filePtr, "MATERIAL_TRANSPARENCY", 21)) {
                 ParseLV4MeshFloat(mat.mTransparency);
-                mat.mTransparency = ai_real( 1.0 ) - mat.mTransparency;
+                mat.mTransparency = ai_real(1.0) - mat.mTransparency;
                 continue;
             }
             // material self illumination
-            if (TokenMatch(filePtr,"MATERIAL_SELFILLUM",18))
-            {
+            if (TokenMatch(filePtr, "MATERIAL_SELFILLUM", 18)) {
                 ai_real f = 0.0;
                 ParseLV4MeshFloat(f);
 
@@ -633,108 +571,94 @@ void Parser::ParseLV2MaterialBlock(ASE::Material& mat)
                 continue;
             }
             // material shininess
-            if (TokenMatch(filePtr,"MATERIAL_SHINE",14) )
-            {
+            if (TokenMatch(filePtr, "MATERIAL_SHINE", 14)) {
                 ParseLV4MeshFloat(mat.mSpecularExponent);
                 mat.mSpecularExponent *= 15;
                 continue;
             }
             // two-sided material
-            if (TokenMatch(filePtr,"MATERIAL_TWOSIDED",17) )
-            {
+            if (TokenMatch(filePtr, "MATERIAL_TWOSIDED", 17)) {
                 mat.mTwoSided = true;
                 continue;
             }
             // material shininess strength
-            if (TokenMatch(filePtr,"MATERIAL_SHINESTRENGTH",22))
-            {
+            if (TokenMatch(filePtr, "MATERIAL_SHINESTRENGTH", 22)) {
                 ParseLV4MeshFloat(mat.mShininessStrength);
                 continue;
             }
             // diffuse color map
-            if (TokenMatch(filePtr,"MAP_DIFFUSE",11))
-            {
+            if (TokenMatch(filePtr, "MAP_DIFFUSE", 11)) {
                 // parse the texture block
                 ParseLV3MapBlock(mat.sTexDiffuse);
                 continue;
             }
             // ambient color map
-            if (TokenMatch(filePtr,"MAP_AMBIENT",11))
-            {
+            if (TokenMatch(filePtr, "MAP_AMBIENT", 11)) {
                 // parse the texture block
                 ParseLV3MapBlock(mat.sTexAmbient);
                 continue;
             }
             // specular color map
-            if (TokenMatch(filePtr,"MAP_SPECULAR",12))
-            {
+            if (TokenMatch(filePtr, "MAP_SPECULAR", 12)) {
                 // parse the texture block
                 ParseLV3MapBlock(mat.sTexSpecular);
                 continue;
             }
             // opacity map
-            if (TokenMatch(filePtr,"MAP_OPACITY",11))
-            {
+            if (TokenMatch(filePtr, "MAP_OPACITY", 11)) {
                 // parse the texture block
                 ParseLV3MapBlock(mat.sTexOpacity);
                 continue;
             }
             // emissive map
-            if (TokenMatch(filePtr,"MAP_SELFILLUM",13))
-            {
+            if (TokenMatch(filePtr, "MAP_SELFILLUM", 13)) {
                 // parse the texture block
                 ParseLV3MapBlock(mat.sTexEmissive);
                 continue;
             }
             // bump map
-            if (TokenMatch(filePtr,"MAP_BUMP",8))
-            {
+            if (TokenMatch(filePtr, "MAP_BUMP", 8)) {
                 // parse the texture block
                 ParseLV3MapBlock(mat.sTexBump);
             }
             // specular/shininess map
-            if (TokenMatch(filePtr,"MAP_SHINESTRENGTH",17))
-            {
+            if (TokenMatch(filePtr, "MAP_SHINESTRENGTH", 17)) {
                 // parse the texture block
                 ParseLV3MapBlock(mat.sTexShininess);
                 continue;
             }
             // number of submaterials
-            if (TokenMatch(filePtr,"NUMSUBMTLS",10))
-            {
+            if (TokenMatch(filePtr, "NUMSUBMTLS", 10)) {
                 ParseLV4MeshLong(iNumSubMaterials);
 
                 // allocate enough storage
                 mat.avSubMaterials.resize(iNumSubMaterials, Material("INVALID SUBMATERIAL"));
             }
             // submaterial chunks
-            if (TokenMatch(filePtr,"SUBMATERIAL",11))
-            {
+            if (TokenMatch(filePtr, "SUBMATERIAL", 11)) {
 
                 unsigned int iIndex = 0;
                 ParseLV4MeshLong(iIndex);
 
-                if (iIndex >= iNumSubMaterials)
-                {
+                if (iIndex >= iNumSubMaterials) {
                     LogWarning("Out of range: submaterial index is too large");
-                    iIndex = iNumSubMaterials-1;
+                    iIndex = iNumSubMaterials - 1;
                 }
 
                 // get a reference to the material
-                Material& sMat = mat.avSubMaterials[iIndex];
+                Material &sMat = mat.avSubMaterials[iIndex];
 
                 // parse the material block
                 ParseLV2MaterialBlock(sMat);
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("2","*MATERIAL");
+        AI_ASE_HANDLE_SECTION("2", "*MATERIAL");
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV3MapBlock(Texture& map)
-{
+void Parser::ParseLV3MapBlock(Texture &map) {
     AI_ASE_PARSER_INIT();
 
     // ***********************************************************
@@ -744,233 +668,186 @@ void Parser::ParseLV3MapBlock(Texture& map)
     // ***********************************************************
     bool parsePath = true;
     std::string temp;
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
             // type of map
-            if (TokenMatch(filePtr,"MAP_CLASS" ,9))
-            {
+            if (TokenMatch(filePtr, "MAP_CLASS", 9)) {
                 temp.clear();
-                if(!ParseString(temp,"*MAP_CLASS"))
+                if (!ParseString(temp, "*MAP_CLASS"))
                     SkipToNextToken();
-                if (temp != "Bitmap" && temp != "Normal Bump")
-                {
-                    ASSIMP_LOG_WARN_F("ASE: Skipping unknown map type: ", temp);
+                if (temp != "Bitmap" && temp != "Normal Bump") {
+                    ASSIMP_LOG_WARN("ASE: Skipping unknown map type: ", temp);
                     parsePath = false;
                 }
                 continue;
             }
             // path to the texture
-            if (parsePath && TokenMatch(filePtr,"BITMAP" ,6))
-            {
-                if(!ParseString(map.mMapName,"*BITMAP"))
+            if (parsePath && TokenMatch(filePtr, "BITMAP", 6)) {
+                if (!ParseString(map.mMapName, "*BITMAP"))
                     SkipToNextToken();
 
-                if (map.mMapName == "None")
-                {
+                if (map.mMapName == "None") {
                     // Files with 'None' as map name are produced by
                     // an Maja to ASE exporter which name I forgot ..
                     ASSIMP_LOG_WARN("ASE: Skipping invalid map entry");
-                    map.mMapName = "";
+                    map.mMapName = std::string();
                 }
 
                 continue;
             }
             // offset on the u axis
-            if (TokenMatch(filePtr,"UVW_U_OFFSET" ,12))
-            {
+            if (TokenMatch(filePtr, "UVW_U_OFFSET", 12)) {
                 ParseLV4MeshFloat(map.mOffsetU);
                 continue;
             }
             // offset on the v axis
-            if (TokenMatch(filePtr,"UVW_V_OFFSET" ,12))
-            {
+            if (TokenMatch(filePtr, "UVW_V_OFFSET", 12)) {
                 ParseLV4MeshFloat(map.mOffsetV);
                 continue;
             }
             // tiling on the u axis
-            if (TokenMatch(filePtr,"UVW_U_TILING" ,12))
-            {
+            if (TokenMatch(filePtr, "UVW_U_TILING", 12)) {
                 ParseLV4MeshFloat(map.mScaleU);
                 continue;
             }
             // tiling on the v axis
-            if (TokenMatch(filePtr,"UVW_V_TILING" ,12))
-            {
+            if (TokenMatch(filePtr, "UVW_V_TILING", 12)) {
                 ParseLV4MeshFloat(map.mScaleV);
                 continue;
             }
             // rotation around the z-axis
-            if (TokenMatch(filePtr,"UVW_ANGLE" ,9))
-            {
+            if (TokenMatch(filePtr, "UVW_ANGLE", 9)) {
                 ParseLV4MeshFloat(map.mRotation);
                 continue;
             }
             // map blending factor
-            if (TokenMatch(filePtr,"MAP_AMOUNT" ,10))
-            {
+            if (TokenMatch(filePtr, "MAP_AMOUNT", 10)) {
                 ParseLV4MeshFloat(map.mTextureBlend);
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("3","*MAP_XXXXXX");
+        AI_ASE_HANDLE_SECTION("3", "*MAP_XXXXXX");
     }
     return;
 }
 
 // ------------------------------------------------------------------------------------------------
-bool Parser::ParseString(std::string& out,const char* szName)
-{
+bool Parser::ParseString(std::string &out, const char *szName) {
     char szBuffer[1024];
-    if (!SkipSpaces(&filePtr))
-    {
+    if (!SkipSpaces(&filePtr)) {
 
-        ai_snprintf(szBuffer, 1024, "Unable to parse %s block: Unexpected EOL",szName);
+        ai_snprintf(szBuffer, 1024, "Unable to parse %s block: Unexpected EOL", szName);
         LogWarning(szBuffer);
         return false;
     }
     // there must be '"'
-    if ('\"' != *filePtr)
-    {
+    if ('\"' != *filePtr) {
 
         ai_snprintf(szBuffer, 1024, "Unable to parse %s block: Strings are expected "
-            "to be enclosed in double quotation marks",szName);
+                                    "to be enclosed in double quotation marks",
+                szName);
         LogWarning(szBuffer);
         return false;
     }
     ++filePtr;
-    const char* sz = filePtr;
-    while (true)
-    {
-        if ('\"' == *sz)break;
-        else if ('\0' == *sz)
-        {
+    const char *sz = filePtr;
+    while (true) {
+        if ('\"' == *sz)
+            break;
+        else if ('\0' == *sz) {
             ai_snprintf(szBuffer, 1024, "Unable to parse %s block: Strings are expected to "
-                "be enclosed in double quotation marks but EOF was reached before "
-                "a closing quotation mark was encountered",szName);
+                                        "be enclosed in double quotation marks but EOF was reached before "
+                                        "a closing quotation mark was encountered",
+                    szName);
             LogWarning(szBuffer);
             return false;
         }
         sz++;
     }
-    out = std::string(filePtr,(uintptr_t)sz-(uintptr_t)filePtr);
-    filePtr = sz+1;
+    out = std::string(filePtr, (uintptr_t)sz - (uintptr_t)filePtr);
+    filePtr = sz + 1;
     return true;
 }
 
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV1ObjectBlock(ASE::BaseNode& node)
-{
+void Parser::ParseLV1ObjectBlock(ASE::BaseNode &node) {
     AI_ASE_PARSER_INIT();
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             // first process common tokens such as node name and transform
             // name of the mesh/node
-            if (TokenMatch(filePtr,"NODE_NAME" ,9))
-            {
-                if(!ParseString(node.mName,"*NODE_NAME"))
+            if (TokenMatch(filePtr, "NODE_NAME", 9)) {
+                if (!ParseString(node.mName, "*NODE_NAME"))
                     SkipToNextToken();
                 continue;
             }
             // name of the parent of the node
-            if (TokenMatch(filePtr,"NODE_PARENT" ,11) )
-            {
-                if(!ParseString(node.mParent,"*NODE_PARENT"))
+            if (TokenMatch(filePtr, "NODE_PARENT", 11)) {
+                if (!ParseString(node.mParent, "*NODE_PARENT"))
                     SkipToNextToken();
                 continue;
             }
             // transformation matrix of the node
-            if (TokenMatch(filePtr,"NODE_TM" ,7))
-            {
+            if (TokenMatch(filePtr, "NODE_TM", 7)) {
                 ParseLV2NodeTransformBlock(node);
                 continue;
             }
             // animation data of the node
-            if (TokenMatch(filePtr,"TM_ANIMATION" ,12))
-            {
+            if (TokenMatch(filePtr, "TM_ANIMATION", 12)) {
                 ParseLV2AnimationBlock(node);
                 continue;
             }
 
-            if (node.mType == BaseNode::Light)
-            {
+            if (node.mType == BaseNode::Light) {
                 // light settings
-                if (TokenMatch(filePtr,"LIGHT_SETTINGS" ,14))
-                {
-                    ParseLV2LightSettingsBlock((ASE::Light&)node);
+                if (TokenMatch(filePtr, "LIGHT_SETTINGS", 14)) {
+                    ParseLV2LightSettingsBlock((ASE::Light &)node);
                     continue;
                 }
                 // type of the light source
-                if (TokenMatch(filePtr,"LIGHT_TYPE" ,10))
-                {
-                    if (!ASSIMP_strincmp("omni",filePtr,4))
-                    {
-                        ((ASE::Light&)node).mLightType = ASE::Light::OMNI;
-                    }
-                    else if (!ASSIMP_strincmp("target",filePtr,6))
-                    {
-                        ((ASE::Light&)node).mLightType = ASE::Light::TARGET;
-                    }
-                    else if (!ASSIMP_strincmp("free",filePtr,4))
-                    {
-                        ((ASE::Light&)node).mLightType = ASE::Light::FREE;
-                    }
-                    else if (!ASSIMP_strincmp("directional",filePtr,11))
-                    {
-                        ((ASE::Light&)node).mLightType = ASE::Light::DIRECTIONAL;
-                    }
-                    else
-                    {
+                if (TokenMatch(filePtr, "LIGHT_TYPE", 10)) {
+                    if (!ASSIMP_strincmp("omni", filePtr, 4)) {
+                        ((ASE::Light &)node).mLightType = ASE::Light::OMNI;
+                    } else if (!ASSIMP_strincmp("target", filePtr, 6)) {
+                        ((ASE::Light &)node).mLightType = ASE::Light::TARGET;
+                    } else if (!ASSIMP_strincmp("free", filePtr, 4)) {
+                        ((ASE::Light &)node).mLightType = ASE::Light::FREE;
+                    } else if (!ASSIMP_strincmp("directional", filePtr, 11)) {
+                        ((ASE::Light &)node).mLightType = ASE::Light::DIRECTIONAL;
+                    } else {
                         LogWarning("Unknown kind of light source");
                     }
                     continue;
                 }
-            }
-            else if (node.mType == BaseNode::Camera)
-            {
+            } else if (node.mType == BaseNode::Camera) {
                 // Camera settings
-                if (TokenMatch(filePtr,"CAMERA_SETTINGS" ,15))
-                {
-                    ParseLV2CameraSettingsBlock((ASE::Camera&)node);
+                if (TokenMatch(filePtr, "CAMERA_SETTINGS", 15)) {
+                    ParseLV2CameraSettingsBlock((ASE::Camera &)node);
                     continue;
-                }
-                else if (TokenMatch(filePtr,"CAMERA_TYPE" ,11))
-                {
-                    if (!ASSIMP_strincmp("target",filePtr,6))
-                    {
-                        ((ASE::Camera&)node).mCameraType = ASE::Camera::TARGET;
-                    }
-                    else if (!ASSIMP_strincmp("free",filePtr,4))
-                    {
-                        ((ASE::Camera&)node).mCameraType = ASE::Camera::FREE;
-                    }
-                    else
-                    {
+                } else if (TokenMatch(filePtr, "CAMERA_TYPE", 11)) {
+                    if (!ASSIMP_strincmp("target", filePtr, 6)) {
+                        ((ASE::Camera &)node).mCameraType = ASE::Camera::TARGET;
+                    } else if (!ASSIMP_strincmp("free", filePtr, 4)) {
+                        ((ASE::Camera &)node).mCameraType = ASE::Camera::FREE;
+                    } else {
                         LogWarning("Unknown kind of camera");
                     }
                     continue;
                 }
-            }
-            else if (node.mType == BaseNode::Mesh)
-            {
+            } else if (node.mType == BaseNode::Mesh) {
                 // mesh data
                 // FIX: Older files use MESH_SOFTSKIN
-                if (TokenMatch(filePtr,"MESH" ,4) ||
-                    TokenMatch(filePtr,"MESH_SOFTSKIN",13))
-                {
-                    ParseLV2MeshBlock((ASE::Mesh&)node);
+                if (TokenMatch(filePtr, "MESH", 4) ||
+                        TokenMatch(filePtr, "MESH_SOFTSKIN", 13)) {
+                    ParseLV2MeshBlock((ASE::Mesh &)node);
                     continue;
                 }
                 // mesh material index
-                if (TokenMatch(filePtr,"MATERIAL_REF" ,12))
-                {
-                    ParseLV4MeshLong(((ASE::Mesh&)node).iMaterialIndex);
+                if (TokenMatch(filePtr, "MATERIAL_REF", 12)) {
+                    ParseLV4MeshLong(((ASE::Mesh &)node).iMaterialIndex);
                     continue;
                 }
             }
@@ -981,156 +858,130 @@ void Parser::ParseLV1ObjectBlock(ASE::BaseNode& node)
 }
 
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV2CameraSettingsBlock(ASE::Camera& camera)
-{
+void Parser::ParseLV2CameraSettingsBlock(ASE::Camera &camera) {
     AI_ASE_PARSER_INIT();
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
-            if (TokenMatch(filePtr,"CAMERA_NEAR" ,11))
-            {
+            if (TokenMatch(filePtr, "CAMERA_NEAR", 11)) {
                 ParseLV4MeshFloat(camera.mNear);
                 continue;
             }
-            if (TokenMatch(filePtr,"CAMERA_FAR" ,10))
-            {
+            if (TokenMatch(filePtr, "CAMERA_FAR", 10)) {
                 ParseLV4MeshFloat(camera.mFar);
                 continue;
             }
-            if (TokenMatch(filePtr,"CAMERA_FOV" ,10))
-            {
+            if (TokenMatch(filePtr, "CAMERA_FOV", 10)) {
                 ParseLV4MeshFloat(camera.mFOV);
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("2","CAMERA_SETTINGS");
+        AI_ASE_HANDLE_SECTION("2", "CAMERA_SETTINGS");
     }
     return;
 }
 
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV2LightSettingsBlock(ASE::Light& light)
-{
+void Parser::ParseLV2LightSettingsBlock(ASE::Light &light) {
     AI_ASE_PARSER_INIT();
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
-            if (TokenMatch(filePtr,"LIGHT_COLOR" ,11))
-            {
+            if (TokenMatch(filePtr, "LIGHT_COLOR", 11)) {
                 ParseLV4MeshFloatTriple(&light.mColor.r);
                 continue;
             }
-            if (TokenMatch(filePtr,"LIGHT_INTENS" ,12))
-            {
+            if (TokenMatch(filePtr, "LIGHT_INTENS", 12)) {
                 ParseLV4MeshFloat(light.mIntensity);
                 continue;
             }
-            if (TokenMatch(filePtr,"LIGHT_HOTSPOT" ,13))
-            {
+            if (TokenMatch(filePtr, "LIGHT_HOTSPOT", 13)) {
                 ParseLV4MeshFloat(light.mAngle);
                 continue;
             }
-            if (TokenMatch(filePtr,"LIGHT_FALLOFF" ,13))
-            {
+            if (TokenMatch(filePtr, "LIGHT_FALLOFF", 13)) {
                 ParseLV4MeshFloat(light.mFalloff);
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("2","LIGHT_SETTINGS");
+        AI_ASE_HANDLE_SECTION("2", "LIGHT_SETTINGS");
     }
-    return;
 }
 
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV2AnimationBlock(ASE::BaseNode& mesh)
-{
+void Parser::ParseLV2AnimationBlock(ASE::BaseNode &mesh) {
     AI_ASE_PARSER_INIT();
 
-    ASE::Animation* anim = &mesh.mAnim;
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    ASE::Animation *anim = &mesh.mAnim;
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
-            if (TokenMatch(filePtr,"NODE_NAME" ,9))
-            {
+            if (TokenMatch(filePtr, "NODE_NAME", 9)) {
                 std::string temp;
-                if(!ParseString(temp,"*NODE_NAME"))
+                if (!ParseString(temp, "*NODE_NAME"))
                     SkipToNextToken();
 
                 // If the name of the node contains .target it
                 // represents an animated camera or spot light
                 // target.
-                if (std::string::npos != temp.find(".Target"))
-                {
-                    if  ((mesh.mType != BaseNode::Camera || ((ASE::Camera&)mesh).mCameraType != ASE::Camera::TARGET)  &&
-                        ( mesh.mType != BaseNode::Light  || ((ASE::Light&)mesh).mLightType   != ASE::Light::TARGET))
-                    {
+                if (std::string::npos != temp.find(".Target")) {
+                    if ((mesh.mType != BaseNode::Camera || ((ASE::Camera &)mesh).mCameraType != ASE::Camera::TARGET) &&
+                            (mesh.mType != BaseNode::Light || ((ASE::Light &)mesh).mLightType != ASE::Light::TARGET)) {
 
                         ASSIMP_LOG_ERROR("ASE: Found target animation channel "
-                            "but the node is neither a camera nor a spot light");
-                        anim = NULL;
-                    }
-                    else anim = &mesh.mTargetAnim;
+                                         "but the node is neither a camera nor a spot light");
+                        anim = nullptr;
+                    } else
+                        anim = &mesh.mTargetAnim;
                 }
                 continue;
             }
 
             // position keyframes
-            if (TokenMatch(filePtr,"CONTROL_POS_TRACK"  ,17)  ||
-                TokenMatch(filePtr,"CONTROL_POS_BEZIER" ,18)  ||
-                TokenMatch(filePtr,"CONTROL_POS_TCB"    ,15))
-            {
-                if (!anim)SkipSection();
-                else ParseLV3PosAnimationBlock(*anim);
+            if (TokenMatch(filePtr, "CONTROL_POS_TRACK", 17) ||
+                    TokenMatch(filePtr, "CONTROL_POS_BEZIER", 18) ||
+                    TokenMatch(filePtr, "CONTROL_POS_TCB", 15)) {
+                if (!anim)
+                    SkipSection();
+                else
+                    ParseLV3PosAnimationBlock(*anim);
                 continue;
             }
             // scaling keyframes
-            if (TokenMatch(filePtr,"CONTROL_SCALE_TRACK"  ,19) ||
-                TokenMatch(filePtr,"CONTROL_SCALE_BEZIER" ,20) ||
-                TokenMatch(filePtr,"CONTROL_SCALE_TCB"    ,17))
-            {
-                if (!anim || anim == &mesh.mTargetAnim)
-                {
+            if (TokenMatch(filePtr, "CONTROL_SCALE_TRACK", 19) ||
+                    TokenMatch(filePtr, "CONTROL_SCALE_BEZIER", 20) ||
+                    TokenMatch(filePtr, "CONTROL_SCALE_TCB", 17)) {
+                if (!anim || anim == &mesh.mTargetAnim) {
                     // Target animation channels may have no rotation channels
                     ASSIMP_LOG_ERROR("ASE: Ignoring scaling channel in target animation");
                     SkipSection();
-                }
-                else ParseLV3ScaleAnimationBlock(*anim);
+                } else
+                    ParseLV3ScaleAnimationBlock(*anim);
                 continue;
             }
             // rotation keyframes
-            if (TokenMatch(filePtr,"CONTROL_ROT_TRACK"  ,17) ||
-                TokenMatch(filePtr,"CONTROL_ROT_BEZIER" ,18) ||
-                TokenMatch(filePtr,"CONTROL_ROT_TCB"    ,15))
-            {
-                if (!anim || anim == &mesh.mTargetAnim)
-                {
+            if (TokenMatch(filePtr, "CONTROL_ROT_TRACK", 17) ||
+                    TokenMatch(filePtr, "CONTROL_ROT_BEZIER", 18) ||
+                    TokenMatch(filePtr, "CONTROL_ROT_TCB", 15)) {
+                if (!anim || anim == &mesh.mTargetAnim) {
                     // Target animation channels may have no rotation channels
                     ASSIMP_LOG_ERROR("ASE: Ignoring rotation channel in target animation");
                     SkipSection();
-                }
-                else ParseLV3RotAnimationBlock(*anim);
+                } else
+                    ParseLV3RotAnimationBlock(*anim);
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("2","TM_ANIMATION");
+        AI_ASE_HANDLE_SECTION("2", "TM_ANIMATION");
     }
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV3ScaleAnimationBlock(ASE::Animation& anim)
-{
+void Parser::ParseLV3ScaleAnimationBlock(ASE::Animation &anim) {
     AI_ASE_PARSER_INIT();
     unsigned int iIndex;
 
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             bool b = false;
@@ -1139,44 +990,37 @@ void Parser::ParseLV3ScaleAnimationBlock(ASE::Animation& anim)
             // we ignore the additional information for bezier's and TCBs
 
             // simple scaling keyframe
-            if (TokenMatch(filePtr,"CONTROL_SCALE_SAMPLE" ,20))
-            {
+            if (TokenMatch(filePtr, "CONTROL_SCALE_SAMPLE", 20)) {
                 b = true;
                 anim.mScalingType = ASE::Animation::TRACK;
             }
 
             // Bezier scaling keyframe
-            if (TokenMatch(filePtr,"CONTROL_BEZIER_SCALE_KEY" ,24))
-            {
+            if (TokenMatch(filePtr, "CONTROL_BEZIER_SCALE_KEY", 24)) {
                 b = true;
                 anim.mScalingType = ASE::Animation::BEZIER;
             }
             // TCB scaling keyframe
-            if (TokenMatch(filePtr,"CONTROL_TCB_SCALE_KEY" ,21))
-            {
+            if (TokenMatch(filePtr, "CONTROL_TCB_SCALE_KEY", 21)) {
                 b = true;
                 anim.mScalingType = ASE::Animation::TCB;
             }
-            if (b)
-            {
+            if (b) {
                 anim.akeyScaling.push_back(aiVectorKey());
-                aiVectorKey& key = anim.akeyScaling.back();
-                ParseLV4MeshFloatTriple(&key.mValue.x,iIndex);
+                aiVectorKey &key = anim.akeyScaling.back();
+                ParseLV4MeshFloatTriple(&key.mValue.x, iIndex);
                 key.mTime = (double)iIndex;
             }
         }
-        AI_ASE_HANDLE_SECTION("3","*CONTROL_POS_TRACK");
+        AI_ASE_HANDLE_SECTION("3", "*CONTROL_POS_TRACK");
     }
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV3PosAnimationBlock(ASE::Animation& anim)
-{
+void Parser::ParseLV3PosAnimationBlock(ASE::Animation &anim) {
     AI_ASE_PARSER_INIT();
     unsigned int iIndex;
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             bool b = false;
@@ -1185,44 +1029,37 @@ void Parser::ParseLV3PosAnimationBlock(ASE::Animation& anim)
             // we ignore the additional information for bezier's and TCBs
 
             // simple scaling keyframe
-            if (TokenMatch(filePtr,"CONTROL_POS_SAMPLE" ,18))
-            {
+            if (TokenMatch(filePtr, "CONTROL_POS_SAMPLE", 18)) {
                 b = true;
                 anim.mPositionType = ASE::Animation::TRACK;
             }
 
             // Bezier scaling keyframe
-            if (TokenMatch(filePtr,"CONTROL_BEZIER_POS_KEY" ,22))
-            {
+            if (TokenMatch(filePtr, "CONTROL_BEZIER_POS_KEY", 22)) {
                 b = true;
                 anim.mPositionType = ASE::Animation::BEZIER;
             }
             // TCB scaling keyframe
-            if (TokenMatch(filePtr,"CONTROL_TCB_POS_KEY" ,19))
-            {
+            if (TokenMatch(filePtr, "CONTROL_TCB_POS_KEY", 19)) {
                 b = true;
                 anim.mPositionType = ASE::Animation::TCB;
             }
-            if (b)
-            {
+            if (b) {
                 anim.akeyPositions.push_back(aiVectorKey());
-                aiVectorKey& key = anim.akeyPositions.back();
-                ParseLV4MeshFloatTriple(&key.mValue.x,iIndex);
+                aiVectorKey &key = anim.akeyPositions.back();
+                ParseLV4MeshFloatTriple(&key.mValue.x, iIndex);
                 key.mTime = (double)iIndex;
             }
         }
-        AI_ASE_HANDLE_SECTION("3","*CONTROL_POS_TRACK");
+        AI_ASE_HANDLE_SECTION("3", "*CONTROL_POS_TRACK");
     }
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV3RotAnimationBlock(ASE::Animation& anim)
-{
+void Parser::ParseLV3RotAnimationBlock(ASE::Animation &anim) {
     AI_ASE_PARSER_INIT();
     unsigned int iIndex;
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             bool b = false;
@@ -1231,150 +1068,126 @@ void Parser::ParseLV3RotAnimationBlock(ASE::Animation& anim)
             // we ignore the additional information for bezier's and TCBs
 
             // simple scaling keyframe
-            if (TokenMatch(filePtr,"CONTROL_ROT_SAMPLE" ,18))
-            {
+            if (TokenMatch(filePtr, "CONTROL_ROT_SAMPLE", 18)) {
                 b = true;
                 anim.mRotationType = ASE::Animation::TRACK;
             }
 
             // Bezier scaling keyframe
-            if (TokenMatch(filePtr,"CONTROL_BEZIER_ROT_KEY" ,22))
-            {
+            if (TokenMatch(filePtr, "CONTROL_BEZIER_ROT_KEY", 22)) {
                 b = true;
                 anim.mRotationType = ASE::Animation::BEZIER;
             }
             // TCB scaling keyframe
-            if (TokenMatch(filePtr,"CONTROL_TCB_ROT_KEY" ,19))
-            {
+            if (TokenMatch(filePtr, "CONTROL_TCB_ROT_KEY", 19)) {
                 b = true;
                 anim.mRotationType = ASE::Animation::TCB;
             }
-            if (b)
-            {
+            if (b) {
                 anim.akeyRotations.push_back(aiQuatKey());
-                aiQuatKey& key = anim.akeyRotations.back();
-                aiVector3D v;ai_real f;
-                ParseLV4MeshFloatTriple(&v.x,iIndex);
+                aiQuatKey &key = anim.akeyRotations.back();
+                aiVector3D v;
+                ai_real f;
+                ParseLV4MeshFloatTriple(&v.x, iIndex);
                 ParseLV4MeshFloat(f);
                 key.mTime = (double)iIndex;
-                key.mValue = aiQuaternion(v,f);
+                key.mValue = aiQuaternion(v, f);
             }
         }
-        AI_ASE_HANDLE_SECTION("3","*CONTROL_ROT_TRACK");
+        AI_ASE_HANDLE_SECTION("3", "*CONTROL_ROT_TRACK");
     }
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV2NodeTransformBlock(ASE::BaseNode& mesh)
-{
+void Parser::ParseLV2NodeTransformBlock(ASE::BaseNode &mesh) {
     AI_ASE_PARSER_INIT();
-    int mode   = 0;
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    int mode = 0;
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
             // name of the node
-            if (TokenMatch(filePtr,"NODE_NAME" ,9))
-            {
+            if (TokenMatch(filePtr, "NODE_NAME", 9)) {
                 std::string temp;
-                if(!ParseString(temp,"*NODE_NAME"))
+                if (!ParseString(temp, "*NODE_NAME"))
                     SkipToNextToken();
 
                 std::string::size_type s;
-                if (temp == mesh.mName)
-                {
+                if (temp == mesh.mName) {
                     mode = 1;
-                }
-                else if (std::string::npos != (s = temp.find(".Target")) &&
-                    mesh.mName == temp.substr(0,s))
-                {
+                } else if (std::string::npos != (s = temp.find(".Target")) &&
+                           mesh.mName == temp.substr(0, s)) {
                     // This should be either a target light or a target camera
-                    if ( (mesh.mType == BaseNode::Light &&  ((ASE::Light&)mesh) .mLightType  == ASE::Light::TARGET) ||
-                         (mesh.mType == BaseNode::Camera && ((ASE::Camera&)mesh).mCameraType == ASE::Camera::TARGET))
-                    {
+                    if ((mesh.mType == BaseNode::Light && ((ASE::Light &)mesh).mLightType == ASE::Light::TARGET) ||
+                            (mesh.mType == BaseNode::Camera && ((ASE::Camera &)mesh).mCameraType == ASE::Camera::TARGET)) {
                         mode = 2;
-                    }
-                    else {
+                    } else {
                         ASSIMP_LOG_ERROR("ASE: Ignoring target transform, "
-                            "this is no spot light or target camera");
+                                         "this is no spot light or target camera");
                     }
-                }
-                else
-                {
-                    ASSIMP_LOG_ERROR("ASE: Unknown node transformation: " + temp);
+                } else {
+                    ASSIMP_LOG_ERROR("ASE: Unknown node transformation: ", temp);
                     // mode = 0
                 }
                 continue;
             }
-            if (mode)
-            {
+            if (mode) {
                 // fourth row of the transformation matrix - and also the
                 // only information here that is interesting for targets
-                if (TokenMatch(filePtr,"TM_ROW3" ,7))
-                {
+                if (TokenMatch(filePtr, "TM_ROW3", 7)) {
                     ParseLV4MeshFloatTriple((mode == 1 ? mesh.mTransform[3] : &mesh.mTargetPosition.x));
                     continue;
                 }
-                if (mode == 1)
-                {
+                if (mode == 1) {
                     // first row of the transformation matrix
-                    if (TokenMatch(filePtr,"TM_ROW0" ,7))
-                    {
+                    if (TokenMatch(filePtr, "TM_ROW0", 7)) {
                         ParseLV4MeshFloatTriple(mesh.mTransform[0]);
                         continue;
                     }
                     // second row of the transformation matrix
-                    if (TokenMatch(filePtr,"TM_ROW1" ,7))
-                    {
+                    if (TokenMatch(filePtr, "TM_ROW1", 7)) {
                         ParseLV4MeshFloatTriple(mesh.mTransform[1]);
                         continue;
                     }
                     // third row of the transformation matrix
-                    if (TokenMatch(filePtr,"TM_ROW2" ,7))
-                    {
+                    if (TokenMatch(filePtr, "TM_ROW2", 7)) {
                         ParseLV4MeshFloatTriple(mesh.mTransform[2]);
                         continue;
                     }
                     // inherited position axes
-                    if (TokenMatch(filePtr,"INHERIT_POS" ,11))
-                    {
+                    if (TokenMatch(filePtr, "INHERIT_POS", 11)) {
                         unsigned int aiVal[3];
                         ParseLV4MeshLongTriple(aiVal);
 
-                        for (unsigned int i = 0; i < 3;++i)
+                        for (unsigned int i = 0; i < 3; ++i)
                             mesh.inherit.abInheritPosition[i] = aiVal[i] != 0;
                         continue;
                     }
                     // inherited rotation axes
-                    if (TokenMatch(filePtr,"INHERIT_ROT" ,11))
-                    {
+                    if (TokenMatch(filePtr, "INHERIT_ROT", 11)) {
                         unsigned int aiVal[3];
                         ParseLV4MeshLongTriple(aiVal);
 
-                        for (unsigned int i = 0; i < 3;++i)
+                        for (unsigned int i = 0; i < 3; ++i)
                             mesh.inherit.abInheritRotation[i] = aiVal[i] != 0;
                         continue;
                     }
                     // inherited scaling axes
-                    if (TokenMatch(filePtr,"INHERIT_SCL" ,11))
-                    {
+                    if (TokenMatch(filePtr, "INHERIT_SCL", 11)) {
                         unsigned int aiVal[3];
                         ParseLV4MeshLongTriple(aiVal);
 
-                        for (unsigned int i = 0; i < 3;++i)
+                        for (unsigned int i = 0; i < 3; ++i)
                             mesh.inherit.abInheritScaling[i] = aiVal[i] != 0;
                         continue;
                     }
                 }
             }
         }
-        AI_ASE_HANDLE_SECTION("2","*NODE_TM");
+        AI_ASE_HANDLE_SECTION("2", "*NODE_TM");
     }
     return;
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV2MeshBlock(ASE::Mesh& mesh)
-{
+void Parser::ParseLV2MeshBlock(ASE::Mesh &mesh) {
     AI_ASE_PARSER_INIT();
 
     unsigned int iNumVertices = 0;
@@ -1383,386 +1196,327 @@ void Parser::ParseLV2MeshBlock(ASE::Mesh& mesh)
     unsigned int iNumTFaces = 0;
     unsigned int iNumCVertices = 0;
     unsigned int iNumCFaces = 0;
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
             // Number of vertices in the mesh
-            if (TokenMatch(filePtr,"MESH_NUMVERTEX" ,14))
-            {
+            if (TokenMatch(filePtr, "MESH_NUMVERTEX", 14)) {
                 ParseLV4MeshLong(iNumVertices);
                 continue;
             }
             // Number of texture coordinates in the mesh
-            if (TokenMatch(filePtr,"MESH_NUMTVERTEX" ,15))
-            {
+            if (TokenMatch(filePtr, "MESH_NUMTVERTEX", 15)) {
                 ParseLV4MeshLong(iNumTVertices);
                 continue;
             }
             // Number of vertex colors in the mesh
-            if (TokenMatch(filePtr,"MESH_NUMCVERTEX" ,15))
-            {
+            if (TokenMatch(filePtr, "MESH_NUMCVERTEX", 15)) {
                 ParseLV4MeshLong(iNumCVertices);
                 continue;
             }
             // Number of regular faces in the mesh
-            if (TokenMatch(filePtr,"MESH_NUMFACES" ,13))
-            {
+            if (TokenMatch(filePtr, "MESH_NUMFACES", 13)) {
                 ParseLV4MeshLong(iNumFaces);
                 continue;
             }
             // Number of UVWed faces in the mesh
-            if (TokenMatch(filePtr,"MESH_NUMTVFACES" ,15))
-            {
+            if (TokenMatch(filePtr, "MESH_NUMTVFACES", 15)) {
                 ParseLV4MeshLong(iNumTFaces);
                 continue;
             }
             // Number of colored faces in the mesh
-            if (TokenMatch(filePtr,"MESH_NUMCVFACES" ,15))
-            {
+            if (TokenMatch(filePtr, "MESH_NUMCVFACES", 15)) {
                 ParseLV4MeshLong(iNumCFaces);
                 continue;
             }
             // mesh vertex list block
-            if (TokenMatch(filePtr,"MESH_VERTEX_LIST" ,16))
-            {
-                ParseLV3MeshVertexListBlock(iNumVertices,mesh);
+            if (TokenMatch(filePtr, "MESH_VERTEX_LIST", 16)) {
+                ParseLV3MeshVertexListBlock(iNumVertices, mesh);
                 continue;
             }
             // mesh face list block
-            if (TokenMatch(filePtr,"MESH_FACE_LIST" ,14))
-            {
-                ParseLV3MeshFaceListBlock(iNumFaces,mesh);
+            if (TokenMatch(filePtr, "MESH_FACE_LIST", 14)) {
+                ParseLV3MeshFaceListBlock(iNumFaces, mesh);
                 continue;
             }
             // mesh texture vertex list block
-            if (TokenMatch(filePtr,"MESH_TVERTLIST" ,14))
-            {
-                ParseLV3MeshTListBlock(iNumTVertices,mesh);
+            if (TokenMatch(filePtr, "MESH_TVERTLIST", 14)) {
+                ParseLV3MeshTListBlock(iNumTVertices, mesh);
                 continue;
             }
             // mesh texture face block
-            if (TokenMatch(filePtr,"MESH_TFACELIST" ,14))
-            {
-                ParseLV3MeshTFaceListBlock(iNumTFaces,mesh);
+            if (TokenMatch(filePtr, "MESH_TFACELIST", 14)) {
+                ParseLV3MeshTFaceListBlock(iNumTFaces, mesh);
                 continue;
             }
             // mesh color vertex list block
-            if (TokenMatch(filePtr,"MESH_CVERTLIST" ,14))
-            {
-                ParseLV3MeshCListBlock(iNumCVertices,mesh);
+            if (TokenMatch(filePtr, "MESH_CVERTLIST", 14)) {
+                ParseLV3MeshCListBlock(iNumCVertices, mesh);
                 continue;
             }
             // mesh color face block
-            if (TokenMatch(filePtr,"MESH_CFACELIST" ,14))
-            {
-                ParseLV3MeshCFaceListBlock(iNumCFaces,mesh);
+            if (TokenMatch(filePtr, "MESH_CFACELIST", 14)) {
+                ParseLV3MeshCFaceListBlock(iNumCFaces, mesh);
                 continue;
             }
             // mesh normals
-            if (TokenMatch(filePtr,"MESH_NORMALS" ,12))
-            {
+            if (TokenMatch(filePtr, "MESH_NORMALS", 12)) {
                 ParseLV3MeshNormalListBlock(mesh);
                 continue;
             }
             // another mesh UV channel ...
-            if (TokenMatch(filePtr,"MESH_MAPPINGCHANNEL" ,19)) {
-                unsigned int iIndex( 0 );
+            if (TokenMatch(filePtr, "MESH_MAPPINGCHANNEL", 19)) {
+                unsigned int iIndex(0);
                 ParseLV4MeshLong(iIndex);
-                if ( 0 == iIndex ) {
-                    LogWarning( "Mapping channel has an invalid index. Skipping UV channel" );
+                if (0 == iIndex) {
+                    LogWarning("Mapping channel has an invalid index. Skipping UV channel");
                     // skip it ...
                     SkipSection();
                 } else {
-                    if ( iIndex < 2 ) {
-                        LogWarning( "Mapping channel has an invalid index. Skipping UV channel" );
+                    if (iIndex < 2) {
+                        LogWarning("Mapping channel has an invalid index. Skipping UV channel");
                         // skip it ...
                         SkipSection();
                     }
-                    if ( iIndex > AI_MAX_NUMBER_OF_TEXTURECOORDS ) {
-                        LogWarning( "Too many UV channels specified. Skipping channel .." );
+                    if (iIndex > AI_MAX_NUMBER_OF_TEXTURECOORDS) {
+                        LogWarning("Too many UV channels specified. Skipping channel ..");
                         // skip it ...
                         SkipSection();
                     } else {
                         // parse the mapping channel
-                        ParseLV3MappingChannel( iIndex - 1, mesh );
+                        ParseLV3MappingChannel(iIndex - 1, mesh);
                     }
                     continue;
                 }
             }
             // mesh animation keyframe. Not supported
-            if (TokenMatch(filePtr,"MESH_ANIMATION" ,14))
-            {
+            if (TokenMatch(filePtr, "MESH_ANIMATION", 14)) {
 
                 LogWarning("Found *MESH_ANIMATION element in ASE/ASK file. "
-                    "Keyframe animation is not supported by Assimp, this element "
-                    "will be ignored");
+                           "Keyframe animation is not supported by Assimp, this element "
+                           "will be ignored");
                 //SkipSection();
                 continue;
             }
-            if (TokenMatch(filePtr,"MESH_WEIGHTS" ,12))
-            {
-                ParseLV3MeshWeightsBlock(mesh);continue;
+            if (TokenMatch(filePtr, "MESH_WEIGHTS", 12)) {
+                ParseLV3MeshWeightsBlock(mesh);
+                continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("2","*MESH");
+        AI_ASE_HANDLE_SECTION("2", "*MESH");
     }
     return;
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV3MeshWeightsBlock(ASE::Mesh& mesh)
-{
+void Parser::ParseLV3MeshWeightsBlock(ASE::Mesh &mesh) {
     AI_ASE_PARSER_INIT();
 
     unsigned int iNumVertices = 0, iNumBones = 0;
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             // Number of bone vertices ...
-            if (TokenMatch(filePtr,"MESH_NUMVERTEX" ,14))
-            {
+            if (TokenMatch(filePtr, "MESH_NUMVERTEX", 14)) {
                 ParseLV4MeshLong(iNumVertices);
                 continue;
             }
             // Number of bones
-            if (TokenMatch(filePtr,"MESH_NUMBONE" ,12))
-            {
+            if (TokenMatch(filePtr, "MESH_NUMBONE", 12)) {
                 ParseLV4MeshLong(iNumBones);
                 continue;
             }
             // parse the list of bones
-            if (TokenMatch(filePtr,"MESH_BONE_LIST" ,14))
-            {
-                ParseLV4MeshBones(iNumBones,mesh);
+            if (TokenMatch(filePtr, "MESH_BONE_LIST", 14)) {
+                ParseLV4MeshBones(iNumBones, mesh);
                 continue;
             }
             // parse the list of bones vertices
-            if (TokenMatch(filePtr,"MESH_BONE_VERTEX_LIST" ,21) )
-            {
-                ParseLV4MeshBonesVertices(iNumVertices,mesh);
+            if (TokenMatch(filePtr, "MESH_BONE_VERTEX_LIST", 21)) {
+                ParseLV4MeshBonesVertices(iNumVertices, mesh);
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("3","*MESH_WEIGHTS");
+        AI_ASE_HANDLE_SECTION("3", "*MESH_WEIGHTS");
     }
     return;
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV4MeshBones(unsigned int iNumBones,ASE::Mesh& mesh)
-{
+void Parser::ParseLV4MeshBones(unsigned int iNumBones, ASE::Mesh &mesh) {
     AI_ASE_PARSER_INIT();
     mesh.mBones.resize(iNumBones, Bone("UNNAMED"));
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             // Mesh bone with name ...
-            if (TokenMatch(filePtr,"MESH_BONE_NAME" ,14))
-            {
+            if (TokenMatch(filePtr, "MESH_BONE_NAME", 14)) {
                 // parse an index ...
-                if(SkipSpaces(&filePtr))
-                {
-                    unsigned int iIndex = strtoul10(filePtr,&filePtr);
-                    if (iIndex >= iNumBones)
-                    {
+                if (SkipSpaces(&filePtr)) {
+                    unsigned int iIndex = strtoul10(filePtr, &filePtr);
+                    if (iIndex >= iNumBones) {
                         LogWarning("Bone index is out of bounds");
                         continue;
                     }
-                    if (!ParseString(mesh.mBones[iIndex].mName,"*MESH_BONE_NAME"))
+                    if (!ParseString(mesh.mBones[iIndex].mName, "*MESH_BONE_NAME"))
                         SkipToNextToken();
                     continue;
                 }
             }
         }
-        AI_ASE_HANDLE_SECTION("3","*MESH_BONE_LIST");
+        AI_ASE_HANDLE_SECTION("3", "*MESH_BONE_LIST");
     }
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV4MeshBonesVertices(unsigned int iNumVertices,ASE::Mesh& mesh)
-{
+void Parser::ParseLV4MeshBonesVertices(unsigned int iNumVertices, ASE::Mesh &mesh) {
     AI_ASE_PARSER_INIT();
     mesh.mBoneVertices.resize(iNumVertices);
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             // Mesh bone vertex
-            if (TokenMatch(filePtr,"MESH_BONE_VERTEX" ,16))
-            {
+            if (TokenMatch(filePtr, "MESH_BONE_VERTEX", 16)) {
                 // read the vertex index
-                unsigned int iIndex = strtoul10(filePtr,&filePtr);
-                if (iIndex >= mesh.mPositions.size())
-                {
-                    iIndex = (unsigned int)mesh.mPositions.size()-1;
+                unsigned int iIndex = strtoul10(filePtr, &filePtr);
+                if (iIndex >= mesh.mPositions.size()) {
+                    iIndex = (unsigned int)mesh.mPositions.size() - 1;
                     LogWarning("Bone vertex index is out of bounds. Using the largest valid "
-                        "bone vertex index instead");
+                               "bone vertex index instead");
                 }
 
                 // --- ignored
                 ai_real afVert[3];
                 ParseLV4MeshFloatTriple(afVert);
 
-                std::pair<int,float> pairOut;
-                while (true)
-                {
+                std::pair<int, float> pairOut;
+                while (true) {
                     // first parse the bone index ...
-                    if (!SkipSpaces(&filePtr))break;
-                    pairOut.first = strtoul10(filePtr,&filePtr);
+                    if (!SkipSpaces(&filePtr)) break;
+                    pairOut.first = strtoul10(filePtr, &filePtr);
 
                     // then parse the vertex weight
-                    if (!SkipSpaces(&filePtr))break;
-                    filePtr = fast_atoreal_move<float>(filePtr,pairOut.second);
+                    if (!SkipSpaces(&filePtr)) break;
+                    filePtr = fast_atoreal_move<float>(filePtr, pairOut.second);
 
                     // -1 marks unused entries
-                    if (-1 != pairOut.first)
-                    {
+                    if (-1 != pairOut.first) {
                         mesh.mBoneVertices[iIndex].mBoneWeights.push_back(pairOut);
                     }
                 }
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("4","*MESH_BONE_VERTEX");
+        AI_ASE_HANDLE_SECTION("4", "*MESH_BONE_VERTEX");
     }
     return;
 }
 // ------------------------------------------------------------------------------------------------
 void Parser::ParseLV3MeshVertexListBlock(
-    unsigned int iNumVertices, ASE::Mesh& mesh)
-{
+        unsigned int iNumVertices, ASE::Mesh &mesh) {
     AI_ASE_PARSER_INIT();
 
     // allocate enough storage in the array
     mesh.mPositions.resize(iNumVertices);
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             // Vertex entry
-            if (TokenMatch(filePtr,"MESH_VERTEX" ,11))
-            {
+            if (TokenMatch(filePtr, "MESH_VERTEX", 11)) {
 
                 aiVector3D vTemp;
                 unsigned int iIndex;
-                ParseLV4MeshFloatTriple(&vTemp.x,iIndex);
+                ParseLV4MeshFloatTriple(&vTemp.x, iIndex);
 
-                if (iIndex >= iNumVertices)
-                {
+                if (iIndex >= iNumVertices) {
                     LogWarning("Invalid vertex index. It will be ignored");
-                }
-                else mesh.mPositions[iIndex] = vTemp;
+                } else
+                    mesh.mPositions[iIndex] = vTemp;
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("3","*MESH_VERTEX_LIST");
+        AI_ASE_HANDLE_SECTION("3", "*MESH_VERTEX_LIST");
     }
     return;
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV3MeshFaceListBlock(unsigned int iNumFaces, ASE::Mesh& mesh)
-{
+void Parser::ParseLV3MeshFaceListBlock(unsigned int iNumFaces, ASE::Mesh &mesh) {
     AI_ASE_PARSER_INIT();
 
     // allocate enough storage in the face array
     mesh.mFaces.resize(iNumFaces);
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             // Face entry
-            if (TokenMatch(filePtr,"MESH_FACE" ,9))
-            {
+            if (TokenMatch(filePtr, "MESH_FACE", 9)) {
 
                 ASE::Face mFace;
                 ParseLV4MeshFace(mFace);
 
-                if (mFace.iFace >= iNumFaces)
-                {
+                if (mFace.iFace >= iNumFaces) {
                     LogWarning("Face has an invalid index. It will be ignored");
-                }
-                else mesh.mFaces[mFace.iFace] = mFace;
+                } else
+                    mesh.mFaces[mFace.iFace] = mFace;
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("3","*MESH_FACE_LIST");
+        AI_ASE_HANDLE_SECTION("3", "*MESH_FACE_LIST");
     }
     return;
 }
 // ------------------------------------------------------------------------------------------------
 void Parser::ParseLV3MeshTListBlock(unsigned int iNumVertices,
-    ASE::Mesh& mesh, unsigned int iChannel)
-{
+        ASE::Mesh &mesh, unsigned int iChannel) {
     AI_ASE_PARSER_INIT();
 
     // allocate enough storage in the array
     mesh.amTexCoords[iChannel].resize(iNumVertices);
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             // Vertex entry
-            if (TokenMatch(filePtr,"MESH_TVERT" ,10))
-            {
+            if (TokenMatch(filePtr, "MESH_TVERT", 10)) {
                 aiVector3D vTemp;
                 unsigned int iIndex;
-                ParseLV4MeshFloatTriple(&vTemp.x,iIndex);
+                ParseLV4MeshFloatTriple(&vTemp.x, iIndex);
 
-                if (iIndex >= iNumVertices)
-                {
+                if (iIndex >= iNumVertices) {
                     LogWarning("Tvertex has an invalid index. It will be ignored");
-                }
-                else mesh.amTexCoords[iChannel][iIndex] = vTemp;
+                } else
+                    mesh.amTexCoords[iChannel][iIndex] = vTemp;
 
-                if (0.0f != vTemp.z)
-                {
+                if (0.0f != vTemp.z) {
                     // we need 3 coordinate channels
                     mesh.mNumUVComponents[iChannel] = 3;
                 }
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("3","*MESH_TVERT_LIST");
+        AI_ASE_HANDLE_SECTION("3", "*MESH_TVERT_LIST");
     }
     return;
 }
 // ------------------------------------------------------------------------------------------------
 void Parser::ParseLV3MeshTFaceListBlock(unsigned int iNumFaces,
-    ASE::Mesh& mesh, unsigned int iChannel)
-{
+        ASE::Mesh &mesh, unsigned int iChannel) {
     AI_ASE_PARSER_INIT();
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             // Face entry
-            if (TokenMatch(filePtr,"MESH_TFACE" ,10))
-            {
+            if (TokenMatch(filePtr, "MESH_TFACE", 10)) {
                 unsigned int aiValues[3];
                 unsigned int iIndex = 0;
 
-                ParseLV4MeshLongTriple(aiValues,iIndex);
-                if (iIndex >= iNumFaces || iIndex >= mesh.mFaces.size())
-                {
+                ParseLV4MeshLongTriple(aiValues, iIndex);
+                if (iIndex >= iNumFaces || iIndex >= mesh.mFaces.size()) {
                     LogWarning("UV-Face has an invalid index. It will be ignored");
-                }
-                else
-                {
+                } else {
                     // copy UV indices
                     mesh.mFaces[iIndex].amUVIndices[iChannel][0] = aiValues[0];
                     mesh.mFaces[iIndex].amUVIndices[iChannel][1] = aiValues[1];
@@ -1771,108 +1525,89 @@ void Parser::ParseLV3MeshTFaceListBlock(unsigned int iNumFaces,
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("3","*MESH_TFACE_LIST");
+        AI_ASE_HANDLE_SECTION("3", "*MESH_TFACE_LIST");
     }
     return;
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV3MappingChannel(unsigned int iChannel, ASE::Mesh& mesh)
-{
+void Parser::ParseLV3MappingChannel(unsigned int iChannel, ASE::Mesh &mesh) {
     AI_ASE_PARSER_INIT();
 
     unsigned int iNumTVertices = 0;
     unsigned int iNumTFaces = 0;
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             // Number of texture coordinates in the mesh
-            if (TokenMatch(filePtr,"MESH_NUMTVERTEX" ,15))
-            {
+            if (TokenMatch(filePtr, "MESH_NUMTVERTEX", 15)) {
                 ParseLV4MeshLong(iNumTVertices);
                 continue;
             }
             // Number of UVWed faces in the mesh
-            if (TokenMatch(filePtr,"MESH_NUMTVFACES" ,15))
-            {
+            if (TokenMatch(filePtr, "MESH_NUMTVFACES", 15)) {
                 ParseLV4MeshLong(iNumTFaces);
                 continue;
             }
             // mesh texture vertex list block
-            if (TokenMatch(filePtr,"MESH_TVERTLIST" ,14))
-            {
-                ParseLV3MeshTListBlock(iNumTVertices,mesh,iChannel);
+            if (TokenMatch(filePtr, "MESH_TVERTLIST", 14)) {
+                ParseLV3MeshTListBlock(iNumTVertices, mesh, iChannel);
                 continue;
             }
             // mesh texture face block
-            if (TokenMatch(filePtr,"MESH_TFACELIST" ,14))
-            {
-                ParseLV3MeshTFaceListBlock(iNumTFaces,mesh, iChannel);
+            if (TokenMatch(filePtr, "MESH_TFACELIST", 14)) {
+                ParseLV3MeshTFaceListBlock(iNumTFaces, mesh, iChannel);
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("3","*MESH_MAPPING_CHANNEL");
+        AI_ASE_HANDLE_SECTION("3", "*MESH_MAPPING_CHANNEL");
     }
     return;
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV3MeshCListBlock(unsigned int iNumVertices, ASE::Mesh& mesh)
-{
+void Parser::ParseLV3MeshCListBlock(unsigned int iNumVertices, ASE::Mesh &mesh) {
     AI_ASE_PARSER_INIT();
 
     // allocate enough storage in the array
     mesh.mVertexColors.resize(iNumVertices);
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             // Vertex entry
-            if (TokenMatch(filePtr,"MESH_VERTCOL" ,12))
-            {
+            if (TokenMatch(filePtr, "MESH_VERTCOL", 12)) {
                 aiColor4D vTemp;
                 vTemp.a = 1.0f;
                 unsigned int iIndex;
-                ParseLV4MeshFloatTriple(&vTemp.r,iIndex);
+                ParseLV4MeshFloatTriple(&vTemp.r, iIndex);
 
-                if (iIndex >= iNumVertices)
-                {
+                if (iIndex >= iNumVertices) {
                     LogWarning("Vertex color has an invalid index. It will be ignored");
-                }
-                else mesh.mVertexColors[iIndex] = vTemp;
+                } else
+                    mesh.mVertexColors[iIndex] = vTemp;
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("3","*MESH_CVERTEX_LIST");
+        AI_ASE_HANDLE_SECTION("3", "*MESH_CVERTEX_LIST");
     }
     return;
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV3MeshCFaceListBlock(unsigned int iNumFaces, ASE::Mesh& mesh)
-{
+void Parser::ParseLV3MeshCFaceListBlock(unsigned int iNumFaces, ASE::Mesh &mesh) {
     AI_ASE_PARSER_INIT();
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             // Face entry
-            if (TokenMatch(filePtr,"MESH_CFACE" ,10))
-            {
+            if (TokenMatch(filePtr, "MESH_CFACE", 10)) {
                 unsigned int aiValues[3];
                 unsigned int iIndex = 0;
 
-                ParseLV4MeshLongTriple(aiValues,iIndex);
-                if (iIndex >= iNumFaces || iIndex >= mesh.mFaces.size())
-                {
+                ParseLV4MeshLongTriple(aiValues, iIndex);
+                if (iIndex >= iNumFaces || iIndex >= mesh.mFaces.size()) {
                     LogWarning("UV-Face has an invalid index. It will be ignored");
-                }
-                else
-                {
+                } else {
                     // copy color indices
                     mesh.mFaces[iIndex].mColorIndices[0] = aiValues[0];
                     mesh.mFaces[iIndex].mColorIndices[1] = aiValues[1];
@@ -1881,17 +1616,16 @@ void Parser::ParseLV3MeshCFaceListBlock(unsigned int iNumFaces, ASE::Mesh& mesh)
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("3","*MESH_CFACE_LIST");
+        AI_ASE_HANDLE_SECTION("3", "*MESH_CFACE_LIST");
     }
     return;
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV3MeshNormalListBlock(ASE::Mesh& sMesh)
-{
+void Parser::ParseLV3MeshNormalListBlock(ASE::Mesh &sMesh) {
     AI_ASE_PARSER_INIT();
 
     // Allocate enough storage for the normals
-    sMesh.mNormals.resize(sMesh.mFaces.size()*3,aiVector3D( 0.f, 0.f, 0.f ));
+    sMesh.mNormals.resize(sMesh.mFaces.size() * 3, aiVector3D(0.f, 0.f, 0.f));
     unsigned int index, faceIdx = UINT_MAX;
 
     // FIXME: rewrite this and find out how to interpret the normals
@@ -1899,34 +1633,34 @@ void Parser::ParseLV3MeshNormalListBlock(ASE::Mesh& sMesh)
 
     // Smooth the vertex and face normals together. The result
     // will be edgy then, but otherwise everything would be soft ...
-    while (true)    {
-        if ('*' == *filePtr)    {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
-            if (faceIdx != UINT_MAX && TokenMatch(filePtr,"MESH_VERTEXNORMAL",17))  {
+            if (faceIdx != UINT_MAX && TokenMatch(filePtr, "MESH_VERTEXNORMAL", 17)) {
                 aiVector3D vNormal;
-                ParseLV4MeshFloatTriple(&vNormal.x,index);
-                if (faceIdx >=  sMesh.mFaces.size())
+                ParseLV4MeshFloatTriple(&vNormal.x, index);
+                if (faceIdx >= sMesh.mFaces.size())
                     continue;
 
                 // Make sure we assign it to the correct face
-                const ASE::Face& face = sMesh.mFaces[faceIdx];
+                const ASE::Face &face = sMesh.mFaces[faceIdx];
                 if (index == face.mIndices[0])
                     index = 0;
                 else if (index == face.mIndices[1])
                     index = 1;
                 else if (index == face.mIndices[2])
                     index = 2;
-                else    {
+                else {
                     ASSIMP_LOG_ERROR("ASE: Invalid vertex index in MESH_VERTEXNORMAL section");
                     continue;
                 }
                 // We'll renormalize later
-                sMesh.mNormals[faceIdx*3+index] += vNormal;
+                sMesh.mNormals[faceIdx * 3 + index] += vNormal;
                 continue;
             }
-            if (TokenMatch(filePtr,"MESH_FACENORMAL",15))   {
+            if (TokenMatch(filePtr, "MESH_FACENORMAL", 15)) {
                 aiVector3D vNormal;
-                ParseLV4MeshFloatTriple(&vNormal.x,faceIdx);
+                ParseLV4MeshFloatTriple(&vNormal.x, faceIdx);
 
                 if (faceIdx >= sMesh.mFaces.size()) {
                     ASSIMP_LOG_ERROR("ASE: Invalid vertex index in MESH_FACENORMAL section");
@@ -1934,53 +1668,47 @@ void Parser::ParseLV3MeshNormalListBlock(ASE::Mesh& sMesh)
                 }
 
                 // We'll renormalize later
-                sMesh.mNormals[faceIdx*3] += vNormal;
-                sMesh.mNormals[faceIdx*3+1] += vNormal;
-                sMesh.mNormals[faceIdx*3+2] += vNormal;
+                sMesh.mNormals[faceIdx * 3] += vNormal;
+                sMesh.mNormals[faceIdx * 3 + 1] += vNormal;
+                sMesh.mNormals[faceIdx * 3 + 2] += vNormal;
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("3","*MESH_NORMALS");
+        AI_ASE_HANDLE_SECTION("3", "*MESH_NORMALS");
     }
     return;
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV4MeshFace(ASE::Face& out)
-{
+void Parser::ParseLV4MeshFace(ASE::Face &out) {
     // skip spaces and tabs
-    if(!SkipSpaces(&filePtr))
-    {
+    if (!SkipSpaces(&filePtr)) {
         LogWarning("Unable to parse *MESH_FACE Element: Unexpected EOL [#1]");
         SkipToNextToken();
         return;
     }
 
     // parse the face index
-    out.iFace = strtoul10(filePtr,&filePtr);
+    out.iFace = strtoul10(filePtr, &filePtr);
 
     // next character should be ':'
-    if(!SkipSpaces(&filePtr))
-    {
+    if (!SkipSpaces(&filePtr)) {
         // FIX: there are some ASE files which haven't got : here ....
         LogWarning("Unable to parse *MESH_FACE Element: Unexpected EOL. \':\' expected [#2]");
         SkipToNextToken();
         return;
     }
     // FIX: There are some ASE files which haven't got ':' here
-    if(':' == *filePtr)++filePtr;
+    if (':' == *filePtr) ++filePtr;
 
     // Parse all mesh indices
-    for (unsigned int i = 0; i < 3;++i)
-    {
+    for (unsigned int i = 0; i < 3; ++i) {
         unsigned int iIndex = 0;
-        if(!SkipSpaces(&filePtr))
-        {
+        if (!SkipSpaces(&filePtr)) {
             LogWarning("Unable to parse *MESH_FACE Element: Unexpected EOL");
             SkipToNextToken();
             return;
         }
-        switch (*filePtr)
-        {
+        switch (*filePtr) {
         case 'A':
         case 'a':
             break;
@@ -1994,38 +1722,34 @@ void Parser::ParseLV4MeshFace(ASE::Face& out)
             break;
         default:
             LogWarning("Unable to parse *MESH_FACE Element: Unexpected EOL. "
-                "A,B or C expected [#3]");
+                       "A,B or C expected [#3]");
             SkipToNextToken();
             return;
         };
         ++filePtr;
 
         // next character should be ':'
-        if(!SkipSpaces(&filePtr) || ':' != *filePtr)
-        {
+        if (!SkipSpaces(&filePtr) || ':' != *filePtr) {
             LogWarning("Unable to parse *MESH_FACE Element: "
-                "Unexpected EOL. \':\' expected [#2]");
+                       "Unexpected EOL. \':\' expected [#2]");
             SkipToNextToken();
             return;
         }
 
         ++filePtr;
-        if(!SkipSpaces(&filePtr))
-        {
+        if (!SkipSpaces(&filePtr)) {
             LogWarning("Unable to parse *MESH_FACE Element: Unexpected EOL. "
-                "Vertex index ecpected [#4]");
+                       "Vertex index ecpected [#4]");
             SkipToNextToken();
             return;
         }
-        out.mIndices[iIndex] = strtoul10(filePtr,&filePtr);
+        out.mIndices[iIndex] = strtoul10(filePtr, &filePtr);
     }
 
     // now we need to skip the AB, BC, CA blocks.
-    while (true)
-    {
-        if ('*' == *filePtr)break;
-        if (IsLineEnd(*filePtr))
-        {
+    while (true) {
+        if ('*' == *filePtr) break;
+        if (IsLineEnd(*filePtr)) {
             //iLineNumber++;
             return;
         }
@@ -2033,27 +1757,22 @@ void Parser::ParseLV4MeshFace(ASE::Face& out)
     }
 
     // parse the smoothing group of the face
-    if (TokenMatch(filePtr,"*MESH_SMOOTHING",15))
-    {
-        if(!SkipSpaces(&filePtr))
-        {
+    if (TokenMatch(filePtr, "*MESH_SMOOTHING", 15)) {
+        if (!SkipSpaces(&filePtr)) {
             LogWarning("Unable to parse *MESH_SMOOTHING Element: "
-                "Unexpected EOL. Smoothing group(s) expected [#5]");
+                       "Unexpected EOL. Smoothing group(s) expected [#5]");
             SkipToNextToken();
             return;
         }
 
         // Parse smoothing groups until we don't anymore see commas
         // FIX: There needn't always be a value, sad but true
-        while (true)
-        {
-            if (*filePtr < '9' && *filePtr >= '0')
-            {
-                out.iSmoothGroup |= (1 << strtoul10(filePtr,&filePtr));
+        while (true) {
+            if (*filePtr < '9' && *filePtr >= '0') {
+                out.iSmoothGroup |= (1 << strtoul10(filePtr, &filePtr));
             }
             SkipSpaces(&filePtr);
-            if (',' != *filePtr)
-            {
+            if (',' != *filePtr) {
                 break;
             }
             ++filePtr;
@@ -2062,41 +1781,37 @@ void Parser::ParseLV4MeshFace(ASE::Face& out)
     }
 
     // *MESH_MTLID  is optional, too
-    while (true)
-    {
-        if ('*' == *filePtr)break;
-        if (IsLineEnd(*filePtr))
-        {
+    while (true) {
+        if ('*' == *filePtr) {
+            break;
+        }
+        if (IsLineEnd(*filePtr)) {
             return;
         }
         filePtr++;
     }
 
-    if (TokenMatch(filePtr,"*MESH_MTLID",11))
-    {
-        if(!SkipSpaces(&filePtr))
-        {
+    if (TokenMatch(filePtr, "*MESH_MTLID", 11)) {
+        if (!SkipSpaces(&filePtr)) {
             LogWarning("Unable to parse *MESH_MTLID Element: Unexpected EOL. "
-                "Material index expected [#6]");
+                       "Material index expected [#6]");
             SkipToNextToken();
             return;
         }
-        out.iMaterial = strtoul10(filePtr,&filePtr);
+        out.iMaterial = strtoul10(filePtr, &filePtr);
     }
     return;
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV4MeshLongTriple(unsigned int* apOut)
-{
-    ai_assert(NULL != apOut);
+void Parser::ParseLV4MeshLongTriple(unsigned int *apOut) {
+    ai_assert(nullptr != apOut);
 
-    for (unsigned int i = 0; i < 3;++i)
+    for (unsigned int i = 0; i < 3; ++i)
         ParseLV4MeshLong(apOut[i]);
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV4MeshLongTriple(unsigned int* apOut, unsigned int& rIndexOut)
-{
-    ai_assert(NULL != apOut);
+void Parser::ParseLV4MeshLongTriple(unsigned int *apOut, unsigned int &rIndexOut) {
+    ai_assert(nullptr != apOut);
 
     // parse the index
     ParseLV4MeshLong(rIndexOut);
@@ -2105,9 +1820,8 @@ void Parser::ParseLV4MeshLongTriple(unsigned int* apOut, unsigned int& rIndexOut
     ParseLV4MeshLongTriple(apOut);
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV4MeshFloatTriple(ai_real* apOut, unsigned int& rIndexOut)
-{
-    ai_assert(NULL != apOut);
+void Parser::ParseLV4MeshFloatTriple(ai_real *apOut, unsigned int &rIndexOut) {
+    ai_assert(nullptr != apOut);
 
     // parse the index
     ParseLV4MeshLong(rIndexOut);
@@ -2116,19 +1830,17 @@ void Parser::ParseLV4MeshFloatTriple(ai_real* apOut, unsigned int& rIndexOut)
     ParseLV4MeshFloatTriple(apOut);
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV4MeshFloatTriple(ai_real* apOut)
-{
-    ai_assert(NULL != apOut);
+void Parser::ParseLV4MeshFloatTriple(ai_real *apOut) {
+    ai_assert(nullptr != apOut);
 
-    for (unsigned int i = 0; i < 3;++i)
+    for (unsigned int i = 0; i < 3; ++i) {
         ParseLV4MeshFloat(apOut[i]);
+    }
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV4MeshFloat(ai_real& fOut)
-{
+void Parser::ParseLV4MeshFloat(ai_real &fOut) {
     // skip spaces and tabs
-    if(!SkipSpaces(&filePtr))
-    {
+    if (!SkipSpaces(&filePtr)) {
         // LOG
         LogWarning("Unable to parse float: unexpected EOL [#1]");
         fOut = 0.0;
@@ -2136,14 +1848,12 @@ void Parser::ParseLV4MeshFloat(ai_real& fOut)
         return;
     }
     // parse the first float
-    filePtr = fast_atoreal_move<ai_real>(filePtr,fOut);
+    filePtr = fast_atoreal_move<ai_real>(filePtr, fOut);
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV4MeshLong(unsigned int& iOut)
-{
+void Parser::ParseLV4MeshLong(unsigned int &iOut) {
     // Skip spaces and tabs
-    if(!SkipSpaces(&filePtr))
-    {
+    if (!SkipSpaces(&filePtr)) {
         // LOG
         LogWarning("Unable to parse long: unexpected EOL [#1]");
         iOut = 0;
@@ -2151,7 +1861,7 @@ void Parser::ParseLV4MeshLong(unsigned int& iOut)
         return;
     }
     // parse the value
-    iOut = strtoul10(filePtr,&filePtr);
+    iOut = strtoul10(filePtr, &filePtr);
 }
 
 #endif // ASSIMP_BUILD_NO_3DS_IMPORTER
diff --git a/Engine/lib/assimp/code/ASE/ASEParser.h b/Engine/lib/assimp/code/AssetLib/ASE/ASEParser.h
similarity index 81%
rename from Engine/lib/assimp/code/ASE/ASEParser.h
rename to Engine/lib/assimp/code/AssetLib/ASE/ASEParser.h
index 988cbda8d..5c24fffd1 100644
--- a/Engine/lib/assimp/code/ASE/ASEParser.h
+++ b/Engine/lib/assimp/code/AssetLib/ASE/ASEParser.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -40,15 +40,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
-
 /** @file Defines the helper data structures for importing ASE files  */
 #ifndef AI_ASEFILEHELPER_H_INC
 #define AI_ASEFILEHELPER_H_INC
 
 // public ASSIMP headers
-#include <assimp/types.h>
-#include <assimp/mesh.h>
 #include <assimp/anim.h>
+#include <assimp/mesh.h>
+#include <assimp/types.h>
 
 #ifndef ASSIMP_BUILD_NO_3DS_IMPORTER
 
@@ -57,68 +56,73 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/qnan.h>
 
 // ASE is quite similar to 3ds. We can reuse some structures
-#include "3DS/3DSLoader.h"
+#include "AssetLib/3DS/3DSLoader.h"
 
-namespace Assimp    {
-namespace ASE   {
+namespace Assimp {
+namespace ASE {
 
 using namespace D3DS;
 
 // ---------------------------------------------------------------------------
 /** Helper structure representing an ASE material */
-struct Material : public D3DS::Material
-{
+struct Material : public D3DS::Material {
     //! Default constructor has been deleted
     Material() = delete;
 
     //! Constructor with explicit name
-    explicit Material(const std::string &name)
-    : D3DS::Material(name)
-    , pcInstance(NULL)
-    , bNeed (false) {
+    explicit Material(const std::string &name) :
+            D3DS::Material(name),
+            pcInstance(nullptr),
+            bNeed(false) {
         // empty
     }
 
-    Material(const Material &other)            = default;
-    Material &operator=(const Material &other) = default;
+    Material(const Material &other) = default;
 
+    Material &operator=(const Material &other) {
+        if (this == &other) {
+            return *this;
+        }
+
+        avSubMaterials = other.avSubMaterials;
+        pcInstance = other.pcInstance;
+        bNeed = other.bNeed;
+
+        return *this;
+    }
 
     //! Move constructor. This is explicitly written because MSVC doesn't support defaulting it
     Material(Material &&other) AI_NO_EXCEPT
-    : D3DS::Material(std::move(other))
-    , avSubMaterials(std::move(other.avSubMaterials))
-    , pcInstance(std::move(other.pcInstance))
-    , bNeed(std::move(other.bNeed))
-    {
+            : D3DS::Material(std::move(other)),
+              avSubMaterials(std::move(other.avSubMaterials)),
+              pcInstance(other.pcInstance),
+              bNeed(other.bNeed) {
         other.pcInstance = nullptr;
     }
 
-
     Material &operator=(Material &&other) AI_NO_EXCEPT {
         if (this == &other) {
             return *this;
         }
 
-        D3DS::Material::operator=(std::move(other));
+        //D3DS::Material::operator=(std::move(other));
 
         avSubMaterials = std::move(other.avSubMaterials);
-        pcInstance = std::move(other.pcInstance);
-        bNeed = std::move(other.bNeed);
+        pcInstance = other.pcInstance;
+        bNeed = other.bNeed;
 
         other.pcInstance = nullptr;
 
         return *this;
     }
 
-
     ~Material() {}
 
-
     //! Contains all sub materials of this material
     std::vector<Material> avSubMaterials;
 
     //! aiMaterial object
-    aiMaterial* pcInstance;
+    aiMaterial *pcInstance;
 
     //! Can we remove this material?
     bool bNeed;
@@ -129,8 +133,8 @@ struct Material : public D3DS::Material
 struct Face : public FaceWithSmoothingGroup {
     //! Default constructor. Initializes everything with 0
     Face() AI_NO_EXCEPT
-    : iMaterial(DEFAULT_MATINDEX)
-    , iFace(0) {
+            : iMaterial(DEFAULT_MATINDEX),
+              iFace(0) {
         // empty
     }
 
@@ -161,8 +165,8 @@ struct Bone {
     Bone() = delete;
 
     //! Construction from an existing name
-    explicit Bone( const std::string& name)
-    : mName(name) {
+    explicit Bone(const std::string &name) :
+            mName(name) {
         // empty
     }
 
@@ -175,33 +179,34 @@ struct Bone {
 struct BoneVertex {
     //! Bone and corresponding vertex weight.
     //! -1 for unrequired bones ....
-    std::vector<std::pair<int,float> > mBoneWeights;
+    std::vector<std::pair<int, float>> mBoneWeights;
 };
 
 // ---------------------------------------------------------------------------
 /** Helper structure to represent an ASE file animation */
 struct Animation {
     enum Type {
-        TRACK   = 0x0,
-        BEZIER  = 0x1,
-        TCB     = 0x2
-    } mRotationType, mScalingType, mPositionType;
+        TRACK = 0x0,
+        BEZIER = 0x1,
+        TCB = 0x2
+    } mRotationType,
+            mScalingType, mPositionType;
 
     Animation() AI_NO_EXCEPT
-    :   mRotationType   (TRACK)
-    ,   mScalingType    (TRACK)
-    ,   mPositionType   (TRACK) {
+            : mRotationType(TRACK),
+              mScalingType(TRACK),
+              mPositionType(TRACK) {
         // empty
     }
 
     //! List of track rotation keyframes
-    std::vector< aiQuatKey > akeyRotations;
+    std::vector<aiQuatKey> akeyRotations;
 
     //! List of track position keyframes
-    std::vector< aiVectorKey > akeyPositions;
+    std::vector<aiVectorKey> akeyPositions;
 
     //! List of track scaling keyframes
-    std::vector< aiVectorKey > akeyScaling;
+    std::vector<aiVectorKey> akeyScaling;
 };
 
 // ---------------------------------------------------------------------------
@@ -209,7 +214,7 @@ struct Animation {
 struct InheritanceInfo {
     //! Default constructor
     InheritanceInfo() AI_NO_EXCEPT {
-        for ( size_t i=0; i<3; ++i ) {
+        for (size_t i = 0; i < 3; ++i) {
             abInheritPosition[i] = abInheritRotation[i] = abInheritScaling[i] = true;
         }
     }
@@ -228,17 +233,15 @@ struct InheritanceInfo {
 /** Represents an ASE file node. Base class for mesh, light and cameras */
 struct BaseNode {
     enum Type {
-        Light, 
-        Camera, 
-        Mesh, 
+        Light,
+        Camera,
+        Mesh,
         Dummy
     } mType;
 
     //! Construction from an existing name
-    BaseNode(Type _mType, const std::string &name)
-    : mType         (_mType)
-    , mName         (name)
-    , mProcessed    (false) {
+    BaseNode(Type _mType, const std::string &name) :
+            mType(_mType), mName(name), mProcessed(false) {
         // Set mTargetPosition to qnan
         const ai_real qnan = get_qnan();
         mTargetPosition.x = qnan;
@@ -278,14 +281,9 @@ struct Mesh : public MeshWithSmoothingGroups<ASE::Face>, public BaseNode {
     Mesh() = delete;
 
     //! Construction from an existing name
-    explicit Mesh(const std::string &name)
-    : BaseNode( BaseNode::Mesh, name )
-    , mVertexColors()
-    , mBoneVertices()
-    , mBones()
-    , iMaterialIndex(Face::DEFAULT_MATINDEX)
-    , bSkip     (false) {
-        for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS;++c) {
+    explicit Mesh(const std::string &name) :
+            BaseNode(BaseNode::Mesh, name), mVertexColors(), mBoneVertices(), mBones(), iMaterialIndex(Face::DEFAULT_MATINDEX), bSkip(false) {
+        for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++c) {
             this->mNumUVComponents[c] = 2;
         }
     }
@@ -314,10 +312,8 @@ struct Mesh : public MeshWithSmoothingGroups<ASE::Face>, public BaseNode {
 
 // ---------------------------------------------------------------------------
 /** Helper structure to represent an ASE light source */
-struct Light : public BaseNode
-{
-    enum LightType
-    {
+struct Light : public BaseNode {
+    enum LightType {
         OMNI,
         TARGET,
         FREE,
@@ -328,17 +324,13 @@ struct Light : public BaseNode
     Light() = delete;
 
     //! Construction from an existing name
-    explicit Light(const std::string &name)
-    : BaseNode   (BaseNode::Light, name)
-    , mLightType (OMNI)
-    , mColor     (1.f,1.f,1.f)
-    , mIntensity (1.f) // light is white by default
-    , mAngle     (45.f)
-    , mFalloff   (0.f)
-    {
+    explicit Light(const std::string &name) :
+            BaseNode(BaseNode::Light, name), mLightType(OMNI), mColor(1.f, 1.f, 1.f), mIntensity(1.f) // light is white by default
+            ,
+            mAngle(45.f),
+            mFalloff(0.f) {
     }
 
-
     LightType mLightType;
     aiColor3D mColor;
     ai_real mIntensity;
@@ -348,10 +340,8 @@ struct Light : public BaseNode
 
 // ---------------------------------------------------------------------------
 /** Helper structure to represent an ASE camera */
-struct Camera : public BaseNode
-{
-    enum CameraType
-    {
+struct Camera : public BaseNode {
+    enum CameraType {
         FREE,
         TARGET
     };
@@ -359,18 +349,16 @@ struct Camera : public BaseNode
     //! Default constructor has been deleted
     Camera() = delete;
 
-
     //! Construction from an existing name
-    explicit Camera(const std::string &name)
-    : BaseNode    (BaseNode::Camera, name)
-    , mFOV        (0.75f)   // in radians
-    , mNear       (0.1f)
-    , mFar        (1000.f)  // could be zero
-    , mCameraType (FREE)
-    {
+    explicit Camera(const std::string &name) :
+            BaseNode(BaseNode::Camera, name), mFOV(0.75f) // in radians
+            ,
+            mNear(0.1f),
+            mFar(1000.f) // could be zero
+            ,
+            mCameraType(FREE) {
     }
 
-
     ai_real mFOV, mNear, mFar;
     CameraType mCameraType;
 };
@@ -380,7 +368,7 @@ struct Camera : public BaseNode
 struct Dummy : public BaseNode {
     //! Constructor
     Dummy() AI_NO_EXCEPT
-    : BaseNode  (BaseNode::Dummy, "DUMMY") {
+            : BaseNode(BaseNode::Dummy, "DUMMY") {
         // empty
     }
 };
@@ -403,7 +391,6 @@ private:
     }
 
 public:
-
     // -------------------------------------------------------------------
     //! Construct a parser from a given input file which is
     //! guaranteed to be terminated with zero.
@@ -411,15 +398,13 @@ public:
     //! @param fileFormatDefault Assumed file format version. If the
     //!   file format is specified in the file the new value replaces
     //!   the default value.
-    Parser (const char* szFile, unsigned int fileFormatDefault);
+    Parser(const char *szFile, unsigned int fileFormatDefault);
 
     // -------------------------------------------------------------------
     //! Parses the file into the parsers internal representation
     void Parse();
 
-
 private:
-
     // -------------------------------------------------------------------
     //! Parse the *SCENE block in a file
     void ParseLV1SceneBlock();
@@ -435,45 +420,45 @@ private:
     // -------------------------------------------------------------------
     //! Parse a *<xxx>OBJECT block in a file
     //! \param mesh Node to be filled
-    void ParseLV1ObjectBlock(BaseNode& mesh);
+    void ParseLV1ObjectBlock(BaseNode &mesh);
 
     // -------------------------------------------------------------------
     //! Parse a *MATERIAL blocks in a material list
     //! \param mat Material structure to be filled
-    void ParseLV2MaterialBlock(Material& mat);
+    void ParseLV2MaterialBlock(Material &mat);
 
     // -------------------------------------------------------------------
     //! Parse a *NODE_TM block in a file
     //! \param mesh Node (!) object to be filled
-    void ParseLV2NodeTransformBlock(BaseNode& mesh);
+    void ParseLV2NodeTransformBlock(BaseNode &mesh);
 
     // -------------------------------------------------------------------
     //! Parse a *TM_ANIMATION block in a file
     //! \param mesh Mesh object to be filled
-    void ParseLV2AnimationBlock(BaseNode& mesh);
-    void ParseLV3PosAnimationBlock(ASE::Animation& anim);
-    void ParseLV3ScaleAnimationBlock(ASE::Animation& anim);
-    void ParseLV3RotAnimationBlock(ASE::Animation& anim);
+    void ParseLV2AnimationBlock(BaseNode &mesh);
+    void ParseLV3PosAnimationBlock(ASE::Animation &anim);
+    void ParseLV3ScaleAnimationBlock(ASE::Animation &anim);
+    void ParseLV3RotAnimationBlock(ASE::Animation &anim);
 
     // -------------------------------------------------------------------
     //! Parse a *MESH block in a file
     //! \param mesh Mesh object to be filled
-    void ParseLV2MeshBlock(Mesh& mesh);
+    void ParseLV2MeshBlock(Mesh &mesh);
 
     // -------------------------------------------------------------------
     //! Parse a *LIGHT_SETTINGS block in a file
     //! \param light Light object to be filled
-    void ParseLV2LightSettingsBlock(Light& light);
+    void ParseLV2LightSettingsBlock(Light &light);
 
     // -------------------------------------------------------------------
     //! Parse a *CAMERA_SETTINGS block in a file
     //! \param cam Camera object to be filled
-    void ParseLV2CameraSettingsBlock(Camera& cam);
+    void ParseLV2CameraSettingsBlock(Camera &cam);
 
     // -------------------------------------------------------------------
     //! Parse the *MAP_XXXXXX blocks in a material
     //! \param map Texture structure to be filled
-    void ParseLV3MapBlock(Texture& map);
+    void ParseLV3MapBlock(Texture &map);
 
     // -------------------------------------------------------------------
     //! Parse a *MESH_VERTEX_LIST block in a file
@@ -482,7 +467,7 @@ private:
     //! A warning is sent to the logger if the validations fails.
     //! \param mesh Mesh object to be filled
     void ParseLV3MeshVertexListBlock(
-        unsigned int iNumVertices,Mesh& mesh);
+            unsigned int iNumVertices, Mesh &mesh);
 
     // -------------------------------------------------------------------
     //! Parse a *MESH_FACE_LIST block in a file
@@ -491,7 +476,7 @@ private:
     //! A warning is sent to the logger if the validations fails.
     //! \param mesh Mesh object to be filled
     void ParseLV3MeshFaceListBlock(
-        unsigned int iNumFaces,Mesh& mesh);
+            unsigned int iNumFaces, Mesh &mesh);
 
     // -------------------------------------------------------------------
     //! Parse a *MESH_TVERT_LIST block in a file
@@ -501,7 +486,7 @@ private:
     //! \param mesh Mesh object to be filled
     //! \param iChannel Output UVW channel
     void ParseLV3MeshTListBlock(
-        unsigned int iNumVertices,Mesh& mesh, unsigned int iChannel = 0);
+            unsigned int iNumVertices, Mesh &mesh, unsigned int iChannel = 0);
 
     // -------------------------------------------------------------------
     //! Parse a *MESH_TFACELIST block in a file
@@ -511,7 +496,7 @@ private:
     //! \param mesh Mesh object to be filled
     //! \param iChannel Output UVW channel
     void ParseLV3MeshTFaceListBlock(
-        unsigned int iNumFaces,Mesh& mesh, unsigned int iChannel = 0);
+            unsigned int iNumFaces, Mesh &mesh, unsigned int iChannel = 0);
 
     // -------------------------------------------------------------------
     //! Parse an additional mapping channel
@@ -519,7 +504,7 @@ private:
     //! \param iChannel Channel index to be filled
     //! \param mesh Mesh object to be filled
     void ParseLV3MappingChannel(
-        unsigned int iChannel, Mesh& mesh);
+            unsigned int iChannel, Mesh &mesh);
 
     // -------------------------------------------------------------------
     //! Parse a *MESH_CVERTLIST block in a file
@@ -528,7 +513,7 @@ private:
     //! A warning is sent to the logger if the validations fails.
     //! \param mesh Mesh object to be filled
     void ParseLV3MeshCListBlock(
-        unsigned int iNumVertices, Mesh& mesh);
+            unsigned int iNumVertices, Mesh &mesh);
 
     // -------------------------------------------------------------------
     //! Parse a *MESH_CFACELIST block in a file
@@ -537,70 +522,70 @@ private:
     //! A warning is sent to the logger if the validations fails.
     //! \param mesh Mesh object to be filled
     void ParseLV3MeshCFaceListBlock(
-        unsigned int iNumFaces, Mesh& mesh);
+            unsigned int iNumFaces, Mesh &mesh);
 
     // -------------------------------------------------------------------
     //! Parse a *MESH_NORMALS block in a file
     //! \param mesh Mesh object to be filled
-    void ParseLV3MeshNormalListBlock(Mesh& mesh);
+    void ParseLV3MeshNormalListBlock(Mesh &mesh);
 
     // -------------------------------------------------------------------
     //! Parse a *MESH_WEIGHTSblock in a file
     //! \param mesh Mesh object to be filled
-    void ParseLV3MeshWeightsBlock(Mesh& mesh);
+    void ParseLV3MeshWeightsBlock(Mesh &mesh);
 
     // -------------------------------------------------------------------
     //! Parse the bone list of a file
     //! \param mesh Mesh object to be filled
     //! \param iNumBones Number of bones in the mesh
-    void ParseLV4MeshBones(unsigned int iNumBones,Mesh& mesh);
+    void ParseLV4MeshBones(unsigned int iNumBones, Mesh &mesh);
 
     // -------------------------------------------------------------------
     //! Parse the bone vertices list of a file
     //! \param mesh Mesh object to be filled
     //! \param iNumVertices Number of vertices to be parsed
-    void ParseLV4MeshBonesVertices(unsigned int iNumVertices,Mesh& mesh);
+    void ParseLV4MeshBonesVertices(unsigned int iNumVertices, Mesh &mesh);
 
     // -------------------------------------------------------------------
     //! Parse a *MESH_FACE block in a file
     //! \param out receive the face data
-    void ParseLV4MeshFace(ASE::Face& out);
+    void ParseLV4MeshFace(ASE::Face &out);
 
     // -------------------------------------------------------------------
     //! Parse a *MESH_VERT block in a file
     //! (also works for MESH_TVERT, MESH_CFACE, MESH_VERTCOL  ...)
     //! \param apOut Output buffer (3 floats)
     //! \param rIndexOut Output index
-    void ParseLV4MeshFloatTriple(ai_real* apOut, unsigned int& rIndexOut);
+    void ParseLV4MeshFloatTriple(ai_real *apOut, unsigned int &rIndexOut);
 
     // -------------------------------------------------------------------
     //! Parse a *MESH_VERT block in a file
     //! (also works for MESH_TVERT, MESH_CFACE, MESH_VERTCOL  ...)
     //! \param apOut Output buffer (3 floats)
-    void ParseLV4MeshFloatTriple(ai_real* apOut);
+    void ParseLV4MeshFloatTriple(ai_real *apOut);
 
     // -------------------------------------------------------------------
     //! Parse a *MESH_TFACE block in a file
     //! (also works for MESH_CFACE)
     //! \param apOut Output buffer (3 ints)
     //! \param rIndexOut Output index
-    void ParseLV4MeshLongTriple(unsigned int* apOut, unsigned int& rIndexOut);
+    void ParseLV4MeshLongTriple(unsigned int *apOut, unsigned int &rIndexOut);
 
     // -------------------------------------------------------------------
     //! Parse a *MESH_TFACE block in a file
     //! (also works for MESH_CFACE)
     //! \param apOut Output buffer (3 ints)
-    void ParseLV4MeshLongTriple(unsigned int* apOut);
+    void ParseLV4MeshLongTriple(unsigned int *apOut);
 
     // -------------------------------------------------------------------
     //! Parse a single float element
     //! \param fOut Output float
-    void ParseLV4MeshFloat(ai_real& fOut);
+    void ParseLV4MeshFloat(ai_real &fOut);
 
     // -------------------------------------------------------------------
     //! Parse a single int element
     //! \param iOut Output integer
-    void ParseLV4MeshLong(unsigned int& iOut);
+    void ParseLV4MeshLong(unsigned int &iOut);
 
     // -------------------------------------------------------------------
     //! Skip everything to the next: '*' or '\0'
@@ -614,17 +599,17 @@ private:
     // -------------------------------------------------------------------
     //! Output a warning to the logger
     //! \param szWarn Warn message
-    void LogWarning(const char* szWarn);
+    void LogWarning(const char *szWarn);
 
     // -------------------------------------------------------------------
     //! Output a message to the logger
     //! \param szWarn Message
-    void LogInfo(const char* szWarn);
+    void LogInfo(const char *szWarn);
 
     // -------------------------------------------------------------------
     //! Output an error to the logger
     //! \param szWarn Error message
-    AI_WONT_RETURN void LogError(const char* szWarn) AI_WONT_RETURN_SUFFIX;
+    AI_WONT_RETURN void LogError(const char *szWarn) AI_WONT_RETURN_SUFFIX;
 
     // -------------------------------------------------------------------
     //! Parse a string, enclosed in double quotation marks
@@ -632,12 +617,11 @@ private:
     //! \param szName Name of the enclosing element -> used in error
     //! messages.
     //! \return false if an error occurred
-    bool ParseString(std::string& out,const char* szName);
+    bool ParseString(std::string &out, const char *szName);
 
 public:
-
     //! Pointer to current data
-    const char* filePtr;
+    const char *filePtr;
 
     //! background color to be passed to the viewer
     //! QNAN if none was found
@@ -684,9 +668,8 @@ public:
     unsigned int iFileFormat;
 };
 
-
 } // Namespace ASE
-} // Namespace ASSIMP
+} // namespace Assimp
 
 #endif // ASSIMP_BUILD_NO_3DS_IMPORTER
 
diff --git a/Engine/lib/assimp/code/AssetLib/Assbin/AssbinExporter.cpp b/Engine/lib/assimp/code/AssetLib/Assbin/AssbinExporter.cpp
new file mode 100644
index 000000000..149b3c5f3
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Assbin/AssbinExporter.cpp
@@ -0,0 +1,68 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+/** @file  AssbinExporter.cpp
+ *  ASSBIN exporter main code
+ */
+
+#ifndef ASSIMP_BUILD_NO_EXPORT
+#ifndef ASSIMP_BUILD_NO_ASSBIN_EXPORTER
+
+#include "AssbinFileWriter.h"
+
+#include <assimp/scene.h>
+#include <assimp/Exporter.hpp>
+#include <assimp/IOSystem.hpp>
+
+namespace Assimp {
+
+void ExportSceneAssbin(const char *pFile, IOSystem *pIOSystem, const aiScene *pScene, const ExportProperties * /*pProperties*/) {
+    DumpSceneToAssbin(
+            pFile,
+            "\0", // no command(s).
+            pIOSystem,
+            pScene,
+            false, // shortened?
+            false); // compressed?
+}
+} // end of namespace Assimp
+
+#endif // ASSIMP_BUILD_NO_ASSBIN_EXPORTER
+#endif // ASSIMP_BUILD_NO_EXPORT
diff --git a/Engine/lib/assimp/code/Assbin/AssbinExporter.h b/Engine/lib/assimp/code/AssetLib/Assbin/AssbinExporter.h
similarity index 95%
rename from Engine/lib/assimp/code/Assbin/AssbinExporter.h
rename to Engine/lib/assimp/code/AssetLib/Assbin/AssbinExporter.h
index 3e13639bb..1801c1680 100644
--- a/Engine/lib/assimp/code/Assbin/AssbinExporter.h
+++ b/Engine/lib/assimp/code/AssetLib/Assbin/AssbinExporter.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,16 +42,19 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file AssbinExporter.h
  * ASSBIN Exporter Main Header
  */
+#pragma once
 #ifndef AI_ASSBINEXPORTER_H_INC
 #define AI_ASSBINEXPORTER_H_INC
 
 #include <assimp/defs.h>
 
+#ifndef ASSIMP_BUILD_NO_EXPORT
+
 // nothing really needed here - reserved for future use like properties
 namespace Assimp {
 
 void ASSIMP_API ExportSceneAssbin(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/);
 
 }
-
+#endif 
 #endif // AI_ASSBINEXPORTER_H_INC
diff --git a/Engine/lib/assimp/code/AssetLib/Assbin/AssbinFileWriter.cpp b/Engine/lib/assimp/code/AssetLib/Assbin/AssbinFileWriter.cpp
new file mode 100644
index 000000000..1d16f179e
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Assbin/AssbinFileWriter.cpp
@@ -0,0 +1,833 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+/** @file  AssbinFileWriter.cpp
+ *  @brief Implementation of Assbin file writer.
+ */
+
+#include "AssbinFileWriter.h"
+#include "Common/assbin_chunks.h"
+#include "PostProcessing/ProcessHelper.h"
+
+#include <assimp/Exceptional.h>
+#include <assimp/version.h>
+#include <assimp/IOStream.hpp>
+
+#ifdef ASSIMP_BUILD_NO_OWN_ZLIB
+#include <zlib.h>
+#else
+#include "../contrib/zlib/zlib.h"
+#endif
+
+#include <ctime>
+
+#if _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4706)
+#endif // _MSC_VER
+
+namespace Assimp {
+
+template <typename T>
+size_t Write(IOStream *stream, const T &v) {
+    return stream->Write(&v, sizeof(T), 1);
+}
+
+// -----------------------------------------------------------------------------------
+// Serialize an aiString
+template <>
+inline size_t Write<aiString>(IOStream *stream, const aiString &s) {
+    const size_t s2 = (uint32_t)s.length;
+    stream->Write(&s, 4, 1);
+    stream->Write(s.data, s2, 1);
+
+    return s2 + 4;
+}
+
+// -----------------------------------------------------------------------------------
+// Serialize an unsigned int as uint32_t
+template <>
+inline size_t Write<unsigned int>(IOStream *stream, const unsigned int &w) {
+    const uint32_t t = (uint32_t)w;
+    if (w > t) {
+        // this shouldn't happen, integers in Assimp data structures never exceed 2^32
+        throw DeadlyExportError("loss of data due to 64 -> 32 bit integer conversion");
+    }
+
+    stream->Write(&t, 4, 1);
+
+    return 4;
+}
+
+// -----------------------------------------------------------------------------------
+// Serialize an unsigned int as uint16_t
+template <>
+inline size_t Write<uint16_t>(IOStream *stream, const uint16_t &w) {
+    static_assert(sizeof(uint16_t) == 2, "sizeof(uint16_t)==2");
+    stream->Write(&w, 2, 1);
+
+    return 2;
+}
+
+// -----------------------------------------------------------------------------------
+// Serialize a float
+template <>
+inline size_t Write<float>(IOStream *stream, const float &f) {
+    static_assert(sizeof(float) == 4, "sizeof(float)==4");
+    stream->Write(&f, 4, 1);
+
+    return 4;
+}
+
+// -----------------------------------------------------------------------------------
+// Serialize a double
+template <>
+inline size_t Write<double>(IOStream *stream, const double &f) {
+    static_assert(sizeof(double) == 8, "sizeof(double)==8");
+    stream->Write(&f, 8, 1);
+
+    return 8;
+}
+
+// -----------------------------------------------------------------------------------
+// Serialize a vec3
+template <>
+inline size_t Write<aiVector3D>(IOStream *stream, const aiVector3D &v) {
+    size_t t = Write<float>(stream, v.x);
+    t += Write<float>(stream, v.y);
+    t += Write<float>(stream, v.z);
+
+    return t;
+}
+
+// -----------------------------------------------------------------------------------
+// Serialize a color value
+template <>
+inline size_t Write<aiColor3D>(IOStream *stream, const aiColor3D &v) {
+    size_t t = Write<float>(stream, v.r);
+    t += Write<float>(stream, v.g);
+    t += Write<float>(stream, v.b);
+
+    return t;
+}
+
+// -----------------------------------------------------------------------------------
+// Serialize a color value
+template <>
+inline size_t Write<aiColor4D>(IOStream *stream, const aiColor4D &v) {
+    size_t t = Write<float>(stream, v.r);
+    t += Write<float>(stream, v.g);
+    t += Write<float>(stream, v.b);
+    t += Write<float>(stream, v.a);
+
+    return t;
+}
+
+// -----------------------------------------------------------------------------------
+// Serialize a quaternion
+template <>
+inline size_t Write<aiQuaternion>(IOStream *stream, const aiQuaternion &v) {
+    size_t t = Write<float>(stream, v.w);
+    t += Write<float>(stream, v.x);
+    t += Write<float>(stream, v.y);
+    t += Write<float>(stream, v.z);
+    ai_assert(t == 16);
+
+    return t;
+}
+
+// -----------------------------------------------------------------------------------
+// Serialize a vertex weight
+template <>
+inline size_t Write<aiVertexWeight>(IOStream *stream, const aiVertexWeight &v) {
+    size_t t = Write<unsigned int>(stream, v.mVertexId);
+
+    return t + Write<float>(stream, v.mWeight);
+}
+
+constexpr size_t MatrixSize = 64;
+
+// -----------------------------------------------------------------------------------
+// Serialize a mat4x4
+template <>
+inline size_t Write<aiMatrix4x4>(IOStream *stream, const aiMatrix4x4 &m) {
+    for (unsigned int i = 0; i < 4; ++i) {
+        for (unsigned int i2 = 0; i2 < 4; ++i2) {
+            Write<float>(stream, m[i][i2]);
+        }
+    }
+
+    return MatrixSize;
+}
+
+// -----------------------------------------------------------------------------------
+// Serialize an aiVectorKey
+template <>
+inline size_t Write<aiVectorKey>(IOStream *stream, const aiVectorKey &v) {
+    const size_t t = Write<double>(stream, v.mTime);
+    return t + Write<aiVector3D>(stream, v.mValue);
+}
+
+// -----------------------------------------------------------------------------------
+// Serialize an aiQuatKey
+template <>
+inline size_t Write<aiQuatKey>(IOStream *stream, const aiQuatKey &v) {
+    const size_t t = Write<double>(stream, v.mTime);
+    return t + Write<aiQuaternion>(stream, v.mValue);
+}
+
+template <typename T>
+inline size_t WriteBounds(IOStream *stream, const T *in, unsigned int size) {
+    T minc, maxc;
+    ArrayBounds(in, size, minc, maxc);
+
+    const size_t t = Write<T>(stream, minc);
+    return t + Write<T>(stream, maxc);
+}
+
+// We use this to write out non-byte arrays so that we write using the specializations.
+// This way we avoid writing out extra bytes that potentially come from struct alignment.
+template <typename T>
+inline size_t WriteArray(IOStream *stream, const T *in, unsigned int size) {
+    size_t n = 0;
+    for (unsigned int i = 0; i < size; i++)
+        n += Write<T>(stream, in[i]);
+
+    return n;
+}
+
+// ----------------------------------------------------------------------------------
+/** @class  AssbinChunkWriter
+ *  @brief  Chunk writer mechanism for the .assbin file structure
+ *
+ *  This is a standard in-memory IOStream (most of the code is based on BlobIOStream),
+ *  the difference being that this takes another IOStream as a "container" in the
+ *  constructor, and when it is destroyed, it appends the magic number, the chunk size,
+ *  and the chunk contents to the container stream. This allows relatively easy chunk
+ *  chunk construction, even recursively.
+ */
+class AssbinChunkWriter : public IOStream {
+private:
+    uint8_t *buffer;
+    uint32_t magic;
+    IOStream *container;
+    size_t cur_size, cursor, initial;
+
+private:
+    // -------------------------------------------------------------------
+    void Grow(size_t need = 0) {
+        size_t new_size = std::max(initial, std::max(need, cur_size + (cur_size >> 1)));
+
+        const uint8_t *const old = buffer;
+        buffer = new uint8_t[new_size];
+
+        if (old) {
+            memcpy(buffer, old, cur_size);
+            delete[] old;
+        }
+
+        cur_size = new_size;
+    }
+
+public:
+    AssbinChunkWriter(IOStream *container, uint32_t magic, size_t initial = 4096) :
+            buffer(nullptr),
+            magic(magic),
+            container(container),
+            cur_size(0),
+            cursor(0),
+            initial(initial) {
+        // empty
+    }
+
+    ~AssbinChunkWriter() override {
+        if (container) {
+            container->Write(&magic, sizeof(uint32_t), 1);
+            container->Write(&cursor, sizeof(uint32_t), 1);
+            container->Write(buffer, 1, cursor);
+        }
+        if (buffer) delete[] buffer;
+    }
+
+    void *GetBufferPointer() { return buffer; }
+
+    size_t Read(void * /*pvBuffer*/, size_t /*pSize*/, size_t /*pCount*/) override {
+        return 0;
+    }
+    
+    aiReturn Seek(size_t /*pOffset*/, aiOrigin /*pOrigin*/) override {
+        return aiReturn_FAILURE;
+    }
+    
+    size_t Tell() const override {
+        return cursor;
+    }
+    
+    void Flush() override {
+        // not implemented
+    }
+
+    size_t FileSize() const override {
+        return cursor;
+    }
+
+    size_t Write(const void *pvBuffer, size_t pSize, size_t pCount) override {
+        pSize *= pCount;
+        if (cursor + pSize > cur_size) {
+            Grow(cursor + pSize);
+        }
+
+        memcpy(buffer + cursor, pvBuffer, pSize);
+        cursor += pSize;
+
+        return pCount;
+    }
+};
+
+// ----------------------------------------------------------------------------------
+/** @class  AssbinFileWriter
+ *  @brief  Assbin file writer class
+ *
+ *  This class writes an .assbin file, and is responsible for the file layout.
+ */
+class AssbinFileWriter {
+private:
+    bool shortened;
+    bool compressed;
+
+protected:
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryNode(IOStream *container, const aiNode *node) {
+        AssbinChunkWriter chunk(container, ASSBIN_CHUNK_AINODE);
+
+        unsigned int nb_metadata = (node->mMetaData != nullptr ? node->mMetaData->mNumProperties : 0);
+
+        Write<aiString>(&chunk, node->mName);
+        Write<aiMatrix4x4>(&chunk, node->mTransformation);
+        Write<unsigned int>(&chunk, node->mNumChildren);
+        Write<unsigned int>(&chunk, node->mNumMeshes);
+        Write<unsigned int>(&chunk, nb_metadata);
+
+        for (unsigned int i = 0; i < node->mNumMeshes; ++i) {
+            Write<unsigned int>(&chunk, node->mMeshes[i]);
+        }
+
+        for (unsigned int i = 0; i < node->mNumChildren; ++i) {
+            WriteBinaryNode(&chunk, node->mChildren[i]);
+        }
+
+        for (unsigned int i = 0; i < nb_metadata; ++i) {
+            const aiString &key = node->mMetaData->mKeys[i];
+            aiMetadataType type = node->mMetaData->mValues[i].mType;
+            void *value = node->mMetaData->mValues[i].mData;
+
+            Write<aiString>(&chunk, key);
+            Write<uint16_t>(&chunk, (uint16_t)type);
+
+            switch (type) {
+            case AI_BOOL:
+                Write<bool>(&chunk, *((bool *)value));
+                break;
+            case AI_INT32:
+                Write<int32_t>(&chunk, *((int32_t *)value));
+                break;
+            case AI_UINT64:
+                Write<uint64_t>(&chunk, *((uint64_t *)value));
+                break;
+            case AI_FLOAT:
+                Write<float>(&chunk, *((float *)value));
+                break;
+            case AI_DOUBLE:
+                Write<double>(&chunk, *((double *)value));
+                break;
+            case AI_AISTRING:
+                Write<aiString>(&chunk, *((aiString *)value));
+                break;
+            case AI_AIVECTOR3D:
+                Write<aiVector3D>(&chunk, *((aiVector3D *)value));
+                break;
+#ifdef SWIG
+                case FORCE_32BIT:
+#endif // SWIG
+            default:
+                break;
+            }
+        }
+    }
+
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryTexture(IOStream *container, const aiTexture *tex) {
+        AssbinChunkWriter chunk(container, ASSBIN_CHUNK_AITEXTURE);
+
+        Write<unsigned int>(&chunk, tex->mWidth);
+        Write<unsigned int>(&chunk, tex->mHeight);
+        // Write the texture format, but don't include the null terminator.
+        chunk.Write(tex->achFormatHint, sizeof(char), HINTMAXTEXTURELEN - 1);
+
+        if (!shortened) {
+            if (!tex->mHeight) {
+                chunk.Write(tex->pcData, 1, tex->mWidth);
+            } else {
+                chunk.Write(tex->pcData, 1, tex->mWidth * tex->mHeight * 4);
+            }
+        }
+    }
+
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryBone(IOStream *container, const aiBone *b) {
+        AssbinChunkWriter chunk(container, ASSBIN_CHUNK_AIBONE);
+
+        Write<aiString>(&chunk, b->mName);
+        Write<unsigned int>(&chunk, b->mNumWeights);
+        Write<aiMatrix4x4>(&chunk, b->mOffsetMatrix);
+
+        // for the moment we write dumb min/max values for the bones, too.
+        // maybe I'll add a better, hash-like solution later
+        if (shortened) {
+            WriteBounds(&chunk, b->mWeights, b->mNumWeights);
+        } // else write as usual
+        else
+            WriteArray<aiVertexWeight>(&chunk, b->mWeights, b->mNumWeights);
+    }
+
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryMesh(IOStream *container, const aiMesh *mesh) {
+        AssbinChunkWriter chunk(container, ASSBIN_CHUNK_AIMESH);
+
+        Write<unsigned int>(&chunk, mesh->mPrimitiveTypes);
+        Write<unsigned int>(&chunk, mesh->mNumVertices);
+        Write<unsigned int>(&chunk, mesh->mNumFaces);
+        Write<unsigned int>(&chunk, mesh->mNumBones);
+        Write<unsigned int>(&chunk, mesh->mMaterialIndex);
+
+        // first of all, write bits for all existent vertex components
+        unsigned int c = 0;
+        if (mesh->mVertices) {
+            c |= ASSBIN_MESH_HAS_POSITIONS;
+        }
+        if (mesh->mNormals) {
+            c |= ASSBIN_MESH_HAS_NORMALS;
+        }
+        if (mesh->mTangents && mesh->mBitangents) {
+            c |= ASSBIN_MESH_HAS_TANGENTS_AND_BITANGENTS;
+        }
+        for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++n) {
+            if (!mesh->mTextureCoords[n]) {
+                break;
+            }
+            c |= ASSBIN_MESH_HAS_TEXCOORD(n);
+        }
+        for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS; ++n) {
+            if (!mesh->mColors[n]) {
+                break;
+            }
+            c |= ASSBIN_MESH_HAS_COLOR(n);
+        }
+        Write<unsigned int>(&chunk, c);
+
+        aiVector3D minVec, maxVec;
+        if (mesh->mVertices) {
+            if (shortened) {
+                WriteBounds(&chunk, mesh->mVertices, mesh->mNumVertices);
+            } // else write as usual
+            else
+                WriteArray<aiVector3D>(&chunk, mesh->mVertices, mesh->mNumVertices);
+        }
+        if (mesh->mNormals) {
+            if (shortened) {
+                WriteBounds(&chunk, mesh->mNormals, mesh->mNumVertices);
+            } // else write as usual
+            else
+                WriteArray<aiVector3D>(&chunk, mesh->mNormals, mesh->mNumVertices);
+        }
+        if (mesh->mTangents && mesh->mBitangents) {
+            if (shortened) {
+                WriteBounds(&chunk, mesh->mTangents, mesh->mNumVertices);
+                WriteBounds(&chunk, mesh->mBitangents, mesh->mNumVertices);
+            } // else write as usual
+            else {
+                WriteArray<aiVector3D>(&chunk, mesh->mTangents, mesh->mNumVertices);
+                WriteArray<aiVector3D>(&chunk, mesh->mBitangents, mesh->mNumVertices);
+            }
+        }
+        for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS; ++n) {
+            if (!mesh->mColors[n])
+                break;
+
+            if (shortened) {
+                WriteBounds(&chunk, mesh->mColors[n], mesh->mNumVertices);
+            } // else write as usual
+            else
+                WriteArray<aiColor4D>(&chunk, mesh->mColors[n], mesh->mNumVertices);
+        }
+        for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++n) {
+            if (!mesh->mTextureCoords[n])
+                break;
+
+            // write number of UV components
+            Write<unsigned int>(&chunk, mesh->mNumUVComponents[n]);
+
+            if (shortened) {
+                WriteBounds(&chunk, mesh->mTextureCoords[n], mesh->mNumVertices);
+            } // else write as usual
+            else
+                WriteArray<aiVector3D>(&chunk, mesh->mTextureCoords[n], mesh->mNumVertices);
+        }
+
+        // write faces. There are no floating-point calculations involved
+        // in these, so we can write a simple hash over the face data
+        // to the dump file. We generate a single 32 Bit hash for 512 faces
+        // using Assimp's standard hashing function.
+        if (shortened) {
+            unsigned int processed = 0;
+            for (unsigned int job; (job = std::min(mesh->mNumFaces - processed, 512u)); processed += job) {
+                uint32_t hash = 0;
+                for (unsigned int a = 0; a < job; ++a) {
+
+                    const aiFace &f = mesh->mFaces[processed + a];
+                    uint32_t tmp = f.mNumIndices;
+                    hash = SuperFastHash(reinterpret_cast<const char *>(&tmp), sizeof tmp, hash);
+                    for (unsigned int i = 0; i < f.mNumIndices; ++i) {
+                        static_assert(AI_MAX_VERTICES <= 0xffffffff, "AI_MAX_VERTICES <= 0xffffffff");
+                        tmp = static_cast<uint32_t>(f.mIndices[i]);
+                        hash = SuperFastHash(reinterpret_cast<const char *>(&tmp), sizeof tmp, hash);
+                    }
+                }
+                Write<unsigned int>(&chunk, hash);
+            }
+        } else // else write as usual
+        {
+            // if there are less than 2^16 vertices, we can simply use 16 bit integers ...
+            for (unsigned int i = 0; i < mesh->mNumFaces; ++i) {
+                const aiFace &f = mesh->mFaces[i];
+
+                static_assert(AI_MAX_FACE_INDICES <= 0xffff, "AI_MAX_FACE_INDICES <= 0xffff");
+                Write<uint16_t>(&chunk, static_cast<uint16_t>(f.mNumIndices));
+
+                for (unsigned int a = 0; a < f.mNumIndices; ++a) {
+                    if (mesh->mNumVertices < (1u << 16)) {
+                        Write<uint16_t>(&chunk, static_cast<uint16_t>(f.mIndices[a]));
+                    } else {
+                        Write<unsigned int>(&chunk, f.mIndices[a]);
+                    }
+                }
+            }
+        }
+
+        // write bones
+        if (mesh->mNumBones) {
+            for (unsigned int a = 0; a < mesh->mNumBones; ++a) {
+                const aiBone *b = mesh->mBones[a];
+                WriteBinaryBone(&chunk, b);
+            }
+        }
+    }
+
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryMaterialProperty(IOStream *container, const aiMaterialProperty *prop) {
+        AssbinChunkWriter chunk(container, ASSBIN_CHUNK_AIMATERIALPROPERTY);
+
+        Write<aiString>(&chunk, prop->mKey);
+        Write<unsigned int>(&chunk, prop->mSemantic);
+        Write<unsigned int>(&chunk, prop->mIndex);
+
+        Write<unsigned int>(&chunk, prop->mDataLength);
+        Write<unsigned int>(&chunk, (unsigned int)prop->mType);
+        chunk.Write(prop->mData, 1, prop->mDataLength);
+    }
+
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryMaterial(IOStream *container, const aiMaterial *mat) {
+        AssbinChunkWriter chunk(container, ASSBIN_CHUNK_AIMATERIAL);
+
+        Write<unsigned int>(&chunk, mat->mNumProperties);
+        for (unsigned int i = 0; i < mat->mNumProperties; ++i) {
+            WriteBinaryMaterialProperty(&chunk, mat->mProperties[i]);
+        }
+    }
+
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryNodeAnim(IOStream *container, const aiNodeAnim *nd) {
+        AssbinChunkWriter chunk(container, ASSBIN_CHUNK_AINODEANIM);
+
+        Write<aiString>(&chunk, nd->mNodeName);
+        Write<unsigned int>(&chunk, nd->mNumPositionKeys);
+        Write<unsigned int>(&chunk, nd->mNumRotationKeys);
+        Write<unsigned int>(&chunk, nd->mNumScalingKeys);
+        Write<unsigned int>(&chunk, nd->mPreState);
+        Write<unsigned int>(&chunk, nd->mPostState);
+
+        if (nd->mPositionKeys) {
+            if (shortened) {
+                WriteBounds(&chunk, nd->mPositionKeys, nd->mNumPositionKeys);
+
+            } // else write as usual
+            else
+                WriteArray<aiVectorKey>(&chunk, nd->mPositionKeys, nd->mNumPositionKeys);
+        }
+        if (nd->mRotationKeys) {
+            if (shortened) {
+                WriteBounds(&chunk, nd->mRotationKeys, nd->mNumRotationKeys);
+
+            } // else write as usual
+            else
+                WriteArray<aiQuatKey>(&chunk, nd->mRotationKeys, nd->mNumRotationKeys);
+        }
+        if (nd->mScalingKeys) {
+            if (shortened) {
+                WriteBounds(&chunk, nd->mScalingKeys, nd->mNumScalingKeys);
+
+            } // else write as usual
+            else
+                WriteArray<aiVectorKey>(&chunk, nd->mScalingKeys, nd->mNumScalingKeys);
+        }
+    }
+
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryAnim(IOStream *container, const aiAnimation *anim) {
+        AssbinChunkWriter chunk(container, ASSBIN_CHUNK_AIANIMATION);
+
+        Write<aiString>(&chunk, anim->mName);
+        Write<double>(&chunk, anim->mDuration);
+        Write<double>(&chunk, anim->mTicksPerSecond);
+        Write<unsigned int>(&chunk, anim->mNumChannels);
+
+        for (unsigned int a = 0; a < anim->mNumChannels; ++a) {
+            const aiNodeAnim *nd = anim->mChannels[a];
+            WriteBinaryNodeAnim(&chunk, nd);
+        }
+    }
+
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryLight(IOStream *container, const aiLight *l) {
+        AssbinChunkWriter chunk(container, ASSBIN_CHUNK_AILIGHT);
+
+        Write<aiString>(&chunk, l->mName);
+        Write<unsigned int>(&chunk, l->mType);
+
+        if (l->mType != aiLightSource_DIRECTIONAL) {
+            Write<float>(&chunk, l->mAttenuationConstant);
+            Write<float>(&chunk, l->mAttenuationLinear);
+            Write<float>(&chunk, l->mAttenuationQuadratic);
+        }
+
+        Write<aiColor3D>(&chunk, l->mColorDiffuse);
+        Write<aiColor3D>(&chunk, l->mColorSpecular);
+        Write<aiColor3D>(&chunk, l->mColorAmbient);
+
+        if (l->mType == aiLightSource_SPOT) {
+            Write<float>(&chunk, l->mAngleInnerCone);
+            Write<float>(&chunk, l->mAngleOuterCone);
+        }
+    }
+
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryCamera(IOStream *container, const aiCamera *cam) {
+        AssbinChunkWriter chunk(container, ASSBIN_CHUNK_AICAMERA);
+
+        Write<aiString>(&chunk, cam->mName);
+        Write<aiVector3D>(&chunk, cam->mPosition);
+        Write<aiVector3D>(&chunk, cam->mLookAt);
+        Write<aiVector3D>(&chunk, cam->mUp);
+        Write<float>(&chunk, cam->mHorizontalFOV);
+        Write<float>(&chunk, cam->mClipPlaneNear);
+        Write<float>(&chunk, cam->mClipPlaneFar);
+        Write<float>(&chunk, cam->mAspect);
+    }
+
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryScene(IOStream *container, const aiScene *scene) {
+        AssbinChunkWriter chunk(container, ASSBIN_CHUNK_AISCENE);
+
+        // basic scene information
+        Write<unsigned int>(&chunk, scene->mFlags);
+        Write<unsigned int>(&chunk, scene->mNumMeshes);
+        Write<unsigned int>(&chunk, scene->mNumMaterials);
+        Write<unsigned int>(&chunk, scene->mNumAnimations);
+        Write<unsigned int>(&chunk, scene->mNumTextures);
+        Write<unsigned int>(&chunk, scene->mNumLights);
+        Write<unsigned int>(&chunk, scene->mNumCameras);
+
+        // write node graph
+        WriteBinaryNode(&chunk, scene->mRootNode);
+
+        // write all meshes
+        for (unsigned int i = 0; i < scene->mNumMeshes; ++i) {
+            const aiMesh *mesh = scene->mMeshes[i];
+            WriteBinaryMesh(&chunk, mesh);
+        }
+
+        // write materials
+        for (unsigned int i = 0; i < scene->mNumMaterials; ++i) {
+            const aiMaterial *mat = scene->mMaterials[i];
+            WriteBinaryMaterial(&chunk, mat);
+        }
+
+        // write all animations
+        for (unsigned int i = 0; i < scene->mNumAnimations; ++i) {
+            const aiAnimation *anim = scene->mAnimations[i];
+            WriteBinaryAnim(&chunk, anim);
+        }
+
+        // write all textures
+        for (unsigned int i = 0; i < scene->mNumTextures; ++i) {
+            const aiTexture *mesh = scene->mTextures[i];
+            WriteBinaryTexture(&chunk, mesh);
+        }
+
+        // write lights
+        for (unsigned int i = 0; i < scene->mNumLights; ++i) {
+            const aiLight *l = scene->mLights[i];
+            WriteBinaryLight(&chunk, l);
+        }
+
+        // write cameras
+        for (unsigned int i = 0; i < scene->mNumCameras; ++i) {
+            const aiCamera *cam = scene->mCameras[i];
+            WriteBinaryCamera(&chunk, cam);
+        }
+    }
+
+public:
+    AssbinFileWriter(bool shortened, bool compressed) :
+            shortened(shortened), compressed(compressed) {
+    }
+
+    // -----------------------------------------------------------------------------------
+    // Write a binary model dump
+    void WriteBinaryDump(const char *pFile, const char *cmd, IOSystem *pIOSystem, const aiScene *pScene) {
+        IOStream *out = pIOSystem->Open(pFile, "wb");
+        if (!out)
+            throw std::runtime_error("Unable to open output file " + std::string(pFile) + '\n');
+
+        auto CloseIOStream = [&]() {
+            if (out) {
+                pIOSystem->Close(out);
+                out = nullptr; // Ensure this is only done once.
+            }
+        };
+
+        try {
+            time_t tt = time(nullptr);
+#if _WIN32
+            tm *p = gmtime(&tt);
+#else
+            struct tm now;
+            tm *p = gmtime_r(&tt, &now);
+#endif
+
+            // header
+            char s[64];
+            memset(s, 0, 64);
+#if _MSC_VER >= 1400
+            sprintf_s(s, "ASSIMP.binary-dump.%s", asctime(p));
+#else
+            ai_snprintf(s, 64, "ASSIMP.binary-dump.%s", asctime(p));
+#endif
+            out->Write(s, 44, 1);
+            // == 44 bytes
+
+            Write<unsigned int>(out, ASSBIN_VERSION_MAJOR);
+            Write<unsigned int>(out, ASSBIN_VERSION_MINOR);
+            Write<unsigned int>(out, aiGetVersionRevision());
+            Write<unsigned int>(out, aiGetCompileFlags());
+            Write<uint16_t>(out, shortened);
+            Write<uint16_t>(out, compressed);
+            // ==  20 bytes
+
+            char buff[256] = { 0 };
+            ai_snprintf(buff, 256, "%s", pFile);
+            out->Write(buff, sizeof(char), 256);
+
+            memset(buff, 0, sizeof(buff));
+            ai_snprintf(buff, 128, "%s", cmd);
+            out->Write(buff, sizeof(char), 128);
+
+            // leave 64 bytes free for future extensions
+            memset(buff, 0xcd, 64);
+            out->Write(buff, sizeof(char), 64);
+            // == 435 bytes
+
+            // ==== total header size: 512 bytes
+            ai_assert(out->Tell() == ASSBIN_HEADER_LENGTH);
+
+            // Up to here the data is uncompressed. For compressed files, the rest
+            // is compressed using standard DEFLATE from zlib.
+            if (compressed) {
+                AssbinChunkWriter uncompressedStream(nullptr, 0);
+                WriteBinaryScene(&uncompressedStream, pScene);
+
+                uLongf uncompressedSize = static_cast<uLongf>(uncompressedStream.Tell());
+                uLongf compressedSize = (uLongf)compressBound(uncompressedSize);
+                uint8_t *compressedBuffer = new uint8_t[compressedSize];
+
+                int res = compress2(compressedBuffer, &compressedSize, (const Bytef *)uncompressedStream.GetBufferPointer(), uncompressedSize, 9);
+                if (res != Z_OK) {
+                    delete[] compressedBuffer;
+                    throw DeadlyExportError("Compression failed.");
+                }
+
+                out->Write(&uncompressedSize, sizeof(uint32_t), 1);
+                out->Write(compressedBuffer, sizeof(char), compressedSize);
+
+                delete[] compressedBuffer;
+            } else {
+                WriteBinaryScene(out, pScene);
+            }
+
+            CloseIOStream();
+        } catch (...) {
+            CloseIOStream();
+            throw;
+        }
+    }
+};
+
+void DumpSceneToAssbin(
+        const char *pFile, const char *cmd, IOSystem *pIOSystem,
+        const aiScene *pScene, bool shortened, bool compressed) {
+    AssbinFileWriter fileWriter(shortened, compressed);
+    fileWriter.WriteBinaryDump(pFile, cmd, pIOSystem, pScene);
+}
+#if _MSC_VER
+#pragma warning(pop)
+#endif // _MSC_VER
+
+} // end of namespace Assimp
diff --git a/Engine/lib/assimp/code/3MF/D3MFImporter.h b/Engine/lib/assimp/code/AssetLib/Assbin/AssbinFileWriter.h
similarity index 74%
rename from Engine/lib/assimp/code/3MF/D3MFImporter.h
rename to Engine/lib/assimp/code/AssetLib/Assbin/AssbinFileWriter.h
index 3dbdf07bf..cfed3b400 100644
--- a/Engine/lib/assimp/code/3MF/D3MFImporter.h
+++ b/Engine/lib/assimp/code/AssetLib/Assbin/AssbinFileWriter.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -40,26 +39,27 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
-#ifndef AI_D3MFLOADER_H_INCLUDED
-#define AI_D3MFLOADER_H_INCLUDED
+/** @file AssbinFileWriter.h
+ *  @brief Declaration of Assbin file writer.
+ */
 
-#include <assimp/BaseImporter.h>
+#ifndef AI_ASSBINFILEWRITER_H_INC
+#define AI_ASSBINFILEWRITER_H_INC
+
+#include <assimp/defs.h>
+#include <assimp/scene.h>
+#include <assimp/IOSystem.hpp>
 
 namespace Assimp {
 
-class D3MFImporter : public BaseImporter {
-public:
-    // BaseImporter interface
-    D3MFImporter();
-    ~D3MFImporter();
-    bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const;
-    void SetupProperties(const Importer *pImp);
-    const aiImporterDesc *GetInfo() const;
+void ASSIMP_API DumpSceneToAssbin(
+        const char *pFile,
+        const char *cmd,
+        IOSystem *pIOSystem,
+        const aiScene *pScene,
+        bool shortened,
+        bool compressed);
 
-protected:
-    void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler);
-};
+}
 
-} // Namespace Assimp
-
-#endif // AI_D3MFLOADER_H_INCLUDED
+#endif // AI_ASSBINFILEWRITER_H_INC
diff --git a/Engine/lib/assimp/code/Assbin/AssbinLoader.cpp b/Engine/lib/assimp/code/AssetLib/Assbin/AssbinLoader.cpp
similarity index 56%
rename from Engine/lib/assimp/code/Assbin/AssbinLoader.cpp
rename to Engine/lib/assimp/code/AssetLib/Assbin/AssbinLoader.cpp
index becc3f8fc..060ce4377 100644
--- a/Engine/lib/assimp/code/Assbin/AssbinLoader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/Assbin/AssbinLoader.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -50,19 +48,19 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_ASSBIN_IMPORTER
 
 // internal headers
-#include "Assbin/AssbinLoader.h"
+#include "AssetLib/Assbin/AssbinLoader.h"
 #include "Common/assbin_chunks.h"
 #include <assimp/MemoryIOWrapper.h>
-#include <assimp/mesh.h>
 #include <assimp/anim.h>
-#include <assimp/scene.h>
 #include <assimp/importerdesc.h>
+#include <assimp/mesh.h>
+#include <assimp/scene.h>
 #include <memory>
 
 #ifdef ASSIMP_BUILD_NO_OWN_ZLIB
-#   include <zlib.h>
+#include <zlib.h>
 #else
-#   include <contrib/zlib/zlib.h>
+#include <contrib/zlib/zlib.h>
 #endif
 
 using namespace Assimp;
@@ -81,94 +79,97 @@ static const aiImporterDesc desc = {
 };
 
 // -----------------------------------------------------------------------------------
-const aiImporterDesc* AssbinImporter::GetInfo() const {
+const aiImporterDesc *AssbinImporter::GetInfo() const {
     return &desc;
 }
 
 // -----------------------------------------------------------------------------------
-bool AssbinImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/ ) const {
-    IOStream * in = pIOHandler->Open(pFile);
+bool AssbinImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
+    IOStream *in = pIOHandler->Open(pFile);
     if (nullptr == in) {
         return false;
     }
 
     char s[32];
-    in->Read( s, sizeof(char), 32 );
+    in->Read(s, sizeof(char), 32);
 
     pIOHandler->Close(in);
 
-    return strncmp( s, "ASSIMP.binary-dump.", 19 ) == 0;
+    return strncmp(s, "ASSIMP.binary-dump.", 19) == 0;
 }
 
 // -----------------------------------------------------------------------------------
 template <typename T>
-T Read(IOStream * stream) {
+T Read(IOStream *stream) {
     T t;
-    size_t res = stream->Read( &t, sizeof(T), 1 );
-    if(res != 1)
+    size_t res = stream->Read(&t, sizeof(T), 1);
+    if (res != 1) {
         throw DeadlyImportError("Unexpected EOF");
+    }
     return t;
 }
 
 // -----------------------------------------------------------------------------------
 template <>
-aiVector3D Read<aiVector3D>(IOStream * stream) {
+aiVector3D Read<aiVector3D>(IOStream *stream) {
     aiVector3D v;
-    v.x = Read<float>(stream);
-    v.y = Read<float>(stream);
-    v.z = Read<float>(stream);
+    v.x = Read<ai_real>(stream);
+    v.y = Read<ai_real>(stream);
+    v.z = Read<ai_real>(stream);
     return v;
 }
 
 // -----------------------------------------------------------------------------------
 template <>
-aiColor4D Read<aiColor4D>(IOStream * stream) {
+aiColor4D Read<aiColor4D>(IOStream *stream) {
     aiColor4D c;
-    c.r = Read<float>(stream);
-    c.g = Read<float>(stream);
-    c.b = Read<float>(stream);
-    c.a = Read<float>(stream);
+    c.r = Read<ai_real>(stream);
+    c.g = Read<ai_real>(stream);
+    c.b = Read<ai_real>(stream);
+    c.a = Read<ai_real>(stream);
     return c;
 }
 
 // -----------------------------------------------------------------------------------
 template <>
-aiQuaternion Read<aiQuaternion>(IOStream * stream) {
+aiQuaternion Read<aiQuaternion>(IOStream *stream) {
     aiQuaternion v;
-    v.w = Read<float>(stream);
-    v.x = Read<float>(stream);
-    v.y = Read<float>(stream);
-    v.z = Read<float>(stream);
+    v.w = Read<ai_real>(stream);
+    v.x = Read<ai_real>(stream);
+    v.y = Read<ai_real>(stream);
+    v.z = Read<ai_real>(stream);
     return v;
 }
 
 // -----------------------------------------------------------------------------------
 template <>
-aiString Read<aiString>(IOStream * stream) {
+aiString Read<aiString>(IOStream *stream) {
     aiString s;
-    stream->Read(&s.length,4,1);
-    if(s.length)
-        stream->Read(s.data,s.length,1);
+    stream->Read(&s.length, 4, 1);
+    if (s.length) {
+        stream->Read(s.data, s.length, 1);
+    }
     s.data[s.length] = 0;
+
     return s;
 }
 
 // -----------------------------------------------------------------------------------
 template <>
-aiVertexWeight Read<aiVertexWeight>(IOStream * stream) {
+aiVertexWeight Read<aiVertexWeight>(IOStream *stream) {
     aiVertexWeight w;
     w.mVertexId = Read<unsigned int>(stream);
-    w.mWeight = Read<float>(stream);
+    w.mWeight = Read<ai_real>(stream);
     return w;
 }
 
 // -----------------------------------------------------------------------------------
 template <>
-aiMatrix4x4 Read<aiMatrix4x4>(IOStream * stream) {
+aiMatrix4x4 Read<aiMatrix4x4>(IOStream *stream) {
     aiMatrix4x4 m;
-    for (unsigned int i = 0; i < 4;++i) {
-        for (unsigned int i2 = 0; i2 < 4;++i2) {
-            m[i][i2] = Read<float>(stream);
+    for (unsigned int i = 0; i < 4; ++i) {
+        for (unsigned int i2 = 0; i2 < 4; ++i2) {
+            m[i][i2] = Read<ai_real>(stream);
         }
     }
     return m;
@@ -176,7 +177,7 @@ aiMatrix4x4 Read<aiMatrix4x4>(IOStream * stream) {
 
 // -----------------------------------------------------------------------------------
 template <>
-aiVectorKey Read<aiVectorKey>(IOStream * stream) {
+aiVectorKey Read<aiVectorKey>(IOStream *stream) {
     aiVectorKey v;
     v.mTime = Read<double>(stream);
     v.mValue = Read<aiVector3D>(stream);
@@ -185,7 +186,7 @@ aiVectorKey Read<aiVectorKey>(IOStream * stream) {
 
 // -----------------------------------------------------------------------------------
 template <>
-aiQuatKey Read<aiQuatKey>(IOStream * stream) {
+aiQuatKey Read<aiQuatKey>(IOStream *stream) {
     aiQuatKey v;
     v.mTime = Read<double>(stream);
     v.mValue = Read<aiQuaternion>(stream);
@@ -194,27 +195,27 @@ aiQuatKey Read<aiQuatKey>(IOStream * stream) {
 
 // -----------------------------------------------------------------------------------
 template <typename T>
-void ReadArray( IOStream *stream, T * out, unsigned int size) {
-    ai_assert( nullptr != stream );
-    ai_assert( nullptr != out );
+void ReadArray(IOStream *stream, T *out, unsigned int size) {
+    ai_assert(nullptr != stream);
+    ai_assert(nullptr != out);
 
-    for (unsigned int i=0; i<size; i++) {
+    for (unsigned int i = 0; i < size; i++) {
         out[i] = Read<T>(stream);
     }
 }
 
 // -----------------------------------------------------------------------------------
 template <typename T>
-void ReadBounds( IOStream * stream, T* /*p*/, unsigned int n ) {
+void ReadBounds(IOStream *stream, T * /*p*/, unsigned int n) {
     // not sure what to do here, the data isn't really useful.
-    stream->Seek( sizeof(T) * n, aiOrigin_CUR );
+    stream->Seek(sizeof(T) * n, aiOrigin_CUR);
 }
 
 // -----------------------------------------------------------------------------------
-void AssbinImporter::ReadBinaryNode( IOStream * stream, aiNode** onode, aiNode* parent ) {
-    if(Read<uint32_t>(stream) != ASSBIN_CHUNK_AINODE)
+void AssbinImporter::ReadBinaryNode(IOStream *stream, aiNode **onode, aiNode *parent) {
+    if (Read<uint32_t>(stream) != ASSBIN_CHUNK_AINODE)
         throw DeadlyImportError("Magic chunk identifiers are wrong!");
-    /*uint32_t size =*/ Read<uint32_t>(stream);
+    /*uint32_t size =*/Read<uint32_t>(stream);
 
     std::unique_ptr<aiNode> node(new aiNode());
 
@@ -222,14 +223,13 @@ void AssbinImporter::ReadBinaryNode( IOStream * stream, aiNode** onode, aiNode*
     node->mTransformation = Read<aiMatrix4x4>(stream);
     unsigned numChildren = Read<unsigned int>(stream);
     unsigned numMeshes = Read<unsigned int>(stream);
-	unsigned int nb_metadata = Read<unsigned int>(stream);
+    unsigned int nb_metadata = Read<unsigned int>(stream);
 
-    if(parent) {
+    if (parent) {
         node->mParent = parent;
     }
 
-    if (numMeshes)
-    {
+    if (numMeshes) {
         node->mMeshes = new unsigned int[numMeshes];
         for (unsigned int i = 0; i < numMeshes; ++i) {
             node->mMeshes[i] = Read<unsigned int>(stream);
@@ -238,60 +238,60 @@ void AssbinImporter::ReadBinaryNode( IOStream * stream, aiNode** onode, aiNode*
     }
 
     if (numChildren) {
-        node->mChildren = new aiNode*[numChildren];
+        node->mChildren = new aiNode *[numChildren];
         for (unsigned int i = 0; i < numChildren; ++i) {
-            ReadBinaryNode( stream, &node->mChildren[i], node.get() );
+            ReadBinaryNode(stream, &node->mChildren[i], node.get());
             node->mNumChildren++;
         }
     }
 
-    if ( nb_metadata > 0 ) {
+    if (nb_metadata > 0) {
         node->mMetaData = aiMetadata::Alloc(nb_metadata);
         for (unsigned int i = 0; i < nb_metadata; ++i) {
             node->mMetaData->mKeys[i] = Read<aiString>(stream);
-            node->mMetaData->mValues[i].mType = (aiMetadataType) Read<uint16_t>(stream);
-            void* data = nullptr;
+            node->mMetaData->mValues[i].mType = (aiMetadataType)Read<uint16_t>(stream);
+            void *data = nullptr;
 
             switch (node->mMetaData->mValues[i].mType) {
-                case AI_BOOL:
-                    data = new bool(Read<bool>(stream));
-                    break;
-                case AI_INT32:
-                    data = new int32_t(Read<int32_t>(stream));
-                    break;
-                case AI_UINT64:
-                    data = new uint64_t(Read<uint64_t>(stream));
-                    break;
-                case AI_FLOAT:
-                    data = new float(Read<float>(stream));
-                    break;
-                case AI_DOUBLE:
-                    data = new double(Read<double>(stream));
-                    break;
-                case AI_AISTRING:
-                    data = new aiString(Read<aiString>(stream));
-                    break;
-                case AI_AIVECTOR3D:
-                    data = new aiVector3D(Read<aiVector3D>(stream));
-                    break;
+            case AI_BOOL:
+                data = new bool(Read<bool>(stream));
+                break;
+            case AI_INT32:
+                data = new int32_t(Read<int32_t>(stream));
+                break;
+            case AI_UINT64:
+                data = new uint64_t(Read<uint64_t>(stream));
+                break;
+            case AI_FLOAT:
+                data = new ai_real(Read<ai_real>(stream));
+                break;
+            case AI_DOUBLE:
+                data = new double(Read<double>(stream));
+                break;
+            case AI_AISTRING:
+                data = new aiString(Read<aiString>(stream));
+                break;
+            case AI_AIVECTOR3D:
+                data = new aiVector3D(Read<aiVector3D>(stream));
+                break;
 #ifndef SWIG
-                case FORCE_32BIT:
+            case FORCE_32BIT:
 #endif // SWIG
-                default:
-                    break;
+            default:
+                break;
             }
 
-			node->mMetaData->mValues[i].mData = data;
-		}
-	}
+            node->mMetaData->mValues[i].mData = data;
+        }
+    }
     *onode = node.release();
 }
 
 // -----------------------------------------------------------------------------------
-void AssbinImporter::ReadBinaryBone( IOStream * stream, aiBone* b ) {
-    if(Read<uint32_t>(stream) != ASSBIN_CHUNK_AIBONE)
+void AssbinImporter::ReadBinaryBone(IOStream *stream, aiBone *b) {
+    if (Read<uint32_t>(stream) != ASSBIN_CHUNK_AIBONE)
         throw DeadlyImportError("Magic chunk identifiers are wrong!");
-    /*uint32_t size =*/ Read<uint32_t>(stream);
+    /*uint32_t size =*/Read<uint32_t>(stream);
 
     b->mName = Read<aiString>(stream);
     b->mNumWeights = Read<unsigned int>(stream);
@@ -300,23 +300,24 @@ void AssbinImporter::ReadBinaryBone( IOStream * stream, aiBone* b ) {
     // for the moment we write dumb min/max values for the bones, too.
     // maybe I'll add a better, hash-like solution later
     if (shortened) {
-        ReadBounds(stream,b->mWeights,b->mNumWeights);
+        ReadBounds(stream, b->mWeights, b->mNumWeights);
     } else {
         // else write as usual
         b->mWeights = new aiVertexWeight[b->mNumWeights];
-        ReadArray<aiVertexWeight>(stream,b->mWeights,b->mNumWeights);
+        ReadArray<aiVertexWeight>(stream, b->mWeights, b->mNumWeights);
     }
 }
 
 // -----------------------------------------------------------------------------------
 static bool fitsIntoUI16(unsigned int mNumVertices) {
-    return ( mNumVertices < (1u<<16) );
+    return (mNumVertices < (1u << 16));
 }
+
 // -----------------------------------------------------------------------------------
-void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh ) {
-    if(Read<uint32_t>(stream) != ASSBIN_CHUNK_AIMESH)
+void AssbinImporter::ReadBinaryMesh(IOStream *stream, aiMesh *mesh) {
+    if (Read<uint32_t>(stream) != ASSBIN_CHUNK_AIMESH)
         throw DeadlyImportError("Magic chunk identifiers are wrong!");
-    /*uint32_t size =*/ Read<uint32_t>(stream);
+    /*uint32_t size =*/Read<uint32_t>(stream);
 
     mesh->mPrimitiveTypes = Read<unsigned int>(stream);
     mesh->mNumVertices = Read<unsigned int>(stream);
@@ -329,48 +330,48 @@ void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh ) {
 
     if (c & ASSBIN_MESH_HAS_POSITIONS) {
         if (shortened) {
-            ReadBounds(stream,mesh->mVertices,mesh->mNumVertices);
-        }  else {
+            ReadBounds(stream, mesh->mVertices, mesh->mNumVertices);
+        } else {
             // else write as usual
             mesh->mVertices = new aiVector3D[mesh->mNumVertices];
-            ReadArray<aiVector3D>(stream,mesh->mVertices,mesh->mNumVertices);
+            ReadArray<aiVector3D>(stream, mesh->mVertices, mesh->mNumVertices);
         }
     }
     if (c & ASSBIN_MESH_HAS_NORMALS) {
         if (shortened) {
-            ReadBounds(stream,mesh->mNormals,mesh->mNumVertices);
-        }  else {
+            ReadBounds(stream, mesh->mNormals, mesh->mNumVertices);
+        } else {
             // else write as usual
             mesh->mNormals = new aiVector3D[mesh->mNumVertices];
-            ReadArray<aiVector3D>(stream,mesh->mNormals,mesh->mNumVertices);
+            ReadArray<aiVector3D>(stream, mesh->mNormals, mesh->mNumVertices);
         }
     }
     if (c & ASSBIN_MESH_HAS_TANGENTS_AND_BITANGENTS) {
         if (shortened) {
-            ReadBounds(stream,mesh->mTangents,mesh->mNumVertices);
-            ReadBounds(stream,mesh->mBitangents,mesh->mNumVertices);
-        }  else {
+            ReadBounds(stream, mesh->mTangents, mesh->mNumVertices);
+            ReadBounds(stream, mesh->mBitangents, mesh->mNumVertices);
+        } else {
             // else write as usual
             mesh->mTangents = new aiVector3D[mesh->mNumVertices];
-            ReadArray<aiVector3D>(stream,mesh->mTangents,mesh->mNumVertices);
+            ReadArray<aiVector3D>(stream, mesh->mTangents, mesh->mNumVertices);
             mesh->mBitangents = new aiVector3D[mesh->mNumVertices];
-            ReadArray<aiVector3D>(stream,mesh->mBitangents,mesh->mNumVertices);
+            ReadArray<aiVector3D>(stream, mesh->mBitangents, mesh->mNumVertices);
         }
     }
-    for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS;++n) {
+    for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS; ++n) {
         if (!(c & ASSBIN_MESH_HAS_COLOR(n))) {
             break;
         }
 
         if (shortened) {
-            ReadBounds(stream,mesh->mColors[n],mesh->mNumVertices);
-        }  else {
+            ReadBounds(stream, mesh->mColors[n], mesh->mNumVertices);
+        } else {
             // else write as usual
             mesh->mColors[n] = new aiColor4D[mesh->mNumVertices];
-            ReadArray<aiColor4D>(stream,mesh->mColors[n],mesh->mNumVertices);
+            ReadArray<aiColor4D>(stream, mesh->mColors[n], mesh->mNumVertices);
         }
     }
-    for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n) {
+    for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++n) {
         if (!(c & ASSBIN_MESH_HAS_TEXCOORD(n))) {
             break;
         }
@@ -379,11 +380,11 @@ void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh ) {
         mesh->mNumUVComponents[n] = Read<unsigned int>(stream);
 
         if (shortened) {
-            ReadBounds(stream,mesh->mTextureCoords[n],mesh->mNumVertices);
-        }  else {
+            ReadBounds(stream, mesh->mTextureCoords[n], mesh->mNumVertices);
+        } else {
             // else write as usual
             mesh->mTextureCoords[n] = new aiVector3D[mesh->mNumVertices];
-            ReadArray<aiVector3D>(stream,mesh->mTextureCoords[n],mesh->mNumVertices);
+            ReadArray<aiVector3D>(stream, mesh->mTextureCoords[n], mesh->mNumVertices);
         }
     }
 
@@ -393,20 +394,20 @@ void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh ) {
     // using Assimp's standard hashing function.
     if (shortened) {
         Read<unsigned int>(stream);
-    } else  {
+    } else {
         // else write as usual
         // if there are less than 2^16 vertices, we can simply use 16 bit integers ...
         mesh->mFaces = new aiFace[mesh->mNumFaces];
-        for (unsigned int i = 0; i < mesh->mNumFaces;++i) {
-            aiFace& f = mesh->mFaces[i];
+        for (unsigned int i = 0; i < mesh->mNumFaces; ++i) {
+            aiFace &f = mesh->mFaces[i];
 
             static_assert(AI_MAX_FACE_INDICES <= 0xffff, "AI_MAX_FACE_INDICES <= 0xffff");
             f.mNumIndices = Read<uint16_t>(stream);
             f.mIndices = new unsigned int[f.mNumIndices];
 
-            for (unsigned int a = 0; a < f.mNumIndices;++a) {
-                // Check if unsigned  short ( 16 bit  ) are big enought for the indices
-                if ( fitsIntoUI16( mesh->mNumVertices ) ) {
+            for (unsigned int a = 0; a < f.mNumIndices; ++a) {
+                // Check if unsigned  short ( 16 bit  ) are big enough for the indices
+                if (fitsIntoUI16(mesh->mNumVertices)) {
                     f.mIndices[a] = Read<uint16_t>(stream);
                 } else {
                     f.mIndices[a] = Read<unsigned int>(stream);
@@ -417,19 +418,19 @@ void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh ) {
 
     // write bones
     if (mesh->mNumBones) {
-        mesh->mBones = new C_STRUCT aiBone*[mesh->mNumBones];
-        for (unsigned int a = 0; a < mesh->mNumBones;++a) {
+        mesh->mBones = new C_STRUCT aiBone *[mesh->mNumBones];
+        for (unsigned int a = 0; a < mesh->mNumBones; ++a) {
             mesh->mBones[a] = new aiBone();
-            ReadBinaryBone(stream,mesh->mBones[a]);
+            ReadBinaryBone(stream, mesh->mBones[a]);
         }
     }
 }
 
 // -----------------------------------------------------------------------------------
-void AssbinImporter::ReadBinaryMaterialProperty(IOStream * stream, aiMaterialProperty* prop) {
-    if(Read<uint32_t>(stream) != ASSBIN_CHUNK_AIMATERIALPROPERTY)
+void AssbinImporter::ReadBinaryMaterialProperty(IOStream *stream, aiMaterialProperty *prop) {
+    if (Read<uint32_t>(stream) != ASSBIN_CHUNK_AIMATERIALPROPERTY)
         throw DeadlyImportError("Magic chunk identifiers are wrong!");
-    /*uint32_t size =*/ Read<uint32_t>(stream);
+    /*uint32_t size =*/Read<uint32_t>(stream);
 
     prop->mKey = Read<aiString>(stream);
     prop->mSemantic = Read<unsigned int>(stream);
@@ -437,36 +438,34 @@ void AssbinImporter::ReadBinaryMaterialProperty(IOStream * stream, aiMaterialPro
 
     prop->mDataLength = Read<unsigned int>(stream);
     prop->mType = (aiPropertyTypeInfo)Read<unsigned int>(stream);
-    prop->mData = new char [ prop->mDataLength ];
-    stream->Read(prop->mData,1,prop->mDataLength);
+    prop->mData = new char[prop->mDataLength];
+    stream->Read(prop->mData, 1, prop->mDataLength);
 }
 
 // -----------------------------------------------------------------------------------
-void AssbinImporter::ReadBinaryMaterial(IOStream * stream, aiMaterial* mat) {
-    if(Read<uint32_t>(stream) != ASSBIN_CHUNK_AIMATERIAL)
+void AssbinImporter::ReadBinaryMaterial(IOStream *stream, aiMaterial *mat) {
+    if (Read<uint32_t>(stream) != ASSBIN_CHUNK_AIMATERIAL)
         throw DeadlyImportError("Magic chunk identifiers are wrong!");
-    /*uint32_t size =*/ Read<uint32_t>(stream);
+    /*uint32_t size =*/Read<uint32_t>(stream);
 
     mat->mNumAllocated = mat->mNumProperties = Read<unsigned int>(stream);
-    if (mat->mNumProperties)
-    {
-        if (mat->mProperties)
-        {
+    if (mat->mNumProperties) {
+        if (mat->mProperties) {
             delete[] mat->mProperties;
         }
-        mat->mProperties = new aiMaterialProperty*[mat->mNumProperties];
-        for (unsigned int i = 0; i < mat->mNumProperties;++i) {
+        mat->mProperties = new aiMaterialProperty *[mat->mNumProperties];
+        for (unsigned int i = 0; i < mat->mNumProperties; ++i) {
             mat->mProperties[i] = new aiMaterialProperty();
-            ReadBinaryMaterialProperty( stream, mat->mProperties[i]);
+            ReadBinaryMaterialProperty(stream, mat->mProperties[i]);
         }
     }
 }
 
 // -----------------------------------------------------------------------------------
-void AssbinImporter::ReadBinaryNodeAnim(IOStream * stream, aiNodeAnim* nd) {
-    if(Read<uint32_t>(stream) != ASSBIN_CHUNK_AINODEANIM)
+void AssbinImporter::ReadBinaryNodeAnim(IOStream *stream, aiNodeAnim *nd) {
+    if (Read<uint32_t>(stream) != ASSBIN_CHUNK_AINODEANIM)
         throw DeadlyImportError("Magic chunk identifiers are wrong!");
-    /*uint32_t size =*/ Read<uint32_t>(stream);
+    /*uint32_t size =*/Read<uint32_t>(stream);
 
     nd->mNodeName = Read<aiString>(stream);
     nd->mNumPositionKeys = Read<unsigned int>(stream);
@@ -477,82 +476,82 @@ void AssbinImporter::ReadBinaryNodeAnim(IOStream * stream, aiNodeAnim* nd) {
 
     if (nd->mNumPositionKeys) {
         if (shortened) {
-            ReadBounds(stream,nd->mPositionKeys,nd->mNumPositionKeys);
+            ReadBounds(stream, nd->mPositionKeys, nd->mNumPositionKeys);
 
         } // else write as usual
         else {
             nd->mPositionKeys = new aiVectorKey[nd->mNumPositionKeys];
-            ReadArray<aiVectorKey>(stream,nd->mPositionKeys,nd->mNumPositionKeys);
+            ReadArray<aiVectorKey>(stream, nd->mPositionKeys, nd->mNumPositionKeys);
         }
     }
     if (nd->mNumRotationKeys) {
         if (shortened) {
-            ReadBounds(stream,nd->mRotationKeys,nd->mNumRotationKeys);
+            ReadBounds(stream, nd->mRotationKeys, nd->mNumRotationKeys);
 
-        }  else {
+        } else {
             // else write as usual
             nd->mRotationKeys = new aiQuatKey[nd->mNumRotationKeys];
-            ReadArray<aiQuatKey>(stream,nd->mRotationKeys,nd->mNumRotationKeys);
+            ReadArray<aiQuatKey>(stream, nd->mRotationKeys, nd->mNumRotationKeys);
         }
     }
     if (nd->mNumScalingKeys) {
         if (shortened) {
-            ReadBounds(stream,nd->mScalingKeys,nd->mNumScalingKeys);
+            ReadBounds(stream, nd->mScalingKeys, nd->mNumScalingKeys);
 
-        }  else {
+        } else {
             // else write as usual
             nd->mScalingKeys = new aiVectorKey[nd->mNumScalingKeys];
-            ReadArray<aiVectorKey>(stream,nd->mScalingKeys,nd->mNumScalingKeys);
+            ReadArray<aiVectorKey>(stream, nd->mScalingKeys, nd->mNumScalingKeys);
         }
     }
 }
 
 // -----------------------------------------------------------------------------------
-void AssbinImporter::ReadBinaryAnim( IOStream * stream, aiAnimation* anim ) {
-    if(Read<uint32_t>(stream) != ASSBIN_CHUNK_AIANIMATION)
+void AssbinImporter::ReadBinaryAnim(IOStream *stream, aiAnimation *anim) {
+    if (Read<uint32_t>(stream) != ASSBIN_CHUNK_AIANIMATION)
         throw DeadlyImportError("Magic chunk identifiers are wrong!");
-    /*uint32_t size =*/ Read<uint32_t>(stream);
+    /*uint32_t size =*/Read<uint32_t>(stream);
 
-    anim->mName = Read<aiString> (stream);
-    anim->mDuration = Read<double> (stream);
-    anim->mTicksPerSecond = Read<double> (stream);
+    anim->mName = Read<aiString>(stream);
+    anim->mDuration = Read<double>(stream);
+    anim->mTicksPerSecond = Read<double>(stream);
     anim->mNumChannels = Read<unsigned int>(stream);
 
     if (anim->mNumChannels) {
-        anim->mChannels = new aiNodeAnim*[ anim->mNumChannels ];
-        for (unsigned int a = 0; a < anim->mNumChannels;++a) {
+        anim->mChannels = new aiNodeAnim *[anim->mNumChannels];
+        for (unsigned int a = 0; a < anim->mNumChannels; ++a) {
             anim->mChannels[a] = new aiNodeAnim();
-            ReadBinaryNodeAnim(stream,anim->mChannels[a]);
+            ReadBinaryNodeAnim(stream, anim->mChannels[a]);
         }
     }
 }
 
 // -----------------------------------------------------------------------------------
-void AssbinImporter::ReadBinaryTexture(IOStream * stream, aiTexture* tex) {
-    if(Read<uint32_t>(stream) != ASSBIN_CHUNK_AITEXTURE)
+void AssbinImporter::ReadBinaryTexture(IOStream *stream, aiTexture *tex) {
+    if (Read<uint32_t>(stream) != ASSBIN_CHUNK_AITEXTURE)
         throw DeadlyImportError("Magic chunk identifiers are wrong!");
-    /*uint32_t size =*/ Read<uint32_t>(stream);
+    /*uint32_t size =*/Read<uint32_t>(stream);
 
     tex->mWidth = Read<unsigned int>(stream);
     tex->mHeight = Read<unsigned int>(stream);
-    stream->Read( tex->achFormatHint, sizeof(char), 4 );
+    stream->Read(tex->achFormatHint, sizeof(char), HINTMAXTEXTURELEN - 1);
 
-    if(!shortened) {
+    if (!shortened) {
         if (!tex->mHeight) {
-            tex->pcData = new aiTexel[ tex->mWidth ];
-            stream->Read(tex->pcData,1,tex->mWidth);
+            tex->pcData = new aiTexel[tex->mWidth];
+            stream->Read(tex->pcData, 1, tex->mWidth);
         } else {
-            tex->pcData = new aiTexel[ tex->mWidth*tex->mHeight ];
-            stream->Read(tex->pcData,1,tex->mWidth*tex->mHeight*4);
+            tex->pcData = new aiTexel[tex->mWidth * tex->mHeight];
+            stream->Read(tex->pcData, 1, tex->mWidth * tex->mHeight * 4);
         }
     }
 }
 
 // -----------------------------------------------------------------------------------
-void AssbinImporter::ReadBinaryLight( IOStream * stream, aiLight* l ) {
-    if(Read<uint32_t>(stream) != ASSBIN_CHUNK_AILIGHT)
+void AssbinImporter::ReadBinaryLight(IOStream *stream, aiLight *l) {
+    if (Read<uint32_t>(stream) != ASSBIN_CHUNK_AILIGHT)
         throw DeadlyImportError("Magic chunk identifiers are wrong!");
-    /*uint32_t size =*/ Read<uint32_t>(stream);
+    /*uint32_t size =*/Read<uint32_t>(stream);
 
     l->mName = Read<aiString>(stream);
     l->mType = (aiLightSourceType)Read<unsigned int>(stream);
@@ -574,10 +573,10 @@ void AssbinImporter::ReadBinaryLight( IOStream * stream, aiLight* l ) {
 }
 
 // -----------------------------------------------------------------------------------
-void AssbinImporter::ReadBinaryCamera( IOStream * stream, aiCamera* cam ) {
-    if(Read<uint32_t>(stream) != ASSBIN_CHUNK_AICAMERA)
+void AssbinImporter::ReadBinaryCamera(IOStream *stream, aiCamera *cam) {
+    if (Read<uint32_t>(stream) != ASSBIN_CHUNK_AICAMERA)
         throw DeadlyImportError("Magic chunk identifiers are wrong!");
-    /*uint32_t size =*/ Read<uint32_t>(stream);
+    /*uint32_t size =*/Read<uint32_t>(stream);
 
     cam->mName = Read<aiString>(stream);
     cam->mPosition = Read<aiVector3D>(stream);
@@ -590,141 +589,139 @@ void AssbinImporter::ReadBinaryCamera( IOStream * stream, aiCamera* cam ) {
 }
 
 // -----------------------------------------------------------------------------------
-void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene ) {
-    if(Read<uint32_t>(stream) != ASSBIN_CHUNK_AISCENE)
+void AssbinImporter::ReadBinaryScene(IOStream *stream, aiScene *scene) {
+    if (Read<uint32_t>(stream) != ASSBIN_CHUNK_AISCENE)
         throw DeadlyImportError("Magic chunk identifiers are wrong!");
-    /*uint32_t size =*/ Read<uint32_t>(stream);
+    /*uint32_t size =*/Read<uint32_t>(stream);
 
-    scene->mFlags         = Read<unsigned int>(stream);
-    scene->mNumMeshes     = Read<unsigned int>(stream);
-    scene->mNumMaterials  = Read<unsigned int>(stream);
+    scene->mFlags = Read<unsigned int>(stream);
+    scene->mNumMeshes = Read<unsigned int>(stream);
+    scene->mNumMaterials = Read<unsigned int>(stream);
     scene->mNumAnimations = Read<unsigned int>(stream);
-    scene->mNumTextures   = Read<unsigned int>(stream);
-    scene->mNumLights     = Read<unsigned int>(stream);
-    scene->mNumCameras    = Read<unsigned int>(stream);
+    scene->mNumTextures = Read<unsigned int>(stream);
+    scene->mNumLights = Read<unsigned int>(stream);
+    scene->mNumCameras = Read<unsigned int>(stream);
 
     // Read node graph
     //scene->mRootNode = new aiNode[1];
-    ReadBinaryNode( stream, &scene->mRootNode, (aiNode*)NULL );
+    ReadBinaryNode(stream, &scene->mRootNode, (aiNode *)nullptr);
 
     // Read all meshes
     if (scene->mNumMeshes) {
-        scene->mMeshes = new aiMesh*[scene->mNumMeshes];
-        memset(scene->mMeshes, 0, scene->mNumMeshes*sizeof(aiMesh*));
-        for (unsigned int i = 0; i < scene->mNumMeshes;++i) {
+        scene->mMeshes = new aiMesh *[scene->mNumMeshes];
+        memset(scene->mMeshes, 0, scene->mNumMeshes * sizeof(aiMesh *));
+        for (unsigned int i = 0; i < scene->mNumMeshes; ++i) {
             scene->mMeshes[i] = new aiMesh();
-            ReadBinaryMesh( stream,scene->mMeshes[i]);
+            ReadBinaryMesh(stream, scene->mMeshes[i]);
         }
     }
 
     // Read materials
     if (scene->mNumMaterials) {
-        scene->mMaterials = new aiMaterial*[scene->mNumMaterials];
-        memset(scene->mMaterials, 0, scene->mNumMaterials*sizeof(aiMaterial*));
-        for (unsigned int i = 0; i< scene->mNumMaterials; ++i) {
+        scene->mMaterials = new aiMaterial *[scene->mNumMaterials];
+        memset(scene->mMaterials, 0, scene->mNumMaterials * sizeof(aiMaterial *));
+        for (unsigned int i = 0; i < scene->mNumMaterials; ++i) {
             scene->mMaterials[i] = new aiMaterial();
-            ReadBinaryMaterial(stream,scene->mMaterials[i]);
+            ReadBinaryMaterial(stream, scene->mMaterials[i]);
         }
     }
 
     // Read all animations
     if (scene->mNumAnimations) {
-        scene->mAnimations = new aiAnimation*[scene->mNumAnimations];
-        memset(scene->mAnimations, 0, scene->mNumAnimations*sizeof(aiAnimation*));
-        for (unsigned int i = 0; i < scene->mNumAnimations;++i) {
+        scene->mAnimations = new aiAnimation *[scene->mNumAnimations];
+        memset(scene->mAnimations, 0, scene->mNumAnimations * sizeof(aiAnimation *));
+        for (unsigned int i = 0; i < scene->mNumAnimations; ++i) {
             scene->mAnimations[i] = new aiAnimation();
-            ReadBinaryAnim(stream,scene->mAnimations[i]);
+            ReadBinaryAnim(stream, scene->mAnimations[i]);
         }
     }
 
     // Read all textures
     if (scene->mNumTextures) {
-        scene->mTextures = new aiTexture*[scene->mNumTextures];
-        memset(scene->mTextures, 0, scene->mNumTextures*sizeof(aiTexture*));
-        for (unsigned int i = 0; i < scene->mNumTextures;++i) {
+        scene->mTextures = new aiTexture *[scene->mNumTextures];
+        memset(scene->mTextures, 0, scene->mNumTextures * sizeof(aiTexture *));
+        for (unsigned int i = 0; i < scene->mNumTextures; ++i) {
             scene->mTextures[i] = new aiTexture();
-            ReadBinaryTexture(stream,scene->mTextures[i]);
+            ReadBinaryTexture(stream, scene->mTextures[i]);
         }
     }
 
     // Read lights
     if (scene->mNumLights) {
-        scene->mLights = new aiLight*[scene->mNumLights];
-        memset(scene->mLights, 0, scene->mNumLights*sizeof(aiLight*));
-        for (unsigned int i = 0; i < scene->mNumLights;++i) {
+        scene->mLights = new aiLight *[scene->mNumLights];
+        memset(scene->mLights, 0, scene->mNumLights * sizeof(aiLight *));
+        for (unsigned int i = 0; i < scene->mNumLights; ++i) {
             scene->mLights[i] = new aiLight();
-            ReadBinaryLight(stream,scene->mLights[i]);
+            ReadBinaryLight(stream, scene->mLights[i]);
         }
     }
 
     // Read cameras
     if (scene->mNumCameras) {
-        scene->mCameras = new aiCamera*[scene->mNumCameras];
-        memset(scene->mCameras, 0, scene->mNumCameras*sizeof(aiCamera*));
-        for (unsigned int i = 0; i < scene->mNumCameras;++i) {
+        scene->mCameras = new aiCamera *[scene->mNumCameras];
+        memset(scene->mCameras, 0, scene->mNumCameras * sizeof(aiCamera *));
+        for (unsigned int i = 0; i < scene->mNumCameras; ++i) {
             scene->mCameras[i] = new aiCamera();
-            ReadBinaryCamera(stream,scene->mCameras[i]);
+            ReadBinaryCamera(stream, scene->mCameras[i]);
         }
     }
-
 }
 
 // -----------------------------------------------------------------------------------
-void AssbinImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler ) {
-    IOStream * stream = pIOHandler->Open(pFile,"rb");
+void AssbinImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
+    IOStream *stream = pIOHandler->Open(pFile, "rb");
     if (nullptr == stream) {
-        return;
+        throw DeadlyImportError("ASSBIN: Could not open ", pFile);
     }
 
     // signature
-    stream->Seek( 44, aiOrigin_CUR );
+    stream->Seek(44, aiOrigin_CUR);
 
     unsigned int versionMajor = Read<unsigned int>(stream);
     unsigned int versionMinor = Read<unsigned int>(stream);
     if (versionMinor != ASSBIN_VERSION_MINOR || versionMajor != ASSBIN_VERSION_MAJOR) {
-        throw DeadlyImportError( "Invalid version, data format not compatible!" );
+        throw DeadlyImportError("Invalid version, data format not compatible!");
     }
 
-    /*unsigned int versionRevision =*/ Read<unsigned int>(stream);
-    /*unsigned int compileFlags =*/ Read<unsigned int>(stream);
+    /*unsigned int versionRevision =*/Read<unsigned int>(stream);
+    /*unsigned int compileFlags =*/Read<unsigned int>(stream);
 
     shortened = Read<uint16_t>(stream) > 0;
     compressed = Read<uint16_t>(stream) > 0;
 
     if (shortened)
-        throw DeadlyImportError( "Shortened binaries are not supported!" );
+        throw DeadlyImportError("Shortened binaries are not supported!");
 
-    stream->Seek( 256, aiOrigin_CUR ); // original filename
-    stream->Seek( 128, aiOrigin_CUR ); // options
-    stream->Seek( 64, aiOrigin_CUR ); // padding
+    stream->Seek(256, aiOrigin_CUR); // original filename
+    stream->Seek(128, aiOrigin_CUR); // options
+    stream->Seek(64, aiOrigin_CUR); // padding
 
     if (compressed) {
         uLongf uncompressedSize = Read<uint32_t>(stream);
         uLongf compressedSize = static_cast<uLongf>(stream->FileSize() - stream->Tell());
 
-        unsigned char * compressedData = new unsigned char[ compressedSize ];
-        size_t len = stream->Read( compressedData, 1, compressedSize );
+        unsigned char *compressedData = new unsigned char[compressedSize];
+        size_t len = stream->Read(compressedData, 1, compressedSize);
         ai_assert(len == compressedSize);
 
-        unsigned char * uncompressedData = new unsigned char[ uncompressedSize ];
+        unsigned char *uncompressedData = new unsigned char[uncompressedSize];
 
-        int res = uncompress( uncompressedData, &uncompressedSize, compressedData, (uLong) len );
-        if(res != Z_OK)
-        {
-            delete [] uncompressedData;
-            delete [] compressedData;
+        int res = uncompress(uncompressedData, &uncompressedSize, compressedData, (uLong)len);
+        if (res != Z_OK) {
+            delete[] uncompressedData;
+            delete[] compressedData;
             pIOHandler->Close(stream);
             throw DeadlyImportError("Zlib decompression failed.");
         }
 
-        MemoryIOStream io( uncompressedData, uncompressedSize );
+        MemoryIOStream io(uncompressedData, uncompressedSize);
 
-        ReadBinaryScene(&io,pScene);
+        ReadBinaryScene(&io, pScene);
 
         delete[] uncompressedData;
         delete[] compressedData;
     } else {
-        ReadBinaryScene(stream,pScene);
+        ReadBinaryScene(stream, pScene);
     }
 
     pIOHandler->Close(stream);
diff --git a/Engine/lib/assimp/code/Assbin/AssbinLoader.h b/Engine/lib/assimp/code/AssetLib/Assbin/AssbinLoader.h
similarity index 90%
rename from Engine/lib/assimp/code/Assbin/AssbinLoader.h
rename to Engine/lib/assimp/code/AssetLib/Assbin/AssbinLoader.h
index 9f2dde125..f922b91fd 100644
--- a/Engine/lib/assimp/code/Assbin/AssbinLoader.h
+++ b/Engine/lib/assimp/code/AssetLib/Assbin/AssbinLoader.h
@@ -3,8 +3,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -74,17 +73,11 @@ private:
     bool compressed;
 
 public:
-    virtual bool CanRead(
-        const std::string& pFile,
-        IOSystem* pIOHandler,
-        bool checkSig
-    ) const;
-    virtual const aiImporterDesc* GetInfo() const;
-    virtual void InternReadFile(
-    const std::string& pFile,
-        aiScene* pScene,
-        IOSystem* pIOHandler
-    );
+    bool CanRead(const std::string& pFile,
+        IOSystem* pIOHandler, bool checkSig) const override;
+    const aiImporterDesc* GetInfo() const override;
+    void InternReadFile(
+    const std::string& pFile,aiScene* pScene,IOSystem* pIOHandler) override;
     void ReadHeader();
     void ReadBinaryScene( IOStream * stream, aiScene* pScene );
     void ReadBinaryNode( IOStream * stream, aiNode** mRootNode, aiNode* parent );
diff --git a/Engine/lib/assimp/code/Assjson/cencode.c b/Engine/lib/assimp/code/AssetLib/Assjson/cencode.c
similarity index 87%
rename from Engine/lib/assimp/code/Assjson/cencode.c
rename to Engine/lib/assimp/code/AssetLib/Assjson/cencode.c
index db99e7efa..614a2671f 100644
--- a/Engine/lib/assimp/code/Assjson/cencode.c
+++ b/Engine/lib/assimp/code/AssetLib/Assjson/cencode.c
@@ -9,6 +9,11 @@ For details, see http://sourceforge.net/projects/libb64
 
 const int CHARS_PER_LINE = 72;
 
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4244)
+#endif // _MSC_VER
+
 void base64_init_encodestate(base64_encodestate* state_in)
 {
 	state_in->step = step_A;
@@ -30,9 +35,9 @@ int base64_encode_block(const char* plaintext_in, int length_in, char* code_out,
 	char* codechar = code_out;
 	char result;
 	char fragment;
-	
+
 	result = state_in->result;
-	
+
 	switch (state_in->step)
 	{
 		while (1)
@@ -42,7 +47,7 @@ int base64_encode_block(const char* plaintext_in, int length_in, char* code_out,
 			{
 				state_in->result = result;
 				state_in->step = step_A;
-				return codechar - code_out;
+				return (int)(codechar - code_out);
 			}
 			fragment = *plainchar++;
 			result = (fragment & 0x0fc) >> 2;
@@ -53,7 +58,7 @@ int base64_encode_block(const char* plaintext_in, int length_in, char* code_out,
 			{
 				state_in->result = result;
 				state_in->step = step_B;
-				return codechar - code_out;
+				return (int)(codechar - code_out);
 			}
 			fragment = *plainchar++;
 			result |= (fragment & 0x0f0) >> 4;
@@ -64,14 +69,14 @@ int base64_encode_block(const char* plaintext_in, int length_in, char* code_out,
 			{
 				state_in->result = result;
 				state_in->step = step_C;
-				return codechar - code_out;
+				return (int)(codechar - code_out);
 			}
 			fragment = *plainchar++;
 			result |= (fragment & 0x0c0) >> 6;
 			*codechar++ = base64_encode_value(result);
 			result  = (fragment & 0x03f) >> 0;
 			*codechar++ = base64_encode_value(result);
-			
+
 			++(state_in->stepcount);
 			if (state_in->stepcount == CHARS_PER_LINE/4)
 			{
@@ -81,13 +86,13 @@ int base64_encode_block(const char* plaintext_in, int length_in, char* code_out,
 		}
 	}
 	/* control should not reach here */
-	return codechar - code_out;
+	return (int)(codechar - code_out);
 }
 
 int base64_encode_blockend(char* code_out, base64_encodestate* state_in)
 {
 	char* codechar = code_out;
-	
+
 	switch (state_in->step)
 	{
 	case step_B:
@@ -103,7 +108,10 @@ int base64_encode_blockend(char* code_out, base64_encodestate* state_in)
 		break;
 	}
 	*codechar++ = '\n';
-	
-	return codechar - code_out;
+
+	return (int)(codechar - code_out);
 }
 
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif // _MSC_VER
diff --git a/Engine/lib/assimp/code/Assjson/cencode.h b/Engine/lib/assimp/code/AssetLib/Assjson/cencode.h
similarity index 91%
rename from Engine/lib/assimp/code/Assjson/cencode.h
rename to Engine/lib/assimp/code/AssetLib/Assjson/cencode.h
index c1e3464af..a7893c434 100644
--- a/Engine/lib/assimp/code/Assjson/cencode.h
+++ b/Engine/lib/assimp/code/AssetLib/Assjson/cencode.h
@@ -8,6 +8,10 @@ For details, see http://sourceforge.net/projects/libb64
 #ifndef BASE64_CENCODE_H
 #define BASE64_CENCODE_H
 
+#ifdef _MSC_VER
+#pragma warning(disable : 4127 )
+#endif // _MSC_VER
+
 typedef enum
 {
 	step_A, step_B, step_C
diff --git a/Engine/lib/assimp/code/Assjson/json_exporter.cpp b/Engine/lib/assimp/code/AssetLib/Assjson/json_exporter.cpp
similarity index 77%
rename from Engine/lib/assimp/code/Assjson/json_exporter.cpp
rename to Engine/lib/assimp/code/AssetLib/Assjson/json_exporter.cpp
index e9fa72496..7b2c8ec81 100644
--- a/Engine/lib/assimp/code/Assjson/json_exporter.cpp
+++ b/Engine/lib/assimp/code/AssetLib/Assjson/json_exporter.cpp
@@ -9,30 +9,31 @@ Licensed under a 3-clause BSD license. See the LICENSE file for more information
 #ifndef ASSIMP_BUILD_NO_EXPORT
 #ifndef ASSIMP_BUILD_NO_ASSJSON_EXPORTER
 
-#include <assimp/Importer.hpp>
+#include <assimp/scene.h>
 #include <assimp/Exporter.hpp>
 #include <assimp/IOStream.hpp>
 #include <assimp/IOSystem.hpp>
-#include <assimp/scene.h>
+#include <assimp/Importer.hpp>
+#include <assimp/Exceptional.h>
 
-#include <sstream>
-#include <limits>
 #include <cassert>
+#include <limits>
 #include <memory>
+#include <sstream>
 
 #define CURRENT_FORMAT_VERSION 100
 
-// grab scoped_ptr from assimp to avoid a dependency on boost. 
+// grab scoped_ptr from assimp to avoid a dependency on boost.
 //#include <assimp/../../code/BoostWorkaround/boost/scoped_ptr.hpp>
 
 #include "mesh_splitter.h"
 
 extern "C" {
-    #include "cencode.h"
+#include "cencode.h"
 }
 namespace Assimp {
 
-void ExportAssimp2Json(const char*, Assimp::IOSystem*, const aiScene*, const Assimp::ExportProperties*);
+void ExportAssimp2Json(const char *, Assimp::IOSystem *, const aiScene *, const Assimp::ExportProperties *);
 
 // small utility class to simplify serializing the aiScene to Json
 class JSONWriter {
@@ -40,14 +41,17 @@ public:
     enum {
         Flag_DoNotIndent = 0x1,
         Flag_WriteSpecialFloats = 0x2,
+        Flag_SkipWhitespaces = 0x4
     };
-
-    JSONWriter(Assimp::IOStream& out, unsigned int flags = 0u)
-    : out(out)
-    , first()
-    , flags(flags) {
+    
+    JSONWriter(Assimp::IOStream &out, unsigned int flags = 0u) :
+            out(out), indent (""), newline("\n"), space(" "), buff (), first(false), flags(flags) {
         // make sure that all formatting happens using the standard, C locale and not the user's current locale
         buff.imbue(std::locale("C"));
+        if (flags & Flag_SkipWhitespaces) {
+            newline = "";
+            space = "";
+        }
     }
 
     ~JSONWriter() {
@@ -68,43 +72,43 @@ public:
         indent.erase(indent.end() - 1);
     }
 
-    void Key(const std::string& name) {
+    void Key(const std::string &name) {
         AddIndentation();
         Delimit();
-        buff << '\"' + name + "\": ";
+        buff << '\"' + name + "\":" << space;
     }
 
-    template<typename Literal>
-    void Element(const Literal& name) {
+    template <typename Literal>
+    void Element(const Literal &name) {
         AddIndentation();
         Delimit();
 
-        LiteralToString(buff, name) << '\n';
+        LiteralToString(buff, name) << newline;
     }
 
-    template<typename Literal>
-    void SimpleValue(const Literal& s) {
-        LiteralToString(buff, s) << '\n';
+    template <typename Literal>
+    void SimpleValue(const Literal &s) {
+        LiteralToString(buff, s) << newline;
     }
 
-    void SimpleValue(const void* buffer, size_t len) {
+    void SimpleValue(const void *buffer, size_t len) {
         base64_encodestate s;
         base64_init_encodestate(&s);
 
-        char* const out = new char[std::max(len * 2, static_cast<size_t>(16u))];
-        const int n = base64_encode_block(reinterpret_cast<const char*>(buffer), static_cast<int>(len), out, &s);
-        out[n + base64_encode_blockend(out + n, &s)] = '\0';
+        char *const cur_out = new char[std::max(len * 2, static_cast<size_t>(16u))];
+        const int n = base64_encode_block(reinterpret_cast<const char *>(buffer), static_cast<int>(len), cur_out, &s);
+        cur_out[n + base64_encode_blockend(cur_out + n, &s)] = '\0';
 
         // base64 encoding may add newlines, but JSON strings may not contain 'real' newlines
         // (only escaped ones). Remove any newlines in out.
-        for (char* cur = out; *cur; ++cur) {
+        for (char *cur = cur_out; *cur; ++cur) {
             if (*cur == '\n') {
                 *cur = ' ';
             }
         }
 
-        buff << '\"' << out << "\"\n";
-        delete[] out;
+        buff << '\"' << cur_out << "\"" << newline;
+        delete[] cur_out;
     }
 
     void StartObj(bool is_element = false) {
@@ -116,7 +120,7 @@ public:
             }
         }
         first = true;
-        buff << "{\n";
+        buff << "{" << newline;
         PushIndent();
     }
 
@@ -124,7 +128,7 @@ public:
         PopIndent();
         AddIndentation();
         first = false;
-        buff << "}\n";
+        buff << "}" << newline;
     }
 
     void StartArray(bool is_element = false) {
@@ -136,19 +140,19 @@ public:
             }
         }
         first = true;
-        buff << "[\n";
+        buff << "[" << newline;
         PushIndent();
     }
 
     void EndArray() {
         PopIndent();
         AddIndentation();
-        buff << "]\n";
+        buff << "]" << newline;
         first = false;
     }
 
     void AddIndentation() {
-        if (!(flags & Flag_DoNotIndent)) {
+        if (!(flags & Flag_DoNotIndent) && !(flags & Flag_SkipWhitespaces)) {
             buff << indent;
         }
     }
@@ -156,21 +160,20 @@ public:
     void Delimit() {
         if (!first) {
             buff << ',';
-        }
-        else {
-            buff << ' ';
+        } else {
+            buff << space;
             first = false;
         }
     }
 
 private:
-    template<typename Literal>
-    std::stringstream& LiteralToString(std::stringstream& stream, const Literal& s) {
+    template <typename Literal>
+    std::stringstream &LiteralToString(std::stringstream &stream, const Literal &s) {
         stream << s;
         return stream;
     }
 
-    std::stringstream& LiteralToString(std::stringstream& stream, const aiString& s) {
+    std::stringstream &LiteralToString(std::stringstream &stream, const aiString &s) {
         std::string t;
 
         // escape backslashes and single quotes, both would render the JSON invalid if left as is
@@ -189,10 +192,10 @@ private:
         return stream;
     }
 
-    std::stringstream& LiteralToString(std::stringstream& stream, float f) {
+    std::stringstream &LiteralToString(std::stringstream &stream, float f) {
         if (!std::numeric_limits<float>::is_iec559) {
             // on a non IEEE-754 platform, we make no assumptions about the representation or existence
-            // of special floating-point numbers. 
+            // of special floating-point numbers.
             stream << f;
             return stream;
         }
@@ -228,15 +231,17 @@ private:
     }
 
 private:
-    Assimp::IOStream& out;
-    std::string indent, newline;
+    Assimp::IOStream &out;
+    std::string indent;
+    std::string newline;
+    std::string space;
     std::stringstream buff;
     bool first;
 
     unsigned int flags;
 };
 
-void Write(JSONWriter& out, const aiVector3D& ai, bool is_elem = true) {
+void Write(JSONWriter &out, const aiVector3D &ai, bool is_elem = true) {
     out.StartArray(is_elem);
     out.Element(ai.x);
     out.Element(ai.y);
@@ -244,7 +249,7 @@ void Write(JSONWriter& out, const aiVector3D& ai, bool is_elem = true) {
     out.EndArray();
 }
 
-void Write(JSONWriter& out, const aiQuaternion& ai, bool is_elem = true) {
+void Write(JSONWriter &out, const aiQuaternion &ai, bool is_elem = true) {
     out.StartArray(is_elem);
     out.Element(ai.w);
     out.Element(ai.x);
@@ -253,7 +258,7 @@ void Write(JSONWriter& out, const aiQuaternion& ai, bool is_elem = true) {
     out.EndArray();
 }
 
-void Write(JSONWriter& out, const aiColor3D& ai, bool is_elem = true) {
+void Write(JSONWriter &out, const aiColor3D &ai, bool is_elem = true) {
     out.StartArray(is_elem);
     out.Element(ai.r);
     out.Element(ai.g);
@@ -261,7 +266,7 @@ void Write(JSONWriter& out, const aiColor3D& ai, bool is_elem = true) {
     out.EndArray();
 }
 
-void Write(JSONWriter& out, const aiMatrix4x4& ai, bool is_elem = true) {
+void Write(JSONWriter &out, const aiMatrix4x4 &ai, bool is_elem = true) {
     out.StartArray(is_elem);
     for (unsigned int x = 0; x < 4; ++x) {
         for (unsigned int y = 0; y < 4; ++y) {
@@ -271,7 +276,7 @@ void Write(JSONWriter& out, const aiMatrix4x4& ai, bool is_elem = true) {
     out.EndArray();
 }
 
-void Write(JSONWriter& out, const aiBone& ai, bool is_elem = true) {
+void Write(JSONWriter &out, const aiBone &ai, bool is_elem = true) {
     out.StartObj(is_elem);
 
     out.Key("name");
@@ -292,7 +297,7 @@ void Write(JSONWriter& out, const aiBone& ai, bool is_elem = true) {
     out.EndObj();
 }
 
-void Write(JSONWriter& out, const aiFace& ai, bool is_elem = true) {
+void Write(JSONWriter &out, const aiFace &ai, bool is_elem = true) {
     out.StartArray(is_elem);
     for (unsigned int i = 0; i < ai.mNumIndices; ++i) {
         out.Element(ai.mIndices[i]);
@@ -300,7 +305,7 @@ void Write(JSONWriter& out, const aiFace& ai, bool is_elem = true) {
     out.EndArray();
 }
 
-void Write(JSONWriter& out, const aiMesh& ai, bool is_elem = true) {
+void Write(JSONWriter &out, const aiMesh &ai, bool is_elem = true) {
     out.StartObj(is_elem);
 
     out.Key("name");
@@ -411,7 +416,7 @@ void Write(JSONWriter& out, const aiMesh& ai, bool is_elem = true) {
     out.EndObj();
 }
 
-void Write(JSONWriter& out, const aiNode& ai, bool is_elem = true) {
+void Write(JSONWriter &out, const aiNode &ai, bool is_elem = true) {
     out.StartObj(is_elem);
 
     out.Key("name");
@@ -441,13 +446,13 @@ void Write(JSONWriter& out, const aiNode& ai, bool is_elem = true) {
     out.EndObj();
 }
 
-void Write(JSONWriter& out, const aiMaterial& ai, bool is_elem = true) {
+void Write(JSONWriter &out, const aiMaterial &ai, bool is_elem = true) {
     out.StartObj(is_elem);
 
     out.Key("properties");
     out.StartArray();
     for (unsigned int i = 0; i < ai.mNumProperties; ++i) {
-        const aiMaterialProperty* const prop = ai.mProperties[i];
+        const aiMaterialProperty *const prop = ai.mProperties[i];
         out.StartObj(true);
         out.Key("key");
         out.SimpleValue(prop->mKey);
@@ -461,46 +466,41 @@ void Write(JSONWriter& out, const aiMaterial& ai, bool is_elem = true) {
 
         out.Key("value");
         switch (prop->mType) {
-            case aiPTI_Float:
-                if (prop->mDataLength / sizeof(float) > 1) {
-                    out.StartArray();
-                    for (unsigned int i = 0; i < prop->mDataLength / sizeof(float); ++i) {
-                        out.Element(reinterpret_cast<float*>(prop->mData)[i]);
-                    }
-                    out.EndArray();
+        case aiPTI_Float:
+            if (prop->mDataLength / sizeof(float) > 1) {
+                out.StartArray();
+                for (unsigned int ii = 0; ii < prop->mDataLength / sizeof(float); ++ii) {
+                    out.Element(reinterpret_cast<float *>(prop->mData)[ii]);
                 }
-                else {
-                    out.SimpleValue(*reinterpret_cast<float*>(prop->mData));
-                }
-                break;
+                out.EndArray();
+            } else {
+                out.SimpleValue(*reinterpret_cast<float *>(prop->mData));
+            }
+            break;
 
-            case aiPTI_Integer:
-                if (prop->mDataLength / sizeof(int) > 1) {
-                    out.StartArray();
-                    for (unsigned int i = 0; i < prop->mDataLength / sizeof(int); ++i) {
-                        out.Element(reinterpret_cast<int*>(prop->mData)[i]);
-                    }
-                    out.EndArray();
-                } else {
-                    out.SimpleValue(*reinterpret_cast<int*>(prop->mData));
+        case aiPTI_Integer:
+            if (prop->mDataLength / sizeof(int) > 1) {
+                out.StartArray();
+                for (unsigned int ii = 0; ii < prop->mDataLength / sizeof(int); ++ii) {
+                    out.Element(reinterpret_cast<int *>(prop->mData)[ii]);
                 }
-                break;
+                out.EndArray();
+            } else {
+                out.SimpleValue(*reinterpret_cast<int *>(prop->mData));
+            }
+            break;
 
-            case aiPTI_String:
-                {
-                    aiString s;
-                    aiGetMaterialString(&ai, prop->mKey.data, prop->mSemantic, prop->mIndex, &s);
-                    out.SimpleValue(s);
-                }
-                break;
-            case aiPTI_Buffer:
-                {
-                    // binary data is written as series of hex-encoded octets
-                    out.SimpleValue(prop->mData, prop->mDataLength);
-                }
-                break;
-            default:
-                assert(false);
+        case aiPTI_String: {
+            aiString s;
+            aiGetMaterialString(&ai, prop->mKey.data, prop->mSemantic, prop->mIndex, &s);
+            out.SimpleValue(s);
+        } break;
+        case aiPTI_Buffer: {
+            // binary data is written as series of hex-encoded octets
+            out.SimpleValue(prop->mData, prop->mDataLength);
+        } break;
+        default:
+            assert(false);
         }
 
         out.EndObj();
@@ -510,7 +510,7 @@ void Write(JSONWriter& out, const aiMaterial& ai, bool is_elem = true) {
     out.EndObj();
 }
 
-void Write(JSONWriter& out, const aiTexture& ai, bool is_elem = true) {
+void Write(JSONWriter &out, const aiTexture &ai, bool is_elem = true) {
     out.StartObj(is_elem);
 
     out.Key("width");
@@ -525,13 +525,12 @@ void Write(JSONWriter& out, const aiTexture& ai, bool is_elem = true) {
     out.Key("data");
     if (!ai.mHeight) {
         out.SimpleValue(ai.pcData, ai.mWidth);
-    }
-    else {
+    } else {
         out.StartArray();
         for (unsigned int y = 0; y < ai.mHeight; ++y) {
             out.StartArray(true);
             for (unsigned int x = 0; x < ai.mWidth; ++x) {
-                const aiTexel& tx = ai.pcData[y*ai.mWidth + x];
+                const aiTexel &tx = ai.pcData[y * ai.mWidth + x];
                 out.StartArray(true);
                 out.Element(static_cast<unsigned int>(tx.r));
                 out.Element(static_cast<unsigned int>(tx.g));
@@ -547,7 +546,7 @@ void Write(JSONWriter& out, const aiTexture& ai, bool is_elem = true) {
     out.EndObj();
 }
 
-void Write(JSONWriter& out, const aiLight& ai, bool is_elem = true) {
+void Write(JSONWriter &out, const aiLight &ai, bool is_elem = true) {
     out.StartObj(is_elem);
 
     out.Key("name");
@@ -585,7 +584,6 @@ void Write(JSONWriter& out, const aiLight& ai, bool is_elem = true) {
     if (ai.mType != aiLightSource_POINT) {
         out.Key("direction");
         Write(out, ai.mDirection, false);
-
     }
 
     if (ai.mType != aiLightSource_DIRECTIONAL) {
@@ -596,7 +594,7 @@ void Write(JSONWriter& out, const aiLight& ai, bool is_elem = true) {
     out.EndObj();
 }
 
-void Write(JSONWriter& out, const aiNodeAnim& ai, bool is_elem = true) {
+void Write(JSONWriter &out, const aiNodeAnim &ai, bool is_elem = true) {
     out.StartObj(is_elem);
 
     out.Key("name");
@@ -612,7 +610,7 @@ void Write(JSONWriter& out, const aiNodeAnim& ai, bool is_elem = true) {
         out.Key("positionkeys");
         out.StartArray();
         for (unsigned int n = 0; n < ai.mNumPositionKeys; ++n) {
-            const aiVectorKey& pos = ai.mPositionKeys[n];
+            const aiVectorKey &pos = ai.mPositionKeys[n];
             out.StartArray(true);
             out.Element(pos.mTime);
             Write(out, pos.mValue);
@@ -625,7 +623,7 @@ void Write(JSONWriter& out, const aiNodeAnim& ai, bool is_elem = true) {
         out.Key("rotationkeys");
         out.StartArray();
         for (unsigned int n = 0; n < ai.mNumRotationKeys; ++n) {
-            const aiQuatKey& rot = ai.mRotationKeys[n];
+            const aiQuatKey &rot = ai.mRotationKeys[n];
             out.StartArray(true);
             out.Element(rot.mTime);
             Write(out, rot.mValue);
@@ -638,7 +636,7 @@ void Write(JSONWriter& out, const aiNodeAnim& ai, bool is_elem = true) {
         out.Key("scalingkeys");
         out.StartArray();
         for (unsigned int n = 0; n < ai.mNumScalingKeys; ++n) {
-            const aiVectorKey& scl = ai.mScalingKeys[n];
+            const aiVectorKey &scl = ai.mScalingKeys[n];
             out.StartArray(true);
             out.Element(scl.mTime);
             Write(out, scl.mValue);
@@ -649,7 +647,7 @@ void Write(JSONWriter& out, const aiNodeAnim& ai, bool is_elem = true) {
     out.EndObj();
 }
 
-void Write(JSONWriter& out, const aiAnimation& ai, bool is_elem = true) {
+void Write(JSONWriter &out, const aiAnimation &ai, bool is_elem = true) {
     out.StartObj(is_elem);
 
     out.Key("name");
@@ -670,7 +668,7 @@ void Write(JSONWriter& out, const aiAnimation& ai, bool is_elem = true) {
     out.EndObj();
 }
 
-void Write(JSONWriter& out, const aiCamera& ai, bool is_elem = true) {
+void Write(JSONWriter &out, const aiCamera &ai, bool is_elem = true) {
     out.StartObj(is_elem);
 
     out.Key("name");
@@ -697,7 +695,7 @@ void Write(JSONWriter& out, const aiCamera& ai, bool is_elem = true) {
     out.EndObj();
 }
 
-void WriteFormatInfo(JSONWriter& out) {
+void WriteFormatInfo(JSONWriter &out) {
     out.StartObj();
     out.Key("format");
     out.SimpleValue("\"assimp2json\"");
@@ -706,7 +704,7 @@ void WriteFormatInfo(JSONWriter& out) {
     out.EndObj();
 }
 
-void Write(JSONWriter& out, const aiScene& ai) {
+void Write(JSONWriter &out, const aiScene &ai) {
     out.StartObj();
 
     out.Key("__metadata__");
@@ -774,15 +772,14 @@ void Write(JSONWriter& out, const aiScene& ai) {
     out.EndObj();
 }
 
-
-void ExportAssimp2Json(const char* file, Assimp::IOSystem* io, const aiScene* scene, const Assimp::ExportProperties*) {
+void ExportAssimp2Json(const char *file, Assimp::IOSystem *io, const aiScene *scene, const Assimp::ExportProperties *pProperties) {
     std::unique_ptr<Assimp::IOStream> str(io->Open(file, "wt"));
     if (!str) {
-        //throw Assimp::DeadlyExportError("could not open output file");
+        throw DeadlyExportError("could not open output file");
     }
 
     // get a copy of the scene so we can modify it
-    aiScene* scenecopy_tmp;
+    aiScene *scenecopy_tmp;
     aiCopyScene(scene, &scenecopy_tmp);
 
     try {
@@ -792,18 +789,22 @@ void ExportAssimp2Json(const char* file, Assimp::IOSystem* io, const aiScene* sc
         splitter.Execute(scenecopy_tmp);
 
         // XXX Flag_WriteSpecialFloats is turned on by default, right now we don't have a configuration interface for exporters
-        JSONWriter s(*str, JSONWriter::Flag_WriteSpecialFloats);
+
+        unsigned int flags = JSONWriter::Flag_WriteSpecialFloats;
+        if (pProperties->GetPropertyBool("JSON_SKIP_WHITESPACES", false)) {
+            flags |= JSONWriter::Flag_SkipWhitespaces;
+        }
+        JSONWriter s(*str, flags);
         Write(s, *scenecopy_tmp);
 
-    }
-    catch (...) {
+    } catch (...) {
         aiFreeScene(scenecopy_tmp);
         throw;
     }
     aiFreeScene(scenecopy_tmp);
 }
 
-}
+} // namespace Assimp
 
 #endif // ASSIMP_BUILD_NO_ASSJSON_EXPORTER
 #endif // ASSIMP_BUILD_NO_EXPORT
diff --git a/Engine/lib/assimp/code/Assjson/mesh_splitter.cpp b/Engine/lib/assimp/code/AssetLib/Assjson/mesh_splitter.cpp
similarity index 96%
rename from Engine/lib/assimp/code/Assjson/mesh_splitter.cpp
rename to Engine/lib/assimp/code/AssetLib/Assjson/mesh_splitter.cpp
index 24385f9a0..978437c41 100644
--- a/Engine/lib/assimp/code/Assjson/mesh_splitter.cpp
+++ b/Engine/lib/assimp/code/AssetLib/Assjson/mesh_splitter.cpp
@@ -69,13 +69,12 @@ void MeshSplitter::UpdateNode(aiNode* pcNode, const std::vector<std::pair<aiMesh
 	for (unsigned int i = 0, end = pcNode->mNumChildren; i < end;++i)	{
 		UpdateNode ( pcNode->mChildren[i], source_mesh_map );
 	}
-	return;
 }
 
-#define WAS_NOT_COPIED 0xffffffff
+static const unsigned int WAS_NOT_COPIED = 0xffffffff;
 
-typedef std::pair <unsigned int,float> PerVertexWeight;
-typedef std::vector	<PerVertexWeight> VertexWeightTable;
+using PerVertexWeight = std::pair <unsigned int,float>;
+using VertexWeightTable = std::vector	<PerVertexWeight>;
 
 // ------------------------------------------------------------------------------------------------
 VertexWeightTable* ComputeVertexBoneWeightTable(const aiMesh* pMesh) {
@@ -89,7 +88,7 @@ VertexWeightTable* ComputeVertexBoneWeightTable(const aiMesh* pMesh) {
 		aiBone* bone = pMesh->mBones[i];
 		for (unsigned int a = 0; a < bone->mNumWeights;++a)	{
 			const aiVertexWeight& weight = bone->mWeights[a];
-			avPerVertexWeights[weight.mVertexId].push_back( std::make_pair(i,weight.mWeight) );
+			avPerVertexWeights[weight.mVertexId].emplace_back(i,weight.mWeight);
 		}
 	}
 	return avPerVertexWeights;
@@ -100,7 +99,7 @@ void MeshSplitter :: SplitMesh(unsigned int a, aiMesh* in_mesh, std::vector<std:
 	// TODO: should better use std::(multi)set for source_mesh_map.
 
 	if (in_mesh->mNumVertices <= LIMIT)	{
-		source_mesh_map.push_back(std::make_pair(in_mesh,a));
+		source_mesh_map.emplace_back(in_mesh,a);
 		return;
 	}
 
@@ -110,7 +109,7 @@ void MeshSplitter :: SplitMesh(unsigned int a, aiMesh* in_mesh, std::vector<std:
 	// we need to split this mesh into sub meshes. Estimate submesh size
 	const unsigned int sub_meshes = (in_mesh->mNumVertices / LIMIT) + 1;
 
-	// create a std::vector<unsigned int> to remember which vertices have already 
+	// create a std::vector<unsigned int> to remember which vertices have already
 	// been copied and to which position (i.e. output index)
 	std::vector<unsigned int> was_copied_to;
 	was_copied_to.resize(in_mesh->mNumVertices,WAS_NOT_COPIED);
@@ -125,7 +124,7 @@ void MeshSplitter :: SplitMesh(unsigned int a, aiMesh* in_mesh, std::vector<std:
 	while (true) {
 		const unsigned int out_vertex_index = LIMIT;
 
-		aiMesh* out_mesh = new aiMesh();			
+		aiMesh* out_mesh = new aiMesh();
 		out_mesh->mNumVertices = 0;
 		out_mesh->mMaterialIndex = in_mesh->mMaterialIndex;
 
@@ -179,7 +178,7 @@ void MeshSplitter :: SplitMesh(unsigned int a, aiMesh* in_mesh, std::vector<std:
 
 				// check whether we do already have this vertex
 				if (WAS_NOT_COPIED == was_copied_to[index])	{
-					iNeed++; 
+					iNeed++;
 				}
 			}
 			if (out_mesh->mNumVertices + iNeed > out_vertex_index)	{
@@ -187,7 +186,7 @@ void MeshSplitter :: SplitMesh(unsigned int a, aiMesh* in_mesh, std::vector<std:
 				break;
 			}
 
-			vFaces.push_back(aiFace());
+			vFaces.emplace_back();
 			aiFace& rFace = vFaces.back();
 
 			// setup face type and number of indices
@@ -240,7 +239,7 @@ void MeshSplitter :: SplitMesh(unsigned int a, aiMesh* in_mesh, std::vector<std:
 						out_mesh->mTextureCoords[c][out_mesh->mNumVertices] = in_mesh->mTextureCoords[c][index];
 					}
 				}
-				// vertex colors 
+				// vertex colors
 				for (unsigned int c = 0;  c < AI_MAX_NUMBER_OF_COLOR_SETS;++c) {
 					if (in_mesh->HasVertexColors( c)) {
 						out_mesh->mColors[c][out_mesh->mNumVertices] = in_mesh->mColors[c][index];
diff --git a/Engine/lib/assimp/code/Assjson/mesh_splitter.h b/Engine/lib/assimp/code/AssetLib/Assjson/mesh_splitter.h
similarity index 59%
rename from Engine/lib/assimp/code/Assjson/mesh_splitter.h
rename to Engine/lib/assimp/code/AssetLib/Assjson/mesh_splitter.h
index 326f73b41..f7f9a9326 100644
--- a/Engine/lib/assimp/code/Assjson/mesh_splitter.h
+++ b/Engine/lib/assimp/code/AssetLib/Assjson/mesh_splitter.h
@@ -22,40 +22,31 @@ struct aiNode;
 
 // ---------------------------------------------------------------------------
 /** Splits meshes of unique vertices into meshes with no more vertices than
- *  a given, configurable threshold value. 
+ *  a given, configurable threshold value.
  */
-class MeshSplitter 
-{
-
+class MeshSplitter {
 public:
-	
-	void SetLimit(unsigned int l) {
-		LIMIT = l;
-	}
+    unsigned int LIMIT;
 
-	unsigned int GetLimit() const {
-		return LIMIT;
-	}
+    void SetLimit(unsigned int l) {
+        LIMIT = l;
+    }
 
-public:
+    unsigned int GetLimit() const {
+        return LIMIT;
+    }
 
-	// -------------------------------------------------------------------
-	/** Executes the post processing step on the given imported data.
+    // -------------------------------------------------------------------
+    /** Executes the post processing step on the given imported data.
 	 * At the moment a process is not supposed to fail.
 	 * @param pScene The imported data to work at.
 	 */
-	void Execute( aiScene* pScene);
-
+    void Execute(aiScene *pScene);
 
 private:
+    void UpdateNode(aiNode *pcNode, const std::vector<std::pair<aiMesh *, unsigned int>> &source_mesh_map);
+    void SplitMesh(unsigned int index, aiMesh *mesh, std::vector<std::pair<aiMesh *, unsigned int>> &source_mesh_map);
 
-	void UpdateNode(aiNode* pcNode, const std::vector<std::pair<aiMesh*, unsigned int> >& source_mesh_map);
-	void SplitMesh (unsigned int index, aiMesh* mesh, std::vector<std::pair<aiMesh*, unsigned int> >& source_mesh_map);
-
-public:
-
-	unsigned int LIMIT;
 };
 
 #endif // INCLUDED_MESH_SPLITTER
-
diff --git a/Engine/lib/assimp/code/AssetLib/Assxml/AssxmlExporter.cpp b/Engine/lib/assimp/code/AssetLib/Assxml/AssxmlExporter.cpp
new file mode 100644
index 000000000..731916a25
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Assxml/AssxmlExporter.cpp
@@ -0,0 +1,68 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+/** @file  AssxmlExporter.cpp
+ *  ASSXML exporter main code
+ */
+
+#ifndef ASSIMP_BUILD_NO_EXPORT
+#ifndef ASSIMP_BUILD_NO_ASSXML_EXPORTER
+
+#include "AssxmlFileWriter.h"
+#include <assimp/IOSystem.hpp>
+#include <assimp/Exporter.hpp>
+
+namespace Assimp   {
+
+void ExportSceneAssxml(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/)
+{
+    DumpSceneToAssxml(
+        pFile,
+        "\0", // command(s)
+        pIOSystem,
+        pScene,
+        false); // shortened?
+}
+
+} // end of namespace Assimp
+
+#endif // ASSIMP_BUILD_NO_ASSXML_EXPORTER
+#endif // ASSIMP_BUILD_NO_EXPORT
diff --git a/Engine/lib/assimp/code/Assxml/AssxmlExporter.h b/Engine/lib/assimp/code/AssetLib/Assxml/AssxmlExporter.h
similarity index 97%
rename from Engine/lib/assimp/code/Assxml/AssxmlExporter.h
rename to Engine/lib/assimp/code/AssetLib/Assxml/AssxmlExporter.h
index 8ca887eea..6fcdebfab 100644
--- a/Engine/lib/assimp/code/Assxml/AssxmlExporter.h
+++ b/Engine/lib/assimp/code/AssetLib/Assxml/AssxmlExporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -43,6 +43,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file AssxmlExporter.h
  * ASSXML Exporter Main Header
  */
+#pragma once
 #ifndef AI_ASSXMLEXPORTER_H_INC
 #define AI_ASSXMLEXPORTER_H_INC
 
diff --git a/Engine/lib/assimp/code/AssetLib/Assxml/AssxmlFileWriter.cpp b/Engine/lib/assimp/code/AssetLib/Assxml/AssxmlFileWriter.cpp
new file mode 100644
index 000000000..640890ea1
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Assxml/AssxmlFileWriter.cpp
@@ -0,0 +1,662 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file AssxmlFileWriter.cpp
+ *  @brief Implementation of Assxml file writer.
+ */
+
+#include "AssxmlFileWriter.h"
+
+#include "PostProcessing/ProcessHelper.h"
+
+#include <assimp/version.h>
+#include <assimp/Exporter.hpp>
+#include <assimp/IOStream.hpp>
+#include <assimp/IOSystem.hpp>
+
+#include <stdarg.h>
+
+#ifdef ASSIMP_BUILD_NO_OWN_ZLIB
+#include <zlib.h>
+#else
+#include <contrib/zlib/zlib.h>
+#endif
+
+#include <stdio.h>
+#include <time.h>
+#include <memory>
+
+using namespace Assimp;
+
+namespace Assimp {
+
+namespace AssxmlFileWriter {
+
+// -----------------------------------------------------------------------------------
+static int ioprintf(IOStream *io, const char *format, ...) {
+    using namespace std;
+    if (nullptr == io) {
+        return -1;
+    }
+
+    static const int Size = 4096;
+    char sz[Size];
+    ::memset(sz, '\0', Size);
+    va_list va;
+    va_start(va, format);
+    const unsigned int nSize = vsnprintf(sz, Size - 1, format, va);
+    ai_assert(nSize < Size);
+    va_end(va);
+
+    io->Write(sz, sizeof(char), nSize);
+
+    return nSize;
+}
+
+// -----------------------------------------------------------------------------------
+// Convert a name to standard XML format
+static void ConvertName(aiString &out, const aiString &in) {
+    out.length = 0;
+    for (unsigned int i = 0; i < in.length; ++i) {
+        switch (in.data[i]) {
+        case '<':
+            out.Append("&lt;");
+            break;
+        case '>':
+            out.Append("&gt;");
+            break;
+        case '&':
+            out.Append("&amp;");
+            break;
+        case '\"':
+            out.Append("&quot;");
+            break;
+        case '\'':
+            out.Append("&apos;");
+            break;
+        default:
+            out.data[out.length++] = in.data[i];
+        }
+    }
+    out.data[out.length] = 0;
+}
+
+// -----------------------------------------------------------------------------------
+// Write a single node as text dump
+static void WriteNode(const aiNode *node, IOStream *io, unsigned int depth) {
+    char prefix[512];
+    for (unsigned int i = 0; i < depth; ++i)
+        prefix[i] = '\t';
+    prefix[depth] = '\0';
+
+    const aiMatrix4x4 &m = node->mTransformation;
+
+    aiString name;
+    ConvertName(name, node->mName);
+    ioprintf(io, "%s<Node name=\"%s\"> \n"
+                 "%s\t<Matrix4> \n"
+                 "%s\t\t%0 6f %0 6f %0 6f %0 6f\n"
+                 "%s\t\t%0 6f %0 6f %0 6f %0 6f\n"
+                 "%s\t\t%0 6f %0 6f %0 6f %0 6f\n"
+                 "%s\t\t%0 6f %0 6f %0 6f %0 6f\n"
+                 "%s\t</Matrix4> \n",
+            prefix, name.data, prefix,
+            prefix, m.a1, m.a2, m.a3, m.a4,
+            prefix, m.b1, m.b2, m.b3, m.b4,
+            prefix, m.c1, m.c2, m.c3, m.c4,
+            prefix, m.d1, m.d2, m.d3, m.d4, prefix);
+
+    if (node->mNumMeshes) {
+        ioprintf(io, "%s\t<MeshRefs num=\"%u\">\n%s\t",
+                prefix, node->mNumMeshes, prefix);
+
+        for (unsigned int i = 0; i < node->mNumMeshes; ++i) {
+            ioprintf(io, "%u ", node->mMeshes[i]);
+        }
+        ioprintf(io, "\n%s\t</MeshRefs>\n", prefix);
+    }
+
+    if (node->mNumChildren) {
+        ioprintf(io, "%s\t<NodeList num=\"%u\">\n",
+                prefix, node->mNumChildren);
+
+        for (unsigned int i = 0; i < node->mNumChildren; ++i) {
+            WriteNode(node->mChildren[i], io, depth + 2);
+        }
+        ioprintf(io, "%s\t</NodeList>\n", prefix);
+    }
+    ioprintf(io, "%s</Node>\n", prefix);
+}
+
+// -----------------------------------------------------------------------------------
+// Some chunks of text will need to be encoded for XML
+// http://stackoverflow.com/questions/5665231/most-efficient-way-to-escape-xml-html-in-c-string#5665377
+static std::string encodeXML(const std::string &data) {
+    std::string buffer;
+    buffer.reserve(data.size());
+    for (size_t pos = 0; pos != data.size(); ++pos) {
+        switch (data[pos]) {
+        case '&': buffer.append("&amp;"); break;
+        case '\"': buffer.append("&quot;"); break;
+        case '\'': buffer.append("&apos;"); break;
+        case '<': buffer.append("&lt;"); break;
+        case '>': buffer.append("&gt;"); break;
+        default: buffer.append(&data[pos], 1); break;
+        }
+    }
+    return buffer;
+}
+
+// -----------------------------------------------------------------------------------
+// Write a text model dump
+static void WriteDump(const char *pFile, const char *cmd, const aiScene *scene, IOStream *io, bool shortened) {
+    time_t tt = ::time(nullptr);
+#if _WIN32
+    tm *p = gmtime(&tt);
+#else
+    struct tm now;
+    tm *p = gmtime_r(&tt, &now);
+#endif
+    ai_assert(nullptr != p);
+
+    std::string c = cmd;
+    std::string::size_type s;
+
+    // https://sourceforge.net/tracker/?func=detail&aid=3167364&group_id=226462&atid=1067632
+    // -- not allowed in XML comments
+    while ((s = c.find("--")) != std::string::npos) {
+        c[s] = '?';
+    }
+
+    // write header
+    std::string header(
+            "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
+            "<ASSIMP format_id=\"1\">\n\n"
+            "<!-- XML Model dump produced by assimp dump\n"
+            "  Library version: %u.%u.%u\n"
+            "  Source: %s\n"
+            "  Command line: %s\n"
+            "  %s\n"
+            "-->"
+            " \n\n"
+            "<Scene flags=\"%u\" postprocessing=\"%u\">\n");
+
+    const unsigned int majorVersion(aiGetVersionMajor());
+    const unsigned int minorVersion(aiGetVersionMinor());
+    const unsigned int rev(aiGetVersionRevision());
+    const char *curtime(asctime(p));
+    ioprintf(io, header.c_str(), majorVersion, minorVersion, rev, pFile, c.c_str(), curtime, scene->mFlags, 0u);
+
+    // write the node graph
+    WriteNode(scene->mRootNode, io, 0);
+
+#if 0
+    // write cameras
+    for (unsigned int i = 0; i < scene->mNumCameras;++i) {
+        aiCamera* cam  = scene->mCameras[i];
+        ConvertName(name,cam->mName);
+
+        // camera header
+        ioprintf(io,"\t<Camera parent=\"%s\">\n"
+            "\t\t<Vector3 name=\"up\"        > %0 8f %0 8f %0 8f </Vector3>\n"
+            "\t\t<Vector3 name=\"lookat\"    > %0 8f %0 8f %0 8f </Vector3>\n"
+            "\t\t<Vector3 name=\"pos\"       > %0 8f %0 8f %0 8f </Vector3>\n"
+            "\t\t<Float   name=\"fov\"       > %f </Float>\n"
+            "\t\t<Float   name=\"aspect\"    > %f </Float>\n"
+            "\t\t<Float   name=\"near_clip\" > %f </Float>\n"
+            "\t\t<Float   name=\"far_clip\"  > %f </Float>\n"
+            "\t</Camera>\n",
+            name.data,
+            cam->mUp.x,cam->mUp.y,cam->mUp.z,
+            cam->mLookAt.x,cam->mLookAt.y,cam->mLookAt.z,
+            cam->mPosition.x,cam->mPosition.y,cam->mPosition.z,
+            cam->mHorizontalFOV,cam->mAspect,cam->mClipPlaneNear,cam->mClipPlaneFar,i);
+    }
+
+    // write lights
+    for (unsigned int i = 0; i < scene->mNumLights;++i) {
+        aiLight* l  = scene->mLights[i];
+        ConvertName(name,l->mName);
+
+        // light header
+        ioprintf(io,"\t<Light parent=\"%s\"> type=\"%s\"\n"
+            "\t\t<Vector3 name=\"diffuse\"   > %0 8f %0 8f %0 8f </Vector3>\n"
+            "\t\t<Vector3 name=\"specular\"  > %0 8f %0 8f %0 8f </Vector3>\n"
+            "\t\t<Vector3 name=\"ambient\"   > %0 8f %0 8f %0 8f </Vector3>\n",
+            name.data,
+            (l->mType == aiLightSource_DIRECTIONAL ? "directional" :
+            (l->mType == aiLightSource_POINT ? "point" : "spot" )),
+            l->mColorDiffuse.r, l->mColorDiffuse.g, l->mColorDiffuse.b,
+            l->mColorSpecular.r,l->mColorSpecular.g,l->mColorSpecular.b,
+            l->mColorAmbient.r, l->mColorAmbient.g, l->mColorAmbient.b);
+
+        if (l->mType != aiLightSource_DIRECTIONAL) {
+            ioprintf(io,
+                "\t\t<Vector3 name=\"pos\"       > %0 8f %0 8f %0 8f </Vector3>\n"
+                "\t\t<Float   name=\"atten_cst\" > %f </Float>\n"
+                "\t\t<Float   name=\"atten_lin\" > %f </Float>\n"
+                "\t\t<Float   name=\"atten_sqr\" > %f </Float>\n",
+                l->mPosition.x,l->mPosition.y,l->mPosition.z,
+                l->mAttenuationConstant,l->mAttenuationLinear,l->mAttenuationQuadratic);
+        }
+
+        if (l->mType != aiLightSource_POINT) {
+            ioprintf(io,
+                "\t\t<Vector3 name=\"lookat\"    > %0 8f %0 8f %0 8f </Vector3>\n",
+                l->mDirection.x,l->mDirection.y,l->mDirection.z);
+        }
+
+        if (l->mType == aiLightSource_SPOT) {
+            ioprintf(io,
+                "\t\t<Float   name=\"cone_out\" > %f </Float>\n"
+                "\t\t<Float   name=\"cone_inn\" > %f </Float>\n",
+                l->mAngleOuterCone,l->mAngleInnerCone);
+        }
+        ioprintf(io,"\t</Light>\n");
+    }
+#endif
+    aiString name;
+
+    // write textures
+    if (scene->mNumTextures) {
+        ioprintf(io, "<TextureList num=\"%u\">\n", scene->mNumTextures);
+        for (unsigned int i = 0; i < scene->mNumTextures; ++i) {
+            aiTexture *tex = scene->mTextures[i];
+            bool compressed = (tex->mHeight == 0);
+
+            // mesh header
+            ioprintf(io, "\t<Texture width=\"%u\" height=\"%u\" compressed=\"%s\"> \n",
+                    (compressed ? -1 : tex->mWidth), (compressed ? -1 : tex->mHeight),
+                    (compressed ? "true" : "false"));
+
+            if (compressed) {
+                ioprintf(io, "\t\t<Data length=\"%u\"> \n", tex->mWidth);
+
+                if (!shortened) {
+                    for (unsigned int n = 0; n < tex->mWidth; ++n) {
+                        ioprintf(io, "\t\t\t%2x", reinterpret_cast<uint8_t *>(tex->pcData)[n]);
+                        if (n && !(n % 50)) {
+                            ioprintf(io, "\n");
+                        }
+                    }
+                }
+            } else if (!shortened) {
+                ioprintf(io, "\t\t<Data length=\"%u\"> \n", tex->mWidth * tex->mHeight * 4);
+
+                // const unsigned int width = (unsigned int)std::log10((double)std::max(tex->mHeight,tex->mWidth))+1;
+                for (unsigned int y = 0; y < tex->mHeight; ++y) {
+                    for (unsigned int x = 0; x < tex->mWidth; ++x) {
+                        aiTexel *tx = tex->pcData + y * tex->mWidth + x;
+                        unsigned int r = tx->r, g = tx->g, b = tx->b, a = tx->a;
+                        ioprintf(io, "\t\t\t%2x %2x %2x %2x", r, g, b, a);
+
+                        // group by four for readability
+                        if (0 == (x + y * tex->mWidth) % 4) {
+                            ioprintf(io, "\n");
+                        }
+                    }
+                }
+            }
+            ioprintf(io, "\t\t</Data>\n\t</Texture>\n");
+        }
+        ioprintf(io, "</TextureList>\n");
+    }
+
+    // write materials
+    if (scene->mNumMaterials) {
+        ioprintf(io, "<MaterialList num=\"%u\">\n", scene->mNumMaterials);
+        for (unsigned int i = 0; i < scene->mNumMaterials; ++i) {
+            const aiMaterial *mat = scene->mMaterials[i];
+
+            ioprintf(io, "\t<Material>\n");
+            ioprintf(io, "\t\t<MatPropertyList  num=\"%u\">\n", mat->mNumProperties);
+            for (unsigned int n = 0; n < mat->mNumProperties; ++n) {
+
+                const aiMaterialProperty *prop = mat->mProperties[n];
+                const char *sz = "";
+                if (prop->mType == aiPTI_Float) {
+                    sz = "float";
+                } else if (prop->mType == aiPTI_Integer) {
+                    sz = "integer";
+                } else if (prop->mType == aiPTI_String) {
+                    sz = "string";
+                } else if (prop->mType == aiPTI_Buffer) {
+                    sz = "binary_buffer";
+                }
+
+                ioprintf(io, "\t\t\t<MatProperty key=\"%s\" \n\t\t\ttype=\"%s\" tex_usage=\"%s\" tex_index=\"%u\"",
+                        prop->mKey.data, sz,
+                        ::TextureTypeToString((aiTextureType)prop->mSemantic), prop->mIndex);
+
+                if (prop->mType == aiPTI_Float) {
+                    ioprintf(io, " size=\"%i\">\n\t\t\t\t",
+                            static_cast<int>(prop->mDataLength / sizeof(float)));
+
+                    for (unsigned int pp = 0; pp < prop->mDataLength / sizeof(float); ++pp) {
+                        ioprintf(io, "%f ", *((float *)(prop->mData + pp * sizeof(float))));
+                    }
+                } else if (prop->mType == aiPTI_Integer) {
+                    ioprintf(io, " size=\"%i\">\n\t\t\t\t",
+                            static_cast<int>(prop->mDataLength / sizeof(int)));
+
+                    for (unsigned int pp = 0; pp < prop->mDataLength / sizeof(int); ++pp) {
+                        ioprintf(io, "%i ", *((int *)(prop->mData + pp * sizeof(int))));
+                    }
+                } else if (prop->mType == aiPTI_Buffer) {
+                    ioprintf(io, " size=\"%i\">\n\t\t\t\t",
+                            static_cast<int>(prop->mDataLength));
+
+                    for (unsigned int pp = 0; pp < prop->mDataLength; ++pp) {
+                        ioprintf(io, "%2x ", prop->mData[pp]);
+                        if (pp && 0 == pp % 30) {
+                            ioprintf(io, "\n\t\t\t\t");
+                        }
+                    }
+                } else if (prop->mType == aiPTI_String) {
+                    ioprintf(io, ">\n\t\t\t\t\"%s\"", encodeXML(prop->mData + 4).c_str() /* skip length */);
+                }
+                ioprintf(io, "\n\t\t\t</MatProperty>\n");
+            }
+            ioprintf(io, "\t\t</MatPropertyList>\n");
+            ioprintf(io, "\t</Material>\n");
+        }
+        ioprintf(io, "</MaterialList>\n");
+    }
+
+    // write animations
+    if (scene->mNumAnimations) {
+        ioprintf(io, "<AnimationList num=\"%u\">\n", scene->mNumAnimations);
+        for (unsigned int i = 0; i < scene->mNumAnimations; ++i) {
+            aiAnimation *anim = scene->mAnimations[i];
+
+            // anim header
+            ConvertName(name, anim->mName);
+            ioprintf(io, "\t<Animation name=\"%s\" duration=\"%e\" tick_cnt=\"%e\">\n",
+                    name.data, anim->mDuration, anim->mTicksPerSecond);
+
+            // write bone animation channels
+            if (anim->mNumChannels) {
+                ioprintf(io, "\t\t<NodeAnimList num=\"%u\">\n", anim->mNumChannels);
+                for (unsigned int n = 0; n < anim->mNumChannels; ++n) {
+                    aiNodeAnim *nd = anim->mChannels[n];
+
+                    // node anim header
+                    ConvertName(name, nd->mNodeName);
+                    ioprintf(io, "\t\t\t<NodeAnim node=\"%s\">\n", name.data);
+
+                    if (!shortened) {
+                        // write position keys
+                        if (nd->mNumPositionKeys) {
+                            ioprintf(io, "\t\t\t\t<PositionKeyList num=\"%u\">\n", nd->mNumPositionKeys);
+                            for (unsigned int a = 0; a < nd->mNumPositionKeys; ++a) {
+                                aiVectorKey *vc = nd->mPositionKeys + a;
+                                ioprintf(io, "\t\t\t\t\t<PositionKey time=\"%e\">\n"
+                                             "\t\t\t\t\t\t%0 8f %0 8f %0 8f\n\t\t\t\t\t</PositionKey>\n",
+                                        vc->mTime, vc->mValue.x, vc->mValue.y, vc->mValue.z);
+                            }
+                            ioprintf(io, "\t\t\t\t</PositionKeyList>\n");
+                        }
+
+                        // write scaling keys
+                        if (nd->mNumScalingKeys) {
+                            ioprintf(io, "\t\t\t\t<ScalingKeyList num=\"%u\">\n", nd->mNumScalingKeys);
+                            for (unsigned int a = 0; a < nd->mNumScalingKeys; ++a) {
+                                aiVectorKey *vc = nd->mScalingKeys + a;
+                                ioprintf(io, "\t\t\t\t\t<ScalingKey time=\"%e\">\n"
+                                             "\t\t\t\t\t\t%0 8f %0 8f %0 8f\n\t\t\t\t\t</ScalingKey>\n",
+                                        vc->mTime, vc->mValue.x, vc->mValue.y, vc->mValue.z);
+                            }
+                            ioprintf(io, "\t\t\t\t</ScalingKeyList>\n");
+                        }
+
+                        // write rotation keys
+                        if (nd->mNumRotationKeys) {
+                            ioprintf(io, "\t\t\t\t<RotationKeyList num=\"%u\">\n", nd->mNumRotationKeys);
+                            for (unsigned int a = 0; a < nd->mNumRotationKeys; ++a) {
+                                aiQuatKey *vc = nd->mRotationKeys + a;
+                                ioprintf(io, "\t\t\t\t\t<RotationKey time=\"%e\">\n"
+                                             "\t\t\t\t\t\t%0 8f %0 8f %0 8f %0 8f\n\t\t\t\t\t</RotationKey>\n",
+                                        vc->mTime, vc->mValue.x, vc->mValue.y, vc->mValue.z, vc->mValue.w);
+                            }
+                            ioprintf(io, "\t\t\t\t</RotationKeyList>\n");
+                        }
+                    }
+                    ioprintf(io, "\t\t\t</NodeAnim>\n");
+                }
+                ioprintf(io, "\t\t</NodeAnimList>\n");
+            }
+            ioprintf(io, "\t</Animation>\n");
+        }
+        ioprintf(io, "</AnimationList>\n");
+    }
+
+    // write meshes
+    if (scene->mNumMeshes) {
+        ioprintf(io, "<MeshList num=\"%u\">\n", scene->mNumMeshes);
+        for (unsigned int i = 0; i < scene->mNumMeshes; ++i) {
+            aiMesh *mesh = scene->mMeshes[i];
+            // const unsigned int width = (unsigned int)std::log10((double)mesh->mNumVertices)+1;
+
+            // mesh header
+            ioprintf(io, "\t<Mesh types=\"%s %s %s %s\" material_index=\"%u\">\n",
+                    (mesh->mPrimitiveTypes & aiPrimitiveType_POINT ? "points" : ""),
+                    (mesh->mPrimitiveTypes & aiPrimitiveType_LINE ? "lines" : ""),
+                    (mesh->mPrimitiveTypes & aiPrimitiveType_TRIANGLE ? "triangles" : ""),
+                    (mesh->mPrimitiveTypes & aiPrimitiveType_POLYGON ? "polygons" : ""),
+                    mesh->mMaterialIndex);
+
+            // bones
+            if (mesh->mNumBones) {
+                ioprintf(io, "\t\t<BoneList num=\"%u\">\n", mesh->mNumBones);
+
+                for (unsigned int n = 0; n < mesh->mNumBones; ++n) {
+                    aiBone *bone = mesh->mBones[n];
+
+                    ConvertName(name, bone->mName);
+                    // bone header
+                    ioprintf(io, "\t\t\t<Bone name=\"%s\">\n"
+                                 "\t\t\t\t<Matrix4> \n"
+                                 "\t\t\t\t\t%0 6f %0 6f %0 6f %0 6f\n"
+                                 "\t\t\t\t\t%0 6f %0 6f %0 6f %0 6f\n"
+                                 "\t\t\t\t\t%0 6f %0 6f %0 6f %0 6f\n"
+                                 "\t\t\t\t\t%0 6f %0 6f %0 6f %0 6f\n"
+                                 "\t\t\t\t</Matrix4> \n",
+                            name.data,
+                            bone->mOffsetMatrix.a1, bone->mOffsetMatrix.a2, bone->mOffsetMatrix.a3, bone->mOffsetMatrix.a4,
+                            bone->mOffsetMatrix.b1, bone->mOffsetMatrix.b2, bone->mOffsetMatrix.b3, bone->mOffsetMatrix.b4,
+                            bone->mOffsetMatrix.c1, bone->mOffsetMatrix.c2, bone->mOffsetMatrix.c3, bone->mOffsetMatrix.c4,
+                            bone->mOffsetMatrix.d1, bone->mOffsetMatrix.d2, bone->mOffsetMatrix.d3, bone->mOffsetMatrix.d4);
+
+                    if (!shortened && bone->mNumWeights) {
+                        ioprintf(io, "\t\t\t\t<WeightList num=\"%u\">\n", bone->mNumWeights);
+
+                        // bone weights
+                        for (unsigned int a = 0; a < bone->mNumWeights; ++a) {
+                            aiVertexWeight *wght = bone->mWeights + a;
+
+                            ioprintf(io, "\t\t\t\t\t<Weight index=\"%u\">\n\t\t\t\t\t\t%f\n\t\t\t\t\t</Weight>\n",
+                                    wght->mVertexId, wght->mWeight);
+                        }
+                        ioprintf(io, "\t\t\t\t</WeightList>\n");
+                    }
+                    ioprintf(io, "\t\t\t</Bone>\n");
+                }
+                ioprintf(io, "\t\t</BoneList>\n");
+            }
+
+            // faces
+            if (!shortened && mesh->mNumFaces) {
+                ioprintf(io, "\t\t<FaceList num=\"%u\">\n", mesh->mNumFaces);
+                for (unsigned int n = 0; n < mesh->mNumFaces; ++n) {
+                    aiFace &f = mesh->mFaces[n];
+                    ioprintf(io, "\t\t\t<Face num=\"%u\">\n"
+                                 "\t\t\t\t",
+                            f.mNumIndices);
+
+                    for (unsigned int j = 0; j < f.mNumIndices; ++j)
+                        ioprintf(io, "%u ", f.mIndices[j]);
+
+                    ioprintf(io, "\n\t\t\t</Face>\n");
+                }
+                ioprintf(io, "\t\t</FaceList>\n");
+            }
+
+            // vertex positions
+            if (mesh->HasPositions()) {
+                ioprintf(io, "\t\t<Positions num=\"%u\" set=\"0\" num_components=\"3\"> \n", mesh->mNumVertices);
+                if (!shortened) {
+                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
+                        ioprintf(io, "\t\t%0 8f %0 8f %0 8f\n",
+                                mesh->mVertices[n].x,
+                                mesh->mVertices[n].y,
+                                mesh->mVertices[n].z);
+                    }
+                }
+                ioprintf(io, "\t\t</Positions>\n");
+            }
+
+            // vertex normals
+            if (mesh->HasNormals()) {
+                ioprintf(io, "\t\t<Normals num=\"%u\" set=\"0\" num_components=\"3\"> \n", mesh->mNumVertices);
+                if (!shortened) {
+                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
+                        ioprintf(io, "\t\t%0 8f %0 8f %0 8f\n",
+                                mesh->mNormals[n].x,
+                                mesh->mNormals[n].y,
+                                mesh->mNormals[n].z);
+                    }
+                }
+                ioprintf(io, "\t\t</Normals>\n");
+            }
+
+            // vertex tangents and bitangents
+            if (mesh->HasTangentsAndBitangents()) {
+                ioprintf(io, "\t\t<Tangents num=\"%u\" set=\"0\" num_components=\"3\"> \n", mesh->mNumVertices);
+                if (!shortened) {
+                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
+                        ioprintf(io, "\t\t%0 8f %0 8f %0 8f\n",
+                                mesh->mTangents[n].x,
+                                mesh->mTangents[n].y,
+                                mesh->mTangents[n].z);
+                    }
+                }
+                ioprintf(io, "\t\t</Tangents>\n");
+
+                ioprintf(io, "\t\t<Bitangents num=\"%u\" set=\"0\" num_components=\"3\"> \n", mesh->mNumVertices);
+                if (!shortened) {
+                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
+                        ioprintf(io, "\t\t%0 8f %0 8f %0 8f\n",
+                                mesh->mBitangents[n].x,
+                                mesh->mBitangents[n].y,
+                                mesh->mBitangents[n].z);
+                    }
+                }
+                ioprintf(io, "\t\t</Bitangents>\n");
+            }
+
+            // texture coordinates
+            for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
+                if (!mesh->mTextureCoords[a])
+                    break;
+
+                ioprintf(io, "\t\t<TextureCoords num=\"%u\" set=\"%u\" name=\"%s\" num_components=\"%u\"> \n",
+                         mesh->mNumVertices,
+                         a,
+                         (mesh->HasTextureCoordsName(a) ? mesh->GetTextureCoordsName(a)->C_Str() : ""),
+                         mesh->mNumUVComponents[a]);
+
+                if (!shortened) {
+                    if (mesh->mNumUVComponents[a] == 3) {
+                        for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
+                            ioprintf(io, "\t\t%0 8f %0 8f %0 8f\n",
+                                    mesh->mTextureCoords[a][n].x,
+                                    mesh->mTextureCoords[a][n].y,
+                                    mesh->mTextureCoords[a][n].z);
+                        }
+                    } else {
+                        for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
+                            ioprintf(io, "\t\t%0 8f %0 8f\n",
+                                    mesh->mTextureCoords[a][n].x,
+                                    mesh->mTextureCoords[a][n].y);
+                        }
+                    }
+                }
+                ioprintf(io, "\t\t</TextureCoords>\n");
+            }
+
+            // vertex colors
+            for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a) {
+                if (!mesh->mColors[a])
+                    break;
+                ioprintf(io, "\t\t<Colors num=\"%u\" set=\"%u\" num_components=\"4\"> \n", mesh->mNumVertices, a);
+                if (!shortened) {
+                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
+                        ioprintf(io, "\t\t%0 8f %0 8f %0 8f %0 8f\n",
+                                mesh->mColors[a][n].r,
+                                mesh->mColors[a][n].g,
+                                mesh->mColors[a][n].b,
+                                mesh->mColors[a][n].a);
+                    }
+                }
+                ioprintf(io, "\t\t</Colors>\n");
+            }
+            ioprintf(io, "\t</Mesh>\n");
+        }
+        ioprintf(io, "</MeshList>\n");
+    }
+    ioprintf(io, "</Scene>\n</ASSIMP>");
+}
+
+} // end of namespace AssxmlFileWriter
+
+void DumpSceneToAssxml(
+        const char *pFile, const char *cmd, IOSystem *pIOSystem,
+        const aiScene *pScene, bool shortened) {
+    std::unique_ptr<IOStream> file(pIOSystem->Open(pFile, "wt"));
+    if (!file.get()) {
+        throw std::runtime_error("Unable to open output file " + std::string(pFile) + '\n');
+    }
+
+    AssxmlFileWriter::WriteDump(pFile, cmd, pScene, file.get(), shortened);
+}
+
+} // end of namespace Assimp
diff --git a/Engine/lib/assimp/code/AssetLib/Assxml/AssxmlFileWriter.h b/Engine/lib/assimp/code/AssetLib/Assxml/AssxmlFileWriter.h
new file mode 100644
index 000000000..0620c9db7
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Assxml/AssxmlFileWriter.h
@@ -0,0 +1,64 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file AssxmlFileWriter.h
+ *  @brief Declaration of Assxml file writer.
+ */
+#pragma once
+#ifndef AI_ASSXMLFILEWRITER_H_INC
+#define AI_ASSXMLFILEWRITER_H_INC
+
+#include <assimp/defs.h>
+#include <assimp/scene.h>
+#include <assimp/IOSystem.hpp>
+
+namespace Assimp {
+
+void ASSIMP_API DumpSceneToAssxml(
+    const char* pFile,
+    const char* cmd,
+    IOSystem* pIOSystem,
+    const aiScene* pScene,
+    bool shortened);
+
+}
+
+#endif // AI_ASSXMLFILEWRITER_H_INC
diff --git a/Engine/lib/assimp/code/AssetLib/B3D/B3DImporter.cpp b/Engine/lib/assimp/code/AssetLib/B3D/B3DImporter.cpp
new file mode 100644
index 000000000..c4ef75be3
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/B3D/B3DImporter.cpp
@@ -0,0 +1,744 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file  B3DImporter.cpp
+ *  @brief Implementation of the b3d importer class
+ */
+
+#ifndef ASSIMP_BUILD_NO_B3D_IMPORTER
+
+// internal headers
+#include "AssetLib/B3D/B3DImporter.h"
+#include "PostProcessing/ConvertToLHProcess.h"
+#include "PostProcessing/TextureTransform.h"
+
+#include <assimp/StringUtils.h>
+#include <assimp/anim.h>
+#include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOSystem.hpp>
+
+#include <memory>
+
+using namespace Assimp;
+using namespace std;
+
+static const aiImporterDesc desc = {
+    "BlitzBasic 3D Importer",
+    "",
+    "",
+    "http://www.blitzbasic.com/",
+    aiImporterFlags_SupportBinaryFlavour,
+    0,
+    0,
+    0,
+    0,
+    "b3d"
+};
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4018)
+#endif
+
+//#define DEBUG_B3D
+
+template<typename T>
+void DeleteAllBarePointers(std::vector<T> &x) {
+    for (auto p : x) {
+        delete p;
+    }
+}
+
+B3DImporter::~B3DImporter() {
+    // empty
+}
+
+// ------------------------------------------------------------------------------------------------
+bool B3DImporter::CanRead(const std::string &pFile, IOSystem * /*pIOHandler*/, bool /*checkSig*/) const {
+    size_t pos = pFile.find_last_of('.');
+    if (pos == string::npos) {
+        return false;
+    }
+
+    string ext = pFile.substr(pos + 1);
+    if (ext.size() != 3) {
+        return false;
+    }
+
+    return (ext[0] == 'b' || ext[0] == 'B') && (ext[1] == '3') && (ext[2] == 'd' || ext[2] == 'D');
+}
+
+// ------------------------------------------------------------------------------------------------
+// Loader meta information
+const aiImporterDesc *B3DImporter::GetInfo() const {
+    return &desc;
+}
+
+// ------------------------------------------------------------------------------------------------
+void B3DImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
+    std::unique_ptr<IOStream> file(pIOHandler->Open(pFile));
+
+    // Check whether we can read from the file
+    if (file.get() == nullptr) {
+        throw DeadlyImportError("Failed to open B3D file ", pFile, ".");
+    }
+
+    // check whether the .b3d file is large enough to contain
+    // at least one chunk.
+    size_t fileSize = file->FileSize();
+    if (fileSize < 8) {
+        throw DeadlyImportError("B3D File is too small.");
+    }
+
+    _pos = 0;
+    _buf.resize(fileSize);
+    file->Read(&_buf[0], 1, fileSize);
+    _stack.clear();
+
+    ReadBB3D(pScene);
+}
+
+// ------------------------------------------------------------------------------------------------
+AI_WONT_RETURN void B3DImporter::Oops() {
+    throw DeadlyImportError("B3D Importer - INTERNAL ERROR");
+}
+
+// ------------------------------------------------------------------------------------------------
+AI_WONT_RETURN void B3DImporter::Fail(const string &str) {
+#ifdef DEBUG_B3D
+    ASSIMP_LOG_ERROR("Error in B3D file data: ", str);
+#endif
+    throw DeadlyImportError("B3D Importer - error in B3D file data: ", str);
+}
+
+// ------------------------------------------------------------------------------------------------
+int B3DImporter::ReadByte() {
+    if (_pos > _buf.size()) {
+        Fail("EOF");
+    }
+
+    return _buf[_pos++];
+}
+
+// ------------------------------------------------------------------------------------------------
+int B3DImporter::ReadInt() {
+    if (_pos + 4 > _buf.size()) {
+        Fail("EOF");
+    }
+
+    int n;
+    memcpy(&n, &_buf[_pos], 4);
+    _pos += 4;
+
+    return n;
+}
+
+// ------------------------------------------------------------------------------------------------
+float B3DImporter::ReadFloat() {
+    if (_pos + 4 > _buf.size()) {
+        Fail("EOF");
+    }
+
+    float n;
+    memcpy(&n, &_buf[_pos], 4);
+    _pos += 4;
+
+    return n;
+}
+
+// ------------------------------------------------------------------------------------------------
+aiVector2D B3DImporter::ReadVec2() {
+    float x = ReadFloat();
+    float y = ReadFloat();
+    return aiVector2D(x, y);
+}
+
+// ------------------------------------------------------------------------------------------------
+aiVector3D B3DImporter::ReadVec3() {
+    float x = ReadFloat();
+    float y = ReadFloat();
+    float z = ReadFloat();
+    return aiVector3D(x, y, z);
+}
+
+// ------------------------------------------------------------------------------------------------
+aiQuaternion B3DImporter::ReadQuat() {
+    // (aramis_acg) Fix to adapt the loader to changed quat orientation
+    float w = -ReadFloat();
+    float x = ReadFloat();
+    float y = ReadFloat();
+    float z = ReadFloat();
+    return aiQuaternion(w, x, y, z);
+}
+
+// ------------------------------------------------------------------------------------------------
+string B3DImporter::ReadString() {
+    if (_pos > _buf.size()) {
+        Fail("EOF");
+    }
+    string str;
+    while (_pos < _buf.size()) {
+        char c = (char)ReadByte();
+        if (!c) {
+            return str;
+        }
+        str += c;
+    }
+    return string();
+}
+
+// ------------------------------------------------------------------------------------------------
+string B3DImporter::ReadChunk() {
+    string tag;
+    for (int i = 0; i < 4; ++i) {
+        tag += char(ReadByte());
+    }
+#ifdef DEBUG_B3D
+    ASSIMP_LOG_DEBUG("ReadChunk: ", tag);
+#endif
+    unsigned sz = (unsigned)ReadInt();
+    _stack.push_back(_pos + sz);
+    return tag;
+}
+
+// ------------------------------------------------------------------------------------------------
+void B3DImporter::ExitChunk() {
+    _pos = _stack.back();
+    _stack.pop_back();
+}
+
+// ------------------------------------------------------------------------------------------------
+size_t B3DImporter::ChunkSize() {
+    return _stack.back() - _pos;
+}
+// ------------------------------------------------------------------------------------------------
+
+template <class T>
+T *B3DImporter::to_array(const vector<T> &v) {
+    if (v.empty()) {
+        return 0;
+    }
+    T *p = new T[v.size()];
+    for (size_t i = 0; i < v.size(); ++i) {
+        p[i] = v[i];
+    }
+    return p;
+}
+
+// ------------------------------------------------------------------------------------------------
+template <class T>
+T **unique_to_array(vector<std::unique_ptr<T>> &v) {
+    if (v.empty()) {
+        return 0;
+    }
+    T **p = new T *[v.size()];
+    for (size_t i = 0; i < v.size(); ++i) {
+        p[i] = v[i].release();
+    }
+    return p;
+}
+
+// ------------------------------------------------------------------------------------------------
+void B3DImporter::ReadTEXS() {
+    while (ChunkSize()) {
+        string name = ReadString();
+        /*int flags=*/ReadInt();
+        /*int blend=*/ReadInt();
+        /*aiVector2D pos=*/ReadVec2();
+        /*aiVector2D scale=*/ReadVec2();
+        /*float rot=*/ReadFloat();
+
+        _textures.push_back(name);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void B3DImporter::ReadBRUS() {
+    int n_texs = ReadInt();
+    if (n_texs < 0 || n_texs > 8) {
+        Fail("Bad texture count");
+    }
+    while (ChunkSize()) {
+        string name = ReadString();
+        aiVector3D color = ReadVec3();
+        float alpha = ReadFloat();
+        float shiny = ReadFloat();
+        /*int blend=**/ ReadInt();
+        int fx = ReadInt();
+
+        std::unique_ptr<aiMaterial> mat(new aiMaterial);
+
+        // Name
+        aiString ainame(name);
+        mat->AddProperty(&ainame, AI_MATKEY_NAME);
+
+        // Diffuse color
+        mat->AddProperty(&color, 1, AI_MATKEY_COLOR_DIFFUSE);
+
+        // Opacity
+        mat->AddProperty(&alpha, 1, AI_MATKEY_OPACITY);
+
+        // Specular color
+        aiColor3D speccolor(shiny, shiny, shiny);
+        mat->AddProperty(&speccolor, 1, AI_MATKEY_COLOR_SPECULAR);
+
+        // Specular power
+        float specpow = shiny * 128;
+        mat->AddProperty(&specpow, 1, AI_MATKEY_SHININESS);
+
+        // Double sided
+        if (fx & 0x10) {
+            int i = 1;
+            mat->AddProperty(&i, 1, AI_MATKEY_TWOSIDED);
+        }
+
+        //Textures
+        for (int i = 0; i < n_texs; ++i) {
+            int texid = ReadInt();
+            if (texid < -1 || (texid >= 0 && texid >= static_cast<int>(_textures.size()))) {
+                Fail("Bad texture id");
+            }
+            if (i == 0 && texid >= 0) {
+                aiString texname(_textures[texid]);
+                mat->AddProperty(&texname, AI_MATKEY_TEXTURE_DIFFUSE(0));
+            }
+        }
+        _materials.emplace_back(std::move(mat));
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void B3DImporter::ReadVRTS() {
+    _vflags = ReadInt();
+    _tcsets = ReadInt();
+    _tcsize = ReadInt();
+    if (_tcsets < 0 || _tcsets > 4 || _tcsize < 0 || _tcsize > 4) {
+        Fail("Bad texcoord data");
+    }
+
+    int sz = 12 + (_vflags & 1 ? 12 : 0) + (_vflags & 2 ? 16 : 0) + (_tcsets * _tcsize * 4);
+    size_t n_verts = ChunkSize() / sz;
+
+    int v0 = static_cast<int>(_vertices.size());
+    _vertices.resize(v0 + n_verts);
+
+    for (unsigned int i = 0; i < n_verts; ++i) {
+        Vertex &v = _vertices[v0 + i];
+
+        memset(v.bones, 0, sizeof(v.bones));
+        memset(v.weights, 0, sizeof(v.weights));
+
+        v.vertex = ReadVec3();
+
+        if (_vflags & 1) {
+            v.normal = ReadVec3();
+        }
+
+        if (_vflags & 2) {
+            ReadQuat(); //skip v 4bytes...
+        }
+
+        for (int j = 0; j < _tcsets; ++j) {
+            float t[4] = { 0, 0, 0, 0 };
+            for (int k = 0; k < _tcsize; ++k) {
+                t[k] = ReadFloat();
+            }
+            t[1] = 1 - t[1];
+            if (!j) {
+                v.texcoords = aiVector3D(t[0], t[1], t[2]);
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void B3DImporter::ReadTRIS(int v0) {
+    int matid = ReadInt();
+    if (matid == -1) {
+        matid = 0;
+    } else if (matid < 0 || matid >= (int)_materials.size()) {
+#ifdef DEBUG_B3D
+        ASSIMP_LOG_ERROR("material id=", matid);
+#endif
+        Fail("Bad material id");
+    }
+
+    std::unique_ptr<aiMesh> mesh(new aiMesh);
+
+    mesh->mMaterialIndex = matid;
+    mesh->mNumFaces = 0;
+    mesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
+
+    size_t n_tris = ChunkSize() / 12;
+    aiFace *face = mesh->mFaces = new aiFace[n_tris];
+
+    for (unsigned int i = 0; i < n_tris; ++i) {
+        int i0 = ReadInt() + v0;
+        int i1 = ReadInt() + v0;
+        int i2 = ReadInt() + v0;
+        if (i0 < 0 || i0 >= (int)_vertices.size() || i1 < 0 || i1 >= (int)_vertices.size() || i2 < 0 || i2 >= (int)_vertices.size()) {
+#ifdef DEBUG_B3D
+            ASSIMP_LOG_ERROR("Bad triangle index: i0=", i0, ", i1=", i1, ", i2=", i2);
+#endif
+            Fail("Bad triangle index");
+            continue;
+        }
+        face->mNumIndices = 3;
+        face->mIndices = new unsigned[3];
+        face->mIndices[0] = i0;
+        face->mIndices[1] = i1;
+        face->mIndices[2] = i2;
+        ++mesh->mNumFaces;
+        ++face;
+    }
+
+    _meshes.emplace_back(std::move(mesh));
+}
+
+// ------------------------------------------------------------------------------------------------
+void B3DImporter::ReadMESH() {
+    /*int matid=*/ReadInt();
+
+    int v0 = static_cast<int>(_vertices.size());
+
+    while (ChunkSize()) {
+        string t = ReadChunk();
+        if (t == "VRTS") {
+            ReadVRTS();
+        } else if (t == "TRIS") {
+            ReadTRIS(v0);
+        }
+        ExitChunk();
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void B3DImporter::ReadBONE(int id) {
+    while (ChunkSize()) {
+        int vertex = ReadInt();
+        float weight = ReadFloat();
+        if (vertex < 0 || vertex >= (int)_vertices.size()) {
+            Fail("Bad vertex index");
+        }
+
+        Vertex &v = _vertices[vertex];
+        for (int i = 0; i < 4; ++i) {
+            if (!v.weights[i]) {
+                v.bones[i] = static_cast<unsigned char>(id);
+                v.weights[i] = weight;
+                break;
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void B3DImporter::ReadKEYS(aiNodeAnim *nodeAnim) {
+    vector<aiVectorKey> trans, scale;
+    vector<aiQuatKey> rot;
+    int flags = ReadInt();
+    while (ChunkSize()) {
+        int frame = ReadInt();
+        if (flags & 1) {
+            trans.push_back(aiVectorKey(frame, ReadVec3()));
+        }
+        if (flags & 2) {
+            scale.push_back(aiVectorKey(frame, ReadVec3()));
+        }
+        if (flags & 4) {
+            rot.push_back(aiQuatKey(frame, ReadQuat()));
+        }
+    }
+
+    if (flags & 1) {
+        nodeAnim->mNumPositionKeys = static_cast<unsigned int>(trans.size());
+        nodeAnim->mPositionKeys = to_array(trans);
+    }
+
+    if (flags & 2) {
+        nodeAnim->mNumScalingKeys = static_cast<unsigned int>(scale.size());
+        nodeAnim->mScalingKeys = to_array(scale);
+    }
+
+    if (flags & 4) {
+        nodeAnim->mNumRotationKeys = static_cast<unsigned int>(rot.size());
+        nodeAnim->mRotationKeys = to_array(rot);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void B3DImporter::ReadANIM() {
+    /*int flags=*/ReadInt();
+    int frames = ReadInt();
+    float fps = ReadFloat();
+
+    std::unique_ptr<aiAnimation> anim(new aiAnimation);
+
+    anim->mDuration = frames;
+    anim->mTicksPerSecond = fps;
+    _animations.emplace_back(std::move(anim));
+}
+
+// ------------------------------------------------------------------------------------------------
+aiNode *B3DImporter::ReadNODE(aiNode *parent) {
+
+    string name = ReadString();
+    aiVector3D t = ReadVec3();
+    aiVector3D s = ReadVec3();
+    aiQuaternion r = ReadQuat();
+
+    aiMatrix4x4 trans, scale, rot;
+
+    aiMatrix4x4::Translation(t, trans);
+    aiMatrix4x4::Scaling(s, scale);
+    rot = aiMatrix4x4(r.GetMatrix());
+
+    aiMatrix4x4 tform = trans * rot * scale;
+
+    int nodeid = static_cast<int>(_nodes.size());
+
+    aiNode *node = new aiNode(name);
+    _nodes.push_back(node);
+
+    node->mParent = parent;
+    node->mTransformation = tform;
+
+    std::unique_ptr<aiNodeAnim> nodeAnim;
+    vector<unsigned> meshes;
+    vector<aiNode *> children;
+
+    while (ChunkSize()) {
+        const string chunk = ReadChunk();
+        if (chunk == "MESH") {
+            unsigned int n = static_cast<unsigned int>(_meshes.size());
+            ReadMESH();
+            for (unsigned int i = n; i < static_cast<unsigned int>(_meshes.size()); ++i) {
+                meshes.push_back(i);
+            }
+        } else if (chunk == "BONE") {
+            ReadBONE(nodeid);
+        } else if (chunk == "ANIM") {
+            ReadANIM();
+        } else if (chunk == "KEYS") {
+            if (!nodeAnim) {
+                nodeAnim.reset(new aiNodeAnim);
+                nodeAnim->mNodeName = node->mName;
+            }
+            ReadKEYS(nodeAnim.get());
+        } else if (chunk == "NODE") {
+            aiNode *child = ReadNODE(node);
+            children.push_back(child);
+        }
+        ExitChunk();
+    }
+
+    if (nodeAnim) {
+        _nodeAnims.emplace_back(std::move(nodeAnim));
+    }
+
+    node->mNumMeshes = static_cast<unsigned int>(meshes.size());
+    node->mMeshes = to_array(meshes);
+
+    node->mNumChildren = static_cast<unsigned int>(children.size());
+    node->mChildren = to_array(children);
+
+    return node;
+}
+
+// ------------------------------------------------------------------------------------------------
+void B3DImporter::ReadBB3D(aiScene *scene) {
+
+    _textures.clear();
+
+    _materials.clear();
+
+    _vertices.clear();
+
+    _meshes.clear();
+
+    DeleteAllBarePointers(_nodes);
+    _nodes.clear();
+
+    _nodeAnims.clear();
+
+    _animations.clear();
+
+    string t = ReadChunk();
+    if (t == "BB3D") {
+        int version = ReadInt();
+
+        if (!DefaultLogger::isNullLogger()) {
+            char dmp[128];
+            ai_snprintf(dmp, 128, "B3D file format version: %i", version);
+            ASSIMP_LOG_INFO(dmp);
+        }
+
+        while (ChunkSize()) {
+            const string chunk = ReadChunk();
+            if (chunk == "TEXS") {
+                ReadTEXS();
+            } else if (chunk == "BRUS") {
+                ReadBRUS();
+            } else if (chunk == "NODE") {
+                ReadNODE(0);
+            }
+            ExitChunk();
+        }
+    }
+    ExitChunk();
+
+    if (!_nodes.size()) {
+        Fail("No nodes");
+    }
+
+    if (!_meshes.size()) {
+        Fail("No meshes");
+    }
+
+    // Fix nodes/meshes/bones
+    for (size_t i = 0; i < _nodes.size(); ++i) {
+        aiNode *node = _nodes[i];
+
+        for (size_t j = 0; j < node->mNumMeshes; ++j) {
+            aiMesh *mesh = _meshes[node->mMeshes[j]].get();
+
+            int n_tris = mesh->mNumFaces;
+            int n_verts = mesh->mNumVertices = n_tris * 3;
+
+            aiVector3D *mv = mesh->mVertices = new aiVector3D[n_verts], *mn = 0, *mc = 0;
+            if (_vflags & 1) {
+                mn = mesh->mNormals = new aiVector3D[n_verts];
+            }
+            if (_tcsets) {
+                mc = mesh->mTextureCoords[0] = new aiVector3D[n_verts];
+            }
+
+            aiFace *face = mesh->mFaces;
+
+            vector<vector<aiVertexWeight>> vweights(_nodes.size());
+
+            for (int vertIdx = 0; vertIdx < n_verts; vertIdx += 3) {
+                for (int faceIndex = 0; faceIndex < 3; ++faceIndex) {
+                    Vertex &v = _vertices[face->mIndices[faceIndex]];
+
+                    *mv++ = v.vertex;
+                    if (mn) *mn++ = v.normal;
+                    if (mc) *mc++ = v.texcoords;
+
+                    face->mIndices[faceIndex] = vertIdx + faceIndex;
+
+                    for (int k = 0; k < 4; ++k) {
+                        if (!v.weights[k])
+                            break;
+
+                        int bone = v.bones[k];
+                        float weight = v.weights[k];
+
+                        vweights[bone].push_back(aiVertexWeight(vertIdx + faceIndex, weight));
+                    }
+                }
+                ++face;
+            }
+
+            vector<aiBone *> bones;
+            for (size_t weightIndx = 0; weightIndx < vweights.size(); ++weightIndx) {
+                vector<aiVertexWeight> &weights = vweights[weightIndx];
+                if (!weights.size()) {
+                    continue;
+                }
+
+                aiBone *bone = new aiBone;
+                bones.push_back(bone);
+
+                aiNode *bnode = _nodes[weightIndx];
+
+                bone->mName = bnode->mName;
+                bone->mNumWeights = static_cast<unsigned int>(weights.size());
+                bone->mWeights = to_array(weights);
+
+                aiMatrix4x4 mat = bnode->mTransformation;
+                while (bnode->mParent) {
+                    bnode = bnode->mParent;
+                    mat = bnode->mTransformation * mat;
+                }
+                bone->mOffsetMatrix = mat.Inverse();
+            }
+            mesh->mNumBones = static_cast<unsigned int>(bones.size());
+            mesh->mBones = to_array(bones);
+        }
+    }
+
+    //nodes
+    scene->mRootNode = _nodes[0];
+    _nodes.clear(); // node ownership now belongs to scene
+
+    //material
+    if (!_materials.size()) {
+        _materials.emplace_back(std::unique_ptr<aiMaterial>(new aiMaterial));
+    }
+    scene->mNumMaterials = static_cast<unsigned int>(_materials.size());
+    scene->mMaterials = unique_to_array(_materials);
+
+    //meshes
+    scene->mNumMeshes = static_cast<unsigned int>(_meshes.size());
+    scene->mMeshes = unique_to_array(_meshes);
+
+    //animations
+    if (_animations.size() == 1 && _nodeAnims.size()) {
+
+        aiAnimation *anim = _animations.back().get();
+        anim->mNumChannels = static_cast<unsigned int>(_nodeAnims.size());
+        anim->mChannels = unique_to_array(_nodeAnims);
+
+        scene->mNumAnimations = static_cast<unsigned int>(_animations.size());
+        scene->mAnimations = unique_to_array(_animations);
+    }
+
+    // convert to RH
+    MakeLeftHandedProcess makeleft;
+    makeleft.Execute(scene);
+
+    FlipWindingOrderProcess flip;
+    flip.Execute(scene);
+}
+
+#endif // !! ASSIMP_BUILD_NO_B3D_IMPORTER
diff --git a/Engine/lib/assimp/code/B3D/B3DImporter.h b/Engine/lib/assimp/code/AssetLib/B3D/B3DImporter.h
similarity index 85%
rename from Engine/lib/assimp/code/B3D/B3DImporter.h
rename to Engine/lib/assimp/code/AssetLib/B3D/B3DImporter.h
index d52dac34a..e47d9078b 100644
--- a/Engine/lib/assimp/code/B3D/B3DImporter.h
+++ b/Engine/lib/assimp/code/AssetLib/B3D/B3DImporter.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -40,8 +39,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
-/** @file Definition of the .b3d importer class. */
-
+/**
+ *  @file Definition of the .b3d importer class.
+ */
+#pragma once
 #ifndef AI_B3DIMPORTER_H_INC
 #define AI_B3DIMPORTER_H_INC
 
@@ -62,14 +63,12 @@ namespace Assimp{
 class B3DImporter : public BaseImporter{
 public:
     B3DImporter() = default;
-    virtual ~B3DImporter();
-
-    virtual bool CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const;
+    ~B3DImporter() override;
+    bool CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const override;
 
 protected:
-
-    virtual const aiImporterDesc* GetInfo () const;
-    virtual void InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler);
+    const aiImporterDesc* GetInfo () const override;
+    void InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) override;
 
 private:
 
@@ -82,7 +81,7 @@ private:
     std::string ReadString();
     std::string ReadChunk();
     void ExitChunk();
-    unsigned ChunkSize();
+    size_t ChunkSize();
 
     template<class T>
     T *to_array( const std::vector<T> &v );
@@ -96,7 +95,7 @@ private:
     };
 
     AI_WONT_RETURN void Oops() AI_WONT_RETURN_SUFFIX;
-    AI_WONT_RETURN void Fail( std::string str ) AI_WONT_RETURN_SUFFIX;
+    AI_WONT_RETURN void Fail(const std::string &str) AI_WONT_RETURN_SUFFIX;
 
     void ReadTEXS();
     void ReadBRUS();
@@ -112,10 +111,9 @@ private:
 
     void ReadBB3D( aiScene *scene );
 
-    unsigned _pos;
-//  unsigned _size;
+    size_t _pos;
     std::vector<unsigned char> _buf;
-    std::vector<unsigned> _stack;
+    std::vector<size_t> _stack;
 
     std::vector<std::string> _textures;
     std::vector<std::unique_ptr<aiMaterial> > _materials;
diff --git a/Engine/lib/assimp/code/AssetLib/BVH/BVHLoader.cpp b/Engine/lib/assimp/code/AssetLib/BVH/BVHLoader.cpp
new file mode 100644
index 000000000..174836847
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/BVH/BVHLoader.cpp
@@ -0,0 +1,528 @@
+/** Implementation of the BVH loader */
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+#ifndef ASSIMP_BUILD_NO_BVH_IMPORTER
+
+#include "BVHLoader.h"
+#include <assimp/SkeletonMeshBuilder.h>
+#include <assimp/TinyFormatter.h>
+#include <assimp/fast_atof.h>
+#include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/IOSystem.hpp>
+#include <assimp/Importer.hpp>
+#include <map>
+#include <memory>
+
+using namespace Assimp;
+using namespace Assimp::Formatter;
+
+static const aiImporterDesc desc = {
+    "BVH Importer (MoCap)",
+    "",
+    "",
+    "",
+    aiImporterFlags_SupportTextFlavour,
+    0,
+    0,
+    0,
+    0,
+    "bvh"
+};
+
+// ------------------------------------------------------------------------------------------------
+// Aborts the file reading with an exception
+template<typename... T>
+AI_WONT_RETURN void BVHLoader::ThrowException(T&&... args) {
+    throw DeadlyImportError(mFileName, ":", mLine, " - ", args...);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Constructor to be privately used by Importer
+BVHLoader::BVHLoader() :
+        mLine(),
+        mAnimTickDuration(),
+        mAnimNumFrames(),
+        noSkeletonMesh() {}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor, private as well
+BVHLoader::~BVHLoader() {}
+
+// ------------------------------------------------------------------------------------------------
+// Returns whether the class can handle the format of the given file.
+bool BVHLoader::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
+    static const char *tokens[] = { "HIERARCHY" };
+    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
+}
+
+// ------------------------------------------------------------------------------------------------
+void BVHLoader::SetupProperties(const Importer *pImp) {
+    noSkeletonMesh = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_NO_SKELETON_MESHES, 0) != 0;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Loader meta information
+const aiImporterDesc *BVHLoader::GetInfo() const {
+    return &desc;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Imports the given file into the given scene structure.
+void BVHLoader::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
+    mFileName = pFile;
+
+    // read file into memory
+    std::unique_ptr<IOStream> file(pIOHandler->Open(pFile));
+    if (file.get() == nullptr) {
+        throw DeadlyImportError("Failed to open file ", pFile, ".");
+    }
+
+    size_t fileSize = file->FileSize();
+    if (fileSize == 0) {
+        throw DeadlyImportError("File is too small.");
+    }
+
+    mBuffer.resize(fileSize);
+    file->Read(&mBuffer.front(), 1, fileSize);
+
+    // start reading
+    mReader = mBuffer.begin();
+    mLine = 1;
+    ReadStructure(pScene);
+
+    if (!noSkeletonMesh) {
+        // build a dummy mesh for the skeleton so that we see something at least
+        SkeletonMeshBuilder meshBuilder(pScene);
+    }
+
+    // construct an animation from all the motion data we read
+    CreateAnimation(pScene);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the file
+void BVHLoader::ReadStructure(aiScene *pScene) {
+    // first comes hierarchy
+    std::string header = GetNextToken();
+    if (header != "HIERARCHY")
+        ThrowException("Expected header string \"HIERARCHY\".");
+    ReadHierarchy(pScene);
+
+    // then comes the motion data
+    std::string motion = GetNextToken();
+    if (motion != "MOTION")
+        ThrowException("Expected beginning of motion data \"MOTION\".");
+    ReadMotion(pScene);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the hierarchy
+void BVHLoader::ReadHierarchy(aiScene *pScene) {
+    std::string root = GetNextToken();
+    if (root != "ROOT")
+        ThrowException("Expected root node \"ROOT\".");
+
+    // Go read the hierarchy from here
+    pScene->mRootNode = ReadNode();
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a node and recursively its children and returns the created node;
+aiNode *BVHLoader::ReadNode() {
+    // first token is name
+    std::string nodeName = GetNextToken();
+    if (nodeName.empty() || nodeName == "{")
+        ThrowException("Expected node name, but found \"", nodeName, "\".");
+
+    // then an opening brace should follow
+    std::string openBrace = GetNextToken();
+    if (openBrace != "{")
+        ThrowException("Expected opening brace \"{\", but found \"", openBrace, "\".");
+
+    // Create a node
+    aiNode *node = new aiNode(nodeName);
+    std::vector<aiNode *> childNodes;
+
+    // and create an bone entry for it
+    mNodes.push_back(Node(node));
+    Node &internNode = mNodes.back();
+
+    // now read the node's contents
+    std::string siteToken;
+    while (1) {
+        std::string token = GetNextToken();
+
+        // node offset to parent node
+        if (token == "OFFSET")
+            ReadNodeOffset(node);
+        else if (token == "CHANNELS")
+            ReadNodeChannels(internNode);
+        else if (token == "JOINT") {
+            // child node follows
+            aiNode *child = ReadNode();
+            child->mParent = node;
+            childNodes.push_back(child);
+        } else if (token == "End") {
+            // The real symbol is "End Site". Second part comes in a separate token
+            siteToken.clear();
+            siteToken = GetNextToken();
+            if (siteToken != "Site")
+                ThrowException("Expected \"End Site\" keyword, but found \"", token, " ", siteToken, "\".");
+
+            aiNode *child = ReadEndSite(nodeName);
+            child->mParent = node;
+            childNodes.push_back(child);
+        } else if (token == "}") {
+            // we're done with that part of the hierarchy
+            break;
+        } else {
+            // everything else is a parse error
+            ThrowException("Unknown keyword \"", token, "\".");
+        }
+    }
+
+    // add the child nodes if there are any
+    if (childNodes.size() > 0) {
+        node->mNumChildren = static_cast<unsigned int>(childNodes.size());
+        node->mChildren = new aiNode *[node->mNumChildren];
+        std::copy(childNodes.begin(), childNodes.end(), node->mChildren);
+    }
+
+    // and return the sub-hierarchy we built here
+    return node;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an end node and returns the created node.
+aiNode *BVHLoader::ReadEndSite(const std::string &pParentName) {
+    // check opening brace
+    std::string openBrace = GetNextToken();
+    if (openBrace != "{")
+        ThrowException("Expected opening brace \"{\", but found \"", openBrace, "\".");
+
+    // Create a node
+    aiNode *node = new aiNode("EndSite_" + pParentName);
+
+    // now read the node's contents. Only possible entry is "OFFSET"
+    std::string token;
+    while (1) {
+        token.clear();
+        token = GetNextToken();
+
+        // end node's offset
+        if (token == "OFFSET") {
+            ReadNodeOffset(node);
+        } else if (token == "}") {
+            // we're done with the end node
+            break;
+        } else {
+            // everything else is a parse error
+            ThrowException("Unknown keyword \"", token, "\".");
+        }
+    }
+
+    // and return the sub-hierarchy we built here
+    return node;
+}
+// ------------------------------------------------------------------------------------------------
+// Reads a node offset for the given node
+void BVHLoader::ReadNodeOffset(aiNode *pNode) {
+    // Offset consists of three floats to read
+    aiVector3D offset;
+    offset.x = GetNextTokenAsFloat();
+    offset.y = GetNextTokenAsFloat();
+    offset.z = GetNextTokenAsFloat();
+
+    // build a transformation matrix from it
+    pNode->mTransformation = aiMatrix4x4(1.0f, 0.0f, 0.0f, offset.x,
+            0.0f, 1.0f, 0.0f, offset.y,
+            0.0f, 0.0f, 1.0f, offset.z,
+            0.0f, 0.0f, 0.0f, 1.0f);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the animation channels for the given node
+void BVHLoader::ReadNodeChannels(BVHLoader::Node &pNode) {
+    // number of channels. Use the float reader because we're lazy
+    float numChannelsFloat = GetNextTokenAsFloat();
+    unsigned int numChannels = (unsigned int)numChannelsFloat;
+
+    for (unsigned int a = 0; a < numChannels; a++) {
+        std::string channelToken = GetNextToken();
+
+        if (channelToken == "Xposition")
+            pNode.mChannels.push_back(Channel_PositionX);
+        else if (channelToken == "Yposition")
+            pNode.mChannels.push_back(Channel_PositionY);
+        else if (channelToken == "Zposition")
+            pNode.mChannels.push_back(Channel_PositionZ);
+        else if (channelToken == "Xrotation")
+            pNode.mChannels.push_back(Channel_RotationX);
+        else if (channelToken == "Yrotation")
+            pNode.mChannels.push_back(Channel_RotationY);
+        else if (channelToken == "Zrotation")
+            pNode.mChannels.push_back(Channel_RotationZ);
+        else
+            ThrowException("Invalid channel specifier \"", channelToken, "\".");
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the motion data
+void BVHLoader::ReadMotion(aiScene * /*pScene*/) {
+    // Read number of frames
+    std::string tokenFrames = GetNextToken();
+    if (tokenFrames != "Frames:")
+        ThrowException("Expected frame count \"Frames:\", but found \"", tokenFrames, "\".");
+
+    float numFramesFloat = GetNextTokenAsFloat();
+    mAnimNumFrames = (unsigned int)numFramesFloat;
+
+    // Read frame duration
+    std::string tokenDuration1 = GetNextToken();
+    std::string tokenDuration2 = GetNextToken();
+    if (tokenDuration1 != "Frame" || tokenDuration2 != "Time:")
+        ThrowException("Expected frame duration \"Frame Time:\", but found \"", tokenDuration1, " ", tokenDuration2, "\".");
+
+    mAnimTickDuration = GetNextTokenAsFloat();
+
+    // resize value vectors for each node
+    for (std::vector<Node>::iterator it = mNodes.begin(); it != mNodes.end(); ++it)
+        it->mChannelValues.reserve(it->mChannels.size() * mAnimNumFrames);
+
+    // now read all the data and store it in the corresponding node's value vector
+    for (unsigned int frame = 0; frame < mAnimNumFrames; ++frame) {
+        // on each line read the values for all nodes
+        for (std::vector<Node>::iterator it = mNodes.begin(); it != mNodes.end(); ++it) {
+            // get as many values as the node has channels
+            for (unsigned int c = 0; c < it->mChannels.size(); ++c)
+                it->mChannelValues.push_back(GetNextTokenAsFloat());
+        }
+
+        // after one frame worth of values for all nodes there should be a newline, but we better don't rely on it
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Retrieves the next token
+std::string BVHLoader::GetNextToken() {
+    // skip any preceding whitespace
+    while (mReader != mBuffer.end()) {
+        if (!isspace((unsigned char)*mReader))
+            break;
+
+        // count lines
+        if (*mReader == '\n')
+            mLine++;
+
+        ++mReader;
+    }
+
+    // collect all chars till the next whitespace. BVH is easy in respect to that.
+    std::string token;
+    while (mReader != mBuffer.end()) {
+        if (isspace((unsigned char)*mReader))
+            break;
+
+        token.push_back(*mReader);
+        ++mReader;
+
+        // little extra logic to make sure braces are counted correctly
+        if (token == "{" || token == "}")
+            break;
+    }
+
+    // empty token means end of file, which is just fine
+    return token;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the next token as a float
+float BVHLoader::GetNextTokenAsFloat() {
+    std::string token = GetNextToken();
+    if (token.empty())
+        ThrowException("Unexpected end of file while trying to read a float");
+
+    // check if the float is valid by testing if the atof() function consumed every char of the token
+    const char *ctoken = token.c_str();
+    float result = 0.0f;
+    ctoken = fast_atoreal_move<float>(ctoken, result);
+
+    if (ctoken != token.c_str() + token.length())
+        ThrowException("Expected a floating point number, but found \"", token, "\".");
+
+    return result;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Constructs an animation for the motion data and stores it in the given scene
+void BVHLoader::CreateAnimation(aiScene *pScene) {
+    // create the animation
+    pScene->mNumAnimations = 1;
+    pScene->mAnimations = new aiAnimation *[1];
+    aiAnimation *anim = new aiAnimation;
+    pScene->mAnimations[0] = anim;
+
+    // put down the basic parameters
+    anim->mName.Set("Motion");
+    anim->mTicksPerSecond = 1.0 / double(mAnimTickDuration);
+    anim->mDuration = double(mAnimNumFrames - 1);
+
+    // now generate the tracks for all nodes
+    anim->mNumChannels = static_cast<unsigned int>(mNodes.size());
+    anim->mChannels = new aiNodeAnim *[anim->mNumChannels];
+
+    // FIX: set the array elements to nullptr to ensure proper deletion if an exception is thrown
+    for (unsigned int i = 0; i < anim->mNumChannels; ++i)
+        anim->mChannels[i] = nullptr;
+
+    for (unsigned int a = 0; a < anim->mNumChannels; a++) {
+        const Node &node = mNodes[a];
+        const std::string nodeName = std::string(node.mNode->mName.data);
+        aiNodeAnim *nodeAnim = new aiNodeAnim;
+        anim->mChannels[a] = nodeAnim;
+        nodeAnim->mNodeName.Set(nodeName);
+        std::map<BVHLoader::ChannelType, int> channelMap;
+
+        //Build map of channels
+        for (unsigned int channel = 0; channel < node.mChannels.size(); ++channel) {
+            channelMap[node.mChannels[channel]] = channel;
+        }
+
+        // translational part, if given
+        if (node.mChannels.size() == 6) {
+            nodeAnim->mNumPositionKeys = mAnimNumFrames;
+            nodeAnim->mPositionKeys = new aiVectorKey[mAnimNumFrames];
+            aiVectorKey *poskey = nodeAnim->mPositionKeys;
+            for (unsigned int fr = 0; fr < mAnimNumFrames; ++fr) {
+                poskey->mTime = double(fr);
+
+                // Now compute all translations
+                for (BVHLoader::ChannelType channel = Channel_PositionX; channel <= Channel_PositionZ; channel = (BVHLoader::ChannelType)(channel + 1)) {
+                    //Find channel in node
+                    std::map<BVHLoader::ChannelType, int>::iterator mapIter = channelMap.find(channel);
+
+                    if (mapIter == channelMap.end())
+                        throw DeadlyImportError("Missing position channel in node ", nodeName);
+                    else {
+                        int channelIdx = mapIter->second;
+                        switch (channel) {
+                        case Channel_PositionX:
+                            poskey->mValue.x = node.mChannelValues[fr * node.mChannels.size() + channelIdx];
+                            break;
+                        case Channel_PositionY:
+                            poskey->mValue.y = node.mChannelValues[fr * node.mChannels.size() + channelIdx];
+                            break;
+                        case Channel_PositionZ:
+                            poskey->mValue.z = node.mChannelValues[fr * node.mChannels.size() + channelIdx];
+                            break;
+
+                        default:
+                            break;
+                        }
+                    }
+                }
+                ++poskey;
+            }
+        } else {
+            // if no translation part is given, put a default sequence
+            aiVector3D nodePos(node.mNode->mTransformation.a4, node.mNode->mTransformation.b4, node.mNode->mTransformation.c4);
+            nodeAnim->mNumPositionKeys = 1;
+            nodeAnim->mPositionKeys = new aiVectorKey[1];
+            nodeAnim->mPositionKeys[0].mTime = 0.0;
+            nodeAnim->mPositionKeys[0].mValue = nodePos;
+        }
+
+        // rotation part. Always present. First find value offsets
+        {
+
+            // Then create the number of rotation keys
+            nodeAnim->mNumRotationKeys = mAnimNumFrames;
+            nodeAnim->mRotationKeys = new aiQuatKey[mAnimNumFrames];
+            aiQuatKey *rotkey = nodeAnim->mRotationKeys;
+            for (unsigned int fr = 0; fr < mAnimNumFrames; ++fr) {
+                aiMatrix4x4 temp;
+                aiMatrix3x3 rotMatrix;
+				for (unsigned int channelIdx = 0; channelIdx < node.mChannels.size(); ++ channelIdx) {
+					switch (node.mChannels[channelIdx]) {
+                    case Channel_RotationX:
+                        {
+                        const float angle = node.mChannelValues[fr * node.mChannels.size() + channelIdx] * float(AI_MATH_PI) / 180.0f;
+                        aiMatrix4x4::RotationX( angle, temp); rotMatrix *= aiMatrix3x3( temp);
+                        }
+                        break;
+                    case Channel_RotationY:
+                        {
+                        const float angle = node.mChannelValues[fr * node.mChannels.size() + channelIdx] * float(AI_MATH_PI) / 180.0f;
+                        aiMatrix4x4::RotationY( angle, temp); rotMatrix *= aiMatrix3x3( temp);
+                        }
+                        break;
+                    case Channel_RotationZ:
+                        {
+                        const float angle = node.mChannelValues[fr * node.mChannels.size() + channelIdx] * float(AI_MATH_PI) / 180.0f;
+                        aiMatrix4x4::RotationZ( angle, temp); rotMatrix *= aiMatrix3x3( temp);
+                        }
+                        break;
+                    default:
+                        break;
+					}
+				}
+                rotkey->mTime = double(fr);
+                rotkey->mValue = aiQuaternion(rotMatrix);
+                ++rotkey;
+            }
+        }
+
+        // scaling part. Always just a default track
+        {
+            nodeAnim->mNumScalingKeys = 1;
+            nodeAnim->mScalingKeys = new aiVectorKey[1];
+            nodeAnim->mScalingKeys[0].mTime = 0.0;
+            nodeAnim->mScalingKeys[0].mValue.Set(1.0f, 1.0f, 1.0f);
+        }
+    }
+}
+
+#endif // !! ASSIMP_BUILD_NO_BVH_IMPORTER
diff --git a/Engine/lib/assimp/code/BVH/BVHLoader.h b/Engine/lib/assimp/code/AssetLib/BVH/BVHLoader.h
similarity index 80%
rename from Engine/lib/assimp/code/BVH/BVHLoader.h
rename to Engine/lib/assimp/code/AssetLib/BVH/BVHLoader.h
index 33b4e2453..56c32bd99 100644
--- a/Engine/lib/assimp/code/BVH/BVHLoader.h
+++ b/Engine/lib/assimp/code/AssetLib/BVH/BVHLoader.h
@@ -4,7 +4,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -53,8 +53,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 struct aiNode;
 
-namespace Assimp
-{
+namespace Assimp {
 
 // --------------------------------------------------------------------------------
 /** Loader class to read Motion Capturing data from a .bvh file.
@@ -63,12 +62,10 @@ namespace Assimp
  * the hierarchy. It contains no actual mesh data, but we generate a dummy mesh
  * inside the loader just to be able to see something.
 */
-class BVHLoader : public BaseImporter
-{
+class BVHLoader : public BaseImporter {
 
     /** Possible animation channels for which the motion data holds the values */
-    enum ChannelType
-    {
+    enum ChannelType {
         Channel_PositionX,
         Channel_PositionY,
         Channel_PositionZ,
@@ -78,61 +75,57 @@ class BVHLoader : public BaseImporter
     };
 
     /** Collected list of node. Will be bones of the dummy mesh some day, addressed by their array index */
-    struct Node
-    {
-        const aiNode* mNode;
+    struct Node {
+        const aiNode *mNode;
         std::vector<ChannelType> mChannels;
         std::vector<float> mChannelValues; // motion data values for that node. Of size NumChannels * NumFrames
 
-        Node()
-        : mNode(nullptr)
-        { }
+        Node() :
+                mNode(nullptr) {}
 
-        explicit Node( const aiNode* pNode) : mNode( pNode) { }
+        explicit Node(const aiNode *pNode) :
+                mNode(pNode) {}
     };
 
 public:
-
     BVHLoader();
     ~BVHLoader();
 
 public:
     /** Returns whether the class can handle the format of the given file.
      * See BaseImporter::CanRead() for details. */
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler, bool cs) const;
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool cs) const;
 
-    void SetupProperties(const Importer* pImp);
-    const aiImporterDesc* GetInfo () const;
+    void SetupProperties(const Importer *pImp);
+    const aiImporterDesc *GetInfo() const;
 
 protected:
-
-
     /** Imports the given file into the given scene structure.
      * See BaseImporter::InternReadFile() for details
      */
-    void InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler);
+    void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler);
 
 protected:
     /** Reads the file */
-    void ReadStructure( aiScene* pScene);
+    void ReadStructure(aiScene *pScene);
 
     /** Reads the hierarchy */
-    void ReadHierarchy( aiScene* pScene);
+    void ReadHierarchy(aiScene *pScene);
 
-    /** Reads a node and recursively its childs and returns the created node. */
-    aiNode* ReadNode();
+    /** Reads a node and recursively its children and returns the created node. */
+    aiNode *ReadNode();
 
     /** Reads an end node and returns the created node. */
-    aiNode* ReadEndSite( const std::string& pParentName);
+    aiNode *ReadEndSite(const std::string &pParentName);
 
     /** Reads a node offset for the given node */
-    void ReadNodeOffset( aiNode* pNode);
+    void ReadNodeOffset(aiNode *pNode);
 
     /** Reads the animation channels into the given node */
-    void ReadNodeChannels( BVHLoader::Node& pNode);
+    void ReadNodeChannels(BVHLoader::Node &pNode);
 
     /** Reads the motion data */
-    void ReadMotion( aiScene* pScene);
+    void ReadMotion(aiScene *pScene);
 
     /** Retrieves the next token */
     std::string GetNextToken();
@@ -141,10 +134,11 @@ protected:
     float GetNextTokenAsFloat();
 
     /** Aborts the file reading with an exception */
-    AI_WONT_RETURN void ThrowException( const std::string& pError) AI_WONT_RETURN_SUFFIX;
+    template<typename... T>
+    AI_WONT_RETURN void ThrowException(T&&... args) AI_WONT_RETURN_SUFFIX;
 
     /** Constructs an animation for the motion data and stores it in the given scene */
-    void CreateAnimation( aiScene* pScene);
+    void CreateAnimation(aiScene *pScene);
 
 protected:
     /** Filename, for a verbose error message */
diff --git a/Engine/lib/assimp/code/Blender/BlenderBMesh.cpp b/Engine/lib/assimp/code/AssetLib/Blender/BlenderBMesh.cpp
similarity index 54%
rename from Engine/lib/assimp/code/Blender/BlenderBMesh.cpp
rename to Engine/lib/assimp/code/AssetLib/Blender/BlenderBMesh.cpp
index 8a13819a6..be536ebdb 100644
--- a/Engine/lib/assimp/code/Blender/BlenderBMesh.cpp
+++ b/Engine/lib/assimp/code/AssetLib/Blender/BlenderBMesh.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2013, assimp team
+Copyright (c) 2006-2022, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -42,165 +42,143 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Conversion of Blender's new BMesh stuff
  */
 
-
 #ifndef ASSIMP_BUILD_NO_BLEND_IMPORTER
 
+#include "BlenderBMesh.h"
 #include "BlenderDNA.h"
 #include "BlenderScene.h"
-#include "BlenderBMesh.h"
 #include "BlenderTessellator.h"
 
-namespace Assimp
-{
-    template< > const char* LogFunctions< BlenderBMeshConverter >::Prefix()
-    {
-        static auto prefix = "BLEND_BMESH: ";
-        return prefix;
-    }
+namespace Assimp {
+template <>
+const char *LogFunctions<BlenderBMeshConverter>::Prefix() {
+    static auto prefix = "BLEND_BMESH: ";
+    return prefix;
 }
+} // namespace Assimp
 
 using namespace Assimp;
 using namespace Assimp::Blender;
 using namespace Assimp::Formatter;
 
 // ------------------------------------------------------------------------------------------------
-BlenderBMeshConverter::BlenderBMeshConverter( const Mesh* mesh ):
-    BMesh( mesh ),
-    triMesh( NULL )
-{
+BlenderBMeshConverter::BlenderBMeshConverter(const Mesh *mesh) :
+        BMesh(mesh),
+        triMesh(nullptr) {
+    ai_assert(nullptr != mesh);
 }
 
 // ------------------------------------------------------------------------------------------------
-BlenderBMeshConverter::~BlenderBMeshConverter( )
-{
-    DestroyTriMesh( );
+BlenderBMeshConverter::~BlenderBMeshConverter() {
+    DestroyTriMesh();
 }
 
 // ------------------------------------------------------------------------------------------------
-bool BlenderBMeshConverter::ContainsBMesh( ) const
-{
+bool BlenderBMeshConverter::ContainsBMesh() const {
     // TODO - Should probably do some additional verification here
     return BMesh->totpoly && BMesh->totloop && BMesh->totvert;
 }
 
 // ------------------------------------------------------------------------------------------------
-const Mesh* BlenderBMeshConverter::TriangulateBMesh( )
-{
-    AssertValidMesh( );
-    AssertValidSizes( );
-    PrepareTriMesh( );
+const Mesh *BlenderBMeshConverter::TriangulateBMesh() {
+    AssertValidMesh();
+    AssertValidSizes();
+    PrepareTriMesh();
 
-    for ( int i = 0; i < BMesh->totpoly; ++i )
-    {
-        const MPoly& poly = BMesh->mpoly[ i ];
-        ConvertPolyToFaces( poly );
+    for (int i = 0; i < BMesh->totpoly; ++i) {
+        const MPoly &poly = BMesh->mpoly[i];
+        ConvertPolyToFaces(poly);
     }
 
     return triMesh;
 }
 
 // ------------------------------------------------------------------------------------------------
-void BlenderBMeshConverter::AssertValidMesh( )
-{
-    if ( !ContainsBMesh( ) )
-    {
-        ThrowException( "BlenderBMeshConverter requires a BMesh with \"polygons\" - please call BlenderBMeshConverter::ContainsBMesh to check this first" );
+void BlenderBMeshConverter::AssertValidMesh() {
+    if (!ContainsBMesh()) {
+        ThrowException("BlenderBMeshConverter requires a BMesh with \"polygons\" - please call BlenderBMeshConverter::ContainsBMesh to check this first");
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void BlenderBMeshConverter::AssertValidSizes( )
-{
-    if ( BMesh->totpoly != static_cast<int>( BMesh->mpoly.size( ) ) )
-    {
-        ThrowException( "BMesh poly array has incorrect size" );
+void BlenderBMeshConverter::AssertValidSizes() {
+    if (BMesh->totpoly != static_cast<int>(BMesh->mpoly.size())) {
+        ThrowException("BMesh poly array has incorrect size");
     }
-    if ( BMesh->totloop != static_cast<int>( BMesh->mloop.size( ) ) )
-    {
-        ThrowException( "BMesh loop array has incorrect size" );
+    if (BMesh->totloop != static_cast<int>(BMesh->mloop.size())) {
+        ThrowException("BMesh loop array has incorrect size");
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void BlenderBMeshConverter::PrepareTriMesh( )
-{
-    if ( triMesh )
-    {
-        DestroyTriMesh( );
+void BlenderBMeshConverter::PrepareTriMesh() {
+    if (triMesh) {
+        DestroyTriMesh();
     }
 
-    triMesh = new Mesh( *BMesh );
+    triMesh = new Mesh(*BMesh);
     triMesh->totface = 0;
-    triMesh->mface.clear( );
+    triMesh->mface.clear();
 }
 
 // ------------------------------------------------------------------------------------------------
-void BlenderBMeshConverter::DestroyTriMesh( )
-{
+void BlenderBMeshConverter::DestroyTriMesh() {
     delete triMesh;
-    triMesh = NULL;
+    triMesh = nullptr;
 }
 
 // ------------------------------------------------------------------------------------------------
-void BlenderBMeshConverter::ConvertPolyToFaces( const MPoly& poly )
-{
-    const MLoop* polyLoop = &BMesh->mloop[ poly.loopstart ];
+void BlenderBMeshConverter::ConvertPolyToFaces(const MPoly &poly) {
+    const MLoop *polyLoop = &BMesh->mloop[poly.loopstart];
 
-    if ( poly.totloop == 3 || poly.totloop == 4 )
-    {
-        AddFace( polyLoop[ 0 ].v, polyLoop[ 1 ].v, polyLoop[ 2 ].v, poly.totloop == 4 ? polyLoop[ 3 ].v : 0 );
+    if (poly.totloop == 3 || poly.totloop == 4) {
+        AddFace(polyLoop[0].v, polyLoop[1].v, polyLoop[2].v, poly.totloop == 4 ? polyLoop[3].v : 0);
 
         // UVs are optional, so only convert when present.
-        if ( BMesh->mloopuv.size() )
-        {
-            if ( (poly.loopstart + poly.totloop ) > static_cast<int>( BMesh->mloopuv.size() ) )
-            {
-                ThrowException( "BMesh uv loop array has incorrect size" );
+        if (BMesh->mloopuv.size()) {
+            if ((poly.loopstart + poly.totloop) > static_cast<int>(BMesh->mloopuv.size())) {
+                ThrowException("BMesh uv loop array has incorrect size");
             }
-            const MLoopUV* loopUV = &BMesh->mloopuv[ poly.loopstart ];
-            AddTFace( loopUV[ 0 ].uv, loopUV[ 1 ].uv, loopUV[ 2 ].uv, poly.totloop == 4 ? loopUV[ 3 ].uv : 0 );
+            const MLoopUV *loopUV = &BMesh->mloopuv[poly.loopstart];
+            AddTFace(loopUV[0].uv, loopUV[1].uv, loopUV[2].uv, poly.totloop == 4 ? loopUV[3].uv : 0);
         }
-    }
-    else if ( poly.totloop > 4 )
-    {
+    } else if (poly.totloop > 4) {
 #if ASSIMP_BLEND_WITH_GLU_TESSELLATE
-        BlenderTessellatorGL tessGL( *this );
-        tessGL.Tessellate( polyLoop, poly.totloop, triMesh->mvert );
+        BlenderTessellatorGL tessGL(*this);
+        tessGL.Tessellate(polyLoop, poly.totloop, triMesh->mvert);
 #elif ASSIMP_BLEND_WITH_POLY_2_TRI
-        BlenderTessellatorP2T tessP2T( *this );
-        tessP2T.Tessellate( polyLoop, poly.totloop, triMesh->mvert );
+        BlenderTessellatorP2T tessP2T(*this);
+        tessP2T.Tessellate(polyLoop, poly.totloop, triMesh->mvert);
 #endif
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void BlenderBMeshConverter::AddFace( int v1, int v2, int v3, int v4 )
-{
+void BlenderBMeshConverter::AddFace(int v1, int v2, int v3, int v4) {
     MFace face;
     face.v1 = v1;
     face.v2 = v2;
     face.v3 = v3;
     face.v4 = v4;
+    face.flag = 0;
     // TODO - Work out how materials work
     face.mat_nr = 0;
-    triMesh->mface.push_back( face );
-    triMesh->totface = static_cast<int>(triMesh->mface.size( ));
+    triMesh->mface.push_back(face);
+    triMesh->totface = static_cast<int>(triMesh->mface.size());
 }
 
 // ------------------------------------------------------------------------------------------------
-void BlenderBMeshConverter::AddTFace( const float* uv1, const float *uv2, const float *uv3, const float* uv4 )
-{
+void BlenderBMeshConverter::AddTFace(const float *uv1, const float *uv2, const float *uv3, const float *uv4) {
     MTFace mtface;
-    memcpy( &mtface.uv[ 0 ], uv1, sizeof(float) * 2 );
-    memcpy( &mtface.uv[ 1 ], uv2, sizeof(float) * 2 );
-    memcpy( &mtface.uv[ 2 ], uv3, sizeof(float) * 2 );
+    memcpy(&mtface.uv[0], uv1, sizeof(float) * 2);
+    memcpy(&mtface.uv[1], uv2, sizeof(float) * 2);
+    memcpy(&mtface.uv[2], uv3, sizeof(float) * 2);
 
-    if ( uv4 )
-    {
-        memcpy( &mtface.uv[ 3 ], uv4, sizeof(float) * 2 );
+    if (uv4) {
+        memcpy(&mtface.uv[3], uv4, sizeof(float) * 2);
     }
 
-    triMesh->mtface.push_back( mtface );
+    triMesh->mtface.push_back(mtface);
 }
 
 #endif // ASSIMP_BUILD_NO_BLEND_IMPORTER
diff --git a/Engine/lib/assimp/code/Blender/BlenderBMesh.h b/Engine/lib/assimp/code/AssetLib/Blender/BlenderBMesh.h
similarity index 98%
rename from Engine/lib/assimp/code/Blender/BlenderBMesh.h
rename to Engine/lib/assimp/code/AssetLib/Blender/BlenderBMesh.h
index 5b65fb503..45ca2c806 100644
--- a/Engine/lib/assimp/code/Blender/BlenderBMesh.h
+++ b/Engine/lib/assimp/code/AssetLib/Blender/BlenderBMesh.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2013, assimp team
+Copyright (c) 2006-2022, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
diff --git a/Engine/lib/assimp/code/AssetLib/Blender/BlenderCustomData.cpp b/Engine/lib/assimp/code/AssetLib/Blender/BlenderCustomData.cpp
new file mode 100644
index 000000000..c74a6bb75
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Blender/BlenderCustomData.cpp
@@ -0,0 +1,181 @@
+#include "BlenderCustomData.h"
+#include "BlenderDNA.h"
+#include <array>
+#include <functional>
+
+namespace Assimp {
+namespace Blender {
+/**
+        *   @brief  read/convert of Structure array to memory
+        */
+template <typename T>
+bool read(const Structure &s, T *p, const size_t cnt, const FileDatabase &db) {
+    for (size_t i = 0; i < cnt; ++i) {
+        T read;
+        s.Convert(read, db);
+        *p = read;
+        p++;
+    }
+    return true;
+}
+
+/**
+        *   @brief  pointer to function read memory for n CustomData types
+        */
+typedef bool (*PRead)(ElemBase *pOut, const size_t cnt, const FileDatabase &db);
+typedef ElemBase *(*PCreate)(const size_t cnt);
+typedef void (*PDestroy)(ElemBase *);
+
+#define IMPL_STRUCT_READ(ty)                                               \
+    bool read##ty(ElemBase *v, const size_t cnt, const FileDatabase &db) { \
+        ty *ptr = dynamic_cast<ty *>(v);                                   \
+        if (nullptr == ptr) {                                              \
+            return false;                                                  \
+        }                                                                  \
+        return read<ty>(db.dna[#ty], ptr, cnt, db);                        \
+    }
+
+#define IMPL_STRUCT_CREATE(ty)               \
+    ElemBase *create##ty(const size_t cnt) { \
+        return new ty[cnt];                  \
+    }
+
+#define IMPL_STRUCT_DESTROY(ty)         \
+    void destroy##ty(ElemBase *pE) {    \
+        ty *p = dynamic_cast<ty *>(pE); \
+        delete[] p;                     \
+    }
+
+/**
+        *   @brief  helper macro to define Structure functions
+        */
+#define IMPL_STRUCT(ty)    \
+    IMPL_STRUCT_READ(ty)   \
+    IMPL_STRUCT_CREATE(ty) \
+    IMPL_STRUCT_DESTROY(ty)
+
+// supported structures for CustomData
+IMPL_STRUCT(MVert)
+IMPL_STRUCT(MEdge)
+IMPL_STRUCT(MFace)
+IMPL_STRUCT(MTFace)
+IMPL_STRUCT(MTexPoly)
+IMPL_STRUCT(MLoopUV)
+IMPL_STRUCT(MLoopCol)
+IMPL_STRUCT(MPoly)
+IMPL_STRUCT(MLoop)
+
+/**
+        *   @brief  describes the size of data and the read function to be used for single CustomerData.type
+        */
+struct CustomDataTypeDescription {
+    PRead Read; ///< function to read one CustomData type element
+    PCreate Create; ///< function to allocate n type elements
+    PDestroy Destroy;
+
+    CustomDataTypeDescription(PRead read, PCreate create, PDestroy destroy) :
+            Read(read), Create(create), Destroy(destroy) {}
+};
+
+/**
+        *   @brief  helper macro to define Structure type specific CustomDataTypeDescription
+        *   @note   IMPL_STRUCT_READ for same ty must be used earlier to implement the typespecific read function
+        */
+#define DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(ty) \
+    CustomDataTypeDescription { &read##ty, &create##ty, &destroy##ty }
+
+/**
+        *   @brief  helper macro to define CustomDataTypeDescription for UNSUPPORTED type
+        */
+#define DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION \
+    CustomDataTypeDescription { nullptr, nullptr, nullptr }
+
+/**
+        *   @brief  descriptors for data pointed to from CustomDataLayer.data
+        *   @note   some of the CustomData uses already well defined Structures
+        *           other (like CD_ORCO, ...) uses arrays of rawtypes or even arrays of Structures
+        *           use a special readfunction for that cases
+        */
+std::array<CustomDataTypeDescription, CD_NUMTYPES> customDataTypeDescriptions = { { DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MVert),
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MEdge),
+        DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MFace),
+        DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MTFace),
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MTexPoly),
+        DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MLoopUV),
+        DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MLoopCol),
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MPoly),
+        DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MLoop),
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION } };
+
+bool isValidCustomDataType(const int cdtype) {
+    return cdtype >= 0 && cdtype < CD_NUMTYPES;
+}
+
+bool readCustomData(std::shared_ptr<ElemBase> &out, const int cdtype, const size_t cnt, const FileDatabase &db) {
+    if (!isValidCustomDataType(cdtype)) {
+        throw Error("CustomData.type ", cdtype, " out of index");
+    }
+
+    const CustomDataTypeDescription cdtd = customDataTypeDescriptions[cdtype];
+    if (cdtd.Read && cdtd.Create && cdtd.Destroy && cnt > 0) {
+        // allocate cnt elements and parse them from file
+        out.reset(cdtd.Create(cnt), cdtd.Destroy);
+        return cdtd.Read(out.get(), cnt, db);
+    }
+    return false;
+}
+
+std::shared_ptr<CustomDataLayer> getCustomDataLayer(const CustomData &customdata, const CustomDataType cdtype, const std::string &name) {
+    for (auto it = customdata.layers.begin(); it != customdata.layers.end(); ++it) {
+        if (it->get()->type == cdtype && name == it->get()->name) {
+            return *it;
+        }
+    }
+    return nullptr;
+}
+
+const ElemBase *getCustomDataLayerData(const CustomData &customdata, const CustomDataType cdtype, const std::string &name) {
+    const std::shared_ptr<CustomDataLayer> pLayer = getCustomDataLayer(customdata, cdtype, name);
+    if (pLayer && pLayer->data) {
+        return pLayer->data.get();
+    }
+    return nullptr;
+}
+} // namespace Blender
+} // namespace Assimp
diff --git a/Engine/lib/assimp/code/Blender/BlenderCustomData.h b/Engine/lib/assimp/code/AssetLib/Blender/BlenderCustomData.h
similarity index 100%
rename from Engine/lib/assimp/code/Blender/BlenderCustomData.h
rename to Engine/lib/assimp/code/AssetLib/Blender/BlenderCustomData.h
diff --git a/Engine/lib/assimp/code/Blender/BlenderDNA.cpp b/Engine/lib/assimp/code/AssetLib/Blender/BlenderDNA.cpp
similarity index 69%
rename from Engine/lib/assimp/code/Blender/BlenderDNA.cpp
rename to Engine/lib/assimp/code/AssetLib/Blender/BlenderDNA.cpp
index f274e02f9..2910904ba 100644
--- a/Engine/lib/assimp/code/Blender/BlenderDNA.cpp
+++ b/Engine/lib/assimp/code/AssetLib/Blender/BlenderDNA.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -45,25 +45,24 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *    serialized set of data structures.
  */
 
-
 #ifndef ASSIMP_BUILD_NO_BLEND_IMPORTER
 #include "BlenderDNA.h"
 #include <assimp/StreamReader.h>
-#include <assimp/fast_atof.h>
 #include <assimp/TinyFormatter.h>
+#include <assimp/fast_atof.h>
 
 using namespace Assimp;
 using namespace Assimp::Blender;
 using namespace Assimp::Formatter;
 
-static bool match4(StreamReaderAny& stream, const char* string) {
-    ai_assert( nullptr != string );
+static bool match4(StreamReaderAny &stream, const char *string) {
+    ai_assert(nullptr != string);
     char tmp[4];
-    tmp[ 0 ] = ( stream ).GetI1();
-    tmp[ 1 ] = ( stream ).GetI1();
-    tmp[ 2 ] = ( stream ).GetI1();
-    tmp[ 3 ] = ( stream ).GetI1();
-    return (tmp[0]==string[0] && tmp[1]==string[1] && tmp[2]==string[2] && tmp[3]==string[3]);
+    tmp[0] = (stream).GetI1();
+    tmp[1] = (stream).GetI1();
+    tmp[2] = (stream).GetI1();
+    tmp[3] = (stream).GetI1();
+    return (tmp[0] == string[0] && tmp[1] == string[1] && tmp[2] == string[2] && tmp[3] == string[3]);
 }
 
 struct Type {
@@ -72,76 +71,74 @@ struct Type {
 };
 
 // ------------------------------------------------------------------------------------------------
-void DNAParser::Parse ()
-{
-    StreamReaderAny& stream = *db.reader.get();
-    DNA& dna = db.dna;
+void DNAParser::Parse() {
+    StreamReaderAny &stream = *db.reader.get();
+    DNA &dna = db.dna;
 
-    if(!match4(stream,"SDNA")) {
+    if (!match4(stream, "SDNA")) {
         throw DeadlyImportError("BlenderDNA: Expected SDNA chunk");
     }
 
     // name dictionary
-    if(!match4(stream,"NAME")) {
+    if (!match4(stream, "NAME")) {
         throw DeadlyImportError("BlenderDNA: Expected NAME field");
     }
 
-    std::vector<std::string> names (stream.GetI4());
-    for(std::string& s : names) {
+    std::vector<std::string> names(stream.GetI4());
+    for (std::string &s : names) {
         while (char c = stream.GetI1()) {
             s += c;
         }
     }
 
     // type dictionary
-    for (;stream.GetCurrentPos() & 0x3; stream.GetI1());
-    if(!match4(stream,"TYPE")) {
+    for (; stream.GetCurrentPos() & 0x3; stream.GetI1())
+        ;
+    if (!match4(stream, "TYPE")) {
         throw DeadlyImportError("BlenderDNA: Expected TYPE field");
     }
 
-    std::vector<Type> types (stream.GetI4());
-    for(Type& s : types) {
+    std::vector<Type> types(stream.GetI4());
+    for (Type &s : types) {
         while (char c = stream.GetI1()) {
             s.name += c;
         }
     }
 
     // type length dictionary
-    for (;stream.GetCurrentPos() & 0x3; stream.GetI1());
-    if(!match4(stream,"TLEN")) {
+    for (; stream.GetCurrentPos() & 0x3; stream.GetI1())
+        ;
+    if (!match4(stream, "TLEN")) {
         throw DeadlyImportError("BlenderDNA: Expected TLEN field");
     }
 
-    for(Type& s : types) {
+    for (Type &s : types) {
         s.size = stream.GetI2();
     }
 
     // structures dictionary
-    for (;stream.GetCurrentPos() & 0x3; stream.GetI1());
-    if(!match4(stream,"STRC")) {
+    for (; stream.GetCurrentPos() & 0x3; stream.GetI1())
+        ;
+    if (!match4(stream, "STRC")) {
         throw DeadlyImportError("BlenderDNA: Expected STRC field");
     }
 
     size_t end = stream.GetI4(), fields = 0;
 
     dna.structures.reserve(end);
-    for(size_t i = 0; i != end; ++i) {
+    for (size_t i = 0; i != end; ++i) {
 
         uint16_t n = stream.GetI2();
         if (n >= types.size()) {
-            throw DeadlyImportError((format(),
-                "BlenderDNA: Invalid type index in structure name" ,n,
-                " (there are only ", types.size(), " entries)"
-            ));
+            throw DeadlyImportError("BlenderDNA: Invalid type index in structure name", n, " (there are only ", types.size(), " entries)");
         }
 
         // maintain separate indexes
         dna.indices[types[n].name] = dna.structures.size();
 
         dna.structures.push_back(Structure());
-        Structure& s = dna.structures.back();
-        s.name  = types[n].name;
-        //s.index = dna.structures.size()-1;
+        Structure &s = dna.structures.back();
+        s.name = types[n].name;
 
         n = stream.GetI2();
         s.fields.reserve(n);
@@ -151,13 +148,10 @@ void DNAParser::Parse ()
 
             uint16_t j = stream.GetI2();
             if (j >= types.size()) {
-                throw DeadlyImportError((format(),
-                    "BlenderDNA: Invalid type index in structure field ", j,
-                    " (there are only ", types.size(), " entries)"
-                ));
+                throw DeadlyImportError("BlenderDNA: Invalid type index in structure field ", j, " (there are only ", types.size(), " entries)");
             }
             s.fields.push_back(Field());
-            Field& f = s.fields.back();
+            Field &f = s.fields.back();
             f.offset = offset;
 
             f.type = types[j].name;
@@ -165,10 +159,7 @@ void DNAParser::Parse ()
 
             j = stream.GetI2();
             if (j >= names.size()) {
-                throw DeadlyImportError((format(),
-                    "BlenderDNA: Invalid name index in structure field ", j,
-                    " (there are only ", names.size(), " entries)"
-                ));
+                throw DeadlyImportError("BlenderDNA: Invalid name index in structure field ", j, " (there are only ", names.size(), " entries)");
             }
 
             f.name = names[j];
@@ -190,29 +181,26 @@ void DNAParser::Parse ()
             if (*f.name.rbegin() == ']') {
                 const std::string::size_type rb = f.name.find('[');
                 if (rb == std::string::npos) {
-                    throw DeadlyImportError((format(),
-                        "BlenderDNA: Encountered invalid array declaration ",
-                        f.name
-                    ));
+                    throw DeadlyImportError("BlenderDNA: Encountered invalid array declaration ", f.name);
                 }
 
                 f.flags |= FieldFlag_Array;
-                DNA::ExtractArraySize(f.name,f.array_sizes);
-                f.name = f.name.substr(0,rb);
+                DNA::ExtractArraySize(f.name, f.array_sizes);
+                f.name = f.name.substr(0, rb);
 
                 f.size *= f.array_sizes[0] * f.array_sizes[1];
             }
 
             // maintain separate indexes
-            s.indices[f.name] = s.fields.size()-1;
+            s.indices[f.name] = s.fields.size() - 1;
             offset += f.size;
         }
         s.size = offset;
     }
 
-    ASSIMP_LOG_DEBUG_F( "BlenderDNA: Got ", dna.structures.size()," structures with totally ",fields," fields");
+    ASSIMP_LOG_DEBUG("BlenderDNA: Got ", dna.structures.size(), " structures with totally ", fields, " fields");
 
-#ifdef ASSIMP_BUILD_BLENDER_DEBUG
+#if ASSIMP_BUILD_BLENDER_DEBUG_DNA
     dna.DumpToFile();
 #endif
 
@@ -220,13 +208,11 @@ void DNAParser::Parse ()
     dna.RegisterConverters();
 }
 
-
-#ifdef ASSIMP_BUILD_BLENDER_DEBUG
+#if ASSIMP_BUILD_BLENDER_DEBUG_DNA
 
 #include <fstream>
 // ------------------------------------------------------------------------------------------------
-void DNA :: DumpToFile()
-{
+void DNA ::DumpToFile() {
     // we don't bother using the VFS here for this is only for debugging.
     // (and all your bases are belong to us).
 
@@ -235,12 +221,14 @@ void DNA :: DumpToFile()
         ASSIMP_LOG_ERROR("Could not dump dna to dna.txt");
         return;
     }
-    f << "Field format: type name offset size" << "\n";
-    f << "Structure format: name size" << "\n";
+    f << "Field format: type name offset size"
+      << "\n";
+    f << "Structure format: name size"
+      << "\n";
 
-    for(const Structure& s : structures) {
+    for (const Structure &s : structures) {
         f << s.name << " " << s.size << "\n\n";
-        for(const Field& ff : s.fields) {
+        for (const Field &ff : s.fields) {
             f << "\t" << ff.type << " " << ff.name << " " << ff.offset << " " << ff.size << "\n";
         }
         f << "\n";
@@ -249,14 +237,12 @@ void DNA :: DumpToFile()
 
     ASSIMP_LOG_INFO("BlenderDNA: Dumped dna to dna.txt");
 }
-#endif
+#endif // ASSIMP_BUILD_BLENDER_DEBUG_DNA
 
 // ------------------------------------------------------------------------------------------------
-/*static*/ void  DNA :: ExtractArraySize(
-    const std::string& out,
-    size_t array_sizes[2]
-)
-{
+/*static*/ void DNA ::ExtractArraySize(
+        const std::string &out,
+        size_t array_sizes[2]) {
     array_sizes[0] = array_sizes[1] = 1;
     std::string::size_type pos = out.find('[');
     if (pos++ == std::string::npos) {
@@ -264,7 +250,7 @@ void DNA :: DumpToFile()
     }
     array_sizes[0] = strtoul10(&out[pos]);
 
-    pos = out.find('[',pos);
+    pos = out.find('[', pos);
     if (pos++ == std::string::npos) {
         return;
     }
@@ -272,36 +258,32 @@ void DNA :: DumpToFile()
 }
 
 // ------------------------------------------------------------------------------------------------
-std::shared_ptr< ElemBase > DNA :: ConvertBlobToStructure(
-    const Structure& structure,
-    const FileDatabase& db
-) const
-{
-    std::map<std::string, FactoryPair >::const_iterator it = converters.find(structure.name);
+std::shared_ptr<ElemBase> DNA ::ConvertBlobToStructure(
+        const Structure &structure,
+        const FileDatabase &db) const {
+    std::map<std::string, FactoryPair>::const_iterator it = converters.find(structure.name);
     if (it == converters.end()) {
-        return std::shared_ptr< ElemBase >();
+        return std::shared_ptr<ElemBase>();
     }
 
-    std::shared_ptr< ElemBase > ret = (structure.*((*it).second.first))();
-    (structure.*((*it).second.second))(ret,db);
+    std::shared_ptr<ElemBase> ret = (structure.*((*it).second.first))();
+    (structure.*((*it).second.second))(ret, db);
 
     return ret;
 }
 
 // ------------------------------------------------------------------------------------------------
-DNA::FactoryPair DNA :: GetBlobToStructureConverter(
-    const Structure& structure,
-    const FileDatabase& /*db*/
-) const
-{
-    std::map<std::string,  FactoryPair>::const_iterator it = converters.find(structure.name);
+DNA::FactoryPair DNA ::GetBlobToStructureConverter(
+        const Structure &structure,
+        const FileDatabase & /*db*/
+) const {
+    std::map<std::string, FactoryPair>::const_iterator it = converters.find(structure.name);
     return it == converters.end() ? FactoryPair() : (*it).second;
 }
 
 // basing on http://www.blender.org/development/architecture/notes-on-sdna/
 // ------------------------------------------------------------------------------------------------
-void DNA :: AddPrimitiveStructures()
-{
+void DNA ::AddPrimitiveStructures() {
     // NOTE: these are just dummies. Their presence enforces
     // Structure::Convert<target_type> to be called on these
     // empty structures. These converters are special
@@ -311,30 +293,27 @@ void DNA :: AddPrimitiveStructures()
     // in question.
 
     indices["int"] = structures.size();
-    structures.push_back( Structure() );
+    structures.push_back(Structure());
     structures.back().name = "int";
     structures.back().size = 4;
 
     indices["short"] = structures.size();
-    structures.push_back( Structure() );
+    structures.push_back(Structure());
     structures.back().name = "short";
     structures.back().size = 2;
 
-
     indices["char"] = structures.size();
-    structures.push_back( Structure() );
+    structures.push_back(Structure());
     structures.back().name = "char";
     structures.back().size = 1;
 
-
     indices["float"] = structures.size();
-    structures.push_back( Structure() );
+    structures.push_back(Structure());
     structures.back().name = "float";
     structures.back().size = 4;
 
-
     indices["double"] = structures.size();
-    structures.push_back( Structure() );
+    structures.push_back(Structure());
     structures.back().name = "double";
     structures.back().size = 8;
 
@@ -342,8 +321,7 @@ void DNA :: AddPrimitiveStructures()
 }
 
 // ------------------------------------------------------------------------------------------------
-void SectionParser :: Next()
-{
+void SectionParser ::Next() {
     stream.SetCurrentPos(current.start + current.size);
 
     const char tmp[] = {
@@ -352,7 +330,7 @@ void SectionParser :: Next()
         (const char)stream.GetI1(),
         (const char)stream.GetI1()
     };
-    current.id = std::string(tmp,tmp[3]?4:tmp[2]?3:tmp[1]?2:1);
+    current.id = std::string(tmp, tmp[3] ? 4 : tmp[2] ? 3 : tmp[1] ? 2 : 1);
 
     current.size = stream.GetI4();
     current.address.val = ptr64 ? stream.GetU8() : stream.GetU4();
@@ -366,10 +344,8 @@ void SectionParser :: Next()
     }
 
 #ifdef ASSIMP_BUILD_BLENDER_DEBUG
-    ASSIMP_LOG_DEBUG(current.id);
+    ASSIMP_LOG_VERBOSE_DEBUG(current.id);
 #endif
 }
 
-
-
 #endif
diff --git a/Engine/lib/assimp/code/Blender/BlenderDNA.h b/Engine/lib/assimp/code/AssetLib/Blender/BlenderDNA.h
similarity index 74%
rename from Engine/lib/assimp/code/Blender/BlenderDNA.h
rename to Engine/lib/assimp/code/AssetLib/Blender/BlenderDNA.h
index 375d0c4bf..b2158f283 100644
--- a/Engine/lib/assimp/code/Blender/BlenderDNA.h
+++ b/Engine/lib/assimp/code/AssetLib/Blender/BlenderDNA.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -49,26 +49,34 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <assimp/BaseImporter.h>
 #include <assimp/StreamReader.h>
-#include <assimp/DefaultLogger.hpp>
 #include <stdint.h>
-#include <memory>
+#include <assimp/DefaultLogger.hpp>
 #include <map>
+#include <memory>
 
 // enable verbose log output. really verbose, so be careful.
 #ifdef ASSIMP_BUILD_DEBUG
-#   define ASSIMP_BUILD_BLENDER_DEBUG
+#define ASSIMP_BUILD_BLENDER_DEBUG
+#endif
+
+// set this to non-zero to dump BlenderDNA stuff to dna.txt.
+// you could set it on the assimp build command line too without touching it here.
+// !!! please make sure this is set to 0 in the repo !!!
+#ifndef ASSIMP_BUILD_BLENDER_DEBUG_DNA
+#define ASSIMP_BUILD_BLENDER_DEBUG_DNA 0
 #endif
 
 // #define ASSIMP_BUILD_BLENDER_NO_STATS
 
-namespace Assimp    {
+namespace Assimp {
 
-template <bool,bool> class StreamReader;
-typedef StreamReader<true,true> StreamReaderAny;
+template <bool, bool>
+class StreamReader;
+typedef StreamReader<true, true> StreamReaderAny;
 
 namespace Blender {
 
-class  FileDatabase;
+class FileDatabase;
 struct FileBlockHead;
 
 template <template <typename> class TOUT>
@@ -82,9 +90,9 @@ class ObjectCache;
  *  ancestry. */
 // -------------------------------------------------------------------------------
 struct Error : DeadlyImportError {
-    Error (const std::string& s)
-    : DeadlyImportError(s) {
-        // empty
+    template <typename... T>
+    explicit Error(T &&...args) :
+            DeadlyImportError(args...) {
     }
 };
 
@@ -93,9 +101,8 @@ struct Error : DeadlyImportError {
  *  descendents. It serves as base class for all data structure fields. */
 // -------------------------------------------------------------------------------
 struct ElemBase {
-    ElemBase()
-    : dna_type(nullptr)
-    {
+    ElemBase() :
+            dna_type(nullptr) {
         // empty
     }
 
@@ -110,7 +117,7 @@ struct ElemBase {
      * data type is not static, i.e. a std::shared_ptr<ElemBase>
      * in the scene description would have its type resolved
      * at runtime, so this member is always set. */
-    const char* dna_type;
+    const char *dna_type;
 };
 
 // -------------------------------------------------------------------------------
@@ -120,8 +127,8 @@ struct ElemBase {
  *  they used to point to.*/
 // -------------------------------------------------------------------------------
 struct Pointer {
-    Pointer()
-    : val() {
+    Pointer() :
+            val() {
         // empty
     }
     uint64_t val;
@@ -131,8 +138,8 @@ struct Pointer {
 /** Represents a generic offset within a BLEND file */
 // -------------------------------------------------------------------------------
 struct FileOffset {
-    FileOffset()
-    : val() {
+    FileOffset() :
+            val() {
         // empty
     }
     uint64_t val;
@@ -154,7 +161,7 @@ public:
         resize(0);
     }
 
-    operator bool () const {
+    operator bool() const {
         return !empty();
     }
 };
@@ -164,7 +171,7 @@ public:
 // -------------------------------------------------------------------------------
 enum FieldFlags {
     FieldFlag_Pointer = 0x1,
-    FieldFlag_Array   = 0x2
+    FieldFlag_Array = 0x2
 };
 
 // -------------------------------------------------------------------------------
@@ -186,7 +193,7 @@ struct Field {
 };
 
 // -------------------------------------------------------------------------------
-/** Range of possible behaviours for fields absend in the input file. Some are
+/** Range of possible behaviors for fields absence in the input file. Some are
  *  mission critical so we need them, while others can silently be default
  *  initialized and no animations are harmed. */
 // -------------------------------------------------------------------------------
@@ -200,7 +207,7 @@ enum ErrorPolicy {
 };
 
 #ifdef ASSIMP_BUILD_BLENDER_DEBUG
-#   define ErrorPolicy_Igno ErrorPolicy_Warn
+#define ErrorPolicy_Igno ErrorPolicy_Warn
 #endif
 
 // -------------------------------------------------------------------------------
@@ -212,47 +219,42 @@ enum ErrorPolicy {
  *  meaningful contents. */
 // -------------------------------------------------------------------------------
 class Structure {
-    template <template <typename> class> friend class ObjectCache;
+    template <template <typename> class>
+    friend class ObjectCache;
 
 public:
-    Structure()
-    : cache_idx(static_cast<size_t>(-1) ){
+    Structure() :
+            cache_idx(static_cast<size_t>(-1)) {
         // empty
     }
 
-public:
-
     // publicly accessible members
     std::string name;
-    vector< Field > fields;
+    vector<Field> fields;
     std::map<std::string, size_t> indices;
 
     size_t size;
 
-public:
-
     // --------------------------------------------------------
     /** Access a field of the structure by its canonical name. The pointer version
-     *  returns NULL on failure while the reference version raises an import error. */
-    inline const Field& operator [] (const std::string& ss) const;
-    inline const Field* Get (const std::string& ss) const;
+     *  returns nullptr on failure while the reference version raises an import error. */
+    inline const Field &operator[](const std::string &ss) const;
+    inline const Field *Get(const std::string &ss) const;
 
     // --------------------------------------------------------
     /** Access a field of the structure by its index */
-    inline const Field& operator [] (const size_t i) const;
+    inline const Field &operator[](const size_t i) const;
 
     // --------------------------------------------------------
-    inline bool operator== (const Structure& other) const {
+    inline bool operator==(const Structure &other) const {
         return name == other.name; // name is meant to be an unique identifier
     }
 
     // --------------------------------------------------------
-    inline bool operator!= (const Structure& other) const {
+    inline bool operator!=(const Structure &other) const {
         return name != other.name;
     }
 
-public:
-
     // --------------------------------------------------------
     /** Try to read an instance of the structure from the stream
      *  and attempt to convert to `T`. This is done by
@@ -260,54 +262,54 @@ public:
      *  a compiler complain is the result.
      *  @param dest Destination value to be written
      *  @param db File database, including input stream. */
-    template <typename T> void Convert (T& dest, const FileDatabase& db) const;
+    template <typename T>
+    void Convert(T &dest, const FileDatabase &db) const;
 
     // --------------------------------------------------------
     // generic converter
     template <typename T>
-    void Convert(std::shared_ptr<ElemBase> in,const FileDatabase& db) const;
+    void Convert(std::shared_ptr<ElemBase> in, const FileDatabase &db) const;
 
     // --------------------------------------------------------
     // generic allocator
-    template <typename T> std::shared_ptr<ElemBase> Allocate() const;
-
-
+    template <typename T>
+    std::shared_ptr<ElemBase> Allocate() const;
 
     // --------------------------------------------------------
     // field parsing for 1d arrays
     template <int error_policy, typename T, size_t M>
-    void ReadFieldArray(T (& out)[M], const char* name,
-        const FileDatabase& db) const;
+    void ReadFieldArray(T (&out)[M], const char *name,
+            const FileDatabase &db) const;
 
     // --------------------------------------------------------
     // field parsing for 2d arrays
     template <int error_policy, typename T, size_t M, size_t N>
-    void ReadFieldArray2(T (& out)[M][N], const char* name,
-        const FileDatabase& db) const;
+    void ReadFieldArray2(T (&out)[M][N], const char *name,
+            const FileDatabase &db) const;
 
     // --------------------------------------------------------
     // field parsing for pointer or dynamic array types
     // (std::shared_ptr)
     // The return value indicates whether the data was already cached.
     template <int error_policy, template <typename> class TOUT, typename T>
-    bool ReadFieldPtr(TOUT<T>& out, const char* name,
-        const FileDatabase& db,
-        bool non_recursive = false) const;
+    bool ReadFieldPtr(TOUT<T> &out, const char *name,
+            const FileDatabase &db,
+            bool non_recursive = false) const;
 
     // --------------------------------------------------------
     // field parsing for static arrays of pointer or dynamic
     // array types (std::shared_ptr[])
     // The return value indicates whether the data was already cached.
     template <int error_policy, template <typename> class TOUT, typename T, size_t N>
-    bool ReadFieldPtr(TOUT<T> (&out)[N], const char* name,
-        const FileDatabase& db) const;
+    bool ReadFieldPtr(TOUT<T> (&out)[N], const char *name,
+            const FileDatabase &db) const;
 
     // --------------------------------------------------------
     // field parsing for `normal` values
     // The return value indicates whether the data was already cached.
     template <int error_policy, typename T>
-    void ReadField(T& out, const char* name,
-        const FileDatabase& db) const;
+    void ReadField(T &out, const char *name,
+            const FileDatabase &db) const;
 
     // --------------------------------------------------------
     /**
@@ -318,7 +320,7 @@ public:
     *   @return true when read was successful
     */
     template <int error_policy, template <typename> class TOUT, typename T>
-    bool ReadFieldPtrVector(vector<TOUT<T>>&out, const char* name, const FileDatabase& db) const;
+    bool ReadFieldPtrVector(vector<TOUT<T>> &out, const char *name, const FileDatabase &db) const;
 
     /**
     *   @brief  parses raw customdata
@@ -329,42 +331,42 @@ public:
     *   @return true when read was successful
     */
     template <int error_policy>
-    bool ReadCustomDataPtr(std::shared_ptr<ElemBase>&out, int cdtype, const char* name, const FileDatabase& db) const;
+    bool ReadCustomDataPtr(std::shared_ptr<ElemBase> &out, int cdtype, const char *name, const FileDatabase &db) const;
 
 private:
+    // --------------------------------------------------------
+    template <template <typename> class TOUT, typename T>
+    bool ResolvePointer(TOUT<T> &out, const Pointer &ptrval,
+            const FileDatabase &db, const Field &f,
+            bool non_recursive = false) const;
 
     // --------------------------------------------------------
     template <template <typename> class TOUT, typename T>
-    bool ResolvePointer(TOUT<T>& out, const Pointer & ptrval,
-        const FileDatabase& db, const Field& f,
-        bool non_recursive = false) const;
+    bool ResolvePointer(vector<TOUT<T>> &out, const Pointer &ptrval,
+            const FileDatabase &db, const Field &f, bool) const;
 
     // --------------------------------------------------------
-    template <template <typename> class TOUT, typename T>
-    bool ResolvePointer(vector< TOUT<T> >& out, const Pointer & ptrval,
-        const FileDatabase& db, const Field& f, bool) const;
+    bool ResolvePointer(std::shared_ptr<FileOffset> &out, const Pointer &ptrval,
+            const FileDatabase &db, const Field &f, bool) const;
 
     // --------------------------------------------------------
-    bool ResolvePointer( std::shared_ptr< FileOffset >& out, const Pointer & ptrval,
-        const FileDatabase& db, const Field& f, bool) const;
-
-    // --------------------------------------------------------
-    inline const FileBlockHead* LocateFileBlockForAddress(
-        const Pointer & ptrval,
-        const FileDatabase& db) const;
+    inline const FileBlockHead *LocateFileBlockForAddress(
+            const Pointer &ptrval,
+            const FileDatabase &db) const;
 
 private:
-
     // ------------------------------------------------------------------------------
-    template <typename T> T* _allocate(std::shared_ptr<T>& out, size_t& s) const {
+    template <typename T>
+    T *_allocate(std::shared_ptr<T> &out, size_t &s) const {
         out = std::shared_ptr<T>(new T());
         s = 1;
         return out.get();
     }
 
-    template <typename T> T* _allocate(vector<T>& out, size_t& s) const {
+    template <typename T>
+    T *_allocate(vector<T> &out, size_t &s) const {
         out.resize(s);
-        return s ? &out.front() : NULL;
+        return s ? &out.front() : nullptr;
     }
 
     // --------------------------------------------------------
@@ -372,14 +374,14 @@ private:
     struct _defaultInitializer {
 
         template <typename T, unsigned int N>
-        void operator ()(T (& out)[N], const char* = NULL) {
+        void operator()(T (&out)[N], const char * = nullptr) {
             for (unsigned int i = 0; i < N; ++i) {
                 out[i] = T();
             }
         }
 
         template <typename T, unsigned int N, unsigned int M>
-        void operator ()(T (& out)[N][M], const char* = NULL) {
+        void operator()(T (&out)[N][M], const char * = nullptr) {
             for (unsigned int i = 0; i < N; ++i) {
                 for (unsigned int j = 0; j < M; ++j) {
                     out[i][j] = T();
@@ -388,21 +390,21 @@ private:
         }
 
         template <typename T>
-        void operator ()(T& out, const char* = NULL) {
+        void operator()(T &out, const char * = nullptr) {
             out = T();
         }
     };
 
 private:
-
     mutable size_t cache_idx;
 };
 
 // --------------------------------------------------------
-template <>  struct Structure :: _defaultInitializer<ErrorPolicy_Warn> {
+template <>
+struct Structure::_defaultInitializer<ErrorPolicy_Warn> {
 
     template <typename T>
-    void operator ()(T& out, const char* reason = "<add reason>") {
+    void operator()(T &out, const char *reason = "<add reason>") {
         ASSIMP_LOG_WARN(reason);
 
         // ... and let the show go on
@@ -410,10 +412,11 @@ template <>  struct Structure :: _defaultInitializer<ErrorPolicy_Warn> {
     }
 };
 
-template <> struct Structure :: _defaultInitializer<ErrorPolicy_Fail> {
+template <>
+struct Structure::_defaultInitializer<ErrorPolicy_Fail> {
 
     template <typename T>
-    void operator ()(T& /*out*/,const char* = "") {
+    void operator()(T & /*out*/, const char * = "") {
         // obviously, it is crucial that _DefaultInitializer is used
         // only from within a catch clause.
         throw DeadlyImportError("Constructing BlenderDNA Structure encountered an error");
@@ -421,13 +424,12 @@ template <> struct Structure :: _defaultInitializer<ErrorPolicy_Fail> {
 };
 
 // -------------------------------------------------------------------------------------------------------
-template <> inline bool Structure :: ResolvePointer<std::shared_ptr,ElemBase>(std::shared_ptr<ElemBase>& out,
-    const Pointer & ptrval,
-    const FileDatabase& db,
-    const Field& f,
-    bool
-    ) const;
-
+template <>
+inline bool Structure ::ResolvePointer<std::shared_ptr, ElemBase>(std::shared_ptr<ElemBase> &out,
+        const Pointer &ptrval,
+        const FileDatabase &db,
+        const Field &f,
+        bool) const;
 
 // -------------------------------------------------------------------------------
 /** Represents the full data structure information for a single BLEND file.
@@ -435,40 +437,34 @@ template <> inline bool Structure :: ResolvePointer<std::shared_ptr,ElemBase>(st
  *  #DNAParser does the reading and represents currently the only place where
  *  DNA is altered.*/
 // -------------------------------------------------------------------------------
-class DNA
-{
+class DNA {
 public:
-
-    typedef void (Structure::*ConvertProcPtr) (
-        std::shared_ptr<ElemBase> in,
-        const FileDatabase&
-    ) const;
+    typedef void (Structure::*ConvertProcPtr)(
+            std::shared_ptr<ElemBase> in,
+            const FileDatabase &) const;
 
     typedef std::shared_ptr<ElemBase> (
-        Structure::*AllocProcPtr) () const;
+            Structure::*AllocProcPtr)() const;
 
-    typedef std::pair< AllocProcPtr, ConvertProcPtr > FactoryPair;
+    typedef std::pair<AllocProcPtr, ConvertProcPtr> FactoryPair;
 
 public:
-
-    std::map<std::string, FactoryPair > converters;
-    vector<Structure > structures;
+    std::map<std::string, FactoryPair> converters;
+    vector<Structure> structures;
     std::map<std::string, size_t> indices;
 
 public:
-
     // --------------------------------------------------------
-    /** Access a structure by its canonical name, the pointer version returns NULL on failure
+    /** Access a structure by its canonical name, the pointer version returns nullptr on failure
       * while the reference version raises an error. */
-    inline const Structure& operator [] (const std::string& ss) const;
-    inline const Structure* Get (const std::string& ss) const;
+    inline const Structure &operator[](const std::string &ss) const;
+    inline const Structure *Get(const std::string &ss) const;
 
     // --------------------------------------------------------
     /** Access a structure by its index */
-    inline const Structure& operator [] (const size_t i) const;
+    inline const Structure &operator[](const size_t i) const;
 
 public:
-
     // --------------------------------------------------------
     /** Add structure definitions for all the primitive types,
      *  i.e. integer, short, char, float */
@@ -480,10 +476,9 @@ public:
      *  in BlenderScene.cpp and is machine-generated.
      *  Converters are used to quickly handle objects whose
      *  exact data type is a runtime-property and not yet
-     *  known at compile time (consier Object::data).*/
+     *  known at compile time (consider Object::data).*/
     void RegisterConverters();
 
-
     // --------------------------------------------------------
     /** Take an input blob from the stream, interpret it according to
      *  a its structure name and convert it to the intermediate
@@ -491,10 +486,9 @@ public:
      *  @param structure Destination structure definition
      *  @param db File database.
      *  @return A null pointer if no appropriate converter is available.*/
-    std::shared_ptr< ElemBase > ConvertBlobToStructure(
-        const Structure& structure,
-        const FileDatabase& db
-        ) const;
+    std::shared_ptr<ElemBase> ConvertBlobToStructure(
+            const Structure &structure,
+            const FileDatabase &db) const;
 
     // --------------------------------------------------------
     /** Find a suitable conversion function for a given Structure.
@@ -505,12 +499,10 @@ public:
      *  @param db File database.
      *  @return A null pointer in .first if no appropriate converter is available.*/
     FactoryPair GetBlobToStructureConverter(
-        const Structure& structure,
-        const FileDatabase& db
-        ) const;
+            const Structure &structure,
+            const FileDatabase &db) const;
 
-
-#ifdef ASSIMP_BUILD_BLENDER_DEBUG
+#if ASSIMP_BUILD_BLENDER_DEBUG_DNA
     // --------------------------------------------------------
     /** Dump the DNA to a text file. This is for debugging purposes.
      *  The output file is `dna.txt` in the current working folder*/
@@ -527,25 +519,29 @@ public:
      *  @throw DeadlyImportError if more than 2 dimensions are
      *    encountered. */
     static void ExtractArraySize(
-        const std::string& out,
-        size_t array_sizes[2]
-    );
+            const std::string &out,
+            size_t array_sizes[2]);
 };
 
 // special converters for primitive types
-template <> inline void Structure :: Convert<int>       (int& dest,const FileDatabase& db) const;
-template <> inline void Structure :: Convert<short>     (short& dest,const FileDatabase& db) const;
-template <> inline void Structure :: Convert<char>      (char& dest,const FileDatabase& db) const;
-template <> inline void Structure :: Convert<float>     (float& dest,const FileDatabase& db) const;
-template <> inline void Structure :: Convert<double>    (double& dest,const FileDatabase& db) const;
-template <> inline void Structure :: Convert<Pointer>   (Pointer& dest,const FileDatabase& db) const;
+template <>
+inline void Structure ::Convert<int>(int &dest, const FileDatabase &db) const;
+template <>
+inline void Structure ::Convert<short>(short &dest, const FileDatabase &db) const;
+template <>
+inline void Structure ::Convert<char>(char &dest, const FileDatabase &db) const;
+template <>
+inline void Structure ::Convert<float>(float &dest, const FileDatabase &db) const;
+template <>
+inline void Structure ::Convert<double>(double &dest, const FileDatabase &db) const;
+template <>
+inline void Structure ::Convert<Pointer>(Pointer &dest, const FileDatabase &db) const;
 
 // -------------------------------------------------------------------------------
 /** Describes a master file block header. Each master file sections holds n
  *  elements of a certain SDNA structure (or otherwise unspecified data). */
 // -------------------------------------------------------------------------------
-struct FileBlockHead
-{
+struct FileBlockHead {
     // points right after the header of the file block
     StreamReaderAny::pos start;
 
@@ -561,66 +557,55 @@ struct FileBlockHead
     // number of structure instances to follow
     size_t num;
 
-
-
     // file blocks are sorted by address to quickly locate specific memory addresses
-    bool operator < (const FileBlockHead& o) const {
+    bool operator<(const FileBlockHead &o) const {
         return address.val < o.address.val;
     }
 
     // for std::upper_bound
-    operator const Pointer& () const {
+    operator const Pointer &() const {
         return address;
     }
 };
 
 // for std::upper_bound
-inline bool operator< (const Pointer& a, const Pointer& b) {
+inline bool operator<(const Pointer &a, const Pointer &b) {
     return a.val < b.val;
 }
 
 // -------------------------------------------------------------------------------
 /** Utility to read all master file blocks in turn. */
 // -------------------------------------------------------------------------------
-class SectionParser
-{
+class SectionParser {
 public:
-
     // --------------------------------------------------------
     /** @param stream Inout stream, must point to the
      *  first section in the file. Call Next() once
      *  to have it read.
      *  @param ptr64 Pointer size in file is 64 bits? */
-    SectionParser(StreamReaderAny& stream,bool ptr64)
-        : stream(stream)
-        , ptr64(ptr64)
-    {
+    SectionParser(StreamReaderAny &stream, bool ptr64) :
+            stream(stream), ptr64(ptr64) {
         current.size = current.start = 0;
     }
 
 public:
-
     // --------------------------------------------------------
-    const FileBlockHead& GetCurrent() const {
+    const FileBlockHead &GetCurrent() const {
         return current;
     }
 
-
 public:
-
     // --------------------------------------------------------
     /** Advance to the next section.
      *  @throw DeadlyImportError if the last chunk was passed. */
     void Next();
 
 public:
-
     FileBlockHead current;
-    StreamReaderAny& stream;
+    StreamReaderAny &stream;
     bool ptr64;
 };
 
-
 #ifndef ASSIMP_BUILD_BLENDER_NO_STATS
 // -------------------------------------------------------------------------------
 /** Import statistics, i.e. number of file blocks read*/
@@ -628,17 +613,13 @@ public:
 class Statistics {
 
 public:
-
-    Statistics ()
-        : fields_read       ()
-        , pointers_resolved ()
-        , cache_hits        ()
-//      , blocks_read       ()
-        , cached_objects    ()
-    {}
+    Statistics() :
+            fields_read(), pointers_resolved(), cache_hits()
+            //      , blocks_read       ()
+            ,
+            cached_objects() {}
 
 public:
-
     /** total number of fields we read */
     unsigned int fields_read;
 
@@ -662,17 +643,13 @@ public:
  *  avoids circular references and avoids object duplication. */
 // -------------------------------------------------------------------------------
 template <template <typename> class TOUT>
-class ObjectCache
-{
+class ObjectCache {
 public:
-
-    typedef std::map< Pointer, TOUT<ElemBase> > StructureCache;
+    typedef std::map<Pointer, TOUT<ElemBase>> StructureCache;
 
 public:
-
-    ObjectCache(const FileDatabase& db)
-        : db(db)
-    {
+    ObjectCache(const FileDatabase &db) :
+            db(db) {
         // currently there are only ~400 structure records per blend file.
         // we read only a small part of them and don't cache objects
         // which we don't need, so this should suffice.
@@ -680,17 +657,17 @@ public:
     }
 
 public:
-
     // --------------------------------------------------------
     /** Check whether a specific item is in the cache.
      *  @param s Data type of the item
      *  @param out Output pointer. Unchanged if the
      *   cache doesn't know the item yet.
      *  @param ptr Item address to look for. */
-    template <typename T> void get (
-        const Structure& s,
-        TOUT<T>& out,
-        const Pointer& ptr) const;
+    template <typename T>
+    void get(
+            const Structure &s,
+            TOUT<T> &out,
+            const Pointer &ptr) const;
 
     // --------------------------------------------------------
     /** Add an item to the cache after the item has
@@ -700,47 +677,44 @@ public:
      *  @param s Data type of the item
      *  @param out Item to insert into the cache
      *  @param ptr address (cache key) of the item. */
-    template <typename T> void set
-        (const Structure& s,
-        const TOUT<T>& out,
-        const Pointer& ptr);
+    template <typename T>
+    void set(const Structure &s,
+            const TOUT<T> &out,
+            const Pointer &ptr);
 
 private:
-
     mutable vector<StructureCache> caches;
-    const FileDatabase& db;
+    const FileDatabase &db;
 };
 
 // -------------------------------------------------------------------------------
 // -------------------------------------------------------------------------------
-template <> class ObjectCache<Blender::vector>
-{
+template <>
+class ObjectCache<Blender::vector> {
 public:
+    ObjectCache(const FileDatabase &) {}
 
-    ObjectCache(const FileDatabase&) {}
-
-    template <typename T> void get(const Structure&, vector<T>&, const Pointer&) {}
-    template <typename T> void set(const Structure&, const vector<T>&, const Pointer&) {}
+    template <typename T>
+    void get(const Structure &, vector<T> &, const Pointer &) {}
+    template <typename T>
+    void set(const Structure &, const vector<T> &, const Pointer &) {}
 };
 
 #ifdef _MSC_VER
-#   pragma warning(disable:4355)
+#pragma warning(disable : 4355)
 #endif
 
 // -------------------------------------------------------------------------------
 /** Memory representation of a full BLEND file and all its dependencies. The
  *  output aiScene is constructed from an instance of this data structure. */
 // -------------------------------------------------------------------------------
-class FileDatabase
-{
-    template <template <typename> class TOUT> friend class ObjectCache;
+class FileDatabase {
+    template <template <typename> class TOUT>
+    friend class ObjectCache;
 
 public:
-    FileDatabase()
-        : _cacheArrays(*this)
-        , _cache(*this)
-        , next_cache_idx()
-    {}
+    FileDatabase() :
+            _cacheArrays(*this), _cache(*this), next_cache_idx() {}
 
 public:
     // publicly accessible fields
@@ -748,12 +722,11 @@ public:
     bool little;
 
     DNA dna;
-    std::shared_ptr< StreamReaderAny > reader;
-    vector< FileBlockHead > entries;
+    std::shared_ptr<StreamReaderAny> reader;
+    vector<FileBlockHead> entries;
 
 public:
-
-    Statistics& stats() const {
+    Statistics &stats() const {
         return _stats;
     }
 
@@ -762,18 +735,16 @@ public:
     // arrays of objects are never cached because we can't easily
     // ensure their proper destruction.
     template <typename T>
-    ObjectCache<std::shared_ptr>& cache(std::shared_ptr<T>& /*in*/) const {
+    ObjectCache<std::shared_ptr> &cache(std::shared_ptr<T> & /*in*/) const {
         return _cache;
     }
 
     template <typename T>
-    ObjectCache<vector>& cache(vector<T>& /*in*/) const {
+    ObjectCache<vector> &cache(vector<T> & /*in*/) const {
         return _cacheArrays;
     }
 
 private:
-
-
 #ifndef ASSIMP_BUILD_BLENDER_NO_STATS
     mutable Statistics _stats;
 #endif
@@ -785,24 +756,20 @@ private:
 };
 
 #ifdef _MSC_VER
-#   pragma warning(default:4355)
+#pragma warning(default : 4355)
 #endif
 
 // -------------------------------------------------------------------------------
 /** Factory to extract a #DNA from the DNA1 file block in a BLEND file. */
 // -------------------------------------------------------------------------------
-class DNAParser
-{
+class DNAParser {
 
 public:
-
     /** Bind the parser to a empty DNA and an input stream */
-    DNAParser(FileDatabase& db)
-        : db(db)
-    {}
+    DNAParser(FileDatabase &db) :
+            db(db) {}
 
 public:
-
     // --------------------------------------------------------
     /** Locate the DNA in the file and parse it. The input
      *  stream is expected to point to the beginning of the DN1
@@ -811,18 +778,16 @@ public:
      *  @throw DeadlyImportError if the DNA cannot be read.
      *  @note The position of the stream pointer is undefined
      *    afterwards.*/
-    void Parse ();
+    void Parse();
 
 public:
-
     /** Obtain a reference to the extracted DNA information */
-    const Blender::DNA& GetDNA() const {
+    const Blender::DNA &GetDNA() const {
         return db.dna;
     }
 
 private:
-
-    FileDatabase& db;
+    FileDatabase &db;
 };
 
 /**
@@ -835,9 +800,8 @@ private:
 */
 bool readCustomData(std::shared_ptr<ElemBase> &out, int cdtype, size_t cnt, const FileDatabase &db);
 
-
-    } // end Blend
-} // end Assimp
+} // namespace Blender
+} // namespace Assimp
 
 #include "BlenderDNA.inl"
 
diff --git a/Engine/lib/assimp/code/Blender/BlenderDNA.inl b/Engine/lib/assimp/code/AssetLib/Blender/BlenderDNA.inl
similarity index 93%
rename from Engine/lib/assimp/code/Blender/BlenderDNA.inl
rename to Engine/lib/assimp/code/AssetLib/Blender/BlenderDNA.inl
index 65bc1374c..4f64987a5 100644
--- a/Engine/lib/assimp/code/Blender/BlenderDNA.inl
+++ b/Engine/lib/assimp/code/AssetLib/Blender/BlenderDNA.inl
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -58,9 +57,7 @@ const Field& Structure :: operator [] (const std::string& ss) const
 {
     std::map<std::string, size_t>::const_iterator it = indices.find(ss);
     if (it == indices.end()) {
-        throw Error((Formatter::format(),
-            "BlendDNA: Did not find a field named `",ss,"` in structure `",name,"`"
-            ));
+        throw Error("BlendDNA: Did not find a field named `",ss,"` in structure `",name,"`");
     }
 
     return fields[(*it).second];
@@ -70,16 +67,14 @@ const Field& Structure :: operator [] (const std::string& ss) const
 const Field* Structure :: Get (const std::string& ss) const
 {
     std::map<std::string, size_t>::const_iterator it = indices.find(ss);
-    return it == indices.end() ? NULL : &fields[(*it).second];
+    return it == indices.end() ? nullptr : &fields[(*it).second];
 }
 
 //--------------------------------------------------------------------------------
 const Field& Structure :: operator [] (const size_t i) const
 {
     if (i >= fields.size()) {
-        throw Error((Formatter::format(),
-            "BlendDNA: There is no field with index `",i,"` in structure `",name,"`"
-            ));
+        throw Error("BlendDNA: There is no field with index `",i,"` in structure `",name,"`");
     }
 
     return fields[i];
@@ -110,9 +105,7 @@ void Structure :: ReadFieldArray(T (& out)[M], const char* name, const FileDatab
 
         // is the input actually an array?
         if (!(f.flags & FieldFlag_Array)) {
-            throw Error((Formatter::format(),"Field `",name,"` of structure `",
-                this->name,"` ought to be an array of size ",M
-                ));
+            throw Error("Field `",name,"` of structure `",this->name,"` ought to be an array of size ",M);
         }
 
         db.reader->IncPtr(f.offset);
@@ -149,9 +142,9 @@ void Structure :: ReadFieldArray2(T (& out)[M][N], const char* name, const FileD
 
         // is the input actually an array?
         if (!(f.flags & FieldFlag_Array)) {
-            throw Error((Formatter::format(),"Field `",name,"` of structure `",
+            throw Error("Field `",name,"` of structure `",
                 this->name,"` ought to be an array of size ",M,"*",N
-                ));
+                );
         }
 
         db.reader->IncPtr(f.offset);
@@ -196,8 +189,8 @@ bool Structure :: ReadFieldPtr(TOUT<T>& out, const char* name, const FileDatabas
 
         // sanity check, should never happen if the genblenddna script is right
         if (!(f->flags & FieldFlag_Pointer)) {
-            throw Error((Formatter::format(),"Field `",name,"` of structure `",
-                this->name,"` ought to be a pointer"));
+            throw Error("Field `",name,"` of structure `",
+                this->name,"` ought to be a pointer");
         }
 
         db.reader->IncPtr(f->offset);
@@ -239,11 +232,13 @@ bool Structure :: ReadFieldPtr(TOUT<T> (&out)[N], const char* name,
     try {
         f = &(*this)[name];
 
+#ifdef _DEBUG
         // sanity check, should never happen if the genblenddna script is right
         if ((FieldFlag_Pointer|FieldFlag_Pointer) != (f->flags & (FieldFlag_Pointer|FieldFlag_Pointer))) {
-            throw Error((Formatter::format(),"Field `",name,"` of structure `",
-                this->name,"` ought to be a pointer AND an array"));
+            throw Error("Field `",name,"` of structure `",
+                this->name,"` ought to be a pointer AND an array");
         }
+#endif // _DEBUG
 
         db.reader->IncPtr(f->offset);
 
@@ -321,8 +316,8 @@ bool Structure::ReadCustomDataPtr(std::shared_ptr<ElemBase>&out, int cdtype, con
 
 		// sanity check, should never happen if the genblenddna script is right
 		if (!(f->flags & FieldFlag_Pointer)) {
-			throw Error((Formatter::format(), "Field `", name, "` of structure `",
-				this->name, "` ought to be a pointer"));
+			throw Error("Field `", name, "` of structure `",
+				this->name, "` ought to be a pointer");
 		}
 
 		db.reader->IncPtr(f->offset);
@@ -368,8 +363,8 @@ bool Structure::ReadFieldPtrVector(vector<TOUT<T>>&out, const char* name, const
 
 		// sanity check, should never happen if the genblenddna script is right
 		if (!(f->flags & FieldFlag_Pointer)) {
-			throw Error((Formatter::format(), "Field `", name, "` of structure `",
-				this->name, "` ought to be a pointer"));
+			throw Error("Field `", name, "` of structure `",
+				this->name, "` ought to be a pointer");
 		}
 
 		db.reader->IncPtr(f->offset);
@@ -427,9 +422,9 @@ bool Structure :: ResolvePointer(TOUT<T>& out, const Pointer & ptrval, const Fil
     // and check if it matches the type which we expect.
     const Structure& ss = db.dna[block->dna_index];
     if (ss != s) {
-        throw Error((Formatter::format(),"Expected target to be of type `",s.name,
+        throw Error("Expected target to be of type `",s.name,
             "` but seemingly it is a `",ss.name,"` instead"
-            ));
+            );
     }
 
     // try to retrieve the object from the cache
@@ -570,7 +565,7 @@ template <> bool Structure :: ResolvePointer<std::shared_ptr,ElemBase>(std::shar
         // this might happen if DNA::RegisterConverters hasn't been called so far
         // or if the target type is not contained in `our` DNA.
         out.reset();
-        ASSIMP_LOG_WARN_F( "Failed to find a converter for the `",s.name,"` structure" );
+        ASSIMP_LOG_WARN( "Failed to find a converter for the `",s.name,"` structure" );
         return false;
     }
 
@@ -613,16 +608,14 @@ const FileBlockHead* Structure :: LocateFileBlockForAddress(const Pointer & ptrv
     if (it == db.entries.end()) {
         // this is crucial, pointers may not be invalid.
         // this is either a corrupted file or an attempted attack.
-        throw DeadlyImportError((Formatter::format(),"Failure resolving pointer 0x",
-            std::hex,ptrval.val,", no file block falls into this address range"
-            ));
+        throw DeadlyImportError("Failure resolving pointer 0x",
+            std::hex,ptrval.val,", no file block falls into this address range");
     }
     if (ptrval.val >= (*it).address.val + (*it).size) {
-        throw DeadlyImportError((Formatter::format(),"Failure resolving pointer 0x",
+        throw DeadlyImportError("Failure resolving pointer 0x",
             std::hex,ptrval.val,", nearest file block starting at 0x",
             (*it).address.val," ends at 0x",
-            (*it).address.val + (*it).size
-            ));
+            (*it).address.val + (*it).size);
     }
     return &*it;
 }
@@ -675,7 +668,7 @@ template <typename T> inline void ConvertDispatcher(T& out, const Structure& in,
         out = static_cast<T>(db.reader->GetF8());
     }
     else {
-        throw DeadlyImportError("Unknown source for conversion to primitive data type: "+in.name);
+        throw DeadlyImportError("Unknown source for conversion to primitive data type: ", in.name);
     }
 }
 
@@ -783,9 +776,7 @@ const Structure& DNA :: operator [] (const std::string& ss) const
 {
     std::map<std::string, size_t>::const_iterator it = indices.find(ss);
     if (it == indices.end()) {
-        throw Error((Formatter::format(),
-            "BlendDNA: Did not find a structure named `",ss,"`"
-            ));
+        throw Error("BlendDNA: Did not find a structure named `",ss,"`");
     }
 
     return structures[(*it).second];
@@ -795,16 +786,14 @@ const Structure& DNA :: operator [] (const std::string& ss) const
 const Structure* DNA :: Get (const std::string& ss) const
 {
     std::map<std::string, size_t>::const_iterator it = indices.find(ss);
-    return it == indices.end() ? NULL : &structures[(*it).second];
+    return it == indices.end() ? nullptr : &structures[(*it).second];
 }
 
 //--------------------------------------------------------------------------------
 const Structure& DNA :: operator [] (const size_t i) const
 {
     if (i >= structures.size()) {
-        throw Error((Formatter::format(),
-            "BlendDNA: There is no structure with index `",i,"`"
-            ));
+        throw Error("BlendDNA: There is no structure with index `",i,"`");
     }
 
     return structures[i];
diff --git a/Engine/lib/assimp/code/Blender/BlenderIntermediate.h b/Engine/lib/assimp/code/AssetLib/Blender/BlenderIntermediate.h
similarity index 99%
rename from Engine/lib/assimp/code/Blender/BlenderIntermediate.h
rename to Engine/lib/assimp/code/AssetLib/Blender/BlenderIntermediate.h
index 95fdf0f03..0651f7117 100644
--- a/Engine/lib/assimp/code/Blender/BlenderIntermediate.h
+++ b/Engine/lib/assimp/code/AssetLib/Blender/BlenderIntermediate.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Blender/BlenderLoader.cpp b/Engine/lib/assimp/code/AssetLib/Blender/BlenderLoader.cpp
similarity index 57%
rename from Engine/lib/assimp/code/Blender/BlenderLoader.cpp
rename to Engine/lib/assimp/code/AssetLib/Blender/BlenderLoader.cpp
index d39cb9699..b3591b4f1 100644
--- a/Engine/lib/assimp/code/Blender/BlenderLoader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/Blender/BlenderLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -45,50 +45,51 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Implementation of the Blender3D importer class.
  */
 
-
 //#define ASSIMP_BUILD_NO_COMPRESSED_BLEND
 // Uncomment this to disable support for (gzip)compressed .BLEND files
 
 #ifndef ASSIMP_BUILD_NO_BLEND_IMPORTER
 
-#include "BlenderIntermediate.h"
-#include "BlenderModifier.h"
 #include "BlenderBMesh.h"
 #include "BlenderCustomData.h"
+#include "BlenderIntermediate.h"
+#include "BlenderModifier.h"
 #include <assimp/StringUtils.h>
-#include <assimp/scene.h>
 #include <assimp/importerdesc.h>
+#include <assimp/scene.h>
 
-#include <assimp/StringComparison.h>
-#include <assimp/StreamReader.h>
 #include <assimp/MemoryIOWrapper.h>
+#include <assimp/StreamReader.h>
+#include <assimp/StringComparison.h>
 
 #include <cctype>
 
-
 // zlib is needed for compressed blend files
 #ifndef ASSIMP_BUILD_NO_COMPRESSED_BLEND
-#   ifdef ASSIMP_BUILD_NO_OWN_ZLIB
-#       include <zlib.h>
-#   else
-#       include "../contrib/zlib/zlib.h"
-#   endif
+#include "Common/Compression.h"
+/* #ifdef ASSIMP_BUILD_NO_OWN_ZLIB
+#    include <zlib.h>
+#  else
+#    include "../contrib/zlib/zlib.h"
+#  endif*/
 #endif
 
 namespace Assimp {
-    template<> const char* LogFunctions<BlenderImporter>::Prefix()
-    {
-        static auto prefix = "BLEND: ";
-        return prefix;
-    }
+
+template <>
+const char *LogFunctions<BlenderImporter>::Prefix() {
+    static auto prefix = "BLEND: ";
+    return prefix;
 }
 
+} // namespace Assimp
+
 using namespace Assimp;
 using namespace Assimp::Blender;
 using namespace Assimp::Formatter;
 
 static const aiImporterDesc blenderDesc = {
-    "Blender 3D Importer \nhttp://www.blender3d.org",
+    "Blender 3D Importer (http://www.blender3d.org)",
     "",
     "",
     "No animation support yet",
@@ -100,88 +101,65 @@ static const aiImporterDesc blenderDesc = {
     "blend"
 };
 
-
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-BlenderImporter::BlenderImporter()
-: modifier_cache(new BlenderModifierShowcase()) {
+BlenderImporter::BlenderImporter() :
+        modifier_cache(new BlenderModifierShowcase()) {
     // empty
 }
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-BlenderImporter::~BlenderImporter()
-{
+BlenderImporter::~BlenderImporter() {
     delete modifier_cache;
 }
 
-static const char* Tokens[] = { "BLENDER" };
-static const char* TokensForSearch[] = { "blender" };
+static const char * const Tokens[] = { "BLENDER" };
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool BlenderImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
-{
-    const std::string& extension = GetExtension(pFile);
-    if (extension == "blend") {
-        return true;
-    }
+bool BlenderImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
+    // note: this won't catch compressed files
+    static const char *tokens[] = { "<BLENDER", "blender" };
 
-    else if ((!extension.length() || checkSig) && pIOHandler)   {
-        // note: this won't catch compressed files
-        return SearchFileHeaderForToken(pIOHandler,pFile, TokensForSearch,1);
-    }
-    return false;
-}
-
-// ------------------------------------------------------------------------------------------------
-// List all extensions handled by this loader
-void BlenderImporter::GetExtensionList(std::set<std::string>& app)
-{
-    app.insert("blend");
+    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------
 // Loader registry entry
-const aiImporterDesc* BlenderImporter::GetInfo () const
-{
+const aiImporterDesc *BlenderImporter::GetInfo() const {
     return &blenderDesc;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup configuration properties for the loader
-void BlenderImporter::SetupProperties(const Importer* /*pImp*/)
-{
+void BlenderImporter::SetupProperties(const Importer * /*pImp*/) {
     // nothing to be done for the moment
 }
 
-
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void BlenderImporter::InternReadFile( const std::string& pFile,
-    aiScene* pScene, IOSystem* pIOHandler)
-{
+void BlenderImporter::InternReadFile(const std::string &pFile,
+        aiScene *pScene, IOSystem *pIOHandler) {
 #ifndef ASSIMP_BUILD_NO_COMPRESSED_BLEND
-    std::vector<Bytef> uncompressed;
+    std::vector<char> uncompressed;
 #endif
 
-
     FileDatabase file;
-    std::shared_ptr<IOStream> stream(pIOHandler->Open(pFile,"rb"));
+    std::shared_ptr<IOStream> stream(pIOHandler->Open(pFile, "rb"));
     if (!stream) {
         ThrowException("Could not open file for reading");
     }
 
-    char magic[8] = {0};
-    stream->Read(magic,7,1);
-    if (strcmp(magic, Tokens[0] )) {
+    char magic[8] = { 0 };
+    stream->Read(magic, 7, 1);
+    if (strcmp(magic, Tokens[0])) {
         // Check for presence of the gzip header. If yes, assume it is a
         // compressed blend file and try uncompressing it, else fail. This is to
         // avoid uncompressing random files which our loader might end up with.
 #ifdef ASSIMP_BUILD_NO_COMPRESSED_BLEND
         ThrowException("BLENDER magic bytes are missing, is this file compressed (Assimp was built without decompression support)?");
 #else
-
         if (magic[0] != 0x1f || static_cast<uint8_t>(magic[1]) != 0x8b) {
             ThrowException("BLENDER magic bytes are missing, couldn't find GZIP header either");
         }
@@ -192,96 +170,63 @@ void BlenderImporter::InternReadFile( const std::string& pFile,
         }
 
         // http://www.gzip.org/zlib/rfc-gzip.html#header-trailer
-        stream->Seek(0L,aiOrigin_SET);
+        stream->Seek(0L, aiOrigin_SET);
         std::shared_ptr<StreamReaderLE> reader = std::shared_ptr<StreamReaderLE>(new StreamReaderLE(stream));
 
-        // build a zlib stream
-        z_stream zstream;
-        zstream.opaque = Z_NULL;
-        zstream.zalloc = Z_NULL;
-        zstream.zfree  = Z_NULL;
-        zstream.data_type = Z_BINARY;
-
-        // http://hewgill.com/journal/entries/349-how-to-decompress-gzip-stream-with-zlib
-        inflateInit2(&zstream, 16+MAX_WBITS);
-
-        zstream.next_in   = reinterpret_cast<Bytef*>( reader->GetPtr() );
-        zstream.avail_in  = reader->GetRemainingSize();
-
-        size_t total = 0l;
-
-        // TODO: be smarter about this, decompress directly into heap buffer
-        // and decompress the data .... do 1k chunks in the hope that we won't kill the stack
-#define MYBLOCK 1024
-        Bytef block[MYBLOCK];
-        int ret;
-        do {
-            zstream.avail_out = MYBLOCK;
-            zstream.next_out = block;
-            ret = inflate(&zstream, Z_NO_FLUSH);
-
-            if (ret != Z_STREAM_END && ret != Z_OK) {
-                ThrowException("Failure decompressing this file using gzip, seemingly it is NOT a compressed .BLEND file");
-            }
-            const size_t have = MYBLOCK - zstream.avail_out;
-            total += have;
-            uncompressed.resize(total);
-            memcpy(uncompressed.data() + total - have,block,have);
+        size_t total = 0;
+        Compression compression;
+        if (compression.open(Compression::Format::Binary, Compression::FlushMode::NoFlush, 16 + Compression::MaxWBits)) {
+            total = compression.decompress((unsigned char *)reader->GetPtr(), reader->GetRemainingSize(), uncompressed);
+            compression.close();
         }
-        while (ret != Z_STREAM_END);
-
-        // terminate zlib
-        inflateEnd(&zstream);
 
         // replace the input stream with a memory stream
-        stream.reset(new MemoryIOStream(reinterpret_cast<uint8_t*>(uncompressed.data()),total));
+        stream.reset(new MemoryIOStream(reinterpret_cast<uint8_t *>(uncompressed.data()), total));
 
         // .. and retry
-        stream->Read(magic,7,1);
-        if (strcmp(magic,"BLENDER")) {
+        stream->Read(magic, 7, 1);
+        if (strcmp(magic, "BLENDER")) {
             ThrowException("Found no BLENDER magic word in decompressed GZIP file");
         }
 #endif
     }
 
-    file.i64bit = (stream->Read(magic,1,1),magic[0]=='-');
-    file.little = (stream->Read(magic,1,1),magic[0]=='v');
+    file.i64bit = (stream->Read(magic, 1, 1), magic[0] == '-');
+    file.little = (stream->Read(magic, 1, 1), magic[0] == 'v');
 
-    stream->Read(magic,3,1);
+    stream->Read(magic, 3, 1);
     magic[3] = '\0';
 
-    LogInfo((format(),"Blender version is ",magic[0],".",magic+1,
-        " (64bit: ",file.i64bit?"true":"false",
-        ", little endian: ",file.little?"true":"false",")"
-    ));
+    LogInfo("Blender version is ", magic[0], ".", magic + 1,
+            " (64bit: ", file.i64bit ? "true" : "false",
+            ", little endian: ", file.little ? "true" : "false", ")");
 
-    ParseBlendFile(file,stream);
+    ParseBlendFile(file, stream);
 
     Scene scene;
-    ExtractScene(scene,file);
+    ExtractScene(scene, file);
 
-    ConvertBlendFile(pScene,scene,file);
+    ConvertBlendFile(pScene, scene, file);
 }
 
 // ------------------------------------------------------------------------------------------------
-void BlenderImporter::ParseBlendFile(FileDatabase& out, std::shared_ptr<IOStream> stream)
-{
-    out.reader = std::shared_ptr<StreamReaderAny>(new StreamReaderAny(stream,out.little));
+void BlenderImporter::ParseBlendFile(FileDatabase &out, std::shared_ptr<IOStream> stream) {
+    out.reader = std::make_shared<StreamReaderAny>(stream, out.little);
 
     DNAParser dna_reader(out);
-    const DNA* dna = NULL;
+    const DNA *dna = nullptr;
 
-    out.entries.reserve(128); { // even small BLEND files tend to consist of many file blocks
-        SectionParser parser(*out.reader.get(),out.i64bit);
+    out.entries.reserve(128);
+    { // even small BLEND files tend to consist of many file blocks
+        SectionParser parser(*out.reader.get(), out.i64bit);
 
         // first parse the file in search for the DNA and insert all other sections into the database
-        while ((parser.Next(),1)) {
-            const FileBlockHead& head = parser.GetCurrent();
+        while ((parser.Next(), 1)) {
+            const FileBlockHead &head = parser.GetCurrent();
 
             if (head.id == "ENDB") {
                 break; // only valid end of the file
-            }
-            else if (head.id == "DNA1") {
+            } else if (head.id == "DNA1") {
                 dna_reader.Parse();
                 dna = &dna_reader.GetDNA();
                 continue;
@@ -294,22 +239,21 @@ void BlenderImporter::ParseBlendFile(FileDatabase& out, std::shared_ptr<IOStream
         ThrowException("SDNA not found");
     }
 
-    std::sort(out.entries.begin(),out.entries.end());
+    std::sort(out.entries.begin(), out.entries.end());
 }
 
 // ------------------------------------------------------------------------------------------------
-void BlenderImporter::ExtractScene(Scene& out, const FileDatabase& file)
-{
-    const FileBlockHead* block = NULL;
-    std::map<std::string,size_t>::const_iterator it = file.dna.indices.find("Scene");
+void BlenderImporter::ExtractScene(Scene &out, const FileDatabase &file) {
+    const FileBlockHead *block = nullptr;
+    std::map<std::string, size_t>::const_iterator it = file.dna.indices.find("Scene");
     if (it == file.dna.indices.end()) {
         ThrowException("There is no `Scene` structure record");
     }
 
-    const Structure& ss = file.dna.structures[(*it).second];
+    const Structure &ss = file.dna.structures[(*it).second];
 
     // we need a scene somewhere to start with.
-    for(const FileBlockHead& bl :file.entries) {
+    for (const FileBlockHead &bl : file.entries) {
 
         // Fix: using the DNA index is more reliable to locate scenes
         //if (bl.id == "SC") {
@@ -325,86 +269,123 @@ void BlenderImporter::ExtractScene(Scene& out, const FileDatabase& file)
     }
 
     file.reader->SetCurrentPos(block->start);
-    ss.Convert(out,file);
+    ss.Convert(out, file);
 
 #ifndef ASSIMP_BUILD_BLENDER_NO_STATS
-    ASSIMP_LOG_INFO_F(
-        "(Stats) Fields read: " ,file.stats().fields_read,
-        ", pointers resolved: " ,file.stats().pointers_resolved,
-        ", cache hits: "        ,file.stats().cache_hits,
-        ", cached objects: "    ,file.stats().cached_objects
-    );
+    ASSIMP_LOG_INFO(
+            "(Stats) Fields read: ", file.stats().fields_read,
+            ", pointers resolved: ", file.stats().pointers_resolved,
+            ", cache hits: ", file.stats().cache_hits,
+            ", cached objects: ", file.stats().cached_objects);
 #endif
 }
 
 // ------------------------------------------------------------------------------------------------
-void BlenderImporter::ConvertBlendFile(aiScene* out, const Scene& in,const FileDatabase& file)
-{
+void BlenderImporter::ParseSubCollection(const Blender::Scene &in, aiNode *root, std::shared_ptr<Collection> collection, ConversionData &conv_data) {
+
+    std::deque<Object *> root_objects;
+    // Count number of objects
+    for (std::shared_ptr<CollectionObject> cur = std::static_pointer_cast<CollectionObject>(collection->gobject.first); cur; cur = cur->next) {
+        if (cur->ob) {
+            root_objects.push_back(cur->ob);
+        }
+    }
+    std::deque<Collection *> root_children;
+    // Count number of child nodes
+    for (std::shared_ptr<CollectionChild> cur = std::static_pointer_cast<CollectionChild>(collection->children.first); cur; cur = cur->next) {
+        if (cur->collection) {
+            root_children.push_back(cur->collection.get());
+        }
+    }
+    root->mNumChildren = static_cast<unsigned int>(root_objects.size() + root_children.size());
+    root->mChildren = new aiNode *[root->mNumChildren]();
+
+    for (unsigned int i = 0; i < static_cast<unsigned int>(root_objects.size()); ++i) {
+        root->mChildren[i] = ConvertNode(in, root_objects[i], conv_data, aiMatrix4x4());
+        root->mChildren[i]->mParent = root;
+    }
+
+    // For each subcollection create a new node to represent it
+    unsigned int iterator = static_cast<unsigned int>(root_objects.size());
+    for (std::shared_ptr<CollectionChild> cur = std::static_pointer_cast<CollectionChild>(collection->children.first); cur; cur = cur->next) {
+        if (cur->collection) {
+            root->mChildren[iterator] = new aiNode(cur->collection->id.name + 2); // skip over the name prefix 'OB'
+            root->mChildren[iterator]->mParent = root;
+            ParseSubCollection(in, root->mChildren[iterator], cur->collection, conv_data);
+        }
+        iterator += 1;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void BlenderImporter::ConvertBlendFile(aiScene *out, const Scene &in, const FileDatabase &file) {
     ConversionData conv(file);
 
-    // FIXME it must be possible to take the hierarchy directly from
-    // the file. This is terrible. Here, we're first looking for
-    // all objects which don't have parent objects at all -
-    std::deque<const Object*> no_parents;
-    for (std::shared_ptr<Base> cur = std::static_pointer_cast<Base> ( in.base.first ); cur; cur = cur->next) {
-        if (cur->object) {
-            if(!cur->object->parent) {
-                no_parents.push_back(cur->object.get());
-            } else {
-                conv.objects.insert( cur->object.get() );
+    aiNode *root = out->mRootNode = new aiNode("<BlenderRoot>");
+    // Iterate over all objects directly under master_collection,
+    // If in.master_collection == null, then we're parsing something older.
+    if (in.master_collection) {
+        ParseSubCollection(in, root, in.master_collection, conv);
+    } else {
+        std::deque<const Object *> no_parents;
+        for (std::shared_ptr<Base> cur = std::static_pointer_cast<Base>(in.base.first); cur; cur = cur->next) {
+            if (cur->object) {
+                if (!cur->object->parent) {
+                    no_parents.push_back(cur->object.get());
+                } else {
+                    conv.objects.insert(cur->object.get());
+                }
             }
         }
-    }
-    for (std::shared_ptr<Base> cur = in.basact; cur; cur = cur->next) {
-        if (cur->object) {
-            if(cur->object->parent) {
-                conv.objects.insert(cur->object.get());
+        for (std::shared_ptr<Base> cur = in.basact; cur; cur = cur->next) {
+            if (cur->object) {
+                if (cur->object->parent) {
+                    conv.objects.insert(cur->object.get());
+                }
             }
         }
-    }
 
-    if (no_parents.empty()) {
-        ThrowException("Expected at least one object with no parent");
-    }
+        if (no_parents.empty()) {
+            ThrowException("Expected at least one object with no parent");
+        }
 
-    aiNode* root = out->mRootNode = new aiNode("<BlenderRoot>");
-
-    root->mNumChildren = static_cast<unsigned int>(no_parents.size());
-    root->mChildren = new aiNode*[root->mNumChildren]();
-    for (unsigned int i = 0; i < root->mNumChildren; ++i) {
-        root->mChildren[i] = ConvertNode(in, no_parents[i], conv, aiMatrix4x4());
-        root->mChildren[i]->mParent = root;
+        root->mNumChildren = static_cast<unsigned int>(no_parents.size());
+        root->mChildren = new aiNode *[root->mNumChildren]();
+        for (unsigned int i = 0; i < root->mNumChildren; ++i) {
+            root->mChildren[i] = ConvertNode(in, no_parents[i], conv, aiMatrix4x4());
+            root->mChildren[i]->mParent = root;
+        }
     }
 
     BuildMaterials(conv);
 
     if (conv.meshes->size()) {
-        out->mMeshes = new aiMesh*[out->mNumMeshes = static_cast<unsigned int>( conv.meshes->size() )];
-        std::copy(conv.meshes->begin(),conv.meshes->end(),out->mMeshes);
+        out->mMeshes = new aiMesh *[out->mNumMeshes = static_cast<unsigned int>(conv.meshes->size())];
+        std::copy(conv.meshes->begin(), conv.meshes->end(), out->mMeshes);
         conv.meshes.dismiss();
     }
 
     if (conv.lights->size()) {
-        out->mLights = new aiLight*[out->mNumLights = static_cast<unsigned int>( conv.lights->size() )];
-        std::copy(conv.lights->begin(),conv.lights->end(),out->mLights);
+        out->mLights = new aiLight *[out->mNumLights = static_cast<unsigned int>(conv.lights->size())];
+        std::copy(conv.lights->begin(), conv.lights->end(), out->mLights);
         conv.lights.dismiss();
     }
 
     if (conv.cameras->size()) {
-        out->mCameras = new aiCamera*[out->mNumCameras = static_cast<unsigned int>( conv.cameras->size() )];
-        std::copy(conv.cameras->begin(),conv.cameras->end(),out->mCameras);
+        out->mCameras = new aiCamera *[out->mNumCameras = static_cast<unsigned int>(conv.cameras->size())];
+        std::copy(conv.cameras->begin(), conv.cameras->end(), out->mCameras);
         conv.cameras.dismiss();
     }
 
     if (conv.materials->size()) {
-        out->mMaterials = new aiMaterial*[out->mNumMaterials = static_cast<unsigned int>( conv.materials->size() )];
-        std::copy(conv.materials->begin(),conv.materials->end(),out->mMaterials);
+        out->mMaterials = new aiMaterial *[out->mNumMaterials = static_cast<unsigned int>(conv.materials->size())];
+        std::copy(conv.materials->begin(), conv.materials->end(), out->mMaterials);
         conv.materials.dismiss();
     }
 
     if (conv.textures->size()) {
-        out->mTextures = new aiTexture*[out->mNumTextures = static_cast<unsigned int>( conv.textures->size() )];
-        std::copy(conv.textures->begin(),conv.textures->end(),out->mTextures);
+        out->mTextures = new aiTexture *[out->mNumTextures = static_cast<unsigned int>(conv.textures->size())];
+        std::copy(conv.textures->begin(), conv.textures->end(), out->mTextures);
         conv.textures.dismiss();
     }
 
@@ -418,44 +399,45 @@ void BlenderImporter::ConvertBlendFile(aiScene* out, const Scene& in,const FileD
 }
 
 // ------------------------------------------------------------------------------------------------
-void BlenderImporter::ResolveImage(aiMaterial* out, const Material* mat, const MTex* tex, const Image* img, ConversionData& conv_data)
-{
-    (void)mat; (void)tex; (void)conv_data;
+void BlenderImporter::ResolveImage(aiMaterial *out, const Material *mat, const MTex *tex, const Image *img, ConversionData &conv_data) {
+    (void)mat;
+    (void)tex;
+    (void)conv_data;
     aiString name;
 
     // check if the file contents are bundled with the BLEND file
     if (img->packedfile) {
         name.data[0] = '*';
-        name.length = 1+ ASSIMP_itoa10(name.data+1,static_cast<unsigned int>(MAXLEN-1), static_cast<int32_t>(conv_data.textures->size()));
+        name.length = 1 + ASSIMP_itoa10(name.data + 1, static_cast<unsigned int>(MAXLEN - 1), static_cast<int32_t>(conv_data.textures->size()));
 
         conv_data.textures->push_back(new aiTexture());
-        aiTexture* tex = conv_data.textures->back();
+        aiTexture *curTex = conv_data.textures->back();
 
         // usually 'img->name' will be the original file name of the embedded textures,
         // so we can extract the file extension from it.
-        const size_t nlen = strlen( img->name );
-        const char* s = img->name+nlen, *e = s;
-        while ( s >= img->name && *s != '.' ) {
+        const size_t nlen = strlen(img->name);
+        const char *s = img->name + nlen, *e = s;
+        while (s >= img->name && *s != '.') {
             --s;
         }
 
-        tex->achFormatHint[0] = s+1>e ? '\0' : ::tolower( s[1] );
-        tex->achFormatHint[1] = s+2>e ? '\0' : ::tolower( s[2] );
-        tex->achFormatHint[2] = s+3>e ? '\0' : ::tolower( s[3] );
-        tex->achFormatHint[3] = '\0';
+        curTex->achFormatHint[0] = s + 1 > e ? '\0' : (char)::tolower((unsigned char)s[1]);
+        curTex->achFormatHint[1] = s + 2 > e ? '\0' : (char)::tolower((unsigned char)s[2]);
+        curTex->achFormatHint[2] = s + 3 > e ? '\0' : (char)::tolower((unsigned char)s[3]);
+        curTex->achFormatHint[3] = '\0';
 
         // tex->mHeight = 0;
-        tex->mWidth = img->packedfile->size;
-        uint8_t* ch = new uint8_t[tex->mWidth];
+        curTex->mWidth = img->packedfile->size;
+        uint8_t *ch = new uint8_t[curTex->mWidth];
 
-        conv_data.db.reader->SetCurrentPos(static_cast<size_t>( img->packedfile->data->val));
-        conv_data.db.reader->CopyAndAdvance(ch,tex->mWidth);
+        conv_data.db.reader->SetCurrentPos(static_cast<size_t>(img->packedfile->data->val));
+        conv_data.db.reader->CopyAndAdvance(ch, curTex->mWidth);
 
-        tex->pcData = reinterpret_cast<aiTexel*>(ch);
+        curTex->pcData = reinterpret_cast<aiTexel *>(ch);
 
-        LogInfo("Reading embedded texture, original file was "+std::string(img->name));
+        LogInfo("Reading embedded texture, original file was ", img->name);
     } else {
-        name = aiString( img->name );
+        name = aiString(img->name);
     }
 
     aiTextureType texture_type = aiTextureType_UNKNOWN;
@@ -466,13 +448,11 @@ void BlenderImporter::ResolveImage(aiMaterial* out, const Material* mat, const M
     else if (map_type & MTex::MapType_NORM) {
         if (tex->tex->imaflag & Tex::ImageFlags_NORMALMAP) {
             texture_type = aiTextureType_NORMALS;
-        }
-        else {
+        } else {
             texture_type = aiTextureType_HEIGHT;
         }
-        out->AddProperty(&tex->norfac,1,AI_MATKEY_BUMPSCALING);
-    }
-    else if (map_type & MTex::MapType_COLSPEC)
+        out->AddProperty(&tex->norfac, 1, AI_MATKEY_BUMPSCALING);
+    } else if (map_type & MTex::MapType_COLSPEC)
         texture_type = aiTextureType_SPECULAR;
     else if (map_type & MTex::MapType_COLMIR)
         texture_type = aiTextureType_REFLECTION;
@@ -491,86 +471,81 @@ void BlenderImporter::ResolveImage(aiMaterial* out, const Material* mat, const M
         texture_type = aiTextureType_DISPLACEMENT;
     //else if (map_type & MTex::MapType_WARP)
 
-    out->AddProperty(&name,AI_MATKEY_TEXTURE(texture_type,
-        conv_data.next_texture[texture_type]++));
-
+    out->AddProperty(&name, AI_MATKEY_TEXTURE(texture_type,
+                                    conv_data.next_texture[texture_type]++));
 }
 
 // ------------------------------------------------------------------------------------------------
-void BlenderImporter::AddSentinelTexture(aiMaterial* out, const Material* mat, const MTex* tex, ConversionData& conv_data)
-{
-    (void)mat; (void)tex; (void)conv_data;
+void BlenderImporter::AddSentinelTexture(aiMaterial *out, const Material *mat, const MTex *tex, ConversionData &conv_data) {
+    (void)mat;
+    (void)tex;
+    (void)conv_data;
 
     aiString name;
-    name.length = ai_snprintf(name.data, MAXLEN, "Procedural,num=%i,type=%s",conv_data.sentinel_cnt++,
-        GetTextureTypeDisplayString(tex->tex->type)
-    );
-    out->AddProperty(&name,AI_MATKEY_TEXTURE_DIFFUSE(
-        conv_data.next_texture[aiTextureType_DIFFUSE]++)
-    );
+    name.length = ai_snprintf(name.data, MAXLEN, "Procedural,num=%i,type=%s", conv_data.sentinel_cnt++,
+            GetTextureTypeDisplayString(tex->tex->type));
+    out->AddProperty(&name, AI_MATKEY_TEXTURE_DIFFUSE(
+                                    conv_data.next_texture[aiTextureType_DIFFUSE]++));
 }
 
 // ------------------------------------------------------------------------------------------------
-void BlenderImporter::ResolveTexture(aiMaterial* out, const Material* mat, const MTex* tex, ConversionData& conv_data)
-{
-    const Tex* rtex = tex->tex.get();
-    if(!rtex || !rtex->type) {
+void BlenderImporter::ResolveTexture(aiMaterial *out, const Material *mat, const MTex *tex, ConversionData &conv_data) {
+    const Tex *rtex = tex->tex.get();
+    if (!rtex || !rtex->type) {
         return;
     }
 
     // We can't support most of the texture types because they're mostly procedural.
     // These are substituted by a dummy texture.
-    const char* dispnam = "";
-    switch( rtex->type )
-    {
-            // these are listed in blender's UI
-        case Tex::Type_CLOUDS       :
-        case Tex::Type_WOOD         :
-        case Tex::Type_MARBLE       :
-        case Tex::Type_MAGIC        :
-        case Tex::Type_BLEND        :
-        case Tex::Type_STUCCI       :
-        case Tex::Type_NOISE        :
-        case Tex::Type_PLUGIN       :
-        case Tex::Type_MUSGRAVE     :
-        case Tex::Type_VORONOI      :
-        case Tex::Type_DISTNOISE    :
-        case Tex::Type_ENVMAP       :
+    const char *dispnam = "";
+    switch (rtex->type) {
+        // these are listed in blender's UI
+    case Tex::Type_CLOUDS:
+    case Tex::Type_WOOD:
+    case Tex::Type_MARBLE:
+    case Tex::Type_MAGIC:
+    case Tex::Type_BLEND:
+    case Tex::Type_STUCCI:
+    case Tex::Type_NOISE:
+    case Tex::Type_PLUGIN:
+    case Tex::Type_MUSGRAVE:
+    case Tex::Type_VORONOI:
+    case Tex::Type_DISTNOISE:
+    case Tex::Type_ENVMAP:
 
-            // these do no appear in the UI, why?
-        case Tex::Type_POINTDENSITY :
-        case Tex::Type_VOXELDATA    :
+        // these do no appear in the UI, why?
+    case Tex::Type_POINTDENSITY:
+    case Tex::Type_VOXELDATA:
 
-            LogWarn(std::string("Encountered a texture with an unsupported type: ")+dispnam);
-            AddSentinelTexture(out, mat, tex, conv_data);
+        LogWarn("Encountered a texture with an unsupported type: ", dispnam);
+        AddSentinelTexture(out, mat, tex, conv_data);
+        break;
+
+    case Tex::Type_IMAGE:
+        if (!rtex->ima) {
+            LogError("A texture claims to be an Image, but no image reference is given");
             break;
+        }
+        ResolveImage(out, mat, tex, rtex->ima.get(), conv_data);
+        break;
 
-        case Tex::Type_IMAGE        :
-            if (!rtex->ima) {
-                LogError("A texture claims to be an Image, but no image reference is given");
-                break;
-            }
-            ResolveImage(out, mat, tex, rtex->ima.get(),conv_data);
-            break;
-
-        default:
-            ai_assert(false);
+    default:
+        ai_assert(false);
     };
 }
 
 // ------------------------------------------------------------------------------------------------
-void BlenderImporter::BuildDefaultMaterial(Blender::ConversionData& conv_data)
-{
+void BlenderImporter::BuildDefaultMaterial(Blender::ConversionData &conv_data) {
     // add a default material if necessary
-    unsigned int index = static_cast<unsigned int>( -1 );
-    for( aiMesh* mesh : conv_data.meshes.get() ) {
-        if (mesh->mMaterialIndex == static_cast<unsigned int>( -1 )) {
+    unsigned int index = static_cast<unsigned int>(-1);
+    for (aiMesh *mesh : conv_data.meshes.get()) {
+        if (mesh->mMaterialIndex == static_cast<unsigned int>(-1)) {
 
-            if (index == static_cast<unsigned int>( -1 )) {
+            if (index == static_cast<unsigned int>(-1)) {
                 // Setup a default material.
                 std::shared_ptr<Material> p(new Material());
-                ai_assert(::strlen(AI_DEFAULT_MATERIAL_NAME) < sizeof(p->id.name)-2);
-                strcpy( p->id.name+2, AI_DEFAULT_MATERIAL_NAME );
+                ai_assert(::strlen(AI_DEFAULT_MATERIAL_NAME) < sizeof(p->id.name) - 2);
+                strcpy(p->id.name + 2, AI_DEFAULT_MATERIAL_NAME);
 
                 // Note: MSVC11 does not zero-initialize Material here, although it should.
                 // Thus all relevant fields should be explicitly initialized. We cannot add
@@ -584,7 +559,7 @@ void BlenderImporter::BuildDefaultMaterial(Blender::ConversionData& conv_data)
                 p->alpha = 0.f;
                 p->har = 0;
 
-                index = static_cast<unsigned int>( conv_data.materials_raw.size() );
+                index = static_cast<unsigned int>(conv_data.materials_raw.size());
                 conv_data.materials_raw.push_back(p);
                 LogInfo("Adding default material");
             }
@@ -593,8 +568,7 @@ void BlenderImporter::BuildDefaultMaterial(Blender::ConversionData& conv_data)
     }
 }
 
-void BlenderImporter::AddBlendParams(aiMaterial* result, const Material* source)
-{
+void BlenderImporter::AddBlendParams(aiMaterial *result, const Material *source) {
     aiColor3D diffuseColor(source->r, source->g, source->b);
     result->AddProperty(&diffuseColor, 1, "$mat.blend.diffuse.color", 0, 0);
 
@@ -607,7 +581,6 @@ void BlenderImporter::AddBlendParams(aiMaterial* result, const Material* source)
     int diffuseRamp = 0;
     result->AddProperty(&diffuseRamp, 1, "$mat.blend.diffuse.ramp", 0, 0);
 
-
     aiColor3D specularColor(source->specr, source->specg, source->specb);
     result->AddProperty(&specularColor, 1, "$mat.blend.specular.color", 0, 0);
 
@@ -623,7 +596,6 @@ void BlenderImporter::AddBlendParams(aiMaterial* result, const Material* source)
     int specularHardness = source->har;
     result->AddProperty(&specularHardness, 1, "$mat.blend.specular.hardness", 0, 0);
 
-
     int transparencyUse = source->mode & MA_TRANSPARENCY ? 1 : 0;
     result->AddProperty(&transparencyUse, 1, "$mat.blend.transparency.use", 0, 0);
 
@@ -666,7 +638,6 @@ void BlenderImporter::AddBlendParams(aiMaterial* result, const Material* source)
     int transparencyGlossSamples = source->samp_gloss_tra;
     result->AddProperty(&transparencyGlossSamples, 1, "$mat.blend.transparency.glossSamples", 0, 0);
 
-
     int mirrorUse = source->mode & MA_RAYMIRROR ? 1 : 0;
     result->AddProperty(&mirrorUse, 1, "$mat.blend.mirror.use", 0, 0);
 
@@ -704,68 +675,67 @@ void BlenderImporter::AddBlendParams(aiMaterial* result, const Material* source)
     result->AddProperty(&mirrorGlossAnisotropic, 1, "$mat.blend.mirror.glossAnisotropic", 0, 0);
 }
 
-void BlenderImporter::BuildMaterials(ConversionData& conv_data)
-{
+void BlenderImporter::BuildMaterials(ConversionData &conv_data) {
     conv_data.materials->reserve(conv_data.materials_raw.size());
 
     BuildDefaultMaterial(conv_data);
 
-    for(std::shared_ptr<Material> mat : conv_data.materials_raw) {
+    for (const std::shared_ptr<Material> &mat : conv_data.materials_raw) {
 
         // reset per material global counters
-        for (size_t i = 0; i < sizeof(conv_data.next_texture)/sizeof(conv_data.next_texture[0]);++i) {
-            conv_data.next_texture[i] = 0 ;
+        for (size_t i = 0; i < sizeof(conv_data.next_texture) / sizeof(conv_data.next_texture[0]); ++i) {
+            conv_data.next_texture[i] = 0;
         }
 
-        aiMaterial* mout = new aiMaterial();
+        aiMaterial *mout = new aiMaterial();
         conv_data.materials->push_back(mout);
         // For any new material field handled here, the default material above must be updated with an appropriate default value.
 
         // set material name
-        aiString name = aiString(mat->id.name+2); // skip over the name prefix 'MA'
-        mout->AddProperty(&name,AI_MATKEY_NAME);
+        aiString name = aiString(mat->id.name + 2); // skip over the name prefix 'MA'
+        mout->AddProperty(&name, AI_MATKEY_NAME);
 
         // basic material colors
-        aiColor3D col(mat->r,mat->g,mat->b);
-        if (mat->r || mat->g || mat->b ) {
+        aiColor3D col(mat->r, mat->g, mat->b);
+        if (mat->r || mat->g || mat->b) {
 
             // Usually, zero diffuse color means no diffuse color at all in the equation.
             // So we omit this member to express this intent.
-            mout->AddProperty(&col,1,AI_MATKEY_COLOR_DIFFUSE);
+            mout->AddProperty(&col, 1, AI_MATKEY_COLOR_DIFFUSE);
 
             if (mat->emit) {
-                aiColor3D emit_col(mat->emit * mat->r, mat->emit * mat->g, mat->emit * mat->b) ;
-                mout->AddProperty(&emit_col, 1, AI_MATKEY_COLOR_EMISSIVE) ;
+                aiColor3D emit_col(mat->emit * mat->r, mat->emit * mat->g, mat->emit * mat->b);
+                mout->AddProperty(&emit_col, 1, AI_MATKEY_COLOR_EMISSIVE);
             }
         }
 
-        col = aiColor3D(mat->specr,mat->specg,mat->specb);
-        mout->AddProperty(&col,1,AI_MATKEY_COLOR_SPECULAR);
+        col = aiColor3D(mat->specr, mat->specg, mat->specb);
+        mout->AddProperty(&col, 1, AI_MATKEY_COLOR_SPECULAR);
 
         // is hardness/shininess set?
-        if( mat->har ) {
+        if (mat->har) {
             const float har = mat->har;
-            mout->AddProperty(&har,1,AI_MATKEY_SHININESS);
+            mout->AddProperty(&har, 1, AI_MATKEY_SHININESS);
         }
 
-        col = aiColor3D(mat->ambr,mat->ambg,mat->ambb);
-        mout->AddProperty(&col,1,AI_MATKEY_COLOR_AMBIENT);
+        col = aiColor3D(mat->ambr, mat->ambg, mat->ambb);
+        mout->AddProperty(&col, 1, AI_MATKEY_COLOR_AMBIENT);
 
         // is mirror enabled?
-        if( mat->mode & MA_RAYMIRROR ) {
+        if (mat->mode & MA_RAYMIRROR) {
             const float ray_mirror = mat->ray_mirror;
-            mout->AddProperty(&ray_mirror,1,AI_MATKEY_REFLECTIVITY);
+            mout->AddProperty(&ray_mirror, 1, AI_MATKEY_REFLECTIVITY);
         }
 
-        col = aiColor3D(mat->mirr,mat->mirg,mat->mirb);
-        mout->AddProperty(&col,1,AI_MATKEY_COLOR_REFLECTIVE);
+        col = aiColor3D(mat->mirr, mat->mirg, mat->mirb);
+        mout->AddProperty(&col, 1, AI_MATKEY_COLOR_REFLECTIVE);
 
-        for(size_t i = 0; i < sizeof(mat->mtex) / sizeof(mat->mtex[0]); ++i) {
+        for (size_t i = 0; i < sizeof(mat->mtex) / sizeof(mat->mtex[0]); ++i) {
             if (!mat->mtex[i]) {
                 continue;
             }
 
-            ResolveTexture(mout,mat.get(),mat->mtex[i].get(),conv_data);
+            ResolveTexture(mout, mat.get(), mat->mtex[i].get(), conv_data);
         }
 
         AddBlendParams(mout, mat.get());
@@ -773,85 +743,78 @@ void BlenderImporter::BuildMaterials(ConversionData& conv_data)
 }
 
 // ------------------------------------------------------------------------------------------------
-void BlenderImporter::CheckActualType(const ElemBase* dt, const char* check)
-{
+void BlenderImporter::CheckActualType(const ElemBase *dt, const char *check) {
     ai_assert(dt);
-    if (strcmp(dt->dna_type,check)) {
-        ThrowException((format(),
-            "Expected object at ",std::hex,dt," to be of type `",check,
-            "`, but it claims to be a `",dt->dna_type,"`instead"
-        ));
+    if (strcmp(dt->dna_type, check)) {
+        ThrowException("Expected object at ", std::hex, dt, " to be of type `", check,
+                "`, but it claims to be a `", dt->dna_type, "`instead");
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void BlenderImporter::NotSupportedObjectType(const Object* obj, const char* type)
-{
-    LogWarn((format(), "Object `",obj->id.name,"` - type is unsupported: `",type, "`, skipping" ));
+void BlenderImporter::NotSupportedObjectType(const Object *obj, const char *type) {
+    LogWarn("Object `", obj->id.name, "` - type is unsupported: `", type, "`, skipping");
 }
 
 // ------------------------------------------------------------------------------------------------
-void BlenderImporter::ConvertMesh(const Scene& /*in*/, const Object* /*obj*/, const Mesh* mesh,
-    ConversionData& conv_data, TempArray<std::vector,aiMesh>&  temp
-    )
-{
+void BlenderImporter::ConvertMesh(const Scene & /*in*/, const Object * /*obj*/, const Mesh *mesh,
+        ConversionData &conv_data, TempArray<std::vector, aiMesh> &temp) {
     // TODO: Resolve various problems with BMesh triangulation before re-enabling.
     //       See issues #400, #373, #318  #315 and #132.
 #if defined(TODO_FIX_BMESH_CONVERSION)
-    BlenderBMeshConverter BMeshConverter( mesh );
-    if ( BMeshConverter.ContainsBMesh( ) )
-    {
-        mesh = BMeshConverter.TriangulateBMesh( );
+    BlenderBMeshConverter BMeshConverter(mesh);
+    if (BMeshConverter.ContainsBMesh()) {
+        mesh = BMeshConverter.TriangulateBMesh();
     }
 #endif
 
-    typedef std::pair<const int,size_t> MyPair;
+    typedef std::pair<const int, size_t> MyPair;
     if ((!mesh->totface && !mesh->totloop) || !mesh->totvert) {
         return;
     }
 
     // some sanity checks
-    if (static_cast<size_t> ( mesh->totface ) > mesh->mface.size() ){
+    if (static_cast<size_t>(mesh->totface) > mesh->mface.size()) {
         ThrowException("Number of faces is larger than the corresponding array");
     }
 
-    if (static_cast<size_t> ( mesh->totvert ) > mesh->mvert.size()) {
+    if (static_cast<size_t>(mesh->totvert) > mesh->mvert.size()) {
         ThrowException("Number of vertices is larger than the corresponding array");
     }
 
-    if (static_cast<size_t> ( mesh->totloop ) > mesh->mloop.size()) {
+    if (static_cast<size_t>(mesh->totloop) > mesh->mloop.size()) {
         ThrowException("Number of vertices is larger than the corresponding array");
     }
 
     // collect per-submesh numbers
-    std::map<int,size_t> per_mat;
-    std::map<int,size_t> per_mat_verts;
+    std::map<int, size_t> per_mat;
+    std::map<int, size_t> per_mat_verts;
     for (int i = 0; i < mesh->totface; ++i) {
 
-        const MFace& mf = mesh->mface[i];
-        per_mat[ mf.mat_nr ]++;
-        per_mat_verts[ mf.mat_nr ] += mf.v4?4:3;
+        const MFace &mf = mesh->mface[i];
+        per_mat[mf.mat_nr]++;
+        per_mat_verts[mf.mat_nr] += mf.v4 ? 4 : 3;
     }
 
     for (int i = 0; i < mesh->totpoly; ++i) {
-        const MPoly& mp = mesh->mpoly[i];
-        per_mat[ mp.mat_nr ]++;
-        per_mat_verts[ mp.mat_nr ] += mp.totloop;
+        const MPoly &mp = mesh->mpoly[i];
+        per_mat[mp.mat_nr]++;
+        per_mat_verts[mp.mat_nr] += mp.totloop;
     }
 
     // ... and allocate the corresponding meshes
     const size_t old = temp->size();
     temp->reserve(temp->size() + per_mat.size());
 
-    std::map<size_t,size_t> mat_num_to_mesh_idx;
-    for(MyPair& it : per_mat) {
+    std::map<size_t, size_t> mat_num_to_mesh_idx;
+    for (MyPair &it : per_mat) {
 
         mat_num_to_mesh_idx[it.first] = temp->size();
         temp->push_back(new aiMesh());
 
-        aiMesh* out = temp->back();
+        aiMesh *out = temp->back();
         out->mVertices = new aiVector3D[per_mat_verts[it.first]];
-        out->mNormals  = new aiVector3D[per_mat_verts[it.first]];
+        out->mNormals = new aiVector3D[per_mat_verts[it.first]];
 
         //out->mNumFaces = 0
         //out->mNumVertices = 0
@@ -859,45 +822,43 @@ void BlenderImporter::ConvertMesh(const Scene& /*in*/, const Object* /*obj*/, co
 
         // all sub-meshes created from this mesh are named equally. this allows
         // curious users to recover the original adjacency.
-        out->mName = aiString(mesh->id.name+2);
-            // skip over the name prefix 'ME'
+        out->mName = aiString(mesh->id.name + 2);
+        // skip over the name prefix 'ME'
 
         // resolve the material reference and add this material to the set of
         // output materials. The (temporary) material index is the index
         // of the material entry within the list of resolved materials.
         if (mesh->mat) {
 
-            if (static_cast<size_t> ( it.first ) >= mesh->mat.size() ) {
+            if (static_cast<size_t>(it.first) >= mesh->mat.size()) {
                 ThrowException("Material index is out of range");
             }
 
             std::shared_ptr<Material> mat = mesh->mat[it.first];
-            const std::deque< std::shared_ptr<Material> >::iterator has = std::find(
+            const std::deque<std::shared_ptr<Material>>::iterator has = std::find(
                     conv_data.materials_raw.begin(),
-                    conv_data.materials_raw.end(),mat
-            );
+                    conv_data.materials_raw.end(), mat);
 
             if (has != conv_data.materials_raw.end()) {
-                out->mMaterialIndex = static_cast<unsigned int>( std::distance(conv_data.materials_raw.begin(),has));
-            }
-            else {
-                out->mMaterialIndex = static_cast<unsigned int>( conv_data.materials_raw.size() );
+                out->mMaterialIndex = static_cast<unsigned int>(std::distance(conv_data.materials_raw.begin(), has));
+            } else {
+                out->mMaterialIndex = static_cast<unsigned int>(conv_data.materials_raw.size());
                 conv_data.materials_raw.push_back(mat);
             }
-        }
-        else out->mMaterialIndex = static_cast<unsigned int>( -1 );
+        } else
+            out->mMaterialIndex = static_cast<unsigned int>(-1);
     }
 
     for (int i = 0; i < mesh->totface; ++i) {
 
-        const MFace& mf = mesh->mface[i];
+        const MFace &mf = mesh->mface[i];
 
-        aiMesh* const out = temp[ mat_num_to_mesh_idx[ mf.mat_nr ] ];
-        aiFace& f = out->mFaces[out->mNumFaces++];
+        aiMesh *const out = temp[mat_num_to_mesh_idx[mf.mat_nr]];
+        aiFace &f = out->mFaces[out->mNumFaces++];
 
-        f.mIndices = new unsigned int[ f.mNumIndices = mf.v4?4:3 ];
-        aiVector3D* vo = out->mVertices + out->mNumVertices;
-        aiVector3D* vn = out->mNormals + out->mNumVertices;
+        f.mIndices = new unsigned int[f.mNumIndices = mf.v4 ? 4 : 3];
+        aiVector3D *vo = out->mVertices + out->mNumVertices;
+        aiVector3D *vn = out->mNormals + out->mNumVertices;
 
         // XXX we can't fold this easily, because we are restricted
         // to the member names from the BLEND file (v1,v2,v3,v4)
@@ -908,7 +869,7 @@ void BlenderImporter::ConvertMesh(const Scene& /*in*/, const Object* /*obj*/, co
         if (mf.v1 >= mesh->totvert) {
             ThrowException("Vertex index v1 out of range");
         }
-        const MVert* v = &mesh->mvert[mf.v1];
+        const MVert *v = &mesh->mvert[mf.v1];
         vo->x = v->co[0];
         vo->y = v->co[1];
         vo->z = v->co[2];
@@ -966,8 +927,8 @@ void BlenderImporter::ConvertMesh(const Scene& /*in*/, const Object* /*obj*/, co
             ++vn;
 
             out->mPrimitiveTypes |= aiPrimitiveType_POLYGON;
-        }
-        else out->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
+        } else
+            out->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
 
         //  }
         //  }
@@ -976,29 +937,28 @@ void BlenderImporter::ConvertMesh(const Scene& /*in*/, const Object* /*obj*/, co
 
     for (int i = 0; i < mesh->totpoly; ++i) {
 
-        const MPoly& mf = mesh->mpoly[i];
+        const MPoly &mf = mesh->mpoly[i];
 
-        aiMesh* const out = temp[ mat_num_to_mesh_idx[ mf.mat_nr ] ];
-        aiFace& f = out->mFaces[out->mNumFaces++];
+        aiMesh *const out = temp[mat_num_to_mesh_idx[mf.mat_nr]];
+        aiFace &f = out->mFaces[out->mNumFaces++];
 
-        f.mIndices = new unsigned int[ f.mNumIndices = mf.totloop ];
-        aiVector3D* vo = out->mVertices + out->mNumVertices;
-        aiVector3D* vn = out->mNormals + out->mNumVertices;
+        f.mIndices = new unsigned int[f.mNumIndices = mf.totloop];
+        aiVector3D *vo = out->mVertices + out->mNumVertices;
+        aiVector3D *vn = out->mNormals + out->mNumVertices;
 
         // XXX we can't fold this easily, because we are restricted
         // to the member names from the BLEND file (v1,v2,v3,v4)
         // which are assigned by the genblenddna.py script and
         // cannot be changed without breaking the entire
         // import process.
-        for (int j = 0;j < mf.totloop; ++j)
-        {
-            const MLoop& loop = mesh->mloop[mf.loopstart + j];
+        for (int j = 0; j < mf.totloop; ++j) {
+            const MLoop &loop = mesh->mloop[mf.loopstart + j];
 
             if (loop.v >= mesh->totvert) {
                 ThrowException("Vertex index out of range");
             }
 
-            const MVert& v = mesh->mvert[loop.v];
+            const MVert &v = mesh->mvert[loop.v];
 
             vo->x = v.co[0];
             vo->y = v.co[1];
@@ -1010,14 +970,10 @@ void BlenderImporter::ConvertMesh(const Scene& /*in*/, const Object* /*obj*/, co
 
             ++vo;
             ++vn;
-
         }
-        if (mf.totloop == 3)
-        {
+        if (mf.totloop == 3) {
             out->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
-        }
-        else
-        {
+        } else {
             out->mPrimitiveTypes |= aiPrimitiveType_POLYGON;
         }
     }
@@ -1052,17 +1008,17 @@ void BlenderImporter::ConvertMesh(const Scene& /*in*/, const Object* /*obj*/, co
 
     // collect texture coordinates, they're stored in a separate per-face buffer
     if (mesh->mtface || mesh->mloopuv) {
-        if (mesh->totface > static_cast<int> ( mesh->mtface.size())) {
+        if (mesh->totface > static_cast<int>(mesh->mtface.size())) {
             ThrowException("Number of UV faces is larger than the corresponding UV face array (#1)");
         }
-        for (std::vector<aiMesh*>::iterator it = temp->begin()+old; it != temp->end(); ++it) {
-            ai_assert((*it)->mNumVertices && (*it)->mNumFaces);
+        for (std::vector<aiMesh *>::iterator it = temp->begin() + old; it != temp->end(); ++it) {
+            ai_assert(0 != (*it)->mNumVertices);
+            ai_assert(0 != (*it)->mNumFaces);
             const auto itMatTexUvMapping = matTexUvMappings.find((*it)->mMaterialIndex);
             if (itMatTexUvMapping == matTexUvMappings.end()) {
                 // default behaviour like before
                 (*it)->mTextureCoords[0] = new aiVector3D[(*it)->mNumVertices];
-            }
-            else {
+            } else {
                 // create texture coords for every mapped tex
                 for (uint32_t i = 0; i < itMatTexUvMapping->second.size(); ++i) {
                     (*it)->mTextureCoords[i] = new aiVector3D[(*it)->mNumVertices];
@@ -1072,41 +1028,40 @@ void BlenderImporter::ConvertMesh(const Scene& /*in*/, const Object* /*obj*/, co
         }
 
         for (int i = 0; i < mesh->totface; ++i) {
-            const MTFace* v = &mesh->mtface[i];
+            const MTFace *v = &mesh->mtface[i];
 
-            aiMesh* const out = temp[ mat_num_to_mesh_idx[ mesh->mface[i].mat_nr ] ];
-            const aiFace& f = out->mFaces[out->mNumFaces++];
+            aiMesh *const out = temp[mat_num_to_mesh_idx[mesh->mface[i].mat_nr]];
+            const aiFace &f = out->mFaces[out->mNumFaces++];
 
-            aiVector3D* vo = &out->mTextureCoords[0][out->mNumVertices];
-            for (unsigned int i = 0; i < f.mNumIndices; ++i,++vo,++out->mNumVertices) {
-                vo->x = v->uv[i][0];
-                vo->y = v->uv[i][1];
+            aiVector3D *vo = &out->mTextureCoords[0][out->mNumVertices];
+            for (unsigned int j = 0; j < f.mNumIndices; ++j, ++vo, ++out->mNumVertices) {
+                vo->x = v->uv[j][0];
+                vo->y = v->uv[j][1];
             }
         }
 
         for (int i = 0; i < mesh->totpoly; ++i) {
-            const MPoly& v = mesh->mpoly[i];
-            aiMesh* const out = temp[ mat_num_to_mesh_idx[ v.mat_nr ] ];
-            const aiFace& f = out->mFaces[out->mNumFaces++];
+            const MPoly &v = mesh->mpoly[i];
+            aiMesh *const out = temp[mat_num_to_mesh_idx[v.mat_nr]];
+            const aiFace &f = out->mFaces[out->mNumFaces++];
 
             const auto itMatTexUvMapping = matTexUvMappings.find(v.mat_nr);
             if (itMatTexUvMapping == matTexUvMappings.end()) {
                 // old behavior
-                aiVector3D* vo = &out->mTextureCoords[0][out->mNumVertices];
+                aiVector3D *vo = &out->mTextureCoords[0][out->mNumVertices];
                 for (unsigned int j = 0; j < f.mNumIndices; ++j, ++vo, ++out->mNumVertices) {
-                    const MLoopUV& uv = mesh->mloopuv[v.loopstart + j];
+                    const MLoopUV &uv = mesh->mloopuv[v.loopstart + j];
                     vo->x = uv.uv[0];
                     vo->y = uv.uv[1];
                 }
-            }
-            else {
+            } else {
                 // create textureCoords for every mapped tex
                 for (uint32_t m = 0; m < itMatTexUvMapping->second.size(); ++m) {
                     const MLoopUV *tm = itMatTexUvMapping->second[m];
-                    aiVector3D* vo = &out->mTextureCoords[m][out->mNumVertices];
+                    aiVector3D *vo = &out->mTextureCoords[m][out->mNumVertices];
                     uint32_t j = 0;
                     for (; j < f.mNumIndices; ++j, ++vo) {
-                        const MLoopUV& uv = tm[v.loopstart + j];
+                        const MLoopUV &uv = tm[v.loopstart + j];
                         vo->x = uv.uv[0];
                         vo->y = uv.uv[1];
                     }
@@ -1122,37 +1077,39 @@ void BlenderImporter::ConvertMesh(const Scene& /*in*/, const Object* /*obj*/, co
 
     // collect texture coordinates, old-style (marked as deprecated in current blender sources)
     if (mesh->tface) {
-        if (mesh->totface > static_cast<int> ( mesh->tface.size())) {
+        if (mesh->totface > static_cast<int>(mesh->tface.size())) {
             ThrowException("Number of faces is larger than the corresponding UV face array (#2)");
         }
-        for (std::vector<aiMesh*>::iterator it = temp->begin()+old; it != temp->end(); ++it) {
-            ai_assert((*it)->mNumVertices && (*it)->mNumFaces);
+        for (std::vector<aiMesh *>::iterator it = temp->begin() + old; it != temp->end(); ++it) {
+            ai_assert(0 != (*it)->mNumVertices);
+            ai_assert(0 != (*it)->mNumFaces);
 
             (*it)->mTextureCoords[0] = new aiVector3D[(*it)->mNumVertices];
             (*it)->mNumFaces = (*it)->mNumVertices = 0;
         }
 
         for (int i = 0; i < mesh->totface; ++i) {
-            const TFace* v = &mesh->tface[i];
+            const TFace *v = &mesh->tface[i];
 
-            aiMesh* const out = temp[ mat_num_to_mesh_idx[ mesh->mface[i].mat_nr ] ];
-            const aiFace& f = out->mFaces[out->mNumFaces++];
+            aiMesh *const out = temp[mat_num_to_mesh_idx[mesh->mface[i].mat_nr]];
+            const aiFace &f = out->mFaces[out->mNumFaces++];
 
-            aiVector3D* vo = &out->mTextureCoords[0][out->mNumVertices];
-            for (unsigned int i = 0; i < f.mNumIndices; ++i,++vo,++out->mNumVertices) {
-                vo->x = v->uv[i][0];
-                vo->y = v->uv[i][1];
+            aiVector3D *vo = &out->mTextureCoords[0][out->mNumVertices];
+            for (unsigned int j = 0; j < f.mNumIndices; ++j, ++vo, ++out->mNumVertices) {
+                vo->x = v->uv[j][0];
+                vo->y = v->uv[j][1];
             }
         }
     }
 
     // collect vertex colors, stored separately as well
     if (mesh->mcol || mesh->mloopcol) {
-        if (mesh->totface > static_cast<int> ( (mesh->mcol.size()/4)) ) {
+        if (mesh->totface > static_cast<int>((mesh->mcol.size() / 4))) {
             ThrowException("Number of faces is larger than the corresponding color face array");
         }
-        for (std::vector<aiMesh*>::iterator it = temp->begin()+old; it != temp->end(); ++it) {
-            ai_assert((*it)->mNumVertices && (*it)->mNumFaces);
+        for (std::vector<aiMesh *>::iterator it = temp->begin() + old; it != temp->end(); ++it) {
+            ai_assert(0 != (*it)->mNumVertices);
+            ai_assert(0 != (*it)->mNumFaces);
 
             (*it)->mColors[0] = new aiColor4D[(*it)->mNumVertices];
             (*it)->mNumFaces = (*it)->mNumVertices = 0;
@@ -1160,53 +1117,51 @@ void BlenderImporter::ConvertMesh(const Scene& /*in*/, const Object* /*obj*/, co
 
         for (int i = 0; i < mesh->totface; ++i) {
 
-            aiMesh* const out = temp[ mat_num_to_mesh_idx[ mesh->mface[i].mat_nr ] ];
-            const aiFace& f = out->mFaces[out->mNumFaces++];
+            aiMesh *const out = temp[mat_num_to_mesh_idx[mesh->mface[i].mat_nr]];
+            const aiFace &f = out->mFaces[out->mNumFaces++];
 
-            aiColor4D* vo = &out->mColors[0][out->mNumVertices];
-            for (unsigned int n = 0; n < f.mNumIndices; ++n, ++vo,++out->mNumVertices) {
-                const MCol* col = &mesh->mcol[(i<<2)+n];
+            aiColor4D *vo = &out->mColors[0][out->mNumVertices];
+            for (unsigned int n = 0; n < f.mNumIndices; ++n, ++vo, ++out->mNumVertices) {
+                const MCol *col = &mesh->mcol[(i << 2) + n];
 
                 vo->r = col->r;
                 vo->g = col->g;
                 vo->b = col->b;
                 vo->a = col->a;
             }
-            for (unsigned int n = f.mNumIndices; n < 4; ++n);
+            for (unsigned int n = f.mNumIndices; n < 4; ++n)
+                ;
         }
 
         for (int i = 0; i < mesh->totpoly; ++i) {
-            const MPoly& v = mesh->mpoly[i];
-            aiMesh* const out = temp[ mat_num_to_mesh_idx[ v.mat_nr ] ];
-            const aiFace& f = out->mFaces[out->mNumFaces++];
+            const MPoly &v = mesh->mpoly[i];
+            aiMesh *const out = temp[mat_num_to_mesh_idx[v.mat_nr]];
+            const aiFace &f = out->mFaces[out->mNumFaces++];
 
-            aiColor4D* vo = &out->mColors[0][out->mNumVertices];
-			const ai_real scaleZeroToOne = 1.f/255.f;
-            for (unsigned int j = 0; j < f.mNumIndices; ++j,++vo,++out->mNumVertices) {
-                const MLoopCol& col = mesh->mloopcol[v.loopstart + j];
+            aiColor4D *vo = &out->mColors[0][out->mNumVertices];
+            const ai_real scaleZeroToOne = 1.f / 255.f;
+            for (unsigned int j = 0; j < f.mNumIndices; ++j, ++vo, ++out->mNumVertices) {
+                const MLoopCol &col = mesh->mloopcol[v.loopstart + j];
                 vo->r = ai_real(col.r) * scaleZeroToOne;
                 vo->g = ai_real(col.g) * scaleZeroToOne;
                 vo->b = ai_real(col.b) * scaleZeroToOne;
                 vo->a = ai_real(col.a) * scaleZeroToOne;
             }
-
         }
-
     }
 
     return;
 }
 
 // ------------------------------------------------------------------------------------------------
-aiCamera* BlenderImporter::ConvertCamera(const Scene& /*in*/, const Object* obj, const Camera* cam, ConversionData& /*conv_data*/)
-{
+aiCamera *BlenderImporter::ConvertCamera(const Scene & /*in*/, const Object *obj, const Camera *cam, ConversionData & /*conv_data*/) {
     std::unique_ptr<aiCamera> out(new aiCamera());
-    out->mName = obj->id.name+2;
+    out->mName = obj->id.name + 2;
     out->mPosition = aiVector3D(0.f, 0.f, 0.f);
     out->mUp = aiVector3D(0.f, 1.f, 0.f);
     out->mLookAt = aiVector3D(0.f, 0.f, -1.f);
     if (cam->sensor_x && cam->lens) {
-        out->mHorizontalFOV = 2.f * std::atan2(cam->sensor_x,  2.f * cam->lens);
+        out->mHorizontalFOV = 2.f * std::atan2(cam->sensor_x, 2.f * cam->lens);
     }
     out->mClipPlaneNear = cam->clipsta;
     out->mClipPlaneFar = cam->clipend;
@@ -1215,51 +1170,48 @@ aiCamera* BlenderImporter::ConvertCamera(const Scene& /*in*/, const Object* obj,
 }
 
 // ------------------------------------------------------------------------------------------------
-aiLight* BlenderImporter::ConvertLight(const Scene& /*in*/, const Object* obj, const Lamp* lamp, ConversionData& /*conv_data*/)
-{
+aiLight *BlenderImporter::ConvertLight(const Scene & /*in*/, const Object *obj, const Lamp *lamp, ConversionData & /*conv_data*/) {
     std::unique_ptr<aiLight> out(new aiLight());
-    out->mName = obj->id.name+2;
+    out->mName = obj->id.name + 2;
 
-    switch (lamp->type)
-    {
-        case Lamp::Type_Local:
-            out->mType = aiLightSource_POINT;
-            break;
-        case Lamp::Type_Spot:
-            out->mType = aiLightSource_SPOT;
+    switch (lamp->type) {
+    case Lamp::Type_Local:
+        out->mType = aiLightSource_POINT;
+        break;
+    case Lamp::Type_Spot:
+        out->mType = aiLightSource_SPOT;
 
-            // blender orients directional lights as facing toward -z
-            out->mDirection = aiVector3D(0.f, 0.f, -1.f);
-            out->mUp = aiVector3D(0.f, 1.f, 0.f);
+        // blender orients directional lights as facing toward -z
+        out->mDirection = aiVector3D(0.f, 0.f, -1.f);
+        out->mUp = aiVector3D(0.f, 1.f, 0.f);
 
-            out->mAngleInnerCone = lamp->spotsize * (1.0f - lamp->spotblend);
-            out->mAngleOuterCone = lamp->spotsize;
-            break;
-        case Lamp::Type_Sun:
-            out->mType = aiLightSource_DIRECTIONAL;
+        out->mAngleInnerCone = lamp->spotsize * (1.0f - lamp->spotblend);
+        out->mAngleOuterCone = lamp->spotsize;
+        break;
+    case Lamp::Type_Sun:
+        out->mType = aiLightSource_DIRECTIONAL;
 
-            // blender orients directional lights as facing toward -z
-            out->mDirection = aiVector3D(0.f, 0.f, -1.f);
-            out->mUp = aiVector3D(0.f, 1.f, 0.f);
-            break;
+        // blender orients directional lights as facing toward -z
+        out->mDirection = aiVector3D(0.f, 0.f, -1.f);
+        out->mUp = aiVector3D(0.f, 1.f, 0.f);
+        break;
 
-        case Lamp::Type_Area:
-            out->mType = aiLightSource_AREA;
+    case Lamp::Type_Area:
+        out->mType = aiLightSource_AREA;
 
-            if (lamp->area_shape == 0) {
-                out->mSize = aiVector2D(lamp->area_size, lamp->area_size);
-            }
-            else {
-                out->mSize = aiVector2D(lamp->area_size, lamp->area_sizey);
-            }
+        if (lamp->area_shape == 0) {
+            out->mSize = aiVector2D(lamp->area_size, lamp->area_size);
+        } else {
+            out->mSize = aiVector2D(lamp->area_size, lamp->area_sizey);
+        }
 
-            // blender orients directional lights as facing toward -z
-            out->mDirection = aiVector3D(0.f, 0.f, -1.f);
-            out->mUp = aiVector3D(0.f, 1.f, 0.f);
-            break;
+        // blender orients directional lights as facing toward -z
+        out->mDirection = aiVector3D(0.f, 0.f, -1.f);
+        out->mUp = aiVector3D(0.f, 1.f, 0.f);
+        break;
 
-        default:
-            break;
+    default:
+        break;
     }
 
     out->mColorAmbient = aiColor3D(lamp->r, lamp->g, lamp->b) * lamp->energy;
@@ -1269,14 +1221,11 @@ aiLight* BlenderImporter::ConvertLight(const Scene& /*in*/, const Object* obj, c
     // If default values are supplied, compute the coefficients from light's max distance
     // Read this: https://imdoingitwrong.wordpress.com/2011/01/31/light-attenuation/
     //
-    if (lamp->constant_coefficient == 1.0f && lamp->linear_coefficient == 0.0f && lamp->quadratic_coefficient == 0.0f && lamp->dist > 0.0f)
-    {
+    if (lamp->constant_coefficient == 1.0f && lamp->linear_coefficient == 0.0f && lamp->quadratic_coefficient == 0.0f && lamp->dist > 0.0f) {
         out->mAttenuationConstant = 1.0f;
         out->mAttenuationLinear = 2.0f / lamp->dist;
         out->mAttenuationQuadratic = 1.0f / (lamp->dist * lamp->dist);
-    }
-    else
-    {
+    } else {
         out->mAttenuationConstant = lamp->constant_coefficient;
         out->mAttenuationLinear = lamp->linear_coefficient;
         out->mAttenuationQuadratic = lamp->quadratic_coefficient;
@@ -1286,11 +1235,10 @@ aiLight* BlenderImporter::ConvertLight(const Scene& /*in*/, const Object* obj, c
 }
 
 // ------------------------------------------------------------------------------------------------
-aiNode* BlenderImporter::ConvertNode(const Scene& in, const Object* obj, ConversionData& conv_data, const aiMatrix4x4& parentTransform)
-{
-    std::deque<const Object*> children;
-    for(ObjectSet::iterator it = conv_data.objects.begin(); it != conv_data.objects.end() ;) {
-        const Object* object = *it;
+aiNode *BlenderImporter::ConvertNode(const Scene &in, const Object *obj, ConversionData &conv_data, const aiMatrix4x4 &parentTransform) {
+    std::deque<const Object *> children;
+    for (ObjectSet::iterator it = conv_data.objects.begin(); it != conv_data.objects.end();) {
+        const Object *object = *it;
         if (object->parent == obj) {
             children.push_back(object);
 
@@ -1300,66 +1248,61 @@ aiNode* BlenderImporter::ConvertNode(const Scene& in, const Object* obj, Convers
         ++it;
     }
 
-    std::unique_ptr<aiNode> node(new aiNode(obj->id.name+2)); // skip over the name prefix 'OB'
+    std::unique_ptr<aiNode> node(new aiNode(obj->id.name + 2)); // skip over the name prefix 'OB'
     if (obj->data) {
-        switch (obj->type)
-        {
-        case Object :: Type_EMPTY:
+        switch (obj->type) {
+        case Object ::Type_EMPTY:
             break; // do nothing
 
-
             // supported object types
-        case Object :: Type_MESH: {
+        case Object ::Type_MESH: {
             const size_t old = conv_data.meshes->size();
 
-            CheckActualType(obj->data.get(),"Mesh");
-            ConvertMesh(in,obj,static_cast<const Mesh*>(obj->data.get()),conv_data,conv_data.meshes);
+            CheckActualType(obj->data.get(), "Mesh");
+            ConvertMesh(in, obj, static_cast<const Mesh *>(obj->data.get()), conv_data, conv_data.meshes);
 
             if (conv_data.meshes->size() > old) {
-                node->mMeshes = new unsigned int[node->mNumMeshes = static_cast<unsigned int>(conv_data.meshes->size()-old)];
+                node->mMeshes = new unsigned int[node->mNumMeshes = static_cast<unsigned int>(conv_data.meshes->size() - old)];
                 for (unsigned int i = 0; i < node->mNumMeshes; ++i) {
                     node->mMeshes[i] = static_cast<unsigned int>(i + old);
                 }
-            }}
-            break;
-        case Object :: Type_LAMP: {
-            CheckActualType(obj->data.get(),"Lamp");
-            aiLight* mesh = ConvertLight(in,obj,static_cast<const Lamp*>(
-                obj->data.get()),conv_data);
+            }
+        } break;
+        case Object ::Type_LAMP: {
+            CheckActualType(obj->data.get(), "Lamp");
+            aiLight *mesh = ConvertLight(in, obj, static_cast<const Lamp *>(obj->data.get()), conv_data);
 
             if (mesh) {
                 conv_data.lights->push_back(mesh);
-            }}
-            break;
-        case Object :: Type_CAMERA: {
-            CheckActualType(obj->data.get(),"Camera");
-            aiCamera* mesh = ConvertCamera(in,obj,static_cast<const Camera*>(
-                obj->data.get()),conv_data);
+            }
+        } break;
+        case Object ::Type_CAMERA: {
+            CheckActualType(obj->data.get(), "Camera");
+            aiCamera *mesh = ConvertCamera(in, obj, static_cast<const Camera *>(obj->data.get()), conv_data);
 
             if (mesh) {
                 conv_data.cameras->push_back(mesh);
-            }}
-            break;
-
+            }
+        } break;
 
             // unsupported object types / log, but do not break
-        case Object :: Type_CURVE:
-            NotSupportedObjectType(obj,"Curve");
+        case Object ::Type_CURVE:
+            NotSupportedObjectType(obj, "Curve");
             break;
-        case Object :: Type_SURF:
-            NotSupportedObjectType(obj,"Surface");
+        case Object ::Type_SURF:
+            NotSupportedObjectType(obj, "Surface");
             break;
-        case Object :: Type_FONT:
-            NotSupportedObjectType(obj,"Font");
+        case Object ::Type_FONT:
+            NotSupportedObjectType(obj, "Font");
             break;
-        case Object :: Type_MBALL:
-            NotSupportedObjectType(obj,"MetaBall");
+        case Object ::Type_MBALL:
+            NotSupportedObjectType(obj, "MetaBall");
             break;
-        case Object :: Type_WAVE:
-            NotSupportedObjectType(obj,"Wave");
+        case Object ::Type_WAVE:
+            NotSupportedObjectType(obj, "Wave");
             break;
-        case Object :: Type_LATTICE:
-            NotSupportedObjectType(obj,"Lattice");
+        case Object ::Type_LATTICE:
+            NotSupportedObjectType(obj, "Lattice");
             break;
 
             // invalid or unknown type
@@ -1368,8 +1311,8 @@ aiNode* BlenderImporter::ConvertNode(const Scene& in, const Object* obj, Convers
         }
     }
 
-    for(unsigned int x = 0; x < 4; ++x) {
-        for(unsigned int y = 0; y < 4; ++y) {
+    for (unsigned int x = 0; x < 4; ++x) {
+        for (unsigned int y = 0; y < 4; ++y) {
             node->mTransformation[y][x] = obj->obmat[x][y];
         }
     }
@@ -1377,19 +1320,19 @@ aiNode* BlenderImporter::ConvertNode(const Scene& in, const Object* obj, Convers
     aiMatrix4x4 m = parentTransform;
     m = m.Inverse();
 
-    node->mTransformation = m*node->mTransformation;
+    node->mTransformation = m * node->mTransformation;
 
     if (children.size()) {
         node->mNumChildren = static_cast<unsigned int>(children.size());
-        aiNode** nd = node->mChildren = new aiNode*[node->mNumChildren]();
-        for (const Object* nobj :children) {
-            *nd = ConvertNode(in,nobj,conv_data,node->mTransformation * parentTransform);
+        aiNode **nd = node->mChildren = new aiNode *[node->mNumChildren]();
+        for (const Object *nobj : children) {
+            *nd = ConvertNode(in, nobj, conv_data, node->mTransformation * parentTransform);
             (*nd++)->mParent = node.get();
         }
     }
 
     // apply modifiers
-    modifier_cache->ApplyModifiers(*node,conv_data,in,*obj);
+    modifier_cache->ApplyModifiers(*node, conv_data, in, *obj);
 
     return node.release();
 }
diff --git a/Engine/lib/assimp/code/AssetLib/Blender/BlenderLoader.h b/Engine/lib/assimp/code/AssetLib/Blender/BlenderLoader.h
new file mode 100644
index 000000000..0299ae393
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Blender/BlenderLoader.h
@@ -0,0 +1,198 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file  BlenderLoader.h
+ *  @brief Declaration of the Blender 3D (*.blend) importer class.
+ */
+#pragma once
+#ifndef INCLUDED_AI_BLEND_LOADER_H
+#define INCLUDED_AI_BLEND_LOADER_H
+
+#include <assimp/BaseImporter.h>
+#include <assimp/LogAux.h>
+#include <memory>
+
+struct aiNode;
+struct aiMesh;
+struct aiLight;
+struct aiCamera;
+struct aiMaterial;
+
+namespace Assimp {
+
+// TinyFormatter.h
+namespace Formatter {
+
+template <typename T, typename TR, typename A>
+class basic_formatter;
+
+typedef class basic_formatter<char, std::char_traits<char>, std::allocator<char>> format;
+
+} // namespace Formatter
+
+// BlenderDNA.h
+namespace Blender {
+class FileDatabase;
+struct ElemBase;
+} // namespace Blender
+
+// BlenderScene.h
+namespace Blender {
+struct Scene;
+struct Object;
+struct Collection;
+struct Mesh;
+struct Camera;
+struct Lamp;
+struct MTex;
+struct Image;
+struct Material;
+} // namespace Blender
+
+// BlenderIntermediate.h
+namespace Blender {
+struct ConversionData;
+template <template <typename, typename> class TCLASS, typename T>
+struct TempArray;
+} // namespace Blender
+
+// BlenderModifier.h
+namespace Blender {
+class BlenderModifierShowcase;
+class BlenderModifier;
+} // namespace Blender
+
+// -------------------------------------------------------------------------------------------
+/** Load blenders official binary format. The actual file structure (the `DNA` how they
+ *  call it is outsourced to BlenderDNA.cpp/BlenderDNA.h. This class only performs the
+ *  conversion from intermediate format to aiScene. */
+// -------------------------------------------------------------------------------------------
+class BlenderImporter : public BaseImporter, public LogFunctions<BlenderImporter> {
+public:
+    BlenderImporter();
+    ~BlenderImporter() override;
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const override;
+
+protected:
+    const aiImporterDesc *GetInfo() const override;
+    void SetupProperties(const Importer *pImp) override;
+    void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) override;
+    void ParseBlendFile(Blender::FileDatabase &out, std::shared_ptr<IOStream> stream);
+    void ExtractScene(Blender::Scene &out, const Blender::FileDatabase &file);
+    void ParseSubCollection(const Blender::Scene &in, aiNode *root, std::shared_ptr<Blender::Collection> collection, Blender::ConversionData &conv_data);
+    void ConvertBlendFile(aiScene *out, const Blender::Scene &in, const Blender::FileDatabase &file);
+
+private:
+    aiNode *ConvertNode(const Blender::Scene &in,
+            const Blender::Object *obj,
+            Blender::ConversionData &conv_info,
+            const aiMatrix4x4 &parentTransform);
+
+    // --------------------
+    void ConvertMesh(const Blender::Scene &in,
+            const Blender::Object *obj,
+            const Blender::Mesh *mesh,
+            Blender::ConversionData &conv_data,
+            Blender::TempArray<std::vector, aiMesh> &temp);
+
+    // --------------------
+    aiLight *ConvertLight(const Blender::Scene &in,
+            const Blender::Object *obj,
+            const Blender::Lamp *mesh,
+            Blender::ConversionData &conv_data);
+
+    // --------------------
+    aiCamera *ConvertCamera(const Blender::Scene &in,
+            const Blender::Object *obj,
+            const Blender::Camera *mesh,
+            Blender::ConversionData &conv_data);
+
+    // --------------------
+    void BuildDefaultMaterial(
+            Blender::ConversionData &conv_data);
+
+    // --------------------
+    void AddBlendParams(
+            aiMaterial *result,
+            const Blender::Material *source);
+
+    // --------------------
+    void BuildMaterials(
+            Blender::ConversionData &conv_data);
+
+    // --------------------
+    void ResolveTexture(
+            aiMaterial *out,
+            const Blender::Material *mat,
+            const Blender::MTex *tex,
+            Blender::ConversionData &conv_data);
+
+    // --------------------
+    void ResolveImage(
+            aiMaterial *out,
+            const Blender::Material *mat,
+            const Blender::MTex *tex,
+            const Blender::Image *img,
+            Blender::ConversionData &conv_data);
+
+    // --------------------
+    void AddSentinelTexture(
+            aiMaterial *out,
+            const Blender::Material *mat,
+            const Blender::MTex *tex,
+            Blender::ConversionData &conv_data);
+
+private: // static stuff, mostly logging and error reporting.
+    // --------------------
+    static void CheckActualType(const Blender::ElemBase *dt,
+            const char *check);
+
+    // --------------------
+    static void NotSupportedObjectType(const Blender::Object *obj,
+            const char *type);
+
+private:
+    Blender::BlenderModifierShowcase *modifier_cache;
+
+}; // !class BlenderImporter
+
+} // end of namespace Assimp
+#endif // AI_UNREALIMPORTER_H_INC
diff --git a/Engine/lib/assimp/code/Blender/BlenderModifier.cpp b/Engine/lib/assimp/code/AssetLib/Blender/BlenderModifier.cpp
similarity index 56%
rename from Engine/lib/assimp/code/Blender/BlenderModifier.cpp
rename to Engine/lib/assimp/code/AssetLib/Blender/BlenderModifier.cpp
index cc7acc929..d2b393dc4 100644
--- a/Engine/lib/assimp/code/Blender/BlenderModifier.cpp
+++ b/Engine/lib/assimp/code/AssetLib/Blender/BlenderModifier.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -57,52 +57,51 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 using namespace Assimp;
 using namespace Assimp::Blender;
 
-template <typename T> BlenderModifier* god() {
+template <typename T>
+BlenderModifier *god() {
     return new T();
 }
 
 // add all available modifiers here
-typedef BlenderModifier* (*fpCreateModifier)();
+typedef BlenderModifier *(*fpCreateModifier)();
 static const fpCreateModifier creators[] = {
-        &god<BlenderModifier_Mirror>,
-        &god<BlenderModifier_Subdivision>,
+    &god<BlenderModifier_Mirror>,
+    &god<BlenderModifier_Subdivision>,
 
-        NULL // sentinel
+    nullptr // sentinel
 };
 
 // ------------------------------------------------------------------------------------------------
-struct SharedModifierData : ElemBase
-{
+struct SharedModifierData : ElemBase {
     ModifierData modifier;
 };
 
 // ------------------------------------------------------------------------------------------------
-void BlenderModifierShowcase::ApplyModifiers(aiNode& out, ConversionData& conv_data, const Scene& in, const Object& orig_object )
-{
+void BlenderModifierShowcase::ApplyModifiers(aiNode &out, ConversionData &conv_data, const Scene &in, const Object &orig_object) {
     size_t cnt = 0u, ful = 0u;
 
     // NOTE: this cast is potentially unsafe by design, so we need to perform type checks before
     // we're allowed to dereference the pointers without risking to crash. We might still be
     // invoking UB btw - we're assuming that the ModifierData member of the respective modifier
     // structures is at offset sizeof(vftable) with no padding.
-    const SharedModifierData* cur = static_cast<const SharedModifierData *> ( orig_object.modifiers.first.get() );
-    for (; cur; cur =  static_cast<const SharedModifierData *> ( cur->modifier.next.get() ), ++ful) {
+    const SharedModifierData *cur = static_cast<const SharedModifierData *>(orig_object.modifiers.first.get());
+    for (; cur; cur = static_cast<const SharedModifierData *>(cur->modifier.next.get()), ++ful) {
         ai_assert(cur->dna_type);
 
-        const Structure* s = conv_data.db.dna.Get( cur->dna_type );
+        const Structure *s = conv_data.db.dna.Get(cur->dna_type);
         if (!s) {
-            ASSIMP_LOG_WARN_F("BlendModifier: could not resolve DNA name: ",cur->dna_type);
+            ASSIMP_LOG_WARN("BlendModifier: could not resolve DNA name: ", cur->dna_type);
             continue;
         }
 
         // this is a common trait of all XXXMirrorData structures in BlenderDNA
-        const Field* f = s->Get("modifier");
+        const Field *f = s->Get("modifier");
         if (!f || f->offset != 0) {
             ASSIMP_LOG_WARN("BlendModifier: expected a `modifier` member at offset 0");
             continue;
         }
 
-        s = conv_data.db.dna.Get( f->type );
+        s = conv_data.db.dna.Get(f->type);
         if (!s || s->name != "ModifierData") {
             ASSIMP_LOG_WARN("BlendModifier: expected a ModifierData structure as first member");
             continue;
@@ -110,30 +109,30 @@ void BlenderModifierShowcase::ApplyModifiers(aiNode& out, ConversionData& conv_d
 
         // now, we can be sure that we should be fine to dereference *cur* as
         // ModifierData (with the above note).
-        const ModifierData& dat = cur->modifier;
+        const ModifierData &dat = cur->modifier;
 
-        const fpCreateModifier* curgod = creators;
-        std::vector< BlenderModifier* >::iterator curmod = cached_modifiers->begin(), endmod = cached_modifiers->end();
+        const fpCreateModifier *curgod = creators;
+        std::vector<BlenderModifier *>::iterator curmod = cached_modifiers->begin(), endmod = cached_modifiers->end();
 
-        for (;*curgod;++curgod,++curmod) { // allocate modifiers on the fly
+        for (; *curgod; ++curgod, ++curmod) { // allocate modifiers on the fly
             if (curmod == endmod) {
                 cached_modifiers->push_back((*curgod)());
 
                 endmod = cached_modifiers->end();
-                curmod = endmod-1;
+                curmod = endmod - 1;
             }
 
-            BlenderModifier* const modifier = *curmod;
-            if(modifier->IsActive(dat)) {
-                modifier->DoIt(out,conv_data,*static_cast<const ElemBase *>(cur),in,orig_object);
+            BlenderModifier *const modifier = *curmod;
+            if (modifier->IsActive(dat)) {
+                modifier->DoIt(out, conv_data, *static_cast<const ElemBase *>(cur), in, orig_object);
                 cnt++;
 
-                curgod = NULL;
+                curgod = nullptr;
                 break;
             }
         }
         if (curgod) {
-            ASSIMP_LOG_WARN_F("Couldn't find a handler for modifier: ",dat.name);
+            ASSIMP_LOG_WARN("Couldn't find a handler for modifier: ", dat.name);
         }
     }
 
@@ -141,26 +140,22 @@ void BlenderModifierShowcase::ApplyModifiers(aiNode& out, ConversionData& conv_d
     // object, we still can't say whether our modifier implementations were
     // able to fully do their job.
     if (ful) {
-        ASSIMP_LOG_DEBUG_F("BlendModifier: found handlers for ",cnt," of ",ful," modifiers on `",orig_object.id.name,
-            "`, check log messages above for errors");
+        ASSIMP_LOG_DEBUG("BlendModifier: found handlers for ", cnt, " of ", ful, " modifiers on `", orig_object.id.name,
+                "`, check log messages above for errors");
     }
 }
 
-
-
 // ------------------------------------------------------------------------------------------------
-bool BlenderModifier_Mirror :: IsActive (const ModifierData& modin)
-{
+bool BlenderModifier_Mirror ::IsActive(const ModifierData &modin) {
     return modin.type == ModifierData::eModifierType_Mirror;
 }
 
 // ------------------------------------------------------------------------------------------------
-void  BlenderModifier_Mirror :: DoIt(aiNode& out, ConversionData& conv_data,  const ElemBase& orig_modifier,
-    const Scene& /*in*/,
-    const Object& orig_object )
-{
+void BlenderModifier_Mirror ::DoIt(aiNode &out, ConversionData &conv_data, const ElemBase &orig_modifier,
+        const Scene & /*in*/,
+        const Object &orig_object) {
     // hijacking the ABI, see the big note in BlenderModifierShowcase::ApplyModifiers()
-    const MirrorModifierData& mir = static_cast<const MirrorModifierData&>(orig_modifier);
+    const MirrorModifierData &mir = static_cast<const MirrorModifierData &>(orig_modifier);
     ai_assert(mir.modifier.type == ModifierData::eModifierType_Mirror);
 
     conv_data.meshes->reserve(conv_data.meshes->size() + out.mNumMeshes);
@@ -169,48 +164,55 @@ void  BlenderModifier_Mirror :: DoIt(aiNode& out, ConversionData& conv_data,  co
 
     // take all input meshes and clone them
     for (unsigned int i = 0; i < out.mNumMeshes; ++i) {
-        aiMesh* mesh;
-        SceneCombiner::Copy(&mesh,conv_data.meshes[out.mMeshes[i]]);
+        aiMesh *mesh;
+        SceneCombiner::Copy(&mesh, conv_data.meshes[out.mMeshes[i]]);
 
         const float xs = mir.flag & MirrorModifierData::Flags_AXIS_X ? -1.f : 1.f;
         const float ys = mir.flag & MirrorModifierData::Flags_AXIS_Y ? -1.f : 1.f;
         const float zs = mir.flag & MirrorModifierData::Flags_AXIS_Z ? -1.f : 1.f;
 
         if (mir.mirror_ob) {
-            const aiVector3D center( mir.mirror_ob->obmat[3][0],mir.mirror_ob->obmat[3][1],mir.mirror_ob->obmat[3][2] );
-            for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
-                aiVector3D& v = mesh->mVertices[i];
+            const aiVector3D center(mir.mirror_ob->obmat[3][0], mir.mirror_ob->obmat[3][1], mir.mirror_ob->obmat[3][2]);
+            for (unsigned int j = 0; j < mesh->mNumVertices; ++j) {
+                aiVector3D &v = mesh->mVertices[j];
 
-                v.x = center.x + xs*(center.x - v.x);
-                v.y = center.y + ys*(center.y - v.y);
-                v.z = center.z + zs*(center.z - v.z);
+                v.x = center.x + xs * (center.x - v.x);
+                v.y = center.y + ys * (center.y - v.y);
+                v.z = center.z + zs * (center.z - v.z);
             }
-        }
-        else {
-            for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
-                aiVector3D& v = mesh->mVertices[i];
-                v.x *= xs;v.y *= ys;v.z *= zs;
+        } else {
+            for (unsigned int j = 0; j < mesh->mNumVertices; ++j) {
+                aiVector3D &v = mesh->mVertices[j];
+                v.x *= xs;
+                v.y *= ys;
+                v.z *= zs;
             }
         }
 
         if (mesh->mNormals) {
-            for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
-                aiVector3D& v = mesh->mNormals[i];
-                v.x *= xs;v.y *= ys;v.z *= zs;
+            for (unsigned int j = 0; j < mesh->mNumVertices; ++j) {
+                aiVector3D &v = mesh->mNormals[j];
+                v.x *= xs;
+                v.y *= ys;
+                v.z *= zs;
             }
         }
 
         if (mesh->mTangents) {
-            for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
-                aiVector3D& v = mesh->mTangents[i];
-                v.x *= xs;v.y *= ys;v.z *= zs;
+            for (unsigned int j = 0; j < mesh->mNumVertices; ++j) {
+                aiVector3D &v = mesh->mTangents[j];
+                v.x *= xs;
+                v.y *= ys;
+                v.z *= zs;
             }
         }
 
         if (mesh->mBitangents) {
-            for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
-                aiVector3D& v = mesh->mBitangents[i];
-                v.x *= xs;v.y *= ys;v.z *= zs;
+            for (unsigned int j = 0; j < mesh->mNumVertices; ++j) {
+                aiVector3D &v = mesh->mBitangents[j];
+                v.x *= xs;
+                v.y *= ys;
+                v.z *= zs;
             }
         }
 
@@ -218,55 +220,53 @@ void  BlenderModifier_Mirror :: DoIt(aiNode& out, ConversionData& conv_data,  co
         const float vs = mir.flag & MirrorModifierData::Flags_MIRROR_V ? -1.f : 1.f;
 
         for (unsigned int n = 0; mesh->HasTextureCoords(n); ++n) {
-            for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
-                aiVector3D& v = mesh->mTextureCoords[n][i];
-                v.x *= us;v.y *= vs;
+            for (unsigned int j = 0; j < mesh->mNumVertices; ++j) {
+                aiVector3D &v = mesh->mTextureCoords[n][j];
+                v.x *= us;
+                v.y *= vs;
             }
         }
 
         // Only reverse the winding order if an odd number of axes were mirrored.
         if (xs * ys * zs < 0) {
-            for( unsigned int i = 0; i < mesh->mNumFaces; i++) {
-                aiFace& face = mesh->mFaces[i];
-                for( unsigned int fi = 0; fi < face.mNumIndices / 2; ++fi)
-                    std::swap( face.mIndices[fi], face.mIndices[face.mNumIndices - 1 - fi]);
+            for (unsigned int j = 0; j < mesh->mNumFaces; ++j) {
+                aiFace &face = mesh->mFaces[j];
+                for (unsigned int fi = 0; fi < face.mNumIndices / 2; ++fi)
+                    std::swap(face.mIndices[fi], face.mIndices[face.mNumIndices - 1 - fi]);
             }
         }
 
         conv_data.meshes->push_back(mesh);
     }
-    unsigned int* nind = new unsigned int[out.mNumMeshes*2];
+    unsigned int *nind = new unsigned int[out.mNumMeshes * 2];
 
-    std::copy(out.mMeshes,out.mMeshes+out.mNumMeshes,nind);
-    std::transform(out.mMeshes,out.mMeshes+out.mNumMeshes,nind+out.mNumMeshes,
-        [&out](unsigned int n) { return out.mNumMeshes + n; });
+    std::copy(out.mMeshes, out.mMeshes + out.mNumMeshes, nind);
+    std::transform(out.mMeshes, out.mMeshes + out.mNumMeshes, nind + out.mNumMeshes,
+            [&out](unsigned int n) { return out.mNumMeshes + n; });
 
     delete[] out.mMeshes;
     out.mMeshes = nind;
     out.mNumMeshes *= 2;
 
-    ASSIMP_LOG_INFO_F("BlendModifier: Applied the `Mirror` modifier to `",
-        orig_object.id.name,"`");
+    ASSIMP_LOG_INFO("BlendModifier: Applied the `Mirror` modifier to `",
+            orig_object.id.name, "`");
 }
 
 // ------------------------------------------------------------------------------------------------
-bool BlenderModifier_Subdivision :: IsActive (const ModifierData& modin)
-{
+bool BlenderModifier_Subdivision ::IsActive(const ModifierData &modin) {
     return modin.type == ModifierData::eModifierType_Subsurf;
 }
 
 // ------------------------------------------------------------------------------------------------
-void  BlenderModifier_Subdivision :: DoIt(aiNode& out, ConversionData& conv_data,  const ElemBase& orig_modifier,
-    const Scene& /*in*/,
-    const Object& orig_object )
-{
+void BlenderModifier_Subdivision ::DoIt(aiNode &out, ConversionData &conv_data, const ElemBase &orig_modifier,
+        const Scene & /*in*/,
+        const Object &orig_object) {
     // hijacking the ABI, see the big note in BlenderModifierShowcase::ApplyModifiers()
-    const SubsurfModifierData& mir = static_cast<const SubsurfModifierData&>(orig_modifier);
+    const SubsurfModifierData &mir = static_cast<const SubsurfModifierData &>(orig_modifier);
     ai_assert(mir.modifier.type == ModifierData::eModifierType_Subsurf);
 
     Subdivider::Algorithm algo;
-    switch (mir.subdivType)
-    {
+    switch (mir.subdivType) {
     case SubsurfModifierData::TYPE_CatmullClarke:
         algo = Subdivider::CATMULL_CLARKE;
         break;
@@ -277,23 +277,23 @@ void  BlenderModifier_Subdivision :: DoIt(aiNode& out, ConversionData& conv_data
         break;
 
     default:
-        ASSIMP_LOG_WARN_F("BlendModifier: Unrecognized subdivision algorithm: ",mir.subdivType);
+        ASSIMP_LOG_WARN("BlendModifier: Unrecognized subdivision algorithm: ", mir.subdivType);
         return;
     };
 
     std::unique_ptr<Subdivider> subd(Subdivider::Create(algo));
     ai_assert(subd);
-    if ( conv_data.meshes->empty() ) {
+    if (conv_data.meshes->empty()) {
         return;
     }
-    aiMesh** const meshes = &conv_data.meshes[conv_data.meshes->size() - out.mNumMeshes];
-    std::unique_ptr<aiMesh*[]> tempmeshes(new aiMesh*[out.mNumMeshes]());
+    aiMesh **const meshes = &conv_data.meshes[conv_data.meshes->size() - out.mNumMeshes];
+    std::unique_ptr<aiMesh *[]> tempmeshes(new aiMesh *[out.mNumMeshes]());
 
-    subd->Subdivide(meshes,out.mNumMeshes,tempmeshes.get(),std::max( mir.renderLevels, mir.levels ),true);
-    std::copy(tempmeshes.get(),tempmeshes.get()+out.mNumMeshes,meshes);
+    subd->Subdivide(meshes, out.mNumMeshes, tempmeshes.get(), std::max(mir.renderLevels, mir.levels), true);
+    std::copy(tempmeshes.get(), tempmeshes.get() + out.mNumMeshes, meshes);
 
-    ASSIMP_LOG_INFO_F("BlendModifier: Applied the `Subdivision` modifier to `",
-        orig_object.id.name,"`");
+    ASSIMP_LOG_INFO("BlendModifier: Applied the `Subdivision` modifier to `",
+            orig_object.id.name, "`");
 }
 
 #endif // ASSIMP_BUILD_NO_BLEND_IMPORTER
diff --git a/Engine/lib/assimp/code/Blender/BlenderModifier.h b/Engine/lib/assimp/code/AssetLib/Blender/BlenderModifier.h
similarity index 93%
rename from Engine/lib/assimp/code/Blender/BlenderModifier.h
rename to Engine/lib/assimp/code/AssetLib/Blender/BlenderModifier.h
index c260ba1f6..5af560caf 100644
--- a/Engine/lib/assimp/code/Blender/BlenderModifier.h
+++ b/Engine/lib/assimp/code/AssetLib/Blender/BlenderModifier.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -52,9 +52,9 @@ namespace Assimp {
 namespace Blender {
 
 // -------------------------------------------------------------------------------------------
-/** 
+/**
  *  Dummy base class for all blender modifiers. Modifiers are reused between imports, so
- *  they should be stateless and not try to cache model data. 
+ *  they should be stateless and not try to cache model data.
  */
 // -------------------------------------------------------------------------------------------
 class BlenderModifier {
@@ -67,7 +67,7 @@ public:
     }
 
     // --------------------
-    /** 
+    /**
      *  Check if *this* modifier is active, given a ModifierData& block.
      */
     virtual bool IsActive( const ModifierData& /*modin*/) {
@@ -75,10 +75,10 @@ public:
     }
 
     // --------------------
-    /** 
+    /**
      *  Apply the modifier to a given output node. The original data used
      *  to construct the node is given as well. Not called unless IsActive()
-     *  was called and gave positive response. 
+     *  was called and gave positive response.
      */
     virtual void DoIt(aiNode& /*out*/,
         ConversionData& /*conv_data*/,
@@ -86,14 +86,14 @@ public:
         const Scene& /*in*/,
         const Object& /*orig_object*/
     ) {
-        ASSIMP_LOG_INFO_F("This modifier is not supported, skipping: ",orig_modifier.dna_type );
+        ASSIMP_LOG_INFO("This modifier is not supported, skipping: ",orig_modifier.dna_type );
         return;
     }
 };
 
 // -------------------------------------------------------------------------------------------
-/** 
- *  Manage all known modifiers and instance and apply them if necessary 
+/**
+ *  Manage all known modifiers and instance and apply them if necessary
  */
 // -------------------------------------------------------------------------------------------
 class BlenderModifierShowcase {
@@ -113,8 +113,8 @@ private:
 // MODIFIERS /////////////////////////////////////////////////////////////////////////////////
 
 // -------------------------------------------------------------------------------------------
-/** 
- *  Mirror modifier. Status: implemented. 
+/**
+ *  Mirror modifier. Status: implemented.
  */
 // -------------------------------------------------------------------------------------------
 class BlenderModifier_Mirror : public BlenderModifier {
diff --git a/Engine/lib/assimp/code/AssetLib/Blender/BlenderScene.cpp b/Engine/lib/assimp/code/AssetLib/Blender/BlenderScene.cpp
new file mode 100644
index 000000000..9ad086fe6
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Blender/BlenderScene.cpp
@@ -0,0 +1,891 @@
+/*
+Open Asset Import Library (ASSIMP)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2020, ASSIMP Development Team
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the ASSIMP team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the ASSIMP Development Team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file  BlenderScene.cpp
+ *  @brief MACHINE GENERATED BY ./scripts/BlenderImporter/genblenddna.py
+ */
+
+#ifndef ASSIMP_BUILD_NO_BLEND_IMPORTER
+
+#include "BlenderScene.h"
+#include "BlenderCustomData.h"
+#include "BlenderDNA.h"
+#include "BlenderSceneGen.h"
+
+namespace Assimp {
+namespace Blender {
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<Object>(
+        Object &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.id, "id", db);
+    int temp = 0;
+    ReadField<ErrorPolicy_Fail>(temp, "type", db);
+    dest.type = static_cast<Assimp::Blender::Object::Type>(temp);
+    ReadFieldArray2<ErrorPolicy_Warn>(dest.obmat, "obmat", db);
+    ReadFieldArray2<ErrorPolicy_Warn>(dest.parentinv, "parentinv", db);
+    ReadFieldArray<ErrorPolicy_Warn>(dest.parsubstr, "parsubstr", db);
+    {
+        std::shared_ptr<Object> parent;
+        ReadFieldPtr<ErrorPolicy_Warn>(parent, "*parent", db);
+        dest.parent = parent.get();
+    }
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.track, "*track", db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.proxy, "*proxy", db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.proxy_from, "*proxy_from", db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.proxy_group, "*proxy_group", db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.dup_group, "*dup_group", db);
+    ReadFieldPtr<ErrorPolicy_Fail>(dest.data, "*data", db);
+    ReadField<ErrorPolicy_Igno>(dest.modifiers, "modifiers", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<Group>(
+        Group &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.id, "id", db);
+    ReadField<ErrorPolicy_Igno>(dest.layer, "layer", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.gobject, "*gobject", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure::Convert<CollectionObject>(
+        CollectionObject &dest,
+        const FileDatabase &db) const {
+
+    ReadFieldPtr<ErrorPolicy_Fail>(dest.next, "*next", db);
+    {
+        //std::shared_ptr<CollectionObject> prev;
+        //ReadFieldPtr<ErrorPolicy_Fail>(prev, "*prev", db);
+        //dest.prev = prev.get();
+
+        std::shared_ptr<Object> ob;
+        ReadFieldPtr<ErrorPolicy_Igno>(ob, "*ob", db);
+        dest.ob = ob.get();
+    }
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure::Convert<CollectionChild>(
+        CollectionChild &dest,
+        const FileDatabase &db) const {
+
+    ReadFieldPtr<ErrorPolicy_Fail>(dest.prev, "*prev", db);
+    ReadFieldPtr<ErrorPolicy_Fail>(dest.next, "*next", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.collection, "*collection", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure::Convert<Collection>(
+        Collection &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.id, "id", db);
+    ReadField<ErrorPolicy_Fail>(dest.gobject, "gobject", db);
+    ReadField<ErrorPolicy_Fail>(dest.children, "children", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<MTex>(
+        MTex &dest,
+        const FileDatabase &db) const {
+
+    int temp_short = 0;
+    ReadField<ErrorPolicy_Igno>(temp_short, "mapto", db);
+    dest.mapto = static_cast<Assimp::Blender::MTex::MapType>(temp_short);
+    int temp = 0;
+    ReadField<ErrorPolicy_Igno>(temp, "blendtype", db);
+    dest.blendtype = static_cast<Assimp::Blender::MTex::BlendType>(temp);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.object, "*object", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.tex, "*tex", db);
+    ReadFieldArray<ErrorPolicy_Igno>(dest.uvname, "uvname", db);
+    ReadField<ErrorPolicy_Igno>(temp, "projx", db);
+    dest.projx = static_cast<Assimp::Blender::MTex::Projection>(temp);
+    ReadField<ErrorPolicy_Igno>(temp, "projy", db);
+    dest.projy = static_cast<Assimp::Blender::MTex::Projection>(temp);
+    ReadField<ErrorPolicy_Igno>(temp, "projz", db);
+    dest.projz = static_cast<Assimp::Blender::MTex::Projection>(temp);
+    ReadField<ErrorPolicy_Igno>(dest.mapping, "mapping", db);
+    ReadFieldArray<ErrorPolicy_Igno>(dest.ofs, "ofs", db);
+    ReadFieldArray<ErrorPolicy_Igno>(dest.size, "size", db);
+    ReadField<ErrorPolicy_Igno>(dest.rot, "rot", db);
+    ReadField<ErrorPolicy_Igno>(dest.texflag, "texflag", db);
+    ReadField<ErrorPolicy_Igno>(dest.colormodel, "colormodel", db);
+    ReadField<ErrorPolicy_Igno>(dest.pmapto, "pmapto", db);
+    ReadField<ErrorPolicy_Igno>(dest.pmaptoneg, "pmaptoneg", db);
+    ReadField<ErrorPolicy_Warn>(dest.r, "r", db);
+    ReadField<ErrorPolicy_Warn>(dest.g, "g", db);
+    ReadField<ErrorPolicy_Warn>(dest.b, "b", db);
+    ReadField<ErrorPolicy_Warn>(dest.k, "k", db);
+    ReadField<ErrorPolicy_Igno>(dest.colspecfac, "colspecfac", db);
+    ReadField<ErrorPolicy_Igno>(dest.mirrfac, "mirrfac", db);
+    ReadField<ErrorPolicy_Igno>(dest.alphafac, "alphafac", db);
+    ReadField<ErrorPolicy_Igno>(dest.difffac, "difffac", db);
+    ReadField<ErrorPolicy_Igno>(dest.specfac, "specfac", db);
+    ReadField<ErrorPolicy_Igno>(dest.emitfac, "emitfac", db);
+    ReadField<ErrorPolicy_Igno>(dest.hardfac, "hardfac", db);
+    ReadField<ErrorPolicy_Igno>(dest.norfac, "norfac", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<TFace>(
+        TFace &dest,
+        const FileDatabase &db) const {
+
+    ReadFieldArray2<ErrorPolicy_Fail>(dest.uv, "uv", db);
+    ReadFieldArray<ErrorPolicy_Fail>(dest.col, "col", db);
+    ReadField<ErrorPolicy_Igno>(dest.flag, "flag", db);
+    ReadField<ErrorPolicy_Igno>(dest.mode, "mode", db);
+    ReadField<ErrorPolicy_Igno>(dest.tile, "tile", db);
+    ReadField<ErrorPolicy_Igno>(dest.unwrap, "unwrap", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<SubsurfModifierData>(
+        SubsurfModifierData &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.modifier, "modifier", db);
+    ReadField<ErrorPolicy_Warn>(dest.subdivType, "subdivType", db);
+    ReadField<ErrorPolicy_Fail>(dest.levels, "levels", db);
+    ReadField<ErrorPolicy_Igno>(dest.renderLevels, "renderLevels", db);
+    ReadField<ErrorPolicy_Igno>(dest.flags, "flags", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<MFace>(
+        MFace &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.v1, "v1", db);
+    ReadField<ErrorPolicy_Fail>(dest.v2, "v2", db);
+    ReadField<ErrorPolicy_Fail>(dest.v3, "v3", db);
+    ReadField<ErrorPolicy_Fail>(dest.v4, "v4", db);
+    ReadField<ErrorPolicy_Fail>(dest.mat_nr, "mat_nr", db);
+    ReadField<ErrorPolicy_Igno>(dest.flag, "flag", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<Lamp>(
+        Lamp &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.id, "id", db);
+    int temp = 0;
+    ReadField<ErrorPolicy_Fail>(temp, "type", db);
+    dest.type = static_cast<Assimp::Blender::Lamp::Type>(temp);
+    ReadField<ErrorPolicy_Igno>(dest.flags, "flag", db);
+    ReadField<ErrorPolicy_Igno>(dest.colormodel, "colormodel", db);
+    ReadField<ErrorPolicy_Igno>(dest.totex, "totex", db);
+    ReadField<ErrorPolicy_Warn>(dest.r, "r", db);
+    ReadField<ErrorPolicy_Warn>(dest.g, "g", db);
+    ReadField<ErrorPolicy_Warn>(dest.b, "b", db);
+    ReadField<ErrorPolicy_Warn>(dest.k, "k", db);
+    ReadField<ErrorPolicy_Igno>(dest.energy, "energy", db);
+    ReadField<ErrorPolicy_Warn>(dest.dist, "dist", db);
+    ReadField<ErrorPolicy_Igno>(dest.spotsize, "spotsize", db);
+    ReadField<ErrorPolicy_Igno>(dest.spotblend, "spotblend", db);
+    ReadField<ErrorPolicy_Warn>(dest.constant_coefficient, "coeff_const", db);
+    ReadField<ErrorPolicy_Warn>(dest.linear_coefficient, "coeff_lin", db);
+    ReadField<ErrorPolicy_Warn>(dest.quadratic_coefficient, "coeff_quad", db);
+    ReadField<ErrorPolicy_Igno>(dest.att1, "att1", db);
+    ReadField<ErrorPolicy_Igno>(dest.att2, "att2", db);
+    ReadField<ErrorPolicy_Igno>(temp, "falloff_type", db);
+    dest.falloff_type = static_cast<Assimp::Blender::Lamp::FalloffType>(temp);
+    ReadField<ErrorPolicy_Igno>(dest.sun_brightness, "sun_brightness", db);
+    ReadField<ErrorPolicy_Igno>(dest.area_size, "area_size", db);
+    ReadField<ErrorPolicy_Igno>(dest.area_sizey, "area_sizey", db);
+    ReadField<ErrorPolicy_Igno>(dest.area_sizez, "area_sizez", db);
+    ReadField<ErrorPolicy_Igno>(dest.area_shape, "area_shape", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<MDeformWeight>(
+        MDeformWeight &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.def_nr, "def_nr", db);
+    ReadField<ErrorPolicy_Fail>(dest.weight, "weight", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<PackedFile>(
+        PackedFile &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Warn>(dest.size, "size", db);
+    ReadField<ErrorPolicy_Warn>(dest.seek, "seek", db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.data, "*data", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<Base>(
+        Base &dest,
+        const FileDatabase &db) const {
+    // note: as per https://github.com/assimp/assimp/issues/128,
+    // reading the Object linked list recursively is prone to stack overflow.
+    // This structure converter is therefore an hand-written exception that
+    // does it iteratively.
+
+    const int initial_pos = db.reader->GetCurrentPos();
+
+    std::pair<Base *, int> todo = std::make_pair(&dest, initial_pos);
+    for (;;) {
+
+        Base &cur_dest = *todo.first;
+        db.reader->SetCurrentPos(todo.second);
+
+        // we know that this is a double-linked, circular list which we never
+        // traverse backwards, so don't bother resolving the back links.
+        cur_dest.prev = nullptr;
+
+        ReadFieldPtr<ErrorPolicy_Warn>(cur_dest.object, "*object", db);
+
+        // the return value of ReadFieldPtr indicates whether the object
+        // was already cached. In this case, we don't need to resolve
+        // it again.
+        if (!ReadFieldPtr<ErrorPolicy_Warn>(cur_dest.next, "*next", db, true) && cur_dest.next) {
+            todo = std::make_pair(&*cur_dest.next, db.reader->GetCurrentPos());
+            continue;
+        }
+        break;
+    }
+
+    db.reader->SetCurrentPos(initial_pos + size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<MTFace>(
+        MTFace &dest,
+        const FileDatabase &db) const {
+
+    ReadFieldArray2<ErrorPolicy_Fail>(dest.uv, "uv", db);
+    ReadField<ErrorPolicy_Igno>(dest.flag, "flag", db);
+    ReadField<ErrorPolicy_Igno>(dest.mode, "mode", db);
+    ReadField<ErrorPolicy_Igno>(dest.tile, "tile", db);
+    ReadField<ErrorPolicy_Igno>(dest.unwrap, "unwrap", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<Material>(
+        Material &dest,
+        const FileDatabase &db) const {
+    ReadField<ErrorPolicy_Fail>(dest.id, "id", db);
+    ReadField<ErrorPolicy_Warn>(dest.r, "r", db);
+    ReadField<ErrorPolicy_Warn>(dest.g, "g", db);
+    ReadField<ErrorPolicy_Warn>(dest.b, "b", db);
+    ReadField<ErrorPolicy_Warn>(dest.specr, "specr", db);
+    ReadField<ErrorPolicy_Warn>(dest.specg, "specg", db);
+    ReadField<ErrorPolicy_Warn>(dest.specb, "specb", db);
+    ReadField<ErrorPolicy_Igno>(dest.har, "har", db);
+    ReadField<ErrorPolicy_Warn>(dest.ambr, "ambr", db);
+    ReadField<ErrorPolicy_Warn>(dest.ambg, "ambg", db);
+    ReadField<ErrorPolicy_Warn>(dest.ambb, "ambb", db);
+    ReadField<ErrorPolicy_Igno>(dest.mirr, "mirr", db);
+    ReadField<ErrorPolicy_Igno>(dest.mirg, "mirg", db);
+    ReadField<ErrorPolicy_Igno>(dest.mirb, "mirb", db);
+    ReadField<ErrorPolicy_Warn>(dest.emit, "emit", db);
+    ReadField<ErrorPolicy_Igno>(dest.ray_mirror, "ray_mirror", db);
+    ReadField<ErrorPolicy_Warn>(dest.alpha, "alpha", db);
+    ReadField<ErrorPolicy_Igno>(dest.ref, "ref", db);
+    ReadField<ErrorPolicy_Igno>(dest.translucency, "translucency", db);
+    ReadField<ErrorPolicy_Igno>(dest.mode, "mode", db);
+    ReadField<ErrorPolicy_Igno>(dest.roughness, "roughness", db);
+    ReadField<ErrorPolicy_Igno>(dest.darkness, "darkness", db);
+    ReadField<ErrorPolicy_Igno>(dest.refrac, "refrac", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.group, "*group", db);
+    ReadField<ErrorPolicy_Warn>(dest.diff_shader, "diff_shader", db);
+    ReadField<ErrorPolicy_Warn>(dest.spec_shader, "spec_shader", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.mtex, "*mtex", db);
+
+    ReadField<ErrorPolicy_Igno>(dest.amb, "amb", db);
+    ReadField<ErrorPolicy_Igno>(dest.ang, "ang", db);
+    ReadField<ErrorPolicy_Igno>(dest.spectra, "spectra", db);
+    ReadField<ErrorPolicy_Igno>(dest.spec, "spec", db);
+    ReadField<ErrorPolicy_Igno>(dest.zoffs, "zoffs", db);
+    ReadField<ErrorPolicy_Igno>(dest.add, "add", db);
+    ReadField<ErrorPolicy_Igno>(dest.fresnel_mir, "fresnel_mir", db);
+    ReadField<ErrorPolicy_Igno>(dest.fresnel_mir_i, "fresnel_mir_i", db);
+    ReadField<ErrorPolicy_Igno>(dest.fresnel_tra, "fresnel_tra", db);
+    ReadField<ErrorPolicy_Igno>(dest.fresnel_tra_i, "fresnel_tra_i", db);
+    ReadField<ErrorPolicy_Igno>(dest.filter, "filter", db);
+    ReadField<ErrorPolicy_Igno>(dest.tx_limit, "tx_limit", db);
+    ReadField<ErrorPolicy_Igno>(dest.tx_falloff, "tx_falloff", db);
+    ReadField<ErrorPolicy_Igno>(dest.gloss_mir, "gloss_mir", db);
+    ReadField<ErrorPolicy_Igno>(dest.gloss_tra, "gloss_tra", db);
+    ReadField<ErrorPolicy_Igno>(dest.adapt_thresh_mir, "adapt_thresh_mir", db);
+    ReadField<ErrorPolicy_Igno>(dest.adapt_thresh_tra, "adapt_thresh_tra", db);
+    ReadField<ErrorPolicy_Igno>(dest.aniso_gloss_mir, "aniso_gloss_mir", db);
+    ReadField<ErrorPolicy_Igno>(dest.dist_mir, "dist_mir", db);
+    ReadField<ErrorPolicy_Igno>(dest.hasize, "hasize", db);
+    ReadField<ErrorPolicy_Igno>(dest.flaresize, "flaresize", db);
+    ReadField<ErrorPolicy_Igno>(dest.subsize, "subsize", db);
+    ReadField<ErrorPolicy_Igno>(dest.flareboost, "flareboost", db);
+    ReadField<ErrorPolicy_Igno>(dest.strand_sta, "strand_sta", db);
+    ReadField<ErrorPolicy_Igno>(dest.strand_end, "strand_end", db);
+    ReadField<ErrorPolicy_Igno>(dest.strand_ease, "strand_ease", db);
+    ReadField<ErrorPolicy_Igno>(dest.strand_surfnor, "strand_surfnor", db);
+    ReadField<ErrorPolicy_Igno>(dest.strand_min, "strand_min", db);
+    ReadField<ErrorPolicy_Igno>(dest.strand_widthfade, "strand_widthfade", db);
+    ReadField<ErrorPolicy_Igno>(dest.sbias, "sbias", db);
+    ReadField<ErrorPolicy_Igno>(dest.lbias, "lbias", db);
+    ReadField<ErrorPolicy_Igno>(dest.shad_alpha, "shad_alpha", db);
+    ReadField<ErrorPolicy_Igno>(dest.param, "param", db);
+    ReadField<ErrorPolicy_Igno>(dest.rms, "rms", db);
+    ReadField<ErrorPolicy_Igno>(dest.rampfac_col, "rampfac_col", db);
+    ReadField<ErrorPolicy_Igno>(dest.rampfac_spec, "rampfac_spec", db);
+    ReadField<ErrorPolicy_Igno>(dest.friction, "friction", db);
+    ReadField<ErrorPolicy_Igno>(dest.fh, "fh", db);
+    ReadField<ErrorPolicy_Igno>(dest.reflect, "reflect", db);
+    ReadField<ErrorPolicy_Igno>(dest.fhdist, "fhdist", db);
+    ReadField<ErrorPolicy_Igno>(dest.xyfrict, "xyfrict", db);
+    ReadField<ErrorPolicy_Igno>(dest.sss_radius, "sss_radius", db);
+    ReadField<ErrorPolicy_Igno>(dest.sss_col, "sss_col", db);
+    ReadField<ErrorPolicy_Igno>(dest.sss_error, "sss_error", db);
+    ReadField<ErrorPolicy_Igno>(dest.sss_scale, "sss_scale", db);
+    ReadField<ErrorPolicy_Igno>(dest.sss_ior, "sss_ior", db);
+    ReadField<ErrorPolicy_Igno>(dest.sss_colfac, "sss_colfac", db);
+    ReadField<ErrorPolicy_Igno>(dest.sss_texfac, "sss_texfac", db);
+    ReadField<ErrorPolicy_Igno>(dest.sss_front, "sss_front", db);
+    ReadField<ErrorPolicy_Igno>(dest.sss_back, "sss_back", db);
+
+    ReadField<ErrorPolicy_Igno>(dest.material_type, "material_type", db);
+    ReadField<ErrorPolicy_Igno>(dest.flag, "flag", db);
+    ReadField<ErrorPolicy_Igno>(dest.ray_depth, "ray_depth", db);
+    ReadField<ErrorPolicy_Igno>(dest.ray_depth_tra, "ray_depth_tra", db);
+    ReadField<ErrorPolicy_Igno>(dest.samp_gloss_mir, "samp_gloss_mir", db);
+    ReadField<ErrorPolicy_Igno>(dest.samp_gloss_tra, "samp_gloss_tra", db);
+    ReadField<ErrorPolicy_Igno>(dest.fadeto_mir, "fadeto_mir", db);
+    ReadField<ErrorPolicy_Igno>(dest.shade_flag, "shade_flag", db);
+    ReadField<ErrorPolicy_Igno>(dest.flarec, "flarec", db);
+    ReadField<ErrorPolicy_Igno>(dest.starc, "starc", db);
+    ReadField<ErrorPolicy_Igno>(dest.linec, "linec", db);
+    ReadField<ErrorPolicy_Igno>(dest.ringc, "ringc", db);
+    ReadField<ErrorPolicy_Igno>(dest.pr_lamp, "pr_lamp", db);
+    ReadField<ErrorPolicy_Igno>(dest.pr_texture, "pr_texture", db);
+    ReadField<ErrorPolicy_Igno>(dest.ml_flag, "ml_flag", db);
+    ReadField<ErrorPolicy_Igno>(dest.diff_shader, "diff_shader", db);
+    ReadField<ErrorPolicy_Igno>(dest.spec_shader, "spec_shader", db);
+    ReadField<ErrorPolicy_Igno>(dest.texco, "texco", db);
+    ReadField<ErrorPolicy_Igno>(dest.mapto, "mapto", db);
+    ReadField<ErrorPolicy_Igno>(dest.ramp_show, "ramp_show", db);
+    ReadField<ErrorPolicy_Igno>(dest.pad3, "pad3", db);
+    ReadField<ErrorPolicy_Igno>(dest.dynamode, "dynamode", db);
+    ReadField<ErrorPolicy_Igno>(dest.pad2, "pad2", db);
+    ReadField<ErrorPolicy_Igno>(dest.sss_flag, "sss_flag", db);
+    ReadField<ErrorPolicy_Igno>(dest.sss_preset, "sss_preset", db);
+    ReadField<ErrorPolicy_Igno>(dest.shadowonly_flag, "shadowonly_flag", db);
+    ReadField<ErrorPolicy_Igno>(dest.index, "index", db);
+    ReadField<ErrorPolicy_Igno>(dest.vcol_alpha, "vcol_alpha", db);
+    ReadField<ErrorPolicy_Igno>(dest.pad4, "pad4", db);
+
+    ReadField<ErrorPolicy_Igno>(dest.seed1, "seed1", db);
+    ReadField<ErrorPolicy_Igno>(dest.seed2, "seed2", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<MTexPoly>(
+        MTexPoly &dest,
+        const FileDatabase &db) const {
+
+    {
+        std::shared_ptr<Image> tpage;
+        ReadFieldPtr<ErrorPolicy_Igno>(tpage, "*tpage", db);
+        dest.tpage = tpage.get();
+    }
+    ReadField<ErrorPolicy_Igno>(dest.flag, "flag", db);
+    ReadField<ErrorPolicy_Igno>(dest.transp, "transp", db);
+    ReadField<ErrorPolicy_Igno>(dest.mode, "mode", db);
+    ReadField<ErrorPolicy_Igno>(dest.tile, "tile", db);
+    ReadField<ErrorPolicy_Igno>(dest.pad, "pad", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<Mesh>(
+        Mesh &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.id, "id", db);
+    ReadField<ErrorPolicy_Fail>(dest.totface, "totface", db);
+    ReadField<ErrorPolicy_Fail>(dest.totedge, "totedge", db);
+    ReadField<ErrorPolicy_Fail>(dest.totvert, "totvert", db);
+    ReadField<ErrorPolicy_Igno>(dest.totloop, "totloop", db);
+    ReadField<ErrorPolicy_Igno>(dest.totpoly, "totpoly", db);
+    ReadField<ErrorPolicy_Igno>(dest.subdiv, "subdiv", db);
+    ReadField<ErrorPolicy_Igno>(dest.subdivr, "subdivr", db);
+    ReadField<ErrorPolicy_Igno>(dest.subsurftype, "subsurftype", db);
+    ReadField<ErrorPolicy_Igno>(dest.smoothresh, "smoothresh", db);
+    ReadFieldPtr<ErrorPolicy_Fail>(dest.mface, "*mface", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.mtface, "*mtface", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.tface, "*tface", db);
+    ReadFieldPtr<ErrorPolicy_Fail>(dest.mvert, "*mvert", db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.medge, "*medge", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.mloop, "*mloop", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.mloopuv, "*mloopuv", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.mloopcol, "*mloopcol", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.mpoly, "*mpoly", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.mtpoly, "*mtpoly", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.dvert, "*dvert", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.mcol, "*mcol", db);
+    ReadFieldPtr<ErrorPolicy_Fail>(dest.mat, "**mat", db);
+
+    ReadField<ErrorPolicy_Igno>(dest.vdata, "vdata", db);
+    ReadField<ErrorPolicy_Igno>(dest.edata, "edata", db);
+    ReadField<ErrorPolicy_Igno>(dest.fdata, "fdata", db);
+    ReadField<ErrorPolicy_Igno>(dest.pdata, "pdata", db);
+    ReadField<ErrorPolicy_Warn>(dest.ldata, "ldata", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<MDeformVert>(
+        MDeformVert &dest,
+        const FileDatabase &db) const {
+
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.dw, "*dw", db);
+    ReadField<ErrorPolicy_Igno>(dest.totweight, "totweight", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<World>(
+        World &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.id, "id", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<MLoopCol>(
+        MLoopCol &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Igno>(dest.r, "r", db);
+    ReadField<ErrorPolicy_Igno>(dest.g, "g", db);
+    ReadField<ErrorPolicy_Igno>(dest.b, "b", db);
+    ReadField<ErrorPolicy_Igno>(dest.a, "a", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<MVert>(
+        MVert &dest,
+        const FileDatabase &db) const {
+
+    ReadFieldArray<ErrorPolicy_Fail>(dest.co, "co", db);
+    ReadFieldArray<ErrorPolicy_Fail>(dest.no, "no", db);
+    ReadField<ErrorPolicy_Igno>(dest.flag, "flag", db);
+    //ReadField<ErrorPolicy_Warn>(dest.mat_nr,"mat_nr",db);
+    ReadField<ErrorPolicy_Igno>(dest.bweight, "bweight", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<MEdge>(
+        MEdge &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.v1, "v1", db);
+    ReadField<ErrorPolicy_Fail>(dest.v2, "v2", db);
+    ReadField<ErrorPolicy_Igno>(dest.crease, "crease", db);
+    ReadField<ErrorPolicy_Igno>(dest.bweight, "bweight", db);
+    ReadField<ErrorPolicy_Igno>(dest.flag, "flag", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<MLoopUV>(
+        MLoopUV &dest,
+        const FileDatabase &db) const {
+
+    ReadFieldArray<ErrorPolicy_Igno>(dest.uv, "uv", db);
+    ReadField<ErrorPolicy_Igno>(dest.flag, "flag", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<GroupObject>(
+        GroupObject &dest,
+        const FileDatabase &db) const {
+
+    ReadFieldPtr<ErrorPolicy_Fail>(dest.prev, "*prev", db);
+    ReadFieldPtr<ErrorPolicy_Fail>(dest.next, "*next", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.ob, "*ob", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<ListBase>(
+        ListBase &dest,
+        const FileDatabase &db) const {
+
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.first, "*first", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.last, "*last", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<MLoop>(
+        MLoop &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Igno>(dest.v, "v", db);
+    ReadField<ErrorPolicy_Igno>(dest.e, "e", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<ModifierData>(
+        ModifierData &dest,
+        const FileDatabase &db) const {
+
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.next, "*next", db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.prev, "*prev", db);
+    ReadField<ErrorPolicy_Igno>(dest.type, "type", db);
+    ReadField<ErrorPolicy_Igno>(dest.mode, "mode", db);
+    ReadFieldArray<ErrorPolicy_Igno>(dest.name, "name", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<ID>(
+        ID &dest,
+        const FileDatabase &db) const {
+
+    ReadFieldArray<ErrorPolicy_Warn>(dest.name, "name", db);
+    ReadField<ErrorPolicy_Igno>(dest.flag, "flag", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<MCol>(
+        MCol &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.r, "r", db);
+    ReadField<ErrorPolicy_Fail>(dest.g, "g", db);
+    ReadField<ErrorPolicy_Fail>(dest.b, "b", db);
+    ReadField<ErrorPolicy_Fail>(dest.a, "a", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<MPoly>(
+        MPoly &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Igno>(dest.loopstart, "loopstart", db);
+    ReadField<ErrorPolicy_Igno>(dest.totloop, "totloop", db);
+    ReadField<ErrorPolicy_Igno>(dest.mat_nr, "mat_nr", db);
+    ReadField<ErrorPolicy_Igno>(dest.flag, "flag", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<Scene>(
+        Scene &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.id, "id", db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.camera, "*camera", db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.world, "*world", db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.basact, "*basact", db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.master_collection, "*master_collection", db);
+    ReadField<ErrorPolicy_Igno>(dest.base, "base", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<Library>(
+        Library &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.id, "id", db);
+    ReadFieldArray<ErrorPolicy_Warn>(dest.name, "name", db);
+    ReadFieldArray<ErrorPolicy_Fail>(dest.filename, "filename", db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.parent, "*parent", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<Tex>(
+        Tex &dest,
+        const FileDatabase &db) const {
+    short temp_short = 0;
+    ReadField<ErrorPolicy_Igno>(temp_short, "imaflag", db);
+    dest.imaflag = static_cast<Assimp::Blender::Tex::ImageFlags>(temp_short);
+    int temp = 0;
+    ReadField<ErrorPolicy_Fail>(temp, "type", db);
+    dest.type = static_cast<Assimp::Blender::Tex::Type>(temp);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.ima, "*ima", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<Camera>(
+        Camera &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.id, "id", db);
+    int temp = 0;
+    ReadField<ErrorPolicy_Warn>(temp, "type", db);
+    dest.type = static_cast<Assimp::Blender::Camera::Type>(temp);
+    ReadField<ErrorPolicy_Warn>(temp, "flag", db);
+    dest.flag = static_cast<Assimp::Blender::Camera::Type>(temp);
+    ReadField<ErrorPolicy_Warn>(dest.lens, "lens", db);
+    ReadField<ErrorPolicy_Warn>(dest.sensor_x, "sensor_x", db);
+    ReadField<ErrorPolicy_Igno>(dest.clipsta, "clipsta", db);
+    ReadField<ErrorPolicy_Igno>(dest.clipend, "clipend", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<MirrorModifierData>(
+        MirrorModifierData &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.modifier, "modifier", db);
+    ReadField<ErrorPolicy_Igno>(dest.axis, "axis", db);
+    ReadField<ErrorPolicy_Igno>(dest.flag, "flag", db);
+    ReadField<ErrorPolicy_Igno>(dest.tolerance, "tolerance", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.mirror_ob, "*mirror_ob", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<Image>(
+        Image &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.id, "id", db);
+    ReadFieldArray<ErrorPolicy_Warn>(dest.name, "name", db);
+    ReadField<ErrorPolicy_Igno>(dest.ok, "ok", db);
+    ReadField<ErrorPolicy_Igno>(dest.flag, "flag", db);
+    ReadField<ErrorPolicy_Igno>(dest.source, "source", db);
+    ReadField<ErrorPolicy_Igno>(dest.type, "type", db);
+    ReadField<ErrorPolicy_Igno>(dest.pad, "pad", db);
+    ReadField<ErrorPolicy_Igno>(dest.pad1, "pad1", db);
+    ReadField<ErrorPolicy_Igno>(dest.lastframe, "lastframe", db);
+    ReadField<ErrorPolicy_Igno>(dest.tpageflag, "tpageflag", db);
+    ReadField<ErrorPolicy_Igno>(dest.totbind, "totbind", db);
+    ReadField<ErrorPolicy_Igno>(dest.xrep, "xrep", db);
+    ReadField<ErrorPolicy_Igno>(dest.yrep, "yrep", db);
+    ReadField<ErrorPolicy_Igno>(dest.twsta, "twsta", db);
+    ReadField<ErrorPolicy_Igno>(dest.twend, "twend", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.packedfile, "*packedfile", db);
+    ReadField<ErrorPolicy_Igno>(dest.lastupdate, "lastupdate", db);
+    ReadField<ErrorPolicy_Igno>(dest.lastused, "lastused", db);
+    ReadField<ErrorPolicy_Igno>(dest.animspeed, "animspeed", db);
+    ReadField<ErrorPolicy_Igno>(dest.gen_x, "gen_x", db);
+    ReadField<ErrorPolicy_Igno>(dest.gen_y, "gen_y", db);
+    ReadField<ErrorPolicy_Igno>(dest.gen_type, "gen_type", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure::Convert<CustomData>(
+        CustomData &dest,
+        const FileDatabase &db) const {
+    ReadFieldArray<ErrorPolicy_Warn>(dest.typemap, "typemap", db);
+    ReadField<ErrorPolicy_Warn>(dest.totlayer, "totlayer", db);
+    ReadField<ErrorPolicy_Warn>(dest.maxlayer, "maxlayer", db);
+    ReadField<ErrorPolicy_Warn>(dest.totsize, "totsize", db);
+    ReadFieldPtrVector<ErrorPolicy_Warn>(dest.layers, "*layers", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure::Convert<CustomDataLayer>(
+        CustomDataLayer &dest,
+        const FileDatabase &db) const {
+    ReadField<ErrorPolicy_Fail>(dest.type, "type", db);
+    ReadField<ErrorPolicy_Fail>(dest.offset, "offset", db);
+    ReadField<ErrorPolicy_Fail>(dest.flag, "flag", db);
+    ReadField<ErrorPolicy_Fail>(dest.active, "active", db);
+    ReadField<ErrorPolicy_Fail>(dest.active_rnd, "active_rnd", db);
+    ReadField<ErrorPolicy_Fail>(dest.active_clone, "active_clone", db);
+    ReadField<ErrorPolicy_Fail>(dest.active_mask, "active_mask", db);
+    ReadField<ErrorPolicy_Fail>(dest.uid, "uid", db);
+    ReadFieldArray<ErrorPolicy_Warn>(dest.name, "name", db);
+    ReadCustomDataPtr<ErrorPolicy_Fail>(dest.data, dest.type, "*data", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+void DNA::RegisterConverters() {
+
+    converters["Object"] = DNA::FactoryPair(&Structure::Allocate<Object>, &Structure::Convert<Object>);
+    converters["Group"] = DNA::FactoryPair(&Structure::Allocate<Group>, &Structure::Convert<Group>);
+    converters["MTex"] = DNA::FactoryPair(&Structure::Allocate<MTex>, &Structure::Convert<MTex>);
+    converters["TFace"] = DNA::FactoryPair(&Structure::Allocate<TFace>, &Structure::Convert<TFace>);
+    converters["SubsurfModifierData"] = DNA::FactoryPair(&Structure::Allocate<SubsurfModifierData>, &Structure::Convert<SubsurfModifierData>);
+    converters["MFace"] = DNA::FactoryPair(&Structure::Allocate<MFace>, &Structure::Convert<MFace>);
+    converters["Lamp"] = DNA::FactoryPair(&Structure::Allocate<Lamp>, &Structure::Convert<Lamp>);
+    converters["MDeformWeight"] = DNA::FactoryPair(&Structure::Allocate<MDeformWeight>, &Structure::Convert<MDeformWeight>);
+    converters["PackedFile"] = DNA::FactoryPair(&Structure::Allocate<PackedFile>, &Structure::Convert<PackedFile>);
+    converters["Base"] = DNA::FactoryPair(&Structure::Allocate<Base>, &Structure::Convert<Base>);
+    converters["MTFace"] = DNA::FactoryPair(&Structure::Allocate<MTFace>, &Structure::Convert<MTFace>);
+    converters["Material"] = DNA::FactoryPair(&Structure::Allocate<Material>, &Structure::Convert<Material>);
+    converters["MTexPoly"] = DNA::FactoryPair(&Structure::Allocate<MTexPoly>, &Structure::Convert<MTexPoly>);
+    converters["Mesh"] = DNA::FactoryPair(&Structure::Allocate<Mesh>, &Structure::Convert<Mesh>);
+    converters["MDeformVert"] = DNA::FactoryPair(&Structure::Allocate<MDeformVert>, &Structure::Convert<MDeformVert>);
+    converters["World"] = DNA::FactoryPair(&Structure::Allocate<World>, &Structure::Convert<World>);
+    converters["MLoopCol"] = DNA::FactoryPair(&Structure::Allocate<MLoopCol>, &Structure::Convert<MLoopCol>);
+    converters["MVert"] = DNA::FactoryPair(&Structure::Allocate<MVert>, &Structure::Convert<MVert>);
+    converters["MEdge"] = DNA::FactoryPair(&Structure::Allocate<MEdge>, &Structure::Convert<MEdge>);
+    converters["MLoopUV"] = DNA::FactoryPair(&Structure::Allocate<MLoopUV>, &Structure::Convert<MLoopUV>);
+    converters["GroupObject"] = DNA::FactoryPair(&Structure::Allocate<GroupObject>, &Structure::Convert<GroupObject>);
+    converters["ListBase"] = DNA::FactoryPair(&Structure::Allocate<ListBase>, &Structure::Convert<ListBase>);
+    converters["MLoop"] = DNA::FactoryPair(&Structure::Allocate<MLoop>, &Structure::Convert<MLoop>);
+    converters["ModifierData"] = DNA::FactoryPair(&Structure::Allocate<ModifierData>, &Structure::Convert<ModifierData>);
+    converters["ID"] = DNA::FactoryPair(&Structure::Allocate<ID>, &Structure::Convert<ID>);
+    converters["MCol"] = DNA::FactoryPair(&Structure::Allocate<MCol>, &Structure::Convert<MCol>);
+    converters["MPoly"] = DNA::FactoryPair(&Structure::Allocate<MPoly>, &Structure::Convert<MPoly>);
+    converters["Scene"] = DNA::FactoryPair(&Structure::Allocate<Scene>, &Structure::Convert<Scene>);
+    converters["Library"] = DNA::FactoryPair(&Structure::Allocate<Library>, &Structure::Convert<Library>);
+    converters["Tex"] = DNA::FactoryPair(&Structure::Allocate<Tex>, &Structure::Convert<Tex>);
+    converters["Camera"] = DNA::FactoryPair(&Structure::Allocate<Camera>, &Structure::Convert<Camera>);
+    converters["MirrorModifierData"] = DNA::FactoryPair(&Structure::Allocate<MirrorModifierData>, &Structure::Convert<MirrorModifierData>);
+    converters["Image"] = DNA::FactoryPair(&Structure::Allocate<Image>, &Structure::Convert<Image>);
+    converters["CustomData"] = DNA::FactoryPair(&Structure::Allocate<CustomData>, &Structure::Convert<CustomData>);
+    converters["CustomDataLayer"] = DNA::FactoryPair(&Structure::Allocate<CustomDataLayer>, &Structure::Convert<CustomDataLayer>);
+    converters["Collection"] = DNA::FactoryPair(&Structure::Allocate<Collection>, &Structure::Convert<Collection>);
+    converters["CollectionChild"] = DNA::FactoryPair(&Structure::Allocate<CollectionChild>, &Structure::Convert<CollectionChild>);
+    converters["CollectionObject"] = DNA::FactoryPair(&Structure::Allocate<CollectionObject>, &Structure::Convert<CollectionObject>);
+}
+
+} // namespace Blender
+} //namespace Assimp
+
+#endif // ASSIMP_BUILD_NO_BLEND_IMPORTER
diff --git a/Engine/lib/assimp/code/Blender/BlenderScene.h b/Engine/lib/assimp/code/AssetLib/Blender/BlenderScene.h
similarity index 66%
rename from Engine/lib/assimp/code/Blender/BlenderScene.h
rename to Engine/lib/assimp/code/AssetLib/Blender/BlenderScene.h
index dd3f1444c..c153d3c22 100644
--- a/Engine/lib/assimp/code/Blender/BlenderScene.h
+++ b/Engine/lib/assimp/code/AssetLib/Blender/BlenderScene.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -48,14 +48,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "BlenderDNA.h"
 
-namespace Assimp    {
+namespace Assimp {
 namespace Blender {
 
 // Minor parts of this file are extracts from blender data structures,
 // declared in the ./source/blender/makesdna directory.
 // Stuff that is not used by Assimp is commented.
 
-
 // NOTE
 // this file serves as input data to the `./scripts/genblenddna.py`
 // script. This script generates the actual binding code to read a
@@ -95,19 +94,20 @@ namespace Blender {
 
 // warn if field is missing, substitute default value
 #ifdef WARN
-#  undef WARN
+#undef WARN
 #endif
-#define WARN 
+#define WARN
 
 // fail the import if the field does not exist
 #ifdef FAIL
-#  undef FAIL
+#undef FAIL
 #endif
-#define FAIL 
+#define FAIL
 
 struct Object;
 struct MTex;
 struct Image;
+struct Collection;
 
 #include <memory>
 
@@ -117,7 +117,7 @@ static const size_t MaxNameLen = 1024;
 
 // -------------------------------------------------------------------------------
 struct ID : ElemBase {
-    char name[ MaxNameLen ] WARN;
+    char name[MaxNameLen] WARN;
     short flag;
 };
 
@@ -127,17 +127,16 @@ struct ListBase : ElemBase {
     std::shared_ptr<ElemBase> last;
 };
 
-
 // -------------------------------------------------------------------------------
 struct PackedFile : ElemBase {
-     int size WARN;
-     int seek WARN;
-     std::shared_ptr< FileOffset > data WARN;
+    int size WARN;
+    int seek WARN;
+    std::shared_ptr<FileOffset> data WARN;
 };
 
 // -------------------------------------------------------------------------------
 struct GroupObject : ElemBase {
-    std::shared_ptr<GroupObject> prev,next FAIL;
+    std::shared_ptr<GroupObject> prev, next FAIL;
     std::shared_ptr<Object> ob;
 };
 
@@ -149,6 +148,26 @@ struct Group : ElemBase {
     std::shared_ptr<GroupObject> gobject;
 };
 
+// -------------------------------------------------------------------------------
+struct CollectionObject : ElemBase {
+    //CollectionObject* prev;
+    std::shared_ptr<CollectionObject> next;
+    Object *ob;
+};
+
+// -------------------------------------------------------------------------------
+struct CollectionChild : ElemBase {
+    std::shared_ptr<CollectionChild> next, prev;
+    std::shared_ptr<Collection> collection;
+};
+
+// -------------------------------------------------------------------------------
+struct Collection : ElemBase {
+    ID id FAIL;
+    ListBase gobject; // CollectionObject
+    ListBase children; // CollectionChild
+};
+
 // -------------------------------------------------------------------------------
 struct World : ElemBase {
     ID id FAIL;
@@ -157,23 +176,20 @@ struct World : ElemBase {
 // -------------------------------------------------------------------------------
 struct MVert : ElemBase {
     float co[3] FAIL;
-    float no[3] FAIL;       // readed as short and divided through / 32767.f
+    float no[3] FAIL; // read as short and divided through / 32767.f
     char flag;
     int mat_nr WARN;
     int bweight;
 
-    MVert() : ElemBase()
-        , flag(0)
-        , mat_nr(0)
-        , bweight(0)
-    {}
+    MVert() :
+            ElemBase(), flag(0), mat_nr(0), bweight(0) {}
 };
 
 // -------------------------------------------------------------------------------
 struct MEdge : ElemBase {
-      int v1, v2 FAIL;
-      char crease, bweight;
-      short flag;
+    int v1, v2 FAIL;
+    char crease, bweight;
+    short flag;
 };
 
 // -------------------------------------------------------------------------------
@@ -190,7 +206,7 @@ struct MLoopUV : ElemBase {
 // -------------------------------------------------------------------------------
 // Note that red and blue are not swapped, as with MCol
 struct MLoopCol : ElemBase {
-	unsigned char r, g, b, a;
+    unsigned char r, g, b, a;
 };
 
 // -------------------------------------------------------------------------------
@@ -203,19 +219,19 @@ struct MPoly : ElemBase {
 
 // -------------------------------------------------------------------------------
 struct MTexPoly : ElemBase {
-    Image* tpage;
+    Image *tpage;
     char flag, transp;
     short mode, tile, pad;
 };
 
 // -------------------------------------------------------------------------------
 struct MCol : ElemBase {
-    char r,g,b,a FAIL;
+    char r, g, b, a FAIL;
 };
 
 // -------------------------------------------------------------------------------
 struct MFace : ElemBase {
-    int v1,v2,v3,v4 FAIL;
+    int v1, v2, v3, v4 FAIL;
     int mat_nr FAIL;
     char flag;
 };
@@ -232,13 +248,12 @@ struct TFace : ElemBase {
 
 // -------------------------------------------------------------------------------
 struct MTFace : ElemBase {
-	MTFace()
-	: flag(0)
-	, mode(0)
-	, tile(0)
-	, unwrap(0)
-	{
-	}
+    MTFace() :
+            flag(0),
+            mode(0),
+            tile(0),
+            unwrap(0) {
+    }
 
     float uv[4][2] FAIL;
     char flag;
@@ -250,31 +265,31 @@ struct MTFace : ElemBase {
 };
 
 // -------------------------------------------------------------------------------
-struct MDeformWeight : ElemBase  {
-      int    def_nr FAIL;
-      float  weight FAIL;
+struct MDeformWeight : ElemBase {
+    int def_nr FAIL;
+    float weight FAIL;
 };
 
 // -------------------------------------------------------------------------------
-struct MDeformVert : ElemBase  {
+struct MDeformVert : ElemBase {
     vector<MDeformWeight> dw WARN;
     int totweight;
 };
 
 // -------------------------------------------------------------------------------
-#define MA_RAYMIRROR    0x40000
+#define MA_RAYMIRROR 0x40000
 #define MA_TRANSPARENCY 0x10000
-#define MA_RAYTRANSP    0x20000
-#define MA_ZTRANSP      0x00040
+#define MA_RAYTRANSP 0x20000
+#define MA_ZTRANSP 0x00040
 
 struct Material : ElemBase {
     ID id FAIL;
 
-    float r,g,b WARN;
-    float specr,specg,specb WARN;
+    float r, g, b WARN;
+    float specr, specg, specb WARN;
     short har;
-    float ambr,ambg,ambb WARN;
-    float mirr,mirg,mirb;
+    float ambr, ambg, ambb WARN;
+    float mirr, mirg, mirb;
     float emit WARN;
     float ray_mirror;
     float alpha WARN;
@@ -399,20 +414,19 @@ struct CustomDataLayer : ElemBase {
     int active_mask;
     int uid;
     char name[64];
-    std::shared_ptr<ElemBase> data;     // must be converted to real type according type member
+    std::shared_ptr<ElemBase> data; // must be converted to real type according type member
 
-    CustomDataLayer()
-        : ElemBase()
-        , type(0)
-        , offset(0)
-        , flag(0)
-        , active(0)
-        , active_rnd(0)
-        , active_clone(0)
-        , active_mask(0)
-        , uid(0)
-        , data(nullptr)
-    {
+    CustomDataLayer() :
+            ElemBase(),
+            type(0),
+            offset(0),
+            flag(0),
+            active(0),
+            active_rnd(0),
+            active_clone(0),
+            active_mask(0),
+            uid(0),
+            data(nullptr) {
         memset(name, 0, sizeof name);
     }
 };
@@ -430,8 +444,8 @@ CustomData 208
     CustomDataExternal *external 200 8
 */
 struct CustomData : ElemBase {
-    vector<std::shared_ptr<struct CustomDataLayer> > layers;
-    int typemap[42];    // CD_NUMTYPES
+    vector<std::shared_ptr<struct CustomDataLayer>> layers;
+    int typemap[42]; // CD_NUMTYPES
     int totlayer;
     int maxlayer;
     int totsize;
@@ -469,7 +483,7 @@ struct Mesh : ElemBase {
     vector<MDeformVert> dvert;
     vector<MCol> mcol;
 
-    vector< std::shared_ptr<Material> > mat FAIL;
+    vector<std::shared_ptr<Material>> mat FAIL;
 
     struct CustomData vdata;
     struct CustomData edata;
@@ -490,142 +504,141 @@ struct Library : ElemBase {
 // -------------------------------------------------------------------------------
 struct Camera : ElemBase {
     enum Type {
-          Type_PERSP    =   0
-         ,Type_ORTHO    =   1
+        Type_PERSP = 0,
+        Type_ORTHO = 1
     };
 
     ID id FAIL;
 
-    Type type,flag WARN;
+    Type type, flag WARN;
     float lens WARN;
     float sensor_x WARN;
     float clipsta, clipend;
 };
 
-
 // -------------------------------------------------------------------------------
 struct Lamp : ElemBase {
 
     enum FalloffType {
-         FalloffType_Constant   = 0x0
-        ,FalloffType_InvLinear  = 0x1
-        ,FalloffType_InvSquare  = 0x2
+        FalloffType_Constant = 0x0,
+        FalloffType_InvLinear = 0x1,
+        FalloffType_InvSquare = 0x2
         //,FalloffType_Curve    = 0x3
         //,FalloffType_Sliders  = 0x4
     };
 
     enum Type {
-         Type_Local         = 0x0
-        ,Type_Sun           = 0x1
-        ,Type_Spot          = 0x2
-        ,Type_Hemi          = 0x3
-        ,Type_Area          = 0x4
+        Type_Local = 0x0,
+        Type_Sun = 0x1,
+        Type_Spot = 0x2,
+        Type_Hemi = 0x3,
+        Type_Area = 0x4
         //,Type_YFPhoton    = 0x5
     };
 
-      ID id FAIL;
-      //AnimData *adt;
+    ID id FAIL;
+    //AnimData *adt;
 
-      Type type FAIL;
-      short flags;
+    Type type FAIL;
+    short flags;
 
-      //int mode;
+    //int mode;
 
-      short colormodel, totex;
-      float r,g,b,k WARN;
-      //float shdwr, shdwg, shdwb;
+    short colormodel, totex;
+    float r, g, b, k WARN;
+    //float shdwr, shdwg, shdwb;
 
-      float energy, dist, spotsize, spotblend;
-      //float haint;
+    float energy, dist, spotsize, spotblend;
+    //float haint;
 
-      float constant_coefficient;
-      float linear_coefficient;
-      float quadratic_coefficient;
+    float constant_coefficient;
+    float linear_coefficient;
+    float quadratic_coefficient;
 
-      float att1, att2;
-      //struct CurveMapping *curfalloff;
-      FalloffType falloff_type;
+    float att1, att2;
+    //struct CurveMapping *curfalloff;
+    FalloffType falloff_type;
 
-      //float clipsta, clipend, shadspotsize;
-      //float bias, soft, compressthresh;
-      //short bufsize, samp, buffers, filtertype;
-      //char bufflag, buftype;
+    //float clipsta, clipend, shadspotsize;
+    //float bias, soft, compressthresh;
+    //short bufsize, samp, buffers, filtertype;
+    //char bufflag, buftype;
 
-      //short ray_samp, ray_sampy, ray_sampz;
-      //short ray_samp_type;
-      short area_shape;
-      float area_size, area_sizey, area_sizez;
-      //float adapt_thresh;
-      //short ray_samp_method;
+    //short ray_samp, ray_sampy, ray_sampz;
+    //short ray_samp_type;
+    short area_shape;
+    float area_size, area_sizey, area_sizez;
+    //float adapt_thresh;
+    //short ray_samp_method;
 
-      //short texact, shadhalostep;
+    //short texact, shadhalostep;
 
-      //short sun_effect_type;
-      //short skyblendtype;
-      //float horizon_brightness;
-      //float spread;
-      float sun_brightness;
-      //float sun_size;
-      //float backscattered_light;
-      //float sun_intensity;
-      //float atm_turbidity;
-      //float atm_inscattering_factor;
-      //float atm_extinction_factor;
-      //float atm_distance_factor;
-      //float skyblendfac;
-      //float sky_exposure;
-      //short sky_colorspace;
+    //short sun_effect_type;
+    //short skyblendtype;
+    //float horizon_brightness;
+    //float spread;
+    float sun_brightness;
+    //float sun_size;
+    //float backscattered_light;
+    //float sun_intensity;
+    //float atm_turbidity;
+    //float atm_inscattering_factor;
+    //float atm_extinction_factor;
+    //float atm_distance_factor;
+    //float skyblendfac;
+    //float sky_exposure;
+    //short sky_colorspace;
 
-      // int YF_numphotons, YF_numsearch;
-      // short YF_phdepth, YF_useqmc, YF_bufsize, YF_pad;
-      // float YF_causticblur, YF_ltradius;
+    // int YF_numphotons, YF_numsearch;
+    // short YF_phdepth, YF_useqmc, YF_bufsize, YF_pad;
+    // float YF_causticblur, YF_ltradius;
 
-      // float YF_glowint, YF_glowofs;
-      // short YF_glowtype, YF_pad2;
+    // float YF_glowint, YF_glowofs;
+    // short YF_glowtype, YF_pad2;
 
-      //struct Ipo *ipo;
-      //struct MTex *mtex[18];
-      // short pr_texture;
+    //struct Ipo *ipo;
+    //struct MTex *mtex[18];
+    // short pr_texture;
 
-      //struct PreviewImage *preview;
+    //struct PreviewImage *preview;
 };
 
 // -------------------------------------------------------------------------------
-struct ModifierData : ElemBase  {
+struct ModifierData : ElemBase {
     enum ModifierType {
-      eModifierType_None = 0,
-      eModifierType_Subsurf,
-      eModifierType_Lattice,
-      eModifierType_Curve,
-      eModifierType_Build,
-      eModifierType_Mirror,
-      eModifierType_Decimate,
-      eModifierType_Wave,
-      eModifierType_Armature,
-      eModifierType_Hook,
-      eModifierType_Softbody,
-      eModifierType_Boolean,
-      eModifierType_Array,
-      eModifierType_EdgeSplit,
-      eModifierType_Displace,
-      eModifierType_UVProject,
-      eModifierType_Smooth,
-      eModifierType_Cast,
-      eModifierType_MeshDeform,
-      eModifierType_ParticleSystem,
-      eModifierType_ParticleInstance,
-      eModifierType_Explode,
-      eModifierType_Cloth,
-      eModifierType_Collision,
-      eModifierType_Bevel,
-      eModifierType_Shrinkwrap,
-      eModifierType_Fluidsim,
-      eModifierType_Mask,
-      eModifierType_SimpleDeform,
-      eModifierType_Multires,
-      eModifierType_Surface,
-      eModifierType_Smoke,
-      eModifierType_ShapeKey
+        eModifierType_None = 0,
+        eModifierType_Subsurf,
+        eModifierType_Lattice,
+        eModifierType_Curve,
+        eModifierType_Build,
+        eModifierType_Mirror,
+        eModifierType_Decimate,
+        eModifierType_Wave,
+        eModifierType_Armature,
+        eModifierType_Hook,
+        eModifierType_Softbody,
+        eModifierType_Boolean,
+        eModifierType_Array,
+        eModifierType_EdgeSplit,
+        eModifierType_Displace,
+        eModifierType_UVProject,
+        eModifierType_Smooth,
+        eModifierType_Cast,
+        eModifierType_MeshDeform,
+        eModifierType_ParticleSystem,
+        eModifierType_ParticleInstance,
+        eModifierType_Explode,
+        eModifierType_Cloth,
+        eModifierType_Collision,
+        eModifierType_Bevel,
+        eModifierType_Shrinkwrap,
+        eModifierType_Fluidsim,
+        eModifierType_Mask,
+        eModifierType_SimpleDeform,
+        eModifierType_Multires,
+        eModifierType_Surface,
+        eModifierType_Smoke,
+        eModifierType_ShapeKey
     };
 
     std::shared_ptr<ElemBase> next WARN;
@@ -636,7 +649,7 @@ struct ModifierData : ElemBase  {
 };
 
 // -------------------------------------------------------------------------------
-struct SubsurfModifierData : ElemBase  {
+struct SubsurfModifierData : ElemBase {
 
     enum Type {
 
@@ -646,13 +659,13 @@ struct SubsurfModifierData : ElemBase  {
 
     enum Flags {
         // some omitted
-        FLAGS_SubsurfUV     =1<<3
+        FLAGS_SubsurfUV = 1 << 3
     };
 
     ModifierData modifier FAIL;
     short subdivType WARN;
     short levels FAIL;
-    short renderLevels ;
+    short renderLevels;
     short flags;
 };
 
@@ -660,13 +673,13 @@ struct SubsurfModifierData : ElemBase  {
 struct MirrorModifierData : ElemBase {
 
     enum Flags {
-        Flags_CLIPPING      =1<<0,
-        Flags_MIRROR_U      =1<<1,
-        Flags_MIRROR_V      =1<<2,
-        Flags_AXIS_X        =1<<3,
-        Flags_AXIS_Y        =1<<4,
-        Flags_AXIS_Z        =1<<5,
-        Flags_VGROUP        =1<<6
+        Flags_CLIPPING = 1 << 0,
+        Flags_MIRROR_U = 1 << 1,
+        Flags_MIRROR_V = 1 << 2,
+        Flags_AXIS_X = 1 << 3,
+        Flags_AXIS_Y = 1 << 4,
+        Flags_AXIS_Z = 1 << 5,
+        Flags_VGROUP = 1 << 6
     };
 
     ModifierData modifier FAIL;
@@ -677,22 +690,24 @@ struct MirrorModifierData : ElemBase {
 };
 
 // -------------------------------------------------------------------------------
-struct Object : ElemBase  {
+struct Object : ElemBase {
     ID id FAIL;
 
     enum Type {
-         Type_EMPTY     =   0
-        ,Type_MESH      =   1
-        ,Type_CURVE     =   2
-        ,Type_SURF      =   3
-        ,Type_FONT      =   4
-        ,Type_MBALL     =   5
+        Type_EMPTY = 0,
+        Type_MESH = 1,
+        Type_CURVE = 2,
+        Type_SURF = 3,
+        Type_FONT = 4,
+        Type_MBALL = 5
 
-        ,Type_LAMP      =   10
-        ,Type_CAMERA    =   11
+        ,
+        Type_LAMP = 10,
+        Type_CAMERA = 11
 
-        ,Type_WAVE      =   21
-        ,Type_LATTICE   =   22
+        ,
+        Type_WAVE = 21,
+        Type_LATTICE = 22
     };
 
     Type type FAIL;
@@ -700,39 +715,29 @@ struct Object : ElemBase  {
     float parentinv[4][4] WARN;
     char parsubstr[32] WARN;
 
-    Object* parent WARN;
+    Object *parent WARN;
     std::shared_ptr<Object> track WARN;
 
-    std::shared_ptr<Object> proxy,proxy_from,proxy_group WARN;
+    std::shared_ptr<Object> proxy, proxy_from, proxy_group WARN;
     std::shared_ptr<Group> dup_group WARN;
     std::shared_ptr<ElemBase> data FAIL;
 
     ListBase modifiers;
 
-    Object()
-    : ElemBase()
-    , type( Type_EMPTY )
-    , parent( nullptr )
-    , track()
-    , proxy()
-    , proxy_from()
-    , data() {
+    Object() :
+            ElemBase(), type(Type_EMPTY), parent(nullptr), track(), proxy(), proxy_from(), data() {
         // empty
     }
 };
 
-
 // -------------------------------------------------------------------------------
 struct Base : ElemBase {
-    Base* prev WARN;
+    Base *prev WARN;
     std::shared_ptr<Base> next WARN;
     std::shared_ptr<Object> object WARN;
 
-    Base() 
-    : ElemBase()
-    , prev( nullptr )
-    , next()
-    , object() {
+    Base() :
+            ElemBase(), prev(nullptr), next(), object() {
         // empty
         // empty
     }
@@ -745,14 +750,12 @@ struct Scene : ElemBase {
     std::shared_ptr<Object> camera WARN;
     std::shared_ptr<World> world WARN;
     std::shared_ptr<Base> basact WARN;
+    std::shared_ptr<Collection> master_collection WARN;
 
     ListBase base;
 
-    Scene()
-    : ElemBase()
-    , camera()
-    , world()
-    , basact() {
+    Scene() :
+            ElemBase(), camera(), world(), basact(), master_collection() {
         // empty
     }
 };
@@ -783,9 +786,9 @@ struct Image : ElemBase {
     short animspeed;
 
     short gen_x, gen_y, gen_type;
-    
-    Image()
-    : ElemBase() {
+
+    Image() :
+            ElemBase() {
         // empty
     }
 };
@@ -795,33 +798,33 @@ struct Tex : ElemBase {
 
     // actually, the only texture type we support is Type_IMAGE
     enum Type {
-         Type_CLOUDS        = 1
-        ,Type_WOOD          = 2
-        ,Type_MARBLE        = 3
-        ,Type_MAGIC         = 4
-        ,Type_BLEND         = 5
-        ,Type_STUCCI        = 6
-        ,Type_NOISE         = 7
-        ,Type_IMAGE         = 8
-        ,Type_PLUGIN        = 9
-        ,Type_ENVMAP        = 10
-        ,Type_MUSGRAVE      = 11
-        ,Type_VORONOI       = 12
-        ,Type_DISTNOISE     = 13
-        ,Type_POINTDENSITY  = 14
-        ,Type_VOXELDATA     = 15
+        Type_CLOUDS = 1,
+        Type_WOOD = 2,
+        Type_MARBLE = 3,
+        Type_MAGIC = 4,
+        Type_BLEND = 5,
+        Type_STUCCI = 6,
+        Type_NOISE = 7,
+        Type_IMAGE = 8,
+        Type_PLUGIN = 9,
+        Type_ENVMAP = 10,
+        Type_MUSGRAVE = 11,
+        Type_VORONOI = 12,
+        Type_DISTNOISE = 13,
+        Type_POINTDENSITY = 14,
+        Type_VOXELDATA = 15
     };
 
     enum ImageFlags {
-         ImageFlags_INTERPOL         = 1
-        ,ImageFlags_USEALPHA         = 2
-        ,ImageFlags_MIPMAP           = 4
-        ,ImageFlags_IMAROT           = 16
-        ,ImageFlags_CALCALPHA        = 32
-        ,ImageFlags_NORMALMAP        = 2048
-        ,ImageFlags_GAUSS_MIP        = 4096
-        ,ImageFlags_FILTER_MIN       = 8192
-        ,ImageFlags_DERIVATIVEMAP   = 16384
+        ImageFlags_INTERPOL = 1,
+        ImageFlags_USEALPHA = 2,
+        ImageFlags_MIPMAP = 4,
+        ImageFlags_IMAROT = 16,
+        ImageFlags_CALCALPHA = 32,
+        ImageFlags_NORMALMAP = 2048,
+        ImageFlags_GAUSS_MIP = 4096,
+        ImageFlags_FILTER_MIN = 8192,
+        ImageFlags_DERIVATIVEMAP = 16384
     };
 
     ID id FAIL;
@@ -876,11 +879,8 @@ struct Tex : ElemBase {
 
     //char use_nodes;
 
-    Tex()
-    : ElemBase()
-    , imaflag( ImageFlags_INTERPOL )
-    , type( Type_CLOUDS )
-    , ima() {
+    Tex() :
+            ElemBase(), imaflag(ImageFlags_INTERPOL), type(Type_CLOUDS), ima() {
         // empty
     }
 };
@@ -889,52 +889,52 @@ struct Tex : ElemBase {
 struct MTex : ElemBase {
 
     enum Projection {
-         Proj_N = 0
-        ,Proj_X = 1
-        ,Proj_Y = 2
-        ,Proj_Z = 3
+        Proj_N = 0,
+        Proj_X = 1,
+        Proj_Y = 2,
+        Proj_Z = 3
     };
 
     enum Flag {
-         Flag_RGBTOINT      = 0x1
-        ,Flag_STENCIL       = 0x2
-        ,Flag_NEGATIVE      = 0x4
-        ,Flag_ALPHAMIX      = 0x8
-        ,Flag_VIEWSPACE     = 0x10
+        Flag_RGBTOINT = 0x1,
+        Flag_STENCIL = 0x2,
+        Flag_NEGATIVE = 0x4,
+        Flag_ALPHAMIX = 0x8,
+        Flag_VIEWSPACE = 0x10
     };
 
     enum BlendType {
-         BlendType_BLEND            = 0
-        ,BlendType_MUL              = 1
-        ,BlendType_ADD              = 2
-        ,BlendType_SUB              = 3
-        ,BlendType_DIV              = 4
-        ,BlendType_DARK             = 5
-        ,BlendType_DIFF             = 6
-        ,BlendType_LIGHT            = 7
-        ,BlendType_SCREEN           = 8
-        ,BlendType_OVERLAY          = 9
-        ,BlendType_BLEND_HUE        = 10
-        ,BlendType_BLEND_SAT        = 11
-        ,BlendType_BLEND_VAL        = 12
-        ,BlendType_BLEND_COLOR      = 13
+        BlendType_BLEND = 0,
+        BlendType_MUL = 1,
+        BlendType_ADD = 2,
+        BlendType_SUB = 3,
+        BlendType_DIV = 4,
+        BlendType_DARK = 5,
+        BlendType_DIFF = 6,
+        BlendType_LIGHT = 7,
+        BlendType_SCREEN = 8,
+        BlendType_OVERLAY = 9,
+        BlendType_BLEND_HUE = 10,
+        BlendType_BLEND_SAT = 11,
+        BlendType_BLEND_VAL = 12,
+        BlendType_BLEND_COLOR = 13
     };
 
     enum MapType {
-         MapType_COL         = 1
-        ,MapType_NORM        = 2
-        ,MapType_COLSPEC     = 4
-        ,MapType_COLMIR      = 8
-        ,MapType_REF         = 16
-        ,MapType_SPEC        = 32
-        ,MapType_EMIT        = 64
-        ,MapType_ALPHA       = 128
-        ,MapType_HAR         = 256
-        ,MapType_RAYMIRR     = 512
-        ,MapType_TRANSLU     = 1024
-        ,MapType_AMB         = 2048
-        ,MapType_DISPLACE    = 4096
-        ,MapType_WARP        = 8192
+        MapType_COL = 1,
+        MapType_NORM = 2,
+        MapType_COLSPEC = 4,
+        MapType_COLMIR = 8,
+        MapType_REF = 16,
+        MapType_SPEC = 32,
+        MapType_EMIT = 64,
+        MapType_ALPHA = 128,
+        MapType_HAR = 256,
+        MapType_RAYMIRR = 512,
+        MapType_TRANSLU = 1024,
+        MapType_AMB = 2048,
+        MapType_DISPLACE = 4096,
+        MapType_WARP = 8192
     };
 
     // short texco, maptoneg;
@@ -945,7 +945,7 @@ struct MTex : ElemBase {
     std::shared_ptr<Tex> tex;
     char uvname[32];
 
-    Projection projx,projy,projz;
+    Projection projx, projy, projz;
     char mapping;
     float ofs[3], size[3], rot;
 
@@ -953,7 +953,7 @@ struct MTex : ElemBase {
     short colormodel, pmapto, pmaptoneg;
     //short normapspace, which_output;
     //char brush_map_mode;
-    float r,g,b,k WARN;
+    float r, g, b, k WARN;
     //float def_var, rt;
 
     //float colfac, varfac;
@@ -972,12 +972,12 @@ struct MTex : ElemBase {
     //float shadowfac;
     //float zenupfac, zendownfac, blendfac;
 
-    MTex()
-    : ElemBase() {
+    MTex() :
+            ElemBase() {
         // empty
     }
 };
 
-}
-}
+} // namespace Blender
+} // namespace Assimp
 #endif
diff --git a/Engine/lib/assimp/code/Blender/BlenderSceneGen.h b/Engine/lib/assimp/code/AssetLib/Blender/BlenderSceneGen.h
similarity index 97%
rename from Engine/lib/assimp/code/Blender/BlenderSceneGen.h
rename to Engine/lib/assimp/code/AssetLib/Blender/BlenderSceneGen.h
index ce94d0dc2..762fdd33b 100644
--- a/Engine/lib/assimp/code/Blender/BlenderSceneGen.h
+++ b/Engine/lib/assimp/code/AssetLib/Blender/BlenderSceneGen.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (ASSIMP)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2016, ASSIMP Development Team
+Copyright (c) 2006-2020, ASSIMP Development Team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -62,6 +62,12 @@ template <> void Structure :: Convert<Group> (
     ) const
 ;
 
+template <> void Structure::Convert<Collection>(
+    Collection& dest,
+    const FileDatabase& db
+    ) const
+;
+
 template <> void Structure :: Convert<MTex> (
     MTex& dest,
     const FileDatabase& db
diff --git a/Engine/lib/assimp/code/Blender/BlenderTessellator.cpp b/Engine/lib/assimp/code/AssetLib/Blender/BlenderTessellator.cpp
similarity index 98%
rename from Engine/lib/assimp/code/Blender/BlenderTessellator.cpp
rename to Engine/lib/assimp/code/AssetLib/Blender/BlenderTessellator.cpp
index d98c2e865..d3d463ece 100644
--- a/Engine/lib/assimp/code/Blender/BlenderTessellator.cpp
+++ b/Engine/lib/assimp/code/AssetLib/Blender/BlenderTessellator.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -386,7 +386,14 @@ void BlenderTessellatorP2T::ReferencePoints( std::vector< Blender::PointP2T >& p
 // ------------------------------------------------------------------------------------------------
 inline PointP2T& BlenderTessellatorP2T::GetActualPointStructure( p2t::Point& point ) const
 {
+#if defined __clang__
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Winvalid-offsetof"
+#endif // __clang__
     unsigned int pointOffset = offsetof( PointP2T, point2D );
+#if defined __clang__
+#    pragma clang diagnostic pop
+#endif
     PointP2T& pointStruct = *reinterpret_cast< PointP2T* >( reinterpret_cast< char* >( &point ) - pointOffset );
     if ( pointStruct.magic != static_cast<int>( BLEND_TESS_MAGIC ) )
     {
@@ -394,7 +401,6 @@ inline PointP2T& BlenderTessellatorP2T::GetActualPointStructure( p2t::Point& poi
     }
     return pointStruct;
 }
-
 // ------------------------------------------------------------------------------------------------
 void BlenderTessellatorP2T::MakeFacesFromTriangles( std::vector< p2t::Triangle* >& triangles ) const
 {
diff --git a/Engine/lib/assimp/code/Blender/BlenderTessellator.h b/Engine/lib/assimp/code/AssetLib/Blender/BlenderTessellator.h
similarity index 99%
rename from Engine/lib/assimp/code/Blender/BlenderTessellator.h
rename to Engine/lib/assimp/code/AssetLib/Blender/BlenderTessellator.h
index 518e56c72..0d0ba320e 100644
--- a/Engine/lib/assimp/code/Blender/BlenderTessellator.h
+++ b/Engine/lib/assimp/code/AssetLib/Blender/BlenderTessellator.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/C4D/C4DImporter.cpp b/Engine/lib/assimp/code/AssetLib/C4D/C4DImporter.cpp
similarity index 92%
rename from Engine/lib/assimp/code/C4D/C4DImporter.cpp
rename to Engine/lib/assimp/code/AssetLib/C4D/C4DImporter.cpp
index 6e5b7d39b..06d7a3412 100644
--- a/Engine/lib/assimp/code/C4D/C4DImporter.cpp
+++ b/Engine/lib/assimp/code/AssetLib/C4D/C4DImporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2021, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -51,7 +51,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #endif
 
 #include "C4DImporter.h"
-#include <assimp/TinyFormatter.h>
 #include <memory>
 #include <assimp/IOSystem.hpp>
 #include <assimp/scene.h>
@@ -65,7 +64,19 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "c4d_file.h"
 #include "default_alien_overloads.h"
 
-using namespace melange;
+namespace {
+
+aiString aiStringFrom(cineware::String const & cinestring) {
+    aiString result;
+    cinestring.GetCString(result.data, MAXLEN-1);
+    result.length = static_cast<ai_uint32>(cinestring.GetLength());
+    return result;
+}
+
+}
+
+using namespace Assimp;
+using namespace cineware;
 
 // overload this function and fill in your own unique data
 void GetWriterInfo(int &id, String &appname) {
@@ -73,9 +84,6 @@ void GetWriterInfo(int &id, String &appname) {
     appname = "Open Asset Import Library";
 }
 
-using namespace Assimp;
-using namespace Assimp::Formatter;
-
 namespace Assimp {
     template<> const char* LogFunctions<C4DImporter>::Prefix() {
         static auto prefix = "C4D: ";
@@ -109,14 +117,14 @@ C4DImporter::~C4DImporter() {
 }
 
 // ------------------------------------------------------------------------------------------------
-bool C4DImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const {
+bool C4DImporter::CanRead( const std::string& pFile, IOSystem* /*pIOHandler*/, bool /*checkSig*/) const {
     const std::string& extension = GetExtension(pFile);
     if (extension == "c4d") {
         return true;
     } else if ((!extension.length() || checkSig) && pIOHandler)   {
         // TODO
     }
-
+    
     return false;
 }
 
@@ -125,11 +133,6 @@ const aiImporterDesc* C4DImporter::GetInfo () const {
     return &desc;
 }
 
-// ------------------------------------------------------------------------------------------------
-void C4DImporter::SetupProperties(const Importer* /*pImp*/) {
-    // nothing to be done for the moment
-}
-
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
@@ -154,8 +157,14 @@ void C4DImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
         ThrowException("failed to read document " + pFile);
     }
 
+    // Generate the root-node
     pScene->mRootNode = new aiNode("<C4DRoot>");
 
+    // convert left-handed to right-handed
+    pScene->mRootNode->mTransformation.a1 = 0.01f;
+    pScene->mRootNode->mTransformation.b2 = 0.01f;
+    pScene->mRootNode->mTransformation.c3 = -0.01f;
+
     // first convert all materials
     ReadMaterials(doc->GetFirstMaterial());
 
@@ -199,8 +208,8 @@ void C4DImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
 
 
 // ------------------------------------------------------------------------------------------------
-bool C4DImporter::ReadShader(aiMaterial* out, melange::BaseShader* shader) {
-    // based on Melange sample code (C4DImportExport.cpp)
+bool C4DImporter::ReadShader(aiMaterial* out, BaseShader* shader) {
+    // based on Cineware sample code (C4DImportExport.cpp)
     while(shader) {
         if(shader->GetType() == Xlayer) {
             BaseContainer* container = shader->GetDataInstance();
@@ -242,13 +251,11 @@ bool C4DImporter::ReadShader(aiMaterial* out, melange::BaseShader* shader) {
                 lsl = lsl->GetNext();
             }
         } else if ( shader->GetType() == Xbitmap ) {
-            aiString path;
-            shader->GetFileName().GetString().GetCString(path.data, MAXLEN-1);
-            path.length = ::strlen(path.data);
+            auto const path = aiStringFrom(shader->GetFileName().GetString());
             out->AddProperty(&path, AI_MATKEY_TEXTURE_DIFFUSE(0));
             return true;
         } else {
-            LogWarn("ignoring shader type: " + std::string(GetObjectTypeName(shader->GetType())));
+            LogWarn("ignoring shader type: ", GetObjectTypeName(shader->GetType()));
         }
         shader = shader->GetNext();
     }
@@ -257,18 +264,15 @@ bool C4DImporter::ReadShader(aiMaterial* out, melange::BaseShader* shader) {
 }
 
 // ------------------------------------------------------------------------------------------------
-void C4DImporter::ReadMaterials(melange::BaseMaterial* mat) {
-    // based on Melange sample code
+void C4DImporter::ReadMaterials(BaseMaterial* mat) {
+    // based on Cineware sample code
     while (mat) {
-        const String& name = mat->GetName();
         if (mat->GetType() == Mmaterial) {
             aiMaterial* out = new aiMaterial();
             material_mapping[mat] = static_cast<unsigned int>(materials.size());
             materials.push_back(out);
 
-            aiString ai_name;
-            name.GetCString(ai_name.data, MAXLEN-1);
-            ai_name.length = ::strlen(ai_name.data);
+            auto const ai_name = aiStringFrom(mat->GetName());
             out->AddProperty(&ai_name, AI_MATKEY_NAME);
 
             Material& m = dynamic_cast<Material&>(*mat);
@@ -294,7 +298,7 @@ void C4DImporter::ReadMaterials(melange::BaseMaterial* mat) {
                 ReadShader(out, shader);
             }
         } else {
-            LogWarn("ignoring plugin material: " + std::string(GetObjectTypeName(mat->GetType())));
+            LogWarn("ignoring plugin material: ", GetObjectTypeName(mat->GetType()));
         }
         mat = mat->GetNext();
     }
@@ -305,19 +309,15 @@ void C4DImporter::RecurseHierarchy(BaseObject* object, aiNode* parent) {
     ai_assert(parent != nullptr );
     std::vector<aiNode*> nodes;
 
-    // based on Melange sample code
+    // based on Cineware sample code
     while (object) {
-        const String& name = object->GetName();
         const LONG type = object->GetType();
         const Matrix& ml = object->GetMl();
 
-        aiString string;
-        name.GetCString(string.data, MAXLEN-1);
-        string.length = ::strlen(string.data);
         aiNode* const nd = new aiNode();
 
         nd->mParent = parent;
-        nd->mName = string;
+        nd->mName = aiStringFrom(object->GetName());
 
         nd->mTransformation.a1 = ml.v1.x;
         nd->mTransformation.b1 = ml.v1.y;
@@ -352,7 +352,7 @@ void C4DImporter::RecurseHierarchy(BaseObject* object, aiNode* parent) {
                 meshes.push_back(mesh);
             }
         } else {
-            LogWarn("ignoring object: " + std::string(GetObjectTypeName(type)));
+            LogWarn("ignoring object: ", GetObjectTypeName(type));
         }
 
         RecurseHierarchy(object->GetDown(), nd);
@@ -370,7 +370,7 @@ aiMesh* C4DImporter::ReadMesh(BaseObject* object) {
     ai_assert(object != nullptr);
     ai_assert( object->GetType() == Opolygon );
 
-    // based on Melange sample code
+    // based on Cineware sample code
     PolygonObject* const polyObject = dynamic_cast<PolygonObject*>(object);
     ai_assert(polyObject != nullptr);
 
@@ -618,4 +618,3 @@ unsigned int C4DImporter::ResolveMaterial(PolygonObject* obj) {
 }
 
 #endif // ASSIMP_BUILD_NO_C4D_IMPORTER
-
diff --git a/Engine/lib/assimp/code/C4D/C4DImporter.h b/Engine/lib/assimp/code/AssetLib/C4D/C4DImporter.h
similarity index 73%
rename from Engine/lib/assimp/code/C4D/C4DImporter.h
rename to Engine/lib/assimp/code/AssetLib/C4D/C4DImporter.h
index f3b1351f6..c44cf5e37 100644
--- a/Engine/lib/assimp/code/C4D/C4DImporter.h
+++ b/Engine/lib/assimp/code/AssetLib/C4D/C4DImporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2021, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -56,8 +56,8 @@ struct aiMaterial;
 
 struct aiImporterDesc;
 
-namespace melange {
-    class BaseObject; // c4d_file.h
+namespace cineware {
+    class BaseObject;
     class PolygonObject;
     class BaseMaterial;
     class BaseShader;
@@ -71,43 +71,34 @@ namespace Assimp  {
     }
 
 // -------------------------------------------------------------------------------------------
-/** Importer class to load Cinema4D files using the Melange library to be obtained from
- *  www.plugincafe.com
+/** Importer class to load Cinema4D files using the Cineware library to be obtained from
+ *  https://developers.maxon.net
  *
- *  Note that Melange is not free software. */
+ *  Note that Cineware is not free software. */
 // -------------------------------------------------------------------------------------------
 class C4DImporter : public BaseImporter, public LogFunctions<C4DImporter> {
 public:
-    C4DImporter();
-    ~C4DImporter();
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
+    bool CanRead( const std::string& pFile, IOSystem*, bool checkSig) const override;
 
 protected:
 
-    // --------------------
-    const aiImporterDesc* GetInfo () const;
+    const aiImporterDesc* GetInfo () const override;
 
-    // --------------------
-    void SetupProperties(const Importer* pImp);
-
-    // --------------------
-    void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
+    void InternReadFile( const std::string& pFile, aiScene*, IOSystem* ) override;
 
 private:
 
-    void ReadMaterials(melange::BaseMaterial* mat);
-    void RecurseHierarchy(melange::BaseObject* object, aiNode* parent);
-    aiMesh* ReadMesh(melange::BaseObject* object);
-    unsigned int ResolveMaterial(melange::PolygonObject* obj);
+    void ReadMaterials(cineware::BaseMaterial* mat);
+    void RecurseHierarchy(cineware::BaseObject* object, aiNode* parent);
+    aiMesh* ReadMesh(cineware::BaseObject* object);
+    unsigned int ResolveMaterial(cineware::PolygonObject* obj);
 
-    bool ReadShader(aiMaterial* out, melange::BaseShader* shader);
+    bool ReadShader(aiMaterial* out, cineware::BaseShader* shader);
 
     std::vector<aiMesh*> meshes;
     std::vector<aiMaterial*> materials;
 
-    typedef std::map<melange::BaseMaterial*, unsigned int> MaterialMap;
+    typedef std::map<cineware::BaseMaterial*, unsigned int> MaterialMap;
     MaterialMap material_mapping;
 
 }; // !class C4DImporter
diff --git a/Engine/lib/assimp/code/COB/COBLoader.cpp b/Engine/lib/assimp/code/AssetLib/COB/COBLoader.cpp
similarity index 51%
rename from Engine/lib/assimp/code/COB/COBLoader.cpp
rename to Engine/lib/assimp/code/AssetLib/COB/COBLoader.cpp
index 19e3cd59e..1c8310061 100644
--- a/Engine/lib/assimp/code/COB/COBLoader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/COB/COBLoader.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,21 +43,21 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Implementation of the TrueSpace COB/SCN importer class.
  */
 
-
 #ifndef ASSIMP_BUILD_NO_COB_IMPORTER
-#include "COB/COBLoader.h"
-#include "COB/COBScene.h"
+
+#include "AssetLib/COB/COBLoader.h"
+#include "AssetLib/COB/COBScene.h"
 #include "PostProcessing/ConvertToLHProcess.h"
 
-#include <assimp/StreamReader.h>
-#include <assimp/ParsingUtils.h>
-#include <assimp/fast_atof.h>
 #include <assimp/LineSplitter.h>
+#include <assimp/ParsingUtils.h>
+#include <assimp/StreamReader.h>
 #include <assimp/TinyFormatter.h>
-#include <assimp/IOSystem.hpp>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/scene.h>
+#include <assimp/fast_atof.h>
 #include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOSystem.hpp>
 
 #include <memory>
 
@@ -65,16 +65,15 @@ using namespace Assimp;
 using namespace Assimp::COB;
 using namespace Assimp::Formatter;
 
-
 static const float units[] = {
     1000.f,
     100.f,
     1.f,
     0.001f,
-    1.f/0.0254f,
-    1.f/0.3048f,
-    1.f/0.9144f,
-    1.f/1609.344f
+    1.f / 0.0254f,
+    1.f / 0.3048f,
+    1.f / 0.9144f,
+    1.f / 1609.344f
 };
 
 static const aiImporterDesc desc = {
@@ -90,238 +89,228 @@ static const aiImporterDesc desc = {
     "cob scn"
 };
 
-
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-COBImporter::COBImporter()
-{}
+COBImporter::COBImporter() {
+    // empty
+}
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-COBImporter::~COBImporter()
-{}
+COBImporter::~COBImporter() {
+    // empty
+}
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool COBImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
-{
-    const std::string& extension = GetExtension(pFile);
-    if (extension == "cob" || extension == "scn" || extension == "COB" || extension == "SCN") {
-        return true;
-    }
-
-    else if ((!extension.length() || checkSig) && pIOHandler)   {
-        const char* tokens[] = {"Caligary"};
-        return SearchFileHeaderForToken(pIOHandler,pFile,tokens,1);
-    }
-    return false;
+bool COBImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
+    static const char *tokens[] = { "Caligary" };
+    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------
 // Loader meta information
-const aiImporterDesc* COBImporter::GetInfo () const
-{
+const aiImporterDesc *COBImporter::GetInfo() const {
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup configuration properties for the loader
-void COBImporter::SetupProperties(const Importer* /*pImp*/)
-{
+void COBImporter::SetupProperties(const Importer * /*pImp*/) {
     // nothing to be done for the moment
 }
 
 // ------------------------------------------------------------------------------------------------
-/*static*/ AI_WONT_RETURN void COBImporter::ThrowException(const std::string& msg)
-{
-    throw DeadlyImportError("COB: "+msg);
+/*static*/ AI_WONT_RETURN void COBImporter::ThrowException(const std::string &msg) {
+    throw DeadlyImportError("COB: ", msg);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void COBImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) {
+void COBImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
     COB::Scene scene;
-    std::unique_ptr<StreamReaderLE> stream(new StreamReaderLE( pIOHandler->Open(pFile,"rb")) );
+
+    auto file = pIOHandler->Open(pFile, "rb");
+    if (!file) {
+        ThrowException("Could not open " + pFile);
+    }
+
+    std::unique_ptr<StreamReaderLE> stream(new StreamReaderLE(file));
 
     // check header
     char head[32];
-    stream->CopyAndAdvance(head,32);
-    if (strncmp(head,"Caligari ",9) != 0) {
+    stream->CopyAndAdvance(head, 32);
+    if (strncmp(head, "Caligari ", 9) != 0) {
         ThrowException("Could not found magic id: `Caligari`");
     }
 
-    ASSIMP_LOG_INFO_F("File format tag: ",std::string(head+9,6));
-    if (head[16]!='L') {
+    ASSIMP_LOG_INFO("File format tag: ", std::string(head + 9, 6));
+    if (head[16] != 'L') {
         ThrowException("File is big-endian, which is not supported");
     }
 
     // load data into intermediate structures
-    if (head[15]=='A') {
+    if (head[15] == 'A') {
         ReadAsciiFile(scene, stream.get());
-    }
-    else {
+    } else {
         ReadBinaryFile(scene, stream.get());
     }
-    if(scene.nodes.empty()) {
+    if (scene.nodes.empty()) {
         ThrowException("No nodes loaded");
     }
 
     // sort faces by material indices
-    for(std::shared_ptr< Node >& n : scene.nodes) {
+    for (std::shared_ptr<Node> &n : scene.nodes) {
         if (n->type == Node::TYPE_MESH) {
-            Mesh& mesh = (Mesh&)(*n.get());
-            for(Face& f : mesh.faces) {
+            Mesh &mesh = (Mesh &)(*n.get());
+            for (Face &f : mesh.faces) {
                 mesh.temp_map[f.material].push_back(&f);
             }
         }
     }
 
     // count meshes
-    for(std::shared_ptr< Node >& n : scene.nodes) {
+    for (std::shared_ptr<Node> &n : scene.nodes) {
         if (n->type == Node::TYPE_MESH) {
-            Mesh& mesh = (Mesh&)(*n.get());
+            Mesh &mesh = (Mesh &)(*n.get());
             if (mesh.vertex_positions.size() && mesh.texture_coords.size()) {
                 pScene->mNumMeshes += static_cast<unsigned int>(mesh.temp_map.size());
             }
         }
     }
-    pScene->mMeshes = new aiMesh*[pScene->mNumMeshes]();
-    pScene->mMaterials = new aiMaterial*[pScene->mNumMeshes]();
+    pScene->mMeshes = new aiMesh *[pScene->mNumMeshes]();
+    pScene->mMaterials = new aiMaterial *[pScene->mNumMeshes]();
     pScene->mNumMeshes = 0;
 
     // count lights and cameras
-    for(std::shared_ptr< Node >& n : scene.nodes) {
+    for (std::shared_ptr<Node> &n : scene.nodes) {
         if (n->type == Node::TYPE_LIGHT) {
             ++pScene->mNumLights;
-        }
-        else if (n->type == Node::TYPE_CAMERA) {
+        } else if (n->type == Node::TYPE_CAMERA) {
             ++pScene->mNumCameras;
         }
     }
 
     if (pScene->mNumLights) {
-        pScene->mLights  = new aiLight*[pScene->mNumLights]();
+        pScene->mLights = new aiLight *[pScene->mNumLights]();
     }
     if (pScene->mNumCameras) {
-        pScene->mCameras = new aiCamera*[pScene->mNumCameras]();
+        pScene->mCameras = new aiCamera *[pScene->mNumCameras]();
     }
     pScene->mNumLights = pScene->mNumCameras = 0;
 
     // resolve parents by their IDs and build the output graph
     std::unique_ptr<Node> root(new Group());
-    for(size_t n = 0; n < scene.nodes.size(); ++n) {
-        const Node& nn = *scene.nodes[n].get();
-        if(nn.parent_id==0) {
+    for (size_t n = 0; n < scene.nodes.size(); ++n) {
+        const Node &nn = *scene.nodes[n].get();
+        if (nn.parent_id == 0) {
             root->temp_children.push_back(&nn);
         }
 
-        for(size_t m = n; m < scene.nodes.size(); ++m) {
-            const Node& mm = *scene.nodes[m].get();
+        for (size_t m = n; m < scene.nodes.size(); ++m) {
+            const Node &mm = *scene.nodes[m].get();
             if (mm.parent_id == nn.id) {
                 nn.temp_children.push_back(&mm);
             }
         }
     }
 
-    pScene->mRootNode = BuildNodes(*root.get(),scene,pScene);
-	//flip normals after import
+    pScene->mRootNode = BuildNodes(*root.get(), scene, pScene);
+    //flip normals after import
     FlipWindingOrderProcess flip;
-    flip.Execute( pScene );
+    flip.Execute(pScene);
 }
 
 // ------------------------------------------------------------------------------------------------
-void ConvertTexture(std::shared_ptr< Texture > tex, aiMaterial* out, aiTextureType type)
-{
-    const aiString path( tex->path );
-    out->AddProperty(&path,AI_MATKEY_TEXTURE(type,0));
-    out->AddProperty(&tex->transform,1,AI_MATKEY_UVTRANSFORM(type,0));
+void ConvertTexture(const std::shared_ptr<Texture> &tex, aiMaterial *out, aiTextureType type) {
+    const aiString path(tex->path);
+    out->AddProperty(&path, AI_MATKEY_TEXTURE(type, 0));
+    out->AddProperty(&tex->transform, 1, AI_MATKEY_UVTRANSFORM(type, 0));
 }
 
 // ------------------------------------------------------------------------------------------------
-aiNode* COBImporter::BuildNodes(const Node& root,const Scene& scin,aiScene* fill)
-{
-    aiNode* nd = new aiNode();
+aiNode *COBImporter::BuildNodes(const Node &root, const Scene &scin, aiScene *fill) {
+    aiNode *nd = new aiNode();
     nd->mName.Set(root.name);
     nd->mTransformation = root.transform;
 
     // Note to everybody believing Voodoo is appropriate here:
     // I know polymorphism, run as fast as you can ;-)
     if (Node::TYPE_MESH == root.type) {
-        const Mesh& ndmesh = (const Mesh&)(root);
+        const Mesh &ndmesh = (const Mesh &)(root);
         if (ndmesh.vertex_positions.size() && ndmesh.texture_coords.size()) {
 
-            typedef std::pair<unsigned int,Mesh::FaceRefList> Entry;
-            for(const Entry& reflist : ndmesh.temp_map) {
-                {   // create mesh
+            typedef std::pair<const unsigned int, Mesh::FaceRefList> Entry;
+            for (const Entry &reflist : ndmesh.temp_map) {
+                { // create mesh
                     size_t n = 0;
-                    for(Face* f : reflist.second) {
+                    for (Face *f : reflist.second) {
                         n += f->indices.size();
                     }
                     if (!n) {
                         continue;
                     }
-                    aiMesh* outmesh = fill->mMeshes[fill->mNumMeshes++] = new aiMesh();
+                    aiMesh *outmesh = fill->mMeshes[fill->mNumMeshes++] = new aiMesh();
                     ++nd->mNumMeshes;
 
                     outmesh->mVertices = new aiVector3D[n];
                     outmesh->mTextureCoords[0] = new aiVector3D[n];
 
                     outmesh->mFaces = new aiFace[reflist.second.size()]();
-                    for(Face* f : reflist.second) {
+                    for (Face *f : reflist.second) {
                         if (f->indices.empty()) {
                             continue;
                         }
 
-                        aiFace& fout = outmesh->mFaces[outmesh->mNumFaces++];
+                        aiFace &fout = outmesh->mFaces[outmesh->mNumFaces++];
                         fout.mIndices = new unsigned int[f->indices.size()];
 
-                        for(VertexIndex& v : f->indices) {
+                        for (VertexIndex &v : f->indices) {
                             if (v.pos_idx >= ndmesh.vertex_positions.size()) {
                                 ThrowException("Position index out of range");
                             }
                             if (v.uv_idx >= ndmesh.texture_coords.size()) {
                                 ThrowException("UV index out of range");
                             }
-                            outmesh->mVertices[outmesh->mNumVertices] = ndmesh.vertex_positions[ v.pos_idx ];
+                            outmesh->mVertices[outmesh->mNumVertices] = ndmesh.vertex_positions[v.pos_idx];
                             outmesh->mTextureCoords[0][outmesh->mNumVertices] = aiVector3D(
-                                ndmesh.texture_coords[ v.uv_idx ].x,
-                                ndmesh.texture_coords[ v.uv_idx ].y,
-                                0.f
-                            );
+                                    ndmesh.texture_coords[v.uv_idx].x,
+                                    ndmesh.texture_coords[v.uv_idx].y,
+                                    0.f);
 
                             fout.mIndices[fout.mNumIndices++] = outmesh->mNumVertices++;
                         }
                     }
                     outmesh->mMaterialIndex = fill->mNumMaterials;
-                }{  // create material
-                    const Material* min = NULL;
-                    for(const Material& m : scin.materials) {
+                }
+                { // create material
+                    const Material *min = nullptr;
+                    for (const Material &m : scin.materials) {
                         if (m.parent_id == ndmesh.id && m.matnum == reflist.first) {
                             min = &m;
                             break;
                         }
                     }
                     std::unique_ptr<const Material> defmat;
-                    if(!min) {
-                        ASSIMP_LOG_DEBUG(format()<<"Could not resolve material index "
-                            <<reflist.first<<" - creating default material for this slot");
+                    if (!min) {
+                        ASSIMP_LOG_VERBOSE_DEBUG("Could not resolve material index ", reflist.first, " - creating default material for this slot");
 
-                        defmat.reset(min=new Material());
+                        defmat.reset(min = new Material());
                     }
 
-                    aiMaterial* mat = new aiMaterial();
+                    aiMaterial *mat = new aiMaterial();
                     fill->mMaterials[fill->mNumMaterials++] = mat;
 
-                    const aiString s(format("#mat_")<<fill->mNumMeshes<<"_"<<min->matnum);
-                    mat->AddProperty(&s,AI_MATKEY_NAME);
+                    const aiString s(format("#mat_") << fill->mNumMeshes << "_" << min->matnum);
+                    mat->AddProperty(&s, AI_MATKEY_NAME);
 
-                    if(int tmp = ndmesh.draw_flags & Mesh::WIRED ? 1 : 0) {
-                        mat->AddProperty(&tmp,1,AI_MATKEY_ENABLE_WIREFRAME);
+                    if (int tmp = ndmesh.draw_flags & Mesh::WIRED ? 1 : 0) {
+                        mat->AddProperty(&tmp, 1, AI_MATKEY_ENABLE_WIREFRAME);
                     }
 
-                    {   int shader;
-                        switch(min->shader)
-                        {
+                    {
+                        int shader;
+                        switch (min->shader) {
                         case Material::FLAT:
                             shader = aiShadingMode_Gouraud;
                             break;
@@ -335,40 +324,41 @@ aiNode* COBImporter::BuildNodes(const Node& root,const Scene& scin,aiScene* fill
                             break;
 
                         default:
+                            ASSIMP_LOG_ERROR("Unknown option.");
                             ai_assert(false); // shouldn't be here
+                            break;
                         }
-                        mat->AddProperty(&shader,1,AI_MATKEY_SHADING_MODEL);
-                        if(shader != aiShadingMode_Gouraud) {
-                            mat->AddProperty(&min->exp,1,AI_MATKEY_SHININESS);
+                        mat->AddProperty(&shader, 1, AI_MATKEY_SHADING_MODEL);
+                        if (shader != aiShadingMode_Gouraud) {
+                            mat->AddProperty(&min->exp, 1, AI_MATKEY_SHININESS);
                         }
                     }
 
-                    mat->AddProperty(&min->ior,1,AI_MATKEY_REFRACTI);
-                    mat->AddProperty(&min->rgb,1,AI_MATKEY_COLOR_DIFFUSE);
+                    mat->AddProperty(&min->ior, 1, AI_MATKEY_REFRACTI);
+                    mat->AddProperty(&min->rgb, 1, AI_MATKEY_COLOR_DIFFUSE);
 
-                    aiColor3D c = aiColor3D(min->rgb)*min->ks;
-                    mat->AddProperty(&c,1,AI_MATKEY_COLOR_SPECULAR);
+                    aiColor3D c = aiColor3D(min->rgb) * min->ks;
+                    mat->AddProperty(&c, 1, AI_MATKEY_COLOR_SPECULAR);
 
-                    c = aiColor3D(min->rgb)*min->ka;
-                    mat->AddProperty(&c,1,AI_MATKEY_COLOR_AMBIENT);
+                    c = aiColor3D(min->rgb) * min->ka;
+                    mat->AddProperty(&c, 1, AI_MATKEY_COLOR_AMBIENT);
 
                     // convert textures if some exist.
-                    if(min->tex_color) {
-                        ConvertTexture(min->tex_color,mat,aiTextureType_DIFFUSE);
+                    if (min->tex_color) {
+                        ConvertTexture(min->tex_color, mat, aiTextureType_DIFFUSE);
                     }
-                    if(min->tex_env) {
-                        ConvertTexture(min->tex_env  ,mat,aiTextureType_UNKNOWN);
+                    if (min->tex_env) {
+                        ConvertTexture(min->tex_env, mat, aiTextureType_UNKNOWN);
                     }
-                    if(min->tex_bump) {
-                        ConvertTexture(min->tex_bump ,mat,aiTextureType_HEIGHT);
+                    if (min->tex_bump) {
+                        ConvertTexture(min->tex_bump, mat, aiTextureType_HEIGHT);
                     }
                 }
             }
         }
-    }
-    else if (Node::TYPE_LIGHT == root.type) {
-        const Light& ndlight = (const Light&)(root);
-        aiLight* outlight = fill->mLights[fill->mNumLights++] = new aiLight();
+    } else if (Node::TYPE_LIGHT == root.type) {
+        const Light &ndlight = (const Light &)(root);
+        aiLight *outlight = fill->mLights[fill->mNumLights++] = new aiLight();
 
         outlight->mName.Set(ndlight.name);
         outlight->mColorDiffuse = outlight->mColorAmbient = outlight->mColorSpecular = ndlight.color;
@@ -377,27 +367,26 @@ aiNode* COBImporter::BuildNodes(const Node& root,const Scene& scin,aiScene* fill
         outlight->mAngleInnerCone = AI_DEG_TO_RAD(ndlight.inner_angle);
 
         // XXX
-        outlight->mType = ndlight.ltype==Light::SPOT ? aiLightSource_SPOT : aiLightSource_DIRECTIONAL;
-    }
-    else if (Node::TYPE_CAMERA == root.type) {
-        const Camera& ndcam = (const Camera&)(root);
-        aiCamera* outcam = fill->mCameras[fill->mNumCameras++] = new aiCamera();
+        outlight->mType = ndlight.ltype == Light::SPOT ? aiLightSource_SPOT : aiLightSource_DIRECTIONAL;
+    } else if (Node::TYPE_CAMERA == root.type) {
+        const Camera &ndcam = (const Camera &)(root);
+        aiCamera *outcam = fill->mCameras[fill->mNumCameras++] = new aiCamera();
 
         outcam->mName.Set(ndcam.name);
     }
 
     // add meshes
-    if (nd->mNumMeshes) { // mMeshes must be NULL if count is 0
+    if (nd->mNumMeshes) { // mMeshes must be nullptr if count is 0
         nd->mMeshes = new unsigned int[nd->mNumMeshes];
-        for(unsigned int i = 0; i < nd->mNumMeshes;++i) {
-            nd->mMeshes[i] = fill->mNumMeshes-i-1;
+        for (unsigned int i = 0; i < nd->mNumMeshes; ++i) {
+            nd->mMeshes[i] = fill->mNumMeshes - i - 1;
         }
     }
 
     // add children recursively
-    nd->mChildren = new aiNode*[root.temp_children.size()]();
-    for(const Node* n : root.temp_children) {
-        (nd->mChildren[nd->mNumChildren++] = BuildNodes(*n,scin,fill))->mParent = nd;
+    nd->mChildren = new aiNode *[root.temp_children.size()]();
+    for (const Node *n : root.temp_children) {
+        (nd->mChildren[nd->mNumChildren++] = BuildNodes(*n, scin, fill))->mParent = nd;
     }
 
     return nd;
@@ -405,47 +394,46 @@ aiNode* COBImporter::BuildNodes(const Node& root,const Scene& scin,aiScene* fill
 
 // ------------------------------------------------------------------------------------------------
 // Read an ASCII file into the given scene data structure
-void COBImporter::ReadAsciiFile(Scene& out, StreamReaderLE* stream)
-{
+void COBImporter::ReadAsciiFile(Scene &out, StreamReaderLE *stream) {
     ChunkInfo ci;
-    for(LineSplitter splitter(*stream);splitter;++splitter) {
+    for (LineSplitter splitter(*stream); splitter; ++splitter) {
 
         // add all chunks to be recognized here. /else ../ omitted intentionally.
         if (splitter.match_start("PolH ")) {
-            ReadChunkInfo_Ascii(ci,splitter);
-            ReadPolH_Ascii(out,splitter,ci);
+            ReadChunkInfo_Ascii(ci, splitter);
+            ReadPolH_Ascii(out, splitter, ci);
         }
         if (splitter.match_start("BitM ")) {
-            ReadChunkInfo_Ascii(ci,splitter);
-            ReadBitM_Ascii(out,splitter,ci);
+            ReadChunkInfo_Ascii(ci, splitter);
+            ReadBitM_Ascii(out, splitter, ci);
         }
         if (splitter.match_start("Mat1 ")) {
-            ReadChunkInfo_Ascii(ci,splitter);
-            ReadMat1_Ascii(out,splitter,ci);
+            ReadChunkInfo_Ascii(ci, splitter);
+            ReadMat1_Ascii(out, splitter, ci);
         }
         if (splitter.match_start("Grou ")) {
-            ReadChunkInfo_Ascii(ci,splitter);
-            ReadGrou_Ascii(out,splitter,ci);
+            ReadChunkInfo_Ascii(ci, splitter);
+            ReadGrou_Ascii(out, splitter, ci);
         }
         if (splitter.match_start("Lght ")) {
-            ReadChunkInfo_Ascii(ci,splitter);
-            ReadLght_Ascii(out,splitter,ci);
+            ReadChunkInfo_Ascii(ci, splitter);
+            ReadLght_Ascii(out, splitter, ci);
         }
         if (splitter.match_start("Came ")) {
-            ReadChunkInfo_Ascii(ci,splitter);
-            ReadCame_Ascii(out,splitter,ci);
+            ReadChunkInfo_Ascii(ci, splitter);
+            ReadCame_Ascii(out, splitter, ci);
         }
         if (splitter.match_start("Bone ")) {
-            ReadChunkInfo_Ascii(ci,splitter);
-            ReadBone_Ascii(out,splitter,ci);
+            ReadChunkInfo_Ascii(ci, splitter);
+            ReadBone_Ascii(out, splitter, ci);
         }
         if (splitter.match_start("Chan ")) {
-            ReadChunkInfo_Ascii(ci,splitter);
-            ReadChan_Ascii(out,splitter,ci);
+            ReadChunkInfo_Ascii(ci, splitter);
+            ReadChan_Ascii(out, splitter, ci);
         }
         if (splitter.match_start("Unit ")) {
-            ReadChunkInfo_Ascii(ci,splitter);
-            ReadUnit_Ascii(out,splitter,ci);
+            ReadChunkInfo_Ascii(ci, splitter);
+            ReadUnit_Ascii(out, splitter, ci);
         }
         if (splitter.match_start("END ")) {
             // we don't need this, but I guess there is a reason this
@@ -456,25 +444,22 @@ void COBImporter::ReadAsciiFile(Scene& out, StreamReaderLE* stream)
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadChunkInfo_Ascii(ChunkInfo& out, const LineSplitter& splitter)
-{
-    const char* all_tokens[8];
+void COBImporter::ReadChunkInfo_Ascii(ChunkInfo &out, const LineSplitter &splitter) {
+    const char *all_tokens[8];
     splitter.get_tokens(all_tokens);
 
-    out.version = (all_tokens[1][1]-'0')*100+(all_tokens[1][3]-'0')*10+(all_tokens[1][4]-'0');
-    out.id  = strtoul10(all_tokens[3]);
+    out.version = (all_tokens[1][1] - '0') * 100 + (all_tokens[1][3] - '0') * 10 + (all_tokens[1][4] - '0');
+    out.id = strtoul10(all_tokens[3]);
     out.parent_id = strtoul10(all_tokens[5]);
     out.size = strtol10(all_tokens[7]);
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::UnsupportedChunk_Ascii(LineSplitter& splitter, const ChunkInfo& nfo, const char* name)
-{
-    const std::string error = format("Encountered unsupported chunk: ") <<  name <<
-        " [version: "<<nfo.version<<", size: "<<nfo.size<<"]";
+void COBImporter::UnsupportedChunk_Ascii(LineSplitter &splitter, const ChunkInfo &nfo, const char *name) {
+    const std::string error = format("Encountered unsupported chunk: ") << name << " [version: " << nfo.version << ", size: " << nfo.size << "]";
 
     // we can recover if the chunk size was specified.
-    if(nfo.size != static_cast<unsigned int>(-1)) {
+    if (nfo.size != static_cast<unsigned int>(-1)) {
         ASSIMP_LOG_ERROR(error);
 
         // (HACK) - our current position in the stream is the beginning of the
@@ -483,25 +468,24 @@ void COBImporter::UnsupportedChunk_Ascii(LineSplitter& splitter, const ChunkInfo
         // missing the next line.
         splitter.get_stream().IncPtr(nfo.size);
         splitter.swallow_next_increment();
+    } else {
+        ThrowException(error);
     }
-    else ThrowException(error);
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadBasicNodeInfo_Ascii(Node& msh, LineSplitter& splitter, const ChunkInfo& /*nfo*/)
-{
-    for(;splitter;++splitter) {
+void COBImporter::ReadBasicNodeInfo_Ascii(Node &msh, LineSplitter &splitter, const ChunkInfo & /*nfo*/) {
+    for (; splitter; ++splitter) {
         if (splitter.match_start("Name")) {
             msh.name = std::string(splitter[1]);
 
             // make nice names by merging the dupe count
-            std::replace(msh.name.begin(),msh.name.end(),
-                ',','_');
-        }
-        else if (splitter.match_start("Transform")) {
-            for(unsigned int y = 0; y < 4 && ++splitter; ++y) {
-                const char* s = splitter->c_str();
-                for(unsigned int x = 0; x < 4; ++x) {
+            std::replace(msh.name.begin(), msh.name.end(),
+                    ',', '_');
+        } else if (splitter.match_start("Transform")) {
+            for (unsigned int y = 0; y < 4 && ++splitter; ++y) {
+                const char *s = splitter->c_str();
+                for (unsigned int x = 0; x < 4; ++x) {
                     SkipSpaces(&s);
                     msh.transform[y][x] = fast_atof(&s);
                 }
@@ -514,12 +498,11 @@ void COBImporter::ReadBasicNodeInfo_Ascii(Node& msh, LineSplitter& splitter, con
 
 // ------------------------------------------------------------------------------------------------
 template <typename T>
-void COBImporter::ReadFloat3Tuple_Ascii(T& fill, const char** in)
-{
-    const char* rgb = *in;
-    for(unsigned int i = 0; i < 3; ++i) {
+void COBImporter::ReadFloat3Tuple_Ascii(T &fill, const char **in) {
+    const char *rgb = *in;
+    for (unsigned int i = 0; i < 3; ++i) {
         SkipSpaces(&rgb);
-        if (*rgb == ',')++rgb;
+        if (*rgb == ',') ++rgb;
         SkipSpaces(&rgb);
 
         fill[i] = fast_atof(&rgb);
@@ -528,225 +511,212 @@ void COBImporter::ReadFloat3Tuple_Ascii(T& fill, const char** in)
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadMat1_Ascii(Scene& out, LineSplitter& splitter, const ChunkInfo& nfo)
-{
-    if(nfo.version > 8) {
-        return UnsupportedChunk_Ascii(splitter,nfo,"Mat1");
+void COBImporter::ReadMat1_Ascii(Scene &out, LineSplitter &splitter, const ChunkInfo &nfo) {
+    if (nfo.version > 8) {
+        return UnsupportedChunk_Ascii(splitter, nfo, "Mat1");
     }
 
     ++splitter;
     if (!splitter.match_start("mat# ")) {
-        ASSIMP_LOG_WARN_F( "Expected `mat#` line in `Mat1` chunk ", nfo.id );
+        ASSIMP_LOG_WARN("Expected `mat#` line in `Mat1` chunk ", nfo.id);
         return;
     }
 
     out.materials.push_back(Material());
-    Material& mat = out.materials.back();
+    Material &mat = out.materials.back();
     mat = nfo;
 
     mat.matnum = strtoul10(splitter[1]);
     ++splitter;
 
     if (!splitter.match_start("shader: ")) {
-        ASSIMP_LOG_WARN_F( "Expected `mat#` line in `Mat1` chunk ", nfo.id);
+        ASSIMP_LOG_WARN("Expected `mat#` line in `Mat1` chunk ", nfo.id);
         return;
     }
     std::string shader = std::string(splitter[1]);
-    shader = shader.substr(0,shader.find_first_of(" \t"));
+    shader = shader.substr(0, shader.find_first_of(" \t"));
 
     if (shader == "metal") {
         mat.shader = Material::METAL;
-    }
-    else if (shader == "phong") {
+    } else if (shader == "phong") {
         mat.shader = Material::PHONG;
-    }
-    else if (shader != "flat") {
-        ASSIMP_LOG_WARN_F( "Unknown value for `shader` in `Mat1` chunk ", nfo.id );
+    } else if (shader != "flat") {
+        ASSIMP_LOG_WARN("Unknown value for `shader` in `Mat1` chunk ", nfo.id);
     }
 
     ++splitter;
     if (!splitter.match_start("rgb ")) {
-        ASSIMP_LOG_WARN_F( "Expected `rgb` line in `Mat1` chunk ", nfo.id);
+        ASSIMP_LOG_WARN("Expected `rgb` line in `Mat1` chunk ", nfo.id);
     }
 
-    const char* rgb = splitter[1];
-    ReadFloat3Tuple_Ascii(mat.rgb,&rgb);
+    const char *rgb = splitter[1];
+    ReadFloat3Tuple_Ascii(mat.rgb, &rgb);
 
     ++splitter;
     if (!splitter.match_start("alpha ")) {
-        ASSIMP_LOG_WARN_F( "Expected `alpha` line in `Mat1` chunk ", nfo.id);
+        ASSIMP_LOG_WARN("Expected `alpha` line in `Mat1` chunk ", nfo.id);
     }
 
-    const char* tokens[10];
+    const char *tokens[10];
     splitter.get_tokens(tokens);
 
-    mat.alpha   = fast_atof( tokens[1] );
-    mat.ka      = fast_atof( tokens[3] );
-    mat.ks      = fast_atof( tokens[5] );
-    mat.exp     = fast_atof( tokens[7] );
-    mat.ior     = fast_atof( tokens[9] );
+    mat.alpha = fast_atof(tokens[1]);
+    mat.ka = fast_atof(tokens[3]);
+    mat.ks = fast_atof(tokens[5]);
+    mat.exp = fast_atof(tokens[7]);
+    mat.ior = fast_atof(tokens[9]);
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadUnit_Ascii(Scene& out, LineSplitter& splitter, const ChunkInfo& nfo)
-{
-    if(nfo.version > 1) {
-        return UnsupportedChunk_Ascii(splitter,nfo,"Unit");
+void COBImporter::ReadUnit_Ascii(Scene &out, LineSplitter &splitter, const ChunkInfo &nfo) {
+    if (nfo.version > 1) {
+        return UnsupportedChunk_Ascii(splitter, nfo, "Unit");
     }
     ++splitter;
     if (!splitter.match_start("Units ")) {
-        ASSIMP_LOG_WARN_F( "Expected `Units` line in `Unit` chunk ", nfo.id);
+        ASSIMP_LOG_WARN("Expected `Units` line in `Unit` chunk ", nfo.id);
         return;
     }
 
-    // parent chunks preceede their childs, so we should have the
+    // parent chunks preceede their children, so we should have the
     // corresponding chunk already.
-    for(std::shared_ptr< Node >& nd : out.nodes) {
+    for (std::shared_ptr<Node> &nd : out.nodes) {
         if (nd->id == nfo.parent_id) {
-            const unsigned int t=strtoul10(splitter[1]);
+            const unsigned int t = strtoul10(splitter[1]);
 
-            nd->unit_scale = t>=sizeof(units)/sizeof(units[0])?(
-                ASSIMP_LOG_WARN_F(t, " is not a valid value for `Units` attribute in `Unit chunk` ", nfo.id)
-                ,1.f):units[t];
+            nd->unit_scale = t >= sizeof(units) / sizeof(units[0]) ? (
+                                                                             ASSIMP_LOG_WARN(t, " is not a valid value for `Units` attribute in `Unit chunk` ", nfo.id), 1.f) :
+                                                                     units[t];
             return;
         }
     }
-    ASSIMP_LOG_WARN_F( "`Unit` chunk ", nfo.id, " is a child of ", nfo.parent_id, " which does not exist");
+    ASSIMP_LOG_WARN("`Unit` chunk ", nfo.id, " is a child of ", nfo.parent_id, " which does not exist");
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadChan_Ascii(Scene& /*out*/, LineSplitter& splitter, const ChunkInfo& nfo)
-{
-    if(nfo.version > 8) {
-        return UnsupportedChunk_Ascii(splitter,nfo,"Chan");
+void COBImporter::ReadChan_Ascii(Scene & /*out*/, LineSplitter &splitter, const ChunkInfo &nfo) {
+    if (nfo.version > 8) {
+        return UnsupportedChunk_Ascii(splitter, nfo, "Chan");
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadLght_Ascii(Scene& out, LineSplitter& splitter, const ChunkInfo& nfo)
-{
-    if(nfo.version > 8) {
-        return UnsupportedChunk_Ascii(splitter,nfo,"Lght");
+void COBImporter::ReadLght_Ascii(Scene &out, LineSplitter &splitter, const ChunkInfo &nfo) {
+    if (nfo.version > 8) {
+        return UnsupportedChunk_Ascii(splitter, nfo, "Lght");
     }
 
     out.nodes.push_back(std::shared_ptr<Light>(new Light()));
-    Light& msh = (Light&)(*out.nodes.back().get());
+    Light &msh = (Light &)(*out.nodes.back().get());
     msh = nfo;
 
-    ReadBasicNodeInfo_Ascii(msh,++splitter,nfo);
+    ReadBasicNodeInfo_Ascii(msh, ++splitter, nfo);
 
     if (splitter.match_start("Infinite ")) {
         msh.ltype = Light::INFINITE;
-    }
-    else if (splitter.match_start("Local ")) {
+    } else if (splitter.match_start("Local ")) {
         msh.ltype = Light::LOCAL;
-    }
-    else if (splitter.match_start("Spot ")) {
+    } else if (splitter.match_start("Spot ")) {
         msh.ltype = Light::SPOT;
-    }
-    else {
-        ASSIMP_LOG_WARN_F( "Unknown kind of light source in `Lght` chunk ", nfo.id, " : ", *splitter );
+    } else {
+        ASSIMP_LOG_WARN("Unknown kind of light source in `Lght` chunk ", nfo.id, " : ", *splitter);
         msh.ltype = Light::SPOT;
     }
 
     ++splitter;
     if (!splitter.match_start("color ")) {
-        ASSIMP_LOG_WARN_F( "Expected `color` line in `Lght` chunk ", nfo.id );
+        ASSIMP_LOG_WARN("Expected `color` line in `Lght` chunk ", nfo.id);
     }
 
-    const char* rgb = splitter[1];
-    ReadFloat3Tuple_Ascii(msh.color ,&rgb);
+    const char *rgb = splitter[1];
+    ReadFloat3Tuple_Ascii(msh.color, &rgb);
 
     SkipSpaces(&rgb);
-    if (strncmp(rgb,"cone angle",10) != 0) {
-        ASSIMP_LOG_WARN_F( "Expected `cone angle` entity in `color` line in `Lght` chunk ", nfo.id );
+    if (strncmp(rgb, "cone angle", 10) != 0) {
+        ASSIMP_LOG_WARN("Expected `cone angle` entity in `color` line in `Lght` chunk ", nfo.id);
     }
-    SkipSpaces(rgb+10,&rgb);
+    SkipSpaces(rgb + 10, &rgb);
     msh.angle = fast_atof(&rgb);
 
     SkipSpaces(&rgb);
-    if (strncmp(rgb,"inner angle",11) != 0) {
-        ASSIMP_LOG_WARN_F( "Expected `inner angle` entity in `color` line in `Lght` chunk ", nfo.id);
+    if (strncmp(rgb, "inner angle", 11) != 0) {
+        ASSIMP_LOG_WARN("Expected `inner angle` entity in `color` line in `Lght` chunk ", nfo.id);
     }
-    SkipSpaces(rgb+11,&rgb);
+    SkipSpaces(rgb + 11, &rgb);
     msh.inner_angle = fast_atof(&rgb);
 
     // skip the rest for we can't handle this kind of physically-based lighting information.
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadCame_Ascii(Scene& out, LineSplitter& splitter, const ChunkInfo& nfo)
-{
-    if(nfo.version > 2) {
-        return UnsupportedChunk_Ascii(splitter,nfo,"Came");
+void COBImporter::ReadCame_Ascii(Scene &out, LineSplitter &splitter, const ChunkInfo &nfo) {
+    if (nfo.version > 2) {
+        return UnsupportedChunk_Ascii(splitter, nfo, "Came");
     }
 
     out.nodes.push_back(std::shared_ptr<Camera>(new Camera()));
-    Camera& msh = (Camera&)(*out.nodes.back().get());
+    Camera &msh = (Camera &)(*out.nodes.back().get());
     msh = nfo;
 
-    ReadBasicNodeInfo_Ascii(msh,++splitter,nfo);
+    ReadBasicNodeInfo_Ascii(msh, ++splitter, nfo);
 
-    // skip the next line, we don't know this differenciation between a
+    // skip the next line, we don't know this differentiation between a
     // standard camera and a panoramic camera.
     ++splitter;
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadBone_Ascii(Scene& out, LineSplitter& splitter, const ChunkInfo& nfo)
-{
-    if(nfo.version > 5) {
-        return UnsupportedChunk_Ascii(splitter,nfo,"Bone");
+void COBImporter::ReadBone_Ascii(Scene &out, LineSplitter &splitter, const ChunkInfo &nfo) {
+    if (nfo.version > 5) {
+        return UnsupportedChunk_Ascii(splitter, nfo, "Bone");
     }
 
     out.nodes.push_back(std::shared_ptr<Bone>(new Bone()));
-    Bone& msh = (Bone&)(*out.nodes.back().get());
+    Bone &msh = (Bone &)(*out.nodes.back().get());
     msh = nfo;
 
-    ReadBasicNodeInfo_Ascii(msh,++splitter,nfo);
+    ReadBasicNodeInfo_Ascii(msh, ++splitter, nfo);
 
     // TODO
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadGrou_Ascii(Scene& out, LineSplitter& splitter, const ChunkInfo& nfo)
-{
-    if(nfo.version > 1) {
-        return UnsupportedChunk_Ascii(splitter,nfo,"Grou");
+void COBImporter::ReadGrou_Ascii(Scene &out, LineSplitter &splitter, const ChunkInfo &nfo) {
+    if (nfo.version > 1) {
+        return UnsupportedChunk_Ascii(splitter, nfo, "Grou");
     }
 
     out.nodes.push_back(std::shared_ptr<Group>(new Group()));
-    Group& msh = (Group&)(*out.nodes.back().get());
+    Group &msh = (Group &)(*out.nodes.back().get());
     msh = nfo;
 
-    ReadBasicNodeInfo_Ascii(msh,++splitter,nfo);
+    ReadBasicNodeInfo_Ascii(msh, ++splitter, nfo);
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadPolH_Ascii(Scene& out, LineSplitter& splitter, const ChunkInfo& nfo)
-{
-    if(nfo.version > 8) {
-        return UnsupportedChunk_Ascii(splitter,nfo,"PolH");
+void COBImporter::ReadPolH_Ascii(Scene &out, LineSplitter &splitter, const ChunkInfo &nfo) {
+    if (nfo.version > 8) {
+        return UnsupportedChunk_Ascii(splitter, nfo, "PolH");
     }
 
     out.nodes.push_back(std::shared_ptr<Mesh>(new Mesh()));
-    Mesh& msh = (Mesh&)(*out.nodes.back().get());
+    Mesh &msh = (Mesh &)(*out.nodes.back().get());
     msh = nfo;
 
-    ReadBasicNodeInfo_Ascii(msh,++splitter,nfo);
+    ReadBasicNodeInfo_Ascii(msh, ++splitter, nfo);
 
     // the chunk has a fixed order of components, but some are not interesting of us so
     // we're just looking for keywords in arbitrary order. The end of the chunk is
     // either the last `Face` or the `DrawFlags` attribute, depending on the format ver.
-    for(;splitter;++splitter) {
+    for (; splitter; ++splitter) {
         if (splitter.match_start("World Vertices")) {
             const unsigned int cnt = strtoul10(splitter[2]);
             msh.vertex_positions.resize(cnt);
 
-            for(unsigned int cur = 0;cur < cnt && ++splitter;++cur) {
-                const char* s = splitter->c_str();
+            for (unsigned int cur = 0; cur < cnt && ++splitter; ++cur) {
+                const char *s = splitter->c_str();
 
-                aiVector3D& v = msh.vertex_positions[cur];
+                aiVector3D &v = msh.vertex_positions[cur];
 
                 SkipSpaces(&s);
                 v.x = fast_atof(&s);
@@ -755,29 +725,27 @@ void COBImporter::ReadPolH_Ascii(Scene& out, LineSplitter& splitter, const Chunk
                 SkipSpaces(&s);
                 v.z = fast_atof(&s);
             }
-        }
-        else if (splitter.match_start("Texture Vertices")) {
+        } else if (splitter.match_start("Texture Vertices")) {
             const unsigned int cnt = strtoul10(splitter[2]);
             msh.texture_coords.resize(cnt);
 
-            for(unsigned int cur = 0;cur < cnt && ++splitter;++cur) {
-                const char* s = splitter->c_str();
+            for (unsigned int cur = 0; cur < cnt && ++splitter; ++cur) {
+                const char *s = splitter->c_str();
 
-                aiVector2D& v = msh.texture_coords[cur];
+                aiVector2D &v = msh.texture_coords[cur];
 
                 SkipSpaces(&s);
                 v.x = fast_atof(&s);
                 SkipSpaces(&s);
                 v.y = fast_atof(&s);
             }
-        }
-        else if (splitter.match_start("Faces")) {
+        } else if (splitter.match_start("Faces")) {
             const unsigned int cnt = strtoul10(splitter[1]);
             msh.faces.reserve(cnt);
 
-            for(unsigned int cur = 0; cur < cnt && ++splitter ;++cur) {
+            for (unsigned int cur = 0; cur < cnt && ++splitter; ++cur) {
                 if (splitter.match_start("Hole")) {
-                    ASSIMP_LOG_WARN( "Skipping unsupported `Hole` line" );
+                    ASSIMP_LOG_WARN("Skipping unsupported `Hole` line");
                     continue;
                 }
 
@@ -786,25 +754,25 @@ void COBImporter::ReadPolH_Ascii(Scene& out, LineSplitter& splitter, const Chunk
                 }
 
                 msh.faces.push_back(Face());
-                Face& face = msh.faces.back();
+                Face &face = msh.faces.back();
 
                 face.indices.resize(strtoul10(splitter[2]));
                 face.flags = strtoul10(splitter[4]);
                 face.material = strtoul10(splitter[6]);
 
-                const char* s = (++splitter)->c_str();
-                for(size_t i = 0; i < face.indices.size(); ++i) {
-                    if(!SkipSpaces(&s)) {
+                const char *s = (++splitter)->c_str();
+                for (size_t i = 0; i < face.indices.size(); ++i) {
+                    if (!SkipSpaces(&s)) {
                         ThrowException("Expected EOL token in Face entry");
                     }
                     if ('<' != *s++) {
                         ThrowException("Expected < token in Face entry");
                     }
-                    face.indices[i].pos_idx = strtoul10(s,&s);
+                    face.indices[i].pos_idx = strtoul10(s, &s);
                     if (',' != *s++) {
                         ThrowException("Expected , token in Face entry");
                     }
-                    face.indices[i].uv_idx = strtoul10(s,&s);
+                    face.indices[i].uv_idx = strtoul10(s, &s);
                     if ('>' != *s++) {
                         ThrowException("Expected < token in Face entry");
                     }
@@ -813,8 +781,7 @@ void COBImporter::ReadPolH_Ascii(Scene& out, LineSplitter& splitter, const Chunk
             if (nfo.version <= 4) {
                 break;
             }
-        }
-        else if (splitter.match_start("DrawFlags")) {
+        } else if (splitter.match_start("DrawFlags")) {
             msh.draw_flags = strtoul10(splitter[1]);
             break;
         }
@@ -822,245 +789,209 @@ void COBImporter::ReadPolH_Ascii(Scene& out, LineSplitter& splitter, const Chunk
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadBitM_Ascii(Scene& /*out*/, LineSplitter& splitter, const ChunkInfo& nfo)
-{
-    if(nfo.version > 1) {
-        return UnsupportedChunk_Ascii(splitter,nfo,"BitM");
+void COBImporter::ReadBitM_Ascii(Scene & /*out*/, LineSplitter &splitter, const ChunkInfo &nfo) {
+    if (nfo.version > 1) {
+        return UnsupportedChunk_Ascii(splitter, nfo, "BitM");
     }
-/*
-    "\nThumbNailHdrSize %ld"
-    "\nThumbHeader: %02hx 02hx %02hx "
-    "\nColorBufSize %ld"
-    "\nColorBufZipSize %ld"
-    "\nZippedThumbnail: %02hx 02hx %02hx "
-*/
 
     const unsigned int head = strtoul10((++splitter)[1]);
     if (head != sizeof(Bitmap::BitmapHeader)) {
         ASSIMP_LOG_WARN("Unexpected ThumbNailHdrSize, skipping this chunk");
         return;
     }
-
-    /*union {
-        Bitmap::BitmapHeader data;
-        char opaq[sizeof Bitmap::BitmapHeader()];
-    };*/
-//  ReadHexOctets(opaq,head,(++splitter)[1]);
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadString_Binary(std::string& out, StreamReaderLE& reader)
-{
-    out.resize( reader.GetI2());
-    for(char& c : out) {
+void COBImporter::ReadString_Binary(std::string &out, StreamReaderLE &reader) {
+    out.resize(reader.GetI2());
+    for (char &c : out) {
         c = reader.GetI1();
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadBasicNodeInfo_Binary(Node& msh, StreamReaderLE& reader, const ChunkInfo& /*nfo*/)
-{
+void COBImporter::ReadBasicNodeInfo_Binary(Node &msh, StreamReaderLE &reader, const ChunkInfo & /*nfo*/) {
     const unsigned int dupes = reader.GetI2();
-    ReadString_Binary(msh.name,reader);
+    ReadString_Binary(msh.name, reader);
 
-    msh.name = format(msh.name)<<'_'<<dupes;
+    msh.name = format(msh.name) << '_' << dupes;
 
     // skip local axes for the moment
     reader.IncPtr(48);
 
     msh.transform = aiMatrix4x4();
-    for(unsigned int y = 0; y < 3; ++y) {
-        for(unsigned int x =0; x < 4; ++x) {
+    for (unsigned int y = 0; y < 3; ++y) {
+        for (unsigned int x = 0; x < 4; ++x) {
             msh.transform[y][x] = reader.GetF4();
         }
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::UnsupportedChunk_Binary( StreamReaderLE& reader, const ChunkInfo& nfo, const char* name)
-{
-    const std::string error = format("Encountered unsupported chunk: ") <<  name <<
-        " [version: "<<nfo.version<<", size: "<<nfo.size<<"]";
+void COBImporter::UnsupportedChunk_Binary(StreamReaderLE &reader, const ChunkInfo &nfo, const char *name) {
+    const std::string error = format("Encountered unsupported chunk: ") << name << " [version: " << nfo.version << ", size: " << nfo.size << "]";
 
     // we can recover if the chunk size was specified.
-    if(nfo.size != static_cast<unsigned int>(-1)) {
+    if (nfo.size != static_cast<unsigned int>(-1)) {
         ASSIMP_LOG_ERROR(error);
         reader.IncPtr(nfo.size);
-    }
-    else ThrowException(error);
+    } else
+        ThrowException(error);
 }
 
 // ------------------------------------------------------------------------------------------------
 // tiny utility guard to aid me at staying within chunk boundaries.
 class chunk_guard {
 public:
-    chunk_guard(const COB::ChunkInfo& nfo, StreamReaderLE& reader)
-    : nfo(nfo)
-    , reader(reader)
-    , cur(reader.GetCurrentPos()) {
+    chunk_guard(const COB::ChunkInfo &nfo, StreamReaderLE &reader) :
+            nfo(nfo), reader(reader), cur(reader.GetCurrentPos()) {
         // empty
     }
 
     ~chunk_guard() {
         // don't do anything if the size is not given
-        if(nfo.size != static_cast<unsigned int>(-1)) {
+        if (nfo.size != static_cast<unsigned int>(-1)) {
             try {
-                reader.IncPtr( static_cast< int >( nfo.size ) - reader.GetCurrentPos() + cur );
-            } catch (const DeadlyImportError& ) {
+                reader.IncPtr(static_cast<int>(nfo.size) - reader.GetCurrentPos() + cur);
+            } catch (const DeadlyImportError &) {
                 // out of limit so correct the value
-                reader.IncPtr( reader.GetReadLimit() );
+                reader.IncPtr(reader.GetReadLimit());
             }
         }
     }
 
 private:
-    const COB::ChunkInfo& nfo;
-    StreamReaderLE& reader;
+    const COB::ChunkInfo &nfo;
+    StreamReaderLE &reader;
     long cur;
 };
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadBinaryFile(Scene& out, StreamReaderLE* reader) {
+void COBImporter::ReadBinaryFile(Scene &out, StreamReaderLE *reader) {
     if (nullptr == reader) {
         return;
     }
 
-    while(1) {
+    while (1) {
         std::string type;
-         type += reader -> GetI1()
-        ,type += reader -> GetI1()
-        ,type += reader -> GetI1()
-        ,type += reader -> GetI1()
-        ;
+        type += reader->GetI1();
+        type += reader->GetI1();
+        type += reader->GetI1();
+        type += reader->GetI1();
 
         ChunkInfo nfo;
-        nfo.version  = reader -> GetI2()*10;
-        nfo.version += reader -> GetI2();
+        nfo.version = reader->GetI2() * 10;
+        nfo.version += reader->GetI2();
 
         nfo.id = reader->GetI4();
         nfo.parent_id = reader->GetI4();
         nfo.size = reader->GetI4();
 
         if (type == "PolH") {
-            ReadPolH_Binary(out,*reader,nfo);
-        }
-        else if (type == "BitM") {
-            ReadBitM_Binary(out,*reader,nfo);
-        }
-        else if (type == "Grou") {
-            ReadGrou_Binary(out,*reader,nfo);
-        }
-        else if (type == "Lght") {
-            ReadLght_Binary(out,*reader,nfo);
-        }
-        else if (type == "Came") {
-            ReadCame_Binary(out,*reader,nfo);
-        }
-        else if (type == "Mat1") {
-            ReadMat1_Binary(out,*reader,nfo);
-        }
-    /*  else if (type == "Bone") {
-            ReadBone_Binary(out,*reader,nfo);
-        }
-        else if (type == "Chan") {
-            ReadChan_Binary(out,*reader,nfo);
-        }*/
-        else if (type == "Unit") {
-            ReadUnit_Binary(out,*reader,nfo);
-        }
-        else if (type == "OLay") {
+            ReadPolH_Binary(out, *reader, nfo);
+        } else if (type == "BitM") {
+            ReadBitM_Binary(out, *reader, nfo);
+        } else if (type == "Grou") {
+            ReadGrou_Binary(out, *reader, nfo);
+        } else if (type == "Lght") {
+            ReadLght_Binary(out, *reader, nfo);
+        } else if (type == "Came") {
+            ReadCame_Binary(out, *reader, nfo);
+        } else if (type == "Mat1") {
+            ReadMat1_Binary(out, *reader, nfo);
+        } else if (type == "Unit") {
+            ReadUnit_Binary(out, *reader, nfo);
+        } else if (type == "OLay") {
             // ignore layer index silently.
-            if(nfo.size != static_cast<unsigned int>(-1) ) {
+            if (nfo.size != static_cast<unsigned int>(-1)) {
                 reader->IncPtr(nfo.size);
-            }
-            else return UnsupportedChunk_Binary(*reader,nfo,type.c_str());
-        }
-        else if (type == "END ") {
+            } else
+                return UnsupportedChunk_Binary(*reader, nfo, type.c_str());
+        } else if (type == "END ") {
             return;
+        } else {
+            UnsupportedChunk_Binary(*reader, nfo, type.c_str());
         }
-        else UnsupportedChunk_Binary(*reader,nfo,type.c_str());
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadPolH_Binary(COB::Scene& out, StreamReaderLE& reader, const ChunkInfo& nfo)
-{
-    if(nfo.version > 8) {
-        return UnsupportedChunk_Binary(reader,nfo,"PolH");
+void COBImporter::ReadPolH_Binary(COB::Scene &out, StreamReaderLE &reader, const ChunkInfo &nfo) {
+    if (nfo.version > 8) {
+        return UnsupportedChunk_Binary(reader, nfo, "PolH");
     }
-    const chunk_guard cn(nfo,reader);
+    const chunk_guard cn(nfo, reader);
 
     out.nodes.push_back(std::shared_ptr<Mesh>(new Mesh()));
-    Mesh& msh = (Mesh&)(*out.nodes.back().get());
+    Mesh &msh = (Mesh &)(*out.nodes.back().get());
     msh = nfo;
 
-    ReadBasicNodeInfo_Binary(msh,reader,nfo);
+    ReadBasicNodeInfo_Binary(msh, reader, nfo);
 
     msh.vertex_positions.resize(reader.GetI4());
-    for(aiVector3D& v : msh.vertex_positions) {
+    for (aiVector3D &v : msh.vertex_positions) {
         v.x = reader.GetF4();
         v.y = reader.GetF4();
         v.z = reader.GetF4();
     }
 
     msh.texture_coords.resize(reader.GetI4());
-    for(aiVector2D& v : msh.texture_coords) {
+    for (aiVector2D &v : msh.texture_coords) {
         v.x = reader.GetF4();
         v.y = reader.GetF4();
     }
 
     const size_t numf = reader.GetI4();
     msh.faces.reserve(numf);
-    for(size_t i = 0; i < numf; ++i) {
+    for (size_t i = 0; i < numf; ++i) {
         // XXX backface culling flag is 0x10 in flags
 
         // hole?
-        bool hole;
-        if ((hole = (reader.GetI1() & 0x08) != 0)) {
+        bool hole = (reader.GetI1() & 0x08) != 0;
+        if (hole) {
             // XXX Basically this should just work fine - then triangulator
             // should output properly triangulated data even for polygons
             // with holes. Test data specific to COB is needed to confirm it.
             if (msh.faces.empty()) {
                 ThrowException(format("A hole is the first entity in the `PolH` chunk with id ") << nfo.id);
             }
-        }
-        else msh.faces.push_back(Face());
-        Face& f = msh.faces.back();
+        } else
+            msh.faces.push_back(Face());
+        Face &f = msh.faces.back();
 
         const size_t num = reader.GetI2();
         f.indices.reserve(f.indices.size() + num);
 
-        if(!hole) {
+        if (!hole) {
             f.material = reader.GetI2();
             f.flags = 0;
         }
 
-        for(size_t x = 0; x < num; ++x) {
+        for (size_t x = 0; x < num; ++x) {
             f.indices.push_back(VertexIndex());
 
-            VertexIndex& v = f.indices.back();
+            VertexIndex &v = f.indices.back();
             v.pos_idx = reader.GetI4();
             v.uv_idx = reader.GetI4();
         }
 
-        if(hole) {
-            std::reverse(f.indices.rbegin(),f.indices.rbegin()+num);
+        if (hole) {
+            std::reverse(f.indices.rbegin(), f.indices.rbegin() + num);
         }
     }
-    if (nfo.version>4) {
+    if (nfo.version > 4) {
         msh.draw_flags = reader.GetI4();
     }
-    nfo.version>5 && nfo.version<8 ? reader.GetI4() : 0;
+    nfo.version > 5 && nfo.version < 8 ? reader.GetI4() : 0;
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadBitM_Binary(COB::Scene& /*out*/, StreamReaderLE& reader, const ChunkInfo& nfo)
-{
-    if(nfo.version > 1) {
-        return UnsupportedChunk_Binary(reader,nfo,"BitM");
+void COBImporter::ReadBitM_Binary(COB::Scene & /*out*/, StreamReaderLE &reader, const ChunkInfo &nfo) {
+    if (nfo.version > 1) {
+        return UnsupportedChunk_Binary(reader, nfo, "BitM");
     }
 
-    const chunk_guard cn(nfo,reader);
+    const chunk_guard cn(nfo, reader);
 
     const uint32_t len = reader.GetI4();
     reader.IncPtr(len);
@@ -1070,47 +1001,46 @@ void COBImporter::ReadBitM_Binary(COB::Scene& /*out*/, StreamReaderLE& reader, c
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadMat1_Binary(COB::Scene& out, StreamReaderLE& reader, const ChunkInfo& nfo)
-{
-    if(nfo.version > 8) {
-        return UnsupportedChunk_Binary(reader,nfo,"Mat1");
+void COBImporter::ReadMat1_Binary(COB::Scene &out, StreamReaderLE &reader, const ChunkInfo &nfo) {
+    if (nfo.version > 8) {
+        return UnsupportedChunk_Binary(reader, nfo, "Mat1");
     }
 
-    const chunk_guard cn(nfo,reader);
+    const chunk_guard cn(nfo, reader);
 
     out.materials.push_back(Material());
-    Material& mat = out.materials.back();
+    Material &mat = out.materials.back();
     mat = nfo;
 
     mat.matnum = reader.GetI2();
-    switch(reader.GetI1()) {
-        case 'f':
-            mat.type = Material::FLAT;
-            break;
-        case 'p':
-            mat.type = Material::PHONG;
-            break;
-        case 'm':
-            mat.type = Material::METAL;
-            break;
-        default:
-            ASSIMP_LOG_ERROR_F( "Unrecognized shader type in `Mat1` chunk with id ", nfo.id );
-            mat.type = Material::FLAT;
+    switch (reader.GetI1()) {
+    case 'f':
+        mat.type = Material::FLAT;
+        break;
+    case 'p':
+        mat.type = Material::PHONG;
+        break;
+    case 'm':
+        mat.type = Material::METAL;
+        break;
+    default:
+        ASSIMP_LOG_ERROR("Unrecognized shader type in `Mat1` chunk with id ", nfo.id);
+        mat.type = Material::FLAT;
     }
 
-    switch(reader.GetI1()) {
-        case 'f':
-            mat.autofacet = Material::FACETED;
-            break;
-        case 'a':
-            mat.autofacet = Material::AUTOFACETED;
-            break;
-        case 's':
-            mat.autofacet = Material::SMOOTH;
-            break;
-        default:
-            ASSIMP_LOG_ERROR_F( "Unrecognized faceting mode in `Mat1` chunk with id ", nfo.id );
-            mat.autofacet = Material::FACETED;
+    switch (reader.GetI1()) {
+    case 'f':
+        mat.autofacet = Material::FACETED;
+        break;
+    case 'a':
+        mat.autofacet = Material::AUTOFACETED;
+        break;
+    case 's':
+        mat.autofacet = Material::SMOOTH;
+        break;
+    default:
+        ASSIMP_LOG_ERROR("Unrecognized faceting mode in `Mat1` chunk with id ", nfo.id);
+        mat.autofacet = Material::FACETED;
     }
     mat.autofacet_angle = static_cast<float>(reader.GetI1());
 
@@ -1119,29 +1049,29 @@ void COBImporter::ReadMat1_Binary(COB::Scene& out, StreamReaderLE& reader, const
     mat.rgb.b = reader.GetF4();
 
     mat.alpha = reader.GetF4();
-    mat.ka    = reader.GetF4();
-    mat.ks    = reader.GetF4();
-    mat.exp   = reader.GetF4();
-    mat.ior   = reader.GetF4();
+    mat.ka = reader.GetF4();
+    mat.ks = reader.GetF4();
+    mat.exp = reader.GetF4();
+    mat.ior = reader.GetF4();
 
     char id[2];
-    id[0] = reader.GetI1(),id[1] = reader.GetI1();
+    id[0] = reader.GetI1(), id[1] = reader.GetI1();
 
     if (id[0] == 'e' && id[1] == ':') {
         mat.tex_env.reset(new Texture());
 
         reader.GetI1();
-        ReadString_Binary(mat.tex_env->path,reader);
+        ReadString_Binary(mat.tex_env->path, reader);
 
         // advance to next texture-id
-        id[0] = reader.GetI1(),id[1] = reader.GetI1();
+        id[0] = reader.GetI1(), id[1] = reader.GetI1();
     }
 
     if (id[0] == 't' && id[1] == ':') {
         mat.tex_color.reset(new Texture());
 
         reader.GetI1();
-        ReadString_Binary(mat.tex_color->path,reader);
+        ReadString_Binary(mat.tex_color->path, reader);
 
         mat.tex_color->transform.mTranslation.x = reader.GetF4();
         mat.tex_color->transform.mTranslation.y = reader.GetF4();
@@ -1150,14 +1080,14 @@ void COBImporter::ReadMat1_Binary(COB::Scene& out, StreamReaderLE& reader, const
         mat.tex_color->transform.mScaling.y = reader.GetF4();
 
         // advance to next texture-id
-        id[0] = reader.GetI1(),id[1] = reader.GetI1();
+        id[0] = reader.GetI1(), id[1] = reader.GetI1();
     }
 
     if (id[0] == 'b' && id[1] == ':') {
         mat.tex_bump.reset(new Texture());
 
         reader.GetI1();
-        ReadString_Binary(mat.tex_bump->path,reader);
+        ReadString_Binary(mat.tex_bump->path, reader);
 
         mat.tex_bump->transform.mTranslation.x = reader.GetF4();
         mat.tex_bump->transform.mTranslation.y = reader.GetF4();
@@ -1172,82 +1102,78 @@ void COBImporter::ReadMat1_Binary(COB::Scene& out, StreamReaderLE& reader, const
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadCame_Binary(COB::Scene& out, StreamReaderLE& reader, const ChunkInfo& nfo)
-{
-    if(nfo.version > 2) {
-        return UnsupportedChunk_Binary(reader,nfo,"Came");
+void COBImporter::ReadCame_Binary(COB::Scene &out, StreamReaderLE &reader, const ChunkInfo &nfo) {
+    if (nfo.version > 2) {
+        return UnsupportedChunk_Binary(reader, nfo, "Came");
     }
 
-    const chunk_guard cn(nfo,reader);
+    const chunk_guard cn(nfo, reader);
 
     out.nodes.push_back(std::shared_ptr<Camera>(new Camera()));
-    Camera& msh = (Camera&)(*out.nodes.back().get());
+    Camera &msh = (Camera &)(*out.nodes.back().get());
     msh = nfo;
 
-    ReadBasicNodeInfo_Binary(msh,reader,nfo);
+    ReadBasicNodeInfo_Binary(msh, reader, nfo);
 
     // the rest is not interesting for us, so we skip over it.
-    if(nfo.version > 1) {
-        if (reader.GetI2()==512) {
+    if (nfo.version > 1) {
+        if (reader.GetI2() == 512) {
             reader.IncPtr(42);
         }
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadLght_Binary(COB::Scene& out, StreamReaderLE& reader, const ChunkInfo& nfo)
-{
-    if(nfo.version > 2) {
-        return UnsupportedChunk_Binary(reader,nfo,"Lght");
+void COBImporter::ReadLght_Binary(COB::Scene &out, StreamReaderLE &reader, const ChunkInfo &nfo) {
+    if (nfo.version > 2) {
+        return UnsupportedChunk_Binary(reader, nfo, "Lght");
     }
 
-    const chunk_guard cn(nfo,reader);
+    const chunk_guard cn(nfo, reader);
 
     out.nodes.push_back(std::shared_ptr<Light>(new Light()));
-    Light& msh = (Light&)(*out.nodes.back().get());
+    Light &msh = (Light &)(*out.nodes.back().get());
     msh = nfo;
 
-    ReadBasicNodeInfo_Binary(msh,reader,nfo);
+    ReadBasicNodeInfo_Binary(msh, reader, nfo);
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadGrou_Binary(COB::Scene& out, StreamReaderLE& reader, const ChunkInfo& nfo)
-{
-    if(nfo.version > 2) {
-        return UnsupportedChunk_Binary(reader,nfo,"Grou");
+void COBImporter::ReadGrou_Binary(COB::Scene &out, StreamReaderLE &reader, const ChunkInfo &nfo) {
+    if (nfo.version > 2) {
+        return UnsupportedChunk_Binary(reader, nfo, "Grou");
     }
 
-    const chunk_guard cn(nfo,reader);
+    const chunk_guard cn(nfo, reader);
 
     out.nodes.push_back(std::make_shared<Group>());
-    Group& msh = (Group&)(*out.nodes.back().get());
+    Group &msh = (Group &)(*out.nodes.back().get());
     msh = nfo;
 
-    ReadBasicNodeInfo_Binary(msh,reader,nfo);
+    ReadBasicNodeInfo_Binary(msh, reader, nfo);
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadUnit_Binary(COB::Scene& out, StreamReaderLE& reader, const ChunkInfo& nfo)
-{
-     if(nfo.version > 1) {
-        return UnsupportedChunk_Binary(reader,nfo,"Unit");
+void COBImporter::ReadUnit_Binary(COB::Scene &out, StreamReaderLE &reader, const ChunkInfo &nfo) {
+    if (nfo.version > 1) {
+        return UnsupportedChunk_Binary(reader, nfo, "Unit");
     }
 
-     const chunk_guard cn(nfo,reader);
+    const chunk_guard cn(nfo, reader);
 
-    // parent chunks preceede their childs, so we should have the
+    // parent chunks preceede their children, so we should have the
     // corresponding chunk already.
-    for(std::shared_ptr< Node >& nd : out.nodes) {
+    for (std::shared_ptr<Node> &nd : out.nodes) {
         if (nd->id == nfo.parent_id) {
-            const unsigned int t=reader.GetI2();
-            nd->unit_scale = t>=sizeof(units)/sizeof(units[0])?(
-                ASSIMP_LOG_WARN_F(t," is not a valid value for `Units` attribute in `Unit chunk` ", nfo.id)
-                ,1.f):units[t];
+            const unsigned int t = reader.GetI2();
+            nd->unit_scale = t >= sizeof(units) / sizeof(units[0]) ? (
+                                                                             ASSIMP_LOG_WARN(t, " is not a valid value for `Units` attribute in `Unit chunk` ", nfo.id), 1.f) :
+                                                                     units[t];
 
             return;
         }
     }
-    ASSIMP_LOG_WARN_F( "`Unit` chunk ", nfo.id, " is a child of ", nfo.parent_id, " which does not exist");
+    ASSIMP_LOG_WARN("`Unit` chunk ", nfo.id, " is a child of ", nfo.parent_id, " which does not exist");
 }
 
 #endif // ASSIMP_BUILD_NO_COB_IMPORTER
diff --git a/Engine/lib/assimp/code/AssetLib/COB/COBLoader.h b/Engine/lib/assimp/code/AssetLib/COB/COBLoader.h
new file mode 100644
index 000000000..e6eb96dc1
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/COB/COBLoader.h
@@ -0,0 +1,152 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file  COBLoader.h
+ *  @brief Declaration of the TrueSpace (*.cob,*.scn) importer class.
+ */
+#ifndef INCLUDED_AI_COB_LOADER_H
+#define INCLUDED_AI_COB_LOADER_H
+
+#include <assimp/BaseImporter.h>
+#include <assimp/StreamReader.h>
+
+struct aiNode;
+
+namespace Assimp {
+class LineSplitter;
+
+// TinyFormatter.h
+namespace Formatter {
+template <typename T, typename TR, typename A>
+class basic_formatter;
+typedef class basic_formatter<char, std::char_traits<char>, std::allocator<char>> format;
+} // namespace Formatter
+
+// COBScene.h
+namespace COB {
+struct ChunkInfo;
+struct Node;
+struct Scene;
+} // namespace COB
+
+// -------------------------------------------------------------------------------------------
+/** Importer class to load TrueSpace files (cob,scn) up to v6.
+ *
+ *  Currently relatively limited, loads only ASCII files and needs more test coverage. */
+// -------------------------------------------------------------------------------------------
+class COBImporter : public BaseImporter {
+public:
+    COBImporter();
+    ~COBImporter() override;
+
+    // --------------------
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
+            bool checkSig) const override;
+
+protected:
+    // --------------------
+    const aiImporterDesc *GetInfo() const override;
+
+    // --------------------
+    void SetupProperties(const Importer *pImp) override;
+
+    // --------------------
+    void InternReadFile(const std::string &pFile, aiScene *pScene,
+            IOSystem *pIOHandler) override;
+
+private:
+    // -------------------------------------------------------------------
+    /** Prepend 'COB: ' and throw msg.*/
+    AI_WONT_RETURN static void ThrowException(const std::string &msg) AI_WONT_RETURN_SUFFIX;
+
+    // -------------------------------------------------------------------
+    /** @brief Read from an ascii scene/object file
+     *  @param out Receives output data.
+     *  @param stream Stream to read from. */
+    void ReadAsciiFile(COB::Scene &out, StreamReaderLE *stream);
+
+    // -------------------------------------------------------------------
+    /** @brief Read from a binary scene/object file
+     *  @param out Receives output data.
+     *  @param stream Stream to read from.  */
+    void ReadBinaryFile(COB::Scene &out, StreamReaderLE *stream);
+
+    // Conversion to Assimp output format
+    aiNode *BuildNodes(const COB::Node &root, const COB::Scene &scin, aiScene *fill);
+
+private:
+    // ASCII file support
+
+    void UnsupportedChunk_Ascii(LineSplitter &splitter, const COB::ChunkInfo &nfo, const char *name);
+    void ReadChunkInfo_Ascii(COB::ChunkInfo &out, const LineSplitter &splitter);
+    void ReadBasicNodeInfo_Ascii(COB::Node &msh, LineSplitter &splitter, const COB::ChunkInfo &nfo);
+    template <typename T>
+    void ReadFloat3Tuple_Ascii(T &fill, const char **in);
+
+    void ReadPolH_Ascii(COB::Scene &out, LineSplitter &splitter, const COB::ChunkInfo &nfo);
+    void ReadBitM_Ascii(COB::Scene &out, LineSplitter &splitter, const COB::ChunkInfo &nfo);
+    void ReadMat1_Ascii(COB::Scene &out, LineSplitter &splitter, const COB::ChunkInfo &nfo);
+    void ReadGrou_Ascii(COB::Scene &out, LineSplitter &splitter, const COB::ChunkInfo &nfo);
+    void ReadBone_Ascii(COB::Scene &out, LineSplitter &splitter, const COB::ChunkInfo &nfo);
+    void ReadCame_Ascii(COB::Scene &out, LineSplitter &splitter, const COB::ChunkInfo &nfo);
+    void ReadLght_Ascii(COB::Scene &out, LineSplitter &splitter, const COB::ChunkInfo &nfo);
+    void ReadUnit_Ascii(COB::Scene &out, LineSplitter &splitter, const COB::ChunkInfo &nfo);
+    void ReadChan_Ascii(COB::Scene &out, LineSplitter &splitter, const COB::ChunkInfo &nfo);
+
+    // Binary file support
+
+    void UnsupportedChunk_Binary(StreamReaderLE &reader, const COB::ChunkInfo &nfo, const char *name);
+    void ReadString_Binary(std::string &out, StreamReaderLE &reader);
+    void ReadBasicNodeInfo_Binary(COB::Node &msh, StreamReaderLE &reader, const COB::ChunkInfo &nfo);
+
+    void ReadPolH_Binary(COB::Scene &out, StreamReaderLE &reader, const COB::ChunkInfo &nfo);
+    void ReadBitM_Binary(COB::Scene &out, StreamReaderLE &reader, const COB::ChunkInfo &nfo);
+    void ReadMat1_Binary(COB::Scene &out, StreamReaderLE &reader, const COB::ChunkInfo &nfo);
+    void ReadCame_Binary(COB::Scene &out, StreamReaderLE &reader, const COB::ChunkInfo &nfo);
+    void ReadLght_Binary(COB::Scene &out, StreamReaderLE &reader, const COB::ChunkInfo &nfo);
+    void ReadGrou_Binary(COB::Scene &out, StreamReaderLE &reader, const COB::ChunkInfo &nfo);
+    void ReadUnit_Binary(COB::Scene &out, StreamReaderLE &reader, const COB::ChunkInfo &nfo);
+
+}; // !class COBImporter
+
+} // end of namespace Assimp
+#endif // AI_UNREALIMPORTER_H_INC
diff --git a/Engine/lib/assimp/code/COB/COBScene.h b/Engine/lib/assimp/code/AssetLib/COB/COBScene.h
similarity index 98%
rename from Engine/lib/assimp/code/COB/COBScene.h
rename to Engine/lib/assimp/code/AssetLib/COB/COBScene.h
index 90349be70..57620ca51 100644
--- a/Engine/lib/assimp/code/COB/COBScene.h
+++ b/Engine/lib/assimp/code/AssetLib/COB/COBScene.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,16 +42,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file  COBScene.h
 *  @brief Utilities for the COB importer.
 */
+#pragma once
 #ifndef INCLUDED_AI_COB_SCENE_H
 #define INCLUDED_AI_COB_SCENE_H
 
-#include <memory>
-#include <deque>
-#include <map>
-
 #include <assimp/BaseImporter.h>
 #include <assimp/material.h>
 
+#include <deque>
+#include <map>
+
 namespace Assimp {
 namespace COB {
 
@@ -75,10 +74,10 @@ struct Face
 
 // ------------------
 /** COB chunk header information */
+const unsigned int NO_SIZE = UINT_MAX;
+
 struct ChunkInfo
 {
-    enum {NO_SIZE=UINT_MAX};
-
     ChunkInfo ()
         :   id        (0)
         ,   parent_id (0)
diff --git a/Engine/lib/assimp/code/CSM/CSMLoader.cpp b/Engine/lib/assimp/code/AssetLib/CSM/CSMLoader.cpp
similarity index 95%
rename from Engine/lib/assimp/code/CSM/CSMLoader.cpp
rename to Engine/lib/assimp/code/AssetLib/CSM/CSMLoader.cpp
index 9dbb38467..681f8602d 100644
--- a/Engine/lib/assimp/code/CSM/CSMLoader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/CSM/CSMLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -90,19 +90,10 @@ CSMImporter::~CSMImporter()
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool CSMImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
+bool CSMImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/) const
 {
-    // check file extension
-    const std::string extension = GetExtension(pFile);
-
-    if( extension == "csm")
-        return true;
-
-    if ((checkSig || !extension.length()) && pIOHandler) {
-        const char* tokens[] = {"$Filename"};
-        return SearchFileHeaderForToken(pIOHandler,pFile,tokens,1);
-    }
-    return false;
+    static const char* tokens[] = {"$Filename"};
+    return SearchFileHeaderForToken(pIOHandler,pFile,tokens,AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -127,8 +118,8 @@ void CSMImporter::InternReadFile( const std::string& pFile,
     std::unique_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));
 
     // Check whether we can read from the file
-    if( file.get() == NULL) {
-        throw DeadlyImportError( "Failed to open CSM file " + pFile + ".");
+    if( file.get() == nullptr) {
+        throw DeadlyImportError( "Failed to open CSM file ", pFile, ".");
     }
 
     // allocate storage and copy the contents of the file to a memory buffer
@@ -178,7 +169,7 @@ void CSMImporter::InternReadFile( const std::string& pFile,
                         *ot++ = *buffer++;
 
                     *ot = '\0';
-                    nda->mNodeName.length = (size_t)(ot-nda->mNodeName.data);
+                    nda->mNodeName.length = static_cast<ai_uint32>(ot-nda->mNodeName.data);
                 }
 
                 anim->mNumChannels = static_cast<unsigned int>(anims_temp.size());
diff --git a/Engine/lib/assimp/code/CSM/CSMLoader.h b/Engine/lib/assimp/code/AssetLib/CSM/CSMLoader.h
similarity index 85%
rename from Engine/lib/assimp/code/CSM/CSMLoader.h
rename to Engine/lib/assimp/code/AssetLib/CSM/CSMLoader.h
index 31a814b52..e9c4cd5ee 100644
--- a/Engine/lib/assimp/code/CSM/CSMLoader.h
+++ b/Engine/lib/assimp/code/AssetLib/CSM/CSMLoader.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -48,7 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <assimp/BaseImporter.h>
 
-namespace Assimp    {
+namespace Assimp {
 
 // ---------------------------------------------------------------------------
 /** Importer class to load MOCAPs in CharacterStudio Motion format.
@@ -59,35 +58,32 @@ namespace Assimp    {
  *  Link to file format specification:
  *  <max_8_dvd>\samples\Motion\Docs\CSM.rtf
 */
-class CSMImporter : public BaseImporter
-{
+class CSMImporter : public BaseImporter {
 public:
     CSMImporter();
-    ~CSMImporter();
+    ~CSMImporter() override;
 
-
-public:
     // -------------------------------------------------------------------
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
+            bool checkSig) const override;
 
 protected:
+    // -------------------------------------------------------------------
+    const aiImporterDesc *GetInfo() const override;
 
     // -------------------------------------------------------------------
-    const aiImporterDesc* GetInfo () const;
+    void SetupProperties(const Importer *pImp) override;
 
     // -------------------------------------------------------------------
-    void SetupProperties(const Importer* pImp);
-
-    // -------------------------------------------------------------------
-    void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
+    void InternReadFile(const std::string &pFile, aiScene *pScene,
+            IOSystem *pIOHandler) override;
 
 private:
-
     bool noSkeletonMesh;
 
 }; // end of class CSMImporter
+
 } // end of namespace Assimp
+
 #endif // AI_AC3DIMPORTER_H_INC
 
diff --git a/Engine/lib/assimp/code/AssetLib/Collada/ColladaExporter.cpp b/Engine/lib/assimp/code/AssetLib/Collada/ColladaExporter.cpp
new file mode 100644
index 000000000..5c91daa1a
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Collada/ColladaExporter.cpp
@@ -0,0 +1,1748 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#ifndef ASSIMP_BUILD_NO_EXPORT
+#ifndef ASSIMP_BUILD_NO_COLLADA_EXPORTER
+
+#include "ColladaExporter.h"
+
+#include <assimp/Bitmap.h>
+#include <assimp/ColladaMetaData.h>
+#include <assimp/DefaultIOSystem.h>
+#include <assimp/Exceptional.h>
+#include <assimp/MathFunctions.h>
+#include <assimp/SceneCombiner.h>
+#include <assimp/StringUtils.h>
+#include <assimp/XMLTools.h>
+#include <assimp/commonMetaData.h>
+#include <assimp/fast_atof.h>
+#include <assimp/scene.h>
+#include <assimp/Exporter.hpp>
+#include <assimp/IOSystem.hpp>
+
+#include <ctime>
+#include <memory>
+
+namespace Assimp {
+
+// ------------------------------------------------------------------------------------------------
+// Worker function for exporting a scene to Collada. Prototyped and registered in Exporter.cpp
+void ExportSceneCollada(const char *pFile, IOSystem *pIOSystem, const aiScene *pScene, const ExportProperties * /*pProperties*/) {
+    std::string path = DefaultIOSystem::absolutePath(std::string(pFile));
+    std::string file = DefaultIOSystem::completeBaseName(std::string(pFile));
+
+    // invoke the exporter
+    ColladaExporter iDoTheExportThing(pScene, pIOSystem, path, file);
+
+    if (iDoTheExportThing.mOutput.fail()) {
+        throw DeadlyExportError("output data creation failed. Most likely the file became too large: " + std::string(pFile));
+    }
+
+    // we're still here - export successfully completed. Write result to the given IOSYstem
+    std::unique_ptr<IOStream> outfile(pIOSystem->Open(pFile, "wt"));
+    if (outfile == nullptr) {
+        throw DeadlyExportError("could not open output .dae file: " + std::string(pFile));
+    }
+
+    // XXX maybe use a small wrapper around IOStream that behaves like std::stringstream in order to avoid the extra copy.
+    outfile->Write(iDoTheExportThing.mOutput.str().c_str(), static_cast<size_t>(iDoTheExportThing.mOutput.tellp()), 1);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Encodes a string into a valid XML ID using the xsd:ID schema qualifications.
+static const std::string XMLIDEncode(const std::string &name) {
+    const char XML_ID_CHARS[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_-.";
+    const unsigned int XML_ID_CHARS_COUNT = sizeof(XML_ID_CHARS) / sizeof(char);
+
+    if (name.length() == 0) {
+        return name;
+    }
+
+    std::stringstream idEncoded;
+
+    // xsd:ID must start with letter or underscore
+    if (!((name[0] >= 'A' && name[0] <= 'z') || name[0] == '_')) {
+        idEncoded << '_';
+    }
+
+    for (std::string::const_iterator it = name.begin(); it != name.end(); ++it) {
+        // xsd:ID can only contain letters, digits, underscores, hyphens and periods
+        if (strchr(XML_ID_CHARS, *it) != nullptr) {
+            idEncoded << *it;
+        } else {
+            // Select placeholder character based on invalid character to reduce ID collisions
+            idEncoded << XML_ID_CHARS[(*it) % XML_ID_CHARS_COUNT];
+        }
+    }
+
+    return idEncoded.str();
+}
+
+// ------------------------------------------------------------------------------------------------
+// Helper functions to create unique ids
+inline bool IsUniqueId(const std::unordered_set<std::string> &idSet, const std::string &idStr) {
+    return (idSet.find(idStr) == idSet.end());
+}
+
+inline std::string MakeUniqueId(const std::unordered_set<std::string> &idSet, const std::string &idPrefix, const std::string &postfix) {
+    std::string result(idPrefix + postfix);
+    if (!IsUniqueId(idSet, result)) {
+        // Select a number to append
+        size_t idnum = 1;
+        do {
+            result = idPrefix + '_' + ai_to_string(idnum) + postfix;
+            ++idnum;
+        } while (!IsUniqueId(idSet, result));
+    }
+    return result;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Constructor for a specific scene to export
+ColladaExporter::ColladaExporter(const aiScene *pScene, IOSystem *pIOSystem, const std::string &path, const std::string &file) :
+        mIOSystem(pIOSystem),
+        mPath(path),
+        mFile(file),
+        mScene(pScene),
+        endstr("\n") {
+    // make sure that all formatting happens using the standard, C locale and not the user's current locale
+    mOutput.imbue(std::locale("C"));
+    mOutput.precision(ASSIMP_AI_REAL_TEXT_PRECISION);
+
+    // start writing the file
+    WriteFile();
+}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor
+ColladaExporter::~ColladaExporter() {
+}
+
+// ------------------------------------------------------------------------------------------------
+// Starts writing the contents
+void ColladaExporter::WriteFile() {
+    // write the DTD
+    mOutput << "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>" << endstr;
+    // COLLADA element start
+    mOutput << "<COLLADA xmlns=\"http://www.collada.org/2005/11/COLLADASchema\" version=\"1.4.1\">" << endstr;
+    PushTag();
+
+    WriteTextures();
+    WriteHeader();
+
+    // Add node names to the unique id database first so they are most likely to use their names as unique ids
+    CreateNodeIds(mScene->mRootNode);
+
+    WriteCamerasLibrary();
+    WriteLightsLibrary();
+    WriteMaterials();
+    WriteGeometryLibrary();
+    WriteControllerLibrary();
+
+    WriteSceneLibrary();
+
+    // customized, Writes the animation library
+    WriteAnimationsLibrary();
+
+    // instantiate the scene(s)
+    // For Assimp there will only ever be one
+    mOutput << startstr << "<scene>" << endstr;
+    PushTag();
+    mOutput << startstr << "<instance_visual_scene url=\"#" + mSceneId + "\" />" << endstr;
+    PopTag();
+    mOutput << startstr << "</scene>" << endstr;
+    PopTag();
+    mOutput << "</COLLADA>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the asset header
+void ColladaExporter::WriteHeader() {
+    static const ai_real epsilon = Math::getEpsilon<ai_real>();
+    static const aiQuaternion x_rot(aiMatrix3x3(
+            0, -1, 0,
+            1, 0, 0,
+            0, 0, 1));
+    static const aiQuaternion y_rot(aiMatrix3x3(
+            1, 0, 0,
+            0, 1, 0,
+            0, 0, 1));
+    static const aiQuaternion z_rot(aiMatrix3x3(
+            1, 0, 0,
+            0, 0, 1,
+            0, -1, 0));
+
+    static const unsigned int date_nb_chars = 20;
+    char date_str[date_nb_chars];
+    std::time_t date = std::time(nullptr);
+    std::strftime(date_str, date_nb_chars, "%Y-%m-%dT%H:%M:%S", std::localtime(&date));
+
+    aiVector3D scaling;
+    aiQuaternion rotation;
+    aiVector3D position;
+    mScene->mRootNode->mTransformation.Decompose(scaling, rotation, position);
+    rotation.Normalize();
+
+    mAdd_root_node = false;
+
+    ai_real scale = 1.0;
+    if (std::abs(scaling.x - scaling.y) <= epsilon && std::abs(scaling.x - scaling.z) <= epsilon && std::abs(scaling.y - scaling.z) <= epsilon) {
+        scale = (ai_real)((((double)scaling.x) + ((double)scaling.y) + ((double)scaling.z)) / 3.0);
+    } else {
+        mAdd_root_node = true;
+    }
+
+    std::string up_axis = "Y_UP";
+    if (rotation.Equal(x_rot, epsilon)) {
+        up_axis = "X_UP";
+    } else if (rotation.Equal(y_rot, epsilon)) {
+        up_axis = "Y_UP";
+    } else if (rotation.Equal(z_rot, epsilon)) {
+        up_axis = "Z_UP";
+    } else {
+        mAdd_root_node = true;
+    }
+
+    if (!position.Equal(aiVector3D(0, 0, 0))) {
+        mAdd_root_node = true;
+    }
+
+    // Assimp root nodes can have meshes, Collada Scenes cannot
+    if (mScene->mRootNode->mNumChildren == 0 || mScene->mRootNode->mMeshes != 0) {
+        mAdd_root_node = true;
+    }
+
+    if (mAdd_root_node) {
+        up_axis = "Y_UP";
+        scale = 1.0;
+    }
+
+    mOutput << startstr << "<asset>" << endstr;
+    PushTag();
+    mOutput << startstr << "<contributor>" << endstr;
+    PushTag();
+
+    // If no Scene metadata, use root node metadata
+    aiMetadata *meta = mScene->mMetaData;
+    if (nullptr == meta) {
+        meta = mScene->mRootNode->mMetaData;
+    }
+
+    aiString value;
+    if (!meta || !meta->Get("Author", value)) {
+        mOutput << startstr << "<author>"
+                << "Assimp"
+                << "</author>" << endstr;
+    } else {
+        mOutput << startstr << "<author>" << XMLEscape(value.C_Str()) << "</author>" << endstr;
+    }
+
+    if (nullptr == meta || !meta->Get(AI_METADATA_SOURCE_GENERATOR, value)) {
+        mOutput << startstr << "<authoring_tool>"
+                << "Assimp Exporter"
+                << "</authoring_tool>" << endstr;
+    } else {
+        mOutput << startstr << "<authoring_tool>" << XMLEscape(value.C_Str()) << "</authoring_tool>" << endstr;
+    }
+
+    if (meta) {
+        if (meta->Get("Comments", value)) {
+            mOutput << startstr << "<comments>" << XMLEscape(value.C_Str()) << "</comments>" << endstr;
+        }
+        if (meta->Get(AI_METADATA_SOURCE_COPYRIGHT, value)) {
+            mOutput << startstr << "<copyright>" << XMLEscape(value.C_Str()) << "</copyright>" << endstr;
+        }
+        if (meta->Get("SourceData", value)) {
+            mOutput << startstr << "<source_data>" << XMLEscape(value.C_Str()) << "</source_data>" << endstr;
+        }
+    }
+
+    PopTag();
+    mOutput << startstr << "</contributor>" << endstr;
+
+    if (nullptr == meta || !meta->Get("Created", value)) {
+        mOutput << startstr << "<created>" << date_str << "</created>" << endstr;
+    } else {
+        mOutput << startstr << "<created>" << XMLEscape(value.C_Str()) << "</created>" << endstr;
+    }
+
+    // Modified date is always the date saved
+    mOutput << startstr << "<modified>" << date_str << "</modified>" << endstr;
+
+    if (meta) {
+        if (meta->Get("Keywords", value)) {
+            mOutput << startstr << "<keywords>" << XMLEscape(value.C_Str()) << "</keywords>" << endstr;
+        }
+        if (meta->Get("Revision", value)) {
+            mOutput << startstr << "<revision>" << XMLEscape(value.C_Str()) << "</revision>" << endstr;
+        }
+        if (meta->Get("Subject", value)) {
+            mOutput << startstr << "<subject>" << XMLEscape(value.C_Str()) << "</subject>" << endstr;
+        }
+        if (meta->Get("Title", value)) {
+            mOutput << startstr << "<title>" << XMLEscape(value.C_Str()) << "</title>" << endstr;
+        }
+    }
+
+    mOutput << startstr << "<unit name=\"meter\" meter=\"" << scale << "\" />" << endstr;
+    mOutput << startstr << "<up_axis>" << up_axis << "</up_axis>" << endstr;
+    PopTag();
+    mOutput << startstr << "</asset>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Write the embedded textures
+void ColladaExporter::WriteTextures() {
+    static const unsigned int buffer_size = 1024;
+    char str[buffer_size];
+
+    if (mScene->HasTextures()) {
+        for (unsigned int i = 0; i < mScene->mNumTextures; i++) {
+            // It would be great to be able to create a directory in portable standard C++, but it's not the case,
+            // so we just write the textures in the current directory.
+
+            aiTexture *texture = mScene->mTextures[i];
+            if (nullptr == texture) {
+                continue;
+            }
+
+            ASSIMP_itoa10(str, buffer_size, i + 1);
+
+            std::string name = mFile + "_texture_" + (i < 1000 ? "0" : "") + (i < 100 ? "0" : "") + (i < 10 ? "0" : "") + str + "." + ((const char *)texture->achFormatHint);
+
+            std::unique_ptr<IOStream> outfile(mIOSystem->Open(mPath + mIOSystem->getOsSeparator() + name, "wb"));
+            if (outfile == nullptr) {
+                throw DeadlyExportError("could not open output texture file: " + mPath + name);
+            }
+
+            if (texture->mHeight == 0) {
+                outfile->Write((void *)texture->pcData, texture->mWidth, 1);
+            } else {
+                Bitmap::Save(texture, outfile.get());
+            }
+
+            outfile->Flush();
+
+            textures.insert(std::make_pair(i, name));
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Write the embedded textures
+void ColladaExporter::WriteCamerasLibrary() {
+    if (mScene->HasCameras()) {
+
+        mOutput << startstr << "<library_cameras>" << endstr;
+        PushTag();
+
+        for (size_t a = 0; a < mScene->mNumCameras; ++a)
+            WriteCamera(a);
+
+        PopTag();
+        mOutput << startstr << "</library_cameras>" << endstr;
+    }
+}
+
+void ColladaExporter::WriteCamera(size_t pIndex) {
+
+    const aiCamera *cam = mScene->mCameras[pIndex];
+    const std::string cameraId = GetObjectUniqueId(AiObjectType::Camera, pIndex);
+    const std::string cameraName = GetObjectName(AiObjectType::Camera, pIndex);
+
+    mOutput << startstr << "<camera id=\"" << cameraId << "\" name=\"" << cameraName << "\" >" << endstr;
+    PushTag();
+    mOutput << startstr << "<optics>" << endstr;
+    PushTag();
+    mOutput << startstr << "<technique_common>" << endstr;
+    PushTag();
+    //assimp doesn't support the import of orthographic cameras! se we write
+    //always perspective
+    mOutput << startstr << "<perspective>" << endstr;
+    PushTag();
+    mOutput << startstr << "<xfov sid=\"xfov\">" << AI_RAD_TO_DEG(cam->mHorizontalFOV)
+            << "</xfov>" << endstr;
+    mOutput << startstr << "<aspect_ratio>"
+            << cam->mAspect
+            << "</aspect_ratio>" << endstr;
+    mOutput << startstr << "<znear sid=\"znear\">"
+            << cam->mClipPlaneNear
+            << "</znear>" << endstr;
+    mOutput << startstr << "<zfar sid=\"zfar\">"
+            << cam->mClipPlaneFar
+            << "</zfar>" << endstr;
+    PopTag();
+    mOutput << startstr << "</perspective>" << endstr;
+    PopTag();
+    mOutput << startstr << "</technique_common>" << endstr;
+    PopTag();
+    mOutput << startstr << "</optics>" << endstr;
+    PopTag();
+    mOutput << startstr << "</camera>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Write the embedded textures
+void ColladaExporter::WriteLightsLibrary() {
+    if (mScene->HasLights()) {
+
+        mOutput << startstr << "<library_lights>" << endstr;
+        PushTag();
+
+        for (size_t a = 0; a < mScene->mNumLights; ++a)
+            WriteLight(a);
+
+        PopTag();
+        mOutput << startstr << "</library_lights>" << endstr;
+    }
+}
+
+void ColladaExporter::WriteLight(size_t pIndex) {
+
+    const aiLight *light = mScene->mLights[pIndex];
+    const std::string lightId = GetObjectUniqueId(AiObjectType::Light, pIndex);
+    const std::string lightName = GetObjectName(AiObjectType::Light, pIndex);
+
+    mOutput << startstr << "<light id=\"" << lightId << "\" name=\""
+            << lightName << "\" >" << endstr;
+    PushTag();
+    mOutput << startstr << "<technique_common>" << endstr;
+    PushTag();
+    switch (light->mType) {
+    case aiLightSource_AMBIENT:
+        WriteAmbienttLight(light);
+        break;
+    case aiLightSource_DIRECTIONAL:
+        WriteDirectionalLight(light);
+        break;
+    case aiLightSource_POINT:
+        WritePointLight(light);
+        break;
+    case aiLightSource_SPOT:
+        WriteSpotLight(light);
+        break;
+    case aiLightSource_AREA:
+    case aiLightSource_UNDEFINED:
+    case _aiLightSource_Force32Bit:
+        break;
+    }
+    PopTag();
+    mOutput << startstr << "</technique_common>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</light>" << endstr;
+}
+
+void ColladaExporter::WritePointLight(const aiLight *const light) {
+    const aiColor3D &color = light->mColorDiffuse;
+    mOutput << startstr << "<point>" << endstr;
+    PushTag();
+    mOutput << startstr << "<color sid=\"color\">"
+            << color.r << " " << color.g << " " << color.b
+            << "</color>" << endstr;
+    mOutput << startstr << "<constant_attenuation>"
+            << light->mAttenuationConstant
+            << "</constant_attenuation>" << endstr;
+    mOutput << startstr << "<linear_attenuation>"
+            << light->mAttenuationLinear
+            << "</linear_attenuation>" << endstr;
+    mOutput << startstr << "<quadratic_attenuation>"
+            << light->mAttenuationQuadratic
+            << "</quadratic_attenuation>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</point>" << endstr;
+}
+
+void ColladaExporter::WriteDirectionalLight(const aiLight *const light) {
+    const aiColor3D &color = light->mColorDiffuse;
+    mOutput << startstr << "<directional>" << endstr;
+    PushTag();
+    mOutput << startstr << "<color sid=\"color\">"
+            << color.r << " " << color.g << " " << color.b
+            << "</color>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</directional>" << endstr;
+}
+
+void ColladaExporter::WriteSpotLight(const aiLight *const light) {
+
+    const aiColor3D &color = light->mColorDiffuse;
+    mOutput << startstr << "<spot>" << endstr;
+    PushTag();
+    mOutput << startstr << "<color sid=\"color\">"
+            << color.r << " " << color.g << " " << color.b
+            << "</color>" << endstr;
+    mOutput << startstr << "<constant_attenuation>"
+            << light->mAttenuationConstant
+            << "</constant_attenuation>" << endstr;
+    mOutput << startstr << "<linear_attenuation>"
+            << light->mAttenuationLinear
+            << "</linear_attenuation>" << endstr;
+    mOutput << startstr << "<quadratic_attenuation>"
+            << light->mAttenuationQuadratic
+            << "</quadratic_attenuation>" << endstr;
+    /*
+    out->mAngleOuterCone = AI_DEG_TO_RAD (std::acos(std::pow(0.1f,1.f/srcLight->mFalloffExponent))+
+                            srcLight->mFalloffAngle);
+    */
+
+    const ai_real fallOffAngle = AI_RAD_TO_DEG(light->mAngleInnerCone);
+    mOutput << startstr << "<falloff_angle sid=\"fall_off_angle\">"
+            << fallOffAngle
+            << "</falloff_angle>" << endstr;
+    double temp = light->mAngleOuterCone - light->mAngleInnerCone;
+
+    temp = std::cos(temp);
+    temp = std::log(temp) / std::log(0.1);
+    temp = 1 / temp;
+    mOutput << startstr << "<falloff_exponent sid=\"fall_off_exponent\">"
+            << temp
+            << "</falloff_exponent>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</spot>" << endstr;
+}
+
+void ColladaExporter::WriteAmbienttLight(const aiLight *const light) {
+
+    const aiColor3D &color = light->mColorAmbient;
+    mOutput << startstr << "<ambient>" << endstr;
+    PushTag();
+    mOutput << startstr << "<color sid=\"color\">"
+            << color.r << " " << color.g << " " << color.b
+            << "</color>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</ambient>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a single surface entry from the given material keys
+bool ColladaExporter::ReadMaterialSurface(Surface &poSurface, const aiMaterial &pSrcMat, aiTextureType pTexture, const char *pKey, size_t pType, size_t pIndex) {
+    if (pSrcMat.GetTextureCount(pTexture) > 0) {
+        aiString texfile;
+        unsigned int uvChannel = 0;
+        pSrcMat.GetTexture(pTexture, 0, &texfile, nullptr, &uvChannel);
+
+        std::string index_str(texfile.C_Str());
+
+        if (index_str.size() != 0 && index_str[0] == '*') {
+            unsigned int index;
+
+            index_str = index_str.substr(1, std::string::npos);
+
+            try {
+                index = (unsigned int)strtoul10_64<DeadlyExportError>(index_str.c_str());
+            } catch (std::exception &error) {
+                throw DeadlyExportError(error.what());
+            }
+
+            std::map<unsigned int, std::string>::const_iterator name = textures.find(index);
+
+            if (name != textures.end()) {
+                poSurface.texture = name->second;
+            } else {
+                throw DeadlyExportError("could not find embedded texture at index " + index_str);
+            }
+        } else {
+            poSurface.texture = texfile.C_Str();
+        }
+
+        poSurface.channel = uvChannel;
+        poSurface.exist = true;
+    } else {
+        if (pKey)
+            poSurface.exist = pSrcMat.Get(pKey, static_cast<unsigned int>(pType), static_cast<unsigned int>(pIndex), poSurface.color) == aiReturn_SUCCESS;
+    }
+    return poSurface.exist;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reimplementation of isalnum(,C locale), because AppVeyor does not see standard version.
+static bool isalnum_C(char c) {
+    return (nullptr != strchr("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", c));
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes an image entry for the given surface
+void ColladaExporter::WriteImageEntry(const Surface &pSurface, const std::string &imageId) {
+    if (!pSurface.texture.empty()) {
+        mOutput << startstr << "<image id=\"" << imageId << "\">" << endstr;
+        PushTag();
+        mOutput << startstr << "<init_from>";
+
+        // URL encode image file name first, then XML encode on top
+        std::stringstream imageUrlEncoded;
+        for (std::string::const_iterator it = pSurface.texture.begin(); it != pSurface.texture.end(); ++it) {
+            if (isalnum_C((unsigned char)*it) || *it == ':' || *it == '_' || *it == '-' || *it == '.' || *it == '/' || *it == '\\')
+                imageUrlEncoded << *it;
+            else
+                imageUrlEncoded << '%' << std::hex << size_t((unsigned char)*it) << std::dec;
+        }
+        mOutput << XMLEscape(imageUrlEncoded.str());
+        mOutput << "</init_from>" << endstr;
+        PopTag();
+        mOutput << startstr << "</image>" << endstr;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes a color-or-texture entry into an effect definition
+void ColladaExporter::WriteTextureColorEntry(const Surface &pSurface, const std::string &pTypeName, const std::string &imageId) {
+    if (pSurface.exist) {
+        mOutput << startstr << "<" << pTypeName << ">" << endstr;
+        PushTag();
+        if (pSurface.texture.empty()) {
+            mOutput << startstr << "<color sid=\"" << pTypeName << "\">" << pSurface.color.r << "   " << pSurface.color.g << "   " << pSurface.color.b << "   " << pSurface.color.a << "</color>" << endstr;
+        } else {
+            mOutput << startstr << "<texture texture=\"" << imageId << "\" texcoord=\"CHANNEL" << pSurface.channel << "\" />" << endstr;
+        }
+        PopTag();
+        mOutput << startstr << "</" << pTypeName << ">" << endstr;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the two parameters necessary for referencing a texture in an effect entry
+void ColladaExporter::WriteTextureParamEntry(const Surface &pSurface, const std::string &pTypeName, const std::string &materialId) {
+    // if surface is a texture, write out the sampler and the surface parameters necessary to reference the texture
+    if (!pSurface.texture.empty()) {
+        mOutput << startstr << "<newparam sid=\"" << materialId << "-" << pTypeName << "-surface\">" << endstr;
+        PushTag();
+        mOutput << startstr << "<surface type=\"2D\">" << endstr;
+        PushTag();
+        mOutput << startstr << "<init_from>" << materialId << "-" << pTypeName << "-image</init_from>" << endstr;
+        PopTag();
+        mOutput << startstr << "</surface>" << endstr;
+        PopTag();
+        mOutput << startstr << "</newparam>" << endstr;
+
+        mOutput << startstr << "<newparam sid=\"" << materialId << "-" << pTypeName << "-sampler\">" << endstr;
+        PushTag();
+        mOutput << startstr << "<sampler2D>" << endstr;
+        PushTag();
+        mOutput << startstr << "<source>" << materialId << "-" << pTypeName << "-surface</source>" << endstr;
+        PopTag();
+        mOutput << startstr << "</sampler2D>" << endstr;
+        PopTag();
+        mOutput << startstr << "</newparam>" << endstr;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes a scalar property
+void ColladaExporter::WriteFloatEntry(const Property &pProperty, const std::string &pTypeName) {
+    if (pProperty.exist) {
+        mOutput << startstr << "<" << pTypeName << ">" << endstr;
+        PushTag();
+        mOutput << startstr << "<float sid=\"" << pTypeName << "\">" << pProperty.value << "</float>" << endstr;
+        PopTag();
+        mOutput << startstr << "</" << pTypeName << ">" << endstr;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the material setup
+void ColladaExporter::WriteMaterials() {
+    std::vector<Material> materials;
+    materials.resize(mScene->mNumMaterials);
+
+    /// collect all materials from the scene
+    size_t numTextures = 0;
+    for (size_t a = 0; a < mScene->mNumMaterials; ++a) {
+        Material &material = materials[a];
+        material.id = GetObjectUniqueId(AiObjectType::Material, a);
+        material.name = GetObjectName(AiObjectType::Material, a);
+
+        const aiMaterial &mat = *(mScene->mMaterials[a]);
+        aiShadingMode shading = aiShadingMode_Flat;
+        material.shading_model = "phong";
+        if (mat.Get(AI_MATKEY_SHADING_MODEL, shading) == aiReturn_SUCCESS) {
+            if (shading == aiShadingMode_Phong) {
+                material.shading_model = "phong";
+            } else if (shading == aiShadingMode_Blinn) {
+                material.shading_model = "blinn";
+            } else if (shading == aiShadingMode_NoShading) {
+                material.shading_model = "constant";
+            } else if (shading == aiShadingMode_Gouraud) {
+                material.shading_model = "lambert";
+            }
+        }
+
+        if (ReadMaterialSurface(material.ambient, mat, aiTextureType_AMBIENT, AI_MATKEY_COLOR_AMBIENT))
+            ++numTextures;
+        if (ReadMaterialSurface(material.diffuse, mat, aiTextureType_DIFFUSE, AI_MATKEY_COLOR_DIFFUSE))
+            ++numTextures;
+        if (ReadMaterialSurface(material.specular, mat, aiTextureType_SPECULAR, AI_MATKEY_COLOR_SPECULAR))
+            ++numTextures;
+        if (ReadMaterialSurface(material.emissive, mat, aiTextureType_EMISSIVE, AI_MATKEY_COLOR_EMISSIVE))
+            ++numTextures;
+        if (ReadMaterialSurface(material.reflective, mat, aiTextureType_REFLECTION, AI_MATKEY_COLOR_REFLECTIVE))
+            ++numTextures;
+        if (ReadMaterialSurface(material.transparent, mat, aiTextureType_OPACITY, AI_MATKEY_COLOR_TRANSPARENT))
+            ++numTextures;
+        if (ReadMaterialSurface(material.normal, mat, aiTextureType_NORMALS, nullptr, 0, 0))
+            ++numTextures;
+
+        material.shininess.exist = mat.Get(AI_MATKEY_SHININESS, material.shininess.value) == aiReturn_SUCCESS;
+        material.transparency.exist = mat.Get(AI_MATKEY_OPACITY, material.transparency.value) == aiReturn_SUCCESS;
+        material.index_refraction.exist = mat.Get(AI_MATKEY_REFRACTI, material.index_refraction.value) == aiReturn_SUCCESS;
+    }
+
+    // output textures if present
+    if (numTextures > 0) {
+        mOutput << startstr << "<library_images>" << endstr;
+        PushTag();
+        for (const Material &mat : materials) {
+            WriteImageEntry(mat.ambient, mat.id + "-ambient-image");
+            WriteImageEntry(mat.diffuse, mat.id + "-diffuse-image");
+            WriteImageEntry(mat.specular, mat.id + "-specular-image");
+            WriteImageEntry(mat.emissive, mat.id + "-emission-image");
+            WriteImageEntry(mat.reflective, mat.id + "-reflective-image");
+            WriteImageEntry(mat.transparent, mat.id + "-transparent-image");
+            WriteImageEntry(mat.normal, mat.id + "-normal-image");
+        }
+        PopTag();
+        mOutput << startstr << "</library_images>" << endstr;
+    }
+
+    // output effects - those are the actual carriers of information
+    if (!materials.empty()) {
+        mOutput << startstr << "<library_effects>" << endstr;
+        PushTag();
+        for (const Material &mat : materials) {
+            // this is so ridiculous it must be right
+            mOutput << startstr << "<effect id=\"" << mat.id << "-fx\" name=\"" << mat.name << "\">" << endstr;
+            PushTag();
+            mOutput << startstr << "<profile_COMMON>" << endstr;
+            PushTag();
+
+            // write sampler- and surface params for the texture entries
+            WriteTextureParamEntry(mat.emissive, "emission", mat.id);
+            WriteTextureParamEntry(mat.ambient, "ambient", mat.id);
+            WriteTextureParamEntry(mat.diffuse, "diffuse", mat.id);
+            WriteTextureParamEntry(mat.specular, "specular", mat.id);
+            WriteTextureParamEntry(mat.reflective, "reflective", mat.id);
+            WriteTextureParamEntry(mat.transparent, "transparent", mat.id);
+            WriteTextureParamEntry(mat.normal, "normal", mat.id);
+
+            mOutput << startstr << "<technique sid=\"standard\">" << endstr;
+            PushTag();
+            mOutput << startstr << "<" << mat.shading_model << ">" << endstr;
+            PushTag();
+
+            WriteTextureColorEntry(mat.emissive, "emission", mat.id + "-emission-sampler");
+            WriteTextureColorEntry(mat.ambient, "ambient", mat.id + "-ambient-sampler");
+            WriteTextureColorEntry(mat.diffuse, "diffuse", mat.id + "-diffuse-sampler");
+            WriteTextureColorEntry(mat.specular, "specular", mat.id + "-specular-sampler");
+            WriteFloatEntry(mat.shininess, "shininess");
+            WriteTextureColorEntry(mat.reflective, "reflective", mat.id + "-reflective-sampler");
+            WriteTextureColorEntry(mat.transparent, "transparent", mat.id + "-transparent-sampler");
+            WriteFloatEntry(mat.transparency, "transparency");
+            WriteFloatEntry(mat.index_refraction, "index_of_refraction");
+
+            if (!mat.normal.texture.empty()) {
+                WriteTextureColorEntry(mat.normal, "bump", mat.id + "-normal-sampler");
+            }
+
+            PopTag();
+            mOutput << startstr << "</" << mat.shading_model << ">" << endstr;
+            PopTag();
+            mOutput << startstr << "</technique>" << endstr;
+            PopTag();
+            mOutput << startstr << "</profile_COMMON>" << endstr;
+            PopTag();
+            mOutput << startstr << "</effect>" << endstr;
+        }
+        PopTag();
+        mOutput << startstr << "</library_effects>" << endstr;
+
+        // write materials - they're just effect references
+        mOutput << startstr << "<library_materials>" << endstr;
+        PushTag();
+        for (std::vector<Material>::const_iterator it = materials.begin(); it != materials.end(); ++it) {
+            const Material &mat = *it;
+            mOutput << startstr << "<material id=\"" << mat.id << "\" name=\"" << mat.name << "\">" << endstr;
+            PushTag();
+            mOutput << startstr << "<instance_effect url=\"#" << mat.id << "-fx\"/>" << endstr;
+            PopTag();
+            mOutput << startstr << "</material>" << endstr;
+        }
+        PopTag();
+        mOutput << startstr << "</library_materials>" << endstr;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the controller library
+void ColladaExporter::WriteControllerLibrary() {
+    mOutput << startstr << "<library_controllers>" << endstr;
+    PushTag();
+
+    for (size_t a = 0; a < mScene->mNumMeshes; ++a) {
+        WriteController(a);
+    }
+
+    PopTag();
+    mOutput << startstr << "</library_controllers>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes a skin controller of the given mesh
+void ColladaExporter::WriteController(size_t pIndex) {
+    const aiMesh *mesh = mScene->mMeshes[pIndex];
+    // Is there a skin controller?
+    if (mesh->mNumBones == 0 || mesh->mNumFaces == 0 || mesh->mNumVertices == 0)
+        return;
+
+    const std::string idstr = GetObjectUniqueId(AiObjectType::Mesh, pIndex);
+    const std::string namestr = GetObjectName(AiObjectType::Mesh, pIndex);
+
+    mOutput << startstr << "<controller id=\"" << idstr << "-skin\" ";
+    mOutput << "name=\"skinCluster" << pIndex << "\">" << endstr;
+    PushTag();
+
+    mOutput << startstr << "<skin source=\"#" << idstr << "\">" << endstr;
+    PushTag();
+
+    // bind pose matrix
+    mOutput << startstr << "<bind_shape_matrix>" << endstr;
+    PushTag();
+
+    // I think it is identity in general cases.
+    aiMatrix4x4 mat;
+    mOutput << startstr << mat.a1 << " " << mat.a2 << " " << mat.a3 << " " << mat.a4 << endstr;
+    mOutput << startstr << mat.b1 << " " << mat.b2 << " " << mat.b3 << " " << mat.b4 << endstr;
+    mOutput << startstr << mat.c1 << " " << mat.c2 << " " << mat.c3 << " " << mat.c4 << endstr;
+    mOutput << startstr << mat.d1 << " " << mat.d2 << " " << mat.d3 << " " << mat.d4 << endstr;
+
+    PopTag();
+    mOutput << startstr << "</bind_shape_matrix>" << endstr;
+
+    mOutput << startstr << "<source id=\"" << idstr << "-skin-joints\" name=\"" << namestr << "-skin-joints\">" << endstr;
+    PushTag();
+
+    mOutput << startstr << "<Name_array id=\"" << idstr << "-skin-joints-array\" count=\"" << mesh->mNumBones << "\">";
+
+    for (size_t i = 0; i < mesh->mNumBones; ++i)
+        mOutput << GetBoneUniqueId(mesh->mBones[i]) << ' ';
+
+    mOutput << "</Name_array>" << endstr;
+
+    mOutput << startstr << "<technique_common>" << endstr;
+    PushTag();
+
+    mOutput << startstr << "<accessor source=\"#" << idstr << "-skin-joints-array\" count=\"" << mesh->mNumBones << "\" stride=\"" << 1 << "\">" << endstr;
+    PushTag();
+
+    mOutput << startstr << "<param name=\"JOINT\" type=\"Name\"></param>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</accessor>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</technique_common>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</source>" << endstr;
+
+    std::vector<ai_real> bind_poses;
+    bind_poses.reserve(mesh->mNumBones * 16);
+    for (unsigned int i = 0; i < mesh->mNumBones; ++i)
+        for (unsigned int j = 0; j < 4; ++j)
+            bind_poses.insert(bind_poses.end(), mesh->mBones[i]->mOffsetMatrix[j], mesh->mBones[i]->mOffsetMatrix[j] + 4);
+
+    WriteFloatArray(idstr + "-skin-bind_poses", FloatType_Mat4x4, (const ai_real *)bind_poses.data(), bind_poses.size() / 16);
+
+    bind_poses.clear();
+
+    std::vector<ai_real> skin_weights;
+    skin_weights.reserve(mesh->mNumVertices * mesh->mNumBones);
+    for (size_t i = 0; i < mesh->mNumBones; ++i)
+        for (size_t j = 0; j < mesh->mBones[i]->mNumWeights; ++j)
+            skin_weights.push_back(mesh->mBones[i]->mWeights[j].mWeight);
+
+    WriteFloatArray(idstr + "-skin-weights", FloatType_Weight, (const ai_real *)skin_weights.data(), skin_weights.size());
+
+    skin_weights.clear();
+
+    mOutput << startstr << "<joints>" << endstr;
+    PushTag();
+
+    mOutput << startstr << "<input semantic=\"JOINT\" source=\"#" << idstr << "-skin-joints\"></input>" << endstr;
+    mOutput << startstr << "<input semantic=\"INV_BIND_MATRIX\" source=\"#" << idstr << "-skin-bind_poses\"></input>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</joints>" << endstr;
+
+    mOutput << startstr << "<vertex_weights count=\"" << mesh->mNumVertices << "\">" << endstr;
+    PushTag();
+
+    mOutput << startstr << "<input semantic=\"JOINT\" source=\"#" << idstr << "-skin-joints\" offset=\"0\"></input>" << endstr;
+    mOutput << startstr << "<input semantic=\"WEIGHT\" source=\"#" << idstr << "-skin-weights\" offset=\"1\"></input>" << endstr;
+
+    mOutput << startstr << "<vcount>";
+
+    std::vector<ai_uint> num_influences(mesh->mNumVertices, (ai_uint)0);
+    for (size_t i = 0; i < mesh->mNumBones; ++i)
+        for (size_t j = 0; j < mesh->mBones[i]->mNumWeights; ++j)
+            ++num_influences[mesh->mBones[i]->mWeights[j].mVertexId];
+
+    for (size_t i = 0; i < mesh->mNumVertices; ++i)
+        mOutput << num_influences[i] << " ";
+
+    mOutput << "</vcount>" << endstr;
+
+    mOutput << startstr << "<v>";
+
+    ai_uint joint_weight_indices_length = 0;
+    std::vector<ai_uint> accum_influences;
+    accum_influences.reserve(num_influences.size());
+    for (size_t i = 0; i < num_influences.size(); ++i) {
+        accum_influences.push_back(joint_weight_indices_length);
+        joint_weight_indices_length += num_influences[i];
+    }
+
+    ai_uint weight_index = 0;
+    std::vector<ai_int> joint_weight_indices(2 * joint_weight_indices_length, (ai_int)-1);
+    for (unsigned int i = 0; i < mesh->mNumBones; ++i)
+        for (unsigned j = 0; j < mesh->mBones[i]->mNumWeights; ++j) {
+            unsigned int vId = mesh->mBones[i]->mWeights[j].mVertexId;
+            for (ai_uint k = 0; k < num_influences[vId]; ++k) {
+                if (joint_weight_indices[2 * (accum_influences[vId] + k)] == -1) {
+                    joint_weight_indices[2 * (accum_influences[vId] + k)] = i;
+                    joint_weight_indices[2 * (accum_influences[vId] + k) + 1] = weight_index;
+                    break;
+                }
+            }
+            ++weight_index;
+        }
+
+    for (size_t i = 0; i < joint_weight_indices.size(); ++i)
+        mOutput << joint_weight_indices[i] << " ";
+
+    num_influences.clear();
+    accum_influences.clear();
+    joint_weight_indices.clear();
+
+    mOutput << "</v>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</vertex_weights>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</skin>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</controller>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the geometry library
+void ColladaExporter::WriteGeometryLibrary() {
+    mOutput << startstr << "<library_geometries>" << endstr;
+    PushTag();
+
+    for (size_t a = 0; a < mScene->mNumMeshes; ++a)
+        WriteGeometry(a);
+
+    PopTag();
+    mOutput << startstr << "</library_geometries>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the given mesh
+void ColladaExporter::WriteGeometry(size_t pIndex) {
+    const aiMesh *mesh = mScene->mMeshes[pIndex];
+    const std::string geometryId = GetObjectUniqueId(AiObjectType::Mesh, pIndex);
+    const std::string geometryName = GetObjectName(AiObjectType::Mesh, pIndex);
+
+    if (mesh->mNumFaces == 0 || mesh->mNumVertices == 0)
+        return;
+
+    // opening tag
+    mOutput << startstr << "<geometry id=\"" << geometryId << "\" name=\"" << geometryName << "\" >" << endstr;
+    PushTag();
+
+    mOutput << startstr << "<mesh>" << endstr;
+    PushTag();
+
+    // Positions
+    WriteFloatArray(geometryId + "-positions", FloatType_Vector, (ai_real *)mesh->mVertices, mesh->mNumVertices);
+    // Normals, if any
+    if (mesh->HasNormals())
+        WriteFloatArray(geometryId + "-normals", FloatType_Vector, (ai_real *)mesh->mNormals, mesh->mNumVertices);
+
+    // texture coords
+    for (size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
+        if (mesh->HasTextureCoords(static_cast<unsigned int>(a))) {
+            WriteFloatArray(geometryId + "-tex" + ai_to_string(a), mesh->mNumUVComponents[a] == 3 ? FloatType_TexCoord3 : FloatType_TexCoord2,
+                    (ai_real *)mesh->mTextureCoords[a], mesh->mNumVertices);
+        }
+    }
+
+    // vertex colors
+    for (size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
+        if (mesh->HasVertexColors(static_cast<unsigned int>(a)))
+            WriteFloatArray(geometryId + "-color" + ai_to_string(a), FloatType_Color, (ai_real *)mesh->mColors[a], mesh->mNumVertices);
+    }
+
+    // assemble vertex structure
+    // Only write input for POSITION since we will write other as shared inputs in polygon definition
+    mOutput << startstr << "<vertices id=\"" << geometryId << "-vertices"
+            << "\">" << endstr;
+    PushTag();
+    mOutput << startstr << "<input semantic=\"POSITION\" source=\"#" << geometryId << "-positions\" />" << endstr;
+    PopTag();
+    mOutput << startstr << "</vertices>" << endstr;
+
+    // count the number of lines, triangles and polygon meshes
+    int countLines = 0;
+    int countPoly = 0;
+    for (size_t a = 0; a < mesh->mNumFaces; ++a) {
+        if (mesh->mFaces[a].mNumIndices == 2)
+            countLines++;
+        else if (mesh->mFaces[a].mNumIndices >= 3)
+            countPoly++;
+    }
+
+    // lines
+    if (countLines) {
+        mOutput << startstr << "<lines count=\"" << countLines << "\" material=\"defaultMaterial\">" << endstr;
+        PushTag();
+        mOutput << startstr << "<input offset=\"0\" semantic=\"VERTEX\" source=\"#" << geometryId << "-vertices\" />" << endstr;
+        if (mesh->HasNormals())
+            mOutput << startstr << "<input semantic=\"NORMAL\" source=\"#" << geometryId << "-normals\" />" << endstr;
+        for (size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
+            if (mesh->HasTextureCoords(static_cast<unsigned int>(a)))
+                mOutput << startstr << "<input semantic=\"TEXCOORD\" source=\"#" << geometryId << "-tex" << a << "\" "
+                        << "set=\"" << a << "\""
+                        << " />" << endstr;
+        }
+        for (size_t a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a) {
+            if (mesh->HasVertexColors(static_cast<unsigned int>(a)))
+                mOutput << startstr << "<input semantic=\"COLOR\" source=\"#" << geometryId << "-color" << a << "\" "
+                        << "set=\"" << a << "\""
+                        << " />" << endstr;
+        }
+
+        mOutput << startstr << "<p>";
+        for (size_t a = 0; a < mesh->mNumFaces; ++a) {
+            const aiFace &face = mesh->mFaces[a];
+            if (face.mNumIndices != 2) continue;
+            for (size_t b = 0; b < face.mNumIndices; ++b)
+                mOutput << face.mIndices[b] << " ";
+        }
+        mOutput << "</p>" << endstr;
+        PopTag();
+        mOutput << startstr << "</lines>" << endstr;
+    }
+
+    // triangle - don't use it, because compatibility problems
+
+    // polygons
+    if (countPoly) {
+        mOutput << startstr << "<polylist count=\"" << countPoly << "\" material=\"defaultMaterial\">" << endstr;
+        PushTag();
+        mOutput << startstr << "<input offset=\"0\" semantic=\"VERTEX\" source=\"#" << geometryId << "-vertices\" />" << endstr;
+        if (mesh->HasNormals())
+            mOutput << startstr << "<input offset=\"0\" semantic=\"NORMAL\" source=\"#" << geometryId << "-normals\" />" << endstr;
+        for (size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
+            if (mesh->HasTextureCoords(static_cast<unsigned int>(a)))
+                mOutput << startstr << "<input offset=\"0\" semantic=\"TEXCOORD\" source=\"#" << geometryId << "-tex" << a << "\" "
+                        << "set=\"" << a << "\""
+                        << " />" << endstr;
+        }
+        for (size_t a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a) {
+            if (mesh->HasVertexColors(static_cast<unsigned int>(a)))
+                mOutput << startstr << "<input offset=\"0\" semantic=\"COLOR\" source=\"#" << geometryId << "-color" << a << "\" "
+                        << "set=\"" << a << "\""
+                        << " />" << endstr;
+        }
+
+        mOutput << startstr << "<vcount>";
+        for (size_t a = 0; a < mesh->mNumFaces; ++a) {
+            if (mesh->mFaces[a].mNumIndices < 3) continue;
+            mOutput << mesh->mFaces[a].mNumIndices << " ";
+        }
+        mOutput << "</vcount>" << endstr;
+
+        mOutput << startstr << "<p>";
+        for (size_t a = 0; a < mesh->mNumFaces; ++a) {
+            const aiFace &face = mesh->mFaces[a];
+            if (face.mNumIndices < 3) continue;
+            for (size_t b = 0; b < face.mNumIndices; ++b)
+                mOutput << face.mIndices[b] << " ";
+        }
+        mOutput << "</p>" << endstr;
+        PopTag();
+        mOutput << startstr << "</polylist>" << endstr;
+    }
+
+    // closing tags
+    PopTag();
+    mOutput << startstr << "</mesh>" << endstr;
+    PopTag();
+    mOutput << startstr << "</geometry>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes a float array of the given type
+void ColladaExporter::WriteFloatArray(const std::string &pIdString, FloatDataType pType, const ai_real *pData, size_t pElementCount) {
+    size_t floatsPerElement = 0;
+    switch (pType) {
+    case FloatType_Vector: floatsPerElement = 3; break;
+    case FloatType_TexCoord2: floatsPerElement = 2; break;
+    case FloatType_TexCoord3: floatsPerElement = 3; break;
+    case FloatType_Color: floatsPerElement = 3; break;
+    case FloatType_Mat4x4: floatsPerElement = 16; break;
+    case FloatType_Weight: floatsPerElement = 1; break;
+    case FloatType_Time: floatsPerElement = 1; break;
+    default:
+        return;
+    }
+
+    std::string arrayId = XMLIDEncode(pIdString) + "-array";
+
+    mOutput << startstr << "<source id=\"" << XMLIDEncode(pIdString) << "\" name=\"" << XMLEscape(pIdString) << "\">" << endstr;
+    PushTag();
+
+    // source array
+    mOutput << startstr << "<float_array id=\"" << arrayId << "\" count=\"" << pElementCount * floatsPerElement << "\"> ";
+    PushTag();
+
+    if (pType == FloatType_TexCoord2) {
+        for (size_t a = 0; a < pElementCount; ++a) {
+            mOutput << pData[a * 3 + 0] << " ";
+            mOutput << pData[a * 3 + 1] << " ";
+        }
+    } else if (pType == FloatType_Color) {
+        for (size_t a = 0; a < pElementCount; ++a) {
+            mOutput << pData[a * 4 + 0] << " ";
+            mOutput << pData[a * 4 + 1] << " ";
+            mOutput << pData[a * 4 + 2] << " ";
+        }
+    } else {
+        for (size_t a = 0; a < pElementCount * floatsPerElement; ++a)
+            mOutput << pData[a] << " ";
+    }
+    mOutput << "</float_array>" << endstr;
+    PopTag();
+
+    // the usual Collada fun. Let's bloat it even more!
+    mOutput << startstr << "<technique_common>" << endstr;
+    PushTag();
+    mOutput << startstr << "<accessor count=\"" << pElementCount << "\" offset=\"0\" source=\"#" << arrayId << "\" stride=\"" << floatsPerElement << "\">" << endstr;
+    PushTag();
+
+    switch (pType) {
+    case FloatType_Vector:
+        mOutput << startstr << "<param name=\"X\" type=\"float\" />" << endstr;
+        mOutput << startstr << "<param name=\"Y\" type=\"float\" />" << endstr;
+        mOutput << startstr << "<param name=\"Z\" type=\"float\" />" << endstr;
+        break;
+
+    case FloatType_TexCoord2:
+        mOutput << startstr << "<param name=\"S\" type=\"float\" />" << endstr;
+        mOutput << startstr << "<param name=\"T\" type=\"float\" />" << endstr;
+        break;
+
+    case FloatType_TexCoord3:
+        mOutput << startstr << "<param name=\"S\" type=\"float\" />" << endstr;
+        mOutput << startstr << "<param name=\"T\" type=\"float\" />" << endstr;
+        mOutput << startstr << "<param name=\"P\" type=\"float\" />" << endstr;
+        break;
+
+    case FloatType_Color:
+        mOutput << startstr << "<param name=\"R\" type=\"float\" />" << endstr;
+        mOutput << startstr << "<param name=\"G\" type=\"float\" />" << endstr;
+        mOutput << startstr << "<param name=\"B\" type=\"float\" />" << endstr;
+        break;
+
+    case FloatType_Mat4x4:
+        mOutput << startstr << "<param name=\"TRANSFORM\" type=\"float4x4\" />" << endstr;
+        break;
+
+    case FloatType_Weight:
+        mOutput << startstr << "<param name=\"WEIGHT\" type=\"float\" />" << endstr;
+        break;
+
+    // customized, add animation related
+    case FloatType_Time:
+        mOutput << startstr << "<param name=\"TIME\" type=\"float\" />" << endstr;
+        break;
+    }
+
+    PopTag();
+    mOutput << startstr << "</accessor>" << endstr;
+    PopTag();
+    mOutput << startstr << "</technique_common>" << endstr;
+    PopTag();
+    mOutput << startstr << "</source>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the scene library
+void ColladaExporter::WriteSceneLibrary() {
+    // Determine if we are using the aiScene root or our own
+    std::string sceneName("Scene");
+    if (mAdd_root_node) {
+        mSceneId = MakeUniqueId(mUniqueIds, sceneName, std::string());
+        mUniqueIds.insert(mSceneId);
+    } else {
+        mSceneId = GetNodeUniqueId(mScene->mRootNode);
+        sceneName = GetNodeName(mScene->mRootNode);
+    }
+
+    mOutput << startstr << "<library_visual_scenes>" << endstr;
+    PushTag();
+    mOutput << startstr << "<visual_scene id=\"" + mSceneId + "\" name=\"" + sceneName + "\">" << endstr;
+    PushTag();
+
+    if (mAdd_root_node) {
+        // Export the root node
+        WriteNode(mScene->mRootNode);
+    } else {
+        // Have already exported the root node
+        for (size_t a = 0; a < mScene->mRootNode->mNumChildren; ++a)
+            WriteNode(mScene->mRootNode->mChildren[a]);
+    }
+
+    PopTag();
+    mOutput << startstr << "</visual_scene>" << endstr;
+    PopTag();
+    mOutput << startstr << "</library_visual_scenes>" << endstr;
+}
+// ------------------------------------------------------------------------------------------------
+void ColladaExporter::WriteAnimationLibrary(size_t pIndex) {
+    const aiAnimation *anim = mScene->mAnimations[pIndex];
+
+    if (anim->mNumChannels == 0 && anim->mNumMeshChannels == 0 && anim->mNumMorphMeshChannels == 0)
+        return;
+
+    const std::string animationNameEscaped = GetObjectName(AiObjectType::Animation, pIndex);
+    const std::string idstrEscaped = GetObjectUniqueId(AiObjectType::Animation, pIndex);
+
+    mOutput << startstr << "<animation id=\"" + idstrEscaped + "\" name=\"" + animationNameEscaped + "\">" << endstr;
+    PushTag();
+
+    std::string cur_node_idstr;
+    for (size_t a = 0; a < anim->mNumChannels; ++a) {
+        const aiNodeAnim *nodeAnim = anim->mChannels[a];
+
+        // sanity check
+        if (nodeAnim->mNumPositionKeys != nodeAnim->mNumScalingKeys || nodeAnim->mNumPositionKeys != nodeAnim->mNumRotationKeys) {
+            continue;
+        }
+
+        {
+            cur_node_idstr.clear();
+            cur_node_idstr += nodeAnim->mNodeName.data;
+            cur_node_idstr += std::string("_matrix-input");
+
+            std::vector<ai_real> frames;
+            for (size_t i = 0; i < nodeAnim->mNumPositionKeys; ++i) {
+                frames.push_back(static_cast<ai_real>(nodeAnim->mPositionKeys[i].mTime));
+            }
+
+            WriteFloatArray(cur_node_idstr, FloatType_Time, (const ai_real *)frames.data(), frames.size());
+            frames.clear();
+        }
+
+        {
+            cur_node_idstr.clear();
+
+            cur_node_idstr += nodeAnim->mNodeName.data;
+            cur_node_idstr += std::string("_matrix-output");
+
+            std::vector<ai_real> keyframes;
+            keyframes.reserve(nodeAnim->mNumPositionKeys * 16);
+            for (size_t i = 0; i < nodeAnim->mNumPositionKeys; ++i) {
+                aiVector3D Scaling = nodeAnim->mScalingKeys[i].mValue;
+                aiMatrix4x4 ScalingM; // identity
+                ScalingM[0][0] = Scaling.x;
+                ScalingM[1][1] = Scaling.y;
+                ScalingM[2][2] = Scaling.z;
+
+                aiQuaternion RotationQ = nodeAnim->mRotationKeys[i].mValue;
+                aiMatrix4x4 s = aiMatrix4x4(RotationQ.GetMatrix());
+                aiMatrix4x4 RotationM(s.a1, s.a2, s.a3, 0, s.b1, s.b2, s.b3, 0, s.c1, s.c2, s.c3, 0, 0, 0, 0, 1);
+
+                aiVector3D Translation = nodeAnim->mPositionKeys[i].mValue;
+                aiMatrix4x4 TranslationM; // identity
+                TranslationM[0][3] = Translation.x;
+                TranslationM[1][3] = Translation.y;
+                TranslationM[2][3] = Translation.z;
+
+                // Combine the above transformations
+                aiMatrix4x4 mat = TranslationM * RotationM * ScalingM;
+
+                for (unsigned int j = 0; j < 4; ++j) {
+                    keyframes.insert(keyframes.end(), mat[j], mat[j] + 4);
+                }
+            }
+
+            WriteFloatArray(cur_node_idstr, FloatType_Mat4x4, (const ai_real *)keyframes.data(), keyframes.size() / 16);
+        }
+
+        {
+            std::vector<std::string> names;
+            for (size_t i = 0; i < nodeAnim->mNumPositionKeys; ++i) {
+                if (nodeAnim->mPreState == aiAnimBehaviour_DEFAULT || nodeAnim->mPreState == aiAnimBehaviour_LINEAR || nodeAnim->mPreState == aiAnimBehaviour_REPEAT) {
+                    names.push_back("LINEAR");
+                } else if (nodeAnim->mPostState == aiAnimBehaviour_CONSTANT) {
+                    names.push_back("STEP");
+                }
+            }
+
+            const std::string cur_node_idstr2 = nodeAnim->mNodeName.data + std::string("_matrix-interpolation");
+            std::string arrayId = XMLIDEncode(cur_node_idstr2) + "-array";
+
+            mOutput << startstr << "<source id=\"" << XMLIDEncode(cur_node_idstr2) << "\">" << endstr;
+            PushTag();
+
+            // source array
+            mOutput << startstr << "<Name_array id=\"" << arrayId << "\" count=\"" << names.size() << "\"> ";
+            for (size_t aa = 0; aa < names.size(); ++aa) {
+                mOutput << names[aa] << " ";
+            }
+            mOutput << "</Name_array>" << endstr;
+
+            mOutput << startstr << "<technique_common>" << endstr;
+            PushTag();
+
+            mOutput << startstr << "<accessor source=\"#" << arrayId << "\" count=\"" << names.size() << "\" stride=\"" << 1 << "\">" << endstr;
+            PushTag();
+
+            mOutput << startstr << "<param name=\"INTERPOLATION\" type=\"name\"></param>" << endstr;
+
+            PopTag();
+            mOutput << startstr << "</accessor>" << endstr;
+
+            PopTag();
+            mOutput << startstr << "</technique_common>" << endstr;
+
+            PopTag();
+            mOutput << startstr << "</source>" << endstr;
+        }
+    }
+
+    for (size_t a = 0; a < anim->mNumChannels; ++a) {
+        const aiNodeAnim *nodeAnim = anim->mChannels[a];
+
+        {
+            // samplers
+            const std::string node_idstr = nodeAnim->mNodeName.data + std::string("_matrix-sampler");
+            mOutput << startstr << "<sampler id=\"" << XMLIDEncode(node_idstr) << "\">" << endstr;
+            PushTag();
+
+            mOutput << startstr << "<input semantic=\"INPUT\" source=\"#" << XMLIDEncode(nodeAnim->mNodeName.data + std::string("_matrix-input")) << "\"/>" << endstr;
+            mOutput << startstr << "<input semantic=\"OUTPUT\" source=\"#" << XMLIDEncode(nodeAnim->mNodeName.data + std::string("_matrix-output")) << "\"/>" << endstr;
+            mOutput << startstr << "<input semantic=\"INTERPOLATION\" source=\"#" << XMLIDEncode(nodeAnim->mNodeName.data + std::string("_matrix-interpolation")) << "\"/>" << endstr;
+
+            PopTag();
+            mOutput << startstr << "</sampler>" << endstr;
+        }
+    }
+
+    for (size_t a = 0; a < anim->mNumChannels; ++a) {
+        const aiNodeAnim *nodeAnim = anim->mChannels[a];
+
+        {
+            // channels
+            mOutput << startstr << "<channel source=\"#" << XMLIDEncode(nodeAnim->mNodeName.data + std::string("_matrix-sampler")) << "\" target=\"" << XMLIDEncode(nodeAnim->mNodeName.data) << "/matrix\"/>" << endstr;
+        }
+    }
+
+    PopTag();
+    mOutput << startstr << "</animation>" << endstr;
+}
+// ------------------------------------------------------------------------------------------------
+void ColladaExporter::WriteAnimationsLibrary() {
+    if (mScene->mNumAnimations > 0) {
+        mOutput << startstr << "<library_animations>" << endstr;
+        PushTag();
+
+        // start recursive write at the root node
+        for (size_t a = 0; a < mScene->mNumAnimations; ++a)
+            WriteAnimationLibrary(a);
+
+        PopTag();
+        mOutput << startstr << "</library_animations>" << endstr;
+    }
+}
+// ------------------------------------------------------------------------------------------------
+// Helper to find a bone by name in the scene
+aiBone *findBone(const aiScene *scene, const aiString &name) {
+    for (size_t m = 0; m < scene->mNumMeshes; m++) {
+        aiMesh *mesh = scene->mMeshes[m];
+        for (size_t b = 0; b < mesh->mNumBones; b++) {
+            aiBone *bone = mesh->mBones[b];
+            if (name == bone->mName) {
+                return bone;
+            }
+        }
+    }
+    return nullptr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Helper to find the node associated with a bone in the scene
+const aiNode *findBoneNode(const aiNode *aNode, const aiBone *bone) {
+    if (aNode && bone && aNode->mName == bone->mName) {
+        return aNode;
+    }
+
+    if (aNode && bone) {
+        for (unsigned int i = 0; i < aNode->mNumChildren; ++i) {
+            aiNode *aChild = aNode->mChildren[i];
+            const aiNode *foundFromChild = nullptr;
+            if (aChild) {
+                foundFromChild = findBoneNode(aChild, bone);
+                if (foundFromChild) {
+                    return foundFromChild;
+                }
+            }
+        }
+    }
+
+    return nullptr;
+}
+
+const aiNode *findSkeletonRootNode(const aiScene *scene, const aiMesh *mesh) {
+    std::set<const aiNode *> topParentBoneNodes;
+    if (mesh && mesh->mNumBones > 0) {
+        for (unsigned int i = 0; i < mesh->mNumBones; ++i) {
+            aiBone *bone = mesh->mBones[i];
+
+            const aiNode *node = findBoneNode(scene->mRootNode, bone);
+            if (node) {
+                while (node->mParent && findBone(scene, node->mParent->mName) != nullptr) {
+                    node = node->mParent;
+                }
+                topParentBoneNodes.insert(node);
+            }
+        }
+    }
+
+    if (!topParentBoneNodes.empty()) {
+        const aiNode *parentBoneNode = *topParentBoneNodes.begin();
+        if (topParentBoneNodes.size() == 1) {
+            return parentBoneNode;
+        } else {
+            for (auto it : topParentBoneNodes) {
+                if (it->mParent) return it->mParent;
+            }
+            return parentBoneNode;
+        }
+    }
+
+    return nullptr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Recursively writes the given node
+void ColladaExporter::WriteNode(const aiNode *pNode) {
+    // If the node is associated with a bone, it is a joint node (JOINT)
+    // otherwise it is a normal node (NODE)
+    // Assimp-specific: nodes with no name cannot be associated with bones
+    const char *node_type;
+    bool is_joint, is_skeleton_root = false;
+    if (pNode->mName.length == 0 || nullptr == findBone(mScene, pNode->mName)) {
+        node_type = "NODE";
+        is_joint = false;
+    } else {
+        node_type = "JOINT";
+        is_joint = true;
+        if (!pNode->mParent || nullptr == findBone(mScene, pNode->mParent->mName)) {
+            is_skeleton_root = true;
+        }
+    }
+
+    const std::string node_id = GetNodeUniqueId(pNode);
+    const std::string node_name = GetNodeName(pNode);
+    mOutput << startstr << "<node ";
+    if (is_skeleton_root) {
+        mFoundSkeletonRootNodeID = node_id; // For now, only support one skeleton in a scene.
+    }
+    mOutput << "id=\"" << node_id << "\" " << (is_joint ? "sid=\"" + node_id + "\" " : "");
+    mOutput << "name=\"" << node_name
+            << "\" type=\"" << node_type
+            << "\">" << endstr;
+    PushTag();
+
+    // write transformation - we can directly put the matrix there
+    // TODO: (thom) decompose into scale - rot - quad to allow addressing it by animations afterwards
+    aiMatrix4x4 mat = pNode->mTransformation;
+
+    // If this node is a Camera node, the camera coordinate system needs to be multiplied in.
+    // When importing from Collada, the mLookAt is set to 0, 0, -1, and the node transform is unchanged.
+    // When importing from a different format, mLookAt is set to 0, 0, 1. Therefore, the local camera
+    // coordinate system must be changed to matche the Collada specification.
+    for (size_t i = 0; i < mScene->mNumCameras; i++) {
+        if (mScene->mCameras[i]->mName == pNode->mName) {
+            aiMatrix4x4 sourceView;
+            mScene->mCameras[i]->GetCameraMatrix(sourceView);
+
+            aiMatrix4x4 colladaView;
+            colladaView.a1 = colladaView.c3 = -1; // move into -z space.
+            mat *= (sourceView * colladaView);
+            break;
+        }
+    }
+
+    // customized, sid should be 'matrix' to match with loader code.
+    //mOutput << startstr << "<matrix sid=\"transform\">";
+    mOutput << startstr << "<matrix sid=\"matrix\">";
+
+    mOutput << mat.a1 << " " << mat.a2 << " " << mat.a3 << " " << mat.a4 << " ";
+    mOutput << mat.b1 << " " << mat.b2 << " " << mat.b3 << " " << mat.b4 << " ";
+    mOutput << mat.c1 << " " << mat.c2 << " " << mat.c3 << " " << mat.c4 << " ";
+    mOutput << mat.d1 << " " << mat.d2 << " " << mat.d3 << " " << mat.d4;
+    mOutput << "</matrix>" << endstr;
+
+    if (pNode->mNumMeshes == 0) {
+        //check if it is a camera node
+        for (size_t i = 0; i < mScene->mNumCameras; i++) {
+            if (mScene->mCameras[i]->mName == pNode->mName) {
+                mOutput << startstr << "<instance_camera url=\"#" << GetObjectUniqueId(AiObjectType::Camera, i) << "\"/>" << endstr;
+                break;
+            }
+        }
+        //check if it is a light node
+        for (size_t i = 0; i < mScene->mNumLights; i++) {
+            if (mScene->mLights[i]->mName == pNode->mName) {
+                mOutput << startstr << "<instance_light url=\"#" << GetObjectUniqueId(AiObjectType::Light, i) << "\"/>" << endstr;
+                break;
+            }
+        }
+
+    } else
+        // instance every geometry
+        for (size_t a = 0; a < pNode->mNumMeshes; ++a) {
+            const aiMesh *mesh = mScene->mMeshes[pNode->mMeshes[a]];
+            // do not instantiate mesh if empty. I wonder how this could happen
+            if (mesh->mNumFaces == 0 || mesh->mNumVertices == 0)
+                continue;
+
+            const std::string meshId = GetObjectUniqueId(AiObjectType::Mesh, pNode->mMeshes[a]);
+
+            if (mesh->mNumBones == 0) {
+                mOutput << startstr << "<instance_geometry url=\"#" << meshId << "\">" << endstr;
+                PushTag();
+            } else {
+                mOutput << startstr
+                        << "<instance_controller url=\"#" << meshId << "-skin\">"
+                        << endstr;
+                PushTag();
+
+                // note! this mFoundSkeletonRootNodeID some how affects animation, it makes the mesh attaches to armature skeleton root node.
+                // use the first bone to find skeleton root
+                const aiNode *skeletonRootBoneNode = findSkeletonRootNode(mScene, mesh);
+                if (skeletonRootBoneNode) {
+                    mFoundSkeletonRootNodeID = GetNodeUniqueId(skeletonRootBoneNode);
+                }
+                mOutput << startstr << "<skeleton>#" << mFoundSkeletonRootNodeID << "</skeleton>" << endstr;
+            }
+            mOutput << startstr << "<bind_material>" << endstr;
+            PushTag();
+            mOutput << startstr << "<technique_common>" << endstr;
+            PushTag();
+            mOutput << startstr << "<instance_material symbol=\"defaultMaterial\" target=\"#" << GetObjectUniqueId(AiObjectType::Material, mesh->mMaterialIndex) << "\">" << endstr;
+            PushTag();
+            for (size_t aa = 0; aa < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++aa) {
+                if (mesh->HasTextureCoords(static_cast<unsigned int>(aa)))
+                    // semantic       as in <texture texcoord=...>
+                    // input_semantic as in <input semantic=...>
+                    // input_set      as in <input set=...>
+                    mOutput << startstr << "<bind_vertex_input semantic=\"CHANNEL" << aa << "\" input_semantic=\"TEXCOORD\" input_set=\"" << aa << "\"/>" << endstr;
+            }
+            PopTag();
+            mOutput << startstr << "</instance_material>" << endstr;
+            PopTag();
+            mOutput << startstr << "</technique_common>" << endstr;
+            PopTag();
+            mOutput << startstr << "</bind_material>" << endstr;
+
+            PopTag();
+            if (mesh->mNumBones == 0)
+                mOutput << startstr << "</instance_geometry>" << endstr;
+            else
+                mOutput << startstr << "</instance_controller>" << endstr;
+        }
+
+    // recurse into subnodes
+    for (size_t a = 0; a < pNode->mNumChildren; ++a)
+        WriteNode(pNode->mChildren[a]);
+
+    PopTag();
+    mOutput << startstr << "</node>" << endstr;
+}
+
+void ColladaExporter::CreateNodeIds(const aiNode *node) {
+    GetNodeUniqueId(node);
+    for (size_t a = 0; a < node->mNumChildren; ++a)
+        CreateNodeIds(node->mChildren[a]);
+}
+
+std::string ColladaExporter::GetNodeUniqueId(const aiNode *node) {
+    // Use the pointer as the key. This is safe because the scene is immutable.
+    auto idIt = mNodeIdMap.find(node);
+    if (idIt != mNodeIdMap.cend())
+        return idIt->second;
+
+    // Prefer the requested Collada Id if extant
+    std::string idStr;
+    aiString origId;
+    if (node->mMetaData && node->mMetaData->Get(AI_METADATA_COLLADA_ID, origId)) {
+        idStr = origId.C_Str();
+    } else {
+        idStr = node->mName.C_Str();
+    }
+    // Make sure the requested id is valid
+    if (idStr.empty())
+        idStr = "node";
+    else
+        idStr = XMLIDEncode(idStr);
+
+    // Ensure it's unique
+    idStr = MakeUniqueId(mUniqueIds, idStr, std::string());
+    mUniqueIds.insert(idStr);
+    mNodeIdMap.insert(std::make_pair(node, idStr));
+    return idStr;
+}
+
+std::string ColladaExporter::GetNodeName(const aiNode *node) {
+
+    return XMLEscape(node->mName.C_Str());
+}
+
+std::string ColladaExporter::GetBoneUniqueId(const aiBone *bone) {
+    // Find the Node that is this Bone
+    const aiNode *boneNode = findBoneNode(mScene->mRootNode, bone);
+    if (boneNode == nullptr)
+        return std::string();
+
+    return GetNodeUniqueId(boneNode);
+}
+
+std::string ColladaExporter::GetObjectUniqueId(AiObjectType type, size_t pIndex) {
+    auto idIt = GetObjectIdMap(type).find(pIndex);
+    if (idIt != GetObjectIdMap(type).cend())
+        return idIt->second;
+
+    // Not seen this object before, create and add
+    NameIdPair result = AddObjectIndexToMaps(type, pIndex);
+    return result.second;
+}
+
+std::string ColladaExporter::GetObjectName(AiObjectType type, size_t pIndex) {
+    auto objectName = GetObjectNameMap(type).find(pIndex);
+    if (objectName != GetObjectNameMap(type).cend())
+        return objectName->second;
+
+    // Not seen this object before, create and add
+    NameIdPair result = AddObjectIndexToMaps(type, pIndex);
+    return result.first;
+}
+
+// Determine unique id and add the name and id to the maps
+// @param type object type
+// @param index object index
+// @param name in/out. Caller to set the original name if known.
+// @param idStr in/out. Caller to set the preferred id if known.
+ColladaExporter::NameIdPair ColladaExporter::AddObjectIndexToMaps(AiObjectType type, size_t index) {
+
+    std::string name;
+    std::string idStr;
+    std::string idPostfix;
+
+    // Get the name and id postfix
+    switch (type) {
+    case AiObjectType::Mesh: name = mScene->mMeshes[index]->mName.C_Str(); break;
+    case AiObjectType::Material: name = mScene->mMaterials[index]->GetName().C_Str(); break;
+    case AiObjectType::Animation: name = mScene->mAnimations[index]->mName.C_Str(); break;
+    case AiObjectType::Light:
+        name = mScene->mLights[index]->mName.C_Str();
+        idPostfix = "-light";
+        break;
+    case AiObjectType::Camera:
+        name = mScene->mCameras[index]->mName.C_Str();
+        idPostfix = "-camera";
+        break;
+    case AiObjectType::Count: throw std::logic_error("ColladaExporter::AiObjectType::Count is not an object type");
+    }
+
+    if (name.empty()) {
+        // Default ids if empty name
+        switch (type) {
+        case AiObjectType::Mesh: idStr = std::string("mesh_"); break;
+        case AiObjectType::Material: idStr = std::string("material_"); break; // This one should never happen
+        case AiObjectType::Animation: idStr = std::string("animation_"); break;
+        case AiObjectType::Light: idStr = std::string("light_"); break;
+        case AiObjectType::Camera: idStr = std::string("camera_"); break;
+        case AiObjectType::Count: throw std::logic_error("ColladaExporter::AiObjectType::Count is not an object type");
+        }
+        idStr.append(ai_to_string(index));
+    } else {
+        idStr = XMLIDEncode(name);
+    }
+
+    if (!name.empty())
+        name = XMLEscape(name);
+
+    idStr = MakeUniqueId(mUniqueIds, idStr, idPostfix);
+
+    // Add to maps
+    mUniqueIds.insert(idStr);
+    GetObjectIdMap(type).insert(std::make_pair(index, idStr));
+    GetObjectNameMap(type).insert(std::make_pair(index, name));
+
+    return std::make_pair(name, idStr);
+}
+
+} // end of namespace Assimp
+
+#endif
+#endif
diff --git a/Engine/lib/assimp/code/AssetLib/Collada/ColladaExporter.h b/Engine/lib/assimp/code/AssetLib/Collada/ColladaExporter.h
new file mode 100644
index 000000000..56415fba7
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Collada/ColladaExporter.h
@@ -0,0 +1,257 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file ColladaExporter.h
+ * Declares the exporter class to write a scene to a Collada file
+ */
+#ifndef AI_COLLADAEXPORTER_H_INC
+#define AI_COLLADAEXPORTER_H_INC
+
+#include <assimp/ai_assert.h>
+#include <assimp/material.h>
+
+#include <array>
+#include <map>
+#include <sstream>
+#include <unordered_set>
+#include <vector>
+
+struct aiScene;
+struct aiNode;
+struct aiLight;
+struct aiBone;
+
+namespace Assimp {
+
+class IOSystem;
+
+/// Helper class to export a given scene to a Collada file. Just for my personal
+/// comfort when implementing it.
+class ColladaExporter {
+public:
+    /// Constructor for a specific scene to export
+    ColladaExporter(const aiScene *pScene, IOSystem *pIOSystem, const std::string &path, const std::string &file);
+
+    /// Destructor
+    virtual ~ColladaExporter();
+
+protected:
+    /// Starts writing the contents
+    void WriteFile();
+
+    /// Writes the asset header
+    void WriteHeader();
+
+    /// Writes the embedded textures
+    void WriteTextures();
+
+    /// Writes the material setup
+    void WriteMaterials();
+
+    /// Writes the cameras library
+    void WriteCamerasLibrary();
+
+    // Write a camera entry
+    void WriteCamera(size_t pIndex);
+
+    /// Writes the cameras library
+    void WriteLightsLibrary();
+
+    // Write a camera entry
+    void WriteLight(size_t pIndex);
+    void WritePointLight(const aiLight *const light);
+    void WriteDirectionalLight(const aiLight *const light);
+    void WriteSpotLight(const aiLight *const light);
+    void WriteAmbienttLight(const aiLight *const light);
+
+    /// Writes the controller library
+    void WriteControllerLibrary();
+
+    /// Writes a skin controller of the given mesh
+    void WriteController(size_t pIndex);
+
+    /// Writes the geometry library
+    void WriteGeometryLibrary();
+
+    /// Writes the given mesh
+    void WriteGeometry(size_t pIndex);
+
+    //enum FloatDataType { FloatType_Vector, FloatType_TexCoord2, FloatType_TexCoord3, FloatType_Color, FloatType_Mat4x4, FloatType_Weight };
+    // customized to add animation related type
+    enum FloatDataType { FloatType_Vector,
+        FloatType_TexCoord2,
+        FloatType_TexCoord3,
+        FloatType_Color,
+        FloatType_Mat4x4,
+        FloatType_Weight,
+        FloatType_Time };
+
+    /// Writes a float array of the given type
+    void WriteFloatArray(const std::string &pIdString, FloatDataType pType, const ai_real *pData, size_t pElementCount);
+
+    /// Writes the scene library
+    void WriteSceneLibrary();
+
+    // customized, Writes the animation library
+    void WriteAnimationsLibrary();
+    void WriteAnimationLibrary(size_t pIndex);
+    std::string mFoundSkeletonRootNodeID = "skeleton_root"; // will be replaced by found node id in the WriteNode call.
+
+    /// Recursively writes the given node
+    void WriteNode(const aiNode *pNode);
+
+    /// Enters a new xml element, which increases the indentation
+    void PushTag() { startstr.append("  "); }
+    /// Leaves an element, decreasing the indentation
+    void PopTag() {
+        ai_assert(startstr.length() > 1);
+        startstr.erase(startstr.length() - 2);
+    }
+
+    void CreateNodeIds(const aiNode *node);
+
+    /// Get or Create a unique Node ID string for the given Node
+    std::string GetNodeUniqueId(const aiNode *node);
+    std::string GetNodeName(const aiNode *node);
+
+    std::string GetBoneUniqueId(const aiBone *bone);
+
+    enum class AiObjectType {
+        Mesh,
+        Material,
+        Animation,
+        Light,
+        Camera,
+        Count,
+    };
+    /// Get or Create a unique ID string for the given scene object index
+    std::string GetObjectUniqueId(AiObjectType type, size_t pIndex);
+    /// Get or Create a name string for the given scene object index
+    std::string GetObjectName(AiObjectType type, size_t pIndex);
+
+    typedef std::map<size_t, std::string> IndexIdMap;
+    typedef std::pair<std::string, std::string> NameIdPair;
+    NameIdPair AddObjectIndexToMaps(AiObjectType type, size_t pIndex);
+
+    // Helpers
+    inline IndexIdMap &GetObjectIdMap(AiObjectType type) { return mObjectIdMap[static_cast<size_t>(type)]; }
+    inline IndexIdMap &GetObjectNameMap(AiObjectType type) { return mObjectNameMap[static_cast<size_t>(type)]; }
+
+private:
+    std::unordered_set<std::string> mUniqueIds; // Cache of used unique ids
+    std::map<const void *, std::string> mNodeIdMap; // Cache of encoded node and bone ids
+    std::array<IndexIdMap, static_cast<size_t>(AiObjectType::Count)> mObjectIdMap; // Cache of encoded unique IDs
+    std::array<IndexIdMap, static_cast<size_t>(AiObjectType::Count)> mObjectNameMap; // Cache of encoded names
+
+public:
+    /// Stringstream to write all output into
+    std::stringstream mOutput;
+
+    /// The IOSystem for output
+    IOSystem *mIOSystem;
+
+    /// Path of the directory where the scene will be exported
+    const std::string mPath;
+
+    /// Name of the file (without extension) where the scene will be exported
+    const std::string mFile;
+
+    /// The scene to be written
+    const aiScene *const mScene;
+    std::string mSceneId;
+    bool mAdd_root_node = false;
+
+    /// current line start string, contains the current indentation for simple stream insertion
+    std::string startstr;
+    /// current line end string for simple stream insertion
+    const std::string endstr;
+
+    // pair of color and texture - texture precedences color
+    struct Surface {
+        bool exist;
+        aiColor4D color;
+        std::string texture;
+        size_t channel;
+        Surface() {
+            exist = false;
+            channel = 0;
+        }
+    };
+
+    struct Property {
+        bool exist;
+        ai_real value;
+        Property() :
+                exist(false),
+                value(0.0) {}
+    };
+
+    // summarize a material in an convenient way.
+    struct Material {
+        std::string id;
+        std::string name;
+        std::string shading_model;
+        Surface ambient, diffuse, specular, emissive, reflective, transparent, normal;
+        Property shininess, transparency, index_refraction;
+
+        Material() {}
+    };
+
+    std::map<unsigned int, std::string> textures;
+
+public:
+    /// Dammit C++ - y u no compile two-pass? No I have to add all methods below the struct definitions
+    /// Reads a single surface entry from the given material keys
+    bool ReadMaterialSurface(Surface &poSurface, const aiMaterial &pSrcMat, aiTextureType pTexture, const char *pKey, size_t pType, size_t pIndex);
+    /// Writes an image entry for the given surface
+    void WriteImageEntry(const Surface &pSurface, const std::string &imageId);
+    /// Writes the two parameters necessary for referencing a texture in an effect entry
+    void WriteTextureParamEntry(const Surface &pSurface, const std::string &pTypeName, const std::string &materialId);
+    /// Writes a color-or-texture entry into an effect definition
+    void WriteTextureColorEntry(const Surface &pSurface, const std::string &pTypeName, const std::string &imageId);
+    /// Writes a scalar property
+    void WriteFloatEntry(const Property &pProperty, const std::string &pTypeName);
+};
+
+} // namespace Assimp
+
+#endif // !! AI_COLLADAEXPORTER_H_INC
diff --git a/Engine/lib/assimp/code/AssetLib/Collada/ColladaHelper.cpp b/Engine/lib/assimp/code/AssetLib/Collada/ColladaHelper.cpp
new file mode 100644
index 000000000..0fb172fbb
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Collada/ColladaHelper.cpp
@@ -0,0 +1,99 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+/** Helper structures for the Collada loader */
+
+#include "ColladaHelper.h"
+
+#include <assimp/ParsingUtils.h>
+#include <assimp/commonMetaData.h>
+
+namespace Assimp {
+namespace Collada {
+
+const MetaKeyPairVector MakeColladaAssimpMetaKeys() {
+    MetaKeyPairVector result;
+    result.emplace_back("authoring_tool", AI_METADATA_SOURCE_GENERATOR);
+    result.emplace_back("copyright", AI_METADATA_SOURCE_COPYRIGHT);
+    return result;
+}
+
+const MetaKeyPairVector &GetColladaAssimpMetaKeys() {
+    static const MetaKeyPairVector result = MakeColladaAssimpMetaKeys();
+    return result;
+}
+
+const MetaKeyPairVector MakeColladaAssimpMetaKeysCamelCase() {
+    MetaKeyPairVector result = MakeColladaAssimpMetaKeys();
+    for (auto &val : result) {
+        ToCamelCase(val.first);
+    }
+    return result;
+}
+
+const MetaKeyPairVector &GetColladaAssimpMetaKeysCamelCase() {
+    static const MetaKeyPairVector result = MakeColladaAssimpMetaKeysCamelCase();
+    return result;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Convert underscore_separated to CamelCase: "authoring_tool" becomes "AuthoringTool"
+void ToCamelCase(std::string &text) {
+    if (text.empty())
+        return;
+    // Capitalise first character
+    auto it = text.begin();
+    (*it) = ai_toupper(*it);
+    ++it;
+    for (/*started above*/; it != text.end(); /*iterated below*/) {
+        if ((*it) == '_') {
+            it = text.erase(it);
+            if (it != text.end())
+                (*it) = ai_toupper(*it);
+        } else {
+            // Make lower case
+            (*it) = ai_tolower(*it);
+            ++it;
+        }
+    }
+}
+
+} // namespace Collada
+} // namespace Assimp
diff --git a/Engine/lib/assimp/code/AssetLib/Collada/ColladaHelper.h b/Engine/lib/assimp/code/AssetLib/Collada/ColladaHelper.h
new file mode 100644
index 000000000..31d7b5ae5
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Collada/ColladaHelper.h
@@ -0,0 +1,679 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** Helper structures for the Collada loader */
+
+#ifndef AI_COLLADAHELPER_H_INC
+#define AI_COLLADAHELPER_H_INC
+
+#include <assimp/light.h>
+#include <assimp/material.h>
+#include <assimp/mesh.h>
+
+#include <cstdint>
+#include <map>
+#include <set>
+#include <vector>
+
+struct aiMaterial;
+
+namespace Assimp {
+namespace Collada {
+
+/// Collada file versions which evolved during the years ...
+enum FormatVersion {
+    FV_1_5_n,
+    FV_1_4_n,
+    FV_1_3_n
+};
+
+/// Transformation types that can be applied to a node
+enum TransformType {
+    TF_LOOKAT,
+    TF_ROTATE,
+    TF_TRANSLATE,
+    TF_SCALE,
+    TF_SKEW,
+    TF_MATRIX
+};
+
+/// Different types of input data to a vertex or face
+enum InputType {
+    IT_Invalid,
+    IT_Vertex, // special type for per-index data referring to the <vertices> element carrying the per-vertex data.
+    IT_Position,
+    IT_Normal,
+    IT_Texcoord,
+    IT_Color,
+    IT_Tangent,
+    IT_Bitangent
+};
+
+/// Supported controller types
+enum ControllerType {
+    Skin,
+    Morph
+};
+
+/// Supported morph methods
+enum MorphMethod {
+    Normalized,
+    Relative
+};
+
+/// Common metadata keys as <Collada, Assimp>
+using MetaKeyPair = std::pair<std::string, std::string>;
+using MetaKeyPairVector = std::vector<MetaKeyPair>;
+
+/// Collada as lower_case (native)
+const MetaKeyPairVector &GetColladaAssimpMetaKeys();
+
+// Collada as CamelCase (used by Assimp for consistency)
+const MetaKeyPairVector &GetColladaAssimpMetaKeysCamelCase();
+
+/// Convert underscore_separated to CamelCase "authoring_tool" becomes "AuthoringTool"
+void ToCamelCase(std::string &text);
+
+/// Contains all data for one of the different transformation types
+struct Transform {
+    std::string mID; ///< SID of the transform step, by which anim channels address their target node
+    TransformType mType;
+    ai_real f[16]; ///< Interpretation of data depends on the type of the transformation
+};
+
+/// A collada camera.
+struct Camera {
+    Camera() :
+            mOrtho(false),
+            mHorFov(10e10f),
+            mVerFov(10e10f),
+            mAspect(10e10f),
+            mZNear(0.1f),
+            mZFar(1000.f) {}
+
+    /// Name of camera
+    std::string mName;
+
+    /// True if it is an orthographic camera
+    bool mOrtho;
+
+    /// Horizontal field of view in degrees
+    ai_real mHorFov;
+
+    /// Vertical field of view in degrees
+    ai_real mVerFov;
+
+    /// Screen aspect
+    ai_real mAspect;
+
+    /// Near& far z
+    ai_real mZNear, mZFar;
+};
+
+#define ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET 1e9f
+
+/** A collada light source. */
+struct Light {
+    Light() :
+            mType(aiLightSource_UNDEFINED),
+            mAttConstant(1.f),
+            mAttLinear(0.f),
+            mAttQuadratic(0.f),
+            mFalloffAngle(180.f),
+            mFalloffExponent(0.f),
+            mPenumbraAngle(ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET),
+            mOuterAngle(ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET),
+            mIntensity(1.f) {}
+
+    /// Type of the light source aiLightSourceType + ambient
+    unsigned int mType;
+
+    /// Color of the light
+    aiColor3D mColor;
+
+    /// Light attenuation
+    ai_real mAttConstant, mAttLinear, mAttQuadratic;
+
+    /// Spot light falloff
+    ai_real mFalloffAngle;
+    ai_real mFalloffExponent;
+
+    // -----------------------------------------------------
+    // FCOLLADA extension from here
+
+    /// ... related stuff from maja and max extensions
+    ai_real mPenumbraAngle;
+    ai_real mOuterAngle;
+
+    /// Common light intensity
+    ai_real mIntensity;
+};
+
+/** Short vertex index description */
+struct InputSemanticMapEntry {
+    InputSemanticMapEntry() :
+            mSet(0),
+            mType(IT_Invalid) {}
+
+    /// Index of set, optional
+    unsigned int mSet;
+
+    /// Type of referenced vertex input
+    InputType mType;
+};
+
+/// Table to map from effect to vertex input semantics
+struct SemanticMappingTable {
+    /// Name of material
+    std::string mMatName;
+
+    /// List of semantic map commands, grouped by effect semantic name
+    using InputSemanticMap = std::map<std::string, InputSemanticMapEntry>;
+    InputSemanticMap mMap;
+
+    /// For std::find
+    bool operator==(const std::string &s) const {
+        return s == mMatName;
+    }
+};
+
+/// A reference to a mesh inside a node, including materials assigned to the various subgroups.
+/// The ID refers to either a mesh or a controller which specifies the mesh
+struct MeshInstance {
+    ///< ID of the mesh or controller to be instanced
+    std::string mMeshOrController;
+
+    ///< Map of materials by the subgroup ID they're applied to
+    std::map<std::string, SemanticMappingTable> mMaterials;
+};
+
+/// A reference to a camera inside a node
+struct CameraInstance {
+    ///< ID of the camera
+    std::string mCamera;
+};
+
+/// A reference to a light inside a node
+struct LightInstance {
+    ///< ID of the camera
+    std::string mLight;
+};
+
+/// A reference to a node inside a node
+struct NodeInstance {
+    ///< ID of the node
+    std::string mNode;
+};
+
+/// A node in a scene hierarchy
+struct Node {
+    std::string mName;
+    std::string mID;
+    std::string mSID;
+    Node *mParent;
+    std::vector<Node *> mChildren;
+
+    /// Operations in order to calculate the resulting transformation to parent.
+    std::vector<Transform> mTransforms;
+
+    /// Meshes at this node
+    std::vector<MeshInstance> mMeshes;
+
+    /// Lights at this node
+    std::vector<LightInstance> mLights;
+
+    /// Cameras at this node
+    std::vector<CameraInstance> mCameras;
+
+    /// Node instances at this node
+    std::vector<NodeInstance> mNodeInstances;
+
+    /// Root-nodes: Name of primary camera, if any
+    std::string mPrimaryCamera;
+
+    /// Constructor. Begin with a zero parent
+    Node() :
+            mParent(nullptr) {
+        // empty
+    }
+
+    /// Destructor: delete all children subsequently
+    ~Node() {
+        for (std::vector<Node *>::iterator it = mChildren.begin(); it != mChildren.end(); ++it) {
+            delete *it;
+        }
+    }
+};
+
+/// Data source array: either floats or strings
+struct Data {
+    bool mIsStringArray;
+    std::vector<ai_real> mValues;
+    std::vector<std::string> mStrings;
+};
+
+/// Accessor to a data array
+struct Accessor {
+    size_t mCount; // in number of objects
+    size_t mSize; // size of an object, in elements (floats or strings, mostly 1)
+    size_t mOffset; // in number of values
+    size_t mStride; // Stride in number of values
+    std::vector<std::string> mParams; // names of the data streams in the accessors. Empty string tells to ignore.
+    size_t mSubOffset[4]; // Sub-offset inside the object for the common 4 elements. For a vector, that's XYZ, for a color RGBA and so on.
+            // For example, SubOffset[0] denotes which of the values inside the object is the vector X component.
+    std::string mSource; // URL of the source array
+    mutable const Data *mData; // Pointer to the source array, if resolved. nullptr else
+
+    Accessor() {
+        mCount = 0;
+        mSize = 0;
+        mOffset = 0;
+        mStride = 0;
+        mData = nullptr;
+        mSubOffset[0] = mSubOffset[1] = mSubOffset[2] = mSubOffset[3] = 0;
+    }
+};
+
+/// A single face in a mesh
+struct Face {
+    std::vector<size_t> mIndices;
+};
+
+/// An input channel for mesh data, referring to a single accessor
+struct InputChannel {
+    InputType mType; // Type of the data
+    size_t mIndex; // Optional index, if multiple sets of the same data type are given
+    size_t mOffset; // Index offset in the indices array of per-face indices. Don't ask, can't explain that any better.
+    std::string mAccessor; // ID of the accessor where to read the actual values from.
+    mutable const Accessor *mResolved; // Pointer to the accessor, if resolved. nullptr else
+
+    InputChannel() {
+        mType = IT_Invalid;
+        mIndex = 0;
+        mOffset = 0;
+        mResolved = nullptr;
+    }
+};
+
+/// Subset of a mesh with a certain material
+struct SubMesh {
+    std::string mMaterial; ///< subgroup identifier
+    size_t mNumFaces; ///< number of faces in this sub-mesh
+};
+
+/// Contains data for a single mesh
+struct Mesh {
+    Mesh(const std::string &id) :
+            mId(id) {
+        for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
+            mNumUVComponents[i] = 2;
+        }
+    }
+
+    const std::string mId;
+    std::string mName;
+
+    // just to check if there's some sophisticated addressing involved...
+    // which we don't support, and therefore should warn about.
+    std::string mVertexID;
+
+    // Vertex data addressed by vertex indices
+    std::vector<InputChannel> mPerVertexData;
+
+    // actual mesh data, assembled on encounter of a <p> element. Verbose format, not indexed
+    std::vector<aiVector3D> mPositions;
+    std::vector<aiVector3D> mNormals;
+    std::vector<aiVector3D> mTangents;
+    std::vector<aiVector3D> mBitangents;
+    std::vector<aiVector3D> mTexCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS];
+    std::vector<aiColor4D> mColors[AI_MAX_NUMBER_OF_COLOR_SETS];
+
+    unsigned int mNumUVComponents[AI_MAX_NUMBER_OF_TEXTURECOORDS];
+
+    // Faces. Stored are only the number of vertices for each face.
+    // 1 == point, 2 == line, 3 == triangle, 4+ == poly
+    std::vector<size_t> mFaceSize;
+
+    // Position indices for all faces in the sequence given in mFaceSize -
+    // necessary for bone weight assignment
+    std::vector<size_t> mFacePosIndices;
+
+    // Sub-meshes in this mesh, each with a given material
+    std::vector<SubMesh> mSubMeshes;
+};
+
+/// Which type of primitives the ReadPrimitives() function is going to read
+enum PrimitiveType {
+    Prim_Invalid,
+    Prim_Lines,
+    Prim_LineStrip,
+    Prim_Triangles,
+    Prim_TriStrips,
+    Prim_TriFans,
+    Prim_Polylist,
+    Prim_Polygon
+};
+
+/// A skeleton controller to deform a mesh with the use of joints
+struct Controller {
+    // controller type
+    ControllerType mType;
+
+    // Morphing method if type is Morph
+    MorphMethod mMethod;
+
+    // the URL of the mesh deformed by the controller.
+    std::string mMeshId;
+
+    // accessor URL of the joint names
+    std::string mJointNameSource;
+
+    ///< The bind shape matrix, as array of floats. I'm not sure what this matrix actually describes, but it can't be ignored in all cases
+    ai_real mBindShapeMatrix[16];
+
+    // accessor URL of the joint inverse bind matrices
+    std::string mJointOffsetMatrixSource;
+
+    // input channel: joint names.
+    InputChannel mWeightInputJoints;
+    // input channel: joint weights
+    InputChannel mWeightInputWeights;
+
+    // Number of weights per vertex.
+    std::vector<size_t> mWeightCounts;
+
+    // JointIndex-WeightIndex pairs for all vertices
+    std::vector<std::pair<size_t, size_t>> mWeights;
+
+    std::string mMorphTarget;
+    std::string mMorphWeight;
+};
+
+/// A collada material. Pretty much the only member is a reference to an effect.
+struct Material {
+    std::string mName;
+    std::string mEffect;
+};
+
+/// Type of the effect param
+enum ParamType {
+    Param_Sampler,
+    Param_Surface
+};
+
+/// A param for an effect. Might be of several types, but they all just refer to each other, so I summarize them
+struct EffectParam {
+    ParamType mType;
+    std::string mReference; // to which other thing the param is referring to.
+};
+
+/// Shading type supported by the standard effect spec of Collada
+enum ShadeType {
+    Shade_Invalid,
+    Shade_Constant,
+    Shade_Lambert,
+    Shade_Phong,
+    Shade_Blinn
+};
+
+/// Represents a texture sampler in collada
+struct Sampler {
+    Sampler() :
+            mWrapU(true),
+            mWrapV(true),
+            mMirrorU(),
+            mMirrorV(),
+            mOp(aiTextureOp_Multiply),
+            mUVId(UINT_MAX),
+            mWeighting(1.f),
+            mMixWithPrevious(1.f) {}
+
+    /// Name of image reference
+    std::string mName;
+
+    /// Wrap U?
+    bool mWrapU;
+
+    /// Wrap V?
+    bool mWrapV;
+
+    /// Mirror U?
+    bool mMirrorU;
+
+    /// Mirror V?
+    bool mMirrorV;
+
+    /// Blend mode
+    aiTextureOp mOp;
+
+    /// UV transformation
+    aiUVTransform mTransform;
+
+    /// Name of source UV channel
+    std::string mUVChannel;
+
+    /// Resolved UV channel index or UINT_MAX if not known
+    unsigned int mUVId;
+
+    // OKINO/MAX3D extensions from here
+    // -------------------------------------------------------
+
+    /// Weighting factor
+    ai_real mWeighting;
+
+    /// Mixing factor from OKINO
+    ai_real mMixWithPrevious;
+};
+
+/// A collada effect. Can contain about anything according to the Collada spec,
+/// but we limit our version to a reasonable subset.
+struct Effect {
+    /// Shading mode
+    ShadeType mShadeType;
+
+    /// Colors
+    aiColor4D mEmissive, mAmbient, mDiffuse, mSpecular,
+            mTransparent, mReflective;
+
+    /// Textures
+    Sampler mTexEmissive, mTexAmbient, mTexDiffuse, mTexSpecular,
+            mTexTransparent, mTexBump, mTexReflective;
+
+    /// Scalar factory
+    ai_real mShininess, mRefractIndex, mReflectivity;
+    ai_real mTransparency;
+    bool mHasTransparency;
+    bool mRGBTransparency;
+    bool mInvertTransparency;
+
+    /// local params referring to each other by their SID
+    using ParamLibrary = std::map<std::string, Collada::EffectParam>;
+    ParamLibrary mParams;
+
+    // MAX3D extensions
+    // ---------------------------------------------------------
+    // Double-sided?
+    bool mDoubleSided, mWireframe, mFaceted;
+
+    Effect() :
+            mShadeType(Shade_Phong),
+            mEmissive(0, 0, 0, 1),
+            mAmbient(0.1f, 0.1f, 0.1f, 1),
+            mDiffuse(0.6f, 0.6f, 0.6f, 1),
+            mSpecular(0.4f, 0.4f, 0.4f, 1),
+            mTransparent(0, 0, 0, 1),
+            mShininess(10.0f),
+            mRefractIndex(1.f),
+            mReflectivity(0.f),
+            mTransparency(1.f),
+            mHasTransparency(false),
+            mRGBTransparency(false),
+            mInvertTransparency(false),
+            mDoubleSided(false),
+            mWireframe(false),
+            mFaceted(false) {
+    }
+};
+
+/// An image, meaning texture
+struct Image {
+    std::string mFileName;
+
+    /// Embedded image data
+    std::vector<uint8_t> mImageData;
+
+    /// File format hint of embedded image data
+    std::string mEmbeddedFormat;
+};
+
+/// An animation channel.
+struct AnimationChannel {
+    /// URL of the data to animate. Could be about anything, but we support only the
+    /// "NodeID/TransformID.SubElement" notation
+    std::string mTarget;
+
+    /// Source URL of the time values. Collada calls them "input". Meh.
+    std::string mSourceTimes;
+    /// Source URL of the value values. Collada calls them "output".
+    std::string mSourceValues;
+    /// Source URL of the IN_TANGENT semantic values.
+    std::string mInTanValues;
+    /// Source URL of the OUT_TANGENT semantic values.
+    std::string mOutTanValues;
+    /// Source URL of the INTERPOLATION semantic values.
+    std::string mInterpolationValues;
+};
+
+/// An animation. Container for 0-x animation channels or 0-x animations
+struct Animation {
+    /// Anim name
+    std::string mName;
+
+    /// the animation channels, if any
+    std::vector<AnimationChannel> mChannels;
+
+    /// the sub-animations, if any
+    std::vector<Animation *> mSubAnims;
+
+    /// Destructor
+    ~Animation() {
+        for (std::vector<Animation *>::iterator it = mSubAnims.begin(); it != mSubAnims.end(); ++it) {
+            delete *it;
+        }
+    }
+
+    /// Collect all channels in the animation hierarchy into a single channel list.
+    void CollectChannelsRecursively(std::vector<AnimationChannel> &channels) {
+        channels.insert(channels.end(), mChannels.begin(), mChannels.end());
+
+        for (std::vector<Animation *>::iterator it = mSubAnims.begin(); it != mSubAnims.end(); ++it) {
+            Animation *pAnim = (*it);
+            pAnim->CollectChannelsRecursively(channels);
+        }
+    }
+
+    /// Combine all single-channel animations' channel into the same (parent) animation channel list.
+    void CombineSingleChannelAnimations() {
+        CombineSingleChannelAnimationsRecursively(this);
+    }
+
+    void CombineSingleChannelAnimationsRecursively(Animation *pParent) {
+        std::set<std::string> childrenTargets;
+        bool childrenAnimationsHaveDifferentChannels = true;
+
+        for (std::vector<Animation *>::iterator it = pParent->mSubAnims.begin(); it != pParent->mSubAnims.end();) {
+            Animation *anim = *it;
+            CombineSingleChannelAnimationsRecursively(anim);
+
+            if (childrenAnimationsHaveDifferentChannels && anim->mChannels.size() == 1 &&
+                    childrenTargets.find(anim->mChannels[0].mTarget) == childrenTargets.end()) {
+                childrenTargets.insert(anim->mChannels[0].mTarget);
+            } else {
+                childrenAnimationsHaveDifferentChannels = false;
+            }
+
+            ++it;
+        }
+
+        // We only want to combine animations if they have different channels
+        if (childrenAnimationsHaveDifferentChannels) {
+            for (std::vector<Animation *>::iterator it = pParent->mSubAnims.begin(); it != pParent->mSubAnims.end();) {
+                Animation *anim = *it;
+
+                pParent->mChannels.push_back(anim->mChannels[0]);
+
+                it = pParent->mSubAnims.erase(it);
+
+                delete anim;
+                continue;
+            }
+        }
+    }
+};
+
+/// Description of a collada animation channel which has been determined to affect the current node
+struct ChannelEntry {
+    const Collada::AnimationChannel *mChannel; ///< the source channel
+    std::string mTargetId;
+    std::string mTransformId; // the ID of the transformation step of the node which is influenced
+    size_t mTransformIndex; // Index into the node's transform chain to apply the channel to
+    size_t mSubElement; // starting index inside the transform data
+
+    // resolved data references
+    const Collada::Accessor *mTimeAccessor; ///> Collada accessor to the time values
+    const Collada::Data *mTimeData; ///> Source data array for the time values
+    const Collada::Accessor *mValueAccessor; ///> Collada accessor to the key value values
+    const Collada::Data *mValueData; ///> Source datat array for the key value values
+
+    ChannelEntry() :
+            mChannel(),
+            mTransformIndex(),
+            mSubElement(),
+            mTimeAccessor(),
+            mTimeData(),
+            mValueAccessor(),
+            mValueData() {}
+};
+
+} // end of namespace Collada
+} // end of namespace Assimp
+
+#endif // AI_COLLADAHELPER_H_INC
diff --git a/Engine/lib/assimp/code/Collada/ColladaLoader.cpp b/Engine/lib/assimp/code/AssetLib/Collada/ColladaLoader.cpp
similarity index 69%
rename from Engine/lib/assimp/code/Collada/ColladaLoader.cpp
rename to Engine/lib/assimp/code/AssetLib/Collada/ColladaLoader.cpp
index 0fbc7d599..775ba44d2 100644
--- a/Engine/lib/assimp/code/Collada/ColladaLoader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/Collada/ColladaLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -45,29 +45,24 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "ColladaLoader.h"
 #include "ColladaParser.h"
-
+#include <assimp/ColladaMetaData.h>
+#include <assimp/CreateAnimMesh.h>
+#include <assimp/ParsingUtils.h>
+#include <assimp/SkeletonMeshBuilder.h>
+#include <assimp/ZipArchiveIOSystem.h>
 #include <assimp/anim.h>
+#include <assimp/fast_atof.h>
+#include <assimp/importerdesc.h>
 #include <assimp/scene.h>
 #include <assimp/DefaultLogger.hpp>
 #include <assimp/Importer.hpp>
-#include <assimp/importerdesc.h>
-#include <assimp/Defines.h>
 
-#include <assimp/fast_atof.h>
-#include <assimp/ParsingUtils.h>
-#include <assimp/SkeletonMeshBuilder.h>
-#include <assimp/CreateAnimMesh.h>
-#include <assimp/ZipArchiveIOSystem.h>
-
-#include "time.h"
-#include "math.h"
-#include <algorithm>
 #include <numeric>
-#include <memory>
 
 namespace Assimp {
-    
+
 using namespace Assimp::Formatter;
+using namespace Assimp::Collada;
 
 static const aiImporterDesc desc = {
     "Collada Importer",
@@ -79,25 +74,37 @@ static const aiImporterDesc desc = {
     3,
     1,
     5,
-    "dae zae"
+    "dae xml zae"
 };
 
+static const float kMillisecondsFromSeconds = 1000.f;
+
+// Add an item of metadata to a node
+// Assumes the key is not already in the list
+template <typename T>
+inline void AddNodeMetaData(aiNode *node, const std::string &key, const T &value) {
+    if (nullptr == node->mMetaData) {
+        node->mMetaData = new aiMetadata();
+    }
+    node->mMetaData->Add(key, value);
+}
+
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-ColladaLoader::ColladaLoader()
-    : mFileName()
-    , mMeshIndexByID()
-    , mMaterialIndexByName()
-    , mMeshes()
-    , newMats()
-    , mCameras()
-    , mLights()
-    , mTextures()
-    , mAnims()
-    , noSkeletonMesh(false)
-    , ignoreUpDirection(false)
-    , useColladaName(false)
-    , mNodeNameCounter(0) {
+ColladaLoader::ColladaLoader() :
+        mFileName(),
+        mMeshIndexByID(),
+        mMaterialIndexByName(),
+        mMeshes(),
+        newMats(),
+        mCameras(),
+        mLights(),
+        mTextures(),
+        mAnims(),
+        noSkeletonMesh(false),
+        ignoreUpDirection(false),
+        useColladaName(false),
+        mNodeNameCounter(0) {
     // empty
 }
 
@@ -109,43 +116,19 @@ ColladaLoader::~ColladaLoader() {
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool ColladaLoader::CanRead(const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const {
-    // check file extension
-    const std::string extension = GetExtension(pFile);
-
-    bool readSig = checkSig && (pIOHandler != nullptr);
-
-    if (!readSig) {
-        if (extension == "dae" || extension == "zae") {
-            return true;
-        }
+bool ColladaLoader::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
+    // Look for a DAE file inside, but don't extract it
+    ZipArchiveIOSystem zip_archive(pIOHandler, pFile);
+    if (zip_archive.isOpen()) {
+        return !ColladaParser::ReadZaeManifest(zip_archive).empty();
     }
 
-    if (readSig) {
-        // Look for a DAE file inside, but don't extract it
-        ZipArchiveIOSystem zip_archive(pIOHandler, pFile);
-        if (zip_archive.isOpen())
-            return !ColladaParser::ReadZaeManifest(zip_archive).empty();
-    }
-
-    // XML - too generic, we need to open the file and search for typical keywords
-    if (extension == "xml" || !extension.length() || checkSig) {
-        /*  If CanRead() is called in order to check whether we
-         *  support a specific file extension in general pIOHandler
-         *  might be NULL and it's our duty to return true here.
-         */
-        if (!pIOHandler) {
-            return true;
-        }
-        static const char* tokens[] = { "<collada" };
-        return SearchFileHeaderForToken(pIOHandler, pFile, tokens, 1);
-    }
-
-    return false;
+    static const char *tokens[] = { "<collada" };
+    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------
-void ColladaLoader::SetupProperties(const Importer* pImp) {
+void ColladaLoader::SetupProperties(const Importer *pImp) {
     noSkeletonMesh = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_NO_SKELETON_MESHES, 0) != 0;
     ignoreUpDirection = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_COLLADA_IGNORE_UP_DIRECTION, 0) != 0;
     useColladaName = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_COLLADA_USE_COLLADA_NAMES, 0) != 0;
@@ -153,13 +136,13 @@ void ColladaLoader::SetupProperties(const Importer* pImp) {
 
 // ------------------------------------------------------------------------------------------------
 // Get file extension list
-const aiImporterDesc* ColladaLoader::GetInfo() const {
+const aiImporterDesc *ColladaLoader::GetInfo() const {
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void ColladaLoader::InternReadFile(const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) {
+void ColladaLoader::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
     mFileName = pFile;
 
     // clean all member arrays - just for safety, it should work even if we did not
@@ -176,14 +159,13 @@ void ColladaLoader::InternReadFile(const std::string& pFile, aiScene* pScene, IO
     // parse the input file
     ColladaParser parser(pIOHandler, pFile);
 
-
-    if( !parser.mRootNode) {
-        throw DeadlyImportError( "Collada: File came out empty. Something is wrong here.");
+    if (!parser.mRootNode) {
+        throw DeadlyImportError("Collada: File came out empty. Something is wrong here.");
     }
 
     // reserve some storage to avoid unnecessary reallocs
-    newMats.reserve(parser.mMaterialLibrary.size()*2u);
-    mMeshes.reserve(parser.mMeshLibrary.size()*2u);
+    newMats.reserve(parser.mMaterialLibrary.size() * 2u);
+    mMeshes.reserve(parser.mMeshLibrary.size() * 2u);
 
     mCameras.reserve(parser.mCameraLibrary.size());
     mLights.reserve(parser.mLightLibrary.size());
@@ -199,24 +181,24 @@ void ColladaLoader::InternReadFile(const std::string& pFile, aiScene* pScene, IO
 
     // Apply unit-size scale calculation
 
-    pScene->mRootNode->mTransformation *= aiMatrix4x4(parser.mUnitSize, 0,  0,  0,
-                                                        0,  parser.mUnitSize,  0,  0,
-                                                        0,  0,  parser.mUnitSize,  0,
-                                                        0,  0,  0,  1);
-    if( !ignoreUpDirection ) {
+    pScene->mRootNode->mTransformation *= aiMatrix4x4(parser.mUnitSize, 0, 0, 0,
+            0, parser.mUnitSize, 0, 0,
+            0, 0, parser.mUnitSize, 0,
+            0, 0, 0, 1);
+    if (!ignoreUpDirection) {
         // Convert to Y_UP, if different orientation
-        if( parser.mUpDirection == ColladaParser::UP_X) {
+        if (parser.mUpDirection == ColladaParser::UP_X) {
             pScene->mRootNode->mTransformation *= aiMatrix4x4(
-                    0, -1,  0,  0,
-                    1,  0,  0,  0,
-                    0,  0,  1,  0,
-                    0,  0,  0,  1);
-        } else if( parser.mUpDirection == ColladaParser::UP_Z) {
+                    0, -1, 0, 0,
+                    1, 0, 0, 0,
+                    0, 0, 1, 0,
+                    0, 0, 0, 1);
+        } else if (parser.mUpDirection == ColladaParser::UP_Z) {
             pScene->mRootNode->mTransformation *= aiMatrix4x4(
-                    1,  0,  0,  0,
-                    0,  0,  1,  0,
-                    0, -1,  0,  0,
-                    0,  0,  0,  1);
+                    1, 0, 0, 0,
+                    0, 0, 1, 0,
+                    0, -1, 0, 0,
+                    0, 0, 0, 1);
         }
     }
 
@@ -230,27 +212,15 @@ void ColladaLoader::InternReadFile(const std::string& pFile, aiScene* pScene, IO
         }
     }
 
-    // store all meshes
     StoreSceneMeshes(pScene);
-
-    // store all materials
     StoreSceneMaterials(pScene);
-
-    // store all textures
     StoreSceneTextures(pScene);
-
-    // store all lights
     StoreSceneLights(pScene);
-
-    // store all cameras
     StoreSceneCameras(pScene);
-
-    // store all animations
     StoreAnimations(pScene, parser);
 
     // If no meshes have been loaded, it's probably just an animated skeleton.
-    if ( 0u == pScene->mNumMeshes) {
-
+    if (0u == pScene->mNumMeshes) {
         if (!noSkeletonMesh) {
             SkeletonMeshBuilder hero(pScene);
         }
@@ -260,23 +230,32 @@ void ColladaLoader::InternReadFile(const std::string& pFile, aiScene* pScene, IO
 
 // ------------------------------------------------------------------------------------------------
 // Recursively constructs a scene node for the given parser node and returns it.
-aiNode* ColladaLoader::BuildHierarchy(const ColladaParser& pParser, const Collada::Node* pNode) {
+aiNode *ColladaLoader::BuildHierarchy(const ColladaParser &pParser, const Collada::Node *pNode) {
     // create a node for it
-    aiNode* node = new aiNode();
+    aiNode *node = new aiNode();
 
     // find a name for the new node. It's more complicated than you might think
     node->mName.Set(FindNameForNode(pNode));
+    // if we're not using the unique IDs, hold onto them for reference and export
+    if (useColladaName) {
+        if (!pNode->mID.empty()) {
+            AddNodeMetaData(node, AI_METADATA_COLLADA_ID, aiString(pNode->mID));
+        }
+        if (!pNode->mSID.empty()) {
+            AddNodeMetaData(node, AI_METADATA_COLLADA_SID, aiString(pNode->mSID));
+        }
+    }
 
     // calculate the transformation matrix for it
     node->mTransformation = pParser.CalculateResultTransform(pNode->mTransforms);
 
     // now resolve node instances
-    std::vector<const Collada::Node*> instances;
+    std::vector<const Node*> instances;
     ResolveNodeInstances(pParser, pNode, instances);
 
     // add children. first the *real* ones
     node->mNumChildren = static_cast<unsigned int>(pNode->mChildren.size() + instances.size());
-    node->mChildren = new aiNode*[node->mNumChildren];
+    node->mChildren = new aiNode *[node->mNumChildren];
 
     for (size_t a = 0; a < pNode->mChildren.size(); ++a) {
         node->mChildren[a] = BuildHierarchy(pParser, pNode->mChildren[a]);
@@ -289,13 +268,8 @@ aiNode* ColladaLoader::BuildHierarchy(const ColladaParser& pParser, const Collad
         node->mChildren[pNode->mChildren.size() + a]->mParent = node;
     }
 
-    // construct meshes
     BuildMeshesForNode(pParser, pNode, node);
-
-    // construct cameras
     BuildCamerasForNode(pParser, pNode, node);
-
-    // construct lights
     BuildLightsForNode(pParser, pNode, node);
 
     return node;
@@ -303,8 +277,8 @@ aiNode* ColladaLoader::BuildHierarchy(const ColladaParser& pParser, const Collad
 
 // ------------------------------------------------------------------------------------------------
 // Resolve node instances
-void ColladaLoader::ResolveNodeInstances(const ColladaParser& pParser, const Collada::Node* pNode,
-    std::vector<const Collada::Node*>& resolved) {
+void ColladaLoader::ResolveNodeInstances(const ColladaParser &pParser, const Node *pNode,
+        std::vector<const Node*> &resolved) {
     // reserve enough storage
     resolved.reserve(pNode->mNodeInstances.size());
 
@@ -312,7 +286,7 @@ void ColladaLoader::ResolveNodeInstances(const ColladaParser& pParser, const Col
     for (const auto &nodeInst : pNode->mNodeInstances) {
         // find the corresponding node in the library
         const ColladaParser::NodeLibrary::const_iterator itt = pParser.mNodeLibrary.find(nodeInst.mNode);
-        const Collada::Node* nd = itt == pParser.mNodeLibrary.end() ? NULL : (*itt).second;
+        const Node *nd = itt == pParser.mNodeLibrary.end() ? nullptr : (*itt).second;
 
         // FIX for http://sourceforge.net/tracker/?func=detail&aid=3054873&group_id=226462&atid=1067632
         // need to check for both name and ID to catch all. To avoid breaking valid files,
@@ -321,7 +295,7 @@ void ColladaLoader::ResolveNodeInstances(const ColladaParser& pParser, const Col
             nd = FindNode(pParser.mRootNode, nodeInst.mNode);
         }
         if (nullptr == nd) {
-            ASSIMP_LOG_ERROR_F("Collada: Unable to resolve reference to instanced node ", nodeInst.mNode);
+            ASSIMP_LOG_ERROR("Collada: Unable to resolve reference to instanced node ", nodeInst.mNode);
         } else {
             //  attach this node to the list of children
             resolved.push_back(nd);
@@ -331,33 +305,33 @@ void ColladaLoader::ResolveNodeInstances(const ColladaParser& pParser, const Col
 
 // ------------------------------------------------------------------------------------------------
 // Resolve UV channels
-void ColladaLoader::ApplyVertexToEffectSemanticMapping(Collada::Sampler& sampler,
-
-        const Collada::SemanticMappingTable& table) {
-    std::map<std::string, Collada::InputSemanticMapEntry>::const_iterator it = table.mMap.find(sampler.mUVChannel);
-    if (it != table.mMap.end()) {
-        if (it->second.mType != Collada::IT_Texcoord) {
-            ASSIMP_LOG_ERROR("Collada: Unexpected effect input mapping");
-        }
-
-        sampler.mUVId = it->second.mSet;
+void ColladaLoader::ApplyVertexToEffectSemanticMapping(Sampler &sampler, const SemanticMappingTable &table) {
+    SemanticMappingTable::InputSemanticMap::const_iterator it = table.mMap.find(sampler.mUVChannel);
+    if (it == table.mMap.end()) {
+        return;
     }
+
+    if (it->second.mType != IT_Texcoord) {
+        ASSIMP_LOG_ERROR("Collada: Unexpected effect input mapping");
+    }
+
+    sampler.mUVId = it->second.mSet;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Builds lights for the given node and references them
-void ColladaLoader::BuildLightsForNode(const ColladaParser& pParser, const Collada::Node* pNode, aiNode* pTarget) {
-    for (const Collada::LightInstance& lid : pNode->mLights) {
+void ColladaLoader::BuildLightsForNode(const ColladaParser &pParser, const Node *pNode, aiNode *pTarget) {
+    for (const LightInstance &lid : pNode->mLights) {
         // find the referred light
         ColladaParser::LightLibrary::const_iterator srcLightIt = pParser.mLightLibrary.find(lid.mLight);
         if (srcLightIt == pParser.mLightLibrary.end()) {
-            ASSIMP_LOG_WARN_F("Collada: Unable to find light for ID \"", lid.mLight, "\". Skipping.");
+            ASSIMP_LOG_WARN("Collada: Unable to find light for ID \"", lid.mLight, "\". Skipping.");
             continue;
         }
-        const Collada::Light* srcLight = &srcLightIt->second;
+        const Collada::Light *srcLight = &srcLightIt->second;
 
         // now fill our ai data structure
-        aiLight* out = new aiLight();
+        aiLight *out = new aiLight();
         out->mName = pTarget->mName;
         out->mType = (aiLightSourceType)srcLight->mType;
 
@@ -368,14 +342,13 @@ void ColladaLoader::BuildLightsForNode(const ColladaParser& pParser, const Colla
         out->mAttenuationLinear = srcLight->mAttLinear;
         out->mAttenuationQuadratic = srcLight->mAttQuadratic;
 
-        out->mColorDiffuse = out->mColorSpecular = out->mColorAmbient = srcLight->mColor*srcLight->mIntensity;
+        out->mColorDiffuse = out->mColorSpecular = out->mColorAmbient = srcLight->mColor * srcLight->mIntensity;
         if (out->mType == aiLightSource_AMBIENT) {
             out->mColorDiffuse = out->mColorSpecular = aiColor3D(0, 0, 0);
-            out->mColorAmbient = srcLight->mColor*srcLight->mIntensity;
-        }
-        else {
+            out->mColorAmbient = srcLight->mColor * srcLight->mIntensity;
+        } else {
             // collada doesn't differentiate between these color types
-            out->mColorDiffuse = out->mColorSpecular = srcLight->mColor*srcLight->mIntensity;
+            out->mColorDiffuse = out->mColorSpecular = srcLight->mColor * srcLight->mIntensity;
             out->mColorAmbient = aiColor3D(0, 0, 0);
         }
 
@@ -384,21 +357,23 @@ void ColladaLoader::BuildLightsForNode(const ColladaParser& pParser, const Colla
             out->mAngleInnerCone = AI_DEG_TO_RAD(srcLight->mFalloffAngle);
 
             // ... some extension magic.
-            if (srcLight->mOuterAngle >= ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET * (1 - 1e-6f)) {
+            if (srcLight->mOuterAngle >= ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET * (1 - ai_epsilon)) {
                 // ... some deprecation magic.
-                if (srcLight->mPenumbraAngle >= ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET * (1 - 1e-6f)) {
+                if (srcLight->mPenumbraAngle >= ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET * (1 - ai_epsilon)) {
                     // Need to rely on falloff_exponent. I don't know how to interpret it, so I need to guess ....
                     // epsilon chosen to be 0.1
-                    out->mAngleOuterCone = std::acos(std::pow(0.1f, 1.f / srcLight->mFalloffExponent)) +
-                        out->mAngleInnerCone;
-                }
-                else {
+                    float f = 1.0f;
+                    if ( 0.0f != srcLight->mFalloffExponent ) {
+                        f = 1.f / srcLight->mFalloffExponent;
+                    }
+                    out->mAngleOuterCone = std::acos(std::pow(0.1f, f)) +
+                                           out->mAngleInnerCone;
+                } else {
                     out->mAngleOuterCone = out->mAngleInnerCone + AI_DEG_TO_RAD(srcLight->mPenumbraAngle);
                     if (out->mAngleOuterCone < out->mAngleInnerCone)
                         std::swap(out->mAngleInnerCone, out->mAngleOuterCone);
                 }
-            }
-            else {
+            } else {
                 out->mAngleOuterCone = AI_DEG_TO_RAD(srcLight->mOuterAngle);
             }
         }
@@ -410,15 +385,15 @@ void ColladaLoader::BuildLightsForNode(const ColladaParser& pParser, const Colla
 
 // ------------------------------------------------------------------------------------------------
 // Builds cameras for the given node and references them
-void ColladaLoader::BuildCamerasForNode(const ColladaParser& pParser, const Collada::Node* pNode, aiNode* pTarget) {
-    for (const Collada::CameraInstance& cid : pNode->mCameras) {
+void ColladaLoader::BuildCamerasForNode(const ColladaParser &pParser, const Node *pNode, aiNode *pTarget) {
+    for (const CameraInstance &cid : pNode->mCameras) {
         // find the referred light
         ColladaParser::CameraLibrary::const_iterator srcCameraIt = pParser.mCameraLibrary.find(cid.mCamera);
         if (srcCameraIt == pParser.mCameraLibrary.end()) {
-            ASSIMP_LOG_WARN_F("Collada: Unable to find camera for ID \"", cid.mCamera, "\". Skipping.");
+            ASSIMP_LOG_WARN("Collada: Unable to find camera for ID \"", cid.mCamera, "\". Skipping.");
             continue;
         }
-        const Collada::Camera* srcCamera = &srcCameraIt->second;
+        const Collada::Camera *srcCamera = &srcCameraIt->second;
 
         // orthographic cameras not yet supported in Assimp
         if (srcCamera->mOrtho) {
@@ -426,7 +401,7 @@ void ColladaLoader::BuildCamerasForNode(const ColladaParser& pParser, const Coll
         }
 
         // now fill our ai data structure
-        aiCamera* out = new aiCamera();
+        aiCamera *out = new aiCamera();
         out->mName = pTarget->mName;
 
         // collada cameras point in -Z by default, rest is specified in node transform
@@ -447,12 +422,12 @@ void ColladaLoader::BuildCamerasForNode(const ColladaParser& pParser, const Coll
 
             if (srcCamera->mVerFov != 10e10f && srcCamera->mAspect == 10e10f) {
                 out->mAspect = std::tan(AI_DEG_TO_RAD(srcCamera->mHorFov)) /
-                    std::tan(AI_DEG_TO_RAD(srcCamera->mVerFov));
+                               std::tan(AI_DEG_TO_RAD(srcCamera->mVerFov));
             }
 
-        } else if (srcCamera->mAspect != 10e10f && srcCamera->mVerFov != 10e10f)  {
+        } else if (srcCamera->mAspect != 10e10f && srcCamera->mVerFov != 10e10f) {
             out->mHorizontalFOV = 2.0f * AI_RAD_TO_DEG(std::atan(srcCamera->mAspect *
-                std::tan(AI_DEG_TO_RAD(srcCamera->mVerFov) * 0.5f)));
+                                                                 std::tan(AI_DEG_TO_RAD(srcCamera->mVerFov) * 0.5f)));
         }
 
         // Collada uses degrees, we use radians
@@ -465,15 +440,15 @@ void ColladaLoader::BuildCamerasForNode(const ColladaParser& pParser, const Coll
 
 // ------------------------------------------------------------------------------------------------
 // Builds meshes for the given node and references them
-void ColladaLoader::BuildMeshesForNode(const ColladaParser& pParser, const Collada::Node* pNode, aiNode* pTarget) {
+void ColladaLoader::BuildMeshesForNode(const ColladaParser &pParser, const Node *pNode, aiNode *pTarget) {
     // accumulated mesh references by this node
     std::vector<size_t> newMeshRefs;
     newMeshRefs.reserve(pNode->mMeshes.size());
 
     // add a mesh for each subgroup in each collada mesh
-    for (const Collada::MeshInstance& mid : pNode->mMeshes) {
-        const Collada::Mesh* srcMesh = nullptr;
-        const Collada::Controller* srcController = nullptr;
+    for (const MeshInstance &mid : pNode->mMeshes) {
+        const Mesh *srcMesh = nullptr;
+        const Controller *srcController = nullptr;
 
         // find the referred mesh
         ColladaParser::MeshLibrary::const_iterator srcMeshIt = pParser.mMeshLibrary.find(mid.mMeshOrController);
@@ -488,13 +463,11 @@ void ColladaLoader::BuildMeshesForNode(const ColladaParser& pParser, const Colla
                 }
             }
 
-
-            if( nullptr == srcMesh) {
-                ASSIMP_LOG_WARN_F( "Collada: Unable to find geometry for ID \"", mid.mMeshOrController, "\". Skipping." );
+            if (nullptr == srcMesh) {
+                ASSIMP_LOG_WARN("Collada: Unable to find geometry for ID \"", mid.mMeshOrController, "\". Skipping.");
                 continue;
             }
-        }
-        else {
+        } else {
             // ID found in the mesh library -> direct reference to an unskinned mesh
             srcMesh = srcMeshIt->second;
         }
@@ -502,23 +475,22 @@ void ColladaLoader::BuildMeshesForNode(const ColladaParser& pParser, const Colla
         // build a mesh for each of its subgroups
         size_t vertexStart = 0, faceStart = 0;
         for (size_t sm = 0; sm < srcMesh->mSubMeshes.size(); ++sm) {
-            const Collada::SubMesh& submesh = srcMesh->mSubMeshes[sm];
+            const Collada::SubMesh &submesh = srcMesh->mSubMeshes[sm];
             if (submesh.mNumFaces == 0) {
                 continue;
             }
 
             // find material assigned to this submesh
             std::string meshMaterial;
-            std::map<std::string, Collada::SemanticMappingTable >::const_iterator meshMatIt = mid.mMaterials.find(submesh.mMaterial);
+            std::map<std::string, SemanticMappingTable>::const_iterator meshMatIt = mid.mMaterials.find(submesh.mMaterial);
 
-            const Collada::SemanticMappingTable* table = nullptr;
+            const Collada::SemanticMappingTable *table = nullptr;
             if (meshMatIt != mid.mMaterials.end()) {
                 table = &meshMatIt->second;
                 meshMaterial = table->mMatName;
-            }
-            else {
-                ASSIMP_LOG_WARN_F("Collada: No material specified for subgroup <", submesh.mMaterial, "> in geometry <",
-                    mid.mMeshOrController, ">.");
+            } else {
+                ASSIMP_LOG_WARN("Collada: No material specified for subgroup <", submesh.mMaterial, "> in geometry <",
+                        mid.mMeshOrController, ">.");
                 if (!mid.mMaterials.empty()) {
                     meshMaterial = mid.mMaterials.begin()->second.mMatName;
                 }
@@ -533,7 +505,7 @@ void ColladaLoader::BuildMeshesForNode(const ColladaParser& pParser, const Colla
             }
 
             if (table && !table->mMap.empty()) {
-                std::pair<Collada::Effect*, aiMaterial*>&  mat = newMats[matIdx];
+                std::pair<Collada::Effect *, aiMaterial *> &mat = newMats[matIdx];
 
                 // Iterate through all texture channels assigned to the effect and
                 // check whether we have mapping information for it.
@@ -552,19 +524,24 @@ void ColladaLoader::BuildMeshesForNode(const ColladaParser& pParser, const Colla
             std::map<ColladaMeshIndex, size_t>::const_iterator dstMeshIt = mMeshIndexByID.find(index);
             if (dstMeshIt != mMeshIndexByID.end()) {
                 newMeshRefs.push_back(dstMeshIt->second);
-            }
-            else {
+            } else {
                 // else we have to add the mesh to the collection and store its newly assigned index at the node
-                aiMesh* dstMesh = CreateMesh(pParser, srcMesh, submesh, srcController, vertexStart, faceStart);
+                aiMesh *dstMesh = CreateMesh(pParser, srcMesh, submesh, srcController, vertexStart, faceStart);
 
                 // store the mesh, and store its new index in the node
                 newMeshRefs.push_back(mMeshes.size());
                 mMeshIndexByID[index] = mMeshes.size();
                 mMeshes.push_back(dstMesh);
-                vertexStart += dstMesh->mNumVertices; faceStart += submesh.mNumFaces;
+                vertexStart += dstMesh->mNumVertices;
+                faceStart += submesh.mNumFaces;
 
                 // assign the material index
-                dstMesh->mMaterialIndex = matIdx;
+                std::map<std::string, size_t>::const_iterator subMatIt = mMaterialIndexByName.find(submesh.mMaterial);
+                if (subMatIt != mMaterialIndexByName.end()) {
+                    dstMesh->mMaterialIndex = static_cast<unsigned int>(subMatIt->second);
+                } else {
+                    dstMesh->mMaterialIndex = matIdx;
+                }
                 if (dstMesh->mName.length == 0) {
                     dstMesh->mName = mid.mMeshOrController;
                 }
@@ -574,9 +551,9 @@ void ColladaLoader::BuildMeshesForNode(const ColladaParser& pParser, const Colla
 
     // now place all mesh references we gathered in the target node
     pTarget->mNumMeshes = static_cast<unsigned int>(newMeshRefs.size());
-    if (newMeshRefs.size()) {
+    if (!newMeshRefs.empty()) {
         struct UIntTypeConverter {
-            unsigned int operator()(const size_t& v) const {
+            unsigned int operator()(const size_t &v) const {
                 return static_cast<unsigned int>(v);
             }
         };
@@ -588,16 +565,20 @@ void ColladaLoader::BuildMeshesForNode(const ColladaParser& pParser, const Colla
 
 // ------------------------------------------------------------------------------------------------
 // Find mesh from either meshes or morph target meshes
-aiMesh *ColladaLoader::findMesh(const std::string& meshid) {
-    for (unsigned int i = 0; i < mMeshes.size(); ++i) {
-        if (std::string(mMeshes[i]->mName.data) == meshid) {
-            return mMeshes[i];
+aiMesh *ColladaLoader::findMesh(const std::string &meshid) {
+    if (meshid.empty()) {
+        return nullptr;
+    }
+
+    for (auto & mMeshe : mMeshes) {
+        if (std::string(mMeshe->mName.data) == meshid) {
+            return mMeshe;
         }
     }
 
-    for (unsigned int i = 0; i < mTargetMeshes.size(); ++i) {
-        if (std::string(mTargetMeshes[i]->mName.data) == meshid) {
-            return mTargetMeshes[i];
+    for (auto & mTargetMeshe : mTargetMeshes) {
+        if (std::string(mTargetMeshe->mName.data) == meshid) {
+            return mTargetMeshe;
         }
     }
 
@@ -606,46 +587,50 @@ aiMesh *ColladaLoader::findMesh(const std::string& meshid) {
 
 // ------------------------------------------------------------------------------------------------
 // Creates a mesh for the given ColladaMesh face subset and returns the newly created mesh
-aiMesh* ColladaLoader::CreateMesh(const ColladaParser& pParser, const Collada::Mesh* pSrcMesh, const Collada::SubMesh& pSubMesh,
-    const Collada::Controller* pSrcController, size_t pStartVertex, size_t pStartFace) {
+aiMesh *ColladaLoader::CreateMesh(const ColladaParser &pParser, const Mesh *pSrcMesh, const SubMesh &pSubMesh,
+        const Controller *pSrcController, size_t pStartVertex, size_t pStartFace) {
     std::unique_ptr<aiMesh> dstMesh(new aiMesh);
 
-    dstMesh->mName = pSrcMesh->mName;
+    if (useColladaName) {
+        dstMesh->mName = pSrcMesh->mName;
+    } else {
+        dstMesh->mName = pSrcMesh->mId;
+    }
+
+    if (pSrcMesh->mPositions.empty()) {
+        return dstMesh.release();
+    }
 
     // count the vertices addressed by its faces
     const size_t numVertices = std::accumulate(pSrcMesh->mFaceSize.begin() + pStartFace,
-        pSrcMesh->mFaceSize.begin() + pStartFace + pSubMesh.mNumFaces, size_t(0));
+            pSrcMesh->mFaceSize.begin() + pStartFace + pSubMesh.mNumFaces, size_t(0));
 
     // copy positions
     dstMesh->mNumVertices = static_cast<unsigned int>(numVertices);
     dstMesh->mVertices = new aiVector3D[numVertices];
-    std::copy(pSrcMesh->mPositions.begin() + pStartVertex, pSrcMesh->mPositions.begin() +
-        pStartVertex + numVertices, dstMesh->mVertices);
+    std::copy(pSrcMesh->mPositions.begin() + pStartVertex, pSrcMesh->mPositions.begin() + pStartVertex + numVertices, dstMesh->mVertices);
 
     // normals, if given. HACK: (thom) Due to the glorious Collada spec we never
     // know if we have the same number of normals as there are positions. So we
     // also ignore any vertex attribute if it has a different count
     if (pSrcMesh->mNormals.size() >= pStartVertex + numVertices) {
         dstMesh->mNormals = new aiVector3D[numVertices];
-        std::copy(pSrcMesh->mNormals.begin() + pStartVertex, pSrcMesh->mNormals.begin() +
-            pStartVertex + numVertices, dstMesh->mNormals);
+        std::copy(pSrcMesh->mNormals.begin() + pStartVertex, pSrcMesh->mNormals.begin() + pStartVertex + numVertices, dstMesh->mNormals);
     }
 
     // tangents, if given.
     if (pSrcMesh->mTangents.size() >= pStartVertex + numVertices) {
         dstMesh->mTangents = new aiVector3D[numVertices];
-        std::copy(pSrcMesh->mTangents.begin() + pStartVertex, pSrcMesh->mTangents.begin() +
-            pStartVertex + numVertices, dstMesh->mTangents);
+        std::copy(pSrcMesh->mTangents.begin() + pStartVertex, pSrcMesh->mTangents.begin() + pStartVertex + numVertices, dstMesh->mTangents);
     }
 
     // bitangents, if given.
     if (pSrcMesh->mBitangents.size() >= pStartVertex + numVertices) {
         dstMesh->mBitangents = new aiVector3D[numVertices];
-        std::copy(pSrcMesh->mBitangents.begin() + pStartVertex, pSrcMesh->mBitangents.begin() +
-            pStartVertex + numVertices, dstMesh->mBitangents);
+        std::copy(pSrcMesh->mBitangents.begin() + pStartVertex, pSrcMesh->mBitangents.begin() + pStartVertex + numVertices, dstMesh->mBitangents);
     }
 
-    // same for texturecoords, as many as we have
+    // same for texture coords, as many as we have
     // empty slots are not allowed, need to pack and adjust UV indexes accordingly
     for (size_t a = 0, real = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
         if (pSrcMesh->mTexCoords[a].size() >= pStartVertex + numVertices) {
@@ -674,7 +659,7 @@ aiMesh* ColladaLoader::CreateMesh(const ColladaParser& pParser, const Collada::M
     dstMesh->mFaces = new aiFace[dstMesh->mNumFaces];
     for (size_t a = 0; a < dstMesh->mNumFaces; ++a) {
         size_t s = pSrcMesh->mFaceSize[pStartFace + a];
-        aiFace& face = dstMesh->mFaces[a];
+        aiFace &face = dstMesh->mFaces[a];
         face.mNumIndices = static_cast<unsigned int>(s);
         face.mIndices = new unsigned int[s];
         for (size_t b = 0; b < s; ++b) {
@@ -683,20 +668,20 @@ aiMesh* ColladaLoader::CreateMesh(const ColladaParser& pParser, const Collada::M
     }
 
     // create morph target meshes if any
-    std::vector<aiMesh*> targetMeshes;
+    std::vector<aiMesh *> targetMeshes;
     std::vector<float> targetWeights;
-    Collada::MorphMethod method = Collada::Normalized;
+    Collada::MorphMethod method = Normalized;
 
-    for (std::map<std::string, Collada::Controller>::const_iterator it = pParser.mControllerLibrary.begin();
-        it != pParser.mControllerLibrary.end(); ++it) {
-        const Collada::Controller &c = it->second;
-        const Collada::Mesh* baseMesh = pParser.ResolveLibraryReference(pParser.mMeshLibrary, c.mMeshId);
+    for (std::map<std::string, Controller>::const_iterator it = pParser.mControllerLibrary.begin();
+            it != pParser.mControllerLibrary.end(); ++it) {
+        const Controller &c = it->second;
+        const Collada::Mesh *baseMesh = pParser.ResolveLibraryReference(pParser.mMeshLibrary, c.mMeshId);
 
         if (c.mType == Collada::Morph && baseMesh->mName == pSrcMesh->mName) {
-            const Collada::Accessor& targetAccessor = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, c.mMorphTarget);
-            const Collada::Accessor& weightAccessor = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, c.mMorphWeight);
-            const Collada::Data& targetData = pParser.ResolveLibraryReference(pParser.mDataLibrary, targetAccessor.mSource);
-            const Collada::Data& weightData = pParser.ResolveLibraryReference(pParser.mDataLibrary, weightAccessor.mSource);
+            const Collada::Accessor &targetAccessor = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, c.mMorphTarget);
+            const Collada::Accessor &weightAccessor = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, c.mMorphWeight);
+            const Collada::Data &targetData = pParser.ResolveLibraryReference(pParser.mDataLibrary, targetAccessor.mSource);
+            const Collada::Data &weightData = pParser.ResolveLibraryReference(pParser.mDataLibrary, weightAccessor.mSource);
 
             // take method
             method = c.mMethod;
@@ -708,38 +693,36 @@ aiMesh* ColladaLoader::CreateMesh(const ColladaParser& pParser, const Collada::M
                 throw DeadlyImportError("target weight data must not be textual ");
             }
 
-            for (unsigned int i = 0; i < targetData.mStrings.size(); ++i) {
-                const Collada::Mesh* targetMesh = pParser.ResolveLibraryReference(pParser.mMeshLibrary, targetData.mStrings.at(i));
+            for (const auto & mString : targetData.mStrings) {
+                const Mesh *targetMesh = pParser.ResolveLibraryReference(pParser.mMeshLibrary, mString);
 
-                aiMesh *aimesh = findMesh(targetMesh->mName);
+                aiMesh *aimesh = findMesh(useColladaName ? targetMesh->mName : targetMesh->mId);
                 if (!aimesh) {
                     if (targetMesh->mSubMeshes.size() > 1) {
-                        throw DeadlyImportError("Morhing target mesh must be a single");
+                        throw DeadlyImportError("Morphing target mesh must be a single");
                     }
-                    aimesh = CreateMesh(pParser, targetMesh, targetMesh->mSubMeshes.at(0), NULL, 0, 0);
+                    aimesh = CreateMesh(pParser, targetMesh, targetMesh->mSubMeshes.at(0), nullptr, 0, 0);
                     mTargetMeshes.push_back(aimesh);
                 }
                 targetMeshes.push_back(aimesh);
             }
-            for (unsigned int i = 0; i < weightData.mValues.size(); ++i) {
-                targetWeights.push_back(weightData.mValues.at(i));
+            for (float mValue : weightData.mValues) {
+                targetWeights.push_back(mValue);
             }
         }
     }
-    if (targetMeshes.size() > 0 && targetWeights.size() == targetMeshes.size()) {
-        std::vector<aiAnimMesh*> animMeshes;
+    if (!targetMeshes.empty() && targetWeights.size() == targetMeshes.size()) {
+        std::vector<aiAnimMesh *> animMeshes;
         for (unsigned int i = 0; i < targetMeshes.size(); ++i) {
-            aiMesh* targetMesh = targetMeshes.at(i);
+            aiMesh *targetMesh = targetMeshes.at(i);
             aiAnimMesh *animMesh = aiCreateAnimMesh(targetMesh);
             float weight = targetWeights[i];
             animMesh->mWeight = weight == 0 ? 1.0f : weight;
             animMesh->mName = targetMesh->mName;
             animMeshes.push_back(animMesh);
         }
-        dstMesh->mMethod = (method == Collada::Relative)
-            ? aiMorphingMethod_MORPH_RELATIVE
-            : aiMorphingMethod_MORPH_NORMALIZED;
-        dstMesh->mAnimMeshes = new aiAnimMesh*[animMeshes.size()];
+        dstMesh->mMethod = (method == Relative) ? aiMorphingMethod_MORPH_RELATIVE : aiMorphingMethod_MORPH_NORMALIZED;
+        dstMesh->mAnimMeshes = new aiAnimMesh *[animMeshes.size()];
         dstMesh->mNumAnimMeshes = static_cast<unsigned int>(animMeshes.size());
         for (unsigned int i = 0; i < animMeshes.size(); ++i) {
             dstMesh->mAnimMeshes[i] = animMeshes.at(i);
@@ -749,31 +732,33 @@ aiMesh* ColladaLoader::CreateMesh(const ColladaParser& pParser, const Collada::M
     // create bones if given
     if (pSrcController && pSrcController->mType == Collada::Skin) {
         // resolve references - joint names
-        const Collada::Accessor& jointNamesAcc = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, pSrcController->mJointNameSource);
-        const Collada::Data& jointNames = pParser.ResolveLibraryReference(pParser.mDataLibrary, jointNamesAcc.mSource);
+        const Collada::Accessor &jointNamesAcc = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, pSrcController->mJointNameSource);
+        const Collada::Data &jointNames = pParser.ResolveLibraryReference(pParser.mDataLibrary, jointNamesAcc.mSource);
         // joint offset matrices
-        const Collada::Accessor& jointMatrixAcc = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, pSrcController->mJointOffsetMatrixSource);
-        const Collada::Data& jointMatrices = pParser.ResolveLibraryReference(pParser.mDataLibrary, jointMatrixAcc.mSource);
+        const Collada::Accessor &jointMatrixAcc = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, pSrcController->mJointOffsetMatrixSource);
+        const Collada::Data &jointMatrices = pParser.ResolveLibraryReference(pParser.mDataLibrary, jointMatrixAcc.mSource);
         // joint vertex_weight name list - should refer to the same list as the joint names above. If not, report and reconsider
-        const Collada::Accessor& weightNamesAcc = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, pSrcController->mWeightInputJoints.mAccessor);
+        const Collada::Accessor &weightNamesAcc = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, pSrcController->mWeightInputJoints.mAccessor);
         if (&weightNamesAcc != &jointNamesAcc)
             throw DeadlyImportError("Temporary implementational laziness. If you read this, please report to the author.");
         // vertex weights
-        const Collada::Accessor& weightsAcc = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, pSrcController->mWeightInputWeights.mAccessor);
-        const Collada::Data& weights = pParser.ResolveLibraryReference(pParser.mDataLibrary, weightsAcc.mSource);
+        const Collada::Accessor &weightsAcc = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, pSrcController->mWeightInputWeights.mAccessor);
+        const Collada::Data &weights = pParser.ResolveLibraryReference(pParser.mDataLibrary, weightsAcc.mSource);
 
-        if (!jointNames.mIsStringArray || jointMatrices.mIsStringArray || weights.mIsStringArray)
+        if (!jointNames.mIsStringArray || jointMatrices.mIsStringArray || weights.mIsStringArray) {
             throw DeadlyImportError("Data type mismatch while resolving mesh joints");
+        }
         // sanity check: we rely on the vertex weights always coming as pairs of BoneIndex-WeightIndex
-        if (pSrcController->mWeightInputJoints.mOffset != 0 || pSrcController->mWeightInputWeights.mOffset != 1)
+        if (pSrcController->mWeightInputJoints.mOffset != 0 || pSrcController->mWeightInputWeights.mOffset != 1) {
             throw DeadlyImportError("Unsupported vertex_weight addressing scheme. ");
+        }
 
         // create containers to collect the weights for each bone
         size_t numBones = jointNames.mStrings.size();
-        std::vector<std::vector<aiVertexWeight> > dstBones(numBones);
+        std::vector<std::vector<aiVertexWeight>> dstBones(numBones);
 
         // build a temporary array of pointers to the start of each vertex's weights
-        typedef std::vector< std::pair<size_t, size_t> > IndexPairVector;
+        using IndexPairVector = std::vector<std::pair<size_t, size_t>>;
         std::vector<IndexPairVector::const_iterator> weightStartPerVertex;
         weightStartPerVertex.resize(pSrcController->mWeightCounts.size(), pSrcController->mWeights.end());
 
@@ -792,18 +777,16 @@ aiMesh* ColladaLoader::CreateMesh(const ColladaParser& pParser, const Collada::M
             IndexPairVector::const_iterator iit = weightStartPerVertex[orgIndex];
             size_t pairCount = pSrcController->mWeightCounts[orgIndex];
 
-
-            for( size_t b = 0; b < pairCount; ++b, ++iit) {
+            for (size_t b = 0; b < pairCount; ++b, ++iit) {
                 const size_t jointIndex = iit->first;
-                const size_t vertexIndex = iit->second;                
+                const size_t vertexIndex = iit->second;
                 ai_real weight = 1.0f;
                 if (!weights.mValues.empty()) {
                     weight = ReadFloat(weightsAcc, weights, vertexIndex, 0);
                 }
 
                 // one day I gonna kill that XSI Collada exporter
-                if (weight > 0.0f)
-                {
+                if (weight > 0.0f) {
                     aiVertexWeight w;
                     w.mVertexId = static_cast<unsigned int>(a - pStartVertex);
                     w.mWeight = weight;
@@ -814,24 +797,24 @@ aiMesh* ColladaLoader::CreateMesh(const ColladaParser& pParser, const Collada::M
 
         // count the number of bones which influence vertices of the current submesh
         size_t numRemainingBones = 0;
-        for( std::vector<std::vector<aiVertexWeight> >::const_iterator it = dstBones.begin(); it != dstBones.end(); ++it) {
-            if( it->size() > 0) {
+        for (const auto & dstBone : dstBones) {
+            if (!dstBone.empty()) {
                 ++numRemainingBones;
             }
         }
 
         // create bone array and copy bone weights one by one
         dstMesh->mNumBones = static_cast<unsigned int>(numRemainingBones);
-        dstMesh->mBones = new aiBone*[numRemainingBones];
+        dstMesh->mBones = new aiBone *[numRemainingBones];
         size_t boneCount = 0;
-        for( size_t a = 0; a < numBones; ++a) {
+        for (size_t a = 0; a < numBones; ++a) {
             // omit bones without weights
-            if( dstBones[a].empty() ) {
+            if (dstBones[a].empty()) {
                 continue;
             }
 
             // create bone with its weights
-            aiBone* bone = new aiBone;
+            aiBone *bone = new aiBone;
             bone->mName = ReadString(jointNamesAcc, jointNames, a);
             bone->mOffsetMatrix.a1 = ReadFloat(jointMatrixAcc, jointMatrices, a, 0);
             bone->mOffsetMatrix.a2 = ReadFloat(jointMatrixAcc, jointMatrices, a, 1);
@@ -873,16 +856,16 @@ aiMesh* ColladaLoader::CreateMesh(const ColladaParser& pParser, const Collada::M
             // Therefore I added a little name replacement here: I search for the bone's node by either name, ID or SID,
             // and replace the bone's name by the node's name so that the user can use the standard
             // find-by-name method to associate nodes with bones.
-            const Collada::Node* bnode = FindNode( pParser.mRootNode, bone->mName.data);
-            if( !bnode) {
-                bnode = FindNodeBySID( pParser.mRootNode, bone->mName.data);
+            const Collada::Node *bnode = FindNode(pParser.mRootNode, bone->mName.data);
+            if (nullptr == bnode) {
+                bnode = FindNodeBySID(pParser.mRootNode, bone->mName.data);
             }
 
             // assign the name that we would have assigned for the source node
-            if( bnode) {
-                bone->mName.Set( FindNameForNode( bnode));
+            if (nullptr != bnode) {
+                bone->mName.Set(FindNameForNode(bnode));
             } else {
-                ASSIMP_LOG_WARN_F( "ColladaLoader::CreateMesh(): could not find corresponding node for joint \"", bone->mName.data, "\"." );
+                ASSIMP_LOG_WARN("ColladaLoader::CreateMesh(): could not find corresponding node for joint \"", bone->mName.data, "\".");
             }
 
             // and insert bone
@@ -895,61 +878,61 @@ aiMesh* ColladaLoader::CreateMesh(const ColladaParser& pParser, const Collada::M
 
 // ------------------------------------------------------------------------------------------------
 // Stores all meshes in the given scene
-void ColladaLoader::StoreSceneMeshes( aiScene* pScene) {
+void ColladaLoader::StoreSceneMeshes(aiScene *pScene) {
     pScene->mNumMeshes = static_cast<unsigned int>(mMeshes.size());
-    if( mMeshes.empty() ) {
+    if (mMeshes.empty()) {
         return;
     }
-    pScene->mMeshes = new aiMesh*[mMeshes.size()];
-    std::copy( mMeshes.begin(), mMeshes.end(), pScene->mMeshes);
+    pScene->mMeshes = new aiMesh *[mMeshes.size()];
+    std::copy(mMeshes.begin(), mMeshes.end(), pScene->mMeshes);
     mMeshes.clear();
 }
 
 // ------------------------------------------------------------------------------------------------
 // Stores all cameras in the given scene
-void ColladaLoader::StoreSceneCameras( aiScene* pScene) {
+void ColladaLoader::StoreSceneCameras(aiScene *pScene) {
     pScene->mNumCameras = static_cast<unsigned int>(mCameras.size());
-    if( mCameras.empty() ) {
+    if (mCameras.empty()) {
         return;
     }
-    pScene->mCameras = new aiCamera*[mCameras.size()];
-    std::copy( mCameras.begin(), mCameras.end(), pScene->mCameras);
+    pScene->mCameras = new aiCamera *[mCameras.size()];
+    std::copy(mCameras.begin(), mCameras.end(), pScene->mCameras);
     mCameras.clear();
 }
 
 // ------------------------------------------------------------------------------------------------
 // Stores all lights in the given scene
-void ColladaLoader::StoreSceneLights( aiScene* pScene) {
+void ColladaLoader::StoreSceneLights(aiScene *pScene) {
     pScene->mNumLights = static_cast<unsigned int>(mLights.size());
-    if( mLights.empty() ) {
+    if (mLights.empty()) {
         return;
     }
-    pScene->mLights = new aiLight*[mLights.size()];
-    std::copy( mLights.begin(), mLights.end(), pScene->mLights);
+    pScene->mLights = new aiLight *[mLights.size()];
+    std::copy(mLights.begin(), mLights.end(), pScene->mLights);
     mLights.clear();
 }
 
 // ------------------------------------------------------------------------------------------------
 // Stores all textures in the given scene
-void ColladaLoader::StoreSceneTextures( aiScene* pScene) {
+void ColladaLoader::StoreSceneTextures(aiScene *pScene) {
     pScene->mNumTextures = static_cast<unsigned int>(mTextures.size());
-    if( mTextures.empty() ) {
+    if (mTextures.empty()) {
         return;
     }
-    pScene->mTextures = new aiTexture*[mTextures.size()];
-    std::copy( mTextures.begin(), mTextures.end(), pScene->mTextures);
+    pScene->mTextures = new aiTexture *[mTextures.size()];
+    std::copy(mTextures.begin(), mTextures.end(), pScene->mTextures);
     mTextures.clear();
 }
 
 // ------------------------------------------------------------------------------------------------
 // Stores all materials in the given scene
-void ColladaLoader::StoreSceneMaterials( aiScene* pScene) {
+void ColladaLoader::StoreSceneMaterials(aiScene *pScene) {
     pScene->mNumMaterials = static_cast<unsigned int>(newMats.size());
-    if (newMats.empty() ) {
+    if (newMats.empty()) {
         return;
     }
-    pScene->mMaterials = new aiMaterial*[newMats.size()];
-    for (unsigned int i = 0; i < newMats.size();++i) {
+    pScene->mMaterials = new aiMaterial *[newMats.size()];
+    for (unsigned int i = 0; i < newMats.size(); ++i) {
         pScene->mMaterials[i] = newMats[i].second;
     }
     newMats.clear();
@@ -957,53 +940,70 @@ void ColladaLoader::StoreSceneMaterials( aiScene* pScene) {
 
 // ------------------------------------------------------------------------------------------------
 // Stores all animations
-void ColladaLoader::StoreAnimations( aiScene* pScene, const ColladaParser& pParser) {
+void ColladaLoader::StoreAnimations(aiScene *pScene, const ColladaParser &pParser) {
     // recursively collect all animations from the collada scene
     StoreAnimations(pScene, pParser, &pParser.mAnims, "");
 
     // catch special case: many animations with the same length, each affecting only a single node.
     // we need to unite all those single-node-anims to a proper combined animation
-    for( size_t a = 0; a < mAnims.size(); ++a) {
-        aiAnimation* templateAnim = mAnims[a];
-        if( templateAnim->mNumChannels == 1) {
+    for (size_t a = 0; a < mAnims.size(); ++a) {
+        aiAnimation *templateAnim = mAnims[a];
+
+        if (templateAnim->mNumChannels == 1) {
             // search for other single-channel-anims with the same duration
             std::vector<size_t> collectedAnimIndices;
-            for( size_t b = a+1; b < mAnims.size(); ++b) {
-                aiAnimation* other = mAnims[b];
+            for (size_t b = a + 1; b < mAnims.size(); ++b) {
+                aiAnimation *other = mAnims[b];
                 if (other->mNumChannels == 1 && other->mDuration == templateAnim->mDuration &&
-                    other->mTicksPerSecond == templateAnim->mTicksPerSecond)
+                        other->mTicksPerSecond == templateAnim->mTicksPerSecond)
                     collectedAnimIndices.push_back(b);
             }
 
+            // We only want to combine the animations if they have different channels
+            std::set<std::string> animTargets;
+            animTargets.insert(templateAnim->mChannels[0]->mNodeName.C_Str());
+            bool collectedAnimationsHaveDifferentChannels = true;
+            for (unsigned long long collectedAnimIndice : collectedAnimIndices) {
+                aiAnimation *srcAnimation = mAnims[(int)collectedAnimIndice];
+                std::string channelName = std::string(srcAnimation->mChannels[0]->mNodeName.C_Str());
+                if (animTargets.find(channelName) == animTargets.end()) {
+                    animTargets.insert(channelName);
+                } else {
+                    collectedAnimationsHaveDifferentChannels = false;
+                    break;
+                }
+            }
+
+            if (!collectedAnimationsHaveDifferentChannels) {
+                continue;
+            }
+
             // if there are other animations which fit the template anim, combine all channels into a single anim
-            if (!collectedAnimIndices.empty())
-            {
-                aiAnimation* combinedAnim = new aiAnimation();
+            if (!collectedAnimIndices.empty()) {
+                aiAnimation *combinedAnim = new aiAnimation();
                 combinedAnim->mName = aiString(std::string("combinedAnim_") + char('0' + a));
                 combinedAnim->mDuration = templateAnim->mDuration;
                 combinedAnim->mTicksPerSecond = templateAnim->mTicksPerSecond;
                 combinedAnim->mNumChannels = static_cast<unsigned int>(collectedAnimIndices.size() + 1);
-                combinedAnim->mChannels = new aiNodeAnim*[combinedAnim->mNumChannels];
+                combinedAnim->mChannels = new aiNodeAnim *[combinedAnim->mNumChannels];
                 // add the template anim as first channel by moving its aiNodeAnim to the combined animation
                 combinedAnim->mChannels[0] = templateAnim->mChannels[0];
-                templateAnim->mChannels[0] = NULL;
+                templateAnim->mChannels[0] = nullptr;
                 delete templateAnim;
                 // combined animation replaces template animation in the anim array
                 mAnims[a] = combinedAnim;
 
                 // move the memory of all other anims to the combined anim and erase them from the source anims
-                for (size_t b = 0; b < collectedAnimIndices.size(); ++b)
-                {
-                    aiAnimation* srcAnimation = mAnims[collectedAnimIndices[b]];
+                for (size_t b = 0; b < collectedAnimIndices.size(); ++b) {
+                    aiAnimation *srcAnimation = mAnims[collectedAnimIndices[b]];
                     combinedAnim->mChannels[1 + b] = srcAnimation->mChannels[0];
-                    srcAnimation->mChannels[0] = NULL;
+                    srcAnimation->mChannels[0] = nullptr;
                     delete srcAnimation;
                 }
 
                 // in a second go, delete all the single-channel-anims that we've stripped from their channels
                 // back to front to preserve indices - you know, removing an element from a vector moves all elements behind the removed one
-                while (!collectedAnimIndices.empty())
-                {
+                while (!collectedAnimIndices.empty()) {
                     mAnims.erase(mAnims.begin() + collectedAnimIndices.back());
                     collectedAnimIndices.pop_back();
                 }
@@ -1012,10 +1012,9 @@ void ColladaLoader::StoreAnimations( aiScene* pScene, const ColladaParser& pPars
     }
 
     // now store all anims in the scene
-    if (!mAnims.empty())
-    {
+    if (!mAnims.empty()) {
         pScene->mNumAnimations = static_cast<unsigned int>(mAnims.size());
-        pScene->mAnimations = new aiAnimation*[mAnims.size()];
+        pScene->mAnimations = new aiAnimation *[mAnims.size()];
         std::copy(mAnims.begin(), mAnims.end(), pScene->mAnimations);
     }
 
@@ -1024,60 +1023,52 @@ void ColladaLoader::StoreAnimations( aiScene* pScene, const ColladaParser& pPars
 
 // ------------------------------------------------------------------------------------------------
 // Constructs the animations for the given source anim
-void ColladaLoader::StoreAnimations(aiScene* pScene, const ColladaParser& pParser, const Collada::Animation* pSrcAnim, const std::string &pPrefix)
-{
+void ColladaLoader::StoreAnimations(aiScene *pScene, const ColladaParser &pParser, const Animation *pSrcAnim, const std::string &pPrefix) {
     std::string animName = pPrefix.empty() ? pSrcAnim->mName : pPrefix + "_" + pSrcAnim->mName;
 
     // create nested animations, if given
-    for (std::vector<Collada::Animation*>::const_iterator it = pSrcAnim->mSubAnims.begin(); it != pSrcAnim->mSubAnims.end(); ++it)
-        StoreAnimations(pScene, pParser, *it, animName);
+    for (auto mSubAnim : pSrcAnim->mSubAnims) {
+        StoreAnimations(pScene, pParser, mSubAnim, animName);
+    }
 
     // create animation channels, if any
-    if (!pSrcAnim->mChannels.empty())
+    if (!pSrcAnim->mChannels.empty()) {
         CreateAnimation(pScene, pParser, pSrcAnim, animName);
+    }
 }
 
-struct MorphTimeValues
-{
+struct MorphTimeValues {
     float mTime;
-    struct key
-    {
+    struct key {
         float mWeight;
         unsigned int mValue;
     };
     std::vector<key> mKeys;
 };
 
-void insertMorphTimeValue(std::vector<MorphTimeValues> &values, float time, float weight, unsigned int value)
-{
+void insertMorphTimeValue(std::vector<MorphTimeValues> &values, float time, float weight, unsigned int value) {
     MorphTimeValues::key k;
     k.mValue = value;
     k.mWeight = weight;
-    if (values.size() == 0 || time < values[0].mTime)
-    {
+    if (values.empty() || time < values[0].mTime) {
         MorphTimeValues val;
         val.mTime = time;
         val.mKeys.push_back(k);
         values.insert(values.begin(), val);
         return;
     }
-    if (time > values.back().mTime)
-    {
+    if (time > values.back().mTime) {
         MorphTimeValues val;
         val.mTime = time;
         val.mKeys.push_back(k);
         values.insert(values.end(), val);
         return;
     }
-    for (unsigned int i = 0; i < values.size(); i++)
-    {
-        if (std::abs(time - values[i].mTime) < 1e-6f)
-        {
+    for (unsigned int i = 0; i < values.size(); i++) {
+        if (std::abs(time - values[i].mTime) < ai_epsilon) {
             values[i].mKeys.push_back(k);
             return;
-        }
-        else if (time > values[i].mTime && time < values[i + 1].mTime)
-        {
+        } else if (time > values[i].mTime && time < values[i + 1].mTime) {
             MorphTimeValues val;
             val.mTime = time;
             val.mKeys.push_back(k);
@@ -1085,15 +1076,13 @@ void insertMorphTimeValue(std::vector<MorphTimeValues> &values, float time, floa
             return;
         }
     }
-    // should not get here
 }
 
-float getWeightAtKey(const std::vector<MorphTimeValues> &values, int key, unsigned int value)
-{
-    for (unsigned int i = 0; i < values[key].mKeys.size(); i++)
-    {
-        if (values[key].mKeys[i].mValue == value)
-            return values[key].mKeys[i].mWeight;
+static float getWeightAtKey(const std::vector<MorphTimeValues> &values, int key, unsigned int value) {
+    for (auto mKey : values[key].mKeys) {
+        if (mKey.mValue == value) {
+            return mKey.mWeight;
+        }
     }
     // no value at key found, try to interpolate if present at other keys. if not, return zero
     // TODO: interpolation
@@ -1102,67 +1091,67 @@ float getWeightAtKey(const std::vector<MorphTimeValues> &values, int key, unsign
 
 // ------------------------------------------------------------------------------------------------
 // Constructs the animation for the given source anim
-void ColladaLoader::CreateAnimation(aiScene* pScene, const ColladaParser& pParser, const Collada::Animation* pSrcAnim, const std::string& pName)
-{
+void ColladaLoader::CreateAnimation(aiScene *pScene, const ColladaParser &pParser, const Animation *pSrcAnim, const std::string &pName) {
     // collect a list of animatable nodes
-    std::vector<const aiNode*> nodes;
+    std::vector<const aiNode *> nodes;
     CollectNodes(pScene->mRootNode, nodes);
 
-    std::vector<aiNodeAnim*> anims;
-    std::vector<aiMeshMorphAnim*> morphAnims;
+    std::vector<aiNodeAnim *> anims;
+    std::vector<aiMeshMorphAnim *> morphAnims;
 
-    for (std::vector<const aiNode*>::const_iterator nit = nodes.begin(); nit != nodes.end(); ++nit)
-    {
+    for (auto node : nodes) {
         // find all the collada anim channels which refer to the current node
-        std::vector<Collada::ChannelEntry> entries;
-        std::string nodeName = (*nit)->mName.data;
+        std::vector<ChannelEntry> entries;
+        std::string nodeName = node->mName.data;
 
         // find the collada node corresponding to the aiNode
-        const Collada::Node* srcNode = FindNode(pParser.mRootNode, nodeName);
-        //      ai_assert( srcNode != NULL);
-        if (!srcNode)
+        const Node *srcNode = FindNode(pParser.mRootNode, nodeName);
+        if (!srcNode) {
             continue;
+        }
 
         // now check all channels if they affect the current node
         std::string targetID, subElement;
-        for (std::vector<Collada::AnimationChannel>::const_iterator cit = pSrcAnim->mChannels.begin();
-            cit != pSrcAnim->mChannels.end(); ++cit)
-        {
-            const Collada::AnimationChannel& srcChannel = *cit;
-            Collada::ChannelEntry entry;
+        for (std::vector<AnimationChannel>::const_iterator cit = pSrcAnim->mChannels.begin();
+                cit != pSrcAnim->mChannels.end(); ++cit) {
+            const AnimationChannel &srcChannel = *cit;
+            ChannelEntry entry;
 
             // we expect the animation target to be of type "nodeName/transformID.subElement". Ignore all others
             // find the slash that separates the node name - there should be only one
             std::string::size_type slashPos = srcChannel.mTarget.find('/');
-            if (slashPos == std::string::npos)
-            {
+            if (slashPos == std::string::npos) {
                 std::string::size_type targetPos = srcChannel.mTarget.find(srcNode->mID);
-                if (targetPos == std::string::npos)
+                if (targetPos == std::string::npos) {
                     continue;
+                }
 
                 // not node transform, but something else. store as unknown animation channel for now
                 entry.mChannel = &(*cit);
                 entry.mTargetId = srcChannel.mTarget.substr(targetPos + pSrcAnim->mName.length(),
-                    srcChannel.mTarget.length() - targetPos - pSrcAnim->mName.length());
-                if (entry.mTargetId.front() == '-')
+                        srcChannel.mTarget.length() - targetPos - pSrcAnim->mName.length());
+                if (entry.mTargetId.front() == '-') {
                     entry.mTargetId = entry.mTargetId.substr(1);
+                }
                 entries.push_back(entry);
                 continue;
             }
-            if (srcChannel.mTarget.find('/', slashPos + 1) != std::string::npos)
+            if (srcChannel.mTarget.find('/', slashPos + 1) != std::string::npos) {
                 continue;
+            }
 
             targetID.clear();
             targetID = srcChannel.mTarget.substr(0, slashPos);
-            if (targetID != srcNode->mID)
+            if (targetID != srcNode->mID) {
                 continue;
+            }
 
             // find the dot that separates the transformID - there should be only one or zero
             std::string::size_type dotPos = srcChannel.mTarget.find('.');
-            if (dotPos != std::string::npos)
-            {
-                if (srcChannel.mTarget.find('.', dotPos + 1) != std::string::npos)
+            if (dotPos != std::string::npos) {
+                if (srcChannel.mTarget.find('.', dotPos + 1) != std::string::npos) {
                     continue;
+                }
 
                 entry.mTransformId = srcChannel.mTarget.substr(slashPos + 1, dotPos - slashPos - 1);
 
@@ -1177,16 +1166,14 @@ void ColladaLoader::CreateAnimation(aiScene* pScene, const ColladaParser& pParse
                 else if (subElement == "Z")
                     entry.mSubElement = 2;
                 else
-                    ASSIMP_LOG_WARN_F("Unknown anim subelement <", subElement, ">. Ignoring");
-            }
-            else {
-                // no subelement following, transformId is remaining string
+                    ASSIMP_LOG_WARN("Unknown anim subelement <", subElement, ">. Ignoring");
+            } else {
+                // no sub-element following, transformId is remaining string
                 entry.mTransformId = srcChannel.mTarget.substr(slashPos + 1);
             }
 
             std::string::size_type bracketPos = srcChannel.mTarget.find('(');
-            if (bracketPos != std::string::npos)
-            {
+            if (bracketPos != std::string::npos) {
                 entry.mTransformId = srcChannel.mTarget.substr(slashPos + 1, bracketPos - slashPos - 1);
                 subElement.clear();
                 subElement = srcChannel.mTarget.substr(bracketPos);
@@ -1231,15 +1218,12 @@ void ColladaLoader::CreateAnimation(aiScene* pScene, const ColladaParser& pParse
                 if (srcNode->mTransforms[a].mID == entry.mTransformId)
                     entry.mTransformIndex = a;
 
-            if (entry.mTransformIndex == SIZE_MAX)
-            {
-                if (entry.mTransformId.find("morph-weights") != std::string::npos)
-                {
-                    entry.mTargetId = entry.mTransformId;
-                    entry.mTransformId = "";
-                }
-                else
+            if (entry.mTransformIndex == SIZE_MAX) {
+                if (entry.mTransformId.find("morph-weights") == std::string::npos) {
                     continue;
+                }
+                entry.mTargetId = entry.mTransformId;
+                entry.mTransformId = std::string();
             }
 
             entry.mChannel = &(*cit);
@@ -1247,25 +1231,24 @@ void ColladaLoader::CreateAnimation(aiScene* pScene, const ColladaParser& pParse
         }
 
         // if there's no channel affecting the current node, we skip it
-        if (entries.empty())
+        if (entries.empty()) {
             continue;
+        }
 
         // resolve the data pointers for all anim channels. Find the minimum time while we're at it
         ai_real startTime = ai_real(1e20), endTime = ai_real(-1e20);
-        for (std::vector<Collada::ChannelEntry>::iterator it = entries.begin(); it != entries.end(); ++it)
-        {
-            Collada::ChannelEntry& e = *it;
+        for (ChannelEntry & e : entries) {
             e.mTimeAccessor = &pParser.ResolveLibraryReference(pParser.mAccessorLibrary, e.mChannel->mSourceTimes);
             e.mTimeData = &pParser.ResolveLibraryReference(pParser.mDataLibrary, e.mTimeAccessor->mSource);
             e.mValueAccessor = &pParser.ResolveLibraryReference(pParser.mAccessorLibrary, e.mChannel->mSourceValues);
             e.mValueData = &pParser.ResolveLibraryReference(pParser.mDataLibrary, e.mValueAccessor->mSource);
 
             // time count and value count must match
-            if (e.mTimeAccessor->mCount != e.mValueAccessor->mCount)
-                throw DeadlyImportError(format() << "Time count / value count mismatch in animation channel \"" << e.mChannel->mTarget << "\".");
+            if (e.mTimeAccessor->mCount != e.mValueAccessor->mCount) {
+                throw DeadlyImportError("Time count / value count mismatch in animation channel \"", e.mChannel->mTarget, "\".");
+            }
 
-            if (e.mTimeAccessor->mCount > 0)
-            {
+            if (e.mTimeAccessor->mCount > 0) {
                 // find bounding times
                 startTime = std::min(startTime, ReadFloat(*e.mTimeAccessor, *e.mTimeData, 0, 0));
                 endTime = std::max(endTime, ReadFloat(*e.mTimeAccessor, *e.mTimeData, e.mTimeAccessor->mCount - 1, 0));
@@ -1273,30 +1256,26 @@ void ColladaLoader::CreateAnimation(aiScene* pScene, const ColladaParser& pParse
         }
 
         std::vector<aiMatrix4x4> resultTrafos;
-        if (!entries.empty() && entries.front().mTimeAccessor->mCount > 0)
-        {
+        if (!entries.empty() && entries.front().mTimeAccessor->mCount > 0) {
             // create a local transformation chain of the node's transforms
             std::vector<Collada::Transform> transforms = srcNode->mTransforms;
 
             // now for every unique point in time, find or interpolate the key values for that time
             // and apply them to the transform chain. Then the node's present transformation can be calculated.
             ai_real time = startTime;
-            while (1)
-            {
-                for (std::vector<Collada::ChannelEntry>::iterator it = entries.begin(); it != entries.end(); ++it)
-                {
-                    Collada::ChannelEntry& e = *it;
-
+            while (1) {
+                for (ChannelEntry & e : entries) {
                     // find the keyframe behind the current point in time
                     size_t pos = 0;
                     ai_real postTime = 0.0;
-                    while (1)
-                    {
-                        if (pos >= e.mTimeAccessor->mCount)
+                    while (1) {
+                        if (pos >= e.mTimeAccessor->mCount) {
                             break;
+                        }
                         postTime = ReadFloat(*e.mTimeAccessor, *e.mTimeData, pos, 0);
-                        if (postTime >= time)
+                        if (postTime >= time) {
                             break;
+                        }
                         ++pos;
                     }
 
@@ -1304,17 +1283,16 @@ void ColladaLoader::CreateAnimation(aiScene* pScene, const ColladaParser& pParse
 
                     // read values from there
                     ai_real temp[16];
-                    for (size_t c = 0; c < e.mValueAccessor->mSize; ++c)
+                    for (size_t c = 0; c < e.mValueAccessor->mSize; ++c) {
                         temp[c] = ReadFloat(*e.mValueAccessor, *e.mValueData, pos, c);
+                    }
 
                     // if not exactly at the key time, interpolate with previous value set
-                    if (postTime > time && pos > 0)
-                    {
+                    if (postTime > time && pos > 0) {
                         ai_real preTime = ReadFloat(*e.mTimeAccessor, *e.mTimeData, pos - 1, 0);
                         ai_real factor = (time - postTime) / (preTime - postTime);
 
-                        for (size_t c = 0; c < e.mValueAccessor->mSize; ++c)
-                        {
+                        for (size_t c = 0; c < e.mValueAccessor->mSize; ++c) {
                             ai_real v = ReadFloat(*e.mValueAccessor, *e.mValueData, pos - 1, c);
                             temp[c] += (v - temp[c]) * factor;
                         }
@@ -1333,17 +1311,12 @@ void ColladaLoader::CreateAnimation(aiScene* pScene, const ColladaParser& pParse
 
                 // find next point in time to evaluate. That's the closest frame larger than the current in any channel
                 ai_real nextTime = ai_real(1e20);
-                for (std::vector<Collada::ChannelEntry>::iterator it = entries.begin(); it != entries.end(); ++it)
-                {
-                    Collada::ChannelEntry& channelElement = *it;
-
+                for (ChannelEntry & channelElement : entries) {
                     // find the next time value larger than the current
                     size_t pos = 0;
-                    while (pos < channelElement.mTimeAccessor->mCount)
-                    {
+                    while (pos < channelElement.mTimeAccessor->mCount) {
                         const ai_real t = ReadFloat(*channelElement.mTimeAccessor, *channelElement.mTimeData, pos, 0);
-                        if (t > time)
-                        {
+                        if (t > time) {
                             nextTime = std::min(nextTime, t);
                             break;
                         }
@@ -1353,7 +1326,7 @@ void ColladaLoader::CreateAnimation(aiScene* pScene, const ColladaParser& pParse
                     // https://github.com/assimp/assimp/issues/458
                     // Sub-sample axis-angle channels if the delta between two consecutive
                     // key-frame angles is >= 180 degrees.
-                    if (transforms[channelElement.mTransformIndex].mType == Collada::TF_ROTATE && channelElement.mSubElement == 3 && pos > 0 && pos < channelElement.mTimeAccessor->mCount) {
+                    if (transforms[channelElement.mTransformIndex].mType == TF_ROTATE && channelElement.mSubElement == 3 && pos > 0 && pos < channelElement.mTimeAccessor->mCount) {
                         const ai_real cur_key_angle = ReadFloat(*channelElement.mValueAccessor, *channelElement.mValueData, pos, 0);
                         const ai_real last_key_angle = ReadFloat(*channelElement.mValueAccessor, *channelElement.mValueData, pos - 1, 0);
                         const ai_real cur_key_time = ReadFloat(*channelElement.mTimeAccessor, *channelElement.mTimeData, pos, 0);
@@ -1371,21 +1344,18 @@ void ColladaLoader::CreateAnimation(aiScene* pScene, const ColladaParser& pParse
                 }
 
                 // no more keys on any channel after the current time -> we're done
-                if (nextTime > 1e19)
+                if (nextTime > 1e19) {
                     break;
+                }
 
-                // else construct next keyframe at this following time point
+                // else construct next key-frame at this following time point
                 time = nextTime;
             }
         }
 
-        // there should be some keyframes, but we aren't that fixated on valid input data
-//      ai_assert( resultTrafos.size() > 0);
-
         // build an animation channel for the given node out of these trafo keys
-        if (!resultTrafos.empty())
-        {
-            aiNodeAnim* dstAnim = new aiNodeAnim;
+        if (!resultTrafos.empty()) {
+            aiNodeAnim *dstAnim = new aiNodeAnim;
             dstAnim->mNodeName = nodeName;
             dstAnim->mNumPositionKeys = static_cast<unsigned int>(resultTrafos.size());
             dstAnim->mNumRotationKeys = static_cast<unsigned int>(resultTrafos.size());
@@ -1394,41 +1364,35 @@ void ColladaLoader::CreateAnimation(aiScene* pScene, const ColladaParser& pParse
             dstAnim->mRotationKeys = new aiQuatKey[resultTrafos.size()];
             dstAnim->mScalingKeys = new aiVectorKey[resultTrafos.size()];
 
-            for (size_t a = 0; a < resultTrafos.size(); ++a)
-            {
+            for (size_t a = 0; a < resultTrafos.size(); ++a) {
                 aiMatrix4x4 mat = resultTrafos[a];
                 double time = double(mat.d4); // remember? time is stored in mat.d4
                 mat.d4 = 1.0f;
 
-                dstAnim->mPositionKeys[a].mTime = time;
-                dstAnim->mRotationKeys[a].mTime = time;
-                dstAnim->mScalingKeys[a].mTime = time;
+                dstAnim->mPositionKeys[a].mTime = time * kMillisecondsFromSeconds;
+                dstAnim->mRotationKeys[a].mTime = time * kMillisecondsFromSeconds;
+                dstAnim->mScalingKeys[a].mTime = time * kMillisecondsFromSeconds;
                 mat.Decompose(dstAnim->mScalingKeys[a].mValue, dstAnim->mRotationKeys[a].mValue, dstAnim->mPositionKeys[a].mValue);
             }
 
             anims.push_back(dstAnim);
-        }
-        else
-        {
+        } else {
             ASSIMP_LOG_WARN("Collada loader: found empty animation channel, ignored. Please check your exporter.");
         }
 
-        if (!entries.empty() && entries.front().mTimeAccessor->mCount > 0)
-        {
-            std::vector<Collada::ChannelEntry> morphChannels;
-            for (std::vector<Collada::ChannelEntry>::iterator it = entries.begin(); it != entries.end(); ++it)
-            {
-                Collada::ChannelEntry& e = *it;
-
+        if (!entries.empty() && entries.front().mTimeAccessor->mCount > 0) {
+            std::vector<ChannelEntry> morphChannels;
+            for (ChannelEntry & e : entries) {
                 // skip non-transform types
-                if (e.mTargetId.empty())
+                if (e.mTargetId.empty()) {
                     continue;
+                }
 
-                if (e.mTargetId.find("morph-weights") != std::string::npos)
+                if (e.mTargetId.find("morph-weights") != std::string::npos) {
                     morphChannels.push_back(e);
+                }
             }
-            if (morphChannels.size() > 0)
-            {
+            if (!morphChannels.empty()) {
                 // either 1) morph weight animation count should contain morph target count channels
                 // or     2) one channel with morph target count arrays
                 // assume first
@@ -1437,36 +1401,34 @@ void ColladaLoader::CreateAnimation(aiScene* pScene, const ColladaParser& pParse
                 morphAnim->mName.Set(nodeName);
 
                 std::vector<MorphTimeValues> morphTimeValues;
-
                 int morphAnimChannelIndex = 0;
-                for (std::vector<Collada::ChannelEntry>::iterator it = morphChannels.begin(); it != morphChannels.end(); ++it)
-                {
-                    Collada::ChannelEntry& e = *it;
+                for (ChannelEntry & e : morphChannels) {
                     std::string::size_type apos = e.mTargetId.find('(');
                     std::string::size_type bpos = e.mTargetId.find(')');
-                    if (apos == std::string::npos || bpos == std::string::npos)
-                        // unknown way to specify weight -> ignore this animation
+
+                    // If unknown way to specify weight -> ignore this animation
+                    if (apos == std::string::npos || bpos == std::string::npos) {
                         continue;
+                    }
 
                     // weight target can be in format Weight_M_N, Weight_N, WeightN, or some other way
                     // we ignore the name and just assume the channels are in the right order
-                    for (unsigned int i = 0; i < e.mTimeData->mValues.size(); i++)
-                        insertMorphTimeValue(morphTimeValues, e.mTimeData->mValues.at(i), e.mValueData->mValues.at(i), morphAnimChannelIndex);
+                    for (unsigned int i = 0; i < e.mTimeData->mValues.size(); i++) {
+                        insertMorphTimeValue(morphTimeValues, e.mTimeData->mValues[i], e.mValueData->mValues[i], morphAnimChannelIndex);
+                    }
 
                     ++morphAnimChannelIndex;
                 }
 
                 morphAnim->mNumKeys = static_cast<unsigned int>(morphTimeValues.size());
                 morphAnim->mKeys = new aiMeshMorphKey[morphAnim->mNumKeys];
-                for (unsigned int key = 0; key < morphAnim->mNumKeys; key++)
-                {
+                for (unsigned int key = 0; key < morphAnim->mNumKeys; key++) {
                     morphAnim->mKeys[key].mNumValuesAndWeights = static_cast<unsigned int>(morphChannels.size());
                     morphAnim->mKeys[key].mValues = new unsigned int[morphChannels.size()];
                     morphAnim->mKeys[key].mWeights = new double[morphChannels.size()];
 
-                    morphAnim->mKeys[key].mTime = morphTimeValues[key].mTime;
-                    for (unsigned int valueIndex = 0; valueIndex < morphChannels.size(); valueIndex++)
-                    {
+                    morphAnim->mKeys[key].mTime = morphTimeValues[key].mTime * kMillisecondsFromSeconds;
+                    for (unsigned int valueIndex = 0; valueIndex < morphChannels.size(); ++valueIndex) {
                         morphAnim->mKeys[key].mValues[valueIndex] = valueIndex;
                         morphAnim->mKeys[key].mWeights[valueIndex] = getWeightAtKey(morphTimeValues, key, valueIndex);
                     }
@@ -1477,90 +1439,90 @@ void ColladaLoader::CreateAnimation(aiScene* pScene, const ColladaParser& pParse
         }
     }
 
-    if (!anims.empty() || !morphAnims.empty())
-    {
-        aiAnimation* anim = new aiAnimation;
+    if (!anims.empty() || !morphAnims.empty()) {
+        aiAnimation *anim = new aiAnimation;
         anim->mName.Set(pName);
         anim->mNumChannels = static_cast<unsigned int>(anims.size());
-        if (anim->mNumChannels > 0)
-        {
-            anim->mChannels = new aiNodeAnim*[anims.size()];
+        if (anim->mNumChannels > 0) {
+            anim->mChannels = new aiNodeAnim *[anims.size()];
             std::copy(anims.begin(), anims.end(), anim->mChannels);
         }
         anim->mNumMorphMeshChannels = static_cast<unsigned int>(morphAnims.size());
-        if (anim->mNumMorphMeshChannels > 0)
-        {
-            anim->mMorphMeshChannels = new aiMeshMorphAnim*[anim->mNumMorphMeshChannels];
+        if (anim->mNumMorphMeshChannels > 0) {
+            anim->mMorphMeshChannels = new aiMeshMorphAnim *[anim->mNumMorphMeshChannels];
             std::copy(morphAnims.begin(), morphAnims.end(), anim->mMorphMeshChannels);
         }
         anim->mDuration = 0.0f;
-        for (size_t a = 0; a < anims.size(); ++a)
-        {
-            anim->mDuration = std::max(anim->mDuration, anims[a]->mPositionKeys[anims[a]->mNumPositionKeys - 1].mTime);
-            anim->mDuration = std::max(anim->mDuration, anims[a]->mRotationKeys[anims[a]->mNumRotationKeys - 1].mTime);
-            anim->mDuration = std::max(anim->mDuration, anims[a]->mScalingKeys[anims[a]->mNumScalingKeys - 1].mTime);
+        for (auto & a : anims) {
+            anim->mDuration = std::max(anim->mDuration, a->mPositionKeys[a->mNumPositionKeys - 1].mTime);
+            anim->mDuration = std::max(anim->mDuration, a->mRotationKeys[a->mNumRotationKeys - 1].mTime);
+            anim->mDuration = std::max(anim->mDuration, a->mScalingKeys[a->mNumScalingKeys - 1].mTime);
         }
-        for (size_t a = 0; a < morphAnims.size(); ++a)
-        {
-            anim->mDuration = std::max(anim->mDuration, morphAnims[a]->mKeys[morphAnims[a]->mNumKeys - 1].mTime);
+        for (auto & morphAnim : morphAnims) {
+            anim->mDuration = std::max(anim->mDuration, morphAnim->mKeys[morphAnim->mNumKeys - 1].mTime);
         }
-        anim->mTicksPerSecond = 1;
+        anim->mTicksPerSecond = 1000.0;
         mAnims.push_back(anim);
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Add a texture to a material structure
-void ColladaLoader::AddTexture(aiMaterial& mat, const ColladaParser& pParser,
-    const Collada::Effect& effect,
-    const Collada::Sampler& sampler,
-    aiTextureType type, unsigned int idx)
-{
+void ColladaLoader::AddTexture(aiMaterial &mat,
+        const ColladaParser &pParser,
+        const Effect &effect,
+        const Sampler &sampler,
+        aiTextureType type,
+        unsigned int idx) {
     // first of all, basic file name
     const aiString name = FindFilenameForEffectTexture(pParser, effect, sampler.mName);
     mat.AddProperty(&name, _AI_MATKEY_TEXTURE_BASE, type, idx);
 
     // mapping mode
     int map = aiTextureMapMode_Clamp;
-    if (sampler.mWrapU)
+    if (sampler.mWrapU) {
         map = aiTextureMapMode_Wrap;
-    if (sampler.mWrapU && sampler.mMirrorU)
+    }
+    if (sampler.mWrapU && sampler.mMirrorU) {
         map = aiTextureMapMode_Mirror;
+    }
 
     mat.AddProperty(&map, 1, _AI_MATKEY_MAPPINGMODE_U_BASE, type, idx);
 
     map = aiTextureMapMode_Clamp;
-    if (sampler.mWrapV)
+    if (sampler.mWrapV) {
         map = aiTextureMapMode_Wrap;
-    if (sampler.mWrapV && sampler.mMirrorV)
+    }
+    if (sampler.mWrapV && sampler.mMirrorV) {
         map = aiTextureMapMode_Mirror;
+    }
 
     mat.AddProperty(&map, 1, _AI_MATKEY_MAPPINGMODE_V_BASE, type, idx);
 
     // UV transformation
     mat.AddProperty(&sampler.mTransform, 1,
-        _AI_MATKEY_UVTRANSFORM_BASE, type, idx);
+            _AI_MATKEY_UVTRANSFORM_BASE, type, idx);
 
     // Blend mode
-    mat.AddProperty((int*)&sampler.mOp, 1,
-        _AI_MATKEY_TEXBLEND_BASE, type, idx);
+    mat.AddProperty((int *)&sampler.mOp, 1,
+            _AI_MATKEY_TEXBLEND_BASE, type, idx);
 
     // Blend factor
-    mat.AddProperty((ai_real*)&sampler.mWeighting, 1,
-        _AI_MATKEY_TEXBLEND_BASE, type, idx);
+    mat.AddProperty((ai_real *)&sampler.mWeighting, 1,
+            _AI_MATKEY_TEXBLEND_BASE, type, idx);
 
     // UV source index ... if we didn't resolve the mapping, it is actually just
     // a guess but it works in most cases. We search for the frst occurrence of a
     // number in the channel name. We assume it is the zero-based index into the
     // UV channel array of all corresponding meshes. It could also be one-based
     // for some exporters, but we won't care of it unless someone complains about.
-    if (sampler.mUVId != UINT_MAX)
+    if (sampler.mUVId != UINT_MAX) {
         map = sampler.mUVId;
-    else {
+    } else {
         map = -1;
         for (std::string::const_iterator it = sampler.mUVChannel.begin(); it != sampler.mUVChannel.end(); ++it) {
             if (IsNumeric(*it)) {
-                map = strtoul10(&(*it));
+                map = strtoul10(&(*it));        
                 break;
             }
         }
@@ -1574,20 +1536,17 @@ void ColladaLoader::AddTexture(aiMaterial& mat, const ColladaParser& pParser,
 
 // ------------------------------------------------------------------------------------------------
 // Fills materials from the collada material definitions
-void ColladaLoader::FillMaterials(const ColladaParser& pParser, aiScene* /*pScene*/)
-{
-    for (auto &elem : newMats)
-    {
-        aiMaterial&  mat = (aiMaterial&)*elem.second;
-        Collada::Effect& effect = *elem.first;
+void ColladaLoader::FillMaterials(const ColladaParser &pParser, aiScene * /*pScene*/) {
+    for (auto &elem : newMats) {
+        aiMaterial &mat = (aiMaterial &)*elem.second;
+        Collada::Effect &effect = *elem.first;
 
         // resolve shading mode
         int shadeMode;
-        if (effect.mFaceted) /* fixme */
+        if (effect.mFaceted) {
             shadeMode = aiShadingMode_Flat;
-        else {
-            switch (effect.mShadeType)
-            {
+        } else {
+            switch (effect.mShadeType) {
             case Collada::Shade_Constant:
                 shadeMode = aiShadingMode_NoShading;
                 break;
@@ -1613,7 +1572,7 @@ void ColladaLoader::FillMaterials(const ColladaParser& pParser, aiScene* /*pScen
         shadeMode = effect.mDoubleSided;
         mat.AddProperty<int>(&shadeMode, 1, AI_MATKEY_TWOSIDED);
 
-        // wireframe?
+        // wire-frame?
         shadeMode = effect.mWireframe;
         mat.AddProperty<int>(&shadeMode, 1, AI_MATKEY_ENABLE_WIREFRAME);
 
@@ -1637,17 +1596,14 @@ void ColladaLoader::FillMaterials(const ColladaParser& pParser, aiScene* /*pScen
             // handle RGB transparency completely, cf Collada specs 1.5.0 pages 249 and 304
             if (effect.mRGBTransparency) {
                 // use luminance as defined by ISO/CIE color standards (see ITU-R Recommendation BT.709-4)
-                effect.mTransparency *= (
-                    0.212671f * effect.mTransparent.r +
-                    0.715160f * effect.mTransparent.g +
-                    0.072169f * effect.mTransparent.b
-                    );
+                effect.mTransparency *= (0.212671f * effect.mTransparent.r +
+                                         0.715160f * effect.mTransparent.g +
+                                         0.072169f * effect.mTransparent.b);
 
                 effect.mTransparent.a = 1.f;
 
                 mat.AddProperty(&effect.mTransparent, 1, AI_MATKEY_COLOR_TRANSPARENT);
-            }
-            else {
+            } else {
                 effect.mTransparency *= effect.mTransparent.a;
             }
 
@@ -1689,63 +1645,43 @@ void ColladaLoader::FillMaterials(const ColladaParser& pParser, aiScene* /*pScen
 
 // ------------------------------------------------------------------------------------------------
 // Constructs materials from the collada material definitions
-void ColladaLoader::BuildMaterials(ColladaParser& pParser, aiScene* /*pScene*/)
-{
+void ColladaLoader::BuildMaterials(ColladaParser &pParser, aiScene * /*pScene*/) {
     newMats.reserve(pParser.mMaterialLibrary.size());
 
     for (ColladaParser::MaterialLibrary::const_iterator matIt = pParser.mMaterialLibrary.begin();
-        matIt != pParser.mMaterialLibrary.end(); ++matIt) {
-        const Collada::Material& material = matIt->second;
+            matIt != pParser.mMaterialLibrary.end(); ++matIt) {
+        const Material &material = matIt->second;
         // a material is only a reference to an effect
         ColladaParser::EffectLibrary::iterator effIt = pParser.mEffectLibrary.find(material.mEffect);
         if (effIt == pParser.mEffectLibrary.end())
             continue;
-        Collada::Effect& effect = effIt->second;
+        Effect &effect = effIt->second;
 
         // create material
-        aiMaterial* mat = new aiMaterial;
+        aiMaterial *mat = new aiMaterial;
         aiString name(material.mName.empty() ? matIt->first : material.mName);
         mat->AddProperty(&name, AI_MATKEY_NAME);
 
         // store the material
         mMaterialIndexByName[matIt->first] = newMats.size();
-        newMats.push_back(std::pair<Collada::Effect*, aiMaterial*>(&effect, mat));
+        newMats.emplace_back(&effect, mat);
     }
     // ScenePreprocessor generates a default material automatically if none is there.
     // All further code here in this loader works well without a valid material so
     // we can safely let it to ScenePreprocessor.
-#if 0
-    if (newMats.size() == 0)
-    {
-        aiMaterial* mat = new aiMaterial;
-        aiString name(AI_DEFAULT_MATERIAL_NAME);
-        mat->AddProperty(&name, AI_MATKEY_NAME);
-
-        const int shadeMode = aiShadingMode_Phong;
-        mat->AddProperty<int>(&shadeMode, 1, AI_MATKEY_SHADING_MODEL);
-        aiColor4D colAmbient(0.2, 0.2, 0.2, 1.0), colDiffuse(0.8, 0.8, 0.8, 1.0), colSpecular(0.5, 0.5, 0.5, 0.5);
-        mat->AddProperty(&colAmbient, 1, AI_MATKEY_COLOR_AMBIENT);
-        mat->AddProperty(&colDiffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
-        mat->AddProperty(&colSpecular, 1, AI_MATKEY_COLOR_SPECULAR);
-        const ai_real specExp = 5.0;
-        mat->AddProperty(&specExp, 1, AI_MATKEY_SHININESS);
-}
-#endif
 }
 
 // ------------------------------------------------------------------------------------------------
-// Resolves the texture name for the given effect texture entry
-aiString ColladaLoader::FindFilenameForEffectTexture(const ColladaParser& pParser,
-    const Collada::Effect& pEffect, const std::string& pName)
-{
+// Resolves the texture name for the given effect texture entry and loads the texture data
+aiString ColladaLoader::FindFilenameForEffectTexture(const ColladaParser &pParser,
+        const Effect &pEffect, const std::string &pName) {
     aiString result;
 
     // recurse through the param references until we end up at an image
     std::string name = pName;
-    while (1)
-    {
+    while (1) {
         // the given string is a param entry. Find it
-        Collada::Effect::ParamLibrary::const_iterator it = pEffect.mParams.find(name);
+        Effect::ParamLibrary::const_iterator it = pEffect.mParams.find(name);
         // if not found, we're at the end of the recursion. The resulting string should be the image ID
         if (it == pEffect.mParams.end())
             break;
@@ -1756,32 +1692,25 @@ aiString ColladaLoader::FindFilenameForEffectTexture(const ColladaParser& pParse
 
     // find the image referred by this name in the image library of the scene
     ColladaParser::ImageLibrary::const_iterator imIt = pParser.mImageLibrary.find(name);
-    if (imIt == pParser.mImageLibrary.end())
-    {
-        ASSIMP_LOG_WARN_F("Collada: Unable to resolve effect texture entry \"", pName, "\", ended up at ID \"", name, "\".");
+    if (imIt == pParser.mImageLibrary.end()) {
+        ASSIMP_LOG_WARN("Collada: Unable to resolve effect texture entry \"", pName, "\", ended up at ID \"", name, "\".");
 
         //set default texture file name
         result.Set(name + ".jpg");
-        ConvertPath(result);
+        ColladaParser::UriDecodePath(result);
         return result;
     }
 
     // if this is an embedded texture image setup an aiTexture for it
-    if (!imIt->second.mImageData.empty())
-    {
-        aiTexture* tex = new aiTexture();
+    if (!imIt->second.mImageData.empty()) {
+        aiTexture *tex = new aiTexture();
 
         // Store embedded texture name reference
         tex->mFilename.Set(imIt->second.mFileName.c_str());
         result.Set(imIt->second.mFileName);
 
-        // TODO: check the possibility of using the flag "AI_CONFIG_IMPORT_FBX_EMBEDDED_TEXTURES_LEGACY_NAMING"
-//        result.data[0] = '*';
-//        result.length = 1 + ASSIMP_itoa10(result.data + 1, static_cast<unsigned int>(MAXLEN - 1), static_cast<int32_t>(mTextures.size()));
-
-
         // setup format hint
-        if (imIt->second.mEmbeddedFormat.length() > 3) {
+        if (imIt->second.mEmbeddedFormat.length() >= HINTMAXTEXTURELEN) {
             ASSIMP_LOG_WARN("Collada: texture format hint is too long, truncating to 3 characters");
         }
         strncpy(tex->achFormatHint, imIt->second.mEmbeddedFormat.c_str(), 3);
@@ -1789,79 +1718,26 @@ aiString ColladaLoader::FindFilenameForEffectTexture(const ColladaParser& pParse
         // and copy texture data
         tex->mHeight = 0;
         tex->mWidth = static_cast<unsigned int>(imIt->second.mImageData.size());
-        tex->pcData = (aiTexel*)new char[tex->mWidth];
+        tex->pcData = (aiTexel *)new char[tex->mWidth];
         memcpy(tex->pcData, &imIt->second.mImageData[0], tex->mWidth);
 
         // and add this texture to the list
         mTextures.push_back(tex);
+        return result;
     }
-    else
-    {
-        if (imIt->second.mFileName.empty()) {
-            throw DeadlyImportError("Collada: Invalid texture, no data or file reference given");
-        }
 
-        result.Set(imIt->second.mFileName);
-        ConvertPath(result);
+    if (imIt->second.mFileName.empty()) {
+        throw DeadlyImportError("Collada: Invalid texture, no data or file reference given");
     }
+
+    result.Set(imIt->second.mFileName);
+
     return result;
 }
 
-// ------------------------------------------------------------------------------------------------
-// Convert a path read from a collada file to the usual representation
-void ColladaLoader::ConvertPath(aiString& ss)
-{
-    // TODO: collada spec, p 22. Handle URI correctly.
-    // For the moment we're just stripping the file:// away to make it work.
-    // Windows doesn't seem to be able to find stuff like
-    // 'file://..\LWO\LWO2\MappingModes\earthSpherical.jpg'
-    if (0 == strncmp(ss.data, "file://", 7))
-    {
-        ss.length -= 7;
-        memmove(ss.data, ss.data + 7, ss.length);
-        ss.data[ss.length] = '\0';
-    }
-
-    // Maxon Cinema Collada Export writes "file:///C:\andsoon" with three slashes...
-    // I need to filter it without destroying linux paths starting with "/somewhere"
-#if defined( _MSC_VER )
-    if (ss.data[0] == '/' && isalpha((unsigned char)ss.data[1]) && ss.data[2] == ':') {
-#else
-    if (ss.data[0] == '/' && isalpha(ss.data[1]) && ss.data[2] == ':') {
-#endif
-        --ss.length;
-        ::memmove(ss.data, ss.data + 1, ss.length);
-        ss.data[ss.length] = 0;
-    }
-
-    // find and convert all %xy special chars
-    char* out = ss.data;
-    for (const char* it = ss.data; it != ss.data + ss.length; /**/)
-    {
-        if (*it == '%' && (it + 3) < ss.data + ss.length)
-        {
-            // separate the number to avoid dragging in chars from behind into the parsing
-            char mychar[3] = { it[1], it[2], 0 };
-            size_t nbr = strtoul16(mychar);
-            it += 3;
-            *out++ = (char)(nbr & 0xFF);
-        }
-        else
-        {
-            *out++ = *it++;
-        }
-    }
-
-    // adjust length and terminator of the shortened string
-    *out = 0;
-    ss.length = (ptrdiff_t)(out - ss.data);
-}
-
 // ------------------------------------------------------------------------------------------------
 // Reads a float value from an accessor and its data array.
-ai_real ColladaLoader::ReadFloat(const Collada::Accessor& pAccessor, const Collada::Data& pData, size_t pIndex, size_t pOffset) const
-{
-    // FIXME: (thom) Test for data type here in every access? For the moment, I leave this to the caller
+ai_real ColladaLoader::ReadFloat(const Accessor &pAccessor, const Data &pData, size_t pIndex, size_t pOffset) const {
     size_t pos = pAccessor.mStride * pIndex + pAccessor.mOffset + pOffset;
     ai_assert(pos < pData.mValues.size());
     return pData.mValues[pos];
@@ -1869,8 +1745,7 @@ ai_real ColladaLoader::ReadFloat(const Collada::Accessor& pAccessor, const Colla
 
 // ------------------------------------------------------------------------------------------------
 // Reads a string value from an accessor and its data array.
-const std::string& ColladaLoader::ReadString(const Collada::Accessor& pAccessor, const Collada::Data& pData, size_t pIndex) const
-{
+const std::string &ColladaLoader::ReadString(const Accessor &pAccessor, const Data &pData, size_t pIndex) const {
     size_t pos = pAccessor.mStride * pIndex + pAccessor.mOffset;
     ai_assert(pos < pData.mStrings.size());
     return pData.mStrings[pos];
@@ -1878,8 +1753,7 @@ const std::string& ColladaLoader::ReadString(const Collada::Accessor& pAccessor,
 
 // ------------------------------------------------------------------------------------------------
 // Collects all nodes into the given array
-void ColladaLoader::CollectNodes(const aiNode* pNode, std::vector<const aiNode*>& poNodes) const
-{
+void ColladaLoader::CollectNodes(const aiNode *pNode, std::vector<const aiNode *> &poNodes) const {
     poNodes.push_back(pNode);
     for (size_t a = 0; a < pNode->mNumChildren; ++a) {
         CollectNodes(pNode->mChildren[a], poNodes);
@@ -1888,24 +1762,23 @@ void ColladaLoader::CollectNodes(const aiNode* pNode, std::vector<const aiNode*>
 
 // ------------------------------------------------------------------------------------------------
 // Finds a node in the collada scene by the given name
-const Collada::Node* ColladaLoader::FindNode(const Collada::Node* pNode, const std::string& pName) const
-{
+const Node *ColladaLoader::FindNode(const Node *pNode, const std::string &pName) const {
     if (pNode->mName == pName || pNode->mID == pName)
         return pNode;
 
-    for (size_t a = 0; a < pNode->mChildren.size(); ++a)
-    {
-        const Collada::Node* node = FindNode(pNode->mChildren[a], pName);
-        if (node)
+    for (auto a : pNode->mChildren) {
+        const Collada::Node *node = FindNode(a, pName);
+        if (node) {
             return node;
+        }
     }
 
-    return NULL;
+    return nullptr;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Finds a node in the collada scene by the given SID
-const Collada::Node* ColladaLoader::FindNodeBySID( const Collada::Node* pNode, const std::string& pSID) const {
+const Node *ColladaLoader::FindNodeBySID(const Node *pNode, const std::string &pSID) const {
     if (nullptr == pNode) {
         return nullptr;
     }
@@ -1914,8 +1787,8 @@ const Collada::Node* ColladaLoader::FindNodeBySID( const Collada::Node* pNode, c
         return pNode;
     }
 
-    for( size_t a = 0; a < pNode->mChildren.size(); ++a) {
-        const Collada::Node* node = FindNodeBySID( pNode->mChildren[a], pSID);
+    for (auto a : pNode->mChildren) {
+        const Collada::Node *node = FindNodeBySID(a, pSID);
         if (node) {
             return node;
         }
@@ -1927,28 +1800,22 @@ const Collada::Node* ColladaLoader::FindNodeBySID( const Collada::Node* pNode, c
 // ------------------------------------------------------------------------------------------------
 // Finds a proper unique name for a node derived from the collada-node's properties.
 // The name must be unique for proper node-bone association.
-std::string ColladaLoader::FindNameForNode(const Collada::Node* pNode)
-{
+std::string ColladaLoader::FindNameForNode(const Node *pNode) {
     // If explicitly requested, just use the collada name.
-    if (useColladaName)
-    {
+    if (useColladaName) {
         if (!pNode->mName.empty()) {
             return pNode->mName;
-        }
-        else {
+        } else {
             return format() << "$ColladaAutoName$_" << mNodeNameCounter++;
         }
-    }
-    else
-    {
+    } else {
         // Now setup the name of the assimp node. The collada name might not be
         // unique, so we use the collada ID.
         if (!pNode->mID.empty())
             return pNode->mID;
         else if (!pNode->mSID.empty())
             return pNode->mSID;
-        else
-        {
+        else {
             // No need to worry. Unnamed nodes are no problem at all, except
             // if cameras or lights need to be assigned to them.
             return format() << "$ColladaAutoName$_" << mNodeNameCounter++;
diff --git a/Engine/lib/assimp/code/Collada/ColladaLoader.h b/Engine/lib/assimp/code/AssetLib/Collada/ColladaLoader.h
similarity index 57%
rename from Engine/lib/assimp/code/Collada/ColladaLoader.h
rename to Engine/lib/assimp/code/AssetLib/Collada/ColladaLoader.h
index dce46e06f..246abed22 100644
--- a/Engine/lib/assimp/code/Collada/ColladaLoader.h
+++ b/Engine/lib/assimp/code/AssetLib/Collada/ColladaLoader.h
@@ -4,7 +4,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -45,8 +45,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_COLLADALOADER_H_INC
 #define AI_COLLADALOADER_H_INC
 
-#include <assimp/BaseImporter.h>
 #include "ColladaParser.h"
+#include <assimp/BaseImporter.h>
 
 struct aiNode;
 struct aiCamera;
@@ -54,28 +54,24 @@ struct aiLight;
 struct aiTexture;
 struct aiAnimation;
 
-namespace Assimp
-{
+namespace Assimp {
 
-struct ColladaMeshIndex
-{
+struct ColladaMeshIndex {
     std::string mMeshID;
     size_t mSubMesh;
     std::string mMaterial;
-    ColladaMeshIndex( const std::string& pMeshID, size_t pSubMesh, const std::string& pMaterial)
-        : mMeshID( pMeshID), mSubMesh( pSubMesh), mMaterial( pMaterial)
-    {   }
+    ColladaMeshIndex(const std::string &pMeshID, size_t pSubMesh, const std::string &pMaterial) :
+            mMeshID(pMeshID), mSubMesh(pSubMesh), mMaterial(pMaterial) {
+        ai_assert(!pMeshID.empty());
+    }
 
-    bool operator < (const ColladaMeshIndex& p) const
-    {
-        if( mMeshID == p.mMeshID)
-        {
-            if( mSubMesh == p.mSubMesh)
+    bool operator<(const ColladaMeshIndex &p) const {
+        if (mMeshID == p.mMeshID) {
+            if (mSubMesh == p.mSubMesh)
                 return mMaterial < p.mMaterial;
             else
                 return mSubMesh < p.mSubMesh;
-        } else
-        {
+        } else {
             return mMeshID < p.mMeshID;
         }
     }
@@ -84,108 +80,102 @@ struct ColladaMeshIndex
 /** Loader class to read Collada scenes. Collada is over-engineered to death, with every new iteration bringing
  * more useless stuff, so I limited the data to what I think is useful for games.
 */
-class ColladaLoader : public BaseImporter
-{
+class ColladaLoader : public BaseImporter {
 public:
+    /// The class constructor.
     ColladaLoader();
-    ~ColladaLoader();
 
+    /// The class destructor.
+    ~ColladaLoader() override;
 
-public:
-    /** Returns whether the class can handle the format of the given file.
-     * See BaseImporter::CanRead() for details. */
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const override;
+    /// Returns whether the class can handle the format of the given file.
+    /// @see BaseImporter::CanRead() for more details.
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const override;
 
 protected:
-    /** Return importer meta information.
-     * See #BaseImporter::GetInfo for the details
-     */
-    const aiImporterDesc* GetInfo () const override;
+    /// See #BaseImporter::GetInfo for the details
+    const aiImporterDesc *GetInfo() const override;
 
-    void SetupProperties(const Importer* pImp) override;
+    /// See #BaseImporter::SetupProperties for the details
+    void SetupProperties(const Importer *pImp) override;
 
-    /** Imports the given file into the given scene structure.
-     * See BaseImporter::InternReadFile() for details
-     */
-    void InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) override;
+    /// See #BaseImporter::InternReadFile for the details
+    void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) override;
 
     /** Recursively constructs a scene node for the given parser node and returns it. */
-    aiNode* BuildHierarchy( const ColladaParser& pParser, const Collada::Node* pNode);
+    aiNode *BuildHierarchy(const ColladaParser &pParser, const Collada::Node *pNode);
 
     /** Resolve node instances */
-    void ResolveNodeInstances( const ColladaParser& pParser, const Collada::Node* pNode,
-        std::vector<const Collada::Node*>& resolved);
+    void ResolveNodeInstances(const ColladaParser &pParser, const Collada::Node *pNode,
+            std::vector<const Collada::Node *> &resolved);
 
     /** Builds meshes for the given node and references them */
-    void BuildMeshesForNode( const ColladaParser& pParser, const Collada::Node* pNode,
-        aiNode* pTarget);
-		
-    aiMesh *findMesh(const std::string& meshid);
+    void BuildMeshesForNode(const ColladaParser &pParser, const Collada::Node *pNode,
+            aiNode *pTarget);
+
+    aiMesh *findMesh(const std::string &meshid);
 
     /** Creates a mesh for the given ColladaMesh face subset and returns the newly created mesh */
-    aiMesh* CreateMesh( const ColladaParser& pParser, const Collada::Mesh* pSrcMesh, const Collada::SubMesh& pSubMesh,
-        const Collada::Controller* pSrcController, size_t pStartVertex, size_t pStartFace);
+    aiMesh *CreateMesh(const ColladaParser &pParser, const Collada::Mesh *pSrcMesh, const Collada::SubMesh &pSubMesh,
+            const Collada::Controller *pSrcController, size_t pStartVertex, size_t pStartFace);
 
     /** Builds cameras for the given node and references them */
-    void BuildCamerasForNode( const ColladaParser& pParser, const Collada::Node* pNode,
-        aiNode* pTarget);
+    void BuildCamerasForNode(const ColladaParser &pParser, const Collada::Node *pNode,
+            aiNode *pTarget);
 
     /** Builds lights for the given node and references them */
-    void BuildLightsForNode( const ColladaParser& pParser, const Collada::Node* pNode,
-        aiNode* pTarget);
+    void BuildLightsForNode(const ColladaParser &pParser, const Collada::Node *pNode,
+            aiNode *pTarget);
 
     /** Stores all meshes in the given scene */
-    void StoreSceneMeshes( aiScene* pScene);
+    void StoreSceneMeshes(aiScene *pScene);
 
     /** Stores all materials in the given scene */
-    void StoreSceneMaterials( aiScene* pScene);
+    void StoreSceneMaterials(aiScene *pScene);
 
     /** Stores all lights in the given scene */
-    void StoreSceneLights( aiScene* pScene);
+    void StoreSceneLights(aiScene *pScene);
 
     /** Stores all cameras in the given scene */
-    void StoreSceneCameras( aiScene* pScene);
+    void StoreSceneCameras(aiScene *pScene);
 
     /** Stores all textures in the given scene */
-    void StoreSceneTextures( aiScene* pScene);
+    void StoreSceneTextures(aiScene *pScene);
 
     /** Stores all animations
      * @param pScene target scene to store the anims
      */
-    void StoreAnimations( aiScene* pScene, const ColladaParser& pParser);
+    void StoreAnimations(aiScene *pScene, const ColladaParser &pParser);
 
     /** Stores all animations for the given source anim and its nested child animations
      * @param pScene target scene to store the anims
      * @param pSrcAnim the source animation to process
      * @param pPrefix Prefix to the name in case of nested animations
      */
-    void StoreAnimations( aiScene* pScene, const ColladaParser& pParser, const Collada::Animation* pSrcAnim, const std::string& pPrefix);
+    void StoreAnimations(aiScene *pScene, const ColladaParser &pParser, const Collada::Animation *pSrcAnim, const std::string &pPrefix);
 
     /** Constructs the animation for the given source anim */
-    void CreateAnimation( aiScene* pScene, const ColladaParser& pParser, const Collada::Animation* pSrcAnim, const std::string& pName);
+    void CreateAnimation(aiScene *pScene, const ColladaParser &pParser, const Collada::Animation *pSrcAnim, const std::string &pName);
 
     /** Constructs materials from the collada material definitions */
-    void BuildMaterials( ColladaParser& pParser, aiScene* pScene);
+    void BuildMaterials(ColladaParser &pParser, aiScene *pScene);
 
     /** Fill materials from the collada material definitions */
-    void FillMaterials( const ColladaParser& pParser, aiScene* pScene);
+    void FillMaterials(const ColladaParser &pParser, aiScene *pScene);
 
     /** Resolve UV channel mappings*/
-    void ApplyVertexToEffectSemanticMapping(Collada::Sampler& sampler,
-        const Collada::SemanticMappingTable& table);
+    void ApplyVertexToEffectSemanticMapping(Collada::Sampler &sampler,
+            const Collada::SemanticMappingTable &table);
 
     /** Add a texture and all of its sampling properties to a material*/
-    void AddTexture ( aiMaterial& mat, const ColladaParser& pParser,
-        const Collada::Effect& effect,
-        const Collada::Sampler& sampler,
-        aiTextureType type, unsigned int idx = 0);
+    void AddTexture(aiMaterial &mat, const ColladaParser &pParser,
+            const Collada::Effect &effect,
+            const Collada::Sampler &sampler,
+            aiTextureType type, unsigned int idx = 0);
 
     /** Resolves the texture name for the given effect texture entry */
-    aiString FindFilenameForEffectTexture( const ColladaParser& pParser,
-        const Collada::Effect& pEffect, const std::string& pName);
-
-    /** Converts a path read from a collada file to the usual representation */
-    void ConvertPath( aiString& ss);
+    aiString FindFilenameForEffectTexture(const ColladaParser &pParser,
+            const Collada::Effect &pEffect, const std::string &pName);
 
     /** Reads a float value from an accessor and its data array.
      * @param pAccessor The accessor to use for reading
@@ -194,7 +184,7 @@ protected:
      * @param pOffset Offset into the element, for multipart elements such as vectors or matrices
      * @return the specified value
      */
-    ai_real ReadFloat( const Collada::Accessor& pAccessor, const Collada::Data& pData, size_t pIndex, size_t pOffset) const;
+    ai_real ReadFloat(const Collada::Accessor &pAccessor, const Collada::Data &pData, size_t pIndex, size_t pOffset) const;
 
     /** Reads a string value from an accessor and its data array.
      * @param pAccessor The accessor to use for reading
@@ -202,18 +192,18 @@ protected:
      * @param pIndex The index of the element to retrieve
      * @return the specified value
      */
-    const std::string& ReadString( const Collada::Accessor& pAccessor, const Collada::Data& pData, size_t pIndex) const;
+    const std::string &ReadString(const Collada::Accessor &pAccessor, const Collada::Data &pData, size_t pIndex) const;
 
     /** Recursively collects all nodes into the given array */
-    void CollectNodes( const aiNode* pNode, std::vector<const aiNode*>& poNodes) const;
+    void CollectNodes(const aiNode *pNode, std::vector<const aiNode *> &poNodes) const;
 
     /** Finds a node in the collada scene by the given name */
-    const Collada::Node* FindNode( const Collada::Node* pNode, const std::string& pName) const;
+    const Collada::Node *FindNode(const Collada::Node *pNode, const std::string &pName) const;
     /** Finds a node in the collada scene by the given SID */
-    const Collada::Node* FindNodeBySID( const Collada::Node* pNode, const std::string& pSID) const;
+    const Collada::Node *FindNodeBySID(const Collada::Node *pNode, const std::string &pSID) const;
 
     /** Finds a proper name for a node derived from the collada-node's properties */
-    std::string FindNameForNode( const Collada::Node* pNode);
+    std::string FindNameForNode(const Collada::Node *pNode);
 
 protected:
     /** Filename, for a verbose error message */
@@ -226,25 +216,25 @@ protected:
     std::map<std::string, size_t> mMaterialIndexByName;
 
     /** Accumulated meshes for the target scene */
-    std::vector<aiMesh*> mMeshes;
-	
+    std::vector<aiMesh *> mMeshes;
+
     /** Accumulated morph target meshes */
-    std::vector<aiMesh*> mTargetMeshes;
+    std::vector<aiMesh *> mTargetMeshes;
 
     /** Temporary material list */
-    std::vector<std::pair<Collada::Effect*, aiMaterial*> > newMats;
+    std::vector<std::pair<Collada::Effect *, aiMaterial *>> newMats;
 
     /** Temporary camera list */
-    std::vector<aiCamera*> mCameras;
+    std::vector<aiCamera *> mCameras;
 
     /** Temporary light list */
-    std::vector<aiLight*> mLights;
+    std::vector<aiLight *> mLights;
 
     /** Temporary texture list */
-    std::vector<aiTexture*> mTextures;
+    std::vector<aiTexture *> mTextures;
 
     /** Accumulated animations for the target scene */
-    std::vector<aiAnimation*> mAnims;
+    std::vector<aiAnimation *> mAnims;
 
     bool noSkeletonMesh;
     bool ignoreUpDirection;
diff --git a/Engine/lib/assimp/code/AssetLib/Collada/ColladaParser.cpp b/Engine/lib/assimp/code/AssetLib/Collada/ColladaParser.cpp
new file mode 100644
index 000000000..922d1f6b2
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Collada/ColladaParser.cpp
@@ -0,0 +1,2402 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file ColladaParser.cpp
+ *  @brief Implementation of the Collada parser helper
+ */
+
+#ifndef ASSIMP_BUILD_NO_COLLADA_IMPORTER
+
+#include "ColladaParser.h"
+#include <assimp/ParsingUtils.h>
+#include <assimp/StringUtils.h>
+#include <assimp/ZipArchiveIOSystem.h>
+#include <assimp/commonMetaData.h>
+#include <assimp/fast_atof.h>
+#include <assimp/light.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOSystem.hpp>
+#include <memory>
+
+using namespace Assimp;
+using namespace Assimp::Collada;
+using namespace Assimp::Formatter;
+
+static void ReportWarning(const char *msg, ...) {
+    ai_assert(nullptr != msg);
+
+    va_list args;
+    va_start(args, msg);
+
+    char szBuffer[3000];
+    const int iLen = vsprintf(szBuffer, msg, args);
+    ai_assert(iLen > 0);
+
+    va_end(args);
+    ASSIMP_LOG_WARN("Validation warning: ", std::string(szBuffer, iLen));
+}
+
+static bool FindCommonKey(const std::string &collada_key, const MetaKeyPairVector &key_renaming, size_t &found_index) {
+    for (size_t i = 0; i < key_renaming.size(); ++i) {
+        if (key_renaming[i].first == collada_key) {
+            found_index = i;
+            return true;
+        }
+    }
+    found_index = std::numeric_limits<size_t>::max();
+
+    return false;
+}
+
+static void readUrlAttribute(XmlNode &node, std::string &url) {
+    url.clear();
+    if (!XmlParser::getStdStrAttribute(node, "url", url)) {
+        return;
+    }
+    if (url[0] != '#') {
+        throw DeadlyImportError("Unknown reference format");
+    }
+    url = url.c_str() + 1;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Constructor to be privately used by Importer
+ColladaParser::ColladaParser(IOSystem *pIOHandler, const std::string &pFile) :
+        mFileName(pFile),
+        mXmlParser(),
+        mDataLibrary(),
+        mAccessorLibrary(),
+        mMeshLibrary(),
+        mNodeLibrary(),
+        mImageLibrary(),
+        mEffectLibrary(),
+        mMaterialLibrary(),
+        mLightLibrary(),
+        mCameraLibrary(),
+        mControllerLibrary(),
+        mRootNode(nullptr),
+        mAnims(),
+        mUnitSize(1.0f),
+        mUpDirection(UP_Y),
+        mFormat(FV_1_5_n) {
+    if (nullptr == pIOHandler) {
+        throw DeadlyImportError("IOSystem is nullptr.");
+    }
+
+    std::unique_ptr<IOStream> daefile;
+    std::unique_ptr<ZipArchiveIOSystem> zip_archive;
+
+    // Determine type
+    std::string extension = BaseImporter::GetExtension(pFile);
+    if (extension != "dae") {
+        zip_archive.reset(new ZipArchiveIOSystem(pIOHandler, pFile));
+    }
+
+    if (zip_archive && zip_archive->isOpen()) {
+        std::string dae_filename = ReadZaeManifest(*zip_archive);
+
+        if (dae_filename.empty()) {
+            throw DeadlyImportError("Invalid ZAE");
+        }
+
+        daefile.reset(zip_archive->Open(dae_filename.c_str()));
+        if (daefile == nullptr) {
+            throw DeadlyImportError("Invalid ZAE manifest: '", dae_filename, "' is missing");
+        }
+    } else {
+        // attempt to open the file directly
+        daefile.reset(pIOHandler->Open(pFile));
+        if (daefile.get() == nullptr) {
+            throw DeadlyImportError("Failed to open file '", pFile, "'.");
+        }
+    }
+
+    // generate a XML reader for it
+    if (!mXmlParser.parse(daefile.get())) {
+        throw DeadlyImportError("Unable to read file, malformed XML");
+    }
+    // start reading
+    XmlNode node = mXmlParser.getRootNode();
+    XmlNode colladaNode = node.child("COLLADA");
+    if (colladaNode.empty()) {
+        return;
+    }
+
+    // Read content and embedded textures
+    ReadContents(colladaNode);
+    if (zip_archive && zip_archive->isOpen()) {
+        ReadEmbeddedTextures(*zip_archive);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor, private as well
+ColladaParser::~ColladaParser() {
+    for (auto &it : mNodeLibrary) {
+        delete it.second;
+    }
+    for (auto &it : mMeshLibrary) {
+        delete it.second;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Read a ZAE manifest and return the filename to attempt to open
+std::string ColladaParser::ReadZaeManifest(ZipArchiveIOSystem &zip_archive) {
+    // Open the manifest
+    std::unique_ptr<IOStream> manifestfile(zip_archive.Open("manifest.xml"));
+    if (manifestfile == nullptr) {
+        // No manifest, hope there is only one .DAE inside
+        std::vector<std::string> file_list;
+        zip_archive.getFileListExtension(file_list, "dae");
+
+        if (file_list.empty()) {
+            return std::string();
+        }
+
+        return file_list.front();
+    }
+    XmlParser manifestParser;
+    if (!manifestParser.parse(manifestfile.get())) {
+        return std::string();
+    }
+
+    XmlNode root = manifestParser.getRootNode();
+    const std::string &name = root.name();
+    if (name != "dae_root") {
+        root = *manifestParser.findNode("dae_root");
+        if (nullptr == root) {
+            return std::string();
+        }
+        std::string v;
+        XmlParser::getValueAsString(root, v);
+        aiString ai_str(v);
+        UriDecodePath(ai_str);
+        return std::string(ai_str.C_Str());
+    }
+
+    return std::string();
+}
+
+// ------------------------------------------------------------------------------------------------
+// Convert a path read from a collada file to the usual representation
+void ColladaParser::UriDecodePath(aiString &ss) {
+    // TODO: collada spec, p 22. Handle URI correctly.
+    // For the moment we're just stripping the file:// away to make it work.
+    // Windows doesn't seem to be able to find stuff like
+    // 'file://..\LWO\LWO2\MappingModes\earthSpherical.jpg'
+    if (0 == strncmp(ss.data, "file://", 7)) {
+        ss.length -= 7;
+        memmove(ss.data, ss.data + 7, ss.length);
+        ss.data[ss.length] = '\0';
+    }
+
+    // Maxon Cinema Collada Export writes "file:///C:\andsoon" with three slashes...
+    // I need to filter it without destroying linux paths starting with "/somewhere"
+    if (ss.data[0] == '/' && isalpha((unsigned char)ss.data[1]) && ss.data[2] == ':') {
+        --ss.length;
+        ::memmove(ss.data, ss.data + 1, ss.length);
+        ss.data[ss.length] = 0;
+    }
+
+    // find and convert all %xy special chars
+    char *out = ss.data;
+    for (const char *it = ss.data; it != ss.data + ss.length; /**/) {
+        if (*it == '%' && (it + 3) < ss.data + ss.length) {
+            // separate the number to avoid dragging in chars from behind into the parsing
+            char mychar[3] = { it[1], it[2], 0 };
+            size_t nbr = strtoul16(mychar);
+            it += 3;
+            *out++ = (char)(nbr & 0xFF);
+        } else {
+            *out++ = *it++;
+        }
+    }
+
+    // adjust length and terminator of the shortened string
+    *out = 0;
+    ai_assert(out > ss.data);
+    ss.length = static_cast<ai_uint32>(out - ss.data);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the contents of the file
+void ColladaParser::ReadContents(XmlNode &node) {
+    const std::string name = node.name();
+    if (name == "COLLADA") {
+        std::string version;
+        if (XmlParser::getStdStrAttribute(node, "version", version)) {
+            aiString v;
+            v.Set(version.c_str());
+            mAssetMetaData.emplace(AI_METADATA_SOURCE_FORMAT_VERSION, v);
+            if (!::strncmp(version.c_str(), "1.5", 3)) {
+                mFormat = FV_1_5_n;
+                ASSIMP_LOG_DEBUG("Collada schema version is 1.5.n");
+            } else if (!::strncmp(version.c_str(), "1.4", 3)) {
+                mFormat = FV_1_4_n;
+                ASSIMP_LOG_DEBUG("Collada schema version is 1.4.n");
+            } else if (!::strncmp(version.c_str(), "1.3", 3)) {
+                mFormat = FV_1_3_n;
+                ASSIMP_LOG_DEBUG("Collada schema version is 1.3.n");
+            }
+        }
+        ReadStructure(node);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the structure of the file
+void ColladaParser::ReadStructure(XmlNode &node) {
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "asset") {
+            ReadAssetInfo(currentNode);
+        } else if (currentName == "library_animations") {
+            ReadAnimationLibrary(currentNode);
+        } else if (currentName == "library_animation_clips") {
+            ReadAnimationClipLibrary(currentNode);
+        } else if (currentName == "library_controllers") {
+            ReadControllerLibrary(currentNode);
+        } else if (currentName == "library_images") {
+            ReadImageLibrary(currentNode);
+        } else if (currentName == "library_materials") {
+            ReadMaterialLibrary(currentNode);
+        } else if (currentName == "library_effects") {
+            ReadEffectLibrary(currentNode);
+        } else if (currentName == "library_geometries") {
+            ReadGeometryLibrary(currentNode);
+        } else if (currentName == "library_visual_scenes") {
+            ReadSceneLibrary(currentNode);
+        } else if (currentName == "library_lights") {
+            ReadLightLibrary(currentNode);
+        } else if (currentName == "library_cameras") {
+            ReadCameraLibrary(currentNode);
+        } else if (currentName == "library_nodes") {
+            ReadSceneNode(currentNode, nullptr); /* some hacking to reuse this piece of code */
+        } else if (currentName == "scene") {
+            ReadScene(currentNode);
+        }
+    }
+
+    PostProcessRootAnimations();
+    PostProcessControllers();
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads asset information such as coordinate system information and legal blah
+void ColladaParser::ReadAssetInfo(XmlNode &node) {
+    if (node.empty()) {
+        return;
+    }
+
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "unit") {
+            mUnitSize = 1.f;
+            std::string tUnitSizeString;
+            if (XmlParser::getStdStrAttribute(currentNode, "meter", tUnitSizeString)) {
+                try {
+                    fast_atoreal_move<ai_real>(tUnitSizeString.data(), mUnitSize);
+                } catch (const DeadlyImportError& die) {
+                    std::string warning("Collada: Failed to parse meter parameter to real number. Exception:\n");
+                    warning.append(die.what());
+                    ASSIMP_LOG_WARN(warning.data());
+                }
+            }
+        } else if (currentName == "up_axis") {
+            std::string v;
+            if (!XmlParser::getValueAsString(currentNode, v)) {
+                continue;
+            }
+            if (v == "X_UP") {
+                mUpDirection = UP_X;
+            } else if (v == "Z_UP") {
+                mUpDirection = UP_Z;
+            } else {
+                mUpDirection = UP_Y;
+            }
+        } else if (currentName == "contributor") {
+            for (XmlNode currentChildNode : currentNode.children()) {
+                ReadMetaDataItem(currentChildNode, mAssetMetaData);
+            }
+        } else {
+            ReadMetaDataItem(currentNode, mAssetMetaData);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a single string metadata item
+void ColladaParser::ReadMetaDataItem(XmlNode &node, StringMetaData &metadata) {
+    const Collada::MetaKeyPairVector &key_renaming = GetColladaAssimpMetaKeysCamelCase();
+    const std::string name = node.name();
+    if (name.empty()) {
+        return;
+    }
+
+    std::string v;
+    if (!XmlParser::getValueAsString(node, v)) {
+        return;
+    }
+
+    v = ai_trim(v);
+    aiString aistr;
+    aistr.Set(v);
+
+    std::string camel_key_str(name);
+    ToCamelCase(camel_key_str);
+
+    size_t found_index;
+    if (FindCommonKey(camel_key_str, key_renaming, found_index)) {
+        metadata.emplace(key_renaming[found_index].second, aistr);
+    } else {
+        metadata.emplace(camel_key_str, aistr);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the animation clips
+void ColladaParser::ReadAnimationClipLibrary(XmlNode &node) {
+    if (node.empty()) {
+        return;
+    }
+
+    std::string animName;
+    if (!XmlParser::getStdStrAttribute(node, "name", animName)) {
+        if (!XmlParser::getStdStrAttribute(node, "id", animName)) {
+            animName = std::string("animation_") + ai_to_string(mAnimationClipLibrary.size());
+        }
+    }
+
+    std::pair<std::string, std::vector<std::string>> clip;
+    clip.first = animName;
+
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "instance_animation") {
+            std::string url;
+            readUrlAttribute(currentNode, url);
+            clip.second.push_back(url);
+        }
+
+        if (clip.second.size() > 0) {
+            mAnimationClipLibrary.push_back(clip);
+        }
+    }
+}
+
+void ColladaParser::PostProcessControllers() {
+    std::string meshId;
+    for (auto &it : mControllerLibrary) {
+        meshId = it.second.mMeshId;
+        if (meshId.empty()) {
+            continue;
+        }
+
+        ControllerLibrary::iterator findItr = mControllerLibrary.find(meshId);
+        while (findItr != mControllerLibrary.end()) {
+            meshId = findItr->second.mMeshId;
+            findItr = mControllerLibrary.find(meshId);
+        }
+
+        it.second.mMeshId = meshId;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Re-build animations from animation clip library, if present, otherwise combine single-channel animations
+void ColladaParser::PostProcessRootAnimations() {
+    if (mAnimationClipLibrary.empty()) {
+        mAnims.CombineSingleChannelAnimations();
+        return;
+    }
+
+    Animation temp;
+    for (auto &it : mAnimationClipLibrary) {
+        std::string clipName = it.first;
+
+        Animation *clip = new Animation();
+        clip->mName = clipName;
+
+        temp.mSubAnims.push_back(clip);
+
+        for (const std::string &animationID : it.second) {
+            AnimationLibrary::iterator animation = mAnimationLibrary.find(animationID);
+
+            if (animation != mAnimationLibrary.end()) {
+                Animation *pSourceAnimation = animation->second;
+                pSourceAnimation->CollectChannelsRecursively(clip->mChannels);
+            }
+        }
+    }
+
+    mAnims = temp;
+
+    // Ensure no double deletes.
+    temp.mSubAnims.clear();
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the animation library
+void ColladaParser::ReadAnimationLibrary(XmlNode &node) {
+    if (node.empty()) {
+        return;
+    }
+
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "animation") {
+            ReadAnimation(currentNode, &mAnims);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an animation into the given parent structure
+void ColladaParser::ReadAnimation(XmlNode &node, Collada::Animation *pParent) {
+    if (node.empty()) {
+        return;
+    }
+
+    // an <animation> element may be a container for grouping sub-elements or an animation channel
+    // this is the channel collection by ID, in case it has channels
+    using ChannelMap = std::map<std::string, AnimationChannel>;
+    ChannelMap channels;
+    // this is the anim container in case we're a container
+    Animation *anim = nullptr;
+
+    // optional name given as an attribute
+    std::string animName;
+    if (!XmlParser::getStdStrAttribute(node, "name", animName)) {
+        animName = "animation";
+    }
+
+    std::string animID;
+    pugi::xml_attribute idAttr = node.attribute("id");
+    if (idAttr) {
+        animID = idAttr.as_string();
+    }
+
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "animation") {
+            if (!anim) {
+                anim = new Animation;
+                anim->mName = animName;
+                pParent->mSubAnims.push_back(anim);
+            }
+
+            // recurse into the sub-element
+            ReadAnimation(currentNode, anim);
+        } else if (currentName == "source") {
+            ReadSource(currentNode);
+        } else if (currentName == "sampler") {
+            std::string id;
+            if (XmlParser::getStdStrAttribute(currentNode, "id", id)) {
+                // have it read into a channel
+                ChannelMap::iterator newChannel = channels.insert(std::make_pair(id, AnimationChannel())).first;
+                ReadAnimationSampler(currentNode, newChannel->second);
+            }
+        } else if (currentName == "channel") {
+            std::string source_name, target;
+            XmlParser::getStdStrAttribute(currentNode, "source", source_name);
+            XmlParser::getStdStrAttribute(currentNode, "target", target);
+            if (source_name[0] == '#') {
+                source_name = source_name.substr(1, source_name.size() - 1);
+            }
+            ChannelMap::iterator cit = channels.find(source_name);
+            if (cit != channels.end()) {
+                cit->second.mTarget = target;
+            }
+        }
+    }
+
+    // it turned out to have channels - add them
+    if (!channels.empty()) {
+        if (nullptr == anim) {
+            anim = new Animation;
+            anim->mName = animName;
+            pParent->mSubAnims.push_back(anim);
+        }
+
+        for (const auto &channel : channels) {
+            anim->mChannels.push_back(channel.second);
+        }
+
+        if (idAttr) {
+            mAnimationLibrary[animID] = anim;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an animation sampler into the given anim channel
+void ColladaParser::ReadAnimationSampler(XmlNode &node, Collada::AnimationChannel &pChannel) {
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "input") {
+            if (XmlParser::hasAttribute(currentNode, "semantic")) {
+                std::string semantic, sourceAttr;
+                XmlParser::getStdStrAttribute(currentNode, "semantic", semantic);
+                if (XmlParser::hasAttribute(currentNode, "source")) {
+                    XmlParser::getStdStrAttribute(currentNode, "source", sourceAttr);
+                    const char *source = sourceAttr.c_str();
+                    if (source[0] != '#') {
+                        throw DeadlyImportError("Unsupported URL format");
+                    }
+                    source++;
+
+                    if (semantic == "INPUT") {
+                        pChannel.mSourceTimes = source;
+                    } else if (semantic == "OUTPUT") {
+                        pChannel.mSourceValues = source;
+                    } else if (semantic == "IN_TANGENT") {
+                        pChannel.mInTanValues = source;
+                    } else if (semantic == "OUT_TANGENT") {
+                        pChannel.mOutTanValues = source;
+                    } else if (semantic == "INTERPOLATION") {
+                        pChannel.mInterpolationValues = source;
+                    }
+                }
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the skeleton controller library
+void ColladaParser::ReadControllerLibrary(XmlNode &node) {
+    if (node.empty()) {
+        return;
+    }
+
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName != "controller") {
+            continue;
+        }
+        std::string id;
+        if (XmlParser::getStdStrAttribute(currentNode, "id", id)) {
+            mControllerLibrary[id] = Controller();
+            ReadController(currentNode, mControllerLibrary[id]);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a controller into the given mesh structure
+void ColladaParser::ReadController(XmlNode &node, Collada::Controller &controller) {
+    // initial values
+    controller.mType = Skin;
+    controller.mMethod = Normalized;
+
+    XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode);
+    XmlNode currentNode;
+    while (xmlIt.getNext(currentNode)) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "morph") {
+            controller.mType = Morph;
+            controller.mMeshId = currentNode.attribute("source").as_string();
+            int methodIndex = currentNode.attribute("method").as_int();
+            if (methodIndex > 0) {
+                std::string method;
+                XmlParser::getValueAsString(currentNode, method);
+
+                if (method == "RELATIVE") {
+                    controller.mMethod = Relative;
+                }
+            }
+        } else if (currentName == "skin") {
+            std::string id;
+            if (XmlParser::getStdStrAttribute(currentNode, "source", id)) {
+                controller.mMeshId = id.substr(1, id.size() - 1);
+            }
+        } else if (currentName == "bind_shape_matrix") {
+            std::string v;
+            XmlParser::getValueAsString(currentNode, v);
+            const char *content = v.c_str();
+            for (unsigned int a = 0; a < 16; a++) {
+                SkipSpacesAndLineEnd(&content);
+                // read a number
+                content = fast_atoreal_move<ai_real>(content, controller.mBindShapeMatrix[a]);
+                // skip whitespace after it
+                SkipSpacesAndLineEnd(&content);
+            }
+        } else if (currentName == "source") {
+            ReadSource(currentNode);
+        } else if (currentName == "joints") {
+            ReadControllerJoints(currentNode, controller);
+        } else if (currentName == "vertex_weights") {
+            ReadControllerWeights(currentNode, controller);
+        } else if (currentName == "targets") {
+            for (XmlNode currentChildNode = node.first_child(); currentNode; currentNode = currentNode.next_sibling()) {
+                const std::string &currentChildName = currentChildNode.name();
+                if (currentChildName == "input") {
+                    const char *semantics = currentChildNode.attribute("semantic").as_string();
+                    const char *source = currentChildNode.attribute("source").as_string();
+                    if (strcmp(semantics, "MORPH_TARGET") == 0) {
+                        controller.mMorphTarget = source + 1;
+                    } else if (strcmp(semantics, "MORPH_WEIGHT") == 0) {
+                        controller.mMorphWeight = source + 1;
+                    }
+                }
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the joint definitions for the given controller
+void ColladaParser::ReadControllerJoints(XmlNode &node, Collada::Controller &pController) {
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "input") {
+            const char *attrSemantic = currentNode.attribute("semantic").as_string();
+            const char *attrSource = currentNode.attribute("source").as_string();
+            if (attrSource[0] != '#') {
+                throw DeadlyImportError("Unsupported URL format in \"", attrSource, "\" in source attribute of <joints> data <input> element");
+            }
+            ++attrSource;
+            // parse source URL to corresponding source
+            if (strcmp(attrSemantic, "JOINT") == 0) {
+                pController.mJointNameSource = attrSource;
+            } else if (strcmp(attrSemantic, "INV_BIND_MATRIX") == 0) {
+                pController.mJointOffsetMatrixSource = attrSource;
+            } else {
+                throw DeadlyImportError("Unknown semantic \"", attrSemantic, "\" in <joints> data <input> element");
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the joint weights for the given controller
+void ColladaParser::ReadControllerWeights(XmlNode &node, Collada::Controller &pController) {
+    // Read vertex count from attributes and resize the array accordingly
+    int vertexCount = 0;
+    XmlParser::getIntAttribute(node, "count", vertexCount);
+    pController.mWeightCounts.resize(vertexCount);
+
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "input") {
+            InputChannel channel;
+
+            const char *attrSemantic = currentNode.attribute("semantic").as_string();
+            const char *attrSource = currentNode.attribute("source").as_string();
+            channel.mOffset = currentNode.attribute("offset").as_int();
+
+            // local URLS always start with a '#'. We don't support global URLs
+            if (attrSource[0] != '#') {
+                throw DeadlyImportError("Unsupported URL format in \"", attrSource, "\" in source attribute of <vertex_weights> data <input> element");
+            }
+            channel.mAccessor = attrSource + 1;
+
+            // parse source URL to corresponding source
+            if (strcmp(attrSemantic, "JOINT") == 0) {
+                pController.mWeightInputJoints = channel;
+            } else if (strcmp(attrSemantic, "WEIGHT") == 0) {
+                pController.mWeightInputWeights = channel;
+            } else {
+                throw DeadlyImportError("Unknown semantic \"", attrSemantic, "\" in <vertex_weights> data <input> element");
+            }
+        } else if (currentName == "vcount" && vertexCount > 0) {
+            const char *text = currentNode.text().as_string();
+            size_t numWeights = 0;
+            for (std::vector<size_t>::iterator it = pController.mWeightCounts.begin(); it != pController.mWeightCounts.end(); ++it) {
+                if (*text == 0) {
+                    throw DeadlyImportError("Out of data while reading <vcount>");
+                }
+
+                *it = strtoul10(text, &text);
+                numWeights += *it;
+                SkipSpacesAndLineEnd(&text);
+            }
+            // reserve weight count
+            pController.mWeights.resize(numWeights);
+        } else if (currentName == "v" && vertexCount > 0) {
+            // read JointIndex - WeightIndex pairs
+            std::string stdText;
+            XmlParser::getValueAsString(currentNode, stdText);
+            const char *text = stdText.c_str();
+            for (std::vector<std::pair<size_t, size_t>>::iterator it = pController.mWeights.begin(); it != pController.mWeights.end(); ++it) {
+                if (text == 0) {
+                    throw DeadlyImportError("Out of data while reading <vertex_weights>");
+                }
+                it->first = strtoul10(text, &text);
+                SkipSpacesAndLineEnd(&text);
+                if (*text == 0) {
+                    throw DeadlyImportError("Out of data while reading <vertex_weights>");
+                }
+                it->second = strtoul10(text, &text);
+                SkipSpacesAndLineEnd(&text);
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the image library contents
+void ColladaParser::ReadImageLibrary(XmlNode &node) {
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "image") {
+            std::string id;
+            if (XmlParser::getStdStrAttribute(currentNode, "id", id)) {
+                mImageLibrary[id] = Image();
+                // read on from there
+                ReadImage(currentNode, mImageLibrary[id]);
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an image entry into the given image
+void ColladaParser::ReadImage(XmlNode &node, Collada::Image &pImage) {
+    for (XmlNode &currentNode : node.children()) {
+        const std::string currentName = currentNode.name();
+        if (currentName == "image") {
+            // Ignore
+            continue;
+        } else if (currentName == "init_from") {
+            if (mFormat == FV_1_4_n) {
+                // FIX: C4D exporter writes empty <init_from/> tags
+                if (!currentNode.empty()) {
+                    // element content is filename - hopefully
+                    const char *sz = currentNode.text().as_string();
+                    if (nullptr != sz) {
+                        aiString filepath(sz);
+                        UriDecodePath(filepath);
+                        pImage.mFileName = filepath.C_Str();
+                    }
+                }
+                if (!pImage.mFileName.length()) {
+                    pImage.mFileName = "unknown_texture";
+                }
+            }
+        } else if (mFormat == FV_1_5_n) {
+            std::string value;
+            XmlNode refChild = currentNode.child("ref");
+            XmlNode hexChild = currentNode.child("hex");
+            if (refChild) {
+                // element content is filename - hopefully
+                if (XmlParser::getValueAsString(refChild, value)) {
+                    aiString filepath(value);
+                    UriDecodePath(filepath);
+                    pImage.mFileName = filepath.C_Str();
+                }
+            } else if (hexChild && !pImage.mFileName.length()) {
+                // embedded image. get format
+                pImage.mEmbeddedFormat = hexChild.attribute("format").as_string();
+                if (pImage.mEmbeddedFormat.empty()) {
+                    ASSIMP_LOG_WARN("Collada: Unknown image file format");
+                }
+
+                XmlParser::getValueAsString(hexChild, value);
+                const char *data = value.c_str();
+                // hexadecimal-encoded binary octets. First of all, find the
+                // required buffer size to reserve enough storage.
+                const char *cur = data;
+                while (!IsSpaceOrNewLine(*cur)) {
+                    ++cur;
+                }
+
+                const unsigned int size = (unsigned int)(cur - data) * 2;
+                pImage.mImageData.resize(size);
+                for (unsigned int i = 0; i < size; ++i) {
+                    pImage.mImageData[i] = HexOctetToDecimal(data + (i << 1));
+                }
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the material library
+void ColladaParser::ReadMaterialLibrary(XmlNode &node) {
+    std::map<std::string, int> names;
+    for (XmlNode &currentNode : node.children()) {
+        std::string id = currentNode.attribute("id").as_string();
+        std::string name = currentNode.attribute("name").as_string();
+        mMaterialLibrary[id] = Material();
+
+        if (!name.empty()) {
+            std::map<std::string, int>::iterator it = names.find(name);
+            if (it != names.end()) {
+                std::ostringstream strStream;
+                strStream << ++it->second;
+                name.append(" " + strStream.str());
+            } else {
+                names[name] = 0;
+            }
+
+            mMaterialLibrary[id].mName = name;
+        }
+
+        ReadMaterial(currentNode, mMaterialLibrary[id]);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the light library
+void ColladaParser::ReadLightLibrary(XmlNode &node) {
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "light") {
+            std::string id;
+            if (XmlParser::getStdStrAttribute(currentNode, "id", id)) {
+                ReadLight(currentNode, mLightLibrary[id] = Light());
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the camera library
+void ColladaParser::ReadCameraLibrary(XmlNode &node) {
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "camera") {
+            std::string id;
+            if (!XmlParser::getStdStrAttribute(currentNode, "id", id)) {
+                continue;
+            }
+
+            // create an entry and store it in the library under its ID
+            Camera &cam = mCameraLibrary[id];
+            std::string name;
+            if (!XmlParser::getStdStrAttribute(currentNode, "name", name)) {
+                continue;
+            }
+            if (!name.empty()) {
+                cam.mName = name;
+            }
+            ReadCamera(currentNode, cam);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a material entry into the given material
+void ColladaParser::ReadMaterial(XmlNode &node, Collada::Material &pMaterial) {
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "instance_effect") {
+            std::string url;
+            readUrlAttribute(currentNode, url);
+            pMaterial.mEffect = url;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a light entry into the given light
+void ColladaParser::ReadLight(XmlNode &node, Collada::Light &pLight) {
+    XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode);
+    XmlNode currentNode;
+    // TODO: Check the current technique and skip over unsupported extra techniques
+
+    while (xmlIt.getNext(currentNode)) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "spot") {
+            pLight.mType = aiLightSource_SPOT;
+        } else if (currentName == "ambient") {
+            pLight.mType = aiLightSource_AMBIENT;
+        } else if (currentName == "directional") {
+            pLight.mType = aiLightSource_DIRECTIONAL;
+        } else if (currentName == "point") {
+            pLight.mType = aiLightSource_POINT;
+        } else if (currentName == "color") {
+            // text content contains 3 floats
+            std::string v;
+            XmlParser::getValueAsString(currentNode, v);
+            const char *content = v.c_str();
+
+            content = fast_atoreal_move<ai_real>(content, (ai_real &)pLight.mColor.r);
+            SkipSpacesAndLineEnd(&content);
+
+            content = fast_atoreal_move<ai_real>(content, (ai_real &)pLight.mColor.g);
+            SkipSpacesAndLineEnd(&content);
+
+            content = fast_atoreal_move<ai_real>(content, (ai_real &)pLight.mColor.b);
+            SkipSpacesAndLineEnd(&content);
+        } else if (currentName == "constant_attenuation") {
+            XmlParser::getValueAsFloat(currentNode, pLight.mAttConstant);
+        } else if (currentName == "linear_attenuation") {
+            XmlParser::getValueAsFloat(currentNode, pLight.mAttLinear);
+        } else if (currentName == "quadratic_attenuation") {
+            XmlParser::getValueAsFloat(currentNode, pLight.mAttQuadratic);
+        } else if (currentName == "falloff_angle") {
+            XmlParser::getValueAsFloat(currentNode, pLight.mFalloffAngle);
+        } else if (currentName == "falloff_exponent") {
+            XmlParser::getValueAsFloat(currentNode, pLight.mFalloffExponent);
+        }
+        // FCOLLADA extensions
+        // -------------------------------------------------------
+        else if (currentName == "outer_cone") {
+            XmlParser::getValueAsFloat(currentNode, pLight.mOuterAngle);
+        } else if (currentName == "penumbra_angle") { // this one is deprecated, now calculated using outer_cone
+            XmlParser::getValueAsFloat(currentNode, pLight.mPenumbraAngle);
+        } else if (currentName == "intensity") {
+            XmlParser::getValueAsFloat(currentNode, pLight.mIntensity);
+        }
+        else if (currentName == "falloff") {
+            XmlParser::getValueAsFloat(currentNode, pLight.mOuterAngle);
+        } else if (currentName == "hotspot_beam") {
+            XmlParser::getValueAsFloat(currentNode, pLight.mFalloffAngle);
+        }
+        // OpenCOLLADA extensions
+        // -------------------------------------------------------
+        else if (currentName == "decay_falloff") {
+            XmlParser::getValueAsFloat(currentNode, pLight.mOuterAngle);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a camera entry into the given light
+void ColladaParser::ReadCamera(XmlNode &node, Collada::Camera &camera) {
+    XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode);
+    XmlNode currentNode;
+    while (xmlIt.getNext(currentNode)) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "orthographic") {
+            camera.mOrtho = true;
+        } else if (currentName == "xfov" || currentName == "xmag") {
+            XmlParser::getValueAsFloat(currentNode, camera.mHorFov);
+        } else if (currentName == "yfov" || currentName == "ymag") {
+            XmlParser::getValueAsFloat(currentNode, camera.mVerFov);
+        } else if (currentName == "aspect_ratio") {
+            XmlParser::getValueAsFloat(currentNode, camera.mAspect);
+        } else if (currentName == "znear") {
+            XmlParser::getValueAsFloat(currentNode, camera.mZNear);
+        } else if (currentName == "zfar") {
+            XmlParser::getValueAsFloat(currentNode, camera.mZFar);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the effect library
+void ColladaParser::ReadEffectLibrary(XmlNode &node) {
+    if (node.empty()) {
+        return;
+    }
+
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "effect") {
+            // read ID. Do I have to repeat my ranting about "optional" attributes?
+            std::string id;
+            XmlParser::getStdStrAttribute(currentNode, "id", id);
+
+            // create an entry and store it in the library under its ID
+            mEffectLibrary[id] = Effect();
+
+            // read on from there
+            ReadEffect(currentNode, mEffectLibrary[id]);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an effect entry into the given effect
+void ColladaParser::ReadEffect(XmlNode &node, Collada::Effect &pEffect) {
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "profile_COMMON") {
+            ReadEffectProfileCommon(currentNode, pEffect);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an COMMON effect profile
+void ColladaParser::ReadEffectProfileCommon(XmlNode &node, Collada::Effect &pEffect) {
+    XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode);
+    XmlNode currentNode;
+    while (xmlIt.getNext(currentNode)) {
+        const std::string currentName = currentNode.name();
+        if (currentName == "newparam") {
+            // save ID
+            std::string sid = currentNode.attribute("sid").as_string();
+            pEffect.mParams[sid] = EffectParam();
+            ReadEffectParam(currentNode, pEffect.mParams[sid]);
+        } else if (currentName == "technique" || currentName == "extra") {
+            // just syntactic sugar
+        } else if (mFormat == FV_1_4_n && currentName == "image") {
+            // read ID. Another entry which is "optional" by design but obligatory in reality
+            std::string id = currentNode.attribute("id").as_string();
+
+            // create an entry and store it in the library under its ID
+            mImageLibrary[id] = Image();
+
+            // read on from there
+            ReadImage(currentNode, mImageLibrary[id]);
+        } else if (currentName == "phong")
+            pEffect.mShadeType = Shade_Phong;
+        else if (currentName == "constant")
+            pEffect.mShadeType = Shade_Constant;
+        else if (currentName == "lambert")
+            pEffect.mShadeType = Shade_Lambert;
+        else if (currentName == "blinn")
+            pEffect.mShadeType = Shade_Blinn;
+
+        /* Color + texture properties */
+        else if (currentName == "emission")
+            ReadEffectColor(currentNode, pEffect.mEmissive, pEffect.mTexEmissive);
+        else if (currentName == "ambient")
+            ReadEffectColor(currentNode, pEffect.mAmbient, pEffect.mTexAmbient);
+        else if (currentName == "diffuse")
+            ReadEffectColor(currentNode, pEffect.mDiffuse, pEffect.mTexDiffuse);
+        else if (currentName == "specular")
+            ReadEffectColor(currentNode, pEffect.mSpecular, pEffect.mTexSpecular);
+        else if (currentName == "reflective") {
+            ReadEffectColor(currentNode, pEffect.mReflective, pEffect.mTexReflective);
+        } else if (currentName == "transparent") {
+            pEffect.mHasTransparency = true;
+            const char *opaque = currentNode.attribute("opaque").as_string();
+            //const char *opaque = mReader->getAttributeValueSafe("opaque");
+
+            if (::strcmp(opaque, "RGB_ZERO") == 0 || ::strcmp(opaque, "RGB_ONE") == 0) {
+                pEffect.mRGBTransparency = true;
+            }
+
+            // In RGB_ZERO mode, the transparency is interpreted in reverse, go figure...
+            if (::strcmp(opaque, "RGB_ZERO") == 0 || ::strcmp(opaque, "A_ZERO") == 0) {
+                pEffect.mInvertTransparency = true;
+            }
+
+            ReadEffectColor(currentNode, pEffect.mTransparent, pEffect.mTexTransparent);
+        } else if (currentName == "shininess")
+            ReadEffectFloat(currentNode, pEffect.mShininess);
+        else if (currentName == "reflectivity")
+            ReadEffectFloat(currentNode, pEffect.mReflectivity);
+
+        /* Single scalar properties */
+        else if (currentName == "transparency")
+            ReadEffectFloat(currentNode, pEffect.mTransparency);
+        else if (currentName == "index_of_refraction")
+            ReadEffectFloat(currentNode, pEffect.mRefractIndex);
+
+        // GOOGLEEARTH/OKINO extensions
+        // -------------------------------------------------------
+        else if (currentName == "double_sided")
+            XmlParser::getValueAsBool(currentNode, pEffect.mDoubleSided);
+
+        // FCOLLADA extensions
+        // -------------------------------------------------------
+        else if (currentName == "bump") {
+            aiColor4D dummy;
+            ReadEffectColor(currentNode, dummy, pEffect.mTexBump);
+        }
+
+        // MAX3D extensions
+        // -------------------------------------------------------
+        else if (currentName == "wireframe") {
+            XmlParser::getValueAsBool(currentNode, pEffect.mWireframe);
+        } else if (currentName == "faceted") {
+            XmlParser::getValueAsBool(currentNode, pEffect.mFaceted);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Read texture wrapping + UV transform settings from a profile==Maya chunk
+void ColladaParser::ReadSamplerProperties(XmlNode &node, Sampler &out) {
+    if (node.empty()) {
+        return;
+    }
+
+    XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode);
+    XmlNode currentNode;
+    while (xmlIt.getNext(currentNode)) {
+        const std::string &currentName = currentNode.name();
+        // MAYA extensions
+        // -------------------------------------------------------
+        if (currentName == "wrapU") {
+            XmlParser::getValueAsBool(currentNode, out.mWrapU);
+        } else if (currentName == "wrapV") {
+            XmlParser::getValueAsBool(currentNode, out.mWrapV);
+        } else if (currentName == "mirrorU") {
+            XmlParser::getValueAsBool(currentNode, out.mMirrorU);
+        } else if (currentName == "mirrorV") {
+            XmlParser::getValueAsBool(currentNode, out.mMirrorV);
+        } else if (currentName == "repeatU") {
+            XmlParser::getValueAsFloat(currentNode, out.mTransform.mScaling.x);
+        } else if (currentName == "repeatV") {
+            XmlParser::getValueAsFloat(currentNode, out.mTransform.mScaling.y);
+        } else if (currentName == "offsetU") {
+            XmlParser::getValueAsFloat(currentNode, out.mTransform.mTranslation.x);
+        } else if (currentName == "offsetV") {
+            XmlParser::getValueAsFloat(currentNode, out.mTransform.mTranslation.y);
+        } else if (currentName == "rotateUV") {
+            XmlParser::getValueAsFloat(currentNode, out.mTransform.mRotation);
+        } else if (currentName == "blend_mode") {
+            std::string v;
+            XmlParser::getValueAsString(currentNode, v);
+            const char *sz = v.c_str();
+            // http://www.feelingsoftware.com/content/view/55/72/lang,en/
+            // NONE, OVER, IN, OUT, ADD, SUBTRACT, MULTIPLY, DIFFERENCE, LIGHTEN, DARKEN, SATURATE, DESATURATE and ILLUMINATE
+            if (0 == ASSIMP_strincmp(sz, "ADD", 3))
+                out.mOp = aiTextureOp_Add;
+            else if (0 == ASSIMP_strincmp(sz, "SUBTRACT", 8))
+                out.mOp = aiTextureOp_Subtract;
+            else if (0 == ASSIMP_strincmp(sz, "MULTIPLY", 8))
+                out.mOp = aiTextureOp_Multiply;
+            else {
+                ASSIMP_LOG_WARN("Collada: Unsupported MAYA texture blend mode");
+            }
+        }
+        // OKINO extensions
+        // -------------------------------------------------------
+        else if (currentName == "weighting") {
+            XmlParser::getValueAsFloat(currentNode, out.mWeighting);
+        } else if (currentName == "mix_with_previous_layer") {
+            XmlParser::getValueAsFloat(currentNode, out.mMixWithPrevious);
+        }
+        // MAX3D extensions
+        // -------------------------------------------------------
+        else if (currentName == "amount") {
+            XmlParser::getValueAsFloat(currentNode, out.mWeighting);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an effect entry containing a color or a texture defining that color
+void ColladaParser::ReadEffectColor(XmlNode &node, aiColor4D &pColor, Sampler &pSampler) {
+    if (node.empty()) {
+        return;
+    }
+
+    XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode);
+    XmlNode currentNode;
+    while (xmlIt.getNext(currentNode)) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "color") {
+            // text content contains 4 floats
+            std::string v;
+            XmlParser::getValueAsString(currentNode, v);
+            const char *content = v.c_str();
+
+            content = fast_atoreal_move<ai_real>(content, (ai_real &)pColor.r);
+            SkipSpacesAndLineEnd(&content);
+
+            content = fast_atoreal_move<ai_real>(content, (ai_real &)pColor.g);
+            SkipSpacesAndLineEnd(&content);
+
+            content = fast_atoreal_move<ai_real>(content, (ai_real &)pColor.b);
+            SkipSpacesAndLineEnd(&content);
+
+            content = fast_atoreal_move<ai_real>(content, (ai_real &)pColor.a);
+            SkipSpacesAndLineEnd(&content);
+        } else if (currentName == "texture") {
+            // get name of source texture/sampler
+            XmlParser::getStdStrAttribute(currentNode, "texture", pSampler.mName);
+
+            // get name of UV source channel. Specification demands it to be there, but some exporters
+            // don't write it. It will be the default UV channel in case it's missing.
+            XmlParser::getStdStrAttribute(currentNode, "texcoord", pSampler.mUVChannel);
+
+            // as we've read texture, the color needs to be 1,1,1,1
+            pColor = aiColor4D(1.f, 1.f, 1.f, 1.f);
+        } else if (currentName == "technique") {
+            std::string profile;
+            XmlParser::getStdStrAttribute(currentNode, "profile", profile);
+
+            // Some extensions are quite useful ... ReadSamplerProperties processes
+            // several extensions in MAYA, OKINO and MAX3D profiles.
+            if (!::strcmp(profile.c_str(), "MAYA") || !::strcmp(profile.c_str(), "MAX3D") || !::strcmp(profile.c_str(), "OKINO")) {
+                // get more information on this sampler
+                ReadSamplerProperties(currentNode, pSampler);
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an effect entry containing a float
+void ColladaParser::ReadEffectFloat(XmlNode &node, ai_real &pFloat) {
+    pFloat = 0.f;
+    XmlNode floatNode = node.child("float");
+    if (floatNode.empty()) {
+        return;
+    }
+    XmlParser::getValueAsFloat(floatNode, pFloat);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an effect parameter specification of any kind
+void ColladaParser::ReadEffectParam(XmlNode &node, Collada::EffectParam &pParam) {
+    if (node.empty()) {
+        return;
+    }
+
+    XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode);
+    XmlNode currentNode;
+    while (xmlIt.getNext(currentNode)) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "surface") {
+            // image ID given inside <init_from> tags
+            XmlNode initNode = currentNode.child("init_from");
+            if (initNode) {
+                std::string v;
+                XmlParser::getValueAsString(initNode, v);
+                pParam.mType = Param_Surface;
+                pParam.mReference = v.c_str();
+            }
+        } else if (currentName == "sampler2D" && (FV_1_4_n == mFormat || FV_1_3_n == mFormat)) {
+            // surface ID is given inside <source> tags
+            const char *content = currentNode.value();
+            pParam.mType = Param_Sampler;
+            pParam.mReference = content;
+        } else if (currentName == "sampler2D") {
+            // surface ID is given inside <instance_image> tags
+            std::string url;
+            XmlParser::getStdStrAttribute(currentNode, "url", url);
+            if (url[0] != '#') {
+                throw DeadlyImportError("Unsupported URL format in instance_image");
+            }
+            pParam.mType = Param_Sampler;
+            pParam.mReference = url.c_str() + 1;
+        } else if (currentName == "source") {
+            const char *source = currentNode.child_value();
+            if (nullptr != source) {
+                pParam.mReference = source;
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the geometry library contents
+void ColladaParser::ReadGeometryLibrary(XmlNode &node) {
+    if (node.empty()) {
+        return;
+    }
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "geometry") {
+            // read ID. Another entry which is "optional" by design but obligatory in reality
+
+            std::string id;
+            XmlParser::getStdStrAttribute(currentNode, "id", id);
+            // create a mesh and store it in the library under its (resolved) ID
+            // Skip and warn if ID is not unique
+            if (mMeshLibrary.find(id) == mMeshLibrary.cend()) {
+                std::unique_ptr<Mesh> mesh(new Mesh(id));
+
+                XmlParser::getStdStrAttribute(currentNode, "name", mesh->mName);
+
+                // read on from there
+                ReadGeometry(currentNode, *mesh);
+                // Read successfully, add to library
+                mMeshLibrary.insert({ id, mesh.release() });
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a geometry from the geometry library.
+void ColladaParser::ReadGeometry(XmlNode &node, Collada::Mesh &pMesh) {
+    if (node.empty()) {
+        return;
+    }
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "mesh") {
+            ReadMesh(currentNode, pMesh);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a mesh from the geometry library
+void ColladaParser::ReadMesh(XmlNode &node, Mesh &pMesh) {
+    if (node.empty()) {
+        return;
+    }
+
+    XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode);
+    XmlNode currentNode;
+    while (xmlIt.getNext(currentNode)) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "source") {
+            ReadSource(currentNode);
+        } else if (currentName == "vertices") {
+            ReadVertexData(currentNode, pMesh);
+        } else if (currentName == "triangles" || currentName == "lines" || currentName == "linestrips" ||
+                   currentName == "polygons" || currentName == "polylist" || currentName == "trifans" ||
+                   currentName == "tristrips") {
+            ReadIndexData(currentNode, pMesh);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a source element
+void ColladaParser::ReadSource(XmlNode &node) {
+    if (node.empty()) {
+        return;
+    }
+
+    std::string sourceID;
+    XmlParser::getStdStrAttribute(node, "id", sourceID);
+    XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode);
+    XmlNode currentNode;
+    while (xmlIt.getNext(currentNode)) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "float_array" || currentName == "IDREF_array" || currentName == "Name_array") {
+            ReadDataArray(currentNode);
+        } else if (currentName == "technique_common") {
+            XmlNode technique = currentNode.child("accessor");
+            if (!technique.empty()) {
+                ReadAccessor(technique, sourceID);
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a data array holding a number of floats, and stores it in the global library
+void ColladaParser::ReadDataArray(XmlNode &node) {
+    std::string name = node.name();
+    bool isStringArray = (name == "IDREF_array" || name == "Name_array");
+
+    // read attributes
+    std::string id;
+    XmlParser::getStdStrAttribute(node, "id", id);
+    unsigned int count = 0;
+    XmlParser::getUIntAttribute(node, "count", count);
+    std::string v;
+    XmlParser::getValueAsString(node, v);
+    v = ai_trim(v);
+    const char *content = v.c_str();
+
+    // read values and store inside an array in the data library
+    mDataLibrary[id] = Data();
+    Data &data = mDataLibrary[id];
+    data.mIsStringArray = isStringArray;
+
+    // some exporters write empty data arrays, but we need to conserve them anyways because others might reference them
+    if (content) {
+        if (isStringArray) {
+            data.mStrings.reserve(count);
+            std::string s;
+
+            for (unsigned int a = 0; a < count; a++) {
+                if (*content == 0) {
+                    throw DeadlyImportError("Expected more values while reading IDREF_array contents.");
+                }
+
+                s.clear();
+                while (!IsSpaceOrNewLine(*content))
+                    s += *content++;
+                data.mStrings.push_back(s);
+
+                SkipSpacesAndLineEnd(&content);
+            }
+        } else {
+            data.mValues.reserve(count);
+
+            for (unsigned int a = 0; a < count; a++) {
+                if (*content == 0) {
+                    throw DeadlyImportError("Expected more values while reading float_array contents.");
+                }
+
+                // read a number
+                ai_real value;
+                content = fast_atoreal_move<ai_real>(content, value);
+                data.mValues.push_back(value);
+                // skip whitespace after it
+                SkipSpacesAndLineEnd(&content);
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an accessor and stores it in the global library
+void ColladaParser::ReadAccessor(XmlNode &node, const std::string &pID) {
+    // read accessor attributes
+    std::string source;
+    XmlParser::getStdStrAttribute(node, "source", source);
+    if (source[0] != '#') {
+        throw DeadlyImportError("Unknown reference format in url \"", source, "\" in source attribute of <accessor> element.");
+    }
+    int count = 0;
+    XmlParser::getIntAttribute(node, "count", count);
+
+    unsigned int offset = 0;
+    if (XmlParser::hasAttribute(node, "offset")) {
+        XmlParser::getUIntAttribute(node, "offset", offset);
+    }
+    unsigned int stride = 1;
+    if (XmlParser::hasAttribute(node, "stride")) {
+        XmlParser::getUIntAttribute(node, "stride", stride);
+    }
+    // store in the library under the given ID
+    mAccessorLibrary[pID] = Accessor();
+    Accessor &acc = mAccessorLibrary[pID];
+    acc.mCount = count;
+    acc.mOffset = offset;
+    acc.mStride = stride;
+    acc.mSource = source.c_str() + 1; // ignore the leading '#'
+    acc.mSize = 0; // gets incremented with every param
+
+    XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode);
+    XmlNode currentNode;
+    while (xmlIt.getNext(currentNode)) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "param") {
+            // read data param
+            std::string name;
+            if (XmlParser::hasAttribute(currentNode, "name")) {
+                XmlParser::getStdStrAttribute(currentNode, "name", name);
+
+                // analyse for common type components and store it's sub-offset in the corresponding field
+
+                // Cartesian coordinates
+                if (name == "X")
+                    acc.mSubOffset[0] = acc.mParams.size();
+                else if (name == "Y")
+                    acc.mSubOffset[1] = acc.mParams.size();
+                else if (name == "Z")
+                    acc.mSubOffset[2] = acc.mParams.size();
+
+                /* RGBA colors */
+                else if (name == "R")
+                    acc.mSubOffset[0] = acc.mParams.size();
+                else if (name == "G")
+                    acc.mSubOffset[1] = acc.mParams.size();
+                else if (name == "B")
+                    acc.mSubOffset[2] = acc.mParams.size();
+                else if (name == "A")
+                    acc.mSubOffset[3] = acc.mParams.size();
+
+                /* UVWQ (STPQ) texture coordinates */
+                else if (name == "S")
+                    acc.mSubOffset[0] = acc.mParams.size();
+                else if (name == "T")
+                    acc.mSubOffset[1] = acc.mParams.size();
+                else if (name == "P")
+                    acc.mSubOffset[2] = acc.mParams.size();
+                /* Generic extra data, interpreted as UV data, too*/
+                else if (name == "U")
+                    acc.mSubOffset[0] = acc.mParams.size();
+                else if (name == "V")
+                    acc.mSubOffset[1] = acc.mParams.size();
+            }
+            if (XmlParser::hasAttribute(currentNode, "type")) {
+                // read data type
+                // TODO: (thom) I don't have a spec here at work. Check if there are other multi-value types
+                // which should be tested for here.
+                std::string type;
+
+                XmlParser::getStdStrAttribute(currentNode, "type", type);
+                if (type == "float4x4")
+                    acc.mSize += 16;
+                else
+                    acc.mSize += 1;
+            }
+
+            acc.mParams.push_back(name);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads input declarations of per-vertex mesh data into the given mesh
+void ColladaParser::ReadVertexData(XmlNode &node, Mesh &pMesh) {
+    // extract the ID of the <vertices> element. Not that we care, but to catch strange referencing schemes we should warn about
+    XmlParser::getStdStrAttribute(node, "id", pMesh.mVertexID);
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "input") {
+            ReadInputChannel(currentNode, pMesh.mPerVertexData);
+        } else {
+            throw DeadlyImportError("Unexpected sub element <", currentName, "> in tag <vertices>");
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads input declarations of per-index mesh data into the given mesh
+void ColladaParser::ReadIndexData(XmlNode &node, Mesh &pMesh) {
+    std::vector<size_t> vcount;
+    std::vector<InputChannel> perIndexData;
+
+    unsigned int numPrimitives = 0;
+    XmlParser::getUIntAttribute(node, "count", numPrimitives);
+    // read primitive count from the attribute
+    //int attrCount = GetAttribute("count");
+    //size_t numPrimitives = (size_t)mReader->getAttributeValueAsInt(attrCount);
+    // some mesh types (e.g. tristrips) don't specify primitive count upfront,
+    // so we need to sum up the actual number of primitives while we read the <p>-tags
+    size_t actualPrimitives = 0;
+    SubMesh subgroup;
+    if (XmlParser::hasAttribute(node, "material")) {
+        XmlParser::getStdStrAttribute(node, "material", subgroup.mMaterial);
+    }
+
+    // distinguish between polys and triangles
+    std::string elementName = node.name();
+    PrimitiveType primType = Prim_Invalid;
+    if (elementName == "lines")
+        primType = Prim_Lines;
+    else if (elementName == "linestrips")
+        primType = Prim_LineStrip;
+    else if (elementName == "polygons")
+        primType = Prim_Polygon;
+    else if (elementName == "polylist")
+        primType = Prim_Polylist;
+    else if (elementName == "triangles")
+        primType = Prim_Triangles;
+    else if (elementName == "trifans")
+        primType = Prim_TriFans;
+    else if (elementName == "tristrips")
+        primType = Prim_TriStrips;
+
+    ai_assert(primType != Prim_Invalid);
+
+    // also a number of <input> elements, but in addition a <p> primitive collection and probably index counts for all primitives
+    XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode);
+    XmlNode currentNode;
+    while (xmlIt.getNext(currentNode)) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "input") {
+            ReadInputChannel(currentNode, perIndexData);
+        } else if (currentName == "vcount") {
+            if (!currentNode.empty()) {
+                if (numPrimitives) // It is possible to define a mesh without any primitives
+                {
+                    // case <polylist> - specifies the number of indices for each polygon
+                    std::string v;
+                    XmlParser::getValueAsString(currentNode, v);
+                    const char *content = v.c_str();
+                    vcount.reserve(numPrimitives);
+                    for (unsigned int a = 0; a < numPrimitives; a++) {
+                        if (*content == 0) {
+                            throw DeadlyImportError("Expected more values while reading <vcount> contents.");
+                        }
+                        // read a number
+                        vcount.push_back((size_t)strtoul10(content, &content));
+                        // skip whitespace after it
+                        SkipSpacesAndLineEnd(&content);
+                    }
+                }
+            }
+        } else if (currentName == "p") {
+            if (!currentNode.empty()) {
+                // now here the actual fun starts - these are the indices to construct the mesh data from
+                actualPrimitives += ReadPrimitives(currentNode, pMesh, perIndexData, numPrimitives, vcount, primType);
+            }
+        } else if (currentName == "extra") {
+            // skip
+        } else if (currentName == "ph") {
+            // skip
+        } else {
+            throw DeadlyImportError("Unexpected sub element <", currentName, "> in tag <", elementName, ">");
+        }
+    }
+
+#ifdef ASSIMP_BUILD_DEBUG
+    if (primType != Prim_TriFans && primType != Prim_TriStrips && primType != Prim_LineStrip &&
+            primType != Prim_Lines) { // this is ONLY to workaround a bug in SketchUp 15.3.331 where it writes the wrong 'count' when it writes out the 'lines'.
+        ai_assert(actualPrimitives == numPrimitives);
+    }
+#endif
+
+    // only when we're done reading all <p> tags (and thus know the final vertex count) can we commit the submesh
+    subgroup.mNumFaces = actualPrimitives;
+    pMesh.mSubMeshes.push_back(subgroup);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a single input channel element and stores it in the given array, if valid
+void ColladaParser::ReadInputChannel(XmlNode &node, std::vector<InputChannel> &poChannels) {
+    InputChannel channel;
+
+    // read semantic
+    std::string semantic;
+    XmlParser::getStdStrAttribute(node, "semantic", semantic);
+    channel.mType = GetTypeForSemantic(semantic);
+
+    // read source
+    std::string source;
+    XmlParser::getStdStrAttribute(node, "source", source);
+    if (source[0] != '#') {
+        throw DeadlyImportError("Unknown reference format in url \"", source, "\" in source attribute of <input> element.");
+    }
+    channel.mAccessor = source.c_str() + 1; // skipping the leading #, hopefully the remaining text is the accessor ID only
+
+    // read index offset, if per-index <input>
+    if (XmlParser::hasAttribute(node, "offset")) {
+        XmlParser::getUIntAttribute(node, "offset", (unsigned int &)channel.mOffset);
+    }
+
+    // read set if texture coordinates
+    if (channel.mType == IT_Texcoord || channel.mType == IT_Color) {
+        unsigned int attrSet = 0;
+        if (XmlParser::getUIntAttribute(node, "set", attrSet))
+            channel.mIndex = attrSet;
+    }
+
+    // store, if valid type
+    if (channel.mType != IT_Invalid)
+        poChannels.push_back(channel);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a <p> primitive index list and assembles the mesh data into the given mesh
+size_t ColladaParser::ReadPrimitives(XmlNode &node, Mesh &pMesh, std::vector<InputChannel> &pPerIndexChannels,
+        size_t pNumPrimitives, const std::vector<size_t> &pVCount, PrimitiveType pPrimType) {
+    // determine number of indices coming per vertex
+    // find the offset index for all per-vertex channels
+    size_t numOffsets = 1;
+    size_t perVertexOffset = SIZE_MAX; // invalid value
+    for (const InputChannel &channel : pPerIndexChannels) {
+        numOffsets = std::max(numOffsets, channel.mOffset + 1);
+        if (channel.mType == IT_Vertex)
+            perVertexOffset = channel.mOffset;
+    }
+
+    // determine the expected number of indices
+    size_t expectedPointCount = 0;
+    switch (pPrimType) {
+    case Prim_Polylist: {
+        for (size_t i : pVCount)
+            expectedPointCount += i;
+        break;
+    }
+    case Prim_Lines:
+        expectedPointCount = 2 * pNumPrimitives;
+        break;
+    case Prim_Triangles:
+        expectedPointCount = 3 * pNumPrimitives;
+        break;
+    default:
+        // other primitive types don't state the index count upfront... we need to guess
+        break;
+    }
+
+    // and read all indices into a temporary array
+    std::vector<size_t> indices;
+    if (expectedPointCount > 0) {
+        indices.reserve(expectedPointCount * numOffsets);
+    }
+
+    // It is possible to not contain any indices
+    if (pNumPrimitives > 0) {
+        std::string v;
+        XmlParser::getValueAsString(node, v);
+        const char *content = v.c_str();
+        SkipSpacesAndLineEnd(&content);
+        while (*content != 0) {
+            // read a value.
+            // Hack: (thom) Some exporters put negative indices sometimes. We just try to carry on anyways.
+            int value = std::max(0, strtol10(content, &content));
+            indices.push_back(size_t(value));
+            // skip whitespace after it
+            SkipSpacesAndLineEnd(&content);
+        }
+    }
+
+    // complain if the index count doesn't fit
+    if (expectedPointCount > 0 && indices.size() != expectedPointCount * numOffsets) {
+        if (pPrimType == Prim_Lines) {
+            // HACK: We just fix this number since SketchUp 15.3.331 writes the wrong 'count' for 'lines'
+            ReportWarning("Expected different index count in <p> element, %zu instead of %zu.", indices.size(), expectedPointCount * numOffsets);
+            pNumPrimitives = (indices.size() / numOffsets) / 2;
+        } else {
+            throw DeadlyImportError("Expected different index count in <p> element.");
+        }
+    } else if (expectedPointCount == 0 && (indices.size() % numOffsets) != 0) {
+        throw DeadlyImportError("Expected different index count in <p> element.");
+    }
+
+    // find the data for all sources
+    for (std::vector<InputChannel>::iterator it = pMesh.mPerVertexData.begin(); it != pMesh.mPerVertexData.end(); ++it) {
+        InputChannel &input = *it;
+        if (input.mResolved) {
+            continue;
+        }
+
+        // find accessor
+        input.mResolved = &ResolveLibraryReference(mAccessorLibrary, input.mAccessor);
+        // resolve accessor's data pointer as well, if necessary
+        const Accessor *acc = input.mResolved;
+        if (!acc->mData) {
+            acc->mData = &ResolveLibraryReference(mDataLibrary, acc->mSource);
+        }
+    }
+    // and the same for the per-index channels
+    for (std::vector<InputChannel>::iterator it = pPerIndexChannels.begin(); it != pPerIndexChannels.end(); ++it) {
+        InputChannel &input = *it;
+        if (input.mResolved) {
+            continue;
+        }
+
+        // ignore vertex pointer, it doesn't refer to an accessor
+        if (input.mType == IT_Vertex) {
+            // warn if the vertex channel does not refer to the <vertices> element in the same mesh
+            if (input.mAccessor != pMesh.mVertexID) {
+                throw DeadlyImportError("Unsupported vertex referencing scheme.");
+            }
+            continue;
+        }
+
+        // find accessor
+        input.mResolved = &ResolveLibraryReference(mAccessorLibrary, input.mAccessor);
+        // resolve accessor's data pointer as well, if necessary
+        const Accessor *acc = input.mResolved;
+        if (!acc->mData) {
+            acc->mData = &ResolveLibraryReference(mDataLibrary, acc->mSource);
+        }
+    }
+
+    // For continued primitives, the given count does not come all in one <p>, but only one primitive per <p>
+    size_t numPrimitives = pNumPrimitives;
+    if (pPrimType == Prim_TriFans || pPrimType == Prim_Polygon)
+        numPrimitives = 1;
+    // For continued primitives, the given count is actually the number of <p>'s inside the parent tag
+    if (pPrimType == Prim_TriStrips) {
+        size_t numberOfVertices = indices.size() / numOffsets;
+        numPrimitives = numberOfVertices - 2;
+    }
+    if (pPrimType == Prim_LineStrip) {
+        size_t numberOfVertices = indices.size() / numOffsets;
+        numPrimitives = numberOfVertices - 1;
+    }
+
+    pMesh.mFaceSize.reserve(numPrimitives);
+    pMesh.mFacePosIndices.reserve(indices.size() / numOffsets);
+
+    size_t polylistStartVertex = 0;
+    for (size_t currentPrimitive = 0; currentPrimitive < numPrimitives; currentPrimitive++) {
+        // determine number of points for this primitive
+        size_t numPoints = 0;
+        switch (pPrimType) {
+        case Prim_Lines:
+            numPoints = 2;
+            for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++)
+                CopyVertex(currentVertex, numOffsets, numPoints, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+            break;
+        case Prim_LineStrip:
+            numPoints = 2;
+            for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++)
+                CopyVertex(currentVertex, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+            break;
+        case Prim_Triangles:
+            numPoints = 3;
+            for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++)
+                CopyVertex(currentVertex, numOffsets, numPoints, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+            break;
+        case Prim_TriStrips:
+            numPoints = 3;
+            ReadPrimTriStrips(numOffsets, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+            break;
+        case Prim_Polylist:
+            numPoints = pVCount[currentPrimitive];
+            for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++)
+                CopyVertex(polylistStartVertex + currentVertex, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, 0, indices);
+            polylistStartVertex += numPoints;
+            break;
+        case Prim_TriFans:
+        case Prim_Polygon:
+            numPoints = indices.size() / numOffsets;
+            for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++)
+                CopyVertex(currentVertex, numOffsets, numPoints, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+            break;
+        default:
+            // LineStrip is not supported due to expected index unmangling
+            throw DeadlyImportError("Unsupported primitive type.");
+            break;
+        }
+
+        // store the face size to later reconstruct the face from
+        pMesh.mFaceSize.push_back(numPoints);
+    }
+
+    // if I ever get my hands on that guy who invented this steaming pile of indirection...
+    return numPrimitives;
+}
+
+///@note This function won't work correctly if both PerIndex and PerVertex channels have same channels.
+///For example if TEXCOORD present in both <vertices> and <polylist> tags this function will create wrong uv coordinates.
+///It's not clear from COLLADA documentation is this allowed or not. For now only exporter fixed to avoid such behavior
+void ColladaParser::CopyVertex(size_t currentVertex, size_t numOffsets, size_t numPoints, size_t perVertexOffset, Mesh &pMesh,
+        std::vector<InputChannel> &pPerIndexChannels, size_t currentPrimitive, const std::vector<size_t> &indices) {
+    // calculate the base offset of the vertex whose attributes we ant to copy
+    size_t baseOffset = currentPrimitive * numOffsets * numPoints + currentVertex * numOffsets;
+
+    // don't overrun the boundaries of the index list
+    ai_assert((baseOffset + numOffsets - 1) < indices.size());
+
+    // extract per-vertex channels using the global per-vertex offset
+    for (std::vector<InputChannel>::iterator it = pMesh.mPerVertexData.begin(); it != pMesh.mPerVertexData.end(); ++it) {
+        ExtractDataObjectFromChannel(*it, indices[baseOffset + perVertexOffset], pMesh);
+    }
+    // and extract per-index channels using there specified offset
+    for (std::vector<InputChannel>::iterator it = pPerIndexChannels.begin(); it != pPerIndexChannels.end(); ++it) {
+        ExtractDataObjectFromChannel(*it, indices[baseOffset + it->mOffset], pMesh);
+    }
+
+    // store the vertex-data index for later assignment of bone vertex weights
+    pMesh.mFacePosIndices.push_back(indices[baseOffset + perVertexOffset]);
+}
+
+void ColladaParser::ReadPrimTriStrips(size_t numOffsets, size_t perVertexOffset, Mesh &pMesh, std::vector<InputChannel> &pPerIndexChannels,
+        size_t currentPrimitive, const std::vector<size_t> &indices) {
+    if (currentPrimitive % 2 != 0) {
+        //odd tristrip triangles need their indices mangled, to preserve winding direction
+        CopyVertex(1, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+        CopyVertex(0, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+        CopyVertex(2, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+    } else { //for non tristrips or even tristrip triangles
+        CopyVertex(0, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+        CopyVertex(1, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+        CopyVertex(2, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Extracts a single object from an input channel and stores it in the appropriate mesh data array
+void ColladaParser::ExtractDataObjectFromChannel(const InputChannel &pInput, size_t pLocalIndex, Mesh &pMesh) {
+    // ignore vertex referrer - we handle them that separate
+    if (pInput.mType == IT_Vertex) {
+        return;
+    }
+
+    const Accessor &acc = *pInput.mResolved;
+    if (pLocalIndex >= acc.mCount) {
+        throw DeadlyImportError("Invalid data index (", pLocalIndex, "/", acc.mCount, ") in primitive specification");
+    }
+
+    // get a pointer to the start of the data object referred to by the accessor and the local index
+    const ai_real *dataObject = &(acc.mData->mValues[0]) + acc.mOffset + pLocalIndex * acc.mStride;
+
+    // assemble according to the accessors component sub-offset list. We don't care, yet,
+    // what kind of object exactly we're extracting here
+    ai_real obj[4];
+    for (size_t c = 0; c < 4; ++c) {
+        obj[c] = dataObject[acc.mSubOffset[c]];
+    }
+
+    // now we reinterpret it according to the type we're reading here
+    switch (pInput.mType) {
+    case IT_Position: // ignore all position streams except 0 - there can be only one position
+        if (pInput.mIndex == 0) {
+            pMesh.mPositions.push_back(aiVector3D(obj[0], obj[1], obj[2]));
+        } else {
+            ASSIMP_LOG_ERROR("Collada: just one vertex position stream supported");
+        }
+        break;
+    case IT_Normal:
+        // pad to current vertex count if necessary
+        if (pMesh.mNormals.size() < pMesh.mPositions.size() - 1)
+            pMesh.mNormals.insert(pMesh.mNormals.end(), pMesh.mPositions.size() - pMesh.mNormals.size() - 1, aiVector3D(0, 1, 0));
+
+        // ignore all normal streams except 0 - there can be only one normal
+        if (pInput.mIndex == 0) {
+            pMesh.mNormals.push_back(aiVector3D(obj[0], obj[1], obj[2]));
+        } else {
+            ASSIMP_LOG_ERROR("Collada: just one vertex normal stream supported");
+        }
+        break;
+    case IT_Tangent:
+        // pad to current vertex count if necessary
+        if (pMesh.mTangents.size() < pMesh.mPositions.size() - 1)
+            pMesh.mTangents.insert(pMesh.mTangents.end(), pMesh.mPositions.size() - pMesh.mTangents.size() - 1, aiVector3D(1, 0, 0));
+
+        // ignore all tangent streams except 0 - there can be only one tangent
+        if (pInput.mIndex == 0) {
+            pMesh.mTangents.push_back(aiVector3D(obj[0], obj[1], obj[2]));
+        } else {
+            ASSIMP_LOG_ERROR("Collada: just one vertex tangent stream supported");
+        }
+        break;
+    case IT_Bitangent:
+        // pad to current vertex count if necessary
+        if (pMesh.mBitangents.size() < pMesh.mPositions.size() - 1) {
+            pMesh.mBitangents.insert(pMesh.mBitangents.end(), pMesh.mPositions.size() - pMesh.mBitangents.size() - 1, aiVector3D(0, 0, 1));
+        }
+
+        // ignore all bitangent streams except 0 - there can be only one bitangent
+        if (pInput.mIndex == 0) {
+            pMesh.mBitangents.push_back(aiVector3D(obj[0], obj[1], obj[2]));
+        } else {
+            ASSIMP_LOG_ERROR("Collada: just one vertex bitangent stream supported");
+        }
+        break;
+    case IT_Texcoord:
+        // up to 4 texture coord sets are fine, ignore the others
+        if (pInput.mIndex < AI_MAX_NUMBER_OF_TEXTURECOORDS) {
+            // pad to current vertex count if necessary
+            if (pMesh.mTexCoords[pInput.mIndex].size() < pMesh.mPositions.size() - 1)
+                pMesh.mTexCoords[pInput.mIndex].insert(pMesh.mTexCoords[pInput.mIndex].end(),
+                        pMesh.mPositions.size() - pMesh.mTexCoords[pInput.mIndex].size() - 1, aiVector3D(0, 0, 0));
+
+            pMesh.mTexCoords[pInput.mIndex].push_back(aiVector3D(obj[0], obj[1], obj[2]));
+            if (0 != acc.mSubOffset[2] || 0 != acc.mSubOffset[3]) {
+                pMesh.mNumUVComponents[pInput.mIndex] = 3;
+            }
+        } else {
+            ASSIMP_LOG_ERROR("Collada: too many texture coordinate sets. Skipping.");
+        }
+        break;
+    case IT_Color:
+        // up to 4 color sets are fine, ignore the others
+        if (pInput.mIndex < AI_MAX_NUMBER_OF_COLOR_SETS) {
+            // pad to current vertex count if necessary
+            if (pMesh.mColors[pInput.mIndex].size() < pMesh.mPositions.size() - 1)
+                pMesh.mColors[pInput.mIndex].insert(pMesh.mColors[pInput.mIndex].end(),
+                        pMesh.mPositions.size() - pMesh.mColors[pInput.mIndex].size() - 1, aiColor4D(0, 0, 0, 1));
+
+            aiColor4D result(0, 0, 0, 1);
+            for (size_t i = 0; i < pInput.mResolved->mSize; ++i) {
+                result[static_cast<unsigned int>(i)] = obj[pInput.mResolved->mSubOffset[i]];
+            }
+            pMesh.mColors[pInput.mIndex].push_back(result);
+        } else {
+            ASSIMP_LOG_ERROR("Collada: too many vertex color sets. Skipping.");
+        }
+
+        break;
+    default:
+        // IT_Invalid and IT_Vertex
+        ai_assert(false && "shouldn't ever get here");
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the library of node hierarchies and scene parts
+void ColladaParser::ReadSceneLibrary(XmlNode &node) {
+    if (node.empty()) {
+        return;
+    }
+
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "visual_scene") {
+            // read ID. Is optional according to the spec, but how on earth should a scene_instance refer to it then?
+            std::string id;
+            XmlParser::getStdStrAttribute(currentNode, "id", id);
+
+            // read name if given.
+            std::string attrName = "Scene";
+            if (XmlParser::hasAttribute(currentNode, "name")) {
+                XmlParser::getStdStrAttribute(currentNode, "name", attrName);
+            }
+
+            // create a node and store it in the library under its ID
+            Node *sceneNode = new Node;
+            sceneNode->mID = id;
+            sceneNode->mName = attrName;
+            mNodeLibrary[sceneNode->mID] = sceneNode;
+
+            ReadSceneNode(currentNode, sceneNode);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a scene node's contents including children and stores it in the given node
+void ColladaParser::ReadSceneNode(XmlNode &node, Node *pNode) {
+    // quit immediately on <bla/> elements
+    if (node.empty()) {
+        return;
+    }
+
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "node") {
+            Node *child = new Node;
+            if (XmlParser::hasAttribute(currentNode, "id")) {
+                XmlParser::getStdStrAttribute(currentNode, "id", child->mID);
+            }
+            if (XmlParser::hasAttribute(currentNode, "sid")) {
+                XmlParser::getStdStrAttribute(currentNode, "id", child->mSID);
+            }
+            if (XmlParser::hasAttribute(currentNode, "name")) {
+                XmlParser::getStdStrAttribute(currentNode, "name", child->mName);
+            }
+            if (pNode) {
+                pNode->mChildren.push_back(child);
+                child->mParent = pNode;
+            } else {
+                // no parent node given, probably called from <library_nodes> element.
+                // create new node in node library
+                mNodeLibrary[child->mID] = child;
+            }
+
+            // read on recursively from there
+            ReadSceneNode(currentNode, child);
+            continue;
+        } else if (!pNode) {
+            // For any further stuff we need a valid node to work on
+            continue;
+        }
+        if (currentName == "lookat") {
+            ReadNodeTransformation(currentNode, pNode, TF_LOOKAT);
+        } else if (currentName == "matrix") {
+            ReadNodeTransformation(currentNode, pNode, TF_MATRIX);
+        } else if (currentName == "rotate") {
+            ReadNodeTransformation(currentNode, pNode, TF_ROTATE);
+        } else if (currentName == "scale") {
+            ReadNodeTransformation(currentNode, pNode, TF_SCALE);
+        } else if (currentName == "skew") {
+            ReadNodeTransformation(currentNode, pNode, TF_SKEW);
+        } else if (currentName == "translate") {
+            ReadNodeTransformation(currentNode, pNode, TF_TRANSLATE);
+        } else if (currentName == "render" && pNode->mParent == nullptr && 0 == pNode->mPrimaryCamera.length()) {
+            // ... scene evaluation or, in other words, postprocessing pipeline,
+            // or, again in other words, a turing-complete description how to
+            // render a Collada scene. The only thing that is interesting for
+            // us is the primary camera.
+            if (XmlParser::hasAttribute(currentNode, "camera_node")) {
+                std::string s;
+                XmlParser::getStdStrAttribute(currentNode, "camera_node", s);
+                if (s[0] != '#') {
+                    ASSIMP_LOG_ERROR("Collada: Unresolved reference format of camera");
+                } else {
+                    pNode->mPrimaryCamera = s.c_str() + 1;
+                }
+            }
+        } else if (currentName == "instance_node") {
+            // find the node in the library
+            if (XmlParser::hasAttribute(currentNode, "url")) {
+                std::string s;
+                XmlParser::getStdStrAttribute(currentNode, "url", s);
+                if (s[0] != '#') {
+                    ASSIMP_LOG_ERROR("Collada: Unresolved reference format of node");
+                } else {
+                    pNode->mNodeInstances.push_back(NodeInstance());
+                    pNode->mNodeInstances.back().mNode = s.c_str() + 1;
+                }
+            }
+        } else if (currentName == "instance_geometry" || currentName == "instance_controller") {
+            // Reference to a mesh or controller, with possible material associations
+            ReadNodeGeometry(currentNode, pNode);
+        } else if (currentName == "instance_light") {
+            // Reference to a light, name given in 'url' attribute
+            if (XmlParser::hasAttribute(currentNode, "url")) {
+                std::string url;
+                XmlParser::getStdStrAttribute(currentNode, "url", url);
+                if (url[0] != '#') {
+                    throw DeadlyImportError("Unknown reference format in <instance_light> element");
+                }
+
+                pNode->mLights.push_back(LightInstance());
+                pNode->mLights.back().mLight = url.c_str() + 1;
+            }
+        } else if (currentName == "instance_camera") {
+            // Reference to a camera, name given in 'url' attribute
+            if (XmlParser::hasAttribute(currentNode, "url")) {
+                std::string url;
+                XmlParser::getStdStrAttribute(currentNode, "url", url);
+                if (url[0] != '#') {
+                    throw DeadlyImportError("Unknown reference format in <instance_camera> element");
+                }
+                pNode->mCameras.push_back(CameraInstance());
+                pNode->mCameras.back().mCamera = url.c_str() + 1;
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a node transformation entry of the given type and adds it to the given node's transformation list.
+void ColladaParser::ReadNodeTransformation(XmlNode &node, Node *pNode, TransformType pType) {
+    if (node.empty()) {
+        return;
+    }
+
+    std::string tagName = node.name();
+
+    Transform tf;
+    tf.mType = pType;
+
+    // read SID
+    if (XmlParser::hasAttribute(node, "sid")) {
+        XmlParser::getStdStrAttribute(node, "sid", tf.mID);
+    }
+
+    // how many parameters to read per transformation type
+    static const unsigned int sNumParameters[] = { 9, 4, 3, 3, 7, 16 };
+    std::string value;
+    XmlParser::getValueAsString(node, value);
+    const char *content = value.c_str();
+
+    // read as many parameters and store in the transformation
+    for (unsigned int a = 0; a < sNumParameters[pType]; a++) {
+        // skip whitespace before the number
+        SkipSpacesAndLineEnd(&content);
+        // read a number
+        content = fast_atoreal_move<ai_real>(content, tf.f[a]);
+    }
+
+    // place the transformation at the queue of the node
+    pNode->mTransforms.push_back(tf);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Processes bind_vertex_input and bind elements
+void ColladaParser::ReadMaterialVertexInputBinding(XmlNode &node, Collada::SemanticMappingTable &tbl) {
+    std::string name = node.name();
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "bind_vertex_input") {
+            Collada::InputSemanticMapEntry vn;
+
+            // effect semantic
+            if (XmlParser::hasAttribute(currentNode, "semantic")) {
+                std::string s;
+                XmlParser::getStdStrAttribute(currentNode, "semantic", s);
+                XmlParser::getUIntAttribute(currentNode, "input_semantic", (unsigned int &)vn.mType);
+            }
+            std::string s;
+            XmlParser::getStdStrAttribute(currentNode, "semantic", s);
+
+            // input semantic
+            XmlParser::getUIntAttribute(currentNode, "input_semantic", (unsigned int &)vn.mType);
+
+            // index of input set
+            if (XmlParser::hasAttribute(currentNode, "input_set")) {
+                XmlParser::getUIntAttribute(currentNode, "input_set", vn.mSet);
+            }
+
+            tbl.mMap[s] = vn;
+        } else if (currentName == "bind") {
+            ASSIMP_LOG_WARN("Collada: Found unsupported <bind> element");
+        }
+    }
+}
+
+void ColladaParser::ReadEmbeddedTextures(ZipArchiveIOSystem &zip_archive) {
+    // Attempt to load any undefined Collada::Image in ImageLibrary
+    for (auto &it : mImageLibrary) {
+        Collada::Image &image = it.second;
+
+        if (image.mImageData.empty()) {
+            std::unique_ptr<IOStream> image_file(zip_archive.Open(image.mFileName.c_str()));
+            if (image_file) {
+                image.mImageData.resize(image_file->FileSize());
+                image_file->Read(image.mImageData.data(), image_file->FileSize(), 1);
+                image.mEmbeddedFormat = BaseImporter::GetExtension(image.mFileName);
+                if (image.mEmbeddedFormat == "jpeg") {
+                    image.mEmbeddedFormat = "jpg";
+                }
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a mesh reference in a node and adds it to the node's mesh list
+void ColladaParser::ReadNodeGeometry(XmlNode &node, Node *pNode) {
+    // referred mesh is given as an attribute of the <instance_geometry> element
+    std::string url;
+    XmlParser::getStdStrAttribute(node, "url", url);
+    if (url[0] != '#') {
+        throw DeadlyImportError("Unknown reference format");
+    }
+
+    Collada::MeshInstance instance;
+    instance.mMeshOrController = url.c_str() + 1; // skipping the leading #
+
+    for (XmlNode currentNode = node.first_child(); currentNode; currentNode = currentNode.next_sibling()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "bind_material") {
+            XmlNode techNode = currentNode.child("technique_common");
+            if (techNode) {
+                for (XmlNode instanceMatNode = techNode.child("instance_material"); instanceMatNode; instanceMatNode = instanceMatNode.next_sibling())
+                {
+                    const std::string &instance_name = instanceMatNode.name();
+                    if (instance_name == "instance_material")
+                    {
+                        // read ID of the geometry subgroup and the target material
+                        std::string group;
+                        XmlParser::getStdStrAttribute(instanceMatNode, "symbol", group);
+                        XmlParser::getStdStrAttribute(instanceMatNode, "target", url);
+                        const char *urlMat = url.c_str();
+                        Collada::SemanticMappingTable s;
+                        if (urlMat[0] == '#')
+                            urlMat++;
+
+                        s.mMatName = urlMat;
+                        // store the association
+                        instance.mMaterials[group] = s;
+                        ReadMaterialVertexInputBinding(instanceMatNode, s);
+                    }
+                }
+            }
+        }
+    }
+
+    // store it
+    pNode->mMeshes.push_back(instance);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the collada scene
+void ColladaParser::ReadScene(XmlNode &node) {
+    if (node.empty()) {
+        return;
+    }
+
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "instance_visual_scene") {
+            // should be the first and only occurrence
+            if (mRootNode) {
+                throw DeadlyImportError("Invalid scene containing multiple root nodes in <instance_visual_scene> element");
+            }
+
+            // read the url of the scene to instance. Should be of format "#some_name"
+            std::string url;
+            XmlParser::getStdStrAttribute(currentNode, "url", url);
+            if (url[0] != '#') {
+                throw DeadlyImportError("Unknown reference format in <instance_visual_scene> element");
+            }
+
+            // find the referred scene, skip the leading #
+            NodeLibrary::const_iterator sit = mNodeLibrary.find(url.c_str() + 1);
+            if (sit == mNodeLibrary.end()) {
+                throw DeadlyImportError("Unable to resolve visual_scene reference \"", std::string(url), "\" in <instance_visual_scene> element.");
+            }
+            mRootNode = sit->second;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Calculates the resulting transformation from all the given transform steps
+aiMatrix4x4 ColladaParser::CalculateResultTransform(const std::vector<Transform> &pTransforms) const {
+    aiMatrix4x4 res;
+
+    for (std::vector<Transform>::const_iterator it = pTransforms.begin(); it != pTransforms.end(); ++it) {
+        const Transform &tf = *it;
+        switch (tf.mType) {
+        case TF_LOOKAT: {
+            aiVector3D pos(tf.f[0], tf.f[1], tf.f[2]);
+            aiVector3D dstPos(tf.f[3], tf.f[4], tf.f[5]);
+            aiVector3D up = aiVector3D(tf.f[6], tf.f[7], tf.f[8]).Normalize();
+            aiVector3D dir = aiVector3D(dstPos - pos).Normalize();
+            aiVector3D right = (dir ^ up).Normalize();
+
+            res *= aiMatrix4x4(
+                    right.x, up.x, -dir.x, pos.x,
+                    right.y, up.y, -dir.y, pos.y,
+                    right.z, up.z, -dir.z, pos.z,
+                    0, 0, 0, 1);
+            break;
+        }
+        case TF_ROTATE: {
+            aiMatrix4x4 rot;
+            ai_real angle = tf.f[3] * ai_real(AI_MATH_PI) / ai_real(180.0);
+            aiVector3D axis(tf.f[0], tf.f[1], tf.f[2]);
+            aiMatrix4x4::Rotation(angle, axis, rot);
+            res *= rot;
+            break;
+        }
+        case TF_TRANSLATE: {
+            aiMatrix4x4 trans;
+            aiMatrix4x4::Translation(aiVector3D(tf.f[0], tf.f[1], tf.f[2]), trans);
+            res *= trans;
+            break;
+        }
+        case TF_SCALE: {
+            aiMatrix4x4 scale(tf.f[0], 0.0f, 0.0f, 0.0f, 0.0f, tf.f[1], 0.0f, 0.0f, 0.0f, 0.0f, tf.f[2], 0.0f,
+                    0.0f, 0.0f, 0.0f, 1.0f);
+            res *= scale;
+            break;
+        }
+        case TF_SKEW:
+            // TODO: (thom)
+            ai_assert(false);
+            break;
+        case TF_MATRIX: {
+            aiMatrix4x4 mat(tf.f[0], tf.f[1], tf.f[2], tf.f[3], tf.f[4], tf.f[5], tf.f[6], tf.f[7],
+                    tf.f[8], tf.f[9], tf.f[10], tf.f[11], tf.f[12], tf.f[13], tf.f[14], tf.f[15]);
+            res *= mat;
+            break;
+        }
+        default:
+            ai_assert(false);
+            break;
+        }
+    }
+
+    return res;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Determines the input data type for the given semantic string
+Collada::InputType ColladaParser::GetTypeForSemantic(const std::string &semantic) {
+    if (semantic.empty()) {
+        ASSIMP_LOG_WARN("Vertex input type is empty.");
+        return IT_Invalid;
+    }
+
+    if (semantic == "POSITION")
+        return IT_Position;
+    else if (semantic == "TEXCOORD")
+        return IT_Texcoord;
+    else if (semantic == "NORMAL")
+        return IT_Normal;
+    else if (semantic == "COLOR")
+        return IT_Color;
+    else if (semantic == "VERTEX")
+        return IT_Vertex;
+    else if (semantic == "BINORMAL" || semantic == "TEXBINORMAL")
+        return IT_Bitangent;
+    else if (semantic == "TANGENT" || semantic == "TEXTANGENT")
+        return IT_Tangent;
+
+    ASSIMP_LOG_WARN("Unknown vertex input type \"", semantic, "\". Ignoring.");
+    return IT_Invalid;
+}
+
+#endif // !! ASSIMP_BUILD_NO_DAE_IMPORTER
diff --git a/Engine/lib/assimp/code/AssetLib/Collada/ColladaParser.h b/Engine/lib/assimp/code/AssetLib/Collada/ColladaParser.h
new file mode 100644
index 000000000..15982934f
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Collada/ColladaParser.h
@@ -0,0 +1,348 @@
+/*
+ Open Asset Import Library (assimp)
+ ----------------------------------------------------------------------
+
+ Copyright (c) 2006-2022, assimp team
+
+ All rights reserved.
+
+ Redistribution and use of this software in source and binary forms,
+ with or without modification, are permitted provided that the
+ following conditions are met:
+
+ * Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+ * Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ----------------------------------------------------------------------
+ */
+
+/** @file ColladaParser.h
+ *  @brief Defines the parser helper class for the collada loader
+ */
+
+#pragma once
+#ifndef AI_COLLADAPARSER_H_INC
+#define AI_COLLADAPARSER_H_INC
+
+#include "ColladaHelper.h"
+#include <assimp/TinyFormatter.h>
+#include <assimp/ai_assert.h>
+#include <assimp/XmlParser.h>
+
+#include <map>
+
+namespace Assimp {
+
+class ZipArchiveIOSystem;
+
+// ------------------------------------------------------------------------------------------
+/** Parser helper class for the Collada loader.
+     *
+     *  Does all the XML reading and builds internal data structures from it,
+     *  but leaves the resolving of all the references to the loader.
+     */
+class ColladaParser {
+    friend class ColladaLoader;
+
+    /** Converts a path read from a collada file to the usual representation */
+    static void UriDecodePath(aiString &ss);
+
+protected:
+    /** Map for generic metadata as aiString */
+    typedef std::map<std::string, aiString> StringMetaData;
+
+    /** Constructor from XML file */
+    ColladaParser(IOSystem *pIOHandler, const std::string &pFile);
+
+    /** Destructor */
+    ~ColladaParser();
+
+    /** Attempts to read the ZAE manifest and returns the DAE to open */
+    static std::string ReadZaeManifest(ZipArchiveIOSystem &zip_archive);
+
+    /** Reads the contents of the file */
+    void ReadContents(XmlNode &node);
+
+    /** Reads the structure of the file */
+    void ReadStructure(XmlNode &node);
+
+    /** Reads asset information such as coordinate system information and legal blah */
+    void ReadAssetInfo(XmlNode &node);
+
+    /** Reads contributor information such as author and legal blah */
+    void ReadContributorInfo(XmlNode &node);
+
+    /** Reads generic metadata into provided map and renames keys for Assimp */
+    void ReadMetaDataItem(XmlNode &node, StringMetaData &metadata);
+
+    /** Reads the animation library */
+    void ReadAnimationLibrary(XmlNode &node);
+
+    /** Reads the animation clip library */
+    void ReadAnimationClipLibrary(XmlNode &node);
+
+    /** Unwrap controllers dependency hierarchy */
+    void PostProcessControllers();
+
+    /** Re-build animations from animation clip library, if present, otherwise combine single-channel animations */
+    void PostProcessRootAnimations();
+
+    /** Reads an animation into the given parent structure */
+    void ReadAnimation(XmlNode &node, Collada::Animation *pParent);
+
+    /** Reads an animation sampler into the given anim channel */
+    void ReadAnimationSampler(XmlNode &node, Collada::AnimationChannel &pChannel);
+
+    /** Reads the skeleton controller library */
+    void ReadControllerLibrary(XmlNode &node);
+
+    /** Reads a controller into the given mesh structure */
+    void ReadController(XmlNode &node, Collada::Controller &pController);
+
+    /** Reads the joint definitions for the given controller */
+    void ReadControllerJoints(XmlNode &node, Collada::Controller &pController);
+
+    /** Reads the joint weights for the given controller */
+    void ReadControllerWeights(XmlNode &node, Collada::Controller &pController);
+
+    /** Reads the image library contents */
+    void ReadImageLibrary(XmlNode &node);
+
+    /** Reads an image entry into the given image */
+    void ReadImage(XmlNode &node, Collada::Image &pImage);
+
+    /** Reads the material library */
+    void ReadMaterialLibrary(XmlNode &node);
+
+    /** Reads a material entry into the given material */
+    void ReadMaterial(XmlNode &node, Collada::Material &pMaterial);
+
+    /** Reads the camera library */
+    void ReadCameraLibrary(XmlNode &node);
+
+    /** Reads a camera entry into the given camera */
+    void ReadCamera(XmlNode &node, Collada::Camera &pCamera);
+
+    /** Reads the light library */
+    void ReadLightLibrary(XmlNode &node);
+
+    /** Reads a light entry into the given light */
+    void ReadLight(XmlNode &node, Collada::Light &pLight);
+
+    /** Reads the effect library */
+    void ReadEffectLibrary(XmlNode &node);
+
+    /** Reads an effect entry into the given effect*/
+    void ReadEffect(XmlNode &node, Collada::Effect &pEffect);
+
+    /** Reads an COMMON effect profile */
+    void ReadEffectProfileCommon(XmlNode &node, Collada::Effect &pEffect);
+
+    /** Read sampler properties */
+    void ReadSamplerProperties(XmlNode &node, Collada::Sampler &pSampler);
+
+    /** Reads an effect entry containing a color or a texture defining that color */
+    void ReadEffectColor(XmlNode &node, aiColor4D &pColor, Collada::Sampler &pSampler);
+
+    /** Reads an effect entry containing a float */
+    void ReadEffectFloat(XmlNode &node, ai_real &pFloat);
+
+    /** Reads an effect parameter specification of any kind */
+    void ReadEffectParam(XmlNode &node, Collada::EffectParam &pParam);
+
+    /** Reads the geometry library contents */
+    void ReadGeometryLibrary(XmlNode &node);
+
+    /** Reads a geometry from the geometry library. */
+    void ReadGeometry(XmlNode &node, Collada::Mesh &pMesh);
+
+    /** Reads a mesh from the geometry library */
+    void ReadMesh(XmlNode &node, Collada::Mesh &pMesh);
+
+    /** Reads a source element - a combination of raw data and an accessor defining
+         * things that should not be redefinable. Yes, that's another rant.
+         */
+    void ReadSource(XmlNode &node);
+
+    /** Reads a data array holding a number of elements, and stores it in the global library.
+         * Currently supported are array of floats and arrays of strings.
+         */
+    void ReadDataArray(XmlNode &node);
+
+    /** Reads an accessor and stores it in the global library under the given ID -
+         * accessors use the ID of the parent <source> element
+         */
+    void ReadAccessor(XmlNode &node, const std::string &pID);
+
+    /** Reads input declarations of per-vertex mesh data into the given mesh */
+    void ReadVertexData(XmlNode &node, Collada::Mesh &pMesh);
+
+    /** Reads input declarations of per-index mesh data into the given mesh */
+    void ReadIndexData(XmlNode &node, Collada::Mesh &pMesh);
+
+    /** Reads a single input channel element and stores it in the given array, if valid */
+    void ReadInputChannel(XmlNode &node, std::vector<Collada::InputChannel> &poChannels);
+
+    /** Reads a <p> primitive index list and assembles the mesh data into the given mesh */
+    size_t ReadPrimitives(XmlNode &node, Collada::Mesh &pMesh, std::vector<Collada::InputChannel> &pPerIndexChannels,
+            size_t pNumPrimitives, const std::vector<size_t> &pVCount, Collada::PrimitiveType pPrimType);
+
+    /** Copies the data for a single primitive into the mesh, based on the InputChannels */
+    void CopyVertex(size_t currentVertex, size_t numOffsets, size_t numPoints, size_t perVertexOffset,
+            Collada::Mesh &pMesh, std::vector<Collada::InputChannel> &pPerIndexChannels,
+            size_t currentPrimitive, const std::vector<size_t> &indices);
+
+    /** Reads one triangle of a tristrip into the mesh */
+    void ReadPrimTriStrips(size_t numOffsets, size_t perVertexOffset, Collada::Mesh &pMesh,
+            std::vector<Collada::InputChannel> &pPerIndexChannels, size_t currentPrimitive, const std::vector<size_t> &indices);
+
+    /** Extracts a single object from an input channel and stores it in the appropriate mesh data array */
+    void ExtractDataObjectFromChannel(const Collada::InputChannel &pInput, size_t pLocalIndex, Collada::Mesh &pMesh);
+
+    /** Reads the library of node hierarchies and scene parts */
+    void ReadSceneLibrary(XmlNode &node);
+
+    /** Reads a scene node's contents including children and stores it in the given node */
+    void ReadSceneNode(XmlNode &node, Collada::Node *pNode);
+
+    /** Reads a node transformation entry of the given type and adds it to the given node's transformation list. */
+    void ReadNodeTransformation(XmlNode &node, Collada::Node *pNode, Collada::TransformType pType);
+
+    /** Reads a mesh reference in a node and adds it to the node's mesh list */
+    void ReadNodeGeometry(XmlNode &node, Collada::Node *pNode);
+
+    /** Reads the collada scene */
+    void ReadScene(XmlNode &node);
+
+    // Processes bind_vertex_input and bind elements
+    void ReadMaterialVertexInputBinding(XmlNode &node, Collada::SemanticMappingTable &tbl);
+
+    /** Reads embedded textures from a ZAE archive*/
+    void ReadEmbeddedTextures(ZipArchiveIOSystem &zip_archive);
+
+protected:
+    /** Calculates the resulting transformation from all the given transform steps */
+    aiMatrix4x4 CalculateResultTransform(const std::vector<Collada::Transform> &pTransforms) const;
+
+    /** Determines the input data type for the given semantic string */
+    Collada::InputType GetTypeForSemantic(const std::string &pSemantic);
+
+    /** Finds the item in the given library by its reference, throws if not found */
+    template <typename Type>
+    const Type &ResolveLibraryReference(const std::map<std::string, Type> &pLibrary, const std::string &pURL) const;
+
+protected:
+    // Filename, for a verbose error message
+    std::string mFileName;
+
+    // XML reader, member for everyday use
+    XmlParser mXmlParser;
+
+    /** All data arrays found in the file by ID. Might be referred to by actually
+         everyone. Collada, you are a steaming pile of indirection. */
+    using DataLibrary = std::map<std::string, Collada::Data> ;
+    DataLibrary mDataLibrary;
+
+    /** Same for accessors which define how the data in a data array is accessed. */
+    using AccessorLibrary = std::map<std::string, Collada::Accessor> ;
+    AccessorLibrary mAccessorLibrary;
+
+    /** Mesh library: mesh by ID */
+    using MeshLibrary = std::map<std::string, Collada::Mesh *>;
+    MeshLibrary mMeshLibrary;
+
+    /** node library: root node of the hierarchy part by ID */
+    using NodeLibrary = std::map<std::string, Collada::Node *>;
+    NodeLibrary mNodeLibrary;
+
+    /** Image library: stores texture properties by ID */
+    using ImageLibrary = std::map<std::string, Collada::Image> ;
+    ImageLibrary mImageLibrary;
+
+    /** Effect library: surface attributes by ID */
+    using EffectLibrary = std::map<std::string, Collada::Effect> ;
+    EffectLibrary mEffectLibrary;
+
+    /** Material library: surface material by ID */
+    using MaterialLibrary = std::map<std::string, Collada::Material> ;
+    MaterialLibrary mMaterialLibrary;
+
+    /** Light library: surface light by ID */
+    using LightLibrary = std::map<std::string, Collada::Light> ;
+    LightLibrary mLightLibrary;
+
+    /** Camera library: surface material by ID */
+    using CameraLibrary = std::map<std::string, Collada::Camera> ;
+    CameraLibrary mCameraLibrary;
+
+    /** Controller library: joint controllers by ID */
+    using ControllerLibrary = std::map<std::string, Collada::Controller> ;
+    ControllerLibrary mControllerLibrary;
+
+    /** Animation library: animation references by ID */
+    using AnimationLibrary = std::map<std::string, Collada::Animation *> ;
+    AnimationLibrary mAnimationLibrary;
+
+    /** Animation clip library: clip animation references by ID */
+    using AnimationClipLibrary = std::vector<std::pair<std::string, std::vector<std::string>>> ;
+    AnimationClipLibrary mAnimationClipLibrary;
+
+    /** Pointer to the root node. Don't delete, it just points to one of
+         the nodes in the node library. */
+    Collada::Node *mRootNode;
+
+    /** Root animation container */
+    Collada::Animation mAnims;
+
+    /** Size unit: how large compared to a meter */
+    ai_real mUnitSize;
+
+    /** Which is the up vector */
+    enum { UP_X,
+        UP_Y,
+        UP_Z } mUpDirection;
+
+    /** Asset metadata (global for scene) */
+    StringMetaData mAssetMetaData;
+
+    /** Collada file format version */
+    Collada::FormatVersion mFormat;
+};
+
+// ------------------------------------------------------------------------------------------------
+// Finds the item in the given library by its reference, throws if not found
+template <typename Type>
+const Type &ColladaParser::ResolveLibraryReference(const std::map<std::string, Type> &pLibrary, const std::string &pURL) const {
+    typename std::map<std::string, Type>::const_iterator it = pLibrary.find(pURL);
+    if (it == pLibrary.end()) {
+        throw DeadlyImportError("Unable to resolve library reference \"", pURL, "\".");
+    }
+    return it->second;
+}
+
+} // end of namespace Assimp
+
+#endif // AI_COLLADAPARSER_H_INC
diff --git a/Engine/lib/assimp/code/DXF/DXFHelper.h b/Engine/lib/assimp/code/AssetLib/DXF/DXFHelper.h
similarity index 97%
rename from Engine/lib/assimp/code/DXF/DXFHelper.h
rename to Engine/lib/assimp/code/AssetLib/DXF/DXFHelper.h
index 0ec8e130b..e50c471d2 100644
--- a/Engine/lib/assimp/code/DXF/DXFHelper.h
+++ b/Engine/lib/assimp/code/AssetLib/DXF/DXFHelper.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -135,7 +135,7 @@ public:
                 for(;splitter->length() && splitter->at(0) != '}'; splitter++, cnt++);
 
                 splitter++;
-                ASSIMP_LOG_DEBUG((Formatter::format("DXF: skipped over control group ("),cnt," lines)"));
+                ASSIMP_LOG_VERBOSE_DEBUG("DXF: skipped over control group (",cnt," lines)");
             }
         } catch(std::logic_error&) {
             ai_assert(!splitter);
diff --git a/Engine/lib/assimp/code/DXF/DXFLoader.cpp b/Engine/lib/assimp/code/AssetLib/DXF/DXFLoader.cpp
similarity index 95%
rename from Engine/lib/assimp/code/DXF/DXFLoader.cpp
rename to Engine/lib/assimp/code/AssetLib/DXF/DXFLoader.cpp
index baf315485..6b2dbbe82 100644
--- a/Engine/lib/assimp/code/DXF/DXFLoader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/DXF/DXFLoader.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -48,8 +46,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_DXF_IMPORTER
 
-#include "DXF/DXFLoader.h"
-#include "DXF/DXFHelper.h"
+#include "AssetLib/DXF/DXFLoader.h"
+#include "AssetLib/DXF/DXFHelper.h"
 #include "PostProcessing/ConvertToLHProcess.h"
 
 #include <assimp/ParsingUtils.h>
@@ -63,11 +61,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 using namespace Assimp;
 
 // AutoCAD Binary DXF<CR><LF><SUB><NULL>
-const std::string AI_DXF_BINARY_IDENT = std::string("AutoCAD Binary DXF\r\n\x1a\0");
-const size_t AI_DXF_BINARY_IDENT_LEN = 24u;
+static constexpr char AI_DXF_BINARY_IDENT[] = "AutoCAD Binary DXF\r\n\x1a";
+static constexpr size_t AI_DXF_BINARY_IDENT_LEN = sizeof AI_DXF_BINARY_IDENT;
 
 // default vertex color that all uncolored vertices will receive
-const aiColor4D AI_DXF_DEFAULT_COLOR(aiColor4D(0.6f, 0.6f, 0.6f, 0.6f));
+static const aiColor4D AI_DXF_DEFAULT_COLOR(aiColor4D(0.6f, 0.6f, 0.6f, 0.6f));
 
 // color indices for DXF - 16 are supported, the table is
 // taken directly from the DXF spec.
@@ -125,18 +123,9 @@ DXFImporter::~DXFImporter() {
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool DXFImporter::CanRead( const std::string& filename, IOSystem* pIOHandler, bool checkSig ) const {
-    const std::string& extension = GetExtension( filename );
-    if ( extension == desc.mFileExtensions ) {
-        return true;
-    }
-
-    if ( extension.empty() || checkSig ) {
-        const char *pTokens[] = { "SECTION", "HEADER", "ENDSEC", "BLOCKS" };
-        return BaseImporter::SearchFileHeaderForToken(pIOHandler, filename, pTokens, 4, 32 );
-    }
-
-    return false;
+bool DXFImporter::CanRead( const std::string& filename, IOSystem* pIOHandler, bool /*checkSig*/ ) const {
+    static const char *tokens[] = { "SECTION", "HEADER", "ENDSEC", "BLOCKS" };
+    return SearchFileHeaderForToken(pIOHandler, filename, tokens, AI_COUNT_OF(tokens), 32);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -152,14 +141,14 @@ void DXFImporter::InternReadFile( const std::string& filename, aiScene* pScene,
 
     // Check whether we can read the file
     if( file.get() == nullptr ) {
-        throw DeadlyImportError( "Failed to open DXF file " + filename + "");
+        throw DeadlyImportError( "Failed to open DXF file ", filename, "");
     }
 
     // Check whether this is a binary DXF file - we can't read binary DXF files :-(
-    char buff[AI_DXF_BINARY_IDENT_LEN+1] = {0};
+    char buff[AI_DXF_BINARY_IDENT_LEN] = {0};
     file->Read(buff,AI_DXF_BINARY_IDENT_LEN,1);
 
-    if (0 == strncmp(AI_DXF_BINARY_IDENT.c_str(),buff,AI_DXF_BINARY_IDENT_LEN)) {
+    if (0 == memcmp(AI_DXF_BINARY_IDENT,buff,AI_DXF_BINARY_IDENT_LEN)) {
         throw DeadlyImportError("DXF: Binary files are not supported at the moment");
     }
 
@@ -202,7 +191,7 @@ void DXFImporter::InternReadFile( const std::string& filename, aiScene* pScene,
 
         // comments
         else if (reader.Is(999)) {
-            ASSIMP_LOG_INFO_F("DXF Comment: ", reader.Value());
+            ASSIMP_LOG_INFO("DXF Comment: ", reader.Value());
         }
 
         // don't read past the official EOF sign
@@ -241,7 +230,7 @@ void DXFImporter::ConvertMeshes(aiScene* pScene, DXF::FileData& output) {
             }
         }
 
-        ASSIMP_LOG_DEBUG_F("DXF: Unexpanded polycount is ", icount, ", vertex count is ", vcount);
+        ASSIMP_LOG_VERBOSE_DEBUG("DXF: Unexpanded polycount is ", icount, ", vertex count is ", vcount);
     }
 
     if (! output.blocks.size()  ) {
@@ -372,7 +361,7 @@ void DXFImporter::ExpandBlockReferences(DXF::Block& bl,const DXF::BlockMap& bloc
         // first check if the referenced blocks exists ...
         const DXF::BlockMap::const_iterator it = blocks_by_name.find(insert.name);
         if (it == blocks_by_name.end()) {
-            ASSIMP_LOG_ERROR_F("DXF: Failed to resolve block reference: ", insert.name,"; skipping" );
+            ASSIMP_LOG_ERROR("DXF: Failed to resolve block reference: ", insert.name,"; skipping" );
             continue;
         }
 
@@ -380,6 +369,11 @@ void DXFImporter::ExpandBlockReferences(DXF::Block& bl,const DXF::BlockMap& bloc
         const DXF::Block& bl_src = *(*it).second;
 
         for (std::shared_ptr<const DXF::PolyLine> pl_in : bl_src.lines) {
+            if (!pl_in) {
+                ASSIMP_LOG_ERROR("DXF: PolyLine instance is nullptr, skipping.");
+                continue;
+            }
+            
             std::shared_ptr<DXF::PolyLine> pl_out = std::shared_ptr<DXF::PolyLine>(new DXF::PolyLine(*pl_in));
 
             if (bl_src.base.Length() || insert.scale.x!=1.f || insert.scale.y!=1.f || insert.scale.z!=1.f || insert.angle || insert.pos.Length()) {
@@ -473,7 +467,7 @@ void DXFImporter::ParseBlocks(DXF::LineReader& reader, DXF::FileData& output) {
         ++reader;
     }
 
-    ASSIMP_LOG_DEBUG_F("DXF: got ", output.blocks.size()," entries in BLOCKS" );
+    ASSIMP_LOG_VERBOSE_DEBUG("DXF: got ", output.blocks.size()," entries in BLOCKS" );
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -549,7 +543,7 @@ void DXFImporter::ParseEntities(DXF::LineReader& reader, DXF::FileData& output)
         ++reader;
     }
 
-    ASSIMP_LOG_DEBUG_F( "DXF: got ", block.lines.size()," polylines and ", block.insertions.size(), 
+    ASSIMP_LOG_VERBOSE_DEBUG( "DXF: got ", block.lines.size()," polylines and ", block.insertions.size(),
         " inserted blocks in ENTITIES" );
 }
 
@@ -654,7 +648,7 @@ void DXFImporter::ParsePolyLine(DXF::LineReader& reader, DXF::FileData& output)
     //}
 
     if (vguess && line.positions.size() != vguess) {
-        ASSIMP_LOG_WARN_F("DXF: unexpected vertex count in polymesh: ",
+        ASSIMP_LOG_WARN("DXF: unexpected vertex count in polymesh: ",
             line.positions.size(),", expected ", vguess );
     }
 
@@ -670,7 +664,7 @@ void DXFImporter::ParsePolyLine(DXF::LineReader& reader, DXF::FileData& output)
         // to set the 71 and 72 fields, respectively, to valid values.
         // So just fire a warning.
         if (iguess && line.counts.size() != iguess) {
-            ASSIMP_LOG_WARN_F( "DXF: unexpected face count in polymesh: ", line.counts.size(),", expected ", iguess );
+            ASSIMP_LOG_WARN( "DXF: unexpected face count in polymesh: ", line.counts.size(),", expected ", iguess );
         }
     }
     else if (!line.indices.size() && !line.counts.size()) {
diff --git a/Engine/lib/assimp/code/DXF/DXFLoader.h b/Engine/lib/assimp/code/AssetLib/DXF/DXFLoader.h
similarity index 93%
rename from Engine/lib/assimp/code/DXF/DXFLoader.h
rename to Engine/lib/assimp/code/AssetLib/DXF/DXFLoader.h
index 044cf6bcb..b32ae106f 100644
--- a/Engine/lib/assimp/code/DXF/DXFLoader.h
+++ b/Engine/lib/assimp/code/AssetLib/DXF/DXFLoader.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,6 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file  DXFLoader.h
  *  @brief Declaration of the .dxf importer class.
  */
+#pragma once
 #ifndef AI_DXFLOADER_H_INCLUDED
 #define AI_DXFLOADER_H_INCLUDED
 
@@ -59,39 +59,36 @@ namespace DXF {
     struct Block;
     struct InsertBlock;
 
-    typedef std::map<std::string, const DXF::Block*> BlockMap;
+    using BlockMap = std::map<std::string, const DXF::Block*>;
 }
 
 // ---------------------------------------------------------------------------
-/** 
+/**
  *  @brief  DXF importer implementation.
  */
 class DXFImporter : public BaseImporter {
 public:
     DXFImporter();
-    ~DXFImporter();
+    ~DXFImporter() override;
 
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
     * See BaseImporter::CanRead() for details.  */
     bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
+        bool checkSig) const override;
 
 protected:
     // -------------------------------------------------------------------
     /** Return importer meta information.
      * See #BaseImporter::GetInfo for the details*/
-    const aiImporterDesc* GetInfo () const;
+    const aiImporterDesc* GetInfo () const override;
 
     // -------------------------------------------------------------------
     /** Imports the given file into the given scene structure.
      * See BaseImporter::InternReadFile() for details */
-    void InternReadFile( const std::string& pFile,
-        aiScene* pScene,
-        IOSystem* pIOHandler);
+    void InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) override;
 
 private:
-
     // -----------------------------------------------------
     void SkipSection(DXF::LineReader& reader);
 
diff --git a/Engine/lib/assimp/code/FBX/FBXAnimation.cpp b/Engine/lib/assimp/code/AssetLib/FBX/FBXAnimation.cpp
similarity index 59%
rename from Engine/lib/assimp/code/FBX/FBXAnimation.cpp
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXAnimation.cpp
index 874914431..2fa3b7b05 100644
--- a/Engine/lib/assimp/code/FBX/FBXAnimation.cpp
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXAnimation.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -47,10 +47,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_FBX_IMPORTER
 
-#include "FBXParser.h"
 #include "FBXDocument.h"
-#include "FBXImporter.h"
 #include "FBXDocumentUtil.h"
+#include "FBXImporter.h"
+#include "FBXParser.h"
 
 namespace Assimp {
 namespace FBX {
@@ -58,65 +58,60 @@ namespace FBX {
 using namespace Util;
 
 // ------------------------------------------------------------------------------------------------
-AnimationCurve::AnimationCurve(uint64_t id, const Element& element, const std::string& name, const Document& /*doc*/)
-: Object(id, element, name)
-{
-    const Scope& sc = GetRequiredScope(element);
-    const Element& KeyTime = GetRequiredElement(sc,"KeyTime");
-    const Element& KeyValueFloat = GetRequiredElement(sc,"KeyValueFloat");
+AnimationCurve::AnimationCurve(uint64_t id, const Element &element, const std::string &name, const Document & /*doc*/) :
+        Object(id, element, name) {
+    const Scope &sc = GetRequiredScope(element);
+    const Element &KeyTime = GetRequiredElement(sc, "KeyTime");
+    const Element &KeyValueFloat = GetRequiredElement(sc, "KeyValueFloat");
 
     ParseVectorDataArray(keys, KeyTime);
     ParseVectorDataArray(values, KeyValueFloat);
 
-    if(keys.size() != values.size()) {
-        DOMError("the number of key times does not match the number of keyframe values",&KeyTime);
+    if (keys.size() != values.size()) {
+        DOMError("the number of key times does not match the number of keyframe values", &KeyTime);
     }
 
     // check if the key times are well-ordered
-    if(!std::equal(keys.begin(), keys.end() - 1, keys.begin() + 1, std::less<KeyTimeList::value_type>())) {
-        DOMError("the keyframes are not in ascending order",&KeyTime);
+    if (!std::equal(keys.begin(), keys.end() - 1, keys.begin() + 1, std::less<KeyTimeList::value_type>())) {
+        DOMError("the keyframes are not in ascending order", &KeyTime);
     }
 
-    const Element* KeyAttrDataFloat = sc["KeyAttrDataFloat"];
-    if(KeyAttrDataFloat) {
+    const Element *KeyAttrDataFloat = sc["KeyAttrDataFloat"];
+    if (KeyAttrDataFloat) {
         ParseVectorDataArray(attributes, *KeyAttrDataFloat);
     }
 
-    const Element* KeyAttrFlags = sc["KeyAttrFlags"];
-    if(KeyAttrFlags) {
+    const Element *KeyAttrFlags = sc["KeyAttrFlags"];
+    if (KeyAttrFlags) {
         ParseVectorDataArray(flags, *KeyAttrFlags);
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-AnimationCurve::~AnimationCurve()
-{
+AnimationCurve::~AnimationCurve() {
     // empty
 }
 
 // ------------------------------------------------------------------------------------------------
-AnimationCurveNode::AnimationCurveNode(uint64_t id, const Element& element, const std::string& name, 
-        const Document& doc, const char* const * target_prop_whitelist /*= NULL*/, 
-        size_t whitelist_size /*= 0*/)
-: Object(id, element, name)
-, target()
-, doc(doc)
-{
-    const Scope& sc = GetRequiredScope(element);
+AnimationCurveNode::AnimationCurveNode(uint64_t id, const Element &element, const std::string &name,
+        const Document &doc, const char *const *target_prop_whitelist /*= nullptr*/,
+        size_t whitelist_size /*= 0*/) :
+        Object(id, element, name), target(), doc(doc) {
+    const Scope &sc = GetRequiredScope(element);
 
     // find target node
-    const char* whitelist[] = {"Model","NodeAttribute","Deformer"};
-    const std::vector<const Connection*>& conns = doc.GetConnectionsBySourceSequenced(ID(),whitelist,3);
+    const char *whitelist[] = { "Model", "NodeAttribute", "Deformer" };
+    const std::vector<const Connection *> &conns = doc.GetConnectionsBySourceSequenced(ID(), whitelist, 3);
 
-    for(const Connection* con : conns) {
+    for (const Connection *con : conns) {
 
         // link should go for a property
         if (!con->PropertyName().length()) {
             continue;
         }
 
-        if(target_prop_whitelist) {
-            const char* const s = con->PropertyName().c_str();
+        if (target_prop_whitelist) {
+            const char *const s = con->PropertyName().c_str();
             bool ok = false;
             for (size_t i = 0; i < whitelist_size; ++i) {
                 if (!strcmp(s, target_prop_whitelist[i])) {
@@ -130,16 +125,14 @@ AnimationCurveNode::AnimationCurveNode(uint64_t id, const Element& element, cons
             }
         }
 
-        const Object* const ob = con->DestinationObject();
-        if(!ob) {
-            DOMWarning("failed to read destination object for AnimationCurveNode->Model link, ignoring",&element);
+        const Object *const ob = con->DestinationObject();
+        if (!ob) {
+            DOMWarning("failed to read destination object for AnimationCurveNode->Model link, ignoring", &element);
             continue;
         }
 
-        // XXX support constraints as DOM class
-        //ai_assert(dynamic_cast<const Model*>(ob) || dynamic_cast<const NodeAttribute*>(ob));
         target = ob;
-        if(!target) {
+        if (!target) {
             continue;
         }
 
@@ -147,42 +140,40 @@ AnimationCurveNode::AnimationCurveNode(uint64_t id, const Element& element, cons
         break;
     }
 
-    if(!target) {
-        DOMWarning("failed to resolve target Model/NodeAttribute/Constraint for AnimationCurveNode",&element);
+    if (!target) {
+        DOMWarning("failed to resolve target Model/NodeAttribute/Constraint for AnimationCurveNode", &element);
     }
 
-    props = GetPropertyTable(doc,"AnimationCurveNode.FbxAnimCurveNode",element,sc,false);
+    props = GetPropertyTable(doc, "AnimationCurveNode.FbxAnimCurveNode", element, sc, false);
 }
 
 // ------------------------------------------------------------------------------------------------
-AnimationCurveNode::~AnimationCurveNode()
-{
+AnimationCurveNode::~AnimationCurveNode() {
     // empty
 }
 
 // ------------------------------------------------------------------------------------------------
-const AnimationCurveMap& AnimationCurveNode::Curves() const
-{
-    if ( curves.empty() ) {
+const AnimationCurveMap &AnimationCurveNode::Curves() const {
+    if (curves.empty()) {
         // resolve attached animation curves
-        const std::vector<const Connection*>& conns = doc.GetConnectionsByDestinationSequenced(ID(),"AnimationCurve");
+        const std::vector<const Connection *> &conns = doc.GetConnectionsByDestinationSequenced(ID(), "AnimationCurve");
 
-        for(const Connection* con : conns) {
+        for (const Connection *con : conns) {
 
             // link should go for a property
             if (!con->PropertyName().length()) {
                 continue;
             }
 
-            const Object* const ob = con->SourceObject();
-            if(!ob) {
-                DOMWarning("failed to read source object for AnimationCurve->AnimationCurveNode link, ignoring",&element);
+            const Object *const ob = con->SourceObject();
+            if (nullptr == ob) {
+                DOMWarning("failed to read source object for AnimationCurve->AnimationCurveNode link, ignoring", &element);
                 continue;
             }
 
-            const AnimationCurve* const anim = dynamic_cast<const AnimationCurve*>(ob);
-            if(!anim) {
-                DOMWarning("source object for ->AnimationCurveNode link is not an AnimationCurve",&element);
+            const AnimationCurve *const anim = dynamic_cast<const AnimationCurve *>(ob);
+            if (nullptr == anim) {
+                DOMWarning("source object for ->AnimationCurveNode link is not an AnimationCurve", &element);
                 continue;
             }
 
@@ -194,53 +185,49 @@ const AnimationCurveMap& AnimationCurveNode::Curves() const
 }
 
 // ------------------------------------------------------------------------------------------------
-AnimationLayer::AnimationLayer(uint64_t id, const Element& element, const std::string& name, const Document& doc)
-: Object(id, element, name)
-, doc(doc)
-{
-    const Scope& sc = GetRequiredScope(element);
+AnimationLayer::AnimationLayer(uint64_t id, const Element &element, const std::string &name, const Document &doc) :
+        Object(id, element, name), doc(doc) {
+    const Scope &sc = GetRequiredScope(element);
 
     // note: the props table here bears little importance and is usually absent
-    props = GetPropertyTable(doc,"AnimationLayer.FbxAnimLayer",element,sc, true);
+    props = GetPropertyTable(doc, "AnimationLayer.FbxAnimLayer", element, sc, true);
 }
 
 // ------------------------------------------------------------------------------------------------
-AnimationLayer::~AnimationLayer()
-{
+AnimationLayer::~AnimationLayer() {
     // empty
 }
 
 // ------------------------------------------------------------------------------------------------
-AnimationCurveNodeList AnimationLayer::Nodes(const char* const * target_prop_whitelist /*= NULL*/,
-    size_t whitelist_size /*= 0*/) const
-{
+AnimationCurveNodeList AnimationLayer::Nodes(const char *const *target_prop_whitelist /*= nullptr*/,
+        size_t whitelist_size /*= 0*/) const {
     AnimationCurveNodeList nodes;
 
     // resolve attached animation nodes
-    const std::vector<const Connection*>& conns = doc.GetConnectionsByDestinationSequenced(ID(),"AnimationCurveNode");
+    const std::vector<const Connection *> &conns = doc.GetConnectionsByDestinationSequenced(ID(), "AnimationCurveNode");
     nodes.reserve(conns.size());
 
-    for(const Connection* con : conns) {
+    for (const Connection *con : conns) {
 
         // link should not go to a property
         if (con->PropertyName().length()) {
             continue;
         }
 
-        const Object* const ob = con->SourceObject();
-        if(!ob) {
-            DOMWarning("failed to read source object for AnimationCurveNode->AnimationLayer link, ignoring",&element);
+        const Object *const ob = con->SourceObject();
+        if (!ob) {
+            DOMWarning("failed to read source object for AnimationCurveNode->AnimationLayer link, ignoring", &element);
             continue;
         }
 
-        const AnimationCurveNode* const anim = dynamic_cast<const AnimationCurveNode*>(ob);
-        if(!anim) {
-            DOMWarning("source object for ->AnimationLayer link is not an AnimationCurveNode",&element);
+        const AnimationCurveNode *const anim = dynamic_cast<const AnimationCurveNode *>(ob);
+        if (!anim) {
+            DOMWarning("source object for ->AnimationLayer link is not an AnimationCurveNode", &element);
             continue;
         }
 
-        if(target_prop_whitelist) {
-            const char* s = anim->TargetProperty().c_str();
+        if (target_prop_whitelist) {
+            const char *s = anim->TargetProperty().c_str();
             bool ok = false;
             for (size_t i = 0; i < whitelist_size; ++i) {
                 if (!strcmp(s, target_prop_whitelist[i])) {
@@ -248,7 +235,7 @@ AnimationCurveNodeList AnimationLayer::Nodes(const char* const * target_prop_whi
                     break;
                 }
             }
-            if(!ok) {
+            if (!ok) {
                 continue;
             }
         }
@@ -259,34 +246,33 @@ AnimationCurveNodeList AnimationLayer::Nodes(const char* const * target_prop_whi
 }
 
 // ------------------------------------------------------------------------------------------------
-AnimationStack::AnimationStack(uint64_t id, const Element& element, const std::string& name, const Document& doc)
-: Object(id, element, name)
-{
-    const Scope& sc = GetRequiredScope(element);
+AnimationStack::AnimationStack(uint64_t id, const Element &element, const std::string &name, const Document &doc) :
+        Object(id, element, name) {
+    const Scope &sc = GetRequiredScope(element);
 
     // note: we don't currently use any of these properties so we shouldn't bother if it is missing
-    props = GetPropertyTable(doc,"AnimationStack.FbxAnimStack",element,sc, true);
+    props = GetPropertyTable(doc, "AnimationStack.FbxAnimStack", element, sc, true);
 
     // resolve attached animation layers
-    const std::vector<const Connection*>& conns = doc.GetConnectionsByDestinationSequenced(ID(),"AnimationLayer");
+    const std::vector<const Connection *> &conns = doc.GetConnectionsByDestinationSequenced(ID(), "AnimationLayer");
     layers.reserve(conns.size());
 
-    for(const Connection* con : conns) {
+    for (const Connection *con : conns) {
 
         // link should not go to a property
         if (con->PropertyName().length()) {
             continue;
         }
 
-        const Object* const ob = con->SourceObject();
-        if(!ob) {
-            DOMWarning("failed to read source object for AnimationLayer->AnimationStack link, ignoring",&element);
+        const Object *const ob = con->SourceObject();
+        if (!ob) {
+            DOMWarning("failed to read source object for AnimationLayer->AnimationStack link, ignoring", &element);
             continue;
         }
 
-        const AnimationLayer* const anim = dynamic_cast<const AnimationLayer*>(ob);
-        if(!anim) {
-            DOMWarning("source object for ->AnimationStack link is not an AnimationLayer",&element);
+        const AnimationLayer *const anim = dynamic_cast<const AnimationLayer *>(ob);
+        if (!anim) {
+            DOMWarning("source object for ->AnimationStack link is not an AnimationLayer", &element);
             continue;
         }
         layers.push_back(anim);
@@ -294,12 +280,11 @@ AnimationStack::AnimationStack(uint64_t id, const Element& element, const std::s
 }
 
 // ------------------------------------------------------------------------------------------------
-AnimationStack::~AnimationStack()
-{
+AnimationStack::~AnimationStack() {
     // empty
 }
 
-} //!FBX
-} //!Assimp
+} // namespace FBX
+} // namespace Assimp
 
 #endif // ASSIMP_BUILD_NO_FBX_IMPORTER
diff --git a/Engine/lib/assimp/code/FBX/FBXBinaryTokenizer.cpp b/Engine/lib/assimp/code/AssetLib/FBX/FBXBinaryTokenizer.cpp
similarity index 94%
rename from Engine/lib/assimp/code/FBX/FBXBinaryTokenizer.cpp
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXBinaryTokenizer.cpp
index a4a2bc8e7..1a4d11856 100644
--- a/Engine/lib/assimp/code/FBX/FBXBinaryTokenizer.cpp
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXBinaryTokenizer.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -53,6 +53,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <stdint.h>
 #include <assimp/Exceptional.h>
 #include <assimp/ByteSwapper.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/StringUtils.h>
 
 namespace Assimp {
 namespace FBX {
@@ -125,7 +127,7 @@ namespace {
 AI_WONT_RETURN void TokenizeError(const std::string& message, size_t offset) AI_WONT_RETURN_SUFFIX;
 AI_WONT_RETURN void TokenizeError(const std::string& message, size_t offset)
 {
-    throw DeadlyImportError(Util::AddOffset("FBX-Tokenize",message,offset));
+    throw DeadlyImportError("FBX-Tokenize", Util::GetOffsetText(offset), message);
 }
 
 
@@ -373,6 +375,11 @@ bool ReadScope(TokenList& output_tokens, const char* input, const char*& cursor,
 
     // now come the individual properties
     const char* begin_cursor = cursor;
+
+    if ((begin_cursor + prop_length) > end) {
+        TokenizeError("property length out of bounds reading length ", input, cursor);
+    }
+
     for (unsigned int i = 0; i < prop_count; ++i) {
         ReadData(sbeg, send, input, cursor, begin_cursor + prop_length);
 
@@ -426,7 +433,8 @@ bool ReadScope(TokenList& output_tokens, const char* input, const char*& cursor,
 // TODO: Test FBX Binary files newer than the 7500 version to check if the 64 bits address behaviour is consistent
 void TokenizeBinary(TokenList& output_tokens, const char* input, size_t length)
 {
-    ai_assert(input);
+	ai_assert(input);
+	ASSIMP_LOG_DEBUG("Tokenizing binary FBX file");
 
     if(length < 0x1b) {
         TokenizeError("file is too short",0);
@@ -451,13 +459,24 @@ void TokenizeBinary(TokenList& output_tokens, const char* input, size_t length)
 	/*Result ignored*/ ReadByte(input, cursor, input + length);
 	/*Result ignored*/ ReadByte(input, cursor, input + length);
 	const uint32_t version = ReadWord(input, cursor, input + length);
+	ASSIMP_LOG_DEBUG("FBX version: ", version);
 	const bool is64bits = version >= 7500;
     const char *end = input + length;
-    while (cursor < end ) {
-		if (!ReadScope(output_tokens, input, cursor, input + length, is64bits)) {
-            break;
+    try
+    {
+        while (cursor < end ) {
+		    if (!ReadScope(output_tokens, input, cursor, input + length, is64bits)) {
+                break;
+            }
         }
     }
+    catch (const DeadlyImportError& e)
+    {
+        if (!is64bits && (length > std::numeric_limits<std::uint32_t>::max())) {
+            throw DeadlyImportError("The FBX file is invalid. This may be because the content is too big for this older version (", ai_to_string(version), ") of the FBX format. (", e.what(), ")");
+        }
+        throw;
+    }
 }
 
 } // !FBX
diff --git a/Engine/lib/assimp/code/FBX/FBXCommon.h b/Engine/lib/assimp/code/AssetLib/FBX/FBXCommon.h
similarity index 61%
rename from Engine/lib/assimp/code/FBX/FBXCommon.h
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXCommon.h
index e51644913..ec7459c9e 100644
--- a/Engine/lib/assimp/code/FBX/FBXCommon.h
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXCommon.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -48,39 +48,42 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_FBX_EXPORTER
 
 namespace Assimp {
-namespace FBX
-{
-    const std::string NULL_RECORD = { // 13 null bytes
-        '\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0'
-    }; // who knows why
-    const std::string SEPARATOR = {'\x00', '\x01'}; // for use inside strings
-    const std::string MAGIC_NODE_TAG = "_$AssimpFbx$"; // from import
-    const int64_t SECOND = 46186158000; // FBX's kTime unit
+namespace FBX {
 
-    // rotation order. We'll probably use EulerXYZ for everything
-    enum RotOrder {
-        RotOrder_EulerXYZ = 0,
-        RotOrder_EulerXZY,
-        RotOrder_EulerYZX,
-        RotOrder_EulerYXZ,
-        RotOrder_EulerZXY,
-        RotOrder_EulerZYX,
+const std::string NULL_RECORD = { // 25 null bytes in 64-bit and 13 null bytes in 32-bit
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0'
+}; // who knows why, it looks like two integers 32/64 bit (compressed and uncompressed sizes?) + 1 byte (might be compression type?)
+const std::string SEPARATOR = { '\x00', '\x01' }; // for use inside strings
+const std::string MAGIC_NODE_TAG = "_$AssimpFbx$"; // from import
+const int64_t SECOND = 46186158000; // FBX's kTime unit
 
-        RotOrder_SphericXYZ,
+// rotation order. We'll probably use EulerXYZ for everything
+enum RotOrder {
+    RotOrder_EulerXYZ = 0,
+    RotOrder_EulerXZY,
+    RotOrder_EulerYZX,
+    RotOrder_EulerYXZ,
+    RotOrder_EulerZXY,
+    RotOrder_EulerZYX,
 
-        RotOrder_MAX // end-of-enum sentinel
-    };
+    RotOrder_SphericXYZ,
 
-    // transformation inheritance method. Most of the time RSrs
-    enum TransformInheritance {
-        TransformInheritance_RrSs = 0,
-        TransformInheritance_RSrs,
-        TransformInheritance_Rrs,
+    RotOrder_MAX // end-of-enum sentinel
+};
+
+// transformation inheritance method. Most of the time RSrs
+enum TransformInheritance {
+    TransformInheritance_RrSs = 0,
+    TransformInheritance_RSrs,
+    TransformInheritance_Rrs,
+
+    TransformInheritance_MAX // end-of-enum sentinel
+};
+
+} // namespace FBX
+} // namespace Assimp
 
-        TransformInheritance_MAX // end-of-enum sentinel
-    };
-}
-}
 #endif // ASSIMP_BUILD_NO_FBX_EXPORTER
 
 #endif // AI_FBXCOMMON_H_INC
diff --git a/Engine/lib/assimp/code/FBX/FBXCompileConfig.h b/Engine/lib/assimp/code/AssetLib/FBX/FBXCompileConfig.h
similarity index 85%
rename from Engine/lib/assimp/code/FBX/FBXCompileConfig.h
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXCompileConfig.h
index 3a3841fa5..75787d303 100644
--- a/Engine/lib/assimp/code/FBX/FBXCompileConfig.h
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXCompileConfig.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -47,6 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define INCLUDED_AI_FBX_COMPILECONFIG_H
 
 #include <map>
+#include <set>
 
 //
 #if _MSC_VER > 1500 || (defined __GNUC___)
@@ -54,16 +55,23 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #   else
 #   define fbx_unordered_map map
 #   define fbx_unordered_multimap multimap
+#   define fbx_unordered_set set
+#   define fbx_unordered_multiset multiset
 #endif
 
 #ifdef ASSIMP_FBX_USE_UNORDERED_MULTIMAP
 #   include <unordered_map>
-#   if _MSC_VER > 1600
-#       define fbx_unordered_map unordered_map
-#       define fbx_unordered_multimap unordered_multimap
-#   else
+#   include <unordered_set>
+#   if defined(_MSC_VER) && _MSC_VER <= 1600
 #       define fbx_unordered_map tr1::unordered_map
 #       define fbx_unordered_multimap tr1::unordered_multimap
+#       define fbx_unordered_set tr1::unordered_set
+#       define fbx_unordered_multiset tr1::unordered_multiset
+#   else
+#       define fbx_unordered_map unordered_map
+#       define fbx_unordered_multimap unordered_multimap
+#       define fbx_unordered_set unordered_set
+#       define fbx_unordered_multiset unordered_multiset
 #   endif
 #endif
 
diff --git a/Engine/lib/assimp/code/AssetLib/FBX/FBXConverter.cpp b/Engine/lib/assimp/code/AssetLib/FBX/FBXConverter.cpp
new file mode 100644
index 000000000..32872108b
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXConverter.cpp
@@ -0,0 +1,3679 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file  FBXConverter.cpp
+ *  @brief Implementation of the FBX DOM -> aiScene converter
+ */
+
+#ifndef ASSIMP_BUILD_NO_FBX_IMPORTER
+
+#include "FBXConverter.h"
+#include "FBXDocument.h"
+#include "FBXImporter.h"
+#include "FBXMeshGeometry.h"
+#include "FBXParser.h"
+#include "FBXProperties.h"
+#include "FBXUtil.h"
+
+#include <assimp/MathFunctions.h>
+#include <assimp/StringComparison.h>
+
+#include <assimp/scene.h>
+
+#include <assimp/CreateAnimMesh.h>
+#include <assimp/StringUtils.h>
+#include <assimp/commonMetaData.h>
+
+#include <stdlib.h>
+#include <cstdint>
+#include <iomanip>
+#include <iostream>
+#include <iterator>
+#include <memory>
+#include <sstream>
+#include <tuple>
+#include <vector>
+
+namespace Assimp {
+namespace FBX {
+
+using namespace Util;
+
+#define MAGIC_NODE_TAG "_$AssimpFbx$"
+
+#define CONVERT_FBX_TIME(time) static_cast<double>(time) / 46186158000LL
+
+FBXConverter::FBXConverter(aiScene *out, const Document &doc, bool removeEmptyBones) :
+        defaultMaterialIndex(),
+        mMeshes(),
+        lights(),
+        cameras(),
+        textures(),
+        materials_converted(),
+        textures_converted(),
+        meshes_converted(),
+        node_anim_chain_bits(),
+        mNodeNames(),
+        anim_fps(),
+        mSceneOut(out),
+        doc(doc),
+        mRemoveEmptyBones(removeEmptyBones) {
+    // animations need to be converted first since this will
+    // populate the node_anim_chain_bits map, which is needed
+    // to determine which nodes need to be generated.
+    ConvertAnimations();
+    // Embedded textures in FBX could be connected to nothing but to itself,
+    // for instance Texture -> Video connection only but not to the main graph,
+    // The idea here is to traverse all objects to find these Textures and convert them,
+    // so later during material conversion it will find converted texture in the textures_converted array.
+    if (doc.Settings().readTextures) {
+        ConvertOrphanedEmbeddedTextures();
+    }
+    ConvertRootNode();
+
+    if (doc.Settings().readAllMaterials) {
+        // unfortunately this means we have to evaluate all objects
+        for (const ObjectMap::value_type &v : doc.Objects()) {
+
+            const Object *ob = v.second->Get();
+            if (!ob) {
+                continue;
+            }
+
+            const Material *mat = dynamic_cast<const Material *>(ob);
+            if (mat) {
+
+                if (materials_converted.find(mat) == materials_converted.end()) {
+                    ConvertMaterial(*mat, 0);
+                }
+            }
+        }
+    }
+
+    ConvertGlobalSettings();
+    TransferDataToScene();
+
+    // if we didn't read any meshes set the AI_SCENE_FLAGS_INCOMPLETE
+    // to make sure the scene passes assimp's validation. FBX files
+    // need not contain geometry (i.e. camera animations, raw armatures).
+    if (out->mNumMeshes == 0) {
+        out->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
+    }
+}
+
+FBXConverter::~FBXConverter() {
+    std::for_each(mMeshes.begin(), mMeshes.end(), Util::delete_fun<aiMesh>());
+    std::for_each(materials.begin(), materials.end(), Util::delete_fun<aiMaterial>());
+    std::for_each(animations.begin(), animations.end(), Util::delete_fun<aiAnimation>());
+    std::for_each(lights.begin(), lights.end(), Util::delete_fun<aiLight>());
+    std::for_each(cameras.begin(), cameras.end(), Util::delete_fun<aiCamera>());
+    std::for_each(textures.begin(), textures.end(), Util::delete_fun<aiTexture>());
+}
+
+void FBXConverter::ConvertRootNode() {
+    mSceneOut->mRootNode = new aiNode();
+    std::string unique_name;
+    GetUniqueName("RootNode", unique_name);
+    mSceneOut->mRootNode->mName.Set(unique_name);
+
+    // root has ID 0
+    ConvertNodes(0L, mSceneOut->mRootNode, mSceneOut->mRootNode);
+}
+
+static std::string getAncestorBaseName(const aiNode *node) {
+    const char *nodeName = nullptr;
+    size_t length = 0;
+    while (node && (!nodeName || length == 0)) {
+        nodeName = node->mName.C_Str();
+        length = node->mName.length;
+        node = node->mParent;
+    }
+
+    if (!nodeName || length == 0) {
+        return {};
+    }
+    // could be std::string_view if c++17 available
+    return std::string(nodeName, length);
+}
+
+// Make unique name
+std::string FBXConverter::MakeUniqueNodeName(const Model *const model, const aiNode &parent) {
+    std::string original_name = FixNodeName(model->Name());
+    if (original_name.empty()) {
+        original_name = getAncestorBaseName(&parent);
+    }
+    std::string unique_name;
+    GetUniqueName(original_name, unique_name);
+    return unique_name;
+}
+
+/// This struct manages nodes which may or may not end up in the node hierarchy.
+/// When a node becomes a child of another node, that node becomes its owner and mOwnership should be released.
+struct FBXConverter::PotentialNode
+{
+    PotentialNode() : mOwnership(new aiNode), mNode(mOwnership.get()) {}
+    PotentialNode(const std::string& name) : mOwnership(new aiNode(name)), mNode(mOwnership.get()) {}
+    aiNode* operator->() { return mNode; }
+    std::unique_ptr<aiNode> mOwnership;
+    aiNode* mNode;
+};
+
+/// todo: pre-build node hierarchy
+/// todo: get bone from stack
+/// todo: make map of aiBone* to aiNode*
+/// then update convert clusters to the new format
+void FBXConverter::ConvertNodes(uint64_t id, aiNode *parent, aiNode *root_node) {
+    const std::vector<const Connection *> &conns = doc.GetConnectionsByDestinationSequenced(id, "Model");
+
+    std::vector<PotentialNode> nodes;
+    nodes.reserve(conns.size());
+
+    std::vector<PotentialNode> nodes_chain;
+    std::vector<PotentialNode> post_nodes_chain;
+
+    for (const Connection *con : conns) {
+        // ignore object-property links
+        if (con->PropertyName().length()) {
+            // really important we document why this is ignored.
+            FBXImporter::LogInfo("ignoring property link - no docs on why this is ignored");
+            continue; //?
+        }
+
+        // convert connection source object into Object base class
+        const Object *const object = con->SourceObject();
+        if (nullptr == object) {
+            FBXImporter::LogError("failed to convert source object for Model link");
+            continue;
+        }
+
+        // FBX Model::Cube, Model::Bone001, etc elements
+        // This detects if we can cast the object into this model structure.
+        const Model *const model = dynamic_cast<const Model *>(object);
+
+        if (nullptr != model) {
+            nodes_chain.clear();
+            post_nodes_chain.clear();
+
+            aiMatrix4x4 new_abs_transform = parent->mTransformation;
+            std::string node_name = FixNodeName(model->Name());
+            // even though there is only a single input node, the design of
+            // assimp (or rather: the complicated transformation chain that
+            // is employed by fbx) means that we may need multiple aiNode's
+            // to represent a fbx node's transformation.
+
+            // generate node transforms - this includes pivot data
+            // if need_additional_node is true then you t
+            const bool need_additional_node = GenerateTransformationNodeChain(*model, node_name, nodes_chain, post_nodes_chain);
+
+            // assert that for the current node we must have at least a single transform
+            ai_assert(nodes_chain.size());
+
+            if (need_additional_node) {
+                nodes_chain.emplace_back(PotentialNode(node_name));
+            }
+
+            //setup metadata on newest node
+            SetupNodeMetadata(*model, *nodes_chain.back().mNode);
+
+            // link all nodes in a row
+            aiNode *last_parent = parent;
+            for (PotentialNode& child : nodes_chain) {
+                ai_assert(child.mNode);
+
+                if (last_parent != parent) {
+                    last_parent->mNumChildren = 1;
+                    last_parent->mChildren = new aiNode *[1];
+                    last_parent->mChildren[0] = child.mOwnership.release();
+                }
+
+                child->mParent = last_parent;
+                last_parent = child.mNode;
+
+                new_abs_transform *= child->mTransformation;
+            }
+
+            // attach geometry
+            ConvertModel(*model, nodes_chain.back().mNode, root_node, new_abs_transform);
+
+            // check if there will be any child nodes
+            const std::vector<const Connection *> &child_conns = doc.GetConnectionsByDestinationSequenced(model->ID(), "Model");
+
+            // if so, link the geometric transform inverse nodes
+            // before we attach any child nodes
+            if (child_conns.size()) {
+                for (PotentialNode& postnode : post_nodes_chain) {
+                    ai_assert(postnode.mNode);
+
+                    if (last_parent != parent) {
+                        last_parent->mNumChildren = 1;
+                        last_parent->mChildren = new aiNode *[1];
+                        last_parent->mChildren[0] = postnode.mOwnership.release();
+                    }
+
+                    postnode->mParent = last_parent;
+                    last_parent = postnode.mNode;
+
+                    new_abs_transform *= postnode->mTransformation;
+                }
+            } else {
+                // free the nodes we allocated as we don't need them
+                post_nodes_chain.clear();
+            }
+
+            // recursion call - child nodes
+            ConvertNodes(model->ID(), last_parent, root_node);
+
+            if (doc.Settings().readLights) {
+                ConvertLights(*model, node_name);
+            }
+
+            if (doc.Settings().readCameras) {
+                ConvertCameras(*model, node_name);
+            }
+
+            nodes.push_back(std::move(nodes_chain.front()));
+            nodes_chain.clear();
+        }
+    }
+
+    if (nodes.size()) {
+        parent->mChildren = new aiNode *[nodes.size()]();
+        parent->mNumChildren = static_cast<unsigned int>(nodes.size());
+
+        for (unsigned int i = 0; i < nodes.size(); ++i)
+        {
+            parent->mChildren[i] = nodes[i].mOwnership.release();
+        }
+        nodes.clear();
+    } else {
+        parent->mNumChildren = 0;
+        parent->mChildren = nullptr;
+    }
+}
+
+void FBXConverter::ConvertLights(const Model &model, const std::string &orig_name) {
+    const std::vector<const NodeAttribute *> &node_attrs = model.GetAttributes();
+    for (const NodeAttribute *attr : node_attrs) {
+        const Light *const light = dynamic_cast<const Light *>(attr);
+        if (light) {
+            ConvertLight(*light, orig_name);
+        }
+    }
+}
+
+void FBXConverter::ConvertCameras(const Model &model, const std::string &orig_name) {
+    const std::vector<const NodeAttribute *> &node_attrs = model.GetAttributes();
+    for (const NodeAttribute *attr : node_attrs) {
+        const Camera *const cam = dynamic_cast<const Camera *>(attr);
+        if (cam) {
+            ConvertCamera(*cam, orig_name);
+        }
+    }
+}
+
+void FBXConverter::ConvertLight(const Light &light, const std::string &orig_name) {
+    lights.push_back(new aiLight());
+    aiLight *const out_light = lights.back();
+
+    out_light->mName.Set(orig_name);
+
+    const float intensity = light.Intensity() / 100.0f;
+    const aiVector3D &col = light.Color();
+
+    out_light->mColorDiffuse = aiColor3D(col.x, col.y, col.z);
+    out_light->mColorDiffuse.r *= intensity;
+    out_light->mColorDiffuse.g *= intensity;
+    out_light->mColorDiffuse.b *= intensity;
+
+    out_light->mColorSpecular = out_light->mColorDiffuse;
+
+    //lights are defined along negative y direction
+    out_light->mPosition = aiVector3D(0.0f);
+    out_light->mDirection = aiVector3D(0.0f, -1.0f, 0.0f);
+    out_light->mUp = aiVector3D(0.0f, 0.0f, -1.0f);
+
+    switch (light.LightType()) {
+        case Light::Type_Point:
+            out_light->mType = aiLightSource_POINT;
+            break;
+
+        case Light::Type_Directional:
+            out_light->mType = aiLightSource_DIRECTIONAL;
+            break;
+
+        case Light::Type_Spot:
+            out_light->mType = aiLightSource_SPOT;
+            out_light->mAngleOuterCone = AI_DEG_TO_RAD(light.OuterAngle());
+            out_light->mAngleInnerCone = AI_DEG_TO_RAD(light.InnerAngle());
+            break;
+
+        case Light::Type_Area:
+            FBXImporter::LogWarn("cannot represent area light, set to UNDEFINED");
+            out_light->mType = aiLightSource_UNDEFINED;
+            break;
+
+        case Light::Type_Volume:
+            FBXImporter::LogWarn("cannot represent volume light, set to UNDEFINED");
+            out_light->mType = aiLightSource_UNDEFINED;
+            break;
+        default:
+            ai_assert(false);
+    }
+
+    float decay = light.DecayStart();
+    switch (light.DecayType()) {
+        case Light::Decay_None:
+            out_light->mAttenuationConstant = decay;
+            out_light->mAttenuationLinear = 0.0f;
+            out_light->mAttenuationQuadratic = 0.0f;
+            break;
+        case Light::Decay_Linear:
+            out_light->mAttenuationConstant = 0.0f;
+            out_light->mAttenuationLinear = 2.0f / decay;
+            out_light->mAttenuationQuadratic = 0.0f;
+            break;
+        case Light::Decay_Quadratic:
+            out_light->mAttenuationConstant = 0.0f;
+            out_light->mAttenuationLinear = 0.0f;
+            out_light->mAttenuationQuadratic = 2.0f / (decay * decay);
+            break;
+        case Light::Decay_Cubic:
+            FBXImporter::LogWarn("cannot represent cubic attenuation, set to Quadratic");
+            out_light->mAttenuationQuadratic = 1.0f;
+            break;
+        default:
+            ai_assert(false);
+            break;
+    }
+}
+
+void FBXConverter::ConvertCamera(const Camera &cam, const std::string &orig_name) {
+    cameras.push_back(new aiCamera());
+    aiCamera *const out_camera = cameras.back();
+
+    out_camera->mName.Set(orig_name);
+
+    out_camera->mAspect = cam.AspectWidth() / cam.AspectHeight();
+
+    out_camera->mPosition = aiVector3D(0.0f);
+    out_camera->mLookAt = aiVector3D(1.0f, 0.0f, 0.0f);
+    out_camera->mUp = aiVector3D(0.0f, 1.0f, 0.0f);
+
+    out_camera->mHorizontalFOV = AI_DEG_TO_RAD(cam.FieldOfView());
+
+    out_camera->mClipPlaneNear = cam.NearPlane();
+    out_camera->mClipPlaneFar = cam.FarPlane();
+
+    out_camera->mHorizontalFOV = AI_DEG_TO_RAD(cam.FieldOfView());
+    out_camera->mClipPlaneNear = cam.NearPlane();
+    out_camera->mClipPlaneFar = cam.FarPlane();
+}
+
+void FBXConverter::GetUniqueName(const std::string &name, std::string &uniqueName) {
+    uniqueName = name;
+    auto it_pair = mNodeNames.insert({ name, 0 }); // duplicate node name instance count
+    unsigned int &i = it_pair.first->second;
+    while (!it_pair.second) {
+        i++;
+        std::ostringstream ext;
+        ext << name << std::setfill('0') << std::setw(3) << i;
+        uniqueName = ext.str();
+        it_pair = mNodeNames.insert({ uniqueName, 0 });
+    }
+}
+
+const char *FBXConverter::NameTransformationComp(TransformationComp comp) {
+    switch (comp) {
+        case TransformationComp_Translation:
+            return "Translation";
+        case TransformationComp_RotationOffset:
+            return "RotationOffset";
+        case TransformationComp_RotationPivot:
+            return "RotationPivot";
+        case TransformationComp_PreRotation:
+            return "PreRotation";
+        case TransformationComp_Rotation:
+            return "Rotation";
+        case TransformationComp_PostRotation:
+            return "PostRotation";
+        case TransformationComp_RotationPivotInverse:
+            return "RotationPivotInverse";
+        case TransformationComp_ScalingOffset:
+            return "ScalingOffset";
+        case TransformationComp_ScalingPivot:
+            return "ScalingPivot";
+        case TransformationComp_Scaling:
+            return "Scaling";
+        case TransformationComp_ScalingPivotInverse:
+            return "ScalingPivotInverse";
+        case TransformationComp_GeometricScaling:
+            return "GeometricScaling";
+        case TransformationComp_GeometricRotation:
+            return "GeometricRotation";
+        case TransformationComp_GeometricTranslation:
+            return "GeometricTranslation";
+        case TransformationComp_GeometricScalingInverse:
+            return "GeometricScalingInverse";
+        case TransformationComp_GeometricRotationInverse:
+            return "GeometricRotationInverse";
+        case TransformationComp_GeometricTranslationInverse:
+            return "GeometricTranslationInverse";
+        case TransformationComp_MAXIMUM: // this is to silence compiler warnings
+        default:
+            break;
+    }
+
+    ai_assert(false);
+
+    return nullptr;
+}
+
+const char *FBXConverter::NameTransformationCompProperty(TransformationComp comp) {
+    switch (comp) {
+        case TransformationComp_Translation:
+            return "Lcl Translation";
+        case TransformationComp_RotationOffset:
+            return "RotationOffset";
+        case TransformationComp_RotationPivot:
+            return "RotationPivot";
+        case TransformationComp_PreRotation:
+            return "PreRotation";
+        case TransformationComp_Rotation:
+            return "Lcl Rotation";
+        case TransformationComp_PostRotation:
+            return "PostRotation";
+        case TransformationComp_RotationPivotInverse:
+            return "RotationPivotInverse";
+        case TransformationComp_ScalingOffset:
+            return "ScalingOffset";
+        case TransformationComp_ScalingPivot:
+            return "ScalingPivot";
+        case TransformationComp_Scaling:
+            return "Lcl Scaling";
+        case TransformationComp_ScalingPivotInverse:
+            return "ScalingPivotInverse";
+        case TransformationComp_GeometricScaling:
+            return "GeometricScaling";
+        case TransformationComp_GeometricRotation:
+            return "GeometricRotation";
+        case TransformationComp_GeometricTranslation:
+            return "GeometricTranslation";
+        case TransformationComp_GeometricScalingInverse:
+            return "GeometricScalingInverse";
+        case TransformationComp_GeometricRotationInverse:
+            return "GeometricRotationInverse";
+        case TransformationComp_GeometricTranslationInverse:
+            return "GeometricTranslationInverse";
+        case TransformationComp_MAXIMUM: // this is to silence compiler warnings
+            break;
+    }
+
+    ai_assert(false);
+
+    return nullptr;
+}
+
+aiVector3D FBXConverter::TransformationCompDefaultValue(TransformationComp comp) {
+    // XXX a neat way to solve the never-ending special cases for scaling
+    // would be to do everything in log space!
+    return comp == TransformationComp_Scaling ? aiVector3D(1.f, 1.f, 1.f) : aiVector3D();
+}
+
+void FBXConverter::GetRotationMatrix(Model::RotOrder mode, const aiVector3D &rotation, aiMatrix4x4 &out) {
+    if (mode == Model::RotOrder_SphericXYZ) {
+        FBXImporter::LogError("Unsupported RotationMode: SphericXYZ");
+        out = aiMatrix4x4();
+        return;
+    }
+
+    const float angle_epsilon = Math::getEpsilon<float>();
+
+    out = aiMatrix4x4();
+
+    bool is_id[3] = { true, true, true };
+
+    aiMatrix4x4 temp[3];
+    if (std::fabs(rotation.z) > angle_epsilon) {
+        aiMatrix4x4::RotationZ(AI_DEG_TO_RAD(rotation.z), temp[2]);
+        is_id[2] = false;
+    }
+    if (std::fabs(rotation.y) > angle_epsilon) {
+        aiMatrix4x4::RotationY(AI_DEG_TO_RAD(rotation.y), temp[1]);
+        is_id[1] = false;
+    }
+    if (std::fabs(rotation.x) > angle_epsilon) {
+        aiMatrix4x4::RotationX(AI_DEG_TO_RAD(rotation.x), temp[0]);
+        is_id[0] = false;
+    }
+
+    int order[3] = { -1, -1, -1 };
+
+    // note: rotation order is inverted since we're left multiplying as is usual in assimp
+    switch (mode) {
+        case Model::RotOrder_EulerXYZ:
+            order[0] = 2;
+            order[1] = 1;
+            order[2] = 0;
+            break;
+
+        case Model::RotOrder_EulerXZY:
+            order[0] = 1;
+            order[1] = 2;
+            order[2] = 0;
+            break;
+
+        case Model::RotOrder_EulerYZX:
+            order[0] = 0;
+            order[1] = 2;
+            order[2] = 1;
+            break;
+
+        case Model::RotOrder_EulerYXZ:
+            order[0] = 2;
+            order[1] = 0;
+            order[2] = 1;
+            break;
+
+        case Model::RotOrder_EulerZXY:
+            order[0] = 1;
+            order[1] = 0;
+            order[2] = 2;
+            break;
+
+        case Model::RotOrder_EulerZYX:
+            order[0] = 0;
+            order[1] = 1;
+            order[2] = 2;
+            break;
+
+        default:
+            ai_assert(false);
+            break;
+    }
+
+    ai_assert(order[0] >= 0);
+    ai_assert(order[0] <= 2);
+    ai_assert(order[1] >= 0);
+    ai_assert(order[1] <= 2);
+    ai_assert(order[2] >= 0);
+    ai_assert(order[2] <= 2);
+
+    if (!is_id[order[0]]) {
+        out = temp[order[0]];
+    }
+
+    if (!is_id[order[1]]) {
+        out = out * temp[order[1]];
+    }
+
+    if (!is_id[order[2]]) {
+        out = out * temp[order[2]];
+    }
+}
+
+bool FBXConverter::NeedsComplexTransformationChain(const Model &model) {
+    const PropertyTable &props = model.Props();
+    bool ok;
+
+    const float zero_epsilon = ai_epsilon;
+    const aiVector3D all_ones(1.0f, 1.0f, 1.0f);
+    for (size_t i = 0; i < TransformationComp_MAXIMUM; ++i) {
+        const TransformationComp comp = static_cast<TransformationComp>(i);
+
+        if (comp == TransformationComp_Rotation || comp == TransformationComp_Scaling || comp == TransformationComp_Translation ||
+            comp == TransformationComp_PreRotation || comp == TransformationComp_PostRotation) {
+            continue;
+        }
+
+        bool scale_compare = (comp == TransformationComp_GeometricScaling || comp == TransformationComp_Scaling);
+
+        const aiVector3D &v = PropertyGet<aiVector3D>(props, NameTransformationCompProperty(comp), ok);
+        if (ok && scale_compare) {
+            if ((v - all_ones).SquareLength() > zero_epsilon) {
+                return true;
+            }
+        } else if (ok) {
+            if (v.SquareLength() > zero_epsilon) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+std::string FBXConverter::NameTransformationChainNode(const std::string &name, TransformationComp comp) {
+    return name + std::string(MAGIC_NODE_TAG) + "_" + NameTransformationComp(comp);
+}
+
+bool FBXConverter::GenerateTransformationNodeChain(const Model &model, const std::string &name, std::vector<PotentialNode> &output_nodes,
+        std::vector<PotentialNode> &post_output_nodes) {
+    const PropertyTable &props = model.Props();
+    const Model::RotOrder rot = model.RotationOrder();
+
+    bool ok;
+
+    aiMatrix4x4 chain[TransformationComp_MAXIMUM];
+
+    ai_assert(TransformationComp_MAXIMUM < 32);
+    std::uint32_t chainBits = 0;
+    // A node won't need a node chain if it only has these.
+    const std::uint32_t chainMaskSimple = (1 << TransformationComp_Translation) + (1 << TransformationComp_Scaling) + (1 << TransformationComp_Rotation);
+    // A node will need a node chain if it has any of these.
+    const std::uint32_t chainMaskComplex = ((1 << (TransformationComp_MAXIMUM)) - 1) - chainMaskSimple;
+
+    std::fill_n(chain, static_cast<unsigned int>(TransformationComp_MAXIMUM), aiMatrix4x4());
+
+    // generate transformation matrices for all the different transformation components
+    const float zero_epsilon = Math::getEpsilon<float>();
+    const aiVector3D all_ones(1.0f, 1.0f, 1.0f);
+
+    const aiVector3D &PreRotation = PropertyGet<aiVector3D>(props, "PreRotation", ok);
+    if (ok && PreRotation.SquareLength() > zero_epsilon) {
+        chainBits = chainBits | (1 << TransformationComp_PreRotation);
+
+        GetRotationMatrix(Model::RotOrder::RotOrder_EulerXYZ, PreRotation, chain[TransformationComp_PreRotation]);
+    }
+
+    const aiVector3D &PostRotation = PropertyGet<aiVector3D>(props, "PostRotation", ok);
+    if (ok && PostRotation.SquareLength() > zero_epsilon) {
+        chainBits = chainBits | (1 << TransformationComp_PostRotation);
+
+        GetRotationMatrix(Model::RotOrder::RotOrder_EulerXYZ, PostRotation, chain[TransformationComp_PostRotation]);
+    }
+
+    const aiVector3D &RotationPivot = PropertyGet<aiVector3D>(props, "RotationPivot", ok);
+    if (ok && RotationPivot.SquareLength() > zero_epsilon) {
+        chainBits = chainBits | (1 << TransformationComp_RotationPivot) | (1 << TransformationComp_RotationPivotInverse);
+
+        aiMatrix4x4::Translation(RotationPivot, chain[TransformationComp_RotationPivot]);
+        aiMatrix4x4::Translation(-RotationPivot, chain[TransformationComp_RotationPivotInverse]);
+    }
+
+    const aiVector3D &RotationOffset = PropertyGet<aiVector3D>(props, "RotationOffset", ok);
+    if (ok && RotationOffset.SquareLength() > zero_epsilon) {
+        chainBits = chainBits | (1 << TransformationComp_RotationOffset);
+
+        aiMatrix4x4::Translation(RotationOffset, chain[TransformationComp_RotationOffset]);
+    }
+
+    const aiVector3D &ScalingOffset = PropertyGet<aiVector3D>(props, "ScalingOffset", ok);
+    if (ok && ScalingOffset.SquareLength() > zero_epsilon) {
+        chainBits = chainBits | (1 << TransformationComp_ScalingOffset);
+
+        aiMatrix4x4::Translation(ScalingOffset, chain[TransformationComp_ScalingOffset]);
+    }
+
+    const aiVector3D &ScalingPivot = PropertyGet<aiVector3D>(props, "ScalingPivot", ok);
+    if (ok && ScalingPivot.SquareLength() > zero_epsilon) {
+        chainBits = chainBits | (1 << TransformationComp_ScalingPivot) | (1 << TransformationComp_ScalingPivotInverse);
+
+        aiMatrix4x4::Translation(ScalingPivot, chain[TransformationComp_ScalingPivot]);
+        aiMatrix4x4::Translation(-ScalingPivot, chain[TransformationComp_ScalingPivotInverse]);
+    }
+
+    const aiVector3D &Translation = PropertyGet<aiVector3D>(props, "Lcl Translation", ok);
+    if (ok && Translation.SquareLength() > zero_epsilon) {
+        chainBits = chainBits | (1 << TransformationComp_Translation);
+
+        aiMatrix4x4::Translation(Translation, chain[TransformationComp_Translation]);
+    }
+
+    const aiVector3D &Scaling = PropertyGet<aiVector3D>(props, "Lcl Scaling", ok);
+    if (ok && (Scaling - all_ones).SquareLength() > zero_epsilon) {
+        chainBits = chainBits | (1 << TransformationComp_Scaling);
+
+        aiMatrix4x4::Scaling(Scaling, chain[TransformationComp_Scaling]);
+    }
+
+    const aiVector3D &Rotation = PropertyGet<aiVector3D>(props, "Lcl Rotation", ok);
+    if (ok && Rotation.SquareLength() > zero_epsilon) {
+        chainBits = chainBits | (1 << TransformationComp_Rotation);
+
+        GetRotationMatrix(rot, Rotation, chain[TransformationComp_Rotation]);
+    }
+
+    const aiVector3D &GeometricScaling = PropertyGet<aiVector3D>(props, "GeometricScaling", ok);
+    if (ok && (GeometricScaling - all_ones).SquareLength() > zero_epsilon) {
+        chainBits = chainBits | (1 << TransformationComp_GeometricScaling);
+        aiMatrix4x4::Scaling(GeometricScaling, chain[TransformationComp_GeometricScaling]);
+        aiVector3D GeometricScalingInverse = GeometricScaling;
+        bool canscale = true;
+        for (unsigned int i = 0; i < 3; ++i) {
+            if (std::fabs(GeometricScalingInverse[i]) > zero_epsilon) {
+                GeometricScalingInverse[i] = 1.0f / GeometricScaling[i];
+            } else {
+                FBXImporter::LogError("cannot invert geometric scaling matrix with a 0.0 scale component");
+                canscale = false;
+                break;
+            }
+        }
+        if (canscale) {
+            chainBits = chainBits | (1 << TransformationComp_GeometricScalingInverse);
+            aiMatrix4x4::Scaling(GeometricScalingInverse, chain[TransformationComp_GeometricScalingInverse]);
+        }
+    }
+
+    const aiVector3D &GeometricRotation = PropertyGet<aiVector3D>(props, "GeometricRotation", ok);
+    if (ok && GeometricRotation.SquareLength() > zero_epsilon) {
+        chainBits = chainBits | (1 << TransformationComp_GeometricRotation) | (1 << TransformationComp_GeometricRotationInverse);
+        GetRotationMatrix(rot, GeometricRotation, chain[TransformationComp_GeometricRotation]);
+        GetRotationMatrix(rot, GeometricRotation, chain[TransformationComp_GeometricRotationInverse]);
+        chain[TransformationComp_GeometricRotationInverse].Inverse();
+    }
+
+    const aiVector3D &GeometricTranslation = PropertyGet<aiVector3D>(props, "GeometricTranslation", ok);
+    if (ok && GeometricTranslation.SquareLength() > zero_epsilon) {
+        chainBits = chainBits | (1 << TransformationComp_GeometricTranslation) | (1 << TransformationComp_GeometricTranslationInverse);
+        aiMatrix4x4::Translation(GeometricTranslation, chain[TransformationComp_GeometricTranslation]);
+        aiMatrix4x4::Translation(-GeometricTranslation, chain[TransformationComp_GeometricTranslationInverse]);
+    }
+
+    // now, if we have more than just Translation, Scaling and Rotation,
+    // we need to generate a full node chain to accommodate for assimp's
+    // lack to express pivots and offsets.
+    if ((chainBits & chainMaskComplex) && doc.Settings().preservePivots) {
+        FBXImporter::LogInfo("generating full transformation chain for node: ", name);
+
+        // query the anim_chain_bits dictionary to find out which chain elements
+        // have associated node animation channels. These can not be dropped
+        // even if they have identity transform in bind pose.
+        NodeAnimBitMap::const_iterator it = node_anim_chain_bits.find(name);
+        const unsigned int anim_chain_bitmask = (it == node_anim_chain_bits.end() ? 0 : (*it).second);
+
+        unsigned int bit = 0x1;
+        for (size_t i = 0; i < TransformationComp_MAXIMUM; ++i, bit <<= 1) {
+            const TransformationComp comp = static_cast<TransformationComp>(i);
+
+            if ((chainBits & bit) == 0 && (anim_chain_bitmask & bit) == 0) {
+                continue;
+            }
+
+            if (comp == TransformationComp_PostRotation) {
+                chain[i] = chain[i].Inverse();
+            }
+
+            PotentialNode nd;
+            nd->mName.Set(NameTransformationChainNode(name, comp));
+            nd->mTransformation = chain[i];
+
+            // geometric inverses go in a post-node chain
+            if (comp == TransformationComp_GeometricScalingInverse ||
+                    comp == TransformationComp_GeometricRotationInverse ||
+                    comp == TransformationComp_GeometricTranslationInverse) {
+                post_output_nodes.emplace_back(std::move(nd));
+            } else {
+                output_nodes.emplace_back(std::move(nd));
+            }
+        }
+
+        ai_assert(output_nodes.size());
+        return true;
+    }
+
+    // else, we can just multiply the matrices together
+    PotentialNode nd;
+
+    // name passed to the method is already unique
+    nd->mName.Set(name);
+    // for (const auto &transform : chain) {
+    // skip inverse chain for no preservePivots
+    for (unsigned int i = TransformationComp_Translation; i < TransformationComp_MAXIMUM; i++) {
+      nd->mTransformation = nd->mTransformation * chain[i];
+    }
+    output_nodes.push_back(std::move(nd));
+    return false;
+}
+
+void FBXConverter::SetupNodeMetadata(const Model &model, aiNode &nd) {
+    const PropertyTable &props = model.Props();
+    DirectPropertyMap unparsedProperties = props.GetUnparsedProperties();
+
+    // create metadata on node
+    const std::size_t numStaticMetaData = 2;
+    aiMetadata *data = aiMetadata::Alloc(static_cast<unsigned int>(unparsedProperties.size() + numStaticMetaData));
+    nd.mMetaData = data;
+    int index = 0;
+
+    // find user defined properties (3ds Max)
+    data->Set(index++, "UserProperties", aiString(PropertyGet<std::string>(props, "UDP3DSMAX", "")));
+    // preserve the info that a node was marked as Null node in the original file.
+    data->Set(index++, "IsNull", model.IsNull() ? true : false);
+
+    // add unparsed properties to the node's metadata
+    for (const DirectPropertyMap::value_type &prop : unparsedProperties) {
+        // Interpret the property as a concrete type
+        if (const TypedProperty<bool> *interpretedBool = prop.second->As<TypedProperty<bool>>()) {
+            data->Set(index++, prop.first, interpretedBool->Value());
+        } else if (const TypedProperty<int> *interpretedInt = prop.second->As<TypedProperty<int>>()) {
+            data->Set(index++, prop.first, interpretedInt->Value());
+        } else if (const TypedProperty<uint64_t> *interpretedUint64 = prop.second->As<TypedProperty<uint64_t>>()) {
+            data->Set(index++, prop.first, interpretedUint64->Value());
+        } else if (const TypedProperty<float> *interpretedFloat = prop.second->As<TypedProperty<float>>()) {
+            data->Set(index++, prop.first, interpretedFloat->Value());
+        } else if (const TypedProperty<std::string> *interpretedString = prop.second->As<TypedProperty<std::string>>()) {
+            data->Set(index++, prop.first, aiString(interpretedString->Value()));
+        } else if (const TypedProperty<aiVector3D> *interpretedVec3 = prop.second->As<TypedProperty<aiVector3D>>()) {
+            data->Set(index++, prop.first, interpretedVec3->Value());
+        } else {
+            ai_assert(false);
+        }
+    }
+}
+
+void FBXConverter::ConvertModel(const Model &model, aiNode *parent, aiNode *root_node,
+        const aiMatrix4x4 &absolute_transform) {
+    const std::vector<const Geometry *> &geos = model.GetGeometry();
+
+    std::vector<unsigned int> meshes;
+    meshes.reserve(geos.size());
+
+    for (const Geometry *geo : geos) {
+
+        const MeshGeometry *const mesh = dynamic_cast<const MeshGeometry *>(geo);
+        const LineGeometry *const line = dynamic_cast<const LineGeometry *>(geo);
+        if (mesh) {
+            const std::vector<unsigned int> &indices = ConvertMesh(*mesh, model, parent, root_node,
+                    absolute_transform);
+            std::copy(indices.begin(), indices.end(), std::back_inserter(meshes));
+        } else if (line) {
+            const std::vector<unsigned int> &indices = ConvertLine(*line, root_node);
+            std::copy(indices.begin(), indices.end(), std::back_inserter(meshes));
+        } else if (geo) {
+            FBXImporter::LogWarn("ignoring unrecognized geometry: ", geo->Name());
+        } else {
+            FBXImporter::LogWarn("skipping null geometry");
+        }
+    }
+
+    if (meshes.size()) {
+        parent->mMeshes = new unsigned int[meshes.size()]();
+        parent->mNumMeshes = static_cast<unsigned int>(meshes.size());
+
+        std::swap_ranges(meshes.begin(), meshes.end(), parent->mMeshes);
+    }
+}
+
+std::vector<unsigned int>
+FBXConverter::ConvertMesh(const MeshGeometry &mesh, const Model &model, aiNode *parent, aiNode *root_node,
+        const aiMatrix4x4 &absolute_transform) {
+    std::vector<unsigned int> temp;
+
+    MeshMap::const_iterator it = meshes_converted.find(&mesh);
+    if (it != meshes_converted.end()) {
+        std::copy((*it).second.begin(), (*it).second.end(), std::back_inserter(temp));
+        return temp;
+    }
+
+    const std::vector<aiVector3D> &vertices = mesh.GetVertices();
+    const std::vector<unsigned int> &faces = mesh.GetFaceIndexCounts();
+    if (vertices.empty() || faces.empty()) {
+        FBXImporter::LogWarn("ignoring empty geometry: ", mesh.Name());
+        return temp;
+    }
+
+    // one material per mesh maps easily to aiMesh. Multiple material
+    // meshes need to be split.
+    const MatIndexArray &mindices = mesh.GetMaterialIndices();
+    if (doc.Settings().readMaterials && !mindices.empty()) {
+        const MatIndexArray::value_type base = mindices[0];
+        for (MatIndexArray::value_type index : mindices) {
+            if (index != base) {
+                return ConvertMeshMultiMaterial(mesh, model, parent, root_node, absolute_transform);
+            }
+        }
+    }
+
+    // faster code-path, just copy the data
+    temp.push_back(ConvertMeshSingleMaterial(mesh, model, absolute_transform, parent, root_node));
+    return temp;
+}
+
+std::vector<unsigned int> FBXConverter::ConvertLine(const LineGeometry &line, aiNode *root_node) {
+    std::vector<unsigned int> temp;
+
+    const std::vector<aiVector3D> &vertices = line.GetVertices();
+    const std::vector<int> &indices = line.GetIndices();
+    if (vertices.empty() || indices.empty()) {
+        FBXImporter::LogWarn("ignoring empty line: ", line.Name());
+        return temp;
+    }
+
+    aiMesh *const out_mesh = SetupEmptyMesh(line, root_node);
+    out_mesh->mPrimitiveTypes |= aiPrimitiveType_LINE;
+
+    // copy vertices
+    out_mesh->mNumVertices = static_cast<unsigned int>(vertices.size());
+    out_mesh->mVertices = new aiVector3D[out_mesh->mNumVertices];
+    std::copy(vertices.begin(), vertices.end(), out_mesh->mVertices);
+
+    //Number of line segments (faces) is "Number of Points - Number of Endpoints"
+    //N.B.: Endpoints in FbxLine are denoted by negative indices.
+    //If such an Index is encountered, add 1 and multiply by -1 to get the real index.
+    unsigned int epcount = 0;
+    for (unsigned i = 0; i < indices.size(); i++) {
+        if (indices[i] < 0) {
+            epcount++;
+        }
+    }
+    unsigned int pcount = static_cast<unsigned int>(indices.size());
+    unsigned int scount = out_mesh->mNumFaces = pcount - epcount;
+
+    aiFace *fac = out_mesh->mFaces = new aiFace[scount]();
+    for (unsigned int i = 0; i < pcount; ++i) {
+        if (indices[i] < 0) continue;
+        aiFace &f = *fac++;
+        f.mNumIndices = 2; //2 == aiPrimitiveType_LINE
+        f.mIndices = new unsigned int[2];
+        f.mIndices[0] = indices[i];
+        int segid = indices[(i + 1 == pcount ? 0 : i + 1)]; //If we have reached he last point, wrap around
+        f.mIndices[1] = (segid < 0 ? (segid + 1) * -1 : segid); //Convert EndPoint Index to normal Index
+    }
+    temp.push_back(static_cast<unsigned int>(mMeshes.size() - 1));
+    return temp;
+}
+
+aiMesh *FBXConverter::SetupEmptyMesh(const Geometry &mesh, aiNode *parent) {
+    aiMesh *const out_mesh = new aiMesh();
+    mMeshes.push_back(out_mesh);
+    meshes_converted[&mesh].push_back(static_cast<unsigned int>(mMeshes.size() - 1));
+
+    // set name
+    std::string name = mesh.Name();
+    if (name.substr(0, 10) == "Geometry::") {
+        name = name.substr(10);
+    }
+
+    if (name.length()) {
+        out_mesh->mName.Set(name);
+    } else {
+        out_mesh->mName = parent->mName;
+    }
+
+    return out_mesh;
+}
+
+unsigned int FBXConverter::ConvertMeshSingleMaterial(const MeshGeometry &mesh, const Model &model,
+        const aiMatrix4x4 &absolute_transform, aiNode *parent,
+        aiNode *) {
+    const MatIndexArray &mindices = mesh.GetMaterialIndices();
+    aiMesh *const out_mesh = SetupEmptyMesh(mesh, parent);
+
+    const std::vector<aiVector3D> &vertices = mesh.GetVertices();
+    const std::vector<unsigned int> &faces = mesh.GetFaceIndexCounts();
+
+    // copy vertices
+    out_mesh->mNumVertices = static_cast<unsigned int>(vertices.size());
+    out_mesh->mVertices = new aiVector3D[vertices.size()];
+
+    std::copy(vertices.begin(), vertices.end(), out_mesh->mVertices);
+
+    // generate dummy faces
+    out_mesh->mNumFaces = static_cast<unsigned int>(faces.size());
+    aiFace *fac = out_mesh->mFaces = new aiFace[faces.size()]();
+
+    unsigned int cursor = 0;
+    for (unsigned int pcount : faces) {
+        aiFace &f = *fac++;
+        f.mNumIndices = pcount;
+        f.mIndices = new unsigned int[pcount];
+        switch (pcount) {
+            case 1:
+                out_mesh->mPrimitiveTypes |= aiPrimitiveType_POINT;
+                break;
+            case 2:
+                out_mesh->mPrimitiveTypes |= aiPrimitiveType_LINE;
+                break;
+            case 3:
+                out_mesh->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
+                break;
+            default:
+                out_mesh->mPrimitiveTypes |= aiPrimitiveType_POLYGON;
+                break;
+        }
+        for (unsigned int i = 0; i < pcount; ++i) {
+            f.mIndices[i] = cursor++;
+        }
+    }
+
+    // copy normals
+    const std::vector<aiVector3D> &normals = mesh.GetNormals();
+    if (normals.size()) {
+        ai_assert(normals.size() == vertices.size());
+
+        out_mesh->mNormals = new aiVector3D[vertices.size()];
+        std::copy(normals.begin(), normals.end(), out_mesh->mNormals);
+    }
+
+    // copy tangents - assimp requires both tangents and bitangents (binormals)
+    // to be present, or neither of them. Compute binormals from normals
+    // and tangents if needed.
+    const std::vector<aiVector3D> &tangents = mesh.GetTangents();
+    const std::vector<aiVector3D> *binormals = &mesh.GetBinormals();
+
+    if (tangents.size()) {
+        std::vector<aiVector3D> tempBinormals;
+        if (!binormals->size()) {
+            if (normals.size()) {
+                tempBinormals.resize(normals.size());
+                for (unsigned int i = 0; i < tangents.size(); ++i) {
+                    tempBinormals[i] = normals[i] ^ tangents[i];
+                }
+
+                binormals = &tempBinormals;
+            } else {
+                binormals = nullptr;
+            }
+        }
+
+        if (binormals) {
+            ai_assert(tangents.size() == vertices.size());
+            ai_assert(binormals->size() == vertices.size());
+
+            out_mesh->mTangents = new aiVector3D[vertices.size()];
+            std::copy(tangents.begin(), tangents.end(), out_mesh->mTangents);
+
+            out_mesh->mBitangents = new aiVector3D[vertices.size()];
+            std::copy(binormals->begin(), binormals->end(), out_mesh->mBitangents);
+        }
+    }
+
+    // copy texture coords
+    for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
+        const std::vector<aiVector2D> &uvs = mesh.GetTextureCoords(i);
+        if (uvs.empty()) {
+            break;
+        }
+
+        aiVector3D *out_uv = out_mesh->mTextureCoords[i] = new aiVector3D[vertices.size()];
+        for (const aiVector2D &v : uvs) {
+            *out_uv++ = aiVector3D(v.x, v.y, 0.0f);
+        }
+
+        out_mesh->SetTextureCoordsName(i, aiString(mesh.GetTextureCoordChannelName(i)));
+
+        out_mesh->mNumUVComponents[i] = 2;
+    }
+
+    // copy vertex colors
+    for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_COLOR_SETS; ++i) {
+        const std::vector<aiColor4D> &colors = mesh.GetVertexColors(i);
+        if (colors.empty()) {
+            break;
+        }
+
+        out_mesh->mColors[i] = new aiColor4D[vertices.size()];
+        std::copy(colors.begin(), colors.end(), out_mesh->mColors[i]);
+    }
+
+    if (!doc.Settings().readMaterials || mindices.empty()) {
+        FBXImporter::LogError("no material assigned to mesh, setting default material");
+        out_mesh->mMaterialIndex = GetDefaultMaterial();
+    } else {
+        ConvertMaterialForMesh(out_mesh, model, mesh, mindices[0]);
+    }
+
+    if (doc.Settings().readWeights && mesh.DeformerSkin() != nullptr) {
+        ConvertWeights(out_mesh, mesh, absolute_transform, parent, NO_MATERIAL_SEPARATION, nullptr);
+    }
+
+    std::vector<aiAnimMesh *> animMeshes;
+    for (const BlendShape *blendShape : mesh.GetBlendShapes()) {
+        for (const BlendShapeChannel *blendShapeChannel : blendShape->BlendShapeChannels()) {
+            const std::vector<const ShapeGeometry *> &shapeGeometries = blendShapeChannel->GetShapeGeometries();
+            for (size_t i = 0; i < shapeGeometries.size(); i++) {
+                aiAnimMesh *animMesh = aiCreateAnimMesh(out_mesh);
+                const ShapeGeometry *shapeGeometry = shapeGeometries.at(i);
+                const std::vector<aiVector3D> &curVertices = shapeGeometry->GetVertices();
+                const std::vector<aiVector3D> &curNormals = shapeGeometry->GetNormals();
+                const std::vector<unsigned int> &curIndices = shapeGeometry->GetIndices();
+                //losing channel name if using shapeGeometry->Name()
+                animMesh->mName.Set(FixAnimMeshName(blendShapeChannel->Name()));
+                for (size_t j = 0; j < curIndices.size(); j++) {
+                    const unsigned int curIndex = curIndices.at(j);
+                    aiVector3D vertex = curVertices.at(j);
+                    aiVector3D normal = curNormals.at(j);
+                    unsigned int count = 0;
+                    const unsigned int *outIndices = mesh.ToOutputVertexIndex(curIndex, count);
+                    for (unsigned int k = 0; k < count; k++) {
+                        unsigned int index = outIndices[k];
+                        animMesh->mVertices[index] += vertex;
+                        if (animMesh->mNormals != nullptr) {
+                            animMesh->mNormals[index] += normal;
+                            animMesh->mNormals[index].NormalizeSafe();
+                        }
+                    }
+                }
+                animMesh->mWeight = shapeGeometries.size() > 1 ? blendShapeChannel->DeformPercent() / 100.0f : 1.0f;
+                animMeshes.push_back(animMesh);
+            }
+        }
+    }
+    const size_t numAnimMeshes = animMeshes.size();
+    if (numAnimMeshes > 0) {
+        out_mesh->mNumAnimMeshes = static_cast<unsigned int>(numAnimMeshes);
+        out_mesh->mAnimMeshes = new aiAnimMesh *[numAnimMeshes];
+        for (size_t i = 0; i < numAnimMeshes; i++) {
+            out_mesh->mAnimMeshes[i] = animMeshes.at(i);
+        }
+    }
+    return static_cast<unsigned int>(mMeshes.size() - 1);
+}
+
+std::vector<unsigned int>
+FBXConverter::ConvertMeshMultiMaterial(const MeshGeometry &mesh, const Model &model, aiNode *parent,
+        aiNode *root_node,
+        const aiMatrix4x4 &absolute_transform) {
+    const MatIndexArray &mindices = mesh.GetMaterialIndices();
+    ai_assert(mindices.size());
+
+    std::set<MatIndexArray::value_type> had;
+    std::vector<unsigned int> indices;
+
+    for (MatIndexArray::value_type index : mindices) {
+        if (had.find(index) == had.end()) {
+
+            indices.push_back(ConvertMeshMultiMaterial(mesh, model, index, parent, root_node, absolute_transform));
+            had.insert(index);
+        }
+    }
+
+    return indices;
+}
+
+unsigned int FBXConverter::ConvertMeshMultiMaterial(const MeshGeometry &mesh, const Model &model,
+        MatIndexArray::value_type index,
+        aiNode *parent, aiNode *,
+        const aiMatrix4x4 &absolute_transform) {
+    aiMesh *const out_mesh = SetupEmptyMesh(mesh, parent);
+
+    const MatIndexArray &mindices = mesh.GetMaterialIndices();
+    const std::vector<aiVector3D> &vertices = mesh.GetVertices();
+    const std::vector<unsigned int> &faces = mesh.GetFaceIndexCounts();
+
+    const bool process_weights = doc.Settings().readWeights && mesh.DeformerSkin() != nullptr;
+
+    unsigned int count_faces = 0;
+    unsigned int count_vertices = 0;
+
+    // count faces
+    std::vector<unsigned int>::const_iterator itf = faces.begin();
+    for (MatIndexArray::const_iterator it = mindices.begin(),
+                                       end = mindices.end();
+            it != end; ++it, ++itf) {
+        if ((*it) != index) {
+            continue;
+        }
+        ++count_faces;
+        count_vertices += *itf;
+    }
+
+    ai_assert(count_faces);
+    ai_assert(count_vertices);
+
+    // mapping from output indices to DOM indexing, needed to resolve weights or blendshapes
+    std::vector<unsigned int> reverseMapping;
+    std::map<unsigned int, unsigned int> translateIndexMap;
+    if (process_weights || mesh.GetBlendShapes().size() > 0) {
+        reverseMapping.resize(count_vertices);
+    }
+
+    // allocate output data arrays, but don't fill them yet
+    out_mesh->mNumVertices = count_vertices;
+    out_mesh->mVertices = new aiVector3D[count_vertices];
+
+    out_mesh->mNumFaces = count_faces;
+    aiFace *fac = out_mesh->mFaces = new aiFace[count_faces]();
+
+    // allocate normals
+    const std::vector<aiVector3D> &normals = mesh.GetNormals();
+    if (normals.size()) {
+        ai_assert(normals.size() == vertices.size());
+        out_mesh->mNormals = new aiVector3D[count_vertices];
+    }
+
+    // allocate tangents, binormals.
+    const std::vector<aiVector3D> &tangents = mesh.GetTangents();
+    const std::vector<aiVector3D> *binormals = &mesh.GetBinormals();
+    std::vector<aiVector3D> tempBinormals;
+
+    if (tangents.size()) {
+        if (!binormals->size()) {
+            if (normals.size()) {
+                // XXX this computes the binormals for the entire mesh, not only
+                // the part for which we need them.
+                tempBinormals.resize(normals.size());
+                for (unsigned int i = 0; i < tangents.size(); ++i) {
+                    tempBinormals[i] = normals[i] ^ tangents[i];
+                }
+
+                binormals = &tempBinormals;
+            } else {
+                binormals = nullptr;
+            }
+        }
+
+        if (binormals) {
+            ai_assert(tangents.size() == vertices.size());
+            ai_assert(binormals->size() == vertices.size());
+
+            out_mesh->mTangents = new aiVector3D[count_vertices];
+            out_mesh->mBitangents = new aiVector3D[count_vertices];
+        }
+    }
+
+    // allocate texture coords
+    unsigned int num_uvs = 0;
+    for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i, ++num_uvs) {
+        const std::vector<aiVector2D> &uvs = mesh.GetTextureCoords(i);
+        if (uvs.empty()) {
+            break;
+        }
+
+        out_mesh->mTextureCoords[i] = new aiVector3D[count_vertices];
+        out_mesh->mNumUVComponents[i] = 2;
+    }
+
+    // allocate vertex colors
+    unsigned int num_vcs = 0;
+    for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_COLOR_SETS; ++i, ++num_vcs) {
+        const std::vector<aiColor4D> &colors = mesh.GetVertexColors(i);
+        if (colors.empty()) {
+            break;
+        }
+
+        out_mesh->mColors[i] = new aiColor4D[count_vertices];
+    }
+
+    unsigned int cursor = 0, in_cursor = 0;
+
+    itf = faces.begin();
+    for (MatIndexArray::const_iterator it = mindices.begin(), end = mindices.end(); it != end; ++it, ++itf) {
+        const unsigned int pcount = *itf;
+        if ((*it) != index) {
+            in_cursor += pcount;
+            continue;
+        }
+
+        aiFace &f = *fac++;
+
+        f.mNumIndices = pcount;
+        f.mIndices = new unsigned int[pcount];
+        switch (pcount) {
+            case 1:
+                out_mesh->mPrimitiveTypes |= aiPrimitiveType_POINT;
+                break;
+            case 2:
+                out_mesh->mPrimitiveTypes |= aiPrimitiveType_LINE;
+                break;
+            case 3:
+                out_mesh->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
+                break;
+            default:
+                out_mesh->mPrimitiveTypes |= aiPrimitiveType_POLYGON;
+                break;
+        }
+        for (unsigned int i = 0; i < pcount; ++i, ++cursor, ++in_cursor) {
+            f.mIndices[i] = cursor;
+
+            if (reverseMapping.size()) {
+                reverseMapping[cursor] = in_cursor;
+                translateIndexMap[in_cursor] = cursor;
+            }
+
+            out_mesh->mVertices[cursor] = vertices[in_cursor];
+
+            if (out_mesh->mNormals) {
+                out_mesh->mNormals[cursor] = normals[in_cursor];
+            }
+
+            if (out_mesh->mTangents) {
+                out_mesh->mTangents[cursor] = tangents[in_cursor];
+                out_mesh->mBitangents[cursor] = (*binormals)[in_cursor];
+            }
+
+            for (unsigned int j = 0; j < num_uvs; ++j) {
+                const std::vector<aiVector2D> &uvs = mesh.GetTextureCoords(j);
+                out_mesh->mTextureCoords[j][cursor] = aiVector3D(uvs[in_cursor].x, uvs[in_cursor].y, 0.0f);
+            }
+
+            for (unsigned int j = 0; j < num_vcs; ++j) {
+                const std::vector<aiColor4D> &cols = mesh.GetVertexColors(j);
+                out_mesh->mColors[j][cursor] = cols[in_cursor];
+            }
+        }
+    }
+
+    ConvertMaterialForMesh(out_mesh, model, mesh, index);
+
+    if (process_weights) {
+        ConvertWeights(out_mesh, mesh, absolute_transform, parent, index, &reverseMapping);
+    }
+
+    std::vector<aiAnimMesh *> animMeshes;
+    for (const BlendShape *blendShape : mesh.GetBlendShapes()) {
+        for (const BlendShapeChannel *blendShapeChannel : blendShape->BlendShapeChannels()) {
+            const std::vector<const ShapeGeometry *> &shapeGeometries = blendShapeChannel->GetShapeGeometries();
+            for (size_t i = 0; i < shapeGeometries.size(); i++) {
+                aiAnimMesh *animMesh = aiCreateAnimMesh(out_mesh);
+                const ShapeGeometry *shapeGeometry = shapeGeometries.at(i);
+                const std::vector<aiVector3D> &curVertices = shapeGeometry->GetVertices();
+                const std::vector<aiVector3D> &curNormals = shapeGeometry->GetNormals();
+                const std::vector<unsigned int> &curIndices = shapeGeometry->GetIndices();
+                animMesh->mName.Set(FixAnimMeshName(shapeGeometry->Name()));
+                for (size_t j = 0; j < curIndices.size(); j++) {
+                    unsigned int curIndex = curIndices.at(j);
+                    aiVector3D vertex = curVertices.at(j);
+                    aiVector3D normal = curNormals.at(j);
+                    unsigned int count = 0;
+                    const unsigned int *outIndices = mesh.ToOutputVertexIndex(curIndex, count);
+                    for (unsigned int k = 0; k < count; k++) {
+                        unsigned int outIndex = outIndices[k];
+                        if (translateIndexMap.find(outIndex) == translateIndexMap.end())
+                            continue;
+                        unsigned int transIndex = translateIndexMap[outIndex];
+                        animMesh->mVertices[transIndex] += vertex;
+                        if (animMesh->mNormals != nullptr) {
+                            animMesh->mNormals[transIndex] += normal;
+                            animMesh->mNormals[transIndex].NormalizeSafe();
+                        }
+                    }
+                }
+                animMesh->mWeight = shapeGeometries.size() > 1 ? blendShapeChannel->DeformPercent() / 100.0f : 1.0f;
+                animMeshes.push_back(animMesh);
+            }
+        }
+    }
+
+    const size_t numAnimMeshes = animMeshes.size();
+    if (numAnimMeshes > 0) {
+        out_mesh->mNumAnimMeshes = static_cast<unsigned int>(numAnimMeshes);
+        out_mesh->mAnimMeshes = new aiAnimMesh *[numAnimMeshes];
+        for (size_t i = 0; i < numAnimMeshes; i++) {
+            out_mesh->mAnimMeshes[i] = animMeshes.at(i);
+        }
+    }
+
+    return static_cast<unsigned int>(mMeshes.size() - 1);
+}
+
+void FBXConverter::ConvertWeights(aiMesh *out, const MeshGeometry &geo,
+        const aiMatrix4x4 &absolute_transform,
+        aiNode *parent, unsigned int materialIndex,
+        std::vector<unsigned int> *outputVertStartIndices) {
+    ai_assert(geo.DeformerSkin());
+
+    std::vector<size_t> out_indices;
+    std::vector<size_t> index_out_indices;
+    std::vector<size_t> count_out_indices;
+
+    const Skin &sk = *geo.DeformerSkin();
+
+    std::vector<aiBone *> bones;
+
+    const bool no_mat_check = materialIndex == NO_MATERIAL_SEPARATION;
+    ai_assert(no_mat_check || outputVertStartIndices);
+
+    try {
+        // iterate over the sub deformers
+        for (const Cluster *cluster : sk.Clusters()) {
+            ai_assert(cluster);
+
+            const WeightIndexArray &indices = cluster->GetIndices();
+
+            const MatIndexArray &mats = geo.GetMaterialIndices();
+
+            const size_t no_index_sentinel = std::numeric_limits<size_t>::max();
+
+            count_out_indices.clear();
+            index_out_indices.clear();
+            out_indices.clear();
+
+            // now check if *any* of these weights is contained in the output mesh,
+            // taking notes so we don't need to do it twice.
+            for (WeightIndexArray::value_type index : indices) {
+
+                unsigned int count = 0;
+                const unsigned int *const out_idx = geo.ToOutputVertexIndex(index, count);
+                // ToOutputVertexIndex only returns nullptr if index is out of bounds
+                // which should never happen
+                ai_assert(out_idx != nullptr);
+
+                index_out_indices.push_back(no_index_sentinel);
+                count_out_indices.push_back(0);
+
+                for (unsigned int i = 0; i < count; ++i) {
+                    if (no_mat_check || static_cast<size_t>(mats[geo.FaceForVertexIndex(out_idx[i])]) == materialIndex) {
+
+                        if (index_out_indices.back() == no_index_sentinel) {
+                            index_out_indices.back() = out_indices.size();
+                        }
+
+                        if (no_mat_check) {
+                            out_indices.push_back(out_idx[i]);
+                        } else {
+                            // this extra lookup is in O(logn), so the entire algorithm becomes O(nlogn)
+                            const std::vector<unsigned int>::iterator it = std::lower_bound(
+                                    outputVertStartIndices->begin(),
+                                    outputVertStartIndices->end(),
+                                    out_idx[i]);
+
+                            out_indices.push_back(std::distance(outputVertStartIndices->begin(), it));
+                        }
+
+                        ++count_out_indices.back();
+                    }
+                }
+            }
+
+            // if we found at least one, generate the output bones
+            // XXX this could be heavily simplified by collecting the bone
+            // data in a single step.
+            ConvertCluster(bones, cluster, out_indices, index_out_indices,
+                    count_out_indices, absolute_transform, parent);
+        }
+
+        bone_map.clear();
+    } catch (std::exception &) {
+        std::for_each(bones.begin(), bones.end(), Util::delete_fun<aiBone>());
+        throw;
+    }
+
+    if (bones.empty()) {
+        out->mBones = nullptr;
+        out->mNumBones = 0;
+        return;
+    } else {
+        out->mBones = new aiBone *[bones.size()]();
+        out->mNumBones = static_cast<unsigned int>(bones.size());
+
+        std::swap_ranges(bones.begin(), bones.end(), out->mBones);
+    }
+}
+
+const aiNode *GetNodeByName(aiNode *current_node) {
+    aiNode *iter = current_node;
+    //printf("Child count: %d", iter->mNumChildren);
+    return iter;
+}
+
+void FBXConverter::ConvertCluster(std::vector<aiBone *> &local_mesh_bones, const Cluster *cl,
+        std::vector<size_t> &out_indices, std::vector<size_t> &index_out_indices,
+        std::vector<size_t> &count_out_indices, const aiMatrix4x4 &absolute_transform,
+        aiNode *) {
+    ai_assert(cl); // make sure cluster valid
+    std::string deformer_name = cl->TargetNode()->Name();
+    aiString bone_name = aiString(FixNodeName(deformer_name));
+
+    aiBone *bone = nullptr;
+
+    if (bone_map.count(deformer_name)) {
+        ASSIMP_LOG_VERBOSE_DEBUG("retrieved bone from lookup ", bone_name.C_Str(), ". Deformer:", deformer_name);
+        bone = bone_map[deformer_name];
+    } else {
+        ASSIMP_LOG_VERBOSE_DEBUG("created new bone ", bone_name.C_Str(), ". Deformer: ", deformer_name);
+        bone = new aiBone();
+        bone->mName = bone_name;
+
+        // store local transform link for post processing
+        bone->mOffsetMatrix = cl->TransformLink();
+        bone->mOffsetMatrix.Inverse();
+
+        aiMatrix4x4 matrix = (aiMatrix4x4)absolute_transform;
+
+        bone->mOffsetMatrix = bone->mOffsetMatrix * matrix; // * mesh_offset
+
+        //
+        // Now calculate the aiVertexWeights
+        //
+
+        aiVertexWeight *cursor = nullptr;
+
+        bone->mNumWeights = static_cast<unsigned int>(out_indices.size());
+        cursor = bone->mWeights = new aiVertexWeight[out_indices.size()];
+
+        const size_t no_index_sentinel = std::numeric_limits<size_t>::max();
+        const WeightArray &weights = cl->GetWeights();
+
+        const size_t c = index_out_indices.size();
+        for (size_t i = 0; i < c; ++i) {
+            const size_t index_index = index_out_indices[i];
+
+            if (index_index == no_index_sentinel) {
+                continue;
+            }
+
+            const size_t cc = count_out_indices[i];
+            for (size_t j = 0; j < cc; ++j) {
+                // cursor runs from first element relative to the start
+                // or relative to the start of the next indexes.
+                aiVertexWeight &out_weight = *cursor++;
+
+                out_weight.mVertexId = static_cast<unsigned int>(out_indices[index_index + j]);
+                out_weight.mWeight = weights[i];
+            }
+        }
+
+        bone_map.insert(std::pair<const std::string, aiBone *>(deformer_name, bone));
+    }
+
+    ASSIMP_LOG_DEBUG("bone research: Indices size: ", out_indices.size());
+
+    // lookup must be populated in case something goes wrong
+    // this also allocates bones to mesh instance outside
+    local_mesh_bones.push_back(bone);
+}
+
+void FBXConverter::ConvertMaterialForMesh(aiMesh *out, const Model &model, const MeshGeometry &geo,
+        MatIndexArray::value_type materialIndex) {
+    // locate source materials for this mesh
+    const std::vector<const Material *> &mats = model.GetMaterials();
+    if (static_cast<unsigned int>(materialIndex) >= mats.size() || materialIndex < 0) {
+        FBXImporter::LogError("material index out of bounds, setting default material");
+        out->mMaterialIndex = GetDefaultMaterial();
+        return;
+    }
+
+    const Material *const mat = mats[materialIndex];
+    MaterialMap::const_iterator it = materials_converted.find(mat);
+    if (it != materials_converted.end()) {
+        out->mMaterialIndex = (*it).second;
+        return;
+    }
+
+    out->mMaterialIndex = ConvertMaterial(*mat, &geo);
+    materials_converted[mat] = out->mMaterialIndex;
+}
+
+unsigned int FBXConverter::GetDefaultMaterial() {
+    if (defaultMaterialIndex) {
+        return defaultMaterialIndex - 1;
+    }
+
+    aiMaterial *out_mat = new aiMaterial();
+    materials.push_back(out_mat);
+
+    const aiColor3D diffuse = aiColor3D(0.8f, 0.8f, 0.8f);
+    out_mat->AddProperty(&diffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
+
+    aiString s;
+    s.Set(AI_DEFAULT_MATERIAL_NAME);
+
+    out_mat->AddProperty(&s, AI_MATKEY_NAME);
+
+    defaultMaterialIndex = static_cast<unsigned int>(materials.size());
+    return defaultMaterialIndex - 1;
+}
+
+unsigned int FBXConverter::ConvertMaterial(const Material &material, const MeshGeometry *const mesh) {
+    const PropertyTable &props = material.Props();
+
+    // generate empty output material
+    aiMaterial *out_mat = new aiMaterial();
+    materials_converted[&material] = static_cast<unsigned int>(materials.size());
+
+    materials.push_back(out_mat);
+
+    aiString str;
+
+    // strip Material:: prefix
+    std::string name = material.Name();
+    if (name.substr(0, 10) == "Material::") {
+        name = name.substr(10);
+    }
+
+    // set material name if not empty - this could happen
+    // and there should be no key for it in this case.
+    if (name.length()) {
+        str.Set(name);
+        out_mat->AddProperty(&str, AI_MATKEY_NAME);
+    }
+
+    // Set the shading mode as best we can: The FBX specification only mentions Lambert and Phong, and only Phong is mentioned in Assimp's aiShadingMode enum.
+    if (material.GetShadingModel() == "phong") {
+        aiShadingMode shadingMode = aiShadingMode_Phong;
+        out_mat->AddProperty<aiShadingMode>(&shadingMode, 1, AI_MATKEY_SHADING_MODEL);
+    }
+
+    // shading stuff and colors
+    SetShadingPropertiesCommon(out_mat, props);
+    SetShadingPropertiesRaw(out_mat, props, material.Textures(), mesh);
+
+    // texture assignments
+    SetTextureProperties(out_mat, material.Textures(), mesh);
+    SetTextureProperties(out_mat, material.LayeredTextures(), mesh);
+
+    return static_cast<unsigned int>(materials.size() - 1);
+}
+
+unsigned int FBXConverter::ConvertVideo(const Video &video) {
+    // generate empty output texture
+    aiTexture *out_tex = new aiTexture();
+    textures.push_back(out_tex);
+
+    // assuming the texture is compressed
+    out_tex->mWidth = static_cast<unsigned int>(video.ContentLength()); // total data size
+    out_tex->mHeight = 0; // fixed to 0
+
+    // steal the data from the Video to avoid an additional copy
+    out_tex->pcData = reinterpret_cast<aiTexel *>(const_cast<Video &>(video).RelinquishContent());
+
+    // try to extract a hint from the file extension
+    const std::string &filename = video.RelativeFilename().empty() ? video.FileName() : video.RelativeFilename();
+    std::string ext = BaseImporter::GetExtension(filename);
+
+    if (ext == "jpeg") {
+        ext = "jpg";
+    }
+
+    if (ext.size() <= 3) {
+        memcpy(out_tex->achFormatHint, ext.c_str(), ext.size());
+    }
+
+    out_tex->mFilename.Set(filename.c_str());
+
+    return static_cast<unsigned int>(textures.size() - 1);
+}
+
+aiString FBXConverter::GetTexturePath(const Texture *tex) {
+    aiString path;
+    path.Set(tex->RelativeFilename());
+
+    const Video *media = tex->Media();
+    if (media != nullptr) {
+        bool textureReady = false; //tells if our texture is ready (if it was loaded or if it was found)
+        unsigned int index=0;
+
+        VideoMap::const_iterator it = textures_converted.find(media);
+        if (it != textures_converted.end()) {
+            index = (*it).second;
+            textureReady = true;
+        } else {
+            if (media->ContentLength() > 0) {
+                index = ConvertVideo(*media);
+                textures_converted[media] = index;
+                textureReady = true;
+            }
+        }
+
+        // setup texture reference string (copied from ColladaLoader::FindFilenameForEffectTexture), if the texture is ready
+        if (doc.Settings().useLegacyEmbeddedTextureNaming) {
+            if (textureReady) {
+                // TODO: check the possibility of using the flag "AI_CONFIG_IMPORT_FBX_EMBEDDED_TEXTURES_LEGACY_NAMING"
+                // In FBX files textures are now stored internally by Assimp with their filename included
+                // Now Assimp can lookup through the loaded textures after all data is processed
+                // We need to load all textures before referencing them, as FBX file format order may reference a texture before loading it
+                // This may occur on this case too, it has to be studied
+                path.data[0] = '*';
+                path.length = 1 + ASSIMP_itoa10(path.data + 1, MAXLEN - 1, index);
+            }
+        }
+    }
+
+    return path;
+}
+
+void FBXConverter::TrySetTextureProperties(aiMaterial *out_mat, const TextureMap &_textures,
+        const std::string &propName,
+        aiTextureType target, const MeshGeometry *const mesh) {
+    TextureMap::const_iterator it = _textures.find(propName);
+    if (it == _textures.end()) {
+        return;
+    }
+
+    const Texture *const tex = (*it).second;
+    if (tex != nullptr) {
+        aiString path = GetTexturePath(tex);
+        out_mat->AddProperty(&path, _AI_MATKEY_TEXTURE_BASE, target, 0);
+
+        aiUVTransform uvTrafo;
+        // XXX handle all kinds of UV transformations
+        uvTrafo.mScaling = tex->UVScaling();
+        uvTrafo.mTranslation = tex->UVTranslation();
+        uvTrafo.mRotation = tex->UVRotation();
+        out_mat->AddProperty(&uvTrafo, 1, _AI_MATKEY_UVTRANSFORM_BASE, target, 0);
+
+        const PropertyTable &props = tex->Props();
+
+        int uvIndex = 0;
+
+        bool ok;
+        const std::string &uvSet = PropertyGet<std::string>(props, "UVSet", ok);
+        if (ok) {
+            // "default" is the name which usually appears in the FbxFileTexture template
+            if (uvSet != "default" && uvSet.length()) {
+                // this is a bit awkward - we need to find a mesh that uses this
+                // material and scan its UV channels for the given UV name because
+                // assimp references UV channels by index, not by name.
+
+                // XXX: the case that UV channels may appear in different orders
+                // in meshes is unhandled. A possible solution would be to sort
+                // the UV channels alphabetically, but this would have the side
+                // effect that the primary (first) UV channel would sometimes
+                // be moved, causing trouble when users read only the first
+                // UV channel and ignore UV channel assignments altogether.
+
+                const unsigned int matIndex = static_cast<unsigned int>(std::distance(materials.begin(),
+                        std::find(materials.begin(), materials.end(), out_mat)));
+
+                uvIndex = -1;
+                if (!mesh) {
+                    for (const MeshMap::value_type &v : meshes_converted) {
+                        const MeshGeometry *const meshGeom = dynamic_cast<const MeshGeometry *>(v.first);
+                        if (!meshGeom) {
+                            continue;
+                        }
+
+                        const MatIndexArray &mats = meshGeom->GetMaterialIndices();
+                        MatIndexArray::const_iterator curIt = std::find(mats.begin(), mats.end(), (int) matIndex);
+                        if (curIt == mats.end()) {
+                            continue;
+                        }
+
+                        int index = -1;
+                        for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
+                            if (meshGeom->GetTextureCoords(i).empty()) {
+                                break;
+                            }
+                            const std::string &name = meshGeom->GetTextureCoordChannelName(i);
+                            if (name == uvSet) {
+                                index = static_cast<int>(i);
+                                break;
+                            }
+                        }
+                        if (index == -1) {
+                            FBXImporter::LogWarn("did not find UV channel named ", uvSet, " in a mesh using this material");
+                            continue;
+                        }
+
+                        if (uvIndex == -1) {
+                            uvIndex = index;
+                        } else {
+                            FBXImporter::LogWarn("the UV channel named ", uvSet,
+                                                 " appears at different positions in meshes, results will be wrong");
+                        }
+                    }
+                } else {
+                    int index = -1;
+                    for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
+                        if (mesh->GetTextureCoords(i).empty()) {
+                            break;
+                        }
+                        const std::string &name = mesh->GetTextureCoordChannelName(i);
+                        if (name == uvSet) {
+                            index = static_cast<int>(i);
+                            break;
+                        }
+                    }
+                    if (index == -1) {
+                        FBXImporter::LogWarn("did not find UV channel named ", uvSet, " in a mesh using this material");
+                    }
+
+                    if (uvIndex == -1) {
+                        uvIndex = index;
+                    }
+                }
+
+                if (uvIndex == -1) {
+                    FBXImporter::LogWarn("failed to resolve UV channel ", uvSet, ", using first UV channel");
+                    uvIndex = 0;
+                }
+            }
+        }
+
+        out_mat->AddProperty(&uvIndex, 1, _AI_MATKEY_UVWSRC_BASE, target, 0);
+    }
+}
+
+void FBXConverter::TrySetTextureProperties(aiMaterial *out_mat, const LayeredTextureMap &layeredTextures,
+        const std::string &propName,
+        aiTextureType target, const MeshGeometry *const mesh) {
+    LayeredTextureMap::const_iterator it = layeredTextures.find(propName);
+    if (it == layeredTextures.end()) {
+        return;
+    }
+
+    int texCount = (*it).second->textureCount();
+
+    // Set the blend mode for layered textures
+    int blendmode = (*it).second->GetBlendMode();
+    out_mat->AddProperty(&blendmode, 1, _AI_MATKEY_TEXOP_BASE, target, 0);
+
+    for (int texIndex = 0; texIndex < texCount; texIndex++) {
+
+        const Texture *const tex = (*it).second->getTexture(texIndex);
+
+        aiString path = GetTexturePath(tex);
+        out_mat->AddProperty(&path, _AI_MATKEY_TEXTURE_BASE, target, texIndex);
+
+        aiUVTransform uvTrafo;
+        // XXX handle all kinds of UV transformations
+        uvTrafo.mScaling = tex->UVScaling();
+        uvTrafo.mTranslation = tex->UVTranslation();
+        uvTrafo.mRotation = tex->UVRotation();
+        out_mat->AddProperty(&uvTrafo, 1, _AI_MATKEY_UVTRANSFORM_BASE, target, texIndex);
+
+        const PropertyTable &props = tex->Props();
+
+        int uvIndex = 0;
+
+        bool ok;
+        const std::string &uvSet = PropertyGet<std::string>(props, "UVSet", ok);
+        if (ok) {
+            // "default" is the name which usually appears in the FbxFileTexture template
+            if (uvSet != "default" && uvSet.length()) {
+                // this is a bit awkward - we need to find a mesh that uses this
+                // material and scan its UV channels for the given UV name because
+                // assimp references UV channels by index, not by name.
+
+                // XXX: the case that UV channels may appear in different orders
+                // in meshes is unhandled. A possible solution would be to sort
+                // the UV channels alphabetically, but this would have the side
+                // effect that the primary (first) UV channel would sometimes
+                // be moved, causing trouble when users read only the first
+                // UV channel and ignore UV channel assignments altogether.
+
+                const unsigned int matIndex = static_cast<unsigned int>(std::distance(materials.begin(),
+                        std::find(materials.begin(), materials.end(), out_mat)));
+
+                uvIndex = -1;
+                if (!mesh) {
+                    for (const MeshMap::value_type &v : meshes_converted) {
+                        const MeshGeometry *const meshGeom = dynamic_cast<const MeshGeometry *>(v.first);
+                        if (!meshGeom) {
+                            continue;
+                        }
+
+                        const MatIndexArray &mats = meshGeom->GetMaterialIndices();
+                        MatIndexArray::const_iterator curIt = std::find(mats.begin(), mats.end(), (int) matIndex);
+                        if ( curIt == mats.end()) {
+                            continue;
+                        }
+
+                        int index = -1;
+                        for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
+                            if (meshGeom->GetTextureCoords(i).empty()) {
+                                break;
+                            }
+                            const std::string &name = meshGeom->GetTextureCoordChannelName(i);
+                            if (name == uvSet) {
+                                index = static_cast<int>(i);
+                                break;
+                            }
+                        }
+                        if (index == -1) {
+                            FBXImporter::LogWarn("did not find UV channel named ", uvSet, " in a mesh using this material");
+                            continue;
+                        }
+
+                        if (uvIndex == -1) {
+                            uvIndex = index;
+                        } else {
+                            FBXImporter::LogWarn("the UV channel named ", uvSet,
+                                                 " appears at different positions in meshes, results will be wrong");
+                        }
+                    }
+                } else {
+                    int index = -1;
+                    for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
+                        if (mesh->GetTextureCoords(i).empty()) {
+                            break;
+                        }
+                        const std::string &name = mesh->GetTextureCoordChannelName(i);
+                        if (name == uvSet) {
+                            index = static_cast<int>(i);
+                            break;
+                        }
+                    }
+                    if (index == -1) {
+                        FBXImporter::LogWarn("did not find UV channel named ", uvSet, " in a mesh using this material");
+                    }
+
+                    if (uvIndex == -1) {
+                        uvIndex = index;
+                    }
+                }
+
+                if (uvIndex == -1) {
+                    FBXImporter::LogWarn("failed to resolve UV channel ", uvSet, ", using first UV channel");
+                    uvIndex = 0;
+                }
+            }
+        }
+
+        out_mat->AddProperty(&uvIndex, 1, _AI_MATKEY_UVWSRC_BASE, target, texIndex);
+    }
+}
+
+void FBXConverter::SetTextureProperties(aiMaterial *out_mat, const TextureMap &_textures, const MeshGeometry *const mesh) {
+    TrySetTextureProperties(out_mat, _textures, "DiffuseColor", aiTextureType_DIFFUSE, mesh);
+    TrySetTextureProperties(out_mat, _textures, "AmbientColor", aiTextureType_AMBIENT, mesh);
+    TrySetTextureProperties(out_mat, _textures, "EmissiveColor", aiTextureType_EMISSIVE, mesh);
+    TrySetTextureProperties(out_mat, _textures, "SpecularColor", aiTextureType_SPECULAR, mesh);
+    TrySetTextureProperties(out_mat, _textures, "SpecularFactor", aiTextureType_SPECULAR, mesh);
+    TrySetTextureProperties(out_mat, _textures, "TransparentColor", aiTextureType_OPACITY, mesh);
+    TrySetTextureProperties(out_mat, _textures, "ReflectionColor", aiTextureType_REFLECTION, mesh);
+    TrySetTextureProperties(out_mat, _textures, "DisplacementColor", aiTextureType_DISPLACEMENT, mesh);
+    TrySetTextureProperties(out_mat, _textures, "NormalMap", aiTextureType_NORMALS, mesh);
+    TrySetTextureProperties(out_mat, _textures, "Bump", aiTextureType_HEIGHT, mesh);
+    TrySetTextureProperties(out_mat, _textures, "ShininessExponent", aiTextureType_SHININESS, mesh);
+    TrySetTextureProperties(out_mat, _textures, "TransparencyFactor", aiTextureType_OPACITY, mesh);
+    TrySetTextureProperties(out_mat, _textures, "EmissiveFactor", aiTextureType_EMISSIVE, mesh);
+    TrySetTextureProperties(out_mat, _textures, "ReflectionFactor", aiTextureType_METALNESS, mesh);
+    //Maya counterparts
+    TrySetTextureProperties(out_mat, _textures, "Maya|DiffuseTexture", aiTextureType_DIFFUSE, mesh);
+    TrySetTextureProperties(out_mat, _textures, "Maya|NormalTexture", aiTextureType_NORMALS, mesh);
+    TrySetTextureProperties(out_mat, _textures, "Maya|SpecularTexture", aiTextureType_SPECULAR, mesh);
+    TrySetTextureProperties(out_mat, _textures, "Maya|FalloffTexture", aiTextureType_OPACITY, mesh);
+    TrySetTextureProperties(out_mat, _textures, "Maya|ReflectionMapTexture", aiTextureType_REFLECTION, mesh);
+
+    // Maya PBR
+    TrySetTextureProperties(out_mat, _textures, "Maya|baseColor", aiTextureType_BASE_COLOR, mesh);
+    TrySetTextureProperties(out_mat, _textures, "Maya|normalCamera", aiTextureType_NORMAL_CAMERA, mesh);
+    TrySetTextureProperties(out_mat, _textures, "Maya|emissionColor", aiTextureType_EMISSION_COLOR, mesh);
+    TrySetTextureProperties(out_mat, _textures, "Maya|metalness", aiTextureType_METALNESS, mesh);
+    TrySetTextureProperties(out_mat, _textures, "Maya|diffuseRoughness", aiTextureType_DIFFUSE_ROUGHNESS, mesh);
+
+    // Maya stingray
+    TrySetTextureProperties(out_mat, _textures, "Maya|TEX_color_map", aiTextureType_BASE_COLOR, mesh);
+    TrySetTextureProperties(out_mat, _textures, "Maya|TEX_normal_map", aiTextureType_NORMAL_CAMERA, mesh);
+    TrySetTextureProperties(out_mat, _textures, "Maya|TEX_emissive_map", aiTextureType_EMISSION_COLOR, mesh);
+    TrySetTextureProperties(out_mat, _textures, "Maya|TEX_metallic_map", aiTextureType_METALNESS, mesh);
+    TrySetTextureProperties(out_mat, _textures, "Maya|TEX_roughness_map", aiTextureType_DIFFUSE_ROUGHNESS, mesh);
+    TrySetTextureProperties(out_mat, _textures, "Maya|TEX_ao_map", aiTextureType_AMBIENT_OCCLUSION, mesh);
+
+    // 3DSMax Physical material
+    TrySetTextureProperties(out_mat, _textures, "3dsMax|Parameters|base_color_map", aiTextureType_BASE_COLOR, mesh);
+    TrySetTextureProperties(out_mat, _textures, "3dsMax|Parameters|bump_map", aiTextureType_NORMAL_CAMERA, mesh);
+    TrySetTextureProperties(out_mat, _textures, "3dsMax|Parameters|emission_map", aiTextureType_EMISSION_COLOR, mesh);
+    TrySetTextureProperties(out_mat, _textures, "3dsMax|Parameters|metalness_map", aiTextureType_METALNESS, mesh);
+    TrySetTextureProperties(out_mat, _textures, "3dsMax|Parameters|roughness_map", aiTextureType_DIFFUSE_ROUGHNESS, mesh);
+
+    // 3DSMax PBR materials
+    TrySetTextureProperties(out_mat, _textures, "3dsMax|main|base_color_map", aiTextureType_BASE_COLOR, mesh);
+    TrySetTextureProperties(out_mat, _textures, "3dsMax|main|norm_map", aiTextureType_NORMAL_CAMERA, mesh);
+    TrySetTextureProperties(out_mat, _textures, "3dsMax|main|emit_color_map", aiTextureType_EMISSION_COLOR, mesh);
+    TrySetTextureProperties(out_mat, _textures, "3dsMax|main|ao_map", aiTextureType_AMBIENT_OCCLUSION, mesh);
+    TrySetTextureProperties(out_mat, _textures, "3dsMax|main|opacity_map", aiTextureType_OPACITY, mesh);
+    // Metalness/Roughness material type
+    TrySetTextureProperties(out_mat, _textures, "3dsMax|main|metalness_map", aiTextureType_METALNESS, mesh);
+    // Specular/Gloss material type
+    TrySetTextureProperties(out_mat, _textures, "3dsMax|main|specular_map", aiTextureType_SPECULAR, mesh);
+
+    // Glossiness vs roughness in 3ds Max Pbr Materials
+    int useGlossiness;
+    if (out_mat->Get("$raw.3dsMax|main|useGlossiness", aiTextureType_NONE, 0, useGlossiness) == aiReturn_SUCCESS) {
+        // These textures swap meaning if ((useGlossiness == 1) != (material type is Specular/Gloss))
+        if (useGlossiness == 1) {
+            TrySetTextureProperties(out_mat, _textures, "3dsMax|main|roughness_map", aiTextureType_SHININESS, mesh);
+            TrySetTextureProperties(out_mat, _textures, "3dsMax|main|glossiness_map", aiTextureType_SHININESS, mesh);
+        }
+        else if (useGlossiness == 2) {
+            TrySetTextureProperties(out_mat, _textures, "3dsMax|main|roughness_map", aiTextureType_DIFFUSE_ROUGHNESS, mesh);
+            TrySetTextureProperties(out_mat, _textures, "3dsMax|main|glossiness_map", aiTextureType_DIFFUSE_ROUGHNESS, mesh);
+        }
+        else {
+            FBXImporter::LogWarn("A 3dsMax Pbr Material must have a useGlossiness value to correctly interpret roughness and glossiness textures.");
+        }
+    }
+}
+
+void FBXConverter::SetTextureProperties(aiMaterial *out_mat, const LayeredTextureMap &layeredTextures, const MeshGeometry *const mesh) {
+    TrySetTextureProperties(out_mat, layeredTextures, "DiffuseColor", aiTextureType_DIFFUSE, mesh);
+    TrySetTextureProperties(out_mat, layeredTextures, "AmbientColor", aiTextureType_AMBIENT, mesh);
+    TrySetTextureProperties(out_mat, layeredTextures, "EmissiveColor", aiTextureType_EMISSIVE, mesh);
+    TrySetTextureProperties(out_mat, layeredTextures, "SpecularColor", aiTextureType_SPECULAR, mesh);
+    TrySetTextureProperties(out_mat, layeredTextures, "SpecularFactor", aiTextureType_SPECULAR, mesh);
+    TrySetTextureProperties(out_mat, layeredTextures, "TransparentColor", aiTextureType_OPACITY, mesh);
+    TrySetTextureProperties(out_mat, layeredTextures, "ReflectionColor", aiTextureType_REFLECTION, mesh);
+    TrySetTextureProperties(out_mat, layeredTextures, "DisplacementColor", aiTextureType_DISPLACEMENT, mesh);
+    TrySetTextureProperties(out_mat, layeredTextures, "NormalMap", aiTextureType_NORMALS, mesh);
+    TrySetTextureProperties(out_mat, layeredTextures, "Bump", aiTextureType_HEIGHT, mesh);
+    TrySetTextureProperties(out_mat, layeredTextures, "ShininessExponent", aiTextureType_SHININESS, mesh);
+    TrySetTextureProperties(out_mat, layeredTextures, "EmissiveFactor", aiTextureType_EMISSIVE, mesh);
+    TrySetTextureProperties(out_mat, layeredTextures, "TransparencyFactor", aiTextureType_OPACITY, mesh);
+    TrySetTextureProperties(out_mat, layeredTextures, "ReflectionFactor", aiTextureType_METALNESS, mesh);
+}
+
+aiColor3D FBXConverter::GetColorPropertyFactored(const PropertyTable &props, const std::string &colorName,
+        const std::string &factorName, bool &result, bool useTemplate) {
+    result = true;
+
+    bool ok;
+    aiVector3D BaseColor = PropertyGet<aiVector3D>(props, colorName, ok, useTemplate);
+    if (!ok) {
+        result = false;
+        return aiColor3D(0.0f, 0.0f, 0.0f);
+    }
+
+    // if no factor name, return the colour as is
+    if (factorName.empty()) {
+        return aiColor3D(BaseColor.x, BaseColor.y, BaseColor.z);
+    }
+
+    // otherwise it should be multiplied by the factor, if found.
+    float factor = PropertyGet<float>(props, factorName, ok, useTemplate);
+    if (ok) {
+        BaseColor *= factor;
+    }
+    return aiColor3D(BaseColor.x, BaseColor.y, BaseColor.z);
+}
+
+aiColor3D FBXConverter::GetColorPropertyFromMaterial(const PropertyTable &props, const std::string &baseName,
+        bool &result) {
+    return GetColorPropertyFactored(props, baseName + "Color", baseName + "Factor", result, true);
+}
+
+aiColor3D FBXConverter::GetColorProperty(const PropertyTable &props, const std::string &colorName,
+        bool &result, bool useTemplate) {
+    result = true;
+    bool ok;
+    const aiVector3D &ColorVec = PropertyGet<aiVector3D>(props, colorName, ok, useTemplate);
+    if (!ok) {
+        result = false;
+        return aiColor3D(0.0f, 0.0f, 0.0f);
+    }
+    return aiColor3D(ColorVec.x, ColorVec.y, ColorVec.z);
+}
+
+void FBXConverter::SetShadingPropertiesCommon(aiMaterial *out_mat, const PropertyTable &props) {
+    // Set shading properties.
+    // Modern FBX Files have two separate systems for defining these,
+    // with only the more comprehensive one described in the property template.
+    // Likely the other values are a legacy system,
+    // which is still always exported by the official FBX SDK.
+    //
+    // Blender's FBX import and export mostly ignore this legacy system,
+    // and as we only support recent versions of FBX anyway, we can do the same.
+    bool ok;
+
+    const aiColor3D &Diffuse = GetColorPropertyFromMaterial(props, "Diffuse", ok);
+    if (ok) {
+        out_mat->AddProperty(&Diffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
+    }
+
+    const aiColor3D &Emissive = GetColorPropertyFromMaterial(props, "Emissive", ok);
+    if (ok) {
+        out_mat->AddProperty(&Emissive, 1, AI_MATKEY_COLOR_EMISSIVE);
+    } else {
+        const aiColor3D &emissiveColor = GetColorProperty(props, "Maya|emissive", ok);
+        if (ok) {
+            out_mat->AddProperty(&emissiveColor, 1, AI_MATKEY_COLOR_EMISSIVE);
+        }
+     }
+
+    const aiColor3D &Ambient = GetColorPropertyFromMaterial(props, "Ambient", ok);
+    if (ok) {
+        out_mat->AddProperty(&Ambient, 1, AI_MATKEY_COLOR_AMBIENT);
+    }
+
+    // we store specular factor as SHININESS_STRENGTH, so just get the color
+    const aiColor3D &Specular = GetColorProperty(props, "SpecularColor", ok, true);
+    if (ok) {
+        out_mat->AddProperty(&Specular, 1, AI_MATKEY_COLOR_SPECULAR);
+    }
+
+    // and also try to get SHININESS_STRENGTH
+    const float SpecularFactor = PropertyGet<float>(props, "SpecularFactor", ok, true);
+    if (ok) {
+        out_mat->AddProperty(&SpecularFactor, 1, AI_MATKEY_SHININESS_STRENGTH);
+    }
+
+    // and the specular exponent
+    const float ShininessExponent = PropertyGet<float>(props, "ShininessExponent", ok);
+    if (ok) {
+        out_mat->AddProperty(&ShininessExponent, 1, AI_MATKEY_SHININESS);
+    }
+
+    // TransparentColor / TransparencyFactor... gee thanks FBX :rolleyes:
+    const aiColor3D &Transparent = GetColorPropertyFactored(props, "TransparentColor", "TransparencyFactor", ok);
+    float CalculatedOpacity = 1.0f;
+    if (ok) {
+        out_mat->AddProperty(&Transparent, 1, AI_MATKEY_COLOR_TRANSPARENT);
+        // as calculated by FBX SDK 2017:
+        CalculatedOpacity = 1.0f - ((Transparent.r + Transparent.g + Transparent.b) / 3.0f);
+    }
+
+    // try to get the transparency factor
+    const float TransparencyFactor = PropertyGet<float>(props, "TransparencyFactor", ok);
+    if (ok) {
+        out_mat->AddProperty(&TransparencyFactor, 1, AI_MATKEY_TRANSPARENCYFACTOR);
+    }
+
+    // use of TransparencyFactor is inconsistent.
+    // Maya always stores it as 1.0,
+    // so we can't use it to set AI_MATKEY_OPACITY.
+    // Blender is more sensible and stores it as the alpha value.
+    // However both the FBX SDK and Blender always write an additional
+    // legacy "Opacity" field, so we can try to use that.
+    //
+    // If we can't find it,
+    // we can fall back to the value which the FBX SDK calculates
+    // from transparency colour (RGB) and factor (F) as
+    // 1.0 - F*((R+G+B)/3).
+    //
+    // There's no consistent way to interpret this opacity value,
+    // so it's up to clients to do the correct thing.
+    const float Opacity = PropertyGet<float>(props, "Opacity", ok);
+    if (ok) {
+        out_mat->AddProperty(&Opacity, 1, AI_MATKEY_OPACITY);
+    } else if (CalculatedOpacity != 1.0) {
+        out_mat->AddProperty(&CalculatedOpacity, 1, AI_MATKEY_OPACITY);
+    }
+
+    // reflection color and factor are stored separately
+    const aiColor3D &Reflection = GetColorProperty(props, "ReflectionColor", ok, true);
+    if (ok) {
+        out_mat->AddProperty(&Reflection, 1, AI_MATKEY_COLOR_REFLECTIVE);
+    }
+
+    float ReflectionFactor = PropertyGet<float>(props, "ReflectionFactor", ok, true);
+    if (ok) {
+        out_mat->AddProperty(&ReflectionFactor, 1, AI_MATKEY_REFLECTIVITY);
+    }
+
+    const float BumpFactor = PropertyGet<float>(props, "BumpFactor", ok);
+    if (ok) {
+        out_mat->AddProperty(&BumpFactor, 1, AI_MATKEY_BUMPSCALING);
+    }
+
+    const float DispFactor = PropertyGet<float>(props, "DisplacementFactor", ok);
+    if (ok) {
+        out_mat->AddProperty(&DispFactor, 1, "$mat.displacementscaling", 0, 0);
+    }
+
+    // PBR material information
+    const aiColor3D &baseColor = GetColorProperty(props, "Maya|base_color", ok);
+    if (ok) {
+        out_mat->AddProperty(&baseColor, 1, AI_MATKEY_BASE_COLOR);
+    }
+
+    const float useColorMap = PropertyGet<float>(props, "Maya|use_color_map", ok);
+    if (ok) {
+        out_mat->AddProperty(&useColorMap, 1, AI_MATKEY_USE_COLOR_MAP);
+    }
+
+    const float useMetallicMap = PropertyGet<float>(props, "Maya|use_metallic_map", ok);
+    if (ok) {
+        out_mat->AddProperty(&useMetallicMap, 1, AI_MATKEY_USE_METALLIC_MAP);
+    }
+
+    const float metallicFactor = PropertyGet<float>(props, "Maya|metallic", ok);
+    if (ok) {
+        out_mat->AddProperty(&metallicFactor, 1, AI_MATKEY_METALLIC_FACTOR);
+    }
+
+    const float useRoughnessMap = PropertyGet<float>(props, "Maya|use_roughness_map", ok);
+    if (ok) {
+        out_mat->AddProperty(&useRoughnessMap, 1, AI_MATKEY_USE_ROUGHNESS_MAP);
+    }
+
+    const float roughnessFactor = PropertyGet<float>(props, "Maya|roughness", ok);
+    if (ok) {
+        out_mat->AddProperty(&roughnessFactor, 1, AI_MATKEY_ROUGHNESS_FACTOR);
+    }
+
+    const float useEmissiveMap = PropertyGet<float>(props, "Maya|use_emissive_map", ok);
+    if (ok) {
+        out_mat->AddProperty(&useEmissiveMap, 1, AI_MATKEY_USE_EMISSIVE_MAP);
+    }
+
+    const float emissiveIntensity = PropertyGet<float>(props, "Maya|emissive_intensity", ok);
+    if (ok) {
+        out_mat->AddProperty(&emissiveIntensity, 1, AI_MATKEY_EMISSIVE_INTENSITY);
+    }
+
+    const float useAOMap = PropertyGet<float>(props, "Maya|use_ao_map", ok);
+    if (ok) {
+        out_mat->AddProperty(&useAOMap, 1, AI_MATKEY_USE_AO_MAP);
+    }
+}
+
+void FBXConverter::SetShadingPropertiesRaw(aiMaterial *out_mat, const PropertyTable &props, const TextureMap &_textures, const MeshGeometry *const mesh) {
+    // Add all the unparsed properties with a "$raw." prefix
+
+    const std::string prefix = "$raw.";
+
+    for (const DirectPropertyMap::value_type &prop : props.GetUnparsedProperties()) {
+
+        std::string name = prefix + prop.first;
+
+        if (const TypedProperty<aiVector3D> *interpretedVec3 = prop.second->As<TypedProperty<aiVector3D>>()) {
+            out_mat->AddProperty(&interpretedVec3->Value(), 1, name.c_str(), 0, 0);
+        } else if (const TypedProperty<aiColor3D> *interpretedCol3 = prop.second->As<TypedProperty<aiColor3D>>()) {
+            out_mat->AddProperty(&interpretedCol3->Value(), 1, name.c_str(), 0, 0);
+        } else if (const TypedProperty<aiColor4D> *interpretedCol4 = prop.second->As<TypedProperty<aiColor4D>>()) {
+            out_mat->AddProperty(&interpretedCol4->Value(), 1, name.c_str(), 0, 0);
+        } else if (const TypedProperty<float> *interpretedFloat = prop.second->As<TypedProperty<float>>()) {
+            out_mat->AddProperty(&interpretedFloat->Value(), 1, name.c_str(), 0, 0);
+        } else if (const TypedProperty<int> *interpretedInt = prop.second->As<TypedProperty<int>>()) {
+            out_mat->AddProperty(&interpretedInt->Value(), 1, name.c_str(), 0, 0);
+        } else if (const TypedProperty<bool> *interpretedBool = prop.second->As<TypedProperty<bool>>()) {
+            int value = interpretedBool->Value() ? 1 : 0;
+            out_mat->AddProperty(&value, 1, name.c_str(), 0, 0);
+        } else if (const TypedProperty<std::string> *interpretedString = prop.second->As<TypedProperty<std::string>>()) {
+            const aiString value = aiString(interpretedString->Value());
+            out_mat->AddProperty(&value, name.c_str(), 0, 0);
+        }
+    }
+
+    // Add the textures' properties
+
+    for (TextureMap::const_iterator it = _textures.begin(); it != _textures.end(); ++it) {
+
+        std::string name = prefix + it->first;
+
+        const Texture *const tex = it->second;
+        if (tex != nullptr) {
+            aiString path;
+            path.Set(tex->RelativeFilename());
+
+            const Video *media = tex->Media();
+            if (media != nullptr && media->ContentLength() > 0) {
+                unsigned int index;
+
+                VideoMap::const_iterator videoIt = textures_converted.find(media);
+                if (videoIt != textures_converted.end()) {
+                    index = videoIt->second;
+                } else {
+                    index = ConvertVideo(*media);
+                    textures_converted[media] = index;
+                }
+
+                // setup texture reference string (copied from ColladaLoader::FindFilenameForEffectTexture)
+                path.data[0] = '*';
+                path.length = 1 + ASSIMP_itoa10(path.data + 1, MAXLEN - 1, index);
+            }
+
+            out_mat->AddProperty(&path, (name + "|file").c_str(), aiTextureType_UNKNOWN, 0);
+
+            aiUVTransform uvTrafo;
+            // XXX handle all kinds of UV transformations
+            uvTrafo.mScaling = tex->UVScaling();
+            uvTrafo.mTranslation = tex->UVTranslation();
+            uvTrafo.mRotation = tex->UVRotation();
+            out_mat->AddProperty(&uvTrafo, 1, (name + "|uvtrafo").c_str(), aiTextureType_UNKNOWN, 0);
+
+            int uvIndex = 0;
+
+            bool uvFound = false;
+            const std::string &uvSet = PropertyGet<std::string>(tex->Props(), "UVSet", uvFound);
+            if (uvFound) {
+                // "default" is the name which usually appears in the FbxFileTexture template
+                if (uvSet != "default" && uvSet.length()) {
+                    // this is a bit awkward - we need to find a mesh that uses this
+                    // material and scan its UV channels for the given UV name because
+                    // assimp references UV channels by index, not by name.
+
+                    // XXX: the case that UV channels may appear in different orders
+                    // in meshes is unhandled. A possible solution would be to sort
+                    // the UV channels alphabetically, but this would have the side
+                    // effect that the primary (first) UV channel would sometimes
+                    // be moved, causing trouble when users read only the first
+                    // UV channel and ignore UV channel assignments altogether.
+
+                    std::vector<aiMaterial *>::iterator materialIt = std::find(materials.begin(), materials.end(), out_mat);
+                    const unsigned int matIndex = static_cast<unsigned int>(std::distance(materials.begin(), materialIt));
+
+                    uvIndex = -1;
+                    if (!mesh) {
+                        for (const MeshMap::value_type &v : meshes_converted) {
+                            const MeshGeometry *const meshGeom = dynamic_cast<const MeshGeometry *>(v.first);
+                            if (!meshGeom) {
+                                continue;
+                            }
+
+                            const MatIndexArray &mats = meshGeom->GetMaterialIndices();
+                            if (std::find(mats.begin(), mats.end(), (int)matIndex) == mats.end()) {
+                                continue;
+                            }
+
+                            int index = -1;
+                            for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
+                                if (meshGeom->GetTextureCoords(i).empty()) {
+                                    break;
+                                }
+                                const std::string &curName = meshGeom->GetTextureCoordChannelName(i);
+                                if (curName == uvSet) {
+                                    index = static_cast<int>(i);
+                                    break;
+                                }
+                            }
+                            if (index == -1) {
+                                FBXImporter::LogWarn("did not find UV channel named ", uvSet, " in a mesh using this material");
+                                continue;
+                            }
+
+                            if (uvIndex == -1) {
+                                uvIndex = index;
+                            } else {
+                                FBXImporter::LogWarn("the UV channel named ", uvSet, " appears at different positions in meshes, results will be wrong");
+                            }
+                        }
+                    } else {
+                        int index = -1;
+                        for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
+                            if (mesh->GetTextureCoords(i).empty()) {
+                                break;
+                            }
+                            const std::string &curName = mesh->GetTextureCoordChannelName(i);
+                            if (curName == uvSet) {
+                                index = static_cast<int>(i);
+                                break;
+                            }
+                        }
+                        if (index == -1) {
+                            FBXImporter::LogWarn("did not find UV channel named ", uvSet, " in a mesh using this material");
+                        }
+
+                        if (uvIndex == -1) {
+                            uvIndex = index;
+                        }
+                    }
+
+                    if (uvIndex == -1) {
+                        FBXImporter::LogWarn("failed to resolve UV channel ", uvSet, ", using first UV channel");
+                        uvIndex = 0;
+                    }
+                }
+            }
+
+            out_mat->AddProperty(&uvIndex, 1, (name + "|uvwsrc").c_str(), aiTextureType_UNKNOWN, 0);
+        }
+    }
+}
+
+double FBXConverter::FrameRateToDouble(FileGlobalSettings::FrameRate fp, double customFPSVal) {
+    switch (fp) {
+        case FileGlobalSettings::FrameRate_DEFAULT:
+            return 1.0;
+
+        case FileGlobalSettings::FrameRate_120:
+            return 120.0;
+
+        case FileGlobalSettings::FrameRate_100:
+            return 100.0;
+
+        case FileGlobalSettings::FrameRate_60:
+            return 60.0;
+
+        case FileGlobalSettings::FrameRate_50:
+            return 50.0;
+
+        case FileGlobalSettings::FrameRate_48:
+            return 48.0;
+
+        case FileGlobalSettings::FrameRate_30:
+        case FileGlobalSettings::FrameRate_30_DROP:
+            return 30.0;
+
+        case FileGlobalSettings::FrameRate_NTSC_DROP_FRAME:
+        case FileGlobalSettings::FrameRate_NTSC_FULL_FRAME:
+            return 29.9700262;
+
+        case FileGlobalSettings::FrameRate_PAL:
+            return 25.0;
+
+        case FileGlobalSettings::FrameRate_CINEMA:
+            return 24.0;
+
+        case FileGlobalSettings::FrameRate_1000:
+            return 1000.0;
+
+        case FileGlobalSettings::FrameRate_CINEMA_ND:
+            return 23.976;
+
+        case FileGlobalSettings::FrameRate_CUSTOM:
+            return customFPSVal;
+
+        case FileGlobalSettings::FrameRate_MAX: // this is to silence compiler warnings
+            break;
+    }
+
+    ai_assert(false);
+
+    return -1.0f;
+}
+
+void FBXConverter::ConvertAnimations() {
+    // first of all determine framerate
+    const FileGlobalSettings::FrameRate fps = doc.GlobalSettings().TimeMode();
+    const float custom = doc.GlobalSettings().CustomFrameRate();
+    anim_fps = FrameRateToDouble(fps, custom);
+
+    const std::vector<const AnimationStack *> &curAnimations = doc.AnimationStacks();
+    for (const AnimationStack *stack : curAnimations) {
+        ConvertAnimationStack(*stack);
+    }
+}
+
+std::string FBXConverter::FixNodeName(const std::string &name) {
+    // strip Model:: prefix, avoiding ambiguities (i.e. don't strip if
+    // this causes ambiguities, well possible between empty identifiers,
+    // such as "Model::" and ""). Make sure the behaviour is consistent
+    // across multiple calls to FixNodeName().
+    if (name.substr(0, 7) == "Model::") {
+        std::string temp = name.substr(7);
+        return temp;
+    }
+
+    return name;
+}
+
+std::string FBXConverter::FixAnimMeshName(const std::string &name) {
+    if (name.length()) {
+        size_t indexOf = name.find_first_of("::");
+        if (indexOf != std::string::npos && indexOf < name.size() - 2) {
+            return name.substr(indexOf + 2);
+        }
+    }
+    return name.length() ? name : "AnimMesh";
+}
+
+void FBXConverter::ConvertAnimationStack(const AnimationStack &st) {
+    const AnimationLayerList &layers = st.Layers();
+    if (layers.empty()) {
+        return;
+    }
+
+    aiAnimation *const anim = new aiAnimation();
+    animations.push_back(anim);
+
+    // strip AnimationStack:: prefix
+    std::string name = st.Name();
+    if (name.substr(0, 16) == "AnimationStack::") {
+        name = name.substr(16);
+    } else if (name.substr(0, 11) == "AnimStack::") {
+        name = name.substr(11);
+    }
+
+    anim->mName.Set(name);
+
+    // need to find all nodes for which we need to generate node animations -
+    // it may happen that we need to merge multiple layers, though.
+    NodeMap node_map;
+
+    // reverse mapping from curves to layers, much faster than querying
+    // the FBX DOM for it.
+    LayerMap layer_map;
+
+    const char *prop_whitelist[] = {
+        "Lcl Scaling",
+        "Lcl Rotation",
+        "Lcl Translation",
+        "DeformPercent"
+    };
+
+    std::map<std::string, morphAnimData *> morphAnimDatas;
+
+    for (const AnimationLayer *layer : layers) {
+        ai_assert(layer);
+        const AnimationCurveNodeList &nodes = layer->Nodes(prop_whitelist, 4);
+        for (const AnimationCurveNode *node : nodes) {
+            ai_assert(node);
+            const Model *const model = dynamic_cast<const Model *>(node->Target());
+            if (model) {
+                const std::string &curName = FixNodeName(model->Name());
+                node_map[curName].push_back(node);
+                layer_map[node] = layer;
+                continue;
+            }
+            const BlendShapeChannel *const bsc = dynamic_cast<const BlendShapeChannel *>(node->Target());
+            if (bsc) {
+                ProcessMorphAnimDatas(&morphAnimDatas, bsc, node);
+            }
+        }
+    }
+
+    // generate node animations
+    std::vector<aiNodeAnim *> node_anims;
+
+    double min_time = 1e10;
+    double max_time = -1e10;
+
+    int64_t start_time = st.LocalStart();
+    int64_t stop_time = st.LocalStop();
+    bool has_local_startstop = start_time != 0 || stop_time != 0;
+    if (!has_local_startstop) {
+        // no time range given, so accept every keyframe and use the actual min/max time
+        // the numbers are INT64_MIN/MAX, the 20000 is for safety because GenerateNodeAnimations uses an epsilon of 10000
+        start_time = -9223372036854775807ll + 20000;
+        stop_time = 9223372036854775807ll - 20000;
+    }
+
+    try {
+        for (const NodeMap::value_type &kv : node_map) {
+            GenerateNodeAnimations(node_anims,
+                    kv.first,
+                    kv.second,
+                    layer_map,
+                    start_time, stop_time,
+                    max_time,
+                    min_time);
+        }
+    } catch (std::exception &) {
+        std::for_each(node_anims.begin(), node_anims.end(), Util::delete_fun<aiNodeAnim>());
+        throw;
+    }
+
+    if (node_anims.size() || morphAnimDatas.size()) {
+        if (node_anims.size()) {
+            anim->mChannels = new aiNodeAnim *[node_anims.size()]();
+            anim->mNumChannels = static_cast<unsigned int>(node_anims.size());
+            std::swap_ranges(node_anims.begin(), node_anims.end(), anim->mChannels);
+        }
+        if (morphAnimDatas.size()) {
+            unsigned int numMorphMeshChannels = static_cast<unsigned int>(morphAnimDatas.size());
+            anim->mMorphMeshChannels = new aiMeshMorphAnim *[numMorphMeshChannels];
+            anim->mNumMorphMeshChannels = numMorphMeshChannels;
+            unsigned int i = 0;
+            for (const auto &morphAnimIt : morphAnimDatas) {
+                morphAnimData *animData = morphAnimIt.second;
+                unsigned int numKeys = static_cast<unsigned int>(animData->size());
+                aiMeshMorphAnim *meshMorphAnim = new aiMeshMorphAnim();
+                meshMorphAnim->mName.Set(morphAnimIt.first);
+                meshMorphAnim->mNumKeys = numKeys;
+                meshMorphAnim->mKeys = new aiMeshMorphKey[numKeys];
+                unsigned int j = 0;
+                for (auto animIt : *animData) {
+                    morphKeyData *keyData = animIt.second;
+                    unsigned int numValuesAndWeights = static_cast<unsigned int>(keyData->values.size());
+                    meshMorphAnim->mKeys[j].mNumValuesAndWeights = numValuesAndWeights;
+                    meshMorphAnim->mKeys[j].mValues = new unsigned int[numValuesAndWeights];
+                    meshMorphAnim->mKeys[j].mWeights = new double[numValuesAndWeights];
+                    meshMorphAnim->mKeys[j].mTime = CONVERT_FBX_TIME(animIt.first) * anim_fps;
+                    for (unsigned int k = 0; k < numValuesAndWeights; k++) {
+                        meshMorphAnim->mKeys[j].mValues[k] = keyData->values.at(k);
+                        meshMorphAnim->mKeys[j].mWeights[k] = keyData->weights.at(k);
+                    }
+                    j++;
+                }
+                anim->mMorphMeshChannels[i++] = meshMorphAnim;
+            }
+        }
+    } else {
+        // empty animations would fail validation, so drop them
+        delete anim;
+        animations.pop_back();
+        FBXImporter::LogInfo("ignoring empty AnimationStack (using IK?): ", name);
+        return;
+    }
+
+    double start_time_fps = has_local_startstop ? (CONVERT_FBX_TIME(start_time) * anim_fps) : min_time;
+    double stop_time_fps = has_local_startstop ? (CONVERT_FBX_TIME(stop_time) * anim_fps) : max_time;
+
+    // adjust relative timing for animation
+    for (unsigned int c = 0; c < anim->mNumChannels; c++) {
+        aiNodeAnim *channel = anim->mChannels[c];
+        for (uint32_t i = 0; i < channel->mNumPositionKeys; i++) {
+            channel->mPositionKeys[i].mTime -= start_time_fps;
+        }
+        for (uint32_t i = 0; i < channel->mNumRotationKeys; i++) {
+            channel->mRotationKeys[i].mTime -= start_time_fps;
+        }
+        for (uint32_t i = 0; i < channel->mNumScalingKeys; i++) {
+            channel->mScalingKeys[i].mTime -= start_time_fps;
+        }
+    }
+    for (unsigned int c = 0; c < anim->mNumMorphMeshChannels; c++) {
+        aiMeshMorphAnim *channel = anim->mMorphMeshChannels[c];
+        for (uint32_t i = 0; i < channel->mNumKeys; i++) {
+            channel->mKeys[i].mTime -= start_time_fps;
+        }
+    }
+
+    // for some mysterious reason, mDuration is simply the maximum key -- the
+    // validator always assumes animations to start at zero.
+    anim->mDuration = stop_time_fps - start_time_fps;
+    anim->mTicksPerSecond = anim_fps;
+}
+
+// ------------------------------------------------------------------------------------------------
+void FBXConverter::ProcessMorphAnimDatas(std::map<std::string, morphAnimData *> *morphAnimDatas, const BlendShapeChannel *bsc, const AnimationCurveNode *node) {
+    std::vector<const Connection *> bscConnections = doc.GetConnectionsBySourceSequenced(bsc->ID(), "Deformer");
+    for (const Connection *bscConnection : bscConnections) {
+        auto bs = dynamic_cast<const BlendShape *>(bscConnection->DestinationObject());
+        if (bs) {
+            auto channelIt = std::find(bs->BlendShapeChannels().begin(), bs->BlendShapeChannels().end(), bsc);
+            if (channelIt != bs->BlendShapeChannels().end()) {
+                auto channelIndex = static_cast<unsigned int>(std::distance(bs->BlendShapeChannels().begin(), channelIt));
+                std::vector<const Connection *> bsConnections = doc.GetConnectionsBySourceSequenced(bs->ID(), "Geometry");
+                for (const Connection *bsConnection : bsConnections) {
+                    auto geo = dynamic_cast<const Geometry *>(bsConnection->DestinationObject());
+                    if (geo) {
+                        std::vector<const Connection *> geoConnections = doc.GetConnectionsBySourceSequenced(geo->ID(), "Model");
+                        for (const Connection *geoConnection : geoConnections) {
+                            auto model = dynamic_cast<const Model *>(geoConnection->DestinationObject());
+                            if (model) {
+                                auto geoIt = std::find(model->GetGeometry().begin(), model->GetGeometry().end(), geo);
+                                auto geoIndex = static_cast<unsigned int>(std::distance(model->GetGeometry().begin(), geoIt));
+                                auto name = aiString(FixNodeName(model->Name() + "*"));
+                                name.length = 1 + ASSIMP_itoa10(name.data + name.length, MAXLEN - 1, geoIndex);
+                                morphAnimData *animData;
+                                auto animIt = morphAnimDatas->find(name.C_Str());
+                                if (animIt == morphAnimDatas->end()) {
+                                    animData = new morphAnimData();
+                                    morphAnimDatas->insert(std::make_pair(name.C_Str(), animData));
+                                } else {
+                                    animData = animIt->second;
+                                }
+                                for (std::pair<std::string, const AnimationCurve *> curvesIt : node->Curves()) {
+                                    if (curvesIt.first == "d|DeformPercent") {
+                                        const AnimationCurve *animationCurve = curvesIt.second;
+                                        const KeyTimeList &keys = animationCurve->GetKeys();
+                                        const KeyValueList &values = animationCurve->GetValues();
+                                        unsigned int k = 0;
+                                        for (auto key : keys) {
+                                            morphKeyData *keyData;
+                                            auto keyIt = animData->find(key);
+                                            if (keyIt == animData->end()) {
+                                                keyData = new morphKeyData();
+                                                animData->insert(std::make_pair(key, keyData));
+                                            } else {
+                                                keyData = keyIt->second;
+                                            }
+                                            keyData->values.push_back(channelIndex);
+                                            keyData->weights.push_back(values.at(k) / 100.0f);
+                                            k++;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+#ifdef ASSIMP_BUILD_DEBUG
+// ------------------------------------------------------------------------------------------------
+// sanity check whether the input is ok
+static void validateAnimCurveNodes(const std::vector<const AnimationCurveNode *> &curves,
+        bool strictMode) {
+    const Object *target(nullptr);
+    for (const AnimationCurveNode *node : curves) {
+        if (!target) {
+            target = node->Target();
+        }
+        if (node->Target() != target) {
+            FBXImporter::LogWarn("Node target is nullptr type.");
+        }
+        if (strictMode) {
+            ai_assert(node->Target() == target);
+        }
+    }
+}
+#endif // ASSIMP_BUILD_DEBUG
+
+// ------------------------------------------------------------------------------------------------
+void FBXConverter::GenerateNodeAnimations(std::vector<aiNodeAnim *> &node_anims,
+        const std::string &fixed_name,
+        const std::vector<const AnimationCurveNode *> &curves,
+        const LayerMap &layer_map,
+        int64_t start, int64_t stop,
+        double &max_time,
+        double &min_time) {
+
+    NodeMap node_property_map;
+    ai_assert(curves.size());
+
+#ifdef ASSIMP_BUILD_DEBUG
+    validateAnimCurveNodes(curves, doc.Settings().strictMode);
+#endif
+    const AnimationCurveNode *curve_node = nullptr;
+    for (const AnimationCurveNode *node : curves) {
+        ai_assert(node);
+
+        if (node->TargetProperty().empty()) {
+            FBXImporter::LogWarn("target property for animation curve not set: ", node->Name());
+            continue;
+        }
+
+        curve_node = node;
+        if (node->Curves().empty()) {
+            FBXImporter::LogWarn("no animation curves assigned to AnimationCurveNode: ", node->Name());
+            continue;
+        }
+
+        node_property_map[node->TargetProperty()].push_back(node);
+    }
+
+    ai_assert(curve_node);
+    ai_assert(curve_node->TargetAsModel());
+
+    const Model &target = *curve_node->TargetAsModel();
+
+    // check for all possible transformation components
+    NodeMap::const_iterator chain[TransformationComp_MAXIMUM];
+
+    bool has_any = false;
+    bool has_complex = false;
+
+    for (size_t i = 0; i < TransformationComp_MAXIMUM; ++i) {
+        const TransformationComp comp = static_cast<TransformationComp>(i);
+
+        // inverse pivots don't exist in the input, we just generate them
+        if (comp == TransformationComp_RotationPivotInverse || comp == TransformationComp_ScalingPivotInverse) {
+            chain[i] = node_property_map.end();
+            continue;
+        }
+
+        chain[i] = node_property_map.find(NameTransformationCompProperty(comp));
+        if (chain[i] != node_property_map.end()) {
+
+            // check if this curves contains redundant information by looking
+            // up the corresponding node's transformation chain.
+            if (doc.Settings().optimizeEmptyAnimationCurves &&
+                    IsRedundantAnimationData(target, comp, (chain[i]->second))) {
+
+                FBXImporter::LogVerboseDebug("dropping redundant animation channel for node ", target.Name());
+                continue;
+            }
+
+            has_any = true;
+
+            if (comp != TransformationComp_Rotation && comp != TransformationComp_Scaling && comp != TransformationComp_Translation) {
+                has_complex = true;
+            }
+        }
+    }
+
+    if (!has_any) {
+        FBXImporter::LogWarn("ignoring node animation, did not find any transformation key frames");
+        return;
+    }
+
+    // this needs to play nicely with GenerateTransformationNodeChain() which will
+    // be invoked _later_ (animations come first). If this node has only rotation,
+    // scaling and translation _and_ there are no animated other components either,
+    // we can use a single node and also a single node animation channel.
+    if( !has_complex && !NeedsComplexTransformationChain(target)) {
+        aiNodeAnim* const nd = GenerateSimpleNodeAnim(fixed_name, target, chain,
+                node_property_map.end(),
+                start, stop,
+                max_time,
+                min_time
+        );
+
+        ai_assert(nd);
+        if (nd->mNumPositionKeys == 0 && nd->mNumRotationKeys == 0 && nd->mNumScalingKeys == 0) {
+            delete nd;
+        } else {
+            node_anims.push_back(nd);
+        }
+        return;
+    }
+
+    // otherwise, things get gruesome and we need separate animation channels
+    // for each part of the transformation chain. Remember which channels
+    // we generated and pass this information to the node conversion
+    // code to avoid nodes that have identity transform, but non-identity
+    // animations, being dropped.
+    unsigned int flags = 0, bit = 0x1;
+    for (size_t i = 0; i < TransformationComp_MAXIMUM; ++i, bit <<= 1) {
+        const TransformationComp comp = static_cast<TransformationComp>(i);
+
+        if (chain[i] != node_property_map.end()) {
+            flags |= bit;
+
+            ai_assert(comp != TransformationComp_RotationPivotInverse);
+            ai_assert(comp != TransformationComp_ScalingPivotInverse);
+
+            const std::string &chain_name = NameTransformationChainNode(fixed_name, comp);
+
+            aiNodeAnim *na = nullptr;
+            switch (comp) {
+                case TransformationComp_Rotation:
+                case TransformationComp_PreRotation:
+                case TransformationComp_PostRotation:
+                case TransformationComp_GeometricRotation:
+                    na = GenerateRotationNodeAnim(chain_name,
+                            target,
+                            (*chain[i]).second,
+                            layer_map,
+                            start, stop,
+                            max_time,
+                            min_time);
+
+                    break;
+
+                case TransformationComp_RotationOffset:
+                case TransformationComp_RotationPivot:
+                case TransformationComp_ScalingOffset:
+                case TransformationComp_ScalingPivot:
+                case TransformationComp_Translation:
+                case TransformationComp_GeometricTranslation:
+                    na = GenerateTranslationNodeAnim(chain_name,
+                            target,
+                            (*chain[i]).second,
+                            layer_map,
+                            start, stop,
+                            max_time,
+                            min_time);
+
+                    // pivoting requires us to generate an implicit inverse channel to undo the pivot translation
+                    if (comp == TransformationComp_RotationPivot) {
+                        const std::string &invName = NameTransformationChainNode(fixed_name,
+                                TransformationComp_RotationPivotInverse);
+
+                        aiNodeAnim *const inv = GenerateTranslationNodeAnim(invName,
+                                target,
+                                (*chain[i]).second,
+                                layer_map,
+                                start, stop,
+                                max_time,
+                                min_time,
+                                true);
+
+                        ai_assert(inv);
+                        if (inv->mNumPositionKeys == 0 && inv->mNumRotationKeys == 0 && inv->mNumScalingKeys == 0) {
+                            delete inv;
+                        } else {
+                            node_anims.push_back(inv);
+                        }
+
+                        ai_assert(TransformationComp_RotationPivotInverse > i);
+                        flags |= bit << (TransformationComp_RotationPivotInverse - i);
+                    } else if (comp == TransformationComp_ScalingPivot) {
+                        const std::string &invName = NameTransformationChainNode(fixed_name,
+                                TransformationComp_ScalingPivotInverse);
+
+                        aiNodeAnim *const inv = GenerateTranslationNodeAnim(invName,
+                                target,
+                                (*chain[i]).second,
+                                layer_map,
+                                start, stop,
+                                max_time,
+                                min_time,
+                                true);
+
+                        ai_assert(inv);
+                        if (inv->mNumPositionKeys == 0 && inv->mNumRotationKeys == 0 && inv->mNumScalingKeys == 0) {
+                            delete inv;
+                        } else {
+                            node_anims.push_back(inv);
+                        }
+
+                        ai_assert(TransformationComp_RotationPivotInverse > i);
+                        flags |= bit << (TransformationComp_RotationPivotInverse - i);
+                    }
+
+                    break;
+
+                case TransformationComp_Scaling:
+                case TransformationComp_GeometricScaling:
+                    na = GenerateScalingNodeAnim(chain_name,
+                            target,
+                            (*chain[i]).second,
+                            layer_map,
+                            start, stop,
+                            max_time,
+                            min_time);
+
+                    break;
+
+                default:
+                    ai_assert(false);
+            }
+
+            ai_assert(na);
+            if (na->mNumPositionKeys == 0 && na->mNumRotationKeys == 0 && na->mNumScalingKeys == 0) {
+                delete na;
+            } else {
+                node_anims.push_back(na);
+            }
+            continue;
+        }
+    }
+
+    node_anim_chain_bits[fixed_name] = flags;
+}
+
+bool FBXConverter::IsRedundantAnimationData(const Model &target,
+        TransformationComp comp,
+        const std::vector<const AnimationCurveNode *> &curves) {
+    ai_assert(curves.size());
+
+    // look for animation nodes with
+    //  * sub channels for all relevant components set
+    //  * one key/value pair per component
+    //  * combined values match up the corresponding value in the bind pose node transformation
+    // only such nodes are 'redundant' for this function.
+
+    if (curves.size() > 1) {
+        return false;
+    }
+
+    const AnimationCurveNode &nd = *curves.front();
+    const AnimationCurveMap &sub_curves = nd.Curves();
+
+    const AnimationCurveMap::const_iterator dx = sub_curves.find("d|X");
+    const AnimationCurveMap::const_iterator dy = sub_curves.find("d|Y");
+    const AnimationCurveMap::const_iterator dz = sub_curves.find("d|Z");
+
+    if (dx == sub_curves.end() || dy == sub_curves.end() || dz == sub_curves.end()) {
+        return false;
+    }
+
+    const KeyValueList &vx = (*dx).second->GetValues();
+    const KeyValueList &vy = (*dy).second->GetValues();
+    const KeyValueList &vz = (*dz).second->GetValues();
+
+    if (vx.size() != 1 || vy.size() != 1 || vz.size() != 1) {
+        return false;
+    }
+
+    const aiVector3D dyn_val = aiVector3D(vx[0], vy[0], vz[0]);
+    const aiVector3D &static_val = PropertyGet<aiVector3D>(target.Props(),
+            NameTransformationCompProperty(comp),
+            TransformationCompDefaultValue(comp));
+
+    const float epsilon = Math::getEpsilon<float>();
+    return (dyn_val - static_val).SquareLength() < epsilon;
+}
+
+aiNodeAnim *FBXConverter::GenerateRotationNodeAnim(const std::string &name,
+        const Model &target,
+        const std::vector<const AnimationCurveNode *> &curves,
+        const LayerMap &layer_map,
+        int64_t start, int64_t stop,
+        double &max_time,
+        double &min_time) {
+    std::unique_ptr<aiNodeAnim> na(new aiNodeAnim());
+    na->mNodeName.Set(name);
+
+    ConvertRotationKeys(na.get(), curves, layer_map, start, stop, max_time, min_time, target.RotationOrder());
+
+    // dummy scaling key
+    na->mScalingKeys = new aiVectorKey[1];
+    na->mNumScalingKeys = 1;
+
+    na->mScalingKeys[0].mTime = 0.;
+    na->mScalingKeys[0].mValue = aiVector3D(1.0f, 1.0f, 1.0f);
+
+    // dummy position key
+    na->mPositionKeys = new aiVectorKey[1];
+    na->mNumPositionKeys = 1;
+
+    na->mPositionKeys[0].mTime = 0.;
+    na->mPositionKeys[0].mValue = aiVector3D();
+
+    return na.release();
+}
+
+aiNodeAnim *FBXConverter::GenerateScalingNodeAnim(const std::string &name,
+        const Model & /*target*/,
+        const std::vector<const AnimationCurveNode *> &curves,
+        const LayerMap &layer_map,
+        int64_t start, int64_t stop,
+        double &max_time,
+        double &min_time) {
+    std::unique_ptr<aiNodeAnim> na(new aiNodeAnim());
+    na->mNodeName.Set(name);
+
+    ConvertScaleKeys(na.get(), curves, layer_map, start, stop, max_time, min_time);
+
+    // dummy rotation key
+    na->mRotationKeys = new aiQuatKey[1];
+    na->mNumRotationKeys = 1;
+
+    na->mRotationKeys[0].mTime = 0.;
+    na->mRotationKeys[0].mValue = aiQuaternion();
+
+    // dummy position key
+    na->mPositionKeys = new aiVectorKey[1];
+    na->mNumPositionKeys = 1;
+
+    na->mPositionKeys[0].mTime = 0.;
+    na->mPositionKeys[0].mValue = aiVector3D();
+
+    return na.release();
+}
+
+aiNodeAnim *FBXConverter::GenerateTranslationNodeAnim(const std::string &name,
+        const Model & /*target*/,
+        const std::vector<const AnimationCurveNode *> &curves,
+        const LayerMap &layer_map,
+        int64_t start, int64_t stop,
+        double &max_time,
+        double &min_time,
+        bool inverse) {
+    std::unique_ptr<aiNodeAnim> na(new aiNodeAnim());
+    na->mNodeName.Set(name);
+
+    ConvertTranslationKeys(na.get(), curves, layer_map, start, stop, max_time, min_time);
+
+    if (inverse) {
+        for (unsigned int i = 0; i < na->mNumPositionKeys; ++i) {
+            na->mPositionKeys[i].mValue *= -1.0f;
+        }
+    }
+
+    // dummy scaling key
+    na->mScalingKeys = new aiVectorKey[1];
+    na->mNumScalingKeys = 1;
+
+    na->mScalingKeys[0].mTime = 0.;
+    na->mScalingKeys[0].mValue = aiVector3D(1.0f, 1.0f, 1.0f);
+
+    // dummy rotation key
+    na->mRotationKeys = new aiQuatKey[1];
+    na->mNumRotationKeys = 1;
+
+    na->mRotationKeys[0].mTime = 0.;
+    na->mRotationKeys[0].mValue = aiQuaternion();
+
+    return na.release();
+}
+
+aiNodeAnim* FBXConverter::GenerateSimpleNodeAnim(const std::string& name,
+        const Model& target,
+        NodeMap::const_iterator chain[TransformationComp_MAXIMUM],
+        NodeMap::const_iterator iterEnd,
+        int64_t start, int64_t stop,
+        double& maxTime,
+        double& minTime)
+{
+    std::unique_ptr<aiNodeAnim> na(new aiNodeAnim());
+    na->mNodeName.Set(name);
+
+    const PropertyTable &props = target.Props();
+
+    // collect unique times and keyframe lists
+    KeyFrameListList keyframeLists[TransformationComp_MAXIMUM];
+    KeyTimeList keytimes;
+
+    for (size_t i = 0; i < TransformationComp_MAXIMUM; ++i) {
+        if (chain[i] == iterEnd)
+            continue;
+
+        if (i == TransformationComp_Rotation || i == TransformationComp_PreRotation
+                || i == TransformationComp_PostRotation || i == TransformationComp_GeometricRotation) {
+            keyframeLists[i] = GetRotationKeyframeList((*chain[i]).second, start, stop);
+        } else {
+            keyframeLists[i] = GetKeyframeList((*chain[i]).second, start, stop);
+        }
+
+        for (KeyFrameListList::const_iterator it = keyframeLists[i].begin(); it != keyframeLists[i].end(); ++it) {
+            const KeyTimeList& times = *std::get<0>(*it);
+            keytimes.insert(keytimes.end(), times.begin(), times.end());
+        }
+
+        // remove duplicates
+        std::sort(keytimes.begin(), keytimes.end());
+
+        auto last = std::unique(keytimes.begin(), keytimes.end());
+        keytimes.erase(last, keytimes.end());
+    }
+
+    const Model::RotOrder rotOrder = target.RotationOrder();
+    const size_t keyCount = keytimes.size();
+
+    aiVector3D defTranslate = PropertyGet(props, "Lcl Translation", aiVector3D(0.f, 0.f, 0.f));
+    aiVector3D defRotation = PropertyGet(props, "Lcl Rotation", aiVector3D(0.f, 0.f, 0.f));
+    aiVector3D defScale = PropertyGet(props, "Lcl Scaling", aiVector3D(1.f, 1.f, 1.f));
+    aiQuaternion defQuat = EulerToQuaternion(defRotation, rotOrder);
+
+    aiVectorKey* outTranslations = new aiVectorKey[keyCount];
+    aiQuatKey* outRotations = new aiQuatKey[keyCount];
+    aiVectorKey* outScales = new aiVectorKey[keyCount];
+
+    if (keyframeLists[TransformationComp_Translation].size() > 0) {
+        InterpolateKeys(outTranslations, keytimes, keyframeLists[TransformationComp_Translation], defTranslate, maxTime, minTime);
+    } else {
+        for (size_t i = 0; i < keyCount; ++i) {
+            outTranslations[i].mTime = CONVERT_FBX_TIME(keytimes[i]) * anim_fps;
+            outTranslations[i].mValue = defTranslate;
+        }
+    }
+
+    if (keyframeLists[TransformationComp_Rotation].size() > 0) {
+        InterpolateKeys(outRotations, keytimes, keyframeLists[TransformationComp_Rotation], defRotation, maxTime, minTime, rotOrder);
+    } else {
+        for (size_t i = 0; i < keyCount; ++i) {
+            outRotations[i].mTime = CONVERT_FBX_TIME(keytimes[i]) * anim_fps;
+            outRotations[i].mValue = defQuat;
+        }
+    }
+
+    if (keyframeLists[TransformationComp_Scaling].size() > 0) {
+        InterpolateKeys(outScales, keytimes, keyframeLists[TransformationComp_Scaling], defScale, maxTime, minTime);
+    } else {
+        for (size_t i = 0; i < keyCount; ++i) {
+            outScales[i].mTime = CONVERT_FBX_TIME(keytimes[i]) * anim_fps;
+            outScales[i].mValue = defScale;
+        }
+    }
+
+    bool ok = false;
+    
+    const float zero_epsilon = ai_epsilon;
+
+    const aiVector3D& preRotation = PropertyGet<aiVector3D>(props, "PreRotation", ok);
+    if (ok && preRotation.SquareLength() > zero_epsilon) {
+        const aiQuaternion preQuat = EulerToQuaternion(preRotation, Model::RotOrder_EulerXYZ);
+        for (size_t i = 0; i < keyCount; ++i) {
+            outRotations[i].mValue = preQuat * outRotations[i].mValue;
+        }
+    }
+
+    const aiVector3D& postRotation = PropertyGet<aiVector3D>(props, "PostRotation", ok);
+    if (ok && postRotation.SquareLength() > zero_epsilon) {
+        const aiQuaternion postQuat = EulerToQuaternion(postRotation, Model::RotOrder_EulerXYZ);
+        for (size_t i = 0; i < keyCount; ++i) {
+            outRotations[i].mValue = outRotations[i].mValue * postQuat;
+        }
+    }
+
+    // convert TRS to SRT
+    for (size_t i = 0; i < keyCount; ++i) {
+        aiQuaternion& r = outRotations[i].mValue;
+        aiVector3D& s = outScales[i].mValue;
+        aiVector3D& t = outTranslations[i].mValue;
+
+        aiMatrix4x4 mat, temp;
+        aiMatrix4x4::Translation(t, mat);
+        mat *= aiMatrix4x4(r.GetMatrix());
+        mat *= aiMatrix4x4::Scaling(s, temp);
+
+        mat.Decompose(s, r, t);
+    }
+
+    na->mNumScalingKeys = static_cast<unsigned int>(keyCount);
+    na->mNumRotationKeys = na->mNumScalingKeys;
+    na->mNumPositionKeys = na->mNumScalingKeys;
+
+    na->mScalingKeys = outScales;
+    na->mRotationKeys = outRotations;
+    na->mPositionKeys = outTranslations;
+
+    return na.release();
+}
+
+FBXConverter::KeyFrameListList FBXConverter::GetKeyframeList(const std::vector<const AnimationCurveNode *> &nodes, int64_t start, int64_t stop) {
+    KeyFrameListList inputs;
+    inputs.reserve(nodes.size() * 3);
+
+    //give some breathing room for rounding errors
+    int64_t adj_start = start - 10000;
+    int64_t adj_stop = stop + 10000;
+
+    for (const AnimationCurveNode *node : nodes) {
+        ai_assert(node);
+
+        const AnimationCurveMap &curves = node->Curves();
+        for (const AnimationCurveMap::value_type &kv : curves) {
+
+            unsigned int mapto;
+            if (kv.first == "d|X") {
+                mapto = 0;
+            } else if (kv.first == "d|Y") {
+                mapto = 1;
+            } else if (kv.first == "d|Z") {
+                mapto = 2;
+            } else {
+                FBXImporter::LogWarn("ignoring scale animation curve, did not recognize target component");
+                continue;
+            }
+
+            const AnimationCurve *const curve = kv.second;
+            ai_assert(curve->GetKeys().size() == curve->GetValues().size());
+            ai_assert(curve->GetKeys().size());
+
+            //get values within the start/stop time window
+            std::shared_ptr<KeyTimeList> Keys(new KeyTimeList());
+            std::shared_ptr<KeyValueList> Values(new KeyValueList());
+            const size_t count = curve->GetKeys().size();
+            Keys->reserve(count);
+            Values->reserve(count);
+            for (size_t n = 0; n < count; n++) {
+                int64_t k = curve->GetKeys().at(n);
+                if (k >= adj_start && k <= adj_stop) {
+                    Keys->push_back(k);
+                    Values->push_back(curve->GetValues().at(n));
+                }
+            }
+
+            inputs.push_back(std::make_tuple(Keys, Values, mapto));
+        }
+    }
+    return inputs; // pray for NRVO :-)
+}
+
+FBXConverter::KeyFrameListList FBXConverter::GetRotationKeyframeList(const std::vector<const AnimationCurveNode *> &nodes,
+                                                                     int64_t start, int64_t stop) {
+    KeyFrameListList inputs;
+    inputs.reserve(nodes.size() * 3);
+
+    //give some breathing room for rounding errors
+    const int64_t adj_start = start - 10000;
+    const int64_t adj_stop = stop + 10000;
+
+    for (const AnimationCurveNode *node : nodes) {
+        ai_assert(node);
+
+        const AnimationCurveMap &curves = node->Curves();
+        for (const AnimationCurveMap::value_type &kv : curves) {
+
+            unsigned int mapto;
+            if (kv.first == "d|X") {
+                mapto = 0;
+            } else if (kv.first == "d|Y") {
+                mapto = 1;
+            } else if (kv.first == "d|Z") {
+                mapto = 2;
+            } else {
+                FBXImporter::LogWarn("ignoring scale animation curve, did not recognize target component");
+                continue;
+            }
+
+            const AnimationCurve *const curve = kv.second;
+            ai_assert(curve->GetKeys().size() == curve->GetValues().size());
+            ai_assert(curve->GetKeys().size());
+
+            //get values within the start/stop time window
+            std::shared_ptr<KeyTimeList> Keys(new KeyTimeList());
+            std::shared_ptr<KeyValueList> Values(new KeyValueList());
+            const size_t count = curve->GetKeys().size();
+
+            int64_t tp = curve->GetKeys().at(0);
+            float vp = curve->GetValues().at(0);
+            Keys->push_back(tp);
+            Values->push_back(vp);
+            if (count > 1) {
+                int64_t tc = curve->GetKeys().at(1);
+                float vc = curve->GetValues().at(1);
+                for (size_t n = 1; n < count; n++) {
+                    while (std::abs(vc - vp) >= 180.0f) {
+                        float step = std::floor(float(tc - tp) / (vc - vp) * 179.0f);
+                        int64_t tnew = tp + int64_t(step);
+                        float vnew = vp + (vc - vp) * step / float(tc - tp);
+                        if (tnew >= adj_start && tnew <= adj_stop) {
+                            Keys->push_back(tnew);
+                            Values->push_back(vnew);
+                        }
+                        tp = tnew;
+                        vp = vnew;
+                    }
+                    if (tc >= adj_start && tc <= adj_stop) {
+                        Keys->push_back(tc);
+                        Values->push_back(vc);
+                    }
+                    if (n + 1 < count) {
+                        tp = tc;
+                        vp = vc;
+                        tc = curve->GetKeys().at(n + 1);
+                        vc = curve->GetValues().at(n + 1);
+                    }
+                }
+            }
+            inputs.push_back(std::make_tuple(Keys, Values, mapto));
+        }
+    }
+    return inputs;
+}
+
+KeyTimeList FBXConverter::GetKeyTimeList(const KeyFrameListList &inputs) {
+    ai_assert(!inputs.empty());
+
+    // reserve some space upfront - it is likely that the key-frame lists
+    // have matching time values, so max(of all key-frame lists) should
+    // be a good estimate.
+    KeyTimeList keys;
+
+    size_t estimate = 0;
+    for (const KeyFrameList &kfl : inputs) {
+        estimate = std::max(estimate, std::get<0>(kfl)->size());
+    }
+
+    keys.reserve(estimate);
+
+    std::vector<unsigned int> next_pos;
+    next_pos.resize(inputs.size(), 0);
+
+    const size_t count = inputs.size();
+    while (true) {
+
+        int64_t min_tick = std::numeric_limits<int64_t>::max();
+        for (size_t i = 0; i < count; ++i) {
+            const KeyFrameList &kfl = inputs[i];
+
+            if (std::get<0>(kfl)->size() > next_pos[i] && std::get<0>(kfl)->at(next_pos[i]) < min_tick) {
+                min_tick = std::get<0>(kfl)->at(next_pos[i]);
+            }
+        }
+
+        if (min_tick == std::numeric_limits<int64_t>::max()) {
+            break;
+        }
+        keys.push_back(min_tick);
+
+        for (size_t i = 0; i < count; ++i) {
+            const KeyFrameList &kfl = inputs[i];
+
+            while (std::get<0>(kfl)->size() > next_pos[i] && std::get<0>(kfl)->at(next_pos[i]) == min_tick) {
+                ++next_pos[i];
+            }
+        }
+    }
+
+    return keys;
+}
+
+void FBXConverter::InterpolateKeys(aiVectorKey *valOut, const KeyTimeList &keys, const KeyFrameListList &inputs,
+        const aiVector3D &def_value,
+        double &max_time,
+        double &min_time) {
+    ai_assert(!keys.empty());
+    ai_assert(nullptr != valOut);
+
+    std::vector<unsigned int> next_pos;
+    const size_t count(inputs.size());
+
+    next_pos.resize(inputs.size(), 0);
+
+    for (KeyTimeList::value_type time : keys) {
+        ai_real result[3] = { def_value.x, def_value.y, def_value.z };
+
+        for (size_t i = 0; i < count; ++i) {
+            const KeyFrameList &kfl = inputs[i];
+
+            const size_t ksize = std::get<0>(kfl)->size();
+            if (ksize == 0) {
+                continue;
+            }
+            if (ksize > next_pos[i] && std::get<0>(kfl)->at(next_pos[i]) == time) {
+                ++next_pos[i];
+            }
+
+            const size_t id0 = next_pos[i] > 0 ? next_pos[i] - 1 : 0;
+            const size_t id1 = next_pos[i] == ksize ? ksize - 1 : next_pos[i];
+
+            // use lerp for interpolation
+            const KeyValueList::value_type valueA = std::get<1>(kfl)->at(id0);
+            const KeyValueList::value_type valueB = std::get<1>(kfl)->at(id1);
+
+            const KeyTimeList::value_type timeA = std::get<0>(kfl)->at(id0);
+            const KeyTimeList::value_type timeB = std::get<0>(kfl)->at(id1);
+
+            const ai_real factor = timeB == timeA ? ai_real(0.) : static_cast<ai_real>((time - timeA)) / (timeB - timeA);
+            const ai_real interpValue = static_cast<ai_real>(valueA + (valueB - valueA) * factor);
+
+            result[std::get<2>(kfl)] = interpValue;
+        }
+
+        // magic value to convert fbx times to seconds
+        valOut->mTime = CONVERT_FBX_TIME(time) * anim_fps;
+
+        min_time = std::min(min_time, valOut->mTime);
+        max_time = std::max(max_time, valOut->mTime);
+
+        valOut->mValue.x = result[0];
+        valOut->mValue.y = result[1];
+        valOut->mValue.z = result[2];
+
+        ++valOut;
+    }
+}
+
+void FBXConverter::InterpolateKeys(aiQuatKey *valOut, const KeyTimeList &keys, const KeyFrameListList &inputs,
+        const aiVector3D &def_value,
+        double &maxTime,
+        double &minTime,
+        Model::RotOrder order) {
+    ai_assert(!keys.empty());
+    ai_assert(nullptr != valOut);
+
+    std::unique_ptr<aiVectorKey[]> temp(new aiVectorKey[keys.size()]);
+    InterpolateKeys(temp.get(), keys, inputs, def_value, maxTime, minTime);
+
+    aiMatrix4x4 m;
+
+    aiQuaternion lastq;
+
+    for (size_t i = 0, c = keys.size(); i < c; ++i) {
+
+        valOut[i].mTime = temp[i].mTime;
+
+        GetRotationMatrix(order, temp[i].mValue, m);
+        aiQuaternion quat = aiQuaternion(aiMatrix3x3(m));
+
+        // take shortest path by checking the inner product
+        // http://www.3dkingdoms.com/weekly/weekly.php?a=36
+        if (quat.x * lastq.x + quat.y * lastq.y + quat.z * lastq.z + quat.w * lastq.w < 0) {
+            quat.Conjugate();
+            quat.w = -quat.w;
+        }
+        lastq = quat;
+
+        valOut[i].mValue = quat;
+    }
+}
+
+aiQuaternion FBXConverter::EulerToQuaternion(const aiVector3D &rot, Model::RotOrder order) {
+    aiMatrix4x4 m;
+    GetRotationMatrix(order, rot, m);
+
+    return aiQuaternion(aiMatrix3x3(m));
+}
+
+void FBXConverter::ConvertScaleKeys(aiNodeAnim *na, const std::vector<const AnimationCurveNode *> &nodes, const LayerMap & /*layers*/,
+        int64_t start, int64_t stop,
+        double &maxTime,
+        double &minTime) {
+    ai_assert(nodes.size());
+
+    // XXX for now, assume scale should be blended geometrically (i.e. two
+    // layers should be multiplied with each other). There is a FBX
+    // property in the layer to specify the behaviour, though.
+
+    const KeyFrameListList &inputs = GetKeyframeList(nodes, start, stop);
+    const KeyTimeList &keys = GetKeyTimeList(inputs);
+
+    na->mNumScalingKeys = static_cast<unsigned int>(keys.size());
+    na->mScalingKeys = new aiVectorKey[keys.size()];
+    if (keys.size() > 0) {
+        InterpolateKeys(na->mScalingKeys, keys, inputs, aiVector3D(1.0f, 1.0f, 1.0f), maxTime, minTime);
+    }
+}
+
+void FBXConverter::ConvertTranslationKeys(aiNodeAnim *na, const std::vector<const AnimationCurveNode *> &nodes,
+        const LayerMap & /*layers*/,
+        int64_t start, int64_t stop,
+        double &maxTime,
+        double &minTime) {
+    ai_assert(nodes.size());
+
+    // XXX see notes in ConvertScaleKeys()
+    const KeyFrameListList &inputs = GetKeyframeList(nodes, start, stop);
+    const KeyTimeList &keys = GetKeyTimeList(inputs);
+
+    na->mNumPositionKeys = static_cast<unsigned int>(keys.size());
+    na->mPositionKeys = new aiVectorKey[keys.size()];
+    if (keys.size() > 0)
+        InterpolateKeys(na->mPositionKeys, keys, inputs, aiVector3D(0.0f, 0.0f, 0.0f), maxTime, minTime);
+}
+
+void FBXConverter::ConvertRotationKeys(aiNodeAnim *na, const std::vector<const AnimationCurveNode *> &nodes,
+        const LayerMap & /*layers*/,
+        int64_t start, int64_t stop,
+        double &maxTime,
+        double &minTime,
+        Model::RotOrder order) {
+    ai_assert(nodes.size());
+
+    // XXX see notes in ConvertScaleKeys()
+    const std::vector<KeyFrameList> &inputs = GetRotationKeyframeList(nodes, start, stop);
+    const KeyTimeList &keys = GetKeyTimeList(inputs);
+
+    na->mNumRotationKeys = static_cast<unsigned int>(keys.size());
+    na->mRotationKeys = new aiQuatKey[keys.size()];
+    if (!keys.empty()) {
+        InterpolateKeys(na->mRotationKeys, keys, inputs, aiVector3D(0.0f, 0.0f, 0.0f), maxTime, minTime, order);
+    }
+}
+
+void FBXConverter::ConvertGlobalSettings() {
+    if (nullptr == mSceneOut) {
+        return;
+    }
+
+    const bool hasGenerator = !doc.Creator().empty();
+
+    mSceneOut->mMetaData = aiMetadata::Alloc(16 + (hasGenerator ? 1 : 0));
+    mSceneOut->mMetaData->Set(0, "UpAxis", doc.GlobalSettings().UpAxis());
+    mSceneOut->mMetaData->Set(1, "UpAxisSign", doc.GlobalSettings().UpAxisSign());
+    mSceneOut->mMetaData->Set(2, "FrontAxis", doc.GlobalSettings().FrontAxis());
+    mSceneOut->mMetaData->Set(3, "FrontAxisSign", doc.GlobalSettings().FrontAxisSign());
+    mSceneOut->mMetaData->Set(4, "CoordAxis", doc.GlobalSettings().CoordAxis());
+    mSceneOut->mMetaData->Set(5, "CoordAxisSign", doc.GlobalSettings().CoordAxisSign());
+    mSceneOut->mMetaData->Set(6, "OriginalUpAxis", doc.GlobalSettings().OriginalUpAxis());
+    mSceneOut->mMetaData->Set(7, "OriginalUpAxisSign", doc.GlobalSettings().OriginalUpAxisSign());
+    //const double unitScaleFactor = (double)doc.GlobalSettings().UnitScaleFactor();
+    mSceneOut->mMetaData->Set(8, "UnitScaleFactor", doc.GlobalSettings().UnitScaleFactor());
+    mSceneOut->mMetaData->Set(9, "OriginalUnitScaleFactor", doc.GlobalSettings().OriginalUnitScaleFactor());
+    mSceneOut->mMetaData->Set(10, "AmbientColor", doc.GlobalSettings().AmbientColor());
+    mSceneOut->mMetaData->Set(11, "FrameRate", (int)doc.GlobalSettings().TimeMode());
+    mSceneOut->mMetaData->Set(12, "TimeSpanStart", doc.GlobalSettings().TimeSpanStart());
+    mSceneOut->mMetaData->Set(13, "TimeSpanStop", doc.GlobalSettings().TimeSpanStop());
+    mSceneOut->mMetaData->Set(14, "CustomFrameRate", doc.GlobalSettings().CustomFrameRate());
+    mSceneOut->mMetaData->Set(15, AI_METADATA_SOURCE_FORMAT_VERSION, aiString(ai_to_string(doc.FBXVersion())));
+    if (hasGenerator) {
+        mSceneOut->mMetaData->Set(16, AI_METADATA_SOURCE_GENERATOR, aiString(doc.Creator()));
+    }
+}
+
+void FBXConverter::TransferDataToScene() {
+    ai_assert(!mSceneOut->mMeshes);
+    ai_assert(!mSceneOut->mNumMeshes);
+
+    // note: the trailing () ensures initialization with nullptr - not
+    // many C++ users seem to know this, so pointing it out to avoid
+    // confusion why this code works.
+
+    if (!mMeshes.empty()) {
+        mSceneOut->mMeshes = new aiMesh *[mMeshes.size()]();
+        mSceneOut->mNumMeshes = static_cast<unsigned int>(mMeshes.size());
+
+        std::swap_ranges(mMeshes.begin(), mMeshes.end(), mSceneOut->mMeshes);
+    }
+
+    if (!materials.empty()) {
+        mSceneOut->mMaterials = new aiMaterial *[materials.size()]();
+        mSceneOut->mNumMaterials = static_cast<unsigned int>(materials.size());
+
+        std::swap_ranges(materials.begin(), materials.end(), mSceneOut->mMaterials);
+    }
+
+    if (!animations.empty()) {
+        mSceneOut->mAnimations = new aiAnimation *[animations.size()]();
+        mSceneOut->mNumAnimations = static_cast<unsigned int>(animations.size());
+
+        std::swap_ranges(animations.begin(), animations.end(), mSceneOut->mAnimations);
+    }
+
+    if (!lights.empty()) {
+        mSceneOut->mLights = new aiLight *[lights.size()]();
+        mSceneOut->mNumLights = static_cast<unsigned int>(lights.size());
+
+        std::swap_ranges(lights.begin(), lights.end(), mSceneOut->mLights);
+    }
+
+    if (!cameras.empty()) {
+        mSceneOut->mCameras = new aiCamera *[cameras.size()]();
+        mSceneOut->mNumCameras = static_cast<unsigned int>(cameras.size());
+
+        std::swap_ranges(cameras.begin(), cameras.end(), mSceneOut->mCameras);
+    }
+
+    if (!textures.empty()) {
+        mSceneOut->mTextures = new aiTexture *[textures.size()]();
+        mSceneOut->mNumTextures = static_cast<unsigned int>(textures.size());
+
+        std::swap_ranges(textures.begin(), textures.end(), mSceneOut->mTextures);
+    }
+}
+
+void FBXConverter::ConvertOrphanedEmbeddedTextures() {
+    // in C++14 it could be:
+    // for (auto&& [id, object] : objects)
+    for (auto &&id_and_object : doc.Objects()) {
+        auto &&id = std::get<0>(id_and_object);
+        auto &&object = std::get<1>(id_and_object);
+        // If an object doesn't have parent
+        if (doc.ConnectionsBySource().count(id) == 0) {
+            const Texture *realTexture = nullptr;
+            try {
+                const auto &element = object->GetElement();
+                const Token &key = element.KeyToken();
+                const char *obtype = key.begin();
+                const size_t length = static_cast<size_t>(key.end() - key.begin());
+                if (strncmp(obtype, "Texture", length) == 0) {
+                    if (const Texture *texture = static_cast<const Texture *>(object->Get())) {
+                        if (texture->Media() && texture->Media()->ContentLength() > 0) {
+                            realTexture = texture;
+                        }
+                    }
+                }
+            } catch (...) {
+                // do nothing
+            }
+            if (realTexture) {
+                const Video *media = realTexture->Media();
+                unsigned int index = ConvertVideo(*media);
+                textures_converted[media] = index;
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void ConvertToAssimpScene(aiScene *out, const Document &doc, bool removeEmptyBones) {
+    FBXConverter converter(out, doc, removeEmptyBones);
+}
+
+} // namespace FBX
+} // namespace Assimp
+
+#endif
diff --git a/Engine/lib/assimp/code/FBX/FBXConverter.h b/Engine/lib/assimp/code/AssetLib/FBX/FBXConverter.h
similarity index 82%
rename from Engine/lib/assimp/code/FBX/FBXConverter.h
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXConverter.h
index 77ced1950..becfdb3e8 100644
--- a/Engine/lib/assimp/code/FBX/FBXConverter.h
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXConverter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -76,7 +76,7 @@ namespace Assimp {
 namespace FBX {
 
 class Document;
-/** 
+/**
  *  Convert a FBX #Document to #aiScene
  *  @param out Empty scene to be populated
  *  @param doc Parsed FBX document
@@ -123,7 +123,7 @@ private:
 
     // ------------------------------------------------------------------------------------------------
     // collect and assign child nodes
-    void ConvertNodes(uint64_t id, aiNode& parent, const aiMatrix4x4& parent_transform = aiMatrix4x4());
+    void ConvertNodes(uint64_t id, aiNode *parent, aiNode *root_node);
 
     // ------------------------------------------------------------------------------------------------
     void ConvertLights(const Model& model, const std::string &orig_name );
@@ -171,40 +171,43 @@ private:
 
     // ------------------------------------------------------------------------------------------------
     /**
-    *  note: memory for output_nodes will be managed by the caller
+    *  note: memory for output_nodes is managed by the caller, via the PotentialNode struct.
     */
-    bool GenerateTransformationNodeChain(const Model& model, const std::string& name, std::vector<aiNode*>& output_nodes, std::vector<aiNode*>& post_output_nodes);
+    struct PotentialNode;
+    bool GenerateTransformationNodeChain(const Model& model, const std::string& name, std::vector<PotentialNode>& output_nodes, std::vector<PotentialNode>& post_output_nodes);
 
     // ------------------------------------------------------------------------------------------------
     void SetupNodeMetadata(const Model& model, aiNode& nd);
 
     // ------------------------------------------------------------------------------------------------
-    void ConvertModel(const Model& model, aiNode& nd, const aiMatrix4x4& node_global_transform);
-    
+    void ConvertModel(const Model &model, aiNode *parent, aiNode *root_node,
+                      const aiMatrix4x4 &absolute_transform);
+
     // ------------------------------------------------------------------------------------------------
     // MeshGeometry -> aiMesh, return mesh index + 1 or 0 if the conversion failed
-    std::vector<unsigned int> ConvertMesh(const MeshGeometry& mesh, const Model& model,
-        const aiMatrix4x4& node_global_transform, aiNode& nd);
+    std::vector<unsigned int>
+    ConvertMesh(const MeshGeometry &mesh, const Model &model, aiNode *parent, aiNode *root_node,
+                const aiMatrix4x4 &absolute_transform);
 
     // ------------------------------------------------------------------------------------------------
-    std::vector<unsigned int> ConvertLine(const LineGeometry& line, const Model& model,
-        const aiMatrix4x4& node_global_transform, aiNode& nd);
+    std::vector<unsigned int> ConvertLine(const LineGeometry& line, aiNode *root_node);
 
     // ------------------------------------------------------------------------------------------------
-    aiMesh* SetupEmptyMesh(const Geometry& mesh, aiNode& nd);
+    aiMesh* SetupEmptyMesh(const Geometry& mesh, aiNode *parent);
 
     // ------------------------------------------------------------------------------------------------
-    unsigned int ConvertMeshSingleMaterial(const MeshGeometry& mesh, const Model& model,
-        const aiMatrix4x4& node_global_transform, aiNode& nd);
+    unsigned int ConvertMeshSingleMaterial(const MeshGeometry &mesh, const Model &model,
+                                           const aiMatrix4x4 &absolute_transform, aiNode *parent,
+                                           aiNode *root_node);
 
     // ------------------------------------------------------------------------------------------------
-    std::vector<unsigned int> ConvertMeshMultiMaterial(const MeshGeometry& mesh, const Model& model,
-        const aiMatrix4x4& node_global_transform, aiNode& nd);
+    std::vector<unsigned int>
+    ConvertMeshMultiMaterial(const MeshGeometry &mesh, const Model &model, aiNode *parent, aiNode *root_node,
+                             const aiMatrix4x4 &absolute_transform);
 
     // ------------------------------------------------------------------------------------------------
-    unsigned int ConvertMeshMultiMaterial(const MeshGeometry& mesh, const Model& model,
-        MatIndexArray::value_type index,
-        const aiMatrix4x4& node_global_transform, aiNode& nd);
+    unsigned int ConvertMeshMultiMaterial(const MeshGeometry &mesh, const Model &model, MatIndexArray::value_type index,
+                                          aiNode *parent, aiNode *root_node, const aiMatrix4x4 &absolute_transform);
 
     // ------------------------------------------------------------------------------------------------
     static const unsigned int NO_MATERIAL_SEPARATION = /* std::numeric_limits<unsigned int>::max() */
@@ -217,17 +220,15 @@ private:
     *  - outputVertStartIndices is only used when a material index is specified, it gives for
     *    each output vertex the DOM index it maps to.
     */
-    void ConvertWeights(aiMesh* out, const Model& model, const MeshGeometry& geo,
-        const aiMatrix4x4& node_global_transform = aiMatrix4x4(),
-        unsigned int materialIndex = NO_MATERIAL_SEPARATION,
-        std::vector<unsigned int>* outputVertStartIndices = NULL);
+    void ConvertWeights(aiMesh *out, const MeshGeometry &geo, const aiMatrix4x4 &absolute_transform,
+            aiNode *parent = nullptr, unsigned int materialIndex = NO_MATERIAL_SEPARATION,
+            std::vector<unsigned int> *outputVertStartIndices = nullptr);
 
     // ------------------------------------------------------------------------------------------------
-    void ConvertCluster(std::vector<aiBone*>& bones, const Model& /*model*/, const Cluster& cl,
-        std::vector<size_t>& out_indices,
-        std::vector<size_t>& index_out_indices,
-        std::vector<size_t>& count_out_indices,
-        const aiMatrix4x4& node_global_transform);
+    void ConvertCluster(std::vector<aiBone *> &local_mesh_bones, const Cluster *cl,
+                        std::vector<size_t> &out_indices, std::vector<size_t> &index_out_indices,
+                        std::vector<size_t> &count_out_indices, const aiMatrix4x4 &absolute_transform,
+                        aiNode *parent );
 
     // ------------------------------------------------------------------------------------------------
     void ConvertMaterialForMesh(aiMesh* out, const Model& model, const MeshGeometry& geo,
@@ -349,12 +350,10 @@ private:
     aiNodeAnim* GenerateSimpleNodeAnim(const std::string& name,
         const Model& target,
         NodeMap::const_iterator chain[TransformationComp_MAXIMUM],
-        NodeMap::const_iterator iter_end,
-        const LayerMap& layer_map,
+        NodeMap::const_iterator iterEnd,
         int64_t start, int64_t stop,
-        double& max_time,
-        double& min_time,
-        bool reverse_order = false);
+        double& maxTime,
+        double& minTime);
 
     // key (time), value, mapto (component index)
     typedef std::tuple<std::shared_ptr<KeyTimeList>, std::shared_ptr<KeyValueList>, unsigned int > KeyFrameList;
@@ -362,6 +361,7 @@ private:
 
     // ------------------------------------------------------------------------------------------------
     KeyFrameListList GetKeyframeList(const std::vector<const AnimationCurveNode*>& nodes, int64_t start, int64_t stop);
+    KeyFrameListList GetRotationKeyframeList(const std::vector<const AnimationCurveNode*>& nodes, int64_t start, int64_t stop);
 
     // ------------------------------------------------------------------------------------------------
     KeyTimeList GetKeyTimeList(const KeyFrameListList& inputs);
@@ -379,20 +379,6 @@ private:
         double& minTime,
         Model::RotOrder order);
 
-    // ------------------------------------------------------------------------------------------------
-    void ConvertTransformOrder_TRStoSRT(aiQuatKey* out_quat, aiVectorKey* out_scale,
-        aiVectorKey* out_translation,
-        const KeyFrameListList& scaling,
-        const KeyFrameListList& translation,
-        const KeyFrameListList& rotation,
-        const KeyTimeList& times,
-        double& maxTime,
-        double& minTime,
-        Model::RotOrder order,
-        const aiVector3D& def_scale,
-        const aiVector3D& def_translate,
-        const aiVector3D& def_rotation);
-
     // ------------------------------------------------------------------------------------------------
     // euler xyz -> quat
     aiQuaternion EulerToQuaternion(const aiVector3D& rot, Model::RotOrder order);
@@ -418,44 +404,70 @@ private:
         double& minTime,
         Model::RotOrder order);
 
+    // ------------------------------------------------------------------------------------------------
+    // Copy global geometric data and some information about the source asset into scene metadata.
     void ConvertGlobalSettings();
 
     // ------------------------------------------------------------------------------------------------
     // copy generated meshes, animations, lights, cameras and textures to the output scene
     void TransferDataToScene();
 
+    // ------------------------------------------------------------------------------------------------
+    // FBX file could have embedded textures not connected to anything
+    void ConvertOrphanedEmbeddedTextures();
+
 private:
     // 0: not assigned yet, others: index is value - 1
     unsigned int defaultMaterialIndex;
 
-    std::vector<aiMesh*> meshes;
+    std::vector<aiMesh*> mMeshes;
     std::vector<aiMaterial*> materials;
     std::vector<aiAnimation*> animations;
     std::vector<aiLight*> lights;
     std::vector<aiCamera*> cameras;
     std::vector<aiTexture*> textures;
 
-    using MaterialMap = std::map<const Material*, unsigned int>;
+    using MaterialMap = std::fbx_unordered_map<const Material*, unsigned int>;
     MaterialMap materials_converted;
 
-    using VideoMap = std::map<const Video*, unsigned int>;
+    using VideoMap = std::fbx_unordered_map<const Video*, unsigned int>;
     VideoMap textures_converted;
 
-    using MeshMap = std::map<const Geometry*, std::vector<unsigned int> >;
+    using MeshMap = std::fbx_unordered_map<const Geometry*, std::vector<unsigned int> >;
     MeshMap meshes_converted;
 
     // fixed node name -> which trafo chain components have animations?
-    using NodeAnimBitMap = std::map<std::string, unsigned int> ;
+    using NodeAnimBitMap = std::fbx_unordered_map<std::string, unsigned int> ;
     NodeAnimBitMap node_anim_chain_bits;
 
     // number of nodes with the same name
-    using NodeNameCache = std::unordered_map<std::string, unsigned int>;
+    using NodeNameCache = std::fbx_unordered_map<std::string, unsigned int>;
     NodeNameCache mNodeNames;
 
+    // Deformer name is not the same as a bone name - it does contain the bone name though :)
+    // Deformer names in FBX are always unique in an FBX file.
+    std::map<const std::string, aiBone *> bone_map;
+
     double anim_fps;
 
-    aiScene* const out;
+    aiScene* const mSceneOut;
     const FBX::Document& doc;
+    bool mRemoveEmptyBones;
+    static void BuildBoneList(aiNode *current_node, const aiNode *root_node, const aiScene *scene,
+                             std::vector<aiBone*>& bones);
+
+    void BuildBoneStack(aiNode *current_node, const aiNode *root_node, const aiScene *scene,
+                   const std::vector<aiBone *> &bones,
+                   std::map<aiBone *, aiNode *> &bone_stack,
+                   std::vector<aiNode*> &node_stack );
+
+    static void BuildNodeList(aiNode *current_node, std::vector<aiNode *> &nodes);
+
+    static aiNode *GetNodeFromStack(const aiString &node_name, std::vector<aiNode *> &nodes);
+
+    static aiNode *GetArmatureRoot(aiNode *bone_node, std::vector<aiBone*> &bone_list);
+
+    static bool IsBoneNode(const aiString &bone_name, std::vector<aiBone *> &bones);
 };
 
 }
diff --git a/Engine/lib/assimp/code/FBX/FBXDeformer.cpp b/Engine/lib/assimp/code/AssetLib/FBX/FBXDeformer.cpp
similarity index 99%
rename from Engine/lib/assimp/code/FBX/FBXDeformer.cpp
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXDeformer.cpp
index 692755345..ba245ed6d 100644
--- a/Engine/lib/assimp/code/FBX/FBXDeformer.cpp
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXDeformer.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/FBX/FBXDocument.cpp b/Engine/lib/assimp/code/AssetLib/FBX/FBXDocument.cpp
similarity index 89%
rename from Engine/lib/assimp/code/FBX/FBXDocument.cpp
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXDocument.cpp
index 506fd978d..b49ee625a 100644
--- a/Engine/lib/assimp/code/FBX/FBXDocument.cpp
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXDocument.cpp
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -55,9 +54,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "FBXDocumentUtil.h"
 #include "FBXProperties.h"
 
-#include <memory>
+#include <assimp/DefaultLogger.hpp>
+
 #include <functional>
 #include <map>
+#include <memory>
+#include <utility>
 
 namespace Assimp {
 namespace FBX {
@@ -65,23 +67,13 @@ namespace FBX {
 using namespace Util;
 
 // ------------------------------------------------------------------------------------------------
-LazyObject::LazyObject(uint64_t id, const Element& element, const Document& doc)
-: doc(doc)
-, element(element)
-, id(id)
-, flags() {
+LazyObject::LazyObject(uint64_t id, const Element& element, const Document& doc) : 
+        doc(doc), element(element), id(id), flags() {
     // empty
 }
 
 // ------------------------------------------------------------------------------------------------
-LazyObject::~LazyObject()
-{
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-const Object* LazyObject::Get(bool dieOnError)
-{
+const Object* LazyObject::Get(bool dieOnError) {
     if(IsBeingConstructed() || FailedToConstruct()) {
         return nullptr;
     }
@@ -219,7 +211,7 @@ const Object* LazyObject::Get(bool dieOnError)
         if(!DefaultLogger::isNullLogger()) {
             ASSIMP_LOG_ERROR(ex.what());
         }
-        return NULL;
+        return nullptr;
     }
 
     if (!object.get()) {
@@ -231,39 +223,22 @@ const Object* LazyObject::Get(bool dieOnError)
 }
 
 // ------------------------------------------------------------------------------------------------
-Object::Object(uint64_t id, const Element& element, const std::string& name)
-: element(element)
-, name(name)
-, id(id)
-{
+Object::Object(uint64_t id, const Element& element, const std::string& name) :
+        element(element), name(name), id(id) {
     // empty
 }
 
 // ------------------------------------------------------------------------------------------------
-Object::~Object()
-{
+FileGlobalSettings::FileGlobalSettings(const Document &doc, std::shared_ptr<const PropertyTable> props) :
+        props(std::move(props)), doc(doc) {
     // empty
 }
 
 // ------------------------------------------------------------------------------------------------
-FileGlobalSettings::FileGlobalSettings(const Document& doc, std::shared_ptr<const PropertyTable> props)
-: props(props)
-, doc(doc)
-{
-    // empty
-}
+Document::Document(const Parser& parser, const ImportSettings& settings) :
+     settings(settings), parser(parser) {
+	ASSIMP_LOG_DEBUG("Creating FBX Document");
 
-// ------------------------------------------------------------------------------------------------
-FileGlobalSettings::~FileGlobalSettings()
-{
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-Document::Document(const Parser& parser, const ImportSettings& settings)
-: settings(settings)
-, parser(parser)
-{
     // Cannot use array default initialization syntax because vc8 fails on it
     for (auto &timeStamp : creationTimeStamp) {
         timeStamp = 0;
@@ -282,8 +257,7 @@ Document::Document(const Parser& parser, const ImportSettings& settings)
 }
 
 // ------------------------------------------------------------------------------------------------
-Document::~Document()
-{
+Document::~Document() {
     for(ObjectMap::value_type& v : objects) {
         delete v.second;
     }
@@ -308,6 +282,7 @@ void Document::ReadHeader() {
 
     const Scope& shead = *ehead->Compound();
     fbxVersion = ParseTokenAsInt(GetRequiredToken(GetRequiredElement(shead,"FBXVersion",ehead),0));
+	ASSIMP_LOG_DEBUG("FBX Version: ", fbxVersion);
 
     // While we may have some success with newer files, we don't support
     // the older 6.n fbx format
@@ -344,8 +319,7 @@ void Document::ReadHeader() {
 }
 
 // ------------------------------------------------------------------------------------------------
-void Document::ReadGlobalSettings()
-{
+void Document::ReadGlobalSettings() {
     const Scope& sc = parser.GetRootScope();
     const Element* const ehead = sc["GlobalSettings"];
     if ( nullptr == ehead || !ehead->Compound() ) {
@@ -366,8 +340,7 @@ void Document::ReadGlobalSettings()
 }
 
 // ------------------------------------------------------------------------------------------------
-void Document::ReadObjects()
-{
+void Document::ReadObjects() {
     // read ID objects from "Objects" section
     const Scope& sc = parser.GetRootScope();
     const Element* const eobjects = sc["Objects"];
@@ -414,8 +387,7 @@ void Document::ReadObjects()
 }
 
 // ------------------------------------------------------------------------------------------------
-void Document::ReadPropertyTemplates()
-{
+void Document::ReadPropertyTemplates() {
     const Scope& sc = parser.GetRootScope();
     // read property templates from "Definitions" section
     const Element* const edefs = sc["Definitions"];
@@ -428,8 +400,8 @@ void Document::ReadPropertyTemplates()
     const ElementCollection otypes = sdefs.GetCollection("ObjectType");
     for(ElementMap::const_iterator it = otypes.first; it != otypes.second; ++it) {
         const Element& el = *(*it).second;
-        const Scope* sc = el.Compound();
-        if(!sc) {
+        const Scope* curSc = el.Compound();
+        if (!curSc) {
             DOMWarning("expected nested scope in ObjectType, ignoring",&el);
             continue;
         }
@@ -442,27 +414,27 @@ void Document::ReadPropertyTemplates()
 
         const std::string& oname = ParseTokenAsString(*tok[0]);
 
-        const ElementCollection templs = sc->GetCollection("PropertyTemplate");
-        for(ElementMap::const_iterator it = templs.first; it != templs.second; ++it) {
-            const Element& el = *(*it).second;
-            const Scope* sc = el.Compound();
-            if(!sc) {
+        const ElementCollection templs = curSc->GetCollection("PropertyTemplate");
+        for (ElementMap::const_iterator elemIt = templs.first; elemIt != templs.second; ++elemIt) {
+            const Element &innerEl = *(*elemIt).second;
+            const Scope *innerSc = innerEl.Compound();
+            if (!innerSc) {
                 DOMWarning("expected nested scope in PropertyTemplate, ignoring",&el);
                 continue;
             }
 
-            const TokenList& tok = el.Tokens();
-            if(tok.empty()) {
+            const TokenList &curTok = innerEl.Tokens();
+            if (curTok.empty()) {
                 DOMWarning("expected name for PropertyTemplate element, ignoring",&el);
                 continue;
             }
 
-            const std::string& pname = ParseTokenAsString(*tok[0]);
+            const std::string &pname = ParseTokenAsString(*curTok[0]);
 
-            const Element* Properties70 = (*sc)["Properties70"];
+            const Element *Properties70 = (*innerSc)["Properties70"];
             if(Properties70) {
                 std::shared_ptr<const PropertyTable> props = std::make_shared<const PropertyTable>(
-                    *Properties70,std::shared_ptr<const PropertyTable>(static_cast<const PropertyTable*>(NULL))
+                        *Properties70, std::shared_ptr<const PropertyTable>(static_cast<const PropertyTable *>(nullptr))
                 );
 
                 templates[oname+"."+pname] = props;
@@ -472,8 +444,7 @@ void Document::ReadPropertyTemplates()
 }
 
 // ------------------------------------------------------------------------------------------------
-void Document::ReadConnections()
-{
+void Document::ReadConnections() {
     const Scope& sc = parser.GetRootScope();
     // read property templates from "Definitions" section
     const Element* const econns = sc["Connections"];
@@ -520,8 +491,7 @@ void Document::ReadConnections()
 }
 
 // ------------------------------------------------------------------------------------------------
-const std::vector<const AnimationStack*>& Document::AnimationStacks() const
-{
+const std::vector<const AnimationStack*>& Document::AnimationStacks() const {
     if (!animationStacksResolved.empty() || animationStacks.empty()) {
         return animationStacksResolved;
     }
@@ -529,8 +499,8 @@ const std::vector<const AnimationStack*>& Document::AnimationStacks() const
     animationStacksResolved.reserve(animationStacks.size());
     for(uint64_t id : animationStacks) {
         LazyObject* const lazy = GetObject(id);
-        const AnimationStack* stack;
-        if(!lazy || !(stack = lazy->Get<AnimationStack>())) {
+        const AnimationStack *stack = lazy->Get<AnimationStack>();
+        if(!lazy || nullptr == stack ) {
             DOMWarning("failed to read AnimationStack object");
             continue;
         }
@@ -541,17 +511,15 @@ const std::vector<const AnimationStack*>& Document::AnimationStacks() const
 }
 
 // ------------------------------------------------------------------------------------------------
-LazyObject* Document::GetObject(uint64_t id) const
-{
+LazyObject* Document::GetObject(uint64_t id) const {
     ObjectMap::const_iterator it = objects.find(id);
     return it == objects.end() ? nullptr : (*it).second;
 }
 
-#define MAX_CLASSNAMES 6
+constexpr size_t MAX_CLASSNAMES  = 6;
 
 // ------------------------------------------------------------------------------------------------
-std::vector<const Connection*> Document::GetConnectionsSequenced(uint64_t id, const ConnectionMap& conns) const
-{
+std::vector<const Connection*> Document::GetConnectionsSequenced(uint64_t id, const ConnectionMap& conns) const {
     std::vector<const Connection*> temp;
 
     const std::pair<ConnectionMap::const_iterator,ConnectionMap::const_iterator> range =
@@ -569,11 +537,9 @@ std::vector<const Connection*> Document::GetConnectionsSequenced(uint64_t id, co
 
 // ------------------------------------------------------------------------------------------------
 std::vector<const Connection*> Document::GetConnectionsSequenced(uint64_t id, bool is_src,
-    const ConnectionMap& conns,
-    const char* const* classnames,
-    size_t count) const
-
-{
+        const ConnectionMap& conns,
+        const char* const* classnames,
+        size_t count) const {
     ai_assert(classnames);
     ai_assert( count != 0 );
     ai_assert( count <= MAX_CLASSNAMES);
@@ -618,95 +584,72 @@ std::vector<const Connection*> Document::GetConnectionsSequenced(uint64_t id, bo
 }
 
 // ------------------------------------------------------------------------------------------------
-std::vector<const Connection*> Document::GetConnectionsBySourceSequenced(uint64_t source) const
-{
+std::vector<const Connection*> Document::GetConnectionsBySourceSequenced(uint64_t source) const {
     return GetConnectionsSequenced(source, ConnectionsBySource());
 }
 
 // ------------------------------------------------------------------------------------------------
-std::vector<const Connection*> Document::GetConnectionsBySourceSequenced(uint64_t src, const char* classname) const
-{
+std::vector<const Connection*> Document::GetConnectionsBySourceSequenced(uint64_t src, const char* classname) const {
     const char* arr[] = {classname};
     return GetConnectionsBySourceSequenced(src, arr,1);
 }
 
 // ------------------------------------------------------------------------------------------------
-std::vector<const Connection*> Document::GetConnectionsBySourceSequenced(uint64_t source, 
-        const char* const* classnames, size_t count) const
-{
+std::vector<const Connection*> Document::GetConnectionsBySourceSequenced(uint64_t source,
+        const char* const* classnames, size_t count) const {
     return GetConnectionsSequenced(source, true, ConnectionsBySource(),classnames, count);
 }
 
 // ------------------------------------------------------------------------------------------------
 std::vector<const Connection*> Document::GetConnectionsByDestinationSequenced(uint64_t dest,
-        const char* classname) const
-{
+        const char* classname) const {
     const char* arr[] = {classname};
     return GetConnectionsByDestinationSequenced(dest, arr,1);
 }
 
 // ------------------------------------------------------------------------------------------------
-std::vector<const Connection*> Document::GetConnectionsByDestinationSequenced(uint64_t dest) const
-{
+std::vector<const Connection*> Document::GetConnectionsByDestinationSequenced(uint64_t dest) const {
     return GetConnectionsSequenced(dest, ConnectionsByDestination());
 }
 
 // ------------------------------------------------------------------------------------------------
 std::vector<const Connection*> Document::GetConnectionsByDestinationSequenced(uint64_t dest,
-    const char* const* classnames, size_t count) const
-
-{
+        const char* const* classnames, size_t count) const {
     return GetConnectionsSequenced(dest, false, ConnectionsByDestination(),classnames, count);
 }
 
 // ------------------------------------------------------------------------------------------------
 Connection::Connection(uint64_t insertionOrder,  uint64_t src, uint64_t dest, const std::string& prop,
-        const Document& doc)
-
-: insertionOrder(insertionOrder)
-, prop(prop)
-, src(src)
-, dest(dest)
-, doc(doc)
-{
+            const Document& doc) :
+            insertionOrder(insertionOrder), prop(prop), src(src), dest(dest), doc(doc) {
     ai_assert(doc.Objects().find(src) != doc.Objects().end());
     // dest may be 0 (root node)
     ai_assert(!dest || doc.Objects().find(dest) != doc.Objects().end());
 }
 
 // ------------------------------------------------------------------------------------------------
-Connection::~Connection()
-{
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-LazyObject& Connection::LazySourceObject() const
-{
+LazyObject& Connection::LazySourceObject() const {
     LazyObject* const lazy = doc.GetObject(src);
     ai_assert(lazy);
     return *lazy;
 }
 
 // ------------------------------------------------------------------------------------------------
-LazyObject& Connection::LazyDestinationObject() const
-{
+LazyObject& Connection::LazyDestinationObject() const {
     LazyObject* const lazy = doc.GetObject(dest);
     ai_assert(lazy);
     return *lazy;
 }
 
 // ------------------------------------------------------------------------------------------------
-const Object* Connection::SourceObject() const
-{
+const Object* Connection::SourceObject() const {
     LazyObject* const lazy = doc.GetObject(src);
     ai_assert(lazy);
     return lazy->Get();
 }
 
 // ------------------------------------------------------------------------------------------------
-const Object* Connection::DestinationObject() const
-{
+const Object* Connection::DestinationObject() const {
     LazyObject* const lazy = doc.GetObject(dest);
     ai_assert(lazy);
     return lazy->Get();
@@ -715,4 +658,4 @@ const Object* Connection::DestinationObject() const
 } // !FBX
 } // !Assimp
 
-#endif
+#endif // ASSIMP_BUILD_NO_FBX_IMPORTER
diff --git a/Engine/lib/assimp/code/FBX/FBXDocument.h b/Engine/lib/assimp/code/AssetLib/FBX/FBXDocument.h
similarity index 95%
rename from Engine/lib/assimp/code/FBX/FBXDocument.h
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXDocument.h
index 18e5c38f1..c61a47410 100644
--- a/Engine/lib/assimp/code/FBX/FBXDocument.h
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXDocument.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -89,14 +88,14 @@ class LazyObject {
 public:
     LazyObject(uint64_t id, const Element& element, const Document& doc);
 
-    ~LazyObject();
+    ~LazyObject() = default;
 
     const Object* Get(bool dieOnError = false);
 
     template <typename T>
     const T* Get(bool dieOnError = false) {
         const Object* const ob = Get(dieOnError);
-        return ob ? dynamic_cast<const T*>(ob) : NULL;
+        return ob ? dynamic_cast<const T *>(ob) : nullptr;
     }
 
     uint64_t ID() const {
@@ -139,7 +138,7 @@ class Object {
 public:
     Object(uint64_t id, const Element& element, const std::string& name);
 
-    virtual ~Object();
+    virtual ~Object() = default;
 
     const Element& SourceElement() const {
         return element;
@@ -213,7 +212,8 @@ private:
     type name() const { \
         const int ival = PropertyGet<int>(Props(), fbx_stringize(name), static_cast<int>(default_value)); \
         if (ival < 0 || ival >= AI_CONCAT(type, _MAX)) { \
-            ai_assert(static_cast<int>(default_value) >= 0 && static_cast<int>(default_value) < AI_CONCAT(type, _MAX)); \
+            ai_assert(static_cast<int>(default_value) >= 0); \
+            ai_assert(static_cast<int>(default_value) < AI_CONCAT(type, _MAX)); \
             return static_cast<type>(default_value); \
         } \
         return static_cast<type>(ival); \
@@ -266,8 +266,7 @@ public:
     Light(uint64_t id, const Element& element, const Document& doc, const std::string& name);
     virtual ~Light();
 
-    enum Type
-    {
+    enum Type {
         Type_Point,
         Type_Directional,
         Type_Spot,
@@ -277,8 +276,7 @@ public:
         Type_MAX // end-of-enum sentinel
     };
 
-    enum Decay
-    {
+    enum Decay {
         Decay_None,
         Decay_Linear,
         Decay_Quadratic,
@@ -346,7 +344,7 @@ public:
 
     Model(uint64_t id, const Element& element, const Document& doc, const std::string& name);
 
-    virtual ~Model();
+    virtual ~Model() = default;
 
     fbx_simple_property(QuaternionInterpolate, int, 0)
 
@@ -499,6 +497,10 @@ public:
         return uvScaling;
     }
 
+    const ai_real &UVRotation() const {
+        return uvRotation;
+    }
+
     const PropertyTable& Props() const {
         ai_assert(props.get());
         return *props.get();
@@ -516,6 +518,7 @@ public:
 private:
     aiVector2D uvTrans;
     aiVector2D uvScaling;
+    ai_real    uvRotation;
 
     std::string type;
     std::string relativeFileName;
@@ -572,31 +575,27 @@ public:
         BlendMode_BlendModeCount
     };
 
-    const Texture* getTexture(int index=0) const
-    {
+    const Texture* getTexture(int index=0) const {
 		return textures[index];
-
     }
 	int textureCount() const {
 		return static_cast<int>(textures.size());
 	}
-    BlendMode GetBlendMode() const
-    {
+    BlendMode GetBlendMode() const {
         return blendMode;
     }
-    float Alpha()
-    {
+    float Alpha() {
         return alpha;
     }
+
 private:
 	std::vector<const Texture*> textures;
     BlendMode blendMode;
     float alpha;
 };
 
-typedef std::fbx_unordered_map<std::string, const Texture*> TextureMap;
-typedef std::fbx_unordered_map<std::string, const LayeredTexture*> LayeredTextureMap;
-
+using TextureMap = std::fbx_unordered_map<std::string, const Texture*>;
+using LayeredTextureMap = std::fbx_unordered_map<std::string, const LayeredTexture*>;
 
 /** DOM class for generic FBX videos */
 class Video : public Object {
@@ -684,10 +683,10 @@ private:
     LayeredTextureMap layeredTextures;
 };
 
-typedef std::vector<int64_t> KeyTimeList;
-typedef std::vector<float> KeyValueList;
+using KeyTimeList = std::vector<int64_t>;
+using KeyValueList = std::vector<float>;
 
-/** Represents a FBX animation curve (i.e. a 1-dimensional set of keyframes and values therefor) */
+/** Represents a FBX animation curve (i.e. a 1-dimensional set of keyframes and values therefore) */
 class AnimationCurve : public Object {
 public:
     AnimationCurve(uint64_t id, const Element& element, const std::string& name, const Document& doc);
@@ -721,7 +720,7 @@ private:
 };
 
 // property-name -> animation curve
-typedef std::map<std::string, const AnimationCurve*> AnimationCurveMap;
+using AnimationCurveMap = std::map<std::string, const AnimationCurve*>;
 
 /** Represents a FBX animation curve (i.e. a mapping from single animation curves to nodes) */
 class AnimationCurveNode : public Object {
@@ -730,7 +729,7 @@ public:
     wants animations for. If the curve node does not match one of these, std::range_error
     will be thrown. */
     AnimationCurveNode(uint64_t id, const Element& element, const std::string& name, const Document& doc,
-        const char* const * target_prop_whitelist = NULL, size_t whitelist_size = 0);
+            const char *const *target_prop_whitelist = nullptr, size_t whitelist_size = 0);
 
     virtual ~AnimationCurveNode();
 
@@ -742,7 +741,7 @@ public:
 
     const AnimationCurveMap& Curves() const;
 
-    /** Object the curve is assigned to, this can be NULL if the
+    /** Object the curve is assigned to, this can be nullptr if the
      *  target object has no DOM representation or could not
      *  be read for other reasons.*/
     const Object* Target() const {
@@ -771,7 +770,7 @@ private:
     const Document& doc;
 };
 
-typedef std::vector<const AnimationCurveNode*> AnimationCurveNodeList;
+using AnimationCurveNodeList = std::vector<const AnimationCurveNode*>;
 
 /** Represents a FBX animation layer (i.e. a list of node animations) */
 class AnimationLayer : public Object {
@@ -794,7 +793,7 @@ private:
     const Document& doc;
 };
 
-typedef std::vector<const AnimationLayer*> AnimationLayerList;
+using AnimationLayerList = std::vector<const AnimationLayer*>;
 
 /** Represents a FBX animation stack (i.e. a list of animation layers) */
 class AnimationStack : public Object {
@@ -837,8 +836,8 @@ private:
     std::shared_ptr<const PropertyTable> props;
 };
 
-typedef std::vector<float> WeightArray;
-typedef std::vector<unsigned int> WeightIndexArray;
+using WeightArray = std::vector<float>;
+using WeightIndexArray = std::vector<unsigned int>;
 
 
 /** DOM class for BlendShapeChannel deformers */
@@ -950,11 +949,11 @@ class Connection {
 public:
     Connection(uint64_t insertionOrder,  uint64_t src, uint64_t dest, const std::string& prop, const Document& doc);
 
-    ~Connection();
+    ~Connection() = default;
 
     // note: a connection ensures that the source and dest objects exist, but
     // not that they have DOM representations, so the return value of one of
-    // these functions can still be NULL.
+    // these functions can still be nullptr.
     const Object* SourceObject() const;
     const Object* DestinationObject() const;
 
@@ -1005,10 +1004,9 @@ public:
 // during their entire lifetime (Document). FBX files have
 // up to many thousands of objects (most of which we never use),
 // so the memory overhead for them should be kept at a minimum.
-typedef std::map<uint64_t, LazyObject*> ObjectMap;
-typedef std::fbx_unordered_map<std::string, std::shared_ptr<const PropertyTable> > PropertyTemplateMap;
-
-typedef std::multimap<uint64_t, const Connection*> ConnectionMap;
+using ObjectMap = std::fbx_unordered_map<uint64_t, LazyObject*> ;
+using PropertyTemplateMap = std::fbx_unordered_map<std::string, std::shared_ptr<const PropertyTable> > ;
+using ConnectionMap = std::fbx_unordered_multimap<uint64_t, const Connection*>;
 
 /** DOM class for global document settings, a single instance per document can
  *  be accessed via Document.Globals(). */
@@ -1016,7 +1014,7 @@ class FileGlobalSettings {
 public:
     FileGlobalSettings(const Document& doc, std::shared_ptr<const PropertyTable> props);
 
-    ~FileGlobalSettings();
+    ~FileGlobalSettings() = default;
 
     const PropertyTable& Props() const {
         ai_assert(props.get());
diff --git a/Engine/lib/assimp/code/FBX/FBXDocumentUtil.cpp b/Engine/lib/assimp/code/AssetLib/FBX/FBXDocumentUtil.cpp
similarity index 91%
rename from Engine/lib/assimp/code/FBX/FBXDocumentUtil.cpp
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXDocumentUtil.cpp
index f84691479..68185e564 100644
--- a/Engine/lib/assimp/code/FBX/FBXDocumentUtil.cpp
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXDocumentUtil.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -61,16 +61,16 @@ namespace Util {
 // signal DOM construction error, this is always unrecoverable. Throws DeadlyImportError.
 void DOMError(const std::string& message, const Token& token)
 {
-    throw DeadlyImportError(Util::AddTokenText("FBX-DOM",message,&token));
+    throw DeadlyImportError("FBX-DOM", Util::GetTokenText(&token), message);
 }
 
 // ------------------------------------------------------------------------------------------------
-void DOMError(const std::string& message, const Element* element /*= NULL*/)
+void DOMError(const std::string& message, const Element* element /*= nullptr*/)
 {
     if(element) {
         DOMError(message,element->KeyToken());
     }
-    throw DeadlyImportError("FBX-DOM " + message);
+    throw DeadlyImportError("FBX-DOM ", message);
 }
 
 
@@ -79,19 +79,19 @@ void DOMError(const std::string& message, const Element* element /*= NULL*/)
 void DOMWarning(const std::string& message, const Token& token)
 {
     if(DefaultLogger::get()) {
-        ASSIMP_LOG_WARN(Util::AddTokenText("FBX-DOM",message,&token));
+        ASSIMP_LOG_WARN("FBX-DOM", Util::GetTokenText(&token), message);
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void DOMWarning(const std::string& message, const Element* element /*= NULL*/)
+void DOMWarning(const std::string& message, const Element* element /*= nullptr*/)
 {
     if(element) {
         DOMWarning(message,element->KeyToken());
         return;
     }
     if(DefaultLogger::get()) {
-        ASSIMP_LOG_WARN("FBX-DOM: " + message);
+        ASSIMP_LOG_WARN("FBX-DOM: ", message);
     }
 }
 
@@ -106,7 +106,7 @@ std::shared_ptr<const PropertyTable> GetPropertyTable(const Document& doc,
 {
     const Element* const Properties70 = sc["Properties70"];
     std::shared_ptr<const PropertyTable> templateProps = std::shared_ptr<const PropertyTable>(
-        static_cast<const PropertyTable*>(NULL));
+            static_cast<const PropertyTable *>(nullptr));
 
     if(templateName.length()) {
         PropertyTemplateMap::const_iterator it = doc.Templates().find(templateName);
diff --git a/Engine/lib/assimp/code/FBX/FBXDocumentUtil.h b/Engine/lib/assimp/code/AssetLib/FBX/FBXDocumentUtil.h
similarity index 99%
rename from Engine/lib/assimp/code/FBX/FBXDocumentUtil.h
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXDocumentUtil.h
index 2450109e5..2d76ee031 100644
--- a/Engine/lib/assimp/code/FBX/FBXDocumentUtil.h
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXDocumentUtil.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2012, assimp team
+Copyright (c) 2006-2020, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
diff --git a/Engine/lib/assimp/code/FBX/FBXExportNode.cpp b/Engine/lib/assimp/code/AssetLib/FBX/FBXExportNode.cpp
similarity index 88%
rename from Engine/lib/assimp/code/FBX/FBXExportNode.cpp
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXExportNode.cpp
index 06c89cee4..21c61b257 100644
--- a/Engine/lib/assimp/code/FBX/FBXExportNode.cpp
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXExportNode.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -62,90 +62,81 @@ namespace Assimp {
 // so they are specified with an 'A' suffix.
 
 void FBX::Node::AddP70int(
-    const std::string& name, int32_t value
+    const std::string& cur_name, int32_t value
 ) {
     FBX::Node n("P");
-    n.AddProperties(name, "int", "Integer", "", value);
+    n.AddProperties(cur_name, "int", "Integer", "", value);
     AddChild(n);
 }
 
 void FBX::Node::AddP70bool(
-    const std::string& name, bool value
+    const std::string& cur_name, bool value
 ) {
     FBX::Node n("P");
-    n.AddProperties(name, "bool", "", "", int32_t(value));
+    n.AddProperties(cur_name, "bool", "", "", int32_t(value));
     AddChild(n);
 }
 
 void FBX::Node::AddP70double(
-    const std::string& name, double value
-) {
+        const std::string &cur_name, double value) {
     FBX::Node n("P");
-    n.AddProperties(name, "double", "Number", "", value);
+    n.AddProperties(cur_name, "double", "Number", "", value);
     AddChild(n);
 }
 
 void FBX::Node::AddP70numberA(
-    const std::string& name, double value
-) {
+        const std::string &cur_name, double value) {
     FBX::Node n("P");
-    n.AddProperties(name, "Number", "", "A", value);
+    n.AddProperties(cur_name, "Number", "", "A", value);
     AddChild(n);
 }
 
 void FBX::Node::AddP70color(
-    const std::string& name, double r, double g, double b
-) {
+        const std::string &cur_name, double r, double g, double b) {
     FBX::Node n("P");
-    n.AddProperties(name, "ColorRGB", "Color", "", r, g, b);
+    n.AddProperties(cur_name, "ColorRGB", "Color", "", r, g, b);
     AddChild(n);
 }
 
 void FBX::Node::AddP70colorA(
-    const std::string& name, double r, double g, double b
-) {
+        const std::string &cur_name, double r, double g, double b) {
     FBX::Node n("P");
-    n.AddProperties(name, "Color", "", "A", r, g, b);
+    n.AddProperties(cur_name, "Color", "", "A", r, g, b);
     AddChild(n);
 }
 
 void FBX::Node::AddP70vector(
-    const std::string& name, double x, double y, double z
-) {
+        const std::string &cur_name, double x, double y, double z) {
     FBX::Node n("P");
-    n.AddProperties(name, "Vector3D", "Vector", "", x, y, z);
+    n.AddProperties(cur_name, "Vector3D", "Vector", "", x, y, z);
     AddChild(n);
 }
 
 void FBX::Node::AddP70vectorA(
-    const std::string& name, double x, double y, double z
-) {
+        const std::string &cur_name, double x, double y, double z) {
     FBX::Node n("P");
-    n.AddProperties(name, "Vector", "", "A", x, y, z);
+    n.AddProperties(cur_name, "Vector", "", "A", x, y, z);
     AddChild(n);
 }
 
 void FBX::Node::AddP70string(
-    const std::string& name, const std::string& value
-) {
+        const std::string &cur_name, const std::string &value) {
     FBX::Node n("P");
-    n.AddProperties(name, "KString", "", "", value);
+    n.AddProperties(cur_name, "KString", "", "", value);
     AddChild(n);
 }
 
 void FBX::Node::AddP70enum(
-    const std::string& name, int32_t value
-) {
+        const std::string &cur_name, int32_t value) {
     FBX::Node n("P");
-    n.AddProperties(name, "enum", "", "", value);
+    n.AddProperties(cur_name, "enum", "", "", value);
     AddChild(n);
 }
 
 void FBX::Node::AddP70time(
-    const std::string& name, int64_t value
-) {
+        const std::string &cur_name, int64_t value) {
     FBX::Node n("P");
-    n.AddProperties(name, "KTime", "Time", "", value);
+    n.AddProperties(cur_name, "KTime", "Time", "", value);
     AddChild(n);
 }
 
@@ -153,9 +144,8 @@ void FBX::Node::AddP70time(
 // public member functions for writing nodes to stream
 
 void FBX::Node::Dump(
-    std::shared_ptr<Assimp::IOStream> outfile,
-    bool binary, int indent
-) {
+        const std::shared_ptr<Assimp::IOStream> &outfile,
+        bool binary, int indent) {
     if (binary) {
         Assimp::StreamWriterLE outstream(outfile);
         DumpBinary(outstream);
@@ -325,9 +315,9 @@ void FBX::Node::BeginBinary(Assimp::StreamWriterLE &s)
     this->start_pos = s.Tell();
 
     // placeholders for end pos and property section info
-    s.PutU4(0); // end pos
-    s.PutU4(0); // number of properties
-    s.PutU4(0); // total property section length
+    s.PutU8(0); // end pos
+    s.PutU8(0); // number of properties
+    s.PutU8(0); // total property section length
 
     // node name
     s.PutU1(uint8_t(name.size())); // length of node name
@@ -352,9 +342,9 @@ void FBX::Node::EndPropertiesBinary(
     size_t pos = s.Tell();
     ai_assert(pos > property_start);
     size_t property_section_size = pos - property_start;
-    s.Seek(start_pos + 4);
-    s.PutU4(uint32_t(num_properties));
-    s.PutU4(uint32_t(property_section_size));
+    s.Seek(start_pos + 8); // 8 bytes of uint64_t of end_pos
+    s.PutU8(num_properties);
+    s.PutU8(property_section_size);
     s.Seek(pos);
 }
 
@@ -375,7 +365,7 @@ void FBX::Node::EndBinary(
     // now go back and write initial pos
     this->end_pos = s.Tell();
     s.Seek(start_pos);
-    s.PutU4(uint32_t(end_pos));
+    s.PutU8(end_pos);
     s.Seek(end_pos);
 }
 
@@ -435,7 +425,7 @@ void FBX::Node::WritePropertyNodeAscii(
     char buffer[32];
     FBX::Node node(name);
     node.Begin(s, false, indent);
-    std::string vsize = to_string(v.size());
+    std::string vsize = ai_to_string(v.size());
     // *<size> {
     s.PutChar('*'); s.PutString(vsize); s.PutString(" {\n");
     // indent + 1
@@ -471,7 +461,7 @@ void FBX::Node::WritePropertyNodeAscii(
     char buffer[32];
     FBX::Node node(name);
     node.Begin(s, false, indent);
-    std::string vsize = to_string(v.size());
+    std::string vsize = ai_to_string(v.size());
     // *<size> {
     s.PutChar('*'); s.PutString(vsize); s.PutString(" {\n");
     // indent + 1
diff --git a/Engine/lib/assimp/code/FBX/FBXExportNode.h b/Engine/lib/assimp/code/AssetLib/FBX/FBXExportNode.h
similarity index 98%
rename from Engine/lib/assimp/code/FBX/FBXExportNode.h
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXExportNode.h
index ef3bc781a..c6c4549d5 100644
--- a/Engine/lib/assimp/code/FBX/FBXExportNode.h
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXExportNode.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -60,7 +60,7 @@ namespace FBX {
 }
 
 class FBX::Node {
-public: 
+public:
     // TODO: accessors
     std::string name; // node name
     std::vector<FBX::FBXExportProperty> properties; // node properties
@@ -157,9 +157,8 @@ public: // member functions for writing data to a file or stream
 
     // write the full node to the given file or stream
     void Dump(
-        std::shared_ptr<Assimp::IOStream> outfile,
-        bool binary, int indent
-    );
+            const std::shared_ptr<Assimp::IOStream> &outfile,
+            bool binary, int indent);
     void Dump(Assimp::StreamWriterLE &s, bool binary, int indent);
 
     // these other functions are for writing data piece by piece.
diff --git a/Engine/lib/assimp/code/FBX/FBXExportProperty.cpp b/Engine/lib/assimp/code/AssetLib/FBX/FBXExportProperty.cpp
similarity index 99%
rename from Engine/lib/assimp/code/FBX/FBXExportProperty.cpp
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXExportProperty.cpp
index f2a63b72b..3216d7d85 100644
--- a/Engine/lib/assimp/code/FBX/FBXExportProperty.cpp
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXExportProperty.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/Engine/lib/assimp/code/FBX/FBXExportProperty.h b/Engine/lib/assimp/code/AssetLib/FBX/FBXExportProperty.h
similarity index 99%
rename from Engine/lib/assimp/code/FBX/FBXExportProperty.h
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXExportProperty.h
index d692fe6ee..26d0cf223 100644
--- a/Engine/lib/assimp/code/FBX/FBXExportProperty.h
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXExportProperty.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/Engine/lib/assimp/code/FBX/FBXExporter.cpp b/Engine/lib/assimp/code/AssetLib/FBX/FBXExporter.cpp
similarity index 88%
rename from Engine/lib/assimp/code/FBX/FBXExporter.cpp
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXExporter.cpp
index 25d057df1..695672883 100644
--- a/Engine/lib/assimp/code/FBX/FBXExporter.cpp
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXExporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -81,8 +81,8 @@ using namespace Assimp::FBX;
 // some constants that we'll use for writing metadata
 namespace Assimp {
 namespace FBX {
-    const std::string EXPORT_VERSION_STR = "7.4.0";
-    const uint32_t EXPORT_VERSION_INT = 7400; // 7.4 == 2014/2015
+    const std::string EXPORT_VERSION_STR = "7.5.0";
+    const uint32_t EXPORT_VERSION_INT = 7500; // 7.5 == 2016+
     // FBX files have some hashed values that depend on the creation time field,
     // but for now we don't actually know how to generate these.
     // what we can do is set them to a known-working version.
@@ -400,6 +400,65 @@ void FBXExporter::WriteHeaderExtension ()
     );
 }
 
+// WriteGlobalSettings helpers
+
+void WritePropInt(const aiScene* scene, FBX::Node& p, const std::string& key, int defaultValue)
+{
+    int value;
+    if (scene->mMetaData != nullptr && scene->mMetaData->Get(key, value)) {
+        p.AddP70int(key, value);
+    } else {
+        p.AddP70int(key, defaultValue);
+    }
+}
+
+void WritePropDouble(const aiScene* scene, FBX::Node& p, const std::string& key, double defaultValue)
+{
+    double value;
+    if (scene->mMetaData != nullptr && scene->mMetaData->Get(key, value)) {
+        p.AddP70double(key, value);
+    } else {
+        // fallback lookup float instead
+        float floatValue;
+        if (scene->mMetaData != nullptr && scene->mMetaData->Get(key, floatValue)) {
+            p.AddP70double(key, (double)floatValue);
+        } else {
+            p.AddP70double(key, defaultValue);
+        }
+    }
+}
+
+void WritePropEnum(const aiScene* scene, FBX::Node& p, const std::string& key, int defaultValue)
+{
+    int value;
+    if (scene->mMetaData != nullptr && scene->mMetaData->Get(key, value)) {
+        p.AddP70enum(key, value);
+    } else {
+        p.AddP70enum(key, defaultValue);
+    }
+}
+
+void WritePropColor(const aiScene* scene, FBX::Node& p, const std::string& key, const aiVector3D& defaultValue)
+{
+    aiVector3D value;
+    if (scene->mMetaData != nullptr && scene->mMetaData->Get(key, value)) {
+        // ai_real can be float or double, cast to avoid warnings
+        p.AddP70color(key, (double)value.x, (double)value.y, (double)value.z);
+    } else {
+        p.AddP70color(key, (double)defaultValue.x, (double)defaultValue.y, (double)defaultValue.z);
+    }
+}
+
+void WritePropString(const aiScene* scene, FBX::Node& p, const std::string& key, const std::string& defaultValue)
+{
+    aiString value; // MetaData doesn't hold std::string
+    if (scene->mMetaData != nullptr && scene->mMetaData->Get(key, value)) {
+        p.AddP70string(key, value.C_Str());
+    } else {
+        p.AddP70string(key, defaultValue);
+    }
+}
+
 void FBXExporter::WriteGlobalSettings ()
 {
     if (!binary) {
@@ -409,26 +468,26 @@ void FBXExporter::WriteGlobalSettings ()
     gs.AddChild("Version", int32_t(1000));
 
     FBX::Node p("Properties70");
-    p.AddP70int("UpAxis", 1);
-    p.AddP70int("UpAxisSign", 1);
-    p.AddP70int("FrontAxis", 2);
-    p.AddP70int("FrontAxisSign", 1);
-    p.AddP70int("CoordAxis", 0);
-    p.AddP70int("CoordAxisSign", 1);
-    p.AddP70int("OriginalUpAxis", 1);
-    p.AddP70int("OriginalUpAxisSign", 1);
-    p.AddP70double("UnitScaleFactor", 1.0);
-    p.AddP70double("OriginalUnitScaleFactor", 1.0);
-    p.AddP70color("AmbientColor", 0.0, 0.0, 0.0);
-    p.AddP70string("DefaultCamera", "Producer Perspective");
-    p.AddP70enum("TimeMode", 11);
-    p.AddP70enum("TimeProtocol", 2);
-    p.AddP70enum("SnapOnFrameMode", 0);
+    WritePropInt(mScene, p, "UpAxis", 1);
+    WritePropInt(mScene, p, "UpAxisSign", 1);
+    WritePropInt(mScene, p, "FrontAxis", 2);
+    WritePropInt(mScene, p, "FrontAxisSign", 1);
+    WritePropInt(mScene, p, "CoordAxis", 0);
+    WritePropInt(mScene, p, "CoordAxisSign", 1);
+    WritePropInt(mScene, p, "OriginalUpAxis", 1);
+    WritePropInt(mScene, p, "OriginalUpAxisSign", 1);
+    WritePropDouble(mScene, p, "UnitScaleFactor", 1.0);
+    WritePropDouble(mScene, p, "OriginalUnitScaleFactor", 1.0);
+    WritePropColor(mScene, p, "AmbientColor", aiVector3D((ai_real)0.0, (ai_real)0.0, (ai_real)0.0));
+    WritePropString(mScene, p,"DefaultCamera", "Producer Perspective");
+    WritePropEnum(mScene, p, "TimeMode", 11);
+    WritePropEnum(mScene, p, "TimeProtocol", 2);
+    WritePropEnum(mScene, p, "SnapOnFrameMode", 0);
     p.AddP70time("TimeSpanStart", 0); // TODO: animation support
     p.AddP70time("TimeSpanStop", FBX::SECOND); // TODO: animation support
-    p.AddP70double("CustomFrameRate", -1.0);
+    WritePropDouble(mScene, p, "CustomFrameRate", -1.0);
     p.AddP70("TimeMarker", "Compound", "", ""); // not sure what this is
-    p.AddP70int("CurrentTimeMarker", -1);
+    WritePropInt(mScene, p, "CurrentTimeMarker", -1);
     gs.AddChild(p);
 
     gs.Dump(outfile, binary, 0);
@@ -439,7 +498,7 @@ void FBXExporter::WriteDocuments ()
     if (!binary) {
         WriteAsciiSectionHeader("Documents Description");
     }
-    
+
     // not sure what the use of multiple documents would be,
     // or whether any end-application supports it
     FBX::Node docs("Documents");
@@ -482,10 +541,17 @@ void FBXExporter::WriteReferences ()
 // (before any actual data is written)
 // ---------------------------------------------------------------
 
-size_t count_nodes(const aiNode* n) {
-    size_t count = 1;
+size_t count_nodes(const aiNode* n, const aiNode* root) {
+    size_t count;
+    if (n == root) {
+        count = n->mNumMeshes; // (not counting root node)
+    } else if (n->mNumMeshes > 1) {
+        count = n->mNumMeshes + 1;
+    } else {
+        count = 1;
+    }
     for (size_t i = 0; i < n->mNumChildren; ++i) {
-        count += count_nodes(n->mChildren[i]);
+        count += count_nodes(n->mChildren[i], root);
     }
     return count;
 }
@@ -655,7 +721,7 @@ void FBXExporter::WriteDefinitions ()
 
     // Model / FbxNode
     // <~~ node hierarchy
-    count = int32_t(count_nodes(mScene->mRootNode)) - 1; // (not counting root node)
+    count = int32_t(count_nodes(mScene->mRootNode, mScene->mRootNode));
     if (count) {
         n = FBX::Node("ObjectType", "Model");
         n.AddChild("Count", count);
@@ -753,6 +819,18 @@ void FBXExporter::WriteDefinitions ()
     // Geometry / FbxMesh
     // <~~ aiMesh
     count = mScene->mNumMeshes;
+
+    // Blendshapes are considered Geometry
+    int32_t bsDeformerCount=0;
+    for (size_t mi = 0; mi < mScene->mNumMeshes; ++mi) {
+        aiMesh* m = mScene->mMeshes[mi];
+        if (m->mNumAnimMeshes > 0) {
+          count+=m->mNumAnimMeshes;
+          bsDeformerCount+=m->mNumAnimMeshes; // One deformer per blendshape
+          bsDeformerCount++;                  // Plus one master blendshape deformer
+        }
+    }
+
     if (count) {
         n = FBX::Node("ObjectType", "Geometry");
         n.AddChild("Count", count);
@@ -919,7 +997,7 @@ void FBXExporter::WriteDefinitions ()
     }
 
     // Deformer
-    count = int32_t(count_deformers(mScene));
+    count = int32_t(count_deformers(mScene))+bsDeformerCount;
     if (count) {
         n = FBX::Node("ObjectType", "Deformer");
         n.AddChild("Count", count);
@@ -944,7 +1022,9 @@ void FBXExporter::WriteDefinitions ()
     FBX::Node defs("Definitions");
     defs.AddChild("Version", int32_t(100));
     defs.AddChild("Count", int32_t(total_count));
-    for (auto &n : object_nodes) { defs.AddChild(n); }
+    for (auto &on : object_nodes) {
+        defs.AddChild(on);
+    }
     defs.Dump(outfile, binary, 0);
 }
 
@@ -1119,10 +1199,10 @@ void FBXExporter::WriteObjects ()
             for (size_t fi = 0; fi < m->mNumFaces; ++fi) {
                 const aiFace &f = m->mFaces[fi];
                 for (size_t pvi = 0; pvi < f.mNumIndices; ++pvi) {
-                    const aiVector3D &n = m->mNormals[f.mIndices[pvi]];
-                    normal_data.push_back(n.x);
-                    normal_data.push_back(n.y);
-                    normal_data.push_back(n.z);
+                    const aiVector3D &curN = m->mNormals[f.mIndices[pvi]];
+                    normal_data.push_back(curN.x);
+                    normal_data.push_back(curN.y);
+                    normal_data.push_back(curN.z);
                 }
             }
             FBX::Node::WritePropertyNode(
@@ -1178,7 +1258,7 @@ void FBXExporter::WriteObjects ()
             indent = 2;
             vertexcolors.End(outstream, binary, indent, true);
         }
-        
+
         // uvs, if any
         for (size_t uvi = 0; uvi < m->GetNumUVChannels(); ++uvi) {
             if (m->mNumUVComponents[uvi] > 2) {
@@ -1226,14 +1306,14 @@ void FBXExporter::WriteObjects ()
             for (size_t fi = 0; fi < m->mNumFaces; ++fi) {
                 const aiFace &f = m->mFaces[fi];
                 for (size_t pvi = 0; pvi < f.mNumIndices; ++pvi) {
-                    const aiVector3D &uv =
+                    const aiVector3D &curUv =
                         m->mTextureCoords[uvi][f.mIndices[pvi]];
-                    auto elem = index_by_uv.find(uv);
+                    auto elem = index_by_uv.find(curUv);
                     if (elem == index_by_uv.end()) {
-                        index_by_uv[uv] = index;
+                        index_by_uv[curUv] = index;
                         uv_indices.push_back(index);
                         for (unsigned int x = 0; x < m->mNumUVComponents[uvi]; ++x) {
-                            uv_data.push_back(uv[x]);
+                            uv_data.push_back(curUv[x]);
                         }
                         ++index;
                     } else {
@@ -1289,7 +1369,7 @@ void FBXExporter::WriteObjects ()
 
         for(unsigned int lr = 1; lr < m->GetNumUVChannels(); ++ lr)
         {
-            FBX::Node layerExtra("Layer", int32_t(1));
+            FBX::Node layerExtra("Layer", int32_t(lr));
             layerExtra.AddChild("Version", int32_t(100));
             FBX::Node leExtra("LayerElement");
             leExtra.AddChild("Type", "LayerElementUV");
@@ -1302,6 +1382,7 @@ void FBXExporter::WriteObjects ()
         n.End(outstream, binary, indent, true);
     }
 
+
     // aiMaterial
     material_uids.clear();
     for (size_t i = 0; i < mScene->mNumMaterials; ++i) {
@@ -1607,6 +1688,10 @@ void FBXExporter::WriteObjects ()
             // link the image data to the texture
             connections.emplace_back("C", "OO", image_uid, texture_uid);
 
+            aiUVTransform trafo;
+            unsigned int max = sizeof(aiUVTransform);
+            aiGetMaterialFloatArray(mat, AI_MATKEY_UVTRANSFORM(aiTextureType_DIFFUSE, 0), (ai_real *)&trafo, &max);
+
             // now write the actual texture node
             FBX::Node tnode("Texture");
             // TODO: some way to determine texture name?
@@ -1617,11 +1702,14 @@ void FBXExporter::WriteObjects ()
             tnode.AddChild("Version", int32_t(202));
             tnode.AddChild("TextureName", texture_name);
             FBX::Node p("Properties70");
+            p.AddP70vectorA("Translation", trafo.mTranslation[0], trafo.mTranslation[1], 0.0);
+            p.AddP70vectorA("Rotation", 0, 0, trafo.mRotation);
+            p.AddP70vectorA("Scaling", trafo.mScaling[0], trafo.mScaling[1], 0.0);
             p.AddP70enum("CurrentTextureBlendMode", 0); // TODO: verify
             //p.AddP70string("UVSet", ""); // TODO: how should this work?
             p.AddP70bool("UseMaterial", 1);
             tnode.AddChild(p);
-            // can't easily detrmine which texture path will be correct,
+            // can't easily determine which texture path will be correct,
             // so just store what we have in every field.
             // these being incorrect is a common problem with FBX anyway.
             tnode.AddChild("FileName", texture_path);
@@ -1636,6 +1724,100 @@ void FBXExporter::WriteObjects ()
         }
     }
 
+    // Blendshapes, if any
+    for (size_t mi = 0; mi < mScene->mNumMeshes; ++mi) {
+      const aiMesh* m = mScene->mMeshes[mi];
+      if (m->mNumAnimMeshes == 0) {
+        continue;
+      }
+      // make a deformer for this mesh
+      int64_t deformer_uid = generate_uid();
+      FBX::Node dnode("Deformer");
+      dnode.AddProperties(deformer_uid, m->mName.data + FBX::SEPARATOR + "Blendshapes", "BlendShape");
+      dnode.AddChild("Version", int32_t(101));
+      dnode.Dump(outstream, binary, indent);
+      // connect it
+      connections.emplace_back("C", "OO", deformer_uid, mesh_uids[mi]);
+      std::vector<int32_t> vertex_indices = vVertexIndice[mi];
+
+      for (unsigned int am = 0; am < m->mNumAnimMeshes; ++am) {
+        aiAnimMesh *pAnimMesh = m->mAnimMeshes[am];
+        std::string blendshape_name = pAnimMesh->mName.data;
+
+        // start the node record
+        FBX::Node bsnode("Geometry");
+        int64_t blendshape_uid = generate_uid();
+        mesh_uids.push_back(blendshape_uid);
+        bsnode.AddProperty(blendshape_uid);
+        bsnode.AddProperty(blendshape_name + FBX::SEPARATOR + "Blendshape");
+        bsnode.AddProperty("Shape");
+        bsnode.AddChild("Version", int32_t(100));
+        bsnode.Begin(outstream, binary, indent);
+        bsnode.DumpProperties(outstream, binary, indent);
+        bsnode.EndProperties(outstream, binary, indent);
+        bsnode.BeginChildren(outstream, binary, indent);
+        indent++;
+        if (pAnimMesh->HasPositions()) {
+          std::vector<int32_t>shape_indices;
+          std::vector<double>pPositionDiff;
+          std::vector<double>pNormalDiff;
+
+          for (unsigned int vt = 0; vt < vertex_indices.size(); ++vt) {
+              aiVector3D pDiff = (pAnimMesh->mVertices[vertex_indices[vt]] - m->mVertices[vertex_indices[vt]]);
+              if(pDiff.Length()>1e-8){
+                shape_indices.push_back(vertex_indices[vt]);
+                pPositionDiff.push_back(pDiff[0]);
+                pPositionDiff.push_back(pDiff[1]);
+                pPositionDiff.push_back(pDiff[2]);
+
+                if (pAnimMesh->HasNormals()) {
+                    aiVector3D nDiff = (pAnimMesh->mNormals[vertex_indices[vt]] - m->mNormals[vertex_indices[vt]]);
+                    pNormalDiff.push_back(nDiff[0]);
+                    pNormalDiff.push_back(nDiff[1]);
+                    pNormalDiff.push_back(nDiff[2]);
+                }
+              }
+          }
+
+          FBX::Node::WritePropertyNode(
+              "Indexes", shape_indices, outstream, binary, indent
+          );
+
+          FBX::Node::WritePropertyNode(
+              "Vertices", pPositionDiff, outstream, binary, indent
+          );
+
+          if (pNormalDiff.size()>0) {
+            FBX::Node::WritePropertyNode(
+                "Normals", pNormalDiff, outstream, binary, indent
+            );
+          }
+        }
+        indent--;
+        bsnode.End(outstream, binary, indent, true);
+
+        // Add blendshape Channel Deformer
+        FBX::Node sdnode("Deformer");
+        const int64_t blendchannel_uid = generate_uid();
+        sdnode.AddProperties(
+            blendchannel_uid, blendshape_name + FBX::SEPARATOR + "SubDeformer", "BlendShapeChannel"
+        );
+        sdnode.AddChild("Version", int32_t(100));
+        sdnode.AddChild("DeformPercent", float(0.0));
+        FBX::Node p("Properties70");
+        p.AddP70numberA("DeformPercent", 0.0);
+        sdnode.AddChild(p);
+        // TODO: Normally just one weight per channel, adding stub for later development
+        std::vector<float>fFullWeights;
+        fFullWeights.push_back(100.);
+        sdnode.AddChild("FullWeights", fFullWeights);
+        sdnode.Dump(outstream, binary, indent);
+
+        connections.emplace_back("C", "OO", blendchannel_uid, deformer_uid);
+        connections.emplace_back("C", "OO", blendshape_uid, blendchannel_uid);
+      }
+    }
+
     // bones.
     //
     // output structure:
@@ -1695,7 +1877,7 @@ void FBXExporter::WriteObjects ()
     // at the same time we can build a list of all the skeleton nodes,
     // which will be used later to mark them as type "limbNode".
     std::unordered_set<const aiNode*> limbnodes;
-    
+
     //actual bone nodes in fbx, without parenting-up
     std::unordered_set<std::string> setAllBoneNamesInScene;
     for(unsigned int m = 0; m < mScene->mNumMeshes; ++ m)
@@ -1705,7 +1887,7 @@ void FBXExporter::WriteObjects ()
             setAllBoneNamesInScene.insert(pMesh->mBones[b]->mName.data);
     }
     aiMatrix4x4 mxTransIdentity;
-    
+
     // and a map of nodes by bone name, as finding them is annoying.
     std::map<std::string,aiNode*> node_by_bone;
     for (size_t mi = 0; mi < mScene->mNumMeshes; ++mi) {
@@ -1733,7 +1915,7 @@ void FBXExporter::WriteObjects ()
             // mark all parent nodes as skeleton as well,
             // up until we find the root node,
             // or else the node containing the mesh,
-            // or else the parent of a node containig the mesh.
+            // or else the parent of a node containing the mesh.
             for (
                 const aiNode* parent = n->mParent;
                 parent && parent != mScene->mRootNode;
@@ -1774,7 +1956,7 @@ void FBXExporter::WriteObjects ()
                     }
                     if (end) { break; }
                 }
-                
+
                 // if it was the skeleton root we can finish here
                 if (end) { break; }
             }
@@ -1860,6 +2042,7 @@ void FBXExporter::WriteObjects ()
             sdnode.AddChild("Version", int32_t(100));
             sdnode.AddChild("UserData", "", "");
 
+            std::set<int32_t> setWeightedVertex;
             // add indices and weights, if any
             if (b) {
                 std::vector<int32_t> subdef_indices;
@@ -1867,7 +2050,8 @@ void FBXExporter::WriteObjects ()
                 int32_t last_index = -1;
                 for (size_t wi = 0; wi < b->mNumWeights; ++wi) {
                     int32_t vi = vertex_indices[b->mWeights[wi].mVertexId];
-                    if (vi == last_index) {
+                    bool bIsWeightedAlready = (setWeightedVertex.find(vi) != setWeightedVertex.end());
+                    if (vi == last_index || bIsWeightedAlready) {
                         // only for vertices we exported to fbx
                         // TODO, FIXME: this assumes identically-located vertices
                         // will always deform in the same way.
@@ -1877,6 +2061,7 @@ void FBXExporter::WriteObjects ()
                         // identical vertex.
                         continue;
                     }
+                    setWeightedVertex.insert(vi);
                     subdef_indices.push_back(vi);
                     subdef_weights.push_back(b->mWeights[wi].mWeight);
                     last_index = vi;
@@ -2025,7 +2210,65 @@ void FBXExporter::WriteObjects ()
         bpnode.Dump(outstream, binary, indent);
     }*/
 
-    // TODO: cameras, lights
+    // lights
+    indent = 1;
+    lights_uids.clear();
+    for (size_t li = 0; li < mScene->mNumLights; ++li) {
+        aiLight* l = mScene->mLights[li];
+
+        int64_t uid = generate_uid();
+        const std::string lightNodeAttributeName = l->mName.C_Str() + FBX::SEPARATOR + "NodeAttribute";
+
+        FBX::Node lna("NodeAttribute");
+        lna.AddProperties(uid, lightNodeAttributeName, "Light");
+        FBX::Node lnap("Properties70");
+
+        // Light color.
+        lnap.AddP70colorA("Color", l->mColorDiffuse.r, l->mColorDiffuse.g, l->mColorDiffuse.b);
+
+        // TODO Assimp light description is quite concise and do not handle light intensity.
+        // Default value to 1000W.
+        lnap.AddP70numberA("Intensity", 1000);
+
+        // FBXLight::EType conversion
+        switch (l->mType) {
+        case aiLightSource_POINT:
+            lnap.AddP70enum("LightType", 0);
+            break;
+        case aiLightSource_DIRECTIONAL:
+            lnap.AddP70enum("LightType", 1);
+            break;
+        case aiLightSource_SPOT:
+            lnap.AddP70enum("LightType", 2);
+            lnap.AddP70numberA("InnerAngle", AI_RAD_TO_DEG(l->mAngleInnerCone));
+            lnap.AddP70numberA("OuterAngle", AI_RAD_TO_DEG(l->mAngleOuterCone));
+            break;
+        // TODO Assimp do not handle 'area' nor 'volume' lights, but FBX does.
+        /*case aiLightSource_AREA:
+            lnap.AddP70enum("LightType", 3);
+            lnap.AddP70enum("AreaLightShape", 0); // 0=Rectangle, 1=Sphere
+            break;
+        case aiLightSource_VOLUME:
+            lnap.AddP70enum("LightType", 4);
+            break;*/
+        default:
+            break;
+        }
+
+        // Did not understood how to configure the decay so disabling attenuation.
+        lnap.AddP70enum("DecayType", 0);
+
+        // Dump to FBX stream
+        lna.AddChild(lnap);
+        lna.AddChild("TypeFlags", FBX::FBXExportProperty("Light"));
+        lna.AddChild("GeometryVersion", FBX::FBXExportProperty(int32_t(124)));
+        lna.Dump(outstream, binary, indent);
+
+        // Store name and uid (will be used later when parsing scene nodes)
+        lights_uids[l->mName.C_Str()] = uid;
+    }
+
+    // TODO: cameras
 
     // write nodes (i.e. model hierarchy)
     // start at root node
@@ -2243,7 +2486,7 @@ const std::map<std::string,std::pair<std::string,char>> transform_types = {
 // write a single model node to the stream
 void FBXExporter::WriteModelNode(
     StreamWriterLE& outstream,
-    bool binary,
+    bool,
     const aiNode* node,
     int64_t node_uid,
     const std::string& type,
@@ -2296,16 +2539,13 @@ void FBXExporter::WriteModelNode(
                 err << item.first;
                 throw DeadlyExportError(err.str());
             }
-            const std::string &name = elem->second.first;
+            const std::string &cur_name = elem->second.first;
             const aiVector3D &v = item.second;
-            if (name.compare(0, 4, "Lcl ") == 0) {
+            if (cur_name.compare(0, 4, "Lcl ") == 0) {
                 // special handling for animatable properties
-                p.AddP70(
-                    name, name, "", "A",
-                    double(v.x), double(v.y), double(v.z)
-                );
+                p.AddP70( cur_name, cur_name, "", "A", double(v.x), double(v.y), double(v.z) );
             } else {
-                p.AddP70vector(name, v.x, v.y, v.z);
+                p.AddP70vector(cur_name, v.x, v.y, v.z);
             }
         }
     }
@@ -2432,10 +2672,19 @@ void FBXExporter::WriteModelNodes(
         // and connect them
         connections.emplace_back("C", "OO", node_attribute_uid, node_uid);
     } else {
-        // generate a null node so we can add children to it
-        WriteModelNode(
-            outstream, binary, node, node_uid, "Null", transform_chain
-        );
+        const auto& lightIt = lights_uids.find(node->mName.C_Str());
+        if(lightIt != lights_uids.end()) {
+            // Node has a light connected to it.
+            WriteModelNode(
+                outstream, binary, node, node_uid, "Light", transform_chain
+            );
+            connections.emplace_back("C", "OO", lightIt->second, node_uid);
+        } else {
+            // generate a null node so we can add children to it
+            WriteModelNode(
+                outstream, binary, node, node_uid, "Null", transform_chain
+            );
+        }
     }
 
     // if more than one child mesh, make nodes for each mesh
@@ -2457,17 +2706,14 @@ void FBXExporter::WriteModelNodes(
                 ],
                 new_node_uid
             );
-            // write model node
-            FBX::Node m("Model");
+
+            aiNode new_node;
             // take name from mesh name, if it exists
-            std::string name = mScene->mMeshes[node->mMeshes[i]]->mName.C_Str();
-            name += FBX::SEPARATOR + "Model";
-            m.AddProperties(new_node_uid, name, "Mesh");
-            m.AddChild("Version", int32_t(232));
-            FBX::Node p("Properties70");
-            p.AddP70enum("InheritType", 1);
-            m.AddChild(p);
-            m.Dump(outstream, binary, 1);
+            new_node.mName = mScene->mMeshes[node->mMeshes[i]]->mName;
+            // write model node
+            WriteModelNode(
+                outstream, binary, &new_node, new_node_uid, "Mesh", std::vector<std::pair<std::string,aiVector3D>>()
+            );
         }
     }
 
@@ -2479,16 +2725,14 @@ void FBXExporter::WriteModelNodes(
     }
 }
 
-
 void FBXExporter::WriteAnimationCurveNode(
-    StreamWriterLE& outstream,
-    int64_t uid,
-    const std::string& name, // "T", "R", or "S"
-    aiVector3D default_value,
-    std::string property_name, // "Lcl Translation" etc
-    int64_t layer_uid,
-    int64_t node_uid
-) {
+        StreamWriterLE &outstream,
+        int64_t uid,
+        const std::string &name, // "T", "R", or "S"
+        aiVector3D default_value,
+        const std::string &property_name, // "Lcl Translation" etc
+        int64_t layer_uid,
+        int64_t node_uid) {
     FBX::Node n("AnimationCurveNode");
     n.AddProperties(uid, name + FBX::SEPARATOR + "AnimCurveNode", "");
     FBX::Node p("Properties70");
@@ -2503,7 +2747,6 @@ void FBXExporter::WriteAnimationCurveNode(
     this->connections.emplace_back("C", "OP", uid, node_uid, property_name);
 }
 
-
 void FBXExporter::WriteAnimationCurve(
     StreamWriterLE& outstream,
     double default_value,
diff --git a/Engine/lib/assimp/code/FBX/FBXExporter.h b/Engine/lib/assimp/code/AssetLib/FBX/FBXExporter.h
similarity index 93%
rename from Engine/lib/assimp/code/FBX/FBXExporter.h
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXExporter.h
index 1ae727eda..659f9368a 100644
--- a/Engine/lib/assimp/code/FBX/FBXExporter.h
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXExporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -63,10 +63,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 struct aiScene;
 struct aiNode;
-//struct aiMaterial;
+struct aiLight;
 
-namespace Assimp
-{
+namespace Assimp {
     class IOSystem;
     class IOStream;
     class ExportProperties;
@@ -95,6 +94,7 @@ namespace Assimp
         std::vector<int64_t> mesh_uids;
         std::vector<int64_t> material_uids;
         std::map<const aiNode*,int64_t> node_uids;
+        std::map<std::string,int64_t> lights_uids;
 
         // this crude unique-ID system is actually fine
         int64_t last_uid = 999999;
@@ -154,14 +154,13 @@ namespace Assimp
             FBX::TransformInheritance ti_type=FBX::TransformInheritance_RSrs
         );
         void WriteAnimationCurveNode(
-            StreamWriterLE& outstream,
-            int64_t uid,
-            const std::string& name, // "T", "R", or "S"
-            aiVector3D default_value,
-            std::string property_name, // "Lcl Translation" etc
-            int64_t animation_layer_uid,
-            int64_t node_uid
-        );
+                StreamWriterLE &outstream,
+                int64_t uid,
+                const std::string &name, // "T", "R", or "S"
+                aiVector3D default_value,
+                const std::string &property_name, // "Lcl Translation" etc
+                int64_t animation_layer_uid,
+                int64_t node_uid);
         void WriteAnimationCurve(
             StreamWriterLE& outstream,
             double default_value,
diff --git a/Engine/lib/assimp/code/FBX/FBXImportSettings.h b/Engine/lib/assimp/code/AssetLib/FBX/FBXImportSettings.h
similarity index 88%
rename from Engine/lib/assimp/code/FBX/FBXImportSettings.h
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXImportSettings.h
index 1a4c80f8b..90e64bf04 100644
--- a/Engine/lib/assimp/code/FBX/FBXImportSettings.h
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXImportSettings.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -50,27 +49,25 @@ namespace Assimp {
 namespace FBX {
 
 /** FBX import settings, parts of which are publicly accessible via their corresponding AI_CONFIG constants */
-struct ImportSettings
-{
-    ImportSettings()
-    : strictMode(true)
-    , readAllLayers(true)
-    , readAllMaterials(false)
-    , readMaterials(true)
-    , readTextures(true)
-    , readCameras(true)
-    , readLights(true)
-    , readAnimations(true)
-    , readWeights(true)
-    , preservePivots(true)
-    , optimizeEmptyAnimationCurves(true)
-    , useLegacyEmbeddedTextureNaming(false)
-    , removeEmptyBones( true )
-    , convertToMeters( false ) {
+struct ImportSettings {
+    ImportSettings() :
+            strictMode(true),
+            readAllLayers(true),
+            readAllMaterials(false),
+            readMaterials(true),
+            readTextures(true),
+            readCameras(true),
+            readLights(true),
+            readAnimations(true),
+            readWeights(true),
+            preservePivots(true),
+            optimizeEmptyAnimationCurves(true),
+            useLegacyEmbeddedTextureNaming(false),
+            removeEmptyBones(true),
+            convertToMeters(false) {
         // empty
     }
 
-
     /** enable strict mode:
      *   - only accept fbx 2012, 2013 files
      *   - on the slightest error, give up.
@@ -94,7 +91,6 @@ struct ImportSettings
      *  This bit is ignored unless readMaterials=true*/
     bool readAllMaterials;
 
-
     /** import materials (true) or skip them and assign a default
      *  material. The default value is true.*/
     bool readMaterials;
@@ -156,9 +152,7 @@ struct ImportSettings
     bool convertToMeters;
 };
 
-
-} // !FBX
-} // !Assimp
+} // namespace FBX
+} // namespace Assimp
 
 #endif
-
diff --git a/Engine/lib/assimp/code/AssetLib/FBX/FBXImporter.cpp b/Engine/lib/assimp/code/AssetLib/FBX/FBXImporter.cpp
new file mode 100644
index 000000000..0f63acc8f
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXImporter.cpp
@@ -0,0 +1,200 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+r
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file  FBXImporter.cpp
+ *  @brief Implementation of the FBX importer.
+ */
+
+#ifndef ASSIMP_BUILD_NO_FBX_IMPORTER
+
+#include "FBXImporter.h"
+
+#include "FBXConverter.h"
+#include "FBXDocument.h"
+#include "FBXParser.h"
+#include "FBXTokenizer.h"
+#include "FBXUtil.h"
+
+#include <assimp/MemoryIOWrapper.h>
+#include <assimp/StreamReader.h>
+#include <assimp/importerdesc.h>
+#include <assimp/Importer.hpp>
+
+namespace Assimp {
+
+template <>
+const char *LogFunctions<FBXImporter>::Prefix() {
+	static auto prefix = "FBX: ";
+	return prefix;
+}
+
+} // namespace Assimp
+
+using namespace Assimp;
+using namespace Assimp::Formatter;
+using namespace Assimp::FBX;
+
+namespace {
+
+static const aiImporterDesc desc = {
+	"Autodesk FBX Importer",
+	"",
+	"",
+	"",
+	aiImporterFlags_SupportTextFlavour,
+	0,
+	0,
+	0,
+	0,
+	"fbx"
+};
+}
+
+// ------------------------------------------------------------------------------------------------
+// Constructor to be privately used by #Importer
+FBXImporter::FBXImporter() {
+}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor, private as well
+FBXImporter::~FBXImporter() {
+}
+
+// ------------------------------------------------------------------------------------------------
+// Returns whether the class can handle the format of the given file.
+bool FBXImporter::CanRead(const std::string & pFile, IOSystem * pIOHandler, bool /*checkSig*/) const {
+	// at least ASCII-FBX files usually have a 'FBX' somewhere in their head
+	static const char *tokens[] = { "fbx" };
+	return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
+}
+
+// ------------------------------------------------------------------------------------------------
+// List all extensions handled by this loader
+const aiImporterDesc *FBXImporter::GetInfo() const {
+	return &desc;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Setup configuration properties for the loader
+void FBXImporter::SetupProperties(const Importer *pImp) {
+	settings.readAllLayers = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_ALL_GEOMETRY_LAYERS, true);
+	settings.readAllMaterials = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_ALL_MATERIALS, false);
+	settings.readMaterials = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_MATERIALS, true);
+	settings.readTextures = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_TEXTURES, true);
+	settings.readCameras = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_CAMERAS, true);
+	settings.readLights = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_LIGHTS, true);
+	settings.readAnimations = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_ANIMATIONS, true);
+	settings.readWeights = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_WEIGHTS, true);
+	settings.strictMode = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_STRICT_MODE, false);
+	settings.preservePivots = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_PRESERVE_PIVOTS, true);
+	settings.optimizeEmptyAnimationCurves = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_OPTIMIZE_EMPTY_ANIMATION_CURVES, true);
+	settings.useLegacyEmbeddedTextureNaming = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_EMBEDDED_TEXTURES_LEGACY_NAMING, false);
+	settings.removeEmptyBones = pImp->GetPropertyBool(AI_CONFIG_IMPORT_REMOVE_EMPTY_BONES, true);
+	settings.convertToMeters = pImp->GetPropertyBool(AI_CONFIG_FBX_CONVERT_TO_M, false);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Imports the given file into the given scene structure.
+void FBXImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
+	auto streamCloser = [&](IOStream *pStream) {
+		pIOHandler->Close(pStream);
+	};
+	std::unique_ptr<IOStream, decltype(streamCloser)> stream(pIOHandler->Open(pFile, "rb"), streamCloser);
+	if (!stream) {
+		ThrowException("Could not open file for reading");
+	}
+
+    ASSIMP_LOG_DEBUG("Reading FBX file");
+
+	// read entire file into memory - no streaming for this, fbx
+	// files can grow large, but the assimp output data structure
+	// then becomes very large, too. Assimp doesn't support
+	// streaming for its output data structures so the net win with
+	// streaming input data would be very low.
+	std::vector<char> contents;
+	contents.resize(stream->FileSize() + 1);
+	stream->Read(&*contents.begin(), 1, contents.size() - 1);
+	contents[contents.size() - 1] = 0;
+	const char *const begin = &*contents.begin();
+
+	// broadphase tokenizing pass in which we identify the core
+	// syntax elements of FBX (brackets, commas, key:value mappings)
+	TokenList tokens;
+	try {
+
+		bool is_binary = false;
+		if (!strncmp(begin, "Kaydara FBX Binary", 18)) {
+			is_binary = true;
+			TokenizeBinary(tokens, begin, contents.size());
+		} else {
+			Tokenize(tokens, begin);
+		}
+
+		// use this information to construct a very rudimentary
+		// parse-tree representing the FBX scope structure
+		Parser parser(tokens, is_binary);
+
+		// take the raw parse-tree and convert it to a FBX DOM
+		Document doc(parser, settings);
+
+		// convert the FBX DOM to aiScene
+		ConvertToAssimpScene(pScene, doc, settings.removeEmptyBones);
+
+		// size relative to cm
+		float size_relative_to_cm = doc.GlobalSettings().UnitScaleFactor();
+        if (size_relative_to_cm == 0.0)
+        {
+			// BaseImporter later asserts that fileScale is non-zero.
+			ThrowException("The UnitScaleFactor must be non-zero");
+        }
+
+		// Set FBX file scale is relative to CM must be converted to M for
+		// assimp universal format (M)
+		SetFileScale(size_relative_to_cm * 0.01f);
+
+		std::for_each(tokens.begin(), tokens.end(), Util::delete_fun<Token>());
+	} catch (std::exception &) {
+		std::for_each(tokens.begin(), tokens.end(), Util::delete_fun<Token>());
+		throw;
+	}
+}
+
+#endif // !ASSIMP_BUILD_NO_FBX_IMPORTER
diff --git a/Engine/lib/assimp/code/FBX/FBXImporter.h b/Engine/lib/assimp/code/AssetLib/FBX/FBXImporter.h
similarity index 77%
rename from Engine/lib/assimp/code/FBX/FBXImporter.h
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXImporter.h
index c365b2cdd..a212efe11 100644
--- a/Engine/lib/assimp/code/FBX/FBXImporter.h
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXImporter.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -51,50 +50,49 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "FBXImportSettings.h"
 
-namespace Assimp    {
+namespace Assimp {
 
 // TinyFormatter.h
 namespace Formatter {
-    template <typename T,typename TR, typename A> class basic_formatter;
-    typedef class basic_formatter< char, std::char_traits<char>, std::allocator<char> > format;
-}
+
+template <typename T, typename TR, typename A>
+class basic_formatter;
+
+typedef class basic_formatter<char, std::char_traits<char>, std::allocator<char>> format;
+
+} // namespace Formatter
 
 // -------------------------------------------------------------------------------------------
-/** Load the Autodesk FBX file format.
-
- See http://en.wikipedia.org/wiki/FBX
-*/
+/// Loads the Autodesk FBX file format.
+///
+/// See http://en.wikipedia.org/wiki/FBX
 // -------------------------------------------------------------------------------------------
-class FBXImporter : public BaseImporter, public LogFunctions<FBXImporter>
-{
+class FBXImporter : public BaseImporter, public LogFunctions<FBXImporter> {
 public:
     FBXImporter();
-    virtual ~FBXImporter();
+    ~FBXImporter() override;
 
     // --------------------
-    bool CanRead( const std::string& pFile,
-        IOSystem* pIOHandler,
-        bool checkSig
-    ) const;
+    bool CanRead(const std::string &pFile,
+            IOSystem *pIOHandler,
+            bool checkSig) const override;
 
 protected:
+    // --------------------
+    const aiImporterDesc *GetInfo() const override;
 
     // --------------------
-    const aiImporterDesc* GetInfo () const;
+    void SetupProperties(const Importer *pImp) override;
 
     // --------------------
-    void SetupProperties(const Importer* pImp);
-
-    // --------------------
-    void InternReadFile( const std::string& pFile,
-        aiScene* pScene,
-        IOSystem* pIOHandler
-    );
+    void InternReadFile(const std::string &pFile,
+            aiScene *pScene,
+            IOSystem *pIOHandler) override;
 
 private:
     FBX::ImportSettings settings;
 }; // !class FBXImporter
 
 } // end of namespace Assimp
-#endif // !INCLUDED_AI_FBX_IMPORTER_H
 
+#endif // !INCLUDED_AI_FBX_IMPORTER_H
diff --git a/Engine/lib/assimp/code/FBX/FBXMaterial.cpp b/Engine/lib/assimp/code/AssetLib/FBX/FBXMaterial.cpp
similarity index 83%
rename from Engine/lib/assimp/code/FBX/FBXMaterial.cpp
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXMaterial.cpp
index f43a8b84b..2162670f8 100644
--- a/Engine/lib/assimp/code/FBX/FBXMaterial.cpp
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXMaterial.cpp
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -53,19 +52,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "FBXDocumentUtil.h"
 #include "FBXProperties.h"
 #include <assimp/ByteSwapper.h>
+#include <assimp/ParsingUtils.h>
 
-#include <algorithm> // std::transform
 #include "FBXUtil.h"
 
 namespace Assimp {
 namespace FBX {
 
-    using namespace Util;
+using namespace Util;
 
 // ------------------------------------------------------------------------------------------------
-Material::Material(uint64_t id, const Element& element, const Document& doc, const std::string& name)
-: Object(id,element,name)
-{
+Material::Material(uint64_t id, const Element& element, const Document& doc, const std::string& name) :
+        Object(id,element,name) {
     const Scope& sc = GetRequiredScope(element);
 
     const Element* const ShadingModel = sc["ShadingModel"];
@@ -77,23 +75,21 @@ Material::Material(uint64_t id, const Element& element, const Document& doc, con
 
     if(ShadingModel) {
         shading = ParseTokenAsString(GetRequiredToken(*ShadingModel,0));
-    }
-    else {
+    } else {
         DOMWarning("shading mode not specified, assuming phong",&element);
         shading = "phong";
     }
 
-    std::string templateName;
-
     // lower-case shading because Blender (for example) writes "Phong"
-    std::transform(shading.begin(), shading.end(), shading.begin(), ::tolower);
+    for (size_t i = 0; i < shading.length(); ++i) {
+        shading[i] = static_cast<char>(tolower(static_cast<unsigned char>(shading[i])));
+    }
+    std::string templateName;
     if(shading == "phong") {
         templateName = "Material.FbxSurfacePhong";
-    }
-    else if(shading == "lambert") {
+    } else if(shading == "lambert") {
         templateName = "Material.FbxSurfaceLambert";
-    }
-    else {
+    } else {
         DOMWarning("shading mode not recognized: " + shading,&element);
     }
 
@@ -102,20 +98,19 @@ Material::Material(uint64_t id, const Element& element, const Document& doc, con
     // resolve texture links
     const std::vector<const Connection*>& conns = doc.GetConnectionsByDestinationSequenced(ID());
     for(const Connection* con : conns) {
-
         // texture link to properties, not objects
-        if (!con->PropertyName().length()) {
+        if ( 0 == con->PropertyName().length()) {
             continue;
         }
 
         const Object* const ob = con->SourceObject();
-        if(!ob) {
+        if(nullptr == ob) {
             DOMWarning("failed to read source object for texture link, ignoring",&element);
             continue;
         }
 
         const Texture* const tex = dynamic_cast<const Texture*>(ob);
-        if(!tex) {
+        if(nullptr == tex) {
             const LayeredTexture* const layeredTexture = dynamic_cast<const LayeredTexture*>(ob);
             if(!layeredTexture) {
                 DOMWarning("source object for texture link is not a texture or layered texture, ignoring",&element);
@@ -128,9 +123,7 @@ Material::Material(uint64_t id, const Element& element, const Document& doc, con
 
             layeredTextures[prop] = layeredTexture;
             ((LayeredTexture*)layeredTexture)->fillTexture(doc);
-        }
-        else
-        {
+        } else {
             const std::string& prop = con->PropertyName();
             if (textures.find(prop) != textures.end()) {
                 DOMWarning("duplicate texture link: " + prop,&element);
@@ -138,23 +131,41 @@ Material::Material(uint64_t id, const Element& element, const Document& doc, con
 
             textures[prop] = tex;
         }
-
     }
 }
 
 
 // ------------------------------------------------------------------------------------------------
-Material::~Material()
-{
+Material::~Material() {
+    // empty
 }
 
+    aiVector2D uvTrans;
+    aiVector2D uvScaling;
+    ai_real    uvRotation;
+
+    std::string type;
+    std::string relativeFileName;
+    std::string fileName;
+    std::string alphaSource;
+    std::shared_ptr<const PropertyTable> props;
+
+    unsigned int crop[4]{};
+
+    const Video* media;
 
 // ------------------------------------------------------------------------------------------------
-Texture::Texture(uint64_t id, const Element& element, const Document& doc, const std::string& name)
-: Object(id,element,name)
-, uvScaling(1.0f,1.0f)
-, media(0)
-{
+Texture::Texture(uint64_t id, const Element& element, const Document& doc, const std::string& name) :
+        Object(id,element,name),
+        uvTrans(0.0f, 0.0f),
+        uvScaling(1.0f,1.0f),
+        uvRotation(0.0f),
+        type(),
+        relativeFileName(),
+        fileName(),
+        alphaSource(),
+        props(),
+        media(nullptr) {
     const Scope& sc = GetRequiredScope(element);
 
     const Element* const Type = sc["Type"];
@@ -194,8 +205,7 @@ Texture::Texture(uint64_t id, const Element& element, const Document& doc, const
         crop[1] = ParseTokenAsInt(GetRequiredToken(*Cropping,1));
         crop[2] = ParseTokenAsInt(GetRequiredToken(*Cropping,2));
         crop[3] = ParseTokenAsInt(GetRequiredToken(*Cropping,3));
-    }
-    else {
+    } else {
         // vc8 doesn't support the crop() syntax in initialization lists
         // (and vc9 WARNS about the new (i.e. compliant) behaviour).
         crop[0] = crop[1] = crop[2] = crop[3] = 0;
@@ -221,12 +231,17 @@ Texture::Texture(uint64_t id, const Element& element, const Document& doc, const
         uvTrans.y = trans.y;
     }
 
+    const aiVector3D &rotation = PropertyGet<aiVector3D>(*props, "Rotation", ok);
+    if (ok) {
+        uvRotation = rotation.z;
+    }
+
     // resolve video links
     if(doc.Settings().readTextures) {
         const std::vector<const Connection*>& conns = doc.GetConnectionsByDestinationSequenced(ID());
         for(const Connection* con : conns) {
             const Object* const ob = con->SourceObject();
-            if(!ob) {
+            if (nullptr == ob) {
                 DOMWarning("failed to read source object for texture link, ignoring",&element);
                 continue;
             }
@@ -240,46 +255,38 @@ Texture::Texture(uint64_t id, const Element& element, const Document& doc, const
 }
 
 
-Texture::~Texture()
-{
-
+Texture::~Texture() {
+    // empty
 }
 
-LayeredTexture::LayeredTexture(uint64_t id, const Element& element, const Document& /*doc*/, const std::string& name)
-: Object(id,element,name)
-,blendMode(BlendMode_Modulate)
-,alpha(1)
-{
+LayeredTexture::LayeredTexture(uint64_t id, const Element& element, const Document& /*doc*/, const std::string& name) :
+        Object(id,element,name),
+        blendMode(BlendMode_Modulate),
+        alpha(1) {
     const Scope& sc = GetRequiredScope(element);
 
     const Element* const BlendModes = sc["BlendModes"];
     const Element* const Alphas = sc["Alphas"];
 
-
-    if(BlendModes!=0)
-    {
+    if (nullptr != BlendModes) {
         blendMode = (BlendMode)ParseTokenAsInt(GetRequiredToken(*BlendModes,0));
     }
-    if(Alphas!=0)
-    {
+    if (nullptr != Alphas) {
         alpha = ParseTokenAsFloat(GetRequiredToken(*Alphas,0));
     }
 }
 
-LayeredTexture::~LayeredTexture()
-{
-    
+LayeredTexture::~LayeredTexture() {
+    // empty
 }
 
-void LayeredTexture::fillTexture(const Document& doc)
-{
+void LayeredTexture::fillTexture(const Document& doc) {
     const std::vector<const Connection*>& conns = doc.GetConnectionsByDestinationSequenced(ID());
-    for(size_t i = 0; i < conns.size();++i)
-    {
+    for(size_t i = 0; i < conns.size();++i) {
         const Connection* con = conns.at(i);
 
         const Object* const ob = con->SourceObject();
-        if(!ob) {
+        if (nullptr == ob) {
             DOMWarning("failed to read source object for texture link, ignoring",&element);
             continue;
         }
@@ -290,13 +297,11 @@ void LayeredTexture::fillTexture(const Document& doc)
     }
 }
 
-
 // ------------------------------------------------------------------------------------------------
-Video::Video(uint64_t id, const Element& element, const Document& doc, const std::string& name)
-: Object(id,element,name)
-, contentLength(0)
-, content(0)
-{
+Video::Video(uint64_t id, const Element& element, const Document& doc, const std::string& name) :
+        Object(id,element,name),
+        contentLength(0),
+        content(0) {
     const Scope& sc = GetRequiredScope(element);
 
     const Element* const Type = sc["Type"];
@@ -324,52 +329,43 @@ Video::Video(uint64_t id, const Element& element, const Document& doc, const std
             if (!token.IsBinary()) {
                 if (*data != '"') {
                     DOMError("embedded content is not surrounded by quotation marks", &element);
-                }
-                else {
+                } else {
                     size_t targetLength = 0;
                     auto numTokens = Content->Tokens().size();
                     // First time compute size (it could be large like 64Gb and it is good to allocate it once)
-                    for (uint32_t tokenIdx = 0; tokenIdx < numTokens; ++tokenIdx)
-                    {
+                    for (uint32_t tokenIdx = 0; tokenIdx < numTokens; ++tokenIdx) {
                         const Token& dataToken = GetRequiredToken(*Content, tokenIdx);
                         size_t tokenLength = dataToken.end() - dataToken.begin() - 2; // ignore double quotes
                         const char* base64data = dataToken.begin() + 1;
                         const size_t outLength = Util::ComputeDecodedSizeBase64(base64data, tokenLength);
-                        if (outLength == 0)
-                        {
+                        if (outLength == 0) {
                             DOMError("Corrupted embedded content found", &element);
                         }
                         targetLength += outLength;
                     }
-                    if (targetLength == 0)
-                    {
+                    if (targetLength == 0) {
                         DOMError("Corrupted embedded content found", &element);
                     }
                     content = new uint8_t[targetLength];
                     contentLength = static_cast<uint64_t>(targetLength);
                     size_t dst_offset = 0;
-                    for (uint32_t tokenIdx = 0; tokenIdx < numTokens; ++tokenIdx)
-                    {
+                    for (uint32_t tokenIdx = 0; tokenIdx < numTokens; ++tokenIdx) {
                         const Token& dataToken = GetRequiredToken(*Content, tokenIdx);
                         size_t tokenLength = dataToken.end() - dataToken.begin() - 2; // ignore double quotes
                         const char* base64data = dataToken.begin() + 1;
                         dst_offset += Util::DecodeBase64(base64data, tokenLength, content + dst_offset, targetLength - dst_offset);
                     }
-                    if (targetLength != dst_offset)
-                    {
+                    if (targetLength != dst_offset) {
                         delete[] content;
                         contentLength = 0;
                         DOMError("Corrupted embedded content found", &element);
                     }
                 }
-            }
-            else if (static_cast<size_t>(token.end() - data) < 5) {
+            } else if (static_cast<size_t>(token.end() - data) < 5) {
                 DOMError("binary data array is too short, need five (5) bytes for type signature and element count", &element);
-            }
-            else if (*data != 'R') {
+            } else if (*data != 'R') {
                 DOMWarning("video content is not raw binary data, ignoring", &element);
-            }
-            else {
+            } else {
                 // read number of elements
                 uint32_t len = 0;
                 ::memcpy(&len, data + 1, sizeof(len));
@@ -380,10 +376,9 @@ Video::Video(uint64_t id, const Element& element, const Document& doc, const std
                 content = new uint8_t[len];
                 ::memcpy(content, data + 5, len);
             }
-        } catch (const runtime_error& runtimeError)
-        {
+        } catch (const runtime_error& runtimeError) {
             //we don't need the content data for contents that has already been loaded
-            ASSIMP_LOG_DEBUG_F("Caught exception in FBXMaterial (likely because content was already loaded): ",
+            ASSIMP_LOG_VERBOSE_DEBUG("Caught exception in FBXMaterial (likely because content was already loaded): ",
                     runtimeError.what());
         }
     }
@@ -392,14 +387,11 @@ Video::Video(uint64_t id, const Element& element, const Document& doc, const std
 }
 
 
-Video::~Video()
-{
-    if(content) {
-        delete[] content;
-    }
+Video::~Video() {
+    delete[] content;
 }
 
 } //!FBX
 } //!Assimp
 
-#endif
+#endif // ASSIMP_BUILD_NO_FBX_IMPORTER
diff --git a/Engine/lib/assimp/code/FBX/FBXMeshGeometry.cpp b/Engine/lib/assimp/code/AssetLib/FBX/FBXMeshGeometry.cpp
similarity index 90%
rename from Engine/lib/assimp/code/FBX/FBXMeshGeometry.cpp
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXMeshGeometry.cpp
index 1386e2383..1f92fa1a7 100644
--- a/Engine/lib/assimp/code/FBX/FBXMeshGeometry.cpp
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXMeshGeometry.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -241,7 +241,7 @@ const MatIndexArray& MeshGeometry::GetMaterialIndices() const {
 // ------------------------------------------------------------------------------------------------
 const unsigned int* MeshGeometry::ToOutputVertexIndex( unsigned int in_index, unsigned int& count ) const {
     if ( in_index >= m_mapping_counts.size() ) {
-        return NULL;
+        return nullptr;
     }
 
     ai_assert( m_mapping_counts.size() == m_mapping_offsets.size() );
@@ -307,8 +307,8 @@ void MeshGeometry::ReadLayerElement(const Scope& layerElement)
         }
     }
 
-    FBXImporter::LogError(Formatter::format("failed to resolve vertex layer element: ")
-        << type << ", index: " << typedIndex);
+    FBXImporter::LogError("failed to resolve vertex layer element: ",
+        type, ", index: ", typedIndex);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -324,13 +324,13 @@ void MeshGeometry::ReadVertexData(const std::string& type, int index, const Scop
 
     if (type == "LayerElementUV") {
         if(index >= AI_MAX_NUMBER_OF_TEXTURECOORDS) {
-            FBXImporter::LogError(Formatter::format("ignoring UV layer, maximum number of UV channels exceeded: ")
-                << index << " (limit is " << AI_MAX_NUMBER_OF_TEXTURECOORDS << ")" );
+            FBXImporter::LogError("ignoring UV layer, maximum number of UV channels exceeded: ",
+                index, " (limit is ", AI_MAX_NUMBER_OF_TEXTURECOORDS, ")" );
             return;
         }
 
         const Element* Name = source["Name"];
-        m_uvNames[index] = "";
+        m_uvNames[index] = std::string();
         if(Name) {
             m_uvNames[index] = ParseTokenAsString(GetRequiredToken(*Name,0));
         }
@@ -402,8 +402,8 @@ void MeshGeometry::ReadVertexData(const std::string& type, int index, const Scop
     }
     else if (type == "LayerElementColor") {
         if(index >= AI_MAX_NUMBER_OF_COLOR_SETS) {
-            FBXImporter::LogError(Formatter::format("ignoring vertex color layer, maximum number of color sets exceeded: ")
-                << index << " (limit is " << AI_MAX_NUMBER_OF_COLOR_SETS << ")" );
+            FBXImporter::LogError("ignoring vertex color layer, maximum number of color sets exceeded: ",
+                index, " (limit is ", AI_MAX_NUMBER_OF_COLOR_SETS, ")" );
             return;
         }
 
@@ -446,14 +446,19 @@ void ResolveVertexDataArray(std::vector<T>& data_out, const Scope& source,
             return;
         }
         std::vector<T> tempData;
-		ParseVectorDataArray(tempData, GetRequiredElement(source, dataElementName));
+        ParseVectorDataArray(tempData, GetRequiredElement(source, dataElementName));
+
+        if (tempData.size() != mapping_offsets.size()) {
+            FBXImporter::LogError("length of input data unexpected for ByVertice mapping: ",
+                                  tempData.size(), ", expected ", mapping_offsets.size());
+            return;
+        }
 
         data_out.resize(vertex_count);
-		for (size_t i = 0, e = tempData.size(); i < e; ++i) {
-
+        for (size_t i = 0, e = tempData.size(); i < e; ++i) {
             const unsigned int istart = mapping_offsets[i], iend = istart + mapping_counts[i];
             for (unsigned int j = istart; j < iend; ++j) {
-				data_out[mappings[j]] = tempData[i];
+                data_out[mappings[j]] = tempData[i];
             }
         }
     }
@@ -461,10 +466,17 @@ void ResolveVertexDataArray(std::vector<T>& data_out, const Scope& source,
 		std::vector<T> tempData;
 		ParseVectorDataArray(tempData, GetRequiredElement(source, dataElementName));
 
-        data_out.resize(vertex_count);
-
         std::vector<int> uvIndices;
         ParseVectorDataArray(uvIndices,GetRequiredElement(source,indexDataElementName));
+
+        if (uvIndices.size() != vertex_count) {
+            FBXImporter::LogError("length of input data unexpected for ByVertice mapping: ",
+                                  uvIndices.size(), ", expected ", vertex_count);
+            return;
+        }
+
+        data_out.resize(vertex_count);
+
         for (size_t i = 0, e = uvIndices.size(); i < e; ++i) {
 
             const unsigned int istart = mapping_offsets[i], iend = istart + mapping_counts[i];
@@ -481,8 +493,8 @@ void ResolveVertexDataArray(std::vector<T>& data_out, const Scope& source,
 		ParseVectorDataArray(tempData, GetRequiredElement(source, dataElementName));
 
 		if (tempData.size() != vertex_count) {
-            FBXImporter::LogError(Formatter::format("length of input data unexpected for ByPolygon mapping: ")
-				<< tempData.size() << ", expected " << vertex_count
+            FBXImporter::LogError("length of input data unexpected for ByPolygon mapping: ",
+				tempData.size(), ", expected ", vertex_count
             );
             return;
         }
@@ -493,16 +505,23 @@ void ResolveVertexDataArray(std::vector<T>& data_out, const Scope& source,
 		std::vector<T> tempData;
 		ParseVectorDataArray(tempData, GetRequiredElement(source, dataElementName));
 
-        data_out.resize(vertex_count);
-
         std::vector<int> uvIndices;
         ParseVectorDataArray(uvIndices,GetRequiredElement(source,indexDataElementName));
 
+        if (uvIndices.size() > vertex_count) {
+            FBXImporter::LogWarn("trimming length of input array for ByPolygonVertex mapping: ",
+                                          uvIndices.size(), ", expected ", vertex_count);
+            uvIndices.resize(vertex_count);
+        }
+
         if (uvIndices.size() != vertex_count) {
-            FBXImporter::LogError("length of input data unexpected for ByPolygonVertex mapping");
+            FBXImporter::LogError("length of input data unexpected for ByPolygonVertex mapping: ",
+                                  uvIndices.size(), ", expected ", vertex_count);
             return;
         }
 
+        data_out.resize(vertex_count);
+
         const T empty;
         unsigned int next = 0;
         for(int i : uvIndices) {
@@ -518,8 +537,8 @@ void ResolveVertexDataArray(std::vector<T>& data_out, const Scope& source,
         }
     }
     else {
-        FBXImporter::LogError(Formatter::format("ignoring vertex data channel, access type not implemented: ")
-            << MappingInformationType << "," << ReferenceInformationType);
+        FBXImporter::LogError("ignoring vertex data channel, access type not implemented: ",
+            MappingInformationType, ",", ReferenceInformationType);
     }
 }
 
@@ -585,15 +604,15 @@ void MeshGeometry::ReadVertexDataTangents(std::vector<aiVector3D>& tangents_out,
 }
 
 // ------------------------------------------------------------------------------------------------
-static const std::string BinormalIndexToken = "BinormalIndex";
-static const std::string BinormalsIndexToken = "BinormalsIndex";
+static const char * BinormalIndexToken = "BinormalIndex";
+static const char * BinormalsIndexToken = "BinormalsIndex";
 
 void MeshGeometry::ReadVertexDataBinormals(std::vector<aiVector3D>& binormals_out, const Scope& source,
     const std::string& MappingInformationType,
     const std::string& ReferenceInformationType)
 {
     const char * str = source.Elements().count( "Binormals" ) > 0 ? "Binormals" : "Binormal";
-    const char * strIdx = source.Elements().count( "Binormals" ) > 0 ? BinormalsIndexToken.c_str() : BinormalIndexToken.c_str();
+    const char * strIdx = source.Elements().count( "Binormals" ) > 0 ? BinormalsIndexToken : BinormalIndexToken;
     ResolveVertexDataArray(binormals_out,source,MappingInformationType,ReferenceInformationType,
         str,
         strIdx,
@@ -614,7 +633,7 @@ void MeshGeometry::ReadVertexDataMaterials(std::vector<int>& materials_out, cons
     {
         return;
     }
-    
+
     // materials are handled separately. First of all, they are assigned per-face
     // and not per polyvert. Secondly, ReferenceInformationType=IndexToDirect
     // has a slightly different meaning for materials.
@@ -623,10 +642,10 @@ void MeshGeometry::ReadVertexDataMaterials(std::vector<int>& materials_out, cons
     if (MappingInformationType == "AllSame") {
         // easy - same material for all faces
         if (materials_out.empty()) {
-            FBXImporter::LogError(Formatter::format("expected material index, ignoring"));
+            FBXImporter::LogError("expected material index, ignoring");
             return;
         } else if (materials_out.size() > 1) {
-            FBXImporter::LogWarn(Formatter::format("expected only a single material index, ignoring all except the first one"));
+            FBXImporter::LogWarn("expected only a single material index, ignoring all except the first one");
             materials_out.clear();
         }
 
@@ -636,14 +655,14 @@ void MeshGeometry::ReadVertexDataMaterials(std::vector<int>& materials_out, cons
         materials_out.resize(face_count);
 
         if(materials_out.size() != face_count) {
-            FBXImporter::LogError(Formatter::format("length of input data unexpected for ByPolygon mapping: ")
-                << materials_out.size() << ", expected " << face_count
+            FBXImporter::LogError("length of input data unexpected for ByPolygon mapping: ",
+                materials_out.size(), ", expected ", face_count
             );
             return;
         }
     } else {
-        FBXImporter::LogError(Formatter::format("ignoring material assignments, access type not implemented: ")
-            << MappingInformationType << "," << ReferenceInformationType);
+        FBXImporter::LogError("ignoring material assignments, access type not implemented: ",
+            MappingInformationType, ",", ReferenceInformationType);
     }
 }
 // ------------------------------------------------------------------------------------------------
diff --git a/Engine/lib/assimp/code/FBX/FBXMeshGeometry.h b/Engine/lib/assimp/code/AssetLib/FBX/FBXMeshGeometry.h
similarity index 96%
rename from Engine/lib/assimp/code/FBX/FBXMeshGeometry.h
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXMeshGeometry.h
index d6d451217..3cca38aa5 100644
--- a/Engine/lib/assimp/code/FBX/FBXMeshGeometry.h
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXMeshGeometry.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -52,8 +52,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 namespace Assimp {
 namespace FBX {
 
-/** 
- *  DOM base class for all kinds of FBX geometry 
+/**
+ *  DOM base class for all kinds of FBX geometry
  */
 class Geometry : public Object
 {
@@ -61,10 +61,10 @@ public:
     Geometry( uint64_t id, const Element& element, const std::string& name, const Document& doc );
     virtual ~Geometry();
 
-    /** Get the Skin attached to this geometry or NULL */
+    /** Get the Skin attached to this geometry or nullptr */
     const Skin* DeformerSkin() const;
 
-    /** Get the BlendShape attached to this geometry or NULL */
+    /** Get the BlendShape attached to this geometry or nullptr */
     const std::vector<const BlendShape*>& GetBlendShapes() const;
 
 private:
@@ -76,7 +76,7 @@ private:
 typedef std::vector<int> MatIndexArray;
 
 
-/** 
+/**
  *  DOM class for FBX geometry of type "Mesh"
  */
 class MeshGeometry : public Geometry
@@ -84,7 +84,7 @@ class MeshGeometry : public Geometry
 public:
     /** The class constructor */
     MeshGeometry( uint64_t id, const Element& element, const std::string& name, const Document& doc );
-    
+
     /** The class destructor */
     virtual ~MeshGeometry();
 
@@ -123,7 +123,7 @@ public:
     /** Get per-face-vertex material assignments */
     const MatIndexArray& GetMaterialIndices() const;
 
-    /** Convert from a fbx file vertex index (for example from a #Cluster weight) or NULL
+    /** Convert from a fbx file vertex index (for example from a #Cluster weight) or nullptr
     * if the vertex index is not valid. */
     const unsigned int* ToOutputVertexIndex( unsigned int in_index, unsigned int& count ) const;
 
diff --git a/Engine/lib/assimp/code/FBX/FBXModel.cpp b/Engine/lib/assimp/code/AssetLib/FBX/FBXModel.cpp
similarity index 64%
rename from Engine/lib/assimp/code/FBX/FBXModel.cpp
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXModel.cpp
index 589af36ac..d731d2e29 100644
--- a/Engine/lib/assimp/code/FBX/FBXModel.cpp
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXModel.cpp
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -46,11 +45,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_FBX_IMPORTER
 
-#include "FBXParser.h"
-#include "FBXMeshGeometry.h"
 #include "FBXDocument.h"
-#include "FBXImporter.h"
 #include "FBXDocumentUtil.h"
+#include "FBXImporter.h"
+#include "FBXMeshGeometry.h"
+#include "FBXParser.h"
 
 namespace Assimp {
 namespace FBX {
@@ -58,87 +57,77 @@ namespace FBX {
 using namespace Util;
 
 // ------------------------------------------------------------------------------------------------
-Model::Model(uint64_t id, const Element& element, const Document& doc, const std::string& name)
-    : Object(id,element,name)
-    , shading("Y")
-{
-    const Scope& sc = GetRequiredScope(element);
-    const Element* const Shading = sc["Shading"];
-    const Element* const Culling = sc["Culling"];
+Model::Model(uint64_t id, const Element &element, const Document &doc, const std::string &name) :
+        Object(id, element, name), shading("Y") {
+    const Scope &sc = GetRequiredScope(element);
+    const Element *const Shading = sc["Shading"];
+    const Element *const Culling = sc["Culling"];
 
-    if(Shading) {
-        shading = GetRequiredToken(*Shading,0).StringContents();
+    if (Shading) {
+        shading = GetRequiredToken(*Shading, 0).StringContents();
     }
 
     if (Culling) {
-        culling = ParseTokenAsString(GetRequiredToken(*Culling,0));
+        culling = ParseTokenAsString(GetRequiredToken(*Culling, 0));
     }
 
-    props = GetPropertyTable(doc,"Model.FbxNode",element,sc);
-    ResolveLinks(element,doc);
+    props = GetPropertyTable(doc, "Model.FbxNode", element, sc);
+    ResolveLinks(element, doc);
 }
 
 // ------------------------------------------------------------------------------------------------
-Model::~Model()
-{
-
-}
-
-// ------------------------------------------------------------------------------------------------
-void Model::ResolveLinks(const Element& element, const Document& doc)
-{
-    const char* const arr[] = {"Geometry","Material","NodeAttribute"};
+void Model::ResolveLinks(const Element&, const Document &doc) {
+    const char *const arr[] = { "Geometry", "Material", "NodeAttribute" };
 
     // resolve material
-    const std::vector<const Connection*>& conns = doc.GetConnectionsByDestinationSequenced(ID(),arr, 3);
+    const std::vector<const Connection *> &conns = doc.GetConnectionsByDestinationSequenced(ID(), arr, 3);
 
     materials.reserve(conns.size());
     geometry.reserve(conns.size());
     attributes.reserve(conns.size());
-    for(const Connection* con : conns) {
+    for (const Connection *con : conns) {
 
         // material and geometry links should be Object-Object connections
         if (con->PropertyName().length()) {
             continue;
         }
 
-        const Object* const ob = con->SourceObject();
-        if(!ob) {
-            DOMWarning("failed to read source object for incoming Model link, ignoring",&element);
+        const Object *const ob = con->SourceObject();
+        if (!ob) {
+            DOMWarning("failed to read source object for incoming Model link, ignoring", &element);
             continue;
         }
 
-        const Material* const mat = dynamic_cast<const Material*>(ob);
-        if(mat) {
+        const Material *const mat = dynamic_cast<const Material *>(ob);
+        if (mat) {
             materials.push_back(mat);
             continue;
         }
 
-        const Geometry* const geo = dynamic_cast<const Geometry*>(ob);
-        if(geo) {
+        const Geometry *const geo = dynamic_cast<const Geometry *>(ob);
+        if (geo) {
             geometry.push_back(geo);
             continue;
         }
 
-        const NodeAttribute* const att = dynamic_cast<const NodeAttribute*>(ob);
-        if(att) {
+        const NodeAttribute *const att = dynamic_cast<const NodeAttribute *>(ob);
+        if (att) {
             attributes.push_back(att);
             continue;
         }
 
-        DOMWarning("source object for model link is neither Material, NodeAttribute nor Geometry, ignoring",&element);
+        DOMWarning("source object for model link is neither Material, NodeAttribute nor Geometry, ignoring", &element);
         continue;
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-bool Model::IsNull() const
-{
-    const std::vector<const NodeAttribute*>& attrs = GetAttributes();
-    for(const NodeAttribute* att : attrs) {
+bool Model::IsNull() const {
+    const std::vector<const NodeAttribute *> &attrs = GetAttributes();
+    for (const NodeAttribute *att : attrs) {
 
-        const Null* null_tag = dynamic_cast<const Null*>(att);
-        if(null_tag) {
+        const Null *null_tag = dynamic_cast<const Null *>(att);
+        if (null_tag) {
             return true;
         }
     }
@@ -146,8 +135,7 @@ bool Model::IsNull() const
     return false;
 }
 
-
-} //!FBX
-} //!Assimp
+} // namespace FBX
+} // namespace Assimp
 
 #endif
diff --git a/Engine/lib/assimp/code/FBX/FBXNodeAttribute.cpp b/Engine/lib/assimp/code/AssetLib/FBX/FBXNodeAttribute.cpp
similarity index 99%
rename from Engine/lib/assimp/code/FBX/FBXNodeAttribute.cpp
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXNodeAttribute.cpp
index b72e5637e..a144f417a 100644
--- a/Engine/lib/assimp/code/FBX/FBXNodeAttribute.cpp
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXNodeAttribute.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/FBX/FBXParser.cpp b/Engine/lib/assimp/code/AssetLib/FBX/FBXParser.cpp
similarity index 92%
rename from Engine/lib/assimp/code/FBX/FBXParser.cpp
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXParser.cpp
index 4a9346040..e20377a3c 100644
--- a/Engine/lib/assimp/code/FBX/FBXParser.cpp
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXParser.cpp
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -46,11 +45,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_FBX_IMPORTER
 
-#ifdef ASSIMP_BUILD_NO_OWN_ZLIB
-#   include <zlib.h>
-#else
-#   include "../contrib/zlib/zlib.h"
-#endif
+//#ifdef ASSIMP_BUILD_NO_OWN_ZLIB
+#include "Common/Compression.h"
+//#   include <zlib.h>
+//#else
+//#   include "../contrib/zlib/zlib.h"
+//#endif
 
 #include "FBXTokenizer.h"
 #include "FBXParser.h"
@@ -59,6 +59,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/ParsingUtils.h>
 #include <assimp/fast_atof.h>
 #include <assimp/ByteSwapper.h>
+#include <assimp/DefaultLogger.hpp>
 
 #include <iostream>
 
@@ -72,17 +73,17 @@ namespace {
     AI_WONT_RETURN void ParseError(const std::string& message, const Token& token) AI_WONT_RETURN_SUFFIX;
     AI_WONT_RETURN void ParseError(const std::string& message, const Token& token)
     {
-        throw DeadlyImportError(Util::AddTokenText("FBX-Parser",message,&token));
+        throw DeadlyImportError("FBX-Parser", Util::GetTokenText(&token), message);
     }
 
     // ------------------------------------------------------------------------------------------------
-    AI_WONT_RETURN void ParseError(const std::string& message, const Element* element = NULL) AI_WONT_RETURN_SUFFIX;
+    AI_WONT_RETURN void ParseError(const std::string &message, const Element *element = nullptr) AI_WONT_RETURN_SUFFIX;
     AI_WONT_RETURN void ParseError(const std::string& message, const Element* element)
     {
         if(element) {
             ParseError(message,element->KeyToken());
         }
-        throw DeadlyImportError("FBX-Parser " + message);
+        throw DeadlyImportError("FBX-Parser ", message);
     }
 
 
@@ -114,9 +115,7 @@ namespace Assimp {
 namespace FBX {
 
 // ------------------------------------------------------------------------------------------------
-Element::Element(const Token& key_token, Parser& parser)
-: key_token(key_token)
-{
+Element::Element(const Token& key_token, Parser& parser) : key_token(key_token) {
     TokenPtr n = nullptr;
     do {
         n = parser.AdvanceToNextToken();
@@ -180,7 +179,7 @@ Scope::Scope(Parser& parser,bool topLevel)
     }
 
     TokenPtr n = parser.AdvanceToNextToken();
-    if(n == NULL) {
+    if (n == nullptr) {
         ParseError("unexpected end of file");
     }
 
@@ -191,11 +190,15 @@ Scope::Scope(Parser& parser,bool topLevel)
         }
 
         const std::string& str = n->StringContents();
+        if (str.empty()) {
+            ParseError("unexpected content: empty string.");
+        }
+        
         elements.insert(ElementMap::value_type(str,new_Element(*n,parser)));
 
         // Element() should stop at the next Key token (or right after a Close token)
         n = parser.CurrentToken();
-        if(n == NULL) {
+        if (n == nullptr) {
             if (topLevel) {
                 return;
             }
@@ -205,8 +208,7 @@ Scope::Scope(Parser& parser,bool topLevel)
 }
 
 // ------------------------------------------------------------------------------------------------
-Scope::~Scope()
-{
+Scope::~Scope() {
     for(ElementMap::value_type& v : elements) {
         delete v.second;
     }
@@ -220,6 +222,7 @@ Parser::Parser (const TokenList& tokens, bool is_binary)
 , cursor(tokens.begin())
 , is_binary(is_binary)
 {
+    ASSIMP_LOG_DEBUG("Parsing FBX tokens");
     root.reset(new Scope(*this,true));
 }
 
@@ -234,7 +237,7 @@ TokenPtr Parser::AdvanceToNextToken()
 {
     last = current;
     if (cursor == tokens.end()) {
-        current = NULL;
+        current = nullptr;
     } else {
         current = *cursor++;
     }
@@ -256,7 +259,7 @@ TokenPtr Parser::LastToken() const
 // ------------------------------------------------------------------------------------------------
 uint64_t ParseTokenAsID(const Token& t, const char*& err_out)
 {
-    err_out = NULL;
+    err_out = nullptr;
 
     if (t.Type() != TokenType_DATA) {
         err_out = "expected TOK_DATA token";
@@ -294,7 +297,7 @@ uint64_t ParseTokenAsID(const Token& t, const char*& err_out)
 size_t ParseTokenAsDim(const Token& t, const char*& err_out)
 {
     // same as ID parsing, except there is a trailing asterisk
-    err_out = NULL;
+    err_out = nullptr;
 
     if (t.Type() != TokenType_DATA) {
         err_out = "expected TOK_DATA token";
@@ -340,7 +343,7 @@ size_t ParseTokenAsDim(const Token& t, const char*& err_out)
 // ------------------------------------------------------------------------------------------------
 float ParseTokenAsFloat(const Token& t, const char*& err_out)
 {
-    err_out = NULL;
+    err_out = nullptr;
 
     if (t.Type() != TokenType_DATA) {
         err_out = "expected TOK_DATA token";
@@ -367,9 +370,13 @@ float ParseTokenAsFloat(const Token& t, const char*& err_out)
     // first - next in the fbx token stream comes ',',
     // which fast_atof could interpret as decimal point.
 #define MAX_FLOAT_LENGTH 31
-    char temp[MAX_FLOAT_LENGTH + 1];
     const size_t length = static_cast<size_t>(t.end()-t.begin());
-    std::copy(t.begin(),t.end(),temp);
+    if (length > MAX_FLOAT_LENGTH) {
+        return 0.f;
+    }
+
+    char temp[MAX_FLOAT_LENGTH + 1];
+    std::copy(t.begin(), t.end(), temp);
     temp[std::min(static_cast<size_t>(MAX_FLOAT_LENGTH),length)] = '\0';
 
     return fast_atof(temp);
@@ -379,7 +386,7 @@ float ParseTokenAsFloat(const Token& t, const char*& err_out)
 // ------------------------------------------------------------------------------------------------
 int ParseTokenAsInt(const Token& t, const char*& err_out)
 {
-    err_out = NULL;
+    err_out = nullptr;
 
     if (t.Type() != TokenType_DATA) {
         err_out = "expected TOK_DATA token";
@@ -415,7 +422,7 @@ int ParseTokenAsInt(const Token& t, const char*& err_out)
 // ------------------------------------------------------------------------------------------------
 int64_t ParseTokenAsInt64(const Token& t, const char*& err_out)
 {
-    err_out = NULL;
+    err_out = nullptr;
 
     if (t.Type() != TokenType_DATA) {
         err_out = "expected TOK_DATA token";
@@ -452,11 +459,11 @@ int64_t ParseTokenAsInt64(const Token& t, const char*& err_out)
 // ------------------------------------------------------------------------------------------------
 std::string ParseTokenAsString(const Token& t, const char*& err_out)
 {
-    err_out = NULL;
+    err_out = nullptr;
 
     if (t.Type() != TokenType_DATA) {
         err_out = "expected TOK_DATA token";
-        return "";
+        return std::string();
     }
 
     if(t.IsBinary())
@@ -464,7 +471,7 @@ std::string ParseTokenAsString(const Token& t, const char*& err_out)
         const char* data = t.begin();
         if (data[0] != 'S') {
             err_out = "failed to parse S(tring), unexpected data type (binary)";
-            return "";
+            return std::string();
         }
 
         // read string length
@@ -478,13 +485,13 @@ std::string ParseTokenAsString(const Token& t, const char*& err_out)
     const size_t length = static_cast<size_t>(t.end() - t.begin());
     if(length < 2) {
         err_out = "token is too short to hold a string";
-        return "";
+        return std::string();
     }
 
     const char* s = t.begin(), *e = t.end() - 1;
     if (*s != '\"' || *e != '\"') {
         err_out = "expected double quoted string";
-        return "";
+        return std::string();
     }
 
     return std::string(s+1,length-2);
@@ -517,9 +524,7 @@ void ReadBinaryDataArrayHead(const char*& data, const char* end, char& type, uin
 // ------------------------------------------------------------------------------------------------
 // read binary data array, assume cursor points to the 'compression mode' field (i.e. behind the header)
 void ReadBinaryDataArray(char type, uint32_t count, const char*& data, const char* end,
-    std::vector<char>& buff,
-    const Element& /*el*/)
-{
+        std::vector<char>& buff, const Element& /*el*/) {
     BE_NCONST uint32_t encmode = SafeParse<uint32_t>(data, end);
     AI_SWAP4(encmode);
     data += 4;
@@ -561,31 +566,11 @@ void ReadBinaryDataArray(char type, uint32_t count, const char*& data, const cha
     else if(encmode == 1) {
         // zlib/deflate, next comes ZIP head (0x78 0x01)
         // see http://www.ietf.org/rfc/rfc1950.txt
-
-        z_stream zstream;
-        zstream.opaque = Z_NULL;
-        zstream.zalloc = Z_NULL;
-        zstream.zfree  = Z_NULL;
-        zstream.data_type = Z_BINARY;
-
-        // http://hewgill.com/journal/entries/349-how-to-decompress-gzip-stream-with-zlib
-        if(Z_OK != inflateInit(&zstream)) {
-            ParseError("failure initializing zlib");
+         Compression compress;
+        if (compress.open(Compression::Format::Binary, Compression::FlushMode::Finish, 0)) {
+            compress.decompress(data, comp_len, buff);
+            compress.close();
         }
-
-        zstream.next_in   = reinterpret_cast<Bytef*>( const_cast<char*>(data) );
-        zstream.avail_in  = comp_len;
-
-        zstream.avail_out = static_cast<uInt>(buff.size());
-        zstream.next_out = reinterpret_cast<Bytef*>(&*buff.begin());
-        const int ret = inflate(&zstream, Z_FINISH);
-
-        if (ret != Z_STREAM_END && ret != Z_OK) {
-            ParseError("failure decompressing compressed data section");
-        }
-
-        // terminate zlib
-        inflateEnd(&zstream);
     }
 #ifdef ASSIMP_BUILD_DEBUG
     else {
@@ -635,7 +620,10 @@ void ParseVectorDataArray(std::vector<aiVector3D>& out, const Element& el)
         ReadBinaryDataArray(type, count, data, end, buff, el);
 
         ai_assert(data == end);
-        ai_assert(buff.size() == count * (type == 'd' ? 8 : 4));
+        uint64_t dataToRead = static_cast<uint64_t>(count) * (type == 'd' ? 8 : 4);
+        if (dataToRead != buff.size()) {
+            ParseError("Invalid read size (binary)",&el);
+        }
 
         const uint32_t count3 = count / 3;
         out.reserve(count3);
@@ -688,7 +676,6 @@ void ParseVectorDataArray(std::vector<aiVector3D>& out, const Element& el)
     }
 }
 
-
 // ------------------------------------------------------------------------------------------------
 // read an array of color4 tuples
 void ParseVectorDataArray(std::vector<aiColor4D>& out, const Element& el)
@@ -722,7 +709,10 @@ void ParseVectorDataArray(std::vector<aiColor4D>& out, const Element& el)
         ReadBinaryDataArray(type, count, data, end, buff, el);
 
         ai_assert(data == end);
-        ai_assert(buff.size() == count * (type == 'd' ? 8 : 4));
+        uint64_t dataToRead = static_cast<uint64_t>(count) * (type == 'd' ? 8 : 4);
+        if (dataToRead != buff.size()) {
+            ParseError("Invalid read size (binary)",&el);
+        }
 
         const uint32_t count4 = count / 4;
         out.reserve(count4);
@@ -770,8 +760,7 @@ void ParseVectorDataArray(std::vector<aiColor4D>& out, const Element& el)
 
 // ------------------------------------------------------------------------------------------------
 // read an array of float2 tuples
-void ParseVectorDataArray(std::vector<aiVector2D>& out, const Element& el)
-{
+void ParseVectorDataArray(std::vector<aiVector2D>& out, const Element& el) {
     out.resize( 0 );
     const TokenList& tok = el.Tokens();
     if(tok.empty()) {
@@ -801,7 +790,10 @@ void ParseVectorDataArray(std::vector<aiVector2D>& out, const Element& el)
         ReadBinaryDataArray(type, count, data, end, buff, el);
 
         ai_assert(data == end);
-        ai_assert(buff.size() == count * (type == 'd' ? 8 : 4));
+        uint64_t dataToRead = static_cast<uint64_t>(count) * (type == 'd' ? 8 : 4);
+        if (dataToRead != buff.size()) {
+            ParseError("Invalid read size (binary)",&el);
+        }
 
         const uint32_t count2 = count / 2;
         out.reserve(count2);
@@ -812,8 +804,7 @@ void ParseVectorDataArray(std::vector<aiVector2D>& out, const Element& el)
                 out.push_back(aiVector2D(static_cast<float>(d[0]),
                     static_cast<float>(d[1])));
             }
-        }
-        else if (type == 'f') {
+        } else if (type == 'f') {
             const float* f = reinterpret_cast<const float*>(&buff[0]);
             for (unsigned int i = 0; i < count2; ++i, f += 2) {
                 out.push_back(aiVector2D(f[0],f[1]));
@@ -846,8 +837,7 @@ void ParseVectorDataArray(std::vector<aiVector2D>& out, const Element& el)
 
 // ------------------------------------------------------------------------------------------------
 // read an array of ints
-void ParseVectorDataArray(std::vector<int>& out, const Element& el)
-{
+void ParseVectorDataArray(std::vector<int>& out, const Element& el) {
     out.resize( 0 );
     const TokenList& tok = el.Tokens();
     if(tok.empty()) {
@@ -873,7 +863,10 @@ void ParseVectorDataArray(std::vector<int>& out, const Element& el)
         ReadBinaryDataArray(type, count, data, end, buff, el);
 
         ai_assert(data == end);
-        ai_assert(buff.size() == count * 4);
+        uint64_t dataToRead = static_cast<uint64_t>(count) * 4;
+        if (dataToRead != buff.size()) {
+            ParseError("Invalid read size (binary)",&el);
+        }
 
         out.reserve(count);
 
@@ -931,7 +924,10 @@ void ParseVectorDataArray(std::vector<float>& out, const Element& el)
         ReadBinaryDataArray(type, count, data, end, buff, el);
 
         ai_assert(data == end);
-        ai_assert(buff.size() == count * (type == 'd' ? 8 : 4));
+        uint64_t dataToRead = static_cast<uint64_t>(count) * (type == 'd' ? 8 : 4);
+        if (dataToRead != buff.size()) {
+            ParseError("Invalid read size (binary)",&el);
+        }
 
         if (type == 'd') {
             const double* d = reinterpret_cast<const double*>(&buff[0]);
@@ -992,7 +988,10 @@ void ParseVectorDataArray(std::vector<unsigned int>& out, const Element& el)
         ReadBinaryDataArray(type, count, data, end, buff, el);
 
         ai_assert(data == end);
-        ai_assert(buff.size() == count * 4);
+        uint64_t dataToRead = static_cast<uint64_t>(count) * 4;
+        if (dataToRead != buff.size()) {
+            ParseError("Invalid read size (binary)",&el);
+        }
 
         out.reserve(count);
 
@@ -1057,7 +1056,10 @@ void ParseVectorDataArray(std::vector<uint64_t>& out, const Element& el)
         ReadBinaryDataArray(type, count, data, end, buff, el);
 
         ai_assert(data == end);
-        ai_assert(buff.size() == count * 8);
+        uint64_t dataToRead = static_cast<uint64_t>(count) * 8;
+        if (dataToRead != buff.size()) {
+            ParseError("Invalid read size (binary)",&el);
+        }
 
         out.reserve(count);
 
@@ -1115,7 +1117,10 @@ void ParseVectorDataArray(std::vector<int64_t>& out, const Element& el)
         ReadBinaryDataArray(type, count, data, end, buff, el);
 
         ai_assert(data == end);
-        ai_assert(buff.size() == count * 8);
+        uint64_t dataToRead = static_cast<uint64_t>(count) * 8;
+        if (dataToRead != buff.size()) {
+            ParseError("Invalid read size (binary)",&el);
+        }
 
         out.reserve(count);
 
@@ -1205,7 +1210,7 @@ bool HasElement( const Scope& sc, const std::string& index ) {
 
 // ------------------------------------------------------------------------------------------------
 // extract a required element from a scope, abort if the element cannot be found
-const Element& GetRequiredElement(const Scope& sc, const std::string& index, const Element* element /*= NULL*/)
+const Element& GetRequiredElement(const Scope& sc, const std::string& index, const Element* element /*= nullptr*/)
 {
     const Element* el = sc[index];
     if(!el) {
diff --git a/Engine/lib/assimp/code/FBX/FBXParser.h b/Engine/lib/assimp/code/AssetLib/FBX/FBXParser.h
similarity index 96%
rename from Engine/lib/assimp/code/FBX/FBXParser.h
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXParser.h
index 7b0cf7203..314481e42 100644
--- a/Engine/lib/assimp/code/FBX/FBXParser.h
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXParser.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -49,6 +48,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <stdint.h>
 #include <map>
 #include <memory>
+#include <vector>
 #include <assimp/LogAux.h>
 #include <assimp/fast_atof.h>
 
@@ -126,7 +126,7 @@ public:
 
     const Element* operator[] (const std::string& index) const {
         ElementMap::const_iterator it = elements.find(index);
-        return it == elements.end() ? NULL : (*it).second;
+        return it == elements.end() ? nullptr : (*it).second;
     }
 
 	const Element* FindElementCaseInsensitive(const std::string& elementName) const {
@@ -137,7 +137,7 @@ public:
 				return element->second;
 			}
 		}
-		return NULL;
+        return nullptr;
 	}
 
     ElementCollection GetCollection(const std::string& index) const {
@@ -219,7 +219,7 @@ void ParseVectorDataArray(std::vector<int64_t>& out, const Element& el);
 bool HasElement( const Scope& sc, const std::string& index );
 
 // extract a required element from a scope, abort if the element cannot be found
-const Element& GetRequiredElement(const Scope& sc, const std::string& index, const Element* element = NULL);
+const Element &GetRequiredElement(const Scope &sc, const std::string &index, const Element *element = nullptr);
 
 // extract required compound scope
 const Scope& GetRequiredScope(const Element& el);
diff --git a/Engine/lib/assimp/code/FBX/FBXProperties.cpp b/Engine/lib/assimp/code/AssetLib/FBX/FBXProperties.cpp
similarity index 78%
rename from Engine/lib/assimp/code/FBX/FBXProperties.cpp
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXProperties.cpp
index 8d7036b6a..7803c27ff 100644
--- a/Engine/lib/assimp/code/FBX/FBXProperties.cpp
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXProperties.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -52,6 +52,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "FBXDocumentUtil.h"
 #include "FBXProperties.h"
 
+#include <utility>
+
 namespace Assimp {
 namespace FBX {
 
@@ -69,30 +71,51 @@ Property::~Property()
 
 namespace {
 
+void checkTokenCount(const TokenList& tok, unsigned int expectedCount)
+{
+    ai_assert(expectedCount >= 2);
+    if (tok.size() < expectedCount) {
+        const std::string& s = ParseTokenAsString(*tok[1]);
+        if (tok[1]->IsBinary()) {
+            throw DeadlyImportError("Not enough tokens for property of type ", s, " at offset ", tok[1]->Offset());
+        }
+        else {
+            throw DeadlyImportError("Not enough tokens for property of type ", s, " at line ", tok[1]->Line());
+        }
+    }
+}
+
 // ------------------------------------------------------------------------------------------------
-// read a typed property out of a FBX element. The return value is NULL if the property cannot be read.
+// read a typed property out of a FBX element. The return value is nullptr if the property cannot be read.
 Property* ReadTypedProperty(const Element& element)
 {
     ai_assert(element.KeyToken().StringContents() == "P");
 
     const TokenList& tok = element.Tokens();
-    ai_assert(tok.size() >= 5);
+    if (tok.size() < 2) {
+        return nullptr;
+    }
 
     const std::string& s = ParseTokenAsString(*tok[1]);
     const char* const cs = s.c_str();
     if (!strcmp(cs,"KString")) {
+        checkTokenCount(tok, 5);
         return new TypedProperty<std::string>(ParseTokenAsString(*tok[4]));
     }
     else if (!strcmp(cs,"bool") || !strcmp(cs,"Bool")) {
+        checkTokenCount(tok, 5);
         return new TypedProperty<bool>(ParseTokenAsInt(*tok[4]) != 0);
     }
-    else if (!strcmp(cs, "int") || !strcmp(cs, "Int") || !strcmp(cs, "enum") || !strcmp(cs, "Enum")) {
+    else if (!strcmp(cs, "int") || !strcmp(cs, "Int") || !strcmp(cs, "enum") || !strcmp(cs, "Enum") || !strcmp(cs, "Integer")) {
+        checkTokenCount(tok, 5);
         return new TypedProperty<int>(ParseTokenAsInt(*tok[4]));
     }
     else if (!strcmp(cs, "ULongLong")) {
+        checkTokenCount(tok, 5);
         return new TypedProperty<uint64_t>(ParseTokenAsID(*tok[4]));
     }
     else if (!strcmp(cs, "KTime")) {
+        checkTokenCount(tok, 5);
         return new TypedProperty<int64_t>(ParseTokenAsInt64(*tok[4]));
     }
     else if (!strcmp(cs,"Vector3D") ||
@@ -103,16 +126,27 @@ Property* ReadTypedProperty(const Element& element)
         !strcmp(cs,"Lcl Rotation") ||
         !strcmp(cs,"Lcl Scaling")
         ) {
+        checkTokenCount(tok, 7);
         return new TypedProperty<aiVector3D>(aiVector3D(
             ParseTokenAsFloat(*tok[4]),
             ParseTokenAsFloat(*tok[5]),
             ParseTokenAsFloat(*tok[6]))
         );
     }
-    else if (!strcmp(cs,"double") || !strcmp(cs,"Number") || !strcmp(cs,"Float") || !strcmp(cs,"FieldOfView") || !strcmp( cs, "UnitScaleFactor" ) ) {
+    else if (!strcmp(cs,"double") || !strcmp(cs,"Number") || !strcmp(cs,"float") || !strcmp(cs,"Float") || !strcmp(cs,"FieldOfView") || !strcmp( cs, "UnitScaleFactor" ) ) {
+        checkTokenCount(tok, 5);
         return new TypedProperty<float>(ParseTokenAsFloat(*tok[4]));
     }
-    return NULL;
+    else if (!strcmp(cs, "ColorAndAlpha")) {
+        checkTokenCount(tok, 8);
+        return new TypedProperty<aiColor4D>(aiColor4D(
+            ParseTokenAsFloat(*tok[4]),
+            ParseTokenAsFloat(*tok[5]),
+            ParseTokenAsFloat(*tok[6]),
+            ParseTokenAsFloat(*tok[7]))
+        );
+    }
+    return nullptr;
 }
 
 
@@ -123,7 +157,7 @@ std::string PeekPropertyName(const Element& element)
     ai_assert(element.KeyToken().StringContents() == "P");
     const TokenList& tok = element.Tokens();
     if(tok.size() < 4) {
-        return "";
+        return std::string();
     }
 
     return ParseTokenAsString(*tok[0]);
@@ -140,10 +174,8 @@ PropertyTable::PropertyTable()
 }
 
 // ------------------------------------------------------------------------------------------------
-PropertyTable::PropertyTable(const Element& element, std::shared_ptr<const PropertyTable> templateProps)
-: templateProps(templateProps)
-, element(&element)
-{
+PropertyTable::PropertyTable(const Element &element, std::shared_ptr<const PropertyTable> templateProps) :
+        templateProps(std::move(templateProps)), element(&element) {
     const Scope& scope = GetRequiredScope(element);
     for(const ElementMap::value_type& v : scope.Elements()) {
         if(v.first != "P") {
@@ -167,7 +199,6 @@ PropertyTable::PropertyTable(const Element& element, std::shared_ptr<const Prope
     }
 }
 
-
 // ------------------------------------------------------------------------------------------------
 PropertyTable::~PropertyTable()
 {
@@ -197,7 +228,7 @@ const Property* PropertyTable::Get(const std::string& name) const
                 return templateProps->Get(name);
             }
 
-            return NULL;
+            return nullptr;
         }
     }
 
@@ -209,21 +240,25 @@ DirectPropertyMap PropertyTable::GetUnparsedProperties() const
     DirectPropertyMap result;
 
     // Loop through all the lazy properties (which is all the properties)
-    for(const LazyPropertyMap::value_type& element : lazyProps) {
+    for(const LazyPropertyMap::value_type& currentElement : lazyProps) {
 
         // Skip parsed properties
-        if (props.end() != props.find(element.first)) continue;
+        if (props.end() != props.find(currentElement.first)) {
+            continue;
+        }
 
         // Read the element's value.
         // Wrap the naked pointer (since the call site is required to acquire ownership)
         // std::unique_ptr from C++11 would be preferred both as a wrapper and a return value.
-        std::shared_ptr<Property> prop = std::shared_ptr<Property>(ReadTypedProperty(*element.second));
+        std::shared_ptr<Property> prop = std::shared_ptr<Property>(ReadTypedProperty(*currentElement.second));
 
         // Element could not be read. Skip it.
-        if (!prop) continue;
+        if (!prop) {
+            continue;
+        }
 
         // Add to result
-        result[element.first] = prop;
+        result[currentElement.first] = prop;
     }
 
     return result;
diff --git a/Engine/lib/assimp/code/FBX/FBXProperties.h b/Engine/lib/assimp/code/AssetLib/FBX/FBXProperties.h
similarity index 98%
rename from Engine/lib/assimp/code/FBX/FBXProperties.h
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXProperties.h
index 58755542f..18816117a 100644
--- a/Engine/lib/assimp/code/FBX/FBXProperties.h
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXProperties.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -98,7 +98,7 @@ typedef std::fbx_unordered_map<std::string,std::shared_ptr<Property> > DirectPro
 typedef std::fbx_unordered_map<std::string,const Property*>            PropertyMap;
 typedef std::fbx_unordered_map<std::string,const Element*>             LazyPropertyMap;
 
-/** 
+/**
  *  Represents a property table as can be found in the newer FBX files (Properties60, Properties70)
  */
 class PropertyTable {
@@ -110,7 +110,7 @@ public:
 
     const Property* Get(const std::string& name) const;
 
-    // PropertyTable's need not be coupled with FBX elements so this can be NULL
+    // PropertyTable's need not be coupled with FBX elements so this can be nullptr
     const Element* GetElement() const {
         return element;
     }
@@ -130,7 +130,7 @@ private:
 
 // ------------------------------------------------------------------------------------------------
 template <typename T>
-inline 
+inline
 T PropertyGet(const PropertyTable& in, const std::string& name, const T& defaultValue) {
     const Property* const prop = in.Get(name);
     if( nullptr == prop) {
@@ -148,7 +148,7 @@ T PropertyGet(const PropertyTable& in, const std::string& name, const T& default
 
 // ------------------------------------------------------------------------------------------------
 template <typename T>
-inline 
+inline
 T PropertyGet(const PropertyTable& in, const std::string& name, bool& result, bool useTemplate=false ) {
     const Property* prop = in.Get(name);
     if( nullptr == prop) {
diff --git a/Engine/lib/assimp/code/FBX/FBXTokenizer.cpp b/Engine/lib/assimp/code/AssetLib/FBX/FBXTokenizer.cpp
similarity index 95%
rename from Engine/lib/assimp/code/FBX/FBXTokenizer.cpp
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXTokenizer.cpp
index 252cce355..8698abac6 100644
--- a/Engine/lib/assimp/code/FBX/FBXTokenizer.cpp
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXTokenizer.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -54,6 +54,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "FBXTokenizer.h"
 #include "FBXUtil.h"
 #include <assimp/Exceptional.h>
+#include <assimp/DefaultLogger.hpp>
 
 namespace Assimp {
 namespace FBX {
@@ -89,7 +90,7 @@ namespace {
 AI_WONT_RETURN void TokenizeError(const std::string& message, unsigned int line, unsigned int column) AI_WONT_RETURN_SUFFIX;
 AI_WONT_RETURN void TokenizeError(const std::string& message, unsigned int line, unsigned int column)
 {
-    throw DeadlyImportError(Util::AddLineAndColumn("FBX-Tokenize",message,line,column));
+    throw DeadlyImportError("FBX-Tokenize", Util::GetLineAndColumnText(line,column), message);
 }
 
 
@@ -126,7 +127,7 @@ void ProcessDataToken( TokenList& output_tokens, const char*& start, const char*
         TokenizeError("unexpected character, expected data token", line, column);
     }
 
-    start = end = NULL;
+    start = end = nullptr;
 }
 
 }
@@ -134,7 +135,8 @@ void ProcessDataToken( TokenList& output_tokens, const char*& start, const char*
 // ------------------------------------------------------------------------------------------------
 void Tokenize(TokenList& output_tokens, const char* input)
 {
-    ai_assert(input);
+	ai_assert(input);
+	ASSIMP_LOG_DEBUG("Tokenizing ASCII FBX file");
 
     // line and column numbers numbers are one-based
     unsigned int line = 1;
@@ -144,7 +146,7 @@ void Tokenize(TokenList& output_tokens, const char* input)
     bool in_double_quotes = false;
     bool pending_data_token = false;
 
-    const char* token_begin = NULL, *token_end = NULL;
+    const char *token_begin = nullptr, *token_end = nullptr;
     for (const char* cur = input;*cur;column += (*cur == '\t' ? ASSIMP_FBX_TAB_WIDTH : 1), ++cur) {
         const char c = *cur;
 
diff --git a/Engine/lib/assimp/code/FBX/FBXTokenizer.h b/Engine/lib/assimp/code/AssetLib/FBX/FBXTokenizer.h
similarity index 98%
rename from Engine/lib/assimp/code/FBX/FBXTokenizer.h
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXTokenizer.h
index afa588a47..877950945 100644
--- a/Engine/lib/assimp/code/FBX/FBXTokenizer.h
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXTokenizer.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -48,6 +48,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "FBXCompileConfig.h"
 #include <assimp/ai_assert.h>
+#include <assimp/defs.h>
 #include <vector>
 #include <string>
 
diff --git a/Engine/lib/assimp/code/FBX/FBXUtil.cpp b/Engine/lib/assimp/code/AssetLib/FBX/FBXUtil.cpp
similarity index 88%
rename from Engine/lib/assimp/code/FBX/FBXUtil.cpp
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXUtil.cpp
index c10e057c8..ac465d6e9 100644
--- a/Engine/lib/assimp/code/FBX/FBXUtil.cpp
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXUtil.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -86,32 +86,30 @@ const char* TokenTypeString(TokenType t)
 
 
 // ------------------------------------------------------------------------------------------------
-std::string AddOffset(const std::string& prefix, const std::string& text, size_t offset)
+std::string GetOffsetText(size_t offset)
 {
-    return static_cast<std::string>( (Formatter::format() << prefix << " (offset 0x" << std::hex << offset << ") " << text) );
+    return static_cast<std::string>( Formatter::format() << " (offset 0x" << std::hex << offset << ") " );
 }
 
 // ------------------------------------------------------------------------------------------------
-std::string AddLineAndColumn(const std::string& prefix, const std::string& text, unsigned int line, unsigned int column)
+std::string GetLineAndColumnText(unsigned int line, unsigned int column)
 {
-    return static_cast<std::string>( (Formatter::format() << prefix << " (line " << line << " <<  col " << column << ") " << text) );
+    return static_cast<std::string>( Formatter::format() << " (line " << line << " <<  col " << column << ") " );
 }
 
 // ------------------------------------------------------------------------------------------------
-std::string AddTokenText(const std::string& prefix, const std::string& text, const Token* tok)
+std::string GetTokenText(const Token* tok)
 {
     if(tok->IsBinary()) {
-        return static_cast<std::string>( (Formatter::format() << prefix <<
+        return static_cast<std::string>( Formatter::format() <<
             " (" << TokenTypeString(tok->Type()) <<
-            ", offset 0x" << std::hex << tok->Offset() << ") " <<
-            text) );
+            ", offset 0x" << std::hex << tok->Offset() << ") " );
     }
 
-    return static_cast<std::string>( (Formatter::format() << prefix <<
+    return static_cast<std::string>( Formatter::format() <<
         " (" << TokenTypeString(tok->Type()) <<
         ", line " << tok->Line() <<
-        ", col " << tok->Column() << ") " <<
-        text) );
+        ", col " << tok->Column() << ") " );
 }
 
 // Generated by this formula: T["ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[i]] = i;
diff --git a/Engine/lib/assimp/code/FBX/FBXUtil.h b/Engine/lib/assimp/code/AssetLib/FBX/FBXUtil.h
similarity index 78%
rename from Engine/lib/assimp/code/FBX/FBXUtil.h
rename to Engine/lib/assimp/code/AssetLib/FBX/FBXUtil.h
index b63441885..0e0bb75be 100644
--- a/Engine/lib/assimp/code/FBX/FBXUtil.h
+++ b/Engine/lib/assimp/code/AssetLib/FBX/FBXUtil.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -73,31 +73,24 @@ const char* TokenTypeString(TokenType t);
 
 /** Format log/error messages using a given offset in the source binary file
  *
- *  @param prefix Message prefix to be preprended to the location info.
- *  @param text Message text
- *  @param line Line index, 1-based
- *  @param column Column index, 1-based
- *  @return A string of the following format: {prefix} (offset 0x{offset}) {text}*/
-std::string AddOffset(const std::string& prefix, const std::string& text, size_t offset);
+ *  @param offset offset within the file
+ *  @return A string of the following format: " (offset 0x{offset}) "*/
+std::string GetOffsetText(size_t offset);
 
 
 /** Format log/error messages using a given line location in the source file.
  *
- *  @param prefix Message prefix to be preprended to the location info.
- *  @param text Message text
  *  @param line Line index, 1-based
  *  @param column Column index, 1-based
- *  @return A string of the following format: {prefix} (line {line}, col {column}) {text}*/
-std::string AddLineAndColumn(const std::string& prefix, const std::string& text, unsigned int line, unsigned int column);
+ *  @return A string of the following format: " (line {line}, col {column}) "*/
+std::string GetLineAndColumnText(unsigned int line, unsigned int column);
 
 
 /** Format log/error messages using a given cursor token.
  *
- *  @param prefix Message prefix to be preprended to the location info.
- *  @param text Message text
  *  @param tok Token where parsing/processing stopped
- *  @return A string of the following format: {prefix} ({token-type}, line {line}, col {column}) {text}*/
-std::string AddTokenText(const std::string& prefix, const std::string& text, const Token* tok);
+ *  @return A string of the following format: " ({token-type}, line {line}, col {column}) "*/
+std::string GetTokenText(const Token* tok);
 
 /** Decode a single Base64-encoded character.
 *
diff --git a/Engine/lib/assimp/code/HMP/HMPFileData.h b/Engine/lib/assimp/code/AssetLib/HMP/HMPFileData.h
similarity index 99%
rename from Engine/lib/assimp/code/HMP/HMPFileData.h
rename to Engine/lib/assimp/code/AssetLib/HMP/HMPFileData.h
index ab4100174..b297136ba 100644
--- a/Engine/lib/assimp/code/HMP/HMPFileData.h
+++ b/Engine/lib/assimp/code/AssetLib/HMP/HMPFileData.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/HMP/HMPLoader.cpp b/Engine/lib/assimp/code/AssetLib/HMP/HMPLoader.cpp
similarity index 53%
rename from Engine/lib/assimp/code/HMP/HMPLoader.cpp
rename to Engine/lib/assimp/code/AssetLib/HMP/HMPLoader.cpp
index d5469181e..1625cb359 100644
--- a/Engine/lib/assimp/code/HMP/HMPLoader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/HMP/HMPLoader.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,17 +41,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** @file Implementation of the MDL importer class */
 
-
 #ifndef ASSIMP_BUILD_NO_HMP_IMPORTER
 
 // internal headers
-#include "HMP/HMPLoader.h"
-#include "MD2/MD2FileData.h"
+#include "AssetLib/HMP/HMPLoader.h"
+#include "AssetLib/MD2/MD2FileData.h"
 
-#include <assimp/IOSystem.hpp>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/scene.h>
+#include <assimp/StringUtils.h>
 #include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOSystem.hpp>
 
 #include <memory>
 
@@ -74,193 +72,169 @@ static const aiImporterDesc desc = {
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-HMPImporter::HMPImporter()
-{
+HMPImporter::HMPImporter() {
     // nothing to do here
 }
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-HMPImporter::~HMPImporter()
-{
+HMPImporter::~HMPImporter() {
     // nothing to do here
 }
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool HMPImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool cs) const
-{
-    const std::string extension = GetExtension(pFile);
-    if (extension == "hmp" )
-        return true;
-
-    // if check for extension is not enough, check for the magic tokens
-    if (!extension.length() || cs) {
-        uint32_t tokens[3];
-        tokens[0] = AI_HMP_MAGIC_NUMBER_LE_4;
-        tokens[1] = AI_HMP_MAGIC_NUMBER_LE_5;
-        tokens[2] = AI_HMP_MAGIC_NUMBER_LE_7;
-        return CheckMagicToken(pIOHandler,pFile,tokens,3,0);
-    }
-    return false;
+bool HMPImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
+    static const uint32_t tokens[] = {
+        AI_HMP_MAGIC_NUMBER_LE_4,
+        AI_HMP_MAGIC_NUMBER_LE_5,
+        AI_HMP_MAGIC_NUMBER_LE_7
+    };
+    return CheckMagicToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get list of all file extensions that are handled by this loader
-const aiImporterDesc* HMPImporter::GetInfo () const
-{
+const aiImporterDesc *HMPImporter::GetInfo() const {
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void HMPImporter::InternReadFile( const std::string& pFile,
-                                 aiScene* _pScene, IOSystem* _pIOHandler)
-{
-    pScene     = _pScene;
-    pIOHandler = _pIOHandler;
-    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile));
+void HMPImporter::InternReadFile(const std::string &pFile,
+        aiScene *_pScene, IOSystem *_pIOHandler) {
+    pScene = _pScene;
+    mIOHandler = _pIOHandler;
+    std::unique_ptr<IOStream> file(mIOHandler->Open(pFile));
 
     // Check whether we can read from the file
-    if( file.get() == NULL)
-        throw DeadlyImportError( "Failed to open HMP file " + pFile + ".");
+    if (file.get() == nullptr) {
+        throw DeadlyImportError("Failed to open HMP file ", pFile, ".");
+    }
 
     // Check whether the HMP file is large enough to contain
     // at least the file header
     const size_t fileSize = file->FileSize();
-    if( fileSize < 50)
-        throw DeadlyImportError( "HMP File is too small.");
+    if (fileSize < 50)
+        throw DeadlyImportError("HMP File is too small.");
 
     // Allocate storage and copy the contents of the file to a memory buffer
     mBuffer = new uint8_t[fileSize];
-    file->Read( (void*)mBuffer, 1, fileSize);
+    file->Read((void *)mBuffer, 1, fileSize);
     iFileSize = (unsigned int)fileSize;
 
     // Determine the file subtype and call the appropriate member function
-    const uint32_t iMagic = *((uint32_t*)this->mBuffer);
+    const uint32_t iMagic = *((uint32_t *)this->mBuffer);
 
     // HMP4 format
     if (AI_HMP_MAGIC_NUMBER_LE_4 == iMagic ||
-        AI_HMP_MAGIC_NUMBER_BE_4 == iMagic)
-    {
+            AI_HMP_MAGIC_NUMBER_BE_4 == iMagic) {
         ASSIMP_LOG_DEBUG("HMP subtype: 3D GameStudio A4, magic word is HMP4");
         InternReadFile_HMP4();
     }
     // HMP5 format
     else if (AI_HMP_MAGIC_NUMBER_LE_5 == iMagic ||
-             AI_HMP_MAGIC_NUMBER_BE_5 == iMagic)
-    {
+             AI_HMP_MAGIC_NUMBER_BE_5 == iMagic) {
         ASSIMP_LOG_DEBUG("HMP subtype: 3D GameStudio A5, magic word is HMP5");
         InternReadFile_HMP5();
     }
     // HMP7 format
     else if (AI_HMP_MAGIC_NUMBER_LE_7 == iMagic ||
-             AI_HMP_MAGIC_NUMBER_BE_7 == iMagic)
-    {
+             AI_HMP_MAGIC_NUMBER_BE_7 == iMagic) {
         ASSIMP_LOG_DEBUG("HMP subtype: 3D GameStudio A7, magic word is HMP7");
         InternReadFile_HMP7();
-    }
-    else
-    {
+    } else {
         // Print the magic word to the logger
-        char szBuffer[5];
-        szBuffer[0] = ((char*)&iMagic)[0];
-        szBuffer[1] = ((char*)&iMagic)[1];
-        szBuffer[2] = ((char*)&iMagic)[2];
-        szBuffer[3] = ((char*)&iMagic)[3];
-        szBuffer[4] = '\0';
+        std::string szBuffer = ai_str_toprintable((const char *)&iMagic, sizeof(iMagic));
+
+        delete[] mBuffer;
+        mBuffer = nullptr;
 
         // We're definitely unable to load this file
-        throw DeadlyImportError( "Unknown HMP subformat " + pFile +
-            ". Magic word (" + szBuffer + ") is not known");
+        throw DeadlyImportError("Unknown HMP subformat ", pFile,
+                                ". Magic word (", szBuffer, ") is not known");
     }
 
     // Set the AI_SCENE_FLAGS_TERRAIN bit
     pScene->mFlags |= AI_SCENE_FLAGS_TERRAIN;
 
     delete[] mBuffer;
-    mBuffer= nullptr;
-
+    mBuffer = nullptr;
 }
 
 // ------------------------------------------------------------------------------------------------
-void HMPImporter::ValidateHeader_HMP457( )
-{
-    const HMP::Header_HMP5* const pcHeader = (const HMP::Header_HMP5*)mBuffer;
+void HMPImporter::ValidateHeader_HMP457() {
+    const HMP::Header_HMP5 *const pcHeader = (const HMP::Header_HMP5 *)mBuffer;
 
-    if (120 > iFileSize)
-    {
+    if (120 > iFileSize) {
         throw DeadlyImportError("HMP file is too small (header size is "
-            "120 bytes, this file is smaller)");
+                                "120 bytes, this file is smaller)");
     }
 
     if (!pcHeader->ftrisize_x || !pcHeader->ftrisize_y)
         throw DeadlyImportError("Size of triangles in either  x or y direction is zero");
 
-    if(pcHeader->fnumverts_x < 1.0f || (pcHeader->numverts/pcHeader->fnumverts_x) < 1.0f)
+    if (pcHeader->fnumverts_x < 1.0f || (pcHeader->numverts / pcHeader->fnumverts_x) < 1.0f)
         throw DeadlyImportError("Number of triangles in either x or y direction is zero");
 
-    if(!pcHeader->numframes)
+    if (!pcHeader->numframes)
         throw DeadlyImportError("There are no frames. At least one should be there");
-
 }
 
 // ------------------------------------------------------------------------------------------------
-void HMPImporter::InternReadFile_HMP4( )
-{
+void HMPImporter::InternReadFile_HMP4() {
     throw DeadlyImportError("HMP4 is currently not supported");
 }
 
 // ------------------------------------------------------------------------------------------------
-void HMPImporter::InternReadFile_HMP5( )
-{
+void HMPImporter::InternReadFile_HMP5() {
     // read the file header and skip everything to byte 84
-    const HMP::Header_HMP5* pcHeader = (const HMP::Header_HMP5*)mBuffer;
-    const unsigned char* szCurrent = (const unsigned char*)(mBuffer+84);
+    const HMP::Header_HMP5 *pcHeader = (const HMP::Header_HMP5 *)mBuffer;
+    const unsigned char *szCurrent = (const unsigned char *)(mBuffer + 84);
     ValidateHeader_HMP457();
 
     // generate an output mesh
     pScene->mNumMeshes = 1;
-    pScene->mMeshes = new aiMesh*[1];
-    aiMesh* pcMesh = pScene->mMeshes[0] = new aiMesh();
+    pScene->mMeshes = new aiMesh *[1];
+    aiMesh *pcMesh = pScene->mMeshes[0] = new aiMesh();
 
     pcMesh->mMaterialIndex = 0;
     pcMesh->mVertices = new aiVector3D[pcHeader->numverts];
     pcMesh->mNormals = new aiVector3D[pcHeader->numverts];
 
     const unsigned int height = (unsigned int)(pcHeader->numverts / pcHeader->fnumverts_x);
-    const unsigned int width =  (unsigned int)pcHeader->fnumverts_x;
+    const unsigned int width = (unsigned int)pcHeader->fnumverts_x;
 
     // generate/load a material for the terrain
-    CreateMaterial(szCurrent,&szCurrent);
+    CreateMaterial(szCurrent, &szCurrent);
 
     // goto offset 120, I don't know why ...
     // (fixme) is this the frame header? I assume yes since it starts with 2.
     szCurrent += 36;
-    SizeCheck(szCurrent + sizeof(const HMP::Vertex_HMP7)*height*width);
+    SizeCheck(szCurrent + sizeof(const HMP::Vertex_HMP7) * height * width);
 
     // now load all vertices from the file
-    aiVector3D* pcVertOut = pcMesh->mVertices;
-    aiVector3D* pcNorOut = pcMesh->mNormals;
-    const HMP::Vertex_HMP5* src = (const HMP::Vertex_HMP5*) szCurrent;
-    for (unsigned int y = 0; y < height;++y)
-    {
-        for (unsigned int x = 0; x < width;++x)
-        {
+    aiVector3D *pcVertOut = pcMesh->mVertices;
+    aiVector3D *pcNorOut = pcMesh->mNormals;
+    const HMP::Vertex_HMP5 *src = (const HMP::Vertex_HMP5 *)szCurrent;
+    for (unsigned int y = 0; y < height; ++y) {
+        for (unsigned int x = 0; x < width; ++x) {
             pcVertOut->x = x * pcHeader->ftrisize_x;
             pcVertOut->y = y * pcHeader->ftrisize_y;
-            pcVertOut->z = (((float)src->z / 0xffff)-0.5f) * pcHeader->ftrisize_x * 8.0f;
-            MD2::LookupNormalIndex(src->normals162index, *pcNorOut );
-            ++pcVertOut;++pcNorOut;++src;
+            pcVertOut->z = (((float)src->z / 0xffff) - 0.5f) * pcHeader->ftrisize_x * 8.0f;
+            MD2::LookupNormalIndex(src->normals162index, *pcNorOut);
+            ++pcVertOut;
+            ++pcNorOut;
+            ++src;
         }
     }
 
     // generate texture coordinates if necessary
     if (pcHeader->numskins)
-        GenerateTextureCoords(width,height);
+        GenerateTextureCoords(width, height);
 
     // now build a list of faces
-    CreateOutputFaceList(width,height);
+    CreateOutputFaceList(width, height);
 
     // there is no nodegraph in HMP files. Simply assign the one mesh
     // (no, not the one ring) to the root node
@@ -272,17 +246,16 @@ void HMPImporter::InternReadFile_HMP5( )
 }
 
 // ------------------------------------------------------------------------------------------------
-void HMPImporter::InternReadFile_HMP7( )
-{
+void HMPImporter::InternReadFile_HMP7() {
     // read the file header and skip everything to byte 84
-    const HMP::Header_HMP5* const pcHeader = (const HMP::Header_HMP5*)mBuffer;
-    const unsigned char* szCurrent = (const unsigned char*)(mBuffer+84);
+    const HMP::Header_HMP5 *const pcHeader = (const HMP::Header_HMP5 *)mBuffer;
+    const unsigned char *szCurrent = (const unsigned char *)(mBuffer + 84);
     ValidateHeader_HMP457();
 
     // generate an output mesh
     pScene->mNumMeshes = 1;
-    pScene->mMeshes = new aiMesh*[1];
-    aiMesh* pcMesh = pScene->mMeshes[0] = new aiMesh();
+    pScene->mMeshes = new aiMesh *[1];
+    aiMesh *pcMesh = pScene->mMeshes[0] = new aiMesh();
 
     pcMesh->mMaterialIndex = 0;
     pcMesh->mVertices = new aiVector3D[pcHeader->numverts];
@@ -292,44 +265,46 @@ void HMPImporter::InternReadFile_HMP7( )
     const unsigned int width = (unsigned int)pcHeader->fnumverts_x;
 
     // generate/load a material for the terrain
-    CreateMaterial(szCurrent,&szCurrent);
+    CreateMaterial(szCurrent, &szCurrent);
 
     // goto offset 120, I don't know why ...
     // (fixme) is this the frame header? I assume yes since it starts with 2.
     szCurrent += 36;
 
-    SizeCheck(szCurrent + sizeof(const HMP::Vertex_HMP7)*height*width);
+    SizeCheck(szCurrent + sizeof(const HMP::Vertex_HMP7) * height * width);
 
     // now load all vertices from the file
-    aiVector3D* pcVertOut = pcMesh->mVertices;
-    aiVector3D* pcNorOut = pcMesh->mNormals;
-    const HMP::Vertex_HMP7* src = (const HMP::Vertex_HMP7*) szCurrent;
-    for (unsigned int y = 0; y < height;++y)
-    {
-        for (unsigned int x = 0; x < width;++x)
-        {
+    aiVector3D *pcVertOut = pcMesh->mVertices;
+    ai_assert(pcVertOut != nullptr);
+    aiVector3D *pcNorOut = pcMesh->mNormals;
+    ai_assert(pcNorOut != nullptr);
+    const HMP::Vertex_HMP7 *src = (const HMP::Vertex_HMP7 *)szCurrent;
+    for (unsigned int y = 0; y < height; ++y) {
+        for (unsigned int x = 0; x < width; ++x) {
             pcVertOut->x = x * pcHeader->ftrisize_x;
             pcVertOut->y = y * pcHeader->ftrisize_y;
 
             // FIXME: What exctly is the correct scaling factor to use?
             // possibly pcHeader->scale_origin[2] in combination with a
             // signed interpretation of src->z?
-            pcVertOut->z = (((float)src->z / 0xffff)-0.5f) * pcHeader->ftrisize_x * 8.0f;
+            pcVertOut->z = (((float)src->z / 0xffff) - 0.5f) * pcHeader->ftrisize_x * 8.0f;
 
-            pcNorOut->x = ((float)src->normal_x / 0x80 ); // * pcHeader->scale_origin[0];
-            pcNorOut->y = ((float)src->normal_y / 0x80 ); // * pcHeader->scale_origin[1];
+            pcNorOut->x = ((float)src->normal_x / 0x80); // * pcHeader->scale_origin[0];
+            pcNorOut->y = ((float)src->normal_y / 0x80); // * pcHeader->scale_origin[1];
             pcNorOut->z = 1.0f;
             pcNorOut->Normalize();
 
-            ++pcVertOut;++pcNorOut;++src;
+            ++pcVertOut;
+            ++pcNorOut;
+            ++src;
         }
     }
 
     // generate texture coordinates if necessary
-    if (pcHeader->numskins)GenerateTextureCoords(width,height);
+    if (pcHeader->numskins) GenerateTextureCoords(width, height);
 
     // now build a list of faces
-    CreateOutputFaceList(width,height);
+    CreateOutputFaceList(width, height);
 
     // there is no nodegraph in HMP files. Simply assign the one mesh
     // (no, not the One Ring) to the root node
@@ -341,96 +316,100 @@ void HMPImporter::InternReadFile_HMP7( )
 }
 
 // ------------------------------------------------------------------------------------------------
-void HMPImporter::CreateMaterial(const unsigned char* szCurrent,
-    const unsigned char** szCurrentOut)
-{
-    aiMesh* const pcMesh = pScene->mMeshes[0];
-    const HMP::Header_HMP5* const pcHeader = (const HMP::Header_HMP5*)mBuffer;
+void HMPImporter::CreateMaterial(const unsigned char *szCurrent,
+        const unsigned char **szCurrentOut) {
+    aiMesh *const pcMesh = pScene->mMeshes[0];
+    const HMP::Header_HMP5 *const pcHeader = (const HMP::Header_HMP5 *)mBuffer;
 
     // we don't need to generate texture coordinates if
     // we have no textures in the file ...
-    if (pcHeader->numskins)
-    {
+    if (pcHeader->numskins) {
         pcMesh->mTextureCoords[0] = new aiVector3D[pcHeader->numverts];
         pcMesh->mNumUVComponents[0] = 2;
 
         // now read the first skin and skip all others
-        ReadFirstSkin(pcHeader->numskins,szCurrent,&szCurrent);
-    }
-    else
-    {
-        // generate a default material
-        const int iMode = (int)aiShadingMode_Gouraud;
-        aiMaterial* pcHelper = new aiMaterial();
-        pcHelper->AddProperty<int>(&iMode, 1, AI_MATKEY_SHADING_MODEL);
+        ReadFirstSkin(pcHeader->numskins, szCurrent, &szCurrent);
+        *szCurrentOut = szCurrent;
+        return;
+    } 
 
-        aiColor3D clr;
-        clr.b = clr.g = clr.r = 0.6f;
-        pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_DIFFUSE);
-        pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_SPECULAR);
+    // generate a default material
+    const int iMode = (int)aiShadingMode_Gouraud;
+    aiMaterial *pcHelper = new aiMaterial();
+    pcHelper->AddProperty<int>(&iMode, 1, AI_MATKEY_SHADING_MODEL);
 
-        clr.b = clr.g = clr.r = 0.05f;
-        pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_AMBIENT);
+    aiColor3D clr;
+    clr.b = clr.g = clr.r = 0.6f;
+    pcHelper->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_DIFFUSE);
+    pcHelper->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_SPECULAR);
 
-        aiString szName;
-        szName.Set(AI_DEFAULT_MATERIAL_NAME);
-        pcHelper->AddProperty(&szName,AI_MATKEY_NAME);
+    clr.b = clr.g = clr.r = 0.05f;
+    pcHelper->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_AMBIENT);
 
-        // add the material to the scene
-        pScene->mNumMaterials = 1;
-        pScene->mMaterials = new aiMaterial*[1];
-        pScene->mMaterials[0] = pcHelper;
-    }
+    aiString szName;
+    szName.Set(AI_DEFAULT_MATERIAL_NAME);
+    pcHelper->AddProperty(&szName, AI_MATKEY_NAME);
+
+    // add the material to the scene
+    pScene->mNumMaterials = 1;
+    pScene->mMaterials = new aiMaterial *[1];
+    pScene->mMaterials[0] = pcHelper;
     *szCurrentOut = szCurrent;
 }
 
 // ------------------------------------------------------------------------------------------------
-void HMPImporter::CreateOutputFaceList(unsigned int width,unsigned int height)
-{
-    aiMesh* const pcMesh = this->pScene->mMeshes[0];
+void HMPImporter::CreateOutputFaceList(unsigned int width, unsigned int height) {
+    aiMesh *const pcMesh = this->pScene->mMeshes[0];
 
     // Allocate enough storage
-    pcMesh->mNumFaces = (width-1) * (height-1);
+    pcMesh->mNumFaces = (width - 1) * (height - 1);
     pcMesh->mFaces = new aiFace[pcMesh->mNumFaces];
 
-    pcMesh->mNumVertices   = pcMesh->mNumFaces*4;
-    aiVector3D* pcVertices = new aiVector3D[pcMesh->mNumVertices];
-    aiVector3D* pcNormals  = new aiVector3D[pcMesh->mNumVertices];
+    pcMesh->mNumVertices = pcMesh->mNumFaces * 4;
+    aiVector3D *pcVertices = new aiVector3D[pcMesh->mNumVertices];
+    aiVector3D *pcNormals = new aiVector3D[pcMesh->mNumVertices];
 
-    aiFace* pcFaceOut(pcMesh->mFaces);
-    aiVector3D* pcVertOut = pcVertices;
-    aiVector3D* pcNorOut = pcNormals;
+    aiFace *pcFaceOut(pcMesh->mFaces);
+    aiVector3D *pcVertOut = pcVertices;
+    aiVector3D *pcNorOut = pcNormals;
 
-    aiVector3D* pcUVs = pcMesh->mTextureCoords[0] ? new aiVector3D[pcMesh->mNumVertices] : NULL;
-    aiVector3D* pcUVOut(pcUVs);
+    aiVector3D *pcUVs = pcMesh->mTextureCoords[0] ? new aiVector3D[pcMesh->mNumVertices] : nullptr;
+    aiVector3D *pcUVOut(pcUVs);
 
     // Build the terrain square
+    const unsigned int upperBound = pcMesh->mNumVertices;
     unsigned int iCurrent = 0;
-    for (unsigned int y = 0; y < height-1;++y)  {
-        for (unsigned int x = 0; x < width-1;++x,++pcFaceOut)   {
+    for (unsigned int y = 0; y < height - 1; ++y) {
+        const size_t offset0 = y * width;
+        const size_t offset1 = (y + 1) * width;
+        for (unsigned int x = 0; x < width - 1; ++x, ++pcFaceOut) {
             pcFaceOut->mNumIndices = 4;
             pcFaceOut->mIndices = new unsigned int[4];
-
-            *pcVertOut++ = pcMesh->mVertices[y*width+x];
-            *pcVertOut++ = pcMesh->mVertices[(y+1)*width+x];
-            *pcVertOut++ = pcMesh->mVertices[(y+1)*width+x+1];
-            *pcVertOut++ = pcMesh->mVertices[y*width+x+1];
-
-
-            *pcNorOut++ = pcMesh->mNormals[y*width+x];
-            *pcNorOut++ = pcMesh->mNormals[(y+1)*width+x];
-            *pcNorOut++ = pcMesh->mNormals[(y+1)*width+x+1];
-            *pcNorOut++ = pcMesh->mNormals[y*width+x+1];
-
-            if (pcMesh->mTextureCoords[0])
-            {
-                *pcUVOut++ = pcMesh->mTextureCoords[0][y*width+x];
-                *pcUVOut++ = pcMesh->mTextureCoords[0][(y+1)*width+x];
-                *pcUVOut++ = pcMesh->mTextureCoords[0][(y+1)*width+x+1];
-                *pcUVOut++ = pcMesh->mTextureCoords[0][y*width+x+1];
+            if ((offset0 + x + 1) >= upperBound){
+                continue;
+            }
+            if ((offset1 + x + 1) >= upperBound){
+                continue;
             }
 
-            for (unsigned int i = 0; i < 4;++i)
+            *pcVertOut++ = pcMesh->mVertices[offset0 + x];
+            *pcVertOut++ = pcMesh->mVertices[offset1 + x];
+            *pcVertOut++ = pcMesh->mVertices[offset1 + x + 1];
+            *pcVertOut++ = pcMesh->mVertices[offset0 + x + 1];
+
+            *pcNorOut++ = pcMesh->mNormals[offset0 + x];
+            *pcNorOut++ = pcMesh->mNormals[offset1 + x];
+            *pcNorOut++ = pcMesh->mNormals[offset1 + x + 1];
+            *pcNorOut++ = pcMesh->mNormals[offset0 + x + 1];
+
+            if (pcMesh->mTextureCoords[0]) {
+                *pcUVOut++ = pcMesh->mTextureCoords[0][offset0 + x];
+                *pcUVOut++ = pcMesh->mTextureCoords[0][offset1 + x];
+                *pcUVOut++ = pcMesh->mTextureCoords[0][offset1 + x + 1];
+                *pcUVOut++ = pcMesh->mTextureCoords[0][offset0 + x + 1];
+            }
+
+            for (unsigned int i = 0; i < 4; ++i)
                 pcFaceOut->mIndices[i] = iCurrent++;
         }
     }
@@ -440,58 +419,59 @@ void HMPImporter::CreateOutputFaceList(unsigned int width,unsigned int height)
     delete[] pcMesh->mNormals;
     pcMesh->mNormals = pcNormals;
 
-    if (pcMesh->mTextureCoords[0])
-    {
+    if (pcMesh->mTextureCoords[0]) {
         delete[] pcMesh->mTextureCoords[0];
         pcMesh->mTextureCoords[0] = pcUVs;
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void HMPImporter::ReadFirstSkin(unsigned int iNumSkins, const unsigned char* szCursor,
-    const unsigned char** szCursorOut)
-{
-    ai_assert( 0 != iNumSkins );
-    ai_assert( nullptr != szCursor);
+void HMPImporter::ReadFirstSkin(unsigned int iNumSkins, const unsigned char *szCursor,
+        const unsigned char **szCursorOut) {
+    ai_assert(0 != iNumSkins);
+    ai_assert(nullptr != szCursor);
 
     // read the type of the skin ...
     // sometimes we need to skip 12 bytes here, I don't know why ...
-    uint32_t iType = *((uint32_t*)szCursor);
+    uint32_t iType = *((uint32_t *)szCursor);
     szCursor += sizeof(uint32_t);
-    if (0 == iType)
-    {
+    if (0 == iType) {
         szCursor += sizeof(uint32_t) * 2;
-        iType = *((uint32_t*)szCursor);
+        iType = *((uint32_t *)szCursor);
         szCursor += sizeof(uint32_t);
         if (!iType)
             throw DeadlyImportError("Unable to read HMP7 skin chunk");
-
     }
     // read width and height
-    uint32_t iWidth  = *((uint32_t*)szCursor); szCursor += sizeof(uint32_t);
-    uint32_t iHeight = *((uint32_t*)szCursor); szCursor += sizeof(uint32_t);
+    uint32_t iWidth = *((uint32_t *)szCursor);
+    szCursor += sizeof(uint32_t);
+    uint32_t iHeight = *((uint32_t *)szCursor);
+    szCursor += sizeof(uint32_t);
 
     // allocate an output material
-    aiMaterial* pcMat = new aiMaterial();
+    aiMaterial *pcMat = new aiMaterial();
 
     // read the skin, this works exactly as for MDL7
-    ParseSkinLump_3DGS_MDL7(szCursor,&szCursor,
-        pcMat,iType,iWidth,iHeight);
+    ParseSkinLump_3DGS_MDL7(szCursor, &szCursor,
+            pcMat, iType, iWidth, iHeight);
 
     // now we need to skip any other skins ...
-    for (unsigned int i = 1; i< iNumSkins;++i)
-    {
-        iType   = *((uint32_t*)szCursor);   szCursor += sizeof(uint32_t);
-        iWidth  = *((uint32_t*)szCursor);   szCursor += sizeof(uint32_t);
-        iHeight = *((uint32_t*)szCursor);   szCursor += sizeof(uint32_t);
+    for (unsigned int i = 1; i < iNumSkins; ++i) {
+        SizeCheck(szCursor + 3 * sizeof(uint32_t));
+        iType = *((uint32_t *)szCursor);
+        szCursor += sizeof(uint32_t);
+        iWidth = *((uint32_t *)szCursor);
+        szCursor += sizeof(uint32_t);
+        iHeight = *((uint32_t *)szCursor);
+        szCursor += sizeof(uint32_t);
 
-        SkipSkinLump_3DGS_MDL7(szCursor,&szCursor,iType,iWidth,iHeight);
+        SkipSkinLump_3DGS_MDL7(szCursor, &szCursor, iType, iWidth, iHeight);
         SizeCheck(szCursor);
     }
 
     // setup the material ...
     pScene->mNumMaterials = 1;
-    pScene->mMaterials = new aiMaterial*[1];
+    pScene->mMaterials = new aiMaterial *[1];
     pScene->mMaterials[0] = pcMat;
 
     *szCursorOut = szCursor;
@@ -499,21 +479,27 @@ void HMPImporter::ReadFirstSkin(unsigned int iNumSkins, const unsigned char* szC
 
 // ------------------------------------------------------------------------------------------------
 // Generate proepr texture coords
-void HMPImporter::GenerateTextureCoords(
-    const unsigned int width, const unsigned int height)
-{
-    ai_assert(NULL != pScene->mMeshes && NULL != pScene->mMeshes[0] &&
-              NULL != pScene->mMeshes[0]->mTextureCoords[0]);
+void HMPImporter::GenerateTextureCoords(const unsigned int width, const unsigned int height) {
+    ai_assert(nullptr != pScene->mMeshes);
+    ai_assert(nullptr != pScene->mMeshes[0]);
+    ai_assert(nullptr != pScene->mMeshes[0]->mTextureCoords[0]);
 
-    aiVector3D* uv = pScene->mMeshes[0]->mTextureCoords[0];
+    aiVector3D *uv = pScene->mMeshes[0]->mTextureCoords[0];
+    if (uv == nullptr) {
+        return;
+    }
+    
+    if (height == 0.0f || width == 0.0) {
+        return;
+    }
+    
+    const float fY = (1.0f / height) + (1.0f / height) / height;
+    const float fX = (1.0f / width) + (1.0f / width) / width;
 
-    const float fY = (1.0f / height) + (1.0f / height) / (height-1);
-    const float fX = (1.0f / width) + (1.0f / width) / (width-1);
-
-    for (unsigned int y = 0; y < height;++y)    {
-        for (unsigned int x = 0; x < width;++x,++uv)    {
-            uv->y = fY*y;
-            uv->x = fX*x;
+    for (unsigned int y = 0; y < height; ++y) {
+        for (unsigned int x = 0; x < width; ++x, ++uv) {
+            uv->y = fY * y;
+            uv->x = fX * x;
             uv->z = 0.0f;
         }
     }
diff --git a/Engine/lib/assimp/code/HMP/HMPLoader.h b/Engine/lib/assimp/code/AssetLib/HMP/HMPLoader.h
similarity index 83%
rename from Engine/lib/assimp/code/HMP/HMPLoader.h
rename to Engine/lib/assimp/code/AssetLib/HMP/HMPLoader.h
index 421826c91..95ce0a9eb 100644
--- a/Engine/lib/assimp/code/HMP/HMPLoader.h
+++ b/Engine/lib/assimp/code/AssetLib/HMP/HMPLoader.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -42,15 +41,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file  HMPLoader.h
  *  @brief Declaration of the HMP importer class
  */
-
+#pragma once
 #ifndef AI_HMPLOADER_H_INCLUDED
 #define AI_HMPLOADER_H_INCLUDED
 
-// internal headers
 #include <assimp/BaseImporter.h>
 
-#include "MDL/MDLLoader.h"
-#include "HMP/HMPFileData.h"
+// internal headers
+#include "AssetLib/HMP/HMPFileData.h"
+#include "AssetLib/MDL/MDLLoader.h"
 
 namespace Assimp {
 using namespace HMP;
@@ -58,66 +57,58 @@ using namespace HMP;
 // ---------------------------------------------------------------------------
 /** Used to load 3D GameStudio HMP files (terrains)
 */
-class HMPImporter : public MDLImporter
-{
+class HMPImporter : public MDLImporter {
 public:
     HMPImporter();
-    ~HMPImporter();
-
-
-public:
+    ~HMPImporter() override;
 
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
      * See BaseImporter::CanRead() for details.
      */
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
+            bool checkSig) const override;
 
 protected:
-
-
     // -------------------------------------------------------------------
     /** Return importer meta information.
      * See #BaseImporter::GetInfo for the details
      */
-    const aiImporterDesc* GetInfo () const;
+    const aiImporterDesc *GetInfo() const override;
 
     // -------------------------------------------------------------------
     /** Imports the given file into the given scene structure.
     * See BaseImporter::InternReadFile() for details
     */
-    void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
-
-protected:
+    void InternReadFile(const std::string &pFile, aiScene *pScene,
+            IOSystem *pIOHandler) override;
 
     // -------------------------------------------------------------------
     /** Import a HMP4 file
     */
-    void InternReadFile_HMP4( );
+    void InternReadFile_HMP4();
 
     // -------------------------------------------------------------------
     /** Import a HMP5 file
     */
-    void InternReadFile_HMP5( );
+    void InternReadFile_HMP5();
 
     // -------------------------------------------------------------------
     /** Import a HMP7 file
     */
-    void InternReadFile_HMP7( );
+    void InternReadFile_HMP7();
 
     // -------------------------------------------------------------------
     /** Validate a HMP 5,4,7 file header
     */
-    void ValidateHeader_HMP457( );
+    void ValidateHeader_HMP457();
 
     // -------------------------------------------------------------------
     /** Try to load one material from the file, if this fails create
      * a default material
     */
-    void CreateMaterial(const unsigned char* szCurrent,
-        const unsigned char** szCurrentOut);
+    void CreateMaterial(const unsigned char *szCurrent,
+            const unsigned char **szCurrentOut);
 
     // -------------------------------------------------------------------
     /** Build a list of output faces and vertices. The function
@@ -125,7 +116,7 @@ protected:
      * \param width Width of the height field
      * \param width Height of the height field
     */
-    void CreateOutputFaceList(unsigned int width,unsigned int height);
+    void CreateOutputFaceList(unsigned int width, unsigned int height);
 
     // -------------------------------------------------------------------
     /** Generate planar texture coordinates for a terrain
@@ -133,21 +124,17 @@ protected:
      * \param height Height of the terrain, in vertices
     */
     void GenerateTextureCoords(const unsigned int width,
-        const unsigned int height);
+            const unsigned int height);
 
     // -------------------------------------------------------------------
     /** Read the first skin from the file and skip all others ...
      *  \param iNumSkins Number of skins in the file
      *  \param szCursor Position of the first skin (offset 84)
     */
-    void ReadFirstSkin(unsigned int iNumSkins, const unsigned char* szCursor,
-        const unsigned char** szCursorOut);
-
-private:
-
+    void ReadFirstSkin(unsigned int iNumSkins, const unsigned char *szCursor,
+            const unsigned char **szCursorOut);
 };
 
 } // end of namespace Assimp
 
 #endif // AI_HMPIMPORTER_H_INC
-
diff --git a/Engine/lib/assimp/code/HMP/HalfLifeFileData.h b/Engine/lib/assimp/code/AssetLib/HMP/HalfLifeFileData.h
similarity index 99%
rename from Engine/lib/assimp/code/HMP/HalfLifeFileData.h
rename to Engine/lib/assimp/code/AssetLib/HMP/HalfLifeFileData.h
index ef328edf8..f47862b7a 100644
--- a/Engine/lib/assimp/code/HMP/HalfLifeFileData.h
+++ b/Engine/lib/assimp/code/AssetLib/HMP/HalfLifeFileData.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCBoolean.cpp b/Engine/lib/assimp/code/AssetLib/IFC/IFCBoolean.cpp
similarity index 72%
rename from Engine/lib/assimp/code/Importer/IFC/IFCBoolean.cpp
rename to Engine/lib/assimp/code/AssetLib/IFC/IFCBoolean.cpp
index 10e7bf3af..36912a7d8 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCBoolean.cpp
+++ b/Engine/lib/assimp/code/AssetLib/IFC/IFCBoolean.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2010, assimp team
+Copyright (c) 2006-2022, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -43,65 +43,59 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
-#include "code/Importer/IFC/IFCUtil.h"
-#include "code/Common/PolyTools.h"
-#include "code/PostProcessing/ProcessHelper.h"
-#include <assimp/Defines.h>
+
+#include "AssetLib/IFC/IFCUtil.h"
+#include "Common/PolyTools.h"
+#include "PostProcessing/ProcessHelper.h"
+
 
 #include <iterator>
 #include <tuple>
 
 namespace Assimp {
-    namespace IFC {
+namespace IFC {
 
 // ------------------------------------------------------------------------------------------------
 // Calculates intersection between line segment and plane. To catch corner cases, specify which side you prefer.
 // The function then generates a hit only if the end is beyond a certain margin in that direction, filtering out
 // "very close to plane" ghost hits as long as start and end stay directly on or within the given plane side.
-bool IntersectSegmentPlane(const IfcVector3& p,const IfcVector3& n, const IfcVector3& e0,
-        const IfcVector3& e1, bool assumeStartOnWhiteSide, IfcVector3& out)
-{
+bool IntersectSegmentPlane(const IfcVector3 &p, const IfcVector3 &n, const IfcVector3 &e0,
+        const IfcVector3 &e1, bool assumeStartOnWhiteSide, IfcVector3 &out) {
     const IfcVector3 pdelta = e0 - p, seg = e1 - e0;
-    const IfcFloat dotOne = n*seg, dotTwo = -(n*pdelta);
+    const IfcFloat dotOne = n * seg, dotTwo = -(n * pdelta);
 
     // if segment ends on plane, do not report a hit. We stay on that side until a following segment starting at this
     // point leaves the plane through the other side
-    if( std::abs(dotOne + dotTwo) < 1e-6 )
+    if (std::abs(dotOne + dotTwo) < ai_epsilon)
         return false;
 
     // if segment starts on the plane, report a hit only if the end lies on the *other* side
-    if( std::abs(dotTwo) < 1e-6 )
-    {
-        if( (assumeStartOnWhiteSide && dotOne + dotTwo < 1e-6) || (!assumeStartOnWhiteSide && dotOne + dotTwo > -1e-6) )
-        {
+    if (std::abs(dotTwo) < ai_epsilon) {
+        if ((assumeStartOnWhiteSide && dotOne + dotTwo < ai_epsilon) || (!assumeStartOnWhiteSide && dotOne + dotTwo > -ai_epsilon)) {
             out = e0;
             return true;
-        }
-        else
-        {
+        } else {
             return false;
         }
     }
 
     // ignore if segment is parallel to plane and far away from it on either side
     // Warning: if there's a few thousand of such segments which slowly accumulate beyond the epsilon, no hit would be registered
-    if( std::abs(dotOne) < 1e-6 )
+    if (std::abs(dotOne) < ai_epsilon)
         return false;
 
     // t must be in [0..1] if the intersection point is within the given segment
     const IfcFloat t = dotTwo / dotOne;
-    if( t > 1.0 || t < 0.0 )
+    if (t > 1.0 || t < 0.0)
         return false;
 
-    out = e0 + t*seg;
+    out = e0 + t * seg;
     return true;
 }
 
 // ------------------------------------------------------------------------------------------------
-void FilterPolygon(std::vector<IfcVector3>& resultpoly)
-{
-    if( resultpoly.size() < 3 )
-    {
+void FilterPolygon(std::vector<IfcVector3> &resultpoly) {
+    if (resultpoly.size() < 3) {
         resultpoly.clear();
         return;
     }
@@ -115,87 +109,80 @@ void FilterPolygon(std::vector<IfcVector3>& resultpoly)
     FuzzyVectorCompare fz(epsilon);
     std::vector<IfcVector3>::iterator e = std::unique(resultpoly.begin(), resultpoly.end(), fz);
 
-    if( e != resultpoly.end() )
+    if (e != resultpoly.end())
         resultpoly.erase(e, resultpoly.end());
 
-    if( !resultpoly.empty() && fz(resultpoly.front(), resultpoly.back()) )
+    if (!resultpoly.empty() && fz(resultpoly.front(), resultpoly.back()))
         resultpoly.pop_back();
 }
 
 // ------------------------------------------------------------------------------------------------
-void WritePolygon(std::vector<IfcVector3>& resultpoly, TempMesh& result)
-{
+void WritePolygon(std::vector<IfcVector3> &resultpoly, TempMesh &result) {
     FilterPolygon(resultpoly);
 
-    if( resultpoly.size() > 2 )
-    {
+    if (resultpoly.size() > 2) {
         result.mVerts.insert(result.mVerts.end(), resultpoly.begin(), resultpoly.end());
         result.mVertcnt.push_back(static_cast<unsigned int>(resultpoly.size()));
     }
 }
 
-
 // ------------------------------------------------------------------------------------------------
-void ProcessBooleanHalfSpaceDifference(const Schema_2x3::IfcHalfSpaceSolid* hs, TempMesh& result,
-    const TempMesh& first_operand,
-    ConversionData& /*conv*/)
-{
-    ai_assert(hs != NULL);
+void ProcessBooleanHalfSpaceDifference(const Schema_2x3::IfcHalfSpaceSolid *hs, TempMesh &result,
+        const TempMesh &first_operand,
+        ConversionData & /*conv*/) {
+    ai_assert(hs != nullptr);
 
-    const Schema_2x3::IfcPlane* const plane = hs->BaseSurface->ToPtr<Schema_2x3::IfcPlane>();
-    if(!plane) {
+    const Schema_2x3::IfcPlane *const plane = hs->BaseSurface->ToPtr<Schema_2x3::IfcPlane>();
+    if (!plane) {
         IFCImporter::LogError("expected IfcPlane as base surface for the IfcHalfSpaceSolid");
         return;
     }
 
     // extract plane base position vector and normal vector
-    IfcVector3 p,n(0.f,0.f,1.f);
+    IfcVector3 p, n(0.f, 0.f, 1.f);
     if (plane->Position->Axis) {
-        ConvertDirection(n,plane->Position->Axis.Get());
+        ConvertDirection(n, plane->Position->Axis.Get());
     }
-    ConvertCartesianPoint(p,plane->Position->Location);
+    ConvertCartesianPoint(p, plane->Position->Location);
 
-    if(!IsTrue(hs->AgreementFlag)) {
+    if (!IsTrue(hs->AgreementFlag)) {
         n *= -1.f;
     }
 
     // clip the current contents of `meshout` against the plane we obtained from the second operand
-    const std::vector<IfcVector3>& in = first_operand.mVerts;
-    std::vector<IfcVector3>& outvert = result.mVerts;
+    const std::vector<IfcVector3> &in = first_operand.mVerts;
+    std::vector<IfcVector3> &outvert = result.mVerts;
 
     std::vector<unsigned int>::const_iterator begin = first_operand.mVertcnt.begin(),
-        end = first_operand.mVertcnt.end(), iit;
+                                              end = first_operand.mVertcnt.end(), iit;
 
     outvert.reserve(in.size());
     result.mVertcnt.reserve(first_operand.mVertcnt.size());
 
     unsigned int vidx = 0;
-    for(iit = begin; iit != end; vidx += *iit++) {
+    for (iit = begin; iit != end; vidx += *iit++) {
 
         unsigned int newcount = 0;
-        bool isAtWhiteSide = (in[vidx] - p) * n > -1e-6;
-        for( unsigned int i = 0; i < *iit; ++i ) {
-            const IfcVector3& e0 = in[vidx + i], e1 = in[vidx + (i + 1) % *iit];
+        bool isAtWhiteSide = (in[vidx] - p) * n > -ai_epsilon;
+        for (unsigned int i = 0; i < *iit; ++i) {
+            const IfcVector3 &e0 = in[vidx + i], e1 = in[vidx + (i + 1) % *iit];
 
             // does the next segment intersect the plane?
             IfcVector3 isectpos;
-            if( IntersectSegmentPlane(p, n, e0, e1, isAtWhiteSide, isectpos) ) {
-                if( isAtWhiteSide ) {
+            if (IntersectSegmentPlane(p, n, e0, e1, isAtWhiteSide, isectpos)) {
+                if (isAtWhiteSide) {
                     // e0 is on the right side, so keep it
                     outvert.push_back(e0);
                     outvert.push_back(isectpos);
                     newcount += 2;
-                }
-                else {
+                } else {
                     // e0 is on the wrong side, so drop it and keep e1 instead
                     outvert.push_back(isectpos);
                     ++newcount;
                 }
                 isAtWhiteSide = !isAtWhiteSide;
-            }
-            else
-            {
-                if( isAtWhiteSide ) {
+            } else {
+                if (isAtWhiteSide) {
                     outvert.push_back(e0);
                     ++newcount;
                 }
@@ -206,35 +193,34 @@ void ProcessBooleanHalfSpaceDifference(const Schema_2x3::IfcHalfSpaceSolid* hs,
             continue;
         }
 
-        IfcVector3 vmin,vmax;
-        ArrayBounds(&*(outvert.end()-newcount),newcount,vmin,vmax);
+        IfcVector3 vmin, vmax;
+        ArrayBounds(&*(outvert.end() - newcount), newcount, vmin, vmax);
 
         // filter our IfcFloat points - those may happen if a point lies
         // directly on the intersection line. However, due to IfcFloat
         // precision a bitwise comparison is not feasible to detect
         // this case.
-        const IfcFloat epsilon = (vmax-vmin).SquareLength() / 1e6f;
+        const IfcFloat epsilon = (vmax - vmin).SquareLength() / 1e6f;
         FuzzyVectorCompare fz(epsilon);
 
-        std::vector<IfcVector3>::iterator e = std::unique( outvert.end()-newcount, outvert.end(), fz );
+        std::vector<IfcVector3>::iterator e = std::unique(outvert.end() - newcount, outvert.end(), fz);
 
         if (e != outvert.end()) {
-            newcount -= static_cast<unsigned int>(std::distance(e,outvert.end()));
-            outvert.erase(e,outvert.end());
+            newcount -= static_cast<unsigned int>(std::distance(e, outvert.end()));
+            outvert.erase(e, outvert.end());
         }
-        if (fz(*( outvert.end()-newcount),outvert.back())) {
+        if (fz(*(outvert.end() - newcount), outvert.back())) {
             outvert.pop_back();
             --newcount;
         }
-        if(newcount > 2) {
+        if (newcount > 2) {
             result.mVertcnt.push_back(newcount);
-        }
-        else while(newcount-->0) {
-            result.mVerts.pop_back();
-        }
-
+        } else
+            while (newcount-- > 0) {
+                result.mVerts.pop_back();
+            }
     }
-    IFCImporter::LogDebug("generating CSG geometry by plane clipping (IfcBooleanClippingResult)");
+    IFCImporter::LogVerboseDebug("generating CSG geometry by plane clipping (IfcBooleanClippingResult)");
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -244,37 +230,36 @@ void ProcessBooleanHalfSpaceDifference(const Schema_2x3::IfcHalfSpaceSolid* hs,
 // the line stays on that side. This should make corner cases more stable.
 // Two million assumptions! Boundary should have all z at 0.0, will be treated as closed, should not have
 // segments with length <1e-6, self-intersecting might break the corner case handling... just don't go there, ok?
-bool IntersectsBoundaryProfile(const IfcVector3& e0, const IfcVector3& e1, const std::vector<IfcVector3>& boundary,
-    const bool isStartAssumedInside, std::vector<std::pair<size_t, IfcVector3> >& intersect_results,
-    const bool halfOpen = false)
-{
+bool IntersectsBoundaryProfile(const IfcVector3 &e0, const IfcVector3 &e1, const std::vector<IfcVector3> &boundary,
+        const bool isStartAssumedInside, std::vector<std::pair<size_t, IfcVector3>> &intersect_results,
+        const bool halfOpen = false) {
     ai_assert(intersect_results.empty());
 
     // determine winding order - necessary to detect segments going "inwards" or "outwards" from a point directly on the border
     // positive sum of angles means clockwise order when looking down the -Z axis
     IfcFloat windingOrder = 0.0;
-    for( size_t i = 0, bcount = boundary.size(); i < bcount; ++i ) {
+    for (size_t i = 0, bcount = boundary.size(); i < bcount; ++i) {
         IfcVector3 b01 = boundary[(i + 1) % bcount] - boundary[i];
         IfcVector3 b12 = boundary[(i + 2) % bcount] - boundary[(i + 1) % bcount];
         IfcVector3 b1_side = IfcVector3(b01.y, -b01.x, 0.0); // rotated 90° clockwise in Z plane
         // Warning: rough estimate only. A concave poly with lots of small segments each featuring a small counter rotation
         // could fool the accumulation. Correct implementation would be sum( acos( b01 * b2) * sign( b12 * b1_side))
-        windingOrder += (b1_side.x*b12.x + b1_side.y*b12.y);
+        windingOrder += (b1_side.x * b12.x + b1_side.y * b12.y);
     }
     windingOrder = windingOrder > 0.0 ? 1.0 : -1.0;
 
     const IfcVector3 e = e1 - e0;
 
-    for( size_t i = 0, bcount = boundary.size(); i < bcount; ++i ) {
+    for (size_t i = 0, bcount = boundary.size(); i < bcount; ++i) {
         // boundary segment i: b0-b1
-        const IfcVector3& b0 = boundary[i];
-        const IfcVector3& b1 = boundary[(i + 1) % bcount];
+        const IfcVector3 &b0 = boundary[i];
+        const IfcVector3 &b1 = boundary[(i + 1) % bcount];
         IfcVector3 b = b1 - b0;
 
         // segment-segment intersection
         // solve b0 + b*s = e0 + e*t for (s,t)
         const IfcFloat det = (-b.x * e.y + e.x * b.y);
-        if( std::abs(det) < 1e-6 ) {
+        if (std::abs(det) < ai_epsilon) {
             // no solutions (parallel lines)
             continue;
         }
@@ -282,11 +267,11 @@ bool IntersectsBoundaryProfile(const IfcVector3& e0, const IfcVector3& e1, const
 
         const IfcFloat x = b0.x - e0.x;
         const IfcFloat y = b0.y - e0.y;
-        const IfcFloat s = (x*e.y - e.x*y) / det; // scale along boundary edge
-        const IfcFloat t = (x*b.y - b.x*y) / det; // scale along given segment
-        const IfcVector3 p = e0 + e*t;
+        const IfcFloat s = (x * e.y - e.x * y) / det; // scale along boundary edge
+        const IfcFloat t = (x * b.y - b.x * y) / det; // scale along given segment
+        const IfcVector3 p = e0 + e * t;
 #ifdef ASSIMP_BUILD_DEBUG
-        const IfcVector3 check = b0 + b*s - p;
+        const IfcVector3 check = b0 + b * s - p;
         ai_assert((IfcVector2(check.x, check.y)).SquareLength() < 1e-5);
 #endif
 
@@ -296,35 +281,33 @@ bool IntersectsBoundaryProfile(const IfcVector3& e0, const IfcVector3& e1, const
         {
             // calculate closest point to each end on the segment, clamp that point to the segment's length, then check
             // distance to that point. This approach is like testing if e0 is inside a capped cylinder.
-            IfcFloat et0 = (b.x*(e0.x - b0.x) + b.y*(e0.y - b0.y)) * b_sqlen_inv;
+            IfcFloat et0 = (b.x * (e0.x - b0.x) + b.y * (e0.y - b0.y)) * b_sqlen_inv;
             IfcVector3 closestPosToE0OnBoundary = b0 + std::max(IfcFloat(0.0), std::min(IfcFloat(1.0), et0)) * b;
             startsAtSegment = (closestPosToE0OnBoundary - IfcVector3(e0.x, e0.y, 0.0)).SquareLength() < 1e-12;
-            IfcFloat et1 = (b.x*(e1.x - b0.x) + b.y*(e1.y - b0.y)) * b_sqlen_inv;
+            IfcFloat et1 = (b.x * (e1.x - b0.x) + b.y * (e1.y - b0.y)) * b_sqlen_inv;
             IfcVector3 closestPosToE1OnBoundary = b0 + std::max(IfcFloat(0.0), std::min(IfcFloat(1.0), et1)) * b;
             endsAtSegment = (closestPosToE1OnBoundary - IfcVector3(e1.x, e1.y, 0.0)).SquareLength() < 1e-12;
         }
 
         // Line segment ends at boundary -> ignore any hit, it will be handled by possibly following segments
-        if( endsAtSegment && !halfOpen )
+        if (endsAtSegment && !halfOpen)
             continue;
 
         // Line segment starts at boundary -> generate a hit only if following that line would change the INSIDE/OUTSIDE
         // state. This should catch the case where a connected set of segments has a point directly on the boundary,
         // one segment not hitting it because it ends there and the next segment not hitting it because it starts there
         // Should NOT generate a hit if the segment only touches the boundary but turns around and stays inside.
-        if( startsAtSegment )
-        {
+        if (startsAtSegment) {
             IfcVector3 inside_dir = IfcVector3(b.y, -b.x, 0.0) * windingOrder;
             bool isGoingInside = (inside_dir * e) > 0.0;
-            if( isGoingInside == isStartAssumedInside )
+            if (isGoingInside == isStartAssumedInside)
                 continue;
 
             // only insert the point into the list if it is sufficiently far away from the previous intersection point.
             // This way, we avoid duplicate detection if the intersection is directly on the vertex between two segments.
-            if( !intersect_results.empty() && intersect_results.back().first == i - 1 )
-            {
+            if (!intersect_results.empty() && intersect_results.back().first == i - 1) {
                 const IfcVector3 diff = intersect_results.back().second - e0;
-                if( IfcVector2(diff.x, diff.y).SquareLength() < 1e-10 )
+                if (IfcVector2(diff.x, diff.y).SquareLength() < 1e-10)
                     continue;
             }
             intersect_results.push_back(std::make_pair(i, e0));
@@ -333,14 +316,12 @@ bool IntersectsBoundaryProfile(const IfcVector3& e0, const IfcVector3& e1, const
 
         // for a valid intersection, s and t should be in range [0,1]. Including a bit of epsilon on s, potential double
         // hits on two consecutive boundary segments are filtered
-        if( s >= -1e-6 * b_sqlen_inv && s <= 1.0 + 1e-6*b_sqlen_inv && t >= 0.0 && (t <= 1.0 || halfOpen) )
-        {
+        if (s >= -ai_epsilon * b_sqlen_inv && s <= 1.0 + ai_epsilon * b_sqlen_inv && t >= 0.0 && (t <= 1.0 || halfOpen)) {
             // only insert the point into the list if it is sufficiently far away from the previous intersection point.
             // This way, we avoid duplicate detection if the intersection is directly on the vertex between two segments.
-            if( !intersect_results.empty() && intersect_results.back().first == i - 1 )
-            {
+            if (!intersect_results.empty() && intersect_results.back().first == i - 1) {
                 const IfcVector3 diff = intersect_results.back().second - p;
-                if( IfcVector2(diff.x, diff.y).SquareLength() < 1e-10 )
+                if (IfcVector2(diff.x, diff.y).SquareLength() < 1e-10)
                     continue;
             }
             intersect_results.push_back(std::make_pair(i, p));
@@ -350,11 +331,9 @@ bool IntersectsBoundaryProfile(const IfcVector3& e0, const IfcVector3& e1, const
     return !intersect_results.empty();
 }
 
-
 // ------------------------------------------------------------------------------------------------
 // note: this functions works on 3D vectors, but performs its intersection checks solely in xy.
-bool PointInPoly(const IfcVector3& p, const std::vector<IfcVector3>& boundary)
-{
+bool PointInPoly(const IfcVector3 &p, const std::vector<IfcVector3> &boundary) {
     // even-odd algorithm: take a random vector that extends from p to infinite
     // and counts how many times it intersects edges of the boundary.
     // because checking for segment intersections is prone to numeric inaccuracies
@@ -365,7 +344,7 @@ bool PointInPoly(const IfcVector3& p, const std::vector<IfcVector3>& boundary)
     // the border of the polygon. If any of our attempts produces this result,
     // we return false immediately.
 
-    std::vector<std::pair<size_t, IfcVector3> > intersected_boundary;
+    std::vector<std::pair<size_t, IfcVector3>> intersected_boundary;
     size_t votes = 0;
 
     IntersectsBoundaryProfile(p, p + IfcVector3(1.0, 0, 0), boundary, true, intersected_boundary, true);
@@ -382,28 +361,26 @@ bool PointInPoly(const IfcVector3& p, const std::vector<IfcVector3>& boundary)
     return votes > 1;
 }
 
-
 // ------------------------------------------------------------------------------------------------
-void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPolygonalBoundedHalfSpace* hs, TempMesh& result,
-                                                       const TempMesh& first_operand,
-                                                       ConversionData& conv)
-{
-    ai_assert(hs != NULL);
+void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPolygonalBoundedHalfSpace *hs, TempMesh &result,
+        const TempMesh &first_operand,
+        ConversionData &conv) {
+    ai_assert(hs != nullptr);
 
-    const Schema_2x3::IfcPlane* const plane = hs->BaseSurface->ToPtr<Schema_2x3::IfcPlane>();
-    if(!plane) {
+    const Schema_2x3::IfcPlane *const plane = hs->BaseSurface->ToPtr<Schema_2x3::IfcPlane>();
+    if (!plane) {
         IFCImporter::LogError("expected IfcPlane as base surface for the IfcHalfSpaceSolid");
         return;
     }
 
     // extract plane base position vector and normal vector
-    IfcVector3 p,n(0.f,0.f,1.f);
+    IfcVector3 p, n(0.f, 0.f, 1.f);
     if (plane->Position->Axis) {
-        ConvertDirection(n,plane->Position->Axis.Get());
+        ConvertDirection(n, plane->Position->Axis.Get());
     }
-    ConvertCartesianPoint(p,plane->Position->Location);
+    ConvertCartesianPoint(p, plane->Position->Location);
 
-    if(!IsTrue(hs->AgreementFlag)) {
+    if (!IsTrue(hs->AgreementFlag)) {
         n *= -1.f;
     }
 
@@ -411,7 +388,7 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPoly
 
     // obtain the polygonal bounding volume
     std::shared_ptr<TempMesh> profile = std::shared_ptr<TempMesh>(new TempMesh());
-    if(!ProcessCurve(hs->PolygonalBoundary, *profile.get(), conv)) {
+    if (!ProcessCurve(hs->PolygonalBoundary, *profile.get(), conv)) {
         IFCImporter::LogError("expected valid polyline for boundary of boolean halfspace");
         return;
     }
@@ -420,7 +397,7 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPoly
     IfcVector3 profileNormal = TempMesh::ComputePolygonNormal(profile->mVerts.data(), profile->mVerts.size());
 
     IfcMatrix4 proj_inv;
-    ConvertAxisPlacement(proj_inv,hs->Position);
+    ConvertAxisPlacement(proj_inv, hs->Position);
 
     // and map everything into a plane coordinate space so all intersection
     // tests can be done in 2D space.
@@ -428,9 +405,9 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPoly
     proj.Inverse();
 
     // clip the current contents of `meshout` against the plane we obtained from the second operand
-    const std::vector<IfcVector3>& in = first_operand.mVerts;
-    std::vector<IfcVector3>& outvert = result.mVerts;
-    std::vector<unsigned int>& outvertcnt = result.mVertcnt;
+    const std::vector<IfcVector3> &in = first_operand.mVerts;
+    std::vector<IfcVector3> &outvert = result.mVerts;
+    std::vector<unsigned int> &outvertcnt = result.mVertcnt;
 
     outvert.reserve(in.size());
     outvertcnt.reserve(first_operand.mVertcnt.size());
@@ -439,52 +416,46 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPoly
     std::vector<unsigned int>::const_iterator begin = first_operand.mVertcnt.begin();
     std::vector<unsigned int>::const_iterator end = first_operand.mVertcnt.end();
     std::vector<unsigned int>::const_iterator iit;
-    for( iit = begin; iit != end; vidx += *iit++ )
-    {
+    for (iit = begin; iit != end; vidx += *iit++) {
         // Our new approach: we cut the poly along the plane, then we intersect the part on the black side of the plane
         // against the bounding polygon. All the white parts, and the black part outside the boundary polygon, are kept.
         std::vector<IfcVector3> whiteside, blackside;
 
         {
-            const IfcVector3* srcVertices = &in[vidx];
+            const IfcVector3 *srcVertices = &in[vidx];
             const size_t srcVtxCount = *iit;
-            if( srcVtxCount == 0 )
+            if (srcVtxCount == 0)
                 continue;
 
             IfcVector3 polyNormal = TempMesh::ComputePolygonNormal(srcVertices, srcVtxCount, true);
 
             // if the poly is parallel to the plane, put it completely on the black or white side
-            if( std::abs(polyNormal * n) > 0.9999 )
-            {
-                bool isOnWhiteSide = (srcVertices[0] - p) * n > -1e-6;
-                std::vector<IfcVector3>& targetSide = isOnWhiteSide ? whiteside : blackside;
+            if (std::abs(polyNormal * n) > 0.9999) {
+                bool isOnWhiteSide = (srcVertices[0] - p) * n > -ai_epsilon;
+                std::vector<IfcVector3> &targetSide = isOnWhiteSide ? whiteside : blackside;
                 targetSide.insert(targetSide.end(), srcVertices, srcVertices + srcVtxCount);
-            }
-            else
-            {
+            } else {
                 // otherwise start building one polygon for each side. Whenever the current line segment intersects the plane
                 // we put a point there as an end of the current segment. Then we switch to the other side, put a point there, too,
                 // as a beginning of the current segment, and simply continue accumulating vertices.
-                bool isCurrentlyOnWhiteSide = ((srcVertices[0]) - p) * n > -1e-6;
-                for( size_t a = 0; a < srcVtxCount; ++a )
-                {
+                bool isCurrentlyOnWhiteSide = ((srcVertices[0]) - p) * n > -ai_epsilon;
+                for (size_t a = 0; a < srcVtxCount; ++a) {
                     IfcVector3 e0 = srcVertices[a];
                     IfcVector3 e1 = srcVertices[(a + 1) % srcVtxCount];
                     IfcVector3 ei;
 
                     // put starting point to the current mesh
-                    std::vector<IfcVector3>& trgt = isCurrentlyOnWhiteSide ? whiteside : blackside;
+                    std::vector<IfcVector3> &trgt = isCurrentlyOnWhiteSide ? whiteside : blackside;
                     trgt.push_back(srcVertices[a]);
 
                     // if there's an intersection, put an end vertex there, switch to the other side's mesh,
                     // and add a starting vertex there, too
                     bool isPlaneHit = IntersectSegmentPlane(p, n, e0, e1, isCurrentlyOnWhiteSide, ei);
-                    if( isPlaneHit )
-                    {
-                        if( trgt.empty() || (trgt.back() - ei).SquareLength() > 1e-12 )
+                    if (isPlaneHit) {
+                        if (trgt.empty() || (trgt.back() - ei).SquareLength() > 1e-12)
                             trgt.push_back(ei);
                         isCurrentlyOnWhiteSide = !isCurrentlyOnWhiteSide;
-                        std::vector<IfcVector3>& newtrgt = isCurrentlyOnWhiteSide ? whiteside : blackside;
+                        std::vector<IfcVector3> &newtrgt = isCurrentlyOnWhiteSide ? whiteside : blackside;
                         newtrgt.push_back(ei);
                     }
                 }
@@ -504,33 +475,27 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPoly
         // an intersection, then we switch back to the poly and run on on this one again, and so on until we got a closed
         // loop. Then we continue with the path we left to catch potential additional polys on the other side of the
         // boundary as described in a)
-        if( !blackside.empty() )
-        {
+        if (!blackside.empty()) {
             // poly edge index, intersection point, edge index in boundary poly
-            std::vector<std::tuple<size_t, IfcVector3, size_t> > intersections;
+            std::vector<std::tuple<size_t, IfcVector3, size_t>> intersections;
             bool startedInside = PointInPoly(proj * blackside.front(), profile->mVerts);
             bool isCurrentlyInside = startedInside;
 
-            std::vector<std::pair<size_t, IfcVector3> > intersected_boundary;
+            std::vector<std::pair<size_t, IfcVector3>> intersected_boundary;
 
-            for( size_t a = 0; a < blackside.size(); ++a )
-            {
+            for (size_t a = 0; a < blackside.size(); ++a) {
                 const IfcVector3 e0 = proj * blackside[a];
                 const IfcVector3 e1 = proj * blackside[(a + 1) % blackside.size()];
 
                 intersected_boundary.clear();
                 IntersectsBoundaryProfile(e0, e1, profile->mVerts, isCurrentlyInside, intersected_boundary);
                 // sort the hits by distance from e0 to get the correct in/out/in sequence. Manually :-( I miss you, C++11.
-                if( intersected_boundary.size() > 1 )
-                {
+                if (intersected_boundary.size() > 1) {
                     bool keepSorting = true;
-                    while( keepSorting )
-                    {
+                    while (keepSorting) {
                         keepSorting = false;
-                        for( size_t b = 0; b < intersected_boundary.size() - 1; ++b )
-                        {
-                            if( (intersected_boundary[b + 1].second - e0).SquareLength() < (intersected_boundary[b].second - e0).SquareLength() )
-                            {
+                        for (size_t b = 0; b < intersected_boundary.size() - 1; ++b) {
+                            if ((intersected_boundary[b + 1].second - e0).SquareLength() < (intersected_boundary[b].second - e0).SquareLength()) {
                                 keepSorting = true;
                                 std::swap(intersected_boundary[b + 1], intersected_boundary[b]);
                             }
@@ -538,60 +503,52 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPoly
                     }
                 }
                 // now add them to the list of intersections
-                for( size_t b = 0; b < intersected_boundary.size(); ++b )
+                for (size_t b = 0; b < intersected_boundary.size(); ++b)
                     intersections.push_back(std::make_tuple(a, proj_inv * intersected_boundary[b].second, intersected_boundary[b].first));
 
                 // and calculate our new inside/outside state
-                if( intersected_boundary.size() & 1 )
+                if (intersected_boundary.size() & 1)
                     isCurrentlyInside = !isCurrentlyInside;
             }
 
             // we got a list of in-out-combinations of intersections. That should be an even number of intersections, or
-            // we're fucked.
-            if( (intersections.size() & 1) != 0 )
-            {
+            // we are facing a non-recoverable error.
+            if ((intersections.size() & 1) != 0) {
                 IFCImporter::LogWarn("Odd number of intersections, can't work with that. Omitting half space boundary check.");
                 continue;
             }
 
-            if( intersections.size() > 1 )
-            {
+            if (intersections.size() > 1) {
                 // If we started outside, the first intersection is a out->in intersection. Cycle them so that it
                 // starts with an intersection leaving the boundary
-                if( !startedInside )
-                for( size_t b = 0; b < intersections.size() - 1; ++b )
-                    std::swap(intersections[b], intersections[(b + intersections.size() - 1) % intersections.size()]);
+                if (!startedInside)
+                    for (size_t b = 0; b < intersections.size() - 1; ++b)
+                        std::swap(intersections[b], intersections[(b + intersections.size() - 1) % intersections.size()]);
 
                 // Filter pairs of out->in->out that lie too close to each other.
-                for( size_t a = 0; intersections.size() > 0 && a < intersections.size() - 1; /**/ )
-                {
-                    if( (std::get<1>(intersections[a]) - std::get<1>(intersections[(a + 1) % intersections.size()])).SquareLength() < 1e-10 )
+                for (size_t a = 0; intersections.size() > 0 && a < intersections.size() - 1; /**/) {
+                    if ((std::get<1>(intersections[a]) - std::get<1>(intersections[(a + 1) % intersections.size()])).SquareLength() < 1e-10)
                         intersections.erase(intersections.begin() + a, intersections.begin() + a + 2);
                     else
                         a++;
                 }
-                if( intersections.size() > 1 && (std::get<1>(intersections.back()) - std::get<1>(intersections.front())).SquareLength() < 1e-10 )
-                {
-                    intersections.pop_back(); intersections.erase(intersections.begin());
+                if (intersections.size() > 1 && (std::get<1>(intersections.back()) - std::get<1>(intersections.front())).SquareLength() < 1e-10) {
+                    intersections.pop_back();
+                    intersections.erase(intersections.begin());
                 }
             }
 
-
             // no intersections at all: either completely inside the boundary, so everything gets discarded, or completely outside.
             // in the latter case we're implementional lost. I'm simply going to ignore this, so a large poly will not get any
             // holes if the boundary is smaller and does not touch it anywhere.
-            if( intersections.empty() )
-            {
+            if (intersections.empty()) {
                 // starting point was outside -> everything is outside the boundary -> nothing is clipped -> add black side
                 // to result mesh unchanged
-                if( !startedInside )
-                {
+                if (!startedInside) {
                     outvertcnt.push_back(static_cast<unsigned int>(blackside.size()));
                     outvert.insert(outvert.end(), blackside.begin(), blackside.end());
                     continue;
-                }
-                else
-                {
+                } else {
                     // starting point was inside the boundary -> everything is inside the boundary -> nothing is spared from the
                     // clipping -> nothing left to add to the result mesh
                     continue;
@@ -608,13 +565,11 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPoly
             // From there we walk along the boundary until we hit another intersection leaving the boundary,
             // walk along the poly to the next IS and so on until we're back at the starting point.
             // We remove every intersection we "used up", so any remaining intersection is the start of a new loop.
-            while( !intersections.empty() )
-            {
+            while (!intersections.empty()) {
                 std::vector<IfcVector3> resultpoly;
                 size_t currentIntersecIdx = 0;
 
-                while( true )
-                {
+                while (true) {
                     ai_assert(intersections.size() > currentIntersecIdx + 1);
                     std::tuple<size_t, IfcVector3, size_t> currintsec = intersections[currentIntersecIdx + 0];
                     std::tuple<size_t, IfcVector3, size_t> nextintsec = intersections[currentIntersecIdx + 1];
@@ -623,9 +578,8 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPoly
                     // we start with an in->out intersection
                     resultpoly.push_back(std::get<1>(currintsec));
                     // climb along the polygon to the next intersection, which should be an out->in
-                    size_t numPolyPoints = (std::get<0>(currintsec) > std::get<0>(nextintsec) ? blackside.size() : 0)
-                        + std::get<0>(nextintsec) - std::get<0>(currintsec);
-                    for( size_t a = 1; a <= numPolyPoints; ++a )
+                    size_t numPolyPoints = (std::get<0>(currintsec) > std::get<0>(nextintsec) ? blackside.size() : 0) + std::get<0>(nextintsec) - std::get<0>(currintsec);
+                    for (size_t a = 1; a <= numPolyPoints; ++a)
                         resultpoly.push_back(blackside[(std::get<0>(currintsec) + a) % blackside.size()]);
                     // put the out->in intersection
                     resultpoly.push_back(std::get<1>(nextintsec));
@@ -634,8 +588,7 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPoly
                     IfcVector3 startingPoint = proj * std::get<1>(nextintsec);
                     size_t currentBoundaryEdgeIdx = (std::get<2>(nextintsec) + (marchBackwardsOnBoundary ? 1 : 0)) % profile->mVerts.size();
                     size_t nextIntsecIdx = SIZE_MAX;
-                    while( nextIntsecIdx == SIZE_MAX )
-                    {
+                    while (nextIntsecIdx == SIZE_MAX) {
                         IfcFloat t = 1e10;
 
                         size_t nextBoundaryEdgeIdx = marchBackwardsOnBoundary ? (currentBoundaryEdgeIdx + profile->mVerts.size() - 1) : currentBoundaryEdgeIdx + 1;
@@ -644,10 +597,9 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPoly
                         IfcVector3 currBoundaryPoint = profile->mVerts[currentBoundaryEdgeIdx];
                         IfcVector3 nextBoundaryPoint = profile->mVerts[nextBoundaryEdgeIdx];
                         // project the two onto the polygon
-                        if( std::abs(polyNormal.z) > 1e-5 )
-                        {
-                            currBoundaryPoint.z = startingPoint.z + (currBoundaryPoint.x - startingPoint.x) * polyNormal.x/polyNormal.z + (currBoundaryPoint.y - startingPoint.y) * polyNormal.y/polyNormal.z;
-                            nextBoundaryPoint.z = startingPoint.z + (nextBoundaryPoint.x - startingPoint.x) * polyNormal.x/polyNormal.z + (nextBoundaryPoint.y - startingPoint.y) * polyNormal.y/polyNormal.z;
+                        if (std::abs(polyNormal.z) > 1e-5) {
+                            currBoundaryPoint.z = startingPoint.z + (currBoundaryPoint.x - startingPoint.x) * polyNormal.x / polyNormal.z + (currBoundaryPoint.y - startingPoint.y) * polyNormal.y / polyNormal.z;
+                            nextBoundaryPoint.z = startingPoint.z + (nextBoundaryPoint.x - startingPoint.x) * polyNormal.x / polyNormal.z + (nextBoundaryPoint.y - startingPoint.y) * polyNormal.y / polyNormal.z;
                         }
 
                         // build a direction that goes along the boundary border but lies in the poly plane
@@ -655,52 +607,45 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPoly
                         IfcVector3 dirAtPolyPlane = (boundaryPlaneNormal ^ polyNormal).Normalize() * (marchBackwardsOnBoundary ? -1.0 : 1.0);
                         // if we can project the direction to the plane, we can calculate a maximum marching distance along that dir
                         // until we finish that boundary segment and continue on the next
-                        if( std::abs(polyNormal.z) > 1e-5 )
-                        {
+                        if (std::abs(polyNormal.z) > 1e-5) {
                             t = std::min(t, (nextBoundaryPoint - startingPoint).Length());
                         }
 
                         // check if the direction hits the loop start - if yes, we got a poly to output
                         IfcVector3 dirToThatPoint = proj * resultpoly.front() - startingPoint;
                         IfcFloat tpt = dirToThatPoint * dirAtPolyPlane;
-                        if( tpt > -1e-6 && tpt <= t && (dirToThatPoint - tpt * dirAtPolyPlane).SquareLength() < 1e-10 )
-                        {
+                        if (tpt > -1e-6 && tpt <= t && (dirToThatPoint - tpt * dirAtPolyPlane).SquareLength() < 1e-10) {
                             nextIntsecIdx = intersections.size(); // dirty hack to end marching along the boundary and signal the end of the loop
                             t = tpt;
                         }
 
                         // also check if the direction hits any in->out intersections earlier. If we hit one, we can switch back
                         // to marching along the poly border from that intersection point
-                        for( size_t a = 0; a < intersections.size(); a += 2 )
-                        {
+                        for (size_t a = 0; a < intersections.size(); a += 2) {
                             dirToThatPoint = proj * std::get<1>(intersections[a]) - startingPoint;
                             tpt = dirToThatPoint * dirAtPolyPlane;
-                            if( tpt > -1e-6 && tpt <= t && (dirToThatPoint - tpt * dirAtPolyPlane).SquareLength() < 1e-10 )
-                            {
+                            if (tpt > -1e-6 && tpt <= t && (dirToThatPoint - tpt * dirAtPolyPlane).SquareLength() < 1e-10) {
                                 nextIntsecIdx = a; // switch back to poly and march on from this in->out intersection
                                 t = tpt;
                             }
                         }
 
                         // if we keep marching on the boundary, put the segment end point to the result poly and well... keep marching
-                        if( nextIntsecIdx == SIZE_MAX )
-                        {
+                        if (nextIntsecIdx == SIZE_MAX) {
                             resultpoly.push_back(proj_inv * nextBoundaryPoint);
                             currentBoundaryEdgeIdx = nextBoundaryEdgeIdx;
                             startingPoint = nextBoundaryPoint;
                         }
 
                         // quick endless loop check
-                        if( resultpoly.size() > blackside.size() + profile->mVerts.size() )
-                        {
+                        if (resultpoly.size() > blackside.size() + profile->mVerts.size()) {
                             IFCImporter::LogError("Encountered endless loop while clipping polygon against poly-bounded half space.");
                             break;
                         }
                     }
 
                     // we're back on the poly - if this is the intersection we started from, we got a closed loop.
-                    if( nextIntsecIdx >= intersections.size() )
-                    {
+                    if (nextIntsecIdx >= intersections.size()) {
                         break;
                     }
 
@@ -712,15 +657,14 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPoly
             }
         }
     }
-    IFCImporter::LogDebug("generating CSG geometry by plane clipping with polygonal bounding (IfcBooleanClippingResult)");
+    IFCImporter::LogVerboseDebug("generating CSG geometry by plane clipping with polygonal bounding (IfcBooleanClippingResult)");
 }
 
 // ------------------------------------------------------------------------------------------------
-void ProcessBooleanExtrudedAreaSolidDifference(const Schema_2x3::IfcExtrudedAreaSolid* as, TempMesh& result,
-                                               const TempMesh& first_operand,
-                                               ConversionData& conv)
-{
-    ai_assert(as != NULL);
+void ProcessBooleanExtrudedAreaSolidDifference(const Schema_2x3::IfcExtrudedAreaSolid *as, TempMesh &result,
+        const TempMesh &first_operand,
+        ConversionData &conv) {
+    ai_assert(as != nullptr);
 
     // This case is handled by reduction to an instance of the quadrify() algorithm.
     // Obviously, this won't work for arbitrarily complex cases. In fact, the first
@@ -728,16 +672,16 @@ void ProcessBooleanExtrudedAreaSolidDifference(const Schema_2x3::IfcExtrudedArea
     // buildings.
 
     std::shared_ptr<TempMesh> meshtmp = std::shared_ptr<TempMesh>(new TempMesh());
-    ProcessExtrudedAreaSolid(*as,*meshtmp,conv,false);
+    ProcessExtrudedAreaSolid(*as, *meshtmp, conv, false);
 
-    std::vector<TempOpening> openings(1, TempOpening(as,IfcVector3(0,0,0),meshtmp,std::shared_ptr<TempMesh>()));
+    std::vector<TempOpening> openings(1, TempOpening(as, IfcVector3(0, 0, 0), meshtmp, std::shared_ptr<TempMesh>()));
 
     result = first_operand;
 
     TempMesh temp;
 
     std::vector<IfcVector3>::const_iterator vit = first_operand.mVerts.begin();
-    for(unsigned int pcount : first_operand.mVertcnt) {
+    for (unsigned int pcount : first_operand.mVertcnt) {
         temp.Clear();
 
         temp.mVerts.insert(temp.mVerts.end(), vit, vit + pcount);
@@ -749,29 +693,28 @@ void ProcessBooleanExtrudedAreaSolidDifference(const Schema_2x3::IfcExtrudedArea
 
         // ComputePolygonNormal returns the Newell normal, so the
         // length of the normal is the area of the polygon.
-        const IfcVector3& normal = temp.ComputeLastPolygonNormal(false);
+        const IfcVector3 &normal = temp.ComputeLastPolygonNormal(false);
         if (normal.SquareLength() < static_cast<IfcFloat>(1e-5)) {
             IFCImporter::LogWarn("skipping degenerate polygon (ProcessBooleanExtrudedAreaSolidDifference)");
             continue;
         }
 
-        GenerateOpenings(openings, std::vector<IfcVector3>(1,IfcVector3(1,0,0)), temp, false, true);
+        GenerateOpenings(openings, temp, false, true);
         result.Append(temp);
 
         vit += pcount;
     }
 
-    IFCImporter::LogDebug("generating CSG geometry by geometric difference to a solid (IfcExtrudedAreaSolid)");
+    IFCImporter::LogVerboseDebug("generating CSG geometry by geometric difference to a solid (IfcExtrudedAreaSolid)");
 }
 
 // ------------------------------------------------------------------------------------------------
-void ProcessBoolean(const Schema_2x3::IfcBooleanResult& boolean, TempMesh& result, ConversionData& conv)
-{
+void ProcessBoolean(const Schema_2x3::IfcBooleanResult &boolean, TempMesh &result, ConversionData &conv) {
     // supported CSG operations:
     //   DIFFERENCE
-    if(const Schema_2x3::IfcBooleanResult* const clip = boolean.ToPtr<Schema_2x3::IfcBooleanResult>()) {
-        if(clip->Operator != "DIFFERENCE") {
-            IFCImporter::LogWarn("encountered unsupported boolean operator: " + (std::string)clip->Operator);
+    if (const Schema_2x3::IfcBooleanResult *const clip = boolean.ToPtr<Schema_2x3::IfcBooleanResult>()) {
+        if (clip->Operator != "DIFFERENCE") {
+            IFCImporter::LogWarn("encountered unsupported boolean operator: ", (std::string)clip->Operator);
             return;
         }
 
@@ -783,47 +726,40 @@ void ProcessBoolean(const Schema_2x3::IfcBooleanResult& boolean, TempMesh& resul
         //  IfcHalfSpaceSolid -- easy, clip against plane
         //  IfcExtrudedAreaSolid -- reduce to an instance of the quadrify() algorithm
 
-
-        const Schema_2x3::IfcHalfSpaceSolid* const hs = clip->SecondOperand->ResolveSelectPtr<Schema_2x3::IfcHalfSpaceSolid>(conv.db);
-        const Schema_2x3::IfcExtrudedAreaSolid* const as = clip->SecondOperand->ResolveSelectPtr<Schema_2x3::IfcExtrudedAreaSolid>(conv.db);
-        if(!hs && !as) {
+        const Schema_2x3::IfcHalfSpaceSolid *const hs = clip->SecondOperand->ResolveSelectPtr<Schema_2x3::IfcHalfSpaceSolid>(conv.db);
+        const Schema_2x3::IfcExtrudedAreaSolid *const as = clip->SecondOperand->ResolveSelectPtr<Schema_2x3::IfcExtrudedAreaSolid>(conv.db);
+        if (!hs && !as) {
             IFCImporter::LogError("expected IfcHalfSpaceSolid or IfcExtrudedAreaSolid as second clipping operand");
             return;
         }
 
         TempMesh first_operand;
-        if(const Schema_2x3::IfcBooleanResult* const op0 = clip->FirstOperand->ResolveSelectPtr<Schema_2x3::IfcBooleanResult>(conv.db)) {
-            ProcessBoolean(*op0,first_operand,conv);
-        }
-        else if (const Schema_2x3::IfcSweptAreaSolid* const swept = clip->FirstOperand->ResolveSelectPtr<Schema_2x3::IfcSweptAreaSolid>(conv.db)) {
-            ProcessSweptAreaSolid(*swept,first_operand,conv);
-        }
-        else {
+        if (const Schema_2x3::IfcBooleanResult *const op0 = clip->FirstOperand->ResolveSelectPtr<Schema_2x3::IfcBooleanResult>(conv.db)) {
+            ProcessBoolean(*op0, first_operand, conv);
+        } else if (const Schema_2x3::IfcSweptAreaSolid *const swept = clip->FirstOperand->ResolveSelectPtr<Schema_2x3::IfcSweptAreaSolid>(conv.db)) {
+            ProcessSweptAreaSolid(*swept, first_operand, conv);
+        } else {
             IFCImporter::LogError("expected IfcSweptAreaSolid or IfcBooleanResult as first clipping operand");
             return;
         }
 
-        if(hs) {
+        if (hs) {
 
-            const Schema_2x3::IfcPolygonalBoundedHalfSpace* const hs_bounded = clip->SecondOperand->ResolveSelectPtr<Schema_2x3::IfcPolygonalBoundedHalfSpace>(conv.db);
+            const Schema_2x3::IfcPolygonalBoundedHalfSpace *const hs_bounded = clip->SecondOperand->ResolveSelectPtr<Schema_2x3::IfcPolygonalBoundedHalfSpace>(conv.db);
             if (hs_bounded) {
                 ProcessPolygonalBoundedBooleanHalfSpaceDifference(hs_bounded, result, first_operand, conv);
-            }
-            else {
+            } else {
                 ProcessBooleanHalfSpaceDifference(hs, result, first_operand, conv);
             }
-        }
-        else {
+        } else {
             ProcessBooleanExtrudedAreaSolidDifference(as, result, first_operand, conv);
         }
-    }
-    else {
-        IFCImporter::LogWarn("skipping unknown IfcBooleanResult entity, type is " + boolean.GetClassName());
+    } else {
+        IFCImporter::LogWarn("skipping unknown IfcBooleanResult entity, type is ", boolean.GetClassName());
     }
 }
 
-} // ! IFC
-} // ! Assimp
+} // namespace IFC
+} // namespace Assimp
 
 #endif
-
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCCurve.cpp b/Engine/lib/assimp/code/AssetLib/IFC/IFCCurve.cpp
similarity index 96%
rename from Engine/lib/assimp/code/Importer/IFC/IFCCurve.cpp
rename to Engine/lib/assimp/code/AssetLib/IFC/IFCCurve.cpp
index a817b4f9f..19732ef25 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCCurve.cpp
+++ b/Engine/lib/assimp/code/AssetLib/IFC/IFCCurve.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -223,7 +223,7 @@ public:
             }
 
             if ( (std::string)curveSegment.Transition != "CONTINUOUS" ) {
-                IFCImporter::LogDebug("ignoring transition code on composite curve segment, only continuous transitions are supported");
+                IFCImporter::LogVerboseDebug("ignoring transition code on composite curve segment, only continuous transitions are supported");
             }
 
             curves.push_back( CurveEntry(bc,IsTrue(curveSegment.SameSense)) );
@@ -285,11 +285,11 @@ public:
         out.mVerts.reserve(out.mVerts.size() + cnt);
 
         for(const CurveEntry& entry : curves) {
-            const size_t cnt = out.mVerts.size();
+            const size_t curCnt = out.mVerts.size();
             entry.first->SampleDiscrete(out);
 
-            if (!entry.second && cnt != out.mVerts.size()) {
-                std::reverse(out.mVerts.begin()+cnt,out.mVerts.end());
+            if (!entry.second && curCnt != out.mVerts.size()) {
+                std::reverse(out.mVerts.begin() + curCnt, out.mVerts.end());
             }
         }
     }
@@ -323,14 +323,14 @@ public:
         // oh well.
         bool have_param = false, have_point = false;
         IfcVector3 point;
-        for(const Entry sel :entity.Trim1) {
+        for(const Entry& sel :entity.Trim1) {
             if (const ::Assimp::STEP::EXPRESS::REAL* const r = sel->ToPtr<::Assimp::STEP::EXPRESS::REAL>()) {
                 range.first = *r;
                 have_param = true;
                 break;
             }
-            else if (const Schema_2x3::IfcCartesianPoint* const r = sel->ResolveSelectPtr<Schema_2x3::IfcCartesianPoint>(conv.db)) {
-                ConvertCartesianPoint(point,*r);
+            else if (const Schema_2x3::IfcCartesianPoint* const curR = sel->ResolveSelectPtr<Schema_2x3::IfcCartesianPoint>(conv.db)) {
+                ConvertCartesianPoint(point, *curR);
                 have_point = true;
             }
         }
@@ -340,14 +340,14 @@ public:
             }
         }
         have_param = false, have_point = false;
-        for(const Entry sel :entity.Trim2) {
+        for(const Entry& sel :entity.Trim2) {
             if (const ::Assimp::STEP::EXPRESS::REAL* const r = sel->ToPtr<::Assimp::STEP::EXPRESS::REAL>()) {
                 range.second = *r;
                 have_param = true;
                 break;
             }
-            else if (const Schema_2x3::IfcCartesianPoint* const r = sel->ResolveSelectPtr<Schema_2x3::IfcCartesianPoint>(conv.db)) {
-                ConvertCartesianPoint(point,*r);
+            else if (const Schema_2x3::IfcCartesianPoint* const curR = sel->ResolveSelectPtr<Schema_2x3::IfcCartesianPoint>(conv.db)) {
+                ConvertCartesianPoint(point, *curR);
                 have_point = true;
             }
         }
@@ -389,7 +389,8 @@ public:
 
     // --------------------------------------------------
     void SampleDiscrete(TempMesh& out,IfcFloat a,IfcFloat b) const {
-        ai_assert(InRange(a) && InRange(b));
+        ai_assert(InRange(a));
+        ai_assert(InRange(b));
         return base->SampleDiscrete(out,TrimParam(a),TrimParam(b));
     }
 
@@ -446,7 +447,8 @@ public:
 
     // --------------------------------------------------
     size_t EstimateSampleCount(IfcFloat a, IfcFloat b) const {
-        ai_assert(InRange(a) && InRange(b));
+        ai_assert(InRange(a));
+        ai_assert(InRange(b));
         return static_cast<size_t>( std::ceil(b) - std::floor(a) );
     }
 
@@ -489,7 +491,7 @@ Curve* Curve::Convert(const IFC::Schema_2x3::IfcCurve& curve,ConversionData& con
     }
 
     // XXX OffsetCurve2D, OffsetCurve3D not currently supported
-    return NULL;
+    return nullptr;
 }
 
 #ifdef ASSIMP_BUILD_DEBUG
@@ -512,7 +514,7 @@ IfcFloat Curve::GetParametricRangeDelta() const {
 
 // ------------------------------------------------------------------------------------------------
 size_t Curve::EstimateSampleCount(IfcFloat a, IfcFloat b) const {
-    (void)(a); (void)(b);  
+    (void)(a); (void)(b);
     ai_assert( InRange( a ) );
     ai_assert( InRange( b ) );
 
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCGeometry.cpp b/Engine/lib/assimp/code/AssetLib/IFC/IFCGeometry.cpp
similarity index 88%
rename from Engine/lib/assimp/code/Importer/IFC/IFCGeometry.cpp
rename to Engine/lib/assimp/code/AssetLib/IFC/IFCGeometry.cpp
index d1c7aee19..ef5954251 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCGeometry.cpp
+++ b/Engine/lib/assimp/code/AssetLib/IFC/IFCGeometry.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2010, assimp team
+Copyright (c) 2006-2022, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -101,7 +101,7 @@ void ProcessPolygonBoundaries(TempMesh& result, const TempMesh& inmesh, size_t m
         return;
     }
 
-    ai_assert(std::count(inmesh.mVertcnt.begin(), inmesh.mVertcnt.end(), 0) == 0);
+    ai_assert(std::count(inmesh.mVertcnt.begin(), inmesh.mVertcnt.end(), 0u) == 0);
 
     typedef std::vector<unsigned int>::const_iterator face_iter;
 
@@ -138,8 +138,9 @@ void ProcessPolygonBoundaries(TempMesh& result, const TempMesh& inmesh, size_t m
             }
         }
     }
-
-    ai_assert(outer_polygon_it != end);
+	if (outer_polygon_it == end) {
+		return;
+	}
 
     const size_t outer_polygon_size = *outer_polygon_it;
     const IfcVector3& master_normal = normals[std::distance(begin, outer_polygon_it)];
@@ -173,7 +174,7 @@ void ProcessPolygonBoundaries(TempMesh& result, const TempMesh& inmesh, size_t m
         TempOpening& opening = fake_openings.back();
 
         opening.extrusionDir = master_normal;
-        opening.solid = NULL;
+        opening.solid = nullptr;
 
         opening.profileMesh = std::make_shared<TempMesh>();
         opening.profileMesh->mVerts.reserve(*iit);
@@ -189,7 +190,7 @@ void ProcessPolygonBoundaries(TempMesh& result, const TempMesh& inmesh, size_t m
     std::copy(outer_vit, outer_vit+outer_polygon_size,
         std::back_inserter(temp.mVerts));
 
-    GenerateOpenings(fake_openings, normals, temp, false, false);
+    GenerateOpenings(fake_openings, temp, false, false);
     result.Append(temp);
 }
 
@@ -215,7 +216,7 @@ void ProcessConnectedFaceSet(const Schema_2x3::IfcConnectedFaceSet& fset, TempMe
                 }
             }
             else {
-                IFCImporter::LogWarn("skipping unknown IfcFaceBound entity, type is " + bound.Bound->GetClassName());
+                IFCImporter::LogWarn("skipping unknown IfcFaceBound entity, type is ", bound.Bound->GetClassName());
                 continue;
             }
 
@@ -318,7 +319,7 @@ void ProcessRevolvedAreaSolid(const Schema_2x3::IfcRevolvedAreaSolid& solid, Tem
     ConvertAxisPlacement(trafo, solid.Position);
 
     result.Transform(trafo);
-    IFCImporter::LogDebug("generate mesh procedurally by radial extrusion (IfcRevolvedAreaSolid)");
+    IFCImporter::LogVerboseDebug("generate mesh procedurally by radial extrusion (IfcRevolvedAreaSolid)");
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -378,22 +379,20 @@ void ProcessSweptDiskSolid(const Schema_2x3::IfcSweptDiskSolid &solid, TempMesh&
         IfcVector3 q;
         bool take_any = false;
 
-        for (unsigned int i = 0; i < 2; ++i, take_any = true) {
-            if ((last_dir == 0 || take_any) && std::abs(d.x) > 1e-6) {
+        for (unsigned int j = 0; j < 2; ++j, take_any = true) {
+            if ((last_dir == 0 || take_any) && std::abs(d.x) > ai_epsilon) {
                 q.y = startvec.y;
                 q.z = startvec.z;
                 q.x = -(d.y * q.y + d.z * q.z) / d.x;
                 last_dir = 0;
                 break;
-            }
-            else if ((last_dir == 1 || take_any) && std::abs(d.y) > 1e-6) {
+            } else if ((last_dir == 1 || take_any) && std::abs(d.y) > ai_epsilon) {
                 q.x = startvec.x;
                 q.z = startvec.z;
                 q.y = -(d.x * q.x + d.z * q.z) / d.y;
                 last_dir = 1;
                 break;
-            }
-            else if ((last_dir == 2 && std::abs(d.z) > 1e-6) || take_any) {
+            } else if ((last_dir == 2 && std::abs(d.z) > ai_epsilon) || take_any) {
                 q.y = startvec.y;
                 q.x = startvec.x;
                 q.z = -(d.y * q.y + d.x * q.x) / d.z;
@@ -456,7 +455,7 @@ void ProcessSweptDiskSolid(const Schema_2x3::IfcSweptDiskSolid &solid, TempMesh&
         }
     }
 
-    IFCImporter::LogDebug("generate mesh procedurally by sweeping a disk along a curve (IfcSweptDiskSolid)");
+    IFCImporter::LogVerboseDebug("generate mesh procedurally by sweeping a disk along a curve (IfcSweptDiskSolid)");
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -528,6 +527,31 @@ IfcMatrix3 DerivePlaneCoordinateSpace(const TempMesh& curmesh, bool& ok, IfcVect
     return m;
 }
 
+const auto closeDistance = ai_epsilon;
+
+bool areClose(Schema_2x3::IfcCartesianPoint pt1,Schema_2x3::IfcCartesianPoint pt2) {
+    if(pt1.Coordinates.size() != pt2.Coordinates.size())
+    {
+        IFCImporter::LogWarn("unable to compare differently-dimensioned points");
+        return false;
+    }
+    auto coord1 = pt1.Coordinates.begin();
+    auto coord2 = pt2.Coordinates.begin();
+    // we're just testing each dimension separately rather than doing euclidean distance, as we're
+    // looking for very close coordinates
+    for(; coord1 != pt1.Coordinates.end(); coord1++,coord2++)
+    {
+        if(std::fabs(*coord1 - *coord2) > closeDistance)
+            return false;
+    }
+    return true;
+}
+
+bool areClose(IfcVector3 pt1,IfcVector3 pt2) {
+    return (std::fabs(pt1.x - pt2.x) < closeDistance &&
+        std::fabs(pt1.y - pt2.y) < closeDistance &&
+        std::fabs(pt1.z - pt2.z) < closeDistance);
+}
 // Extrudes the given polygon along the direction, converts it into an opening or applies all openings as necessary.
 void ProcessExtrudedArea(const Schema_2x3::IfcExtrudedAreaSolid& solid, const TempMesh& curve,
     const IfcVector3& extrusionDir, TempMesh& result, ConversionData &conv, bool collect_openings)
@@ -535,7 +559,7 @@ void ProcessExtrudedArea(const Schema_2x3::IfcExtrudedAreaSolid& solid, const Te
     // Outline: 'curve' is now a list of vertex points forming the underlying profile, extrude along the given axis,
     // forming new triangles.
     const bool has_area = solid.SweptArea->ProfileType == "AREA" && curve.mVerts.size() > 2;
-    if( solid.Depth < 1e-6 ) {
+    if (solid.Depth < ai_epsilon) {
         if( has_area ) {
             result.Append(curve);
         }
@@ -591,7 +615,21 @@ void ProcessExtrudedArea(const Schema_2x3::IfcExtrudedAreaSolid& solid, const Te
                 nors.push_back(IfcVector3());
                 continue;
             }
-            nors.push_back(((bounds.mVerts[2] - bounds.mVerts[0]) ^ (bounds.mVerts[1] - bounds.mVerts[0])).Normalize());
+            auto nor = ((bounds.mVerts[2] - bounds.mVerts[0]) ^ (bounds.mVerts[1] - bounds.mVerts[0])).Normalize();
+            auto vI0 = bounds.mVertcnt[0];
+            for(size_t faceI = 0; faceI < bounds.mVertcnt.size(); faceI++)
+            {
+                if(bounds.mVertcnt[faceI] >= 3) {
+                    // do a check that this is at least parallel to the base plane
+                    auto nor2 = ((bounds.mVerts[vI0 + 2] - bounds.mVerts[vI0]) ^ (bounds.mVerts[vI0 + 1] - bounds.mVerts[vI0])).Normalize();
+                    if(!areClose(nor,nor2)) {
+                        std::stringstream msg;
+                        msg << "Face " << faceI << " is not parallel with face 0 - opening on entity " << solid.GetID();
+                        IFCImporter::LogWarn(msg.str().c_str());
+                    }
+                }
+            }
+            nors.push_back(nor);
         }
     }
 
@@ -612,7 +650,7 @@ void ProcessExtrudedArea(const Schema_2x3::IfcExtrudedAreaSolid& solid, const Te
         out.push_back(in[i] + dir);
 
         if( openings ) {
-            if( (in[i] - in[next]).Length() > diag * 0.1 && GenerateOpenings(*conv.apply_openings, nors, temp, true, true, dir) ) {
+            if( (in[i] - in[next]).Length() > diag * 0.1 && GenerateOpenings(*conv.apply_openings, temp, true, true, dir) ) {
                 ++sides_with_openings;
             }
 
@@ -621,31 +659,33 @@ void ProcessExtrudedArea(const Schema_2x3::IfcExtrudedAreaSolid& solid, const Te
         }
     }
 
-    if( openings ) {
+    if(openings) {
         for(TempOpening& opening : *conv.apply_openings) {
-            if( !opening.wallPoints.empty() ) {
-                IFCImporter::LogError("failed to generate all window caps");
+            if(!opening.wallPoints.empty()) {
+                std::stringstream msg;
+                msg << "failed to generate all window caps on ID " << (int)solid.GetID();
+                IFCImporter::LogError(msg.str().c_str());
             }
             opening.wallPoints.clear();
         }
     }
 
     size_t sides_with_v_openings = 0;
-    if( has_area ) {
+    if(has_area) {
 
-        for( size_t n = 0; n < 2; ++n ) {
-            if( n > 0 ) {
-                for( size_t i = 0; i < in.size(); ++i )
+        for(size_t n = 0; n < 2; ++n) {
+            if(n > 0) {
+                for(size_t i = 0; i < in.size(); ++i)
                     out.push_back(in[i] + dir);
             }
             else {
-                for( size_t i = in.size(); i--; )
+                for(size_t i = in.size(); i--; )
                     out.push_back(in[i]);
             }
 
             curmesh.mVertcnt.push_back(static_cast<unsigned int>(in.size()));
-            if( openings && in.size() > 2 ) {
-                if( GenerateOpenings(*conv.apply_openings, nors, temp, true, true, dir) ) {
+            if(openings && in.size() > 2) {
+                if(GenerateOpenings(*conv.apply_openings,temp,true,true,dir)) {
                     ++sides_with_v_openings;
                 }
 
@@ -655,11 +695,13 @@ void ProcessExtrudedArea(const Schema_2x3::IfcExtrudedAreaSolid& solid, const Te
         }
     }
 
-    if( openings && ((sides_with_openings == 1 && sides_with_openings) || (sides_with_v_openings == 2 && sides_with_v_openings)) ) {
-        IFCImporter::LogWarn("failed to resolve all openings, presumably their topology is not supported by Assimp");
+    if (openings && (sides_with_openings == 1 || sides_with_v_openings == 2)) {
+        std::stringstream msg;
+        msg << "failed to resolve all openings, presumably their topology is not supported by Assimp - ID " << solid.GetID() << " sides_with_openings " << sides_with_openings << " sides_with_v_openings " << sides_with_v_openings;
+        IFCImporter::LogWarn(msg.str().c_str());
     }
 
-    IFCImporter::LogDebug("generate mesh procedurally by extrusion (IfcExtrudedAreaSolid)");
+    IFCImporter::LogVerboseDebug("generate mesh procedurally by extrusion (IfcExtrudedAreaSolid)");
 
     // If this is an opening element, store both the extruded mesh and the 2D profile mesh
     // it was created from. Return an empty mesh to the caller.
@@ -728,7 +770,7 @@ void ProcessSweptAreaSolid(const Schema_2x3::IfcSweptAreaSolid& swept, TempMesh&
         ProcessRevolvedAreaSolid(*rev,meshout,conv);
     }
     else {
-        IFCImporter::LogWarn("skipping unknown IfcSweptAreaSolid entity, type is " + swept.GetClassName());
+        IFCImporter::LogWarn("skipping unknown IfcSweptAreaSolid entity, type is ", swept.GetClassName());
     }
 }
 
@@ -739,7 +781,7 @@ bool ProcessGeometricItem(const Schema_2x3::IfcRepresentationItem& geo, unsigned
     bool fix_orientation = false;
     std::shared_ptr< TempMesh > meshtmp = std::make_shared<TempMesh>();
     if(const Schema_2x3::IfcShellBasedSurfaceModel* shellmod = geo.ToPtr<Schema_2x3::IfcShellBasedSurfaceModel>()) {
-        for(std::shared_ptr<const Schema_2x3::IfcShell> shell :shellmod->SbsmBoundary) {
+        for (const std::shared_ptr<const Schema_2x3::IfcShell> &shell : shellmod->SbsmBoundary) {
             try {
                 const ::Assimp::STEP::EXPRESS::ENTITY& e = shell->To<::Assimp::STEP::EXPRESS::ENTITY>();
                 const Schema_2x3::IfcConnectedFaceSet& fs = conv.db.MustGetObject(e).To<Schema_2x3::IfcConnectedFaceSet>();
@@ -780,7 +822,9 @@ bool ProcessGeometricItem(const Schema_2x3::IfcRepresentationItem& geo, unsigned
         return false;
     }
     else {
-        IFCImporter::LogWarn("skipping unknown IfcGeometricRepresentationItem entity, type is " + geo.GetClassName());
+        std::stringstream toLog;
+        toLog << "skipping unknown IfcGeometricRepresentationItem entity, type is " << geo.GetClassName() << " id is " << geo.GetID();
+        IFCImporter::LogWarn(toLog.str().c_str());
         return false;
     }
 
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCLoader.cpp b/Engine/lib/assimp/code/AssetLib/IFC/IFCLoader.cpp
similarity index 56%
rename from Engine/lib/assimp/code/Importer/IFC/IFCLoader.cpp
rename to Engine/lib/assimp/code/AssetLib/IFC/IFCLoader.cpp
index 5c705c256..0c20686f4 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCLoader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/IFC/IFCLoader.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -44,7 +44,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Implementation of the Industry Foundation Classes loader.
  */
 
-
 #ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
 
 #include <iterator>
@@ -52,31 +51,30 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <tuple>
 
 #ifndef ASSIMP_BUILD_NO_COMPRESSED_IFC
-#  ifdef ASSIMP_USE_HUNTER
-#    include <minizip/unzip.h>
-#  else
-#    include <unzip.h>
-#  endif
+#ifdef ASSIMP_USE_HUNTER
+#include <minizip/unzip.h>
+#else
+#include <unzip.h>
+#endif
 #endif
 
-#include "IFCLoader.h"
 #include "../STEPParser/STEPFileReader.h"
+#include "IFCLoader.h"
 
 #include "IFCUtil.h"
 
 #include <assimp/MemoryIOWrapper.h>
+#include <assimp/importerdesc.h>
 #include <assimp/scene.h>
 #include <assimp/Importer.hpp>
-#include <assimp/importerdesc.h>
-
 
 namespace Assimp {
-    template<> const char* LogFunctions<IFCImporter>::Prefix()
-    {
-        static auto prefix = "IFC: ";
-        return prefix;
-    }
+template <>
+const char *LogFunctions<IFCImporter>::Prefix() {
+    static auto prefix = "IFC: ";
+    return prefix;
 }
+} // namespace Assimp
 
 using namespace Assimp;
 using namespace Assimp::Formatter;
@@ -98,15 +96,14 @@ using namespace Assimp::IFC;
 
 namespace {
 
-
 // forward declarations
-void SetUnits(ConversionData& conv);
-void SetCoordinateSpace(ConversionData& conv);
-void ProcessSpatialStructures(ConversionData& conv);
-void MakeTreeRelative(ConversionData& conv);
-void ConvertUnit(const ::Assimp::STEP::EXPRESS::DataType& dt,ConversionData& conv);
+void SetUnits(ConversionData &conv);
+void SetCoordinateSpace(ConversionData &conv);
+void ProcessSpatialStructures(ConversionData &conv);
+void MakeTreeRelative(ConversionData &conv);
+void ConvertUnit(const ::Assimp::STEP::EXPRESS::DataType &dt, ConversionData &conv);
 
-} // anon
+} // namespace
 
 static const aiImporterDesc desc = {
     "Industry Foundation Classes (IFC) Importer",
@@ -118,129 +115,110 @@ static const aiImporterDesc desc = {
     0,
     0,
     0,
-    "ifc ifczip stp"
+    "ifc ifczip step stp"
 };
 
-
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-IFCImporter::IFCImporter()
-{}
+IFCImporter::IFCImporter() {}
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-IFCImporter::~IFCImporter()
-{
+IFCImporter::~IFCImporter() {
 }
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool IFCImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
-{
-    const std::string& extension = GetExtension(pFile);
-    if (extension == "ifc" || extension == "ifczip" ) {
-        return true;
-    } else if ((!extension.length() || checkSig) && pIOHandler)   {
-        // note: this is the common identification for STEP-encoded files, so
-        // it is only unambiguous as long as we don't support any further
-        // file formats with STEP as their encoding.
-        const char* tokens[] = {"ISO-10303-21"};
-        const bool found( SearchFileHeaderForToken( pIOHandler, pFile, tokens, 1 ) );
-        return found;
-    }
-    return false;
+bool IFCImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
+    // note: this is the common identification for STEP-encoded files, so
+    // it is only unambiguous as long as we don't support any further
+    // file formats with STEP as their encoding.
+    static const char *tokens[] = { "ISO-10303-21" };
+    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------
 // List all extensions handled by this loader
-const aiImporterDesc* IFCImporter::GetInfo () const
-{
+const aiImporterDesc *IFCImporter::GetInfo() const {
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup configuration properties for the loader
-void IFCImporter::SetupProperties(const Importer* pImp)
-{
-    settings.skipSpaceRepresentations = pImp->GetPropertyBool(AI_CONFIG_IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS,true);
-    settings.useCustomTriangulation = pImp->GetPropertyBool(AI_CONFIG_IMPORT_IFC_CUSTOM_TRIANGULATION,true);
-    settings.conicSamplingAngle = std::min(std::max((float) pImp->GetPropertyFloat(AI_CONFIG_IMPORT_IFC_SMOOTHING_ANGLE, AI_IMPORT_IFC_DEFAULT_SMOOTHING_ANGLE), 5.0f), 120.0f);
-	settings.cylindricalTessellation = std::min(std::max(pImp->GetPropertyInteger(AI_CONFIG_IMPORT_IFC_CYLINDRICAL_TESSELLATION, AI_IMPORT_IFC_DEFAULT_CYLINDRICAL_TESSELLATION), 3), 180);
-	settings.skipAnnotations = true;
+void IFCImporter::SetupProperties(const Importer *pImp) {
+    settings.skipSpaceRepresentations = pImp->GetPropertyBool(AI_CONFIG_IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS, true);
+    settings.useCustomTriangulation = pImp->GetPropertyBool(AI_CONFIG_IMPORT_IFC_CUSTOM_TRIANGULATION, true);
+    settings.conicSamplingAngle = std::min(std::max((float)pImp->GetPropertyFloat(AI_CONFIG_IMPORT_IFC_SMOOTHING_ANGLE, AI_IMPORT_IFC_DEFAULT_SMOOTHING_ANGLE), 5.0f), 120.0f);
+    settings.cylindricalTessellation = std::min(std::max(pImp->GetPropertyInteger(AI_CONFIG_IMPORT_IFC_CYLINDRICAL_TESSELLATION, AI_IMPORT_IFC_DEFAULT_CYLINDRICAL_TESSELLATION), 3), 180);
+    settings.skipAnnotations = true;
 }
 
-
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void IFCImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler)
-{
+void IFCImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
     std::shared_ptr<IOStream> stream(pIOHandler->Open(pFile));
     if (!stream) {
         ThrowException("Could not open file for reading");
     }
 
-
     // if this is a ifczip file, decompress its contents first
-    if(GetExtension(pFile) == "ifczip") {
+    if (GetExtension(pFile) == "ifczip") {
 #ifndef ASSIMP_BUILD_NO_COMPRESSED_IFC
-        unzFile zip = unzOpen( pFile.c_str() );
-        if(zip == NULL) {
+        unzFile zip = unzOpen(pFile.c_str());
+        if (zip == nullptr) {
             ThrowException("Could not open ifczip file for reading, unzip failed");
         }
 
         // chop 'zip' postfix
-        std::string fileName = pFile.substr(0,pFile.length() - 3);
+        std::string fileName = pFile.substr(0, pFile.length() - 3);
 
         std::string::size_type s = pFile.find_last_of('\\');
-        if(s == std::string::npos) {
+        if (s == std::string::npos) {
             s = pFile.find_last_of('/');
         }
-        if(s != std::string::npos) {
-            fileName = fileName.substr(s+1);
+        if (s != std::string::npos) {
+            fileName = fileName.substr(s + 1);
         }
 
         // search file (same name as the IFCZIP except for the file extension) and place file pointer there
-        if(UNZ_OK == unzGoToFirstFile(zip)) {
+        if (UNZ_OK == unzGoToFirstFile(zip)) {
             do {
                 // get file size, etc.
                 unz_file_info fileInfo;
                 char filename[256];
-                unzGetCurrentFileInfo( zip , &fileInfo, filename, sizeof(filename), 0, 0, 0, 0 );
+                unzGetCurrentFileInfo(zip, &fileInfo, filename, sizeof(filename), 0, 0, 0, 0);
                 if (GetExtension(filename) != "ifc") {
                     continue;
                 }
-                uint8_t* buff = new uint8_t[fileInfo.uncompressed_size];
+                uint8_t *buff = new uint8_t[fileInfo.uncompressed_size];
                 LogInfo("Decompressing IFCZIP file");
                 unzOpenCurrentFile(zip);
                 size_t total = 0;
                 int read = 0;
                 do {
                     int bufferSize = fileInfo.uncompressed_size < INT16_MAX ? fileInfo.uncompressed_size : INT16_MAX;
-                    void* buffer = malloc(bufferSize);
+                    void *buffer = malloc(bufferSize);
                     read = unzReadCurrentFile(zip, buffer, bufferSize);
                     if (read > 0) {
-                        memcpy((char*)buff + total, buffer, read);
+                        memcpy((char *)buff + total, buffer, read);
                         total += read;
                     }
                     free(buffer);
                 } while (read > 0);
                 size_t filesize = fileInfo.uncompressed_size;
-                if (total == 0 || size_t(total) != filesize)
-                {
+                if (total == 0 || size_t(total) != filesize) {
                     delete[] buff;
                     ThrowException("Failed to decompress IFC ZIP file");
                 }
-                unzCloseCurrentFile( zip );
-                stream.reset(new MemoryIOStream(buff,fileInfo.uncompressed_size,true));
-                break;
-
+                unzCloseCurrentFile(zip);
+                stream.reset(new MemoryIOStream(buff, fileInfo.uncompressed_size, true));
                 if (unzGoToNextFile(zip) == UNZ_END_OF_LIST_OF_FILE) {
                     ThrowException("Found no IFC file member in IFCZIP file (1)");
                 }
+                break;
 
-            } while(true);
-        }
-        else {
+            } while (true);
+        } else {
             ThrowException("Found no IFC file member in IFCZIP file (2)");
         }
 
@@ -251,19 +229,19 @@ void IFCImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
     }
 
     std::unique_ptr<STEP::DB> db(STEP::ReadFileHeader(stream));
-    const STEP::HeaderInfo& head = static_cast<const STEP::DB&>(*db).GetHeader();
+    const STEP::HeaderInfo &head = static_cast<const STEP::DB &>(*db).GetHeader();
 
-    if(!head.fileSchema.size() || head.fileSchema.substr(0,3) != "IFC") {
+    if (!head.fileSchema.size() || head.fileSchema.substr(0, 3) != "IFC") {
         ThrowException("Unrecognized file schema: " + head.fileSchema);
     }
 
     if (!DefaultLogger::isNullLogger()) {
-        LogDebug("File schema is \'" + head.fileSchema + '\'');
+        LogDebug("File schema is \'", head.fileSchema, '\'');
         if (head.timestamp.length()) {
-            LogDebug("Timestamp \'" + head.timestamp + '\'');
+            LogDebug("Timestamp \'", head.timestamp, '\'');
         }
         if (head.app.length()) {
-            LogDebug("Application/Exporter identline is \'" + head.app  + '\'');
+            LogDebug("Application/Exporter identline is \'", head.app, '\'');
         }
     }
 
@@ -272,41 +250,41 @@ void IFCImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
     Schema_2x3::GetSchema(schema);
 
     // tell the reader which entity types to track with special care
-    static const char* const types_to_track[] = {
+    static const char *const types_to_track[] = {
         "ifcsite", "ifcbuilding", "ifcproject"
     };
 
     // tell the reader for which types we need to simulate STEPs reverse indices
-    static const char* const inverse_indices_to_track[] = {
+    static const char *const inverse_indices_to_track[] = {
         "ifcrelcontainedinspatialstructure", "ifcrelaggregates", "ifcrelvoidselement", "ifcreldefinesbyproperties", "ifcpropertyset", "ifcstyleditem"
     };
 
     // feed the IFC schema into the reader and pre-parse all lines
     STEP::ReadFile(*db, schema, types_to_track, inverse_indices_to_track);
-    const STEP::LazyObject* proj =  db->GetObject("ifcproject");
+    const STEP::LazyObject *proj = db->GetObject("ifcproject");
     if (!proj) {
         ThrowException("missing IfcProject entity");
     }
 
-    ConversionData conv(*db,proj->To<Schema_2x3::IfcProject>(),pScene,settings);
+    ConversionData conv(*db, proj->To<Schema_2x3::IfcProject>(), pScene, settings);
     SetUnits(conv);
     SetCoordinateSpace(conv);
     ProcessSpatialStructures(conv);
     MakeTreeRelative(conv);
 
-    // NOTE - this is a stress test for the importer, but it works only
-    // in a build with no entities disabled. See
-    //     scripts/IFCImporter/CPPGenerator.py
-    // for more information.
-    #ifdef ASSIMP_IFC_TEST
-        db->EvaluateAll();
-    #endif
+// NOTE - this is a stress test for the importer, but it works only
+// in a build with no entities disabled. See
+//     scripts/IFCImporter/CPPGenerator.py
+// for more information.
+#ifdef ASSIMP_IFC_TEST
+    db->EvaluateAll();
+#endif
 
     // do final data copying
     if (conv.meshes.size()) {
         pScene->mNumMeshes = static_cast<unsigned int>(conv.meshes.size());
-        pScene->mMeshes = new aiMesh*[pScene->mNumMeshes]();
-        std::copy(conv.meshes.begin(),conv.meshes.end(),pScene->mMeshes);
+        pScene->mMeshes = new aiMesh *[pScene->mNumMeshes]();
+        std::copy(conv.meshes.begin(), conv.meshes.end(), pScene->mMeshes);
 
         // needed to keep the d'tor from burning us
         conv.meshes.clear();
@@ -314,8 +292,8 @@ void IFCImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
 
     if (conv.materials.size()) {
         pScene->mNumMaterials = static_cast<unsigned int>(conv.materials.size());
-        pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials]();
-        std::copy(conv.materials.begin(),conv.materials.end(),pScene->mMaterials);
+        pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials]();
+        std::copy(conv.materials.begin(), conv.materials.end(), pScene->mMaterials);
 
         // needed to keep the d'tor from burning us
         conv.materials.clear();
@@ -323,42 +301,38 @@ void IFCImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
 
     // apply world coordinate system (which includes the scaling to convert to meters and a -90 degrees rotation around x)
     aiMatrix4x4 scale, rot;
-    aiMatrix4x4::Scaling(static_cast<aiVector3D>(IfcVector3(conv.len_scale)),scale);
-    aiMatrix4x4::RotationX(-AI_MATH_HALF_PI_F,rot);
+    aiMatrix4x4::Scaling(static_cast<aiVector3D>(IfcVector3(conv.len_scale)), scale);
+    aiMatrix4x4::RotationX(-AI_MATH_HALF_PI_F, rot);
 
     pScene->mRootNode->mTransformation = rot * scale * conv.wcs * pScene->mRootNode->mTransformation;
 
     // this must be last because objects are evaluated lazily as we process them
-    if ( !DefaultLogger::isNullLogger() ){
-        LogDebug((Formatter::format(),"STEP: evaluated ",db->GetEvaluatedObjectCount()," object records"));
+    if (!DefaultLogger::isNullLogger()) {
+        LogDebug("STEP: evaluated ", db->GetEvaluatedObjectCount(), " object records");
     }
 }
 
 namespace {
 
-
 // ------------------------------------------------------------------------------------------------
-void ConvertUnit(const Schema_2x3::IfcNamedUnit& unit,ConversionData& conv)
-{
-    if(const Schema_2x3::IfcSIUnit* const si = unit.ToPtr<Schema_2x3::IfcSIUnit>()) {
-        if(si->UnitType == "LENGTHUNIT") {
+void ConvertUnit(const Schema_2x3::IfcNamedUnit &unit, ConversionData &conv) {
+    if (const Schema_2x3::IfcSIUnit *const si = unit.ToPtr<Schema_2x3::IfcSIUnit>()) {
+        if (si->UnitType == "LENGTHUNIT") {
             conv.len_scale = si->Prefix ? ConvertSIPrefix(si->Prefix) : 1.f;
             IFCImporter::LogDebug("got units used for lengths");
         }
-        if(si->UnitType == "PLANEANGLEUNIT") {
+        if (si->UnitType == "PLANEANGLEUNIT") {
             if (si->Name != "RADIAN") {
                 IFCImporter::LogWarn("expected base unit for angles to be radian");
             }
         }
-    }
-    else if(const Schema_2x3::IfcConversionBasedUnit* const convu = unit.ToPtr<Schema_2x3::IfcConversionBasedUnit>()) {
-        if(convu->UnitType == "PLANEANGLEUNIT") {
+    } else if (const Schema_2x3::IfcConversionBasedUnit *const convu = unit.ToPtr<Schema_2x3::IfcConversionBasedUnit>()) {
+        if (convu->UnitType == "PLANEANGLEUNIT") {
             try {
                 conv.angle_scale = convu->ConversionFactor->ValueComponent->To<::Assimp::STEP::EXPRESS::REAL>();
-                ConvertUnit(*convu->ConversionFactor->UnitComponent,conv);
+                ConvertUnit(*convu->ConversionFactor->UnitComponent, conv);
                 IFCImporter::LogDebug("got units used for angles");
-            }
-            catch(std::bad_cast&) {
+            } catch (std::bad_cast &) {
                 IFCImporter::LogError("skipping unknown IfcConversionBasedUnit.ValueComponent entry - expected REAL");
             }
         }
@@ -366,39 +340,34 @@ void ConvertUnit(const Schema_2x3::IfcNamedUnit& unit,ConversionData& conv)
 }
 
 // ------------------------------------------------------------------------------------------------
-void ConvertUnit(const ::Assimp::STEP::EXPRESS::DataType& dt,ConversionData& conv)
-{
+void ConvertUnit(const ::Assimp::STEP::EXPRESS::DataType &dt, ConversionData &conv) {
     try {
-        const ::Assimp::STEP::EXPRESS::ENTITY& e = dt.To<::Assimp::STEP::EXPRESS::ENTITY>();
+        const ::Assimp::STEP::EXPRESS::ENTITY &e = dt.To<::Assimp::STEP::EXPRESS::ENTITY>();
 
-        const Schema_2x3::IfcNamedUnit& unit = e.ResolveSelect<Schema_2x3::IfcNamedUnit>(conv.db);
-        if(unit.UnitType != "LENGTHUNIT" && unit.UnitType != "PLANEANGLEUNIT") {
+        const Schema_2x3::IfcNamedUnit &unit = e.ResolveSelect<Schema_2x3::IfcNamedUnit>(conv.db);
+        if (unit.UnitType != "LENGTHUNIT" && unit.UnitType != "PLANEANGLEUNIT") {
             return;
         }
 
-        ConvertUnit(unit,conv);
-    }
-    catch(std::bad_cast&) {
+        ConvertUnit(unit, conv);
+    } catch (std::bad_cast &) {
         // not entity, somehow
         IFCImporter::LogError("skipping unknown IfcUnit entry - expected entity");
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void SetUnits(ConversionData& conv)
-{
+void SetUnits(ConversionData &conv) {
     // see if we can determine the coordinate space used to express.
-    for(size_t i = 0; i <  conv.proj.UnitsInContext->Units.size(); ++i ) {
-        ConvertUnit(*conv.proj.UnitsInContext->Units[i],conv);
+    for (size_t i = 0; i < conv.proj.UnitsInContext->Units.size(); ++i) {
+        ConvertUnit(*conv.proj.UnitsInContext->Units[i], conv);
     }
 }
 
-
 // ------------------------------------------------------------------------------------------------
-void SetCoordinateSpace(ConversionData& conv)
-{
-    const Schema_2x3::IfcRepresentationContext* fav = NULL;
-    for(const Schema_2x3::IfcRepresentationContext& v : conv.proj.RepresentationContexts) {
+void SetCoordinateSpace(ConversionData &conv) {
+    const Schema_2x3::IfcRepresentationContext *fav = nullptr;
+    for (const Schema_2x3::IfcRepresentationContext &v : conv.proj.RepresentationContexts) {
         fav = &v;
         // Model should be the most suitable type of context, hence ignore the others
         if (v.ContextType && v.ContextType.Get() == "Model") {
@@ -406,37 +375,33 @@ void SetCoordinateSpace(ConversionData& conv)
         }
     }
     if (fav) {
-        if(const Schema_2x3::IfcGeometricRepresentationContext* const geo = fav->ToPtr<Schema_2x3::IfcGeometricRepresentationContext>()) {
+        if (const Schema_2x3::IfcGeometricRepresentationContext *const geo = fav->ToPtr<Schema_2x3::IfcGeometricRepresentationContext>()) {
             ConvertAxisPlacement(conv.wcs, *geo->WorldCoordinateSystem, conv);
             IFCImporter::LogDebug("got world coordinate system");
         }
     }
 }
 
-
 // ------------------------------------------------------------------------------------------------
-void ResolveObjectPlacement(aiMatrix4x4& m, const Schema_2x3::IfcObjectPlacement& place, ConversionData& conv)
-{
-    if (const Schema_2x3::IfcLocalPlacement* const local = place.ToPtr<Schema_2x3::IfcLocalPlacement>()){
+void ResolveObjectPlacement(aiMatrix4x4 &m, const Schema_2x3::IfcObjectPlacement &place, ConversionData &conv) {
+    if (const Schema_2x3::IfcLocalPlacement *const local = place.ToPtr<Schema_2x3::IfcLocalPlacement>()) {
         IfcMatrix4 tmp;
         ConvertAxisPlacement(tmp, *local->RelativePlacement, conv);
 
         m = static_cast<aiMatrix4x4>(tmp);
 
         if (local->PlacementRelTo) {
-            aiMatrix4x4 tmp;
-            ResolveObjectPlacement(tmp,local->PlacementRelTo.Get(),conv);
-            m = tmp * m;
+            aiMatrix4x4 tmpM;
+            ResolveObjectPlacement(tmpM, local->PlacementRelTo.Get(), conv);
+            m = tmpM * m;
         }
-    }
-    else {
-        IFCImporter::LogWarn("skipping unknown IfcObjectPlacement entity, type is " + place.GetClassName());
+    } else {
+        IFCImporter::LogWarn("skipping unknown IfcObjectPlacement entity, type is ", place.GetClassName());
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-bool ProcessMappedItem(const Schema_2x3::IfcMappedItem& mapped, aiNode* nd_src, std::vector< aiNode* >& subnodes_src, unsigned int matid, ConversionData& conv)
-{
+bool ProcessMappedItem(const Schema_2x3::IfcMappedItem &mapped, aiNode *nd_src, std::vector<aiNode *> &subnodes_src, unsigned int matid, ConversionData &conv) {
     // insert a custom node here, the carthesian transform operator is simply a conventional transformation matrix
     std::unique_ptr<aiNode> nd(new aiNode());
     nd->mName.Set("IfcMappedItem");
@@ -446,49 +411,49 @@ bool ProcessMappedItem(const Schema_2x3::IfcMappedItem& mapped, aiNode* nd_src,
     ConvertTransformOperator(m, *mapped.MappingTarget);
 
     IfcMatrix4 msrc;
-    ConvertAxisPlacement(msrc,*mapped.MappingSource->MappingOrigin,conv);
+    ConvertAxisPlacement(msrc, *mapped.MappingSource->MappingOrigin, conv);
 
-    msrc = m*msrc;
+    msrc = m * msrc;
 
     std::set<unsigned int> meshes;
     const size_t old_openings = conv.collect_openings ? conv.collect_openings->size() : 0;
     if (conv.apply_openings) {
         IfcMatrix4 minv = msrc;
         minv.Inverse();
-        for(TempOpening& open :*conv.apply_openings){
+        for (TempOpening &open : *conv.apply_openings) {
             open.Transform(minv);
         }
     }
 
-    unsigned int localmatid = ProcessMaterials(mapped.GetID(),matid,conv,false);
-    const Schema_2x3::IfcRepresentation& repr = mapped.MappingSource->MappedRepresentation;
+    unsigned int localmatid = ProcessMaterials(mapped.GetID(), matid, conv, false);
+    const Schema_2x3::IfcRepresentation &repr = mapped.MappingSource->MappedRepresentation;
 
     bool got = false;
-    for(const Schema_2x3::IfcRepresentationItem& item : repr.Items) {
-        if(!ProcessRepresentationItem(item,localmatid,meshes,conv)) {
-            IFCImporter::LogWarn("skipping mapped entity of type " + item.GetClassName() + ", no representations could be generated");
-        }
-        else got = true;
+    for (const Schema_2x3::IfcRepresentationItem &item : repr.Items) {
+        if (!ProcessRepresentationItem(item, localmatid, meshes, conv)) {
+            IFCImporter::LogWarn("skipping mapped entity of type ", item.GetClassName(), ", no representations could be generated");
+        } else
+            got = true;
     }
 
     if (!got) {
         return false;
     }
 
-    AssignAddedMeshes(meshes,nd.get(),conv);
+    AssignAddedMeshes(meshes, nd.get(), conv);
     if (conv.collect_openings) {
 
         // if this pass serves us only to collect opening geometry,
         // make sure we transform the TempMesh's which we need to
         // preserve as well.
-        if(const size_t diff = conv.collect_openings->size() - old_openings) {
-            for(size_t i = 0; i < diff; ++i) {
-                (*conv.collect_openings)[old_openings+i].Transform(msrc);
+        if (const size_t diff = conv.collect_openings->size() - old_openings) {
+            for (size_t i = 0; i < diff; ++i) {
+                (*conv.collect_openings)[old_openings + i].Transform(msrc);
             }
         }
     }
 
-    nd->mTransformation =  nd_src->mTransformation * static_cast<aiMatrix4x4>( msrc );
+    nd->mTransformation = nd_src->mTransformation * static_cast<aiMatrix4x4>(msrc);
     subnodes_src.push_back(nd.release());
 
     return true;
@@ -496,20 +461,19 @@ bool ProcessMappedItem(const Schema_2x3::IfcMappedItem& mapped, aiNode* nd_src,
 
 // ------------------------------------------------------------------------------------------------
 struct RateRepresentationPredicate {
-    int Rate(const Schema_2x3::IfcRepresentation* r) const {
+    int Rate(const Schema_2x3::IfcRepresentation *r) const {
         // the smaller, the better
 
-        if (! r->RepresentationIdentifier) {
+        if (!r->RepresentationIdentifier) {
             // neutral choice if no extra information is specified
             return 0;
         }
 
-
-        const std::string& name = r->RepresentationIdentifier.Get();
+        const std::string &name = r->RepresentationIdentifier.Get();
         if (name == "MappedRepresentation") {
             if (!r->Items.empty()) {
                 // take the first item and base our choice on it
-                const Schema_2x3::IfcMappedItem* const m = r->Items.front()->ToPtr<Schema_2x3::IfcMappedItem>();
+                const Schema_2x3::IfcMappedItem *const m = r->Items.front()->ToPtr<Schema_2x3::IfcMappedItem>();
                 if (m) {
                     return Rate(m->MappingSource->MappedRepresentation);
                 }
@@ -520,7 +484,7 @@ struct RateRepresentationPredicate {
         return Rate(name);
     }
 
-    int Rate(const std::string& r) const {
+    int Rate(const std::string &r) const {
         if (r == "SolidModel") {
             return -3;
         }
@@ -551,20 +515,19 @@ struct RateRepresentationPredicate {
         return 0;
     }
 
-    bool operator() (const Schema_2x3::IfcRepresentation* a, const Schema_2x3::IfcRepresentation* b) const {
+    bool operator()(const Schema_2x3::IfcRepresentation *a, const Schema_2x3::IfcRepresentation *b) const {
         return Rate(a) < Rate(b);
     }
 };
 
 // ------------------------------------------------------------------------------------------------
-void ProcessProductRepresentation(const Schema_2x3::IfcProduct& el, aiNode* nd, std::vector< aiNode* >& subnodes, ConversionData& conv)
-{
-    if(!el.Representation) {
+void ProcessProductRepresentation(const Schema_2x3::IfcProduct &el, aiNode *nd, std::vector<aiNode *> &subnodes, ConversionData &conv) {
+    if (!el.Representation) {
         return;
     }
 
     // extract Color from metadata, if present
-    unsigned int matid = ProcessMaterials( el.GetID(), std::numeric_limits<uint32_t>::max(), conv, false);
+    unsigned int matid = ProcessMaterials(el.GetID(), std::numeric_limits<uint32_t>::max(), conv, false);
     std::set<unsigned int> meshes;
 
     // we want only one representation type, so bring them in a suitable order (i.e try those
@@ -572,162 +535,151 @@ void ProcessProductRepresentation(const Schema_2x3::IfcProduct& el, aiNode* nd,
     // representation is relatively generic and allows the concrete implementations
     // for the different representation types to make some sensible choices what
     // to load and what not to load.
-    const STEP::ListOf< STEP::Lazy< Schema_2x3::IfcRepresentation >, 1, 0 >& src = el.Representation.Get()->Representations;
-    std::vector<const Schema_2x3::IfcRepresentation*> repr_ordered(src.size());
-    std::copy(src.begin(),src.end(),repr_ordered.begin());
-    std::sort(repr_ordered.begin(),repr_ordered.end(),RateRepresentationPredicate());
-    for(const Schema_2x3::IfcRepresentation* repr : repr_ordered) {
+    const STEP::ListOf<STEP::Lazy<Schema_2x3::IfcRepresentation>, 1, 0> &src = el.Representation.Get()->Representations;
+    std::vector<const Schema_2x3::IfcRepresentation *> repr_ordered(src.size());
+    std::copy(src.begin(), src.end(), repr_ordered.begin());
+    std::sort(repr_ordered.begin(), repr_ordered.end(), RateRepresentationPredicate());
+    for (const Schema_2x3::IfcRepresentation *repr : repr_ordered) {
         bool res = false;
-        for(const Schema_2x3::IfcRepresentationItem& item : repr->Items) {
-            if(const Schema_2x3::IfcMappedItem* const geo = item.ToPtr<Schema_2x3::IfcMappedItem>()) {
-                res = ProcessMappedItem(*geo,nd,subnodes,matid,conv) || res;
-            }
-            else {
-                res = ProcessRepresentationItem(item,matid,meshes,conv) || res;
+        for (const Schema_2x3::IfcRepresentationItem &item : repr->Items) {
+            if (const Schema_2x3::IfcMappedItem *const geo = item.ToPtr<Schema_2x3::IfcMappedItem>()) {
+                res = ProcessMappedItem(*geo, nd, subnodes, matid, conv) || res;
+            } else {
+                res = ProcessRepresentationItem(item, matid, meshes, conv) || res;
             }
         }
         // if we got something meaningful at this point, skip any further representations
-        if(res) {
+        if (res) {
             break;
         }
     }
-    AssignAddedMeshes(meshes,nd,conv);
+    AssignAddedMeshes(meshes, nd, conv);
 }
 
 typedef std::map<std::string, std::string> Metadata;
 
 // ------------------------------------------------------------------------------------------------
-void ProcessMetadata(const Schema_2x3::ListOf< Schema_2x3::Lazy< Schema_2x3::IfcProperty >, 1, 0 >& set, ConversionData& conv, Metadata& properties,
-        const std::string& prefix = "",
+void ProcessMetadata(const Schema_2x3::ListOf<Schema_2x3::Lazy<Schema_2x3::IfcProperty>, 1, 0> &set, ConversionData &conv, Metadata &properties,
+        const std::string &prefix = std::string(),
         unsigned int nest = 0) {
-    for(const Schema_2x3::IfcProperty& property : set) {
-        const std::string& key = prefix.length() > 0 ? (prefix + "." + property.Name) : property.Name;
-        if (const Schema_2x3::IfcPropertySingleValue* const singleValue = property.ToPtr<Schema_2x3::IfcPropertySingleValue>()) {
+    for (const Schema_2x3::IfcProperty &property : set) {
+        const std::string &key = prefix.length() > 0 ? (prefix + "." + property.Name) : property.Name;
+        if (const Schema_2x3::IfcPropertySingleValue *const singleValue = property.ToPtr<Schema_2x3::IfcPropertySingleValue>()) {
             if (singleValue->NominalValue) {
-                if (const ::Assimp::STEP::EXPRESS::STRING* str = singleValue->NominalValue.Get()->ToPtr<::Assimp::STEP::EXPRESS::STRING>()) {
+                if (const ::Assimp::STEP::EXPRESS::STRING *str = singleValue->NominalValue.Get()->ToPtr<::Assimp::STEP::EXPRESS::STRING>()) {
                     std::string value = static_cast<std::string>(*str);
-                    properties[key]=value;
-                }
-                else if (const ::Assimp::STEP::EXPRESS::REAL* val = singleValue->NominalValue.Get()->ToPtr<::Assimp::STEP::EXPRESS::REAL>()) {
-                    float value = static_cast<float>(*val);
+                    properties[key] = value;
+                } else if (const ::Assimp::STEP::EXPRESS::REAL *val1 = singleValue->NominalValue.Get()->ToPtr<::Assimp::STEP::EXPRESS::REAL>()) {
+                    float value = static_cast<float>(*val1);
                     std::stringstream s;
                     s << value;
-                    properties[key]=s.str();
-                }
-                else if (const ::Assimp::STEP::EXPRESS::INTEGER* val = singleValue->NominalValue.Get()->ToPtr<::Assimp::STEP::EXPRESS::INTEGER>()) {
-                    int64_t value = static_cast<int64_t>(*val);
+                    properties[key] = s.str();
+                } else if (const ::Assimp::STEP::EXPRESS::INTEGER *val2 = singleValue->NominalValue.Get()->ToPtr<::Assimp::STEP::EXPRESS::INTEGER>()) {
+                    int64_t curValue = static_cast<int64_t>(*val2);
                     std::stringstream s;
-                    s << value;
-                    properties[key]=s.str();
+                    s << curValue;
+                    properties[key] = s.str();
                 }
             }
-        }
-        else if (const Schema_2x3::IfcPropertyListValue* const listValue = property.ToPtr<Schema_2x3::IfcPropertyListValue>()) {
+        } else if (const Schema_2x3::IfcPropertyListValue *const listValue = property.ToPtr<Schema_2x3::IfcPropertyListValue>()) {
             std::stringstream ss;
             ss << "[";
-            unsigned index=0;
-            for(const Schema_2x3::IfcValue::Out& v : listValue->ListValues) {
+            unsigned index = 0;
+            for (const Schema_2x3::IfcValue::Out &v : listValue->ListValues) {
                 if (!v) continue;
-                if (const ::Assimp::STEP::EXPRESS::STRING* str = v->ToPtr<::Assimp::STEP::EXPRESS::STRING>()) {
+                if (const ::Assimp::STEP::EXPRESS::STRING *str = v->ToPtr<::Assimp::STEP::EXPRESS::STRING>()) {
                     std::string value = static_cast<std::string>(*str);
                     ss << "'" << value << "'";
-                }
-                else if (const ::Assimp::STEP::EXPRESS::REAL* val = v->ToPtr<::Assimp::STEP::EXPRESS::REAL>()) {
-                    float value = static_cast<float>(*val);
+                } else if (const ::Assimp::STEP::EXPRESS::REAL *val1 = v->ToPtr<::Assimp::STEP::EXPRESS::REAL>()) {
+                    float value = static_cast<float>(*val1);
+                    ss << value;
+                } else if (const ::Assimp::STEP::EXPRESS::INTEGER *val2 = v->ToPtr<::Assimp::STEP::EXPRESS::INTEGER>()) {
+                    int64_t value = static_cast<int64_t>(*val2);
                     ss << value;
                 }
-                else if (const ::Assimp::STEP::EXPRESS::INTEGER* val = v->ToPtr<::Assimp::STEP::EXPRESS::INTEGER>()) {
-                    int64_t value = static_cast<int64_t>(*val);
-                    ss << value;
-                }
-                if (index+1<listValue->ListValues.size()) {
+                if (index + 1 < listValue->ListValues.size()) {
                     ss << ",";
                 }
                 index++;
             }
             ss << "]";
-            properties[key]=ss.str();
-        }
-        else if (const Schema_2x3::IfcComplexProperty* const complexProp = property.ToPtr<Schema_2x3::IfcComplexProperty>()) {
-            if(nest > 2) { // mostly arbitrary limit to prevent stack overflow vulnerabilities
+            properties[key] = ss.str();
+        } else if (const Schema_2x3::IfcComplexProperty *const complexProp = property.ToPtr<Schema_2x3::IfcComplexProperty>()) {
+            if (nest > 2) { // mostly arbitrary limit to prevent stack overflow vulnerabilities
                 IFCImporter::LogError("maximum nesting level for IfcComplexProperty reached, skipping this property.");
-            }
-            else {
+            } else {
                 ProcessMetadata(complexProp->HasProperties, conv, properties, key, nest + 1);
             }
-        }
-        else {
-            properties[key]="";
+        } else {
+            properties[key] = std::string();
         }
     }
 }
 
-
 // ------------------------------------------------------------------------------------------------
-void ProcessMetadata(uint64_t relDefinesByPropertiesID, ConversionData& conv, Metadata& properties)
-{
-    if (const Schema_2x3::IfcRelDefinesByProperties* const pset = conv.db.GetObject(relDefinesByPropertiesID)->ToPtr<Schema_2x3::IfcRelDefinesByProperties>()) {
-        if (const Schema_2x3::IfcPropertySet* const set = conv.db.GetObject(pset->RelatingPropertyDefinition->GetID())->ToPtr<Schema_2x3::IfcPropertySet>()) {
+void ProcessMetadata(uint64_t relDefinesByPropertiesID, ConversionData &conv, Metadata &properties) {
+    if (const Schema_2x3::IfcRelDefinesByProperties *const pset = conv.db.GetObject(relDefinesByPropertiesID)->ToPtr<Schema_2x3::IfcRelDefinesByProperties>()) {
+        if (const Schema_2x3::IfcPropertySet *const set = conv.db.GetObject(pset->RelatingPropertyDefinition->GetID())->ToPtr<Schema_2x3::IfcPropertySet>()) {
             ProcessMetadata(set->HasProperties, conv, properties);
         }
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-aiNode* ProcessSpatialStructure(aiNode* parent, const Schema_2x3::IfcProduct& el, ConversionData& conv,
-        std::vector<TempOpening>* collect_openings = nullptr ) {
-    const STEP::DB::RefMap& refs = conv.db.GetRefs();
+aiNode *ProcessSpatialStructure(aiNode *parent, const Schema_2x3::IfcProduct &el, ConversionData &conv,
+        std::vector<TempOpening> *collect_openings = nullptr) {
+    const STEP::DB::RefMap &refs = conv.db.GetRefs();
 
     // skip over space and annotation nodes - usually, these have no meaning in Assimp's context
     bool skipGeometry = false;
-    if(conv.settings.skipSpaceRepresentations) {
-        if(el.ToPtr<Schema_2x3::IfcSpace>()) {
-            IFCImporter::LogDebug("skipping IfcSpace entity due to importer settings");
+    if (conv.settings.skipSpaceRepresentations) {
+        if (el.ToPtr<Schema_2x3::IfcSpace>()) {
+            IFCImporter::LogVerboseDebug("skipping IfcSpace entity due to importer settings");
             skipGeometry = true;
         }
     }
 
-    if(conv.settings.skipAnnotations) {
-        if(el.ToPtr<Schema_2x3::IfcAnnotation>()) {
-            IFCImporter::LogDebug("skipping IfcAnnotation entity due to importer settings");
+    if (conv.settings.skipAnnotations) {
+        if (el.ToPtr<Schema_2x3::IfcAnnotation>()) {
+            IFCImporter::LogVerboseDebug("skipping IfcAnnotation entity due to importer settings");
             return nullptr;
         }
     }
 
     // add an output node for this spatial structure
-    aiNode *nd(new aiNode );
-    nd->mName.Set(el.GetClassName()+"_"+(el.Name?el.Name.Get():"Unnamed")+"_"+el.GlobalId);
+    aiNode *nd(new aiNode);
+    nd->mName.Set(el.GetClassName() + "_" + (el.Name ? el.Name.Get() : "Unnamed") + "_" + el.GlobalId);
     nd->mParent = parent;
 
     conv.already_processed.insert(el.GetID());
 
     // check for node metadata
     STEP::DB::RefMapRange children = refs.equal_range(el.GetID());
-    if (children.first!=refs.end()) {
+    if (children.first != refs.end()) {
         Metadata properties;
-        if (children.first==children.second) {
+        if (children.first == children.second) {
             // handles single property set
             ProcessMetadata((*children.first).second, conv, properties);
         } else {
             // handles multiple property sets (currently all property sets are merged,
             // which may not be the best solution in the long run)
-            for (STEP::DB::RefMap::const_iterator it=children.first; it!=children.second; ++it) {
+            for (STEP::DB::RefMap::const_iterator it = children.first; it != children.second; ++it) {
                 ProcessMetadata((*it).second, conv, properties);
             }
         }
 
         if (!properties.empty()) {
-            aiMetadata* data = aiMetadata::Alloc( static_cast<unsigned int>(properties.size()) );
-            unsigned int index( 0 );
-            for ( const Metadata::value_type& kv : properties ) {
-                data->Set( index++, kv.first, aiString( kv.second ) );
+            aiMetadata *data = aiMetadata::Alloc(static_cast<unsigned int>(properties.size()));
+            unsigned int index(0);
+            for (const Metadata::value_type &kv : properties) {
+                data->Set(index++, kv.first, aiString(kv.second));
             }
             nd->mMetaData = data;
         }
     }
 
-    if(el.ObjectPlacement) {
-        ResolveObjectPlacement(nd->mTransformation,el.ObjectPlacement.Get(),conv);
+    if (el.ObjectPlacement) {
+        ResolveObjectPlacement(nd->mTransformation, el.ObjectPlacement.Get(), conv);
     }
 
     std::vector<TempOpening> openings;
@@ -737,44 +689,44 @@ aiNode* ProcessSpatialStructure(aiNode* parent, const Schema_2x3::IfcProduct& el
 
     // convert everything contained directly within this structure,
     // this may result in more nodes.
-    std::vector< aiNode* > subnodes;
+    std::vector<aiNode *> subnodes;
     try {
         // locate aggregates and 'contained-in-here'-elements of this spatial structure and add them in recursively
         // on our way, collect openings in *this* element
         STEP::DB::RefMapRange range = refs.equal_range(el.GetID());
 
-        for(STEP::DB::RefMapRange range2 = range; range2.first != range.second; ++range2.first) {
+        for (STEP::DB::RefMapRange range2 = range; range2.first != range.second; ++range2.first) {
             // skip over meshes that have already been processed before. This is strictly necessary
             // because the reverse indices also include references contained in argument lists and
             // therefore every element has a back-reference hold by its parent.
             if (conv.already_processed.find((*range2.first).second) != conv.already_processed.end()) {
                 continue;
             }
-            const STEP::LazyObject& obj = conv.db.MustGetObject((*range2.first).second);
+            const STEP::LazyObject &obj = conv.db.MustGetObject((*range2.first).second);
 
             // handle regularly-contained elements
-            if(const Schema_2x3::IfcRelContainedInSpatialStructure* const cont = obj->ToPtr<Schema_2x3::IfcRelContainedInSpatialStructure>()) {
-                if(cont->RelatingStructure->GetID() != el.GetID()) {
+            if (const Schema_2x3::IfcRelContainedInSpatialStructure *const cont = obj->ToPtr<Schema_2x3::IfcRelContainedInSpatialStructure>()) {
+                if (cont->RelatingStructure->GetID() != el.GetID()) {
                     continue;
                 }
-                for(const Schema_2x3::IfcProduct& pro : cont->RelatedElements) {
-                    if(pro.ToPtr<Schema_2x3::IfcOpeningElement>()) {
+                for (const Schema_2x3::IfcProduct &pro : cont->RelatedElements) {
+                    if (pro.ToPtr<Schema_2x3::IfcOpeningElement>()) {
                         // IfcOpeningElement is handled below. Sadly we can't use it here as is:
                         // The docs say that opening elements are USUALLY attached to building storey,
                         // but we want them for the building elements to which they belong.
                         continue;
                     }
 
-                    aiNode* const ndnew = ProcessSpatialStructure(nd,pro,conv,nullptr);
-                    if(ndnew) {
-                        subnodes.push_back( ndnew );
+                    aiNode *const ndnew = ProcessSpatialStructure(nd, pro, conv, nullptr);
+                    if (ndnew) {
+                        subnodes.push_back(ndnew);
                     }
                 }
             }
             // handle openings, which we collect in a list rather than adding them to the node graph
-            else if(const Schema_2x3::IfcRelVoidsElement* const fills = obj->ToPtr<Schema_2x3::IfcRelVoidsElement>()) {
-                if(fills->RelatingBuildingElement->GetID() == el.GetID()) {
-                    const Schema_2x3::IfcFeatureElementSubtraction& open = fills->RelatedOpeningElement;
+            else if (const Schema_2x3::IfcRelVoidsElement *const fills = obj->ToPtr<Schema_2x3::IfcRelVoidsElement>()) {
+                if (fills->RelatingBuildingElement->GetID() == el.GetID()) {
+                    const Schema_2x3::IfcFeatureElementSubtraction &open = fills->RelatedOpeningElement;
 
                     // move opening elements to a separate node since they are semantically different than elements that are just 'contained'
                     std::unique_ptr<aiNode> nd_aggr(new aiNode());
@@ -784,40 +736,39 @@ aiNode* ProcessSpatialStructure(aiNode* parent, const Schema_2x3::IfcProduct& el
                     nd_aggr->mTransformation = nd->mTransformation;
 
                     std::vector<TempOpening> openings_local;
-                    aiNode* const ndnew = ProcessSpatialStructure( nd_aggr.get(),open, conv,&openings_local);
+                    aiNode *const ndnew = ProcessSpatialStructure(nd_aggr.get(), open, conv, &openings_local);
                     if (ndnew) {
 
                         nd_aggr->mNumChildren = 1;
-                        nd_aggr->mChildren = new aiNode*[1]();
-
+                        nd_aggr->mChildren = new aiNode *[1]();
 
                         nd_aggr->mChildren[0] = ndnew;
 
-                        if(openings_local.size()) {
+                        if (openings_local.size()) {
                             if (!didinv) {
-                                myInv = aiMatrix4x4(nd->mTransformation ).Inverse();
+                                myInv = aiMatrix4x4(nd->mTransformation).Inverse();
                                 didinv = true;
                             }
 
                             // we need all openings to be in the local space of *this* node, so transform them
-                            for(TempOpening& op :openings_local) {
-                                op.Transform( myInv*nd_aggr->mChildren[0]->mTransformation);
+                            for (TempOpening &op : openings_local) {
+                                op.Transform(myInv * nd_aggr->mChildren[0]->mTransformation);
                                 openings.push_back(op);
                             }
                         }
-                        subnodes.push_back( nd_aggr.release() );
+                        subnodes.push_back(nd_aggr.release());
                     }
                 }
             }
         }
 
-        for(;range.first != range.second; ++range.first) {
+        for (; range.first != range.second; ++range.first) {
             // see note in loop above
             if (conv.already_processed.find((*range.first).second) != conv.already_processed.end()) {
                 continue;
             }
-            if(const Schema_2x3::IfcRelAggregates* const aggr = conv.db.GetObject((*range.first).second)->ToPtr<Schema_2x3::IfcRelAggregates>()) {
-                if(aggr->RelatingObject->GetID() != el.GetID()) {
+            if (const Schema_2x3::IfcRelAggregates *const aggr = conv.db.GetObject((*range.first).second)->ToPtr<Schema_2x3::IfcRelAggregates>()) {
+                if (aggr->RelatingObject->GetID() != el.GetID()) {
                     continue;
                 }
 
@@ -828,41 +779,41 @@ aiNode* ProcessSpatialStructure(aiNode* parent, const Schema_2x3::IfcProduct& el
 
                 nd_aggr->mTransformation = nd->mTransformation;
 
-                nd_aggr->mChildren = new aiNode*[aggr->RelatedObjects.size()]();
-                for(const Schema_2x3::IfcObjectDefinition& def : aggr->RelatedObjects) {
-                    if(const Schema_2x3::IfcProduct* const prod = def.ToPtr<Schema_2x3::IfcProduct>()) {
+                nd_aggr->mChildren = new aiNode *[aggr->RelatedObjects.size()]();
+                for (const Schema_2x3::IfcObjectDefinition &def : aggr->RelatedObjects) {
+                    if (const Schema_2x3::IfcProduct *const prod = def.ToPtr<Schema_2x3::IfcProduct>()) {
 
-                        aiNode* const ndnew = ProcessSpatialStructure(nd_aggr.get(),*prod,conv,NULL);
-                        if(ndnew) {
+                        aiNode *const ndnew = ProcessSpatialStructure(nd_aggr.get(), *prod, conv, nullptr);
+                        if (ndnew) {
                             nd_aggr->mChildren[nd_aggr->mNumChildren++] = ndnew;
                         }
                     }
                 }
 
-                subnodes.push_back( nd_aggr.release() );
+                subnodes.push_back(nd_aggr.release());
             }
         }
 
         conv.collect_openings = collect_openings;
-        if(!conv.collect_openings) {
+        if (!conv.collect_openings) {
             conv.apply_openings = &openings;
         }
 
         if (!skipGeometry) {
-          ProcessProductRepresentation(el, nd, subnodes, conv);
-          conv.apply_openings = conv.collect_openings = nullptr;
+            ProcessProductRepresentation(el, nd, subnodes, conv);
+            conv.apply_openings = conv.collect_openings = nullptr;
         }
 
         if (subnodes.size()) {
-            nd->mChildren = new aiNode*[subnodes.size()]();
-            for(aiNode* nd2 : subnodes) {
+            nd->mChildren = new aiNode *[subnodes.size()]();
+            for (aiNode *nd2 : subnodes) {
                 nd->mChildren[nd->mNumChildren++] = nd2;
                 nd2->mParent = nd;
             }
         }
-    } catch(...) {
+    } catch (...) {
         // it hurts, but I don't want to pull boost::ptr_vector into -noboost only for these few spots here
-        std::for_each(subnodes.begin(),subnodes.end(),delete_fun<aiNode>());
+        std::for_each(subnodes.begin(), subnodes.end(), delete_fun<aiNode>());
         throw;
     }
 
@@ -872,17 +823,15 @@ aiNode* ProcessSpatialStructure(aiNode* parent, const Schema_2x3::IfcProduct& el
 }
 
 // ------------------------------------------------------------------------------------------------
-void ProcessSpatialStructures(ConversionData& conv)
-{
+void ProcessSpatialStructures(ConversionData &conv) {
     // XXX add support for multiple sites (i.e. IfcSpatialStructureElements with composition == COMPLEX)
 
-
     // process all products in the file. it is reasonable to assume that a
     // file that is relevant for us contains at least a site or a building.
-    const STEP::DB::ObjectMapByType& map = conv.db.GetObjectsByType();
+    const STEP::DB::ObjectMapByType &map = conv.db.GetObjectsByType();
 
     ai_assert(map.find("ifcsite") != map.end());
-    const STEP::DB::ObjectSet* range = &map.find("ifcsite")->second;
+    const STEP::DB::ObjectSet *range = &map.find("ifcsite")->second;
 
     if (range->empty()) {
         ai_assert(map.find("ifcbuilding") != map.end());
@@ -893,75 +842,72 @@ void ProcessSpatialStructures(ConversionData& conv)
         }
     }
 
-	std::vector<aiNode*> nodes;
+    std::vector<aiNode *> nodes;
 
-    for(const STEP::LazyObject* lz : *range) {
-        const Schema_2x3::IfcSpatialStructureElement* const prod = lz->ToPtr<Schema_2x3::IfcSpatialStructureElement>();
-        if(!prod) {
+    for (const STEP::LazyObject *lz : *range) {
+        const Schema_2x3::IfcSpatialStructureElement *const prod = lz->ToPtr<Schema_2x3::IfcSpatialStructureElement>();
+        if (!prod) {
             continue;
         }
-        IFCImporter::LogDebug("looking at spatial structure `" + (prod->Name ? prod->Name.Get() : "unnamed") + "`" + (prod->ObjectType? " which is of type " + prod->ObjectType.Get():""));
+        IFCImporter::LogVerboseDebug("looking at spatial structure `", (prod->Name ? prod->Name.Get() : "unnamed"), "`", (prod->ObjectType ? " which is of type " + prod->ObjectType.Get() : ""));
 
         // the primary sites are referenced by an IFCRELAGGREGATES element which assigns them to the IFCPRODUCT
-        const STEP::DB::RefMap& refs = conv.db.GetRefs();
+        const STEP::DB::RefMap &refs = conv.db.GetRefs();
         STEP::DB::RefMapRange ref_range = refs.equal_range(conv.proj.GetID());
-        for(; ref_range.first != ref_range.second; ++ref_range.first) {
-            if(const Schema_2x3::IfcRelAggregates* const aggr = conv.db.GetObject((*ref_range.first).second)->ToPtr<Schema_2x3::IfcRelAggregates>()) {
+        for (; ref_range.first != ref_range.second; ++ref_range.first) {
+            if (const Schema_2x3::IfcRelAggregates *const aggr = conv.db.GetObject((*ref_range.first).second)->ToPtr<Schema_2x3::IfcRelAggregates>()) {
 
-                for(const Schema_2x3::IfcObjectDefinition& def : aggr->RelatedObjects) {
+                for (const Schema_2x3::IfcObjectDefinition &def : aggr->RelatedObjects) {
                     // comparing pointer values is not sufficient, we would need to cast them to the same type first
                     // as there is multiple inheritance in the game.
                     if (def.GetID() == prod->GetID()) {
-                        IFCImporter::LogDebug("selecting this spatial structure as root structure");
+                        IFCImporter::LogVerboseDebug("selecting this spatial structure as root structure");
                         // got it, this is one primary site.
-						nodes.push_back(ProcessSpatialStructure(NULL, *prod, conv, NULL));
+                        nodes.push_back(ProcessSpatialStructure(nullptr, *prod, conv, nullptr));
                     }
                 }
             }
         }
     }
 
-	size_t nb_nodes = nodes.size();
+    size_t nb_nodes = nodes.size();
 
-	if (nb_nodes == 0) {
-		IFCImporter::LogWarn("failed to determine primary site element, taking all the IfcSite");
-		for (const STEP::LazyObject* lz : *range) {
-			const Schema_2x3::IfcSpatialStructureElement* const prod = lz->ToPtr<Schema_2x3::IfcSpatialStructureElement>();
-			if (!prod) {
-				continue;
-			}
+    if (nb_nodes == 0) {
+        IFCImporter::LogWarn("failed to determine primary site element, taking all the IfcSite");
+        for (const STEP::LazyObject *lz : *range) {
+            const Schema_2x3::IfcSpatialStructureElement *const prod = lz->ToPtr<Schema_2x3::IfcSpatialStructureElement>();
+            if (!prod) {
+                continue;
+            }
 
-			nodes.push_back(ProcessSpatialStructure(NULL, *prod, conv, NULL));
-		}
+            nodes.push_back(ProcessSpatialStructure(nullptr, *prod, conv, nullptr));
+        }
 
-		nb_nodes = nodes.size();
-	}
+        nb_nodes = nodes.size();
+    }
 
-	if (nb_nodes == 1) {
-		conv.out->mRootNode = nodes[0];
-	}
-	else if (nb_nodes > 1) {
-		conv.out->mRootNode = new aiNode("Root");
-		conv.out->mRootNode->mParent = NULL;
-		conv.out->mRootNode->mNumChildren = static_cast<unsigned int>(nb_nodes);
-		conv.out->mRootNode->mChildren = new aiNode*[conv.out->mRootNode->mNumChildren];
+    if (nb_nodes == 1) {
+        conv.out->mRootNode = nodes[0];
+    } else if (nb_nodes > 1) {
+        conv.out->mRootNode = new aiNode("Root");
+        conv.out->mRootNode->mParent = nullptr;
+        conv.out->mRootNode->mNumChildren = static_cast<unsigned int>(nb_nodes);
+        conv.out->mRootNode->mChildren = new aiNode *[conv.out->mRootNode->mNumChildren];
 
-		for (size_t i = 0; i < nb_nodes; ++i) {
-			aiNode* node = nodes[i];
+        for (size_t i = 0; i < nb_nodes; ++i) {
+            aiNode *node = nodes[i];
 
-			node->mParent = conv.out->mRootNode;
+            node->mParent = conv.out->mRootNode;
 
-			conv.out->mRootNode->mChildren[i] = node;
-		}
-	}
-	else {
-		IFCImporter::ThrowException("failed to determine primary site element");
-	}
+            conv.out->mRootNode->mChildren[i] = node;
+        }
+    } else {
+        IFCImporter::ThrowException("failed to determine primary site element");
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
-void MakeTreeRelative(aiNode* start, const aiMatrix4x4& combined)
-{
+void MakeTreeRelative(aiNode *start, const aiMatrix4x4 &combined) {
     // combined is the parent's absolute transformation matrix
     const aiMatrix4x4 old = start->mTransformation;
 
@@ -971,18 +917,15 @@ void MakeTreeRelative(aiNode* start, const aiMatrix4x4& combined)
 
     // All nodes store absolute transformations right now, so we need to make them relative
     for (unsigned int i = 0; i < start->mNumChildren; ++i) {
-        MakeTreeRelative(start->mChildren[i],old);
+        MakeTreeRelative(start->mChildren[i], old);
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void MakeTreeRelative(ConversionData& conv)
-{
-    MakeTreeRelative(conv.out->mRootNode,IfcMatrix4());
+void MakeTreeRelative(ConversionData &conv) {
+    MakeTreeRelative(conv.out->mRootNode, IfcMatrix4());
 }
 
-} // !anon
-
-
+} // namespace
 
 #endif
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCLoader.h b/Engine/lib/assimp/code/AssetLib/IFC/IFCLoader.h
similarity index 74%
rename from Engine/lib/assimp/code/Importer/IFC/IFCLoader.h
rename to Engine/lib/assimp/code/AssetLib/IFC/IFCLoader.h
index 678c60343..7b2c3aae6 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCLoader.h
+++ b/Engine/lib/assimp/code/AssetLib/IFC/IFCLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -49,18 +49,22 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/BaseImporter.h>
 #include <assimp/LogAux.h>
 
-namespace Assimp    {
+namespace Assimp {
 
-    // TinyFormatter.h
-    namespace Formatter {
-        template <typename T,typename TR, typename A> class basic_formatter;
-        typedef class basic_formatter< char, std::char_traits<char>, std::allocator<char> > format;
-    }
+// TinyFormatter.h
+namespace Formatter {
 
-    namespace STEP {
-        class DB;
-    }
+template <typename T, typename TR, typename A>
+class basic_formatter;
+typedef class basic_formatter<char, std::char_traits<char>, std::allocator<char>> format;
 
+} // namespace Formatter
+
+namespace STEP {
+
+class DB;
+
+}
 
 // -------------------------------------------------------------------------------------------
 /** Load the IFC format, which is an open specification to describe building and construction
@@ -69,63 +73,41 @@ namespace Assimp    {
  See http://en.wikipedia.org/wiki/Industry_Foundation_Classes
 */
 // -------------------------------------------------------------------------------------------
-class IFCImporter : public BaseImporter, public LogFunctions<IFCImporter>
-{
+class IFCImporter : public BaseImporter, public LogFunctions<IFCImporter> {
 public:
-    IFCImporter();
-    ~IFCImporter();
-
-
-public:
-
-    // --------------------
-    bool CanRead( const std::string& pFile,
-        IOSystem* pIOHandler,
-        bool checkSig
-    ) const;
-
-protected:
-
-    // --------------------
-    const aiImporterDesc* GetInfo () const;
-
-    // --------------------
-    void SetupProperties(const Importer* pImp);
-
-    // --------------------
-    void InternReadFile( const std::string& pFile,
-        aiScene* pScene,
-        IOSystem* pIOHandler
-    );
-
-private:
-
-
-public:
-
-
     // loader settings, publicly accessible via their corresponding AI_CONFIG constants
-    struct Settings
-    {
-        Settings()
-            : skipSpaceRepresentations()
-            , useCustomTriangulation()
-            , skipAnnotations()
-            , conicSamplingAngle(10.f)
-			, cylindricalTessellation(32)
-        {}
-
+    struct Settings {
+        Settings() :
+                skipSpaceRepresentations(), useCustomTriangulation(), skipAnnotations(), conicSamplingAngle(10.f), cylindricalTessellation(32) {}
 
         bool skipSpaceRepresentations;
         bool useCustomTriangulation;
         bool skipAnnotations;
         float conicSamplingAngle;
-		int cylindricalTessellation;
+        int cylindricalTessellation;
     };
 
+    IFCImporter();
+    ~IFCImporter() override;
+
+    // --------------------
+    bool CanRead(const std::string &pFile,
+            IOSystem *pIOHandler,
+            bool checkSig) const override;
+
+protected:
+    // --------------------
+    const aiImporterDesc *GetInfo() const override;
+
+    // --------------------
+    void SetupProperties(const Importer *pImp) override;
+
+    // --------------------
+    void InternReadFile(const std::string &pFile,
+            aiScene *pScene,
+            IOSystem *pIOHandler) override;
 
 private:
-
     Settings settings;
 
 }; // !class IFCImporter
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCMaterial.cpp b/Engine/lib/assimp/code/AssetLib/IFC/IFCMaterial.cpp
similarity index 95%
rename from Engine/lib/assimp/code/Importer/IFC/IFCMaterial.cpp
rename to Engine/lib/assimp/code/AssetLib/IFC/IFCMaterial.cpp
index 5fda0a1de..6cd0e5910 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCMaterial.cpp
+++ b/Engine/lib/assimp/code/AssetLib/IFC/IFCMaterial.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -64,7 +64,7 @@ static int ConvertShadingMode(const std::string& name) {
     else if (name == "PHONG") {
         return aiShadingMode_Phong;
     }
-    IFCImporter::LogWarn("shading mode "+name+" not recognized by Assimp, using Phong instead");
+    IFCImporter::LogWarn("shading mode ", name, " not recognized by Assimp, using Phong instead");
     return aiShadingMode_Phong;
 }
 
@@ -75,7 +75,7 @@ static void FillMaterial(aiMaterial* mat,const IFC::Schema_2x3::IfcSurfaceStyle*
     mat->AddProperty(&name,AI_MATKEY_NAME);
 
     // now see which kinds of surface information are present
-    for(std::shared_ptr< const IFC::Schema_2x3::IfcSurfaceStyleElementSelect > sel2 : surf->Styles) {
+    for (const std::shared_ptr<const IFC::Schema_2x3::IfcSurfaceStyleElementSelect> &sel2 : surf->Styles) {
         if (const IFC::Schema_2x3::IfcSurfaceStyleShading* shade = sel2->ResolveSelectPtr<IFC::Schema_2x3::IfcSurfaceStyleShading>(conv.db)) {
             aiColor4D col_base,col;
 
@@ -124,7 +124,7 @@ static void FillMaterial(aiMaterial* mat,const IFC::Schema_2x3::IfcSurfaceStyle*
                     }
                 }
             }
-        } 
+        }
     }
 }
 
@@ -134,7 +134,7 @@ unsigned int ProcessMaterials(uint64_t id, unsigned int prevMatId, ConversionDat
     for(;range.first != range.second; ++range.first) {
         if(const IFC::Schema_2x3::IfcStyledItem* const styled = conv.db.GetObject((*range.first).second)->ToPtr<IFC::Schema_2x3::IfcStyledItem>()) {
             for(const IFC::Schema_2x3::IfcPresentationStyleAssignment& as : styled->Styles) {
-                for(std::shared_ptr<const IFC::Schema_2x3::IfcPresentationStyleSelect> sel : as.Styles) {
+                for (const std::shared_ptr<const IFC::Schema_2x3::IfcPresentationStyleSelect> &sel : as.Styles) {
 
                     if( const IFC::Schema_2x3::IfcSurfaceStyle* const surf = sel->ResolveSelectPtr<IFC::Schema_2x3::IfcSurfaceStyle>(conv.db) ) {
                         // try to satisfy from cache
@@ -145,7 +145,7 @@ unsigned int ProcessMaterials(uint64_t id, unsigned int prevMatId, ConversionDat
                         // not found, create new material
                         const std::string side = static_cast<std::string>(surf->Side);
                         if( side != "BOTH" ) {
-                            IFCImporter::LogWarn("ignoring surface side marker on IFC::IfcSurfaceStyle: " + side);
+                            IFCImporter::LogWarn("ignoring surface side marker on IFC::IfcSurfaceStyle: ", side);
                         }
 
                         std::unique_ptr<aiMaterial> mat(new aiMaterial());
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCOpenings.cpp b/Engine/lib/assimp/code/AssetLib/IFC/IFCOpenings.cpp
similarity index 82%
rename from Engine/lib/assimp/code/Importer/IFC/IFCOpenings.cpp
rename to Engine/lib/assimp/code/AssetLib/IFC/IFCOpenings.cpp
index d6c40b383..74200195b 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCOpenings.cpp
+++ b/Engine/lib/assimp/code/AssetLib/IFC/IFCOpenings.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2010, assimp team
+Copyright (c) 2006-2022, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -58,6 +58,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #endif
 
 #include <iterator>
+#include <forward_list>
+#include <deque>
 
 namespace Assimp {
     namespace IFC {
@@ -73,7 +75,7 @@ namespace Assimp {
 
 
         // fallback method to generate wall openings
-        bool TryAddOpenings_Poly2Tri(const std::vector<TempOpening>& openings,const std::vector<IfcVector3>& nors,
+        bool TryAddOpenings_Poly2Tri(const std::vector<TempOpening>& openings,
             TempMesh& curmesh);
 
 
@@ -294,7 +296,7 @@ void InsertWindowContours(const ContourVector& contours,
         const IfcFloat epsilon = diag/1000.f;
 
         // walk through all contour points and find those that lie on the BB corner
-        size_t last_hit = -1, very_first_hit = -1;
+        size_t last_hit = (size_t)-1, very_first_hit = (size_t)-1;
         IfcVector2 edge;
         for(size_t n = 0, e=0, size = contour.size();; n=(n+1)%size, ++e) {
 
@@ -330,7 +332,7 @@ void InsertWindowContours(const ContourVector& contours,
 
                     const size_t old = curmesh.mVerts.size();
                     size_t cnt = last_hit > n ? size-(last_hit-n) : n-last_hit;
-                    for(size_t a = last_hit, e = 0; e <= cnt; a=(a+1)%size, ++e) {
+                    for(size_t a = last_hit, ee = 0; ee <= cnt; a=(a+1)%size, ++ee) {
                         // hack: this is to fix cases where opening contours are self-intersecting.
                         // Clipper doesn't produce such polygons, but as soon as we're back in
                         // our brave new floating-point world, very small distances are consumed
@@ -911,14 +913,14 @@ size_t CloseWindows(ContourVector& contours,
             // compare base poly normal and contour normal to detect if we need to reverse the face winding
 			if(curmesh.mVertcnt.size() > 0) {
 				IfcVector3 basePolyNormal = TempMesh::ComputePolygonNormal(curmesh.mVerts.data(), curmesh.mVertcnt.front());
-				
+
 				std::vector<IfcVector3> worldSpaceContourVtx(it->contour.size());
-				
+
 				for(size_t a = 0; a < it->contour.size(); ++a)
 					worldSpaceContourVtx[a] = minv * IfcVector3(it->contour[a].x, it->contour[a].y, 0.0);
-				
+
 				IfcVector3 contourNormal = TempMesh::ComputePolygonNormal(worldSpaceContourVtx.data(), worldSpaceContourVtx.size());
-				
+
 				reverseCountourFaces = (contourNormal * basePolyNormal) > 0.0;
 			}
 
@@ -1131,7 +1133,7 @@ IfcMatrix4 ProjectOntoPlane(std::vector<IfcVector2>& out_contour, const TempMesh
     }
 
     for(size_t i = 0; i < out_contour.size(); ++i) {
-        ai_assert((out_contour[i]-out_contour2[i]).SquareLength() < 1e-6);
+        ai_assert((out_contour[i] - out_contour2[i]).SquareLength() < ai_epsilon);
     }
 #endif
 
@@ -1140,7 +1142,6 @@ IfcMatrix4 ProjectOntoPlane(std::vector<IfcVector2>& out_contour, const TempMesh
 
 // ------------------------------------------------------------------------------------------------
 bool GenerateOpenings(std::vector<TempOpening>& openings,
-    const std::vector<IfcVector3>& nors,
     TempMesh& curmesh,
     bool check_intersection,
     bool generate_connection_geometry,
@@ -1189,20 +1190,9 @@ bool GenerateOpenings(std::vector<TempOpening>& openings,
         TempMesh* profile_data =  opening.profileMesh.get();
         bool is_2d_source = false;
         if (opening.profileMesh2D && norm_extrusion_dir.SquareLength() > 0) {
-
-            if(std::fabs(norm_extrusion_dir * wall_extrusion_axis_norm) < 0.1) {
-                // horizontal extrusion
-                if (std::fabs(norm_extrusion_dir * nor) > 0.9) {
-                    profile_data = opening.profileMesh2D.get();
-                    is_2d_source = true;
-                }
-            }
-            else {
-                // vertical extrusion
-                if (std::fabs(norm_extrusion_dir * nor) > 0.9) {
-                    profile_data = opening.profileMesh2D.get();
-                    is_2d_source = true;
-                }
+            if (std::fabs(norm_extrusion_dir * nor) > 0.9) {
+                profile_data = opening.profileMesh2D.get();
+                is_2d_source = true;
             }
         }
         std::vector<IfcVector3> profile_verts = profile_data->mVerts;
@@ -1351,7 +1341,7 @@ bool GenerateOpenings(std::vector<TempOpening>& openings,
                 MergeWindowContours(temp_contour, other, poly);
 
                 if (poly.size() > 1) {
-                    return TryAddOpenings_Poly2Tri(openings, nors, curmesh);
+                    return TryAddOpenings_Poly2Tri(openings, curmesh);
                 }
                 else if (poly.size() == 0) {
                     IFCImporter::LogWarn("ignoring duplicate opening");
@@ -1359,7 +1349,7 @@ bool GenerateOpenings(std::vector<TempOpening>& openings,
                     break;
                 }
                 else {
-                    IFCImporter::LogDebug("merging overlapping openings");
+                    IFCImporter::LogVerboseDebug("merging overlapping openings");
                     ExtractVerticesFromClipper(poly[0].outer, temp_contour, false);
 
                     // Generate the union of the bounding boxes
@@ -1438,8 +1428,289 @@ bool GenerateOpenings(std::vector<TempOpening>& openings,
     return true;
 }
 
+std::vector<IfcVector2> GetContourInPlane2D(std::shared_ptr<TempMesh> mesh,IfcMatrix3 planeSpace,
+    IfcVector3 planeNor,IfcFloat planeOffset,
+    IfcVector3 extrusionDir,IfcVector3& wall_extrusion,bool& first,bool& ok) {
+    std::vector<IfcVector2> contour;
+
+    const auto outernor = ((mesh->mVerts[2] - mesh->mVerts[0]) ^ (mesh->mVerts[1] - mesh->mVerts[0])).Normalize();
+    const IfcFloat dot = planeNor * outernor;
+    if (std::fabs(dot) < 1.f - ai_epsilon) {
+        std::stringstream msg;
+        msg << "Skipping: Unaligned opening (" << planeNor.x << ", " << planeNor.y << ", " << planeNor.z << ")";
+        msg << " . ( " << outernor.x << ", " << outernor.y << ", " << outernor.z << ") = " << dot;
+        IFCImporter::LogDebug(msg.str().c_str());
+        ok = false;
+        return contour;
+    }
+
+    const std::vector<IfcVector3>& va = mesh->mVerts;
+    if(va.size() <= 2) {
+        std::stringstream msg;
+        msg << "Skipping: Only " << va.size() << " verticies in opening mesh.";
+        IFCImporter::LogDebug(msg.str().c_str());
+        ok = false;
+        return contour;
+    }
+
+    for(const IfcVector3& xx : mesh->mVerts) {
+        IfcVector3 vv = planeSpace * xx,vv_extr = planeSpace * (xx + extrusionDir);
+
+        const bool is_extruded_side = std::fabs(vv.z - planeOffset) > std::fabs(vv_extr.z - planeOffset);
+        if(first) {
+            first = false;
+            if(dot > 0.f) {
+                wall_extrusion = extrusionDir;
+                if(is_extruded_side) {
+                    wall_extrusion = -wall_extrusion;
+                }
+            }
+        }
+
+        // XXX should not be necessary - but it is. Why? For precision reasons?
+        vv = is_extruded_side ? vv_extr : vv;
+        contour.push_back(IfcVector2(vv.x,vv.y));
+    }
+    ok = true;
+
+    return contour;
+}
+
+const float close{ ai_epsilon };
+
+static bool isClose(IfcVector2 first,IfcVector2 second) {
+    auto diff = (second - first);
+    return (std::fabs(diff.x) < close && std::fabs(diff.y) < close);
+}
+
+static void logSegment(std::pair<IfcVector2,IfcVector2> segment) {
+    std::stringstream msg2;
+    msg2 << " Segment: \n";
+    msg2 << "   " << segment.first.x << " " << segment.first.y << " \n";
+    msg2 << "   " << segment.second.x << " " << segment.second.y << " \n";
+    IFCImporter::LogInfo(msg2.str().c_str());
+}
+
+std::vector<std::vector<IfcVector2>> GetContoursInPlane3D(std::shared_ptr<TempMesh> mesh,IfcMatrix3 planeSpace,
+    IfcFloat planeOffset) {
+
+        {
+            std::stringstream msg;
+            msg << "GetContoursInPlane3D: planeSpace is \n";
+            msg << planeSpace.a1 << " " << planeSpace.a2 << " " << planeSpace.a3 << " " << "\n";
+            msg << planeSpace.b1 << " " << planeSpace.b2 << " " << planeSpace.b3 << " " << "\n";
+            msg << planeSpace.c1 << " " << planeSpace.c2 << " " << planeSpace.c3 << " " << "\n";
+            msg << "\n planeOffset is " << planeOffset;
+            IFCImporter::LogInfo(msg.str().c_str());
+        }
+
+        // we'll put our line segments in here, and then merge them together into contours later
+        std::deque<std::pair<IfcVector2,IfcVector2>> lineSegments;
+
+        // find the lines giving the intersection of the faces with the plane - we'll work in planeSpace throughout.
+        size_t vI0{ 0 }; // vertex index for first vertex in plane
+        for(auto nVertices : mesh->mVertcnt) { // iterate over faces
+            {
+                std::stringstream msg;
+                msg << "GetContoursInPlane3D: face (transformed) is  \n";
+                for(auto vI = vI0; vI < vI0 + nVertices; vI++) {
+                    auto v = planeSpace * mesh->mVerts[vI];
+                    msg << "   " << v.x << " " << v.y << " " << v.z << " " << "\n";
+                }
+                IFCImporter::LogInfo(msg.str().c_str());
+            }
+
+            if(nVertices <= 2) // not a plane, a point or line
+            {
+                std::stringstream msg;
+                msg << "GetContoursInPlane3D: found point or line when expecting plane (only " << nVertices << " vertices)";
+                IFCImporter::LogWarn(msg.str().c_str());
+                vI0 += nVertices;
+                continue;
+            }
+
+            auto v0 = planeSpace * mesh->mVerts[vI0];
+
+            // now calculate intersections between face and plane
+            IfcVector2 firstPoint;
+            bool gotFirstPoint(false);
+
+            if(std::fabs(v0.z - planeOffset) < close) {
+                // first point is on the plane
+                firstPoint.x = v0.x;
+                firstPoint.y = v0.y;
+                gotFirstPoint = true;
+            }
+
+            auto vn = v0;
+            for(auto vI = vI0 + 1; vI < vI0 + nVertices; vI++) {
+                auto vp = vn;
+                vn = planeSpace * mesh->mVerts[vI];
+                IfcVector3 intersection;
+
+                if(std::fabs(vn.z - planeOffset) < close) {
+                    // on the plane
+                    intersection = vn;
+                }
+                else if((vn.z > planeOffset) != (vp.z > planeOffset))
+                {
+                    // passes through the plane
+                    auto vdir = vn - vp;
+                    auto scale = (planeOffset - vp.z) / vdir.z;
+                    intersection = vp + scale * vdir;
+                }
+                else {
+                    // nowhere near - move on
+                    continue;
+                }
+
+                if(!gotFirstPoint) {
+                    if(std::fabs(vp.z - planeOffset) < close) {
+                        // just had a second line along the plane
+                        firstPoint.x = vp.x;
+                        firstPoint.y = vp.y;
+                        IfcVector2 secondPoint(intersection.x,intersection.y);
+                        auto s = std::pair<IfcVector2,IfcVector2>(firstPoint,secondPoint);
+                        logSegment(s);
+                        lineSegments.push_back(s);
+                        // next firstpoint should be this one
+                    }
+                    else {
+                        // store the first intersection point
+                        firstPoint.x = intersection.x;
+                        firstPoint.y = intersection.y;
+                        gotFirstPoint = true;
+                    }
+                }
+                else {
+                    // now got the second point, so store the pair
+                    IfcVector2 secondPoint(intersection.x,intersection.y);
+                    auto s = std::pair<IfcVector2,IfcVector2>(firstPoint,secondPoint);
+                    logSegment(s);
+                    lineSegments.push_back(s);
+
+                    // - note that we don't move onto the next face as a non-convex face can create two or more intersections with a plane
+                    gotFirstPoint = false;
+                }
+            }
+            if(gotFirstPoint) {
+                IFCImporter::LogWarn("GetContoursInPlane3D: odd number of intersections with plane");
+            }
+            vI0 += nVertices;
+        }
+
+        {
+            std::stringstream msg;
+            msg << "GetContoursInPlane3D: found " << lineSegments.size() << " line segments:\n";
+            IFCImporter::LogInfo(msg.str().c_str());
+
+            for(auto& s : lineSegments) {
+                logSegment(s);
+            }
+
+        }
+
+        // now merge contours until we have the best-looking polygons we can
+        std::vector<Contour> contours;
+        while(!lineSegments.empty()) {
+            // start with a polygon and make the best closed contour we can
+            const auto& firstSeg = lineSegments.front();
+            std::deque<IfcVector2> contour{ firstSeg.first, firstSeg.second };
+            lineSegments.pop_front();
+            bool foundNextPoint{ true };
+            bool closedContour{ false };
+            while(foundNextPoint) {
+                foundNextPoint = false;
+                for(auto nextSeg = lineSegments.begin(); nextSeg != lineSegments.end(); nextSeg++) {
+                    // see if we can match up both ends - in which case we've closed the contour
+                    if((isClose(contour.front(),nextSeg->first) && isClose(contour.back(),nextSeg->second)) ||
+                        (isClose(contour.back(),nextSeg->first) && isClose(contour.front(),nextSeg->second))
+                        ) {
+                        lineSegments.erase(nextSeg);
+                        closedContour = true;
+                        break;
+                    }
+
+                    // otherwise, see if we can match up either end
+                    foundNextPoint = true;
+                    if(isClose(contour.front(),nextSeg->first)) {
+                        contour.push_front(nextSeg->second);
+                    }
+                    else if(isClose(contour.front(),nextSeg->second)) {
+                        contour.push_front(nextSeg->first);
+                    }
+                    else if(isClose(contour.back(),nextSeg->first)) {
+                        contour.push_back(nextSeg->second);
+                    }
+                    else if(isClose(contour.back(),nextSeg->second)) {
+                        contour.push_back(nextSeg->first);
+                    }
+                    else {
+                        foundNextPoint = false;
+                    }
+                    if(foundNextPoint) {
+                        lineSegments.erase(nextSeg);
+                        break;
+                    }
+                }
+            }
+
+            if(!closedContour) {
+                IFCImporter::LogWarn("GetContoursInPlane3D: did not close contour");
+            }
+
+            // now add the contour if we can
+            if(contour.size() <= 2) {
+                IFCImporter::LogWarn("GetContoursInPlane3D: discarding line/point contour");
+                continue;
+            }
+            Contour c{};
+            for(auto p : contour)
+            {
+                c.push_back(p);
+            }
+            contours.push_back(c);
+        }
+
+        {
+            std::stringstream msg;
+            msg << "GetContoursInPlane3D: found " << contours.size() << " contours:\n";
+
+            for(auto c : contours) {
+                msg << " Contour: \n";
+                for(auto p : c) {
+                    msg << "   " << p.x << " " << p.y << " \n";
+                }
+            }
+
+            IFCImporter::LogInfo(msg.str().c_str());
+        }
+
+
+        return contours;
+}
+
+std::vector<std::vector<IfcVector2>> GetContoursInPlane(std::shared_ptr<TempMesh> mesh,IfcMatrix3 planeSpace,
+    IfcVector3 planeNor,IfcFloat planeOffset,
+    IfcVector3 extrusionDir,IfcVector3& wall_extrusion,bool& first) {
+
+    if(mesh->mVertcnt.size() == 1)
+    {
+        bool ok;
+        auto contour = GetContourInPlane2D(mesh,planeSpace,planeNor,planeOffset,extrusionDir,wall_extrusion,first,ok);
+        if(ok)
+            return std::vector<std::vector<IfcVector2>> {contour};
+        else
+            return std::vector<std::vector<IfcVector2>> {};
+    }
+    else
+    {
+        return GetContoursInPlane3D(mesh,planeSpace,planeOffset);
+    }
+}
+
 // ------------------------------------------------------------------------------------------------
-bool TryAddOpenings_Poly2Tri(const std::vector<TempOpening>& openings,const std::vector<IfcVector3>& nors,
+bool TryAddOpenings_Poly2Tri(const std::vector<TempOpening>& openings,
     TempMesh& curmesh)
 {
     IFCImporter::LogWarn("forced to use poly2tri fallback method to generate wall openings");
@@ -1509,61 +1780,41 @@ bool TryAddOpenings_Poly2Tri(const std::vector<TempOpening>& openings,const std:
     try {
 
         ClipperLib::Clipper clipper_holes;
-        size_t c = 0;
 
-        for(const TempOpening& t :openings) {
-            const IfcVector3& outernor = nors[c++];
-            const IfcFloat dot = nor * outernor;
-            if (std::fabs(dot)<1.f-1e-6f) {
-                continue;
-            }
+        for(const TempOpening& t : openings) {
+            auto contours = GetContoursInPlane(t.profileMesh,m,nor,coord,t.extrusionDir,wall_extrusion,first);
 
-            const std::vector<IfcVector3>& va = t.profileMesh->mVerts;
-            if(va.size() <= 2) {
-                continue;
-            }
+            for(auto& contour : contours) {
+                // scale to clipping space
+                ClipperLib::Polygon hole;
+                for(IfcVector2& pip : contour) {
+                    pip.x = (pip.x - vmin.x) / vmax.x;
+                    pip.y = (pip.y - vmin.y) / vmax.y;
 
-            std::vector<IfcVector2> contour;
-
-            for(const IfcVector3& xx : t.profileMesh->mVerts) {
-                IfcVector3 vv = m *  xx, vv_extr = m * (xx + t.extrusionDir);
-
-                const bool is_extruded_side = std::fabs(vv.z - coord) > std::fabs(vv_extr.z - coord);
-                if (first) {
-                    first = false;
-                    if (dot > 0.f) {
-                        wall_extrusion = t.extrusionDir;
-                        if (is_extruded_side) {
-                            wall_extrusion = - wall_extrusion;
-                        }
-                    }
+                    hole.push_back(ClipperLib::IntPoint(to_int64(pip.x),to_int64(pip.y)));
                 }
 
-                // XXX should not be necessary - but it is. Why? For precision reasons?
-                vv = is_extruded_side ? vv_extr : vv;
-                contour.push_back(IfcVector2(vv.x,vv.y));
+                if(!ClipperLib::Orientation(hole)) {
+                    std::reverse(hole.begin(),hole.end());
+                    //  assert(ClipperLib::Orientation(hole));
+                }
+
+                /*ClipperLib::Polygons pol_temp(1), pol_temp2(1);
+                pol_temp[0] = hole;
+
+                ClipperLib::OffsetPolygons(pol_temp,pol_temp2,5.0);
+                hole = pol_temp2[0];*/
+
+                clipper_holes.AddPolygon(hole,ClipperLib::ptSubject);
+                {
+                    std::stringstream msg;
+                    msg << "- added polygon ";
+                    for(auto elem : hole) {
+                        msg << " (" << elem.X << ", " << elem.Y << ")";
+                    }
+                    IFCImporter::LogDebug(msg.str().c_str());
+                }
             }
-
-            ClipperLib::Polygon hole;
-            for(IfcVector2& pip : contour) {
-                pip.x  = (pip.x - vmin.x) / vmax.x;
-                pip.y  = (pip.y - vmin.y) / vmax.y;
-
-                hole.push_back(ClipperLib::IntPoint(  to_int64(pip.x), to_int64(pip.y) ));
-            }
-
-            if (!ClipperLib::Orientation(hole)) {
-                std::reverse(hole.begin(), hole.end());
-            //  assert(ClipperLib::Orientation(hole));
-            }
-
-            /*ClipperLib::Polygons pol_temp(1), pol_temp2(1);
-            pol_temp[0] = hole;
-
-            ClipperLib::OffsetPolygons(pol_temp,pol_temp2,5.0);
-            hole = pol_temp2[0];*/
-
-            clipper_holes.AddPolygon(hole,ClipperLib::ptSubject);
         }
 
         clipper_holes.Execute(ClipperLib::ctUnion,holes_union,
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCProfile.cpp b/Engine/lib/assimp/code/AssetLib/IFC/IFCProfile.cpp
similarity index 96%
rename from Engine/lib/assimp/code/Importer/IFC/IFCProfile.cpp
rename to Engine/lib/assimp/code/AssetLib/IFC/IFCProfile.cpp
index daafc9afe..aa31124ed 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCProfile.cpp
+++ b/Engine/lib/assimp/code/AssetLib/IFC/IFCProfile.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -68,7 +68,7 @@ bool ProcessCurve(const Schema_2x3::IfcCurve& curve,  TempMesh& meshout, Convers
 {
     std::unique_ptr<const Curve> cv(Curve::Convert(curve,conv));
     if (!cv) {
-        IFCImporter::LogWarn("skipping unknown IfcCurve entity, type is " + curve.GetClassName());
+        IFCImporter::LogWarn("skipping unknown IfcCurve entity, type is ", curve.GetClassName());
         return false;
     }
 
@@ -78,7 +78,7 @@ bool ProcessCurve(const Schema_2x3::IfcCurve& curve,  TempMesh& meshout, Convers
             bc->SampleDiscrete(meshout);
         }
         catch(const  CurveError& cv) {
-            IFCImporter::LogError(cv.mStr + " (error occurred while processing curve)");
+            IFCImporter::LogError(cv.mStr, " (error occurred while processing curve)");
             return false;
         }
         meshout.mVertcnt.push_back(static_cast<unsigned int>(meshout.mVerts.size()));
@@ -152,7 +152,7 @@ void ProcessParametrizedProfile(const Schema_2x3::IfcParameterizedProfileDef& de
         meshout.mVertcnt.push_back(12);
     }
     else {
-        IFCImporter::LogWarn("skipping unknown IfcParameterizedProfileDef entity, type is " + def.GetClassName());
+        IFCImporter::LogWarn("skipping unknown IfcParameterizedProfileDef entity, type is ", def.GetClassName());
         return;
     }
 
@@ -174,7 +174,7 @@ bool ProcessProfile(const Schema_2x3::IfcProfileDef& prof, TempMesh& meshout, Co
         ProcessParametrizedProfile(*cparam,meshout,conv);
     }
     else {
-        IFCImporter::LogWarn("skipping unknown IfcProfileDef entity, type is " + prof.GetClassName());
+        IFCImporter::LogWarn("skipping unknown IfcProfileDef entity, type is ", prof.GetClassName());
         return false;
     }
     meshout.RemoveAdjacentDuplicates();
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen1_2x3.cpp b/Engine/lib/assimp/code/AssetLib/IFC/IFCReaderGen1_2x3.cpp
similarity index 91%
rename from Engine/lib/assimp/code/Importer/IFC/IFCReaderGen1_2x3.cpp
rename to Engine/lib/assimp/code/AssetLib/IFC/IFCReaderGen1_2x3.cpp
index f4dbed1d1..a6f7ae3eb 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen1_2x3.cpp
+++ b/Engine/lib/assimp/code/AssetLib/IFC/IFCReaderGen1_2x3.cpp
@@ -2,11 +2,11 @@
 Open Asset Import Library (ASSIMP)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2010, ASSIMP Development Team
+Copyright (c) 2006-2020, ASSIMP Development Team
 All rights reserved.
 
-Redistribution and use of this software in source and binary forms, 
-with or without modification, are permitted provided that the 
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
 following conditions are met:
 
 * Redistributions of source code must retain the above
@@ -23,16 +23,16 @@ following conditions are met:
   derived from this software without specific prior
   written permission of the ASSIMP Development Team.
 
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 ----------------------------------------------------------------------
@@ -45,6 +45,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "IFCReaderGen_2x3.h"
 
+#if _MSC_VER
+#    pragma warning(push)
+#    pragma warning(disable : 4702)
+#endif // _MSC_VER
+
 namespace Assimp {
 
 using namespace ::Assimp::IFC;
@@ -54,333 +59,333 @@ namespace {
 	typedef EXPRESS::ConversionSchema::SchemaEntry SchemaEntry;
 
     static const SchemaEntry schema_raw_2x3[] =  {
-		SchemaEntry("ifcstairtypeenum",NULL )
-,		SchemaEntry("ifcspacetypeenum",NULL )
-,		SchemaEntry("ifcwalltypeenum",NULL )
-,		SchemaEntry("ifcmonthinyearnumber",NULL )
-,		SchemaEntry("ifcheatfluxdensitymeasure",NULL )
-,		SchemaEntry("ifckinematicviscositymeasure",NULL )
-,		SchemaEntry("ifcsequenceenum",NULL )
-,		SchemaEntry("ifcairtoairheatrecoverytypeenum",NULL )
-,		SchemaEntry("ifcactorselect",NULL )
-,		SchemaEntry("ifctransformertypeenum",NULL )
-,		SchemaEntry("ifcunitaryequipmenttypeenum",NULL )
-,		SchemaEntry("ifcelectricflowstoragedevicetypeenum",NULL )
-,		SchemaEntry("ifcenergysequenceenum",NULL )
-,		SchemaEntry("ifcworkcontroltypeenum",NULL )
-,		SchemaEntry("ifccurvaturemeasure",NULL )
-,		SchemaEntry("ifcparametervalue",NULL )
-,		SchemaEntry("ifcappliedvalueselect",NULL )
-,		SchemaEntry("ifcwarpingconstantmeasure",NULL )
-,		SchemaEntry("ifcarithmeticoperatorenum",NULL )
-,		SchemaEntry("ifclinearforcemeasure",NULL )
-,		SchemaEntry("ifcwindowpanelpositionenum",NULL )
-,		SchemaEntry("ifcflowmetertypeenum",NULL )
-,		SchemaEntry("ifcrampflighttypeenum",NULL )
-,		SchemaEntry("ifcspecularhighlightselect",NULL )
-,		SchemaEntry("ifcactiontypeenum",NULL )
-,		SchemaEntry("ifcgeometricprojectionenum",NULL )
-,		SchemaEntry("ifctimeseriesdatatypeenum",NULL )
-,		SchemaEntry("ifcmagneticfluxmeasure",NULL )
-,		SchemaEntry("ifcobjecttypeenum",NULL )
-,		SchemaEntry("ifcdataoriginenum",NULL )
-,		SchemaEntry("ifcmassdensitymeasure",NULL )
-,		SchemaEntry("ifclightfixturetypeenum",NULL )
-,		SchemaEntry("ifcservicelifetypeenum",NULL )
-,		SchemaEntry("ifcelectricvoltagemeasure",NULL )
-,		SchemaEntry("ifcheatingvaluemeasure",NULL )
-,		SchemaEntry("ifcpresentabletext",NULL )
-,		SchemaEntry("ifcaheadorbehind",NULL )
-,		SchemaEntry("ifcsimplevalue",NULL )
-,		SchemaEntry("ifcsensortypeenum",NULL )
-,		SchemaEntry("ifcderivedunitenum",NULL )
-,		SchemaEntry("ifcsizeselect",NULL )
-,		SchemaEntry("ifctransportelementtypeenum",NULL )
-,		SchemaEntry("ifcinventorytypeenum",NULL )
-,		SchemaEntry("ifctextdecoration",NULL )
-,		SchemaEntry("ifcdirectionsenseenum",NULL )
-,		SchemaEntry("ifcductfittingtypeenum",NULL )
-,		SchemaEntry("ifcdocumentstatusenum",NULL )
-,		SchemaEntry("ifcslabtypeenum",NULL )
-,		SchemaEntry("ifcdoorstyleconstructionenum",NULL )
-,		SchemaEntry("ifcvolumemeasure",NULL )
-,		SchemaEntry("ifcinductancemeasure",NULL )
-,		SchemaEntry("ifccurtainwalltypeenum",NULL )
-,		SchemaEntry("ifcsiunitname",NULL )
-,		SchemaEntry("ifcspecularexponent",NULL )
-,		SchemaEntry("ifcsoundpressuremeasure",NULL )
-,		SchemaEntry("ifcanalysistheorytypeenum",NULL )
-,		SchemaEntry("ifcgasterminaltypeenum",NULL )
-,		SchemaEntry("ifcyearnumber",NULL )
-,		SchemaEntry("ifcmodulusofelasticitymeasure",NULL )
-,		SchemaEntry("ifcchangeactionenum",NULL )
-,		SchemaEntry("ifcdampertypeenum",NULL )
-,		SchemaEntry("ifcevaporatortypeenum",NULL )
-,		SchemaEntry("ifcionconcentrationmeasure",NULL )
-,		SchemaEntry("ifcductsegmenttypeenum",NULL )
-,		SchemaEntry("ifcprotectivedevicetypeenum",NULL )
-,		SchemaEntry("ifcabsorbeddosemeasure",NULL )
-,		SchemaEntry("ifcmassperlengthmeasure",NULL )
-,		SchemaEntry("ifctextfontname",NULL )
-,		SchemaEntry("ifcorientationselect",NULL )
-,		SchemaEntry("ifcilluminancemeasure",NULL )
-,		SchemaEntry("ifcfiresuppressionterminaltypeenum",NULL )
-,		SchemaEntry("ifcfontstyle",NULL )
-,		SchemaEntry("ifcmomentofinertiameasure",NULL )
-,		SchemaEntry("ifcmodulusofsubgradereactionmeasure",NULL )
-,		SchemaEntry("ifccomplexnumber",NULL )
-,		SchemaEntry("ifchumidifiertypeenum",NULL )
-,		SchemaEntry("ifcpresentationstyleselect",NULL )
-,		SchemaEntry("ifcthermaltransmittancemeasure",NULL )
-,		SchemaEntry("ifcribplatedirectionenum",NULL )
-,		SchemaEntry("ifcclassificationnotationselect",NULL )
-,		SchemaEntry("ifcminuteinhour",NULL )
-,		SchemaEntry("ifcinternalorexternalenum",NULL )
-,		SchemaEntry("ifcrotationalfrequencymeasure",NULL )
-,		SchemaEntry("ifcsanitaryterminaltypeenum",NULL )
-,		SchemaEntry("ifcsymbolstyleselect",NULL )
-,		SchemaEntry("ifcelementcompositionenum",NULL )
-,		SchemaEntry("ifctextpath",NULL )
-,		SchemaEntry("ifcpowermeasure",NULL )
-,		SchemaEntry("ifcsurfacestyleelementselect",NULL )
-,		SchemaEntry("ifcresourceconsumptionenum",NULL )
-,		SchemaEntry("ifcelectriccapacitancemeasure",NULL )
-,		SchemaEntry("ifclayersetdirectionenum",NULL )
-,		SchemaEntry("ifcrailingtypeenum",NULL )
-,		SchemaEntry("ifcobjectiveenum",NULL )
-,		SchemaEntry("ifcdocumentselect",NULL )
-,		SchemaEntry("ifcmodulusoflinearsubgradereactionmeasure",NULL )
-,		SchemaEntry("ifcthermaladmittancemeasure",NULL )
-,		SchemaEntry("ifctransitioncode",NULL )
-,		SchemaEntry("ifcconnectiontypeenum",NULL )
-,		SchemaEntry("ifcmonetarymeasure",NULL )
-,		SchemaEntry("ifcstackterminaltypeenum",NULL )
-,		SchemaEntry("ifccolour",NULL )
-,		SchemaEntry("ifctext",NULL )
-,		SchemaEntry("ifccontextdependentmeasure",NULL )
-,		SchemaEntry("ifcthermalconductivitymeasure",NULL )
-,		SchemaEntry("ifcprojectedortruelengthenum",NULL )
-,		SchemaEntry("ifcpressuremeasure",NULL )
-,		SchemaEntry("ifcmoisturediffusivitymeasure",NULL )
-,		SchemaEntry("ifcbooleanoperator",NULL )
-,		SchemaEntry("ifcpropertysourceenum",NULL )
-,		SchemaEntry("ifctimestamp",NULL )
-,		SchemaEntry("ifcmaterialselect",NULL )
-,		SchemaEntry("ifcgloballyuniqueid",NULL )
-,		SchemaEntry("ifcreflectancemethodenum",NULL )
-,		SchemaEntry("ifcvaporpermeabilitymeasure",NULL )
-,		SchemaEntry("ifctimeseriesscheduletypeenum",NULL )
-,		SchemaEntry("ifclinearmomentmeasure",NULL )
-,		SchemaEntry("ifcgeometricsetselect",NULL )
-,		SchemaEntry("ifcsectionmodulusmeasure",NULL )
-,		SchemaEntry("ifcbsplinecurveform",NULL )
-,		SchemaEntry("ifcdimensionextentusage",NULL )
-,		SchemaEntry("ifcthermalexpansioncoefficientmeasure",NULL )
-,		SchemaEntry("ifchourinday",NULL )
-,		SchemaEntry("ifclinearvelocitymeasure",NULL )
-,		SchemaEntry("ifctorquemeasure",NULL )
-,		SchemaEntry("ifctemperaturegradientmeasure",NULL )
-,		SchemaEntry("ifcfillstyleselect",NULL )
-,		SchemaEntry("ifcelectricchargemeasure",NULL )
-,		SchemaEntry("ifcheatexchangertypeenum",NULL )
-,		SchemaEntry("ifcelectriccurrentenum",NULL )
-,		SchemaEntry("ifcdaylightsavinghour",NULL )
-,		SchemaEntry("ifcshell",NULL )
-,		SchemaEntry("ifcdoseequivalentmeasure",NULL )
-,		SchemaEntry("ifcprojectordertypeenum",NULL )
-,		SchemaEntry("ifcderivedmeasurevalue",NULL )
-,		SchemaEntry("ifclightdistributioncurveenum",NULL )
-,		SchemaEntry("ifcwarpingmomentmeasure",NULL )
-,		SchemaEntry("ifcmembertypeenum",NULL )
-,		SchemaEntry("ifcsoundpowermeasure",NULL )
-,		SchemaEntry("ifctextalignment",NULL )
-,		SchemaEntry("ifccurveoredgecurve",NULL )
-,		SchemaEntry("ifcmassflowratemeasure",NULL )
-,		SchemaEntry("ifcisothermalmoisturecapacitymeasure",NULL )
-,		SchemaEntry("ifccsgselect",NULL )
-,		SchemaEntry("ifccoolingtowertypeenum",NULL )
-,		SchemaEntry("ifcmassmeasure",NULL )
-,		SchemaEntry("ifcpileconstructionenum",NULL )
-,		SchemaEntry("ifcdoorstyleoperationenum",NULL )
-,		SchemaEntry("ifcflowdirectionenum",NULL )
-,		SchemaEntry("ifcthermalloadsourceenum",NULL )
-,		SchemaEntry("ifclengthmeasure",NULL )
-,		SchemaEntry("ifcconstraintenum",NULL )
-,		SchemaEntry("ifcaxis2placement",NULL )
-,		SchemaEntry("ifcloadgrouptypeenum",NULL )
-,		SchemaEntry("ifcvalue",NULL )
-,		SchemaEntry("ifcreinforcingbarsurfaceenum",NULL )
-,		SchemaEntry("ifcprojectorderrecordtypeenum",NULL )
-,		SchemaEntry("ifcdatetimeselect",NULL )
-,		SchemaEntry("ifcstructuralsurfacetypeenum",NULL )
-,		SchemaEntry("ifcpermeablecoveringoperationenum",NULL )
-,		SchemaEntry("ifcfontweight",NULL )
-,		SchemaEntry("ifcphmeasure",NULL )
-,		SchemaEntry("ifcdescriptivemeasure",NULL )
-,		SchemaEntry("ifccurvestylefontselect",NULL )
-,		SchemaEntry("ifcunit",NULL )
-,		SchemaEntry("ifchatchlinedistanceselect",NULL )
-,		SchemaEntry("ifctextstyleselect",NULL )
-,		SchemaEntry("ifcmetricvalueselect",NULL )
-,		SchemaEntry("ifcvectorordirection",NULL )
-,		SchemaEntry("ifcassemblyplaceenum",NULL )
-,		SchemaEntry("ifcairterminaltypeenum",NULL )
-,		SchemaEntry("ifccoveringtypeenum",NULL )
-,		SchemaEntry("ifcplanarforcemeasure",NULL )
-,		SchemaEntry("ifcvalvetypeenum",NULL )
-,		SchemaEntry("ifcalarmtypeenum",NULL )
-,		SchemaEntry("ifcdynamicviscositymeasure",NULL )
-,		SchemaEntry("ifccurrencyenum",NULL )
-,		SchemaEntry("ifcmodulusofrotationalsubgradereactionmeasure",NULL )
-,		SchemaEntry("ifccablecarrierfittingtypeenum",NULL )
-,		SchemaEntry("ifcboolean",NULL )
-,		SchemaEntry("ifcactionsourcetypeenum",NULL )
-,		SchemaEntry("ifcstructuralactivityassignmentselect",NULL )
-,		SchemaEntry("ifcdistributionchamberelementtypeenum",NULL )
-,		SchemaEntry("ifcevaporativecoolertypeenum",NULL )
-,		SchemaEntry("ifcmagneticfluxdensitymeasure",NULL )
-,		SchemaEntry("ifclightdistributiondatasourceselect",NULL )
-,		SchemaEntry("ifctubebundletypeenum",NULL )
-,		SchemaEntry("ifcaccelerationmeasure",NULL )
-,		SchemaEntry("ifcboilertypeenum",NULL )
-,		SchemaEntry("ifcramptypeenum",NULL )
-,		SchemaEntry("ifcluminousintensitydistributionmeasure",NULL )
-,		SchemaEntry("ifctrimmingpreference",NULL )
-,		SchemaEntry("ifcspecificheatcapacitymeasure",NULL )
-,		SchemaEntry("ifcamountofsubstancemeasure",NULL )
-,		SchemaEntry("ifcroleenum",NULL )
-,		SchemaEntry("ifcdocumentconfidentialityenum",NULL )
-,		SchemaEntry("ifcfrequencymeasure",NULL )
-,		SchemaEntry("ifcsectiontypeenum",NULL )
-,		SchemaEntry("ifcelementassemblytypeenum",NULL )
-,		SchemaEntry("ifcfootingtypeenum",NULL )
-,		SchemaEntry("ifclayereditem",NULL )
-,		SchemaEntry("ifccablesegmenttypeenum",NULL )
-,		SchemaEntry("ifcdefinedsymbolselect",NULL )
-,		SchemaEntry("ifcbuildingelementproxytypeenum",NULL )
-,		SchemaEntry("ifcelectricgeneratortypeenum",NULL )
-,		SchemaEntry("ifcrotationalstiffnessmeasure",NULL )
-,		SchemaEntry("ifcspaceheatertypeenum",NULL )
-,		SchemaEntry("ifcareameasure",NULL )
-,		SchemaEntry("ifclabel",NULL )
-,		SchemaEntry("ifccostscheduletypeenum",NULL )
-,		SchemaEntry("ifcswitchingdevicetypeenum",NULL )
-,		SchemaEntry("ifcelectrictimecontroltypeenum",NULL )
-,		SchemaEntry("ifcfiltertypeenum",NULL )
-,		SchemaEntry("ifcpositivelengthmeasure",NULL )
-,		SchemaEntry("ifcnullstyle",NULL )
-,		SchemaEntry("ifcconditioncriterionselect",NULL )
-,		SchemaEntry("ifcshearmodulusmeasure",NULL )
-,		SchemaEntry("ifcnormalisedratiomeasure",NULL )
-,		SchemaEntry("ifcdoorpaneloperationenum",NULL )
-,		SchemaEntry("ifcpointorvertexpoint",NULL )
-,		SchemaEntry("ifcrooftypeenum",NULL )
-,		SchemaEntry("ifccountmeasure",NULL )
-,		SchemaEntry("ifcelectricconductancemeasure",NULL )
-,		SchemaEntry("ifcproceduretypeenum",NULL )
-,		SchemaEntry("ifcflowinstrumenttypeenum",NULL )
-,		SchemaEntry("ifcelectricmotortypeenum",NULL )
-,		SchemaEntry("ifcsurfaceside",NULL )
-,		SchemaEntry("ifcstructuralcurvetypeenum",NULL )
-,		SchemaEntry("ifccondensertypeenum",NULL )
-,		SchemaEntry("ifclinearstiffnessmeasure",NULL )
-,		SchemaEntry("ifcunitenum",NULL )
-,		SchemaEntry("ifcoccupanttypeenum",NULL )
-,		SchemaEntry("ifcthermalloadtypeenum",NULL )
-,		SchemaEntry("ifcreinforcingbarroleenum",NULL )
-,		SchemaEntry("ifcbenchmarkenum",NULL )
-,		SchemaEntry("ifcpositiveplaneanglemeasure",NULL )
-,		SchemaEntry("ifctexttransformation",NULL )
-,		SchemaEntry("ifcdraughtingcalloutelement",NULL )
-,		SchemaEntry("ifcratiomeasure",NULL )
-,		SchemaEntry("ifcsolidanglemeasure",NULL )
-,		SchemaEntry("ifcpipesegmenttypeenum",NULL )
-,		SchemaEntry("ifccablecarriersegmenttypeenum",NULL )
-,		SchemaEntry("ifccolourorfactor",NULL )
-,		SchemaEntry("ifcidentifier",NULL )
-,		SchemaEntry("ifctendontypeenum",NULL )
-,		SchemaEntry("ifccontrollertypeenum",NULL )
-,		SchemaEntry("ifcradioactivitymeasure",NULL )
-,		SchemaEntry("ifctimemeasure",NULL )
-,		SchemaEntry("ifcpumptypeenum",NULL )
-,		SchemaEntry("ifcelectricheatertypeenum",NULL )
-,		SchemaEntry("ifcbeamtypeenum",NULL )
-,		SchemaEntry("ifcstateenum",NULL )
-,		SchemaEntry("ifcsiprefix",NULL )
-,		SchemaEntry("ifcnumericmeasure",NULL )
-,		SchemaEntry("ifcoutlettypeenum",NULL )
-,		SchemaEntry("ifccompoundplaneanglemeasure",NULL )
-,		SchemaEntry("ifcservicelifefactortypeenum",NULL )
-,		SchemaEntry("ifclogicaloperatorenum",NULL )
-,		SchemaEntry("ifcbooleanoperand",NULL )
-,		SchemaEntry("ifcobjectreferenceselect",NULL )
-,		SchemaEntry("ifccooledbeamtypeenum",NULL )
-,		SchemaEntry("ifcductsilencertypeenum",NULL )
-,		SchemaEntry("ifcsectionalareaintegralmeasure",NULL )
-,		SchemaEntry("ifcfontvariant",NULL )
-,		SchemaEntry("ifcvolumetricflowratemeasure",NULL )
-,		SchemaEntry("ifcplatetypeenum",NULL )
-,		SchemaEntry("ifcenvironmentalimpactcategoryenum",NULL )
-,		SchemaEntry("ifcvibrationisolatortypeenum",NULL )
-,		SchemaEntry("ifcthermodynamictemperaturemeasure",NULL )
-,		SchemaEntry("ifcrotationalmassmeasure",NULL )
-,		SchemaEntry("ifcsecondinminute",NULL )
-,		SchemaEntry("ifcdayinmonthnumber",NULL )
-,		SchemaEntry("ifcdimensioncount",NULL )
-,		SchemaEntry("ifcwindowstyleoperationenum",NULL )
-,		SchemaEntry("ifcthermalresistancemeasure",NULL )
-,		SchemaEntry("ifcmeasurevalue",NULL )
-,		SchemaEntry("ifcwindowpaneloperationenum",NULL )
-,		SchemaEntry("ifcchillertypeenum",NULL )
-,		SchemaEntry("ifcpositiveratiomeasure",NULL )
-,		SchemaEntry("ifcinteger",NULL )
-,		SchemaEntry("ifclogical",NULL )
-,		SchemaEntry("ifcjunctionboxtypeenum",NULL )
-,		SchemaEntry("ifcaddresstypeenum",NULL )
-,		SchemaEntry("ifcwasteterminaltypeenum",NULL )
-,		SchemaEntry("ifctrimmingselect",NULL )
-,		SchemaEntry("ifclightemissionsourceenum",NULL )
-,		SchemaEntry("ifcsoundscaleenum",NULL )
-,		SchemaEntry("ifcluminousfluxmeasure",NULL )
-,		SchemaEntry("ifcelectricresistancemeasure",NULL )
-,		SchemaEntry("ifcintegercountratemeasure",NULL )
-,		SchemaEntry("ifcphysicalorvirtualenum",NULL )
-,		SchemaEntry("ifcmolecularweightmeasure",NULL )
-,		SchemaEntry("ifcprofiletypeenum",NULL )
-,		SchemaEntry("ifcboxalignment",NULL )
-,		SchemaEntry("ifcglobalorlocalenum",NULL )
-,		SchemaEntry("ifcspecularroughness",NULL )
-,		SchemaEntry("ifclamptypeenum",NULL )
-,		SchemaEntry("ifcpiletypeenum",NULL )
-,		SchemaEntry("ifcelectriccurrentmeasure",NULL )
-,		SchemaEntry("ifcfantypeenum",NULL )
-,		SchemaEntry("ifcsurfaceorfacesurface",NULL )
-,		SchemaEntry("ifcpipefittingtypeenum",NULL )
-,		SchemaEntry("ifctanktypeenum",NULL )
-,		SchemaEntry("ifccurvefontorscaledcurvefontselect",NULL )
-,		SchemaEntry("ifcwindowstyleconstructionenum",NULL )
-,		SchemaEntry("ifcairterminalboxtypeenum",NULL )
-,		SchemaEntry("ifcstairflighttypeenum",NULL )
-,		SchemaEntry("ifcluminousintensitymeasure",NULL )
-,		SchemaEntry("ifcmotorconnectiontypeenum",NULL )
-,		SchemaEntry("ifcplaneanglemeasure",NULL )
-,		SchemaEntry("ifcactuatortypeenum",NULL )
-,		SchemaEntry("ifccolumntypeenum",NULL )
-,		SchemaEntry("ifctextfontselect",NULL )
-,		SchemaEntry("ifcdoorpanelpositionenum",NULL )
-,		SchemaEntry("ifccoiltypeenum",NULL )
-,		SchemaEntry("ifcangularvelocitymeasure",NULL )
-,		SchemaEntry("ifcanalysismodeltypeenum",NULL )
-,		SchemaEntry("ifclibraryselect",NULL )
-,		SchemaEntry("ifcforcemeasure",NULL )
-,		SchemaEntry("ifcfillareastyletileshapeselect",NULL )
-,		SchemaEntry("ifcelectricappliancetypeenum",NULL )
-,		SchemaEntry("ifcsurfacetextureenum",NULL )
-,		SchemaEntry("ifccharacterstyleselect",NULL )
-,		SchemaEntry("ifcenergymeasure",NULL )
-,		SchemaEntry("ifcreal",NULL )
-,		SchemaEntry("ifccompressortypeenum",NULL )
-,		SchemaEntry("ifcelectricdistributionpointfunctionenum",NULL )
+		SchemaEntry("ifcstairtypeenum",nullptr )
+,		SchemaEntry("ifcspacetypeenum",nullptr )
+,		SchemaEntry("ifcwalltypeenum",nullptr )
+,		SchemaEntry("ifcmonthinyearnumber",nullptr )
+,		SchemaEntry("ifcheatfluxdensitymeasure",nullptr )
+,		SchemaEntry("ifckinematicviscositymeasure",nullptr )
+,		SchemaEntry("ifcsequenceenum",nullptr )
+,		SchemaEntry("ifcairtoairheatrecoverytypeenum",nullptr )
+,		SchemaEntry("ifcactorselect",nullptr )
+,		SchemaEntry("ifctransformertypeenum",nullptr )
+,		SchemaEntry("ifcunitaryequipmenttypeenum",nullptr )
+,		SchemaEntry("ifcelectricflowstoragedevicetypeenum",nullptr )
+,		SchemaEntry("ifcenergysequenceenum",nullptr )
+,		SchemaEntry("ifcworkcontroltypeenum",nullptr )
+,		SchemaEntry("ifccurvaturemeasure",nullptr )
+,		SchemaEntry("ifcparametervalue",nullptr )
+,		SchemaEntry("ifcappliedvalueselect",nullptr )
+,		SchemaEntry("ifcwarpingconstantmeasure",nullptr )
+,		SchemaEntry("ifcarithmeticoperatorenum",nullptr )
+,		SchemaEntry("ifclinearforcemeasure",nullptr )
+,		SchemaEntry("ifcwindowpanelpositionenum",nullptr )
+,		SchemaEntry("ifcflowmetertypeenum",nullptr )
+,		SchemaEntry("ifcrampflighttypeenum",nullptr )
+,		SchemaEntry("ifcspecularhighlightselect",nullptr )
+,		SchemaEntry("ifcactiontypeenum",nullptr )
+,		SchemaEntry("ifcgeometricprojectionenum",nullptr )
+,		SchemaEntry("ifctimeseriesdatatypeenum",nullptr )
+,		SchemaEntry("ifcmagneticfluxmeasure",nullptr )
+,		SchemaEntry("ifcobjecttypeenum",nullptr )
+,		SchemaEntry("ifcdataoriginenum",nullptr )
+,		SchemaEntry("ifcmassdensitymeasure",nullptr )
+,		SchemaEntry("ifclightfixturetypeenum",nullptr )
+,		SchemaEntry("ifcservicelifetypeenum",nullptr )
+,		SchemaEntry("ifcelectricvoltagemeasure",nullptr )
+,		SchemaEntry("ifcheatingvaluemeasure",nullptr )
+,		SchemaEntry("ifcpresentabletext",nullptr )
+,		SchemaEntry("ifcaheadorbehind",nullptr )
+,		SchemaEntry("ifcsimplevalue",nullptr )
+,		SchemaEntry("ifcsensortypeenum",nullptr )
+,		SchemaEntry("ifcderivedunitenum",nullptr )
+,		SchemaEntry("ifcsizeselect",nullptr )
+,		SchemaEntry("ifctransportelementtypeenum",nullptr )
+,		SchemaEntry("ifcinventorytypeenum",nullptr )
+,		SchemaEntry("ifctextdecoration",nullptr )
+,		SchemaEntry("ifcdirectionsenseenum",nullptr )
+,		SchemaEntry("ifcductfittingtypeenum",nullptr )
+,		SchemaEntry("ifcdocumentstatusenum",nullptr )
+,		SchemaEntry("ifcslabtypeenum",nullptr )
+,		SchemaEntry("ifcdoorstyleconstructionenum",nullptr )
+,		SchemaEntry("ifcvolumemeasure",nullptr )
+,		SchemaEntry("ifcinductancemeasure",nullptr )
+,		SchemaEntry("ifccurtainwalltypeenum",nullptr )
+,		SchemaEntry("ifcsiunitname",nullptr )
+,		SchemaEntry("ifcspecularexponent",nullptr )
+,		SchemaEntry("ifcsoundpressuremeasure",nullptr )
+,		SchemaEntry("ifcanalysistheorytypeenum",nullptr )
+,		SchemaEntry("ifcgasterminaltypeenum",nullptr )
+,		SchemaEntry("ifcyearnumber",nullptr )
+,		SchemaEntry("ifcmodulusofelasticitymeasure",nullptr )
+,		SchemaEntry("ifcchangeactionenum",nullptr )
+,		SchemaEntry("ifcdampertypeenum",nullptr )
+,		SchemaEntry("ifcevaporatortypeenum",nullptr )
+,		SchemaEntry("ifcionconcentrationmeasure",nullptr )
+,		SchemaEntry("ifcductsegmenttypeenum",nullptr )
+,		SchemaEntry("ifcprotectivedevicetypeenum",nullptr )
+,		SchemaEntry("ifcabsorbeddosemeasure",nullptr )
+,		SchemaEntry("ifcmassperlengthmeasure",nullptr )
+,		SchemaEntry("ifctextfontname",nullptr )
+,		SchemaEntry("ifcorientationselect",nullptr )
+,		SchemaEntry("ifcilluminancemeasure",nullptr )
+,		SchemaEntry("ifcfiresuppressionterminaltypeenum",nullptr )
+,		SchemaEntry("ifcfontstyle",nullptr )
+,		SchemaEntry("ifcmomentofinertiameasure",nullptr )
+,		SchemaEntry("ifcmodulusofsubgradereactionmeasure",nullptr )
+,		SchemaEntry("ifccomplexnumber",nullptr )
+,		SchemaEntry("ifchumidifiertypeenum",nullptr )
+,		SchemaEntry("ifcpresentationstyleselect",nullptr )
+,		SchemaEntry("ifcthermaltransmittancemeasure",nullptr )
+,		SchemaEntry("ifcribplatedirectionenum",nullptr )
+,		SchemaEntry("ifcclassificationnotationselect",nullptr )
+,		SchemaEntry("ifcminuteinhour",nullptr )
+,		SchemaEntry("ifcinternalorexternalenum",nullptr )
+,		SchemaEntry("ifcrotationalfrequencymeasure",nullptr )
+,		SchemaEntry("ifcsanitaryterminaltypeenum",nullptr )
+,		SchemaEntry("ifcsymbolstyleselect",nullptr )
+,		SchemaEntry("ifcelementcompositionenum",nullptr )
+,		SchemaEntry("ifctextpath",nullptr )
+,		SchemaEntry("ifcpowermeasure",nullptr )
+,		SchemaEntry("ifcsurfacestyleelementselect",nullptr )
+,		SchemaEntry("ifcresourceconsumptionenum",nullptr )
+,		SchemaEntry("ifcelectriccapacitancemeasure",nullptr )
+,		SchemaEntry("ifclayersetdirectionenum",nullptr )
+,		SchemaEntry("ifcrailingtypeenum",nullptr )
+,		SchemaEntry("ifcobjectiveenum",nullptr )
+,		SchemaEntry("ifcdocumentselect",nullptr )
+,		SchemaEntry("ifcmodulusoflinearsubgradereactionmeasure",nullptr )
+,		SchemaEntry("ifcthermaladmittancemeasure",nullptr )
+,		SchemaEntry("ifctransitioncode",nullptr )
+,		SchemaEntry("ifcconnectiontypeenum",nullptr )
+,		SchemaEntry("ifcmonetarymeasure",nullptr )
+,		SchemaEntry("ifcstackterminaltypeenum",nullptr )
+,		SchemaEntry("ifccolour",nullptr )
+,		SchemaEntry("ifctext",nullptr )
+,		SchemaEntry("ifccontextdependentmeasure",nullptr )
+,		SchemaEntry("ifcthermalconductivitymeasure",nullptr )
+,		SchemaEntry("ifcprojectedortruelengthenum",nullptr )
+,		SchemaEntry("ifcpressuremeasure",nullptr )
+,		SchemaEntry("ifcmoisturediffusivitymeasure",nullptr )
+,		SchemaEntry("ifcbooleanoperator",nullptr )
+,		SchemaEntry("ifcpropertysourceenum",nullptr )
+,		SchemaEntry("ifctimestamp",nullptr )
+,		SchemaEntry("ifcmaterialselect",nullptr )
+,		SchemaEntry("ifcgloballyuniqueid",nullptr )
+,		SchemaEntry("ifcreflectancemethodenum",nullptr )
+,		SchemaEntry("ifcvaporpermeabilitymeasure",nullptr )
+,		SchemaEntry("ifctimeseriesscheduletypeenum",nullptr )
+,		SchemaEntry("ifclinearmomentmeasure",nullptr )
+,		SchemaEntry("ifcgeometricsetselect",nullptr )
+,		SchemaEntry("ifcsectionmodulusmeasure",nullptr )
+,		SchemaEntry("ifcbsplinecurveform",nullptr )
+,		SchemaEntry("ifcdimensionextentusage",nullptr )
+,		SchemaEntry("ifcthermalexpansioncoefficientmeasure",nullptr )
+,		SchemaEntry("ifchourinday",nullptr )
+,		SchemaEntry("ifclinearvelocitymeasure",nullptr )
+,		SchemaEntry("ifctorquemeasure",nullptr )
+,		SchemaEntry("ifctemperaturegradientmeasure",nullptr )
+,		SchemaEntry("ifcfillstyleselect",nullptr )
+,		SchemaEntry("ifcelectricchargemeasure",nullptr )
+,		SchemaEntry("ifcheatexchangertypeenum",nullptr )
+,		SchemaEntry("ifcelectriccurrentenum",nullptr )
+,		SchemaEntry("ifcdaylightsavinghour",nullptr )
+,		SchemaEntry("ifcshell",nullptr )
+,		SchemaEntry("ifcdoseequivalentmeasure",nullptr )
+,		SchemaEntry("ifcprojectordertypeenum",nullptr )
+,		SchemaEntry("ifcderivedmeasurevalue",nullptr )
+,		SchemaEntry("ifclightdistributioncurveenum",nullptr )
+,		SchemaEntry("ifcwarpingmomentmeasure",nullptr )
+,		SchemaEntry("ifcmembertypeenum",nullptr )
+,		SchemaEntry("ifcsoundpowermeasure",nullptr )
+,		SchemaEntry("ifctextalignment",nullptr )
+,		SchemaEntry("ifccurveoredgecurve",nullptr )
+,		SchemaEntry("ifcmassflowratemeasure",nullptr )
+,		SchemaEntry("ifcisothermalmoisturecapacitymeasure",nullptr )
+,		SchemaEntry("ifccsgselect",nullptr )
+,		SchemaEntry("ifccoolingtowertypeenum",nullptr )
+,		SchemaEntry("ifcmassmeasure",nullptr )
+,		SchemaEntry("ifcpileconstructionenum",nullptr )
+,		SchemaEntry("ifcdoorstyleoperationenum",nullptr )
+,		SchemaEntry("ifcflowdirectionenum",nullptr )
+,		SchemaEntry("ifcthermalloadsourceenum",nullptr )
+,		SchemaEntry("ifclengthmeasure",nullptr )
+,		SchemaEntry("ifcconstraintenum",nullptr )
+,		SchemaEntry("ifcaxis2placement",nullptr )
+,		SchemaEntry("ifcloadgrouptypeenum",nullptr )
+,		SchemaEntry("ifcvalue",nullptr )
+,		SchemaEntry("ifcreinforcingbarsurfaceenum",nullptr )
+,		SchemaEntry("ifcprojectorderrecordtypeenum",nullptr )
+,		SchemaEntry("ifcdatetimeselect",nullptr )
+,		SchemaEntry("ifcstructuralsurfacetypeenum",nullptr )
+,		SchemaEntry("ifcpermeablecoveringoperationenum",nullptr )
+,		SchemaEntry("ifcfontweight",nullptr )
+,		SchemaEntry("ifcphmeasure",nullptr )
+,		SchemaEntry("ifcdescriptivemeasure",nullptr )
+,		SchemaEntry("ifccurvestylefontselect",nullptr )
+,		SchemaEntry("ifcunit",nullptr )
+,		SchemaEntry("ifchatchlinedistanceselect",nullptr )
+,		SchemaEntry("ifctextstyleselect",nullptr )
+,		SchemaEntry("ifcmetricvalueselect",nullptr )
+,		SchemaEntry("ifcvectorordirection",nullptr )
+,		SchemaEntry("ifcassemblyplaceenum",nullptr )
+,		SchemaEntry("ifcairterminaltypeenum",nullptr )
+,		SchemaEntry("ifccoveringtypeenum",nullptr )
+,		SchemaEntry("ifcplanarforcemeasure",nullptr )
+,		SchemaEntry("ifcvalvetypeenum",nullptr )
+,		SchemaEntry("ifcalarmtypeenum",nullptr )
+,		SchemaEntry("ifcdynamicviscositymeasure",nullptr )
+,		SchemaEntry("ifccurrencyenum",nullptr )
+,		SchemaEntry("ifcmodulusofrotationalsubgradereactionmeasure",nullptr )
+,		SchemaEntry("ifccablecarrierfittingtypeenum",nullptr )
+,		SchemaEntry("ifcboolean",nullptr )
+,		SchemaEntry("ifcactionsourcetypeenum",nullptr )
+,		SchemaEntry("ifcstructuralactivityassignmentselect",nullptr )
+,		SchemaEntry("ifcdistributionchamberelementtypeenum",nullptr )
+,		SchemaEntry("ifcevaporativecoolertypeenum",nullptr )
+,		SchemaEntry("ifcmagneticfluxdensitymeasure",nullptr )
+,		SchemaEntry("ifclightdistributiondatasourceselect",nullptr )
+,		SchemaEntry("ifctubebundletypeenum",nullptr )
+,		SchemaEntry("ifcaccelerationmeasure",nullptr )
+,		SchemaEntry("ifcboilertypeenum",nullptr )
+,		SchemaEntry("ifcramptypeenum",nullptr )
+,		SchemaEntry("ifcluminousintensitydistributionmeasure",nullptr )
+,		SchemaEntry("ifctrimmingpreference",nullptr )
+,		SchemaEntry("ifcspecificheatcapacitymeasure",nullptr )
+,		SchemaEntry("ifcamountofsubstancemeasure",nullptr )
+,		SchemaEntry("ifcroleenum",nullptr )
+,		SchemaEntry("ifcdocumentconfidentialityenum",nullptr )
+,		SchemaEntry("ifcfrequencymeasure",nullptr )
+,		SchemaEntry("ifcsectiontypeenum",nullptr )
+,		SchemaEntry("ifcelementassemblytypeenum",nullptr )
+,		SchemaEntry("ifcfootingtypeenum",nullptr )
+,		SchemaEntry("ifclayereditem",nullptr )
+,		SchemaEntry("ifccablesegmenttypeenum",nullptr )
+,		SchemaEntry("ifcdefinedsymbolselect",nullptr )
+,		SchemaEntry("ifcbuildingelementproxytypeenum",nullptr )
+,		SchemaEntry("ifcelectricgeneratortypeenum",nullptr )
+,		SchemaEntry("ifcrotationalstiffnessmeasure",nullptr )
+,		SchemaEntry("ifcspaceheatertypeenum",nullptr )
+,		SchemaEntry("ifcareameasure",nullptr )
+,		SchemaEntry("ifclabel",nullptr )
+,		SchemaEntry("ifccostscheduletypeenum",nullptr )
+,		SchemaEntry("ifcswitchingdevicetypeenum",nullptr )
+,		SchemaEntry("ifcelectrictimecontroltypeenum",nullptr )
+,		SchemaEntry("ifcfiltertypeenum",nullptr )
+,		SchemaEntry("ifcpositivelengthmeasure",nullptr )
+,		SchemaEntry("ifcnullstyle",nullptr )
+,		SchemaEntry("ifcconditioncriterionselect",nullptr )
+,		SchemaEntry("ifcshearmodulusmeasure",nullptr )
+,		SchemaEntry("ifcnormalisedratiomeasure",nullptr )
+,		SchemaEntry("ifcdoorpaneloperationenum",nullptr )
+,		SchemaEntry("ifcpointorvertexpoint",nullptr )
+,		SchemaEntry("ifcrooftypeenum",nullptr )
+,		SchemaEntry("ifccountmeasure",nullptr )
+,		SchemaEntry("ifcelectricconductancemeasure",nullptr )
+,		SchemaEntry("ifcproceduretypeenum",nullptr )
+,		SchemaEntry("ifcflowinstrumenttypeenum",nullptr )
+,		SchemaEntry("ifcelectricmotortypeenum",nullptr )
+,		SchemaEntry("ifcsurfaceside",nullptr )
+,		SchemaEntry("ifcstructuralcurvetypeenum",nullptr )
+,		SchemaEntry("ifccondensertypeenum",nullptr )
+,		SchemaEntry("ifclinearstiffnessmeasure",nullptr )
+,		SchemaEntry("ifcunitenum",nullptr )
+,		SchemaEntry("ifcoccupanttypeenum",nullptr )
+,		SchemaEntry("ifcthermalloadtypeenum",nullptr )
+,		SchemaEntry("ifcreinforcingbarroleenum",nullptr )
+,		SchemaEntry("ifcbenchmarkenum",nullptr )
+,		SchemaEntry("ifcpositiveplaneanglemeasure",nullptr )
+,		SchemaEntry("ifctexttransformation",nullptr )
+,		SchemaEntry("ifcdraughtingcalloutelement",nullptr )
+,		SchemaEntry("ifcratiomeasure",nullptr )
+,		SchemaEntry("ifcsolidanglemeasure",nullptr )
+,		SchemaEntry("ifcpipesegmenttypeenum",nullptr )
+,		SchemaEntry("ifccablecarriersegmenttypeenum",nullptr )
+,		SchemaEntry("ifccolourorfactor",nullptr )
+,		SchemaEntry("ifcidentifier",nullptr )
+,		SchemaEntry("ifctendontypeenum",nullptr )
+,		SchemaEntry("ifccontrollertypeenum",nullptr )
+,		SchemaEntry("ifcradioactivitymeasure",nullptr )
+,		SchemaEntry("ifctimemeasure",nullptr )
+,		SchemaEntry("ifcpumptypeenum",nullptr )
+,		SchemaEntry("ifcelectricheatertypeenum",nullptr )
+,		SchemaEntry("ifcbeamtypeenum",nullptr )
+,		SchemaEntry("ifcstateenum",nullptr )
+,		SchemaEntry("ifcsiprefix",nullptr )
+,		SchemaEntry("ifcnumericmeasure",nullptr )
+,		SchemaEntry("ifcoutlettypeenum",nullptr )
+,		SchemaEntry("ifccompoundplaneanglemeasure",nullptr )
+,		SchemaEntry("ifcservicelifefactortypeenum",nullptr )
+,		SchemaEntry("ifclogicaloperatorenum",nullptr )
+,		SchemaEntry("ifcbooleanoperand",nullptr )
+,		SchemaEntry("ifcobjectreferenceselect",nullptr )
+,		SchemaEntry("ifccooledbeamtypeenum",nullptr )
+,		SchemaEntry("ifcductsilencertypeenum",nullptr )
+,		SchemaEntry("ifcsectionalareaintegralmeasure",nullptr )
+,		SchemaEntry("ifcfontvariant",nullptr )
+,		SchemaEntry("ifcvolumetricflowratemeasure",nullptr )
+,		SchemaEntry("ifcplatetypeenum",nullptr )
+,		SchemaEntry("ifcenvironmentalimpactcategoryenum",nullptr )
+,		SchemaEntry("ifcvibrationisolatortypeenum",nullptr )
+,		SchemaEntry("ifcthermodynamictemperaturemeasure",nullptr )
+,		SchemaEntry("ifcrotationalmassmeasure",nullptr )
+,		SchemaEntry("ifcsecondinminute",nullptr )
+,		SchemaEntry("ifcdayinmonthnumber",nullptr )
+,		SchemaEntry("ifcdimensioncount",nullptr )
+,		SchemaEntry("ifcwindowstyleoperationenum",nullptr )
+,		SchemaEntry("ifcthermalresistancemeasure",nullptr )
+,		SchemaEntry("ifcmeasurevalue",nullptr )
+,		SchemaEntry("ifcwindowpaneloperationenum",nullptr )
+,		SchemaEntry("ifcchillertypeenum",nullptr )
+,		SchemaEntry("ifcpositiveratiomeasure",nullptr )
+,		SchemaEntry("ifcinteger",nullptr )
+,		SchemaEntry("ifclogical",nullptr )
+,		SchemaEntry("ifcjunctionboxtypeenum",nullptr )
+,		SchemaEntry("ifcaddresstypeenum",nullptr )
+,		SchemaEntry("ifcwasteterminaltypeenum",nullptr )
+,		SchemaEntry("ifctrimmingselect",nullptr )
+,		SchemaEntry("ifclightemissionsourceenum",nullptr )
+,		SchemaEntry("ifcsoundscaleenum",nullptr )
+,		SchemaEntry("ifcluminousfluxmeasure",nullptr )
+,		SchemaEntry("ifcelectricresistancemeasure",nullptr )
+,		SchemaEntry("ifcintegercountratemeasure",nullptr )
+,		SchemaEntry("ifcphysicalorvirtualenum",nullptr )
+,		SchemaEntry("ifcmolecularweightmeasure",nullptr )
+,		SchemaEntry("ifcprofiletypeenum",nullptr )
+,		SchemaEntry("ifcboxalignment",nullptr )
+,		SchemaEntry("ifcglobalorlocalenum",nullptr )
+,		SchemaEntry("ifcspecularroughness",nullptr )
+,		SchemaEntry("ifclamptypeenum",nullptr )
+,		SchemaEntry("ifcpiletypeenum",nullptr )
+,		SchemaEntry("ifcelectriccurrentmeasure",nullptr )
+,		SchemaEntry("ifcfantypeenum",nullptr )
+,		SchemaEntry("ifcsurfaceorfacesurface",nullptr )
+,		SchemaEntry("ifcpipefittingtypeenum",nullptr )
+,		SchemaEntry("ifctanktypeenum",nullptr )
+,		SchemaEntry("ifccurvefontorscaledcurvefontselect",nullptr )
+,		SchemaEntry("ifcwindowstyleconstructionenum",nullptr )
+,		SchemaEntry("ifcairterminalboxtypeenum",nullptr )
+,		SchemaEntry("ifcstairflighttypeenum",nullptr )
+,		SchemaEntry("ifcluminousintensitymeasure",nullptr )
+,		SchemaEntry("ifcmotorconnectiontypeenum",nullptr )
+,		SchemaEntry("ifcplaneanglemeasure",nullptr )
+,		SchemaEntry("ifcactuatortypeenum",nullptr )
+,		SchemaEntry("ifccolumntypeenum",nullptr )
+,		SchemaEntry("ifctextfontselect",nullptr )
+,		SchemaEntry("ifcdoorpanelpositionenum",nullptr )
+,		SchemaEntry("ifccoiltypeenum",nullptr )
+,		SchemaEntry("ifcangularvelocitymeasure",nullptr )
+,		SchemaEntry("ifcanalysismodeltypeenum",nullptr )
+,		SchemaEntry("ifclibraryselect",nullptr )
+,		SchemaEntry("ifcforcemeasure",nullptr )
+,		SchemaEntry("ifcfillareastyletileshapeselect",nullptr )
+,		SchemaEntry("ifcelectricappliancetypeenum",nullptr )
+,		SchemaEntry("ifcsurfacetextureenum",nullptr )
+,		SchemaEntry("ifccharacterstyleselect",nullptr )
+,		SchemaEntry("ifcenergymeasure",nullptr )
+,		SchemaEntry("ifcreal",nullptr )
+,		SchemaEntry("ifccompressortypeenum",nullptr )
+,		SchemaEntry("ifcelectricdistributionpointfunctionenum",nullptr )
 ,		SchemaEntry("ifcroot",&STEP::ObjectHelper<IfcRoot,4>::Construct )
 ,		SchemaEntry("ifcobjectdefinition",&STEP::ObjectHelper<IfcObjectDefinition,0>::Construct )
 ,		SchemaEntry("ifctypeobject",&STEP::ObjectHelper<IfcTypeObject,2>::Construct )
@@ -1058,27 +1063,27 @@ template <> size_t GenericFill<IfcRoot>(const DB& db, const LIST& params, IfcRoo
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRoot"); }    do { // convert the 'GlobalId' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRoot,4>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->GlobalId, arg, db ); break; } 
+        try { GenericConvert( in->GlobalId, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRoot to be a `IfcGloballyUniqueId`")); }
     } while(0);
     do { // convert the 'OwnerHistory' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRoot,4>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->OwnerHistory, arg, db ); break; } 
+        try { GenericConvert( in->OwnerHistory, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRoot to be a `IfcOwnerHistory`")); }
     } while(0);
     do { // convert the 'Name' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRoot,4>::aux_is_derived[2]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Name, arg, db ); break; } 
+        try { GenericConvert( in->Name, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcRoot to be a `IfcLabel`")); }
     } while(0);
     do { // convert the 'Description' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRoot,4>::aux_is_derived[3]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Description, arg, db ); break; } 
+        try { GenericConvert( in->Description, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRoot to be a `IfcText`")); }
     } while(0);
 	return base;
@@ -1145,27 +1150,27 @@ template <> size_t GenericFill<IfcRepresentation>(const DB& db, const LIST& para
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRepresentation"); }    do { // convert the 'ContextOfItems' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentation,4>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->ContextOfItems, arg, db ); break; } 
+        try { GenericConvert( in->ContextOfItems, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRepresentation to be a `IfcRepresentationContext`")); }
     } while(0);
     do { // convert the 'RepresentationIdentifier' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentation,4>::aux_is_derived[1]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RepresentationIdentifier, arg, db ); break; } 
+        try { GenericConvert( in->RepresentationIdentifier, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRepresentation to be a `IfcLabel`")); }
     } while(0);
     do { // convert the 'RepresentationType' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentation,4>::aux_is_derived[2]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RepresentationType, arg, db ); break; } 
+        try { GenericConvert( in->RepresentationType, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcRepresentation to be a `IfcLabel`")); }
     } while(0);
     do { // convert the 'Items' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentation,4>::aux_is_derived[3]=true; break; }
-        try { GenericConvert( in->Items, arg, db ); break; } 
+        try { GenericConvert( in->Items, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRepresentation to be a `SET [1:?] OF IfcRepresentationItem`")); }
     } while(0);
 	return base;
@@ -1232,7 +1237,7 @@ template <> size_t GenericFill<IfcObject>(const DB& db, const LIST& params, IfcO
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcObject,1>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ObjectType, arg, db ); break; } 
+        try { GenericConvert( in->ObjectType, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcObject to be a `IfcLabel`")); }
     } while(0);
 	return base;
@@ -1285,20 +1290,20 @@ template <> size_t GenericFill<IfcProductRepresentation>(const DB& db, const LIS
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProductRepresentation,3>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Name, arg, db ); break; } 
+        try { GenericConvert( in->Name, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcProductRepresentation to be a `IfcLabel`")); }
     } while(0);
     do { // convert the 'Description' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProductRepresentation,3>::aux_is_derived[1]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Description, arg, db ); break; } 
+        try { GenericConvert( in->Description, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcProductRepresentation to be a `IfcText`")); }
     } while(0);
     do { // convert the 'Representations' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProductRepresentation,3>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->Representations, arg, db ); break; } 
+        try { GenericConvert( in->Representations, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcProductRepresentation to be a `LIST [1:?] OF IfcRepresentation`")); }
     } while(0);
 	return base;
@@ -1311,14 +1316,14 @@ template <> size_t GenericFill<IfcProduct>(const DB& db, const LIST& params, Ifc
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProduct,2>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ObjectPlacement, arg, db ); break; } 
+        try { GenericConvert( in->ObjectPlacement, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcProduct to be a `IfcObjectPlacement`")); }
     } while(0);
     do { // convert the 'Representation' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProduct,2>::aux_is_derived[1]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Representation, arg, db ); break; } 
+        try { GenericConvert( in->Representation, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcProduct to be a `IfcProductRepresentation`")); }
     } while(0);
 	return base;
@@ -1331,7 +1336,7 @@ template <> size_t GenericFill<IfcElement>(const DB& db, const LIST& params, Ifc
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcElement,1>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Tag, arg, db ); break; } 
+        try { GenericConvert( in->Tag, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcElement to be a `IfcIdentifier`")); }
     } while(0);
 	return base;
@@ -1369,13 +1374,13 @@ template <> size_t GenericFill<IfcCompositeCurve>(const DB& db, const LIST& para
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcCompositeCurve"); }    do { // convert the 'Segments' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCompositeCurve,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Segments, arg, db ); break; } 
+        try { GenericConvert( in->Segments, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCompositeCurve to be a `LIST [1:?] OF IfcCompositeCurveSegment`")); }
     } while(0);
     do { // convert the 'SelfIntersect' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCompositeCurve,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->SelfIntersect, arg, db ); break; } 
+        try { GenericConvert( in->SelfIntersect, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCompositeCurve to be a `LOGICAL`")); }
     } while(0);
 	return base;
@@ -1395,27 +1400,27 @@ template <> size_t GenericFill<IfcCartesianTransformationOperator>(const DB& db,
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCartesianTransformationOperator,4>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Axis1, arg, db ); break; } 
+        try { GenericConvert( in->Axis1, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCartesianTransformationOperator to be a `IfcDirection`")); }
     } while(0);
     do { // convert the 'Axis2' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCartesianTransformationOperator,4>::aux_is_derived[1]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Axis2, arg, db ); break; } 
+        try { GenericConvert( in->Axis2, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCartesianTransformationOperator to be a `IfcDirection`")); }
     } while(0);
     do { // convert the 'LocalOrigin' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCartesianTransformationOperator,4>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->LocalOrigin, arg, db ); break; } 
+        try { GenericConvert( in->LocalOrigin, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcCartesianTransformationOperator to be a `IfcCartesianPoint`")); }
     } while(0);
     do { // convert the 'Scale' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCartesianTransformationOperator,4>::aux_is_derived[3]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Scale, arg, db ); break; } 
+        try { GenericConvert( in->Scale, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcCartesianTransformationOperator to be a `REAL`")); }
     } while(0);
 	return base;
@@ -1428,7 +1433,7 @@ template <> size_t GenericFill<IfcCartesianTransformationOperator3D>(const DB& d
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCartesianTransformationOperator3D,1>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Axis3, arg, db ); break; } 
+        try { GenericConvert( in->Axis3, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcCartesianTransformationOperator3D to be a `IfcDirection`")); }
     } while(0);
 	return base;
@@ -1440,14 +1445,14 @@ template <> size_t GenericFill<IfcProperty>(const DB& db, const LIST& params, If
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcProperty"); }    do { // convert the 'Name' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProperty,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Name, arg, db ); break; } 
+        try { GenericConvert( in->Name, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcProperty to be a `IfcIdentifier`")); }
     } while(0);
     do { // convert the 'Description' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProperty,2>::aux_is_derived[1]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Description, arg, db ); break; } 
+        try { GenericConvert( in->Description, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcProperty to be a `IfcText`")); }
     } while(0);
 	return base;
@@ -1492,7 +1497,7 @@ template <> size_t GenericFill<IfcElementarySurface>(const DB& db, const LIST& p
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcElementarySurface"); }    do { // convert the 'Position' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcElementarySurface,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Position, arg, db ); break; } 
+        try { GenericConvert( in->Position, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcElementarySurface to be a `IfcAxis2Placement3D`")); }
     } while(0);
 	return base;
@@ -1510,19 +1515,19 @@ template <> size_t GenericFill<IfcBooleanResult>(const DB& db, const LIST& param
 	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcBooleanResult"); }    do { // convert the 'Operator' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBooleanResult,3>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Operator, arg, db ); break; } 
+        try { GenericConvert( in->Operator, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcBooleanResult to be a `IfcBooleanOperator`")); }
     } while(0);
     do { // convert the 'FirstOperand' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBooleanResult,3>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->FirstOperand, arg, db ); break; } 
+        try { GenericConvert( in->FirstOperand, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcBooleanResult to be a `IfcBooleanOperand`")); }
     } while(0);
     do { // convert the 'SecondOperand' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBooleanResult,3>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->SecondOperand, arg, db ); break; } 
+        try { GenericConvert( in->SecondOperand, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcBooleanResult to be a `IfcBooleanOperand`")); }
     } while(0);
 	return base;
@@ -1546,7 +1551,7 @@ template <> size_t GenericFill<IfcManifoldSolidBrep>(const DB& db, const LIST& p
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcManifoldSolidBrep"); }    do { // convert the 'Outer' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcManifoldSolidBrep,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Outer, arg, db ); break; } 
+        try { GenericConvert( in->Outer, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcManifoldSolidBrep to be a `IfcClosedShell`")); }
     } while(0);
 	return base;
@@ -1625,12 +1630,12 @@ template <> size_t GenericFill<IfcRelFillsElement>(const DB& db, const LIST& par
 	size_t base = GenericFill(db,params,static_cast<IfcRelConnects*>(in));
 	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelFillsElement"); }    do { // convert the 'RelatingOpeningElement' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatingOpeningElement, arg, db ); break; } 
+        try { GenericConvert( in->RelatingOpeningElement, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelFillsElement to be a `IfcOpeningElement`")); }
     } while(0);
     do { // convert the 'RelatedBuildingElement' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatedBuildingElement, arg, db ); break; } 
+        try { GenericConvert( in->RelatedBuildingElement, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelFillsElement to be a `IfcElement`")); }
     } while(0);
 	return base;
@@ -1676,12 +1681,12 @@ template <> size_t GenericFill<IfcRelContainedInSpatialStructure>(const DB& db,
 	size_t base = GenericFill(db,params,static_cast<IfcRelConnects*>(in));
 	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelContainedInSpatialStructure"); }    do { // convert the 'RelatedElements' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatedElements, arg, db ); break; } 
+        try { GenericConvert( in->RelatedElements, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelContainedInSpatialStructure to be a `SET [1:?] OF IfcProduct`")); }
     } while(0);
     do { // convert the 'RelatingStructure' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatingStructure, arg, db ); break; } 
+        try { GenericConvert( in->RelatingStructure, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelContainedInSpatialStructure to be a `IfcSpatialStructureElement`")); }
     } while(0);
 	return base;
@@ -1767,7 +1772,7 @@ template <> size_t GenericFill<IfcDirection>(const DB& db, const LIST& params, I
 	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcDirection"); }    do { // convert the 'DirectionRatios' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->DirectionRatios, arg, db ); break; } 
+        try { GenericConvert( in->DirectionRatios, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcDirection to be a `LIST [2:3] OF REAL`")); }
     } while(0);
 	return base;
@@ -1779,14 +1784,14 @@ template <> size_t GenericFill<IfcProfileDef>(const DB& db, const LIST& params,
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcProfileDef"); }    do { // convert the 'ProfileType' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProfileDef,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->ProfileType, arg, db ); break; } 
+        try { GenericConvert( in->ProfileType, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcProfileDef to be a `IfcProfileTypeEnum`")); }
     } while(0);
     do { // convert the 'ProfileName' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProfileDef,2>::aux_is_derived[1]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ProfileName, arg, db ); break; } 
+        try { GenericConvert( in->ProfileName, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcProfileDef to be a `IfcLabel`")); }
     } while(0);
 	return base;
@@ -1798,7 +1803,7 @@ template <> size_t GenericFill<IfcParameterizedProfileDef>(const DB& db, const L
 	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcParameterizedProfileDef"); }    do { // convert the 'Position' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcParameterizedProfileDef,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Position, arg, db ); break; } 
+        try { GenericConvert( in->Position, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcParameterizedProfileDef to be a `IfcAxis2Placement2D`")); }
     } while(0);
 	return base;
@@ -1905,7 +1910,7 @@ template <> size_t GenericFill<IfcCircleProfileDef>(const DB& db, const LIST& pa
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcCircleProfileDef"); }    do { // convert the 'Radius' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCircleProfileDef,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Radius, arg, db ); break; } 
+        try { GenericConvert( in->Radius, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcCircleProfileDef to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
 	return base;
@@ -1916,7 +1921,7 @@ template <> size_t GenericFill<IfcCircleHollowProfileDef>(const DB& db, const LI
 	size_t base = GenericFill(db,params,static_cast<IfcCircleProfileDef*>(in));
 	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcCircleHollowProfileDef"); }    do { // convert the 'WallThickness' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->WallThickness, arg, db ); break; } 
+        try { GenericConvert( in->WallThickness, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcCircleHollowProfileDef to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
 	return base;
@@ -1928,7 +1933,7 @@ template <> size_t GenericFill<IfcPlacement>(const DB& db, const LIST& params, I
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPlacement"); }    do { // convert the 'Location' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcPlacement,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Location, arg, db ); break; } 
+        try { GenericConvert( in->Location, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPlacement to be a `IfcCartesianPoint`")); }
     } while(0);
 	return base;
@@ -1940,13 +1945,13 @@ template <> size_t GenericFill<IfcAxis2Placement3D>(const DB& db, const LIST& pa
 	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcAxis2Placement3D"); }    do { // convert the 'Axis' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Axis, arg, db ); break; } 
+        try { GenericConvert( in->Axis, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcAxis2Placement3D to be a `IfcDirection`")); }
     } while(0);
     do { // convert the 'RefDirection' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RefDirection, arg, db ); break; } 
+        try { GenericConvert( in->RefDirection, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcAxis2Placement3D to be a `IfcDirection`")); }
     } while(0);
 	return base;
@@ -1959,7 +1964,7 @@ template <> size_t GenericFill<IfcPresentationStyle>(const DB& db, const LIST& p
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcPresentationStyle,1>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Name, arg, db ); break; } 
+        try { GenericConvert( in->Name, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPresentationStyle to be a `IfcLabel`")); }
     } while(0);
 	return base;
@@ -1977,17 +1982,17 @@ template <> size_t GenericFill<IfcCompositeCurveSegment>(const DB& db, const LIS
 	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
 	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcCompositeCurveSegment"); }    do { // convert the 'Transition' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Transition, arg, db ); break; } 
+        try { GenericConvert( in->Transition, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCompositeCurveSegment to be a `IfcTransitionCode`")); }
     } while(0);
     do { // convert the 'SameSense' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->SameSense, arg, db ); break; } 
+        try { GenericConvert( in->SameSense, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCompositeCurveSegment to be a `BOOLEAN`")); }
     } while(0);
     do { // convert the 'ParentCurve' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->ParentCurve, arg, db ); break; } 
+        try { GenericConvert( in->ParentCurve, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcCompositeCurveSegment to be a `IfcCurve`")); }
     } while(0);
 	return base;
@@ -1999,13 +2004,13 @@ template <> size_t GenericFill<IfcRectangleProfileDef>(const DB& db, const LIST&
 	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcRectangleProfileDef"); }    do { // convert the 'XDim' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRectangleProfileDef,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->XDim, arg, db ); break; } 
+        try { GenericConvert( in->XDim, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRectangleProfileDef to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
     do { // convert the 'YDim' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRectangleProfileDef,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->YDim, arg, db ); break; } 
+        try { GenericConvert( in->YDim, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRectangleProfileDef to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
 	return base;
@@ -2101,12 +2106,12 @@ template <> size_t GenericFill<IfcLocalPlacement>(const DB& db, const LIST& para
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcLocalPlacement"); }    do { // convert the 'PlacementRelTo' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->PlacementRelTo, arg, db ); break; } 
+        try { GenericConvert( in->PlacementRelTo, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcLocalPlacement to be a `IfcObjectPlacement`")); }
     } while(0);
     do { // convert the 'RelativePlacement' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelativePlacement, arg, db ); break; } 
+        try { GenericConvert( in->RelativePlacement, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcLocalPlacement to be a `IfcAxis2Placement`")); }
     } while(0);
 	return base;
@@ -2118,13 +2123,13 @@ template <> size_t GenericFill<IfcSweptAreaSolid>(const DB& db, const LIST& para
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcSweptAreaSolid"); }    do { // convert the 'SweptArea' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcSweptAreaSolid,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->SweptArea, arg, db ); break; } 
+        try { GenericConvert( in->SweptArea, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSweptAreaSolid to be a `IfcProfileDef`")); }
     } while(0);
     do { // convert the 'Position' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcSweptAreaSolid,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->Position, arg, db ); break; } 
+        try { GenericConvert( in->Position, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSweptAreaSolid to be a `IfcAxis2Placement3D`")); }
     } while(0);
 	return base;
@@ -2135,12 +2140,12 @@ template <> size_t GenericFill<IfcRevolvedAreaSolid>(const DB& db, const LIST& p
 	size_t base = GenericFill(db,params,static_cast<IfcSweptAreaSolid*>(in));
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRevolvedAreaSolid"); }    do { // convert the 'Axis' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Axis, arg, db ); break; } 
+        try { GenericConvert( in->Axis, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcRevolvedAreaSolid to be a `IfcAxis1Placement`")); }
     } while(0);
     do { // convert the 'Angle' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Angle, arg, db ); break; } 
+        try { GenericConvert( in->Angle, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRevolvedAreaSolid to be a `IfcPlaneAngleMeasure`")); }
     } while(0);
 	return base;
@@ -2165,28 +2170,28 @@ template <> size_t GenericFill<IfcSweptDiskSolid>(const DB& db, const LIST& para
 	size_t base = GenericFill(db,params,static_cast<IfcSolidModel*>(in));
 	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcSweptDiskSolid"); }    do { // convert the 'Directrix' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Directrix, arg, db ); break; } 
+        try { GenericConvert( in->Directrix, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSweptDiskSolid to be a `IfcCurve`")); }
     } while(0);
     do { // convert the 'Radius' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Radius, arg, db ); break; } 
+        try { GenericConvert( in->Radius, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSweptDiskSolid to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
     do { // convert the 'InnerRadius' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->InnerRadius, arg, db ); break; } 
+        try { GenericConvert( in->InnerRadius, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSweptDiskSolid to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
     do { // convert the 'StartParam' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->StartParam, arg, db ); break; } 
+        try { GenericConvert( in->StartParam, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcSweptDiskSolid to be a `IfcParameterValue`")); }
     } while(0);
     do { // convert the 'EndParam' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->EndParam, arg, db ); break; } 
+        try { GenericConvert( in->EndParam, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcSweptDiskSolid to be a `IfcParameterValue`")); }
     } while(0);
 	return base;
@@ -2198,13 +2203,13 @@ template <> size_t GenericFill<IfcHalfSpaceSolid>(const DB& db, const LIST& para
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcHalfSpaceSolid"); }    do { // convert the 'BaseSurface' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcHalfSpaceSolid,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->BaseSurface, arg, db ); break; } 
+        try { GenericConvert( in->BaseSurface, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcHalfSpaceSolid to be a `IfcSurface`")); }
     } while(0);
     do { // convert the 'AgreementFlag' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcHalfSpaceSolid,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->AgreementFlag, arg, db ); break; } 
+        try { GenericConvert( in->AgreementFlag, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcHalfSpaceSolid to be a `BOOLEAN`")); }
     } while(0);
 	return base;
@@ -2215,12 +2220,12 @@ template <> size_t GenericFill<IfcPolygonalBoundedHalfSpace>(const DB& db, const
 	size_t base = GenericFill(db,params,static_cast<IfcHalfSpaceSolid*>(in));
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcPolygonalBoundedHalfSpace"); }    do { // convert the 'Position' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Position, arg, db ); break; } 
+        try { GenericConvert( in->Position, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcPolygonalBoundedHalfSpace to be a `IfcAxis2Placement3D`")); }
     } while(0);
     do { // convert the 'PolygonalBoundary' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->PolygonalBoundary, arg, db ); break; } 
+        try { GenericConvert( in->PolygonalBoundary, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcPolygonalBoundedHalfSpace to be a `IfcBoundedCurve`")); }
     } while(0);
 	return base;
@@ -2246,23 +2251,23 @@ template <> size_t GenericFill<IfcProject>(const DB& db, const LIST& params, Ifc
 	if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to IfcProject"); }    do { // convert the 'LongName' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->LongName, arg, db ); break; } 
+        try { GenericConvert( in->LongName, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcProject to be a `IfcLabel`")); }
     } while(0);
     do { // convert the 'Phase' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Phase, arg, db ); break; } 
+        try { GenericConvert( in->Phase, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcProject to be a `IfcLabel`")); }
     } while(0);
     do { // convert the 'RepresentationContexts' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RepresentationContexts, arg, db ); break; } 
+        try { GenericConvert( in->RepresentationContexts, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcProject to be a `SET [1:?] OF IfcRepresentationContext`")); }
     } while(0);
     do { // convert the 'UnitsInContext' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->UnitsInContext, arg, db ); break; } 
+        try { GenericConvert( in->UnitsInContext, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcProject to be a `IfcUnitAssignment`")); }
     } while(0);
 	return base;
@@ -2322,27 +2327,27 @@ template <> size_t GenericFill<IfcTrimmedCurve>(const DB& db, const LIST& params
 	size_t base = GenericFill(db,params,static_cast<IfcBoundedCurve*>(in));
 	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcTrimmedCurve"); }    do { // convert the 'BasisCurve' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->BasisCurve, arg, db ); break; } 
+        try { GenericConvert( in->BasisCurve, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcTrimmedCurve to be a `IfcCurve`")); }
     } while(0);
     do { // convert the 'Trim1' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Trim1, arg, db ); break; } 
+        try { GenericConvert( in->Trim1, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcTrimmedCurve to be a `SET [1:2] OF IfcTrimmingSelect`")); }
     } while(0);
     do { // convert the 'Trim2' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Trim2, arg, db ); break; } 
+        try { GenericConvert( in->Trim2, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcTrimmedCurve to be a `SET [1:2] OF IfcTrimmingSelect`")); }
     } while(0);
     do { // convert the 'SenseAgreement' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->SenseAgreement, arg, db ); break; } 
+        try { GenericConvert( in->SenseAgreement, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcTrimmedCurve to be a `BOOLEAN`")); }
     } while(0);
     do { // convert the 'MasterRepresentation' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->MasterRepresentation, arg, db ); break; } 
+        try { GenericConvert( in->MasterRepresentation, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcTrimmedCurve to be a `IfcTrimmingPreference`")); }
     } while(0);
 	return base;
@@ -2354,7 +2359,7 @@ template <> size_t GenericFill<IfcRelDefines>(const DB& db, const LIST& params,
 	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcRelDefines"); }    do { // convert the 'RelatedObjects' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRelDefines,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->RelatedObjects, arg, db ); break; } 
+        try { GenericConvert( in->RelatedObjects, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelDefines to be a `SET [1:?] OF IfcObject`")); }
     } while(0);
 	return base;
@@ -2366,7 +2371,7 @@ template <> size_t GenericFill<IfcRelDefinesByProperties>(const DB& db, const LI
 	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelDefinesByProperties"); }    do { // convert the 'RelatingPropertyDefinition' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRelDefinesByProperties,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->RelatingPropertyDefinition, arg, db ); break; } 
+        try { GenericConvert( in->RelatingPropertyDefinition, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelDefinesByProperties to be a `IfcPropertySetDefinition`")); }
     } while(0);
 	return base;
@@ -2399,7 +2404,7 @@ template <> size_t GenericFill<IfcArbitraryOpenProfileDef>(const DB& db, const L
 	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcArbitraryOpenProfileDef"); }    do { // convert the 'Curve' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcArbitraryOpenProfileDef,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Curve, arg, db ); break; } 
+        try { GenericConvert( in->Curve, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcArbitraryOpenProfileDef to be a `IfcBoundedCurve`")); }
     } while(0);
 	return base;
@@ -2565,13 +2570,13 @@ template <> size_t GenericFill<IfcRelDecomposes>(const DB& db, const LIST& param
 	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelDecomposes"); }    do { // convert the 'RelatingObject' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRelDecomposes,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->RelatingObject, arg, db ); break; } 
+        try { GenericConvert( in->RelatingObject, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelDecomposes to be a `IfcObjectDefinition`")); }
     } while(0);
     do { // convert the 'RelatedObjects' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRelDecomposes,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->RelatedObjects, arg, db ); break; } 
+        try { GenericConvert( in->RelatedObjects, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelDecomposes to be a `SET [1:?] OF IfcObjectDefinition`")); }
     } while(0);
 	return base;
@@ -2589,7 +2594,7 @@ template <> size_t GenericFill<IfcPolyline>(const DB& db, const LIST& params, If
 	size_t base = GenericFill(db,params,static_cast<IfcBoundedCurve*>(in));
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPolyline"); }    do { // convert the 'Points' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Points, arg, db ); break; } 
+        try { GenericConvert( in->Points, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPolyline to be a `LIST [2:?] OF IfcCartesianPoint`")); }
     } while(0);
 	return base;
@@ -2621,12 +2626,12 @@ template <> size_t GenericFill<IfcMappedItem>(const DB& db, const LIST& params,
 	size_t base = GenericFill(db,params,static_cast<IfcRepresentationItem*>(in));
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcMappedItem"); }    do { // convert the 'MappingSource' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->MappingSource, arg, db ); break; } 
+        try { GenericConvert( in->MappingSource, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcMappedItem to be a `IfcRepresentationMap`")); }
     } while(0);
     do { // convert the 'MappingTarget' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->MappingTarget, arg, db ); break; } 
+        try { GenericConvert( in->MappingTarget, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcMappedItem to be a `IfcCartesianTransformationOperator`")); }
     } while(0);
 	return base;
@@ -2653,13 +2658,13 @@ template <> size_t GenericFill<IfcNamedUnit>(const DB& db, const LIST& params, I
         std::shared_ptr<const DataType> arg = params[base++];
 		if (dynamic_cast<const UNSET*>(&*arg)) break;
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcNamedUnit,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Dimensions, arg, db ); break; } 
+        try { GenericConvert( in->Dimensions, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcNamedUnit to be a `IfcDimensionalExponents`")); }
     } while(0);
     do { // convert the 'UnitType' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcNamedUnit,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->UnitType, arg, db ); break; } 
+        try { GenericConvert( in->UnitType, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcNamedUnit to be a `IfcUnitEnum`")); }
     } while(0);
 	return base;
@@ -2714,13 +2719,13 @@ template <> size_t GenericFill<IfcSpatialStructureElement>(const DB& db, const L
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcSpatialStructureElement,2>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->LongName, arg, db ); break; } 
+        try { GenericConvert( in->LongName, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcSpatialStructureElement to be a `IfcLabel`")); }
     } while(0);
     do { // convert the 'CompositionType' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcSpatialStructureElement,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->CompositionType, arg, db ); break; } 
+        try { GenericConvert( in->CompositionType, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcSpatialStructureElement to be a `IfcElementCompositionEnum`")); }
     } while(0);
 	return base;
@@ -2732,19 +2737,19 @@ template <> size_t GenericFill<IfcBuilding>(const DB& db, const LIST& params, If
 	if (params.GetSize() < 12) { throw STEP::TypeError("expected 12 arguments to IfcBuilding"); }    do { // convert the 'ElevationOfRefHeight' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ElevationOfRefHeight, arg, db ); break; } 
+        try { GenericConvert( in->ElevationOfRefHeight, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcBuilding to be a `IfcLengthMeasure`")); }
     } while(0);
     do { // convert the 'ElevationOfTerrain' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ElevationOfTerrain, arg, db ); break; } 
+        try { GenericConvert( in->ElevationOfTerrain, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to IfcBuilding to be a `IfcLengthMeasure`")); }
     } while(0);
     do { // convert the 'BuildingAddress' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->BuildingAddress, arg, db ); break; } 
+        try { GenericConvert( in->BuildingAddress, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 11 to IfcBuilding to be a `IfcPostalAddress`")); }
     } while(0);
 	return base;
@@ -2756,7 +2761,7 @@ template <> size_t GenericFill<IfcConnectedFaceSet>(const DB& db, const LIST& pa
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcConnectedFaceSet"); }    do { // convert the 'CfsFaces' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcConnectedFaceSet,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->CfsFaces, arg, db ); break; } 
+        try { GenericConvert( in->CfsFaces, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcConnectedFaceSet to be a `SET [1:?] OF IfcFace`")); }
     } while(0);
 	return base;
@@ -2782,7 +2787,7 @@ template <> size_t GenericFill<IfcConic>(const DB& db, const LIST& params, IfcCo
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcConic"); }    do { // convert the 'Position' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcConic,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Position, arg, db ); break; } 
+        try { GenericConvert( in->Position, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcConic to be a `IfcAxis2Placement`")); }
     } while(0);
 	return base;
@@ -2829,32 +2834,32 @@ template <> size_t GenericFill<IfcIShapeProfileDef>(const DB& db, const LIST& pa
 	if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to IfcIShapeProfileDef"); }    do { // convert the 'OverallWidth' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcIShapeProfileDef,5>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->OverallWidth, arg, db ); break; } 
+        try { GenericConvert( in->OverallWidth, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
     do { // convert the 'OverallDepth' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcIShapeProfileDef,5>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->OverallDepth, arg, db ); break; } 
+        try { GenericConvert( in->OverallDepth, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
     do { // convert the 'WebThickness' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcIShapeProfileDef,5>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->WebThickness, arg, db ); break; } 
+        try { GenericConvert( in->WebThickness, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
     do { // convert the 'FlangeThickness' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcIShapeProfileDef,5>::aux_is_derived[3]=true; break; }
-        try { GenericConvert( in->FlangeThickness, arg, db ); break; } 
+        try { GenericConvert( in->FlangeThickness, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
     do { // convert the 'FilletRadius' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcIShapeProfileDef,5>::aux_is_derived[4]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->FilletRadius, arg, db ); break; } 
+        try { GenericConvert( in->FilletRadius, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
 	return base;
@@ -2928,13 +2933,13 @@ template <> size_t GenericFill<IfcPropertyListValue>(const DB& db, const LIST& p
 	size_t base = GenericFill(db,params,static_cast<IfcSimpleProperty*>(in));
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcPropertyListValue"); }    do { // convert the 'ListValues' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->ListValues, arg, db ); break; } 
+        try { GenericConvert( in->ListValues, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcPropertyListValue to be a `LIST [1:?] OF IfcValue`")); }
     } while(0);
     do { // convert the 'Unit' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Unit, arg, db ); break; } 
+        try { GenericConvert( in->Unit, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcPropertyListValue to be a `IfcUnit`")); }
     } while(0);
 	return base;
@@ -2960,13 +2965,13 @@ template <> size_t GenericFill<IfcDoor>(const DB& db, const LIST& params, IfcDoo
 	if (params.GetSize() < 10) { throw STEP::TypeError("expected 10 arguments to IfcDoor"); }    do { // convert the 'OverallHeight' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->OverallHeight, arg, db ); break; } 
+        try { GenericConvert( in->OverallHeight, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcDoor to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
     do { // convert the 'OverallWidth' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->OverallWidth, arg, db ); break; } 
+        try { GenericConvert( in->OverallWidth, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcDoor to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
 	return base;
@@ -2979,20 +2984,20 @@ template <> size_t GenericFill<IfcStyledItem>(const DB& db, const LIST& params,
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcStyledItem,3>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Item, arg, db ); break; } 
+        try { GenericConvert( in->Item, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcStyledItem to be a `IfcRepresentationItem`")); }
     } while(0);
     do { // convert the 'Styles' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcStyledItem,3>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->Styles, arg, db ); break; } 
+        try { GenericConvert( in->Styles, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcStyledItem to be a `SET [1:?] OF IfcPresentationStyleAssignment`")); }
     } while(0);
     do { // convert the 'Name' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcStyledItem,3>::aux_is_derived[2]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Name, arg, db ); break; } 
+        try { GenericConvert( in->Name, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcStyledItem to be a `IfcLabel`")); }
     } while(0);
 	return base;
@@ -3018,7 +3023,7 @@ template <> size_t GenericFill<IfcArbitraryClosedProfileDef>(const DB& db, const
 	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcArbitraryClosedProfileDef"); }    do { // convert the 'OuterCurve' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcArbitraryClosedProfileDef,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->OuterCurve, arg, db ); break; } 
+        try { GenericConvert( in->OuterCurve, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcArbitraryClosedProfileDef to be a `IfcCurve`")); }
     } while(0);
 	return base;
@@ -3036,12 +3041,12 @@ template <> size_t GenericFill<IfcLine>(const DB& db, const LIST& params, IfcLin
 	size_t base = GenericFill(db,params,static_cast<IfcCurve*>(in));
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcLine"); }    do { // convert the 'Pnt' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Pnt, arg, db ); break; } 
+        try { GenericConvert( in->Pnt, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcLine to be a `IfcCartesianPoint`")); }
     } while(0);
     do { // convert the 'Dir' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Dir, arg, db ); break; } 
+        try { GenericConvert( in->Dir, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcLine to be a `IfcVector`")); }
     } while(0);
 	return base;
@@ -3067,13 +3072,13 @@ template <> size_t GenericFill<IfcPropertySingleValue>(const DB& db, const LIST&
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcPropertySingleValue"); }    do { // convert the 'NominalValue' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->NominalValue, arg, db ); break; } 
+        try { GenericConvert( in->NominalValue, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcPropertySingleValue to be a `IfcValue`")); }
     } while(0);
     do { // convert the 'Unit' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Unit, arg, db ); break; } 
+        try { GenericConvert( in->Unit, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcPropertySingleValue to be a `IfcUnit`")); }
     } while(0);
 	return base;
@@ -3106,7 +3111,7 @@ template <> size_t GenericFill<IfcSurfaceStyleShading>(const DB& db, const LIST&
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcSurfaceStyleShading"); }    do { // convert the 'SurfaceColour' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcSurfaceStyleShading,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->SurfaceColour, arg, db ); break; } 
+        try { GenericConvert( in->SurfaceColour, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSurfaceStyleShading to be a `IfcColourRgb`")); }
     } while(0);
 	return base;
@@ -3165,4 +3170,8 @@ template <> size_t GenericFill<IfcLightSourceDirectional>(const DB& db, const LI
 } // ! STEP
 } // ! Assimp
 
+#if _MSC_VER
+#    pragma warning(pop)
+#endif // _MSC_VER
+
 #endif
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen2_2x3.cpp b/Engine/lib/assimp/code/AssetLib/IFC/IFCReaderGen2_2x3.cpp
similarity index 98%
rename from Engine/lib/assimp/code/Importer/IFC/IFCReaderGen2_2x3.cpp
rename to Engine/lib/assimp/code/AssetLib/IFC/IFCReaderGen2_2x3.cpp
index 7dabe278e..0d7051195 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen2_2x3.cpp
+++ b/Engine/lib/assimp/code/AssetLib/IFC/IFCReaderGen2_2x3.cpp
@@ -2,11 +2,11 @@
 Open Asset Import Library (ASSIMP)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2010, ASSIMP Development Team
+Copyright (c) 2006-2020, ASSIMP Development Team
 All rights reserved.
 
-Redistribution and use of this software in source and binary forms, 
-with or without modification, are permitted provided that the 
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
 following conditions are met:
 
 * Redistributions of source code must retain the above
@@ -23,16 +23,16 @@ following conditions are met:
   derived from this software without specific prior
   written permission of the ASSIMP Development Team.
 
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 ----------------------------------------------------------------------
@@ -43,6 +43,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "IFCReaderGen_2x3.h"
 
+#if _MSC_VER
+#    pragma warning(push)
+#    pragma warning(disable : 4702)
+#endif // _MSC_VER
+
 namespace Assimp {
 using namespace IFC;
 using namespace ::Assimp::IFC::Schema_2x3;
@@ -54,12 +59,12 @@ template <> size_t GenericFill<IfcSurfaceStyle>(const DB& db, const LIST& params
 	size_t base = GenericFill(db,params,static_cast<IfcPresentationStyle*>(in));
 	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcSurfaceStyle"); }    do { // convert the 'Side' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Side, arg, db ); break; } 
+        try { GenericConvert( in->Side, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSurfaceStyle to be a `IfcSurfaceSide`")); }
     } while(0);
     do { // convert the 'Styles' argument
         std::shared_ptr<const DataType> arg = params[ base++ ];
-        try { GenericConvert( in->Styles, arg, db ); break; } 
+        try { GenericConvert( in->Styles, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSurfaceStyle to be a `SET [1:5] OF IfcSurfaceStyleElementSelect`")); }
     } while(0);
 	return base;
@@ -113,7 +118,7 @@ template <> size_t GenericFill<IfcFace>(const DB& db, const LIST& params, IfcFac
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcFace"); }    do { // convert the 'Bounds' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcFace,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Bounds, arg, db ); break; } 
+        try { GenericConvert( in->Bounds, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcFace to be a `SET [1:?] OF IfcFaceBound`")); }
     } while(0);
 	return base;
@@ -168,7 +173,7 @@ template <> size_t GenericFill<IfcColourSpecification>(const DB& db, const LIST&
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcColourSpecification,1>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Name, arg, db ); break; } 
+        try { GenericConvert( in->Name, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcColourSpecification to be a `IfcLabel`")); }
     } while(0);
 	return base;
@@ -179,12 +184,12 @@ template <> size_t GenericFill<IfcVector>(const DB& db, const LIST& params, IfcV
 	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcVector"); }    do { // convert the 'Orientation' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Orientation, arg, db ); break; } 
+        try { GenericConvert( in->Orientation, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcVector to be a `IfcDirection`")); }
     } while(0);
     do { // convert the 'Magnitude' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Magnitude, arg, db ); break; } 
+        try { GenericConvert( in->Magnitude, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcVector to be a `IfcLengthMeasure`")); }
     } while(0);
 	return base;
@@ -202,17 +207,17 @@ template <> size_t GenericFill<IfcColourRgb>(const DB& db, const LIST& params, I
 	size_t base = GenericFill(db,params,static_cast<IfcColourSpecification*>(in));
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcColourRgb"); }    do { // convert the 'Red' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Red, arg, db ); break; } 
+        try { GenericConvert( in->Red, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcColourRgb to be a `IfcNormalisedRatioMeasure`")); }
     } while(0);
     do { // convert the 'Green' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Green, arg, db ); break; } 
+        try { GenericConvert( in->Green, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcColourRgb to be a `IfcNormalisedRatioMeasure`")); }
     } while(0);
     do { // convert the 'Blue' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Blue, arg, db ); break; } 
+        try { GenericConvert( in->Blue, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcColourRgb to be a `IfcNormalisedRatioMeasure`")); }
     } while(0);
 	return base;
@@ -238,31 +243,31 @@ template <> size_t GenericFill<IfcSite>(const DB& db, const LIST& params, IfcSit
 	if (params.GetSize() < 14) { throw STEP::TypeError("expected 14 arguments to IfcSite"); }    do { // convert the 'RefLatitude' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RefLatitude, arg, db ); break; } 
+        try { GenericConvert( in->RefLatitude, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcSite to be a `IfcCompoundPlaneAngleMeasure`")); }
     } while(0);
     do { // convert the 'RefLongitude' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RefLongitude, arg, db ); break; } 
+        try { GenericConvert( in->RefLongitude, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to IfcSite to be a `IfcCompoundPlaneAngleMeasure`")); }
     } while(0);
     do { // convert the 'RefElevation' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RefElevation, arg, db ); break; } 
+        try { GenericConvert( in->RefElevation, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 11 to IfcSite to be a `IfcLengthMeasure`")); }
     } while(0);
     do { // convert the 'LandTitleNumber' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->LandTitleNumber, arg, db ); break; } 
+        try { GenericConvert( in->LandTitleNumber, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 12 to IfcSite to be a `IfcLabel`")); }
     } while(0);
     do { // convert the 'SiteAddress' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->SiteAddress, arg, db ); break; } 
+        try { GenericConvert( in->SiteAddress, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 13 to IfcSite to be a `IfcPostalAddress`")); }
     } while(0);
 	return base;
@@ -407,31 +412,31 @@ template <> size_t GenericFill<IfcBSplineCurve>(const DB& db, const LIST& params
 	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcBSplineCurve"); }    do { // convert the 'Degree' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBSplineCurve,5>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Degree, arg, db ); break; } 
+        try { GenericConvert( in->Degree, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcBSplineCurve to be a `INTEGER`")); }
     } while(0);
     do { // convert the 'ControlPointsList' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBSplineCurve,5>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->ControlPointsList, arg, db ); break; } 
+        try { GenericConvert( in->ControlPointsList, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcBSplineCurve to be a `LIST [2:?] OF IfcCartesianPoint`")); }
     } while(0);
     do { // convert the 'CurveForm' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBSplineCurve,5>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->CurveForm, arg, db ); break; } 
+        try { GenericConvert( in->CurveForm, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcBSplineCurve to be a `IfcBSplineCurveForm`")); }
     } while(0);
     do { // convert the 'ClosedCurve' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBSplineCurve,5>::aux_is_derived[3]=true; break; }
-        try { GenericConvert( in->ClosedCurve, arg, db ); break; } 
+        try { GenericConvert( in->ClosedCurve, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcBSplineCurve to be a `LOGICAL`")); }
     } while(0);
     do { // convert the 'SelfIntersect' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBSplineCurve,5>::aux_is_derived[4]=true; break; }
-        try { GenericConvert( in->SelfIntersect, arg, db ); break; } 
+        try { GenericConvert( in->SelfIntersect, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcBSplineCurve to be a `LOGICAL`")); }
     } while(0);
 	return base;
@@ -469,7 +474,7 @@ template <> size_t GenericFill<IfcShellBasedSurfaceModel>(const DB& db, const LI
 	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcShellBasedSurfaceModel"); }    do { // convert the 'SbsmBoundary' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->SbsmBoundary, arg, db ); break; } 
+        try { GenericConvert( in->SbsmBoundary, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcShellBasedSurfaceModel to be a `SET [1:?] OF IfcShell`")); }
     } while(0);
 	return base;
@@ -487,12 +492,12 @@ template <> size_t GenericFill<IfcExtrudedAreaSolid>(const DB& db, const LIST& p
 	size_t base = GenericFill(db,params,static_cast<IfcSweptAreaSolid*>(in));
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcExtrudedAreaSolid"); }    do { // convert the 'ExtrudedDirection' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->ExtrudedDirection, arg, db ); break; } 
+        try { GenericConvert( in->ExtrudedDirection, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcExtrudedAreaSolid to be a `IfcDirection`")); }
     } while(0);
     do { // convert the 'Depth' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Depth, arg, db ); break; } 
+        try { GenericConvert( in->Depth, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcExtrudedAreaSolid to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
 	return base;
@@ -517,12 +522,12 @@ template <> size_t GenericFill<IfcRelVoidsElement>(const DB& db, const LIST& par
 	size_t base = GenericFill(db,params,static_cast<IfcRelConnects*>(in));
 	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelVoidsElement"); }    do { // convert the 'RelatingBuildingElement' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatingBuildingElement, arg, db ); break; } 
+        try { GenericConvert( in->RelatingBuildingElement, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelVoidsElement to be a `IfcElement`")); }
     } while(0);
     do { // convert the 'RelatedOpeningElement' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatedOpeningElement, arg, db ); break; } 
+        try { GenericConvert( in->RelatedOpeningElement, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelVoidsElement to be a `IfcFeatureElementSubtraction`")); }
     } while(0);
 	return base;
@@ -541,13 +546,13 @@ template <> size_t GenericFill<IfcCartesianTransformationOperator3DnonUniform>(c
 	if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to IfcCartesianTransformationOperator3DnonUniform"); }    do { // convert the 'Scale2' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Scale2, arg, db ); break; } 
+        try { GenericConvert( in->Scale2, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcCartesianTransformationOperator3DnonUniform to be a `REAL`")); }
     } while(0);
     do { // convert the 'Scale3' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Scale3, arg, db ); break; } 
+        try { GenericConvert( in->Scale3, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcCartesianTransformationOperator3DnonUniform to be a `REAL`")); }
     } while(0);
 	return base;
@@ -629,7 +634,7 @@ template <> size_t GenericFill<IfcAxis2Placement2D>(const DB& db, const LIST& pa
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcAxis2Placement2D"); }    do { // convert the 'RefDirection' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RefDirection, arg, db ); break; } 
+        try { GenericConvert( in->RefDirection, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcAxis2Placement2D to be a `IfcDirection`")); }
     } while(0);
 	return base;
@@ -653,7 +658,7 @@ template <> size_t GenericFill<IfcCartesianPoint>(const DB& db, const LIST& para
 	size_t base = GenericFill(db,params,static_cast<IfcPoint*>(in));
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcCartesianPoint"); }    do { // convert the 'Coordinates' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Coordinates, arg, db ); break; } 
+        try { GenericConvert( in->Coordinates, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCartesianPoint to be a `LIST [1:3] OF IfcLengthMeasure`")); }
     } while(0);
 	return base;
@@ -677,7 +682,7 @@ template <> size_t GenericFill<IfcPolyLoop>(const DB& db, const LIST& params, If
 	size_t base = GenericFill(db,params,static_cast<IfcLoop*>(in));
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPolyLoop"); }    do { // convert the 'Polygon' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Polygon, arg, db ); break; } 
+        try { GenericConvert( in->Polygon, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPolyLoop to be a `LIST [3:?] OF IfcCartesianPoint`")); }
     } while(0);
 	return base;
@@ -711,14 +716,14 @@ template <> size_t GenericFill<IfcRepresentationContext>(const DB& db, const LIS
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentationContext,2>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ContextIdentifier, arg, db ); break; } 
+        try { GenericConvert( in->ContextIdentifier, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRepresentationContext to be a `IfcLabel`")); }
     } while(0);
     do { // convert the 'ContextType' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentationContext,2>::aux_is_derived[1]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ContextType, arg, db ); break; } 
+        try { GenericConvert( in->ContextType, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRepresentationContext to be a `IfcLabel`")); }
     } while(0);
 	return base;
@@ -730,27 +735,27 @@ template <> size_t GenericFill<IfcGeometricRepresentationContext>(const DB& db,
 	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcGeometricRepresentationContext"); }    do { // convert the 'CoordinateSpaceDimension' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcGeometricRepresentationContext,4>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->CoordinateSpaceDimension, arg, db ); break; } 
+        try { GenericConvert( in->CoordinateSpaceDimension, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcGeometricRepresentationContext to be a `IfcDimensionCount`")); }
     } while(0);
     do { // convert the 'Precision' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcGeometricRepresentationContext,4>::aux_is_derived[1]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Precision, arg, db ); break; } 
+        try { GenericConvert( in->Precision, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcGeometricRepresentationContext to be a `REAL`")); }
     } while(0);
     do { // convert the 'WorldCoordinateSystem' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcGeometricRepresentationContext,4>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->WorldCoordinateSystem, arg, db ); break; } 
+        try { GenericConvert( in->WorldCoordinateSystem, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcGeometricRepresentationContext to be a `IfcAxis2Placement`")); }
     } while(0);
     do { // convert the 'TrueNorth' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcGeometricRepresentationContext,4>::aux_is_derived[3]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->TrueNorth, arg, db ); break; } 
+        try { GenericConvert( in->TrueNorth, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcGeometricRepresentationContext to be a `IfcDirection`")); }
     } while(0);
 	return base;
@@ -769,12 +774,12 @@ template <> size_t GenericFill<IfcSIUnit>(const DB& db, const LIST& params, IfcS
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcSIUnit"); }    do { // convert the 'Prefix' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Prefix, arg, db ); break; } 
+        try { GenericConvert( in->Prefix, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSIUnit to be a `IfcSIPrefix`")); }
     } while(0);
     do { // convert the 'Name' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Name, arg, db ); break; } 
+        try { GenericConvert( in->Name, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcSIUnit to be a `IfcSIUnitName`")); }
     } while(0);
 	return base;
@@ -800,7 +805,7 @@ template <> size_t GenericFill<IfcAxis1Placement>(const DB& db, const LIST& para
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcAxis1Placement"); }    do { // convert the 'Axis' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Axis, arg, db ); break; } 
+        try { GenericConvert( in->Axis, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcAxis1Placement to be a `IfcDirection`")); }
     } while(0);
 	return base;
@@ -853,12 +858,12 @@ template <> size_t GenericFill<IfcRepresentationMap>(const DB& db, const LIST& p
 	size_t base = 0;
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcRepresentationMap"); }    do { // convert the 'MappingOrigin' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->MappingOrigin, arg, db ); break; } 
+        try { GenericConvert( in->MappingOrigin, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRepresentationMap to be a `IfcAxis2Placement`")); }
     } while(0);
     do { // convert the 'MappedRepresentation' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->MappedRepresentation, arg, db ); break; } 
+        try { GenericConvert( in->MappedRepresentation, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRepresentationMap to be a `IfcRepresentation`")); }
     } while(0);
 	return base;
@@ -1007,12 +1012,12 @@ template <> size_t GenericFill<IfcMeasureWithUnit>(const DB& db, const LIST& par
 	size_t base = 0;
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcMeasureWithUnit"); }    do { // convert the 'ValueComponent' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->ValueComponent, arg, db ); break; } 
+        try { GenericConvert( in->ValueComponent, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcMeasureWithUnit to be a `IfcValue`")); }
     } while(0);
     do { // convert the 'UnitComponent' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->UnitComponent, arg, db ); break; } 
+        try { GenericConvert( in->UnitComponent, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcMeasureWithUnit to be a `IfcUnit`")); }
     } while(0);
 	return base;
@@ -1120,7 +1125,7 @@ template <> size_t GenericFill<IfcFaceBasedSurfaceModel>(const DB& db, const LIS
 	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcFaceBasedSurfaceModel"); }    do { // convert the 'FbsmFaces' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->FbsmFaces, arg, db ); break; } 
+        try { GenericConvert( in->FbsmFaces, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcFaceBasedSurfaceModel to be a `SET [1:?] OF IfcConnectedFaceSet`")); }
     } while(0);
 	return base;
@@ -1167,13 +1172,13 @@ template <> size_t GenericFill<IfcFaceBound>(const DB& db, const LIST& params, I
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcFaceBound"); }    do { // convert the 'Bound' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcFaceBound,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Bound, arg, db ); break; } 
+        try { GenericConvert( in->Bound, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcFaceBound to be a `IfcLoop`")); }
     } while(0);
     do { // convert the 'Orientation' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcFaceBound,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->Orientation, arg, db ); break; } 
+        try { GenericConvert( in->Orientation, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcFaceBound to be a `BOOLEAN`")); }
     } while(0);
 	return base;
@@ -1211,12 +1216,12 @@ template <> size_t GenericFill<IfcComplexProperty>(const DB& db, const LIST& par
 	size_t base = GenericFill(db,params,static_cast<IfcProperty*>(in));
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcComplexProperty"); }    do { // convert the 'UsageName' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->UsageName, arg, db ); break; } 
+        try { GenericConvert( in->UsageName, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcComplexProperty to be a `IfcIdentifier`")); }
     } while(0);
     do { // convert the 'HasProperties' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->HasProperties, arg, db ); break; } 
+        try { GenericConvert( in->HasProperties, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcComplexProperty to be a `SET [1:?] OF IfcProperty`")); }
     } while(0);
 	return base;
@@ -1269,7 +1274,7 @@ template <> size_t GenericFill<IfcUnitAssignment>(const DB& db, const LIST& para
 	size_t base = 0;
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcUnitAssignment"); }    do { // convert the 'Units' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Units, arg, db ); break; } 
+        try { GenericConvert( in->Units, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcUnitAssignment to be a `SET [1:?] OF IfcUnit`")); }
     } while(0);
 	return base;
@@ -1302,12 +1307,12 @@ template <> size_t GenericFill<IfcElementQuantity>(const DB& db, const LIST& par
 	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcElementQuantity"); }    do { // convert the 'MethodOfMeasurement' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->MethodOfMeasurement, arg, db ); break; } 
+        try { GenericConvert( in->MethodOfMeasurement, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcElementQuantity to be a `IfcLabel`")); }
     } while(0);
     do { // convert the 'Quantities' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Quantities, arg, db ); break; } 
+        try { GenericConvert( in->Quantities, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcElementQuantity to be a `SET [1:?] OF IfcPhysicalQuantity`")); }
     } while(0);
 	return base;
@@ -1374,7 +1379,7 @@ template <> size_t GenericFill<IfcPresentationStyleAssignment>(const DB& db, con
 	size_t base = 0;
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPresentationStyleAssignment"); }    do { // convert the 'Styles' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Styles, arg, db ); break; } 
+        try { GenericConvert( in->Styles, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPresentationStyleAssignment to be a `SET [1:?] OF IfcPresentationStyleSelect`")); }
     } while(0);
 	return base;
@@ -1413,13 +1418,13 @@ template <> size_t GenericFill<IfcSpace>(const DB& db, const LIST& params, IfcSp
 	size_t base = GenericFill(db,params,static_cast<IfcSpatialStructureElement*>(in));
 	if (params.GetSize() < 11) { throw STEP::TypeError("expected 11 arguments to IfcSpace"); }    do { // convert the 'InteriorOrExteriorSpace' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->InteriorOrExteriorSpace, arg, db ); break; } 
+        try { GenericConvert( in->InteriorOrExteriorSpace, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcSpace to be a `IfcInternalOrExternalEnum`")); }
     } while(0);
     do { // convert the 'ElevationWithFlooring' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ElevationWithFlooring, arg, db ); break; } 
+        try { GenericConvert( in->ElevationWithFlooring, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to IfcSpace to be a `IfcLengthMeasure`")); }
     } while(0);
 	return base;
@@ -1479,7 +1484,7 @@ template <> size_t GenericFill<IfcSurfaceStyleWithTextures>(const DB& db, const
 	size_t base = 0;
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcSurfaceStyleWithTextures"); }    do { // convert the 'Textures' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Textures, arg, db ); break; } 
+        try { GenericConvert( in->Textures, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSurfaceStyleWithTextures to be a `LIST [1:?] OF IfcSurfaceTexture`")); }
     } while(0);
 	return base;
@@ -1490,22 +1495,22 @@ template <> size_t GenericFill<IfcBoundingBox>(const DB& db, const LIST& params,
 	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcBoundingBox"); }    do { // convert the 'Corner' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Corner, arg, db ); break; } 
+        try { GenericConvert( in->Corner, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcBoundingBox to be a `IfcCartesianPoint`")); }
     } while(0);
     do { // convert the 'XDim' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->XDim, arg, db ); break; } 
+        try { GenericConvert( in->XDim, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcBoundingBox to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
     do { // convert the 'YDim' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->YDim, arg, db ); break; } 
+        try { GenericConvert( in->YDim, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcBoundingBox to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
     do { // convert the 'ZDim' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->ZDim, arg, db ); break; } 
+        try { GenericConvert( in->ZDim, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcBoundingBox to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
 	return base;
@@ -1530,7 +1535,7 @@ template <> size_t GenericFill<IfcCircle>(const DB& db, const LIST& params, IfcC
 	size_t base = GenericFill(db,params,static_cast<IfcConic*>(in));
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcCircle"); }    do { // convert the 'Radius' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Radius, arg, db ); break; } 
+        try { GenericConvert( in->Radius, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCircle to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
 	return base;
@@ -1618,12 +1623,12 @@ template <> size_t GenericFill<IfcConversionBasedUnit>(const DB& db, const LIST&
 	size_t base = GenericFill(db,params,static_cast<IfcNamedUnit*>(in));
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcConversionBasedUnit"); }    do { // convert the 'Name' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Name, arg, db ); break; } 
+        try { GenericConvert( in->Name, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcConversionBasedUnit to be a `IfcLabel`")); }
     } while(0);
     do { // convert the 'ConversionFactor' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->ConversionFactor, arg, db ); break; } 
+        try { GenericConvert( in->ConversionFactor, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcConversionBasedUnit to be a `IfcMeasureWithUnit`")); }
     } while(0);
 	return base;
@@ -1739,12 +1744,12 @@ template <> size_t GenericFill<IfcEllipse>(const DB& db, const LIST& params, Ifc
 	size_t base = GenericFill(db,params,static_cast<IfcConic*>(in));
 	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcEllipse"); }    do { // convert the 'SemiAxis1' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->SemiAxis1, arg, db ); break; } 
+        try { GenericConvert( in->SemiAxis1, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcEllipse to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
     do { // convert the 'SemiAxis2' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->SemiAxis2, arg, db ); break; } 
+        try { GenericConvert( in->SemiAxis2, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcEllipse to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
 	return base;
@@ -1811,7 +1816,7 @@ template <> size_t GenericFill<IfcPropertySet>(const DB& db, const LIST& params,
 	size_t base = GenericFill(db,params,static_cast<IfcPropertySetDefinition*>(in));
 	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcPropertySet"); }    do { // convert the 'HasProperties' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->HasProperties, arg, db ); break; } 
+        try { GenericConvert( in->HasProperties, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcPropertySet to be a `SET [1:?] OF IfcProperty`")); }
     } while(0);
 	return base;
@@ -1823,48 +1828,48 @@ template <> size_t GenericFill<IfcSurfaceStyleRendering>(const DB& db, const LIS
 	if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to IfcSurfaceStyleRendering"); }    do { // convert the 'Transparency' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Transparency, arg, db ); break; } 
+        try { GenericConvert( in->Transparency, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSurfaceStyleRendering to be a `IfcNormalisedRatioMeasure`")); }
     } while(0);
     do { // convert the 'DiffuseColour' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->DiffuseColour, arg, db ); break; } 
+        try { GenericConvert( in->DiffuseColour, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
     } while(0);
     do { // convert the 'TransmissionColour' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->TransmissionColour, arg, db ); break; } 
+        try { GenericConvert( in->TransmissionColour, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
     } while(0);
     do { // convert the 'DiffuseTransmissionColour' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->DiffuseTransmissionColour, arg, db ); break; } 
+        try { GenericConvert( in->DiffuseTransmissionColour, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
     } while(0);
     do { // convert the 'ReflectionColour' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ReflectionColour, arg, db ); break; } 
+        try { GenericConvert( in->ReflectionColour, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
     } while(0);
     do { // convert the 'SpecularColour' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->SpecularColour, arg, db ); break; } 
+        try { GenericConvert( in->SpecularColour, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
     } while(0);
     do { // convert the 'SpecularHighlight' argument
         std::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->SpecularHighlight, arg, db ); break; } 
+        try { GenericConvert( in->SpecularHighlight, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcSurfaceStyleRendering to be a `IfcSpecularHighlightSelect`")); }
     } while(0);
     do { // convert the 'ReflectanceMethod' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->ReflectanceMethod, arg, db ); break; } 
+        try { GenericConvert( in->ReflectanceMethod, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcSurfaceStyleRendering to be a `IfcReflectanceMethodEnum`")); }
     } while(0);
 	return base;
@@ -1915,4 +1920,8 @@ template <> size_t GenericFill<IfcConditionCriterion>(const DB& db, const LIST&
 } // ! STEP
 } // ! Assimp
 
+#if _MSC_VER
+#    pragma warning(pop)
+#endif // _MSC_VER
+
 #endif
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen_2x3.h b/Engine/lib/assimp/code/AssetLib/IFC/IFCReaderGen_2x3.h
similarity index 99%
rename from Engine/lib/assimp/code/Importer/IFC/IFCReaderGen_2x3.h
rename to Engine/lib/assimp/code/AssetLib/IFC/IFCReaderGen_2x3.h
index 8b39ccdc2..f87f121b9 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen_2x3.h
+++ b/Engine/lib/assimp/code/AssetLib/IFC/IFCReaderGen_2x3.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (ASSIMP)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2010, ASSIMP Development Team
+Copyright (c) 2006-2020, ASSIMP Development Team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -43,7 +43,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef INCLUDED_IFC_READER_GEN_H
 #define INCLUDED_IFC_READER_GEN_H
 
-#include "code/Step/STEPFile.h"
+#include "AssetLib/Step/STEPFile.h"
+
+#ifdef _MSC_VER
+#    pragma warning(push)
+#    pragma warning( disable : 4512 )
+#endif // _MSC_VER
 
 namespace Assimp {
 namespace IFC {
@@ -4368,4 +4373,8 @@ namespace STEP {
 } //! STEP
 } //! Assimp
 
+#ifdef _MSC_VER
+#    pragma warning(pop)
+#endif // _MSC_VER
+
 #endif // INCLUDED_IFC_READER_GEN_H
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen_4.cpp b/Engine/lib/assimp/code/AssetLib/IFC/IFCReaderGen_4.cpp
similarity index 98%
rename from Engine/lib/assimp/code/Importer/IFC/IFCReaderGen_4.cpp
rename to Engine/lib/assimp/code/AssetLib/IFC/IFCReaderGen_4.cpp
index fdefedb18..179322902 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen_4.cpp
+++ b/Engine/lib/assimp/code/AssetLib/IFC/IFCReaderGen_4.cpp
@@ -2,11 +2,11 @@
 Open Asset Import Library (ASSIMP)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2010, ASSIMP Development Team
+Copyright (c) 2006-2020, ASSIMP Development Team
 All rights reserved.
 
-Redistribution and use of this software in source and binary forms, 
-with or without modification, are permitted provided that the 
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
 following conditions are met:
 
 * Redistributions of source code must retain the above
@@ -23,16 +23,16 @@ following conditions are met:
   derived from this software without specific prior
   written permission of the ASSIMP Development Team.
 
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 ----------------------------------------------------------------------
@@ -1254,28 +1254,28 @@ template <> size_t GenericFill<IfcRoot>(const DB& db, const LIST& params, IfcRoo
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRoot"); }    do { // convert the 'GlobalId' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRoot,4>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->GlobalId, arg, db ); break; } 
+        try { GenericConvert( in->GlobalId, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRoot to be a `IfcGloballyUniqueId`")); }
     } while(0);
     do { // convert the 'OwnerHistory' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRoot,4>::aux_is_derived[1]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->OwnerHistory, arg, db ); break; } 
+        try { GenericConvert( in->OwnerHistory, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRoot to be a `IfcOwnerHistory`")); }
     } while(0);
     do { // convert the 'Name' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRoot,4>::aux_is_derived[2]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Name, arg, db ); break; } 
+        try { GenericConvert( in->Name, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcRoot to be a `IfcLabel`")); }
     } while(0);
     do { // convert the 'Description' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRoot,4>::aux_is_derived[3]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Description, arg, db ); break; } 
+        try { GenericConvert( in->Description, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRoot to be a `IfcText`")); }
     } while(0);
 	return base;
@@ -1294,7 +1294,7 @@ template <> size_t GenericFill<IfcObject>(const DB& db, const LIST& params, IfcO
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcObject,1>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ObjectType, arg, db ); break; } 
+        try { GenericConvert( in->ObjectType, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcObject to be a `IfcLabel`")); }
     } while(0);
 	return base;
@@ -1328,14 +1328,14 @@ template <> size_t GenericFill<IfcProduct>(const DB& db, const LIST& params, Ifc
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProduct,2>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ObjectPlacement, arg, db ); break; } 
+        try { GenericConvert( in->ObjectPlacement, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcProduct to be a `IfcObjectPlacement`")); }
     } while(0);
     do { // convert the 'Representation' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProduct,2>::aux_is_derived[1]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Representation, arg, db ); break; } 
+        try { GenericConvert( in->Representation, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcProduct to be a `IfcProductRepresentation`")); }
     } while(0);
 	return base;
@@ -1348,7 +1348,7 @@ template <> size_t GenericFill<IfcElement>(const DB& db, const LIST& params, Ifc
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcElement,1>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Tag, arg, db ); break; } 
+        try { GenericConvert( in->Tag, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcElement to be a `IfcIdentifier`")); }
     } while(0);
 	return base;
@@ -1441,7 +1441,7 @@ template <> size_t GenericFill<IfcManifoldSolidBrep>(const DB& db, const LIST& p
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcManifoldSolidBrep"); }    do { // convert the 'Outer' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcManifoldSolidBrep,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Outer, arg, db ); break; } 
+        try { GenericConvert( in->Outer, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcManifoldSolidBrep to be a `IfcClosedShell`")); }
     } while(0);
 	return base;
@@ -1473,7 +1473,7 @@ template <> size_t GenericFill<IfcFace>(const DB& db, const LIST& params, IfcFac
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcFace"); }    do { // convert the 'Bounds' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcFace,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Bounds, arg, db ); break; } 
+        try { GenericConvert( in->Bounds, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcFace to be a `SET [1:?] OF IfcFaceBound`")); }
     } while(0);
 	return base;
@@ -1624,14 +1624,14 @@ template <> size_t GenericFill<IfcProfileDef>(const DB& db, const LIST& params,
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcProfileDef"); }    do { // convert the 'ProfileType' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProfileDef,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->ProfileType, arg, db ); break; } 
+        try { GenericConvert( in->ProfileType, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcProfileDef to be a `IfcProfileTypeEnum`")); }
     } while(0);
     do { // convert the 'ProfileName' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProfileDef,2>::aux_is_derived[1]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ProfileName, arg, db ); break; } 
+        try { GenericConvert( in->ProfileName, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcProfileDef to be a `IfcLabel`")); }
     } while(0);
 	return base;
@@ -1643,7 +1643,7 @@ template <> size_t GenericFill<IfcArbitraryClosedProfileDef>(const DB& db, const
 	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcArbitraryClosedProfileDef"); }    do { // convert the 'OuterCurve' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcArbitraryClosedProfileDef,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->OuterCurve, arg, db ); break; } 
+        try { GenericConvert( in->OuterCurve, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcArbitraryClosedProfileDef to be a `IfcCurve`")); }
     } while(0);
 	return base;
@@ -1655,7 +1655,7 @@ template <> size_t GenericFill<IfcArbitraryOpenProfileDef>(const DB& db, const L
 	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcArbitraryOpenProfileDef"); }    do { // convert the 'Curve' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcArbitraryOpenProfileDef,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Curve, arg, db ); break; } 
+        try { GenericConvert( in->Curve, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcArbitraryOpenProfileDef to be a `IfcBoundedCurve`")); }
     } while(0);
 	return base;
@@ -1666,7 +1666,7 @@ template <> size_t GenericFill<IfcArbitraryProfileDefWithVoids>(const DB& db, co
 	size_t base = GenericFill(db,params,static_cast<IfcArbitraryClosedProfileDef*>(in));
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcArbitraryProfileDefWithVoids"); }    do { // convert the 'InnerCurves' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->InnerCurves, arg, db ); break; } 
+        try { GenericConvert( in->InnerCurves, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcArbitraryProfileDefWithVoids to be a `SET [1:?] OF IfcCurve`")); }
     } while(0);
 	return base;
@@ -1693,7 +1693,7 @@ template <> size_t GenericFill<IfcParameterizedProfileDef>(const DB& db, const L
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcParameterizedProfileDef,1>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Position, arg, db ); break; } 
+        try { GenericConvert( in->Position, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcParameterizedProfileDef to be a `IfcAxis2Placement2D`")); }
     } while(0);
 	return base;
@@ -1726,7 +1726,7 @@ template <> size_t GenericFill<IfcPlacement>(const DB& db, const LIST& params, I
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPlacement"); }    do { // convert the 'Location' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcPlacement,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Location, arg, db ); break; } 
+        try { GenericConvert( in->Location, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPlacement to be a `IfcCartesianPoint`")); }
     } while(0);
 	return base;
@@ -1738,7 +1738,7 @@ template <> size_t GenericFill<IfcAxis1Placement>(const DB& db, const LIST& para
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcAxis1Placement"); }    do { // convert the 'Axis' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Axis, arg, db ); break; } 
+        try { GenericConvert( in->Axis, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcAxis1Placement to be a `IfcDirection`")); }
     } while(0);
 	return base;
@@ -1750,7 +1750,7 @@ template <> size_t GenericFill<IfcAxis2Placement2D>(const DB& db, const LIST& pa
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcAxis2Placement2D"); }    do { // convert the 'RefDirection' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RefDirection, arg, db ); break; } 
+        try { GenericConvert( in->RefDirection, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcAxis2Placement2D to be a `IfcDirection`")); }
     } while(0);
 	return base;
@@ -1762,13 +1762,13 @@ template <> size_t GenericFill<IfcAxis2Placement3D>(const DB& db, const LIST& pa
 	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcAxis2Placement3D"); }    do { // convert the 'Axis' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Axis, arg, db ); break; } 
+        try { GenericConvert( in->Axis, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcAxis2Placement3D to be a `IfcDirection`")); }
     } while(0);
     do { // convert the 'RefDirection' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RefDirection, arg, db ); break; } 
+        try { GenericConvert( in->RefDirection, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcAxis2Placement3D to be a `IfcDirection`")); }
     } while(0);
 	return base;
@@ -1792,31 +1792,31 @@ template <> size_t GenericFill<IfcBSplineCurve>(const DB& db, const LIST& params
 	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcBSplineCurve"); }    do { // convert the 'Degree' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBSplineCurve,5>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Degree, arg, db ); break; } 
+        try { GenericConvert( in->Degree, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcBSplineCurve to be a `IfcInteger`")); }
     } while(0);
     do { // convert the 'ControlPointsList' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBSplineCurve,5>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->ControlPointsList, arg, db ); break; } 
+        try { GenericConvert( in->ControlPointsList, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcBSplineCurve to be a `LIST [2:?] OF IfcCartesianPoint`")); }
     } while(0);
     do { // convert the 'CurveForm' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBSplineCurve,5>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->CurveForm, arg, db ); break; } 
+        try { GenericConvert( in->CurveForm, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcBSplineCurve to be a `IfcBSplineCurveForm`")); }
     } while(0);
     do { // convert the 'ClosedCurve' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBSplineCurve,5>::aux_is_derived[3]=true; break; }
-        try { GenericConvert( in->ClosedCurve, arg, db ); break; } 
+        try { GenericConvert( in->ClosedCurve, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcBSplineCurve to be a `IfcLogical`")); }
     } while(0);
     do { // convert the 'SelfIntersect' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBSplineCurve,5>::aux_is_derived[4]=true; break; }
-        try { GenericConvert( in->SelfIntersect, arg, db ); break; } 
+        try { GenericConvert( in->SelfIntersect, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcBSplineCurve to be a `IfcLogical`")); }
     } while(0);
 	return base;
@@ -1930,19 +1930,19 @@ template <> size_t GenericFill<IfcBooleanResult>(const DB& db, const LIST& param
 	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcBooleanResult"); }    do { // convert the 'Operator' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBooleanResult,3>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Operator, arg, db ); break; } 
+        try { GenericConvert( in->Operator, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcBooleanResult to be a `IfcBooleanOperator`")); }
     } while(0);
     do { // convert the 'FirstOperand' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBooleanResult,3>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->FirstOperand, arg, db ); break; } 
+        try { GenericConvert( in->FirstOperand, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcBooleanResult to be a `IfcBooleanOperand`")); }
     } while(0);
     do { // convert the 'SecondOperand' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBooleanResult,3>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->SecondOperand, arg, db ); break; } 
+        try { GenericConvert( in->SecondOperand, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcBooleanResult to be a `IfcBooleanOperand`")); }
     } while(0);
 	return base;
@@ -1960,13 +1960,13 @@ template <> size_t GenericFill<IfcCompositeCurve>(const DB& db, const LIST& para
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcCompositeCurve"); }    do { // convert the 'Segments' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCompositeCurve,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Segments, arg, db ); break; } 
+        try { GenericConvert( in->Segments, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCompositeCurve to be a `LIST [1:?] OF IfcCompositeCurveSegment`")); }
     } while(0);
     do { // convert the 'SelfIntersect' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCompositeCurve,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->SelfIntersect, arg, db ); break; } 
+        try { GenericConvert( in->SelfIntersect, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCompositeCurve to be a `IfcLogical`")); }
     } while(0);
 	return base;
@@ -1991,22 +1991,22 @@ template <> size_t GenericFill<IfcBoundingBox>(const DB& db, const LIST& params,
 	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcBoundingBox"); }    do { // convert the 'Corner' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Corner, arg, db ); break; } 
+        try { GenericConvert( in->Corner, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcBoundingBox to be a `IfcCartesianPoint`")); }
     } while(0);
     do { // convert the 'XDim' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->XDim, arg, db ); break; } 
+        try { GenericConvert( in->XDim, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcBoundingBox to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
     do { // convert the 'YDim' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->YDim, arg, db ); break; } 
+        try { GenericConvert( in->YDim, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcBoundingBox to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
     do { // convert the 'ZDim' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->ZDim, arg, db ); break; } 
+        try { GenericConvert( in->ZDim, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcBoundingBox to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
 	return base;
@@ -2018,13 +2018,13 @@ template <> size_t GenericFill<IfcHalfSpaceSolid>(const DB& db, const LIST& para
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcHalfSpaceSolid"); }    do { // convert the 'BaseSurface' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcHalfSpaceSolid,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->BaseSurface, arg, db ); break; } 
+        try { GenericConvert( in->BaseSurface, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcHalfSpaceSolid to be a `IfcSurface`")); }
     } while(0);
     do { // convert the 'AgreementFlag' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcHalfSpaceSolid,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->AgreementFlag, arg, db ); break; } 
+        try { GenericConvert( in->AgreementFlag, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcHalfSpaceSolid to be a `IfcBoolean`")); }
     } while(0);
 	return base;
@@ -2044,7 +2044,7 @@ template <> size_t GenericFill<IfcSpatialElement>(const DB& db, const LIST& para
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSpatialElement,1>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->LongName, arg, db ); break; } 
+        try { GenericConvert( in->LongName, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcSpatialElement to be a `IfcLabel`")); }
     } while(0);
 	return base;
@@ -2057,7 +2057,7 @@ template <> size_t GenericFill<IfcSpatialStructureElement>(const DB& db, const L
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSpatialStructureElement,1>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->CompositionType, arg, db ); break; } 
+        try { GenericConvert( in->CompositionType, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcSpatialStructureElement to be a `IfcElementCompositionEnum`")); }
     } while(0);
 	return base;
@@ -2069,19 +2069,19 @@ template <> size_t GenericFill<IfcBuilding>(const DB& db, const LIST& params, If
 	if (params.GetSize() < 12) { throw STEP::TypeError("expected 12 arguments to IfcBuilding"); }    do { // convert the 'ElevationOfRefHeight' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ElevationOfRefHeight, arg, db ); break; } 
+        try { GenericConvert( in->ElevationOfRefHeight, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcBuilding to be a `IfcLengthMeasure`")); }
     } while(0);
     do { // convert the 'ElevationOfTerrain' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ElevationOfTerrain, arg, db ); break; } 
+        try { GenericConvert( in->ElevationOfTerrain, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to IfcBuilding to be a `IfcLengthMeasure`")); }
     } while(0);
     do { // convert the 'BuildingAddress' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->BuildingAddress, arg, db ); break; } 
+        try { GenericConvert( in->BuildingAddress, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 11 to IfcBuilding to be a `IfcPostalAddress`")); }
     } while(0);
 	return base;
@@ -2266,7 +2266,7 @@ template <> size_t GenericFill<IfcCartesianPoint>(const DB& db, const LIST& para
 	size_t base = GenericFill(db,params,static_cast<IfcPoint*>(in));
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcCartesianPoint"); }    do { // convert the 'Coordinates' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Coordinates, arg, db ); break; } 
+        try { GenericConvert( in->Coordinates, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCartesianPoint to be a `LIST [1:3] OF IfcLengthMeasure`")); }
     } while(0);
 	return base;
@@ -2300,27 +2300,27 @@ template <> size_t GenericFill<IfcCartesianTransformationOperator>(const DB& db,
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCartesianTransformationOperator,4>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Axis1, arg, db ); break; } 
+        try { GenericConvert( in->Axis1, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCartesianTransformationOperator to be a `IfcDirection`")); }
     } while(0);
     do { // convert the 'Axis2' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCartesianTransformationOperator,4>::aux_is_derived[1]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Axis2, arg, db ); break; } 
+        try { GenericConvert( in->Axis2, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCartesianTransformationOperator to be a `IfcDirection`")); }
     } while(0);
     do { // convert the 'LocalOrigin' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCartesianTransformationOperator,4>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->LocalOrigin, arg, db ); break; } 
+        try { GenericConvert( in->LocalOrigin, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcCartesianTransformationOperator to be a `IfcCartesianPoint`")); }
     } while(0);
     do { // convert the 'Scale' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCartesianTransformationOperator,4>::aux_is_derived[3]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Scale, arg, db ); break; } 
+        try { GenericConvert( in->Scale, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcCartesianTransformationOperator to be a `IfcReal`")); }
     } while(0);
 	return base;
@@ -2347,7 +2347,7 @@ template <> size_t GenericFill<IfcCartesianTransformationOperator3D>(const DB& d
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCartesianTransformationOperator3D,1>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Axis3, arg, db ); break; } 
+        try { GenericConvert( in->Axis3, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcCartesianTransformationOperator3D to be a `IfcDirection`")); }
     } while(0);
 	return base;
@@ -2359,13 +2359,13 @@ template <> size_t GenericFill<IfcCartesianTransformationOperator3DnonUniform>(c
 	if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to IfcCartesianTransformationOperator3DnonUniform"); }    do { // convert the 'Scale2' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Scale2, arg, db ); break; } 
+        try { GenericConvert( in->Scale2, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcCartesianTransformationOperator3DnonUniform to be a `IfcReal`")); }
     } while(0);
     do { // convert the 'Scale3' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Scale3, arg, db ); break; } 
+        try { GenericConvert( in->Scale3, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcCartesianTransformationOperator3DnonUniform to be a `IfcReal`")); }
     } while(0);
 	return base;
@@ -2412,7 +2412,7 @@ template <> size_t GenericFill<IfcConic>(const DB& db, const LIST& params, IfcCo
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcConic"); }    do { // convert the 'Position' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcConic,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Position, arg, db ); break; } 
+        try { GenericConvert( in->Position, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcConic to be a `IfcAxis2Placement`")); }
     } while(0);
 	return base;
@@ -2423,7 +2423,7 @@ template <> size_t GenericFill<IfcCircle>(const DB& db, const LIST& params, IfcC
 	size_t base = GenericFill(db,params,static_cast<IfcConic*>(in));
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcCircle"); }    do { // convert the 'Radius' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Radius, arg, db ); break; } 
+        try { GenericConvert( in->Radius, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCircle to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
 	return base;
@@ -2435,7 +2435,7 @@ template <> size_t GenericFill<IfcCircleProfileDef>(const DB& db, const LIST& pa
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcCircleProfileDef"); }    do { // convert the 'Radius' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCircleProfileDef,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Radius, arg, db ); break; } 
+        try { GenericConvert( in->Radius, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcCircleProfileDef to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
 	return base;
@@ -2446,7 +2446,7 @@ template <> size_t GenericFill<IfcCircleHollowProfileDef>(const DB& db, const LI
 	size_t base = GenericFill(db,params,static_cast<IfcCircleProfileDef*>(in));
 	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcCircleHollowProfileDef"); }    do { // convert the 'WallThickness' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->WallThickness, arg, db ); break; } 
+        try { GenericConvert( in->WallThickness, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcCircleHollowProfileDef to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
 	return base;
@@ -2472,7 +2472,7 @@ template <> size_t GenericFill<IfcConnectedFaceSet>(const DB& db, const LIST& pa
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcConnectedFaceSet"); }    do { // convert the 'CfsFaces' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcConnectedFaceSet,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->CfsFaces, arg, db ); break; } 
+        try { GenericConvert( in->CfsFaces, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcConnectedFaceSet to be a `SET [1:?] OF IfcFace`")); }
     } while(0);
 	return base;
@@ -2505,7 +2505,7 @@ template <> size_t GenericFill<IfcColourSpecification>(const DB& db, const LIST&
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcColourSpecification,1>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Name, arg, db ); break; } 
+        try { GenericConvert( in->Name, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcColourSpecification to be a `IfcLabel`")); }
     } while(0);
 	return base;
@@ -2516,17 +2516,17 @@ template <> size_t GenericFill<IfcColourRgb>(const DB& db, const LIST& params, I
 	size_t base = GenericFill(db,params,static_cast<IfcColourSpecification*>(in));
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcColourRgb"); }    do { // convert the 'Red' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Red, arg, db ); break; } 
+        try { GenericConvert( in->Red, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcColourRgb to be a `IfcNormalisedRatioMeasure`")); }
     } while(0);
     do { // convert the 'Green' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Green, arg, db ); break; } 
+        try { GenericConvert( in->Green, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcColourRgb to be a `IfcNormalisedRatioMeasure`")); }
     } while(0);
     do { // convert the 'Blue' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Blue, arg, db ); break; } 
+        try { GenericConvert( in->Blue, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcColourRgb to be a `IfcNormalisedRatioMeasure`")); }
     } while(0);
 	return base;
@@ -2579,14 +2579,14 @@ template <> size_t GenericFill<IfcProperty>(const DB& db, const LIST& params, If
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcProperty"); }    do { // convert the 'Name' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProperty,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Name, arg, db ); break; } 
+        try { GenericConvert( in->Name, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcProperty to be a `IfcIdentifier`")); }
     } while(0);
     do { // convert the 'Description' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProperty,2>::aux_is_derived[1]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Description, arg, db ); break; } 
+        try { GenericConvert( in->Description, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcProperty to be a `IfcText`")); }
     } while(0);
 	return base;
@@ -2597,12 +2597,12 @@ template <> size_t GenericFill<IfcComplexProperty>(const DB& db, const LIST& par
 	size_t base = GenericFill(db,params,static_cast<IfcProperty*>(in));
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcComplexProperty"); }    do { // convert the 'UsageName' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->UsageName, arg, db ); break; } 
+        try { GenericConvert( in->UsageName, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcComplexProperty to be a `IfcIdentifier`")); }
     } while(0);
     do { // convert the 'HasProperties' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->HasProperties, arg, db ); break; } 
+        try { GenericConvert( in->HasProperties, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcComplexProperty to be a `SET [1:?] OF IfcProperty`")); }
     } while(0);
 	return base;
@@ -2620,19 +2620,19 @@ template <> size_t GenericFill<IfcCompositeCurveSegment>(const DB& db, const LIS
 	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcCompositeCurveSegment"); }    do { // convert the 'Transition' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCompositeCurveSegment,3>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Transition, arg, db ); break; } 
+        try { GenericConvert( in->Transition, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCompositeCurveSegment to be a `IfcTransitionCode`")); }
     } while(0);
     do { // convert the 'SameSense' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCompositeCurveSegment,3>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->SameSense, arg, db ); break; } 
+        try { GenericConvert( in->SameSense, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCompositeCurveSegment to be a `IfcBoolean`")); }
     } while(0);
     do { // convert the 'ParentCurve' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCompositeCurveSegment,3>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->ParentCurve, arg, db ); break; } 
+        try { GenericConvert( in->ParentCurve, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcCompositeCurveSegment to be a `IfcCurve`")); }
     } while(0);
 	return base;
@@ -2764,35 +2764,35 @@ template <> size_t GenericFill<IfcContext>(const DB& db, const LIST& params, Ifc
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcContext,5>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ObjectType, arg, db ); break; } 
+        try { GenericConvert( in->ObjectType, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcContext to be a `IfcLabel`")); }
     } while(0);
     do { // convert the 'LongName' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcContext,5>::aux_is_derived[1]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->LongName, arg, db ); break; } 
+        try { GenericConvert( in->LongName, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcContext to be a `IfcLabel`")); }
     } while(0);
     do { // convert the 'Phase' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcContext,5>::aux_is_derived[2]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Phase, arg, db ); break; } 
+        try { GenericConvert( in->Phase, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcContext to be a `IfcLabel`")); }
     } while(0);
     do { // convert the 'RepresentationContexts' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcContext,5>::aux_is_derived[3]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RepresentationContexts, arg, db ); break; } 
+        try { GenericConvert( in->RepresentationContexts, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcContext to be a `SET [1:?] OF IfcRepresentationContext`")); }
     } while(0);
     do { // convert the 'UnitsInContext' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcContext,5>::aux_is_derived[4]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->UnitsInContext, arg, db ); break; } 
+        try { GenericConvert( in->UnitsInContext, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcContext to be a `IfcUnitAssignment`")); }
     } while(0);
 	return base;
@@ -2804,13 +2804,13 @@ template <> size_t GenericFill<IfcNamedUnit>(const DB& db, const LIST& params, I
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcNamedUnit"); }    do { // convert the 'Dimensions' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcNamedUnit,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Dimensions, arg, db ); break; } 
+        try { GenericConvert( in->Dimensions, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcNamedUnit to be a `IfcDimensionalExponents`")); }
     } while(0);
     do { // convert the 'UnitType' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcNamedUnit,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->UnitType, arg, db ); break; } 
+        try { GenericConvert( in->UnitType, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcNamedUnit to be a `IfcUnitEnum`")); }
     } while(0);
 	return base;
@@ -2843,13 +2843,13 @@ template <> size_t GenericFill<IfcConversionBasedUnit>(const DB& db, const LIST&
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcConversionBasedUnit"); }    do { // convert the 'Name' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcConversionBasedUnit,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Name, arg, db ); break; } 
+        try { GenericConvert( in->Name, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcConversionBasedUnit to be a `IfcLabel`")); }
     } while(0);
     do { // convert the 'ConversionFactor' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcConversionBasedUnit,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->ConversionFactor, arg, db ); break; } 
+        try { GenericConvert( in->ConversionFactor, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcConversionBasedUnit to be a `IfcMeasureWithUnit`")); }
     } while(0);
 	return base;
@@ -2974,7 +2974,7 @@ template <> size_t GenericFill<IfcPresentationStyle>(const DB& db, const LIST& p
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcPresentationStyle,1>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Name, arg, db ); break; } 
+        try { GenericConvert( in->Name, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPresentationStyle to be a `IfcLabel`")); }
     } while(0);
 	return base;
@@ -2986,7 +2986,7 @@ template <> size_t GenericFill<IfcElementarySurface>(const DB& db, const LIST& p
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcElementarySurface"); }    do { // convert the 'Position' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcElementarySurface,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Position, arg, db ); break; } 
+        try { GenericConvert( in->Position, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcElementarySurface to be a `IfcAxis2Placement3D`")); }
     } while(0);
 	return base;
@@ -3025,7 +3025,7 @@ template <> size_t GenericFill<IfcDirection>(const DB& db, const LIST& params, I
 	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcDirection"); }    do { // convert the 'DirectionRatios' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->DirectionRatios, arg, db ); break; } 
+        try { GenericConvert( in->DirectionRatios, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcDirection to be a `LIST [2:3] OF IfcReal`")); }
     } while(0);
 	return base;
@@ -3094,35 +3094,35 @@ template <> size_t GenericFill<IfcDoor>(const DB& db, const LIST& params, IfcDoo
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcDoor,5>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->OverallHeight, arg, db ); break; } 
+        try { GenericConvert( in->OverallHeight, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcDoor to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
     do { // convert the 'OverallWidth' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcDoor,5>::aux_is_derived[1]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->OverallWidth, arg, db ); break; } 
+        try { GenericConvert( in->OverallWidth, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcDoor to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
     do { // convert the 'PredefinedType' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcDoor,5>::aux_is_derived[2]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->PredefinedType, arg, db ); break; } 
+        try { GenericConvert( in->PredefinedType, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to IfcDoor to be a `IfcDoorTypeEnum`")); }
     } while(0);
     do { // convert the 'OperationType' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcDoor,5>::aux_is_derived[3]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->OperationType, arg, db ); break; } 
+        try { GenericConvert( in->OperationType, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 11 to IfcDoor to be a `IfcDoorTypeOperationEnum`")); }
     } while(0);
     do { // convert the 'UserDefinedOperationType' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcDoor,5>::aux_is_derived[4]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->UserDefinedOperationType, arg, db ); break; } 
+        try { GenericConvert( in->UserDefinedOperationType, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 12 to IfcDoor to be a `IfcLabel`")); }
     } while(0);
 	return base;
@@ -3362,12 +3362,12 @@ template <> size_t GenericFill<IfcElementQuantity>(const DB& db, const LIST& par
 	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcElementQuantity"); }    do { // convert the 'MethodOfMeasurement' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->MethodOfMeasurement, arg, db ); break; } 
+        try { GenericConvert( in->MethodOfMeasurement, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcElementQuantity to be a `IfcLabel`")); }
     } while(0);
     do { // convert the 'Quantities' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Quantities, arg, db ); break; } 
+        try { GenericConvert( in->Quantities, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcElementQuantity to be a `SET [1:?] OF IfcPhysicalQuantity`")); }
     } while(0);
 	return base;
@@ -3378,12 +3378,12 @@ template <> size_t GenericFill<IfcEllipse>(const DB& db, const LIST& params, Ifc
 	size_t base = GenericFill(db,params,static_cast<IfcConic*>(in));
 	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcEllipse"); }    do { // convert the 'SemiAxis1' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->SemiAxis1, arg, db ); break; } 
+        try { GenericConvert( in->SemiAxis1, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcEllipse to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
     do { // convert the 'SemiAxis2' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->SemiAxis2, arg, db ); break; } 
+        try { GenericConvert( in->SemiAxis2, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcEllipse to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
 	return base;
@@ -3486,14 +3486,14 @@ template <> size_t GenericFill<IfcSweptAreaSolid>(const DB& db, const LIST& para
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcSweptAreaSolid"); }    do { // convert the 'SweptArea' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSweptAreaSolid,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->SweptArea, arg, db ); break; } 
+        try { GenericConvert( in->SweptArea, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSweptAreaSolid to be a `IfcProfileDef`")); }
     } while(0);
     do { // convert the 'Position' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSweptAreaSolid,2>::aux_is_derived[1]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Position, arg, db ); break; } 
+        try { GenericConvert( in->Position, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSweptAreaSolid to be a `IfcAxis2Placement3D`")); }
     } while(0);
 	return base;
@@ -3505,13 +3505,13 @@ template <> size_t GenericFill<IfcExtrudedAreaSolid>(const DB& db, const LIST& p
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcExtrudedAreaSolid"); }    do { // convert the 'ExtrudedDirection' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcExtrudedAreaSolid,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->ExtrudedDirection, arg, db ); break; } 
+        try { GenericConvert( in->ExtrudedDirection, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcExtrudedAreaSolid to be a `IfcDirection`")); }
     } while(0);
     do { // convert the 'Depth' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcExtrudedAreaSolid,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->Depth, arg, db ); break; } 
+        try { GenericConvert( in->Depth, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcExtrudedAreaSolid to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
 	return base;
@@ -3529,7 +3529,7 @@ template <> size_t GenericFill<IfcFaceBasedSurfaceModel>(const DB& db, const LIS
 	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcFaceBasedSurfaceModel"); }    do { // convert the 'FbsmFaces' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->FbsmFaces, arg, db ); break; } 
+        try { GenericConvert( in->FbsmFaces, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcFaceBasedSurfaceModel to be a `SET [1:?] OF IfcConnectedFaceSet`")); }
     } while(0);
 	return base;
@@ -3541,13 +3541,13 @@ template <> size_t GenericFill<IfcFaceBound>(const DB& db, const LIST& params, I
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcFaceBound"); }    do { // convert the 'Bound' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcFaceBound,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Bound, arg, db ); break; } 
+        try { GenericConvert( in->Bound, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcFaceBound to be a `IfcLoop`")); }
     } while(0);
     do { // convert the 'Orientation' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcFaceBound,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->Orientation, arg, db ); break; } 
+        try { GenericConvert( in->Orientation, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcFaceBound to be a `IfcBoolean`")); }
     } while(0);
 	return base;
@@ -3774,14 +3774,14 @@ template <> size_t GenericFill<IfcRepresentationContext>(const DB& db, const LIS
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRepresentationContext,2>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ContextIdentifier, arg, db ); break; } 
+        try { GenericConvert( in->ContextIdentifier, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRepresentationContext to be a `IfcLabel`")); }
     } while(0);
     do { // convert the 'ContextType' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRepresentationContext,2>::aux_is_derived[1]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ContextType, arg, db ); break; } 
+        try { GenericConvert( in->ContextType, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRepresentationContext to be a `IfcLabel`")); }
     } while(0);
 	return base;
@@ -3793,27 +3793,27 @@ template <> size_t GenericFill<IfcGeometricRepresentationContext>(const DB& db,
 	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcGeometricRepresentationContext"); }    do { // convert the 'CoordinateSpaceDimension' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcGeometricRepresentationContext,4>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->CoordinateSpaceDimension, arg, db ); break; } 
+        try { GenericConvert( in->CoordinateSpaceDimension, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcGeometricRepresentationContext to be a `IfcDimensionCount`")); }
     } while(0);
     do { // convert the 'Precision' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcGeometricRepresentationContext,4>::aux_is_derived[1]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Precision, arg, db ); break; } 
+        try { GenericConvert( in->Precision, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcGeometricRepresentationContext to be a `IfcReal`")); }
     } while(0);
     do { // convert the 'WorldCoordinateSystem' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcGeometricRepresentationContext,4>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->WorldCoordinateSystem, arg, db ); break; } 
+        try { GenericConvert( in->WorldCoordinateSystem, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcGeometricRepresentationContext to be a `IfcAxis2Placement`")); }
     } while(0);
     do { // convert the 'TrueNorth' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcGeometricRepresentationContext,4>::aux_is_derived[3]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->TrueNorth, arg, db ); break; } 
+        try { GenericConvert( in->TrueNorth, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcGeometricRepresentationContext to be a `IfcDirection`")); }
     } while(0);
 	return base;
@@ -3879,40 +3879,40 @@ template <> size_t GenericFill<IfcIShapeProfileDef>(const DB& db, const LIST& pa
 	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
 	if (params.GetSize() < 10) { throw STEP::TypeError("expected 10 arguments to IfcIShapeProfileDef"); }    do { // convert the 'OverallWidth' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->OverallWidth, arg, db ); break; } 
+        try { GenericConvert( in->OverallWidth, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
     do { // convert the 'OverallDepth' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->OverallDepth, arg, db ); break; } 
+        try { GenericConvert( in->OverallDepth, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
     do { // convert the 'WebThickness' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->WebThickness, arg, db ); break; } 
+        try { GenericConvert( in->WebThickness, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
     do { // convert the 'FlangeThickness' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->FlangeThickness, arg, db ); break; } 
+        try { GenericConvert( in->FlangeThickness, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
     do { // convert the 'FilletRadius' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->FilletRadius, arg, db ); break; } 
+        try { GenericConvert( in->FilletRadius, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcIShapeProfileDef to be a `IfcNonNegativeLengthMeasure`")); }
     } while(0);
     do { // convert the 'FlangeEdgeRadius' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->FlangeEdgeRadius, arg, db ); break; } 
+        try { GenericConvert( in->FlangeEdgeRadius, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcIShapeProfileDef to be a `IfcNonNegativeLengthMeasure`")); }
     } while(0);
     do { // convert the 'FlangeSlope' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->FlangeSlope, arg, db ); break; } 
+        try { GenericConvert( in->FlangeSlope, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcIShapeProfileDef to be a `IfcPlaneAngleMeasure`")); }
     } while(0);
 	return base;
@@ -4091,12 +4091,12 @@ template <> size_t GenericFill<IfcLine>(const DB& db, const LIST& params, IfcLin
 	size_t base = GenericFill(db,params,static_cast<IfcCurve*>(in));
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcLine"); }    do { // convert the 'Pnt' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Pnt, arg, db ); break; } 
+        try { GenericConvert( in->Pnt, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcLine to be a `IfcCartesianPoint`")); }
     } while(0);
     do { // convert the 'Dir' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Dir, arg, db ); break; } 
+        try { GenericConvert( in->Dir, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcLine to be a `IfcVector`")); }
     } while(0);
 	return base;
@@ -4108,12 +4108,12 @@ template <> size_t GenericFill<IfcLocalPlacement>(const DB& db, const LIST& para
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcLocalPlacement"); }    do { // convert the 'PlacementRelTo' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->PlacementRelTo, arg, db ); break; } 
+        try { GenericConvert( in->PlacementRelTo, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcLocalPlacement to be a `IfcObjectPlacement`")); }
     } while(0);
     do { // convert the 'RelativePlacement' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelativePlacement, arg, db ); break; } 
+        try { GenericConvert( in->RelativePlacement, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcLocalPlacement to be a `IfcAxis2Placement`")); }
     } while(0);
 	return base;
@@ -4124,12 +4124,12 @@ template <> size_t GenericFill<IfcMappedItem>(const DB& db, const LIST& params,
 	size_t base = GenericFill(db,params,static_cast<IfcRepresentationItem*>(in));
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcMappedItem"); }    do { // convert the 'MappingSource' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->MappingSource, arg, db ); break; } 
+        try { GenericConvert( in->MappingSource, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcMappedItem to be a `IfcRepresentationMap`")); }
     } while(0);
     do { // convert the 'MappingTarget' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->MappingTarget, arg, db ); break; } 
+        try { GenericConvert( in->MappingTarget, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcMappedItem to be a `IfcCartesianTransformationOperator`")); }
     } while(0);
 	return base;
@@ -4142,20 +4142,20 @@ template <> size_t GenericFill<IfcProductRepresentation>(const DB& db, const LIS
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProductRepresentation,3>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Name, arg, db ); break; } 
+        try { GenericConvert( in->Name, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcProductRepresentation to be a `IfcLabel`")); }
     } while(0);
     do { // convert the 'Description' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProductRepresentation,3>::aux_is_derived[1]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Description, arg, db ); break; } 
+        try { GenericConvert( in->Description, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcProductRepresentation to be a `IfcText`")); }
     } while(0);
     do { // convert the 'Representations' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProductRepresentation,3>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->Representations, arg, db ); break; } 
+        try { GenericConvert( in->Representations, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcProductRepresentation to be a `LIST [1:?] OF IfcRepresentation`")); }
     } while(0);
 	return base;
@@ -4173,12 +4173,12 @@ template <> size_t GenericFill<IfcMeasureWithUnit>(const DB& db, const LIST& par
 	size_t base = 0;
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcMeasureWithUnit"); }    do { // convert the 'ValueComponent' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->ValueComponent, arg, db ); break; } 
+        try { GenericConvert( in->ValueComponent, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcMeasureWithUnit to be a `IfcValue`")); }
     } while(0);
     do { // convert the 'UnitComponent' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->UnitComponent, arg, db ); break; } 
+        try { GenericConvert( in->UnitComponent, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcMeasureWithUnit to be a `IfcUnit`")); }
     } while(0);
 	return base;
@@ -4289,7 +4289,7 @@ template <> size_t GenericFill<IfcOpeningElement>(const DB& db, const LIST& para
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcOpeningElement,1>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->PredefinedType, arg, db ); break; } 
+        try { GenericConvert( in->PredefinedType, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcOpeningElement to be a `IfcOpeningElementTypeEnum`")); }
     } while(0);
 	return base;
@@ -4460,7 +4460,7 @@ template <> size_t GenericFill<IfcPolyLoop>(const DB& db, const LIST& params, If
 	size_t base = GenericFill(db,params,static_cast<IfcLoop*>(in));
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPolyLoop"); }    do { // convert the 'Polygon' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Polygon, arg, db ); break; } 
+        try { GenericConvert( in->Polygon, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPolyLoop to be a `LIST [3:?] OF IfcCartesianPoint`")); }
     } while(0);
 	return base;
@@ -4471,12 +4471,12 @@ template <> size_t GenericFill<IfcPolygonalBoundedHalfSpace>(const DB& db, const
 	size_t base = GenericFill(db,params,static_cast<IfcHalfSpaceSolid*>(in));
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcPolygonalBoundedHalfSpace"); }    do { // convert the 'Position' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Position, arg, db ); break; } 
+        try { GenericConvert( in->Position, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcPolygonalBoundedHalfSpace to be a `IfcAxis2Placement3D`")); }
     } while(0);
     do { // convert the 'PolygonalBoundary' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->PolygonalBoundary, arg, db ); break; } 
+        try { GenericConvert( in->PolygonalBoundary, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcPolygonalBoundedHalfSpace to be a `IfcBoundedCurve`")); }
     } while(0);
 	return base;
@@ -4501,7 +4501,7 @@ template <> size_t GenericFill<IfcPolyline>(const DB& db, const LIST& params, If
 	size_t base = GenericFill(db,params,static_cast<IfcBoundedCurve*>(in));
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPolyline"); }    do { // convert the 'Points' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Points, arg, db ); break; } 
+        try { GenericConvert( in->Points, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPolyline to be a `LIST [2:?] OF IfcCartesianPoint`")); }
     } while(0);
 	return base;
@@ -4512,7 +4512,7 @@ template <> size_t GenericFill<IfcPresentationStyleAssignment>(const DB& db, con
 	size_t base = 0;
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPresentationStyleAssignment"); }    do { // convert the 'Styles' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Styles, arg, db ); break; } 
+        try { GenericConvert( in->Styles, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPresentationStyleAssignment to be a `SET [1:?] OF IfcPresentationStyleSelect`")); }
     } while(0);
 	return base;
@@ -4592,13 +4592,13 @@ template <> size_t GenericFill<IfcPropertyListValue>(const DB& db, const LIST& p
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcPropertyListValue"); }    do { // convert the 'ListValues' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ListValues, arg, db ); break; } 
+        try { GenericConvert( in->ListValues, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcPropertyListValue to be a `LIST [1:?] OF IfcValue`")); }
     } while(0);
     do { // convert the 'Unit' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Unit, arg, db ); break; } 
+        try { GenericConvert( in->Unit, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcPropertyListValue to be a `IfcUnit`")); }
     } while(0);
 	return base;
@@ -4616,7 +4616,7 @@ template <> size_t GenericFill<IfcPropertySet>(const DB& db, const LIST& params,
 	size_t base = GenericFill(db,params,static_cast<IfcPropertySetDefinition*>(in));
 	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcPropertySet"); }    do { // convert the 'HasProperties' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->HasProperties, arg, db ); break; } 
+        try { GenericConvert( in->HasProperties, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcPropertySet to be a `SET [1:?] OF IfcProperty`")); }
     } while(0);
 	return base;
@@ -4628,13 +4628,13 @@ template <> size_t GenericFill<IfcPropertySingleValue>(const DB& db, const LIST&
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcPropertySingleValue"); }    do { // convert the 'NominalValue' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->NominalValue, arg, db ); break; } 
+        try { GenericConvert( in->NominalValue, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcPropertySingleValue to be a `IfcValue`")); }
     } while(0);
     do { // convert the 'Unit' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Unit, arg, db ); break; } 
+        try { GenericConvert( in->Unit, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcPropertySingleValue to be a `IfcUnit`")); }
     } while(0);
 	return base;
@@ -4758,13 +4758,13 @@ template <> size_t GenericFill<IfcRectangleProfileDef>(const DB& db, const LIST&
 	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcRectangleProfileDef"); }    do { // convert the 'XDim' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRectangleProfileDef,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->XDim, arg, db ); break; } 
+        try { GenericConvert( in->XDim, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRectangleProfileDef to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
     do { // convert the 'YDim' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRectangleProfileDef,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->YDim, arg, db ); break; } 
+        try { GenericConvert( in->YDim, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRectangleProfileDef to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
 	return base;
@@ -4850,12 +4850,12 @@ template <> size_t GenericFill<IfcRelAggregates>(const DB& db, const LIST& param
 	size_t base = GenericFill(db,params,static_cast<IfcRelDecomposes*>(in));
 	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelAggregates"); }    do { // convert the 'RelatingObject' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatingObject, arg, db ); break; } 
+        try { GenericConvert( in->RelatingObject, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelAggregates to be a `IfcObjectDefinition`")); }
     } while(0);
     do { // convert the 'RelatedObjects' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatedObjects, arg, db ); break; } 
+        try { GenericConvert( in->RelatedObjects, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelAggregates to be a `SET [1:?] OF IfcObjectDefinition`")); }
     } while(0);
 	return base;
@@ -4872,12 +4872,12 @@ template <> size_t GenericFill<IfcRelContainedInSpatialStructure>(const DB& db,
 	size_t base = GenericFill(db,params,static_cast<IfcRelConnects*>(in));
 	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelContainedInSpatialStructure"); }    do { // convert the 'RelatedElements' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatedElements, arg, db ); break; } 
+        try { GenericConvert( in->RelatedElements, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelContainedInSpatialStructure to be a `SET [1:?] OF IfcProduct`")); }
     } while(0);
     do { // convert the 'RelatingStructure' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatingStructure, arg, db ); break; } 
+        try { GenericConvert( in->RelatingStructure, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelContainedInSpatialStructure to be a `IfcSpatialElement`")); }
     } while(0);
 	return base;
@@ -4894,12 +4894,12 @@ template <> size_t GenericFill<IfcRelDefinesByProperties>(const DB& db, const LI
 	size_t base = GenericFill(db,params,static_cast<IfcRelDefines*>(in));
 	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelDefinesByProperties"); }    do { // convert the 'RelatedObjects' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatedObjects, arg, db ); break; } 
+        try { GenericConvert( in->RelatedObjects, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelDefinesByProperties to be a `SET [1:?] OF IfcObjectDefinition`")); }
     } while(0);
     do { // convert the 'RelatingPropertyDefinition' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatingPropertyDefinition, arg, db ); break; } 
+        try { GenericConvert( in->RelatingPropertyDefinition, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelDefinesByProperties to be a `IfcPropertySetDefinitionSelect`")); }
     } while(0);
 	return base;
@@ -4910,12 +4910,12 @@ template <> size_t GenericFill<IfcRelFillsElement>(const DB& db, const LIST& par
 	size_t base = GenericFill(db,params,static_cast<IfcRelConnects*>(in));
 	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelFillsElement"); }    do { // convert the 'RelatingOpeningElement' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatingOpeningElement, arg, db ); break; } 
+        try { GenericConvert( in->RelatingOpeningElement, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelFillsElement to be a `IfcOpeningElement`")); }
     } while(0);
     do { // convert the 'RelatedBuildingElement' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatedBuildingElement, arg, db ); break; } 
+        try { GenericConvert( in->RelatedBuildingElement, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelFillsElement to be a `IfcElement`")); }
     } while(0);
 	return base;
@@ -4926,12 +4926,12 @@ template <> size_t GenericFill<IfcRelVoidsElement>(const DB& db, const LIST& par
 	size_t base = GenericFill(db,params,static_cast<IfcRelDecomposes*>(in));
 	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelVoidsElement"); }    do { // convert the 'RelatingBuildingElement' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatingBuildingElement, arg, db ); break; } 
+        try { GenericConvert( in->RelatingBuildingElement, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelVoidsElement to be a `IfcElement`")); }
     } while(0);
     do { // convert the 'RelatedOpeningElement' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatedOpeningElement, arg, db ); break; } 
+        try { GenericConvert( in->RelatedOpeningElement, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelVoidsElement to be a `IfcFeatureElementSubtraction`")); }
     } while(0);
 	return base;
@@ -4950,27 +4950,27 @@ template <> size_t GenericFill<IfcRepresentation>(const DB& db, const LIST& para
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRepresentation"); }    do { // convert the 'ContextOfItems' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRepresentation,4>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->ContextOfItems, arg, db ); break; } 
+        try { GenericConvert( in->ContextOfItems, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRepresentation to be a `IfcRepresentationContext`")); }
     } while(0);
     do { // convert the 'RepresentationIdentifier' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRepresentation,4>::aux_is_derived[1]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RepresentationIdentifier, arg, db ); break; } 
+        try { GenericConvert( in->RepresentationIdentifier, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRepresentation to be a `IfcLabel`")); }
     } while(0);
     do { // convert the 'RepresentationType' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRepresentation,4>::aux_is_derived[2]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RepresentationType, arg, db ); break; } 
+        try { GenericConvert( in->RepresentationType, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcRepresentation to be a `IfcLabel`")); }
     } while(0);
     do { // convert the 'Items' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRepresentation,4>::aux_is_derived[3]=true; break; }
-        try { GenericConvert( in->Items, arg, db ); break; } 
+        try { GenericConvert( in->Items, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRepresentation to be a `SET [1:?] OF IfcRepresentationItem`")); }
     } while(0);
 	return base;
@@ -4981,12 +4981,12 @@ template <> size_t GenericFill<IfcRepresentationMap>(const DB& db, const LIST& p
 	size_t base = 0;
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcRepresentationMap"); }    do { // convert the 'MappingOrigin' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->MappingOrigin, arg, db ); break; } 
+        try { GenericConvert( in->MappingOrigin, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRepresentationMap to be a `IfcAxis2Placement`")); }
     } while(0);
     do { // convert the 'MappedRepresentation' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->MappedRepresentation, arg, db ); break; } 
+        try { GenericConvert( in->MappedRepresentation, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRepresentationMap to be a `IfcRepresentation`")); }
     } while(0);
 	return base;
@@ -4998,13 +4998,13 @@ template <> size_t GenericFill<IfcRevolvedAreaSolid>(const DB& db, const LIST& p
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRevolvedAreaSolid"); }    do { // convert the 'Axis' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRevolvedAreaSolid,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Axis, arg, db ); break; } 
+        try { GenericConvert( in->Axis, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcRevolvedAreaSolid to be a `IfcAxis1Placement`")); }
     } while(0);
     do { // convert the 'Angle' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRevolvedAreaSolid,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->Angle, arg, db ); break; } 
+        try { GenericConvert( in->Angle, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRevolvedAreaSolid to be a `IfcPlaneAngleMeasure`")); }
     } while(0);
 	return base;
@@ -5058,12 +5058,12 @@ template <> size_t GenericFill<IfcSIUnit>(const DB& db, const LIST& params, IfcS
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcSIUnit"); }    do { // convert the 'Prefix' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Prefix, arg, db ); break; } 
+        try { GenericConvert( in->Prefix, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSIUnit to be a `IfcSIPrefix`")); }
     } while(0);
     do { // convert the 'Name' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Name, arg, db ); break; } 
+        try { GenericConvert( in->Name, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcSIUnit to be a `IfcSIUnitName`")); }
     } while(0);
 	return base;
@@ -5144,7 +5144,7 @@ template <> size_t GenericFill<IfcShellBasedSurfaceModel>(const DB& db, const LI
 	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcShellBasedSurfaceModel"); }    do { // convert the 'SbsmBoundary' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->SbsmBoundary, arg, db ); break; } 
+        try { GenericConvert( in->SbsmBoundary, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcShellBasedSurfaceModel to be a `SET [1:?] OF IfcShell`")); }
     } while(0);
 	return base;
@@ -5156,31 +5156,31 @@ template <> size_t GenericFill<IfcSite>(const DB& db, const LIST& params, IfcSit
 	if (params.GetSize() < 14) { throw STEP::TypeError("expected 14 arguments to IfcSite"); }    do { // convert the 'RefLatitude' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RefLatitude, arg, db ); break; } 
+        try { GenericConvert( in->RefLatitude, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcSite to be a `IfcCompoundPlaneAngleMeasure`")); }
     } while(0);
     do { // convert the 'RefLongitude' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RefLongitude, arg, db ); break; } 
+        try { GenericConvert( in->RefLongitude, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to IfcSite to be a `IfcCompoundPlaneAngleMeasure`")); }
     } while(0);
     do { // convert the 'RefElevation' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RefElevation, arg, db ); break; } 
+        try { GenericConvert( in->RefElevation, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 11 to IfcSite to be a `IfcLengthMeasure`")); }
     } while(0);
     do { // convert the 'LandTitleNumber' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->LandTitleNumber, arg, db ); break; } 
+        try { GenericConvert( in->LandTitleNumber, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 12 to IfcSite to be a `IfcLabel`")); }
     } while(0);
     do { // convert the 'SiteAddress' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->SiteAddress, arg, db ); break; } 
+        try { GenericConvert( in->SiteAddress, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 13 to IfcSite to be a `IfcPostalAddress`")); }
     } while(0);
 	return base;
@@ -5234,13 +5234,13 @@ template <> size_t GenericFill<IfcSpace>(const DB& db, const LIST& params, IfcSp
 	if (params.GetSize() < 11) { throw STEP::TypeError("expected 11 arguments to IfcSpace"); }    do { // convert the 'PredefinedType' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->PredefinedType, arg, db ); break; } 
+        try { GenericConvert( in->PredefinedType, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcSpace to be a `IfcSpaceTypeEnum`")); }
     } while(0);
     do { // convert the 'ElevationWithFlooring' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ElevationWithFlooring, arg, db ); break; } 
+        try { GenericConvert( in->ElevationWithFlooring, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to IfcSpace to be a `IfcLengthMeasure`")); }
     } while(0);
 	return base;
@@ -5539,18 +5539,18 @@ template <> size_t GenericFill<IfcStyledItem>(const DB& db, const LIST& params,
 	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcStyledItem"); }    do { // convert the 'Item' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Item, arg, db ); break; } 
+        try { GenericConvert( in->Item, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcStyledItem to be a `IfcRepresentationItem`")); }
     } while(0);
     do { // convert the 'Styles' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Styles, arg, db ); break; } 
+        try { GenericConvert( in->Styles, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcStyledItem to be a `SET [1:?] OF IfcStyleAssignmentSelect`")); }
     } while(0);
     do { // convert the 'Name' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Name, arg, db ); break; } 
+        try { GenericConvert( in->Name, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcStyledItem to be a `IfcLabel`")); }
     } while(0);
 	return base;
@@ -5624,12 +5624,12 @@ template <> size_t GenericFill<IfcSurfaceStyle>(const DB& db, const LIST& params
 	size_t base = GenericFill(db,params,static_cast<IfcPresentationStyle*>(in));
 	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcSurfaceStyle"); }    do { // convert the 'Side' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Side, arg, db ); break; } 
+        try { GenericConvert( in->Side, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSurfaceStyle to be a `IfcSurfaceSide`")); }
     } while(0);
     do { // convert the 'Styles' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Styles, arg, db ); break; } 
+        try { GenericConvert( in->Styles, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSurfaceStyle to be a `SET [1:5] OF IfcSurfaceStyleElementSelect`")); }
     } while(0);
 	return base;
@@ -5641,14 +5641,14 @@ template <> size_t GenericFill<IfcSurfaceStyleShading>(const DB& db, const LIST&
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcSurfaceStyleShading"); }    do { // convert the 'SurfaceColour' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSurfaceStyleShading,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->SurfaceColour, arg, db ); break; } 
+        try { GenericConvert( in->SurfaceColour, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSurfaceStyleShading to be a `IfcColourRgb`")); }
     } while(0);
     do { // convert the 'Transparency' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSurfaceStyleShading,2>::aux_is_derived[1]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Transparency, arg, db ); break; } 
+        try { GenericConvert( in->Transparency, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSurfaceStyleShading to be a `IfcNormalisedRatioMeasure`")); }
     } while(0);
 	return base;
@@ -5660,42 +5660,42 @@ template <> size_t GenericFill<IfcSurfaceStyleRendering>(const DB& db, const LIS
 	if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to IfcSurfaceStyleRendering"); }    do { // convert the 'DiffuseColour' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->DiffuseColour, arg, db ); break; } 
+        try { GenericConvert( in->DiffuseColour, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
     } while(0);
     do { // convert the 'TransmissionColour' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->TransmissionColour, arg, db ); break; } 
+        try { GenericConvert( in->TransmissionColour, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
     } while(0);
     do { // convert the 'DiffuseTransmissionColour' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->DiffuseTransmissionColour, arg, db ); break; } 
+        try { GenericConvert( in->DiffuseTransmissionColour, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
     } while(0);
     do { // convert the 'ReflectionColour' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ReflectionColour, arg, db ); break; } 
+        try { GenericConvert( in->ReflectionColour, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
     } while(0);
     do { // convert the 'SpecularColour' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->SpecularColour, arg, db ); break; } 
+        try { GenericConvert( in->SpecularColour, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
     } while(0);
     do { // convert the 'SpecularHighlight' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->SpecularHighlight, arg, db ); break; } 
+        try { GenericConvert( in->SpecularHighlight, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcSurfaceStyleRendering to be a `IfcSpecularHighlightSelect`")); }
     } while(0);
     do { // convert the 'ReflectanceMethod' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->ReflectanceMethod, arg, db ); break; } 
+        try { GenericConvert( in->ReflectanceMethod, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcSurfaceStyleRendering to be a `IfcReflectanceMethodEnum`")); }
     } while(0);
 	return base;
@@ -5706,7 +5706,7 @@ template <> size_t GenericFill<IfcSurfaceStyleWithTextures>(const DB& db, const
 	size_t base = GenericFill(db,params,static_cast<IfcPresentationItem*>(in));
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcSurfaceStyleWithTextures"); }    do { // convert the 'Textures' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Textures, arg, db ); break; } 
+        try { GenericConvert( in->Textures, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSurfaceStyleWithTextures to be a `LIST [1:?] OF IfcSurfaceTexture`")); }
     } while(0);
 	return base;
@@ -5718,34 +5718,34 @@ template <> size_t GenericFill<IfcSweptDiskSolid>(const DB& db, const LIST& para
 	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcSweptDiskSolid"); }    do { // convert the 'Directrix' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSweptDiskSolid,5>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Directrix, arg, db ); break; } 
+        try { GenericConvert( in->Directrix, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSweptDiskSolid to be a `IfcCurve`")); }
     } while(0);
     do { // convert the 'Radius' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSweptDiskSolid,5>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->Radius, arg, db ); break; } 
+        try { GenericConvert( in->Radius, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSweptDiskSolid to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
     do { // convert the 'InnerRadius' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSweptDiskSolid,5>::aux_is_derived[2]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->InnerRadius, arg, db ); break; } 
+        try { GenericConvert( in->InnerRadius, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSweptDiskSolid to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
     do { // convert the 'StartParam' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSweptDiskSolid,5>::aux_is_derived[3]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->StartParam, arg, db ); break; } 
+        try { GenericConvert( in->StartParam, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcSweptDiskSolid to be a `IfcParameterValue`")); }
     } while(0);
     do { // convert the 'EndParam' argument
         boost::shared_ptr<const DataType> arg = params[base++];
         if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSweptDiskSolid,5>::aux_is_derived[4]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->EndParam, arg, db ); break; } 
+        try { GenericConvert( in->EndParam, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcSweptDiskSolid to be a `IfcParameterValue`")); }
     } while(0);
 	return base;
@@ -5924,27 +5924,27 @@ template <> size_t GenericFill<IfcTrimmedCurve>(const DB& db, const LIST& params
 	size_t base = GenericFill(db,params,static_cast<IfcBoundedCurve*>(in));
 	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcTrimmedCurve"); }    do { // convert the 'BasisCurve' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->BasisCurve, arg, db ); break; } 
+        try { GenericConvert( in->BasisCurve, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcTrimmedCurve to be a `IfcCurve`")); }
     } while(0);
     do { // convert the 'Trim1' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Trim1, arg, db ); break; } 
+        try { GenericConvert( in->Trim1, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcTrimmedCurve to be a `SET [1:2] OF IfcTrimmingSelect`")); }
     } while(0);
     do { // convert the 'Trim2' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Trim2, arg, db ); break; } 
+        try { GenericConvert( in->Trim2, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcTrimmedCurve to be a `SET [1:2] OF IfcTrimmingSelect`")); }
     } while(0);
     do { // convert the 'SenseAgreement' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->SenseAgreement, arg, db ); break; } 
+        try { GenericConvert( in->SenseAgreement, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcTrimmedCurve to be a `IfcBoolean`")); }
     } while(0);
     do { // convert the 'MasterRepresentation' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->MasterRepresentation, arg, db ); break; } 
+        try { GenericConvert( in->MasterRepresentation, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcTrimmedCurve to be a `IfcTrimmingPreference`")); }
     } while(0);
 	return base;
@@ -5976,7 +5976,7 @@ template <> size_t GenericFill<IfcUnitAssignment>(const DB& db, const LIST& para
 	size_t base = 0;
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcUnitAssignment"); }    do { // convert the 'Units' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Units, arg, db ); break; } 
+        try { GenericConvert( in->Units, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcUnitAssignment to be a `SET [1:?] OF IfcUnit`")); }
     } while(0);
 	return base;
@@ -6029,12 +6029,12 @@ template <> size_t GenericFill<IfcVector>(const DB& db, const LIST& params, IfcV
 	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcVector"); }    do { // convert the 'Orientation' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Orientation, arg, db ); break; } 
+        try { GenericConvert( in->Orientation, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcVector to be a `IfcDirection`")); }
     } while(0);
     do { // convert the 'Magnitude' argument
         boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Magnitude, arg, db ); break; } 
+        try { GenericConvert( in->Magnitude, arg, db ); break; }
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcVector to be a `IfcLengthMeasure`")); }
     } while(0);
 	return base;
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen_4.h b/Engine/lib/assimp/code/AssetLib/IFC/IFCReaderGen_4.h
similarity index 99%
rename from Engine/lib/assimp/code/Importer/IFC/IFCReaderGen_4.h
rename to Engine/lib/assimp/code/AssetLib/IFC/IFCReaderGen_4.h
index ccfcb6ea0..abf021911 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCReaderGen_4.h
+++ b/Engine/lib/assimp/code/AssetLib/IFC/IFCReaderGen_4.h
@@ -2,11 +2,11 @@
 Open Asset Import Library (ASSIMP)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2010, ASSIMP Development Team
+Copyright (c) 2006-2020, ASSIMP Development Team
 All rights reserved.
 
-Redistribution and use of this software in source and binary forms, 
-with or without modification, are permitted provided that the 
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
 following conditions are met:
 
 * Redistributions of source code must retain the above
@@ -23,16 +23,16 @@ following conditions are met:
   derived from this software without specific prior
   written permission of the ASSIMP Development Team.
 
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 ----------------------------------------------------------------------
@@ -51,12 +51,12 @@ namespace Schema_4 {
 
 	using namespace STEP;
 	using namespace STEP::EXPRESS;
-	
-	
+
+
 	struct NotImplemented : public ObjectHelper<NotImplemented,0> {
-		
+
 	};
-	
+
 
 	// ******************************************************************************
 	// IFC Custom data types
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCUtil.cpp b/Engine/lib/assimp/code/AssetLib/IFC/IFCUtil.cpp
similarity index 96%
rename from Engine/lib/assimp/code/Importer/IFC/IFCUtil.cpp
rename to Engine/lib/assimp/code/AssetLib/IFC/IFCUtil.cpp
index f6bca91f5..6b378c1da 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCUtil.cpp
+++ b/Engine/lib/assimp/code/AssetLib/IFC/IFCUtil.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -46,10 +46,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
 
-#include "Importer/IFC/IFCUtil.h"
+#include "AssetLib/IFC/IFCUtil.h"
 #include "Common/PolyTools.h"
 #include "PostProcessing/ProcessHelper.h"
-#include <assimp/Defines.h>
 
 namespace Assimp {
 namespace IFC {
@@ -71,7 +70,7 @@ aiMesh* TempMesh::ToMesh()
     ai_assert(mVerts.size() == std::accumulate(mVertcnt.begin(),mVertcnt.end(),size_t(0)));
 
     if (mVerts.empty()) {
-        return NULL;
+        return nullptr;
     }
 
     std::unique_ptr<aiMesh> mesh(new aiMesh());
@@ -162,7 +161,7 @@ void TempMesh::RemoveDegenerates()
     }
 
     if(drop) {
-        IFCImporter::LogDebug("removing degenerate faces");
+        IFCImporter::LogVerboseDebug("removing degenerate faces");
     }
 }
 
@@ -229,25 +228,24 @@ void TempMesh::ComputePolygonNormals(std::vector<IfcVector3>& normals,
 
 // ------------------------------------------------------------------------------------------------
 // Compute the normal of the last polygon in the given mesh
-IfcVector3 TempMesh::ComputeLastPolygonNormal(bool normalize) const
-{
+IfcVector3 TempMesh::ComputeLastPolygonNormal(bool normalize) const {
     return ComputePolygonNormal(&mVerts[mVerts.size() - mVertcnt.back()], mVertcnt.back(), normalize);
 }
 
-struct CompareVector
-{
-    bool operator () (const IfcVector3& a, const IfcVector3& b) const
-    {
+struct CompareVector {
+    bool operator () (const IfcVector3& a, const IfcVector3& b) const {
         IfcVector3 d = a - b;
-        IfcFloat eps = 1e-6;
+        IfcFloat eps = ai_epsilon;
         return d.x < -eps || (std::abs(d.x) < eps && d.y < -eps) || (std::abs(d.x) < eps && std::abs(d.y) < eps && d.z < -eps);
     }
 };
-struct FindVector
-{
+
+struct FindVector {
     IfcVector3 v;
     FindVector(const IfcVector3& p) : v(p) { }
-    bool operator () (const IfcVector3& p) { return FuzzyVectorCompare(1e-6)(p, v); }
+    bool operator()(const IfcVector3 &p) {
+        return FuzzyVectorCompare(ai_epsilon)(p, v);
+    }
 };
 
 // ------------------------------------------------------------------------------------------------
@@ -358,12 +356,12 @@ void TempMesh::FixupFaceOrientation()
                 // to reverse the neighbour
                 nb_vidx = (nb_vidx + 1) % nbvc;
                 size_t oursideidx = (a + 1) % vc;
-                if( FuzzyVectorCompare(1e-6)(mVerts[vsi + oursideidx], mVerts[nbvsi + nb_vidx]) )
-                {
+                if (FuzzyVectorCompare(ai_epsilon)(mVerts[vsi + oursideidx], mVerts[nbvsi + nb_vidx])) {
                     std::reverse(mVerts.begin() + nbvsi, mVerts.begin() + nbvsi + nbvc);
                     std::reverse(neighbour.begin() + nbvsi, neighbour.begin() + nbvsi + nbvc);
-                    for( size_t a = 0; a < nbvc - 1; ++a )
-                        std::swap(neighbour[nbvsi + a], neighbour[nbvsi + a + 1]);
+                    for (size_t aa = 0; aa < nbvc - 1; ++aa) {
+                        std::swap(neighbour[nbvsi + aa], neighbour[nbvsi + aa + 1]);
+                    }
                 }
 
                 // either way we're done with the neighbour. Mark it as done and continue checking from there recursively
@@ -436,7 +434,7 @@ void TempMesh::RemoveAdjacentDuplicates() {
         base += cnt;
     }
     if(drop) {
-        IFCImporter::LogDebug("removing duplicate vertices");
+        IFCImporter::LogVerboseDebug("removing duplicate vertices");
     }
 }
 
@@ -505,7 +503,7 @@ IfcFloat ConvertSIPrefix(const std::string& prefix)
         return 1e-18f;
     }
     else {
-        IFCImporter::LogError("Unrecognized SI prefix: " + prefix);
+        IFCImporter::LogError("Unrecognized SI prefix: ", prefix);
         return 1;
     }
 }
@@ -564,7 +562,7 @@ void ConvertDirection(IfcVector3& out, const Schema_2x3::IfcDirection& in)
         out[static_cast<unsigned int>(i)] = in.DirectionRatios[i];
     }
     const IfcFloat len = out.Length();
-    if (len<1e-6) {
+    if (len < ai_epsilon) {
         IFCImporter::LogWarn("direction vector magnitude too small, normalization would result in a division by zero");
         return;
     }
diff --git a/Engine/lib/assimp/code/Importer/IFC/IFCUtil.h b/Engine/lib/assimp/code/AssetLib/IFC/IFCUtil.h
similarity index 96%
rename from Engine/lib/assimp/code/Importer/IFC/IFCUtil.h
rename to Engine/lib/assimp/code/AssetLib/IFC/IFCUtil.h
index 32ae1e07f..b5f72a56d 100644
--- a/Engine/lib/assimp/code/Importer/IFC/IFCUtil.h
+++ b/Engine/lib/assimp/code/AssetLib/IFC/IFCUtil.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -47,12 +47,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef INCLUDED_IFCUTIL_H
 #define INCLUDED_IFCUTIL_H
 
-#include "IFCReaderGen_2x3.h"
-#include "IFCLoader.h"
-#include "code/Step/STEPFile.h"
+#include "AssetLib/IFC/IFCReaderGen_2x3.h"
+#include "AssetLib/IFC/IFCLoader.h"
+#include "AssetLib/Step/STEPFile.h"
+
 #include <assimp/mesh.h>
 #include <assimp/material.h>
 
+#include <utility>
+
 struct aiNode;
 
 namespace Assimp {
@@ -136,14 +139,10 @@ struct TempOpening
     }
 
     // ------------------------------------------------------------------------------
-    TempOpening(const IFC::Schema_2x3::IfcSolidModel* solid,IfcVector3 extrusionDir,
-        std::shared_ptr<TempMesh> profileMesh,
-        std::shared_ptr<TempMesh> profileMesh2D)
-        : solid(solid)
-        , extrusionDir(extrusionDir)
-        , profileMesh(profileMesh)
-        , profileMesh2D(profileMesh2D)
-    {
+    TempOpening(const IFC::Schema_2x3::IfcSolidModel *solid, IfcVector3 extrusionDir,
+            std::shared_ptr<TempMesh> profileMesh,
+            std::shared_ptr<TempMesh> profileMesh2D) :
+            solid(solid), extrusionDir(extrusionDir), profileMesh(std::move(profileMesh)), profileMesh2D(std::move(profileMesh2D)) {
     }
 
     // ------------------------------------------------------------------------------
@@ -200,7 +199,7 @@ struct ConversionData
 
     struct MeshCacheIndex {
         const IFC::Schema_2x3::IfcRepresentationItem* item; unsigned int matindex;
-        MeshCacheIndex() : item(NULL), matindex(0) { }
+        MeshCacheIndex() : item(nullptr), matindex(0) { }
         MeshCacheIndex(const IFC::Schema_2x3::IfcRepresentationItem* i, unsigned int mi) : item(i), matindex(mi) { }
         bool operator == (const MeshCacheIndex& o) const { return item == o.item && matindex == o.matindex; }
         bool operator < (const MeshCacheIndex& o) const { return item < o.item || (item == o.item && matindex < o.matindex); }
@@ -308,7 +307,6 @@ void ProcessBooleanExtrudedAreaSolidDifference(const Schema_2x3::IfcExtrudedArea
 // IFCOpenings.cpp
 
 bool GenerateOpenings(std::vector<TempOpening>& openings,
-                      const std::vector<IfcVector3>& nors,
                       TempMesh& curmesh,
                       bool check_intersection,
                       bool generate_connection_geometry,
diff --git a/Engine/lib/assimp/code/AssetLib/IQM/IQMImporter.cpp b/Engine/lib/assimp/code/AssetLib/IQM/IQMImporter.cpp
new file mode 100644
index 000000000..2bea66c6b
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/IQM/IQMImporter.cpp
@@ -0,0 +1,322 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2021, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#ifndef ASSIMP_BUILD_NO_IQM_IMPORTER
+
+#include <assimp/DefaultIOSystem.h>
+#include <assimp/IOStreamBuffer.h>
+#include <assimp/ai_assert.h>
+#include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/Importer.hpp>
+#include <assimp/ByteSwapper.h>
+#include <memory>
+#include <numeric>
+
+#include "IQMImporter.h"
+#include "iqm.h"
+
+// RESOURCES:
+// http://sauerbraten.org/iqm/
+// https://github.com/lsalzman/iqm
+
+
+inline void swap_block( uint32_t *block, size_t size ){
+    (void)block; // suppress 'unreferenced formal parameter' MSVC warning
+    size >>= 2;
+    for ( size_t i = 0; i < size; ++i )
+        AI_SWAP4( block[ i ] );
+}
+
+static const aiImporterDesc desc = {
+    "Inter-Quake Model Importer",
+    "",
+    "",
+    "",
+    aiImporterFlags_SupportBinaryFlavour,
+    0,
+    0,
+    0,
+    0,
+    "iqm"
+};
+
+namespace Assimp {
+
+// ------------------------------------------------------------------------------------------------
+//  Default constructor
+IQMImporter::IQMImporter() :
+        mScene(nullptr) {
+    // empty
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Returns true, if file is a binary Inter-Quake Model file.
+bool IQMImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const {
+    const std::string extension = GetExtension(pFile);
+
+    if (extension == "iqm")
+        return true;
+    else if (!extension.length() || checkSig) {
+        if (!pIOHandler) {
+            return true;
+        }
+        /*
+         * don't use CheckMagicToken because that checks with swapped bytes too, leading to false
+         * positives. This magic is not uint32_t, but char[4], so memcmp is the best way
+
+        const char* tokens[] = {"3DMO", "3dmo"};
+        return CheckMagicToken(pIOHandler,pFile,tokens,2,0,4);
+        */
+        std::unique_ptr<IOStream> pStream(pIOHandler->Open(pFile, "rb"));
+        unsigned char data[15];
+        if (!pStream || 15 != pStream->Read(data, 1, 15)) {
+            return false;
+        }
+        return !memcmp(data, "INTERQUAKEMODEL", 15);
+    }
+    return false;
+}
+
+// ------------------------------------------------------------------------------------------------
+const aiImporterDesc *IQMImporter::GetInfo() const {
+    return &desc;
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Model 3D import implementation
+void IQMImporter::InternReadFile(const std::string &file, aiScene *pScene, IOSystem *pIOHandler) {
+    // Read file into memory
+    std::unique_ptr<IOStream> pStream(pIOHandler->Open(file, "rb"));
+    if (!pStream.get()) {
+        throw DeadlyImportError("Failed to open file ", file, ".");
+    }
+
+    // Get the file-size and validate it, throwing an exception when fails
+    const size_t fileSize = pStream->FileSize();
+    if (fileSize < sizeof( iqmheader )) {
+        throw DeadlyImportError("IQM-file ", file, " is too small.");
+    }
+    std::vector<unsigned char> buffer(fileSize);
+    unsigned char *data = buffer.data();
+    if (fileSize != pStream->Read(data, 1, fileSize)) {
+        throw DeadlyImportError("Failed to read the file ", file, ".");
+    }
+
+    // get header
+    iqmheader &hdr = reinterpret_cast<iqmheader&>( *data );
+    swap_block( &hdr.version, sizeof( iqmheader ) - sizeof( iqmheader::magic ) );
+
+    // extra check for header
+    if (memcmp(data, IQM_MAGIC, sizeof( IQM_MAGIC ) )
+     || hdr.version != IQM_VERSION
+     || hdr.filesize != fileSize) {
+        throw DeadlyImportError("Bad binary header in file ", file, ".");
+    }
+
+    ASSIMP_LOG_DEBUG("IQM: loading ", file);
+
+    // create the root node
+    pScene->mRootNode = new aiNode( "<IQMRoot>" );
+    // Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system
+    pScene->mRootNode->mTransformation = aiMatrix4x4(
+            1.f, 0.f, 0.f, 0.f,
+            0.f, 0.f, 1.f, 0.f,
+            0.f, -1.f, 0.f, 0.f,
+            0.f, 0.f, 0.f, 1.f);
+    pScene->mRootNode->mNumMeshes = hdr.num_meshes;
+    pScene->mRootNode->mMeshes = new unsigned int[hdr.num_meshes];
+    std::iota( pScene->mRootNode->mMeshes, pScene->mRootNode->mMeshes + pScene->mRootNode->mNumMeshes, 0 );
+
+    mScene = pScene;
+
+    // Allocate output storage
+    pScene->mNumMeshes = 0;
+    pScene->mMeshes = new aiMesh *[hdr.num_meshes](); // Set arrays to zero to ensue proper destruction if an exception is raised
+
+    pScene->mNumMaterials = 0;
+    pScene->mMaterials = new aiMaterial *[hdr.num_meshes]();
+
+    // swap vertex arrays beforehand...
+    for( auto array = reinterpret_cast<iqmvertexarray*>( data + hdr.ofs_vertexarrays ), end = array + hdr.num_vertexarrays; array != end; ++array )
+    {
+        swap_block( &array->type, sizeof( iqmvertexarray ) );
+    }
+
+    // Read all surfaces from the file
+    for( auto imesh = reinterpret_cast<iqmmesh*>( data + hdr.ofs_meshes ), end_ = imesh + hdr.num_meshes; imesh != end_; ++imesh )
+    {
+        swap_block( &imesh->name, sizeof( iqmmesh ) );
+        // Allocate output mesh & material
+        auto mesh = pScene->mMeshes[pScene->mNumMeshes++] = new aiMesh();
+        mesh->mMaterialIndex = pScene->mNumMaterials;
+        auto mat = pScene->mMaterials[pScene->mNumMaterials++] = new aiMaterial();
+
+        {
+            auto text = reinterpret_cast<char*>( data + hdr.ofs_text );
+            aiString name( text + imesh->material );
+            mat->AddProperty( &name, AI_MATKEY_NAME );
+            mat->AddProperty( &name, AI_MATKEY_TEXTURE_DIFFUSE(0) );
+        }
+
+        // Fill mesh information
+        mesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
+        mesh->mNumFaces = 0;
+        mesh->mFaces = new aiFace[imesh->num_triangles];
+
+        // Fill in all triangles
+        for( auto tri = reinterpret_cast<iqmtriangle*>( data + hdr.ofs_triangles ) + imesh->first_triangle, end = tri + imesh->num_triangles; tri != end; ++tri )
+        {
+            swap_block( tri->vertex, sizeof( tri->vertex ) );
+            auto& face = mesh->mFaces[mesh->mNumFaces++];
+            face.mNumIndices = 3;
+            face.mIndices = new unsigned int[3]{ tri->vertex[0] - imesh->first_vertex,
+                                                 tri->vertex[2] - imesh->first_vertex,
+                                                 tri->vertex[1] - imesh->first_vertex };
+        }
+
+        // Fill in all vertices
+        for( auto array = reinterpret_cast<const iqmvertexarray*>( data + hdr.ofs_vertexarrays ), end__ = array + hdr.num_vertexarrays; array != end__; ++array )
+        {
+            const unsigned int nVerts = imesh->num_vertexes;
+            const unsigned int step = array->size;
+
+            switch ( array->type )
+            {
+            case IQM_POSITION:
+                if( array->format == IQM_FLOAT && step >= 3 ){
+                    mesh->mNumVertices = nVerts;
+                    auto v = mesh->mVertices = new aiVector3D[nVerts];
+                    for( auto f = reinterpret_cast<const float*>( data + array->offset ) + imesh->first_vertex * step,
+                        end = f + nVerts * step; f != end; f += step, ++v )
+                    {
+                        *v = { AI_BE( f[0] ),
+                               AI_BE( f[1] ),
+                               AI_BE( f[2] ) };
+                    }
+                }
+                break;
+               case IQM_TEXCOORD:
+                if( array->format == IQM_FLOAT && step >= 2)
+                {
+                    auto v = mesh->mTextureCoords[0] = new aiVector3D[nVerts];
+                    mesh->mNumUVComponents[0] = 2;
+                    for( auto f = reinterpret_cast<const float*>( data + array->offset ) + imesh->first_vertex * step,
+                        end = f + nVerts * step; f != end; f += step, ++v )
+                    {
+                        *v = { AI_BE( f[0] ),
+                           1 - AI_BE( f[1] ), 0 };
+                    }
+                }
+                break;
+            case IQM_NORMAL:
+                if (array->format == IQM_FLOAT && step >= 3)
+                {
+                    auto v = mesh->mNormals = new aiVector3D[nVerts];
+                    for( auto f = reinterpret_cast<const float*>( data + array->offset ) + imesh->first_vertex * step,
+                        end = f + nVerts * step; f != end; f += step, ++v )
+                    {
+                        *v = { AI_BE( f[0] ),
+                               AI_BE( f[1] ),
+                               AI_BE( f[2] ) };
+                    }
+                }
+                break;
+            case IQM_COLOR:
+                if (array->format == IQM_UBYTE && step >= 3)
+                {
+                    auto v = mesh->mColors[0] = new aiColor4D[nVerts];
+                    for( auto f = ( data + array->offset ) + imesh->first_vertex * step,
+                        end = f + nVerts * step; f != end; f += step, ++v )
+                    {
+                        *v = { ( f[0] ) / 255.f,
+                               ( f[1] ) / 255.f,
+                               ( f[2] ) / 255.f,
+                               step == 3? 1 : ( f[3] ) / 255.f };
+                    }
+                }
+                else if (array->format == IQM_FLOAT && step >= 3)
+                {
+                    auto v = mesh->mColors[0] = new aiColor4D[nVerts];
+                    for( auto f = reinterpret_cast<const float*>( data + array->offset ) + imesh->first_vertex * step,
+                        end = f + nVerts * step; f != end; f += step, ++v )
+                    {
+                        *v = { AI_BE( f[0] ),
+                               AI_BE( f[1] ),
+                               AI_BE( f[2] ),
+                               step == 3? 1 : AI_BE( f[3] ) };
+                    }
+                }
+                break;
+            case IQM_TANGENT:
+#if 0
+                if (array->format == IQM_FLOAT && step >= 3)
+                {
+                    auto v = mesh->mTangents = new aiVector3D[nVerts];
+                    for( auto f = reinterpret_cast<const float*>( data + array->offset ) + imesh->first_vertex * step,
+                        end = f + nVerts * step; f != end; f += step, ++v )
+                    {
+                        *v = { AI_BE( f[0] ),
+                               AI_BE( f[1] ),
+                               AI_BE( f[2] ) };
+                    }
+                }
+#endif
+                break;
+            case IQM_BLENDINDEXES:
+            case IQM_BLENDWEIGHTS:
+            case IQM_CUSTOM:
+                break; // these attributes are not relevant.
+
+            default:
+                break;
+            }
+        }
+    }
+}
+
+
+// ------------------------------------------------------------------------------------------------
+
+} // Namespace Assimp
+
+#endif // !! ASSIMP_BUILD_NO_IQM_IMPORTER
diff --git a/Engine/lib/assimp/code/AssetLib/IQM/IQMImporter.h b/Engine/lib/assimp/code/AssetLib/IQM/IQMImporter.h
new file mode 100644
index 000000000..fbeaff8c3
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/IQM/IQMImporter.h
@@ -0,0 +1,78 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2021, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file IQMImporter.h
+*   @brief Declares the importer class to read a scene from an Inter-Quake Model file
+*/
+
+#pragma once
+
+#ifndef ASSIMP_BUILD_NO_IQM_IMPORTER
+
+#include <assimp/BaseImporter.h>
+#include <assimp/material.h>
+
+namespace Assimp {
+
+class IQMImporter : public BaseImporter {
+public:
+	/// \brief  Default constructor
+	IQMImporter();
+    ~IQMImporter() override {}
+
+	/// \brief  Returns whether the class can handle the format of the given file.
+	/// \remark See BaseImporter::CanRead() for details.
+	bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const override;
+
+protected:
+    //! \brief  Appends the supported extension.
+    const aiImporterDesc *GetInfo() const override;
+
+    //! \brief  File import implementation.
+    void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) override;
+
+private:
+    aiScene *mScene = nullptr; // the scene to import to
+};
+
+} // Namespace Assimp
+
+#endif // ASSIMP_BUILD_NO_IQM_IMPORTER
diff --git a/Engine/lib/assimp/code/AssetLib/IQM/iqm.h b/Engine/lib/assimp/code/AssetLib/IQM/iqm.h
new file mode 100644
index 000000000..a450504f9
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/IQM/iqm.h
@@ -0,0 +1,134 @@
+#ifndef __IQM_H__
+#define __IQM_H__
+
+#define IQM_MAGIC "INTERQUAKEMODEL"
+#define IQM_VERSION 2
+
+struct iqmheader
+{
+    char magic[16];
+    unsigned int version;
+    unsigned int filesize;
+    unsigned int flags;
+    unsigned int num_text, ofs_text;
+    unsigned int num_meshes, ofs_meshes;
+    unsigned int num_vertexarrays, num_vertexes, ofs_vertexarrays;
+    unsigned int num_triangles, ofs_triangles, ofs_adjacency;
+    unsigned int num_joints, ofs_joints;
+    unsigned int num_poses, ofs_poses;
+    unsigned int num_anims, ofs_anims;
+    unsigned int num_frames, num_framechannels, ofs_frames, ofs_bounds;
+    unsigned int num_comment, ofs_comment;
+    unsigned int num_extensions, ofs_extensions;
+};
+
+struct iqmmesh
+{
+    unsigned int name;
+    unsigned int material;
+    unsigned int first_vertex, num_vertexes;
+    unsigned int first_triangle, num_triangles;
+};
+
+enum
+{
+    IQM_POSITION     = 0,
+    IQM_TEXCOORD     = 1,
+    IQM_NORMAL       = 2,
+    IQM_TANGENT      = 3,
+    IQM_BLENDINDEXES = 4,
+    IQM_BLENDWEIGHTS = 5,
+    IQM_COLOR        = 6,
+    IQM_CUSTOM       = 0x10
+};
+
+enum
+{
+    IQM_BYTE   = 0,
+    IQM_UBYTE  = 1,
+    IQM_SHORT  = 2,
+    IQM_USHORT = 3,
+    IQM_INT    = 4,
+    IQM_UINT   = 5,
+    IQM_HALF   = 6,
+    IQM_FLOAT  = 7,
+    IQM_DOUBLE = 8
+};
+
+struct iqmtriangle
+{
+    unsigned int vertex[3];
+};
+
+struct iqmadjacency
+{
+    unsigned int triangle[3];
+};
+
+struct iqmjointv1
+{
+    unsigned int name;
+    int parent;
+    float translate[3], rotate[3], scale[3];
+};
+
+struct iqmjoint
+{
+    unsigned int name;
+    int parent;
+    float translate[3], rotate[4], scale[3];
+};
+
+struct iqmposev1
+{
+    int parent;
+    unsigned int mask;
+    float channeloffset[9];
+    float channelscale[9];
+};
+
+struct iqmpose
+{
+    int parent;
+    unsigned int mask;
+    float channeloffset[10];
+    float channelscale[10];
+};
+
+struct iqmanim
+{
+    unsigned int name;
+    unsigned int first_frame, num_frames;
+    float framerate;
+    unsigned int flags;
+};
+
+enum
+{
+    IQM_LOOP = 1<<0
+};
+
+struct iqmvertexarray
+{
+    unsigned int type;
+    unsigned int flags;
+    unsigned int format;
+    unsigned int size;
+    unsigned int offset;
+};
+
+struct iqmbounds
+{
+    float bbmin[3], bbmax[3];
+    float xyradius, radius;
+};
+
+struct iqmextension
+{
+    unsigned int name;
+    unsigned int num_data, ofs_data;
+    unsigned int ofs_extensions; // pointer to next extension
+};
+
+#endif
+
diff --git a/Engine/lib/assimp/code/AssetLib/Irr/IRRLoader.cpp b/Engine/lib/assimp/code/AssetLib/Irr/IRRLoader.cpp
new file mode 100644
index 000000000..0061634a6
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Irr/IRRLoader.cpp
@@ -0,0 +1,1359 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file  IRRLoader.cpp
+ *  @brief Implementation of the Irr importer class
+ */
+
+#ifndef ASSIMP_BUILD_NO_IRR_IMPORTER
+
+#include "AssetLib/Irr/IRRLoader.h"
+#include "Common/Importer.h"
+
+#include <assimp/GenericProperty.h>
+#include <assimp/MathFunctions.h>
+#include <assimp/ParsingUtils.h>
+#include <assimp/SceneCombiner.h>
+#include <assimp/StandardShapes.h>
+#include <assimp/fast_atof.h>
+#include <assimp/importerdesc.h>
+#include <assimp/material.h>
+#include <assimp/mesh.h>
+#include <assimp/postprocess.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOSystem.hpp>
+
+#include <memory>
+
+using namespace Assimp;
+
+static const aiImporterDesc desc = {
+	"Irrlicht Scene Reader",
+	"",
+	"",
+	"http://irrlicht.sourceforge.net/",
+	aiImporterFlags_SupportTextFlavour,
+	0,
+	0,
+	0,
+	0,
+	"irr xml"
+};
+
+// ------------------------------------------------------------------------------------------------
+// Constructor to be privately used by Importer
+IRRImporter::IRRImporter() :
+		fps(), configSpeedFlag() {
+	// empty
+}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor, private as well
+IRRImporter::~IRRImporter() {
+	// empty
+}
+
+// ------------------------------------------------------------------------------------------------
+// Returns whether the class can handle the format of the given file.
+bool IRRImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
+	static const char *tokens[] = { "irr_scene" };
+	return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
+}
+
+// ------------------------------------------------------------------------------------------------
+const aiImporterDesc *IRRImporter::GetInfo() const {
+	return &desc;
+}
+
+// ------------------------------------------------------------------------------------------------
+void IRRImporter::SetupProperties(const Importer *pImp) {
+	// read the output frame rate of all node animation channels
+	fps = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_IRR_ANIM_FPS, 100);
+	if (fps < 10.) {
+		ASSIMP_LOG_ERROR("IRR: Invalid FPS configuration");
+		fps = 100;
+	}
+
+	// AI_CONFIG_FAVOUR_SPEED
+	configSpeedFlag = (0 != pImp->GetPropertyInteger(AI_CONFIG_FAVOUR_SPEED, 0));
+}
+
+// ------------------------------------------------------------------------------------------------
+// Build a mesh that consists of a single squad (a side of a skybox)
+aiMesh *IRRImporter::BuildSingleQuadMesh(const SkyboxVertex &v1,
+		const SkyboxVertex &v2,
+		const SkyboxVertex &v3,
+		const SkyboxVertex &v4) {
+	// allocate and prepare the mesh
+	aiMesh *out = new aiMesh();
+
+	out->mPrimitiveTypes = aiPrimitiveType_POLYGON;
+	out->mNumFaces = 1;
+
+	// build the face
+	out->mFaces = new aiFace[1];
+	aiFace &face = out->mFaces[0];
+
+	face.mNumIndices = 4;
+	face.mIndices = new unsigned int[4];
+	for (unsigned int i = 0; i < 4; ++i)
+		face.mIndices[i] = i;
+
+	out->mNumVertices = 4;
+
+	// copy vertex positions
+	aiVector3D *vec = out->mVertices = new aiVector3D[4];
+	*vec++ = v1.position;
+	*vec++ = v2.position;
+	*vec++ = v3.position;
+	*vec = v4.position;
+
+	// copy vertex normals
+	vec = out->mNormals = new aiVector3D[4];
+	*vec++ = v1.normal;
+	*vec++ = v2.normal;
+	*vec++ = v3.normal;
+	*vec = v4.normal;
+
+	// copy texture coordinates
+	vec = out->mTextureCoords[0] = new aiVector3D[4];
+	*vec++ = v1.uv;
+	*vec++ = v2.uv;
+	*vec++ = v3.uv;
+	*vec = v4.uv;
+	return out;
+}
+
+// ------------------------------------------------------------------------------------------------
+void IRRImporter::BuildSkybox(std::vector<aiMesh *> &meshes, std::vector<aiMaterial *> materials) {
+	// Update the material of the skybox - replace the name and disable shading for skyboxes.
+	for (unsigned int i = 0; i < 6; ++i) {
+		aiMaterial *out = (aiMaterial *)(*(materials.end() - (6 - i)));
+
+		aiString s;
+		s.length = ::ai_snprintf(s.data, MAXLEN, "SkyboxSide_%u", i);
+		out->AddProperty(&s, AI_MATKEY_NAME);
+
+		int shading = aiShadingMode_NoShading;
+		out->AddProperty(&shading, 1, AI_MATKEY_SHADING_MODEL);
+	}
+
+	// Skyboxes are much more difficult. They are represented
+	// by six single planes with different textures, so we'll
+	// need to build six meshes.
+
+	const ai_real l = 10.0; // the size used by Irrlicht
+
+	// FRONT SIDE
+	meshes.push_back(BuildSingleQuadMesh(
+			SkyboxVertex(-l, -l, -l, 0, 0, 1, 1.0, 1.0),
+			SkyboxVertex(l, -l, -l, 0, 0, 1, 0.0, 1.0),
+			SkyboxVertex(l, l, -l, 0, 0, 1, 0.0, 0.0),
+			SkyboxVertex(-l, l, -l, 0, 0, 1, 1.0, 0.0)));
+	meshes.back()->mMaterialIndex = static_cast<unsigned int>(materials.size() - 6u);
+
+	// LEFT SIDE
+	meshes.push_back(BuildSingleQuadMesh(
+			SkyboxVertex(l, -l, -l, -1, 0, 0, 1.0, 1.0),
+			SkyboxVertex(l, -l, l, -1, 0, 0, 0.0, 1.0),
+			SkyboxVertex(l, l, l, -1, 0, 0, 0.0, 0.0),
+			SkyboxVertex(l, l, -l, -1, 0, 0, 1.0, 0.0)));
+	meshes.back()->mMaterialIndex = static_cast<unsigned int>(materials.size() - 5u);
+
+	// BACK SIDE
+	meshes.push_back(BuildSingleQuadMesh(
+			SkyboxVertex(l, -l, l, 0, 0, -1, 1.0, 1.0),
+			SkyboxVertex(-l, -l, l, 0, 0, -1, 0.0, 1.0),
+			SkyboxVertex(-l, l, l, 0, 0, -1, 0.0, 0.0),
+			SkyboxVertex(l, l, l, 0, 0, -1, 1.0, 0.0)));
+	meshes.back()->mMaterialIndex = static_cast<unsigned int>(materials.size() - 4u);
+
+	// RIGHT SIDE
+	meshes.push_back(BuildSingleQuadMesh(
+			SkyboxVertex(-l, -l, l, 1, 0, 0, 1.0, 1.0),
+			SkyboxVertex(-l, -l, -l, 1, 0, 0, 0.0, 1.0),
+			SkyboxVertex(-l, l, -l, 1, 0, 0, 0.0, 0.0),
+			SkyboxVertex(-l, l, l, 1, 0, 0, 1.0, 0.0)));
+	meshes.back()->mMaterialIndex = static_cast<unsigned int>(materials.size() - 3u);
+
+	// TOP SIDE
+	meshes.push_back(BuildSingleQuadMesh(
+			SkyboxVertex(l, l, -l, 0, -1, 0, 1.0, 1.0),
+			SkyboxVertex(l, l, l, 0, -1, 0, 0.0, 1.0),
+			SkyboxVertex(-l, l, l, 0, -1, 0, 0.0, 0.0),
+			SkyboxVertex(-l, l, -l, 0, -1, 0, 1.0, 0.0)));
+	meshes.back()->mMaterialIndex = static_cast<unsigned int>(materials.size() - 2u);
+
+	// BOTTOM SIDE
+	meshes.push_back(BuildSingleQuadMesh(
+			SkyboxVertex(l, -l, l, 0, 1, 0, 0.0, 0.0),
+			SkyboxVertex(l, -l, -l, 0, 1, 0, 1.0, 0.0),
+			SkyboxVertex(-l, -l, -l, 0, 1, 0, 1.0, 1.0),
+			SkyboxVertex(-l, -l, l, 0, 1, 0, 0.0, 1.0)));
+	meshes.back()->mMaterialIndex = static_cast<unsigned int>(materials.size() - 1u);
+}
+
+// ------------------------------------------------------------------------------------------------
+void IRRImporter::CopyMaterial(std::vector<aiMaterial *> &materials,
+		std::vector<std::pair<aiMaterial *, unsigned int>> &inmaterials,
+		unsigned int &defMatIdx,
+		aiMesh *mesh) {
+	if (inmaterials.empty()) {
+		// Do we have a default material? If not we need to create one
+		if (UINT_MAX == defMatIdx) {
+			defMatIdx = (unsigned int)materials.size();
+			//TODO: add this materials to someone?
+			/*aiMaterial* mat = new aiMaterial();
+
+            aiString s;
+            s.Set(AI_DEFAULT_MATERIAL_NAME);
+            mat->AddProperty(&s,AI_MATKEY_NAME);
+
+            aiColor3D c(0.6f,0.6f,0.6f);
+            mat->AddProperty(&c,1,AI_MATKEY_COLOR_DIFFUSE);*/
+		}
+		mesh->mMaterialIndex = defMatIdx;
+		return;
+	} else if (inmaterials.size() > 1) {
+		ASSIMP_LOG_INFO("IRR: Skipping additional materials");
+	}
+
+	mesh->mMaterialIndex = (unsigned int)materials.size();
+	materials.push_back(inmaterials[0].first);
+}
+
+// ------------------------------------------------------------------------------------------------
+inline int ClampSpline(int idx, int size) {
+	return (idx < 0 ? size + idx : (idx >= size ? idx - size : idx));
+}
+
+// ------------------------------------------------------------------------------------------------
+inline void FindSuitableMultiple(int &angle) {
+	if (angle < 3)
+		angle = 3;
+	else if (angle < 10)
+		angle = 10;
+	else if (angle < 20)
+		angle = 20;
+	else if (angle < 30)
+		angle = 30;
+}
+
+// ------------------------------------------------------------------------------------------------
+void IRRImporter::ComputeAnimations(Node *root, aiNode *real, std::vector<aiNodeAnim *> &anims) {
+	ai_assert(nullptr != root && nullptr != real);
+
+	// XXX totally WIP - doesn't produce proper results, need to evaluate
+	// whether there's any use for Irrlicht's proprietary scene format
+	// outside Irrlicht ...
+	// This also applies to the above function of FindSuitableMultiple and ClampSpline which are
+	// solely used in this function
+
+	if (root->animators.empty()) {
+		return;
+	}
+	unsigned int total(0);
+	for (std::list<Animator>::iterator it = root->animators.begin(); it != root->animators.end(); ++it) {
+		if ((*it).type == Animator::UNKNOWN || (*it).type == Animator::OTHER) {
+			ASSIMP_LOG_WARN("IRR: Skipping unknown or unsupported animator");
+			continue;
+		}
+		++total;
+	}
+	if (!total) {
+		return;
+	} else if (1 == total) {
+		ASSIMP_LOG_WARN("IRR: Adding dummy nodes to simulate multiple animators");
+	}
+
+	// NOTE: 1 tick == i millisecond
+
+	unsigned int cur = 0;
+	for (std::list<Animator>::iterator it = root->animators.begin();
+			it != root->animators.end(); ++it) {
+		if ((*it).type == Animator::UNKNOWN || (*it).type == Animator::OTHER) continue;
+
+		Animator &in = *it;
+		aiNodeAnim *anim = new aiNodeAnim();
+
+		if (cur != total - 1) {
+			// Build a new name - a prefix instead of a suffix because it is
+			// easier to check against
+			anim->mNodeName.length = ::ai_snprintf(anim->mNodeName.data, MAXLEN,
+					"$INST_DUMMY_%i_%s", total - 1,
+					(root->name.length() ? root->name.c_str() : ""));
+
+			// we'll also need to insert a dummy in the node hierarchy.
+			aiNode *dummy = new aiNode();
+
+			for (unsigned int i = 0; i < real->mParent->mNumChildren; ++i)
+				if (real->mParent->mChildren[i] == real)
+					real->mParent->mChildren[i] = dummy;
+
+			dummy->mParent = real->mParent;
+			dummy->mName = anim->mNodeName;
+
+			dummy->mNumChildren = 1;
+			dummy->mChildren = new aiNode *[dummy->mNumChildren];
+			dummy->mChildren[0] = real;
+
+			// the transformation matrix of the dummy node is the identity
+
+			real->mParent = dummy;
+		} else
+			anim->mNodeName.Set(root->name);
+		++cur;
+
+		switch (in.type) {
+			case Animator::ROTATION: {
+				// -----------------------------------------------------
+				// find out how long a full rotation will take
+				// This is the least common multiple of 360.f and all
+				// three euler angles. Although we'll surely find a
+				// possible multiple (haha) it could be somewhat large
+				// for our purposes. So we need to modify the angles
+				// here in order to get good results.
+				// -----------------------------------------------------
+				int angles[3];
+				angles[0] = (int)(in.direction.x * 100);
+				angles[1] = (int)(in.direction.y * 100);
+				angles[2] = (int)(in.direction.z * 100);
+
+				angles[0] %= 360;
+				angles[1] %= 360;
+				angles[2] %= 360;
+
+				if ((angles[0] * angles[1]) != 0 && (angles[1] * angles[2]) != 0) {
+					FindSuitableMultiple(angles[0]);
+					FindSuitableMultiple(angles[1]);
+					FindSuitableMultiple(angles[2]);
+				}
+
+				int lcm = 360;
+
+				if (angles[0])
+					lcm = Math::lcm(lcm, angles[0]);
+
+				if (angles[1])
+					lcm = Math::lcm(lcm, angles[1]);
+
+				if (angles[2])
+					lcm = Math::lcm(lcm, angles[2]);
+
+				if (360 == lcm)
+					break;
+
+
+				// find out how many time units we'll need for the finest
+				// track (in seconds) - this defines the number of output
+				// keys (fps * seconds)
+				float max = 0.f;
+				if (angles[0])
+					max = (float)lcm / angles[0];
+				if (angles[1])
+					max = std::max(max, (float)lcm / angles[1]);
+				if (angles[2])
+					max = std::max(max, (float)lcm / angles[2]);
+
+				anim->mNumRotationKeys = (unsigned int)(max * fps);
+				anim->mRotationKeys = new aiQuatKey[anim->mNumRotationKeys];
+
+				// begin with a zero angle
+				aiVector3D angle;
+				for (unsigned int i = 0; i < anim->mNumRotationKeys; ++i) {
+					// build the quaternion for the given euler angles
+					aiQuatKey &q = anim->mRotationKeys[i];
+
+					q.mValue = aiQuaternion(angle.x, angle.y, angle.z);
+					q.mTime = (double)i;
+
+					// increase the angle
+					angle += in.direction;
+				}
+
+				// This animation is repeated and repeated ...
+				anim->mPostState = anim->mPreState = aiAnimBehaviour_REPEAT;
+			} break;
+
+			case Animator::FLY_CIRCLE: {
+				// -----------------------------------------------------
+				// Find out how much time we'll need to perform a
+				// full circle.
+				// -----------------------------------------------------
+				const double seconds = (1. / in.speed) / 1000.;
+				const double tdelta = 1000. / fps;
+
+				anim->mNumPositionKeys = (unsigned int)(fps * seconds);
+				anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys];
+
+				// from Irrlicht, what else should we do than copying it?
+				aiVector3D vecU, vecV;
+				if (in.direction.y) {
+					vecV = aiVector3D(50, 0, 0) ^ in.direction;
+				} else
+					vecV = aiVector3D(0, 50, 00) ^ in.direction;
+				vecV.Normalize();
+				vecU = (vecV ^ in.direction).Normalize();
+
+				// build the output keys
+				for (unsigned int i = 0; i < anim->mNumPositionKeys; ++i) {
+					aiVectorKey &key = anim->mPositionKeys[i];
+					key.mTime = i * tdelta;
+
+					const ai_real t = (ai_real)(in.speed * key.mTime);
+					key.mValue = in.circleCenter + in.circleRadius * ((vecU * std::cos(t)) + (vecV * std::sin(t)));
+				}
+
+				// This animation is repeated and repeated ...
+				anim->mPostState = anim->mPreState = aiAnimBehaviour_REPEAT;
+			} break;
+
+			case Animator::FLY_STRAIGHT: {
+				anim->mPostState = anim->mPreState = (in.loop ? aiAnimBehaviour_REPEAT : aiAnimBehaviour_CONSTANT);
+				const double seconds = in.timeForWay / 1000.;
+				const double tdelta = 1000. / fps;
+
+				anim->mNumPositionKeys = (unsigned int)(fps * seconds);
+				anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys];
+
+				aiVector3D diff = in.direction - in.circleCenter;
+				const ai_real lengthOfWay = diff.Length();
+				diff.Normalize();
+
+				const double timeFactor = lengthOfWay / in.timeForWay;
+
+				// build the output keys
+				for (unsigned int i = 0; i < anim->mNumPositionKeys; ++i) {
+					aiVectorKey &key = anim->mPositionKeys[i];
+					key.mTime = i * tdelta;
+					key.mValue = in.circleCenter + diff * ai_real(timeFactor * key.mTime);
+				}
+			} break;
+
+			case Animator::FOLLOW_SPLINE: {
+				// repeat outside the defined time range
+				anim->mPostState = anim->mPreState = aiAnimBehaviour_REPEAT;
+				const int size = (int)in.splineKeys.size();
+				if (!size) {
+					// We have no point in the spline. That's bad. Really bad.
+					ASSIMP_LOG_WARN("IRR: Spline animators with no points defined");
+
+					delete anim;
+					anim = nullptr;
+					break;
+				} else if (size == 1) {
+					// We have just one point in the spline so we don't need the full calculation
+					anim->mNumPositionKeys = 1;
+					anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys];
+
+					anim->mPositionKeys[0].mValue = in.splineKeys[0].mValue;
+					anim->mPositionKeys[0].mTime = 0.f;
+					break;
+				}
+
+				unsigned int ticksPerFull = 15;
+				anim->mNumPositionKeys = (unsigned int)(ticksPerFull * fps);
+				anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys];
+
+				for (unsigned int i = 0; i < anim->mNumPositionKeys; ++i) {
+					aiVectorKey &key = anim->mPositionKeys[i];
+
+					const ai_real dt = (i * in.speed * ai_real(0.001));
+					const ai_real u = dt - std::floor(dt);
+					const int idx = (int)std::floor(dt) % size;
+
+					// get the 4 current points to evaluate the spline
+					const aiVector3D &p0 = in.splineKeys[ClampSpline(idx - 1, size)].mValue;
+					const aiVector3D &p1 = in.splineKeys[ClampSpline(idx + 0, size)].mValue;
+					const aiVector3D &p2 = in.splineKeys[ClampSpline(idx + 1, size)].mValue;
+					const aiVector3D &p3 = in.splineKeys[ClampSpline(idx + 2, size)].mValue;
+
+					// compute polynomials
+					const ai_real u2 = u * u;
+					const ai_real u3 = u2 * 2;
+
+					const ai_real h1 = ai_real(2.0) * u3 - ai_real(3.0) * u2 + ai_real(1.0);
+					const ai_real h2 = ai_real(-2.0) * u3 + ai_real(3.0) * u3;
+					const ai_real h3 = u3 - ai_real(2.0) * u3;
+					const ai_real h4 = u3 - u2;
+
+					// compute the spline tangents
+					const aiVector3D t1 = (p2 - p0) * in.tightness;
+					aiVector3D t2 = (p3 - p1) * in.tightness;
+
+					// and use them to get the interpolated point
+					t2 = (h1 * p1 + p2 * h2 + t1 * h3 + h4 * t2);
+
+					// build a simple translation matrix from it
+					key.mValue = t2;
+					key.mTime = (double)i;
+				}
+			} break;
+			default:
+				// UNKNOWN , OTHER
+				break;
+		};
+		if (anim) {
+			anims.push_back(anim);
+			++total;
+		}
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+// This function is maybe more generic than we'd need it here
+void SetupMapping(aiMaterial *mat, aiTextureMapping mode, const aiVector3D &axis = aiVector3D(0.f, 0.f, -1.f)) {
+	if (nullptr == mat) {
+		return;
+	}
+
+    // Check whether there are texture properties defined - setup
+	// the desired texture mapping mode for all of them and ignore
+	// all UV settings we might encounter. WE HAVE NO UVS!
+
+	std::vector<aiMaterialProperty *> p;
+	p.reserve(mat->mNumProperties + 1);
+
+	for (unsigned int i = 0; i < mat->mNumProperties; ++i) {
+		aiMaterialProperty *prop = mat->mProperties[i];
+		if (!::strcmp(prop->mKey.data, "$tex.file")) {
+			// Setup the mapping key
+			aiMaterialProperty *m = new aiMaterialProperty();
+			m->mKey.Set("$tex.mapping");
+			m->mIndex = prop->mIndex;
+			m->mSemantic = prop->mSemantic;
+			m->mType = aiPTI_Integer;
+
+			m->mDataLength = 4;
+			m->mData = new char[4];
+			*((int *)m->mData) = mode;
+
+			p.push_back(prop);
+			p.push_back(m);
+
+			// Setup the mapping axis
+			if (mode == aiTextureMapping_CYLINDER || mode == aiTextureMapping_PLANE || mode == aiTextureMapping_SPHERE) {
+				m = new aiMaterialProperty();
+				m->mKey.Set("$tex.mapaxis");
+				m->mIndex = prop->mIndex;
+				m->mSemantic = prop->mSemantic;
+				m->mType = aiPTI_Float;
+
+				m->mDataLength = 12;
+				m->mData = new char[12];
+				*((aiVector3D *)m->mData) = axis;
+				p.push_back(m);
+			}
+		} else if (!::strcmp(prop->mKey.data, "$tex.uvwsrc")) {
+			delete mat->mProperties[i];
+		} else
+			p.push_back(prop);
+	}
+
+	if (p.empty()) return;
+
+	// rebuild the output array
+	if (p.size() > mat->mNumAllocated) {
+		delete[] mat->mProperties;
+		mat->mProperties = new aiMaterialProperty *[p.size() * 2];
+
+		mat->mNumAllocated = static_cast<unsigned int>(p.size() * 2);
+	}
+	mat->mNumProperties = (unsigned int)p.size();
+	::memcpy(mat->mProperties, &p[0], sizeof(void *) * mat->mNumProperties);
+}
+
+// ------------------------------------------------------------------------------------------------
+void IRRImporter::GenerateGraph(Node *root, aiNode *rootOut, aiScene *scene,
+		BatchLoader &batch,
+		std::vector<aiMesh *> &meshes,
+		std::vector<aiNodeAnim *> &anims,
+		std::vector<AttachmentInfo> &attach,
+		std::vector<aiMaterial *> &materials,
+		unsigned int &defMatIdx) {
+	unsigned int oldMeshSize = (unsigned int)meshes.size();
+	//unsigned int meshTrafoAssign = 0;
+
+	// Now determine the type of the node
+	switch (root->type) {
+		case Node::ANIMMESH:
+		case Node::MESH: {
+			if (!root->meshPath.length())
+				break;
+
+			// Get the loaded mesh from the scene and add it to
+			// the list of all scenes to be attached to the
+			// graph we're currently building
+			aiScene *localScene = batch.GetImport(root->id);
+			if (!localScene) {
+				ASSIMP_LOG_ERROR("IRR: Unable to load external file: ", root->meshPath);
+				break;
+			}
+			attach.push_back(AttachmentInfo(localScene, rootOut));
+
+			// Now combine the material we've loaded for this mesh
+			// with the real materials we got from the file. As we
+			// don't execute any pp-steps on the file, the numbers
+			// should be equal. If they are not, we can impossibly
+			// do this  ...
+			if (root->materials.size() != (unsigned int)localScene->mNumMaterials) {
+				ASSIMP_LOG_WARN("IRR: Failed to match imported materials "
+								"with the materials found in the IRR scene file");
+
+				break;
+			}
+			for (unsigned int i = 0; i < localScene->mNumMaterials; ++i) {
+				// Delete the old material, we don't need it anymore
+				delete localScene->mMaterials[i];
+
+				std::pair<aiMaterial *, unsigned int> &src = root->materials[i];
+				localScene->mMaterials[i] = src.first;
+			}
+
+			// NOTE: Each mesh should have exactly one material assigned,
+			// but we do it in a separate loop if this behavior changes
+			// in future.
+			for (unsigned int i = 0; i < localScene->mNumMeshes; ++i) {
+				// Process material flags
+				aiMesh *mesh = localScene->mMeshes[i];
+
+				// If "trans_vertex_alpha" mode is enabled, search all vertex colors
+				// and check whether they have a common alpha value. This is quite
+				// often the case so we can simply extract it to a shared oacity
+				// value.
+				std::pair<aiMaterial *, unsigned int> &src = root->materials[mesh->mMaterialIndex];
+				aiMaterial *mat = (aiMaterial *)src.first;
+
+				if (mesh->HasVertexColors(0) && src.second & AI_IRRMESH_MAT_trans_vertex_alpha) {
+					bool bdo = true;
+					for (unsigned int a = 1; a < mesh->mNumVertices; ++a) {
+
+						if (mesh->mColors[0][a].a != mesh->mColors[0][a - 1].a) {
+							bdo = false;
+							break;
+						}
+					}
+					if (bdo) {
+						ASSIMP_LOG_INFO("IRR: Replacing mesh vertex alpha with common opacity");
+
+						for (unsigned int a = 0; a < mesh->mNumVertices; ++a)
+							mesh->mColors[0][a].a = 1.f;
+
+						mat->AddProperty(&mesh->mColors[0][0].a, 1, AI_MATKEY_OPACITY);
+					}
+				}
+
+				// If we have a second texture coordinate set and a second texture
+				// (either light-map, normal-map, 2layered material) we need to
+				// setup the correct UV index for it. The texture can either
+				// be diffuse (light-map & 2layer) or a normal map (normal & parallax)
+				if (mesh->HasTextureCoords(1)) {
+
+					int idx = 1;
+					if (src.second & (AI_IRRMESH_MAT_solid_2layer | AI_IRRMESH_MAT_lightmap)) {
+						mat->AddProperty(&idx, 1, AI_MATKEY_UVWSRC_DIFFUSE(0));
+					} else if (src.second & AI_IRRMESH_MAT_normalmap_solid) {
+						mat->AddProperty(&idx, 1, AI_MATKEY_UVWSRC_NORMALS(0));
+					}
+				}
+			}
+		} break;
+
+		case Node::LIGHT:
+		case Node::CAMERA:
+
+			// We're already finished with lights and cameras
+			break;
+
+		case Node::SPHERE: {
+			// Generate the sphere model. Our input parameter to
+			// the sphere generation algorithm is the number of
+			// subdivisions of each triangle - but here we have
+			// the number of polygons on a specific axis. Just
+			// use some hard-coded limits to approximate this ...
+			unsigned int mul = root->spherePolyCountX * root->spherePolyCountY;
+			if (mul < 100)
+				mul = 2;
+			else if (mul < 300)
+				mul = 3;
+			else
+				mul = 4;
+
+			meshes.push_back(StandardShapes::MakeMesh(mul,
+					&StandardShapes::MakeSphere));
+
+			// Adjust scaling
+			root->scaling *= root->sphereRadius / 2;
+
+			// Copy one output material
+			CopyMaterial(materials, root->materials, defMatIdx, meshes.back());
+
+			// Now adjust this output material - if there is a first texture
+			// set, setup spherical UV mapping around the Y axis.
+			SetupMapping((aiMaterial *)materials.back(), aiTextureMapping_SPHERE);
+		} break;
+
+		case Node::CUBE: {
+			// Generate an unit cube first
+			meshes.push_back(StandardShapes::MakeMesh(
+					&StandardShapes::MakeHexahedron));
+
+			// Adjust scaling
+			root->scaling *= root->sphereRadius;
+
+			// Copy one output material
+			CopyMaterial(materials, root->materials, defMatIdx, meshes.back());
+
+			// Now adjust this output material - if there is a first texture
+			// set, setup cubic UV mapping
+			SetupMapping((aiMaterial *)materials.back(), aiTextureMapping_BOX);
+		} break;
+
+		case Node::SKYBOX: {
+			// A sky-box is defined by six materials
+			if (root->materials.size() < 6) {
+				ASSIMP_LOG_ERROR("IRR: There should be six materials for a skybox");
+				break;
+			}
+
+			// copy those materials and generate 6 meshes for our new sky-box
+			materials.reserve(materials.size() + 6);
+			for (unsigned int i = 0; i < 6; ++i)
+				materials.insert(materials.end(), root->materials[i].first);
+
+			BuildSkybox(meshes, materials);
+
+			// *************************************************************
+			// Skyboxes will require a different code path for rendering,
+			// so there must be a way for the user to add special support
+			// for IRR skyboxes. We add a 'IRR.SkyBox_' prefix to the node.
+			// *************************************************************
+			root->name = "IRR.SkyBox_" + root->name;
+			ASSIMP_LOG_INFO("IRR: Loading skybox, this will "
+							"require special handling to be displayed correctly");
+		} break;
+
+		case Node::TERRAIN: {
+			// to support terrains, we'd need to have a texture decoder
+			ASSIMP_LOG_ERROR("IRR: Unsupported node - TERRAIN");
+		} break;
+		default:
+			// DUMMY
+			break;
+	};
+
+	// Check whether we added a mesh (or more than one ...). In this case
+	// we'll also need to attach it to the node
+	if (oldMeshSize != (unsigned int)meshes.size()) {
+
+		rootOut->mNumMeshes = (unsigned int)meshes.size() - oldMeshSize;
+		rootOut->mMeshes = new unsigned int[rootOut->mNumMeshes];
+
+		for (unsigned int a = 0; a < rootOut->mNumMeshes; ++a) {
+			rootOut->mMeshes[a] = oldMeshSize + a;
+		}
+	}
+
+	// Setup the name of this node
+	rootOut->mName.Set(root->name);
+
+	// Now compute the final local transformation matrix of the
+	// node from the given translation, rotation and scaling values.
+	// (the rotation is given in Euler angles, XYZ order)
+	//std::swap((float&)root->rotation.z,(float&)root->rotation.y);
+	rootOut->mTransformation.FromEulerAnglesXYZ(AI_DEG_TO_RAD(root->rotation));
+
+	// apply scaling
+	aiMatrix4x4 &mat = rootOut->mTransformation;
+	mat.a1 *= root->scaling.x;
+	mat.b1 *= root->scaling.x;
+	mat.c1 *= root->scaling.x;
+	mat.a2 *= root->scaling.y;
+	mat.b2 *= root->scaling.y;
+	mat.c2 *= root->scaling.y;
+	mat.a3 *= root->scaling.z;
+	mat.b3 *= root->scaling.z;
+	mat.c3 *= root->scaling.z;
+
+	// apply translation
+	mat.a4 += root->position.x;
+	mat.b4 += root->position.y;
+	mat.c4 += root->position.z;
+
+	// now compute animations for the node
+	ComputeAnimations(root, rootOut, anims);
+
+	// Add all children recursively. First allocate enough storage
+	// for them, then call us again
+	rootOut->mNumChildren = (unsigned int)root->children.size();
+	if (rootOut->mNumChildren) {
+
+		rootOut->mChildren = new aiNode *[rootOut->mNumChildren];
+		for (unsigned int i = 0; i < rootOut->mNumChildren; ++i) {
+
+			aiNode *node = rootOut->mChildren[i] = new aiNode();
+			node->mParent = rootOut;
+			GenerateGraph(root->children[i], node, scene, batch, meshes,
+					anims, attach, materials, defMatIdx);
+		}
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+// Imports the given file into the given scene structure.
+void IRRImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
+	std::unique_ptr<IOStream> file(pIOHandler->Open(pFile));
+
+	// Check whether we can read from the file
+	if (file.get() == nullptr) {
+        throw DeadlyImportError("Failed to open IRR file ", pFile);
+	}
+
+	// Construct the irrXML parser
+	XmlParser st;
+    if (!st.parse( file.get() )) {
+        throw DeadlyImportError("XML parse error while loading IRR file ", pFile);
+    }
+    pugi::xml_node rootElement = st.getRootNode();
+
+	// The root node of the scene
+	Node *root = new Node(Node::DUMMY);
+	root->parent = nullptr;
+	root->name = "<IRRSceneRoot>";
+
+	// Current node parent
+	Node *curParent = root;
+
+	// Scene-graph node we're currently working on
+	Node *curNode = nullptr;
+
+	// List of output cameras
+	std::vector<aiCamera *> cameras;
+
+	// List of output lights
+	std::vector<aiLight *> lights;
+
+	// Batch loader used to load external models
+	BatchLoader batch(pIOHandler);
+	//  batch.SetBasePath(pFile);
+
+	cameras.reserve(5);
+	lights.reserve(5);
+
+	bool inMaterials = false, inAnimator = false;
+	unsigned int guessedAnimCnt = 0, guessedMeshCnt = 0, guessedMatCnt = 0;
+
+	// Parse the XML file
+
+	//while (reader->read())  {
+	for (pugi::xml_node child : rootElement.children())
+		switch (child.type()) {
+			case pugi::node_element:
+				if (!ASSIMP_stricmp(child.name(), "node")) {
+					// ***********************************************************************
+					/*  What we're going to do with the node depends
+                     *  on its type:
+                     *
+                     *  "mesh" - Load a mesh from an external file
+                     *  "cube" - Generate a cube
+                     *  "skybox" - Generate a skybox
+                     *  "light" - A light source
+                     *  "sphere" - Generate a sphere mesh
+                     *  "animatedMesh" - Load an animated mesh from an external file
+                     *    and join its animation channels with ours.
+                     *  "empty" - A dummy node
+                     *  "camera" - A camera
+                     *  "terrain" - a terrain node (data comes from a heightmap)
+                     *  "billboard", ""
+                     *
+                     *  Each of these nodes can be animated and all can have multiple
+                     *  materials assigned (except lights, cameras and dummies, of course).
+                     */
+					// ***********************************************************************
+					//const char *sz = reader->getAttributeValueSafe("type");
+					pugi::xml_attribute attrib = child.attribute("type");
+					Node *nd;
+					if (!ASSIMP_stricmp(attrib.name(), "mesh") || !ASSIMP_stricmp(attrib.name(), "octTree")) {
+						// OctTree's and meshes are treated equally
+						nd = new Node(Node::MESH);
+					} else if (!ASSIMP_stricmp(attrib.name(), "cube")) {
+						nd = new Node(Node::CUBE);
+						++guessedMeshCnt;
+					} else if (!ASSIMP_stricmp(attrib.name(), "skybox")) {
+						nd = new Node(Node::SKYBOX);
+						guessedMeshCnt += 6;
+					} else if (!ASSIMP_stricmp(attrib.name(), "camera")) {
+						nd = new Node(Node::CAMERA);
+
+						// Setup a temporary name for the camera
+						aiCamera *cam = new aiCamera();
+						cam->mName.Set(nd->name);
+						cameras.push_back(cam);
+					} else if (!ASSIMP_stricmp(attrib.name(), "light")) {
+						nd = new Node(Node::LIGHT);
+
+						// Setup a temporary name for the light
+						aiLight *cam = new aiLight();
+						cam->mName.Set(nd->name);
+						lights.push_back(cam);
+					} else if (!ASSIMP_stricmp(attrib.name(), "sphere")) {
+						nd = new Node(Node::SPHERE);
+						++guessedMeshCnt;
+					} else if (!ASSIMP_stricmp(attrib.name(), "animatedMesh")) {
+						nd = new Node(Node::ANIMMESH);
+					} else if (!ASSIMP_stricmp(attrib.name(), "empty")) {
+						nd = new Node(Node::DUMMY);
+					} else if (!ASSIMP_stricmp(attrib.name(), "terrain")) {
+						nd = new Node(Node::TERRAIN);
+					} else if (!ASSIMP_stricmp(attrib.name(), "billBoard")) {
+						// We don't support billboards, so ignore them
+						ASSIMP_LOG_ERROR("IRR: Billboards are not supported by Assimp");
+						nd = new Node(Node::DUMMY);
+					} else {
+						ASSIMP_LOG_WARN("IRR: Found unknown node: ", attrib.name());
+
+						/*  We skip the contents of nodes we don't know.
+                         *  We parse the transformation and all animators
+                         *  and skip the rest.
+                         */
+						nd = new Node(Node::DUMMY);
+					}
+
+					/* Attach the newly created node to the scene-graph
+                     */
+					curNode = nd;
+					nd->parent = curParent;
+					curParent->children.push_back(nd);
+				} else if (!ASSIMP_stricmp(child.name(), "materials")) {
+					inMaterials = true;
+				} else if (!ASSIMP_stricmp(child.name(), "animators")) {
+					inAnimator = true;
+				} else if (!ASSIMP_stricmp(child.name(), "attributes")) {
+					//  We should have a valid node here
+					//  FIX: no ... the scene root node is also contained in an attributes block
+					if (!curNode) {
+						continue;
+					}
+
+					Animator *curAnim = nullptr;
+
+					// Materials can occur for nearly any type of node
+					if (inMaterials && curNode->type != Node::DUMMY) {
+						//  This is a material description - parse it!
+						curNode->materials.push_back(std::pair<aiMaterial *, unsigned int>());
+						std::pair<aiMaterial *, unsigned int> &p = curNode->materials.back();
+
+						p.first = ParseMaterial(p.second);
+						++guessedMatCnt;
+						continue;
+					} else if (inAnimator) {
+						//  This is an animation path - add a new animator
+						//  to the list.
+						curNode->animators.push_back(Animator());
+						curAnim = &curNode->animators.back();
+
+						++guessedAnimCnt;
+					}
+
+					/*  Parse all elements in the attributes block
+                     *  and process them.
+                     */
+					//					while (reader->read()) {
+					for (pugi::xml_node attrib : child.children()) {
+						if (attrib.type() == pugi::node_element) {
+							//if (reader->getNodeType() == EXN_ELEMENT) {
+							//if (!ASSIMP_stricmp(reader->getNodeName(), "vector3d")) {
+							if (!ASSIMP_stricmp(attrib.name(), "vector3d")) {
+								VectorProperty prop;
+								ReadVectorProperty(prop);
+
+								if (inAnimator) {
+									if (curAnim->type == Animator::ROTATION && prop.name == "Rotation") {
+										// We store the rotation euler angles in 'direction'
+										curAnim->direction = prop.value;
+									} else if (curAnim->type == Animator::FOLLOW_SPLINE) {
+										// Check whether the vector follows the PointN naming scheme,
+										// here N is the ONE-based index of the point
+										if (prop.name.length() >= 6 && prop.name.substr(0, 5) == "Point") {
+											// Add a new key to the list
+											curAnim->splineKeys.push_back(aiVectorKey());
+											aiVectorKey &key = curAnim->splineKeys.back();
+
+											// and parse its properties
+											key.mValue = prop.value;
+											key.mTime = strtoul10(&prop.name[5]);
+										}
+									} else if (curAnim->type == Animator::FLY_CIRCLE) {
+										if (prop.name == "Center") {
+											curAnim->circleCenter = prop.value;
+										} else if (prop.name == "Direction") {
+											curAnim->direction = prop.value;
+
+											// From Irrlicht's source - a workaround for backward compatibility with Irrlicht 1.1
+											if (curAnim->direction == aiVector3D()) {
+												curAnim->direction = aiVector3D(0.f, 1.f, 0.f);
+											} else
+												curAnim->direction.Normalize();
+										}
+									} else if (curAnim->type == Animator::FLY_STRAIGHT) {
+										if (prop.name == "Start") {
+											// We reuse the field here
+											curAnim->circleCenter = prop.value;
+										} else if (prop.name == "End") {
+											// We reuse the field here
+											curAnim->direction = prop.value;
+										}
+									}
+								} else {
+									if (prop.name == "Position") {
+										curNode->position = prop.value;
+									} else if (prop.name == "Rotation") {
+										curNode->rotation = prop.value;
+									} else if (prop.name == "Scale") {
+										curNode->scaling = prop.value;
+									} else if (Node::CAMERA == curNode->type) {
+										aiCamera *cam = cameras.back();
+										if (prop.name == "Target") {
+											cam->mLookAt = prop.value;
+										} else if (prop.name == "UpVector") {
+											cam->mUp = prop.value;
+										}
+									}
+								}
+								//} else if (!ASSIMP_stricmp(reader->getNodeName(), "bool")) {
+							} else if (!ASSIMP_stricmp(attrib.name(), "bool")) {
+								BoolProperty prop;
+								ReadBoolProperty(prop);
+
+								if (inAnimator && curAnim->type == Animator::FLY_CIRCLE && prop.name == "Loop") {
+									curAnim->loop = prop.value;
+								}
+								//} else if (!ASSIMP_stricmp(reader->getNodeName(), "float")) {
+							} else if (!ASSIMP_stricmp(attrib.name(), "float")) {
+								FloatProperty prop;
+								ReadFloatProperty(prop);
+
+								if (inAnimator) {
+									// The speed property exists for several animators
+									if (prop.name == "Speed") {
+										curAnim->speed = prop.value;
+									} else if (curAnim->type == Animator::FLY_CIRCLE && prop.name == "Radius") {
+										curAnim->circleRadius = prop.value;
+									} else if (curAnim->type == Animator::FOLLOW_SPLINE && prop.name == "Tightness") {
+										curAnim->tightness = prop.value;
+									}
+								} else {
+									if (prop.name == "FramesPerSecond" && Node::ANIMMESH == curNode->type) {
+										curNode->framesPerSecond = prop.value;
+									} else if (Node::CAMERA == curNode->type) {
+										/*  This is the vertical, not the horizontal FOV.
+                                    *  We need to compute the right FOV from the
+                                    *  screen aspect which we don't know yet.
+                                    */
+										if (prop.name == "Fovy") {
+											cameras.back()->mHorizontalFOV = prop.value;
+										} else if (prop.name == "Aspect") {
+											cameras.back()->mAspect = prop.value;
+										} else if (prop.name == "ZNear") {
+											cameras.back()->mClipPlaneNear = prop.value;
+										} else if (prop.name == "ZFar") {
+											cameras.back()->mClipPlaneFar = prop.value;
+										}
+									} else if (Node::LIGHT == curNode->type) {
+										/*  Additional light information
+                                     */
+										if (prop.name == "Attenuation") {
+											lights.back()->mAttenuationLinear = prop.value;
+										} else if (prop.name == "OuterCone") {
+											lights.back()->mAngleOuterCone = AI_DEG_TO_RAD(prop.value);
+										} else if (prop.name == "InnerCone") {
+											lights.back()->mAngleInnerCone = AI_DEG_TO_RAD(prop.value);
+										}
+									}
+									// radius of the sphere to be generated -
+									// or alternatively, size of the cube
+									else if ((Node::SPHERE == curNode->type && prop.name == "Radius") || (Node::CUBE == curNode->type && prop.name == "Size")) {
+
+										curNode->sphereRadius = prop.value;
+									}
+								}
+								//} else if (!ASSIMP_stricmp(reader->getNodeName(), "int")) {
+							} else if (!ASSIMP_stricmp(attrib.name(), "int")) {
+								IntProperty prop;
+								ReadIntProperty(prop);
+
+								if (inAnimator) {
+									if (curAnim->type == Animator::FLY_STRAIGHT && prop.name == "TimeForWay") {
+										curAnim->timeForWay = prop.value;
+									}
+								} else {
+									// sphere polygon numbers in each direction
+									if (Node::SPHERE == curNode->type) {
+
+										if (prop.name == "PolyCountX") {
+											curNode->spherePolyCountX = prop.value;
+										} else if (prop.name == "PolyCountY") {
+											curNode->spherePolyCountY = prop.value;
+										}
+									}
+								}
+								//} else if (!ASSIMP_stricmp(reader->getNodeName(), "string") || !ASSIMP_stricmp(reader->getNodeName(), "enum")) {
+							} else if (!ASSIMP_stricmp(attrib.name(), "string") || !ASSIMP_stricmp(attrib.name(), "enum")) {
+								StringProperty prop;
+								ReadStringProperty(prop);
+								if (prop.value.length()) {
+									if (prop.name == "Name") {
+										curNode->name = prop.value;
+
+										/*  If we're either a camera or a light source
+                                     *  we need to update the name in the aiLight/
+                                     *  aiCamera structure, too.
+                                     */
+										if (Node::CAMERA == curNode->type) {
+											cameras.back()->mName.Set(prop.value);
+										} else if (Node::LIGHT == curNode->type) {
+											lights.back()->mName.Set(prop.value);
+										}
+									} else if (Node::LIGHT == curNode->type && "LightType" == prop.name) {
+										if (prop.value == "Spot")
+											lights.back()->mType = aiLightSource_SPOT;
+										else if (prop.value == "Point")
+											lights.back()->mType = aiLightSource_POINT;
+										else if (prop.value == "Directional")
+											lights.back()->mType = aiLightSource_DIRECTIONAL;
+										else {
+											// We won't pass the validation with aiLightSourceType_UNDEFINED,
+											// so we remove the light and replace it with a silly dummy node
+											delete lights.back();
+											lights.pop_back();
+											curNode->type = Node::DUMMY;
+
+											ASSIMP_LOG_ERROR("Ignoring light of unknown type: ", prop.value);
+										}
+									} else if ((prop.name == "Mesh" && Node::MESH == curNode->type) ||
+											   Node::ANIMMESH == curNode->type) {
+    								/*  This is the file name of the mesh - either
+                                     *  animated or not. We need to make sure we setup
+                                     *  the correct post-processing settings here.
+                                     */
+										unsigned int pp = 0;
+										BatchLoader::PropertyMap map;
+
+										/* If the mesh is a static one remove all animations from the impor data
+                                     */
+										if (Node::ANIMMESH != curNode->type) {
+											pp |= aiProcess_RemoveComponent;
+											SetGenericProperty<int>(map.ints, AI_CONFIG_PP_RVC_FLAGS,
+													aiComponent_ANIMATIONS | aiComponent_BONEWEIGHTS);
+										}
+
+										/*  TODO: maybe implement the protection against recursive
+                                        *  loading calls directly in BatchLoader? The current
+                                        *  implementation is not absolutely safe. A LWS and an IRR
+                                        *  file referencing each other *could* cause the system to
+                                        *  recurse forever.
+                                        */
+
+										const std::string extension = GetExtension(prop.value);
+										if ("irr" == extension) {
+											ASSIMP_LOG_ERROR("IRR: Can't load another IRR file recursively");
+										} else {
+											curNode->id = batch.AddLoadRequest(prop.value, pp, &map);
+											curNode->meshPath = prop.value;
+										}
+									} else if (inAnimator && prop.name == "Type") {
+										// type of the animator
+										if (prop.value == "rotation") {
+											curAnim->type = Animator::ROTATION;
+										} else if (prop.value == "flyCircle") {
+											curAnim->type = Animator::FLY_CIRCLE;
+										} else if (prop.value == "flyStraight") {
+											curAnim->type = Animator::FLY_CIRCLE;
+										} else if (prop.value == "followSpline") {
+											curAnim->type = Animator::FOLLOW_SPLINE;
+										} else {
+											ASSIMP_LOG_WARN("IRR: Ignoring unknown animator: ", prop.value);
+
+											curAnim->type = Animator::UNKNOWN;
+										}
+									}
+								}
+							}
+							//} else if (reader->getNodeType() == EXN_ELEMENT_END && !ASSIMP_stricmp(reader->getNodeName(), "attributes")) {
+						} else if (attrib.type() == pugi::node_null && !ASSIMP_stricmp(attrib.name(), "attributes")) {
+							break;
+						}
+					}
+				}
+				break;
+
+				/*case EXN_ELEMENT_END:
+
+				// If we reached the end of a node, we need to continue processing its parent
+				if (!ASSIMP_stricmp(reader->getNodeName(), "node")) {
+					if (!curNode) {
+						// currently is no node set. We need to go
+						// back in the node hierarchy
+						if (!curParent) {
+							curParent = root;
+							ASSIMP_LOG_ERROR("IRR: Too many closing <node> elements");
+						} else
+							curParent = curParent->parent;
+					} else
+						curNode = nullptr;
+				}
+				// clear all flags
+				else if (!ASSIMP_stricmp(reader->getNodeName(), "materials")) {
+					inMaterials = false;
+				} else if (!ASSIMP_stricmp(reader->getNodeName(), "animators")) {
+					inAnimator = false;
+				}
+				break;*/
+
+			default:
+				// GCC complains that not all enumeration values are handled
+				break;
+		}
+	//}
+
+	//  Now iterate through all cameras and compute their final (horizontal) FOV
+	for (aiCamera *cam : cameras) {
+		// screen aspect could be missing
+		if (cam->mAspect) {
+			cam->mHorizontalFOV *= cam->mAspect;
+		} else {
+			ASSIMP_LOG_WARN("IRR: Camera aspect is not given, can't compute horizontal FOV");
+		}
+	}
+
+	batch.LoadAll();
+
+	// Allocate a temporary scene data structure
+	aiScene *tempScene = new aiScene();
+	tempScene->mRootNode = new aiNode();
+	tempScene->mRootNode->mName.Set("<IRRRoot>");
+
+	// Copy the cameras to the output array
+	if (!cameras.empty()) {
+		tempScene->mNumCameras = (unsigned int)cameras.size();
+		tempScene->mCameras = new aiCamera *[tempScene->mNumCameras];
+		::memcpy(tempScene->mCameras, &cameras[0], sizeof(void *) * tempScene->mNumCameras);
+	}
+
+	// Copy the light sources to the output array
+	if (!lights.empty()) {
+		tempScene->mNumLights = (unsigned int)lights.size();
+		tempScene->mLights = new aiLight *[tempScene->mNumLights];
+		::memcpy(tempScene->mLights, &lights[0], sizeof(void *) * tempScene->mNumLights);
+	}
+
+	// temporary data
+	std::vector<aiNodeAnim *> anims;
+	std::vector<aiMaterial *> materials;
+	std::vector<AttachmentInfo> attach;
+	std::vector<aiMesh *> meshes;
+
+	// try to guess how much storage we'll need
+	anims.reserve(guessedAnimCnt + (guessedAnimCnt >> 2));
+	meshes.reserve(guessedMeshCnt + (guessedMeshCnt >> 2));
+	materials.reserve(guessedMatCnt + (guessedMatCnt >> 2));
+
+	// Now process our scene-graph recursively: generate final
+	// meshes and generate animation channels for all nodes.
+	unsigned int defMatIdx = UINT_MAX;
+	GenerateGraph(root, tempScene->mRootNode, tempScene,
+			batch, meshes, anims, attach, materials, defMatIdx);
+
+	if (!anims.empty()) {
+		tempScene->mNumAnimations = 1;
+		tempScene->mAnimations = new aiAnimation *[tempScene->mNumAnimations];
+		aiAnimation *an = tempScene->mAnimations[0] = new aiAnimation();
+
+		// ***********************************************************
+		// This is only the global animation channel of the scene.
+		// If there are animated models, they will have separate
+		// animation channels in the scene. To display IRR scenes
+		// correctly, users will need to combine the global anim
+		// channel with all the local animations they want to play
+		// ***********************************************************
+		an->mName.Set("Irr_GlobalAnimChannel");
+
+		// copy all node animation channels to the global channel
+		an->mNumChannels = (unsigned int)anims.size();
+		an->mChannels = new aiNodeAnim *[an->mNumChannels];
+		::memcpy(an->mChannels, &anims[0], sizeof(void *) * an->mNumChannels);
+	}
+	if (!meshes.empty()) {
+		// copy all meshes to the temporary scene
+		tempScene->mNumMeshes = (unsigned int)meshes.size();
+		tempScene->mMeshes = new aiMesh *[tempScene->mNumMeshes];
+		::memcpy(tempScene->mMeshes, &meshes[0], tempScene->mNumMeshes * sizeof(void *));
+	}
+
+	// Copy all materials to the output array
+	if (!materials.empty()) {
+		tempScene->mNumMaterials = (unsigned int)materials.size();
+		tempScene->mMaterials = new aiMaterial *[tempScene->mNumMaterials];
+		::memcpy(tempScene->mMaterials, &materials[0], sizeof(void *) * tempScene->mNumMaterials);
+	}
+
+	//  Now merge all sub scenes and attach them to the correct
+	//  attachment points in the scenegraph.
+	SceneCombiner::MergeScenes(&pScene, tempScene, attach,
+			AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES | (!configSpeedFlag ? (
+																			  AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY | AI_INT_MERGE_SCENE_GEN_UNIQUE_MATNAMES) :
+																	  0));
+
+	// If we have no meshes | no materials now set the INCOMPLETE
+	// scene flag. This is necessary if we failed to load all
+	// models from external files
+	if (!pScene->mNumMeshes || !pScene->mNumMaterials) {
+		ASSIMP_LOG_WARN("IRR: No meshes loaded, setting AI_SCENE_FLAGS_INCOMPLETE");
+		pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
+	}
+
+	// Finished ... everything destructs automatically and all
+	// temporary scenes have already been deleted by MergeScenes()
+	delete root;
+}
+
+#endif // !! ASSIMP_BUILD_NO_IRR_IMPORTER
diff --git a/Engine/lib/assimp/code/Irr/IRRLoader.h b/Engine/lib/assimp/code/AssetLib/Irr/IRRLoader.h
similarity index 90%
rename from Engine/lib/assimp/code/Irr/IRRLoader.h
rename to Engine/lib/assimp/code/AssetLib/Irr/IRRLoader.h
index b3ad81a7d..d56c4ca2d 100644
--- a/Engine/lib/assimp/code/Irr/IRRLoader.h
+++ b/Engine/lib/assimp/code/AssetLib/Irr/IRRLoader.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -40,7 +39,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
-
 /** @file IRRLoader.h
  *  @brief Declaration of the .irrMesh (Irrlight Engine Mesh Format)
  *  importer class.
@@ -48,7 +46,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_IRRLOADER_H_INCLUDED
 #define AI_IRRLOADER_H_INCLUDED
 
-#include "Irr/IRRShared.h"
+#include "AssetLib/Irr/IRRShared.h"
 #include "Common/Importer.h"
 
 #include <assimp/SceneCombiner.h>
@@ -67,23 +65,22 @@ namespace Assimp    {
 class IRRImporter : public BaseImporter, public IrrlichtBase {
 public:
     IRRImporter();
-    ~IRRImporter();
+    ~IRRImporter() override;
 
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
      *  See BaseImporter::CanRead() for details.
      */
     bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
+        bool checkSig) const override;
 
 protected:
-    const aiImporterDesc* GetInfo () const;
-    void InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler);
-    void SetupProperties(const Importer* pImp);
+    const aiImporterDesc* GetInfo () const override;
+    void InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) override;
+    void SetupProperties(const Importer* pImp) override;
 
 private:
-
-    /** Data structure for a scenegraph node animator
+    /** Data structure for a scene-graph node animator
      */
     struct Animator {
         // Type of the animator
@@ -129,7 +126,7 @@ private:
         int timeForWay;
     };
 
-    /** Data structure for a scenegraph node in an IRR file
+    /** Data structure for a scene-graph node in an IRR file
      */
     struct Node
     {
@@ -227,8 +224,7 @@ private:
 
 
     // -------------------------------------------------------------------
-    /** Fill the scenegraph recursively
-     */
+    /// Fill the scene-graph recursively
     void GenerateGraph(Node* root,aiNode* rootOut ,aiScene* scene,
         BatchLoader& batch,
         std::vector<aiMesh*>& meshes,
@@ -237,27 +233,22 @@ private:
         std::vector<aiMaterial*>& materials,
         unsigned int& defaultMatIdx);
 
-
     // -------------------------------------------------------------------
-    /** Generate a mesh that consists of just a single quad
-     */
+    /// Generate a mesh that consists of just a single quad
     aiMesh* BuildSingleQuadMesh(const SkyboxVertex& v1,
         const SkyboxVertex& v2,
         const SkyboxVertex& v3,
         const SkyboxVertex& v4);
 
-
     // -------------------------------------------------------------------
-    /** Build a skybox
-     *
-     *  @param meshes Receives 6 output meshes
-     *  @param materials The last 6 materials are assigned to the newly
-     *    created meshes. The names of the materials are adjusted.
-     */
+    /// Build a sky-box
+    ///
+    /// @param meshes Receives 6 output meshes
+    /// @param materials The last 6 materials are assigned to the newly
+    ///                  created meshes. The names of the materials are adjusted.
     void BuildSkybox(std::vector<aiMesh*>& meshes,
         std::vector<aiMaterial*> materials);
 
-
     // -------------------------------------------------------------------
     /** Copy a material for a mesh to the output material list
      *
@@ -271,7 +262,6 @@ private:
         unsigned int& defMatIdx,
         aiMesh* mesh);
 
-
     // -------------------------------------------------------------------
     /** Compute animations for a specific node
      *
@@ -281,13 +271,11 @@ private:
     void ComputeAnimations(Node* root, aiNode* real,
         std::vector<aiNodeAnim*>& anims);
 
-
 private:
-
-    /** Configuration option: desired output FPS */
+    /// Configuration option: desired output FPS
     double fps;
 
-    /** Configuration option: speed flag was set? */
+    /// Configuration option: speed flag was set?
     bool configSpeedFlag;
 };
 
diff --git a/Engine/lib/assimp/code/AssetLib/Irr/IRRMeshLoader.cpp b/Engine/lib/assimp/code/AssetLib/Irr/IRRMeshLoader.cpp
new file mode 100644
index 000000000..90b4d85af
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Irr/IRRMeshLoader.cpp
@@ -0,0 +1,502 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file Implementation of the IrrMesh importer class */
+
+#ifndef ASSIMP_BUILD_NO_IRRMESH_IMPORTER
+
+#include "IRRMeshLoader.h"
+#include <assimp/ParsingUtils.h>
+#include <assimp/fast_atof.h>
+#include <assimp/importerdesc.h>
+#include <assimp/material.h>
+#include <assimp/mesh.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOSystem.hpp>
+#include <memory>
+
+using namespace Assimp;
+
+static const aiImporterDesc desc = {
+	"Irrlicht Mesh Reader",
+	"",
+	"",
+	"http://irrlicht.sourceforge.net/",
+	aiImporterFlags_SupportTextFlavour,
+	0,
+	0,
+	0,
+	0,
+	"xml irrmesh"
+};
+
+// ------------------------------------------------------------------------------------------------
+// Constructor to be privately used by Importer
+IRRMeshImporter::IRRMeshImporter() :
+        BaseImporter(),
+        IrrlichtBase() {
+    // empty
+}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor, private as well
+IRRMeshImporter::~IRRMeshImporter() {}
+
+// ------------------------------------------------------------------------------------------------
+// Returns whether the class can handle the format of the given file.
+bool IRRMeshImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
+	/* NOTE: A simple check for the file extension is not enough
+	 * here. Irrmesh and irr are easy, but xml is too generic
+	 * and could be collada, too. So we need to open the file and
+	 * search for typical tokens.
+	 */
+	static const char *tokens[] = { "irrmesh" };
+	return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
+}
+
+// ------------------------------------------------------------------------------------------------
+// Get a list of all file extensions which are handled by this class
+const aiImporterDesc *IRRMeshImporter::GetInfo() const {
+	return &desc;
+}
+
+static void releaseMaterial(aiMaterial **mat) {
+	if (*mat != nullptr) {
+		delete *mat;
+		*mat = nullptr;
+	}
+}
+
+static void releaseMesh(aiMesh **mesh) {
+	if (*mesh != nullptr) {
+		delete *mesh;
+		*mesh = nullptr;
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+// Imports the given file into the given scene structure.
+void IRRMeshImporter::InternReadFile(const std::string &pFile,
+		aiScene *pScene, IOSystem *pIOHandler) {
+	std::unique_ptr<IOStream> file(pIOHandler->Open(pFile));
+
+	// Check whether we can read from the file
+	if (file.get() == NULL)
+        throw DeadlyImportError("Failed to open IRRMESH file ", pFile);
+
+	// Construct the irrXML parser
+	XmlParser parser;
+    if (!parser.parse( file.get() )) {
+        throw DeadlyImportError("XML parse error while loading IRRMESH file ", pFile);
+    }
+    XmlNode root = parser.getRootNode();
+
+	// final data
+	std::vector<aiMaterial *> materials;
+	std::vector<aiMesh *> meshes;
+	materials.reserve(5);
+	meshes.reserve(5);
+
+	// temporary data - current mesh buffer
+	aiMaterial *curMat = nullptr;
+	aiMesh *curMesh = nullptr;
+	unsigned int curMatFlags = 0;
+
+	std::vector<aiVector3D> curVertices, curNormals, curTangents, curBitangents;
+	std::vector<aiColor4D> curColors;
+	std::vector<aiVector3D> curUVs, curUV2s;
+
+	// some temporary variables
+	int textMeaning = 0;
+	int vertexFormat = 0; // 0 = normal; 1 = 2 tcoords, 2 = tangents
+	bool useColors = false;
+
+	// Parse the XML file
+	for (pugi::xml_node child : root.children()) {
+		if (child.type() == pugi::node_element) {
+			if (!ASSIMP_stricmp(child.name(), "buffer") && (curMat || curMesh)) {
+				// end of previous buffer. A material and a mesh should be there
+				if (!curMat || !curMesh) {
+					ASSIMP_LOG_ERROR("IRRMESH: A buffer must contain a mesh and a material");
+					releaseMaterial(&curMat);
+					releaseMesh(&curMesh);
+				} else {
+					materials.push_back(curMat);
+					meshes.push_back(curMesh);
+				}
+				curMat = nullptr;
+				curMesh = nullptr;
+
+				curVertices.clear();
+				curColors.clear();
+				curNormals.clear();
+				curUV2s.clear();
+				curUVs.clear();
+				curTangents.clear();
+				curBitangents.clear();
+			}
+
+			if (!ASSIMP_stricmp(child.name(), "material")) {
+				if (curMat) {
+					ASSIMP_LOG_WARN("IRRMESH: Only one material description per buffer, please");
+					releaseMaterial(&curMat);
+				}
+				curMat = ParseMaterial(curMatFlags);
+			}
+			/* no else here! */ if (!ASSIMP_stricmp(child.name(), "vertices")) {
+				pugi::xml_attribute attr = child.attribute("vertexCount");
+				int num = attr.as_int();
+                //int num = reader->getAttributeValueAsInt("vertexCount");
+
+				if (!num) {
+					// This is possible ... remove the mesh from the list and skip further reading
+					ASSIMP_LOG_WARN("IRRMESH: Found mesh with zero vertices");
+
+					releaseMaterial(&curMat);
+					releaseMesh(&curMesh);
+					textMeaning = 0;
+					continue;
+				}
+
+				curVertices.reserve(num);
+				curNormals.reserve(num);
+				curColors.reserve(num);
+				curUVs.reserve(num);
+
+				// Determine the file format
+				//const char *t = reader->getAttributeValueSafe("type");
+                pugi::xml_attribute t = child.attribute("type");
+				if (!ASSIMP_stricmp("2tcoords", t.name())) {
+					curUV2s.reserve(num);
+					vertexFormat = 1;
+
+					if (curMatFlags & AI_IRRMESH_EXTRA_2ND_TEXTURE) {
+						// *********************************************************
+						// We have a second texture! So use this UV channel
+						// for it. The 2nd texture can be either a normal
+						// texture (solid_2layer or lightmap_xxx) or a normal
+						// map (normal_..., parallax_...)
+						// *********************************************************
+						int idx = 1;
+						aiMaterial *mat = (aiMaterial *)curMat;
+
+						if (curMatFlags & AI_IRRMESH_MAT_lightmap) {
+							mat->AddProperty(&idx, 1, AI_MATKEY_UVWSRC_LIGHTMAP(0));
+						} else if (curMatFlags & AI_IRRMESH_MAT_normalmap_solid) {
+							mat->AddProperty(&idx, 1, AI_MATKEY_UVWSRC_NORMALS(0));
+						} else if (curMatFlags & AI_IRRMESH_MAT_solid_2layer) {
+							mat->AddProperty(&idx, 1, AI_MATKEY_UVWSRC_DIFFUSE(1));
+						}
+					}
+				} else if (!ASSIMP_stricmp("tangents", t.name())) {
+					curTangents.reserve(num);
+					curBitangents.reserve(num);
+					vertexFormat = 2;
+				} else if (ASSIMP_stricmp("standard", t.name())) {
+					releaseMaterial(&curMat);
+					ASSIMP_LOG_WARN("IRRMESH: Unknown vertex format");
+				} else
+					vertexFormat = 0;
+				textMeaning = 1;
+			} else if (!ASSIMP_stricmp(child.name(), "indices")) {
+				if (curVertices.empty() && curMat) {
+					releaseMaterial(&curMat);
+					throw DeadlyImportError("IRRMESH: indices must come after vertices");
+				}
+
+				textMeaning = 2;
+
+				// start a new mesh
+				curMesh = new aiMesh();
+
+				// allocate storage for all faces
+				pugi::xml_attribute attr = child.attribute("indexCount");
+				curMesh->mNumVertices = attr.as_int();
+				if (!curMesh->mNumVertices) {
+					// This is possible ... remove the mesh from the list and skip further reading
+					ASSIMP_LOG_WARN("IRRMESH: Found mesh with zero indices");
+
+					// mesh - away
+					releaseMesh(&curMesh);
+
+					// material - away
+					releaseMaterial(&curMat);
+
+					textMeaning = 0;
+					continue;
+				}
+
+				if (curMesh->mNumVertices % 3) {
+					ASSIMP_LOG_WARN("IRRMESH: Number if indices isn't divisible by 3");
+				}
+
+				curMesh->mNumFaces = curMesh->mNumVertices / 3;
+				curMesh->mFaces = new aiFace[curMesh->mNumFaces];
+
+				// setup some members
+				curMesh->mMaterialIndex = (unsigned int)materials.size();
+				curMesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
+
+				// allocate storage for all vertices
+				curMesh->mVertices = new aiVector3D[curMesh->mNumVertices];
+
+				if (curNormals.size() == curVertices.size()) {
+					curMesh->mNormals = new aiVector3D[curMesh->mNumVertices];
+				}
+				if (curTangents.size() == curVertices.size()) {
+					curMesh->mTangents = new aiVector3D[curMesh->mNumVertices];
+				}
+				if (curBitangents.size() == curVertices.size()) {
+					curMesh->mBitangents = new aiVector3D[curMesh->mNumVertices];
+				}
+				if (curColors.size() == curVertices.size() && useColors) {
+					curMesh->mColors[0] = new aiColor4D[curMesh->mNumVertices];
+				}
+				if (curUVs.size() == curVertices.size()) {
+					curMesh->mTextureCoords[0] = new aiVector3D[curMesh->mNumVertices];
+				}
+				if (curUV2s.size() == curVertices.size()) {
+					curMesh->mTextureCoords[1] = new aiVector3D[curMesh->mNumVertices];
+				}
+			}
+			//break;
+
+			//case EXN_TEXT: {
+			const char *sz = child.child_value();
+			if (textMeaning == 1) {
+				textMeaning = 0;
+
+				// read vertices
+				do {
+					SkipSpacesAndLineEnd(&sz);
+					aiVector3D temp;
+					aiColor4D c;
+
+					// Read the vertex position
+					sz = fast_atoreal_move<float>(sz, (float &)temp.x);
+					SkipSpaces(&sz);
+
+					sz = fast_atoreal_move<float>(sz, (float &)temp.y);
+					SkipSpaces(&sz);
+
+					sz = fast_atoreal_move<float>(sz, (float &)temp.z);
+					SkipSpaces(&sz);
+					curVertices.push_back(temp);
+
+					// Read the vertex normals
+					sz = fast_atoreal_move<float>(sz, (float &)temp.x);
+					SkipSpaces(&sz);
+
+					sz = fast_atoreal_move<float>(sz, (float &)temp.y);
+					SkipSpaces(&sz);
+
+					sz = fast_atoreal_move<float>(sz, (float &)temp.z);
+					SkipSpaces(&sz);
+					curNormals.push_back(temp);
+
+					// read the vertex colors
+					uint32_t clr = strtoul16(sz, &sz);
+					ColorFromARGBPacked(clr, c);
+
+					if (!curColors.empty() && c != *(curColors.end() - 1))
+						useColors = true;
+
+					curColors.push_back(c);
+					SkipSpaces(&sz);
+
+					// read the first UV coordinate set
+					sz = fast_atoreal_move<float>(sz, (float &)temp.x);
+					SkipSpaces(&sz);
+
+					sz = fast_atoreal_move<float>(sz, (float &)temp.y);
+					SkipSpaces(&sz);
+					temp.z = 0.f;
+					temp.y = 1.f - temp.y; // DX to OGL
+					curUVs.push_back(temp);
+
+					// read the (optional) second UV coordinate set
+					if (vertexFormat == 1) {
+						sz = fast_atoreal_move<float>(sz, (float &)temp.x);
+						SkipSpaces(&sz);
+
+						sz = fast_atoreal_move<float>(sz, (float &)temp.y);
+						temp.y = 1.f - temp.y; // DX to OGL
+						curUV2s.push_back(temp);
+					}
+					// read optional tangent and bitangent vectors
+					else if (vertexFormat == 2) {
+						// tangents
+						sz = fast_atoreal_move<float>(sz, (float &)temp.x);
+						SkipSpaces(&sz);
+
+						sz = fast_atoreal_move<float>(sz, (float &)temp.z);
+						SkipSpaces(&sz);
+
+						sz = fast_atoreal_move<float>(sz, (float &)temp.y);
+						SkipSpaces(&sz);
+						temp.y *= -1.0f;
+						curTangents.push_back(temp);
+
+						// bitangents
+						sz = fast_atoreal_move<float>(sz, (float &)temp.x);
+						SkipSpaces(&sz);
+
+						sz = fast_atoreal_move<float>(sz, (float &)temp.z);
+						SkipSpaces(&sz);
+
+						sz = fast_atoreal_move<float>(sz, (float &)temp.y);
+						SkipSpaces(&sz);
+						temp.y *= -1.0f;
+						curBitangents.push_back(temp);
+					}
+				}
+
+				/* IMPORTANT: We assume that each vertex is specified in one
+                line. So we can skip the rest of the line - unknown vertex
+                elements are ignored.
+                */
+
+				while (SkipLine(&sz));
+			} else if (textMeaning == 2) {
+				textMeaning = 0;
+
+				// read indices
+				aiFace *curFace = curMesh->mFaces;
+				aiFace *const faceEnd = curMesh->mFaces + curMesh->mNumFaces;
+
+				aiVector3D *pcV = curMesh->mVertices;
+				aiVector3D *pcN = curMesh->mNormals;
+				aiVector3D *pcT = curMesh->mTangents;
+				aiVector3D *pcB = curMesh->mBitangents;
+				aiColor4D *pcC0 = curMesh->mColors[0];
+				aiVector3D *pcT0 = curMesh->mTextureCoords[0];
+				aiVector3D *pcT1 = curMesh->mTextureCoords[1];
+
+				unsigned int curIdx = 0;
+				unsigned int total = 0;
+				while (SkipSpacesAndLineEnd(&sz)) {
+					if (curFace >= faceEnd) {
+						ASSIMP_LOG_ERROR("IRRMESH: Too many indices");
+						break;
+					}
+					if (!curIdx) {
+						curFace->mNumIndices = 3;
+						curFace->mIndices = new unsigned int[3];
+					}
+
+					unsigned int idx = strtoul10(sz, &sz);
+					if (idx >= curVertices.size()) {
+						ASSIMP_LOG_ERROR("IRRMESH: Index out of range");
+						idx = 0;
+					}
+
+					curFace->mIndices[curIdx] = total++;
+
+					*pcV++ = curVertices[idx];
+					if (pcN) *pcN++ = curNormals[idx];
+					if (pcT) *pcT++ = curTangents[idx];
+					if (pcB) *pcB++ = curBitangents[idx];
+					if (pcC0) *pcC0++ = curColors[idx];
+					if (pcT0) *pcT0++ = curUVs[idx];
+					if (pcT1) *pcT1++ = curUV2s[idx];
+
+					if (++curIdx == 3) {
+						++curFace;
+						curIdx = 0;
+					}
+				}
+
+				if (curFace != faceEnd)
+					ASSIMP_LOG_ERROR("IRRMESH: Not enough indices");
+
+				// Finish processing the mesh - do some small material workarounds
+				if (curMatFlags & AI_IRRMESH_MAT_trans_vertex_alpha && !useColors) {
+					// Take the opacity value of the current material
+					// from the common vertex color alpha
+					aiMaterial *mat = (aiMaterial *)curMat;
+					mat->AddProperty(&curColors[0].a, 1, AI_MATKEY_OPACITY);
+				}
+			}
+		}
+	}
+
+	// End of the last buffer. A material and a mesh should be there
+	if (curMat || curMesh) {
+		if (!curMat || !curMesh) {
+			ASSIMP_LOG_ERROR("IRRMESH: A buffer must contain a mesh and a material");
+			releaseMaterial(&curMat);
+			releaseMesh(&curMesh);
+		} else {
+			materials.push_back(curMat);
+			meshes.push_back(curMesh);
+		}
+	}
+
+	if (materials.empty()) {
+		throw DeadlyImportError("IRRMESH: Unable to read a mesh from this file");
+	}
+
+	// now generate the output scene
+	pScene->mNumMeshes = (unsigned int)meshes.size();
+	pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
+	for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
+		pScene->mMeshes[i] = meshes[i];
+
+		// clean this value ...
+		pScene->mMeshes[i]->mNumUVComponents[3] = 0;
+	}
+
+	pScene->mNumMaterials = (unsigned int)materials.size();
+	pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials];
+	::memcpy(pScene->mMaterials, &materials[0], sizeof(void *) * pScene->mNumMaterials);
+
+	pScene->mRootNode = new aiNode();
+	pScene->mRootNode->mName.Set("<IRRMesh>");
+	pScene->mRootNode->mNumMeshes = pScene->mNumMeshes;
+	pScene->mRootNode->mMeshes = new unsigned int[pScene->mNumMeshes];
+
+	for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
+		pScene->mRootNode->mMeshes[i] = i;
+	}
+}
+
+#endif // !! ASSIMP_BUILD_NO_IRRMESH_IMPORTER
diff --git a/Engine/lib/assimp/code/Irr/IRRMeshLoader.h b/Engine/lib/assimp/code/AssetLib/Irr/IRRMeshLoader.h
similarity index 89%
rename from Engine/lib/assimp/code/Irr/IRRMeshLoader.h
rename to Engine/lib/assimp/code/AssetLib/Irr/IRRMeshLoader.h
index d8b42d78d..79c1e486b 100644
--- a/Engine/lib/assimp/code/Irr/IRRMeshLoader.h
+++ b/Engine/lib/assimp/code/AssetLib/Irr/IRRMeshLoader.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -47,12 +46,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_IRRMESHLOADER_H_INCLUDED
 #define AI_IRRMESHLOADER_H_INCLUDED
 
-#include <assimp/BaseImporter.h>
 #include "IRRShared.h"
+#include <assimp/BaseImporter.h>
 
 #ifndef ASSIMP_BUILD_NO_IRRMESH_IMPORTER
 
-namespace Assimp    {
+namespace Assimp {
 
 // ---------------------------------------------------------------------------
 /** IrrMesh importer class.
@@ -61,37 +60,31 @@ namespace Assimp    {
  * irrEdit. As IrrEdit itself is capable of importing quite many file formats,
  * it might be a good file format for data exchange.
  */
-class IRRMeshImporter : public BaseImporter, public IrrlichtBase
-{
+class IRRMeshImporter : public BaseImporter, public IrrlichtBase {
 public:
     IRRMeshImporter();
-    ~IRRMeshImporter();
-
-
-public:
+    ~IRRMeshImporter() override;
 
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
      *  See BaseImporter::CanRead() for details.
      */
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
+            bool checkSig) const override;
 
 protected:
-
     // -------------------------------------------------------------------
     /** Return importer meta information.
      * See #BaseImporter::GetInfo for the details
      */
-    const aiImporterDesc* GetInfo () const;
+    const aiImporterDesc *GetInfo() const override;
 
     // -------------------------------------------------------------------
     /** Imports the given file into the given scene structure.
      * See BaseImporter::InternReadFile() for details
      */
-    void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
-
+    void InternReadFile(const std::string &pFile, aiScene *pScene,
+            IOSystem *pIOHandler) override;
 };
 
 } // end of namespace Assimp
diff --git a/Engine/lib/assimp/code/AssetLib/Irr/IRRShared.cpp b/Engine/lib/assimp/code/AssetLib/Irr/IRRShared.cpp
new file mode 100644
index 000000000..8763b63ae
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Irr/IRRShared.cpp
@@ -0,0 +1,387 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file  IRRShared.cpp
+ *  @brief Shared utilities for the IRR and IRRMESH loaders
+ */
+
+//This section should be excluded only if both the Irrlicht AND the Irrlicht Mesh importers were omitted.
+#if !(defined(ASSIMP_BUILD_NO_IRR_IMPORTER) && defined(ASSIMP_BUILD_NO_IRRMESH_IMPORTER))
+
+#include "IRRShared.h"
+#include <assimp/ParsingUtils.h>
+#include <assimp/fast_atof.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/material.h>
+
+using namespace Assimp;
+
+// Transformation matrix to convert from Assimp to IRR space
+const aiMatrix4x4 Assimp::AI_TO_IRR_MATRIX = aiMatrix4x4 (
+    1.0f, 0.0f, 0.0f, 0.0f,
+    0.0f, 0.0f, 1.0f, 0.0f,
+    0.0f, 1.0f, 0.0f, 0.0f,
+    0.0f, 0.0f, 0.0f, 1.0f);
+
+// ------------------------------------------------------------------------------------------------
+// read a property in hexadecimal format (i.e. ffffffff)
+void IrrlichtBase::ReadHexProperty(HexProperty &out ) {
+	for (pugi::xml_attribute attrib : mNode->attributes()) {
+        if (!ASSIMP_stricmp(attrib.name(), "name")) {
+            out.name = std::string( attrib.value() );
+        } else if (!ASSIMP_stricmp(attrib.name(),"value")) {
+            // parse the hexadecimal value
+			out.value = strtoul16(attrib.name());
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// read a decimal property
+void IrrlichtBase::ReadIntProperty(IntProperty & out) {
+	for (pugi::xml_attribute attrib : mNode->attributes()) {
+		if (!ASSIMP_stricmp(attrib.name(), "name")) {
+			out.name = std::string(attrib.value());
+        } else if (!ASSIMP_stricmp(attrib.value(),"value")) {
+            // parse the int value
+			out.value = strtol10(attrib.name());
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// read a string property
+void IrrlichtBase::ReadStringProperty( StringProperty& out) {
+	for (pugi::xml_attribute attrib : mNode->attributes()) {
+		if (!ASSIMP_stricmp(attrib.name(), "name")) {
+			out.name = std::string(attrib.value());
+		} else if (!ASSIMP_stricmp(attrib.name(), "value")) {
+            // simple copy the string
+			out.value = std::string(attrib.value());
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// read a boolean property
+void IrrlichtBase::ReadBoolProperty(BoolProperty &out) {
+	for (pugi::xml_attribute attrib : mNode->attributes()) {
+		if (!ASSIMP_stricmp(attrib.name(), "name")){
+			out.name = std::string(attrib.value());
+		} else if (!ASSIMP_stricmp(attrib.name(), "value")) {
+            // true or false, case insensitive
+			out.value = (ASSIMP_stricmp(attrib.value(), "true") ? false : true);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// read a float property
+void IrrlichtBase::ReadFloatProperty(FloatProperty &out) {
+	for (pugi::xml_attribute attrib : mNode->attributes()) {
+		if (!ASSIMP_stricmp(attrib.name(), "name")) {
+			out.name = std::string(attrib.value());
+		} else if (!ASSIMP_stricmp(attrib.name(), "value")) {
+            // just parse the float
+			out.value = fast_atof(attrib.value());
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// read a vector property
+void IrrlichtBase::ReadVectorProperty( VectorProperty &out ) {
+	for (pugi::xml_attribute attrib : mNode->attributes()) {
+		if (!ASSIMP_stricmp(attrib.name(), "name")) {
+			out.name = std::string(attrib.value());
+		} else if (!ASSIMP_stricmp(attrib.name(), "value")) {
+            // three floats, separated with commas
+            const char *ptr = attrib.value();
+
+            SkipSpaces(&ptr);
+            ptr = fast_atoreal_move<float>( ptr,(float&)out.value.x );
+            SkipSpaces(&ptr);
+            if (',' != *ptr) {
+                ASSIMP_LOG_ERROR("IRR(MESH): Expected comma in vector definition");
+			} else {
+				SkipSpaces(ptr + 1, &ptr);
+			}
+            ptr = fast_atoreal_move<float>( ptr,(float&)out.value.y );
+            SkipSpaces(&ptr);
+            if (',' != *ptr) {
+                ASSIMP_LOG_ERROR("IRR(MESH): Expected comma in vector definition");
+			} else {
+				SkipSpaces(ptr + 1, &ptr);
+			}
+            ptr = fast_atoreal_move<float>( ptr,(float&)out.value.z );
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Convert a string to a proper aiMappingMode
+int ConvertMappingMode(const std::string& mode) {
+    if (mode == "texture_clamp_repeat") {
+        return aiTextureMapMode_Wrap;
+	} else if (mode == "texture_clamp_mirror") {
+		return aiTextureMapMode_Mirror;
+	}
+
+    return aiTextureMapMode_Clamp;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Parse a material from the XML file
+aiMaterial* IrrlichtBase::ParseMaterial(unsigned int& matFlags) {
+    aiMaterial* mat = new aiMaterial();
+    aiColor4D clr;
+    aiString s;
+
+    matFlags = 0; // zero output flags
+    int cnt  = 0; // number of used texture channels
+    unsigned int nd = 0;
+
+    for (pugi::xml_node child : mNode->children()) {
+		if (!ASSIMP_stricmp(child.name(), "color")) { // Hex properties
+			HexProperty prop;
+			ReadHexProperty(prop);
+			if (prop.name == "Diffuse") {
+				ColorFromARGBPacked(prop.value, clr);
+				mat->AddProperty(&clr, 1, AI_MATKEY_COLOR_DIFFUSE);
+			} else if (prop.name == "Ambient") {
+				ColorFromARGBPacked(prop.value, clr);
+				mat->AddProperty(&clr, 1, AI_MATKEY_COLOR_AMBIENT);
+			} else if (prop.name == "Specular") {
+				ColorFromARGBPacked(prop.value, clr);
+				mat->AddProperty(&clr, 1, AI_MATKEY_COLOR_SPECULAR);
+			}
+
+			// NOTE: The 'emissive' property causes problems. It is
+			// often != 0, even if there is obviously no light
+			// emitted by the described surface. In fact I think
+			// IRRLICHT ignores this property, too.
+#if 0
+            else if (prop.name == "Emissive") {
+                ColorFromARGBPacked(prop.value,clr);
+                mat->AddProperty(&clr,1,AI_MATKEY_COLOR_EMISSIVE);
+            }
+#endif
+		} else if (!ASSIMP_stricmp(child.name(), "float")) { // Float properties
+			FloatProperty prop;
+			ReadFloatProperty(prop);
+			if (prop.name == "Shininess") {
+				mat->AddProperty(&prop.value, 1, AI_MATKEY_SHININESS);
+			}
+		} else if (!ASSIMP_stricmp(child.name(), "bool")) { // Bool properties
+			BoolProperty prop;
+			ReadBoolProperty(prop);
+			if (prop.name == "Wireframe") {
+				int val = (prop.value ? true : false);
+				mat->AddProperty(&val, 1, AI_MATKEY_ENABLE_WIREFRAME);
+			} else if (prop.name == "GouraudShading") {
+				int val = (prop.value ? aiShadingMode_Gouraud : aiShadingMode_NoShading);
+				mat->AddProperty(&val, 1, AI_MATKEY_SHADING_MODEL);
+			} else if (prop.name == "BackfaceCulling") {
+				int val = (!prop.value);
+				mat->AddProperty(&val, 1, AI_MATKEY_TWOSIDED);
+			}
+		} else if (!ASSIMP_stricmp(child.name(), "texture") ||
+				   !ASSIMP_stricmp(child.name(), "enum")) { // String properties - textures and texture related properties
+			StringProperty prop;
+			ReadStringProperty(prop);
+			if (prop.value.length()) {
+				// material type (shader)
+				if (prop.name == "Type") {
+					if (prop.value == "solid") {
+						// default material ...
+					} else if (prop.value == "trans_vertex_alpha") {
+						matFlags = AI_IRRMESH_MAT_trans_vertex_alpha;
+					} else if (prop.value == "lightmap") {
+						matFlags = AI_IRRMESH_MAT_lightmap;
+					} else if (prop.value == "solid_2layer") {
+						matFlags = AI_IRRMESH_MAT_solid_2layer;
+					} else if (prop.value == "lightmap_m2") {
+						matFlags = AI_IRRMESH_MAT_lightmap_m2;
+					} else if (prop.value == "lightmap_m4") {
+						matFlags = AI_IRRMESH_MAT_lightmap_m4;
+					} else if (prop.value == "lightmap_light") {
+						matFlags = AI_IRRMESH_MAT_lightmap_light;
+					} else if (prop.value == "lightmap_light_m2") {
+						matFlags = AI_IRRMESH_MAT_lightmap_light_m2;
+					} else if (prop.value == "lightmap_light_m4") {
+						matFlags = AI_IRRMESH_MAT_lightmap_light_m4;
+					} else if (prop.value == "lightmap_add") {
+						matFlags = AI_IRRMESH_MAT_lightmap_add;
+					} else if (prop.value == "normalmap_solid" ||
+							   prop.value == "parallaxmap_solid") { // Normal and parallax maps are treated equally
+						matFlags = AI_IRRMESH_MAT_normalmap_solid;
+					} else if (prop.value == "normalmap_trans_vertex_alpha" ||
+							   prop.value == "parallaxmap_trans_vertex_alpha") {
+						matFlags = AI_IRRMESH_MAT_normalmap_tva;
+					} else if (prop.value == "normalmap_trans_add" ||
+							   prop.value == "parallaxmap_trans_add") {
+						matFlags = AI_IRRMESH_MAT_normalmap_ta;
+					} else {
+						ASSIMP_LOG_WARN("IRRMat: Unrecognized material type: ", prop.value);
+					}
+				}
+
+				// Up to 4 texture channels are supported
+				if (prop.name == "Texture1") {
+					// Always accept the primary texture channel
+					++cnt;
+					s.Set(prop.value);
+					mat->AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(0));
+				} else if (prop.name == "Texture2" && cnt == 1) {
+					// 2-layer material lightmapped?
+					if (matFlags & AI_IRRMESH_MAT_lightmap) {
+						++cnt;
+						s.Set(prop.value);
+						mat->AddProperty(&s, AI_MATKEY_TEXTURE_LIGHTMAP(0));
+
+						// set the corresponding material flag
+						matFlags |= AI_IRRMESH_EXTRA_2ND_TEXTURE;
+					} else if (matFlags & AI_IRRMESH_MAT_normalmap_solid) { // alternatively: normal or parallax mapping
+						++cnt;
+						s.Set(prop.value);
+						mat->AddProperty(&s, AI_MATKEY_TEXTURE_NORMALS(0));
+
+						// set the corresponding material flag
+						matFlags |= AI_IRRMESH_EXTRA_2ND_TEXTURE;
+					} else if (matFlags & AI_IRRMESH_MAT_solid_2layer) { // or just as second diffuse texture
+						++cnt;
+						s.Set(prop.value);
+						mat->AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(1));
+						++nd;
+
+						// set the corresponding material flag
+						matFlags |= AI_IRRMESH_EXTRA_2ND_TEXTURE;
+					} else {
+						ASSIMP_LOG_WARN("IRRmat: Skipping second texture");
+					}
+				} else if (prop.name == "Texture3" && cnt == 2) {
+					// Irrlicht does not seem to use these channels.
+					++cnt;
+					s.Set(prop.value);
+					mat->AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(nd + 1));
+				} else if (prop.name == "Texture4" && cnt == 3) {
+					// Irrlicht does not seem to use these channels.
+					++cnt;
+					s.Set(prop.value);
+					mat->AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(nd + 2));
+				}
+
+				// Texture mapping options
+				if (prop.name == "TextureWrap1" && cnt >= 1) {
+					int map = ConvertMappingMode(prop.value);
+					mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_DIFFUSE(0));
+					mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_DIFFUSE(0));
+				} else if (prop.name == "TextureWrap2" && cnt >= 2) {
+					int map = ConvertMappingMode(prop.value);
+					if (matFlags & AI_IRRMESH_MAT_lightmap) {
+						mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_LIGHTMAP(0));
+						mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_LIGHTMAP(0));
+					} else if (matFlags & (AI_IRRMESH_MAT_normalmap_solid)) {
+						mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_NORMALS(0));
+						mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_NORMALS(0));
+					} else if (matFlags & AI_IRRMESH_MAT_solid_2layer) {
+						mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_DIFFUSE(1));
+						mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_DIFFUSE(1));
+					}
+				} else if (prop.name == "TextureWrap3" && cnt >= 3) {
+					int map = ConvertMappingMode(prop.value);
+					mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_DIFFUSE(nd + 1));
+					mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_DIFFUSE(nd + 1));
+				} else if (prop.name == "TextureWrap4" && cnt >= 4) {
+					int map = ConvertMappingMode(prop.value);
+					mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_DIFFUSE(nd + 2));
+					mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_DIFFUSE(nd + 2));
+				}
+			}
+		}
+		//break;
+		/*case EXN_ELEMENT_END:
+
+                // Assume there are no further nested nodes in <material> elements
+                if ( !ASSIMP_stricmp(reader->getNodeName(),"material") ||
+                     !ASSIMP_stricmp(reader->getNodeName(),"attributes"))
+                {
+                    // Now process lightmapping flags
+                    // We should have at least one textur to do that ..
+                    if (cnt && matFlags & AI_IRRMESH_MAT_lightmap)
+                    {
+                        float f = 1.f;
+                        unsigned int unmasked = matFlags&~AI_IRRMESH_MAT_lightmap;
+
+                        // Additive lightmap?
+                        int op = (unmasked & AI_IRRMESH_MAT_lightmap_add
+                            ? aiTextureOp_Add : aiTextureOp_Multiply);
+
+                        // Handle Irrlicht's lightmapping scaling factor
+                        if (unmasked & AI_IRRMESH_MAT_lightmap_m2 ||
+                            unmasked & AI_IRRMESH_MAT_lightmap_light_m2)
+                        {
+                            f = 2.f;
+                        }
+                        else if (unmasked & AI_IRRMESH_MAT_lightmap_m4 ||
+                            unmasked & AI_IRRMESH_MAT_lightmap_light_m4)
+                        {
+                            f = 4.f;
+                        }
+                        mat->AddProperty( &f, 1, AI_MATKEY_TEXBLEND_LIGHTMAP(0));
+                        mat->AddProperty( &op,1, AI_MATKEY_TEXOP_LIGHTMAP(0));
+                    }
+
+                    return mat;
+                }
+            default:
+
+                // GCC complains here ...
+                break;
+        }
+    }*/
+	}
+    ASSIMP_LOG_ERROR("IRRMESH: Unexpected end of file. Material is not complete");
+
+    return mat;
+}
+
+#endif // !(defined(ASSIMP_BUILD_NO_IRR_IMPORTER) && defined(ASSIMP_BUILD_NO_IRRMESH_IMPORTER))
diff --git a/Engine/lib/assimp/code/Irr/IRRShared.h b/Engine/lib/assimp/code/AssetLib/Irr/IRRShared.h
similarity index 51%
rename from Engine/lib/assimp/code/Irr/IRRShared.h
rename to Engine/lib/assimp/code/AssetLib/Irr/IRRShared.h
index 2f6f87405..90e212d65 100644
--- a/Engine/lib/assimp/code/Irr/IRRShared.h
+++ b/Engine/lib/assimp/code/AssetLib/Irr/IRRShared.h
@@ -7,50 +7,48 @@
 #ifndef INCLUDED_AI_IRRSHARED_H
 #define INCLUDED_AI_IRRSHARED_H
 
-#include <assimp/irrXMLWrapper.h>
 #include <assimp/BaseImporter.h>
-#include <stdint.h>
+#include <assimp/XmlParser.h>
+#include <cstdint>
 
 struct aiMaterial;
 
-namespace Assimp    {
-
+namespace Assimp {
 
 /** @brief Matrix to convert from Assimp to IRR and backwards
  */
 extern const aiMatrix4x4 AI_TO_IRR_MATRIX;
 
-
 // Default: 0 = solid, one texture
-#define AI_IRRMESH_MAT_solid_2layer         0x10000
+#define AI_IRRMESH_MAT_solid_2layer 0x10000
 
 // Transparency flags
-#define AI_IRRMESH_MAT_trans_vertex_alpha   0x1
-#define AI_IRRMESH_MAT_trans_add            0x2
+#define AI_IRRMESH_MAT_trans_vertex_alpha 0x1
+#define AI_IRRMESH_MAT_trans_add 0x2
 
 // Lightmapping flags
-#define AI_IRRMESH_MAT_lightmap             0x2
-#define AI_IRRMESH_MAT_lightmap_m2          (AI_IRRMESH_MAT_lightmap|0x4)
-#define AI_IRRMESH_MAT_lightmap_m4          (AI_IRRMESH_MAT_lightmap|0x8)
-#define AI_IRRMESH_MAT_lightmap_light       (AI_IRRMESH_MAT_lightmap|0x10)
-#define AI_IRRMESH_MAT_lightmap_light_m2    (AI_IRRMESH_MAT_lightmap|0x20)
-#define AI_IRRMESH_MAT_lightmap_light_m4    (AI_IRRMESH_MAT_lightmap|0x40)
-#define AI_IRRMESH_MAT_lightmap_add         (AI_IRRMESH_MAT_lightmap|0x80)
+#define AI_IRRMESH_MAT_lightmap 0x2
+#define AI_IRRMESH_MAT_lightmap_m2 (AI_IRRMESH_MAT_lightmap | 0x4)
+#define AI_IRRMESH_MAT_lightmap_m4 (AI_IRRMESH_MAT_lightmap | 0x8)
+#define AI_IRRMESH_MAT_lightmap_light (AI_IRRMESH_MAT_lightmap | 0x10)
+#define AI_IRRMESH_MAT_lightmap_light_m2 (AI_IRRMESH_MAT_lightmap | 0x20)
+#define AI_IRRMESH_MAT_lightmap_light_m4 (AI_IRRMESH_MAT_lightmap | 0x40)
+#define AI_IRRMESH_MAT_lightmap_add (AI_IRRMESH_MAT_lightmap | 0x80)
 
 // Standard NormalMap (or Parallax map, they're treated equally)
-#define AI_IRRMESH_MAT_normalmap_solid      (0x100)
+#define AI_IRRMESH_MAT_normalmap_solid (0x100)
 
 // Normal map combined with vertex alpha
-#define AI_IRRMESH_MAT_normalmap_tva    \
+#define AI_IRRMESH_MAT_normalmap_tva \
     (AI_IRRMESH_MAT_normalmap_solid | AI_IRRMESH_MAT_trans_vertex_alpha)
 
 // Normal map combined with additive transparency
-#define AI_IRRMESH_MAT_normalmap_ta     \
+#define AI_IRRMESH_MAT_normalmap_ta \
     (AI_IRRMESH_MAT_normalmap_solid | AI_IRRMESH_MAT_trans_add)
 
 // Special flag. It indicates a second texture has been found
 // Its type depends ... either a normal textue or a normal map
-#define AI_IRRMESH_EXTRA_2ND_TEXTURE        0x100000
+#define AI_IRRMESH_EXTRA_2ND_TEXTURE 0x100000
 
 // ---------------------------------------------------------------------------
 /** Base class for the Irr and IrrMesh importers.
@@ -58,61 +56,64 @@ extern const aiMatrix4x4 AI_TO_IRR_MATRIX;
  *  Declares some irrlight-related xml parsing utilities and provides tools
  *  to load materials from IRR and IRRMESH files.
  */
-class IrrlichtBase
-{
+class IrrlichtBase {
 protected:
+    IrrlichtBase() :
+            mNode(nullptr) {
+        // empty
+    }
+
+    ~IrrlichtBase() {
+        // empty
+    }
 
     /** @brief Data structure for a simple name-value property
      */
     template <class T>
-    struct Property
-    {
+    struct Property {
         std::string name;
         T value;
     };
 
-    typedef Property<uint32_t>      HexProperty;
-    typedef Property<std::string>   StringProperty;
-    typedef Property<bool>          BoolProperty;
-    typedef Property<float>         FloatProperty;
-    typedef Property<aiVector3D>    VectorProperty;
-    typedef Property<int>           IntProperty;
+    typedef Property<uint32_t> HexProperty;
+    typedef Property<std::string> StringProperty;
+    typedef Property<bool> BoolProperty;
+    typedef Property<float> FloatProperty;
+    typedef Property<aiVector3D> VectorProperty;
+    typedef Property<int> IntProperty;
 
-    /** XML reader instance
-     */
-  irr::io::IrrXMLReader* reader;
+    /// XML reader instance
+    XmlParser mParser;
+    pugi::xml_node *mNode;
 
     // -------------------------------------------------------------------
     /** Parse a material description from the XML
      *  @return The created material
      *  @param matFlags Receives AI_IRRMESH_MAT_XX flags
      */
-    aiMaterial* ParseMaterial(unsigned int& matFlags);
+    aiMaterial *ParseMaterial(unsigned int &matFlags);
 
     // -------------------------------------------------------------------
     /** Read a property of the specified type from the current XML element.
      *  @param out Receives output data
      */
-    void ReadHexProperty    (HexProperty&    out);
-    void ReadStringProperty (StringProperty& out);
-    void ReadBoolProperty   (BoolProperty&   out);
-    void ReadFloatProperty  (FloatProperty&  out);
-    void ReadVectorProperty (VectorProperty&  out);
-    void ReadIntProperty    (IntProperty&    out);
+    void ReadHexProperty(HexProperty &out);
+    void ReadStringProperty(StringProperty &out);
+    void ReadBoolProperty(BoolProperty &out);
+    void ReadFloatProperty(FloatProperty &out);
+    void ReadVectorProperty(VectorProperty &out);
+    void ReadIntProperty(IntProperty &out);
 };
 
-
 // ------------------------------------------------------------------------------------------------
 // Unpack a hex color, e.g. 0xdcdedfff
-inline void ColorFromARGBPacked(uint32_t in, aiColor4D& clr)
-{
+inline void ColorFromARGBPacked(uint32_t in, aiColor4D &clr) {
     clr.a = ((in >> 24) & 0xff) / 255.f;
     clr.r = ((in >> 16) & 0xff) / 255.f;
-    clr.g = ((in >>  8) & 0xff) / 255.f;
-    clr.b = ((in      ) & 0xff) / 255.f;
+    clr.g = ((in >> 8) & 0xff) / 255.f;
+    clr.b = ((in)&0xff) / 255.f;
 }
 
-
 } // end namespace Assimp
 
 #endif // !! INCLUDED_AI_IRRSHARED_H
diff --git a/Engine/lib/assimp/code/LWO/LWOAnimation.cpp b/Engine/lib/assimp/code/AssetLib/LWO/LWOAnimation.cpp
similarity index 55%
rename from Engine/lib/assimp/code/LWO/LWOAnimation.cpp
rename to Engine/lib/assimp/code/AssetLib/LWO/LWOAnimation.cpp
index 3a0d2c392..c2ee2d9c0 100644
--- a/Engine/lib/assimp/code/LWO/LWOAnimation.cpp
+++ b/Engine/lib/assimp/code/AssetLib/LWO/LWOAnimation.cpp
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -44,11 +43,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief LWOAnimationResolver utility class
  *
  *  It's a very generic implementation of LightWave's system of
- *  componentwise-animated stuff. The one and only fully free
+ *  component-wise-animated stuff. The one and only fully free
  *  implementation of LightWave envelopes of which I know.
 */
 
-
 #if (!defined ASSIMP_BUILD_NO_LWO_IMPORTER) && (!defined ASSIMP_BUILD_NO_LWS_IMPORTER)
 
 #include <functional>
@@ -62,17 +60,20 @@ using namespace Assimp::LWO;
 
 // ------------------------------------------------------------------------------------------------
 // Construct an animation resolver from a given list of envelopes
-AnimResolver::AnimResolver(std::list<Envelope>& _envelopes,double tick)
-    : envelopes   (_envelopes)
-    , sample_rate (0.)
-    , envl_x(), envl_y(), envl_z()
-    , end_x(), end_y(), end_z()
-    , flags()
-    , sample_delta()
-{
-    trans_x = trans_y = trans_z = NULL;
-    rotat_x = rotat_y = rotat_z = NULL;
-    scale_x = scale_y = scale_z = NULL;
+AnimResolver::AnimResolver(std::list<Envelope> &_envelopes, double tick) :
+        envelopes(_envelopes),
+        sample_rate(0.),
+        envl_x(),
+        envl_y(),
+        envl_z(),
+        end_x(),
+        end_y(),
+        end_z(),
+        flags(),
+        sample_delta() {
+    trans_x = trans_y = trans_z = nullptr;
+    rotat_x = rotat_y = rotat_z = nullptr;
+    scale_x = scale_y = scale_z = nullptr;
 
     first = last = 150392.;
 
@@ -80,36 +81,49 @@ AnimResolver::AnimResolver(std::list<Envelope>& _envelopes,double tick)
     for (std::list<LWO::Envelope>::iterator it = envelopes.begin(); it != envelopes.end(); ++it) {
 
         (*it).old_first = 0;
-        (*it).old_last  = (*it).keys.size()-1;
+        (*it).old_last = (*it).keys.size() - 1;
 
-        if ((*it).keys.empty()) continue;
+        if ((*it).keys.empty()) {
+            continue;
+        }
+        if ((int)(*it).type < 1 || (int)(*it).type>EnvelopeType_Unknown) {
+            continue;
+        }
         switch ((*it).type) {
+        // translation
+        case LWO::EnvelopeType_Position_X:
+            trans_x = &*it;
+            break;
+        case LWO::EnvelopeType_Position_Y:
+            trans_y = &*it;
+            break;
+        case LWO::EnvelopeType_Position_Z:
+            trans_z = &*it;
+            break;
 
-            // translation
-            case LWO::EnvelopeType_Position_X:
-                trans_x = &*it;break;
-            case LWO::EnvelopeType_Position_Y:
-                trans_y = &*it;break;
-            case LWO::EnvelopeType_Position_Z:
-                trans_z = &*it;break;
+            // rotation
+        case LWO::EnvelopeType_Rotation_Heading:
+            rotat_x = &*it;
+            break;
+        case LWO::EnvelopeType_Rotation_Pitch:
+            rotat_y = &*it;
+            break;
+        case LWO::EnvelopeType_Rotation_Bank:
+            rotat_z = &*it;
+            break;
 
-                // rotation
-            case LWO::EnvelopeType_Rotation_Heading:
-                rotat_x = &*it;break;
-            case LWO::EnvelopeType_Rotation_Pitch:
-                rotat_y = &*it;break;
-            case LWO::EnvelopeType_Rotation_Bank:
-                rotat_z = &*it;break;
-
-                // scaling
-            case LWO::EnvelopeType_Scaling_X:
-                scale_x = &*it;break;
-            case LWO::EnvelopeType_Scaling_Y:
-                scale_y = &*it;break;
-            case LWO::EnvelopeType_Scaling_Z:
-                scale_z = &*it;break;
-            default:
-                continue;
+            // scaling
+        case LWO::EnvelopeType_Scaling_X:
+            scale_x = &*it;
+            break;
+        case LWO::EnvelopeType_Scaling_Y:
+            scale_y = &*it;
+            break;
+        case LWO::EnvelopeType_Scaling_Z:
+            scale_z = &*it;
+            break;
+        default:
+            continue;
         };
 
         // convert from seconds to ticks
@@ -117,8 +131,8 @@ AnimResolver::AnimResolver(std::list<Envelope>& _envelopes,double tick)
             (*d).time *= tick;
 
         // set default animation range (minimum and maximum time value for which we have a keyframe)
-        first = std::min(first, (*it).keys.front().time );
-        last  = std::max(last,  (*it).keys.back().time );
+        first = std::min(first, (*it).keys.front().time);
+        last = std::max(last, (*it).keys.back().time);
     }
 
     // deferred setup of animation range to increase performance.
@@ -128,28 +142,26 @@ AnimResolver::AnimResolver(std::list<Envelope>& _envelopes,double tick)
 
 // ------------------------------------------------------------------------------------------------
 // Reset all envelopes to their original contents
-void AnimResolver::ClearAnimRangeSetup()
-{
+void AnimResolver::ClearAnimRangeSetup() {
     for (std::list<LWO::Envelope>::iterator it = envelopes.begin(); it != envelopes.end(); ++it) {
 
-        (*it).keys.erase((*it).keys.begin(),(*it).keys.begin()+(*it).old_first);
-        (*it).keys.erase((*it).keys.begin()+(*it).old_last+1,(*it).keys.end());
+        (*it).keys.erase((*it).keys.begin(), (*it).keys.begin() + (*it).old_first);
+        (*it).keys.erase((*it).keys.begin() + (*it).old_last + 1, (*it).keys.end());
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-// Insert additional keys to match LWO's pre& post behaviours.
-void AnimResolver::UpdateAnimRangeSetup()
-{
+// Insert additional keys to match LWO's pre& post behaviors.
+void AnimResolver::UpdateAnimRangeSetup() {
     // XXX doesn't work yet (hangs if more than one envelope channels needs to be interpolated)
 
     for (std::list<LWO::Envelope>::iterator it = envelopes.begin(); it != envelopes.end(); ++it) {
         if ((*it).keys.empty()) continue;
 
         const double my_first = (*it).keys.front().time;
-        const double my_last  = (*it).keys.back().time;
+        const double my_last = (*it).keys.back().time;
 
-        const double delta = my_last-my_first;
+        const double delta = my_last - my_first;
         const size_t old_size = (*it).keys.size();
 
         const float value_delta = (*it).keys.back().value - (*it).keys.front().value;
@@ -157,87 +169,88 @@ void AnimResolver::UpdateAnimRangeSetup()
         // NOTE: We won't handle reset, linear and constant here.
         // See DoInterpolation() for their implementation.
 
-        // process pre behaviour
+        // process pre behavior
         switch ((*it).pre) {
-            case LWO::PrePostBehaviour_OffsetRepeat:
-            case LWO::PrePostBehaviour_Repeat:
-            case LWO::PrePostBehaviour_Oscillate:
-                {
-                const double start_time = delta - std::fmod(my_first-first,delta);
-                std::vector<LWO::Key>::iterator n = std::find_if((*it).keys.begin(),(*it).keys.end(),
-                    [start_time](double t) { return start_time > t; }),m;
+        case LWO::PrePostBehaviour_OffsetRepeat:
+        case LWO::PrePostBehaviour_Repeat:
+        case LWO::PrePostBehaviour_Oscillate: {
+            const double start_time = delta - std::fmod(my_first - first, delta);
+            std::vector<LWO::Key>::iterator n = std::find_if((*it).keys.begin(), (*it).keys.end(),
+                                                    [start_time](double t) { return start_time > t; }),
+                                            m;
 
-                size_t ofs = 0;
-                if (n != (*it).keys.end()) {
-                    // copy from here - don't use iterators, insert() would invalidate them
-                    ofs = (*it).keys.end()-n;
-                    (*it).keys.insert((*it).keys.begin(),ofs,LWO::Key());
+            size_t ofs = 0;
+            if (n != (*it).keys.end()) {
+                // copy from here - don't use iterators, insert() would invalidate them
+                ofs = (*it).keys.end() - n;
+                (*it).keys.insert((*it).keys.begin(), ofs, LWO::Key());
 
-                    std::copy((*it).keys.end()-ofs,(*it).keys.end(),(*it).keys.begin());
+                std::copy((*it).keys.end() - ofs, (*it).keys.end(), (*it).keys.begin());
+            }
+
+            // do full copies. again, no iterators
+            const unsigned int num = (unsigned int)((my_first - first) / delta);
+            (*it).keys.resize((*it).keys.size() + num * old_size);
+
+            n = (*it).keys.begin() + ofs;
+            bool reverse = false;
+            for (unsigned int i = 0; i < num; ++i) {
+                m = n + old_size * (i + 1);
+                std::copy(n, n + old_size, m);
+                const bool res = ((*it).pre == LWO::PrePostBehaviour_Oscillate);
+                reverse = !reverse;
+                if (res && reverse) {
+                    std::reverse(m, m + old_size - 1);
                 }
+            }
 
-                // do full copies. again, no iterators
-                const unsigned int num = (unsigned int)((my_first-first) / delta);
-                (*it).keys.resize((*it).keys.size() + num*old_size);
+            // update time values
+            n = (*it).keys.end() - (old_size + 1);
+            double cur_minus = delta;
+            unsigned int tt = 1;
+            for (const double tmp = delta * (num + 1); cur_minus <= tmp; cur_minus += delta, ++tt) {
+                m = (delta == tmp ? (*it).keys.begin() : n - (old_size + 1));
+                for (; m != n; --n) {
+                    (*n).time -= cur_minus;
 
-                n = (*it).keys.begin()+ofs;
-                bool reverse = false;
-                for (unsigned int i = 0; i < num; ++i) {
-                    m = n+old_size*(i+1);
-                    std::copy(n,n+old_size,m);
-
-                    if ((*it).pre == LWO::PrePostBehaviour_Oscillate && (reverse = !reverse))
-                        std::reverse(m,m+old_size-1);
-                }
-
-                // update time values
-                n = (*it).keys.end() - (old_size+1);
-                double cur_minus = delta;
-                unsigned int tt = 1;
-                for (const double tmp =  delta*(num+1);cur_minus <= tmp;cur_minus += delta,++tt) {
-                    m = (delta == tmp ? (*it).keys.begin() :  n - (old_size+1));
-                    for (;m != n; --n) {
-                        (*n).time -= cur_minus;
-
-                        // offset repeat? add delta offset to key value
-                        if ((*it).pre == LWO::PrePostBehaviour_OffsetRepeat) {
-                            (*n).value += tt * value_delta;
-                        }
+                    // offset repeat? add delta offset to key value
+                    if ((*it).pre == LWO::PrePostBehaviour_OffsetRepeat) {
+                        (*n).value += tt * value_delta;
                     }
                 }
-                break;
-                }
-            default:
-                // silence compiler warning
-                break;
+            }
+            break;
+        }
+        default:
+            // silence compiler warning
+            break;
         }
 
-        // process post behaviour
+        // process post behavior
         switch ((*it).post) {
 
-            case LWO::PrePostBehaviour_OffsetRepeat:
-            case LWO::PrePostBehaviour_Repeat:
-            case LWO::PrePostBehaviour_Oscillate:
+        case LWO::PrePostBehaviour_OffsetRepeat:
+        case LWO::PrePostBehaviour_Repeat:
+        case LWO::PrePostBehaviour_Oscillate:
 
-                break;
+            break;
 
-            default:
-                // silence compiler warning
-                break;
+        default:
+            // silence compiler warning
+            break;
         }
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Extract bind pose matrix
-void AnimResolver::ExtractBindPose(aiMatrix4x4& out)
-{
+void AnimResolver::ExtractBindPose(aiMatrix4x4 &out) {
     // If we have no envelopes, return identity
     if (envelopes.empty()) {
         out = aiMatrix4x4();
         return;
     }
-    aiVector3D angles, scaling(1.f,1.f,1.f), translation;
+    aiVector3D angles, scaling(1.f, 1.f, 1.f), translation;
 
     if (trans_x) translation.x = trans_x->keys[0].value;
     if (trans_y) translation.y = trans_y->keys[0].value;
@@ -252,20 +265,19 @@ void AnimResolver::ExtractBindPose(aiMatrix4x4& out)
     if (scale_z) scaling.z = scale_z->keys[0].value;
 
     // build the final matrix
-    aiMatrix4x4 s,rx,ry,rz,t;
+    aiMatrix4x4 s, rx, ry, rz, t;
     aiMatrix4x4::RotationZ(angles.z, rz);
     aiMatrix4x4::RotationX(angles.y, rx);
     aiMatrix4x4::RotationY(angles.x, ry);
-    aiMatrix4x4::Translation(translation,t);
-    aiMatrix4x4::Scaling(scaling,s);
-    out = t*ry*rx*rz*s;
+    aiMatrix4x4::Translation(translation, t);
+    aiMatrix4x4::Scaling(scaling, s);
+    out = t * ry * rx * rz * s;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Do a single interpolation on a channel
 void AnimResolver::DoInterpolation(std::vector<LWO::Key>::const_iterator cur,
-    LWO::Envelope* envl,double time, float& fill)
-{
+        LWO::Envelope *envl, double time, float &fill) {
     if (envl->keys.size() == 1) {
         fill = envl->keys[0].value;
         return;
@@ -276,64 +288,61 @@ void AnimResolver::DoInterpolation(std::vector<LWO::Key>::const_iterator cur,
 
         // ok ... this depends on pre behaviour now
         // we don't need to handle repeat&offset repeat&oszillate here, see UpdateAnimRangeSetup()
-        switch (envl->pre)
-        {
+        switch (envl->pre) {
         case LWO::PrePostBehaviour_Linear:
-            DoInterpolation2(cur,cur+1,time,fill);
+            DoInterpolation2(cur, cur + 1, time, fill);
             return;
 
         case LWO::PrePostBehaviour_Reset:
             fill = 0.f;
             return;
 
-        default : //case LWO::PrePostBehaviour_Constant:
+        default: //case LWO::PrePostBehaviour_Constant:
             fill = (*cur).value;
             return;
         }
     }
     // check whether we're at the end of the animation track
-    else if (cur == envl->keys.end()-1 && time > envl->keys.rbegin()->time) {
+    else if (cur == envl->keys.end() - 1 && time > envl->keys.rbegin()->time) {
         // ok ... this depends on post behaviour now
-        switch (envl->post)
-        {
+        switch (envl->post) {
         case LWO::PrePostBehaviour_Linear:
-            DoInterpolation2(cur,cur-1,time,fill);
+            DoInterpolation2(cur, cur - 1, time, fill);
             return;
 
         case LWO::PrePostBehaviour_Reset:
             fill = 0.f;
             return;
 
-        default : //case LWO::PrePostBehaviour_Constant:
+        default: //case LWO::PrePostBehaviour_Constant:
             fill = (*cur).value;
             return;
         }
     }
 
     // Otherwise do a simple interpolation
-    DoInterpolation2(cur-1,cur,time,fill);
+    DoInterpolation2(cur - 1, cur, time, fill);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Almost the same, except we won't handle pre/post conditions here
 void AnimResolver::DoInterpolation2(std::vector<LWO::Key>::const_iterator beg,
-    std::vector<LWO::Key>::const_iterator end,double time, float& fill)
-{
+        std::vector<LWO::Key>::const_iterator end, double time, float &fill) {
     switch ((*end).inter) {
 
-        case LWO::IT_STEP:
-            // no interpolation at all - take the value of the last key
-            fill = (*beg).value;
-            return;
-        default:
+    case LWO::IT_STEP:
+        // no interpolation at all - take the value of the last key
+        fill = (*beg).value;
+        return;
+    default:
 
-            // silence compiler warning
-            break;
+        // silence compiler warning
+        break;
     }
     // linear interpolation - default
     double duration = (*end).time - (*beg).time;
     if (duration > 0.0) {
-        fill = (*beg).value + ((*end).value - (*beg).value)*(float)(((time - (*beg).time) / duration));
+        fill = (*beg).value + ((*end).value - (*beg).value) * (float)(((time - (*beg).time) / duration));
     } else {
         fill = (*beg).value;
     }
@@ -341,22 +350,20 @@ void AnimResolver::DoInterpolation2(std::vector<LWO::Key>::const_iterator beg,
 
 // ------------------------------------------------------------------------------------------------
 // Subsample animation track by given key values
-void AnimResolver::SubsampleAnimTrack(std::vector<aiVectorKey>& /*out*/,
-    double /*time*/ ,double /*sample_delta*/ )
-{
+void AnimResolver::SubsampleAnimTrack(std::vector<aiVectorKey> & /*out*/,
+        double /*time*/, double /*sample_delta*/) {
     //ai_assert(out.empty() && sample_delta);
 
     //const double time_start = out.back().mTime;
-//  for ()
+    //  for ()
 }
 
 // ------------------------------------------------------------------------------------------------
 // Track interpolation
-void AnimResolver::InterpolateTrack(std::vector<aiVectorKey>& out,aiVectorKey& fill,double time)
-{
+void AnimResolver::InterpolateTrack(std::vector<aiVectorKey> &out, aiVectorKey &fill, double time) {
     // subsample animation track?
     if (flags & AI_LWO_ANIM_FLAG_SAMPLE_ANIMS) {
-        SubsampleAnimTrack(out,time, sample_delta);
+        SubsampleAnimTrack(out, time, sample_delta);
     }
 
     fill.mTime = time;
@@ -365,56 +372,58 @@ void AnimResolver::InterpolateTrack(std::vector<aiVectorKey>& out,aiVectorKey& f
     if ((*cur_x).time == time) {
         fill.mValue.x = (*cur_x).value;
 
-        if (cur_x != envl_x->keys.end()-1) /* increment x */
+        if (cur_x != envl_x->keys.end() - 1) /* increment x */
             ++cur_x;
-        else end_x = true;
-    }
-    else DoInterpolation(cur_x,envl_x,time,(float&)fill.mValue.x);
+        else
+            end_x = true;
+    } else
+        DoInterpolation(cur_x, envl_x, time, (float &)fill.mValue.x);
 
     // get y
     if ((*cur_y).time == time) {
         fill.mValue.y = (*cur_y).value;
 
-        if (cur_y != envl_y->keys.end()-1) /* increment y */
+        if (cur_y != envl_y->keys.end() - 1) /* increment y */
             ++cur_y;
-        else end_y = true;
-    }
-    else DoInterpolation(cur_y,envl_y,time,(float&)fill.mValue.y);
+        else
+            end_y = true;
+    } else
+        DoInterpolation(cur_y, envl_y, time, (float &)fill.mValue.y);
 
     // get z
     if ((*cur_z).time == time) {
         fill.mValue.z = (*cur_z).value;
 
-        if (cur_z != envl_z->keys.end()-1) /* increment z */
+        if (cur_z != envl_z->keys.end() - 1) /* increment z */
             ++cur_z;
-        else end_x = true;
-    }
-    else DoInterpolation(cur_z,envl_z,time,(float&)fill.mValue.z);
+        else
+            end_x = true;
+    } else
+        DoInterpolation(cur_z, envl_z, time, (float &)fill.mValue.z);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Build linearly subsampled keys from three single envelopes, one for each component (x,y,z)
-void AnimResolver::GetKeys(std::vector<aiVectorKey>& out,
-    LWO::Envelope* _envl_x,
-    LWO::Envelope* _envl_y,
-    LWO::Envelope* _envl_z,
-    unsigned int _flags)
-{
+void AnimResolver::GetKeys(std::vector<aiVectorKey> &out,
+        LWO::Envelope *_envl_x,
+        LWO::Envelope *_envl_y,
+        LWO::Envelope *_envl_z,
+        unsigned int _flags) {
     envl_x = _envl_x;
     envl_y = _envl_y;
     envl_z = _envl_z;
-    flags  = _flags;
+    flags = _flags;
 
     // generate default channels if none are given
     LWO::Envelope def_x, def_y, def_z;
     LWO::Key key_dummy;
     key_dummy.time = 0.f;
     if ((envl_x && envl_x->type == LWO::EnvelopeType_Scaling_X) ||
-        (envl_y && envl_y->type == LWO::EnvelopeType_Scaling_Y) ||
-        (envl_z && envl_z->type == LWO::EnvelopeType_Scaling_Z)) {
+            (envl_y && envl_y->type == LWO::EnvelopeType_Scaling_Y) ||
+            (envl_z && envl_z->type == LWO::EnvelopeType_Scaling_Z)) {
         key_dummy.value = 1.f;
-    }
-    else key_dummy.value = 0.f;
+    } else
+        key_dummy.value = 0.f;
 
     if (!envl_x) {
         envl_x = &def_x;
@@ -435,15 +444,17 @@ void AnimResolver::GetKeys(std::vector<aiVectorKey>& out,
     if (flags & AI_LWO_ANIM_FLAG_SAMPLE_ANIMS) {
         if (!sample_rate)
             sr = 100.f;
-        else sr = sample_rate;
+        else
+            sr = sample_rate;
         sample_delta = 1.f / sr;
 
         reserve = (size_t)(
-            std::max( envl_x->keys.rbegin()->time,
-            std::max( envl_y->keys.rbegin()->time, envl_z->keys.rbegin()->time )) * sr);
-    }
-    else reserve = std::max(envl_x->keys.size(),std::max(envl_x->keys.size(),envl_z->keys.size()));
-    out.reserve(reserve+(reserve>>1));
+                std::max(envl_x->keys.rbegin()->time,
+                        std::max(envl_y->keys.rbegin()->time, envl_z->keys.rbegin()->time)) *
+                sr);
+    } else
+        reserve = std::max(envl_x->keys.size(), std::max(envl_x->keys.size(), envl_z->keys.size()));
+    out.reserve(reserve + (reserve >> 1));
 
     // Iterate through all three arrays at once - it's tricky, but
     // rather interesting to implement.
@@ -456,7 +467,7 @@ void AnimResolver::GetKeys(std::vector<aiVectorKey>& out,
 
         aiVectorKey fill;
 
-        if ((*cur_x).time == (*cur_y).time && (*cur_x).time == (*cur_z).time ) {
+        if ((*cur_x).time == (*cur_y).time && (*cur_x).time == (*cur_z).time) {
 
             // we have a keyframe for all of them defined .. this means
             // we don't need to interpolate here.
@@ -476,52 +487,49 @@ void AnimResolver::GetKeys(std::vector<aiVectorKey>& out,
         else if ((*cur_x).time <= (*cur_y).time && !end_x) {
 
             if ((*cur_z).time <= (*cur_x).time && !end_z) {
-                InterpolateTrack(out,fill,(*cur_z).time);
+                InterpolateTrack(out, fill, (*cur_z).time);
+            } else {
+                InterpolateTrack(out, fill, (*cur_x).time);
             }
-            else {
-                InterpolateTrack(out,fill,(*cur_x).time);
-            }
-        }
-        else if ((*cur_z).time <= (*cur_y).time && !end_y)  {
-            InterpolateTrack(out,fill,(*cur_y).time);
-        }
-        else if (!end_y) {
+        } else if ((*cur_z).time <= (*cur_y).time && !end_y) {
+            InterpolateTrack(out, fill, (*cur_y).time);
+        } else if (!end_y) {
             // welcome on the server, y
-            InterpolateTrack(out,fill,(*cur_y).time);
-        }
-        else {
+            InterpolateTrack(out, fill, (*cur_y).time);
+        } else {
             // we have reached the end of at least 2 channels,
             // only one is remaining. Extrapolate the 2.
             if (end_y) {
-                InterpolateTrack(out,fill,(end_x ? (*cur_z) : (*cur_x)).time);
-            }
-            else if (end_x) {
-                InterpolateTrack(out,fill,(end_z ? (*cur_y) : (*cur_z)).time);
-            }
-            else { // if (end_z)
-                InterpolateTrack(out,fill,(end_y ? (*cur_x) : (*cur_y)).time);
+                InterpolateTrack(out, fill, (end_x ? (*cur_z) : (*cur_x)).time);
+            } else if (end_x) {
+                InterpolateTrack(out, fill, (end_z ? (*cur_y) : (*cur_z)).time);
+            } else { // if (end_z)
+                InterpolateTrack(out, fill, (end_y ? (*cur_x) : (*cur_y)).time);
             }
         }
         double lasttime = fill.mTime;
         out.push_back(fill);
 
         if (lasttime >= (*cur_x).time) {
-            if (cur_x != envl_x->keys.end()-1)
+            if (cur_x != envl_x->keys.end() - 1)
                 ++cur_x;
-            else end_x = true;
+            else
+                end_x = true;
         }
         if (lasttime >= (*cur_y).time) {
-            if (cur_y != envl_y->keys.end()-1)
+            if (cur_y != envl_y->keys.end() - 1)
                 ++cur_y;
-            else end_y = true;
+            else
+                end_y = true;
         }
         if (lasttime >= (*cur_z).time) {
-            if (cur_z != envl_z->keys.end()-1)
+            if (cur_z != envl_z->keys.end() - 1)
                 ++cur_z;
-            else end_z = true;
+            else
+                end_z = true;
         }
 
-        if( end_x && end_y && end_z ) /* finished? */
+        if (end_x && end_y && end_z) /* finished? */
             break;
     }
 
@@ -533,14 +541,12 @@ void AnimResolver::GetKeys(std::vector<aiVectorKey>& out,
 
 // ------------------------------------------------------------------------------------------------
 // Extract animation channel
-void AnimResolver::ExtractAnimChannel(aiNodeAnim** out, unsigned int flags /*= 0*/)
-{
-    *out = NULL;
-
+void AnimResolver::ExtractAnimChannel(aiNodeAnim **out, unsigned int /*= 0*/) {
+    *out = nullptr;
 
     //FIXME: crashes if more than one component is animated at different timings, to be resolved.
 
-    // If we have no envelopes, return NULL
+    // If we have no envelopes, return nullptr
     if (envelopes.empty()) {
         return;
     }
@@ -553,7 +559,7 @@ void AnimResolver::ExtractAnimChannel(aiNodeAnim** out, unsigned int flags /*= 0
         return;
 
     // Allocate the output animation
-    aiNodeAnim* anim = *out = new aiNodeAnim();
+    aiNodeAnim *anim = *out = new aiNodeAnim();
 
     // Setup default animation setup if necessary
     if (need_to_setup) {
@@ -564,41 +570,40 @@ void AnimResolver::ExtractAnimChannel(aiNodeAnim** out, unsigned int flags /*= 0
     // copy translation keys
     if (trans) {
         std::vector<aiVectorKey> keys;
-        GetKeys(keys,trans_x,trans_y,trans_z,flags);
+        GetKeys(keys, trans_x, trans_y, trans_z, flags);
 
-        anim->mPositionKeys = new aiVectorKey[ anim->mNumPositionKeys = static_cast<unsigned int>(keys.size()) ];
-        std::copy(keys.begin(),keys.end(),anim->mPositionKeys);
+        anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys = static_cast<unsigned int>(keys.size())];
+        std::copy(keys.begin(), keys.end(), anim->mPositionKeys);
     }
 
     // copy rotation keys
     if (rotat) {
         std::vector<aiVectorKey> keys;
-        GetKeys(keys,rotat_x,rotat_y,rotat_z,flags);
+        GetKeys(keys, rotat_x, rotat_y, rotat_z, flags);
 
-        anim->mRotationKeys = new aiQuatKey[ anim->mNumRotationKeys = static_cast<unsigned int>(keys.size()) ];
+        anim->mRotationKeys = new aiQuatKey[anim->mNumRotationKeys = static_cast<unsigned int>(keys.size())];
 
         // convert heading, pitch, bank to quaternion
         // mValue.x=Heading=Rot(Y), mValue.y=Pitch=Rot(X), mValue.z=Bank=Rot(Z)
         // Lightwave's rotation order is ZXY
-        aiVector3D X(1.0,0.0,0.0);
-        aiVector3D Y(0.0,1.0,0.0);
-        aiVector3D Z(0.0,0.0,1.0);
+        aiVector3D X(1.0, 0.0, 0.0);
+        aiVector3D Y(0.0, 1.0, 0.0);
+        aiVector3D Z(0.0, 0.0, 1.0);
         for (unsigned int i = 0; i < anim->mNumRotationKeys; ++i) {
-            aiQuatKey& qk = anim->mRotationKeys[i];
-            qk.mTime  = keys[i].mTime;
-            qk.mValue = aiQuaternion(Y,keys[i].mValue.x)*aiQuaternion(X,keys[i].mValue.y)*aiQuaternion(Z,keys[i].mValue.z);
+            aiQuatKey &qk = anim->mRotationKeys[i];
+            qk.mTime = keys[i].mTime;
+            qk.mValue = aiQuaternion(Y, keys[i].mValue.x) * aiQuaternion(X, keys[i].mValue.y) * aiQuaternion(Z, keys[i].mValue.z);
         }
     }
 
     // copy scaling keys
     if (scale) {
         std::vector<aiVectorKey> keys;
-        GetKeys(keys,scale_x,scale_y,scale_z,flags);
+        GetKeys(keys, scale_x, scale_y, scale_z, flags);
 
-        anim->mScalingKeys = new aiVectorKey[ anim->mNumScalingKeys = static_cast<unsigned int>(keys.size()) ];
-        std::copy(keys.begin(),keys.end(),anim->mScalingKeys);
+        anim->mScalingKeys = new aiVectorKey[anim->mNumScalingKeys = static_cast<unsigned int>(keys.size())];
+        std::copy(keys.begin(), keys.end(), anim->mScalingKeys);
     }
 }
 
-
 #endif // no lwo or no lws
diff --git a/Engine/lib/assimp/code/LWO/LWOAnimation.h b/Engine/lib/assimp/code/AssetLib/LWO/LWOAnimation.h
similarity index 98%
rename from Engine/lib/assimp/code/LWO/LWOAnimation.h
rename to Engine/lib/assimp/code/AssetLib/LWO/LWOAnimation.h
index dd29695cc..1e419d461 100644
--- a/Engine/lib/assimp/code/LWO/LWOAnimation.h
+++ b/Engine/lib/assimp/code/AssetLib/LWO/LWOAnimation.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -114,7 +114,7 @@ enum PrePostBehaviour
 /** \brief Data structure for a LWO animation keyframe
  */
 struct Key {
-    Key() AI_NO_EXCEPT 
+    Key() AI_NO_EXCEPT
     : time()
     , value()
     , inter(IT_LINE)
@@ -211,7 +211,7 @@ public:
     // ------------------------------------------------------------------
     /** @brief Extract a node animation channel
      *  @param out Receives a pointer to a newly allocated node anim.
-     *    If there's just one keyframe defined, *out is set to NULL and
+     *    If there's just one keyframe defined, *out is set to nullptr and
      *    no animation channel is computed.
      *  @param flags Any combination of the AI_LWO_ANIM_FLAG_XXX flags.
      */
@@ -261,7 +261,7 @@ protected:
      *  @param envl_y Y-component envelope
      *  @param envl_z Z-component envelope
      *  @param flags Any combination of the AI_LWO_ANIM_FLAG_XXX flags.
-     *  @note Up to two input envelopes may be NULL
+     *  @note Up to two input envelopes may be nullptr
      */
     void GetKeys(std::vector<aiVectorKey>& out,
         LWO::Envelope* envl_x,
diff --git a/Engine/lib/assimp/code/LWO/LWOBLoader.cpp b/Engine/lib/assimp/code/AssetLib/LWO/LWOBLoader.cpp
similarity index 99%
rename from Engine/lib/assimp/code/LWO/LWOBLoader.cpp
rename to Engine/lib/assimp/code/AssetLib/LWO/LWOBLoader.cpp
index b24957072..1fbd9b9df 100644
--- a/Engine/lib/assimp/code/LWO/LWOBLoader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/LWO/LWOBLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -242,7 +242,7 @@ LWO::Texture* LWOImporter::SetupNewTextureLWOB(LWO::TextureList& list,unsigned i
     else
     {
         // procedural or gradient, not supported
-        ASSIMP_LOG_ERROR_F("LWOB: Unsupported legacy texture: ", type);
+        ASSIMP_LOG_ERROR("LWOB: Unsupported legacy texture: ", type);
     }
 
     return tex;
@@ -255,7 +255,7 @@ void LWOImporter::LoadLWOBSurface(unsigned int size)
 
     mSurfaces->push_back( LWO::Surface () );
     LWO::Surface& surf = mSurfaces->back();
-    LWO::Texture* pTex = NULL;
+    LWO::Texture *pTex = nullptr;
 
     GetS0(surf.mName,size);
     bool running = true;
diff --git a/Engine/lib/assimp/code/AssetLib/LWO/LWOFileData.h b/Engine/lib/assimp/code/AssetLib/LWO/LWOFileData.h
new file mode 100644
index 000000000..59d10eca1
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/LWO/LWOFileData.h
@@ -0,0 +1,715 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file LWOFileData.h
+ *  @brief Defines chunk constants used by the LWO file format
+
+The chunks are taken from the official LightWave SDK headers.
+
+*/
+#ifndef AI_LWO_FILEDATA_INCLUDED
+#define AI_LWO_FILEDATA_INCLUDED
+
+// STL headers
+#include <list>
+#include <vector>
+
+// public ASSIMP headers
+#include <assimp/mesh.h>
+
+// internal headers
+#include "AssetLib/LWO/LWOAnimation.h"
+#include "Common/IFF.h"
+
+namespace Assimp {
+namespace LWO {
+
+#define AI_LWO_FOURCC_LWOB AI_IFF_FOURCC('L', 'W', 'O', 'B')
+#define AI_LWO_FOURCC_LWO2 AI_IFF_FOURCC('L', 'W', 'O', '2')
+#define AI_LWO_FOURCC_LWO3 AI_IFF_FOURCC('L', 'W', 'O', '3')
+#define AI_LWO_FOURCC_LXOB AI_IFF_FOURCC('L', 'X', 'O', 'B')
+
+// chunks specific to the LWOB format
+#define AI_LWO_SRFS AI_IFF_FOURCC('S', 'R', 'F', 'S')
+#define AI_LWO_FLAG AI_IFF_FOURCC('F', 'L', 'A', 'G')
+#define AI_LWO_VLUM AI_IFF_FOURCC('V', 'L', 'U', 'M')
+#define AI_LWO_VDIF AI_IFF_FOURCC('V', 'D', 'I', 'F')
+#define AI_LWO_VSPC AI_IFF_FOURCC('V', 'S', 'P', 'C')
+#define AI_LWO_RFLT AI_IFF_FOURCC('R', 'F', 'L', 'T')
+#define AI_LWO_BTEX AI_IFF_FOURCC('B', 'T', 'E', 'X')
+#define AI_LWO_CTEX AI_IFF_FOURCC('C', 'T', 'E', 'X')
+#define AI_LWO_DTEX AI_IFF_FOURCC('D', 'T', 'E', 'X')
+#define AI_LWO_LTEX AI_IFF_FOURCC('L', 'T', 'E', 'X')
+#define AI_LWO_RTEX AI_IFF_FOURCC('R', 'T', 'E', 'X')
+#define AI_LWO_STEX AI_IFF_FOURCC('S', 'T', 'E', 'X')
+#define AI_LWO_TTEX AI_IFF_FOURCC('T', 'T', 'E', 'X')
+#define AI_LWO_TFLG AI_IFF_FOURCC('T', 'F', 'L', 'G')
+#define AI_LWO_TSIZ AI_IFF_FOURCC('T', 'S', 'I', 'Z')
+#define AI_LWO_TCTR AI_IFF_FOURCC('T', 'C', 'T', 'R')
+#define AI_LWO_TFAL AI_IFF_FOURCC('T', 'F', 'A', 'L')
+#define AI_LWO_TVEL AI_IFF_FOURCC('T', 'V', 'E', 'L')
+#define AI_LWO_TCLR AI_IFF_FOURCC('T', 'C', 'L', 'R')
+#define AI_LWO_TVAL AI_IFF_FOURCC('T', 'V', 'A', 'L')
+#define AI_LWO_TAMP AI_IFF_FOURCC('T', 'A', 'M', 'P')
+#define AI_LWO_TIMG AI_IFF_FOURCC('T', 'I', 'M', 'G')
+#define AI_LWO_TAAS AI_IFF_FOURCC('T', 'A', 'A', 'S')
+#define AI_LWO_TREF AI_IFF_FOURCC('T', 'R', 'E', 'F')
+#define AI_LWO_TOPC AI_IFF_FOURCC('T', 'O', 'P', 'C')
+#define AI_LWO_SDAT AI_IFF_FOURCC('S', 'D', 'A', 'T')
+#define AI_LWO_TFP0 AI_IFF_FOURCC('T', 'F', 'P', '0')
+#define AI_LWO_TFP1 AI_IFF_FOURCC('T', 'F', 'P', '1')
+
+/* top-level chunks */
+#define AI_LWO_LAYR AI_IFF_FOURCC('L', 'A', 'Y', 'R')
+#define AI_LWO_TAGS AI_IFF_FOURCC('T', 'A', 'G', 'S')
+#define AI_LWO_PNTS AI_IFF_FOURCC('P', 'N', 'T', 'S')
+#define AI_LWO_BBOX AI_IFF_FOURCC('B', 'B', 'O', 'X')
+#define AI_LWO_VMAP AI_IFF_FOURCC('V', 'M', 'A', 'P')
+#define AI_LWO_VMAD AI_IFF_FOURCC('V', 'M', 'A', 'D')
+#define AI_LWO_POLS AI_IFF_FOURCC('P', 'O', 'L', 'S')
+#define AI_LWO_PTAG AI_IFF_FOURCC('P', 'T', 'A', 'G')
+#define AI_LWO_ENVL AI_IFF_FOURCC('E', 'N', 'V', 'L')
+#define AI_LWO_CLIP AI_IFF_FOURCC('C', 'L', 'I', 'P')
+#define AI_LWO_SURF AI_IFF_FOURCC('S', 'U', 'R', 'F')
+#define AI_LWO_DESC AI_IFF_FOURCC('D', 'E', 'S', 'C')
+#define AI_LWO_TEXT AI_IFF_FOURCC('T', 'E', 'X', 'T')
+#define AI_LWO_ICON AI_IFF_FOURCC('I', 'C', 'O', 'N')
+
+/* polygon types */
+#define AI_LWO_FACE AI_IFF_FOURCC('F', 'A', 'C', 'E')
+#define AI_LWO_CURV AI_IFF_FOURCC('C', 'U', 'R', 'V')
+#define AI_LWO_PTCH AI_IFF_FOURCC('P', 'T', 'C', 'H')
+#define AI_LWO_MBAL AI_IFF_FOURCC('M', 'B', 'A', 'L')
+#define AI_LWO_BONE AI_IFF_FOURCC('B', 'O', 'N', 'E')
+#define AI_LWO_SUBD AI_IFF_FOURCC('S', 'U', 'B', 'D')
+
+/* polygon tags */
+#define AI_LWO_SURF AI_IFF_FOURCC('S', 'U', 'R', 'F')
+#define AI_LWO_PART AI_IFF_FOURCC('P', 'A', 'R', 'T')
+#define AI_LWO_SMGP AI_IFF_FOURCC('S', 'M', 'G', 'P')
+
+/* envelopes */
+#define AI_LWO_PRE AI_IFF_FOURCC('P', 'R', 'E', ' ')
+#define AI_LWO_POST AI_IFF_FOURCC('P', 'O', 'S', 'T')
+#define AI_LWO_KEY AI_IFF_FOURCC('K', 'E', 'Y', ' ')
+#define AI_LWO_SPAN AI_IFF_FOURCC('S', 'P', 'A', 'N')
+#define AI_LWO_TCB AI_IFF_FOURCC('T', 'C', 'B', ' ')
+#define AI_LWO_HERM AI_IFF_FOURCC('H', 'E', 'R', 'M')
+#define AI_LWO_BEZI AI_IFF_FOURCC('B', 'E', 'Z', 'I')
+#define AI_LWO_BEZ2 AI_IFF_FOURCC('B', 'E', 'Z', '2')
+#define AI_LWO_LINE AI_IFF_FOURCC('L', 'I', 'N', 'E')
+#define AI_LWO_STEP AI_IFF_FOURCC('S', 'T', 'E', 'P')
+
+/* clips */
+#define AI_LWO_STIL AI_IFF_FOURCC('S', 'T', 'I', 'L')
+#define AI_LWO_ISEQ AI_IFF_FOURCC('I', 'S', 'E', 'Q')
+#define AI_LWO_ANIM AI_IFF_FOURCC('A', 'N', 'I', 'M')
+#define AI_LWO_XREF AI_IFF_FOURCC('X', 'R', 'E', 'F')
+#define AI_LWO_STCC AI_IFF_FOURCC('S', 'T', 'C', 'C')
+#define AI_LWO_TIME AI_IFF_FOURCC('T', 'I', 'M', 'E')
+#define AI_LWO_CONT AI_IFF_FOURCC('C', 'O', 'N', 'T')
+#define AI_LWO_BRIT AI_IFF_FOURCC('B', 'R', 'I', 'T')
+#define AI_LWO_SATR AI_IFF_FOURCC('S', 'A', 'T', 'R')
+#define AI_LWO_HUE AI_IFF_FOURCC('H', 'U', 'E', ' ')
+#define AI_LWO_GAMM AI_IFF_FOURCC('G', 'A', 'M', 'M')
+#define AI_LWO_NEGA AI_IFF_FOURCC('N', 'E', 'G', 'A')
+#define AI_LWO_IFLT AI_IFF_FOURCC('I', 'F', 'L', 'T')
+#define AI_LWO_PFLT AI_IFF_FOURCC('P', 'F', 'L', 'T')
+
+/* surfaces */
+#define AI_LWO_COLR AI_IFF_FOURCC('C', 'O', 'L', 'R')
+#define AI_LWO_LUMI AI_IFF_FOURCC('L', 'U', 'M', 'I')
+#define AI_LWO_DIFF AI_IFF_FOURCC('D', 'I', 'F', 'F')
+#define AI_LWO_SPEC AI_IFF_FOURCC('S', 'P', 'E', 'C')
+#define AI_LWO_GLOS AI_IFF_FOURCC('G', 'L', 'O', 'S')
+#define AI_LWO_REFL AI_IFF_FOURCC('R', 'E', 'F', 'L')
+#define AI_LWO_RFOP AI_IFF_FOURCC('R', 'F', 'O', 'P')
+#define AI_LWO_RIMG AI_IFF_FOURCC('R', 'I', 'M', 'G')
+#define AI_LWO_RSAN AI_IFF_FOURCC('R', 'S', 'A', 'N')
+#define AI_LWO_TRAN AI_IFF_FOURCC('T', 'R', 'A', 'N')
+#define AI_LWO_TROP AI_IFF_FOURCC('T', 'R', 'O', 'P')
+#define AI_LWO_TIMG AI_IFF_FOURCC('T', 'I', 'M', 'G')
+#define AI_LWO_RIND AI_IFF_FOURCC('R', 'I', 'N', 'D')
+#define AI_LWO_TRNL AI_IFF_FOURCC('T', 'R', 'N', 'L')
+#define AI_LWO_BUMP AI_IFF_FOURCC('B', 'U', 'M', 'P')
+#define AI_LWO_SMAN AI_IFF_FOURCC('S', 'M', 'A', 'N')
+#define AI_LWO_SIDE AI_IFF_FOURCC('S', 'I', 'D', 'E')
+#define AI_LWO_CLRH AI_IFF_FOURCC('C', 'L', 'R', 'H')
+#define AI_LWO_CLRF AI_IFF_FOURCC('C', 'L', 'R', 'F')
+#define AI_LWO_ADTR AI_IFF_FOURCC('A', 'D', 'T', 'R')
+#define AI_LWO_SHRP AI_IFF_FOURCC('S', 'H', 'R', 'P')
+#define AI_LWO_LINE AI_IFF_FOURCC('L', 'I', 'N', 'E')
+#define AI_LWO_LSIZ AI_IFF_FOURCC('L', 'S', 'I', 'Z')
+#define AI_LWO_ALPH AI_IFF_FOURCC('A', 'L', 'P', 'H')
+#define AI_LWO_AVAL AI_IFF_FOURCC('A', 'V', 'A', 'L')
+#define AI_LWO_GVAL AI_IFF_FOURCC('G', 'V', 'A', 'L')
+#define AI_LWO_BLOK AI_IFF_FOURCC('B', 'L', 'O', 'K')
+#define AI_LWO_VCOL AI_IFF_FOURCC('V', 'C', 'O', 'L')
+
+/* texture layer */
+#define AI_LWO_TYPE AI_IFF_FOURCC('T', 'Y', 'P', 'E')
+#define AI_LWO_CHAN AI_IFF_FOURCC('C', 'H', 'A', 'N')
+#define AI_LWO_NAME AI_IFF_FOURCC('N', 'A', 'M', 'E')
+#define AI_LWO_ENAB AI_IFF_FOURCC('E', 'N', 'A', 'B')
+#define AI_LWO_OPAC AI_IFF_FOURCC('O', 'P', 'A', 'C')
+#define AI_LWO_FLAG AI_IFF_FOURCC('F', 'L', 'A', 'G')
+#define AI_LWO_PROJ AI_IFF_FOURCC('P', 'R', 'O', 'J')
+#define AI_LWO_STCK AI_IFF_FOURCC('S', 'T', 'C', 'K')
+#define AI_LWO_TAMP AI_IFF_FOURCC('T', 'A', 'M', 'P')
+
+/* texture coordinates */
+#define AI_LWO_TMAP AI_IFF_FOURCC('T', 'M', 'A', 'P')
+#define AI_LWO_AXIS AI_IFF_FOURCC('A', 'X', 'I', 'S')
+#define AI_LWO_CNTR AI_IFF_FOURCC('C', 'N', 'T', 'R')
+#define AI_LWO_SIZE AI_IFF_FOURCC('S', 'I', 'Z', 'E')
+#define AI_LWO_ROTA AI_IFF_FOURCC('R', 'O', 'T', 'A')
+#define AI_LWO_OREF AI_IFF_FOURCC('O', 'R', 'E', 'F')
+#define AI_LWO_FALL AI_IFF_FOURCC('F', 'A', 'L', 'L')
+#define AI_LWO_CSYS AI_IFF_FOURCC('C', 'S', 'Y', 'S')
+
+/* image map */
+#define AI_LWO_IMAP AI_IFF_FOURCC('I', 'M', 'A', 'P')
+#define AI_LWO_IMAG AI_IFF_FOURCC('I', 'M', 'A', 'G')
+#define AI_LWO_WRAP AI_IFF_FOURCC('W', 'R', 'A', 'P')
+#define AI_LWO_WRPW AI_IFF_FOURCC('W', 'R', 'P', 'W')
+#define AI_LWO_WRPH AI_IFF_FOURCC('W', 'R', 'P', 'H')
+#define AI_LWO_VMAP AI_IFF_FOURCC('V', 'M', 'A', 'P')
+#define AI_LWO_AAST AI_IFF_FOURCC('A', 'A', 'S', 'T')
+#define AI_LWO_PIXB AI_IFF_FOURCC('P', 'I', 'X', 'B')
+
+/* procedural */
+#define AI_LWO_PROC AI_IFF_FOURCC('P', 'R', 'O', 'C')
+#define AI_LWO_COLR AI_IFF_FOURCC('C', 'O', 'L', 'R')
+#define AI_LWO_VALU AI_IFF_FOURCC('V', 'A', 'L', 'U')
+#define AI_LWO_FUNC AI_IFF_FOURCC('F', 'U', 'N', 'C')
+#define AI_LWO_FTPS AI_IFF_FOURCC('F', 'T', 'P', 'S')
+#define AI_LWO_ITPS AI_IFF_FOURCC('I', 'T', 'P', 'S')
+#define AI_LWO_ETPS AI_IFF_FOURCC('E', 'T', 'P', 'S')
+
+/* gradient */
+#define AI_LWO_GRAD AI_IFF_FOURCC('G', 'R', 'A', 'D')
+#define AI_LWO_GRST AI_IFF_FOURCC('G', 'R', 'S', 'T')
+#define AI_LWO_GREN AI_IFF_FOURCC('G', 'R', 'E', 'N')
+#define AI_LWO_PNAM AI_IFF_FOURCC('P', 'N', 'A', 'M')
+#define AI_LWO_INAM AI_IFF_FOURCC('I', 'N', 'A', 'M')
+#define AI_LWO_GRPT AI_IFF_FOURCC('G', 'R', 'P', 'T')
+#define AI_LWO_FKEY AI_IFF_FOURCC('F', 'K', 'E', 'Y')
+#define AI_LWO_IKEY AI_IFF_FOURCC('I', 'K', 'E', 'Y')
+
+/* shader */
+#define AI_LWO_SHDR AI_IFF_FOURCC('S', 'H', 'D', 'R')
+#define AI_LWO_DATA AI_IFF_FOURCC('D', 'A', 'T', 'A')
+
+/* VMAP types */
+#define AI_LWO_TXUV AI_IFF_FOURCC('T', 'X', 'U', 'V')
+#define AI_LWO_RGB AI_IFF_FOURCC('R', 'G', 'B', ' ')
+#define AI_LWO_RGBA AI_IFF_FOURCC('R', 'G', 'B', 'A')
+#define AI_LWO_WGHT AI_IFF_FOURCC('W', 'G', 'H', 'T')
+
+#define AI_LWO_MNVW AI_IFF_FOURCC('M', 'N', 'V', 'W')
+#define AI_LWO_MORF AI_IFF_FOURCC('M', 'O', 'R', 'F')
+#define AI_LWO_SPOT AI_IFF_FOURCC('S', 'P', 'O', 'T')
+#define AI_LWO_PICK AI_IFF_FOURCC('P', 'I', 'C', 'K')
+
+// Surface Part
+#define AI_LWO_NODS AI_IFF_FOURCC('N', 'O', 'D', 'S')
+#define AI_LWO_NNDS AI_IFF_FOURCC('N', 'N', 'D', 'S')
+#define AI_LWO_NTAG AI_IFF_FOURCC('N', 'T', 'A', 'G')
+#define AI_LWO_NRNM AI_IFF_FOURCC('N', 'R', 'N', 'M')
+#define AI_LWO_NRME AI_IFF_FOURCC('N', 'R', 'M', 'E')
+#define AI_LWO_NDTA AI_IFF_FOURCC('N', 'D', 'T', 'A')
+#define AI_LWO_ATTR AI_IFF_FOURCC('A', 'T', 'T', 'R')
+#define AI_LWO_VERS AI_IFF_FOURCC('V', 'E', 'R', 'S')
+#define AI_LWO_ENUM AI_IFF_FOURCC('E', 'N', 'U', 'M')
+#define AI_LWO_ENTR AI_IFF_FOURCC('E', 'N', 'T', 'R')
+#define AI_LWO_NAME AI_IFF_FOURCC('N', 'A', 'M', 'E')
+#define AI_LWO_FLAG AI_IFF_FOURCC('F', 'L', 'A', 'G')
+#define AI_LWO_TAG AI_IFF_FOURCC('T', 'A', 'G', ' ')
+#define AI_LWO_VALU AI_IFF_FOURCC('V', 'A', 'L', 'U')
+#define AI_LWO_IBGC AI_IFF_FOURCC('I', 'B', 'G', 'C')
+#define AI_LWO_IOPC AI_IFF_FOURCC('I', 'O', 'P', 'C')
+#define AI_LWO_IIMG AI_IFF_FOURCC('I', 'I', 'M', 'G')
+#define AI_LWO_TXTR AI_IFF_FOURCC('T', 'X', 'T', 'R')
+
+#define AI_LWO_IFAL AI_IFF_FOURCC('I', 'F', 'A', 'L')
+#define AI_LWO_ISCL AI_IFF_FOURCC('I', 'S', 'C', 'L')
+#define AI_LWO_IPOS AI_IFF_FOURCC('I', 'P', 'O', 'S')
+#define AI_LWO_IROT AI_IFF_FOURCC('I', 'R', 'O', 'T')
+#define AI_LWO_IBMP AI_IFF_FOURCC('I', 'B', 'M', 'P')
+#define AI_LWO_IUTD AI_IFF_FOURCC('I', 'U', 'T', 'D')
+#define AI_LWO_IVTD AI_IFF_FOURCC('I', 'V', 'T', 'D')
+
+#define AI_LWO_IPIX AI_IFF_FOURCC('I', 'P', 'I', 'X')
+#define AI_LWO_IMIP AI_IFF_FOURCC('I', 'M', 'I', 'P')
+#define AI_LWO_IMOD AI_IFF_FOURCC('I', 'M', 'O', 'D')
+#define AI_LWO_AMOD AI_IFF_FOURCC('A', 'M', 'O', 'D')
+#define AI_LWO_IINV AI_IFF_FOURCC('I', 'I', 'N', 'V')
+#define AI_LWO_INCR AI_IFF_FOURCC('I', 'N', 'C', 'R')
+#define AI_LWO_IAXS AI_IFF_FOURCC('I', 'A', 'X', 'S')
+#define AI_LWO_IFOT AI_IFF_FOURCC('I', 'F', 'O', 'T')
+#define AI_LWO_ITIM AI_IFF_FOURCC('I', 'T', 'I', 'M')
+#define AI_LWO_IWRL AI_IFF_FOURCC('I', 'W', 'R', 'L')
+#define AI_LWO_IUTI AI_IFF_FOURCC('I', 'U', 'T', 'I')
+#define AI_LWO_IINX AI_IFF_FOURCC('I', 'I', 'N', 'X')
+#define AI_LWO_IINY AI_IFF_FOURCC('I', 'I', 'N', 'Y')
+#define AI_LWO_IINZ AI_IFF_FOURCC('I', 'I', 'N', 'Z')
+#define AI_LWO_IREF AI_IFF_FOURCC('I', 'R', 'E', 'F')
+#define AI_LWO_IMST AI_IFF_FOURCC('I', 'M', 'S', 'T')
+#define AI_LWO_VPVL AI_IFF_FOURCC('V', 'P', 'V', 'L')
+#define AI_LWO_VPRM AI_IFF_FOURCC('V', 'P', 'R', 'M')
+#define AI_LWO_IMAP AI_IFF_FOURCC('I', 'M', 'A', 'P')
+#define AI_LWO_IUVI AI_IFF_FOURCC('I', 'U', 'V', 'I')
+#define AI_LWO_IUTL AI_IFF_FOURCC('I', 'U', 'T', 'L')
+#define AI_LWO_IVTL AI_IFF_FOURCC('I', 'V', 'T', 'L')
+
+// MODO extension - per-vertex normal vectors
+#define AI_LWO_MODO_NORM AI_IFF_FOURCC('N', 'O', 'R', 'M')
+
+// ---------------------------------------------------------------------------
+/** \brief Data structure for a face in a LWO file
+ *
+ * \note We can't use the code in SmoothingGroups.inl here - the mesh
+ *   structures of 3DS/ASE and LWO are too different.
+ */
+struct Face : public aiFace {
+    //! Default construction
+    Face() AI_NO_EXCEPT
+            : surfaceIndex(0),
+              smoothGroup(0),
+              type(AI_LWO_FACE) {
+        // empty
+    }
+
+    //! Construction from given type
+    explicit Face(uint32_t _type) :
+            surfaceIndex(0), smoothGroup(0), type(_type) {}
+
+    //! Copy construction
+    Face(const Face &f) :
+            aiFace() {
+        *this = f;
+    }
+
+    //! Zero-based index into tags chunk
+    unsigned int surfaceIndex;
+
+    //! Smooth group this face is assigned to
+    unsigned int smoothGroup;
+
+    //! Type of face
+    uint32_t type;
+
+    //! Assignment operator
+    Face &operator=(const LWO::Face &f) {
+        aiFace::operator=(f);
+        surfaceIndex = f.surfaceIndex;
+        smoothGroup = f.smoothGroup;
+        type = f.type;
+        return *this;
+    }
+};
+
+// ---------------------------------------------------------------------------
+/** \brief Base structure for all vertex map representations
+ */
+struct VMapEntry {
+    explicit VMapEntry(unsigned int _dims) :
+            dims(_dims) {}
+
+    virtual ~VMapEntry() {}
+
+    //! allocates memory for the vertex map
+    virtual void Allocate(unsigned int num) {
+        if (!rawData.empty())
+            return; // return if already allocated
+
+        const unsigned int m = num * dims;
+        rawData.reserve(m + (m >> 2u)); // 25% as  extra storage for VMADs
+        rawData.resize(m, 0.f);
+        abAssigned.resize(num, false);
+    }
+
+    std::string name;
+    unsigned int dims;
+
+    std::vector<float> rawData;
+    std::vector<bool> abAssigned;
+};
+
+// ---------------------------------------------------------------------------
+/** \brief Represents an extra vertex color channel
+ */
+struct VColorChannel : public VMapEntry {
+    VColorChannel() :
+            VMapEntry(4) {}
+
+    //! need to overwrite this function - the alpha channel must
+    //! be initialized to 1.0 by default
+    virtual void Allocate(unsigned int num) {
+        if (!rawData.empty())
+            return; // return if already allocated
+
+        unsigned int m = num * dims;
+        rawData.reserve(m + (m >> 2u)); // 25% as  extra storage for VMADs
+        rawData.resize(m);
+
+        for (aiColor4D *p = (aiColor4D *)&rawData[0]; p < (aiColor4D *)&rawData[m - 1]; ++p)
+            p->a = 1.f;
+
+        abAssigned.resize(num, false);
+    }
+};
+
+// ---------------------------------------------------------------------------
+/** \brief Represents an extra vertex UV channel
+ */
+struct UVChannel : public VMapEntry {
+    UVChannel() :
+            VMapEntry(2) {}
+};
+
+// ---------------------------------------------------------------------------
+/** \brief Represents a weight map
+ */
+struct WeightChannel : public VMapEntry {
+    WeightChannel() :
+            VMapEntry(1) {}
+};
+
+// ---------------------------------------------------------------------------
+/** \brief Represents a vertex-normals channel (MODO extension)
+ */
+struct NormalChannel : public VMapEntry {
+    NormalChannel() :
+            VMapEntry(3) {}
+};
+
+// ---------------------------------------------------------------------------
+/** \brief Data structure for a LWO file texture
+ */
+struct Texture {
+    // we write the enum values out here to make debugging easier ...
+    enum BlendType {
+        Normal = 0,
+        Subtractive = 1,
+        Difference = 2,
+        Multiply = 3,
+        Divide = 4,
+        Alpha = 5,
+        TextureDispl = 6,
+        Additive = 7
+    };
+
+    enum MappingMode {
+        Planar = 0,
+        Cylindrical = 1,
+        Spherical = 2,
+        Cubic = 3,
+        FrontProjection = 4,
+        UV = 5
+    };
+
+    enum Axes {
+        AXIS_X = 0,
+        AXIS_Y = 1,
+        AXIS_Z = 2
+    };
+
+    enum Wrap {
+        RESET = 0,
+        REPEAT = 1,
+        MIRROR = 2,
+        EDGE = 3
+    };
+
+    Texture() :
+            mClipIdx(UINT_MAX), mStrength(1.0f), type(), mUVChannelIndex("unknown"), mRealUVIndex(UINT_MAX), enabled(true), blendType(Additive), bCanUse(true), mapMode(UV), majorAxis(AXIS_X), wrapAmountH(1.0f), wrapAmountW(1.0f), wrapModeWidth(REPEAT), wrapModeHeight(REPEAT), ordinal("\x00") {}
+
+    //! File name of the texture
+    std::string mFileName;
+
+    //! Clip index
+    unsigned int mClipIdx;
+
+    //! Strength of the texture - blend factor
+    float mStrength;
+
+    uint32_t type; // type of the texture
+
+    //! Name of the corresponding UV channel
+    std::string mUVChannelIndex;
+    unsigned int mRealUVIndex;
+
+    //! is the texture enabled?
+    bool enabled;
+
+    //! blend type
+    BlendType blendType;
+
+    //! are we able to use the texture?
+    bool bCanUse;
+
+    //! mapping mode
+    MappingMode mapMode;
+
+    //! major axis for planar, cylindrical, spherical projections
+    Axes majorAxis;
+
+    //! wrap amount for cylindrical and spherical projections
+    float wrapAmountH, wrapAmountW;
+
+    //! wrapping mode for the texture
+    Wrap wrapModeWidth, wrapModeHeight;
+
+    //! ordinal string of the texture
+    std::string ordinal;
+};
+
+// ---------------------------------------------------------------------------
+/** \brief Data structure for a LWO file clip
+ */
+struct Clip {
+    enum Type {
+        STILL,
+        SEQ,
+        REF,
+        UNSUPPORTED
+    } type;
+
+    Clip() :
+            type(UNSUPPORTED), clipRef(), idx(0), negate(false) {}
+
+    //! path to the base texture -
+    std::string path;
+
+    //! reference to another CLIP
+    unsigned int clipRef;
+
+    //! index of the clip
+    unsigned int idx;
+
+    //! Negate the clip?
+    bool negate;
+};
+
+// ---------------------------------------------------------------------------
+/** \brief Data structure for a LWO file shader
+ *
+ *  Later
+ */
+struct Shader {
+    Shader() :
+            ordinal("\x00"), functionName("unknown"), enabled(true) {}
+
+    std::string ordinal;
+    std::string functionName;
+    bool enabled;
+};
+
+typedef std::list<Texture> TextureList;
+typedef std::list<Shader> ShaderList;
+
+// ---------------------------------------------------------------------------
+/** \brief Data structure for a LWO file surface (= material)
+ */
+struct Surface {
+    Surface() :
+            mColor(0.78431f, 0.78431f, 0.78431f), bDoubleSided(false), mDiffuseValue(1.f), mSpecularValue(0.f), mTransparency(0.f), mGlossiness(0.4f), mLuminosity(0.f), mColorHighlights(0.f), mMaximumSmoothAngle(0.f) // 0 == not specified, no smoothing
+            ,
+            mVCMap(),
+            mVCMapType(AI_LWO_RGBA),
+            mIOR(1.f) // vakuum
+            ,
+            mBumpIntensity(1.f),
+            mWireframe(false),
+            mAdditiveTransparency(0.f) {}
+
+    //! Name of the surface
+    std::string mName;
+
+    //! Color of the surface
+    aiColor3D mColor;
+
+    //! true for two-sided materials
+    bool bDoubleSided;
+
+    //! Various material parameters
+    float mDiffuseValue, mSpecularValue, mTransparency, mGlossiness, mLuminosity, mColorHighlights;
+
+    //! Maximum angle between two adjacent triangles
+    //! that they can be smoothed - in degrees
+    float mMaximumSmoothAngle;
+
+    //! Vertex color map to be used to color the surface
+    std::string mVCMap;
+    uint32_t mVCMapType;
+
+    //! Names of the special shaders to be applied to the surface
+    ShaderList mShaders;
+
+    //! Textures - the first entry in the list is evaluated first
+    TextureList mColorTextures, // color textures are added to both diffuse and specular texture stacks
+            mDiffuseTextures,
+            mSpecularTextures,
+            mOpacityTextures,
+            mBumpTextures,
+            mGlossinessTextures,
+            mReflectionTextures;
+
+    //! Index of refraction
+    float mIOR;
+
+    //! Bump intensity scaling
+    float mBumpIntensity;
+
+    //! Wireframe flag
+    bool mWireframe;
+
+    //! Intensity of additive blending
+    float mAdditiveTransparency;
+};
+
+// ---------------------------------------------------------------------------
+/** \brief Data structure for a LWO node
+ */
+struct Node {
+    // Name of node
+    std::string mName;
+
+    // RefName of node
+    std::string mRefName;
+
+    // Ref FileName
+    std::string fileName;
+};
+
+struct NodeAttribute {
+    //! Color of the surface
+    aiColor3D mColor;
+
+    //! true for two-sided materials
+    bool bDoubleSided;
+
+    //! Various material parameters
+    float mDiffuseValue, mSpecularValue, mTransparency, mGlossiness, mLuminosity, mColorHighlights;
+};
+
+// ---------------------------------------------------------------------------
+#define AI_LWO_VALIDATE_CHUNK_LENGTH(length, name, size)              \
+    if (length < size) {                                              \
+        throw DeadlyImportError("LWO: " #name " chunk is too small"); \
+    }
+
+// some typedefs ... to make life with loader monsters like this easier
+typedef std::vector<aiVector3D> PointList;
+typedef std::vector<LWO::Face> FaceList;
+typedef std::vector<LWO::Surface> SurfaceList;
+typedef std::vector<std::string> TagList;
+typedef std::vector<unsigned int> TagMappingTable;
+typedef std::vector<unsigned int> ReferrerList;
+typedef std::vector<WeightChannel> WeightChannelList;
+typedef std::vector<VColorChannel> VColorChannelList;
+typedef std::vector<UVChannel> UVChannelList;
+typedef std::vector<Clip> ClipList;
+typedef std::vector<Envelope> EnvelopeList;
+typedef std::vector<unsigned int> SortedRep;
+
+// ---------------------------------------------------------------------------
+/** \brief Represents a layer in the file
+ */
+struct Layer {
+    Layer() :
+            mFaceIDXOfs(0), mPointIDXOfs(0), mParent(0x0), mIndex(0xffff), skip(false) {}
+
+    /** Temporary point list from the file */
+    PointList mTempPoints;
+
+    /** Lists for every point the index of another point
+        that has been copied from *this* point or UINT_MAX if
+        no copy of the point has been made */
+    ReferrerList mPointReferrers;
+
+    /** Weight channel list from the file */
+    WeightChannelList mWeightChannels;
+
+    /** Subdivision weight channel list from the file */
+    WeightChannelList mSWeightChannels;
+
+    /** Vertex color list from the file */
+    VColorChannelList mVColorChannels;
+
+    /** UV channel list from the file */
+    UVChannelList mUVChannels;
+
+    /** Normal vector channel from the file */
+    NormalChannel mNormals;
+
+    /** Temporary face list from the file*/
+    FaceList mFaces;
+
+    /** Current face indexing offset from the beginning of the buffers*/
+    unsigned int mFaceIDXOfs;
+
+    /** Current point indexing offset from the beginning of the buffers*/
+    unsigned int mPointIDXOfs;
+
+    /** Parent index */
+    uint16_t mParent;
+
+    /** Index of the layer */
+    uint16_t mIndex;
+
+    /** Name of the layer */
+    std::string mName;
+
+    /** Pivot point of the layer */
+    aiVector3D mPivot;
+
+    /** Skip this layer? */
+    bool skip;
+};
+
+typedef std::list<LWO::Layer> LayerList;
+
+} // namespace LWO
+} // namespace Assimp
+
+#endif // !! AI_LWO_FILEDATA_INCLUDED
diff --git a/Engine/lib/assimp/code/AssetLib/LWO/LWOLoader.cpp b/Engine/lib/assimp/code/AssetLib/LWO/LWOLoader.cpp
new file mode 100644
index 000000000..c4e85bc50
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/LWO/LWOLoader.cpp
@@ -0,0 +1,1618 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file  LWOLoader.cpp
+ *  @brief Implementation of the LWO importer class
+ */
+
+#ifndef ASSIMP_BUILD_NO_LWO_IMPORTER
+
+// internal headers
+#include "AssetLib/LWO/LWOLoader.h"
+#include "PostProcessing/ConvertToLHProcess.h"
+#include "PostProcessing/ProcessHelper.h"
+
+#include <assimp/ByteSwapper.h>
+#include <assimp/SGSpatialSort.h>
+#include <assimp/StringComparison.h>
+#include <assimp/importerdesc.h>
+#include <assimp/IOSystem.hpp>
+
+#include <iomanip>
+#include <map>
+#include <memory>
+#include <sstream>
+
+using namespace Assimp;
+
+static const aiImporterDesc desc = {
+    "LightWave/Modo Object Importer",
+    "",
+    "",
+    "https://www.lightwave3d.com/lightwave_sdk/",
+    aiImporterFlags_SupportTextFlavour,
+    0,
+    0,
+    0,
+    0,
+    "lwo lxo"
+};
+
+// ------------------------------------------------------------------------------------------------
+// Constructor to be privately used by Importer
+LWOImporter::LWOImporter() :
+        mIsLWO2(),
+        mIsLXOB(),
+        mIsLWO3(),
+        mLayers(),
+        mCurLayer(),
+        mTags(),
+        mMapping(),
+        mSurfaces(),
+        mFileBuffer(),
+        fileSize(),
+        mScene(nullptr),
+        configSpeedFlag(),
+        configLayerIndex(),
+        hasNamedLayer() {
+    // empty
+}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor, private as well
+LWOImporter::~LWOImporter() {
+    // empty
+}
+
+// ------------------------------------------------------------------------------------------------
+// Returns whether the class can handle the format of the given file.
+bool LWOImporter::CanRead(const std::string &file, IOSystem *pIOHandler, bool /*checkSig*/) const {
+    static const uint32_t tokens[] = {
+        AI_LWO_FOURCC_LWOB,
+        AI_LWO_FOURCC_LWO2,
+        AI_LWO_FOURCC_LXOB
+    };
+    return CheckMagicToken(pIOHandler, file, tokens, AI_COUNT_OF(tokens), 8);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Setup configuration properties
+void LWOImporter::SetupProperties(const Importer *pImp) {
+    configSpeedFlag = (0 != pImp->GetPropertyInteger(AI_CONFIG_FAVOUR_SPEED, 0) ? true : false);
+    configLayerIndex = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY, UINT_MAX);
+    configLayerName = pImp->GetPropertyString(AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY, "");
+}
+
+// ------------------------------------------------------------------------------------------------
+// Get list of file extensions
+const aiImporterDesc *LWOImporter::GetInfo() const {
+    return &desc;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Imports the given file into the given scene structure.
+void LWOImporter::InternReadFile(const std::string &pFile,
+        aiScene *pScene,
+        IOSystem *pIOHandler) {
+    std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));
+
+    // Check whether we can read from the file
+    if (file.get() == nullptr) {
+        throw DeadlyImportError("Failed to open LWO file ", pFile, ".");
+    }
+
+    if ((this->fileSize = (unsigned int)file->FileSize()) < 12) {
+        throw DeadlyImportError("LWO: The file is too small to contain the IFF header");
+    }
+
+    // Allocate storage and copy the contents of the file to a memory buffer
+    std::vector<uint8_t> mBuffer(fileSize);
+    file->Read(&mBuffer[0], 1, fileSize);
+    mScene = pScene;
+
+    // Determine the type of the file
+    uint32_t fileType;
+    const char *sz = IFF::ReadHeader(&mBuffer[0], fileType);
+    if (sz) {
+        throw DeadlyImportError(sz);
+    }
+
+    mFileBuffer = &mBuffer[0] + 12;
+    fileSize -= 12;
+
+    // Initialize some members with their default values
+    hasNamedLayer = false;
+
+    // Create temporary storage on the stack but store pointers to it in the class
+    // instance. Therefore everything will be destructed properly if an exception
+    // is thrown and we needn't take care of that.
+    LayerList _mLayers;
+    SurfaceList _mSurfaces;
+    TagList _mTags;
+    TagMappingTable _mMapping;
+
+    mLayers = &_mLayers;
+    mTags = &_mTags;
+    mMapping = &_mMapping;
+    mSurfaces = &_mSurfaces;
+
+    // Allocate a default layer (layer indices are 1-based from now)
+    mLayers->push_back(Layer());
+    mCurLayer = &mLayers->back();
+    mCurLayer->mName = "<LWODefault>";
+    mCurLayer->mIndex = (uint16_t) -1;
+
+    // old lightwave file format (prior to v6)
+    mIsLWO2 = false;
+    mIsLWO3 = false;
+    mIsLXOB = false;
+
+    if (AI_LWO_FOURCC_LWOB == fileType) {
+        ASSIMP_LOG_INFO("LWO file format: LWOB (<= LightWave 5.5)");
+
+        LoadLWOBFile();
+    } else if (AI_LWO_FOURCC_LWO2 == fileType) {
+        // New lightwave format
+        ASSIMP_LOG_INFO("LWO file format: LWO2 (>= LightWave 6)");
+    } else if ( AI_LWO_FOURCC_LWO3 == fileType ) {
+        ASSIMP_LOG_INFO("LWO file format: LWO3 (>= LightWave 2018)");
+    } else if (AI_LWO_FOURCC_LXOB == fileType) {
+        // MODO file format
+        mIsLXOB = true;
+        ASSIMP_LOG_INFO("LWO file format: LXOB (Modo)");
+    }
+    else {
+        char szBuff[5];
+        szBuff[0] = (char)(fileType >> 24u);
+        szBuff[1] = (char)(fileType >> 16u);
+        szBuff[2] = (char)(fileType >> 8u);
+        szBuff[3] = (char)(fileType);
+        szBuff[4] = '\0';
+        throw DeadlyImportError("Unknown LWO sub format: ", szBuff);
+    }
+
+    if (AI_LWO_FOURCC_LWOB != fileType) {   //
+        if( AI_LWO_FOURCC_LWO3 == fileType ) {
+            mIsLWO3 = true;
+        } else {
+            mIsLWO2 = true;
+        }
+        
+        LoadLWO2File();
+
+        // The newer lightwave format allows the user to configure the
+        // loader that just one layer is used. If this is the case
+        // we need to check now whether the requested layer has been found.
+        if (UINT_MAX != configLayerIndex) {
+            unsigned int layerCount = 0;
+            for (std::list<LWO::Layer>::iterator itLayers = mLayers->begin(); itLayers != mLayers->end(); ++itLayers)
+                if (!itLayers->skip)
+                    layerCount++;
+            if (layerCount != 2)
+                throw DeadlyImportError("LWO2: The requested layer was not found");
+        }
+
+        if (configLayerName.length() && !hasNamedLayer) {
+            throw DeadlyImportError("LWO2: Unable to find the requested layer: ", configLayerName);
+        }
+    }
+
+    // now, as we have loaded all data, we can resolve cross-referenced tags and clips
+    ResolveTags();
+    ResolveClips();
+
+    // now process all layers and build meshes and nodes
+    std::vector<aiMesh *> apcMeshes;
+    std::map<uint16_t, aiNode *> apcNodes;
+
+    apcMeshes.reserve(mLayers->size() * std::min(((unsigned int)mSurfaces->size() / 2u), 1u));
+
+    unsigned int iDefaultSurface = UINT_MAX; // index of the default surface
+    for (LWO::Layer &layer : *mLayers) {
+        if (layer.skip)
+            continue;
+
+        // I don't know whether there could be dummy layers, but it would be possible
+        const unsigned int meshStart = (unsigned int)apcMeshes.size();
+        if (!layer.mFaces.empty() && !layer.mTempPoints.empty()) {
+
+            // now sort all faces by the surfaces assigned to them
+            std::vector<SortedRep> pSorted(mSurfaces->size() + 1);
+
+            unsigned int i = 0;
+            for (FaceList::iterator it = layer.mFaces.begin(), end = layer.mFaces.end(); it != end; ++it, ++i) {
+                // Check whether we support this face's type
+                if ((*it).type != AI_LWO_FACE && (*it).type != AI_LWO_PTCH &&
+                        (*it).type != AI_LWO_BONE && (*it).type != AI_LWO_SUBD) {
+                    continue;
+                }
+
+                unsigned int idx = (*it).surfaceIndex;
+                if (idx >= mTags->size()) {
+                    ASSIMP_LOG_WARN("LWO: Invalid face surface index");
+                    idx = UINT_MAX;
+                }
+                if (UINT_MAX == idx || UINT_MAX == (idx = _mMapping[idx])) {
+                    if (UINT_MAX == iDefaultSurface) {
+                        iDefaultSurface = (unsigned int)mSurfaces->size();
+                        mSurfaces->push_back(LWO::Surface());
+                        LWO::Surface &surf = mSurfaces->back();
+                        surf.mColor.r = surf.mColor.g = surf.mColor.b = 0.6f;
+                        surf.mName = "LWODefaultSurface";
+                    }
+                    idx = iDefaultSurface;
+                }
+                pSorted[idx].push_back(i);
+            }
+            if (UINT_MAX == iDefaultSurface) {
+                pSorted.erase(pSorted.end() - 1);
+            }
+            for (unsigned int p = 0, j = 0; j < mSurfaces->size(); ++j) {
+                SortedRep &sorted = pSorted[j];
+                if (sorted.empty())
+                    continue;
+
+                // generate the mesh
+                aiMesh *mesh = new aiMesh();
+                apcMeshes.push_back(mesh);
+                mesh->mNumFaces = (unsigned int)sorted.size();
+
+                // count the number of vertices
+                SortedRep::const_iterator it = sorted.begin(), end = sorted.end();
+                for (; it != end; ++it) {
+                    mesh->mNumVertices += layer.mFaces[*it].mNumIndices;
+                }
+
+                aiVector3D *nrm = nullptr, *pv = mesh->mVertices = new aiVector3D[mesh->mNumVertices];
+                aiFace *pf = mesh->mFaces = new aiFace[mesh->mNumFaces];
+                mesh->mMaterialIndex = j;
+
+                // find out which vertex color channels and which texture coordinate
+                // channels are really required by the material attached to this mesh
+                unsigned int vUVChannelIndices[AI_MAX_NUMBER_OF_TEXTURECOORDS];
+                unsigned int vVColorIndices[AI_MAX_NUMBER_OF_COLOR_SETS];
+
+#ifdef ASSIMP_BUILD_DEBUG
+                for (unsigned int mui = 0; mui < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++mui) {
+                    vUVChannelIndices[mui] = UINT_MAX;
+                }
+                for (unsigned int mui = 0; mui < AI_MAX_NUMBER_OF_COLOR_SETS; ++mui) {
+                    vVColorIndices[mui] = UINT_MAX;
+                }
+#endif
+
+                FindUVChannels(_mSurfaces[j], sorted, layer, vUVChannelIndices);
+                FindVCChannels(_mSurfaces[j], sorted, layer, vVColorIndices);
+
+                // allocate storage for UV and CV channels
+                aiVector3D *pvUV[AI_MAX_NUMBER_OF_TEXTURECOORDS];
+                for (unsigned int mui = 0; mui < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++mui) {
+                    if (UINT_MAX == vUVChannelIndices[mui]) {
+                        break;
+                    }
+
+                    pvUV[mui] = mesh->mTextureCoords[mui] = new aiVector3D[mesh->mNumVertices];
+
+                    // LightWave doesn't support more than 2 UV components (?)
+                    mesh->mNumUVComponents[0] = 2;
+                }
+
+                if (layer.mNormals.name.length()) {
+                    nrm = mesh->mNormals = new aiVector3D[mesh->mNumVertices];
+                }
+
+                aiColor4D *pvVC[AI_MAX_NUMBER_OF_COLOR_SETS];
+                for (unsigned int mui = 0; mui < AI_MAX_NUMBER_OF_COLOR_SETS; ++mui) {
+                    if (UINT_MAX == vVColorIndices[mui]) {
+                        break;
+                    }
+                    pvVC[mui] = mesh->mColors[mui] = new aiColor4D[mesh->mNumVertices];
+                }
+
+                // we would not need this extra array, but the code is much cleaner if we use it
+                std::vector<unsigned int> &smoothingGroups = layer.mPointReferrers;
+                smoothingGroups.erase(smoothingGroups.begin(), smoothingGroups.end());
+                smoothingGroups.resize(mesh->mNumFaces, 0);
+
+                // now convert all faces
+                unsigned int vert = 0;
+                std::vector<unsigned int>::iterator outIt = smoothingGroups.begin();
+                for (it = sorted.begin(); it != end; ++it, ++outIt) {
+                    const LWO::Face &face = layer.mFaces[*it];
+                    *outIt = face.smoothGroup;
+
+                    // copy all vertices
+                    for (unsigned int q = 0; q < face.mNumIndices; ++q, ++vert) {
+                        unsigned int idx = face.mIndices[q];
+                        *pv++ = layer.mTempPoints[idx] /*- layer.mPivot*/;
+
+                        // process UV coordinates
+                        for (unsigned int w = 0; w < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++w) {
+                            if (UINT_MAX == vUVChannelIndices[w]) {
+                                break;
+                            }
+                            aiVector3D *&pp = pvUV[w];
+                            const aiVector2D &src = ((aiVector2D *)&layer.mUVChannels[vUVChannelIndices[w]].rawData[0])[idx];
+                            pp->x = src.x;
+                            pp->y = src.y;
+                            pp++;
+                        }
+
+                        // process normals (MODO extension)
+                        if (nrm) {
+                            *nrm = ((aiVector3D *)&layer.mNormals.rawData[0])[idx];
+                            nrm->z *= -1.f;
+                            ++nrm;
+                        }
+
+                        // process vertex colors
+                        for (unsigned int w = 0; w < AI_MAX_NUMBER_OF_COLOR_SETS; ++w) {
+                            if (UINT_MAX == vVColorIndices[w]) {
+                                break;
+                            }
+                            *pvVC[w] = ((aiColor4D *)&layer.mVColorChannels[vVColorIndices[w]].rawData[0])[idx];
+
+                            // If a RGB color map is explicitly requested delete the
+                            // alpha channel - it could theoretically be != 1.
+                            if (_mSurfaces[j].mVCMapType == AI_LWO_RGB)
+                                pvVC[w]->a = 1.f;
+
+                            pvVC[w]++;
+                        }
+
+#if 0
+                        // process vertex weights. We can't properly reconstruct the whole skeleton for now,
+                        // but we can create dummy bones for all weight channels which we have.
+                        for (unsigned int w = 0; w < layer.mWeightChannels.size();++w)
+                        {
+                        }
+#endif
+
+                        face.mIndices[q] = vert;
+                    }
+                    pf->mIndices = face.mIndices;
+                    pf->mNumIndices = face.mNumIndices;
+                    unsigned int **facePtr = (unsigned int **)&face.mIndices;
+                    *facePtr = nullptr; // HACK: make sure it won't be deleted
+                    pf++;
+                }
+
+                if (!mesh->mNormals) {
+                    // Compute normal vectors for the mesh - we can't use our GenSmoothNormal-
+                    // Step here since it wouldn't handle smoothing groups correctly for LWO.
+                    // So we use a separate implementation.
+                    ComputeNormals(mesh, smoothingGroups, _mSurfaces[j]);
+                } else {
+                    ASSIMP_LOG_VERBOSE_DEBUG("LWO2: No need to compute normals, they're already there");
+                }
+                ++p;
+            }
+        }
+
+        // Generate nodes to render the mesh. Store the source layer in the mParent member of the nodes
+        unsigned int num = static_cast<unsigned int>(apcMeshes.size() - meshStart);
+        if (layer.mName != "<LWODefault>" || num > 0) {
+            aiNode *pcNode = new aiNode();
+            pcNode->mName.Set(layer.mName);
+            pcNode->mParent = (aiNode *)&layer;
+            pcNode->mNumMeshes = num;
+
+            if (pcNode->mNumMeshes) {
+                pcNode->mMeshes = new unsigned int[pcNode->mNumMeshes];
+                for (unsigned int p = 0; p < pcNode->mNumMeshes; ++p)
+                    pcNode->mMeshes[p] = p + meshStart;
+            }
+            apcNodes[layer.mIndex] = pcNode;
+        }
+    }
+
+    if (apcNodes.empty() || apcMeshes.empty())
+        throw DeadlyImportError("LWO: No meshes loaded");
+
+    // The RemoveRedundantMaterials step will clean this up later
+    pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials = (unsigned int)mSurfaces->size()];
+
+    for (unsigned int mat = 0; mat < pScene->mNumMaterials; ++mat) {
+        aiMaterial *pcMat = new aiMaterial();
+        pScene->mMaterials[mat] = pcMat;
+        ConvertMaterial((*mSurfaces)[mat], pcMat);
+    }
+
+    // copy the meshes to the output structure
+    pScene->mMeshes = new aiMesh *[pScene->mNumMeshes = (unsigned int)apcMeshes.size()];
+    ::memcpy(pScene->mMeshes, &apcMeshes[0], pScene->mNumMeshes * sizeof(void *));
+
+    // generate the final node graph
+    GenerateNodeGraph(apcNodes);
+}
+
+// ------------------------------------------------------------------------------------------------
+void LWOImporter::ComputeNormals(aiMesh *mesh, const std::vector<unsigned int> &smoothingGroups,
+        const LWO::Surface &surface) {
+    // Allocate output storage
+    mesh->mNormals = new aiVector3D[mesh->mNumVertices];
+
+    // First generate per-face normals
+    aiVector3D *out;
+    std::vector<aiVector3D> faceNormals;
+
+    // ... in some cases that's already enough
+    if (!surface.mMaximumSmoothAngle)
+        out = mesh->mNormals;
+    else {
+        faceNormals.resize(mesh->mNumVertices);
+        out = &faceNormals[0];
+    }
+
+    aiFace *begin = mesh->mFaces, *const end = mesh->mFaces + mesh->mNumFaces;
+    for (; begin != end; ++begin) {
+        aiFace &face = *begin;
+
+        if (face.mNumIndices < 3) {
+            continue;
+        }
+
+        // LWO doc: "the normal is defined as the cross product of the first and last edges"
+        aiVector3D *pV1 = mesh->mVertices + face.mIndices[0];
+        aiVector3D *pV2 = mesh->mVertices + face.mIndices[1];
+        aiVector3D *pV3 = mesh->mVertices + face.mIndices[face.mNumIndices - 1];
+
+        aiVector3D vNor = ((*pV2 - *pV1) ^ (*pV3 - *pV1)).Normalize();
+        for (unsigned int i = 0; i < face.mNumIndices; ++i)
+            out[face.mIndices[i]] = vNor;
+    }
+    if (!surface.mMaximumSmoothAngle) return;
+    const float posEpsilon = ComputePositionEpsilon(mesh);
+
+    // Now generate the spatial sort tree
+    SGSpatialSort sSort;
+    std::vector<unsigned int>::const_iterator it = smoothingGroups.begin();
+    for (begin = mesh->mFaces; begin != end; ++begin, ++it) {
+        aiFace &face = *begin;
+        for (unsigned int i = 0; i < face.mNumIndices; ++i) {
+            unsigned int tt = face.mIndices[i];
+            sSort.Add(mesh->mVertices[tt], tt, *it);
+        }
+    }
+    // Sort everything - this takes O(nlogn) time
+    sSort.Prepare();
+    std::vector<unsigned int> poResult;
+    poResult.reserve(20);
+
+    // Generate vertex normals. We have O(logn) for the binary lookup, which we need
+    // for n elements, thus the EXPECTED complexity is O(nlogn)
+    if (surface.mMaximumSmoothAngle < 3.f && !configSpeedFlag) {
+        const float fLimit = std::cos(surface.mMaximumSmoothAngle);
+
+        for (begin = mesh->mFaces, it = smoothingGroups.begin(); begin != end; ++begin, ++it) {
+            const aiFace &face = *begin;
+            unsigned int *beginIdx = face.mIndices, *const endIdx = face.mIndices + face.mNumIndices;
+            for (; beginIdx != endIdx; ++beginIdx) {
+                unsigned int idx = *beginIdx;
+                sSort.FindPositions(mesh->mVertices[idx], *it, posEpsilon, poResult, true);
+
+                aiVector3D vNormals;
+                 for (std::vector<unsigned int>::const_iterator a = poResult.begin(); a != poResult.end(); ++a) {
+                    const aiVector3D &v = faceNormals[*a];
+                    if (v * faceNormals[idx] < fLimit)
+                        continue;
+                    vNormals += v;
+                }
+                mesh->mNormals[idx] = vNormals.Normalize();
+            }
+        }
+    }
+    // faster code path in case there is no smooth angle
+    else {
+        std::vector<bool> vertexDone(mesh->mNumVertices, false);
+        for (begin = mesh->mFaces, it = smoothingGroups.begin(); begin != end; ++begin, ++it) {
+            const aiFace &face = *begin;
+            unsigned int *beginIdx = face.mIndices, *const endIdx = face.mIndices + face.mNumIndices;
+            for (; beginIdx != endIdx; ++beginIdx) {
+                unsigned int idx = *beginIdx;
+                if (vertexDone[idx])
+                    continue;
+                sSort.FindPositions(mesh->mVertices[idx], *it, posEpsilon, poResult, true);
+
+                aiVector3D vNormals;
+                 for (std::vector<unsigned int>::const_iterator a = poResult.begin(); a != poResult.end(); ++a) {
+                    const aiVector3D &v = faceNormals[*a];
+                    vNormals += v;
+                }
+                vNormals.Normalize();
+                for (std::vector<unsigned int>::const_iterator a = poResult.begin(); a != poResult.end(); ++a) {
+                    mesh->mNormals[*a] = vNormals;
+                    vertexDone[*a] = true;
+                }
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void LWOImporter::GenerateNodeGraph(std::map<uint16_t, aiNode *> &apcNodes) {
+    // now generate the final nodegraph - generate a root node and attach children
+    aiNode *root = mScene->mRootNode = new aiNode();
+    root->mName.Set("<LWORoot>");
+
+    //Set parent of all children, inserting pivots
+    std::map<uint16_t, aiNode *> mapPivot;
+    for (auto itapcNodes = apcNodes.begin(); itapcNodes != apcNodes.end(); ++itapcNodes) {
+
+        //Get the parent index
+        LWO::Layer *nodeLayer = (LWO::Layer *)(itapcNodes->second->mParent);
+        uint16_t parentIndex = nodeLayer->mParent;
+
+        //Create pivot node, store it into the pivot map, and set the parent as the pivot
+        aiNode *pivotNode = new aiNode();
+        pivotNode->mName.Set("Pivot-" + std::string(itapcNodes->second->mName.data));
+        itapcNodes->second->mParent = pivotNode;
+
+        //Look for the parent node to attach the pivot to
+        if (apcNodes.find(parentIndex) != apcNodes.end()) {
+            pivotNode->mParent = apcNodes[parentIndex];
+        } else {
+            //If not, attach to the root node
+            pivotNode->mParent = root;
+        }
+
+        //Set the node and the pivot node transformation
+        itapcNodes->second->mTransformation.a4 = -nodeLayer->mPivot.x;
+        itapcNodes->second->mTransformation.b4 = -nodeLayer->mPivot.y;
+        itapcNodes->second->mTransformation.c4 = -nodeLayer->mPivot.z;
+        pivotNode->mTransformation.a4 = nodeLayer->mPivot.x;
+        pivotNode->mTransformation.b4 = nodeLayer->mPivot.y;
+        pivotNode->mTransformation.c4 = nodeLayer->mPivot.z;
+        mapPivot[-(itapcNodes->first + 2)] = pivotNode;
+    }
+
+    //Merge pivot map into node map
+    for (auto itMapPivot = mapPivot.begin(); itMapPivot != mapPivot.end(); ++itMapPivot) {
+        apcNodes[itMapPivot->first] = itMapPivot->second;
+    }
+
+    //Set children of all parents
+    apcNodes[(uint16_t)-1] = root;
+    for (auto itMapParentNodes = apcNodes.begin(); itMapParentNodes != apcNodes.end(); ++itMapParentNodes) {
+        for (auto itMapChildNodes = apcNodes.begin(); itMapChildNodes != apcNodes.end(); ++itMapChildNodes) {
+            if ((itMapParentNodes->first != itMapChildNodes->first) && (itMapParentNodes->second == itMapChildNodes->second->mParent)) {
+                ++(itMapParentNodes->second->mNumChildren);
+            }
+        }
+        if (itMapParentNodes->second->mNumChildren) {
+            itMapParentNodes->second->mChildren = new aiNode *[itMapParentNodes->second->mNumChildren];
+            uint16_t p = 0;
+            for (auto itMapChildNodes = apcNodes.begin(); itMapChildNodes != apcNodes.end(); ++itMapChildNodes) {
+                if ((itMapParentNodes->first != itMapChildNodes->first) && (itMapParentNodes->second == itMapChildNodes->second->mParent)) {
+                    itMapParentNodes->second->mChildren[p++] = itMapChildNodes->second;
+                }
+            }
+        }
+    }
+
+    if (!mScene->mRootNode->mNumChildren)
+        throw DeadlyImportError("LWO: Unable to build a valid node graph");
+
+    // Remove a single root node with no meshes assigned to it ...
+    if (1 == mScene->mRootNode->mNumChildren) {
+        aiNode *pc = mScene->mRootNode->mChildren[0];
+        pc->mParent = mScene->mRootNode->mChildren[0] = nullptr;
+        delete mScene->mRootNode;
+        mScene->mRootNode = pc;
+    }
+
+    // convert the whole stuff to RH with CCW winding
+    MakeLeftHandedProcess maker;
+    maker.Execute(mScene);
+
+    FlipWindingOrderProcess flipper;
+    flipper.Execute(mScene);
+}
+
+// ------------------------------------------------------------------------------------------------
+void LWOImporter::ResolveTags() {
+    // --- this function is used for both LWO2 and LWOB
+    mMapping->resize(mTags->size(), UINT_MAX);
+    for (unsigned int a = 0; a < mTags->size(); ++a) {
+
+        const std::string &c = (*mTags)[a];
+        for (unsigned int i = 0; i < mSurfaces->size(); ++i) {
+
+            const std::string &d = (*mSurfaces)[i].mName;
+            if (!ASSIMP_stricmp(c, d)) {
+
+                (*mMapping)[a] = i;
+                break;
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void LWOImporter::ResolveClips() {
+    for (unsigned int i = 0; i < mClips.size(); ++i) {
+
+        Clip &clip = mClips[i];
+        if (Clip::REF == clip.type) {
+
+            if (clip.clipRef >= mClips.size()) {
+                ASSIMP_LOG_ERROR("LWO2: Clip referrer index is out of range");
+                clip.clipRef = 0;
+            }
+
+            Clip &dest = mClips[clip.clipRef];
+            if (Clip::REF == dest.type) {
+                ASSIMP_LOG_ERROR("LWO2: Clip references another clip reference");
+                clip.type = Clip::UNSUPPORTED;
+            }
+
+            else {
+                clip.path = dest.path;
+                clip.type = dest.type;
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void LWOImporter::AdjustTexturePath(std::string &out) {
+    // --- this function is used for both LWO2 and LWOB
+    if (!mIsLWO2 && !mIsLWO3 && ::strstr(out.c_str(), "(sequence)")) {
+
+        // remove the (sequence) and append 000
+        ASSIMP_LOG_INFO("LWOB: Sequence of animated texture found. It will be ignored");
+        out = out.substr(0, out.length() - 10) + "000";
+    }
+
+    // format: drive:path/file - we just need to insert a slash after the drive
+    std::string::size_type n = out.find_first_of(':');
+    if (std::string::npos != n) {
+        out.insert(n + 1, "/");
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void LWOImporter::LoadLWOTags(unsigned int size) {
+    // --- this function is used for both LWO2 and LWOB
+
+    const char *szCur = (const char *)mFileBuffer, *szLast = szCur;
+    const char *const szEnd = szLast + size;
+    while (szCur < szEnd) {
+        if (!(*szCur)) {
+            const size_t len = (size_t)(szCur - szLast);
+            // FIX: skip empty-sized tags
+            if (len)
+                mTags->push_back(std::string(szLast, len));
+            szCur += (len & 0x1 ? 1 : 2);
+            szLast = szCur;
+        }
+        szCur++;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void LWOImporter::LoadLWOPoints(unsigned int length) {
+    // --- this function is used for both LWO2 and LWOB but for
+    // LWO2 we need to allocate 25% more storage - it could be we'll
+    // need to duplicate some points later.
+    const size_t vertexLen = 12;
+    if ((length % vertexLen) != 0) {
+        throw DeadlyImportError("LWO2: Points chunk length is not multiple of vertexLen (12)");
+    }
+    unsigned int regularSize = (unsigned int)mCurLayer->mTempPoints.size() + length / 12;
+    if (mIsLWO2 || mIsLWO3) {
+        mCurLayer->mTempPoints.reserve(regularSize + (regularSize >> 2u));
+        mCurLayer->mTempPoints.resize(regularSize);
+
+        // initialize all point referrers with the default values
+        mCurLayer->mPointReferrers.reserve(regularSize + (regularSize >> 2u));
+        mCurLayer->mPointReferrers.resize(regularSize, UINT_MAX);
+    } else
+        mCurLayer->mTempPoints.resize(regularSize);
+
+        // perform endianness conversions
+#ifndef AI_BUILD_BIG_ENDIAN
+    for (unsigned int i = 0; i<length >> 2; ++i)
+        ByteSwap::Swap4(mFileBuffer + (i << 2));
+#endif
+    ::memcpy(&mCurLayer->mTempPoints[0], mFileBuffer, length);
+}
+
+// ------------------------------------------------------------------------------------------------
+void LWOImporter::LoadLWO2Polygons(unsigned int length) {
+    LE_NCONST uint16_t *const end = (LE_NCONST uint16_t *)(mFileBuffer + length);
+    const uint32_t type = GetU4();
+
+    // Determine the type of the polygons
+    switch (type) {
+            // read unsupported stuff too (although we won't process it)
+        case AI_LWO_MBAL:
+            ASSIMP_LOG_WARN("LWO2: Encountered unsupported primitive chunk (METABALL)");
+            break;
+        case AI_LWO_CURV:
+            ASSIMP_LOG_WARN("LWO2: Encountered unsupported primitive chunk (SPLINE)");
+            ;
+            break;
+
+            // These are ok with no restrictions
+        case AI_LWO_PTCH:
+        case AI_LWO_FACE:
+        case AI_LWO_BONE:
+        case AI_LWO_SUBD:
+            break;
+        default:
+
+            // hm!? wtf is this? ok ...
+            ASSIMP_LOG_ERROR("LWO2: Ignoring unknown polygon type.");
+            break;
+    }
+
+    // first find out how many faces and vertices we'll finally need
+    uint16_t *cursor = (uint16_t *)mFileBuffer;
+
+    unsigned int iNumFaces = 0, iNumVertices = 0;
+    CountVertsAndFacesLWO2(iNumVertices, iNumFaces, cursor, end);
+
+    // allocate the output array and copy face indices
+    if (iNumFaces) {
+        cursor = (uint16_t *)mFileBuffer;
+
+        mCurLayer->mFaces.resize(iNumFaces, LWO::Face(type));
+        FaceList::iterator it = mCurLayer->mFaces.begin();
+        CopyFaceIndicesLWO2(it, cursor, end);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void LWOImporter::CountVertsAndFacesLWO2(unsigned int &verts, unsigned int &faces,
+        uint16_t *&cursor, const uint16_t *const end, unsigned int max) {
+    while (cursor < end && max--) {
+        uint16_t numIndices;
+        ::memcpy(&numIndices, cursor++, 2);
+        AI_LSWAP2(numIndices);
+        numIndices &= 0x03FF;
+
+        verts += numIndices;
+        ++faces;
+
+        for (uint16_t i = 0; i < numIndices; i++) {
+            ReadVSizedIntLWO2((uint8_t *&)cursor);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void LWOImporter::CopyFaceIndicesLWO2(FaceList::iterator &it,
+        uint16_t *&cursor,
+        const uint16_t *const end) {
+    while (cursor < end) {
+        LWO::Face &face = *it++;
+        uint16_t numIndices;
+        ::memcpy(&numIndices, cursor++, 2);
+        AI_LSWAP2(numIndices);
+        face.mNumIndices = numIndices & 0x03FF;
+
+        if (face.mNumIndices) /* byte swapping has already been done */
+        {
+            face.mIndices = new unsigned int[face.mNumIndices];
+            for (unsigned int i = 0; i < face.mNumIndices; i++) {
+                face.mIndices[i] = ReadVSizedIntLWO2((uint8_t *&)cursor) + mCurLayer->mPointIDXOfs;
+                if (face.mIndices[i] > mCurLayer->mTempPoints.size()) {
+                    ASSIMP_LOG_WARN("LWO2: Failure evaluating face record, index is out of range");
+                    face.mIndices[i] = (unsigned int)mCurLayer->mTempPoints.size() - 1;
+                }
+            }
+        } else
+            throw DeadlyImportError("LWO2: Encountered invalid face record with zero indices");
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void LWOImporter::LoadLWO2PolygonTags(unsigned int length) {
+    LE_NCONST uint8_t *const end = mFileBuffer + length;
+
+    AI_LWO_VALIDATE_CHUNK_LENGTH(length, PTAG, 4);
+    uint32_t type = GetU4();
+
+    if (type != AI_LWO_SURF && type != AI_LWO_SMGP)
+        return;
+
+    while (mFileBuffer < end) {
+        unsigned int i = ReadVSizedIntLWO2(mFileBuffer) + mCurLayer->mFaceIDXOfs;
+        unsigned int j = GetU2();
+
+        if (i >= mCurLayer->mFaces.size()) {
+            ASSIMP_LOG_WARN("LWO2: face index in PTAG is out of range");
+            continue;
+        }
+
+        switch (type) {
+
+            case AI_LWO_SURF:
+                mCurLayer->mFaces[i].surfaceIndex = j;
+                break;
+            case AI_LWO_SMGP: /* is that really used? */
+                mCurLayer->mFaces[i].smoothGroup = j;
+                break;
+        };
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+template <class T>
+VMapEntry *FindEntry(std::vector<T> &list, const std::string &name, bool perPoly) {
+    for (auto &elem : list) {
+        if (elem.name == name) {
+            if (!perPoly) {
+                ASSIMP_LOG_WARN("LWO2: Found two VMAP sections with equal names");
+            }
+            return &elem;
+        }
+    }
+    list.push_back(T());
+    VMapEntry *p = &list.back();
+    p->name = name;
+    return p;
+}
+
+// ------------------------------------------------------------------------------------------------
+template <class T>
+inline void CreateNewEntry(T &chan, unsigned int srcIdx) {
+    if (!chan.name.length())
+        return;
+
+    chan.abAssigned[srcIdx] = true;
+    chan.abAssigned.resize(chan.abAssigned.size() + 1, false);
+
+    for (unsigned int a = 0; a < chan.dims; ++a)
+        chan.rawData.push_back(chan.rawData[srcIdx * chan.dims + a]);
+}
+
+// ------------------------------------------------------------------------------------------------
+template <class T>
+inline void CreateNewEntry(std::vector<T> &list, unsigned int srcIdx) {
+    for (auto &elem : list) {
+        CreateNewEntry(elem, srcIdx);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+inline void LWOImporter::DoRecursiveVMAPAssignment(VMapEntry *base, unsigned int numRead,
+        unsigned int idx, float *data) {
+    ai_assert(nullptr != data);
+    LWO::ReferrerList &refList = mCurLayer->mPointReferrers;
+    unsigned int i;
+
+    if (idx >= base->abAssigned.size()) {
+        throw DeadlyImportError("Bad index");
+    }
+    base->abAssigned[idx] = true;
+    for (i = 0; i < numRead; ++i) {
+        base->rawData[idx * base->dims + i] = data[i];
+    }
+
+    if (UINT_MAX != (i = refList[idx])) {
+        DoRecursiveVMAPAssignment(base, numRead, i, data);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+inline void AddToSingleLinkedList(ReferrerList &refList, unsigned int srcIdx, unsigned int destIdx) {
+    if (UINT_MAX == refList[srcIdx]) {
+        refList[srcIdx] = destIdx;
+        return;
+    }
+    AddToSingleLinkedList(refList, refList[srcIdx], destIdx);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Load LWO2 vertex map
+void LWOImporter::LoadLWO2VertexMap(unsigned int length, bool perPoly) {
+    LE_NCONST uint8_t *const end = mFileBuffer + length;
+
+    AI_LWO_VALIDATE_CHUNK_LENGTH(length, VMAP, 6);
+    unsigned int type = GetU4();
+    unsigned int dims = GetU2();
+
+    VMapEntry *base;
+
+    // read the name of the vertex map
+    std::string name;
+    GetS0(name, length);
+
+    switch (type) {
+        case AI_LWO_TXUV:
+            if (dims != 2) {
+                ASSIMP_LOG_WARN("LWO2: Skipping UV channel \'", name, "\' with !2 components");
+                return;
+            }
+            base = FindEntry(mCurLayer->mUVChannels, name, perPoly);
+            break;
+        case AI_LWO_WGHT:
+        case AI_LWO_MNVW:
+            if (dims != 1) {
+                ASSIMP_LOG_WARN("LWO2: Skipping Weight Channel \'", name, "\' with !1 components");
+                return;
+            }
+            base = FindEntry((type == AI_LWO_WGHT ? mCurLayer->mWeightChannels : mCurLayer->mSWeightChannels), name, perPoly);
+            break;
+        case AI_LWO_RGB:
+        case AI_LWO_RGBA:
+            if (dims != 3 && dims != 4) {
+                ASSIMP_LOG_WARN("LWO2: Skipping Color Map \'", name, "\' with a dimension > 4 or < 3");
+                return;
+            }
+            base = FindEntry(mCurLayer->mVColorChannels, name, perPoly);
+            break;
+
+        case AI_LWO_MODO_NORM:
+            /*  This is a non-standard extension chunk used by Luxology's MODO.
+         *  It stores per-vertex normals. This VMAP exists just once, has
+         *  3 dimensions and is btw extremely beautiful.
+         */
+            if (name != "vert_normals" || dims != 3 || mCurLayer->mNormals.name.length())
+                return;
+
+            ASSIMP_LOG_INFO("Processing non-standard extension: MODO VMAP.NORM.vert_normals");
+
+            mCurLayer->mNormals.name = name;
+            base = &mCurLayer->mNormals;
+            break;
+
+        case AI_LWO_PICK: /* these VMAPs are just silently dropped */
+        case AI_LWO_MORF:
+        case AI_LWO_SPOT:
+            return;
+
+        default:
+            if (name == "APS.Level") {
+                // XXX handle this (seems to be subdivision-related).
+            }
+            ASSIMP_LOG_WARN("LWO2: Skipping unknown VMAP/VMAD channel \'", name, "\'");
+            return;
+    };
+    base->Allocate((unsigned int)mCurLayer->mTempPoints.size());
+
+    // now read all entries in the map
+    type = std::min(dims, base->dims);
+    const unsigned int diff = (dims - type) << 2u;
+
+    LWO::FaceList &list = mCurLayer->mFaces;
+    LWO::PointList &pointList = mCurLayer->mTempPoints;
+    LWO::ReferrerList &refList = mCurLayer->mPointReferrers;
+
+    const unsigned int numPoints = (unsigned int)pointList.size();
+    const unsigned int numFaces = (unsigned int)list.size();
+
+    while (mFileBuffer < end) {
+
+        unsigned int idx = ReadVSizedIntLWO2(mFileBuffer) + mCurLayer->mPointIDXOfs;
+        if (idx >= numPoints) {
+            ASSIMP_LOG_WARN("LWO2: Failure evaluating VMAP/VMAD entry \'", name, "\', vertex index is out of range");
+            mFileBuffer += base->dims << 2u;
+            continue;
+        }
+        if (perPoly) {
+            unsigned int polyIdx = ReadVSizedIntLWO2(mFileBuffer) + mCurLayer->mFaceIDXOfs;
+            if (base->abAssigned[idx]) {
+                // we have already a VMAP entry for this vertex - thus
+                // we need to duplicate the corresponding polygon.
+                if (polyIdx >= numFaces) {
+                    ASSIMP_LOG_WARN("LWO2: Failure evaluating VMAD entry \'", name, "\', polygon index is out of range");
+                    mFileBuffer += base->dims << 2u;
+                    continue;
+                }
+
+                LWO::Face &src = list[polyIdx];
+
+                // generate a new unique vertex for the corresponding index - but only
+                // if we can find the index in the face
+                bool had = false;
+                for (unsigned int i = 0; i < src.mNumIndices; ++i) {
+
+                    unsigned int srcIdx = src.mIndices[i], tmp = idx;
+                    do {
+                        if (tmp == srcIdx)
+                            break;
+                    } while ((tmp = refList[tmp]) != UINT_MAX);
+                    if (tmp == UINT_MAX) {
+                        continue;
+                    }
+
+                    had = true;
+                    refList.resize(refList.size() + 1, UINT_MAX);
+
+                    idx = (unsigned int)pointList.size();
+                    src.mIndices[i] = (unsigned int)pointList.size();
+
+                    // store the index of the new vertex in the old vertex
+                    // so we get a single linked list we can traverse in
+                    // only one direction
+                    AddToSingleLinkedList(refList, srcIdx, src.mIndices[i]);
+                    pointList.push_back(pointList[srcIdx]);
+
+                    CreateNewEntry(mCurLayer->mVColorChannels, srcIdx);
+                    CreateNewEntry(mCurLayer->mUVChannels, srcIdx);
+                    CreateNewEntry(mCurLayer->mWeightChannels, srcIdx);
+                    CreateNewEntry(mCurLayer->mSWeightChannels, srcIdx);
+                    CreateNewEntry(mCurLayer->mNormals, srcIdx);
+                }
+                if (!had) {
+                    ASSIMP_LOG_WARN("LWO2: Failure evaluating VMAD entry \'", name, "\', vertex index wasn't found in that polygon");
+                    ai_assert(had);
+                }
+            }
+        }
+
+        std::unique_ptr<float[]> temp(new float[type]);
+        for (unsigned int l = 0; l < type; ++l)
+            temp[l] = GetF4();
+
+        DoRecursiveVMAPAssignment(base, type, idx, temp.get());
+        mFileBuffer += diff;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Load LWO2 clip
+void LWOImporter::LoadLWO2Clip(unsigned int length) {
+    AI_LWO_VALIDATE_CHUNK_LENGTH(length, CLIP, 10);
+
+    mClips.push_back(LWO::Clip());
+    LWO::Clip &clip = mClips.back();
+
+    // first - get the index of the clip
+    clip.idx = GetU4();
+
+    IFF::SubChunkHeader head = IFF::LoadSubChunk(mFileBuffer);
+    switch (head.type) {
+        case AI_LWO_STIL:
+            AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, STIL, 1);
+
+            // "Normal" texture
+            GetS0(clip.path, head.length);
+            clip.type = Clip::STILL;
+            break;
+
+        case AI_LWO_ISEQ:
+            AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, ISEQ, 16);
+            // Image sequence. We'll later take the first.
+            {
+                uint8_t digits = GetU1();
+                mFileBuffer++;
+                int16_t offset = GetU2();
+                mFileBuffer += 4;
+                int16_t start = GetU2();
+                mFileBuffer += 4;
+
+                std::string s;
+                std::ostringstream ss;
+                GetS0(s, head.length);
+
+                head.length -= (uint16_t)s.length() + 1;
+                ss << s;
+                ss << std::setw(digits) << offset + start;
+                GetS0(s, head.length);
+                ss << s;
+                clip.path = ss.str();
+                clip.type = Clip::SEQ;
+            }
+            break;
+
+        case AI_LWO_STCC:
+            ASSIMP_LOG_WARN("LWO2: Color shifted images are not supported");
+            break;
+
+        case AI_LWO_ANIM:
+            ASSIMP_LOG_WARN("LWO2: Animated textures are not supported");
+            break;
+
+        case AI_LWO_XREF:
+            AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, XREF, 4);
+
+            // Just a cross-reference to another CLIp
+            clip.type = Clip::REF;
+            clip.clipRef = GetU4();
+            break;
+
+        case AI_LWO_NEGA:
+            AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, NEGA, 2);
+            clip.negate = (0 != GetU2());
+            break;
+
+        default:
+            ASSIMP_LOG_WARN("LWO2: Encountered unknown CLIP sub-chunk");
+    }
+}
+
+void LWOImporter::LoadLWO3Clip(unsigned int length) {
+    AI_LWO_VALIDATE_CHUNK_LENGTH(length, CLIP, 12);
+
+    mClips.push_back(LWO::Clip());
+    LWO::Clip &clip = mClips.back();
+
+    // first - get the index of the clip
+    clip.idx = GetU4();
+
+    IFF::ChunkHeader head = IFF::LoadChunk(mFileBuffer);
+    switch (head.type) {
+        case AI_LWO_STIL:
+            AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, STIL, 1);
+
+            // "Normal" texture
+            GetS0(clip.path, head.length);
+            clip.type = Clip::STILL;
+            break;
+
+        case AI_LWO_ISEQ:
+            AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, ISEQ, 16);
+            // Image sequence. We'll later take the first.
+            {
+                uint8_t digits = GetU1();
+                mFileBuffer++;
+                int16_t offset = GetU2();
+                mFileBuffer += 4;
+                int16_t start = GetU2();
+                mFileBuffer += 4;
+
+                std::string s;
+                std::ostringstream ss;
+                GetS0(s, head.length);
+
+                head.length -= (uint16_t)s.length() + 1;
+                ss << s;
+                ss << std::setw(digits) << offset + start;
+                GetS0(s, head.length);
+                ss << s;
+                clip.path = ss.str();
+                clip.type = Clip::SEQ;
+            }
+            break;
+
+        case AI_LWO_STCC:
+            ASSIMP_LOG_WARN("LWO3: Color shifted images are not supported");
+            break;
+
+        case AI_LWO_ANIM:
+            ASSIMP_LOG_WARN("LWO3: Animated textures are not supported");
+            break;
+
+        case AI_LWO_XREF:
+            AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, XREF, 4);
+
+            // Just a cross-reference to another CLIp
+            clip.type = Clip::REF;
+            clip.clipRef = GetU4();
+            break;
+
+        case AI_LWO_NEGA:
+            AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, NEGA, 2);
+            clip.negate = (0 != GetU2());
+            break;
+
+        default:
+            ASSIMP_LOG_WARN("LWO3: Encountered unknown CLIP sub-chunk");
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Load envelope description
+void LWOImporter::LoadLWO2Envelope(unsigned int length) {
+    LE_NCONST uint8_t *const end = mFileBuffer + length;
+    AI_LWO_VALIDATE_CHUNK_LENGTH(length, ENVL, 4);
+
+    mEnvelopes.push_back(LWO::Envelope());
+    LWO::Envelope &envelope = mEnvelopes.back();
+
+    // Get the index of the envelope
+    envelope.index = ReadVSizedIntLWO2(mFileBuffer);
+
+    // It looks like there might be an extra U4 right after the index,
+    // at least in modo (LXOB) files: we'll ignore it if it's zero,
+    // otherwise it represents the start of a subchunk, so we backtrack.
+    if (mIsLXOB) {
+        uint32_t extra = GetU4();
+        if (extra) {
+            mFileBuffer -= 4;
+        }
+    }
+
+    // ... and read all subchunks
+    while (true) {
+        if (mFileBuffer + 6 >= end) break;
+        LE_NCONST IFF::SubChunkHeader head = IFF::LoadSubChunk(mFileBuffer);
+
+        if (mFileBuffer + head.length > end)
+            throw DeadlyImportError("LWO2: Invalid envelope chunk length");
+
+        uint8_t *const next = mFileBuffer + head.length;
+        switch (head.type) {
+                // Type & representation of the envelope
+            case AI_LWO_TYPE:
+                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, TYPE, 2);
+                mFileBuffer++; // skip user format
+
+                // Determine type of envelope
+                envelope.type = (LWO::EnvelopeType)*mFileBuffer;
+                ++mFileBuffer;
+                break;
+
+                // precondition
+            case AI_LWO_PRE:
+                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, PRE, 2);
+                envelope.pre = (LWO::PrePostBehaviour)GetU2();
+                break;
+
+                // postcondition
+            case AI_LWO_POST:
+                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, POST, 2);
+                envelope.post = (LWO::PrePostBehaviour)GetU2();
+                break;
+
+                // keyframe
+            case AI_LWO_KEY: {
+                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, KEY, 8);
+
+                envelope.keys.push_back(LWO::Key());
+                LWO::Key &key = envelope.keys.back();
+
+                key.time = GetF4();
+                key.value = GetF4();
+                break;
+            }
+
+                // interval interpolation
+            case AI_LWO_SPAN: {
+                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, SPAN, 4);
+                if (envelope.keys.size() < 2)
+                    ASSIMP_LOG_WARN("LWO2: Unexpected SPAN chunk");
+                else {
+                    LWO::Key &key = envelope.keys.back();
+                    switch (GetU4()) {
+                        case AI_LWO_STEP:
+                            key.inter = LWO::IT_STEP;
+                            break;
+                        case AI_LWO_LINE:
+                            key.inter = LWO::IT_LINE;
+                            break;
+                        case AI_LWO_TCB:
+                            key.inter = LWO::IT_TCB;
+                            break;
+                        case AI_LWO_HERM:
+                            key.inter = LWO::IT_HERM;
+                            break;
+                        case AI_LWO_BEZI:
+                            key.inter = LWO::IT_BEZI;
+                            break;
+                        case AI_LWO_BEZ2:
+                            key.inter = LWO::IT_BEZ2;
+                            break;
+                        default:
+                            ASSIMP_LOG_WARN("LWO2: Unknown interval interpolation mode");
+                    };
+
+                    // todo ... read params
+                }
+                break;
+            }
+
+            default:
+                ASSIMP_LOG_WARN("LWO2: Encountered unknown ENVL subchunk");
+                break;
+        }
+        // regardless how much we did actually read, go to the next chunk
+        mFileBuffer = next;
+    }
+}
+
+void LWOImporter::LoadLWO3Envelope(unsigned int length) {
+    LE_NCONST uint8_t *const end = mFileBuffer + length;
+    AI_LWO_VALIDATE_CHUNK_LENGTH(length, ENVL, 4);
+
+    mEnvelopes.push_back(LWO::Envelope());
+    LWO::Envelope &envelope = mEnvelopes.back();
+
+    // Get the index of the envelope
+    envelope.index = ReadVSizedIntLWO2(mFileBuffer);
+
+    // ... and read all blocks
+    while (true) {
+        if (mFileBuffer + 8 >= end) break;
+        LE_NCONST IFF::ChunkHeader head = IFF::LoadChunk(mFileBuffer);
+
+        if (mFileBuffer + head.length > end)
+            throw DeadlyImportError("LWO3: Invalid envelope chunk length");
+
+        uint8_t *const next = mFileBuffer + head.length;
+        switch (head.type) {
+                // Type & representation of the envelope
+            case AI_LWO_TYPE:
+                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, TYPE, 4);
+                mFileBuffer++; // skip user format
+
+                // Determine type of envelope
+                envelope.type = (LWO::EnvelopeType)*mFileBuffer;
+                ++mFileBuffer;
+                break;
+
+                // precondition
+            case AI_LWO_PRE:
+                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, PRE, 4);
+                envelope.pre = (LWO::PrePostBehaviour)GetU2();
+                break;
+
+                // postcondition
+            case AI_LWO_POST:
+                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, POST, 4);
+                envelope.post = (LWO::PrePostBehaviour)GetU2();
+                break;
+
+                // keyframe
+            case AI_LWO_KEY: {
+                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, KEY, 10);
+
+                envelope.keys.push_back(LWO::Key());
+                LWO::Key &key = envelope.keys.back();
+
+                key.time = GetF4();
+                key.value = GetF4();
+                break;
+            }
+
+                // interval interpolation
+            case AI_LWO_SPAN: {
+                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, SPAN, 6);
+                if (envelope.keys.size() < 2)
+                    ASSIMP_LOG_WARN("LWO3: Unexpected SPAN chunk");
+                else {
+                    LWO::Key &key = envelope.keys.back();
+                    switch (GetU4()) {
+                        case AI_LWO_STEP:
+                            key.inter = LWO::IT_STEP;
+                            break;
+                        case AI_LWO_LINE:
+                            key.inter = LWO::IT_LINE;
+                            break;
+                        case AI_LWO_TCB:
+                            key.inter = LWO::IT_TCB;
+                            break;
+                        case AI_LWO_HERM:
+                            key.inter = LWO::IT_HERM;
+                            break;
+                        case AI_LWO_BEZI:
+                            key.inter = LWO::IT_BEZI;
+                            break;
+                        case AI_LWO_BEZ2:
+                            key.inter = LWO::IT_BEZ2;
+                            break;
+                        default:
+                            ASSIMP_LOG_WARN("LWO3: Unknown interval interpolation mode");
+                    };
+
+                    // todo ... read params
+                }
+                break;
+            }
+
+            default:
+                ASSIMP_LOG_WARN("LWO3: Encountered unknown ENVL subchunk");
+                break;
+        }
+        // regardless how much we did actually read, go to the next chunk
+        mFileBuffer = next;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Load file - master function
+void LWOImporter::LoadLWO2File() {
+    bool skip = false;
+
+    LE_NCONST uint8_t *const end = mFileBuffer + fileSize;
+    unsigned int iUnnamed = 0;
+
+    while (true) {
+        if (mFileBuffer + sizeof(IFF::ChunkHeader) > end) break;
+
+        IFF::ChunkHeader head = IFF::LoadChunk(mFileBuffer);
+
+        int bufOffset = 0;
+        if( head.type == AI_IFF_FOURCC_FORM ) { // not chunk, it's a form
+            mFileBuffer -= 8;
+            head = IFF::LoadForm(mFileBuffer);
+            bufOffset = 4;
+        }
+
+        if (mFileBuffer + head.length > end) {
+            throw DeadlyImportError("LWO2: Chunk length points behind the file");
+            break;
+        }
+        uint8_t *const next = mFileBuffer + head.length;
+        mFileBuffer += bufOffset;
+        if (!head.length) {
+            mFileBuffer = next;
+            continue;
+        }
+
+        switch (head.type) {
+                // new layer
+            case AI_LWO_LAYR: {
+                // add a new layer to the list ....
+                mLayers->push_back(LWO::Layer());
+                LWO::Layer &layer = mLayers->back();
+                mCurLayer = &layer;
+
+                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, LAYR, 16);
+
+                // layer index.
+                layer.mIndex = GetU2();
+
+                // Continue loading this layer or ignore it? Check the layer index property
+                if (UINT_MAX != configLayerIndex && (configLayerIndex - 1) != layer.mIndex) {
+                    skip = true;
+                } else
+                    skip = false;
+
+                // pivot point
+                mFileBuffer += 2; /* unknown */
+                mCurLayer->mPivot.x = GetF4();
+                mCurLayer->mPivot.y = GetF4();
+                mCurLayer->mPivot.z = GetF4();
+                GetS0(layer.mName, head.length - 16);
+
+                // if the name is empty, generate a default name
+                if (layer.mName.empty()) {
+                    char buffer[128]; // should be sufficiently large
+                    ::ai_snprintf(buffer, 128, "Layer_%i", iUnnamed++);
+                    layer.mName = buffer;
+                }
+
+                // load this layer or ignore it? Check the layer name property
+                if (configLayerName.length() && configLayerName != layer.mName) {
+                    skip = true;
+                } else
+                    hasNamedLayer = true;
+
+                // optional: parent of this layer
+                if (mFileBuffer + 2 <= next)
+                    layer.mParent = GetU2();
+                else
+                    layer.mParent = (uint16_t) -1;
+
+                // Set layer skip parameter
+                layer.skip = skip;
+
+                break;
+            }
+                // vertex list
+            case AI_LWO_PNTS: {
+                if (skip)
+                    break;
+
+                unsigned int old = (unsigned int)mCurLayer->mTempPoints.size();
+                LoadLWOPoints(head.length);
+                mCurLayer->mPointIDXOfs = old;
+                break;
+            }
+                // vertex tags
+            case AI_LWO_VMAD:
+                if (mCurLayer->mFaces.empty()) {
+                    ASSIMP_LOG_WARN("LWO2: Unexpected VMAD chunk");
+                    break;
+                }
+                // --- intentionally no break here
+            case AI_LWO_VMAP: {
+                if (skip)
+                    break;
+
+                if (mCurLayer->mTempPoints.empty())
+                    ASSIMP_LOG_WARN("LWO2: Unexpected VMAP chunk");
+                else
+                    LoadLWO2VertexMap(head.length, head.type == AI_LWO_VMAD);
+                break;
+            }
+                // face list
+            case AI_LWO_POLS: {
+                if (skip)
+                    break;
+
+                unsigned int old = (unsigned int)mCurLayer->mFaces.size();
+                LoadLWO2Polygons(head.length);
+                mCurLayer->mFaceIDXOfs = old;
+                break;
+            }
+                // polygon tags
+            case AI_LWO_PTAG: {
+                if (skip)
+                    break;
+
+                if (mCurLayer->mFaces.empty()) {
+                    ASSIMP_LOG_WARN("LWO2: Unexpected PTAG");
+                } else {
+                    LoadLWO2PolygonTags(head.length);
+                }
+                break;
+            }
+                // list of tags
+            case AI_LWO_TAGS: {
+                if (!mTags->empty()) {
+                    ASSIMP_LOG_WARN("LWO2: SRFS chunk encountered twice");
+                } else {
+                    LoadLWOTags(head.length);
+                }
+                break;
+            }
+
+                // surface chunk
+            case AI_LWO_SURF: {
+                if( mIsLWO3 )
+                    LoadLWO3Surface(head.length);
+                else
+                    LoadLWO2Surface(head.length);
+
+                break;
+            }
+
+                // clip chunk
+            case AI_LWO_CLIP: {
+                if( mIsLWO3 )
+                    LoadLWO3Clip(head.length);
+                else
+                    LoadLWO2Clip(head.length);
+                break;
+            }
+
+                // envelope chunk
+            case AI_LWO_ENVL: {
+                if( mIsLWO3 )
+                    LoadLWO3Envelope(head.length);
+                else
+                    LoadLWO2Envelope(head.length);
+                break;
+            }
+        }
+        mFileBuffer = next;
+    }
+}
+
+#endif // !! ASSIMP_BUILD_NO_LWO_IMPORTER
diff --git a/Engine/lib/assimp/code/LWO/LWOLoader.h b/Engine/lib/assimp/code/AssetLib/LWO/LWOLoader.h
similarity index 72%
rename from Engine/lib/assimp/code/LWO/LWOLoader.h
rename to Engine/lib/assimp/code/AssetLib/LWO/LWOLoader.h
index 05b958fd2..9e116a3cc 100644
--- a/Engine/lib/assimp/code/LWO/LWOLoader.h
+++ b/Engine/lib/assimp/code/AssetLib/LWO/LWOLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -41,15 +41,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 /** @file Declaration of the LWO importer class. */
+#pragma once
 #ifndef AI_LWOLOADER_H_INCLUDED
 #define AI_LWOLOADER_H_INCLUDED
 
-#include <assimp/types.h>
-#include <assimp/material.h>
-#include <assimp/DefaultLogger.hpp>
-
 #include "LWOFileData.h"
 #include <assimp/BaseImporter.h>
+#include <assimp/material.h>
+#include <assimp/DefaultLogger.hpp>
 
 #include <map>
 
@@ -57,7 +56,7 @@ struct aiTexture;
 struct aiNode;
 struct aiMaterial;
 
-namespace Assimp    {
+namespace Assimp {
 using namespace LWO;
 
 // ---------------------------------------------------------------------------
@@ -70,45 +69,38 @@ using namespace LWO;
  *         they aren't specific to one format version
 */
 // ---------------------------------------------------------------------------
-class LWOImporter : public BaseImporter
-{
+class LWOImporter : public BaseImporter {
 public:
     LWOImporter();
-    ~LWOImporter();
-
-
-public:
+    ~LWOImporter() override;
 
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
      * See BaseImporter::CanRead() for details.
      */
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
-
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
+            bool checkSig) const override;
 
     // -------------------------------------------------------------------
     /** Called prior to ReadFile().
     * The function is a request to the importer to update its configuration
     * basing on the Importer's configuration property list.
     */
-    void SetupProperties(const Importer* pImp);
+    void SetupProperties(const Importer *pImp) override;
 
 protected:
-
     // -------------------------------------------------------------------
     // Get list of supported extensions
-    const aiImporterDesc* GetInfo () const;
+    const aiImporterDesc *GetInfo() const override;
 
     // -------------------------------------------------------------------
     /** Imports the given file into the given scene structure.
     * See BaseImporter::InternReadFile() for details
     */
-    void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
+    void InternReadFile(const std::string &pFile, aiScene *pScene,
+            IOSystem *pIOHandler) override;
 
 private:
-
     // -------------------------------------------------------------------
     /** Loads a LWO file in the older LWOB format (LW < 6)
      */
@@ -119,16 +111,16 @@ private:
      */
     void LoadLWO2File();
 
-
     // -------------------------------------------------------------------
     /** Parsing functions used for all file format versions
     */
-    inline void GetS0(std::string& out,unsigned int max);
+    inline void GetS0(std::string &out, unsigned int max);
     inline float GetF4();
+    inline float GetF8();
+    inline uint64_t GetU8();
     inline uint32_t GetU4();
     inline uint16_t GetU2();
-    inline uint8_t  GetU1();
-
+    inline uint8_t GetU1();
 
     // -------------------------------------------------------------------
     /** Loads a surface chunk from an LWOB file
@@ -141,34 +133,35 @@ private:
      *  @param size Maximum size to be read, in bytes.
      */
     void LoadLWO2Surface(unsigned int size);
+    void LoadLWO3Surface(unsigned int size);
 
     // -------------------------------------------------------------------
     /** Loads a texture block from a LWO2 file.
      *  @param size Maximum size to be read, in bytes.
      *  @param head Header of the SUF.BLOK header
      */
-    void LoadLWO2TextureBlock(LE_NCONST IFF::SubChunkHeader* head,
-        unsigned int size );
+    void LoadLWO2TextureBlock(LE_NCONST IFF::SubChunkHeader *head,
+            unsigned int size);
 
     // -------------------------------------------------------------------
     /** Loads a shader block from a LWO2 file.
      *  @param size Maximum size to be read, in bytes.
      *  @param head Header of the SUF.BLOK header
      */
-    void LoadLWO2ShaderBlock(LE_NCONST IFF::SubChunkHeader* head,
-        unsigned int size );
+    void LoadLWO2ShaderBlock(LE_NCONST IFF::SubChunkHeader *head,
+            unsigned int size);
 
     // -------------------------------------------------------------------
     /** Loads an image map from a LWO2 file
      *  @param size Maximum size to be read, in bytes.
      *  @param tex Texture object to be filled
      */
-    void LoadLWO2ImageMap(unsigned int size, LWO::Texture& tex );
-    void LoadLWO2Gradient(unsigned int size, LWO::Texture& tex );
-    void LoadLWO2Procedural(unsigned int size, LWO::Texture& tex );
+    void LoadLWO2ImageMap(unsigned int size, LWO::Texture &tex);
+    void LoadLWO2Gradient(unsigned int size, LWO::Texture &tex);
+    void LoadLWO2Procedural(unsigned int size, LWO::Texture &tex);
 
     // loads the header - used by thethree functions above
-    void LoadLWO2TextureHeader(unsigned int size, LWO::Texture& tex );
+    void LoadLWO2TextureHeader(unsigned int size, LWO::Texture &tex);
 
     // -------------------------------------------------------------------
     /** Loads the LWO tag list from the file
@@ -207,40 +200,51 @@ private:
      *  @param length Size of the chunk
     */
     void LoadLWO2Clip(unsigned int length);
+    void LoadLWO3Clip(unsigned int length);
 
     // -------------------------------------------------------------------
     /** Load an envelope from an EVL chunk
      *  @param length Size of the chunk
     */
     void LoadLWO2Envelope(unsigned int length);
+    void LoadLWO3Envelope(unsigned int length);
+
+    // -------------------------------------------------------------------
+    /** Load an nodal blocks from surface form
+     *  @param length Size of the chunk
+    */
+    void LoadNodalBlocks(unsigned int length);
+    void LoadNodes(unsigned int length);
+    void LoadNodeTag(unsigned int length);
+    void LoadNodeData(unsigned int length);
 
     // -------------------------------------------------------------------
     /** Count vertices and faces in a LWOB/LWO2 file
     */
-    void CountVertsAndFacesLWO2(unsigned int& verts,
-        unsigned int& faces,
-        uint16_t*& cursor,
-        const uint16_t* const end,
-        unsigned int max = UINT_MAX);
+    void CountVertsAndFacesLWO2(unsigned int &verts,
+            unsigned int &faces,
+            uint16_t *&cursor,
+            const uint16_t *const end,
+            unsigned int max = UINT_MAX);
 
-    void CountVertsAndFacesLWOB(unsigned int& verts,
-        unsigned int& faces,
-        LE_NCONST uint16_t*& cursor,
-        const uint16_t* const end,
-        unsigned int max = UINT_MAX);
+    void CountVertsAndFacesLWOB(unsigned int &verts,
+            unsigned int &faces,
+            LE_NCONST uint16_t *&cursor,
+            const uint16_t *const end,
+            unsigned int max = UINT_MAX);
 
     // -------------------------------------------------------------------
     /** Read vertices and faces in a LWOB/LWO2 file
     */
-    void CopyFaceIndicesLWO2(LWO::FaceList::iterator& it,
-        uint16_t*& cursor,
-        const uint16_t* const end);
+    void CopyFaceIndicesLWO2(LWO::FaceList::iterator &it,
+            uint16_t *&cursor,
+            const uint16_t *const end);
 
     // -------------------------------------------------------------------
-    void CopyFaceIndicesLWOB(LWO::FaceList::iterator& it,
-        LE_NCONST uint16_t*& cursor,
-        const uint16_t* const end,
-        unsigned int max = UINT_MAX);
+    void CopyFaceIndicesLWOB(LWO::FaceList::iterator &it,
+            LE_NCONST uint16_t *&cursor,
+            const uint16_t *const end,
+            unsigned int max = UINT_MAX);
 
     // -------------------------------------------------------------------
     /** Resolve the tag and surface lists that have been loaded.
@@ -261,19 +265,18 @@ private:
      *  @param in Input texture list
      *  @param type Type identifier of the texture list
     */
-    bool HandleTextures(aiMaterial* pcMat, const TextureList& in,
-        aiTextureType type);
+    bool HandleTextures(aiMaterial *pcMat, const TextureList &in,
+            aiTextureType type);
 
     // -------------------------------------------------------------------
     /** Adjust a texture path
     */
-    void AdjustTexturePath(std::string& out);
+    void AdjustTexturePath(std::string &out);
 
     // -------------------------------------------------------------------
     /** Convert a LWO surface description to an ASSIMP material
     */
-    void ConvertMaterial(const LWO::Surface& surf,aiMaterial* pcMat);
-
+    void ConvertMaterial(const LWO::Surface &surf, aiMaterial *pcMat);
 
     // -------------------------------------------------------------------
     /** Get a list of all UV/VC channels required by a specific surface.
@@ -283,42 +286,42 @@ private:
      *  @param out Output list. The members are indices into the
      *    UV/VC channel lists of the layer
     */
-    void FindUVChannels(/*const*/ LWO::Surface& surf,
-        LWO::SortedRep& sorted,
-        /*const*/ LWO::Layer& layer,
-        unsigned int out[AI_MAX_NUMBER_OF_TEXTURECOORDS]);
+    void FindUVChannels(/*const*/ LWO::Surface &surf,
+            LWO::SortedRep &sorted,
+            /*const*/ LWO::Layer &layer,
+            unsigned int out[AI_MAX_NUMBER_OF_TEXTURECOORDS]);
 
     // -------------------------------------------------------------------
-    char FindUVChannels(LWO::TextureList& list,
-        LWO::Layer& layer,LWO::UVChannel& uv, unsigned int next);
+    char FindUVChannels(LWO::TextureList &list,
+            LWO::Layer &layer, LWO::UVChannel &uv, unsigned int next);
 
     // -------------------------------------------------------------------
-    void FindVCChannels(const LWO::Surface& surf,
-        LWO::SortedRep& sorted,
-        const LWO::Layer& layer,
-        unsigned int out[AI_MAX_NUMBER_OF_COLOR_SETS]);
+    void FindVCChannels(const LWO::Surface &surf,
+            LWO::SortedRep &sorted,
+            const LWO::Layer &layer,
+            unsigned int out[AI_MAX_NUMBER_OF_COLOR_SETS]);
 
     // -------------------------------------------------------------------
     /** Generate the final node graph
      *  Unused nodes are deleted.
      *  @param apcNodes Flat list of nodes
     */
-    void GenerateNodeGraph(std::map<uint16_t,aiNode*>& apcNodes);
+    void GenerateNodeGraph(std::map<uint16_t, aiNode *> &apcNodes);
 
     // -------------------------------------------------------------------
     /** Add children to a node
      *  @param node Node to become a father
      *  @param parent Index of the node
-     *  @param apcNodes Flat list of nodes - used nodes are set to NULL.
+     *  @param apcNodes Flat list of nodes - used nodes are set to nullptr.
     */
-    void AddChildren(aiNode* node, uint16_t parent,
-        std::vector<aiNode*>& apcNodes);
+    void AddChildren(aiNode *node, uint16_t parent,
+            std::vector<aiNode *> &apcNodes);
 
     // -------------------------------------------------------------------
     /** Read a variable sized integer
      *  @param inout Input and output buffer
     */
-    int ReadVSizedIntLWO2(uint8_t*& inout);
+    int ReadVSizedIntLWO2(uint8_t *&inout);
 
     // -------------------------------------------------------------------
     /** Assign a value from a VMAP to a vertex and all vertices
@@ -329,8 +332,8 @@ private:
      *  @param data Value of the VMAP to be assigned - read numRead
      *    floats from this array.
     */
-    void DoRecursiveVMAPAssignment(VMapEntry* base, unsigned int numRead,
-        unsigned int idx, float* data);
+    void DoRecursiveVMAPAssignment(VMapEntry *base, unsigned int numRead,
+            unsigned int idx, float *data);
 
     // -------------------------------------------------------------------
     /** Compute normal vectors for a mesh
@@ -338,9 +341,8 @@ private:
      *  @param smoothingGroups Smoothing-groups-per-face array
      *  @param surface Surface for the mesh
     */
-    void ComputeNormals(aiMesh* mesh, const std::vector<unsigned int>& smoothingGroups,
-        const LWO::Surface& surface);
-
+    void ComputeNormals(aiMesh *mesh, const std::vector<unsigned int> &smoothingGroups,
+            const LWO::Surface &surface);
 
     // -------------------------------------------------------------------
     /** Setup a new texture after the corresponding chunk was
@@ -349,32 +351,33 @@ private:
      *  @param size Maximum number of bytes to be read
      *  @return Pointer to new texture
     */
-    LWO::Texture* SetupNewTextureLWOB(LWO::TextureList& list,
-        unsigned int size);
+    LWO::Texture *SetupNewTextureLWOB(LWO::TextureList &list,
+            unsigned int size);
 
 protected:
-
     /** true if the file is a LWO2 file*/
     bool mIsLWO2;
 
     /** true if the file is a LXOB file*/
     bool mIsLXOB;
 
+    bool mIsLWO3;
+
     /** Temporary list of layers from the file */
-    LayerList* mLayers;
+    LayerList *mLayers;
 
     /** Pointer to the current layer */
-    LWO::Layer* mCurLayer;
+    LWO::Layer *mCurLayer;
 
     /** Temporary tag list from the file */
-    TagList* mTags;
+    TagList *mTags;
 
     /** Mapping table to convert from tag to surface indices.
         UINT_MAX indicates that a no corresponding surface is available */
-    TagMappingTable* mMapping;
+    TagMappingTable *mMapping;
 
     /** Temporary surface list from the file */
-    SurfaceList* mSurfaces;
+    SurfaceList *mSurfaces;
 
     /** Temporary clip list from the file */
     ClipList mClips;
@@ -383,13 +386,13 @@ protected:
     EnvelopeList mEnvelopes;
 
     /** file buffer */
-    uint8_t* mFileBuffer;
+    uint8_t *mFileBuffer;
 
     /** Size of the file, in bytes */
     unsigned int fileSize;
 
     /** Output scene */
-    aiScene* pScene;
+    aiScene *mScene;
 
     /** Configuration option: speed flag set? */
     bool configSpeedFlag;
@@ -398,16 +401,14 @@ protected:
     unsigned int configLayerIndex;
 
     /** Configuration option: name of layer to be loaded */
-    std::string  configLayerName;
+    std::string configLayerName;
 
     /** True if we have a named layer */
     bool hasNamedLayer;
 };
 
-
 // ------------------------------------------------------------------------------------------------
-inline float LWOImporter::GetF4()
-{
+inline float LWOImporter::GetF4() {
     float f;
     ::memcpy(&f, mFileBuffer, 4);
     mFileBuffer += 4;
@@ -415,9 +416,24 @@ inline float LWOImporter::GetF4()
     return f;
 }
 
+inline float LWOImporter::GetF8() {
+    double f;
+    ::memcpy(&f, mFileBuffer, 8);
+    mFileBuffer += 8;
+    AI_LSWAP8(f);
+    return (float)f;
+}
+
+inline uint64_t LWOImporter::GetU8() {
+    uint64_t f;
+    ::memcpy(&f, mFileBuffer, 8);
+    mFileBuffer += 8;
+    AI_LSWAP8(f);
+    return f;
+}
+
 // ------------------------------------------------------------------------------------------------
-inline uint32_t LWOImporter::GetU4()
-{
+inline uint32_t LWOImporter::GetU4() {
     uint32_t f;
     ::memcpy(&f, mFileBuffer, 4);
     mFileBuffer += 4;
@@ -426,8 +442,7 @@ inline uint32_t LWOImporter::GetU4()
 }
 
 // ------------------------------------------------------------------------------------------------
-inline uint16_t LWOImporter::GetU2()
-{
+inline uint16_t LWOImporter::GetU2() {
     uint16_t f;
     ::memcpy(&f, mFileBuffer, 2);
     mFileBuffer += 2;
@@ -436,55 +451,50 @@ inline uint16_t LWOImporter::GetU2()
 }
 
 // ------------------------------------------------------------------------------------------------
-inline uint8_t LWOImporter::GetU1()
-{
+inline uint8_t LWOImporter::GetU1() {
     return *mFileBuffer++;
 }
 
 // ------------------------------------------------------------------------------------------------
-inline int LWOImporter::ReadVSizedIntLWO2(uint8_t*& inout)
-{
+inline int LWOImporter::ReadVSizedIntLWO2(uint8_t *&inout) {
     int i;
-    int c = *inout;inout++;
-    if(c != 0xFF)
-    {
+    int c = *inout;
+    inout++;
+    if (c != 0xFF) {
         i = c << 8;
-        c = *inout;inout++;
+        c = *inout;
+        inout++;
         i |= c;
-    }
-    else
-    {
-        c = *inout;inout++;
+    } else {
+        c = *inout;
+        inout++;
         i = c << 16;
-        c = *inout;inout++;
+        c = *inout;
+        inout++;
         i |= c << 8;
-        c = *inout;inout++;
+        c = *inout;
+        inout++;
         i |= c;
     }
     return i;
 }
 
 // ------------------------------------------------------------------------------------------------
-inline void LWOImporter::GetS0(std::string& out,unsigned int max)
-{
+inline void LWOImporter::GetS0(std::string &out, unsigned int max) {
     unsigned int iCursor = 0;
-    const char*sz = (const char*)mFileBuffer;
-    while (*mFileBuffer)
-    {
-        if (++iCursor > max)
-        {
+    const char *sz = (const char *)mFileBuffer;
+    while (*mFileBuffer) {
+        if (++iCursor > max) {
             ASSIMP_LOG_WARN("LWO: Invalid file, string is is too long");
             break;
         }
         ++mFileBuffer;
     }
-    size_t len = (size_t) ((const char*)mFileBuffer-sz);
-    out = std::string(sz,len);
-    mFileBuffer += (len&0x1 ? 1 : 2);
+    size_t len = (size_t)((const char *)mFileBuffer - sz);
+    out = std::string(sz, len);
+    mFileBuffer += (len & 0x1 ? 1 : 2);
 }
 
-
-
 } // end of namespace Assimp
 
 #endif // AI_LWOIMPORTER_H_INCLUDED
diff --git a/Engine/lib/assimp/code/AssetLib/LWO/LWOMaterial.cpp b/Engine/lib/assimp/code/AssetLib/LWO/LWOMaterial.cpp
new file mode 100644
index 000000000..4728706db
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/LWO/LWOMaterial.cpp
@@ -0,0 +1,1155 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file Implementation of the material oart of the LWO importer class */
+
+#ifndef ASSIMP_BUILD_NO_LWO_IMPORTER
+
+// internal headers
+#include "LWOLoader.h"
+#include <assimp/ByteSwapper.h>
+
+using namespace Assimp;
+
+// ------------------------------------------------------------------------------------------------
+template <class T>
+T lerp(const T &one, const T &two, float val) {
+    return one + (two - one) * val;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Convert a lightwave mapping mode to our's
+inline aiTextureMapMode GetMapMode(LWO::Texture::Wrap in) {
+    switch (in) {
+        case LWO::Texture::REPEAT:
+            return aiTextureMapMode_Wrap;
+
+        case LWO::Texture::MIRROR:
+            return aiTextureMapMode_Mirror;
+
+        case LWO::Texture::RESET:
+            ASSIMP_LOG_WARN("LWO2: Unsupported texture map mode: RESET");
+
+            // fall though here
+        case LWO::Texture::EDGE:
+            return aiTextureMapMode_Clamp;
+    }
+    return (aiTextureMapMode)0;
+}
+
+// ------------------------------------------------------------------------------------------------
+bool LWOImporter::HandleTextures(aiMaterial *pcMat, const TextureList &in, aiTextureType type) {
+    ai_assert(nullptr != pcMat);
+
+    unsigned int cur = 0, temp = 0;
+    aiString s;
+    bool ret = false;
+
+    for (const auto &texture : in) {
+        if (!texture.enabled || !texture.bCanUse)
+            continue;
+        ret = true;
+
+        // Convert lightwave's mapping modes to ours. We let them
+        // as they are, the GenUVcoords step will compute UV
+        // channels if they're not there.
+
+        aiTextureMapping mapping = aiTextureMapping_OTHER;
+        switch (texture.mapMode) {
+            case LWO::Texture::Planar:
+                mapping = aiTextureMapping_PLANE;
+                break;
+            case LWO::Texture::Cylindrical:
+                mapping = aiTextureMapping_CYLINDER;
+                break;
+            case LWO::Texture::Spherical:
+                mapping = aiTextureMapping_SPHERE;
+                break;
+            case LWO::Texture::Cubic:
+                mapping = aiTextureMapping_BOX;
+                break;
+            case LWO::Texture::FrontProjection:
+                ASSIMP_LOG_ERROR("LWO2: Unsupported texture mapping: FrontProjection");
+                mapping = aiTextureMapping_OTHER;
+                break;
+            case LWO::Texture::UV: {
+                if (UINT_MAX == texture.mRealUVIndex) {
+                    // We have no UV index for this texture, so we can't display it
+                    continue;
+                }
+
+                // add the UV source index
+                temp = texture.mRealUVIndex;
+                pcMat->AddProperty<int>((int *)&temp, 1, AI_MATKEY_UVWSRC(type, cur));
+
+                mapping = aiTextureMapping_UV;
+            } break;
+            default:
+                ai_assert(false);
+        };
+
+        if (mapping != aiTextureMapping_UV) {
+            // Setup the main axis
+            aiVector3D v;
+            switch (texture.majorAxis) {
+                case Texture::AXIS_X:
+                    v = aiVector3D(1.0, 0.0, 0.0);
+                    break;
+                case Texture::AXIS_Y:
+                    v = aiVector3D(0.0, 1.0, 0.0);
+                    break;
+                default: // case Texture::AXIS_Z:
+                    v = aiVector3D(0.0, 0.0, 1.0);
+                    break;
+            }
+
+            pcMat->AddProperty(&v, 1, AI_MATKEY_TEXMAP_AXIS(type, cur));
+
+            // Setup UV scalings for cylindric and spherical projections
+            if (mapping == aiTextureMapping_CYLINDER || mapping == aiTextureMapping_SPHERE) {
+                aiUVTransform trafo;
+                trafo.mScaling.x = texture.wrapAmountW;
+                trafo.mScaling.y = texture.wrapAmountH;
+
+                static_assert(sizeof(aiUVTransform) / sizeof(ai_real) == 5, "sizeof(aiUVTransform)/sizeof(ai_real) == 5");
+                pcMat->AddProperty(&trafo, 1, AI_MATKEY_UVTRANSFORM(type, cur));
+            }
+            ASSIMP_LOG_VERBOSE_DEBUG("LWO2: Setting up non-UV mapping");
+        }
+
+        // The older LWOB format does not use indirect references to clips.
+        // The file name of a texture is directly specified in the tex chunk.
+        if (mIsLWO2 || mIsLWO3) {
+            // find the corresponding clip (take the last one if multiple
+            // share the same index)
+            ClipList::iterator end = mClips.end(), candidate = end;
+            temp = texture.mClipIdx;
+            for (ClipList::iterator clip = mClips.begin(); clip != end; ++clip) {
+                if ((*clip).idx == temp) {
+                    candidate = clip;
+                }
+            }
+            if (candidate == end) {
+                ASSIMP_LOG_ERROR("LWO2: Clip index is out of bounds");
+                temp = 0;
+
+                // fixme: apparently some LWO files shipping with Doom3 don't
+                // have clips at all ... check whether that's true or whether
+                // it's a bug in the loader.
+
+                s.Set("$texture.png");
+
+                //continue;
+            } else {
+                if (Clip::UNSUPPORTED == (*candidate).type) {
+                    ASSIMP_LOG_ERROR("LWO2: Clip type is not supported");
+                    continue;
+                }
+                AdjustTexturePath((*candidate).path);
+                s.Set((*candidate).path);
+
+                // Additional image settings
+                int flags = 0;
+                if ((*candidate).negate) {
+                    flags |= aiTextureFlags_Invert;
+                }
+                pcMat->AddProperty(&flags, 1, AI_MATKEY_TEXFLAGS(type, cur));
+            }
+        } else {
+            std::string ss = texture.mFileName;
+            if (!ss.length()) {
+                ASSIMP_LOG_WARN("LWOB: Empty file name");
+                continue;
+            }
+            AdjustTexturePath(ss);
+            s.Set(ss);
+        }
+        pcMat->AddProperty(&s, AI_MATKEY_TEXTURE(type, cur));
+
+        // add the blend factor
+        pcMat->AddProperty<float>(&texture.mStrength, 1, AI_MATKEY_TEXBLEND(type, cur));
+
+        // add the blend operation
+        switch (texture.blendType) {
+            case LWO::Texture::Normal:
+            case LWO::Texture::Multiply:
+                temp = (unsigned int)aiTextureOp_Multiply;
+                break;
+
+            case LWO::Texture::Subtractive:
+            case LWO::Texture::Difference:
+                temp = (unsigned int)aiTextureOp_Subtract;
+                break;
+
+            case LWO::Texture::Divide:
+                temp = (unsigned int)aiTextureOp_Divide;
+                break;
+
+            case LWO::Texture::Additive:
+                temp = (unsigned int)aiTextureOp_Add;
+                break;
+
+            default:
+                temp = (unsigned int)aiTextureOp_Multiply;
+                ASSIMP_LOG_WARN("LWO2: Unsupported texture blend mode: alpha or displacement");
+        }
+        // Setup texture operation
+        pcMat->AddProperty<int>((int *)&temp, 1, AI_MATKEY_TEXOP(type, cur));
+
+        // setup the mapping mode
+        int mapping_ = static_cast<int>(mapping);
+        pcMat->AddProperty<int>(&mapping_, 1, AI_MATKEY_MAPPING(type, cur));
+
+        // add the u-wrapping
+        temp = (unsigned int)GetMapMode(texture.wrapModeWidth);
+        pcMat->AddProperty<int>((int *)&temp, 1, AI_MATKEY_MAPPINGMODE_U(type, cur));
+
+        // add the v-wrapping
+        temp = (unsigned int)GetMapMode(texture.wrapModeHeight);
+        pcMat->AddProperty<int>((int *)&temp, 1, AI_MATKEY_MAPPINGMODE_V(type, cur));
+
+        ++cur;
+    }
+    return ret;
+}
+
+// ------------------------------------------------------------------------------------------------
+void LWOImporter::ConvertMaterial(const LWO::Surface &surf, aiMaterial *pcMat) {
+    // copy the name of the surface
+    aiString st;
+    st.Set(surf.mName);
+    pcMat->AddProperty(&st, AI_MATKEY_NAME);
+
+    const int i = surf.bDoubleSided ? 1 : 0;
+    pcMat->AddProperty(&i, 1, AI_MATKEY_TWOSIDED);
+
+    // add the refraction index and the bump intensity
+    pcMat->AddProperty(&surf.mIOR, 1, AI_MATKEY_REFRACTI);
+    pcMat->AddProperty(&surf.mBumpIntensity, 1, AI_MATKEY_BUMPSCALING);
+
+    aiShadingMode m;
+    if (surf.mSpecularValue && surf.mGlossiness) {
+        float fGloss;
+        if (mIsLWO2 || mIsLWO3) {
+            fGloss = std::pow(surf.mGlossiness * ai_real(10.0) + ai_real(2.0), ai_real(2.0));
+        } else {
+            if (16.0 >= surf.mGlossiness)
+                fGloss = 6.0;
+            else if (64.0 >= surf.mGlossiness)
+                fGloss = 20.0;
+            else if (256.0 >= surf.mGlossiness)
+                fGloss = 50.0;
+            else
+                fGloss = 80.0;
+        }
+
+        pcMat->AddProperty(&surf.mSpecularValue, 1, AI_MATKEY_SHININESS_STRENGTH);
+        pcMat->AddProperty(&fGloss, 1, AI_MATKEY_SHININESS);
+        m = aiShadingMode_Phong;
+    } else
+        m = aiShadingMode_Gouraud;
+
+    // specular color
+    aiColor3D clr = lerp(aiColor3D(1.0, 1.0, 1.0), surf.mColor, surf.mColorHighlights);
+    pcMat->AddProperty(&clr, 1, AI_MATKEY_COLOR_SPECULAR);
+    pcMat->AddProperty(&surf.mSpecularValue, 1, AI_MATKEY_SHININESS_STRENGTH);
+
+    // emissive color
+    // luminosity is not really the same but it affects the surface in a similar way. Some scaling looks good.
+    clr.g = clr.b = clr.r = surf.mLuminosity * ai_real(0.8);
+    pcMat->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_EMISSIVE);
+
+    // opacity ... either additive or default-blended, please
+    if (0.0 != surf.mAdditiveTransparency) {
+        const int add = aiBlendMode_Additive;
+        pcMat->AddProperty(&surf.mAdditiveTransparency, 1, AI_MATKEY_OPACITY);
+        pcMat->AddProperty(&add, 1, AI_MATKEY_BLEND_FUNC);
+    } else if (10e10f != surf.mTransparency) {
+        const int def = aiBlendMode_Default;
+        const float f = 1.0f - surf.mTransparency;
+        pcMat->AddProperty(&f, 1, AI_MATKEY_OPACITY);
+        pcMat->AddProperty(&def, 1, AI_MATKEY_BLEND_FUNC);
+    }
+
+    // ADD TEXTURES to the material
+    // TODO: find out how we can handle COLOR textures correctly...
+    bool b = HandleTextures(pcMat, surf.mColorTextures, aiTextureType_DIFFUSE);
+    b = (b || HandleTextures(pcMat, surf.mDiffuseTextures, aiTextureType_DIFFUSE));
+    HandleTextures(pcMat, surf.mSpecularTextures, aiTextureType_SPECULAR);
+    HandleTextures(pcMat, surf.mGlossinessTextures, aiTextureType_SHININESS);
+    HandleTextures(pcMat, surf.mBumpTextures, aiTextureType_HEIGHT);
+    HandleTextures(pcMat, surf.mOpacityTextures, aiTextureType_OPACITY);
+    HandleTextures(pcMat, surf.mReflectionTextures, aiTextureType_REFLECTION);
+
+    // Now we need to know which shader to use .. iterate through the shader list of
+    // the surface and  search for a name which we know ...
+    for (const auto &shader : surf.mShaders) {
+        if (shader.functionName == "LW_SuperCelShader" || shader.functionName == "AH_CelShader") {
+            ASSIMP_LOG_INFO("LWO2: Mapping LW_SuperCelShader/AH_CelShader to aiShadingMode_Toon");
+
+            m = aiShadingMode_Toon;
+            break;
+        } else if (shader.functionName == "LW_RealFresnel" || shader.functionName == "LW_FastFresnel") {
+            ASSIMP_LOG_INFO("LWO2: Mapping LW_RealFresnel/LW_FastFresnel to aiShadingMode_Fresnel");
+
+            m = aiShadingMode_Fresnel;
+            break;
+        } else {
+            ASSIMP_LOG_WARN("LWO2: Unknown surface shader: ", shader.functionName);
+        }
+    }
+    if (surf.mMaximumSmoothAngle <= 0.0)
+        m = aiShadingMode_Flat;
+    int m_ = static_cast<int>(m);
+    pcMat->AddProperty(&m_, 1, AI_MATKEY_SHADING_MODEL);
+
+    // (the diffuse value is just a scaling factor)
+    // If a diffuse texture is set, we set this value to 1.0
+    clr = (b && false ? aiColor3D(1.0, 1.0, 1.0) : surf.mColor);
+    clr.r *= surf.mDiffuseValue;
+    clr.g *= surf.mDiffuseValue;
+    clr.b *= surf.mDiffuseValue;
+    pcMat->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_DIFFUSE);
+}
+
+// ------------------------------------------------------------------------------------------------
+char LWOImporter::FindUVChannels(LWO::TextureList &list,
+        LWO::Layer & /*layer*/, LWO::UVChannel &uv, unsigned int next) {
+    char ret = 0;
+    for (auto &texture : list) {
+
+        // Ignore textures with non-UV mappings for the moment.
+        if (!texture.enabled || !texture.bCanUse || texture.mapMode != LWO::Texture::UV) {
+            continue;
+        }
+
+        if (texture.mUVChannelIndex == uv.name) {
+            ret = 1;
+
+            // got it.
+            if (texture.mRealUVIndex == UINT_MAX || texture.mRealUVIndex == next) {
+                texture.mRealUVIndex = next;
+            } else {
+                // channel mismatch. need to duplicate the material.
+                ASSIMP_LOG_WARN("LWO: Channel mismatch, would need to duplicate surface [design bug]");
+
+                // TODO
+            }
+        }
+    }
+    return ret;
+}
+
+// ------------------------------------------------------------------------------------------------
+void LWOImporter::FindUVChannels(LWO::Surface &surf,
+        LWO::SortedRep &sorted, LWO::Layer &layer,
+        unsigned int out[AI_MAX_NUMBER_OF_TEXTURECOORDS]) {
+    unsigned int next = 0, extra = 0, num_extra = 0;
+
+    // Check whether we have an UV entry != 0 for one of the faces in 'sorted'
+    for (unsigned int i = 0; i < layer.mUVChannels.size(); ++i) {
+        LWO::UVChannel &uv = layer.mUVChannels[i];
+
+        for (LWO::SortedRep::const_iterator it = sorted.begin(); it != sorted.end(); ++it) {
+
+            LWO::Face &face = layer.mFaces[*it];
+
+            for (unsigned int n = 0; n < face.mNumIndices; ++n) {
+                unsigned int idx = face.mIndices[n];
+
+                if (uv.abAssigned[idx] && ((aiVector2D *)&uv.rawData[0])[idx] != aiVector2D()) {
+
+                    if (extra >= AI_MAX_NUMBER_OF_TEXTURECOORDS) {
+
+                        ASSIMP_LOG_ERROR("LWO: Maximum number of UV channels for "
+                                         "this mesh reached. Skipping channel \'" +
+                                         uv.name + "\'");
+
+                    } else {
+                        // Search through all textures assigned to 'surf' and look for this UV channel
+                        char had = 0;
+                        had |= FindUVChannels(surf.mColorTextures, layer, uv, next);
+                        had |= FindUVChannels(surf.mDiffuseTextures, layer, uv, next);
+                        had |= FindUVChannels(surf.mSpecularTextures, layer, uv, next);
+                        had |= FindUVChannels(surf.mGlossinessTextures, layer, uv, next);
+                        had |= FindUVChannels(surf.mOpacityTextures, layer, uv, next);
+                        had |= FindUVChannels(surf.mBumpTextures, layer, uv, next);
+                        had |= FindUVChannels(surf.mReflectionTextures, layer, uv, next);
+
+                        // We have a texture referencing this UV channel so we have to take special care
+                        // and are willing to drop unreferenced channels in favour of it.
+                        if (had != 0) {
+                            if (num_extra) {
+
+                                for (unsigned int a = next; a < std::min(extra, AI_MAX_NUMBER_OF_TEXTURECOORDS - 1u); ++a) {
+                                    out[a + 1] = out[a];
+                                }
+                            }
+                            ++extra;
+                            out[next++] = i;
+                        }
+                        // Bah ... seems not to be used at all. Push to end if enough space is available.
+                        else {
+                            out[extra++] = i;
+                            ++num_extra;
+                        }
+                    }
+                    it = sorted.end() - 1;
+                    break;
+                }
+            }
+        }
+    }
+    if (extra < AI_MAX_NUMBER_OF_TEXTURECOORDS) {
+        out[extra] = UINT_MAX;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void LWOImporter::FindVCChannels(const LWO::Surface &surf, LWO::SortedRep &sorted, const LWO::Layer &layer,
+        unsigned int out[AI_MAX_NUMBER_OF_COLOR_SETS]) {
+    unsigned int next = 0;
+
+    // Check whether we have an vc entry != 0 for one of the faces in 'sorted'
+    for (unsigned int i = 0; i < layer.mVColorChannels.size(); ++i) {
+        const LWO::VColorChannel &vc = layer.mVColorChannels[i];
+
+        if (surf.mVCMap == vc.name) {
+            // The vertex color map is explicitly requested by the surface so we need to take special care of it
+            for (unsigned int a = 0; a < std::min(next, AI_MAX_NUMBER_OF_COLOR_SETS - 1u); ++a) {
+                out[a + 1] = out[a];
+            }
+            out[0] = i;
+            ++next;
+        } else {
+
+            for (LWO::SortedRep::iterator it = sorted.begin(); it != sorted.end(); ++it) {
+                const LWO::Face &face = layer.mFaces[*it];
+
+                for (unsigned int n = 0; n < face.mNumIndices; ++n) {
+                    unsigned int idx = face.mIndices[n];
+
+                    if (vc.abAssigned[idx] && ((aiColor4D *)&vc.rawData[0])[idx] != aiColor4D(0.0, 0.0, 0.0, 1.0)) {
+                        if (next >= AI_MAX_NUMBER_OF_COLOR_SETS) {
+
+                            ASSIMP_LOG_ERROR("LWO: Maximum number of vertex color channels for "
+                                             "this mesh reached. Skipping channel \'" +
+                                             vc.name + "\'");
+
+                        } else {
+                            out[next++] = i;
+                        }
+                        it = sorted.end() - 1;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    if (next != AI_MAX_NUMBER_OF_COLOR_SETS) {
+        out[next] = UINT_MAX;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void LWOImporter::LoadLWO2ImageMap(unsigned int size, LWO::Texture &tex) {
+    LE_NCONST uint8_t *const end = mFileBuffer + size;
+    while (true) {
+        if (mFileBuffer + 6 >= end) break;
+        LE_NCONST IFF::SubChunkHeader head = IFF::LoadSubChunk(mFileBuffer);
+
+        if (mFileBuffer + head.length > end)
+            throw DeadlyImportError("LWO2: Invalid SURF.BLOCK chunk length");
+
+        uint8_t *const next = mFileBuffer + head.length;
+        switch (head.type) {
+            case AI_LWO_PROJ:
+                tex.mapMode = (Texture::MappingMode)GetU2();
+                break;
+            case AI_LWO_WRAP:
+                tex.wrapModeWidth = (Texture::Wrap)GetU2();
+                tex.wrapModeHeight = (Texture::Wrap)GetU2();
+                break;
+            case AI_LWO_AXIS:
+                tex.majorAxis = (Texture::Axes)GetU2();
+                break;
+            case AI_LWO_IMAG:
+                tex.mClipIdx = GetU2();
+                break;
+            case AI_LWO_VMAP:
+                GetS0(tex.mUVChannelIndex, head.length);
+                break;
+            case AI_LWO_WRPH:
+                tex.wrapAmountH = GetF4();
+                break;
+            case AI_LWO_WRPW:
+                tex.wrapAmountW = GetF4();
+                break;
+        }
+        mFileBuffer = next;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void LWOImporter::LoadLWO2Procedural(unsigned int /*size*/, LWO::Texture &tex) {
+    // --- not supported at the moment
+    ASSIMP_LOG_ERROR("LWO2: Found procedural texture, this is not supported");
+    tex.bCanUse = false;
+}
+
+// ------------------------------------------------------------------------------------------------
+void LWOImporter::LoadLWO2Gradient(unsigned int /*size*/, LWO::Texture &tex) {
+    // --- not supported at the moment
+    ASSIMP_LOG_ERROR("LWO2: Found gradient texture, this is not supported");
+    tex.bCanUse = false;
+}
+
+// ------------------------------------------------------------------------------------------------
+void LWOImporter::LoadLWO2TextureHeader(unsigned int size, LWO::Texture &tex) {
+    LE_NCONST uint8_t *const end = mFileBuffer + size;
+
+    // get the ordinal string
+    GetS0(tex.ordinal, size);
+
+    // we could crash later if this is an empty string ...
+    if (!tex.ordinal.length()) {
+        ASSIMP_LOG_ERROR("LWO2: Ill-formed SURF.BLOK ordinal string");
+        tex.ordinal = "\x00";
+    }
+    while (true) {
+        if (mFileBuffer + 6 >= end) break;
+        const IFF::SubChunkHeader head = IFF::LoadSubChunk(mFileBuffer);
+
+        if (mFileBuffer + head.length > end)
+            throw DeadlyImportError("LWO2: Invalid texture header chunk length");
+
+        uint8_t *const next = mFileBuffer + head.length;
+        switch (head.type) {
+            case AI_LWO_CHAN:
+                tex.type = GetU4();
+                break;
+            case AI_LWO_ENAB:
+                tex.enabled = GetU2() ? true : false;
+                break;
+            case AI_LWO_OPAC:
+                tex.blendType = (Texture::BlendType)GetU2();
+                tex.mStrength = GetF4();
+                break;
+        }
+        mFileBuffer = next;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void LWOImporter::LoadLWO2TextureBlock(LE_NCONST IFF::SubChunkHeader *head, unsigned int size) {
+    ai_assert(!mSurfaces->empty());
+    LWO::Surface &surf = mSurfaces->back();
+    LWO::Texture tex;
+
+    // load the texture header
+    LoadLWO2TextureHeader(head->length, tex);
+    size -= head->length + 6;
+
+    // now get the exact type of the texture
+    switch (head->type) {
+        case AI_LWO_PROC:
+            LoadLWO2Procedural(size, tex);
+            break;
+        case AI_LWO_GRAD:
+            LoadLWO2Gradient(size, tex);
+            break;
+        case AI_LWO_IMAP:
+            LoadLWO2ImageMap(size, tex);
+    }
+
+    // get the destination channel
+    TextureList *listRef = nullptr;
+    switch (tex.type) {
+        case AI_LWO_COLR:
+            listRef = &surf.mColorTextures;
+            break;
+        case AI_LWO_DIFF:
+            listRef = &surf.mDiffuseTextures;
+            break;
+        case AI_LWO_SPEC:
+            listRef = &surf.mSpecularTextures;
+            break;
+        case AI_LWO_GLOS:
+            listRef = &surf.mGlossinessTextures;
+            break;
+        case AI_LWO_BUMP:
+            listRef = &surf.mBumpTextures;
+            break;
+        case AI_LWO_TRAN:
+            listRef = &surf.mOpacityTextures;
+            break;
+        case AI_LWO_REFL:
+            listRef = &surf.mReflectionTextures;
+            break;
+        default:
+            ASSIMP_LOG_WARN("LWO2: Encountered unknown texture type");
+            return;
+    }
+
+    // now attach the texture to the parent surface - sort by ordinal string
+    for (TextureList::iterator it = listRef->begin(); it != listRef->end(); ++it) {
+        if (::strcmp(tex.ordinal.c_str(), (*it).ordinal.c_str()) < 0) {
+            listRef->insert(it, tex);
+            return;
+        }
+    }
+    listRef->push_back(tex);
+}
+
+// ------------------------------------------------------------------------------------------------
+void LWOImporter::LoadLWO2ShaderBlock(LE_NCONST IFF::SubChunkHeader * /*head*/, unsigned int size) {
+    LE_NCONST uint8_t *const end = mFileBuffer + size;
+
+    ai_assert(!mSurfaces->empty());
+    LWO::Surface &surf = mSurfaces->back();
+    LWO::Shader shader;
+
+    // get the ordinal string
+    GetS0(shader.ordinal, size);
+
+    // we could crash later if this is an empty string ...
+    if (!shader.ordinal.length()) {
+        ASSIMP_LOG_ERROR("LWO2: Ill-formed SURF.BLOK ordinal string");
+        shader.ordinal = "\x00";
+    }
+
+    // read the header
+    while (true) {
+        if (mFileBuffer + 6 >= end) break;
+        const IFF::SubChunkHeader head = IFF::LoadSubChunk(mFileBuffer);
+
+        if (mFileBuffer + head.length > end)
+            throw DeadlyImportError("LWO2: Invalid shader header chunk length");
+
+        uint8_t *const next = mFileBuffer + head.length;
+        switch (head.type) {
+            case AI_LWO_ENAB:
+                shader.enabled = GetU2() ? true : false;
+                break;
+
+            case AI_LWO_FUNC:
+                GetS0(shader.functionName, head.length);
+        }
+        mFileBuffer = next;
+    }
+
+    // now attach the shader to the parent surface - sort by ordinal string
+    for (ShaderList::iterator it = surf.mShaders.begin(); it != surf.mShaders.end(); ++it) {
+        if (::strcmp(shader.ordinal.c_str(), (*it).ordinal.c_str()) < 0) {
+            surf.mShaders.insert(it, shader);
+            return;
+        }
+    }
+    surf.mShaders.push_back(shader);
+}
+
+// ------------------------------------------------------------------------------------------------
+void LWOImporter::LoadNodalBlocks(unsigned int size) {
+    LE_NCONST uint8_t *const end = mFileBuffer + size;
+
+    while (true) {
+        if (mFileBuffer + 8 >= end)
+            break;
+
+        IFF::ChunkHeader head = IFF::LoadChunk(mFileBuffer);
+        int bufOffset = 0;
+        if (head.type == AI_IFF_FOURCC_FORM) { // not chunk, it's a form
+            mFileBuffer -= 8;
+            head = IFF::LoadForm(mFileBuffer);
+            bufOffset = 4;
+        }
+
+        if (mFileBuffer + head.length > end) {
+            throw DeadlyImportError("LWO3: cannot read length; LoadNodalBlocks");
+        }
+        int node_idx = 0;
+        uint8_t *const next = mFileBuffer + head.length;
+        mFileBuffer += bufOffset;
+        switch (head.type) {
+        case AI_LWO_NNDS:
+            node_idx++;
+            LoadNodes(head.length);
+            break;
+        }
+
+        mFileBuffer = next;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void LWOImporter::LoadNodes(unsigned int size) {
+    LE_NCONST uint8_t *const end = mFileBuffer + size;
+
+    while (true) {
+        if (mFileBuffer + 8 >= end)
+            break;
+
+        IFF::ChunkHeader head = IFF::LoadChunk(mFileBuffer);
+        int bufOffset = 0;
+        if (head.type == AI_IFF_FOURCC_FORM) { // not chunk, it's a form
+            mFileBuffer -= 8;
+            head = IFF::LoadForm(mFileBuffer);
+            bufOffset = 4;
+        }
+
+        if (mFileBuffer + head.length > end) {
+            throw DeadlyImportError("LWO3: cannot read length; LoadNodes");
+        }
+
+        uint8_t *const next = mFileBuffer + head.length;
+        mFileBuffer += bufOffset;
+        switch (head.type) {
+        case AI_LWO_NTAG:
+            LoadNodeTag(head.length);
+            break;
+        }
+
+        mFileBuffer = next;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void LWOImporter::LoadNodeTag(unsigned int size) {
+    LE_NCONST uint8_t *const end = mFileBuffer + size;
+
+    while (true) {
+        if (mFileBuffer + 8 >= end)
+            break;
+
+        IFF::ChunkHeader head = IFF::LoadChunk(mFileBuffer);
+        int bufOffset = 0;
+        if (head.type == AI_IFF_FOURCC_FORM) { // not chunk, it's a form
+            mFileBuffer -= 8;
+            head = IFF::LoadForm(mFileBuffer);
+            bufOffset = 4;
+        }
+
+        if (mFileBuffer + head.length > end) {
+            throw DeadlyImportError("LWO3: cannot read length; LoadNodeTag");
+        }
+
+        uint8_t *const next = mFileBuffer + head.length;
+        mFileBuffer += bufOffset;
+
+        switch (head.type) {
+        case AI_LWO_NDTA:
+            LoadNodeData(head.length);
+            break;
+        }
+
+        mFileBuffer = next;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void LWOImporter::LoadNodeData(unsigned int size) {
+    LE_NCONST uint8_t *const end = mFileBuffer + size;
+
+    LWO::Surface &surf = mSurfaces->back();
+
+    while (true) {
+        if (mFileBuffer + 8 >= end)
+            break;
+
+        IFF::ChunkHeader head = IFF::LoadChunk(mFileBuffer);
+        int bufOffset = 0;
+        if (head.type == AI_IFF_FOURCC_FORM) { // not chunk, it's a form
+            mFileBuffer -= 8;
+            head = IFF::LoadForm(mFileBuffer);
+            bufOffset = 4;
+        }
+
+        if (mFileBuffer + head.length > end) {
+            throw DeadlyImportError("LWO3: INVALID LENGTH; LoadNodeData");
+        }
+
+        uint8_t *const next = mFileBuffer + head.length;
+        mFileBuffer += bufOffset;
+        switch (head.type) {
+            case AI_LWO_VERS:
+            case AI_LWO_ENUM:
+            case AI_LWO_IBGC:
+            case AI_LWO_IOPC:
+            case AI_LWO_IIMG:
+            case AI_LWO_TXTR:
+            case AI_LWO_IFAL:
+            case AI_LWO_ISCL:
+            case AI_LWO_IPOS:
+            case AI_LWO_IROT:
+            case AI_LWO_IBMP:
+            case AI_LWO_IUTD:
+            case AI_LWO_IVTD:
+
+            case AI_LWO_IPIX:
+            case AI_LWO_IMIP:
+            case AI_LWO_IMOD:
+            case AI_LWO_AMOD:
+            case AI_LWO_IINV:
+            case AI_LWO_INCR:
+            case AI_LWO_IAXS:
+            case AI_LWO_IFOT:
+            case AI_LWO_ITIM:
+            case AI_LWO_IWRL:
+            case AI_LWO_IUTI:
+            case AI_LWO_IUVI:
+            case AI_LWO_IINX:
+            case AI_LWO_IINY:
+            case AI_LWO_IINZ:
+            case AI_LWO_IREF:
+            case AI_LWO_IMST:
+            case AI_LWO_IMAP:
+            case AI_LWO_IUTL:
+            case AI_LWO_IVTL:
+            case AI_LWO_VPVL:
+            case AI_LWO_VPRM:
+                mFileBuffer = next;
+                break;
+            case AI_LWO_ENTR:
+                std::string attrName;
+
+                while (true) {
+                    if (mFileBuffer + 8 >= next)
+                        break;
+
+                    IFF::ChunkHeader head1 = IFF::LoadChunk(mFileBuffer);
+                    int bufOffset1 = 0;
+                    if (head1.type == AI_IFF_FOURCC_FORM) { // not chunk, it's a form
+                        mFileBuffer -= 8;
+                        head1 = IFF::LoadForm(mFileBuffer);
+                        bufOffset1 = 4;
+                    }
+
+                    if (mFileBuffer + head1.length > end) {
+                        throw DeadlyImportError("LWO3: cannot read length;");
+                    }
+                    uint8_t *const next1 = mFileBuffer + head1.length;
+                    mFileBuffer += bufOffset1;
+
+                    switch (head1.type) {
+                        case AI_LWO_FLAG:
+                        case AI_LWO_TAG:
+                            mFileBuffer = next1;
+                            break;
+                        case AI_LWO_NAME:
+                            GetS0(attrName, head1.length);
+                            break;
+                        case AI_LWO_VALU:
+                            mFileBuffer += 8;
+
+                            std::string valueType;
+                            GetS0(valueType, 8);
+
+                            if (valueType == "int") {
+                                static_cast<void>(GetU4());
+                            } else if (valueType == "double") {
+                                static_cast<void>(GetU8());
+                            } else if (valueType == "vparam") {
+                                mFileBuffer += 24;
+
+                                float value = GetF8();
+                                if (attrName == "Diffuse") {
+                                    surf.mDiffuseValue = value;
+                                } else if (attrName == "Specular") {
+                                    surf.mSpecularValue = value;
+                                } else if (attrName == "Transparency") {
+                                    surf.mTransparency = value;
+                                } else if (attrName == "Glossiness") {
+                                    surf.mGlossiness = value;
+                                } else if (attrName == "Luminosity") {
+                                    surf.mLuminosity = value;
+                                } else if (attrName == "Color Highlight") {
+                                    surf.mColorHighlights = value;
+                                } else if (attrName == "Refraction Index") {
+                                    surf.mIOR = value;
+                                } else if (attrName == "Bump Height") {
+                                    surf.mBumpIntensity = value;
+                                }
+                            } else if (valueType == "vparam3") {
+                                mFileBuffer += 24;
+
+                                float value1, value2, value3;
+                                value1 = GetF8();
+                                value2 = GetF8();
+                                value3 = GetF8();
+
+                                if (attrName == "Color") {
+                                    surf.mColor.r = value1;
+                                    surf.mColor.g = value2;
+                                    surf.mColor.b = value3;
+                                }
+                            }
+
+                            mFileBuffer = next1;
+                            break;
+                    }
+                }
+
+                break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void LWOImporter::LoadLWO2Surface(unsigned int size) {
+    LE_NCONST uint8_t *const end = mFileBuffer + size;
+
+    mSurfaces->push_back(LWO::Surface());
+    LWO::Surface &surf = mSurfaces->back();
+
+    GetS0(surf.mName, size);
+
+    // check whether this surface was derived from any other surface
+    std::string derived;
+    GetS0(derived, (unsigned int)(end - mFileBuffer));
+    if (derived.length()) {
+        // yes, find this surface
+        for (SurfaceList::iterator it = mSurfaces->begin(), itEnd = mSurfaces->end() - 1; it != itEnd; ++it) {
+            if ((*it).mName == derived) {
+                // we have it ...
+                surf = *it;
+                derived.clear();
+                break;
+            }
+        }
+        if (derived.size()) {
+            ASSIMP_LOG_WARN("LWO2: Unable to find source surface: ", derived);
+        }
+    }
+
+    while (true) {
+        if (mFileBuffer + 6 >= end)
+            break;
+        const IFF::SubChunkHeader head = IFF::LoadSubChunk(mFileBuffer);
+
+        if (mFileBuffer + head.length > end)
+            throw DeadlyImportError("LWO2: Invalid surface chunk length");
+
+        uint8_t *const next = mFileBuffer + head.length;
+        switch (head.type) {
+                // diffuse color
+            case AI_LWO_COLR: {
+                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, COLR, 12);
+                surf.mColor.r = GetF4();
+                surf.mColor.g = GetF4();
+                surf.mColor.b = GetF4();
+                break;
+            }
+                // diffuse strength ... hopefully
+            case AI_LWO_DIFF: {
+                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, DIFF, 4);
+                surf.mDiffuseValue = GetF4();
+                break;
+            }
+                // specular strength ... hopefully
+            case AI_LWO_SPEC: {
+                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, SPEC, 4);
+                surf.mSpecularValue = GetF4();
+                break;
+            }
+                // transparency
+            case AI_LWO_TRAN: {
+                // transparency explicitly disabled?
+                if (surf.mTransparency == 10e10f)
+                    break;
+
+                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, TRAN, 4);
+                surf.mTransparency = GetF4();
+                break;
+            }
+                // additive transparency
+            case AI_LWO_ADTR: {
+                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, ADTR, 4);
+                surf.mAdditiveTransparency = GetF4();
+                break;
+            }
+                // wireframe mode
+            case AI_LWO_LINE: {
+                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, LINE, 2);
+                if (GetU2() & 0x1)
+                    surf.mWireframe = true;
+                break;
+            }
+                // glossiness
+            case AI_LWO_GLOS: {
+                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, GLOS, 4);
+                surf.mGlossiness = GetF4();
+                break;
+            }
+                // bump intensity
+            case AI_LWO_BUMP: {
+                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, BUMP, 4);
+                surf.mBumpIntensity = GetF4();
+                break;
+            }
+                // color highlights
+            case AI_LWO_CLRH: {
+                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, CLRH, 4);
+                surf.mColorHighlights = GetF4();
+                break;
+            }
+                // index of refraction
+            case AI_LWO_RIND: {
+                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, RIND, 4);
+                surf.mIOR = GetF4();
+                break;
+            }
+                // polygon sidedness
+            case AI_LWO_SIDE: {
+                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, SIDE, 2);
+                surf.bDoubleSided = (3 == GetU2());
+                break;
+            }
+                // maximum smoothing angle
+            case AI_LWO_SMAN: {
+                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, SMAN, 4);
+                surf.mMaximumSmoothAngle = std::fabs(GetF4());
+                break;
+            }
+                // vertex color channel to be applied to the surface
+            case AI_LWO_VCOL: {
+                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, VCOL, 12);
+                surf.mDiffuseValue *= GetF4(); // strength
+                ReadVSizedIntLWO2(mFileBuffer); // skip envelope
+                surf.mVCMapType = GetU4(); // type of the channel
+
+                // name of the channel
+                GetS0(surf.mVCMap, (unsigned int)(next - mFileBuffer));
+                break;
+            }
+                // surface bock entry
+            case AI_LWO_BLOK: {
+                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, BLOK, 4);
+                IFF::SubChunkHeader head2 = IFF::LoadSubChunk(mFileBuffer);
+
+                switch (head2.type) {
+                    case AI_LWO_PROC:
+                    case AI_LWO_GRAD:
+                    case AI_LWO_IMAP:
+                        LoadLWO2TextureBlock(&head2, head.length);
+                        break;
+                    case AI_LWO_SHDR:
+                        LoadLWO2ShaderBlock(&head2, head.length);
+                        break;
+
+                    default:
+                        ASSIMP_LOG_WARN("LWO2: Found an unsupported surface BLOK");
+                };
+
+                break;
+            }
+        }
+        mFileBuffer = next;
+    }
+}
+
+void LWOImporter::LoadLWO3Surface(unsigned int size) {
+    mFileBuffer += 8;
+    LE_NCONST uint8_t *const end = mFileBuffer + size - 12;
+
+    mSurfaces->push_back(LWO::Surface());
+    LWO::Surface &surf = mSurfaces->back();
+
+    GetS0(surf.mName, size);
+
+    // check whether this surface was derived from any other surface
+    std::string derived;
+    GetS0(derived, (unsigned int)(end - mFileBuffer));
+    if (derived.length()) {
+        // yes, find this surface
+        for (SurfaceList::iterator it = mSurfaces->begin(), itEnd = mSurfaces->end() - 1; it != itEnd; ++it) {
+            if ((*it).mName == derived) {
+                // we have it ...
+                surf = *it;
+                derived.clear();
+                break;
+            }
+        }
+        if (derived.size()) {
+            ASSIMP_LOG_WARN("LWO3: Unable to find source surface: ", derived);
+        }
+    }
+    while (true) {
+        if (mFileBuffer + 8 >= end)
+            break;
+
+        IFF::ChunkHeader head = IFF::LoadChunk(mFileBuffer);
+        int bufOffset = 0;
+        if( head.type == AI_IFF_FOURCC_FORM ) { // not chunk, it's a form
+            mFileBuffer -= 8;
+            head = IFF::LoadForm(mFileBuffer);
+            bufOffset = 4;
+        }
+
+        if (mFileBuffer + head.length > end) {
+            throw DeadlyImportError("LWO3: cannot read length; LoadLWO3Surface");
+        }
+
+        uint8_t *const next = mFileBuffer + head.length;
+        mFileBuffer += bufOffset;
+        switch (head.type) {
+            case AI_LWO_NODS:
+                LoadNodalBlocks(head.length);
+                break;
+                // polygon sidedness
+            case AI_LWO_SIDE: {
+                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, SIDE, 2);
+                surf.bDoubleSided = (3 == GetU2());
+                break;
+            }
+                // maximum smoothing angle
+            case AI_LWO_SMAN: {
+                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, SMAN, 4);
+                surf.mMaximumSmoothAngle = std::fabs(GetF4());
+                break;
+            }
+        }
+        mFileBuffer = next;
+    }
+}
+
+#endif // !! ASSIMP_BUILD_NO_X_IMPORTER
diff --git a/Engine/lib/assimp/code/LWS/LWSLoader.cpp b/Engine/lib/assimp/code/AssetLib/LWS/LWSLoader.cpp
similarity index 63%
rename from Engine/lib/assimp/code/LWS/LWSLoader.cpp
rename to Engine/lib/assimp/code/AssetLib/LWS/LWSLoader.cpp
index b52cafa6d..951dbe180 100644
--- a/Engine/lib/assimp/code/LWS/LWSLoader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/LWS/LWSLoader.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -45,22 +43,21 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Implementation of the LWS importer class
  */
 
-
 #ifndef ASSIMP_BUILD_NO_LWS_IMPORTER
 
-#include "LWS/LWSLoader.h"
-#include "PostProcessing/ConvertToLHProcess.h"
+#include "AssetLib/LWS/LWSLoader.h"
 #include "Common/Importer.h"
+#include "PostProcessing/ConvertToLHProcess.h"
 
-#include <assimp/ParsingUtils.h>
-#include <assimp/fast_atof.h>
-#include <assimp/SceneCombiner.h>
 #include <assimp/GenericProperty.h>
+#include <assimp/ParsingUtils.h>
+#include <assimp/SceneCombiner.h>
 #include <assimp/SkeletonMeshBuilder.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/scene.h>
-#include <assimp/IOSystem.hpp>
+#include <assimp/fast_atof.h>
 #include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOSystem.hpp>
 
 #include <memory>
 
@@ -81,9 +78,8 @@ static const aiImporterDesc desc = {
 
 // ------------------------------------------------------------------------------------------------
 // Recursive parsing of LWS files
-void LWS::Element::Parse (const char*& buffer)
-{
-    for (;SkipSpacesAndLineEnd(&buffer);SkipLine(&buffer)) {
+void LWS::Element::Parse(const char *&buffer) {
+    for (; SkipSpacesAndLineEnd(&buffer); SkipLine(&buffer)) {
 
         // begin of a new element with children
         bool sub = false;
@@ -91,27 +87,26 @@ void LWS::Element::Parse (const char*& buffer)
             ++buffer;
             SkipSpaces(&buffer);
             sub = true;
-        }
-        else if (*buffer == '}')
+        } else if (*buffer == '}')
             return;
 
         children.push_back(Element());
 
         // copy data line - read token per token
 
-        const char* cur = buffer;
-        while (!IsSpaceOrNewLine(*buffer)) ++buffer;
-        children.back().tokens[0] = std::string(cur,(size_t) (buffer-cur));
+        const char *cur = buffer;
+        while (!IsSpaceOrNewLine(*buffer))
+            ++buffer;
+        children.back().tokens[0] = std::string(cur, (size_t)(buffer - cur));
         SkipSpaces(&buffer);
 
-        if (children.back().tokens[0] == "Plugin")
-        {
-            ASSIMP_LOG_DEBUG("LWS: Skipping over plugin-specific data");
+        if (children.back().tokens[0] == "Plugin") {
+            ASSIMP_LOG_VERBOSE_DEBUG("LWS: Skipping over plugin-specific data");
 
             // strange stuff inside Plugin/Endplugin blocks. Needn't
             // follow LWS syntax, so we skip over it
-            for (;SkipSpacesAndLineEnd(&buffer);SkipLine(&buffer)) {
-                if (!::strncmp(buffer,"EndPlugin",9)) {
+            for (; SkipSpacesAndLineEnd(&buffer); SkipLine(&buffer)) {
+                if (!::strncmp(buffer, "EndPlugin", 9)) {
                     //SkipLine(&buffer);
                     break;
                 }
@@ -120,113 +115,103 @@ void LWS::Element::Parse (const char*& buffer)
         }
 
         cur = buffer;
-        while (!IsLineEnd(*buffer)) ++buffer;
-        children.back().tokens[1] = std::string(cur,(size_t) (buffer-cur));
+        while (!IsLineEnd(*buffer)) {
+            ++buffer;
+        }
+        children.back().tokens[1] = std::string(cur, (size_t)(buffer - cur));
 
         // parse more elements recursively
-        if (sub)
+        if (sub) {
             children.back().Parse(buffer);
+        }
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-LWSImporter::LWSImporter()
-    : configSpeedFlag(),
-    io(),
-    first(),
-    last(),
-    fps(),
-    noSkeletonMesh()
-{
+LWSImporter::LWSImporter() :
+        configSpeedFlag(),
+        io(),
+        first(),
+        last(),
+        fps(),
+        noSkeletonMesh() {
     // nothing to do here
 }
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-LWSImporter::~LWSImporter()
-{
+LWSImporter::~LWSImporter() {
     // nothing to do here
 }
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool LWSImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler,bool checkSig) const
-{
-    const std::string extension = GetExtension(pFile);
-    if (extension == "lws" || extension == "mot")
-        return true;
-
-    // if check for extension is not enough, check for the magic tokens LWSC and LWMO
-    if (!extension.length() || checkSig) {
-        uint32_t tokens[2];
-        tokens[0] = AI_MAKE_MAGIC("LWSC");
-        tokens[1] = AI_MAKE_MAGIC("LWMO");
-        return CheckMagicToken(pIOHandler,pFile,tokens,2);
-    }
-    return false;
+bool LWSImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
+    static const uint32_t tokens[] = {
+        AI_MAKE_MAGIC("LWSC"),
+        AI_MAKE_MAGIC("LWMO")
+    };
+    return CheckMagicToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get list of file extensions
-const aiImporterDesc* LWSImporter::GetInfo () const
-{
+const aiImporterDesc *LWSImporter::GetInfo() const {
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup configuration properties
-void LWSImporter::SetupProperties(const Importer* pImp)
-{
+void LWSImporter::SetupProperties(const Importer *pImp) {
     // AI_CONFIG_FAVOUR_SPEED
-    configSpeedFlag = (0 != pImp->GetPropertyInteger(AI_CONFIG_FAVOUR_SPEED,0));
+    configSpeedFlag = (0 != pImp->GetPropertyInteger(AI_CONFIG_FAVOUR_SPEED, 0));
 
     // AI_CONFIG_IMPORT_LWS_ANIM_START
     first = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_LWS_ANIM_START,
-        150392 /* magic hack */);
+            150392 /* magic hack */);
 
     // AI_CONFIG_IMPORT_LWS_ANIM_END
     last = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_LWS_ANIM_END,
-        150392 /* magic hack */);
+            150392 /* magic hack */);
 
     if (last < first) {
-        std::swap(last,first);
+        std::swap(last, first);
     }
 
-    noSkeletonMesh = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_NO_SKELETON_MESHES,0) != 0;
+    noSkeletonMesh = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_NO_SKELETON_MESHES, 0) != 0;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Read an envelope description
-void LWSImporter::ReadEnvelope(const LWS::Element& dad, LWO::Envelope& fill )
-{
+void LWSImporter::ReadEnvelope(const LWS::Element &dad, LWO::Envelope &fill) {
     if (dad.children.empty()) {
         ASSIMP_LOG_ERROR("LWS: Envelope descriptions must not be empty");
         return;
     }
 
     // reserve enough storage
-    std::list< LWS::Element >::const_iterator it = dad.children.begin();;
+    std::list<LWS::Element>::const_iterator it = dad.children.begin();
+
     fill.keys.reserve(strtoul10(it->tokens[1].c_str()));
 
     for (++it; it != dad.children.end(); ++it) {
-        const char* c = (*it).tokens[1].c_str();
+        const char *c = (*it).tokens[1].c_str();
 
         if ((*it).tokens[0] == "Key") {
             fill.keys.push_back(LWO::Key());
-            LWO::Key& key = fill.keys.back();
+            LWO::Key &key = fill.keys.back();
 
             float f;
             SkipSpaces(&c);
-            c = fast_atoreal_move<float>(c,key.value);
+            c = fast_atoreal_move<float>(c, key.value);
             SkipSpaces(&c);
-            c = fast_atoreal_move<float>(c,f);
+            c = fast_atoreal_move<float>(c, f);
 
             key.time = f;
 
-            unsigned int span = strtoul10(c,&c), num = 0;
+            unsigned int span = strtoul10(c, &c), num = 0;
             switch (span) {
-
                 case 0:
                     key.inter = LWO::IT_TCB;
                     num = 5;
@@ -251,16 +236,15 @@ void LWSImporter::ReadEnvelope(const LWS::Element& dad, LWO::Envelope& fill )
                 default:
                     ASSIMP_LOG_ERROR("LWS: Unknown span type");
             }
-            for (unsigned int i = 0; i < num;++i) {
+            for (unsigned int i = 0; i < num; ++i) {
                 SkipSpaces(&c);
-                c = fast_atoreal_move<float>(c,key.params[i]);
+                c = fast_atoreal_move<float>(c, key.params[i]);
             }
-        }
-        else if ((*it).tokens[0] == "Behaviors") {
+        } else if ((*it).tokens[0] == "Behaviors") {
             SkipSpaces(&c);
-            fill.pre = (LWO::PrePostBehaviour) strtoul10(c,&c);
+            fill.pre = (LWO::PrePostBehaviour)strtoul10(c, &c);
             SkipSpaces(&c);
-            fill.post = (LWO::PrePostBehaviour) strtoul10(c,&c);
+            fill.post = (LWO::PrePostBehaviour)strtoul10(c, &c);
         }
     }
 }
@@ -268,36 +252,37 @@ void LWSImporter::ReadEnvelope(const LWS::Element& dad, LWO::Envelope& fill )
 // ------------------------------------------------------------------------------------------------
 // Read animation channels in the old LightWave animation format
 void LWSImporter::ReadEnvelope_Old(
-    std::list< LWS::Element >::const_iterator& it,
-    const std::list< LWS::Element >::const_iterator& end,
-    LWS::NodeDesc& nodes,
-    unsigned int /*version*/)
-{
-    unsigned int num,sub_num;
-    if (++it == end)goto unexpected_end;
+        std::list<LWS::Element>::const_iterator &it,
+        const std::list<LWS::Element>::const_iterator &end,
+        LWS::NodeDesc &nodes,
+        unsigned int /*version*/) {
+    unsigned int num, sub_num;
+    if (++it == end) goto unexpected_end;
 
     num = strtoul10((*it).tokens[0].c_str());
     for (unsigned int i = 0; i < num; ++i) {
 
         nodes.channels.push_back(LWO::Envelope());
-        LWO::Envelope& envl = nodes.channels.back();
+        LWO::Envelope &envl = nodes.channels.back();
 
         envl.index = i;
-        envl.type  = (LWO::EnvelopeType)(i+1);
+        envl.type = (LWO::EnvelopeType)(i + 1);
 
-        if (++it == end)goto unexpected_end;
+        if (++it == end) {
+            goto unexpected_end;
+        }
         sub_num = strtoul10((*it).tokens[0].c_str());
 
-        for (unsigned int n = 0; n < sub_num;++n) {
+        for (unsigned int n = 0; n < sub_num; ++n) {
 
-            if (++it == end)goto unexpected_end;
+            if (++it == end) goto unexpected_end;
 
             // parse value and time, skip the rest for the moment.
             LWO::Key key;
-            const char* c = fast_atoreal_move<float>((*it).tokens[0].c_str(),key.value);
+            const char *c = fast_atoreal_move<float>((*it).tokens[0].c_str(), key.value);
             SkipSpaces(&c);
             float f;
-            fast_atoreal_move<float>((*it).tokens[0].c_str(),f);
+            fast_atoreal_move<float>((*it).tokens[0].c_str(), f);
             key.time = f;
 
             envl.keys.push_back(key);
@@ -311,51 +296,50 @@ unexpected_end:
 
 // ------------------------------------------------------------------------------------------------
 // Setup a nice name for a node
-void LWSImporter::SetupNodeName(aiNode* nd, LWS::NodeDesc& src)
-{
+void LWSImporter::SetupNodeName(aiNode *nd, LWS::NodeDesc &src) {
     const unsigned int combined = src.number | ((unsigned int)src.type) << 28u;
 
     // the name depends on the type. We break LWS's strange naming convention
     // and return human-readable, but still machine-parsable and unique, strings.
-    if (src.type == LWS::NodeDesc::OBJECT)  {
+    if (src.type == LWS::NodeDesc::OBJECT) {
 
         if (src.path.length()) {
             std::string::size_type s = src.path.find_last_of("\\/");
-            if (s == std::string::npos)
+            if (s == std::string::npos) {
                 s = 0;
-            else ++s;
-            std::string::size_type t = src.path.substr(s).find_last_of(".");
+            } else {
+                ++s;
+            }
+            std::string::size_type t = src.path.substr(s).find_last_of('.');
 
-            nd->mName.length = ::ai_snprintf(nd->mName.data, MAXLEN, "%s_(%08X)",src.path.substr(s).substr(0,t).c_str(),combined);
+            nd->mName.length = ::ai_snprintf(nd->mName.data, MAXLEN, "%s_(%08X)", src.path.substr(s).substr(0, t).c_str(), combined);
             return;
         }
     }
-    nd->mName.length = ::ai_snprintf(nd->mName.data, MAXLEN, "%s_(%08X)",src.name,combined);
+    nd->mName.length = ::ai_snprintf(nd->mName.data, MAXLEN, "%s_(%08X)", src.name, combined);
 }
 
 // ------------------------------------------------------------------------------------------------
-// Recursively build the scenegraph
-void LWSImporter::BuildGraph(aiNode* nd, LWS::NodeDesc& src, std::vector<AttachmentInfo>& attach,
-    BatchLoader& batch,
-    aiCamera**& camOut,
-    aiLight**& lightOut,
-    std::vector<aiNodeAnim*>& animOut)
-{
+// Recursively build the scene-graph
+void LWSImporter::BuildGraph(aiNode *nd, LWS::NodeDesc &src, std::vector<AttachmentInfo> &attach,
+        BatchLoader &batch,
+        aiCamera **&camOut,
+        aiLight **&lightOut,
+        std::vector<aiNodeAnim *> &animOut) {
     // Setup a very cryptic name for the node, we want the user to be happy
-    SetupNodeName(nd,src);
-    aiNode* ndAnim = nd;
+    SetupNodeName(nd, src);
+    aiNode *ndAnim = nd;
 
     // If the node is an object
     if (src.type == LWS::NodeDesc::OBJECT) {
 
         // If the object is from an external file, get it
-        aiScene* obj = NULL;
-        if (src.path.length() ) {
+        aiScene *obj = nullptr;
+        if (src.path.length()) {
             obj = batch.GetImport(src.id);
             if (!obj) {
-                ASSIMP_LOG_ERROR("LWS: Failed to read external file " + src.path);
-            }
-            else {
+                ASSIMP_LOG_ERROR("LWS: Failed to read external file ", src.path);
+            } else {
                 if (obj->mRootNode->mNumChildren == 1) {
 
                     //If the pivot is not set for this layer, get it from the external object
@@ -366,8 +350,8 @@ void LWSImporter::BuildGraph(aiNode* nd, LWS::NodeDesc& src, std::vector<Attachm
                     }
 
                     //Remove first node from obj (the old pivot), reset transform of second node (the mesh node)
-                    aiNode* newRootNode = obj->mRootNode->mChildren[0];
-                    obj->mRootNode->mChildren[0] = NULL;
+                    aiNode *newRootNode = obj->mRootNode->mChildren[0];
+                    obj->mRootNode->mChildren[0] = nullptr;
                     delete obj->mRootNode;
 
                     obj->mRootNode = newRootNode;
@@ -384,7 +368,7 @@ void LWSImporter::BuildGraph(aiNode* nd, LWS::NodeDesc& src, std::vector<Attachm
 
         //Add the attachment node to it
         nd->mNumChildren = 1;
-        nd->mChildren = new aiNode*[1];
+        nd->mChildren = new aiNode *[1];
         nd->mChildren[0] = new aiNode();
         nd->mChildren[0]->mParent = nd;
         nd->mChildren[0]->mTransformation.a4 = -src.pivotPos.x;
@@ -397,16 +381,16 @@ void LWSImporter::BuildGraph(aiNode* nd, LWS::NodeDesc& src, std::vector<Attachm
 
         //Push attachment, if the object came from an external file
         if (obj) {
-            attach.push_back(AttachmentInfo(obj,nd));
+            attach.push_back(AttachmentInfo(obj, nd));
         }
     }
 
     // If object is a light source - setup a corresponding ai structure
     else if (src.type == LWS::NodeDesc::LIGHT) {
-        aiLight* lit = *lightOut++ = new aiLight();
+        aiLight *lit = *lightOut++ = new aiLight();
 
         // compute final light color
-        lit->mColorDiffuse = lit->mColorSpecular = src.lightColor*src.lightIntensity;
+        lit->mColorDiffuse = lit->mColorSpecular = src.lightColor * src.lightIntensity;
 
         // name to attach light to node -> unique due to LWs indexing system
         lit->mName = nd->mName;
@@ -415,42 +399,40 @@ void LWSImporter::BuildGraph(aiNode* nd, LWS::NodeDesc& src, std::vector<Attachm
         if (src.lightType == 2) { /* spot light */
 
             lit->mType = aiLightSource_SPOT;
-            lit->mAngleInnerCone = (float)AI_DEG_TO_RAD( src.lightConeAngle );
-            lit->mAngleOuterCone = lit->mAngleInnerCone+(float)AI_DEG_TO_RAD( src.lightEdgeAngle );
+            lit->mAngleInnerCone = (float)AI_DEG_TO_RAD(src.lightConeAngle);
+            lit->mAngleOuterCone = lit->mAngleInnerCone + (float)AI_DEG_TO_RAD(src.lightEdgeAngle);
 
-        }
-        else if (src.lightType == 1) { /* directional light source */
+        } else if (src.lightType == 1) { /* directional light source */
             lit->mType = aiLightSource_DIRECTIONAL;
+        } else {
+            lit->mType = aiLightSource_POINT;
         }
-        else lit->mType = aiLightSource_POINT;
 
         // fixme: no proper handling of light falloffs yet
-        if (src.lightFalloffType == 1)
+        if (src.lightFalloffType == 1) {
             lit->mAttenuationConstant = 1.f;
-        else if (src.lightFalloffType == 1)
+        } else if (src.lightFalloffType == 2) {
             lit->mAttenuationLinear = 1.f;
-        else
+        } else {
             lit->mAttenuationQuadratic = 1.f;
-    }
-
-    // If object is a camera - setup a corresponding ai structure
-    else if (src.type == LWS::NodeDesc::CAMERA) {
-        aiCamera* cam = *camOut++ = new aiCamera();
+        }
+    } else if (src.type == LWS::NodeDesc::CAMERA) { // If object is a camera - setup a corresponding ai structure
+        aiCamera *cam = *camOut++ = new aiCamera();
 
         // name to attach cam to node -> unique due to LWs indexing system
         cam->mName = nd->mName;
     }
 
     // Get the node transformation from the LWO key
-    LWO::AnimResolver resolver(src.channels,fps);
+    LWO::AnimResolver resolver(src.channels, fps);
     resolver.ExtractBindPose(ndAnim->mTransformation);
 
     // .. and construct animation channels
-    aiNodeAnim* anim = NULL;
+    aiNodeAnim *anim = nullptr;
 
     if (first != last) {
-        resolver.SetAnimationRange(first,last);
-        resolver.ExtractAnimChannel(&anim,AI_LWO_ANIM_FLAG_SAMPLE_ANIMS|AI_LWO_ANIM_FLAG_START_AT_ZERO);
+        resolver.SetAnimationRange(first, last);
+        resolver.ExtractAnimChannel(&anim, AI_LWO_ANIM_FLAG_SAMPLE_ANIMS | AI_LWO_ANIM_FLAG_START_AT_ZERO);
         if (anim) {
             anim->mNodeName = ndAnim->mName;
             animOut.push_back(anim);
@@ -459,27 +441,24 @@ void LWSImporter::BuildGraph(aiNode* nd, LWS::NodeDesc& src, std::vector<Attachm
 
     // Add children
     if (!src.children.empty()) {
-        nd->mChildren = new aiNode*[src.children.size()];
-        for (std::list<LWS::NodeDesc*>::iterator it = src.children.begin(); it != src.children.end(); ++it) {
-            aiNode* ndd = nd->mChildren[nd->mNumChildren++] = new aiNode();
+        nd->mChildren = new aiNode *[src.children.size()];
+        for (std::list<LWS::NodeDesc *>::iterator it = src.children.begin(); it != src.children.end(); ++it) {
+            aiNode *ndd = nd->mChildren[nd->mNumChildren++] = new aiNode();
             ndd->mParent = nd;
 
-            BuildGraph(ndd,**it,attach,batch,camOut,lightOut,animOut);
+            BuildGraph(ndd, **it, attach, batch, camOut, lightOut, animOut);
         }
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Determine the exact location of a LWO file
-std::string LWSImporter::FindLWOFile(const std::string& in)
-{
+std::string LWSImporter::FindLWOFile(const std::string &in) {
     // insert missing directory separator if necessary
-    std::string tmp;
-    if (in.length() > 3 && in[1] == ':'&& in[2] != '\\' && in[2] != '/')
-    {
+    std::string tmp(in);
+    if (in.length() > 3 && in[1] == ':' && in[2] != '\\' && in[2] != '/') {
         tmp = in[0] + (std::string(":\\") + in.substr(2));
     }
-    else tmp = in;
 
     if (io->Exists(tmp)) {
         return in;
@@ -503,35 +482,32 @@ std::string LWSImporter::FindLWOFile(const std::string& in)
         return test;
     }
 
-
     // return original path, maybe the IOsystem knows better
     return tmp;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Read file into given scene data structure
-void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
-    IOSystem* pIOHandler)
-{
+void LWSImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
     io = pIOHandler;
-    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));
+    std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));
 
     // Check whether we can read from the file
-    if( file.get() == NULL) {
-        throw DeadlyImportError( "Failed to open LWS file " + pFile + ".");
+    if (file.get() == nullptr) {
+        throw DeadlyImportError("Failed to open LWS file ", pFile, ".");
     }
 
     // Allocate storage and copy the contents of the file to a memory buffer
-    std::vector< char > mBuffer;
-    TextFileToBuffer(file.get(),mBuffer);
+    std::vector<char> mBuffer;
+    TextFileToBuffer(file.get(), mBuffer);
 
     // Parse the file structure
-    LWS::Element root; const char* dummy = &mBuffer[0];
+    LWS::Element root;
+    const char *dummy = &mBuffer[0];
     root.Parse(dummy);
 
-    // Construct a Batchimporter to read more files recursively
+    // Construct a Batch-importer to read more files recursively
     BatchLoader batch(pIOHandler);
-//  batch.SetBasePath(pFile);
 
     // Construct an array to receive the flat output graph
     std::list<LWS::NodeDesc> nodes;
@@ -541,101 +517,102 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
 
     // check magic identifier, 'LWSC'
     bool motion_file = false;
-    std::list< LWS::Element >::const_iterator it = root.children.begin();
+    std::list<LWS::Element>::const_iterator it = root.children.begin();
 
-    if ((*it).tokens[0] == "LWMO")
+    if ((*it).tokens[0] == "LWMO") {
         motion_file = true;
+    }
 
-    if ((*it).tokens[0] != "LWSC" && !motion_file)
+    if ((*it).tokens[0] != "LWSC" && !motion_file) {
         throw DeadlyImportError("LWS: Not a LightWave scene, magic tag LWSC not found");
+    }
 
     // get file format version and print to log
     ++it;
-    unsigned int version = strtoul10((*it).tokens[0].c_str());
-    ASSIMP_LOG_INFO("LWS file format version is " + (*it).tokens[0]);
-    first = 0.;
-    last  = 60.;
-    fps   = 25.; /* seems to be a good default frame rate */
 
-    // Now read all elements in a very straghtforward manner
+    if (it == root.children.end() || (*it).tokens[0].empty()) {
+        ASSIMP_LOG_ERROR("Invalid LWS file detectedm abort import.");
+        return;
+    }
+    unsigned int version = strtoul10((*it).tokens[0].c_str());
+    ASSIMP_LOG_INFO("LWS file format version is ", (*it).tokens[0]);
+    first = 0.;
+    last = 60.;
+    fps = 25.; // seems to be a good default frame rate
+
+    // Now read all elements in a very straightforward manner
     for (; it != root.children.end(); ++it) {
-        const char* c = (*it).tokens[1].c_str();
+        const char *c = (*it).tokens[1].c_str();
 
         // 'FirstFrame': begin of animation slice
         if ((*it).tokens[0] == "FirstFrame") {
-            if (150392. != first           /* see SetupProperties() */)
-                first = strtoul10(c,&c)-1.; /* we're zero-based */
-        }
-
-        // 'LastFrame': end of animation slice
-        else if ((*it).tokens[0] == "LastFrame") {
-            if (150392. != last      /* see SetupProperties() */)
-                last = strtoul10(c,&c)-1.; /* we're zero-based */
-        }
-
-        // 'FramesPerSecond': frames per second
-        else if ((*it).tokens[0] == "FramesPerSecond") {
-            fps = strtoul10(c,&c);
-        }
-
-        // 'LoadObjectLayer': load a layer of a specific LWO file
-        else if ((*it).tokens[0] == "LoadObjectLayer") {
+            // see SetupProperties()
+            if (150392. != first ) {
+                first = strtoul10(c, &c) - 1.; // we're zero-based
+            }
+        } else if ((*it).tokens[0] == "LastFrame") { // 'LastFrame': end of animation slice
+            // see SetupProperties()
+            if (150392. != last ) {
+                last = strtoul10(c, &c) - 1.; // we're zero-based
+            }
+        } else if ((*it).tokens[0] == "FramesPerSecond") { // 'FramesPerSecond': frames per second
+            fps = strtoul10(c, &c);
+        } else if ((*it).tokens[0] == "LoadObjectLayer") { // 'LoadObjectLayer': load a layer of a specific LWO file
 
             // get layer index
-            const int layer = strtoul10(c,&c);
+            const int layer = strtoul10(c, &c);
 
             // setup the layer to be loaded
             BatchLoader::PropertyMap props;
-            SetGenericProperty(props.ints,AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY,layer);
+            SetGenericProperty(props.ints, AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY, layer);
 
             // add node to list
             LWS::NodeDesc d;
             d.type = LWS::NodeDesc::OBJECT;
             if (version >= 4) { // handle LWSC 4 explicit ID
                 SkipSpaces(&c);
-                d.number = strtoul16(c,&c) & AI_LWS_MASK;
+                d.number = strtoul16(c, &c) & AI_LWS_MASK;
+            } else {
+                d.number = cur_object++;
             }
-            else d.number = cur_object++;
 
             // and add the file to the import list
             SkipSpaces(&c);
-            std::string path = FindLWOFile( c );
+            std::string path = FindLWOFile(c);
             d.path = path;
-            d.id = batch.AddLoadRequest(path,0,&props);
+            d.id = batch.AddLoadRequest(path, 0, &props);
 
             nodes.push_back(d);
-            num_object++;
-        }
-        // 'LoadObject': load a LWO file into the scenegraph
-        else if ((*it).tokens[0] == "LoadObject") {
+            ++num_object;
+        } else if ((*it).tokens[0] == "LoadObject") { // 'LoadObject': load a LWO file into the scene-graph
 
             // add node to list
             LWS::NodeDesc d;
             d.type = LWS::NodeDesc::OBJECT;
 
             if (version >= 4) { // handle LWSC 4 explicit ID
-                d.number = strtoul16(c,&c) & AI_LWS_MASK;
+                d.number = strtoul16(c, &c) & AI_LWS_MASK;
                 SkipSpaces(&c);
+            } else {
+                d.number = cur_object++;
             }
-            else d.number = cur_object++;
-            std::string path = FindLWOFile( c );
-            d.id = batch.AddLoadRequest(path,0,NULL);
+            std::string path = FindLWOFile(c);
+            d.id = batch.AddLoadRequest(path, 0, nullptr);
 
             d.path = path;
             nodes.push_back(d);
-            num_object++;
-        }
-        // 'AddNullObject': add a dummy node to the hierarchy
-        else if ((*it).tokens[0] == "AddNullObject") {
+            ++num_object;
+        } else if ((*it).tokens[0] == "AddNullObject") { // 'AddNullObject': add a dummy node to the hierarchy
 
             // add node to list
             LWS::NodeDesc d;
             d.type = LWS::NodeDesc::OBJECT;
             if (version >= 4) { // handle LWSC 4 explicit ID
-                d.number = strtoul16(c,&c) & AI_LWS_MASK;
+                d.number = strtoul16(c, &c) & AI_LWS_MASK;
                 SkipSpaces(&c);
+            } else {
+                d.number = cur_object++;
             }
-            else d.number = cur_object++;
             d.name = c;
             nodes.push_back(d);
 
@@ -662,13 +639,13 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
 
             // important: index of channel
             nodes.back().channels.push_back(LWO::Envelope());
-            LWO::Envelope& env = nodes.back().channels.back();
+            LWO::Envelope &env = nodes.back().channels.back();
 
             env.index = strtoul10(c);
 
             // currently we can just interpret the standard channels 0...9
             // (hack) assume that index-i yields the binary channel type from LWO
-            env.type = (LWO::EnvelopeType)(env.index+1);
+            env.type = (LWO::EnvelopeType)(env.index + 1);
 
         }
         // 'Envelope': a single animation channel
@@ -676,18 +653,18 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
             if (nodes.empty() || nodes.back().channels.empty())
                 ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'Envelope\'");
             else {
-                ReadEnvelope((*it),nodes.back().channels.back());
+                ReadEnvelope((*it), nodes.back().channels.back());
             }
         }
         // 'ObjectMotion': animation information for older lightwave formats
-        else if (version < 3  && ((*it).tokens[0] == "ObjectMotion" ||
-            (*it).tokens[0] == "CameraMotion" ||
-            (*it).tokens[0] == "LightMotion")) {
+        else if (version < 3 && ((*it).tokens[0] == "ObjectMotion" ||
+                                        (*it).tokens[0] == "CameraMotion" ||
+                                        (*it).tokens[0] == "LightMotion")) {
 
             if (nodes.empty())
                 ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'<Light|Object|Camera>Motion\'");
             else {
-                ReadEnvelope_Old(it,root.children.end(),nodes.back(),version);
+                ReadEnvelope_Old(it, root.children.end(), nodes.back(), version);
             }
         }
         // 'Pre/PostBehavior': pre/post animation behaviour for LWSC 2
@@ -695,11 +672,13 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
             if (nodes.empty())
                 ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'Pre/PostBehavior'");
             else {
-                for (std::list<LWO::Envelope>::iterator it = nodes.back().channels.begin(); it != nodes.back().channels.end(); ++it) {
+                for (std::list<LWO::Envelope>::iterator envelopeIt = nodes.back().channels.begin(); envelopeIt != nodes.back().channels.end(); ++envelopeIt) {
                     // two ints per envelope
-                    LWO::Envelope& env = *it;
-                    env.pre  = (LWO::PrePostBehaviour) strtoul10(c,&c); SkipSpaces(&c);
-                    env.post = (LWO::PrePostBehaviour) strtoul10(c,&c); SkipSpaces(&c);
+                    LWO::Envelope &env = *envelopeIt;
+                    env.pre = (LWO::PrePostBehaviour)strtoul10(c, &c);
+                    SkipSpaces(&c);
+                    env.post = (LWO::PrePostBehaviour)strtoul10(c, &c);
+                    SkipSpaces(&c);
                 }
             }
         }
@@ -708,7 +687,8 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
             if (nodes.empty())
                 ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'ParentItem\'");
 
-            else nodes.back().parent = strtoul16(c,&c);
+            else
+                nodes.back().parent = strtoul16(c, &c);
         }
         // 'ParentObject': deprecated one for older formats
         else if (version < 3 && (*it).tokens[0] == "ParentObject") {
@@ -716,7 +696,7 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
                 ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'ParentObject\'");
 
             else {
-                nodes.back().parent = strtoul10(c,&c) | (1u << 28u);
+                nodes.back().parent = strtoul10(c, &c) | (1u << 28u);
             }
         }
         // 'AddCamera': add a camera to the scenegraph
@@ -727,9 +707,9 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
             d.type = LWS::NodeDesc::CAMERA;
 
             if (version >= 4) { // handle LWSC 4 explicit ID
-                d.number = strtoul16(c,&c) & AI_LWS_MASK;
-            }
-            else d.number = cur_camera++;
+                d.number = strtoul16(c, &c) & AI_LWS_MASK;
+            } else
+                d.number = cur_camera++;
             nodes.push_back(d);
 
             num_camera++;
@@ -739,7 +719,8 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
             if (nodes.empty() || nodes.back().type != LWS::NodeDesc::CAMERA)
                 ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'CameraName\'");
 
-            else nodes.back().name = c;
+            else
+                nodes.back().name = c;
         }
         // 'AddLight': add a light to the scenegraph
         else if ((*it).tokens[0] == "AddLight") {
@@ -749,9 +730,9 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
             d.type = LWS::NodeDesc::LIGHT;
 
             if (version >= 4) { // handle LWSC 4 explicit ID
-                d.number = strtoul16(c,&c) & AI_LWS_MASK;
-            }
-            else d.number = cur_light++;
+                d.number = strtoul16(c, &c) & AI_LWS_MASK;
+            } else
+                d.number = cur_light++;
             nodes.push_back(d);
 
             num_light++;
@@ -761,30 +742,38 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
             if (nodes.empty() || nodes.back().type != LWS::NodeDesc::LIGHT)
                 ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'LightName\'");
 
-            else nodes.back().name = c;
+            else
+                nodes.back().name = c;
         }
         // 'LightIntensity': set intensity of currently active light
-        else if ((*it).tokens[0] == "LightIntensity" || (*it).tokens[0] == "LgtIntensity" ) {
-            if (nodes.empty() || nodes.back().type != LWS::NodeDesc::LIGHT)
+        else if ((*it).tokens[0] == "LightIntensity" || (*it).tokens[0] == "LgtIntensity") {
+            if (nodes.empty() || nodes.back().type != LWS::NodeDesc::LIGHT) {
                 ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'LightIntensity\'");
-
-            else fast_atoreal_move<float>(c, nodes.back().lightIntensity );
-
+            } else {
+                const std::string env = "(envelope)";
+                if (0 == strncmp(c, env.c_str(), env.size())) {
+                    ASSIMP_LOG_ERROR("LWS: envelopes for  LightIntensity not supported, set to 1.0");
+                    nodes.back().lightIntensity = (ai_real)1.0;
+                } else {
+                    fast_atoreal_move<float>(c, nodes.back().lightIntensity);
+                }
+            }
         }
         // 'LightType': set type of currently active light
         else if ((*it).tokens[0] == "LightType") {
             if (nodes.empty() || nodes.back().type != LWS::NodeDesc::LIGHT)
                 ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'LightType\'");
 
-            else nodes.back().lightType = strtoul10(c);
+            else
+                nodes.back().lightType = strtoul10(c);
 
         }
         // 'LightFalloffType': set falloff type of currently active light
         else if ((*it).tokens[0] == "LightFalloffType") {
             if (nodes.empty() || nodes.back().type != LWS::NodeDesc::LIGHT)
                 ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'LightFalloffType\'");
-
-            else nodes.back().lightFalloffType = strtoul10(c);
+            else
+                nodes.back().lightFalloffType = strtoul10(c);
 
         }
         // 'LightConeAngle': set cone angle of currently active light
@@ -792,7 +781,8 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
             if (nodes.empty() || nodes.back().type != LWS::NodeDesc::LIGHT)
                 ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'LightConeAngle\'");
 
-            else nodes.back().lightConeAngle = fast_atof(c);
+            else
+                nodes.back().lightConeAngle = fast_atof(c);
 
         }
         // 'LightEdgeAngle': set area where we're smoothing from min to max intensity
@@ -800,7 +790,8 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
             if (nodes.empty() || nodes.back().type != LWS::NodeDesc::LIGHT)
                 ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'LightEdgeAngle\'");
 
-            else nodes.back().lightEdgeAngle = fast_atof(c);
+            else
+                nodes.back().lightEdgeAngle = fast_atof(c);
 
         }
         // 'LightColor': set color of currently active light
@@ -809,11 +800,11 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
                 ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'LightColor\'");
 
             else {
-                c = fast_atoreal_move<float>(c, (float&) nodes.back().lightColor.r );
+                c = fast_atoreal_move<float>(c, (float &)nodes.back().lightColor.r);
                 SkipSpaces(&c);
-                c = fast_atoreal_move<float>(c, (float&) nodes.back().lightColor.g );
+                c = fast_atoreal_move<float>(c, (float &)nodes.back().lightColor.g);
                 SkipSpaces(&c);
-                c = fast_atoreal_move<float>(c, (float&) nodes.back().lightColor.b );
+                c = fast_atoreal_move<float>(c, (float &)nodes.back().lightColor.b);
             }
         }
 
@@ -822,11 +813,11 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
             if (nodes.empty())
                 ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'PivotPosition\'");
             else {
-                c = fast_atoreal_move<float>(c, (float&) nodes.back().pivotPos.x );
+                c = fast_atoreal_move<float>(c, (float &)nodes.back().pivotPos.x);
                 SkipSpaces(&c);
-                c = fast_atoreal_move<float>(c, (float&) nodes.back().pivotPos.y );
+                c = fast_atoreal_move<float>(c, (float &)nodes.back().pivotPos.y);
                 SkipSpaces(&c);
-                c = fast_atoreal_move<float>(c, (float&) nodes.back().pivotPos.z );
+                c = fast_atoreal_move<float>(c, (float &)nodes.back().pivotPos.z);
                 // Mark pivotPos as set
                 nodes.back().isPivotSet = true;
             }
@@ -834,79 +825,80 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
     }
 
     // resolve parenting
-    for (std::list<LWS::NodeDesc>::iterator it = nodes.begin(); it != nodes.end(); ++it) {
+    for (std::list<LWS::NodeDesc>::iterator ndIt = nodes.begin(); ndIt != nodes.end(); ++ndIt) {
 
         // check whether there is another node which calls us a parent
         for (std::list<LWS::NodeDesc>::iterator dit = nodes.begin(); dit != nodes.end(); ++dit) {
-            if (dit != it && *it == (*dit).parent) {
+            if (dit != ndIt && *ndIt == (*dit).parent) {
                 if ((*dit).parent_resolved) {
                     // fixme: it's still possible to produce an overflow due to cross references ..
                     ASSIMP_LOG_ERROR("LWS: Found cross reference in scene-graph");
                     continue;
                 }
 
-                (*it).children.push_back(&*dit);
-                (*dit).parent_resolved = &*it;
+                ndIt->children.push_back(&*dit);
+                (*dit).parent_resolved = &*ndIt;
             }
         }
     }
 
     // find out how many nodes have no parent yet
     unsigned int no_parent = 0;
-    for (std::list<LWS::NodeDesc>::iterator it = nodes.begin(); it != nodes.end(); ++it) {
-        if (!(*it).parent_resolved)
-            ++ no_parent;
+    for (std::list<LWS::NodeDesc>::iterator ndIt = nodes.begin(); ndIt != nodes.end(); ++ndIt) {
+        if (!ndIt->parent_resolved) {
+            ++no_parent;
+        }
     }
-    if (!no_parent)
+    if (!no_parent) {
         throw DeadlyImportError("LWS: Unable to find scene root node");
-
+    }
 
     // Load all subsequent files
     batch.LoadAll();
 
     // and build the final output graph by attaching the loaded external
     // files to ourselves. first build a master graph
-    aiScene* master = new aiScene();
-    aiNode* nd = master->mRootNode = new aiNode();
+    aiScene *master = new aiScene();
+    aiNode *nd = master->mRootNode = new aiNode();
 
     // allocate storage for cameras&lights
     if (num_camera) {
-        master->mCameras = new aiCamera*[master->mNumCameras = num_camera];
+        master->mCameras = new aiCamera *[master->mNumCameras = num_camera];
     }
-    aiCamera** cams = master->mCameras;
+    aiCamera **cams = master->mCameras;
     if (num_light) {
-        master->mLights = new aiLight*[master->mNumLights = num_light];
+        master->mLights = new aiLight *[master->mNumLights = num_light];
     }
-    aiLight** lights = master->mLights;
+    aiLight **lights = master->mLights;
 
     std::vector<AttachmentInfo> attach;
-    std::vector<aiNodeAnim*> anims;
+    std::vector<aiNodeAnim *> anims;
 
     nd->mName.Set("<LWSRoot>");
-    nd->mChildren = new aiNode*[no_parent];
-    for (std::list<LWS::NodeDesc>::iterator it = nodes.begin(); it != nodes.end(); ++it) {
-        if (!(*it).parent_resolved) {
-            aiNode* ro = nd->mChildren[ nd->mNumChildren++ ] = new aiNode();
+    nd->mChildren = new aiNode *[no_parent];
+    for (std::list<LWS::NodeDesc>::iterator ndIt = nodes.begin(); ndIt != nodes.end(); ++ndIt) {
+        if (!ndIt->parent_resolved) {
+            aiNode *ro = nd->mChildren[nd->mNumChildren++] = new aiNode();
             ro->mParent = nd;
 
             // ... and build the scene graph. If we encounter object nodes,
             // add then to our attachment table.
-            BuildGraph(ro,*it, attach, batch, cams, lights, anims);
+            BuildGraph(ro, *ndIt, attach, batch, cams, lights, anims);
         }
     }
 
     // create a master animation channel for us
     if (anims.size()) {
-        master->mAnimations = new aiAnimation*[master->mNumAnimations = 1];
-        aiAnimation* anim = master->mAnimations[0] = new aiAnimation();
+        master->mAnimations = new aiAnimation *[master->mNumAnimations = 1];
+        aiAnimation *anim = master->mAnimations[0] = new aiAnimation();
         anim->mName.Set("LWSMasterAnim");
 
         // LWS uses seconds as time units, but we convert to frames
         anim->mTicksPerSecond = fps;
-        anim->mDuration = last-(first-1); /* fixme ... zero or one-based?*/
+        anim->mDuration = last - (first - 1); /* fixme ... zero or one-based?*/
 
-        anim->mChannels = new aiNodeAnim*[anim->mNumChannels = static_cast<unsigned int>(anims.size())];
-        std::copy(anims.begin(),anims.end(),anim->mChannels);
+        anim->mChannels = new aiNodeAnim *[anim->mNumChannels = static_cast<unsigned int>(anims.size())];
+        std::copy(anims.begin(), anims.end(), anim->mChannels);
     }
 
     // convert the master scene to RH
@@ -918,9 +910,10 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
     flipper.Execute(master);
 
     // OK ... finally build the output graph
-    SceneCombiner::MergeScenes(&pScene,master,attach,
-        AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES    | (!configSpeedFlag ? (
-        AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY | AI_INT_MERGE_SCENE_GEN_UNIQUE_MATNAMES) : 0));
+    SceneCombiner::MergeScenes(&pScene, master, attach,
+            AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES | (!configSpeedFlag ? (
+                                                                              AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY | AI_INT_MERGE_SCENE_GEN_UNIQUE_MATNAMES) :
+                                                                      0));
 
     // Check flags
     if (!pScene->mNumMeshes || !pScene->mNumMaterials) {
@@ -931,7 +924,6 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
             SkeletonMeshBuilder builder(pScene);
         }
     }
-
 }
 
 #endif // !! ASSIMP_BUILD_NO_LWS_IMPORTER
diff --git a/Engine/lib/assimp/code/LWS/LWSLoader.h b/Engine/lib/assimp/code/AssetLib/LWS/LWSLoader.h
similarity index 72%
rename from Engine/lib/assimp/code/LWS/LWSLoader.h
rename to Engine/lib/assimp/code/AssetLib/LWS/LWSLoader.h
index eed0491f3..225186f5c 100644
--- a/Engine/lib/assimp/code/LWS/LWSLoader.h
+++ b/Engine/lib/assimp/code/AssetLib/LWS/LWSLoader.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,22 +42,24 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file  LWSLoader.h
  *  @brief Declaration of the LightWave scene importer class.
  */
+#pragma once
 #ifndef AI_LWSLOADER_H_INCLUDED
 #define AI_LWSLOADER_H_INCLUDED
 
-#include "LWO/LWOFileData.h"
+#include "AssetLib/LWO/LWOFileData.h"
 
-#include <assimp/SceneCombiner.h>
 #include <assimp/BaseImporter.h>
+#include <assimp/SceneCombiner.h>
 
 struct aiImporterDesc;
 
-namespace Assimp    {
-    class BatchLoader;
-    class Importer;
-    class IOSystem;
+namespace Assimp {
 
-    namespace LWS   {
+class BatchLoader;
+class Importer;
+class IOSystem;
+
+namespace LWS {
 
 // ---------------------------------------------------------------------------
 /** Represents an element in a LWS file.
@@ -66,18 +67,16 @@ namespace Assimp    {
  *  This can either be a single data line - <name> <value> or a data
  *  group - { name <data_line0> ... n }
  */
-class Element
-{
+class Element {
 public:
-    Element()
-    {}
+    Element() {}
 
     // first: name, second: rest
     std::string tokens[2];
     std::list<Element> children;
 
     //! Recursive parsing function
-    void Parse (const char*& buffer);
+    void Parse(const char *&buffer);
 };
 
 #define AI_LWS_MASK (0xffffffff >> 4u)
@@ -85,30 +84,28 @@ public:
 // ---------------------------------------------------------------------------
 /** Represents a LWS scenegraph element
  */
-struct NodeDesc
-{
-    NodeDesc()
-        :   type()
-        ,   id()
-        ,   number  (0)
-        ,   parent  (0)
-        ,   name    ("")
-        ,   isPivotSet (false)
-        ,   lightColor (1.f,1.f,1.f)
-        ,   lightIntensity (1.f)
-        ,   lightType (0)
-        ,   lightFalloffType (0)
-        ,   lightConeAngle (45.f)
-        ,   lightEdgeAngle()
-        ,   parent_resolved (NULL)
-    {}
+struct NodeDesc {
+    NodeDesc() :
+            type(),
+            id(),
+            number(0),
+            parent(0),
+            name(),
+            isPivotSet(false),
+            lightColor(1.f, 1.f, 1.f),
+            lightIntensity(1.f),
+            lightType(0),
+            lightFalloffType(0),
+            lightConeAngle(45.f),
+            lightEdgeAngle(),
+            parent_resolved(nullptr) {}
 
     enum {
 
         OBJECT = 1,
-        LIGHT  = 2,
+        LIGHT = 2,
         CAMERA = 3,
-        BONE   = 4
+        BONE = 4
     } type; // type of node
 
     // if object: path
@@ -122,17 +119,15 @@ struct NodeDesc
     unsigned int parent;
 
     // lights & cameras & dummies: name
-    const char* name;
+    const char *name;
 
     // animation channels
-    std::list< LWO::Envelope > channels;
+    std::list<LWO::Envelope> channels;
 
     // position of pivot point
     aiVector3D pivotPos;
     bool isPivotSet;
 
-
-
     // color of light source
     aiColor3D lightColor;
 
@@ -151,17 +146,14 @@ struct NodeDesc
     // soft cone angle of (spot) light source
     float lightEdgeAngle;
 
-
-
     // list of resolved children
-    std::list< NodeDesc* > children;
+    std::list<NodeDesc *> children;
 
     // resolved parent node
-    NodeDesc* parent_resolved;
-
+    NodeDesc *parent_resolved;
 
     // for std::find()
-    bool operator == (unsigned int num)  const {
+    bool operator==(unsigned int num) const {
         if (!num)
             return false;
         unsigned int _type = num >> 28u;
@@ -179,74 +171,64 @@ struct NodeDesc
  *  contain mainly descriptions how LWO objects are composed together
  *  in a scene.
 */
-class LWSImporter : public BaseImporter
-{
+class LWSImporter : public BaseImporter {
 public:
     LWSImporter();
-    ~LWSImporter();
-
-
-public:
+    ~LWSImporter() override;
 
     // -------------------------------------------------------------------
     // Check whether we can read a specific file
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
+            bool checkSig) const override;
 
 protected:
-
     // -------------------------------------------------------------------
     // Get list of supported extensions
-    const aiImporterDesc* GetInfo () const;
+    const aiImporterDesc *GetInfo() const override;
 
     // -------------------------------------------------------------------
     // Import file into given scene data structure
-    void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
+    void InternReadFile(const std::string &pFile, aiScene *pScene,
+            IOSystem *pIOHandler) override;
 
     // -------------------------------------------------------------------
     // Setup import properties
-    void SetupProperties(const Importer* pImp);
+    void SetupProperties(const Importer *pImp) override;
 
 private:
-
-
     // -------------------------------------------------------------------
     // Read an envelope description
-    void ReadEnvelope(const LWS::Element& dad, LWO::Envelope& out );
+    void ReadEnvelope(const LWS::Element &dad, LWO::Envelope &out);
 
     // -------------------------------------------------------------------
     // Read an envelope description for the older LW file format
-    void ReadEnvelope_Old(std::list< LWS::Element >::const_iterator& it,
-        const std::list< LWS::Element >::const_iterator& end,
-        LWS::NodeDesc& nodes,
-        unsigned int version);
+    void ReadEnvelope_Old(std::list<LWS::Element>::const_iterator &it,
+            const std::list<LWS::Element>::const_iterator &end,
+            LWS::NodeDesc &nodes,
+            unsigned int version);
 
     // -------------------------------------------------------------------
     // Setup a nice name for a node
-    void SetupNodeName(aiNode* nd, LWS::NodeDesc& src);
+    void SetupNodeName(aiNode *nd, LWS::NodeDesc &src);
 
     // -------------------------------------------------------------------
     // Recursively build the scenegraph
-    void BuildGraph(aiNode* nd,
-        LWS::NodeDesc& src,
-        std::vector<AttachmentInfo>& attach,
-        BatchLoader& batch,
-        aiCamera**& camOut,
-        aiLight**& lightOut,
-        std::vector<aiNodeAnim*>& animOut);
+    void BuildGraph(aiNode *nd,
+            LWS::NodeDesc &src,
+            std::vector<AttachmentInfo> &attach,
+            BatchLoader &batch,
+            aiCamera **&camOut,
+            aiLight **&lightOut,
+            std::vector<aiNodeAnim *> &animOut);
 
     // -------------------------------------------------------------------
     // Try several dirs until we find the right location of a LWS file.
-    std::string FindLWOFile(const std::string& in);
+    std::string FindLWOFile(const std::string &in);
 
 private:
-
     bool configSpeedFlag;
-    IOSystem* io;
-
-    double first,last,fps;
-
+    IOSystem *io;
+    double first, last, fps;
     bool noSkeletonMesh;
 };
 
diff --git a/Engine/lib/assimp/code/AssetLib/M3D/M3DExporter.cpp b/Engine/lib/assimp/code/AssetLib/M3D/M3DExporter.cpp
new file mode 100644
index 000000000..cf87b6221
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/M3D/M3DExporter.cpp
@@ -0,0 +1,442 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+Copyright (c) 2019 bzt
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+#ifndef ASSIMP_BUILD_NO_EXPORT
+#ifndef ASSIMP_BUILD_NO_M3D_EXPORTER
+
+#define M3D_IMPLEMENTATION
+#define M3D_NOIMPORTER
+#define M3D_EXPORTER
+#ifndef ASSIMP_BUILD_NO_M3D_IMPORTER
+#define M3D_NODUP
+
+
+// Header files, standard library.
+#include <memory> // shared_ptr
+#include <string>
+#include <vector>
+
+#include <assimp/Exceptional.h> // DeadlyExportError
+#include <assimp/StreamWriter.h> // StreamWriterLE
+#include <assimp/material.h> // aiTextureType
+#include <assimp/mesh.h>
+#include <assimp/scene.h>
+#include <assimp/version.h> // aiGetVersion
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/Exporter.hpp>
+#include <assimp/IOSystem.hpp>
+
+#include "M3DExporter.h"
+#include "M3DMaterials.h"
+#include "M3DWrapper.h"
+
+// RESOURCES:
+// https://gitlab.com/bztsrc/model3d/blob/master/docs/m3d_format.md
+// https://gitlab.com/bztsrc/model3d/blob/master/docs/a3d_format.md
+
+/*
+ * Currently supports static meshes, vertex colors, materials, textures
+ *
+ * For animation, it would require the following conversions:
+ *  - aiNode (bones) -> m3d_t.bone (with parent id, position vector and orientation quaternion)
+ *  - aiMesh.aiBone -> m3d_t.skin (per vertex, with bone id, weight pairs)
+ *  - aiAnimation -> m3d_action (frame with timestamp and list of bone id, position, orientation
+ *      triplets, instead of per bone timestamp + lists)
+ */
+
+// ------------------------------------------------------------------------------------------------
+// Conversion functions
+// ------------------------------------------------------------------------------------------------
+// helper to add a vertex (private to NodeWalk)
+m3dv_t *AddVrtx(m3dv_t *vrtx, uint32_t *numvrtx, m3dv_t *v, uint32_t *idx) {
+    if (v->x == (M3D_FLOAT)-0.0) v->x = (M3D_FLOAT)0.0;
+    if (v->y == (M3D_FLOAT)-0.0) v->y = (M3D_FLOAT)0.0;
+    if (v->z == (M3D_FLOAT)-0.0) v->z = (M3D_FLOAT)0.0;
+    if (v->w == (M3D_FLOAT)-0.0) v->w = (M3D_FLOAT)0.0;
+    vrtx = (m3dv_t *)M3D_REALLOC(vrtx, ((*numvrtx) + 1) * sizeof(m3dv_t));
+    memcpy(&vrtx[*numvrtx], v, sizeof(m3dv_t));
+    *idx = *numvrtx;
+    (*numvrtx)++;
+    return vrtx;
+}
+
+// ------------------------------------------------------------------------------------------------
+// helper to add a tmap (private to NodeWalk)
+m3dti_t *AddTmap(m3dti_t *tmap, uint32_t *numtmap, m3dti_t *ti, uint32_t *idx) {
+    tmap = (m3dti_t *)M3D_REALLOC(tmap, ((*numtmap) + 1) * sizeof(m3dti_t));
+    memcpy(&tmap[*numtmap], ti, sizeof(m3dti_t));
+    *idx = *numtmap;
+    (*numtmap)++;
+    return tmap;
+}
+
+// ------------------------------------------------------------------------------------------------
+// convert aiColor4D into uint32_t
+uint32_t mkColor(aiColor4D *c) {
+    return ((uint8_t)(c->a * 255) << 24L) |
+           ((uint8_t)(c->b * 255) << 16L) |
+           ((uint8_t)(c->g * 255) << 8L) |
+           ((uint8_t)(c->r * 255) << 0L);
+}
+
+// ------------------------------------------------------------------------------------------------
+// add a material property to the output
+void addProp(m3dm_t *m, uint8_t type, uint32_t value) {
+    unsigned int i;
+    i = m->numprop++;
+    m->prop = (m3dp_t *)M3D_REALLOC(m->prop, m->numprop * sizeof(m3dp_t));
+    if (!m->prop) {
+        throw DeadlyExportError("memory allocation error");
+    }
+    m->prop[i].type = type;
+    m->prop[i].value.num = value;
+}
+
+// ------------------------------------------------------------------------------------------------
+// convert aiString to identifier safe C string. This is a duplication of _m3d_safestr
+char *SafeStr(aiString str, bool isStrict) {
+    char *s = (char *)&str.data;
+    char *d, *ret;
+    int i, len;
+
+    for (len = str.length + 1; *s && (*s == ' ' || *s == '\t'); s++, len--)
+        ;
+    if (len > 255) len = 255;
+    ret = (char *)M3D_MALLOC(len + 1);
+    if (!ret) {
+        throw DeadlyExportError("memory allocation error");
+    }
+    for (i = 0, d = ret; i < len && *s && *s != '\r' && *s != '\n'; s++, d++, i++) {
+        *d = isStrict && (*s == ' ' || *s == '\t' || *s == '/' || *s == '\\') ? '_' : (*s == '\t' ? ' ' : *s);
+    }
+    for (; d > ret && (*(d - 1) == ' ' || *(d - 1) == '\t'); d--)
+        ;
+    *d = 0;
+    return ret;
+}
+
+// ------------------------------------------------------------------------------------------------
+// add a material to the output
+M3D_INDEX addMaterial(const Assimp::M3DWrapper &m3d, const aiMaterial *mat) {
+    unsigned int mi = M3D_NOTDEFINED;
+    aiColor4D c;
+    aiString name;
+    ai_real f;
+    char *fn;
+
+    if (mat && mat->Get(AI_MATKEY_NAME, name) == AI_SUCCESS && name.length &&
+            strcmp((char *)&name.data, AI_DEFAULT_MATERIAL_NAME)) {
+        // check if we have saved a material by this name. This has to be done
+        // because only the referenced materials should be added to the output
+        for (unsigned int i = 0; i < m3d->nummaterial; i++)
+            if (!strcmp((char *)&name.data, m3d->material[i].name)) {
+                mi = i;
+                break;
+            }
+        // if not found, add the material to the output
+        if (mi == M3D_NOTDEFINED) {
+            unsigned int k;
+            mi = m3d->nummaterial++;
+            m3d->material = (m3dm_t *)M3D_REALLOC(m3d->material, m3d->nummaterial * sizeof(m3dm_t));
+            if (!m3d->material) {
+                throw DeadlyExportError("memory allocation error");
+            }
+            m3d->material[mi].name = SafeStr(name, true);
+            m3d->material[mi].numprop = 0;
+            m3d->material[mi].prop = nullptr;
+            // iterate through the material property table and see what we got
+            for (k = 0; k < 15; k++) {
+                unsigned int j;
+                if (m3d_propertytypes[k].format == m3dpf_map)
+                    continue;
+                if (aiProps[k].pKey) {
+                    switch (m3d_propertytypes[k].format) {
+                    case m3dpf_color:
+                        if (mat->Get(aiProps[k].pKey, aiProps[k].type,
+                                    aiProps[k].index, c) == AI_SUCCESS)
+                            addProp(&m3d->material[mi],
+                                    m3d_propertytypes[k].id, mkColor(&c));
+                        break;
+                    case m3dpf_float:
+                        if (mat->Get(aiProps[k].pKey, aiProps[k].type,
+                                    aiProps[k].index, f) == AI_SUCCESS) {
+                            uint32_t f_uint32;
+                            memcpy(&f_uint32, &f, sizeof(uint32_t));
+                            addProp(&m3d->material[mi],
+                                    m3d_propertytypes[k].id,
+                                    /* not (uint32_t)f, because we don't want to convert
+                                         * it, we want to see it as 32 bits of memory */
+                                    f_uint32);
+                        }
+                        break;
+                    case m3dpf_uint8:
+                        if (mat->Get(aiProps[k].pKey, aiProps[k].type,
+                                    aiProps[k].index, j) == AI_SUCCESS) {
+                            // special conversion for illumination model property
+                            if (m3d_propertytypes[k].id == m3dp_il) {
+                                switch (j) {
+                                case aiShadingMode_NoShading: j = 0; break;
+                                case aiShadingMode_Phong: j = 2; break;
+                                default: j = 1; break;
+                                }
+                            }
+                            addProp(&m3d->material[mi],
+                                    m3d_propertytypes[k].id, j);
+                        }
+                        break;
+                    default:
+                        if (mat->Get(aiProps[k].pKey, aiProps[k].type,
+                                    aiProps[k].index, j) == AI_SUCCESS)
+                            addProp(&m3d->material[mi],
+                                    m3d_propertytypes[k].id, j);
+                        break;
+                    }
+                }
+                if (aiTxProps[k].pKey &&
+                        mat->GetTexture((aiTextureType)aiTxProps[k].type,
+                                aiTxProps[k].index, &name, nullptr, nullptr, nullptr,
+                                nullptr, nullptr) == AI_SUCCESS) {
+                    unsigned int i;
+                    for (j = name.length - 1; j > 0 && name.data[j] != '.'; j++)
+                        ;
+                    if (j && name.data[j] == '.' &&
+                            (name.data[j + 1] == 'p' || name.data[j + 1] == 'P') &&
+                            (name.data[j + 1] == 'n' || name.data[j + 1] == 'N') &&
+                            (name.data[j + 1] == 'g' || name.data[j + 1] == 'G'))
+                        name.data[j] = 0;
+                    // do we have this texture saved already?
+                    fn = SafeStr(name, true);
+                    for (j = 0, i = M3D_NOTDEFINED; j < m3d->numtexture; j++)
+                        if (!strcmp(fn, m3d->texture[j].name)) {
+                            i = j;
+                            free(fn);
+                            break;
+                        }
+                    if (i == M3D_NOTDEFINED) {
+                        i = m3d->numtexture++;
+                        m3d->texture = (m3dtx_t *)M3D_REALLOC(
+                                m3d->texture,
+                                m3d->numtexture * sizeof(m3dtx_t));
+                        if (!m3d->texture) {
+                            throw DeadlyExportError("memory allocation error");
+                        }
+                        // we don't need the texture itself, only its name
+                        m3d->texture[i].name = fn;
+                        m3d->texture[i].w = 0;
+                        m3d->texture[i].h = 0;
+                        m3d->texture[i].d = nullptr;
+                    }
+                    addProp(&m3d->material[mi],
+                            m3d_propertytypes[k].id + 128, i);
+                }
+            }
+        }
+    }
+    return mi;
+}
+
+namespace Assimp {
+
+// ---------------------------------------------------------------------
+// Worker function for exporting a scene to binary M3D.
+// Prototyped and registered in Exporter.cpp
+void ExportSceneM3D(
+        const char *pFile,
+        IOSystem *pIOSystem,
+        const aiScene *pScene,
+        const ExportProperties *pProperties) {
+    // initialize the exporter
+    M3DExporter exporter(pScene, pProperties);
+
+    // perform binary export
+    exporter.doExport(pFile, pIOSystem, false);
+}
+
+// ---------------------------------------------------------------------
+// Worker function for exporting a scene to ASCII A3D.
+// Prototyped and registered in Exporter.cpp
+void ExportSceneM3DA(
+        const char *pFile,
+        IOSystem *pIOSystem,
+        const aiScene *pScene,
+        const ExportProperties *pProperties
+
+) {
+    // initialize the exporter
+    M3DExporter exporter(pScene, pProperties);
+
+    // perform ascii export
+    exporter.doExport(pFile, pIOSystem, true);
+}
+
+// ------------------------------------------------------------------------------------------------
+M3DExporter::M3DExporter(const aiScene *pScene, const ExportProperties *pProperties) :
+        mScene(pScene),
+        mProperties(pProperties),
+        outfile() {
+    // empty
+}
+
+// ------------------------------------------------------------------------------------------------
+void M3DExporter::doExport(
+        const char *pFile,
+        IOSystem *pIOSystem,
+        bool toAscii) {
+    // TODO: convert mProperties into M3D_EXP_* flags
+    (void)mProperties;
+
+    // open the indicated file for writing (in binary / ASCII mode)
+    outfile.reset(pIOSystem->Open(pFile, toAscii ? "wt" : "wb"));
+    if (!outfile) {
+        throw DeadlyExportError("could not open output .m3d file: " + std::string(pFile));
+    }
+
+    M3DWrapper m3d;
+    if (!m3d) {
+        throw DeadlyExportError("memory allocation error");
+    }
+    m3d->name = SafeStr(mScene->mRootNode->mName, false);
+
+    // Create a model from assimp structures
+    aiMatrix4x4 m;
+    NodeWalk(m3d, mScene->mRootNode, m);
+
+    // serialize the structures
+    unsigned int size;
+    unsigned char *output = m3d.Save(M3D_EXP_FLOAT, M3D_EXP_EXTRA | (toAscii ? M3D_EXP_ASCII : 0), size);
+
+    if (!output || size < 8) {
+        throw DeadlyExportError("unable to serialize into Model 3D");
+    }
+
+    // Write out serialized model
+    outfile->Write(output, size, 1);
+
+    // explicitly release file pointer,
+    // so we don't have to rely on class destruction.
+    outfile.reset();
+
+    M3D_FREE(m3d->name);
+    m3d->name = nullptr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// recursive node walker
+void M3DExporter::NodeWalk(const M3DWrapper &m3d, const aiNode *pNode, aiMatrix4x4 m) {
+    aiMatrix4x4 nm = m * pNode->mTransformation;
+
+    for (unsigned int i = 0; i < pNode->mNumMeshes; i++) {
+        const aiMesh *mesh = mScene->mMeshes[pNode->mMeshes[i]];
+        unsigned int mi = M3D_NOTDEFINED;
+        if (mScene->mMaterials) {
+            // get the material for this mesh
+            mi = addMaterial(m3d, mScene->mMaterials[mesh->mMaterialIndex]);
+        }
+        // iterate through the mesh faces
+        for (unsigned int j = 0; j < mesh->mNumFaces; j++) {
+            unsigned int n;
+            const aiFace *face = &(mesh->mFaces[j]);
+            // only triangle meshes supported for now
+            if (face->mNumIndices != 3) {
+                throw DeadlyExportError("use aiProcess_Triangulate before export");
+            }
+            // add triangle to the output
+            n = m3d->numface++;
+            m3d->face = (m3df_t *)M3D_REALLOC(m3d->face,
+                    m3d->numface * sizeof(m3df_t));
+            if (!m3d->face) {
+                throw DeadlyExportError("memory allocation error");
+            }
+            /* set all index to -1 by default */
+            m3d->face[n].vertex[0] = m3d->face[n].vertex[1] = m3d->face[n].vertex[2] =
+                    m3d->face[n].normal[0] = m3d->face[n].normal[1] = m3d->face[n].normal[2] =
+                            m3d->face[n].texcoord[0] = m3d->face[n].texcoord[1] = m3d->face[n].texcoord[2] = M3D_UNDEF;
+            m3d->face[n].materialid = mi;
+            for (unsigned int k = 0; k < face->mNumIndices; k++) {
+                // get the vertex's index
+                unsigned int l = face->mIndices[k];
+                unsigned int idx;
+                m3dv_t vertex;
+                m3dti_t ti;
+                // multiply the position vector by the transformation matrix
+                aiVector3D v = mesh->mVertices[l];
+                v *= nm;
+                vertex.x = v.x;
+                vertex.y = v.y;
+                vertex.z = v.z;
+                vertex.w = 1.0;
+                vertex.color = 0;
+                vertex.skinid = M3D_UNDEF;
+                // add color if defined
+                if (mesh->HasVertexColors(0))
+                    vertex.color = mkColor(&mesh->mColors[0][l]);
+                // save the vertex to the output
+                m3d->vertex = AddVrtx(m3d->vertex, &m3d->numvertex,
+                        &vertex, &idx);
+                m3d->face[n].vertex[k] = (M3D_INDEX)idx;
+                // do we have texture coordinates?
+                if (mesh->HasTextureCoords(0)) {
+                    ti.u = mesh->mTextureCoords[0][l].x;
+                    ti.v = mesh->mTextureCoords[0][l].y;
+                    m3d->tmap = AddTmap(m3d->tmap, &m3d->numtmap, &ti, &idx);
+                    m3d->face[n].texcoord[k] = (M3D_INDEX)idx;
+                }
+                // do we have normal vectors?
+                if (mesh->HasNormals()) {
+                    vertex.x = mesh->mNormals[l].x;
+                    vertex.y = mesh->mNormals[l].y;
+                    vertex.z = mesh->mNormals[l].z;
+                    vertex.color = 0;
+                    m3d->vertex = AddVrtx(m3d->vertex, &m3d->numvertex, &vertex, &idx);
+                    m3d->face[n].normal[k] = (M3D_INDEX)idx;
+                }
+            }
+        }
+    }
+    // repeat for the children nodes
+    for (unsigned int i = 0; i < pNode->mNumChildren; i++) {
+        NodeWalk(m3d, pNode->mChildren[i], nm);
+    }
+}
+} // namespace Assimp
+#endif
+#endif // ASSIMP_BUILD_NO_M3D_EXPORTER
+#endif // ASSIMP_BUILD_NO_EXPORT
diff --git a/Engine/lib/assimp/code/glTF/glTFExporter.h b/Engine/lib/assimp/code/AssetLib/M3D/M3DExporter.h
similarity index 54%
rename from Engine/lib/assimp/code/glTF/glTFExporter.h
rename to Engine/lib/assimp/code/AssetLib/M3D/M3DExporter.h
index d6c2e7f04..d77743f56 100644
--- a/Engine/lib/assimp/code/glTF/glTFExporter.h
+++ b/Engine/lib/assimp/code/AssetLib/M3D/M3DExporter.h
@@ -2,8 +2,8 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
+Copyright (c) 2019 bzt
 
 All rights reserved.
 
@@ -40,80 +40,54 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
-/** @file GltfExporter.h
-* Declares the exporter class to write a scene to a gltf/glb file
+/** @file M3DExporter.h
+*   @brief Declares the exporter class to write a scene to a Model 3D file
 */
-#ifndef AI_GLTFEXPORTER_H_INC
-#define AI_GLTFEXPORTER_H_INC
+#ifndef AI_M3DEXPORTER_H_INC
+#define AI_M3DEXPORTER_H_INC
 
-#ifndef ASSIMP_BUILD_NO_GLTF_EXPORTER
+#ifndef ASSIMP_BUILD_NO_M3D_IMPORTER
+#ifndef ASSIMP_BUILD_NO_M3D_EXPORTER
 
 #include <assimp/types.h>
-#include <assimp/material.h>
+#include <assimp/StreamWriter.h> // StreamWriterLE
+#include <assimp/Exceptional.h> // DeadlyExportError
 
-#include <sstream>
-#include <vector>
-#include <map>
-#include <memory>
+#include <memory> // shared_ptr
 
 struct aiScene;
 struct aiNode;
 struct aiMaterial;
+struct aiFace;
 
-namespace glTF
-{
-    template<class T>
-    class Ref;
-
-    class Asset;
-    struct TexProperty;
-    struct Node;
-}
-
-namespace Assimp
-{
+namespace Assimp {
     class IOSystem;
     class IOStream;
     class ExportProperties;
 
-    // ------------------------------------------------------------------------------------------------
-    /** Helper class to export a given scene to an glTF file. */
-    // ------------------------------------------------------------------------------------------------
-    class glTFExporter
-    {
+    class M3DWrapper;
+
+    // ---------------------------------------------------------------------
+    /** Helper class to export a given scene to an M3D file. */
+    // ---------------------------------------------------------------------
+    class M3DExporter {
     public:
         /// Constructor for a specific scene to export
-        glTFExporter(const char* filename, IOSystem* pIOSystem, const aiScene* pScene,
-            const ExportProperties* pProperties, bool binary);
+        M3DExporter(const aiScene* pScene, const ExportProperties* pProperties);
+        // call this to do the actual export
+        void doExport(const char* pFile, IOSystem* pIOSystem, bool toAscii);
 
     private:
+        const aiScene* mScene; // the scene to export
+        const ExportProperties* mProperties; // currently unused
+        std::shared_ptr<IOStream> outfile; // file to write to
 
-        const char* mFilename;
-        IOSystem* mIOSystem;
-        const aiScene* mScene;
-        const ExportProperties* mProperties;
-
-        std::map<std::string, unsigned int> mTexturesByPath;
-
-        std::shared_ptr<glTF::Asset> mAsset;
-
-        std::vector<unsigned char> mBodyData;
-
-        void WriteBinaryData(IOStream* outfile, std::size_t sceneLength);
-
-        void GetTexSampler(const aiMaterial* mat, glTF::TexProperty& prop);
-        void GetMatColorOrTex(const aiMaterial* mat, glTF::TexProperty& prop, const char* propName, int type, int idx, aiTextureType tt);
-        void ExportMetadata();
-        void ExportMaterials();
-        void ExportMeshes();
-        unsigned int ExportNodeHierarchy(const aiNode* n);
-        unsigned int ExportNode(const aiNode* node, glTF::Ref<glTF::Node>& parent);
-        void ExportScene();
-        void ExportAnimations();
+        // helper to do the recursive walking
+        void NodeWalk(const M3DWrapper &m3d, const aiNode* pNode, aiMatrix4x4 m);
     };
-
 }
 
-#endif // ASSIMP_BUILD_NO_GLTF_EXPORTER
+#endif // #ifndef ASSIMP_BUILD_NO_M3D_IMPORTER
+#endif // ASSIMP_BUILD_NO_M3D_EXPORTER
 
-#endif // AI_GLTFEXPORTER_H_INC
+#endif // AI_M3DEXPORTER_H_INC
diff --git a/Engine/lib/assimp/code/AssetLib/M3D/M3DImporter.cpp b/Engine/lib/assimp/code/AssetLib/M3D/M3DImporter.cpp
new file mode 100644
index 000000000..895b2bf70
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/M3D/M3DImporter.cpp
@@ -0,0 +1,789 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+Copyright (c) 2019 bzt
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#ifndef ASSIMP_BUILD_NO_M3D_IMPORTER
+
+#define M3D_IMPLEMENTATION
+#define M3D_NONORMALS /* leave the post-processing to Assimp */
+#define M3D_NOWEIGHTS
+#define M3D_NOANIMATION
+
+#include <assimp/DefaultIOSystem.h>
+#include <assimp/IOStreamBuffer.h>
+#include <assimp/ai_assert.h>
+#include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/Importer.hpp>
+#include <memory>
+
+#include "M3DImporter.h"
+#include "M3DMaterials.h"
+#include "M3DWrapper.h"
+
+// RESOURCES:
+// https://gitlab.com/bztsrc/model3d/blob/master/docs/m3d_format.md
+// https://gitlab.com/bztsrc/model3d/blob/master/docs/a3d_format.md
+
+/*
+ Unfortunately aiNode has bone structures and meshes too, yet we can't assign
+ the mesh to a bone aiNode as a skin may refer to several aiNodes. Therefore
+ I've decided to import into this structure:
+
+   aiScene->mRootNode
+    |        |->mMeshes (all the meshes)
+    |        \->children (empty if there's no skeleton imported, no meshes)
+    |             \->skeleton root aiNode*
+    |                   |->bone aiNode
+    |                   |   \->subbone aiNode
+    |                   |->bone aiNode
+    |                   |   ...
+    |                   \->bone aiNode
+    \->mMeshes[]
+        \->aiBone, referencing mesh-less aiNodes from above
+
+  * - normally one, but if a model has several skeleton roots, then all of them
+      are listed in aiScene->mRootNode->children, but all without meshes
+*/
+
+static const aiImporterDesc desc = {
+    "Model 3D Importer",
+    "",
+    "",
+    "",
+    aiImporterFlags_SupportTextFlavour | aiImporterFlags_SupportBinaryFlavour,
+    0,
+    0,
+    0,
+    0,
+    "m3d a3d"
+};
+
+namespace Assimp {
+
+using namespace std;
+
+// ------------------------------------------------------------------------------------------------
+//  Default constructor
+M3DImporter::M3DImporter() :
+        mScene(nullptr) {
+    // empty
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Returns true, if file is a binary or ASCII Model 3D file.
+bool M3DImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
+    // don't use CheckMagicToken because that checks with swapped bytes too, leading to false
+    // positives. This magic is not uint32_t, but char[4], so memcmp is the best way
+    std::unique_ptr<IOStream> pStream(pIOHandler->Open(pFile, "rb"));
+    unsigned char data[4];
+    if (4 != pStream->Read(data, 1, 4)) {
+        return false;
+    }
+    return !memcmp(data, "3DMO", 4) /* bin */
+#ifdef M3D_ASCII
+        || !memcmp(data, "3dmo", 4) /* ASCII */
+#endif
+            ;
+}
+
+// ------------------------------------------------------------------------------------------------
+const aiImporterDesc *M3DImporter::GetInfo() const {
+    return &desc;
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Model 3D import implementation
+void M3DImporter::InternReadFile(const std::string &file, aiScene *pScene, IOSystem *pIOHandler) {
+    // Read file into memory
+    std::unique_ptr<IOStream> pStream(pIOHandler->Open(file, "rb"));
+    if (!pStream.get()) {
+        throw DeadlyImportError("Failed to open file ", file, ".");
+    }
+
+    // Get the file-size and validate it, throwing an exception when fails
+    size_t fileSize = pStream->FileSize();
+    if (fileSize < 8) {
+        throw DeadlyImportError("M3D-file ", file, " is too small.");
+    }
+    std::vector<unsigned char> buffer(fileSize);
+    if (fileSize != pStream->Read(buffer.data(), 1, fileSize)) {
+        throw DeadlyImportError("Failed to read the file ", file, ".");
+    }
+    // extra check for binary format's first 8 bytes. Not done for the ASCII variant
+    if (!memcmp(buffer.data(), "3DMO", 4) && memcmp(buffer.data() + 4, &fileSize, 4)) {
+        throw DeadlyImportError("Bad binary header in file ", file, ".");
+    }
+    // make sure there's a terminator zero character, as input must be ASCIIZ
+    if (!memcmp(buffer.data(), "3dmo", 4)) {
+        buffer.push_back(0);
+    }
+
+    // Get the path for external assets
+    std::string folderName("./");
+    std::string::size_type pos = file.find_last_of("\\/");
+    if (pos != std::string::npos) {
+        folderName = file.substr(0, pos);
+        if (!folderName.empty()) {
+            pIOHandler->PushDirectory(folderName);
+        }
+    }
+
+    //DefaultLogger::create("/dev/stderr", Logger::VERBOSE);
+    ASSIMP_LOG_DEBUG("M3D: loading ", file);
+
+    // let the C SDK do the hard work for us
+    M3DWrapper m3d(pIOHandler, buffer);
+
+    if (!m3d) {
+        throw DeadlyImportError("Unable to parse ", file, " as M3D.");
+    }
+
+    // create the root node
+    pScene->mRootNode = new aiNode;
+    pScene->mRootNode->mName = aiString(m3d.Name());
+    pScene->mRootNode->mTransformation = aiMatrix4x4();
+    pScene->mRootNode->mNumChildren = 0;
+    mScene = pScene;
+
+    ASSIMP_LOG_DEBUG("M3D: root node ", m3d.Name());
+
+    // now we just have to fill up the Assimp structures in pScene
+    importMaterials(m3d);
+    importTextures(m3d);
+    importBones(m3d, M3D_NOTDEFINED, pScene->mRootNode);
+    importMeshes(m3d);
+    importAnimations(m3d);
+
+    // Pop directory stack
+    if (pIOHandler->StackSize() > 0) {
+        pIOHandler->PopDirectory();
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// convert materials. properties are converted using a static table in M3DMaterials.h
+void M3DImporter::importMaterials(const M3DWrapper &m3d) {
+    unsigned int i, j, k, l, n;
+    m3dm_t *m;
+    aiString name = aiString(AI_DEFAULT_MATERIAL_NAME);
+    aiColor4D c;
+    ai_real f;
+
+    ai_assert(mScene != nullptr);
+    ai_assert(m3d);
+
+    mScene->mNumMaterials = m3d->nummaterial + 1;
+    mScene->mMaterials = new aiMaterial *[mScene->mNumMaterials];
+
+    ASSIMP_LOG_DEBUG("M3D: importMaterials ", mScene->mNumMaterials);
+
+    // add a default material as first
+    aiMaterial *defaultMat = new aiMaterial;
+    defaultMat->AddProperty(&name, AI_MATKEY_NAME);
+    c.a = 1.0f;
+    c.b = c.g = c.r = 0.6f;
+    defaultMat->AddProperty(&c, 1, AI_MATKEY_COLOR_DIFFUSE);
+    mScene->mMaterials[0] = defaultMat;
+
+    if (!m3d->nummaterial || !m3d->material) {
+        return;
+    }
+
+    for (i = 0; i < m3d->nummaterial; i++) {
+        m = &m3d->material[i];
+        aiMaterial *newMat = new aiMaterial;
+        name.Set(std::string(m->name));
+        newMat->AddProperty(&name, AI_MATKEY_NAME);
+        for (j = 0; j < m->numprop; j++) {
+            // look up property type
+            // 0 - 127 scalar values,
+            // 128 - 255 the same properties but for texture maps
+            k = 256;
+            for (l = 0; l < sizeof(m3d_propertytypes) / sizeof(m3d_propertytypes[0]); l++)
+                if (m->prop[j].type == m3d_propertytypes[l].id ||
+                        m->prop[j].type == m3d_propertytypes[l].id + 128) {
+                    k = l;
+                    break;
+                }
+            // should never happen, but be safe than sorry
+            if (k == 256)
+                continue;
+
+            // scalar properties
+            if (m->prop[j].type < 128 && aiProps[k].pKey) {
+                switch (m3d_propertytypes[k].format) {
+                    case m3dpf_color:
+                        c = mkColor(m->prop[j].value.color);
+                        newMat->AddProperty(&c, 1, aiProps[k].pKey, aiProps[k].type, aiProps[k].index);
+                        break;
+                    case m3dpf_float:
+                        f = m->prop[j].value.fnum;
+                        newMat->AddProperty(&f, 1, aiProps[k].pKey, aiProps[k].type, aiProps[k].index);
+                        break;
+                    default:
+                        n = m->prop[j].value.num;
+                        if (m->prop[j].type == m3dp_il) {
+                            switch (n) {
+                                case 0:
+                                    n = aiShadingMode_NoShading;
+                                    break;
+                                case 2:
+                                    n = aiShadingMode_Phong;
+                                    break;
+                                default:
+                                    n = aiShadingMode_Gouraud;
+                                    break;
+                            }
+                        }
+                        newMat->AddProperty(&n, 1, aiProps[k].pKey, aiProps[k].type, aiProps[k].index);
+                        break;
+                }
+            }
+            // texture map properties
+            if (m->prop[j].type >= 128 && aiTxProps[k].pKey &&
+                    // extra check, should never happen, do we have the referred texture?
+                    m->prop[j].value.textureid < m3d->numtexture &&
+                    m3d->texture[m->prop[j].value.textureid].name) {
+                name.Set(std::string(std::string(m3d->texture[m->prop[j].value.textureid].name) + ".png"));
+                newMat->AddProperty(&name, aiTxProps[k].pKey, aiTxProps[k].type, aiTxProps[k].index);
+                n = 0;
+                newMat->AddProperty(&n, 1, _AI_MATKEY_UVWSRC_BASE, aiProps[k].type, aiProps[k].index);
+            }
+        }
+        mScene->mMaterials[i + 1] = newMat;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// import textures, this is the simplest of all
+void M3DImporter::importTextures(const M3DWrapper &m3d) {
+    unsigned int i;
+    const char *formatHint[] = {
+        "rgba0800",
+        "rgba0808",
+        "rgba8880",
+        "rgba8888"
+    };
+    m3dtx_t *t;
+
+    ai_assert(mScene != nullptr);
+    ai_assert(m3d);
+
+    mScene->mNumTextures = m3d->numtexture;
+    ASSIMP_LOG_DEBUG("M3D: importTextures ", mScene->mNumTextures);
+
+    if (!m3d->numtexture || !m3d->texture) {
+        return;
+    }
+
+    mScene->mTextures = new aiTexture *[m3d->numtexture];
+    for (i = 0; i < m3d->numtexture; i++) {
+        unsigned int j, k;
+        t = &m3d->texture[i];
+        aiTexture *tx = new aiTexture;
+        tx->mFilename = aiString(std::string(t->name) + ".png");
+        if (!t->w || !t->h || !t->f || !t->d) {
+            /* without ASSIMP_USE_M3D_READFILECB, we only have the filename, but no texture data ever */
+            tx->mWidth = 0;
+            tx->mHeight = 0;
+            memcpy(tx->achFormatHint, "png\000", 4);
+            tx->pcData = nullptr;
+        } else {
+            /* if we have the texture loaded, set format hint and pcData too */
+            tx->mWidth = t->w;
+            tx->mHeight = t->h;
+            strcpy(tx->achFormatHint, formatHint[t->f - 1]);
+            tx->pcData = new aiTexel[tx->mWidth * tx->mHeight];
+            for (j = k = 0; j < tx->mWidth * tx->mHeight; j++) {
+                switch (t->f) {
+                    case 1: tx->pcData[j].g = t->d[k++]; break;
+                    case 2:
+                        tx->pcData[j].g = t->d[k++];
+                        tx->pcData[j].a = t->d[k++];
+                        break;
+                    case 3:
+                        tx->pcData[j].r = t->d[k++];
+                        tx->pcData[j].g = t->d[k++];
+                        tx->pcData[j].b = t->d[k++];
+                        tx->pcData[j].a = 255;
+                        break;
+                    case 4:
+                        tx->pcData[j].r = t->d[k++];
+                        tx->pcData[j].g = t->d[k++];
+                        tx->pcData[j].b = t->d[k++];
+                        tx->pcData[j].a = t->d[k++];
+                        break;
+                }
+            }
+        }
+        mScene->mTextures[i] = tx;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// this is tricky. M3D has a global vertex and UV list, and faces are indexing them
+// individually. In assimp there're per mesh vertex and UV lists, and they must be
+// indexed simultaneously.
+void M3DImporter::importMeshes(const M3DWrapper &m3d) {
+    ASSIMP_LOG_DEBUG("M3D: importMeshes ", m3d->numface);
+
+    if (!m3d->numface || !m3d->face || !m3d->numvertex || !m3d->vertex) {
+        return;
+    }
+
+    unsigned int i, j, k, l, numpoly = 3, lastMat = M3D_INDEXMAX;
+    std::vector<aiMesh *> *meshes = new std::vector<aiMesh *>();
+    std::vector<aiFace> *faces = nullptr;
+    std::vector<aiVector3D> *vertices = nullptr;
+    std::vector<aiVector3D> *normals = nullptr;
+    std::vector<aiVector3D> *texcoords = nullptr;
+    std::vector<aiColor4D> *colors = nullptr;
+    std::vector<unsigned int> *vertexids = nullptr;
+    aiMesh *pMesh = nullptr;
+
+    ai_assert(mScene != nullptr);
+    ai_assert(m3d);
+    ai_assert(mScene->mRootNode != nullptr);
+
+    for (i = 0; i < m3d->numface; i++) {
+        // we must switch mesh if material changes
+        if (lastMat != m3d->face[i].materialid) {
+            lastMat = m3d->face[i].materialid;
+            if (pMesh && vertices && vertices->size() && faces && faces->size()) {
+                populateMesh(m3d, pMesh, faces, vertices, normals, texcoords, colors, vertexids);
+                meshes->push_back(pMesh);
+                delete faces;
+                delete vertices;
+                delete normals;
+                delete texcoords;
+                delete colors;
+                delete vertexids; // this is not stored in pMesh, just to collect bone vertices
+            }
+            pMesh = new aiMesh;
+            pMesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
+            pMesh->mMaterialIndex = lastMat + 1;
+            faces = new std::vector<aiFace>();
+            vertices = new std::vector<aiVector3D>();
+            normals = new std::vector<aiVector3D>();
+            texcoords = new std::vector<aiVector3D>();
+            colors = new std::vector<aiColor4D>();
+            vertexids = new std::vector<unsigned int>();
+        }
+        // add a face to temporary vector
+        aiFace *pFace = new aiFace;
+        pFace->mNumIndices = numpoly;
+        pFace->mIndices = new unsigned int[numpoly];
+        for (j = 0; j < numpoly; j++) {
+            aiVector3D pos, uv, norm;
+            k = static_cast<unsigned int>(vertices->size());
+            pFace->mIndices[j] = k;
+            l = m3d->face[i].vertex[j];
+            if (l >= m3d->numvertex) continue;
+            pos.x = m3d->vertex[l].x;
+            pos.y = m3d->vertex[l].y;
+            pos.z = m3d->vertex[l].z;
+            vertices->push_back(pos);
+            colors->push_back(mkColor(m3d->vertex[l].color));
+            // add a bone to temporary vector
+            if (m3d->vertex[l].skinid != M3D_UNDEF && m3d->vertex[l].skinid != M3D_INDEXMAX && m3d->skin && m3d->bone) {
+                // this is complicated, because M3D stores a list of bone id / weight pairs per
+                // vertex but assimp uses lists of local vertex id/weight pairs per local bone list
+                vertexids->push_back(l);
+            }
+            l = m3d->face[i].texcoord[j];
+            if (l != M3D_UNDEF && l < m3d->numtmap) {
+                uv.x = m3d->tmap[l].u;
+                uv.y = m3d->tmap[l].v;
+                uv.z = 0.0;
+                texcoords->push_back(uv);
+            }
+            l = m3d->face[i].normal[j];
+            if (l != M3D_UNDEF && l < m3d->numvertex) {
+                norm.x = m3d->vertex[l].x;
+                norm.y = m3d->vertex[l].y;
+                norm.z = m3d->vertex[l].z;
+                normals->push_back(norm);
+            }
+        }
+        faces->push_back(*pFace);
+        delete pFace;
+    }
+    // if there's data left in the temporary vectors, flush them
+    if (pMesh && vertices->size() && faces->size()) {
+        populateMesh(m3d, pMesh, faces, vertices, normals, texcoords, colors, vertexids);
+        meshes->push_back(pMesh);
+    }
+
+    // create global mesh list in scene
+    mScene->mNumMeshes = static_cast<unsigned int>(meshes->size());
+    mScene->mMeshes = new aiMesh *[mScene->mNumMeshes];
+    std::copy(meshes->begin(), meshes->end(), mScene->mMeshes);
+
+    // create mesh indices in root node
+    mScene->mRootNode->mNumMeshes = static_cast<unsigned int>(meshes->size());
+    mScene->mRootNode->mMeshes = new unsigned int[meshes->size()];
+    for (i = 0; i < meshes->size(); i++) {
+        mScene->mRootNode->mMeshes[i] = i;
+    }
+
+    delete meshes;
+    if (faces) delete faces;
+    if (vertices) delete vertices;
+    if (normals) delete normals;
+    if (texcoords) delete texcoords;
+    if (colors) delete colors;
+    if (vertexids) delete vertexids;
+}
+
+// ------------------------------------------------------------------------------------------------
+// a reentrant node parser. Otherwise this is simple
+void M3DImporter::importBones(const M3DWrapper &m3d, unsigned int parentid, aiNode *pParent) {
+    unsigned int i, n;
+
+    ai_assert(pParent != nullptr);
+    ai_assert(mScene != nullptr);
+    ai_assert(m3d);
+
+    ASSIMP_LOG_DEBUG("M3D: importBones ", m3d->numbone, " parentid ", (int)parentid);
+
+    if (!m3d->numbone || !m3d->bone) {
+        return;
+    }
+
+    for (n = 0, i = parentid + 1; i < m3d->numbone; i++) {
+        if (m3d->bone[i].parent == parentid) {
+            n++;
+        }
+    }
+    pParent->mChildren = new aiNode *[n];
+
+    for (i = parentid + 1; i < m3d->numbone; i++) {
+        if (m3d->bone[i].parent == parentid) {
+            aiNode *pChild = new aiNode;
+            pChild->mParent = pParent;
+            pChild->mName = aiString(std::string(m3d->bone[i].name));
+            convertPose(m3d, &pChild->mTransformation, m3d->bone[i].pos, m3d->bone[i].ori);
+            pChild->mNumChildren = 0;
+            pParent->mChildren[pParent->mNumChildren] = pChild;
+            pParent->mNumChildren++;
+            importBones(m3d, i, pChild);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// this is another headache. M3D stores list of changed bone id/position/orientation triplets and
+// a timestamp per frame, but assimp needs timestamp and lists of position, orientation lists per
+// bone, so we have to convert between the two conceptually different representation forms
+void M3DImporter::importAnimations(const M3DWrapper &m3d) {
+    unsigned int i, j, k, l, pos, ori;
+    double t;
+    m3da_t *a;
+
+    ai_assert(mScene != nullptr);
+    ai_assert(m3d);
+
+    mScene->mNumAnimations = m3d->numaction;
+
+    ASSIMP_LOG_DEBUG("M3D: importAnimations ", mScene->mNumAnimations);
+
+    if (!m3d->numaction || !m3d->action || !m3d->numbone || !m3d->bone || !m3d->vertex) {
+        return;
+    }
+
+    mScene->mAnimations = new aiAnimation *[m3d->numaction];
+    for (i = 0; i < m3d->numaction; i++) {
+        a = &m3d->action[i];
+        aiAnimation *pAnim = new aiAnimation;
+        pAnim->mName = aiString(std::string(a->name));
+        pAnim->mDuration = ((double)a->durationmsec) / 10;
+        pAnim->mTicksPerSecond = 100;
+        // now we know how many bones are referenced in this animation
+        pAnim->mNumChannels = m3d->numbone;
+        pAnim->mChannels = new aiNodeAnim *[pAnim->mNumChannels];
+        for (l = 0; l < m3d->numbone; l++) {
+            unsigned int n;
+            pAnim->mChannels[l] = new aiNodeAnim;
+            pAnim->mChannels[l]->mNodeName = aiString(std::string(m3d->bone[l].name));
+            // now n is the size of positions / orientations arrays
+            pAnim->mChannels[l]->mNumPositionKeys = pAnim->mChannels[l]->mNumRotationKeys = a->numframe;
+            pAnim->mChannels[l]->mPositionKeys = new aiVectorKey[a->numframe];
+            pAnim->mChannels[l]->mRotationKeys = new aiQuatKey[a->numframe];
+            pos = m3d->bone[l].pos;
+            ori = m3d->bone[l].ori;
+            for (j = n = 0; j < a->numframe; j++) {
+                t = ((double)a->frame[j].msec) / 10;
+                for (k = 0; k < a->frame[j].numtransform; k++) {
+                    if (a->frame[j].transform[k].boneid == l) {
+                        pos = a->frame[j].transform[k].pos;
+                        ori = a->frame[j].transform[k].ori;
+                    }
+                }
+                if (pos >= m3d->numvertex || ori >= m3d->numvertex) continue;
+                m3dv_t *v = &m3d->vertex[pos];
+                m3dv_t *q = &m3d->vertex[ori];
+                pAnim->mChannels[l]->mPositionKeys[j].mTime = t;
+                pAnim->mChannels[l]->mPositionKeys[j].mValue.x = v->x;
+                pAnim->mChannels[l]->mPositionKeys[j].mValue.y = v->y;
+                pAnim->mChannels[l]->mPositionKeys[j].mValue.z = v->z;
+                pAnim->mChannels[l]->mRotationKeys[j].mTime = t;
+                pAnim->mChannels[l]->mRotationKeys[j].mValue.w = q->w;
+                pAnim->mChannels[l]->mRotationKeys[j].mValue.x = q->x;
+                pAnim->mChannels[l]->mRotationKeys[j].mValue.y = q->y;
+                pAnim->mChannels[l]->mRotationKeys[j].mValue.z = q->z;
+            } // foreach frame
+        } // foreach bones
+        mScene->mAnimations[i] = pAnim;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// convert uint32_t into aiColor4D
+aiColor4D M3DImporter::mkColor(uint32_t c) {
+    aiColor4D color;
+    color.a = ((float)((c >> 24) & 0xff)) / 255;
+    color.b = ((float)((c >> 16) & 0xff)) / 255;
+    color.g = ((float)((c >> 8) & 0xff)) / 255;
+    color.r = ((float)((c >> 0) & 0xff)) / 255;
+    return color;
+}
+
+// ------------------------------------------------------------------------------------------------
+// convert a position id and orientation id into a 4 x 4 transformation matrix
+void M3DImporter::convertPose(const M3DWrapper &m3d, aiMatrix4x4 *m, unsigned int posid, unsigned int orientid) {
+    ai_assert(m != nullptr);
+    ai_assert(m3d);
+    ai_assert(posid != M3D_UNDEF);
+    ai_assert(posid < m3d->numvertex);
+    ai_assert(orientid != M3D_UNDEF);
+    ai_assert(orientid < m3d->numvertex);
+    if (!m3d->numvertex || !m3d->vertex)
+        return;
+    m3dv_t *p = &m3d->vertex[posid];
+    m3dv_t *q = &m3d->vertex[orientid];
+
+    /* quaternion to matrix. Do NOT use aiQuaternion to aiMatrix3x3, gives bad results */
+    if (q->x == 0.0 && q->y == 0.0 && q->z >= 0.7071065 && q->z <= 0.7071075 && q->w == 0.0) {
+        m->a2 = m->a3 = m->b1 = m->b3 = m->c1 = m->c2 = 0.0;
+        m->a1 = m->b2 = m->c3 = -1.0;
+    } else {
+        m->a1 = 1 - 2 * (q->y * q->y + q->z * q->z);
+        if (m->a1 > -M3D_EPSILON && m->a1 < M3D_EPSILON) m->a1 = 0.0;
+        m->a2 = 2 * (q->x * q->y - q->z * q->w);
+        if (m->a2 > -M3D_EPSILON && m->a2 < M3D_EPSILON) m->a2 = 0.0;
+        m->a3 = 2 * (q->x * q->z + q->y * q->w);
+        if (m->a3 > -M3D_EPSILON && m->a3 < M3D_EPSILON) m->a3 = 0.0;
+        m->b1 = 2 * (q->x * q->y + q->z * q->w);
+        if (m->b1 > -M3D_EPSILON && m->b1 < M3D_EPSILON) m->b1 = 0.0;
+        m->b2 = 1 - 2 * (q->x * q->x + q->z * q->z);
+        if (m->b2 > -M3D_EPSILON && m->b2 < M3D_EPSILON) m->b2 = 0.0;
+        m->b3 = 2 * (q->y * q->z - q->x * q->w);
+        if (m->b3 > -M3D_EPSILON && m->b3 < M3D_EPSILON) m->b3 = 0.0;
+        m->c1 = 2 * (q->x * q->z - q->y * q->w);
+        if (m->c1 > -M3D_EPSILON && m->c1 < M3D_EPSILON) m->c1 = 0.0;
+        m->c2 = 2 * (q->y * q->z + q->x * q->w);
+        if (m->c2 > -M3D_EPSILON && m->c2 < M3D_EPSILON) m->c2 = 0.0;
+        m->c3 = 1 - 2 * (q->x * q->x + q->y * q->y);
+        if (m->c3 > -M3D_EPSILON && m->c3 < M3D_EPSILON) m->c3 = 0.0;
+    }
+
+    /* set translation */
+    m->a4 = p->x;
+    m->b4 = p->y;
+    m->c4 = p->z;
+
+    m->d1 = 0;
+    m->d2 = 0;
+    m->d3 = 0;
+    m->d4 = 1;
+}
+
+// ------------------------------------------------------------------------------------------------
+// find a node by name
+aiNode *M3DImporter::findNode(aiNode *pNode, const aiString &name) {
+    ai_assert(pNode != nullptr);
+    ai_assert(mScene != nullptr);
+
+    if (pNode->mName == name) {
+        return pNode;
+    }
+
+    for (unsigned int i = 0; i < pNode->mNumChildren; i++) {
+        aiNode *pChild = findNode(pNode->mChildren[i], name);
+        if (pChild) {
+            return pChild;
+        }
+    }
+    return nullptr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// fills up offsetmatrix in mBones
+void M3DImporter::calculateOffsetMatrix(aiNode *pNode, aiMatrix4x4 *m) {
+    ai_assert(pNode != nullptr);
+    ai_assert(mScene != nullptr);
+
+    if (pNode->mParent) {
+        calculateOffsetMatrix(pNode->mParent, m);
+        *m *= pNode->mTransformation;
+    } else {
+        *m = pNode->mTransformation;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// because M3D has a global mesh, global vertex ids and stores materialid on the face, we need
+// temporary lists to collect data for an aiMesh, which requires local arrays and local indices
+// this function fills up an aiMesh with those temporary lists
+void M3DImporter::populateMesh(const M3DWrapper &m3d, aiMesh *pMesh, std::vector<aiFace> *faces, std::vector<aiVector3D> *vertices,
+        std::vector<aiVector3D> *normals, std::vector<aiVector3D> *texcoords, std::vector<aiColor4D> *colors,
+        std::vector<unsigned int> *vertexids) {
+
+    ai_assert(pMesh != nullptr);
+    ai_assert(faces != nullptr);
+    ai_assert(vertices != nullptr);
+    ai_assert(normals != nullptr);
+    ai_assert(texcoords != nullptr);
+    ai_assert(colors != nullptr);
+    ai_assert(vertexids != nullptr);
+    ai_assert(m3d);
+
+    ASSIMP_LOG_DEBUG("M3D: populateMesh numvertices ", vertices->size(), " numfaces ", faces->size(),
+            " numnormals ", normals->size(), " numtexcoord ", texcoords->size(), " numbones ", m3d->numbone);
+
+    if (vertices->size() && faces->size()) {
+        pMesh->mNumFaces = static_cast<unsigned int>(faces->size());
+        pMesh->mFaces = new aiFace[pMesh->mNumFaces];
+        std::copy(faces->begin(), faces->end(), pMesh->mFaces);
+        pMesh->mNumVertices = static_cast<unsigned int>(vertices->size());
+        pMesh->mVertices = new aiVector3D[pMesh->mNumVertices];
+        std::copy(vertices->begin(), vertices->end(), pMesh->mVertices);
+        if (normals->size() == vertices->size()) {
+            pMesh->mNormals = new aiVector3D[pMesh->mNumVertices];
+            std::copy(normals->begin(), normals->end(), pMesh->mNormals);
+        }
+        if (texcoords->size() == vertices->size()) {
+            pMesh->mTextureCoords[0] = new aiVector3D[pMesh->mNumVertices];
+            std::copy(texcoords->begin(), texcoords->end(), pMesh->mTextureCoords[0]);
+            pMesh->mNumUVComponents[0] = 2;
+        }
+        if (colors->size() == vertices->size()) {
+            pMesh->mColors[0] = new aiColor4D[pMesh->mNumVertices];
+            std::copy(colors->begin(), colors->end(), pMesh->mColors[0]);
+        }
+        // this is complicated, because M3D stores a list of bone id / weight pairs per
+        // vertex but assimp uses lists of local vertex id/weight pairs per local bone list
+        pMesh->mNumBones = m3d->numbone;
+        // we need aiBone with mOffsetMatrix for bones without weights as well
+        if (pMesh->mNumBones && m3d->numbone && m3d->bone) {
+            pMesh->mBones = new aiBone *[pMesh->mNumBones];
+            for (unsigned int i = 0; i < m3d->numbone; i++) {
+                aiNode *pNode;
+                pMesh->mBones[i] = new aiBone;
+                pMesh->mBones[i]->mName = aiString(std::string(m3d->bone[i].name));
+                pMesh->mBones[i]->mNumWeights = 0;
+                pNode = findNode(mScene->mRootNode, pMesh->mBones[i]->mName);
+                if (pNode) {
+                    calculateOffsetMatrix(pNode, &pMesh->mBones[i]->mOffsetMatrix);
+                    pMesh->mBones[i]->mOffsetMatrix.Inverse();
+                } else
+                    pMesh->mBones[i]->mOffsetMatrix = aiMatrix4x4();
+            }
+            if (vertexids->size() && m3d->numvertex && m3d->vertex && m3d->numskin && m3d->skin) {
+                unsigned int i, j;
+                // first count how many vertices we have per bone
+                for (i = 0; i < vertexids->size(); i++) {
+                    if (vertexids->at(i) >= m3d->numvertex) {
+                        continue;
+                    }
+                    unsigned int s = m3d->vertex[vertexids->at(i)].skinid;
+                    if (s != M3D_UNDEF && s != M3D_INDEXMAX) {
+                        for (unsigned int k = 0; k < M3D_NUMBONE && m3d->skin[s].weight[k] > 0.0; k++) {
+                            aiString name = aiString(std::string(m3d->bone[m3d->skin[s].boneid[k]].name));
+                            for (j = 0; j < pMesh->mNumBones; j++) {
+                                if (pMesh->mBones[j]->mName == name) {
+                                    pMesh->mBones[j]->mNumWeights++;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+                // allocate mWeights
+                for (j = 0; j < pMesh->mNumBones; j++) {
+                    aiBone *pBone = pMesh->mBones[j];
+                    if (pBone->mNumWeights) {
+                        pBone->mWeights = new aiVertexWeight[pBone->mNumWeights];
+                        pBone->mNumWeights = 0;
+                    }
+                }
+                // fill up with data
+                for (i = 0; i < vertexids->size(); i++) {
+                    if (vertexids->at(i) >= m3d->numvertex) continue;
+                    unsigned int s = m3d->vertex[vertexids->at(i)].skinid;
+                    if (s != M3D_UNDEF && s != M3D_INDEXMAX && s < m3d->numskin) {
+                        for (unsigned int k = 0; k < M3D_NUMBONE && m3d->skin[s].weight[k] > 0.0; k++) {
+                            if (m3d->skin[s].boneid[k] >= m3d->numbone) continue;
+                            aiString name = aiString(std::string(m3d->bone[m3d->skin[s].boneid[k]].name));
+                            for (j = 0; j < pMesh->mNumBones; j++) {
+                                if (pMesh->mBones[j]->mName == name) {
+                                    aiBone *pBone = pMesh->mBones[j];
+                                    pBone->mWeights[pBone->mNumWeights].mVertexId = i;
+                                    pBone->mWeights[pBone->mNumWeights].mWeight = m3d->skin[s].weight[k];
+                                    pBone->mNumWeights++;
+                                    break;
+                                }
+                            }
+                        } // foreach skin
+                    }
+                } // foreach vertexids
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+
+} // Namespace Assimp
+
+#endif // !! ASSIMP_BUILD_NO_M3D_IMPORTER
diff --git a/Engine/lib/assimp/code/AssetLib/M3D/M3DImporter.h b/Engine/lib/assimp/code/AssetLib/M3D/M3DImporter.h
new file mode 100644
index 000000000..5d3fcaa7b
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/M3D/M3DImporter.h
@@ -0,0 +1,105 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+Copyright (c) 2019 bzt
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file M3DImporter.h
+*   @brief Declares the importer class to read a scene from a Model 3D file
+*/
+#ifndef AI_M3DIMPORTER_H_INC
+#define AI_M3DIMPORTER_H_INC
+
+#ifndef ASSIMP_BUILD_NO_M3D_IMPORTER
+
+#include <assimp/BaseImporter.h>
+#include <assimp/material.h>
+#include <vector>
+
+struct aiMesh;
+struct aiNode;
+struct aiMaterial;
+struct aiFace;
+
+namespace Assimp {
+
+class M3DWrapper;
+
+class M3DImporter : public BaseImporter {
+public:
+	/// \brief  Default constructor
+	M3DImporter();
+    ~M3DImporter() override {}
+
+	/// \brief  Returns whether the class can handle the format of the given file.
+	/// \remark See BaseImporter::CanRead() for details.
+	bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const override;
+
+protected:
+    //! \brief  Appends the supported extension.
+    const aiImporterDesc *GetInfo() const override;
+
+    //! \brief  File import implementation.
+    void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) override;
+
+private:
+	void importMaterials(const M3DWrapper &m3d);
+	void importTextures(const M3DWrapper &m3d);
+	void importMeshes(const M3DWrapper &m3d);
+	void importBones(const M3DWrapper &m3d, unsigned int parentid, aiNode *pParent);
+	void importAnimations(const M3DWrapper &m3d);
+
+	// helper functions
+	aiColor4D mkColor(uint32_t c);
+	void convertPose(const M3DWrapper &m3d, aiMatrix4x4 *m, unsigned int posid, unsigned int orientid);
+    aiNode *findNode(aiNode *pNode, const aiString &name);
+    void calculateOffsetMatrix(aiNode *pNode, aiMatrix4x4 *m);
+	void populateMesh(const M3DWrapper &m3d, aiMesh *pMesh, std::vector<aiFace> *faces, std::vector<aiVector3D> *verteces,
+			std::vector<aiVector3D> *normals, std::vector<aiVector3D> *texcoords, std::vector<aiColor4D> *colors,
+			std::vector<unsigned int> *vertexids);
+
+private:
+    aiScene *mScene = nullptr; // the scene to import to
+};
+
+} // Namespace Assimp
+
+#endif // ASSIMP_BUILD_NO_M3D_IMPORTER
+
+#endif // AI_M3DIMPORTER_H_INC
diff --git a/Engine/lib/assimp/code/AssetLib/M3D/M3DMaterials.h b/Engine/lib/assimp/code/AssetLib/M3D/M3DMaterials.h
new file mode 100644
index 000000000..a1b0fd742
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/M3D/M3DMaterials.h
@@ -0,0 +1,106 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+Copyright (c) 2019 bzt
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file M3DMaterials.h
+*   @brief Declares the Assimp and Model 3D file material type relations
+*/
+#ifndef AI_M3DMATERIALS_H_INC
+#define AI_M3DMATERIALS_H_INC
+
+/*
+ * In the m3d.h header, there's a static array which defines the material
+ * properties, called m3d_propertytypes. These must have the same size, and
+ * list the matching Assimp materials for those properties. Used by both the
+ * M3DImporter and the M3DExporter, so you have to define these relations
+ * only once. D.R.Y. and K.I.S.S.
+ */
+typedef struct {
+    const char *pKey;
+    unsigned int type;
+    unsigned int index;
+} aiMatProp;
+
+/* --- Scalar Properties ---        !!!!! must match m3d_propertytypes !!!!! */
+static const aiMatProp aiProps[] = {
+    { AI_MATKEY_COLOR_DIFFUSE },                                /* m3dp_Kd */
+    { AI_MATKEY_COLOR_AMBIENT },                                /* m3dp_Ka */
+    { AI_MATKEY_COLOR_SPECULAR },                               /* m3dp_Ks */
+    { AI_MATKEY_SHININESS },                                    /* m3dp_Ns */
+    { AI_MATKEY_COLOR_EMISSIVE },                               /* m3dp_Ke */
+    { AI_MATKEY_COLOR_REFLECTIVE },                             /* m3dp_Tf */
+    { AI_MATKEY_BUMPSCALING },                                  /* m3dp_Km */
+    { AI_MATKEY_OPACITY },                                      /* m3dp_d */
+    { AI_MATKEY_SHADING_MODEL },                                /* m3dp_il */
+
+    { nullptr, 0, 0 },                                          /* m3dp_Pr */
+    { AI_MATKEY_REFLECTIVITY },                                 /* m3dp_Pm */
+    { nullptr, 0, 0 },                                          /* m3dp_Ps */
+    { AI_MATKEY_REFRACTI },                                     /* m3dp_Ni */
+    { nullptr, 0, 0 },                                          /* m3dp_Nt */
+    { nullptr, 0, 0 },
+    { nullptr, 0, 0 },
+    { nullptr, 0, 0 }
+};
+
+/* --- Texture Map Properties ---   !!!!! must match m3d_propertytypes !!!!! */
+static const aiMatProp aiTxProps[] = {
+    { AI_MATKEY_TEXTURE_DIFFUSE(0) },                        /* m3dp_map_Kd */
+    { AI_MATKEY_TEXTURE(aiTextureType_AMBIENT_OCCLUSION,0) },/* m3dp_map_Ka */
+    { AI_MATKEY_TEXTURE_SPECULAR(0) },                       /* m3dp_map_Ks */
+    { AI_MATKEY_TEXTURE_SHININESS(0) },                      /* m3dp_map_Ns */
+    { AI_MATKEY_TEXTURE_EMISSIVE(0) },                       /* m3dp_map_Ke */
+    { nullptr, 0, 0 },                                       /* m3dp_map_Tf */
+    { AI_MATKEY_TEXTURE_HEIGHT(0) },                         /* m3dp_bump */
+    { AI_MATKEY_TEXTURE_OPACITY(0) },                        /* m3dp_map_d */
+    { AI_MATKEY_TEXTURE_NORMALS(0) },                        /* m3dp_map_N */
+
+    { AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE_ROUGHNESS,0) },/* m3dp_map_Pr */
+    { AI_MATKEY_TEXTURE(aiTextureType_METALNESS,0) },        /* m3dp_map_Pm */
+    { nullptr, 0, 0 },                                       /* m3dp_map_Ps */
+    { AI_MATKEY_TEXTURE(aiTextureType_REFLECTION,0) },       /* m3dp_map_Ni */
+    { nullptr, 0, 0 },                                       /* m3dp_map_Nt */
+    { nullptr, 0, 0 },
+    { nullptr, 0, 0 },
+    { nullptr, 0, 0 }
+};
+
+#endif // AI_M3DMATERIALS_H_INC
diff --git a/Engine/lib/assimp/code/AssetLib/M3D/M3DWrapper.cpp b/Engine/lib/assimp/code/AssetLib/M3D/M3DWrapper.cpp
new file mode 100644
index 000000000..30452c776
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/M3D/M3DWrapper.cpp
@@ -0,0 +1,152 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+Copyright (c) 2019 bzt
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+#ifndef ASSIMP_BUILD_NO_M3D_IMPORTER
+#if !(ASSIMP_BUILD_NO_EXPORT || ASSIMP_BUILD_NO_M3D_EXPORTER)
+
+#include "M3DWrapper.h"
+
+#include <assimp/DefaultIOSystem.h>
+#include <assimp/IOStreamBuffer.h>
+#include <assimp/ai_assert.h>
+
+#ifdef ASSIMP_USE_M3D_READFILECB
+
+#if (__cplusplus >= 201103L) || !defined(_MSC_VER) || (_MSC_VER >= 1900) // C++11 and MSVC 2015 onwards
+#define threadlocal thread_local
+#else
+#if defined(_MSC_VER) && (_MSC_VER >= 1800) // there's an alternative for MSVC 2013
+#define threadlocal __declspec(thread)
+#else
+#define threadlocal
+#endif
+#endif
+
+extern "C" {
+
+// workaround: the M3D SDK expects a C callback, but we want to use Assimp::IOSystem to implement that
+threadlocal void *m3dimporter_pIOHandler;
+
+unsigned char *m3dimporter_readfile(char *fn, unsigned int *size) {
+    ai_assert(nullptr != fn);
+    ai_assert(nullptr != size);
+    std::string file(fn);
+    std::unique_ptr<Assimp::IOStream> pStream(
+            (reinterpret_cast<Assimp::IOSystem *>(m3dimporter_pIOHandler))->Open(file, "rb"));
+    size_t fileSize = 0;
+    unsigned char *data = nullptr;
+    // sometimes pStream is nullptr in a single-threaded scenario too for some reason
+    // (should be an empty object returning nothing I guess)
+    if (pStream) {
+        fileSize = pStream->FileSize();
+        // should be allocated with malloc(), because the library will call free() to deallocate
+        data = (unsigned char *)malloc(fileSize);
+        if (!data || !pStream.get() || !fileSize || fileSize != pStream->Read(data, 1, fileSize)) {
+            pStream.reset();
+            *size = 0;
+            // don't throw a deadly exception, it's not fatal if we can't read an external asset
+            return nullptr;
+        }
+        pStream.reset();
+    }
+    *size = (int)fileSize;
+    return data;
+}
+}
+#endif
+
+namespace Assimp {
+M3DWrapper::M3DWrapper() {
+    // use malloc() here because m3d_free() will call free()
+    m3d_ = (m3d_t *)calloc(1, sizeof(m3d_t));
+}
+
+M3DWrapper::M3DWrapper(IOSystem *pIOHandler, const std::vector<unsigned char> &buffer) {
+    if (nullptr == pIOHandler) {
+        ai_assert(nullptr != pIOHandler);
+    }
+
+#ifdef ASSIMP_USE_M3D_READFILECB
+    // pass this IOHandler to the C callback in a thread-local pointer
+    m3dimporter_pIOHandler = pIOHandler;
+    m3d_ = m3d_load(const_cast<unsigned char *>(buffer.data()), m3dimporter_readfile, free, nullptr);
+    // Clear the C callback
+    m3dimporter_pIOHandler = nullptr;
+#else
+    m3d_ = m3d_load(const_cast<unsigned char *>(buffer.data()), nullptr, nullptr, nullptr);
+#endif
+}
+
+M3DWrapper::~M3DWrapper() {
+    reset();
+}
+
+void M3DWrapper::reset() {
+    ClearSave();
+    if (m3d_) {
+        m3d_free(m3d_);
+    }
+    m3d_ = nullptr;
+}
+
+unsigned char *M3DWrapper::Save(int quality, int flags, unsigned int &size) {
+#if (!(ASSIMP_BUILD_NO_EXPORT || ASSIMP_BUILD_NO_M3D_EXPORTER))
+    ClearSave();
+    saved_output_ = m3d_save(m3d_, quality, flags, &size);
+    return saved_output_;
+#else
+    (void)quality;
+    (void)flags;
+    (void)size;
+    return nullptr;
+#endif
+}
+
+void M3DWrapper::ClearSave() {
+    if (saved_output_) {
+        M3D_FREE(saved_output_);
+    }
+    saved_output_ = nullptr;
+}
+} // namespace Assimp
+
+#endif
+#endif
diff --git a/Engine/lib/assimp/code/AssetLib/M3D/M3DWrapper.h b/Engine/lib/assimp/code/AssetLib/M3D/M3DWrapper.h
new file mode 100644
index 000000000..7cc2d0eef
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/M3D/M3DWrapper.h
@@ -0,0 +1,134 @@
+#pragma once
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+Copyright (c) 2019 bzt
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file M3DWrapper.h
+*   @brief Declares a class to wrap the C m3d SDK
+*/
+#ifndef AI_M3DWRAPPER_H_INC
+#define AI_M3DWRAPPER_H_INC
+
+#ifndef ASSIMP_BUILD_NO_M3D_IMPORTER
+#if !(ASSIMP_BUILD_NO_EXPORT || ASSIMP_BUILD_NO_M3D_EXPORTER)  
+
+#include <memory>
+#include <vector>
+#include <string>
+
+// Assimp specific M3D configuration. Comment out these defines to remove functionality
+//#define ASSIMP_USE_M3D_READFILECB
+
+// Share stb_image's PNG loader with other importers/exporters instead of bringing our own copy.
+#define STBI_ONLY_PNG
+#include <stb/stb_image.h>
+
+#include "m3d.h"
+
+namespace Assimp {
+
+class IOSystem;
+
+/// brief   The M3D-Wrapper, provudes c++ access to the data.
+class M3DWrapper {
+public:
+	/// Construct an empty M3D model
+	explicit M3DWrapper();
+
+	/// Construct an M3D model from provided buffer
+	/// @note The m3d.h SDK function does not mark the data as const. Have assumed it does not write.
+	/// BUG: SECURITY: The m3d.h SDK cannot be informed of the buffer size. BUFFER OVERFLOW IS CERTAIN
+	explicit M3DWrapper(IOSystem *pIOHandler, const std::vector<unsigned char> &buffer);
+
+	/// Theclasss destructor.
+    ~M3DWrapper();
+
+	/// Will reset the wrapper, all data will become nullptr.
+    void reset();
+
+	// The Name access, empty string returned when no m3d instance.
+	std::string Name() const;
+
+	/// Executes a save.
+	unsigned char *Save(int quality, int flags, unsigned int &size);
+
+    /// Clearer
+	void ClearSave();
+
+    /// True for m3d instance exists.
+	explicit operator bool() const;
+
+	// Allow direct access to M3D API
+	m3d_t *operator->() const;
+	m3d_t *M3D() const;
+
+private:
+	m3d_t *m3d_ = nullptr;
+	unsigned char *saved_output_ = nullptr;
+};
+
+inline std::string M3DWrapper::Name() const {
+    if (nullptr != m3d_) {
+        if (nullptr != m3d_->name) {
+            return std::string(m3d_->name);
+        }
+    }
+    return std::string();
+}
+
+inline M3DWrapper::operator bool() const {
+    return m3d_ != nullptr;
+}
+
+inline m3d_t *M3DWrapper::operator->() const {
+    return m3d_;
+}
+
+inline m3d_t *M3DWrapper::M3D() const {
+    return m3d_;
+}
+
+} // namespace Assimp
+
+#endif
+#endif // ASSIMP_BUILD_NO_M3D_IMPORTER
+
+#endif // AI_M3DWRAPPER_H_INC
diff --git a/Engine/lib/assimp/code/AssetLib/M3D/m3d.h b/Engine/lib/assimp/code/AssetLib/M3D/m3d.h
new file mode 100644
index 000000000..875007eab
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/M3D/m3d.h
@@ -0,0 +1,4902 @@
+/*
+ * m3d.h
+ *
+ * Copyright (C) 2019 bzt (bztsrc@gitlab)
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy,
+ * modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * @brief ANSI C89 / C++11 single header importer / exporter SDK for the Model 3D (.M3D) format
+ * https://gitlab.com/bztsrc/model3d
+ *
+ * PNG decompressor included from (with minor modifications to make it C89 valid):
+ *  stb_image - v2.13 - public domain image loader - http://nothings.org/stb_image.h
+ *
+ * @version: 1.0.0
+ */
+
+#ifndef _M3D_H_
+#define _M3D_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+/*** configuration ***/
+#ifndef M3D_MALLOC
+#define M3D_MALLOC(sz) malloc(sz)
+#endif
+#ifndef M3D_REALLOC
+#define M3D_REALLOC(p, nsz) realloc(p, nsz)
+#endif
+#ifndef M3D_FREE
+#define M3D_FREE(p) free(p)
+#endif
+#ifndef M3D_LOG
+#define M3D_LOG(x)
+#endif
+#ifndef M3D_APIVERSION
+#define M3D_APIVERSION 0x0100
+#ifndef M3D_DOUBLE
+typedef float M3D_FLOAT;
+#ifndef M3D_EPSILON
+/* carefully chosen for IEEE 754 don't change */
+#define M3D_EPSILON ((M3D_FLOAT)1e-7)
+#endif
+#else
+typedef double M3D_FLOAT;
+#ifndef M3D_EPSILON
+#define M3D_EPSILON ((M3D_FLOAT)1e-14)
+#endif
+#endif
+#if !defined(M3D_SMALLINDEX)
+typedef uint32_t M3D_INDEX;
+#define M3D_UNDEF 0xffffffff
+#define M3D_INDEXMAX 0xfffffffe
+#else
+typedef uint16_t M3D_INDEX;
+#define M3D_UNDEF 0xffff
+#define M3D_INDEXMAX 0xfffe
+#endif
+#define M3D_NOTDEFINED 0xffffffff
+#ifndef M3D_NUMBONE
+#define M3D_NUMBONE 4
+#endif
+#ifndef M3D_BONEMAXLEVEL
+#define M3D_BONEMAXLEVEL 8
+#endif
+#if !defined(_MSC_VER) || defined(__clang__)
+#ifndef _inline
+#define _inline __inline__
+#endif
+#define _pack __attribute__((packed))
+#define _unused __attribute__((unused))
+#else
+#define _inline
+#define _pack
+#define _unused __pragma(warning(suppress : 4100))
+#endif
+#ifndef __cplusplus
+#define _register register
+#else
+#define _register
+#endif
+
+#if _MSC_VER > 1920 && !defined(__clang__)
+#    pragma warning(push)
+#    pragma warning(disable : 4100 4127 4189 4505 4244 4403  4701 4703)
+#    if (_MSC_VER > 1800 )
+#        pragma warning(disable : 5573 5744)
+#    endif
+#endif // _MSC_VER
+
+/*** File format structures ***/
+
+/**
+ * M3D file format structure
+ *  3DMO m3dchunk_t file header chunk, may followed by compressed data
+ *  HEAD m3dhdr_t model header chunk
+ *  n x m3dchunk_t more chunks follow
+ *      PRVW preview chunk (optional)
+ *      CMAP color map chunk (optional)
+ *      TMAP texture map chunk (optional)
+ *      VRTS vertex data chunk (optional if it's a material library)
+ *      BONE bind-pose skeleton, bone hierarchy chunk (optional)
+ *          n x m3db_t contains probably more, but at least one bone
+ *          n x m3ds_t skin group records
+ *      MTRL* material chunk(s), can be more (optional)
+ *          n x m3dp_t each material contains propapbly more, but at least one property
+ *                     the properties are configurable with a static array, see m3d_propertytypes
+ *      n x m3dchunk_t at least one, but maybe more face chunks
+ *          PROC* procedural face, or
+ *          MESH* triangle mesh (vertex index list) or
+ *          SHPE* mathematical shapes like parameterized surfaces
+ *      LBLS* annotation label chunks, can be more (optional)
+ *      ACTN* action chunk(s), animation-pose skeletons, can be more (optional)
+ *          n x m3dfr_t each action contains probably more, but at least one frame
+ *              n x m3dtr_t each frame contains probably more, but at least one transformation
+ *      ASET* inlined asset chunk(s), can be more (optional)
+ *  OMD3 end chunk
+ *
+ * Typical chunks for a game engine: 3DMO, HEAD, CMAP, TMAP, VRTS, BONE, MTRL, MESH, ACTN, OMD3
+ * Typical chunks for CAD software:  3DMO, HEAD, PRVW, CMAP, TMAP, VRTS, MTRL, SHPE, LBLS, OMD3
+ */
+#ifdef _MSC_VER
+#pragma pack(push)
+#pragma pack(1)
+#endif
+
+typedef struct {
+    char magic[4];
+    uint32_t length;
+    float scale; /* deliberately not M3D_FLOAT */
+    uint32_t types;
+} _pack m3dhdr_t;
+
+typedef struct {
+    char magic[4];
+    uint32_t length;
+} _pack m3dchunk_t;
+
+#ifdef _MSC_VER
+#pragma pack(pop)
+#endif
+
+/*** in-memory model structure ***/
+
+/* textmap entry */
+typedef struct {
+    M3D_FLOAT u;
+    M3D_FLOAT v;
+} m3dti_t;
+#define m3d_textureindex_t m3dti_t
+
+/* texture */
+typedef struct {
+    char *name; /* texture name */
+    uint8_t *d; /* pixels data */
+    uint16_t w; /* width */
+    uint16_t h; /* height */
+    uint8_t f; /* format, 1 = grayscale, 2 = grayscale+alpha, 3 = rgb, 4 = rgba */
+} m3dtx_t;
+#define m3d_texturedata_t m3dtx_t
+
+typedef struct {
+    M3D_INDEX vertexid;
+    M3D_FLOAT weight;
+} m3dw_t;
+#define m3d_weight_t m3dw_t
+
+/* bone entry */
+typedef struct {
+    M3D_INDEX parent; /* parent bone index */
+    char *name; /* name for this bone */
+    M3D_INDEX pos; /* vertex index position */
+    M3D_INDEX ori; /* vertex index orientation (quaternion) */
+    M3D_INDEX numweight; /* number of controlled vertices */
+    m3dw_t *weight; /* weights for those vertices */
+    M3D_FLOAT mat4[16]; /* transformation matrix */
+} m3db_t;
+#define m3d_bone_t m3db_t
+
+/* skin: bone per vertex entry */
+typedef struct {
+    M3D_INDEX boneid[M3D_NUMBONE];
+    M3D_FLOAT weight[M3D_NUMBONE];
+} m3ds_t;
+#define m3d_skin_t m3ds_t
+
+/* vertex entry */
+typedef struct {
+    M3D_FLOAT x; /* 3D coordinates and weight */
+    M3D_FLOAT y;
+    M3D_FLOAT z;
+    M3D_FLOAT w;
+    uint32_t color; /* default vertex color */
+    M3D_INDEX skinid; /* skin index */
+#ifdef M3D_VERTEXTYPE
+    uint8_t type;
+#endif
+} m3dv_t;
+#define m3d_vertex_t m3dv_t
+
+/* material property formats */
+enum {
+    m3dpf_color,
+    m3dpf_uint8,
+    m3dpf_uint16,
+    m3dpf_uint32,
+    m3dpf_float,
+    m3dpf_map
+};
+typedef struct {
+    uint8_t format;
+    uint8_t id;
+#define M3D_PROPERTYDEF(f, i, n) \
+    { (f), (i), (char *)(n) }
+    char *key;
+} m3dpd_t;
+
+/* material property types */
+/* You shouldn't change the first 8 display and first 4 physical property. Assign the rest as you like. */
+enum {
+    m3dp_Kd = 0, /* scalar display properties */
+    m3dp_Ka,
+    m3dp_Ks,
+    m3dp_Ns,
+    m3dp_Ke,
+    m3dp_Tf,
+    m3dp_Km,
+    m3dp_d,
+    m3dp_il,
+
+    m3dp_Pr = 64, /* scalar physical properties */
+    m3dp_Pm,
+    m3dp_Ps,
+    m3dp_Ni,
+    m3dp_Nt,
+
+    m3dp_map_Kd = 128, /* textured display map properties */
+    m3dp_map_Ka,
+    m3dp_map_Ks,
+    m3dp_map_Ns,
+    m3dp_map_Ke,
+    m3dp_map_Tf,
+    m3dp_map_Km, /* bump map */
+    m3dp_map_D,
+    m3dp_map_N, /* normal map */
+
+    m3dp_map_Pr = 192, /* textured physical map properties */
+    m3dp_map_Pm,
+    m3dp_map_Ps,
+    m3dp_map_Ni,
+    m3dp_map_Nt
+};
+enum { /* aliases */
+    m3dp_bump = m3dp_map_Km,
+    m3dp_map_il = m3dp_map_N,
+    m3dp_refl = m3dp_map_Pm
+};
+
+/* material property */
+typedef struct {
+    uint8_t type; /* property type, see "m3dp_*" enumeration */
+    union {
+        uint32_t color; /* if value is a color, m3dpf_color */
+        uint32_t num; /* if value is a number, m3dpf_uint8, m3pf_uint16, m3dpf_uint32 */
+        float fnum; /* if value is a floating point number, m3dpf_float */
+        M3D_INDEX textureid; /* if value is a texture, m3dpf_map */
+    } value;
+} m3dp_t;
+#define m3d_property_t m3dp_t
+
+/* material entry */
+typedef struct {
+    char *name; /* name of the material */
+    uint8_t numprop; /* number of properties */
+    m3dp_t *prop; /* properties array */
+} m3dm_t;
+#define m3d_material_t m3dm_t
+
+/* face entry */
+typedef struct {
+    M3D_INDEX materialid; /* material index */
+    M3D_INDEX vertex[3]; /* 3D points of the triangle in CCW order */
+    M3D_INDEX normal[3]; /* normal vectors */
+    M3D_INDEX texcoord[3]; /* UV coordinates */
+} m3df_t;
+#define m3d_face_t m3df_t
+
+/* shape command types. must match the row in m3d_commandtypes */
+enum {
+    /* special commands */
+    m3dc_use = 0, /* use material */
+    m3dc_inc, /* include another shape */
+    m3dc_mesh, /* include part of polygon mesh */
+    /* approximations */
+    m3dc_div, /* subdivision by constant resolution for both u, v */
+    m3dc_sub, /* subdivision by constant, different for u and v */
+    m3dc_len, /* spacial subdivision by maxlength */
+    m3dc_dist, /* subdivision by maxdistance and maxangle */
+    /* modifiers */
+    m3dc_degu, /* degree for both u, v */
+    m3dc_deg, /* separate degree for u and v */
+    m3dc_rangeu, /* range for u */
+    m3dc_range, /* range for u and v */
+    m3dc_paru, /* u parameters (knots) */
+    m3dc_parv, /* v parameters */
+    m3dc_trim, /* outer trimming curve */
+    m3dc_hole, /* inner trimming curve */
+    m3dc_scrv, /* spacial curve */
+    m3dc_sp, /* special points */
+    /* helper curves */
+    m3dc_bez1, /* Bezier 1D */
+    m3dc_bsp1, /* B-spline 1D */
+    m3dc_bez2, /* bezier 2D */
+    m3dc_bsp2, /* B-spline 2D */
+    /* surfaces */
+    m3dc_bezun, /* Bezier 3D with control, UV, normal */
+    m3dc_bezu, /* with control and UV */
+    m3dc_bezn, /* with control and normal */
+    m3dc_bez, /* control points only */
+    m3dc_nurbsun, /* B-spline 3D */
+    m3dc_nurbsu,
+    m3dc_nurbsn,
+    m3dc_nurbs,
+    m3dc_conn, /* connect surfaces */
+    /* geometrical */
+    m3dc_line,
+    m3dc_polygon,
+    m3dc_circle,
+    m3dc_cylinder,
+    m3dc_shpere,
+    m3dc_torus,
+    m3dc_cone,
+    m3dc_cube
+};
+
+/* shape command argument types */
+enum {
+    m3dcp_mi_t = 1, /* material index */
+    m3dcp_hi_t, /* shape index */
+    m3dcp_fi_t, /* face index */
+    m3dcp_ti_t, /* texture map index */
+    m3dcp_vi_t, /* vertex index */
+    m3dcp_qi_t, /* vertex index for quaternions */
+    m3dcp_vc_t, /* coordinate or radius, float scalar */
+    m3dcp_i1_t, /* int8 scalar */
+    m3dcp_i2_t, /* int16 scalar */
+    m3dcp_i4_t, /* int32 scalar */
+    m3dcp_va_t /* variadic arguments */
+};
+
+#define M3D_CMDMAXARG 8 /* if you increase this, add more arguments to the macro below */
+typedef struct {
+#define M3D_CMDDEF(t, n, p, a, b, c, d, e, f, g, h)                  \
+    {                                                                \
+        (char *)(n), (p), { (a), (b), (c), (d), (e), (f), (g), (h) } \
+    }
+    char *key;
+    uint8_t p;
+    uint8_t a[M3D_CMDMAXARG];
+} m3dcd_t;
+
+/* shape command */
+typedef struct {
+    uint16_t type; /* shape type */
+    uint32_t *arg; /* arguments array */
+} m3dc_t;
+#define m3d_shapecommand_t m3dc_t
+
+/* shape entry */
+typedef struct {
+    char *name; /* name of the mathematical shape */
+    M3D_INDEX group; /* group this shape belongs to or -1 */
+    uint32_t numcmd; /* number of commands */
+    m3dc_t *cmd; /* commands array */
+} m3dh_t;
+#define m3d_shape_t m3dh_t
+
+/* label entry */
+typedef struct {
+    char *name; /* name of the annotation layer or NULL */
+    char *lang; /* language code or NULL */
+    char *text; /* the label text */
+    uint32_t color; /* color */
+    M3D_INDEX vertexid; /* the vertex the label refers to */
+} m3dl_t;
+#define m3d_label_t m3dl_t
+
+/* frame transformations / working copy skeleton entry */
+typedef struct {
+    M3D_INDEX boneid; /* selects a node in bone hierarchy */
+    M3D_INDEX pos; /* vertex index new position */
+    M3D_INDEX ori; /* vertex index new orientation (quaternion) */
+} m3dtr_t;
+#define m3d_transform_t m3dtr_t
+
+/* animation frame entry */
+typedef struct {
+    uint32_t msec; /* frame's position on the timeline, timestamp */
+    M3D_INDEX numtransform; /* number of transformations in this frame */
+    m3dtr_t *transform; /* transformations */
+} m3dfr_t;
+#define m3d_frame_t m3dfr_t
+
+/* model action entry */
+typedef struct {
+    char *name; /* name of the action */
+    uint32_t durationmsec; /* duration in millisec (1/1000 sec) */
+    M3D_INDEX numframe; /* number of frames in this animation */
+    m3dfr_t *frame; /* frames array */
+} m3da_t;
+#define m3d_action_t m3da_t
+
+/* inlined asset */
+typedef struct {
+    char *name; /* asset name (same pointer as in texture[].name) */
+    uint8_t *data; /* compressed asset data */
+    uint32_t length; /* compressed data length */
+} m3di_t;
+#define m3d_inlinedasset_t m3di_t
+
+/*** in-memory model structure ***/
+#define M3D_FLG_FREERAW (1 << 0)
+#define M3D_FLG_FREESTR (1 << 1)
+#define M3D_FLG_MTLLIB (1 << 2)
+#define M3D_FLG_GENNORM (1 << 3)
+
+typedef struct {
+    m3dhdr_t *raw; /* pointer to raw data */
+    char flags; /* internal flags */
+    signed char errcode; /* returned error code */
+    char vc_s, vi_s, si_s, ci_s, ti_s, bi_s, nb_s, sk_s, fc_s, hi_s, fi_s; /* decoded sizes for types */
+    char *name; /* name of the model, like "Utah teapot" */
+    char *license; /* usage condition or license, like "MIT", "LGPL" or "BSD-3clause" */
+    char *author; /* nickname, email, homepage or github URL etc. */
+    char *desc; /* comments, descriptions. May contain '\n' newline character */
+    M3D_FLOAT scale; /* the model's bounding cube's size in SI meters */
+    M3D_INDEX numcmap;
+    uint32_t *cmap; /* color map */
+    M3D_INDEX numtmap;
+    m3dti_t *tmap; /* texture map indices */
+    M3D_INDEX numtexture;
+    m3dtx_t *texture; /* uncompressed textures */
+    M3D_INDEX numbone;
+    m3db_t *bone; /* bone hierarchy */
+    M3D_INDEX numvertex;
+    m3dv_t *vertex; /* vertex data */
+    M3D_INDEX numskin;
+    m3ds_t *skin; /* skin data */
+    M3D_INDEX nummaterial;
+    m3dm_t *material; /* material list */
+    M3D_INDEX numface;
+    m3df_t *face; /* model face, polygon (triangle) mesh */
+    M3D_INDEX numshape;
+    m3dh_t *shape; /* model face, shape commands */
+    M3D_INDEX numlabel;
+    m3dl_t *label; /* annotation labels */
+    M3D_INDEX numaction;
+    m3da_t *action; /* action animations */
+    M3D_INDEX numinlined;
+    m3di_t *inlined; /* inlined assets */
+    M3D_INDEX numextra;
+    m3dchunk_t **extra; /* unknown chunks, application / engine specific data probably */
+    m3di_t preview; /* preview chunk */
+} m3d_t;
+
+/*** export parameters ***/
+#define M3D_EXP_INT8 0
+#define M3D_EXP_INT16 1
+#define M3D_EXP_FLOAT 2
+#define M3D_EXP_DOUBLE 3
+
+#define M3D_EXP_NOCMAP (1 << 0)
+#define M3D_EXP_NOMATERIAL (1 << 1)
+#define M3D_EXP_NOFACE (1 << 2)
+#define M3D_EXP_NONORMAL (1 << 3)
+#define M3D_EXP_NOTXTCRD (1 << 4)
+#define M3D_EXP_FLIPTXTCRD (1 << 5)
+#define M3D_EXP_NORECALC (1 << 6)
+#define M3D_EXP_IDOSUCK (1 << 7)
+#define M3D_EXP_NOBONE (1 << 8)
+#define M3D_EXP_NOACTION (1 << 9)
+#define M3D_EXP_INLINE (1 << 10)
+#define M3D_EXP_EXTRA (1 << 11)
+#define M3D_EXP_NOZLIB (1 << 14)
+#define M3D_EXP_ASCII (1 << 15)
+
+/*** error codes ***/
+#define M3D_SUCCESS 0
+#define M3D_ERR_ALLOC -1
+#define M3D_ERR_BADFILE -2
+#define M3D_ERR_UNIMPL -65
+#define M3D_ERR_UNKPROP -66
+#define M3D_ERR_UNKMESH -67
+#define M3D_ERR_UNKIMG -68
+#define M3D_ERR_UNKFRAME -69
+#define M3D_ERR_UNKCMD -70
+#define M3D_ERR_TRUNC -71
+#define M3D_ERR_CMAP -72
+#define M3D_ERR_TMAP -73
+#define M3D_ERR_VRTS -74
+#define M3D_ERR_BONE -75
+#define M3D_ERR_MTRL -76
+#define M3D_ERR_SHPE -77
+
+#define M3D_ERR_ISFATAL(x) ((x) < 0 && (x) > -65)
+
+/* callbacks */
+typedef unsigned char *(*m3dread_t)(char *filename, unsigned int *size); /* read file contents into buffer */
+typedef void (*m3dfree_t)(void *buffer); /* free file contents buffer */
+typedef int (*m3dtxsc_t)(const char *name, const void *script, uint32_t len, m3dtx_t *output); /* interpret texture script */
+typedef int (*m3dprsc_t)(const char *name, const void *script, uint32_t len, m3d_t *model); /* interpret surface script */
+#endif /* ifndef M3D_APIVERSION */
+
+/*** C prototypes ***/
+/* import / export */
+m3d_t *m3d_load(unsigned char *data, m3dread_t readfilecb, m3dfree_t freecb, m3d_t *mtllib);
+unsigned char *m3d_save(m3d_t *model, int quality, int flags, unsigned int *size);
+void m3d_free(m3d_t *model);
+/* generate animation pose skeleton */
+m3dtr_t *m3d_frame(m3d_t *model, M3D_INDEX actionid, M3D_INDEX frameid, m3dtr_t *skeleton);
+m3db_t *m3d_pose(m3d_t *model, M3D_INDEX actionid, uint32_t msec);
+
+/* private prototypes used by both importer and exporter */
+char *_m3d_safestr(char *in, int morelines);
+
+/*** C implementation ***/
+#ifdef M3D_IMPLEMENTATION
+#if !defined(M3D_NOIMPORTER) || defined(M3D_EXPORTER)
+/* material property definitions */
+static m3dpd_t m3d_propertytypes[] = {
+    M3D_PROPERTYDEF(m3dpf_color, m3dp_Kd, "Kd"), /* diffuse color */
+    M3D_PROPERTYDEF(m3dpf_color, m3dp_Ka, "Ka"), /* ambient color */
+    M3D_PROPERTYDEF(m3dpf_color, m3dp_Ks, "Ks"), /* specular color */
+    M3D_PROPERTYDEF(m3dpf_float, m3dp_Ns, "Ns"), /* specular exponent */
+    M3D_PROPERTYDEF(m3dpf_color, m3dp_Ke, "Ke"), /* emissive (emitting light of this color) */
+    M3D_PROPERTYDEF(m3dpf_color, m3dp_Tf, "Tf"), /* transmission color */
+    M3D_PROPERTYDEF(m3dpf_float, m3dp_Km, "Km"), /* bump strength */
+    M3D_PROPERTYDEF(m3dpf_float, m3dp_d, "d"), /* dissolve (transparency) */
+    M3D_PROPERTYDEF(m3dpf_uint8, m3dp_il, "il"), /* illumination model (informational, ignored by PBR-shaders) */
+
+    M3D_PROPERTYDEF(m3dpf_float, m3dp_Pr, "Pr"), /* roughness */
+    M3D_PROPERTYDEF(m3dpf_float, m3dp_Pm, "Pm"), /* metallic, also reflection */
+    M3D_PROPERTYDEF(m3dpf_float, m3dp_Ps, "Ps"), /* sheen */
+    M3D_PROPERTYDEF(m3dpf_float, m3dp_Ni, "Ni"), /* index of refraction (optical density) */
+    M3D_PROPERTYDEF(m3dpf_float, m3dp_Nt, "Nt"), /* thickness of face in millimeter, for printing */
+
+    /* aliases, note that "map_*" aliases are handled automatically */
+    M3D_PROPERTYDEF(m3dpf_map, m3dp_map_Km, "bump"),
+    M3D_PROPERTYDEF(m3dpf_map, m3dp_map_N, "map_N"), /* as normal map has no scalar version, it's counterpart is 'il' */
+    M3D_PROPERTYDEF(m3dpf_map, m3dp_map_Pm, "refl")
+};
+/* shape command definitions. if more commands start with the same string, the longer must come first */
+static m3dcd_t m3d_commandtypes[] = {
+    /* technical */
+    M3D_CMDDEF(m3dc_use, "use", 1, m3dcp_mi_t, 0, 0, 0, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_inc, "inc", 3, m3dcp_hi_t, m3dcp_vi_t, m3dcp_qi_t, m3dcp_vi_t, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_mesh, "mesh", 1, m3dcp_fi_t, m3dcp_fi_t, m3dcp_vi_t, m3dcp_qi_t, m3dcp_vi_t, 0, 0, 0),
+    /* approximations */
+    M3D_CMDDEF(m3dc_div, "div", 1, m3dcp_vc_t, 0, 0, 0, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_sub, "sub", 2, m3dcp_vc_t, m3dcp_vc_t, 0, 0, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_len, "len", 1, m3dcp_vc_t, 0, 0, 0, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_dist, "dist", 2, m3dcp_vc_t, m3dcp_vc_t, 0, 0, 0, 0, 0, 0),
+    /* modifiers */
+    M3D_CMDDEF(m3dc_degu, "degu", 1, m3dcp_i1_t, 0, 0, 0, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_deg, "deg", 2, m3dcp_i1_t, m3dcp_i1_t, 0, 0, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_rangeu, "rangeu", 1, m3dcp_ti_t, 0, 0, 0, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_range, "range", 2, m3dcp_ti_t, m3dcp_ti_t, 0, 0, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_paru, "paru", 2, m3dcp_va_t, m3dcp_vc_t, 0, 0, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_parv, "parv", 2, m3dcp_va_t, m3dcp_vc_t, 0, 0, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_trim, "trim", 3, m3dcp_va_t, m3dcp_ti_t, m3dcp_i2_t, 0, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_hole, "hole", 3, m3dcp_va_t, m3dcp_ti_t, m3dcp_i2_t, 0, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_scrv, "scrv", 3, m3dcp_va_t, m3dcp_ti_t, m3dcp_i2_t, 0, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_sp, "sp", 2, m3dcp_va_t, m3dcp_vi_t, 0, 0, 0, 0, 0, 0),
+    /* helper curves */
+    M3D_CMDDEF(m3dc_bez1, "bez1", 2, m3dcp_va_t, m3dcp_vi_t, 0, 0, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_bsp1, "bsp1", 2, m3dcp_va_t, m3dcp_vi_t, 0, 0, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_bez2, "bez2", 2, m3dcp_va_t, m3dcp_vi_t, 0, 0, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_bsp2, "bsp2", 2, m3dcp_va_t, m3dcp_vi_t, 0, 0, 0, 0, 0, 0),
+    /* surfaces */
+    M3D_CMDDEF(m3dc_bezun, "bezun", 4, m3dcp_va_t, m3dcp_vi_t, m3dcp_ti_t, m3dcp_vi_t, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_bezu, "bezu", 3, m3dcp_va_t, m3dcp_vi_t, m3dcp_ti_t, 0, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_bezn, "bezn", 3, m3dcp_va_t, m3dcp_vi_t, m3dcp_vi_t, 0, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_bez, "bez", 2, m3dcp_va_t, m3dcp_vi_t, 0, 0, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_nurbsun, "nurbsun", 4, m3dcp_va_t, m3dcp_vi_t, m3dcp_ti_t, m3dcp_vi_t, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_nurbsu, "nurbsu", 3, m3dcp_va_t, m3dcp_vi_t, m3dcp_ti_t, 0, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_nurbsn, "nurbsn", 3, m3dcp_va_t, m3dcp_vi_t, m3dcp_vi_t, 0, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_nurbs, "nurbs", 2, m3dcp_va_t, m3dcp_vi_t, 0, 0, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_conn, "conn", 6, m3dcp_i2_t, m3dcp_ti_t, m3dcp_i2_t, m3dcp_i2_t, m3dcp_ti_t, m3dcp_i2_t, 0, 0),
+    /* geometrical */
+    M3D_CMDDEF(m3dc_line, "line", 2, m3dcp_va_t, m3dcp_vi_t, 0, 0, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_polygon, "polygon", 2, m3dcp_va_t, m3dcp_vi_t, 0, 0, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_circle, "circle", 3, m3dcp_vi_t, m3dcp_qi_t, m3dcp_vc_t, 0, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_cylinder, "cylinder", 6, m3dcp_vi_t, m3dcp_qi_t, m3dcp_vc_t, m3dcp_vi_t, m3dcp_qi_t, m3dcp_vc_t, 0, 0),
+    M3D_CMDDEF(m3dc_shpere, "shpere", 2, m3dcp_vi_t, m3dcp_vc_t, 0, 0, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_torus, "torus", 4, m3dcp_vi_t, m3dcp_qi_t, m3dcp_vc_t, m3dcp_vc_t, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_cone, "cone", 3, m3dcp_vi_t, m3dcp_vi_t, m3dcp_vi_t, 0, 0, 0, 0, 0),
+    M3D_CMDDEF(m3dc_cube, "cube", 3, m3dcp_vi_t, m3dcp_vi_t, m3dcp_vi_t, 0, 0, 0, 0, 0)
+};
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(M3D_EXPORTER) && !defined(INCLUDE_STB_IMAGE_WRITE_H)
+/* zlib_compressor from
+
+   stb_image_write - v1.13 - public domain - http://nothings.org/stb/stb_image_write.h
+*/
+typedef unsigned char _m3dstbiw__uc;
+typedef unsigned short _m3dstbiw__us;
+
+typedef uint16_t _m3dstbiw__uint16;
+typedef int16_t _m3dstbiw__int16;
+typedef uint32_t _m3dstbiw__uint32;
+typedef int32_t _m3dstbiw__int32;
+
+#define STBIW_MALLOC(s) M3D_MALLOC(s)
+#define STBIW_REALLOC(p, ns) M3D_REALLOC(p, ns)
+#define STBIW_REALLOC_SIZED(p, oldsz, newsz) STBIW_REALLOC(p, newsz)
+#define STBIW_FREE M3D_FREE
+#define STBIW_MEMMOVE memmove
+#define STBIW_UCHAR (uint8_t)
+#define STBIW_ASSERT(x)
+#define _m3dstbiw___sbraw(a) ((int *)(a)-2)
+#define _m3dstbiw___sbm(a) _m3dstbiw___sbraw(a)[0]
+#define _m3dstbiw___sbn(a) _m3dstbiw___sbraw(a)[1]
+
+#define _m3dstbiw___sbneedgrow(a, n) ((a) == 0 || _m3dstbiw___sbn(a) + n >= _m3dstbiw___sbm(a))
+#define _m3dstbiw___sbmaybegrow(a, n) (_m3dstbiw___sbneedgrow(a, (n)) ? _m3dstbiw___sbgrow(a, n) : 0)
+#define _m3dstbiw___sbgrow(a, n) _m3dstbiw___sbgrowf((void **)&(a), (n), sizeof(*(a)))
+
+#define _m3dstbiw___sbpush(a, v) (_m3dstbiw___sbmaybegrow(a, 1), (a)[_m3dstbiw___sbn(a)++] = (v))
+#define _m3dstbiw___sbcount(a) ((a) ? _m3dstbiw___sbn(a) : 0)
+#define _m3dstbiw___sbfree(a) ((a) ? STBIW_FREE(_m3dstbiw___sbraw(a)), 0 : 0)
+
+static void *_m3dstbiw___sbgrowf(void **arr, int increment, int itemsize) {
+    int m = *arr ? 2 * _m3dstbiw___sbm(*arr) + increment : increment + 1;
+    void *p = STBIW_REALLOC_SIZED(*arr ? _m3dstbiw___sbraw(*arr) : 0, *arr ? (_m3dstbiw___sbm(*arr) * itemsize + sizeof(int) * 2) : 0, itemsize * m + sizeof(int) * 2);
+    STBIW_ASSERT(p);
+    if (p) {
+        if (!*arr) ((int *)p)[1] = 0;
+        *arr = (void *)((int *)p + 2);
+        _m3dstbiw___sbm(*arr) = m;
+    }
+    return *arr;
+}
+
+static unsigned char *_m3dstbiw___zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount) {
+    while (*bitcount >= 8) {
+        _m3dstbiw___sbpush(data, STBIW_UCHAR(*bitbuffer));
+        *bitbuffer >>= 8;
+        *bitcount -= 8;
+    }
+    return data;
+}
+
+static int _m3dstbiw___zlib_bitrev(int code, int codebits) {
+    int res = 0;
+    while (codebits--) {
+        res = (res << 1) | (code & 1);
+        code >>= 1;
+    }
+    return res;
+}
+
+static unsigned int _m3dstbiw___zlib_countm(unsigned char *a, unsigned char *b, int limit) {
+    int i;
+    for (i = 0; i < limit && i < 258; ++i)
+        if (a[i] != b[i]) break;
+    return i;
+}
+
+static unsigned int _m3dstbiw___zhash(unsigned char *data) {
+    _m3dstbiw__uint32 hash = data[0] + (data[1] << 8) + (data[2] << 16);
+    hash ^= hash << 3;
+    hash += hash >> 5;
+    hash ^= hash << 4;
+    hash += hash >> 17;
+    hash ^= hash << 25;
+    hash += hash >> 6;
+    return hash;
+}
+
+#define _m3dstbiw___zlib_flush() (out = _m3dstbiw___zlib_flushf(out, &bitbuf, &bitcount))
+#define _m3dstbiw___zlib_add(code, codebits) \
+    (bitbuf |= (code) << bitcount, bitcount += (codebits), _m3dstbiw___zlib_flush())
+#define _m3dstbiw___zlib_huffa(b, c) _m3dstbiw___zlib_add(_m3dstbiw___zlib_bitrev(b, c), c)
+#define _m3dstbiw___zlib_huff1(n) _m3dstbiw___zlib_huffa(0x30 + (n), 8)
+#define _m3dstbiw___zlib_huff2(n) _m3dstbiw___zlib_huffa(0x190 + (n)-144, 9)
+#define _m3dstbiw___zlib_huff3(n) _m3dstbiw___zlib_huffa(0 + (n)-256, 7)
+#define _m3dstbiw___zlib_huff4(n) _m3dstbiw___zlib_huffa(0xc0 + (n)-280, 8)
+#define _m3dstbiw___zlib_huff(n) ((n) <= 143 ? _m3dstbiw___zlib_huff1(n) : (n) <= 255 ? _m3dstbiw___zlib_huff2(n) : (n) <= 279 ? _m3dstbiw___zlib_huff3(n) : _m3dstbiw___zlib_huff4(n))
+#define _m3dstbiw___zlib_huffb(n) ((n) <= 143 ? _m3dstbiw___zlib_huff1(n) : _m3dstbiw___zlib_huff2(n))
+
+#define _m3dstbiw___ZHASH 16384
+
+unsigned char *_m3dstbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality) {
+    static unsigned short lengthc[] = { 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 259 };
+    static unsigned char lengtheb[] = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0 };
+    static unsigned short distc[] = { 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 32768 };
+    static unsigned char disteb[] = { 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13 };
+    unsigned int bitbuf = 0;
+    int i, j, bitcount = 0;
+    unsigned char *out = NULL;
+    unsigned char ***hash_table = (unsigned char ***)STBIW_MALLOC(_m3dstbiw___ZHASH * sizeof(char **));
+    if (hash_table == NULL)
+        return NULL;
+    if (quality < 5) quality = 5;
+
+    _m3dstbiw___sbpush(out, 0x78);
+    _m3dstbiw___sbpush(out, 0x5e);
+    _m3dstbiw___zlib_add(1, 1);
+    _m3dstbiw___zlib_add(1, 2);
+
+    for (i = 0; i < _m3dstbiw___ZHASH; ++i)
+        hash_table[i] = NULL;
+
+    i = 0;
+    while (i < data_len - 3) {
+        int h = _m3dstbiw___zhash(data + i) & (_m3dstbiw___ZHASH - 1), best = 3;
+        unsigned char *bestloc = 0;
+        unsigned char **hlist = hash_table[h];
+        int n = _m3dstbiw___sbcount(hlist);
+        for (j = 0; j < n; ++j) {
+            if (hlist[j] - data > i - 32768) {
+                int d = _m3dstbiw___zlib_countm(hlist[j], data + i, data_len - i);
+                if (d >= best) best = d, bestloc = hlist[j];
+            }
+        }
+        if (hash_table[h] && _m3dstbiw___sbn(hash_table[h]) == 2 * quality) {
+            STBIW_MEMMOVE(hash_table[h], hash_table[h] + quality, sizeof(hash_table[h][0]) * quality);
+            _m3dstbiw___sbn(hash_table[h]) = quality;
+        }
+        _m3dstbiw___sbpush(hash_table[h], data + i);
+
+        if (bestloc) {
+            h = _m3dstbiw___zhash(data + i + 1) & (_m3dstbiw___ZHASH - 1);
+            hlist = hash_table[h];
+            n = _m3dstbiw___sbcount(hlist);
+            for (j = 0; j < n; ++j) {
+                if (hlist[j] - data > i - 32767) {
+                    int e = _m3dstbiw___zlib_countm(hlist[j], data + i + 1, data_len - i - 1);
+                    if (e > best) {
+                        bestloc = NULL;
+                        break;
+                    }
+                }
+            }
+        }
+
+        if (bestloc) {
+            int d = (int)(data + i - bestloc);
+            STBIW_ASSERT(d <= 32767 && best <= 258);
+            for (j = 0; best > lengthc[j + 1] - 1; ++j)
+                ;
+            _m3dstbiw___zlib_huff(j + 257);
+            if (lengtheb[j]) _m3dstbiw___zlib_add(best - lengthc[j], lengtheb[j]);
+            for (j = 0; d > distc[j + 1] - 1; ++j)
+                ;
+            _m3dstbiw___zlib_add(_m3dstbiw___zlib_bitrev(j, 5), 5);
+            if (disteb[j]) _m3dstbiw___zlib_add(d - distc[j], disteb[j]);
+            i += best;
+        } else {
+            _m3dstbiw___zlib_huffb(data[i]);
+            ++i;
+        }
+    }
+    for (; i < data_len; ++i)
+        _m3dstbiw___zlib_huffb(data[i]);
+    _m3dstbiw___zlib_huff(256);
+    while (bitcount)
+        _m3dstbiw___zlib_add(0, 1);
+
+    for (i = 0; i < _m3dstbiw___ZHASH; ++i)
+        (void)_m3dstbiw___sbfree(hash_table[i]);
+    STBIW_FREE(hash_table);
+
+    {
+        unsigned int s1 = 1, s2 = 0;
+        int blocklen = (int)(data_len % 5552);
+        j = 0;
+        while (j < data_len) {
+            for (i = 0; i < blocklen; ++i)
+                s1 += data[j + i], s2 += s1;
+            s1 %= 65521, s2 %= 65521;
+            j += blocklen;
+            blocklen = 5552;
+        }
+        _m3dstbiw___sbpush(out, STBIW_UCHAR(s2 >> 8));
+        _m3dstbiw___sbpush(out, STBIW_UCHAR(s2));
+        _m3dstbiw___sbpush(out, STBIW_UCHAR(s1 >> 8));
+        _m3dstbiw___sbpush(out, STBIW_UCHAR(s1));
+    }
+    *out_len = _m3dstbiw___sbn(out);
+    STBIW_MEMMOVE(_m3dstbiw___sbraw(out), out, *out_len);
+    return (unsigned char *)_m3dstbiw___sbraw(out);
+}
+#define stbi_zlib_compress _m3dstbi_zlib_compress
+#else
+unsigned char *_m3dstbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality);
+#endif
+
+#define M3D_CHUNKMAGIC(m, a, b, c, d) ((m)[0] == (a) && (m)[1] == (b) && (m)[2] == (c) && (m)[3] == (d))
+
+#include <locale.h> /* sprintf and strtod cares about number locale */
+#include <stdio.h> /* get sprintf */
+#ifdef M3D_PROFILING
+#include <sys/time.h>
+#endif
+
+#if !defined(M3D_NOIMPORTER)
+/* helper functions for the ASCII parser */
+static char *_m3d_findarg(char *s) {
+    while (s && *s && *s != ' ' && *s != '\t' && *s != '\r' && *s != '\n')
+        s++;
+    while (s && *s && (*s == ' ' || *s == '\t'))
+        s++;
+    return s;
+}
+static char *_m3d_findnl(char *s) {
+    while (s && *s && *s != '\r' && *s != '\n')
+        s++;
+    if (*s == '\r') s++;
+    if (*s == '\n') s++;
+    return s;
+}
+static char *_m3d_gethex(char *s, uint32_t *ret) {
+    if (*s == '#') s++;
+    *ret = 0;
+    for (; *s; s++) {
+        if (*s >= '0' && *s <= '9') {
+            *ret <<= 4;
+            *ret += (uint32_t)(*s - '0');
+        } else if (*s >= 'a' && *s <= 'f') {
+            *ret <<= 4;
+            *ret += (uint32_t)(*s - 'a' + 10);
+        } else if (*s >= 'A' && *s <= 'F') {
+            *ret <<= 4;
+            *ret += (uint32_t)(*s - 'A' + 10);
+        } else
+            break;
+    }
+    return _m3d_findarg(s);
+}
+static char *_m3d_getint(char *s, uint32_t *ret) {
+    char *e = s;
+    if (!s || !*s || *s == '\r' || *s == '\n') return s;
+    for (; *e >= '0' && *e <= '9'; e++)
+        ;
+    *ret = atoi(s);
+    return e;
+}
+static char *_m3d_getfloat(char *s, M3D_FLOAT *ret) {
+    char *e = s;
+    if (!s || !*s || *s == '\r' || *s == '\n') return s;
+    for (; *e == '-' || *e == '+' || *e == '.' || (*e >= '0' && *e <= '9') || *e == 'e' || *e == 'E'; e++)
+        ;
+    *ret = (M3D_FLOAT)strtod(s, NULL);
+    return _m3d_findarg(e);
+}
+#endif
+#if !defined(M3D_NODUP) && (!defined(M3D_NOIMPORTER) || defined(M3D_EXPORTER))
+/* helper function to create safe strings */
+char *_m3d_safestr(char *in, int morelines) {
+    char *out, *o, *i = in;
+    int l;
+    if (!in || !*in) {
+        out = (char *)M3D_MALLOC(1);
+        if (!out) return NULL;
+        out[0] = 0;
+    } else {
+        for (o = in, l = 0; *o && ((morelines & 1) || (*o != '\r' && *o != '\n')) && l < 256; o++, l++)
+            ;
+        out = o = (char *)M3D_MALLOC(l + 1);
+        if (!out) return NULL;
+        while (*i == ' ' || *i == '\t' || *i == '\r' || (morelines && *i == '\n'))
+            i++;
+        for (; *i && (morelines || (*i != '\r' && *i != '\n')) && o - out < l; i++) {
+            if (*i == '\r') continue;
+            if (*i == '\n') {
+                if (morelines >= 3 && o > out && *(o - 1) == '\n') break;
+                if (i > in && *(i - 1) == '\n') continue;
+                if (morelines & 1) {
+                    if (morelines == 1) *o++ = '\r';
+                    *o++ = '\n';
+                } else
+                    break;
+            } else if (*i == ' ' || *i == '\t') {
+                *o++ = morelines ? ' ' : '_';
+            } else
+                *o++ = !morelines && (*i == '/' || *i == '\\') ? '_' : *i;
+        }
+        for (; o > out && (*(o - 1) == ' ' || *(o - 1) == '\t' || *(o - 1) == '\r' || *(o - 1) == '\n'); o--)
+            ;
+        *o = 0;
+        out = (char *)M3D_REALLOC(out, (uintptr_t)o - (uintptr_t)out + 1);
+    }
+    return out;
+}
+#endif
+#ifndef M3D_NOIMPORTER
+/* helper function to load and decode/generate a texture */
+M3D_INDEX _m3d_gettx(m3d_t *model, m3dread_t readfilecb, m3dfree_t freecb, char *fn) {
+    unsigned int i, len = 0;
+    unsigned char *buff = NULL;
+    char *fn2;
+#ifdef STBI__PNG_TYPE
+    unsigned int w, h;
+    stbi__context s;
+    stbi__result_info ri;
+#endif
+
+    /* do we have loaded this texture already? */
+    for (i = 0; i < model->numtexture; i++)
+        if (!strcmp(fn, model->texture[i].name)) return i;
+    /* see if it's inlined in the model */
+    if (model->inlined) {
+        for (i = 0; i < model->numinlined; i++)
+            if (!strcmp(fn, model->inlined[i].name)) {
+                buff = model->inlined[i].data;
+                len = model->inlined[i].length;
+                freecb = NULL;
+                break;
+            }
+    }
+    /* try to load from external source */
+    if (!buff && readfilecb) {
+        i = (unsigned int)strlen(fn);
+        if (i < 5 || fn[i - 4] != '.') {
+            fn2 = (char *)M3D_MALLOC(i + 5);
+            if (!fn2) {
+                model->errcode = M3D_ERR_ALLOC;
+                return M3D_UNDEF;
+            }
+            memcpy(fn2, fn, i);
+            memcpy(fn2 + i, ".png", 5);
+            buff = (*readfilecb)(fn2, &len);
+            M3D_FREE(fn2);
+        }
+        if (!buff) {
+            buff = (*readfilecb)(fn, &len);
+            if (!buff) return M3D_UNDEF;
+        }
+    }
+    /* add to textures array */
+    i = model->numtexture++;
+    model->texture = (m3dtx_t *)M3D_REALLOC(model->texture, model->numtexture * sizeof(m3dtx_t));
+    if (!model->texture) {
+        if (buff && freecb) (*freecb)(buff);
+        model->errcode = M3D_ERR_ALLOC;
+        return M3D_UNDEF;
+    }
+    model->texture[i].name = fn;
+    model->texture[i].w = model->texture[i].h = 0;
+    model->texture[i].d = NULL;
+    if (buff) {
+        if (buff[0] == 0x89 && buff[1] == 'P' && buff[2] == 'N' && buff[3] == 'G') {
+#ifdef STBI__PNG_TYPE
+            s.read_from_callbacks = 0;
+            s.img_buffer = s.img_buffer_original = (unsigned char *)buff;
+            s.img_buffer_end = s.img_buffer_original_end = (unsigned char *)buff + len;
+            /* don't use model->texture[i].w directly, it's a uint16_t */
+            w = h = len = 0;
+            ri.bits_per_channel = 8;
+            model->texture[i].d = (uint8_t *)stbi__png_load(&s, (int *)&w, (int *)&h, (int *)&len, 0, &ri);
+            model->texture[i].w = (uint16_t)w;
+            model->texture[i].h = (uint16_t)h;
+            model->texture[i].f = (uint8_t)len;
+#endif
+        } else {
+#ifdef M3D_TX_INTERP
+            if ((model->errcode = M3D_TX_INTERP(fn, buff, len, &model->texture[i])) != M3D_SUCCESS) {
+                M3D_LOG("Unable to generate texture");
+                M3D_LOG(fn);
+            }
+#else
+            M3D_LOG("Unimplemented interpreter");
+            M3D_LOG(fn);
+#endif
+        }
+        if (freecb) (*freecb)(buff);
+    }
+    if (!model->texture[i].d)
+        model->errcode = M3D_ERR_UNKIMG;
+    return i;
+}
+
+/* helper function to load and generate a procedural surface */
+void _m3d_getpr(m3d_t *model, _unused m3dread_t readfilecb, _unused m3dfree_t freecb, _unused char *fn) {
+#ifdef M3D_PR_INTERP
+    unsigned int i, len = 0;
+    unsigned char *buff = readfilecb ? (*readfilecb)(fn, &len) : NULL;
+
+    if (!buff && model->inlined) {
+        for (i = 0; i < model->numinlined; i++)
+            if (!strcmp(fn, model->inlined[i].name)) {
+                buff = model->inlined[i].data;
+                len = model->inlined[i].length;
+                freecb = NULL;
+                break;
+            }
+    }
+    if (!buff || !len || (model->errcode = M3D_PR_INTERP(fn, buff, len, model)) != M3D_SUCCESS) {
+        M3D_LOG("Unable to generate procedural surface");
+        M3D_LOG(fn);
+        model->errcode = M3D_ERR_UNKIMG;
+    }
+    if (freecb && buff) (*freecb)(buff);
+#else
+    (void)readfilecb;
+    (void)freecb;
+    (void)fn;
+    M3D_LOG("Unimplemented interpreter");
+    M3D_LOG(fn);
+    model->errcode = M3D_ERR_UNIMPL;
+#endif
+}
+/* helpers to read indices from data stream */
+#define M3D_GETSTR(x)                                       \
+    do {                                                    \
+        offs = 0;                                           \
+        data = _m3d_getidx(data, model->si_s, &offs);       \
+        x = offs ? ((char *)model->raw + 16 + offs) : NULL; \
+    } while (0)
+_inline static unsigned char *_m3d_getidx(unsigned char *data, char type, M3D_INDEX *idx) {
+    switch (type) {
+    case 1:
+        *idx = data[0] > 253 ? (int8_t)data[0] : data[0];
+        data++;
+        break;
+    case 2:
+        *idx = *((uint16_t *)data) > 65533 ? *((int16_t *)data) : *((uint16_t *)data);
+        data += 2;
+        break;
+    case 4:
+        *idx = *((int32_t *)data);
+        data += 4;
+        break;
+    }
+    return data;
+}
+
+#ifndef M3D_NOANIMATION
+/* multiply 4 x 4 matrices. Do not use float *r[16] as argument, because some compilers misinterpret that as
+ * 16 pointers each pointing to a float, but we need a single pointer to 16 floats. */
+void _m3d_mul(M3D_FLOAT *r, M3D_FLOAT *a, M3D_FLOAT *b) {
+    r[0] = b[0] * a[0] + b[4] * a[1] + b[8] * a[2] + b[12] * a[3];
+    r[1] = b[1] * a[0] + b[5] * a[1] + b[9] * a[2] + b[13] * a[3];
+    r[2] = b[2] * a[0] + b[6] * a[1] + b[10] * a[2] + b[14] * a[3];
+    r[3] = b[3] * a[0] + b[7] * a[1] + b[11] * a[2] + b[15] * a[3];
+    r[4] = b[0] * a[4] + b[4] * a[5] + b[8] * a[6] + b[12] * a[7];
+    r[5] = b[1] * a[4] + b[5] * a[5] + b[9] * a[6] + b[13] * a[7];
+    r[6] = b[2] * a[4] + b[6] * a[5] + b[10] * a[6] + b[14] * a[7];
+    r[7] = b[3] * a[4] + b[7] * a[5] + b[11] * a[6] + b[15] * a[7];
+    r[8] = b[0] * a[8] + b[4] * a[9] + b[8] * a[10] + b[12] * a[11];
+    r[9] = b[1] * a[8] + b[5] * a[9] + b[9] * a[10] + b[13] * a[11];
+    r[10] = b[2] * a[8] + b[6] * a[9] + b[10] * a[10] + b[14] * a[11];
+    r[11] = b[3] * a[8] + b[7] * a[9] + b[11] * a[10] + b[15] * a[11];
+    r[12] = b[0] * a[12] + b[4] * a[13] + b[8] * a[14] + b[12] * a[15];
+    r[13] = b[1] * a[12] + b[5] * a[13] + b[9] * a[14] + b[13] * a[15];
+    r[14] = b[2] * a[12] + b[6] * a[13] + b[10] * a[14] + b[14] * a[15];
+    r[15] = b[3] * a[12] + b[7] * a[13] + b[11] * a[14] + b[15] * a[15];
+}
+/* calculate 4 x 4 matrix inverse */
+void _m3d_inv(M3D_FLOAT *m) {
+    M3D_FLOAT r[16];
+    M3D_FLOAT det =
+            m[0] * m[5] * m[10] * m[15] - m[0] * m[5] * m[11] * m[14] + m[0] * m[6] * m[11] * m[13] - m[0] * m[6] * m[9] * m[15] + m[0] * m[7] * m[9] * m[14] - m[0] * m[7] * m[10] * m[13] - m[1] * m[6] * m[11] * m[12] + m[1] * m[6] * m[8] * m[15] - m[1] * m[7] * m[8] * m[14] + m[1] * m[7] * m[10] * m[12] - m[1] * m[4] * m[10] * m[15] + m[1] * m[4] * m[11] * m[14] + m[2] * m[7] * m[8] * m[13] - m[2] * m[7] * m[9] * m[12] + m[2] * m[4] * m[9] * m[15] - m[2] * m[4] * m[11] * m[13] + m[2] * m[5] * m[11] * m[12] - m[2] * m[5] * m[8] * m[15] - m[3] * m[4] * m[9] * m[14] + m[3] * m[4] * m[10] * m[13] - m[3] * m[5] * m[10] * m[12] + m[3] * m[5] * m[8] * m[14] - m[3] * m[6] * m[8] * m[13] + m[3] * m[6] * m[9] * m[12];
+    if (det == (M3D_FLOAT)0.0 || det == (M3D_FLOAT)-0.0)
+        det = (M3D_FLOAT)1.0;
+    else
+        det = (M3D_FLOAT)1.0 / det;
+    r[0] = det * (m[5] * (m[10] * m[15] - m[11] * m[14]) + m[6] * (m[11] * m[13] - m[9] * m[15]) + m[7] * (m[9] * m[14] - m[10] * m[13]));
+    r[1] = -det * (m[1] * (m[10] * m[15] - m[11] * m[14]) + m[2] * (m[11] * m[13] - m[9] * m[15]) + m[3] * (m[9] * m[14] - m[10] * m[13]));
+    r[2] = det * (m[1] * (m[6] * m[15] - m[7] * m[14]) + m[2] * (m[7] * m[13] - m[5] * m[15]) + m[3] * (m[5] * m[14] - m[6] * m[13]));
+    r[3] = -det * (m[1] * (m[6] * m[11] - m[7] * m[10]) + m[2] * (m[7] * m[9] - m[5] * m[11]) + m[3] * (m[5] * m[10] - m[6] * m[9]));
+    r[4] = -det * (m[4] * (m[10] * m[15] - m[11] * m[14]) + m[6] * (m[11] * m[12] - m[8] * m[15]) + m[7] * (m[8] * m[14] - m[10] * m[12]));
+    r[5] = det * (m[0] * (m[10] * m[15] - m[11] * m[14]) + m[2] * (m[11] * m[12] - m[8] * m[15]) + m[3] * (m[8] * m[14] - m[10] * m[12]));
+    r[6] = -det * (m[0] * (m[6] * m[15] - m[7] * m[14]) + m[2] * (m[7] * m[12] - m[4] * m[15]) + m[3] * (m[4] * m[14] - m[6] * m[12]));
+    r[7] = det * (m[0] * (m[6] * m[11] - m[7] * m[10]) + m[2] * (m[7] * m[8] - m[4] * m[11]) + m[3] * (m[4] * m[10] - m[6] * m[8]));
+    r[8] = det * (m[4] * (m[9] * m[15] - m[11] * m[13]) + m[5] * (m[11] * m[12] - m[8] * m[15]) + m[7] * (m[8] * m[13] - m[9] * m[12]));
+    r[9] = -det * (m[0] * (m[9] * m[15] - m[11] * m[13]) + m[1] * (m[11] * m[12] - m[8] * m[15]) + m[3] * (m[8] * m[13] - m[9] * m[12]));
+    r[10] = det * (m[0] * (m[5] * m[15] - m[7] * m[13]) + m[1] * (m[7] * m[12] - m[4] * m[15]) + m[3] * (m[4] * m[13] - m[5] * m[12]));
+    r[11] = -det * (m[0] * (m[5] * m[11] - m[7] * m[9]) + m[1] * (m[7] * m[8] - m[4] * m[11]) + m[3] * (m[4] * m[9] - m[5] * m[8]));
+    r[12] = -det * (m[4] * (m[9] * m[14] - m[10] * m[13]) + m[5] * (m[10] * m[12] - m[8] * m[14]) + m[6] * (m[8] * m[13] - m[9] * m[12]));
+    r[13] = det * (m[0] * (m[9] * m[14] - m[10] * m[13]) + m[1] * (m[10] * m[12] - m[8] * m[14]) + m[2] * (m[8] * m[13] - m[9] * m[12]));
+    r[14] = -det * (m[0] * (m[5] * m[14] - m[6] * m[13]) + m[1] * (m[6] * m[12] - m[4] * m[14]) + m[2] * (m[4] * m[13] - m[5] * m[12]));
+    r[15] = det * (m[0] * (m[5] * m[10] - m[6] * m[9]) + m[1] * (m[6] * m[8] - m[4] * m[10]) + m[2] * (m[4] * m[9] - m[5] * m[8]));
+    memcpy(m, &r, sizeof(r));
+}
+/* compose a column major 4 x 4 matrix from vec3 position and vec4 orientation/rotation quaternion */
+void _m3d_mat(M3D_FLOAT *r, m3dv_t *p, m3dv_t *q) {
+    if (q->x == (M3D_FLOAT)0.0 && q->y == (M3D_FLOAT)0.0 && q->z >= (M3D_FLOAT)0.7071065 && q->z <= (M3D_FLOAT)0.7071075 &&
+            q->w == (M3D_FLOAT)0.0) {
+        r[1] = r[2] = r[4] = r[6] = r[8] = r[9] = (M3D_FLOAT)0.0;
+        r[0] = r[5] = r[10] = (M3D_FLOAT)-1.0;
+    } else {
+        r[0] = 1 - 2 * (q->y * q->y + q->z * q->z);
+        if (r[0] > -M3D_EPSILON && r[0] < M3D_EPSILON) r[0] = (M3D_FLOAT)0.0;
+        r[1] = 2 * (q->x * q->y - q->z * q->w);
+        if (r[1] > -M3D_EPSILON && r[1] < M3D_EPSILON) r[1] = (M3D_FLOAT)0.0;
+        r[2] = 2 * (q->x * q->z + q->y * q->w);
+        if (r[2] > -M3D_EPSILON && r[2] < M3D_EPSILON) r[2] = (M3D_FLOAT)0.0;
+        r[4] = 2 * (q->x * q->y + q->z * q->w);
+        if (r[4] > -M3D_EPSILON && r[4] < M3D_EPSILON) r[4] = (M3D_FLOAT)0.0;
+        r[5] = 1 - 2 * (q->x * q->x + q->z * q->z);
+        if (r[5] > -M3D_EPSILON && r[5] < M3D_EPSILON) r[5] = (M3D_FLOAT)0.0;
+        r[6] = 2 * (q->y * q->z - q->x * q->w);
+        if (r[6] > -M3D_EPSILON && r[6] < M3D_EPSILON) r[6] = (M3D_FLOAT)0.0;
+        r[8] = 2 * (q->x * q->z - q->y * q->w);
+        if (r[8] > -M3D_EPSILON && r[8] < M3D_EPSILON) r[8] = (M3D_FLOAT)0.0;
+        r[9] = 2 * (q->y * q->z + q->x * q->w);
+        if (r[9] > -M3D_EPSILON && r[9] < M3D_EPSILON) r[9] = (M3D_FLOAT)0.0;
+        r[10] = 1 - 2 * (q->x * q->x + q->y * q->y);
+        if (r[10] > -M3D_EPSILON && r[10] < M3D_EPSILON) r[10] = (M3D_FLOAT)0.0;
+    }
+    r[3] = p->x;
+    r[7] = p->y;
+    r[11] = p->z;
+    r[12] = 0;
+    r[13] = 0;
+    r[14] = 0;
+    r[15] = 1;
+}
+#endif
+#if !defined(M3D_NOANIMATION) || !defined(M3D_NONORMALS)
+/* portable fast inverse square root calculation. returns 1/sqrt(x) */
+static M3D_FLOAT _m3d_rsq(M3D_FLOAT x) {
+#ifdef M3D_DOUBLE
+    return ((M3D_FLOAT)15.0 / (M3D_FLOAT)8.0) + ((M3D_FLOAT)-5.0 / (M3D_FLOAT)4.0) * x + ((M3D_FLOAT)3.0 / (M3D_FLOAT)8.0) * x * x;
+#else
+    /* John Carmack's */
+    float x2 = x * 0.5f;
+    *((uint32_t *)&x) = (0x5f3759df - (*((uint32_t *)&x) >> 1));
+    return x * (1.5f - (x2 * x * x));
+#endif
+}
+#endif
+
+/**
+ * Function to decode a Model 3D into in-memory format
+ */
+m3d_t *m3d_load(unsigned char *data, m3dread_t readfilecb, m3dfree_t freecb, m3d_t *mtllib) {
+    unsigned char *end, *chunk, *buff, weights[8];
+    unsigned int i, j, k, l, n, am, len = 0, reclen, offs;
+    char *name, *lang;
+    float f;
+    m3d_t *model;
+    M3D_INDEX mi;
+    M3D_FLOAT w;
+    m3dcd_t *cd;
+    m3dtx_t *tx;
+    m3dh_t *h;
+    m3dm_t *m;
+    m3da_t *a;
+    m3di_t *t;
+#ifndef M3D_NONORMALS
+    char neednorm = 0;
+    m3dv_t *norm = NULL, *v0, *v1, *v2, va, vb;
+#endif
+#ifndef M3D_NOANIMATION
+    M3D_FLOAT r[16];
+#endif
+#if !defined(M3D_NOWEIGHTS) || !defined(M3D_NOANIMATION)
+    m3db_t *b;
+#endif
+#ifndef M3D_NOWEIGHTS
+    m3ds_t *sk;
+#endif
+    m3ds_t s;
+    M3D_INDEX bi[M3D_BONEMAXLEVEL + 1], level;
+    const char *ol;
+    char *ptr, *pe, *fn;
+#ifdef M3D_PROFILING
+    struct timeval tv0, tv1, tvd;
+    gettimeofday(&tv0, NULL);
+#endif
+
+    if (!data || (!M3D_CHUNKMAGIC(data, '3', 'D', 'M', 'O')
+                         && !M3D_CHUNKMAGIC(data, '3', 'd', 'm', 'o')
+                                 ))
+        return NULL;
+    model = (m3d_t *)M3D_MALLOC(sizeof(m3d_t));
+    if (!model) {
+        M3D_LOG("Out of memory");
+        return NULL;
+    }
+    memset(model, 0, sizeof(m3d_t));
+
+    if (mtllib) {
+        model->nummaterial = mtllib->nummaterial;
+        model->material = mtllib->material;
+        model->numtexture = mtllib->numtexture;
+        model->texture = mtllib->texture;
+        model->flags |= M3D_FLG_MTLLIB;
+    }
+    /* ASCII variant? */
+    if (M3D_CHUNKMAGIC(data, '3', 'd', 'm', 'o')) {
+        model->errcode = M3D_ERR_BADFILE;
+        model->flags |= M3D_FLG_FREESTR;
+        model->raw = (m3dhdr_t *)data;
+        ptr = (char *)data;
+        ol = setlocale(LC_NUMERIC, NULL);
+        setlocale(LC_NUMERIC, "C");
+        /* parse header. Don't use sscanf, that's incredibly slow */
+        ptr = _m3d_findarg(ptr);
+        if (!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
+        pe = _m3d_findnl(ptr);
+        model->scale = (float)strtod(ptr, NULL);
+        ptr = pe;
+        if (model->scale <= (M3D_FLOAT)0.0) model->scale = (M3D_FLOAT)1.0;
+        model->name = _m3d_safestr(ptr, 2);
+        ptr = _m3d_findnl(ptr);
+        if (!*ptr) goto asciiend;
+        model->license = _m3d_safestr(ptr, 2);
+        ptr = _m3d_findnl(ptr);
+        if (!*ptr) goto asciiend;
+        model->author = _m3d_safestr(ptr, 2);
+        ptr = _m3d_findnl(ptr);
+        if (!*ptr) goto asciiend;
+        if (*ptr != '\r' && *ptr != '\n')
+            model->desc = _m3d_safestr(ptr, 3);
+        while (*ptr) {
+            while (*ptr && *ptr != '\n')
+                ptr++;
+            ptr++;
+            if (*ptr == '\r') ptr++;
+            if (*ptr == '\n') break;
+        }
+
+        /* the main chunk reader loop */
+        while (*ptr) {
+            while (*ptr && (*ptr == '\r' || *ptr == '\n'))
+                ptr++;
+            if (!*ptr || (ptr[0] == 'E' && ptr[1] == 'n' && ptr[2] == 'd')) break;
+            /* make sure there's at least one data row */
+            pe = ptr;
+            ptr = _m3d_findnl(ptr);
+            if (!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
+            /* Preview chunk */
+            if (!memcmp(pe, "Preview", 7)) {
+                if (readfilecb) {
+                    pe = _m3d_safestr(ptr, 0);
+                    if (!pe || !*pe) goto asciiend;
+                    model->preview.data = (*readfilecb)(pe, &model->preview.length);
+                    M3D_FREE(pe);
+                }
+                while (*ptr && *ptr != '\r' && *ptr != '\n')
+                    ptr = _m3d_findnl(ptr);
+            } else
+                    /* texture map chunk */
+                    if (!memcmp(pe, "Textmap", 7)) {
+                if (model->tmap) {
+                    M3D_LOG("More texture map chunks, should be unique");
+                    goto asciiend;
+                }
+                while (*ptr && *ptr != '\r' && *ptr != '\n') {
+                    i = model->numtmap++;
+                    model->tmap = (m3dti_t *)M3D_REALLOC(model->tmap, model->numtmap * sizeof(m3dti_t));
+                    if (!model->tmap) goto memerr;
+                    ptr = _m3d_getfloat(ptr, &model->tmap[i].u);
+                    if (!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
+                    _m3d_getfloat(ptr, &model->tmap[i].v);
+                    ptr = _m3d_findnl(ptr);
+                }
+            } else
+                    /* vertex chunk */
+                    if (!memcmp(pe, "Vertex", 6)) {
+                if (model->vertex) {
+                    M3D_LOG("More vertex chunks, should be unique");
+                    goto asciiend;
+                }
+                while (*ptr && *ptr != '\r' && *ptr != '\n') {
+                    i = model->numvertex++;
+                    model->vertex = (m3dv_t *)M3D_REALLOC(model->vertex, model->numvertex * sizeof(m3dv_t));
+                    if (!model->vertex) goto memerr;
+                    memset(&model->vertex[i], 0, sizeof(m3dv_t));
+                    model->vertex[i].skinid = M3D_UNDEF;
+                    model->vertex[i].color = 0;
+                    model->vertex[i].w = (M3D_FLOAT)1.0;
+                    ptr = _m3d_getfloat(ptr, &model->vertex[i].x);
+                    if (!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
+                    ptr = _m3d_getfloat(ptr, &model->vertex[i].y);
+                    if (!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
+                    ptr = _m3d_getfloat(ptr, &model->vertex[i].z);
+                    if (!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
+                    ptr = _m3d_getfloat(ptr, &model->vertex[i].w);
+                    if (!*ptr) goto asciiend;
+                    if (*ptr == '#') {
+                        ptr = _m3d_gethex(ptr, &model->vertex[i].color);
+                        if (!*ptr) goto asciiend;
+                    }
+                    /* parse skin */
+                    memset(&s, 0, sizeof(m3ds_t));
+                    for (j = 0, w = (M3D_FLOAT)0.0; j < M3D_NUMBONE && *ptr && *ptr != '\r' && *ptr != '\n'; j++) {
+                        ptr = _m3d_findarg(ptr);
+                        if (!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
+                        ptr = _m3d_getint(ptr, &k);
+                        s.boneid[j] = (M3D_INDEX)k;
+                        if (*ptr == ':') {
+                            ptr++;
+                            ptr = _m3d_getfloat(ptr, &s.weight[j]);
+                            w += s.weight[j];
+                        } else if (!j)
+                            s.weight[j] = (M3D_FLOAT)1.0;
+                        if (!*ptr) goto asciiend;
+                    }
+                    if (s.boneid[0] != M3D_UNDEF && s.weight[0] > (M3D_FLOAT)0.0) {
+                        if (w != (M3D_FLOAT)1.0 && w != (M3D_FLOAT)0.0)
+                            for (j = 0; j < M3D_NUMBONE && s.weight[j] > (M3D_FLOAT)0.0; j++)
+                                s.weight[j] /= w;
+                        k = M3D_NOTDEFINED;
+                        if (model->skin) {
+                            for (j = 0; j < model->numskin; j++)
+                                if (!memcmp(&model->skin[j], &s, sizeof(m3ds_t))) {
+                                    k = j;
+                                    break;
+                                }
+                        }
+                        if (k == M3D_NOTDEFINED) {
+                            k = model->numskin++;
+                            model->skin = (m3ds_t *)M3D_REALLOC(model->skin, model->numskin * sizeof(m3ds_t));
+                            memcpy(&model->skin[k], &s, sizeof(m3ds_t));
+                        }
+                        model->vertex[i].skinid = (M3D_INDEX)k;
+                    }
+                    ptr = _m3d_findnl(ptr);
+                }
+            } else
+                    /* Skeleton, bone hierarchy */
+                    if (!memcmp(pe, "Bones", 5)) {
+                if (model->bone) {
+                    M3D_LOG("More bones chunks, should be unique");
+                    goto asciiend;
+                }
+                bi[0] = M3D_UNDEF;
+                while (*ptr && *ptr != '\r' && *ptr != '\n') {
+                    i = model->numbone++;
+                    model->bone = (m3db_t *)M3D_REALLOC(model->bone, model->numbone * sizeof(m3db_t));
+                    if (!model->bone) goto memerr;
+                    for (level = 0; *ptr == '/'; ptr++, level++)
+                        ;
+                    if (level > M3D_BONEMAXLEVEL || !*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
+                    bi[level + 1] = i;
+                    model->bone[i].numweight = 0;
+                    model->bone[i].weight = NULL;
+                    model->bone[i].parent = bi[level];
+                    ptr = _m3d_getint(ptr, &k);
+                    ptr = _m3d_findarg(ptr);
+                    if (!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
+                    model->bone[i].pos = (M3D_INDEX)k;
+                    ptr = _m3d_getint(ptr, &k);
+                    ptr = _m3d_findarg(ptr);
+                    if (!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
+                    model->bone[i].ori = (M3D_INDEX)k;
+                    model->vertex[k].skinid = M3D_INDEXMAX;
+                    pe = _m3d_safestr(ptr, 0);
+                    if (!pe || !*pe) goto asciiend;
+                    model->bone[i].name = pe;
+                    ptr = _m3d_findnl(ptr);
+                }
+            } else
+                    /* material chunk */
+                    if (!memcmp(pe, "Material", 8)) {
+                pe = _m3d_findarg(pe);
+                if (!*pe || *pe == '\r' || *pe == '\n') goto asciiend;
+                pe = _m3d_safestr(pe, 0);
+                if (!pe || !*pe) goto asciiend;
+                for (i = 0; i < model->nummaterial; i++)
+                    if (!strcmp(pe, model->material[i].name)) {
+                        M3D_LOG("Multiple definitions for material");
+                        M3D_LOG(pe);
+                        M3D_FREE(pe);
+                        pe = NULL;
+                        while (*ptr && *ptr != '\r' && *ptr != '\n')
+                            ptr = _m3d_findnl(ptr);
+                        break;
+                    }
+                if (!pe) continue;
+                i = model->nummaterial++;
+                if (model->flags & M3D_FLG_MTLLIB) {
+                    m = model->material;
+                    model->material = (m3dm_t *)M3D_MALLOC(model->nummaterial * sizeof(m3dm_t));
+                    if (!model->material) goto memerr;
+                    memcpy(model->material, m, (model->nummaterial - 1) * sizeof(m3dm_t));
+                    if (model->texture) {
+                        tx = model->texture;
+                        model->texture = (m3dtx_t *)M3D_MALLOC(model->numtexture * sizeof(m3dtx_t));
+                        if (!model->texture) goto memerr;
+                        memcpy(model->texture, tx, model->numtexture * sizeof(m3dm_t));
+                    }
+                    model->flags &= ~M3D_FLG_MTLLIB;
+                } else {
+                    model->material = (m3dm_t *)M3D_REALLOC(model->material, model->nummaterial * sizeof(m3dm_t));
+                    if (!model->material) goto memerr;
+                }
+                m = &model->material[i];
+                m->name = pe;
+                m->numprop = 0;
+                m->prop = NULL;
+                while (*ptr && *ptr != '\r' && *ptr != '\n') {
+                    k = n = 256;
+                    if (*ptr == 'm' && *(ptr + 1) == 'a' && *(ptr + 2) == 'p' && *(ptr + 3) == '_') {
+                        k = m3dpf_map;
+                        ptr += 4;
+                    }
+                    for (j = 0; j < sizeof(m3d_propertytypes) / sizeof(m3d_propertytypes[0]); j++)
+                        if (!memcmp(ptr, m3d_propertytypes[j].key, strlen(m3d_propertytypes[j].key))) {
+                            n = m3d_propertytypes[j].id;
+                            if (k != m3dpf_map) k = m3d_propertytypes[j].format;
+                            break;
+                        }
+                    if (n != 256 && k != 256) {
+                        ptr = _m3d_findarg(ptr);
+                        if (!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
+                        j = m->numprop++;
+                        m->prop = (m3dp_t *)M3D_REALLOC(m->prop, m->numprop * sizeof(m3dp_t));
+                        if (!m->prop) goto memerr;
+                        m->prop[j].type = n + (k == m3dpf_map && n < 128 ? 128 : 0);
+                        switch (k) {
+                        case m3dpf_color: ptr = _m3d_gethex(ptr, &m->prop[j].value.color); break;
+                        case m3dpf_uint8:
+                        case m3dpf_uint16:
+                        case m3dpf_uint32: ptr = _m3d_getint(ptr, &m->prop[j].value.num); break;
+                        case m3dpf_float: ptr = _m3d_getfloat(ptr, &m->prop[j].value.fnum); break;
+                        case m3dpf_map:
+                            pe = _m3d_safestr(ptr, 0);
+                            if (!pe || !*pe) goto asciiend;
+                            m->prop[j].value.textureid = _m3d_gettx(model, readfilecb, freecb, pe);
+                            if (model->errcode == M3D_ERR_ALLOC) {
+                                M3D_FREE(pe);
+                                goto memerr;
+                            }
+                            /* this error code only returned if readfilecb was specified */
+                            if (m->prop[j].value.textureid == M3D_UNDEF) {
+                                M3D_LOG("Texture not found");
+                                M3D_LOG(pe);
+                                m->numprop--;
+                            }
+                            M3D_FREE(pe);
+                            break;
+                        }
+                    } else {
+                        M3D_LOG("Unknown material property in");
+                        M3D_LOG(m->name);
+                        model->errcode = M3D_ERR_UNKPROP;
+                    }
+                    ptr = _m3d_findnl(ptr);
+                }
+                if (!m->numprop) model->nummaterial--;
+            } else
+                    /* procedural */
+                    if (!memcmp(pe, "Procedural", 10)) {
+                pe = _m3d_safestr(ptr, 0);
+                _m3d_getpr(model, readfilecb, freecb, pe);
+                M3D_FREE(pe);
+                while (*ptr && *ptr != '\r' && *ptr != '\n')
+                    ptr = _m3d_findnl(ptr);
+            } else
+                    /* mesh */
+                    if (!memcmp(pe, "Mesh", 4)) {
+                mi = M3D_UNDEF;
+                while (*ptr && *ptr != '\r' && *ptr != '\n') {
+                    if (*ptr == 'u') {
+                        ptr = _m3d_findarg(ptr);
+                        if (!*ptr) goto asciiend;
+                        mi = M3D_UNDEF;
+                        if (*ptr != '\r' && *ptr != '\n') {
+                            pe = _m3d_safestr(ptr, 0);
+                            if (!pe || !*pe) goto asciiend;
+                            for (j = 0; j < model->nummaterial; j++)
+                                if (!strcmp(pe, model->material[j].name)) {
+                                    mi = (M3D_INDEX)j;
+                                    break;
+                                }
+                            if (mi == M3D_UNDEF && !(model->flags & M3D_FLG_MTLLIB)) {
+                                mi = model->nummaterial++;
+                                model->material = (m3dm_t *)M3D_REALLOC(model->material, model->nummaterial * sizeof(m3dm_t));
+                                if (!model->material) goto memerr;
+                                model->material[mi].name = pe;
+                                model->material[mi].numprop = 1;
+                                model->material[mi].prop = NULL;
+                            } else
+                                M3D_FREE(pe);
+                        }
+                    } else {
+                        i = model->numface++;
+                        model->face = (m3df_t *)M3D_REALLOC(model->face, model->numface * sizeof(m3df_t));
+                        if (!model->face) goto memerr;
+                        memset(&model->face[i], 255, sizeof(m3df_t)); /* set all index to -1 by default */
+                        model->face[i].materialid = mi;
+                        /* hardcoded triangles. */
+                        for (j = 0; j < 3; j++) {
+                            /* vertex */
+                            ptr = _m3d_getint(ptr, &k);
+                            model->face[i].vertex[j] = (M3D_INDEX)k;
+                            if (!*ptr) goto asciiend;
+                            if (*ptr == '/') {
+                                ptr++;
+                                if (*ptr != '/') {
+                                    /* texcoord */
+                                    ptr = _m3d_getint(ptr, &k);
+                                    model->face[i].texcoord[j] = (M3D_INDEX)k;
+                                    if (!*ptr) goto asciiend;
+                                }
+                                if (*ptr == '/') {
+                                    ptr++;
+                                    /* normal */
+                                    ptr = _m3d_getint(ptr, &k);
+                                    model->face[i].normal[j] = (M3D_INDEX)k;
+                                    if (!*ptr) goto asciiend;
+                                }
+                            }
+#ifndef M3D_NONORMALS
+                            if (model->face[i].normal[j] == M3D_UNDEF) neednorm = 1;
+#endif
+                            ptr = _m3d_findarg(ptr);
+                        }
+                    }
+                    ptr = _m3d_findnl(ptr);
+                }
+            } else
+                    /* mathematical shape */
+                    if (!memcmp(pe, "Shape", 5)) {
+                pe = _m3d_findarg(pe);
+                if (!*pe || *pe == '\r' || *pe == '\n') goto asciiend;
+                pe = _m3d_safestr(pe, 0);
+                if (!pe || !*pe) goto asciiend;
+                i = model->numshape++;
+                model->shape = (m3dh_t *)M3D_REALLOC(model->shape, model->numshape * sizeof(m3ds_t));
+                if (!model->shape) goto memerr;
+                h = &model->shape[i];
+                h->name = pe;
+                h->group = M3D_UNDEF;
+                h->numcmd = 0;
+                h->cmd = NULL;
+                while (*ptr && *ptr != '\r' && *ptr != '\n') {
+                    if (!memcmp(ptr, "group", 5)) {
+                        ptr = _m3d_findarg(ptr);
+                        ptr = _m3d_getint(ptr, &h->group);
+                        ptr = _m3d_findnl(ptr);
+                        if (h->group != M3D_UNDEF && h->group >= model->numbone) {
+                            M3D_LOG("Unknown bone id as shape group in shape");
+                            M3D_LOG(pe);
+                            h->group = M3D_UNDEF;
+                            model->errcode = M3D_ERR_SHPE;
+                        }
+                        continue;
+                    }
+                    for (cd = NULL, k = 0; k < (unsigned int)(sizeof(m3d_commandtypes) / sizeof(m3d_commandtypes[0])); k++) {
+                        j = (unsigned int)strlen(m3d_commandtypes[k].key);
+                        if (!memcmp(ptr, m3d_commandtypes[k].key, j) && (ptr[j] == ' ' || ptr[j] == '\r' || ptr[j] == '\n')) {
+                            cd = &m3d_commandtypes[k];
+                            break;
+                        }
+                    }
+                    if (cd) {
+                        j = h->numcmd++;
+                        h->cmd = (m3dc_t *)M3D_REALLOC(h->cmd, h->numcmd * sizeof(m3dc_t));
+                        if (!h->cmd) goto memerr;
+                        h->cmd[j].type = k;
+                        h->cmd[j].arg = (uint32_t *)M3D_MALLOC(cd->p * sizeof(uint32_t));
+                        if (!h->cmd[j].arg) goto memerr;
+                        memset(h->cmd[j].arg, 0, cd->p * sizeof(uint32_t));
+                        for (k = n = 0, l = cd->p; k < l; k++) {
+                            ptr = _m3d_findarg(ptr);
+                            if (!*ptr) goto asciiend;
+                            if (*ptr == '[') {
+                                ptr = _m3d_findarg(ptr + 1);
+                                if (!*ptr) goto asciiend;
+                            }
+                            if (*ptr == ']' || *ptr == '\r' || *ptr == '\n') break;
+                            switch (cd->a[((k - n) % (cd->p - n)) + n]) {
+                            case m3dcp_mi_t:
+                                mi = M3D_UNDEF;
+                                if (*ptr != '\r' && *ptr != '\n') {
+                                    pe = _m3d_safestr(ptr, 0);
+                                    if (!pe || !*pe) goto asciiend;
+                                    for (n = 0; n < model->nummaterial; n++)
+                                        if (!strcmp(pe, model->material[n].name)) {
+                                            mi = (M3D_INDEX)n;
+                                            break;
+                                        }
+                                    if (mi == M3D_UNDEF && !(model->flags & M3D_FLG_MTLLIB)) {
+                                        mi = model->nummaterial++;
+                                        model->material = (m3dm_t *)M3D_REALLOC(model->material,
+                                                model->nummaterial * sizeof(m3dm_t));
+                                        if (!model->material) goto memerr;
+                                        model->material[mi].name = pe;
+                                        model->material[mi].numprop = 1;
+                                        model->material[mi].prop = NULL;
+                                    } else
+                                        M3D_FREE(pe);
+                                }
+                                h->cmd[j].arg[k] = mi;
+                                break;
+                            case m3dcp_vc_t:
+                                _m3d_getfloat(ptr, &w);
+                                h->cmd[j].arg[k] = *((uint32_t *)&w);
+                                break;
+                            case m3dcp_va_t:
+                                ptr = _m3d_getint(ptr, &h->cmd[j].arg[k]);
+                                n = k + 1;
+                                l += (h->cmd[j].arg[k] - 1) * (cd->p - k - 1);
+                                h->cmd[j].arg = (uint32_t *)M3D_REALLOC(h->cmd[j].arg, l * sizeof(uint32_t));
+                                if (!h->cmd[j].arg) goto memerr;
+                                memset(&h->cmd[j].arg[k + 1], 0, (l - k - 1) * sizeof(uint32_t));
+                                break;
+                            case m3dcp_qi_t:
+                                ptr = _m3d_getint(ptr, &h->cmd[j].arg[k]);
+                                model->vertex[h->cmd[i].arg[k]].skinid = M3D_INDEXMAX;
+                                break;
+                            default:
+                                ptr = _m3d_getint(ptr, &h->cmd[j].arg[k]);
+                                break;
+                            }
+                        }
+                    } else {
+                        M3D_LOG("Unknown shape command in");
+                        M3D_LOG(h->name);
+                        model->errcode = M3D_ERR_UNKCMD;
+                    }
+                    ptr = _m3d_findnl(ptr);
+                }
+                if (!h->numcmd) model->numshape--;
+            } else
+                    /* annotation labels */
+                    if (!memcmp(pe, "Labels", 6)) {
+                pe = _m3d_findarg(pe);
+                if (!*pe) goto asciiend;
+                if (*pe == '\r' || *pe == '\n')
+                    pe = NULL;
+                else
+                    pe = _m3d_safestr(pe, 0);
+                k = 0;
+                fn = NULL;
+                while (*ptr && *ptr != '\r' && *ptr != '\n') {
+                    if (*ptr == 'c') {
+                        ptr = _m3d_findarg(ptr);
+                        if (!*pe || *pe == '\r' || *pe == '\n') goto asciiend;
+                        ptr = _m3d_gethex(ptr, &k);
+                    } else if (*ptr == 'l') {
+                        ptr = _m3d_findarg(ptr);
+                        if (!*pe || *pe == '\r' || *pe == '\n') goto asciiend;
+                        fn = _m3d_safestr(ptr, 2);
+                    } else {
+                        i = model->numlabel++;
+                        model->label = (m3dl_t *)M3D_REALLOC(model->label, model->numlabel * sizeof(m3dl_t));
+                        if (!model->label) goto memerr;
+                        model->label[i].name = pe;
+                        model->label[i].lang = fn;
+                        model->label[i].color = k;
+                        ptr = _m3d_getint(ptr, &j);
+                        model->label[i].vertexid = (M3D_INDEX)j;
+                        ptr = _m3d_findarg(ptr);
+                        if (!*pe || *pe == '\r' || *pe == '\n') goto asciiend;
+                        model->label[i].text = _m3d_safestr(ptr, 2);
+                    }
+                    ptr = _m3d_findnl(ptr);
+                }
+            } else
+                    /* action */
+                    if (!memcmp(pe, "Action", 6)) {
+                pe = _m3d_findarg(pe);
+                if (!*pe || *pe == '\r' || *pe == '\n') goto asciiend;
+                pe = _m3d_getint(pe, &k);
+                pe = _m3d_findarg(pe);
+                if (!*pe || *pe == '\r' || *pe == '\n') goto asciiend;
+                pe = _m3d_safestr(pe, 0);
+                if (!pe || !*pe) goto asciiend;
+                i = model->numaction++;
+                model->action = (m3da_t *)M3D_REALLOC(model->action, model->numaction * sizeof(m3da_t));
+                if (!model->action) goto memerr;
+                a = &model->action[i];
+                a->name = pe;
+                a->durationmsec = k;
+                /* skip the first frame marker as there's always at least one frame */
+                a->numframe = 1;
+                a->frame = (m3dfr_t *)M3D_MALLOC(sizeof(m3dfr_t));
+                if (!a->frame) goto memerr;
+                a->frame[0].msec = 0;
+                a->frame[0].numtransform = 0;
+                a->frame[0].transform = NULL;
+                i = 0;
+                if (*ptr == 'f')
+                    ptr = _m3d_findnl(ptr);
+                while (*ptr && *ptr != '\r' && *ptr != '\n') {
+                    if (*ptr == 'f') {
+                        i = a->numframe++;
+                        a->frame = (m3dfr_t *)M3D_REALLOC(a->frame, a->numframe * sizeof(m3dfr_t));
+                        if (!a->frame) goto memerr;
+                        ptr = _m3d_findarg(ptr);
+                        ptr = _m3d_getint(ptr, &a->frame[i].msec);
+                        a->frame[i].numtransform = 0;
+                        a->frame[i].transform = NULL;
+                    } else {
+                        j = a->frame[i].numtransform++;
+                        a->frame[i].transform = (m3dtr_t *)M3D_REALLOC(a->frame[i].transform,
+                                a->frame[i].numtransform * sizeof(m3dtr_t));
+                        if (!a->frame[i].transform) goto memerr;
+                        ptr = _m3d_getint(ptr, &k);
+                        ptr = _m3d_findarg(ptr);
+                        if (!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
+                        a->frame[i].transform[j].boneid = (M3D_INDEX)k;
+                        ptr = _m3d_getint(ptr, &k);
+                        ptr = _m3d_findarg(ptr);
+                        if (!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
+                        a->frame[i].transform[j].pos = (M3D_INDEX)k;
+                        ptr = _m3d_getint(ptr, &k);
+                        if (!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
+                        a->frame[i].transform[j].ori = (M3D_INDEX)k;
+                        model->vertex[k].skinid = M3D_INDEXMAX;
+                    }
+                    ptr = _m3d_findnl(ptr);
+                }
+            } else
+                    /* inlined assets chunk */
+                    if (!memcmp(pe, "Assets", 6)) {
+                while (*ptr && *ptr != '\r' && *ptr != '\n') {
+                    if (readfilecb) {
+                        pe = _m3d_safestr(ptr, 2);
+                        if (!pe || !*pe) goto asciiend;
+                        i = model->numinlined++;
+                        model->inlined = (m3di_t *)M3D_REALLOC(model->inlined, model->numinlined * sizeof(m3di_t));
+                        if (!model->inlined) goto memerr;
+                        t = &model->inlined[i];
+                        model->inlined[i].data = (*readfilecb)(pe, &model->inlined[i].length);
+                        if (model->inlined[i].data) {
+                            fn = strrchr(pe, '.');
+                            if (fn && (fn[1] == 'p' || fn[1] == 'P') && (fn[2] == 'n' || fn[2] == 'N') &&
+                                    (fn[3] == 'g' || fn[3] == 'G')) *fn = 0;
+                            fn = strrchr(pe, '/');
+                            if (!fn) fn = strrchr(pe, '\\');
+                            if (!fn)
+                                fn = pe;
+                            else
+                                fn++;
+                            model->inlined[i].name = _m3d_safestr(fn, 0);
+                        } else
+                            model->numinlined--;
+                        M3D_FREE(pe);
+                    }
+                    ptr = _m3d_findnl(ptr);
+                }
+            } else
+                    /* extra chunks */
+                    if (!memcmp(pe, "Extra", 5)) {
+                pe = _m3d_findarg(pe);
+                if (!*pe || *pe == '\r' || *pe == '\n') goto asciiend;
+                buff = (unsigned char *)_m3d_findnl(ptr);
+                k = ((uint32_t)((uintptr_t)buff - (uintptr_t)ptr) / 3) + 1;
+                i = model->numextra++;
+                model->extra = (m3dchunk_t **)M3D_REALLOC(model->extra, model->numextra * sizeof(m3dchunk_t *));
+                if (!model->extra) goto memerr;
+                model->extra[i] = (m3dchunk_t *)M3D_MALLOC(k + sizeof(m3dchunk_t));
+                if (!model->extra[i]) goto memerr;
+                memcpy(&model->extra[i]->magic, pe, 4);
+                model->extra[i]->length = sizeof(m3dchunk_t);
+                pe = (char *)model->extra[i] + sizeof(m3dchunk_t);
+                while (*ptr && *ptr != '\r' && *ptr != '\n') {
+                    ptr = _m3d_gethex(ptr, &k);
+                    *pe++ = (uint8_t)k;
+                    model->extra[i]->length++;
+                }
+            } else
+                goto asciiend;
+        }
+        model->errcode = M3D_SUCCESS;
+    asciiend:
+        setlocale(LC_NUMERIC, ol);
+        goto postprocess;
+    }
+    /* Binary variant */
+    if (!M3D_CHUNKMAGIC(data + 8, 'H', 'E', 'A', 'D')) {
+        buff = (unsigned char *)stbi_zlib_decode_malloc_guesssize_headerflag((const char *)data + 8, ((m3dchunk_t *)data)->length - 8,
+                4096, (int *)&len, 1);
+        if (!buff || !len || !M3D_CHUNKMAGIC(buff, 'H', 'E', 'A', 'D')) {
+            if (buff) M3D_FREE(buff);
+            M3D_FREE(model);
+            return NULL;
+        }
+        buff = (unsigned char *)M3D_REALLOC(buff, len);
+        model->flags |= M3D_FLG_FREERAW; /* mark that we have to free the raw buffer */
+        data = buff;
+#ifdef M3D_PROFILING
+        gettimeofday(&tv1, NULL);
+        tvd.tv_sec = tv1.tv_sec - tv0.tv_sec;
+        tvd.tv_usec = tv1.tv_usec - tv0.tv_usec;
+        if (tvd.tv_usec < 0) {
+            tvd.tv_sec--;
+            tvd.tv_usec += 1000000L;
+        }
+        printf("  Deflate model   %ld.%06ld sec\n", tvd.tv_sec, tvd.tv_usec);
+        memcpy(&tv0, &tv1, sizeof(struct timeval));
+#endif
+    } else {
+        len = ((m3dhdr_t *)data)->length;
+        data += 8;
+    }
+    model->raw = (m3dhdr_t *)data;
+    end = data + len;
+
+    /* parse header */
+    data += sizeof(m3dhdr_t);
+    M3D_LOG(data);
+    model->name = (char *)data;
+    for (; data < end && *data; data++) {
+    };
+    data++;
+    model->license = (char *)data;
+    for (; data < end && *data; data++) {
+    };
+    data++;
+    model->author = (char *)data;
+    for (; data < end && *data; data++) {
+    };
+    data++;
+    model->desc = (char *)data;
+    chunk = (unsigned char *)model->raw + model->raw->length;
+    model->scale = (M3D_FLOAT)model->raw->scale;
+    if (model->scale <= (M3D_FLOAT)0.0) model->scale = (M3D_FLOAT)1.0;
+    model->vc_s = 1 << ((model->raw->types >> 0) & 3); /* vertex coordinate size */
+    model->vi_s = 1 << ((model->raw->types >> 2) & 3); /* vertex index size */
+    model->si_s = 1 << ((model->raw->types >> 4) & 3); /* string offset size */
+    model->ci_s = 1 << ((model->raw->types >> 6) & 3); /* color index size */
+    model->ti_s = 1 << ((model->raw->types >> 8) & 3); /* tmap index size */
+    model->bi_s = 1 << ((model->raw->types >> 10) & 3); /* bone index size */
+    model->nb_s = 1 << ((model->raw->types >> 12) & 3); /* number of bones per vertex */
+    model->sk_s = 1 << ((model->raw->types >> 14) & 3); /* skin index size */
+    model->fc_s = 1 << ((model->raw->types >> 16) & 3); /* frame counter size */
+    model->hi_s = 1 << ((model->raw->types >> 18) & 3); /* shape index size */
+    model->fi_s = 1 << ((model->raw->types >> 20) & 3); /* face index size */
+    if (model->ci_s == 8) model->ci_s = 0; /* optional indices */
+    if (model->ti_s == 8) model->ti_s = 0;
+    if (model->bi_s == 8) model->bi_s = 0;
+    if (model->sk_s == 8) model->sk_s = 0;
+    if (model->fc_s == 8) model->fc_s = 0;
+    if (model->hi_s == 8) model->hi_s = 0;
+    if (model->fi_s == 8) model->fi_s = 0;
+
+    /* variable limit checks */
+    if (sizeof(M3D_FLOAT) == 4 && model->vc_s > 4) {
+        M3D_LOG("Double precision coordinates not supported, truncating to float...");
+        model->errcode = M3D_ERR_TRUNC;
+    }
+    if (sizeof(M3D_INDEX) == 2 && (model->vi_s > 2 || model->si_s > 2 || model->ci_s > 2 || model->ti_s > 2 ||
+                                          model->bi_s > 2 || model->sk_s > 2 || model->fc_s > 2 || model->hi_s > 2 || model->fi_s > 2)) {
+        M3D_LOG("32 bit indices not supported, unable to load model");
+        M3D_FREE(model);
+        return NULL;
+    }
+    if (model->vi_s > 4 || model->si_s > 4) {
+        M3D_LOG("Invalid index size, unable to load model");
+        M3D_FREE(model);
+        return NULL;
+    }
+    if (model->nb_s > M3D_NUMBONE) {
+        M3D_LOG("Model has more bones per vertex than what importer was configured to support");
+        model->errcode = M3D_ERR_TRUNC;
+    }
+
+    /* look for inlined assets in advance, material and procedural chunks may need them */
+    buff = chunk;
+    while (buff < end && !M3D_CHUNKMAGIC(buff, 'O', 'M', 'D', '3')) {
+        data = buff;
+        len = ((m3dchunk_t *)data)->length;
+        buff += len;
+        if (len < sizeof(m3dchunk_t) || buff >= end) {
+            M3D_LOG("Invalid chunk size");
+            break;
+        }
+        len -= sizeof(m3dchunk_t) + model->si_s;
+
+        /* inlined assets */
+        if (M3D_CHUNKMAGIC(data, 'A', 'S', 'E', 'T') && len > 0) {
+            M3D_LOG("Inlined asset");
+            i = model->numinlined++;
+            model->inlined = (m3di_t *)M3D_REALLOC(model->inlined, model->numinlined * sizeof(m3di_t));
+            if (!model->inlined) {
+            memerr:
+                M3D_LOG("Out of memory");
+                model->errcode = M3D_ERR_ALLOC;
+                return model;
+            }
+            data += sizeof(m3dchunk_t);
+            t = &model->inlined[i];
+            M3D_GETSTR(t->name);
+            M3D_LOG(t->name);
+            t->data = (uint8_t *)data;
+            t->length = len;
+        }
+    }
+
+    /* parse chunks */
+    while (chunk < end && !M3D_CHUNKMAGIC(chunk, 'O', 'M', 'D', '3')) {
+        data = chunk;
+        len = ((m3dchunk_t *)chunk)->length;
+        chunk += len;
+        if (len < sizeof(m3dchunk_t) || chunk >= end) {
+            M3D_LOG("Invalid chunk size");
+            break;
+        }
+        len -= sizeof(m3dchunk_t);
+
+        /* preview chunk */
+        if (M3D_CHUNKMAGIC(data, 'P', 'R', 'V', 'W') && len > 0) {
+            model->preview.length = len;
+            model->preview.data = data + sizeof(m3dchunk_t);
+        } else
+                /* color map */
+                if (M3D_CHUNKMAGIC(data, 'C', 'M', 'A', 'P')) {
+            M3D_LOG("Color map");
+            if (model->cmap) {
+                M3D_LOG("More color map chunks, should be unique");
+                model->errcode = M3D_ERR_CMAP;
+                continue;
+            }
+            if (!model->ci_s) {
+                M3D_LOG("Color map chunk, shouldn't be any");
+                model->errcode = M3D_ERR_CMAP;
+                continue;
+            }
+            model->numcmap = len / sizeof(uint32_t);
+            model->cmap = (uint32_t *)(data + sizeof(m3dchunk_t));
+        } else
+                /* texture map */
+                if (M3D_CHUNKMAGIC(data, 'T', 'M', 'A', 'P')) {
+            M3D_LOG("Texture map");
+            if (model->tmap) {
+                M3D_LOG("More texture map chunks, should be unique");
+                model->errcode = M3D_ERR_TMAP;
+                continue;
+            }
+            if (!model->ti_s) {
+                M3D_LOG("Texture map chunk, shouldn't be any");
+                model->errcode = M3D_ERR_TMAP;
+                continue;
+            }
+            reclen = model->vc_s + model->vc_s;
+            model->numtmap = len / reclen;
+            model->tmap = (m3dti_t *)M3D_MALLOC(model->numtmap * sizeof(m3dti_t));
+            if (!model->tmap) goto memerr;
+            for (i = 0, data += sizeof(m3dchunk_t); data < chunk; i++) {
+                switch (model->vc_s) {
+                case 1:
+                    model->tmap[i].u = (M3D_FLOAT)(data[0]) / (M3D_FLOAT)255.0;
+                    model->tmap[i].v = (M3D_FLOAT)(data[1]) / (M3D_FLOAT)255.0;
+                    break;
+                case 2:
+                    model->tmap[i].u = (M3D_FLOAT)(*((int16_t *)(data + 0))) / (M3D_FLOAT)65535.0;
+                    model->tmap[i].v = (M3D_FLOAT)(*((int16_t *)(data + 2))) / (M3D_FLOAT)65535.0;
+                    break;
+                case 4:
+                    model->tmap[i].u = (M3D_FLOAT)(*((float *)(data + 0)));
+                    model->tmap[i].v = (M3D_FLOAT)(*((float *)(data + 4)));
+                    break;
+                case 8:
+                    model->tmap[i].u = (M3D_FLOAT)(*((double *)(data + 0)));
+                    model->tmap[i].v = (M3D_FLOAT)(*((double *)(data + 8)));
+                    break;
+                }
+                data += reclen;
+            }
+        } else
+                /* vertex list */
+                if (M3D_CHUNKMAGIC(data, 'V', 'R', 'T', 'S')) {
+            M3D_LOG("Vertex list");
+            if (model->vertex) {
+                M3D_LOG("More vertex chunks, should be unique");
+                model->errcode = M3D_ERR_VRTS;
+                continue;
+            }
+            if (model->ci_s && model->ci_s < 4 && !model->cmap) model->errcode = M3D_ERR_CMAP;
+            reclen = model->ci_s + model->sk_s + 4 * model->vc_s;
+            model->numvertex = len / reclen;
+            model->vertex = (m3dv_t *)M3D_MALLOC(model->numvertex * sizeof(m3dv_t));
+            if (!model->vertex) goto memerr;
+            memset(model->vertex, 0, model->numvertex * sizeof(m3dv_t));
+            for (i = 0, data += sizeof(m3dchunk_t); data < chunk && i < model->numvertex; i++) {
+                switch (model->vc_s) {
+                case 1:
+                    model->vertex[i].x = (M3D_FLOAT)((int8_t)data[0]) / (M3D_FLOAT)127.0;
+                    model->vertex[i].y = (M3D_FLOAT)((int8_t)data[1]) / (M3D_FLOAT)127.0;
+                    model->vertex[i].z = (M3D_FLOAT)((int8_t)data[2]) / (M3D_FLOAT)127.0;
+                    model->vertex[i].w = (M3D_FLOAT)((int8_t)data[3]) / (M3D_FLOAT)127.0;
+                    data += 4;
+                    break;
+                case 2:
+                    model->vertex[i].x = (M3D_FLOAT)(*((int16_t *)(data + 0))) / (M3D_FLOAT)32767.0;
+                    model->vertex[i].y = (M3D_FLOAT)(*((int16_t *)(data + 2))) / (M3D_FLOAT)32767.0;
+                    model->vertex[i].z = (M3D_FLOAT)(*((int16_t *)(data + 4))) / (M3D_FLOAT)32767.0;
+                    model->vertex[i].w = (M3D_FLOAT)(*((int16_t *)(data + 6))) / (M3D_FLOAT)32767.0;
+                    data += 8;
+                    break;
+                case 4:
+                    model->vertex[i].x = (M3D_FLOAT)(*((float *)(data + 0)));
+                    model->vertex[i].y = (M3D_FLOAT)(*((float *)(data + 4)));
+                    model->vertex[i].z = (M3D_FLOAT)(*((float *)(data + 8)));
+                    model->vertex[i].w = (M3D_FLOAT)(*((float *)(data + 12)));
+                    data += 16;
+                    break;
+                case 8:
+                    model->vertex[i].x = (M3D_FLOAT)(*((double *)(data + 0)));
+                    model->vertex[i].y = (M3D_FLOAT)(*((double *)(data + 8)));
+                    model->vertex[i].z = (M3D_FLOAT)(*((double *)(data + 16)));
+                    model->vertex[i].w = (M3D_FLOAT)(*((double *)(data + 24)));
+                    data += 32;
+                    break;
+                }
+                switch (model->ci_s) {
+                case 1:
+                    model->vertex[i].color = model->cmap ? model->cmap[data[0]] : 0;
+                    data++;
+                    break;
+                case 2:
+                    model->vertex[i].color = model->cmap ? model->cmap[*((uint16_t *)data)] : 0;
+                    data += 2;
+                    break;
+                case 4:
+                    model->vertex[i].color = *((uint32_t *)data);
+                    data += 4;
+                    break;
+                    /* case 8: break; */
+                }
+                model->vertex[i].skinid = M3D_UNDEF;
+                data = _m3d_getidx(data, model->sk_s, &model->vertex[i].skinid);
+            }
+        } else
+                /* skeleton: bone hierarchy and skin */
+                if (M3D_CHUNKMAGIC(data, 'B', 'O', 'N', 'E')) {
+            M3D_LOG("Skeleton");
+            if (model->bone) {
+                M3D_LOG("More bone chunks, should be unique");
+                model->errcode = M3D_ERR_BONE;
+                continue;
+            }
+            if (!model->bi_s) {
+                M3D_LOG("Bone chunk, shouldn't be any");
+                model->errcode = M3D_ERR_BONE;
+                continue;
+            }
+            if (!model->vertex) {
+                M3D_LOG("No vertex chunk before bones");
+                model->errcode = M3D_ERR_VRTS;
+                break;
+            }
+            data += sizeof(m3dchunk_t);
+            model->numbone = 0;
+            data = _m3d_getidx(data, model->bi_s, &model->numbone);
+            if (model->numbone) {
+                model->bone = (m3db_t *)M3D_MALLOC(model->numbone * sizeof(m3db_t));
+                if (!model->bone) goto memerr;
+            }
+            model->numskin = 0;
+            data = _m3d_getidx(data, model->sk_s, &model->numskin);
+            /* read bone hierarchy */
+            for (i = 0; i < model->numbone; i++) {
+                data = _m3d_getidx(data, model->bi_s, &model->bone[i].parent);
+                M3D_GETSTR(model->bone[i].name);
+                data = _m3d_getidx(data, model->vi_s, &model->bone[i].pos);
+                data = _m3d_getidx(data, model->vi_s, &model->bone[i].ori);
+                model->bone[i].numweight = 0;
+                model->bone[i].weight = NULL;
+            }
+            /* read skin definitions */
+            if (model->numskin) {
+                model->skin = (m3ds_t *)M3D_MALLOC(model->numskin * sizeof(m3ds_t));
+                if (!model->skin) goto memerr;
+                for (i = 0; data < chunk && i < model->numskin; i++) {
+                    for (j = 0; j < M3D_NUMBONE; j++) {
+                        model->skin[i].boneid[j] = M3D_UNDEF;
+                        model->skin[i].weight[j] = (M3D_FLOAT)0.0;
+                    }
+                    memset(&weights, 0, sizeof(weights));
+                    if (model->nb_s == 1)
+                        weights[0] = 255;
+                    else {
+                        memcpy(&weights, data, model->nb_s);
+                        data += model->nb_s;
+                    }
+                    for (j = 0, w = (M3D_FLOAT)0.0; j < (unsigned int)model->nb_s; j++) {
+                        if (weights[j]) {
+                            if (j >= M3D_NUMBONE)
+                                data += model->bi_s;
+                            else {
+                                model->skin[i].weight[j] = (M3D_FLOAT)(weights[j]) / (M3D_FLOAT)255.0;
+                                w += model->skin[i].weight[j];
+                                data = _m3d_getidx(data, model->bi_s, &model->skin[i].boneid[j]);
+                            }
+                        }
+                    }
+                    /* this can occur if model has more bones than what the importer is configured to handle */
+                    if (w != (M3D_FLOAT)1.0 && w != (M3D_FLOAT)0.0) {
+                        for (j = 0; j < M3D_NUMBONE; j++)
+                            model->skin[i].weight[j] /= w;
+                    }
+                }
+            }
+        } else
+                /* material */
+                if (M3D_CHUNKMAGIC(data, 'M', 'T', 'R', 'L')) {
+            data += sizeof(m3dchunk_t);
+            M3D_GETSTR(name);
+            M3D_LOG("Material");
+            M3D_LOG(name);
+            if (model->ci_s < 4 && !model->numcmap) model->errcode = M3D_ERR_CMAP;
+            for (i = 0; i < model->nummaterial; i++)
+                if (!strcmp(name, model->material[i].name)) {
+                    model->errcode = M3D_ERR_MTRL;
+                    M3D_LOG("Multiple definitions for material");
+                    M3D_LOG(name);
+                    name = NULL;
+                    break;
+                }
+            if (name) {
+                i = model->nummaterial++;
+                if (model->flags & M3D_FLG_MTLLIB) {
+                    m = model->material;
+                    model->material = (m3dm_t *)M3D_MALLOC(model->nummaterial * sizeof(m3dm_t));
+                    if (!model->material) goto memerr;
+                    memcpy(model->material, m, (model->nummaterial - 1) * sizeof(m3dm_t));
+                    if (model->texture) {
+                        tx = model->texture;
+                        model->texture = (m3dtx_t *)M3D_MALLOC(model->numtexture * sizeof(m3dtx_t));
+                        if (!model->texture) goto memerr;
+                        memcpy(model->texture, tx, model->numtexture * sizeof(m3dm_t));
+                    }
+                    model->flags &= ~M3D_FLG_MTLLIB;
+                } else {
+                    model->material = (m3dm_t *)M3D_REALLOC(model->material, model->nummaterial * sizeof(m3dm_t));
+                    if (!model->material) goto memerr;
+                }
+                m = &model->material[i];
+                m->numprop = 0;
+                m->name = name;
+                m->prop = (m3dp_t *)M3D_MALLOC((len / 2) * sizeof(m3dp_t));
+                if (!m->prop) goto memerr;
+                while (data < chunk) {
+                    i = m->numprop++;
+                    m->prop[i].type = *data++;
+                    m->prop[i].value.num = 0;
+                    if (m->prop[i].type >= 128)
+                        k = m3dpf_map;
+                    else {
+                        for (k = 256, j = 0; j < sizeof(m3d_propertytypes) / sizeof(m3d_propertytypes[0]); j++)
+                            if (m->prop[i].type == m3d_propertytypes[j].id) {
+                                k = m3d_propertytypes[j].format;
+                                break;
+                            }
+                    }
+                    switch (k) {
+                    case m3dpf_color:
+                        switch (model->ci_s) {
+                        case 1:
+                            m->prop[i].value.color = model->cmap ? model->cmap[data[0]] : 0;
+                            data++;
+                            break;
+                        case 2:
+                            m->prop[i].value.color = model->cmap ? model->cmap[*((uint16_t *)data)] : 0;
+                            data += 2;
+                            break;
+                        case 4:
+                            m->prop[i].value.color = *((uint32_t *)data);
+                            data += 4;
+                            break;
+                        }
+                        break;
+
+                    case m3dpf_uint8: m->prop[i].value.num = *data++; break;
+                    case m3dpf_uint16:
+                        m->prop[i].value.num = *((uint16_t *)data);
+                        data += 2;
+                        break;
+                    case m3dpf_uint32:
+                        m->prop[i].value.num = *((uint32_t *)data);
+                        data += 4;
+                        break;
+                    case m3dpf_float:
+                        m->prop[i].value.fnum = *((float *)data);
+                        data += 4;
+                        break;
+
+                    case m3dpf_map:
+                        M3D_GETSTR(name);
+                        m->prop[i].value.textureid = _m3d_gettx(model, readfilecb, freecb, name);
+                        if (model->errcode == M3D_ERR_ALLOC) goto memerr;
+                        /* this error code only returned if readfilecb was specified */
+                        if (m->prop[i].value.textureid == M3D_UNDEF) {
+                            M3D_LOG("Texture not found");
+                            M3D_LOG(m->name);
+                            m->numprop--;
+                        }
+                        break;
+
+                    default:
+                        M3D_LOG("Unknown material property in");
+                        M3D_LOG(m->name);
+                        model->errcode = M3D_ERR_UNKPROP;
+                        data = chunk;
+                        break;
+                    }
+                }
+                m->prop = (m3dp_t *)M3D_REALLOC(m->prop, m->numprop * sizeof(m3dp_t));
+                if (!m->prop) goto memerr;
+            }
+        } else
+                /* face */
+                if (M3D_CHUNKMAGIC(data, 'P', 'R', 'O', 'C')) {
+            /* procedural surface */
+            M3D_GETSTR(name);
+            M3D_LOG("Procedural surface");
+            M3D_LOG(name);
+            _m3d_getpr(model, readfilecb, freecb, name);
+        } else if (M3D_CHUNKMAGIC(data, 'M', 'E', 'S', 'H')) {
+            M3D_LOG("Mesh data");
+            /* mesh */
+            data += sizeof(m3dchunk_t);
+            mi = M3D_UNDEF;
+            am = model->numface;
+            while (data < chunk) {
+                k = *data++;
+                n = k >> 4;
+                k &= 15;
+                if (!n) {
+                    /* use material */
+                    mi = M3D_UNDEF;
+                    M3D_GETSTR(name);
+                    if (name) {
+                        for (j = 0; j < model->nummaterial; j++)
+                            if (!strcmp(name, model->material[j].name)) {
+                                mi = (M3D_INDEX)j;
+                                break;
+                            }
+                        if (mi == M3D_UNDEF) model->errcode = M3D_ERR_MTRL;
+                    }
+                    continue;
+                }
+                if (n != 3) {
+                    M3D_LOG("Only triangle mesh supported for now");
+                    model->errcode = M3D_ERR_UNKMESH;
+                    return model;
+                }
+                i = model->numface++;
+                if (model->numface > am) {
+                    am = model->numface + 4095;
+                    model->face = (m3df_t *)M3D_REALLOC(model->face, am * sizeof(m3df_t));
+                    if (!model->face) goto memerr;
+                }
+                memset(&model->face[i], 255, sizeof(m3df_t)); /* set all index to -1 by default */
+                model->face[i].materialid = mi;
+                for (j = 0; j < n; j++) {
+                    /* vertex */
+                    data = _m3d_getidx(data, model->vi_s, &model->face[i].vertex[j]);
+                    /* texcoord */
+                    if (k & 1)
+                        data = _m3d_getidx(data, model->ti_s, &model->face[i].texcoord[j]);
+                    /* normal */
+                    if (k & 2)
+                        data = _m3d_getidx(data, model->vi_s, &model->face[i].normal[j]);
+#ifndef M3D_NONORMALS
+                    if (model->face[i].normal[j] == M3D_UNDEF) neednorm = 1;
+#endif
+                }
+            }
+            model->face = (m3df_t *)M3D_REALLOC(model->face, model->numface * sizeof(m3df_t));
+        } else if (M3D_CHUNKMAGIC(data, 'S', 'H', 'P', 'E')) {
+            /* mathematical shape */
+            data += sizeof(m3dchunk_t);
+            M3D_GETSTR(name);
+            M3D_LOG("Mathematical Shape");
+            M3D_LOG(name);
+            i = model->numshape++;
+            model->shape = (m3dh_t *)M3D_REALLOC(model->shape, model->numshape * sizeof(m3dh_t));
+            if (!model->shape) goto memerr;
+            h = &model->shape[i];
+            h->numcmd = 0;
+            h->cmd = NULL;
+            h->name = name;
+            h->group = M3D_UNDEF;
+            data = _m3d_getidx(data, model->bi_s, &h->group);
+            if (h->group != M3D_UNDEF && h->group >= model->numbone) {
+                M3D_LOG("Unknown bone id as shape group in shape");
+                M3D_LOG(name);
+                h->group = M3D_UNDEF;
+                model->errcode = M3D_ERR_SHPE;
+            }
+            while (data < chunk) {
+                i = h->numcmd++;
+                h->cmd = (m3dc_t *)M3D_REALLOC(h->cmd, h->numcmd * sizeof(m3dc_t));
+                if (!h->cmd) goto memerr;
+                h->cmd[i].type = *data++;
+                if (h->cmd[i].type & 0x80) {
+                    h->cmd[i].type &= 0x7F;
+                    h->cmd[i].type |= (*data++ << 7);
+                }
+                if (h->cmd[i].type >= (unsigned int)(sizeof(m3d_commandtypes) / sizeof(m3d_commandtypes[0]))) {
+                    M3D_LOG("Unknown shape command in");
+                    M3D_LOG(h->name);
+                    model->errcode = M3D_ERR_UNKCMD;
+                    break;
+                }
+                cd = &m3d_commandtypes[h->cmd[i].type];
+                h->cmd[i].arg = (uint32_t *)M3D_MALLOC(cd->p * sizeof(uint32_t));
+                if (!h->cmd[i].arg) goto memerr;
+                memset(h->cmd[i].arg, 0, cd->p * sizeof(uint32_t));
+                for (k = n = 0, l = cd->p; k < l; k++)
+                    switch (cd->a[((k - n) % (cd->p - n)) + n]) {
+                    case m3dcp_mi_t:
+                        h->cmd[i].arg[k] = M3D_NOTDEFINED;
+                        M3D_GETSTR(name);
+                        if (name) {
+                            for (n = 0; n < model->nummaterial; n++)
+                                if (!strcmp(name, model->material[n].name)) {
+                                    h->cmd[i].arg[k] = n;
+                                    break;
+                                }
+                            if (h->cmd[i].arg[k] == M3D_NOTDEFINED) model->errcode = M3D_ERR_MTRL;
+                        }
+                        break;
+                    case m3dcp_vc_t:
+                        f = 0.0f;
+                        switch (model->vc_s) {
+                        case 1: f = (float)((int8_t)data[0]) / 127; break;
+                        case 2: f = (float)(*((int16_t *)(data + 0))) / 32767; break;
+                        case 4: f = (float)(*((float *)(data + 0))); break;
+                        case 8: f = (float)(*((double *)(data + 0))); break;
+                        }
+                        memcpy(&(h->cmd[i].arg[k]), &f, sizeof(uint32_t));
+                        data += model->vc_s;
+                        break;
+                    case m3dcp_hi_t: data = _m3d_getidx(data, model->hi_s, &h->cmd[i].arg[k]); break;
+                    case m3dcp_fi_t: data = _m3d_getidx(data, model->fi_s, &h->cmd[i].arg[k]); break;
+                    case m3dcp_ti_t: data = _m3d_getidx(data, model->ti_s, &h->cmd[i].arg[k]); break;
+                    case m3dcp_qi_t:
+                    case m3dcp_vi_t: data = _m3d_getidx(data, model->vi_s, &h->cmd[i].arg[k]); break;
+                    case m3dcp_i1_t: data = _m3d_getidx(data, 1, &h->cmd[i].arg[k]); break;
+                    case m3dcp_i2_t: data = _m3d_getidx(data, 2, &h->cmd[i].arg[k]); break;
+                    case m3dcp_i4_t: data = _m3d_getidx(data, 4, &h->cmd[i].arg[k]); break;
+                    case m3dcp_va_t:
+                        data = _m3d_getidx(data, 4, &h->cmd[i].arg[k]);
+                        n = k + 1;
+                        l += (h->cmd[i].arg[k] - 1) * (cd->p - k - 1);
+                        h->cmd[i].arg = (uint32_t *)M3D_REALLOC(h->cmd[i].arg, l * sizeof(uint32_t));
+                        if (!h->cmd[i].arg) goto memerr;
+                        memset(&h->cmd[i].arg[k + 1], 0, (l - k - 1) * sizeof(uint32_t));
+                        break;
+                    }
+            }
+        } else
+                /* annotation label list */
+                if (M3D_CHUNKMAGIC(data, 'L', 'B', 'L', 'S')) {
+            data += sizeof(m3dchunk_t);
+            M3D_GETSTR(name);
+            M3D_GETSTR(lang);
+            M3D_LOG("Label list");
+            if (name) {
+                M3D_LOG(name);
+            }
+            if (lang) {
+                M3D_LOG(lang);
+            }
+            if (model->ci_s && model->ci_s < 4 && !model->cmap) model->errcode = M3D_ERR_CMAP;
+            k = 0;
+            switch (model->ci_s) {
+            case 1:
+                k = model->cmap ? model->cmap[data[0]] : 0;
+                data++;
+                break;
+            case 2:
+                k = model->cmap ? model->cmap[*((uint16_t *)data)] : 0;
+                data += 2;
+                break;
+            case 4:
+                k = *((uint32_t *)data);
+                data += 4;
+                break;
+                /* case 8: break; */
+            }
+            reclen = model->vi_s + model->si_s;
+            i = model->numlabel;
+            model->numlabel += len / reclen;
+            model->label = (m3dl_t *)M3D_REALLOC(model->label, model->numlabel * sizeof(m3dl_t));
+            if (!model->label) goto memerr;
+            memset(&model->label[i], 0, (model->numlabel - i) * sizeof(m3dl_t));
+            for (; data < chunk && i < model->numlabel; i++) {
+                model->label[i].name = name;
+                model->label[i].lang = lang;
+                model->label[i].color = k;
+                data = _m3d_getidx(data, model->vi_s, &model->label[i].vertexid);
+                M3D_GETSTR(model->label[i].text);
+            }
+        } else
+                /* action */
+                if (M3D_CHUNKMAGIC(data, 'A', 'C', 'T', 'N')) {
+            M3D_LOG("Action");
+            i = model->numaction++;
+            model->action = (m3da_t *)M3D_REALLOC(model->action, model->numaction * sizeof(m3da_t));
+            if (!model->action) goto memerr;
+            a = &model->action[i];
+            data += sizeof(m3dchunk_t);
+            M3D_GETSTR(a->name);
+            M3D_LOG(a->name);
+            a->numframe = *((uint16_t *)data);
+            data += 2;
+            if (a->numframe < 1) {
+                model->numaction--;
+            } else {
+                a->durationmsec = *((uint32_t *)data);
+                data += 4;
+                a->frame = (m3dfr_t *)M3D_MALLOC(a->numframe * sizeof(m3dfr_t));
+                if (!a->frame) goto memerr;
+                for (i = 0; data < chunk && i < a->numframe; i++) {
+                    a->frame[i].msec = *((uint32_t *)data);
+                    data += 4;
+                    a->frame[i].numtransform = 0;
+                    a->frame[i].transform = NULL;
+                    data = _m3d_getidx(data, model->fc_s, &a->frame[i].numtransform);
+                    if (a->frame[i].numtransform > 0) {
+                        a->frame[i].transform = (m3dtr_t *)M3D_MALLOC(a->frame[i].numtransform * sizeof(m3dtr_t));
+                        for (j = 0; j < a->frame[i].numtransform; j++) {
+                            data = _m3d_getidx(data, model->bi_s, &a->frame[i].transform[j].boneid);
+                            data = _m3d_getidx(data, model->vi_s, &a->frame[i].transform[j].pos);
+                            data = _m3d_getidx(data, model->vi_s, &a->frame[i].transform[j].ori);
+                        }
+                    }
+                }
+            }
+        } else {
+            i = model->numextra++;
+            model->extra = (m3dchunk_t **)M3D_REALLOC(model->extra, model->numextra * sizeof(m3dchunk_t *));
+            if (!model->extra) goto memerr;
+            model->extra[i] = (m3dchunk_t *)data;
+        }
+    }
+    /* calculate normals, normalize skin weights, create bone/vertex cross-references and calculate transform matrices */
+postprocess:
+    if (model) {
+        M3D_LOG("Post-process");
+#ifdef M3D_PROFILING
+        gettimeofday(&tv1, NULL);
+        tvd.tv_sec = tv1.tv_sec - tv0.tv_sec;
+        tvd.tv_usec = tv1.tv_usec - tv0.tv_usec;
+        if (tvd.tv_usec < 0) {
+            tvd.tv_sec--;
+            tvd.tv_usec += 1000000L;
+        }
+        printf("  Parsing chunks  %ld.%06ld sec\n", tvd.tv_sec, tvd.tv_usec);
+#endif
+#ifndef M3D_NONORMALS
+        if (model->numface && model->face && neednorm) {
+            /* if they are missing, calculate triangle normals into a temporary buffer */
+            norm = (m3dv_t *)M3D_MALLOC(model->numface * sizeof(m3dv_t));
+            if (!norm) goto memerr;
+            for (i = 0, n = model->numvertex; i < model->numface; i++)
+                if (model->face[i].normal[0] == M3D_UNDEF) {
+                    v0 = &model->vertex[model->face[i].vertex[0]];
+                    v1 = &model->vertex[model->face[i].vertex[1]];
+                    v2 = &model->vertex[model->face[i].vertex[2]];
+                    va.x = v1->x - v0->x;
+                    va.y = v1->y - v0->y;
+                    va.z = v1->z - v0->z;
+                    vb.x = v2->x - v0->x;
+                    vb.y = v2->y - v0->y;
+                    vb.z = v2->z - v0->z;
+                    v0 = &norm[i];
+                    v0->x = (va.y * vb.z) - (va.z * vb.y);
+                    v0->y = (va.z * vb.x) - (va.x * vb.z);
+                    v0->z = (va.x * vb.y) - (va.y * vb.x);
+                    w = _m3d_rsq((v0->x * v0->x) + (v0->y * v0->y) + (v0->z * v0->z));
+                    v0->x *= w;
+                    v0->y *= w;
+                    v0->z *= w;
+                    model->face[i].normal[0] = model->face[i].vertex[0] + n;
+                    model->face[i].normal[1] = model->face[i].vertex[1] + n;
+                    model->face[i].normal[2] = model->face[i].vertex[2] + n;
+                }
+            /* this is the fast way, we don't care if a normal is repeated in model->vertex */
+            M3D_LOG("Generating normals");
+            model->flags |= M3D_FLG_GENNORM;
+            model->numvertex <<= 1;
+            model->vertex = (m3dv_t *)M3D_REALLOC(model->vertex, model->numvertex * sizeof(m3dv_t));
+            if (!model->vertex) goto memerr;
+            memset(&model->vertex[n], 0, n * sizeof(m3dv_t));
+            for (i = 0; i < model->numface; i++)
+                for (j = 0; j < 3; j++) {
+                    v0 = &model->vertex[model->face[i].vertex[j] + n];
+                    v0->x += norm[i].x;
+                    v0->y += norm[i].y;
+                    v0->z += norm[i].z;
+                }
+            /* for each vertex, take the average of the temporary normals and use that */
+            for (i = 0, v0 = &model->vertex[n]; i < n; i++, v0++) {
+                w = _m3d_rsq((v0->x * v0->x) + (v0->y * v0->y) + (v0->z * v0->z));
+                v0->x *= w;
+                v0->y *= w;
+                v0->z *= w;
+                v0->skinid = M3D_UNDEF;
+            }
+            M3D_FREE(norm);
+        }
+#endif
+        if (model->numbone && model->bone && model->numskin && model->skin && model->numvertex && model->vertex) {
+#ifndef M3D_NOWEIGHTS
+            M3D_LOG("Generating weight cross-reference");
+            for (i = 0; i < model->numvertex; i++) {
+                if (model->vertex[i].skinid < model->numskin) {
+                    sk = &model->skin[model->vertex[i].skinid];
+                    w = (M3D_FLOAT)0.0;
+                    for (j = 0; j < M3D_NUMBONE && sk->boneid[j] != M3D_UNDEF && sk->weight[j] > (M3D_FLOAT)0.0; j++)
+                        w += sk->weight[j];
+                    for (j = 0; j < M3D_NUMBONE && sk->boneid[j] != M3D_UNDEF && sk->weight[j] > (M3D_FLOAT)0.0; j++) {
+                        sk->weight[j] /= w;
+                        b = &model->bone[sk->boneid[j]];
+                        k = b->numweight++;
+                        b->weight = (m3dw_t *)M3D_REALLOC(b->weight, b->numweight * sizeof(m3da_t));
+                        if (!b->weight) goto memerr;
+                        b->weight[k].vertexid = i;
+                        b->weight[k].weight = sk->weight[j];
+                    }
+                }
+            }
+#endif
+#ifndef M3D_NOANIMATION
+            M3D_LOG("Calculating bone transformation matrices");
+            for (i = 0; i < model->numbone; i++) {
+                b = &model->bone[i];
+                if (model->bone[i].parent == M3D_UNDEF) {
+                    _m3d_mat((M3D_FLOAT *)&b->mat4, &model->vertex[b->pos], &model->vertex[b->ori]);
+                } else {
+                    _m3d_mat((M3D_FLOAT *)&r, &model->vertex[b->pos], &model->vertex[b->ori]);
+                    _m3d_mul((M3D_FLOAT *)&b->mat4, (M3D_FLOAT *)&model->bone[b->parent].mat4, (M3D_FLOAT *)&r);
+                }
+            }
+            for (i = 0; i < model->numbone; i++)
+                _m3d_inv((M3D_FLOAT *)&model->bone[i].mat4);
+#endif
+        }
+#ifdef M3D_PROFILING
+        gettimeofday(&tv0, NULL);
+        tvd.tv_sec = tv0.tv_sec - tv1.tv_sec;
+        tvd.tv_usec = tv0.tv_usec - tv1.tv_usec;
+        if (tvd.tv_usec < 0) {
+            tvd.tv_sec--;
+            tvd.tv_usec += 1000000L;
+        }
+        printf("  Post-process    %ld.%06ld sec\n", tvd.tv_sec, tvd.tv_usec);
+#endif
+    }
+    return model;
+}
+
+/**
+ * Calculates skeletons for animation frames, returns a working copy (should be freed after use)
+ */
+m3dtr_t *m3d_frame(m3d_t *model, M3D_INDEX actionid, M3D_INDEX frameid, m3dtr_t *skeleton) {
+    unsigned int i;
+    M3D_INDEX s = frameid;
+    m3dfr_t *fr;
+
+    if (!model || !model->numbone || !model->bone || (actionid != M3D_UNDEF && (!model->action || actionid >= model->numaction || frameid >= model->action[actionid].numframe))) {
+        model->errcode = M3D_ERR_UNKFRAME;
+        return skeleton;
+    }
+    model->errcode = M3D_SUCCESS;
+    if (!skeleton) {
+        skeleton = (m3dtr_t *)M3D_MALLOC(model->numbone * sizeof(m3dtr_t));
+        if (!skeleton) {
+            model->errcode = M3D_ERR_ALLOC;
+            return NULL;
+        }
+        goto gen;
+    }
+    if (actionid == M3D_UNDEF || !frameid) {
+    gen:
+        s = 0;
+        for (i = 0; i < model->numbone; i++) {
+            skeleton[i].boneid = i;
+            skeleton[i].pos = model->bone[i].pos;
+            skeleton[i].ori = model->bone[i].ori;
+        }
+    }
+    if (actionid < model->numaction && (frameid || !model->action[actionid].frame[0].msec)) {
+        for (; s <= frameid; s++) {
+            fr = &model->action[actionid].frame[s];
+            for (i = 0; i < fr->numtransform; i++) {
+                skeleton[fr->transform[i].boneid].pos = fr->transform[i].pos;
+                skeleton[fr->transform[i].boneid].ori = fr->transform[i].ori;
+            }
+        }
+    }
+    return skeleton;
+}
+
+#ifndef M3D_NOANIMATION
+/**
+ * Returns interpolated animation-pose, a working copy (should be freed after use)
+ */
+m3db_t *m3d_pose(m3d_t *model, M3D_INDEX actionid, uint32_t msec) {
+    unsigned int i, j, l;
+    M3D_FLOAT r[16], t, c, d, s;
+    m3db_t *ret;
+    m3dv_t *v, *p, *f;
+    m3dtr_t *tmp;
+    m3dfr_t *fr;
+
+    if (!model || !model->numbone || !model->bone) {
+        model->errcode = M3D_ERR_UNKFRAME;
+        return NULL;
+    }
+    ret = (m3db_t *)M3D_MALLOC(model->numbone * sizeof(m3db_t));
+    if (!ret) {
+        model->errcode = M3D_ERR_ALLOC;
+        return NULL;
+    }
+    memcpy(ret, model->bone, model->numbone * sizeof(m3db_t));
+    for (i = 0; i < model->numbone; i++)
+        _m3d_inv((M3D_FLOAT *)&ret[i].mat4);
+    if (!model->action || actionid >= model->numaction) {
+        model->errcode = M3D_ERR_UNKFRAME;
+        return ret;
+    }
+    msec %= model->action[actionid].durationmsec;
+    model->errcode = M3D_SUCCESS;
+    fr = &model->action[actionid].frame[0];
+    for (j = l = 0; j < model->action[actionid].numframe && model->action[actionid].frame[j].msec <= msec; j++) {
+        fr = &model->action[actionid].frame[j];
+        l = fr->msec;
+        for (i = 0; i < fr->numtransform; i++) {
+            ret[fr->transform[i].boneid].pos = fr->transform[i].pos;
+            ret[fr->transform[i].boneid].ori = fr->transform[i].ori;
+        }
+    }
+    if (l != msec) {
+        model->vertex = (m3dv_t *)M3D_REALLOC(model->vertex, (model->numvertex + 2 * model->numbone) * sizeof(m3dv_t));
+        if (!model->vertex) {
+            free(ret);
+            model->errcode = M3D_ERR_ALLOC;
+            return NULL;
+        }
+        tmp = (m3dtr_t *)M3D_MALLOC(model->numbone * sizeof(m3dtr_t));
+        if (tmp) {
+            for (i = 0; i < model->numbone; i++) {
+                tmp[i].pos = ret[i].pos;
+                tmp[i].ori = ret[i].ori;
+            }
+            fr = &model->action[actionid].frame[j % model->action[actionid].numframe];
+            t = l >= fr->msec ? (M3D_FLOAT)1.0 : (M3D_FLOAT)(msec - l) / (M3D_FLOAT)(fr->msec - l);
+            for (i = 0; i < fr->numtransform; i++) {
+                tmp[fr->transform[i].boneid].pos = fr->transform[i].pos;
+                tmp[fr->transform[i].boneid].ori = fr->transform[i].ori;
+            }
+            for (i = 0, j = model->numvertex; i < model->numbone; i++) {
+                /* interpolation of position */
+                if (ret[i].pos != tmp[i].pos) {
+                    p = &model->vertex[ret[i].pos];
+                    f = &model->vertex[tmp[i].pos];
+                    v = &model->vertex[j];
+                    v->x = p->x + t * (f->x - p->x);
+                    v->y = p->y + t * (f->y - p->y);
+                    v->z = p->z + t * (f->z - p->z);
+                    ret[i].pos = j++;
+                }
+                /* interpolation of orientation */
+                if (ret[i].ori != tmp[i].ori) {
+                    p = &model->vertex[ret[i].ori];
+                    f = &model->vertex[tmp[i].ori];
+                    v = &model->vertex[j];
+                    d = p->w * f->w + p->x * f->x + p->y * f->y + p->z * f->z;
+                    if (d < 0) {
+                        d = -d;
+                        s = (M3D_FLOAT)-1.0;
+                    } else
+                        s = (M3D_FLOAT)1.0;
+#if 0
+                    /* don't use SLERP, requires two more variables, libm linkage and it is slow (but nice) */
+                    a = (M3D_FLOAT)1.0 - t; b = t;
+                    if(d < (M3D_FLOAT)0.999999) { c = acosf(d); b = 1 / sinf(c); a = sinf(a * c) * b; b *= sinf(t * c) * s; }
+                    v->x = p->x * a + f->x * b;
+                    v->y = p->y * a + f->y * b;
+                    v->z = p->z * a + f->z * b;
+                    v->w = p->w * a + f->w * b;
+#else
+                    /* approximated NLERP, original approximation by Arseny Kapoulkine, heavily optimized by me */
+                    c = t - (M3D_FLOAT)0.5;
+                    t += t * c * (t - (M3D_FLOAT)1.0) * (((M3D_FLOAT)1.0904 + d * ((M3D_FLOAT)-3.2452 + d * ((M3D_FLOAT)3.55645 - d * (M3D_FLOAT)1.43519))) * c * c + ((M3D_FLOAT)0.848013 + d * ((M3D_FLOAT)-1.06021 + d * (M3D_FLOAT)0.215638)));
+                    v->x = p->x + t * (s * f->x - p->x);
+                    v->y = p->y + t * (s * f->y - p->y);
+                    v->z = p->z + t * (s * f->z - p->z);
+                    v->w = p->w + t * (s * f->w - p->w);
+                    d = _m3d_rsq(v->w * v->w + v->x * v->x + v->y * v->y + v->z * v->z);
+                    v->x *= d;
+                    v->y *= d;
+                    v->z *= d;
+                    v->w *= d;
+#endif
+                    ret[i].ori = j++;
+                }
+            }
+            M3D_FREE(tmp);
+        }
+    }
+    for (i = 0; i < model->numbone; i++) {
+        if (ret[i].parent == M3D_UNDEF) {
+            _m3d_mat((M3D_FLOAT *)&ret[i].mat4, &model->vertex[ret[i].pos], &model->vertex[ret[i].ori]);
+        } else {
+            _m3d_mat((M3D_FLOAT *)&r, &model->vertex[ret[i].pos], &model->vertex[ret[i].ori]);
+            _m3d_mul((M3D_FLOAT *)&ret[i].mat4, (M3D_FLOAT *)&ret[ret[i].parent].mat4, (M3D_FLOAT *)&r);
+        }
+    }
+    return ret;
+}
+
+#endif /* M3D_NOANIMATION */
+
+#endif /* M3D_IMPLEMENTATION */
+
+#if !defined(M3D_NODUP) && (!defined(M3D_NOIMPORTER) || defined(M3D_EXPORTER))
+/**
+ * Free the in-memory model
+ */
+void m3d_free(m3d_t *model) {
+    unsigned int i, j;
+
+    if (!model) return;
+    /* if model imported from ASCII, we have to free all strings as well */
+    if (model->flags & M3D_FLG_FREESTR) {
+        if (model->name) M3D_FREE(model->name);
+        if (model->license) M3D_FREE(model->license);
+        if (model->author) M3D_FREE(model->author);
+        if (model->desc) M3D_FREE(model->desc);
+        if (model->bone)
+            for (i = 0; i < model->numbone; i++)
+                if (model->bone[i].name)
+                    M3D_FREE(model->bone[i].name);
+        if (model->shape)
+            for (i = 0; i < model->numshape; i++)
+                if (model->shape[i].name)
+                    M3D_FREE(model->shape[i].name);
+        if (model->material)
+            for (i = 0; i < model->nummaterial; i++)
+                if (model->material[i].name)
+                    M3D_FREE(model->material[i].name);
+        if (model->action)
+            for (i = 0; i < model->numaction; i++)
+                if (model->action[i].name)
+                    M3D_FREE(model->action[i].name);
+        if (model->texture)
+            for (i = 0; i < model->numtexture; i++)
+                if (model->texture[i].name)
+                    M3D_FREE(model->texture[i].name);
+        if (model->inlined)
+            for (i = 0; i < model->numinlined; i++) {
+                if (model->inlined[i].name)
+                    M3D_FREE(model->inlined[i].name);
+                if (model->inlined[i].data)
+                    M3D_FREE(model->inlined[i].data);
+            }
+        if (model->extra)
+            for (i = 0; i < model->numextra; i++)
+                if (model->extra[i])
+                    M3D_FREE(model->extra[i]);
+        if (model->label)
+            for (i = 0; i < model->numlabel; i++) {
+                if (model->label[i].name) {
+                    for (j = i + 1; j < model->numlabel; j++)
+                        if (model->label[j].name == model->label[i].name)
+                            model->label[j].name = NULL;
+                    M3D_FREE(model->label[i].name);
+                }
+                if (model->label[i].lang) {
+                    for (j = i + 1; j < model->numlabel; j++)
+                        if (model->label[j].lang == model->label[i].lang)
+                            model->label[j].lang = NULL;
+                    M3D_FREE(model->label[i].lang);
+                }
+                if (model->label[i].text)
+                    M3D_FREE(model->label[i].text);
+            }
+        if (model->preview.data)
+            M3D_FREE(model->preview.data);
+    }
+    if (model->flags & M3D_FLG_FREERAW) M3D_FREE(model->raw);
+
+    if (model->tmap) M3D_FREE(model->tmap);
+    if (model->bone) {
+        for (i = 0; i < model->numbone; i++)
+            if (model->bone[i].weight)
+                M3D_FREE(model->bone[i].weight);
+        M3D_FREE(model->bone);
+    }
+    if (model->skin) M3D_FREE(model->skin);
+    if (model->vertex) M3D_FREE(model->vertex);
+    if (model->face) M3D_FREE(model->face);
+    if (model->shape) {
+        for (i = 0; i < model->numshape; i++) {
+            if (model->shape[i].cmd) {
+                for (j = 0; j < model->shape[i].numcmd; j++)
+                    if (model->shape[i].cmd[j].arg) M3D_FREE(model->shape[i].cmd[j].arg);
+                M3D_FREE(model->shape[i].cmd);
+            }
+        }
+        M3D_FREE(model->shape);
+    }
+    if (model->material && !(model->flags & M3D_FLG_MTLLIB)) {
+        for (i = 0; i < model->nummaterial; i++)
+            if (model->material[i].prop) M3D_FREE(model->material[i].prop);
+        M3D_FREE(model->material);
+    }
+    if (model->texture) {
+        for (i = 0; i < model->numtexture; i++)
+            if (model->texture[i].d) M3D_FREE(model->texture[i].d);
+        M3D_FREE(model->texture);
+    }
+    if (model->action) {
+        for (i = 0; i < model->numaction; i++) {
+            if (model->action[i].frame) {
+                for (j = 0; j < model->action[i].numframe; j++)
+                    if (model->action[i].frame[j].transform) M3D_FREE(model->action[i].frame[j].transform);
+                M3D_FREE(model->action[i].frame);
+            }
+        }
+        M3D_FREE(model->action);
+    }
+    if (model->label) M3D_FREE(model->label);
+    if (model->inlined) M3D_FREE(model->inlined);
+    if (model->extra) M3D_FREE(model->extra);
+    free(model);
+}
+#endif
+
+#ifdef M3D_EXPORTER
+typedef struct {
+    char *str;
+    uint32_t offs;
+} m3dstr_t;
+
+typedef struct {
+    m3dti_t data;
+    M3D_INDEX oldidx;
+    M3D_INDEX newidx;
+} m3dtisave_t;
+
+typedef struct {
+    m3dv_t data;
+    M3D_INDEX oldidx;
+    M3D_INDEX newidx;
+    unsigned char norm;
+} m3dvsave_t;
+
+typedef struct {
+    m3ds_t data;
+    M3D_INDEX oldidx;
+    M3D_INDEX newidx;
+} m3dssave_t;
+
+typedef struct {
+    m3df_t data;
+    int group;
+    uint8_t opacity;
+} m3dfsave_t;
+
+/* create unique list of strings */
+static m3dstr_t *_m3d_addstr(m3dstr_t *str, uint32_t *numstr, char *s) {
+    uint32_t i;
+    if (!s || !*s) return str;
+    if (str) {
+        for (i = 0; i < *numstr; i++)
+            if (str[i].str == s || !strcmp(str[i].str, s)) return str;
+    }
+    str = (m3dstr_t *)M3D_REALLOC(str, ((*numstr) + 1) * sizeof(m3dstr_t));
+    str[*numstr].str = s;
+    str[*numstr].offs = 0;
+    (*numstr)++;
+    return str;
+}
+
+/* add strings to header */
+m3dhdr_t *_m3d_addhdr(m3dhdr_t *h, m3dstr_t *s) {
+    int i;
+    char *safe = _m3d_safestr(s->str, 0);
+    i = (int)strlen(safe);
+    h = (m3dhdr_t *)M3D_REALLOC(h, h->length + i + 1);
+    if (!h) {
+        M3D_FREE(safe);
+        return NULL;
+    }
+    memcpy((uint8_t *)h + h->length, safe, i + 1);
+    s->offs = h->length - 16;
+    h->length += i + 1;
+    M3D_FREE(safe);
+    return h;
+}
+
+/* return offset of string */
+static uint32_t _m3d_stridx(m3dstr_t *str, uint32_t numstr, char *s) {
+    uint32_t i;
+    char *safe;
+    if (!s || !*s) return 0;
+    if (str) {
+        safe = _m3d_safestr(s, 0);
+        if (!safe) return 0;
+        if (!*safe) {
+            free(safe);
+            return 0;
+        }
+        for (i = 0; i < numstr; i++)
+            if (!strcmp(str[i].str, s)) {
+                free(safe);
+                return str[i].offs;
+            }
+        free(safe);
+    }
+    return 0;
+}
+
+/* compare to faces by their material */
+static int _m3d_facecmp(const void *a, const void *b) {
+    const m3dfsave_t *A = (const m3dfsave_t *)a, *B = (const m3dfsave_t *)b;
+    return A->group != B->group ? A->group - B->group : (A->opacity != B->opacity ? (int)B->opacity - (int)A->opacity : (int)A->data.materialid - (int)B->data.materialid);
+}
+/* compare face groups */
+static int _m3d_grpcmp(const void *a, const void *b) {
+    return *((uint32_t *)a) - *((uint32_t *)b);
+}
+/* compare UVs */
+static int _m3d_ticmp(const void *a, const void *b) {
+    return memcmp(a, b, sizeof(m3dti_t));
+}
+/* compare skin groups */
+static int _m3d_skincmp(const void *a, const void *b) {
+    return memcmp(a, b, sizeof(m3ds_t));
+}
+/* compare vertices */
+static int _m3d_vrtxcmp(const void *a, const void *b) {
+    int c = memcmp(a, b, 3 * sizeof(M3D_FLOAT));
+    if (c) return c;
+    c = ((m3dvsave_t *)a)->norm - ((m3dvsave_t *)b)->norm;
+    if (c) return c;
+    return memcmp(a, b, sizeof(m3dv_t));
+}
+/* compare labels */
+static _inline int _m3d_strcmp(char *a, char *b) {
+    if (a == NULL && b != NULL) return -1;
+    if (a != NULL && b == NULL) return 1;
+    if (a == NULL && b == NULL) return 0;
+    return strcmp(a, b);
+}
+static int _m3d_lblcmp(const void *a, const void *b) {
+    const m3dl_t *A = (const m3dl_t *)a, *B = (const m3dl_t *)b;
+    int c = _m3d_strcmp(A->lang, B->lang);
+    if (!c) c = _m3d_strcmp(A->name, B->name);
+    if (!c) c = _m3d_strcmp(A->text, B->text);
+    return c;
+}
+/* compare two colors by HSV value */
+_inline static int _m3d_cmapcmp(const void *a, const void *b) {
+    uint8_t *A = (uint8_t *)a, *B = (uint8_t *)b;
+    _register int m, vA, vB;
+    /* get HSV value for A */
+    m = A[2] < A[1] ? A[2] : A[1];
+    if (A[0] < m) m = A[0];
+    vA = A[2] > A[1] ? A[2] : A[1];
+    if (A[0] > vA) vA = A[0];
+    /* get HSV value for B */
+    m = B[2] < B[1] ? B[2] : B[1];
+    if (B[0] < m) m = B[0];
+    vB = B[2] > B[1] ? B[2] : B[1];
+    if (B[0] > vB) vB = B[0];
+    return vA - vB;
+}
+
+/* create sorted list of colors */
+static uint32_t *_m3d_addcmap(uint32_t *cmap, uint32_t *numcmap, uint32_t color) {
+    uint32_t i;
+    if (cmap) {
+        for (i = 0; i < *numcmap; i++)
+            if (cmap[i] == color) return cmap;
+    }
+    cmap = (uint32_t *)M3D_REALLOC(cmap, ((*numcmap) + 1) * sizeof(uint32_t));
+    for (i = 0; i < *numcmap && _m3d_cmapcmp(&color, &cmap[i]) > 0; i++)
+        ;
+    if (i < *numcmap) memmove(&cmap[i + 1], &cmap[i], ((*numcmap) - i) * sizeof(uint32_t));
+    cmap[i] = color;
+    (*numcmap)++;
+    return cmap;
+}
+
+/* look up a color and return its index */
+static uint32_t _m3d_cmapidx(uint32_t *cmap, uint32_t numcmap, uint32_t color) {
+    uint32_t i;
+    if (numcmap >= 65536)
+        return color;
+    for (i = 0; i < numcmap; i++)
+        if (cmap[i] == color) return i;
+    return 0;
+}
+
+/* add index to output */
+static unsigned char *_m3d_addidx(unsigned char *out, char type, uint32_t idx) {
+    switch (type) {
+    case 1: *out++ = (uint8_t)(idx); break;
+    case 2:
+        *((uint16_t *)out) = (uint16_t)(idx);
+        out += 2;
+        break;
+    case 4:
+        *((uint32_t *)out) = (uint32_t)(idx);
+        out += 4;
+        break;
+        /* case 0: case 8: break; */
+    }
+    return out;
+}
+
+/* round a vertex position */
+static void _m3d_round(int quality, m3dv_t *src, m3dv_t *dst) {
+    _register int t;
+    /* copy additional attributes */
+    if (src != dst) memcpy(dst, src, sizeof(m3dv_t));
+    /* round according to quality */
+    switch (quality) {
+    case M3D_EXP_INT8:
+        t = (int)(src->x * 127 + (src->x >= 0 ? (M3D_FLOAT)0.5 : (M3D_FLOAT)-0.5));
+        dst->x = (M3D_FLOAT)t / (M3D_FLOAT)127.0;
+        t = (int)(src->y * 127 + (src->y >= 0 ? (M3D_FLOAT)0.5 : (M3D_FLOAT)-0.5));
+        dst->y = (M3D_FLOAT)t / (M3D_FLOAT)127.0;
+        t = (int)(src->z * 127 + (src->z >= 0 ? (M3D_FLOAT)0.5 : (M3D_FLOAT)-0.5));
+        dst->z = (M3D_FLOAT)t / (M3D_FLOAT)127.0;
+        t = (int)(src->w * 127 + (src->w >= 0 ? (M3D_FLOAT)0.5 : (M3D_FLOAT)-0.5));
+        dst->w = (M3D_FLOAT)t / (M3D_FLOAT)127.0;
+        break;
+    case M3D_EXP_INT16:
+        t = (int)(src->x * 32767 + (src->x >= 0 ? (M3D_FLOAT)0.5 : (M3D_FLOAT)-0.5));
+        dst->x = (M3D_FLOAT)t / (M3D_FLOAT)32767.0;
+        t = (int)(src->y * 32767 + (src->y >= 0 ? (M3D_FLOAT)0.5 : (M3D_FLOAT)-0.5));
+        dst->y = (M3D_FLOAT)t / (M3D_FLOAT)32767.0;
+        t = (int)(src->z * 32767 + (src->z >= 0 ? (M3D_FLOAT)0.5 : (M3D_FLOAT)-0.5));
+        dst->z = (M3D_FLOAT)t / (M3D_FLOAT)32767.0;
+        t = (int)(src->w * 32767 + (src->w >= 0 ? (M3D_FLOAT)0.5 : (M3D_FLOAT)-0.5));
+        dst->w = (M3D_FLOAT)t / (M3D_FLOAT)32767.0;
+        break;
+    }
+    if (dst->x == (M3D_FLOAT)-0.0) dst->x = (M3D_FLOAT)0.0;
+    if (dst->y == (M3D_FLOAT)-0.0) dst->y = (M3D_FLOAT)0.0;
+    if (dst->z == (M3D_FLOAT)-0.0) dst->z = (M3D_FLOAT)0.0;
+    if (dst->w == (M3D_FLOAT)-0.0) dst->w = (M3D_FLOAT)0.0;
+}
+
+/* add a bone to ascii output */
+static char *_m3d_prtbone(char *ptr, m3db_t *bone, M3D_INDEX numbone, M3D_INDEX parent, uint32_t level, M3D_INDEX *vrtxidx) {
+    uint32_t i, j;
+    char *sn;
+
+    if (level > M3D_BONEMAXLEVEL || !bone) return ptr;
+    for (i = 0; i < numbone; i++) {
+        if (bone[i].parent == parent) {
+            for (j = 0; j < level; j++)
+                *ptr++ = '/';
+            sn = _m3d_safestr(bone[i].name, 0);
+            ptr += sprintf(ptr, "%d %d %s\r\n", vrtxidx[bone[i].pos], vrtxidx[bone[i].ori], sn);
+            M3D_FREE(sn);
+            ptr = _m3d_prtbone(ptr, bone, numbone, i, level + 1, vrtxidx);
+        }
+    }
+    return ptr;
+}
+
+/**
+ * Function to encode an in-memory model into on storage Model 3D format
+ */
+unsigned char *m3d_save(m3d_t *model, int quality, int flags, unsigned int *size) {
+    const char *ol;
+    char *ptr;
+    char vc_s, vi_s, si_s, ci_s, ti_s, bi_s, nb_s, sk_s, fc_s, hi_s, fi_s;
+    char *sn = NULL, *sl = NULL, *sa = NULL, *sd = NULL;
+    unsigned char *out = NULL, *z = NULL, weights[M3D_NUMBONE], *norm = NULL;
+    unsigned int i = 0, j = 0, k = 0, l = 0, n = 0, len = 0, chunklen = 0, *length = NULL;
+    M3D_FLOAT scale = (M3D_FLOAT)0.0, min_x, max_x, min_y, max_y, min_z, max_z;
+    M3D_INDEX last, *vrtxidx = NULL, *mtrlidx = NULL, *tmapidx = NULL, *skinidx = NULL;
+    uint32_t idx, numcmap = 0, *cmap = NULL, numvrtx = 0, maxvrtx = 0, numtmap = 0, maxtmap = 0, numproc = 0;
+    uint32_t numskin = 0, maxskin = 0, numstr = 0, maxt = 0, maxbone = 0, numgrp = 0, maxgrp = 0, *grpidx = NULL;
+    uint8_t *opa = nullptr;
+    m3dcd_t *cd;
+    m3dc_t *cmd;
+    m3dstr_t *str = NULL;
+    m3dvsave_t *vrtx = NULL, vertex;
+    m3dtisave_t *tmap = NULL, tcoord;
+    m3dssave_t *skin = NULL, sk;
+    m3dfsave_t *face = NULL;
+    m3dhdr_t *h = NULL;
+    m3dm_t *m;
+    m3da_t *a;
+
+    if (!model) {
+        if (size) *size = 0;
+        return NULL;
+    }
+    model->errcode = M3D_SUCCESS;
+    if (flags & M3D_EXP_ASCII) quality = M3D_EXP_DOUBLE;
+    vrtxidx = (M3D_INDEX *)M3D_MALLOC(model->numvertex * sizeof(M3D_INDEX));
+    if (!vrtxidx) goto memerr;
+    memset(vrtxidx, 255, model->numvertex * sizeof(M3D_INDEX));
+    if (model->numvertex && !(flags & M3D_EXP_NONORMAL)) {
+        norm = (unsigned char *)M3D_MALLOC(model->numvertex * sizeof(unsigned char));
+        if (!norm) goto memerr;
+        memset(norm, 0, model->numvertex * sizeof(unsigned char));
+    }
+    if (model->nummaterial && !(flags & M3D_EXP_NOMATERIAL)) {
+        mtrlidx = (M3D_INDEX *)M3D_MALLOC(model->nummaterial * sizeof(M3D_INDEX));
+        if (!mtrlidx) goto memerr;
+        memset(mtrlidx, 255, model->nummaterial * sizeof(M3D_INDEX));
+        opa = (uint8_t *)M3D_MALLOC(model->nummaterial * 2 * sizeof(M3D_INDEX));
+        if (!opa) goto memerr;
+        memset(opa, 255, model->nummaterial * 2 * sizeof(M3D_INDEX));
+    }
+    if (model->numtmap && !(flags & M3D_EXP_NOTXTCRD)) {
+        tmapidx = (M3D_INDEX *)M3D_MALLOC(model->numtmap * sizeof(M3D_INDEX));
+        if (!tmapidx) goto memerr;
+        memset(tmapidx, 255, model->numtmap * sizeof(M3D_INDEX));
+    }
+    /** collect array elements that are actually referenced **/
+    if (!(flags & M3D_EXP_NOFACE)) {
+        /* face */
+        if (model->numface && model->face) {
+            M3D_LOG("Processing mesh face");
+            face = (m3dfsave_t *)M3D_MALLOC(model->numface * sizeof(m3dfsave_t));
+            if (!face) goto memerr;
+            for (i = 0; i < model->numface; i++) {
+                memcpy(&face[i].data, &model->face[i], sizeof(m3df_t));
+                face[i].group = 0;
+                face[i].opacity = 255;
+                if (!(flags & M3D_EXP_NOMATERIAL) && model->face[i].materialid < model->nummaterial) {
+                    if (model->material[model->face[i].materialid].numprop) {
+                        mtrlidx[model->face[i].materialid] = 0;
+                        if (opa[model->face[i].materialid * 2]) {
+                            m = &model->material[model->face[i].materialid];
+                            for (j = 0; j < m->numprop; j++)
+                                if (m->prop[j].type == m3dp_Kd) {
+                                    opa[model->face[i].materialid * 2 + 1] = ((uint8_t *)&m->prop[j].value.color)[3];
+                                    break;
+                                }
+                            for (j = 0; j < m->numprop; j++)
+                                if (m->prop[j].type == m3dp_d) {
+                                    opa[model->face[i].materialid * 2 + 1] = (uint8_t)(m->prop[j].value.fnum * 255);
+                                    break;
+                                }
+                            opa[model->face[i].materialid * 2] = 0;
+                        }
+                        face[i].opacity = opa[model->face[i].materialid * 2 + 1];
+                    } else
+                        face[i].data.materialid = M3D_UNDEF;
+                }
+                for (j = 0; j < 3; j++) {
+                    k = model->face[i].vertex[j];
+                    if (k < model->numvertex)
+                        vrtxidx[k] = 0;
+                    if (!(flags & M3D_EXP_NOCMAP)) {
+                        cmap = _m3d_addcmap(cmap, &numcmap, model->vertex[k].color);
+                        if (!cmap) goto memerr;
+                    }
+                    k = model->face[i].normal[j];
+                    if (k < model->numvertex && !(flags & M3D_EXP_NONORMAL)) {
+                        vrtxidx[k] = 0;
+                        norm[k] = 1;
+                    }
+                    k = model->face[i].texcoord[j];
+                    if (k < model->numtmap && !(flags & M3D_EXP_NOTXTCRD))
+                        tmapidx[k] = 0;
+                }
+                /* convert from CW to CCW */
+                if (flags & M3D_EXP_IDOSUCK) {
+                    j = face[i].data.vertex[1];
+                    face[i].data.vertex[1] = face[i].data.vertex[2];
+                    face[i].data.vertex[2] = face[i].data.vertex[1];
+                    j = face[i].data.normal[1];
+                    face[i].data.normal[1] = face[i].data.normal[2];
+                    face[i].data.normal[2] = face[i].data.normal[1];
+                    j = face[i].data.texcoord[1];
+                    face[i].data.texcoord[1] = face[i].data.texcoord[2];
+                    face[i].data.texcoord[2] = face[i].data.texcoord[1];
+                }
+            }
+        }
+        if (model->numshape && model->shape) {
+            M3D_LOG("Processing shape face");
+            for (i = 0; i < model->numshape; i++) {
+                if (!model->shape[i].numcmd) continue;
+                str = _m3d_addstr(str, &numstr, model->shape[i].name);
+                if (!str) goto memerr;
+                for (j = 0; j < model->shape[i].numcmd; j++) {
+                    cmd = &model->shape[i].cmd[j];
+                    if (cmd->type >= (unsigned int)(sizeof(m3d_commandtypes) / sizeof(m3d_commandtypes[0])) || !cmd->arg)
+                        continue;
+                    if (cmd->type == m3dc_mesh) {
+                        if (numgrp + 2 < maxgrp) {
+                            maxgrp += 1024;
+                            grpidx = (uint32_t *)realloc(grpidx, maxgrp * sizeof(uint32_t));
+                            if (!grpidx) goto memerr;
+                            if (!numgrp) {
+                                grpidx[0] = 0;
+                                grpidx[1] = model->numface;
+                                numgrp += 2;
+                            }
+                        }
+                        grpidx[numgrp + 0] = cmd->arg[0];
+                        grpidx[numgrp + 1] = cmd->arg[0] + cmd->arg[1];
+                        numgrp += 2;
+                    }
+                    cd = &m3d_commandtypes[cmd->type];
+                    for (k = n = 0, l = cd->p; k < l; k++)
+                        switch (cd->a[((k - n) % (cd->p - n)) + n]) {
+                        case m3dcp_mi_t:
+                            if (!(flags & M3D_EXP_NOMATERIAL) && cmd->arg[k] < model->nummaterial)
+                                mtrlidx[cmd->arg[k]] = 0;
+                            break;
+                        case m3dcp_ti_t:
+                            if (!(flags & M3D_EXP_NOTXTCRD) && cmd->arg[k] < model->numtmap)
+                                tmapidx[cmd->arg[k]] = 0;
+                            break;
+                        case m3dcp_qi_t:
+                        case m3dcp_vi_t:
+                            if (cmd->arg[k] < model->numvertex)
+                                vrtxidx[cmd->arg[k]] = 0;
+                            break;
+                        case m3dcp_va_t:
+                            n = k + 1;
+                            l += (cmd->arg[k] - 1) * (cd->p - k - 1);
+                            break;
+                        }
+                }
+            }
+        }
+        if (model->numface && face) {
+            if (numgrp && grpidx) {
+                qsort(grpidx, numgrp, sizeof(uint32_t), _m3d_grpcmp);
+                for (i = j = 0; i < model->numface && j < numgrp; i++) {
+                    while (j < numgrp && grpidx[j] < i)
+                        j++;
+                    face[i].group = j;
+                }
+            }
+            qsort(face, model->numface, sizeof(m3dfsave_t), _m3d_facecmp);
+        }
+        if (grpidx) {
+            M3D_FREE(grpidx);
+            grpidx = NULL;
+        }
+        if (model->numlabel && model->label) {
+            M3D_LOG("Processing annotation labels");
+            for (i = 0; i < model->numlabel; i++) {
+                str = _m3d_addstr(str, &numstr, model->label[i].name);
+                str = _m3d_addstr(str, &numstr, model->label[i].lang);
+                str = _m3d_addstr(str, &numstr, model->label[i].text);
+                if (!(flags & M3D_EXP_NOCMAP)) {
+                    cmap = _m3d_addcmap(cmap, &numcmap, model->label[i].color);
+                    if (!cmap) goto memerr;
+                }
+                if (model->label[i].vertexid < model->numvertex)
+                    vrtxidx[model->label[i].vertexid] = 0;
+            }
+            qsort(model->label, model->numlabel, sizeof(m3dl_t), _m3d_lblcmp);
+        }
+    } else if (!(flags & M3D_EXP_NOMATERIAL)) {
+        /* without a face, simply add all materials, because it can be an mtllib */
+        for (i = 0; i < model->nummaterial; i++)
+            mtrlidx[i] = i;
+    }
+    /* bind-pose skeleton */
+    if (model->numbone && model->bone && !(flags & M3D_EXP_NOBONE)) {
+        M3D_LOG("Processing bones");
+        for (i = 0; i < model->numbone; i++) {
+            str = _m3d_addstr(str, &numstr, model->bone[i].name);
+            if (!str) goto memerr;
+            k = model->bone[i].pos;
+            if (k < model->numvertex)
+                vrtxidx[k] = 0;
+            k = model->bone[i].ori;
+            if (k < model->numvertex)
+                vrtxidx[k] = 0;
+        }
+    }
+    /* actions, animated skeleton poses */
+    if (model->numaction && model->action && !(flags & M3D_EXP_NOACTION)) {
+        M3D_LOG("Processing action list");
+        for (j = 0; j < model->numaction; j++) {
+            a = &model->action[j];
+            str = _m3d_addstr(str, &numstr, a->name);
+            if (!str) goto memerr;
+            if (a->numframe > 65535) a->numframe = 65535;
+            for (i = 0; i < a->numframe; i++) {
+                for (l = 0; l < a->frame[i].numtransform; l++) {
+                    k = a->frame[i].transform[l].pos;
+                    if (k < model->numvertex)
+                        vrtxidx[k] = 0;
+                    k = a->frame[i].transform[l].ori;
+                    if (k < model->numvertex)
+                        vrtxidx[k] = 0;
+                }
+                if (l > maxt) maxt = l;
+            }
+        }
+    }
+    /* add colors to color map and texture names to string table */
+    if (!(flags & M3D_EXP_NOMATERIAL)) {
+        M3D_LOG("Processing materials");
+        for (i = k = 0; i < model->nummaterial; i++) {
+            if (mtrlidx[i] == M3D_UNDEF || !model->material[i].numprop) continue;
+            mtrlidx[i] = k++;
+            m = &model->material[i];
+            str = _m3d_addstr(str, &numstr, m->name);
+            if (!str) goto memerr;
+            if (m->prop)
+                for (j = 0; j < m->numprop; j++) {
+                    if (!(flags & M3D_EXP_NOCMAP) && m->prop[j].type < 128) {
+                        for (l = 0; l < sizeof(m3d_propertytypes) / sizeof(m3d_propertytypes[0]); l++) {
+                            if (m->prop[j].type == m3d_propertytypes[l].id && m3d_propertytypes[l].format == m3dpf_color) {
+                                ((uint8_t *)&m->prop[j].value.color)[3] = opa[i * 2 + 1];
+                                cmap = _m3d_addcmap(cmap, &numcmap, m->prop[j].value.color);
+                                if (!cmap) goto memerr;
+                                break;
+                            }
+                        }
+                    }
+                    if (m->prop[j].type >= 128 && m->prop[j].value.textureid < model->numtexture &&
+                            model->texture[m->prop[j].value.textureid].name) {
+                        str = _m3d_addstr(str, &numstr, model->texture[m->prop[j].value.textureid].name);
+                        if (!str) goto memerr;
+                    }
+                }
+        }
+    }
+    /* if there's only one black color, don't store it */
+    if (numcmap == 1 && cmap && !cmap[0]) numcmap = 0;
+
+    /** compress lists **/
+    if (model->numtmap && !(flags & M3D_EXP_NOTXTCRD)) {
+        M3D_LOG("Compressing tmap");
+        tmap = (m3dtisave_t *)M3D_MALLOC(model->numtmap * sizeof(m3dtisave_t));
+        if (!tmap) goto memerr;
+        for (i = 0; i < model->numtmap; i++) {
+            if (tmapidx[i] == M3D_UNDEF) continue;
+            switch (quality) {
+            case M3D_EXP_INT8:
+                l = (unsigned int)(model->tmap[i].u * 255);
+                tcoord.data.u = (M3D_FLOAT)l / (M3D_FLOAT)255.0;
+                l = (unsigned int)(model->tmap[i].v * 255);
+                tcoord.data.v = (M3D_FLOAT)l / (M3D_FLOAT)255.0;
+                break;
+            case M3D_EXP_INT16:
+                l = (unsigned int)(model->tmap[i].u * 65535);
+                tcoord.data.u = (M3D_FLOAT)l / (M3D_FLOAT)65535.0;
+                l = (unsigned int)(model->tmap[i].v * 65535);
+                tcoord.data.v = (M3D_FLOAT)l / (M3D_FLOAT)65535.0;
+                break;
+            default:
+                tcoord.data.u = model->tmap[i].u;
+                tcoord.data.v = model->tmap[i].v;
+                break;
+            }
+            if (flags & M3D_EXP_FLIPTXTCRD)
+                tcoord.data.v = (M3D_FLOAT)1.0 - tcoord.data.v;
+            tcoord.oldidx = i;
+            memcpy(&tmap[numtmap++], &tcoord, sizeof(m3dtisave_t));
+        }
+        if (numtmap) {
+            qsort(tmap, numtmap, sizeof(m3dtisave_t), _m3d_ticmp);
+            memcpy(&tcoord.data, &tmap[0], sizeof(m3dti_t));
+            for (i = 0; i < numtmap; i++) {
+                if (memcmp(&tcoord.data, &tmap[i].data, sizeof(m3dti_t))) {
+                    memcpy(&tcoord.data, &tmap[i].data, sizeof(m3dti_t));
+                    maxtmap++;
+                }
+                tmap[i].newidx = maxtmap;
+                tmapidx[tmap[i].oldidx] = maxtmap;
+            }
+            maxtmap++;
+        }
+    }
+    if (model->numskin && model->skin && !(flags & M3D_EXP_NOBONE)) {
+        M3D_LOG("Compressing skin");
+        skinidx = (M3D_INDEX *)M3D_MALLOC(model->numskin * sizeof(M3D_INDEX));
+        if (!skinidx) goto memerr;
+        skin = (m3dssave_t *)M3D_MALLOC(model->numskin * sizeof(m3dssave_t));
+        if (!skin) goto memerr;
+        memset(skinidx, 255, model->numskin * sizeof(M3D_INDEX));
+        for (i = 0; i < model->numvertex; i++) {
+            if (vrtxidx[i] != M3D_UNDEF && model->vertex[i].skinid < model->numskin)
+                skinidx[model->vertex[i].skinid] = 0;
+        }
+        for (i = 0; i < model->numskin; i++) {
+            if (skinidx[i] == M3D_UNDEF) continue;
+            memset(&sk, 0, sizeof(m3dssave_t));
+            for (j = 0, min_x = (M3D_FLOAT)0.0; j < M3D_NUMBONE && model->skin[i].boneid[j] != M3D_UNDEF &&
+                                                model->skin[i].weight[j] > (M3D_FLOAT)0.0;
+                    j++) {
+                sk.data.boneid[j] = model->skin[i].boneid[j];
+                sk.data.weight[j] = model->skin[i].weight[j];
+                min_x += sk.data.weight[j];
+            }
+            if (j > maxbone) maxbone = j;
+            if (min_x != (M3D_FLOAT)1.0 && min_x != (M3D_FLOAT)0.0)
+                for (j = 0; j < M3D_NUMBONE && sk.data.weight[j] > (M3D_FLOAT)0.0; j++)
+                    sk.data.weight[j] /= min_x;
+            sk.oldidx = i;
+            memcpy(&skin[numskin++], &sk, sizeof(m3dssave_t));
+        }
+        if (numskin) {
+            qsort(skin, numskin, sizeof(m3dssave_t), _m3d_skincmp);
+            memcpy(&sk.data, &skin[0].data, sizeof(m3ds_t));
+            for (i = 0; i < numskin; i++) {
+                if (memcmp(&sk.data, &skin[i].data, sizeof(m3ds_t))) {
+                    memcpy(&sk.data, &skin[i].data, sizeof(m3ds_t));
+                    maxskin++;
+                }
+                skin[i].newidx = maxskin;
+                skinidx[skin[i].oldidx] = maxskin;
+            }
+            maxskin++;
+        }
+    }
+
+    M3D_LOG("Compressing vertex list");
+    min_x = min_y = min_z = (M3D_FLOAT)1e10;
+    max_x = max_y = max_z = (M3D_FLOAT)-1e10;
+    if (vrtxidx) {
+        vrtx = (m3dvsave_t *)M3D_MALLOC(model->numvertex * sizeof(m3dvsave_t));
+        if (!vrtx) goto memerr;
+        for (i = numvrtx = 0; i < model->numvertex; i++) {
+            if (vrtxidx[i] == M3D_UNDEF) continue;
+            _m3d_round(quality, &model->vertex[i], &vertex.data);
+            vertex.norm = norm ? norm[i] : 0;
+            if (vertex.data.skinid != M3D_INDEXMAX && !vertex.norm) {
+                vertex.data.skinid = vertex.data.skinid != M3D_UNDEF && skinidx ? skinidx[vertex.data.skinid] : M3D_UNDEF;
+                if (vertex.data.x > max_x) max_x = vertex.data.x;
+                if (vertex.data.x < min_x) min_x = vertex.data.x;
+                if (vertex.data.y > max_y) max_y = vertex.data.y;
+                if (vertex.data.y < min_y) min_y = vertex.data.y;
+                if (vertex.data.z > max_z) max_z = vertex.data.z;
+                if (vertex.data.z < min_z) min_z = vertex.data.z;
+            }
+#ifdef M3D_VERTEXTYPE
+            vertex.data.type = 0;
+#endif
+            vertex.oldidx = i;
+            memcpy(&vrtx[numvrtx++], &vertex, sizeof(m3dvsave_t));
+        }
+        if (numvrtx) {
+            qsort(vrtx, numvrtx, sizeof(m3dvsave_t), _m3d_vrtxcmp);
+            memcpy(&vertex.data, &vrtx[0].data, sizeof(m3dv_t));
+            for (i = 0; i < numvrtx; i++) {
+                if (memcmp(&vertex.data, &vrtx[i].data, vrtx[i].norm ? 3 * sizeof(M3D_FLOAT) : sizeof(m3dv_t))) {
+                    memcpy(&vertex.data, &vrtx[i].data, sizeof(m3dv_t));
+                    maxvrtx++;
+                }
+                vrtx[i].newidx = maxvrtx;
+                vrtxidx[vrtx[i].oldidx] = maxvrtx;
+            }
+            maxvrtx++;
+        }
+    }
+    if (skinidx) {
+        M3D_FREE(skinidx);
+        skinidx = NULL;
+    }
+    if (norm) {
+        M3D_FREE(norm);
+        norm = NULL;
+    }
+
+    /* normalize to bounding cube */
+    if (numvrtx && !(flags & M3D_EXP_NORECALC)) {
+        M3D_LOG("Normalizing coordinates");
+        if (min_x < (M3D_FLOAT)0.0) min_x = -min_x;
+        if (max_x < (M3D_FLOAT)0.0) max_x = -max_x;
+        if (min_y < (M3D_FLOAT)0.0) min_y = -min_y;
+        if (max_y < (M3D_FLOAT)0.0) max_y = -max_y;
+        if (min_z < (M3D_FLOAT)0.0) min_z = -min_z;
+        if (max_z < (M3D_FLOAT)0.0) max_z = -max_z;
+        scale = min_x;
+        if (max_x > scale) scale = max_x;
+        if (min_y > scale) scale = min_y;
+        if (max_y > scale) scale = max_y;
+        if (min_z > scale) scale = min_z;
+        if (max_z > scale) scale = max_z;
+        if (scale == (M3D_FLOAT)0.0) scale = (M3D_FLOAT)1.0;
+        if (scale != (M3D_FLOAT)1.0) {
+            for (i = 0; i < numvrtx; i++) {
+                if (vrtx[i].data.skinid == M3D_INDEXMAX) continue;
+                vrtx[i].data.x /= scale;
+                vrtx[i].data.y /= scale;
+                vrtx[i].data.z /= scale;
+            }
+        }
+    }
+    if (model->scale > (M3D_FLOAT)0.0) scale = model->scale;
+    if (scale <= (M3D_FLOAT)0.0) scale = (M3D_FLOAT)1.0;
+
+    /* meta info */
+    sn = _m3d_safestr(model->name && *model->name ? model->name : (char *)"(noname)", 2);
+    sl = _m3d_safestr(model->license ? model->license : (char *)"MIT", 2);
+    sa = _m3d_safestr(model->author ? model->author : getenv("LOGNAME"), 2);
+    if (!sn || !sl || !sa) {
+    memerr:
+        if (vrtxidx) M3D_FREE(vrtxidx);
+        if (mtrlidx) M3D_FREE(mtrlidx);
+        if (tmapidx) M3D_FREE(tmapidx);
+        if (skinidx) M3D_FREE(skinidx);
+        if (grpidx) M3D_FREE(grpidx);
+        if (norm) M3D_FREE(norm);
+        if (face) M3D_FREE(face);
+        if (cmap) M3D_FREE(cmap);
+        if (tmap) M3D_FREE(tmap);
+        if (skin) M3D_FREE(skin);
+        if (str) M3D_FREE(str);
+        if (vrtx) M3D_FREE(vrtx);
+        if (sn) M3D_FREE(sn);
+        if (sl) M3D_FREE(sl);
+        if (sa) M3D_FREE(sa);
+        if (sd) M3D_FREE(sd);
+        if (out) M3D_FREE(out);
+        if (h) M3D_FREE(h);
+        M3D_LOG("Out of memory");
+        model->errcode = M3D_ERR_ALLOC;
+        return NULL;
+    }
+
+    M3D_LOG("Serializing model");
+    if (flags & M3D_EXP_ASCII) {
+        /* use CRLF to make model creators on Win happy... */
+        sd = _m3d_safestr(model->desc, 1);
+        if (!sd) goto memerr;
+        ol = setlocale(LC_NUMERIC, NULL);
+        setlocale(LC_NUMERIC, "C");
+        /* header */
+        len = 64 + (unsigned int)(strlen(sn) + strlen(sl) + strlen(sa) + strlen(sd));
+        out = (unsigned char *)M3D_MALLOC(len);
+        if (!out) {
+            setlocale(LC_NUMERIC, ol);
+            goto memerr;
+        }
+        ptr = (char *)out;
+        ptr += sprintf(ptr, "3dmodel %g\r\n%s\r\n%s\r\n%s\r\n%s\r\n\r\n", scale,
+                sn, sl, sa, sd);
+        M3D_FREE(sl);
+        M3D_FREE(sa);
+        M3D_FREE(sd);
+        sl = sa = sd = NULL;
+        /* preview chunk */
+        if (model->preview.data && model->preview.length) {
+            sl = _m3d_safestr(sn, 0);
+            if (sl) {
+                ptr -= (uintptr_t)out;
+                len = (unsigned int)((uintptr_t)ptr + (uintptr_t)20);
+                out = (unsigned char *)M3D_REALLOC(out, len);
+                ptr += (uintptr_t)out;
+                if (!out) {
+                    setlocale(LC_NUMERIC, ol);
+                    goto memerr;
+                }
+                ptr += sprintf(ptr, "Preview\r\n%s.png\r\n\r\n", sl);
+                M3D_FREE(sl);
+                sl = NULL;
+            }
+        }
+        M3D_FREE(sn);
+        sn = NULL;
+        /* texture map */
+        if (numtmap && tmap && !(flags & M3D_EXP_NOTXTCRD) && !(flags & M3D_EXP_NOFACE)) {
+            ptr -= (uintptr_t)out;
+            len = (unsigned int)((uintptr_t)ptr + (uintptr_t)(maxtmap * 32) + (uintptr_t)12);
+            out = (unsigned char *)M3D_REALLOC(out, len);
+            ptr += (uintptr_t)out;
+            if (!out) {
+                setlocale(LC_NUMERIC, ol);
+                goto memerr;
+            }
+            ptr += sprintf(ptr, "Textmap\r\n");
+            last = M3D_UNDEF;
+            for (i = 0; i < numtmap; i++) {
+                if (tmap[i].newidx == last) continue;
+                last = tmap[i].newidx;
+                ptr += sprintf(ptr, "%g %g\r\n", tmap[i].data.u, tmap[i].data.v);
+            }
+            ptr += sprintf(ptr, "\r\n");
+        }
+        /* vertex chunk */
+        if (numvrtx && vrtx && !(flags & M3D_EXP_NOFACE)) {
+            ptr -= (uintptr_t)out;
+            len = (unsigned int)((uintptr_t)ptr + (uintptr_t)(maxvrtx * 128) + (uintptr_t)10);
+            out = (unsigned char *)M3D_REALLOC(out, len);
+            ptr += (uintptr_t)out;
+            if (!out) {
+                setlocale(LC_NUMERIC, ol);
+                goto memerr;
+            }
+            ptr += sprintf(ptr, "Vertex\r\n");
+            last = M3D_UNDEF;
+            for (i = 0; i < numvrtx; i++) {
+                if (vrtx[i].newidx == last) continue;
+                last = vrtx[i].newidx;
+                ptr += sprintf(ptr, "%g %g %g %g", vrtx[i].data.x, vrtx[i].data.y, vrtx[i].data.z, vrtx[i].data.w);
+                if (!(flags & M3D_EXP_NOCMAP) && vrtx[i].data.color)
+                    ptr += sprintf(ptr, " #%08x", vrtx[i].data.color);
+                if (!(flags & M3D_EXP_NOBONE) && model->numbone && maxskin && vrtx[i].data.skinid < M3D_INDEXMAX) {
+                    if (skin[vrtx[i].data.skinid].data.weight[0] == (M3D_FLOAT)1.0)
+                        ptr += sprintf(ptr, " %d", skin[vrtx[i].data.skinid].data.boneid[0]);
+                    else
+                        for (j = 0; j < M3D_NUMBONE && skin[vrtx[i].data.skinid].data.boneid[j] != M3D_UNDEF &&
+                                    skin[vrtx[i].data.skinid].data.weight[j] > (M3D_FLOAT)0.0;
+                                j++)
+                            ptr += sprintf(ptr, " %d:%g", skin[vrtx[i].data.skinid].data.boneid[j],
+                                    skin[vrtx[i].data.skinid].data.weight[j]);
+                }
+                ptr += sprintf(ptr, "\r\n");
+            }
+            ptr += sprintf(ptr, "\r\n");
+        }
+        /* bones chunk */
+        if (model->numbone && model->bone && !(flags & M3D_EXP_NOBONE)) {
+            ptr -= (uintptr_t)out;
+            len = (unsigned int)((uintptr_t)ptr + (uintptr_t)9);
+            for (i = 0; i < model->numbone; i++) {
+                len += (unsigned int)strlen(model->bone[i].name) + 128;
+            }
+            out = (unsigned char *)M3D_REALLOC(out, len);
+            ptr += (uintptr_t)out;
+            if (!out) {
+                setlocale(LC_NUMERIC, ol);
+                goto memerr;
+            }
+            ptr += sprintf(ptr, "Bones\r\n");
+            ptr = _m3d_prtbone(ptr, model->bone, model->numbone, M3D_UNDEF, 0, vrtxidx);
+            ptr += sprintf(ptr, "\r\n");
+        }
+        /* materials */
+        if (model->nummaterial && !(flags & M3D_EXP_NOMATERIAL)) {
+            for (j = 0; j < model->nummaterial; j++) {
+                if (mtrlidx[j] == M3D_UNDEF || !model->material[j].numprop || !model->material[j].prop) continue;
+                m = &model->material[j];
+                sn = _m3d_safestr(m->name, 0);
+                if (!sn) {
+                    setlocale(LC_NUMERIC, ol);
+                    goto memerr;
+                }
+                ptr -= (uintptr_t)out;
+                len = (unsigned int)((uintptr_t)ptr + (uintptr_t)strlen(sn) + (uintptr_t)12);
+                for (i = 0; i < m->numprop; i++) {
+                    if (m->prop[i].type < 128)
+                        len += 32;
+                    else if (m->prop[i].value.textureid < model->numtexture && model->texture[m->prop[i].value.textureid].name)
+                        len += (unsigned int)strlen(model->texture[m->prop[i].value.textureid].name) + 16;
+                }
+                out = (unsigned char *)M3D_REALLOC(out, len);
+                ptr += (uintptr_t)out;
+                if (!out) {
+                    setlocale(LC_NUMERIC, ol);
+                    goto memerr;
+                }
+                ptr += sprintf(ptr, "Material %s\r\n", sn);
+                M3D_FREE(sn);
+                sn = NULL;
+                for (i = 0; i < m->numprop; i++) {
+                    k = 256;
+                    if (m->prop[i].type >= 128) {
+                        for (l = 0; l < sizeof(m3d_propertytypes) / sizeof(m3d_propertytypes[0]); l++)
+                            if (m->prop[i].type == m3d_propertytypes[l].id) {
+                                sn = m3d_propertytypes[l].key;
+                                break;
+                            }
+                        if (!sn)
+                            for (l = 0; l < sizeof(m3d_propertytypes) / sizeof(m3d_propertytypes[0]); l++)
+                                if (m->prop[i].type - 128 == m3d_propertytypes[l].id) {
+                                    sn = m3d_propertytypes[l].key;
+                                    break;
+                                }
+                        k = sn ? m3dpf_map : 256;
+                    } else {
+                        for (l = 0; l < sizeof(m3d_propertytypes) / sizeof(m3d_propertytypes[0]); l++)
+                            if (m->prop[i].type == m3d_propertytypes[l].id) {
+                                sn = m3d_propertytypes[l].key;
+                                k = m3d_propertytypes[l].format;
+                                break;
+                            }
+                    }
+                    switch (k) {
+                    case m3dpf_color: ptr += sprintf(ptr, "%s #%08x\r\n", sn, m->prop[i].value.color); break;
+                    case m3dpf_uint8:
+                    case m3dpf_uint16:
+                    case m3dpf_uint32: ptr += sprintf(ptr, "%s %d\r\n", sn, m->prop[i].value.num); break;
+                    case m3dpf_float: ptr += sprintf(ptr, "%s %g\r\n", sn, m->prop[i].value.fnum); break;
+                    case m3dpf_map:
+                        if (m->prop[i].value.textureid < model->numtexture &&
+                                model->texture[m->prop[i].value.textureid].name) {
+                            sl = _m3d_safestr(model->texture[m->prop[i].value.textureid].name, 0);
+                            if (!sl) {
+                                setlocale(LC_NUMERIC, ol);
+                                goto memerr;
+                            }
+                            if (*sl)
+                                ptr += sprintf(ptr, "map_%s %s\r\n", sn, sl);
+                            M3D_FREE(sn);
+                            M3D_FREE(sl);
+                            sl = NULL;
+                        }
+                        break;
+                    }
+                    sn = NULL;
+                }
+                ptr += sprintf(ptr, "\r\n");
+            }
+        }
+        /* procedural face */
+        if (model->numinlined && model->inlined && !(flags & M3D_EXP_NOFACE)) {
+            /* all inlined assets which are not textures should be procedural surfaces */
+            for (j = 0; j < model->numinlined; j++) {
+                if (!model->inlined[j].name || !*model->inlined[j].name || !model->inlined[j].length || !model->inlined[j].data ||
+                        (model->inlined[j].data[1] == 'P' && model->inlined[j].data[2] == 'N' && model->inlined[j].data[3] == 'G'))
+                    continue;
+                for (i = k = 0; i < model->numtexture; i++) {
+                    if (!strcmp(model->inlined[j].name, model->texture[i].name)) {
+                        k = 1;
+                        break;
+                    }
+                }
+                if (k) continue;
+                sn = _m3d_safestr(model->inlined[j].name, 0);
+                if (!sn) {
+                    setlocale(LC_NUMERIC, ol);
+                    goto memerr;
+                }
+                ptr -= (uintptr_t)out;
+                len = (unsigned int)((uintptr_t)ptr + (uintptr_t)strlen(sn) + (uintptr_t)18);
+                out = (unsigned char *)M3D_REALLOC(out, len);
+                ptr += (uintptr_t)out;
+                if (!out) {
+                    setlocale(LC_NUMERIC, ol);
+                    goto memerr;
+                }
+                ptr += sprintf(ptr, "Procedural\r\n%s\r\n\r\n", sn);
+                M3D_FREE(sn);
+                sn = NULL;
+            }
+        }
+        /* mesh face */
+        if (model->numface && face && !(flags & M3D_EXP_NOFACE)) {
+            ptr -= (uintptr_t)out;
+            len = (unsigned int)((uintptr_t)ptr + (uintptr_t)(model->numface * 128) + (uintptr_t)6);
+            last = M3D_UNDEF;
+            if (!(flags & M3D_EXP_NOMATERIAL))
+                for (i = 0; i < model->numface; i++) {
+                    j = face[i].data.materialid < model->nummaterial ? face[i].data.materialid : M3D_UNDEF;
+                    if (j != last) {
+                        last = j;
+                        if (last < model->nummaterial)
+                            len += (unsigned int)strlen(model->material[last].name);
+                        len += 6;
+                    }
+                }
+            out = (unsigned char *)M3D_REALLOC(out, len);
+            ptr += (uintptr_t)out;
+            if (!out) {
+                setlocale(LC_NUMERIC, ol);
+                goto memerr;
+            }
+            ptr += sprintf(ptr, "Mesh\r\n");
+            last = M3D_UNDEF;
+            for (i = 0; i < model->numface; i++) {
+                j = face[i].data.materialid < model->nummaterial ? face[i].data.materialid : M3D_UNDEF;
+                if (!(flags & M3D_EXP_NOMATERIAL) && j != last) {
+                    last = j;
+                    if (last < model->nummaterial) {
+                        sn = _m3d_safestr(model->material[last].name, 0);
+                        if (!sn) {
+                            setlocale(LC_NUMERIC, ol);
+                            goto memerr;
+                        }
+                        ptr += sprintf(ptr, "use %s\r\n", sn);
+                        M3D_FREE(sn);
+                        sn = NULL;
+                    } else
+                        ptr += sprintf(ptr, "use\r\n");
+                }
+                /* hardcoded triangles. Should be repeated as many times as the number of edges in polygon */
+                for (j = 0; j < 3; j++) {
+                    ptr += sprintf(ptr, "%s%d", j ? " " : "", vrtxidx[face[i].data.vertex[j]]);
+                    k = M3D_NOTDEFINED;
+                    if (!(flags & M3D_EXP_NOTXTCRD) && (face[i].data.texcoord[j] != M3D_UNDEF) &&
+                            (tmapidx[face[i].data.texcoord[j]] != M3D_UNDEF)) {
+                        k = tmapidx[face[i].data.texcoord[j]];
+                        ptr += sprintf(ptr, "/%d", k);
+                    }
+                    if (!(flags & M3D_EXP_NONORMAL) && (face[i].data.normal[j] != M3D_UNDEF))
+                        ptr += sprintf(ptr, "%s/%d", k == M3D_NOTDEFINED ? "/" : "", vrtxidx[face[i].data.normal[j]]);
+                }
+                ptr += sprintf(ptr, "\r\n");
+            }
+            ptr += sprintf(ptr, "\r\n");
+        }
+        /* mathematical shapes face */
+        if (model->numshape && (!(flags & M3D_EXP_NOFACE))) {
+            for (j = 0; j < model->numshape; j++) {
+                sn = _m3d_safestr(model->shape[j].name, 0);
+                if (!sn) {
+                    setlocale(LC_NUMERIC, ol);
+                    goto memerr;
+                }
+                ptr -= (uintptr_t)out;
+                len = (unsigned int)((uintptr_t)ptr + (uintptr_t)strlen(sn) + (uintptr_t)33);
+                out = (unsigned char *)M3D_REALLOC(out, len);
+                ptr += (uintptr_t)out;
+                if (!out) {
+                    setlocale(LC_NUMERIC, ol);
+                    goto memerr;
+                }
+                ptr += sprintf(ptr, "Shape %s\r\n", sn);
+                M3D_FREE(sn);
+                sn = NULL;
+                if (model->shape[j].group != M3D_UNDEF && !(flags & M3D_EXP_NOBONE))
+                    ptr += sprintf(ptr, "group %d\r\n", model->shape[j].group);
+                for (i = 0; i < model->shape[j].numcmd; i++) {
+                    cmd = &model->shape[j].cmd[i];
+                    if (cmd->type >= (unsigned int)(sizeof(m3d_commandtypes) / sizeof(m3d_commandtypes[0])) || !cmd->arg)
+                        continue;
+                    cd = &m3d_commandtypes[cmd->type];
+                    ptr -= (uintptr_t)out;
+                    len = (unsigned int)((uintptr_t)ptr + (uintptr_t)strlen(cd->key) + (uintptr_t)3);
+                    for (k = 0; k < cd->p; k++)
+                        switch (cd->a[k]) {
+                        case m3dcp_mi_t:
+                            if (cmd->arg[k] != M3D_NOTDEFINED) {
+                                len += (unsigned int)strlen(model->material[cmd->arg[k]].name) + 1;
+                            }
+                            break;
+                        case m3dcp_va_t:
+                            len += cmd->arg[k] * (cd->p - k - 1) * 16;
+                            k = cd->p;
+                            break;
+                        default: len += 16; break;
+                        }
+                    out = (unsigned char *)M3D_REALLOC(out, len);
+                    ptr += (uintptr_t)out;
+                    if (!out) {
+                        setlocale(LC_NUMERIC, ol);
+                        goto memerr;
+                    }
+                    ptr += sprintf(ptr, "%s", cd->key);
+                    for (k = n = 0, l = cd->p; k < l; k++) {
+                        switch (cd->a[((k - n) % (cd->p - n)) + n]) {
+                        case m3dcp_mi_t:
+                            if (cmd->arg[k] != M3D_NOTDEFINED) {
+                                sn = _m3d_safestr(model->material[cmd->arg[k]].name, 0);
+                                if (!sn) {
+                                    setlocale(LC_NUMERIC, ol);
+                                    goto memerr;
+                                }
+                                ptr += sprintf(ptr, " %s", sn);
+                                M3D_FREE(sn);
+                                sn = NULL;
+                            }
+                            break;
+                        case m3dcp_vc_t: ptr += sprintf(ptr, " %g", *((float *)&cmd->arg[k])); break;
+                        case m3dcp_va_t:
+                            ptr += sprintf(ptr, " %d[", cmd->arg[k]);
+                            n = k + 1;
+                            l += (cmd->arg[k] - 1) * (cd->p - k - 1);
+                            break;
+                        default: ptr += sprintf(ptr, " %d", cmd->arg[k]); break;
+                        }
+                    }
+                    ptr += sprintf(ptr, "%s\r\n", l > cd->p ? " ]" : "");
+                }
+                ptr += sprintf(ptr, "\r\n");
+            }
+        }
+        /* annotation labels */
+        if (model->numlabel && model->label && !(flags & M3D_EXP_NOFACE)) {
+            for (i = 0, j = 3, length = NULL; i < model->numlabel; i++) {
+                if (model->label[i].name) j += (unsigned int)strlen(model->label[i].name);
+                if (model->label[i].lang) j += (unsigned int)strlen(model->label[i].lang);
+                if (model->label[i].text) j += (unsigned int)strlen(model->label[i].text);
+                j += 40;
+            }
+            ptr -= (uintptr_t)out;
+            len = (unsigned int)((uintptr_t)ptr + (uintptr_t)j);
+            out = (unsigned char *)M3D_REALLOC(out, len);
+            ptr += (uintptr_t)out;
+            if (!out) {
+                setlocale(LC_NUMERIC, ol);
+                goto memerr;
+            }
+            for (i = 0; i < model->numlabel; i++) {
+                if (!i || _m3d_strcmp(sl, model->label[i].lang) || _m3d_strcmp(sn, model->label[i].name)) {
+                    sl = model->label[i].lang;
+                    sn = model->label[i].name;
+                    sd = _m3d_safestr(sn, 0);
+                    if (!sd) {
+                        setlocale(LC_NUMERIC, ol);
+                        sn = sl = NULL;
+                        goto memerr;
+                    }
+                    if (i) ptr += sprintf(ptr, "\r\n");
+                    ptr += sprintf(ptr, "Labels %s\r\n", sd);
+                    M3D_FREE(sd);
+                    sd = NULL;
+                    if (model->label[i].color)
+                        ptr += sprintf(ptr, "color #0x%08x\r\n", model->label[i].color);
+                    if (sl && *sl) {
+                        sd = _m3d_safestr(sl, 0);
+                        if (!sd) {
+                            setlocale(LC_NUMERIC, ol);
+                            sn = sl = NULL;
+                            goto memerr;
+                        }
+                        ptr += sprintf(ptr, "lang %s\r\n", sd);
+                        M3D_FREE(sd);
+                        sd = NULL;
+                    }
+                }
+                sd = _m3d_safestr(model->label[i].text, 2);
+                if (!sd) {
+                    setlocale(LC_NUMERIC, ol);
+                    sn = sl = NULL;
+                    goto memerr;
+                }
+                ptr += sprintf(ptr, "%d %s\r\n", model->label[i].vertexid, sd);
+                M3D_FREE(sd);
+                sd = NULL;
+            }
+            ptr += sprintf(ptr, "\r\n");
+            sn = sl = NULL;
+        }
+        /* actions */
+        if (model->numaction && model->action && !(flags & M3D_EXP_NOACTION)) {
+            for (j = 0; j < model->numaction; j++) {
+                a = &model->action[j];
+                sn = _m3d_safestr(a->name, 0);
+                if (!sn) {
+                    setlocale(LC_NUMERIC, ol);
+                    goto memerr;
+                }
+                ptr -= (uintptr_t)out;
+                len = (unsigned int)((uintptr_t)ptr + (uintptr_t)strlen(sn) + (uintptr_t)48);
+                for (i = 0; i < a->numframe; i++)
+                    len += a->frame[i].numtransform * 128 + 8;
+                out = (unsigned char *)M3D_REALLOC(out, len);
+                ptr += (uintptr_t)out;
+                if (!out) {
+                    setlocale(LC_NUMERIC, ol);
+                    goto memerr;
+                }
+                ptr += sprintf(ptr, "Action %d %s\r\n", a->durationmsec, sn);
+                M3D_FREE(sn);
+                sn = NULL;
+                for (i = 0; i < a->numframe; i++) {
+                    ptr += sprintf(ptr, "frame %d\r\n", a->frame[i].msec);
+                    for (k = 0; k < a->frame[i].numtransform; k++) {
+                        ptr += sprintf(ptr, "%d %d %d\r\n", a->frame[i].transform[k].boneid,
+                                vrtxidx[a->frame[i].transform[k].pos], vrtxidx[a->frame[i].transform[k].ori]);
+                    }
+                }
+                ptr += sprintf(ptr, "\r\n");
+            }
+        }
+        /* inlined assets */
+        if (model->numinlined && model->inlined) {
+            for (i = j = 0; i < model->numinlined; i++)
+                if (model->inlined[i].name)
+                    j += (unsigned int)strlen(model->inlined[i].name) + 6;
+            if (j > 0) {
+                ptr -= (uintptr_t)out;
+                len = (unsigned int)((uintptr_t)ptr + (uintptr_t)j + (uintptr_t)16);
+                out = (unsigned char *)M3D_REALLOC(out, len);
+                ptr += (uintptr_t)out;
+                if (!out) {
+                    setlocale(LC_NUMERIC, ol);
+                    goto memerr;
+                }
+                ptr += sprintf(ptr, "Assets\r\n");
+                for (i = 0; i < model->numinlined; i++)
+                    if (model->inlined[i].name)
+                        ptr += sprintf(ptr, "%s%s\r\n", model->inlined[i].name, strrchr(model->inlined[i].name, '.') ? "" : ".png");
+                ptr += sprintf(ptr, "\r\n");
+            }
+        }
+        /* extra info */
+        if (model->numextra && (flags & M3D_EXP_EXTRA)) {
+            for (i = 0; i < model->numextra; i++) {
+                if (model->extra[i]->length < 9) continue;
+                ptr -= (uintptr_t)out;
+                len = (unsigned int)((uintptr_t)ptr + (uintptr_t)17 + (uintptr_t)(model->extra[i]->length * 3));
+                out = (unsigned char *)M3D_REALLOC(out, len);
+                ptr += (uintptr_t)out;
+                if (!out) {
+                    setlocale(LC_NUMERIC, ol);
+                    goto memerr;
+                }
+                ptr += sprintf(ptr, "Extra %c%c%c%c\r\n",
+                        model->extra[i]->magic[0] > ' ' ? model->extra[i]->magic[0] : '_',
+                        model->extra[i]->magic[1] > ' ' ? model->extra[i]->magic[1] : '_',
+                        model->extra[i]->magic[2] > ' ' ? model->extra[i]->magic[2] : '_',
+                        model->extra[i]->magic[3] > ' ' ? model->extra[i]->magic[3] : '_');
+                for (j = 0; j < model->extra[i]->length; j++)
+                    ptr += sprintf(ptr, "%02x ", *((unsigned char *)model->extra + sizeof(m3dchunk_t) + j));
+                ptr--;
+                ptr += sprintf(ptr, "\r\n\r\n");
+            }
+        }
+        setlocale(LC_NUMERIC, ol);
+        len = (unsigned int)((uintptr_t)ptr - (uintptr_t)out);
+        out = (unsigned char *)M3D_REALLOC(out, len + 1);
+        if (!out) goto memerr;
+        out[len] = 0;
+    } else
+    {
+        /* strictly only use LF (newline) in binary */
+        sd = _m3d_safestr(model->desc, 3);
+        if (!sd) goto memerr;
+        /* header */
+        h = (m3dhdr_t *)M3D_MALLOC(sizeof(m3dhdr_t) + strlen(sn) + strlen(sl) + strlen(sa) + strlen(sd) + 4);
+        if (!h) goto memerr;
+        memcpy((uint8_t *)h, "HEAD", 4);
+        h->length = sizeof(m3dhdr_t);
+        h->scale = scale;
+        i = (unsigned int)strlen(sn);
+        memcpy((uint8_t *)h + h->length, sn, i + 1);
+        h->length += i + 1;
+        M3D_FREE(sn);
+        i = (unsigned int)strlen(sl);
+        memcpy((uint8_t *)h + h->length, sl, i + 1);
+        h->length += i + 1;
+        M3D_FREE(sl);
+        i = (unsigned int)strlen(sa);
+        memcpy((uint8_t *)h + h->length, sa, i + 1);
+        h->length += i + 1;
+        M3D_FREE(sa);
+        i = (unsigned int)strlen(sd);
+        memcpy((uint8_t *)h + h->length, sd, i + 1);
+        h->length += i + 1;
+        M3D_FREE(sd);
+        sn = sl = sa = sd = NULL;
+        if (model->inlined)
+            for (i = 0; i < model->numinlined; i++) {
+                if (model->inlined[i].name && *model->inlined[i].name && model->inlined[i].length > 0) {
+                    str = _m3d_addstr(str, &numstr, model->inlined[i].name);
+                    if (!str) goto memerr;
+                }
+            }
+        if (str)
+            for (i = 0; i < numstr; i++) {
+                h = _m3d_addhdr(h, &str[i]);
+                if (!h) goto memerr;
+            }
+        vc_s = quality == M3D_EXP_INT8 ? 1 : (quality == M3D_EXP_INT16 ? 2 : (quality == M3D_EXP_DOUBLE ? 8 : 4));
+        vi_s = maxvrtx < 254 ? 1 : (maxvrtx < 65534 ? 2 : 4);
+        si_s = h->length - 16 < 254 ? 1 : (h->length - 16 < 65534 ? 2 : 4);
+        ci_s = !numcmap || !cmap ? 0 : (numcmap < 254 ? 1 : (numcmap < 65534 ? 2 : 4));
+        ti_s = !maxtmap || !tmap ? 0 : (maxtmap < 254 ? 1 : (maxtmap < 65534 ? 2 : 4));
+        bi_s = !model->numbone || !model->bone || (flags & M3D_EXP_NOBONE) ? 0 : (model->numbone < 254 ? 1 : (model->numbone < 65534 ? 2 : 4));
+        nb_s = maxbone < 2 ? 1 : (maxbone == 2 ? 2 : (maxbone <= 4 ? 4 : 8));
+        sk_s = !bi_s || !maxskin || !skin ? 0 : (maxskin < 254 ? 1 : (maxskin < 65534 ? 2 : 4));
+        fc_s = maxt < 254 ? 1 : (maxt < 65534 ? 2 : 4);
+        hi_s = !model->numshape || !model->shape || (flags & M3D_EXP_NOFACE) ? 0 : (model->numshape < 254 ? 1 : (model->numshape < 65534 ? 2 : 4));
+        fi_s = !model->numface || !model->face || (flags & M3D_EXP_NOFACE) ? 0 : (model->numface < 254 ? 1 : (model->numface < 65534 ? 2 : 4));
+        h->types = (vc_s == 8 ? (3 << 0) : (vc_s == 2 ? (1 << 0) : (vc_s == 1 ? (0 << 0) : (2 << 0)))) |
+                   (vi_s == 2 ? (1 << 2) : (vi_s == 1 ? (0 << 2) : (2 << 2))) |
+                   (si_s == 2 ? (1 << 4) : (si_s == 1 ? (0 << 4) : (2 << 4))) |
+                   (ci_s == 2 ? (1 << 6) : (ci_s == 1 ? (0 << 6) : (ci_s == 4 ? (2 << 6) : (3 << 6)))) |
+                   (ti_s == 2 ? (1 << 8) : (ti_s == 1 ? (0 << 8) : (ti_s == 4 ? (2 << 8) : (3 << 8)))) |
+                   (bi_s == 2 ? (1 << 10) : (bi_s == 1 ? (0 << 10) : (bi_s == 4 ? (2 << 10) : (3 << 10)))) |
+                   (nb_s == 2 ? (1 << 12) : (nb_s == 1 ? (0 << 12) : (2 << 12))) |
+                   (sk_s == 2 ? (1 << 14) : (sk_s == 1 ? (0 << 14) : (sk_s == 4 ? (2 << 14) : (3 << 14)))) |
+                   (fc_s == 2 ? (1 << 16) : (fc_s == 1 ? (0 << 16) : (2 << 16))) |
+                   (hi_s == 2 ? (1 << 18) : (hi_s == 1 ? (0 << 18) : (hi_s == 4 ? (2 << 18) : (3 << 18)))) |
+                   (fi_s == 2 ? (1 << 20) : (fi_s == 1 ? (0 << 20) : (fi_s == 4 ? (2 << 20) : (3 << 20))));
+        len = h->length;
+        /* preview image chunk, must be the first if exists */
+        if (model->preview.data && model->preview.length) {
+            chunklen = 8 + model->preview.length;
+            h = (m3dhdr_t *)M3D_REALLOC(h, len + chunklen);
+            if (!h) goto memerr;
+            memcpy((uint8_t *)h + len, "PRVW", 4);
+            *((uint32_t *)((uint8_t *)h + len + 4)) = chunklen;
+            memcpy((uint8_t *)h + len + 8, model->preview.data, model->preview.length);
+            len += chunklen;
+        }
+        /* color map */
+        if (numcmap && cmap && ci_s < 4 && !(flags & M3D_EXP_NOCMAP)) {
+            chunklen = 8 + numcmap * sizeof(uint32_t);
+            h = (m3dhdr_t *)M3D_REALLOC(h, len + chunklen);
+            if (!h) goto memerr;
+            memcpy((uint8_t *)h + len, "CMAP", 4);
+            *((uint32_t *)((uint8_t *)h + len + 4)) = chunklen;
+            memcpy((uint8_t *)h + len + 8, cmap, chunklen - 8);
+            len += chunklen;
+        } else
+            numcmap = 0;
+        /* texture map */
+        if (numtmap && tmap && !(flags & M3D_EXP_NOTXTCRD) && !(flags & M3D_EXP_NOFACE)) {
+            chunklen = 8 + maxtmap * vc_s * 2;
+            h = (m3dhdr_t *)M3D_REALLOC(h, len + chunklen);
+            if (!h) goto memerr;
+            memcpy((uint8_t *)h + len, "TMAP", 4);
+            length = (uint32_t *)((uint8_t *)h + len + 4);
+            out = (uint8_t *)h + len + 8;
+            last = M3D_UNDEF;
+            for (i = 0; i < numtmap; i++) {
+                if (tmap[i].newidx == last) continue;
+                last = tmap[i].newidx;
+                switch (vc_s) {
+                case 1:
+                    *out++ = (uint8_t)(tmap[i].data.u * 255);
+                    *out++ = (uint8_t)(tmap[i].data.v * 255);
+                    break;
+                case 2:
+                    *((uint16_t *)out) = (uint16_t)(tmap[i].data.u * 65535);
+                    out += 2;
+                    *((uint16_t *)out) = (uint16_t)(tmap[i].data.v * 65535);
+                    out += 2;
+                    break;
+                case 4:
+                    *((float *)out) = tmap[i].data.u;
+                    out += 4;
+                    *((float *)out) = tmap[i].data.v;
+                    out += 4;
+                    break;
+                case 8:
+                    *((double *)out) = tmap[i].data.u;
+                    out += 8;
+                    *((double *)out) = tmap[i].data.v;
+                    out += 8;
+                    break;
+                }
+            }
+            *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
+            out = NULL;
+            len += *length;
+        }
+        /* vertex */
+        if (numvrtx && vrtx) {
+            chunklen = 8 + maxvrtx * (ci_s + sk_s + 4 * vc_s);
+            h = (m3dhdr_t *)M3D_REALLOC(h, len + chunklen);
+            if (!h) goto memerr;
+            memcpy((uint8_t *)h + len, "VRTS", 4);
+            length = (uint32_t *)((uint8_t *)h + len + 4);
+            out = (uint8_t *)h + len + 8;
+            last = M3D_UNDEF;
+            for (i = 0; i < numvrtx; i++) {
+                if (vrtx[i].newidx == last) continue;
+                last = vrtx[i].newidx;
+                switch (vc_s) {
+                case 1:
+                    *out++ = (int8_t)(vrtx[i].data.x * 127);
+                    *out++ = (int8_t)(vrtx[i].data.y * 127);
+                    *out++ = (int8_t)(vrtx[i].data.z * 127);
+                    *out++ = (int8_t)(vrtx[i].data.w * 127);
+                    break;
+                case 2:
+                    *((int16_t *)out) = (int16_t)(vrtx[i].data.x * 32767);
+                    out += 2;
+                    *((int16_t *)out) = (int16_t)(vrtx[i].data.y * 32767);
+                    out += 2;
+                    *((int16_t *)out) = (int16_t)(vrtx[i].data.z * 32767);
+                    out += 2;
+                    *((int16_t *)out) = (int16_t)(vrtx[i].data.w * 32767);
+                    out += 2;
+                    break;
+                case 4:
+                    memcpy(out, &vrtx[i].data.x, sizeof(float));
+                    out += 4;
+                    memcpy(out, &vrtx[i].data.y, sizeof(float));
+                    out += 4;
+                    memcpy(out, &vrtx[i].data.z, sizeof(float));
+                    out += 4;
+                    memcpy(out, &vrtx[i].data.w, sizeof(float));
+                    out += 4;
+                    break;
+                case 8:
+                    *((double *)out) = vrtx[i].data.x;
+                    out += 8;
+                    *((double *)out) = vrtx[i].data.y;
+                    out += 8;
+                    *((double *)out) = vrtx[i].data.z;
+                    out += 8;
+                    *((double *)out) = vrtx[i].data.w;
+                    out += 8;
+                    break;
+                }
+                idx = _m3d_cmapidx(cmap, numcmap, vrtx[i].data.color);
+                switch (ci_s) {
+                case 1: *out++ = (uint8_t)(idx); break;
+                case 2:
+                    *((uint16_t *)out) = (uint16_t)(idx);
+                    out += 2;
+                    break;
+                case 4:
+                    *((uint32_t *)out) = vrtx[i].data.color;
+                    out += 4;
+                    break;
+                }
+                out = _m3d_addidx(out, sk_s, vrtx[i].data.skinid);
+            }
+            uint32_t v = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
+            memcpy(length, &v, sizeof(uint32_t));
+            //*length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
+            out = NULL;
+            len += v;
+        }
+        /* bones chunk */
+        if (model->numbone && model->bone && !(flags & M3D_EXP_NOBONE)) {
+            i = 8 + bi_s + sk_s + model->numbone * (bi_s + si_s + 2 * vi_s);
+            chunklen = i + numskin * nb_s * (bi_s + 1);
+            h = (m3dhdr_t *)M3D_REALLOC(h, len + chunklen);
+            if (!h) goto memerr;
+            memcpy((uint8_t *)h + len, "BONE", 4);
+            length = (uint32_t *)((uint8_t *)h + len + 4);
+            out = (uint8_t *)h + len + 8;
+            out = _m3d_addidx(out, bi_s, model->numbone);
+            out = _m3d_addidx(out, sk_s, maxskin);
+            for (i = 0; i < model->numbone; i++) {
+                out = _m3d_addidx(out, bi_s, model->bone[i].parent);
+                out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, model->bone[i].name));
+                out = _m3d_addidx(out, vi_s, vrtxidx[model->bone[i].pos]);
+                out = _m3d_addidx(out, vi_s, vrtxidx[model->bone[i].ori]);
+            }
+            if (numskin && skin && sk_s) {
+                last = M3D_UNDEF;
+                for (i = 0; i < numskin; i++) {
+                    if (skin[i].newidx == last) continue;
+                    last = skin[i].newidx;
+                    memset(&weights, 0, nb_s);
+                    for (j = 0; j < (uint32_t)nb_s && skin[i].data.boneid[j] != M3D_UNDEF &&
+                                skin[i].data.weight[j] > (M3D_FLOAT)0.0;
+                            j++)
+                        weights[j] = (uint8_t)(skin[i].data.weight[j] * 255);
+                    switch (nb_s) {
+                    case 1: weights[0] = 255; break;
+                    case 2:
+                        *((uint16_t *)out) = *((uint16_t *)&weights[0]);
+                        out += 2;
+                        break;
+                    case 4:
+                        *((uint32_t *)out) = *((uint32_t *)&weights[0]);
+                        out += 4;
+                        break;
+                    case 8:
+                        *((uint64_t *)out) = *((uint64_t *)&weights[0]);
+                        out += 8;
+                        break;
+                    }
+                    for (j = 0; j < (uint32_t)nb_s && skin[i].data.boneid[j] != M3D_UNDEF && weights[j]; j++) {
+                        out = _m3d_addidx(out, bi_s, skin[i].data.boneid[j]);
+                        *length += bi_s;
+                    }
+                }
+            }
+            *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
+            out = NULL;
+            len += *length;
+        }
+        /* materials */
+        if (model->nummaterial && !(flags & M3D_EXP_NOMATERIAL)) {
+            for (j = 0; j < model->nummaterial; j++) {
+                if (mtrlidx[j] == M3D_UNDEF || !model->material[j].numprop || !model->material[j].prop) continue;
+                m = &model->material[j];
+                chunklen = 12 + si_s + m->numprop * 5;
+                h = (m3dhdr_t *)M3D_REALLOC(h, len + chunklen);
+                if (!h) goto memerr;
+                memcpy((uint8_t *)h + len, "MTRL", 4);
+                length = (uint32_t *)((uint8_t *)h + len + 4);
+                out = (uint8_t *)h + len + 8;
+                out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, m->name));
+                for (i = 0; i < m->numprop; i++) {
+                    if (m->prop[i].type >= 128) {
+                        if (m->prop[i].value.textureid >= model->numtexture ||
+                                !model->texture[m->prop[i].value.textureid].name) continue;
+                        k = m3dpf_map;
+                    } else {
+                        for (k = 256, l = 0; l < sizeof(m3d_propertytypes) / sizeof(m3d_propertytypes[0]); l++)
+                            if (m->prop[i].type == m3d_propertytypes[l].id) {
+                                k = m3d_propertytypes[l].format;
+                                break;
+                            }
+                    }
+                    if (k == 256) continue;
+                    *out++ = m->prop[i].type;
+                    switch (k) {
+                    case m3dpf_color:
+                        if (!(flags & M3D_EXP_NOCMAP)) {
+                            idx = _m3d_cmapidx(cmap, numcmap, m->prop[i].value.color);
+                            switch (ci_s) {
+                            case 1: *out++ = (uint8_t)(idx); break;
+                            case 2:
+                                *((uint16_t *)out) = (uint16_t)(idx);
+                                out += 2;
+                                break;
+                            case 4:
+                                *((uint32_t *)out) = (uint32_t)(m->prop[i].value.color);
+                                out += 4;
+                                break;
+                            }
+                        } else
+                            out--;
+                        break;
+                    case m3dpf_uint8: *out++ = (uint8_t)m->prop[i].value.num; break;
+                    case m3dpf_uint16:
+                        *((uint16_t *)out) = (uint16_t)m->prop[i].value.num;
+                        out += 2;
+                        break;
+                    case m3dpf_uint32:
+                        *((uint32_t *)out) = m->prop[i].value.num;
+                        out += 4;
+                        break;
+                    case m3dpf_float:
+                        *((float *)out) = m->prop[i].value.fnum;
+                        out += 4;
+                        break;
+
+                    case m3dpf_map:
+                        idx = _m3d_stridx(str, numstr, model->texture[m->prop[i].value.textureid].name);
+                        out = _m3d_addidx(out, si_s, idx);
+                        break;
+                    }
+                }
+                *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
+                len += *length;
+                out = NULL;
+            }
+        }
+        /* procedural face */
+        if (model->numinlined && model->inlined && !(flags & M3D_EXP_NOFACE)) {
+            /* all inlined assets which are not textures should be procedural surfaces */
+            for (j = 0; j < model->numinlined; j++) {
+                if (!model->inlined[j].name || !model->inlined[j].name[0] || model->inlined[j].length < 4 ||
+                        !model->inlined[j].data || (model->inlined[j].data[1] == 'P' && model->inlined[j].data[2] == 'N' && model->inlined[j].data[3] == 'G'))
+                    continue;
+                for (i = k = 0; i < model->numtexture; i++) {
+                    if (!strcmp(model->inlined[j].name, model->texture[i].name)) {
+                        k = 1;
+                        break;
+                    }
+                }
+                if (k) continue;
+                numproc++;
+                chunklen = 8 + si_s;
+                h = (m3dhdr_t *)M3D_REALLOC(h, len + chunklen);
+                if (!h) goto memerr;
+                memcpy((uint8_t *)h + len, "PROC", 4);
+                *((uint32_t *)((uint8_t *)h + len + 4)) = chunklen;
+                out = (uint8_t *)h + len + 8;
+                out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, model->inlined[j].name));
+                out = NULL;
+                len += chunklen;
+            }
+        }
+        /* mesh face */
+        if (model->numface && face && !(flags & M3D_EXP_NOFACE)) {
+            chunklen = 8 + si_s + model->numface * (6 * vi_s + 3 * ti_s + si_s + 1);
+            h = (m3dhdr_t *)M3D_REALLOC(h, len + chunklen);
+            if (!h) goto memerr;
+            memcpy((uint8_t *)h + len, "MESH", 4);
+            length = (uint32_t *)((uint8_t *)h + len + 4);
+            out = (uint8_t *)h + len + 8;
+            last = M3D_UNDEF;
+            for (i = 0; i < model->numface; i++) {
+                if (!(flags & M3D_EXP_NOMATERIAL) && face[i].data.materialid != last) {
+                    last = face[i].data.materialid;
+                    idx = last < model->nummaterial ? _m3d_stridx(str, numstr, model->material[last].name) : 0;
+                    *out++ = 0;
+                    out = _m3d_addidx(out, si_s, idx);
+                }
+                /* hardcoded triangles. */
+                k = (3 << 4) |
+                    (((flags & M3D_EXP_NOTXTCRD) || !ti_s || face[i].data.texcoord[0] == M3D_UNDEF ||
+                             face[i].data.texcoord[1] == M3D_UNDEF || face[i].data.texcoord[2] == M3D_UNDEF) ?
+                                    0 :
+                                    1) |
+                    (((flags & M3D_EXP_NONORMAL) || face[i].data.normal[0] == M3D_UNDEF ||
+                             face[i].data.normal[1] == M3D_UNDEF || face[i].data.normal[2] == M3D_UNDEF) ?
+                                    0 :
+                                    2);
+                *out++ = (uint8_t)k;
+                for (j = 0; j < 3; j++) {
+                    out = _m3d_addidx(out, vi_s, vrtxidx[face[i].data.vertex[j]]);
+                    if (k & 1)
+                        out = _m3d_addidx(out, ti_s, tmapidx[face[i].data.texcoord[j]]);
+                    if (k & 2)
+                        out = _m3d_addidx(out, vi_s, vrtxidx[face[i].data.normal[j]]);
+                }
+            }
+            uint32_t v = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
+            memcpy(length, &v, sizeof(uint32_t));
+            len += v;
+            out = NULL;
+        }
+        /* mathematical shapes face */
+        if (model->numshape && model->shape && !(flags & M3D_EXP_NOFACE)) {
+            for (j = 0; j < model->numshape; j++) {
+                chunklen = 12 + si_s + model->shape[j].numcmd * (M3D_CMDMAXARG + 1) * 4;
+                h = (m3dhdr_t *)M3D_REALLOC(h, len + chunklen);
+                if (!h) goto memerr;
+                memcpy((uint8_t *)h + len, "SHPE", 4);
+                length = (uint32_t *)((uint8_t *)h + len + 4);
+                out = (uint8_t *)h + len + 8;
+                out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, model->shape[j].name));
+                out = _m3d_addidx(out, bi_s, model->shape[j].group);
+                for (i = 0; i < model->shape[j].numcmd; i++) {
+                    cmd = &model->shape[j].cmd[i];
+                    if (cmd->type >= (unsigned int)(sizeof(m3d_commandtypes) / sizeof(m3d_commandtypes[0])) || !cmd->arg)
+                        continue;
+                    cd = &m3d_commandtypes[cmd->type];
+                    *out++ = (cmd->type & 0x7F) | (cmd->type > 127 ? 0x80 : 0);
+                    if (cmd->type > 127) *out++ = (cmd->type >> 7) & 0xff;
+                    for (k = n = 0, l = cd->p; k < l; k++) {
+                        switch (cd->a[((k - n) % (cd->p - n)) + n]) {
+                        case m3dcp_mi_t:
+                            out = _m3d_addidx(out, si_s, cmd->arg[k] < model->nummaterial ? _m3d_stridx(str, numstr, model->material[cmd->arg[k]].name) : 0);
+                            break;
+                        case m3dcp_vc_t:
+                            min_x = *((float *)&cmd->arg[k]);
+                            switch (vc_s) {
+                            case 1: *out++ = (int8_t)(min_x * 127); break;
+                            case 2:
+                                *((int16_t *)out) = (int16_t)(min_x * 32767);
+                                out += 2;
+                                break;
+                            case 4:
+                                *((float *)out) = min_x;
+                                out += 4;
+                                break;
+                            case 8:
+                                *((double *)out) = min_x;
+                                out += 8;
+                                break;
+                            }
+                            break;
+                        case m3dcp_hi_t: out = _m3d_addidx(out, hi_s, cmd->arg[k]); break;
+                        case m3dcp_fi_t: out = _m3d_addidx(out, fi_s, cmd->arg[k]); break;
+                        case m3dcp_ti_t: out = _m3d_addidx(out, ti_s, cmd->arg[k]); break;
+                        case m3dcp_qi_t:
+                        case m3dcp_vi_t: out = _m3d_addidx(out, vi_s, cmd->arg[k]); break;
+                        case m3dcp_i1_t: out = _m3d_addidx(out, 1, cmd->arg[k]); break;
+                        case m3dcp_i2_t: out = _m3d_addidx(out, 2, cmd->arg[k]); break;
+                        case m3dcp_i4_t: out = _m3d_addidx(out, 4, cmd->arg[k]); break;
+                        case m3dcp_va_t:
+                            out = _m3d_addidx(out, 4, cmd->arg[k]);
+                            n = k + 1;
+                            l += (cmd->arg[k] - 1) * (cd->p - k - 1);
+                            break;
+                        }
+                    }
+                }
+                uint32_t v = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
+                memcpy( length, &v, sizeof(uint32_t));
+                len += v;
+                out = NULL;
+            }
+        }
+        /* annotation labels */
+        if (model->numlabel && model->label) {
+            for (i = 0, length = NULL; i < model->numlabel; i++) {
+                if (!i || _m3d_strcmp(sl, model->label[i].lang) || _m3d_strcmp(sn, model->label[i].name)) {
+                    sl = model->label[i].lang;
+                    sn = model->label[i].name;
+                    if (length) {
+                        *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
+                        len += *length;
+                    }
+                    chunklen = 8 + 2 * si_s + ci_s + model->numlabel * (vi_s + si_s);
+                    h = (m3dhdr_t *)M3D_REALLOC(h, len + chunklen);
+                    if (!h) {
+                        sn = NULL;
+                        sl = NULL;
+                        goto memerr;
+                    }
+                    memcpy((uint8_t *)h + len, "LBLS", 4);
+                    length = (uint32_t *)((uint8_t *)h + len + 4);
+                    out = (uint8_t *)h + len + 8;
+                    out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, model->label[l].name));
+                    out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, model->label[l].lang));
+                    idx = _m3d_cmapidx(cmap, numcmap, model->label[i].color);
+                    switch (ci_s) {
+                    case 1: *out++ = (uint8_t)(idx); break;
+                    case 2:
+                        *((uint16_t *)out) = (uint16_t)(idx);
+                        out += 2;
+                        break;
+                    case 4:
+                        *((uint32_t *)out) = model->label[i].color;
+                        out += 4;
+                        break;
+                    }
+                }
+                out = _m3d_addidx(out, vi_s, vrtxidx[model->label[i].vertexid]);
+                out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, model->label[l].text));
+            }
+            if (length) {
+                uint32_t v = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
+                memcpy( length, &v, sizeof(uint32_t));
+                len += v;
+            }
+            out = NULL;
+            sn = sl = NULL;
+        }
+        /* actions */
+        if (model->numaction && model->action && model->numbone && model->bone && !(flags & M3D_EXP_NOACTION)) {
+            for (j = 0; j < model->numaction; j++) {
+                a = &model->action[j];
+                chunklen = 14 + si_s + a->numframe * (4 + fc_s + maxt * (bi_s + 2 * vi_s));
+                h = (m3dhdr_t *)M3D_REALLOC(h, len + chunklen);
+                if (!h) goto memerr;
+                memcpy((uint8_t *)h + len, "ACTN", 4);
+                length = (uint32_t *)((uint8_t *)h + len + 4);
+                out = (uint8_t *)h + len + 8;
+                out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, a->name));
+                *((uint16_t *)out) = (uint16_t)(a->numframe);
+                out += 2;
+                *((uint32_t *)out) = (uint32_t)(a->durationmsec);
+                out += 4;
+                for (i = 0; i < a->numframe; i++) {
+                    *((uint32_t *)out) = (uint32_t)(a->frame[i].msec);
+                    out += 4;
+                    out = _m3d_addidx(out, fc_s, a->frame[i].numtransform);
+                    for (k = 0; k < a->frame[i].numtransform; k++) {
+                        out = _m3d_addidx(out, bi_s, a->frame[i].transform[k].boneid);
+                        out = _m3d_addidx(out, vi_s, vrtxidx[a->frame[i].transform[k].pos]);
+                        out = _m3d_addidx(out, vi_s, vrtxidx[a->frame[i].transform[k].ori]);
+                    }
+                }
+                uint32_t v = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
+                memcpy( length, &v, sizeof(uint32_t));
+                len += v;
+                out = NULL;
+            }
+        }
+        /* inlined assets */
+        if (model->numinlined && model->inlined && (numproc || (flags & M3D_EXP_INLINE))) {
+            for (j = 0; j < model->numinlined; j++) {
+                if (!model->inlined[j].name || !model->inlined[j].name[0] || model->inlined[j].length < 4 || !model->inlined[j].data)
+                    continue;
+                if (!(flags & M3D_EXP_INLINE)) {
+                    if (model->inlined[j].data[1] == 'P' && model->inlined[j].data[2] == 'N' && model->inlined[j].data[3] == 'G')
+                        continue;
+                    for (i = k = 0; i < model->numtexture; i++) {
+                        if (!strcmp(model->inlined[j].name, model->texture[i].name)) {
+                            k = 1;
+                            break;
+                        }
+                    }
+                    if (k) continue;
+                }
+                chunklen = 8 + si_s + model->inlined[j].length;
+                h = (m3dhdr_t *)M3D_REALLOC(h, len + chunklen);
+                if (!h) goto memerr;
+                memcpy((uint8_t *)h + len, "ASET", 4);
+                *((uint32_t *)((uint8_t *)h + len + 4)) = chunklen;
+                out = (uint8_t *)h + len + 8;
+                out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, model->inlined[j].name));
+                memcpy(out, model->inlined[j].data, model->inlined[j].length);
+                out = NULL;
+                len += chunklen;
+            }
+        }
+        /* extra chunks */
+        if (model->numextra && model->extra && (flags & M3D_EXP_EXTRA)) {
+            for (j = 0; j < model->numextra; j++) {
+                if (!model->extra[j] || model->extra[j]->length < 8)
+                    continue;
+                chunklen = model->extra[j]->length;
+                h = (m3dhdr_t *)M3D_REALLOC(h, len + chunklen);
+                if (!h) goto memerr;
+                memcpy((uint8_t *)h + len, model->extra[j], chunklen);
+                len += chunklen;
+            }
+        }
+        /* add end chunk */
+        h = (m3dhdr_t *)M3D_REALLOC(h, len + 4);
+        if (!h) goto memerr;
+        memcpy((uint8_t *)h + len, "OMD3", 4);
+        len += 4;
+        /* zlib compress */
+        if (!(flags & M3D_EXP_NOZLIB)) {
+            M3D_LOG("Deflating chunks");
+            z = stbi_zlib_compress((unsigned char *)h, len, (int *)&l, 9);
+            if (z && l > 0 && l < len) {
+                len = l;
+                M3D_FREE(h);
+                h = (m3dhdr_t *)z;
+            }
+        }
+        /* add file header at the beginning */
+        len += 8;
+        out = (unsigned char *)M3D_MALLOC(len);
+        if (!out) goto memerr;
+        memcpy(out, "3DMO", 4);
+        *((uint32_t *)(out + 4)) = len;
+        memcpy(out + 8, h, len - 8);
+    }
+    if (size) *size = out ? len : 0;
+    if (vrtxidx) M3D_FREE(vrtxidx);
+    if (mtrlidx) M3D_FREE(mtrlidx);
+    if (tmapidx) M3D_FREE(tmapidx);
+    if (skinidx) M3D_FREE(skinidx);
+    if (norm) M3D_FREE(norm);
+    if (face) M3D_FREE(face);
+    if (cmap) M3D_FREE(cmap);
+    if (tmap) M3D_FREE(tmap);
+    if (skin) M3D_FREE(skin);
+    if (str) M3D_FREE(str);
+    if (vrtx) M3D_FREE(vrtx);
+    if (h) M3D_FREE(h);
+    return out;
+}
+#endif
+
+#endif /* M3D_IMPLEMENTATION */
+
+#ifdef __cplusplus
+}
+#ifdef M3D_CPPWRAPPER
+#include <memory>
+#include <string>
+#include <vector>
+
+/*** C++ wrapper class ***/
+namespace M3D {
+#ifdef M3D_IMPLEMENTATION
+
+class Model {
+public:
+    m3d_t *model;
+
+public:
+    Model() {
+        this->model = (m3d_t *)malloc(sizeof(m3d_t));
+        memset(this->model, 0, sizeof(m3d_t));
+    }
+    Model(_unused const std::string &data, _unused m3dread_t ReadFileCB,
+            _unused m3dfree_t FreeCB, _unused M3D::Model mtllib) {
+#ifndef M3D_NOIMPORTER
+        this->model = m3d_load((unsigned char *)data.data(), ReadFileCB, FreeCB, mtllib.model);
+#else
+        Model();
+#endif
+    }
+    Model(_unused const std::vector<unsigned char> data, _unused m3dread_t ReadFileCB,
+            _unused m3dfree_t FreeCB, _unused M3D::Model mtllib) {
+#ifndef M3D_NOIMPORTER
+        this->model = m3d_load((unsigned char *)&data[0], ReadFileCB, FreeCB, mtllib.model);
+#else
+        Model();
+#endif
+    }
+    Model(_unused const unsigned char *data, _unused m3dread_t ReadFileCB,
+            _unused m3dfree_t FreeCB, _unused M3D::Model mtllib) {
+#ifndef M3D_NOIMPORTER
+        this->model = m3d_load((unsigned char *)data, ReadFileCB, FreeCB, mtllib.model);
+#else
+        Model();
+#endif
+    }
+    ~Model() { m3d_free(this->model); }
+
+public:
+    m3d_t *getCStruct() { return this->model; }
+    std::string getName() { return std::string(this->model->name); }
+    void setName(std::string name) { this->model->name = (char *)name.c_str(); }
+    std::string getLicense() { return std::string(this->model->license); }
+    void setLicense(std::string license) { this->model->license = (char *)license.c_str(); }
+    std::string getAuthor() { return std::string(this->model->author); }
+    void setAuthor(std::string author) { this->model->author = (char *)author.c_str(); }
+    std::string getDescription() { return std::string(this->model->desc); }
+    void setDescription(std::string desc) { this->model->desc = (char *)desc.c_str(); }
+    float getScale() { return this->model->scale; }
+    void setScale(float scale) { this->model->scale = scale; }
+    std::vector<unsigned char> getPreview() { return this->model->preview.data ?
+                                                             std::vector<unsigned char>(this->model->preview.data, this->model->preview.data + this->model->preview.length) :
+                                                             std::vector<unsigned char>(); }
+    std::vector<uint32_t> getColorMap() { return this->model->cmap ? std::vector<uint32_t>(this->model->cmap,
+                                                                             this->model->cmap + this->model->numcmap) :
+                                                                     std::vector<uint32_t>(); }
+    std::vector<m3dti_t> getTextureMap() { return this->model->tmap ? std::vector<m3dti_t>(this->model->tmap,
+                                                                              this->model->tmap + this->model->numtmap) :
+                                                                      std::vector<m3dti_t>(); }
+    std::vector<m3dtx_t> getTextures() { return this->model->texture ? std::vector<m3dtx_t>(this->model->texture,
+                                                                               this->model->texture + this->model->numtexture) :
+                                                                       std::vector<m3dtx_t>(); }
+    std::string getTextureName(int idx) { return idx >= 0 && (unsigned int)idx < this->model->numtexture ?
+                                                         std::string(this->model->texture[idx].name) :
+                                                         nullptr; }
+    std::vector<m3db_t> getBones() { return this->model->bone ? std::vector<m3db_t>(this->model->bone, this->model->bone +
+                                                                                                               this->model->numbone) :
+                                                                std::vector<m3db_t>(); }
+    std::string getBoneName(int idx) { return idx >= 0 && (unsigned int)idx < this->model->numbone ?
+                                                      std::string(this->model->bone[idx].name) :
+                                                      nullptr; }
+    std::vector<m3dm_t> getMaterials() { return this->model->material ? std::vector<m3dm_t>(this->model->material,
+                                                                                this->model->material + this->model->nummaterial) :
+                                                                        std::vector<m3dm_t>(); }
+    std::string getMaterialName(int idx) { return idx >= 0 && (unsigned int)idx < this->model->nummaterial ?
+                                                          std::string(this->model->material[idx].name) :
+                                                          nullptr; }
+    int getMaterialPropertyInt(int idx, int type) {
+        if (idx < 0 || (unsigned int)idx >= this->model->nummaterial || type < 0 || type >= 127 ||
+                !this->model->material[idx].prop) return -1;
+        for (int i = 0; i < this->model->material[idx].numprop; i++) {
+            if (this->model->material[idx].prop[i].type == type)
+                return this->model->material[idx].prop[i].value.num;
+        }
+        return -1;
+    }
+    uint32_t getMaterialPropertyColor(int idx, int type) { return this->getMaterialPropertyInt(idx, type); }
+    float getMaterialPropertyFloat(int idx, int type) {
+        if (idx < 0 || (unsigned int)idx >= this->model->nummaterial || type < 0 || type >= 127 ||
+                !this->model->material[idx].prop) return -1.0f;
+        for (int i = 0; i < this->model->material[idx].numprop; i++) {
+            if (this->model->material[idx].prop[i].type == type)
+                return this->model->material[idx].prop[i].value.fnum;
+        }
+        return -1.0f;
+    }
+    m3dtx_t *getMaterialPropertyMap(int idx, int type) {
+        if (idx < 0 || (unsigned int)idx >= this->model->nummaterial || type < 128 || type > 255 ||
+                !this->model->material[idx].prop) return nullptr;
+        for (int i = 0; i < this->model->material[idx].numprop; i++) {
+            if (this->model->material[idx].prop[i].type == type)
+                return this->model->material[idx].prop[i].value.textureid < this->model->numtexture ?
+                               &this->model->texture[this->model->material[idx].prop[i].value.textureid] :
+                               nullptr;
+        }
+        return nullptr;
+    }
+    std::vector<m3dv_t> getVertices() { return this->model->vertex ? std::vector<m3dv_t>(this->model->vertex,
+                                                                             this->model->vertex + this->model->numvertex) :
+                                                                     std::vector<m3dv_t>(); }
+    std::vector<m3df_t> getFace() { return this->model->face ? std::vector<m3df_t>(this->model->face, this->model->face +
+                                                                                                              this->model->numface) :
+                                                               std::vector<m3df_t>(); }
+    std::vector<m3dh_t> getShape() { return this->model->shape ? std::vector<m3dh_t>(this->model->shape,
+                                                                         this->model->shape + this->model->numshape) :
+                                                                 std::vector<m3dh_t>(); }
+    std::string getShapeName(int idx) { return idx >= 0 && (unsigned int)idx < this->model->numshape &&
+                                                               this->model->shape[idx].name && this->model->shape[idx].name[0] ?
+                                                       std::string(this->model->shape[idx].name) :
+                                                       nullptr; }
+    unsigned int getShapeGroup(int idx) { return idx >= 0 && (unsigned int)idx < this->model->numshape ?
+                                                         this->model->shape[idx].group :
+                                                         0xFFFFFFFF; }
+    std::vector<m3dc_t> getShapeCommands(int idx) { return idx >= 0 && (unsigned int)idx < this->model->numshape &&
+                                                                           this->model->shape[idx].cmd ?
+                                                                   std::vector<m3dc_t>(this->model->shape[idx].cmd, this->model->shape[idx].cmd +
+                                                                                                                            this->model->shape[idx].numcmd) :
+                                                                   std::vector<m3dc_t>(); }
+    std::vector<m3dl_t> getAnnotationLabels() { return this->model->label ? std::vector<m3dl_t>(this->model->label,
+                                                                                    this->model->label + this->model->numlabel) :
+                                                                            std::vector<m3dl_t>(); }
+    std::vector<m3ds_t> getSkin() { return this->model->skin ? std::vector<m3ds_t>(this->model->skin, this->model->skin +
+                                                                                                              this->model->numskin) :
+                                                               std::vector<m3ds_t>(); }
+    std::vector<m3da_t> getActions() { return this->model->action ? std::vector<m3da_t>(this->model->action,
+                                                                            this->model->action + this->model->numaction) :
+                                                                    std::vector<m3da_t>(); }
+    std::string getActionName(int aidx) { return aidx >= 0 && (unsigned int)aidx < this->model->numaction ?
+                                                         std::string(this->model->action[aidx].name) :
+                                                         nullptr; }
+    unsigned int getActionDuration(int aidx) { return aidx >= 0 && (unsigned int)aidx < this->model->numaction ?
+                                                              this->model->action[aidx].durationmsec :
+                                                              0; }
+    std::vector<m3dfr_t> getActionFrames(int aidx) { return aidx >= 0 && (unsigned int)aidx < this->model->numaction ?
+                                                                    std::vector<m3dfr_t>(this->model->action[aidx].frame, this->model->action[aidx].frame +
+                                                                                                                                  this->model->action[aidx].numframe) :
+                                                                    std::vector<m3dfr_t>(); }
+    unsigned int getActionFrameTimestamp(int aidx, int fidx) { return aidx >= 0 && (unsigned int)aidx < this->model->numaction ?
+                                                                              (fidx >= 0 && (unsigned int)fidx < this->model->action[aidx].numframe ?
+                                                                                              this->model->action[aidx].frame[fidx].msec :
+                                                                                              0) :
+                                                                              0; }
+    std::vector<m3dtr_t> getActionFrameTransforms(int aidx, int fidx) {
+        return aidx >= 0 && (unsigned int)aidx < this->model->numaction ? (
+                                                                                  fidx >= 0 && (unsigned int)fidx < this->model->action[aidx].numframe ?
+                                                                                          std::vector<m3dtr_t>(this->model->action[aidx].frame[fidx].transform,
+                                                                                                  this->model->action[aidx].frame[fidx].transform + this->model->action[aidx].frame[fidx].numtransform) :
+                                                                                          std::vector<m3dtr_t>()) :
+                                                                          std::vector<m3dtr_t>();
+    }
+    std::vector<m3dtr_t> getActionFrame(int aidx, int fidx, std::vector<m3dtr_t> skeleton) {
+        m3dtr_t *pose = m3d_frame(this->model, (unsigned int)aidx, (unsigned int)fidx,
+                skeleton.size() ? &skeleton[0] : nullptr);
+        return std::vector<m3dtr_t>(pose, pose + this->model->numbone);
+    }
+    std::vector<m3db_t> getActionPose(int aidx, unsigned int msec) {
+        m3db_t *pose = m3d_pose(this->model, (unsigned int)aidx, (unsigned int)msec);
+        return std::vector<m3db_t>(pose, pose + this->model->numbone);
+    }
+    std::vector<m3di_t> getInlinedAssets() { return this->model->inlined ? std::vector<m3di_t>(this->model->inlined,
+                                                                                   this->model->inlined + this->model->numinlined) :
+                                                                           std::vector<m3di_t>(); }
+    std::vector<std::unique_ptr<m3dchunk_t>> getExtras() { return this->model->extra ?
+                                                                          std::vector<std::unique_ptr<m3dchunk_t>>(this->model->extra,
+                                                                                  this->model->extra + this->model->numextra) :
+                                                                          std::vector<std::unique_ptr<m3dchunk_t>>(); }
+    std::vector<unsigned char> Save(_unused int quality, _unused int flags) {
+#ifdef M3D_EXPORTER
+        unsigned int size;
+        unsigned char *ptr = m3d_save(this->model, quality, flags, &size);
+        return ptr && size ? std::vector<unsigned char>(ptr, ptr + size) : std::vector<unsigned char>();
+#else
+        return std::vector<unsigned char>();
+#endif
+    }
+};
+
+#else
+class Model {
+public:
+    m3d_t *model;
+
+public:
+    Model(const std::string &data, m3dread_t ReadFileCB, m3dfree_t FreeCB);
+    Model(const std::vector<unsigned char> data, m3dread_t ReadFileCB, m3dfree_t FreeCB);
+    Model(const unsigned char *data, m3dread_t ReadFileCB, m3dfree_t FreeCB);
+    Model();
+    ~Model();
+
+public:
+    m3d_t *getCStruct();
+    std::string getName();
+    void setName(std::string name);
+    std::string getLicense();
+    void setLicense(std::string license);
+    std::string getAuthor();
+    void setAuthor(std::string author);
+    std::string getDescription();
+    void setDescription(std::string desc);
+    float getScale();
+    void setScale(float scale);
+    std::vector<unsigned char> getPreview();
+    std::vector<uint32_t> getColorMap();
+    std::vector<m3dti_t> getTextureMap();
+    std::vector<m3dtx_t> getTextures();
+    std::string getTextureName(int idx);
+    std::vector<m3db_t> getBones();
+    std::string getBoneName(int idx);
+    std::vector<m3dm_t> getMaterials();
+    std::string getMaterialName(int idx);
+    int getMaterialPropertyInt(int idx, int type);
+    uint32_t getMaterialPropertyColor(int idx, int type);
+    float getMaterialPropertyFloat(int idx, int type);
+    m3dtx_t *getMaterialPropertyMap(int idx, int type);
+    std::vector<m3dv_t> getVertices();
+    std::vector<m3df_t> getFace();
+    std::vector<m3dh_t> getShape();
+    std::string getShapeName(int idx);
+    unsigned int getShapeGroup(int idx);
+    std::vector<m3dc_t> getShapeCommands(int idx);
+    std::vector<m3dl_t> getAnnotationLabels();
+    std::vector<m3ds_t> getSkin();
+    std::vector<m3da_t> getActions();
+    std::string getActionName(int aidx);
+    unsigned int getActionDuration(int aidx);
+    std::vector<m3dfr_t> getActionFrames(int aidx);
+    unsigned int getActionFrameTimestamp(int aidx, int fidx);
+    std::vector<m3dtr_t> getActionFrameTransforms(int aidx, int fidx);
+    std::vector<m3dtr_t> getActionFrame(int aidx, int fidx, std::vector<m3dtr_t> skeleton);
+    std::vector<m3db_t> getActionPose(int aidx, unsigned int msec);
+    std::vector<m3di_t> getInlinedAssets();
+    std::vector<std::unique_ptr<m3dchunk_t>> getExtras();
+    std::vector<unsigned char> Save(int quality, int flags);
+};
+
+#endif /* impl */
+} // namespace M3D
+
+#endif /* M3D_CPPWRAPPER */
+
+#if _MSC_VER > 1920 && !defined(__clang__)
+#    pragma warning(pop)
+#endif /* _MSC_VER */
+
+#endif /* __cplusplus */
+
+#endif
diff --git a/Engine/lib/assimp/code/MD2/MD2FileData.h b/Engine/lib/assimp/code/AssetLib/MD2/MD2FileData.h
similarity index 99%
rename from Engine/lib/assimp/code/MD2/MD2FileData.h
rename to Engine/lib/assimp/code/AssetLib/MD2/MD2FileData.h
index 9fcb8b0e2..3bce8feee 100644
--- a/Engine/lib/assimp/code/MD2/MD2FileData.h
+++ b/Engine/lib/assimp/code/AssetLib/MD2/MD2FileData.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/MD2/MD2Loader.cpp b/Engine/lib/assimp/code/AssetLib/MD2/MD2Loader.cpp
similarity index 89%
rename from Engine/lib/assimp/code/MD2/MD2Loader.cpp
rename to Engine/lib/assimp/code/AssetLib/MD2/MD2Loader.cpp
index 7023c0fa3..99ab3f521 100644
--- a/Engine/lib/assimp/code/MD2/MD2Loader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/MD2/MD2Loader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -53,6 +53,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/IOSystem.hpp>
 #include <assimp/scene.h>
 #include <assimp/importerdesc.h>
+#include <assimp/StringUtils.h>
 
 #include <memory>
 
@@ -106,19 +107,10 @@ MD2Importer::~MD2Importer()
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool MD2Importer::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
+bool MD2Importer::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/) const
 {
-    const std::string extension = GetExtension(pFile);
-    if (extension == "md2")
-        return true;
-
-    // if check for extension is not enough, check for the magic tokens
-    if (!extension.length() || checkSig) {
-        uint32_t tokens[1];
-        tokens[0] = AI_MD2_MAGIC_NUMBER_LE;
-        return CheckMagicToken(pIOHandler,pFile,tokens,1);
-    }
-    return false;
+    static const uint32_t tokens[] = { AI_MD2_MAGIC_NUMBER_LE };
+    return CheckMagicToken(pIOHandler,pFile,tokens,AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -148,46 +140,39 @@ void MD2Importer::ValidateHeader( )
     if (m_pcHeader->magic != AI_MD2_MAGIC_NUMBER_BE &&
         m_pcHeader->magic != AI_MD2_MAGIC_NUMBER_LE)
     {
-        char szBuffer[5];
-        szBuffer[0] = ((char*)&m_pcHeader->magic)[0];
-        szBuffer[1] = ((char*)&m_pcHeader->magic)[1];
-        szBuffer[2] = ((char*)&m_pcHeader->magic)[2];
-        szBuffer[3] = ((char*)&m_pcHeader->magic)[3];
-        szBuffer[4] = '\0';
-
-        throw DeadlyImportError("Invalid MD2 magic word: should be IDP2, the "
-            "magic word found is " + std::string(szBuffer));
+        throw DeadlyImportError("Invalid MD2 magic word: expected IDP2, found ",
+                                ai_str_toprintable((char *)&m_pcHeader->magic, 4));
     }
 
     // check file format version
     if (m_pcHeader->version != 8)
-        ASSIMP_LOG_WARN( "Unsupported md2 file version. Continuing happily ...");
+        ASSIMP_LOG_WARN( "Unsupported MD2 file version. Continuing happily ...");
 
     // check some values whether they are valid
     if (0 == m_pcHeader->numFrames)
-        throw DeadlyImportError( "Invalid md2 file: NUM_FRAMES is 0");
+        throw DeadlyImportError( "Invalid MD2 file: NUM_FRAMES is 0");
 
     if (m_pcHeader->offsetEnd > (uint32_t)fileSize)
-        throw DeadlyImportError( "Invalid md2 file: File is too small");
+        throw DeadlyImportError( "Invalid MD2 file: File is too small");
 
     if (m_pcHeader->numSkins > AI_MAX_ALLOC(MD2::Skin)) {
-        throw DeadlyImportError("Invalid MD2 header: too many skins, would overflow");
+        throw DeadlyImportError("Invalid MD2 header: Too many skins, would overflow");
     }
 
     if (m_pcHeader->numVertices > AI_MAX_ALLOC(MD2::Vertex)) {
-        throw DeadlyImportError("Invalid MD2 header: too many vertices, would overflow");
+        throw DeadlyImportError("Invalid MD2 header: Too many vertices, would overflow");
     }
 
     if (m_pcHeader->numTexCoords > AI_MAX_ALLOC(MD2::TexCoord)) {
-        throw DeadlyImportError("Invalid MD2 header: too many texcoords, would overflow");
+        throw DeadlyImportError("Invalid MD2 header: Too many texcoords, would overflow");
     }
 
     if (m_pcHeader->numTriangles > AI_MAX_ALLOC(MD2::Triangle)) {
-        throw DeadlyImportError("Invalid MD2 header: too many triangles, would overflow");
+        throw DeadlyImportError("Invalid MD2 header: Too many triangles, would overflow");
     }
 
     if (m_pcHeader->numFrames > AI_MAX_ALLOC(MD2::Frame)) {
-        throw DeadlyImportError("Invalid MD2 header: too many frames, would overflow");
+        throw DeadlyImportError("Invalid MD2 header: Too many frames, would overflow");
     }
 
     // -1 because Frame already contains one
@@ -199,7 +184,7 @@ void MD2Importer::ValidateHeader( )
         m_pcHeader->offsetFrames    + m_pcHeader->numFrames * frameSize                 >= fileSize ||
         m_pcHeader->offsetEnd           > fileSize)
     {
-        throw DeadlyImportError("Invalid MD2 header: some offsets are outside the file");
+        throw DeadlyImportError("Invalid MD2 header: Some offsets are outside the file");
     }
 
     if (m_pcHeader->numSkins > AI_MD2_MAX_SKINS)
@@ -210,7 +195,7 @@ void MD2Importer::ValidateHeader( )
         ASSIMP_LOG_WARN("The model contains more vertices than Quake 2 supports");
 
     if (m_pcHeader->numFrames <= configFrameID )
-        throw DeadlyImportError("The requested frame is not existing the file");
+        throw DeadlyImportError("MD2: The requested frame (", configFrameID, ") does not exist in the file");
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -221,20 +206,21 @@ void MD2Importer::InternReadFile( const std::string& pFile,
     std::unique_ptr<IOStream> file( pIOHandler->Open( pFile));
 
     // Check whether we can read from the file
-    if( file.get() == NULL)
-        throw DeadlyImportError( "Failed to open MD2 file " + pFile + "");
+    if (file.get() == nullptr) {
+        throw DeadlyImportError("Failed to open MD2 file ", pFile, "");
+    }
 
     // check whether the md3 file is large enough to contain
     // at least the file header
     fileSize = (unsigned int)file->FileSize();
-    if( fileSize < sizeof(MD2::Header))
-        throw DeadlyImportError( "MD2 File is too small");
+    if (fileSize < sizeof(MD2::Header)) {
+        throw DeadlyImportError("MD2 File is too small");
+    }
 
     std::vector<uint8_t> mBuffer2(fileSize);
     file->Read(&mBuffer2[0], 1, fileSize);
     mBuffer = &mBuffer2[0];
 
-
     m_pcHeader = (BE_NCONST MD2::Header*)mBuffer;
 
 #ifdef AI_BUILD_BIG_ENDIAN
@@ -432,10 +418,6 @@ void MD2Importer::InternReadFile( const std::string& pFile,
             aiVector3D& vNormal = pcMesh->mNormals[iCurrent];
             LookupNormalIndex(pcVerts[iIndex].lightNormalIndex,vNormal);
 
-            // flip z and y to become right-handed
-            std::swap((float&)vNormal.z,(float&)vNormal.y);
-            std::swap((float&)vec.z,(float&)vec.y);
-
             if (m_pcHeader->numTexCoords)   {
                 // validate texture coordinates
                 iIndex = pcTriangles[i].textureIndices[c];
@@ -453,7 +435,15 @@ void MD2Importer::InternReadFile( const std::string& pFile,
             }
             pScene->mMeshes[0]->mFaces[i].mIndices[c] = iCurrent;
         }
+        // flip the face order
+        std::swap( pScene->mMeshes[0]->mFaces[i].mIndices[0], pScene->mMeshes[0]->mFaces[i].mIndices[2] );
     }
+    // Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system
+    pScene->mRootNode->mTransformation = aiMatrix4x4(
+            1.f, 0.f, 0.f, 0.f,
+            0.f, 0.f, 1.f, 0.f,
+            0.f, -1.f, 0.f, 0.f,
+            0.f, 0.f, 0.f, 1.f);
 }
 
 #endif // !! ASSIMP_BUILD_NO_MD2_IMPORTER
diff --git a/Engine/lib/assimp/code/MD2/MD2Loader.h b/Engine/lib/assimp/code/AssetLib/MD2/MD2Loader.h
similarity index 86%
rename from Engine/lib/assimp/code/MD2/MD2Loader.h
rename to Engine/lib/assimp/code/AssetLib/MD2/MD2Loader.h
index a3863f366..a49ccb2fd 100644
--- a/Engine/lib/assimp/code/MD2/MD2Loader.h
+++ b/Engine/lib/assimp/code/AssetLib/MD2/MD2Loader.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,61 +42,55 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file  MD2Loader.h
  *  @brief Declaration of the .MD2 importer class.
  */
+#pragma once
 #ifndef AI_MD2LOADER_H_INCLUDED
 #define AI_MD2LOADER_H_INCLUDED
 
-#include <assimp/BaseImporter.h>
-#include <assimp/types.h>
-#include <assimp/ByteSwapper.h>
 #include "MD2FileData.h"
+#include <assimp/BaseImporter.h>
+#include <assimp/ByteSwapper.h>
+#include <assimp/types.h>
 
 struct aiNode;
 
-namespace Assimp  {
+namespace Assimp {
 
 using namespace MD2;
 
 // ---------------------------------------------------------------------------
 /** Importer class for MD2
 */
-class MD2Importer : public BaseImporter
-{
+class MD2Importer : public BaseImporter {
 public:
     MD2Importer();
-    ~MD2Importer();
-
-
-public:
+    ~MD2Importer() override;
 
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
     * See BaseImporter::CanRead() for details.  */
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
-
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
+            bool checkSig) const override;
 
     // -------------------------------------------------------------------
     /** Called prior to ReadFile().
     * The function is a request to the importer to update its configuration
     * basing on the Importer's configuration property list.
     */
-    void SetupProperties(const Importer* pImp);
+    void SetupProperties(const Importer *pImp) override;
 
 protected:
-
     // -------------------------------------------------------------------
     /** Return importer meta information.
      * See #BaseImporter::GetInfo for the details
      */
-    const aiImporterDesc* GetInfo () const;
+    const aiImporterDesc *GetInfo() const override;
 
     // -------------------------------------------------------------------
     /** Imports the given file into the given scene structure.
     * See BaseImporter::InternReadFile() for details
     */
-    void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
-
+    void InternReadFile(const std::string &pFile, aiScene *pScene,
+            IOSystem *pIOHandler) override;
 
     // -------------------------------------------------------------------
     /** Validate the header of the file
@@ -105,15 +98,14 @@ protected:
     void ValidateHeader();
 
 protected:
-
     /** Configuration option: frame to be loaded */
     unsigned int configFrameID;
 
     /** Header of the MD2 file */
-    BE_NCONST MD2::Header* m_pcHeader;
+    BE_NCONST MD2::Header *m_pcHeader;
 
     /** Buffer to hold the loaded file */
-    BE_NCONST uint8_t* mBuffer;
+    BE_NCONST uint8_t *mBuffer;
 
     /** Size of the file, in bytes */
     unsigned int fileSize;
diff --git a/Engine/lib/assimp/code/MD2/MD2NormalTable.h b/Engine/lib/assimp/code/AssetLib/MD2/MD2NormalTable.h
similarity index 99%
rename from Engine/lib/assimp/code/MD2/MD2NormalTable.h
rename to Engine/lib/assimp/code/AssetLib/MD2/MD2NormalTable.h
index f82b57683..1837939e8 100644
--- a/Engine/lib/assimp/code/MD2/MD2NormalTable.h
+++ b/Engine/lib/assimp/code/AssetLib/MD2/MD2NormalTable.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -51,7 +51,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define AI_MDL_NORMALTABLE_H_INC
 
 
-float g_avNormals[162][3] = {
+const float g_avNormals[162][3] = {
 { -0.525731f,  0.000000f,  0.850651f },
 { -0.442863f,  0.238856f,  0.864188f },
 { -0.295242f,  0.000000f,  0.955423f },
diff --git a/Engine/lib/assimp/code/MD3/MD3FileData.h b/Engine/lib/assimp/code/AssetLib/MD3/MD3FileData.h
similarity index 98%
rename from Engine/lib/assimp/code/MD3/MD3FileData.h
rename to Engine/lib/assimp/code/AssetLib/MD3/MD3FileData.h
index 2acd6631f..01475e679 100644
--- a/Engine/lib/assimp/code/MD3/MD3FileData.h
+++ b/Engine/lib/assimp/code/AssetLib/MD3/MD3FileData.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -271,7 +271,7 @@ inline void LatLngNormalToVec3(uint16_t p_iNormal, ai_real* p_afOut)
 
 
 // -------------------------------------------------------------------------------
-/** @brief Pack a Q3 normal into 16bit latitute/longitude representation
+/** @brief Pack a Q3 normal into 16bit latitude/longitude representation
  *  @param p_vIn Input vector
  *  @param p_iOut Output normal
  *
diff --git a/Engine/lib/assimp/code/MD3/MD3Loader.cpp b/Engine/lib/assimp/code/AssetLib/MD3/MD3Loader.cpp
similarity index 63%
rename from Engine/lib/assimp/code/MD3/MD3Loader.cpp
rename to Engine/lib/assimp/code/AssetLib/MD3/MD3Loader.cpp
index 1e78b6e05..6120bd8cb 100644
--- a/Engine/lib/assimp/code/MD3/MD3Loader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/MD3/MD3Loader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -50,21 +50,20 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *     http://www.heppler.com/shader/shader/
  */
 
-
 #ifndef ASSIMP_BUILD_NO_MD3_IMPORTER
 
-#include "MD3/MD3Loader.h"
+#include "AssetLib/MD3/MD3Loader.h"
 #include "Common/Importer.h"
 
-#include <assimp/SceneCombiner.h>
 #include <assimp/GenericProperty.h>
-#include <assimp/RemoveComments.h>
 #include <assimp/ParsingUtils.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/IOSystem.hpp>
+#include <assimp/RemoveComments.h>
+#include <assimp/SceneCombiner.h>
+#include <assimp/importerdesc.h>
 #include <assimp/material.h>
 #include <assimp/scene.h>
-#include <assimp/importerdesc.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOSystem.hpp>
 
 #include <cctype>
 #include <memory>
@@ -86,8 +85,7 @@ static const aiImporterDesc desc = {
 
 // ------------------------------------------------------------------------------------------------
 // Convert a Q3 shader blend function to the appropriate enum value
-Q3Shader::BlendFunc StringToBlendFunc(const std::string& m)
-{
+Q3Shader::BlendFunc StringToBlendFunc(const std::string &m) {
     if (m == "GL_ONE") {
         return Q3Shader::BLEND_GL_ONE;
     }
@@ -103,35 +101,34 @@ Q3Shader::BlendFunc StringToBlendFunc(const std::string& m)
     if (m == "GL_ONE_MINUS_DST_COLOR") {
         return Q3Shader::BLEND_GL_ONE_MINUS_DST_COLOR;
     }
-    ASSIMP_LOG_ERROR("Q3Shader: Unknown blend function: " + m);
+    ASSIMP_LOG_ERROR("Q3Shader: Unknown blend function: ", m);
     return Q3Shader::BLEND_NONE;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Load a Quake 3 shader
-bool Q3Shader::LoadShader(ShaderData& fill, const std::string& pFile,IOSystem* io)
-{
-    std::unique_ptr<IOStream> file( io->Open( pFile, "rt"));
+bool Q3Shader::LoadShader(ShaderData &fill, const std::string &pFile, IOSystem *io) {
+    std::unique_ptr<IOStream> file(io->Open(pFile, "rt"));
     if (!file.get())
         return false; // if we can't access the file, don't worry and return
 
-    ASSIMP_LOG_INFO_F("Loading Quake3 shader file ", pFile);
+    ASSIMP_LOG_INFO("Loading Quake3 shader file ", pFile);
 
     // read file in memory
     const size_t s = file->FileSize();
-    std::vector<char> _buff(s+1);
-    file->Read(&_buff[0],s,1);
+    std::vector<char> _buff(s + 1);
+    file->Read(&_buff[0], s, 1);
     _buff[s] = 0;
 
     // remove comments from it (C++ style)
-    CommentRemover::RemoveLineComments("//",&_buff[0]);
-    const char* buff = &_buff[0];
+    CommentRemover::RemoveLineComments("//", &_buff[0]);
+    const char *buff = &_buff[0];
 
-    Q3Shader::ShaderDataBlock* curData = NULL;
-    Q3Shader::ShaderMapBlock*  curMap  = NULL;
+    Q3Shader::ShaderDataBlock *curData = nullptr;
+    Q3Shader::ShaderMapBlock *curMap = nullptr;
 
     // read line per line
-    for (;SkipSpacesAndLineEnd(&buff);SkipLine(&buff)) {
+    for (; SkipSpacesAndLineEnd(&buff); SkipLine(&buff)) {
 
         if (*buff == '{') {
             ++buff;
@@ -143,74 +140,67 @@ bool Q3Shader::LoadShader(ShaderData& fill, const std::string& pFile,IOSystem* i
             }
 
             // read this data section
-            for (;SkipSpacesAndLineEnd(&buff);SkipLine(&buff)) {
+            for (; SkipSpacesAndLineEnd(&buff); SkipLine(&buff)) {
                 if (*buff == '{') {
                     ++buff;
                     // add new map section
                     curData->maps.push_back(Q3Shader::ShaderMapBlock());
                     curMap = &curData->maps.back();
 
-                    for (;SkipSpacesAndLineEnd(&buff);SkipLine(&buff)) {
+                    for (; SkipSpacesAndLineEnd(&buff); SkipLine(&buff)) {
                         // 'map' - Specifies texture file name
-                        if (TokenMatchI(buff,"map",3) || TokenMatchI(buff,"clampmap",8)) {
+                        if (TokenMatchI(buff, "map", 3) || TokenMatchI(buff, "clampmap", 8)) {
                             curMap->name = GetNextToken(buff);
                         }
                         // 'blendfunc' - Alpha blending mode
-                        else if (TokenMatchI(buff,"blendfunc",9)) {
+                        else if (TokenMatchI(buff, "blendfunc", 9)) {
                             const std::string blend_src = GetNextToken(buff);
                             if (blend_src == "add") {
-                                curMap->blend_src  = Q3Shader::BLEND_GL_ONE;
+                                curMap->blend_src = Q3Shader::BLEND_GL_ONE;
                                 curMap->blend_dest = Q3Shader::BLEND_GL_ONE;
-                            }
-                            else if (blend_src == "filter") {
-                                curMap->blend_src  = Q3Shader::BLEND_GL_DST_COLOR;
+                            } else if (blend_src == "filter") {
+                                curMap->blend_src = Q3Shader::BLEND_GL_DST_COLOR;
                                 curMap->blend_dest = Q3Shader::BLEND_GL_ZERO;
-                            }
-                            else if (blend_src == "blend") {
-                                curMap->blend_src  = Q3Shader::BLEND_GL_SRC_ALPHA;
+                            } else if (blend_src == "blend") {
+                                curMap->blend_src = Q3Shader::BLEND_GL_SRC_ALPHA;
                                 curMap->blend_dest = Q3Shader::BLEND_GL_ONE_MINUS_SRC_ALPHA;
-                            }
-                            else {
-                                curMap->blend_src  = StringToBlendFunc(blend_src);
+                            } else {
+                                curMap->blend_src = StringToBlendFunc(blend_src);
                                 curMap->blend_dest = StringToBlendFunc(GetNextToken(buff));
                             }
                         }
                         // 'alphafunc' - Alpha testing mode
-                        else if (TokenMatchI(buff,"alphafunc",9)) {
+                        else if (TokenMatchI(buff, "alphafunc", 9)) {
                             const std::string at = GetNextToken(buff);
                             if (at == "GT0") {
                                 curMap->alpha_test = Q3Shader::AT_GT0;
-                            }
-                            else if (at == "LT128") {
+                            } else if (at == "LT128") {
                                 curMap->alpha_test = Q3Shader::AT_LT128;
-                            }
-                            else if (at == "GE128") {
+                            } else if (at == "GE128") {
                                 curMap->alpha_test = Q3Shader::AT_GE128;
                             }
-                        }
-                        else if (*buff == '}') {
+                        } else if (*buff == '}') {
                             ++buff;
                             // close this map section
-                            curMap = NULL;
+                            curMap = nullptr;
                             break;
                         }
                     }
 
-                }
-                else if (*buff == '}') {
+                } else if (*buff == '}') {
                     ++buff;
-                    curData = NULL;
+                    curData = nullptr;
                     break;
                 }
 
                 // 'cull' specifies culling behaviour for the model
-                else if (TokenMatchI(buff,"cull",4)) {
+                else if (TokenMatchI(buff, "cull", 4)) {
                     SkipSpaces(&buff);
-                    if (!ASSIMP_strincmp(buff,"back",4)) {
+                    if (!ASSIMP_strincmp(buff, "back", 4)) { // render face's backside, does not function in Q3 engine (bug)
                         curData->cull = Q3Shader::CULL_CCW;
-                    } else if (!ASSIMP_strincmp(buff,"front",5)) {
+                    } else if (!ASSIMP_strincmp(buff, "front", 5)) { // is not valid keyword in Q3, but occurs in shaders
                         curData->cull = Q3Shader::CULL_CW;
-                    } else if (!ASSIMP_strincmp(buff,"none",4) || !ASSIMP_strincmp(buff,"disable",7)) {
+                    } else if (!ASSIMP_strincmp(buff, "none", 4) || !ASSIMP_strincmp(buff, "twosided", 8) || !ASSIMP_strincmp(buff, "disable", 7)) {
                         curData->cull = Q3Shader::CULL_NONE;
                     } else {
                         ASSIMP_LOG_ERROR("Q3Shader: Unrecognized cull mode");
@@ -231,38 +221,38 @@ bool Q3Shader::LoadShader(ShaderData& fill, const std::string& pFile,IOSystem* i
 
 // ------------------------------------------------------------------------------------------------
 // Load a Quake 3 skin
-bool Q3Shader::LoadSkin(SkinData& fill, const std::string& pFile,IOSystem* io)
-{
-    std::unique_ptr<IOStream> file( io->Open( pFile, "rt"));
+bool Q3Shader::LoadSkin(SkinData &fill, const std::string &pFile, IOSystem *io) {
+    std::unique_ptr<IOStream> file(io->Open(pFile, "rt"));
     if (!file.get())
         return false; // if we can't access the file, don't worry and return
 
-    ASSIMP_LOG_INFO("Loading Quake3 skin file " + pFile);
+    ASSIMP_LOG_INFO("Loading Quake3 skin file ", pFile);
 
     // read file in memory
     const size_t s = file->FileSize();
-    std::vector<char> _buff(s+1);const char* buff = &_buff[0];
-    file->Read(&_buff[0],s,1);
+    std::vector<char> _buff(s + 1);
+    const char *buff = &_buff[0];
+    file->Read(&_buff[0], s, 1);
     _buff[s] = 0;
 
     // remove commas
-    std::replace(_buff.begin(),_buff.end(),',',' ');
+    std::replace(_buff.begin(), _buff.end(), ',', ' ');
 
     // read token by token and fill output table
-    for (;*buff;) {
+    for (; *buff;) {
         SkipSpacesAndLineEnd(&buff);
 
         // get first identifier
         std::string ss = GetNextToken(buff);
 
         // ignore tokens starting with tag_
-        if (!::strncmp(&ss[0],"tag_",std::min((size_t)4, ss.length())))
+        if (!::strncmp(&ss[0], "tag_", std::min((size_t)4, ss.length())))
             continue;
 
         fill.textures.push_back(SkinData::TextureEntry());
         SkinData::TextureEntry &entry = fill.textures.back();
 
-        entry.first  = ss;
+        entry.first = ss;
         entry.second = GetNextToken(buff);
     }
     return true;
@@ -270,9 +260,8 @@ bool Q3Shader::LoadSkin(SkinData& fill, const std::string& pFile,IOSystem* io)
 
 // ------------------------------------------------------------------------------------------------
 // Convert Q3Shader to material
-void Q3Shader::ConvertShaderToMaterial(aiMaterial* out, const ShaderDataBlock& shader)
-{
-    ai_assert(NULL != out);
+void Q3Shader::ConvertShaderToMaterial(aiMaterial *out, const ShaderDataBlock &shader) {
+    ai_assert(nullptr != out);
 
     /*  IMPORTANT: This is not a real conversion. Actually we're just guessing and
      *  hacking around to build an aiMaterial that looks nearly equal to the
@@ -284,13 +273,13 @@ void Q3Shader::ConvertShaderToMaterial(aiMaterial* out, const ShaderDataBlock& s
     // Two-sided material?
     if (shader.cull == Q3Shader::CULL_NONE) {
         const int twosided = 1;
-        out->AddProperty(&twosided,1,AI_MATKEY_TWOSIDED);
+        out->AddProperty(&twosided, 1, AI_MATKEY_TWOSIDED);
     }
 
-    unsigned int cur_emissive = 0, cur_diffuse = 0, cur_lm =0;
+    unsigned int cur_emissive = 0, cur_diffuse = 0, cur_lm = 0;
 
     // Iterate through all textures
-    for (std::list< Q3Shader::ShaderMapBlock >::const_iterator it = shader.maps.begin(); it != shader.maps.end();++it) {
+    for (std::list<Q3Shader::ShaderMapBlock>::const_iterator it = shader.maps.begin(); it != shader.maps.end(); ++it) {
 
         // CONVERSION BEHAVIOUR:
         //
@@ -309,127 +298,104 @@ void Q3Shader::ConvertShaderToMaterial(aiMaterial* out, const ShaderDataBlock& s
         // Textures with alpha funcs
         //  - aiTextureFlags_UseAlpha is set (otherwise aiTextureFlags_NoAlpha is explicitly set)
         aiString s((*it).name);
-        aiTextureType type; unsigned int index;
+        aiTextureType type;
+        unsigned int index;
 
         if ((*it).blend_src == Q3Shader::BLEND_GL_ONE && (*it).blend_dest == Q3Shader::BLEND_GL_ONE) {
             if (it == shader.maps.begin()) {
                 const int additive = aiBlendMode_Additive;
-                out->AddProperty(&additive,1,AI_MATKEY_BLEND_FUNC);
+                out->AddProperty(&additive, 1, AI_MATKEY_BLEND_FUNC);
 
                 index = cur_diffuse++;
-                type  = aiTextureType_DIFFUSE;
-            }
-            else {
+                type = aiTextureType_DIFFUSE;
+            } else {
                 index = cur_emissive++;
-                type  = aiTextureType_EMISSIVE;
+                type = aiTextureType_EMISSIVE;
             }
-        }
-        else if ((*it).blend_src == Q3Shader::BLEND_GL_DST_COLOR && (*it).blend_dest == Q3Shader::BLEND_GL_ZERO) {
+        } else if ((*it).blend_src == Q3Shader::BLEND_GL_DST_COLOR && (*it).blend_dest == Q3Shader::BLEND_GL_ZERO) {
             index = cur_lm++;
-            type  = aiTextureType_LIGHTMAP;
-        }
-        else {
+            type = aiTextureType_LIGHTMAP;
+        } else {
             const int blend = aiBlendMode_Default;
-            out->AddProperty(&blend,1,AI_MATKEY_BLEND_FUNC);
+            out->AddProperty(&blend, 1, AI_MATKEY_BLEND_FUNC);
 
             index = cur_diffuse++;
-            type  = aiTextureType_DIFFUSE;
+            type = aiTextureType_DIFFUSE;
         }
 
         // setup texture
-        out->AddProperty(&s,AI_MATKEY_TEXTURE(type,index));
+        out->AddProperty(&s, AI_MATKEY_TEXTURE(type, index));
 
         // setup texture flags
         const int use_alpha = ((*it).alpha_test != Q3Shader::AT_NONE ? aiTextureFlags_UseAlpha : aiTextureFlags_IgnoreAlpha);
-        out->AddProperty(&use_alpha,1,AI_MATKEY_TEXFLAGS(type,index));
+        out->AddProperty(&use_alpha, 1, AI_MATKEY_TEXFLAGS(type, index));
     }
     // If at least one emissive texture was set, set the emissive base color to 1 to ensure
     // the texture is actually displayed.
     if (0 != cur_emissive) {
-        aiColor3D one(1.f,1.f,1.f);
-        out->AddProperty(&one,1,AI_MATKEY_COLOR_EMISSIVE);
+        aiColor3D one(1.f, 1.f, 1.f);
+        out->AddProperty(&one, 1, AI_MATKEY_COLOR_EMISSIVE);
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-MD3Importer::MD3Importer()
-    : configFrameID  (0)
-    , configHandleMP (true)
-    , configSpeedFlag()
-    , pcHeader()
-    , mBuffer()
-    , fileSize()
-    , mScene()
-    , mIOHandler()
-{}
+MD3Importer::MD3Importer() :
+        configFrameID(0), configHandleMP(true), configSpeedFlag(), pcHeader(), mBuffer(), fileSize(), mScene(), mIOHandler() {}
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-MD3Importer::~MD3Importer()
-{}
+MD3Importer::~MD3Importer() {}
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool MD3Importer::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
-{
-    const std::string extension = GetExtension(pFile);
-    if (extension == "md3")
-        return true;
-
-    // if check for extension is not enough, check for the magic tokens
-    if (!extension.length() || checkSig) {
-        uint32_t tokens[1];
-        tokens[0] = AI_MD3_MAGIC_NUMBER_LE;
-        return CheckMagicToken(pIOHandler,pFile,tokens,1);
-    }
-    return false;
+bool MD3Importer::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
+    static const uint32_t tokens[] = { AI_MD3_MAGIC_NUMBER_LE };
+    return CheckMagicToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------
-void MD3Importer::ValidateHeaderOffsets()
-{
+void MD3Importer::ValidateHeaderOffsets() {
     // Check magic number
     if (pcHeader->IDENT != AI_MD3_MAGIC_NUMBER_BE &&
-        pcHeader->IDENT != AI_MD3_MAGIC_NUMBER_LE)
-            throw DeadlyImportError( "Invalid MD3 file: Magic bytes not found");
+            pcHeader->IDENT != AI_MD3_MAGIC_NUMBER_LE)
+        throw DeadlyImportError("Invalid MD3 file: Magic bytes not found");
 
     // Check file format version
     if (pcHeader->VERSION > 15)
-        ASSIMP_LOG_WARN( "Unsupported MD3 file version. Continuing happily ...");
+        ASSIMP_LOG_WARN("Unsupported MD3 file version. Continuing happily ...");
 
     // Check some offset values whether they are valid
     if (!pcHeader->NUM_SURFACES)
-        throw DeadlyImportError( "Invalid md3 file: NUM_SURFACES is 0");
+        throw DeadlyImportError("Invalid md3 file: NUM_SURFACES is 0");
 
     if (pcHeader->OFS_FRAMES >= fileSize || pcHeader->OFS_SURFACES >= fileSize ||
-        pcHeader->OFS_EOF > fileSize) {
+            pcHeader->OFS_EOF > fileSize) {
         throw DeadlyImportError("Invalid MD3 header: some offsets are outside the file");
     }
 
-	if (pcHeader->NUM_SURFACES > AI_MAX_ALLOC(MD3::Surface)) {
+    if (pcHeader->NUM_SURFACES > AI_MAX_ALLOC(MD3::Surface)) {
         throw DeadlyImportError("Invalid MD3 header: too many surfaces, would overflow");
-	}
+    }
 
     if (pcHeader->OFS_SURFACES + pcHeader->NUM_SURFACES * sizeof(MD3::Surface) >= fileSize) {
         throw DeadlyImportError("Invalid MD3 header: some surfaces are outside the file");
     }
 
-    if (pcHeader->NUM_FRAMES <= configFrameID )
+    if (pcHeader->NUM_FRAMES <= configFrameID)
         throw DeadlyImportError("The requested frame is not existing the file");
 }
 
 // ------------------------------------------------------------------------------------------------
-void MD3Importer::ValidateSurfaceHeaderOffsets(const MD3::Surface* pcSurf)
-{
+void MD3Importer::ValidateSurfaceHeaderOffsets(const MD3::Surface *pcSurf) {
     // Calculate the relative offset of the surface
-    const int32_t ofs = int32_t((const unsigned char*)pcSurf-this->mBuffer);
+    const int32_t ofs = int32_t((const unsigned char *)pcSurf - this->mBuffer);
 
     // Check whether all data chunks are inside the valid range
-    if (pcSurf->OFS_TRIANGLES + ofs + pcSurf->NUM_TRIANGLES * sizeof(MD3::Triangle) > fileSize  ||
-        pcSurf->OFS_SHADERS + ofs + pcSurf->NUM_SHADER * sizeof(MD3::Shader) > fileSize         ||
-        pcSurf->OFS_ST + ofs + pcSurf->NUM_VERTICES * sizeof(MD3::TexCoord) > fileSize          ||
-        pcSurf->OFS_XYZNORMAL + ofs + pcSurf->NUM_VERTICES * sizeof(MD3::Vertex) > fileSize)    {
+    if (pcSurf->OFS_TRIANGLES + ofs + pcSurf->NUM_TRIANGLES * sizeof(MD3::Triangle) > fileSize ||
+            pcSurf->OFS_SHADERS + ofs + pcSurf->NUM_SHADER * sizeof(MD3::Shader) > fileSize ||
+            pcSurf->OFS_ST + ofs + pcSurf->NUM_VERTICES * sizeof(MD3::TexCoord) > fileSize ||
+            pcSurf->OFS_XYZNORMAL + ofs + pcSurf->NUM_VERTICES * sizeof(MD3::Vertex) > fileSize) {
 
         throw DeadlyImportError("Invalid MD3 surface header: some offsets are outside the file");
     }
@@ -454,39 +420,40 @@ void MD3Importer::ValidateSurfaceHeaderOffsets(const MD3::Surface* pcSurf)
 }
 
 // ------------------------------------------------------------------------------------------------
-const aiImporterDesc* MD3Importer::GetInfo () const {
+const aiImporterDesc *MD3Importer::GetInfo() const {
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup configuration properties
-void MD3Importer::SetupProperties(const Importer* pImp)
-{
+void MD3Importer::SetupProperties(const Importer *pImp) {
     // The
     // AI_CONFIG_IMPORT_MD3_KEYFRAME option overrides the
     // AI_CONFIG_IMPORT_GLOBAL_KEYFRAME option.
-    configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_MD3_KEYFRAME,-1);
-    if(static_cast<unsigned int>(-1) == configFrameID) {
-        configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_GLOBAL_KEYFRAME,0);
+    configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_MD3_KEYFRAME, -1);
+    if (static_cast<unsigned int>(-1) == configFrameID) {
+        configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_GLOBAL_KEYFRAME, 0);
     }
 
     // AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART
-    configHandleMP = (0 != pImp->GetPropertyInteger(AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART,1));
+    configHandleMP = (0 != pImp->GetPropertyInteger(AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART, 1));
 
     // AI_CONFIG_IMPORT_MD3_SKIN_NAME
-    configSkinFile = (pImp->GetPropertyString(AI_CONFIG_IMPORT_MD3_SKIN_NAME,"default"));
+    configSkinFile = (pImp->GetPropertyString(AI_CONFIG_IMPORT_MD3_SKIN_NAME, "default"));
+
+    // AI_CONFIG_IMPORT_MD3_LOAD_SHADERS
+    configLoadShaders = (pImp->GetPropertyBool(AI_CONFIG_IMPORT_MD3_LOAD_SHADERS, true));
 
     // AI_CONFIG_IMPORT_MD3_SHADER_SRC
-    configShaderFile = (pImp->GetPropertyString(AI_CONFIG_IMPORT_MD3_SHADER_SRC,""));
+    configShaderFile = (pImp->GetPropertyString(AI_CONFIG_IMPORT_MD3_SHADER_SRC, ""));
 
     // AI_CONFIG_FAVOUR_SPEED
-    configSpeedFlag = (0 != pImp->GetPropertyInteger(AI_CONFIG_FAVOUR_SPEED,0));
+    configSpeedFlag = (0 != pImp->GetPropertyInteger(AI_CONFIG_FAVOUR_SPEED, 0));
 }
 
 // ------------------------------------------------------------------------------------------------
 // Try to read the skin for a MD3 file
-void MD3Importer::ReadSkin(Q3Shader::SkinData& fill) const
-{
+void MD3Importer::ReadSkin(Q3Shader::SkinData &fill) const {
     // skip any postfixes (e.g. lower_1.md3)
     std::string::size_type s = filename.find_last_of('_');
     if (s == std::string::npos) {
@@ -497,51 +464,48 @@ void MD3Importer::ReadSkin(Q3Shader::SkinData& fill) const
     }
     ai_assert(s != std::string::npos);
 
-    const std::string skin_file = path + filename.substr(0,s) + "_" + configSkinFile + ".skin";
-    Q3Shader::LoadSkin(fill,skin_file,mIOHandler);
+    const std::string skin_file = path + filename.substr(0, s) + "_" + configSkinFile + ".skin";
+    Q3Shader::LoadSkin(fill, skin_file, mIOHandler);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Try to read the shader for a MD3 file
-void MD3Importer::ReadShader(Q3Shader::ShaderData& fill) const
-{
+void MD3Importer::ReadShader(Q3Shader::ShaderData &fill) const {
     // Determine Q3 model name from given path
-    const std::string::size_type s = path.find_last_of("\\/",path.length()-2);
-    const std::string model_file = path.substr(s+1,path.length()-(s+2));
+    const std::string::size_type s = path.find_last_of("\\/", path.length() - 2);
+    const std::string model_file = path.substr(s + 1, path.length() - (s + 2));
 
     // If no specific dir or file is given, use our default search behaviour
     if (!configShaderFile.length()) {
-        if(!Q3Shader::LoadShader(fill,path + "..\\..\\..\\scripts\\" + model_file + ".shader",mIOHandler)) {
-            Q3Shader::LoadShader(fill,path + "..\\..\\..\\scripts\\" + filename + ".shader",mIOHandler);
+        const char sep = mIOHandler->getOsSeparator();
+        if (!Q3Shader::LoadShader(fill, path + ".." + sep + ".." + sep + ".." + sep + "scripts" + sep + model_file + ".shader", mIOHandler)) {
+             Q3Shader::LoadShader(fill, path + ".." + sep + ".." + sep + ".." + sep + "scripts" + sep + filename + ".shader", mIOHandler);
         }
-    }
-    else {
+    } else {
         // If the given string specifies a file, load this file.
         // Otherwise it's a directory.
         const std::string::size_type st = configShaderFile.find_last_of('.');
         if (st == std::string::npos) {
 
-            if(!Q3Shader::LoadShader(fill,configShaderFile + model_file + ".shader",mIOHandler)) {
-                Q3Shader::LoadShader(fill,configShaderFile + filename + ".shader",mIOHandler);
+            if (!Q3Shader::LoadShader(fill, configShaderFile + model_file + ".shader", mIOHandler)) {
+                Q3Shader::LoadShader(fill, configShaderFile + filename + ".shader", mIOHandler);
             }
-        }
-        else {
-            Q3Shader::LoadShader(fill,configShaderFile,mIOHandler);
+        } else {
+            Q3Shader::LoadShader(fill, configShaderFile, mIOHandler);
         }
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Tiny helper to remove a single node from its parent' list
-void RemoveSingleNodeFromList(aiNode* nd)
-{
-    if (!nd || nd->mNumChildren || !nd->mParent)return;
-    aiNode* par = nd->mParent;
-    for (unsigned int i = 0; i < par->mNumChildren;++i) {
+void RemoveSingleNodeFromList(aiNode *nd) {
+    if (!nd || nd->mNumChildren || !nd->mParent) return;
+    aiNode *par = nd->mParent;
+    for (unsigned int i = 0; i < par->mNumChildren; ++i) {
         if (par->mChildren[i] == nd) {
             --par->mNumChildren;
-            for (;i < par->mNumChildren;++i) {
-                par->mChildren[i] = par->mChildren[i+1];
+            for (; i < par->mNumChildren; ++i) {
+                par->mChildren[i] = par->mChildren[i + 1];
             }
             delete nd;
             break;
@@ -551,8 +515,7 @@ void RemoveSingleNodeFromList(aiNode* nd)
 
 // ------------------------------------------------------------------------------------------------
 // Read a multi-part Q3 player model
-bool MD3Importer::ReadMultipartFile()
-{
+bool MD3Importer::ReadMultipartFile() {
     // check whether the file name contains a common postfix, e.g lower_2.md3
     std::string::size_type s = filename.find_last_of('_'), t = filename.find_last_of('.');
 
@@ -561,38 +524,38 @@ bool MD3Importer::ReadMultipartFile()
     if (s == std::string::npos)
         s = t;
 
-    const std::string mod_filename = filename.substr(0,s);
-    const std::string suffix = filename.substr(s,t-s);
+    const std::string mod_filename = filename.substr(0, s);
+    const std::string suffix = filename.substr(s, t - s);
 
-    if (mod_filename == "lower" || mod_filename == "upper" || mod_filename == "head"){
+    if (mod_filename == "lower" || mod_filename == "upper" || mod_filename == "head") {
         const std::string lower = path + "lower" + suffix + ".md3";
         const std::string upper = path + "upper" + suffix + ".md3";
-        const std::string head  = path + "head"  + suffix + ".md3";
+        const std::string head = path + "head" + suffix + ".md3";
 
-        aiScene* scene_upper = NULL;
-        aiScene* scene_lower = NULL;
-        aiScene* scene_head = NULL;
+        aiScene *scene_upper = nullptr;
+        aiScene *scene_lower = nullptr;
+        aiScene *scene_head = nullptr;
         std::string failure;
 
-        aiNode* tag_torso, *tag_head;
+        aiNode *tag_torso, *tag_head;
         std::vector<AttachmentInfo> attach;
 
         ASSIMP_LOG_INFO("Multi part MD3 player model: lower, upper and head parts are joined");
 
         // ensure we won't try to load ourselves recursively
         BatchLoader::PropertyMap props;
-        SetGenericProperty( props.ints, AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART, 0);
+        SetGenericProperty(props.ints, AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART, 0);
 
         // now read these three files
         BatchLoader batch(mIOHandler);
-        const unsigned int _lower = batch.AddLoadRequest(lower,0,&props);
-        const unsigned int _upper = batch.AddLoadRequest(upper,0,&props);
-        const unsigned int _head  = batch.AddLoadRequest(head,0,&props);
+        const unsigned int _lower = batch.AddLoadRequest(lower, 0, &props);
+        const unsigned int _upper = batch.AddLoadRequest(upper, 0, &props);
+        const unsigned int _head = batch.AddLoadRequest(head, 0, &props);
         batch.LoadAll();
 
         // now construct a dummy scene to place these three parts in
-        aiScene* master   = new aiScene();
-        aiNode* nd = master->mRootNode = new aiNode();
+        aiScene *master = new aiScene();
+        aiNode *nd = master->mRootNode = new aiNode();
         nd->mName.Set("<MD3_Player>");
 
         // ... and get them. We need all of them.
@@ -610,7 +573,7 @@ bool MD3Importer::ReadMultipartFile()
             goto error_cleanup;
         }
 
-        scene_head  = batch.GetImport(_head);
+        scene_head = batch.GetImport(_head);
         if (!scene_head) {
             ASSIMP_LOG_ERROR("M3D: Failed to read multi part model, head.md3 fails to load");
             failure = "head";
@@ -630,43 +593,43 @@ bool MD3Importer::ReadMultipartFile()
             goto error_cleanup;
         }
         scene_upper->mRootNode->mName.Set("upper");
-        attach.push_back(AttachmentInfo(scene_upper,tag_torso));
+        attach.push_back(AttachmentInfo(scene_upper, tag_torso));
 
         // tag_head
         tag_head = scene_upper->mRootNode->FindNode("tag_head");
         if (!tag_head) {
-            ASSIMP_LOG_ERROR( "M3D: Failed to find attachment tag for multi part model: tag_head expected");
+            ASSIMP_LOG_ERROR("M3D: Failed to find attachment tag for multi part model: tag_head expected");
             goto error_cleanup;
         }
         scene_head->mRootNode->mName.Set("head");
-        attach.push_back(AttachmentInfo(scene_head,tag_head));
+        attach.push_back(AttachmentInfo(scene_head, tag_head));
 
         // Remove tag_head and tag_torso from all other model parts ...
         // this ensures (together with AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY)
         // that tag_torso/tag_head is also the name of the (unique) output node
-        RemoveSingleNodeFromList (scene_upper->mRootNode->FindNode("tag_torso"));
-        RemoveSingleNodeFromList (scene_head-> mRootNode->FindNode("tag_head" ));
+        RemoveSingleNodeFromList(scene_upper->mRootNode->FindNode("tag_torso"));
+        RemoveSingleNodeFromList(scene_head->mRootNode->FindNode("tag_head"));
 
         // Undo the rotations which we applied to the coordinate systems. We're
         // working in global Quake space here
-        scene_head->mRootNode->mTransformation  = aiMatrix4x4();
+        scene_head->mRootNode->mTransformation = aiMatrix4x4();
         scene_lower->mRootNode->mTransformation = aiMatrix4x4();
         scene_upper->mRootNode->mTransformation = aiMatrix4x4();
 
         // and merge the scenes
-        SceneCombiner::MergeScenes(&mScene,master, attach,
-            AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES          |
-            AI_INT_MERGE_SCENE_GEN_UNIQUE_MATNAMES       |
-            AI_INT_MERGE_SCENE_RESOLVE_CROSS_ATTACHMENTS |
-            (!configSpeedFlag ? AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY : 0));
+        SceneCombiner::MergeScenes(&mScene, master, attach,
+                AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES |
+                        AI_INT_MERGE_SCENE_GEN_UNIQUE_MATNAMES |
+                        AI_INT_MERGE_SCENE_RESOLVE_CROSS_ATTACHMENTS |
+                        (!configSpeedFlag ? AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY : 0));
 
         // Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system
-        mScene->mRootNode->mTransformation = aiMatrix4x4(1.f,0.f,0.f,0.f,
-            0.f,0.f,1.f,0.f,0.f,-1.f,0.f,0.f,0.f,0.f,0.f,1.f);
+        mScene->mRootNode->mTransformation = aiMatrix4x4(1.f, 0.f, 0.f, 0.f,
+                0.f, 0.f, 1.f, 0.f, 0.f, -1.f, 0.f, 0.f, 0.f, 0.f, 0.f, 1.f);
 
         return true;
 
-error_cleanup:
+    error_cleanup:
         delete scene_upper;
         delete scene_lower;
         delete scene_head;
@@ -681,36 +644,35 @@ error_cleanup:
 
 // ------------------------------------------------------------------------------------------------
 // Convert a MD3 path to a proper value
-void MD3Importer::ConvertPath(const char* texture_name, const char* header_name, std::string& out) const
-{
+void MD3Importer::ConvertPath(const char *texture_name, const char *header_name, std::string &out) const {
     // If the MD3's internal path itself and the given path are using
     // the same directory, remove it completely to get right output paths.
-    const char* end1 = ::strrchr(header_name,'\\');
-    if (!end1)end1   = ::strrchr(header_name,'/');
+    const char *end1 = ::strrchr(header_name, '\\');
+    if (!end1) end1 = ::strrchr(header_name, '/');
 
-    const char* end2 = ::strrchr(texture_name,'\\');
-    if (!end2)end2   = ::strrchr(texture_name,'/');
+    const char *end2 = ::strrchr(texture_name, '\\');
+    if (!end2) end2 = ::strrchr(texture_name, '/');
 
     // HACK: If the paths starts with "models", ignore the
     // next two hierarchy levels, it specifies just the model name.
     // Ignored by Q3, it might be not equal to the real model location.
-    if (end2)   {
+    if (end2) {
 
         size_t len2;
         const size_t len1 = (size_t)(end1 - header_name);
-        if (!ASSIMP_strincmp(texture_name,"models",6) && (texture_name[6] == '/' || texture_name[6] == '\\')) {
+        if (!ASSIMP_strincmp(texture_name, "models", 6) && (texture_name[6] == '/' || texture_name[6] == '\\')) {
             len2 = 6; // ignore the seventh - could be slash or backslash
 
             if (!header_name[0]) {
                 // Use the file name only
-                out = end2+1;
+                out = end2 + 1;
                 return;
             }
-        }
-        else len2 = std::min (len1, (size_t)(end2 - texture_name ));
-        if (!ASSIMP_strincmp(texture_name,header_name,static_cast<unsigned int>(len2))) {
+        } else
+            len2 = std::min(len1, (size_t)(end2 - texture_name));
+        if (!ASSIMP_strincmp(texture_name, header_name, static_cast<unsigned int>(len2))) {
             // Use the file name only
-            out = end2+1;
+            out = end2 + 1;
             return;
         }
     }
@@ -720,7 +682,7 @@ void MD3Importer::ConvertPath(const char* texture_name, const char* header_name,
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void MD3Importer::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) {
+void MD3Importer::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
     mFile = pFile;
     mScene = pScene;
     mIOHandler = pIOHandler;
@@ -735,7 +697,7 @@ void MD3Importer::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
     }
     filename = mFile.substr(s), path = mFile.substr(0, s);
     for (std::string::iterator it = filename.begin(); it != filename.end(); ++it) {
-        *it = static_cast<char>( tolower(*it) );
+        *it = static_cast<char>(tolower(static_cast<unsigned char>(*it)));
     }
 
     // Load multi-part model file, if necessary
@@ -744,23 +706,24 @@ void MD3Importer::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
             return;
     }
 
-    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile));
+    std::unique_ptr<IOStream> file(pIOHandler->Open(pFile));
 
     // Check whether we can read from the file
-    if( file.get() == NULL)
-        throw DeadlyImportError( "Failed to open MD3 file " + pFile + ".");
+    if (file.get() == nullptr) {
+        throw DeadlyImportError("Failed to open MD3 file ", pFile, ".");
+    }
 
     // Check whether the md3 file is large enough to contain the header
     fileSize = (unsigned int)file->FileSize();
-    if( fileSize < sizeof(MD3::Header))
-        throw DeadlyImportError( "MD3 File is too small.");
+    if (fileSize < sizeof(MD3::Header))
+        throw DeadlyImportError("MD3 File is too small.");
 
     // Allocate storage and copy the contents of the file to a memory buffer
-    std::vector<unsigned char> mBuffer2 (fileSize);
-    file->Read( &mBuffer2[0], 1, fileSize);
+    std::vector<unsigned char> mBuffer2(fileSize);
+    file->Read(&mBuffer2[0], 1, fileSize);
     mBuffer = &mBuffer2[0];
 
-    pcHeader = (BE_NCONST MD3::Header*)mBuffer;
+    pcHeader = (BE_NCONST MD3::Header *)mBuffer;
 
     // Ensure correct endianness
 #ifdef AI_BUILD_BIG_ENDIAN
@@ -783,10 +746,10 @@ void MD3Importer::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
     ValidateHeaderOffsets();
 
     // Navigate to the list of surfaces
-    BE_NCONST MD3::Surface* pcSurfaces = (BE_NCONST MD3::Surface*)(mBuffer + pcHeader->OFS_SURFACES);
+    BE_NCONST MD3::Surface *pcSurfaces = (BE_NCONST MD3::Surface *)(mBuffer + pcHeader->OFS_SURFACES);
 
     // Navigate to the list of tags
-    BE_NCONST MD3::Tag* pcTags = (BE_NCONST MD3::Tag*)(mBuffer + pcHeader->OFS_TAGS);
+    BE_NCONST MD3::Tag *pcTags = (BE_NCONST MD3::Tag *)(mBuffer + pcHeader->OFS_TAGS);
 
     // Allocate output storage
     pScene->mNumMeshes = pcHeader->NUM_SURFACES;
@@ -797,14 +760,14 @@ void MD3Importer::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
         // since those pointers will eventually have to point to real objects
         throw DeadlyImportError("MD3: Too many surfaces, would run out of memory");
     }
-    pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];
+    pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
 
     pScene->mNumMaterials = pcHeader->NUM_SURFACES;
-    pScene->mMaterials = new aiMaterial*[pScene->mNumMeshes];
+    pScene->mMaterials = new aiMaterial *[pScene->mNumMeshes];
 
     // Set arrays to zero to ensue proper destruction if an exception is raised
-    ::memset(pScene->mMeshes,0,pScene->mNumMeshes*sizeof(aiMesh*));
-    ::memset(pScene->mMaterials,0,pScene->mNumMaterials*sizeof(aiMaterial*));
+    ::memset(pScene->mMeshes, 0, pScene->mNumMeshes * sizeof(aiMesh *));
+    ::memset(pScene->mMaterials, 0, pScene->mNumMaterials * sizeof(aiMaterial *));
 
     // Now read possible skins from .skin file
     Q3Shader::SkinData skins;
@@ -812,16 +775,18 @@ void MD3Importer::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
 
     // And check whether we can locate a shader file for this model
     Q3Shader::ShaderData shaders;
-    ReadShader(shaders);
+    if (configLoadShaders){
+        ReadShader(shaders);
+    }
 
     // Adjust all texture paths in the shader
-    const char* header_name = pcHeader->NAME;
+    const char *header_name = pcHeader->NAME;
     if (!shaders.blocks.empty()) {
-        for (std::list< Q3Shader::ShaderDataBlock >::iterator dit = shaders.blocks.begin(); dit != shaders.blocks.end(); ++dit) {
-            ConvertPath((*dit).name.c_str(),header_name,(*dit).name);
+        for (std::list<Q3Shader::ShaderDataBlock>::iterator dit = shaders.blocks.begin(); dit != shaders.blocks.end(); ++dit) {
+            ConvertPath((*dit).name.c_str(), header_name, (*dit).name);
 
-            for (std::list< Q3Shader::ShaderMapBlock >::iterator mit = (*dit).maps.begin(); mit != (*dit).maps.end(); ++mit) {
-                ConvertPath((*mit).name.c_str(),header_name,(*mit).name);
+            for (std::list<Q3Shader::ShaderMapBlock>::iterator mit = (*dit).maps.begin(); mit != (*dit).maps.end(); ++mit) {
+                ConvertPath((*mit).name.c_str(), header_name, (*mit).name);
             }
         }
     }
@@ -829,7 +794,7 @@ void MD3Importer::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
     // Read all surfaces from the file
     unsigned int iNum = pcHeader->NUM_SURFACES;
     unsigned int iNumMaterials = 0;
-    while (iNum-- > 0)  {
+    while (iNum-- > 0) {
 
         // Ensure correct endianness
 #ifdef AI_BUILD_BIG_ENDIAN
@@ -852,57 +817,57 @@ void MD3Importer::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
         ValidateSurfaceHeaderOffsets(pcSurfaces);
 
         // Navigate to the vertex list of the surface
-        BE_NCONST MD3::Vertex* pcVertices = (BE_NCONST MD3::Vertex*)
-            (((uint8_t*)pcSurfaces) + pcSurfaces->OFS_XYZNORMAL);
+        BE_NCONST MD3::Vertex *pcVertices = (BE_NCONST MD3::Vertex *)(((uint8_t *)pcSurfaces) + pcSurfaces->OFS_XYZNORMAL);
 
         // Navigate to the triangle list of the surface
-        BE_NCONST MD3::Triangle* pcTriangles = (BE_NCONST MD3::Triangle*)
-            (((uint8_t*)pcSurfaces) + pcSurfaces->OFS_TRIANGLES);
+        BE_NCONST MD3::Triangle *pcTriangles = (BE_NCONST MD3::Triangle *)(((uint8_t *)pcSurfaces) + pcSurfaces->OFS_TRIANGLES);
 
         // Navigate to the texture coordinate list of the surface
-        BE_NCONST MD3::TexCoord* pcUVs = (BE_NCONST MD3::TexCoord*)
-            (((uint8_t*)pcSurfaces) + pcSurfaces->OFS_ST);
+        BE_NCONST MD3::TexCoord *pcUVs = (BE_NCONST MD3::TexCoord *)(((uint8_t *)pcSurfaces) + pcSurfaces->OFS_ST);
 
         // Navigate to the shader list of the surface
-        BE_NCONST MD3::Shader* pcShaders = (BE_NCONST MD3::Shader*)
-            (((uint8_t*)pcSurfaces) + pcSurfaces->OFS_SHADERS);
+        BE_NCONST MD3::Shader *pcShaders = (BE_NCONST MD3::Shader *)(((uint8_t *)pcSurfaces) + pcSurfaces->OFS_SHADERS);
 
         // If the submesh is empty ignore it
-        if (0 == pcSurfaces->NUM_VERTICES || 0 == pcSurfaces->NUM_TRIANGLES)
-        {
-            pcSurfaces = (BE_NCONST MD3::Surface*)(((uint8_t*)pcSurfaces) + pcSurfaces->OFS_END);
+        if (0 == pcSurfaces->NUM_VERTICES || 0 == pcSurfaces->NUM_TRIANGLES) {
+            pcSurfaces = (BE_NCONST MD3::Surface *)(((uint8_t *)pcSurfaces) + pcSurfaces->OFS_END);
             pScene->mNumMeshes--;
             continue;
         }
 
         // Allocate output mesh
         pScene->mMeshes[iNum] = new aiMesh();
-        aiMesh* pcMesh = pScene->mMeshes[iNum];
+        aiMesh *pcMesh = pScene->mMeshes[iNum];
 
         std::string _texture_name;
-        const char* texture_name = NULL;
+        const char *texture_name = nullptr;
 
         // Check whether we have a texture record for this surface in the .skin file
-        std::list< Q3Shader::SkinData::TextureEntry >::iterator it = std::find(
-            skins.textures.begin(), skins.textures.end(), pcSurfaces->NAME );
+        std::list<Q3Shader::SkinData::TextureEntry>::iterator it = std::find(
+                skins.textures.begin(), skins.textures.end(), pcSurfaces->NAME);
 
         if (it != skins.textures.end()) {
-            texture_name = &*( _texture_name = (*it).second).begin();
-            ASSIMP_LOG_DEBUG_F("MD3: Assigning skin texture ", (*it).second, " to surface ", pcSurfaces->NAME);
+            texture_name = &*(_texture_name = (*it).second).begin();
+            ASSIMP_LOG_VERBOSE_DEBUG("MD3: Assigning skin texture ", (*it).second, " to surface ", pcSurfaces->NAME);
             (*it).resolved = true; // mark entry as resolved
         }
 
         // Get the first shader (= texture?) assigned to the surface
-        if (!texture_name && pcSurfaces->NUM_SHADER)    {
+        if (!texture_name && pcSurfaces->NUM_SHADER) {
             texture_name = pcShaders->NAME;
         }
 
         std::string convertedPath;
         if (texture_name) {
-            ConvertPath(texture_name,header_name,convertedPath);
+            if (configLoadShaders){
+                ConvertPath(texture_name, header_name, convertedPath);
+            }
+            else{
+                convertedPath = texture_name;
+            }
         }
 
-        const Q3Shader::ShaderDataBlock* shader = NULL;
+        const Q3Shader::ShaderDataBlock *shader = nullptr;
 
         // Now search the current shader for a record with this name (
         // excluding texture file extension)
@@ -912,18 +877,18 @@ void MD3Importer::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
                 sh = convertedPath.length();
             }
 
-            const std::string without_ext = convertedPath.substr(0,sh);
-            std::list< Q3Shader::ShaderDataBlock >::const_iterator dit = std::find(shaders.blocks.begin(),shaders.blocks.end(),without_ext);
+            const std::string without_ext = convertedPath.substr(0, sh);
+            std::list<Q3Shader::ShaderDataBlock>::const_iterator dit = std::find(shaders.blocks.begin(), shaders.blocks.end(), without_ext);
             if (dit != shaders.blocks.end()) {
                 // We made it!
                 shader = &*dit;
-                ASSIMP_LOG_INFO("Found shader record for " +without_ext );
+                ASSIMP_LOG_INFO("Found shader record for ", without_ext);
             } else {
-                ASSIMP_LOG_WARN("Unable to find shader record for " + without_ext);
+                ASSIMP_LOG_WARN("Unable to find shader record for ", without_ext);
             }
         }
 
-        aiMaterial* pcHelper = new aiMaterial();
+        aiMaterial *pcHelper = new aiMaterial();
 
         const int iMode = (int)aiShadingMode_Gouraud;
         pcHelper->AddProperty<int>(&iMode, 1, AI_MATKEY_SHADING_MODEL);
@@ -931,51 +896,51 @@ void MD3Importer::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
         // Add a small ambient color value - Quake 3 seems to have one
         aiColor3D clr;
         clr.b = clr.g = clr.r = 0.05f;
-        pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_AMBIENT);
+        pcHelper->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_AMBIENT);
 
         clr.b = clr.g = clr.r = 1.0f;
-        pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_DIFFUSE);
-        pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_SPECULAR);
+        pcHelper->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_DIFFUSE);
+        pcHelper->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_SPECULAR);
 
         // use surface name + skin_name as material name
         aiString name;
         name.Set("MD3_[" + configSkinFile + "][" + pcSurfaces->NAME + "]");
-        pcHelper->AddProperty(&name,AI_MATKEY_NAME);
+        pcHelper->AddProperty(&name, AI_MATKEY_NAME);
 
         if (!shader) {
             // Setup dummy texture file name to ensure UV coordinates are kept during postprocessing
             aiString szString;
             if (convertedPath.length()) {
                 szString.Set(convertedPath);
-            } else    {
+            } else {
                 ASSIMP_LOG_WARN("Texture file name has zero length. Using default name");
                 szString.Set("dummy_texture.bmp");
             }
-            pcHelper->AddProperty(&szString,AI_MATKEY_TEXTURE_DIFFUSE(0));
+            pcHelper->AddProperty(&szString, AI_MATKEY_TEXTURE_DIFFUSE(0));
 
             // prevent transparency by default
             int no_alpha = aiTextureFlags_IgnoreAlpha;
-            pcHelper->AddProperty(&no_alpha,1,AI_MATKEY_TEXFLAGS_DIFFUSE(0));
+            pcHelper->AddProperty(&no_alpha, 1, AI_MATKEY_TEXFLAGS_DIFFUSE(0));
         } else {
-            Q3Shader::ConvertShaderToMaterial(pcHelper,*shader);
+            Q3Shader::ConvertShaderToMaterial(pcHelper, *shader);
         }
 
-        pScene->mMaterials[iNumMaterials] = (aiMaterial*)pcHelper;
+        pScene->mMaterials[iNumMaterials] = (aiMaterial *)pcHelper;
         pcMesh->mMaterialIndex = iNumMaterials++;
 
-            // Ensure correct endianness
+        // Ensure correct endianness
 #ifdef AI_BUILD_BIG_ENDIAN
 
-        for (uint32_t i = 0; i < pcSurfaces->NUM_VERTICES;++i)  {
-            AI_SWAP2( pcVertices[i].NORMAL );
-            AI_SWAP2( pcVertices[i].X );
-            AI_SWAP2( pcVertices[i].Y );
-            AI_SWAP2( pcVertices[i].Z );
+        for (uint32_t i = 0; i < pcSurfaces->NUM_VERTICES; ++i) {
+            AI_SWAP2(pcVertices[i].NORMAL);
+            AI_SWAP2(pcVertices[i].X);
+            AI_SWAP2(pcVertices[i].Y);
+            AI_SWAP2(pcVertices[i].Z);
 
-            AI_SWAP4( pcUVs[i].U );
-            AI_SWAP4( pcUVs[i].U );
+            AI_SWAP4(pcUVs[i].U);
+            AI_SWAP4(pcUVs[i].V);
         }
-        for (uint32_t i = 0; i < pcSurfaces->NUM_TRIANGLES;++i) {
+        for (uint32_t i = 0; i < pcSurfaces->NUM_TRIANGLES; ++i) {
             AI_SWAP4(pcTriangles[i].INDEXES[0]);
             AI_SWAP4(pcTriangles[i].INDEXES[1]);
             AI_SWAP4(pcTriangles[i].INDEXES[2]);
@@ -986,64 +951,64 @@ void MD3Importer::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
         // Fill mesh information
         pcMesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
 
-        pcMesh->mNumVertices        = pcSurfaces->NUM_TRIANGLES*3;
-        pcMesh->mNumFaces           = pcSurfaces->NUM_TRIANGLES;
-        pcMesh->mFaces              = new aiFace[pcSurfaces->NUM_TRIANGLES];
-        pcMesh->mNormals            = new aiVector3D[pcMesh->mNumVertices];
-        pcMesh->mVertices           = new aiVector3D[pcMesh->mNumVertices];
-        pcMesh->mTextureCoords[0]   = new aiVector3D[pcMesh->mNumVertices];
+        pcMesh->mNumVertices = pcSurfaces->NUM_TRIANGLES * 3;
+        pcMesh->mNumFaces = pcSurfaces->NUM_TRIANGLES;
+        pcMesh->mFaces = new aiFace[pcSurfaces->NUM_TRIANGLES];
+        pcMesh->mNormals = new aiVector3D[pcMesh->mNumVertices];
+        pcMesh->mVertices = new aiVector3D[pcMesh->mNumVertices];
+        pcMesh->mTextureCoords[0] = new aiVector3D[pcMesh->mNumVertices];
         pcMesh->mNumUVComponents[0] = 2;
 
         // Fill in all triangles
         unsigned int iCurrent = 0;
-        for (unsigned int i = 0; i < (unsigned int)pcSurfaces->NUM_TRIANGLES;++i)   {
+        for (unsigned int i = 0; i < (unsigned int)pcSurfaces->NUM_TRIANGLES; ++i) {
             pcMesh->mFaces[i].mIndices = new unsigned int[3];
             pcMesh->mFaces[i].mNumIndices = 3;
 
             //unsigned int iTemp = iCurrent;
-            for (unsigned int c = 0; c < 3;++c,++iCurrent)  {
+            for (unsigned int c = 0; c < 3; ++c, ++iCurrent) {
                 pcMesh->mFaces[i].mIndices[c] = iCurrent;
 
                 // Read vertices
-                aiVector3D& vec = pcMesh->mVertices[iCurrent];
+                aiVector3D &vec = pcMesh->mVertices[iCurrent];
                 uint32_t index = pcTriangles->INDEXES[c];
                 if (index >= pcSurfaces->NUM_VERTICES) {
-                    throw DeadlyImportError( "MD3: Invalid vertex index");
+                    throw DeadlyImportError("MD3: Invalid vertex index");
                 }
-                vec.x = pcVertices[index].X*AI_MD3_XYZ_SCALE;
-                vec.y = pcVertices[index].Y*AI_MD3_XYZ_SCALE;
-                vec.z = pcVertices[index].Z*AI_MD3_XYZ_SCALE;
+                vec.x = pcVertices[index].X * AI_MD3_XYZ_SCALE;
+                vec.y = pcVertices[index].Y * AI_MD3_XYZ_SCALE;
+                vec.z = pcVertices[index].Z * AI_MD3_XYZ_SCALE;
 
                 // Convert the normal vector to uncompressed float3 format
-                aiVector3D& nor = pcMesh->mNormals[iCurrent];
-                LatLngNormalToVec3(pcVertices[index].NORMAL,(ai_real*)&nor);
+                aiVector3D &nor = pcMesh->mNormals[iCurrent];
+                LatLngNormalToVec3(pcVertices[index].NORMAL, (ai_real *)&nor);
 
                 // Read texture coordinates
                 pcMesh->mTextureCoords[0][iCurrent].x = pcUVs[index].U;
-                pcMesh->mTextureCoords[0][iCurrent].y = 1.0f-pcUVs[index].V;
+                pcMesh->mTextureCoords[0][iCurrent].y = 1.0f - pcUVs[index].V;
             }
-            // Flip face order if necessary
-            if (!shader || shader->cull == Q3Shader::CULL_CW) {
-                std::swap(pcMesh->mFaces[i].mIndices[2],pcMesh->mFaces[i].mIndices[1]);
+            // Flip face order normally, unless shader is backfacing
+            if (!(shader && shader->cull == Q3Shader::CULL_CCW)) {
+                std::swap(pcMesh->mFaces[i].mIndices[2], pcMesh->mFaces[i].mIndices[1]);
             }
             ++pcTriangles;
         }
 
         // Go to the next surface
-        pcSurfaces = (BE_NCONST MD3::Surface*)(((unsigned char*)pcSurfaces) + pcSurfaces->OFS_END);
+        pcSurfaces = (BE_NCONST MD3::Surface *)(((unsigned char *)pcSurfaces) + pcSurfaces->OFS_END);
     }
 
     // For debugging purposes: check whether we found matches for all entries in the skins file
     if (!DefaultLogger::isNullLogger()) {
-        for (std::list< Q3Shader::SkinData::TextureEntry>::const_iterator it = skins.textures.begin();it != skins.textures.end(); ++it) {
+        for (std::list<Q3Shader::SkinData::TextureEntry>::const_iterator it = skins.textures.begin(); it != skins.textures.end(); ++it) {
             if (!(*it).resolved) {
-                ASSIMP_LOG_ERROR_F("MD3: Failed to match skin ", (*it).first, " to surface ", (*it).second);
+                ASSIMP_LOG_ERROR("MD3: Failed to match skin ", (*it).first, " to surface ", (*it).second);
             }
         }
     }
 
     if (!pScene->mNumMeshes) {
-        throw DeadlyImportError( "MD3: File contains no valid mesh");
+        throw DeadlyImportError("MD3: File contains no valid mesh");
     }
     pScene->mNumMaterials = iNumMaterials;
 
@@ -1055,11 +1020,11 @@ void MD3Importer::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
     // Attach tiny children for all tags
     if (pcHeader->NUM_TAGS) {
         pScene->mRootNode->mNumChildren = pcHeader->NUM_TAGS;
-        pScene->mRootNode->mChildren = new aiNode*[pcHeader->NUM_TAGS];
+        pScene->mRootNode->mChildren = new aiNode *[pcHeader->NUM_TAGS];
 
         for (unsigned int i = 0; i < pcHeader->NUM_TAGS; ++i, ++pcTags) {
-            aiNode* nd = pScene->mRootNode->mChildren[i] = new aiNode();
-            nd->mName.Set((const char*)pcTags->NAME);
+            aiNode *nd = pScene->mRootNode->mChildren[i] = new aiNode();
+            nd->mName.Set((const char *)pcTags->NAME);
             nd->mParent = pScene->mRootNode;
 
             AI_SWAP4(pcTags->origin.x);
@@ -1072,8 +1037,8 @@ void MD3Importer::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
             nd->mTransformation.c4 = pcTags->origin.z;
 
             // Copy rest of transformation (need to transpose to match row-order matrix)
-            for (unsigned int a = 0; a < 3;++a) {
-                for (unsigned int m = 0; m < 3;++m) {
+            for (unsigned int a = 0; a < 3; ++a) {
+                for (unsigned int m = 0; m < 3; ++m) {
                     nd->mTransformation[m][a] = pcTags->orientation[a][m];
                     AI_SWAP4(nd->mTransformation[m][a]);
                 }
@@ -1081,16 +1046,15 @@ void MD3Importer::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
         }
     }
 
-    for (unsigned int i = 0; i < pScene->mNumMeshes;++i)
+    for (unsigned int i = 0; i < pScene->mNumMeshes; ++i)
         pScene->mRootNode->mMeshes[i] = i;
 
     // Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system
     pScene->mRootNode->mTransformation = aiMatrix4x4(
-        1.f,0.f,0.f,0.f,
-        0.f,0.f,1.f,0.f,
-        0.f,-1.f,0.f,0.f,
-        0.f,0.f,0.f,1.f
-    );
+            1.f, 0.f, 0.f, 0.f,
+            0.f, 0.f, 1.f, 0.f,
+            0.f, -1.f, 0.f, 0.f,
+            0.f, 0.f, 0.f, 1.f);
 }
 
 #endif // !! ASSIMP_BUILD_NO_MD3_IMPORTER
diff --git a/Engine/lib/assimp/code/MD3/MD3Loader.h b/Engine/lib/assimp/code/AssetLib/MD3/MD3Loader.h
similarity index 81%
rename from Engine/lib/assimp/code/MD3/MD3Loader.h
rename to Engine/lib/assimp/code/AssetLib/MD3/MD3Loader.h
index 01b840228..d911bb1da 100644
--- a/Engine/lib/assimp/code/MD3/MD3Loader.h
+++ b/Engine/lib/assimp/code/AssetLib/MD3/MD3Loader.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -46,9 +45,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_MD3LOADER_H_INCLUDED
 #define AI_MD3LOADER_H_INCLUDED
 
+#include "MD3FileData.h"
 #include <assimp/BaseImporter.h>
 #include <assimp/ByteSwapper.h>
-#include "MD3FileData.h"
 #include <assimp/StringComparison.h>
 #include <assimp/types.h>
 
@@ -56,8 +55,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 struct aiMaterial;
 
-namespace Assimp    {
-
+namespace Assimp {
 
 using namespace MD3;
 namespace Q3Shader {
@@ -65,16 +63,14 @@ namespace Q3Shader {
 // ---------------------------------------------------------------------------
 /** @brief Tiny utility data structure to hold the data of a .skin file
  */
-struct SkinData
-{
-    //! A single entryin texture list
-    struct TextureEntry : public std::pair<std::string,std::string>
-    {
+struct SkinData {
+    //! A single entry in texture list
+    struct TextureEntry : public std::pair<std::string, std::string> {
         // did we resolve this texture entry?
         bool resolved;
 
         // for std::find()
-        bool operator == (const std::string& f) const {
+        bool operator==(const std::string &f) const {
             return f == first;
         }
     };
@@ -88,8 +84,7 @@ struct SkinData
 // ---------------------------------------------------------------------------
 /** @brief Specifies cull modi for Quake shader files.
  */
-enum ShaderCullMode
-{
+enum ShaderCullMode {
     CULL_NONE,
     CULL_CW,
     CULL_CCW
@@ -98,8 +93,7 @@ enum ShaderCullMode
 // ---------------------------------------------------------------------------
 /** @brief Specifies alpha blend modi (src + dest) for Quake shader files
  */
-enum BlendFunc
-{
+enum BlendFunc {
     BLEND_NONE,
     BLEND_GL_ONE,
     BLEND_GL_ZERO,
@@ -112,8 +106,7 @@ enum BlendFunc
 // ---------------------------------------------------------------------------
 /** @brief Specifies alpha test modi for Quake texture maps
  */
-enum AlphaTestFunc
-{
+enum AlphaTestFunc {
     AT_NONE,
     AT_GT0,
     AT_LT128,
@@ -123,36 +116,31 @@ enum AlphaTestFunc
 // ---------------------------------------------------------------------------
 /** @brief Tiny utility data structure to hold a .shader map data block
  */
-struct ShaderMapBlock
-{
+struct ShaderMapBlock {
     ShaderMapBlock() AI_NO_EXCEPT
-         :  blend_src   (BLEND_NONE)
-         ,  blend_dest  (BLEND_NONE)
-         ,  alpha_test  (AT_NONE)
-    {}
+            : blend_src(BLEND_NONE),
+              blend_dest(BLEND_NONE),
+              alpha_test(AT_NONE) {}
 
     //! Name of referenced map
     std::string name;
 
     //! Blend and alpha test settings for texture
-    BlendFunc blend_src,blend_dest;
+    BlendFunc blend_src, blend_dest;
     AlphaTestFunc alpha_test;
 
-
     //! For std::find()
-    bool operator== (const std::string& o) const {
-        return !ASSIMP_stricmp(o,name);
+    bool operator==(const std::string &o) const {
+        return !ASSIMP_stricmp(o, name);
     }
 };
 
 // ---------------------------------------------------------------------------
 /** @brief Tiny utility data structure to hold a .shader data block
  */
-struct ShaderDataBlock
-{
+struct ShaderDataBlock {
     ShaderDataBlock() AI_NO_EXCEPT
-        :   cull    (CULL_CW)
-    {}
+            : cull(CULL_CW) {}
 
     //! Name of referenced data element
     std::string name;
@@ -163,18 +151,16 @@ struct ShaderDataBlock
     //! Maps defined in the shader
     std::list<ShaderMapBlock> maps;
 
-
     //! For std::find()
-    bool operator== (const std::string& o) const {
-        return !ASSIMP_stricmp(o,name);
+    bool operator==(const std::string &o) const {
+        return !ASSIMP_stricmp(o, name);
     }
 };
 
 // ---------------------------------------------------------------------------
 /** @brief Tiny utility data structure to hold the data of a .shader file
  */
-struct ShaderData
-{
+struct ShaderData {
     //! Shader data blocks
     std::list<ShaderDataBlock> blocks;
 };
@@ -188,8 +174,7 @@ struct ShaderData
  *  @param io IOSystem to be used for reading
  *  @return false if file is not accessible
  */
-bool LoadShader(ShaderData& fill, const std::string& file,IOSystem* io);
-
+bool LoadShader(ShaderData &fill, const std::string &file, IOSystem *io);
 
 // ---------------------------------------------------------------------------
 /** @brief Convert a Q3Shader to an aiMaterial
@@ -197,7 +182,7 @@ bool LoadShader(ShaderData& fill, const std::string& file,IOSystem* io);
  *  @param[out] out Material structure to be filled.
  *  @param[in] shader Input shader
  */
-void ConvertShaderToMaterial(aiMaterial* out, const ShaderDataBlock& shader);
+void ConvertShaderToMaterial(aiMaterial *out, const ShaderDataBlock &shader);
 
 // ---------------------------------------------------------------------------
 /** @brief Load a skin file
@@ -208,56 +193,50 @@ void ConvertShaderToMaterial(aiMaterial* out, const ShaderDataBlock& shader);
  *  @param io IOSystem to be used for reading
  *  @return false if file is not accessible
  */
-bool LoadSkin(SkinData& fill, const std::string& file,IOSystem* io);
+bool LoadSkin(SkinData &fill, const std::string &file, IOSystem *io);
 
-} // ! namespace Q3SHader
+} // namespace Q3Shader
 
 // ---------------------------------------------------------------------------
 /** @brief Importer class to load MD3 files
 */
-class MD3Importer : public BaseImporter
-{
+class MD3Importer : public BaseImporter {
 public:
     MD3Importer();
-    ~MD3Importer();
-
-
-public:
+    ~MD3Importer() override;
 
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
     * See BaseImporter::CanRead() for details.  */
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
-
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
+            bool checkSig) const override;
 
     // -------------------------------------------------------------------
     /** Called prior to ReadFile().
     * The function is a request to the importer to update its configuration
     * basing on the Importer's configuration property list.
     */
-    void SetupProperties(const Importer* pImp);
+    void SetupProperties(const Importer *pImp) override;
 
 protected:
-
     // -------------------------------------------------------------------
     /** Return importer meta information.
      * See #BaseImporter::GetInfo for the details
      */
-    const aiImporterDesc* GetInfo () const;
+    const aiImporterDesc *GetInfo() const override;
 
     // -------------------------------------------------------------------
     /** Imports the given file into the given scene structure.
      * See BaseImporter::InternReadFile() for details
      */
-    void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
+    void InternReadFile(const std::string &pFile, aiScene *pScene,
+            IOSystem *pIOHandler) override;
 
     // -------------------------------------------------------------------
     /** Validate offsets in the header
      */
     void ValidateHeaderOffsets();
-    void ValidateSurfaceHeaderOffsets(const MD3::Surface* pcSurfHeader);
+    void ValidateSurfaceHeaderOffsets(const MD3::Surface *pcSurfHeader);
 
     // -------------------------------------------------------------------
     /** Read a Q3 multipart file
@@ -269,13 +248,13 @@ protected:
     /** Try to read the skin for a MD3 file
      *  @param fill Receives output information
      */
-    void ReadSkin(Q3Shader::SkinData& fill) const;
+    void ReadSkin(Q3Shader::SkinData &fill) const;
 
     // -------------------------------------------------------------------
     /** Try to read the shader for a MD3 file
      *  @param fill Receives output information
      */
-    void ReadShader(Q3Shader::ShaderData& fill) const;
+    void ReadShader(Q3Shader::ShaderData &fill) const;
 
     // -------------------------------------------------------------------
     /** Convert a texture path in a MD3 file to a proper value
@@ -283,11 +262,10 @@ protected:
      *  @param[in] header_path Base path specified in MD3 header
      *  @param[out] out Receives the converted output string
      */
-    void ConvertPath(const char* texture_name, const char* header_path,
-        std::string& out) const;
+    void ConvertPath(const char *texture_name, const char *header_path,
+            std::string &out) const;
 
 protected:
-
     /** Configuration option: frame to be loaded */
     unsigned int configFrameID;
 
@@ -297,6 +275,9 @@ protected:
     /** Configuration option: name of skin file to be read */
     std::string configSkinFile;
 
+    /** Configuration option: whether to load shaders */
+    bool configLoadShaders;
+
     /** Configuration option: name or path of shader */
     std::string configShaderFile;
 
@@ -304,10 +285,10 @@ protected:
     bool configSpeedFlag;
 
     /** Header of the MD3 file */
-    BE_NCONST MD3::Header* pcHeader;
+    BE_NCONST MD3::Header *pcHeader;
 
     /** File buffer  */
-    BE_NCONST unsigned char* mBuffer;
+    BE_NCONST unsigned char *mBuffer;
 
     /** Size of the file, in bytes */
     unsigned int fileSize;
@@ -322,11 +303,11 @@ protected:
     std::string filename;
 
     /** Output scene to be filled */
-    aiScene* mScene;
+    aiScene *mScene;
 
     /** IO system to be used to access the data*/
-    IOSystem* mIOHandler;
-    };
+    IOSystem *mIOHandler;
+};
 
 } // end of namespace Assimp
 
diff --git a/Engine/lib/assimp/code/MD4/MD4FileData.h b/Engine/lib/assimp/code/AssetLib/MD4/MD4FileData.h
similarity index 99%
rename from Engine/lib/assimp/code/MD4/MD4FileData.h
rename to Engine/lib/assimp/code/AssetLib/MD4/MD4FileData.h
index ed3dc65e7..880df3230 100644
--- a/Engine/lib/assimp/code/MD4/MD4FileData.h
+++ b/Engine/lib/assimp/code/AssetLib/MD4/MD4FileData.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (ASSIMP)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2010, ASSIMP Development Team
+Copyright (c) 2006-2020, ASSIMP Development Team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
diff --git a/Engine/lib/assimp/code/MD5/MD5Loader.cpp b/Engine/lib/assimp/code/AssetLib/MD5/MD5Loader.cpp
similarity index 60%
rename from Engine/lib/assimp/code/MD5/MD5Loader.cpp
rename to Engine/lib/assimp/code/AssetLib/MD5/MD5Loader.cpp
index a4aed8d70..2d5da4d92 100644
--- a/Engine/lib/assimp/code/MD5/MD5Loader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/MD5/MD5Loader.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -45,21 +43,20 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Implementation of the MD5 importer class
  */
 
-
 #ifndef ASSIMP_BUILD_NO_MD5_IMPORTER
 
 // internal headers
-#include <assimp/RemoveComments.h>
 #include "MD5Loader.h"
+#include <assimp/MathFunctions.h>
+#include <assimp/RemoveComments.h>
+#include <assimp/SkeletonMeshBuilder.h>
 #include <assimp/StringComparison.h>
 #include <assimp/fast_atof.h>
-#include <assimp/MathFunctions.h>
-#include <assimp/SkeletonMeshBuilder.h>
-#include <assimp/Importer.hpp>
-#include <assimp/scene.h>
-#include <assimp/IOSystem.hpp>
-#include <assimp/DefaultLogger.hpp>
 #include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOSystem.hpp>
+#include <assimp/Importer.hpp>
 #include <memory>
 
 using namespace Assimp;
@@ -67,7 +64,6 @@ using namespace Assimp;
 // Minimum weight value. Weights inside [-n ... n] are ignored
 #define AI_MD5_WEIGHT_EPSILON Math::getEpsilon<float>()
 
-
 static const aiImporterDesc desc = {
     "Doom 3 / MD5 Mesh Importer",
     "",
@@ -83,109 +79,91 @@ static const aiImporterDesc desc = {
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-MD5Importer::MD5Importer()
-    : mIOHandler()
-    , mBuffer()
-    , fileSize()
-    , iLineNumber()
-    , pScene()
-    , pIOHandler()
-    , bHadMD5Mesh()
-    , bHadMD5Anim()
-    , bHadMD5Camera()
-    , configNoAutoLoad (false)
-{}
+MD5Importer::MD5Importer() :
+        mIOHandler(nullptr),
+        mBuffer(),
+        mFileSize(),
+        mLineNumber(),
+        mScene(),
+        mHadMD5Mesh(),
+        mHadMD5Anim(),
+        mHadMD5Camera(),
+        mCconfigNoAutoLoad(false) {
+    // empty
+}
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-MD5Importer::~MD5Importer()
-{}
+MD5Importer::~MD5Importer() {
+    // empty
+}
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool MD5Importer::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
-{
-    const std::string extension = GetExtension(pFile);
-
-    if (extension == "md5anim" || extension == "md5mesh" || extension == "md5camera")
-        return true;
-    else if (!extension.length() || checkSig)   {
-        if (!pIOHandler) {
-            return true;
-        }
-        const char* tokens[] = {"MD5Version"};
-        return SearchFileHeaderForToken(pIOHandler,pFile,tokens,1);
-    }
-    return false;
+bool MD5Importer::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
+    static const char *tokens[] = { "MD5Version" };
+    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get list of all supported extensions
-const aiImporterDesc* MD5Importer::GetInfo () const
-{
+const aiImporterDesc *MD5Importer::GetInfo() const {
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup import properties
-void MD5Importer::SetupProperties(const Importer* pImp)
-{
+void MD5Importer::SetupProperties(const Importer *pImp) {
     // AI_CONFIG_IMPORT_MD5_NO_ANIM_AUTOLOAD
-    configNoAutoLoad = (0 !=  pImp->GetPropertyInteger(AI_CONFIG_IMPORT_MD5_NO_ANIM_AUTOLOAD,0));
+    mCconfigNoAutoLoad = (0 != pImp->GetPropertyInteger(AI_CONFIG_IMPORT_MD5_NO_ANIM_AUTOLOAD, 0));
 }
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void MD5Importer::InternReadFile( const std::string& pFile,
-                                 aiScene* _pScene, IOSystem* _pIOHandler)
-{
-    pIOHandler = _pIOHandler;
-    pScene     = _pScene;
-    bHadMD5Mesh = bHadMD5Anim = bHadMD5Camera = false;
+void MD5Importer::InternReadFile(const std::string &pFile, aiScene *_pScene, IOSystem *pIOHandler) {
+    mIOHandler = pIOHandler;
+    mScene = _pScene;
+    mHadMD5Mesh = mHadMD5Anim = mHadMD5Camera = false;
 
     // remove the file extension
     const std::string::size_type pos = pFile.find_last_of('.');
-    mFile = (std::string::npos == pos ? pFile : pFile.substr(0,pos+1));
+    mFile = (std::string::npos == pos ? pFile : pFile.substr(0, pos + 1));
 
     const std::string extension = GetExtension(pFile);
     try {
         if (extension == "md5camera") {
             LoadMD5CameraFile();
-        }
-        else if (configNoAutoLoad || extension == "md5anim") {
+        } else if (mCconfigNoAutoLoad || extension == "md5anim") {
             // determine file extension and process just *one* file
             if (extension.length() == 0) {
                 throw DeadlyImportError("Failure, need file extension to determine MD5 part type");
             }
             if (extension == "md5anim") {
                 LoadMD5AnimFile();
-            }
-            else if (extension == "md5mesh") {
+            } else if (extension == "md5mesh") {
                 LoadMD5MeshFile();
             }
-        }
-        else {
+        } else {
             LoadMD5MeshFile();
             LoadMD5AnimFile();
         }
-    }
-    catch ( ... ) { // std::exception, Assimp::DeadlyImportError
+    } catch (...) { // std::exception, Assimp::DeadlyImportError
         UnloadFileFromMemory();
         throw;
     }
 
     // make sure we have at least one file
-    if (!bHadMD5Mesh && !bHadMD5Anim && !bHadMD5Camera) {
+    if (!mHadMD5Mesh && !mHadMD5Anim && !mHadMD5Camera) {
         throw DeadlyImportError("Failed to read valid contents out of this MD5* file");
     }
 
     // Now rotate the whole scene 90 degrees around the x axis to match our internal coordinate system
-    pScene->mRootNode->mTransformation = aiMatrix4x4(1.f,0.f,0.f,0.f,
-        0.f,0.f,1.f,0.f,0.f,-1.f,0.f,0.f,0.f,0.f,0.f,1.f);
+    mScene->mRootNode->mTransformation = aiMatrix4x4(1.f, 0.f, 0.f, 0.f,
+            0.f, 0.f, 1.f, 0.f, 0.f, -1.f, 0.f, 0.f, 0.f, 0.f, 0.f, 1.f);
 
     // the output scene wouldn't pass the validation without this flag
-    if (!bHadMD5Mesh) {
-        pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
+    if (!mHadMD5Mesh) {
+        mScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
     }
 
     // clean the instance -- the BaseImporter instance may be reused later.
@@ -194,90 +172,87 @@ void MD5Importer::InternReadFile( const std::string& pFile,
 
 // ------------------------------------------------------------------------------------------------
 // Load a file into a memory buffer
-void MD5Importer::LoadFileIntoMemory (IOStream* file)
-{
+void MD5Importer::LoadFileIntoMemory(IOStream *file) {
     // unload the previous buffer, if any
     UnloadFileFromMemory();
 
-    ai_assert(NULL != file);
-    fileSize = (unsigned int)file->FileSize();
-    ai_assert(fileSize);
+    ai_assert(nullptr != file);
+    mFileSize = (unsigned int)file->FileSize();
+    ai_assert(mFileSize);
 
     // allocate storage and copy the contents of the file to a memory buffer
-    mBuffer = new char[fileSize+1];
-    file->Read( (void*)mBuffer, 1, fileSize);
-    iLineNumber = 1;
+    mBuffer = new char[mFileSize + 1];
+    file->Read((void *)mBuffer, 1, mFileSize);
+    mLineNumber = 1;
 
     // append a terminal 0
-    mBuffer[fileSize] = '\0';
+    mBuffer[mFileSize] = '\0';
 
     // now remove all line comments from the file
-    CommentRemover::RemoveLineComments("//",mBuffer,' ');
+    CommentRemover::RemoveLineComments("//", mBuffer, ' ');
 }
 
 // ------------------------------------------------------------------------------------------------
 // Unload the current memory buffer
-void MD5Importer::UnloadFileFromMemory ()
-{
+void MD5Importer::UnloadFileFromMemory() {
     // delete the file buffer
     delete[] mBuffer;
-    mBuffer = NULL;
-    fileSize = 0;
+    mBuffer = nullptr;
+    mFileSize = 0;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Build unique vertices
-void MD5Importer::MakeDataUnique (MD5::MeshDesc& meshSrc)
-{
-    std::vector<bool> abHad(meshSrc.mVertices.size(),false);
+void MD5Importer::MakeDataUnique(MD5::MeshDesc &meshSrc) {
+    std::vector<bool> abHad(meshSrc.mVertices.size(), false);
 
     // allocate enough storage to keep the output structures
-    const unsigned int iNewNum = static_cast<unsigned int>(meshSrc.mFaces.size()*3);
+    const unsigned int iNewNum = static_cast<unsigned int>(meshSrc.mFaces.size() * 3);
     unsigned int iNewIndex = static_cast<unsigned int>(meshSrc.mVertices.size());
     meshSrc.mVertices.resize(iNewNum);
 
     // try to guess how much storage we'll need for new weights
     const float fWeightsPerVert = meshSrc.mWeights.size() / (float)iNewIndex;
-    const unsigned int guess = (unsigned int)(fWeightsPerVert*iNewNum);
+    const unsigned int guess = (unsigned int)(fWeightsPerVert * iNewNum);
     meshSrc.mWeights.reserve(guess + (guess >> 3)); // + 12.5% as buffer
 
-    for (FaceList::const_iterator iter = meshSrc.mFaces.begin(),iterEnd = meshSrc.mFaces.end();iter != iterEnd;++iter){
-        const aiFace& face = *iter;
-        for (unsigned int i = 0; i < 3;++i) {
+    for (FaceList::const_iterator iter = meshSrc.mFaces.begin(), iterEnd = meshSrc.mFaces.end(); iter != iterEnd; ++iter) {
+        const aiFace &face = *iter;
+        for (unsigned int i = 0; i < 3; ++i) {
             if (face.mIndices[0] >= meshSrc.mVertices.size()) {
                 throw DeadlyImportError("MD5MESH: Invalid vertex index");
             }
 
-            if (abHad[face.mIndices[i]])    {
+            if (abHad[face.mIndices[i]]) {
                 // generate a new vertex
                 meshSrc.mVertices[iNewIndex] = meshSrc.mVertices[face.mIndices[i]];
                 face.mIndices[i] = iNewIndex++;
-            }
-            else abHad[face.mIndices[i]] = true;
+            } else
+                abHad[face.mIndices[i]] = true;
         }
         // swap face order
-        std::swap(face.mIndices[0],face.mIndices[2]);
+        std::swap(face.mIndices[0], face.mIndices[2]);
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Recursive node graph construction from a MD5MESH
-void MD5Importer::AttachChilds_Mesh(int iParentID,aiNode* piParent, BoneList& bones)
-{
-    ai_assert(NULL != piParent && !piParent->mNumChildren);
+void MD5Importer::AttachChilds_Mesh(int iParentID, aiNode *piParent, BoneList &bones) {
+    ai_assert(nullptr != piParent);
+    ai_assert(!piParent->mNumChildren);
 
     // First find out how many children we'll have
-    for (int i = 0; i < (int)bones.size();++i)  {
-        if (iParentID != i && bones[i].mParentIndex == iParentID)   {
+    for (int i = 0; i < (int)bones.size(); ++i) {
+        if (iParentID != i && bones[i].mParentIndex == iParentID) {
             ++piParent->mNumChildren;
         }
     }
     if (piParent->mNumChildren) {
-        piParent->mChildren = new aiNode*[piParent->mNumChildren];
-        for (int i = 0; i < (int)bones.size();++i)  {
+        piParent->mChildren = new aiNode *[piParent->mNumChildren];
+        for (int i = 0; i < (int)bones.size(); ++i) {
             // (avoid infinite recursion)
-            if (iParentID != i && bones[i].mParentIndex == iParentID)   {
-                aiNode* pc;
+            if (iParentID != i && bones[i].mParentIndex == iParentID) {
+                aiNode *pc;
                 // setup a new node
                 *piParent->mChildren++ = pc = new aiNode();
                 pc->mName = aiString(bones[i].mName);
@@ -285,9 +260,9 @@ void MD5Importer::AttachChilds_Mesh(int iParentID,aiNode* piParent, BoneList& bo
 
                 // get the transformation matrix from rotation and translational components
                 aiQuaternion quat;
-                MD5::ConvertQuaternion ( bones[i].mRotationQuat, quat );
+                MD5::ConvertQuaternion(bones[i].mRotationQuat, quat);
 
-                bones[i].mTransform = aiMatrix4x4 ( quat.GetMatrix());
+                bones[i].mTransform = aiMatrix4x4(quat.GetMatrix());
                 bones[i].mTransform.a4 = bones[i].mPositionXYZ.x;
                 bones[i].mTransform.b4 = bones[i].mPositionXYZ.y;
                 bones[i].mTransform.c4 = bones[i].mPositionXYZ.z;
@@ -298,12 +273,12 @@ void MD5Importer::AttachChilds_Mesh(int iParentID,aiNode* piParent, BoneList& bo
 
                 // the transformations for each bone are absolute, so we need to multiply them
                 // with the inverse of the absolute matrix of the parent joint
-                if (-1 != iParentID)    {
+                if (-1 != iParentID) {
                     pc->mTransformation = bones[iParentID].mInvTransform * pc->mTransformation;
                 }
 
                 // add children to this node, too
-                AttachChilds_Mesh( i, pc, bones);
+                AttachChilds_Mesh(i, pc, bones);
             }
         }
         // undo offset computations
@@ -313,37 +288,37 @@ void MD5Importer::AttachChilds_Mesh(int iParentID,aiNode* piParent, BoneList& bo
 
 // ------------------------------------------------------------------------------------------------
 // Recursive node graph construction from a MD5ANIM
-void MD5Importer::AttachChilds_Anim(int iParentID,aiNode* piParent, AnimBoneList& bones,const aiNodeAnim** node_anims)
-{
-    ai_assert(NULL != piParent && !piParent->mNumChildren);
+void MD5Importer::AttachChilds_Anim(int iParentID, aiNode *piParent, AnimBoneList &bones, const aiNodeAnim **node_anims) {
+    ai_assert(nullptr != piParent);
+    ai_assert(!piParent->mNumChildren);
 
     // First find out how many children we'll have
-    for (int i = 0; i < (int)bones.size();++i)  {
-        if (iParentID != i && bones[i].mParentIndex == iParentID)   {
+    for (int i = 0; i < (int)bones.size(); ++i) {
+        if (iParentID != i && bones[i].mParentIndex == iParentID) {
             ++piParent->mNumChildren;
         }
     }
     if (piParent->mNumChildren) {
-        piParent->mChildren = new aiNode*[piParent->mNumChildren];
-        for (int i = 0; i < (int)bones.size();++i)  {
+        piParent->mChildren = new aiNode *[piParent->mNumChildren];
+        for (int i = 0; i < (int)bones.size(); ++i) {
             // (avoid infinite recursion)
-            if (iParentID != i && bones[i].mParentIndex == iParentID)
-            {
-                aiNode* pc;
+            if (iParentID != i && bones[i].mParentIndex == iParentID) {
+                aiNode *pc;
                 // setup a new node
                 *piParent->mChildren++ = pc = new aiNode();
                 pc->mName = aiString(bones[i].mName);
                 pc->mParent = piParent;
 
                 // get the corresponding animation channel and its first frame
-                const aiNodeAnim** cur = node_anims;
-                while ((**cur).mNodeName != pc->mName)++cur;
+                const aiNodeAnim **cur = node_anims;
+                while ((**cur).mNodeName != pc->mName)
+                    ++cur;
 
-                aiMatrix4x4::Translation((**cur).mPositionKeys[0].mValue,pc->mTransformation);
-                pc->mTransformation = pc->mTransformation * aiMatrix4x4((**cur).mRotationKeys[0].mValue.GetMatrix()) ;
+                aiMatrix4x4::Translation((**cur).mPositionKeys[0].mValue, pc->mTransformation);
+                pc->mTransformation = pc->mTransformation * aiMatrix4x4((**cur).mRotationKeys[0].mValue.GetMatrix());
 
                 // add children to this node, too
-                AttachChilds_Anim( i, pc, bones,node_anims);
+                AttachChilds_Anim(i, pc, bones, node_anims);
             }
         }
         // undo offset computations
@@ -353,39 +328,38 @@ void MD5Importer::AttachChilds_Anim(int iParentID,aiNode* piParent, AnimBoneList
 
 // ------------------------------------------------------------------------------------------------
 // Load a MD5MESH file
-void MD5Importer::LoadMD5MeshFile ()
-{
-    std::string pFile = mFile + "md5mesh";
-    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));
+void MD5Importer::LoadMD5MeshFile() {
+    std::string filename = mFile + "md5mesh";
+    std::unique_ptr<IOStream> file(mIOHandler->Open(filename, "rb"));
 
     // Check whether we can read from the file
-    if( file.get() == NULL || !file->FileSize())    {
-        ASSIMP_LOG_WARN("Failed to access MD5MESH file: " + pFile);
+    if (file.get() == nullptr || !file->FileSize()) {
+        ASSIMP_LOG_WARN("Failed to access MD5MESH file: ", filename);
         return;
     }
-    bHadMD5Mesh = true;
+    mHadMD5Mesh = true;
     LoadFileIntoMemory(file.get());
 
     // now construct a parser and parse the file
-    MD5::MD5Parser parser(mBuffer,fileSize);
+    MD5::MD5Parser parser(mBuffer, mFileSize);
 
     // load the mesh information from it
     MD5::MD5MeshParser meshParser(parser.mSections);
 
     // create the bone hierarchy - first the root node and dummy nodes for all meshes
-    pScene->mRootNode = new aiNode("<MD5_Root>");
-    pScene->mRootNode->mNumChildren = 2;
-    pScene->mRootNode->mChildren = new aiNode*[2];
+    mScene->mRootNode = new aiNode("<MD5_Root>");
+    mScene->mRootNode->mNumChildren = 2;
+    mScene->mRootNode->mChildren = new aiNode *[2];
 
     // build the hierarchy from the MD5MESH file
-    aiNode* pcNode = pScene->mRootNode->mChildren[1] = new aiNode();
+    aiNode *pcNode = mScene->mRootNode->mChildren[1] = new aiNode();
     pcNode->mName.Set("<MD5_Hierarchy>");
-    pcNode->mParent = pScene->mRootNode;
-    AttachChilds_Mesh(-1,pcNode,meshParser.mJoints);
+    pcNode->mParent = mScene->mRootNode;
+    AttachChilds_Mesh(-1, pcNode, meshParser.mJoints);
 
-    pcNode = pScene->mRootNode->mChildren[0] = new aiNode();
+    pcNode = mScene->mRootNode->mChildren[0] = new aiNode();
     pcNode->mName.Set("<MD5_Mesh>");
-    pcNode->mParent = pScene->mRootNode;
+    pcNode->mParent = mScene->mRootNode;
 
 #if 0
     if (pScene->mRootNode->mChildren[1]->mNumChildren) /* start at the right hierarchy level */
@@ -393,129 +367,134 @@ void MD5Importer::LoadMD5MeshFile ()
 #else
 
     // FIX: MD5 files exported from Blender can have empty meshes
-    for (std::vector<MD5::MeshDesc>::const_iterator it  = meshParser.mMeshes.begin(),end = meshParser.mMeshes.end(); it != end;++it) {
-        if (!(*it).mFaces.empty() && !(*it).mVertices.empty())
-            ++pScene->mNumMaterials;
+    for (std::vector<MD5::MeshDesc>::const_iterator it = meshParser.mMeshes.begin(), end = meshParser.mMeshes.end(); it != end; ++it) {
+        if (!(*it).mFaces.empty() && !(*it).mVertices.empty()) {
+            ++mScene->mNumMaterials;
+        }
     }
 
     // generate all meshes
-    pScene->mNumMeshes = pScene->mNumMaterials;
-    pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];
-    pScene->mMaterials = new aiMaterial*[pScene->mNumMeshes];
+    mScene->mNumMeshes = mScene->mNumMaterials;
+    mScene->mMeshes = new aiMesh *[mScene->mNumMeshes];
+    mScene->mMaterials = new aiMaterial *[mScene->mNumMeshes];
 
     //  storage for node mesh indices
-    pcNode->mNumMeshes = pScene->mNumMeshes;
+    pcNode->mNumMeshes = mScene->mNumMeshes;
     pcNode->mMeshes = new unsigned int[pcNode->mNumMeshes];
-    for (unsigned int m = 0; m < pcNode->mNumMeshes;++m)
+    for (unsigned int m = 0; m < pcNode->mNumMeshes; ++m) {
         pcNode->mMeshes[m] = m;
+    }
 
     unsigned int n = 0;
-    for (std::vector<MD5::MeshDesc>::iterator it  = meshParser.mMeshes.begin(),end = meshParser.mMeshes.end(); it != end;++it) {
-        MD5::MeshDesc& meshSrc = *it;
-        if (meshSrc.mFaces.empty() || meshSrc.mVertices.empty())
+    for (std::vector<MD5::MeshDesc>::iterator it = meshParser.mMeshes.begin(), end = meshParser.mMeshes.end(); it != end; ++it) {
+        MD5::MeshDesc &meshSrc = *it;
+        if (meshSrc.mFaces.empty() || meshSrc.mVertices.empty()) {
             continue;
+        }
 
-        aiMesh* mesh = pScene->mMeshes[n] = new aiMesh();
+        aiMesh *mesh = mScene->mMeshes[n] = new aiMesh();
         mesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
 
         // generate unique vertices in our internal verbose format
         MakeDataUnique(meshSrc);
 
-        std::string name( meshSrc.mShader.C_Str() );
+        std::string name(meshSrc.mShader.C_Str());
         name += ".msh";
         mesh->mName = name;
-        mesh->mNumVertices = (unsigned int) meshSrc.mVertices.size();
+        mesh->mNumVertices = (unsigned int)meshSrc.mVertices.size();
         mesh->mVertices = new aiVector3D[mesh->mNumVertices];
         mesh->mTextureCoords[0] = new aiVector3D[mesh->mNumVertices];
         mesh->mNumUVComponents[0] = 2;
 
         // copy texture coordinates
-        aiVector3D* pv = mesh->mTextureCoords[0];
-        for (MD5::VertexList::const_iterator iter =  meshSrc.mVertices.begin();iter != meshSrc.mVertices.end();++iter,++pv) {
+        aiVector3D *pv = mesh->mTextureCoords[0];
+        for (MD5::VertexList::const_iterator iter = meshSrc.mVertices.begin(); iter != meshSrc.mVertices.end(); ++iter, ++pv) {
             pv->x = (*iter).mUV.x;
-            pv->y = 1.0f-(*iter).mUV.y; // D3D to OpenGL
+            pv->y = 1.0f - (*iter).mUV.y; // D3D to OpenGL
             pv->z = 0.0f;
         }
 
         // sort all bone weights - per bone
-        unsigned int* piCount = new unsigned int[meshParser.mJoints.size()];
-        ::memset(piCount,0,sizeof(unsigned int)*meshParser.mJoints.size());
+        unsigned int *piCount = new unsigned int[meshParser.mJoints.size()];
+        ::memset(piCount, 0, sizeof(unsigned int) * meshParser.mJoints.size());
 
-        for (MD5::VertexList::const_iterator iter =  meshSrc.mVertices.begin();iter != meshSrc.mVertices.end();++iter,++pv) {
-            for (unsigned int jub = (*iter).mFirstWeight, w = jub; w < jub + (*iter).mNumWeights;++w)
-            {
-                MD5::WeightDesc& weightDesc = meshSrc.mWeights[w];
+        for (MD5::VertexList::const_iterator iter = meshSrc.mVertices.begin(); iter != meshSrc.mVertices.end(); ++iter, ++pv) {
+            for (unsigned int jub = (*iter).mFirstWeight, w = jub; w < jub + (*iter).mNumWeights; ++w) {
+                MD5::WeightDesc &weightDesc = meshSrc.mWeights[w];
                 /* FIX for some invalid exporters */
-                if (!(weightDesc.mWeight < AI_MD5_WEIGHT_EPSILON && weightDesc.mWeight >= -AI_MD5_WEIGHT_EPSILON ))
+                if (!(weightDesc.mWeight < AI_MD5_WEIGHT_EPSILON && weightDesc.mWeight >= -AI_MD5_WEIGHT_EPSILON)) {
                     ++piCount[weightDesc.mBone];
+                }
             }
         }
 
         // check how many we will need
-        for (unsigned int p = 0; p < meshParser.mJoints.size();++p)
-            if (piCount[p])mesh->mNumBones++;
+        for (unsigned int p = 0; p < meshParser.mJoints.size(); ++p) {
+            if (piCount[p]) mesh->mNumBones++;
+        }
 
-        if (mesh->mNumBones) // just for safety
-        {
-            mesh->mBones = new aiBone*[mesh->mNumBones];
-            for (unsigned int q = 0,h = 0; q < meshParser.mJoints.size();++q)
-            {
-                if (!piCount[q])continue;
-                aiBone* p = mesh->mBones[h] = new aiBone();
+        // just for safety
+        if (mesh->mNumBones) {
+            mesh->mBones = new aiBone *[mesh->mNumBones];
+            for (unsigned int q = 0, h = 0; q < meshParser.mJoints.size(); ++q) {
+                if (!piCount[q]) continue;
+                aiBone *p = mesh->mBones[h] = new aiBone();
                 p->mNumWeights = piCount[q];
                 p->mWeights = new aiVertexWeight[p->mNumWeights];
                 p->mName = aiString(meshParser.mJoints[q].mName);
                 p->mOffsetMatrix = meshParser.mJoints[q].mInvTransform;
 
                 // store the index for later use
-                MD5::BoneDesc& boneSrc = meshParser.mJoints[q];
+                MD5::BoneDesc &boneSrc = meshParser.mJoints[q];
                 boneSrc.mMap = h++;
 
                 // compute w-component of quaternion
-                MD5::ConvertQuaternion( boneSrc.mRotationQuat, boneSrc.mRotationQuatConverted );
+                MD5::ConvertQuaternion(boneSrc.mRotationQuat, boneSrc.mRotationQuatConverted);
             }
 
             pv = mesh->mVertices;
-            for (MD5::VertexList::const_iterator iter =  meshSrc.mVertices.begin();iter != meshSrc.mVertices.end();++iter,++pv) {
+            for (MD5::VertexList::const_iterator iter = meshSrc.mVertices.begin(); iter != meshSrc.mVertices.end(); ++iter, ++pv) {
                 // compute the final vertex position from all single weights
                 *pv = aiVector3D();
 
                 // there are models which have weights which don't sum to 1 ...
                 ai_real fSum = 0.0;
-                for (unsigned int jub = (*iter).mFirstWeight, w = jub; w < jub + (*iter).mNumWeights;++w)
+                for (unsigned int jub = (*iter).mFirstWeight, w = jub; w < jub + (*iter).mNumWeights; ++w) {
                     fSum += meshSrc.mWeights[w].mWeight;
+                }
                 if (!fSum) {
                     ASSIMP_LOG_ERROR("MD5MESH: The sum of all vertex bone weights is 0");
                     continue;
                 }
 
                 // process bone weights
-                for (unsigned int jub = (*iter).mFirstWeight, w = jub; w < jub + (*iter).mNumWeights;++w)   {
-                    if (w >= meshSrc.mWeights.size())
+                for (unsigned int jub = (*iter).mFirstWeight, w = jub; w < jub + (*iter).mNumWeights; ++w) {
+                    if (w >= meshSrc.mWeights.size()) {
                         throw DeadlyImportError("MD5MESH: Invalid weight index");
+                    }
 
-                    MD5::WeightDesc& weightDesc = meshSrc.mWeights[w];
-                    if ( weightDesc.mWeight < AI_MD5_WEIGHT_EPSILON && weightDesc.mWeight >= -AI_MD5_WEIGHT_EPSILON) {
+                    MD5::WeightDesc &weightDesc = meshSrc.mWeights[w];
+                    if (weightDesc.mWeight < AI_MD5_WEIGHT_EPSILON && weightDesc.mWeight >= -AI_MD5_WEIGHT_EPSILON) {
                         continue;
                     }
 
                     const ai_real fNewWeight = weightDesc.mWeight / fSum;
 
                     // transform the local position into worldspace
-                    MD5::BoneDesc& boneSrc = meshParser.mJoints[weightDesc.mBone];
-                    const aiVector3D v = boneSrc.mRotationQuatConverted.Rotate (weightDesc.vOffsetPosition);
+                    MD5::BoneDesc &boneSrc = meshParser.mJoints[weightDesc.mBone];
+                    const aiVector3D v = boneSrc.mRotationQuatConverted.Rotate(weightDesc.vOffsetPosition);
 
                     // use the original weight to compute the vertex position
                     // (some MD5s seem to depend on the invalid weight values ...)
-                    *pv += ((boneSrc.mPositionXYZ+v)* (ai_real)weightDesc.mWeight);
+                    *pv += ((boneSrc.mPositionXYZ + v) * (ai_real)weightDesc.mWeight);
 
-                    aiBone* bone = mesh->mBones[boneSrc.mMap];
-                    *bone->mWeights++ = aiVertexWeight((unsigned int)(pv-mesh->mVertices),fNewWeight);
+                    aiBone *bone = mesh->mBones[boneSrc.mMap];
+                    *bone->mWeights++ = aiVertexWeight((unsigned int)(pv - mesh->mVertices), fNewWeight);
                 }
             }
 
             // undo our nice offset tricks ...
-            for (unsigned int p = 0; p < mesh->mNumBones;++p) {
+            for (unsigned int p = 0; p < mesh->mNumBones; ++p) {
                 mesh->mBones[p]->mWeights -= mesh->mBones[p]->mNumWeights;
             }
         }
@@ -526,43 +505,42 @@ void MD5Importer::LoadMD5MeshFile ()
         // (however, take care that the aiFace destructor doesn't delete the mIndices array)
         mesh->mNumFaces = (unsigned int)meshSrc.mFaces.size();
         mesh->mFaces = new aiFace[mesh->mNumFaces];
-        for (unsigned int c = 0; c < mesh->mNumFaces;++c)   {
+        for (unsigned int c = 0; c < mesh->mNumFaces; ++c) {
             mesh->mFaces[c].mNumIndices = 3;
             mesh->mFaces[c].mIndices = meshSrc.mFaces[c].mIndices;
-            meshSrc.mFaces[c].mIndices = NULL;
+            meshSrc.mFaces[c].mIndices = nullptr;
         }
 
         // generate a material for the mesh
-        aiMaterial* mat = new aiMaterial();
-        pScene->mMaterials[n] = mat;
+        aiMaterial *mat = new aiMaterial();
+        mScene->mMaterials[n] = mat;
 
         // insert the typical doom3 textures:
         // nnn_local.tga  - normal map
         // nnn_h.tga      - height map
         // nnn_s.tga      - specular map
         // nnn_d.tga      - diffuse map
-        if (meshSrc.mShader.length && !strchr(meshSrc.mShader.data,'.')) {
+        if (meshSrc.mShader.length && !strchr(meshSrc.mShader.data, '.')) {
 
             aiString temp(meshSrc.mShader);
             temp.Append("_local.tga");
-            mat->AddProperty(&temp,AI_MATKEY_TEXTURE_NORMALS(0));
+            mat->AddProperty(&temp, AI_MATKEY_TEXTURE_NORMALS(0));
 
-            temp =  aiString(meshSrc.mShader);
+            temp = aiString(meshSrc.mShader);
             temp.Append("_s.tga");
-            mat->AddProperty(&temp,AI_MATKEY_TEXTURE_SPECULAR(0));
+            mat->AddProperty(&temp, AI_MATKEY_TEXTURE_SPECULAR(0));
 
-            temp =  aiString(meshSrc.mShader);
+            temp = aiString(meshSrc.mShader);
             temp.Append("_d.tga");
-            mat->AddProperty(&temp,AI_MATKEY_TEXTURE_DIFFUSE(0));
+            mat->AddProperty(&temp, AI_MATKEY_TEXTURE_DIFFUSE(0));
 
-            temp =  aiString(meshSrc.mShader);
+            temp = aiString(meshSrc.mShader);
             temp.Append("_h.tga");
-            mat->AddProperty(&temp,AI_MATKEY_TEXTURE_HEIGHT(0));
+            mat->AddProperty(&temp, AI_MATKEY_TEXTURE_HEIGHT(0));
 
             // set this also as material name
-            mat->AddProperty(&meshSrc.mShader,AI_MATKEY_NAME);
-        }
-        else {
+            mat->AddProperty(&meshSrc.mShader, AI_MATKEY_NAME);
+        } else {
             mat->AddProperty(&meshSrc.mShader, AI_MATKEY_TEXTURE_DIFFUSE(0));
         }
         mesh->mMaterialIndex = n++;
@@ -572,39 +550,38 @@ void MD5Importer::LoadMD5MeshFile ()
 
 // ------------------------------------------------------------------------------------------------
 // Load an MD5ANIM file
-void MD5Importer::LoadMD5AnimFile ()
-{
+void MD5Importer::LoadMD5AnimFile() {
     std::string pFile = mFile + "md5anim";
-    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));
+    std::unique_ptr<IOStream> file(mIOHandler->Open(pFile, "rb"));
 
     // Check whether we can read from the file
-    if( !file.get() || !file->FileSize())   {
-        ASSIMP_LOG_WARN("Failed to read MD5ANIM file: " + pFile);
+    if (!file.get() || !file->FileSize()) {
+        ASSIMP_LOG_WARN("Failed to read MD5ANIM file: ", pFile);
         return;
     }
+
     LoadFileIntoMemory(file.get());
 
     // parse the basic file structure
-    MD5::MD5Parser parser(mBuffer,fileSize);
+    MD5::MD5Parser parser(mBuffer, mFileSize);
 
     // load the animation information from the parse tree
     MD5::MD5AnimParser animParser(parser.mSections);
 
     // generate and fill the output animation
     if (animParser.mAnimatedBones.empty() || animParser.mFrames.empty() ||
-        animParser.mBaseFrames.size() != animParser.mAnimatedBones.size())  {
+            animParser.mBaseFrames.size() != animParser.mAnimatedBones.size()) {
         ASSIMP_LOG_ERROR("MD5ANIM: No frames or animated bones loaded");
-    }
-    else {
-        bHadMD5Anim = true;
+    } else {
+        mHadMD5Anim = true;
 
-        pScene->mAnimations = new aiAnimation*[pScene->mNumAnimations = 1];
-        aiAnimation* anim = pScene->mAnimations[0] = new aiAnimation();
+        mScene->mAnimations = new aiAnimation *[mScene->mNumAnimations = 1];
+        aiAnimation *anim = mScene->mAnimations[0] = new aiAnimation();
         anim->mNumChannels = (unsigned int)animParser.mAnimatedBones.size();
-        anim->mChannels = new aiNodeAnim*[anim->mNumChannels];
-        for (unsigned int i = 0; i < anim->mNumChannels;++i)    {
-            aiNodeAnim* node = anim->mChannels[i] = new aiNodeAnim();
-            node->mNodeName = aiString( animParser.mAnimatedBones[i].mName );
+        anim->mChannels = new aiNodeAnim *[anim->mNumChannels];
+        for (unsigned int i = 0; i < anim->mNumChannels; ++i) {
+            aiNodeAnim *node = anim->mChannels[i] = new aiNodeAnim();
+            node->mNodeName = aiString(animParser.mAnimatedBones[i].mName);
 
             // allocate storage for the keyframes
             node->mPositionKeys = new aiVectorKey[animParser.mFrames.size()];
@@ -614,46 +591,44 @@ void MD5Importer::LoadMD5AnimFile ()
         // 1 tick == 1 frame
         anim->mTicksPerSecond = animParser.fFrameRate;
 
-        for (FrameList::const_iterator iter = animParser.mFrames.begin(), iterEnd = animParser.mFrames.end();iter != iterEnd;++iter){
+        for (FrameList::const_iterator iter = animParser.mFrames.begin(), iterEnd = animParser.mFrames.end(); iter != iterEnd; ++iter) {
             double dTime = (double)(*iter).iIndex;
-            aiNodeAnim** pcAnimNode = anim->mChannels;
+            aiNodeAnim **pcAnimNode = anim->mChannels;
             if (!(*iter).mValues.empty() || iter == animParser.mFrames.begin()) /* be sure we have at least one frame */
             {
                 // now process all values in there ... read all joints
-                MD5::BaseFrameDesc* pcBaseFrame = &animParser.mBaseFrames[0];
-                for (AnimBoneList::const_iterator iter2 = animParser.mAnimatedBones.begin(); iter2 != animParser.mAnimatedBones.end();++iter2,
-                    ++pcAnimNode,++pcBaseFrame)
-                {
-                    if((*iter2).iFirstKeyIndex >= (*iter).mValues.size()) {
+                MD5::BaseFrameDesc *pcBaseFrame = &animParser.mBaseFrames[0];
+                for (AnimBoneList::const_iterator iter2 = animParser.mAnimatedBones.begin(); iter2 != animParser.mAnimatedBones.end(); ++iter2,
+                                                  ++pcAnimNode, ++pcBaseFrame) {
+                    if ((*iter2).iFirstKeyIndex >= (*iter).mValues.size()) {
 
                         // Allow for empty frames
                         if ((*iter2).iFlags != 0) {
                             throw DeadlyImportError("MD5: Keyframe index is out of range");
-
                         }
                         continue;
                     }
-                    const float* fpCur = &(*iter).mValues[(*iter2).iFirstKeyIndex];
-                    aiNodeAnim* pcCurAnimBone = *pcAnimNode;
+                    const float *fpCur = &(*iter).mValues[(*iter2).iFirstKeyIndex];
+                    aiNodeAnim *pcCurAnimBone = *pcAnimNode;
 
-                    aiVectorKey* vKey = &pcCurAnimBone->mPositionKeys[pcCurAnimBone->mNumPositionKeys++];
-                    aiQuatKey* qKey = &pcCurAnimBone->mRotationKeys  [pcCurAnimBone->mNumRotationKeys++];
+                    aiVectorKey *vKey = &pcCurAnimBone->mPositionKeys[pcCurAnimBone->mNumPositionKeys++];
+                    aiQuatKey *qKey = &pcCurAnimBone->mRotationKeys[pcCurAnimBone->mNumRotationKeys++];
                     aiVector3D vTemp;
 
                     // translational component
                     for (unsigned int i = 0; i < 3; ++i) {
                         if ((*iter2).iFlags & (1u << i)) {
-                            vKey->mValue[i] =  *fpCur++;
-                        }
-                        else vKey->mValue[i] = pcBaseFrame->vPositionXYZ[i];
+                            vKey->mValue[i] = *fpCur++;
+                        } else
+                            vKey->mValue[i] = pcBaseFrame->vPositionXYZ[i];
                     }
 
                     // orientation component
                     for (unsigned int i = 0; i < 3; ++i) {
                         if ((*iter2).iFlags & (8u << i)) {
-                            vTemp[i] =  *fpCur++;
-                        }
-                        else vTemp[i] = pcBaseFrame->vRotationQuat[i];
+                            vTemp[i] = *fpCur++;
+                        } else
+                            vTemp[i] = pcBaseFrame->vRotationQuat[i];
                     }
 
                     MD5::ConvertQuaternion(vTemp, qKey->mValue);
@@ -662,20 +637,20 @@ void MD5Importer::LoadMD5AnimFile ()
             }
 
             // compute the duration of the animation
-            anim->mDuration = std::max(dTime,anim->mDuration);
+            anim->mDuration = std::max(dTime, anim->mDuration);
         }
 
         // If we didn't build the hierarchy yet (== we didn't load a MD5MESH),
         // construct it now from the data given in the MD5ANIM.
-        if (!pScene->mRootNode) {
-            pScene->mRootNode = new aiNode();
-            pScene->mRootNode->mName.Set("<MD5_Hierarchy>");
+        if (!mScene->mRootNode) {
+            mScene->mRootNode = new aiNode();
+            mScene->mRootNode->mName.Set("<MD5_Hierarchy>");
 
-            AttachChilds_Anim(-1,pScene->mRootNode,animParser.mAnimatedBones,(const aiNodeAnim**)anim->mChannels);
+            AttachChilds_Anim(-1, mScene->mRootNode, animParser.mAnimatedBones, (const aiNodeAnim **)anim->mChannels);
 
             // Call SkeletonMeshBuilder to construct a mesh to represent the shape
-            if (pScene->mRootNode->mNumChildren) {
-                SkeletonMeshBuilder skeleton_maker(pScene,pScene->mRootNode->mChildren[0]);
+            if (mScene->mRootNode->mNumChildren) {
+                SkeletonMeshBuilder skeleton_maker(mScene, mScene->mRootNode->mChildren[0]);
             }
         }
     }
@@ -683,20 +658,19 @@ void MD5Importer::LoadMD5AnimFile ()
 
 // ------------------------------------------------------------------------------------------------
 // Load an MD5CAMERA file
-void MD5Importer::LoadMD5CameraFile ()
-{
+void MD5Importer::LoadMD5CameraFile() {
     std::string pFile = mFile + "md5camera";
-    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));
+    std::unique_ptr<IOStream> file(mIOHandler->Open(pFile, "rb"));
 
     // Check whether we can read from the file
-    if( !file.get() || !file->FileSize())   {
-        throw DeadlyImportError("Failed to read MD5CAMERA file: " + pFile);
+    if (!file.get() || !file->FileSize()) {
+        throw DeadlyImportError("Failed to read MD5CAMERA file: ", pFile);
     }
-    bHadMD5Camera = true;
+    mHadMD5Camera = true;
     LoadFileIntoMemory(file.get());
 
     // parse the basic file structure
-    MD5::MD5Parser parser(mBuffer,fileSize);
+    MD5::MD5Parser parser(mBuffer, mFileSize);
 
     // load the camera animation data from the parse tree
     MD5::MD5CameraParser cameraParser(parser.mSections);
@@ -705,56 +679,55 @@ void MD5Importer::LoadMD5CameraFile ()
         throw DeadlyImportError("MD5CAMERA: No frames parsed");
     }
 
-    std::vector<unsigned int>& cuts = cameraParser.cuts;
-    std::vector<MD5::CameraAnimFrameDesc>& frames = cameraParser.frames;
+    std::vector<unsigned int> &cuts = cameraParser.cuts;
+    std::vector<MD5::CameraAnimFrameDesc> &frames = cameraParser.frames;
 
     // Construct output graph - a simple root with a dummy child.
     // The root node performs the coordinate system conversion
-    aiNode* root = pScene->mRootNode = new aiNode("<MD5CameraRoot>");
-    root->mChildren = new aiNode*[root->mNumChildren = 1];
+    aiNode *root = mScene->mRootNode = new aiNode("<MD5CameraRoot>");
+    root->mChildren = new aiNode *[root->mNumChildren = 1];
     root->mChildren[0] = new aiNode("<MD5Camera>");
     root->mChildren[0]->mParent = root;
 
     // ... but with one camera assigned to it
-    pScene->mCameras = new aiCamera*[pScene->mNumCameras = 1];
-    aiCamera* cam = pScene->mCameras[0] = new aiCamera();
+    mScene->mCameras = new aiCamera *[mScene->mNumCameras = 1];
+    aiCamera *cam = mScene->mCameras[0] = new aiCamera();
     cam->mName = "<MD5Camera>";
 
     // FIXME: Fov is currently set to the first frame's value
-    cam->mHorizontalFOV = AI_DEG_TO_RAD( frames.front().fFOV );
+    cam->mHorizontalFOV = AI_DEG_TO_RAD(frames.front().fFOV);
 
     // every cut is written to a separate aiAnimation
     if (!cuts.size()) {
         cuts.push_back(0);
-        cuts.push_back(static_cast<unsigned int>(frames.size()-1));
-    }
-    else {
-        cuts.insert(cuts.begin(),0);
+        cuts.push_back(static_cast<unsigned int>(frames.size() - 1));
+    } else {
+        cuts.insert(cuts.begin(), 0);
 
-        if (cuts.back() < frames.size()-1)
-            cuts.push_back(static_cast<unsigned int>(frames.size()-1));
+        if (cuts.back() < frames.size() - 1)
+            cuts.push_back(static_cast<unsigned int>(frames.size() - 1));
     }
 
-    pScene->mNumAnimations = static_cast<unsigned int>(cuts.size()-1);
-    aiAnimation** tmp = pScene->mAnimations = new aiAnimation*[pScene->mNumAnimations];
-    for (std::vector<unsigned int>::const_iterator it = cuts.begin(); it != cuts.end()-1; ++it) {
+    mScene->mNumAnimations = static_cast<unsigned int>(cuts.size() - 1);
+    aiAnimation **tmp = mScene->mAnimations = new aiAnimation *[mScene->mNumAnimations];
+    for (std::vector<unsigned int>::const_iterator it = cuts.begin(); it != cuts.end() - 1; ++it) {
 
-        aiAnimation* anim = *tmp++ = new aiAnimation();
-        anim->mName.length = ::ai_snprintf(anim->mName.data, MAXLEN, "anim%u_from_%u_to_%u",(unsigned int)(it-cuts.begin()),(*it),*(it+1));
+        aiAnimation *anim = *tmp++ = new aiAnimation();
+        anim->mName.length = ::ai_snprintf(anim->mName.data, MAXLEN, "anim%u_from_%u_to_%u", (unsigned int)(it - cuts.begin()), (*it), *(it + 1));
 
         anim->mTicksPerSecond = cameraParser.fFrameRate;
-        anim->mChannels = new aiNodeAnim*[anim->mNumChannels = 1];
-        aiNodeAnim* nd  = anim->mChannels[0] = new aiNodeAnim();
+        anim->mChannels = new aiNodeAnim *[anim->mNumChannels = 1];
+        aiNodeAnim *nd = anim->mChannels[0] = new aiNodeAnim();
         nd->mNodeName.Set("<MD5Camera>");
 
-        nd->mNumPositionKeys = nd->mNumRotationKeys = *(it+1) - (*it);
+        nd->mNumPositionKeys = nd->mNumRotationKeys = *(it + 1) - (*it);
         nd->mPositionKeys = new aiVectorKey[nd->mNumPositionKeys];
-        nd->mRotationKeys = new aiQuatKey  [nd->mNumRotationKeys];
+        nd->mRotationKeys = new aiQuatKey[nd->mNumRotationKeys];
         for (unsigned int i = 0; i < nd->mNumPositionKeys; ++i) {
 
-            nd->mPositionKeys[i].mValue = frames[*it+i].vPositionXYZ;
-            MD5::ConvertQuaternion(frames[*it+i].vRotationQuat,nd->mRotationKeys[i].mValue);
-            nd->mRotationKeys[i].mTime = nd->mPositionKeys[i].mTime = *it+i;
+            nd->mPositionKeys[i].mValue = frames[*it + i].vPositionXYZ;
+            MD5::ConvertQuaternion(frames[*it + i].vRotationQuat, nd->mRotationKeys[i].mValue);
+            nd->mRotationKeys[i].mTime = nd->mPositionKeys[i].mTime = *it + i;
         }
     }
 }
diff --git a/Engine/lib/assimp/code/MD5/MD5Loader.h b/Engine/lib/assimp/code/AssetLib/MD5/MD5Loader.h
similarity index 81%
rename from Engine/lib/assimp/code/MD5/MD5Loader.h
rename to Engine/lib/assimp/code/AssetLib/MD5/MD5Loader.h
index e15cc3fb9..63fb1c36b 100644
--- a/Engine/lib/assimp/code/MD5/MD5Loader.h
+++ b/Engine/lib/assimp/code/AssetLib/MD5/MD5Loader.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -40,23 +39,22 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
-
 /** @file   MD5Loader.h
  *  @brief Definition of the .MD5 importer class.
  *  http://www.modwiki.net/wiki/MD5_(file_format)
 */
+#pragma once
 #ifndef AI_MD5LOADER_H_INCLUDED
 #define AI_MD5LOADER_H_INCLUDED
 
-#include <assimp/BaseImporter.h>
 #include "MD5Parser.h"
-
+#include <assimp/BaseImporter.h>
 #include <assimp/types.h>
 
 struct aiNode;
 struct aiNodeAnim;
 
-namespace Assimp    {
+namespace Assimp {
 
 class IOStream;
 using namespace Assimp::MD5;
@@ -64,61 +62,53 @@ using namespace Assimp::MD5;
 // ---------------------------------------------------------------------------
 /** Importer class for the MD5 file format
 */
-class MD5Importer : public BaseImporter
-{
+class MD5Importer : public BaseImporter {
 public:
     MD5Importer();
-    ~MD5Importer();
-
-
-public:
+    ~MD5Importer() override;
 
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
      * See BaseImporter::CanRead() for details.
      */
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
+            bool checkSig) const override;
 
 protected:
-
     // -------------------------------------------------------------------
     /** Return importer meta information.
      * See #BaseImporter::GetInfo for the details
      */
-    const aiImporterDesc* GetInfo () const;
+    const aiImporterDesc *GetInfo() const override;
 
     // -------------------------------------------------------------------
     /** Called prior to ReadFile().
      * The function is a request to the importer to update its configuration
      * basing on the Importer's configuration property list.
      */
-    void SetupProperties(const Importer* pImp);
+    void SetupProperties(const Importer *pImp) override;
 
     // -------------------------------------------------------------------
     /** Imports the given file into the given scene structure.
      * See BaseImporter::InternReadFile() for details
      */
-    void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
-
-protected:
-
+    void InternReadFile(const std::string &pFile, aiScene *pScene,
+            IOSystem *pIOHandler) override;
 
     // -------------------------------------------------------------------
     /** Load a *.MD5MESH file.
      */
-    void LoadMD5MeshFile ();
+    void LoadMD5MeshFile();
 
     // -------------------------------------------------------------------
     /** Load a *.MD5ANIM file.
      */
-    void LoadMD5AnimFile ();
+    void LoadMD5AnimFile();
 
     // -------------------------------------------------------------------
     /** Load a *.MD5CAMERA file.
      */
-    void LoadMD5CameraFile ();
+    void LoadMD5CameraFile();
 
     // -------------------------------------------------------------------
     /** Construct node hierarchy from a given MD5ANIM
@@ -127,8 +117,8 @@ protected:
      *  @param bones Input bones
      *  @param node_anims Generated node animations
     */
-    void AttachChilds_Anim(int iParentID,aiNode* piParent,
-        AnimBoneList& bones,const aiNodeAnim** node_anims);
+    void AttachChilds_Anim(int iParentID, aiNode *piParent,
+            AnimBoneList &bones, const aiNodeAnim **node_anims);
 
     // -------------------------------------------------------------------
     /** Construct node hierarchy from a given MD5MESH
@@ -136,13 +126,13 @@ protected:
      *  @param piParent Parent node to attach to
      *  @param bones Input bones
     */
-    void AttachChilds_Mesh(int iParentID,aiNode* piParent,BoneList& bones);
+    void AttachChilds_Mesh(int iParentID, aiNode *piParent, BoneList &bones);
 
     // -------------------------------------------------------------------
     /** Build unique vertex buffers from a given MD5ANIM
      *  @param meshSrc Input data
      */
-    void MakeDataUnique (MD5::MeshDesc& meshSrc);
+    void MakeDataUnique(MD5::MeshDesc &meshSrc);
 
     // -------------------------------------------------------------------
     /** Load the contents of a specific file into memory and
@@ -151,43 +141,39 @@ protected:
      *  mBuffer is modified to point to this buffer.
      *  @param pFile File stream to be read
     */
-    void LoadFileIntoMemory (IOStream* pFile);
-    void UnloadFileFromMemory ();
-
+    void LoadFileIntoMemory(IOStream *pFile);
+    void UnloadFileFromMemory();
 
     /** IOSystem to be used to access files */
-    IOSystem* mIOHandler;
+    IOSystem *mIOHandler;
 
     /** Path to the file, excluding the file extension but
         with the dot */
     std::string mFile;
 
     /** Buffer to hold the loaded file */
-    char* mBuffer;
+    char *mBuffer;
 
     /** Size of the file */
-    unsigned int fileSize;
+    unsigned int mFileSize;
 
     /** Current line number. For debugging purposes */
-    unsigned int iLineNumber;
+    unsigned int mLineNumber;
 
     /** Scene to be filled */
-    aiScene* pScene;
-
-    /** (Custom) I/O handler implementation */
-    IOSystem* pIOHandler;
+    aiScene *mScene;
 
     /** true if a MD5MESH file has already been parsed */
-    bool bHadMD5Mesh;
+    bool mHadMD5Mesh;
 
     /** true if a MD5ANIM file has already been parsed */
-    bool bHadMD5Anim;
+    bool mHadMD5Anim;
 
     /** true if a MD5CAMERA file has already been parsed */
-    bool bHadMD5Camera;
+    bool mHadMD5Camera;
 
     /** configuration option: prevent anim autoload */
-    bool configNoAutoLoad;
+    bool mCconfigNoAutoLoad;
 };
 
 } // end of namespace Assimp
diff --git a/Engine/lib/assimp/code/MD5/MD5Parser.cpp b/Engine/lib/assimp/code/AssetLib/MD5/MD5Parser.cpp
similarity index 53%
rename from Engine/lib/assimp/code/MD5/MD5Parser.cpp
rename to Engine/lib/assimp/code/AssetLib/MD5/MD5Parser.cpp
index 37490212f..7ed23cb82 100644
--- a/Engine/lib/assimp/code/MD5/MD5Parser.cpp
+++ b/Engine/lib/assimp/code/AssetLib/MD5/MD5Parser.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -45,25 +45,24 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Implementation of the MD5 parser class
  */
 
-
 // internal headers
-#include "MD5/MD5Loader.h"
+#include "AssetLib/MD5/MD5Loader.h"
 #include "Material/MaterialSystem.h"
 
-#include <assimp/fast_atof.h>
 #include <assimp/ParsingUtils.h>
 #include <assimp/StringComparison.h>
-#include <assimp/DefaultLogger.hpp>
+#include <assimp/fast_atof.h>
 #include <assimp/mesh.h>
+#include <assimp/DefaultLogger.hpp>
 
 using namespace Assimp;
 using namespace Assimp::MD5;
 
 // ------------------------------------------------------------------------------------------------
-// Parse the segment structure fo a MD5 file
-MD5Parser::MD5Parser(char* _buffer, unsigned int _fileSize )
-{
-    ai_assert(NULL != _buffer && 0 != _fileSize);
+// Parse the segment structure for an MD5 file
+MD5Parser::MD5Parser(char *_buffer, unsigned int _fileSize) {
+    ai_assert(nullptr != _buffer);
+    ai_assert(0 != _fileSize);
 
     buffer = _buffer;
     fileSize = _fileSize;
@@ -78,48 +77,45 @@ MD5Parser::MD5Parser(char* _buffer, unsigned int _fileSize )
     bool running = true;
     while (running) {
         mSections.push_back(Section());
-        Section& sec = mSections.back();
-        if(!ParseSection(sec))  {
+        Section &sec = mSections.back();
+        if (!ParseSection(sec)) {
             break;
         }
     }
 
-    if ( !DefaultLogger::isNullLogger())    {
+    if (!DefaultLogger::isNullLogger()) {
         char szBuffer[128]; // should be sufficiently large
-        ::ai_snprintf(szBuffer,128,"MD5Parser end. Parsed %i sections",(int)mSections.size());
+        ::ai_snprintf(szBuffer, 128, "MD5Parser end. Parsed %i sections", (int)mSections.size());
         ASSIMP_LOG_DEBUG(szBuffer);
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Report error to the log stream
-/*static*/ AI_WONT_RETURN void MD5Parser::ReportError (const char* error, unsigned int line)
-{
+/*static*/ AI_WONT_RETURN void MD5Parser::ReportError(const char *error, unsigned int line) {
     char szBuffer[1024];
-    ::ai_snprintf(szBuffer, 1024, "[MD5] Line %u: %s",line,error);
+    ::ai_snprintf(szBuffer, 1024, "[MD5] Line %u: %s", line, error);
     throw DeadlyImportError(szBuffer);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Report warning to the log stream
-/*static*/ void MD5Parser::ReportWarning (const char* warn, unsigned int line)
-{
+/*static*/ void MD5Parser::ReportWarning(const char *warn, unsigned int line) {
     char szBuffer[1024];
-    ::sprintf(szBuffer,"[MD5] Line %u: %s",line,warn);
+    ::sprintf(szBuffer, "[MD5] Line %u: %s", line, warn);
     ASSIMP_LOG_WARN(szBuffer);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Parse and validate the MD5 header
-void MD5Parser::ParseHeader()
-{
+void MD5Parser::ParseHeader() {
     // parse and validate the file version
     SkipSpaces();
-    if (!TokenMatch(buffer,"MD5Version",10))    {
+    if (!TokenMatch(buffer, "MD5Version", 10)) {
         ReportError("Invalid MD5 file: MD5Version tag has not been found");
     }
     SkipSpaces();
-    unsigned int iVer = ::strtoul10(buffer,(const char**)&buffer);
+    unsigned int iVer = ::strtoul10(buffer, (const char **)&buffer);
     if (10 != iVer) {
         ReportError("MD5 version tag is unknown (10 is expected)");
     }
@@ -127,23 +123,24 @@ void MD5Parser::ParseHeader()
 
     // print the command line options to the console
     // FIX: can break the log length limit, so we need to be careful
-    char* sz = buffer;
-    while (!IsLineEnd( *buffer++));
-    ASSIMP_LOG_INFO(std::string(sz,std::min((uintptr_t)MAX_LOG_MESSAGE_LENGTH, (uintptr_t)(buffer-sz))));
+    char *sz = buffer;
+    while (!IsLineEnd(*buffer++))
+        ;
+    ASSIMP_LOG_INFO(std::string(sz, std::min((uintptr_t)MAX_LOG_MESSAGE_LENGTH, (uintptr_t)(buffer - sz))));
     SkipSpacesAndLineEnd();
 }
 
 // ------------------------------------------------------------------------------------------------
 // Recursive MD5 parsing function
-bool MD5Parser::ParseSection(Section& out)
-{
+bool MD5Parser::ParseSection(Section &out) {
     // store the current line number for use in error messages
     out.iLineNumber = lineNumber;
 
     // first parse the name of the section
-    char* sz = buffer;
-    while (!IsSpaceOrNewLine( *buffer))buffer++;
-    out.mName = std::string(sz,(uintptr_t)(buffer-sz));
+    char *sz = buffer;
+    while (!IsSpaceOrNewLine(*buffer))
+        buffer++;
+    out.mName = std::string(sz, (uintptr_t)(buffer - sz));
     SkipSpaces();
 
     bool running = true;
@@ -152,8 +149,7 @@ bool MD5Parser::ParseSection(Section& out)
             // it is a normal section so read all lines
             buffer++;
             bool run = true;
-            while (run)
-            {
+            while (run) {
                 if (!SkipSpacesAndLineEnd()) {
                     return false; // seems this was the last section
                 }
@@ -163,25 +159,26 @@ bool MD5Parser::ParseSection(Section& out)
                 }
 
                 out.mElements.push_back(Element());
-                Element& elem = out.mElements.back();
+                Element &elem = out.mElements.back();
 
                 elem.iLineNumber = lineNumber;
                 elem.szStart = buffer;
 
                 // terminate the line with zero
-                while (!IsLineEnd( *buffer))buffer++;
+                while (!IsLineEnd(*buffer))
+                    buffer++;
                 if (*buffer) {
                     ++lineNumber;
                     *buffer++ = '\0';
                 }
             }
             break;
-        }
-        else if (!IsSpaceOrNewLine(*buffer))    {
+        } else if (!IsSpaceOrNewLine(*buffer)) {
             // it is an element at global scope. Parse its value and go on
             sz = buffer;
-            while (!IsSpaceOrNewLine( *buffer++));
-            out.mGlobalValue = std::string(sz,(uintptr_t)(buffer-sz));
+            while (!IsSpaceOrNewLine(*buffer++))
+                ;
+            out.mGlobalValue = std::string(sz, (uintptr_t)(buffer - sz));
             continue;
         }
         break;
@@ -193,161 +190,161 @@ bool MD5Parser::ParseSection(Section& out)
 // Some dirty macros just because they're so funny and easy to debug
 
 // skip all spaces ... handle EOL correctly
-#define AI_MD5_SKIP_SPACES()  if(!SkipSpaces(&sz)) \
-    MD5Parser::ReportWarning("Unexpected end of line",elem.iLineNumber);
+#define AI_MD5_SKIP_SPACES() \
+    if (!SkipSpaces(&sz))    \
+        MD5Parser::ReportWarning("Unexpected end of line", elem.iLineNumber);
 
-	// read a triple float in brackets: (1.0 1.0 1.0)
-#define AI_MD5_READ_TRIPLE(vec) \
-    AI_MD5_SKIP_SPACES(); \
-    if ('(' != *sz++) \
-        MD5Parser::ReportWarning("Unexpected token: ( was expected",elem.iLineNumber); \
-    AI_MD5_SKIP_SPACES(); \
-    sz = fast_atoreal_move<float>(sz,(float&)vec.x); \
-    AI_MD5_SKIP_SPACES(); \
-    sz = fast_atoreal_move<float>(sz,(float&)vec.y); \
-    AI_MD5_SKIP_SPACES(); \
-    sz = fast_atoreal_move<float>(sz,(float&)vec.z); \
-    AI_MD5_SKIP_SPACES(); \
-    if (')' != *sz++) \
-        MD5Parser::ReportWarning("Unexpected token: ) was expected",elem.iLineNumber);
+// read a triple float in brackets: (1.0 1.0 1.0)
+#define AI_MD5_READ_TRIPLE(vec)                                                         \
+    AI_MD5_SKIP_SPACES();                                                               \
+    if ('(' != *sz++)                                                                   \
+        MD5Parser::ReportWarning("Unexpected token: ( was expected", elem.iLineNumber); \
+    AI_MD5_SKIP_SPACES();                                                               \
+    sz = fast_atoreal_move<float>(sz, (float &)vec.x);                                  \
+    AI_MD5_SKIP_SPACES();                                                               \
+    sz = fast_atoreal_move<float>(sz, (float &)vec.y);                                  \
+    AI_MD5_SKIP_SPACES();                                                               \
+    sz = fast_atoreal_move<float>(sz, (float &)vec.z);                                  \
+    AI_MD5_SKIP_SPACES();                                                               \
+    if (')' != *sz++)                                                                   \
+        MD5Parser::ReportWarning("Unexpected token: ) was expected", elem.iLineNumber);
 
-	// parse a string, enclosed in quotation marks or not
-#define AI_MD5_PARSE_STRING(out) \
-    bool bQuota = (*sz == '\"'); \
-    const char* szStart = sz; \
-    while (!IsSpaceOrNewLine(*sz))++sz; \
-    const char* szEnd = sz; \
-    if (bQuota) { \
-        szStart++; \
-        if ('\"' != *(szEnd-=1)) { \
+// parse a string, enclosed in quotation marks or not
+#define AI_MD5_PARSE_STRING(out)                                                   \
+    bool bQuota = (*sz == '\"');                                                   \
+    const char *szStart = sz;                                                      \
+    while (!IsSpaceOrNewLine(*sz))                                                 \
+        ++sz;                                                                      \
+    const char *szEnd = sz;                                                        \
+    if (bQuota) {                                                                  \
+        szStart++;                                                                 \
+        if ('\"' != *(szEnd -= 1)) {                                               \
             MD5Parser::ReportWarning("Expected closing quotation marks in string", \
-                elem.iLineNumber); \
-            continue; \
-        } \
-    } \
-    out.length = (size_t)(szEnd - szStart); \
-    ::memcpy(out.data,szStart,out.length); \
+                    elem.iLineNumber);                                             \
+            continue;                                                              \
+        }                                                                          \
+    }                                                                              \
+    out.length = (size_t)(szEnd - szStart);                                        \
+    ::memcpy(out.data, szStart, out.length);                                       \
     out.data[out.length] = '\0';
 
-	// parse a string, enclosed in quotation marks
-#define AI_MD5_PARSE_STRING_IN_QUOTATION(out) \
-	while('\"'!=*sz)++sz; \
-    const char* szStart = ++sz; \
-	while('\"'!=*sz)++sz; \
-    const char* szEnd = (sz++); \
-    out.length = (ai_uint32) (szEnd - szStart); \
-    ::memcpy(out.data,szStart,out.length); \
+// parse a string, enclosed in quotation marks
+#define AI_MD5_PARSE_STRING_IN_QUOTATION(out)  \
+    while ('\"' != *sz)                        \
+        ++sz;                                  \
+    const char *szStart = ++sz;                \
+    while ('\"' != *sz)                        \
+        ++sz;                                  \
+    const char *szEnd = (sz++);                \
+    out.length = (ai_uint32)(szEnd - szStart); \
+    ::memcpy(out.data, szStart, out.length);   \
     out.data[out.length] = '\0';
 // ------------------------------------------------------------------------------------------------
 // .MD5MESH parsing function
-MD5MeshParser::MD5MeshParser(SectionList& mSections)
-{
+MD5MeshParser::MD5MeshParser(SectionList &mSections) {
     ASSIMP_LOG_DEBUG("MD5MeshParser begin");
 
     // now parse all sections
-    for (SectionList::const_iterator iter =  mSections.begin(), iterEnd = mSections.end();iter != iterEnd;++iter){
-        if ( (*iter).mName == "numMeshes")  {
+    for (SectionList::const_iterator iter = mSections.begin(), iterEnd = mSections.end(); iter != iterEnd; ++iter) {
+        if ((*iter).mName == "numMeshes") {
             mMeshes.reserve(::strtoul10((*iter).mGlobalValue.c_str()));
-        }
-        else if ( (*iter).mName == "numJoints") {
+        } else if ((*iter).mName == "numJoints") {
             mJoints.reserve(::strtoul10((*iter).mGlobalValue.c_str()));
-        }
-        else if ((*iter).mName == "joints") {
+        } else if ((*iter).mName == "joints") {
             // "origin" -1 ( -0.000000 0.016430 -0.006044 ) ( 0.707107 0.000000 0.707107 )
-            for (const auto & elem : (*iter).mElements){
+            for (const auto &elem : (*iter).mElements) {
                 mJoints.push_back(BoneDesc());
-                BoneDesc& desc = mJoints.back();
-				
-                const char* sz = elem.szStart;
-				AI_MD5_PARSE_STRING_IN_QUOTATION(desc.mName);
+                BoneDesc &desc = mJoints.back();
+
+                const char *sz = elem.szStart;
+                AI_MD5_PARSE_STRING_IN_QUOTATION(desc.mName);
                 AI_MD5_SKIP_SPACES();
 
                 // negative values, at least -1, is allowed here
-                desc.mParentIndex = (int)strtol10(sz,&sz);
+                desc.mParentIndex = (int)strtol10(sz, &sz);
 
                 AI_MD5_READ_TRIPLE(desc.mPositionXYZ);
                 AI_MD5_READ_TRIPLE(desc.mRotationQuat); // normalized quaternion, so w is not there
             }
-        }
-        else if ((*iter).mName == "mesh")   {
+        } else if ((*iter).mName == "mesh") {
             mMeshes.push_back(MeshDesc());
-            MeshDesc& desc = mMeshes.back();
+            MeshDesc &desc = mMeshes.back();
 
-            for (const auto & elem : (*iter).mElements){
-                const char* sz = elem.szStart;
+            for (const auto &elem : (*iter).mElements) {
+                const char *sz = elem.szStart;
 
                 // shader attribute
-                if (TokenMatch(sz,"shader",6))  {
+                if (TokenMatch(sz, "shader", 6)) {
                     AI_MD5_SKIP_SPACES();
                     AI_MD5_PARSE_STRING_IN_QUOTATION(desc.mShader);
                 }
                 // numverts attribute
-                else if (TokenMatch(sz,"numverts",8))   {
+                else if (TokenMatch(sz, "numverts", 8)) {
                     AI_MD5_SKIP_SPACES();
                     desc.mVertices.resize(strtoul10(sz));
                 }
                 // numtris attribute
-                else if (TokenMatch(sz,"numtris",7))    {
+                else if (TokenMatch(sz, "numtris", 7)) {
                     AI_MD5_SKIP_SPACES();
                     desc.mFaces.resize(strtoul10(sz));
                 }
                 // numweights attribute
-                else if (TokenMatch(sz,"numweights",10))    {
+                else if (TokenMatch(sz, "numweights", 10)) {
                     AI_MD5_SKIP_SPACES();
                     desc.mWeights.resize(strtoul10(sz));
                 }
                 // vert attribute
                 // "vert 0 ( 0.394531 0.513672 ) 0 1"
-                else if (TokenMatch(sz,"vert",4))   {
+                else if (TokenMatch(sz, "vert", 4)) {
                     AI_MD5_SKIP_SPACES();
-                    const unsigned int idx = ::strtoul10(sz,&sz);
+                    const unsigned int idx = ::strtoul10(sz, &sz);
                     AI_MD5_SKIP_SPACES();
                     if (idx >= desc.mVertices.size())
-                        desc.mVertices.resize(idx+1);
+                        desc.mVertices.resize(idx + 1);
 
-                    VertexDesc& vert = desc.mVertices[idx];
+                    VertexDesc &vert = desc.mVertices[idx];
                     if ('(' != *sz++)
-                        MD5Parser::ReportWarning("Unexpected token: ( was expected",elem.iLineNumber);
+                        MD5Parser::ReportWarning("Unexpected token: ( was expected", elem.iLineNumber);
                     AI_MD5_SKIP_SPACES();
-                    sz = fast_atoreal_move<float>(sz,(float&)vert.mUV.x);
+                    sz = fast_atoreal_move<float>(sz, (float &)vert.mUV.x);
                     AI_MD5_SKIP_SPACES();
-                    sz = fast_atoreal_move<float>(sz,(float&)vert.mUV.y);
+                    sz = fast_atoreal_move<float>(sz, (float &)vert.mUV.y);
                     AI_MD5_SKIP_SPACES();
                     if (')' != *sz++)
-                        MD5Parser::ReportWarning("Unexpected token: ) was expected",elem.iLineNumber);
+                        MD5Parser::ReportWarning("Unexpected token: ) was expected", elem.iLineNumber);
                     AI_MD5_SKIP_SPACES();
-                    vert.mFirstWeight = ::strtoul10(sz,&sz);
+                    vert.mFirstWeight = ::strtoul10(sz, &sz);
                     AI_MD5_SKIP_SPACES();
-                    vert.mNumWeights = ::strtoul10(sz,&sz);
+                    vert.mNumWeights = ::strtoul10(sz, &sz);
                 }
                 // tri attribute
                 // "tri 0 15 13 12"
-                else if (TokenMatch(sz,"tri",3)) {
+                else if (TokenMatch(sz, "tri", 3)) {
                     AI_MD5_SKIP_SPACES();
-                    const unsigned int idx = strtoul10(sz,&sz);
+                    const unsigned int idx = strtoul10(sz, &sz);
                     if (idx >= desc.mFaces.size())
-                        desc.mFaces.resize(idx+1);
+                        desc.mFaces.resize(idx + 1);
 
-                    aiFace& face = desc.mFaces[idx];
+                    aiFace &face = desc.mFaces[idx];
                     face.mIndices = new unsigned int[face.mNumIndices = 3];
-                    for (unsigned int i = 0; i < 3;++i) {
+                    for (unsigned int i = 0; i < 3; ++i) {
                         AI_MD5_SKIP_SPACES();
-                        face.mIndices[i] = strtoul10(sz,&sz);
+                        face.mIndices[i] = strtoul10(sz, &sz);
                     }
                 }
                 // weight attribute
                 // "weight 362 5 0.500000 ( -3.553583 11.893474 9.719339 )"
-                else if (TokenMatch(sz,"weight",6)) {
+                else if (TokenMatch(sz, "weight", 6)) {
                     AI_MD5_SKIP_SPACES();
-                    const unsigned int idx = strtoul10(sz,&sz);
+                    const unsigned int idx = strtoul10(sz, &sz);
                     AI_MD5_SKIP_SPACES();
                     if (idx >= desc.mWeights.size())
-                        desc.mWeights.resize(idx+1);
+                        desc.mWeights.resize(idx + 1);
 
-                    WeightDesc& weight = desc.mWeights[idx];
-                    weight.mBone = strtoul10(sz,&sz);
+                    WeightDesc &weight = desc.mWeights[idx];
+                    weight.mBone = strtoul10(sz, &sz);
                     AI_MD5_SKIP_SPACES();
-                    sz = fast_atoreal_move<float>(sz,weight.mWeight);
+                    sz = fast_atoreal_move<float>(sz, weight.mWeight);
                     AI_MD5_READ_TRIPLE(weight.vOffsetPosition);
                 }
             }
@@ -358,57 +355,54 @@ MD5MeshParser::MD5MeshParser(SectionList& mSections)
 
 // ------------------------------------------------------------------------------------------------
 // .MD5ANIM parsing function
-MD5AnimParser::MD5AnimParser(SectionList& mSections)
-{
+MD5AnimParser::MD5AnimParser(SectionList &mSections) {
     ASSIMP_LOG_DEBUG("MD5AnimParser begin");
 
     fFrameRate = 24.0f;
     mNumAnimatedComponents = UINT_MAX;
-    for (SectionList::const_iterator iter =  mSections.begin(), iterEnd = mSections.end();iter != iterEnd;++iter) {
-        if ((*iter).mName == "hierarchy")   {
+    for (SectionList::const_iterator iter = mSections.begin(), iterEnd = mSections.end(); iter != iterEnd; ++iter) {
+        if ((*iter).mName == "hierarchy") {
             // "sheath" 0 63 6
-            for (const auto & elem : (*iter).mElements) {
-                mAnimatedBones.push_back ( AnimBoneDesc () );
-                AnimBoneDesc& desc = mAnimatedBones.back();
+            for (const auto &elem : (*iter).mElements) {
+                mAnimatedBones.push_back(AnimBoneDesc());
+                AnimBoneDesc &desc = mAnimatedBones.back();
 
-                const char* sz = elem.szStart;
+                const char *sz = elem.szStart;
                 AI_MD5_PARSE_STRING_IN_QUOTATION(desc.mName);
                 AI_MD5_SKIP_SPACES();
 
                 // parent index - negative values are allowed (at least -1)
-                desc.mParentIndex = ::strtol10(sz,&sz);
+                desc.mParentIndex = ::strtol10(sz, &sz);
 
                 // flags (highest is 2^6-1)
                 AI_MD5_SKIP_SPACES();
-                if(63 < (desc.iFlags = ::strtoul10(sz,&sz))){
-                    MD5Parser::ReportWarning("Invalid flag combination in hierarchy section",elem.iLineNumber);
+                if (63 < (desc.iFlags = ::strtoul10(sz, &sz))) {
+                    MD5Parser::ReportWarning("Invalid flag combination in hierarchy section", elem.iLineNumber);
                 }
                 AI_MD5_SKIP_SPACES();
 
                 // index of the first animation keyframe component for this joint
-                desc.iFirstKeyIndex = ::strtoul10(sz,&sz);
+                desc.iFirstKeyIndex = ::strtoul10(sz, &sz);
             }
-        }
-        else if((*iter).mName == "baseframe")   {
+        } else if ((*iter).mName == "baseframe") {
             // ( -0.000000 0.016430 -0.006044 ) ( 0.707107 0.000242 0.707107 )
-            for (const auto & elem : (*iter).mElements) {
-                const char* sz = elem.szStart;
+            for (const auto &elem : (*iter).mElements) {
+                const char *sz = elem.szStart;
 
-                mBaseFrames.push_back ( BaseFrameDesc () );
-                BaseFrameDesc& desc = mBaseFrames.back();
+                mBaseFrames.push_back(BaseFrameDesc());
+                BaseFrameDesc &desc = mBaseFrames.back();
 
                 AI_MD5_READ_TRIPLE(desc.vPositionXYZ);
                 AI_MD5_READ_TRIPLE(desc.vRotationQuat);
             }
-        }
-        else if((*iter).mName ==  "frame")  {
+        } else if ((*iter).mName == "frame") {
             if (!(*iter).mGlobalValue.length()) {
-                MD5Parser::ReportWarning("A frame section must have a frame index",(*iter).iLineNumber);
+                MD5Parser::ReportWarning("A frame section must have a frame index", (*iter).iLineNumber);
                 continue;
             }
 
-            mFrames.push_back ( FrameDesc () );
-            FrameDesc& desc = mFrames.back();
+            mFrames.push_back(FrameDesc());
+            FrameDesc &desc = mFrames.back();
             desc.iIndex = strtoul10((*iter).mGlobalValue.c_str());
 
             // we do already know how much storage we will presumably need
@@ -417,31 +411,28 @@ MD5AnimParser::MD5AnimParser(SectionList& mSections)
             }
 
             // now read all elements (continuous list of floats)
-            for (const auto & elem : (*iter).mElements){
-                const char* sz = elem.szStart;
-                while (SkipSpacesAndLineEnd(&sz))   {
-                    float f;sz = fast_atoreal_move<float>(sz,f);
+            for (const auto &elem : (*iter).mElements) {
+                const char *sz = elem.szStart;
+                while (SkipSpacesAndLineEnd(&sz)) {
+                    float f;
+                    sz = fast_atoreal_move<float>(sz, f);
                     desc.mValues.push_back(f);
                 }
             }
-        }
-        else if((*iter).mName == "numFrames")   {
+        } else if ((*iter).mName == "numFrames") {
             mFrames.reserve(strtoul10((*iter).mGlobalValue.c_str()));
-        }
-        else if((*iter).mName == "numJoints")   {
+        } else if ((*iter).mName == "numJoints") {
             const unsigned int num = strtoul10((*iter).mGlobalValue.c_str());
             mAnimatedBones.reserve(num);
 
             // try to guess the number of animated components if that element is not given
-            if (UINT_MAX  == mNumAnimatedComponents) {
+            if (UINT_MAX == mNumAnimatedComponents) {
                 mNumAnimatedComponents = num * 6;
             }
-        }
-        else if((*iter).mName == "numAnimatedComponents")   {
-            mAnimatedBones.reserve( strtoul10((*iter).mGlobalValue.c_str()));
-        }
-        else if((*iter).mName == "frameRate")   {
-            fast_atoreal_move<float>((*iter).mGlobalValue.c_str(),fFrameRate);
+        } else if ((*iter).mName == "numAnimatedComponents") {
+            mAnimatedBones.reserve(strtoul10((*iter).mGlobalValue.c_str()));
+        } else if ((*iter).mName == "frameRate") {
+            fast_atoreal_move<float>((*iter).mGlobalValue.c_str(), fFrameRate);
         }
     }
     ASSIMP_LOG_DEBUG("MD5AnimParser end");
@@ -449,32 +440,27 @@ MD5AnimParser::MD5AnimParser(SectionList& mSections)
 
 // ------------------------------------------------------------------------------------------------
 // .MD5CAMERA parsing function
-MD5CameraParser::MD5CameraParser(SectionList& mSections)
-{
+MD5CameraParser::MD5CameraParser(SectionList &mSections) {
     ASSIMP_LOG_DEBUG("MD5CameraParser begin");
     fFrameRate = 24.0f;
 
-    for (SectionList::const_iterator iter =  mSections.begin(), iterEnd = mSections.end();iter != iterEnd;++iter) {
-        if ((*iter).mName == "numFrames")   {
+    for (SectionList::const_iterator iter = mSections.begin(), iterEnd = mSections.end(); iter != iterEnd; ++iter) {
+        if ((*iter).mName == "numFrames") {
             frames.reserve(strtoul10((*iter).mGlobalValue.c_str()));
-        }
-        else if ((*iter).mName == "frameRate")  {
-            fFrameRate = fast_atof ((*iter).mGlobalValue.c_str());
-        }
-        else if ((*iter).mName == "numCuts")    {
+        } else if ((*iter).mName == "frameRate") {
+            fFrameRate = fast_atof((*iter).mGlobalValue.c_str());
+        } else if ((*iter).mName == "numCuts") {
             cuts.reserve(strtoul10((*iter).mGlobalValue.c_str()));
-        }
-        else if ((*iter).mName == "cuts")   {
-            for (const auto & elem : (*iter).mElements){
-                cuts.push_back(strtoul10(elem.szStart)+1);
+        } else if ((*iter).mName == "cuts") {
+            for (const auto &elem : (*iter).mElements) {
+                cuts.push_back(strtoul10(elem.szStart) + 1);
             }
-        }
-        else if ((*iter).mName == "camera") {
-            for (const auto & elem : (*iter).mElements){
-                const char* sz = elem.szStart;
+        } else if ((*iter).mName == "camera") {
+            for (const auto &elem : (*iter).mElements) {
+                const char *sz = elem.szStart;
 
                 frames.push_back(CameraAnimFrameDesc());
-                CameraAnimFrameDesc& cur = frames.back();
+                CameraAnimFrameDesc &cur = frames.back();
                 AI_MD5_READ_TRIPLE(cur.vPositionXYZ);
                 AI_MD5_READ_TRIPLE(cur.vRotationQuat);
                 AI_MD5_SKIP_SPACES();
@@ -484,4 +470,3 @@ MD5CameraParser::MD5CameraParser(SectionList& mSections)
     }
     ASSIMP_LOG_DEBUG("MD5CameraParser end");
 }
-
diff --git a/Engine/lib/assimp/code/MD5/MD5Parser.h b/Engine/lib/assimp/code/AssetLib/MD5/MD5Parser.h
similarity index 99%
rename from Engine/lib/assimp/code/MD5/MD5Parser.h
rename to Engine/lib/assimp/code/AssetLib/MD5/MD5Parser.h
index f7ff5303f..3108655f1 100644
--- a/Engine/lib/assimp/code/MD5/MD5Parser.h
+++ b/Engine/lib/assimp/code/AssetLib/MD5/MD5Parser.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/MDC/MDCFileData.h b/Engine/lib/assimp/code/AssetLib/MDC/MDCFileData.h
similarity index 98%
rename from Engine/lib/assimp/code/MDC/MDCFileData.h
rename to Engine/lib/assimp/code/AssetLib/MDC/MDCFileData.h
index 052473158..36c589e91 100644
--- a/Engine/lib/assimp/code/MDC/MDCFileData.h
+++ b/Engine/lib/assimp/code/AssetLib/MDC/MDCFileData.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -120,13 +120,13 @@ struct Surface {
     , ulFlags()
     , ulNumCompFrames()
     , ulNumBaseFrames()
-    , ulNumShaders() 
+    , ulNumShaders()
     , ulNumVertices()
     , ulNumTriangles()
     , ulOffsetTriangles()
     , ulOffsetShaders()
     , ulOffsetTexCoords()
-    , ulOffsetBaseVerts() 
+    , ulOffsetBaseVerts()
     , ulOffsetCompVerts()
     , ulOffsetFrameBaseFrames()
     , ulOffsetFrameCompFrames()
diff --git a/Engine/lib/assimp/code/MDC/MDCLoader.cpp b/Engine/lib/assimp/code/AssetLib/MDC/MDCLoader.cpp
similarity index 52%
rename from Engine/lib/assimp/code/MDC/MDCLoader.cpp
rename to Engine/lib/assimp/code/AssetLib/MDC/MDCLoader.cpp
index 084ec6024..7810800de 100644
--- a/Engine/lib/assimp/code/MDC/MDCLoader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/MDC/MDCLoader.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,19 +41,19 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** @file Implementation of the MDC importer class */
 
-
 #ifndef ASSIMP_BUILD_NO_MDC_IMPORTER
 
 // internal headers
-#include "MDC/MDCLoader.h"
-#include "MD3/MD3FileData.h"
-#include "MDC/MDCNormalTable.h" // shouldn't be included by other units
+#include "AssetLib/MDC/MDCLoader.h"
+#include "AssetLib/MD3/MD3FileData.h"
+#include "AssetLib/MDC/MDCNormalTable.h" // shouldn't be included by other units
 
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/Importer.hpp>
-#include <assimp/IOSystem.hpp>
-#include <assimp/scene.h>
 #include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOSystem.hpp>
+#include <assimp/Importer.hpp>
+#include <assimp/StringUtils.h>
 
 #include <memory>
 
@@ -76,12 +74,11 @@ static const aiImporterDesc desc = {
 };
 
 // ------------------------------------------------------------------------------------------------
-void MDC::BuildVertex(const Frame& frame,
-    const BaseVertex& bvert,
-    const CompressedVertex& cvert,
-    aiVector3D& vXYZOut,
-    aiVector3D& vNorOut)
-{
+void MDC::BuildVertex(const Frame &frame,
+        const BaseVertex &bvert,
+        const CompressedVertex &cvert,
+        aiVector3D &vXYZOut,
+        aiVector3D &vNorOut) {
     // compute the position
     const float xd = (cvert.xd - AI_MDC_CVERT_BIAS) * AI_MDC_DELTA_SCALING;
     const float yd = (cvert.yd - AI_MDC_CVERT_BIAS) * AI_MDC_DELTA_SCALING;
@@ -98,66 +95,47 @@ void MDC::BuildVertex(const Frame& frame,
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-MDCImporter::MDCImporter()
-    : configFrameID(),
-    pcHeader(),
-    mBuffer(),
-    fileSize()
-{
+MDCImporter::MDCImporter() :
+        configFrameID(),
+        pcHeader(),
+        mBuffer(),
+        fileSize() {
+    // empty
 }
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-MDCImporter::~MDCImporter()
-{
+MDCImporter::~MDCImporter() {
+    // empty
 }
+
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool MDCImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
-{
-    const std::string extension = GetExtension(pFile);
-    if (extension == "mdc")
-        return true;
-
-    // if check for extension is not enough, check for the magic tokens
-    if (!extension.length() || checkSig) {
-        uint32_t tokens[1];
-        tokens[0] = AI_MDC_MAGIC_NUMBER_LE;
-        return CheckMagicToken(pIOHandler,pFile,tokens,1);
-    }
-    return false;
+bool MDCImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
+    static const uint32_t tokens[] = { AI_MDC_MAGIC_NUMBER_LE };
+    return CheckMagicToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------
-const aiImporterDesc* MDCImporter::GetInfo () const
-{
+const aiImporterDesc *MDCImporter::GetInfo() const {
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Validate the header of the given MDC file
-void MDCImporter::ValidateHeader()
-{
-    AI_SWAP4( this->pcHeader->ulVersion );
-    AI_SWAP4( this->pcHeader->ulFlags );
-    AI_SWAP4( this->pcHeader->ulNumFrames );
-    AI_SWAP4( this->pcHeader->ulNumTags );
-    AI_SWAP4( this->pcHeader->ulNumSurfaces );
-    AI_SWAP4( this->pcHeader->ulNumSkins );
-    AI_SWAP4( this->pcHeader->ulOffsetBorderFrames );
+void MDCImporter::ValidateHeader() {
+    AI_SWAP4(this->pcHeader->ulVersion);
+    AI_SWAP4(this->pcHeader->ulFlags);
+    AI_SWAP4(this->pcHeader->ulNumFrames);
+    AI_SWAP4(this->pcHeader->ulNumTags);
+    AI_SWAP4(this->pcHeader->ulNumSurfaces);
+    AI_SWAP4(this->pcHeader->ulNumSkins);
+    AI_SWAP4(this->pcHeader->ulOffsetBorderFrames);
 
     if (pcHeader->ulIdent != AI_MDC_MAGIC_NUMBER_BE &&
-        pcHeader->ulIdent != AI_MDC_MAGIC_NUMBER_LE)
-    {
-        char szBuffer[5];
-        szBuffer[0] = ((char*)&pcHeader->ulIdent)[0];
-        szBuffer[1] = ((char*)&pcHeader->ulIdent)[1];
-        szBuffer[2] = ((char*)&pcHeader->ulIdent)[2];
-        szBuffer[3] = ((char*)&pcHeader->ulIdent)[3];
-        szBuffer[4] = '\0';
-
-        throw DeadlyImportError("Invalid MDC magic word: should be IDPC, the "
-            "magic word found is " + std::string( szBuffer ));
+            pcHeader->ulIdent != AI_MDC_MAGIC_NUMBER_LE) {
+        throw DeadlyImportError("Invalid MDC magic word: expected IDPC, found ",
+                                ai_str_toprintable((char *)&pcHeader->ulIdent, 4));
     }
 
     if (pcHeader->ulVersion != AI_MDC_VERSION) {
@@ -165,10 +143,9 @@ void MDCImporter::ValidateHeader()
     }
 
     if (pcHeader->ulOffsetBorderFrames + pcHeader->ulNumFrames * sizeof(MDC::Frame) > this->fileSize ||
-        pcHeader->ulOffsetSurfaces + pcHeader->ulNumSurfaces * sizeof(MDC::Surface) > this->fileSize)
-    {
+            pcHeader->ulOffsetSurfaces + pcHeader->ulNumSurfaces * sizeof(MDC::Surface) > this->fileSize) {
         throw DeadlyImportError("Some of the offset values in the MDC header are invalid "
-            "and point to something behind the file.");
+                                "and point to something behind the file.");
     }
 
     if (this->configFrameID >= this->pcHeader->ulNumFrames) {
@@ -178,8 +155,7 @@ void MDCImporter::ValidateHeader()
 
 // ------------------------------------------------------------------------------------------------
 // Validate the header of a given MDC file surface
-void MDCImporter::ValidateSurfaceHeader(BE_NCONST MDC::Surface* pcSurf)
-{
+void MDCImporter::ValidateSurfaceHeader(BE_NCONST MDC::Surface *pcSurf) {
     AI_SWAP4(pcSurf->ulFlags);
     AI_SWAP4(pcSurf->ulNumCompFrames);
     AI_SWAP4(pcSurf->ulNumBaseFrames);
@@ -194,230 +170,216 @@ void MDCImporter::ValidateSurfaceHeader(BE_NCONST MDC::Surface* pcSurf)
     AI_SWAP4(pcSurf->ulOffsetFrameCompFrames);
     AI_SWAP4(pcSurf->ulOffsetEnd);
 
-    const unsigned int iMax = this->fileSize - (unsigned int)((int8_t*)pcSurf-(int8_t*)pcHeader);
+    const unsigned int iMax = this->fileSize - (unsigned int)((int8_t *)pcSurf - (int8_t *)pcHeader);
 
-    if (pcSurf->ulOffsetBaseVerts + pcSurf->ulNumVertices * sizeof(MDC::BaseVertex)         > iMax ||
-        (pcSurf->ulNumCompFrames && pcSurf->ulOffsetCompVerts + pcSurf->ulNumVertices * sizeof(MDC::CompressedVertex)   > iMax) ||
-        pcSurf->ulOffsetTriangles + pcSurf->ulNumTriangles * sizeof(MDC::Triangle)          > iMax ||
-        pcSurf->ulOffsetTexCoords + pcSurf->ulNumVertices * sizeof(MDC::TexturCoord)        > iMax ||
-        pcSurf->ulOffsetShaders + pcSurf->ulNumShaders * sizeof(MDC::Shader)                > iMax ||
-        pcSurf->ulOffsetFrameBaseFrames + pcSurf->ulNumBaseFrames * 2                       > iMax ||
-        (pcSurf->ulNumCompFrames && pcSurf->ulOffsetFrameCompFrames + pcSurf->ulNumCompFrames * 2   > iMax))
-    {
+    if (pcSurf->ulOffsetBaseVerts + pcSurf->ulNumVertices * sizeof(MDC::BaseVertex) > iMax ||
+            (pcSurf->ulNumCompFrames && pcSurf->ulOffsetCompVerts + pcSurf->ulNumVertices * sizeof(MDC::CompressedVertex) > iMax) ||
+            pcSurf->ulOffsetTriangles + pcSurf->ulNumTriangles * sizeof(MDC::Triangle) > iMax ||
+            pcSurf->ulOffsetTexCoords + pcSurf->ulNumVertices * sizeof(MDC::TexturCoord) > iMax ||
+            pcSurf->ulOffsetShaders + pcSurf->ulNumShaders * sizeof(MDC::Shader) > iMax ||
+            pcSurf->ulOffsetFrameBaseFrames + pcSurf->ulNumBaseFrames * 2 > iMax ||
+            (pcSurf->ulNumCompFrames && pcSurf->ulOffsetFrameCompFrames + pcSurf->ulNumCompFrames * 2 > iMax)) {
         throw DeadlyImportError("Some of the offset values in the MDC surface header "
-            "are invalid and point somewhere behind the file.");
+                                "are invalid and point somewhere behind the file.");
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup configuration properties
-void MDCImporter::SetupProperties(const Importer* pImp)
-{
+void MDCImporter::SetupProperties(const Importer *pImp) {
     // The AI_CONFIG_IMPORT_MDC_KEYFRAME option overrides the
     // AI_CONFIG_IMPORT_GLOBAL_KEYFRAME option.
-    if(static_cast<unsigned int>(-1) == (configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_MDC_KEYFRAME,-1))){
-        configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_GLOBAL_KEYFRAME,0);
+    if (static_cast<unsigned int>(-1) == (configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_MDC_KEYFRAME, -1))) {
+        configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_GLOBAL_KEYFRAME, 0);
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
 void MDCImporter::InternReadFile(
-    const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler)
-{
-    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile));
+        const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
+    std::unique_ptr<IOStream> file(pIOHandler->Open(pFile));
 
     // Check whether we can read from the file
-    if( file.get() == NULL)
-        throw DeadlyImportError( "Failed to open MDC file " + pFile + ".");
+    if (file.get() == nullptr) {
+        throw DeadlyImportError("Failed to open MDC file ", pFile, ".");
+    }
 
     // check whether the mdc file is large enough to contain the file header
-    fileSize = (unsigned int)file->FileSize();
-    if( fileSize < sizeof(MDC::Header))
-        throw DeadlyImportError( "MDC File is too small.");
+    fileSize = static_cast<unsigned int>(file->FileSize());
+    if (fileSize < sizeof(MDC::Header)) {
+        throw DeadlyImportError("MDC File is too small.");
+    }
 
     std::vector<unsigned char> mBuffer2(fileSize);
-    file->Read( &mBuffer2[0], 1, fileSize);
+    file->Read(&mBuffer2[0], 1, fileSize);
     mBuffer = &mBuffer2[0];
 
     // validate the file header
-    this->pcHeader = (BE_NCONST MDC::Header*)this->mBuffer;
+    this->pcHeader = (BE_NCONST MDC::Header *)this->mBuffer;
     this->ValidateHeader();
 
     std::vector<std::string> aszShaders;
 
     // get a pointer to the frame we want to read
-    BE_NCONST MDC::Frame* pcFrame = (BE_NCONST MDC::Frame*)(this->mBuffer+
-        this->pcHeader->ulOffsetBorderFrames);
+    BE_NCONST MDC::Frame *pcFrame = (BE_NCONST MDC::Frame *)(this->mBuffer +
+                                                             this->pcHeader->ulOffsetBorderFrames);
 
     // no need to swap the other members, we won't need them
     pcFrame += configFrameID;
-    AI_SWAP4( pcFrame->localOrigin[0] );
-    AI_SWAP4( pcFrame->localOrigin[1] );
-    AI_SWAP4( pcFrame->localOrigin[2] );
+    AI_SWAP4(pcFrame->localOrigin[0]);
+    AI_SWAP4(pcFrame->localOrigin[1]);
+    AI_SWAP4(pcFrame->localOrigin[2]);
 
     // get the number of valid surfaces
-    BE_NCONST MDC::Surface* pcSurface, *pcSurface2;
-    pcSurface = pcSurface2 = new (mBuffer + pcHeader->ulOffsetSurfaces) MDC::Surface;
+    BE_NCONST MDC::Surface *pcSurface, *pcSurface2;
+    pcSurface = pcSurface2 = reinterpret_cast<BE_NCONST MDC::Surface *>(mBuffer + pcHeader->ulOffsetSurfaces);
     unsigned int iNumShaders = 0;
-    for (unsigned int i = 0; i < pcHeader->ulNumSurfaces;++i)
-    {
+    for (unsigned int i = 0; i < pcHeader->ulNumSurfaces; ++i) {
         // validate the surface header
         this->ValidateSurfaceHeader(pcSurface2);
 
-        if (pcSurface2->ulNumVertices && pcSurface2->ulNumTriangles)++pScene->mNumMeshes;
+        if (pcSurface2->ulNumVertices && pcSurface2->ulNumTriangles) {
+            ++pScene->mNumMeshes;
+        }
         iNumShaders += pcSurface2->ulNumShaders;
-        pcSurface2 = new ((int8_t*)pcSurface2 + pcSurface2->ulOffsetEnd) MDC::Surface;
+        pcSurface2 = reinterpret_cast<BE_NCONST MDC::Surface *>((BE_NCONST int8_t *)pcSurface2 + pcSurface2->ulOffsetEnd);
     }
     aszShaders.reserve(iNumShaders);
-    pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];
+    pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
 
     // necessary that we don't crash if an exception occurs
-    for (unsigned int i = 0; i < pScene->mNumMeshes;++i)
-        pScene->mMeshes[i] = NULL;
+    for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
+        pScene->mMeshes[i] = nullptr;
+    }
 
     // now read all surfaces
     unsigned int iDefaultMatIndex = UINT_MAX;
-    for (unsigned int i = 0, iNum = 0; i < pcHeader->ulNumSurfaces;++i)
-    {
-        if (!pcSurface->ulNumVertices || !pcSurface->ulNumTriangles)continue;
-        aiMesh* pcMesh = pScene->mMeshes[iNum++] = new aiMesh();
+    for (unsigned int i = 0, iNum = 0; i < pcHeader->ulNumSurfaces; ++i) {
+        if (!pcSurface->ulNumVertices || !pcSurface->ulNumTriangles) continue;
+        aiMesh *pcMesh = pScene->mMeshes[iNum++] = new aiMesh();
 
         pcMesh->mNumFaces = pcSurface->ulNumTriangles;
         pcMesh->mNumVertices = pcMesh->mNumFaces * 3;
 
         // store the name of the surface for use as node name.
-        pcMesh->mName.Set(std::string(pcSurface->ucName
-                                    , strnlen(pcSurface->ucName, AI_MDC_MAXQPATH - 1)));
+        pcMesh->mName.Set(std::string(pcSurface->ucName, strnlen(pcSurface->ucName, AI_MDC_MAXQPATH - 1)));
 
         // go to the first shader in the file. ignore the others.
-        if (pcSurface->ulNumShaders)
-        {
-            const MDC::Shader* pcShader = (const MDC::Shader*)((int8_t*)pcSurface + pcSurface->ulOffsetShaders);
+        if (pcSurface->ulNumShaders) {
+            const MDC::Shader *pcShader = (const MDC::Shader *)((int8_t *)pcSurface + pcSurface->ulOffsetShaders);
             pcMesh->mMaterialIndex = (unsigned int)aszShaders.size();
 
             // create a new shader
-            aszShaders.push_back(std::string( pcShader->ucName, 
-                ::strnlen(pcShader->ucName, sizeof(pcShader->ucName)) ));
+            aszShaders.push_back(std::string(pcShader->ucName,
+                    ::strnlen(pcShader->ucName, sizeof(pcShader->ucName))));
         }
         // need to create a default material
-        else if (UINT_MAX == iDefaultMatIndex)
-        {
+        else if (UINT_MAX == iDefaultMatIndex) {
             pcMesh->mMaterialIndex = iDefaultMatIndex = (unsigned int)aszShaders.size();
             aszShaders.push_back(std::string());
         }
         // otherwise assign a reference to the default material
-        else pcMesh->mMaterialIndex = iDefaultMatIndex;
+        else
+            pcMesh->mMaterialIndex = iDefaultMatIndex;
 
         // allocate output storage for the mesh
-        aiVector3D* pcVertCur   = pcMesh->mVertices         = new aiVector3D[pcMesh->mNumVertices];
-        aiVector3D* pcNorCur    = pcMesh->mNormals          = new aiVector3D[pcMesh->mNumVertices];
-        aiVector3D* pcUVCur     = pcMesh->mTextureCoords[0] = new aiVector3D[pcMesh->mNumVertices];
-        aiFace* pcFaceCur       = pcMesh->mFaces            = new aiFace[pcMesh->mNumFaces];
+        aiVector3D *pcVertCur = pcMesh->mVertices = new aiVector3D[pcMesh->mNumVertices];
+        aiVector3D *pcNorCur = pcMesh->mNormals = new aiVector3D[pcMesh->mNumVertices];
+        aiVector3D *pcUVCur = pcMesh->mTextureCoords[0] = new aiVector3D[pcMesh->mNumVertices];
+        aiFace *pcFaceCur = pcMesh->mFaces = new aiFace[pcMesh->mNumFaces];
 
         // create all vertices/faces
-        BE_NCONST MDC::Triangle* pcTriangle = (BE_NCONST MDC::Triangle*)
-            ((int8_t*)pcSurface+pcSurface->ulOffsetTriangles);
+        BE_NCONST MDC::Triangle *pcTriangle = (BE_NCONST MDC::Triangle *)((int8_t *)pcSurface + pcSurface->ulOffsetTriangles);
 
-        BE_NCONST MDC::TexturCoord* const pcUVs = (BE_NCONST MDC::TexturCoord*)
-            ((int8_t*)pcSurface+pcSurface->ulOffsetTexCoords);
+        BE_NCONST MDC::TexturCoord *const pcUVs = (BE_NCONST MDC::TexturCoord *)((int8_t *)pcSurface + pcSurface->ulOffsetTexCoords);
 
         // get a pointer to the uncompressed vertices
-        int16_t iOfs = *((int16_t*) ((int8_t*) pcSurface +
-            pcSurface->ulOffsetFrameBaseFrames) +  this->configFrameID);
+        int16_t iOfs = *((int16_t *)((int8_t *)pcSurface +
+                                     pcSurface->ulOffsetFrameBaseFrames) +
+                         this->configFrameID);
 
         AI_SWAP2(iOfs);
 
-        BE_NCONST MDC::BaseVertex* const pcVerts = (BE_NCONST MDC::BaseVertex*)
-            ((int8_t*)pcSurface+pcSurface->ulOffsetBaseVerts) +
-            ((int)iOfs * pcSurface->ulNumVertices * 4);
+        BE_NCONST MDC::BaseVertex *const pcVerts = (BE_NCONST MDC::BaseVertex *)((int8_t *)pcSurface + pcSurface->ulOffsetBaseVerts) +
+                                                   ((int)iOfs * pcSurface->ulNumVertices * 4);
 
         // do the main swapping stuff ...
 #if (defined AI_BUILD_BIG_ENDIAN)
 
         // swap all triangles
-        for (unsigned int i = 0; i < pcSurface->ulNumTriangles;++i)
-        {
-            AI_SWAP4( pcTriangle[i].aiIndices[0] );
-            AI_SWAP4( pcTriangle[i].aiIndices[1] );
-            AI_SWAP4( pcTriangle[i].aiIndices[2] );
+        for (unsigned int i = 0; i < pcSurface->ulNumTriangles; ++i) {
+            AI_SWAP4(pcTriangle[i].aiIndices[0]);
+            AI_SWAP4(pcTriangle[i].aiIndices[1]);
+            AI_SWAP4(pcTriangle[i].aiIndices[2]);
         }
 
         // swap all vertices
-        for (unsigned int i = 0; i < pcSurface->ulNumVertices*pcSurface->ulNumBaseFrames;++i)
-        {
-            AI_SWAP2( pcVerts->normal );
-            AI_SWAP2( pcVerts->x );
-            AI_SWAP2( pcVerts->y );
-            AI_SWAP2( pcVerts->z );
+        for (unsigned int i = 0; i < pcSurface->ulNumVertices * pcSurface->ulNumBaseFrames; ++i) {
+            AI_SWAP2(pcVerts->normal);
+            AI_SWAP2(pcVerts->x);
+            AI_SWAP2(pcVerts->y);
+            AI_SWAP2(pcVerts->z);
         }
 
         // swap all texture coordinates
-        for (unsigned int i = 0; i < pcSurface->ulNumVertices;++i)
-        {
-            AI_SWAP4( pcUVs->v );
-            AI_SWAP4( pcUVs->v );
+        for (unsigned int i = 0; i < pcSurface->ulNumVertices; ++i) {
+            AI_SWAP4(pcUVs->u);
+            AI_SWAP4(pcUVs->v);
         }
 
 #endif
 
-        const MDC::CompressedVertex* pcCVerts = NULL;
-        int16_t* mdcCompVert = NULL;
+        const MDC::CompressedVertex *pcCVerts = nullptr;
+        int16_t *mdcCompVert = nullptr;
 
         // access compressed frames for large frame numbers, but never for the first
-        if( this->configFrameID && pcSurface->ulNumCompFrames > 0 )
-        {
-            mdcCompVert = (int16_t*) ((int8_t*)pcSurface+pcSurface->ulOffsetFrameCompFrames) + this->configFrameID;
+        if (this->configFrameID && pcSurface->ulNumCompFrames > 0) {
+            mdcCompVert = (int16_t *)((int8_t *)pcSurface + pcSurface->ulOffsetFrameCompFrames) + this->configFrameID;
             AI_SWAP2P(mdcCompVert);
-            if( *mdcCompVert >= 0 )
-            {
-                pcCVerts = (const MDC::CompressedVertex*)((int8_t*)pcSurface +
-                    pcSurface->ulOffsetCompVerts) + *mdcCompVert * pcSurface->ulNumVertices;
-            }
-            else mdcCompVert = NULL;
+            if (*mdcCompVert >= 0) {
+                pcCVerts = (const MDC::CompressedVertex *)((int8_t *)pcSurface +
+                                                           pcSurface->ulOffsetCompVerts) +
+                           *mdcCompVert * pcSurface->ulNumVertices;
+            } else
+                mdcCompVert = nullptr;
         }
 
         // copy all faces
-        for (unsigned int iFace = 0; iFace < pcSurface->ulNumTriangles;++iFace,
-            ++pcTriangle,++pcFaceCur)
-        {
-            const unsigned int iOutIndex = iFace*3;
+        for (unsigned int iFace = 0; iFace < pcSurface->ulNumTriangles; ++iFace,
+                          ++pcTriangle, ++pcFaceCur) {
+            const unsigned int iOutIndex = iFace * 3;
             pcFaceCur->mNumIndices = 3;
             pcFaceCur->mIndices = new unsigned int[3];
 
-            for (unsigned int iIndex = 0; iIndex < 3;++iIndex,
-                ++pcVertCur,++pcUVCur,++pcNorCur)
-            {
+            for (unsigned int iIndex = 0; iIndex < 3; ++iIndex,
+                              ++pcVertCur, ++pcUVCur, ++pcNorCur) {
                 uint32_t quak = pcTriangle->aiIndices[iIndex];
-                if (quak >= pcSurface->ulNumVertices)
-                {
+                if (quak >= pcSurface->ulNumVertices) {
                     ASSIMP_LOG_ERROR("MDC vertex index is out of range");
-                    quak = pcSurface->ulNumVertices-1;
+                    quak = pcSurface->ulNumVertices - 1;
                 }
 
                 // compressed vertices?
-                if (mdcCompVert)
-                {
-                    MDC::BuildVertex(*pcFrame,pcVerts[quak],pcCVerts[quak],
-                        *pcVertCur,*pcNorCur);
-                }
-                else
-                {
+                if (mdcCompVert) {
+                    MDC::BuildVertex(*pcFrame, pcVerts[quak], pcCVerts[quak],
+                            *pcVertCur, *pcNorCur);
+                } else {
                     // copy position
                     pcVertCur->x = pcVerts[quak].x * AI_MDC_BASE_SCALING;
                     pcVertCur->y = pcVerts[quak].y * AI_MDC_BASE_SCALING;
                     pcVertCur->z = pcVerts[quak].z * AI_MDC_BASE_SCALING;
 
                     // copy normals
-                    MD3::LatLngNormalToVec3( pcVerts[quak].normal, &pcNorCur->x );
+                    MD3::LatLngNormalToVec3(pcVerts[quak].normal, &pcNorCur->x);
 
                     // copy texture coordinates
                     pcUVCur->x = pcUVs[quak].u;
-                    pcUVCur->y = ai_real( 1.0 )-pcUVs[quak].v; // DX to OGL
+                    pcUVCur->y = ai_real(1.0) - pcUVs[quak].v; // DX to OGL
                 }
-                pcVertCur->x += pcFrame->localOrigin[0] ;
-                pcVertCur->y += pcFrame->localOrigin[1] ;
-                pcVertCur->z += pcFrame->localOrigin[2] ;
+                pcVertCur->x += pcFrame->localOrigin[0];
+                pcVertCur->y += pcFrame->localOrigin[1];
+                pcVertCur->z += pcFrame->localOrigin[2];
             }
 
             // swap the face order - DX to OGL
@@ -426,31 +388,27 @@ void MDCImporter::InternReadFile(
             pcFaceCur->mIndices[2] = iOutIndex + 0;
         }
 
-        pcSurface =  new ((int8_t*)pcSurface + pcSurface->ulOffsetEnd) MDC::Surface;
+        pcSurface = reinterpret_cast<BE_NCONST MDC::Surface *>((BE_NCONST int8_t *)pcSurface + pcSurface->ulOffsetEnd);
     }
 
     // create a flat node graph with a root node and one child for each surface
     if (!pScene->mNumMeshes)
-        throw DeadlyImportError( "Invalid MDC file: File contains no valid mesh");
-    else if (1 == pScene->mNumMeshes)
-    {
+        throw DeadlyImportError("Invalid MDC file: File contains no valid mesh");
+    else if (1 == pScene->mNumMeshes) {
         pScene->mRootNode = new aiNode();
-        if ( nullptr != pScene->mMeshes[0] ) {
+        if (nullptr != pScene->mMeshes[0]) {
             pScene->mRootNode->mName = pScene->mMeshes[0]->mName;
             pScene->mRootNode->mNumMeshes = 1;
             pScene->mRootNode->mMeshes = new unsigned int[1];
             pScene->mRootNode->mMeshes[0] = 0;
         }
-    }
-    else
-    {
+    } else {
         pScene->mRootNode = new aiNode();
         pScene->mRootNode->mNumChildren = pScene->mNumMeshes;
-        pScene->mRootNode->mChildren = new aiNode*[pScene->mNumMeshes];
+        pScene->mRootNode->mChildren = new aiNode *[pScene->mNumMeshes];
         pScene->mRootNode->mName.Set("<root>");
-        for (unsigned int i = 0; i < pScene->mNumMeshes;++i)
-        {
-            aiNode* pcNode = pScene->mRootNode->mChildren[i] = new aiNode();
+        for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
+            aiNode *pcNode = pScene->mRootNode->mChildren[i] = new aiNode();
             pcNode->mParent = pScene->mRootNode;
             pcNode->mName = pScene->mMeshes[i]->mName;
             pcNode->mNumMeshes = 1;
@@ -461,13 +419,12 @@ void MDCImporter::InternReadFile(
 
     // create materials
     pScene->mNumMaterials = (unsigned int)aszShaders.size();
-    pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials];
-    for (unsigned int i = 0; i < pScene->mNumMaterials;++i)
-    {
-        aiMaterial* pcMat = new aiMaterial();
+    pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials];
+    for (unsigned int i = 0; i < pScene->mNumMaterials; ++i) {
+        aiMaterial *pcMat = new aiMaterial();
         pScene->mMaterials[i] = pcMat;
 
-        const std::string& name = aszShaders[i];
+        const std::string &name = aszShaders[i];
 
         int iMode = (int)aiShadingMode_Gouraud;
         pcMat->AddProperty<int>(&iMode, 1, AI_MATKEY_SHADING_MODEL);
@@ -475,21 +432,29 @@ void MDCImporter::InternReadFile(
         // add a small ambient color value - RtCW seems to have one
         aiColor3D clr;
         clr.b = clr.g = clr.r = 0.05f;
-        pcMat->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_AMBIENT);
-
-        if (name.length())clr.b = clr.g = clr.r = 1.0f;
-        else clr.b = clr.g = clr.r = 0.6f;
-
-        pcMat->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_DIFFUSE);
-        pcMat->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_SPECULAR);
+        pcMat->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_AMBIENT);
 
         if (name.length())
-        {
+            clr.b = clr.g = clr.r = 1.0f;
+        else
+            clr.b = clr.g = clr.r = 0.6f;
+
+        pcMat->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_DIFFUSE);
+        pcMat->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_SPECULAR);
+
+        if (name.length()) {
             aiString path;
             path.Set(name);
-            pcMat->AddProperty(&path,AI_MATKEY_TEXTURE_DIFFUSE(0));
+            pcMat->AddProperty(&path, AI_MATKEY_TEXTURE_DIFFUSE(0));
         }
     }
+
+    // Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system
+    pScene->mRootNode->mTransformation = aiMatrix4x4(
+            1.f, 0.f, 0.f, 0.f,
+            0.f, 0.f, 1.f, 0.f,
+            0.f, -1.f, 0.f, 0.f,
+            0.f, 0.f, 0.f, 1.f);
 }
 
 #endif // !! ASSIMP_BUILD_NO_MDC_IMPORTER
diff --git a/Engine/lib/assimp/code/MDC/MDCLoader.h b/Engine/lib/assimp/code/AssetLib/MDC/MDCLoader.h
similarity index 86%
rename from Engine/lib/assimp/code/MDC/MDCLoader.h
rename to Engine/lib/assimp/code/AssetLib/MDC/MDCLoader.h
index a21b8a55a..6e67cd12f 100644
--- a/Engine/lib/assimp/code/MDC/MDCLoader.h
+++ b/Engine/lib/assimp/code/AssetLib/MDC/MDCLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -48,8 +48,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <assimp/types.h>
 
-#include <assimp/BaseImporter.h>
 #include "MDCFileData.h"
+#include <assimp/BaseImporter.h>
 #include <assimp/ByteSwapper.h>
 
 namespace Assimp {
@@ -59,45 +59,37 @@ using namespace MDC;
 // ---------------------------------------------------------------------------
 /** Importer class to load the RtCW MDC file format
 */
-class MDCImporter : public BaseImporter
-{
+class MDCImporter : public BaseImporter {
 public:
     MDCImporter();
-    ~MDCImporter();
-
-
-public:
+    ~MDCImporter() override;
 
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
     * See BaseImporter::CanRead() for details.  */
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
+            bool checkSig) const override;
 
     // -------------------------------------------------------------------
     /** Called prior to ReadFile().
     * The function is a request to the importer to update its configuration
     * basing on the Importer's configuration property list.
     */
-    void SetupProperties(const Importer* pImp);
+    void SetupProperties(const Importer *pImp) override;
 
 protected:
-
     // -------------------------------------------------------------------
     /** Return importer meta information.
      * See #BaseImporter::GetInfo for the details
      */
-    const aiImporterDesc* GetInfo () const;
+    const aiImporterDesc *GetInfo() const override;
 
     // -------------------------------------------------------------------
     /** Imports the given file into the given scene structure.
     * See BaseImporter::InternReadFile() for details
     */
-    void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
-
-protected:
-
+    void InternReadFile(const std::string &pFile, aiScene *pScene,
+            IOSystem *pIOHandler) override;
 
     // -------------------------------------------------------------------
     /** Validate the header of the file
@@ -107,19 +99,17 @@ protected:
     // -------------------------------------------------------------------
     /** Validate the header of a MDC surface
     */
-    void ValidateSurfaceHeader(BE_NCONST MDC::Surface* pcSurf);
+    void ValidateSurfaceHeader(BE_NCONST MDC::Surface *pcSurf);
 
 protected:
-
-
     /** Configuration option: frame to be loaded */
     unsigned int configFrameID;
 
     /** Header of the MDC file */
-    BE_NCONST MDC::Header* pcHeader;
+    BE_NCONST MDC::Header *pcHeader;
 
     /** Buffer to hold the loaded file */
-    unsigned char* mBuffer;
+    unsigned char *mBuffer;
 
     /** size of the file, in bytes */
     unsigned int fileSize;
diff --git a/Engine/lib/assimp/code/MDC/MDCNormalTable.h b/Engine/lib/assimp/code/AssetLib/MDC/MDCNormalTable.h
similarity index 99%
rename from Engine/lib/assimp/code/MDC/MDCNormalTable.h
rename to Engine/lib/assimp/code/AssetLib/MDC/MDCNormalTable.h
index f47e97f33..c96eba7bd 100644
--- a/Engine/lib/assimp/code/MDC/MDCNormalTable.h
+++ b/Engine/lib/assimp/code/AssetLib/MDC/MDCNormalTable.h
@@ -36,7 +36,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define MDC_NORMAL_TABLE_INCLUDED
 
 /* mdc decoding normal table */
-float mdcNormals[ 256 ][ 3 ] =
+const float mdcNormals[ 256 ][ 3 ] =
 {
     { 1.000000f, 0.000000f, 0.000000f },
     { 0.980785f, 0.195090f, 0.000000f },
diff --git a/Engine/lib/assimp/code/AssetLib/MDL/HalfLife/HL1FileData.h b/Engine/lib/assimp/code/AssetLib/MDL/HalfLife/HL1FileData.h
new file mode 100644
index 000000000..28b1b2822
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/MDL/HalfLife/HL1FileData.h
@@ -0,0 +1,600 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file  HL1FileData.h
+ *  @brief Definition of in-memory structures for the
+ *         Half-Life 1 MDL file format.
+ */
+
+#ifndef AI_HL1FILEDATA_INCLUDED
+#define AI_HL1FILEDATA_INCLUDED
+
+#include "HalfLifeMDLBaseHeader.h"
+
+#include <assimp/Compiler/pushpack1.h>
+#include <assimp/types.h>
+
+namespace Assimp {
+namespace MDL {
+namespace HalfLife {
+
+using vec3_t = float[3];
+
+/** \struct Header_HL1
+ *  \brief Data structure for the HL1 MDL file header.
+ */
+struct Header_HL1 : HalfLifeMDLBaseHeader {
+    //! The model name.
+    char name[64];
+
+    //! The total file size in bytes.
+    int32_t length;
+
+    //! Ideal eye position.
+    vec3_t eyeposition;
+
+    //! Ideal movement hull size.
+    vec3_t min;
+    vec3_t max;
+
+    //! Clipping bounding box.
+    vec3_t bbmin;
+    vec3_t bbmax;
+
+    //! Was "flags".
+    int32_t unused;
+
+    //! The number of bones.
+    int32_t numbones;
+
+    //! Offset to the first bone chunk.
+    int32_t boneindex;
+
+    //! The number of bone controllers.
+    int32_t numbonecontrollers;
+
+    //! Offset to the first bone controller chunk.
+    int32_t bonecontrollerindex;
+
+    //! The number of hitboxes.
+    int32_t numhitboxes;
+
+    //! Offset to the first hitbox chunk.
+    int32_t hitboxindex;
+
+    //! The number of sequences.
+    int32_t numseq;
+
+    //! Offset to the first sequence description chunk.
+    int32_t seqindex;
+
+    //! The number of sequence groups.
+    int32_t numseqgroups;
+
+    //! Offset to the first sequence group chunk.
+    int32_t seqgroupindex;
+
+    //! The number of textures.
+    int32_t numtextures;
+
+    //! Offset to the first texture chunk.
+    int32_t textureindex;
+
+    //! Offset to the first texture's image data.
+    int32_t texturedataindex;
+
+    //! The number of replaceable textures.
+    int32_t numskinref;
+
+    //! The number of skin families.
+    int32_t numskinfamilies;
+
+    //! Offset to the first replaceable texture.
+    int32_t skinindex;
+
+    //! The number of bodyparts.
+    int32_t numbodyparts;
+
+    //! Offset the the first bodypart.
+    int32_t bodypartindex;
+
+    //! The number of attachments.
+    int32_t numattachments;
+
+    //! Offset the the first attachment chunk.
+    int32_t attachmentindex;
+
+    //! Was "soundtable".
+    int32_t unused2;
+
+    //! Was "soundindex".
+    int32_t unused3;
+
+    //! Was "soundgroups".
+    int32_t unused4;
+
+    //! Was "soundgroupindex".
+    int32_t unused5;
+
+    //! The number of nodes in the sequence transition graph.
+    int32_t numtransitions;
+
+    //! Offset the the first sequence transition.
+    int32_t transitionindex;
+} PACK_STRUCT;
+
+/** \struct SequenceHeader_HL1
+ *  \brief Data structure for the file header of a demand loaded
+ *         HL1 MDL sequence group file.
+ */
+struct SequenceHeader_HL1 : HalfLifeMDLBaseHeader {
+    //! The sequence group file name.
+    char name[64];
+
+    //! The total file size in bytes.
+    int32_t length;
+} PACK_STRUCT;
+
+/** \struct Bone_HL1
+ *  \brief Data structure for a bone in HL1 MDL files.
+ */
+struct Bone_HL1 {
+    //! The bone name.
+    char name[32];
+
+    //! The parent bone index. (-1) If it has no parent.
+    int32_t parent;
+
+    //! Was "flags".
+    int32_t unused;
+
+    //! Available bone controller per motion type.
+    //! (-1) if no controller is available.
+    int32_t bonecontroller[6];
+
+    /*! Default position and rotation values where
+     * scale[0] = position.X
+     * scale[1] = position.Y
+     * scale[2] = position.Z
+     * scale[3] = rotation.X
+     * scale[4] = rotation.Y
+     * scale[5] = rotation.Z
+     */
+    float value[6];
+
+    /*! Compressed scale values where
+     * scale[0] = position.X scale
+     * scale[1] = position.Y scale
+     * scale[2] = position.Z scale
+     * scale[3] = rotation.X scale
+     * scale[4] = rotation.Y scale
+     * scale[5] = rotation.Z scale
+     */
+    float scale[6];
+} PACK_STRUCT;
+
+/** \struct BoneController_HL1
+ *  \brief Data structure for a bone controller in HL1 MDL files.
+ */
+struct BoneController_HL1 {
+    //! Bone affected by this controller.
+    int32_t bone;
+
+    //! The motion type.
+    int32_t type;
+
+    //! The minimum and maximum values.
+    float start;
+    float end;
+
+    // Was "rest".
+    int32_t unused;
+
+    // The bone controller channel.
+    int32_t index;
+} PACK_STRUCT;
+
+/** \struct Hitbox_HL1
+ *  \brief Data structure for a hitbox in HL1 MDL files.
+ */
+struct Hitbox_HL1 {
+    //! The bone this hitbox follows.
+    int32_t bone;
+
+    //! The hit group.
+    int32_t group;
+
+    //! The hitbox minimum and maximum extents.
+    vec3_t bbmin;
+    vec3_t bbmax;
+} PACK_STRUCT;
+
+/** \struct SequenceGroup_HL1
+ *  \brief Data structure for a sequence group in HL1 MDL files.
+ */
+struct SequenceGroup_HL1 {
+    //! A textual name for this sequence group.
+    char label[32];
+
+    //! The file name.
+    char name[64];
+
+    //! Was "cache".
+    int32_t unused;
+
+    //! Was "data".
+    int32_t unused2;
+} PACK_STRUCT;
+
+//! The type of blending for a sequence.
+enum SequenceBlendMode_HL1 {
+    NoBlend = 1,
+    TwoWayBlending = 2,
+    FourWayBlending = 4,
+};
+
+/** \struct SequenceDesc_HL1
+ *  \brief Data structure for a sequence description in HL1 MDL files.
+ */
+struct SequenceDesc_HL1 {
+    //! The sequence name.
+    char label[32];
+
+    //! Frames per second.
+    float fps;
+
+    //! looping/non-looping flags.
+    int32_t flags;
+
+    //! The sequence activity.
+    int32_t activity;
+
+    //! The sequence activity weight.
+    int32_t actweight;
+
+    //! The number of animation events.
+    int32_t numevents;
+
+    //! Offset the the first animation event chunk.
+    int32_t eventindex;
+
+    //! The number of frames in the sequence.
+    int32_t numframes;
+
+    //! Was "numpivots".
+    int32_t unused;
+
+    //! Was "pivotindex".
+    int32_t unused2;
+
+    //! Linear motion type.
+    int32_t motiontype;
+
+    //! Linear motion bone.
+    int32_t motionbone;
+
+    //! Linear motion.
+    vec3_t linearmovement;
+
+    //! Was "automoveposindex".
+    int32_t unused3;
+
+    //! Was "automoveangleindex".
+    int32_t unused4;
+
+    //! The sequence minimum and maximum extents.
+    vec3_t bbmin;
+    vec3_t bbmax;
+
+    //! The number of blend animations.
+    int32_t numblends;
+
+    //! Offset to first the AnimValueOffset_HL1 chunk.
+    //! This offset is relative to the SequenceHeader_HL1 of the file
+    //! that contains the animation data.
+    int32_t animindex;
+
+    //! The motion type of each blend controller.
+    int32_t blendtype[2];
+
+    //! The starting value of each blend controller.
+    float blendstart[2];
+
+    //! The ending value of each blend controller.
+    float blendend[2];
+
+    //! Was "blendparent".
+    int32_t unused5;
+
+    //! The sequence group.
+    int32_t seqgroup;
+
+    //! The node at entry in the sequence transition graph.
+    int32_t entrynode;
+
+    //! The node at exit in the sequence transition graph.
+    int32_t exitnode;
+
+    //! Transition rules.
+    int32_t nodeflags;
+
+    //! Was "nextseq"
+    int32_t unused6;
+} PACK_STRUCT;
+
+/** \struct AnimEvent_HL1
+ *  \brief Data structure for an animation event in HL1 MDL files.
+ */
+struct AnimEvent_HL1 {
+    //! The frame at which this animation event occurs.
+    int32_t frame;
+
+    //! The script event type.
+    int32_t event;
+
+    //! was "type"
+    int32_t unused;
+
+    //! Options. Could be path to sound WAVE files.
+    char options[64];
+} PACK_STRUCT;
+
+/** \struct Attachment_HL1
+ *  \brief Data structure for an attachment in HL1 MDL files.
+ */
+struct Attachment_HL1 {
+    //! Was "name".
+    char unused[32];
+
+    //! Was "type".
+    int32_t unused2;
+
+    //! The bone this attachment follows.
+    int32_t bone;
+
+    //! The attachment origin.
+    vec3_t org;
+
+    //! Was "vectors"
+    vec3_t unused3[3];
+} PACK_STRUCT;
+
+/** \struct AnimValueOffset_HL1
+ *  \brief Data structure to hold offsets (one per motion type)
+ *         to the first animation frame value for a single bone
+ *         in HL1 MDL files.
+ */
+struct AnimValueOffset_HL1 {
+    unsigned short offset[6];
+} PACK_STRUCT;
+
+/** \struct AnimValue_HL1
+ *  \brief Data structure for an animation frame in HL1 MDL files.
+ */
+union AnimValue_HL1 {
+    struct {
+        uint8_t valid;
+        uint8_t total;
+    } num;
+    short value;
+} PACK_STRUCT;
+
+/** \struct Bodypart_HL1
+ *  \brief Data structure for a bodypart in HL1 MDL files.
+ */
+struct Bodypart_HL1 {
+    //! The bodypart name.
+    char name[64];
+
+    //! The number of available models for this bodypart.
+    int32_t nummodels;
+
+    //! Used to convert from a global model index
+    //! to a local bodypart model index.
+    int32_t base;
+
+    //! The offset to the first model chunk.
+    int32_t modelindex;
+} PACK_STRUCT;
+
+/** \struct Texture_HL1
+ *  \brief Data structure for a texture in HL1 MDL files.
+ */
+struct Texture_HL1 {
+    //! Texture file name.
+    char name[64];
+
+    //! Texture flags.
+    int32_t flags;
+
+    //! Texture width in pixels.
+    int32_t width;
+
+    //! Texture height in pixels.
+    int32_t height;
+
+    //! Offset to the image data.
+    //! This offset is relative to the texture file header.
+    int32_t index;
+} PACK_STRUCT;
+
+/** \struct Model_HL1
+ *  \brief Data structure for a model in HL1 MDL files.
+ */
+struct Model_HL1 {
+    //! Model name.
+    char name[64];
+
+    //! Was "type".
+    int32_t unused;
+
+    //! Was "boundingradius".
+    float unused2;
+
+    //! The number of meshes in the model.
+    int32_t nummesh;
+
+    //! Offset to the first mesh chunk.
+    int32_t meshindex;
+
+    //! The number of unique vertices.
+    int32_t numverts;
+
+    //! Offset to the vertex bone array.
+    int32_t vertinfoindex;
+
+    //! Offset to the vertex array.
+    int32_t vertindex;
+
+    //! The number of unique normals.
+    int32_t numnorms;
+
+    //! Offset to the normal bone array.
+    int32_t norminfoindex;
+
+    //! Offset to the normal array.
+    int32_t normindex;
+
+    //! Was "numgroups".
+    int32_t unused3;
+
+    //! Was "groupindex".
+    int32_t unused4;
+} PACK_STRUCT;
+
+/** \struct Mesh_HL1
+ *  \brief Data structure for a mesh in HL1 MDL files.
+ */
+struct Mesh_HL1 {
+    //! Can be interpreted as the number of triangles in the mesh.
+    int32_t numtris;
+
+    //! Offset to the start of the tris sequence.
+    int32_t triindex;
+
+    //! The skin index.
+    int32_t skinref;
+
+    //! The number of normals in the mesh.
+    int32_t numnorms;
+
+    //! Was "normindex".
+    int32_t unused;
+} PACK_STRUCT;
+
+/** \struct Trivert
+ *  \brief Data structure for a trivert in HL1 MDL files.
+ */
+struct Trivert {
+    //! Index into Model_HL1 vertex array.
+    short vertindex;
+
+    //! Index into Model_HL1 normal array.
+    short normindex;
+
+    //! Texture coordinates in absolute space (unnormalized).
+    short s, t;
+} PACK_STRUCT;
+
+#include <assimp/Compiler/poppack1.h>
+
+#if (!defined AI_MDL_HL1_VERSION)
+#define AI_MDL_HL1_VERSION 10
+#endif
+#if (!defined AI_MDL_HL1_MAX_TRIANGLES)
+#define AI_MDL_HL1_MAX_TRIANGLES 20000
+#endif
+#if (!defined AI_MDL_HL1_MAX_VERTICES)
+#define AI_MDL_HL1_MAX_VERTICES 2048
+#endif
+#if (!defined AI_MDL_HL1_MAX_SEQUENCES)
+#define AI_MDL_HL1_MAX_SEQUENCES 2048
+#endif
+#if (!defined AI_MDL_HL1_MAX_SEQUENCE_GROUPS)
+#define AI_MDL_HL1_MAX_SEQUENCE_GROUPS 32
+#endif
+#if (!defined AI_MDL_HL1_MAX_TEXTURES)
+#define AI_MDL_HL1_MAX_TEXTURES 100
+#endif
+#if (!defined AI_MDL_HL1_MAX_SKIN_FAMILIES)
+#define AI_MDL_HL1_MAX_SKIN_FAMILIES 100
+#endif
+#if (!defined AI_MDL_HL1_MAX_BONES)
+#define AI_MDL_HL1_MAX_BONES 128
+#endif
+#if (!defined AI_MDL_HL1_MAX_BODYPARTS)
+#define AI_MDL_HL1_MAX_BODYPARTS 32
+#endif
+#if (!defined AI_MDL_HL1_MAX_MODELS)
+#define AI_MDL_HL1_MAX_MODELS 32
+#endif
+#if (!defined AI_MDL_HL1_MAX_MESHES)
+#define AI_MDL_HL1_MAX_MESHES 256
+#endif
+#if (!defined AI_MDL_HL1_MAX_EVENTS)
+#define AI_MDL_HL1_MAX_EVENTS 1024
+#endif
+#if (!defined AI_MDL_HL1_MAX_BONE_CONTROLLERS)
+#define AI_MDL_HL1_MAX_BONE_CONTROLLERS 8
+#endif
+#if (!defined AI_MDL_HL1_MAX_ATTACHMENTS)
+#define AI_MDL_HL1_MAX_ATTACHMENTS 512
+#endif
+
+// lighting options
+#if (!defined AI_MDL_HL1_STUDIO_NF_FLATSHADE)
+#define AI_MDL_HL1_STUDIO_NF_FLATSHADE 0x0001
+#endif
+#if (!defined AI_MDL_HL1_STUDIO_NF_CHROME)
+#define AI_MDL_HL1_STUDIO_NF_CHROME 0x0002
+#endif
+#if (!defined AI_MDL_HL1_STUDIO_NF_ADDITIVE)
+#define AI_MDL_HL1_STUDIO_NF_ADDITIVE 0x0020
+#endif
+#if (!defined AI_MDL_HL1_STUDIO_NF_MASKED)
+#define AI_MDL_HL1_STUDIO_NF_MASKED 0x0040
+#endif
+
+} // namespace HalfLife
+} // namespace MDL
+} // namespace Assimp
+
+#endif // AI_HL1FILEDATA_INCLUDED
diff --git a/Engine/lib/assimp/code/AssetLib/MDL/HalfLife/HL1ImportDefinitions.h b/Engine/lib/assimp/code/AssetLib/MDL/HalfLife/HL1ImportDefinitions.h
new file mode 100644
index 000000000..d412aeede
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/MDL/HalfLife/HL1ImportDefinitions.h
@@ -0,0 +1,64 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file HL1ImportDefinitions.h
+ *  @brief HL1 MDL loader specific definitions.
+ */
+
+#ifndef AI_MDL_HL1_IMPORT_DEFINITIONS_INCLUDED
+#define AI_MDL_HL1_IMPORT_DEFINITIONS_INCLUDED
+
+#define AI_MDL_HL1_NODE_ROOT "<MDL_root>"
+#define AI_MDL_HL1_NODE_BODYPARTS "<MDL_bodyparts>"
+#define AI_MDL_HL1_NODE_BONES "<MDL_bones>"
+#define AI_MDL_HL1_NODE_BONE_CONTROLLERS "<MDL_bone_controllers>"
+#define AI_MDL_HL1_NODE_SEQUENCE_INFOS "<MDL_sequence_infos>"
+#define AI_MDL_HL1_NODE_SEQUENCE_GROUPS "<MDL_sequence_groups>"
+#define AI_MDL_HL1_NODE_SEQUENCE_TRANSITION_GRAPH "<MDL_sequence_transition_graph>"
+#define AI_MDL_HL1_NODE_ATTACHMENTS "<MDL_attachments>"
+#define AI_MDL_HL1_NODE_HITBOXES "<MDL_hitboxes>"
+#define AI_MDL_HL1_NODE_GLOBAL_INFO "<MDL_global_info>"
+#define AI_MDL_HL1_NODE_ANIMATION_EVENTS "AnimationEvents"
+#define AI_MDL_HL1_NODE_BLEND_CONTROLLERS "BlendControllers"
+
+#define AI_MDL_HL1_MATKEY_CHROME(type, N) "$mat.HL1.chrome", type, N
+
+#endif // AI_MDL_HL1_IMPORT_DEFINITIONS_INCLUDED
diff --git a/Engine/lib/assimp/code/AssetLib/MDL/HalfLife/HL1ImportSettings.h b/Engine/lib/assimp/code/AssetLib/MDL/HalfLife/HL1ImportSettings.h
new file mode 100644
index 000000000..340ba2da5
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/MDL/HalfLife/HL1ImportSettings.h
@@ -0,0 +1,85 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file HL1ImportSettings.h
+ *  @brief Half-Life 1 MDL loader configuration settings.
+ */
+
+#ifndef AI_HL1IMPORTSETTINGS_INCLUDED
+#define AI_HL1IMPORTSETTINGS_INCLUDED
+
+#include <string>
+
+namespace Assimp {
+namespace MDL {
+namespace HalfLife {
+
+struct HL1ImportSettings {
+    HL1ImportSettings() :
+        read_animations(false),
+        read_animation_events(false),
+        read_blend_controllers(false),
+        read_sequence_groups_info(false),
+        read_sequence_transitions(false),
+        read_attachments(false),
+        read_bone_controllers(false),
+        read_hitboxes(false),
+        read_textures(false),
+        read_misc_global_info(false) {
+    }
+
+    bool read_animations;
+    bool read_animation_events;
+    bool read_blend_controllers;
+    bool read_sequence_groups_info;
+    bool read_sequence_transitions;
+    bool read_attachments;
+    bool read_bone_controllers;
+    bool read_hitboxes;
+    bool read_textures;
+    bool read_misc_global_info;
+};
+
+} // namespace HalfLife
+} // namespace MDL
+} // namespace Assimp
+
+#endif // AI_HL1IMPORTSETTINGS_INCLUDED
diff --git a/Engine/lib/assimp/code/AssetLib/MDL/HalfLife/HL1MDLLoader.cpp b/Engine/lib/assimp/code/AssetLib/MDL/HalfLife/HL1MDLLoader.cpp
new file mode 100644
index 000000000..93d37536c
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/MDL/HalfLife/HL1MDLLoader.cpp
@@ -0,0 +1,1353 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file HL1MDLLoader.cpp
+ *  @brief Implementation for the Half-Life 1 MDL loader.
+ */
+
+#include "HL1MDLLoader.h"
+#include "HL1ImportDefinitions.h"
+#include "HL1MeshTrivert.h"
+#include "UniqueNameGenerator.h"
+
+#include <assimp/BaseImporter.h>
+#include <assimp/StringUtils.h>
+#include <assimp/ai_assert.h>
+#include <assimp/qnan.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/Importer.hpp>
+
+#include <iomanip>
+#include <sstream>
+#include <map>
+
+#ifdef MDL_HALFLIFE_LOG_WARN_HEADER
+#undef MDL_HALFLIFE_LOG_WARN_HEADER
+#endif
+#define MDL_HALFLIFE_LOG_HEADER "[Half-Life 1 MDL] "
+#include "LogFunctions.h"
+
+namespace Assimp {
+namespace MDL {
+namespace HalfLife {
+
+#ifdef _MSC_VER
+#    pragma warning(disable : 4706)
+#endif // _MSC_VER
+
+// ------------------------------------------------------------------------------------------------
+HL1MDLLoader::HL1MDLLoader(
+    aiScene *scene,
+    IOSystem *io,
+    const unsigned char *buffer,
+    const std::string &file_path,
+    const HL1ImportSettings &import_settings) :
+    scene_(scene),
+    io_(io),
+    buffer_(buffer),
+    file_path_(file_path),
+    import_settings_(import_settings),
+    header_(nullptr),
+    texture_header_(nullptr),
+    anim_headers_(nullptr),
+    texture_buffer_(nullptr),
+    anim_buffers_(nullptr),
+    num_sequence_groups_(0),
+    rootnode_children_(),
+    unique_name_generator_(),
+    unique_sequence_names_(),
+    unique_sequence_groups_names_(),
+    temp_bones_(),
+    num_blend_controllers_(0),
+    total_models_(0) {
+    load_file();
+}
+
+// ------------------------------------------------------------------------------------------------
+HL1MDLLoader::~HL1MDLLoader() {
+    release_resources();
+}
+
+// ------------------------------------------------------------------------------------------------
+void HL1MDLLoader::release_resources() {
+    if (buffer_ != texture_buffer_) {
+        delete[] texture_buffer_;
+        texture_buffer_ = nullptr;
+    }
+
+    if (num_sequence_groups_ && anim_buffers_) {
+        for (int i = 1; i < num_sequence_groups_; ++i) {
+            if (anim_buffers_[i]) {
+                delete[] anim_buffers_[i];
+                anim_buffers_[i] = nullptr;
+            }
+        }
+
+        delete[] anim_buffers_;
+        anim_buffers_ = nullptr;
+    }
+
+    if (anim_headers_) {
+        delete[] anim_headers_;
+        anim_headers_ = nullptr;
+    }
+
+    // Root has some children nodes. so let's proceed them
+    if (!rootnode_children_.empty()) {
+        // Here, it means that the nodes were not added to the
+        // scene root node. We still have to delete them.
+        for (auto it = rootnode_children_.begin(); it != rootnode_children_.end(); ++it) {
+            if (*it) {
+                delete *it;
+            }
+        }
+        // Ensure this happens only once.
+        rootnode_children_.clear();
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void HL1MDLLoader::load_file() {
+    try {
+        header_ = (const Header_HL1 *)buffer_;
+        validate_header(header_, false);
+
+        // Create the root scene node.
+        scene_->mRootNode = new aiNode(AI_MDL_HL1_NODE_ROOT);
+
+        load_texture_file();
+
+        if (import_settings_.read_animations) {
+            load_sequence_groups_files();
+        }
+
+        read_textures();
+        read_skins();
+
+        read_bones();
+        read_meshes();
+
+        if (import_settings_.read_animations) {
+            read_sequence_groups_info();
+            read_animations();
+            read_sequence_infos();
+            if (import_settings_.read_sequence_transitions)
+                read_sequence_transitions();
+        }
+
+        if (import_settings_.read_attachments) {
+            read_attachments();
+        }
+
+        if (import_settings_.read_hitboxes) {
+            read_hitboxes();
+        }
+
+        if (import_settings_.read_bone_controllers) {
+            read_bone_controllers();
+        }
+
+        read_global_info();
+
+        if (!header_->numbodyparts) {
+            // This could be an MDL external texture file. In this case,
+            // add this flag to allow the scene to be loaded even if it
+            // has no meshes.
+            scene_->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
+        }
+
+        // Append children to root node.
+        if (rootnode_children_.size()) {
+            scene_->mRootNode->addChildren(
+                    static_cast<unsigned int>(rootnode_children_.size()),
+                    rootnode_children_.data());
+
+            // Clear the list of nodes so they will not be destroyed
+            // when resources are released.
+            rootnode_children_.clear();
+        }
+
+        release_resources();
+
+    } catch (...) {
+        release_resources();
+        throw;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void HL1MDLLoader::validate_header(const Header_HL1 *header, bool is_texture_header) {
+    if (is_texture_header) {
+        // Every single Half-Life model is assumed to have at least one texture.
+        if (!header->numtextures) {
+            throw DeadlyImportError(MDL_HALFLIFE_LOG_HEADER "There are no textures in the file");
+        }
+
+        if (header->numtextures > AI_MDL_HL1_MAX_TEXTURES) {
+            log_warning_limit_exceeded<AI_MDL_HL1_MAX_TEXTURES>(header->numtextures, "textures");
+        }
+
+        if (header->numskinfamilies > AI_MDL_HL1_MAX_SKIN_FAMILIES) {
+            log_warning_limit_exceeded<AI_MDL_HL1_MAX_SKIN_FAMILIES>(header->numskinfamilies, "skin families");
+        }
+
+    } else {
+
+        if (header->numbodyparts > AI_MDL_HL1_MAX_BODYPARTS) {
+            log_warning_limit_exceeded<AI_MDL_HL1_MAX_BODYPARTS>(header->numbodyparts, "bodyparts");
+        }
+
+        if (header->numbones > AI_MDL_HL1_MAX_BONES) {
+            log_warning_limit_exceeded<AI_MDL_HL1_MAX_BONES>(header->numbones, "bones");
+        }
+
+        if (header->numbonecontrollers > AI_MDL_HL1_MAX_BONE_CONTROLLERS) {
+            log_warning_limit_exceeded<AI_MDL_HL1_MAX_BONE_CONTROLLERS>(header->numbonecontrollers, "bone controllers");
+        }
+
+        if (header->numseq > AI_MDL_HL1_MAX_SEQUENCES) {
+            log_warning_limit_exceeded<AI_MDL_HL1_MAX_SEQUENCES>(header->numseq, "sequences");
+        }
+
+        if (header->numseqgroups > AI_MDL_HL1_MAX_SEQUENCE_GROUPS) {
+            log_warning_limit_exceeded<AI_MDL_HL1_MAX_SEQUENCE_GROUPS>(header->numseqgroups, "sequence groups");
+        }
+
+        if (header->numattachments > AI_MDL_HL1_MAX_ATTACHMENTS) {
+            log_warning_limit_exceeded<AI_MDL_HL1_MAX_ATTACHMENTS>(header->numattachments, "attachments");
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+/*
+    Load textures.
+
+    There are two ways for textures to be stored in a Half-Life model:
+
+    1. Directly in the MDL file (filePath) or
+    2. In an external MDL file.
+
+    Due to the way StudioMDL works (tool used to compile SMDs into MDLs),
+    it is assumed that an external texture file follows the naming
+    convention: <YourModelName>T.mdl. Note the extra (T) at the end of the
+    model name.
+
+    .e.g For a given model named MyModel.mdl
+
+    The external texture file name would be MyModelT.mdl
+*/
+void HL1MDLLoader::load_texture_file() {
+    if (header_->numtextures == 0) {
+        // Load an external MDL texture file.
+        std::string texture_file_path =
+                DefaultIOSystem::absolutePath(file_path_) + io_->getOsSeparator() +
+                DefaultIOSystem::completeBaseName(file_path_) + "T." +
+                BaseImporter::GetExtension(file_path_);
+
+        load_file_into_buffer<Header_HL1>(texture_file_path, texture_buffer_);
+    } else {
+        // Model has no external texture file. This means the texture is stored inside the main MDL file.
+        texture_buffer_ = const_cast<unsigned char *>(buffer_);
+    }
+
+    texture_header_ = (const Header_HL1 *)texture_buffer_;
+
+    // Validate texture header.
+    validate_header(texture_header_, true);
+}
+
+// ------------------------------------------------------------------------------------------------
+/*
+    Load sequence group files if any.
+
+    Due to the way StudioMDL works (tool used to compile SMDs into MDLs),
+    it is assumed that a sequence group file follows the naming
+    convention: <YourModelName>0X.mdl. Note the extra (0X) at the end of
+    the model name, where (X) is the sequence group.
+
+    .e.g For a given model named MyModel.mdl
+
+    Sequence group 1 => MyModel01.mdl
+    Sequence group 2 => MyModel02.mdl
+    Sequence group X => MyModel0X.mdl
+
+*/
+void HL1MDLLoader::load_sequence_groups_files() {
+    if (header_->numseqgroups <= 1) {
+        return;
+    }
+
+    num_sequence_groups_ = header_->numseqgroups;
+
+    anim_buffers_ = new unsigned char *[num_sequence_groups_];
+    anim_headers_ = new SequenceHeader_HL1 *[num_sequence_groups_];
+    for (int i = 0; i < num_sequence_groups_; ++i) {
+        anim_buffers_[i] = nullptr;
+        anim_headers_[i] = nullptr;
+    }
+
+    std::string file_path_without_extension =
+            DefaultIOSystem::absolutePath(file_path_) +
+            io_->getOsSeparator() +
+            DefaultIOSystem::completeBaseName(file_path_);
+
+    for (int i = 1; i < num_sequence_groups_; ++i) {
+        std::stringstream ss;
+        ss << file_path_without_extension;
+        ss << std::setw(2) << std::setfill('0') << i;
+        ss << '.' << BaseImporter::GetExtension(file_path_);
+
+        std::string sequence_file_path = ss.str();
+
+        load_file_into_buffer<SequenceHeader_HL1>(sequence_file_path, anim_buffers_[i]);
+
+        anim_headers_[i] = (SequenceHeader_HL1 *)anim_buffers_[i];
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Read an MDL texture.
+void HL1MDLLoader::read_texture(const Texture_HL1 *ptexture,
+        uint8_t *data, uint8_t *pal, aiTexture *pResult,
+        aiColor3D &last_palette_color) {
+    pResult->mFilename = ptexture->name;
+    pResult->mWidth = static_cast<unsigned int>(ptexture->width);
+    pResult->mHeight = static_cast<unsigned int>(ptexture->height);
+    pResult->achFormatHint[0] = 'r';
+    pResult->achFormatHint[1] = 'g';
+    pResult->achFormatHint[2] = 'b';
+    pResult->achFormatHint[3] = 'a';
+    pResult->achFormatHint[4] = '8';
+    pResult->achFormatHint[5] = '8';
+    pResult->achFormatHint[6] = '8';
+    pResult->achFormatHint[7] = '8';
+    pResult->achFormatHint[8] = '\0';
+
+    const size_t num_pixels = pResult->mWidth * pResult->mHeight;
+    aiTexel *out = pResult->pcData = new aiTexel[num_pixels];
+
+    // Convert indexed 8 bit to 32 bit RGBA.
+    for (size_t i = 0; i < num_pixels; ++i, ++out) {
+        out->r = pal[data[i] * 3];
+        out->g = pal[data[i] * 3 + 1];
+        out->b = pal[data[i] * 3 + 2];
+        out->a = 255;
+    }
+
+    // Get the last palette color.
+    last_palette_color.r = pal[255 * 3];
+    last_palette_color.g = pal[255 * 3 + 1];
+    last_palette_color.b = pal[255 * 3 + 2];
+}
+
+// ------------------------------------------------------------------------------------------------
+void HL1MDLLoader::read_textures() {
+    const Texture_HL1 *ptexture = (const Texture_HL1 *)((uint8_t *)texture_header_ + texture_header_->textureindex);
+    unsigned char *pin = texture_buffer_;
+
+    scene_->mNumTextures = scene_->mNumMaterials = texture_header_->numtextures;
+    scene_->mTextures = new aiTexture *[scene_->mNumTextures];
+    scene_->mMaterials = new aiMaterial *[scene_->mNumMaterials];
+
+    for (int i = 0; i < texture_header_->numtextures; ++i) {
+        scene_->mTextures[i] = new aiTexture();
+
+        aiColor3D last_palette_color;
+        read_texture(&ptexture[i],
+                pin + ptexture[i].index,
+                pin + ptexture[i].width * ptexture[i].height + ptexture[i].index,
+                scene_->mTextures[i],
+                last_palette_color);
+
+        aiMaterial *scene_material = scene_->mMaterials[i] = new aiMaterial();
+
+        const aiTextureType texture_type = aiTextureType_DIFFUSE;
+        aiString texture_name(ptexture[i].name);
+        scene_material->AddProperty(&texture_name, AI_MATKEY_TEXTURE(texture_type, 0));
+
+        // Is this a chrome texture?
+        int chrome = ptexture[i].flags & AI_MDL_HL1_STUDIO_NF_CHROME ? 1 : 0;
+        scene_material->AddProperty(&chrome, 1, AI_MDL_HL1_MATKEY_CHROME(texture_type, 0));
+
+        if (ptexture[i].flags & AI_MDL_HL1_STUDIO_NF_FLATSHADE) {
+            // Flat shading.
+            const aiShadingMode shading_mode = aiShadingMode_Flat;
+            scene_material->AddProperty(&shading_mode, 1, AI_MATKEY_SHADING_MODEL);
+        }
+
+        if (ptexture[i].flags & AI_MDL_HL1_STUDIO_NF_ADDITIVE) {
+            // Additive texture.
+            const aiBlendMode blend_mode = aiBlendMode_Additive;
+            scene_material->AddProperty(&blend_mode, 1, AI_MATKEY_BLEND_FUNC);
+        } else if (ptexture[i].flags & AI_MDL_HL1_STUDIO_NF_MASKED) {
+            // Texture with 1 bit alpha test.
+            const aiTextureFlags use_alpha = aiTextureFlags_UseAlpha;
+            scene_material->AddProperty(&use_alpha, 1, AI_MATKEY_TEXFLAGS(texture_type, 0));
+            scene_material->AddProperty(&last_palette_color, 1, AI_MATKEY_COLOR_TRANSPARENT);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void HL1MDLLoader::read_skins() {
+    // Read skins, if any.
+    if (texture_header_->numskinfamilies <= 1) {
+        return;
+    }
+
+    // Pointer to base texture index.
+    short *default_skin_ptr = (short *)((uint8_t *)texture_header_ + texture_header_->skinindex);
+
+    // Start at first replacement skin.
+    short *replacement_skin_ptr = default_skin_ptr + texture_header_->numskinref;
+
+    for (int i = 1; i < texture_header_->numskinfamilies; ++i, replacement_skin_ptr += texture_header_->numskinref) {
+        for (int j = 0; j < texture_header_->numskinref; ++j) {
+            if (default_skin_ptr[j] != replacement_skin_ptr[j]) {
+                // Save replacement textures.
+                aiString skinMaterialId(scene_->mTextures[replacement_skin_ptr[j]]->mFilename);
+                scene_->mMaterials[default_skin_ptr[j]]->AddProperty(&skinMaterialId, AI_MATKEY_TEXTURE_DIFFUSE(i));
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void HL1MDLLoader::read_bones() {
+    if (!header_->numbones) {
+        return;
+    }
+
+    const Bone_HL1 *pbone = (const Bone_HL1 *)((uint8_t *)header_ + header_->boneindex);
+
+    std::vector<std::string> unique_bones_names(header_->numbones);
+    for (int i = 0; i < header_->numbones; ++i) {
+        unique_bones_names[i] = pbone[i].name;
+    }
+
+    // Ensure bones have unique names.
+    unique_name_generator_.set_template_name("Bone");
+    unique_name_generator_.make_unique(unique_bones_names);
+
+    temp_bones_.resize(header_->numbones);
+
+    aiNode *bones_node = new aiNode(AI_MDL_HL1_NODE_BONES);
+    rootnode_children_.push_back(bones_node);
+    bones_node->mNumChildren = static_cast<unsigned int>(header_->numbones);
+    bones_node->mChildren = new aiNode *[bones_node->mNumChildren];
+
+    // Create bone matrices in local space.
+    for (int i = 0; i < header_->numbones; ++i) {
+        aiNode *bone_node = temp_bones_[i].node = bones_node->mChildren[i] = new aiNode(unique_bones_names[i]);
+
+        aiVector3D angles(pbone[i].value[3], pbone[i].value[4], pbone[i].value[5]);
+        temp_bones_[i].absolute_transform = bone_node->mTransformation =
+                aiMatrix4x4(aiVector3D(1), aiQuaternion(angles.y, angles.z, angles.x),
+                        aiVector3D(pbone[i].value[0], pbone[i].value[1], pbone[i].value[2]));
+
+        if (pbone[i].parent == -1) {
+            bone_node->mParent = scene_->mRootNode;
+        } else {
+            bone_node->mParent = bones_node->mChildren[pbone[i].parent];
+
+            temp_bones_[i].absolute_transform =
+                    temp_bones_[pbone[i].parent].absolute_transform * bone_node->mTransformation;
+        }
+
+        temp_bones_[i].offset_matrix = temp_bones_[i].absolute_transform;
+        temp_bones_[i].offset_matrix.Inverse();
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+/*
+    Read meshes.
+
+    Half-Life MDLs are structured such that each MDL
+    contains one or more 'bodypart(s)', which contain one
+    or more 'model(s)', which contains one or more mesh(es).
+
+    * Bodyparts are used to group models that may be replaced
+    in the game .e.g a character could have a 'heads' group,
+    'torso' group, 'shoes' group, with each group containing
+    different 'model(s)'.
+
+    * Models, also called 'sub models', contain vertices as
+    well as a reference to each mesh used by the sub model.
+
+    * Meshes contain a list of tris, also known as 'triverts'.
+    Each tris contains the following information:
+
+        1. The index of the position to use for the vertex.
+        2. The index of the normal to use for the vertex.
+        3. The S coordinate to use for the vertex UV.
+        4. The T coordinate ^
+
+    These tris represent the way to represent the triangles
+    for each mesh. Depending on how the tool compiled the MDL,
+    those triangles were saved as strips and or fans.
+
+    NOTE: Each tris is NOT unique. This means that you
+    might encounter the same vertex index but with a different
+    normal index, S coordinate, T coordinate.
+
+    In addition, each mesh contains the texture's index.
+
+    ------------------------------------------------------
+    With the details above, there are several things to
+    take into consideration.
+
+    * The Half-Life models store the vertices by sub model
+    rather than by mesh. Due to Assimp's structure, it
+    is necessary to remap each model vertex to be used
+    per mesh. Unfortunately, this has the consequence
+    to duplicate vertices.
+
+    * Because the mesh triangles are comprised of strips and
+    fans, it is necessary to convert each primitive to
+    triangles, respectively (3 indices per face).
+*/
+void HL1MDLLoader::read_meshes() {
+    if (!header_->numbodyparts) {
+        return;
+    }
+
+    int total_verts = 0;
+    int total_triangles = 0;
+    total_models_ = 0;
+
+    const Bodypart_HL1 *pbodypart = (const Bodypart_HL1 *)((uint8_t *)header_ + header_->bodypartindex);
+    const Model_HL1 *pmodel = nullptr;
+    const Mesh_HL1 *pmesh = nullptr;
+
+    const Texture_HL1 *ptexture = (const Texture_HL1 *)((uint8_t *)texture_header_ + texture_header_->textureindex);
+    short *pskinref = (short *)((uint8_t *)texture_header_ + texture_header_->skinindex);
+
+    scene_->mNumMeshes = 0;
+
+    std::vector<std::string> unique_bodyparts_names;
+    unique_bodyparts_names.resize(header_->numbodyparts);
+
+    // Count the number of meshes.
+
+    for (int i = 0; i < header_->numbodyparts; ++i, ++pbodypart) {
+        unique_bodyparts_names[i] = pbodypart->name;
+
+        pmodel = (Model_HL1 *)((uint8_t *)header_ + pbodypart->modelindex);
+        for (int j = 0; j < pbodypart->nummodels; ++j, ++pmodel) {
+            scene_->mNumMeshes += pmodel->nummesh;
+            total_verts += pmodel->numverts;
+        }
+
+        total_models_ += pbodypart->nummodels;
+    }
+
+    // Display limit infos.
+    if (total_verts > AI_MDL_HL1_MAX_VERTICES) {
+        log_warning_limit_exceeded<AI_MDL_HL1_MAX_VERTICES>(total_verts, "vertices");
+    }
+
+    if (scene_->mNumMeshes > AI_MDL_HL1_MAX_MESHES) {
+        log_warning_limit_exceeded<AI_MDL_HL1_MAX_MESHES>(scene_->mNumMeshes, "meshes");
+    }
+
+    if (total_models_ > AI_MDL_HL1_MAX_MODELS) {
+        log_warning_limit_exceeded<AI_MDL_HL1_MAX_MODELS>(total_models_, "models");
+    }
+
+    // Ensure bodyparts have unique names.
+    unique_name_generator_.set_template_name("Bodypart");
+    unique_name_generator_.make_unique(unique_bodyparts_names);
+
+    // Now do the same for each model.
+    pbodypart = (const Bodypart_HL1 *)((uint8_t *)header_ + header_->bodypartindex);
+
+    // Prepare template name for bodypart models.
+    std::vector<std::string> unique_models_names;
+    unique_models_names.resize(total_models_);
+
+    unsigned int model_index = 0;
+
+    for (int i = 0; i < header_->numbodyparts; ++i, ++pbodypart) {
+        pmodel = (Model_HL1 *)((uint8_t *)header_ + pbodypart->modelindex);
+        for (int j = 0; j < pbodypart->nummodels; ++j, ++pmodel, ++model_index)
+            unique_models_names[model_index] = pmodel->name;
+    }
+
+    unique_name_generator_.set_template_name("Model");
+    unique_name_generator_.make_unique(unique_models_names);
+
+    unsigned int mesh_index = 0;
+
+    scene_->mMeshes = new aiMesh *[scene_->mNumMeshes];
+
+    pbodypart = (const Bodypart_HL1 *)((uint8_t *)header_ + header_->bodypartindex);
+
+    /* Create a node that will represent the mesh hierarchy.
+
+        <MDL_bodyparts>
+            |
+            +-- bodypart --+-- model -- [mesh index, mesh index, ...]
+            |              |
+            |              +-- model -- [mesh index, mesh index, ...]
+            |              |
+            |              ...
+            |
+            |-- bodypart -- ...
+            |
+            ...
+     */
+    aiNode *bodyparts_node = new aiNode(AI_MDL_HL1_NODE_BODYPARTS);
+    rootnode_children_.push_back(bodyparts_node);
+    bodyparts_node->mNumChildren = static_cast<unsigned int>(header_->numbodyparts);
+    bodyparts_node->mChildren = new aiNode *[bodyparts_node->mNumChildren];
+    aiNode **bodyparts_node_ptr = bodyparts_node->mChildren;
+
+    // The following variables are defined here so they don't have
+    // to be recreated every iteration.
+
+    // Model_HL1 vertices, in bind pose space.
+    std::vector<aiVector3D> bind_pose_vertices;
+
+    // Model_HL1 normals, in bind pose space.
+    std::vector<aiVector3D> bind_pose_normals;
+
+    // Used to contain temporary information for building a mesh.
+    std::vector<HL1MeshTrivert> triverts;
+
+    std::vector<short> tricmds;
+
+    // Which triverts to use for the mesh.
+    std::vector<short> mesh_triverts_indices;
+
+    std::vector<HL1MeshFace> mesh_faces;
+
+    /* triverts that have the same vertindex, but have different normindex,s,t values.
+       Similar triverts are mapped from vertindex to a list of similar triverts. */
+    std::map<short, std::set<short>> triverts_similars;
+
+    // triverts per bone.
+    std::map<int, std::set<short>> bone_triverts;
+
+    /** This function adds a trivert index to the list of triverts per bone.
+     * \param[in] bone The bone that affects the trivert at index \p trivert_index.
+     * \param[in] trivert_index The trivert index.
+     */
+    auto AddTrivertToBone = [&](int bone, short trivert_index) {
+        if (bone_triverts.count(bone) == 0)
+            bone_triverts.insert({ bone, std::set<short>{ trivert_index }});
+        else
+            bone_triverts[bone].insert(trivert_index);
+    };
+
+    /** This function creates and appends a new trivert to the list of triverts.
+     * \param[in] trivert The trivert to use as a prototype.
+     * \param[in] bone The bone that affects \p trivert.
+     */
+    auto AddSimilarTrivert = [&](const Trivert &trivert, const int bone) {
+        HL1MeshTrivert new_trivert(trivert);
+        new_trivert.localindex = static_cast<short>(mesh_triverts_indices.size());
+
+        short new_trivert_index = static_cast<short>(triverts.size());
+
+        if (triverts_similars.count(trivert.vertindex) == 0)
+            triverts_similars.insert({ trivert.vertindex, std::set<short>{ new_trivert_index }});
+        else
+            triverts_similars[trivert.vertindex].insert(new_trivert_index);
+
+        triverts.push_back(new_trivert);
+
+        mesh_triverts_indices.push_back(new_trivert_index);
+        tricmds.push_back(new_trivert.localindex);
+        AddTrivertToBone(bone, new_trivert.localindex);
+    };
+
+    model_index = 0;
+
+    for (int i = 0; i < header_->numbodyparts; ++i, ++pbodypart, ++bodyparts_node_ptr) {
+        pmodel = (const Model_HL1 *)((uint8_t *)header_ + pbodypart->modelindex);
+
+        // Create bodypart node for the mesh tree hierarchy.
+        aiNode *bodypart_node = (*bodyparts_node_ptr) = new aiNode(unique_bodyparts_names[i]);
+        bodypart_node->mParent = bodyparts_node;
+        bodypart_node->mMetaData = aiMetadata::Alloc(1);
+        bodypart_node->mMetaData->Set(0, "Base", pbodypart->base);
+
+        bodypart_node->mNumChildren = static_cast<unsigned int>(pbodypart->nummodels);
+        bodypart_node->mChildren = new aiNode *[bodypart_node->mNumChildren];
+        aiNode **bodypart_models_ptr = bodypart_node->mChildren;
+
+        for (int j = 0; j < pbodypart->nummodels;
+                ++j, ++pmodel, ++bodypart_models_ptr, ++model_index) {
+
+            pmesh = (const Mesh_HL1 *)((uint8_t *)header_ + pmodel->meshindex);
+
+            uint8_t *pvertbone = ((uint8_t *)header_ + pmodel->vertinfoindex);
+            uint8_t *pnormbone = ((uint8_t *)header_ + pmodel->norminfoindex);
+            vec3_t *pstudioverts = (vec3_t *)((uint8_t *)header_ + pmodel->vertindex);
+            vec3_t *pstudionorms = (vec3_t *)((uint8_t *)header_ + pmodel->normindex);
+
+            // Each vertex and normal is in local space, so transform
+            // each of them to bring them in bind pose.
+            bind_pose_vertices.resize(pmodel->numverts);
+            bind_pose_normals.resize(pmodel->numnorms);
+            for (size_t k = 0; k < bind_pose_vertices.size(); ++k) {
+                const vec3_t &vert = pstudioverts[k];
+                bind_pose_vertices[k] = temp_bones_[pvertbone[k]].absolute_transform * aiVector3D(vert[0], vert[1], vert[2]);
+            }
+            for (size_t k = 0; k < bind_pose_normals.size(); ++k) {
+                const vec3_t &norm = pstudionorms[k];
+                // Compute the normal matrix to transform the normal into bind pose,
+                // without affecting its length.
+                const aiMatrix4x4 normal_matrix = aiMatrix4x4(temp_bones_[pnormbone[k]].absolute_transform).Inverse().Transpose();
+                bind_pose_normals[k] = normal_matrix * aiVector3D(norm[0], norm[1], norm[2]);
+            }
+
+            // Create model node for the mesh tree hierarchy.
+            aiNode *model_node = (*bodypart_models_ptr) = new aiNode(unique_models_names[model_index]);
+            model_node->mParent = bodypart_node;
+            model_node->mNumMeshes = static_cast<unsigned int>(pmodel->nummesh);
+            model_node->mMeshes = new unsigned int[model_node->mNumMeshes];
+            unsigned int *model_meshes_ptr = model_node->mMeshes;
+
+            for (int k = 0; k < pmodel->nummesh; ++k, ++pmesh, ++mesh_index, ++model_meshes_ptr) {
+                *model_meshes_ptr = mesh_index;
+
+                // Read triverts.
+                short *ptricmds = (short *)((uint8_t *)header_ + pmesh->triindex);
+                float texcoords_s_scale = 1.0f / (float)ptexture[pskinref[pmesh->skinref]].width;
+                float texcoords_t_scale = 1.0f / (float)ptexture[pskinref[pmesh->skinref]].height;
+
+                // Reset the data for the upcoming mesh.
+                triverts.clear();
+                triverts.resize(pmodel->numverts);
+                mesh_triverts_indices.clear();
+                mesh_faces.clear();
+                triverts_similars.clear();
+                bone_triverts.clear();
+
+                int l;
+                while ((l = *(ptricmds++))) {
+                    bool is_triangle_fan = false;
+
+                    if (l < 0) {
+                        l = -l;
+                        is_triangle_fan = true;
+                    }
+
+                    // Clear the list of tris for the upcoming tris.
+                    tricmds.clear();
+
+                    for (; l > 0; l--, ptricmds += 4) {
+                        const Trivert *input_trivert = reinterpret_cast<const Trivert *>(ptricmds);
+                        const int bone = pvertbone[input_trivert->vertindex];
+
+                        HL1MeshTrivert *private_trivert = &triverts[input_trivert->vertindex];
+                        if (private_trivert->localindex == -1) {
+                            // First time referenced.
+                            *private_trivert = *input_trivert;
+                            private_trivert->localindex = static_cast<short>(mesh_triverts_indices.size());
+                            mesh_triverts_indices.push_back(input_trivert->vertindex);
+                            tricmds.push_back(private_trivert->localindex);
+                            AddTrivertToBone(bone, private_trivert->localindex);
+                        } else if (*private_trivert == *input_trivert) {
+                            // Exists and is the same.
+                            tricmds.push_back(private_trivert->localindex);
+                        } else {
+                            // No similar trivert associated to the trivert currently processed.
+                            if (triverts_similars.count(input_trivert->vertindex) == 0)
+                                AddSimilarTrivert(*input_trivert, bone);
+                            else {
+                                // Search in the list of similar triverts to see if the
+                                // trivert in process is already registered.
+                                short similar_index = -1;
+                                for (auto it = triverts_similars[input_trivert->vertindex].cbegin();
+                                        similar_index == -1 && it != triverts_similars[input_trivert->vertindex].cend();
+                                        ++it) {
+                                    if (triverts[*it] == *input_trivert)
+                                        similar_index = *it;
+                                }
+
+                                // If a similar trivert has been found, reuse it.
+                                // Otherwise, add it.
+                                if (similar_index == -1)
+                                    AddSimilarTrivert(*input_trivert, bone);
+                                else
+                                    tricmds.push_back(triverts[similar_index].localindex);
+                            }
+                        }
+                    }
+
+                    // Build mesh faces.
+                    const int num_faces = static_cast<int>(tricmds.size() - 2);
+                    mesh_faces.reserve(num_faces);
+
+                    if (is_triangle_fan) {
+                        for (int faceIdx = 0; faceIdx < num_faces; ++faceIdx) {
+                            mesh_faces.push_back(HL1MeshFace{
+                                    tricmds[0],
+                                    tricmds[faceIdx + 1],
+                                    tricmds[faceIdx + 2] });
+                        }
+                    } else {
+                        for (int faceIdx = 0; faceIdx < num_faces; ++faceIdx) {
+                            if (faceIdx & 1) {
+                                // Preserve winding order.
+                                mesh_faces.push_back(HL1MeshFace{
+                                        tricmds[faceIdx + 1],
+                                        tricmds[faceIdx],
+                                        tricmds[faceIdx + 2] });
+                            } else {
+                                mesh_faces.push_back(HL1MeshFace{
+                                        tricmds[faceIdx],
+                                        tricmds[faceIdx + 1],
+                                        tricmds[faceIdx + 2] });
+                            }
+                        }
+                    }
+
+                    total_triangles += num_faces;
+                }
+
+                // Create the scene mesh.
+                aiMesh *scene_mesh = scene_->mMeshes[mesh_index] = new aiMesh();
+                scene_mesh->mPrimitiveTypes = aiPrimitiveType::aiPrimitiveType_TRIANGLE;
+                scene_mesh->mMaterialIndex = pskinref[pmesh->skinref];
+
+                scene_mesh->mNumVertices = static_cast<unsigned int>(mesh_triverts_indices.size());
+
+                if (scene_mesh->mNumVertices) {
+                    scene_mesh->mVertices = new aiVector3D[scene_mesh->mNumVertices];
+                    scene_mesh->mNormals = new aiVector3D[scene_mesh->mNumVertices];
+
+                    scene_mesh->mNumUVComponents[0] = 2;
+                    scene_mesh->mTextureCoords[0] = new aiVector3D[scene_mesh->mNumVertices];
+
+                    // Add vertices.
+                    for (unsigned int v = 0; v < scene_mesh->mNumVertices; ++v) {
+                        const HL1MeshTrivert *pTrivert = &triverts[mesh_triverts_indices[v]];
+                        scene_mesh->mVertices[v] = bind_pose_vertices[pTrivert->vertindex];
+                        scene_mesh->mNormals[v] = bind_pose_normals[pTrivert->normindex];
+                        scene_mesh->mTextureCoords[0][v] = aiVector3D(
+                                pTrivert->s * texcoords_s_scale,
+                                pTrivert->t * -texcoords_t_scale, 0);
+                    }
+
+                    // Add face and indices.
+                    scene_mesh->mNumFaces = static_cast<unsigned int>(mesh_faces.size());
+                    scene_mesh->mFaces = new aiFace[scene_mesh->mNumFaces];
+
+                    for (unsigned int f = 0; f < scene_mesh->mNumFaces; ++f) {
+                        aiFace *face = &scene_mesh->mFaces[f];
+                        face->mNumIndices = 3;
+                        face->mIndices = new unsigned int[3];
+                        face->mIndices[0] = mesh_faces[f].v2;
+                        face->mIndices[1] = mesh_faces[f].v1;
+                        face->mIndices[2] = mesh_faces[f].v0;
+                    }
+
+                    // Add mesh bones.
+                    scene_mesh->mNumBones = static_cast<unsigned int>(bone_triverts.size());
+                    scene_mesh->mBones = new aiBone *[scene_mesh->mNumBones];
+
+                    aiBone **scene_bone_ptr = scene_mesh->mBones;
+
+                    for (auto bone_it = bone_triverts.cbegin();
+                            bone_it != bone_triverts.cend();
+                            ++bone_it, ++scene_bone_ptr) {
+                        const int bone_index = bone_it->first;
+
+                        aiBone *scene_bone = (*scene_bone_ptr) = new aiBone();
+                        scene_bone->mName = temp_bones_[bone_index].node->mName;
+
+                        scene_bone->mOffsetMatrix = temp_bones_[bone_index].offset_matrix;
+
+                        auto vertex_ids = bone_triverts.at(bone_index);
+
+                        // Add vertex weight per bone.
+                        scene_bone->mNumWeights = static_cast<unsigned int>(vertex_ids.size());
+                        aiVertexWeight *vertex_weight_ptr = scene_bone->mWeights = new aiVertexWeight[scene_bone->mNumWeights];
+
+                        for (auto vertex_it = vertex_ids.begin();
+                                vertex_it != vertex_ids.end();
+                                ++vertex_it, ++vertex_weight_ptr) {
+                            vertex_weight_ptr->mVertexId = *vertex_it;
+                            vertex_weight_ptr->mWeight = 1.0f;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    if (total_triangles > AI_MDL_HL1_MAX_TRIANGLES) {
+        log_warning_limit_exceeded<AI_MDL_HL1_MAX_TRIANGLES>(total_triangles, "triangles");
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void HL1MDLLoader::read_animations() {
+    if (!header_->numseq) {
+        return;
+    }
+
+    const SequenceDesc_HL1 *pseqdesc = (const SequenceDesc_HL1 *)((uint8_t *)header_ + header_->seqindex);
+    const SequenceGroup_HL1 *pseqgroup = nullptr;
+    const AnimValueOffset_HL1 *panim = nullptr;
+    const AnimValue_HL1 *panimvalue = nullptr;
+
+    unique_sequence_names_.resize(header_->numseq);
+    for (int i = 0; i < header_->numseq; ++i)
+        unique_sequence_names_[i] = pseqdesc[i].label;
+
+    // Ensure sequences have unique names.
+    unique_name_generator_.set_template_name("Sequence");
+    unique_name_generator_.make_unique(unique_sequence_names_);
+
+    scene_->mNumAnimations = 0;
+
+    int highest_num_blend_animations = SequenceBlendMode_HL1::NoBlend;
+
+    // Count the total number of animations.
+    for (int i = 0; i < header_->numseq; ++i, ++pseqdesc) {
+        scene_->mNumAnimations += pseqdesc->numblends;
+        highest_num_blend_animations = std::max(pseqdesc->numblends, highest_num_blend_animations);
+    }
+
+    // Get the number of available blend controllers for global info.
+    get_num_blend_controllers(highest_num_blend_animations, num_blend_controllers_);
+
+    pseqdesc = (const SequenceDesc_HL1 *)((uint8_t *)header_ + header_->seqindex);
+
+    aiAnimation **scene_animations_ptr = scene_->mAnimations = new aiAnimation *[scene_->mNumAnimations];
+
+    for (int sequence = 0; sequence < header_->numseq; ++sequence, ++pseqdesc) {
+        pseqgroup = (const SequenceGroup_HL1 *)((uint8_t *)header_ + header_->seqgroupindex) + pseqdesc->seqgroup;
+
+        if (pseqdesc->seqgroup == 0) {
+            panim = (const AnimValueOffset_HL1 *)((uint8_t *)header_ + pseqgroup->unused2 + pseqdesc->animindex);
+        } else {
+            panim = (const AnimValueOffset_HL1 *)((uint8_t *)anim_headers_[pseqdesc->seqgroup] + pseqdesc->animindex);
+        }
+
+        for (int blend = 0; blend < pseqdesc->numblends; ++blend, ++scene_animations_ptr) {
+
+            const Bone_HL1 *pbone = (const Bone_HL1 *)((uint8_t *)header_ + header_->boneindex);
+
+            aiAnimation *scene_animation = (*scene_animations_ptr) = new aiAnimation();
+
+            scene_animation->mName = unique_sequence_names_[sequence];
+            scene_animation->mTicksPerSecond = pseqdesc->fps;
+            scene_animation->mDuration = static_cast<double>(pseqdesc->fps) * pseqdesc->numframes;
+            scene_animation->mNumChannels = static_cast<unsigned int>(header_->numbones);
+            scene_animation->mChannels = new aiNodeAnim *[scene_animation->mNumChannels];
+
+            for (int bone = 0; bone < header_->numbones; bone++, ++pbone, ++panim) {
+                aiNodeAnim *node_anim = scene_animation->mChannels[bone] = new aiNodeAnim();
+                node_anim->mNodeName = temp_bones_[bone].node->mName;
+
+                node_anim->mNumPositionKeys = pseqdesc->numframes;
+                node_anim->mNumRotationKeys = node_anim->mNumPositionKeys;
+                node_anim->mNumScalingKeys = 0;
+
+                node_anim->mPositionKeys = new aiVectorKey[node_anim->mNumPositionKeys];
+                node_anim->mRotationKeys = new aiQuatKey[node_anim->mNumRotationKeys];
+
+                for (int frame = 0; frame < pseqdesc->numframes; ++frame) {
+                    aiVectorKey *position_key = &node_anim->mPositionKeys[frame];
+                    aiQuatKey *rotation_key = &node_anim->mRotationKeys[frame];
+
+                    aiVector3D angle1;
+                    for (int j = 0; j < 3; ++j) {
+                        if (panim->offset[j + 3] != 0) {
+                            // Read compressed rotation delta.
+                            panimvalue = (const AnimValue_HL1 *)((uint8_t *)panim + panim->offset[j + 3]);
+                            extract_anim_value(panimvalue, frame, pbone->scale[j + 3], angle1[j]);
+                        }
+
+                        // Add the default rotation value.
+                        angle1[j] += pbone->value[j + 3];
+
+                        if (panim->offset[j] != 0) {
+                            // Read compressed position delta.
+                            panimvalue = (const AnimValue_HL1 *)((uint8_t *)panim + panim->offset[j]);
+                            extract_anim_value(panimvalue, frame, pbone->scale[j], position_key->mValue[j]);
+                        }
+
+                        // Add the default position value.
+                        position_key->mValue[j] += pbone->value[j];
+                    }
+
+                    position_key->mTime = rotation_key->mTime = static_cast<double>(frame);
+                    /* The Half-Life engine uses X as forward, Y as left, Z as up. Therefore,
+                       pitch,yaw,roll is represented as (YZX). */
+                    rotation_key->mValue = aiQuaternion(angle1.y, angle1.z, angle1.x);
+                    rotation_key->mValue.Normalize();
+                }
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void HL1MDLLoader::read_sequence_groups_info() {
+    if (!header_->numseqgroups) {
+        return;
+    }
+
+    aiNode *sequence_groups_node = new aiNode(AI_MDL_HL1_NODE_SEQUENCE_GROUPS);
+    rootnode_children_.push_back(sequence_groups_node);
+
+    sequence_groups_node->mNumChildren = static_cast<unsigned int>(header_->numseqgroups);
+    sequence_groups_node->mChildren = new aiNode *[sequence_groups_node->mNumChildren];
+
+    const SequenceGroup_HL1 *pseqgroup = (const SequenceGroup_HL1 *)((uint8_t *)header_ + header_->seqgroupindex);
+
+    unique_sequence_groups_names_.resize(header_->numseqgroups);
+    for (int i = 0; i < header_->numseqgroups; ++i) {
+        unique_sequence_groups_names_[i] = pseqgroup[i].label;
+    }
+
+    // Ensure sequence groups have unique names.
+    unique_name_generator_.set_template_name("SequenceGroup");
+    unique_name_generator_.make_unique(unique_sequence_groups_names_);
+
+    for (int i = 0; i < header_->numseqgroups; ++i, ++pseqgroup) {
+        aiNode *sequence_group_node = sequence_groups_node->mChildren[i] = new aiNode(unique_sequence_groups_names_[i]);
+        sequence_group_node->mParent = sequence_groups_node;
+
+        aiMetadata *md = sequence_group_node->mMetaData = aiMetadata::Alloc(1);
+        if (i == 0) {
+            /* StudioMDL does not write the file name for the default sequence group,
+               so we will write it. */
+            md->Set(0, "File", aiString(file_path_));
+        } else {
+            md->Set(0, "File", aiString(pseqgroup->name));
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void HL1MDLLoader::read_sequence_infos() {
+    if (!header_->numseq) {
+        return;
+    }
+
+    const SequenceDesc_HL1 *pseqdesc = (const SequenceDesc_HL1 *)((uint8_t *)header_ + header_->seqindex);
+
+    aiNode *sequence_infos_node = new aiNode(AI_MDL_HL1_NODE_SEQUENCE_INFOS);
+    rootnode_children_.push_back(sequence_infos_node);
+
+    sequence_infos_node->mNumChildren = static_cast<unsigned int>(header_->numseq);
+    sequence_infos_node->mChildren = new aiNode *[sequence_infos_node->mNumChildren];
+
+    std::vector<aiNode *> sequence_info_node_children;
+
+    int animation_index = 0;
+    for (int i = 0; i < header_->numseq; ++i, ++pseqdesc) {
+        // Clear the list of children for the upcoming sequence info node.
+        sequence_info_node_children.clear();
+
+        aiNode *sequence_info_node = sequence_infos_node->mChildren[i] = new aiNode(unique_sequence_names_[i]);
+        sequence_info_node->mParent = sequence_infos_node;
+
+        // Setup sequence info node Metadata.
+        aiMetadata *md = sequence_info_node->mMetaData = aiMetadata::Alloc(16);
+        md->Set(0, "AnimationIndex", animation_index);
+        animation_index += pseqdesc->numblends;
+
+        // Reference the sequence group by name. This allows us to search a particular
+        // sequence group by name using aiNode(s).
+        md->Set(1, "SequenceGroup", aiString(unique_sequence_groups_names_[pseqdesc->seqgroup]));
+        md->Set(2, "FramesPerSecond", pseqdesc->fps);
+        md->Set(3, "NumFrames", pseqdesc->numframes);
+        md->Set(4, "NumBlends", pseqdesc->numblends);
+        md->Set(5, "Activity", pseqdesc->activity);
+        md->Set(6, "ActivityWeight", pseqdesc->actweight);
+        md->Set(7, "MotionFlags", pseqdesc->motiontype);
+        md->Set(8, "MotionBone", temp_bones_[pseqdesc->motionbone].node->mName);
+        md->Set(9, "LinearMovement", aiVector3D(pseqdesc->linearmovement[0], pseqdesc->linearmovement[1], pseqdesc->linearmovement[2]));
+        md->Set(10, "BBMin", aiVector3D(pseqdesc->bbmin[0], pseqdesc->bbmin[1], pseqdesc->bbmin[2]));
+        md->Set(11, "BBMax", aiVector3D(pseqdesc->bbmax[0], pseqdesc->bbmax[1], pseqdesc->bbmax[2]));
+        md->Set(12, "EntryNode", pseqdesc->entrynode);
+        md->Set(13, "ExitNode", pseqdesc->exitnode);
+        md->Set(14, "NodeFlags", pseqdesc->nodeflags);
+        md->Set(15, "Flags", pseqdesc->flags);
+
+        if (import_settings_.read_blend_controllers) {
+            int num_blend_controllers;
+            if (get_num_blend_controllers(pseqdesc->numblends, num_blend_controllers) && num_blend_controllers) {
+                // Read blend controllers info.
+                aiNode *blend_controllers_node = new aiNode(AI_MDL_HL1_NODE_BLEND_CONTROLLERS);
+                sequence_info_node_children.push_back(blend_controllers_node);
+                blend_controllers_node->mParent = sequence_info_node;
+                blend_controllers_node->mNumChildren = static_cast<unsigned int>(num_blend_controllers);
+                blend_controllers_node->mChildren = new aiNode *[blend_controllers_node->mNumChildren];
+
+                for (unsigned int j = 0; j < blend_controllers_node->mNumChildren; ++j) {
+                    aiNode *blend_controller_node = blend_controllers_node->mChildren[j] = new aiNode();
+                    blend_controller_node->mParent = blend_controllers_node;
+
+                    aiMetadata *metaData = blend_controller_node->mMetaData = aiMetadata::Alloc(3);
+                    metaData->Set(0, "Start", pseqdesc->blendstart[j]);
+                    metaData->Set(1, "End", pseqdesc->blendend[j]);
+                    metaData->Set(2, "MotionFlags", pseqdesc->blendtype[j]);
+                }
+            }
+        }
+
+        if (import_settings_.read_animation_events && pseqdesc->numevents) {
+            // Read animation events.
+
+            if (pseqdesc->numevents > AI_MDL_HL1_MAX_EVENTS) {
+                log_warning_limit_exceeded<AI_MDL_HL1_MAX_EVENTS>(
+                        "Sequence " + std::string(pseqdesc->label),
+                        pseqdesc->numevents, "animation events");
+            }
+
+            const AnimEvent_HL1 *pevent = (const AnimEvent_HL1 *)((uint8_t *)header_ + pseqdesc->eventindex);
+
+            aiNode *pEventsNode = new aiNode(AI_MDL_HL1_NODE_ANIMATION_EVENTS);
+            sequence_info_node_children.push_back(pEventsNode);
+            pEventsNode->mParent = sequence_info_node;
+            pEventsNode->mNumChildren = static_cast<unsigned int>(pseqdesc->numevents);
+            pEventsNode->mChildren = new aiNode *[pEventsNode->mNumChildren];
+
+            for (unsigned int j = 0; j < pEventsNode->mNumChildren; ++j, ++pevent) {
+                aiNode *pEvent = pEventsNode->mChildren[j] = new aiNode();
+                pEvent->mParent = pEventsNode;
+
+                aiMetadata *metaData = pEvent->mMetaData = aiMetadata::Alloc(3);
+                metaData->Set(0, "Frame", pevent->frame);
+                metaData->Set(1, "ScriptEvent", pevent->event);
+                metaData->Set(2, "Options", aiString(pevent->options));
+            }
+        }
+
+        if (sequence_info_node_children.size()) {
+            sequence_info_node->addChildren(
+                    static_cast<unsigned int>(sequence_info_node_children.size()),
+                    sequence_info_node_children.data());
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void HL1MDLLoader::read_sequence_transitions() {
+    if (!header_->numtransitions) {
+        return;
+    }
+
+    // Read sequence transition graph.
+    aiNode *transition_graph_node = new aiNode(AI_MDL_HL1_NODE_SEQUENCE_TRANSITION_GRAPH);
+    rootnode_children_.push_back(transition_graph_node);
+
+    uint8_t *ptransitions = ((uint8_t *)header_ + header_->transitionindex);
+    aiMetadata *md = transition_graph_node->mMetaData = aiMetadata::Alloc(header_->numtransitions * header_->numtransitions);
+    for (unsigned int i = 0; i < md->mNumProperties; ++i)
+        md->Set(i, std::to_string(i), static_cast<int>(ptransitions[i]));
+}
+
+void HL1MDLLoader::read_attachments() {
+    if (!header_->numattachments) {
+        return;
+    }
+
+    const Attachment_HL1 *pattach = (const Attachment_HL1 *)((uint8_t *)header_ + header_->attachmentindex);
+
+    aiNode *attachments_node = new aiNode(AI_MDL_HL1_NODE_ATTACHMENTS);
+    rootnode_children_.push_back(attachments_node);
+    attachments_node->mNumChildren = static_cast<unsigned int>(header_->numattachments);
+    attachments_node->mChildren = new aiNode *[attachments_node->mNumChildren];
+
+    for (int i = 0; i < header_->numattachments; ++i, ++pattach) {
+        aiNode *attachment_node = attachments_node->mChildren[i] = new aiNode();
+        attachment_node->mParent = attachments_node;
+        attachment_node->mMetaData = aiMetadata::Alloc(2);
+        attachment_node->mMetaData->Set(0, "Position", aiVector3D(pattach->org[0], pattach->org[1], pattach->org[2]));
+        // Reference the bone by name. This allows us to search a particular
+        // bone by name using aiNode(s).
+        attachment_node->mMetaData->Set(1, "Bone", temp_bones_[pattach->bone].node->mName);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void HL1MDLLoader::read_hitboxes() {
+    if (!header_->numhitboxes) {
+        return;
+    }
+
+    const Hitbox_HL1 *phitbox = (const Hitbox_HL1 *)((uint8_t *)header_ + header_->hitboxindex);
+
+    aiNode *hitboxes_node = new aiNode(AI_MDL_HL1_NODE_HITBOXES);
+    rootnode_children_.push_back(hitboxes_node);
+    hitboxes_node->mNumChildren = static_cast<unsigned int>(header_->numhitboxes);
+    hitboxes_node->mChildren = new aiNode *[hitboxes_node->mNumChildren];
+
+    for (int i = 0; i < header_->numhitboxes; ++i, ++phitbox) {
+        aiNode *hitbox_node = hitboxes_node->mChildren[i] = new aiNode();
+        hitbox_node->mParent = hitboxes_node;
+
+        aiMetadata *md = hitbox_node->mMetaData = aiMetadata::Alloc(4);
+        // Reference the bone by name. This allows us to search a particular
+        // bone by name using aiNode(s).
+        md->Set(0, "Bone", temp_bones_[phitbox->bone].node->mName);
+        md->Set(1, "HitGroup", phitbox->group);
+        md->Set(2, "BBMin", aiVector3D(phitbox->bbmin[0], phitbox->bbmin[1], phitbox->bbmin[2]));
+        md->Set(3, "BBMax", aiVector3D(phitbox->bbmax[0], phitbox->bbmax[1], phitbox->bbmax[2]));
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void HL1MDLLoader::read_bone_controllers() {
+    if (!header_->numbonecontrollers) {
+        return;
+    }
+
+    const BoneController_HL1 *pbonecontroller = (const BoneController_HL1 *)((uint8_t *)header_ + header_->bonecontrollerindex);
+
+    aiNode *bones_controller_node = new aiNode(AI_MDL_HL1_NODE_BONE_CONTROLLERS);
+    rootnode_children_.push_back(bones_controller_node);
+    bones_controller_node->mNumChildren = static_cast<unsigned int>(header_->numbonecontrollers);
+    bones_controller_node->mChildren = new aiNode *[bones_controller_node->mNumChildren];
+
+    for (int i = 0; i < header_->numbonecontrollers; ++i, ++pbonecontroller) {
+        aiNode *bone_controller_node = bones_controller_node->mChildren[i] = new aiNode();
+        bone_controller_node->mParent = bones_controller_node;
+
+        aiMetadata *md = bone_controller_node->mMetaData = aiMetadata::Alloc(5);
+        // Reference the bone by name. This allows us to search a particular
+        // bone by name using aiNode(s).
+        md->Set(0, "Bone", temp_bones_[pbonecontroller->bone].node->mName);
+        md->Set(1, "MotionFlags", pbonecontroller->type);
+        md->Set(2, "Start", pbonecontroller->start);
+        md->Set(3, "End", pbonecontroller->end);
+        md->Set(4, "Channel", pbonecontroller->index);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void HL1MDLLoader::read_global_info() {
+    aiNode *global_info_node = new aiNode(AI_MDL_HL1_NODE_GLOBAL_INFO);
+    rootnode_children_.push_back(global_info_node);
+
+    aiMetadata *md = global_info_node->mMetaData = aiMetadata::Alloc(import_settings_.read_misc_global_info ? 16 : 11);
+    md->Set(0, "Version", AI_MDL_HL1_VERSION);
+    md->Set(1, "NumBodyparts", header_->numbodyparts);
+    md->Set(2, "NumModels", total_models_);
+    md->Set(3, "NumBones", header_->numbones);
+    md->Set(4, "NumAttachments", import_settings_.read_attachments ? header_->numattachments : 0);
+    md->Set(5, "NumSkinFamilies", texture_header_->numskinfamilies);
+    md->Set(6, "NumHitboxes", import_settings_.read_hitboxes ? header_->numhitboxes : 0);
+    md->Set(7, "NumBoneControllers", import_settings_.read_bone_controllers ? header_->numbonecontrollers : 0);
+    md->Set(8, "NumSequences", import_settings_.read_animations ? header_->numseq : 0);
+    md->Set(9, "NumBlendControllers", import_settings_.read_blend_controllers ? num_blend_controllers_ : 0);
+    md->Set(10, "NumTransitionNodes", import_settings_.read_sequence_transitions ? header_->numtransitions : 0);
+
+    if (import_settings_.read_misc_global_info) {
+        md->Set(11, "EyePosition", aiVector3D(header_->eyeposition[0], header_->eyeposition[1], header_->eyeposition[2]));
+        md->Set(12, "HullMin", aiVector3D(header_->min[0], header_->min[1], header_->min[2]));
+        md->Set(13, "HullMax", aiVector3D(header_->max[0], header_->max[1], header_->max[2]));
+        md->Set(14, "CollisionMin", aiVector3D(header_->bbmin[0], header_->bbmin[1], header_->bbmin[2]));
+        md->Set(15, "CollisionMax", aiVector3D(header_->bbmax[0], header_->bbmax[1], header_->bbmax[2]));
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+/** @brief This method reads a compressed anim value.
+*
+*   @note The structure of this method is taken from HL2 source code.
+*   Although this is from HL2, it's implementation is almost identical
+*   to code found in HL1 SDK. See HL1 and HL2 SDKs for more info.
+*
+*   source:
+*       HL1 source code.
+*           file: studio_render.cpp
+*           function(s): CalcBoneQuaternion and CalcBonePosition
+*
+*       HL2 source code.
+*           file: bone_setup.cpp
+*           function(s): ExtractAnimValue
+*/
+void HL1MDLLoader::extract_anim_value(
+        const AnimValue_HL1 *panimvalue,
+        int frame, float bone_scale, ai_real &value) {
+    int k = frame;
+
+    // find span of values that includes the frame we want
+    while (panimvalue->num.total <= k) {
+        k -= panimvalue->num.total;
+        panimvalue += panimvalue->num.valid + 1;
+    }
+
+    // Bah, missing blend!
+    if (panimvalue->num.valid > k) {
+        value = panimvalue[k + 1].value * bone_scale;
+    } else {
+        value = panimvalue[panimvalue->num.valid].value * bone_scale;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Get the number of blend controllers.
+bool HL1MDLLoader::get_num_blend_controllers(const int num_blend_animations, int &num_blend_controllers) {
+
+    switch (num_blend_animations) {
+        case SequenceBlendMode_HL1::NoBlend:
+            num_blend_controllers = 0;
+            return true;
+        case SequenceBlendMode_HL1::TwoWayBlending:
+            num_blend_controllers = 1;
+            return true;
+        case SequenceBlendMode_HL1::FourWayBlending:
+            num_blend_controllers = 2;
+            return true;
+        default:
+            num_blend_controllers = 0;
+            ASSIMP_LOG_WARN(MDL_HALFLIFE_LOG_HEADER "Unsupported number of blend animations (", num_blend_animations, ")");
+            return false;
+    }
+}
+
+} // namespace HalfLife
+} // namespace MDL
+} // namespace Assimp
diff --git a/Engine/lib/assimp/code/AssetLib/MDL/HalfLife/HL1MDLLoader.h b/Engine/lib/assimp/code/AssetLib/MDL/HalfLife/HL1MDLLoader.h
new file mode 100644
index 000000000..d87d6d3e8
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/MDL/HalfLife/HL1MDLLoader.h
@@ -0,0 +1,243 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file HL1MDLLoader.h
+ *  @brief Declaration of the Half-Life 1 MDL loader.
+ */
+
+#ifndef AI_HL1MDLLOADER_INCLUDED
+#define AI_HL1MDLLOADER_INCLUDED
+
+#include "HL1FileData.h"
+#include "HL1ImportSettings.h"
+#include "UniqueNameGenerator.h"
+
+#include <memory>
+#include <string>
+
+#include <assimp/types.h>
+#include <assimp/scene.h>
+#include <assimp/texture.h>
+#include <assimp/IOSystem.hpp>
+#include <assimp/DefaultIOSystem.h>
+#include <assimp/Exceptional.h>
+
+namespace Assimp {
+namespace MDL {
+namespace HalfLife {
+
+class HL1MDLLoader {
+public:
+    HL1MDLLoader() = delete;
+    HL1MDLLoader(const HL1MDLLoader &) = delete;
+
+    /** See variables descriptions at the end for more details. */
+    HL1MDLLoader(
+        aiScene *scene,
+        IOSystem *io,
+        const unsigned char *buffer,
+        const std::string &file_path,
+        const HL1ImportSettings &import_settings);
+
+    ~HL1MDLLoader();
+
+    void load_file();
+
+protected:
+    /** \brief Validate the header data structure of a Half-Life 1 MDL file.
+     * \param[in] header Input header to be validated.
+     * \param[in] is_texture_header Whether or not we are reading an MDL
+     *   texture file.
+     */
+    void validate_header(const Header_HL1 *header, bool is_texture_header);
+
+    void load_texture_file();
+    void load_sequence_groups_files();
+    void read_textures();
+    void read_skins();
+    void read_bones();
+    void read_meshes();
+    void read_animations();
+    void read_sequence_groups_info();
+    void read_sequence_infos();
+    void read_sequence_transitions();
+    void read_attachments();
+    void read_hitboxes();
+    void read_bone_controllers();
+    void read_global_info();
+
+private:
+    void release_resources();
+
+    /** \brief Load a file and copy it's content to a buffer.
+     * \param file_path The path to the file to be loaded.
+     * \param buffer A pointer to a buffer to receive the data.
+     */
+    template <typename MDLFileHeader>
+    void load_file_into_buffer(const std::string &file_path, unsigned char *&buffer);
+
+    /** \brief Read an MDL texture.
+     * \param[in] ptexture A pointer to an MDL texture.
+     * \param[in] data A pointer to the data from \p ptexture.
+     * \param[in] pal A pointer to the texture palette from \p ptexture.
+     * \param[in,out] pResult A pointer to the output resulting Assimp texture.
+     * \param[in,out] last_palette_color The last color from the image palette.
+     */
+    void read_texture(const Texture_HL1 *ptexture,
+            uint8_t *data, uint8_t *pal, aiTexture *pResult,
+            aiColor3D &last_palette_color);
+
+    /** \brief This method reads a compressed anim value.
+    * \param[in] panimvalue A pointer to the animation data.
+    * \param[in] frame The frame to look for.
+    * \param[in] bone_scale The current bone scale to apply to the compressed value.
+    * \param[in,out] value The decompressed anim value at \p frame.
+    */
+    void extract_anim_value(const AnimValue_HL1 *panimvalue,
+            int frame, float bone_scale, ai_real &value);
+
+    /**
+     *  \brief Given the number of blend animations, determine the number of blend controllers.
+     *
+     * \param[in] num_blend_animations The number of blend animations.
+     * \param[out] num_blend_controllers The number of blend controllers.
+     * \return True if the number of blend controllers was determined. False otherwise.
+     */
+    static bool get_num_blend_controllers(const int num_blend_animations, int &num_blend_controllers);
+
+    /** Output scene to be filled */
+    aiScene *scene_;
+
+    /** Output I/O handler. Required for additional IO operations. */
+    IOSystem *io_;
+
+    /** Buffer from MDLLoader class. */
+    const unsigned char *buffer_;
+
+    /** The full file path to the MDL file we are trying to load.
+     * Used to locate other MDL files since MDL may store resources
+     * in external MDL files. */
+    const std::string &file_path_;
+
+    /** Configuration for HL1 MDL */
+    const HL1ImportSettings &import_settings_;
+
+    /** Main MDL header. */
+    const Header_HL1 *header_;
+
+    /** External MDL texture header. */
+    const Header_HL1 *texture_header_;
+
+    /** External MDL animation headers.
+     * One for each loaded animation file. */
+    SequenceHeader_HL1 **anim_headers_;
+
+    /** Texture file data. */
+    unsigned char *texture_buffer_;
+
+    /** Animation files data. */
+    unsigned char **anim_buffers_;
+
+    /** The number of sequence groups. */
+    int num_sequence_groups_;
+
+    /** The list of children to be appended to the scene's root node. */
+    std::vector<aiNode *> rootnode_children_;
+
+    /** A unique name generator. Used to generate names for MDL values
+     * that may have empty/duplicate names. */
+    UniqueNameGenerator unique_name_generator_;
+
+    /** The list of unique sequence names. */
+    std::vector<std::string> unique_sequence_names_;
+
+    /** The list of unique sequence groups names. */
+    std::vector<std::string> unique_sequence_groups_names_;
+
+    /** Structure to store temporary bone information. */
+    struct TempBone {
+
+        TempBone() :
+            node(nullptr),
+            absolute_transform(),
+            offset_matrix() {}
+
+        aiNode *node;
+        aiMatrix4x4 absolute_transform;
+        aiMatrix4x4 offset_matrix;
+    };
+
+    std::vector<TempBone> temp_bones_;
+
+    /** The number of available bone controllers in the model. */
+    int num_blend_controllers_;
+
+    /** Self explanatory. */
+    int total_models_;
+};
+
+// ------------------------------------------------------------------------------------------------
+template <typename MDLFileHeader>
+void HL1MDLLoader::load_file_into_buffer(const std::string &file_path, unsigned char *&buffer) {
+    if (!io_->Exists(file_path))
+        throw DeadlyImportError("Missing file ", DefaultIOSystem::fileName(file_path), ".");
+
+    std::unique_ptr<IOStream> file(io_->Open(file_path));
+
+    if (file.get() == nullptr) {
+        throw DeadlyImportError("Failed to open MDL file ", DefaultIOSystem::fileName(file_path), ".");
+    }
+
+    const size_t file_size = file->FileSize();
+    if (file_size < sizeof(MDLFileHeader)) {
+        throw DeadlyImportError("MDL file is too small.");
+    }
+
+    buffer = new unsigned char[1 + file_size];
+    file->Read((void *)buffer, 1, file_size);
+    buffer[file_size] = '\0';
+}
+
+} // namespace HalfLife
+} // namespace MDL
+} // namespace Assimp
+
+#endif // AI_HL1MDLLOADER_INCLUDED
diff --git a/Engine/lib/assimp/code/AssetLib/MDL/HalfLife/HL1MeshTrivert.h b/Engine/lib/assimp/code/AssetLib/MDL/HalfLife/HL1MeshTrivert.h
new file mode 100644
index 000000000..4ef8a13ce
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/MDL/HalfLife/HL1MeshTrivert.h
@@ -0,0 +1,127 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file HL1MeshTrivert.h
+ *  @brief This file contains the class declaration for the
+ *         HL1 mesh trivert class.
+ */
+
+#ifndef AI_HL1MESHTRIVERT_INCLUDED
+#define AI_HL1MESHTRIVERT_INCLUDED
+
+#include "HL1FileData.h"
+
+namespace Assimp {
+namespace MDL {
+namespace HalfLife {
+
+/* A class to help map model triverts to mesh triverts. */
+struct HL1MeshTrivert {
+    HL1MeshTrivert() :
+            vertindex(-1),
+            normindex(-1),
+            s(0),
+            t(0),
+            localindex(-1) {
+    }
+
+    HL1MeshTrivert(short vertindex, short normindex, short s, short t, short localindex) :
+            vertindex(vertindex),
+            normindex(normindex),
+            s(s),
+            t(t),
+            localindex(localindex) {
+    }
+
+    HL1MeshTrivert(const Trivert &a) :
+            vertindex(a.vertindex),
+            normindex(a.normindex),
+            s(a.s),
+            t(a.t),
+            localindex(-1) {
+    }
+
+    inline bool operator==(const Trivert &a) const {
+        return vertindex == a.vertindex &&
+               normindex == a.normindex &&
+               s == a.s &&
+               t == a.t;
+    }
+
+    inline bool operator!=(const Trivert &a) const {
+        return !(*this == a);
+    }
+
+    inline bool operator==(const HL1MeshTrivert &a) const {
+        return localindex == a.localindex &&
+               vertindex == a.vertindex &&
+               normindex == a.normindex &&
+               s == a.s &&
+               t == a.t;
+    }
+
+    inline bool operator!=(const HL1MeshTrivert &a) const {
+        return !(*this == a);
+    }
+
+    inline HL1MeshTrivert &operator=(const Trivert &other) {
+        vertindex = other.vertindex;
+        normindex = other.normindex;
+        s = other.s;
+        t = other.t;
+        return *this;
+    }
+
+    short vertindex;
+    short normindex;
+    short s, t;
+    short localindex;
+};
+
+struct HL1MeshFace {
+    short v0, v1, v2;
+};
+
+} // namespace HalfLife
+} // namespace MDL
+} // namespace Assimp
+
+#endif // AI_HL1MESHTRIVERT_INCLUDED
diff --git a/Engine/lib/assimp/code/Importer/StepFile/StepFileImporter.h b/Engine/lib/assimp/code/AssetLib/MDL/HalfLife/HalfLifeMDLBaseHeader.h
similarity index 74%
rename from Engine/lib/assimp/code/Importer/StepFile/StepFileImporter.h
rename to Engine/lib/assimp/code/AssetLib/MDL/HalfLife/HalfLifeMDLBaseHeader.h
index 70f65fdcf..c7808c401 100644
--- a/Engine/lib/assimp/code/Importer/StepFile/StepFileImporter.h
+++ b/Engine/lib/assimp/code/AssetLib/MDL/HalfLife/HalfLifeMDLBaseHeader.h
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -41,29 +39,29 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
 
-#pragma once
+/** @file HalfLifeMDLBaseHeader.h */
 
-#ifndef ASSIMP_BUILD_NO_STEP_IMPORTER
+#ifndef AI_HALFLIFEMDLBASEHEADER_INCLUDED
+#define AI_HALFLIFEMDLBASEHEADER_INCLUDED
 
-#include <assimp/BaseImporter.h>
+#include <assimp/types.h>
 
 namespace Assimp {
-namespace StepFile {
+namespace MDL {
+namespace HalfLife {
 
-class StepFileImporter : public BaseImporter {
-public:
-    StepFileImporter();
-    ~StepFileImporter();
-    bool CanRead(const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const override;
-    const aiImporterDesc* GetInfo() const override;
+/** Used to interface different Valve MDL formats. */
+struct HalfLifeMDLBaseHeader
+{
+    //! Magic number: "IDST"/"IDSQ"
+    char ident[4];
 
-protected:
-    void InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler ) override;
-
-private:
+    //! The file format version.
+    int32_t version;
 };
 
-} // Namespace StepFile
-} // Namespace Assimp
+}
+}
+}
 
-#endif // ASSIMP_BUILD_NO_STEP_IMPORTER
+#endif // AI_HALFLIFEMDLBASEHEADER_INCLUDED
diff --git a/Engine/lib/assimp/code/AssetLib/MDL/HalfLife/LogFunctions.h b/Engine/lib/assimp/code/AssetLib/MDL/HalfLife/LogFunctions.h
new file mode 100644
index 000000000..003774dc1
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/MDL/HalfLife/LogFunctions.h
@@ -0,0 +1,95 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file LogFunctions.h */
+
+#ifndef AI_MDL_HALFLIFE_LOGFUNCTIONS_INCLUDED
+#define AI_MDL_HALFLIFE_LOGFUNCTIONS_INCLUDED
+
+#include <assimp/Logger.hpp>
+#include <string>
+
+namespace Assimp {
+namespace MDL {
+namespace HalfLife {
+
+/**
+ * \brief A function to log precise messages regarding limits exceeded.
+ *
+ * \param[in] subject Subject.
+ * \param[in] current_amount Current amount.
+ * \param[in] direct_object Direct object.
+ *            LIMIT Limit constant.
+ *
+ * Example: Model has 100 textures, which exceeds the limit (50)
+ *
+ *          where \p subject is 'Model'
+ *                \p current_amount is '100'
+ *                \p direct_object is 'textures'
+ *                LIMIT is '50'
+ */
+template <int LIMIT>
+static inline void log_warning_limit_exceeded(
+    const std::string &subject, int current_amount,
+    const std::string &direct_object) {
+
+    ASSIMP_LOG_WARN(MDL_HALFLIFE_LOG_HEADER
+        + subject
+        + " has "
+        + std::to_string(current_amount) + " "
+        + direct_object
+        + ", which exceeds the limit ("
+        + std::to_string(LIMIT)
+        + ")");
+}
+
+/** \brief Same as above, but uses 'Model' as the subject. */
+template <int LIMIT>
+static inline void log_warning_limit_exceeded(int current_amount,
+    const std::string &direct_object) {
+    log_warning_limit_exceeded<LIMIT>("Model", current_amount, direct_object);
+}
+
+} // namespace HalfLife
+} // namespace MDL
+} // namespace Assimp
+
+#endif // AI_MDL_HALFLIFE_LOGFUNCTIONS_INCLUDED
diff --git a/Engine/lib/assimp/code/AssetLib/MDL/HalfLife/UniqueNameGenerator.cpp b/Engine/lib/assimp/code/AssetLib/MDL/HalfLife/UniqueNameGenerator.cpp
new file mode 100644
index 000000000..6fc8b118e
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/MDL/HalfLife/UniqueNameGenerator.cpp
@@ -0,0 +1,180 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file UniqueNameGenerator.cpp
+ *  @brief Implementation for the unique name generator.
+ */
+
+#include "UniqueNameGenerator.h"
+#include <algorithm>
+#include <list>
+#include <map>
+#include <numeric>
+
+namespace Assimp {
+namespace MDL {
+namespace HalfLife {
+
+UniqueNameGenerator::UniqueNameGenerator() :
+    template_name_("unnamed"),
+    separator_("_") {
+}
+
+UniqueNameGenerator::UniqueNameGenerator(const char *template_name) :
+    template_name_(template_name),
+    separator_("_") {
+}
+
+UniqueNameGenerator::UniqueNameGenerator(const char *template_name, const char *separator) :
+    template_name_(template_name),
+    separator_(separator) {
+}
+
+UniqueNameGenerator::~UniqueNameGenerator() {
+}
+
+void UniqueNameGenerator::make_unique(std::vector<std::string> &names) {
+    struct DuplicateInfo {
+        DuplicateInfo() :
+            indices(),
+            next_id(0) {
+        }
+
+        std::list<size_t> indices;
+        size_t next_id;
+    };
+
+    std::vector<size_t> empty_names_indices;
+    std::vector<size_t> template_name_duplicates;
+    std::map<std::string, DuplicateInfo> names_to_duplicates;
+
+    const std::string template_name_with_separator(template_name_ + separator_);
+
+    auto format_name = [&](const std::string &base_name, size_t id) -> std::string {
+        return base_name + separator_ + std::to_string(id);
+    };
+
+    auto generate_unique_name = [&](const std::string &base_name) -> std::string {
+        auto *duplicate_info = &names_to_duplicates[base_name];
+
+        std::string new_name;
+
+        bool found_identical_name;
+        bool tried_with_base_name_only = false;
+        do {
+            // Assume that no identical name exists.
+            found_identical_name = false;
+
+            if (!tried_with_base_name_only) {
+                // First try with only the base name.
+                new_name = base_name;
+            } else {
+                // Create the name expected to be unique.
+                new_name = format_name(base_name, duplicate_info->next_id);
+            }
+
+            // Check in the list of duplicates for an identical name.
+            for (size_t i = 0;
+                    i < names.size() &&
+                    !found_identical_name;
+                    ++i) {
+                if (new_name == names[i])
+                    found_identical_name = true;
+            }
+
+            if (tried_with_base_name_only)
+                ++duplicate_info->next_id;
+
+            tried_with_base_name_only = true;
+
+        } while (found_identical_name);
+
+        return new_name;
+    };
+
+    for (size_t i = 0; i < names.size(); ++i) {
+        // Check for empty names.
+        if (names[i].find_first_not_of(' ') == std::string::npos) {
+            empty_names_indices.push_back(i);
+            continue;
+        }
+
+        /* Check for potential duplicate.
+        a) Either if this name is the same as the template name or
+        b) <template name><separator> is found at the beginning. */
+        if (names[i] == template_name_ ||
+                names[i].substr(0, template_name_with_separator.length()) == template_name_with_separator)
+            template_name_duplicates.push_back(i);
+
+        // Map each unique name to it's duplicate.
+        if (names_to_duplicates.count(names[i]) == 0)
+            names_to_duplicates.insert({ names[i], DuplicateInfo()});
+        else
+            names_to_duplicates[names[i]].indices.push_back(i);
+    }
+
+    // Make every non-empty name unique.
+    for (auto it = names_to_duplicates.begin();
+            it != names_to_duplicates.end(); ++it) {
+        for (auto it2 = it->second.indices.begin();
+                it2 != it->second.indices.end();
+                ++it2)
+            names[*it2] = generate_unique_name(it->first);
+    }
+
+    // Generate a unique name for every empty string.
+    if (template_name_duplicates.size()) {
+        // At least one string ressembles to <template name>.
+        for (auto it = empty_names_indices.begin();
+                it != empty_names_indices.end(); ++it)
+            names[*it] = generate_unique_name(template_name_);
+    } else {
+        // No string alike <template name> exists.
+        size_t i = 0;
+        for (auto it = empty_names_indices.begin();
+                it != empty_names_indices.end(); ++it, ++i)
+            names[*it] = format_name(template_name_, i);
+    }
+}
+
+} // namespace HalfLife
+} // namespace MDL
+} // namespace Assimp
diff --git a/Engine/lib/assimp/code/AssetLib/MDL/HalfLife/UniqueNameGenerator.h b/Engine/lib/assimp/code/AssetLib/MDL/HalfLife/UniqueNameGenerator.h
new file mode 100644
index 000000000..73b6f9e74
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/MDL/HalfLife/UniqueNameGenerator.h
@@ -0,0 +1,81 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file UniqueNameGenerator.h
+ *  @brief Declaration of the unique name generator.
+ */
+
+#ifndef AI_UNIQUENAMEGENERATOR_INCLUDED
+#define AI_UNIQUENAMEGENERATOR_INCLUDED
+
+#include <string>
+#include <vector>
+
+namespace Assimp {
+namespace MDL {
+namespace HalfLife {
+
+class UniqueNameGenerator {
+public:
+    UniqueNameGenerator();
+    UniqueNameGenerator(const char *template_name);
+    UniqueNameGenerator(const char *template_name, const char *separator);
+    ~UniqueNameGenerator();
+
+    inline void set_template_name(const char *template_name) {
+        template_name_ = template_name;
+    }
+    inline void set_separator(const char *separator) {
+        separator_ = separator;
+    }
+
+    void make_unique(std::vector<std::string> &names);
+
+private:
+    std::string template_name_;
+    std::string separator_;
+};
+
+} // namespace HalfLife
+} // namespace MDL
+} // namespace Assimp
+
+#endif // AI_UNIQUENAMEGENERATOR_INCLUDED
diff --git a/Engine/lib/assimp/code/MDL/MDLDefaultColorMap.h b/Engine/lib/assimp/code/AssetLib/MDL/MDLDefaultColorMap.h
similarity index 99%
rename from Engine/lib/assimp/code/MDL/MDLDefaultColorMap.h
rename to Engine/lib/assimp/code/AssetLib/MDL/MDLDefaultColorMap.h
index 58f642884..2eecac2dc 100644
--- a/Engine/lib/assimp/code/MDL/MDLDefaultColorMap.h
+++ b/Engine/lib/assimp/code/AssetLib/MDL/MDLDefaultColorMap.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/MDL/MDLFileData.h b/Engine/lib/assimp/code/AssetLib/MDL/MDLFileData.h
similarity index 99%
rename from Engine/lib/assimp/code/MDL/MDLFileData.h
rename to Engine/lib/assimp/code/AssetLib/MDL/MDLFileData.h
index f33a57731..7ec2afe9a 100644
--- a/Engine/lib/assimp/code/MDL/MDLFileData.h
+++ b/Engine/lib/assimp/code/AssetLib/MDL/MDLFileData.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -696,14 +696,16 @@ struct GroupFrame
     //! 0 = simple frame, !0 = group frame
     int32_t type;
 
+    int32_t numframes;
+
     //! Minimum vertex for all single frames
     Vertex min;
 
     //! Maximum vertex for all single frames
     Vertex max;
 
-    //! Time for all single frames
-    float *time;
+    //! List of times for all single frames
+    float *times;
 
     //! List of single frames
     SimpleFrame *frames;
diff --git a/Engine/lib/assimp/code/MDL/MDLLoader.cpp b/Engine/lib/assimp/code/AssetLib/MDL/MDLLoader.cpp
similarity index 56%
rename from Engine/lib/assimp/code/MDL/MDLLoader.cpp
rename to Engine/lib/assimp/code/AssetLib/MDL/MDLLoader.cpp
index 9c9ce2330..9c9cf910c 100644
--- a/Engine/lib/assimp/code/MDL/MDLLoader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/MDL/MDLLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -48,18 +48,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_MDL_IMPORTER
 
-#include "MDL/MDLLoader.h"
-#include "MDL/MDLDefaultColorMap.h"
-#include "MD2/MD2FileData.h"
+#include "AssetLib/MDL/MDLLoader.h"
+#include "AssetLib/MD2/MD2FileData.h"
+#include "AssetLib/MDL/HalfLife/HL1MDLLoader.h"
+#include "AssetLib/MDL/MDLDefaultColorMap.h"
 
-#include <assimp/Macros.h>
-#include <assimp/qnan.h>
 #include <assimp/StringUtils.h>
-#include <assimp/Importer.hpp>
-#include <assimp/IOSystem.hpp>
+#include <assimp/importerdesc.h>
+#include <assimp/qnan.h>
 #include <assimp/scene.h>
 #include <assimp/DefaultLogger.hpp>
-#include <assimp/importerdesc.h>
+#include <assimp/IOSystem.hpp>
+#include <assimp/Importer.hpp>
 
 #include <memory>
 
@@ -80,24 +80,19 @@ static const aiImporterDesc desc = {
 
 // ------------------------------------------------------------------------------------------------
 // Ugly stuff ... nevermind
-#define _AI_MDL7_ACCESS(_data, _index, _limit, _type)               \
-    (*((const _type*)(((const char*)_data) + _index * _limit)))
+#define _AI_MDL7_ACCESS(_data, _index, _limit, _type) \
+    (*((const _type *)(((const char *)_data) + _index * _limit)))
 
-#define _AI_MDL7_ACCESS_PTR(_data, _index, _limit, _type)           \
-    ((BE_NCONST _type*)(((const char*)_data) + _index * _limit))
+#define _AI_MDL7_ACCESS_PTR(_data, _index, _limit, _type) \
+    ((BE_NCONST _type *)(((const char *)_data) + _index * _limit))
 
-#define _AI_MDL7_ACCESS_VERT(_data, _index, _limit)                 \
-    _AI_MDL7_ACCESS(_data,_index,_limit,MDL::Vertex_MDL7)
+#define _AI_MDL7_ACCESS_VERT(_data, _index, _limit) \
+    _AI_MDL7_ACCESS(_data, _index, _limit, MDL::Vertex_MDL7)
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-MDLImporter::MDLImporter()
-: configFrameID()
-, mBuffer()
-, iGSFileVersion()
-, pIOHandler()
-, pScene()
-, iFileSize() {
+MDLImporter::MDLImporter() :
+        configFrameID(), mBuffer(), iGSFileVersion(), mIOHandler(nullptr), pScene(), iFileSize() {
     // empty
 }
 
@@ -109,172 +104,205 @@ MDLImporter::~MDLImporter() {
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool MDLImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const {
-    const std::string extension = GetExtension(pFile);
-
-    // if check for extension is not enough, check for the magic tokens
-    if (extension == "mdl"  || !extension.length() || checkSig) {
-        uint32_t tokens[8];
-        tokens[0] = AI_MDL_MAGIC_NUMBER_LE_HL2a;
-        tokens[1] = AI_MDL_MAGIC_NUMBER_LE_HL2b;
-        tokens[2] = AI_MDL_MAGIC_NUMBER_LE_GS7;
-        tokens[3] = AI_MDL_MAGIC_NUMBER_LE_GS5b;
-        tokens[4] = AI_MDL_MAGIC_NUMBER_LE_GS5a;
-        tokens[5] = AI_MDL_MAGIC_NUMBER_LE_GS4;
-        tokens[6] = AI_MDL_MAGIC_NUMBER_LE_GS3;
-        tokens[7] = AI_MDL_MAGIC_NUMBER_LE;
-        return CheckMagicToken(pIOHandler,pFile,tokens,8,0);
-    }
-    return false;
+bool MDLImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
+    static const uint32_t tokens[] = {
+        AI_MDL_MAGIC_NUMBER_LE_HL2a,
+        AI_MDL_MAGIC_NUMBER_LE_HL2b,
+        AI_MDL_MAGIC_NUMBER_LE_GS7,
+        AI_MDL_MAGIC_NUMBER_LE_GS5b,
+        AI_MDL_MAGIC_NUMBER_LE_GS5a,
+        AI_MDL_MAGIC_NUMBER_LE_GS4,
+        AI_MDL_MAGIC_NUMBER_LE_GS3,
+        AI_MDL_MAGIC_NUMBER_LE
+    };
+    return CheckMagicToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup configuration properties
-void MDLImporter::SetupProperties(const Importer* pImp)
-{
-    configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_MDL_KEYFRAME,-1);
+void MDLImporter::SetupProperties(const Importer *pImp) {
+    configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_MDL_KEYFRAME, -1);
 
     // The
     // AI_CONFIG_IMPORT_MDL_KEYFRAME option overrides the
     // AI_CONFIG_IMPORT_GLOBAL_KEYFRAME option.
-    if(static_cast<unsigned int>(-1) == configFrameID)  {
-        configFrameID =  pImp->GetPropertyInteger(AI_CONFIG_IMPORT_GLOBAL_KEYFRAME,0);
+    if (static_cast<unsigned int>(-1) == configFrameID) {
+        configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_GLOBAL_KEYFRAME, 0);
     }
 
     // AI_CONFIG_IMPORT_MDL_COLORMAP - palette file
-    configPalette =  pImp->GetPropertyString(AI_CONFIG_IMPORT_MDL_COLORMAP,"colormap.lmp");
+    configPalette = pImp->GetPropertyString(AI_CONFIG_IMPORT_MDL_COLORMAP, "colormap.lmp");
+
+    // Read configuration specific to MDL (Half-Life 1).
+    mHL1ImportSettings.read_animations = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_ANIMATIONS, true);
+    if (mHL1ImportSettings.read_animations) {
+        mHL1ImportSettings.read_animation_events = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_ANIMATION_EVENTS, true);
+        mHL1ImportSettings.read_blend_controllers = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_BLEND_CONTROLLERS, true);
+        mHL1ImportSettings.read_sequence_transitions = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_SEQUENCE_TRANSITIONS, true);
+    }
+    mHL1ImportSettings.read_attachments = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_ATTACHMENTS, true);
+    mHL1ImportSettings.read_bone_controllers = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_BONE_CONTROLLERS, true);
+    mHL1ImportSettings.read_hitboxes = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_HITBOXES, true);
+    mHL1ImportSettings.read_misc_global_info = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_MISC_GLOBAL_INFO, true);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get a list of all supported extensions
-const aiImporterDesc* MDLImporter::GetInfo () const
-{
+const aiImporterDesc *MDLImporter::GetInfo() const {
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void MDLImporter::InternReadFile( const std::string& pFile,
-    aiScene* _pScene, IOSystem* _pIOHandler)
-{
-    pScene     = _pScene;
-    pIOHandler = _pIOHandler;
-    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile));
+void MDLImporter::InternReadFile(const std::string &pFile,
+        aiScene *_pScene, IOSystem *pIOHandler) {
+    pScene = _pScene;
+    mIOHandler = pIOHandler;
+    std::unique_ptr<IOStream> file(pIOHandler->Open(pFile));
 
     // Check whether we can read from the file
-    if( file.get() == NULL) {
-        throw DeadlyImportError( "Failed to open MDL file " + pFile + ".");
+    if (file.get() == nullptr) {
+        throw DeadlyImportError("Failed to open MDL file ", pFile, ".");
     }
 
     // This should work for all other types of MDL files, too ...
-    // the quake header is one of the smallest, afaik
+    // the HL1 sequence group header is one of the smallest, afaik
     iFileSize = (unsigned int)file->FileSize();
-    if( iFileSize < sizeof(MDL::Header)) {
-        throw DeadlyImportError( "MDL File is too small.");
+    if (iFileSize < sizeof(MDL::HalfLife::SequenceHeader_HL1)) {
+        throw DeadlyImportError("MDL File is too small.");
     }
 
-    // Allocate storage and copy the contents of the file to a memory buffer
-    mBuffer =new unsigned char[iFileSize+1];
-    file->Read( (void*)mBuffer, 1, iFileSize);
+    // delete the file buffer and cleanup.
+    auto DeleteBufferAndCleanup = [&]() {
+        if (mBuffer) {
+            delete[] mBuffer;
+            mBuffer = nullptr;
+        }
+        AI_DEBUG_INVALIDATE_PTR(mIOHandler);
+        AI_DEBUG_INVALIDATE_PTR(pScene);
+    };
 
-    // Append a binary zero to the end of the buffer.
-    // this is just for safety that string parsing routines
-    // find the end of the buffer ...
-    mBuffer[iFileSize] = '\0';
-    const uint32_t iMagicWord = *((uint32_t*)mBuffer);
+    try {
+        // Allocate storage and copy the contents of the file to a memory buffer
+        mBuffer = new unsigned char[iFileSize + 1];
+        file->Read((void *)mBuffer, 1, iFileSize);
 
-    // Determine the file subtype and call the appropriate member function
+        // Append a binary zero to the end of the buffer.
+        // this is just for safety that string parsing routines
+        // find the end of the buffer ...
+        mBuffer[iFileSize] = '\0';
+        const uint32_t iMagicWord = *((uint32_t *)mBuffer);
 
-    // Original Quake1 format
-    if (AI_MDL_MAGIC_NUMBER_BE == iMagicWord || AI_MDL_MAGIC_NUMBER_LE == iMagicWord)   {
-        ASSIMP_LOG_DEBUG("MDL subtype: Quake 1, magic word is IDPO");
-        iGSFileVersion = 0;
-        InternReadFile_Quake1();
-    }
-    // GameStudio A<old> MDL2 format - used by some test models that come with 3DGS
-    else if (AI_MDL_MAGIC_NUMBER_BE_GS3 == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS3 == iMagicWord)  {
-        ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A2, magic word is MDL2");
-        iGSFileVersion = 2;
-        InternReadFile_Quake1();
-    }
-    // GameStudio A4 MDL3 format
-    else if (AI_MDL_MAGIC_NUMBER_BE_GS4 == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS4 == iMagicWord)  {
-        ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A4, magic word is MDL3");
-        iGSFileVersion = 3;
-        InternReadFile_3DGS_MDL345();
-    }
-    // GameStudio A5+ MDL4 format
-    else if (AI_MDL_MAGIC_NUMBER_BE_GS5a == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS5a == iMagicWord)    {
-        ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A4, magic word is MDL4");
-        iGSFileVersion = 4;
-        InternReadFile_3DGS_MDL345();
-    }
-    // GameStudio A5+ MDL5 format
-    else if (AI_MDL_MAGIC_NUMBER_BE_GS5b == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS5b == iMagicWord)    {
-        ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A5, magic word is MDL5");
-        iGSFileVersion = 5;
-        InternReadFile_3DGS_MDL345();
-    }
-    // GameStudio A7 MDL7 format
-    else if (AI_MDL_MAGIC_NUMBER_BE_GS7 == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS7 == iMagicWord)  {
-        ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A7, magic word is MDL7");
-        iGSFileVersion = 7;
-        InternReadFile_3DGS_MDL7();
-    }
-    // IDST/IDSQ Format (CS:S/HL^2, etc ...)
-    else if (AI_MDL_MAGIC_NUMBER_BE_HL2a == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_HL2a == iMagicWord ||
-        AI_MDL_MAGIC_NUMBER_BE_HL2b == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_HL2b == iMagicWord)
-    {
-        ASSIMP_LOG_DEBUG("MDL subtype: Source(tm) Engine, magic word is IDST/IDSQ");
-        iGSFileVersion = 0;
-        InternReadFile_HL2();
-    }
-    else    {
-        // print the magic word to the log file
-        throw DeadlyImportError( "Unknown MDL subformat " + pFile +
-            ". Magic word (" + std::string((char*)&iMagicWord,4) + ") is not known");
-    }
+        // Determine the file subtype and call the appropriate member function
+        bool is_half_life = false;
 
-    // Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system
-    pScene->mRootNode->mTransformation = aiMatrix4x4(1.f,0.f,0.f,0.f,
-        0.f,0.f,1.f,0.f,0.f,-1.f,0.f,0.f,0.f,0.f,0.f,1.f);
+        // Original Quake1 format
+        if (AI_MDL_MAGIC_NUMBER_BE == iMagicWord || AI_MDL_MAGIC_NUMBER_LE == iMagicWord) {
+            ASSIMP_LOG_DEBUG("MDL subtype: Quake 1, magic word is IDPO");
+            iGSFileVersion = 0;
+            InternReadFile_Quake1();
+        }
+        // GameStudio A<old> MDL2 format - used by some test models that come with 3DGS
+        else if (AI_MDL_MAGIC_NUMBER_BE_GS3 == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS3 == iMagicWord) {
+            ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A2, magic word is MDL2");
+            iGSFileVersion = 2;
+            InternReadFile_Quake1();
+        }
+        // GameStudio A4 MDL3 format
+        else if (AI_MDL_MAGIC_NUMBER_BE_GS4 == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS4 == iMagicWord) {
+            ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A4, magic word is MDL3");
+            iGSFileVersion = 3;
+            InternReadFile_3DGS_MDL345();
+        }
+        // GameStudio A5+ MDL4 format
+        else if (AI_MDL_MAGIC_NUMBER_BE_GS5a == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS5a == iMagicWord) {
+            ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A4, magic word is MDL4");
+            iGSFileVersion = 4;
+            InternReadFile_3DGS_MDL345();
+        }
+        // GameStudio A5+ MDL5 format
+        else if (AI_MDL_MAGIC_NUMBER_BE_GS5b == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS5b == iMagicWord) {
+            ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A5, magic word is MDL5");
+            iGSFileVersion = 5;
+            InternReadFile_3DGS_MDL345();
+        }
+        // GameStudio A7 MDL7 format
+        else if (AI_MDL_MAGIC_NUMBER_BE_GS7 == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS7 == iMagicWord) {
+            ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A7, magic word is MDL7");
+            iGSFileVersion = 7;
+            InternReadFile_3DGS_MDL7();
+        }
+        // IDST/IDSQ Format (CS:S/HL^2, etc ...)
+        else if (AI_MDL_MAGIC_NUMBER_BE_HL2a == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_HL2a == iMagicWord ||
+                 AI_MDL_MAGIC_NUMBER_BE_HL2b == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_HL2b == iMagicWord) {
+            iGSFileVersion = 0;
+            is_half_life = true;
 
-    // delete the file buffer and cleanup
-    delete [] mBuffer;
-    mBuffer= nullptr;
-    AI_DEBUG_INVALIDATE_PTR(pIOHandler);
-    AI_DEBUG_INVALIDATE_PTR(pScene);
+            HalfLife::HalfLifeMDLBaseHeader *pHeader = (HalfLife::HalfLifeMDLBaseHeader *)mBuffer;
+            if (pHeader->version == AI_MDL_HL1_VERSION) {
+                ASSIMP_LOG_DEBUG("MDL subtype: Half-Life 1/Goldsrc Engine, magic word is IDST/IDSQ");
+                InternReadFile_HL1(pFile, iMagicWord);
+            } else {
+                ASSIMP_LOG_DEBUG("MDL subtype: Source(tm) Engine, magic word is IDST/IDSQ");
+                InternReadFile_HL2();
+            }
+        } else {
+            // print the magic word to the log file
+            throw DeadlyImportError("Unknown MDL subformat ", pFile,
+                                    ". Magic word (", ai_str_toprintable((const char *)&iMagicWord, sizeof(iMagicWord)), ") is not known");
+        }
+
+        if (is_half_life){
+            // Now rotate the whole scene 90 degrees around the z and x axes to convert to internal coordinate system
+            pScene->mRootNode->mTransformation = aiMatrix4x4(
+                    0.f, -1.f, 0.f, 0.f,
+                    0.f, 0.f, 1.f, 0.f,
+                    -1.f, 0.f, 0.f, 0.f,
+                    0.f, 0.f, 0.f, 1.f);
+        }
+        else {
+            // Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system
+            pScene->mRootNode->mTransformation = aiMatrix4x4(1.f, 0.f, 0.f, 0.f,
+                    0.f, 0.f, 1.f, 0.f, 0.f, -1.f, 0.f, 0.f, 0.f, 0.f, 0.f, 1.f);
+        }
+
+        DeleteBufferAndCleanup();
+    } catch (...) {
+        DeleteBufferAndCleanup();
+        throw;
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Check whether we're still inside the valid file range
-void MDLImporter::SizeCheck(const void* szPos)
-{
-    if (!szPos || (const unsigned char*)szPos > this->mBuffer + this->iFileSize)
-    {
+void MDLImporter::SizeCheck(const void *szPos) {
+    if (!szPos || (const unsigned char *)szPos > this->mBuffer + this->iFileSize) {
         throw DeadlyImportError("Invalid MDL file. The file is too small "
-            "or contains invalid data.");
+                                "or contains invalid data.");
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Just for debugging purposes
-void MDLImporter::SizeCheck(const void* szPos, const char* szFile, unsigned int iLine)
-{
-    ai_assert(NULL != szFile);
-    if (!szPos || (const unsigned char*)szPos > mBuffer + iFileSize)
-    {
+void MDLImporter::SizeCheck(const void *szPos, const char *szFile, unsigned int iLine) {
+    ai_assert(nullptr != szFile);
+    if (!szPos || (const unsigned char *)szPos > mBuffer + iFileSize) {
         // remove a directory if there is one
-        const char* szFilePtr = ::strrchr(szFile,'\\');
+        const char *szFilePtr = ::strrchr(szFile, '\\');
         if (!szFilePtr) {
-            if(!(szFilePtr = ::strrchr(szFile,'/')))
+            szFilePtr = ::strrchr(szFile, '/');
+            if (nullptr == szFilePtr) {
                 szFilePtr = szFile;
+            }
+        }
+        if (szFilePtr) {
+            ++szFilePtr;
         }
-        if (szFilePtr)++szFilePtr;
 
         char szBuffer[1024];
-        ::sprintf(szBuffer,"Invalid MDL file. The file is too small "
-            "or contains invalid data (File: %s Line: %u)",szFilePtr,iLine);
+        ::sprintf(szBuffer, "Invalid MDL file. The file is too small "
+                            "or contains invalid data (File: %s Line: %u)",
+                szFilePtr, iLine);
 
         throw DeadlyImportError(szBuffer);
     }
@@ -282,21 +310,19 @@ void MDLImporter::SizeCheck(const void* szPos, const char* szFile, unsigned int
 
 // ------------------------------------------------------------------------------------------------
 // Validate a quake file header
-void MDLImporter::ValidateHeader_Quake1(const MDL::Header* pcHeader)
-{
-    // some values may not be NULL
+void MDLImporter::ValidateHeader_Quake1(const MDL::Header *pcHeader) {
+    // some values may not be nullptr
     if (!pcHeader->num_frames)
-        throw DeadlyImportError( "[Quake 1 MDL] There are no frames in the file");
+        throw DeadlyImportError("[Quake 1 MDL] There are no frames in the file");
 
     if (!pcHeader->num_verts)
-        throw DeadlyImportError( "[Quake 1 MDL] There are no vertices in the file");
+        throw DeadlyImportError("[Quake 1 MDL] There are no vertices in the file");
 
     if (!pcHeader->num_tris)
-        throw DeadlyImportError( "[Quake 1 MDL] There are no triangles in the file");
+        throw DeadlyImportError("[Quake 1 MDL] There are no triangles in the file");
 
     // check whether the maxima are exceeded ...however, this applies for Quake 1 MDLs only
-    if (!this->iGSFileVersion)
-    {
+    if (!this->iGSFileVersion) {
         if (pcHeader->num_verts > AI_MDL_MAX_VERTS)
             ASSIMP_LOG_WARN("Quake 1 MDL model has more than AI_MDL_MAX_VERTS vertices");
 
@@ -309,42 +335,40 @@ void MDLImporter::ValidateHeader_Quake1(const MDL::Header* pcHeader)
         // (this does not apply for 3DGS MDLs)
         if (!this->iGSFileVersion && pcHeader->version != AI_MDL_VERSION)
             ASSIMP_LOG_WARN("Quake 1 MDL model has an unknown version: AI_MDL_VERSION (=6) is "
-                "the expected file format version");
-        if(pcHeader->num_skins && (!pcHeader->skinwidth || !pcHeader->skinheight))
+                            "the expected file format version");
+        if (pcHeader->num_skins && (!pcHeader->skinwidth || !pcHeader->skinheight))
             ASSIMP_LOG_WARN("Skin width or height are 0");
     }
 }
 
 #ifdef AI_BUILD_BIG_ENDIAN
 // ------------------------------------------------------------------------------------------------
-void FlipQuakeHeader(BE_NCONST MDL::Header* pcHeader)
-{
-    AI_SWAP4( pcHeader->ident);
-    AI_SWAP4( pcHeader->version);
-    AI_SWAP4( pcHeader->boundingradius);
-    AI_SWAP4( pcHeader->flags);
-    AI_SWAP4( pcHeader->num_frames);
-    AI_SWAP4( pcHeader->num_skins);
-    AI_SWAP4( pcHeader->num_tris);
-    AI_SWAP4( pcHeader->num_verts);
-    for (unsigned int i = 0; i < 3;++i)
-    {
-        AI_SWAP4( pcHeader->scale[i]);
-        AI_SWAP4( pcHeader->translate[i]);
+void FlipQuakeHeader(BE_NCONST MDL::Header *pcHeader) {
+    AI_SWAP4(pcHeader->ident);
+    AI_SWAP4(pcHeader->version);
+    AI_SWAP4(pcHeader->boundingradius);
+    AI_SWAP4(pcHeader->flags);
+    AI_SWAP4(pcHeader->num_frames);
+    AI_SWAP4(pcHeader->num_skins);
+    AI_SWAP4(pcHeader->num_tris);
+    AI_SWAP4(pcHeader->num_verts);
+    for (unsigned int i = 0; i < 3; ++i) {
+        AI_SWAP4(pcHeader->scale[i]);
+        AI_SWAP4(pcHeader->translate[i]);
     }
-    AI_SWAP4( pcHeader->size);
-    AI_SWAP4( pcHeader->skinheight);
-    AI_SWAP4( pcHeader->skinwidth);
-    AI_SWAP4( pcHeader->synctype);
+    AI_SWAP4(pcHeader->size);
+    AI_SWAP4(pcHeader->skinheight);
+    AI_SWAP4(pcHeader->skinwidth);
+    AI_SWAP4(pcHeader->synctype);
 }
 #endif
 
 // ------------------------------------------------------------------------------------------------
 // Read a Quake 1 file
 void MDLImporter::InternReadFile_Quake1() {
-    ai_assert(NULL != pScene);
+    ai_assert(nullptr != pScene);
 
-    BE_NCONST MDL::Header *pcHeader = (BE_NCONST MDL::Header*)this->mBuffer;
+    BE_NCONST MDL::Header *pcHeader = (BE_NCONST MDL::Header *)this->mBuffer;
 
 #ifdef AI_BUILD_BIG_ENDIAN
     FlipQuakeHeader(pcHeader);
@@ -353,24 +377,24 @@ void MDLImporter::InternReadFile_Quake1() {
     ValidateHeader_Quake1(pcHeader);
 
     // current cursor position in the file
-    const unsigned char* szCurrent = (const unsigned char*)(pcHeader+1);
+    const unsigned char *szCurrent = (const unsigned char *)(pcHeader + 1);
 
     // need to read all textures
-    for ( unsigned int i = 0; i < (unsigned int)pcHeader->num_skins; ++i) {
+    for (unsigned int i = 0; i < (unsigned int)pcHeader->num_skins; ++i) {
         union {
-            BE_NCONST MDL::Skin* pcSkin;
-            BE_NCONST MDL::GroupSkin* pcGroupSkin;
+            BE_NCONST MDL::Skin *pcSkin;
+            BE_NCONST MDL::GroupSkin *pcGroupSkin;
         };
         if (szCurrent + sizeof(MDL::Skin) > this->mBuffer + this->iFileSize) {
             throw DeadlyImportError("[Quake 1 MDL] Unexpected EOF");
         }
-        pcSkin = (BE_NCONST MDL::Skin*)szCurrent;
+        pcSkin = (BE_NCONST MDL::Skin *)szCurrent;
 
-        AI_SWAP4( pcSkin->group );
+        AI_SWAP4(pcSkin->group);
 
         // Quake 1 group-skins
         if (1 == pcSkin->group) {
-            AI_SWAP4( pcGroupSkin->nb );
+            AI_SWAP4(pcGroupSkin->nb);
 
             // need to skip multiple images
             const unsigned int iNumImages = (unsigned int)pcGroupSkin->nb;
@@ -383,53 +407,52 @@ void MDLImporter::InternReadFile_Quake1() {
                 }
                 // go to the end of the skin section / the beginning of the next skin
                 szCurrent += pcHeader->skinheight * pcHeader->skinwidth +
-                    sizeof(float) * iNumImages;
+                             sizeof(float) * iNumImages;
             }
         } else {
             szCurrent += sizeof(uint32_t);
             unsigned int iSkip = i ? UINT_MAX : 0;
-            CreateTexture_3DGS_MDL4(szCurrent,pcSkin->group,&iSkip);
+            CreateTexture_3DGS_MDL4(szCurrent, pcSkin->group, &iSkip);
             szCurrent += iSkip;
         }
     }
     // get a pointer to the texture coordinates
-    BE_NCONST MDL::TexCoord* pcTexCoords = (BE_NCONST MDL::TexCoord*)szCurrent;
+    BE_NCONST MDL::TexCoord *pcTexCoords = (BE_NCONST MDL::TexCoord *)szCurrent;
     szCurrent += sizeof(MDL::TexCoord) * pcHeader->num_verts;
 
     // get a pointer to the triangles
-    BE_NCONST MDL::Triangle* pcTriangles = (BE_NCONST MDL::Triangle*)szCurrent;
+    BE_NCONST MDL::Triangle *pcTriangles = (BE_NCONST MDL::Triangle *)szCurrent;
     szCurrent += sizeof(MDL::Triangle) * pcHeader->num_tris;
     VALIDATE_FILE_SIZE(szCurrent);
 
     // now get a pointer to the first frame in the file
-    BE_NCONST MDL::Frame* pcFrames = (BE_NCONST MDL::Frame*)szCurrent;
-    MDL::SimpleFrame* pcFirstFrame;
+    BE_NCONST MDL::Frame *pcFrames = (BE_NCONST MDL::Frame *)szCurrent;
+    MDL::SimpleFrame *pcFirstFrame;
 
     if (0 == pcFrames->type) {
         // get address of single frame
-        pcFirstFrame =( MDL::SimpleFrame*) &pcFrames->frame;
+        pcFirstFrame = (MDL::SimpleFrame *)&pcFrames->frame;
     } else {
         // get the first frame in the group
-        BE_NCONST MDL::GroupFrame* pcFrames2 = (BE_NCONST MDL::GroupFrame*) pcFrames;
-        pcFirstFrame = &(pcFrames2->frames[0]);
+        BE_NCONST MDL::GroupFrame *pcFrames2 = (BE_NCONST MDL::GroupFrame *)szCurrent;
+        pcFirstFrame = (MDL::SimpleFrame *)( szCurrent + sizeof(MDL::GroupFrame::type) + sizeof(MDL::GroupFrame::numframes)
+        + sizeof(MDL::GroupFrame::min) + sizeof(MDL::GroupFrame::max) + sizeof(*MDL::GroupFrame::times) * pcFrames2->numframes );
     }
-    BE_NCONST MDL::Vertex* pcVertices = (BE_NCONST MDL::Vertex*) ((pcFirstFrame->name) + sizeof(pcFirstFrame->name));
-    VALIDATE_FILE_SIZE((const unsigned char*)(pcVertices + pcHeader->num_verts));
+    BE_NCONST MDL::Vertex *pcVertices = (BE_NCONST MDL::Vertex *)((pcFirstFrame->name) + sizeof(pcFirstFrame->name));
+    VALIDATE_FILE_SIZE((const unsigned char *)(pcVertices + pcHeader->num_verts));
 
 #ifdef AI_BUILD_BIG_ENDIAN
-    for (int i = 0; i<pcHeader->num_verts;++i)
-    {
-        AI_SWAP4( pcTexCoords[i].onseam );
-        AI_SWAP4( pcTexCoords[i].s );
-        AI_SWAP4( pcTexCoords[i].t );
+    for (int i = 0; i < pcHeader->num_verts; ++i) {
+        AI_SWAP4(pcTexCoords[i].onseam);
+        AI_SWAP4(pcTexCoords[i].s);
+        AI_SWAP4(pcTexCoords[i].t);
     }
 
-    for (int i = 0; i<pcHeader->num_tris;++i)
-    {
-        AI_SWAP4( pcTriangles[i].facesfront);
-        AI_SWAP4( pcTriangles[i].vertex[0]);
-        AI_SWAP4( pcTriangles[i].vertex[1]);
-        AI_SWAP4( pcTriangles[i].vertex[2]);
+    for (int i = 0; i < pcHeader->num_tris; ++i) {
+        AI_SWAP4(pcTriangles[i].facesfront);
+        AI_SWAP4(pcTriangles[i].vertex[0]);
+        AI_SWAP4(pcTriangles[i].vertex[1]);
+        AI_SWAP4(pcTriangles[i].vertex[2]);
     }
 #endif
 
@@ -437,7 +460,7 @@ void MDLImporter::InternReadFile_Quake1() {
     SetupMaterialProperties_3DGS_MDL5_Quake1();
 
     // allocate enough storage to hold all vertices and triangles
-    aiMesh* pcMesh = new aiMesh();
+    aiMesh *pcMesh = new aiMesh();
 
     pcMesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
     pcMesh->mNumVertices = pcHeader->num_tris * 3;
@@ -454,30 +477,27 @@ void MDLImporter::InternReadFile_Quake1() {
     pScene->mRootNode->mMeshes = new unsigned int[1];
     pScene->mRootNode->mMeshes[0] = 0;
     pScene->mNumMeshes = 1;
-    pScene->mMeshes = new aiMesh*[1];
+    pScene->mMeshes = new aiMesh *[1];
     pScene->mMeshes[0] = pcMesh;
 
     // now iterate through all triangles
     unsigned int iCurrent = 0;
-    for (unsigned int i = 0; i < (unsigned int) pcHeader->num_tris;++i)
-    {
+    for (unsigned int i = 0; i < (unsigned int)pcHeader->num_tris; ++i) {
         pcMesh->mFaces[i].mIndices = new unsigned int[3];
         pcMesh->mFaces[i].mNumIndices = 3;
 
         unsigned int iTemp = iCurrent;
-        for (unsigned int c = 0; c < 3;++c,++iCurrent)
-        {
+        for (unsigned int c = 0; c < 3; ++c, ++iCurrent) {
             pcMesh->mFaces[i].mIndices[c] = iCurrent;
 
             // read vertices
             unsigned int iIndex = pcTriangles->vertex[c];
-            if (iIndex >= (unsigned int)pcHeader->num_verts)
-            {
-                iIndex = pcHeader->num_verts-1;
+            if (iIndex >= (unsigned int)pcHeader->num_verts) {
+                iIndex = pcHeader->num_verts - 1;
                 ASSIMP_LOG_WARN("Index overflow in Q1-MDL vertex list.");
             }
 
-            aiVector3D& vec = pcMesh->mVertices[iCurrent];
+            aiVector3D &vec = pcMesh->mVertices[iCurrent];
             vec.x = (float)pcVertices[iIndex].v[0] * pcHeader->scale[0];
             vec.x += pcHeader->translate[0];
 
@@ -489,7 +509,7 @@ void MDLImporter::InternReadFile_Quake1() {
             vec.z += pcHeader->translate[2];
 
             // read the normal vector from the precalculated normal table
-            MD2::LookupNormalIndex(pcVertices[iIndex].normalIndex,pcMesh->mNormals[iCurrent]);
+            MD2::LookupNormalIndex(pcVertices[iIndex].normalIndex, pcMesh->mNormals[iCurrent]);
             //pcMesh->mNormals[iCurrent].y *= -1.0f;
 
             // read texture coordinates
@@ -497,18 +517,17 @@ void MDLImporter::InternReadFile_Quake1() {
             float t = (float)pcTexCoords[iIndex].t;
 
             // translate texture coordinates
-            if (0 == pcTriangles->facesfront && 0 != pcTexCoords[iIndex].onseam)    {
+            if (0 == pcTriangles->facesfront && 0 != pcTexCoords[iIndex].onseam) {
                 s += pcHeader->skinwidth * 0.5f;
             }
 
             // Scale s and t to range from 0.0 to 1.0
             pcMesh->mTextureCoords[0][iCurrent].x = (s + 0.5f) / pcHeader->skinwidth;
-            pcMesh->mTextureCoords[0][iCurrent].y = 1.0f-(t + 0.5f) / pcHeader->skinheight;
-
+            pcMesh->mTextureCoords[0][iCurrent].y = 1.0f - (t + 0.5f) / pcHeader->skinheight;
         }
-        pcMesh->mFaces[i].mIndices[0] = iTemp+2;
-        pcMesh->mFaces[i].mIndices[1] = iTemp+1;
-        pcMesh->mFaces[i].mIndices[2] = iTemp+0;
+        pcMesh->mFaces[i].mIndices[0] = iTemp + 2;
+        pcMesh->mFaces[i].mIndices[1] = iTemp + 1;
+        pcMesh->mFaces[i].mIndices[2] = iTemp + 0;
         pcTriangles++;
     }
     return;
@@ -516,113 +535,109 @@ void MDLImporter::InternReadFile_Quake1() {
 
 // ------------------------------------------------------------------------------------------------
 // Setup material properties for Quake and older GameStudio files
-void MDLImporter::SetupMaterialProperties_3DGS_MDL5_Quake1( )
-{
-    const MDL::Header* const pcHeader = (const MDL::Header*)this->mBuffer;
+void MDLImporter::SetupMaterialProperties_3DGS_MDL5_Quake1() {
+    const MDL::Header *const pcHeader = (const MDL::Header *)this->mBuffer;
 
     // allocate ONE material
-    pScene->mMaterials    = new aiMaterial*[1];
+    pScene->mMaterials = new aiMaterial *[1];
     pScene->mMaterials[0] = new aiMaterial();
     pScene->mNumMaterials = 1;
 
     // setup the material's properties
     const int iMode = (int)aiShadingMode_Gouraud;
-    aiMaterial* const pcHelper = (aiMaterial*)pScene->mMaterials[0];
+    aiMaterial *const pcHelper = (aiMaterial *)pScene->mMaterials[0];
     pcHelper->AddProperty<int>(&iMode, 1, AI_MATKEY_SHADING_MODEL);
 
     aiColor4D clr;
-    if (0 != pcHeader->num_skins && pScene->mNumTextures)   {
+    if (0 != pcHeader->num_skins && pScene->mNumTextures) {
         // can we replace the texture with a single color?
         clr = this->ReplaceTextureWithColor(pScene->mTextures[0]);
         if (is_not_qnan(clr.r)) {
             delete pScene->mTextures[0];
             delete[] pScene->mTextures;
 
-            pScene->mTextures = NULL;
+            pScene->mTextures = nullptr;
             pScene->mNumTextures = 0;
-        }
-        else    {
+        } else {
             clr.b = clr.a = clr.g = clr.r = 1.0f;
             aiString szString;
-            ::memcpy(szString.data,AI_MAKE_EMBEDDED_TEXNAME(0),3);
+            ::memcpy(szString.data, AI_MAKE_EMBEDDED_TEXNAME(0), 3);
             szString.length = 2;
-            pcHelper->AddProperty(&szString,AI_MATKEY_TEXTURE_DIFFUSE(0));
+            pcHelper->AddProperty(&szString, AI_MATKEY_TEXTURE_DIFFUSE(0));
         }
     }
 
-    pcHelper->AddProperty<aiColor4D>(&clr, 1,AI_MATKEY_COLOR_DIFFUSE);
-    pcHelper->AddProperty<aiColor4D>(&clr, 1,AI_MATKEY_COLOR_SPECULAR);
+    pcHelper->AddProperty<aiColor4D>(&clr, 1, AI_MATKEY_COLOR_DIFFUSE);
+    pcHelper->AddProperty<aiColor4D>(&clr, 1, AI_MATKEY_COLOR_SPECULAR);
 
-    clr.r *= 0.05f;clr.g *= 0.05f;
-    clr.b *= 0.05f;clr.a  = 1.0f;
-    pcHelper->AddProperty<aiColor4D>(&clr, 1,AI_MATKEY_COLOR_AMBIENT);
+    clr.r *= 0.05f;
+    clr.g *= 0.05f;
+    clr.b *= 0.05f;
+    clr.a = 1.0f;
+    pcHelper->AddProperty<aiColor4D>(&clr, 1, AI_MATKEY_COLOR_AMBIENT);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Read a MDL 3,4,5 file
-void MDLImporter::InternReadFile_3DGS_MDL345( )
-{
-    ai_assert(NULL != pScene);
+void MDLImporter::InternReadFile_3DGS_MDL345() {
+    ai_assert(nullptr != pScene);
 
     // the header of MDL 3/4/5 is nearly identical to the original Quake1 header
-    BE_NCONST MDL::Header *pcHeader = (BE_NCONST MDL::Header*)this->mBuffer;
+    BE_NCONST MDL::Header *pcHeader = (BE_NCONST MDL::Header *)this->mBuffer;
 #ifdef AI_BUILD_BIG_ENDIAN
     FlipQuakeHeader(pcHeader);
 #endif
     ValidateHeader_Quake1(pcHeader);
 
     // current cursor position in the file
-    const unsigned char* szCurrent = (const unsigned char*)(pcHeader+1);
-    const unsigned char* szEnd = mBuffer + iFileSize;
+    const unsigned char *szCurrent = (const unsigned char *)(pcHeader + 1);
+    const unsigned char *szEnd = mBuffer + iFileSize;
 
     // need to read all textures
-    for (unsigned int i = 0; i < (unsigned int)pcHeader->num_skins;++i) {
-        if (szCurrent >= szEnd) {
-            throw DeadlyImportError( "Texture data past end of file.");
+    for (unsigned int i = 0; i < (unsigned int)pcHeader->num_skins; ++i) {
+        if (szCurrent + sizeof(uint32_t) > szEnd) {
+            throw DeadlyImportError("Texture data past end of file.");
         }
-        BE_NCONST MDL::Skin* pcSkin;
-        pcSkin = (BE_NCONST  MDL::Skin*)szCurrent;
-        AI_SWAP4( pcSkin->group);
+        BE_NCONST MDL::Skin *pcSkin;
+        pcSkin = (BE_NCONST MDL::Skin *)szCurrent;
+        AI_SWAP4(pcSkin->group);
         // create one output image
         unsigned int iSkip = i ? UINT_MAX : 0;
-        if (5 <= iGSFileVersion)
-        {
+        if (5 <= iGSFileVersion) {
             // MDL5 format could contain MIPmaps
-            CreateTexture_3DGS_MDL5((unsigned char*)pcSkin + sizeof(uint32_t),
-                pcSkin->group,&iSkip);
-        }
-        else    {
-            CreateTexture_3DGS_MDL4((unsigned char*)pcSkin + sizeof(uint32_t),
-                pcSkin->group,&iSkip);
+            CreateTexture_3DGS_MDL5((unsigned char *)pcSkin + sizeof(uint32_t),
+                    pcSkin->group, &iSkip);
+        } else {
+            CreateTexture_3DGS_MDL4((unsigned char *)pcSkin + sizeof(uint32_t),
+                    pcSkin->group, &iSkip);
         }
         // need to skip one image
         szCurrent += iSkip + sizeof(uint32_t);
-
     }
     // get a pointer to the texture coordinates
-    BE_NCONST MDL::TexCoord_MDL3* pcTexCoords = (BE_NCONST MDL::TexCoord_MDL3*)szCurrent;
+    BE_NCONST MDL::TexCoord_MDL3 *pcTexCoords = (BE_NCONST MDL::TexCoord_MDL3 *)szCurrent;
     szCurrent += sizeof(MDL::TexCoord_MDL3) * pcHeader->synctype;
 
     // NOTE: for MDLn formats "synctype" corresponds to the number of UV coords
 
     // get a pointer to the triangles
-    BE_NCONST MDL::Triangle_MDL3* pcTriangles = (BE_NCONST MDL::Triangle_MDL3*)szCurrent;
+    BE_NCONST MDL::Triangle_MDL3 *pcTriangles = (BE_NCONST MDL::Triangle_MDL3 *)szCurrent;
     szCurrent += sizeof(MDL::Triangle_MDL3) * pcHeader->num_tris;
 
 #ifdef AI_BUILD_BIG_ENDIAN
 
-    for (int i = 0; i<pcHeader->synctype;++i)   {
-        AI_SWAP2( pcTexCoords[i].u );
-        AI_SWAP2( pcTexCoords[i].v );
+    for (int i = 0; i < pcHeader->synctype; ++i) {
+        AI_SWAP2(pcTexCoords[i].u);
+        AI_SWAP2(pcTexCoords[i].v);
     }
 
-    for (int i = 0; i<pcHeader->num_tris;++i)   {
-        AI_SWAP2( pcTriangles[i].index_xyz[0]);
-        AI_SWAP2( pcTriangles[i].index_xyz[1]);
-        AI_SWAP2( pcTriangles[i].index_xyz[2]);
-        AI_SWAP2( pcTriangles[i].index_uv[0]);
-        AI_SWAP2( pcTriangles[i].index_uv[1]);
-        AI_SWAP2( pcTriangles[i].index_uv[2]);
+    for (int i = 0; i < pcHeader->num_tris; ++i) {
+        AI_SWAP2(pcTriangles[i].index_xyz[0]);
+        AI_SWAP2(pcTriangles[i].index_xyz[1]);
+        AI_SWAP2(pcTriangles[i].index_xyz[2]);
+        AI_SWAP2(pcTriangles[i].index_uv[0]);
+        AI_SWAP2(pcTriangles[i].index_uv[1]);
+        AI_SWAP2(pcTriangles[i].index_uv[2]);
     }
 
 #endif
@@ -633,7 +648,7 @@ void MDLImporter::InternReadFile_3DGS_MDL345( )
     SetupMaterialProperties_3DGS_MDL5_Quake1();
 
     // allocate enough storage to hold all vertices and triangles
-    aiMesh* pcMesh = new aiMesh();
+    aiMesh *pcMesh = new aiMesh();
     pcMesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
 
     pcMesh->mNumVertices = pcHeader->num_tris * 3;
@@ -646,13 +661,13 @@ void MDLImporter::InternReadFile_3DGS_MDL345( )
     pScene->mRootNode->mMeshes = new unsigned int[1];
     pScene->mRootNode->mMeshes[0] = 0;
     pScene->mNumMeshes = 1;
-    pScene->mMeshes = new aiMesh*[1];
+    pScene->mMeshes = new aiMesh *[1];
     pScene->mMeshes[0] = pcMesh;
 
     // allocate output storage
-    pcMesh->mNumVertices = (unsigned int)pcHeader->num_tris*3;
-    pcMesh->mVertices    = new aiVector3D[pcMesh->mNumVertices];
-    pcMesh->mNormals     = new aiVector3D[pcMesh->mNumVertices];
+    pcMesh->mNumVertices = (unsigned int)pcHeader->num_tris * 3;
+    pcMesh->mVertices = new aiVector3D[pcMesh->mNumVertices];
+    pcMesh->mNormals = new aiVector3D[pcMesh->mNumVertices];
 
     if (pcHeader->synctype) {
         pcMesh->mTextureCoords[0] = new aiVector3D[pcMesh->mNumVertices];
@@ -660,35 +675,35 @@ void MDLImporter::InternReadFile_3DGS_MDL345( )
     }
 
     // now get a pointer to the first frame in the file
-    BE_NCONST MDL::Frame* pcFrames = (BE_NCONST MDL::Frame*)szCurrent;
+    BE_NCONST MDL::Frame *pcFrames = (BE_NCONST MDL::Frame *)szCurrent;
     AI_SWAP4(pcFrames->type);
 
     // byte packed vertices
     // FIXME: these two snippets below are almost identical ... join them?
     /////////////////////////////////////////////////////////////////////////////////////
-    if (0 == pcFrames->type || 3 >= this->iGSFileVersion)   {
+    if (0 == pcFrames->type || 3 >= this->iGSFileVersion) {
 
-        const MDL::SimpleFrame* pcFirstFrame = (const MDL::SimpleFrame*)(szCurrent + sizeof(uint32_t));
-        const MDL::Vertex* pcVertices = (const MDL::Vertex*) ((pcFirstFrame->name) + sizeof(pcFirstFrame->name));
+        const MDL::SimpleFrame *pcFirstFrame = (const MDL::SimpleFrame *)(szCurrent + sizeof(uint32_t));
+        const MDL::Vertex *pcVertices = (const MDL::Vertex *)((pcFirstFrame->name) + sizeof(pcFirstFrame->name));
 
         VALIDATE_FILE_SIZE(pcVertices + pcHeader->num_verts);
 
         // now iterate through all triangles
         unsigned int iCurrent = 0;
-        for (unsigned int i = 0; i < (unsigned int) pcHeader->num_tris;++i) {
+        for (unsigned int i = 0; i < (unsigned int)pcHeader->num_tris; ++i) {
             pcMesh->mFaces[i].mIndices = new unsigned int[3];
             pcMesh->mFaces[i].mNumIndices = 3;
 
             unsigned int iTemp = iCurrent;
-            for (unsigned int c = 0; c < 3;++c,++iCurrent)  {
+            for (unsigned int c = 0; c < 3; ++c, ++iCurrent) {
                 // read vertices
                 unsigned int iIndex = pcTriangles->index_xyz[c];
-                if (iIndex >= (unsigned int)pcHeader->num_verts)    {
-                    iIndex = pcHeader->num_verts-1;
+                if (iIndex >= (unsigned int)pcHeader->num_verts) {
+                    iIndex = pcHeader->num_verts - 1;
                     ASSIMP_LOG_WARN("Index overflow in MDLn vertex list");
                 }
 
-                aiVector3D& vec = pcMesh->mVertices[iCurrent];
+                aiVector3D &vec = pcMesh->mVertices[iCurrent];
                 vec.x = (float)pcVertices[iIndex].v[0] * pcHeader->scale[0];
                 vec.x += pcHeader->translate[0];
 
@@ -700,50 +715,50 @@ void MDLImporter::InternReadFile_3DGS_MDL345( )
                 vec.z += pcHeader->translate[2];
 
                 // read the normal vector from the precalculated normal table
-                MD2::LookupNormalIndex(pcVertices[iIndex].normalIndex,pcMesh->mNormals[iCurrent]);
+                MD2::LookupNormalIndex(pcVertices[iIndex].normalIndex, pcMesh->mNormals[iCurrent]);
                 // pcMesh->mNormals[iCurrent].y *= -1.0f;
 
                 // read texture coordinates
                 if (pcHeader->synctype) {
                     ImportUVCoordinate_3DGS_MDL345(pcMesh->mTextureCoords[0][iCurrent],
-                        pcTexCoords,pcTriangles->index_uv[c]);
+                            pcTexCoords, pcTriangles->index_uv[c]);
                 }
             }
-            pcMesh->mFaces[i].mIndices[0] = iTemp+2;
-            pcMesh->mFaces[i].mIndices[1] = iTemp+1;
-            pcMesh->mFaces[i].mIndices[2] = iTemp+0;
+            pcMesh->mFaces[i].mIndices[0] = iTemp + 2;
+            pcMesh->mFaces[i].mIndices[1] = iTemp + 1;
+            pcMesh->mFaces[i].mIndices[2] = iTemp + 0;
             pcTriangles++;
         }
 
     }
     // short packed vertices
     /////////////////////////////////////////////////////////////////////////////////////
-    else    {
+    else {
         // now get a pointer to the first frame in the file
-        const MDL::SimpleFrame_MDLn_SP* pcFirstFrame = (const MDL::SimpleFrame_MDLn_SP*) (szCurrent + sizeof(uint32_t));
+        const MDL::SimpleFrame_MDLn_SP *pcFirstFrame = (const MDL::SimpleFrame_MDLn_SP *)(szCurrent + sizeof(uint32_t));
 
         // get a pointer to the vertices
-        const MDL::Vertex_MDL4* pcVertices = (const MDL::Vertex_MDL4*) ((pcFirstFrame->name) +
-            sizeof(pcFirstFrame->name));
+        const MDL::Vertex_MDL4 *pcVertices = (const MDL::Vertex_MDL4 *)((pcFirstFrame->name) +
+                                                                        sizeof(pcFirstFrame->name));
 
         VALIDATE_FILE_SIZE(pcVertices + pcHeader->num_verts);
 
         // now iterate through all triangles
         unsigned int iCurrent = 0;
-        for (unsigned int i = 0; i < (unsigned int) pcHeader->num_tris;++i) {
+        for (unsigned int i = 0; i < (unsigned int)pcHeader->num_tris; ++i) {
             pcMesh->mFaces[i].mIndices = new unsigned int[3];
             pcMesh->mFaces[i].mNumIndices = 3;
 
             unsigned int iTemp = iCurrent;
-            for (unsigned int c = 0; c < 3;++c,++iCurrent)  {
+            for (unsigned int c = 0; c < 3; ++c, ++iCurrent) {
                 // read vertices
                 unsigned int iIndex = pcTriangles->index_xyz[c];
-                if (iIndex >= (unsigned int)pcHeader->num_verts)    {
-                    iIndex = pcHeader->num_verts-1;
+                if (iIndex >= (unsigned int)pcHeader->num_verts) {
+                    iIndex = pcHeader->num_verts - 1;
                     ASSIMP_LOG_WARN("Index overflow in MDLn vertex list");
                 }
 
-                aiVector3D& vec = pcMesh->mVertices[iCurrent];
+                aiVector3D &vec = pcMesh->mVertices[iCurrent];
                 vec.x = (float)pcVertices[iIndex].v[0] * pcHeader->scale[0];
                 vec.x += pcHeader->translate[0];
 
@@ -755,18 +770,18 @@ void MDLImporter::InternReadFile_3DGS_MDL345( )
                 vec.z += pcHeader->translate[2];
 
                 // read the normal vector from the precalculated normal table
-                MD2::LookupNormalIndex(pcVertices[iIndex].normalIndex,pcMesh->mNormals[iCurrent]);
+                MD2::LookupNormalIndex(pcVertices[iIndex].normalIndex, pcMesh->mNormals[iCurrent]);
                 // pcMesh->mNormals[iCurrent].y *= -1.0f;
 
                 // read texture coordinates
                 if (pcHeader->synctype) {
                     ImportUVCoordinate_3DGS_MDL345(pcMesh->mTextureCoords[0][iCurrent],
-                        pcTexCoords,pcTriangles->index_uv[c]);
+                            pcTexCoords, pcTriangles->index_uv[c]);
                 }
             }
-            pcMesh->mFaces[i].mIndices[0] = iTemp+2;
-            pcMesh->mFaces[i].mIndices[1] = iTemp+1;
-            pcMesh->mFaces[i].mIndices[2] = iTemp+0;
+            pcMesh->mFaces[i].mIndices[0] = iTemp + 2;
+            pcMesh->mFaces[i].mIndices[1] = iTemp + 1;
+            pcMesh->mFaces[i].mIndices[2] = iTemp + 0;
             pcTriangles++;
         }
     }
@@ -781,16 +796,15 @@ void MDLImporter::InternReadFile_3DGS_MDL345( )
 // ------------------------------------------------------------------------------------------------
 // Get a single UV coordinate for Quake and older GameStudio files
 void MDLImporter::ImportUVCoordinate_3DGS_MDL345(
-    aiVector3D& vOut,
-    const MDL::TexCoord_MDL3* pcSrc,
-    unsigned int iIndex)
-{
-    ai_assert(NULL != pcSrc);
-    const MDL::Header* const pcHeader = (const MDL::Header*)this->mBuffer;
+        aiVector3D &vOut,
+        const MDL::TexCoord_MDL3 *pcSrc,
+        unsigned int iIndex) {
+    ai_assert(nullptr != pcSrc);
+    const MDL::Header *const pcHeader = (const MDL::Header *)this->mBuffer;
 
     // validate UV indices
-    if (iIndex >= (unsigned int) pcHeader->synctype)    {
-        iIndex = pcHeader->synctype-1;
+    if (iIndex >= (unsigned int)pcHeader->synctype) {
+        iIndex = pcHeader->synctype - 1;
         ASSIMP_LOG_WARN("Index overflow in MDLn UV coord list");
     }
 
@@ -798,9 +812,9 @@ void MDLImporter::ImportUVCoordinate_3DGS_MDL345(
     float t = (float)pcSrc[iIndex].v;
 
     // Scale s and t to range from 0.0 to 1.0
-    if (0x5 != iGSFileVersion)  {
-        s = (s + 0.5f)      / pcHeader->skinwidth;
-        t = 1.0f-(t + 0.5f) / pcHeader->skinheight;
+    if (0x5 != iGSFileVersion) {
+        s = (s + 0.5f) / pcHeader->skinwidth;
+        t = 1.0f - (t + 0.5f) / pcHeader->skinheight;
     }
 
     vOut.x = s;
@@ -810,43 +824,42 @@ void MDLImporter::ImportUVCoordinate_3DGS_MDL345(
 
 // ------------------------------------------------------------------------------------------------
 // Compute UV coordinates for a MDL5 file
-void MDLImporter::CalculateUVCoordinates_MDL5()
-{
-    const MDL::Header* const pcHeader = (const MDL::Header*)this->mBuffer;
-    if (pcHeader->num_skins && this->pScene->mNumTextures)  {
-        const aiTexture* pcTex = this->pScene->mTextures[0];
+void MDLImporter::CalculateUVCoordinates_MDL5() {
+    const MDL::Header *const pcHeader = (const MDL::Header *)this->mBuffer;
+    if (pcHeader->num_skins && this->pScene->mNumTextures) {
+        const aiTexture *pcTex = this->pScene->mTextures[0];
 
         // if the file is loaded in DDS format: get the size of the
         // texture from the header of the DDS file
         // skip three DWORDs and read first height, then the width
         unsigned int iWidth, iHeight;
-        if (!pcTex->mHeight)    {
-            const uint32_t* piPtr = (uint32_t*)pcTex->pcData;
+        if (!pcTex->mHeight) {
+            const uint32_t *piPtr = (uint32_t *)pcTex->pcData;
 
             piPtr += 3;
             iHeight = (unsigned int)*piPtr++;
-            iWidth  = (unsigned int)*piPtr;
-            if (!iHeight || !iWidth)
-            {
+            iWidth = (unsigned int)*piPtr;
+            if (!iHeight || !iWidth) {
                 ASSIMP_LOG_WARN("Either the width or the height of the "
-                    "embedded DDS texture is zero. Unable to compute final texture "
-                    "coordinates. The texture coordinates remain in their original "
-                    "0-x/0-y (x,y = texture size) range.");
-                iWidth  = 1;
+                                "embedded DDS texture is zero. Unable to compute final texture "
+                                "coordinates. The texture coordinates remain in their original "
+                                "0-x/0-y (x,y = texture size) range.");
+                iWidth = 1;
                 iHeight = 1;
             }
-        }
-        else    {
-            iWidth  = pcTex->mWidth;
+        } else {
+            iWidth = pcTex->mWidth;
             iHeight = pcTex->mHeight;
         }
 
-        if (1 != iWidth || 1 != iHeight)    {
+        if (1 != iWidth || 1 != iHeight) {
             const float fWidth = (float)iWidth;
             const float fHeight = (float)iHeight;
-            aiMesh* pcMesh = this->pScene->mMeshes[0];
-            for (unsigned int i = 0; i < pcMesh->mNumVertices;++i)
-            {
+            aiMesh *pcMesh = this->pScene->mMeshes[0];
+            for (unsigned int i = 0; i < pcMesh->mNumVertices; ++i) {
+                if (!pcMesh->HasTextureCoords(0)) {
+                    continue;
+                }
                 pcMesh->mTextureCoords[0][i].x /= fWidth;
                 pcMesh->mTextureCoords[0][i].y /= fHeight;
                 pcMesh->mTextureCoords[0][i].y = 1.0f - pcMesh->mTextureCoords[0][i].y; // DX to OGL
@@ -857,37 +870,35 @@ void MDLImporter::CalculateUVCoordinates_MDL5()
 
 // ------------------------------------------------------------------------------------------------
 // Validate the header of a MDL7 file
-void MDLImporter::ValidateHeader_3DGS_MDL7(const MDL::Header_MDL7* pcHeader)
-{
-    ai_assert(NULL != pcHeader);
+void MDLImporter::ValidateHeader_3DGS_MDL7(const MDL::Header_MDL7 *pcHeader) {
+    ai_assert(nullptr != pcHeader);
 
     // There are some fixed sizes ...
-    if (sizeof(MDL::ColorValue_MDL7) != pcHeader->colorvalue_stc_size)  {
+    if (sizeof(MDL::ColorValue_MDL7) != pcHeader->colorvalue_stc_size) {
         throw DeadlyImportError(
-            "[3DGS MDL7] sizeof(MDL::ColorValue_MDL7) != pcHeader->colorvalue_stc_size");
+                "[3DGS MDL7] sizeof(MDL::ColorValue_MDL7) != pcHeader->colorvalue_stc_size");
     }
     if (sizeof(MDL::TexCoord_MDL7) != pcHeader->skinpoint_stc_size) {
         throw DeadlyImportError(
-            "[3DGS MDL7] sizeof(MDL::TexCoord_MDL7) != pcHeader->skinpoint_stc_size");
+                "[3DGS MDL7] sizeof(MDL::TexCoord_MDL7) != pcHeader->skinpoint_stc_size");
     }
-    if (sizeof(MDL::Skin_MDL7) != pcHeader->skin_stc_size)  {
+    if (sizeof(MDL::Skin_MDL7) != pcHeader->skin_stc_size) {
         throw DeadlyImportError(
-            "sizeof(MDL::Skin_MDL7) != pcHeader->skin_stc_size");
+                "sizeof(MDL::Skin_MDL7) != pcHeader->skin_stc_size");
     }
 
     // if there are no groups ... how should we load such a file?
-    if(!pcHeader->groups_num)   {
-        throw DeadlyImportError( "[3DGS MDL7] No frames found");
+    if (!pcHeader->groups_num) {
+        throw DeadlyImportError("[3DGS MDL7] No frames found");
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // resolve bone animation matrices
-void MDLImporter::CalcAbsBoneMatrices_3DGS_MDL7(MDL::IntBone_MDL7** apcOutBones)
-{
-    const MDL::Header_MDL7 *pcHeader = (const MDL::Header_MDL7*)this->mBuffer;
-    const MDL::Bone_MDL7* pcBones = (const MDL::Bone_MDL7*)(pcHeader+1);
-    ai_assert(NULL != apcOutBones);
+void MDLImporter::CalcAbsBoneMatrices_3DGS_MDL7(MDL::IntBone_MDL7 **apcOutBones) {
+    const MDL::Header_MDL7 *pcHeader = (const MDL::Header_MDL7 *)this->mBuffer;
+    const MDL::Bone_MDL7 *pcBones = (const MDL::Bone_MDL7 *)(pcHeader + 1);
+    ai_assert(nullptr != apcOutBones);
 
     // first find the bone that has NO parent, calculate the
     // animation matrix for it, then go on and search for the next parent
@@ -895,16 +906,16 @@ void MDLImporter::CalcAbsBoneMatrices_3DGS_MDL7(MDL::IntBone_MDL7** apcOutBones)
     uint16_t iParent = 0xffff;
     uint32_t iIterations = 0;
     while (iIterations++ < pcHeader->bones_num) {
-        for (uint32_t iBone = 0; iBone < pcHeader->bones_num;++iBone)   {
-            BE_NCONST MDL::Bone_MDL7* pcBone = _AI_MDL7_ACCESS_PTR(pcBones,iBone,
-                pcHeader->bone_stc_size,MDL::Bone_MDL7);
+        for (uint32_t iBone = 0; iBone < pcHeader->bones_num; ++iBone) {
+            BE_NCONST MDL::Bone_MDL7 *pcBone = _AI_MDL7_ACCESS_PTR(pcBones, iBone,
+                    pcHeader->bone_stc_size, MDL::Bone_MDL7);
 
             AI_SWAP2(pcBone->parent_index);
             AI_SWAP4(pcBone->x);
             AI_SWAP4(pcBone->y);
             AI_SWAP4(pcBone->z);
 
-            if (iParent == pcBone->parent_index)    {
+            if (iParent == pcBone->parent_index) {
                 // MDL7 readme
                 ////////////////////////////////////////////////////////////////
                 /*
@@ -925,12 +936,12 @@ void MDLImporter::CalcAbsBoneMatrices_3DGS_MDL7(MDL::IntBone_MDL7** apcOutBones)
                 */
                 /////////////////////////////////////////////////////////////////
 
-                MDL::IntBone_MDL7* const pcOutBone = apcOutBones[iBone];
+                MDL::IntBone_MDL7 *const pcOutBone = apcOutBones[iBone];
 
                 // store the parent index of the bone
                 pcOutBone->iParent = pcBone->parent_index;
-                if (0xffff != iParent)  {
-                    const MDL::IntBone_MDL7* pcParentBone = apcOutBones[iParent];
+                if (0xffff != iParent) {
+                    const MDL::IntBone_MDL7 *pcParentBone = apcOutBones[iParent];
                     pcOutBone->mOffsetMatrix.a4 = -pcParentBone->vPosition.x;
                     pcOutBone->mOffsetMatrix.b4 = -pcParentBone->vPosition.y;
                     pcOutBone->mOffsetMatrix.c4 = -pcParentBone->vPosition.z;
@@ -945,15 +956,14 @@ void MDLImporter::CalcAbsBoneMatrices_3DGS_MDL7(MDL::IntBone_MDL7** apcOutBones)
                 if (AI_MDL7_BONE_STRUCT_SIZE__NAME_IS_NOT_THERE == pcHeader->bone_stc_size) {
                     // no real name for our poor bone is specified :-(
                     pcOutBone->mName.length = ai_snprintf(pcOutBone->mName.data, MAXLEN,
-                        "UnnamedBone_%i",iBone);
-                }
-                else    {
+                            "UnnamedBone_%i", iBone);
+                } else {
                     // Make sure we won't run over the buffer's end if there is no
                     // terminal 0 character (however the documentation says there
                     // should be one)
-                    uint32_t iMaxLen = pcHeader->bone_stc_size-16;
-                    for (uint32_t qq = 0; qq < iMaxLen;++qq)    {
-                        if (!pcBone->name[qq])  {
+                    uint32_t iMaxLen = pcHeader->bone_stc_size - 16;
+                    for (uint32_t qq = 0; qq < iMaxLen; ++qq) {
+                        if (!pcBone->name[qq]) {
                             iMaxLen = qq;
                             break;
                         }
@@ -961,7 +971,7 @@ void MDLImporter::CalcAbsBoneMatrices_3DGS_MDL7(MDL::IntBone_MDL7** apcOutBones)
 
                     // store the name of the bone
                     pcOutBone->mName.length = (size_t)iMaxLen;
-                    ::memcpy(pcOutBone->mName.data,pcBone->name,pcOutBone->mName.length);
+                    ::memcpy(pcOutBone->mName.data, pcBone->name, pcOutBone->mName.length);
                     pcOutBone->mName.data[pcOutBone->mName.length] = '\0';
                 }
             }
@@ -972,37 +982,34 @@ void MDLImporter::CalcAbsBoneMatrices_3DGS_MDL7(MDL::IntBone_MDL7** apcOutBones)
 
 // ------------------------------------------------------------------------------------------------
 // read bones from a MDL7 file
-MDL::IntBone_MDL7** MDLImporter::LoadBones_3DGS_MDL7()
-{
-  const MDL::Header_MDL7 *pcHeader = (const MDL::Header_MDL7*)this->mBuffer;
-    if (pcHeader->bones_num)    {
+MDL::IntBone_MDL7 **MDLImporter::LoadBones_3DGS_MDL7() {
+    const MDL::Header_MDL7 *pcHeader = (const MDL::Header_MDL7 *)this->mBuffer;
+    if (pcHeader->bones_num) {
         // validate the size of the bone data structure in the file
-        if (AI_MDL7_BONE_STRUCT_SIZE__NAME_IS_20_CHARS  != pcHeader->bone_stc_size &&
-            AI_MDL7_BONE_STRUCT_SIZE__NAME_IS_32_CHARS  != pcHeader->bone_stc_size &&
-            AI_MDL7_BONE_STRUCT_SIZE__NAME_IS_NOT_THERE != pcHeader->bone_stc_size)
-        {
+        if (AI_MDL7_BONE_STRUCT_SIZE__NAME_IS_20_CHARS != pcHeader->bone_stc_size &&
+                AI_MDL7_BONE_STRUCT_SIZE__NAME_IS_32_CHARS != pcHeader->bone_stc_size &&
+                AI_MDL7_BONE_STRUCT_SIZE__NAME_IS_NOT_THERE != pcHeader->bone_stc_size) {
             ASSIMP_LOG_WARN("Unknown size of bone data structure");
-            return NULL;
+            return nullptr;
         }
 
-        MDL::IntBone_MDL7** apcBonesOut = new MDL::IntBone_MDL7*[pcHeader->bones_num];
-        for (uint32_t crank = 0; crank < pcHeader->bones_num;++crank)
+        MDL::IntBone_MDL7 **apcBonesOut = new MDL::IntBone_MDL7 *[pcHeader->bones_num];
+        for (uint32_t crank = 0; crank < pcHeader->bones_num; ++crank)
             apcBonesOut[crank] = new MDL::IntBone_MDL7();
 
         // and calculate absolute bone offset matrices ...
         CalcAbsBoneMatrices_3DGS_MDL7(apcBonesOut);
         return apcBonesOut;
     }
-    return NULL;
+    return nullptr;
 }
 
 // ------------------------------------------------------------------------------------------------
 // read faces from a MDL7 file
-void MDLImporter::ReadFaces_3DGS_MDL7(const MDL::IntGroupInfo_MDL7& groupInfo,
-    MDL::IntGroupData_MDL7& groupData)
-{
-    const MDL::Header_MDL7 *pcHeader = (const MDL::Header_MDL7*)this->mBuffer;
-    MDL::Triangle_MDL7* pcGroupTris = groupInfo.pcGroupTris;
+void MDLImporter::ReadFaces_3DGS_MDL7(const MDL::IntGroupInfo_MDL7 &groupInfo,
+        MDL::IntGroupData_MDL7 &groupData) {
+    const MDL::Header_MDL7 *pcHeader = (const MDL::Header_MDL7 *)this->mBuffer;
+    MDL::Triangle_MDL7 *pcGroupTris = groupInfo.pcGroupTris;
 
     // iterate through all triangles and build valid display lists
     unsigned int iOutIndex = 0;
@@ -1012,142 +1019,143 @@ void MDLImporter::ReadFaces_3DGS_MDL7(const MDL::IntGroupInfo_MDL7& groupInfo,
         AI_SWAP2(pcGroupTris->v_index[2]);
 
         // iterate through all indices of the current triangle
-        for (unsigned int c = 0; c < 3;++c,++iOutIndex) {
+        for (unsigned int c = 0; c < 3; ++c, ++iOutIndex) {
 
             // validate the vertex index
             unsigned int iIndex = pcGroupTris->v_index[c];
-            if(iIndex > (unsigned int)groupInfo.pcGroup->numverts)  {
+            if (iIndex > (unsigned int)groupInfo.pcGroup->numverts) {
                 // (we might need to read this section a second time - to process frame vertices correctly)
-                pcGroupTris->v_index[c] = iIndex = groupInfo.pcGroup->numverts-1;
+                pcGroupTris->v_index[c] = (uint16_t)(iIndex = groupInfo.pcGroup->numverts - 1);
                 ASSIMP_LOG_WARN("Index overflow in MDL7 vertex list");
             }
 
             // write the output face index
-            groupData.pcFaces[iTriangle].mIndices[2-c] = iOutIndex;
+            groupData.pcFaces[iTriangle].mIndices[2 - c] = iOutIndex;
 
-            aiVector3D& vPosition = groupData.vPositions[ iOutIndex ];
-            vPosition.x = _AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts,iIndex, pcHeader->mainvertex_stc_size) .x;
-            vPosition.y = _AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts,iIndex,pcHeader->mainvertex_stc_size) .y;
-            vPosition.z = _AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts,iIndex,pcHeader->mainvertex_stc_size) .z;
+            aiVector3D &vPosition = groupData.vPositions[iOutIndex];
+            vPosition.x = _AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts, iIndex, pcHeader->mainvertex_stc_size).x;
+            vPosition.y = _AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts, iIndex, pcHeader->mainvertex_stc_size).y;
+            vPosition.z = _AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts, iIndex, pcHeader->mainvertex_stc_size).z;
 
             // if we have bones, save the index
             if (!groupData.aiBones.empty()) {
                 groupData.aiBones[iOutIndex] = _AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts,
-                    iIndex,pcHeader->mainvertex_stc_size).vertindex;
+                        iIndex, pcHeader->mainvertex_stc_size)
+                                                       .vertindex;
             }
 
             // now read the normal vector
             if (AI_MDL7_FRAMEVERTEX030305_STCSIZE <= pcHeader->mainvertex_stc_size) {
                 // read the full normal vector
-                aiVector3D& vNormal = groupData.vNormals[ iOutIndex ];
-                vNormal.x = _AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts,iIndex,pcHeader->mainvertex_stc_size) .norm[0];
+                aiVector3D &vNormal = groupData.vNormals[iOutIndex];
+                vNormal.x = _AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts, iIndex, pcHeader->mainvertex_stc_size).norm[0];
                 AI_SWAP4(vNormal.x);
-                vNormal.y = _AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts,iIndex,pcHeader->mainvertex_stc_size) .norm[1];
+                vNormal.y = _AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts, iIndex, pcHeader->mainvertex_stc_size).norm[1];
                 AI_SWAP4(vNormal.y);
-                vNormal.z = _AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts,iIndex,pcHeader->mainvertex_stc_size) .norm[2];
+                vNormal.z = _AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts, iIndex, pcHeader->mainvertex_stc_size).norm[2];
                 AI_SWAP4(vNormal.z);
-            }
-            else if (AI_MDL7_FRAMEVERTEX120503_STCSIZE <= pcHeader->mainvertex_stc_size)    {
+            } else if (AI_MDL7_FRAMEVERTEX120503_STCSIZE <= pcHeader->mainvertex_stc_size) {
                 // read the normal vector from Quake2's smart table
-                aiVector3D& vNormal = groupData.vNormals[ iOutIndex ];
-                MD2::LookupNormalIndex(_AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts,iIndex,
-                    pcHeader->mainvertex_stc_size) .norm162index,vNormal);
+                aiVector3D &vNormal = groupData.vNormals[iOutIndex];
+                MD2::LookupNormalIndex(_AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts, iIndex,
+                                               pcHeader->mainvertex_stc_size)
+                                               .norm162index,
+                        vNormal);
             }
             // validate and process the first uv coordinate set
-            if (pcHeader->triangle_stc_size >= AI_MDL7_TRIANGLE_STD_SIZE_ONE_UV)    {
+            if (pcHeader->triangle_stc_size >= AI_MDL7_TRIANGLE_STD_SIZE_ONE_UV) {
 
-                if (groupInfo.pcGroup->num_stpts)   {
+                if (groupInfo.pcGroup->num_stpts) {
                     AI_SWAP2(pcGroupTris->skinsets[0].st_index[0]);
                     AI_SWAP2(pcGroupTris->skinsets[0].st_index[1]);
                     AI_SWAP2(pcGroupTris->skinsets[0].st_index[2]);
 
                     iIndex = pcGroupTris->skinsets[0].st_index[c];
-                    if(iIndex > (unsigned int)groupInfo.pcGroup->num_stpts) {
-                        iIndex = groupInfo.pcGroup->num_stpts-1;
+                    if (iIndex > (unsigned int)groupInfo.pcGroup->num_stpts) {
+                        iIndex = groupInfo.pcGroup->num_stpts - 1;
                         ASSIMP_LOG_WARN("Index overflow in MDL7 UV coordinate list (#1)");
                     }
 
                     float u = groupInfo.pcGroupUVs[iIndex].u;
-                    float v = 1.0f-groupInfo.pcGroupUVs[iIndex].v; // DX to OGL
+                    float v = 1.0f - groupInfo.pcGroupUVs[iIndex].v; // DX to OGL
 
                     groupData.vTextureCoords1[iOutIndex].x = u;
                     groupData.vTextureCoords1[iOutIndex].y = v;
                 }
                 // assign the material index, but only if it is existing
-                if (pcHeader->triangle_stc_size >= AI_MDL7_TRIANGLE_STD_SIZE_ONE_UV_WITH_MATINDEX){
+                if (pcHeader->triangle_stc_size >= AI_MDL7_TRIANGLE_STD_SIZE_ONE_UV_WITH_MATINDEX) {
                     AI_SWAP4(pcGroupTris->skinsets[0].material);
                     groupData.pcFaces[iTriangle].iMatIndex[0] = pcGroupTris->skinsets[0].material;
                 }
             }
             // validate and process the second uv coordinate set
-            if (pcHeader->triangle_stc_size >= AI_MDL7_TRIANGLE_STD_SIZE_TWO_UV)    {
+            if (pcHeader->triangle_stc_size >= AI_MDL7_TRIANGLE_STD_SIZE_TWO_UV) {
 
-                if (groupInfo.pcGroup->num_stpts)   {
+                if (groupInfo.pcGroup->num_stpts) {
                     AI_SWAP2(pcGroupTris->skinsets[1].st_index[0]);
                     AI_SWAP2(pcGroupTris->skinsets[1].st_index[1]);
                     AI_SWAP2(pcGroupTris->skinsets[1].st_index[2]);
                     AI_SWAP4(pcGroupTris->skinsets[1].material);
 
                     iIndex = pcGroupTris->skinsets[1].st_index[c];
-                    if(iIndex > (unsigned int)groupInfo.pcGroup->num_stpts) {
-                        iIndex = groupInfo.pcGroup->num_stpts-1;
+                    if (iIndex > (unsigned int)groupInfo.pcGroup->num_stpts) {
+                        iIndex = groupInfo.pcGroup->num_stpts - 1;
                         ASSIMP_LOG_WARN("Index overflow in MDL7 UV coordinate list (#2)");
                     }
 
-                    float u = groupInfo.pcGroupUVs[ iIndex ].u;
-                    float v = 1.0f-groupInfo.pcGroupUVs[ iIndex ].v;
+                    float u = groupInfo.pcGroupUVs[iIndex].u;
+                    float v = 1.0f - groupInfo.pcGroupUVs[iIndex].v;
 
-                    groupData.vTextureCoords2[ iOutIndex ].x = u;
-                    groupData.vTextureCoords2[ iOutIndex ].y = v; // DX to OGL
+                    groupData.vTextureCoords2[iOutIndex].x = u;
+                    groupData.vTextureCoords2[iOutIndex].y = v; // DX to OGL
 
                     // check whether we do really need the second texture
                     // coordinate set ... wastes memory and loading time
-                    if (0 != iIndex && (u != groupData.vTextureCoords1[ iOutIndex ].x ||
-                        v != groupData.vTextureCoords1[ iOutIndex ].y ) )
+                    if (0 != iIndex && (u != groupData.vTextureCoords1[iOutIndex].x ||
+                                               v != groupData.vTextureCoords1[iOutIndex].y))
                         groupData.bNeed2UV = true;
 
                     // if the material differs, we need a second skin, too
-                    if (pcGroupTris->skinsets[ 1 ].material != pcGroupTris->skinsets[ 0 ].material)
+                    if (pcGroupTris->skinsets[1].material != pcGroupTris->skinsets[0].material)
                         groupData.bNeed2UV = true;
                 }
                 // assign the material index
-                groupData.pcFaces[ iTriangle ].iMatIndex[ 1 ] = pcGroupTris->skinsets[ 1 ].material;
+                groupData.pcFaces[iTriangle].iMatIndex[1] = pcGroupTris->skinsets[1].material;
             }
         }
         // get the next triangle in the list
-        pcGroupTris = (MDL::Triangle_MDL7*)((const char*)pcGroupTris + pcHeader->triangle_stc_size);
+        pcGroupTris = (MDL::Triangle_MDL7 *)((const char *)pcGroupTris + pcHeader->triangle_stc_size);
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // handle frames in a MDL7 file
-bool MDLImporter::ProcessFrames_3DGS_MDL7(const MDL::IntGroupInfo_MDL7& groupInfo,
-    MDL::IntGroupData_MDL7&  groupData,
-    MDL::IntSharedData_MDL7& shared,
-    const unsigned char*     szCurrent,
-    const unsigned char**    szCurrentOut)
-{
-    ai_assert( nullptr != szCurrent );
-    ai_assert( nullptr != szCurrentOut);
+bool MDLImporter::ProcessFrames_3DGS_MDL7(const MDL::IntGroupInfo_MDL7 &groupInfo,
+        MDL::IntGroupData_MDL7 &groupData,
+        MDL::IntSharedData_MDL7 &shared,
+        const unsigned char *szCurrent,
+        const unsigned char **szCurrentOut) {
+    ai_assert(nullptr != szCurrent);
+    ai_assert(nullptr != szCurrentOut);
 
-    const MDL::Header_MDL7 *pcHeader = (const MDL::Header_MDL7*)mBuffer;
+    const MDL::Header_MDL7 *pcHeader = (const MDL::Header_MDL7 *)mBuffer;
 
     // if we have no bones we can simply skip all frames,
     // otherwise we'll need to process them.
     // FIX: If we need another frame than the first we must apply frame vertex replacements ...
-    for(unsigned int iFrame = 0; iFrame < (unsigned int)groupInfo.pcGroup->numframes;++iFrame)  {
-        MDL::IntFrameInfo_MDL7 frame ((BE_NCONST MDL::Frame_MDL7*)szCurrent,iFrame);
+    for (unsigned int iFrame = 0; iFrame < (unsigned int)groupInfo.pcGroup->numframes; ++iFrame) {
+        MDL::IntFrameInfo_MDL7 frame((BE_NCONST MDL::Frame_MDL7 *)szCurrent, iFrame);
 
         AI_SWAP4(frame.pcFrame->vertices_count);
         AI_SWAP4(frame.pcFrame->transmatrix_count);
 
         const unsigned int iAdd = pcHeader->frame_stc_size +
-            frame.pcFrame->vertices_count * pcHeader->framevertex_stc_size +
-            frame.pcFrame->transmatrix_count * pcHeader->bonetrans_stc_size;
+                                  frame.pcFrame->vertices_count * pcHeader->framevertex_stc_size +
+                                  frame.pcFrame->transmatrix_count * pcHeader->bonetrans_stc_size;
 
-        if (((const char*)szCurrent - (const char*)pcHeader) + iAdd > (unsigned int)pcHeader->data_size)    {
+        if (((const char *)szCurrent - (const char *)pcHeader) + iAdd > (unsigned int)pcHeader->data_size) {
             ASSIMP_LOG_WARN("Index overflow in frame area. "
-                "Ignoring all frames and all further mesh groups, too.");
+                            "Ignoring all frames and all further mesh groups, too.");
 
             // don't parse more groups if we can't even read one
             // FIXME: sometimes this seems to occur even for valid files ...
@@ -1155,66 +1163,68 @@ bool MDLImporter::ProcessFrames_3DGS_MDL7(const MDL::IntGroupInfo_MDL7& groupInf
             return false;
         }
         // our output frame?
-        if (configFrameID == iFrame)    {
-            BE_NCONST MDL::Vertex_MDL7* pcFrameVertices = (BE_NCONST MDL::Vertex_MDL7*)(szCurrent+pcHeader->frame_stc_size);
+        if (configFrameID == iFrame) {
+            BE_NCONST MDL::Vertex_MDL7 *pcFrameVertices = (BE_NCONST MDL::Vertex_MDL7 *)(szCurrent + pcHeader->frame_stc_size);
 
-            for (unsigned int qq = 0; qq < frame.pcFrame->vertices_count;++qq)  {
+            for (unsigned int qq = 0; qq < frame.pcFrame->vertices_count; ++qq) {
                 // I assume this are simple replacements for normal vertices, the bone index serving
                 // as the index of the vertex to be replaced.
-                uint16_t iIndex = _AI_MDL7_ACCESS(pcFrameVertices,qq,pcHeader->framevertex_stc_size,MDL::Vertex_MDL7).vertindex;
+                uint16_t iIndex = _AI_MDL7_ACCESS(pcFrameVertices, qq, pcHeader->framevertex_stc_size, MDL::Vertex_MDL7).vertindex;
                 AI_SWAP2(iIndex);
-                if (iIndex >= groupInfo.pcGroup->numverts)  {
+                if (iIndex >= groupInfo.pcGroup->numverts) {
                     ASSIMP_LOG_WARN("Invalid vertex index in frame vertex section");
                     continue;
                 }
 
-                aiVector3D vPosition,vNormal;
+                aiVector3D vPosition, vNormal;
 
-                vPosition.x = _AI_MDL7_ACCESS_VERT(pcFrameVertices,qq,pcHeader->framevertex_stc_size) .x;
+                vPosition.x = _AI_MDL7_ACCESS_VERT(pcFrameVertices, qq, pcHeader->framevertex_stc_size).x;
                 AI_SWAP4(vPosition.x);
-                vPosition.y = _AI_MDL7_ACCESS_VERT(pcFrameVertices,qq,pcHeader->framevertex_stc_size) .y;
+                vPosition.y = _AI_MDL7_ACCESS_VERT(pcFrameVertices, qq, pcHeader->framevertex_stc_size).y;
                 AI_SWAP4(vPosition.y);
-                vPosition.z = _AI_MDL7_ACCESS_VERT(pcFrameVertices,qq,pcHeader->framevertex_stc_size) .z;
+                vPosition.z = _AI_MDL7_ACCESS_VERT(pcFrameVertices, qq, pcHeader->framevertex_stc_size).z;
                 AI_SWAP4(vPosition.z);
 
                 // now read the normal vector
                 if (AI_MDL7_FRAMEVERTEX030305_STCSIZE <= pcHeader->mainvertex_stc_size) {
                     // read the full normal vector
-                    vNormal.x = _AI_MDL7_ACCESS_VERT(pcFrameVertices,qq,pcHeader->framevertex_stc_size) .norm[0];
+                    vNormal.x = _AI_MDL7_ACCESS_VERT(pcFrameVertices, qq, pcHeader->framevertex_stc_size).norm[0];
                     AI_SWAP4(vNormal.x);
-                    vNormal.y = _AI_MDL7_ACCESS_VERT(pcFrameVertices,qq,pcHeader->framevertex_stc_size) .norm[1];
+                    vNormal.y = _AI_MDL7_ACCESS_VERT(pcFrameVertices, qq, pcHeader->framevertex_stc_size).norm[1];
                     AI_SWAP4(vNormal.y);
-                    vNormal.z = _AI_MDL7_ACCESS_VERT(pcFrameVertices,qq,pcHeader->framevertex_stc_size) .norm[2];
+                    vNormal.z = _AI_MDL7_ACCESS_VERT(pcFrameVertices, qq, pcHeader->framevertex_stc_size).norm[2];
                     AI_SWAP4(vNormal.z);
-                }
-                else if (AI_MDL7_FRAMEVERTEX120503_STCSIZE <= pcHeader->mainvertex_stc_size)    {
+                } else if (AI_MDL7_FRAMEVERTEX120503_STCSIZE <= pcHeader->mainvertex_stc_size) {
                     // read the normal vector from Quake2's smart table
-                    MD2::LookupNormalIndex(_AI_MDL7_ACCESS_VERT(pcFrameVertices,qq,
-                        pcHeader->framevertex_stc_size) .norm162index,vNormal);
+                    MD2::LookupNormalIndex(_AI_MDL7_ACCESS_VERT(pcFrameVertices, qq,
+                                                   pcHeader->framevertex_stc_size)
+                                                   .norm162index,
+                            vNormal);
                 }
 
                 // FIXME: O(n^2) at the moment ...
-                BE_NCONST MDL::Triangle_MDL7* pcGroupTris = groupInfo.pcGroupTris;
+                BE_NCONST MDL::Triangle_MDL7 *pcGroupTris = groupInfo.pcGroupTris;
                 unsigned int iOutIndex = 0;
                 for (unsigned int iTriangle = 0; iTriangle < (unsigned int)groupInfo.pcGroup->numtris; ++iTriangle) {
                     // iterate through all indices of the current triangle
-                    for (unsigned int c = 0; c < 3;++c,++iOutIndex) {
+                    for (unsigned int c = 0; c < 3; ++c, ++iOutIndex) {
                         // replace the vertex with the new data
                         const unsigned int iCurIndex = pcGroupTris->v_index[c];
-                        if (iCurIndex == iIndex)    {
+                        if (iCurIndex == iIndex) {
                             groupData.vPositions[iOutIndex] = vPosition;
                             groupData.vNormals[iOutIndex] = vNormal;
                         }
                     }
                     // get the next triangle in the list
-                    pcGroupTris = (BE_NCONST MDL::Triangle_MDL7*)((const char*)
-                        pcGroupTris + pcHeader->triangle_stc_size);
+                    pcGroupTris = (BE_NCONST MDL::Triangle_MDL7 *)((const char *)
+                                                                           pcGroupTris +
+                                                                   pcHeader->triangle_stc_size);
                 }
             }
         }
         // parse bone trafo matrix keys (only if there are bones ...)
         if (shared.apcOutBones) {
-            ParseBoneTrafoKeys_3DGS_MDL7(groupInfo,frame,shared);
+            ParseBoneTrafoKeys_3DGS_MDL7(groupInfo, frame, shared);
         }
         szCurrent += iAdd;
     }
@@ -1225,92 +1235,88 @@ bool MDLImporter::ProcessFrames_3DGS_MDL7(const MDL::IntGroupInfo_MDL7& groupInf
 // ------------------------------------------------------------------------------------------------
 // Sort faces by material, handle multiple UVs correctly
 void MDLImporter::SortByMaterials_3DGS_MDL7(
-    const MDL::IntGroupInfo_MDL7&   groupInfo,
-    MDL::IntGroupData_MDL7&         groupData,
-    MDL::IntSplitGroupData_MDL7& splitGroupData)
-{
+        const MDL::IntGroupInfo_MDL7 &groupInfo,
+        MDL::IntGroupData_MDL7 &groupData,
+        MDL::IntSplitGroupData_MDL7 &splitGroupData) {
     const unsigned int iNumMaterials = (unsigned int)splitGroupData.shared.pcMats.size();
-    if (!groupData.bNeed2UV)    {
+    if (!groupData.bNeed2UV) {
         // if we don't need a second set of texture coordinates there is no reason to keep it in memory ...
         groupData.vTextureCoords2.clear();
 
         // allocate the array
-        splitGroupData.aiSplit = new std::vector<unsigned int>*[iNumMaterials];
+        splitGroupData.aiSplit = new std::vector<unsigned int> *[iNumMaterials];
 
-        for (unsigned int m = 0; m < iNumMaterials;++m)
+        for (unsigned int m = 0; m < iNumMaterials; ++m)
             splitGroupData.aiSplit[m] = new std::vector<unsigned int>();
 
         // iterate through all faces and sort by material
-        for (unsigned int iFace = 0; iFace < (unsigned int)groupInfo.pcGroup->numtris;++iFace)  {
+        for (unsigned int iFace = 0; iFace < (unsigned int)groupInfo.pcGroup->numtris; ++iFace) {
             // check range
             if (groupData.pcFaces[iFace].iMatIndex[0] >= iNumMaterials) {
                 // use the last material instead
-                splitGroupData.aiSplit[iNumMaterials-1]->push_back(iFace);
+                splitGroupData.aiSplit[iNumMaterials - 1]->push_back(iFace);
 
                 // sometimes MED writes -1, but normally only if there is only
                 // one skin assigned. No warning in this case
-                if(0xFFFFFFFF != groupData.pcFaces[iFace].iMatIndex[0])
+                if (0xFFFFFFFF != groupData.pcFaces[iFace].iMatIndex[0])
                     ASSIMP_LOG_WARN("Index overflow in MDL7 material list [#0]");
-            }
-            else splitGroupData.aiSplit[groupData.pcFaces[iFace].
-                iMatIndex[0]]->push_back(iFace);
+            } else
+                splitGroupData.aiSplit[groupData.pcFaces[iFace].iMatIndex[0]]->push_back(iFace);
         }
-    }
-    else
-    {
+    } else {
         // we need to build combined materials for each combination of
         std::vector<MDL::IntMaterial_MDL7> avMats;
-        avMats.reserve(iNumMaterials*2);
+        avMats.reserve(iNumMaterials * 2);
 
         // fixme: why on the heap?
-        std::vector<std::vector<unsigned int>* > aiTempSplit(iNumMaterials*2);
-        for (unsigned int m = 0; m < iNumMaterials;++m)
+        std::vector<std::vector<unsigned int> *> aiTempSplit(iNumMaterials * 2);
+        for (unsigned int m = 0; m < iNumMaterials; ++m)
             aiTempSplit[m] = new std::vector<unsigned int>();
 
         // iterate through all faces and sort by material
-        for (unsigned int iFace = 0; iFace < (unsigned int)groupInfo.pcGroup->numtris;++iFace)  {
+        for (unsigned int iFace = 0; iFace < (unsigned int)groupInfo.pcGroup->numtris; ++iFace) {
             // check range
             unsigned int iMatIndex = groupData.pcFaces[iFace].iMatIndex[0];
             if (iMatIndex >= iNumMaterials) {
                 // sometimes MED writes -1, but normally only if there is only
                 // one skin assigned. No warning in this case
-                if(UINT_MAX != iMatIndex)
+                if (UINT_MAX != iMatIndex)
                     ASSIMP_LOG_WARN("Index overflow in MDL7 material list [#1]");
-                iMatIndex = iNumMaterials-1;
+                iMatIndex = iNumMaterials - 1;
             }
             unsigned int iMatIndex2 = groupData.pcFaces[iFace].iMatIndex[1];
 
             unsigned int iNum = iMatIndex;
-            if (UINT_MAX != iMatIndex2 && iMatIndex != iMatIndex2)  {
-                if (iMatIndex2 >= iNumMaterials)    {
+            if (UINT_MAX != iMatIndex2 && iMatIndex != iMatIndex2) {
+                if (iMatIndex2 >= iNumMaterials) {
                     // sometimes MED writes -1, but normally only if there is only
                     // one skin assigned. No warning in this case
                     ASSIMP_LOG_WARN("Index overflow in MDL7 material list [#2]");
-                    iMatIndex2 = iNumMaterials-1;
+                    iMatIndex2 = iNumMaterials - 1;
                 }
 
                 // do a slow search in the list ...
                 iNum = 0;
                 bool bFound = false;
-                for (std::vector<MDL::IntMaterial_MDL7>::iterator i =  avMats.begin();i != avMats.end();++i,++iNum){
-                    if ((*i).iOldMatIndices[0] == iMatIndex && (*i).iOldMatIndices[1] == iMatIndex2)    {
+                for (std::vector<MDL::IntMaterial_MDL7>::iterator i = avMats.begin(); i != avMats.end(); ++i, ++iNum) {
+                    if ((*i).iOldMatIndices[0] == iMatIndex && (*i).iOldMatIndices[1] == iMatIndex2) {
                         // reuse this material
                         bFound = true;
                         break;
                     }
                 }
-                if (!bFound)    {
+                if (!bFound) {
                     //  build a new material ...
                     MDL::IntMaterial_MDL7 sHelper;
                     sHelper.pcMat = new aiMaterial();
                     sHelper.iOldMatIndices[0] = iMatIndex;
                     sHelper.iOldMatIndices[1] = iMatIndex2;
                     JoinSkins_3DGS_MDL7(splitGroupData.shared.pcMats[iMatIndex],
-                        splitGroupData.shared.pcMats[iMatIndex2],sHelper.pcMat);
+                            splitGroupData.shared.pcMats[iMatIndex2], sHelper.pcMat);
 
                     // and add it to the list
                     avMats.push_back(sHelper);
-                    iNum = (unsigned int)avMats.size()-1;
+                    iNum = (unsigned int)avMats.size() - 1;
                 }
                 // adjust the size of the file array
                 if (iNum == aiTempSplit.size()) {
@@ -1321,36 +1327,34 @@ void MDLImporter::SortByMaterials_3DGS_MDL7(
         }
 
         // now add the newly created materials to the old list
-        if (0 == groupInfo.iIndex)  {
+        if (0 == groupInfo.iIndex) {
             splitGroupData.shared.pcMats.resize(avMats.size());
-            for (unsigned int o = 0; o < avMats.size();++o)
+            for (unsigned int o = 0; o < avMats.size(); ++o)
                 splitGroupData.shared.pcMats[o] = avMats[o].pcMat;
-        }
-        else    {
+        } else {
             // This might result in redundant materials ...
             splitGroupData.shared.pcMats.resize(iNumMaterials + avMats.size());
-            for (unsigned int o = iNumMaterials; o < avMats.size();++o)
+            for (unsigned int o = iNumMaterials; o < avMats.size(); ++o)
                 splitGroupData.shared.pcMats[o] = avMats[o].pcMat;
         }
 
         // and build the final face-to-material array
-        splitGroupData.aiSplit = new std::vector<unsigned int>*[aiTempSplit.size()];
-        for (unsigned int m = 0; m < iNumMaterials;++m)
+        splitGroupData.aiSplit = new std::vector<unsigned int> *[aiTempSplit.size()];
+        for (unsigned int m = 0; m < iNumMaterials; ++m)
             splitGroupData.aiSplit[m] = aiTempSplit[m];
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Read a MDL7 file
-void MDLImporter::InternReadFile_3DGS_MDL7( )
-{
-    ai_assert(NULL != pScene);
+void MDLImporter::InternReadFile_3DGS_MDL7() {
+    ai_assert(nullptr != pScene);
 
     MDL::IntSharedData_MDL7 sharedData;
 
     // current cursor position in the file
-    BE_NCONST MDL::Header_MDL7 *pcHeader = (BE_NCONST MDL::Header_MDL7*)this->mBuffer;
-    const unsigned char* szCurrent = (const unsigned char*)(pcHeader+1);
+    BE_NCONST MDL::Header_MDL7 *pcHeader = (BE_NCONST MDL::Header_MDL7 *)this->mBuffer;
+    const unsigned char *szCurrent = (const unsigned char *)(pcHeader + 1);
 
     AI_SWAP4(pcHeader->version);
     AI_SWAP4(pcHeader->bones_num);
@@ -1375,26 +1379,26 @@ void MDLImporter::InternReadFile_3DGS_MDL7( )
 
     // load all bones (they are shared by all groups, so
     // we'll need to add them to all groups/meshes later)
-    // apcBonesOut is a list of all bones or NULL if they could not been loaded
+    // apcBonesOut is a list of all bones or nullptr if they could not been loaded
     szCurrent += pcHeader->bones_num * pcHeader->bone_stc_size;
     sharedData.apcOutBones = this->LoadBones_3DGS_MDL7();
 
     // vector to held all created meshes
-    std::vector<aiMesh*>* avOutList;
+    std::vector<aiMesh *> *avOutList;
 
     // 3 meshes per group - that should be OK for most models
-    avOutList = new std::vector<aiMesh*>[pcHeader->groups_num];
-    for (uint32_t i = 0; i < pcHeader->groups_num;++i)
+    avOutList = new std::vector<aiMesh *>[pcHeader->groups_num];
+    for (uint32_t i = 0; i < pcHeader->groups_num; ++i)
         avOutList[i].reserve(3);
 
     // buffer to held the names of all groups in the file
-	const size_t buffersize( AI_MDL7_MAX_GROUPNAMESIZE*pcHeader->groups_num );
-	char* aszGroupNameBuffer = new char[ buffersize ];
+    const size_t buffersize(AI_MDL7_MAX_GROUPNAMESIZE * pcHeader->groups_num);
+    char *aszGroupNameBuffer = new char[buffersize];
 
     // read all groups
-    for (unsigned int iGroup = 0; iGroup < (unsigned int)pcHeader->groups_num;++iGroup) {
-        MDL::IntGroupInfo_MDL7 groupInfo((BE_NCONST MDL::Group_MDL7*)szCurrent,iGroup);
-        szCurrent = (const unsigned char*)(groupInfo.pcGroup+1);
+    for (unsigned int iGroup = 0; iGroup < (unsigned int)pcHeader->groups_num; ++iGroup) {
+        MDL::IntGroupInfo_MDL7 groupInfo((BE_NCONST MDL::Group_MDL7 *)szCurrent, iGroup);
+        szCurrent = (const unsigned char *)(groupInfo.pcGroup + 1);
 
         VALIDATE_FILE_SIZE(szCurrent);
 
@@ -1405,64 +1409,65 @@ void MDLImporter::InternReadFile_3DGS_MDL7( )
         AI_SWAP4(groupInfo.pcGroup->numverts);
         AI_SWAP4(groupInfo.pcGroup->numframes);
 
-        if (1 != groupInfo.pcGroup->typ)    {
+        if (1 != groupInfo.pcGroup->typ) {
             // Not a triangle-based mesh
             ASSIMP_LOG_WARN("[3DGS MDL7] Not a triangle mesh group. Continuing happily");
         }
 
         // store the name of the group
-        const unsigned int ofs = iGroup*AI_MDL7_MAX_GROUPNAMESIZE;
+        const unsigned int ofs = iGroup * AI_MDL7_MAX_GROUPNAMESIZE;
         ::memcpy(&aszGroupNameBuffer[ofs],
-            groupInfo.pcGroup->name,AI_MDL7_MAX_GROUPNAMESIZE);
+                groupInfo.pcGroup->name, AI_MDL7_MAX_GROUPNAMESIZE);
 
         // make sure '\0' is at the end
-        aszGroupNameBuffer[ofs+AI_MDL7_MAX_GROUPNAMESIZE-1] = '\0';
+        aszGroupNameBuffer[ofs + AI_MDL7_MAX_GROUPNAMESIZE - 1] = '\0';
 
         // read all skins
         sharedData.pcMats.reserve(sharedData.pcMats.size() + groupInfo.pcGroup->numskins);
         sharedData.abNeedMaterials.resize(sharedData.abNeedMaterials.size() +
-            groupInfo.pcGroup->numskins,false);
+                                                  groupInfo.pcGroup->numskins,
+                false);
 
-        for (unsigned int iSkin = 0; iSkin < (unsigned int)groupInfo.pcGroup->numskins;++iSkin) {
-            ParseSkinLump_3DGS_MDL7(szCurrent,&szCurrent,sharedData.pcMats);
+        for (unsigned int iSkin = 0; iSkin < (unsigned int)groupInfo.pcGroup->numskins; ++iSkin) {
+            ParseSkinLump_3DGS_MDL7(szCurrent, &szCurrent, sharedData.pcMats);
         }
         // if we have absolutely no skin loaded we need to generate a default material
-        if (sharedData.pcMats.empty())  {
+        if (sharedData.pcMats.empty()) {
             const int iMode = (int)aiShadingMode_Gouraud;
             sharedData.pcMats.push_back(new aiMaterial());
-            aiMaterial* pcHelper = (aiMaterial*)sharedData.pcMats[0];
+            aiMaterial *pcHelper = (aiMaterial *)sharedData.pcMats[0];
             pcHelper->AddProperty<int>(&iMode, 1, AI_MATKEY_SHADING_MODEL);
 
             aiColor3D clr;
             clr.b = clr.g = clr.r = 0.6f;
-            pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_DIFFUSE);
-            pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_SPECULAR);
+            pcHelper->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_DIFFUSE);
+            pcHelper->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_SPECULAR);
 
             clr.b = clr.g = clr.r = 0.05f;
-            pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_AMBIENT);
+            pcHelper->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_AMBIENT);
 
             aiString szName;
             szName.Set(AI_DEFAULT_MATERIAL_NAME);
-            pcHelper->AddProperty(&szName,AI_MATKEY_NAME);
+            pcHelper->AddProperty(&szName, AI_MATKEY_NAME);
 
-            sharedData.abNeedMaterials.resize(1,false);
+            sharedData.abNeedMaterials.resize(1, false);
         }
 
         // now get a pointer to all texture coords in the group
-        groupInfo.pcGroupUVs = (BE_NCONST MDL::TexCoord_MDL7*)szCurrent;
-        for(int i = 0; i < groupInfo.pcGroup->num_stpts; ++i){
+        groupInfo.pcGroupUVs = (BE_NCONST MDL::TexCoord_MDL7 *)szCurrent;
+        for (int i = 0; i < groupInfo.pcGroup->num_stpts; ++i) {
             AI_SWAP4(groupInfo.pcGroupUVs[i].u);
             AI_SWAP4(groupInfo.pcGroupUVs[i].v);
         }
         szCurrent += pcHeader->skinpoint_stc_size * groupInfo.pcGroup->num_stpts;
 
         // now get a pointer to all triangle in the group
-        groupInfo.pcGroupTris = (Triangle_MDL7*)szCurrent;
+        groupInfo.pcGroupTris = (Triangle_MDL7 *)szCurrent;
         szCurrent += pcHeader->triangle_stc_size * groupInfo.pcGroup->numtris;
 
         // now get a pointer to all vertices in the group
-        groupInfo.pcGroupVerts = (BE_NCONST MDL::Vertex_MDL7*)szCurrent;
-        for(int i = 0; i < groupInfo.pcGroup->numverts; ++i){
+        groupInfo.pcGroupVerts = (BE_NCONST MDL::Vertex_MDL7 *)szCurrent;
+        for (int i = 0; i < groupInfo.pcGroup->numverts; ++i) {
             AI_SWAP4(groupInfo.pcGroupVerts[i].x);
             AI_SWAP4(groupInfo.pcGroupVerts[i].y);
             AI_SWAP4(groupInfo.pcGroupVerts[i].z);
@@ -1473,25 +1478,24 @@ void MDLImporter::InternReadFile_3DGS_MDL7( )
         szCurrent += pcHeader->mainvertex_stc_size * groupInfo.pcGroup->numverts;
         VALIDATE_FILE_SIZE(szCurrent);
 
-        MDL::IntSplitGroupData_MDL7 splitGroupData(sharedData,avOutList[iGroup]);
+        MDL::IntSplitGroupData_MDL7 splitGroupData(sharedData, avOutList[iGroup]);
         MDL::IntGroupData_MDL7 groupData;
-        if (groupInfo.pcGroup->numtris && groupInfo.pcGroup->numverts)
-        {
+        if (groupInfo.pcGroup->numtris && groupInfo.pcGroup->numverts) {
             // build output vectors
-            const unsigned int iNumVertices = groupInfo.pcGroup->numtris*3;
+            const unsigned int iNumVertices = groupInfo.pcGroup->numtris * 3;
             groupData.vPositions.resize(iNumVertices);
             groupData.vNormals.resize(iNumVertices);
 
-            if (sharedData.apcOutBones)groupData.aiBones.resize(iNumVertices,UINT_MAX);
+            if (sharedData.apcOutBones) groupData.aiBones.resize(iNumVertices, UINT_MAX);
 
             // it is also possible that there are 0 UV coordinate sets
-            if (groupInfo.pcGroup->num_stpts){
-                groupData.vTextureCoords1.resize(iNumVertices,aiVector3D());
+            if (groupInfo.pcGroup->num_stpts) {
+                groupData.vTextureCoords1.resize(iNumVertices, aiVector3D());
 
                 // check whether the triangle data structure is large enough
                 // to contain a second UV coordinate set
-                if (pcHeader->triangle_stc_size >= AI_MDL7_TRIANGLE_STD_SIZE_TWO_UV)    {
-                    groupData.vTextureCoords2.resize(iNumVertices,aiVector3D());
+                if (pcHeader->triangle_stc_size >= AI_MDL7_TRIANGLE_STD_SIZE_TWO_UV) {
+                    groupData.vTextureCoords2.resize(iNumVertices, aiVector3D());
                     groupData.bNeed2UV = true;
                 }
             }
@@ -1502,73 +1506,74 @@ void MDLImporter::InternReadFile_3DGS_MDL7( )
 
             // sort by materials
             SortByMaterials_3DGS_MDL7(groupInfo, groupData,
-                splitGroupData);
+                    splitGroupData);
 
-            for (unsigned int qq = 0; qq < sharedData.pcMats.size();++qq)   {
+            for (unsigned int qq = 0; qq < sharedData.pcMats.size(); ++qq) {
                 if (!splitGroupData.aiSplit[qq]->empty())
                     sharedData.abNeedMaterials[qq] = true;
             }
-        }
-        else ASSIMP_LOG_WARN("[3DGS MDL7] Mesh group consists of 0 "
-            "vertices or faces. It will be skipped.");
+        } else
+            ASSIMP_LOG_WARN("[3DGS MDL7] Mesh group consists of 0 "
+                            "vertices or faces. It will be skipped.");
 
         // process all frames and generate output meshes
-        ProcessFrames_3DGS_MDL7(groupInfo,groupData, sharedData,szCurrent,&szCurrent);
-        GenerateOutputMeshes_3DGS_MDL7(groupData,splitGroupData);
+        ProcessFrames_3DGS_MDL7(groupInfo, groupData, sharedData, szCurrent, &szCurrent);
+        GenerateOutputMeshes_3DGS_MDL7(groupData, splitGroupData);
     }
 
     // generate a nodegraph and subnodes for each group
     pScene->mRootNode = new aiNode();
 
     // now we need to build a final mesh list
-    for (uint32_t i = 0; i < pcHeader->groups_num;++i)
+    for (uint32_t i = 0; i < pcHeader->groups_num; ++i)
         pScene->mNumMeshes += (unsigned int)avOutList[i].size();
 
-    pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];  {
-        unsigned int p = 0,q = 0;
-        for (uint32_t i = 0; i < pcHeader->groups_num;++i)  {
-            for (unsigned int a = 0; a < avOutList[i].size();++a)   {
+    pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
+    {
+        unsigned int p = 0, q = 0;
+        for (uint32_t i = 0; i < pcHeader->groups_num; ++i) {
+            for (unsigned int a = 0; a < avOutList[i].size(); ++a) {
                 pScene->mMeshes[p++] = avOutList[i][a];
             }
-            if (!avOutList[i].empty())++pScene->mRootNode->mNumChildren;
+            if (!avOutList[i].empty()) ++pScene->mRootNode->mNumChildren;
         }
         // we will later need an extra node to serve as parent for all bones
-        if (sharedData.apcOutBones)++pScene->mRootNode->mNumChildren;
-        this->pScene->mRootNode->mChildren = new aiNode*[pScene->mRootNode->mNumChildren];
+        if (sharedData.apcOutBones) ++pScene->mRootNode->mNumChildren;
+        this->pScene->mRootNode->mChildren = new aiNode *[pScene->mRootNode->mNumChildren];
         p = 0;
-        for (uint32_t i = 0; i < pcHeader->groups_num;++i)  {
-            if (avOutList[i].empty())continue;
+        for (uint32_t i = 0; i < pcHeader->groups_num; ++i) {
+            if (avOutList[i].empty()) continue;
 
-            aiNode* const pcNode = pScene->mRootNode->mChildren[p] = new aiNode();
+            aiNode *const pcNode = pScene->mRootNode->mChildren[p] = new aiNode();
             pcNode->mNumMeshes = (unsigned int)avOutList[i].size();
             pcNode->mMeshes = new unsigned int[pcNode->mNumMeshes];
             pcNode->mParent = this->pScene->mRootNode;
-            for (unsigned int a = 0; a < pcNode->mNumMeshes;++a)
+            for (unsigned int a = 0; a < pcNode->mNumMeshes; ++a)
                 pcNode->mMeshes[a] = q + a;
             q += (unsigned int)avOutList[i].size();
 
             // setup the name of the node
-            char* const szBuffer = &aszGroupNameBuffer[i*AI_MDL7_MAX_GROUPNAMESIZE];
-			if ('\0' == *szBuffer) {
-				const size_t maxSize(buffersize - (i*AI_MDL7_MAX_GROUPNAMESIZE));
-				pcNode->mName.length = ai_snprintf(szBuffer, maxSize, "Group_%u", p);
-			} else {
-				pcNode->mName.length = ::strlen(szBuffer);
-			}
-            ::strncpy(pcNode->mName.data,szBuffer,MAXLEN-1);
+            char *const szBuffer = &aszGroupNameBuffer[i * AI_MDL7_MAX_GROUPNAMESIZE];
+            if ('\0' == *szBuffer) {
+                const size_t maxSize(buffersize - (i * AI_MDL7_MAX_GROUPNAMESIZE));
+                pcNode->mName.length = ai_snprintf(szBuffer, maxSize, "Group_%u", p);
+            } else {
+                pcNode->mName.length = (ai_uint32)::strlen(szBuffer);
+            }
+            ::strncpy(pcNode->mName.data, szBuffer, MAXLEN - 1);
             ++p;
         }
     }
 
     // if there is only one root node with a single child we can optimize it a bit ...
-    if (1 == pScene->mRootNode->mNumChildren && !sharedData.apcOutBones)    {
-        aiNode* pcOldRoot = this->pScene->mRootNode;
+    if (1 == pScene->mRootNode->mNumChildren && !sharedData.apcOutBones) {
+        aiNode *pcOldRoot = this->pScene->mRootNode;
         pScene->mRootNode = pcOldRoot->mChildren[0];
-        pcOldRoot->mChildren[0] = NULL;
+        pcOldRoot->mChildren[0] = nullptr;
         delete pcOldRoot;
-        pScene->mRootNode->mParent = NULL;
-    }
-    else pScene->mRootNode->mName.Set("<mesh_root>");
+        pScene->mRootNode->mParent = nullptr;
+    } else
+        pScene->mRootNode->mName.Set("<mesh_root>");
 
     delete[] avOutList;
     delete[] aszGroupNameBuffer;
@@ -1583,53 +1588,51 @@ void MDLImporter::InternReadFile_3DGS_MDL7( )
     if (sharedData.apcOutBones) {
         // this step adds empty dummy bones to the nodegraph
         // insert another dummy node to avoid name conflicts
-        aiNode* const pc = pScene->mRootNode->mChildren[pScene->mRootNode->mNumChildren-1] = new aiNode();
+        aiNode *const pc = pScene->mRootNode->mChildren[pScene->mRootNode->mNumChildren - 1] = new aiNode();
 
         pc->mName.Set("<skeleton_root>");
 
         // add bones to the nodegraph
         AddBonesToNodeGraph_3DGS_MDL7((const Assimp::MDL::IntBone_MDL7 **)
-            sharedData.apcOutBones,pc,0xffff);
+                                              sharedData.apcOutBones,
+                pc, 0xffff);
 
         // this steps build a valid output animation
         BuildOutputAnims_3DGS_MDL7((const Assimp::MDL::IntBone_MDL7 **)
-            sharedData.apcOutBones);
+                                           sharedData.apcOutBones);
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Copy materials
-void MDLImporter::CopyMaterials_3DGS_MDL7(MDL::IntSharedData_MDL7 &shared)
-{
+void MDLImporter::CopyMaterials_3DGS_MDL7(MDL::IntSharedData_MDL7 &shared) {
     pScene->mNumMaterials = (unsigned int)shared.pcMats.size();
-    pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials];
-    for (unsigned int i = 0; i < pScene->mNumMaterials;++i)
+    pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials];
+    for (unsigned int i = 0; i < pScene->mNumMaterials; ++i)
         pScene->mMaterials[i] = shared.pcMats[i];
 }
 
-
 // ------------------------------------------------------------------------------------------------
 // Process material references
-void MDLImporter::HandleMaterialReferences_3DGS_MDL7()
-{
+void MDLImporter::HandleMaterialReferences_3DGS_MDL7() {
     // search for referrer materials
-    for (unsigned int i = 0; i < pScene->mNumMaterials;++i) {
+    for (unsigned int i = 0; i < pScene->mNumMaterials; ++i) {
         int iIndex = 0;
-        if (AI_SUCCESS == aiGetMaterialInteger(pScene->mMaterials[i],AI_MDL7_REFERRER_MATERIAL, &iIndex) )  {
-            for (unsigned int a = 0; a < pScene->mNumMeshes;++a)    {
-                aiMesh* const pcMesh = pScene->mMeshes[a];
+        if (AI_SUCCESS == aiGetMaterialInteger(pScene->mMaterials[i], AI_MDL7_REFERRER_MATERIAL, &iIndex)) {
+            for (unsigned int a = 0; a < pScene->mNumMeshes; ++a) {
+                aiMesh *const pcMesh = pScene->mMeshes[a];
                 if (i == pcMesh->mMaterialIndex) {
                     pcMesh->mMaterialIndex = iIndex;
                 }
             }
             // collapse the rest of the array
             delete pScene->mMaterials[i];
-            for (unsigned int pp = i; pp < pScene->mNumMaterials-1;++pp)    {
+            for (unsigned int pp = i; pp < pScene->mNumMaterials - 1; ++pp) {
 
-                pScene->mMaterials[pp] = pScene->mMaterials[pp+1];
-                for (unsigned int a = 0; a < pScene->mNumMeshes;++a)    {
-                    aiMesh* const pcMesh = pScene->mMeshes[a];
-                    if (pcMesh->mMaterialIndex > i)--pcMesh->mMaterialIndex;
+                pScene->mMaterials[pp] = pScene->mMaterials[pp + 1];
+                for (unsigned int a = 0; a < pScene->mNumMeshes; ++a) {
+                    aiMesh *const pcMesh = pScene->mMeshes[a];
+                    if (pcMesh->mMaterialIndex > i) --pcMesh->mMaterialIndex;
                 }
             }
             --pScene->mNumMaterials;
@@ -1640,35 +1643,30 @@ void MDLImporter::HandleMaterialReferences_3DGS_MDL7()
 // ------------------------------------------------------------------------------------------------
 // Read bone transformation keys
 void MDLImporter::ParseBoneTrafoKeys_3DGS_MDL7(
-    const MDL::IntGroupInfo_MDL7& groupInfo,
-    IntFrameInfo_MDL7&            frame,
-    MDL::IntSharedData_MDL7&      shared)
-{
-    const MDL::Header_MDL7* const pcHeader = (const MDL::Header_MDL7*)this->mBuffer;
+        const MDL::IntGroupInfo_MDL7 &groupInfo,
+        IntFrameInfo_MDL7 &frame,
+        MDL::IntSharedData_MDL7 &shared) {
+    const MDL::Header_MDL7 *const pcHeader = (const MDL::Header_MDL7 *)this->mBuffer;
 
     // only the first group contains bone animation keys
-    if (frame.pcFrame->transmatrix_count)   {
-        if (!groupInfo.iIndex)  {
+    if (frame.pcFrame->transmatrix_count) {
+        if (!groupInfo.iIndex) {
             // skip all frames vertices. We can't support them
-            const MDL::BoneTransform_MDL7* pcBoneTransforms = (const MDL::BoneTransform_MDL7*)
-                (((const char*)frame.pcFrame) + pcHeader->frame_stc_size +
-                frame.pcFrame->vertices_count * pcHeader->framevertex_stc_size);
+            const MDL::BoneTransform_MDL7 *pcBoneTransforms = (const MDL::BoneTransform_MDL7 *)(((const char *)frame.pcFrame) + pcHeader->frame_stc_size +
+                                                                                                frame.pcFrame->vertices_count * pcHeader->framevertex_stc_size);
 
             // read all transformation matrices
-            for (unsigned int iTrafo = 0; iTrafo < frame.pcFrame->transmatrix_count;++iTrafo)   {
-                if(pcBoneTransforms->bone_index >= pcHeader->bones_num) {
+            for (unsigned int iTrafo = 0; iTrafo < frame.pcFrame->transmatrix_count; ++iTrafo) {
+                if (pcBoneTransforms->bone_index >= pcHeader->bones_num) {
                     ASSIMP_LOG_WARN("Index overflow in frame area. "
-                        "Unable to parse this bone transformation");
-                }
-                else    {
+                                    "Unable to parse this bone transformation");
+                } else {
                     AddAnimationBoneTrafoKey_3DGS_MDL7(frame.iIndex,
-                        pcBoneTransforms,shared.apcOutBones);
+                            pcBoneTransforms, shared.apcOutBones);
                 }
-                pcBoneTransforms = (const MDL::BoneTransform_MDL7*)(
-                    (const char*)pcBoneTransforms + pcHeader->bonetrans_stc_size);
+                pcBoneTransforms = (const MDL::BoneTransform_MDL7 *)((const char *)pcBoneTransforms + pcHeader->bonetrans_stc_size);
             }
-        }
-        else    {
+        } else {
             ASSIMP_LOG_WARN("Ignoring animation keyframes in groups != 0");
         }
     }
@@ -1676,79 +1674,80 @@ void MDLImporter::ParseBoneTrafoKeys_3DGS_MDL7(
 
 // ------------------------------------------------------------------------------------------------
 // Attach bones to the output nodegraph
-void MDLImporter::AddBonesToNodeGraph_3DGS_MDL7(const MDL::IntBone_MDL7** apcBones,
-    aiNode* pcParent,uint16_t iParentIndex)
-{
-    ai_assert(NULL != apcBones && NULL != pcParent);
+void MDLImporter::AddBonesToNodeGraph_3DGS_MDL7(const MDL::IntBone_MDL7 **apcBones,
+        aiNode *pcParent, uint16_t iParentIndex) {
+    ai_assert(nullptr != apcBones);
+    ai_assert(nullptr != pcParent);
 
     // get a pointer to the header ...
-    const MDL::Header_MDL7* const pcHeader = (const MDL::Header_MDL7*)this->mBuffer;
+    const MDL::Header_MDL7 *const pcHeader = (const MDL::Header_MDL7 *)this->mBuffer;
 
-    const MDL::IntBone_MDL7** apcBones2 = apcBones;
-    for (uint32_t i = 0; i <  pcHeader->bones_num;++i)  {
+    const MDL::IntBone_MDL7 **apcBones2 = apcBones;
+    for (uint32_t i = 0; i < pcHeader->bones_num; ++i) {
 
-        const MDL::IntBone_MDL7* const pcBone = *apcBones2++;
+        const MDL::IntBone_MDL7 *const pcBone = *apcBones2++;
         if (pcBone->iParent == iParentIndex) {
             ++pcParent->mNumChildren;
         }
     }
-    pcParent->mChildren = new aiNode*[pcParent->mNumChildren];
+    pcParent->mChildren = new aiNode *[pcParent->mNumChildren];
     unsigned int qq = 0;
-    for (uint32_t i = 0; i <  pcHeader->bones_num;++i)  {
+    for (uint32_t i = 0; i < pcHeader->bones_num; ++i) {
 
-        const MDL::IntBone_MDL7* const pcBone = *apcBones++;
-        if (pcBone->iParent != iParentIndex)continue;
+        const MDL::IntBone_MDL7 *const pcBone = *apcBones++;
+        if (pcBone->iParent != iParentIndex) continue;
 
-        aiNode* pcNode = pcParent->mChildren[qq++] = new aiNode();
-        pcNode->mName = aiString( pcBone->mName );
+        aiNode *pcNode = pcParent->mChildren[qq++] = new aiNode();
+        pcNode->mName = aiString(pcBone->mName);
 
-        AddBonesToNodeGraph_3DGS_MDL7(apcBones,pcNode,(uint16_t)i);
+        AddBonesToNodeGraph_3DGS_MDL7(apcBones, pcNode, (uint16_t)i);
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Build output animations
 void MDLImporter::BuildOutputAnims_3DGS_MDL7(
-    const MDL::IntBone_MDL7** apcBonesOut)
-{
-    ai_assert(NULL != apcBonesOut);
-    const MDL::Header_MDL7* const pcHeader = (const MDL::Header_MDL7*)mBuffer;
+        const MDL::IntBone_MDL7 **apcBonesOut) {
+    ai_assert(nullptr != apcBonesOut);
+    const MDL::Header_MDL7 *const pcHeader = (const MDL::Header_MDL7 *)mBuffer;
 
     // one animation ...
-    aiAnimation* pcAnim = new aiAnimation();
-    for (uint32_t i = 0; i < pcHeader->bones_num;++i)   {
+    aiAnimation *pcAnim = new aiAnimation();
+    for (uint32_t i = 0; i < pcHeader->bones_num; ++i) {
         if (!apcBonesOut[i]->pkeyPositions.empty()) {
 
             // get the last frame ... (needn't be equal to pcHeader->frames_num)
-            for (size_t qq = 0; qq < apcBonesOut[i]->pkeyPositions.size();++qq) {
+            for (size_t qq = 0; qq < apcBonesOut[i]->pkeyPositions.size(); ++qq) {
                 pcAnim->mDuration = std::max(pcAnim->mDuration, (double)
-                    apcBonesOut[i]->pkeyPositions[qq].mTime);
+                                                                        apcBonesOut[i]
+                                                                                ->pkeyPositions[qq]
+                                                                                .mTime);
             }
             ++pcAnim->mNumChannels;
         }
     }
-    if (pcAnim->mDuration)  {
-        pcAnim->mChannels = new aiNodeAnim*[pcAnim->mNumChannels];
+    if (pcAnim->mDuration) {
+        pcAnim->mChannels = new aiNodeAnim *[pcAnim->mNumChannels];
 
         unsigned int iCnt = 0;
-        for (uint32_t i = 0; i < pcHeader->bones_num;++i)   {
+        for (uint32_t i = 0; i < pcHeader->bones_num; ++i) {
             if (!apcBonesOut[i]->pkeyPositions.empty()) {
-                const MDL::IntBone_MDL7* const intBone = apcBonesOut[i];
+                const MDL::IntBone_MDL7 *const intBone = apcBonesOut[i];
 
-                aiNodeAnim* const pcNodeAnim = pcAnim->mChannels[iCnt++] = new aiNodeAnim();
-                pcNodeAnim->mNodeName = aiString( intBone->mName );
+                aiNodeAnim *const pcNodeAnim = pcAnim->mChannels[iCnt++] = new aiNodeAnim();
+                pcNodeAnim->mNodeName = aiString(intBone->mName);
 
                 // allocate enough storage for all keys
                 pcNodeAnim->mNumPositionKeys = (unsigned int)intBone->pkeyPositions.size();
-                pcNodeAnim->mNumScalingKeys  = (unsigned int)intBone->pkeyPositions.size();
+                pcNodeAnim->mNumScalingKeys = (unsigned int)intBone->pkeyPositions.size();
                 pcNodeAnim->mNumRotationKeys = (unsigned int)intBone->pkeyPositions.size();
 
                 pcNodeAnim->mPositionKeys = new aiVectorKey[pcNodeAnim->mNumPositionKeys];
-                pcNodeAnim->mScalingKeys  = new aiVectorKey[pcNodeAnim->mNumPositionKeys];
+                pcNodeAnim->mScalingKeys = new aiVectorKey[pcNodeAnim->mNumPositionKeys];
                 pcNodeAnim->mRotationKeys = new aiQuatKey[pcNodeAnim->mNumPositionKeys];
 
                 // copy all keys
-                for (unsigned int qq = 0; qq < pcNodeAnim->mNumPositionKeys;++qq)   {
+                for (unsigned int qq = 0; qq < pcNodeAnim->mNumPositionKeys; ++qq) {
                     pcNodeAnim->mPositionKeys[qq] = intBone->pkeyPositions[qq];
                     pcNodeAnim->mScalingKeys[qq] = intBone->pkeyScalings[qq];
                     pcNodeAnim->mRotationKeys[qq] = intBone->pkeyRotations[qq];
@@ -1758,19 +1757,18 @@ void MDLImporter::BuildOutputAnims_3DGS_MDL7(
 
         // store the output animation
         pScene->mNumAnimations = 1;
-        pScene->mAnimations = new aiAnimation*[1];
+        pScene->mAnimations = new aiAnimation *[1];
         pScene->mAnimations[0] = pcAnim;
-    }
-    else delete pcAnim;
+    } else
+        delete pcAnim;
 }
 
 // ------------------------------------------------------------------------------------------------
 void MDLImporter::AddAnimationBoneTrafoKey_3DGS_MDL7(unsigned int iTrafo,
-    const MDL::BoneTransform_MDL7* pcBoneTransforms,
-    MDL::IntBone_MDL7** apcBonesOut)
-{
-    ai_assert(NULL != pcBoneTransforms);
-    ai_assert(NULL != apcBonesOut);
+        const MDL::BoneTransform_MDL7 *pcBoneTransforms,
+        MDL::IntBone_MDL7 **apcBonesOut) {
+    ai_assert(nullptr != pcBoneTransforms);
+    ai_assert(nullptr != apcBonesOut);
 
     // first .. get the transformation matrix
     aiMatrix4x4 mTransform;
@@ -1791,39 +1789,38 @@ void MDLImporter::AddAnimationBoneTrafoKey_3DGS_MDL7(unsigned int iTrafo,
 
     // now decompose the transformation matrix into separate
     // scaling, rotation and translation
-    aiVectorKey vScaling,vPosition;
+    aiVectorKey vScaling, vPosition;
     aiQuatKey qRotation;
 
     // FIXME: Decompose will assert in debug builds if the matrix is invalid ...
-    mTransform.Decompose(vScaling.mValue,qRotation.mValue,vPosition.mValue);
+    mTransform.Decompose(vScaling.mValue, qRotation.mValue, vPosition.mValue);
 
     // now generate keys
     vScaling.mTime = qRotation.mTime = vPosition.mTime = (double)iTrafo;
 
     // add the keys to the bone
-    MDL::IntBone_MDL7* const pcBoneOut = apcBonesOut[pcBoneTransforms->bone_index];
-    pcBoneOut->pkeyPositions.push_back  ( vPosition );
-    pcBoneOut->pkeyScalings.push_back   ( vScaling  );
-    pcBoneOut->pkeyRotations.push_back  ( qRotation );
+    MDL::IntBone_MDL7 *const pcBoneOut = apcBonesOut[pcBoneTransforms->bone_index];
+    pcBoneOut->pkeyPositions.push_back(vPosition);
+    pcBoneOut->pkeyScalings.push_back(vScaling);
+    pcBoneOut->pkeyRotations.push_back(qRotation);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Construct output meshes
 void MDLImporter::GenerateOutputMeshes_3DGS_MDL7(
-    MDL::IntGroupData_MDL7& groupData,
-    MDL::IntSplitGroupData_MDL7& splitGroupData)
-{
-    const MDL::IntSharedData_MDL7& shared = splitGroupData.shared;
+        MDL::IntGroupData_MDL7 &groupData,
+        MDL::IntSplitGroupData_MDL7 &splitGroupData) {
+    const MDL::IntSharedData_MDL7 &shared = splitGroupData.shared;
 
     // get a pointer to the header ...
-    const MDL::Header_MDL7* const pcHeader = (const MDL::Header_MDL7*)this->mBuffer;
+    const MDL::Header_MDL7 *const pcHeader = (const MDL::Header_MDL7 *)this->mBuffer;
     const unsigned int iNumOutBones = pcHeader->bones_num;
 
-    for (std::vector<aiMaterial*>::size_type i = 0; i < shared.pcMats.size();++i)   {
-        if (!splitGroupData.aiSplit[i]->empty())    {
+    for (std::vector<aiMaterial *>::size_type i = 0; i < shared.pcMats.size(); ++i) {
+        if (!splitGroupData.aiSplit[i]->empty()) {
 
             // allocate the output mesh
-            aiMesh* pcMesh = new aiMesh();
+            aiMesh *pcMesh = new aiMesh();
 
             pcMesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
             pcMesh->mMaterialIndex = (unsigned int)i;
@@ -1832,7 +1829,7 @@ void MDLImporter::GenerateOutputMeshes_3DGS_MDL7(
             pcMesh->mNumFaces = (unsigned int)splitGroupData.aiSplit[i]->size();
             pcMesh->mFaces = new aiFace[pcMesh->mNumFaces];
 
-            pcMesh->mNumVertices = pcMesh->mNumFaces*3;
+            pcMesh->mNumVertices = pcMesh->mNumFaces * 3;
             pcMesh->mVertices = new aiVector3D[pcMesh->mNumVertices];
             pcMesh->mNormals = new aiVector3D[pcMesh->mNumVertices];
 
@@ -1847,15 +1844,15 @@ void MDLImporter::GenerateOutputMeshes_3DGS_MDL7(
 
             // iterate through all faces and build an unique set of vertices
             unsigned int iCurrent = 0;
-            for (unsigned int iFace = 0; iFace < pcMesh->mNumFaces;++iFace) {
+            for (unsigned int iFace = 0; iFace < pcMesh->mNumFaces; ++iFace) {
                 pcMesh->mFaces[iFace].mNumIndices = 3;
                 pcMesh->mFaces[iFace].mIndices = new unsigned int[3];
 
                 unsigned int iSrcFace = splitGroupData.aiSplit[i]->operator[](iFace);
-                const MDL::IntFace_MDL7& oldFace = groupData.pcFaces[iSrcFace];
+                const MDL::IntFace_MDL7 &oldFace = groupData.pcFaces[iSrcFace];
 
                 // iterate through all face indices
-                for (unsigned int c = 0; c < 3;++c) {
+                for (unsigned int c = 0; c < 3; ++c) {
                     const uint32_t iIndex = oldFace.mIndices[c];
                     pcMesh->mVertices[iCurrent] = groupData.vPositions[iIndex];
                     pcMesh->mNormals[iCurrent] = groupData.vNormals[iIndex];
@@ -1874,51 +1871,50 @@ void MDLImporter::GenerateOutputMeshes_3DGS_MDL7(
             // if we have bones in the mesh we'll need to generate
             // proper vertex weights for them
             if (!groupData.aiBones.empty()) {
-                std::vector<std::vector<unsigned int> > aaiVWeightList;
+                std::vector<std::vector<unsigned int>> aaiVWeightList;
                 aaiVWeightList.resize(iNumOutBones);
 
-                int iCurrent = 0;
-                for (unsigned int iFace = 0; iFace < pcMesh->mNumFaces;++iFace) {
+                int iCurrentWeight = 0;
+                for (unsigned int iFace = 0; iFace < pcMesh->mNumFaces; ++iFace) {
                     unsigned int iSrcFace = splitGroupData.aiSplit[i]->operator[](iFace);
-                    const MDL::IntFace_MDL7& oldFace = groupData.pcFaces[iSrcFace];
+                    const MDL::IntFace_MDL7 &oldFace = groupData.pcFaces[iSrcFace];
 
                     // iterate through all face indices
-                    for (unsigned int c = 0; c < 3;++c) {
-                        unsigned int iBone = groupData.aiBones[ oldFace.mIndices[c] ];
-                        if (UINT_MAX != iBone)  {
-                            if (iBone >= iNumOutBones)  {
+                    for (unsigned int c = 0; c < 3; ++c) {
+                        unsigned int iBone = groupData.aiBones[oldFace.mIndices[c]];
+                        if (UINT_MAX != iBone) {
+                            if (iBone >= iNumOutBones) {
                                 ASSIMP_LOG_ERROR("Bone index overflow. "
-                                    "The bone index of a vertex exceeds the allowed range. ");
-                                iBone = iNumOutBones-1;
+                                                 "The bone index of a vertex exceeds the allowed range. ");
+                                iBone = iNumOutBones - 1;
                             }
-                            aaiVWeightList[ iBone ].push_back ( iCurrent );
+                            aaiVWeightList[iBone].push_back(iCurrentWeight);
                         }
-                        ++iCurrent;
+                        ++iCurrentWeight;
                     }
                 }
                 // now check which bones are required ...
-                for (std::vector<std::vector<unsigned int> >::const_iterator k =  aaiVWeightList.begin();k != aaiVWeightList.end();++k) {
+                for (std::vector<std::vector<unsigned int>>::const_iterator k = aaiVWeightList.begin(); k != aaiVWeightList.end(); ++k) {
                     if (!(*k).empty()) {
                         ++pcMesh->mNumBones;
                     }
                 }
-                pcMesh->mBones = new aiBone*[pcMesh->mNumBones];
+                pcMesh->mBones = new aiBone *[pcMesh->mNumBones];
                 iCurrent = 0;
-                for (std::vector<std::vector<unsigned int> >::const_iterator k = aaiVWeightList.begin();k!= aaiVWeightList.end();++k,++iCurrent)
-                {
+                for (std::vector<std::vector<unsigned int>>::const_iterator k = aaiVWeightList.begin(); k != aaiVWeightList.end(); ++k, ++iCurrent) {
                     if ((*k).empty())
                         continue;
 
                     // seems we'll need this node
-                    aiBone* pcBone = pcMesh->mBones[ iCurrent ] = new aiBone();
-                    pcBone->mName = aiString(shared.apcOutBones[ iCurrent ]->mName);
-                    pcBone->mOffsetMatrix = shared.apcOutBones[ iCurrent ]->mOffsetMatrix;
+                    aiBone *pcBone = pcMesh->mBones[iCurrent] = new aiBone();
+                    pcBone->mName = aiString(shared.apcOutBones[iCurrent]->mName);
+                    pcBone->mOffsetMatrix = shared.apcOutBones[iCurrent]->mOffsetMatrix;
 
                     // setup vertex weights
                     pcBone->mNumWeights = (unsigned int)(*k).size();
                     pcBone->mWeights = new aiVertexWeight[pcBone->mNumWeights];
 
-                    for (unsigned int weight = 0; weight < pcBone->mNumWeights;++weight)    {
+                    for (unsigned int weight = 0; weight < pcBone->mNumWeights; ++weight) {
                         pcBone->mWeights[weight].mVertexId = (*k)[weight];
                         pcBone->mWeights[weight].mWeight = 1.0f;
                     }
@@ -1933,33 +1929,49 @@ void MDLImporter::GenerateOutputMeshes_3DGS_MDL7(
 // ------------------------------------------------------------------------------------------------
 // Join to materials
 void MDLImporter::JoinSkins_3DGS_MDL7(
-    aiMaterial* pcMat1,
-    aiMaterial* pcMat2,
-    aiMaterial* pcMatOut)
-{
-    ai_assert(NULL != pcMat1 && NULL != pcMat2 && NULL != pcMatOut);
+        aiMaterial *pcMat1,
+        aiMaterial *pcMat2,
+        aiMaterial *pcMatOut) {
+    ai_assert(nullptr != pcMat1);
+    ai_assert(nullptr != pcMat2);
+    ai_assert(nullptr != pcMatOut);
 
     // first create a full copy of the first skin property set
     // and assign it to the output material
-    aiMaterial::CopyPropertyList(pcMatOut,pcMat1);
+    aiMaterial::CopyPropertyList(pcMatOut, pcMat1);
 
     int iVal = 0;
-    pcMatOut->AddProperty<int>(&iVal,1,AI_MATKEY_UVWSRC_DIFFUSE(0));
+    pcMatOut->AddProperty<int>(&iVal, 1, AI_MATKEY_UVWSRC_DIFFUSE(0));
 
     // then extract the diffuse texture from the second skin,
     // setup 1 as UV source and we have it
     aiString sString;
-    if(AI_SUCCESS == aiGetMaterialString ( pcMat2, AI_MATKEY_TEXTURE_DIFFUSE(0),&sString )) {
+    if (AI_SUCCESS == aiGetMaterialString(pcMat2, AI_MATKEY_TEXTURE_DIFFUSE(0), &sString)) {
         iVal = 1;
-        pcMatOut->AddProperty<int>(&iVal,1,AI_MATKEY_UVWSRC_DIFFUSE(1));
-        pcMatOut->AddProperty(&sString,AI_MATKEY_TEXTURE_DIFFUSE(1));
+        pcMatOut->AddProperty<int>(&iVal, 1, AI_MATKEY_UVWSRC_DIFFUSE(1));
+        pcMatOut->AddProperty(&sString, AI_MATKEY_TEXTURE_DIFFUSE(1));
     }
 }
 
+// ------------------------------------------------------------------------------------------------
+// Read a Half-life 1 MDL
+void MDLImporter::InternReadFile_HL1(const std::string &pFile, const uint32_t iMagicWord) {
+    // We can't correctly load an MDL from a MDL "sequence" file.
+    if (iMagicWord == AI_MDL_MAGIC_NUMBER_BE_HL2b || iMagicWord == AI_MDL_MAGIC_NUMBER_LE_HL2b)
+        throw DeadlyImportError("Impossible to properly load a model from an MDL sequence file.");
+
+    // Read the MDL file.
+    HalfLife::HL1MDLLoader loader(
+            pScene,
+            mIOHandler,
+            mBuffer,
+            pFile,
+            mHL1ImportSettings);
+}
+
 // ------------------------------------------------------------------------------------------------
 // Read a half-life 2 MDL
-void MDLImporter::InternReadFile_HL2( )
-{
+void MDLImporter::InternReadFile_HL2() {
     //const MDL::Header_HL2* pcHeader = (const MDL::Header_HL2*)this->mBuffer;
     throw DeadlyImportError("HL2 MDLs are not implemented");
 }
diff --git a/Engine/lib/assimp/code/MDL/MDLLoader.h b/Engine/lib/assimp/code/AssetLib/MDL/MDLLoader.h
similarity index 95%
rename from Engine/lib/assimp/code/MDL/MDLLoader.h
rename to Engine/lib/assimp/code/AssetLib/MDL/MDLLoader.h
index c5ebac024..b7d87e88d 100644
--- a/Engine/lib/assimp/code/MDL/MDLLoader.h
+++ b/Engine/lib/assimp/code/AssetLib/MDL/MDLLoader.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -44,19 +43,19 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /**  @file MDLLoader.h
  *   @brief Declaration of the loader for MDL files
  */
-
+#pragma once
 #ifndef AI_MDLLOADER_H_INCLUDED
 #define AI_MDLLOADER_H_INCLUDED
 
 #include <assimp/BaseImporter.h>
 #include "MDLFileData.h"
-#include "HMP/HalfLifeFileData.h"
+#include "AssetLib/HMP/HalfLifeFileData.h"
+#include "AssetLib/MDL/HalfLife/HL1ImportSettings.h"
 
 struct aiNode;
 struct aiTexture;
 
-namespace Assimp    {
-
+namespace Assimp {
 
 using namespace MDL;
 
@@ -77,6 +76,7 @@ using namespace MDL;
  *      <li>3D Game Studio MDL3, MDL4</li>
  *      <li>3D Game Studio MDL5</li>
  *      <li>3D Game Studio MDL7</li>
+ *      <li>Halflife 1</li>
  *      <li>Halflife 2</li>
  *   </ul>
  *  These formats are partially identical and it would be possible to load
@@ -87,34 +87,34 @@ class MDLImporter : public BaseImporter
 {
 public:
     MDLImporter();
-    ~MDLImporter();
+    ~MDLImporter() override;
 
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
     * See BaseImporter::CanRead() for details.  */
     bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
+        bool checkSig) const override;
 
     // -------------------------------------------------------------------
     /** Called prior to ReadFile().
     * The function is a request to the importer to update its configuration
     * basing on the Importer's configuration property list.
     */
-    void SetupProperties(const Importer* pImp);
+    void SetupProperties(const Importer* pImp) override;
 
 protected:
     // -------------------------------------------------------------------
     /** Return importer meta information.
      * See #BaseImporter::GetInfo for the details
      */
-    const aiImporterDesc* GetInfo () const;
+    const aiImporterDesc* GetInfo () const override;
 
     // -------------------------------------------------------------------
     /** Imports the given file into the given scene structure.
     * See BaseImporter::InternReadFile() for details
     */
     void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
+        IOSystem* pIOHandler) override;
 
     // -------------------------------------------------------------------
     /** Import a quake 1 MDL file (IDPO)
@@ -131,6 +131,11 @@ protected:
     */
     void InternReadFile_3DGS_MDL7( );
 
+    // -------------------------------------------------------------------
+    /** Import a Half-Life 1 MDL file
+    */
+    void InternReadFile_HL1(const std::string& pFile, const uint32_t iMagicWord);
+
     // -------------------------------------------------------------------
     /** Import a CS:S/HL2 MDL file (not fully implemented)
     */
@@ -315,7 +320,7 @@ protected:
     /** Load the bone list of a MDL7 file
      * \return If the bones could be loaded successfully, a valid
      *   array containing pointers to a temporary bone
-     *   representation. NULL if the bones could not be loaded.
+     *   representation. nullptr if the bones could not be loaded.
      */
     MDL::IntBone_MDL7** LoadBones_3DGS_MDL7();
 
@@ -429,13 +434,16 @@ protected:
     unsigned int iGSFileVersion;
 
     /** Output I/O handler. used to load external lmp files */
-    IOSystem* pIOHandler;
+    IOSystem* mIOHandler;
 
     /** Output scene to be filled */
     aiScene* pScene;
 
     /** Size of the input file in bytes */
     unsigned int iFileSize;
+
+    /* Configuration for HL1 MDL */
+    HalfLife::HL1ImportSettings mHL1ImportSettings;
 };
 
 } // end of namespace Assimp
diff --git a/Engine/lib/assimp/code/MDL/MDLMaterialLoader.cpp b/Engine/lib/assimp/code/AssetLib/MDL/MDLMaterialLoader.cpp
similarity index 59%
rename from Engine/lib/assimp/code/MDL/MDLMaterialLoader.cpp
rename to Engine/lib/assimp/code/AssetLib/MDL/MDLMaterialLoader.cpp
index 0a196761f..2de43d241 100644
--- a/Engine/lib/assimp/code/MDL/MDLMaterialLoader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/MDL/MDLMaterialLoader.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,85 +41,76 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** @file Implementation of the material part of the MDL importer class */
 
-
 #ifndef ASSIMP_BUILD_NO_MDL_IMPORTER
 
-// internal headers
-#include "MDLLoader.h"
 #include "MDLDefaultColorMap.h"
+#include "MDLLoader.h"
+
 #include <assimp/StringUtils.h>
-#include <assimp/texture.h>
-#include <assimp/IOSystem.hpp>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/scene.h>
-#include <assimp/Defines.h>
 #include <assimp/qnan.h>
+#include <assimp/scene.h>
+#include <assimp/texture.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOSystem.hpp>
 
 #include <memory>
 
-
 using namespace Assimp;
-static aiTexel* const bad_texel = reinterpret_cast<aiTexel*>(SIZE_MAX);
+
+static aiTexel *const bad_texel = reinterpret_cast<aiTexel *>(SIZE_MAX);
 
 // ------------------------------------------------------------------------------------------------
 // Find a suitable palette file or take the default one
-void MDLImporter::SearchPalette(const unsigned char** pszColorMap)
-{
+void MDLImporter::SearchPalette(const unsigned char **pszColorMap) {
     // now try to find the color map in the current directory
-    IOStream* pcStream = pIOHandler->Open(configPalette,"rb");
+    IOStream *pcStream = mIOHandler->Open(configPalette, "rb");
 
-    const unsigned char* szColorMap = (const unsigned char*)::g_aclrDefaultColorMap;
-    if(pcStream)
-    {
-        if (pcStream->FileSize() >= 768)
-        {
+    const unsigned char *szColorMap = (const unsigned char *)::g_aclrDefaultColorMap;
+    if (pcStream) {
+        if (pcStream->FileSize() >= 768) {
             size_t len = 256 * 3;
-            unsigned char* colorMap = new unsigned char[len];
+            unsigned char *colorMap = new unsigned char[len];
             szColorMap = colorMap;
-            pcStream->Read(colorMap, len,1);
+            pcStream->Read(colorMap, len, 1);
             ASSIMP_LOG_INFO("Found valid colormap.lmp in directory. "
-                "It will be used to decode embedded textures in palletized formats.");
+                            "It will be used to decode embedded textures in palletized formats.");
         }
         delete pcStream;
-        pcStream = NULL;
+        pcStream = nullptr;
     }
     *pszColorMap = szColorMap;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Free the palette again
-void MDLImporter::FreePalette(const unsigned char* szColorMap)
-{
-    if (szColorMap != (const unsigned char*)::g_aclrDefaultColorMap)
+void MDLImporter::FreePalette(const unsigned char *szColorMap) {
+    if (szColorMap != (const unsigned char *)::g_aclrDefaultColorMap) {
         delete[] szColorMap;
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Check whether we can replace a texture with a single color
-aiColor4D MDLImporter::ReplaceTextureWithColor(const aiTexture* pcTexture)
-{
-    ai_assert(NULL != pcTexture);
+aiColor4D MDLImporter::ReplaceTextureWithColor(const aiTexture *pcTexture) {
+    ai_assert(nullptr != pcTexture);
 
     aiColor4D clrOut;
     clrOut.r = get_qnan();
     if (!pcTexture->mHeight || !pcTexture->mWidth)
         return clrOut;
 
-    const unsigned int iNumPixels = pcTexture->mHeight*pcTexture->mWidth;
-    const aiTexel* pcTexel = pcTexture->pcData+1;
-    const aiTexel* const pcTexelEnd = &pcTexture->pcData[iNumPixels];
+    const unsigned int iNumPixels = pcTexture->mHeight * pcTexture->mWidth;
+    const aiTexel *pcTexel = pcTexture->pcData + 1;
+    const aiTexel *const pcTexelEnd = &pcTexture->pcData[iNumPixels];
 
-    while (pcTexel != pcTexelEnd)
-    {
-        if (*pcTexel != *(pcTexel-1))
-        {
-            pcTexel = NULL;
+    while (pcTexel != pcTexelEnd) {
+        if (*pcTexel != *(pcTexel - 1)) {
+            pcTexel = nullptr;
             break;
         }
         ++pcTexel;
     }
-    if (pcTexel)
-    {
+    if (pcTexel) {
         clrOut.r = pcTexture->pcData->r / 255.0f;
         clrOut.g = pcTexture->pcData->g / 255.0f;
         clrOut.b = pcTexture->pcData->b / 255.0f;
@@ -132,28 +121,29 @@ aiColor4D MDLImporter::ReplaceTextureWithColor(const aiTexture* pcTexture)
 
 // ------------------------------------------------------------------------------------------------
 // Read a texture from a MDL3 file
-void MDLImporter::CreateTextureARGB8_3DGS_MDL3(const unsigned char* szData)
-{
-    const MDL::Header *pcHeader = (const MDL::Header*)mBuffer;  //the endianness is already corrected in the InternReadFile_3DGS_MDL345 function
+void MDLImporter::CreateTextureARGB8_3DGS_MDL3(const unsigned char *szData) {
+    const MDL::Header *pcHeader = (const MDL::Header *)mBuffer; //the endianness is already corrected in the InternReadFile_3DGS_MDL345 function
 
     VALIDATE_FILE_SIZE(szData + pcHeader->skinwidth *
-        pcHeader->skinheight);
+                                        pcHeader->skinheight);
 
     // allocate a new texture object
-    aiTexture* pcNew = new aiTexture();
+    aiTexture *pcNew = new aiTexture();
     pcNew->mWidth = pcHeader->skinwidth;
     pcNew->mHeight = pcHeader->skinheight;
 
+    if(pcNew->mWidth != 0 && pcNew->mHeight > UINT_MAX/pcNew->mWidth) {
+        throw DeadlyImportError("Invalid MDL file. A texture is too big.");
+    }
     pcNew->pcData = new aiTexel[pcNew->mWidth * pcNew->mHeight];
 
-    const unsigned char* szColorMap;
+    const unsigned char *szColorMap;
     this->SearchPalette(&szColorMap);
 
     // copy texture data
-    for (unsigned int i = 0; i < pcNew->mWidth*pcNew->mHeight;++i)
-    {
+    for (unsigned int i = 0; i < pcNew->mWidth * pcNew->mHeight; ++i) {
         const unsigned char val = szData[i];
-        const unsigned char* sz = &szColorMap[val*3];
+        const unsigned char *sz = &szColorMap[val * 3];
 
         pcNew->pcData[i].a = 0xFF;
         pcNew->pcData[i].r = *sz++;
@@ -164,29 +154,26 @@ void MDLImporter::CreateTextureARGB8_3DGS_MDL3(const unsigned char* szData)
     FreePalette(szColorMap);
 
     // store the texture
-    aiTexture** pc = this->pScene->mTextures;
-    this->pScene->mTextures = new aiTexture*[pScene->mNumTextures+1];
-    for (unsigned int i = 0; i <pScene->mNumTextures;++i)
+    aiTexture **pc = this->pScene->mTextures;
+    this->pScene->mTextures = new aiTexture *[pScene->mNumTextures + 1];
+    for (unsigned int i = 0; i < pScene->mNumTextures; ++i)
         pScene->mTextures[i] = pc[i];
 
     pScene->mTextures[this->pScene->mNumTextures] = pcNew;
     pScene->mNumTextures++;
     delete[] pc;
-    return;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Read a texture from a MDL4 file
-void MDLImporter::CreateTexture_3DGS_MDL4(const unsigned char* szData,
-    unsigned int iType,
-     unsigned int* piSkip)
-{
-    ai_assert(NULL != piSkip);
+void MDLImporter::CreateTexture_3DGS_MDL4(const unsigned char *szData,
+        unsigned int iType,
+        unsigned int *piSkip) {
+    ai_assert(nullptr != piSkip);
 
-    const MDL::Header *pcHeader = (const MDL::Header*)mBuffer;  //the endianness is already corrected in the InternReadFile_3DGS_MDL345 function
+    const MDL::Header *pcHeader = (const MDL::Header *)mBuffer; //the endianness is already corrected in the InternReadFile_3DGS_MDL345 function
 
-    if (iType == 1 || iType > 3)
-    {
+    if (iType == 1 || iType > 3) {
         ASSIMP_LOG_ERROR("Unsupported texture file format");
         return;
     }
@@ -194,35 +181,30 @@ void MDLImporter::CreateTexture_3DGS_MDL4(const unsigned char* szData,
     const bool bNoRead = *piSkip == UINT_MAX;
 
     // allocate a new texture object
-    aiTexture* pcNew = new aiTexture();
+    aiTexture *pcNew = new aiTexture();
     pcNew->mWidth = pcHeader->skinwidth;
     pcNew->mHeight = pcHeader->skinheight;
 
-    if (bNoRead)pcNew->pcData = bad_texel;
-    ParseTextureColorData(szData,iType,piSkip,pcNew);
+    if (bNoRead) pcNew->pcData = bad_texel;
+    ParseTextureColorData(szData, iType, piSkip, pcNew);
 
     // store the texture
-    if (!bNoRead)
-    {
-        if (!this->pScene->mNumTextures)
-        {
+    if (!bNoRead) {
+        if (!this->pScene->mNumTextures) {
             pScene->mNumTextures = 1;
-            pScene->mTextures = new aiTexture*[1];
+            pScene->mTextures = new aiTexture *[1];
             pScene->mTextures[0] = pcNew;
-        }
-        else
-        {
-            aiTexture** pc = pScene->mTextures;
-            pScene->mTextures = new aiTexture*[pScene->mNumTextures+1];
-            for (unsigned int i = 0; i < this->pScene->mNumTextures;++i)
+        } else {
+            aiTexture **pc = pScene->mTextures;
+            pScene->mTextures = new aiTexture *[pScene->mNumTextures + 1];
+            for (unsigned int i = 0; i < this->pScene->mNumTextures; ++i)
                 pScene->mTextures[i] = pc[i];
             pScene->mTextures[pScene->mNumTextures] = pcNew;
             pScene->mNumTextures++;
             delete[] pc;
         }
-    }
-    else {
-        pcNew->pcData = NULL;
+    } else {
+        pcNew->pcData = nullptr;
         delete pcNew;
     }
     return;
@@ -230,31 +212,30 @@ void MDLImporter::CreateTexture_3DGS_MDL4(const unsigned char* szData,
 
 // ------------------------------------------------------------------------------------------------
 // Load color data of a texture and convert it to our output format
-void MDLImporter::ParseTextureColorData(const unsigned char* szData,
-    unsigned int iType,
-    unsigned int* piSkip,
-    aiTexture* pcNew)
-{
+void MDLImporter::ParseTextureColorData(const unsigned char *szData,
+        unsigned int iType,
+        unsigned int *piSkip,
+        aiTexture *pcNew) {
     const bool do_read = bad_texel != pcNew->pcData;
 
     // allocate storage for the texture image
     if (do_read) {
+        if(pcNew->mWidth != 0 && pcNew->mHeight > UINT_MAX/pcNew->mWidth) {
+            throw DeadlyImportError("Invalid MDL file. A texture is too big.");
+        }
         pcNew->pcData = new aiTexel[pcNew->mWidth * pcNew->mHeight];
     }
 
     // R5G6B5 format (with or without MIPs)
     // ****************************************************************
-    if (2 == iType || 10 == iType)
-    {
-        VALIDATE_FILE_SIZE(szData + pcNew->mWidth*pcNew->mHeight*2);
+    if (2 == iType || 10 == iType) {
+        VALIDATE_FILE_SIZE(szData + pcNew->mWidth * pcNew->mHeight * 2);
 
         // copy texture data
         unsigned int i;
-        if (do_read)
-        {
-            for (i = 0; i < pcNew->mWidth*pcNew->mHeight;++i)
-            {
-                MDL::RGB565 val = ((MDL::RGB565*)szData)[i];
+        if (do_read) {
+            for (i = 0; i < pcNew->mWidth * pcNew->mHeight; ++i) {
+                MDL::RGB565 val = ((MDL::RGB565 *)szData)[i];
                 AI_SWAP2(val);
 
                 pcNew->pcData[i].a = 0xFF;
@@ -262,30 +243,27 @@ void MDLImporter::ParseTextureColorData(const unsigned char* szData,
                 pcNew->pcData[i].g = (unsigned char)val.g << 2;
                 pcNew->pcData[i].b = (unsigned char)val.r << 3;
             }
+        } else {
+            i = pcNew->mWidth * pcNew->mHeight;
         }
-        else i = pcNew->mWidth*pcNew->mHeight;
         *piSkip = i * 2;
 
         // apply MIP maps
-        if (10 == iType)
-        {
+        if (10 == iType) {
             *piSkip += ((i >> 2) + (i >> 4) + (i >> 6)) << 1;
             VALIDATE_FILE_SIZE(szData + *piSkip);
         }
     }
     // ARGB4 format (with or without MIPs)
     // ****************************************************************
-    else if (3 == iType || 11 == iType)
-    {
-        VALIDATE_FILE_SIZE(szData + pcNew->mWidth*pcNew->mHeight*4);
+    else if (3 == iType || 11 == iType) {
+        VALIDATE_FILE_SIZE(szData + pcNew->mWidth * pcNew->mHeight * 4);
 
         // copy texture data
         unsigned int i;
-        if (do_read)
-        {
-            for (i = 0; i < pcNew->mWidth*pcNew->mHeight;++i)
-            {
-                MDL::ARGB4 val = ((MDL::ARGB4*)szData)[i];
+        if (do_read) {
+            for (i = 0; i < pcNew->mWidth * pcNew->mHeight; ++i) {
+                MDL::ARGB4 val = ((MDL::ARGB4 *)szData)[i];
                 AI_SWAP2(val);
 
                 pcNew->pcData[i].a = (unsigned char)val.a << 4;
@@ -293,95 +271,83 @@ void MDLImporter::ParseTextureColorData(const unsigned char* szData,
                 pcNew->pcData[i].g = (unsigned char)val.g << 4;
                 pcNew->pcData[i].b = (unsigned char)val.b << 4;
             }
-        }
-        else i = pcNew->mWidth*pcNew->mHeight;
+        } else
+            i = pcNew->mWidth * pcNew->mHeight;
         *piSkip = i * 2;
 
         // apply MIP maps
-        if (11 == iType)
-        {
+        if (11 == iType) {
             *piSkip += ((i >> 2) + (i >> 4) + (i >> 6)) << 1;
             VALIDATE_FILE_SIZE(szData + *piSkip);
         }
     }
     // RGB8 format (with or without MIPs)
     // ****************************************************************
-    else if (4 == iType || 12 == iType)
-    {
-        VALIDATE_FILE_SIZE(szData + pcNew->mWidth*pcNew->mHeight*3);
+    else if (4 == iType || 12 == iType) {
+        VALIDATE_FILE_SIZE(szData + pcNew->mWidth * pcNew->mHeight * 3);
 
         // copy texture data
         unsigned int i;
-        if (do_read)
-        {
-            for (i = 0; i < pcNew->mWidth*pcNew->mHeight;++i)
-            {
-                const unsigned char* _szData = &szData[i*3];
+        if (do_read) {
+            for (i = 0; i < pcNew->mWidth * pcNew->mHeight; ++i) {
+                const unsigned char *_szData = &szData[i * 3];
 
                 pcNew->pcData[i].a = 0xFF;
                 pcNew->pcData[i].b = *_szData++;
                 pcNew->pcData[i].g = *_szData++;
                 pcNew->pcData[i].r = *_szData;
             }
-        }
-        else i = pcNew->mWidth*pcNew->mHeight;
-
+        } else
+            i = pcNew->mWidth * pcNew->mHeight;
 
         // apply MIP maps
         *piSkip = i * 3;
-        if (12 == iType)
-        {
-            *piSkip += ((i >> 2) + (i >> 4) + (i >> 6)) *3;
+        if (12 == iType) {
+            *piSkip += ((i >> 2) + (i >> 4) + (i >> 6)) * 3;
             VALIDATE_FILE_SIZE(szData + *piSkip);
         }
     }
     // ARGB8 format (with ir without MIPs)
     // ****************************************************************
-    else if (5 == iType || 13 == iType)
-    {
-        VALIDATE_FILE_SIZE(szData + pcNew->mWidth*pcNew->mHeight*4);
+    else if (5 == iType || 13 == iType) {
+        VALIDATE_FILE_SIZE(szData + pcNew->mWidth * pcNew->mHeight * 4);
 
         // copy texture data
         unsigned int i;
-        if (do_read)
-        {
-            for (i = 0; i < pcNew->mWidth*pcNew->mHeight;++i)
-            {
-                const unsigned char* _szData = &szData[i*4];
+        if (do_read) {
+            for (i = 0; i < pcNew->mWidth * pcNew->mHeight; ++i) {
+                const unsigned char *_szData = &szData[i * 4];
 
                 pcNew->pcData[i].b = *_szData++;
                 pcNew->pcData[i].g = *_szData++;
                 pcNew->pcData[i].r = *_szData++;
                 pcNew->pcData[i].a = *_szData;
             }
+        } else {
+            i = pcNew->mWidth * pcNew->mHeight;
         }
-        else i = pcNew->mWidth*pcNew->mHeight;
 
         // apply MIP maps
         *piSkip = i << 2;
-        if (13 == iType)
-        {
+        if (13 == iType) {
             *piSkip += ((i >> 2) + (i >> 4) + (i >> 6)) << 2;
         }
     }
     // palletized 8 bit texture. As for Quake 1
     // ****************************************************************
-    else if (0 == iType)
-    {
-        VALIDATE_FILE_SIZE(szData + pcNew->mWidth*pcNew->mHeight);
+    else if (0 == iType) {
+        VALIDATE_FILE_SIZE(szData + pcNew->mWidth * pcNew->mHeight);
 
         // copy texture data
         unsigned int i;
-        if (do_read)
-        {
+        if (do_read) {
 
-            const unsigned char* szColorMap;
+            const unsigned char *szColorMap;
             SearchPalette(&szColorMap);
 
-            for (i = 0; i < pcNew->mWidth*pcNew->mHeight;++i)
-            {
+            for (i = 0; i < pcNew->mWidth * pcNew->mHeight; ++i) {
                 const unsigned char val = szData[i];
-                const unsigned char* sz = &szColorMap[val*3];
+                const unsigned char *sz = &szColorMap[val * 3];
 
                 pcNew->pcData[i].a = 0xFF;
                 pcNew->pcData[i].r = *sz++;
@@ -390,8 +356,8 @@ void MDLImporter::ParseTextureColorData(const unsigned char* szData,
             }
             this->FreePalette(szColorMap);
 
-        }
-        else i = pcNew->mWidth*pcNew->mHeight;
+        } else
+            i = pcNew->mWidth * pcNew->mHeight;
         *piSkip = i;
 
         // FIXME: Also support for MIP maps?
@@ -400,24 +366,23 @@ void MDLImporter::ParseTextureColorData(const unsigned char* szData,
 
 // ------------------------------------------------------------------------------------------------
 // Get a texture from a MDL5 file
-void MDLImporter::CreateTexture_3DGS_MDL5(const unsigned char* szData,
-    unsigned int iType,
-    unsigned int* piSkip)
-{
-    ai_assert(NULL != piSkip);
+void MDLImporter::CreateTexture_3DGS_MDL5(const unsigned char *szData,
+        unsigned int iType,
+        unsigned int *piSkip) {
+    ai_assert(nullptr != piSkip);
     bool bNoRead = *piSkip == UINT_MAX;
 
     // allocate a new texture object
-    aiTexture* pcNew = new aiTexture();
+    aiTexture *pcNew = new aiTexture();
 
-    VALIDATE_FILE_SIZE(szData+8);
+    VALIDATE_FILE_SIZE(szData + 8);
 
     // first read the size of the texture
-    pcNew->mWidth = *((uint32_t*)szData);
+    pcNew->mWidth = *((uint32_t *)szData);
     AI_SWAP4(pcNew->mWidth);
     szData += sizeof(uint32_t);
 
-    pcNew->mHeight = *((uint32_t*)szData);
+    pcNew->mHeight = *((uint32_t *)szData);
     AI_SWAP4(pcNew->mHeight);
     szData += sizeof(uint32_t);
 
@@ -428,15 +393,13 @@ void MDLImporter::CreateTexture_3DGS_MDL5(const unsigned char* szData,
     // this should not occur - at least the docs say it shouldn't.
     // however, one can easily try out what MED does if you have
     // a model with a DDS texture and export it to MDL5 ...
-    // yeah, it embedds the DDS file.
-    if (6 == iType)
-    {
+    // yeah, it embeds the DDS file.
+    if (6 == iType) {
         // this is a compressed texture in DDS format
         *piSkip = pcNew->mWidth;
         VALIDATE_FILE_SIZE(szData + *piSkip);
 
-        if (!bNoRead)
-        {
+        if (!bNoRead) {
             // place a hint and let the application know that this is a DDS file
             pcNew->mHeight = 0;
             pcNew->achFormatHint[0] = 'd';
@@ -444,40 +407,33 @@ void MDLImporter::CreateTexture_3DGS_MDL5(const unsigned char* szData,
             pcNew->achFormatHint[2] = 's';
             pcNew->achFormatHint[3] = '\0';
 
-            pcNew->pcData = (aiTexel*) new unsigned char[pcNew->mWidth];
-            ::memcpy(pcNew->pcData,szData,pcNew->mWidth);
+            pcNew->pcData = (aiTexel *)new unsigned char[pcNew->mWidth];
+            ::memcpy(pcNew->pcData, szData, pcNew->mWidth);
         }
-    }
-    else
-    {
+    } else {
         // parse the color data of the texture
-        ParseTextureColorData(szData,iType,piSkip,pcNew);
+        ParseTextureColorData(szData, iType, piSkip, pcNew);
     }
     *piSkip += sizeof(uint32_t) * 2;
 
-    if (!bNoRead)
-    {
+    if (!bNoRead) {
         // store the texture
-        if (!this->pScene->mNumTextures)
-        {
+        if (!this->pScene->mNumTextures) {
             pScene->mNumTextures = 1;
-            pScene->mTextures = new aiTexture*[1];
+            pScene->mTextures = new aiTexture *[1];
             pScene->mTextures[0] = pcNew;
-        }
-        else
-        {
-            aiTexture** pc = pScene->mTextures;
-            pScene->mTextures = new aiTexture*[pScene->mNumTextures+1];
-            for (unsigned int i = 0; i < pScene->mNumTextures;++i)
+        } else {
+            aiTexture **pc = pScene->mTextures;
+            pScene->mTextures = new aiTexture *[pScene->mNumTextures + 1];
+            for (unsigned int i = 0; i < pScene->mNumTextures; ++i)
                 this->pScene->mTextures[i] = pc[i];
 
             pScene->mTextures[pScene->mNumTextures] = pcNew;
             pScene->mNumTextures++;
             delete[] pc;
         }
-    }
-    else {
-        pcNew->pcData = NULL;
+    } else {
+        pcNew->pcData = nullptr;
         delete pcNew;
     }
     return;
@@ -486,34 +442,33 @@ void MDLImporter::CreateTexture_3DGS_MDL5(const unsigned char* szData,
 // ------------------------------------------------------------------------------------------------
 // Get a skin from a MDL7 file - more complex than all other subformats
 void MDLImporter::ParseSkinLump_3DGS_MDL7(
-    const unsigned char* szCurrent,
-    const unsigned char** szCurrentOut,
-    aiMaterial* pcMatOut,
-    unsigned int iType,
-    unsigned int iWidth,
-    unsigned int iHeight)
-{
+        const unsigned char *szCurrent,
+        const unsigned char **szCurrentOut,
+        aiMaterial *pcMatOut,
+        unsigned int iType,
+        unsigned int iWidth,
+        unsigned int iHeight) {
     std::unique_ptr<aiTexture> pcNew;
 
     // get the type of the skin
     unsigned int iMasked = (unsigned int)(iType & 0xF);
 
-    if (0x1 ==  iMasked)
-    {
+    if (0x1 == iMasked) {
         // ***** REFERENCE TO ANOTHER SKIN INDEX *****
         int referrer = (int)iWidth;
-        pcMatOut->AddProperty<int>(&referrer,1,AI_MDL7_REFERRER_MATERIAL);
-    }
-    else if (0x6 == iMasked)
-    {
+        pcMatOut->AddProperty<int>(&referrer, 1, AI_MDL7_REFERRER_MATERIAL);
+    } else if (0x6 == iMasked) {
         // ***** EMBEDDED DDS FILE *****
-        if (1 != iHeight)
-        {
+        if (1 != iHeight) {
             ASSIMP_LOG_WARN("Found a reference to an embedded DDS texture, "
-                "but texture height is not equal to 1, which is not supported by MED");
+                            "but texture height is not equal to 1, which is not supported by MED");
         }
-
-        pcNew.reset(new aiTexture());
+        if (iWidth == 0) {
+            ASSIMP_LOG_ERROR("Found a reference to an embedded DDS texture, but texture width is zero, aborting import.");
+            return;
+        }
+        
+        pcNew.reset(new aiTexture);
         pcNew->mHeight = 0;
         pcNew->mWidth = iWidth;
 
@@ -523,57 +478,47 @@ void MDLImporter::ParseSkinLump_3DGS_MDL7(
         pcNew->achFormatHint[2] = 's';
         pcNew->achFormatHint[3] = '\0';
 
-        pcNew->pcData = (aiTexel*) new unsigned char[pcNew->mWidth];
-        memcpy(pcNew->pcData,szCurrent,pcNew->mWidth);
+        pcNew->pcData = (aiTexel *)new unsigned char[pcNew->mWidth];
+        memcpy(pcNew->pcData, szCurrent, pcNew->mWidth);
         szCurrent += iWidth;
-    }
-    else if (0x7 == iMasked)
-    {
+    } else if (0x7 == iMasked) {
         // ***** REFERENCE TO EXTERNAL FILE *****
-        if (1 != iHeight)
-        {
+        if (1 != iHeight) {
             ASSIMP_LOG_WARN("Found a reference to an external texture, "
-                "but texture height is not equal to 1, which is not supported by MED");
+                            "but texture height is not equal to 1, which is not supported by MED");
         }
 
         aiString szFile;
-        const size_t iLen = strlen((const char*)szCurrent);
-        size_t iLen2 = iLen+1;
+        const size_t iLen = strlen((const char *)szCurrent);
+        size_t iLen2 = iLen + 1;
         iLen2 = iLen2 > MAXLEN ? MAXLEN : iLen2;
-        memcpy(szFile.data,(const char*)szCurrent,iLen2);
-        szFile.length = iLen;
+        memcpy(szFile.data, (const char *)szCurrent, iLen2);
+        szFile.length = static_cast<ai_uint32>(iLen2);
 
         szCurrent += iLen2;
 
         // place this as diffuse texture
-        pcMatOut->AddProperty(&szFile,AI_MATKEY_TEXTURE_DIFFUSE(0));
-    }
-    else if (iMasked || !iType || (iType && iWidth && iHeight))
-    {
+        pcMatOut->AddProperty(&szFile, AI_MATKEY_TEXTURE_DIFFUSE(0));
+    } else if (iMasked || !iType || (iType && iWidth && iHeight)) {
         pcNew.reset(new aiTexture());
-        if (!iHeight || !iWidth)
-        {
+        if (!iHeight || !iWidth) {
             ASSIMP_LOG_WARN("Found embedded texture, but its width "
-                "an height are both 0. Is this a joke?");
+                            "an height are both 0. Is this a joke?");
 
             // generate an empty chess pattern
             pcNew->mWidth = pcNew->mHeight = 8;
             pcNew->pcData = new aiTexel[64];
-            for (unsigned int x = 0; x < 8;++x)
-            {
-                for (unsigned int y = 0; y < 8;++y)
-                {
+            for (unsigned int x = 0; x < 8; ++x) {
+                for (unsigned int y = 0; y < 8; ++y) {
                     const bool bSet = ((0 == x % 2 && 0 != y % 2) ||
-                        (0 != x % 2 && 0 == y % 2));
+                                       (0 != x % 2 && 0 == y % 2));
 
-                    aiTexel* pc = &pcNew->pcData[y * 8 + x];
-                    pc->r = pc->b = pc->g = (bSet?0xFF:0);
+                    aiTexel *pc = &pcNew->pcData[y * 8 + x];
+                    pc->r = pc->b = pc->g = (bSet ? 0xFF : 0);
                     pc->a = 0xFF;
                 }
             }
-        }
-        else
-        {
+        } else {
             // it is a standard color texture. Fill in width and height
             // and call the same function we used for loading MDL5 files
 
@@ -581,7 +526,7 @@ void MDLImporter::ParseSkinLump_3DGS_MDL7(
             pcNew->mHeight = iHeight;
 
             unsigned int iSkip = 0;
-            ParseTextureColorData(szCurrent,iMasked,&iSkip,pcNew.get());
+            ParseTextureColorData(szCurrent, iMasked, &iSkip, pcNew.get());
 
             // skip length of texture data
             szCurrent += iSkip;
@@ -589,28 +534,28 @@ void MDLImporter::ParseSkinLump_3DGS_MDL7(
     }
 
     // sometimes there are MDL7 files which have a monochrome
-    // texture instead of material colors ... posssible they have
+    // texture instead of material colors ... possible they have
     // been converted to MDL7 from other formats, such as MDL5
     aiColor4D clrTexture;
-    if (pcNew)clrTexture = ReplaceTextureWithColor(pcNew.get());
-    else clrTexture.r = get_qnan();
+    if (pcNew)
+        clrTexture = ReplaceTextureWithColor(pcNew.get());
+    else
+        clrTexture.r = get_qnan();
 
     // check whether a material definition is contained in the skin
-    if (iType & AI_MDL7_SKINTYPE_MATERIAL)
-    {
-        BE_NCONST MDL::Material_MDL7* pcMatIn = (BE_NCONST MDL::Material_MDL7*)szCurrent;
-        szCurrent = (unsigned char*)(pcMatIn+1);
+    if (iType & AI_MDL7_SKINTYPE_MATERIAL) {
+        BE_NCONST MDL::Material_MDL7 *pcMatIn = (BE_NCONST MDL::Material_MDL7 *)szCurrent;
+        szCurrent = (unsigned char *)(pcMatIn + 1);
         VALIDATE_FILE_SIZE(szCurrent);
 
         aiColor3D clrTemp;
 
-#define COLOR_MULTIPLY_RGB() \
-    if (is_not_qnan(clrTexture.r)) \
-        { \
-        clrTemp.r *= clrTexture.r; \
-        clrTemp.g *= clrTexture.g; \
-        clrTemp.b *= clrTexture.b; \
-        }
+#define COLOR_MULTIPLY_RGB()         \
+    if (is_not_qnan(clrTexture.r)) { \
+        clrTemp.r *= clrTexture.r;   \
+        clrTemp.g *= clrTexture.g;   \
+        clrTemp.b *= clrTexture.b;   \
+    }
 
         // read diffuse color
         clrTemp.r = pcMatIn->Diffuse.r;
@@ -620,7 +565,7 @@ void MDLImporter::ParseSkinLump_3DGS_MDL7(
         clrTemp.b = pcMatIn->Diffuse.b;
         AI_SWAP4(clrTemp.b);
         COLOR_MULTIPLY_RGB();
-        pcMatOut->AddProperty<aiColor3D>(&clrTemp,1,AI_MATKEY_COLOR_DIFFUSE);
+        pcMatOut->AddProperty<aiColor3D>(&clrTemp, 1, AI_MATKEY_COLOR_DIFFUSE);
 
         // read specular color
         clrTemp.r = pcMatIn->Specular.r;
@@ -630,7 +575,7 @@ void MDLImporter::ParseSkinLump_3DGS_MDL7(
         clrTemp.b = pcMatIn->Specular.b;
         AI_SWAP4(clrTemp.b);
         COLOR_MULTIPLY_RGB();
-        pcMatOut->AddProperty<aiColor3D>(&clrTemp,1,AI_MATKEY_COLOR_SPECULAR);
+        pcMatOut->AddProperty<aiColor3D>(&clrTemp, 1, AI_MATKEY_COLOR_SPECULAR);
 
         // read ambient color
         clrTemp.r = pcMatIn->Ambient.r;
@@ -640,7 +585,7 @@ void MDLImporter::ParseSkinLump_3DGS_MDL7(
         clrTemp.b = pcMatIn->Ambient.b;
         AI_SWAP4(clrTemp.b);
         COLOR_MULTIPLY_RGB();
-        pcMatOut->AddProperty<aiColor3D>(&clrTemp,1,AI_MATKEY_COLOR_AMBIENT);
+        pcMatOut->AddProperty<aiColor3D>(&clrTemp, 1, AI_MATKEY_COLOR_AMBIENT);
 
         // read emissive color
         clrTemp.r = pcMatIn->Emissive.r;
@@ -649,7 +594,7 @@ void MDLImporter::ParseSkinLump_3DGS_MDL7(
         AI_SWAP4(clrTemp.g);
         clrTemp.b = pcMatIn->Emissive.b;
         AI_SWAP4(clrTemp.b);
-        pcMatOut->AddProperty<aiColor3D>(&clrTemp,1,AI_MATKEY_COLOR_EMISSIVE);
+        pcMatOut->AddProperty<aiColor3D>(&clrTemp, 1, AI_MATKEY_COLOR_EMISSIVE);
 
 #undef COLOR_MULITPLY_RGB
 
@@ -661,38 +606,33 @@ void MDLImporter::ParseSkinLump_3DGS_MDL7(
         if (is_not_qnan(clrTexture.r)) {
             clrTemp.r *= clrTexture.a;
         }
-        pcMatOut->AddProperty<ai_real>(&clrTemp.r,1,AI_MATKEY_OPACITY);
+        pcMatOut->AddProperty<ai_real>(&clrTemp.r, 1, AI_MATKEY_OPACITY);
 
         // read phong power
         int iShadingMode = (int)aiShadingMode_Gouraud;
         AI_SWAP4(pcMatIn->Power);
-        if (0.0f != pcMatIn->Power)
-        {
+        if (0.0f != pcMatIn->Power) {
             iShadingMode = (int)aiShadingMode_Phong;
             // pcMatIn is packed, we can't form pointers to its members
             float power = pcMatIn->Power;
-            pcMatOut->AddProperty<float>(&power,1,AI_MATKEY_SHININESS);
+            pcMatOut->AddProperty<float>(&power, 1, AI_MATKEY_SHININESS);
         }
-        pcMatOut->AddProperty<int>(&iShadingMode,1,AI_MATKEY_SHADING_MODEL);
-    }
-    else if (is_not_qnan(clrTexture.r))
-    {
-        pcMatOut->AddProperty<aiColor4D>(&clrTexture,1,AI_MATKEY_COLOR_DIFFUSE);
-        pcMatOut->AddProperty<aiColor4D>(&clrTexture,1,AI_MATKEY_COLOR_SPECULAR);
+        pcMatOut->AddProperty<int>(&iShadingMode, 1, AI_MATKEY_SHADING_MODEL);
+    } else if (is_not_qnan(clrTexture.r)) {
+        pcMatOut->AddProperty<aiColor4D>(&clrTexture, 1, AI_MATKEY_COLOR_DIFFUSE);
+        pcMatOut->AddProperty<aiColor4D>(&clrTexture, 1, AI_MATKEY_COLOR_SPECULAR);
     }
     // if the texture could be replaced by a single material color
     // we don't need the texture anymore
-    if (is_not_qnan(clrTexture.r))
-    {
+    if (is_not_qnan(clrTexture.r)) {
         pcNew.reset();
     }
 
     // If an ASCII effect description (HLSL?) is contained in the file,
     // we can simply ignore it ...
-    if (iType & AI_MDL7_SKINTYPE_MATERIAL_ASCDEF)
-    {
+    if (iType & AI_MDL7_SKINTYPE_MATERIAL_ASCDEF) {
         VALIDATE_FILE_SIZE(szCurrent);
-        int32_t iMe = *((int32_t*)szCurrent);
+        int32_t iMe = *((int32_t *)szCurrent);
         AI_SWAP4(iMe);
         szCurrent += sizeof(char) * iMe + sizeof(int32_t);
         VALIDATE_FILE_SIZE(szCurrent);
@@ -700,32 +640,27 @@ void MDLImporter::ParseSkinLump_3DGS_MDL7(
 
     // If an embedded texture has been loaded setup the corresponding
     // data structures in the aiScene instance
-    if (pcNew && pScene->mNumTextures <= 999)
-    {
-
+    if (pcNew && pScene->mNumTextures <= 999) {
         // place this as diffuse texture
-        char szCurrent[5];
-        ai_snprintf(szCurrent,5,"*%i",this->pScene->mNumTextures);
+        char current[5];
+        ai_snprintf(current, 5, "*%i", this->pScene->mNumTextures);
 
         aiString szFile;
-        const size_t iLen = strlen((const char*)szCurrent);
-        ::memcpy(szFile.data,(const char*)szCurrent,iLen+1);
-        szFile.length = iLen;
+        const size_t iLen = strlen((const char *)current);
+        ::memcpy(szFile.data, (const char *)current, iLen + 1);
+        szFile.length = (ai_uint32)iLen;
 
-        pcMatOut->AddProperty(&szFile,AI_MATKEY_TEXTURE_DIFFUSE(0));
+        pcMatOut->AddProperty(&szFile, AI_MATKEY_TEXTURE_DIFFUSE(0));
 
         // store the texture
-        if (!pScene->mNumTextures)
-        {
+        if (!pScene->mNumTextures) {
             pScene->mNumTextures = 1;
-            pScene->mTextures = new aiTexture*[1];
+            pScene->mTextures = new aiTexture *[1];
             pScene->mTextures[0] = pcNew.release();
-        }
-        else
-        {
-            aiTexture** pc = pScene->mTextures;
-            pScene->mTextures = new aiTexture*[pScene->mNumTextures+1];
-            for (unsigned int i = 0; i < pScene->mNumTextures;++i) {
+        } else {
+            aiTexture **pc = pScene->mTextures;
+            pScene->mTextures = new aiTexture *[pScene->mNumTextures + 1];
+            for (unsigned int i = 0; i < pScene->mNumTextures; ++i) {
                 pScene->mTextures[i] = pc[i];
             }
 
@@ -741,28 +676,22 @@ void MDLImporter::ParseSkinLump_3DGS_MDL7(
 // ------------------------------------------------------------------------------------------------
 // Skip a skin lump
 void MDLImporter::SkipSkinLump_3DGS_MDL7(
-    const unsigned char* szCurrent,
-    const unsigned char** szCurrentOut,
-    unsigned int iType,
-    unsigned int iWidth,
-    unsigned int iHeight)
-{
+        const unsigned char *szCurrent,
+        const unsigned char **szCurrentOut,
+        unsigned int iType,
+        unsigned int iWidth,
+        unsigned int iHeight) {
     // get the type of the skin
     const unsigned int iMasked = (unsigned int)(iType & 0xF);
 
-    if (0x6 == iMasked)
-    {
+    if (0x6 == iMasked) {
         szCurrent += iWidth;
     }
-    if (0x7 == iMasked)
-    {
-        const size_t iLen = ::strlen((const char*)szCurrent);
-        szCurrent += iLen+1;
-    }
-    else if (iMasked || !iType)
-    {
-        if (iMasked || !iType || (iType && iWidth && iHeight))
-        {
+    if (0x7 == iMasked) {
+        const size_t iLen = std::strlen((const char *)szCurrent);
+        szCurrent += iLen + 1;
+    } else if (iMasked || !iType) {
+        if (iMasked || !iType || (iType && iWidth && iHeight)) {
             // ParseTextureColorData(..., aiTexture::pcData == bad_texel) will simply
             // return the size of the color data in bytes in iSkip
             unsigned int iSkip = 0;
@@ -771,10 +700,10 @@ void MDLImporter::SkipSkinLump_3DGS_MDL7(
             tex.pcData = bad_texel;
             tex.mHeight = iHeight;
             tex.mWidth = iWidth;
-            ParseTextureColorData(szCurrent,iMasked,&iSkip,&tex);
+            ParseTextureColorData(szCurrent, iMasked, &iSkip, &tex);
 
             // FIX: Important, otherwise the destructor will crash
-            tex.pcData = NULL;
+            tex.pcData = nullptr;
 
             // skip length of texture data
             szCurrent += iSkip;
@@ -782,17 +711,15 @@ void MDLImporter::SkipSkinLump_3DGS_MDL7(
     }
 
     // check whether a material definition is contained in the skin
-    if (iType & AI_MDL7_SKINTYPE_MATERIAL)
-    {
-        BE_NCONST MDL::Material_MDL7* pcMatIn = (BE_NCONST MDL::Material_MDL7*)szCurrent;
-        szCurrent = (unsigned char*)(pcMatIn+1);
+    if (iType & AI_MDL7_SKINTYPE_MATERIAL) {
+        BE_NCONST MDL::Material_MDL7 *pcMatIn = (BE_NCONST MDL::Material_MDL7 *)szCurrent;
+        szCurrent = (unsigned char *)(pcMatIn + 1);
     }
 
     // if an ASCII effect description (HLSL?) is contained in the file,
     // we can simply ignore it ...
-    if (iType & AI_MDL7_SKINTYPE_MATERIAL_ASCDEF)
-    {
-        int32_t iMe = *((int32_t*)szCurrent);
+    if (iType & AI_MDL7_SKINTYPE_MATERIAL_ASCDEF) {
+        int32_t iMe = *((int32_t *)szCurrent);
         AI_SWAP4(iMe);
         szCurrent += sizeof(char) * iMe + sizeof(int32_t);
     }
@@ -801,39 +728,37 @@ void MDLImporter::SkipSkinLump_3DGS_MDL7(
 
 // ------------------------------------------------------------------------------------------------
 void MDLImporter::ParseSkinLump_3DGS_MDL7(
-    const unsigned char* szCurrent,
-    const unsigned char** szCurrentOut,
-    std::vector<aiMaterial*>& pcMats)
-{
-    ai_assert(NULL != szCurrent);
-    ai_assert(NULL != szCurrentOut);
+        const unsigned char *szCurrent,
+        const unsigned char **szCurrentOut,
+        std::vector<aiMaterial *> &pcMats) {
+    ai_assert(nullptr != szCurrent);
+    ai_assert(nullptr != szCurrentOut);
 
     *szCurrentOut = szCurrent;
-    BE_NCONST MDL::Skin_MDL7* pcSkin = (BE_NCONST MDL::Skin_MDL7*)szCurrent;
+    BE_NCONST MDL::Skin_MDL7 *pcSkin = (BE_NCONST MDL::Skin_MDL7 *)szCurrent;
     AI_SWAP4(pcSkin->width);
     AI_SWAP4(pcSkin->height);
     szCurrent += 12;
 
     // allocate an output material
-    aiMaterial* pcMatOut = new aiMaterial();
+    aiMaterial *pcMatOut = new aiMaterial();
     pcMats.push_back(pcMatOut);
 
     // skip length of file name
     szCurrent += AI_MDL7_MAX_TEXNAMESIZE;
 
-    ParseSkinLump_3DGS_MDL7(szCurrent,szCurrentOut,pcMatOut,
-        pcSkin->typ,pcSkin->width,pcSkin->height);
+    ParseSkinLump_3DGS_MDL7(szCurrent, szCurrentOut, pcMatOut,
+            pcSkin->typ, pcSkin->width, pcSkin->height);
 
     // place the name of the skin in the material
-    if (pcSkin->texture_name[0])
-    {
+    if (pcSkin->texture_name[0]) {
         // the 0 termination could be there or not - we can't know
         aiString szFile;
-        ::memcpy(szFile.data,pcSkin->texture_name,sizeof(pcSkin->texture_name));
+        ::memcpy(szFile.data, pcSkin->texture_name, sizeof(pcSkin->texture_name));
         szFile.data[sizeof(pcSkin->texture_name)] = '\0';
-        szFile.length = ::strlen(szFile.data);
+        szFile.length = (ai_uint32)::strlen(szFile.data);
 
-        pcMatOut->AddProperty(&szFile,AI_MATKEY_NAME);
+        pcMatOut->AddProperty(&szFile, AI_MATKEY_NAME);
     }
 }
 
diff --git a/Engine/lib/assimp/code/MMD/MMDCpp14.h b/Engine/lib/assimp/code/AssetLib/MMD/MMDCpp14.h
similarity index 98%
rename from Engine/lib/assimp/code/MMD/MMDCpp14.h
rename to Engine/lib/assimp/code/AssetLib/MMD/MMDCpp14.h
index 638b0bfd2..10d376829 100644
--- a/Engine/lib/assimp/code/MMD/MMDCpp14.h
+++ b/Engine/lib/assimp/code/AssetLib/MMD/MMDCpp14.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/AssetLib/MMD/MMDImporter.cpp b/Engine/lib/assimp/code/AssetLib/MMD/MMDImporter.cpp
new file mode 100644
index 000000000..e0e68f7c5
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/MMD/MMDImporter.cpp
@@ -0,0 +1,368 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+#ifndef ASSIMP_BUILD_NO_MMD_IMPORTER
+
+#include "AssetLib/MMD/MMDImporter.h"
+#include "AssetLib/MMD/MMDPmdParser.h"
+#include "AssetLib/MMD/MMDPmxParser.h"
+#include "AssetLib/MMD/MMDVmdParser.h"
+#include "PostProcessing/ConvertToLHProcess.h"
+
+#include <assimp/DefaultIOSystem.h>
+#include <assimp/ai_assert.h>
+#include <assimp/scene.h>
+#include <assimp/Importer.hpp>
+
+#include <fstream>
+#include <iomanip>
+#include <memory>
+
+static const aiImporterDesc desc = { "MMD Importer",
+    "",
+    "",
+    "surfaces supported?",
+    aiImporterFlags_SupportTextFlavour,
+    0,
+    0,
+    0,
+    0,
+    "pmx" };
+
+namespace Assimp {
+
+using namespace std;
+
+// ------------------------------------------------------------------------------------------------
+//  Default constructor
+MMDImporter::MMDImporter() :
+        m_Buffer(),
+        m_strAbsPath() {
+    DefaultIOSystem io;
+    m_strAbsPath = io.getOsSeparator();
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Destructor.
+MMDImporter::~MMDImporter() {
+    // empty
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Returns true, if file is an pmx file.
+bool MMDImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler,
+        bool /*checkSig*/) const {
+    static const char *tokens[] = { "PMX " };
+    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
+}
+
+// ------------------------------------------------------------------------------------------------
+const aiImporterDesc *MMDImporter::GetInfo() const {
+    return &desc;
+}
+
+// ------------------------------------------------------------------------------------------------
+//  MMD import implementation
+void MMDImporter::InternReadFile(const std::string &file, aiScene *pScene,
+        IOSystem * /*pIOHandler*/) {
+    // Read file by istream
+    std::filebuf fb;
+    if (!fb.open(file, std::ios::in | std::ios::binary)) {
+        throw DeadlyImportError("Failed to open file ", file, ".");
+    }
+
+    std::istream fileStream(&fb);
+
+    // Get the file-size and validate it, throwing an exception when fails
+    fileStream.seekg(0, fileStream.end);
+    size_t fileSize = static_cast<size_t>(fileStream.tellg());
+    fileStream.seekg(0, fileStream.beg);
+
+    if (fileSize < sizeof(pmx::PmxModel)) {
+        throw DeadlyImportError(file, " is too small.");
+    }
+
+    pmx::PmxModel model;
+    model.Read(&fileStream);
+
+    CreateDataFromImport(&model, pScene);
+}
+
+// ------------------------------------------------------------------------------------------------
+void MMDImporter::CreateDataFromImport(const pmx::PmxModel *pModel,
+        aiScene *pScene) {
+    if (pModel == nullptr) {
+        return;
+    }
+
+    aiNode *pNode = new aiNode;
+    if (!pModel->model_name.empty()) {
+        pNode->mName.Set(pModel->model_name);
+    }
+
+    pScene->mRootNode = pNode;
+
+    pNode = new aiNode;
+    pScene->mRootNode->addChildren(1, &pNode);
+    pNode->mName.Set(string(pModel->model_name) + string("_mesh"));
+
+    // split mesh by materials
+    pNode->mNumMeshes = pModel->material_count;
+    pNode->mMeshes = new unsigned int[pNode->mNumMeshes];
+    for (unsigned int index = 0; index < pNode->mNumMeshes; index++) {
+        pNode->mMeshes[index] = index;
+    }
+
+    pScene->mNumMeshes = pModel->material_count;
+    pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
+    for (unsigned int i = 0, indexStart = 0; i < pScene->mNumMeshes; i++) {
+        const int indexCount = pModel->materials[i].index_count;
+
+        pScene->mMeshes[i] = CreateMesh(pModel, indexStart, indexCount);
+        pScene->mMeshes[i]->mName = pModel->materials[i].material_name;
+        pScene->mMeshes[i]->mMaterialIndex = i;
+        indexStart += indexCount;
+    }
+
+    // create node hierarchy for bone position
+    std::unique_ptr<aiNode *[]> ppNode(new aiNode *[pModel->bone_count]);
+    for (auto i = 0; i < pModel->bone_count; i++) {
+        ppNode[i] = new aiNode(pModel->bones[i].bone_name);
+    }
+
+    for (auto i = 0; i < pModel->bone_count; i++) {
+        const pmx::PmxBone &bone = pModel->bones[i];
+
+        if (bone.parent_index < 0) {
+            pScene->mRootNode->addChildren(1, ppNode.get() + i);
+        } else {
+            ppNode[bone.parent_index]->addChildren(1, ppNode.get() + i);
+
+            aiVector3D v3 = aiVector3D(
+                    bone.position[0] - pModel->bones[bone.parent_index].position[0],
+                    bone.position[1] - pModel->bones[bone.parent_index].position[1],
+                    bone.position[2] - pModel->bones[bone.parent_index].position[2]);
+            aiMatrix4x4::Translation(v3, ppNode[i]->mTransformation);
+        }
+    }
+
+    // create materials
+    pScene->mNumMaterials = pModel->material_count;
+    pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials];
+    for (unsigned int i = 0; i < pScene->mNumMaterials; i++) {
+        pScene->mMaterials[i] = CreateMaterial(&pModel->materials[i], pModel);
+    }
+
+    // Convert everything to OpenGL space
+    MakeLeftHandedProcess convertProcess;
+    convertProcess.Execute(pScene);
+
+    FlipUVsProcess uvFlipper;
+    uvFlipper.Execute(pScene);
+
+    FlipWindingOrderProcess windingFlipper;
+    windingFlipper.Execute(pScene);
+}
+
+// ------------------------------------------------------------------------------------------------
+aiMesh *MMDImporter::CreateMesh(const pmx::PmxModel *pModel,
+        const int indexStart, const int indexCount) {
+    aiMesh *pMesh = new aiMesh;
+
+    pMesh->mNumVertices = indexCount;
+
+    pMesh->mNumFaces = indexCount / 3;
+    pMesh->mFaces = new aiFace[pMesh->mNumFaces];
+
+    const int numIndices = 3; // triangular face
+    for (unsigned int index = 0; index < pMesh->mNumFaces; index++) {
+        pMesh->mFaces[index].mNumIndices = numIndices;
+        unsigned int *indices = new unsigned int[numIndices];
+        indices[0] = numIndices * index;
+        indices[1] = numIndices * index + 1;
+        indices[2] = numIndices * index + 2;
+        pMesh->mFaces[index].mIndices = indices;
+    }
+
+    pMesh->mVertices = new aiVector3D[pMesh->mNumVertices];
+    pMesh->mNormals = new aiVector3D[pMesh->mNumVertices];
+    pMesh->mTextureCoords[0] = new aiVector3D[pMesh->mNumVertices];
+    pMesh->mNumUVComponents[0] = 2;
+
+    // additional UVs
+    for (int i = 1; i <= pModel->setting.uv; i++) {
+        pMesh->mTextureCoords[i] = new aiVector3D[pMesh->mNumVertices];
+        pMesh->mNumUVComponents[i] = 4;
+    }
+
+    map<int, vector<aiVertexWeight>> bone_vertex_map;
+
+    // fill in contents and create bones
+    for (int index = 0; index < indexCount; index++) {
+        const pmx::PmxVertex *v =
+                &pModel->vertices[pModel->indices[indexStart + index]];
+        const float *position = v->position;
+        pMesh->mVertices[index].Set(position[0], position[1], position[2]);
+        const float *normal = v->normal;
+
+        pMesh->mNormals[index].Set(normal[0], normal[1], normal[2]);
+        pMesh->mTextureCoords[0][index].x = v->uv[0];
+        pMesh->mTextureCoords[0][index].y = v->uv[1];
+
+        for (int i = 1; i <= pModel->setting.uv; i++) {
+            // TODO: wrong here? use quaternion transform?
+            pMesh->mTextureCoords[i][index].x = v->uva[i][0];
+            pMesh->mTextureCoords[i][index].y = v->uva[i][1];
+        }
+
+        // handle bone map
+        const auto vsBDEF1_ptr =
+                dynamic_cast<pmx::PmxVertexSkinningBDEF1 *>(v->skinning.get());
+        const auto vsBDEF2_ptr =
+                dynamic_cast<pmx::PmxVertexSkinningBDEF2 *>(v->skinning.get());
+        const auto vsBDEF4_ptr =
+                dynamic_cast<pmx::PmxVertexSkinningBDEF4 *>(v->skinning.get());
+        const auto vsSDEF_ptr =
+                dynamic_cast<pmx::PmxVertexSkinningSDEF *>(v->skinning.get());
+        switch (v->skinning_type) {
+        case pmx::PmxVertexSkinningType::BDEF1:
+            bone_vertex_map[vsBDEF1_ptr->bone_index].push_back(
+                    aiVertexWeight(index, 1.0));
+            break;
+        case pmx::PmxVertexSkinningType::BDEF2:
+            bone_vertex_map[vsBDEF2_ptr->bone_index1].push_back(
+                    aiVertexWeight(index, vsBDEF2_ptr->bone_weight));
+            bone_vertex_map[vsBDEF2_ptr->bone_index2].push_back(
+                    aiVertexWeight(index, 1.0f - vsBDEF2_ptr->bone_weight));
+            break;
+        case pmx::PmxVertexSkinningType::BDEF4:
+            bone_vertex_map[vsBDEF4_ptr->bone_index1].push_back(
+                    aiVertexWeight(index, vsBDEF4_ptr->bone_weight1));
+            bone_vertex_map[vsBDEF4_ptr->bone_index2].push_back(
+                    aiVertexWeight(index, vsBDEF4_ptr->bone_weight2));
+            bone_vertex_map[vsBDEF4_ptr->bone_index3].push_back(
+                    aiVertexWeight(index, vsBDEF4_ptr->bone_weight3));
+            bone_vertex_map[vsBDEF4_ptr->bone_index4].push_back(
+                    aiVertexWeight(index, vsBDEF4_ptr->bone_weight4));
+            break;
+        case pmx::PmxVertexSkinningType::SDEF: // TODO: how to use sdef_c, sdef_r0,
+                // sdef_r1?
+            bone_vertex_map[vsSDEF_ptr->bone_index1].push_back(
+                    aiVertexWeight(index, vsSDEF_ptr->bone_weight));
+            bone_vertex_map[vsSDEF_ptr->bone_index2].push_back(
+                    aiVertexWeight(index, 1.0f - vsSDEF_ptr->bone_weight));
+            break;
+        case pmx::PmxVertexSkinningType::QDEF:
+            const auto vsQDEF_ptr =
+                    dynamic_cast<pmx::PmxVertexSkinningQDEF *>(v->skinning.get());
+            bone_vertex_map[vsQDEF_ptr->bone_index1].push_back(
+                    aiVertexWeight(index, vsQDEF_ptr->bone_weight1));
+            bone_vertex_map[vsQDEF_ptr->bone_index2].push_back(
+                    aiVertexWeight(index, vsQDEF_ptr->bone_weight2));
+            bone_vertex_map[vsQDEF_ptr->bone_index3].push_back(
+                    aiVertexWeight(index, vsQDEF_ptr->bone_weight3));
+            bone_vertex_map[vsQDEF_ptr->bone_index4].push_back(
+                    aiVertexWeight(index, vsQDEF_ptr->bone_weight4));
+            break;
+        }
+    }
+
+    // make all bones for each mesh
+    // assign bone weights to skinned bones (otherwise just initialize)
+    auto bone_ptr_ptr = new aiBone *[pModel->bone_count];
+    pMesh->mNumBones = pModel->bone_count;
+    pMesh->mBones = bone_ptr_ptr;
+    for (auto ii = 0; ii < pModel->bone_count; ++ii) {
+        auto pBone = new aiBone;
+        const auto &pmxBone = pModel->bones[ii];
+        pBone->mName = pmxBone.bone_name;
+        aiVector3D pos(pmxBone.position[0], pmxBone.position[1], pmxBone.position[2]);
+        aiMatrix4x4::Translation(-pos, pBone->mOffsetMatrix);
+        auto it = bone_vertex_map.find(ii);
+        if (it != bone_vertex_map.end()) {
+            pBone->mNumWeights = static_cast<unsigned int>(it->second.size());
+            pBone->mWeights = new aiVertexWeight[pBone->mNumWeights];
+            for (unsigned int j = 0; j < pBone->mNumWeights; j++) {
+                pBone->mWeights[j] = it->second[j];
+            }
+        }
+        bone_ptr_ptr[ii] = pBone;
+    }
+
+    return pMesh;
+}
+
+// ------------------------------------------------------------------------------------------------
+aiMaterial *MMDImporter::CreateMaterial(const pmx::PmxMaterial *pMat,
+        const pmx::PmxModel *pModel) {
+    aiMaterial *mat = new aiMaterial();
+    aiString name(pMat->material_english_name);
+    mat->AddProperty(&name, AI_MATKEY_NAME);
+
+    aiColor3D diffuse(pMat->diffuse[0], pMat->diffuse[1], pMat->diffuse[2]);
+    mat->AddProperty(&diffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
+    aiColor3D specular(pMat->specular[0], pMat->specular[1], pMat->specular[2]);
+    mat->AddProperty(&specular, 1, AI_MATKEY_COLOR_SPECULAR);
+    aiColor3D ambient(pMat->ambient[0], pMat->ambient[1], pMat->ambient[2]);
+    mat->AddProperty(&ambient, 1, AI_MATKEY_COLOR_AMBIENT);
+
+    float opacity = pMat->diffuse[3];
+    mat->AddProperty(&opacity, 1, AI_MATKEY_OPACITY);
+    float shininess = pMat->specularlity;
+    mat->AddProperty(&shininess, 1, AI_MATKEY_SHININESS_STRENGTH);
+
+    if (pMat->diffuse_texture_index >= 0) {
+        aiString texture_path(pModel->textures[pMat->diffuse_texture_index]);
+        mat->AddProperty(&texture_path, AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE, 0));
+    }
+
+    int mapping_uvwsrc = 0;
+    mat->AddProperty(&mapping_uvwsrc, 1,
+            AI_MATKEY_UVWSRC(aiTextureType_DIFFUSE, 0));
+
+    return mat;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+} // Namespace Assimp
+
+#endif // !! ASSIMP_BUILD_NO_MMD_IMPORTER
diff --git a/Engine/lib/assimp/code/MMD/MMDImporter.h b/Engine/lib/assimp/code/AssetLib/MMD/MMDImporter.h
similarity index 94%
rename from Engine/lib/assimp/code/MMD/MMDImporter.h
rename to Engine/lib/assimp/code/AssetLib/MMD/MMDImporter.h
index 4ee94eeb0..36f384829 100644
--- a/Engine/lib/assimp/code/MMD/MMDImporter.h
+++ b/Engine/lib/assimp/code/AssetLib/MMD/MMDImporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2016, assimp team
+Copyright (c) 2006-2022, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -59,19 +59,19 @@ public:
     MMDImporter();
 
     /// \brief  Destructor
-    ~MMDImporter();
+    ~MMDImporter() override;
 
 public:
     /// \brief  Returns whether the class can handle the format of the given file.
     /// \remark See BaseImporter::CanRead() for details.
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const;
+    bool CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const override;
 
 private:
     //! \brief  Appends the supported extension.
-    const aiImporterDesc* GetInfo () const;
+    const aiImporterDesc* GetInfo() const override;
 
     //! \brief  File import implementation.
-    void InternReadFile(const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler);
+    void InternReadFile(const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) override;
 
     //! \brief  Create the data from imported content.
     void CreateDataFromImport(const pmx::PmxModel* pModel, aiScene* pScene);
@@ -93,4 +93,4 @@ private:
 
 } // Namespace Assimp
 
-#endif
\ No newline at end of file
+#endif
diff --git a/Engine/lib/assimp/code/MMD/MMDPmdParser.h b/Engine/lib/assimp/code/AssetLib/MMD/MMDPmdParser.h
similarity index 98%
rename from Engine/lib/assimp/code/MMD/MMDPmdParser.h
rename to Engine/lib/assimp/code/AssetLib/MMD/MMDPmdParser.h
index d2f2224aa..35e4f09d1 100644
--- a/Engine/lib/assimp/code/MMD/MMDPmdParser.h
+++ b/Engine/lib/assimp/code/AssetLib/MMD/MMDPmdParser.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -131,7 +131,7 @@ namespace pmd
 			stream->read((char*) &index_count, sizeof(uint32_t));
 			stream->read((char*) &buffer, sizeof(char) * 20);
 			char* pstar = strchr(buffer, '*');
-			if (NULL == pstar)
+            if (nullptr == pstar)
 			{
 				texture_filename = std::string(buffer);
 				sphere_filename.clear();
@@ -195,7 +195,7 @@ namespace pmd
 	public:
 		uint16_t ik_bone_index;
 		uint16_t target_bone_index;
-		uint16_t interations;
+		uint16_t iterations;
 		float angle_limit;
 		std::vector<uint16_t> ik_child_bone_index;
 
@@ -205,7 +205,7 @@ namespace pmd
 			stream->read((char *) &target_bone_index, sizeof(uint16_t));
 			uint8_t ik_chain_length;
 			stream->read((char*) &ik_chain_length, sizeof(uint8_t));
-			stream->read((char *) &interations, sizeof(uint16_t));
+			stream->read((char *) &iterations, sizeof(uint16_t));
 			stream->read((char *) &angle_limit, sizeof(float));
 			ik_child_bone_index.resize(ik_chain_length);
 			for (int i = 0; i < ik_chain_length; i++)
diff --git a/Engine/lib/assimp/code/MMD/MMDPmxParser.cpp b/Engine/lib/assimp/code/AssetLib/MMD/MMDPmxParser.cpp
similarity index 97%
rename from Engine/lib/assimp/code/MMD/MMDPmxParser.cpp
rename to Engine/lib/assimp/code/AssetLib/MMD/MMDPmxParser.cpp
index 80f0986dd..ca37ba199 100644
--- a/Engine/lib/assimp/code/MMD/MMDPmxParser.cpp
+++ b/Engine/lib/assimp/code/AssetLib/MMD/MMDPmxParser.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -43,7 +43,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "MMDPmxParser.h"
 #include <assimp/StringUtils.h>
 #ifdef ASSIMP_USE_HUNTER
-#  include <utf8/utf8.h>
+#  include <utf8.h>
 #else
 #  include "../contrib/utf8cpp/source/utf8.h"
 #endif
@@ -91,7 +91,7 @@ namespace pmx
 		std::vector<char> buffer;
 		if (size == 0)
 		{
-			return std::string("");
+			return std::string();
 		}
 		buffer.reserve(size);
 		stream->read((char*) buffer.data(), size);
@@ -102,7 +102,7 @@ namespace pmx
 			const unsigned int targetSize = size * 3; // enough to encode
 			char *targetStart = new char[targetSize];
             std::memset(targetStart, 0, targetSize * sizeof(char));
-            
+
             utf8::utf16to8( sourceStart, sourceStart + size/2, targetStart );
 
 			std::string result(targetStart);
@@ -478,8 +478,7 @@ namespace pmx
 
     void PmxSoftBody::Read(std::istream * /*stream*/, PmxSetting * /*setting*/)
 	{
-		std::cerr << "Not Implemented Exception" << std::endl;
-        throw DeadlyImportError("MMD: Not Implemented Exception");
+        throw DeadlyImportError("MMD: Soft Body support is not implemented.");
     }
 
 	void PmxModel::Init()
@@ -516,16 +515,14 @@ namespace pmx
 		char magic[4];
 		stream->read((char*) magic, sizeof(char) * 4);
 		if (magic[0] != 0x50 || magic[1] != 0x4d || magic[2] != 0x58 || magic[3] != 0x20)
-		{
-			std::cerr << "invalid magic number." << std::endl;
-      throw DeadlyImportError("MMD: invalid magic number.");
-    }
+        {
+            throw DeadlyImportError("MMD: Invalid magic number.");
+        }
 		stream->read((char*) &version, sizeof(float));
 		if (version != 2.0f && version != 2.1f)
 		{
-			std::cerr << "this is not ver2.0 or ver2.1 but " << version << "." << std::endl;
-            throw DeadlyImportError("MMD: this is not ver2.0 or ver2.1 but " + to_string(version));
-    }
+            throw DeadlyImportError("MMD: Unsupported version (must be 2.0 or 2.1): ", ai_to_string(version));
+        }
 		this->setting.Read(stream);
 
 		this->model_name = ReadString(stream, setting.encoding);
diff --git a/Engine/lib/assimp/code/MMD/MMDPmxParser.h b/Engine/lib/assimp/code/AssetLib/MMD/MMDPmxParser.h
similarity index 99%
rename from Engine/lib/assimp/code/MMD/MMDPmxParser.h
rename to Engine/lib/assimp/code/AssetLib/MMD/MMDPmxParser.h
index cf523a129..08f57f6f0 100644
--- a/Engine/lib/assimp/code/MMD/MMDPmxParser.h
+++ b/Engine/lib/assimp/code/AssetLib/MMD/MMDPmxParser.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/MMD/MMDVmdParser.h b/Engine/lib/assimp/code/AssetLib/MMD/MMDVmdParser.h
similarity index 97%
rename from Engine/lib/assimp/code/MMD/MMDVmdParser.h
rename to Engine/lib/assimp/code/AssetLib/MMD/MMDVmdParser.h
index 947c3a242..d5c7dedff 100644
--- a/Engine/lib/assimp/code/MMD/MMDVmdParser.h
+++ b/Engine/lib/assimp/code/AssetLib/MMD/MMDVmdParser.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -199,9 +199,9 @@ namespace vmd
 			stream->write((char*)&ik_count, sizeof(int));
 			for (int i = 0; i < ik_count; i++)
 			{
-				const VmdIkEnable& ik_enable = this->ik_enable.at(i);
-				stream->write(ik_enable.ik_name.c_str(), 20);
-				stream->write((char*)&ik_enable.enable, sizeof(uint8_t));
+				const VmdIkEnable& ik_enable_ref = this->ik_enable.at(i);
+                stream->write(ik_enable_ref.ik_name.c_str(), 20);
+                stream->write((char *)&ik_enable_ref.enable, sizeof(uint8_t));
 			}
 		}
 	};
@@ -358,7 +358,7 @@ namespace vmd
 				light_frames[i].Write(stream);
 			}
 
-			// self shadow datas
+			// self shadow data
 			const int self_shadow_num = 0;
 			stream->write(reinterpret_cast<const char*>(&self_shadow_num), sizeof(int));
 
diff --git a/Engine/lib/assimp/code/MS3D/MS3DLoader.cpp b/Engine/lib/assimp/code/AssetLib/MS3D/MS3DLoader.cpp
similarity index 90%
rename from Engine/lib/assimp/code/MS3D/MS3DLoader.cpp
rename to Engine/lib/assimp/code/AssetLib/MS3D/MS3DLoader.cpp
index c0d0eddbe..fc2ed042b 100644
--- a/Engine/lib/assimp/code/MS3D/MS3DLoader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/MS3D/MS3DLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -88,26 +88,12 @@ MS3DImporter::MS3DImporter()
 // Destructor, private as well
 MS3DImporter::~MS3DImporter()
 {}
-
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool MS3DImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
+bool MS3DImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/) const
 {
-    // first call - simple extension check
-    const std::string extension = GetExtension(pFile);
-    if (extension == "ms3d") {
-        return true;
-    }
-
-    // second call - check for magic identifiers
-    else if (!extension.length() || checkSig)   {
-        if (!pIOHandler) {
-            return true;
-        }
-        const char* tokens[] = {"MS3D000000"};
-        return SearchFileHeaderForToken(pIOHandler,pFile,tokens,1);
-    }
-    return false;
+    static const char* tokens[] = { "MS3D000000" };
+    return SearchFileHeaderForToken(pIOHandler,pFile,tokens,AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -215,7 +201,12 @@ void MS3DImporter :: CollectChildJoints(const std::vector<TempJoint>& joints, ai
 void MS3DImporter::InternReadFile( const std::string& pFile,
     aiScene* pScene, IOSystem* pIOHandler)
 {
-    StreamReaderLE stream(pIOHandler->Open(pFile,"rb"));
+
+    auto file = pIOHandler->Open(pFile, "rb");
+    if (!file)
+        throw DeadlyImportError("MS3D: Could not open ", pFile);
+
+    StreamReaderLE stream(file);
 
     // CanRead() should have done this already
     char head[10];
@@ -229,7 +220,7 @@ void MS3DImporter::InternReadFile( const std::string& pFile,
     stream.CopyAndAdvance(head,10);
     stream >> version;
     if (strncmp(head,"MS3D000000",10)) {
-        throw DeadlyImportError("Not a MS3D file, magic string MS3D000000 not found: "+pFile);
+        throw DeadlyImportError("Not a MS3D file, magic string MS3D000000 not found: ", pFile);
     }
 
     if (version != 4) {
@@ -261,19 +252,19 @@ void MS3DImporter::InternReadFile( const std::string& pFile,
         TempTriangle& t = triangles[i];
 
         stream.IncPtr(2);
-        for (unsigned int i = 0; i < 3; ++i) {
-            t.indices[i] = stream.GetI2();
+        for (unsigned int j = 0; j < 3; ++j) {
+            t.indices[j] = stream.GetI2();
         }
 
-        for (unsigned int i = 0; i < 3; ++i) {
-            ReadVector(stream,t.normals[i]);
+        for (unsigned int j = 0; j < 3; ++j) {
+            ReadVector(stream,t.normals[j]);
         }
 
-        for (unsigned int i = 0; i < 3; ++i) {
-            stream >> (float&)(t.uv[i].x); // see note in ReadColor()
+        for (unsigned int j = 0; j < 3; ++j) {
+            stream >> (float&)(t.uv[j].x); // see note in ReadColor()
         }
-        for (unsigned int i = 0; i < 3; ++i) {
-            stream >> (float&)(t.uv[i].y);
+        for (unsigned int j = 0; j < 3; ++j) {
+            stream >> (float&)(t.uv[j].y);
         }
 
         t.sg    = stream.GetI1();
@@ -296,8 +287,8 @@ void MS3DImporter::InternReadFile( const std::string& pFile,
         stream >> num;
 
         t.triangles.resize(num);
-        for (unsigned int i = 0; i < num; ++i) {
-            t.triangles[i] = stream.GetI2();
+        for (unsigned int j = 0; j < num; ++j) {
+            t.triangles[j] = stream.GetI2();
         }
         t.mat = stream.GetI1();
         if (t.mat == UINT_MAX) {
@@ -309,8 +300,8 @@ void MS3DImporter::InternReadFile( const std::string& pFile,
     stream >> mat;
 
     std::vector<TempMaterial> materials(mat);
-    for (unsigned int i = 0;i < mat; ++i) {
-        TempMaterial& t = materials[i];
+    for (unsigned int j = 0;j < mat; ++j) {
+        TempMaterial& t = materials[j];
 
         stream.CopyAndAdvance(t.name,32);
         t.name[32] = '\0';
@@ -338,8 +329,8 @@ void MS3DImporter::InternReadFile( const std::string& pFile,
     stream >> joint;
 
     std::vector<TempJoint> joints(joint);
-    for(unsigned int i = 0; i < joint; ++i) {
-        TempJoint& j = joints[i];
+    for(unsigned int ii = 0; ii < joint; ++ii) {
+        TempJoint& j = joints[ii];
 
         stream.IncPtr(1);
         stream.CopyAndAdvance(j.name,32);
@@ -382,7 +373,7 @@ void MS3DImporter::InternReadFile( const std::string& pFile,
                 }
 
                 const std::string& s = std::string(reinterpret_cast<char*>(stream.GetPtr()),len);
-                ASSIMP_LOG_DEBUG_F("MS3D: Model comment: ", s);
+                ASSIMP_LOG_DEBUG("MS3D: Model comment: ", s);
             }
 
             if(stream.GetRemainingSize() > 4 && inrange((stream >> subversion,subversion),1u,3u)) {
@@ -494,21 +485,21 @@ void MS3DImporter::InternReadFile( const std::string& pFile,
         typedef std::map<unsigned int,unsigned int> BoneSet;
         BoneSet mybones;
 
-        for (unsigned int i = 0,n = 0; i < m->mNumFaces; ++i) {
-            aiFace& f = m->mFaces[i];
-            if (g.triangles[i]>triangles.size()) {
+        for (unsigned int j = 0,n = 0; j < m->mNumFaces; ++j) {
+            aiFace& f = m->mFaces[j];
+            if (g.triangles[j]>triangles.size()) {
                 throw DeadlyImportError("MS3D: Encountered invalid triangle index, file is malformed");
             }
 
-            TempTriangle& t = triangles[g.triangles[i]];
+            TempTriangle& t = triangles[g.triangles[j]];
             f.mIndices = new unsigned int[f.mNumIndices=3];
 
-            for (unsigned int i = 0; i < 3; ++i,++n) {
-                if (t.indices[i]>vertices.size()) {
+            for (unsigned int k = 0; k < 3; ++k,++n) {
+                if (t.indices[k]>vertices.size()) {
                     throw DeadlyImportError("MS3D: Encountered invalid vertex index, file is malformed");
                 }
 
-                const TempVertex& v = vertices[t.indices[i]];
+                const TempVertex& v = vertices[t.indices[k]];
                 for(unsigned int a = 0; a < 4; ++a) {
                     if (v.bone_id[a] != UINT_MAX) {
                         if (v.bone_id[a] >= joints.size()) {
@@ -524,9 +515,9 @@ void MS3DImporter::InternReadFile( const std::string& pFile,
                 // collect vertex components
                 m->mVertices[n] = v.pos;
 
-                m->mNormals[n] = t.normals[i];
-                m->mTextureCoords[0][n] = aiVector3D(t.uv[i].x,1.f-t.uv[i].y,0.0);
-                f.mIndices[i] = n;
+                m->mNormals[n] = t.normals[k];
+                m->mTextureCoords[0][n] = aiVector3D(t.uv[k].x,1.f-t.uv[k].y,0.0);
+                f.mIndices[k] = n;
             }
         }
 
@@ -545,11 +536,11 @@ void MS3DImporter::InternReadFile( const std::string& pFile,
             }
 
             // .. and collect bone weights
-            for (unsigned int i = 0,n = 0; i < m->mNumFaces; ++i) {
-                TempTriangle& t = triangles[g.triangles[i]];
+            for (unsigned int j = 0,n = 0; j < m->mNumFaces; ++j) {
+                TempTriangle& t = triangles[g.triangles[j]];
 
-                for (unsigned int i = 0; i < 3; ++i,++n) {
-                    const TempVertex& v = vertices[t.indices[i]];
+                for (unsigned int k = 0; k < 3; ++k,++n) {
+                    const TempVertex& v = vertices[t.indices[k]];
                     for(unsigned int a = 0; a < 4; ++a) {
                         const unsigned int bone = v.bone_id[a];
                         if(bone==UINT_MAX){
@@ -657,7 +648,7 @@ void MS3DImporter::InternReadFile( const std::string& pFile,
         }
         // fixup to pass the validation if not a single animation channel is non-trivial
         if (!anim->mNumChannels) {
-            anim->mChannels = NULL;
+            anim->mChannels = nullptr;
         }
     }
 }
diff --git a/Engine/lib/assimp/code/MS3D/MS3DLoader.h b/Engine/lib/assimp/code/AssetLib/MS3D/MS3DLoader.h
similarity index 78%
rename from Engine/lib/assimp/code/MS3D/MS3DLoader.h
rename to Engine/lib/assimp/code/AssetLib/MS3D/MS3DLoader.h
index 3e39dc79f..4bd417566 100644
--- a/Engine/lib/assimp/code/MS3D/MS3DLoader.h
+++ b/Engine/lib/assimp/code/AssetLib/MS3D/MS3DLoader.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,6 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file  MS3DLoader.h
  *  @brief Declaration of the MS3D importer class.
  */
+#pragma once
 #ifndef AI_MS3DLOADER_H_INCLUDED
 #define AI_MS3DLOADER_H_INCLUDED
 
@@ -50,65 +50,53 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/StreamReader.h>
 struct aiNode;
 
-namespace Assimp    {
+namespace Assimp {
 
 // ----------------------------------------------------------------------------------------------
 /** Milkshape 3D importer implementation */
 // ----------------------------------------------------------------------------------------------
-class MS3DImporter
-    : public BaseImporter
-{
-
+class MS3DImporter : public BaseImporter {
 public:
-
     MS3DImporter();
-    ~MS3DImporter();
-
-public:
+    ~MS3DImporter() override;
 
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
     * See BaseImporter::CanRead() for details.  */
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
+            bool checkSig) const override;
 
 protected:
-
     // -------------------------------------------------------------------
     /** Return importer meta information.
      * See #BaseImporter::GetInfo for the details */
-    const aiImporterDesc* GetInfo () const;
-
+    const aiImporterDesc *GetInfo() const override;
 
     // -------------------------------------------------------------------
     /** Imports the given file into the given scene structure.
     * See BaseImporter::InternReadFile() for details */
-    void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
-
+    void InternReadFile(const std::string &pFile, aiScene *pScene,
+            IOSystem *pIOHandler) override;
 
 private:
-
     struct TempJoint;
-    void CollectChildJoints(const std::vector<TempJoint>& joints, std::vector<bool>& hadit, aiNode* nd,const aiMatrix4x4& absTrafo);
-    void CollectChildJoints(const std::vector<TempJoint>& joints, aiNode* nd);
+    void CollectChildJoints(const std::vector<TempJoint> &joints, std::vector<bool> &hadit, aiNode *nd, const aiMatrix4x4 &absTrafo);
+    void CollectChildJoints(const std::vector<TempJoint> &joints, aiNode *nd);
 
-    template<typename T> void ReadComments(StreamReaderLE& stream, std::vector<T>& outp);
-private:
-
-    aiScene* mScene;
+    template <typename T>
+    void ReadComments(StreamReaderLE &stream, std::vector<T> &outp);
 
 private:
+    aiScene *mScene;
 
-    struct TempVertex
-    {
+private:
+    struct TempVertex {
         aiVector3D pos;
         unsigned int bone_id[4], ref_cnt;
         float weights[4];
     };
 
-    struct TempTriangle
-    {
+    struct TempTriangle {
         unsigned int indices[3];
         aiVector3D normals[3];
         aiVector2D uv[3];
@@ -116,34 +104,30 @@ private:
         unsigned int sg, group;
     };
 
-    struct TempGroup
-    {
+    struct TempGroup {
         char name[33]; // +0
         std::vector<unsigned int> triangles;
         unsigned int mat; // 0xff is no material
         std::string comment;
     };
 
-    struct TempMaterial
-    {
+    struct TempMaterial {
         // again, add an extra 0 character to all strings -
         char name[33];
         char texture[129];
         char alphamap[129];
 
-        aiColor4D diffuse,specular,ambient,emissive;
-        float shininess,transparency;
+        aiColor4D diffuse, specular, ambient, emissive;
+        float shininess, transparency;
         std::string comment;
     };
 
-    struct TempKeyFrame
-    {
+    struct TempKeyFrame {
         float time;
         aiVector3D value;
     };
 
-    struct TempJoint
-    {
+    struct TempJoint {
         char name[33];
         char parentName[33];
         aiVector3D rotation, position;
@@ -158,5 +142,5 @@ private:
     //};
 };
 
-}
+} // namespace Assimp
 #endif
diff --git a/Engine/lib/assimp/code/NDO/NDOLoader.cpp b/Engine/lib/assimp/code/AssetLib/NDO/NDOLoader.cpp
similarity index 94%
rename from Engine/lib/assimp/code/NDO/NDOLoader.cpp
rename to Engine/lib/assimp/code/AssetLib/NDO/NDOLoader.cpp
index d33f40c75..37c543692 100644
--- a/Engine/lib/assimp/code/NDO/NDOLoader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/NDO/NDOLoader.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -82,19 +80,10 @@ NDOImporter::~NDOImporter()
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool NDOImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
+bool NDOImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/) const
 {
-    // check file extension
-    const std::string extension = GetExtension(pFile);
-
-    if( extension == "ndo")
-        return true;
-
-    if ((checkSig || !extension.length()) && pIOHandler) {
-        const char* tokens[] = {"nendo"};
-        return SearchFileHeaderForToken(pIOHandler,pFile,tokens,1,5);
-    }
-    return false;
+    static const char* tokens[] = {"nendo"};
+    return SearchFileHeaderForToken(pIOHandler,pFile,tokens,AI_COUNT_OF(tokens),5);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -116,7 +105,13 @@ void NDOImporter::SetupProperties(const Importer* /*pImp*/)
 void NDOImporter::InternReadFile( const std::string& pFile,
     aiScene* pScene, IOSystem* pIOHandler)
 {
-    StreamReaderBE reader(pIOHandler->Open( pFile, "rb"));
+
+    auto file = pIOHandler->Open( pFile, "rb");
+    if (!file) {
+        throw DeadlyImportError("Nendo: Could not open ", pFile);
+    }
+
+    StreamReaderBE reader(file);
 
     // first 9 bytes are nendo file format ("nendo 1.n")
     const char* head = (const char*)reader.GetPtr();
@@ -141,7 +136,7 @@ void NDOImporter::InternReadFile( const std::string& pFile,
         ASSIMP_LOG_INFO("NDO file format is 1.2");
     }
     else {
-        ASSIMP_LOG_WARN_F( "Unrecognized nendo file format version, continuing happily ... :", (head+6));
+        ASSIMP_LOG_WARN( "Unrecognized nendo file format version, continuing happily ... :", (head+6));
     }
 
     reader.IncPtr(2); /* skip flags */
diff --git a/Engine/lib/assimp/code/NDO/NDOLoader.h b/Engine/lib/assimp/code/AssetLib/NDO/NDOLoader.h
similarity index 84%
rename from Engine/lib/assimp/code/NDO/NDOLoader.h
rename to Engine/lib/assimp/code/AssetLib/NDO/NDOLoader.h
index f2212edab..61dd93981 100644
--- a/Engine/lib/assimp/code/NDO/NDOLoader.h
+++ b/Engine/lib/assimp/code/AssetLib/NDO/NDOLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2008, assimp team
+Copyright (c) 2006-2022, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -44,19 +44,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef INCLUDED_AI_NDO_LOADER_H
 #define INCLUDED_AI_NDO_LOADER_H
 
-#include <assimp/vector3.h>
 #include <assimp/BaseImporter.h>
-#include <stdint.h>
+#include <assimp/vector3.h>
+#include <cstdint>
 #include <string>
 #include <vector>
 
-
 struct aiImporterDesc;
 struct aiScene;
 
-namespace Assimp    {
-    class IOSystem;
-    class Importer;
+namespace Assimp {
+class IOSystem;
+class Importer;
 
 // ---------------------------------------------------------------------------
 /** @brief Importer class to load meshes from Nendo.
@@ -64,38 +63,30 @@ namespace Assimp    {
  *  Basing on
  *  <blender>/blender/release/scripts/nendo_import.py by Anthony D'Agostino.
 */
-class NDOImporter : public BaseImporter
-{
+class NDOImporter : public BaseImporter {
 public:
     NDOImporter();
-    ~NDOImporter();
-
-
-public:
+    ~NDOImporter() override;
 
     //! Represents a single edge
-    struct Edge
-    {
+    struct Edge {
         unsigned int edge[8];
         unsigned int hard;
         uint8_t color[8];
     };
 
     //! Represents a single face
-    struct Face
-    {
+    struct Face {
         unsigned int elem;
     };
 
-    struct Vertex
-    {
+    struct Vertex {
         unsigned int num;
         aiVector3D val;
     };
 
     //! Represents a single object
-    struct Object
-    {
+    struct Object {
         std::string name;
 
         std::vector<Edge> edges;
@@ -104,23 +95,22 @@ public:
     };
 
     // -------------------------------------------------------------------
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
+            bool checkSig) const override;
 
 protected:
+    // -------------------------------------------------------------------
+    const aiImporterDesc *GetInfo() const override;
 
     // -------------------------------------------------------------------
-    const aiImporterDesc* GetInfo () const;
+    void SetupProperties(const Importer *pImp) override;
 
     // -------------------------------------------------------------------
-    void SetupProperties(const Importer* pImp);
-
-    // -------------------------------------------------------------------
-    void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
-
-private:
+    void InternReadFile(const std::string &pFile, aiScene *pScene,
+            IOSystem *pIOHandler) override;
 
 }; // end of class NDOImporter
+
 } // end of namespace Assimp
+
 #endif // INCLUDED_AI_NDO_LOADER_H
diff --git a/Engine/lib/assimp/code/NFF/NFFLoader.cpp b/Engine/lib/assimp/code/AssetLib/NFF/NFFLoader.cpp
similarity index 54%
rename from Engine/lib/assimp/code/NFF/NFFLoader.cpp
rename to Engine/lib/assimp/code/AssetLib/NFF/NFFLoader.cpp
index 10a7d1aff..48271d137 100644
--- a/Engine/lib/assimp/code/NFF/NFFLoader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/NFF/NFFLoader.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,23 +41,21 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** @file Implementation of the STL importer class */
 
-
 #ifndef ASSIMP_BUILD_NO_NFF_IMPORTER
 
 // internal headers
 #include "NFFLoader.h"
 #include <assimp/ParsingUtils.h>
-#include <assimp/StandardShapes.h>
-#include <assimp/qnan.h>
-#include <assimp/fast_atof.h>
 #include <assimp/RemoveComments.h>
-#include <assimp/IOSystem.hpp>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/scene.h>
+#include <assimp/StandardShapes.h>
+#include <assimp/fast_atof.h>
 #include <assimp/importerdesc.h>
+#include <assimp/qnan.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOSystem.hpp>
 #include <memory>
 
-
 using namespace Assimp;
 
 static const aiImporterDesc desc = {
@@ -77,70 +73,64 @@ static const aiImporterDesc desc = {
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-NFFImporter::NFFImporter()
-{}
+NFFImporter::NFFImporter() {}
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-NFFImporter::~NFFImporter()
-{}
+NFFImporter::~NFFImporter() {}
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool NFFImporter::CanRead( const std::string& pFile, IOSystem* /*pIOHandler*/, bool /*checkSig*/) const
-{
-    return SimpleExtensionCheck(pFile,"nff","enff");
+bool NFFImporter::CanRead(const std::string & pFile, IOSystem * /*pIOHandler*/, bool /*checkSig*/) const {
+    return SimpleExtensionCheck(pFile, "nff", "enff");
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get the list of all supported file extensions
-const aiImporterDesc* NFFImporter::GetInfo () const
-{
+const aiImporterDesc *NFFImporter::GetInfo() const {
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 #define AI_NFF_PARSE_FLOAT(f) \
-    SkipSpaces(&sz); \
-    if (!::IsLineEnd(*sz))sz = fast_atoreal_move<float>(sz, (float&)f);
+    SkipSpaces(&sz);          \
+    if (!::IsLineEnd(*sz)) sz = fast_atoreal_move<ai_real>(sz, (ai_real &)f);
 
 // ------------------------------------------------------------------------------------------------
 #define AI_NFF_PARSE_TRIPLE(v) \
-    AI_NFF_PARSE_FLOAT(v[0]) \
-    AI_NFF_PARSE_FLOAT(v[1]) \
+    AI_NFF_PARSE_FLOAT(v[0])   \
+    AI_NFF_PARSE_FLOAT(v[1])   \
     AI_NFF_PARSE_FLOAT(v[2])
 
 // ------------------------------------------------------------------------------------------------
-#define AI_NFF_PARSE_SHAPE_INFORMATION() \
-    aiVector3D center, radius(1.0f,get_qnan(),get_qnan()); \
-    AI_NFF_PARSE_TRIPLE(center); \
-    AI_NFF_PARSE_TRIPLE(radius); \
-    if (is_qnan(radius.z))radius.z = radius.x; \
-    if (is_qnan(radius.y))radius.y = radius.x; \
-    currentMesh.radius = radius; \
-    currentMesh.center = center;
+#define AI_NFF_PARSE_SHAPE_INFORMATION()                     \
+    aiVector3D center, radius(1.0f, get_qnan(), get_qnan()); \
+    AI_NFF_PARSE_TRIPLE(center);                             \
+    AI_NFF_PARSE_TRIPLE(radius);                             \
+    if (is_qnan(radius.z)) radius.z = radius.x;              \
+    if (is_qnan(radius.y)) radius.y = radius.x;              \
+    curMesh.radius = radius;                                 \
+    curMesh.center = center;
 
 // ------------------------------------------------------------------------------------------------
-#define AI_NFF2_GET_NEXT_TOKEN() \
-    do \
-    { \
-    if (!GetNextLine(buffer,line)) \
-        {ASSIMP_LOG_WARN("NFF2: Unexpected EOF, can't read next token");break;} \
-    SkipSpaces(line,&sz); \
-    } \
-    while(IsLineEnd(*sz))
-
+#define AI_NFF2_GET_NEXT_TOKEN()                                            \
+    do {                                                                    \
+        if (!GetNextLine(buffer, line)) {                                   \
+            ASSIMP_LOG_WARN("NFF2: Unexpected EOF, can't read next token"); \
+            break;                                                          \
+        }                                                                   \
+        SkipSpaces(line, &sz);                                              \
+    } while (IsLineEnd(*sz))
 
 // ------------------------------------------------------------------------------------------------
 // Loads the material table for the NFF2 file format from an external file
-void NFFImporter::LoadNFF2MaterialTable(std::vector<ShadingInfo>& output,
-    const std::string& path, IOSystem* pIOHandler)
-{
-    std::unique_ptr<IOStream> file( pIOHandler->Open( path, "rb"));
+void NFFImporter::LoadNFF2MaterialTable(std::vector<ShadingInfo> &output,
+        const std::string &path, IOSystem *pIOHandler) {
+    std::unique_ptr<IOStream> file(pIOHandler->Open(path, "rb"));
 
     // Check whether we can read from the file
-    if( !file.get())    {
-        ASSIMP_LOG_ERROR("NFF2: Unable to open material library " + path + ".");
+    if (!file.get()) {
+        ASSIMP_LOG_ERROR("NFF2: Unable to open material library ", path, ".");
         return;
     }
 
@@ -149,83 +139,65 @@ void NFFImporter::LoadNFF2MaterialTable(std::vector<ShadingInfo>& output,
 
     // allocate storage and copy the contents of the file to a memory buffer
     // (terminate it with zero)
-    std::vector<char> mBuffer2(m+1);
-    TextFileToBuffer(file.get(),mBuffer2);
-    const char* buffer = &mBuffer2[0];
+    std::vector<char> mBuffer2(m + 1);
+    TextFileToBuffer(file.get(), mBuffer2);
+    const char *buffer = &mBuffer2[0];
 
     // First of all: remove all comments from the file
-    CommentRemover::RemoveLineComments("//",&mBuffer2[0]);
+    CommentRemover::RemoveLineComments("//", &mBuffer2[0]);
 
     // The file should start with the magic sequence "mat"
-    if (!TokenMatch(buffer,"mat",3))    {
-        ASSIMP_LOG_ERROR_F("NFF2: Not a valid material library ", path, ".");
+    if (!TokenMatch(buffer, "mat", 3)) {
+        ASSIMP_LOG_ERROR("NFF2: Not a valid material library ", path, ".");
         return;
     }
 
-    ShadingInfo* curShader = NULL;
+    ShadingInfo *curShader = nullptr;
 
     // No read the file line per line
     char line[4096];
-    const char* sz;
-    while (GetNextLine(buffer,line))
-    {
-        SkipSpaces(line,&sz);
+    const char *sz;
+    while (GetNextLine(buffer, line)) {
+        SkipSpaces(line, &sz);
 
         // 'version' defines the version of the file format
-        if (TokenMatch(sz,"version",7))
-        {
-            ASSIMP_LOG_INFO_F("NFF (Sense8) material library file format: ", std::string(sz));
+        if (TokenMatch(sz, "version", 7)) {
+            ASSIMP_LOG_INFO("NFF (Sense8) material library file format: ", std::string(sz));
         }
         // 'matdef' starts a new material in the file
-        else if (TokenMatch(sz,"matdef",6))
-        {
+        else if (TokenMatch(sz, "matdef", 6)) {
             // add a new material to the list
-            output.push_back( ShadingInfo() );
-            curShader = & output.back();
+            output.push_back(ShadingInfo());
+            curShader = &output.back();
 
             // parse the name of the material
-        }
-        else if (!TokenMatch(sz,"valid",5))
-        {
+        } else if (!TokenMatch(sz, "valid", 5)) {
             // check whether we have an active material at the moment
-            if (!IsLineEnd(*sz))
-            {
-                if (!curShader)
-                {
-                    ASSIMP_LOG_ERROR_F("NFF2 material library: Found element ", sz, "but there is no active material");
+            if (!IsLineEnd(*sz)) {
+                if (!curShader) {
+                    ASSIMP_LOG_ERROR("NFF2 material library: Found element ", sz, "but there is no active material");
                     continue;
                 }
-            }
-            else continue;
+            } else
+                continue;
 
             // now read the material property and determine its type
             aiColor3D c;
-            if (TokenMatch(sz,"ambient",7))
-            {
+            if (TokenMatch(sz, "ambient", 7)) {
                 AI_NFF_PARSE_TRIPLE(c);
                 curShader->ambient = c;
-            }
-            else if (TokenMatch(sz,"diffuse",7) || TokenMatch(sz,"ambientdiffuse",14) /* correct? */)
-            {
+            } else if (TokenMatch(sz, "diffuse", 7) || TokenMatch(sz, "ambientdiffuse", 14) /* correct? */) {
                 AI_NFF_PARSE_TRIPLE(c);
                 curShader->diffuse = curShader->ambient = c;
-            }
-            else if (TokenMatch(sz,"specular",8))
-            {
+            } else if (TokenMatch(sz, "specular", 8)) {
                 AI_NFF_PARSE_TRIPLE(c);
                 curShader->specular = c;
-            }
-            else if (TokenMatch(sz,"emission",8))
-            {
+            } else if (TokenMatch(sz, "emission", 8)) {
                 AI_NFF_PARSE_TRIPLE(c);
                 curShader->emissive = c;
-            }
-            else if (TokenMatch(sz,"shininess",9))
-            {
+            } else if (TokenMatch(sz, "shininess", 9)) {
                 AI_NFF_PARSE_FLOAT(curShader->shininess);
-            }
-            else if (TokenMatch(sz,"opacity",7))
-            {
+            } else if (TokenMatch(sz, "opacity", 7)) {
                 AI_NFF_PARSE_FLOAT(curShader->opacity);
             }
         }
@@ -234,20 +206,19 @@ void NFFImporter::LoadNFF2MaterialTable(std::vector<ShadingInfo>& output,
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void NFFImporter::InternReadFile( const std::string& pFile,
-    aiScene* pScene, IOSystem* pIOHandler)
-{
-    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));
+void NFFImporter::InternReadFile(const std::string &pFile,
+        aiScene *pScene, IOSystem *pIOHandler) {
+    std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));
 
     // Check whether we can read from the file
-    if( !file.get())
-        throw DeadlyImportError( "Failed to open NFF file " + pFile + ".");
+    if (!file.get())
+        throw DeadlyImportError("Failed to open NFF file ", pFile, ".");
 
     // allocate storage and copy the contents of the file to a memory buffer
     // (terminate it with zero)
     std::vector<char> mBuffer2;
-    TextFileToBuffer(file.get(),mBuffer2);
-    const char* buffer = &mBuffer2[0];
+    TextFileToBuffer(file.get(), mBuffer2);
+    const char *buffer = &mBuffer2[0];
 
     // mesh arrays - separate here to make the handling of the pointers below easier.
     std::vector<MeshInfo> meshes;
@@ -256,18 +227,18 @@ void NFFImporter::InternReadFile( const std::string& pFile,
     std::vector<MeshInfo> meshesLocked;
 
     char line[4096];
-    const char* sz;
+    const char *sz;
 
     // camera parameters
-    aiVector3D camPos, camUp(0.f,1.f,0.f), camLookAt(0.f,0.f,1.f);
-    float angle = 45.f;
+    aiVector3D camPos, camUp(0.f, 1.f, 0.f), camLookAt(0.f, 0.f, 1.f);
+    ai_real angle = 45.f;
     aiVector2D resolution;
 
     bool hasCam = false;
 
-    MeshInfo* currentMeshWithNormals = NULL;
-    MeshInfo* currentMesh = NULL;
-    MeshInfo* currentMeshWithUVCoords = NULL;
+    MeshInfo *currentMeshWithNormals = nullptr;
+    MeshInfo *currentMesh = nullptr;
+    MeshInfo *currentMeshWithUVCoords = nullptr;
 
     ShadingInfo s; // current material info
 
@@ -275,24 +246,23 @@ void NFFImporter::InternReadFile( const std::string& pFile,
     unsigned int iTesselation = 4;
 
     // some temporary variables we need to parse the file
-    unsigned int sphere     = 0,
-        cylinder            = 0,
-        cone                = 0,
-        numNamed            = 0,
-        dodecahedron        = 0,
-        octahedron          = 0,
-        tetrahedron         = 0,
-        hexahedron          = 0;
+    unsigned int sphere = 0,
+                 cylinder = 0,
+                 cone = 0,
+                 numNamed = 0,
+                 dodecahedron = 0,
+                 octahedron = 0,
+                 tetrahedron = 0,
+                 hexahedron = 0;
 
     // lights imported from the file
     std::vector<Light> lights;
 
     // check whether this is the NFF2 file format
-    if (TokenMatch(buffer,"nff",3))
-    {
-        const float qnan = get_qnan();
-        const aiColor4D  cQNAN = aiColor4D (qnan,0.f,0.f,1.f);
-        const aiVector3D vQNAN = aiVector3D(qnan,0.f,0.f);
+    if (TokenMatch(buffer, "nff", 3)) {
+        const ai_real qnan = get_qnan();
+        const aiColor4D cQNAN = aiColor4D(qnan, 0.f, 0.f, 1.f);
+        const aiVector3D vQNAN = aiVector3D(qnan, 0.f, 0.f);
 
         // another NFF file format ... just a raw parser has been implemented
         // no support for further details, I don't think it is worth the effort
@@ -300,132 +270,119 @@ void NFFImporter::InternReadFile( const std::string& pFile,
         // http://www.netghost.narod.ru/gff/graphics/summary/sense8.htm
 
         // First of all: remove all comments from the file
-        CommentRemover::RemoveLineComments("//",&mBuffer2[0]);
+        CommentRemover::RemoveLineComments("//", &mBuffer2[0]);
 
-        while (GetNextLine(buffer,line))
-        {
-            SkipSpaces(line,&sz);
-            if (TokenMatch(sz,"version",7))
-            {
-                ASSIMP_LOG_INFO_F("NFF (Sense8) file format: ", sz );
-            }
-            else if (TokenMatch(sz,"viewpos",7))
-            {
+        while (GetNextLine(buffer, line)) {
+            SkipSpaces(line, &sz);
+            if (TokenMatch(sz, "version", 7)) {
+                ASSIMP_LOG_INFO("NFF (Sense8) file format: ", sz);
+            } else if (TokenMatch(sz, "viewpos", 7)) {
                 AI_NFF_PARSE_TRIPLE(camPos);
                 hasCam = true;
-            }
-            else if (TokenMatch(sz,"viewdir",7))
-            {
+            } else if (TokenMatch(sz, "viewdir", 7)) {
                 AI_NFF_PARSE_TRIPLE(camLookAt);
                 hasCam = true;
             }
             // This starts a new object section
-            else if (!IsSpaceOrNewLine(*sz))
-            {
+            else if (!IsSpaceOrNewLine(*sz)) {
                 unsigned int subMeshIdx = 0;
 
                 // read the name of the object, skip all spaces
                 // at the end of it.
-                const char* sz3 = sz;
-                while (!IsSpaceOrNewLine(*sz))++sz;
-                std::string objectName = std::string(sz3,(unsigned int)(sz-sz3));
+                const char *sz3 = sz;
+                while (!IsSpaceOrNewLine(*sz))
+                    ++sz;
+                std::string objectName = std::string(sz3, (unsigned int)(sz - sz3));
 
                 const unsigned int objStart = (unsigned int)meshes.size();
 
                 // There could be a material table in a separate file
                 std::vector<ShadingInfo> materialTable;
-                while (true)
-                {
+                while (true) {
                     AI_NFF2_GET_NEXT_TOKEN();
 
                     // material table - an external file
-                    if (TokenMatch(sz,"mtable",6))
-                    {
+                    if (TokenMatch(sz, "mtable", 6)) {
                         SkipSpaces(&sz);
                         sz3 = sz;
-                        while (!IsSpaceOrNewLine(*sz))++sz;
-                        const unsigned int diff = (unsigned int)(sz-sz3);
-                        if (!diff)ASSIMP_LOG_WARN("NFF2: Found empty mtable token");
-                        else
-                        {
+                        while (!IsSpaceOrNewLine(*sz))
+                            ++sz;
+                        const unsigned int diff = (unsigned int)(sz - sz3);
+                        if (!diff)
+                            ASSIMP_LOG_WARN("NFF2: Found empty mtable token");
+                        else {
                             // The material table has the file extension .mat.
                             // If it is not there, we need to append it
-                            std::string path = std::string(sz3,diff);
-                            if(std::string::npos == path.find_last_of(".mat"))
-                            {
+                            std::string path = std::string(sz3, diff);
+                            if (std::string::npos == path.find_last_of(".mat")) {
                                 path.append(".mat");
                             }
 
                             // Now extract the working directory from the path to
                             // this file and append the material library filename
                             // to it.
-                            std::string::size_type s;
-                            if ((std::string::npos == (s = path.find_last_of('\\')) || !s) &&
-                                (std::string::npos == (s = path.find_last_of('/'))  || !s) )
-                            {
-                                s = pFile.find_last_of('\\');
-                                if (std::string::npos == s)s = pFile.find_last_of('/');
-                                if (std::string::npos != s)
-                                {
-                                    path = pFile.substr(0,s+1) + path;
+                            std::string::size_type sepPos;
+                            if ((std::string::npos == (sepPos = path.find_last_of('\\')) || !sepPos) &&
+                                    (std::string::npos == (sepPos = path.find_last_of('/')) || !sepPos)) {
+                                sepPos = pFile.find_last_of('\\');
+                                if (std::string::npos == sepPos) {
+                                    sepPos = pFile.find_last_of('/');
+                                }
+                                if (std::string::npos != sepPos) {
+                                    path = pFile.substr(0, sepPos + 1) + path;
                                 }
                             }
-                            LoadNFF2MaterialTable(materialTable,path,pIOHandler);
+                            LoadNFF2MaterialTable(materialTable, path, pIOHandler);
                         }
-                    }
-                    else break;
+                    } else
+                        break;
                 }
 
                 // read the numbr of vertices
-                unsigned int num = ::strtoul10(sz,&sz);
+                unsigned int num = ::strtoul10(sz, &sz);
 
                 // temporary storage
-                std::vector<aiColor4D>  tempColors;
-                std::vector<aiVector3D> tempPositions,tempTextureCoords,tempNormals;
+                std::vector<aiColor4D> tempColors;
+                std::vector<aiVector3D> tempPositions, tempTextureCoords, tempNormals;
 
-                bool hasNormals = false,hasUVs = false,hasColor = false;
+                bool hasNormals = false, hasUVs = false, hasColor = false;
 
-                tempPositions.reserve      (num);
-                tempColors.reserve         (num);
-                tempNormals.reserve        (num);
-                tempTextureCoords.reserve  (num);
-                for (unsigned int i = 0; i < num; ++i)
-                {
+                tempPositions.reserve(num);
+                tempColors.reserve(num);
+                tempNormals.reserve(num);
+                tempTextureCoords.reserve(num);
+                for (unsigned int i = 0; i < num; ++i) {
                     AI_NFF2_GET_NEXT_TOKEN();
                     aiVector3D v;
                     AI_NFF_PARSE_TRIPLE(v);
                     tempPositions.push_back(v);
 
                     // parse all other attributes in the line
-                    while (true)
-                    {
+                    while (true) {
                         SkipSpaces(&sz);
-                        if (IsLineEnd(*sz))break;
+                        if (IsLineEnd(*sz)) break;
 
                         // color definition
-                        if (TokenMatch(sz,"0x",2))
-                        {
+                        if (TokenMatch(sz, "0x", 2)) {
                             hasColor = true;
-                            unsigned int numIdx = ::strtoul16(sz,&sz);
+                            unsigned int numIdx = ::strtoul16(sz, &sz);
                             aiColor4D clr;
                             clr.a = 1.f;
 
                             // 0xRRGGBB
                             clr.r = ((numIdx >> 16u) & 0xff) / 255.f;
-                            clr.g = ((numIdx >> 8u)  & 0xff) / 255.f;
-                            clr.b = ((numIdx)        & 0xff) / 255.f;
+                            clr.g = ((numIdx >> 8u) & 0xff) / 255.f;
+                            clr.b = ((numIdx)&0xff) / 255.f;
                             tempColors.push_back(clr);
                         }
                         // normal vector
-                        else if (TokenMatch(sz,"norm",4))
-                        {
+                        else if (TokenMatch(sz, "norm", 4)) {
                             hasNormals = true;
                             AI_NFF_PARSE_TRIPLE(v);
                             tempNormals.push_back(v);
                         }
                         // UV coordinate
-                        else if (TokenMatch(sz,"uv",2))
-                        {
+                        else if (TokenMatch(sz, "uv", 2)) {
                             hasUVs = true;
                             AI_NFF_PARSE_FLOAT(v.x);
                             AI_NFF_PARSE_FLOAT(v.y);
@@ -446,32 +403,28 @@ void NFFImporter::InternReadFile( const std::string& pFile,
                 }
 
                 AI_NFF2_GET_NEXT_TOKEN();
-                if (!num)throw DeadlyImportError("NFF2: There are zero vertices");
-                num = ::strtoul10(sz,&sz);
+                if (!num) throw DeadlyImportError("NFF2: There are zero vertices");
+                num = ::strtoul10(sz, &sz);
 
                 std::vector<unsigned int> tempIdx;
                 tempIdx.reserve(10);
-                for (unsigned int i = 0; i < num; ++i)
-                {
+                for (unsigned int i = 0; i < num; ++i) {
                     AI_NFF2_GET_NEXT_TOKEN();
-                    SkipSpaces(line,&sz);
-                    unsigned int numIdx = ::strtoul10(sz,&sz);
+                    SkipSpaces(line, &sz);
+                    unsigned int numIdx = ::strtoul10(sz, &sz);
 
                     // read all faces indices
-                    if (numIdx)
-                    {
+                    if (numIdx) {
                         // mesh.faces.push_back(numIdx);
                         // tempIdx.erase(tempIdx.begin(),tempIdx.end());
                         tempIdx.resize(numIdx);
 
-                        for (unsigned int a = 0; a < numIdx;++a)
-                        {
-                            SkipSpaces(sz,&sz);
-                            unsigned int m = ::strtoul10(sz,&sz);
-                            if (m >= (unsigned int)tempPositions.size())
-                            {
+                        for (unsigned int a = 0; a < numIdx; ++a) {
+                            SkipSpaces(sz, &sz);
+                            unsigned int m = ::strtoul10(sz, &sz);
+                            if (m >= (unsigned int)tempPositions.size()) {
                                 ASSIMP_LOG_ERROR("NFF2: Vertex index overflow");
-                                m= 0;
+                                m = 0;
                             }
                             // mesh.vertices.push_back (tempPositions[idx]);
                             tempIdx[a] = m;
@@ -483,34 +436,30 @@ void NFFImporter::InternReadFile( const std::string& pFile,
                     unsigned int matIdx = 0;
 
                     // white material color - we have vertex colors
-                    shader.color = aiColor3D(1.f,1.f,1.f);
-                    aiColor4D c  = aiColor4D(1.f,1.f,1.f,1.f);
-                    while (true)
-                    {
-                        SkipSpaces(sz,&sz);
-                        if(IsLineEnd(*sz))break;
+                    shader.color = aiColor3D(1.f, 1.f, 1.f);
+                    aiColor4D c = aiColor4D(1.f, 1.f, 1.f, 1.f);
+                    while (true) {
+                        SkipSpaces(sz, &sz);
+                        if (IsLineEnd(*sz)) break;
 
                         // per-polygon colors
-                        if (TokenMatch(sz,"0x",2))
-                        {
+                        if (TokenMatch(sz, "0x", 2)) {
                             hasColor = true;
-                            const char* sz2 = sz;
-                            numIdx = ::strtoul16(sz,&sz);
-                            const unsigned int diff = (unsigned int)(sz-sz2);
+                            const char *sz2 = sz;
+                            numIdx = ::strtoul16(sz, &sz);
+                            const unsigned int diff = (unsigned int)(sz - sz2);
 
                             // 0xRRGGBB
-                            if (diff > 3)
-                            {
+                            if (diff > 3) {
                                 c.r = ((numIdx >> 16u) & 0xff) / 255.f;
-                                c.g = ((numIdx >> 8u)  & 0xff) / 255.f;
-                                c.b = ((numIdx)        & 0xff) / 255.f;
+                                c.g = ((numIdx >> 8u) & 0xff) / 255.f;
+                                c.b = ((numIdx)&0xff) / 255.f;
                             }
                             // 0xRGB
-                            else
-                            {
+                            else {
                                 c.r = ((numIdx >> 8u) & 0xf) / 16.f;
                                 c.g = ((numIdx >> 4u) & 0xf) / 16.f;
-                                c.b = ((numIdx)       & 0xf) / 16.f;
+                                c.b = ((numIdx)&0xf) / 16.f;
                             }
                         }
                         // TODO - implement texture mapping here
@@ -534,81 +483,73 @@ void NFFImporter::InternReadFile( const std::string& pFile,
 #endif
 
                         // texture file name for this polygon + mapping information
-                        else if ('_' == sz[0])
-                        {
+                        else if ('_' == sz[0]) {
                             // get mapping information
-                            switch (sz[1])
-                            {
-                            case 'v':
-                            case 'V':
+                            switch (sz[1]) {
+                                case 'v':
+                                case 'V':
 
-                                shader.shaded = false;
-                                break;
+                                    shader.shaded = false;
+                                    break;
 
-                            case 't':
-                            case 'T':
-                            case 'u':
-                            case 'U':
+                                case 't':
+                                case 'T':
+                                case 'u':
+                                case 'U':
 
-                                ASSIMP_LOG_WARN("Unsupported NFF2 texture attribute: trans");
+                                    ASSIMP_LOG_WARN("Unsupported NFF2 texture attribute: trans");
                             };
-                            if (!sz[1] || '_' != sz[2])
-                            {
+                            if (!sz[1] || '_' != sz[2]) {
                                 ASSIMP_LOG_WARN("NFF2: Expected underscore after texture attributes");
                                 continue;
                             }
-                            const char* sz2 = sz+3;
-                            while (!IsSpaceOrNewLine( *sz ))++sz;
-                            const unsigned int diff = (unsigned int)(sz-sz2);
-                            if (diff)shader.texFile = std::string(sz2,diff);
+                            const char *sz2 = sz + 3;
+                            while (!IsSpaceOrNewLine(*sz))
+                                ++sz;
+                            const unsigned int diff = (unsigned int)(sz - sz2);
+                            if (diff) shader.texFile = std::string(sz2, diff);
                         }
 
                         // Two-sided material?
-                        else if (TokenMatch(sz,"both",4))
-                        {
+                        else if (TokenMatch(sz, "both", 4)) {
                             shader.twoSided = true;
                         }
 
                         // Material ID?
-                        else if (!materialTable.empty() && TokenMatch(sz,"matid",5))
-                        {
+                        else if (!materialTable.empty() && TokenMatch(sz, "matid", 5)) {
                             SkipSpaces(&sz);
-                            matIdx = ::strtoul10(sz,&sz);
-                            if (matIdx >= materialTable.size())
-                            {
+                            matIdx = ::strtoul10(sz, &sz);
+                            if (matIdx >= materialTable.size()) {
                                 ASSIMP_LOG_ERROR("NFF2: Material index overflow.");
                                 matIdx = 0;
                             }
 
                             // now combine our current shader with the shader we
                             // read from the material table.
-                            ShadingInfo& mat = materialTable[matIdx];
-                            shader.ambient   = mat.ambient;
-                            shader.diffuse   = mat.diffuse;
-                            shader.emissive  = mat.emissive;
-                            shader.opacity   = mat.opacity;
-                            shader.specular  = mat.specular;
+                            ShadingInfo &mat = materialTable[matIdx];
+                            shader.ambient = mat.ambient;
+                            shader.diffuse = mat.diffuse;
+                            shader.emissive = mat.emissive;
+                            shader.opacity = mat.opacity;
+                            shader.specular = mat.specular;
                             shader.shininess = mat.shininess;
-                        }
-                        else SkipToken(sz);
+                        } else
+                            SkipToken(sz);
                     }
 
                     // search the list of all shaders we have for this object whether
                     // there is an identical one. In this case, we append our mesh
                     // data to it.
-                    MeshInfo* mesh = NULL;
+                    MeshInfo *mesh = nullptr;
                     for (std::vector<MeshInfo>::iterator it = meshes.begin() + objStart, end = meshes.end();
-                         it != end; ++it)
-                    {
-                        if ((*it).shader == shader && (*it).matIndex == matIdx)
-                        {
+                            it != end; ++it) {
+                        if ((*it).shader == shader && (*it).matIndex == matIdx) {
                             // we have one, we can append our data to it
                             mesh = &(*it);
                         }
                     }
-                    if (!mesh)
-                    {
-                        meshes.push_back(MeshInfo(PatchType_Simple,false));
+                    if (!mesh) {
+                        meshes.push_back(MeshInfo(PatchType_Simple, false));
                         mesh = &meshes.back();
                         mesh->matIndex = matIdx;
 
@@ -616,10 +557,9 @@ void NFFImporter::InternReadFile( const std::string& pFile,
                         // an unique name to it to make sure the scene will
                         // pass the validation step for the moment.
                         // TODO: fix naming of objects in the scenegraph later
-                        if (objectName.length())
-                        {
-                            ::strcpy(mesh->name,objectName.c_str());
-                            ASSIMP_itoa10(&mesh->name[objectName.length()],30,subMeshIdx++);
+                        if (objectName.length()) {
+                            ::strcpy(mesh->name, objectName.c_str());
+                            ASSIMP_itoa10(&mesh->name[objectName.length()], 30, subMeshIdx++);
                         }
 
                         // copy the shader to the mesh.
@@ -627,63 +567,53 @@ void NFFImporter::InternReadFile( const std::string& pFile,
                     }
 
                     // fill the mesh with data
-                    if (!tempIdx.empty())
-                    {
+                    if (!tempIdx.empty()) {
                         mesh->faces.push_back((unsigned int)tempIdx.size());
                         for (std::vector<unsigned int>::const_iterator it = tempIdx.begin(), end = tempIdx.end();
-                            it != end;++it)
-                        {
+                                it != end; ++it) {
                             unsigned int m = *it;
 
                             // copy colors -vertex color specifications override polygon color specifications
-                            if (hasColor)
-                            {
-                                const aiColor4D& clr = tempColors[m];
-                                mesh->colors.push_back((is_qnan( clr.r ) ? c : clr));
+                            if (hasColor) {
+                                const aiColor4D &clr = tempColors[m];
+                                mesh->colors.push_back((is_qnan(clr.r) ? c : clr));
                             }
 
                             // positions should always be there
-                            mesh->vertices.push_back (tempPositions[m]);
+                            mesh->vertices.push_back(tempPositions[m]);
 
                             // copy normal vectors
                             if (hasNormals)
-                                mesh->normals.push_back  (tempNormals[m]);
+                                mesh->normals.push_back(tempNormals[m]);
 
                             // copy texture coordinates
                             if (hasUVs)
-                                mesh->uvs.push_back      (tempTextureCoords[m]);
+                                mesh->uvs.push_back(tempTextureCoords[m]);
                         }
                     }
                 }
-                if (!num)throw DeadlyImportError("NFF2: There are zero faces");
+                if (!num) throw DeadlyImportError("NFF2: There are zero faces");
             }
         }
         camLookAt = camLookAt + camPos;
-    }
-    else // "Normal" Neutral file format that is quite more common
+    } else // "Normal" Neutral file format that is quite more common
     {
-        while (GetNextLine(buffer,line))
-        {
+        while (GetNextLine(buffer, line)) {
             sz = line;
-            if ('p' == line[0] || TokenMatch(sz,"tpp",3))
-            {
-                MeshInfo* out = NULL;
+            if ('p' == line[0] || TokenMatch(sz, "tpp", 3)) {
+                MeshInfo *out = nullptr;
 
                 // 'tpp' - texture polygon patch primitive
-                if ('t' == line[0])
-                {
-                    currentMeshWithUVCoords = NULL;
-                    for (auto &mesh : meshesWithUVCoords)
-                    {
-                        if (mesh.shader == s)
-                        {
+                if ('t' == line[0]) {
+                    currentMeshWithUVCoords = nullptr;
+                    for (auto &mesh : meshesWithUVCoords) {
+                        if (mesh.shader == s) {
                             currentMeshWithUVCoords = &mesh;
                             break;
                         }
                     }
 
-                    if (!currentMeshWithUVCoords)
-                    {
+                    if (!currentMeshWithUVCoords) {
                         meshesWithUVCoords.push_back(MeshInfo(PatchType_UVAndNormals));
                         currentMeshWithUVCoords = &meshesWithUVCoords.back();
                         currentMeshWithUVCoords->shader = s;
@@ -691,104 +621,90 @@ void NFFImporter::InternReadFile( const std::string& pFile,
                     out = currentMeshWithUVCoords;
                 }
                 // 'pp' - polygon patch primitive
-                else if ('p' == line[1])
-                {
-                    currentMeshWithNormals = NULL;
-                    for (auto &mesh : meshesWithNormals)
-                    {
-                        if (mesh.shader == s)
-                        {
+                else if ('p' == line[1]) {
+                    currentMeshWithNormals = nullptr;
+                    for (auto &mesh : meshesWithNormals) {
+                        if (mesh.shader == s) {
                             currentMeshWithNormals = &mesh;
                             break;
                         }
                     }
 
-                    if (!currentMeshWithNormals)
-                    {
+                    if (!currentMeshWithNormals) {
                         meshesWithNormals.push_back(MeshInfo(PatchType_Normals));
                         currentMeshWithNormals = &meshesWithNormals.back();
                         currentMeshWithNormals->shader = s;
                     }
-                    sz = &line[2];out = currentMeshWithNormals;
+                    sz = &line[2];
+                    out = currentMeshWithNormals;
                 }
                 // 'p' - polygon primitive
-                else
-                {
-                    currentMesh = NULL;
-                    for (auto &mesh : meshes)
-                    {
-                        if (mesh.shader == s)
-                        {
+                else {
+                    currentMesh = nullptr;
+                    for (auto &mesh : meshes) {
+                        if (mesh.shader == s) {
                             currentMesh = &mesh;
                             break;
                         }
                     }
 
-                    if (!currentMesh)
-                    {
+                    if (!currentMesh) {
                         meshes.push_back(MeshInfo(PatchType_Simple));
                         currentMesh = &meshes.back();
                         currentMesh->shader = s;
                     }
-                    sz = &line[1];out = currentMesh;
+                    sz = &line[1];
+                    out = currentMesh;
                 }
-                SkipSpaces(sz,&sz);
+                SkipSpaces(sz, &sz);
                 unsigned int m = strtoul10(sz);
 
                 // ---- flip the face order
-                out->vertices.resize(out->vertices.size()+m);
-                if (out != currentMesh)
-                {
+                out->vertices.resize(out->vertices.size() + m);
+                if (out != currentMesh) {
                     out->normals.resize(out->vertices.size());
                 }
-                if (out == currentMeshWithUVCoords)
-                {
+                if (out == currentMeshWithUVCoords) {
                     out->uvs.resize(out->vertices.size());
                 }
-                for (unsigned int n = 0; n < m;++n)
-                {
-                    if(!GetNextLine(buffer,line))
-                    {
+                for (unsigned int n = 0; n < m; ++n) {
+                    if (!GetNextLine(buffer, line)) {
                         ASSIMP_LOG_ERROR("NFF: Unexpected EOF was encountered. Patch definition incomplete");
                         continue;
                     }
 
-                    aiVector3D v; sz = &line[0];
+                    aiVector3D v;
+                    sz = &line[0];
                     AI_NFF_PARSE_TRIPLE(v);
-                    out->vertices[out->vertices.size()-n-1] = v;
+                    out->vertices[out->vertices.size() - n - 1] = v;
 
-                    if (out != currentMesh)
-                    {
+                    if (out != currentMesh) {
                         AI_NFF_PARSE_TRIPLE(v);
-                        out->normals[out->vertices.size()-n-1] = v;
+                        out->normals[out->vertices.size() - n - 1] = v;
                     }
-                    if (out == currentMeshWithUVCoords)
-                    {
+                    if (out == currentMeshWithUVCoords) {
                         // FIX: in one test file this wraps over multiple lines
                         SkipSpaces(&sz);
-                        if (IsLineEnd(*sz))
-                        {
-                            GetNextLine(buffer,line);
+                        if (IsLineEnd(*sz)) {
+                            GetNextLine(buffer, line);
                             sz = line;
                         }
                         AI_NFF_PARSE_FLOAT(v.x);
                         SkipSpaces(&sz);
-                        if (IsLineEnd(*sz))
-                        {
-                            GetNextLine(buffer,line);
+                        if (IsLineEnd(*sz)) {
+                            GetNextLine(buffer, line);
                             sz = line;
                         }
                         AI_NFF_PARSE_FLOAT(v.y);
                         v.y = 1.f - v.y;
-                        out->uvs[out->vertices.size()-n-1] = v;
+                        out->uvs[out->vertices.size() - n - 1] = v;
                     }
                 }
                 out->faces.push_back(m);
             }
             // 'f' - shading information block
-            else if (TokenMatch(sz,"f",1))
-            {
-                float d;
+            else if (TokenMatch(sz, "f", 1)) {
+                ai_real d;
 
                 // read the RGB colors
                 AI_NFF_PARSE_TRIPLE(s.color);
@@ -802,158 +718,147 @@ void NFFImporter::InternReadFile( const std::string& pFile,
 
                 // NFF2 uses full colors here so we need to use them too
                 // although NFF uses simple scaling factors
-                s.diffuse.g  = s.diffuse.b = s.diffuse.r;
+                s.diffuse.g = s.diffuse.b = s.diffuse.r;
                 s.specular.g = s.specular.b = s.specular.r;
 
                 // if the next one is NOT a number we assume it is a texture file name
                 // this feature is used by some NFF files on the internet and it has
                 // been implemented as it can be really useful
                 SkipSpaces(&sz);
-                if (!IsNumeric(*sz))
-                {
+                if (!IsNumeric(*sz)) {
                     // TODO: Support full file names with spaces and quotation marks ...
-                    const char* p = sz;
-                    while (!IsSpaceOrNewLine( *sz ))++sz;
+                    const char *p = sz;
+                    while (!IsSpaceOrNewLine(*sz))
+                        ++sz;
 
-                    unsigned int diff = (unsigned int)(sz-p);
-                    if (diff)
-                    {
-                        s.texFile = std::string(p,diff);
+                    unsigned int diff = (unsigned int)(sz - p);
+                    if (diff) {
+                        s.texFile = std::string(p, diff);
                     }
-                }
-                else
-                {
+                } else {
                     AI_NFF_PARSE_FLOAT(s.ambient); // optional
                 }
             }
             // 'shader' - other way to specify a texture
-            else if (TokenMatch(sz,"shader",6))
-            {
+            else if (TokenMatch(sz, "shader", 6)) {
                 SkipSpaces(&sz);
-                const char* old = sz;
-                while (!IsSpaceOrNewLine(*sz))++sz;
+                const char *old = sz;
+                while (!IsSpaceOrNewLine(*sz))
+                    ++sz;
                 s.texFile = std::string(old, (uintptr_t)sz - (uintptr_t)old);
             }
             // 'l' - light source
-            else if (TokenMatch(sz,"l",1))
-            {
+            else if (TokenMatch(sz, "l", 1)) {
                 lights.push_back(Light());
-                Light& light = lights.back();
+                Light &light = lights.back();
 
                 AI_NFF_PARSE_TRIPLE(light.position);
-                AI_NFF_PARSE_FLOAT (light.intensity);
+                AI_NFF_PARSE_FLOAT(light.intensity);
                 AI_NFF_PARSE_TRIPLE(light.color);
             }
             // 's' - sphere
-            else if (TokenMatch(sz,"s",1))
-            {
-                meshesLocked.push_back(MeshInfo(PatchType_Simple,true));
-                MeshInfo& currentMesh = meshesLocked.back();
-                currentMesh.shader = s;
-                currentMesh.shader.mapping = aiTextureMapping_SPHERE;
+            else if (TokenMatch(sz, "s", 1)) {
+                meshesLocked.push_back(MeshInfo(PatchType_Simple, true));
+                MeshInfo &curMesh = meshesLocked.back();
+                curMesh.shader = s;
+                curMesh.shader.mapping = aiTextureMapping_SPHERE;
 
                 AI_NFF_PARSE_SHAPE_INFORMATION();
 
                 // we don't need scaling or translation here - we do it in the node's transform
-                StandardShapes::MakeSphere(iTesselation, currentMesh.vertices);
-                currentMesh.faces.resize(currentMesh.vertices.size()/3,3);
+                StandardShapes::MakeSphere(iTesselation, curMesh.vertices);
+                curMesh.faces.resize(curMesh.vertices.size() / 3, 3);
 
                 // generate a name for the mesh
-                ::ai_snprintf(currentMesh.name,128,"sphere_%i",sphere++);
+                ::ai_snprintf(curMesh.name, MeshInfo::MaxNameLen, "sphere_%i", sphere++);
             }
             // 'dod' - dodecahedron
-            else if (TokenMatch(sz,"dod",3))
-            {
-                meshesLocked.push_back(MeshInfo(PatchType_Simple,true));
-                MeshInfo& currentMesh = meshesLocked.back();
-                currentMesh.shader = s;
-                currentMesh.shader.mapping = aiTextureMapping_SPHERE;
+            else if (TokenMatch(sz, "dod", 3)) {
+                meshesLocked.push_back(MeshInfo(PatchType_Simple, true));
+                MeshInfo &curMesh = meshesLocked.back();
+                curMesh.shader = s;
+                curMesh.shader.mapping = aiTextureMapping_SPHERE;
 
                 AI_NFF_PARSE_SHAPE_INFORMATION();
 
                 // we don't need scaling or translation here - we do it in the node's transform
-                StandardShapes::MakeDodecahedron(currentMesh.vertices);
-                currentMesh.faces.resize(currentMesh.vertices.size()/3,3);
+                StandardShapes::MakeDodecahedron(curMesh.vertices);
+                curMesh.faces.resize(curMesh.vertices.size() / 3, 3);
 
                 // generate a name for the mesh
-                ::ai_snprintf(currentMesh.name,128,"dodecahedron_%i",dodecahedron++);
+                ::ai_snprintf(curMesh.name, 128, "dodecahedron_%i", dodecahedron++);
             }
 
             // 'oct' - octahedron
-            else if (TokenMatch(sz,"oct",3))
-            {
-                meshesLocked.push_back(MeshInfo(PatchType_Simple,true));
-                MeshInfo& currentMesh = meshesLocked.back();
-                currentMesh.shader = s;
-                currentMesh.shader.mapping = aiTextureMapping_SPHERE;
+            else if (TokenMatch(sz, "oct", 3)) {
+                meshesLocked.push_back(MeshInfo(PatchType_Simple, true));
+                MeshInfo &curMesh = meshesLocked.back();
+                curMesh.shader = s;
+                curMesh.shader.mapping = aiTextureMapping_SPHERE;
 
                 AI_NFF_PARSE_SHAPE_INFORMATION();
 
                 // we don't need scaling or translation here - we do it in the node's transform
-                StandardShapes::MakeOctahedron(currentMesh.vertices);
-                currentMesh.faces.resize(currentMesh.vertices.size()/3,3);
+                StandardShapes::MakeOctahedron(curMesh.vertices);
+                curMesh.faces.resize(curMesh.vertices.size() / 3, 3);
 
                 // generate a name for the mesh
-                ::ai_snprintf(currentMesh.name,128,"octahedron_%i",octahedron++);
+                ::ai_snprintf(curMesh.name, MeshInfo::MaxNameLen, "octahedron_%i", octahedron++);
             }
 
             // 'tet' - tetrahedron
-            else if (TokenMatch(sz,"tet",3))
-            {
-                meshesLocked.push_back(MeshInfo(PatchType_Simple,true));
-                MeshInfo& currentMesh = meshesLocked.back();
-                currentMesh.shader = s;
-                currentMesh.shader.mapping = aiTextureMapping_SPHERE;
+            else if (TokenMatch(sz, "tet", 3)) {
+                meshesLocked.push_back(MeshInfo(PatchType_Simple, true));
+                MeshInfo &curMesh = meshesLocked.back();
+                curMesh.shader = s;
+                curMesh.shader.mapping = aiTextureMapping_SPHERE;
 
                 AI_NFF_PARSE_SHAPE_INFORMATION();
 
                 // we don't need scaling or translation here - we do it in the node's transform
-                StandardShapes::MakeTetrahedron(currentMesh.vertices);
-                currentMesh.faces.resize(currentMesh.vertices.size()/3,3);
+                StandardShapes::MakeTetrahedron(curMesh.vertices);
+                curMesh.faces.resize(curMesh.vertices.size() / 3, 3);
 
                 // generate a name for the mesh
-                ::ai_snprintf(currentMesh.name,128,"tetrahedron_%i",tetrahedron++);
+                ::ai_snprintf(curMesh.name, MeshInfo::MaxNameLen, "tetrahedron_%i", tetrahedron++);
             }
 
             // 'hex' - hexahedron
-            else if (TokenMatch(sz,"hex",3))
-            {
-                meshesLocked.push_back(MeshInfo(PatchType_Simple,true));
-                MeshInfo& currentMesh = meshesLocked.back();
-                currentMesh.shader = s;
-                currentMesh.shader.mapping = aiTextureMapping_BOX;
+            else if (TokenMatch(sz, "hex", 3)) {
+                meshesLocked.push_back(MeshInfo(PatchType_Simple, true));
+                MeshInfo &curMesh = meshesLocked.back();
+                curMesh.shader = s;
+                curMesh.shader.mapping = aiTextureMapping_BOX;
 
                 AI_NFF_PARSE_SHAPE_INFORMATION();
 
                 // we don't need scaling or translation here - we do it in the node's transform
-                StandardShapes::MakeHexahedron(currentMesh.vertices);
-                currentMesh.faces.resize(currentMesh.vertices.size()/3,3);
+                StandardShapes::MakeHexahedron(curMesh.vertices);
+                curMesh.faces.resize(curMesh.vertices.size() / 3, 3);
 
                 // generate a name for the mesh
-                ::ai_snprintf(currentMesh.name,128,"hexahedron_%i",hexahedron++);
+                ::ai_snprintf(curMesh.name, MeshInfo::MaxNameLen, "hexahedron_%i", hexahedron++);
             }
             // 'c' - cone
-            else if (TokenMatch(sz,"c",1))
-            {
-                meshesLocked.push_back(MeshInfo(PatchType_Simple,true));
-                MeshInfo& currentMesh = meshesLocked.back();
-                currentMesh.shader = s;
-                currentMesh.shader.mapping = aiTextureMapping_CYLINDER;
+            else if (TokenMatch(sz, "c", 1)) {
+                meshesLocked.push_back(MeshInfo(PatchType_Simple, true));
+                MeshInfo &curMesh = meshesLocked.back();
+                curMesh.shader = s;
+                curMesh.shader.mapping = aiTextureMapping_CYLINDER;
 
-                if(!GetNextLine(buffer,line))
-                {
+                if (!GetNextLine(buffer, line)) {
                     ASSIMP_LOG_ERROR("NFF: Unexpected end of file (cone definition not complete)");
                     break;
                 }
                 sz = line;
 
                 // read the two center points and the respective radii
-                aiVector3D center1, center2; float radius1, radius2;
+                aiVector3D center1, center2;
+                ai_real radius1 = 0.f, radius2 = 0.f;
                 AI_NFF_PARSE_TRIPLE(center1);
                 AI_NFF_PARSE_FLOAT(radius1);
 
-                if(!GetNextLine(buffer,line))
-                {
+                if (!GetNextLine(buffer, line)) {
                     ASSIMP_LOG_ERROR("NFF: Unexpected end of file (cone definition not complete)");
                     break;
                 }
@@ -964,164 +869,152 @@ void NFFImporter::InternReadFile( const std::string& pFile,
 
                 // compute the center point of the cone/cylinder -
                 // it is its local transformation origin
-                currentMesh.dir    =  center2-center1;
-                currentMesh.center =  center1+currentMesh.dir/(ai_real)2.0;
+                curMesh.dir = center2 - center1;
+                curMesh.center = center1 + curMesh.dir / (ai_real)2.0;
 
-                float f;
-                if (( f = currentMesh.dir.Length()) < 10e-3f )
-                {
+                ai_real f;
+                if ((f = curMesh.dir.Length()) < 10e-3f) {
                     ASSIMP_LOG_ERROR("NFF: Cone height is close to zero");
                     continue;
                 }
-                currentMesh.dir /= f; // normalize
+                curMesh.dir /= f; // normalize
 
                 // generate the cone - it consists of simple triangles
                 StandardShapes::MakeCone(f, radius1, radius2,
-                    integer_pow(4, iTesselation), currentMesh.vertices);
+                        integer_pow(4, iTesselation), curMesh.vertices);
 
                 // MakeCone() returns tris
-                currentMesh.faces.resize(currentMesh.vertices.size()/3,3);
+                curMesh.faces.resize(curMesh.vertices.size() / 3, 3);
 
                 // generate a name for the mesh. 'cone' if it a cone,
                 // 'cylinder' if it is a cylinder. Funny, isn't it?
-                if (radius1 != radius2)
-                    ::ai_snprintf(currentMesh.name,128,"cone_%i",cone++);
-                else ::ai_snprintf(currentMesh.name,128,"cylinder_%i",cylinder++);
+                if (radius1 != radius2) {
+                    ::ai_snprintf(curMesh.name, MeshInfo::MaxNameLen, "cone_%i", cone++);
+                } else {
+                    ::ai_snprintf(curMesh.name, MeshInfo::MaxNameLen, "cylinder_%i", cylinder++);
+                }
             }
             // 'tess' - tessellation
-            else if (TokenMatch(sz,"tess",4))
-            {
+            else if (TokenMatch(sz, "tess", 4)) {
                 SkipSpaces(&sz);
                 iTesselation = strtoul10(sz);
             }
             // 'from' - camera position
-            else if (TokenMatch(sz,"from",4))
-            {
+            else if (TokenMatch(sz, "from", 4)) {
                 AI_NFF_PARSE_TRIPLE(camPos);
                 hasCam = true;
             }
             // 'at' - camera look-at vector
-            else if (TokenMatch(sz,"at",2))
-            {
+            else if (TokenMatch(sz, "at", 2)) {
                 AI_NFF_PARSE_TRIPLE(camLookAt);
                 hasCam = true;
             }
             // 'up' - camera up vector
-            else if (TokenMatch(sz,"up",2))
-            {
+            else if (TokenMatch(sz, "up", 2)) {
                 AI_NFF_PARSE_TRIPLE(camUp);
                 hasCam = true;
             }
             // 'angle' - (half?) camera field of view
-            else if (TokenMatch(sz,"angle",5))
-            {
+            else if (TokenMatch(sz, "angle", 5)) {
                 AI_NFF_PARSE_FLOAT(angle);
                 hasCam = true;
             }
             // 'resolution' - used to compute the screen aspect
-            else if (TokenMatch(sz,"resolution",10))
-            {
+            else if (TokenMatch(sz, "resolution", 10)) {
                 AI_NFF_PARSE_FLOAT(resolution.x);
                 AI_NFF_PARSE_FLOAT(resolution.y);
                 hasCam = true;
             }
             // 'pb' - bezier patch. Not supported yet
-            else if (TokenMatch(sz,"pb",2))
-            {
+            else if (TokenMatch(sz, "pb", 2)) {
                 ASSIMP_LOG_ERROR("NFF: Encountered unsupported ID: bezier patch");
             }
             // 'pn' - NURBS. Not supported yet
-            else if (TokenMatch(sz,"pn",2) || TokenMatch(sz,"pnn",3))
-            {
+            else if (TokenMatch(sz, "pn", 2) || TokenMatch(sz, "pnn", 3)) {
                 ASSIMP_LOG_ERROR("NFF: Encountered unsupported ID: NURBS");
             }
             // '' - comment
-            else if ('#' == line[0])
-            {
-                const char* sz;SkipSpaces(&line[1],&sz);
-                if (!IsLineEnd(*sz)) {
-                    ASSIMP_LOG_INFO(sz);
+            else if ('#' == line[0]) {
+                const char *space;
+                SkipSpaces(&line[1], &space);
+                if (!IsLineEnd(*space)) {
+                    ASSIMP_LOG_INFO(space);
                 }
             }
         }
     }
 
     // copy all arrays into one large
-    meshes.reserve (meshes.size()+meshesLocked.size()+meshesWithNormals.size()+meshesWithUVCoords.size());
-    meshes.insert  (meshes.end(),meshesLocked.begin(),meshesLocked.end());
-    meshes.insert  (meshes.end(),meshesWithNormals.begin(),meshesWithNormals.end());
-    meshes.insert  (meshes.end(),meshesWithUVCoords.begin(),meshesWithUVCoords.end());
+    meshes.reserve(meshes.size() + meshesLocked.size() + meshesWithNormals.size() + meshesWithUVCoords.size());
+    meshes.insert(meshes.end(), meshesLocked.begin(), meshesLocked.end());
+    meshes.insert(meshes.end(), meshesWithNormals.begin(), meshesWithNormals.end());
+    meshes.insert(meshes.end(), meshesWithUVCoords.begin(), meshesWithUVCoords.end());
 
     // now generate output meshes. first find out how many meshes we'll need
     std::vector<MeshInfo>::const_iterator it = meshes.begin(), end = meshes.end();
-    for (;it != end;++it)
-    {
-        if (!(*it).faces.empty())
-        {
+    for (; it != end; ++it) {
+        if (!(*it).faces.empty()) {
             ++pScene->mNumMeshes;
-            if ((*it).name[0])++numNamed;
+            if ((*it).name[0]) ++numNamed;
         }
     }
 
     // generate a dummy root node - assign all unnamed elements such
     // as polygons and polygon patches to the root node and generate
     // sub nodes for named objects such as spheres and cones.
-    aiNode* const root = new aiNode();
+    aiNode *const root = new aiNode();
     root->mName.Set("<NFF_Root>");
-    root->mNumChildren = numNamed + (hasCam ? 1 : 0) + (unsigned int) lights.size();
-    root->mNumMeshes = pScene->mNumMeshes-numNamed;
+    root->mNumChildren = numNamed + (hasCam ? 1 : 0) + (unsigned int)lights.size();
+    root->mNumMeshes = pScene->mNumMeshes - numNamed;
 
-    aiNode** ppcChildren = NULL;
-    unsigned int* pMeshes = NULL;
+    aiNode **ppcChildren = nullptr;
+    unsigned int *pMeshes = nullptr;
     if (root->mNumMeshes)
         pMeshes = root->mMeshes = new unsigned int[root->mNumMeshes];
     if (root->mNumChildren)
-        ppcChildren = root->mChildren = new aiNode*[root->mNumChildren];
+        ppcChildren = root->mChildren = new aiNode *[root->mNumChildren];
 
     // generate the camera
-    if (hasCam)
-    {
+    if (hasCam) {
         ai_assert(ppcChildren);
-        aiNode* nd = new aiNode();
+        aiNode *nd = new aiNode();
         *ppcChildren = nd;
         nd->mName.Set("<NFF_Camera>");
         nd->mParent = root;
 
         // allocate the camera in the scene
         pScene->mNumCameras = 1;
-        pScene->mCameras = new aiCamera*[1];
-        aiCamera* c = pScene->mCameras[0] = new aiCamera;
+        pScene->mCameras = new aiCamera *[1];
+        aiCamera *c = pScene->mCameras[0] = new aiCamera;
 
         c->mName = nd->mName; // make sure the names are identical
-        c->mHorizontalFOV = AI_DEG_TO_RAD( angle );
-        c->mLookAt      = camLookAt - camPos;
-        c->mPosition    = camPos;
-        c->mUp          = camUp;
+        c->mHorizontalFOV = AI_DEG_TO_RAD(angle);
+        c->mLookAt = camLookAt - camPos;
+        c->mPosition = camPos;
+        c->mUp = camUp;
 
         // If the resolution is not specified in the file, we
         // need to set 1.0 as aspect.
-        c->mAspect      = (!resolution.y ? 0.f : resolution.x / resolution.y);
+        c->mAspect = (!resolution.y ? 0.f : resolution.x / resolution.y);
         ++ppcChildren;
     }
 
     // generate light sources
-    if (!lights.empty())
-    {
+    if (!lights.empty()) {
         ai_assert(ppcChildren);
         pScene->mNumLights = (unsigned int)lights.size();
-        pScene->mLights = new aiLight*[pScene->mNumLights];
-        for (unsigned int i = 0; i < pScene->mNumLights;++i,++ppcChildren)
-        {
-            const Light& l = lights[i];
+        pScene->mLights = new aiLight *[pScene->mNumLights];
+        for (unsigned int i = 0; i < pScene->mNumLights; ++i, ++ppcChildren) {
+            const Light &l = lights[i];
 
-            aiNode* nd = new aiNode();
+            aiNode *nd = new aiNode();
             *ppcChildren = nd;
             nd->mParent = root;
 
-            nd->mName.length = ::ai_snprintf(nd->mName.data,1024,"<NFF_Light%u>",i);
+            nd->mName.length = ::ai_snprintf(nd->mName.data, 1024, "<NFF_Light%u>", i);
 
             // allocate the light in the scene data structure
-            aiLight* out = pScene->mLights[i] = new aiLight();
+            aiLight *out = pScene->mLights[i] = new aiLight();
             out->mName = nd->mName; // make sure the names are identical
             out->mType = aiLightSource_POINT;
             out->mColorDiffuse = out->mColorSpecular = l.color * l.intensity;
@@ -1129,22 +1022,21 @@ void NFFImporter::InternReadFile( const std::string& pFile,
         }
     }
 
-    if (!pScene->mNumMeshes)throw DeadlyImportError("NFF: No meshes loaded");
-    pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];
-    pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials = pScene->mNumMeshes];
+    if (!pScene->mNumMeshes) throw DeadlyImportError("NFF: No meshes loaded");
+    pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
+    pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials = pScene->mNumMeshes];
     unsigned int m = 0;
-    for (it = meshes.begin(); it != end;++it)
-    {
-        if ((*it).faces.empty())continue;
+    for (it = meshes.begin(); it != end; ++it) {
+        if ((*it).faces.empty()) continue;
 
-        const MeshInfo& src = *it;
-        aiMesh* const mesh = pScene->mMeshes[m] = new aiMesh();
+        const MeshInfo &src = *it;
+        aiMesh *const mesh = pScene->mMeshes[m] = new aiMesh();
         mesh->mNumVertices = (unsigned int)src.vertices.size();
         mesh->mNumFaces = (unsigned int)src.faces.size();
 
         // Generate sub nodes for named meshes
-        if ( src.name[ 0 ] && NULL != ppcChildren  ) {
-            aiNode* const node = *ppcChildren = new aiNode();
+        if (src.name[0] && nullptr != ppcChildren) {
+            aiNode *const node = *ppcChildren = new aiNode();
             node->mParent = root;
             node->mNumMeshes = 1;
             node->mMeshes = new unsigned int[1];
@@ -1152,13 +1044,19 @@ void NFFImporter::InternReadFile( const std::string& pFile,
             node->mName.Set(src.name);
 
             // setup the transformation matrix of the node
-            aiMatrix4x4::FromToMatrix(aiVector3D(0.f,1.f,0.f),
-                src.dir,node->mTransformation);
+            aiMatrix4x4::FromToMatrix(aiVector3D(0.f, 1.f, 0.f),
+                    src.dir, node->mTransformation);
 
-            aiMatrix4x4& mat = node->mTransformation;
-            mat.a1 *= src.radius.x; mat.b1 *= src.radius.x; mat.c1 *= src.radius.x;
-            mat.a2 *= src.radius.y; mat.b2 *= src.radius.y; mat.c2 *= src.radius.y;
-            mat.a3 *= src.radius.z; mat.b3 *= src.radius.z; mat.c3 *= src.radius.z;
+            aiMatrix4x4 &mat = node->mTransformation;
+            mat.a1 *= src.radius.x;
+            mat.b1 *= src.radius.x;
+            mat.c1 *= src.radius.x;
+            mat.a2 *= src.radius.y;
+            mat.b2 *= src.radius.y;
+            mat.c2 *= src.radius.y;
+            mat.a3 *= src.radius.z;
+            mat.b3 *= src.radius.z;
+            mat.c3 *= src.radius.z;
             mat.a4 = src.center.x;
             mat.b4 = src.center.y;
             mat.c4 = src.center.z;
@@ -1170,107 +1068,99 @@ void NFFImporter::InternReadFile( const std::string& pFile,
 
         // copy vertex positions
         mesh->mVertices = new aiVector3D[mesh->mNumVertices];
-        ::memcpy(mesh->mVertices,&src.vertices[0],
-            sizeof(aiVector3D)*mesh->mNumVertices);
+        ::memcpy(mesh->mVertices, &src.vertices[0],
+                sizeof(aiVector3D) * mesh->mNumVertices);
 
         // NFF2: there could be vertex colors
-        if (!src.colors.empty())
-        {
+        if (!src.colors.empty()) {
             ai_assert(src.colors.size() == src.vertices.size());
 
             // copy vertex colors
             mesh->mColors[0] = new aiColor4D[mesh->mNumVertices];
-            ::memcpy(mesh->mColors[0],&src.colors[0],
-                sizeof(aiColor4D)*mesh->mNumVertices);
+            ::memcpy(mesh->mColors[0], &src.colors[0],
+                    sizeof(aiColor4D) * mesh->mNumVertices);
         }
 
-        if (!src.normals.empty())
-        {
+        if (!src.normals.empty()) {
             ai_assert(src.normals.size() == src.vertices.size());
 
             // copy normal vectors
             mesh->mNormals = new aiVector3D[mesh->mNumVertices];
-            ::memcpy(mesh->mNormals,&src.normals[0],
-                sizeof(aiVector3D)*mesh->mNumVertices);
+            ::memcpy(mesh->mNormals, &src.normals[0],
+                    sizeof(aiVector3D) * mesh->mNumVertices);
         }
 
-        if (!src.uvs.empty())
-        {
+        if (!src.uvs.empty()) {
             ai_assert(src.uvs.size() == src.vertices.size());
 
             // copy texture coordinates
             mesh->mTextureCoords[0] = new aiVector3D[mesh->mNumVertices];
-            ::memcpy(mesh->mTextureCoords[0],&src.uvs[0],
-                sizeof(aiVector3D)*mesh->mNumVertices);
+            ::memcpy(mesh->mTextureCoords[0], &src.uvs[0],
+                    sizeof(aiVector3D) * mesh->mNumVertices);
         }
 
         // generate faces
         unsigned int p = 0;
-        aiFace* pFace = mesh->mFaces = new aiFace[mesh->mNumFaces];
+        aiFace *pFace = mesh->mFaces = new aiFace[mesh->mNumFaces];
         for (std::vector<unsigned int>::const_iterator it2 = src.faces.begin(),
-            end2 = src.faces.end();
-            it2 != end2;++it2,++pFace)
-        {
-            pFace->mIndices = new unsigned int [ pFace->mNumIndices = *it2 ];
-            for (unsigned int o = 0; o < pFace->mNumIndices;++o)
+                                                       end2 = src.faces.end();
+                it2 != end2; ++it2, ++pFace) {
+            pFace->mIndices = new unsigned int[pFace->mNumIndices = *it2];
+            for (unsigned int o = 0; o < pFace->mNumIndices; ++o)
                 pFace->mIndices[o] = p++;
         }
 
         // generate a material for the mesh
-        aiMaterial* pcMat = (aiMaterial*)(pScene->mMaterials[m] = new aiMaterial());
+        aiMaterial *pcMat = (aiMaterial *)(pScene->mMaterials[m] = new aiMaterial());
 
         mesh->mMaterialIndex = m++;
 
-        aiString s;
-        s.Set(AI_DEFAULT_MATERIAL_NAME);
-        pcMat->AddProperty(&s, AI_MATKEY_NAME);
+        aiString matName;
+        matName.Set(AI_DEFAULT_MATERIAL_NAME);
+        pcMat->AddProperty(&matName, AI_MATKEY_NAME);
 
         // FIX: Ignore diffuse == 0
-        aiColor3D c = src.shader.color * (src.shader.diffuse.r ?  src.shader.diffuse : aiColor3D(1.f,1.f,1.f));
-        pcMat->AddProperty(&c,1,AI_MATKEY_COLOR_DIFFUSE);
+        aiColor3D c = src.shader.color * (src.shader.diffuse.r ? src.shader.diffuse : aiColor3D(1.f, 1.f, 1.f));
+        pcMat->AddProperty(&c, 1, AI_MATKEY_COLOR_DIFFUSE);
         c = src.shader.color * src.shader.specular;
-        pcMat->AddProperty(&c,1,AI_MATKEY_COLOR_SPECULAR);
+        pcMat->AddProperty(&c, 1, AI_MATKEY_COLOR_SPECULAR);
 
         // NFF2 - default values for NFF
-        pcMat->AddProperty(&src.shader.ambient, 1,AI_MATKEY_COLOR_AMBIENT);
-        pcMat->AddProperty(&src.shader.emissive,1,AI_MATKEY_COLOR_EMISSIVE);
-        pcMat->AddProperty(&src.shader.opacity, 1,AI_MATKEY_OPACITY);
+        pcMat->AddProperty(&src.shader.ambient, 1, AI_MATKEY_COLOR_AMBIENT);
+        pcMat->AddProperty(&src.shader.emissive, 1, AI_MATKEY_COLOR_EMISSIVE);
+        pcMat->AddProperty(&src.shader.opacity, 1, AI_MATKEY_OPACITY);
 
         // setup the first texture layer, if existing
-        if (src.shader.texFile.length())
-        {
-            s.Set(src.shader.texFile);
-            pcMat->AddProperty(&s,AI_MATKEY_TEXTURE_DIFFUSE(0));
+        if (src.shader.texFile.length()) {
+            matName.Set(src.shader.texFile);
+            pcMat->AddProperty(&matName, AI_MATKEY_TEXTURE_DIFFUSE(0));
 
             if (aiTextureMapping_UV != src.shader.mapping) {
 
-                aiVector3D v(0.f,-1.f,0.f);
-                pcMat->AddProperty(&v, 1,AI_MATKEY_TEXMAP_AXIS_DIFFUSE(0));
-                pcMat->AddProperty((int*)&src.shader.mapping, 1,AI_MATKEY_MAPPING_DIFFUSE(0));
+                aiVector3D v(0.f, -1.f, 0.f);
+                pcMat->AddProperty(&v, 1, AI_MATKEY_TEXMAP_AXIS_DIFFUSE(0));
+                pcMat->AddProperty((int *)&src.shader.mapping, 1, AI_MATKEY_MAPPING_DIFFUSE(0));
             }
         }
 
         // setup the name of the material
-        if (src.shader.name.length())
-        {
-            s.Set(src.shader.texFile);
-            pcMat->AddProperty(&s,AI_MATKEY_NAME);
+        if (src.shader.name.length()) {
+            matName.Set(src.shader.texFile);
+            pcMat->AddProperty(&matName, AI_MATKEY_NAME);
         }
 
         // setup some more material properties that are specific to NFF2
         int i;
-        if (src.shader.twoSided)
-        {
+        if (src.shader.twoSided) {
             i = 1;
-            pcMat->AddProperty(&i,1,AI_MATKEY_TWOSIDED);
+            pcMat->AddProperty(&i, 1, AI_MATKEY_TWOSIDED);
         }
         i = (src.shader.shaded ? aiShadingMode_Gouraud : aiShadingMode_NoShading);
-        if (src.shader.shininess)
-        {
+        if (src.shader.shininess) {
             i = aiShadingMode_Phong;
-            pcMat->AddProperty(&src.shader.shininess,1,AI_MATKEY_SHININESS);
+            pcMat->AddProperty(&src.shader.shininess, 1, AI_MATKEY_SHININESS);
         }
-        pcMat->AddProperty(&i,1,AI_MATKEY_SHADING_MODEL);
+        pcMat->AddProperty(&i, 1, AI_MATKEY_SHADING_MODEL);
     }
     pScene->mRootNode = root;
 }
diff --git a/Engine/lib/assimp/code/NFF/NFFLoader.h b/Engine/lib/assimp/code/AssetLib/NFF/NFFLoader.h
similarity index 68%
rename from Engine/lib/assimp/code/NFF/NFFLoader.h
rename to Engine/lib/assimp/code/AssetLib/NFF/NFFLoader.h
index bc4840e14..0fa615b19 100644
--- a/Engine/lib/assimp/code/NFF/NFFLoader.h
+++ b/Engine/lib/assimp/code/AssetLib/NFF/NFFLoader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -43,16 +43,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file NFFLoader.h
  *  @brief Declaration of the NFF importer class.
  */
+#pragma once
 #ifndef AI_NFFLOADER_H_INCLUDED
 #define AI_NFFLOADER_H_INCLUDED
 
 #include <assimp/BaseImporter.h>
-#include <assimp/types.h>
 #include <assimp/material.h>
+#include <assimp/types.h>
 #include <vector>
 
-
-namespace Assimp    {
+namespace Assimp {
 
 // ----------------------------------------------------------------------------------
 /** NFF (Neutral File Format) Importer class.
@@ -61,67 +61,56 @@ namespace Assimp    {
  * Both are quite different and the loading code is somewhat dirty at
  * the moment. Sense8 should be moved to a separate loader.
 */
-class NFFImporter : public BaseImporter
-{
+class NFFImporter : public BaseImporter {
 public:
     NFFImporter();
-    ~NFFImporter();
-
-
-public:
+    ~NFFImporter() override;
 
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
      * See BaseImporter::CanRead() for details.
      */
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
+            bool checkSig) const override;
 
 protected:
-
     // -------------------------------------------------------------------
     /** Return importer meta information.
      * See #BaseImporter::GetInfo for the details
      */
-    const aiImporterDesc* GetInfo () const;
+    const aiImporterDesc *GetInfo() const override;
 
     // -------------------------------------------------------------------
     /** Imports the given file into the given scene structure.
     * See BaseImporter::InternReadFile() for details
     */
-    void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
+    void InternReadFile(const std::string &pFile, aiScene *pScene,
+            IOSystem *pIOHandler) override;
 
 private:
-
-
     // describes face material properties
-    struct ShadingInfo
-    {
-        ShadingInfo()
-            : color     (0.6f,0.6f,0.6f)
-            , diffuse   (1.f,1.f,1.f)
-            , specular  (1.f,1.f,1.f)
-            , ambient   (0.f,0.f,0.f)
-            , emissive  (0.f,0.f,0.f)
-            , refracti  (1.f)
-            , twoSided  (false) // for NFF2
-            , shaded    (true)  // for NFF2
-            , opacity   (1.f)
-            , shininess (0.f)
-            , mapping   (aiTextureMapping_UV)
-        {}
+    struct ShadingInfo {
+        ShadingInfo() :
+                color(0.6f, 0.6f, 0.6f),
+                diffuse(1.f, 1.f, 1.f),
+                specular(1.f, 1.f, 1.f),
+                ambient(0.f, 0.f, 0.f),
+                emissive(0.f, 0.f, 0.f),
+                refracti(1.f),
+                twoSided(false), // for NFF2
+                shaded(true), // for NFF2
+                opacity(1.f),
+                shininess(0.f),
+                mapping(aiTextureMapping_UV) {
+            // empty
+        }
 
-        aiColor3D color,diffuse,specular,ambient,emissive;
-        float refracti;
-
-        std::string texFile;
-
-        // For NFF2
-        bool twoSided;
+        aiColor3D color, diffuse, specular, ambient, emissive;
+        ai_real refracti;
+        std::string texFile;        
+        bool twoSided; // For NFF2
         bool shaded;
-        float opacity, shininess;
-
+        ai_real opacity, shininess;
         std::string name;
 
         // texture mapping to be generated for the mesh - uv is the default
@@ -130,16 +119,15 @@ private:
         aiTextureMapping mapping;
 
         // shininess is ignored for the moment
-        bool operator == (const ShadingInfo& other) const
-        {
-            return color == other.color     &&
-                diffuse  == other.diffuse   &&
-                specular == other.specular  &&
-                ambient  == other.ambient   &&
-                refracti == other.refracti  &&
-                texFile  == other.texFile   &&
-                twoSided == other.twoSided  &&
-                shaded   == other.shaded;
+        bool operator == (const ShadingInfo &other) const {
+            return color == other.color &&
+                   diffuse == other.diffuse &&
+                   specular == other.specular &&
+                   ambient == other.ambient &&
+                   refracti == other.refracti &&
+                   texFile == other.texFile &&
+                   twoSided == other.twoSided &&
+                   shaded == other.shaded;
 
             // Some properties from NFF2 aren't compared by this operator.
             // Comparing MeshInfo::matIndex should do that.
@@ -147,35 +135,25 @@ private:
     };
 
     // describes a NFF light source
-    struct Light
-    {
-        Light()
-            : intensity (1.f)
-            , color     (1.f,1.f,1.f)
-        {}
+    struct Light {
+        Light() :
+                intensity(1.f), color(1.f, 1.f, 1.f) {}
 
         aiVector3D position;
-        float intensity;
+        ai_real intensity;
         aiColor3D color;
     };
 
-    enum PatchType
-    {
+    enum PatchType {
         PatchType_Simple = 0x0,
         PatchType_Normals = 0x1,
         PatchType_UVAndNormals = 0x2
     };
 
     // describes a NFF mesh
-    struct MeshInfo
-    {
-        MeshInfo(PatchType _pType, bool bL = false)
-            : pType     (_pType)
-            , bLocked   (bL)
-            , radius    (1.f,1.f,1.f)
-            , dir       (0.f,1.f,0.f)
-            , matIndex  (0)
-        {
+    struct MeshInfo {
+        MeshInfo(PatchType _pType, bool bL = false) :
+                pType(_pType), bLocked(bL), radius(1.f, 1.f, 1.f), dir(0.f, 1.f, 0.f), matIndex(0) {
             name[0] = '\0'; // by default meshes are unnamed
         }
 
@@ -185,18 +163,17 @@ private:
 
         // for spheres, cones and cylinders: center point of the object
         aiVector3D center, radius, dir;
-
-        char name[128];
+        static const size_t MaxNameLen = 128;
+        char name[MaxNameLen];
 
         std::vector<aiVector3D> vertices, normals, uvs;
         std::vector<unsigned int> faces;
 
         // for NFF2
-        std::vector<aiColor4D>  colors;
+        std::vector<aiColor4D> colors;
         unsigned int matIndex;
     };
 
-
     // -------------------------------------------------------------------
     /** Loads the material table for the NFF2 file format from an
      *  external file.
@@ -205,9 +182,8 @@ private:
      *  @param path Path to the file (abs. or rel.)
      *  @param pIOHandler IOSystem to be used to open the file
     */
-    void LoadNFF2MaterialTable(std::vector<ShadingInfo>& output,
-        const std::string& path, IOSystem* pIOHandler);
-
+    void LoadNFF2MaterialTable(std::vector<ShadingInfo> &output,
+            const std::string &path, IOSystem *pIOHandler);
 };
 
 } // end of namespace Assimp
diff --git a/Engine/lib/assimp/code/OFF/OFFLoader.cpp b/Engine/lib/assimp/code/AssetLib/OFF/OFFLoader.cpp
similarity index 94%
rename from Engine/lib/assimp/code/OFF/OFFLoader.cpp
rename to Engine/lib/assimp/code/AssetLib/OFF/OFFLoader.cpp
index afd44a539..640e79249 100644
--- a/Engine/lib/assimp/code/OFF/OFFLoader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/OFF/OFFLoader.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -85,19 +83,10 @@ OFFImporter::~OFFImporter()
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool OFFImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
+bool OFFImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/) const
 {
-    const std::string extension = GetExtension(pFile);
-
-    if (extension == "off")
-        return true;
-    else if (!extension.length() || checkSig)
-    {
-        if (!pIOHandler)return true;
-        const char* tokens[] = {"off"};
-        return SearchFileHeaderForToken(pIOHandler,pFile,tokens,1,3);
-    }
-    return false;
+    static const char* tokens[] = { "off" };
+    return SearchFileHeaderForToken(pIOHandler,pFile,tokens,AI_COUNT_OF(tokens),3);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -123,7 +112,7 @@ void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
 
     // Check whether we can read from the file
     if( file.get() == nullptr) {
-        throw DeadlyImportError( "Failed to open OFF file " + pFile + ".");
+        throw DeadlyImportError( "Failed to open OFF file ", pFile, ".");
     }
 
     // allocate storage and copy the contents of the file to a memory buffer
@@ -138,7 +127,7 @@ void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
     const char* car = buffer;
     const char* end = buffer + mBuffer2.size();
     NextToken(&car, end);
-    
+
     if (car < end - 2 && car[0] == 'S' && car[1] == 'T') {
       hasTexCoord = true; car += 2;
     }
@@ -164,7 +153,7 @@ void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
       dimensions = 3;
       hasHomogenous = false;
       NextToken(&car, end);
-      
+
       // at this point the next token should be an integer number
       if (car >= end - 1 || *car < '0' || *car > '9') {
 	throw DeadlyImportError("OFF: Header is invalid");
@@ -223,7 +212,7 @@ void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
             ASSIMP_LOG_ERROR("OFF: The number of verts in the header is incorrect");
             break;
         }
-        aiVector3D& v = mesh->mVertices[i];	
+        aiVector3D& v = mesh->mVertices[i];
         sz = line;
 
 	// helper array to write a for loop over possible dimension values
@@ -235,7 +224,7 @@ void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
 	    sz = fast_atoreal_move<ai_real>(sz, *vec[dim]);
 	}
 
-	// if has homogenous coordinate, divide others by this one
+	// if has homogeneous coordinate, divide others by this one
 	if (hasHomogenous) {
 	    SkipSpaces(&sz);
 	    ai_real w = 1.;
@@ -255,7 +244,7 @@ void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
 	    SkipSpaces(&sz);
 	    fast_atoreal_move<ai_real>(sz,(ai_real&)n.z);
 	}
-	
+
 	// reading colors is a pain because the specification says it can be
 	// integers or floats, and any number of them between 1 and 4 included,
 	// until the next comment or end of line
@@ -321,7 +310,7 @@ void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
         ++i;
         ++faces;
     }
-    
+
     // generate the output node graph
     pScene->mRootNode = new aiNode();
     pScene->mRootNode->mName.Set("<OFFRoot>");
diff --git a/Engine/lib/assimp/code/OFF/OFFLoader.h b/Engine/lib/assimp/code/AssetLib/OFF/OFFLoader.h
similarity index 86%
rename from Engine/lib/assimp/code/OFF/OFFLoader.h
rename to Engine/lib/assimp/code/AssetLib/OFF/OFFLoader.h
index 3fca77e1b..04bb7f481 100644
--- a/Engine/lib/assimp/code/OFF/OFFLoader.h
+++ b/Engine/lib/assimp/code/AssetLib/OFF/OFFLoader.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,6 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file  OFFLoader.h
  *  @brief Declaration of the OFF importer class.
  */
+#pragma once
 #ifndef AI_OFFLOADER_H_INCLUDED
 #define AI_OFFLOADER_H_INCLUDED
 
@@ -50,43 +50,35 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/types.h>
 #include <vector>
 
-namespace Assimp    {
+namespace Assimp {
 
 // ---------------------------------------------------------------------------
 /** Importer class for the Object File Format (.off)
 */
-class OFFImporter : public BaseImporter
-{
+class OFFImporter : public BaseImporter {
 public:
     OFFImporter();
-    ~OFFImporter();
-
-
-public:
+    ~OFFImporter() override;
 
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
     * See BaseImporter::CanRead() for details.  */
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
+            bool checkSig) const override;
 
 protected:
-
     // -------------------------------------------------------------------
     /** Return importer meta information.
      * See #BaseImporter::GetInfo for the details
      */
-    const aiImporterDesc* GetInfo () const;
+    const aiImporterDesc *GetInfo() const override;
 
     // -------------------------------------------------------------------
     /** Imports the given file into the given scene structure.
     * See BaseImporter::InternReadFile() for details
     */
-    void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
-
-private:
-
+    void InternReadFile(const std::string &pFile, aiScene *pScene,
+            IOSystem *pIOHandler) override;
 };
 
 } // end of namespace Assimp
diff --git a/Engine/lib/assimp/code/Ogre/OgreBinarySerializer.cpp b/Engine/lib/assimp/code/AssetLib/Ogre/OgreBinarySerializer.cpp
similarity index 66%
rename from Engine/lib/assimp/code/Ogre/OgreBinarySerializer.cpp
rename to Engine/lib/assimp/code/AssetLib/Ogre/OgreBinarySerializer.cpp
index 589e69c7e..738e1181e 100644
--- a/Engine/lib/assimp/code/Ogre/OgreBinarySerializer.cpp
+++ b/Engine/lib/assimp/code/AssetLib/Ogre/OgreBinarySerializer.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -41,124 +41,105 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "OgreBinarySerializer.h"
-#include "OgreXmlSerializer.h"
 #include "OgreParsingUtils.h"
+#include "OgreXmlSerializer.h"
 
 #include <assimp/TinyFormatter.h>
 #include <assimp/DefaultLogger.hpp>
 
-
 #ifndef ASSIMP_BUILD_NO_OGRE_IMPORTER
 
 // Define as 1 to get verbose logging.
 #define OGRE_BINARY_SERIALIZER_DEBUG 0
 
-namespace Assimp
-{
-namespace Ogre
-{
+namespace Assimp {
+namespace Ogre {
 
-const std::string       MESH_VERSION_1_8        = "[MeshSerializer_v1.8]";
-const std::string       SKELETON_VERSION_1_8    = "[Serializer_v1.80]";
-const std::string       SKELETON_VERSION_1_1    = "[Serializer_v1.10]";
+static constexpr auto MESH_VERSION_1_8 = "[MeshSerializer_v1.8]";
+static constexpr auto SKELETON_VERSION_1_8 = "[Serializer_v1.80]";
+static constexpr auto SKELETON_VERSION_1_1 = "[Serializer_v1.10]";
 
-const unsigned short    HEADER_CHUNK_ID         = 0x1000;
+const unsigned short HEADER_CHUNK_ID = 0x1000;
 
-const long              MSTREAM_OVERHEAD_SIZE               = sizeof(uint16_t) + sizeof(uint32_t);
-const long              MSTREAM_BONE_SIZE_WITHOUT_SCALE     = MSTREAM_OVERHEAD_SIZE + sizeof(unsigned short) + (sizeof(float) * 7);
-const long              MSTREAM_KEYFRAME_SIZE_WITHOUT_SCALE = MSTREAM_OVERHEAD_SIZE + (sizeof(float) * 8);
+const long MSTREAM_OVERHEAD_SIZE = sizeof(uint16_t) + sizeof(uint32_t);
+const long MSTREAM_BONE_SIZE_WITHOUT_SCALE = MSTREAM_OVERHEAD_SIZE + sizeof(unsigned short) + (sizeof(float) * 7);
+const long MSTREAM_KEYFRAME_SIZE_WITHOUT_SCALE = MSTREAM_OVERHEAD_SIZE + (sizeof(float) * 8);
 
-template<>
-inline bool OgreBinarySerializer::Read<bool>()
-{
+template <>
+inline bool OgreBinarySerializer::Read<bool>() {
     return (m_reader->GetU1() > 0);
 }
 
-template<>
-inline char OgreBinarySerializer::Read<char>()
-{
+template <>
+inline char OgreBinarySerializer::Read<char>() {
     return static_cast<char>(m_reader->GetU1());
 }
 
-template<>
-inline uint8_t OgreBinarySerializer::Read<uint8_t>()
-{
+template <>
+inline uint8_t OgreBinarySerializer::Read<uint8_t>() {
     return m_reader->GetU1();
 }
 
-template<>
-inline uint16_t OgreBinarySerializer::Read<uint16_t>()
-{
+template <>
+inline uint16_t OgreBinarySerializer::Read<uint16_t>() {
     return m_reader->GetU2();
 }
 
-template<>
-inline uint32_t OgreBinarySerializer::Read<uint32_t>()
-{
+template <>
+inline uint32_t OgreBinarySerializer::Read<uint32_t>() {
     return m_reader->GetU4();
 }
 
-template<>
-inline float OgreBinarySerializer::Read<float>()
-{
+template <>
+inline float OgreBinarySerializer::Read<float>() {
     return m_reader->GetF4();
 }
 
-void OgreBinarySerializer::ReadBytes(char *dest, size_t numBytes)
-{
-    ReadBytes(static_cast<void*>(dest), numBytes);
+void OgreBinarySerializer::ReadBytes(char *dest, size_t numBytes) {
+    ReadBytes(static_cast<void *>(dest), numBytes);
 }
 
-void OgreBinarySerializer::ReadBytes(uint8_t *dest, size_t numBytes)
-{
-    ReadBytes(static_cast<void*>(dest), numBytes);
+void OgreBinarySerializer::ReadBytes(uint8_t *dest, size_t numBytes) {
+    ReadBytes(static_cast<void *>(dest), numBytes);
 }
 
-void OgreBinarySerializer::ReadBytes(void *dest, size_t numBytes)
-{
+void OgreBinarySerializer::ReadBytes(void *dest, size_t numBytes) {
     m_reader->CopyAndAdvance(dest, numBytes);
 }
 
-uint8_t *OgreBinarySerializer::ReadBytes(size_t numBytes)
-{
+uint8_t *OgreBinarySerializer::ReadBytes(size_t numBytes) {
     uint8_t *bytes = new uint8_t[numBytes];
     ReadBytes(bytes, numBytes);
     return bytes;
 }
 
-void OgreBinarySerializer::ReadVector(aiVector3D &vec)
-{
-    m_reader->CopyAndAdvance(&vec.x, sizeof(float)*3);
+void OgreBinarySerializer::ReadVector(aiVector3D &vec) {
+    m_reader->CopyAndAdvance(&vec.x, sizeof(float) * 3);
 }
 
-void OgreBinarySerializer::ReadQuaternion(aiQuaternion &quat)
-{
+void OgreBinarySerializer::ReadQuaternion(aiQuaternion &quat) {
     float temp[4];
-    m_reader->CopyAndAdvance(temp, sizeof(float)*4);
+    m_reader->CopyAndAdvance(temp, sizeof(float) * 4);
     quat.x = temp[0];
     quat.y = temp[1];
     quat.z = temp[2];
     quat.w = temp[3];
 }
 
-bool OgreBinarySerializer::AtEnd() const
-{
+bool OgreBinarySerializer::AtEnd() const {
     return (m_reader->GetRemainingSize() == 0);
 }
 
-std::string OgreBinarySerializer::ReadString(size_t len)
-{
+std::string OgreBinarySerializer::ReadString(size_t len) {
     std::string str;
     str.resize(len);
     ReadBytes(&str[0], len);
     return str;
 }
 
-std::string OgreBinarySerializer::ReadLine()
-{
+std::string OgreBinarySerializer::ReadLine() {
     std::string str;
-    while(!AtEnd())
-    {
+    while (!AtEnd()) {
         char c = Read<char>();
         if (c == '\n')
             break;
@@ -167,32 +148,27 @@ std::string OgreBinarySerializer::ReadLine()
     return str;
 }
 
-uint16_t OgreBinarySerializer::ReadHeader(bool readLen)
-{
+uint16_t OgreBinarySerializer::ReadHeader(bool readLen) {
     uint16_t id = Read<uint16_t>();
     if (readLen)
         m_currentLen = Read<uint32_t>();
 
 #if (OGRE_BINARY_SERIALIZER_DEBUG == 1)
-    if (id != HEADER_CHUNK_ID)
-    {
-        ASSIMP_LOG_DEBUG(Formatter::format() << (assetMode == AM_Mesh
-            ? MeshHeaderToString(static_cast<MeshChunkId>(id)) : SkeletonHeaderToString(static_cast<SkeletonChunkId>(id))));
+    if (id != HEADER_CHUNK_ID) {
+        ASSIMP_LOG_DEBUG((assetMode == AM_Mesh ? MeshHeaderToString(static_cast<MeshChunkId>(id)) : SkeletonHeaderToString(static_cast<SkeletonChunkId>(id))));
     }
 #endif
 
     return id;
 }
 
-void OgreBinarySerializer::RollbackHeader()
-{
+void OgreBinarySerializer::RollbackHeader() {
     m_reader->IncPtr(-MSTREAM_OVERHEAD_SIZE);
 }
 
-void OgreBinarySerializer::SkipBytes(size_t numBytes)
-{
+void OgreBinarySerializer::SkipBytes(size_t numBytes) {
 #if (OGRE_BINARY_SERIALIZER_DEBUG == 1)
-    ASSIMP_LOG_DEBUG_F( "Skipping ", numBytes, " bytes");
+    ASSIMP_LOG_VERBOSE_DEBUG("Skipping ", numBytes, " bytes");
 #endif
 
     m_reader->IncPtr(numBytes);
@@ -200,31 +176,26 @@ void OgreBinarySerializer::SkipBytes(size_t numBytes)
 
 // Mesh
 
-Mesh *OgreBinarySerializer::ImportMesh(MemoryStreamReader *stream)
-{
+Mesh *OgreBinarySerializer::ImportMesh(MemoryStreamReader *stream) {
     OgreBinarySerializer serializer(stream, OgreBinarySerializer::AM_Mesh);
 
     uint16_t id = serializer.ReadHeader(false);
     if (id != HEADER_CHUNK_ID) {
-        throw DeadlyExportError("Invalid Ogre Mesh file header.");
+        throw DeadlyImportError("Invalid Ogre Mesh file header.");
     }
 
     /// @todo Check what we can actually support.
     std::string version = serializer.ReadLine();
-    if (version != MESH_VERSION_1_8)
-    {
-        throw DeadlyExportError(Formatter::format() << "Mesh version " << version << " not supported by this importer. Run OgreMeshUpgrader tool on the file and try again."
-            << " Supported versions: " << MESH_VERSION_1_8);
+    if (version != MESH_VERSION_1_8) {
+        throw DeadlyImportError("Mesh version ", version, " not supported by this importer. Run OgreMeshUpgrader tool on the file and try again.",
+                                                    " Supported versions: ", MESH_VERSION_1_8);
     }
 
     Mesh *mesh = new Mesh();
-    while (!serializer.AtEnd())
-    {
+    while (!serializer.AtEnd()) {
         id = serializer.ReadHeader();
-        switch(id)
-        {
-            case M_MESH:
-            {
+        switch (id) {
+            case M_MESH: {
                 serializer.ReadMesh(mesh);
                 break;
             }
@@ -233,84 +204,69 @@ Mesh *OgreBinarySerializer::ImportMesh(MemoryStreamReader *stream)
     return mesh;
 }
 
-void OgreBinarySerializer::ReadMesh(Mesh *mesh)
-{
+void OgreBinarySerializer::ReadMesh(Mesh *mesh) {
     mesh->hasSkeletalAnimations = Read<bool>();
 
-    ASSIMP_LOG_DEBUG("Reading Mesh");
-    ASSIMP_LOG_DEBUG_F( "  - Skeletal animations: ", mesh->hasSkeletalAnimations ? "true" : "false" );
+    ASSIMP_LOG_VERBOSE_DEBUG("Reading Mesh");
+    ASSIMP_LOG_VERBOSE_DEBUG("  - Skeletal animations: ", mesh->hasSkeletalAnimations ? "true" : "false");
 
-    if (!AtEnd())
-    {
+    if (!AtEnd()) {
         uint16_t id = ReadHeader();
         while (!AtEnd() &&
-            (id == M_GEOMETRY ||
-             id == M_SUBMESH ||
-             id == M_MESH_SKELETON_LINK ||
-             id == M_MESH_BONE_ASSIGNMENT ||
-             id == M_MESH_LOD ||
-             id == M_MESH_BOUNDS ||
-             id == M_SUBMESH_NAME_TABLE ||
-             id == M_EDGE_LISTS ||
-             id == M_POSES ||
-             id == M_ANIMATIONS ||
-             id == M_TABLE_EXTREMES))
-        {
-            switch(id)
-            {
-                case M_GEOMETRY:
-                {
+                (id == M_GEOMETRY ||
+                        id == M_SUBMESH ||
+                        id == M_MESH_SKELETON_LINK ||
+                        id == M_MESH_BONE_ASSIGNMENT ||
+                        id == M_MESH_LOD ||
+                        id == M_MESH_BOUNDS ||
+                        id == M_SUBMESH_NAME_TABLE ||
+                        id == M_EDGE_LISTS ||
+                        id == M_POSES ||
+                        id == M_ANIMATIONS ||
+                        id == M_TABLE_EXTREMES)) {
+            switch (id) {
+                case M_GEOMETRY: {
                     mesh->sharedVertexData = new VertexData();
                     ReadGeometry(mesh->sharedVertexData);
                     break;
                 }
-                case M_SUBMESH:
-                {
+                case M_SUBMESH: {
                     ReadSubMesh(mesh);
                     break;
                 }
-                case M_MESH_SKELETON_LINK:
-                {
+                case M_MESH_SKELETON_LINK: {
                     ReadMeshSkeletonLink(mesh);
                     break;
                 }
-                case M_MESH_BONE_ASSIGNMENT:
-                {
+                case M_MESH_BONE_ASSIGNMENT: {
                     ReadBoneAssignment(mesh->sharedVertexData);
                     break;
                 }
-                case M_MESH_LOD:
-                {
+                case M_MESH_LOD: {
                     ReadMeshLodInfo(mesh);
                     break;
                 }
-                case M_MESH_BOUNDS:
-                {
+                case M_MESH_BOUNDS: {
                     ReadMeshBounds(mesh);
                     break;
                 }
-                case M_SUBMESH_NAME_TABLE:
-                {
+                case M_SUBMESH_NAME_TABLE: {
                     ReadSubMeshNames(mesh);
                     break;
                 }
-                case M_EDGE_LISTS:
-                {
+                case M_EDGE_LISTS: {
                     ReadEdgeList(mesh);
                     break;
                 }
-                case M_POSES:
-                {
+                case M_POSES: {
                     ReadPoses(mesh);
                     break;
                 }
-                case M_ANIMATIONS:
-                {
+                case M_ANIMATIONS: {
                     ReadAnimations(mesh);
                     break;
                 }
-                case M_TABLE_EXTREMES:
-                {
+                case M_TABLE_EXTREMES: {
                     ReadMeshExtremes(mesh);
                     break;
                 }
@@ -326,8 +282,7 @@ void OgreBinarySerializer::ReadMesh(Mesh *mesh)
     NormalizeBoneWeights(mesh->sharedVertexData);
 }
 
-void OgreBinarySerializer::ReadMeshLodInfo(Mesh *mesh)
-{
+void OgreBinarySerializer::ReadMeshLodInfo(Mesh *mesh) {
     // Assimp does not acknowledge LOD levels as far as I can see it. This info is just skipped.
     // @todo Put this stuff to scene/mesh custom properties. If manual mesh the app can use the information.
     ReadLine(); // strategy name
@@ -335,8 +290,7 @@ void OgreBinarySerializer::ReadMeshLodInfo(Mesh *mesh)
     bool manual = Read<bool>();
 
     /// @note Main mesh is considered as LOD 0, start from index 1.
-    for (size_t i=1; i<numLods; ++i)
-    {
+    for (size_t i = 1; i < numLods; ++i) {
         uint16_t id = ReadHeader();
         if (id != M_MESH_LOD_USAGE) {
             throw DeadlyImportError("M_MESH_LOD does not contain a M_MESH_LOD_USAGE for each LOD level");
@@ -344,19 +298,15 @@ void OgreBinarySerializer::ReadMeshLodInfo(Mesh *mesh)
 
         m_reader->IncPtr(sizeof(float)); // user value
 
-        if (manual)
-        {
+        if (manual) {
             id = ReadHeader();
             if (id != M_MESH_LOD_MANUAL) {
                 throw DeadlyImportError("Manual M_MESH_LOD_USAGE does not contain M_MESH_LOD_MANUAL");
             }
 
             ReadLine(); // manual mesh name (ref to another mesh)
-        }
-        else
-        {
-            for(size_t si=0, silen=mesh->NumSubMeshes(); si<silen; ++si)
-            {
+        } else {
+            for (size_t si = 0, silen = mesh->NumSubMeshes(); si < silen; ++si) {
                 id = ReadHeader();
                 if (id != M_MESH_LOD_GENERATED) {
                     throw DeadlyImportError("Generated M_MESH_LOD_USAGE does not contain M_MESH_LOD_GENERATED");
@@ -365,8 +315,7 @@ void OgreBinarySerializer::ReadMeshLodInfo(Mesh *mesh)
                 uint32_t indexCount = Read<uint32_t>();
                 bool is32bit = Read<bool>();
 
-                if (indexCount > 0)
-                {
+                if (indexCount > 0) {
                     uint32_t len = indexCount * (is32bit ? sizeof(uint32_t) : sizeof(uint16_t));
                     m_reader->IncPtr(len);
                 }
@@ -375,27 +324,23 @@ void OgreBinarySerializer::ReadMeshLodInfo(Mesh *mesh)
     }
 }
 
-void OgreBinarySerializer::ReadMeshSkeletonLink(Mesh *mesh)
-{
+void OgreBinarySerializer::ReadMeshSkeletonLink(Mesh *mesh) {
     mesh->skeletonRef = ReadLine();
 }
 
-void OgreBinarySerializer::ReadMeshBounds(Mesh * /*mesh*/)
-{
+void OgreBinarySerializer::ReadMeshBounds(Mesh * /*mesh*/) {
     // Skip bounds, not compatible with Assimp.
     // 2x float vec3 + 1x float sphere radius
     SkipBytes(sizeof(float) * 7);
 }
 
-void OgreBinarySerializer::ReadMeshExtremes(Mesh * /*mesh*/)
-{
+void OgreBinarySerializer::ReadMeshExtremes(Mesh * /*mesh*/) {
     // Skip extremes, not compatible with Assimp.
     size_t numBytes = m_currentLen - MSTREAM_OVERHEAD_SIZE;
     SkipBytes(numBytes);
 }
 
-void OgreBinarySerializer::ReadBoneAssignment(VertexData *dest)
-{
+void OgreBinarySerializer::ReadBoneAssignment(VertexData *dest) {
     if (!dest) {
         throw DeadlyImportError("Cannot read bone assignments, vertex data is null.");
     }
@@ -408,8 +353,7 @@ void OgreBinarySerializer::ReadBoneAssignment(VertexData *dest)
     dest->boneAssignments.push_back(ba);
 }
 
-void OgreBinarySerializer::ReadSubMesh(Mesh *mesh)
-{
+void OgreBinarySerializer::ReadSubMesh(Mesh *mesh) {
     uint16_t id = 0;
 
     SubMesh *submesh = new SubMesh();
@@ -420,25 +364,23 @@ void OgreBinarySerializer::ReadSubMesh(Mesh *mesh)
     submesh->indexData->faceCount = static_cast<uint32_t>(submesh->indexData->count / 3);
     submesh->indexData->is32bit = Read<bool>();
 
-    ASSIMP_LOG_DEBUG_F( "Reading SubMesh ", mesh->subMeshes.size());
-    ASSIMP_LOG_DEBUG_F( "  - Material: '", submesh->materialRef, "'");
-    ASSIMP_LOG_DEBUG_F( "  - Uses shared geometry: ", submesh->usesSharedVertexData ? "true" : "false" );
+    ASSIMP_LOG_VERBOSE_DEBUG("Reading SubMesh ", mesh->subMeshes.size());
+    ASSIMP_LOG_VERBOSE_DEBUG("  - Material: '", submesh->materialRef, "'");
+    ASSIMP_LOG_VERBOSE_DEBUG("  - Uses shared geometry: ", submesh->usesSharedVertexData ? "true" : "false");
 
     // Index buffer
-    if (submesh->indexData->count > 0)
-    {
+    if (submesh->indexData->count > 0) {
         uint32_t numBytes = submesh->indexData->count * (submesh->indexData->is32bit ? sizeof(uint32_t) : sizeof(uint16_t));
         uint8_t *indexBuffer = ReadBytes(numBytes);
         submesh->indexData->buffer = MemoryStreamPtr(new Assimp::MemoryIOStream(indexBuffer, numBytes, true));
 
-        ASSIMP_LOG_DEBUG_F( "  - ", submesh->indexData->faceCount,
-            " faces from ", submesh->indexData->count, (submesh->indexData->is32bit ? " 32bit" : " 16bit"),
-            " indexes of ", numBytes, " bytes");
+        ASSIMP_LOG_VERBOSE_DEBUG("  - ", submesh->indexData->faceCount,
+                " faces from ", submesh->indexData->count, (submesh->indexData->is32bit ? " 32bit" : " 16bit"),
+                " indexes of ", numBytes, " bytes");
     }
 
     // Vertex buffer if not referencing the shared geometry
-    if (!submesh->usesSharedVertexData)
-    {
+    if (!submesh->usesSharedVertexData) {
         id = ReadHeader();
         if (id != M_GEOMETRY) {
             throw DeadlyImportError("M_SUBMESH does not contain M_GEOMETRY, but shader geometry is set to false");
@@ -449,28 +391,22 @@ void OgreBinarySerializer::ReadSubMesh(Mesh *mesh)
     }
 
     // Bone assignment, submesh operation and texture aliases
-    if (!AtEnd())
-    {
+    if (!AtEnd()) {
         id = ReadHeader();
         while (!AtEnd() &&
-            (id == M_SUBMESH_OPERATION ||
-             id == M_SUBMESH_BONE_ASSIGNMENT ||
-             id == M_SUBMESH_TEXTURE_ALIAS))
-        {
-            switch(id)
-            {
-                case M_SUBMESH_OPERATION:
-                {
+                (id == M_SUBMESH_OPERATION ||
+                        id == M_SUBMESH_BONE_ASSIGNMENT ||
+                        id == M_SUBMESH_TEXTURE_ALIAS)) {
+            switch (id) {
+                case M_SUBMESH_OPERATION: {
                     ReadSubMeshOperation(submesh);
                     break;
                 }
-                case M_SUBMESH_BONE_ASSIGNMENT:
-                {
+                case M_SUBMESH_BONE_ASSIGNMENT: {
                     ReadBoneAssignment(submesh->vertexData);
                     break;
                 }
-                case M_SUBMESH_TEXTURE_ALIAS:
-                {
+                case M_SUBMESH_TEXTURE_ALIAS: {
                     ReadSubMeshTextureAlias(submesh);
                     break;
                 }
@@ -489,13 +425,12 @@ void OgreBinarySerializer::ReadSubMesh(Mesh *mesh)
     mesh->subMeshes.push_back(submesh);
 }
 
-void OgreBinarySerializer::NormalizeBoneWeights(VertexData *vertexData) const
-{
+void OgreBinarySerializer::NormalizeBoneWeights(VertexData *vertexData) const {
     if (!vertexData || vertexData->boneAssignments.empty())
         return;
 
     std::set<uint32_t> influencedVertices;
-    for (VertexBoneAssignmentList::const_iterator baIter=vertexData->boneAssignments.begin(), baEnd=vertexData->boneAssignments.end(); baIter != baEnd; ++baIter) {
+    for (VertexBoneAssignmentList::const_iterator baIter = vertexData->boneAssignments.begin(), baEnd = vertexData->boneAssignments.end(); baIter != baEnd; ++baIter) {
         influencedVertices.insert(baIter->vertexIndex);
     }
 
@@ -503,18 +438,14 @@ void OgreBinarySerializer::NormalizeBoneWeights(VertexData *vertexData) const
         Some exporters won't care if the sum of all bone weights
         for a single vertex equals 1 or not, so validate here. */
     const float epsilon = 0.05f;
-    for (const uint32_t vertexIndex : influencedVertices)
-    {
+    for (const uint32_t vertexIndex : influencedVertices) {
         float sum = 0.0f;
-        for (VertexBoneAssignmentList::const_iterator baIter=vertexData->boneAssignments.begin(), baEnd=vertexData->boneAssignments.end(); baIter != baEnd; ++baIter)
-        {
+        for (VertexBoneAssignmentList::const_iterator baIter = vertexData->boneAssignments.begin(), baEnd = vertexData->boneAssignments.end(); baIter != baEnd; ++baIter) {
             if (baIter->vertexIndex == vertexIndex)
                 sum += baIter->weight;
         }
-        if ((sum < (1.0f - epsilon)) || (sum > (1.0f + epsilon)))
-        {
-            for (auto &boneAssign : vertexData->boneAssignments)
-            {
+        if ((sum < (1.0f - epsilon)) || (sum > (1.0f + epsilon))) {
+            for (auto &boneAssign : vertexData->boneAssignments) {
                 if (boneAssign.vertexIndex == vertexIndex)
                     boneAssign.weight /= sum;
             }
@@ -522,34 +453,29 @@ void OgreBinarySerializer::NormalizeBoneWeights(VertexData *vertexData) const
     }
 }
 
-void OgreBinarySerializer::ReadSubMeshOperation(SubMesh *submesh)
-{
+void OgreBinarySerializer::ReadSubMeshOperation(SubMesh *submesh) {
     submesh->operationType = static_cast<SubMesh::OperationType>(Read<uint16_t>());
 }
 
-void OgreBinarySerializer::ReadSubMeshTextureAlias(SubMesh *submesh)
-{
+void OgreBinarySerializer::ReadSubMeshTextureAlias(SubMesh *submesh) {
     submesh->textureAliasName = ReadLine();
     submesh->textureAliasRef = ReadLine();
 }
 
-void OgreBinarySerializer::ReadSubMeshNames(Mesh *mesh)
-{
+void OgreBinarySerializer::ReadSubMeshNames(Mesh *mesh) {
     uint16_t id = 0;
 
-    if (!AtEnd())
-    {
+    if (!AtEnd()) {
         id = ReadHeader();
-        while (!AtEnd() && id == M_SUBMESH_NAME_TABLE_ELEMENT)
-        {
+        while (!AtEnd() && id == M_SUBMESH_NAME_TABLE_ELEMENT) {
             uint16_t submeshIndex = Read<uint16_t>();
             SubMesh *submesh = mesh->GetSubMesh(submeshIndex);
             if (!submesh) {
-                throw DeadlyImportError(Formatter::format() << "Ogre Mesh does not include submesh " << submeshIndex << " referenced in M_SUBMESH_NAME_TABLE_ELEMENT. Invalid mesh file.");
+                throw DeadlyImportError("Ogre Mesh does not include submesh ", submeshIndex, " referenced in M_SUBMESH_NAME_TABLE_ELEMENT. Invalid mesh file.");
             }
 
             submesh->name = ReadLine();
-            ASSIMP_LOG_DEBUG_F( "  - SubMesh ", submesh->index, " name '", submesh->name, "'");
+            ASSIMP_LOG_VERBOSE_DEBUG("  - SubMesh ", submesh->index, " name '", submesh->name, "'");
 
             if (!AtEnd())
                 id = ReadHeader();
@@ -559,28 +485,22 @@ void OgreBinarySerializer::ReadSubMeshNames(Mesh *mesh)
     }
 }
 
-void OgreBinarySerializer::ReadGeometry(VertexData *dest)
-{
+void OgreBinarySerializer::ReadGeometry(VertexData *dest) {
     dest->count = Read<uint32_t>();
 
-    ASSIMP_LOG_DEBUG_F( "  - Reading geometry of ", dest->count, " vertices");
+    ASSIMP_LOG_VERBOSE_DEBUG("  - Reading geometry of ", dest->count, " vertices");
 
-    if (!AtEnd())
-    {
+    if (!AtEnd()) {
         uint16_t id = ReadHeader();
         while (!AtEnd() &&
-            (id == M_GEOMETRY_VERTEX_DECLARATION ||
-             id == M_GEOMETRY_VERTEX_BUFFER))
-        {
-            switch(id)
-            {
-                case M_GEOMETRY_VERTEX_DECLARATION:
-                {
+                (id == M_GEOMETRY_VERTEX_DECLARATION ||
+                        id == M_GEOMETRY_VERTEX_BUFFER)) {
+            switch (id) {
+                case M_GEOMETRY_VERTEX_DECLARATION: {
                     ReadGeometryVertexDeclaration(dest);
                     break;
                 }
-                case M_GEOMETRY_VERTEX_BUFFER:
-                {
+                case M_GEOMETRY_VERTEX_BUFFER: {
                     ReadGeometryVertexBuffer(dest);
                     break;
                 }
@@ -594,13 +514,10 @@ void OgreBinarySerializer::ReadGeometry(VertexData *dest)
     }
 }
 
-void OgreBinarySerializer::ReadGeometryVertexDeclaration(VertexData *dest)
-{
-    if (!AtEnd())
-    {
+void OgreBinarySerializer::ReadGeometryVertexDeclaration(VertexData *dest) {
+    if (!AtEnd()) {
         uint16_t id = ReadHeader();
-        while (!AtEnd() && id == M_GEOMETRY_VERTEX_ELEMENT)
-        {
+        while (!AtEnd() && id == M_GEOMETRY_VERTEX_ELEMENT) {
             ReadGeometryVertexElement(dest);
 
             if (!AtEnd())
@@ -611,8 +528,7 @@ void OgreBinarySerializer::ReadGeometryVertexDeclaration(VertexData *dest)
     }
 }
 
-void OgreBinarySerializer::ReadGeometryVertexElement(VertexData *dest)
-{
+void OgreBinarySerializer::ReadGeometryVertexElement(VertexData *dest) {
     VertexElement element;
     element.source = Read<uint16_t>();
     element.type = static_cast<VertexElement::Type>(Read<uint16_t>());
@@ -620,14 +536,13 @@ void OgreBinarySerializer::ReadGeometryVertexElement(VertexData *dest)
     element.offset = Read<uint16_t>();
     element.index = Read<uint16_t>();
 
-    ASSIMP_LOG_DEBUG_F( "    - Vertex element ", element.SemanticToString(), " of type ",
-        element.TypeToString(), " index=", element.index, " source=", element.source);
+    ASSIMP_LOG_VERBOSE_DEBUG("    - Vertex element ", element.SemanticToString(), " of type ",
+            element.TypeToString(), " index=", element.index, " source=", element.source);
 
     dest->vertexElements.push_back(element);
 }
 
-void OgreBinarySerializer::ReadGeometryVertexBuffer(VertexData *dest)
-{
+void OgreBinarySerializer::ReadGeometryVertexBuffer(VertexData *dest) {
     uint16_t bindIndex = Read<uint16_t>();
     uint16_t vertexSize = Read<uint16_t>();
 
@@ -642,23 +557,19 @@ void OgreBinarySerializer::ReadGeometryVertexBuffer(VertexData *dest)
     uint8_t *vertexBuffer = ReadBytes(numBytes);
     dest->vertexBindings[bindIndex] = MemoryStreamPtr(new Assimp::MemoryIOStream(vertexBuffer, numBytes, true));
 
-    ASSIMP_LOG_DEBUG_F( "    - Read vertex buffer for source ", bindIndex, " of ", numBytes, " bytes");
+    ASSIMP_LOG_VERBOSE_DEBUG("    - Read vertex buffer for source ", bindIndex, " of ", numBytes, " bytes");
 }
 
-void OgreBinarySerializer::ReadEdgeList(Mesh * /*mesh*/)
-{
+void OgreBinarySerializer::ReadEdgeList(Mesh * /*mesh*/) {
     // Assimp does not acknowledge LOD levels as far as I can see it. This info is just skipped.
 
-    if (!AtEnd())
-    {
+    if (!AtEnd()) {
         uint16_t id = ReadHeader();
-        while (!AtEnd() && id == M_EDGE_LIST_LOD)
-        {
+        while (!AtEnd() && id == M_EDGE_LIST_LOD) {
             m_reader->IncPtr(sizeof(uint16_t)); // lod index
             bool manual = Read<bool>();
 
-            if (!manual)
-            {
+            if (!manual) {
                 m_reader->IncPtr(sizeof(uint8_t));
                 uint32_t numTriangles = Read<uint32_t>();
                 uint32_t numEdgeGroups = Read<uint32_t>();
@@ -666,16 +577,14 @@ void OgreBinarySerializer::ReadEdgeList(Mesh * /*mesh*/)
                 size_t skipBytes = (sizeof(uint32_t) * 8 + sizeof(float) * 4) * numTriangles;
                 m_reader->IncPtr(skipBytes);
 
-                for (size_t i=0; i<numEdgeGroups; ++i)
-                {
-                    uint16_t id = ReadHeader();
-                    if (id != M_EDGE_GROUP)
+                for (size_t i = 0; i < numEdgeGroups; ++i) {
+                    uint16_t curId = ReadHeader();
+                    if (curId != M_EDGE_GROUP)
                         throw DeadlyImportError("M_EDGE_GROUP not found in M_EDGE_LIST_LOD");
 
                     m_reader->IncPtr(sizeof(uint32_t) * 3);
                     uint32_t numEdges = Read<uint32_t>();
-                    for (size_t j=0; j<numEdges; ++j)
-                    {
+                    for (size_t j = 0; j < numEdges; ++j) {
                         m_reader->IncPtr(sizeof(uint32_t) * 6 + sizeof(uint8_t));
                     }
                 }
@@ -689,13 +598,10 @@ void OgreBinarySerializer::ReadEdgeList(Mesh * /*mesh*/)
     }
 }
 
-void OgreBinarySerializer::ReadPoses(Mesh *mesh)
-{
-    if (!AtEnd())
-    {
+void OgreBinarySerializer::ReadPoses(Mesh *mesh) {
+    if (!AtEnd()) {
         uint16_t id = ReadHeader();
-        while (!AtEnd() && id == M_POSE)
-        {
+        while (!AtEnd() && id == M_POSE) {
             Pose *pose = new Pose();
             pose->name = ReadLine();
             pose->target = Read<uint16_t>();
@@ -713,13 +619,10 @@ void OgreBinarySerializer::ReadPoses(Mesh *mesh)
     }
 }
 
-void OgreBinarySerializer::ReadPoseVertices(Pose *pose)
-{
-    if (!AtEnd())
-    {
+void OgreBinarySerializer::ReadPoseVertices(Pose *pose) {
+    if (!AtEnd()) {
         uint16_t id = ReadHeader();
-        while (!AtEnd() && id == M_POSE_VERTEX)
-        {
+        while (!AtEnd() && id == M_POSE_VERTEX) {
             Pose::Vertex v;
             v.index = Read<uint32_t>();
             ReadVector(v.offset);
@@ -736,13 +639,10 @@ void OgreBinarySerializer::ReadPoseVertices(Pose *pose)
     }
 }
 
-void OgreBinarySerializer::ReadAnimations(Mesh *mesh)
-{
-    if (!AtEnd())
-    {
+void OgreBinarySerializer::ReadAnimations(Mesh *mesh) {
+    if (!AtEnd()) {
         uint16_t id = ReadHeader();
-        while (!AtEnd() && id == M_ANIMATION)
-        {
+        while (!AtEnd() && id == M_ANIMATION) {
             Animation *anim = new Animation(mesh);
             anim->name = ReadLine();
             anim->length = Read<float>();
@@ -759,13 +659,10 @@ void OgreBinarySerializer::ReadAnimations(Mesh *mesh)
     }
 }
 
-void OgreBinarySerializer::ReadAnimation(Animation *anim)
-{
-    if (!AtEnd())
-    {
+void OgreBinarySerializer::ReadAnimation(Animation *anim) {
+    if (!AtEnd()) {
         uint16_t id = ReadHeader();
-        if (id == M_ANIMATION_BASEINFO)
-        {
+        if (id == M_ANIMATION_BASEINFO) {
             anim->baseName = ReadLine();
             anim->baseTime = Read<float>();
 
@@ -773,8 +670,7 @@ void OgreBinarySerializer::ReadAnimation(Animation *anim)
             id = ReadHeader();
         }
 
-        while (!AtEnd() && id == M_ANIMATION_TRACK)
-        {
+        while (!AtEnd() && id == M_ANIMATION_TRACK) {
             VertexAnimationTrack track;
             track.type = static_cast<VertexAnimationTrack::Type>(Read<uint16_t>());
             track.target = Read<uint16_t>();
@@ -791,17 +687,13 @@ void OgreBinarySerializer::ReadAnimation(Animation *anim)
     }
 }
 
-void OgreBinarySerializer::ReadAnimationKeyFrames(Animation *anim, VertexAnimationTrack *track)
-{
-    if (!AtEnd())
-    {
+void OgreBinarySerializer::ReadAnimationKeyFrames(Animation *anim, VertexAnimationTrack *track) {
+    if (!AtEnd()) {
         uint16_t id = ReadHeader();
         while (!AtEnd() &&
-            (id == M_ANIMATION_MORPH_KEYFRAME ||
-             id == M_ANIMATION_POSE_KEYFRAME))
-        {
-            if (id == M_ANIMATION_MORPH_KEYFRAME)
-            {
+                (id == M_ANIMATION_MORPH_KEYFRAME ||
+                        id == M_ANIMATION_POSE_KEYFRAME)) {
+            if (id == M_ANIMATION_MORPH_KEYFRAME) {
                 MorphKeyFrame kf;
                 kf.timePos = Read<float>();
                 bool hasNormals = Read<bool>();
@@ -814,17 +706,13 @@ void OgreBinarySerializer::ReadAnimationKeyFrames(Animation *anim, VertexAnimati
                 kf.buffer = MemoryStreamPtr(new Assimp::MemoryIOStream(morphBuffer, numBytes, true));
 
                 track->morphKeyFrames.push_back(kf);
-            }
-            else if (id == M_ANIMATION_POSE_KEYFRAME)
-            {
+            } else if (id == M_ANIMATION_POSE_KEYFRAME) {
                 PoseKeyFrame kf;
                 kf.timePos = Read<float>();
 
-                if (!AtEnd())
-                {
+                if (!AtEnd()) {
                     id = ReadHeader();
-                    while (!AtEnd() && id == M_ANIMATION_POSE_REF)
-                    {
+                    while (!AtEnd() && id == M_ANIMATION_POSE_REF) {
                         PoseRef pr;
                         pr.index = Read<uint16_t>();
                         pr.influence = Read<float>();
@@ -850,22 +738,20 @@ void OgreBinarySerializer::ReadAnimationKeyFrames(Animation *anim, VertexAnimati
 
 // Skeleton
 
-bool OgreBinarySerializer::ImportSkeleton(Assimp::IOSystem *pIOHandler, Mesh *mesh)
-{
+bool OgreBinarySerializer::ImportSkeleton(Assimp::IOSystem *pIOHandler, Mesh *mesh) {
     if (!mesh || mesh->skeletonRef.empty())
         return false;
 
     // Highly unusual to see in read world cases but support
     // binary mesh referencing a XML skeleton file.
-    if (EndsWith(mesh->skeletonRef, ".skeleton.xml", false))
-    {
+    if (EndsWith(mesh->skeletonRef, ".skeleton.xml", false)) {
         OgreXmlSerializer::ImportSkeleton(pIOHandler, mesh);
         return false;
     }
 
     MemoryStreamReaderPtr reader = OpenReader(pIOHandler, mesh->skeletonRef);
     if (!reader)
-      return false;
+        return false;
 
     Skeleton *skeleton = new Skeleton();
     OgreBinarySerializer serializer(reader.get(), OgreBinarySerializer::AM_Skeleton);
@@ -874,8 +760,7 @@ bool OgreBinarySerializer::ImportSkeleton(Assimp::IOSystem *pIOHandler, Mesh *me
     return true;
 }
 
-bool OgreBinarySerializer::ImportSkeleton(Assimp::IOSystem *pIOHandler, MeshXml *mesh)
-{
+bool OgreBinarySerializer::ImportSkeleton(Assimp::IOSystem *pIOHandler, MeshXml *mesh) {
     if (!mesh || mesh->skeletonRef.empty())
         return false;
 
@@ -890,87 +775,73 @@ bool OgreBinarySerializer::ImportSkeleton(Assimp::IOSystem *pIOHandler, MeshXml
     return true;
 }
 
-MemoryStreamReaderPtr OgreBinarySerializer::OpenReader(Assimp::IOSystem *pIOHandler, const std::string &filename)
-{
-    if (!EndsWith(filename, ".skeleton", false))
-    {
-        ASSIMP_LOG_ERROR_F("Imported Mesh is referencing to unsupported '", filename, "' skeleton file.");
+MemoryStreamReaderPtr OgreBinarySerializer::OpenReader(Assimp::IOSystem *pIOHandler, const std::string &filename) {
+    if (!EndsWith(filename, ".skeleton", false)) {
+        ASSIMP_LOG_ERROR("Imported Mesh is referencing to unsupported '", filename, "' skeleton file.");
         return MemoryStreamReaderPtr();
     }
 
-    if (!pIOHandler->Exists(filename))
-    {
-        ASSIMP_LOG_ERROR_F("Failed to find skeleton file '", filename, "' that is referenced by imported Mesh.");
+    if (!pIOHandler->Exists(filename)) {
+        ASSIMP_LOG_ERROR("Failed to find skeleton file '", filename, "' that is referenced by imported Mesh.");
         return MemoryStreamReaderPtr();
     }
 
     IOStream *f = pIOHandler->Open(filename, "rb");
     if (!f) {
-        throw DeadlyImportError("Failed to open skeleton file " + filename);
+        throw DeadlyImportError("Failed to open skeleton file ", filename);
     }
 
     return MemoryStreamReaderPtr(new MemoryStreamReader(f));
 }
 
-void OgreBinarySerializer::ReadSkeleton(Skeleton *skeleton)
-{
+void OgreBinarySerializer::ReadSkeleton(Skeleton *skeleton) {
     uint16_t id = ReadHeader(false);
     if (id != HEADER_CHUNK_ID) {
-        throw DeadlyExportError("Invalid Ogre Skeleton file header.");
+        throw DeadlyImportError("Invalid Ogre Skeleton file header.");
     }
 
     // This deserialization supports both versions of the skeleton spec
     std::string version = ReadLine();
-    if (version != SKELETON_VERSION_1_8 && version != SKELETON_VERSION_1_1)
-    {
-        throw DeadlyExportError(Formatter::format() << "Skeleton version " << version << " not supported by this importer."
-            << " Supported versions: " << SKELETON_VERSION_1_8 << " and " << SKELETON_VERSION_1_1);
+    if (version != SKELETON_VERSION_1_8 && version != SKELETON_VERSION_1_1) {
+        throw DeadlyImportError("Skeleton version ", version, " not supported by this importer.",
+                                                    " Supported versions: ", SKELETON_VERSION_1_8, " and ", SKELETON_VERSION_1_1);
     }
 
-    ASSIMP_LOG_DEBUG("Reading Skeleton");
+    ASSIMP_LOG_VERBOSE_DEBUG("Reading Skeleton");
 
     bool firstBone = true;
     bool firstAnim = true;
 
-    while (!AtEnd())
-    {
+    while (!AtEnd()) {
         id = ReadHeader();
-        switch(id)
-        {
-            case SKELETON_BLENDMODE:
-            {
+        switch (id) {
+            case SKELETON_BLENDMODE: {
                 skeleton->blendMode = static_cast<Skeleton::BlendMode>(Read<uint16_t>());
                 break;
             }
-            case SKELETON_BONE:
-            {
-                if (firstBone)
-                {
-                    ASSIMP_LOG_DEBUG("  - Bones");
+            case SKELETON_BONE: {
+                if (firstBone) {
+                    ASSIMP_LOG_VERBOSE_DEBUG("  - Bones");
                     firstBone = false;
                 }
 
                 ReadBone(skeleton);
                 break;
             }
-            case SKELETON_BONE_PARENT:
-            {
+            case SKELETON_BONE_PARENT: {
                 ReadBoneParent(skeleton);
                 break;
             }
-            case SKELETON_ANIMATION:
-            {
-                if (firstAnim)
-                {
-                    ASSIMP_LOG_DEBUG("  - Animations");
+            case SKELETON_ANIMATION: {
+                if (firstAnim) {
+                    ASSIMP_LOG_VERBOSE_DEBUG("  - Animations");
                     firstAnim = false;
                 }
 
                 ReadSkeletonAnimation(skeleton);
                 break;
             }
-            case SKELETON_ANIMATION_LINK:
-            {
+            case SKELETON_ANIMATION_LINK: {
                 ReadSkeletonAnimationLink(skeleton);
                 break;
             }
@@ -978,16 +849,14 @@ void OgreBinarySerializer::ReadSkeleton(Skeleton *skeleton)
     }
 
     // Calculate bone matrices for root bones. Recursively calculates their children.
-    for (size_t i=0, len=skeleton->bones.size(); i<len; ++i)
-    {
+    for (size_t i = 0, len = skeleton->bones.size(); i < len; ++i) {
         Bone *bone = skeleton->bones[i];
         if (!bone->IsParented())
             bone->CalculateWorldMatrixAndDefaultPose(skeleton);
     }
 }
 
-void OgreBinarySerializer::ReadBone(Skeleton *skeleton)
-{
+void OgreBinarySerializer::ReadBone(Skeleton *skeleton) {
     Bone *bone = new Bone();
     bone->name = ReadLine();
     bone->id = Read<uint16_t>();
@@ -1002,16 +871,15 @@ void OgreBinarySerializer::ReadBone(Skeleton *skeleton)
 
     // Bone indexes need to start from 0 and be contiguous
     if (bone->id != skeleton->bones.size()) {
-        throw DeadlyImportError(Formatter::format() << "Ogre Skeleton bone indexes not contiguous. Error at bone index " << bone->id);
+        throw DeadlyImportError("Ogre Skeleton bone indexes not contiguous. Error at bone index ", bone->id);
     }
 
-    ASSIMP_LOG_DEBUG_F( "    ", bone->id, " ", bone->name);
+    ASSIMP_LOG_VERBOSE_DEBUG("    ", bone->id, " ", bone->name);
 
     skeleton->bones.push_back(bone);
 }
 
-void OgreBinarySerializer::ReadBoneParent(Skeleton *skeleton)
-{
+void OgreBinarySerializer::ReadBoneParent(Skeleton *skeleton) {
     uint16_t childId = Read<uint16_t>();
     uint16_t parentId = Read<uint16_t>();
 
@@ -1021,20 +889,17 @@ void OgreBinarySerializer::ReadBoneParent(Skeleton *skeleton)
     if (child && parent)
         parent->AddChild(child);
     else
-        throw DeadlyImportError(Formatter::format() << "Failed to find bones for parenting: Child id " << childId << " for parent id " << parentId);
+        throw DeadlyImportError("Failed to find bones for parenting: Child id ", childId, " for parent id ", parentId);
 }
 
-void OgreBinarySerializer::ReadSkeletonAnimation(Skeleton *skeleton)
-{
+void OgreBinarySerializer::ReadSkeletonAnimation(Skeleton *skeleton) {
     Animation *anim = new Animation(skeleton);
     anim->name = ReadLine();
     anim->length = Read<float>();
 
-    if (!AtEnd())
-    {
+    if (!AtEnd()) {
         uint16_t id = ReadHeader();
-        if (id == SKELETON_ANIMATION_BASEINFO)
-        {
+        if (id == SKELETON_ANIMATION_BASEINFO) {
             anim->baseName = ReadLine();
             anim->baseTime = Read<float>();
 
@@ -1042,8 +907,7 @@ void OgreBinarySerializer::ReadSkeletonAnimation(Skeleton *skeleton)
             id = ReadHeader();
         }
 
-        while (!AtEnd() && id == SKELETON_ANIMATION_TRACK)
-        {
+        while (!AtEnd() && id == SKELETON_ANIMATION_TRACK) {
             ReadSkeletonAnimationTrack(skeleton, anim);
 
             if (!AtEnd())
@@ -1055,15 +919,14 @@ void OgreBinarySerializer::ReadSkeletonAnimation(Skeleton *skeleton)
 
     skeleton->animations.push_back(anim);
 
-    ASSIMP_LOG_DEBUG_F( "    ", anim->name, " (", anim->length, " sec, ", anim->tracks.size(), " tracks)");
+    ASSIMP_LOG_VERBOSE_DEBUG("    ", anim->name, " (", anim->length, " sec, ", anim->tracks.size(), " tracks)");
 }
 
-void OgreBinarySerializer::ReadSkeletonAnimationTrack(Skeleton * /*skeleton*/, Animation *dest)
-{
+void OgreBinarySerializer::ReadSkeletonAnimationTrack(Skeleton * /*skeleton*/, Animation *dest) {
     uint16_t boneId = Read<uint16_t>();
     Bone *bone = dest->parentSkeleton->BoneById(boneId);
     if (!bone) {
-        throw DeadlyImportError(Formatter::format() << "Cannot read animation track, target bone " << boneId << " not in target Skeleton");
+        throw DeadlyImportError("Cannot read animation track, target bone ", boneId, " not in target Skeleton");
     }
 
     VertexAnimationTrack track;
@@ -1071,8 +934,7 @@ void OgreBinarySerializer::ReadSkeletonAnimationTrack(Skeleton * /*skeleton*/, A
     track.boneName = bone->name;
 
     uint16_t id = ReadHeader();
-    while (!AtEnd() && id == SKELETON_ANIMATION_TRACK_KEYFRAME)
-    {
+    while (!AtEnd() && id == SKELETON_ANIMATION_TRACK_KEYFRAME) {
         ReadSkeletonAnimationKeyFrame(&track);
 
         if (!AtEnd())
@@ -1084,8 +946,7 @@ void OgreBinarySerializer::ReadSkeletonAnimationTrack(Skeleton * /*skeleton*/, A
     dest->tracks.push_back(track);
 }
 
-void OgreBinarySerializer::ReadSkeletonAnimationKeyFrame(VertexAnimationTrack *dest)
-{
+void OgreBinarySerializer::ReadSkeletonAnimationKeyFrame(VertexAnimationTrack *dest) {
     TransformKeyFrame keyframe;
     keyframe.timePos = Read<float>();
 
@@ -1100,14 +961,13 @@ void OgreBinarySerializer::ReadSkeletonAnimationKeyFrame(VertexAnimationTrack *d
     dest->transformKeyFrames.push_back(keyframe);
 }
 
-void OgreBinarySerializer::ReadSkeletonAnimationLink(Skeleton * /*skeleton*/)
-{
+void OgreBinarySerializer::ReadSkeletonAnimationLink(Skeleton * /*skeleton*/) {
     // Skip bounds, not compatible with Assimp.
     ReadLine(); // skeleton name
     SkipBytes(sizeof(float) * 3); // scale
 }
 
-} // Ogre
-} // Assimp
+} // namespace Ogre
+} // namespace Assimp
 
 #endif // ASSIMP_BUILD_NO_OGRE_IMPORTER
diff --git a/Engine/lib/assimp/code/AssetLib/Ogre/OgreBinarySerializer.h b/Engine/lib/assimp/code/AssetLib/Ogre/OgreBinarySerializer.h
new file mode 100644
index 000000000..eb026ea70
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Ogre/OgreBinarySerializer.h
@@ -0,0 +1,415 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#ifndef AI_OGREBINARYSERIALIZER_H_INC
+#define AI_OGREBINARYSERIALIZER_H_INC
+
+#ifndef ASSIMP_BUILD_NO_OGRE_IMPORTER
+
+#include "OgreStructs.h"
+#include <assimp/StreamReader.h>
+
+namespace Assimp {
+namespace Ogre {
+
+typedef Assimp::StreamReaderLE MemoryStreamReader;
+typedef std::shared_ptr<MemoryStreamReader> MemoryStreamReaderPtr;
+
+class OgreBinarySerializer {
+public:
+    /// Imports mesh and returns the result.
+    /** @note Fatal unrecoverable errors will throw a DeadlyImportError. */
+    static Mesh *ImportMesh(MemoryStreamReader *reader);
+
+    /// Imports skeleton to @c mesh into Mesh::skeleton.
+    /** If mesh does not have a skeleton reference or the skeleton file
+        cannot be found it is not a fatal DeadlyImportError.
+        @return If skeleton import was successful. */
+    static bool ImportSkeleton(Assimp::IOSystem *pIOHandler, Mesh *mesh);
+    static bool ImportSkeleton(Assimp::IOSystem *pIOHandler, MeshXml *mesh);
+
+private:
+    enum AssetMode {
+        AM_Mesh,
+        AM_Skeleton
+    };
+
+    OgreBinarySerializer(MemoryStreamReader *reader, AssetMode mode) :
+            m_currentLen(0),
+            m_reader(reader),
+            assetMode(mode) {
+    }
+
+    static MemoryStreamReaderPtr OpenReader(Assimp::IOSystem *pIOHandler, const std::string &filename);
+
+    // Header
+
+    uint16_t ReadHeader(bool readLen = true);
+    void RollbackHeader();
+
+    // Mesh
+
+    void ReadMesh(Mesh *mesh);
+    void ReadMeshLodInfo(Mesh *mesh);
+    void ReadMeshSkeletonLink(Mesh *mesh);
+    void ReadMeshBounds(Mesh *mesh);
+    void ReadMeshExtremes(Mesh *mesh);
+
+    void ReadSubMesh(Mesh *mesh);
+    void ReadSubMeshNames(Mesh *mesh);
+    void ReadSubMeshOperation(SubMesh *submesh);
+    void ReadSubMeshTextureAlias(SubMesh *submesh);
+
+    void ReadBoneAssignment(VertexData *dest);
+
+    void ReadGeometry(VertexData *dest);
+    void ReadGeometryVertexDeclaration(VertexData *dest);
+    void ReadGeometryVertexElement(VertexData *dest);
+    void ReadGeometryVertexBuffer(VertexData *dest);
+
+    void ReadEdgeList(Mesh *mesh);
+    void ReadPoses(Mesh *mesh);
+    void ReadPoseVertices(Pose *pose);
+
+    void ReadAnimations(Mesh *mesh);
+    void ReadAnimation(Animation *anim);
+    void ReadAnimationKeyFrames(Animation *anim, VertexAnimationTrack *track);
+
+    void NormalizeBoneWeights(VertexData *vertexData) const;
+
+    // Skeleton
+
+    void ReadSkeleton(Skeleton *skeleton);
+
+    void ReadBone(Skeleton *skeleton);
+    void ReadBoneParent(Skeleton *skeleton);
+
+    void ReadSkeletonAnimation(Skeleton *skeleton);
+    void ReadSkeletonAnimationTrack(Skeleton *skeleton, Animation *dest);
+    void ReadSkeletonAnimationKeyFrame(VertexAnimationTrack *dest);
+    void ReadSkeletonAnimationLink(Skeleton *skeleton);
+
+    // Reader utils
+    bool AtEnd() const;
+
+    template <typename T>
+    inline T Read();
+
+    void ReadBytes(char *dest, size_t numBytes);
+    void ReadBytes(uint8_t *dest, size_t numBytes);
+    void ReadBytes(void *dest, size_t numBytes);
+    uint8_t *ReadBytes(size_t numBytes);
+
+    void ReadVector(aiVector3D &vec);
+    void ReadQuaternion(aiQuaternion &quat);
+
+    std::string ReadString(size_t len);
+    std::string ReadLine();
+
+    void SkipBytes(size_t numBytes);
+
+    uint32_t m_currentLen;
+    MemoryStreamReader *m_reader;
+
+    AssetMode assetMode;
+};
+
+enum MeshChunkId {
+    M_HEADER = 0x1000,
+    // char*          version          : Version number check
+    M_MESH = 0x3000,
+    // bool skeletallyAnimated   // important flag which affects h/w buffer policies
+    // Optional M_GEOMETRY chunk
+    M_SUBMESH = 0x4000,
+    // char* materialName
+    // bool useSharedVertices
+    // unsigned int indexCount
+    // bool indexes32Bit
+    // unsigned int* faceVertexIndices (indexCount)
+    // OR
+    // unsigned short* faceVertexIndices (indexCount)
+    // M_GEOMETRY chunk (Optional: present only if useSharedVertices = false)
+    M_SUBMESH_OPERATION = 0x4010, // optional, trilist assumed if missing
+    // unsigned short operationType
+    M_SUBMESH_BONE_ASSIGNMENT = 0x4100,
+    // Optional bone weights (repeating section)
+    // unsigned int vertexIndex;
+    // unsigned short boneIndex;
+    // float weight;
+    // Optional chunk that matches a texture name to an alias
+    // a texture alias is sent to the submesh material to use this texture name
+    // instead of the one in the texture unit with a matching alias name
+    M_SUBMESH_TEXTURE_ALIAS = 0x4200, // Repeating section
+    // char* aliasName;
+    // char* textureName;
+
+    M_GEOMETRY = 0x5000, // NB this chunk is embedded within M_MESH and M_SUBMESH
+    // unsigned int vertexCount
+    M_GEOMETRY_VERTEX_DECLARATION = 0x5100,
+    M_GEOMETRY_VERTEX_ELEMENT = 0x5110, // Repeating section
+    // unsigned short source;   // buffer bind source
+    // unsigned short type;     // VertexElementType
+    // unsigned short semantic; // VertexElementSemantic
+    // unsigned short offset;   // start offset in buffer in bytes
+    // unsigned short index;    // index of the semantic (for colours and texture coords)
+    M_GEOMETRY_VERTEX_BUFFER = 0x5200, // Repeating section
+    // unsigned short bindIndex;    // Index to bind this buffer to
+    // unsigned short vertexSize;   // Per-vertex size, must agree with declaration at this index
+    M_GEOMETRY_VERTEX_BUFFER_DATA = 0x5210,
+    // raw buffer data
+    M_MESH_SKELETON_LINK = 0x6000,
+    // Optional link to skeleton
+    // char* skeletonName          : name of .skeleton to use
+    M_MESH_BONE_ASSIGNMENT = 0x7000,
+    // Optional bone weights (repeating section)
+    // unsigned int vertexIndex;
+    // unsigned short boneIndex;
+    // float weight;
+    M_MESH_LOD = 0x8000,
+    // Optional LOD information
+    // string strategyName;
+    // unsigned short numLevels;
+    // bool manual;  (true for manual alternate meshes, false for generated)
+    M_MESH_LOD_USAGE = 0x8100,
+    // Repeating section, ordered in increasing depth
+    // NB LOD 0 (full detail from 0 depth) is omitted
+    // LOD value - this is a distance, a pixel count etc, based on strategy
+    // float lodValue;
+    M_MESH_LOD_MANUAL = 0x8110,
+    // Required if M_MESH_LOD section manual = true
+    // String manualMeshName;
+    M_MESH_LOD_GENERATED = 0x8120,
+    // Required if M_MESH_LOD section manual = false
+    // Repeating section (1 per submesh)
+    // unsigned int indexCount;
+    // bool indexes32Bit
+    // unsigned short* faceIndexes;  (indexCount)
+    // OR
+    // unsigned int* faceIndexes;  (indexCount)
+    M_MESH_BOUNDS = 0x9000,
+    // float minx, miny, minz
+    // float maxx, maxy, maxz
+    // float radius
+
+    // Added By DrEvil
+    // optional chunk that contains a table of submesh indexes and the names of
+    // the sub-meshes.
+    M_SUBMESH_NAME_TABLE = 0xA000,
+    // Subchunks of the name table. Each chunk contains an index & string
+    M_SUBMESH_NAME_TABLE_ELEMENT = 0xA100,
+    // short index
+    // char* name
+    // Optional chunk which stores precomputed edge data
+    M_EDGE_LISTS = 0xB000,
+    // Each LOD has a separate edge list
+    M_EDGE_LIST_LOD = 0xB100,
+    // unsigned short lodIndex
+    // bool isManual            // If manual, no edge data here, loaded from manual mesh
+    // bool isClosed
+    // unsigned long numTriangles
+    // unsigned long numEdgeGroups
+    // Triangle* triangleList
+    // unsigned long indexSet
+    // unsigned long vertexSet
+    // unsigned long vertIndex[3]
+    // unsigned long sharedVertIndex[3]
+    // float normal[4]
+
+    M_EDGE_GROUP = 0xB110,
+    // unsigned long vertexSet
+    // unsigned long triStart
+    // unsigned long triCount
+    // unsigned long numEdges
+    // Edge* edgeList
+    // unsigned long  triIndex[2]
+    // unsigned long  vertIndex[2]
+    // unsigned long  sharedVertIndex[2]
+    // bool degenerate
+    // Optional poses section, referred to by pose keyframes
+    M_POSES = 0xC000,
+    M_POSE = 0xC100,
+    // char* name (may be blank)
+    // unsigned short target    // 0 for shared geometry,
+    // 1+ for submesh index + 1
+    // bool includesNormals [1.8+]
+    M_POSE_VERTEX = 0xC111,
+    // unsigned long vertexIndex
+    // float xoffset, yoffset, zoffset
+    // float xnormal, ynormal, znormal (optional, 1.8+)
+    // Optional vertex animation chunk
+    M_ANIMATIONS = 0xD000,
+    M_ANIMATION = 0xD100,
+    // char* name
+    // float length
+    M_ANIMATION_BASEINFO = 0xD105,
+    // [Optional] base keyframe information (pose animation only)
+    // char* baseAnimationName (blank for self)
+    // float baseKeyFrameTime
+    M_ANIMATION_TRACK = 0xD110,
+    // unsigned short type          // 1 == morph, 2 == pose
+    // unsigned short target        // 0 for shared geometry,
+    // 1+ for submesh index + 1
+    M_ANIMATION_MORPH_KEYFRAME = 0xD111,
+    // float time
+    // bool includesNormals [1.8+]
+    // float x,y,z          // repeat by number of vertices in original geometry
+    M_ANIMATION_POSE_KEYFRAME = 0xD112,
+    // float time
+    M_ANIMATION_POSE_REF = 0xD113, // repeat for number of referenced poses
+    // unsigned short poseIndex
+    // float influence
+    // Optional submesh extreme vertex list chink
+    M_TABLE_EXTREMES = 0xE000
+    // unsigned short submesh_index;
+    // float extremes [n_extremes][3];
+};
+
+/*
+static std::string MeshHeaderToString(MeshChunkId id)
+{
+    switch(id)
+    {
+        case M_HEADER:                      return "HEADER";
+        case M_MESH:                        return "MESH";
+        case M_SUBMESH:                     return "SUBMESH";
+        case M_SUBMESH_OPERATION:           return "SUBMESH_OPERATION";
+        case M_SUBMESH_BONE_ASSIGNMENT:     return "SUBMESH_BONE_ASSIGNMENT";
+        case M_SUBMESH_TEXTURE_ALIAS:       return "SUBMESH_TEXTURE_ALIAS";
+        case M_GEOMETRY:                    return "GEOMETRY";
+        case M_GEOMETRY_VERTEX_DECLARATION: return "GEOMETRY_VERTEX_DECLARATION";
+        case M_GEOMETRY_VERTEX_ELEMENT:     return "GEOMETRY_VERTEX_ELEMENT";
+        case M_GEOMETRY_VERTEX_BUFFER:      return "GEOMETRY_VERTEX_BUFFER";
+        case M_GEOMETRY_VERTEX_BUFFER_DATA: return "GEOMETRY_VERTEX_BUFFER_DATA";
+        case M_MESH_SKELETON_LINK:          return "MESH_SKELETON_LINK";
+        case M_MESH_BONE_ASSIGNMENT:        return "MESH_BONE_ASSIGNMENT";
+        case M_MESH_LOD:                    return "MESH_LOD";
+        case M_MESH_LOD_USAGE:              return "MESH_LOD_USAGE";
+        case M_MESH_LOD_MANUAL:             return "MESH_LOD_MANUAL";
+        case M_MESH_LOD_GENERATED:          return "MESH_LOD_GENERATED";
+        case M_MESH_BOUNDS:                 return "MESH_BOUNDS";
+        case M_SUBMESH_NAME_TABLE:          return "SUBMESH_NAME_TABLE";
+        case M_SUBMESH_NAME_TABLE_ELEMENT:  return "SUBMESH_NAME_TABLE_ELEMENT";
+        case M_EDGE_LISTS:                  return "EDGE_LISTS";
+        case M_EDGE_LIST_LOD:               return "EDGE_LIST_LOD";
+        case M_EDGE_GROUP:                  return "EDGE_GROUP";
+        case M_POSES:                       return "POSES";
+        case M_POSE:                        return "POSE";
+        case M_POSE_VERTEX:                 return "POSE_VERTEX";
+        case M_ANIMATIONS:                  return "ANIMATIONS";
+        case M_ANIMATION:                   return "ANIMATION";
+        case M_ANIMATION_BASEINFO:          return "ANIMATION_BASEINFO";
+        case M_ANIMATION_TRACK:             return "ANIMATION_TRACK";
+        case M_ANIMATION_MORPH_KEYFRAME:    return "ANIMATION_MORPH_KEYFRAME";
+        case M_ANIMATION_POSE_KEYFRAME:     return "ANIMATION_POSE_KEYFRAME";
+        case M_ANIMATION_POSE_REF:          return "ANIMATION_POSE_REF";
+        case M_TABLE_EXTREMES:              return "TABLE_EXTREMES";
+    }
+    return "Unknown_MeshChunkId";
+}
+*/
+
+enum SkeletonChunkId {
+    SKELETON_HEADER = 0x1000,
+    // char* version           : Version number check
+    SKELETON_BLENDMODE = 0x1010, // optional
+    // unsigned short blendmode     : SkeletonAnimationBlendMode
+    SKELETON_BONE = 0x2000,
+    // Repeating section defining each bone in the system.
+    // Bones are assigned indexes automatically based on their order of declaration
+    // starting with 0.
+    // char* name                      : name of the bone
+    // unsigned short handle            : handle of the bone, should be contiguous & start at 0
+    // Vector3 position              : position of this bone relative to parent
+    // Quaternion orientation          : orientation of this bone relative to parent
+    // Vector3 scale                    : scale of this bone relative to parent
+    SKELETON_BONE_PARENT = 0x3000,
+    // Record of the parent of a single bone, used to build the node tree
+    // Repeating section, listed in Bone Index order, one per Bone
+    // unsigned short handle             : child bone
+    // unsigned short parentHandle   : parent bone
+    SKELETON_ANIMATION = 0x4000,
+    // A single animation for this skeleton
+    // char* name                      : Name of the animation
+    // float length                   : Length of the animation in seconds
+    SKELETON_ANIMATION_BASEINFO = 0x4010,
+    // [Optional] base keyframe information
+    // char* baseAnimationName (blank for self)
+    // float baseKeyFrameTime
+    SKELETON_ANIMATION_TRACK = 0x4100,
+    // A single animation track (relates to a single bone)
+    // Repeating section (within SKELETON_ANIMATION)
+    // unsigned short boneIndex  : Index of bone to apply to
+    SKELETON_ANIMATION_TRACK_KEYFRAME = 0x4110,
+    // A single keyframe within the track
+    // Repeating section
+    // float time                   : The time position (seconds)
+    // Quaternion rotate            : Rotation to apply at this keyframe
+    // Vector3 translate            : Translation to apply at this keyframe
+    // Vector3 scale                : Scale to apply at this keyframe
+    SKELETON_ANIMATION_LINK = 0x5000
+    // Link to another skeleton, to re-use its animations
+    // char* skeletonName                   : name of skeleton to get animations from
+    // float scale                          : scale to apply to trans/scale keys
+};
+
+/*
+static std::string SkeletonHeaderToString(SkeletonChunkId id)
+{
+    switch(id)
+    {
+        case SKELETON_HEADER:                   return "HEADER";
+        case SKELETON_BLENDMODE:                return "BLENDMODE";
+        case SKELETON_BONE:                     return "BONE";
+        case SKELETON_BONE_PARENT:              return "BONE_PARENT";
+        case SKELETON_ANIMATION:                return "ANIMATION";
+        case SKELETON_ANIMATION_BASEINFO:       return "ANIMATION_BASEINFO";
+        case SKELETON_ANIMATION_TRACK:          return "ANIMATION_TRACK";
+        case SKELETON_ANIMATION_TRACK_KEYFRAME: return "ANIMATION_TRACK_KEYFRAME";
+        case SKELETON_ANIMATION_LINK:           return "ANIMATION_LINK";
+    }
+    return "Unknown_SkeletonChunkId";
+}
+*/
+} // namespace Ogre
+} // namespace Assimp
+
+#endif // ASSIMP_BUILD_NO_OGRE_IMPORTER
+#endif // AI_OGREBINARYSERIALIZER_H_INC
diff --git a/Engine/lib/assimp/code/Ogre/OgreImporter.cpp b/Engine/lib/assimp/code/AssetLib/Ogre/OgreImporter.cpp
similarity index 68%
rename from Engine/lib/assimp/code/Ogre/OgreImporter.cpp
rename to Engine/lib/assimp/code/AssetLib/Ogre/OgreImporter.cpp
index c2c328a47..860aed727 100644
--- a/Engine/lib/assimp/code/Ogre/OgreImporter.cpp
+++ b/Engine/lib/assimp/code/AssetLib/Ogre/OgreImporter.cpp
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -45,8 +44,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "OgreImporter.h"
 #include "OgreBinarySerializer.h"
 #include "OgreXmlSerializer.h"
-#include <assimp/Importer.hpp>
 #include <assimp/importerdesc.h>
+#include <assimp/Importer.hpp>
 #include <memory>
 
 static const aiImporterDesc desc = {
@@ -62,51 +61,37 @@ static const aiImporterDesc desc = {
     "mesh mesh.xml"
 };
 
-namespace Assimp
-{
-namespace Ogre
-{
+namespace Assimp {
+namespace Ogre {
 
-const aiImporterDesc* OgreImporter::GetInfo() const
-{
+const aiImporterDesc *OgreImporter::GetInfo() const {
     return &desc;
 }
 
-void OgreImporter::SetupProperties(const Importer* pImp)
-{
+void OgreImporter::SetupProperties(const Importer *pImp) {
     m_userDefinedMaterialLibFile = pImp->GetPropertyString(AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE, "Scene.material");
     m_detectTextureTypeFromFilename = pImp->GetPropertyBool(AI_CONFIG_IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME, false);
 }
 
-bool OgreImporter::CanRead(const std::string &pFile, Assimp::IOSystem *pIOHandler, bool checkSig) const
-{
-    if (!checkSig) {
-        return EndsWith(pFile, ".mesh.xml", false) || EndsWith(pFile, ".mesh", false);
+bool OgreImporter::CanRead(const std::string &pFile, Assimp::IOSystem *pIOHandler, bool /*checkSig*/) const {
+    if (EndsWith(pFile, ".mesh.xml", false)) {
+        static const char *tokens[] = { "<mesh>" };
+        return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
     }
 
-    if (EndsWith(pFile, ".mesh.xml", false))
-    {
-        const char* tokens[] = { "<mesh>" };
-        return SearchFileHeaderForToken(pIOHandler, pFile, tokens, 1);
-    }
-    else
-    {
-        /// @todo Read and validate first header chunk?
-        return EndsWith(pFile, ".mesh", false);
-    }
+    /// @todo Read and validate first header chunk?
+    return EndsWith(pFile, ".mesh", false);
 }
 
-void OgreImporter::InternReadFile(const std::string &pFile, aiScene *pScene, Assimp::IOSystem *pIOHandler)
-{
+void OgreImporter::InternReadFile(const std::string &pFile, aiScene *pScene, Assimp::IOSystem *pIOHandler) {
     // Open source file
     IOStream *f = pIOHandler->Open(pFile, "rb");
     if (!f) {
-        throw DeadlyImportError("Failed to open file " + pFile);
+        throw DeadlyImportError("Failed to open file ", pFile);
     }
 
     // Binary .mesh import
-    if (EndsWith(pFile, ".mesh", false))
-    {
+    if (EndsWith(pFile, ".mesh", false)) {
         /// @note MemoryStreamReader takes ownership of f.
         MemoryStreamReader reader(f);
 
@@ -121,30 +106,30 @@ void OgreImporter::InternReadFile(const std::string &pFile, aiScene *pScene, Ass
 
         // Convert to Assimp
         mesh->ConvertToAssimpScene(pScene);
+        return;
     }
     // XML .mesh.xml import
-    else
-    {
-        /// @note XmlReader does not take ownership of f, hence the scoped ptr.
-        std::unique_ptr<IOStream> scopedFile(f);
-        std::unique_ptr<CIrrXML_IOStreamReader> xmlStream(new CIrrXML_IOStreamReader(scopedFile.get()));
-        std::unique_ptr<XmlReader> reader(irr::io::createIrrXMLReader(xmlStream.get()));
+    /// @note XmlReader does not take ownership of f, hence the scoped ptr.
+    std::unique_ptr<IOStream> scopedFile(f);
+    XmlParser xmlParser;
 
-        // Import mesh
-        std::unique_ptr<MeshXml> mesh(OgreXmlSerializer::ImportMesh(reader.get()));
+    //std::unique_ptr<CIrrXML_IOStreamReader> xmlStream(new CIrrXML_IOStreamReader(scopedFile.get()));
+    //std::unique_ptr<XmlReader> reader(irr::io::createIrrXMLReader(xmlStream.get()));
+    xmlParser.parse(scopedFile.get());
+    // Import mesh
+    std::unique_ptr<MeshXml> mesh(OgreXmlSerializer::ImportMesh(&xmlParser));
 
-        // Import skeleton
-        OgreXmlSerializer::ImportSkeleton(pIOHandler, mesh.get());
+    // Import skeleton
+    OgreXmlSerializer::ImportSkeleton(pIOHandler, mesh.get());
 
-        // Import mesh referenced materials
-        ReadMaterials(pFile, pIOHandler, pScene, mesh.get());
+    // Import mesh referenced materials
+    ReadMaterials(pFile, pIOHandler, pScene, mesh.get());
 
-        // Convert to Assimp
-        mesh->ConvertToAssimpScene(pScene);
-    }
+    // Convert to Assimp
+    mesh->ConvertToAssimpScene(pScene);
 }
 
-} // Ogre
-} // Assimp
+} // namespace Ogre
+} // namespace Assimp
 
 #endif // ASSIMP_BUILD_NO_OGRE_IMPORTER
diff --git a/Engine/lib/assimp/code/Ogre/OgreImporter.h b/Engine/lib/assimp/code/AssetLib/Ogre/OgreImporter.h
similarity index 87%
rename from Engine/lib/assimp/code/Ogre/OgreImporter.h
rename to Engine/lib/assimp/code/AssetLib/Ogre/OgreImporter.h
index 321d58763..dc8b09051 100644
--- a/Engine/lib/assimp/code/Ogre/OgreImporter.h
+++ b/Engine/lib/assimp/code/AssetLib/Ogre/OgreImporter.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -39,64 +38,61 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 ----------------------------------------------------------------------
 */
-
+#pragma once
 #ifndef AI_OGREIMPORTER_H_INC
 #define AI_OGREIMPORTER_H_INC
 
 #ifndef ASSIMP_BUILD_NO_OGRE_IMPORTER
 
 #include <assimp/BaseImporter.h>
-
-#include "OgreStructs.h"
-#include "OgreParsingUtils.h"
-
 #include <assimp/material.h>
 
-namespace Assimp
-{
-namespace Ogre
-{
+#include "OgreParsingUtils.h"
+#include "OgreStructs.h"
+
+namespace Assimp {
+namespace Ogre {
 
 /** Importer for Ogre mesh, skeleton and material formats.
     @todo Support vertex colors.
     @todo Support poses/animations from the mesh file.
     Currently only skeleton file animations are supported. */
-class OgreImporter : public BaseImporter
-{
+class OgreImporter : public BaseImporter {
 public:
     /// BaseImporter override.
-    virtual bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const;
+    virtual bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const override;
+
+protected:
+    /// BaseImporter override.
+    virtual void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) override;
 
     /// BaseImporter override.
-    virtual void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler);
+    virtual const aiImporterDesc *GetInfo() const override;
 
     /// BaseImporter override.
-    virtual const aiImporterDesc *GetInfo() const;
-
-    /// BaseImporter override.
-    virtual void SetupProperties(const Importer *pImp);
+    virtual void SetupProperties(const Importer *pImp) override;
 
 private:
     /// Read materials referenced by the @c mesh to @c pScene.
     void ReadMaterials(const std::string &pFile, Assimp::IOSystem *pIOHandler, aiScene *pScene, Mesh *mesh);
     void ReadMaterials(const std::string &pFile, Assimp::IOSystem *pIOHandler, aiScene *pScene, MeshXml *mesh);
-    void AssignMaterials(aiScene *pScene, std::vector<aiMaterial*> &materials);
+    void AssignMaterials(aiScene *pScene, std::vector<aiMaterial *> &materials);
 
     /// Reads material
-    aiMaterial* ReadMaterial(const std::string &pFile, Assimp::IOSystem *pIOHandler, const std::string &MaterialName);
+    aiMaterial *ReadMaterial(const std::string &pFile, Assimp::IOSystem *pIOHandler, const std::string &MaterialName);
 
     // These functions parse blocks from a material file from @c ss. Starting parsing from "{" and ending it to "}".
     bool ReadTechnique(const std::string &techniqueName, std::stringstream &ss, aiMaterial *material);
     bool ReadPass(const std::string &passName, std::stringstream &ss, aiMaterial *material);
     bool ReadTextureUnit(const std::string &textureUnitName, std::stringstream &ss, aiMaterial *material);
 
+private:
     std::string m_userDefinedMaterialLibFile;
     bool m_detectTextureTypeFromFilename;
-
     std::map<aiTextureType, unsigned int> m_textures;
 };
-} // Ogre
-} // Assimp
+} // namespace Ogre
+} // namespace Assimp
 
 #endif // ASSIMP_BUILD_NO_OGRE_IMPORTER
 #endif // AI_OGREIMPORTER_H_INC
diff --git a/Engine/lib/assimp/code/Ogre/OgreMaterial.cpp b/Engine/lib/assimp/code/AssetLib/Ogre/OgreMaterial.cpp
similarity index 60%
rename from Engine/lib/assimp/code/Ogre/OgreMaterial.cpp
rename to Engine/lib/assimp/code/AssetLib/Ogre/OgreMaterial.cpp
index 47cb17eb0..7478a80a9 100644
--- a/Engine/lib/assimp/code/Ogre/OgreMaterial.cpp
+++ b/Engine/lib/assimp/code/AssetLib/Ogre/OgreMaterial.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -40,45 +40,38 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
-
-
 #ifndef ASSIMP_BUILD_NO_OGRE_IMPORTER
 
 #include "OgreImporter.h"
+#include <assimp/StringUtils.h>
 #include <assimp/TinyFormatter.h>
+#include <assimp/fast_atof.h>
 #include <assimp/material.h>
 #include <assimp/scene.h>
 #include <assimp/DefaultLogger.hpp>
-#include <assimp/fast_atof.h>
 
-#include <vector>
-#include <sstream>
 #include <memory>
+#include <sstream>
+#include <vector>
 
 using namespace std;
 
-namespace Assimp
-{
-namespace Ogre
-{
+namespace Assimp {
+namespace Ogre {
 
-static const string partComment    = "//";
+static const string partComment = "//";
 static const string partBlockStart = "{";
-static const string partBlockEnd   = "}";
+static const string partBlockEnd = "}";
 
-void OgreImporter::ReadMaterials(const std::string &pFile, Assimp::IOSystem *pIOHandler, aiScene *pScene, Mesh *mesh)
-{
-    std::vector<aiMaterial*> materials;
+void OgreImporter::ReadMaterials(const std::string &pFile, Assimp::IOSystem *pIOHandler, aiScene *pScene, Mesh *mesh) {
+    std::vector<aiMaterial *> materials;
 
     // Create materials that can be found and parsed via the IOSystem.
-    for (size_t i=0, len=mesh->NumSubMeshes(); i<len; ++i)
-    {
+    for (size_t i = 0, len = mesh->NumSubMeshes(); i < len; ++i) {
         SubMesh *submesh = mesh->GetSubMesh(i);
-        if (submesh && !submesh->materialRef.empty())
-        {
+        if (submesh && !submesh->materialRef.empty()) {
             aiMaterial *material = ReadMaterial(pFile, pIOHandler, submesh->materialRef);
-            if (material)
-            {
+            if (material) {
                 submesh->materialIndex = static_cast<int>(materials.size());
                 materials.push_back(material);
             }
@@ -88,19 +81,15 @@ void OgreImporter::ReadMaterials(const std::string &pFile, Assimp::IOSystem *pIO
     AssignMaterials(pScene, materials);
 }
 
-void OgreImporter::ReadMaterials(const std::string &pFile, Assimp::IOSystem *pIOHandler, aiScene *pScene, MeshXml *mesh)
-{
-    std::vector<aiMaterial*> materials;
+void OgreImporter::ReadMaterials(const std::string &pFile, Assimp::IOSystem *pIOHandler, aiScene *pScene, MeshXml *mesh) {
+    std::vector<aiMaterial *> materials;
 
     // Create materials that can be found and parsed via the IOSystem.
-    for (size_t i=0, len=mesh->NumSubMeshes(); i<len; ++i)
-    {
-        SubMeshXml *submesh = mesh->GetSubMesh( static_cast<uint16_t>(i));
-        if (submesh && !submesh->materialRef.empty())
-        {
+    for (size_t i = 0, len = mesh->NumSubMeshes(); i < len; ++i) {
+        SubMeshXml *submesh = mesh->GetSubMesh(static_cast<uint16_t>(i));
+        if (submesh && !submesh->materialRef.empty()) {
             aiMaterial *material = ReadMaterial(pFile, pIOHandler, submesh->materialRef);
-            if (material)
-            {
+            if (material) {
                 submesh->materialIndex = static_cast<int>(materials.size());
                 materials.push_back(material);
             }
@@ -110,20 +99,17 @@ void OgreImporter::ReadMaterials(const std::string &pFile, Assimp::IOSystem *pIO
     AssignMaterials(pScene, materials);
 }
 
-void OgreImporter::AssignMaterials(aiScene *pScene, std::vector<aiMaterial*> &materials)
-{
+void OgreImporter::AssignMaterials(aiScene *pScene, std::vector<aiMaterial *> &materials) {
     pScene->mNumMaterials = static_cast<unsigned int>(materials.size());
-    if (pScene->mNumMaterials > 0)
-    {
-        pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials];
-        for(size_t i=0;i<pScene->mNumMaterials; ++i) {
+    if (pScene->mNumMaterials > 0) {
+        pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials];
+        for (size_t i = 0; i < pScene->mNumMaterials; ++i) {
             pScene->mMaterials[i] = materials[i];
         }
     }
 }
 
-aiMaterial* OgreImporter::ReadMaterial(const std::string &pFile, Assimp::IOSystem *pIOHandler, const std::string &materialName)
-{
+aiMaterial *OgreImporter::ReadMaterial(const std::string &pFile, Assimp::IOSystem *pIOHandler, const std::string &materialName) {
     if (materialName.empty()) {
         return 0;
     }
@@ -169,24 +155,21 @@ aiMaterial* OgreImporter::ReadMaterial(const std::string &pFile, Assimp::IOSyste
             potentialFiles.push_back(m_userDefinedMaterialLibFile);
 
         IOStream *materialFile = 0;
-        for(size_t i=0; i<potentialFiles.size(); ++i)
-        {
+        for (size_t i = 0; i < potentialFiles.size(); ++i) {
             materialFile = pIOHandler->Open(potentialFiles[i]);
             if (materialFile) {
                 break;
             }
-            ASSIMP_LOG_DEBUG_F( "Source file for material '", materialName, "' ", potentialFiles[i], " does not exist");
+            ASSIMP_LOG_VERBOSE_DEBUG("Source file for material '", materialName, "' ", potentialFiles[i], " does not exist");
         }
-        if (!materialFile)
-        {
-            ASSIMP_LOG_ERROR_F( "Failed to find source file for material '", materialName, "'");
+        if (!materialFile) {
+            ASSIMP_LOG_ERROR("Failed to find source file for material '", materialName, "'");
             return 0;
         }
 
         std::unique_ptr<IOStream> stream(materialFile);
-        if (stream->FileSize() == 0)
-        {
-            ASSIMP_LOG_WARN_F( "Source file for material '", materialName, "' is empty (size is 0 bytes)");
+        if (stream->FileSize() == 0) {
+            ASSIMP_LOG_WARN("Source file for material '", materialName, "' is empty (size is 0 bytes)");
             return 0;
         }
 
@@ -201,61 +184,54 @@ aiMaterial* OgreImporter::ReadMaterial(const std::string &pFile, Assimp::IOSyste
         ss << &data[0];
     }
 
-    ASSIMP_LOG_DEBUG_F("Reading material '", materialName, "'");
+    ASSIMP_LOG_VERBOSE_DEBUG("Reading material '", materialName, "'");
 
     aiMaterial *material = new aiMaterial();
     m_textures.clear();
 
-    aiString ts(materialName);
-    material->AddProperty(&ts, AI_MATKEY_NAME);
+    aiString matName(materialName);
+    material->AddProperty(&matName, AI_MATKEY_NAME);
 
     // The stringstream will push words from a line until newline.
     // It will also trim whitespace from line start and between words.
     string linePart;
     ss >> linePart;
 
-    const string partMaterial   = "material";
-    const string partTechnique  = "technique";
+    const string partMaterial = "material";
+    const string partTechnique = "technique";
 
-    while(!ss.eof())
-    {
+    while (!ss.eof()) {
         // Skip commented lines
-        if (linePart == partComment)
-        {
+        if (linePart == partComment) {
             NextAfterNewLine(ss, linePart);
             continue;
         }
-        if (linePart != partMaterial)
-        {
+        if (linePart != partMaterial) {
             ss >> linePart;
             continue;
         }
 
         ss >> linePart;
-        if (linePart != materialName)
-        {
+        if (linePart != materialName) {
             ss >> linePart;
             continue;
         }
 
         NextAfterNewLine(ss, linePart);
-        if (linePart != partBlockStart)
-        {
-            ASSIMP_LOG_ERROR_F( "Invalid material: block start missing near index ", ss.tellg());
+        if (linePart != partBlockStart) {
+            ASSIMP_LOG_ERROR("Invalid material: block start missing near index ", ss.tellg());
             return material;
         }
 
-        ASSIMP_LOG_DEBUG_F("material '", materialName, "'");
+        ASSIMP_LOG_VERBOSE_DEBUG("material '", materialName, "'");
 
-        while(linePart != partBlockEnd)
-        {
+        while (linePart != partBlockEnd) {
             // Proceed to the first technique
             ss >> linePart;
 
-            if (linePart == partTechnique)
-            {
-                string techniqueName = SkipLine(ss);
-                ReadTechnique(Trim(techniqueName), ss, material);
+            if (linePart == partTechnique) {
+                std::string techniqueName = SkipLine(ss);
+                ReadTechnique(ai_trim(techniqueName), ss, material);
             }
 
             // Read information from a custom material
@@ -264,71 +240,51 @@ aiMaterial* OgreImporter::ReadMaterial(const std::string &pFile, Assimp::IOSyste
                 parent texture unit name in your cloned material.
                 This is not yet supported and below code is probably some hack from the original
                 author of this Ogre importer. Should be removed? */
-            if (linePart=="set")
-            {
+            if (linePart == "set") {
                 ss >> linePart;
-                if (linePart=="$specular")//todo load this values:
-                {
-                }
-                else if (linePart=="$diffuse")
-                {
-                }
-                else if (linePart=="$ambient")
-                {
-                }
-                else if (linePart=="$colormap")
+                if (linePart == "$specular") //todo load this values:
                 {
+                } else if (linePart == "$diffuse") {
+                } else if (linePart == "$ambient") {
+                } else if (linePart == "$colormap") {
                     ss >> linePart;
-                    aiString ts(linePart);
-                    material->AddProperty(&ts, AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE, 0));
-                }
-                else if (linePart=="$normalmap")
-                {
+                    aiString cm(linePart);
+                    material->AddProperty(&cm, AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE, 0));
+                } else if (linePart == "$normalmap") {
                     ss >> linePart;
-                    aiString ts(linePart);
-                    material->AddProperty(&ts, AI_MATKEY_TEXTURE(aiTextureType_NORMALS, 0));
-                }
-                else if (linePart=="$shininess_strength")
-                {
+                    aiString nm(linePart);
+                    material->AddProperty(&nm, AI_MATKEY_TEXTURE(aiTextureType_NORMALS, 0));
+                } else if (linePart == "$shininess_strength") {
                     ss >> linePart;
                     float Shininess = fast_atof(linePart.c_str());
                     material->AddProperty(&Shininess, 1, AI_MATKEY_SHININESS_STRENGTH);
-                }
-                else if (linePart=="$shininess_exponent")
-                {
+                } else if (linePart == "$shininess_exponent") {
                     ss >> linePart;
                     float Shininess = fast_atof(linePart.c_str());
                     material->AddProperty(&Shininess, 1, AI_MATKEY_SHININESS);
                 }
                 //Properties from Venetica:
-                else if (linePart=="$diffuse_map")
-                {
+                else if (linePart == "$diffuse_map") {
                     ss >> linePart;
-                    if (linePart[0] == '"')// "file" -> file
-                        linePart = linePart.substr(1, linePart.size()-2);
+                    if (linePart[0] == '"') // "file" -> file
+                        linePart = linePart.substr(1, linePart.size() - 2);
                     aiString ts(linePart);
                     material->AddProperty(&ts, AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE, 0));
-                }
-                else if (linePart=="$specular_map")
-                {
+                } else if (linePart == "$specular_map") {
                     ss >> linePart;
-                    if (linePart[0] == '"')// "file" -> file
-                        linePart = linePart.substr(1, linePart.size()-2);
+                    if (linePart[0] == '"') // "file" -> file
+                        linePart = linePart.substr(1, linePart.size() - 2);
                     aiString ts(linePart);
                     material->AddProperty(&ts, AI_MATKEY_TEXTURE(aiTextureType_SHININESS, 0));
-                }
-                else if (linePart=="$normal_map")
-                {
+                } else if (linePart == "$normal_map") {
                     ss >> linePart;
-                    if (linePart[0]=='"')// "file" -> file
-                        linePart = linePart.substr(1, linePart.size()-2);
+                    if (linePart[0] == '"') // "file" -> file
+                        linePart = linePart.substr(1, linePart.size() - 2);
                     aiString ts(linePart);
                     material->AddProperty(&ts, AI_MATKEY_TEXTURE(aiTextureType_NORMALS, 0));
-                }
-                else if (linePart=="$light_map")
-                {
+                } else if (linePart == "$light_map") {
                     ss >> linePart;
-                    if (linePart[0]=='"') {
+                    if (linePart[0] == '"') {
                         linePart = linePart.substr(1, linePart.size() - 2);
                     }
                     aiString ts(linePart);
@@ -342,216 +298,166 @@ aiMaterial* OgreImporter::ReadMaterial(const std::string &pFile, Assimp::IOSyste
     return material;
 }
 
-bool OgreImporter::ReadTechnique(const std::string &techniqueName, stringstream &ss, aiMaterial *material)
-{
+bool OgreImporter::ReadTechnique(const std::string &techniqueName, stringstream &ss, aiMaterial *material) {
     string linePart;
     ss >> linePart;
 
-    if (linePart != partBlockStart)
-    {
-        ASSIMP_LOG_ERROR_F( "Invalid material: Technique block start missing near index ", ss.tellg());
+    if (linePart != partBlockStart) {
+        ASSIMP_LOG_ERROR("Invalid material: Technique block start missing near index ", ss.tellg());
         return false;
     }
 
-    ASSIMP_LOG_DEBUG_F(" technique '", techniqueName, "'");
+    ASSIMP_LOG_VERBOSE_DEBUG(" technique '", techniqueName, "'");
 
-    const string partPass  = "pass";
+    const string partPass = "pass";
 
-    while(linePart != partBlockEnd)
-    {
+    while (linePart != partBlockEnd) {
         ss >> linePart;
 
         // Skip commented lines
-        if (linePart == partComment)
-        {
+        if (linePart == partComment) {
             SkipLine(ss);
             continue;
         }
 
         /// @todo Techniques have other attributes than just passes.
-        if (linePart == partPass)
-        {
+        if (linePart == partPass) {
             string passName = SkipLine(ss);
-            ReadPass(Trim(passName), ss, material);
+            ReadPass(ai_trim(passName), ss, material);
         }
     }
     return true;
 }
 
-bool OgreImporter::ReadPass(const std::string &passName, stringstream &ss, aiMaterial *material)
-{
+bool OgreImporter::ReadPass(const std::string &passName, stringstream &ss, aiMaterial *material) {
     string linePart;
     ss >> linePart;
 
-    if (linePart != partBlockStart)
-    {
-        ASSIMP_LOG_ERROR_F( "Invalid material: Pass block start missing near index ", ss.tellg());
+    if (linePart != partBlockStart) {
+        ASSIMP_LOG_ERROR("Invalid material: Pass block start missing near index ", ss.tellg());
         return false;
     }
 
-    ASSIMP_LOG_DEBUG_F("  pass '", passName, "'");
+    ASSIMP_LOG_VERBOSE_DEBUG("  pass '", passName, "'");
 
-    const string partAmbient     = "ambient";
-    const string partDiffuse     = "diffuse";
-    const string partSpecular    = "specular";
-    const string partEmissive    = "emissive";
+    const string partAmbient = "ambient";
+    const string partDiffuse = "diffuse";
+    const string partSpecular = "specular";
+    const string partEmissive = "emissive";
     const string partTextureUnit = "texture_unit";
 
-    while(linePart != partBlockEnd)
-    {
+    while (linePart != partBlockEnd) {
         ss >> linePart;
 
         // Skip commented lines
-        if (linePart == partComment)
-        {
+        if (linePart == partComment) {
             SkipLine(ss);
             continue;
         }
 
         // Colors
         /// @todo Support alpha via aiColor4D.
-        if (linePart == partAmbient || linePart == partDiffuse || linePart == partSpecular || linePart == partEmissive)
-        {
+        if (linePart == partAmbient || linePart == partDiffuse || linePart == partSpecular || linePart == partEmissive) {
             float r, g, b;
             ss >> r >> g >> b;
             const aiColor3D color(r, g, b);
 
-            ASSIMP_LOG_DEBUG_F( "   ", linePart, " ", r, " ", g, " ", b);
+            ASSIMP_LOG_VERBOSE_DEBUG("   ", linePart, " ", r, " ", g, " ", b);
 
-            if (linePart == partAmbient)
-            {
+            if (linePart == partAmbient) {
                 material->AddProperty(&color, 1, AI_MATKEY_COLOR_AMBIENT);
-            }
-            else if (linePart == partDiffuse)
-            {
+            } else if (linePart == partDiffuse) {
                 material->AddProperty(&color, 1, AI_MATKEY_COLOR_DIFFUSE);
-            }
-            else if (linePart == partSpecular)
-            {
+            } else if (linePart == partSpecular) {
                 material->AddProperty(&color, 1, AI_MATKEY_COLOR_SPECULAR);
-            }
-            else if (linePart == partEmissive)
-            {
+            } else if (linePart == partEmissive) {
                 material->AddProperty(&color, 1, AI_MATKEY_COLOR_EMISSIVE);
             }
-        }
-        else if (linePart == partTextureUnit)
-        {
+        } else if (linePart == partTextureUnit) {
             string textureUnitName = SkipLine(ss);
-            ReadTextureUnit(Trim(textureUnitName), ss, material);
+            ReadTextureUnit(ai_trim(textureUnitName), ss, material);
         }
     }
     return true;
 }
 
-bool OgreImporter::ReadTextureUnit(const std::string &textureUnitName, stringstream &ss, aiMaterial *material)
-{
+bool OgreImporter::ReadTextureUnit(const std::string &textureUnitName, stringstream &ss, aiMaterial *material) {
     string linePart;
     ss >> linePart;
 
-    if (linePart != partBlockStart)
-    {
-        ASSIMP_LOG_ERROR_F( "Invalid material: Texture unit block start missing near index ", ss.tellg());
+    if (linePart != partBlockStart) {
+        ASSIMP_LOG_ERROR("Invalid material: Texture unit block start missing near index ", ss.tellg());
         return false;
     }
 
-    ASSIMP_LOG_DEBUG_F("   texture_unit '", textureUnitName, "'");
+    ASSIMP_LOG_VERBOSE_DEBUG("   texture_unit '", textureUnitName, "'");
 
-    const string partTexture      = "texture";
+    const string partTexture = "texture";
     const string partTextCoordSet = "tex_coord_set";
-    const string partColorOp      = "colour_op";
+    const string partColorOp = "colour_op";
 
     aiTextureType textureType = aiTextureType_NONE;
     std::string textureRef;
     int uvCoord = 0;
 
-    while(linePart != partBlockEnd)
-    {
+    while (linePart != partBlockEnd) {
         ss >> linePart;
 
         // Skip commented lines
-        if (linePart == partComment)
-        {
+        if (linePart == partComment) {
             SkipLine(ss);
             continue;
         }
 
-        if (linePart == partTexture)
-        {
+        if (linePart == partTexture) {
             ss >> linePart;
             textureRef = linePart;
 
             // User defined Assimp config property to detect texture type from filename.
-            if (m_detectTextureTypeFromFilename)
-            {
-                size_t posSuffix = textureRef.find_last_of(".");
-                size_t posUnderscore = textureRef.find_last_of("_");
+            if (m_detectTextureTypeFromFilename) {
+                size_t posSuffix = textureRef.find_last_of('.');
+                size_t posUnderscore = textureRef.find_last_of('_');
 
-                if (posSuffix != string::npos && posUnderscore != string::npos && posSuffix > posUnderscore)
-                {
-                    string identifier = Ogre::ToLower(textureRef.substr(posUnderscore, posSuffix - posUnderscore));
-                    ASSIMP_LOG_DEBUG_F( "Detecting texture type from filename postfix '", identifier, "'");
+                if (posSuffix != string::npos && posUnderscore != string::npos && posSuffix > posUnderscore) {
+                    string identifier = ai_tolower(textureRef.substr(posUnderscore, posSuffix - posUnderscore));
+                    ASSIMP_LOG_VERBOSE_DEBUG("Detecting texture type from filename postfix '", identifier, "'");
 
-                    if (identifier == "_n" || identifier == "_nrm" || identifier == "_nrml" || identifier == "_normal" || identifier == "_normals" || identifier == "_normalmap")
-                    {
+                    if (identifier == "_n" || identifier == "_nrm" || identifier == "_nrml" || identifier == "_normal" || identifier == "_normals" || identifier == "_normalmap") {
                         textureType = aiTextureType_NORMALS;
-                    }
-                    else if (identifier == "_s" || identifier == "_spec" || identifier == "_specular" || identifier == "_specularmap")
-                    {
+                    } else if (identifier == "_s" || identifier == "_spec" || identifier == "_specular" || identifier == "_specularmap") {
                         textureType = aiTextureType_SPECULAR;
-                    }
-                    else if (identifier == "_l" || identifier == "_light" || identifier == "_lightmap" || identifier == "_occ" || identifier == "_occlusion")
-                    {
+                    } else if (identifier == "_l" || identifier == "_light" || identifier == "_lightmap" || identifier == "_occ" || identifier == "_occlusion") {
                         textureType = aiTextureType_LIGHTMAP;
-                    }
-                    else if (identifier == "_disp" || identifier == "_displacement")
-                    {
+                    } else if (identifier == "_disp" || identifier == "_displacement") {
                         textureType = aiTextureType_DISPLACEMENT;
-                    }
-                    else
-                    {
+                    } else {
                         textureType = aiTextureType_DIFFUSE;
                     }
-                }
-                else
-                {
+                } else {
                     textureType = aiTextureType_DIFFUSE;
                 }
             }
             // Detect from texture unit name. This cannot be too broad as
             // authors might give names like "LightSaber" or "NormalNinja".
-            else
-            {
-                string unitNameLower = Ogre::ToLower(textureUnitName);
-                if (unitNameLower.find("normalmap") != string::npos)
-                {
+            else {
+                string unitNameLower = ai_tolower(textureUnitName);
+                if (unitNameLower.find("normalmap") != string::npos) {
                     textureType = aiTextureType_NORMALS;
-                }
-                else if (unitNameLower.find("specularmap") != string::npos)
-                {
+                } else if (unitNameLower.find("specularmap") != string::npos) {
                     textureType = aiTextureType_SPECULAR;
-                }
-                else if (unitNameLower.find("lightmap") != string::npos)
-                {
+                } else if (unitNameLower.find("lightmap") != string::npos) {
                     textureType = aiTextureType_LIGHTMAP;
-                }
-                else if (unitNameLower.find("displacementmap") != string::npos)
-                {
+                } else if (unitNameLower.find("displacementmap") != string::npos) {
                     textureType = aiTextureType_DISPLACEMENT;
-                }
-                else
-                {
+                } else {
                     textureType = aiTextureType_DIFFUSE;
                 }
             }
-        }
-        else if (linePart == partTextCoordSet)
-        {
+        } else if (linePart == partTextCoordSet) {
             ss >> uvCoord;
         }
         /// @todo Implement
-        else if(linePart == partColorOp)
-        {
+        else if (linePart == partColorOp) {
             /*
             ss >> linePart;
             if("replace"==linePart)//I don't think, assimp has something for this...
@@ -566,22 +472,20 @@ bool OgreImporter::ReadTextureUnit(const std::string &textureUnitName, stringstr
         }
     }
 
-    if (textureRef.empty())
-    {
+    if (textureRef.empty()) {
         ASSIMP_LOG_WARN("Texture reference is empty, ignoring texture_unit.");
         return false;
     }
-    if (textureType == aiTextureType_NONE)
-    {
-        ASSIMP_LOG_WARN("Failed to detect texture type for '" + textureRef  + "', ignoring texture_unit.");
+    if (textureType == aiTextureType_NONE) {
+        ASSIMP_LOG_WARN("Failed to detect texture type for '", textureRef, "', ignoring texture_unit.");
         return false;
     }
 
     unsigned int textureTypeIndex = m_textures[textureType];
     m_textures[textureType]++;
 
-    ASSIMP_LOG_DEBUG_F( "    texture '", textureRef, "' type ", textureType,
-        " index ", textureTypeIndex, " UV ", uvCoord);
+    ASSIMP_LOG_VERBOSE_DEBUG("    texture '", textureRef, "' type ", textureType,
+            " index ", textureTypeIndex, " UV ", uvCoord);
 
     aiString assimpTextureRef(textureRef);
     material->AddProperty(&assimpTextureRef, AI_MATKEY_TEXTURE(textureType, textureTypeIndex));
@@ -590,7 +494,7 @@ bool OgreImporter::ReadTextureUnit(const std::string &textureUnitName, stringstr
     return true;
 }
 
-} // Ogre
-} // Assimp
+} // namespace Ogre
+} // namespace Assimp
 
 #endif // ASSIMP_BUILD_NO_OGRE_IMPORTER
diff --git a/Engine/lib/assimp/code/Ogre/OgreParsingUtils.h b/Engine/lib/assimp/code/AssetLib/Ogre/OgreParsingUtils.h
similarity index 57%
rename from Engine/lib/assimp/code/Ogre/OgreParsingUtils.h
rename to Engine/lib/assimp/code/AssetLib/Ogre/OgreParsingUtils.h
index 8786521e4..60dd5cf76 100644
--- a/Engine/lib/assimp/code/Ogre/OgreParsingUtils.h
+++ b/Engine/lib/assimp/code/AssetLib/Ogre/OgreParsingUtils.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -46,26 +45,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_OGRE_IMPORTER
 
 #include <assimp/ParsingUtils.h>
-#include <functional>
+#include <cstdint>
 #include <algorithm>
-#include <stdint.h>
-#include <sstream>
 #include <cctype>
+#include <functional>
+#include <sstream>
 
 namespace Assimp {
 namespace Ogre {
 
-/// Returns a lower cased copy of @s.
-static AI_FORCE_INLINE
-std::string ToLower(std::string s)
-{
-    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
-    return s;
-}
 
 /// Returns if @c s ends with @c suffix. If @c caseSensitive is false, both strings will be lower cased before matching.
-static AI_FORCE_INLINE
-bool EndsWith(const std::string &s, const std::string &suffix, bool caseSensitive = true) {
+static inline bool EndsWith(const std::string &s, const std::string &suffix, bool caseSensitive = true) {
     if (s.empty() || suffix.empty()) {
         return false;
     } else if (s.length() < suffix.length()) {
@@ -73,64 +64,32 @@ bool EndsWith(const std::string &s, const std::string &suffix, bool caseSensitiv
     }
 
     if (!caseSensitive) {
-        return EndsWith(ToLower(s), ToLower(suffix), true);
+        return EndsWith(ai_tolower(s), ai_tolower(suffix), true);
     }
 
     size_t len = suffix.length();
-    std::string sSuffix = s.substr(s.length()-len, len);
+    std::string sSuffix = s.substr(s.length() - len, len);
 
     return (ASSIMP_stricmp(sSuffix, suffix) == 0);
 }
 
-// Below trim functions adapted from http://stackoverflow.com/questions/216823/whats-the-best-way-to-trim-stdstring
-
-/// Trim from start
-static AI_FORCE_INLINE
-std::string &TrimLeft(std::string &s, bool newlines = true) {
-    if (!newlines) {
-        s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](char c) { return !Assimp::IsSpace<char>(c); }));
-    } else {
-        s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](char c) { return !Assimp::IsSpaceOrNewLine<char>(c); }));
-    }
-    return s;
-}
-
-/// Trim from end
-static AI_FORCE_INLINE
-std::string &TrimRight(std::string &s, bool newlines = true) {
-    if (!newlines) {
-        s.erase(std::find_if(s.rbegin(), s.rend(), [](char c) { return !Assimp::IsSpace<char>(c); }).base(),s.end());
-    } else {
-        s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](char c) { return !Assimp::IsSpaceOrNewLine<char>(c); }));
-    }
-    return s;
-}
-
-/// Trim from both ends
-static AI_FORCE_INLINE
-std::string &Trim(std::string &s, bool newlines = true) {
-    return TrimLeft(TrimRight(s, newlines), newlines);
-}
-
-/// Skips a line from current @ss position until a newline. Returns the skipped part.
-static AI_FORCE_INLINE
-std::string SkipLine(std::stringstream &ss) {
+// Skips a line from current @ss position until a newline. Returns the skipped part.
+static inline std::string SkipLine(std::stringstream &ss) {
     std::string skipped;
     getline(ss, skipped);
     return skipped;
 }
 
-/// Skips a line and reads next element from @c ss to @c nextElement.
+// Skips a line and reads next element from @c ss to @c nextElement.
 /** @return Skipped line content until newline. */
-static AI_FORCE_INLINE
-std::string NextAfterNewLine(std::stringstream &ss, std::string &nextElement) {
+static inline std::string NextAfterNewLine(std::stringstream &ss, std::string &nextElement) {
     std::string skipped = SkipLine(ss);
     ss >> nextElement;
     return skipped;
 }
 
-} // Ogre
-} // Assimp
+} // namespace Ogre
+} // namespace Assimp
 
 #endif // ASSIMP_BUILD_NO_OGRE_IMPORTER
 #endif // AI_OGREPARSINGUTILS_H_INC
diff --git a/Engine/lib/assimp/code/Ogre/OgreStructs.cpp b/Engine/lib/assimp/code/AssetLib/Ogre/OgreStructs.cpp
similarity index 57%
rename from Engine/lib/assimp/code/Ogre/OgreStructs.cpp
rename to Engine/lib/assimp/code/AssetLib/Ogre/OgreStructs.cpp
index 7962202c1..d63dd934a 100644
--- a/Engine/lib/assimp/code/Ogre/OgreStructs.cpp
+++ b/Engine/lib/assimp/code/AssetLib/Ogre/OgreStructs.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -43,199 +43,183 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_OGRE_IMPORTER
 
 #include "OgreStructs.h"
+#include <assimp/Exceptional.h>
 #include <assimp/TinyFormatter.h>
 #include <assimp/scene.h>
 #include <assimp/DefaultLogger.hpp>
-#include <assimp/Exceptional.h>
 
-
-namespace Assimp
-{
-namespace Ogre
-{
+namespace Assimp {
+namespace Ogre {
 
 // VertexElement
 
 VertexElement::VertexElement() :
-    index(0),
-    source(0),
-    offset(0),
-    type(VET_FLOAT1),
-    semantic(VES_POSITION)
-{
+        index(0),
+        source(0),
+        offset(0),
+        type(VET_FLOAT1),
+        semantic(VES_POSITION) {
 }
 
-size_t VertexElement::Size() const
-{
+size_t VertexElement::Size() const {
     return TypeSize(type);
 }
 
-size_t VertexElement::ComponentCount() const
-{
+size_t VertexElement::ComponentCount() const {
     return ComponentCount(type);
 }
 
-size_t VertexElement::ComponentCount(Type type)
-{
-    switch(type)
-    {
-        case VET_COLOUR:
-        case VET_COLOUR_ABGR:
-        case VET_COLOUR_ARGB:
-        case VET_FLOAT1:
-        case VET_DOUBLE1:
-        case VET_SHORT1:
-        case VET_USHORT1:
-        case VET_INT1:
-        case VET_UINT1:
-            return 1;
-        case VET_FLOAT2:
-        case VET_DOUBLE2:
-        case VET_SHORT2:
-        case VET_USHORT2:
-        case VET_INT2:
-        case VET_UINT2:
-            return 2;
-        case VET_FLOAT3:
-        case VET_DOUBLE3:
-        case VET_SHORT3:
-        case VET_USHORT3:
-        case VET_INT3:
-        case VET_UINT3:
-            return 3;
-        case VET_FLOAT4:
-        case VET_DOUBLE4:
-        case VET_SHORT4:
-        case VET_USHORT4:
-        case VET_INT4:
-        case VET_UINT4:
-        case VET_UBYTE4:
-            return 4;
+size_t VertexElement::ComponentCount(Type type) {
+    switch (type) {
+    case VET_COLOUR:
+    case VET_COLOUR_ABGR:
+    case VET_COLOUR_ARGB:
+    case VET_FLOAT1:
+    case VET_DOUBLE1:
+    case VET_SHORT1:
+    case VET_USHORT1:
+    case VET_INT1:
+    case VET_UINT1:
+        return 1;
+    case VET_FLOAT2:
+    case VET_DOUBLE2:
+    case VET_SHORT2:
+    case VET_USHORT2:
+    case VET_INT2:
+    case VET_UINT2:
+        return 2;
+    case VET_FLOAT3:
+    case VET_DOUBLE3:
+    case VET_SHORT3:
+    case VET_USHORT3:
+    case VET_INT3:
+    case VET_UINT3:
+        return 3;
+    case VET_FLOAT4:
+    case VET_DOUBLE4:
+    case VET_SHORT4:
+    case VET_USHORT4:
+    case VET_INT4:
+    case VET_UINT4:
+    case VET_UBYTE4:
+        return 4;
     }
     return 0;
 }
 
-size_t VertexElement::TypeSize(Type type)
-{
-    switch(type)
-    {
-        case VET_COLOUR:
-        case VET_COLOUR_ABGR:
-        case VET_COLOUR_ARGB:
-            return sizeof(unsigned int);
-        case VET_FLOAT1:
-            return sizeof(float);
-        case VET_FLOAT2:
-            return sizeof(float)*2;
-        case VET_FLOAT3:
-            return sizeof(float)*3;
-        case VET_FLOAT4:
-            return sizeof(float)*4;
-        case VET_DOUBLE1:
-            return sizeof(double);
-        case VET_DOUBLE2:
-            return sizeof(double)*2;
-        case VET_DOUBLE3:
-            return sizeof(double)*3;
-        case VET_DOUBLE4:
-            return sizeof(double)*4;
-        case VET_SHORT1:
-            return sizeof(short);
-        case VET_SHORT2:
-            return sizeof(short)*2;
-        case VET_SHORT3:
-            return sizeof(short)*3;
-        case VET_SHORT4:
-            return sizeof(short)*4;
-        case VET_USHORT1:
-            return sizeof(unsigned short);
-        case VET_USHORT2:
-            return sizeof(unsigned short)*2;
-        case VET_USHORT3:
-            return sizeof(unsigned short)*3;
-        case VET_USHORT4:
-            return sizeof(unsigned short)*4;
-        case VET_INT1:
-            return sizeof(int);
-        case VET_INT2:
-            return sizeof(int)*2;
-        case VET_INT3:
-            return sizeof(int)*3;
-        case VET_INT4:
-            return sizeof(int)*4;
-        case VET_UINT1:
-            return sizeof(unsigned int);
-        case VET_UINT2:
-            return sizeof(unsigned int)*2;
-        case VET_UINT3:
-            return sizeof(unsigned int)*3;
-        case VET_UINT4:
-            return sizeof(unsigned int)*4;
-        case VET_UBYTE4:
-            return sizeof(unsigned char)*4;
+size_t VertexElement::TypeSize(Type type) {
+    switch (type) {
+    case VET_COLOUR:
+    case VET_COLOUR_ABGR:
+    case VET_COLOUR_ARGB:
+        return sizeof(unsigned int);
+    case VET_FLOAT1:
+        return sizeof(float);
+    case VET_FLOAT2:
+        return sizeof(float) * 2;
+    case VET_FLOAT3:
+        return sizeof(float) * 3;
+    case VET_FLOAT4:
+        return sizeof(float) * 4;
+    case VET_DOUBLE1:
+        return sizeof(double);
+    case VET_DOUBLE2:
+        return sizeof(double) * 2;
+    case VET_DOUBLE3:
+        return sizeof(double) * 3;
+    case VET_DOUBLE4:
+        return sizeof(double) * 4;
+    case VET_SHORT1:
+        return sizeof(short);
+    case VET_SHORT2:
+        return sizeof(short) * 2;
+    case VET_SHORT3:
+        return sizeof(short) * 3;
+    case VET_SHORT4:
+        return sizeof(short) * 4;
+    case VET_USHORT1:
+        return sizeof(unsigned short);
+    case VET_USHORT2:
+        return sizeof(unsigned short) * 2;
+    case VET_USHORT3:
+        return sizeof(unsigned short) * 3;
+    case VET_USHORT4:
+        return sizeof(unsigned short) * 4;
+    case VET_INT1:
+        return sizeof(int);
+    case VET_INT2:
+        return sizeof(int) * 2;
+    case VET_INT3:
+        return sizeof(int) * 3;
+    case VET_INT4:
+        return sizeof(int) * 4;
+    case VET_UINT1:
+        return sizeof(unsigned int);
+    case VET_UINT2:
+        return sizeof(unsigned int) * 2;
+    case VET_UINT3:
+        return sizeof(unsigned int) * 3;
+    case VET_UINT4:
+        return sizeof(unsigned int) * 4;
+    case VET_UBYTE4:
+        return sizeof(unsigned char) * 4;
     }
     return 0;
 }
 
-std::string VertexElement::TypeToString()
-{
+std::string VertexElement::TypeToString() {
     return TypeToString(type);
 }
 
-std::string VertexElement::TypeToString(Type type)
-{
-    switch(type)
-    {
-        case VET_COLOUR:        return "COLOUR";
-        case VET_COLOUR_ABGR:   return "COLOUR_ABGR";
-        case VET_COLOUR_ARGB:   return "COLOUR_ARGB";
-        case VET_FLOAT1:        return "FLOAT1";
-        case VET_FLOAT2:        return "FLOAT2";
-        case VET_FLOAT3:        return "FLOAT3";
-        case VET_FLOAT4:        return "FLOAT4";
-        case VET_DOUBLE1:       return "DOUBLE1";
-        case VET_DOUBLE2:       return "DOUBLE2";
-        case VET_DOUBLE3:       return "DOUBLE3";
-        case VET_DOUBLE4:       return "DOUBLE4";
-        case VET_SHORT1:        return "SHORT1";
-        case VET_SHORT2:        return "SHORT2";
-        case VET_SHORT3:        return "SHORT3";
-        case VET_SHORT4:        return "SHORT4";
-        case VET_USHORT1:       return "USHORT1";
-        case VET_USHORT2:       return "USHORT2";
-        case VET_USHORT3:       return "USHORT3";
-        case VET_USHORT4:       return "USHORT4";
-        case VET_INT1:          return "INT1";
-        case VET_INT2:          return "INT2";
-        case VET_INT3:          return "INT3";
-        case VET_INT4:          return "INT4";
-        case VET_UINT1:         return "UINT1";
-        case VET_UINT2:         return "UINT2";
-        case VET_UINT3:         return "UINT3";
-        case VET_UINT4:         return "UINT4";
-        case VET_UBYTE4:        return "UBYTE4";
+std::string VertexElement::TypeToString(Type type) {
+    switch (type) {
+    case VET_COLOUR: return "COLOUR";
+    case VET_COLOUR_ABGR: return "COLOUR_ABGR";
+    case VET_COLOUR_ARGB: return "COLOUR_ARGB";
+    case VET_FLOAT1: return "FLOAT1";
+    case VET_FLOAT2: return "FLOAT2";
+    case VET_FLOAT3: return "FLOAT3";
+    case VET_FLOAT4: return "FLOAT4";
+    case VET_DOUBLE1: return "DOUBLE1";
+    case VET_DOUBLE2: return "DOUBLE2";
+    case VET_DOUBLE3: return "DOUBLE3";
+    case VET_DOUBLE4: return "DOUBLE4";
+    case VET_SHORT1: return "SHORT1";
+    case VET_SHORT2: return "SHORT2";
+    case VET_SHORT3: return "SHORT3";
+    case VET_SHORT4: return "SHORT4";
+    case VET_USHORT1: return "USHORT1";
+    case VET_USHORT2: return "USHORT2";
+    case VET_USHORT3: return "USHORT3";
+    case VET_USHORT4: return "USHORT4";
+    case VET_INT1: return "INT1";
+    case VET_INT2: return "INT2";
+    case VET_INT3: return "INT3";
+    case VET_INT4: return "INT4";
+    case VET_UINT1: return "UINT1";
+    case VET_UINT2: return "UINT2";
+    case VET_UINT3: return "UINT3";
+    case VET_UINT4: return "UINT4";
+    case VET_UBYTE4: return "UBYTE4";
     }
     return "Uknown_VertexElement::Type";
 }
 
-std::string VertexElement::SemanticToString()
-{
+std::string VertexElement::SemanticToString() {
     return SemanticToString(semantic);
 }
 
-std::string VertexElement::SemanticToString(Semantic semantic)
-{
-    switch(semantic)
-    {
-        case VES_POSITION:              return "POSITION";
-        case VES_BLEND_WEIGHTS:         return "BLEND_WEIGHTS";
-        case VES_BLEND_INDICES:         return "BLEND_INDICES";
-        case VES_NORMAL:                return "NORMAL";
-        case VES_DIFFUSE:               return "DIFFUSE";
-        case VES_SPECULAR:              return "SPECULAR";
-        case VES_TEXTURE_COORDINATES:   return "TEXTURE_COORDINATES";
-        case VES_BINORMAL:              return "BINORMAL";
-        case VES_TANGENT:               return "TANGENT";
+std::string VertexElement::SemanticToString(Semantic semantic) {
+    switch (semantic) {
+    case VES_POSITION: return "POSITION";
+    case VES_BLEND_WEIGHTS: return "BLEND_WEIGHTS";
+    case VES_BLEND_INDICES: return "BLEND_INDICES";
+    case VES_NORMAL: return "NORMAL";
+    case VES_DIFFUSE: return "DIFFUSE";
+    case VES_SPECULAR: return "SPECULAR";
+    case VES_TEXTURE_COORDINATES: return "TEXTURE_COORDINATES";
+    case VES_BINORMAL: return "BINORMAL";
+    case VES_TANGENT: return "TANGENT";
     }
     return "Uknown_VertexElement::Semantic";
 }
@@ -243,27 +227,21 @@ std::string VertexElement::SemanticToString(Semantic semantic)
 // IVertexData
 
 IVertexData::IVertexData() :
-    count(0)
-{
+        count(0) {
 }
 
-bool IVertexData::HasBoneAssignments() const
-{
+bool IVertexData::HasBoneAssignments() const {
     return !boneAssignments.empty();
 }
 
-void IVertexData::AddVertexMapping(uint32_t oldIndex, uint32_t newIndex)
-{
+void IVertexData::AddVertexMapping(uint32_t oldIndex, uint32_t newIndex) {
     BoneAssignmentsForVertex(oldIndex, newIndex, boneAssignmentsMap[newIndex]);
     vertexIndexMapping[oldIndex].push_back(newIndex);
 }
 
-void IVertexData::BoneAssignmentsForVertex(uint32_t currentIndex, uint32_t newIndex, VertexBoneAssignmentList &dest) const
-{
-    for (const auto &boneAssign : boneAssignments)
-    {
-        if (boneAssign.vertexIndex == currentIndex)
-        {
+void IVertexData::BoneAssignmentsForVertex(uint32_t currentIndex, uint32_t newIndex, VertexBoneAssignmentList &dest) const {
+    for (const auto &boneAssign : boneAssignments) {
+        if (boneAssign.vertexIndex == currentIndex) {
             VertexBoneAssignment a = boneAssign;
             a.vertexIndex = newIndex;
             dest.push_back(a);
@@ -271,15 +249,12 @@ void IVertexData::BoneAssignmentsForVertex(uint32_t currentIndex, uint32_t newIn
     }
 }
 
-AssimpVertexBoneWeightList IVertexData::AssimpBoneWeights(size_t vertices)
-{
+AssimpVertexBoneWeightList IVertexData::AssimpBoneWeights(size_t vertices) {
     AssimpVertexBoneWeightList weights;
-    for(size_t vi=0; vi<vertices; ++vi)
-    {
+    for (size_t vi = 0; vi < vertices; ++vi) {
         VertexBoneAssignmentList &vertexWeights = boneAssignmentsMap[static_cast<unsigned int>(vi)];
-        for (VertexBoneAssignmentList::const_iterator iter=vertexWeights.begin(), end=vertexWeights.end();
-            iter!=end; ++iter)
-        {
+        for (VertexBoneAssignmentList::const_iterator iter = vertexWeights.begin(), end = vertexWeights.end();
+                iter != end; ++iter) {
             std::vector<aiVertexWeight> &boneWeights = weights[iter->boneIndex];
             boneWeights.push_back(aiVertexWeight(static_cast<unsigned int>(vi), iter->weight));
         }
@@ -287,11 +262,9 @@ AssimpVertexBoneWeightList IVertexData::AssimpBoneWeights(size_t vertices)
     return weights;
 }
 
-std::set<uint16_t> IVertexData::ReferencedBonesByWeights() const
-{
+std::set<uint16_t> IVertexData::ReferencedBonesByWeights() const {
     std::set<uint16_t> referenced;
-    for (const auto &boneAssign : boneAssignments)
-    {
+    for (const auto &boneAssign : boneAssignments) {
         referenced.insert(boneAssign.boneIndex);
     }
     return referenced;
@@ -299,44 +272,36 @@ std::set<uint16_t> IVertexData::ReferencedBonesByWeights() const
 
 // VertexData
 
-VertexData::VertexData()
-{
+VertexData::VertexData() {
 }
 
-VertexData::~VertexData()
-{
+VertexData::~VertexData() {
     Reset();
 }
 
-void VertexData::Reset()
-{
+void VertexData::Reset() {
     // Releases shared ptr memory streams.
     vertexBindings.clear();
     vertexElements.clear();
 }
 
-uint32_t VertexData::VertexSize(uint16_t source) const
-{
+uint32_t VertexData::VertexSize(uint16_t source) const {
     uint32_t size = 0;
-    for(const auto &element : vertexElements)
-    {
+    for (const auto &element : vertexElements) {
         if (element.source == source)
             size += static_cast<uint32_t>(element.Size());
     }
     return size;
 }
 
-MemoryStream *VertexData::VertexBuffer(uint16_t source)
-{
+MemoryStream *VertexData::VertexBuffer(uint16_t source) {
     if (vertexBindings.find(source) != vertexBindings.end())
         return vertexBindings[source].get();
     return 0;
 }
 
-VertexElement *VertexData::GetVertexElement(VertexElement::Semantic semantic, uint16_t index)
-{
-    for(auto & element : vertexElements)
-    {
+VertexElement *VertexData::GetVertexElement(VertexElement::Semantic semantic, uint16_t index) {
+    for (auto &element : vertexElements) {
         if (element.semantic == semantic && element.index == index)
             return &element;
     }
@@ -345,125 +310,108 @@ VertexElement *VertexData::GetVertexElement(VertexElement::Semantic semantic, ui
 
 // VertexDataXml
 
-VertexDataXml::VertexDataXml()
-{
+VertexDataXml::VertexDataXml() {
 }
 
-bool VertexDataXml::HasPositions() const
-{
+bool VertexDataXml::HasPositions() const {
     return !positions.empty();
 }
 
-bool VertexDataXml::HasNormals() const
-{
+bool VertexDataXml::HasNormals() const {
     return !normals.empty();
 }
 
-bool VertexDataXml::HasTangents() const
-{
+bool VertexDataXml::HasTangents() const {
     return !tangents.empty();
 }
 
-bool VertexDataXml::HasUvs() const
-{
+bool VertexDataXml::HasUvs() const {
     return !uvs.empty();
 }
 
-size_t VertexDataXml::NumUvs() const
-{
+size_t VertexDataXml::NumUvs() const {
     return uvs.size();
 }
 
 // IndexData
 
 IndexData::IndexData() :
-    count(0),
-    faceCount(0),
-    is32bit(false)
-{
+        count(0),
+        faceCount(0),
+        is32bit(false) {
 }
 
-IndexData::~IndexData()
-{
+IndexData::~IndexData() {
     Reset();
 }
 
-void IndexData::Reset()
-{
+void IndexData::Reset() {
     // Release shared ptr memory stream.
     buffer.reset();
 }
 
-size_t IndexData::IndexSize() const
-{
+size_t IndexData::IndexSize() const {
     return (is32bit ? sizeof(uint32_t) : sizeof(uint16_t));
 }
 
-size_t IndexData::FaceSize() const
-{
+size_t IndexData::FaceSize() const {
     return IndexSize() * 3;
 }
 
 // Mesh
 
-Mesh::Mesh() 
-    : hasSkeletalAnimations(false)
-    , skeleton(NULL)
-    , sharedVertexData(NULL)
-    , subMeshes()
-    , animations()
-    , poses()
-{
+Mesh::Mesh() :
+        hasSkeletalAnimations(false),
+        skeleton(nullptr),
+        sharedVertexData(nullptr),
+        subMeshes(),
+        animations(),
+        poses() {
 }
 
-Mesh::~Mesh()
-{
+Mesh::~Mesh() {
     Reset();
 }
 
-void Mesh::Reset()
-{
+void Mesh::Reset() {
     OGRE_SAFE_DELETE(skeleton)
     OGRE_SAFE_DELETE(sharedVertexData)
 
-    for(auto &mesh : subMeshes) {
+    for (auto &mesh : subMeshes) {
         OGRE_SAFE_DELETE(mesh)
     }
     subMeshes.clear();
-    for(auto &anim : animations) {
+    for (auto &anim : animations) {
         OGRE_SAFE_DELETE(anim)
     }
     animations.clear();
-    for(auto &pose : poses) {
+    for (auto &pose : poses) {
         OGRE_SAFE_DELETE(pose)
     }
     poses.clear();
 }
 
-size_t Mesh::NumSubMeshes() const
-{
+size_t Mesh::NumSubMeshes() const {
     return subMeshes.size();
 }
 
-SubMesh *Mesh::GetSubMesh( size_t index ) const
-{
-    for ( size_t i = 0; i < subMeshes.size(); ++i ) {
-        if ( subMeshes[ i ]->index == index ) {
-            return subMeshes[ i ];
+SubMesh *Mesh::GetSubMesh(size_t index) const {
+    for (size_t i = 0; i < subMeshes.size(); ++i) {
+        if (subMeshes[i]->index == index) {
+            return subMeshes[i];
         }
     }
     return 0;
 }
 
-void Mesh::ConvertToAssimpScene(aiScene* dest)
-{
-    if ( nullptr == dest ) {
+void Mesh::ConvertToAssimpScene(aiScene *dest) {
+    if (nullptr == dest) {
         return;
     }
 
     // Setup
     dest->mNumMeshes = static_cast<unsigned int>(NumSubMeshes());
-    dest->mMeshes = new aiMesh*[dest->mNumMeshes];
+    dest->mMeshes = new aiMesh *[dest->mNumMeshes];
 
     // Create root node
     dest->mRootNode = new aiNode();
@@ -471,35 +419,30 @@ void Mesh::ConvertToAssimpScene(aiScene* dest)
     dest->mRootNode->mMeshes = new unsigned int[dest->mRootNode->mNumMeshes];
 
     // Export meshes
-    for(size_t i=0; i<dest->mNumMeshes; ++i) {
+    for (size_t i = 0; i < dest->mNumMeshes; ++i) {
         dest->mMeshes[i] = subMeshes[i]->ConvertToAssimpMesh(this);
         dest->mRootNode->mMeshes[i] = static_cast<unsigned int>(i);
     }
 
     // Export skeleton
-    if (skeleton)
-    {
+    if (skeleton) {
         // Bones
-        if (!skeleton->bones.empty())
-        {
+        if (!skeleton->bones.empty()) {
             BoneList rootBones = skeleton->RootBones();
             dest->mRootNode->mNumChildren = static_cast<unsigned int>(rootBones.size());
-            dest->mRootNode->mChildren = new aiNode*[dest->mRootNode->mNumChildren];
+            dest->mRootNode->mChildren = new aiNode *[dest->mRootNode->mNumChildren];
 
-            for(size_t i=0, len=rootBones.size(); i<len; ++i)
-            {
+            for (size_t i = 0, len = rootBones.size(); i < len; ++i) {
                 dest->mRootNode->mChildren[i] = rootBones[i]->ConvertToAssimpNode(skeleton, dest->mRootNode);
             }
         }
 
         // Animations
-        if (!skeleton->animations.empty())
-        {
+        if (!skeleton->animations.empty()) {
             dest->mNumAnimations = static_cast<unsigned int>(skeleton->animations.size());
-            dest->mAnimations = new aiAnimation*[dest->mNumAnimations];
+            dest->mAnimations = new aiAnimation *[dest->mNumAnimations];
 
-            for(size_t i=0, len=skeleton->animations.size(); i<len; ++i)
-            {
+            for (size_t i = 0, len = skeleton->animations.size(); i < len; ++i) {
                 dest->mAnimations[i] = skeleton->animations[i]->ConvertToAssimpAnimation();
             }
         }
@@ -509,36 +452,31 @@ void Mesh::ConvertToAssimpScene(aiScene* dest)
 // ISubMesh
 
 ISubMesh::ISubMesh() :
-    index(0),
-    materialIndex(-1),
-    usesSharedVertexData(false),
-    operationType(OT_POINT_LIST)
-{
+        index(0),
+        materialIndex(-1),
+        usesSharedVertexData(false),
+        operationType(OT_POINT_LIST) {
 }
 
 // SubMesh
 
 SubMesh::SubMesh() :
-    vertexData(0),
-    indexData(new IndexData())
-{
+        vertexData(0),
+        indexData(new IndexData()) {
 }
 
-SubMesh::~SubMesh()
-{
+SubMesh::~SubMesh() {
     Reset();
 }
 
-void SubMesh::Reset()
-{
+void SubMesh::Reset(){
     OGRE_SAFE_DELETE(vertexData)
-    OGRE_SAFE_DELETE(indexData)
+            OGRE_SAFE_DELETE(indexData)
 }
 
-aiMesh *SubMesh::ConvertToAssimpMesh(Mesh *parent)
-{
+aiMesh *SubMesh::ConvertToAssimpMesh(Mesh *parent) {
     if (operationType != OT_TRIANGLE_LIST) {
-        throw DeadlyImportError(Formatter::format() << "Only mesh operation type OT_TRIANGLE_LIST is supported. Found " << operationType);
+        throw DeadlyImportError("Only mesh operation type OT_TRIANGLE_LIST is supported. Found ", operationType);
     }
 
     aiMesh *dest = new aiMesh();
@@ -555,9 +493,9 @@ aiMesh *SubMesh::ConvertToAssimpMesh(Mesh *parent)
     VertexData *src = (!usesSharedVertexData ? vertexData : parent->sharedVertexData);
 
     VertexElement *positionsElement = src->GetVertexElement(VertexElement::VES_POSITION);
-    VertexElement *normalsElement   = src->GetVertexElement(VertexElement::VES_NORMAL);
-    VertexElement *uv1Element       = src->GetVertexElement(VertexElement::VES_TEXTURE_COORDINATES, 0);
-    VertexElement *uv2Element       = src->GetVertexElement(VertexElement::VES_TEXTURE_COORDINATES, 1);
+    VertexElement *normalsElement = src->GetVertexElement(VertexElement::VES_NORMAL);
+    VertexElement *uv1Element = src->GetVertexElement(VertexElement::VES_TEXTURE_COORDINATES, 0);
+    VertexElement *uv2Element = src->GetVertexElement(VertexElement::VES_TEXTURE_COORDINATES, 1);
 
     // Sanity checks
     if (!positionsElement) {
@@ -578,22 +516,22 @@ aiMesh *SubMesh::ConvertToAssimpMesh(Mesh *parent)
     dest->mVertices = new aiVector3D[dest->mNumVertices];
 
     // Source streams
-    MemoryStream *positions      = src->VertexBuffer(positionsElement->source);
-    MemoryStream *normals        = (normalsElement ? src->VertexBuffer(normalsElement->source) : 0);
-    MemoryStream *uv1            = (uv1Element ? src->VertexBuffer(uv1Element->source) : 0);
-    MemoryStream *uv2            = (uv2Element ? src->VertexBuffer(uv2Element->source) : 0);
+    MemoryStream *positions = src->VertexBuffer(positionsElement->source);
+    MemoryStream *normals = (normalsElement ? src->VertexBuffer(normalsElement->source) : 0);
+    MemoryStream *uv1 = (uv1Element ? src->VertexBuffer(uv1Element->source) : 0);
+    MemoryStream *uv2 = (uv2Element ? src->VertexBuffer(uv2Element->source) : 0);
 
     // Element size
-    const size_t sizePosition    = positionsElement->Size();
-    const size_t sizeNormal      = (normalsElement ? normalsElement->Size() : 0);
-    const size_t sizeUv1         = (uv1Element ? uv1Element->Size() : 0);
-    const size_t sizeUv2         = (uv2Element ? uv2Element->Size() : 0);
+    const size_t sizePosition = positionsElement->Size();
+    const size_t sizeNormal = (normalsElement ? normalsElement->Size() : 0);
+    const size_t sizeUv1 = (uv1Element ? uv1Element->Size() : 0);
+    const size_t sizeUv2 = (uv2Element ? uv2Element->Size() : 0);
 
     // Vertex width
-    const size_t vWidthPosition  = src->VertexSize(positionsElement->source);
-    const size_t vWidthNormal    = (normalsElement ? src->VertexSize(normalsElement->source) : 0);
-    const size_t vWidthUv1       = (uv1Element ? src->VertexSize(uv1Element->source) : 0);
-    const size_t vWidthUv2       = (uv2Element ? src->VertexSize(uv2Element->source) : 0);
+    const size_t vWidthPosition = src->VertexSize(positionsElement->source);
+    const size_t vWidthNormal = (normalsElement ? src->VertexSize(normalsElement->source) : 0);
+    const size_t vWidthUv1 = (uv1Element ? src->VertexSize(uv1Element->source) : 0);
+    const size_t vWidthUv2 = (uv2Element ? src->VertexSize(uv2Element->source) : 0);
 
     bool boneAssignments = src->HasBoneAssignments();
 
@@ -602,29 +540,21 @@ aiMesh *SubMesh::ConvertToAssimpMesh(Mesh *parent)
         dest->mNormals = new aiVector3D[dest->mNumVertices];
 
     // Prepare UVs, ignoring incompatible UVs.
-    if (uv1)
-    {
-        if (uv1Element->type == VertexElement::VET_FLOAT2 || uv1Element->type == VertexElement::VET_FLOAT3)
-        {
+    if (uv1) {
+        if (uv1Element->type == VertexElement::VET_FLOAT2 || uv1Element->type == VertexElement::VET_FLOAT3) {
             dest->mNumUVComponents[0] = static_cast<unsigned int>(uv1Element->ComponentCount());
             dest->mTextureCoords[0] = new aiVector3D[dest->mNumVertices];
-        }
-        else
-        {
-            ASSIMP_LOG_WARN(Formatter::format() << "Ogre imported UV0 type " << uv1Element->TypeToString() << " is not compatible with Assimp. Ignoring UV.");
+        } else {
+            ASSIMP_LOG_WARN("Ogre imported UV0 type ", uv1Element->TypeToString(), " is not compatible with Assimp. Ignoring UV.");
             uv1 = 0;
         }
     }
-    if (uv2)
-    {
-        if (uv2Element->type == VertexElement::VET_FLOAT2 || uv2Element->type == VertexElement::VET_FLOAT3)
-        {
+    if (uv2) {
+        if (uv2Element->type == VertexElement::VET_FLOAT2 || uv2Element->type == VertexElement::VET_FLOAT3) {
             dest->mNumUVComponents[1] = static_cast<unsigned int>(uv2Element->ComponentCount());
             dest->mTextureCoords[1] = new aiVector3D[dest->mNumVertices];
-        }
-        else
-        {
-            ASSIMP_LOG_WARN(Formatter::format() << "Ogre imported UV0 type " << uv2Element->TypeToString() << " is not compatible with Assimp. Ignoring UV.");
+        } else {
+            ASSIMP_LOG_WARN("Ogre imported UV0 type ", uv2Element->TypeToString(), " is not compatible with Assimp. Ignoring UV.");
             uv2 = 0;
         }
     }
@@ -633,24 +563,19 @@ aiMesh *SubMesh::ConvertToAssimpMesh(Mesh *parent)
     aiVector3D *uv2Dest = (uv2 ? dest->mTextureCoords[1] : 0);
 
     MemoryStream *faces = indexData->buffer.get();
-    for (size_t fi=0, isize=indexData->IndexSize(), fsize=indexData->FaceSize();
-         fi<dest->mNumFaces; ++fi)
-    {
+    for (size_t fi = 0, isize = indexData->IndexSize(), fsize = indexData->FaceSize();
+            fi < dest->mNumFaces; ++fi) {
         // Source Ogre face
         aiFace ogreFace;
         ogreFace.mNumIndices = 3;
         ogreFace.mIndices = new unsigned int[3];
 
         faces->Seek(fi * fsize, aiOrigin_SET);
-        if (indexData->is32bit)
-        {
+        if (indexData->is32bit) {
             faces->Read(&ogreFace.mIndices[0], isize, 3);
-        }
-        else
-        {
+        } else {
             uint16_t iout = 0;
-            for (size_t ii=0; ii<3; ++ii)
-            {
+            for (size_t ii = 0; ii < 3; ++ii) {
                 faces->Read(&iout, isize, 1);
                 ogreFace.mIndices[ii] = static_cast<unsigned int>(iout);
             }
@@ -662,8 +587,7 @@ aiMesh *SubMesh::ConvertToAssimpMesh(Mesh *parent)
         face.mIndices = new unsigned int[3];
 
         const size_t pos = fi * 3;
-        for (size_t v=0; v<3; ++v)
-        {
+        for (size_t v = 0; v < 3; ++v) {
             const size_t newIndex = pos + v;
 
             // Write face index
@@ -678,21 +602,18 @@ aiMesh *SubMesh::ConvertToAssimpMesh(Mesh *parent)
             positions->Read(&dest->mVertices[newIndex], sizePosition, 1);
 
             // Normal
-            if (normals)
-            {
+            if (normals) {
                 normals->Seek((vWidthNormal * ogreVertexIndex) + normalsElement->offset, aiOrigin_SET);
                 normals->Read(&dest->mNormals[newIndex], sizeNormal, 1);
             }
             // UV0
-            if (uv1 && uv1Dest)
-            {
+            if (uv1 && uv1Dest) {
                 uv1->Seek((vWidthUv1 * ogreVertexIndex) + uv1Element->offset, aiOrigin_SET);
                 uv1->Read(&uv1Dest[newIndex], sizeUv1, 1);
                 uv1Dest[newIndex].y = (uv1Dest[newIndex].y * -1) + 1; // Flip UV from Ogre to Assimp form
             }
             // UV1
-            if (uv2 && uv2Dest)
-            {
+            if (uv2 && uv2Dest) {
                 uv2->Seek((vWidthUv2 * ogreVertexIndex) + uv2Element->offset, aiOrigin_SET);
                 uv2->Read(&uv2Dest[newIndex], sizeUv2, 1);
                 uv2Dest[newIndex].y = (uv2Dest[newIndex].y * -1) + 1; // Flip UV from Ogre to Assimp form
@@ -701,17 +622,15 @@ aiMesh *SubMesh::ConvertToAssimpMesh(Mesh *parent)
     }
 
     // Bones and bone weights
-    if (parent->skeleton && boneAssignments)
-    {
+    if (parent->skeleton && boneAssignments) {
         AssimpVertexBoneWeightList weights = src->AssimpBoneWeights(dest->mNumVertices);
         std::set<uint16_t> referencedBones = src->ReferencedBonesByWeights();
 
         dest->mNumBones = static_cast<unsigned int>(referencedBones.size());
-        dest->mBones = new aiBone*[dest->mNumBones];
+        dest->mBones = new aiBone *[dest->mNumBones];
 
         size_t assimpBoneIndex = 0;
-        for(std::set<uint16_t>::const_iterator rbIter=referencedBones.begin(), rbEnd=referencedBones.end(); rbIter != rbEnd; ++rbIter, ++assimpBoneIndex)
-        {
+        for (std::set<uint16_t>::const_iterator rbIter = referencedBones.begin(), rbEnd = referencedBones.end(); rbIter != rbEnd; ++rbIter, ++assimpBoneIndex) {
             Bone *bone = parent->skeleton->BoneById((*rbIter));
             dest->mBones[assimpBoneIndex] = bone->ConvertToAssimpBone(parent->skeleton, weights[bone->id]);
         }
@@ -723,45 +642,39 @@ aiMesh *SubMesh::ConvertToAssimpMesh(Mesh *parent)
 // MeshXml
 
 MeshXml::MeshXml() :
-    skeleton(0),
-    sharedVertexData(0)
-{
+        skeleton(0),
+        sharedVertexData(0) {
 }
 
-MeshXml::~MeshXml()
-{
+MeshXml::~MeshXml() {
     Reset();
 }
 
-void MeshXml::Reset()
-{
+void MeshXml::Reset() {
     OGRE_SAFE_DELETE(skeleton)
     OGRE_SAFE_DELETE(sharedVertexData)
 
-    for(auto &mesh : subMeshes) {
+    for (auto &mesh : subMeshes) {
         OGRE_SAFE_DELETE(mesh)
     }
     subMeshes.clear();
 }
 
-size_t MeshXml::NumSubMeshes() const
-{
+size_t MeshXml::NumSubMeshes() const {
     return subMeshes.size();
 }
 
-SubMeshXml *MeshXml::GetSubMesh(uint16_t index) const
-{
-    for(size_t i=0; i<subMeshes.size(); ++i)
+SubMeshXml *MeshXml::GetSubMesh(uint16_t index) const {
+    for (size_t i = 0; i < subMeshes.size(); ++i)
         if (subMeshes[i]->index == index)
             return subMeshes[i];
     return 0;
 }
 
-void MeshXml::ConvertToAssimpScene(aiScene* dest)
-{
+void MeshXml::ConvertToAssimpScene(aiScene *dest) {
     // Setup
     dest->mNumMeshes = static_cast<unsigned int>(NumSubMeshes());
-    dest->mMeshes = new aiMesh*[dest->mNumMeshes];
+    dest->mMeshes = new aiMesh *[dest->mNumMeshes];
 
     // Create root node
     dest->mRootNode = new aiNode();
@@ -769,36 +682,30 @@ void MeshXml::ConvertToAssimpScene(aiScene* dest)
     dest->mRootNode->mMeshes = new unsigned int[dest->mRootNode->mNumMeshes];
 
     // Export meshes
-    for(size_t i=0; i<dest->mNumMeshes; ++i)
-    {
+    for (size_t i = 0; i < dest->mNumMeshes; ++i) {
         dest->mMeshes[i] = subMeshes[i]->ConvertToAssimpMesh(this);
         dest->mRootNode->mMeshes[i] = static_cast<unsigned int>(i);
     }
 
     // Export skeleton
-    if (skeleton)
-    {
+    if (skeleton) {
         // Bones
-        if (!skeleton->bones.empty())
-        {
+        if (!skeleton->bones.empty()) {
             BoneList rootBones = skeleton->RootBones();
             dest->mRootNode->mNumChildren = static_cast<unsigned int>(rootBones.size());
-            dest->mRootNode->mChildren = new aiNode*[dest->mRootNode->mNumChildren];
+            dest->mRootNode->mChildren = new aiNode *[dest->mRootNode->mNumChildren];
 
-            for(size_t i=0, len=rootBones.size(); i<len; ++i)
-            {
+            for (size_t i = 0, len = rootBones.size(); i < len; ++i) {
                 dest->mRootNode->mChildren[i] = rootBones[i]->ConvertToAssimpNode(skeleton, dest->mRootNode);
             }
         }
 
         // Animations
-        if (!skeleton->animations.empty())
-        {
+        if (!skeleton->animations.empty()) {
             dest->mNumAnimations = static_cast<unsigned int>(skeleton->animations.size());
-            dest->mAnimations = new aiAnimation*[dest->mNumAnimations];
+            dest->mAnimations = new aiAnimation *[dest->mNumAnimations];
 
-            for(size_t i=0, len=skeleton->animations.size(); i<len; ++i)
-            {
+            for (size_t i = 0, len = skeleton->animations.size(); i < len; ++i) {
                 dest->mAnimations[i] = skeleton->animations[i]->ConvertToAssimpAnimation();
             }
         }
@@ -808,24 +715,20 @@ void MeshXml::ConvertToAssimpScene(aiScene* dest)
 // SubMeshXml
 
 SubMeshXml::SubMeshXml() :
-    indexData(new IndexDataXml()),
-    vertexData(0)
-{
+        indexData(new IndexDataXml()),
+        vertexData(0) {
 }
 
-SubMeshXml::~SubMeshXml()
-{
+SubMeshXml::~SubMeshXml() {
     Reset();
 }
 
-void SubMeshXml::Reset()
-{
+void SubMeshXml::Reset(){
     OGRE_SAFE_DELETE(indexData)
-    OGRE_SAFE_DELETE(vertexData)
+            OGRE_SAFE_DELETE(vertexData)
 }
 
-aiMesh *SubMeshXml::ConvertToAssimpMesh(MeshXml *parent)
-{
+aiMesh *SubMeshXml::ConvertToAssimpMesh(MeshXml *parent) {
     aiMesh *dest = new aiMesh();
     dest->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
 
@@ -855,14 +758,12 @@ aiMesh *SubMeshXml::ConvertToAssimpMesh(MeshXml *parent)
         dest->mNormals = new aiVector3D[dest->mNumVertices];
 
     // Prepare UVs
-    for(size_t uvi=0; uvi<uvs; ++uvi)
-    {
+    for (size_t uvi = 0; uvi < uvs; ++uvi) {
         dest->mNumUVComponents[uvi] = 2;
         dest->mTextureCoords[uvi] = new aiVector3D[dest->mNumVertices];
     }
 
-    for (size_t fi=0; fi<dest->mNumFaces; ++fi)
-    {
+    for (size_t fi = 0; fi < dest->mNumFaces; ++fi) {
         // Source Ogre face
         aiFace &ogreFace = indexData->faces[fi];
 
@@ -872,8 +773,7 @@ aiMesh *SubMeshXml::ConvertToAssimpMesh(MeshXml *parent)
         face.mIndices = new unsigned int[3];
 
         const size_t pos = fi * 3;
-        for (size_t v=0; v<3; ++v)
-        {
+        for (size_t v = 0; v < 3; ++v) {
             const size_t newIndex = pos + v;
 
             // Write face index
@@ -891,8 +791,7 @@ aiMesh *SubMeshXml::ConvertToAssimpMesh(MeshXml *parent)
                 dest->mNormals[newIndex] = src->normals[ogreVertexIndex];
 
             // UVs
-            for(size_t uvi=0; uvi<uvs; ++uvi)
-            {
+            for (size_t uvi = 0; uvi < uvs; ++uvi) {
                 aiVector3D *uvDest = dest->mTextureCoords[uvi];
                 std::vector<aiVector3D> &uvSrc = src->uvs[uvi];
                 uvDest[newIndex] = uvSrc[ogreVertexIndex];
@@ -901,17 +800,15 @@ aiMesh *SubMeshXml::ConvertToAssimpMesh(MeshXml *parent)
     }
 
     // Bones and bone weights
-    if (parent->skeleton && boneAssignments)
-    {
+    if (parent->skeleton && boneAssignments) {
         AssimpVertexBoneWeightList weights = src->AssimpBoneWeights(dest->mNumVertices);
         std::set<uint16_t> referencedBones = src->ReferencedBonesByWeights();
 
         dest->mNumBones = static_cast<unsigned int>(referencedBones.size());
-        dest->mBones = new aiBone*[dest->mNumBones];
+        dest->mBones = new aiBone *[dest->mNumBones];
 
         size_t assimpBoneIndex = 0;
-        for(std::set<uint16_t>::const_iterator rbIter=referencedBones.begin(), rbEnd=referencedBones.end(); rbIter != rbEnd; ++rbIter, ++assimpBoneIndex)
-        {
+        for (std::set<uint16_t>::const_iterator rbIter = referencedBones.begin(), rbEnd = referencedBones.end(); rbIter != rbEnd; ++rbIter, ++assimpBoneIndex) {
             Bone *bone = parent->skeleton->BoneById((*rbIter));
             dest->mBones[assimpBoneIndex] = bone->ConvertToAssimpBone(parent->skeleton, weights[bone->id]);
         }
@@ -923,48 +820,46 @@ aiMesh *SubMeshXml::ConvertToAssimpMesh(MeshXml *parent)
 // Animation
 
 Animation::Animation(Skeleton *parent) :
-    parentMesh(NULL),
-    parentSkeleton(parent),
-    length(0.0f),
-    baseTime(-1.0f)
-{
+        parentMesh(nullptr),
+        parentSkeleton(parent),
+        length(0.0f),
+        baseTime(-1.0f) {
+    // empty
 }
 
 Animation::Animation(Mesh *parent) :
-    parentMesh(parent),
-    parentSkeleton(0),
-    length(0.0f),
-    baseTime(-1.0f)
-{
+        parentMesh(parent),
+        parentSkeleton(0),
+        length(0.0f),
+        baseTime(-1.0f) {
+    // empty
 }
 
-VertexData *Animation::AssociatedVertexData(VertexAnimationTrack *track) const
-{
-    if (!parentMesh)
-        return 0;
+VertexData *Animation::AssociatedVertexData(VertexAnimationTrack *track) const {
+    if (nullptr == parentMesh) {
+        return nullptr;
+    }
 
     bool sharedGeom = (track->target == 0);
-    if (sharedGeom)
+    if (sharedGeom) {
         return parentMesh->sharedVertexData;
-    else
-        return parentMesh->GetSubMesh(track->target-1)->vertexData;
+    }
+
+    return parentMesh->GetSubMesh(track->target - 1)->vertexData;
 }
 
-aiAnimation *Animation::ConvertToAssimpAnimation()
-{
+aiAnimation *Animation::ConvertToAssimpAnimation() {
     aiAnimation *anim = new aiAnimation();
     anim->mName = name;
     anim->mDuration = static_cast<double>(length);
     anim->mTicksPerSecond = 1.0;
 
     // Tracks
-    if (!tracks.empty())
-    {
+    if (!tracks.empty()) {
         anim->mNumChannels = static_cast<unsigned int>(tracks.size());
-        anim->mChannels = new aiNodeAnim*[anim->mNumChannels];
+        anim->mChannels = new aiNodeAnim *[anim->mNumChannels];
 
-        for(size_t i=0, len=tracks.size(); i<len; ++i)
-        {
+        for (size_t i = 0, len = tracks.size(); i < len; ++i) {
             anim->mChannels[i] = tracks[i].ConvertToAssimpAnimationNode(parentSkeleton);
         }
     }
@@ -974,65 +869,54 @@ aiAnimation *Animation::ConvertToAssimpAnimation()
 // Skeleton
 
 Skeleton::Skeleton() :
-    bones(),
-    animations(),
-    blendMode(ANIMBLEND_AVERAGE)
-{
+        bones(),
+        animations(),
+        blendMode(ANIMBLEND_AVERAGE) {
 }
 
-Skeleton::~Skeleton()
-{
+Skeleton::~Skeleton() {
     Reset();
 }
 
-void Skeleton::Reset()
-{
-    for(auto &bone : bones) {
+void Skeleton::Reset() {
+    for (auto &bone : bones) {
         OGRE_SAFE_DELETE(bone)
     }
     bones.clear();
-    for(auto &anim : animations) {
+    for (auto &anim : animations) {
         OGRE_SAFE_DELETE(anim)
     }
     animations.clear();
 }
 
-BoneList Skeleton::RootBones() const
-{
+BoneList Skeleton::RootBones() const {
     BoneList rootBones;
-    for(BoneList::const_iterator iter = bones.begin(); iter != bones.end(); ++iter)
-    {
+    for (BoneList::const_iterator iter = bones.begin(); iter != bones.end(); ++iter) {
         if (!(*iter)->IsParented())
             rootBones.push_back((*iter));
     }
     return rootBones;
 }
 
-size_t Skeleton::NumRootBones() const
-{
+size_t Skeleton::NumRootBones() const {
     size_t num = 0;
-    for(BoneList::const_iterator iter = bones.begin(); iter != bones.end(); ++iter)
-    {
+    for (BoneList::const_iterator iter = bones.begin(); iter != bones.end(); ++iter) {
         if (!(*iter)->IsParented())
             num++;
     }
     return num;
 }
 
-Bone *Skeleton::BoneByName(const std::string &name) const
-{
-    for(BoneList::const_iterator iter = bones.begin(); iter != bones.end(); ++iter)
-    {
+Bone *Skeleton::BoneByName(const std::string &name) const {
+    for (BoneList::const_iterator iter = bones.begin(); iter != bones.end(); ++iter) {
         if ((*iter)->name == name)
             return (*iter);
     }
     return 0;
 }
 
-Bone *Skeleton::BoneById(uint16_t id) const
-{
-    for(BoneList::const_iterator iter = bones.begin(); iter != bones.end(); ++iter)
-    {
+Bone *Skeleton::BoneById(uint16_t id) const {
+    for (BoneList::const_iterator iter = bones.begin(); iter != bones.end(); ++iter) {
         if ((*iter)->id == id)
             return (*iter);
     }
@@ -1042,37 +926,32 @@ Bone *Skeleton::BoneById(uint16_t id) const
 // Bone
 
 Bone::Bone() :
-    id(0),
-    parent(0),
-    parentId(-1),
-    scale(1.0f, 1.0f, 1.0f)
-{
+        id(0),
+        parent(0),
+        parentId(-1),
+        scale(1.0f, 1.0f, 1.0f) {
 }
 
-bool Bone::IsParented() const
-{
+bool Bone::IsParented() const {
     return (parentId != -1 && parent != 0);
 }
 
-uint16_t Bone::ParentId() const
-{
+uint16_t Bone::ParentId() const {
     return static_cast<uint16_t>(parentId);
 }
 
-void Bone::AddChild(Bone *bone)
-{
+void Bone::AddChild(Bone *bone) {
     if (!bone)
         return;
     if (bone->IsParented())
-        throw DeadlyImportError("Attaching child Bone that is already parented: " + bone->name);
+        throw DeadlyImportError("Attaching child Bone that is already parented: ", bone->name);
 
     bone->parent = this;
     bone->parentId = id;
     children.push_back(bone->id);
 }
 
-void Bone::CalculateWorldMatrixAndDefaultPose(Skeleton *skeleton)
-{
+void Bone::CalculateWorldMatrixAndDefaultPose(Skeleton *skeleton) {
     if (!IsParented())
         worldMatrix = aiMatrix4x4(scale, rotation, position).Inverse();
     else
@@ -1081,34 +960,30 @@ void Bone::CalculateWorldMatrixAndDefaultPose(Skeleton *skeleton)
     defaultPose = aiMatrix4x4(scale, rotation, position);
 
     // Recursively for all children now that the parent matrix has been calculated.
-    for (auto boneId : children)
-    {
+    for (auto boneId : children) {
         Bone *child = skeleton->BoneById(boneId);
         if (!child) {
-            throw DeadlyImportError(Formatter::format() << "CalculateWorldMatrixAndDefaultPose: Failed to find child bone " << boneId << " for parent " << id << " " << name);
+            throw DeadlyImportError("CalculateWorldMatrixAndDefaultPose: Failed to find child bone ", boneId, " for parent ", id, " ", name);
         }
         child->CalculateWorldMatrixAndDefaultPose(skeleton);
     }
 }
 
-aiNode *Bone::ConvertToAssimpNode(Skeleton *skeleton, aiNode *parentNode)
-{
+aiNode *Bone::ConvertToAssimpNode(Skeleton *skeleton, aiNode *parentNode) {
     // Bone node
-    aiNode* node = new aiNode(name);
+    aiNode *node = new aiNode(name);
     node->mParent = parentNode;
     node->mTransformation = defaultPose;
 
     // Children
-    if (!children.empty())
-    {
+    if (!children.empty()) {
         node->mNumChildren = static_cast<unsigned int>(children.size());
-        node->mChildren = new aiNode*[node->mNumChildren];
+        node->mChildren = new aiNode *[node->mNumChildren];
 
-        for(size_t i=0, len=children.size(); i<len; ++i)
-        {
+        for (size_t i = 0, len = children.size(); i < len; ++i) {
             Bone *child = skeleton->BoneById(children[i]);
             if (!child) {
-                throw DeadlyImportError(Formatter::format() << "ConvertToAssimpNode: Failed to find child bone " << children[i] << " for parent " << id << " " << name);
+                throw DeadlyImportError("ConvertToAssimpNode: Failed to find child bone ", children[i], " for parent ", id, " ", name);
             }
             node->mChildren[i] = child->ConvertToAssimpNode(skeleton, node);
         }
@@ -1116,14 +991,12 @@ aiNode *Bone::ConvertToAssimpNode(Skeleton *skeleton, aiNode *parentNode)
     return node;
 }
 
-aiBone *Bone::ConvertToAssimpBone(Skeleton * /*parent*/, const std::vector<aiVertexWeight> &boneWeights)
-{
+aiBone *Bone::ConvertToAssimpBone(Skeleton * /*parent*/, const std::vector<aiVertexWeight> &boneWeights) {
     aiBone *bone = new aiBone();
     bone->mName = name;
     bone->mOffsetMatrix = worldMatrix;
 
-    if (!boneWeights.empty())
-    {
+    if (!boneWeights.empty()) {
         bone->mNumWeights = static_cast<unsigned int>(boneWeights.size());
         bone->mWeights = new aiVertexWeight[boneWeights.size()];
         memcpy(bone->mWeights, &boneWeights[0], boneWeights.size() * sizeof(aiVertexWeight));
@@ -1135,13 +1008,11 @@ aiBone *Bone::ConvertToAssimpBone(Skeleton * /*parent*/, const std::vector<aiVer
 // VertexAnimationTrack
 
 VertexAnimationTrack::VertexAnimationTrack() :
-    type(VAT_NONE),
-    target(0)
-{
+        type(VAT_NONE),
+        target(0) {
 }
 
-aiNodeAnim *VertexAnimationTrack::ConvertToAssimpAnimationNode(Skeleton *skeleton)
-{
+aiNodeAnim *VertexAnimationTrack::ConvertToAssimpAnimationNode(Skeleton *skeleton) {
     if (boneName.empty() || type != VAT_TRANSFORM) {
         throw DeadlyImportError("VertexAnimationTrack::ConvertToAssimpAnimationNode: Cannot convert track that has no target bone name or is not type of VAT_TRANSFORM");
     }
@@ -1151,7 +1022,7 @@ aiNodeAnim *VertexAnimationTrack::ConvertToAssimpAnimationNode(Skeleton *skeleto
 
     Bone *bone = skeleton->BoneByName(boneName);
     if (!bone) {
-        throw DeadlyImportError("VertexAnimationTrack::ConvertToAssimpAnimationNode: Failed to find bone " + boneName + " from parent Skeleton");
+        throw DeadlyImportError("VertexAnimationTrack::ConvertToAssimpAnimationNode: Failed to find bone ", boneName, " from parent Skeleton");
     }
 
     // Keyframes
@@ -1162,14 +1033,15 @@ aiNodeAnim *VertexAnimationTrack::ConvertToAssimpAnimationNode(Skeleton *skeleto
     nodeAnim->mScalingKeys = new aiVectorKey[numKeyframes];
     nodeAnim->mNumPositionKeys = static_cast<unsigned int>(numKeyframes);
     nodeAnim->mNumRotationKeys = static_cast<unsigned int>(numKeyframes);
-    nodeAnim->mNumScalingKeys  = static_cast<unsigned int>(numKeyframes);
+    nodeAnim->mNumScalingKeys = static_cast<unsigned int>(numKeyframes);
 
-    for(size_t kfi=0; kfi<numKeyframes; ++kfi)
-    {
+    for (size_t kfi = 0; kfi < numKeyframes; ++kfi) {
         TransformKeyFrame &kfSource = transformKeyFrames[kfi];
 
         // Calculate the complete transformation from world space to bone space
-        aiVector3D pos; aiQuaternion rot; aiVector3D scale;
+        aiVector3D pos;
+        aiQuaternion rot;
+        aiVector3D scale;
 
         aiMatrix4x4 finalTransform = bone->defaultPose * kfSource.Transform();
         finalTransform.Decompose(scale, rot, pos);
@@ -1190,17 +1062,15 @@ aiNodeAnim *VertexAnimationTrack::ConvertToAssimpAnimationNode(Skeleton *skeleto
 // TransformKeyFrame
 
 TransformKeyFrame::TransformKeyFrame() :
-    timePos(0.0f),
-    scale(1.0f, 1.0f, 1.0f)
-{
+        timePos(0.0f),
+        scale(1.0f, 1.0f, 1.0f) {
 }
 
-aiMatrix4x4 TransformKeyFrame::Transform()
-{
+aiMatrix4x4 TransformKeyFrame::Transform() {
     return aiMatrix4x4(scale, rotation, position);
 }
 
-} // Ogre
-} // Assimp
+} // namespace Ogre
+} // namespace Assimp
 
 #endif // ASSIMP_BUILD_NO_OGRE_IMPORTER
diff --git a/Engine/lib/assimp/code/Ogre/OgreStructs.h b/Engine/lib/assimp/code/AssetLib/Ogre/OgreStructs.h
similarity index 99%
rename from Engine/lib/assimp/code/Ogre/OgreStructs.h
rename to Engine/lib/assimp/code/AssetLib/Ogre/OgreStructs.h
index 6ea211e10..be9ffa02d 100644
--- a/Engine/lib/assimp/code/Ogre/OgreStructs.h
+++ b/Engine/lib/assimp/code/AssetLib/Ogre/OgreStructs.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -555,7 +555,7 @@ public:
         should be 0 after this reset. */
     void Reset();
 
-    /// Covert to Assimp mesh.
+    /// Convert to Assimp mesh.
     aiMesh *ConvertToAssimpMesh(Mesh *parent);
 
     /// Vertex data.
diff --git a/Engine/lib/assimp/code/AssetLib/Ogre/OgreXmlSerializer.cpp b/Engine/lib/assimp/code/AssetLib/Ogre/OgreXmlSerializer.cpp
new file mode 100644
index 000000000..545107ea3
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Ogre/OgreXmlSerializer.cpp
@@ -0,0 +1,755 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#include "OgreXmlSerializer.h"
+#include "OgreBinarySerializer.h"
+#include "OgreParsingUtils.h"
+
+#include <assimp/TinyFormatter.h>
+#include <assimp/DefaultLogger.hpp>
+
+#include <memory>
+
+#ifndef ASSIMP_BUILD_NO_OGRE_IMPORTER
+
+// Define as 1 to get verbose logging.
+#define OGRE_XML_SERIALIZER_DEBUG 0
+
+namespace Assimp {
+namespace Ogre {
+
+//AI_WONT_RETURN void ThrowAttibuteError(const XmlParser *reader, const std::string &name, const std::string &error = "") AI_WONT_RETURN_SUFFIX;
+
+AI_WONT_RETURN void ThrowAttibuteError(const std::string &nodeName, const std::string &name, const std::string &error) {
+    if (!error.empty()) {
+        throw DeadlyImportError(error, " in node '", nodeName, "' and attribute '", name, "'");
+    } else {
+        throw DeadlyImportError("Attribute '", name, "' does not exist in node '", nodeName, "'");
+    }
+}
+
+template <>
+int32_t OgreXmlSerializer::ReadAttribute<int32_t>(XmlNode &xmlNode, const char *name) const {
+    if (!XmlParser::hasAttribute(xmlNode, name)) {
+        ThrowAttibuteError(xmlNode.name(), name, "Not found");
+    }
+    pugi::xml_attribute attr = xmlNode.attribute(name);
+    return static_cast<int32_t>(attr.as_int());
+}
+
+template <>
+uint32_t OgreXmlSerializer::ReadAttribute<uint32_t>(XmlNode &xmlNode, const char *name) const {
+    if (!XmlParser::hasAttribute(xmlNode, name)) {
+        ThrowAttibuteError(xmlNode.name(), name, "Not found");
+    }
+
+    // @note This is hackish. But we are never expecting unsigned values that go outside the
+    //       int32_t range. Just monitor for negative numbers and kill the import.
+    int32_t temp = ReadAttribute<int32_t>(xmlNode, name);
+    if (temp < 0) {
+        ThrowAttibuteError(xmlNode.name(), name, "Found a negative number value where expecting a uint32_t value");
+    }
+
+    return static_cast<uint32_t>(temp);
+}
+
+template <>
+uint16_t OgreXmlSerializer::ReadAttribute<uint16_t>(XmlNode &xmlNode, const char *name) const {
+    if (!XmlParser::hasAttribute(xmlNode, name)) {
+        ThrowAttibuteError(xmlNode.name(), name, "Not found");
+    }
+
+    return static_cast<uint16_t>(xmlNode.attribute(name).as_int());
+}
+
+template <>
+float OgreXmlSerializer::ReadAttribute<float>(XmlNode &xmlNode, const char *name) const {
+    if (!XmlParser::hasAttribute(xmlNode, name)) {
+        ThrowAttibuteError(xmlNode.name(), name, "Not found");
+    }
+
+    return xmlNode.attribute(name).as_float();
+}
+
+template <>
+std::string OgreXmlSerializer::ReadAttribute<std::string>(XmlNode &xmlNode, const char *name) const {
+    if (!XmlParser::hasAttribute(xmlNode, name)) {
+        ThrowAttibuteError(xmlNode.name(), name, "Not found");
+    }
+
+    return xmlNode.attribute(name).as_string();
+}
+
+template <>
+bool OgreXmlSerializer::ReadAttribute<bool>(XmlNode &xmlNode, const char *name) const {
+    std::string value = ai_tolower(ReadAttribute<std::string>(xmlNode, name));
+    if (ASSIMP_stricmp(value, "true") == 0) {
+        return true;
+    } else if (ASSIMP_stricmp(value, "false") == 0) {
+        return false;
+    }
+
+    ThrowAttibuteError(xmlNode.name(), name, "Boolean value is expected to be 'true' or 'false', encountered '" + value + "'");
+    return false;
+}
+
+// Mesh XML constants
+
+// <mesh>
+static const char *nnMesh = "mesh";
+static const char *nnSharedGeometry = "sharedgeometry";
+static const char *nnSubMeshes = "submeshes";
+static const char *nnSubMesh = "submesh";
+//static const char *nnSubMeshNames = "submeshnames";
+static const char *nnSkeletonLink = "skeletonlink";
+//static const char *nnLOD = "levelofdetail";
+//static const char *nnExtremes = "extremes";
+//static const char *nnPoses = "poses";
+static const char *nnAnimations = "animations";
+
+// <submesh>
+static const char *nnFaces = "faces";
+static const char *nnFace = "face";
+static const char *nnGeometry = "geometry";
+//static const char *nnTextures = "textures";
+
+// <mesh/submesh>
+static const char *nnBoneAssignments = "boneassignments";
+
+// <sharedgeometry/geometry>
+static const char *nnVertexBuffer = "vertexbuffer";
+
+// <vertexbuffer>
+//static const char *nnVertex = "vertex";
+static const char *nnPosition = "position";
+static const char *nnNormal = "normal";
+static const char *nnTangent = "tangent";
+//static const char *nnBinormal = "binormal";
+static const char *nnTexCoord = "texcoord";
+//static const char *nnColorDiffuse = "colour_diffuse";
+//static const char *nnColorSpecular = "colour_specular";
+
+// <boneassignments>
+static const char *nnVertexBoneAssignment = "vertexboneassignment";
+
+// Skeleton XML constants
+
+// <skeleton>
+static const char *nnSkeleton = "skeleton";
+static const char *nnBones = "bones";
+static const char *nnBoneHierarchy = "bonehierarchy";
+//static const char *nnAnimationLinks = "animationlinks";
+
+// <bones>
+static const char *nnBone = "bone";
+static const char *nnRotation = "rotation";
+static const char *nnAxis = "axis";
+static const char *nnScale = "scale";
+
+// <bonehierarchy>
+static const char *nnBoneParent = "boneparent";
+
+// <animations>
+static const char *nnAnimation = "animation";
+static const char *nnTracks = "tracks";
+
+// <tracks>
+static const char *nnTrack = "track";
+static const char *nnKeyFrames = "keyframes";
+static const char *nnKeyFrame = "keyframe";
+static const char *nnTranslate = "translate";
+static const char *nnRotate = "rotate";
+
+// Common XML constants
+static const char *anX = "x";
+static const char *anY = "y";
+static const char *anZ = "z";
+
+// Mesh
+
+OgreXmlSerializer::OgreXmlSerializer(XmlParser *parser) :
+        mParser(parser) {
+    // empty
+}
+
+MeshXml *OgreXmlSerializer::ImportMesh(XmlParser *parser) {
+    if (nullptr == parser) {
+        return nullptr;
+    }
+
+    OgreXmlSerializer serializer(parser);
+
+    MeshXml *mesh = new MeshXml();
+    serializer.ReadMesh(mesh);
+
+    return mesh;
+}
+
+void OgreXmlSerializer::ReadMesh(MeshXml *mesh) {
+    XmlNode root = mParser->getRootNode();
+    if (nullptr == root) {
+        throw DeadlyImportError("Root node is <" + std::string(root.name()) + "> expecting <mesh>");
+    }
+
+    XmlNode startNode = root.child(nnMesh);
+    if (startNode.empty()) {
+        throw DeadlyImportError("Root node is <" + std::string(root.name()) + "> expecting <mesh>");
+    }
+    for (XmlNode currentNode : startNode.children()) {
+        const std::string currentName = currentNode.name();
+        if (currentName == nnSharedGeometry) {
+            mesh->sharedVertexData = new VertexDataXml();
+            ReadGeometry(currentNode, mesh->sharedVertexData);
+        } else if (currentName == nnSubMeshes) {
+            for (XmlNode &subMeshesNode : currentNode.children()) {
+                const std::string &currentSMName = subMeshesNode.name();
+                if (currentSMName == nnSubMesh) {
+                    ReadSubMesh(subMeshesNode, mesh);
+                }
+            }
+        } else if (currentName == nnBoneAssignments) {
+            ReadBoneAssignments(currentNode, mesh->sharedVertexData);
+        } else if (currentName == nnSkeletonLink) {
+        }
+    }
+
+    ASSIMP_LOG_VERBOSE_DEBUG("Reading Mesh");
+}
+
+void OgreXmlSerializer::ReadGeometry(XmlNode &node, VertexDataXml *dest) {
+    dest->count = ReadAttribute<uint32_t>(node, "vertexcount");
+    ASSIMP_LOG_VERBOSE_DEBUG("  - Reading geometry of ", dest->count, " vertices");
+
+    for (XmlNode currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == nnVertexBuffer) {
+            ReadGeometryVertexBuffer(currentNode, dest);
+        }
+    }
+}
+
+void OgreXmlSerializer::ReadGeometryVertexBuffer(XmlNode &node, VertexDataXml *dest) {
+    bool positions = (XmlParser::hasAttribute(node, "positions") && ReadAttribute<bool>(node, "positions"));
+    bool normals = (XmlParser::hasAttribute(node, "normals") && ReadAttribute<bool>(node, "normals"));
+    bool tangents = (XmlParser::hasAttribute(node, "tangents") && ReadAttribute<bool>(node, "tangents"));
+    uint32_t uvs = (XmlParser::hasAttribute(node, "texture_coords") ? ReadAttribute<uint32_t>(node, "texture_coords") : 0);
+
+    // Not having positions is a error only if a previous vertex buffer did not have them.
+    if (!positions && !dest->HasPositions()) {
+        throw DeadlyImportError("Vertex buffer does not contain positions!");
+    }
+
+    if (positions) {
+        ASSIMP_LOG_VERBOSE_DEBUG("    - Contains positions");
+        dest->positions.reserve(dest->count);
+    }
+    if (normals) {
+        ASSIMP_LOG_VERBOSE_DEBUG("    - Contains normals");
+        dest->normals.reserve(dest->count);
+    }
+    if (tangents) {
+        ASSIMP_LOG_VERBOSE_DEBUG("    - Contains tangents");
+        dest->tangents.reserve(dest->count);
+    }
+    if (uvs > 0) {
+        ASSIMP_LOG_VERBOSE_DEBUG("    - Contains ", uvs, " texture coords");
+        dest->uvs.resize(uvs);
+        for (size_t i = 0, len = dest->uvs.size(); i < len; ++i) {
+            dest->uvs[i].reserve(dest->count);
+        }
+    }
+
+    for (XmlNode currentNode : node.children("vertex")) {
+        for (XmlNode vertexNode : currentNode.children()) {
+            const std::string &currentName = vertexNode.name();
+            if (positions && currentName == nnPosition) {
+                aiVector3D pos;
+                pos.x = ReadAttribute<float>(vertexNode, anX);
+                pos.y = ReadAttribute<float>(vertexNode, anY);
+                pos.z = ReadAttribute<float>(vertexNode, anZ);
+                dest->positions.push_back(pos);
+            } else if (normals && currentName == nnNormal) {
+                aiVector3D normal;
+                normal.x = ReadAttribute<float>(vertexNode, anX);
+                normal.y = ReadAttribute<float>(vertexNode, anY);
+                normal.z = ReadAttribute<float>(vertexNode, anZ);
+                dest->normals.push_back(normal);
+            } else if (tangents && currentName == nnTangent) {
+                aiVector3D tangent;
+                tangent.x = ReadAttribute<float>(vertexNode, anX);
+                tangent.y = ReadAttribute<float>(vertexNode, anY);
+                tangent.z = ReadAttribute<float>(vertexNode, anZ);
+                dest->tangents.push_back(tangent);
+            } else if (uvs > 0 && currentName == nnTexCoord) {
+                for (auto &curUvs : dest->uvs) {
+                    aiVector3D uv;
+                    uv.x = ReadAttribute<float>(vertexNode, "u");
+                    uv.y = (ReadAttribute<float>(vertexNode, "v") * -1) + 1; // Flip UV from Ogre to Assimp form
+                    curUvs.push_back(uv);
+                }
+            }
+        }
+    }
+
+    // Sanity checks
+    if (dest->positions.size() != dest->count) {
+        throw DeadlyImportError("Read only ", dest->positions.size(), " positions when should have read ", dest->count);
+    }
+    if (normals && dest->normals.size() != dest->count) {
+        throw DeadlyImportError("Read only ", dest->normals.size(), " normals when should have read ", dest->count);
+    }
+    if (tangents && dest->tangents.size() != dest->count) {
+        throw DeadlyImportError("Read only ", dest->tangents.size(), " tangents when should have read ", dest->count);
+    }
+    for (unsigned int i = 0; i < dest->uvs.size(); ++i) {
+        if (dest->uvs[i].size() != dest->count) {
+            throw DeadlyImportError("Read only ", dest->uvs[i].size(),
+                    " uvs for uv index ", i, " when should have read ", dest->count);
+        }
+    }
+}
+
+void OgreXmlSerializer::ReadSubMesh(XmlNode &node, MeshXml *mesh) {
+    static const char *anMaterial = "material";
+    static const char *anUseSharedVertices = "usesharedvertices";
+    static const char *anCount = "count";
+    static const char *anV1 = "v1";
+    static const char *anV2 = "v2";
+    static const char *anV3 = "v3";
+    static const char *anV4 = "v4";
+
+    SubMeshXml *submesh = new SubMeshXml();
+
+    if (XmlParser::hasAttribute(node, anMaterial)) {
+        submesh->materialRef = ReadAttribute<std::string>(node, anMaterial);
+    }
+    if (XmlParser::hasAttribute(node, anUseSharedVertices)) {
+        submesh->usesSharedVertexData = ReadAttribute<bool>(node, anUseSharedVertices);
+    }
+
+    ASSIMP_LOG_VERBOSE_DEBUG("Reading SubMesh ", mesh->subMeshes.size());
+    ASSIMP_LOG_VERBOSE_DEBUG("  - Material: '", submesh->materialRef, "'");
+    ASSIMP_LOG_VERBOSE_DEBUG("  - Uses shared geometry: ", (submesh->usesSharedVertexData ? "true" : "false"));
+
+    // TODO: maybe we have always just 1 faces and 1 geometry and always in this order. this loop will only work correct, when the order
+    // of faces and geometry changed, and not if we have more than one of one
+    /// @todo Fix above comment with better read logic below
+
+    bool quadWarned = false;
+
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == nnFaces) {
+            submesh->indexData->faceCount = ReadAttribute<uint32_t>(currentNode, anCount);
+            submesh->indexData->faces.reserve(submesh->indexData->faceCount);
+            for (XmlNode currentChildNode : currentNode.children()) {
+                const std::string &currentChildName = currentChildNode.name();
+                if (currentChildName == nnFace) {
+                    aiFace face;
+                    face.mNumIndices = 3;
+                    face.mIndices = new unsigned int[3];
+                    face.mIndices[0] = ReadAttribute<uint32_t>(currentChildNode, anV1);
+                    face.mIndices[1] = ReadAttribute<uint32_t>(currentChildNode, anV2);
+                    face.mIndices[2] = ReadAttribute<uint32_t>(currentChildNode, anV3);
+                    /// @todo Support quads if Ogre even supports them in XML (I'm not sure but I doubt it)
+                    if (!quadWarned && XmlParser::hasAttribute(currentChildNode, anV4)) {
+                        ASSIMP_LOG_WARN("Submesh <face> has quads with <v4>, only triangles are supported at the moment!");
+                        quadWarned = true;
+                    }
+                    submesh->indexData->faces.push_back(face);
+                }
+            }
+            if (submesh->indexData->faces.size() == submesh->indexData->faceCount) {
+                ASSIMP_LOG_VERBOSE_DEBUG("  - Faces ", submesh->indexData->faceCount);
+            } else {
+                throw DeadlyImportError("Read only ", submesh->indexData->faces.size(), " faces when should have read ", submesh->indexData->faceCount);
+            }
+        } else if (currentName == nnGeometry) {
+            if (submesh->usesSharedVertexData) {
+                throw DeadlyImportError("Found <geometry> in <submesh> when use shared geometry is true. Invalid mesh file.");
+            }
+
+            submesh->vertexData = new VertexDataXml();
+            ReadGeometry(currentNode, submesh->vertexData);
+        } else if (currentName == nnBoneAssignments) {
+            ReadBoneAssignments(currentNode, submesh->vertexData);
+        }
+    }
+
+    submesh->index = static_cast<unsigned int>(mesh->subMeshes.size());
+    mesh->subMeshes.push_back(submesh);
+}
+
+void OgreXmlSerializer::ReadBoneAssignments(XmlNode &node, VertexDataXml *dest) {
+    if (!dest) {
+        throw DeadlyImportError("Cannot read bone assignments, vertex data is null.");
+    }
+
+    static const char *anVertexIndex = "vertexindex";
+    static const char *anBoneIndex = "boneindex";
+    static const char *anWeight = "weight";
+
+    std::set<uint32_t> influencedVertices;
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == nnVertexBoneAssignment) {
+            VertexBoneAssignment ba;
+            ba.vertexIndex = ReadAttribute<uint32_t>(currentNode, anVertexIndex);
+            ba.boneIndex = ReadAttribute<uint16_t>(currentNode, anBoneIndex);
+            ba.weight = ReadAttribute<float>(currentNode, anWeight);
+
+            dest->boneAssignments.push_back(ba);
+            influencedVertices.insert(ba.vertexIndex);
+        }
+    }
+
+    /** Normalize bone weights.
+        Some exporters won't care if the sum of all bone weights
+        for a single vertex equals 1 or not, so validate here. */
+    const float epsilon = 0.05f;
+    for (const uint32_t vertexIndex : influencedVertices) {
+        float sum = 0.0f;
+        for (VertexBoneAssignmentList::const_iterator baIter = dest->boneAssignments.begin(), baEnd = dest->boneAssignments.end(); baIter != baEnd; ++baIter) {
+            if (baIter->vertexIndex == vertexIndex)
+                sum += baIter->weight;
+        }
+        if ((sum < (1.0f - epsilon)) || (sum > (1.0f + epsilon))) {
+            for (auto &boneAssign : dest->boneAssignments) {
+                if (boneAssign.vertexIndex == vertexIndex)
+                    boneAssign.weight /= sum;
+            }
+        }
+    }
+
+    ASSIMP_LOG_VERBOSE_DEBUG("  - ", dest->boneAssignments.size(), " bone assignments");
+}
+
+// Skeleton
+
+bool OgreXmlSerializer::ImportSkeleton(Assimp::IOSystem *pIOHandler, MeshXml *mesh) {
+    if (!mesh || mesh->skeletonRef.empty())
+        return false;
+
+    // Highly unusual to see in read world cases but support
+    // XML mesh referencing a binary skeleton file.
+    if (EndsWith(mesh->skeletonRef, ".skeleton", false)) {
+        if (OgreBinarySerializer::ImportSkeleton(pIOHandler, mesh))
+            return true;
+
+        /** Last fallback if .skeleton failed to be read. Try reading from
+            .skeleton.xml even if the XML file referenced a binary skeleton.
+            @note This logic was in the previous version and I don't want to break
+            old code that might depends on it. */
+        mesh->skeletonRef = mesh->skeletonRef + ".xml";
+    }
+
+    XmlParserPtr xmlParser = OpenXmlParser(pIOHandler, mesh->skeletonRef);
+    if (!xmlParser.get())
+        return false;
+
+    Skeleton *skeleton = new Skeleton();
+    OgreXmlSerializer serializer(xmlParser.get());
+    XmlNode root = xmlParser->getRootNode();
+    serializer.ReadSkeleton(root, skeleton);
+    mesh->skeleton = skeleton;
+    return true;
+}
+
+bool OgreXmlSerializer::ImportSkeleton(Assimp::IOSystem *pIOHandler, Mesh *mesh) {
+    if (!mesh || mesh->skeletonRef.empty()) {
+        return false;
+    }
+
+    XmlParserPtr xmlParser = OpenXmlParser(pIOHandler, mesh->skeletonRef);
+    if (!xmlParser.get()) {
+        return false;
+    }
+
+    Skeleton *skeleton = new Skeleton();
+    OgreXmlSerializer serializer(xmlParser.get());
+    XmlNode root = xmlParser->getRootNode();
+
+    serializer.ReadSkeleton(root, skeleton);
+    mesh->skeleton = skeleton;
+
+    return true;
+}
+
+XmlParserPtr OgreXmlSerializer::OpenXmlParser(Assimp::IOSystem *pIOHandler, const std::string &filename) {
+    if (!EndsWith(filename, ".skeleton.xml", false)) {
+        ASSIMP_LOG_ERROR("Imported Mesh is referencing to unsupported '", filename, "' skeleton file.");
+        return XmlParserPtr();
+    }
+
+    if (!pIOHandler->Exists(filename)) {
+        ASSIMP_LOG_ERROR("Failed to find skeleton file '", filename, "' that is referenced by imported Mesh.");
+        return XmlParserPtr();
+    }
+
+    std::unique_ptr<IOStream> file(pIOHandler->Open(filename));
+    if (!file.get()) {
+        throw DeadlyImportError("Failed to open skeleton file ", filename);
+    }
+
+    XmlParserPtr xmlParser = std::make_shared<XmlParser>();
+    if (!xmlParser->parse(file.get())) {
+        throw DeadlyImportError("Failed to create XML reader for skeleton file " + filename);
+    }
+    return xmlParser;
+}
+
+void OgreXmlSerializer::ReadSkeleton(XmlNode &node, Skeleton *skeleton) {
+    if (node.name() != nnSkeleton) {
+        throw DeadlyImportError("Root node is <" + std::string(node.name()) + "> expecting <skeleton>");
+    }
+
+    ASSIMP_LOG_VERBOSE_DEBUG("Reading Skeleton");
+
+    // Optional blend mode from root node
+    if (XmlParser::hasAttribute(node, "blendmode")) {
+        skeleton->blendMode = (ai_tolower(ReadAttribute<std::string>(node, "blendmode")) == "cumulative" ? Skeleton::ANIMBLEND_CUMULATIVE : Skeleton::ANIMBLEND_AVERAGE);
+    }
+
+    for (XmlNode &currentNode : node.children()) {
+        const std::string currentName = currentNode.name();
+        if (currentName == nnBones) {
+            ReadBones(currentNode, skeleton);
+        } else if (currentName == nnBoneHierarchy) {
+            ReadBoneHierarchy(currentNode, skeleton);
+        } else if (currentName == nnAnimations) {
+            ReadAnimations(currentNode, skeleton);
+        }
+    }
+}
+
+void OgreXmlSerializer::ReadAnimations(XmlNode &node, Skeleton *skeleton) {
+    if (skeleton->bones.empty()) {
+        throw DeadlyImportError("Cannot read <animations> for a Skeleton without bones");
+    }
+
+    ASSIMP_LOG_VERBOSE_DEBUG("  - Animations");
+
+    for (XmlNode &currentNode : node.children()) {
+        const std::string currentName = currentNode.name();
+        if (currentName == nnAnimation) {
+            Animation *anim = new Animation(skeleton);
+            anim->name = ReadAttribute<std::string>(currentNode, "name");
+            anim->length = ReadAttribute<float>(currentNode, "length");
+            for (XmlNode &currentChildNode : currentNode.children()) {
+                const std::string currentChildName = currentNode.name();
+                if (currentChildName == nnTracks) {
+                    ReadAnimationTracks(currentChildNode, anim);
+                    skeleton->animations.push_back(anim);
+                } else {
+                    throw DeadlyImportError("No <tracks> found in <animation> ", anim->name);
+                }
+            }
+        }
+    }
+}
+
+void OgreXmlSerializer::ReadAnimationTracks(XmlNode &node, Animation *dest) {
+    for (XmlNode &currentNode : node.children()) {
+        const std::string currentName = currentNode.name();
+        if (currentName == nnTrack) {
+            VertexAnimationTrack track;
+            track.type = VertexAnimationTrack::VAT_TRANSFORM;
+            track.boneName = ReadAttribute<std::string>(currentNode, "bone");
+            for (XmlNode &currentChildNode : currentNode.children()) {
+                const std::string currentChildName = currentNode.name();
+                if (currentChildName == nnKeyFrames) {
+                    ReadAnimationKeyFrames(currentChildNode, dest, &track);
+                    dest->tracks.push_back(track);
+                } else {
+                    throw DeadlyImportError("No <keyframes> found in <track> ", dest->name);
+                }
+            }
+        }
+    }
+}
+
+void OgreXmlSerializer::ReadAnimationKeyFrames(XmlNode &node, Animation *anim, VertexAnimationTrack *dest) {
+    const aiVector3D zeroVec(0.f, 0.f, 0.f);
+    for (XmlNode &currentNode : node.children()) {
+        TransformKeyFrame keyframe;
+        const std::string currentName = currentNode.name();
+        if (currentName == nnKeyFrame) {
+            keyframe.timePos = ReadAttribute<float>(currentNode, "time");
+            for (XmlNode &currentChildNode : currentNode.children()) {
+                const std::string currentChildName = currentNode.name();
+                if (currentChildName == nnTranslate) {
+                    keyframe.position.x = ReadAttribute<float>(currentChildNode, anX);
+                    keyframe.position.y = ReadAttribute<float>(currentChildNode, anY);
+                    keyframe.position.z = ReadAttribute<float>(currentChildNode, anZ);
+                } else if (currentChildName == nnRotate) {
+                    float angle = ReadAttribute<float>(currentChildNode, "angle");
+                    for (XmlNode &currentChildChildNode : currentNode.children()) {
+                        const std::string currentChildChildName = currentNode.name();
+                        if (currentChildChildName == nnAxis) {
+                            aiVector3D axis;
+                            axis.x = ReadAttribute<float>(currentChildChildNode, anX);
+                            axis.y = ReadAttribute<float>(currentChildChildNode, anY);
+                            axis.z = ReadAttribute<float>(currentChildChildNode, anZ);
+                            if (axis.Equal(zeroVec)) {
+                                axis.x = 1.0f;
+                                if (angle != 0) {
+                                    ASSIMP_LOG_WARN("Found invalid a key frame with a zero rotation axis in animation: ", anim->name);
+                                }
+                            }
+                            keyframe.rotation = aiQuaternion(axis, angle);
+                        }
+                    }
+                } else if (currentChildName == nnScale) {
+                    keyframe.scale.x = ReadAttribute<float>(currentChildNode, anX);
+                    keyframe.scale.y = ReadAttribute<float>(currentChildNode, anY);
+                    keyframe.scale.z = ReadAttribute<float>(currentChildNode, anZ);
+                }
+            }
+        }
+        dest->transformKeyFrames.push_back(keyframe);
+    }
+}
+
+void OgreXmlSerializer::ReadBoneHierarchy(XmlNode &node, Skeleton *skeleton) {
+    if (skeleton->bones.empty()) {
+        throw DeadlyImportError("Cannot read <bonehierarchy> for a Skeleton without bones");
+    }
+
+    for (XmlNode &currentNode : node.children()) {
+        const std::string currentName = currentNode.name();
+        if (currentName == nnBoneParent) {
+            const std::string name = ReadAttribute<std::string>(currentNode, "bone");
+            const std::string parentName = ReadAttribute<std::string>(currentNode, "parent");
+
+            Bone *bone = skeleton->BoneByName(name);
+            Bone *parent = skeleton->BoneByName(parentName);
+
+            if (bone && parent) {
+                parent->AddChild(bone);
+            } else {
+                throw DeadlyImportError("Failed to find bones for parenting: Child ", name, " for parent ", parentName);
+            }
+        }
+    }
+
+    // Calculate bone matrices for root bones. Recursively calculates their children.
+    for (size_t i = 0, len = skeleton->bones.size(); i < len; ++i) {
+        Bone *bone = skeleton->bones[i];
+        if (!bone->IsParented())
+            bone->CalculateWorldMatrixAndDefaultPose(skeleton);
+    }
+}
+
+static bool BoneCompare(Bone *a, Bone *b) {
+    ai_assert(nullptr != a);
+    ai_assert(nullptr != b);
+
+    return (a->id < b->id);
+}
+
+void OgreXmlSerializer::ReadBones(XmlNode &node, Skeleton *skeleton) {
+    ASSIMP_LOG_VERBOSE_DEBUG("  - Bones");
+
+    for (XmlNode &currentNode : node.children()) {
+        const std::string currentName = currentNode.name();
+        if (currentName == nnBone) {
+            Bone *bone = new Bone();
+            bone->id = ReadAttribute<uint16_t>(currentNode, "id");
+            bone->name = ReadAttribute<std::string>(currentNode, "name");
+            for (XmlNode &currentChildNode : currentNode.children()) {
+                const std::string currentChildName = currentNode.name();
+                if (currentChildName == nnRotation) {
+                    bone->position.x = ReadAttribute<float>(currentChildNode, anX);
+                    bone->position.y = ReadAttribute<float>(currentChildNode, anY);
+                    bone->position.z = ReadAttribute<float>(currentChildNode, anZ);
+                } else if (currentChildName == nnScale) {
+                    float angle = ReadAttribute<float>(currentChildNode, "angle");
+                    for (XmlNode currentChildChildNode : currentChildNode.children()) {
+                        const std::string &currentChildChildName = currentChildChildNode.name();
+                        if (currentChildChildName == nnAxis) {
+                            aiVector3D axis;
+                            axis.x = ReadAttribute<float>(currentChildChildNode, anX);
+                            axis.y = ReadAttribute<float>(currentChildChildNode, anY);
+                            axis.z = ReadAttribute<float>(currentChildChildNode, anZ);
+
+                            bone->rotation = aiQuaternion(axis, angle);
+                        } else {
+                            throw DeadlyImportError("No axis specified for bone rotation in bone ", bone->id);
+                        }
+                    }
+                } else if (currentChildName == nnScale) {
+                    if (XmlParser::hasAttribute(currentChildNode, "factor")) {
+                        float factor = ReadAttribute<float>(currentChildNode, "factor");
+                        bone->scale.Set(factor, factor, factor);
+                    } else {
+                        if (XmlParser::hasAttribute(currentChildNode, anX))
+                            bone->scale.x = ReadAttribute<float>(currentChildNode, anX);
+                        if (XmlParser::hasAttribute(currentChildNode, anY))
+                            bone->scale.y = ReadAttribute<float>(currentChildNode, anY);
+                        if (XmlParser::hasAttribute(currentChildNode, anZ))
+                            bone->scale.z = ReadAttribute<float>(currentChildNode, anZ);
+                    }
+                }
+            }
+            skeleton->bones.push_back(bone);
+        }
+    }
+
+    // Order bones by Id
+    std::sort(skeleton->bones.begin(), skeleton->bones.end(), BoneCompare);
+
+    // Validate that bone indexes are not skipped.
+    /** @note Left this from original authors code, but not sure if this is strictly necessary
+        as per the Ogre skeleton spec. It might be more that other (later) code in this imported does not break. */
+    for (size_t i = 0, len = skeleton->bones.size(); i < len; ++i) {
+        Bone *b = skeleton->bones[i];
+        ASSIMP_LOG_VERBOSE_DEBUG("    ", b->id, " ", b->name);
+
+        if (b->id != static_cast<uint16_t>(i)) {
+            throw DeadlyImportError("Bone ids are not in sequence starting from 0. Missing index ", i);
+        }
+    }
+}
+
+} // namespace Ogre
+} // namespace Assimp
+
+#endif // ASSIMP_BUILD_NO_OGRE_IMPORTER
diff --git a/Engine/lib/assimp/code/Ogre/OgreXmlSerializer.h b/Engine/lib/assimp/code/AssetLib/Ogre/OgreXmlSerializer.h
similarity index 54%
rename from Engine/lib/assimp/code/Ogre/OgreXmlSerializer.h
rename to Engine/lib/assimp/code/AssetLib/Ogre/OgreXmlSerializer.h
index 7e5e83fec..406681f55 100644
--- a/Engine/lib/assimp/code/Ogre/OgreXmlSerializer.h
+++ b/Engine/lib/assimp/code/AssetLib/Ogre/OgreXmlSerializer.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -46,73 +46,57 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_OGRE_IMPORTER
 
 #include "OgreStructs.h"
-#include <assimp/irrXMLWrapper.h>
+#include <assimp/XmlParser.h>
 
-namespace Assimp
-{
-namespace Ogre
-{
+namespace Assimp {
 
-typedef irr::io::IrrXMLReader XmlReader;
-typedef std::shared_ptr<XmlReader> XmlReaderPtr;
+namespace Ogre {
 
-class OgreXmlSerializer
-{
+using XmlParserPtr = std::shared_ptr<::Assimp::XmlParser> ;
+
+class OgreXmlSerializer {
 public:
     /// Imports mesh and returns the result.
-    /** @note Fatal unrecoverable errors will throw a DeadlyImportError. */
-    static MeshXml *ImportMesh(XmlReader *reader);
+    /// @note Fatal unrecoverable errors will throw a DeadlyImportError.
+    static MeshXml *ImportMesh(XmlParser *parser);
 
     /// Imports skeleton to @c mesh.
-    /** If mesh does not have a skeleton reference or the skeleton file
-        cannot be found it is not a fatal DeadlyImportError.
-        @return If skeleton import was successful. */
-    static bool ImportSkeleton(Assimp::IOSystem *pIOHandler, MeshXml *mesh);
-    static bool ImportSkeleton(Assimp::IOSystem *pIOHandler, Mesh *mesh);
+    /// If mesh does not have a skeleton reference or the skeleton file
+    /// cannot be found it is not a fatal DeadlyImportError.
+    /// @return If skeleton import was successful.
+    static bool ImportSkeleton(IOSystem *pIOHandler, MeshXml *mesh);
+    static bool ImportSkeleton(IOSystem *pIOHandler, Mesh *mesh);
 
 private:
-    explicit OgreXmlSerializer(XmlReader *reader) :
-        m_reader(reader)
-    {
-    }
+    explicit OgreXmlSerializer(XmlParser *xmlParser);
 
-    static XmlReaderPtr OpenReader(Assimp::IOSystem *pIOHandler, const std::string &filename);
+    static XmlParserPtr OpenXmlParser(Assimp::IOSystem *pIOHandler, const std::string &filename);
 
     // Mesh
     void ReadMesh(MeshXml *mesh);
-    void ReadSubMesh(MeshXml *mesh);
-
-    void ReadGeometry(VertexDataXml *dest);
-    void ReadGeometryVertexBuffer(VertexDataXml *dest);
-
-    void ReadBoneAssignments(VertexDataXml *dest);
+    void ReadSubMesh(XmlNode &node, MeshXml *mesh);
+    void ReadGeometry(XmlNode &node, VertexDataXml *dest);
+    void ReadGeometryVertexBuffer(XmlNode &node, VertexDataXml *dest);
+    void ReadBoneAssignments(XmlNode &node, VertexDataXml *dest);
 
     // Skeleton
-    void ReadSkeleton(Skeleton *skeleton);
+    void ReadSkeleton(XmlNode &node, Skeleton *skeleton);
+    void ReadBones(XmlNode &node, Skeleton *skeleton);
+    void ReadBoneHierarchy(XmlNode &node, Skeleton *skeleton);
+    void ReadAnimations(XmlNode &node, Skeleton *skeleton);
+    void ReadAnimationTracks(XmlNode &node, Animation *dest);
+    void ReadAnimationKeyFrames(XmlNode &node, Animation *anim, VertexAnimationTrack *dest);
 
-    void ReadBones(Skeleton *skeleton);
-    void ReadBoneHierarchy(Skeleton *skeleton);
+    template <typename T>
+    T ReadAttribute(XmlNode &xmlNode, const char *name) const;
 
-    void ReadAnimations(Skeleton *skeleton);
-    void ReadAnimationTracks(Animation *dest);
-    void ReadAnimationKeyFrames(Animation *anim, VertexAnimationTrack *dest);
-
-    template<typename T>
-    T ReadAttribute(const char *name) const;
-    bool HasAttribute(const char *name) const;
-
-    std::string &NextNode();
-    std::string &SkipCurrentNode();
-
-    bool CurrentNodeNameEquals(const std::string &name) const;
-    std::string CurrentNodeName(bool forceRead = false);
-
-    XmlReader *m_reader;
-    std::string m_currentNodeName;
+private:
+    XmlParser *mParser;
 };
 
-} // Ogre
-} // Assimp
+
+} // namespace Ogre
+} // namespace Assimp
 
 #endif // ASSIMP_BUILD_NO_OGRE_IMPORTER
 #endif // AI_OGREXMLSERIALIZER_H_INC
diff --git a/Engine/lib/assimp/code/OpenGEX/OpenGEXExporter.cpp b/Engine/lib/assimp/code/AssetLib/OpenGEX/OpenGEXExporter.cpp
similarity index 98%
rename from Engine/lib/assimp/code/OpenGEX/OpenGEXExporter.cpp
rename to Engine/lib/assimp/code/AssetLib/OpenGEX/OpenGEXExporter.cpp
index 635174185..328c3c460 100644
--- a/Engine/lib/assimp/code/OpenGEX/OpenGEXExporter.cpp
+++ b/Engine/lib/assimp/code/AssetLib/OpenGEX/OpenGEXExporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/OpenGEX/OpenGEXExporter.h b/Engine/lib/assimp/code/AssetLib/OpenGEX/OpenGEXExporter.h
similarity index 97%
rename from Engine/lib/assimp/code/OpenGEX/OpenGEXExporter.h
rename to Engine/lib/assimp/code/AssetLib/OpenGEX/OpenGEXExporter.h
index b9b54c208..cc22c7d21 100644
--- a/Engine/lib/assimp/code/OpenGEX/OpenGEXExporter.h
+++ b/Engine/lib/assimp/code/AssetLib/OpenGEX/OpenGEXExporter.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -39,6 +38,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 ----------------------------------------------------------------------
 */
+#pragma once
 #ifndef AI_OPENGEX_EXPORTER_H
 #define AI_OPENGEX_EXPORTER_H
 
diff --git a/Engine/lib/assimp/code/AssetLib/OpenGEX/OpenGEXImporter.cpp b/Engine/lib/assimp/code/AssetLib/OpenGEX/OpenGEXImporter.cpp
new file mode 100644
index 000000000..c8e47933d
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/OpenGEX/OpenGEXImporter.cpp
@@ -0,0 +1,1326 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+#ifndef ASSIMP_BUILD_NO_OPENGEX_IMPORTER
+
+#include "AssetLib/OpenGEX/OpenGEXImporter.h"
+#include "PostProcessing/MakeVerboseFormat.h"
+
+#include <assimp/DefaultIOSystem.h>
+#include <assimp/StringComparison.h>
+#include <assimp/StringUtils.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/ai_assert.h>
+#include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <openddlparser/OpenDDLParser.h>
+
+static const aiImporterDesc desc = {
+    "Open Game Engine Exchange",
+    "",
+    "",
+    "",
+    aiImporterFlags_SupportTextFlavour,
+    0,
+    0,
+    0,
+    0,
+    "ogex"
+};
+
+namespace Grammar {
+    static const char* MetricType = "Metric";
+    static const char *Metric_DistanceType = "distance";
+    static const char *Metric_AngleType = "angle";
+    static const char *Metric_TimeType = "time";
+    static const char *Metric_UpType = "up";
+    static const char *NameType = "Name";
+    static const char *ObjectRefType = "ObjectRef";
+    static const char *MaterialRefType = "MaterialRef";
+    static const char *MetricKeyType = "key";
+    static const char *GeometryNodeType = "GeometryNode";
+    static const char *CameraNodeType = "CameraNode";
+    static const char *LightNodeType = "LightNode";
+    static const char *GeometryObjectType = "GeometryObject";
+    static const char *CameraObjectType = "CameraObject";
+    static const char *LightObjectType = "LightObject";
+    static const char *TransformType = "Transform";
+    static const char *MeshType = "Mesh";
+    static const char *VertexArrayType = "VertexArray";
+    static const char *IndexArrayType = "IndexArray";
+    static const char *MaterialType = "Material";
+    static const char *ColorType = "Color";
+    static const char *ParamType = "Param";
+    static const char *TextureType = "Texture";
+    static const char *AttenType = "Atten";
+
+    static const char *DiffuseColorToken = "diffuse";
+    static const char *SpecularColorToken = "specular";
+    static const char *EmissionColorToken = "emission";
+
+    static const char *DiffuseTextureToken = "diffuse";
+    static const char *DiffuseSpecularTextureToken = "specular";
+    static const char *SpecularPowerTextureToken = "specular_power";
+    static const char *EmissionTextureToken = "emission";
+    static const char *OpacyTextureToken = "opacity";
+    static const char *TransparencyTextureToken = "transparency";
+    static const char *NormalTextureToken = "normal";
+
+    enum TokenType {
+        NoneType = -1,
+        MetricToken,
+        NameToken,
+        ObjectRefToken,
+        MaterialRefToken,
+        MetricKeyToken,
+        GeometryNodeToken,
+        CameraNodeToken,
+        LightNodeToken,
+        GeometryObjectToken,
+        CameraObjectToken,
+        LightObjectToken,
+        TransformToken,
+        MeshToken,
+        VertexArrayToken,
+        IndexArrayToken,
+        MaterialToken,
+        ColorToken,
+        ParamToken,
+        TextureToken,
+        AttenToken
+    };
+
+    static const std::string ValidMetricToken[4] = {
+        Metric_DistanceType,
+        Metric_AngleType,
+        Metric_TimeType,
+        Metric_UpType
+    };
+
+    static int isValidMetricType(const char *token) {
+        if (nullptr == token) {
+            return false;
+        }
+
+        int idx(-1);
+        for (size_t i = 0; i < 4; i++) {
+            if (ValidMetricToken[i] == token) {
+                idx = (int)i;
+                break;
+            }
+        }
+
+        return idx;
+    }
+
+    static TokenType matchTokenType(const char *tokenType) {
+        if (MetricType == tokenType) {
+            return MetricToken;
+        } else if (NameType == tokenType) {
+            return NameToken;
+        } else if (ObjectRefType == tokenType) {
+            return ObjectRefToken;
+        } else if (MaterialRefType == tokenType) {
+            return MaterialRefToken;
+        } else if (MetricKeyType == tokenType) {
+            return MetricKeyToken;
+        } else if (GeometryNodeType == tokenType) {
+            return GeometryNodeToken;
+        } else if (CameraNodeType == tokenType) {
+            return CameraNodeToken;
+        } else if (LightNodeType == tokenType) {
+            return LightNodeToken;
+        } else if (GeometryObjectType == tokenType) {
+            return GeometryObjectToken;
+        } else if (CameraObjectType == tokenType) {
+            return CameraObjectToken;
+        } else if (LightObjectType == tokenType) {
+            return LightObjectToken;
+        } else if (TransformType == tokenType) {
+            return TransformToken;
+        } else if (MeshType == tokenType) {
+            return MeshToken;
+        } else if (VertexArrayType == tokenType) {
+            return VertexArrayToken;
+        } else if (IndexArrayType == tokenType) {
+            return IndexArrayToken;
+        } else if (MaterialType == tokenType) {
+            return MaterialToken;
+        } else if (ColorType == tokenType) {
+            return ColorToken;
+        } else if (ParamType == tokenType) {
+            return ParamToken;
+        } else if (TextureType == tokenType) {
+            return TextureToken;
+        } else if (AttenType == tokenType) {
+            return AttenToken;
+        }
+
+        return NoneType;
+    }
+} // Namespace Grammar
+
+namespace Assimp {
+namespace OpenGEX {
+
+USE_ODDLPARSER_NS
+
+//------------------------------------------------------------------------------------------------
+static void propId2StdString(Property *prop, std::string &name, std::string &key) {
+    name = key = std::string();
+    if (nullptr == prop) {
+        return;
+    }
+
+    if (nullptr != prop->m_key) {
+#ifdef ASSIMP_USE_HUNTER
+        name = prop->m_key->m_text.m_buffer;
+#else
+        name = prop->m_key->m_buffer;
+#endif
+        if (Value::ValueType::ddl_string == prop->m_value->m_type) {
+            key = prop->m_value->getString();
+        }
+    }
+}
+
+//------------------------------------------------------------------------------------------------
+static void logDDLParserMessage (LogSeverity severity, const std::string &rawmsg) {
+    std::string msg = ai_str_toprintable(rawmsg);
+    switch (severity) {
+    case ddl_debug_msg: ASSIMP_LOG_DEBUG(msg);         break;
+    case ddl_info_msg:  ASSIMP_LOG_INFO(msg);          break;
+    case ddl_warn_msg:  ASSIMP_LOG_WARN(msg);          break;
+    case ddl_error_msg: ASSIMP_LOG_ERROR(msg);         break;
+    default:            ASSIMP_LOG_VERBOSE_DEBUG(msg); break;
+    }
+}
+
+//------------------------------------------------------------------------------------------------
+OpenGEXImporter::VertexContainer::VertexContainer() :
+        m_numColors(0), m_colors(nullptr), m_numUVComps(), m_textureCoords() {
+    // empty
+}
+
+//------------------------------------------------------------------------------------------------
+OpenGEXImporter::VertexContainer::~VertexContainer() {
+    delete[] m_colors;
+
+    for (auto &texcoords : m_textureCoords) {
+        delete[] texcoords;
+    }
+}
+
+//------------------------------------------------------------------------------------------------
+OpenGEXImporter::RefInfo::RefInfo(aiNode *node, Type type, std::vector<std::string> &names) :
+        m_node(node),
+        m_type(type),
+        m_Names(names) {
+    // empty
+}
+
+//------------------------------------------------------------------------------------------------
+OpenGEXImporter::RefInfo::~RefInfo() {
+    // empty
+}
+
+//------------------------------------------------------------------------------------------------
+OpenGEXImporter::OpenGEXImporter() :
+        m_root(nullptr),
+        m_nodeChildMap(),
+        m_meshCache(),
+        m_mesh2refMap(),
+        m_material2refMap(),
+        m_ctx(nullptr),
+        m_metrics(),
+        m_currentNode(nullptr),
+        m_currentVertices(),
+        m_currentMesh(nullptr),
+        m_currentMaterial(nullptr),
+        m_currentLight(nullptr),
+        m_currentCamera(nullptr),
+        m_tokenType(Grammar::NoneType),
+        m_materialCache(),
+        m_cameraCache(),
+        m_lightCache(),
+        m_nodeStack(),
+        m_unresolvedRefStack() {
+    // empty
+}
+
+//------------------------------------------------------------------------------------------------
+OpenGEXImporter::~OpenGEXImporter() {
+}
+
+//------------------------------------------------------------------------------------------------
+bool OpenGEXImporter::CanRead(const std::string &file, IOSystem *pIOHandler, bool /*checkSig*/) const {
+    static const char *tokens[] = { "Metric", "GeometryNode", "VertexArray (attrib", "IndexArray" };
+    return SearchFileHeaderForToken(pIOHandler, file, tokens, AI_COUNT_OF(tokens));
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::InternReadFile(const std::string &filename, aiScene *pScene, IOSystem *pIOHandler) {
+    // open source file
+    IOStream *file = pIOHandler->Open(filename, "rb");
+    if (!file) {
+        throw DeadlyImportError("Failed to open file ", filename);
+    }
+
+    std::vector<char> buffer;
+    TextFileToBuffer(file, buffer);
+    pIOHandler->Close(file);
+
+    OpenDDLParser myParser;
+    myParser.setLogCallback(&logDDLParserMessage);
+    myParser.setBuffer(&buffer[0], buffer.size());
+    bool success(myParser.parse());
+    if (success) {
+        m_ctx = myParser.getContext();
+        pScene->mRootNode = new aiNode;
+        pScene->mRootNode->mName.Set(filename);
+        handleNodes(m_ctx->m_root, pScene);
+    }
+
+    copyMeshes(pScene);
+    copyCameras(pScene);
+    copyLights(pScene);
+    copyMaterials(pScene);
+    resolveReferences();
+    createNodeTree(pScene);
+}
+
+//------------------------------------------------------------------------------------------------
+const aiImporterDesc *OpenGEXImporter::GetInfo() const {
+    return &desc;
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::SetupProperties(const Importer *pImp) {
+    if (nullptr == pImp) {
+        return;
+    }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleNodes(DDLNode *node, aiScene *pScene) {
+    if (nullptr == node) {
+        return;
+    }
+
+    DDLNode::DllNodeList children = node->getChildNodeList();
+    for (DDLNode::DllNodeList::iterator it = children.begin(); it != children.end(); ++it) {
+        Grammar::TokenType tokenType(Grammar::matchTokenType((*it)->getType().c_str()));
+        switch (tokenType) {
+        case Grammar::MetricToken:
+            handleMetricNode(*it, pScene);
+            break;
+
+        case Grammar::NameToken:
+            handleNameNode(*it, pScene);
+            break;
+
+        case Grammar::ObjectRefToken:
+            handleObjectRefNode(*it, pScene);
+            break;
+
+        case Grammar::MaterialRefToken:
+            handleMaterialRefNode(*it, pScene);
+            break;
+
+        case Grammar::MetricKeyToken:
+            break;
+
+        case Grammar::GeometryNodeToken:
+            handleGeometryNode(*it, pScene);
+            break;
+
+        case Grammar::CameraNodeToken:
+            handleCameraNode(*it, pScene);
+            break;
+
+        case Grammar::LightNodeToken:
+            handleLightNode(*it, pScene);
+            break;
+
+        case Grammar::GeometryObjectToken:
+            handleGeometryObject(*it, pScene);
+            break;
+
+        case Grammar::CameraObjectToken:
+            handleCameraObject(*it, pScene);
+            break;
+
+        case Grammar::LightObjectToken:
+            handleLightObject(*it, pScene);
+            break;
+
+        case Grammar::TransformToken:
+            handleTransformNode(*it, pScene);
+            break;
+
+        case Grammar::MeshToken:
+            handleMeshNode(*it, pScene);
+            break;
+
+        case Grammar::VertexArrayToken:
+            handleVertexArrayNode(*it, pScene);
+            break;
+
+        case Grammar::IndexArrayToken:
+            handleIndexArrayNode(*it, pScene);
+            break;
+
+        case Grammar::MaterialToken:
+            handleMaterialNode(*it, pScene);
+            break;
+
+        case Grammar::ColorToken:
+            handleColorNode(*it, pScene);
+            break;
+
+        case Grammar::ParamToken:
+            handleParamNode(*it, pScene);
+            break;
+
+        case Grammar::TextureToken:
+            handleTextureNode(*it, pScene);
+            break;
+
+        default:
+            break;
+        }
+    }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleMetricNode(DDLNode *node, aiScene * /*pScene*/) {
+    if (nullptr == node || nullptr == m_ctx) {
+        return;
+    }
+
+    if (m_ctx->m_root != node->getParent()) {
+        return;
+    }
+
+    Property *prop(node->getProperties());
+    while (nullptr != prop) {
+        if (nullptr != prop->m_key) {
+            if (Value::ValueType::ddl_string == prop->m_value->m_type) {
+                std::string valName((char *)prop->m_value->m_data);
+                int type(Grammar::isValidMetricType(valName.c_str()));
+                if (Grammar::NoneType != type) {
+                    Value *val(node->getValue());
+                    if (nullptr != val) {
+                        if (Value::ValueType::ddl_float == val->m_type) {
+                            m_metrics[type].m_floatValue = val->getFloat();
+                        } else if (Value::ValueType::ddl_int32 == val->m_type) {
+                            m_metrics[type].m_intValue = val->getInt32();
+                        } else if (Value::ValueType::ddl_string == val->m_type) {
+                            m_metrics[type].m_stringValue = std::string(val->getString());
+                        } else {
+                            throw DeadlyImportError("OpenGEX: invalid data type for Metric node.");
+                        }
+                    }
+                }
+            }
+        }
+        prop = prop->m_next;
+    }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleNameNode(DDLNode *node, aiScene * /*pScene*/) {
+    if (nullptr == m_currentNode) {
+        throw DeadlyImportError("No current node for name.");
+        return;
+    }
+
+    Value *val(node->getValue());
+    if (nullptr != val) {
+        if (Value::ValueType::ddl_string != val->m_type) {
+            throw DeadlyImportError("OpenGEX: invalid data type for value in node name.");
+            return;
+        }
+
+        const std::string name(val->getString());
+        if (m_tokenType == Grammar::GeometryNodeToken || m_tokenType == Grammar::LightNodeToken || m_tokenType == Grammar::CameraNodeToken) {
+            m_currentNode->mName.Set(name.c_str());
+        } else if (m_tokenType == Grammar::MaterialToken) {
+            aiString aiName;
+            aiName.Set(name);
+            m_currentMaterial->AddProperty(&aiName, AI_MATKEY_NAME);
+            m_material2refMap[name] = m_materialCache.size() - 1;
+        }
+    }
+}
+
+//------------------------------------------------------------------------------------------------
+static void getRefNames(DDLNode *node, std::vector<std::string> &names) {
+    ai_assert(nullptr != node);
+
+    Reference *ref = node->getReferences();
+    if (nullptr != ref) {
+        for (size_t i = 0; i < ref->m_numRefs; i++) {
+            Name *currentName(ref->m_referencedName[i]);
+            if (nullptr != currentName && nullptr != currentName->m_id) {
+#ifdef ASSIMP_USE_HUNTER
+                const std::string name(currentName->m_id->m_text.m_buffer);
+#else
+                const std::string name(currentName->m_id->m_buffer);
+#endif
+                if (!name.empty()) {
+                    names.push_back(name);
+                }
+            }
+        }
+    }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleObjectRefNode(DDLNode *node, aiScene * /*pScene*/) {
+    if (nullptr == m_currentNode) {
+        throw DeadlyImportError("No parent node for name.");
+        return;
+    }
+
+    std::vector<std::string> objRefNames;
+    getRefNames(node, objRefNames);
+
+    // when we are dealing with a geometry node prepare the mesh cache
+    if (m_tokenType == Grammar::GeometryNodeToken) {
+        m_currentNode->mNumMeshes = static_cast<unsigned int>(objRefNames.size());
+        m_currentNode->mMeshes = new unsigned int[objRefNames.size()];
+        if (!objRefNames.empty()) {
+            m_unresolvedRefStack.push_back(std::unique_ptr<RefInfo>(new RefInfo(m_currentNode, RefInfo::MeshRef, objRefNames)));
+        }
+    } else if (m_tokenType == Grammar::LightNodeToken) {
+        // TODO!
+    } else if (m_tokenType == Grammar::CameraNodeToken) {
+        // TODO!
+    }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleMaterialRefNode(ODDLParser::DDLNode *node, aiScene * /*pScene*/) {
+    if (nullptr == m_currentNode) {
+        throw DeadlyImportError("No parent node for name.");
+        return;
+    }
+
+    std::vector<std::string> matRefNames;
+    getRefNames(node, matRefNames);
+    if (!matRefNames.empty()) {
+        m_unresolvedRefStack.push_back(std::unique_ptr<RefInfo>(new RefInfo(m_currentNode, RefInfo::MaterialRef, matRefNames)));
+    }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleGeometryNode(DDLNode *node, aiScene *pScene) {
+    aiNode *newNode = new aiNode;
+    pushNode(newNode, pScene);
+    m_tokenType = Grammar::GeometryNodeToken;
+    m_currentNode = newNode;
+    handleNodes(node, pScene);
+
+    popNode();
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleCameraNode(DDLNode *node, aiScene *pScene) {
+    aiCamera *camera(new aiCamera);
+    m_cameraCache.push_back(camera);
+    m_currentCamera = camera;
+
+    aiNode *newNode = new aiNode;
+    pushNode(newNode, pScene);
+    m_tokenType = Grammar::CameraNodeToken;
+    m_currentNode = newNode;
+
+    handleNodes(node, pScene);
+
+    popNode();
+
+    m_currentCamera->mName.Set(newNode->mName.C_Str());
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleLightNode(ODDLParser::DDLNode *node, aiScene *pScene) {
+    aiLight *light(new aiLight);
+    m_lightCache.push_back(light);
+    m_currentLight = light;
+
+    aiNode *newNode = new aiNode;
+    m_tokenType = Grammar::LightNodeToken;
+    m_currentNode = newNode;
+    pushNode(newNode, pScene);
+
+    handleNodes(node, pScene);
+
+    popNode();
+
+    m_currentLight->mName.Set(newNode->mName.C_Str());
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleGeometryObject(DDLNode *node, aiScene *pScene) {
+    // parameters will be parsed normally in the tree, so just go for it
+    handleNodes(node, pScene);
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleCameraObject(ODDLParser::DDLNode *node, aiScene *pScene) {
+    // parameters will be parsed normally in the tree, so just go for it
+
+    handleNodes(node, pScene);
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleLightObject(ODDLParser::DDLNode *node, aiScene *pScene) {
+    aiLight *light(new aiLight);
+    m_lightCache.push_back(light);
+    std::string objName = node->getName();
+    if (!objName.empty()) {
+        light->mName.Set(objName);
+    }
+    m_currentLight = light;
+
+    Property *prop(node->findPropertyByName("type"));
+    if (nullptr != prop) {
+        if (nullptr != prop->m_value) {
+            std::string typeStr(prop->m_value->getString());
+            if ("point" == typeStr) {
+                m_currentLight->mType = aiLightSource_POINT;
+            } else if ("spot" == typeStr) {
+                m_currentLight->mType = aiLightSource_SPOT;
+            } else if ("infinite" == typeStr) {
+                m_currentLight->mType = aiLightSource_DIRECTIONAL;
+            }
+        }
+    }
+
+    // parameters will be parsed normally in the tree, so just go for it
+    handleNodes(node, pScene);
+}
+
+//------------------------------------------------------------------------------------------------
+static void setMatrix(aiNode *node, DataArrayList *transformData) {
+    ai_assert(nullptr != node);
+    ai_assert(nullptr != transformData);
+
+    float m[16];
+    size_t i(1);
+    Value *next(transformData->m_dataList->m_next);
+    m[0] = transformData->m_dataList->getFloat();
+    while (next != nullptr) {
+        m[i] = next->getFloat();
+        next = next->m_next;
+        i++;
+    }
+
+    ai_assert(i == 16);
+
+    node->mTransformation.a1 = m[0];
+    node->mTransformation.a2 = m[4];
+    node->mTransformation.a3 = m[8];
+    node->mTransformation.a4 = m[12];
+
+    node->mTransformation.b1 = m[1];
+    node->mTransformation.b2 = m[5];
+    node->mTransformation.b3 = m[9];
+    node->mTransformation.b4 = m[13];
+
+    node->mTransformation.c1 = m[2];
+    node->mTransformation.c2 = m[6];
+    node->mTransformation.c3 = m[10];
+    node->mTransformation.c4 = m[14];
+
+    node->mTransformation.d1 = m[3];
+    node->mTransformation.d2 = m[7];
+    node->mTransformation.d3 = m[11];
+    node->mTransformation.d4 = m[15];
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleTransformNode(ODDLParser::DDLNode *node, aiScene * /*pScene*/) {
+    if (nullptr == m_currentNode) {
+        throw DeadlyImportError("No parent node for name.");
+        return;
+    }
+
+    DataArrayList *transformData(node->getDataArrayList());
+    if (nullptr != transformData) {
+        if (transformData->m_numItems != 16) {
+            throw DeadlyImportError("Invalid number of data for transform matrix.");
+            return;
+        }
+        setMatrix(m_currentNode, transformData);
+    }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleMeshNode(ODDLParser::DDLNode *node, aiScene *pScene) {
+    m_currentMesh = new aiMesh;
+    const size_t meshidx(m_meshCache.size());
+    // ownership is transferred but a reference remains in m_currentMesh
+    m_meshCache.emplace_back(m_currentMesh);
+
+    Property *prop = node->getProperties();
+    if (nullptr != prop) {
+        std::string propName, propKey;
+        propId2StdString(prop, propName, propKey);
+        if ("primitive" == propName) {
+            if ("points" == propKey) {
+                m_currentMesh->mPrimitiveTypes |= aiPrimitiveType_POINT;
+            } else if ("lines" == propKey) {
+                m_currentMesh->mPrimitiveTypes |= aiPrimitiveType_LINE;
+            } else if ("triangles" == propKey) {
+                m_currentMesh->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
+            } else if ("quads" == propKey) {
+                m_currentMesh->mPrimitiveTypes |= aiPrimitiveType_POLYGON;
+            } else {
+                ASSIMP_LOG_WARN(propKey, " is not supported primitive type.");
+            }
+        }
+    }
+
+    handleNodes(node, pScene);
+
+    DDLNode *parent(node->getParent());
+    if (nullptr != parent) {
+        const std::string &name = parent->getName();
+        m_mesh2refMap[name] = meshidx;
+    }
+}
+
+//------------------------------------------------------------------------------------------------
+enum MeshAttribute {
+    None,
+    Position,
+    Color,
+    Normal,
+    TexCoord
+};
+
+constexpr auto PosToken = "position";
+constexpr auto ColToken = "color";
+constexpr auto NormalToken = "normal";
+constexpr auto TexCoordToken = "texcoord";
+
+//------------------------------------------------------------------------------------------------
+static MeshAttribute getAttributeByName(const char *attribName) {
+    ai_assert(nullptr != attribName);
+
+    if (0 == strcmp(PosToken, attribName)) {
+        return Position;
+    } else if (0 == strcmp(ColToken, attribName)) {
+        return Color;
+    } else if (0 == strcmp(NormalToken, attribName)) {
+        return Normal;
+    } else if (0 == strcmp(TexCoordToken, attribName)) {
+        return TexCoord;
+    }
+
+    return None;
+}
+
+//------------------------------------------------------------------------------------------------
+static void fillVector3(aiVector3D *vec3, Value *vals) {
+    ai_assert(nullptr != vec3);
+    ai_assert(nullptr != vals);
+
+    float x(0.0f), y(0.0f), z(0.0f);
+    Value *next(vals);
+    x = next->getFloat();
+    next = next->m_next;
+    y = next->getFloat();
+    next = next->m_next;
+    if (nullptr != next) {
+        z = next->getFloat();
+    }
+
+    vec3->Set(x, y, z);
+}
+
+//------------------------------------------------------------------------------------------------
+static void fillColor4(aiColor4D *col4, Value *vals) {
+    ai_assert(nullptr != col4);
+    ai_assert(nullptr != vals);
+
+    Value *next(vals);
+    col4->r = next->getFloat();
+    next = next->m_next;
+    if (!next) {
+        throw DeadlyImportError("OpenGEX: Not enough values to fill 4-element color, only 1");
+    }
+
+    col4->g = next->getFloat();
+    next = next->m_next;
+    if (!next) {
+        throw DeadlyImportError("OpenGEX: Not enough values to fill 4-element color, only 2");
+    }
+
+    col4->b = next->getFloat();
+    next = next->m_next;
+    if (!next) {
+        throw DeadlyImportError("OpenGEX: Not enough values to fill 4-element color, only 3");
+    }
+
+    col4->a = next->getFloat();
+}
+
+//------------------------------------------------------------------------------------------------
+static size_t countDataArrayListItems(DataArrayList *vaList) {
+    size_t numItems(0);
+    if (nullptr == vaList) {
+        return numItems;
+    }
+
+    DataArrayList *next(vaList);
+    while (nullptr != next) {
+        if (nullptr != vaList->m_dataList) {
+            numItems++;
+        }
+        next = next->m_next;
+    }
+
+    return numItems;
+}
+
+//------------------------------------------------------------------------------------------------
+static void copyVectorArray(size_t numItems, DataArrayList *vaList, aiVector3D *vectorArray) {
+    for (size_t i = 0; i < numItems; i++) {
+        Value *next(vaList->m_dataList);
+        fillVector3(&vectorArray[i], next);
+        vaList = vaList->m_next;
+    }
+}
+
+//------------------------------------------------------------------------------------------------
+static void copyColor4DArray(size_t numItems, DataArrayList *vaList, aiColor4D *colArray) {
+    for (size_t i = 0; i < numItems; i++) {
+        Value *next(vaList->m_dataList);
+        fillColor4(&colArray[i], next);
+    }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleVertexArrayNode(ODDLParser::DDLNode *node, aiScene * /*pScene*/) {
+    if (nullptr == node) {
+        throw DeadlyImportError("No parent node for name.");
+        return;
+    }
+
+    Property *prop = node->getProperties();
+    if (nullptr != prop) {
+        std::string propName, propKey;
+        propId2StdString(prop, propName, propKey);
+        MeshAttribute attribType(getAttributeByName(propKey.c_str()));
+        if (None == attribType) {
+            return;
+        }
+
+        DataArrayList *vaList = node->getDataArrayList();
+        if (nullptr == vaList) {
+            return;
+        }
+
+        const size_t numItems(countDataArrayListItems(vaList));
+
+        if (Position == attribType) {
+            m_currentVertices.m_vertices.resize(numItems);
+            copyVectorArray(numItems, vaList, m_currentVertices.m_vertices.data());
+        } else if (Color == attribType) {
+            m_currentVertices.m_numColors = numItems;
+            m_currentVertices.m_colors = new aiColor4D[numItems];
+            copyColor4DArray(numItems, vaList, m_currentVertices.m_colors);
+        } else if (Normal == attribType) {
+            m_currentVertices.m_normals.resize(numItems);
+            copyVectorArray(numItems, vaList, m_currentVertices.m_normals.data());
+        } else if (TexCoord == attribType) {
+            m_currentVertices.m_numUVComps[0] = numItems;
+            m_currentVertices.m_textureCoords[0] = new aiVector3D[numItems];
+            copyVectorArray(numItems, vaList, m_currentVertices.m_textureCoords[0]);
+        }
+    }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleIndexArrayNode(ODDLParser::DDLNode *node, aiScene * /*pScene*/) {
+    if (nullptr == node) {
+        throw DeadlyImportError("No parent node for name.");
+        return;
+    }
+
+    if (nullptr == m_currentMesh) {
+        throw DeadlyImportError("No current mesh for index data found.");
+        return;
+    }
+
+    DataArrayList *vaList = node->getDataArrayList();
+    if (nullptr == vaList) {
+        return;
+    }
+
+    const size_t numItems(countDataArrayListItems(vaList));
+    m_currentMesh->mNumFaces = static_cast<unsigned int>(numItems);
+    m_currentMesh->mFaces = new aiFace[numItems];
+    m_currentMesh->mNumVertices = static_cast<unsigned int>(numItems * 3);
+    m_currentMesh->mVertices = new aiVector3D[m_currentMesh->mNumVertices];
+    bool hasColors(false);
+    if (m_currentVertices.m_numColors > 0) {
+        m_currentMesh->mColors[0] = new aiColor4D[m_currentVertices.m_numColors];
+        hasColors = true;
+    }
+    bool hasNormalCoords(false);
+    if (!m_currentVertices.m_normals.empty()) {
+        m_currentMesh->mNormals = new aiVector3D[m_currentMesh->mNumVertices];
+        hasNormalCoords = true;
+    }
+    bool hasTexCoords(false);
+    if (m_currentVertices.m_numUVComps[0] > 0) {
+        m_currentMesh->mTextureCoords[0] = new aiVector3D[m_currentMesh->mNumVertices];
+        hasTexCoords = true;
+    }
+
+    unsigned int index(0);
+    for (size_t i = 0; i < m_currentMesh->mNumFaces; i++) {
+        aiFace &current(m_currentMesh->mFaces[i]);
+        current.mNumIndices = 3;
+        current.mIndices = new unsigned int[current.mNumIndices];
+        Value *next(vaList->m_dataList);
+        for (size_t indices = 0; indices < current.mNumIndices; indices++) {
+            const int idx(next->getUnsignedInt32());
+            ai_assert(static_cast<size_t>(idx) <= m_currentVertices.m_vertices.size());
+            ai_assert(index < m_currentMesh->mNumVertices);
+            aiVector3D &pos = (m_currentVertices.m_vertices[idx]);
+            m_currentMesh->mVertices[index].Set(pos.x, pos.y, pos.z);
+            if (hasColors) {
+                aiColor4D &col = m_currentVertices.m_colors[idx];
+                m_currentMesh->mColors[0][index] = col;
+            }
+            if (hasNormalCoords) {
+                aiVector3D &normal = (m_currentVertices.m_normals[idx]);
+                m_currentMesh->mNormals[index].Set(normal.x, normal.y, normal.z);
+            }
+            if (hasTexCoords) {
+                aiVector3D &tex = (m_currentVertices.m_textureCoords[0][idx]);
+                m_currentMesh->mTextureCoords[0][index].Set(tex.x, tex.y, tex.z);
+            }
+            current.mIndices[indices] = index;
+            index++;
+
+            next = next->m_next;
+        }
+        vaList = vaList->m_next;
+    }
+}
+
+//------------------------------------------------------------------------------------------------
+static void getColorRGB3(aiColor3D *pColor, DataArrayList *colList) {
+    if (nullptr == pColor || nullptr == colList) {
+        return;
+    }
+
+    ai_assert(3 == colList->m_numItems);
+    Value *val(colList->m_dataList);
+    pColor->r = val->getFloat();
+    val = val->getNext();
+    pColor->g = val->getFloat();
+    val = val->getNext();
+    pColor->b = val->getFloat();
+}
+
+//------------------------------------------------------------------------------------------------
+static void getColorRGB4(aiColor4D *pColor, DataArrayList *colList) {
+    if (nullptr == pColor || nullptr == colList) {
+        return;
+    }
+
+    ai_assert(4 == colList->m_numItems);
+    Value *val(colList->m_dataList);
+    pColor->r = val->getFloat();
+    val = val->getNext();
+    pColor->g = val->getFloat();
+    val = val->getNext();
+    pColor->b = val->getFloat();
+    val = val->getNext();
+    pColor->a = val->getFloat();
+}
+
+//------------------------------------------------------------------------------------------------
+enum ColorType {
+    NoneColor = 0,
+    DiffuseColor,
+    SpecularColor,
+    EmissionColor,
+    LightColor
+};
+
+//------------------------------------------------------------------------------------------------
+static ColorType getColorType(Text *id) {
+    if (nullptr == id) {
+        return NoneColor;
+    }
+
+    if (*id == Grammar::DiffuseColorToken) {
+        return DiffuseColor;
+    } else if (*id == Grammar::SpecularColorToken) {
+        return SpecularColor;
+    } else if (*id == Grammar::EmissionColorToken) {
+        return EmissionColor;
+    } else if (*id == "light") {
+        return LightColor;
+    }
+
+    return NoneColor;
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleMaterialNode(ODDLParser::DDLNode *node, aiScene *pScene) {
+    m_currentMaterial = new aiMaterial;
+    m_materialCache.push_back(m_currentMaterial);
+    m_tokenType = Grammar::MaterialToken;
+    handleNodes(node, pScene);
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleColorNode(ODDLParser::DDLNode *node, aiScene * /*pScene*/) {
+    if (nullptr == node) {
+        return;
+    }
+
+    Property *prop = node->findPropertyByName("attrib");
+    if (nullptr != prop) {
+        if (nullptr != prop->m_value) {
+            DataArrayList *colList(node->getDataArrayList());
+            if (nullptr == colList) {
+                return;
+            }
+            aiColor3D col;
+            if (3 == colList->m_numItems) {
+                aiColor3D col3;
+                getColorRGB3(&col3, colList);
+                col = col3;
+            } else {
+                aiColor4D col4;
+                getColorRGB4(&col4, colList);
+                col.r = col4.r;
+                col.g = col4.g;
+                col.b = col4.b;
+            }
+#ifdef ASSIMP_USE_HUNTER
+            const ColorType colType(getColorType(&prop->m_key->m_text));
+#else
+            const ColorType colType(getColorType(prop->m_key));
+#endif
+            if (DiffuseColor == colType) {
+                m_currentMaterial->AddProperty(&col, 1, AI_MATKEY_COLOR_DIFFUSE);
+            } else if (SpecularColor == colType) {
+                m_currentMaterial->AddProperty(&col, 1, AI_MATKEY_COLOR_SPECULAR);
+            } else if (EmissionColor == colType) {
+                m_currentMaterial->AddProperty(&col, 1, AI_MATKEY_COLOR_EMISSIVE);
+            } else if (LightColor == colType) {
+                m_currentLight->mColorDiffuse = col;
+            }
+        }
+    }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleTextureNode(ODDLParser::DDLNode *node, aiScene * /*pScene*/) {
+    if (nullptr == node) {
+        return;
+    }
+
+    Property *prop = node->findPropertyByName("attrib");
+    if (nullptr != prop) {
+        if (nullptr != prop->m_value) {
+            Value *val(node->getValue());
+            if (nullptr != val) {
+                aiString tex;
+                tex.Set(val->getString());
+                if (prop->m_value->getString() == Grammar::DiffuseTextureToken) {
+                    m_currentMaterial->AddProperty(&tex, AI_MATKEY_TEXTURE_DIFFUSE(0));
+                } else if (prop->m_value->getString() == Grammar::DiffuseSpecularTextureToken) {
+                    m_currentMaterial->AddProperty(&tex, AI_MATKEY_TEXTURE_SPECULAR(0));
+                } else if (prop->m_value->getString() == Grammar::SpecularPowerTextureToken) {
+                    m_currentMaterial->AddProperty(&tex, AI_MATKEY_TEXTURE_SPECULAR(0));
+                } else if (prop->m_value->getString() == Grammar::EmissionTextureToken) {
+                    m_currentMaterial->AddProperty(&tex, AI_MATKEY_TEXTURE_EMISSIVE(0));
+                } else if (prop->m_value->getString() == Grammar::OpacyTextureToken) {
+                    m_currentMaterial->AddProperty(&tex, AI_MATKEY_TEXTURE_OPACITY(0));
+                } else if (prop->m_value->getString() == Grammar::TransparencyTextureToken) {
+                    // ToDo!
+                    // m_currentMaterial->AddProperty( &tex, AI_MATKEY_TEXTURE_DIFFUSE( 0 ) );
+                } else if (prop->m_value->getString() == Grammar::NormalTextureToken) {
+                    m_currentMaterial->AddProperty(&tex, AI_MATKEY_TEXTURE_NORMALS(0));
+                } else {
+                    ai_assert(false);
+                }
+            }
+        }
+    }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleParamNode(ODDLParser::DDLNode *node, aiScene * /*pScene*/) {
+    if (nullptr == node) {
+        return;
+    }
+
+    Property *prop = node->findPropertyByName("attrib");
+    if (nullptr == prop) {
+        return;
+    }
+
+    if (nullptr != prop->m_value) {
+        Value *val(node->getValue());
+        if (nullptr == val) {
+            return;
+        }
+        const float floatVal(val->getFloat());
+        if (0 == ASSIMP_strincmp("fov", prop->m_value->getString(), 3)) {
+            m_currentCamera->mHorizontalFOV = floatVal;
+        } else if (0 == ASSIMP_strincmp("near", prop->m_value->getString(), 4)) {
+            m_currentCamera->mClipPlaneNear = floatVal;
+        } else if (0 == ASSIMP_strincmp("far", prop->m_value->getString(), 3)) {
+            m_currentCamera->mClipPlaneFar = floatVal;
+        }
+    }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::handleAttenNode(ODDLParser::DDLNode *node, aiScene * /*pScene*/) {
+    if (nullptr == node) {
+        return;
+    }
+
+    Property *prop = node->findPropertyByName("curve");
+    if (nullptr != prop) {
+        if (nullptr != prop->m_value) {
+            Value *val(node->getValue());
+            const float floatVal(val->getFloat());
+            if (0 == strncmp("scale", prop->m_value->getString(), strlen("scale"))) {
+                m_currentLight->mAttenuationQuadratic = floatVal;
+            }
+        }
+    }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::copyMeshes(aiScene *pScene) {
+    ai_assert(nullptr != pScene);
+
+    if (m_meshCache.empty()) {
+        return;
+    }
+
+    pScene->mNumMeshes = static_cast<unsigned int>(m_meshCache.size());
+    pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
+    for (unsigned int i = 0; i < pScene->mNumMeshes; i++) {
+        pScene->mMeshes[i] = m_meshCache[i].release();
+    }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::copyCameras(aiScene *pScene) {
+    ai_assert(nullptr != pScene);
+
+    if (m_cameraCache.empty()) {
+        return;
+    }
+
+    pScene->mNumCameras = static_cast<unsigned int>(m_cameraCache.size());
+    pScene->mCameras = new aiCamera *[pScene->mNumCameras];
+    std::copy(m_cameraCache.begin(), m_cameraCache.end(), pScene->mCameras);
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::copyLights(aiScene *pScene) {
+    ai_assert(nullptr != pScene);
+
+    if (m_lightCache.empty()) {
+        return;
+    }
+
+    pScene->mNumLights = static_cast<unsigned int>(m_lightCache.size());
+    pScene->mLights = new aiLight *[pScene->mNumLights];
+    std::copy(m_lightCache.begin(), m_lightCache.end(), pScene->mLights);
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::copyMaterials(aiScene *pScene) {
+    ai_assert(nullptr != pScene);
+
+    if (m_materialCache.empty()) {
+        return;
+    }
+
+    pScene->mNumMaterials = static_cast<unsigned int>(m_materialCache.size());
+    pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials];
+    std::copy(m_materialCache.begin(), m_materialCache.end(), pScene->mMaterials);
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::resolveReferences() {
+    if (m_unresolvedRefStack.empty()) {
+        return;
+    }
+
+    RefInfo *currentRefInfo(nullptr);
+    for (auto it = m_unresolvedRefStack.begin(); it != m_unresolvedRefStack.end(); ++it) {
+        currentRefInfo = it->get();
+        if (nullptr != currentRefInfo) {
+            aiNode *node(currentRefInfo->m_node);
+            if (RefInfo::MeshRef == currentRefInfo->m_type) {
+                for (size_t i = 0; i < currentRefInfo->m_Names.size(); ++i) {
+                    const std::string &name(currentRefInfo->m_Names[i]);
+                    ReferenceMap::const_iterator curIt(m_mesh2refMap.find(name));
+                    if (m_mesh2refMap.end() != curIt) {
+                        unsigned int meshIdx = static_cast<unsigned int>(m_mesh2refMap[name]);
+                        node->mMeshes[i] = meshIdx;
+                    }
+                }
+            } else if (RefInfo::MaterialRef == currentRefInfo->m_type) {
+                for (size_t i = 0; i < currentRefInfo->m_Names.size(); ++i) {
+                    const std::string name(currentRefInfo->m_Names[i]);
+                    ReferenceMap::const_iterator curIt(m_material2refMap.find(name));
+                    if (m_material2refMap.end() != curIt) {
+                        if (nullptr != m_currentMesh) {
+                            unsigned int matIdx = static_cast<unsigned int>(m_material2refMap[name]);
+                            if (m_currentMesh->mMaterialIndex != 0) {
+                                ASSIMP_LOG_WARN("Override of material reference in current mesh by material reference.");
+                            }
+                            m_currentMesh->mMaterialIndex = matIdx;
+                        } else {
+                            ASSIMP_LOG_WARN("Cannot resolve material reference, because no current mesh is there.");
+                        }
+                    }
+                }
+            } else {
+                throw DeadlyImportError("Unknown reference info to resolve.");
+            }
+        }
+    }
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::createNodeTree(aiScene *pScene) {
+    if (nullptr == m_root) {
+        return;
+    }
+
+    if (m_root->m_children.empty()) {
+        return;
+    }
+
+    pScene->mRootNode->mNumChildren = static_cast<unsigned int>(m_root->m_children.size());
+    pScene->mRootNode->mChildren = new aiNode *[pScene->mRootNode->mNumChildren];
+    std::copy(m_root->m_children.begin(), m_root->m_children.end(), pScene->mRootNode->mChildren);
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::pushNode(aiNode *node, aiScene *pScene) {
+    ai_assert(nullptr != pScene);
+
+    if (nullptr == node) {
+        return;
+    }
+
+    ChildInfo *info(nullptr);
+    if (m_nodeStack.empty()) {
+        node->mParent = pScene->mRootNode;
+        NodeChildMap::iterator it(m_nodeChildMap.find(node->mParent));
+        if (m_nodeChildMap.end() == it) {
+            info = new ChildInfo;
+            m_root = info;
+            m_nodeChildMap[node->mParent] = std::unique_ptr<ChildInfo>(info);
+        } else {
+            info = it->second.get();
+        }
+        info->m_children.push_back(node);
+    } else {
+        aiNode *parent(m_nodeStack.back());
+        ai_assert(nullptr != parent);
+        node->mParent = parent;
+        NodeChildMap::iterator it(m_nodeChildMap.find(node->mParent));
+        if (m_nodeChildMap.end() == it) {
+            info = new ChildInfo;
+            m_nodeChildMap[node->mParent] = std::unique_ptr<ChildInfo>(info);
+        } else {
+            info = it->second.get();
+        }
+        info->m_children.push_back(node);
+    }
+    m_nodeStack.push_back(node);
+}
+
+//------------------------------------------------------------------------------------------------
+aiNode *OpenGEXImporter::popNode() {
+    if (m_nodeStack.empty()) {
+        return nullptr;
+    }
+
+    aiNode *node(top());
+    m_nodeStack.pop_back();
+
+    return node;
+}
+
+//------------------------------------------------------------------------------------------------
+aiNode *OpenGEXImporter::top() const {
+    if (m_nodeStack.empty()) {
+        return nullptr;
+    }
+
+    return m_nodeStack.back();
+}
+
+//------------------------------------------------------------------------------------------------
+void OpenGEXImporter::clearNodeStack() {
+    m_nodeStack.clear();
+}
+
+//------------------------------------------------------------------------------------------------
+
+} // Namespace OpenGEX
+} // Namespace Assimp
+
+#endif // ASSIMP_BUILD_NO_OPENGEX_IMPORTER
diff --git a/Engine/lib/assimp/code/OpenGEX/OpenGEXImporter.h b/Engine/lib/assimp/code/AssetLib/OpenGEX/OpenGEXImporter.h
similarity index 91%
rename from Engine/lib/assimp/code/OpenGEX/OpenGEXImporter.h
rename to Engine/lib/assimp/code/AssetLib/OpenGEX/OpenGEXImporter.h
index 22b5cabef..fca3eb1d5 100644
--- a/Engine/lib/assimp/code/OpenGEX/OpenGEXImporter.h
+++ b/Engine/lib/assimp/code/AssetLib/OpenGEX/OpenGEXImporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -39,6 +39,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 ----------------------------------------------------------------------
 */
+#pragma once
 #ifndef AI_OPENGEX_IMPORTER_H
 #define AI_OPENGEX_IMPORTER_H
 
@@ -79,7 +80,7 @@ struct MetricInfo {
     int m_intValue;
 
     MetricInfo()
-    : m_stringValue( "" )
+    : m_stringValue( )
     , m_floatValue( 0.0f )
     , m_intValue( -1 ) {
         // empty
@@ -96,21 +97,21 @@ public:
     OpenGEXImporter();
 
     /// The class destructor.
-    virtual ~OpenGEXImporter();
+    ~OpenGEXImporter() override;
 
     /// BaseImporter override.
-    virtual bool CanRead( const std::string &file, IOSystem *pIOHandler, bool checkSig ) const;
-
-    /// BaseImporter override.
-    virtual void InternReadFile( const std::string &file, aiScene *pScene, IOSystem *pIOHandler );
-
-    /// BaseImporter override.
-    virtual const aiImporterDesc *GetInfo() const;
-
-    /// BaseImporter override.
-    virtual void SetupProperties( const Importer *pImp );
+    bool CanRead( const std::string &file, IOSystem *pIOHandler, bool checkSig ) const override;
 
 protected:
+    /// BaseImporter override.
+    void InternReadFile( const std::string &file, aiScene *pScene, IOSystem *pIOHandler ) override;
+
+    /// BaseImporter override.
+    virtual const aiImporterDesc *GetInfo() const override;
+
+    /// BaseImporter override.
+    virtual void SetupProperties( const Importer *pImp ) override;
+
     void handleNodes( ODDLParser::DDLNode *node, aiScene *pScene );
     void handleMetricNode( ODDLParser::DDLNode *node, aiScene *pScene );
     void handleNameNode( ODDLParser::DDLNode *node, aiScene *pScene );
@@ -176,15 +177,15 @@ private:
     };
 
     struct ChildInfo {
-        typedef std::list<aiNode*> NodeList;
+        using NodeList = std::list<aiNode*>;
         std::list<aiNode*> m_children;
     };
     ChildInfo *m_root;
-    typedef std::map<aiNode*, std::unique_ptr<ChildInfo> > NodeChildMap;
+    using NodeChildMap = std::map<aiNode*, std::unique_ptr<ChildInfo> >;
     NodeChildMap m_nodeChildMap;
 
     std::vector<std::unique_ptr<aiMesh> > m_meshCache;
-    typedef std::map<std::string, size_t> ReferenceMap;
+    using ReferenceMap = std::map<std::string, size_t>;
     std::map<std::string, size_t> m_mesh2refMap;
     std::map<std::string, size_t> m_material2refMap;
 
diff --git a/Engine/lib/assimp/code/OpenGEX/OpenGEXStructs.h b/Engine/lib/assimp/code/AssetLib/OpenGEX/OpenGEXStructs.h
similarity index 99%
rename from Engine/lib/assimp/code/OpenGEX/OpenGEXStructs.h
rename to Engine/lib/assimp/code/AssetLib/OpenGEX/OpenGEXStructs.h
index 2c83e8660..5f845483d 100644
--- a/Engine/lib/assimp/code/OpenGEX/OpenGEXStructs.h
+++ b/Engine/lib/assimp/code/AssetLib/OpenGEX/OpenGEXStructs.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Ply/PlyExporter.cpp b/Engine/lib/assimp/code/AssetLib/Ply/PlyExporter.cpp
similarity index 98%
rename from Engine/lib/assimp/code/Ply/PlyExporter.cpp
rename to Engine/lib/assimp/code/AssetLib/Ply/PlyExporter.cpp
index 5e21a88ac..a98b83f67 100644
--- a/Engine/lib/assimp/code/Ply/PlyExporter.cpp
+++ b/Engine/lib/assimp/code/AssetLib/Ply/PlyExporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -77,7 +77,7 @@ void ExportScenePly(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene
 
     // we're still here - export successfully completed. Write the file.
     std::unique_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wt"));
-    if(outfile == NULL) {
+    if (outfile == nullptr) {
         throw DeadlyExportError("could not open output .ply file: " + std::string(pFile));
     }
 
@@ -91,7 +91,7 @@ void ExportScenePlyBinary(const char* pFile, IOSystem* pIOSystem, const aiScene*
 
     // we're still here - export successfully completed. Write the file.
     std::unique_ptr<IOStream> outfile(pIOSystem->Open(pFile, "wb"));
-    if (outfile == NULL) {
+    if (outfile == nullptr) {
         throw DeadlyExportError("could not open output .ply file: " + std::string(pFile));
     }
 
@@ -373,10 +373,11 @@ void PlyExporter::WriteMeshIndices(const aiMesh* m, unsigned int offset)
 {
     for (unsigned int i = 0; i < m->mNumFaces; ++i) {
         const aiFace& f = m->mFaces[i];
-        mOutput << f.mNumIndices << " ";
+        mOutput << f.mNumIndices;
         for(unsigned int c = 0; c < f.mNumIndices; ++c) {
-            mOutput << (f.mIndices[c] + offset) << (c == f.mNumIndices-1 ? endl : " ");
+            mOutput << " " << (f.mIndices[c] + offset);
         }
+        mOutput << endl;
     }
 }
 
diff --git a/Engine/lib/assimp/code/Ply/PlyExporter.h b/Engine/lib/assimp/code/AssetLib/Ply/PlyExporter.h
similarity index 98%
rename from Engine/lib/assimp/code/Ply/PlyExporter.h
rename to Engine/lib/assimp/code/AssetLib/Ply/PlyExporter.h
index b82498cbd..ff3a54cb6 100644
--- a/Engine/lib/assimp/code/Ply/PlyExporter.h
+++ b/Engine/lib/assimp/code/AssetLib/Ply/PlyExporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Ply/PlyLoader.cpp b/Engine/lib/assimp/code/AssetLib/Ply/PlyLoader.cpp
similarity index 57%
rename from Engine/lib/assimp/code/Ply/PlyLoader.cpp
rename to Engine/lib/assimp/code/AssetLib/Ply/PlyLoader.cpp
index 3924305cb..6cf1a1c74 100644
--- a/Engine/lib/assimp/code/Ply/PlyLoader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/Ply/PlyLoader.cpp
@@ -3,8 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -49,11 +48,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // internal headers
 #include "PlyLoader.h"
 #include <assimp/IOStreamBuffer.h>
-#include <assimp/Macros.h>
-#include <memory>
-#include <assimp/IOSystem.hpp>
-#include <assimp/scene.h>
 #include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/IOSystem.hpp>
+#include <memory>
 
 using namespace ::Assimp;
 
@@ -70,29 +68,27 @@ static const aiImporterDesc desc = {
     "ply"
 };
 
-
 // ------------------------------------------------------------------------------------------------
 // Internal stuff
 namespace {
-    // ------------------------------------------------------------------------------------------------
-    // Checks that property index is within range
-    template <class T>
-    inline
-    const T &GetProperty(const std::vector<T> &props, int idx) {
-        if (static_cast<size_t>(idx) >= props.size()) {
-            throw DeadlyImportError("Invalid .ply file: Property index is out of range.");
-        }
-
-        return props[idx];
+// ------------------------------------------------------------------------------------------------
+// Checks that property index is within range
+template <class T>
+inline const T &GetProperty(const std::vector<T> &props, int idx) {
+    if (static_cast<size_t>(idx) >= props.size()) {
+        throw DeadlyImportError("Invalid .ply file: Property index is out of range.");
     }
+
+    return props[idx];
 }
+} // namespace
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-PLYImporter::PLYImporter()
-: mBuffer(nullptr)
-, pcDOM(nullptr)
-, mGeneratedMesh(nullptr) {
+PLYImporter::PLYImporter() :
+        mBuffer(nullptr),
+        pcDOM(nullptr),
+        mGeneratedMesh(nullptr) {
     // empty
 }
 
@@ -104,36 +100,25 @@ PLYImporter::~PLYImporter() {
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool PLYImporter::CanRead(const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const {
-    const std::string extension = GetExtension(pFile);
-
-    if ( extension == "ply" ) {
-        return true;
-    } else if (!extension.length() || checkSig) {
-        if ( !pIOHandler ) {
-            return true;
-        }
-        static const char* tokens[] = { "ply" };
-        return SearchFileHeaderForToken(pIOHandler, pFile, tokens, 1);
-    }
-
-    return false;
+bool PLYImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
+    static const char *tokens[] = { "ply" };
+    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------
-const aiImporterDesc* PLYImporter::GetInfo() const {
+const aiImporterDesc *PLYImporter::GetInfo() const {
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
-static bool isBigEndian(const char* szMe) {
+static bool isBigEndian(const char *szMe) {
     ai_assert(nullptr != szMe);
 
     // binary_little_endian
     // binary_big_endian
     bool isBigEndian(false);
 #if (defined AI_BUILD_BIG_ENDIAN)
-    if ( 'l' == *szMe || 'L' == *szMe ) {
+    if ('l' == *szMe || 'L' == *szMe) {
         isBigEndian = true;
     }
 #else
@@ -147,17 +132,17 @@ static bool isBigEndian(const char* szMe) {
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void PLYImporter::InternReadFile(const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) {
+void PLYImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
     const std::string mode = "rb";
     std::unique_ptr<IOStream> fileStream(pIOHandler->Open(pFile, mode));
     if (!fileStream.get()) {
-        throw DeadlyImportError("Failed to open file " + pFile + ".");
+        throw DeadlyImportError("Failed to open file ", pFile, ".");
     }
 
     // Get the file-size
-    const size_t fileSize( fileStream->FileSize() );
-    if ( 0 == fileSize ) {
-        throw DeadlyImportError("File " + pFile + " is empty.");
+    const size_t fileSize(fileStream->FileSize());
+    if (0 == fileSize) {
+        throw DeadlyImportError("File ", pFile, " is empty.");
     }
 
     IOStreamBuffer<char> streamedBuffer(1024 * 1024);
@@ -170,28 +155,28 @@ void PLYImporter::InternReadFile(const std::string& pFile, aiScene* pScene, IOSy
     if ((headerCheck.size() < 3) ||
             (headerCheck[0] != 'P' && headerCheck[0] != 'p') ||
             (headerCheck[1] != 'L' && headerCheck[1] != 'l') ||
-            (headerCheck[2] != 'Y' && headerCheck[2] != 'y') ) {
+            (headerCheck[2] != 'Y' && headerCheck[2] != 'y')) {
         streamedBuffer.close();
-        throw DeadlyImportError("Invalid .ply file: Magic number \'ply\' is no there");
+        throw DeadlyImportError("Invalid .ply file: Incorrect magic number (expected 'ply' or 'PLY').");
     }
 
     std::vector<char> mBuffer2;
     streamedBuffer.getNextLine(mBuffer2);
-    mBuffer = (unsigned char*)&mBuffer2[0];
+    mBuffer = (unsigned char *)&mBuffer2[0];
 
-    char* szMe = (char*)&this->mBuffer[0];
-    SkipSpacesAndLineEnd(szMe, (const char**)&szMe);
+    char *szMe = (char *)&this->mBuffer[0];
+    SkipSpacesAndLineEnd(szMe, (const char **)&szMe);
 
     // determine the format of the file data and construct the aiMesh
-    PLY::DOM sPlyDom;   
+    PLY::DOM sPlyDom;
     this->pcDOM = &sPlyDom;
 
     if (TokenMatch(szMe, "format", 6)) {
         if (TokenMatch(szMe, "ascii", 5)) {
-            SkipLine(szMe, (const char**)&szMe);
+            SkipLine(szMe, (const char **)&szMe);
             if (!PLY::DOM::ParseInstance(streamedBuffer, &sPlyDom, this)) {
                 if (mGeneratedMesh != nullptr) {
-                    delete(mGeneratedMesh);
+                    delete (mGeneratedMesh);
                     mGeneratedMesh = nullptr;
                 }
 
@@ -205,7 +190,7 @@ void PLYImporter::InternReadFile(const std::string& pFile, aiScene* pScene, IOSy
             // skip the line, parse the rest of the header and build the DOM
             if (!PLY::DOM::ParseInstanceBinary(streamedBuffer, &sPlyDom, this, bIsBE)) {
                 if (mGeneratedMesh != nullptr) {
-                    delete(mGeneratedMesh);
+                    delete (mGeneratedMesh);
                     mGeneratedMesh = nullptr;
                 }
 
@@ -214,7 +199,7 @@ void PLYImporter::InternReadFile(const std::string& pFile, aiScene* pScene, IOSy
             }
         } else {
             if (mGeneratedMesh != nullptr) {
-                delete(mGeneratedMesh);
+                delete (mGeneratedMesh);
                 mGeneratedMesh = nullptr;
             }
 
@@ -224,7 +209,7 @@ void PLYImporter::InternReadFile(const std::string& pFile, aiScene* pScene, IOSy
     } else {
         AI_DEBUG_INVALIDATE_PTR(this->mBuffer);
         if (mGeneratedMesh != nullptr) {
-            delete(mGeneratedMesh);
+            delete (mGeneratedMesh);
             mGeneratedMesh = nullptr;
         }
 
@@ -243,24 +228,24 @@ void PLYImporter::InternReadFile(const std::string& pFile, aiScene* pScene, IOSy
     // list is containing a list of points
     bool pointsOnly = mGeneratedMesh->mFaces == nullptr ? true : false;
     if (pointsOnly) {
-      mGeneratedMesh->mPrimitiveTypes = aiPrimitiveType::aiPrimitiveType_POINT;
+        mGeneratedMesh->mPrimitiveTypes = aiPrimitiveType::aiPrimitiveType_POINT;
     }
 
     // now load a list of all materials
-    std::vector<aiMaterial*> avMaterials;
+    std::vector<aiMaterial *> avMaterials;
     std::string defaultTexture;
     LoadMaterial(&avMaterials, defaultTexture, pointsOnly);
 
     // now generate the output scene object. Fill the material list
     pScene->mNumMaterials = (unsigned int)avMaterials.size();
-    pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials];
+    pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials];
     for (unsigned int i = 0; i < pScene->mNumMaterials; ++i) {
         pScene->mMaterials[i] = avMaterials[i];
     }
 
     // fill the mesh list
     pScene->mNumMeshes = 1;
-    pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];
+    pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
     pScene->mMeshes[0] = mGeneratedMesh;
     mGeneratedMesh = nullptr;
 
@@ -274,7 +259,7 @@ void PLYImporter::InternReadFile(const std::string& pFile, aiScene* pScene, IOSy
     }
 }
 
-void PLYImporter::LoadVertex(const PLY::Element* pcElement, const PLY::ElementInstance* instElement, unsigned int pos) {
+void PLYImporter::LoadVertex(const PLY::Element *pcElement, const PLY::ElementInstance *instElement, unsigned int pos) {
     ai_assert(nullptr != pcElement);
     ai_assert(nullptr != instElement);
 
@@ -291,8 +276,8 @@ void PLYImporter::LoadVertex(const PLY::Element* pcElement, const PLY::ElementIn
     PLY::EDataType aiTexcoordTypes[2] = { EDT_Char, EDT_Char };
 
     // now check whether which normal components are available
-    unsigned int _a( 0 ), cnt( 0 );
-    for ( std::vector<PLY::Property>::const_iterator a = pcElement->alProperties.begin();
+    unsigned int _a(0), cnt(0);
+    for (std::vector<PLY::Property>::const_iterator a = pcElement->alProperties.begin();
             a != pcElement->alProperties.end(); ++a, ++_a) {
         if ((*a).bIsList) {
             continue;
@@ -359,17 +344,17 @@ void PLYImporter::LoadVertex(const PLY::Element* pcElement, const PLY::ElementIn
         aiVector3D vOut;
         if (0xFFFFFFFF != aiPositions[0]) {
             vOut.x = PLY::PropertyInstance::ConvertTo<ai_real>(
-                GetProperty(instElement->alProperties, aiPositions[0]).avList.front(), aiTypes[0]);
+                    GetProperty(instElement->alProperties, aiPositions[0]).avList.front(), aiTypes[0]);
         }
 
         if (0xFFFFFFFF != aiPositions[1]) {
             vOut.y = PLY::PropertyInstance::ConvertTo<ai_real>(
-                GetProperty(instElement->alProperties, aiPositions[1]).avList.front(), aiTypes[1]);
+                    GetProperty(instElement->alProperties, aiPositions[1]).avList.front(), aiTypes[1]);
         }
 
         if (0xFFFFFFFF != aiPositions[2]) {
             vOut.z = PLY::PropertyInstance::ConvertTo<ai_real>(
-                GetProperty(instElement->alProperties, aiPositions[2]).avList.front(), aiTypes[2]);
+                    GetProperty(instElement->alProperties, aiPositions[2]).avList.front(), aiTypes[2]);
         }
 
         // Normals
@@ -377,19 +362,19 @@ void PLYImporter::LoadVertex(const PLY::Element* pcElement, const PLY::ElementIn
         bool haveNormal = false;
         if (0xFFFFFFFF != aiNormal[0]) {
             nOut.x = PLY::PropertyInstance::ConvertTo<ai_real>(
-                GetProperty(instElement->alProperties, aiNormal[0]).avList.front(), aiNormalTypes[0]);
+                    GetProperty(instElement->alProperties, aiNormal[0]).avList.front(), aiNormalTypes[0]);
             haveNormal = true;
         }
 
         if (0xFFFFFFFF != aiNormal[1]) {
             nOut.y = PLY::PropertyInstance::ConvertTo<ai_real>(
-                GetProperty(instElement->alProperties, aiNormal[1]).avList.front(), aiNormalTypes[1]);
+                    GetProperty(instElement->alProperties, aiNormal[1]).avList.front(), aiNormalTypes[1]);
             haveNormal = true;
         }
 
         if (0xFFFFFFFF != aiNormal[2]) {
             nOut.z = PLY::PropertyInstance::ConvertTo<ai_real>(
-                GetProperty(instElement->alProperties, aiNormal[2]).avList.front(), aiNormalTypes[2]);
+                    GetProperty(instElement->alProperties, aiNormal[2]).avList.front(), aiNormalTypes[2]);
             haveNormal = true;
         }
 
@@ -398,19 +383,25 @@ void PLYImporter::LoadVertex(const PLY::Element* pcElement, const PLY::ElementIn
         bool haveColor = false;
         if (0xFFFFFFFF != aiColors[0]) {
             cOut.r = NormalizeColorValue(GetProperty(instElement->alProperties,
-                aiColors[0]).avList.front(), aiColorsTypes[0]);
+                                                 aiColors[0])
+                                                 .avList.front(),
+                    aiColorsTypes[0]);
             haveColor = true;
         }
 
         if (0xFFFFFFFF != aiColors[1]) {
             cOut.g = NormalizeColorValue(GetProperty(instElement->alProperties,
-                aiColors[1]).avList.front(), aiColorsTypes[1]);
+                                                 aiColors[1])
+                                                 .avList.front(),
+                    aiColorsTypes[1]);
             haveColor = true;
         }
 
         if (0xFFFFFFFF != aiColors[2]) {
             cOut.b = NormalizeColorValue(GetProperty(instElement->alProperties,
-                aiColors[2]).avList.front(), aiColorsTypes[2]);
+                                                 aiColors[2])
+                                                 .avList.front(),
+                    aiColorsTypes[2]);
             haveColor = true;
         }
 
@@ -419,7 +410,9 @@ void PLYImporter::LoadVertex(const PLY::Element* pcElement, const PLY::ElementIn
             cOut.a = 1.0;
         } else {
             cOut.a = NormalizeColorValue(GetProperty(instElement->alProperties,
-                aiColors[3]).avList.front(), aiColorsTypes[3]);
+                                                 aiColors[3])
+                                                 .avList.front(),
+                    aiColorsTypes[3]);
 
             haveColor = true;
         }
@@ -430,18 +423,18 @@ void PLYImporter::LoadVertex(const PLY::Element* pcElement, const PLY::ElementIn
         bool haveTextureCoords = false;
         if (0xFFFFFFFF != aiTexcoord[0]) {
             tOut.x = PLY::PropertyInstance::ConvertTo<ai_real>(
-                GetProperty(instElement->alProperties, aiTexcoord[0]).avList.front(), aiTexcoordTypes[0]);
+                    GetProperty(instElement->alProperties, aiTexcoord[0]).avList.front(), aiTexcoordTypes[0]);
             haveTextureCoords = true;
         }
 
         if (0xFFFFFFFF != aiTexcoord[1]) {
             tOut.y = PLY::PropertyInstance::ConvertTo<ai_real>(
-                GetProperty(instElement->alProperties, aiTexcoord[1]).avList.front(), aiTexcoordTypes[1]);
+                    GetProperty(instElement->alProperties, aiTexcoord[1]).avList.front(), aiTexcoordTypes[1]);
             haveTextureCoords = true;
         }
 
         //create aiMesh if needed
-        if ( nullptr == mGeneratedMesh ) {
+        if (nullptr == mGeneratedMesh) {
             mGeneratedMesh = new aiMesh();
             mGeneratedMesh->mMaterialIndex = 0;
         }
@@ -475,29 +468,28 @@ void PLYImporter::LoadVertex(const PLY::Element* pcElement, const PLY::ElementIn
     }
 }
 
-
 // ------------------------------------------------------------------------------------------------
 // Convert a color component to [0...1]
 ai_real PLYImporter::NormalizeColorValue(PLY::PropertyInstance::ValueUnion val, PLY::EDataType eType) {
     switch (eType) {
-        case EDT_Float:
-            return val.fFloat;
-        case EDT_Double:
-            return (ai_real)val.fDouble;
-        case EDT_UChar:
-            return (ai_real)val.iUInt / (ai_real)0xFF;
-        case EDT_Char:
-            return (ai_real)(val.iInt + (0xFF / 2)) / (ai_real)0xFF;
-        case EDT_UShort:
-            return (ai_real)val.iUInt / (ai_real)0xFFFF;
-        case EDT_Short:
-            return (ai_real)(val.iInt + (0xFFFF / 2)) / (ai_real)0xFFFF;
-        case EDT_UInt:
-            return (ai_real)val.iUInt / (ai_real)0xFFFF;
-        case EDT_Int:
-            return ((ai_real)val.iInt / (ai_real)0xFF) + 0.5f;
-        default:
-            break;
+    case EDT_Float:
+        return val.fFloat;
+    case EDT_Double:
+        return (ai_real)val.fDouble;
+    case EDT_UChar:
+        return (ai_real)val.iUInt / (ai_real)0xFF;
+    case EDT_Char:
+        return (ai_real)(val.iInt + (0xFF / 2)) / (ai_real)0xFF;
+    case EDT_UShort:
+        return (ai_real)val.iUInt / (ai_real)0xFFFF;
+    case EDT_Short:
+        return (ai_real)(val.iInt + (0xFFFF / 2)) / (ai_real)0xFFFF;
+    case EDT_UInt:
+        return (ai_real)val.iUInt / (ai_real)0xFFFF;
+    case EDT_Int:
+        return ((ai_real)val.iInt / (ai_real)0xFF) + 0.5f;
+    default:
+        break;
     }
 
     return 0.0f;
@@ -505,7 +497,7 @@ ai_real PLYImporter::NormalizeColorValue(PLY::PropertyInstance::ValueUnion val,
 
 // ------------------------------------------------------------------------------------------------
 // Try to extract proper faces from the PLY DOM
-void PLYImporter::LoadFace(const PLY::Element* pcElement, const PLY::ElementInstance* instElement,
+void PLYImporter::LoadFace(const PLY::Element *pcElement, const PLY::ElementInstance *instElement,
         unsigned int pos) {
     ai_assert(nullptr != pcElement);
     ai_assert(nullptr != instElement);
@@ -587,16 +579,16 @@ void PLYImporter::LoadFace(const PLY::Element* pcElement, const PLY::ElementInst
                 mGeneratedMesh->mFaces[pos].mIndices = new unsigned int[iNum];
 
                 std::vector<PLY::PropertyInstance::ValueUnion>::const_iterator p =
-                GetProperty(instElement->alProperties, iProperty).avList.begin();
+                        GetProperty(instElement->alProperties, iProperty).avList.begin();
 
                 for (unsigned int a = 0; a < iNum; ++a, ++p) {
                     mGeneratedMesh->mFaces[pos].mIndices[a] = PLY::PropertyInstance::ConvertTo<unsigned int>(*p, eType);
                 }
             }
 
-        // parse the material index
-        // cannot be handled without processing the whole file first
-        /*if (0xFFFFFFFF != iMaterialIndex)
+            // parse the material index
+            // cannot be handled without processing the whole file first
+            /*if (0xFFFFFFFF != iMaterialIndex)
         {
             mGeneratedMesh->mFaces[pos]. = PLY::PropertyInstance::ConvertTo<unsigned int>(
             GetProperty(instElement->alProperties, iMaterialIndex).avList.front(), eType2);
@@ -607,14 +599,14 @@ void PLYImporter::LoadFace(const PLY::Element* pcElement, const PLY::ElementInst
 
                 //should be 6 coords
                 std::vector<PLY::PropertyInstance::ValueUnion>::const_iterator p =
-                GetProperty(instElement->alProperties, iTextureCoord).avList.begin();
+                        GetProperty(instElement->alProperties, iTextureCoord).avList.begin();
 
                 if ((iNum / 3) == 2) // X Y coord
                 {
                     for (unsigned int a = 0; a < iNum; ++a, ++p) {
                         unsigned int vindex = mGeneratedMesh->mFaces[pos].mIndices[a / 2];
                         if (vindex < mGeneratedMesh->mNumVertices) {
-                            if (mGeneratedMesh->mTextureCoords[0] == nullptr ) {
+                            if (mGeneratedMesh->mTextureCoords[0] == nullptr) {
                                 mGeneratedMesh->mNumUVComponents[0] = 2;
                                 mGeneratedMesh->mTextureCoords[0] = new aiVector3D[mGeneratedMesh->mNumVertices];
                             }
@@ -634,11 +626,11 @@ void PLYImporter::LoadFace(const PLY::Element* pcElement, const PLY::ElementInst
             // normally we have only one triangle strip instance where
             // a value of -1 indicates a restart of the strip
             bool flip = false;
-            const std::vector<PLY::PropertyInstance::ValueUnion>& quak = GetProperty(instElement->alProperties, iProperty).avList;
+            const std::vector<PLY::PropertyInstance::ValueUnion> &quak = GetProperty(instElement->alProperties, iProperty).avList;
             //pvOut->reserve(pvOut->size() + quak.size() + (quak.size()>>2u)); //Limits memory consumption
 
             int aiTable[2] = { -1, -1 };
-            for (std::vector<PLY::PropertyInstance::ValueUnion>::const_iterator a = quak.begin(); a != quak.end(); ++a)  {
+            for (std::vector<PLY::PropertyInstance::ValueUnion>::const_iterator a = quak.begin(); a != quak.end(); ++a) {
                 const int p = PLY::PropertyInstance::ConvertTo<int>(*a, eType);
 
                 if (-1 == p) {
@@ -669,7 +661,7 @@ void PLYImporter::LoadFace(const PLY::Element* pcElement, const PLY::ElementInst
 
                 // every second pass swap the indices.
                 flip = !flip;
-                if ( flip ) {
+                if (flip) {
                     std::swap(mGeneratedMesh->mFaces[pos].mIndices[0], mGeneratedMesh->mFaces[pos].mIndices[1]);
                 }
 
@@ -682,285 +674,254 @@ void PLYImporter::LoadFace(const PLY::Element* pcElement, const PLY::ElementInst
 
 // ------------------------------------------------------------------------------------------------
 // Get a RGBA color in [0...1] range
-void PLYImporter::GetMaterialColor(const std::vector<PLY::PropertyInstance>& avList,
-  unsigned int aiPositions[4],
-  PLY::EDataType aiTypes[4],
-  aiColor4D* clrOut)
-{
-  ai_assert(NULL != clrOut);
+void PLYImporter::GetMaterialColor(const std::vector<PLY::PropertyInstance> &avList,
+        unsigned int aiPositions[4],
+        PLY::EDataType aiTypes[4],
+        aiColor4D *clrOut) {
+    ai_assert(nullptr != clrOut);
 
-  if (0xFFFFFFFF == aiPositions[0])clrOut->r = 0.0f;
-  else
-  {
-    clrOut->r = NormalizeColorValue(GetProperty(avList,
-      aiPositions[0]).avList.front(), aiTypes[0]);
-  }
+    if (0xFFFFFFFF == aiPositions[0])
+        clrOut->r = 0.0f;
+    else {
+        clrOut->r = NormalizeColorValue(GetProperty(avList,
+                                                aiPositions[0])
+                                                .avList.front(),
+                aiTypes[0]);
+    }
 
-  if (0xFFFFFFFF == aiPositions[1])clrOut->g = 0.0f;
-  else
-  {
-    clrOut->g = NormalizeColorValue(GetProperty(avList,
-      aiPositions[1]).avList.front(), aiTypes[1]);
-  }
+    if (0xFFFFFFFF == aiPositions[1])
+        clrOut->g = 0.0f;
+    else {
+        clrOut->g = NormalizeColorValue(GetProperty(avList,
+                                                aiPositions[1])
+                                                .avList.front(),
+                aiTypes[1]);
+    }
 
-  if (0xFFFFFFFF == aiPositions[2])clrOut->b = 0.0f;
-  else
-  {
-    clrOut->b = NormalizeColorValue(GetProperty(avList,
-      aiPositions[2]).avList.front(), aiTypes[2]);
-  }
+    if (0xFFFFFFFF == aiPositions[2])
+        clrOut->b = 0.0f;
+    else {
+        clrOut->b = NormalizeColorValue(GetProperty(avList,
+                                                aiPositions[2])
+                                                .avList.front(),
+                aiTypes[2]);
+    }
 
-  // assume 1.0 for the alpha channel ifit is not set
-  if (0xFFFFFFFF == aiPositions[3])clrOut->a = 1.0f;
-  else
-  {
-    clrOut->a = NormalizeColorValue(GetProperty(avList,
-      aiPositions[3]).avList.front(), aiTypes[3]);
-  }
+    // assume 1.0 for the alpha channel ifit is not set
+    if (0xFFFFFFFF == aiPositions[3])
+        clrOut->a = 1.0f;
+    else {
+        clrOut->a = NormalizeColorValue(GetProperty(avList,
+                                                aiPositions[3])
+                                                .avList.front(),
+                aiTypes[3]);
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Extract a material from the PLY DOM
-void PLYImporter::LoadMaterial(std::vector<aiMaterial*>* pvOut, std::string &defaultTexture, const bool pointsOnly)
-{
-  ai_assert(NULL != pvOut);
+void PLYImporter::LoadMaterial(std::vector<aiMaterial *> *pvOut, std::string &defaultTexture, const bool pointsOnly) {
+    ai_assert(nullptr != pvOut);
 
-  // diffuse[4], specular[4], ambient[4]
-  // rgba order
-  unsigned int aaiPositions[3][4] = {
+    // diffuse[4], specular[4], ambient[4]
+    // rgba order
+    unsigned int aaiPositions[3][4] = {
 
-    { 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF },
-    { 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF },
-    { 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF },
-  };
+        { 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF },
+        { 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF },
+        { 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF },
+    };
 
-  PLY::EDataType aaiTypes[3][4] = {
-    { EDT_Char, EDT_Char, EDT_Char, EDT_Char },
-    { EDT_Char, EDT_Char, EDT_Char, EDT_Char },
-    { EDT_Char, EDT_Char, EDT_Char, EDT_Char }
-  };
-  PLY::ElementInstanceList* pcList = NULL;
+    PLY::EDataType aaiTypes[3][4] = {
+        { EDT_Char, EDT_Char, EDT_Char, EDT_Char },
+        { EDT_Char, EDT_Char, EDT_Char, EDT_Char },
+        { EDT_Char, EDT_Char, EDT_Char, EDT_Char }
+    };
+    PLY::ElementInstanceList *pcList = nullptr;
 
-  unsigned int iPhong = 0xFFFFFFFF;
-  PLY::EDataType ePhong = EDT_Char;
+    unsigned int iPhong = 0xFFFFFFFF;
+    PLY::EDataType ePhong = EDT_Char;
 
-  unsigned int iOpacity = 0xFFFFFFFF;
-  PLY::EDataType eOpacity = EDT_Char;
+    unsigned int iOpacity = 0xFFFFFFFF;
+    PLY::EDataType eOpacity = EDT_Char;
 
-  // search in the DOM for a vertex entry
-  unsigned int _i = 0;
-  for (std::vector<PLY::Element>::const_iterator i = this->pcDOM->alElements.begin();
-    i != this->pcDOM->alElements.end(); ++i, ++_i)
-  {
-    if (PLY::EEST_Material == (*i).eSemantic)
-    {
-      pcList = &this->pcDOM->alElementData[_i];
+    // search in the DOM for a vertex entry
+    unsigned int _i = 0;
+    for (std::vector<PLY::Element>::const_iterator i = this->pcDOM->alElements.begin();
+            i != this->pcDOM->alElements.end(); ++i, ++_i) {
+        if (PLY::EEST_Material == (*i).eSemantic) {
+            pcList = &this->pcDOM->alElementData[_i];
 
-      // now check whether which coordinate sets are available
-      unsigned int _a = 0;
-      for (std::vector<PLY::Property>::const_iterator
-        a = (*i).alProperties.begin();
-        a != (*i).alProperties.end(); ++a, ++_a)
-      {
-        if ((*a).bIsList)continue;
+            // now check whether which coordinate sets are available
+            unsigned int _a = 0;
+            for (std::vector<PLY::Property>::const_iterator
+                            a = (*i).alProperties.begin();
+                    a != (*i).alProperties.end(); ++a, ++_a) {
+                if ((*a).bIsList) continue;
 
-        // pohng specularity      -----------------------------------
-        if (PLY::EST_PhongPower == (*a).Semantic)
-        {
-          iPhong = _a;
-          ePhong = (*a).eType;
-        }
+                // pohng specularity      -----------------------------------
+                if (PLY::EST_PhongPower == (*a).Semantic) {
+                    iPhong = _a;
+                    ePhong = (*a).eType;
+                }
 
-        // general opacity        -----------------------------------
-        if (PLY::EST_Opacity == (*a).Semantic)
-        {
-          iOpacity = _a;
-          eOpacity = (*a).eType;
-        }
+                // general opacity        -----------------------------------
+                if (PLY::EST_Opacity == (*a).Semantic) {
+                    iOpacity = _a;
+                    eOpacity = (*a).eType;
+                }
 
-        // diffuse color channels -----------------------------------
-        if (PLY::EST_DiffuseRed == (*a).Semantic)
-        {
-          aaiPositions[0][0] = _a;
-          aaiTypes[0][0] = (*a).eType;
+                // diffuse color channels -----------------------------------
+                if (PLY::EST_DiffuseRed == (*a).Semantic) {
+                    aaiPositions[0][0] = _a;
+                    aaiTypes[0][0] = (*a).eType;
+                } else if (PLY::EST_DiffuseGreen == (*a).Semantic) {
+                    aaiPositions[0][1] = _a;
+                    aaiTypes[0][1] = (*a).eType;
+                } else if (PLY::EST_DiffuseBlue == (*a).Semantic) {
+                    aaiPositions[0][2] = _a;
+                    aaiTypes[0][2] = (*a).eType;
+                } else if (PLY::EST_DiffuseAlpha == (*a).Semantic) {
+                    aaiPositions[0][3] = _a;
+                    aaiTypes[0][3] = (*a).eType;
+                }
+                // specular color channels -----------------------------------
+                else if (PLY::EST_SpecularRed == (*a).Semantic) {
+                    aaiPositions[1][0] = _a;
+                    aaiTypes[1][0] = (*a).eType;
+                } else if (PLY::EST_SpecularGreen == (*a).Semantic) {
+                    aaiPositions[1][1] = _a;
+                    aaiTypes[1][1] = (*a).eType;
+                } else if (PLY::EST_SpecularBlue == (*a).Semantic) {
+                    aaiPositions[1][2] = _a;
+                    aaiTypes[1][2] = (*a).eType;
+                } else if (PLY::EST_SpecularAlpha == (*a).Semantic) {
+                    aaiPositions[1][3] = _a;
+                    aaiTypes[1][3] = (*a).eType;
+                }
+                // ambient color channels -----------------------------------
+                else if (PLY::EST_AmbientRed == (*a).Semantic) {
+                    aaiPositions[2][0] = _a;
+                    aaiTypes[2][0] = (*a).eType;
+                } else if (PLY::EST_AmbientGreen == (*a).Semantic) {
+                    aaiPositions[2][1] = _a;
+                    aaiTypes[2][1] = (*a).eType;
+                } else if (PLY::EST_AmbientBlue == (*a).Semantic) {
+                    aaiPositions[2][2] = _a;
+                    aaiTypes[2][2] = (*a).eType;
+                } else if (PLY::EST_AmbientAlpha == (*a).Semantic) {
+                    aaiPositions[2][3] = _a;
+                    aaiTypes[2][3] = (*a).eType;
+                }
+            }
+            break;
+        } else if (PLY::EEST_TextureFile == (*i).eSemantic) {
+            defaultTexture = (*i).szName;
         }
-        else if (PLY::EST_DiffuseGreen == (*a).Semantic)
-        {
-          aaiPositions[0][1] = _a;
-          aaiTypes[0][1] = (*a).eType;
-        }
-        else if (PLY::EST_DiffuseBlue == (*a).Semantic)
-        {
-          aaiPositions[0][2] = _a;
-          aaiTypes[0][2] = (*a).eType;
-        }
-        else if (PLY::EST_DiffuseAlpha == (*a).Semantic)
-        {
-          aaiPositions[0][3] = _a;
-          aaiTypes[0][3] = (*a).eType;
-        }
-        // specular color channels -----------------------------------
-        else if (PLY::EST_SpecularRed == (*a).Semantic)
-        {
-          aaiPositions[1][0] = _a;
-          aaiTypes[1][0] = (*a).eType;
-        }
-        else if (PLY::EST_SpecularGreen == (*a).Semantic)
-        {
-          aaiPositions[1][1] = _a;
-          aaiTypes[1][1] = (*a).eType;
-        }
-        else if (PLY::EST_SpecularBlue == (*a).Semantic)
-        {
-          aaiPositions[1][2] = _a;
-          aaiTypes[1][2] = (*a).eType;
-        }
-        else if (PLY::EST_SpecularAlpha == (*a).Semantic)
-        {
-          aaiPositions[1][3] = _a;
-          aaiTypes[1][3] = (*a).eType;
-        }
-        // ambient color channels -----------------------------------
-        else if (PLY::EST_AmbientRed == (*a).Semantic)
-        {
-          aaiPositions[2][0] = _a;
-          aaiTypes[2][0] = (*a).eType;
-        }
-        else if (PLY::EST_AmbientGreen == (*a).Semantic)
-        {
-          aaiPositions[2][1] = _a;
-          aaiTypes[2][1] = (*a).eType;
-        }
-        else if (PLY::EST_AmbientBlue == (*a).Semantic)
-        {
-          aaiPositions[2][2] = _a;
-          aaiTypes[2][2] = (*a).eType;
-        }
-        else if (PLY::EST_AmbientAlpha == (*a).Semantic)
-        {
-          aaiPositions[2][3] = _a;
-          aaiTypes[2][3] = (*a).eType;
-        }
-      }
-      break;
     }
-    else if (PLY::EEST_TextureFile == (*i).eSemantic)
-    {
-      defaultTexture = (*i).szName;
-    }
-  }
-  // check whether we have a valid source for the material data
-  if (NULL != pcList) {
-    for (std::vector<ElementInstance>::const_iterator i = pcList->alInstances.begin(); i != pcList->alInstances.end(); ++i)  {
-      aiColor4D clrOut;
-      aiMaterial* pcHelper = new aiMaterial();
+    // check whether we have a valid source for the material data
+    if (nullptr != pcList) {
+        for (std::vector<ElementInstance>::const_iterator i = pcList->alInstances.begin(); i != pcList->alInstances.end(); ++i) {
+            aiColor4D clrOut;
+            aiMaterial *pcHelper = new aiMaterial();
 
-      // build the diffuse material color
-      GetMaterialColor((*i).alProperties, aaiPositions[0], aaiTypes[0], &clrOut);
-      pcHelper->AddProperty<aiColor4D>(&clrOut, 1, AI_MATKEY_COLOR_DIFFUSE);
+            // build the diffuse material color
+            GetMaterialColor((*i).alProperties, aaiPositions[0], aaiTypes[0], &clrOut);
+            pcHelper->AddProperty<aiColor4D>(&clrOut, 1, AI_MATKEY_COLOR_DIFFUSE);
 
-      // build the specular material color
-      GetMaterialColor((*i).alProperties, aaiPositions[1], aaiTypes[1], &clrOut);
-      pcHelper->AddProperty<aiColor4D>(&clrOut, 1, AI_MATKEY_COLOR_SPECULAR);
+            // build the specular material color
+            GetMaterialColor((*i).alProperties, aaiPositions[1], aaiTypes[1], &clrOut);
+            pcHelper->AddProperty<aiColor4D>(&clrOut, 1, AI_MATKEY_COLOR_SPECULAR);
 
-      // build the ambient material color
-      GetMaterialColor((*i).alProperties, aaiPositions[2], aaiTypes[2], &clrOut);
-      pcHelper->AddProperty<aiColor4D>(&clrOut, 1, AI_MATKEY_COLOR_AMBIENT);
+            // build the ambient material color
+            GetMaterialColor((*i).alProperties, aaiPositions[2], aaiTypes[2], &clrOut);
+            pcHelper->AddProperty<aiColor4D>(&clrOut, 1, AI_MATKEY_COLOR_AMBIENT);
 
-      // handle phong power and shading mode
-      int iMode = (int)aiShadingMode_Gouraud;
-      if (0xFFFFFFFF != iPhong)   {
-        ai_real fSpec = PLY::PropertyInstance::ConvertTo<ai_real>(GetProperty((*i).alProperties, iPhong).avList.front(), ePhong);
+            // handle phong power and shading mode
+            int iMode = (int)aiShadingMode_Gouraud;
+            if (0xFFFFFFFF != iPhong) {
+                ai_real fSpec = PLY::PropertyInstance::ConvertTo<ai_real>(GetProperty((*i).alProperties, iPhong).avList.front(), ePhong);
 
-        // if shininess is 0 (and the pow() calculation would therefore always
-        // become 1, not depending on the angle), use gouraud lighting
-        if (fSpec)  {
-          // scale this with 15 ... hopefully this is correct
-          fSpec *= 15;
-          pcHelper->AddProperty<ai_real>(&fSpec, 1, AI_MATKEY_SHININESS);
+                // if shininess is 0 (and the pow() calculation would therefore always
+                // become 1, not depending on the angle), use gouraud lighting
+                if (fSpec) {
+                    // scale this with 15 ... hopefully this is correct
+                    fSpec *= 15;
+                    pcHelper->AddProperty<ai_real>(&fSpec, 1, AI_MATKEY_SHININESS);
 
-          iMode = (int)aiShadingMode_Phong;
+                    iMode = (int)aiShadingMode_Phong;
+                }
+            }
+            pcHelper->AddProperty<int>(&iMode, 1, AI_MATKEY_SHADING_MODEL);
+
+            // handle opacity
+            if (0xFFFFFFFF != iOpacity) {
+                ai_real fOpacity = PLY::PropertyInstance::ConvertTo<ai_real>(GetProperty((*i).alProperties, iPhong).avList.front(), eOpacity);
+                pcHelper->AddProperty<ai_real>(&fOpacity, 1, AI_MATKEY_OPACITY);
+            }
+
+            // The face order is absolutely undefined for PLY, so we have to
+            // use two-sided rendering to be sure it's ok.
+            const int two_sided = 1;
+            pcHelper->AddProperty(&two_sided, 1, AI_MATKEY_TWOSIDED);
+
+            //default texture
+            if (!defaultTexture.empty()) {
+                const aiString name(defaultTexture.c_str());
+                pcHelper->AddProperty(&name, _AI_MATKEY_TEXTURE_BASE, aiTextureType_DIFFUSE, 0);
+            }
+
+            if (!pointsOnly) {
+                pcHelper->AddProperty(&two_sided, 1, AI_MATKEY_TWOSIDED);
+            }
+
+            //set to wireframe, so when using this material info we can switch to points rendering
+            if (pointsOnly) {
+                const int wireframe = 1;
+                pcHelper->AddProperty(&wireframe, 1, AI_MATKEY_ENABLE_WIREFRAME);
+            }
+
+            // add the newly created material instance to the list
+            pvOut->push_back(pcHelper);
         }
-      }
-      pcHelper->AddProperty<int>(&iMode, 1, AI_MATKEY_SHADING_MODEL);
+    } else {
+        // generate a default material
+        aiMaterial *pcHelper = new aiMaterial();
 
-      // handle opacity
-      if (0xFFFFFFFF != iOpacity) {
-        ai_real fOpacity = PLY::PropertyInstance::ConvertTo<ai_real>(GetProperty((*i).alProperties, iPhong).avList.front(), eOpacity);
-        pcHelper->AddProperty<ai_real>(&fOpacity, 1, AI_MATKEY_OPACITY);
-      }
+        // fill in a default material
+        int iMode = (int)aiShadingMode_Gouraud;
+        pcHelper->AddProperty<int>(&iMode, 1, AI_MATKEY_SHADING_MODEL);
 
-      // The face order is absolutely undefined for PLY, so we have to
-      // use two-sided rendering to be sure it's ok.
-      const int two_sided = 1;
-      pcHelper->AddProperty(&two_sided, 1, AI_MATKEY_TWOSIDED);
+        //generate white material most 3D engine just multiply ambient / diffuse color with actual ambient / light color
+        aiColor3D clr;
+        clr.b = clr.g = clr.r = 1.0f;
+        pcHelper->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_DIFFUSE);
+        pcHelper->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_SPECULAR);
 
-      //default texture
-      if (!defaultTexture.empty())
-      {
-        const aiString name(defaultTexture.c_str());
-        pcHelper->AddProperty(&name, _AI_MATKEY_TEXTURE_BASE, aiTextureType_DIFFUSE, 0);
-      }
+        clr.b = clr.g = clr.r = 1.0f;
+        pcHelper->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_AMBIENT);
 
-      if (!pointsOnly)
-      {
-        const int two_sided = 1;
-        pcHelper->AddProperty(&two_sided, 1, AI_MATKEY_TWOSIDED);
-      }
+        // The face order is absolutely undefined for PLY, so we have to
+        // use two-sided rendering to be sure it's ok.
+        if (!pointsOnly) {
+            const int two_sided = 1;
+            pcHelper->AddProperty(&two_sided, 1, AI_MATKEY_TWOSIDED);
+        }
 
-      //set to wireframe, so when using this material info we can switch to points rendering
-      if (pointsOnly)
-      {
-        const int wireframe = 1;
-        pcHelper->AddProperty(&wireframe, 1, AI_MATKEY_ENABLE_WIREFRAME);
-      }
+        //default texture
+        if (!defaultTexture.empty()) {
+            const aiString name(defaultTexture.c_str());
+            pcHelper->AddProperty(&name, _AI_MATKEY_TEXTURE_BASE, aiTextureType_DIFFUSE, 0);
+        }
 
-      // add the newly created material instance to the list
-      pvOut->push_back(pcHelper);
+        //set to wireframe, so when using this material info we can switch to points rendering
+        if (pointsOnly) {
+            const int wireframe = 1;
+            pcHelper->AddProperty(&wireframe, 1, AI_MATKEY_ENABLE_WIREFRAME);
+        }
+
+        pvOut->push_back(pcHelper);
     }
-  }
-  else
-  {
-    // generate a default material
-    aiMaterial* pcHelper = new aiMaterial();
-
-    // fill in a default material
-    int iMode = (int)aiShadingMode_Gouraud;
-    pcHelper->AddProperty<int>(&iMode, 1, AI_MATKEY_SHADING_MODEL);
-
-    //generate white material most 3D engine just multiply ambient / diffuse color with actual ambient / light color
-    aiColor3D clr;
-    clr.b = clr.g = clr.r = 1.0f;
-    pcHelper->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_DIFFUSE);
-    pcHelper->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_SPECULAR);
-
-    clr.b = clr.g = clr.r = 1.0f;
-    pcHelper->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_AMBIENT);
-
-    // The face order is absolutely undefined for PLY, so we have to
-    // use two-sided rendering to be sure it's ok.
-    if (!pointsOnly)
-    {
-      const int two_sided = 1;
-      pcHelper->AddProperty(&two_sided, 1, AI_MATKEY_TWOSIDED);
-    }
-
-    //default texture
-    if (!defaultTexture.empty())
-    {
-      const aiString name(defaultTexture.c_str());
-      pcHelper->AddProperty(&name, _AI_MATKEY_TEXTURE_BASE, aiTextureType_DIFFUSE, 0);
-    }
-
-    //set to wireframe, so when using this material info we can switch to points rendering
-    if (pointsOnly)
-    {
-      const int wireframe = 1;
-      pcHelper->AddProperty(&wireframe, 1, AI_MATKEY_ENABLE_WIREFRAME);
-    }
-
-    pvOut->push_back(pcHelper);
-  }
 }
 
 #endif // !! ASSIMP_BUILD_NO_PLY_IMPORTER
diff --git a/Engine/lib/assimp/code/Ply/PlyLoader.h b/Engine/lib/assimp/code/AssetLib/Ply/PlyLoader.h
similarity index 77%
rename from Engine/lib/assimp/code/Ply/PlyLoader.h
rename to Engine/lib/assimp/code/AssetLib/Ply/PlyLoader.h
index 201c463b2..e29da1db6 100644
--- a/Engine/lib/assimp/code/Ply/PlyLoader.h
+++ b/Engine/lib/assimp/code/AssetLib/Ply/PlyLoader.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,12 +42,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file  PLYLoader.h
  *  @brief Declaration of the .ply importer class.
  */
+#pragma once
 #ifndef AI_PLYLOADER_H_INCLUDED
 #define AI_PLYLOADER_H_INCLUDED
 
+#include "PlyParser.h"
 #include <assimp/BaseImporter.h>
 #include <assimp/types.h>
-#include "PlyParser.h"
 #include <vector>
 
 struct aiNode;
@@ -62,77 +62,72 @@ using namespace PLY;
 // ---------------------------------------------------------------------------
 /** Importer class to load the stanford PLY file format
 */
-class PLYImporter : public BaseImporter
-{
+class PLYImporter : public BaseImporter {
 public:
     PLYImporter();
-    ~PLYImporter();
-
-public:
+    ~PLYImporter() override;
 
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
      * See BaseImporter::CanRead() for details.
      */
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
+            bool checkSig) const override;
 
     // -------------------------------------------------------------------
     /** Extract a vertex from the DOM
     */
-    void LoadVertex(const PLY::Element* pcElement, const PLY::ElementInstance* instElement, unsigned int pos);
+    void LoadVertex(const PLY::Element *pcElement, const PLY::ElementInstance *instElement, unsigned int pos);
 
     // -------------------------------------------------------------------
     /** Extract a face from the DOM
     */
-    void LoadFace(const PLY::Element* pcElement, const PLY::ElementInstance* instElement, unsigned int pos);
+    void LoadFace(const PLY::Element *pcElement, const PLY::ElementInstance *instElement, unsigned int pos);
 
 protected:
-
     // -------------------------------------------------------------------
     /** Return importer meta information.
      * See #BaseImporter::GetInfo for the details
      */
-    const aiImporterDesc* GetInfo () const;
+    const aiImporterDesc *GetInfo() const override;
 
     // -------------------------------------------------------------------
     /** Imports the given file into the given scene structure.
     * See BaseImporter::InternReadFile() for details
     */
-    void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
+    void InternReadFile(const std::string &pFile, aiScene *pScene,
+            IOSystem *pIOHandler) override;
 
-protected:
     // -------------------------------------------------------------------
     /** Extract a material list from the DOM
     */
-    void LoadMaterial(std::vector<aiMaterial*>* pvOut, std::string &defaultTexture, const bool pointsOnly);
+    void LoadMaterial(std::vector<aiMaterial *> *pvOut, std::string &defaultTexture, const bool pointsOnly);
 
     // -------------------------------------------------------------------
     /** Static helper to parse a color from four single channels in
     */
     static void GetMaterialColor(
-        const std::vector<PLY::PropertyInstance>& avList,
-        unsigned int aiPositions[4],
-        PLY::EDataType aiTypes[4],
-        aiColor4D* clrOut);
+            const std::vector<PLY::PropertyInstance> &avList,
+            unsigned int aiPositions[4],
+            PLY::EDataType aiTypes[4],
+            aiColor4D *clrOut);
 
     // -------------------------------------------------------------------
     /** Static helper to parse a color channel value. The input value
     *  is normalized to 0-1.
     */
-    static ai_real NormalizeColorValue (
-        PLY::PropertyInstance::ValueUnion val,
-        PLY::EDataType eType);
+    static ai_real NormalizeColorValue(
+            PLY::PropertyInstance::ValueUnion val,
+            PLY::EDataType eType);
 
     /** Buffer to hold the loaded file */
-    unsigned char* mBuffer;
+    unsigned char *mBuffer;
 
     /** Document object model representation extracted from the file */
-    PLY::DOM* pcDOM;
+    PLY::DOM *pcDOM;
 
     /** Mesh generated by loader */
-    aiMesh* mGeneratedMesh;
+    aiMesh *mGeneratedMesh;
 };
 
 } // end of namespace Assimp
diff --git a/Engine/lib/assimp/code/AssetLib/Ply/PlyParser.cpp b/Engine/lib/assimp/code/AssetLib/Ply/PlyParser.cpp
new file mode 100644
index 000000000..df93d5a57
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Ply/PlyParser.cpp
@@ -0,0 +1,963 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file Implementation of the PLY parser class */
+
+#ifndef ASSIMP_BUILD_NO_PLY_IMPORTER
+
+#include "PlyLoader.h"
+#include <assimp/ByteSwapper.h>
+#include <assimp/fast_atof.h>
+#include <assimp/DefaultLogger.hpp>
+
+using namespace Assimp;
+
+// ------------------------------------------------------------------------------------------------
+PLY::EDataType PLY::Property::ParseDataType(std::vector<char> &buffer) {
+    ai_assert(!buffer.empty());
+
+    PLY::EDataType eOut = PLY::EDT_INVALID;
+
+    if (PLY::DOM::TokenMatch(buffer, "char", 4) ||
+            PLY::DOM::TokenMatch(buffer, "int8", 4)) {
+        eOut = PLY::EDT_Char;
+    } else if (PLY::DOM::TokenMatch(buffer, "uchar", 5) ||
+               PLY::DOM::TokenMatch(buffer, "uint8", 5)) {
+        eOut = PLY::EDT_UChar;
+    } else if (PLY::DOM::TokenMatch(buffer, "short", 5) ||
+               PLY::DOM::TokenMatch(buffer, "int16", 5)) {
+        eOut = PLY::EDT_Short;
+    } else if (PLY::DOM::TokenMatch(buffer, "ushort", 6) ||
+               PLY::DOM::TokenMatch(buffer, "uint16", 6)) {
+        eOut = PLY::EDT_UShort;
+    } else if (PLY::DOM::TokenMatch(buffer, "int32", 5) || PLY::DOM::TokenMatch(buffer, "int", 3)) {
+        eOut = PLY::EDT_Int;
+    } else if (PLY::DOM::TokenMatch(buffer, "uint32", 6) || PLY::DOM::TokenMatch(buffer, "uint", 4)) {
+        eOut = PLY::EDT_UInt;
+    } else if (PLY::DOM::TokenMatch(buffer, "float", 5) || PLY::DOM::TokenMatch(buffer, "float32", 7)) {
+        eOut = PLY::EDT_Float;
+    } else if (PLY::DOM::TokenMatch(buffer, "double64", 8) || PLY::DOM::TokenMatch(buffer, "double", 6) ||
+               PLY::DOM::TokenMatch(buffer, "float64", 7)) {
+        eOut = PLY::EDT_Double;
+    }
+    if (PLY::EDT_INVALID == eOut) {
+        ASSIMP_LOG_INFO("Found unknown data type in PLY file. This is OK");
+    }
+
+    return eOut;
+}
+
+// ------------------------------------------------------------------------------------------------
+PLY::ESemantic PLY::Property::ParseSemantic(std::vector<char> &buffer) {
+    ai_assert(!buffer.empty());
+
+    PLY::ESemantic eOut = PLY::EST_INVALID;
+    if (PLY::DOM::TokenMatch(buffer, "red", 3)) {
+        eOut = PLY::EST_Red;
+    } else if (PLY::DOM::TokenMatch(buffer, "green", 5)) {
+        eOut = PLY::EST_Green;
+    } else if (PLY::DOM::TokenMatch(buffer, "blue", 4)) {
+        eOut = PLY::EST_Blue;
+    } else if (PLY::DOM::TokenMatch(buffer, "alpha", 5)) {
+        eOut = PLY::EST_Alpha;
+    } else if (PLY::DOM::TokenMatch(buffer, "vertex_index", 12) || PLY::DOM::TokenMatch(buffer, "vertex_indices", 14)) {
+        eOut = PLY::EST_VertexIndex;
+    } else if (PLY::DOM::TokenMatch(buffer, "texcoord", 8)) // Manage uv coords on faces
+    {
+        eOut = PLY::EST_TextureCoordinates;
+    } else if (PLY::DOM::TokenMatch(buffer, "material_index", 14)) {
+        eOut = PLY::EST_MaterialIndex;
+    } else if (PLY::DOM::TokenMatch(buffer, "ambient_red", 11)) {
+        eOut = PLY::EST_AmbientRed;
+    } else if (PLY::DOM::TokenMatch(buffer, "ambient_green", 13)) {
+        eOut = PLY::EST_AmbientGreen;
+    } else if (PLY::DOM::TokenMatch(buffer, "ambient_blue", 12)) {
+        eOut = PLY::EST_AmbientBlue;
+    } else if (PLY::DOM::TokenMatch(buffer, "ambient_alpha", 13)) {
+        eOut = PLY::EST_AmbientAlpha;
+    } else if (PLY::DOM::TokenMatch(buffer, "diffuse_red", 11)) {
+        eOut = PLY::EST_DiffuseRed;
+    } else if (PLY::DOM::TokenMatch(buffer, "diffuse_green", 13)) {
+        eOut = PLY::EST_DiffuseGreen;
+    } else if (PLY::DOM::TokenMatch(buffer, "diffuse_blue", 12)) {
+        eOut = PLY::EST_DiffuseBlue;
+    } else if (PLY::DOM::TokenMatch(buffer, "diffuse_alpha", 13)) {
+        eOut = PLY::EST_DiffuseAlpha;
+    } else if (PLY::DOM::TokenMatch(buffer, "specular_red", 12)) {
+        eOut = PLY::EST_SpecularRed;
+    } else if (PLY::DOM::TokenMatch(buffer, "specular_green", 14)) {
+        eOut = PLY::EST_SpecularGreen;
+    } else if (PLY::DOM::TokenMatch(buffer, "specular_blue", 13)) {
+        eOut = PLY::EST_SpecularBlue;
+    } else if (PLY::DOM::TokenMatch(buffer, "specular_alpha", 14)) {
+        eOut = PLY::EST_SpecularAlpha;
+    } else if (PLY::DOM::TokenMatch(buffer, "opacity", 7)) {
+        eOut = PLY::EST_Opacity;
+    } else if (PLY::DOM::TokenMatch(buffer, "specular_power", 14)) {
+        eOut = PLY::EST_PhongPower;
+    } else if (PLY::DOM::TokenMatch(buffer, "r", 1)) {
+        eOut = PLY::EST_Red;
+    } else if (PLY::DOM::TokenMatch(buffer, "g", 1)) {
+        eOut = PLY::EST_Green;
+    } else if (PLY::DOM::TokenMatch(buffer, "b", 1)) {
+        eOut = PLY::EST_Blue;
+    }
+
+    // NOTE: Blender3D exports texture coordinates as s,t tuples
+    else if (PLY::DOM::TokenMatch(buffer, "u", 1) || PLY::DOM::TokenMatch(buffer, "s", 1) || PLY::DOM::TokenMatch(buffer, "tx", 2) || PLY::DOM::TokenMatch(buffer, "texture_u", 9)) {
+        eOut = PLY::EST_UTextureCoord;
+    } else if (PLY::DOM::TokenMatch(buffer, "v", 1) || PLY::DOM::TokenMatch(buffer, "t", 1) || PLY::DOM::TokenMatch(buffer, "ty", 2) || PLY::DOM::TokenMatch(buffer, "texture_v", 9)) {
+        eOut = PLY::EST_VTextureCoord;
+    } else if (PLY::DOM::TokenMatch(buffer, "x", 1)) {
+        eOut = PLY::EST_XCoord;
+    } else if (PLY::DOM::TokenMatch(buffer, "y", 1)) {
+        eOut = PLY::EST_YCoord;
+    } else if (PLY::DOM::TokenMatch(buffer, "z", 1)) {
+        eOut = PLY::EST_ZCoord;
+    } else if (PLY::DOM::TokenMatch(buffer, "nx", 2)) {
+        eOut = PLY::EST_XNormal;
+    } else if (PLY::DOM::TokenMatch(buffer, "ny", 2)) {
+        eOut = PLY::EST_YNormal;
+    } else if (PLY::DOM::TokenMatch(buffer, "nz", 2)) {
+        eOut = PLY::EST_ZNormal;
+    } else {
+        ASSIMP_LOG_INFO("Found unknown property semantic in file. This is ok");
+        PLY::DOM::SkipLine(buffer);
+    }
+    return eOut;
+}
+
+// ------------------------------------------------------------------------------------------------
+bool PLY::Property::ParseProperty(std::vector<char> &buffer, PLY::Property *pOut) {
+    ai_assert(!buffer.empty());
+
+    // Forms supported:
+    // "property float x"
+    // "property list uchar int vertex_index"
+
+    // skip leading spaces
+    if (!PLY::DOM::SkipSpaces(buffer)) {
+        return false;
+    }
+
+    // skip the "property" string at the beginning
+    if (!PLY::DOM::TokenMatch(buffer, "property", 8)) {
+        // seems not to be a valid property entry
+        return false;
+    }
+    // get next word
+    if (!PLY::DOM::SkipSpaces(buffer)) {
+        return false;
+    }
+    if (PLY::DOM::TokenMatch(buffer, "list", 4)) {
+        pOut->bIsList = true;
+
+        // seems to be a list.
+        if (EDT_INVALID == (pOut->eFirstType = PLY::Property::ParseDataType(buffer))) {
+            // unable to parse list size data type
+            PLY::DOM::SkipLine(buffer);
+            return false;
+        }
+        if (!PLY::DOM::SkipSpaces(buffer)) return false;
+        if (EDT_INVALID == (pOut->eType = PLY::Property::ParseDataType(buffer))) {
+            // unable to parse list data type
+            PLY::DOM::SkipLine(buffer);
+            return false;
+        }
+    } else {
+        if (EDT_INVALID == (pOut->eType = PLY::Property::ParseDataType(buffer))) {
+            // unable to parse data type. Skip the property
+            PLY::DOM::SkipLine(buffer);
+            return false;
+        }
+    }
+
+    if (!PLY::DOM::SkipSpaces(buffer))
+        return false;
+
+    pOut->Semantic = PLY::Property::ParseSemantic(buffer);
+
+    if (PLY::EST_INVALID == pOut->Semantic) {
+        ASSIMP_LOG_INFO("Found unknown semantic in PLY file. This is OK");
+        std::string(&buffer[0], &buffer[0] + strlen(&buffer[0]));
+    }
+
+    PLY::DOM::SkipSpacesAndLineEnd(buffer);
+    return true;
+}
+
+// ------------------------------------------------------------------------------------------------
+PLY::EElementSemantic PLY::Element::ParseSemantic(std::vector<char> &buffer) {
+    ai_assert(!buffer.empty());
+
+    PLY::EElementSemantic eOut = PLY::EEST_INVALID;
+    if (PLY::DOM::TokenMatch(buffer, "vertex", 6)) {
+        eOut = PLY::EEST_Vertex;
+    } else if (PLY::DOM::TokenMatch(buffer, "face", 4)) {
+        eOut = PLY::EEST_Face;
+    } else if (PLY::DOM::TokenMatch(buffer, "tristrips", 9)) {
+        eOut = PLY::EEST_TriStrip;
+    }
+#if 0
+  // TODO: maybe implement this?
+  else if (PLY::DOM::TokenMatch(buffer,"range_grid",10))
+  {
+    eOut = PLY::EEST_Face;
+  }
+#endif
+    else if (PLY::DOM::TokenMatch(buffer, "edge", 4)) {
+        eOut = PLY::EEST_Edge;
+    } else if (PLY::DOM::TokenMatch(buffer, "material", 8)) {
+        eOut = PLY::EEST_Material;
+    } else if (PLY::DOM::TokenMatch(buffer, "TextureFile", 11)) {
+        eOut = PLY::EEST_TextureFile;
+    }
+
+    return eOut;
+}
+
+// ------------------------------------------------------------------------------------------------
+bool PLY::Element::ParseElement(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer, PLY::Element *pOut) {
+    ai_assert(nullptr != pOut);
+    // Example format: "element vertex 8"
+
+    // skip leading spaces
+    if (!PLY::DOM::SkipSpaces(buffer)) {
+        return false;
+    }
+
+    // skip the "element" string at the beginning
+    if (!PLY::DOM::TokenMatch(buffer, "element", 7) && !PLY::DOM::TokenMatch(buffer, "comment", 7)) {
+        // seems not to be a valid property entry
+        return false;
+    }
+    // get next word
+    if (!PLY::DOM::SkipSpaces(buffer))
+        return false;
+
+    // parse the semantic of the element
+    pOut->eSemantic = PLY::Element::ParseSemantic(buffer);
+    if (PLY::EEST_INVALID == pOut->eSemantic) {
+        // if the exact semantic can't be determined, just store
+        // the original string identifier
+        pOut->szName = std::string(&buffer[0], &buffer[0] + strlen(&buffer[0]));
+    }
+
+    if (!PLY::DOM::SkipSpaces(buffer))
+        return false;
+
+    if (PLY::EEST_TextureFile == pOut->eSemantic) {
+        char *endPos = &buffer[0] + (strlen(&buffer[0]) - 1);
+        pOut->szName = std::string(&buffer[0], endPos);
+
+        // go to the next line
+        PLY::DOM::SkipSpacesAndLineEnd(buffer);
+
+        return true;
+    }
+
+    //parse the number of occurrences of this element
+    const char *pCur = (char *)&buffer[0];
+    pOut->NumOccur = strtoul10(pCur, &pCur);
+
+    // go to the next line
+    PLY::DOM::SkipSpacesAndLineEnd(buffer);
+
+    // now parse all properties of the element
+    while (true) {
+        streamBuffer.getNextLine(buffer);
+        pCur = (char *)&buffer[0];
+
+        // skip all comments
+        PLY::DOM::SkipComments(buffer);
+
+        PLY::Property prop;
+        if (!PLY::Property::ParseProperty(buffer, &prop))
+            break;
+
+        pOut->alProperties.push_back(prop);
+    }
+
+    return true;
+}
+
+// ------------------------------------------------------------------------------------------------
+bool PLY::DOM::SkipSpaces(std::vector<char> &buffer) {
+    const char *pCur = buffer.empty() ? nullptr : (char *)&buffer[0];
+    bool ret = false;
+    if (pCur) {
+        const char *szCur = pCur;
+        ret = Assimp::SkipSpaces(pCur, &pCur);
+
+        uintptr_t iDiff = (uintptr_t)pCur - (uintptr_t)szCur;
+        buffer.erase(buffer.begin(), buffer.begin() + iDiff);
+        return ret;
+    }
+
+    return ret;
+}
+
+bool PLY::DOM::SkipLine(std::vector<char> &buffer) {
+    const char *pCur = buffer.empty() ? nullptr : (char *)&buffer[0];
+    bool ret = false;
+    if (pCur) {
+        const char *szCur = pCur;
+        ret = Assimp::SkipLine(pCur, &pCur);
+
+        uintptr_t iDiff = (uintptr_t)pCur - (uintptr_t)szCur;
+        buffer.erase(buffer.begin(), buffer.begin() + iDiff);
+        return ret;
+    }
+
+    return ret;
+}
+
+bool PLY::DOM::TokenMatch(std::vector<char> &buffer, const char *token, unsigned int len) {
+    const char *pCur = buffer.empty() ? nullptr : (char *)&buffer[0];
+    bool ret = false;
+    if (pCur) {
+        const char *szCur = pCur;
+        ret = Assimp::TokenMatch(pCur, token, len);
+
+        uintptr_t iDiff = (uintptr_t)pCur - (uintptr_t)szCur;
+        buffer.erase(buffer.begin(), buffer.begin() + iDiff);
+        return ret;
+    }
+
+    return ret;
+}
+
+bool PLY::DOM::SkipSpacesAndLineEnd(std::vector<char> &buffer) {
+    const char *pCur = buffer.empty() ? nullptr : (char *)&buffer[0];
+    bool ret = false;
+    if (pCur) {
+        const char *szCur = pCur;
+        ret = Assimp::SkipSpacesAndLineEnd(pCur, &pCur);
+
+        uintptr_t iDiff = (uintptr_t)pCur - (uintptr_t)szCur;
+        buffer.erase(buffer.begin(), buffer.begin() + iDiff);
+        return ret;
+    }
+
+    return ret;
+}
+
+bool PLY::DOM::SkipComments(std::vector<char> &buffer) {
+    ai_assert(!buffer.empty());
+
+    std::vector<char> nbuffer = buffer;
+    // skip spaces
+    if (!SkipSpaces(nbuffer)) {
+        return false;
+    }
+
+    if (TokenMatch(nbuffer, "comment", 7)) {
+        if (!SkipSpaces(nbuffer))
+            SkipLine(nbuffer);
+
+        if (!TokenMatch(nbuffer, "TextureFile", 11)) {
+            SkipLine(nbuffer);
+            buffer = nbuffer;
+            return true;
+        }
+
+        return true;
+    }
+
+    return false;
+}
+
+// ------------------------------------------------------------------------------------------------
+bool PLY::DOM::ParseHeader(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer, bool isBinary) {
+    ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseHeader() begin");
+
+    // parse all elements
+    while (!buffer.empty()) {
+        // skip all comments
+        PLY::DOM::SkipComments(buffer);
+
+        PLY::Element out;
+        if (PLY::Element::ParseElement(streamBuffer, buffer, &out)) {
+            // add the element to the list of elements
+            alElements.push_back(out);
+        } else if (TokenMatch(buffer, "end_header", 10)) { //checks for /n ending, if it doesn't end with /r/n
+            // we have reached the end of the header
+            break;
+        } else {
+            // ignore unknown header elements
+            streamBuffer.getNextLine(buffer);
+        }
+    }
+
+    if (!isBinary) // it would occur an error, if binary data start with values as space or line end.
+        SkipSpacesAndLineEnd(buffer);
+
+    ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseHeader() succeeded");
+    return true;
+}
+
+// ------------------------------------------------------------------------------------------------
+bool PLY::DOM::ParseElementInstanceLists(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer, PLYImporter *loader) {
+    ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseElementInstanceLists() begin");
+    alElementData.resize(alElements.size());
+
+    std::vector<PLY::Element>::const_iterator i = alElements.begin();
+    std::vector<PLY::ElementInstanceList>::iterator a = alElementData.begin();
+
+    // parse all element instances
+    //construct vertices and faces
+    for (; i != alElements.end(); ++i, ++a) {
+        if ((*i).eSemantic == EEST_Vertex || (*i).eSemantic == EEST_Face || (*i).eSemantic == EEST_TriStrip) {
+            PLY::ElementInstanceList::ParseInstanceList(streamBuffer, buffer, &(*i), nullptr, loader);
+        } else {
+            (*a).alInstances.resize((*i).NumOccur);
+            PLY::ElementInstanceList::ParseInstanceList(streamBuffer, buffer, &(*i), &(*a), nullptr);
+        }
+    }
+
+    ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseElementInstanceLists() succeeded");
+    return true;
+}
+
+// ------------------------------------------------------------------------------------------------
+bool PLY::DOM::ParseElementInstanceListsBinary(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer,
+        const char *&pCur,
+        unsigned int &bufferSize,
+        PLYImporter *loader,
+        bool p_bBE) {
+    ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseElementInstanceListsBinary() begin");
+    alElementData.resize(alElements.size());
+
+    std::vector<PLY::Element>::const_iterator i = alElements.begin();
+    std::vector<PLY::ElementInstanceList>::iterator a = alElementData.begin();
+
+    // parse all element instances
+    for (; i != alElements.end(); ++i, ++a) {
+        if ((*i).eSemantic == EEST_Vertex || (*i).eSemantic == EEST_Face || (*i).eSemantic == EEST_TriStrip) {
+            PLY::ElementInstanceList::ParseInstanceListBinary(streamBuffer, buffer, pCur, bufferSize, &(*i), nullptr, loader, p_bBE);
+        } else {
+            (*a).alInstances.resize((*i).NumOccur);
+            PLY::ElementInstanceList::ParseInstanceListBinary(streamBuffer, buffer, pCur, bufferSize, &(*i), &(*a), nullptr, p_bBE);
+        }
+    }
+
+    ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseElementInstanceListsBinary() succeeded");
+    return true;
+}
+
+// ------------------------------------------------------------------------------------------------
+bool PLY::DOM::ParseInstanceBinary(IOStreamBuffer<char> &streamBuffer, DOM *p_pcOut, PLYImporter *loader, bool p_bBE) {
+    ai_assert(nullptr != p_pcOut);
+    ai_assert(nullptr != loader);
+
+    std::vector<char> buffer;
+    streamBuffer.getNextLine(buffer);
+
+    ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseInstanceBinary() begin");
+
+    if (!p_pcOut->ParseHeader(streamBuffer, buffer, true)) {
+        ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseInstanceBinary() failure");
+        return false;
+    }
+
+    streamBuffer.getNextBlock(buffer);
+
+    // remove first char if it's /n in case of file with /r/n
+    if (((char *)&buffer[0])[0] == '\n')
+        buffer.erase(buffer.begin(), buffer.begin() + 1);
+
+    unsigned int bufferSize = static_cast<unsigned int>(buffer.size());
+    const char *pCur = (char *)&buffer[0];
+    if (!p_pcOut->ParseElementInstanceListsBinary(streamBuffer, buffer, pCur, bufferSize, loader, p_bBE)) {
+        ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseInstanceBinary() failure");
+        return false;
+    }
+    ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseInstanceBinary() succeeded");
+    return true;
+}
+
+// ------------------------------------------------------------------------------------------------
+bool PLY::DOM::ParseInstance(IOStreamBuffer<char> &streamBuffer, DOM *p_pcOut, PLYImporter *loader) {
+    ai_assert(nullptr != p_pcOut);
+    ai_assert(nullptr != loader);
+
+    std::vector<char> buffer;
+    streamBuffer.getNextLine(buffer);
+
+    ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseInstance() begin");
+
+    if (!p_pcOut->ParseHeader(streamBuffer, buffer, false)) {
+        ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseInstance() failure");
+        return false;
+    }
+
+    //get next line after header
+    streamBuffer.getNextLine(buffer);
+    if (!p_pcOut->ParseElementInstanceLists(streamBuffer, buffer, loader)) {
+        ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseInstance() failure");
+        return false;
+    }
+    ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseInstance() succeeded");
+    return true;
+}
+
+// ------------------------------------------------------------------------------------------------
+bool PLY::ElementInstanceList::ParseInstanceList(
+        IOStreamBuffer<char> &streamBuffer,
+        std::vector<char> &buffer,
+        const PLY::Element *pcElement,
+        PLY::ElementInstanceList *p_pcOut,
+        PLYImporter *loader) {
+    ai_assert(nullptr != pcElement);
+
+    // parse all elements
+    if (EEST_INVALID == pcElement->eSemantic || pcElement->alProperties.empty()) {
+        // if the element has an unknown semantic we can skip all lines
+        // However, there could be comments
+        for (unsigned int i = 0; i < pcElement->NumOccur; ++i) {
+            PLY::DOM::SkipComments(buffer);
+            PLY::DOM::SkipLine(buffer);
+            streamBuffer.getNextLine(buffer);
+        }
+    } else {
+        const char *pCur = (const char *)&buffer[0];
+        // be sure to have enough storage
+        for (unsigned int i = 0; i < pcElement->NumOccur; ++i) {
+            if (p_pcOut)
+                PLY::ElementInstance::ParseInstance(pCur, pcElement, &p_pcOut->alInstances[i]);
+            else {
+                ElementInstance elt;
+                PLY::ElementInstance::ParseInstance(pCur, pcElement, &elt);
+
+                // Create vertex or face
+                if (pcElement->eSemantic == EEST_Vertex) {
+                    //call loader instance from here
+                    loader->LoadVertex(pcElement, &elt, i);
+                } else if (pcElement->eSemantic == EEST_Face) {
+                    //call loader instance from here
+                    loader->LoadFace(pcElement, &elt, i);
+                } else if (pcElement->eSemantic == EEST_TriStrip) {
+                    //call loader instance from here
+                    loader->LoadFace(pcElement, &elt, i);
+                }
+            }
+
+            streamBuffer.getNextLine(buffer);
+            pCur = (buffer.empty()) ? nullptr : (const char *)&buffer[0];
+        }
+    }
+    return true;
+}
+
+// ------------------------------------------------------------------------------------------------
+bool PLY::ElementInstanceList::ParseInstanceListBinary(
+        IOStreamBuffer<char> &streamBuffer,
+        std::vector<char> &buffer,
+        const char *&pCur,
+        unsigned int &bufferSize,
+        const PLY::Element *pcElement,
+        PLY::ElementInstanceList *p_pcOut,
+        PLYImporter *loader,
+        bool p_bBE /* = false */) {
+    ai_assert(nullptr != pcElement);
+
+    // we can add special handling code for unknown element semantics since
+    // we can't skip it as a whole block (we don't know its exact size
+    // due to the fact that lists could be contained in the property list
+    // of the unknown element)
+    for (unsigned int i = 0; i < pcElement->NumOccur; ++i) {
+        if (p_pcOut)
+            PLY::ElementInstance::ParseInstanceBinary(streamBuffer, buffer, pCur, bufferSize, pcElement, &p_pcOut->alInstances[i], p_bBE);
+        else {
+            ElementInstance elt;
+            PLY::ElementInstance::ParseInstanceBinary(streamBuffer, buffer, pCur, bufferSize, pcElement, &elt, p_bBE);
+
+            // Create vertex or face
+            if (pcElement->eSemantic == EEST_Vertex) {
+                //call loader instance from here
+                loader->LoadVertex(pcElement, &elt, i);
+            } else if (pcElement->eSemantic == EEST_Face) {
+                //call loader instance from here
+                loader->LoadFace(pcElement, &elt, i);
+            } else if (pcElement->eSemantic == EEST_TriStrip) {
+                //call loader instance from here
+                loader->LoadFace(pcElement, &elt, i);
+            }
+        }
+    }
+    return true;
+}
+
+// ------------------------------------------------------------------------------------------------
+bool PLY::ElementInstance::ParseInstance(const char *&pCur,
+        const PLY::Element *pcElement,
+        PLY::ElementInstance *p_pcOut) {
+    ai_assert(nullptr != pcElement);
+    ai_assert(nullptr != p_pcOut);
+
+    // allocate enough storage
+    p_pcOut->alProperties.resize(pcElement->alProperties.size());
+
+    std::vector<PLY::PropertyInstance>::iterator i = p_pcOut->alProperties.begin();
+    std::vector<PLY::Property>::const_iterator a = pcElement->alProperties.begin();
+    for (; i != p_pcOut->alProperties.end(); ++i, ++a) {
+        if (!(PLY::PropertyInstance::ParseInstance(pCur, &(*a), &(*i)))) {
+            ASSIMP_LOG_WARN("Unable to parse property instance. "
+                            "Skipping this element instance");
+
+            PLY::PropertyInstance::ValueUnion v = PLY::PropertyInstance::DefaultValue((*a).eType);
+            (*i).avList.push_back(v);
+        }
+    }
+    return true;
+}
+
+// ------------------------------------------------------------------------------------------------
+bool PLY::ElementInstance::ParseInstanceBinary(
+        IOStreamBuffer<char> &streamBuffer,
+        std::vector<char> &buffer,
+        const char *&pCur,
+        unsigned int &bufferSize,
+        const PLY::Element *pcElement,
+        PLY::ElementInstance *p_pcOut,
+        bool p_bBE /* = false */) {
+    ai_assert(nullptr != pcElement);
+    ai_assert(nullptr != p_pcOut);
+
+    // allocate enough storage
+    p_pcOut->alProperties.resize(pcElement->alProperties.size());
+
+    std::vector<PLY::PropertyInstance>::iterator i = p_pcOut->alProperties.begin();
+    std::vector<PLY::Property>::const_iterator a = pcElement->alProperties.begin();
+    for (; i != p_pcOut->alProperties.end(); ++i, ++a) {
+        if (!(PLY::PropertyInstance::ParseInstanceBinary(streamBuffer, buffer, pCur, bufferSize, &(*a), &(*i), p_bBE))) {
+            ASSIMP_LOG_WARN("Unable to parse binary property instance. "
+                            "Skipping this element instance");
+
+            (*i).avList.push_back(PLY::PropertyInstance::DefaultValue((*a).eType));
+        }
+    }
+    return true;
+}
+
+// ------------------------------------------------------------------------------------------------
+bool PLY::PropertyInstance::ParseInstance(const char *&pCur,
+        const PLY::Property *prop, PLY::PropertyInstance *p_pcOut) {
+    ai_assert(nullptr != prop);
+    ai_assert(nullptr != p_pcOut);
+
+    // skip spaces at the beginning
+    if (!SkipSpaces(&pCur)) {
+        return false;
+    }
+
+    if (prop->bIsList) {
+        // parse the number of elements in the list
+        PLY::PropertyInstance::ValueUnion v;
+        PLY::PropertyInstance::ParseValue(pCur, prop->eFirstType, &v);
+
+        // convert to unsigned int
+        unsigned int iNum = PLY::PropertyInstance::ConvertTo<unsigned int>(v, prop->eFirstType);
+
+        // parse all list elements
+        p_pcOut->avList.resize(iNum);
+        for (unsigned int i = 0; i < iNum; ++i) {
+            if (!SkipSpaces(&pCur))
+                return false;
+
+            PLY::PropertyInstance::ParseValue(pCur, prop->eType, &p_pcOut->avList[i]);
+        }
+    } else {
+        // parse the property
+        PLY::PropertyInstance::ValueUnion v;
+
+        PLY::PropertyInstance::ParseValue(pCur, prop->eType, &v);
+        p_pcOut->avList.push_back(v);
+    }
+    SkipSpacesAndLineEnd(&pCur);
+    return true;
+}
+
+// ------------------------------------------------------------------------------------------------
+bool PLY::PropertyInstance::ParseInstanceBinary(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer,
+        const char *&pCur,
+        unsigned int &bufferSize,
+        const PLY::Property *prop,
+        PLY::PropertyInstance *p_pcOut,
+        bool p_bBE) {
+    ai_assert(nullptr != prop);
+    ai_assert(nullptr != p_pcOut);
+
+    // parse all elements
+    if (prop->bIsList) {
+        // parse the number of elements in the list
+        PLY::PropertyInstance::ValueUnion v;
+        PLY::PropertyInstance::ParseValueBinary(streamBuffer, buffer, pCur, bufferSize, prop->eFirstType, &v, p_bBE);
+
+        // convert to unsigned int
+        unsigned int iNum = PLY::PropertyInstance::ConvertTo<unsigned int>(v, prop->eFirstType);
+
+        // parse all list elements
+        p_pcOut->avList.resize(iNum);
+        for (unsigned int i = 0; i < iNum; ++i) {
+            PLY::PropertyInstance::ParseValueBinary(streamBuffer, buffer, pCur, bufferSize, prop->eType, &p_pcOut->avList[i], p_bBE);
+        }
+    } else {
+        // parse the property
+        PLY::PropertyInstance::ValueUnion v;
+        PLY::PropertyInstance::ParseValueBinary(streamBuffer, buffer, pCur, bufferSize, prop->eType, &v, p_bBE);
+        p_pcOut->avList.push_back(v);
+    }
+    return true;
+}
+
+// ------------------------------------------------------------------------------------------------
+PLY::PropertyInstance::ValueUnion PLY::PropertyInstance::DefaultValue(PLY::EDataType eType) {
+    PLY::PropertyInstance::ValueUnion out;
+
+    switch (eType) {
+    case EDT_Float:
+        out.fFloat = 0.f;
+        return out;
+
+    case EDT_Double:
+        out.fDouble = 0.;
+        return out;
+
+    default:;
+    };
+    out.iUInt = 0;
+    return out;
+}
+
+// ------------------------------------------------------------------------------------------------
+bool PLY::PropertyInstance::ParseValue(const char *&pCur,
+        PLY::EDataType eType,
+        PLY::PropertyInstance::ValueUnion *out) {
+    ai_assert(nullptr != pCur);
+    ai_assert(nullptr != out);
+
+    //calc element size
+    bool ret = true;
+    switch (eType) {
+    case EDT_UInt:
+    case EDT_UShort:
+    case EDT_UChar:
+
+        out->iUInt = (uint32_t)strtoul10(pCur, &pCur);
+        break;
+
+    case EDT_Int:
+    case EDT_Short:
+    case EDT_Char:
+
+        out->iInt = (int32_t)strtol10(pCur, &pCur);
+        break;
+
+    case EDT_Float:
+        // technically this should cast to float, but people tend to use float descriptors for double data
+        // this is the best way to not risk losing precision on import and it doesn't hurt to do this
+        ai_real f;
+        pCur = fast_atoreal_move<ai_real>(pCur, f);
+        out->fFloat = (ai_real)f;
+        break;
+
+    case EDT_Double:
+        double d;
+        pCur = fast_atoreal_move<double>(pCur, d);
+        out->fDouble = (double)d;
+        break;
+
+    case EDT_INVALID:
+    default:
+        ret = false;
+        break;
+    }
+
+    return ret;
+}
+
+// ------------------------------------------------------------------------------------------------
+bool PLY::PropertyInstance::ParseValueBinary(IOStreamBuffer<char> &streamBuffer,
+        std::vector<char> &buffer,
+        const char *&pCur,
+        unsigned int &bufferSize,
+        PLY::EDataType eType,
+        PLY::PropertyInstance::ValueUnion *out,
+        bool p_bBE) {
+    ai_assert(nullptr != out);
+
+    //calc element size
+    unsigned int lsize = 0;
+    switch (eType) {
+    case EDT_Char:
+    case EDT_UChar:
+        lsize = 1;
+        break;
+
+    case EDT_UShort:
+    case EDT_Short:
+        lsize = 2;
+        break;
+
+    case EDT_UInt:
+    case EDT_Int:
+    case EDT_Float:
+        lsize = 4;
+        break;
+
+    case EDT_Double:
+        lsize = 8;
+        break;
+
+    case EDT_INVALID:
+    default:
+        break;
+    }
+
+    //read the next file block if needed
+    if (bufferSize < lsize) {
+        std::vector<char> nbuffer;
+        if (streamBuffer.getNextBlock(nbuffer)) {
+            //concat buffer contents
+            buffer = std::vector<char>(buffer.end() - bufferSize, buffer.end());
+            buffer.insert(buffer.end(), nbuffer.begin(), nbuffer.end());
+            nbuffer.clear();
+            bufferSize = static_cast<unsigned int>(buffer.size());
+            pCur = (char *)&buffer[0];
+        } else {
+            throw DeadlyImportError("Invalid .ply file: File corrupted");
+        }
+    }
+
+    bool ret = true;
+    switch (eType) {
+    case EDT_UInt: {
+        uint32_t t;
+        memcpy(&t, pCur, sizeof(uint32_t));
+        pCur += sizeof(uint32_t);
+
+        // Swap endianness
+        if (p_bBE) ByteSwap::Swap(&t);
+        out->iUInt = t;
+        break;
+    }
+
+    case EDT_UShort: {
+        uint16_t t;
+        memcpy(&t, pCur, sizeof(uint16_t));
+        pCur += sizeof(uint16_t);
+
+        // Swap endianness
+        if (p_bBE) ByteSwap::Swap(&t);
+        out->iUInt = t;
+        break;
+    }
+
+    case EDT_UChar: {
+        uint8_t t;
+        memcpy(&t, pCur, sizeof(uint8_t));
+        pCur += sizeof(uint8_t);
+        out->iUInt = t;
+        break;
+    }
+
+    case EDT_Int: {
+        int32_t t;
+        memcpy(&t, pCur, sizeof(int32_t));
+        pCur += sizeof(int32_t);
+
+        // Swap endianness
+        if (p_bBE) ByteSwap::Swap(&t);
+        out->iInt = t;
+        break;
+    }
+
+    case EDT_Short: {
+        int16_t t;
+        memcpy(&t, pCur, sizeof(int16_t));
+        pCur += sizeof(int16_t);
+
+        // Swap endianness
+        if (p_bBE) ByteSwap::Swap(&t);
+        out->iInt = t;
+        break;
+    }
+
+    case EDT_Char: {
+        int8_t t;
+        memcpy(&t, pCur, sizeof(int8_t));
+        pCur += sizeof(int8_t);
+        out->iInt = t;
+        break;
+    }
+
+    case EDT_Float: {
+        float t;
+        memcpy(&t, pCur, sizeof(float));
+        pCur += sizeof(float);
+
+        // Swap endianness
+        if (p_bBE) ByteSwap::Swap(&t);
+        out->fFloat = t;
+        break;
+    }
+    case EDT_Double: {
+        double t;
+        memcpy(&t, pCur, sizeof(double));
+        pCur += sizeof(double);
+
+        // Swap endianness
+        if (p_bBE) ByteSwap::Swap(&t);
+        out->fDouble = t;
+        break;
+    }
+    default:
+        ret = false;
+    }
+
+    bufferSize -= lsize;
+
+    return ret;
+}
+
+#endif // !! ASSIMP_BUILD_NO_PLY_IMPORTER
diff --git a/Engine/lib/assimp/code/Ply/PlyParser.h b/Engine/lib/assimp/code/AssetLib/Ply/PlyParser.h
similarity index 99%
rename from Engine/lib/assimp/code/Ply/PlyParser.h
rename to Engine/lib/assimp/code/AssetLib/Ply/PlyParser.h
index a11b411d1..86349294e 100644
--- a/Engine/lib/assimp/code/Ply/PlyParser.h
+++ b/Engine/lib/assimp/code/AssetLib/Ply/PlyParser.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -48,8 +48,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/IOStreamBuffer.h>
 #include <vector>
 
-namespace Assimp
-{
+namespace Assimp {
 
 //pre-declaration
 class PLYImporter;
diff --git a/Engine/lib/assimp/code/Q3BSP/Q3BSPFileData.h b/Engine/lib/assimp/code/AssetLib/Q3BSP/Q3BSPFileData.h
similarity index 98%
rename from Engine/lib/assimp/code/Q3BSP/Q3BSPFileData.h
rename to Engine/lib/assimp/code/AssetLib/Q3BSP/Q3BSPFileData.h
index 4e05bebf1..8ccee0b0a 100644
--- a/Engine/lib/assimp/code/Q3BSP/Q3BSPFileData.h
+++ b/Engine/lib/assimp/code/AssetLib/Q3BSP/Q3BSPFileData.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -95,7 +95,7 @@ struct sQ3BSPVertex {
     vec3f vPosition;    ///< Position of vertex
     vec2f vTexCoord;    ///< (u,v) Texturecoordinate of detailtexture
     vec2f vLightmap;    ///< (u,v) Texturecoordinate of lightmap
-    vec3f vNormal;      ///< vertex normale
+    vec3f vNormal;      ///< vertex normal
     unsigned char bColor[ 4 ];          ///< Color in RGBA
 };
 
@@ -178,7 +178,7 @@ struct Q3BSPModel {
         m_Textures(),
         m_Lightmaps(),
         m_EntityData(),
-        m_ModelName( "" )
+        m_ModelName()
     {
         // empty
     }
diff --git a/Engine/lib/assimp/code/AssetLib/Q3BSP/Q3BSPFileImporter.cpp b/Engine/lib/assimp/code/AssetLib/Q3BSP/Q3BSPFileImporter.cpp
new file mode 100644
index 000000000..db9a4a02f
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Q3BSP/Q3BSPFileImporter.cpp
@@ -0,0 +1,680 @@
+/*
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+---------------------------------------------------------------------------------------------------
+*/
+
+#ifndef ASSIMP_BUILD_NO_Q3BSP_IMPORTER
+
+#include "Q3BSPFileImporter.h"
+#include "Q3BSPFileData.h"
+#include "Q3BSPFileParser.h"
+
+#include <assimp/DefaultLogger.hpp>
+
+#ifdef ASSIMP_BUILD_NO_OWN_ZLIB
+#include <zlib.h>
+#else
+#include "../contrib/zlib/zlib.h"
+#endif
+
+#include <assimp/DefaultIOSystem.h>
+#include <assimp/StringComparison.h>
+#include <assimp/ZipArchiveIOSystem.h>
+#include <assimp/ai_assert.h>
+#include <assimp/importerdesc.h>
+#include <assimp/mesh.h>
+#include <assimp/scene.h>
+#include <assimp/types.h>
+#include <sstream>
+#include <vector>
+
+static const aiImporterDesc desc = {
+    "Quake III BSP Importer",
+    "",
+    "",
+    "",
+    aiImporterFlags_SupportBinaryFlavour,
+    0,
+    0,
+    0,
+    0,
+    "bsp pk3"
+};
+
+namespace Assimp {
+
+using namespace Q3BSP;
+
+// ------------------------------------------------------------------------------------------------
+//  Local function to create a material key name.
+static void createKey(int id1, int id2, std::string &key) {
+    std::ostringstream str;
+    str << id1 << "." << id2;
+    key = str.str();
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Local function to extract the texture ids from a material key-name.
+static void extractIds(const std::string &key, int &id1, int &id2) {
+    id1 = -1;
+    id2 = -1;
+    if (key.empty()) {
+        return;
+    }
+
+    const std::string::size_type pos = key.find('.');
+    if (std::string::npos == pos) {
+        return;
+    }
+
+    std::string tmp1 = key.substr(0, pos);
+    std::string tmp2 = key.substr(pos + 1, key.size() - pos - 1);
+    id1 = atoi(tmp1.c_str());
+    id2 = atoi(tmp2.c_str());
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Local helper function to normalize filenames.
+static void normalizePathName(const std::string &rPath, std::string &normalizedPath) {
+    normalizedPath = std::string();
+    if (rPath.empty()) {
+        return;
+    }
+
+#ifdef _WIN32
+    std::string sep = "\\";
+#else
+    std::string sep = "/";
+#endif
+
+    static const unsigned int numDelimiters = 2;
+    const char delimiters[numDelimiters] = { '/', '\\' };
+    normalizedPath = rPath;
+    for (const char delimiter : delimiters) {
+        for (size_t j = 0; j < normalizedPath.size(); ++j) {
+            if (normalizedPath[j] == delimiter) {
+                normalizedPath[j] = sep[0];
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Constructor.
+Q3BSPFileImporter::Q3BSPFileImporter() :
+        m_pCurrentMesh(nullptr), m_pCurrentFace(nullptr), m_MaterialLookupMap(), mTextures() {
+    // empty
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Destructor.
+Q3BSPFileImporter::~Q3BSPFileImporter() {
+    // Clear face-to-material map
+    for (FaceMap::iterator it = m_MaterialLookupMap.begin(); it != m_MaterialLookupMap.end(); ++it) {
+        const std::string &matName = it->first;
+        if (!matName.empty()) {
+            delete it->second;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Returns true if the loader can read this.
+bool Q3BSPFileImporter::CanRead(const std::string &filename, IOSystem * /*pIOHandler*/, bool checkSig) const {
+    if (!checkSig) {
+        return SimpleExtensionCheck(filename, "pk3", "bsp");
+    }
+    return false;
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Adds extensions.
+const aiImporterDesc *Q3BSPFileImporter::GetInfo() const {
+    return &desc;
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Import method.
+void Q3BSPFileImporter::InternReadFile(const std::string &rFile, aiScene *scene, IOSystem *ioHandler) {
+    ZipArchiveIOSystem Archive(ioHandler, rFile);
+    if (!Archive.isOpen()) {
+        throw DeadlyImportError("Failed to open file ", rFile, ".");
+    }
+
+    std::string archiveName, mapName;
+    separateMapName(rFile, archiveName, mapName);
+
+    if (mapName.empty()) {
+        if (!findFirstMapInArchive(Archive, mapName)) {
+            return;
+        }
+    }
+
+    Q3BSPFileParser fileParser(mapName, &Archive);
+    Q3BSPModel *pBSPModel = fileParser.getModel();
+    if (nullptr != pBSPModel) {
+        CreateDataFromImport(pBSPModel, scene, &Archive);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Separates the map name from the import name.
+void Q3BSPFileImporter::separateMapName(const std::string &importName, std::string &archiveName, std::string &mapName) {
+    archiveName = std::string();
+    mapName = std::string();
+    if (importName.empty()) {
+        return;
+    }
+
+    const std::string::size_type pos = importName.rfind(',');
+    if (std::string::npos == pos) {
+        archiveName = importName;
+        return;
+    }
+
+    archiveName = importName.substr(0, pos);
+    mapName = importName.substr(pos, importName.size() - pos - 1);
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Returns the first map in the map archive.
+bool Q3BSPFileImporter::findFirstMapInArchive(ZipArchiveIOSystem &bspArchive, std::string &mapName) {
+    mapName = std::string();
+    std::vector<std::string> fileList;
+    bspArchive.getFileListExtension(fileList, "bsp");
+    if (fileList.empty()) {
+        return false;
+    }
+
+    std::vector<std::string>::iterator it(fileList.begin());
+    for (; it != fileList.end(); ++it) {
+        const std::string::size_type pos = (*it).find("maps/");
+        if (std::string::npos != pos) {
+            std::string::size_type extPos = (*it).find(".bsp");
+            if (std::string::npos != extPos) {
+                mapName = *it;
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Creates the assimp specific data.
+void Q3BSPFileImporter::CreateDataFromImport(const Q3BSP::Q3BSPModel *pModel, aiScene *pScene,
+        ZipArchiveIOSystem *pArchive) {
+    if (nullptr == pModel || nullptr == pScene) {
+        return;
+    }
+
+    pScene->mRootNode = new aiNode;
+    if (!pModel->m_ModelName.empty()) {
+        pScene->mRootNode->mName.Set(pModel->m_ModelName);
+    }
+
+    // Create the face to material relation map
+    createMaterialMap(pModel);
+
+    // Create all nodes
+    CreateNodes(pModel, pScene, pScene->mRootNode);
+
+    // Create the assigned materials
+    createMaterials(pModel, pScene, pArchive);
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Creates all assimp nodes.
+void Q3BSPFileImporter::CreateNodes(const Q3BSP::Q3BSPModel *pModel, aiScene *pScene,
+        aiNode *pParent) {
+    if (nullptr == pModel) {
+        return;
+    }
+
+    unsigned int matIdx(0);
+    std::vector<aiMesh *> MeshArray;
+    std::vector<aiNode *> NodeArray;
+    for (FaceMapIt it = m_MaterialLookupMap.begin(); it != m_MaterialLookupMap.end(); ++it) {
+        std::vector<Q3BSP::sQ3BSPFace *> *pArray = (*it).second;
+        size_t numVerts = countData(*pArray);
+        if (0 != numVerts) {
+            aiMesh *pMesh(nullptr);
+            aiNode *pNode = CreateTopology(pModel, matIdx, *pArray, &pMesh);
+            if (nullptr != pNode) {
+                NodeArray.push_back(pNode);
+                MeshArray.push_back(pMesh);
+            }
+        }
+        matIdx++;
+    }
+
+    pScene->mNumMeshes = static_cast<unsigned int>(MeshArray.size());
+    if (pScene->mNumMeshes > 0) {
+        pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
+        for (size_t i = 0; i < MeshArray.size(); i++) {
+            aiMesh *pMesh = MeshArray[i];
+            if (nullptr != pMesh) {
+                pScene->mMeshes[i] = pMesh;
+            }
+        }
+    }
+
+    pParent->mNumChildren = static_cast<unsigned int>(MeshArray.size());
+    pParent->mChildren = new aiNode *[pScene->mRootNode->mNumChildren];
+    for (size_t i = 0; i < NodeArray.size(); i++) {
+        aiNode *pNode = NodeArray[i];
+        pNode->mParent = pParent;
+        pParent->mChildren[i] = pNode;
+        pParent->mChildren[i]->mMeshes[0] = static_cast<unsigned int>(i);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Creates the topology.
+aiNode *Q3BSPFileImporter::CreateTopology(const Q3BSP::Q3BSPModel *pModel, unsigned int materialIdx,
+        std::vector<sQ3BSPFace *> &rArray, aiMesh **pMesh) {
+    size_t numVerts = countData(rArray);
+    if (0 == numVerts) {
+        return nullptr;
+    }
+
+    size_t numFaces = countFaces(rArray);
+    if (0 == numFaces) {
+        return nullptr;
+    }
+
+    aiMesh *mesh = new aiMesh;
+    size_t numTriangles = countTriangles(rArray);
+    mesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
+
+    mesh->mFaces = new aiFace[numTriangles];
+    mesh->mNumFaces = static_cast<unsigned int>(numTriangles);
+
+    mesh->mNumVertices = static_cast<unsigned int>(numVerts);
+    mesh->mVertices = new aiVector3D[numVerts];
+    mesh->mNormals = new aiVector3D[numVerts];
+    mesh->mTextureCoords[0] = new aiVector3D[numVerts];
+    mesh->mTextureCoords[1] = new aiVector3D[numVerts];
+    mesh->mMaterialIndex = materialIdx;
+
+    unsigned int faceIdx = 0;
+    unsigned int vertIdx = 0;
+    mesh->mNumUVComponents[0] = 2;
+    mesh->mNumUVComponents[1] = 2;
+    for (std::vector<sQ3BSPFace *>::const_iterator it = rArray.begin(); it != rArray.end(); ++it) {
+        Q3BSP::sQ3BSPFace *pQ3BSPFace = *it;
+        ai_assert(nullptr != pQ3BSPFace);
+        if (nullptr == pQ3BSPFace) {
+            continue;
+        }
+
+        if (pQ3BSPFace->iNumOfFaceVerts > 0) {
+            if (pQ3BSPFace->iType == Polygon || pQ3BSPFace->iType == TriangleMesh) {
+                createTriangleTopology(pModel, pQ3BSPFace, mesh, faceIdx, vertIdx);
+            }
+        }
+    }
+
+    aiNode *pNode = new aiNode;
+    pNode->mNumMeshes = 1;
+    pNode->mMeshes = new unsigned int[1];
+    *pMesh = mesh;
+
+    return pNode;
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Creates the triangle topology from a face array.
+void Q3BSPFileImporter::createTriangleTopology(const Q3BSP::Q3BSPModel *pModel, sQ3BSPFace *pQ3BSPFace,
+        aiMesh *pMesh, unsigned int &faceIdx, unsigned int &vertIdx) {
+    ai_assert(faceIdx < pMesh->mNumFaces);
+
+    m_pCurrentFace = getNextFace(pMesh, faceIdx);
+    if (nullptr == m_pCurrentFace) {
+        return;
+    }
+
+    m_pCurrentFace->mNumIndices = 3;
+    m_pCurrentFace->mIndices = new unsigned int[m_pCurrentFace->mNumIndices];
+
+    size_t idx(0);
+    for (size_t i = 0; i < (size_t)pQ3BSPFace->iNumOfFaceVerts; ++i) {
+        const size_t index = pQ3BSPFace->iVertexIndex + pModel->m_Indices[pQ3BSPFace->iFaceVertexIndex + i];
+        if (index >= pModel->m_Vertices.size()) {
+            continue;
+        }
+
+        sQ3BSPVertex *pVertex = pModel->m_Vertices[index];
+        if (nullptr == pVertex) {
+            continue;
+        }
+        if (idx > 2) {
+            idx = 0;
+            m_pCurrentFace = getNextFace(pMesh, faceIdx);
+            if (nullptr != m_pCurrentFace) {
+                m_pCurrentFace->mNumIndices = 3;
+                m_pCurrentFace->mIndices = new unsigned int[3];
+                m_pCurrentFace->mIndices[idx] = vertIdx;
+            }
+        }
+
+        pMesh->mVertices[vertIdx].Set(pVertex->vPosition.x, pVertex->vPosition.y, pVertex->vPosition.z);
+        pMesh->mNormals[vertIdx].Set(pVertex->vNormal.x, pVertex->vNormal.y, pVertex->vNormal.z);
+
+        pMesh->mTextureCoords[0][vertIdx].Set(pVertex->vTexCoord.x, pVertex->vTexCoord.y, 0.0f);
+        pMesh->mTextureCoords[1][vertIdx].Set(pVertex->vLightmap.x, pVertex->vLightmap.y, 0.0f);
+
+        vertIdx++;
+        idx++;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Creates all referenced materials.
+void Q3BSPFileImporter::createMaterials(const Q3BSP::Q3BSPModel *pModel, aiScene *pScene,
+        ZipArchiveIOSystem *pArchive) {
+    if (m_MaterialLookupMap.empty()) {
+        return;
+    }
+
+    pScene->mMaterials = new aiMaterial *[m_MaterialLookupMap.size()];
+    aiString aiMatName;
+    int textureId(-1), lightmapId(-1);
+    for (FaceMapIt it = m_MaterialLookupMap.begin(); it != m_MaterialLookupMap.end();
+            ++it) {
+        const std::string matName(it->first);
+        if (matName.empty()) {
+            continue;
+        }
+
+        aiMatName.Set(matName);
+        aiMaterial *pMatHelper = new aiMaterial;
+        pMatHelper->AddProperty(&aiMatName, AI_MATKEY_NAME);
+
+        extractIds(matName, textureId, lightmapId);
+
+        // Adding the texture
+        if (-1 != textureId) {
+            sQ3BSPTexture *pTexture = pModel->m_Textures[textureId];
+            if (nullptr != pTexture) {
+                std::string tmp("*"), texName;
+                tmp += pTexture->strName;
+                tmp += ".jpg";
+                normalizePathName(tmp, texName);
+
+                if (!importTextureFromArchive(pModel, pArchive, pScene, pMatHelper, textureId)) {
+                    ASSIMP_LOG_ERROR("Cannot import texture from archive ", texName);
+                }
+            }
+        }
+        if (-1 != lightmapId) {
+            importLightmap(pModel, pScene, pMatHelper, lightmapId);
+        }
+        pScene->mMaterials[pScene->mNumMaterials] = pMatHelper;
+        pScene->mNumMaterials++;
+    }
+    pScene->mNumTextures = static_cast<unsigned int>(mTextures.size());
+    pScene->mTextures = new aiTexture *[pScene->mNumTextures];
+    std::copy(mTextures.begin(), mTextures.end(), pScene->mTextures);
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Counts the number of referenced vertices.
+size_t Q3BSPFileImporter::countData(const std::vector<sQ3BSPFace *> &faceArray) const {
+    size_t numVerts(0);
+    for (std::vector<sQ3BSPFace *>::const_iterator it = faceArray.begin(); it != faceArray.end();
+            ++it) {
+        sQ3BSPFace *pQ3BSPFace = *it;
+        if (pQ3BSPFace->iType == Polygon || pQ3BSPFace->iType == TriangleMesh) {
+            Q3BSP::sQ3BSPFace *face = *it;
+            if (nullptr != face) {
+                numVerts += face->iNumOfFaceVerts;
+            }
+        }
+    }
+
+    return numVerts;
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Counts the faces with vertices.
+size_t Q3BSPFileImporter::countFaces(const std::vector<Q3BSP::sQ3BSPFace *> &rArray) const {
+    size_t numFaces = 0;
+    for (std::vector<sQ3BSPFace *>::const_iterator it = rArray.begin(); it != rArray.end();
+            ++it) {
+        Q3BSP::sQ3BSPFace *pQ3BSPFace = *it;
+        if (pQ3BSPFace->iNumOfFaceVerts > 0) {
+            numFaces++;
+        }
+    }
+
+    return numFaces;
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Counts the number of triangles in a Q3-face-array.
+size_t Q3BSPFileImporter::countTriangles(const std::vector<Q3BSP::sQ3BSPFace *> &rArray) const {
+    size_t numTriangles = 0;
+    for (std::vector<Q3BSP::sQ3BSPFace *>::const_iterator it = rArray.begin(); it != rArray.end();
+            ++it) {
+        const Q3BSP::sQ3BSPFace *pQ3BSPFace = *it;
+        if (nullptr != pQ3BSPFace) {
+            numTriangles += pQ3BSPFace->iNumOfFaceVerts / 3;
+        }
+    }
+
+    return numTriangles;
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Creates the faces-to-material map.
+void Q3BSPFileImporter::createMaterialMap(const Q3BSP::Q3BSPModel *pModel) {
+    std::string key;
+    std::vector<sQ3BSPFace *> *pCurFaceArray = nullptr;
+    for (size_t idx = 0; idx < pModel->m_Faces.size(); idx++) {
+        Q3BSP::sQ3BSPFace *pQ3BSPFace = pModel->m_Faces[idx];
+        const int texId = pQ3BSPFace->iTextureID;
+        const int lightMapId = pQ3BSPFace->iLightmapID;
+        createKey(texId, lightMapId, key);
+        FaceMapIt it = m_MaterialLookupMap.find(key);
+        if (m_MaterialLookupMap.end() == it) {
+            pCurFaceArray = new std::vector<Q3BSP::sQ3BSPFace *>;
+            m_MaterialLookupMap[key] = pCurFaceArray;
+        } else {
+            pCurFaceArray = (*it).second;
+        }
+        ai_assert(nullptr != pCurFaceArray);
+        if (nullptr != pCurFaceArray) {
+            pCurFaceArray->push_back(pQ3BSPFace);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Returns the next face.
+aiFace *Q3BSPFileImporter::getNextFace(aiMesh *mesh, unsigned int &faceIdx) {
+    aiFace *face(nullptr);
+    if (faceIdx < mesh->mNumFaces) {
+        face = &mesh->mFaces[faceIdx];
+        ++faceIdx;
+    }
+
+    return face;
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Imports a texture file.
+bool Q3BSPFileImporter::importTextureFromArchive(const Q3BSP::Q3BSPModel *model,
+        ZipArchiveIOSystem *archive, aiScene *,
+        aiMaterial *pMatHelper, int textureId) {
+    if (nullptr == archive || nullptr == pMatHelper) {
+        return false;
+    }
+
+    if (textureId < 0 || textureId >= static_cast<int>(model->m_Textures.size())) {
+        return false;
+    }
+
+    bool res = true;
+    sQ3BSPTexture *pTexture = model->m_Textures[textureId];
+    if (!pTexture) {
+        return false;
+    }
+
+    std::vector<std::string> supportedExtensions;
+    supportedExtensions.push_back(".jpg");
+    supportedExtensions.push_back(".png");
+    supportedExtensions.push_back(".tga");
+    std::string textureName, ext;
+    if (expandFile(archive, pTexture->strName, supportedExtensions, textureName, ext)) {
+        IOStream *pTextureStream = archive->Open(textureName.c_str());
+        if (pTextureStream) {
+            size_t texSize = pTextureStream->FileSize();
+            aiTexture *curTexture = new aiTexture;
+            curTexture->mHeight = 0;
+            curTexture->mWidth = static_cast<unsigned int>(texSize);
+            unsigned char *pData = new unsigned char[curTexture->mWidth];
+            size_t readSize = pTextureStream->Read(pData, sizeof(unsigned char), curTexture->mWidth);
+            (void)readSize;
+            ai_assert(readSize == curTexture->mWidth);
+            curTexture->pcData = reinterpret_cast<aiTexel *>(pData);
+            curTexture->achFormatHint[0] = ext[1];
+            curTexture->achFormatHint[1] = ext[2];
+            curTexture->achFormatHint[2] = ext[3];
+            curTexture->achFormatHint[3] = '\0';
+            res = true;
+
+            aiString name;
+            name.data[0] = '*';
+            name.length = 1 + ASSIMP_itoa10(name.data + 1, static_cast<unsigned int>(MAXLEN - 1), static_cast<int32_t>(mTextures.size()));
+
+            archive->Close(pTextureStream);
+
+            pMatHelper->AddProperty(&name, AI_MATKEY_TEXTURE_DIFFUSE(0));
+            mTextures.push_back(curTexture);
+        } else {
+            // If it doesn't exist in the archive, it is probably just a reference to an external file.
+            // We'll leave it up to the user to figure out which extension the file has.
+            aiString name;
+            strncpy(name.data, pTexture->strName, sizeof name.data);
+            name.length = static_cast<ai_uint32>(strlen(name.data));
+            pMatHelper->AddProperty(&name, AI_MATKEY_TEXTURE_DIFFUSE(0));
+        }
+    }
+
+    return res;
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Imports a light map file.
+bool Q3BSPFileImporter::importLightmap(const Q3BSP::Q3BSPModel *pModel, aiScene *pScene,
+        aiMaterial *pMatHelper, int lightmapId) {
+    if (nullptr == pModel || nullptr == pScene || nullptr == pMatHelper) {
+        return false;
+    }
+
+    if (lightmapId < 0 || lightmapId >= static_cast<int>(pModel->m_Lightmaps.size())) {
+        return false;
+    }
+
+    sQ3BSPLightmap *pLightMap = pModel->m_Lightmaps[lightmapId];
+    if (nullptr == pLightMap) {
+        return false;
+    }
+
+    aiTexture *pTexture = new aiTexture;
+
+    pTexture->mWidth = CE_BSP_LIGHTMAPWIDTH;
+    pTexture->mHeight = CE_BSP_LIGHTMAPHEIGHT;
+    pTexture->pcData = new aiTexel[CE_BSP_LIGHTMAPWIDTH * CE_BSP_LIGHTMAPHEIGHT];
+
+    ::memcpy(pTexture->pcData, pLightMap->bLMapData, pTexture->mWidth);
+    size_t p = 0;
+    for (size_t i = 0; i < CE_BSP_LIGHTMAPWIDTH * CE_BSP_LIGHTMAPHEIGHT; ++i) {
+        pTexture->pcData[i].r = pLightMap->bLMapData[p++];
+        pTexture->pcData[i].g = pLightMap->bLMapData[p++];
+        pTexture->pcData[i].b = pLightMap->bLMapData[p++];
+        pTexture->pcData[i].a = 0xFF;
+    }
+
+    aiString name;
+    name.data[0] = '*';
+    name.length = 1 + ASSIMP_itoa10(name.data + 1, static_cast<unsigned int>(MAXLEN - 1), static_cast<int32_t>(mTextures.size()));
+
+    pMatHelper->AddProperty(&name, AI_MATKEY_TEXTURE_LIGHTMAP(1));
+    mTextures.push_back(pTexture);
+
+    return true;
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Will search for a supported extension.
+bool Q3BSPFileImporter::expandFile(ZipArchiveIOSystem *pArchive, const std::string &rFilename,
+        const std::vector<std::string> &rExtList, std::string &rFile,
+        std::string &rExt) {
+    ai_assert(nullptr != pArchive);
+    ai_assert(!rFilename.empty());
+
+    if (rExtList.empty()) {
+        rFile = rFilename;
+        rExt = std::string();
+        return true;
+    }
+
+    bool found = false;
+    for (std::vector<std::string>::const_iterator it = rExtList.begin(); it != rExtList.end(); ++it) {
+        const std::string textureName = rFilename + *it;
+        if (pArchive->Exists(textureName.c_str())) {
+            rExt = *it;
+            rFile = textureName;
+            found = true;
+            break;
+        }
+    }
+
+    return found;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+} // Namespace Assimp
+
+#endif // ASSIMP_BUILD_NO_Q3BSP_IMPORTER
diff --git a/Engine/lib/assimp/code/Q3BSP/Q3BSPFileImporter.h b/Engine/lib/assimp/code/AssetLib/Q3BSP/Q3BSPFileImporter.h
similarity index 91%
rename from Engine/lib/assimp/code/Q3BSP/Q3BSPFileImporter.h
rename to Engine/lib/assimp/code/AssetLib/Q3BSP/Q3BSPFileImporter.h
index ee21fa48e..fdcfff876 100644
--- a/Engine/lib/assimp/code/Q3BSP/Q3BSPFileImporter.h
+++ b/Engine/lib/assimp/code/AssetLib/Q3BSP/Q3BSPFileImporter.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -71,19 +70,19 @@ public:
     Q3BSPFileImporter();
 
     /// @brief  Destructor.
-    ~Q3BSPFileImporter();
+    ~Q3BSPFileImporter() override;
 
     /// @brief  Returns whether the class can handle the format of the given file.
     /// @remark See BaseImporter::CanRead() for details.
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig ) const;
+    bool CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig ) const override;
 
 protected:
-    typedef std::map<std::string, std::vector<Q3BSP::sQ3BSPFace*>*> FaceMap;
-    typedef std::map<std::string, std::vector<Q3BSP::sQ3BSPFace*>* >::iterator FaceMapIt;
-    typedef std::map<std::string, std::vector<Q3BSP::sQ3BSPFace*>*>::const_iterator FaceMapConstIt;
+    using FaceMap = std::map<std::string, std::vector<Q3BSP::sQ3BSPFace*>*>;
+    using FaceMapIt = std::map<std::string, std::vector<Q3BSP::sQ3BSPFace*>* >::iterator;
+    using FaceMapConstIt = std::map<std::string, std::vector<Q3BSP::sQ3BSPFace*>*>::const_iterator;
 
-    const aiImporterDesc* GetInfo () const;
-    void InternReadFile(const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler);
+    const aiImporterDesc* GetInfo () const override;
+    void InternReadFile(const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) override;
     void separateMapName( const std::string &rImportName, std::string &rArchiveName, std::string &rMapName );
     bool findFirstMapInArchive(ZipArchiveIOSystem &rArchive, std::string &rMapName );
     void CreateDataFromImport( const Q3BSP::Q3BSPModel *pModel, aiScene* pScene, ZipArchiveIOSystem *pArchive );
diff --git a/Engine/lib/assimp/code/Q3BSP/Q3BSPFileParser.cpp b/Engine/lib/assimp/code/AssetLib/Q3BSP/Q3BSPFileParser.cpp
similarity index 99%
rename from Engine/lib/assimp/code/Q3BSP/Q3BSPFileParser.cpp
rename to Engine/lib/assimp/code/AssetLib/Q3BSP/Q3BSPFileParser.cpp
index bed2efe53..910da5b36 100644
--- a/Engine/lib/assimp/code/Q3BSP/Q3BSPFileParser.cpp
+++ b/Engine/lib/assimp/code/AssetLib/Q3BSP/Q3BSPFileParser.cpp
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -78,7 +77,6 @@ Q3BSPFileParser::Q3BSPFileParser( const std::string &mapName, ZipArchiveIOSystem
 // ------------------------------------------------------------------------------------------------
 Q3BSPFileParser::~Q3BSPFileParser() {
     delete m_pModel;
-    m_pModel = nullptr;
 }
 
 // ------------------------------------------------------------------------------------------------
diff --git a/Engine/lib/assimp/code/Q3BSP/Q3BSPFileParser.h b/Engine/lib/assimp/code/AssetLib/Q3BSP/Q3BSPFileParser.h
similarity index 95%
rename from Engine/lib/assimp/code/Q3BSP/Q3BSPFileParser.h
rename to Engine/lib/assimp/code/AssetLib/Q3BSP/Q3BSPFileParser.h
index fd73f5e10..15cc751cc 100644
--- a/Engine/lib/assimp/code/Q3BSP/Q3BSPFileParser.h
+++ b/Engine/lib/assimp/code/AssetLib/Q3BSP/Q3BSPFileParser.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -57,9 +56,9 @@ namespace Q3BSP
 }
 
 // -------------------------------------------------------------------
+///	@brief  This class implements th Q3DSP file parsing.
 // -------------------------------------------------------------------
-class Q3BSPFileParser
-{
+class Q3BSPFileParser {
 public:
     Q3BSPFileParser( const std::string &rMapName, ZipArchiveIOSystem *pZipArchive );
     ~Q3BSPFileParser();
diff --git a/Engine/lib/assimp/code/AssetLib/Q3D/Q3DLoader.cpp b/Engine/lib/assimp/code/AssetLib/Q3D/Q3DLoader.cpp
new file mode 100644
index 000000000..c773bbfcd
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Q3D/Q3DLoader.cpp
@@ -0,0 +1,575 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file  Q3DLoader.cpp
+ *  @brief Implementation of the Q3D importer class
+ */
+
+#ifndef ASSIMP_BUILD_NO_Q3D_IMPORTER
+
+// internal headers
+#include "Q3DLoader.h"
+#include <assimp/StringUtils.h>
+#include <assimp/StreamReader.h>
+#include <assimp/fast_atof.h>
+#include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOSystem.hpp>
+
+using namespace Assimp;
+
+static const aiImporterDesc desc = {
+    "Quick3D Importer",
+    "",
+    "",
+    "http://www.quick3d.com/",
+    aiImporterFlags_SupportBinaryFlavour,
+    0,
+    0,
+    0,
+    0,
+    "q3o q3s"
+};
+
+// ------------------------------------------------------------------------------------------------
+// Constructor to be privately used by Importer
+Q3DImporter::Q3DImporter() {
+    // empty
+}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor, private as well
+Q3DImporter::~Q3DImporter() {
+    // empty
+}
+
+// ------------------------------------------------------------------------------------------------
+// Returns whether the class can handle the format of the given file.
+bool Q3DImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
+    static const char *tokens[] = { "quick3Do", "quick3Ds" };
+    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
+}
+
+// ------------------------------------------------------------------------------------------------
+const aiImporterDesc *Q3DImporter::GetInfo() const {
+    return &desc;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Imports the given file into the given scene structure.
+void Q3DImporter::InternReadFile(const std::string &pFile,
+        aiScene *pScene, IOSystem *pIOHandler) {
+
+    auto file = pIOHandler->Open(pFile, "rb");
+    if (!file)
+        throw DeadlyImportError("Quick3D: Could not open ", pFile);
+
+    StreamReaderLE stream(file);
+
+    // The header is 22 bytes large
+    if (stream.GetRemainingSize() < 22)
+        throw DeadlyImportError("File is either empty or corrupt: ", pFile);
+
+    // Check the file's signature
+    if (ASSIMP_strincmp((const char *)stream.GetPtr(), "quick3Do", 8) &&
+            ASSIMP_strincmp((const char *)stream.GetPtr(), "quick3Ds", 8)) {
+        throw DeadlyImportError("Not a Quick3D file. Signature string is: ", ai_str_toprintable((const char *)stream.GetPtr(), 8));
+    }
+
+    // Print the file format version
+    ASSIMP_LOG_INFO("Quick3D File format version: ",
+            std::string(&((const char *)stream.GetPtr())[8], 2));
+
+    // ... an store it
+    char major = ((const char *)stream.GetPtr())[8];
+    char minor = ((const char *)stream.GetPtr())[9];
+
+    stream.IncPtr(10);
+    unsigned int numMeshes = (unsigned int)stream.GetI4();
+    unsigned int numMats = (unsigned int)stream.GetI4();
+    unsigned int numTextures = (unsigned int)stream.GetI4();
+
+    std::vector<Material> materials;
+    materials.reserve(numMats);
+
+    std::vector<Mesh> meshes;
+    meshes.reserve(numMeshes);
+
+    // Allocate the scene root node
+    pScene->mRootNode = new aiNode();
+
+    aiColor3D fgColor(0.6f, 0.6f, 0.6f);
+
+    // Now read all file chunks
+    while (true) {
+        if (stream.GetRemainingSize() < 1) break;
+        char c = stream.GetI1();
+        switch (c) {
+            // Meshes chunk
+        case 'm': {
+            for (unsigned int quak = 0; quak < numMeshes; ++quak) {
+                meshes.push_back(Mesh());
+                Mesh &mesh = meshes.back();
+
+                // read all vertices
+                unsigned int numVerts = (unsigned int)stream.GetI4();
+                if (!numVerts)
+                    throw DeadlyImportError("Quick3D: Found mesh with zero vertices");
+
+                std::vector<aiVector3D> &verts = mesh.verts;
+                verts.resize(numVerts);
+
+                for (unsigned int i = 0; i < numVerts; ++i) {
+                    verts[i].x = stream.GetF4();
+                    verts[i].y = stream.GetF4();
+                    verts[i].z = stream.GetF4();
+                }
+
+                // read all faces
+                numVerts = (unsigned int)stream.GetI4();
+                if (!numVerts)
+                    throw DeadlyImportError("Quick3D: Found mesh with zero faces");
+
+                std::vector<Face> &faces = mesh.faces;
+                faces.reserve(numVerts);
+
+                // number of indices
+                for (unsigned int i = 0; i < numVerts; ++i) {
+                    faces.push_back(Face(stream.GetI2()));
+                    if (faces.back().indices.empty())
+                        throw DeadlyImportError("Quick3D: Found face with zero indices");
+                }
+
+                // indices
+                for (unsigned int i = 0; i < numVerts; ++i) {
+                    Face &vec = faces[i];
+                    for (unsigned int a = 0; a < (unsigned int)vec.indices.size(); ++a)
+                        vec.indices[a] = stream.GetI4();
+                }
+
+                // material indices
+                for (unsigned int i = 0; i < numVerts; ++i) {
+                    faces[i].mat = (unsigned int)stream.GetI4();
+                }
+
+                // read all normals
+                numVerts = (unsigned int)stream.GetI4();
+                std::vector<aiVector3D> &normals = mesh.normals;
+                normals.resize(numVerts);
+
+                for (unsigned int i = 0; i < numVerts; ++i) {
+                    normals[i].x = stream.GetF4();
+                    normals[i].y = stream.GetF4();
+                    normals[i].z = stream.GetF4();
+                }
+
+                numVerts = (unsigned int)stream.GetI4();
+                if (numTextures && numVerts) {
+                    // read all texture coordinates
+                    std::vector<aiVector3D> &uv = mesh.uv;
+                    uv.resize(numVerts);
+
+                    for (unsigned int i = 0; i < numVerts; ++i) {
+                        uv[i].x = stream.GetF4();
+                        uv[i].y = stream.GetF4();
+                    }
+
+                    // UV indices
+                    for (unsigned int i = 0; i < (unsigned int)faces.size(); ++i) {
+                        Face &vec = faces[i];
+                        for (unsigned int a = 0; a < (unsigned int)vec.indices.size(); ++a) {
+                            vec.uvindices[a] = stream.GetI4();
+                            if (!i && !a)
+                                mesh.prevUVIdx = vec.uvindices[a];
+                            else if (vec.uvindices[a] != mesh.prevUVIdx)
+                                mesh.prevUVIdx = UINT_MAX;
+                        }
+                    }
+                }
+
+                // we don't need the rest, but we need to get to the next chunk
+                stream.IncPtr(36);
+                if (minor > '0' && major == '3')
+                    stream.IncPtr(mesh.faces.size());
+            }
+            // stream.IncPtr(4); // unknown value here
+        } break;
+
+            // materials chunk
+        case 'c':
+
+            for (unsigned int i = 0; i < numMats; ++i) {
+                materials.push_back(Material());
+                Material &mat = materials.back();
+
+                // read the material name
+                c = stream.GetI1();
+                while (c) {
+                    mat.name.data[mat.name.length++] = c;
+                    c = stream.GetI1();
+                }
+
+                // add the terminal character
+                mat.name.data[mat.name.length] = '\0';
+
+                // read the ambient color
+                mat.ambient.r = stream.GetF4();
+                mat.ambient.g = stream.GetF4();
+                mat.ambient.b = stream.GetF4();
+
+                // read the diffuse color
+                mat.diffuse.r = stream.GetF4();
+                mat.diffuse.g = stream.GetF4();
+                mat.diffuse.b = stream.GetF4();
+
+                // read the ambient color
+                mat.specular.r = stream.GetF4();
+                mat.specular.g = stream.GetF4();
+                mat.specular.b = stream.GetF4();
+
+                // read the transparency
+                mat.transparency = stream.GetF4();
+
+                // unknown value here
+                // stream.IncPtr(4);
+                // FIX: it could be the texture index ...
+                mat.texIdx = (unsigned int)stream.GetI4();
+            }
+
+            break;
+
+            // texture chunk
+        case 't':
+
+            pScene->mNumTextures = numTextures;
+            if (!numTextures) {
+                break;
+            }
+            pScene->mTextures = new aiTexture *[pScene->mNumTextures];
+            // to make sure we won't crash if we leave through an exception
+            ::memset(pScene->mTextures, 0, sizeof(void *) * pScene->mNumTextures);
+            for (unsigned int i = 0; i < pScene->mNumTextures; ++i) {
+                aiTexture *tex = pScene->mTextures[i] = new aiTexture;
+
+                // skip the texture name
+                while (stream.GetI1())
+                    ;
+
+                // read texture width and height
+                tex->mWidth = (unsigned int)stream.GetI4();
+                tex->mHeight = (unsigned int)stream.GetI4();
+
+                if (!tex->mWidth || !tex->mHeight) {
+                    throw DeadlyImportError("Quick3D: Invalid texture. Width or height is zero");
+                }
+
+                unsigned int mul = tex->mWidth * tex->mHeight;
+                aiTexel *begin = tex->pcData = new aiTexel[mul];
+                aiTexel *const end = &begin[mul - 1] + 1;
+
+                for (; begin != end; ++begin) {
+                    begin->r = stream.GetI1();
+                    begin->g = stream.GetI1();
+                    begin->b = stream.GetI1();
+                    begin->a = 0xff;
+                }
+            }
+
+            break;
+
+            // scene chunk
+        case 's': {
+            // skip position and rotation
+            stream.IncPtr(12);
+
+            for (unsigned int i = 0; i < 4; ++i)
+                for (unsigned int a = 0; a < 4; ++a)
+                    pScene->mRootNode->mTransformation[i][a] = stream.GetF4();
+
+            stream.IncPtr(16);
+
+            // now setup a single camera
+            pScene->mNumCameras = 1;
+            pScene->mCameras = new aiCamera *[1];
+            aiCamera *cam = pScene->mCameras[0] = new aiCamera();
+            cam->mPosition.x = stream.GetF4();
+            cam->mPosition.y = stream.GetF4();
+            cam->mPosition.z = stream.GetF4();
+            cam->mName.Set("Q3DCamera");
+
+            // skip eye rotation for the moment
+            stream.IncPtr(12);
+
+            // read the default material color
+            fgColor.r = stream.GetF4();
+            fgColor.g = stream.GetF4();
+            fgColor.b = stream.GetF4();
+
+            // skip some unimportant properties
+            stream.IncPtr(29);
+
+            // setup a single point light with no attenuation
+            pScene->mNumLights = 1;
+            pScene->mLights = new aiLight *[1];
+            aiLight *light = pScene->mLights[0] = new aiLight();
+            light->mName.Set("Q3DLight");
+            light->mType = aiLightSource_POINT;
+
+            light->mAttenuationConstant = 1;
+            light->mAttenuationLinear = 0;
+            light->mAttenuationQuadratic = 0;
+
+            light->mColorDiffuse.r = stream.GetF4();
+            light->mColorDiffuse.g = stream.GetF4();
+            light->mColorDiffuse.b = stream.GetF4();
+
+            light->mColorSpecular = light->mColorDiffuse;
+
+            // We don't need the rest, but we need to know where this chunk ends.
+            unsigned int temp = (unsigned int)(stream.GetI4() * stream.GetI4());
+
+            // skip the background file name
+            while (stream.GetI1())
+                ;
+
+            // skip background texture data + the remaining fields
+            stream.IncPtr(temp * 3 + 20); // 4 bytes of unknown data here
+
+            // TODO
+            goto outer;
+        } break;
+
+        default:
+            throw DeadlyImportError("Quick3D: Unknown chunk");
+            break;
+        };
+    }
+outer:
+
+    // If we have no mesh loaded - break here
+    if (meshes.empty())
+        throw DeadlyImportError("Quick3D: No meshes loaded");
+
+    // If we have no materials loaded - generate a default mat
+    if (materials.empty()) {
+        ASSIMP_LOG_INFO("Quick3D: No material found, generating one");
+        materials.push_back(Material());
+        materials.back().diffuse = fgColor;
+    }
+
+    // find out which materials we'll need
+    typedef std::pair<unsigned int, unsigned int> FaceIdx;
+    typedef std::vector<FaceIdx> FaceIdxArray;
+    FaceIdxArray *fidx = new FaceIdxArray[materials.size()];
+
+    unsigned int p = 0;
+    for (std::vector<Mesh>::iterator it = meshes.begin(), end = meshes.end();
+            it != end; ++it, ++p) {
+        unsigned int q = 0;
+        for (std::vector<Face>::iterator fit = (*it).faces.begin(), fend = (*it).faces.end();
+                fit != fend; ++fit, ++q) {
+            if ((*fit).mat >= materials.size()) {
+                ASSIMP_LOG_WARN("Quick3D: Material index overflow");
+                (*fit).mat = 0;
+            }
+            if (fidx[(*fit).mat].empty()) ++pScene->mNumMeshes;
+            fidx[(*fit).mat].push_back(FaceIdx(p, q));
+        }
+    }
+    pScene->mNumMaterials = pScene->mNumMeshes;
+    pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials];
+    pScene->mMeshes = new aiMesh *[pScene->mNumMaterials];
+
+    for (unsigned int i = 0, real = 0; i < (unsigned int)materials.size(); ++i) {
+        if (fidx[i].empty()) continue;
+
+        // Allocate a mesh and a material
+        aiMesh *mesh = pScene->mMeshes[real] = new aiMesh();
+        aiMaterial *mat = new aiMaterial();
+        pScene->mMaterials[real] = mat;
+
+        mesh->mMaterialIndex = real;
+
+        // Build the output material
+        Material &srcMat = materials[i];
+        mat->AddProperty(&srcMat.diffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
+        mat->AddProperty(&srcMat.specular, 1, AI_MATKEY_COLOR_SPECULAR);
+        mat->AddProperty(&srcMat.ambient, 1, AI_MATKEY_COLOR_AMBIENT);
+
+        // NOTE: Ignore transparency for the moment - it seems
+        // unclear how to interpret the data
+#if 0
+        if (!(minor > '0' && major == '3'))
+            srcMat.transparency = 1.0f - srcMat.transparency;
+        mat->AddProperty(&srcMat.transparency, 1, AI_MATKEY_OPACITY);
+#endif
+
+        // add shininess - Quick3D seems to use it ins its viewer
+        srcMat.transparency = 16.f;
+        mat->AddProperty(&srcMat.transparency, 1, AI_MATKEY_SHININESS);
+
+        int m = (int)aiShadingMode_Phong;
+        mat->AddProperty(&m, 1, AI_MATKEY_SHADING_MODEL);
+
+        if (srcMat.name.length)
+            mat->AddProperty(&srcMat.name, AI_MATKEY_NAME);
+
+        // Add a texture
+        if (srcMat.texIdx < pScene->mNumTextures || real < pScene->mNumTextures) {
+            srcMat.name.data[0] = '*';
+            srcMat.name.length = ASSIMP_itoa10(&srcMat.name.data[1], 1000,
+                    (srcMat.texIdx < pScene->mNumTextures ? srcMat.texIdx : real));
+            mat->AddProperty(&srcMat.name, AI_MATKEY_TEXTURE_DIFFUSE(0));
+        }
+
+        mesh->mNumFaces = (unsigned int)fidx[i].size();
+        aiFace *faces = mesh->mFaces = new aiFace[mesh->mNumFaces];
+
+        // Now build the output mesh. First find out how many
+        // vertices we'll need
+        for (FaceIdxArray::const_iterator it = fidx[i].begin(), end = fidx[i].end();
+                it != end; ++it) {
+            mesh->mNumVertices += (unsigned int)meshes[(*it).first].faces[(*it).second].indices.size();
+        }
+
+        aiVector3D *verts = mesh->mVertices = new aiVector3D[mesh->mNumVertices];
+        aiVector3D *norms = mesh->mNormals = new aiVector3D[mesh->mNumVertices];
+        aiVector3D *uv = nullptr;
+        if (real < pScene->mNumTextures) {
+            uv = mesh->mTextureCoords[0] = new aiVector3D[mesh->mNumVertices];
+            mesh->mNumUVComponents[0] = 2;
+        }
+
+        // Build the final array
+        unsigned int cnt = 0;
+        for (FaceIdxArray::const_iterator it = fidx[i].begin(), end = fidx[i].end();
+                it != end; ++it, ++faces) {
+            Mesh &curMesh = meshes[(*it).first];
+            Face &face = curMesh.faces[(*it).second];
+            faces->mNumIndices = (unsigned int)face.indices.size();
+            faces->mIndices = new unsigned int[faces->mNumIndices];
+
+            aiVector3D faceNormal;
+            bool fnOK = false;
+
+            for (unsigned int n = 0; n < faces->mNumIndices; ++n, ++cnt, ++norms, ++verts) {
+                if (face.indices[n] >= curMesh.verts.size()) {
+                    ASSIMP_LOG_WARN("Quick3D: Vertex index overflow");
+                    face.indices[n] = 0;
+                }
+
+                // copy vertices
+                *verts = curMesh.verts[face.indices[n]];
+
+                if (face.indices[n] >= curMesh.normals.size() && faces->mNumIndices >= 3) {
+                    // we have no normal here - assign the face normal
+                    if (!fnOK) {
+                        const aiVector3D &pV1 = curMesh.verts[face.indices[0]];
+                        const aiVector3D &pV2 = curMesh.verts[face.indices[1]];
+                        const aiVector3D &pV3 = curMesh.verts[face.indices.size() - 1];
+                        faceNormal = (pV2 - pV1) ^ (pV3 - pV1).Normalize();
+                        fnOK = true;
+                    }
+                    *norms = faceNormal;
+                } else {
+                    *norms = curMesh.normals[face.indices[n]];
+                }
+
+                // copy texture coordinates
+                if (uv && curMesh.uv.size()) {
+                    if (curMesh.prevUVIdx != 0xffffffff && curMesh.uv.size() >= curMesh.verts.size()) // workaround
+                    {
+                        *uv = curMesh.uv[face.indices[n]];
+                    } else {
+                        if (face.uvindices[n] >= curMesh.uv.size()) {
+                            ASSIMP_LOG_WARN("Quick3D: Texture coordinate index overflow");
+                            face.uvindices[n] = 0;
+                        }
+                        *uv = curMesh.uv[face.uvindices[n]];
+                    }
+                    uv->y = 1.f - uv->y;
+                    ++uv;
+                }
+
+                // setup the new vertex index
+                faces->mIndices[n] = cnt;
+            }
+        }
+        ++real;
+    }
+
+    // Delete our nice helper array
+    delete[] fidx;
+
+    // Now we need to attach the meshes to the root node of the scene
+    pScene->mRootNode->mNumMeshes = pScene->mNumMeshes;
+    pScene->mRootNode->mMeshes = new unsigned int[pScene->mNumMeshes];
+    for (unsigned int i = 0; i < pScene->mNumMeshes; ++i)
+        pScene->mRootNode->mMeshes[i] = i;
+
+    /*pScene->mRootNode->mTransformation *= aiMatrix4x4(
+        1.f, 0.f, 0.f, 0.f,
+        0.f, -1.f,0.f, 0.f,
+        0.f, 0.f, 1.f, 0.f,
+        0.f, 0.f, 0.f, 1.f);*/
+
+    // Add cameras and light sources to the scene root node
+    pScene->mRootNode->mNumChildren = pScene->mNumLights + pScene->mNumCameras;
+    if (pScene->mRootNode->mNumChildren) {
+        pScene->mRootNode->mChildren = new aiNode *[pScene->mRootNode->mNumChildren];
+
+        // the light source
+        aiNode *nd = pScene->mRootNode->mChildren[0] = new aiNode();
+        nd->mParent = pScene->mRootNode;
+        nd->mName.Set("Q3DLight");
+        nd->mTransformation = pScene->mRootNode->mTransformation;
+        nd->mTransformation.Inverse();
+
+        // camera
+        nd = pScene->mRootNode->mChildren[1] = new aiNode();
+        nd->mParent = pScene->mRootNode;
+        nd->mName.Set("Q3DCamera");
+        nd->mTransformation = pScene->mRootNode->mChildren[0]->mTransformation;
+    }
+}
+
+#endif // !! ASSIMP_BUILD_NO_Q3D_IMPORTER
diff --git a/Engine/lib/assimp/code/Q3D/Q3DLoader.h b/Engine/lib/assimp/code/AssetLib/Q3D/Q3DLoader.h
similarity index 84%
rename from Engine/lib/assimp/code/Q3D/Q3DLoader.h
rename to Engine/lib/assimp/code/AssetLib/Q3D/Q3DLoader.h
index 954d3105c..54af86dc2 100644
--- a/Engine/lib/assimp/code/Q3D/Q3DLoader.h
+++ b/Engine/lib/assimp/code/AssetLib/Q3D/Q3DLoader.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -36,80 +35,66 @@ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
 ----------------------------------------------------------------------
 */
 
 /** @file  Q3DLoader.h
  *  @brief Declaration of the Q3D importer class.
  */
+#pragma once
 #ifndef AI_Q3DLOADER_H_INCLUDED
 #define AI_Q3DLOADER_H_INCLUDED
 
 #include <assimp/BaseImporter.h>
 #include <assimp/types.h>
 #include <vector>
-#include <stdint.h>
+#include <cstdint>
 
 namespace Assimp    {
 
 // ---------------------------------------------------------------------------
 /** Importer class for the Quick3D Object and Scene formats.
 */
-class Q3DImporter : public BaseImporter
-{
+class Q3DImporter : public BaseImporter {
 public:
     Q3DImporter();
-    ~Q3DImporter();
-
-
-public:
+    ~Q3DImporter() override;
 
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
     * See BaseImporter::CanRead() for details.  */
     bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
+        bool checkSig) const override;
 
 protected:
-
     // -------------------------------------------------------------------
     /** Return importer meta information.
      * See #BaseImporter::GetInfo for the details
      */
-    const aiImporterDesc* GetInfo () const;
+    const aiImporterDesc* GetInfo () const override;
 
     // -------------------------------------------------------------------
     /** Imports the given file into the given scene structure.
     * See BaseImporter::InternReadFile() for details
     */
     void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
+        IOSystem* pIOHandler) override;
 
 private:
-
-    struct Material
-    {
-        Material()
-            :   diffuse         (0.6f,0.6f,0.6f)
-            ,   transparency    (0.f)
-            ,   texIdx          (UINT_MAX)
-        {}
+    struct Material {
+        Material() : diffuse(0.6f,0.6f,0.6f), transparency(0.f), texIdx(UINT_MAX) {
+            // empty
+        }
 
         aiString name;
         aiColor3D ambient, diffuse, specular;
         float transparency;
-
         unsigned int texIdx;
     };
 
-    struct Face
-    {
-        explicit Face(unsigned int s)
-            :   indices   (s)
-            ,   uvindices (s)
-            ,   mat       (0)
-        {
+    struct Face {
+        explicit Face(unsigned int s) : indices(s), uvindices(s), mat(0) {
+            // empty
         }
 
         std::vector<unsigned int> indices;
@@ -117,14 +102,11 @@ private:
         unsigned int mat;
     };
 
-    struct Mesh
-    {
-
+    struct Mesh {
         std::vector<aiVector3D> verts;
         std::vector<aiVector3D> normals;
         std::vector<aiVector3D> uv;
         std::vector<Face>       faces;
-
         uint32_t prevUVIdx;
     };
 };
diff --git a/Engine/lib/assimp/code/Raw/RawLoader.cpp b/Engine/lib/assimp/code/AssetLib/Raw/RawLoader.cpp
similarity index 56%
rename from Engine/lib/assimp/code/Raw/RawLoader.cpp
rename to Engine/lib/assimp/code/AssetLib/Raw/RawLoader.cpp
index d0da247e4..bfd2e6d6e 100644
--- a/Engine/lib/assimp/code/Raw/RawLoader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/Raw/RawLoader.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -45,18 +43,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Implementation of the RAW importer class
  */
 
-
 #ifndef ASSIMP_BUILD_NO_RAW_IMPORTER
 
 // internal headers
 #include "RawLoader.h"
 #include <assimp/ParsingUtils.h>
 #include <assimp/fast_atof.h>
-#include <memory>
-#include <assimp/IOSystem.hpp>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/scene.h>
 #include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOSystem.hpp>
+#include <memory>
 
 using namespace Assimp;
 
@@ -75,146 +72,129 @@ static const aiImporterDesc desc = {
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-RAWImporter::RAWImporter()
-{}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-RAWImporter::~RAWImporter()
-{}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the class can handle the format of the given file.
-bool RAWImporter::CanRead( const std::string& pFile, IOSystem* /*pIOHandler*/, bool /*checkSig*/) const
-{
-    return SimpleExtensionCheck(pFile,"raw");
+RAWImporter::RAWImporter() {
+    // empty
 }
 
 // ------------------------------------------------------------------------------------------------
-const aiImporterDesc* RAWImporter::GetInfo () const
-{
+// Destructor, private as well
+RAWImporter::~RAWImporter() {
+    // empty
+}
+
+// ------------------------------------------------------------------------------------------------
+// Returns whether the class can handle the format of the given file.
+bool RAWImporter::CanRead(const std::string &filename, IOSystem * /*pIOHandler*/, bool /*checkSig*/) const {
+    return SimpleExtensionCheck(filename, "raw");
+}
+
+// ------------------------------------------------------------------------------------------------
+const aiImporterDesc *RAWImporter::GetInfo() const {
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void RAWImporter::InternReadFile( const std::string& pFile,
-    aiScene* pScene, IOSystem* pIOHandler)
-{
-    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));
+void RAWImporter::InternReadFile(const std::string &pFile,
+        aiScene *pScene, IOSystem *pIOHandler) {
+    std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));
 
     // Check whether we can read from the file
-    if( file.get() == NULL) {
-        throw DeadlyImportError( "Failed to open RAW file " + pFile + ".");
+    if (file.get() == nullptr) {
+        throw DeadlyImportError("Failed to open RAW file ", pFile, ".");
     }
 
     // allocate storage and copy the contents of the file to a memory buffer
     // (terminate it with zero)
     std::vector<char> mBuffer2;
-    TextFileToBuffer(file.get(),mBuffer2);
-    const char* buffer = &mBuffer2[0];
+    TextFileToBuffer(file.get(), mBuffer2);
+    const char *buffer = &mBuffer2[0];
 
     // list of groups loaded from the file
-    std::vector< GroupInformation > outGroups(1,GroupInformation("<default>"));
-    std::vector< GroupInformation >::iterator curGroup = outGroups.begin();
+    std::vector<GroupInformation> outGroups(1, GroupInformation("<default>"));
+    std::vector<GroupInformation>::iterator curGroup = outGroups.begin();
 
     // now read all lines
     char line[4096];
-    while (GetNextLine(buffer,line))
-    {
+    while (GetNextLine(buffer, line)) {
         // if the line starts with a non-numeric identifier, it marks
         // the beginning of a new group
-        const char* sz = line;SkipSpaces(&sz);
-        if (IsLineEnd(*sz))continue;
-        if (!IsNumeric(*sz))
-        {
-            const char* sz2 = sz;
-            while (!IsSpaceOrNewLine(*sz2))++sz2;
-            const unsigned int length = (unsigned int)(sz2-sz);
+        const char *sz = line;
+        SkipSpaces(&sz);
+        if (IsLineEnd(*sz)) continue;
+        if (!IsNumeric(*sz)) {
+            const char *sz2 = sz;
+            while (!IsSpaceOrNewLine(*sz2))
+                ++sz2;
+            const unsigned int length = (unsigned int)(sz2 - sz);
 
             // find an existing group with this name
-            for (std::vector< GroupInformation >::iterator it = outGroups.begin(), end = outGroups.end();
-                it != end;++it)
-            {
-                if (length == (*it).name.length() && !::strcmp(sz,(*it).name.c_str()))
-                {
-                    curGroup = it;sz2 = NULL;
+            for (std::vector<GroupInformation>::iterator it = outGroups.begin(), end = outGroups.end();
+                    it != end; ++it) {
+                if (length == (*it).name.length() && !::strcmp(sz, (*it).name.c_str())) {
+                    curGroup = it;
+                    sz2 = nullptr;
                     break;
                 }
             }
-            if (sz2)
-            {
-                outGroups.push_back(GroupInformation(std::string(sz,length)));
-                curGroup = outGroups.end()-1;
+            if (sz2) {
+                outGroups.push_back(GroupInformation(std::string(sz, length)));
+                curGroup = outGroups.end() - 1;
             }
-        }
-        else
-        {
+        } else {
             // there can be maximally 12 floats plus an extra texture file name
             float data[12];
             unsigned int num;
-            for (num = 0; num < 12;++num)
-            {
-                if(!SkipSpaces(&sz) || !IsNumeric(*sz))break;
-                sz = fast_atoreal_move<float>(sz,data[num]);
+            for (num = 0; num < 12; ++num) {
+                if (!SkipSpaces(&sz) || !IsNumeric(*sz)) break;
+                sz = fast_atoreal_move<float>(sz, data[num]);
             }
-            if (num != 12 && num != 9)
-            {
+            if (num != 12 && num != 9) {
                 ASSIMP_LOG_ERROR("A line may have either 9 or 12 floats and an optional texture");
                 continue;
             }
 
-            MeshInformation* output = NULL;
+            MeshInformation *output = nullptr;
 
-            const char* sz2 = sz;
+            const char *sz2 = sz;
             unsigned int length;
-            if (!IsLineEnd(*sz))
-            {
-                while (!IsSpaceOrNewLine(*sz2))++sz2;
-                length = (unsigned int)(sz2-sz);
-            }
-            else if (9 == num)
-            {
+            if (!IsLineEnd(*sz)) {
+                while (!IsSpaceOrNewLine(*sz2))
+                    ++sz2;
+                length = (unsigned int)(sz2 - sz);
+            } else if (9 == num) {
                 sz = "%default%";
                 length = 9;
-            }
-            else
-            {
+            } else {
                 sz = "";
                 length = 0;
             }
 
             // search in the list of meshes whether we have one with this texture
-            for (auto &mesh : (*curGroup).meshes)
-            {
-                if (length == mesh.name.length() && (length ? !::strcmp(sz, mesh.name.c_str()) : true))
-                {
+            for (auto &mesh : (*curGroup).meshes) {
+                if (length == mesh.name.length() && (length ? !::strcmp(sz, mesh.name.c_str()) : true)) {
                     output = &mesh;
                     break;
                 }
             }
             // if we don't have the mesh, create it
-            if (!output)
-            {
-                (*curGroup).meshes.push_back(MeshInformation(std::string(sz,length)));
+            if (!output) {
+                (*curGroup).meshes.push_back(MeshInformation(std::string(sz, length)));
                 output = &((*curGroup).meshes.back());
             }
-            if (12 == num)
-            {
-                aiColor4D v(data[0],data[1],data[2],1.0f);
+            if (12 == num) {
+                aiColor4D v(data[0], data[1], data[2], 1.0f);
                 output->colors.push_back(v);
                 output->colors.push_back(v);
                 output->colors.push_back(v);
 
-                output->vertices.push_back(aiVector3D(data[3],data[4],data[5]));
-                output->vertices.push_back(aiVector3D(data[6],data[7],data[8]));
-                output->vertices.push_back(aiVector3D(data[9],data[10],data[11]));
-            }
-            else
-            {
-                output->vertices.push_back(aiVector3D(data[0],data[1],data[2]));
-                output->vertices.push_back(aiVector3D(data[3],data[4],data[5]));
-                output->vertices.push_back(aiVector3D(data[6],data[7],data[8]));
+                output->vertices.push_back(aiVector3D(data[3], data[4], data[5]));
+                output->vertices.push_back(aiVector3D(data[6], data[7], data[8]));
+                output->vertices.push_back(aiVector3D(data[9], data[10], data[11]));
+            } else {
+                output->vertices.push_back(aiVector3D(data[0], data[1], data[2]));
+                output->vertices.push_back(aiVector3D(data[3], data[4], data[5]));
+                output->vertices.push_back(aiVector3D(data[6], data[7], data[8]));
             }
         }
     }
@@ -224,105 +204,96 @@ void RAWImporter::InternReadFile( const std::string& pFile,
 
     // count the number of valid groups
     // (meshes can't be empty)
-    for (auto & outGroup : outGroups)
-    {
-        if (!outGroup.meshes.empty())
-        {
+    for (auto &outGroup : outGroups) {
+        if (!outGroup.meshes.empty()) {
             ++pScene->mRootNode->mNumChildren;
-            pScene->mNumMeshes += (unsigned int) outGroup.meshes.size();
+            pScene->mNumMeshes += (unsigned int)outGroup.meshes.size();
         }
     }
 
-    if (!pScene->mNumMeshes)
-    {
+    if (!pScene->mNumMeshes) {
         throw DeadlyImportError("RAW: No meshes loaded. The file seems to be corrupt or empty.");
     }
 
-    pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];
-    aiNode** cc;
-    if (1 == pScene->mRootNode->mNumChildren)
-    {
+    pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
+    aiNode **cc;
+    if (1 == pScene->mRootNode->mNumChildren) {
         cc = &pScene->mRootNode;
         pScene->mRootNode->mNumChildren = 0;
     } else {
-        cc = new aiNode*[pScene->mRootNode->mNumChildren];
-        memset(cc, 0, sizeof(aiNode*) * pScene->mRootNode->mNumChildren);
+        cc = new aiNode *[pScene->mRootNode->mNumChildren];
+        memset(cc, 0, sizeof(aiNode *) * pScene->mRootNode->mNumChildren);
         pScene->mRootNode->mChildren = cc;
     }
 
     pScene->mNumMaterials = pScene->mNumMeshes;
-    aiMaterial** mats = pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials];
+    aiMaterial **mats = pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials];
 
     unsigned int meshIdx = 0;
-    for (auto & outGroup : outGroups)
-    {
-        if (outGroup.meshes.empty())continue;
+    for (auto &outGroup : outGroups) {
+        if (outGroup.meshes.empty()) continue;
 
-        aiNode* node;
-        if (pScene->mRootNode->mNumChildren)
-        {
+        aiNode *node;
+        if (pScene->mRootNode->mNumChildren) {
             node = *cc = new aiNode();
             node->mParent = pScene->mRootNode;
-        }
-        else node = *cc;
+        } else
+            node = *cc;
         node->mName.Set(outGroup.name);
 
         // add all meshes
-        node->mNumMeshes = (unsigned int) outGroup.meshes.size();
-        unsigned int* pi = node->mMeshes = new unsigned int[ node->mNumMeshes ];
-        for (std::vector< MeshInformation >::iterator it2 = outGroup.meshes.begin(),
-            end2 = outGroup.meshes.end(); it2 != end2; ++it2)
-        {
+        node->mNumMeshes = (unsigned int)outGroup.meshes.size();
+        unsigned int *pi = node->mMeshes = new unsigned int[node->mNumMeshes];
+        for (std::vector<MeshInformation>::iterator it2 = outGroup.meshes.begin(),
+                                                    end2 = outGroup.meshes.end();
+                it2 != end2; ++it2) {
             ai_assert(!(*it2).vertices.empty());
 
             // allocate the mesh
             *pi++ = meshIdx;
-            aiMesh* mesh = pScene->mMeshes[meshIdx] = new aiMesh();
+            aiMesh *mesh = pScene->mMeshes[meshIdx] = new aiMesh();
             mesh->mMaterialIndex = meshIdx++;
 
             mesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
 
             // allocate storage for the vertex components and copy them
             mesh->mNumVertices = (unsigned int)(*it2).vertices.size();
-            mesh->mVertices = new aiVector3D[ mesh->mNumVertices ];
-            ::memcpy(mesh->mVertices,&(*it2).vertices[0],sizeof(aiVector3D)*mesh->mNumVertices);
+            mesh->mVertices = new aiVector3D[mesh->mNumVertices];
+            ::memcpy(mesh->mVertices, &(*it2).vertices[0], sizeof(aiVector3D) * mesh->mNumVertices);
 
-            if ((*it2).colors.size())
-            {
+            if ((*it2).colors.size()) {
                 ai_assert((*it2).colors.size() == mesh->mNumVertices);
 
-                mesh->mColors[0] = new aiColor4D[ mesh->mNumVertices ];
-                ::memcpy(mesh->mColors[0],&(*it2).colors[0],sizeof(aiColor4D)*mesh->mNumVertices);
+                mesh->mColors[0] = new aiColor4D[mesh->mNumVertices];
+                ::memcpy(mesh->mColors[0], &(*it2).colors[0], sizeof(aiColor4D) * mesh->mNumVertices);
             }
 
             // generate triangles
             ai_assert(0 == mesh->mNumVertices % 3);
-            aiFace* fc = mesh->mFaces = new aiFace[ mesh->mNumFaces = mesh->mNumVertices/3 ];
-            aiFace* const fcEnd = fc + mesh->mNumFaces;
+            aiFace *fc = mesh->mFaces = new aiFace[mesh->mNumFaces = mesh->mNumVertices / 3];
+            aiFace *const fcEnd = fc + mesh->mNumFaces;
             unsigned int n = 0;
-            while (fc != fcEnd)
-            {
-                aiFace& f = *fc++;
+            while (fc != fcEnd) {
+                aiFace &f = *fc++;
                 f.mIndices = new unsigned int[f.mNumIndices = 3];
-                for (unsigned int m = 0; m < 3;++m)
+                for (unsigned int m = 0; m < 3; ++m)
                     f.mIndices[m] = n++;
             }
 
             // generate a material for the mesh
-            aiMaterial* mat = new aiMaterial();
+            aiMaterial *mat = new aiMaterial();
 
-            aiColor4D clr(1.0f,1.0f,1.0f,1.0f);
+            aiColor4D clr(1.0f, 1.0f, 1.0f, 1.0f);
             if ("%default%" == (*it2).name) // a gray default material
             {
                 clr.r = clr.g = clr.b = 0.6f;
-            }
-            else if ((*it2).name.length() > 0) // a texture
+            } else if ((*it2).name.length() > 0) // a texture
             {
                 aiString s;
                 s.Set((*it2).name);
-                mat->AddProperty(&s,AI_MATKEY_TEXTURE_DIFFUSE(0));
+                mat->AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(0));
             }
-            mat->AddProperty<aiColor4D>(&clr,1,AI_MATKEY_COLOR_DIFFUSE);
+            mat->AddProperty<aiColor4D>(&clr, 1, AI_MATKEY_COLOR_DIFFUSE);
             *mats++ = mat;
         }
     }
diff --git a/Engine/lib/assimp/code/Raw/RawLoader.h b/Engine/lib/assimp/code/AssetLib/Raw/RawLoader.h
similarity index 87%
rename from Engine/lib/assimp/code/Raw/RawLoader.h
rename to Engine/lib/assimp/code/AssetLib/Raw/RawLoader.h
index 8bfe8ef98..6e4c4d110 100644
--- a/Engine/lib/assimp/code/Raw/RawLoader.h
+++ b/Engine/lib/assimp/code/AssetLib/Raw/RawLoader.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,6 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file  RAWLoader.h
  *  @brief Declaration of the RAW importer class.
  */
+#pragma once
 #ifndef AI_RAWLOADER_H_INCLUDED
 #define AI_RAWLOADER_H_INCLUDED
 
@@ -50,64 +50,51 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/types.h>
 #include <vector>
 
-namespace Assimp    {
+namespace Assimp {
 
 // ---------------------------------------------------------------------------
 /** Importer class for the PovRay RAW triangle format
 */
-class RAWImporter : public BaseImporter
-{
+class RAWImporter : public BaseImporter {
 public:
     RAWImporter();
     ~RAWImporter();
 
-
-public:
-
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
      * See BaseImporter::CanRead() for details.
      */
     bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
+        bool checkSig) const override;
 
 protected:
-
     // -------------------------------------------------------------------
     /** Return importer meta information.
      * See #BaseImporter::GetInfo for the details
      */
-    const aiImporterDesc* GetInfo () const;
+    const aiImporterDesc* GetInfo () const override;
 
     // -------------------------------------------------------------------
     /** Imports the given file into the given scene structure.
     * See BaseImporter::InternReadFile() for details
     */
     void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
+        IOSystem* pIOHandler) override;
 
 private:
-
-    struct MeshInformation
-    {
-        explicit MeshInformation(const std::string& _name)
-            : name(_name)
-        {
+    struct MeshInformation {
+        explicit MeshInformation(const std::string& _name) : name(_name) {
             vertices.reserve(100);
             colors.reserve(100);
         }
 
         std::string name;
-
         std::vector<aiVector3D> vertices;
         std::vector<aiColor4D> colors;
     };
 
-    struct GroupInformation
-    {
-        explicit GroupInformation(const std::string& _name)
-            : name(_name)
-        {
+    struct GroupInformation {
+        explicit GroupInformation(const std::string& _name) : name(_name) {
             meshes.reserve(10);
         }
 
diff --git a/Engine/lib/assimp/code/SIB/SIBImporter.cpp b/Engine/lib/assimp/code/AssetLib/SIB/SIBImporter.cpp
similarity index 70%
rename from Engine/lib/assimp/code/SIB/SIBImporter.cpp
rename to Engine/lib/assimp/code/AssetLib/SIB/SIBImporter.cpp
index 20cdc8009..7b66afa44 100644
--- a/Engine/lib/assimp/code/SIB/SIBImporter.cpp
+++ b/Engine/lib/assimp/code/AssetLib/SIB/SIBImporter.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -51,7 +49,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  Nevertheless, this implementation is reasonably complete.
  */
 
-
 #ifndef ASSIMP_BUILD_NO_SIB_IMPORTER
 
 // internal headers
@@ -60,15 +57,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/StreamReader.h>
 #include <assimp/TinyFormatter.h>
 #ifdef ASSIMP_USE_HUNTER
-#  include <utf8/utf8.h>
+#include <utf8.h>
 #else
-//#  include "../contrib/ConvertUTF/ConvertUTF.h"
-#  include "../contrib/utf8cpp/source/utf8.h"
+#include "../contrib/utf8cpp/source/utf8.h"
 #endif
-#include <assimp/IOSystem.hpp>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/scene.h>
 #include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOSystem.hpp>
+#include <assimp/StringUtils.h>
 
 #include <map>
 
@@ -86,14 +83,14 @@ static const aiImporterDesc desc = {
 };
 
 struct SIBChunk {
-    uint32_t    Tag;
-    uint32_t    Size;
+    uint32_t Tag;
+    uint32_t Size;
 } PACK_STRUCT;
 
-enum { 
-    POS, 
-    NRM, 
-    UV,    
+enum {
+    POS,
+    NRM,
+    UV,
     N
 };
 
@@ -122,14 +119,14 @@ struct SIBObject {
 };
 
 struct SIB {
-    std::vector<aiMaterial*> mtls;
-    std::vector<aiMesh*> meshes;
-    std::vector<aiLight*> lights;
+    std::vector<aiMaterial *> mtls;
+    std::vector<aiMesh *> meshes;
+    std::vector<aiLight *> lights;
     std::vector<SIBObject> objs, insts;
 };
 
 // ------------------------------------------------------------------------------------------------
-static SIBEdge& GetEdge(SIBMesh* mesh, uint32_t posA, uint32_t posB) {
+static SIBEdge &GetEdge(SIBMesh *mesh, uint32_t posA, uint32_t posB) {
     SIBPair pair = (posA < posB) ? SIBPair(posA, posB) : SIBPair(posB, posA);
     std::map<SIBPair, uint32_t>::iterator it = mesh->edgeMap.find(pair);
     if (it != mesh->edgeMap.end())
@@ -146,10 +143,9 @@ static SIBEdge& GetEdge(SIBMesh* mesh, uint32_t posA, uint32_t posB) {
 // ------------------------------------------------------------------------------------------------
 // Helpers for reading chunked data.
 
-#define TAG(A,B,C,D) ((A << 24) | (B << 16) | (C << 8) | D)
+#define TAG(A, B, C, D) ((A << 24) | (B << 16) | (C << 8) | D)
 
-static SIBChunk ReadChunk(StreamReaderLE* stream)
-{
+static SIBChunk ReadChunk(StreamReaderLE *stream) {
     SIBChunk chunk;
     chunk.Tag = stream->GetU4();
     chunk.Size = stream->GetU4();
@@ -159,8 +155,7 @@ static SIBChunk ReadChunk(StreamReaderLE* stream)
     return chunk;
 }
 
-static aiColor3D ReadColor(StreamReaderLE* stream)
-{
+static aiColor3D ReadColor(StreamReaderLE *stream) {
     float r = stream->GetF4();
     float g = stream->GetF4();
     float b = stream->GetF4();
@@ -168,37 +163,35 @@ static aiColor3D ReadColor(StreamReaderLE* stream)
     return aiColor3D(r, g, b);
 }
 
-static void UnknownChunk(StreamReaderLE* /*stream*/, const SIBChunk& chunk)
-{
-    char temp[5] = {
-        static_cast<char>(( chunk.Tag>>24 ) & 0xff),
-        static_cast<char>(( chunk.Tag>>16 ) & 0xff),
-        static_cast<char>(( chunk.Tag>>8 ) & 0xff),
-        static_cast<char>(chunk.Tag & 0xff), '\0'
+static void UnknownChunk(StreamReaderLE * /*stream*/, const SIBChunk &chunk) {
+    char temp[4] = {
+        static_cast<char>((chunk.Tag >> 24) & 0xff),
+        static_cast<char>((chunk.Tag >> 16) & 0xff),
+        static_cast<char>((chunk.Tag >> 8) & 0xff),
+        static_cast<char>(chunk.Tag & 0xff)
     };
 
-    ASSIMP_LOG_WARN((Formatter::format(), "SIB: Skipping unknown '",temp,"' chunk."));
+    ASSIMP_LOG_WARN("SIB: Skipping unknown '", ai_str_toprintable(temp, 4), "' chunk.");
 }
 
 // Reads a UTF-16LE string and returns it at UTF-8.
 static aiString ReadString(StreamReaderLE *stream, uint32_t numWChars) {
-    if ( nullptr == stream || 0 == numWChars ) {
-        static const aiString empty;
-        return empty;
+    if (nullptr == stream || 0 == numWChars) {
+        return aiString();
     }
 
     // Allocate buffers (max expansion is 1 byte -> 4 bytes for UTF-8)
     std::vector<unsigned char> str;
-    str.reserve( numWChars * 4 + 1 );
-    uint16_t *temp = new uint16_t[ numWChars ];
-    for ( uint32_t n = 0; n < numWChars; ++n ) {
-        temp[ n ] = stream->GetU2();
+    str.reserve(numWChars * 4 + 1);
+    uint16_t *temp = new uint16_t[numWChars];
+    for (uint32_t n = 0; n < numWChars; ++n) {
+        temp[n] = stream->GetU2();
     }
 
     // Convert it and NUL-terminate.
-    const uint16_t *start( temp ), *end( temp + numWChars );
-    utf8::utf16to8( start, end, back_inserter( str ) );
-    str[ str.size() - 1 ] = '\0';
+    const uint16_t *start(temp), *end(temp + numWChars);
+    utf8::utf16to8(start, end, back_inserter(str));
+    str[str.size() - 1] = '\0';
 
     // Return the final string.
     aiString result = aiString((const char *)&str[0]);
@@ -221,52 +214,49 @@ SIBImporter::~SIBImporter() {
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool SIBImporter::CanRead( const std::string& pFile, IOSystem* /*pIOHandler*/, bool /*checkSig*/) const {
-    return SimpleExtensionCheck(pFile, "sib");
+bool SIBImporter::CanRead(const std::string &filename, IOSystem * /*pIOHandler*/, bool /*checkSig*/) const {
+    return SimpleExtensionCheck(filename, "sib");
 }
 
 // ------------------------------------------------------------------------------------------------
-const aiImporterDesc* SIBImporter::GetInfo () const {
+const aiImporterDesc *SIBImporter::GetInfo() const {
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
-static void ReadVerts(SIBMesh* mesh, StreamReaderLE* stream, uint32_t count) {
-    if ( nullptr == mesh || nullptr == stream ) {
+static void ReadVerts(SIBMesh *mesh, StreamReaderLE *stream, uint32_t count) {
+    if (nullptr == mesh || nullptr == stream) {
         return;
     }
 
     mesh->pos.resize(count);
-    for ( uint32_t n=0; n<count; ++n ) {
-        mesh->pos[ n ].x = stream->GetF4();
-        mesh->pos[ n ].y = stream->GetF4();
-        mesh->pos[ n ].z = stream->GetF4();
+    for (uint32_t n = 0; n < count; ++n) {
+        mesh->pos[n].x = stream->GetF4();
+        mesh->pos[n].y = stream->GetF4();
+        mesh->pos[n].z = stream->GetF4();
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-static void ReadFaces(SIBMesh* mesh, StreamReaderLE* stream)
-{
+static void ReadFaces(SIBMesh *mesh, StreamReaderLE *stream) {
     uint32_t ptIdx = 0;
-    while (stream->GetRemainingSizeToLimit() > 0)
-    {
+    while (stream->GetRemainingSizeToLimit() > 0) {
         uint32_t numPoints = stream->GetU4();
 
         // Store room for the N index channels, plus the point count.
         size_t pos = mesh->idx.size() + 1;
-        mesh->idx.resize(pos + numPoints*N);
-        mesh->idx[pos-1] = numPoints;
+        mesh->idx.resize(pos + numPoints * N);
+        mesh->idx[pos - 1] = numPoints;
         uint32_t *idx = &mesh->idx[pos];
 
-        mesh->faceStart.push_back(static_cast<uint32_t>(pos-1));
+        mesh->faceStart.push_back(static_cast<uint32_t>(pos - 1));
         mesh->mtls.push_back(0);
 
         // Read all the position data.
         // UV/normals will be supplied later.
         // Positions are supplied indexed already, so we preserve that
         // mapping. UVs are supplied uniquely, so we allocate unique indices.
-        for (uint32_t n=0;n<numPoints;n++,idx+=N,ptIdx++)
-        {
+        for (uint32_t n = 0; n < numPoints; n++, idx += N, ptIdx++) {
             uint32_t p = stream->GetU4();
             if (p >= mesh->pos.size())
                 throw DeadlyImportError("Vertex index is out of range.");
@@ -277,17 +267,15 @@ static void ReadFaces(SIBMesh* mesh, StreamReaderLE* stream)
     }
 
     // Allocate data channels for normals/UVs.
-    mesh->nrm.resize(ptIdx, aiVector3D(0,0,0));
-    mesh->uv.resize(ptIdx, aiVector3D(0,0,0));
+    mesh->nrm.resize(ptIdx, aiVector3D(0, 0, 0));
+    mesh->uv.resize(ptIdx, aiVector3D(0, 0, 0));
 
     mesh->numPts = ptIdx;
 }
 
 // ------------------------------------------------------------------------------------------------
-static void ReadUVs(SIBMesh* mesh, StreamReaderLE* stream)
-{
-    while (stream->GetRemainingSizeToLimit() > 0)
-    {
+static void ReadUVs(SIBMesh *mesh, StreamReaderLE *stream) {
+    while (stream->GetRemainingSizeToLimit() > 0) {
         uint32_t faceIdx = stream->GetU4();
         uint32_t numPoints = stream->GetU4();
 
@@ -297,8 +285,7 @@ static void ReadUVs(SIBMesh* mesh, StreamReaderLE* stream)
         uint32_t pos = mesh->faceStart[faceIdx];
         uint32_t *idx = &mesh->idx[pos + 1];
 
-        for (uint32_t n=0;n<numPoints;n++,idx+=N)
-        {
+        for (uint32_t n = 0; n < numPoints; n++, idx += N) {
             uint32_t id = idx[UV];
             mesh->uv[id].x = stream->GetF4();
             mesh->uv[id].y = stream->GetF4();
@@ -307,19 +294,16 @@ static void ReadUVs(SIBMesh* mesh, StreamReaderLE* stream)
 }
 
 // ------------------------------------------------------------------------------------------------
-static void ReadMtls(SIBMesh* mesh, StreamReaderLE* stream)
-{
+static void ReadMtls(SIBMesh *mesh, StreamReaderLE *stream) {
     // Material assignments are stored run-length encoded.
     // Also, we add 1 to each material so that we can use mtl #0
     // as the default material.
     uint32_t prevFace = stream->GetU4();
     uint32_t prevMtl = stream->GetU4() + 1;
-    while (stream->GetRemainingSizeToLimit() > 0)
-    {
+    while (stream->GetRemainingSizeToLimit() > 0) {
         uint32_t face = stream->GetU4();
         uint32_t mtl = stream->GetU4() + 1;
-        while (prevFace < face)
-        {
+        while (prevFace < face) {
             if (prevFace >= mesh->mtls.size())
                 throw DeadlyImportError("Invalid face index.");
             mesh->mtls[prevFace++] = prevMtl;
@@ -334,8 +318,7 @@ static void ReadMtls(SIBMesh* mesh, StreamReaderLE* stream)
 }
 
 // ------------------------------------------------------------------------------------------------
-static void ReadAxis(aiMatrix4x4& axis, StreamReaderLE* stream)
-{
+static void ReadAxis(aiMatrix4x4 &axis, StreamReaderLE *stream) {
     axis.a4 = stream->GetF4();
     axis.b4 = stream->GetF4();
     axis.c4 = stream->GetF4();
@@ -355,10 +338,8 @@ static void ReadAxis(aiMatrix4x4& axis, StreamReaderLE* stream)
 }
 
 // ------------------------------------------------------------------------------------------------
-static void ReadEdges(SIBMesh* mesh, StreamReaderLE* stream)
-{
-    while (stream->GetRemainingSizeToLimit() > 0)
-    {
+static void ReadEdges(SIBMesh *mesh, StreamReaderLE *stream) {
+    while (stream->GetRemainingSizeToLimit() > 0) {
         uint32_t posA = stream->GetU4();
         uint32_t posB = stream->GetU4();
         GetEdge(mesh, posA, posB);
@@ -366,10 +347,8 @@ static void ReadEdges(SIBMesh* mesh, StreamReaderLE* stream)
 }
 
 // ------------------------------------------------------------------------------------------------
-static void ReadCreases(SIBMesh* mesh, StreamReaderLE* stream)
-{
-    while (stream->GetRemainingSizeToLimit() > 0)
-    {
+static void ReadCreases(SIBMesh *mesh, StreamReaderLE *stream) {
+    while (stream->GetRemainingSizeToLimit() > 0) {
         uint32_t edge = stream->GetU4();
         if (edge >= mesh->edges.size())
             throw DeadlyImportError("SIB: Invalid edge index.");
@@ -378,22 +357,19 @@ static void ReadCreases(SIBMesh* mesh, StreamReaderLE* stream)
 }
 
 // ------------------------------------------------------------------------------------------------
-static void ConnectFaces(SIBMesh* mesh)
-{
+static void ConnectFaces(SIBMesh *mesh) {
     // Find faces connected to each edge.
     size_t numFaces = mesh->faceStart.size();
-    for (size_t faceIdx=0;faceIdx<numFaces;faceIdx++)
-    {
+    for (size_t faceIdx = 0; faceIdx < numFaces; faceIdx++) {
         uint32_t *idx = &mesh->idx[mesh->faceStart[faceIdx]];
         uint32_t numPoints = *idx++;
-        uint32_t prev = idx[(numPoints-1)*N+POS];
+        uint32_t prev = idx[(numPoints - 1) * N + POS];
 
-        for (uint32_t i=0;i<numPoints;i++,idx+=N)
-        {
+        for (uint32_t i = 0; i < numPoints; i++, idx += N) {
             uint32_t next = idx[POS];
 
             // Find this edge.
-            SIBEdge& edge = GetEdge(mesh, prev, next);
+            SIBEdge &edge = GetEdge(mesh, prev, next);
 
             // Link this face onto it.
             // This gives potentially undesirable normals when used
@@ -409,45 +385,39 @@ static void ConnectFaces(SIBMesh* mesh)
 }
 
 // ------------------------------------------------------------------------------------------------
-static aiVector3D CalculateVertexNormal(SIBMesh* mesh, uint32_t faceIdx, uint32_t pos,
-                                        const std::vector<aiVector3D>& faceNormals)
-{
+static aiVector3D CalculateVertexNormal(SIBMesh *mesh, uint32_t faceIdx, uint32_t pos,
+        const std::vector<aiVector3D> &faceNormals) {
     // Creased edges complicate this. We need to find the start/end range of the
     // ring of faces that touch this position.
     // We do this in two passes. The first pass is to find the end of the range,
     // the second is to work backwards to the start and calculate the final normal.
     aiVector3D vtxNormal;
-    for (int pass=0;pass<2;pass++)
-    {
+    for (int pass = 0; pass < 2; pass++) {
         vtxNormal = aiVector3D(0, 0, 0);
         uint32_t startFaceIdx = faceIdx;
         uint32_t prevFaceIdx = faceIdx;
 
         // Process each connected face.
-        while (true)
-        {
+        while (true) {
             // Accumulate the face normal.
             vtxNormal += faceNormals[faceIdx];
 
             uint32_t nextFaceIdx = 0xffffffff;
 
             // Move to the next edge sharing this position.
-            uint32_t* idx = &mesh->idx[mesh->faceStart[faceIdx]];
+            uint32_t *idx = &mesh->idx[mesh->faceStart[faceIdx]];
             uint32_t numPoints = *idx++;
-            uint32_t posA = idx[(numPoints-1)*N+POS];
-            for (uint32_t n=0;n<numPoints;n++,idx+=N)
-            {
+            uint32_t posA = idx[(numPoints - 1) * N + POS];
+            for (uint32_t n = 0; n < numPoints; n++, idx += N) {
                 uint32_t posB = idx[POS];
 
                 // Test if this edge shares our target position.
-                if (posA == pos || posB == pos)
-                {
-                    SIBEdge& edge = GetEdge(mesh, posA, posB);
+                if (posA == pos || posB == pos) {
+                    SIBEdge &edge = GetEdge(mesh, posA, posB);
 
                     // Non-manifold meshes can produce faces which share
                     // positions but have no edge entry, so check it.
-                    if (edge.faceA == faceIdx || edge.faceB == faceIdx)
-                    {
+                    if (edge.faceA == faceIdx || edge.faceB == faceIdx) {
                         // Move to whichever side we didn't just come from.
                         if (!edge.creased) {
                             if (edge.faceA != prevFaceIdx && edge.faceA != faceIdx && edge.faceA != 0xffffffff)
@@ -479,24 +449,21 @@ static aiVector3D CalculateVertexNormal(SIBMesh* mesh, uint32_t faceIdx, uint32_
 }
 
 // ------------------------------------------------------------------------------------------------
-static void CalculateNormals(SIBMesh* mesh)
-{
+static void CalculateNormals(SIBMesh *mesh) {
     size_t numFaces = mesh->faceStart.size();
 
     // Calculate face normals.
     std::vector<aiVector3D> faceNormals(numFaces);
-    for (size_t faceIdx=0;faceIdx<numFaces;faceIdx++)
-    {
-        uint32_t* idx = &mesh->idx[mesh->faceStart[faceIdx]];
+    for (size_t faceIdx = 0; faceIdx < numFaces; faceIdx++) {
+        uint32_t *idx = &mesh->idx[mesh->faceStart[faceIdx]];
         uint32_t numPoints = *idx++;
 
         aiVector3D faceNormal(0, 0, 0);
 
-        uint32_t *prev = &idx[(numPoints-1)*N];
+        uint32_t *prev = &idx[(numPoints - 1) * N];
 
-        for (uint32_t i=0;i<numPoints;i++)
-        {
-            uint32_t *next = &idx[i*N];
+        for (uint32_t i = 0; i < numPoints; i++) {
+            uint32_t *next = &idx[i * N];
 
             faceNormal += mesh->pos[prev[POS]] ^ mesh->pos[next[POS]];
             prev = next;
@@ -506,15 +473,13 @@ static void CalculateNormals(SIBMesh* mesh)
     }
 
     // Calculate vertex normals.
-    for (size_t faceIdx=0;faceIdx<numFaces;faceIdx++)
-    {
-        uint32_t* idx = &mesh->idx[mesh->faceStart[faceIdx]];
+    for (size_t faceIdx = 0; faceIdx < numFaces; faceIdx++) {
+        uint32_t *idx = &mesh->idx[mesh->faceStart[faceIdx]];
         uint32_t numPoints = *idx++;
 
-        for (uint32_t i=0;i<numPoints;i++)
-        {
-            uint32_t pos = idx[i*N+POS];
-            uint32_t nrm = idx[i*N+NRM];
+        for (uint32_t i = 0; i < numPoints; i++) {
+            uint32_t pos = idx[i * N + POS];
+            uint32_t nrm = idx[i * N + NRM];
             aiVector3D vtxNorm = CalculateVertexNormal(mesh, static_cast<uint32_t>(faceIdx), pos, faceNormals);
             mesh->nrm[nrm] = vtxNorm;
         }
@@ -522,43 +487,39 @@ static void CalculateNormals(SIBMesh* mesh)
 }
 
 // ------------------------------------------------------------------------------------------------
-struct TempMesh
-{
+struct TempMesh {
     std::vector<aiVector3D> vtx;
     std::vector<aiVector3D> nrm;
     std::vector<aiVector3D> uv;
-    std::vector<aiFace>     faces;
+    std::vector<aiFace> faces;
 };
 
-static void ReadShape(SIB* sib, StreamReaderLE* stream)
-{
+static void ReadShape(SIB *sib, StreamReaderLE *stream) {
     SIBMesh smesh;
     aiString name;
 
-    while (stream->GetRemainingSizeToLimit() >= sizeof(SIBChunk))
-    {
+    while (stream->GetRemainingSizeToLimit() >= sizeof(SIBChunk)) {
         SIBChunk chunk = ReadChunk(stream);
         unsigned oldLimit = stream->SetReadLimit(stream->GetCurrentPos() + chunk.Size);
 
-        switch (chunk.Tag)
-        {
-        case TAG('M','I','R','P'): break; // mirror plane maybe?
-        case TAG('I','M','R','P'): break; // instance mirror? (not supported here yet)
-        case TAG('D','I','N','F'): break; // display info, not needed
-        case TAG('P','I','N','F'): break; // ?
-        case TAG('V','M','I','R'): break; // ?
-        case TAG('F','M','I','R'): break; // ?
-        case TAG('T','X','S','M'): break; // ?
-        case TAG('F','A','H','S'): break; // ?
-        case TAG('V','R','T','S'): ReadVerts(&smesh, stream, chunk.Size/12); break;
-        case TAG('F','A','C','S'): ReadFaces(&smesh, stream); break;
-        case TAG('F','T','V','S'): ReadUVs(&smesh, stream); break;
-        case TAG('S','N','A','M'): name = ReadString(stream, chunk.Size/2); break;
-        case TAG('F','A','M','A'): ReadMtls(&smesh, stream); break;
-        case TAG('A','X','I','S'): ReadAxis(smesh.axis, stream); break;
-        case TAG('E','D','G','S'): ReadEdges(&smesh, stream); break;
-        case TAG('E','C','R','S'): ReadCreases(&smesh, stream); break;
-        default:                   UnknownChunk(stream, chunk); break;
+        switch (chunk.Tag) {
+        case TAG('M', 'I', 'R', 'P'): break; // mirror plane maybe?
+        case TAG('I', 'M', 'R', 'P'): break; // instance mirror? (not supported here yet)
+        case TAG('D', 'I', 'N', 'F'): break; // display info, not needed
+        case TAG('P', 'I', 'N', 'F'): break; // ?
+        case TAG('V', 'M', 'I', 'R'): break; // ?
+        case TAG('F', 'M', 'I', 'R'): break; // ?
+        case TAG('T', 'X', 'S', 'M'): break; // ?
+        case TAG('F', 'A', 'H', 'S'): break; // ?
+        case TAG('V', 'R', 'T', 'S'): ReadVerts(&smesh, stream, chunk.Size / 12); break;
+        case TAG('F', 'A', 'C', 'S'): ReadFaces(&smesh, stream); break;
+        case TAG('F', 'T', 'V', 'S'): ReadUVs(&smesh, stream); break;
+        case TAG('S', 'N', 'A', 'M'): name = ReadString(stream, chunk.Size / 2); break;
+        case TAG('F', 'A', 'M', 'A'): ReadMtls(&smesh, stream); break;
+        case TAG('A', 'X', 'I', 'S'): ReadAxis(smesh.axis, stream); break;
+        case TAG('E', 'D', 'G', 'S'): ReadEdges(&smesh, stream); break;
+        case TAG('E', 'C', 'R', 'S'): ReadCreases(&smesh, stream); break;
+        default: UnknownChunk(stream, chunk); break;
         }
 
         stream->SetCurrentPos(stream->GetReadLimit());
@@ -585,25 +546,22 @@ static void ReadShape(SIB* sib, StreamReaderLE* stream)
     std::vector<TempMesh> meshes(sib->mtls.size());
 
     // Un-index the source data and apply to each vertex.
-    for (unsigned fi=0;fi<smesh.faceStart.size();fi++)
-    {
+    for (unsigned fi = 0; fi < smesh.faceStart.size(); fi++) {
         uint32_t start = smesh.faceStart[fi];
         uint32_t mtl = smesh.mtls[fi];
         uint32_t *idx = &smesh.idx[start];
 
-        if (mtl >= meshes.size())
-        {
+        if (mtl >= meshes.size()) {
             ASSIMP_LOG_ERROR("SIB: Face material index is invalid.");
             mtl = 0;
         }
 
-        TempMesh& dest = meshes[mtl];
+        TempMesh &dest = meshes[mtl];
 
         aiFace face;
         face.mNumIndices = *idx++;
         face.mIndices = new unsigned[face.mNumIndices];
-        for (unsigned pt=0;pt<face.mNumIndices;pt++,idx+=N)
-        {
+        for (unsigned pt = 0; pt < face.mNumIndices; pt++, idx += N) {
             size_t vtxIdx = dest.vtx.size();
             face.mIndices[pt] = static_cast<unsigned int>(vtxIdx);
 
@@ -611,7 +569,7 @@ static void ReadShape(SIB* sib, StreamReaderLE* stream)
             // we did it when creating the data.
             aiVector3D pos = smesh.pos[idx[POS]];
             aiVector3D nrm = smesh.nrm[idx[NRM]];
-            aiVector3D uv  = smesh.uv[idx[UV]];
+            aiVector3D uv = smesh.uv[idx[UV]];
 
             // The verts are supplied in world-space, so let's
             // transform them back into the local space of this mesh:
@@ -632,13 +590,12 @@ static void ReadShape(SIB* sib, StreamReaderLE* stream)
 
     // Now that we know the size of everything,
     // we can build the final one-material-per-mesh data.
-    for (size_t n=0;n<meshes.size();n++)
-    {
-        TempMesh& src = meshes[n];
+    for (size_t n = 0; n < meshes.size(); n++) {
+        TempMesh &src = meshes[n];
         if (src.faces.empty())
             continue;
 
-        aiMesh* mesh = new aiMesh;
+        aiMesh *mesh = new aiMesh;
         mesh->mName = name;
         mesh->mNumFaces = static_cast<unsigned int>(src.faces.size());
         mesh->mFaces = new aiFace[mesh->mNumFaces];
@@ -649,14 +606,12 @@ static void ReadShape(SIB* sib, StreamReaderLE* stream)
         mesh->mNumUVComponents[0] = 2;
         mesh->mMaterialIndex = static_cast<unsigned int>(n);
 
-        for (unsigned i=0;i<mesh->mNumVertices;i++)
-        {
+        for (unsigned i = 0; i < mesh->mNumVertices; i++) {
             mesh->mVertices[i] = src.vtx[i];
             mesh->mNormals[i] = src.nrm[i];
             mesh->mTextureCoords[0][i] = src.uv[i];
         }
-        for (unsigned i=0;i<mesh->mNumFaces;i++)
-        {
+        for (unsigned i = 0; i < mesh->mNumFaces; i++) {
             mesh->mFaces[i] = src.faces[i];
         }
 
@@ -668,8 +623,7 @@ static void ReadShape(SIB* sib, StreamReaderLE* stream)
 }
 
 // ------------------------------------------------------------------------------------------------
-static void ReadMaterial(SIB* sib, StreamReaderLE* stream)
-{
+static void ReadMaterial(SIB *sib, StreamReaderLE *stream) {
     aiColor3D diff = ReadColor(stream);
     aiColor3D ambi = ReadColor(stream);
     aiColor3D spec = ReadColor(stream);
@@ -677,11 +631,11 @@ static void ReadMaterial(SIB* sib, StreamReaderLE* stream)
     float shiny = (float)stream->GetU4();
 
     uint32_t nameLen = stream->GetU4();
-    aiString name = ReadString(stream, nameLen/2);
+    aiString name = ReadString(stream, nameLen / 2);
     uint32_t texLen = stream->GetU4();
-    aiString tex = ReadString(stream, texLen/2);
+    aiString tex = ReadString(stream, texLen / 2);
 
-    aiMaterial* mtl = new aiMaterial();
+    aiMaterial *mtl = new aiMaterial();
     mtl->AddProperty(&diff, 1, AI_MATKEY_COLOR_DIFFUSE);
     mtl->AddProperty(&ambi, 1, AI_MATKEY_COLOR_AMBIENT);
     mtl->AddProperty(&spec, 1, AI_MATKEY_COLOR_SPECULAR);
@@ -697,8 +651,7 @@ static void ReadMaterial(SIB* sib, StreamReaderLE* stream)
 }
 
 // ------------------------------------------------------------------------------------------------
-static void ReadLightInfo(aiLight* light, StreamReaderLE* stream)
-{
+static void ReadLightInfo(aiLight *light, StreamReaderLE *stream) {
     uint32_t type = stream->GetU4();
     switch (type) {
     case 0: light->mType = aiLightSource_POINT; break;
@@ -728,7 +681,7 @@ static void ReadLightInfo(aiLight* light, StreamReaderLE* stream)
     // 99% and 1% percentiles.
     //    OpenGL: I = cos(angle)^E
     //   Solving: angle = acos(I^(1/E))
-    ai_real E = ai_real( 1.0 ) / std::max(spotExponent, (ai_real)0.00001);
+    ai_real E = ai_real(1.0) / std::max(spotExponent, (ai_real)0.00001);
     ai_real inner = std::acos(std::pow((ai_real)0.99, E));
     ai_real outer = std::acos(std::pow((ai_real)0.01, E));
 
@@ -739,20 +692,17 @@ static void ReadLightInfo(aiLight* light, StreamReaderLE* stream)
     light->mAngleOuterCone = outer;
 }
 
-static void ReadLight(SIB* sib, StreamReaderLE* stream)
-{
-    aiLight* light = new aiLight();
+static void ReadLight(SIB *sib, StreamReaderLE *stream) {
+    aiLight *light = new aiLight();
 
-    while (stream->GetRemainingSizeToLimit() >= sizeof(SIBChunk))
-    {
+    while (stream->GetRemainingSizeToLimit() >= sizeof(SIBChunk)) {
         SIBChunk chunk = ReadChunk(stream);
         unsigned oldLimit = stream->SetReadLimit(stream->GetCurrentPos() + chunk.Size);
 
-        switch (chunk.Tag)
-        {
-        case TAG('L','N','F','O'): ReadLightInfo(light, stream); break;
-        case TAG('S','N','A','M'): light->mName = ReadString(stream, chunk.Size/2); break;
-        default:                   UnknownChunk(stream, chunk); break;
+        switch (chunk.Tag) {
+        case TAG('L', 'N', 'F', 'O'): ReadLightInfo(light, stream); break;
+        case TAG('S', 'N', 'A', 'M'): light->mName = ReadString(stream, chunk.Size / 2); break;
+        default: UnknownChunk(stream, chunk); break;
         }
 
         stream->SetCurrentPos(stream->GetReadLimit());
@@ -763,8 +713,7 @@ static void ReadLight(SIB* sib, StreamReaderLE* stream)
 }
 
 // ------------------------------------------------------------------------------------------------
-static void ReadScale(aiMatrix4x4& axis, StreamReaderLE* stream)
-{
+static void ReadScale(aiMatrix4x4 &axis, StreamReaderLE *stream) {
     aiMatrix4x4 scale;
     scale.a1 = stream->GetF4();
     scale.b1 = stream->GetF4();
@@ -786,68 +735,61 @@ static void ReadScale(aiMatrix4x4& axis, StreamReaderLE* stream)
     axis = axis * scale;
 }
 
-static void ReadInstance(SIB* sib, StreamReaderLE* stream)
-{
+static void ReadInstance(SIB *sib, StreamReaderLE *stream) {
     SIBObject inst;
     uint32_t shapeIndex = 0;
 
-    while (stream->GetRemainingSizeToLimit() >= sizeof(SIBChunk))
-    {
+    while (stream->GetRemainingSizeToLimit() >= sizeof(SIBChunk)) {
         SIBChunk chunk = ReadChunk(stream);
         unsigned oldLimit = stream->SetReadLimit(stream->GetCurrentPos() + chunk.Size);
 
-        switch (chunk.Tag)
-        {
-        case TAG('D','I','N','F'): break; // display info, not needed
-        case TAG('P','I','N','F'): break; // ?
-        case TAG('A','X','I','S'): ReadAxis(inst.axis, stream); break;
-        case TAG('I','N','S','I'): shapeIndex = stream->GetU4(); break;
-        case TAG('S','M','T','X'): ReadScale(inst.axis, stream); break;
-        case TAG('S','N','A','M'): inst.name = ReadString(stream, chunk.Size/2); break;
-        default:                   UnknownChunk(stream, chunk); break;
+        switch (chunk.Tag) {
+        case TAG('D', 'I', 'N', 'F'): break; // display info, not needed
+        case TAG('P', 'I', 'N', 'F'): break; // ?
+        case TAG('A', 'X', 'I', 'S'): ReadAxis(inst.axis, stream); break;
+        case TAG('I', 'N', 'S', 'I'): shapeIndex = stream->GetU4(); break;
+        case TAG('S', 'M', 'T', 'X'): ReadScale(inst.axis, stream); break;
+        case TAG('S', 'N', 'A', 'M'): inst.name = ReadString(stream, chunk.Size / 2); break;
+        default: UnknownChunk(stream, chunk); break;
         }
 
         stream->SetCurrentPos(stream->GetReadLimit());
         stream->SetReadLimit(oldLimit);
     }
 
-    if ( shapeIndex >= sib->objs.size() ) {
-        throw DeadlyImportError( "SIB: Invalid shape index." );
+    if (shapeIndex >= sib->objs.size()) {
+        throw DeadlyImportError("SIB: Invalid shape index.");
     }
 
-    const SIBObject& src = sib->objs[shapeIndex];
+    const SIBObject &src = sib->objs[shapeIndex];
     inst.meshIdx = src.meshIdx;
     inst.meshCount = src.meshCount;
     sib->insts.push_back(inst);
 }
 
 // ------------------------------------------------------------------------------------------------
-static void CheckVersion(StreamReaderLE* stream)
-{
+static void CheckVersion(StreamReaderLE *stream) {
     uint32_t version = stream->GetU4();
-    if ( version < 1 || version > 2 ) {
-        throw DeadlyImportError( "SIB: Unsupported file version." );
+    if (version < 1 || version > 2) {
+        throw DeadlyImportError("SIB: Unsupported file version.");
     }
 }
 
-static void ReadScene(SIB* sib, StreamReaderLE* stream)
-{
+static void ReadScene(SIB *sib, StreamReaderLE *stream) {
     // Parse each chunk in turn.
-    while (stream->GetRemainingSizeToLimit() >= sizeof(SIBChunk))
-    {
+    while (stream->GetRemainingSizeToLimit() >= sizeof(SIBChunk)) {
         SIBChunk chunk = ReadChunk(stream);
         unsigned oldLimit = stream->SetReadLimit(stream->GetCurrentPos() + chunk.Size);
 
-        switch (chunk.Tag)
-        {
-        case TAG('H','E','A','D'): CheckVersion(stream); break;
-        case TAG('S','H','A','P'): ReadShape(sib, stream); break;
-        case TAG('G','R','P','S'): break; // group assignment, we don't import this
-        case TAG('T','E','X','P'): break; // ?
-        case TAG('I','N','S','T'): ReadInstance(sib, stream); break;
-        case TAG('M','A','T','R'): ReadMaterial(sib, stream); break;
-        case TAG('L','G','H','T'): ReadLight(sib, stream); break;
-        default:                   UnknownChunk(stream, chunk); break;
+        switch (chunk.Tag) {
+        case TAG('H', 'E', 'A', 'D'): CheckVersion(stream); break;
+        case TAG('S', 'H', 'A', 'P'): ReadShape(sib, stream); break;
+        case TAG('G', 'R', 'P', 'S'): break; // group assignment, we don't import this
+        case TAG('T', 'E', 'X', 'P'): break; // ?
+        case TAG('I', 'N', 'S', 'T'): ReadInstance(sib, stream); break;
+        case TAG('M', 'A', 'T', 'R'): ReadMaterial(sib, stream); break;
+        case TAG('L', 'G', 'H', 'T'): ReadLight(sib, stream); break;
+        default: UnknownChunk(stream, chunk); break;
         }
 
         stream->SetCurrentPos(stream->GetReadLimit());
@@ -857,19 +799,23 @@ static void ReadScene(SIB* sib, StreamReaderLE* stream)
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void SIBImporter::InternReadFile(const std::string& pFile,
-    aiScene* pScene, IOSystem* pIOHandler)
-{
-    StreamReaderLE stream(pIOHandler->Open(pFile, "rb"));
+void SIBImporter::InternReadFile(const std::string &pFile,
+        aiScene *pScene, IOSystem *pIOHandler) {
+
+    auto file = pIOHandler->Open(pFile, "rb");
+    if (!file)
+        throw DeadlyImportError("SIB: Could not open ", pFile);
+
+    StreamReaderLE stream(file);
 
     // We should have at least one chunk
     if (stream.GetRemainingSize() < 16)
-        throw DeadlyImportError("SIB file is either empty or corrupt: " + pFile);
+        throw DeadlyImportError("SIB file is either empty or corrupt: ", pFile);
 
     SIB sib;
 
     // Default material.
-    aiMaterial* defmtl = new aiMaterial;
+    aiMaterial *defmtl = new aiMaterial;
     aiString defname = aiString(AI_DEFAULT_MATERIAL_NAME);
     defmtl->AddProperty(&defname, AI_MATKEY_NAME);
     sib.mtls.push_back(defmtl);
@@ -886,57 +832,54 @@ void SIBImporter::InternReadFile(const std::string& pFile,
     pScene->mNumMaterials = static_cast<unsigned int>(sib.mtls.size());
     pScene->mNumMeshes = static_cast<unsigned int>(sib.meshes.size());
     pScene->mNumLights = static_cast<unsigned int>(sib.lights.size());
-    pScene->mMaterials = pScene->mNumMaterials ? new aiMaterial*[pScene->mNumMaterials] : NULL;
-    pScene->mMeshes = pScene->mNumMeshes ? new aiMesh*[pScene->mNumMeshes] : NULL;
-    pScene->mLights = pScene->mNumLights ? new aiLight*[pScene->mNumLights] : NULL;
+    pScene->mMaterials = pScene->mNumMaterials ? new aiMaterial *[pScene->mNumMaterials] : nullptr;
+    pScene->mMeshes = pScene->mNumMeshes ? new aiMesh *[pScene->mNumMeshes] : nullptr;
+    pScene->mLights = pScene->mNumLights ? new aiLight *[pScene->mNumLights] : nullptr;
     if (pScene->mNumMaterials)
-        memcpy(pScene->mMaterials, &sib.mtls[0], sizeof(aiMaterial*) * pScene->mNumMaterials);
+        memcpy(pScene->mMaterials, &sib.mtls[0], sizeof(aiMaterial *) * pScene->mNumMaterials);
     if (pScene->mNumMeshes)
-        memcpy(pScene->mMeshes, &sib.meshes[0], sizeof(aiMesh*) * pScene->mNumMeshes);
+        memcpy(pScene->mMeshes, &sib.meshes[0], sizeof(aiMesh *) * pScene->mNumMeshes);
     if (pScene->mNumLights)
-        memcpy(pScene->mLights, &sib.lights[0], sizeof(aiLight*) * pScene->mNumLights);
+        memcpy(pScene->mLights, &sib.lights[0], sizeof(aiLight *) * pScene->mNumLights);
 
     // Construct the root node.
     size_t childIdx = 0;
     aiNode *root = new aiNode();
     root->mName.Set("<SIBRoot>");
     root->mNumChildren = static_cast<unsigned int>(sib.objs.size() + sib.lights.size());
-    root->mChildren = root->mNumChildren ? new aiNode*[root->mNumChildren] : NULL;
+    root->mChildren = root->mNumChildren ? new aiNode *[root->mNumChildren] : nullptr;
     pScene->mRootNode = root;
 
     // Add nodes for each object.
-    for (size_t n=0;n<sib.objs.size();n++)
-    {
+    for (size_t n = 0; n < sib.objs.size(); n++) {
         ai_assert(root->mChildren);
-        SIBObject& obj = sib.objs[n];
-        aiNode* node = new aiNode;
+        SIBObject &obj = sib.objs[n];
+        aiNode *node = new aiNode;
         root->mChildren[childIdx++] = node;
         node->mName = obj.name;
         node->mParent = root;
         node->mTransformation = obj.axis;
 
         node->mNumMeshes = static_cast<unsigned int>(obj.meshCount);
-        node->mMeshes = node->mNumMeshes ? new unsigned[node->mNumMeshes] : NULL;
-        for (unsigned i=0;i<node->mNumMeshes;i++)
+        node->mMeshes = node->mNumMeshes ? new unsigned[node->mNumMeshes] : nullptr;
+        for (unsigned i = 0; i < node->mNumMeshes; i++)
             node->mMeshes[i] = static_cast<unsigned int>(obj.meshIdx + i);
 
         // Mark instanced objects as being so.
-        if (n >= firstInst)
-        {
-            node->mMetaData = aiMetadata::Alloc( 1 );
-            node->mMetaData->Set( 0, "IsInstance", true );
+        if (n >= firstInst) {
+            node->mMetaData = aiMetadata::Alloc(1);
+            node->mMetaData->Set(0, "IsInstance", true);
         }
     }
 
     // Add nodes for each light.
     // (no transformation as the light is already in world space)
-    for (size_t n=0;n<sib.lights.size();n++)
-    {
+    for (size_t n = 0; n < sib.lights.size(); n++) {
         ai_assert(root->mChildren);
-        aiLight* light = sib.lights[n];
-        if ( nullptr != light ) {
-            aiNode* node = new aiNode;
-            root->mChildren[ childIdx++ ] = node;
+        aiLight *light = sib.lights[n];
+        if (nullptr != light) {
+            aiNode *node = new aiNode;
+            root->mChildren[childIdx++] = node;
             node->mName = light->mName;
             node->mParent = root;
         }
diff --git a/Engine/lib/assimp/code/SIB/SIBImporter.h b/Engine/lib/assimp/code/AssetLib/SIB/SIBImporter.h
similarity index 86%
rename from Engine/lib/assimp/code/SIB/SIBImporter.h
rename to Engine/lib/assimp/code/AssetLib/SIB/SIBImporter.h
index bb88c2255..2b197ddca 100644
--- a/Engine/lib/assimp/code/SIB/SIBImporter.h
+++ b/Engine/lib/assimp/code/AssetLib/SIB/SIBImporter.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,6 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file  SIBImporter.h
  *  @brief Declaration of the SIB importer class.
  */
+#pragma once
 #ifndef AI_SIBIMPORTER_H_INCLUDED
 #define AI_SIBIMPORTER_H_INCLUDED
 
@@ -50,60 +50,51 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/types.h>
 #include <vector>
 
-namespace Assimp    {
+namespace Assimp {
 
 // ---------------------------------------------------------------------------
 /** Importer class for the Nevercenter Silo SIB scene format
 */
-class ASSIMP_API SIBImporter : public BaseImporter
-{
+class ASSIMP_API SIBImporter : public BaseImporter {
 public:
     SIBImporter();
-    ~SIBImporter();
+    ~SIBImporter() override;
 
-public:
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
      * See BaseImporter::CanRead() for details.
      */
     bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
+        bool checkSig) const override;
 
 protected:
     // -------------------------------------------------------------------
     /** Return importer meta information.
      * See #BaseImporter::GetInfo for the details
      */
-    const aiImporterDesc* GetInfo () const;
+    const aiImporterDesc* GetInfo () const override;
 
     // -------------------------------------------------------------------
     /** Imports the given file into the given scene structure.
     * See BaseImporter::InternReadFile() for details
     */
     void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
+        IOSystem* pIOHandler) override;
 
 private:
-    struct MeshInformation
-    {
-        explicit MeshInformation(const std::string& _name)
-            : name(_name)
-        {
+    struct MeshInformation {
+        explicit MeshInformation(const std::string& _name) : name(_name) {
             vertices.reserve(100);
             colors.reserve(100);
         }
 
         std::string name;
-
         std::vector<aiVector3D> vertices;
         std::vector<aiColor4D> colors;
     };
 
-    struct GroupInformation
-    {
-        explicit GroupInformation(const std::string& _name)
-            : name(_name)
-        {
+    struct GroupInformation {
+        explicit GroupInformation(const std::string& _name) : name(_name) {
             meshes.reserve(10);
         }
 
diff --git a/Engine/lib/assimp/code/SMD/SMDLoader.cpp b/Engine/lib/assimp/code/AssetLib/SMD/SMDLoader.cpp
similarity index 97%
rename from Engine/lib/assimp/code/SMD/SMDLoader.cpp
rename to Engine/lib/assimp/code/AssetLib/SMD/SMDLoader.cpp
index 4288bf9c3..46fd968c8 100644
--- a/Engine/lib/assimp/code/SMD/SMDLoader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/SMD/SMDLoader.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -60,7 +60,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // internal headers
 #include "SMDLoader.h"
 
-#ifndef _WIN32
+#ifndef _MSC_VER
 #define strtok_s strtok_r
 #endif
 
@@ -81,15 +81,15 @@ static const aiImporterDesc desc = {
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-SMDImporter::SMDImporter()
-: configFrameID()
-, mBuffer()
-, pScene( nullptr )
-, iFileSize( 0 )
-, iSmallestFrame( INT_MAX )
-, dLengthOfAnim( 0.0 )
-, bHasUVs(false )
-, iLineNumber(-1)  {
+SMDImporter::SMDImporter() :
+        configFrameID(), 
+        mBuffer(), 
+        pScene( nullptr ), 
+        iFileSize( 0 ), 
+        iSmallestFrame( INT_MAX ),
+        dLengthOfAnim( 0.0 ),
+        bHasUVs(false ), 
+        iLineNumber((unsigned int)-1)  {
     // empty
 }
 
@@ -101,9 +101,8 @@ SMDImporter::~SMDImporter() {
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool SMDImporter::CanRead( const std::string& pFile, IOSystem* /*pIOHandler*/, bool) const {
-    // fixme: auto format detection
-    return SimpleExtensionCheck(pFile,"smd","vta");
+bool SMDImporter::CanRead( const std::string& filename, IOSystem* /*pIOHandler*/, bool) const {
+    return SimpleExtensionCheck(filename, "smd", "vta");
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -129,8 +128,8 @@ void SMDImporter::SetupProperties(const Importer* pImp) {
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void SMDImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) {
-    this->pScene = pScene;
+void SMDImporter::InternReadFile( const std::string& pFile, aiScene* scene, IOSystem* pIOHandler) {
+    this->pScene = scene;
     ReadSmd(pFile, pIOHandler);
 
     // If there are no triangles it seems to be an animation SMD,
@@ -190,19 +189,19 @@ void SMDImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
 // ------------------------------------------------------------------------------------------------
 // Write an error message with line number to the log file
 void SMDImporter::LogErrorNoThrow(const char* msg) {
-    const size_t BufferSize = 1024;
-    char szTemp[BufferSize];
-    ai_snprintf(szTemp,BufferSize,"Line %u: %s",iLineNumber,msg);
+    const size_t _BufferSize = 1024;
+    char szTemp[_BufferSize];
+    ai_snprintf(szTemp,_BufferSize,"Line %u: %s",iLineNumber,msg);
     DefaultLogger::get()->error(szTemp);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Write a warning with line number to the log file
 void SMDImporter::LogWarning(const char* msg) {
-    const size_t BufferSize = 1024;
-    char szTemp[BufferSize];
+    const size_t _BufferSize = 1024;
+    char szTemp[_BufferSize];
     ai_assert(strlen(msg) < 1000);
-    ai_snprintf(szTemp,BufferSize,"Line %u: %s",iLineNumber,msg);
+    ai_snprintf(szTemp,_BufferSize,"Line %u: %s",iLineNumber,msg);
     ASSIMP_LOG_WARN(szTemp);
 }
 
@@ -438,7 +437,7 @@ void SMDImporter::AddBoneChildren(aiNode* pcNode, uint32_t iParent) {
             pc->mTransformation = bone.sAnim.asKeys[0].matrix;
         }
 
-        if (bone.iParent == static_cast<uint32_t>(-1)) { 
+        if (bone.iParent == static_cast<uint32_t>(-1)) {
             bone.mOffsetMatrix = pc->mTransformation;
         } else {
             bone.mOffsetMatrix = asBones[bone.iParent].mOffsetMatrix * pc->mTransformation;
@@ -577,7 +576,7 @@ void SMDImporter::GetAnimationFileList(const std::string &pFile, IOSystem* pIOHa
     char *context1, *context2;
 
     tok1 = strtok_s(&buf[0], "\r\n", &context1);
-    while (tok1 != NULL) {
+    while (tok1 != nullptr) {
         tok2 = strtok_s(tok1, " \t", &context2);
         if (tok2) {
             char *p = tok2;
@@ -616,7 +615,7 @@ void SMDImporter::CreateOutputMaterials() {
         if (aszTextures[iMat].length())
         {
             ::strncpy(szName.data, aszTextures[iMat].c_str(),MAXLEN-1);
-            szName.length = aszTextures[iMat].length();
+            szName.length = static_cast<ai_uint32>( aszTextures[iMat].length() );
             pcMat->AddProperty(&szName,AI_MATKEY_TEXTURE_DIFFUSE(0));
         }
     }
@@ -695,7 +694,7 @@ void SMDImporter::ReadSmd(const std::string &pFile, IOSystem* pIOHandler) {
 
     // Check whether we can read from the file
     if (file.get() == nullptr) {
-        throw DeadlyImportError("Failed to open SMD/VTA file " + pFile + ".");
+        throw DeadlyImportError("Failed to open SMD/VTA file ", pFile, ".");
     }
 
     iFileSize = (unsigned int)file->FileSize();
@@ -868,7 +867,7 @@ void SMDImporter::ParseNodeInfo(const char* szCurrent, const char** szCurrentOut
 
     bool bQuota = true;
     if ('\"' != *szCurrent) {
-        LogWarning("Bone name is expcted to be enclosed in "
+        LogWarning("Bone name is expected to be enclosed in "
             "double quotation marks. ");
         bQuota = false;
     } else {
diff --git a/Engine/lib/assimp/code/SMD/SMDLoader.h b/Engine/lib/assimp/code/AssetLib/SMD/SMDLoader.h
similarity index 94%
rename from Engine/lib/assimp/code/SMD/SMDLoader.h
rename to Engine/lib/assimp/code/AssetLib/SMD/SMDLoader.h
index 85dac97d1..db882a241 100644
--- a/Engine/lib/assimp/code/SMD/SMDLoader.h
+++ b/Engine/lib/assimp/code/AssetLib/SMD/SMDLoader.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -44,24 +43,21 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Definition of the Valve SMD file format
  */
 
+#pragma once
 #ifndef AI_SMDLOADER_H_INCLUDED
 #define AI_SMDLOADER_H_INCLUDED
 
-// internal headers
 #include <assimp/BaseImporter.h>
 #include <assimp/ParsingUtils.h>
-
-// public Assimp headers
 #include <assimp/types.h>
 #include <assimp/texture.h>
 #include <assimp/anim.h>
 #include <assimp/material.h>
 
-struct aiNode;
-
-// STL headers
 #include <vector>
 
+struct aiNode;
+
 namespace Assimp {
 namespace SMD {
 
@@ -69,8 +65,7 @@ namespace SMD {
 /** Data structure for a vertex in a SMD file
 */
 struct Vertex {
-    Vertex() AI_NO_EXCEPT
-    : iParentNode(UINT_MAX) {
+    Vertex() AI_NO_EXCEPT : iParentNode(UINT_MAX) {
         // empty
     }
 
@@ -91,12 +86,11 @@ struct Vertex {
 /** Data structure for a face in a SMD file
 */
 struct Face {
-    Face() AI_NO_EXCEPT
-    : iTexture(0x0)
-    , avVertices{} {
+    Face() AI_NO_EXCEPT :
+            iTexture(0x0), avVertices{} {
         // empty
     }
-
+    
     //! Texture index for the face
     unsigned int iTexture;
 
@@ -109,17 +103,10 @@ struct Face {
 */
 struct Bone {
     //! Default constructor
-    Bone() AI_NO_EXCEPT
-    : iParent(UINT_MAX)
-    , bIsUsed(false) {
+    Bone() AI_NO_EXCEPT : iParent(UINT_MAX), bIsUsed(false) {
         // empty
     }
 
-    //! Destructor
-    ~Bone()
-    {
-    }
-
     //! Name of the bone
     std::string mName;
 
@@ -129,14 +116,12 @@ struct Bone {
     //! Animation of the bone
     struct Animation {
         //! Public default constructor
-        Animation() AI_NO_EXCEPT
-        : iFirstTimeKey() {
+        Animation() AI_NO_EXCEPT : iFirstTimeKey() {
             asKeys.reserve(20);
         }
 
         //! Data structure for a matrix key
-        struct MatrixKey
-        {
+        struct MatrixKey {
             //! Matrix at this time
             aiMatrix4x4 matrix;
 
@@ -174,46 +159,38 @@ struct Bone {
 // ---------------------------------------------------------------------------
 /** Used to load Half-life 1 and 2 SMD models
 */
-class ASSIMP_API SMDImporter : public BaseImporter
-{
+class ASSIMP_API SMDImporter : public BaseImporter {
 public:
     SMDImporter();
-    ~SMDImporter();
-
-
-public:
+    ~SMDImporter() override;
 
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
      * See BaseImporter::CanRead() for details.
      */
     bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
+        bool checkSig) const override;
 
     // -------------------------------------------------------------------
     /** Called prior to ReadFile().
      * The function is a request to the importer to update its configuration
      * basing on the Importer's configuration property list.
      */
-    void SetupProperties(const Importer* pImp);
+    void SetupProperties(const Importer* pImp) override;
 
 protected:
-
-
     // -------------------------------------------------------------------
     /** Return importer meta information.
      * See #BaseImporter::GetInfo for the details
      */
-    const aiImporterDesc* GetInfo () const;
+    const aiImporterDesc* GetInfo () const override;
 
     // -------------------------------------------------------------------
     /** Imports the given file into the given scene structure.
     * See BaseImporter::InternReadFile() for details
     */
     void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
-
-protected:
+        IOSystem* pIOHandler) override;
 
     // -------------------------------------------------------------------
     /** Parse the SMD file and create the output scene
@@ -405,7 +382,7 @@ private:
      */
     bool bHasUVs;
 
-    /** Current line numer
+    /** Current line number
      */
     unsigned int iLineNumber;
 
diff --git a/Engine/lib/assimp/code/Importer/STEPParser/STEPFileEncoding.cpp b/Engine/lib/assimp/code/AssetLib/STEPParser/STEPFileEncoding.cpp
similarity index 99%
rename from Engine/lib/assimp/code/Importer/STEPParser/STEPFileEncoding.cpp
rename to Engine/lib/assimp/code/AssetLib/STEPParser/STEPFileEncoding.cpp
index 101dcdfd7..d4456e674 100644
--- a/Engine/lib/assimp/code/Importer/STEPParser/STEPFileEncoding.cpp
+++ b/Engine/lib/assimp/code/AssetLib/STEPParser/STEPFileEncoding.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -46,7 +46,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "STEPFileEncoding.h"
 #include <assimp/fast_atof.h>
 #ifdef ASSIMP_USE_HUNTER
-#  include <utf8/utf8.h>
+#  include <utf8.h>
 #else
 #  include <contrib/utf8cpp/source/utf8.h>
 #endif
diff --git a/Engine/lib/assimp/code/Importer/STEPParser/STEPFileEncoding.h b/Engine/lib/assimp/code/AssetLib/STEPParser/STEPFileEncoding.h
similarity index 98%
rename from Engine/lib/assimp/code/Importer/STEPParser/STEPFileEncoding.h
rename to Engine/lib/assimp/code/AssetLib/STEPParser/STEPFileEncoding.h
index 09f16ba33..950c9b3e2 100644
--- a/Engine/lib/assimp/code/Importer/STEPParser/STEPFileEncoding.h
+++ b/Engine/lib/assimp/code/AssetLib/STEPParser/STEPFileEncoding.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Importer/STEPParser/STEPFileReader.cpp b/Engine/lib/assimp/code/AssetLib/STEPParser/STEPFileReader.cpp
similarity index 94%
rename from Engine/lib/assimp/code/Importer/STEPParser/STEPFileReader.cpp
rename to Engine/lib/assimp/code/AssetLib/STEPParser/STEPFileReader.cpp
index f099d2be7..2bcfa1755 100644
--- a/Engine/lib/assimp/code/Importer/STEPParser/STEPFileReader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/STEPParser/STEPFileReader.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -49,22 +49,22 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "STEPFileEncoding.h"
 #include <assimp/TinyFormatter.h>
 #include <assimp/fast_atof.h>
+#include <functional>
 #include <memory>
-
+#include <utility>
 
 using namespace Assimp;
+
 namespace EXPRESS = STEP::EXPRESS;
 
-#include <functional>
-
 // ------------------------------------------------------------------------------------------------
-std::string AddLineNumber(const std::string& s,uint64_t line /*= LINE_NOT_SPECIFIED*/, const std::string& prefix = "")
+std::string AddLineNumber(const std::string& s,uint64_t line /*= LINE_NOT_SPECIFIED*/, const std::string& prefix = std::string())
 {
     return line == STEP::SyntaxError::LINE_NOT_SPECIFIED ? prefix+s : static_cast<std::string>( (Formatter::format(),prefix,"(line ",line,") ",s) );
 }
 
 // ------------------------------------------------------------------------------------------------
-std::string AddEntityID(const std::string& s,uint64_t entity /*= ENTITY_NOT_SPECIFIED*/, const std::string& prefix = "")
+std::string AddEntityID(const std::string& s,uint64_t entity /*= ENTITY_NOT_SPECIFIED*/, const std::string& prefix = std::string())
 {
     return entity == STEP::TypeError::ENTITY_NOT_SPECIFIED ? prefix+s : static_cast<std::string>( (Formatter::format(),prefix,"(entity #",entity,") ",s));
 }
@@ -88,7 +88,7 @@ static const char *ISO_Token         = "ISO-10303-21;";
 static const char *FILE_SCHEMA_Token = "FILE_SCHEMA";
 // ------------------------------------------------------------------------------------------------
 STEP::DB* STEP::ReadFileHeader(std::shared_ptr<IOStream> stream) {
-    std::shared_ptr<StreamReaderLE> reader = std::shared_ptr<StreamReaderLE>(new StreamReaderLE(stream));
+    std::shared_ptr<StreamReaderLE> reader = std::shared_ptr<StreamReaderLE>(new StreamReaderLE(std::move(stream)));
     std::unique_ptr<STEP::DB> db = std::unique_ptr<STEP::DB>(new STEP::DB(reader));
 
     LineSplitter &splitter = db->GetSplitter();
@@ -127,8 +127,8 @@ STEP::DB* STEP::ReadFileHeader(std::shared_ptr<IOStream> stream) {
                 if (list->GetSize() > 1)    {
                     ASSIMP_LOG_WARN(AddLineNumber("multiple schemas currently not supported",line));
                 }
-                const EXPRESS::STRING* string( nullptr );
-                if (!list->GetSize() || !(string=dynamic_cast<const EXPRESS::STRING*>( (*list)[0].get() ))) {
+                const EXPRESS::STRING *string = dynamic_cast<const EXPRESS::STRING *>((*list)[0].get());
+                if (!list->GetSize() || nullptr == string ) {
                     throw STEP::SyntaxError("expected FILE_SCHEMA to contain a single string literal",line);
                 }
                 head.fileSchema =  *string;
@@ -271,11 +271,15 @@ void STEP::ReadFile(DB& db,const EXPRESS::ConversionSchema& scheme,
         }
 
         std::string::size_type ns = n0;
-        do ++ns; while( IsSpace(s.at(ns)));
+        do {
+            ++ns;
+        } while (IsSpace(s.at(ns)));
         std::string::size_type ne = n1;
-        do --ne; while( IsSpace(s.at(ne)));
-        std::string type = s.substr(ns,ne-ns+1);
-        std::transform( type.begin(), type.end(), type.begin(), &Assimp::ToLower<char>  );
+        do {
+            --ne;
+        } while (IsSpace(s.at(ne)));
+        std::string type = s.substr(ns, ne - ns + 1);
+        type = ai_tolower(type);
         const char* sz = scheme.GetStaticStringForToken(type);
         if(sz) {
             const std::string::size_type szLen = n2-n1+1;
@@ -294,13 +298,13 @@ void STEP::ReadFile(DB& db,const EXPRESS::ConversionSchema& scheme,
     }
 
     if ( !DefaultLogger::isNullLogger()){
-        ASSIMP_LOG_DEBUG((Formatter::format(),"STEP: got ",map.size()," object records with ",
-            db.GetRefs().size()," inverse index entries"));
+        ASSIMP_LOG_DEBUG("STEP: got ",map.size()," object records with ",
+            db.GetRefs().size()," inverse index entries");
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-std::shared_ptr<const EXPRESS::DataType> EXPRESS::DataType::Parse(const char*& inout,uint64_t line, const EXPRESS::ConversionSchema* schema /*= NULL*/)
+std::shared_ptr<const EXPRESS::DataType> EXPRESS::DataType::Parse(const char*& inout,uint64_t line, const EXPRESS::ConversionSchema* schema /*= nullptr*/)
 {
     const char* cur = inout;
     SkipSpaces(&cur);
@@ -318,10 +322,10 @@ std::shared_ptr<const EXPRESS::DataType> EXPRESS::DataType::Parse(const char*& i
                 }
                 for(--t;IsSpace(*t);--t);
                 std::string s(cur,static_cast<size_t>(t-cur+1));
-                std::transform(s.begin(),s.end(),s.begin(),&ToLower<char> );
+                std::transform(s.begin(),s.end(),s.begin(),&ai_tolower<char> );
                 if (schema->IsKnownToken(s)) {
                     for(cur = t+1;*cur++ != '(';);
-                    const std::shared_ptr<const EXPRESS::DataType> dt = Parse(cur);
+                    std::shared_ptr<const EXPRESS::DataType> dt = Parse(cur);
                     inout = *cur ? cur+1 : cur;
                     return dt;
                 }
@@ -423,7 +427,7 @@ std::shared_ptr<const EXPRESS::DataType> EXPRESS::DataType::Parse(const char*& i
 }
 
 // ------------------------------------------------------------------------------------------------
-std::shared_ptr<const EXPRESS::LIST> EXPRESS::LIST::Parse(const char*& inout,uint64_t line, const EXPRESS::ConversionSchema* schema /*= NULL*/) {
+std::shared_ptr<const EXPRESS::LIST> EXPRESS::LIST::Parse(const char*& inout,uint64_t line, const EXPRESS::ConversionSchema* schema /*= nullptr*/) {
     const std::shared_ptr<EXPRESS::LIST> list = std::make_shared<EXPRESS::LIST>();
     EXPRESS::LIST::MemberList& members = list->members;
 
@@ -539,11 +543,11 @@ void STEP::LazyObject::LazyInit() const {
     }
 
     const char* acopy = args;
-    std::shared_ptr<const EXPRESS::LIST> conv_args = EXPRESS::LIST::Parse(acopy,STEP::SyntaxError::LINE_NOT_SPECIFIED,&db.GetSchema());
+    std::shared_ptr<const EXPRESS::LIST> conv_args = EXPRESS::LIST::Parse(acopy,(uint64_t)STEP::SyntaxError::LINE_NOT_SPECIFIED,&db.GetSchema());
     delete[] args;
-    args = NULL;
+    args = nullptr;
 
-    // if the converter fails, it should throw an exception, but it should never return NULL
+    // if the converter fails, it should throw an exception, but it should never return nullptr
     try {
         obj = proc(db,*conv_args);
     }
diff --git a/Engine/lib/assimp/code/Importer/STEPParser/STEPFileReader.h b/Engine/lib/assimp/code/AssetLib/STEPParser/STEPFileReader.h
similarity index 97%
rename from Engine/lib/assimp/code/Importer/STEPParser/STEPFileReader.h
rename to Engine/lib/assimp/code/AssetLib/STEPParser/STEPFileReader.h
index 9c4b77241..8a57937c0 100644
--- a/Engine/lib/assimp/code/Importer/STEPParser/STEPFileReader.h
+++ b/Engine/lib/assimp/code/AssetLib/STEPParser/STEPFileReader.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -43,7 +43,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef INCLUDED_AI_STEPFILEREADER_H
 #define INCLUDED_AI_STEPFILEREADER_H
 
-#include "code/Step/STEPFile.h"
+#include "AssetLib/Step/STEPFile.h"
 
 namespace Assimp {
 namespace STEP {
diff --git a/Engine/lib/assimp/code/STL/STLExporter.cpp b/Engine/lib/assimp/code/AssetLib/STL/STLExporter.cpp
similarity index 97%
rename from Engine/lib/assimp/code/STL/STLExporter.cpp
rename to Engine/lib/assimp/code/AssetLib/STL/STLExporter.cpp
index 43bc752ae..9bbc2063f 100644
--- a/Engine/lib/assimp/code/STL/STLExporter.cpp
+++ b/Engine/lib/assimp/code/AssetLib/STL/STLExporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -69,10 +69,10 @@ void ExportSceneSTL(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene
     if (exporter.mOutput.fail()) {
         throw DeadlyExportError("output data creation failed. Most likely the file became too large: " + std::string(pFile));
     }
-    
+
     // we're still here - export successfully completed. Write the file.
     std::unique_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wt"));
-    if(outfile == NULL) {
+    if (outfile == nullptr) {
         throw DeadlyExportError("could not open output .stl file: " + std::string(pFile));
     }
 
@@ -88,10 +88,10 @@ void ExportSceneSTLBinary(const char* pFile,IOSystem* pIOSystem, const aiScene*
     if (exporter.mOutput.fail()) {
         throw DeadlyExportError("output data creation failed. Most likely the file became too large: " + std::string(pFile));
     }
-    
+
     // we're still here - export successfully completed. Write the file.
     std::unique_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wb"));
-    if(outfile == NULL) {
+    if (outfile == nullptr) {
         throw DeadlyExportError("could not open output .stl file: " + std::string(pFile));
     }
 
@@ -139,15 +139,15 @@ STLExporter::STLExporter(const char* _filename, const aiScene* pScene, bool expo
         if (exportPointClouds) {
             WritePointCloud("Assimp_Pointcloud", pScene );
             return;
-        } 
+        }
 
-        // Export the assimp mesh 
+        // Export the assimp mesh
         const std::string name = "AssimpScene";
         mOutput << SolidToken << " " << name << endl;
         for(unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
             WriteMesh(pScene->mMeshes[ i ]);
         }
-        mOutput << EndSolidToken << name << endl;
+        mOutput << EndSolidToken << " " << name << endl;
     }
 }
 
diff --git a/Engine/lib/assimp/code/STL/STLExporter.h b/Engine/lib/assimp/code/AssetLib/STL/STLExporter.h
similarity index 86%
rename from Engine/lib/assimp/code/STL/STLExporter.h
rename to Engine/lib/assimp/code/AssetLib/STL/STLExporter.h
index cb5238e60..066dcfefd 100644
--- a/Engine/lib/assimp/code/STL/STLExporter.h
+++ b/Engine/lib/assimp/code/AssetLib/STL/STLExporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -43,6 +43,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file STLExporter.h
  * Declares the exporter class to write a scene to a Stereolithography (STL) file
  */
+#pragma once
 #ifndef AI_STLEXPORTER_H_INC
 #define AI_STLEXPORTER_H_INC
 
@@ -57,28 +58,24 @@ namespace Assimp {
 // ------------------------------------------------------------------------------------------------
 /** Helper class to export a given scene to a STL file. */
 // ------------------------------------------------------------------------------------------------
-class STLExporter
-{
+class STLExporter {
 public:
     /// Constructor for a specific scene to export
-    STLExporter(const char* filename, const aiScene* pScene, bool exportPOintClouds, bool binary = false);
+    STLExporter(const char *filename, const aiScene *pScene, bool exportPOintClouds, bool binary = false);
 
-    /// public stringstreams to write all output into
+    /// public string-streams to write all output into
     std::ostringstream mOutput;
 
 private:
-    void WritePointCloud(const std::string &name, const aiScene* pScene);
-    void WriteMesh(const aiMesh* m);
-    void WriteMeshBinary(const aiMesh* m);
+    void WritePointCloud(const std::string &name, const aiScene *pScene);
+    void WriteMesh(const aiMesh *m);
+    void WriteMeshBinary(const aiMesh *m);
 
 private:
-
     const std::string filename;
-
-    // this endl() doesn't flush() the stream
     const std::string endl;
 };
 
-}
+} // namespace Assimp
 
 #endif
diff --git a/Engine/lib/assimp/code/STL/STLLoader.cpp b/Engine/lib/assimp/code/AssetLib/STL/STLLoader.cpp
similarity index 60%
rename from Engine/lib/assimp/code/STL/STLLoader.cpp
rename to Engine/lib/assimp/code/AssetLib/STL/STLLoader.cpp
index 199a84a44..8de57f1ee 100644
--- a/Engine/lib/assimp/code/STL/STLLoader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/STL/STLLoader.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,23 +41,21 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** @file Implementation of the STL importer class */
 
-
 #ifndef ASSIMP_BUILD_NO_STL_IMPORTER
 
-// internal headers
 #include "STLLoader.h"
 #include <assimp/ParsingUtils.h>
 #include <assimp/fast_atof.h>
-#include <memory>
-#include <assimp/IOSystem.hpp>
+#include <assimp/importerdesc.h>
 #include <assimp/scene.h>
 #include <assimp/DefaultLogger.hpp>
-#include <assimp/importerdesc.h>
+#include <assimp/IOSystem.hpp>
+#include <memory>
 
 using namespace Assimp;
 
 namespace {
-    
+
 static const aiImporterDesc desc = {
     "Stereolithography (STL) Importer",
     "",
@@ -77,14 +73,14 @@ static const aiImporterDesc desc = {
 // 1) 80 byte header
 // 2) 4 byte face count
 // 3) 50 bytes per face
-static bool IsBinarySTL(const char* buffer, unsigned int fileSize) {
-    if( fileSize < 84 ) {
+static bool IsBinarySTL(const char *buffer, unsigned int fileSize) {
+    if (fileSize < 84) {
         return false;
     }
 
     const char *facecount_pos = buffer + 80;
-    uint32_t faceCount( 0 );
-    ::memcpy( &faceCount, facecount_pos, sizeof( uint32_t ) );
+    uint32_t faceCount(0);
+    ::memcpy(&faceCount, facecount_pos, sizeof(uint32_t));
     const uint32_t expectedBinaryFileSize = faceCount * 50 + 84;
 
     return expectedBinaryFileSize == fileSize;
@@ -96,25 +92,27 @@ static const char UnicodeBoundary = 127;
 // An ascii STL buffer will begin with "solid NAME", where NAME is optional.
 // Note: The "solid NAME" check is necessary, but not sufficient, to determine
 // if the buffer is ASCII; a binary header could also begin with "solid NAME".
-static bool IsAsciiSTL(const char* buffer, unsigned int fileSize) {
+static bool IsAsciiSTL(const char *buffer, unsigned int fileSize) {
     if (IsBinarySTL(buffer, fileSize))
         return false;
 
-    const char* bufferEnd = buffer + fileSize;
+    const char *bufferEnd = buffer + fileSize;
 
-    if (!SkipSpaces(&buffer))
+    if (!SkipSpaces(&buffer)) {
         return false;
+    }
 
-    if (buffer + 5 >= bufferEnd)
+    if (buffer + 5 >= bufferEnd) {
         return false;
+    }
 
-    bool isASCII( strncmp( buffer, "solid", 5 ) == 0 );
-    if( isASCII ) {
+    bool isASCII(strncmp(buffer, "solid", 5) == 0);
+    if (isASCII) {
         // A lot of importers are write solid even if the file is binary. So we have to check for ASCII-characters.
-        if( fileSize >= BufferSize) {
+        if (fileSize >= BufferSize) {
             isASCII = true;
-            for( unsigned int i = 0; i < BufferSize; i++ ) {
-                if( buffer[ i ] > UnicodeBoundary) {
+            for (unsigned int i = 0; i < BufferSize; i++) {
+                if (buffer[i] > UnicodeBoundary) {
                     isASCII = false;
                     break;
                 }
@@ -127,49 +125,38 @@ static bool IsAsciiSTL(const char* buffer, unsigned int fileSize) {
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-STLImporter::STLImporter()
-    : mBuffer(),
-    fileSize(),
-    pScene()
-{}
+STLImporter::STLImporter() :
+        mBuffer(),
+        mFileSize(0),
+        mScene() {
+   // empty
+}
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-STLImporter::~STLImporter()
-{}
+STLImporter::~STLImporter() {
+    // empty
+}
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool STLImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
-{
-    const std::string extension = GetExtension(pFile);
-
-    if( extension == "stl" ) {
-        return true;
-    } else if (!extension.length() || checkSig)   {
-        if( !pIOHandler ) {
-            return true;
-        }
-        const char* tokens[] = {"STL","solid"};
-        return SearchFileHeaderForToken(pIOHandler,pFile,tokens,2);
-    }
-
-    return false;
+bool STLImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
+    static const char *tokens[] = { "STL", "solid" };
+    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------
-const aiImporterDesc* STLImporter::GetInfo () const {
+const aiImporterDesc *STLImporter::GetInfo() const {
     return &desc;
 }
 
-void addFacesToMesh(aiMesh* pMesh)
-{
+void addFacesToMesh(aiMesh *pMesh) {
     pMesh->mFaces = new aiFace[pMesh->mNumFaces];
-    for (unsigned int i = 0, p = 0; i < pMesh->mNumFaces;++i)    {
+    for (unsigned int i = 0, p = 0; i < pMesh->mNumFaces; ++i) {
 
-        aiFace& face = pMesh->mFaces[i];
+        aiFace &face = pMesh->mFaces[i];
         face.mIndices = new unsigned int[face.mNumIndices = 3];
-        for (unsigned int o = 0; o < 3;++o,++p) {
+        for (unsigned int o = 0; o < 3; ++o, ++p) {
             face.mIndices[o] = p;
         }
     }
@@ -177,137 +164,132 @@ void addFacesToMesh(aiMesh* pMesh)
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void STLImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler )
-{
-    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));
+void STLImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
+    std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));
 
     // Check whether we can read from the file
-    if( file.get() == nullptr) {
-        throw DeadlyImportError( "Failed to open STL file " + pFile + ".");
+    if (file.get() == nullptr) {
+        throw DeadlyImportError("Failed to open STL file ", pFile, ".");
     }
 
-    fileSize = (unsigned int)file->FileSize();
+    mFileSize = (unsigned int)file->FileSize();
 
     // allocate storage and copy the contents of the file to a memory buffer
     // (terminate it with zero)
     std::vector<char> buffer2;
-    TextFileToBuffer(file.get(),buffer2);
+    TextFileToBuffer(file.get(), buffer2);
 
-    this->pScene = pScene;
-    this->mBuffer = &buffer2[0];
+    mScene = pScene;
+    mBuffer = &buffer2[0];
 
     // the default vertex color is light gray.
-    clrColorDefault.r = clrColorDefault.g = clrColorDefault.b = clrColorDefault.a = (ai_real) 0.6;
+    mClrColorDefault.r = mClrColorDefault.g = mClrColorDefault.b = mClrColorDefault.a = (ai_real)0.6;
 
     // allocate a single node
-    pScene->mRootNode = new aiNode();
+    mScene->mRootNode = new aiNode();
 
     bool bMatClr = false;
 
-    if (IsBinarySTL(mBuffer, fileSize)) {
+    if (IsBinarySTL(mBuffer, mFileSize)) {
         bMatClr = LoadBinaryFile();
-    } else if (IsAsciiSTL(mBuffer, fileSize)) {
-        LoadASCIIFile( pScene->mRootNode );
+    } else if (IsAsciiSTL(mBuffer, mFileSize)) {
+        LoadASCIIFile(mScene->mRootNode);
     } else {
-        throw DeadlyImportError( "Failed to determine STL storage representation for " + pFile + ".");
+        throw DeadlyImportError("Failed to determine STL storage representation for ", pFile, ".");
     }
 
     // create a single default material, using a white diffuse color for consistency with
     // other geometric types (e.g., PLY).
-    aiMaterial* pcMat = new aiMaterial();
+    aiMaterial *pcMat = new aiMaterial();
     aiString s;
     s.Set(AI_DEFAULT_MATERIAL_NAME);
     pcMat->AddProperty(&s, AI_MATKEY_NAME);
 
-    aiColor4D clrDiffuse(ai_real(1.0),ai_real(1.0),ai_real(1.0),ai_real(1.0));
+    aiColor4D clrDiffuse(ai_real(1.0), ai_real(1.0), ai_real(1.0), ai_real(1.0));
     if (bMatClr) {
-        clrDiffuse = clrColorDefault;
+        clrDiffuse = mClrColorDefault;
     }
-    pcMat->AddProperty(&clrDiffuse,1,AI_MATKEY_COLOR_DIFFUSE);
-    pcMat->AddProperty(&clrDiffuse,1,AI_MATKEY_COLOR_SPECULAR);
-    clrDiffuse = aiColor4D( ai_real(0.05), ai_real(0.05), ai_real(0.05), ai_real(1.0));
-    pcMat->AddProperty(&clrDiffuse,1,AI_MATKEY_COLOR_AMBIENT);
+    pcMat->AddProperty(&clrDiffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
+    pcMat->AddProperty(&clrDiffuse, 1, AI_MATKEY_COLOR_SPECULAR);
+    clrDiffuse = aiColor4D(ai_real(0.05), ai_real(0.05), ai_real(0.05), ai_real(1.0));
+    pcMat->AddProperty(&clrDiffuse, 1, AI_MATKEY_COLOR_AMBIENT);
 
-    pScene->mNumMaterials = 1;
-    pScene->mMaterials = new aiMaterial*[1];
-    pScene->mMaterials[0] = pcMat;
+    mScene->mNumMaterials = 1;
+    mScene->mMaterials = new aiMaterial *[1];
+    mScene->mMaterials[0] = pcMat;
 
     mBuffer = nullptr;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Read an ASCII STL file
-void STLImporter::LoadASCIIFile( aiNode *root ) {
-    std::vector<aiMesh*> meshes;
-    std::vector<aiNode*> nodes;
-    const char* sz = mBuffer;
-    const char* bufferEnd = mBuffer + fileSize;
+void STLImporter::LoadASCIIFile(aiNode *root) {
+    std::vector<aiMesh *> meshes;
+    std::vector<aiNode *> nodes;
+    const char *sz = mBuffer;
+    const char *bufferEnd = mBuffer + mFileSize;
     std::vector<aiVector3D> positionBuffer;
     std::vector<aiVector3D> normalBuffer;
 
     // try to guess how many vertices we could have
     // assume we'll need 160 bytes for each face
-    size_t sizeEstimate = std::max(1u, fileSize / 160u ) * 3;
+    size_t sizeEstimate = std::max(1u, mFileSize / 160u) * 3;
     positionBuffer.reserve(sizeEstimate);
     normalBuffer.reserve(sizeEstimate);
 
     while (IsAsciiSTL(sz, static_cast<unsigned int>(bufferEnd - sz))) {
         std::vector<unsigned int> meshIndices;
-        aiMesh* pMesh = new aiMesh();
+        aiMesh *pMesh = new aiMesh();
         pMesh->mMaterialIndex = 0;
-        meshIndices.push_back((unsigned int) meshes.size() );
+        meshIndices.push_back((unsigned int)meshes.size());
         meshes.push_back(pMesh);
         aiNode *node = new aiNode;
         node->mParent = root;
-        nodes.push_back( node );
+        nodes.push_back(node);
         SkipSpaces(&sz);
         ai_assert(!IsLineEnd(sz));
 
         sz += 5; // skip the "solid"
         SkipSpaces(&sz);
-        const char* szMe = sz;
+        const char *szMe = sz;
         while (!::IsSpaceOrNewLine(*sz)) {
             sz++;
         }
 
-        size_t temp;
+        size_t temp = (size_t)(sz - szMe);
         // setup the name of the node
-        if ((temp = (size_t)(sz-szMe))) {
+        if ( temp ) {
             if (temp >= MAXLEN) {
-                throw DeadlyImportError( "STL: Node name too long" );
+                throw DeadlyImportError("STL: Node name too long");
             }
-            std::string name( szMe, temp );
-            node->mName.Set( name.c_str() );
-            pMesh->mName.Set( name.c_str() );
-            //pScene->mRootNode->mName.length = temp;
-            //memcpy(pScene->mRootNode->mName.data,szMe,temp);
-            //pScene->mRootNode->mName.data[temp] = '\0';
+            std::string name(szMe, temp);
+            node->mName.Set(name.c_str());
+            pMesh->mName.Set(name.c_str());
         } else {
-            pScene->mRootNode->mName.Set("<STL_ASCII>");
+            mScene->mRootNode->mName.Set("<STL_ASCII>");
         }
 
         unsigned int faceVertexCounter = 3;
-        for ( ;; ) {
+        for (;;) {
             // go to the next token
-            if(!SkipSpacesAndLineEnd(&sz))
-            {
+            if (!SkipSpacesAndLineEnd(&sz)) {
                 // seems we're finished although there was no end marker
                 ASSIMP_LOG_WARN("STL: unexpected EOF. \'endsolid\' keyword was expected");
                 break;
             }
             // facet normal -0.13 -0.13 -0.98
-            if (!strncmp(sz,"facet",5) && IsSpaceOrNewLine(*(sz+5)) && *(sz + 5) != '\0')    {
+            if (!strncmp(sz, "facet", 5) && IsSpaceOrNewLine(*(sz + 5)) && *(sz + 5) != '\0') {
 
                 if (faceVertexCounter != 3) {
                     ASSIMP_LOG_WARN("STL: A new facet begins but the old is not yet complete");
                 }
                 faceVertexCounter = 0;
                 normalBuffer.push_back(aiVector3D());
-                aiVector3D* vn = &normalBuffer.back();
+                aiVector3D *vn = &normalBuffer.back();
 
                 sz += 6;
                 SkipSpaces(&sz);
-                if (strncmp(sz,"normal",6))    {
+                if (strncmp(sz, "normal", 6)) {
                     ASSIMP_LOG_WARN("STL: a facet normal vector was expected but not found");
                 } else {
                     if (sz[6] == '\0') {
@@ -315,15 +297,15 @@ void STLImporter::LoadASCIIFile( aiNode *root ) {
                     }
                     sz += 7;
                     SkipSpaces(&sz);
-                    sz = fast_atoreal_move<ai_real>(sz, (ai_real&)vn->x );
+                    sz = fast_atoreal_move<ai_real>(sz, (ai_real &)vn->x);
                     SkipSpaces(&sz);
-                    sz = fast_atoreal_move<ai_real>(sz, (ai_real&)vn->y );
+                    sz = fast_atoreal_move<ai_real>(sz, (ai_real &)vn->y);
                     SkipSpaces(&sz);
-                    sz = fast_atoreal_move<ai_real>(sz, (ai_real&)vn->z );
+                    sz = fast_atoreal_move<ai_real>(sz, (ai_real &)vn->z);
                     normalBuffer.push_back(*vn);
                     normalBuffer.push_back(*vn);
                 }
-            } else if (!strncmp(sz,"vertex",6) && ::IsSpaceOrNewLine(*(sz+6))) { // vertex 1.50000 1.50000 0.00000
+            } else if (!strncmp(sz, "vertex", 6) && ::IsSpaceOrNewLine(*(sz + 6))) { // vertex 1.50000 1.50000 0.00000
                 if (faceVertexCounter >= 3) {
                     ASSIMP_LOG_ERROR("STL: a facet with more than 3 vertices has been found");
                     ++sz;
@@ -334,15 +316,15 @@ void STLImporter::LoadASCIIFile( aiNode *root ) {
                     sz += 7;
                     SkipSpaces(&sz);
                     positionBuffer.push_back(aiVector3D());
-                    aiVector3D* vn = &positionBuffer.back();
-                    sz = fast_atoreal_move<ai_real>(sz, (ai_real&)vn->x );
+                    aiVector3D *vn = &positionBuffer.back();
+                    sz = fast_atoreal_move<ai_real>(sz, (ai_real &)vn->x);
                     SkipSpaces(&sz);
-                    sz = fast_atoreal_move<ai_real>(sz, (ai_real&)vn->y );
+                    sz = fast_atoreal_move<ai_real>(sz, (ai_real &)vn->y);
                     SkipSpaces(&sz);
-                    sz = fast_atoreal_move<ai_real>(sz, (ai_real&)vn->z );
+                    sz = fast_atoreal_move<ai_real>(sz, (ai_real &)vn->z);
                     faceVertexCounter++;
                 }
-            } else if (!::strncmp(sz,"endsolid",8))    {
+            } else if (!::strncmp(sz, "endsolid", 8)) {
                 do {
                     ++sz;
                 } while (!::IsLineEnd(*sz));
@@ -356,15 +338,15 @@ void STLImporter::LoadASCIIFile( aiNode *root ) {
             }
         }
 
-        if (positionBuffer.empty())    {
+        if (positionBuffer.empty()) {
             pMesh->mNumFaces = 0;
             ASSIMP_LOG_WARN("STL: mesh is empty or invalid; no data loaded");
         }
-        if (positionBuffer.size() % 3 != 0)    {
+        if (positionBuffer.size() % 3 != 0) {
             pMesh->mNumFaces = 0;
             throw DeadlyImportError("STL: Invalid number of vertices");
         }
-        if (normalBuffer.size() != positionBuffer.size())    {
+        if (normalBuffer.size() != positionBuffer.size()) {
             pMesh->mNumFaces = 0;
             throw DeadlyImportError("Normal buffer size does not match position buffer size");
         }
@@ -376,13 +358,21 @@ void STLImporter::LoadASCIIFile( aiNode *root ) {
             pMesh->mNumFaces = static_cast<unsigned int>(positionBuffer.size() / 3);
             pMesh->mNumVertices = static_cast<unsigned int>(positionBuffer.size());
             pMesh->mVertices = new aiVector3D[pMesh->mNumVertices];
-            memcpy(pMesh->mVertices, &positionBuffer[0].x, pMesh->mNumVertices * sizeof(aiVector3D));
+            for (size_t i=0; i<pMesh->mNumVertices; ++i ) {
+                pMesh->mVertices[i].x = positionBuffer[i].x;
+                pMesh->mVertices[i].y = positionBuffer[i].y;
+                pMesh->mVertices[i].z = positionBuffer[i].z;
+            }
             positionBuffer.clear();
         }
         // also only process normalBuffer when filled, else exception when accessing with index operator
         if (!normalBuffer.empty()) {
             pMesh->mNormals = new aiVector3D[pMesh->mNumVertices];
-            memcpy(pMesh->mNormals, &normalBuffer[0].x, pMesh->mNumVertices * sizeof(aiVector3D));
+            for (size_t i=0; i<pMesh->mNumVertices; ++i ) {
+                pMesh->mNormals[i].x = normalBuffer[i].x;
+                pMesh->mNormals[i].y = normalBuffer[i].y;
+                pMesh->mNormals[i].z = normalBuffer[i].z;
+            }
             normalBuffer.clear();
         }
 
@@ -390,67 +380,66 @@ void STLImporter::LoadASCIIFile( aiNode *root ) {
         addFacesToMesh(pMesh);
 
         // assign the meshes to the current node
-        pushMeshesToNode( meshIndices, node );
+        pushMeshesToNode(meshIndices, node);
     }
 
     // now add the loaded meshes
-    pScene->mNumMeshes = (unsigned int)meshes.size();
-    pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];
+    mScene->mNumMeshes = (unsigned int)meshes.size();
+    mScene->mMeshes = new aiMesh *[mScene->mNumMeshes];
     for (size_t i = 0; i < meshes.size(); i++) {
-        pScene->mMeshes[ i ] = meshes[i];
+        mScene->mMeshes[i] = meshes[i];
     }
 
-    root->mNumChildren = (unsigned int) nodes.size();
-    root->mChildren = new aiNode*[ root->mNumChildren ];
-    for ( size_t i=0; i<nodes.size(); ++i ) {
-        root->mChildren[ i ] = nodes[ i ];
+    root->mNumChildren = (unsigned int)nodes.size();
+    root->mChildren = new aiNode *[root->mNumChildren];
+    for (size_t i = 0; i < nodes.size(); ++i) {
+        root->mChildren[i] = nodes[i];
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Read a binary STL file
-bool STLImporter::LoadBinaryFile()
-{
+bool STLImporter::LoadBinaryFile() {
     // allocate one mesh
-    pScene->mNumMeshes = 1;
-    pScene->mMeshes = new aiMesh*[1];
-    aiMesh* pMesh = pScene->mMeshes[0] = new aiMesh();
+    mScene->mNumMeshes = 1;
+    mScene->mMeshes = new aiMesh *[1];
+    aiMesh *pMesh = mScene->mMeshes[0] = new aiMesh();
     pMesh->mMaterialIndex = 0;
 
     // skip the first 80 bytes
-    if (fileSize < 84) {
+    if (mFileSize < 84) {
         throw DeadlyImportError("STL: file is too small for the header");
     }
     bool bIsMaterialise = false;
 
     // search for an occurrence of "COLOR=" in the header
-    const unsigned char* sz2 = (const unsigned char*)mBuffer;
-    const unsigned char* const szEnd = sz2+80;
+    const unsigned char *sz2 = (const unsigned char *)mBuffer;
+    const unsigned char *const szEnd = sz2 + 80;
     while (sz2 < szEnd) {
 
         if ('C' == *sz2++ && 'O' == *sz2++ && 'L' == *sz2++ &&
-            'O' == *sz2++ && 'R' == *sz2++ && '=' == *sz2++)    {
+                'O' == *sz2++ && 'R' == *sz2++ && '=' == *sz2++) {
 
             // read the default vertex color for facets
             bIsMaterialise = true;
             ASSIMP_LOG_INFO("STL: Taking code path for Materialise files");
-            const ai_real invByte = (ai_real)1.0 / ( ai_real )255.0;
-            clrColorDefault.r = (*sz2++) * invByte;
-            clrColorDefault.g = (*sz2++) * invByte;
-            clrColorDefault.b = (*sz2++) * invByte;
-            clrColorDefault.a = (*sz2++) * invByte;
+            const ai_real invByte = (ai_real)1.0 / (ai_real)255.0;
+            mClrColorDefault.r = (*sz2++) * invByte;
+            mClrColorDefault.g = (*sz2++) * invByte;
+            mClrColorDefault.b = (*sz2++) * invByte;
+            mClrColorDefault.a = (*sz2++) * invByte;
             break;
         }
     }
-    const unsigned char* sz = (const unsigned char*)mBuffer + 80;
+    const unsigned char *sz = (const unsigned char *)mBuffer + 80;
 
     // now read the number of facets
-    pScene->mRootNode->mName.Set("<STL_BINARY>");
+    mScene->mRootNode->mName.Set("<STL_BINARY>");
 
-    pMesh->mNumFaces = *((uint32_t*)sz);
+    pMesh->mNumFaces = *((uint32_t *)sz);
     sz += 4;
 
-    if (fileSize < 84 + pMesh->mNumFaces*50) {
+    if (mFileSize < 84 + pMesh->mNumFaces * 50) {
         throw DeadlyImportError("STL: file is too small to hold all facets");
     }
 
@@ -458,123 +447,127 @@ bool STLImporter::LoadBinaryFile()
         throw DeadlyImportError("STL: file is empty. There are no facets defined");
     }
 
-    pMesh->mNumVertices = pMesh->mNumFaces*3;
+    pMesh->mNumVertices = pMesh->mNumFaces * 3;
 
-    
     aiVector3D *vp = pMesh->mVertices = new aiVector3D[pMesh->mNumVertices];
     aiVector3D *vn = pMesh->mNormals = new aiVector3D[pMesh->mNumVertices];
 
     typedef aiVector3t<float> aiVector3F;
-    aiVector3F* theVec;
+    aiVector3F *theVec;
     aiVector3F theVec3F;
-    
-    for ( unsigned int i = 0; i < pMesh->mNumFaces; ++i ) {
+
+    for (unsigned int i = 0; i < pMesh->mNumFaces; ++i) {
         // NOTE: Blender sometimes writes empty normals ... this is not
         // our fault ... the RemoveInvalidData helper step should fix that
 
         // There's one normal for the face in the STL; use it three times
         // for vertex normals
-        theVec = (aiVector3F*) sz;
-        ::memcpy( &theVec3F, theVec, sizeof(aiVector3F) );
-        vn->x = theVec3F.x; vn->y = theVec3F.y; vn->z = theVec3F.z;
-        *(vn+1) = *vn;
-        *(vn+2) = *vn;
+        theVec = (aiVector3F *)sz;
+        ::memcpy(&theVec3F, theVec, sizeof(aiVector3F));
+        vn->x = theVec3F.x;
+        vn->y = theVec3F.y;
+        vn->z = theVec3F.z;
+        *(vn + 1) = *vn;
+        *(vn + 2) = *vn;
         ++theVec;
         vn += 3;
 
         // vertex 1
-        ::memcpy( &theVec3F, theVec, sizeof(aiVector3F) );
-        vp->x = theVec3F.x; vp->y = theVec3F.y; vp->z = theVec3F.z;
+        ::memcpy(&theVec3F, theVec, sizeof(aiVector3F));
+        vp->x = theVec3F.x;
+        vp->y = theVec3F.y;
+        vp->z = theVec3F.z;
         ++theVec;
         ++vp;
 
         // vertex 2
-        ::memcpy( &theVec3F, theVec, sizeof(aiVector3F) );
-        vp->x = theVec3F.x; vp->y = theVec3F.y; vp->z = theVec3F.z;
+        ::memcpy(&theVec3F, theVec, sizeof(aiVector3F));
+        vp->x = theVec3F.x;
+        vp->y = theVec3F.y;
+        vp->z = theVec3F.z;
         ++theVec;
         ++vp;
 
         // vertex 3
-        ::memcpy( &theVec3F, theVec, sizeof(aiVector3F) );
-        vp->x = theVec3F.x; vp->y = theVec3F.y; vp->z = theVec3F.z;
+        ::memcpy(&theVec3F, theVec, sizeof(aiVector3F));
+        vp->x = theVec3F.x;
+        vp->y = theVec3F.y;
+        vp->z = theVec3F.z;
         ++theVec;
         ++vp;
-        
-        sz = (const unsigned char*) theVec;
 
-        uint16_t color = *((uint16_t*)sz);
+        sz = (const unsigned char *)theVec;
+
+        uint16_t color = *((uint16_t *)sz);
         sz += 2;
 
-        if (color & (1 << 15))
-        {
+        if (color & (1 << 15)) {
             // seems we need to take the color
-            if (!pMesh->mColors[0])
-            {
+            if (!pMesh->mColors[0]) {
                 pMesh->mColors[0] = new aiColor4D[pMesh->mNumVertices];
-                for (unsigned int i = 0; i <pMesh->mNumVertices;++i)
-                    *pMesh->mColors[0]++ = this->clrColorDefault;
+                for (unsigned int j = 0; j < pMesh->mNumVertices; ++j) {
+                    *pMesh->mColors[0]++ = mClrColorDefault;
+                }
                 pMesh->mColors[0] -= pMesh->mNumVertices;
 
                 ASSIMP_LOG_INFO("STL: Mesh has vertex colors");
             }
-            aiColor4D* clr = &pMesh->mColors[0][i*3];
+            aiColor4D *clr = &pMesh->mColors[0][i * 3];
             clr->a = 1.0;
-            const ai_real invVal( (ai_real)1.0 / ( ai_real )31.0 );
+            const ai_real invVal((ai_real)1.0 / (ai_real)31.0);
             if (bIsMaterialise) // this is reversed
             {
-                clr->r = (color & 0x31u) *invVal;
-                clr->g = ((color & (0x31u<<5))>>5u) *invVal;
-                clr->b = ((color & (0x31u<<10))>>10u) *invVal;
-            }
-            else
-            {
-                clr->b = (color & 0x31u) *invVal;
-                clr->g = ((color & (0x31u<<5))>>5u) *invVal;
-                clr->r = ((color & (0x31u<<10))>>10u) *invVal;
+                clr->r = (color & 0x31u) * invVal;
+                clr->g = ((color & (0x31u << 5)) >> 5u) * invVal;
+                clr->b = ((color & (0x31u << 10)) >> 10u) * invVal;
+            } else {
+                clr->b = (color & 0x31u) * invVal;
+                clr->g = ((color & (0x31u << 5)) >> 5u) * invVal;
+                clr->r = ((color & (0x31u << 10)) >> 10u) * invVal;
             }
             // assign the color to all vertices of the face
-            *(clr+1) = *clr;
-            *(clr+2) = *clr;
+            *(clr + 1) = *clr;
+            *(clr + 2) = *clr;
         }
     }
 
     // now copy faces
     addFacesToMesh(pMesh);
 
-    aiNode* root = pScene->mRootNode;
+    aiNode *root = mScene->mRootNode;
 
     // allocate one node
-    aiNode* node = new aiNode();
+    aiNode *node = new aiNode();
     node->mParent = root;
 
     root->mNumChildren = 1u;
-    root->mChildren = new aiNode*[root->mNumChildren];
+    root->mChildren = new aiNode *[root->mNumChildren];
     root->mChildren[0] = node;
 
     // add all created meshes to the single node
-    node->mNumMeshes = pScene->mNumMeshes;
-    node->mMeshes = new unsigned int[pScene->mNumMeshes];
-    for (unsigned int i = 0; i < pScene->mNumMeshes; i++)
+    node->mNumMeshes = mScene->mNumMeshes;
+    node->mMeshes = new unsigned int[mScene->mNumMeshes];
+    for (unsigned int i = 0; i < mScene->mNumMeshes; ++i) {
         node->mMeshes[i] = i;
+    }
 
-    if (bIsMaterialise && !pMesh->mColors[0])
-    {
+    if (bIsMaterialise && !pMesh->mColors[0]) {
         // use the color as diffuse material color
         return true;
     }
     return false;
 }
 
-void STLImporter::pushMeshesToNode( std::vector<unsigned int> &meshIndices, aiNode *node ) {
-    ai_assert( nullptr != node );
-    if ( meshIndices.empty() ) {
+void STLImporter::pushMeshesToNode(std::vector<unsigned int> &meshIndices, aiNode *node) {
+    ai_assert(nullptr != node);
+    if (meshIndices.empty()) {
         return;
     }
 
-    node->mNumMeshes = static_cast<unsigned int>( meshIndices.size() );
-    node->mMeshes = new unsigned int[ meshIndices.size() ];
-    for ( size_t i=0; i<meshIndices.size(); ++i ) {
-        node->mMeshes[ i ] = meshIndices[ i ];
+    node->mNumMeshes = static_cast<unsigned int>(meshIndices.size());
+    node->mMeshes = new unsigned int[meshIndices.size()];
+    for (size_t i = 0; i < meshIndices.size(); ++i) {
+        node->mMeshes[i] = meshIndices[i];
     }
     meshIndices.clear();
 }
diff --git a/Engine/lib/assimp/code/STL/STLLoader.h b/Engine/lib/assimp/code/AssetLib/STL/STLLoader.h
similarity index 92%
rename from Engine/lib/assimp/code/STL/STLLoader.h
rename to Engine/lib/assimp/code/AssetLib/STL/STLLoader.h
index ca1011cb8..a340abe6b 100644
--- a/Engine/lib/assimp/code/STL/STLLoader.h
+++ b/Engine/lib/assimp/code/AssetLib/STL/STLLoader.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -54,7 +53,6 @@ struct aiNode;
 
 namespace Assimp {
 
-
 // ---------------------------------------------------------------------------
 /**
  * @brief   Importer class for the sterolithography STL file format.
@@ -69,13 +67,13 @@ public:
     /**
      * @brief   The class destructor.
      */
-    ~STLImporter();
+    ~STLImporter() override;
 
     /**
      * @brief   Returns whether the class can handle the format of the given file.
      *  See BaseImporter::CanRead() for details.
      */
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const;
+    bool CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const override;
 
 protected:
 
@@ -83,14 +81,14 @@ protected:
      * @brief   Return importer meta information.
      *  See #BaseImporter::GetInfo for the details
      */
-    const aiImporterDesc* GetInfo () const;
+    const aiImporterDesc* GetInfo () const override;
 
     /**
      * @brief   Imports the given file into the given scene structure.
     * See BaseImporter::InternReadFile() for details
     */
     void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
+        IOSystem* pIOHandler) override;
 
     /**
      * @brief   Loads a binary .stl file
@@ -111,13 +109,13 @@ protected:
     const char* mBuffer;
 
     /** Size of the file, in bytes */
-    unsigned int fileSize;
+    unsigned int mFileSize;
 
     /** Output scene */
-    aiScene* pScene;
+    aiScene* mScene;
 
     /** Default vertex color */
-    aiColor4D clrColorDefault;
+    aiColor4D mClrColorDefault;
 };
 
 } // end of namespace Assimp
diff --git a/Engine/lib/assimp/code/AssetLib/Step/STEPFile.h b/Engine/lib/assimp/code/AssetLib/Step/STEPFile.h
new file mode 100644
index 000000000..e09faad98
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Step/STEPFile.h
@@ -0,0 +1,971 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2020, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#ifndef INCLUDED_AI_STEPFILE_H
+#define INCLUDED_AI_STEPFILE_H
+
+#include <bitset>
+#include <map>
+#include <memory>
+#include <set>
+#include <typeinfo>
+#include <vector>
+
+#include "AssetLib/FBX/FBXDocument.h" //ObjectMap::value_type
+
+#include <assimp/DefaultLogger.hpp>
+
+#ifdef _MSC_VER
+#    pragma warning(push)
+#    pragma warning(disable : 4127 4456 4245 4512 )
+#endif // _MSC_VER
+
+//
+#if _MSC_VER > 1500 || (defined __GNUC___)
+#    define ASSIMP_STEP_USE_UNORDERED_MULTIMAP
+#else
+#    define step_unordered_map map
+#    define step_unordered_multimap multimap
+#endif
+
+#ifdef ASSIMP_STEP_USE_UNORDERED_MULTIMAP
+#    include <unordered_map>
+#    if defined(_MSC_VER) && _MSC_VER <= 1600
+#        define step_unordered_map tr1::unordered_map
+#        define step_unordered_multimap tr1::unordered_multimap
+#    else
+#        define step_unordered_map unordered_map
+#        define step_unordered_multimap unordered_multimap
+#    endif
+#endif
+
+#include <assimp/LineSplitter.h>
+
+// uncomment this to have the loader evaluate all entities upon loading.
+// this is intended as stress test - by default, entities are evaluated
+// lazily and therefore not unless needed.
+
+//#define ASSIMP_IFC_TEST
+
+namespace Assimp {
+
+// ********************************************************************************
+// before things get complicated, this is the basic outline:
+
+namespace STEP {
+
+namespace EXPRESS {
+
+// base data types known by EXPRESS schemata - any custom data types will derive one of those
+class DataType;
+class UNSET; /*: public DataType */
+class ISDERIVED; /*: public DataType */
+//  class REAL;         /*: public DataType */
+class ENUM; /*: public DataType */
+//  class STRING;       /*: public DataType */
+//  class INTEGER;      /*: public DataType */
+class ENTITY; /*: public DataType */
+class LIST; /*: public DataType */
+//  class SELECT;       /*: public DataType */
+
+// a conversion schema is not exactly an EXPRESS schema, rather it
+// is a list of pointers to conversion functions to build up the
+// object tree from an input file.
+class ConversionSchema;
+} // namespace EXPRESS
+
+struct HeaderInfo;
+class Object;
+class LazyObject;
+class DB;
+
+typedef Object *(*ConvertObjectProc)(const DB &db, const EXPRESS::LIST &params);
+} // namespace STEP
+
+// ********************************************************************************
+
+namespace STEP {
+
+// -------------------------------------------------------------------------------
+/** Exception class used by the STEP loading & parsing code. It is typically
+     *  coupled with a line number. */
+// -------------------------------------------------------------------------------
+struct SyntaxError : DeadlyImportError {
+    enum : uint64_t {
+        LINE_NOT_SPECIFIED = 0xfffffffffffffffLL
+    };
+
+    SyntaxError(const std::string &s, uint64_t line = LINE_NOT_SPECIFIED);
+};
+
+// -------------------------------------------------------------------------------
+/** Exception class used by the STEP loading & parsing code when a type
+     *  error (i.e. an entity expects a string but receives a bool) occurs.
+     *  It is typically coupled with both an entity id and a line number.*/
+// -------------------------------------------------------------------------------
+struct TypeError : DeadlyImportError {
+    enum : uint64_t {
+        ENTITY_NOT_SPECIFIED = 0xffffffffffffffffUL,
+        ENTITY_NOT_SPECIFIED_32 = 0x00000000ffffffff
+    };
+
+    TypeError(const std::string &s, uint64_t entity = ENTITY_NOT_SPECIFIED, uint64_t line = SyntaxError::LINE_NOT_SPECIFIED);
+};
+
+// hack to make a given member template-dependent
+template <typename T, typename T2>
+T2 &Couple(T2 &in) {
+    return in;
+}
+
+namespace EXPRESS {
+
+// -------------------------------------------------------------------------------
+//** Base class for all STEP data types */
+// -------------------------------------------------------------------------------
+class DataType {
+public:
+    typedef std::shared_ptr<const DataType> Out;
+
+public:
+    virtual ~DataType() {
+    }
+
+public:
+    template <typename T>
+    const T &To() const {
+        return dynamic_cast<const T &>(*this);
+    }
+
+    template <typename T>
+    T &To() {
+        return dynamic_cast<T &>(*this);
+    }
+
+    template <typename T>
+    const T *ToPtr() const {
+        return dynamic_cast<const T *>(this);
+    }
+
+    template <typename T>
+    T *ToPtr() {
+        return dynamic_cast<T *>(this);
+    }
+
+    // utilities to deal with SELECT entities, which currently lack automatic
+    // conversion support.
+    template <typename T>
+    const T &ResolveSelect(const DB &db) const {
+        return Couple<T>(db).MustGetObject(To<EXPRESS::ENTITY>())->template To<T>();
+    }
+
+    template <typename T>
+    const T *ResolveSelectPtr(const DB &db) const {
+        const EXPRESS::ENTITY *e = ToPtr<EXPRESS::ENTITY>();
+        return e ? Couple<T>(db).MustGetObject(*e)->template ToPtr<T>() : (const T *)0;
+    }
+
+public:
+    /** parse a variable from a string and set 'inout' to the character
+             *  behind the last consumed character. An optional schema enables,
+             *  if specified, automatic conversion of custom data types.
+             *
+             *  @throw SyntaxError
+             */
+    static std::shared_ptr<const EXPRESS::DataType> Parse(const char *&inout,
+            uint64_t line = SyntaxError::LINE_NOT_SPECIFIED,
+            const EXPRESS::ConversionSchema *schema = NULL);
+
+public:
+};
+
+typedef DataType SELECT;
+typedef DataType LOGICAL;
+
+// -------------------------------------------------------------------------------
+/** Sentinel class to represent explicitly unset (optional) fields ($) */
+// -------------------------------------------------------------------------------
+class UNSET : public DataType {
+public:
+private:
+};
+
+// -------------------------------------------------------------------------------
+/** Sentinel class to represent explicitly derived fields (*) */
+// -------------------------------------------------------------------------------
+class ISDERIVED : public DataType {
+public:
+private:
+};
+
+// -------------------------------------------------------------------------------
+/** Shared implementation for some of the primitive data type, i.e. int, float */
+// -------------------------------------------------------------------------------
+template <typename T>
+class PrimitiveDataType : public DataType {
+public:
+    // This is the type that will cd ultimatively be used to
+    // expose this data type to the user.
+    typedef T Out;
+
+    PrimitiveDataType() {}
+    PrimitiveDataType(const T &val) :
+            val(val) {}
+
+    PrimitiveDataType(const PrimitiveDataType &o) {
+        (*this) = o;
+    }
+
+    operator const T &() const {
+        return val;
+    }
+
+    PrimitiveDataType &operator=(const PrimitiveDataType &o) {
+        val = o.val;
+        return *this;
+    }
+
+protected:
+    T val;
+};
+
+typedef PrimitiveDataType<int64_t> INTEGER;
+typedef PrimitiveDataType<double> REAL;
+typedef PrimitiveDataType<double> NUMBER;
+typedef PrimitiveDataType<std::string> STRING;
+
+// -------------------------------------------------------------------------------
+/** Generic base class for all enumerated types */
+// -------------------------------------------------------------------------------
+class ENUMERATION : public STRING {
+public:
+    ENUMERATION(const std::string &val) :
+            STRING(val) {}
+
+private:
+};
+
+typedef ENUMERATION BOOLEAN;
+
+// -------------------------------------------------------------------------------
+/** This is just a reference to an entity/object somewhere else */
+// -------------------------------------------------------------------------------
+class ENTITY : public PrimitiveDataType<uint64_t> {
+public:
+    ENTITY(uint64_t val) :
+            PrimitiveDataType<uint64_t>(val) {
+        ai_assert(val != 0);
+    }
+
+    ENTITY() :
+            PrimitiveDataType<uint64_t>(TypeError::ENTITY_NOT_SPECIFIED) {
+        // empty
+    }
+
+private:
+};
+
+// -------------------------------------------------------------------------------
+/** Wrap any STEP aggregate: LIST, SET, ... */
+// -------------------------------------------------------------------------------
+class LIST : public DataType {
+public:
+    // access a particular list index, throw std::range_error for wrong indices
+    std::shared_ptr<const DataType> operator[](size_t index) const {
+        return members[index];
+    }
+
+    size_t GetSize() const {
+        return members.size();
+    }
+
+public:
+    /** @see DaraType::Parse */
+    static std::shared_ptr<const EXPRESS::LIST> Parse(const char *&inout,
+            uint64_t line = SyntaxError::LINE_NOT_SPECIFIED,
+            const EXPRESS::ConversionSchema *schema = NULL);
+
+private:
+    typedef std::vector<std::shared_ptr<const DataType>> MemberList;
+    MemberList members;
+};
+
+class BINARY : public PrimitiveDataType<uint32_t> {
+public:
+    BINARY(uint32_t val) :
+            PrimitiveDataType<uint32_t>(val) {
+        // empty
+    }
+
+    BINARY() :
+            PrimitiveDataType<uint32_t>(TypeError::ENTITY_NOT_SPECIFIED_32) {
+        // empty
+    }
+};
+
+// -------------------------------------------------------------------------------
+/* Not exactly a full EXPRESS schema but rather a list of conversion functions
+         * to extract valid C++ objects out of a STEP file. Those conversion functions
+         * may, however, perform further schema validations. */
+// -------------------------------------------------------------------------------
+class ConversionSchema {
+public:
+    struct SchemaEntry {
+        SchemaEntry(const char *name, ConvertObjectProc func) :
+                mName(name), mFunc(func) {
+            // empty
+        }
+
+        const char *mName;
+        ConvertObjectProc mFunc;
+    };
+
+    typedef std::map<std::string, ConvertObjectProc> ConverterMap;
+
+    template <size_t N>
+    explicit ConversionSchema(const SchemaEntry (&schemas)[N]) {
+        *this = schemas;
+    }
+
+    ConversionSchema() {
+    }
+
+    ConvertObjectProc GetConverterProc(const std::string &name) const {
+        ConverterMap::const_iterator it = converters.find(name);
+        return it == converters.end() ? nullptr : (*it).second;
+    }
+
+    bool IsKnownToken(const std::string &name) const {
+        return converters.find(name) != converters.end();
+    }
+
+    const char *GetStaticStringForToken(const std::string &token) const {
+        ConverterMap::const_iterator it = converters.find(token);
+        return it == converters.end() ? nullptr : (*it).first.c_str();
+    }
+
+    template <size_t N>
+    const ConversionSchema &operator=(const SchemaEntry (&schemas)[N]) {
+        for (size_t i = 0; i < N; ++i) {
+            const SchemaEntry &schema = schemas[i];
+            converters[schema.mName] = schema.mFunc;
+        }
+        return *this;
+    }
+
+private:
+    ConverterMap converters;
+};
+} // namespace EXPRESS
+
+// ------------------------------------------------------------------------------
+/** Bundle all the relevant info from a STEP header, parts of which may later
+     *  be plainly dumped to the logfile, whereas others may help the caller pick an
+     *  appropriate loading strategy.*/
+// ------------------------------------------------------------------------------
+struct HeaderInfo {
+    std::string timestamp;
+    std::string app;
+    std::string fileSchema;
+};
+
+// ------------------------------------------------------------------------------
+/** Base class for all concrete object instances */
+// ------------------------------------------------------------------------------
+class Object {
+public:
+    Object(const char *classname = "unknown") :
+            id(0), classname(classname) {
+        // empty
+    }
+
+    virtual ~Object() {
+        // empty
+    }
+
+    // utilities to simplify casting to concrete types
+    template <typename T>
+    const T &To() const {
+        return dynamic_cast<const T &>(*this);
+    }
+
+    template <typename T>
+    T &To() {
+        return dynamic_cast<T &>(*this);
+    }
+
+    template <typename T>
+    const T *ToPtr() const {
+        return dynamic_cast<const T *>(this);
+    }
+
+    template <typename T>
+    T *ToPtr() {
+        return dynamic_cast<T *>(this);
+    }
+
+    uint64_t GetID() const {
+        return id;
+    }
+
+    std::string GetClassName() const {
+        return classname;
+    }
+
+    void SetID(uint64_t newval) {
+        id = newval;
+    }
+
+private:
+    uint64_t id;
+    const char *const classname;
+};
+
+template <typename T>
+size_t GenericFill(const STEP::DB &db, const EXPRESS::LIST &params, T *in);
+// (intentionally undefined)
+
+// ------------------------------------------------------------------------------
+/** CRTP shared base class for use by concrete entity implementation classes */
+// ------------------------------------------------------------------------------
+template <typename TDerived, size_t arg_count>
+struct ObjectHelper : virtual Object {
+    ObjectHelper() :
+            aux_is_derived(0) {
+        // empty
+    }
+
+    static Object *Construct(const STEP::DB &db, const EXPRESS::LIST &params) {
+        // make sure we don't leak if Fill() throws an exception
+        std::unique_ptr<TDerived> impl(new TDerived());
+
+        // GenericFill<T> is undefined so we need to have a specialization
+        const size_t num_args = GenericFill<TDerived>(db, params, &*impl);
+        (void)num_args;
+
+        // the following check is commented because it will always trigger if
+        // parts of the entities are generated with dummy wrapper code.
+        // This is currently done to reduce the size of the loader
+        // code.
+        //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") {
+        //  DefaultLogger::get()->debug("STEP: not all parameters consumed");
+        //}
+        return impl.release();
+    }
+
+    // note that this member always exists multiple times within the hierarchy
+    // of an individual object, so any access to it must be disambiguated.
+    std::bitset<arg_count> aux_is_derived;
+};
+
+// ------------------------------------------------------------------------------
+/** Class template used to represent OPTIONAL data members in the converted schema */
+// ------------------------------------------------------------------------------
+template <typename T>
+struct Maybe {
+    Maybe() :
+            have() {
+        // empty
+    }
+
+    explicit Maybe(const T &ptr) :
+            ptr(ptr), have(true) {
+        // empty
+    }
+
+    void flag_invalid() {
+        have = false;
+    }
+
+    void flag_valid() {
+        have = true;
+    }
+
+    bool operator!() const {
+        return !have;
+    }
+
+    operator bool() const {
+        return have;
+    }
+
+    operator const T &() const {
+        return Get();
+    }
+
+    const T &Get() const {
+        ai_assert(have);
+        return ptr;
+    }
+
+    Maybe &operator=(const T &_ptr) {
+        ptr = _ptr;
+        have = true;
+        return *this;
+    }
+
+private:
+    template <typename T2>
+    friend struct InternGenericConvert;
+
+    operator T &() {
+        return ptr;
+    }
+
+    T ptr;
+    bool have;
+};
+
+// ------------------------------------------------------------------------------
+/** A LazyObject is created when needed. Before this happens, we just keep
+       the text line that contains the object definition. */
+// -------------------------------------------------------------------------------
+class LazyObject {
+    friend class DB;
+
+public:
+    LazyObject(DB &db, uint64_t id, uint64_t line, const char *type, const char *args);
+    ~LazyObject();
+
+    Object &operator*() {
+        if (!obj) {
+            LazyInit();
+            ai_assert(obj);
+        }
+        return *obj;
+    }
+
+    const Object &operator*() const {
+        if (!obj) {
+            LazyInit();
+            ai_assert(obj);
+        }
+        return *obj;
+    }
+
+    template <typename T>
+    const T &To() const {
+        return dynamic_cast<const T &>(**this);
+    }
+
+    template <typename T>
+    T &To() {
+        return dynamic_cast<T &>(**this);
+    }
+
+    template <typename T>
+    const T *ToPtr() const {
+        return dynamic_cast<const T *>(&**this);
+    }
+
+    template <typename T>
+    T *ToPtr() {
+        return dynamic_cast<T *>(&**this);
+    }
+
+    Object *operator->() {
+        return &**this;
+    }
+
+    const Object *operator->() const {
+        return &**this;
+    }
+
+    bool operator==(const std::string &atype) const {
+        return type == atype;
+    }
+
+    bool operator!=(const std::string &atype) const {
+        return type != atype;
+    }
+
+    uint64_t GetID() const {
+        return id;
+    }
+
+private:
+    void LazyInit() const;
+
+private:
+    mutable uint64_t id;
+    const char *const type;
+    DB &db;
+    mutable const char *args;
+    mutable Object *obj;
+};
+
+template <typename T>
+inline bool operator==(const std::shared_ptr<LazyObject> &lo, T whatever) {
+    return *lo == whatever; // XXX use std::forward if we have 0x
+}
+
+template <typename T>
+inline bool operator==(const std::pair<uint64_t, std::shared_ptr<LazyObject>> &lo, T whatever) {
+    return *(lo.second) == whatever; // XXX use std::forward if we have 0x
+}
+
+// ------------------------------------------------------------------------------
+/** Class template used to represent lazily evaluated object references in the converted schema */
+// ------------------------------------------------------------------------------
+template <typename T>
+struct Lazy {
+    typedef Lazy Out;
+    Lazy(const LazyObject *obj = nullptr) :
+            obj(obj) {
+        // empty
+    }
+
+    operator const T *() const {
+        return obj->ToPtr<T>();
+    }
+
+    operator const T &() const {
+        return obj->To<T>();
+    }
+
+    const T &operator*() const {
+        return obj->To<T>();
+    }
+
+    const T *operator->() const {
+        return &obj->To<T>();
+    }
+
+    const LazyObject *obj;
+};
+
+// ------------------------------------------------------------------------------
+/** Class template used to represent LIST and SET data members in the converted schema */
+// ------------------------------------------------------------------------------
+template <typename T, uint64_t min_cnt, uint64_t max_cnt = 0uL>
+struct ListOf : public std::vector<typename T::Out> {
+    typedef typename T::Out OutScalar;
+    typedef ListOf Out;
+
+    ListOf() {
+        static_assert(min_cnt <= max_cnt || !max_cnt, "min_cnt <= max_cnt || !max_cnt");
+    }
+};
+
+// ------------------------------------------------------------------------------
+template <typename TOut>
+struct PickBaseType {
+    typedef EXPRESS::PrimitiveDataType<TOut> Type;
+};
+
+template <typename TOut>
+struct PickBaseType<Lazy<TOut>> {
+    typedef EXPRESS::ENTITY Type;
+};
+
+template <>
+struct PickBaseType<std::shared_ptr<const EXPRESS::DataType>>;
+
+// ------------------------------------------------------------------------------
+template <typename T>
+struct InternGenericConvert {
+    void operator()(T &out, const std::shared_ptr<const EXPRESS::DataType> &in, const STEP::DB & /*db*/) {
+        try {
+            out = dynamic_cast<const typename PickBaseType<T>::Type &>(*in);
+        } catch (std::bad_cast &) {
+            throw TypeError("type error reading literal field");
+        }
+    }
+};
+
+template <>
+struct InternGenericConvert<std::shared_ptr<const EXPRESS::DataType>> {
+    void operator()(std::shared_ptr<const EXPRESS::DataType> &out, const std::shared_ptr<const EXPRESS::DataType> &in, const STEP::DB & /*db*/) {
+        out = in;
+    }
+};
+
+template <typename T>
+struct InternGenericConvert<Maybe<T>> {
+    void operator()(Maybe<T> &out, const std::shared_ptr<const EXPRESS::DataType> &in, const STEP::DB &db) {
+        GenericConvert((T &)out, in, db);
+        out.flag_valid();
+    }
+};
+
+#if _MSC_VER > 1920
+#pragma warning(push)
+#pragma warning(disable : 4127)
+#endif // _WIN32
+
+template <typename T, uint64_t min_cnt, uint64_t max_cnt>
+struct InternGenericConvertList {
+    void operator()(ListOf<T, min_cnt, max_cnt> &out, const std::shared_ptr<const EXPRESS::DataType> &inp_base, const STEP::DB &db) {
+
+        const EXPRESS::LIST *inp = dynamic_cast<const EXPRESS::LIST *>(inp_base.get());
+        if (!inp) {
+            throw TypeError("type error reading aggregate");
+        }
+
+        // XXX is this really how the EXPRESS notation ([?:3],[1:3]) is intended?
+        const size_t len = inp->GetSize();
+        if (0 != max_cnt && len > max_cnt) {
+            ASSIMP_LOG_WARN("too many aggregate elements");
+        } else if (len < min_cnt) {
+            ASSIMP_LOG_WARN("too few aggregate elements");
+        }
+
+        out.reserve(inp->GetSize());
+        for (size_t i = 0; i < inp->GetSize(); ++i) {
+
+            out.push_back(typename ListOf<T, min_cnt, max_cnt>::OutScalar());
+            try {
+                GenericConvert(out.back(), (*inp)[i], db);
+            } catch (const TypeError &t) {
+                throw TypeError(t.what() + std::string(" of aggregate"));
+            }
+        }
+    }
+};
+
+template <typename T>
+struct InternGenericConvert<Lazy<T>> {
+    void operator()(Lazy<T> &out, const std::shared_ptr<const EXPRESS::DataType> &in_base, const STEP::DB &db) {
+        const EXPRESS::ENTITY *in = dynamic_cast<const EXPRESS::ENTITY *>(in_base.get());
+        if (!in) {
+            throw TypeError("type error reading entity");
+        }
+        out = Couple<T>(db).GetObject(*in);
+    }
+};
+
+template <typename T1>
+inline void GenericConvert(T1 &a, const std::shared_ptr<const EXPRESS::DataType> &b, const STEP::DB &db) {
+    return InternGenericConvert<T1>()(a, b, db);
+}
+
+template <typename T1, uint64_t N1, uint64_t N2>
+inline void GenericConvert(ListOf<T1, N1, N2> &a, const std::shared_ptr<const EXPRESS::DataType> &b, const STEP::DB &db) {
+    return InternGenericConvertList<T1, N1, N2>()(a, b, db);
+}
+
+// ------------------------------------------------------------------------------
+/** Lightweight manager class that holds the map of all objects in a
+     *  STEP file. DB's are exclusively maintained by the functions in
+     *  STEPFileReader.h*/
+// -------------------------------------------------------------------------------
+class DB {
+    friend DB *ReadFileHeader(std::shared_ptr<IOStream> stream);
+    friend void ReadFile(DB &db, const EXPRESS::ConversionSchema &scheme,
+            const char *const *types_to_track, size_t len,
+            const char *const *inverse_indices_to_track, size_t len2);
+
+    friend class LazyObject;
+
+public:
+    // objects indexed by ID - this can grow pretty large (i.e some hundred million
+    // entries), so use raw pointers to avoid *any* overhead.
+    typedef std::map<uint64_t, const LazyObject *> ObjectMap;
+
+    // objects indexed by their declarative type, but only for those that we truly want
+    typedef std::set<const LazyObject *> ObjectSet;
+    typedef std::map<std::string, ObjectSet> ObjectMapByType;
+
+    // list of types for which to keep inverse indices for all references
+    // that the respective objects keep.
+    // the list keeps pointers to strings in static storage
+    typedef std::set<const char *> InverseWhitelist;
+
+    // references - for each object id the ids of all objects which reference it
+    // this is used to simulate STEP inverse indices for selected types.
+    typedef std::step_unordered_multimap<uint64_t, uint64_t> RefMap;
+    typedef std::pair<RefMap::const_iterator, RefMap::const_iterator> RefMapRange;
+
+private:
+    DB(const std::shared_ptr<StreamReaderLE> &reader) :
+            reader(reader), splitter(*reader, true, true), evaluated_count(), schema(nullptr) {}
+
+public:
+    ~DB() {
+        for (ObjectMap::value_type &o : objects) {
+            delete o.second;
+        }
+    }
+
+    uint64_t GetObjectCount() const {
+        return objects.size();
+    }
+
+    uint64_t GetEvaluatedObjectCount() const {
+        return evaluated_count;
+    }
+
+    const HeaderInfo &GetHeader() const {
+        return header;
+    }
+
+    const EXPRESS::ConversionSchema &GetSchema() const {
+        return *schema;
+    }
+
+    const ObjectMap &GetObjects() const {
+        return objects;
+    }
+
+    const ObjectMapByType &GetObjectsByType() const {
+        return objects_bytype;
+    }
+
+    const RefMap &GetRefs() const {
+        return refs;
+    }
+
+    bool KeepInverseIndicesForType(const char *const type) const {
+        return inv_whitelist.find(type) != inv_whitelist.end();
+    }
+
+    // get the yet unevaluated object record with a given id
+    const LazyObject *GetObject(uint64_t id) const {
+        const ObjectMap::const_iterator it = objects.find(id);
+        if (it != objects.end()) {
+            return (*it).second;
+        }
+        return nullptr;
+    }
+
+    // get an arbitrary object out of the soup with the only restriction being its type.
+    const LazyObject *GetObject(const std::string &type) const {
+        const ObjectMapByType::const_iterator it = objects_bytype.find(type);
+        if (it != objects_bytype.end() && (*it).second.size()) {
+            return *(*it).second.begin();
+        }
+        return NULL;
+    }
+
+    // same, but raise an exception if the object doesn't exist and return a reference
+    const LazyObject &MustGetObject(uint64_t id) const {
+        const LazyObject *o = GetObject(id);
+        if (!o) {
+            throw TypeError("requested entity is not present", id);
+        }
+        return *o;
+    }
+
+    const LazyObject &MustGetObject(const std::string &type) const {
+        const LazyObject *o = GetObject(type);
+        if (!o) {
+            throw TypeError("requested entity of type " + type + "is not present");
+        }
+        return *o;
+    }
+
+#ifdef ASSIMP_IFC_TEST
+
+    // evaluate *all* entities in the file. this is a power test for the loader
+    void EvaluateAll() {
+        for (ObjectMap::value_type &e : objects) {
+            **e.second;
+        }
+        ai_assert(evaluated_count == objects.size());
+    }
+
+#endif
+
+private:
+    // full access only offered to close friends - they should
+    // use the provided getters rather than messing around with
+    // the members directly.
+    LineSplitter &GetSplitter() {
+        return splitter;
+    }
+
+    void InternInsert(const LazyObject *lz) {
+        objects[lz->GetID()] = lz;
+
+        const ObjectMapByType::iterator it = objects_bytype.find(lz->type);
+        if (it != objects_bytype.end()) {
+            (*it).second.insert(lz);
+        }
+    }
+
+    void SetSchema(const EXPRESS::ConversionSchema &_schema) {
+        schema = &_schema;
+    }
+
+    void SetTypesToTrack(const char *const *types, size_t N) {
+        for (size_t i = 0; i < N; ++i) {
+            objects_bytype[types[i]] = ObjectSet();
+        }
+    }
+
+    void SetInverseIndicesToTrack(const char *const *types, size_t N) {
+        for (size_t i = 0; i < N; ++i) {
+            const char *const sz = schema->GetStaticStringForToken(types[i]);
+            ai_assert(sz);
+            inv_whitelist.insert(sz);
+        }
+    }
+
+    HeaderInfo &GetHeader() {
+        return header;
+    }
+
+    void MarkRef(uint64_t who, uint64_t by_whom) {
+        refs.insert(std::make_pair(who, by_whom));
+    }
+
+private:
+    HeaderInfo header;
+    ObjectMap objects;
+    ObjectMapByType objects_bytype;
+    RefMap refs;
+    InverseWhitelist inv_whitelist;
+    std::shared_ptr<StreamReaderLE> reader;
+    LineSplitter splitter;
+    uint64_t evaluated_count;
+    const EXPRESS::ConversionSchema *schema;
+};
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif // _MSC_VER
+
+} // namespace STEP
+
+} // namespace Assimp
+
+#endif // INCLUDED_AI_STEPFILE_H
diff --git a/Engine/lib/assimp/code/Step/StepExporter.cpp b/Engine/lib/assimp/code/AssetLib/Step/StepExporter.cpp
similarity index 76%
rename from Engine/lib/assimp/code/Step/StepExporter.cpp
rename to Engine/lib/assimp/code/AssetLib/Step/StepExporter.cpp
index 70035d9ea..e13c9edab 100644
--- a/Engine/lib/assimp/code/Step/StepExporter.cpp
+++ b/Engine/lib/assimp/code/AssetLib/Step/StepExporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -45,7 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_EXPORT
 #ifndef ASSIMP_BUILD_NO_STEP_EXPORTER
 
-#include "Step/StepExporter.h"
+#include "AssetLib/Step/StepExporter.h"
 #include "PostProcessing/ConvertToLHProcess.h"
 
 #include <assimp/Bitmap.h>
@@ -75,12 +75,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef ASSIMP_STEP_USE_UNORDERED_MULTIMAP
 #   include <unordered_map>
-#   if _MSC_VER > 1600
-#       define step_unordered_map unordered_map
-#       define step_unordered_multimap unordered_multimap
-#   else
+#   if defined(_MSC_VER) && _MSC_VER <= 1600
 #       define step_unordered_map tr1::unordered_map
 #       define step_unordered_multimap tr1::unordered_multimap
+#   else
+#       define step_unordered_map unordered_map
+#       define step_unordered_multimap unordered_multimap
 #   endif
 #endif
 
@@ -108,7 +108,7 @@ void ExportSceneStep(const char* pFile,IOSystem* pIOSystem, const aiScene* pScen
 
     // we're still here - export successfully completed. Write result to the given IOSYstem
     std::unique_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wt"));
-    if(outfile == NULL) {
+    if (outfile == nullptr) {
         throw DeadlyExportError("could not open output .stp file: " + std::string(pFile));
     }
 
@@ -175,12 +175,11 @@ void StepExporter::WriteFile()
     fColor.b = 0.8f;
 
     int ind = 100; // the start index to be used
-    int faceEntryLen = 30; // number of entries for a triangle/face
+    std::vector<int> faceEntryLen; // numbers of entries for a triangle/face
     // prepare unique (count triangles and vertices)
 
     VectorIndexUMap uniqueVerts; // use a map to reduce find complexity to log(n)
     VectorIndexUMap::iterator it;
-    int countFace = 0;
 
     for (unsigned int i=0; i<mScene->mNumMeshes; ++i)
     {
@@ -189,7 +188,7 @@ void StepExporter::WriteFile()
         {
             aiFace* face = &(mesh->mFaces[j]);
 
-            if (face->mNumIndices == 3) countFace++;
+            if (face->mNumIndices >= 3) faceEntryLen.push_back(15 + 5 * face->mNumIndices);
         }
         for (unsigned int j=0; j<mesh->mNumVertices; ++j)
         {
@@ -204,7 +203,7 @@ void StepExporter::WriteFile()
 
     static const unsigned int date_nb_chars = 20;
     char date_str[date_nb_chars];
-    std::time_t date = std::time(NULL);
+    std::time_t date = std::time(nullptr);
     std::strftime(date_str, date_nb_chars, "%Y-%m-%dT%H:%M:%S", std::localtime(&date));
 
     // write the header
@@ -218,10 +217,13 @@ void StepExporter::WriteFile()
     // write the top of data
     mOutput << "DATA" << endstr;
     mOutput << "#1=MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION(' ',(";
-    for (int i=0; i<countFace; ++i)
+    size_t countFace = faceEntryLen.size();
+    size_t faceLenIndex = ind + 2 * uniqueVerts.size();
+    for (size_t i=0; i<countFace; ++i)
     {
-        mOutput << "#" << i*faceEntryLen + ind + 2*uniqueVerts.size();
+        mOutput << "#" << faceLenIndex;
         if (i!=countFace-1) mOutput << ",";
+        faceLenIndex += faceEntryLen[i];
     }
     mOutput << "),#6)" << endstr;
 
@@ -253,10 +255,12 @@ void StepExporter::WriteFile()
     mOutput << "#27=DIRECTION('',(1.0,0.0,0.0))" << endstr;
     mOutput << "#28= (NAMED_UNIT(#21)LENGTH_UNIT()SI_UNIT(.MILLI.,.METRE.))" << endstr;
     mOutput << "#29=CLOSED_SHELL('',(";
-    for (int i=0; i<countFace; ++i)
+    faceLenIndex = ind + 2 * uniqueVerts.size() + 8;
+    for (size_t i=0; i<countFace; ++i)
     {
-        mOutput << "#" << i*faceEntryLen + ind + 2*uniqueVerts.size() + 8;
+        mOutput << "#" << faceLenIndex;
         if (i!=countFace-1) mOutput << ",";
+        faceLenIndex += faceEntryLen[i];
     }
     mOutput << "))" << endstr;
 
@@ -289,23 +293,28 @@ void StepExporter::WriteFile()
         {
             aiFace* face = &(mesh->mFaces[j]);
 
-            if (face->mNumIndices != 3) continue;
+            const int numIndices = face->mNumIndices;
+            if (numIndices < 3) continue;
 
-            aiVector3D* v1 = &(mesh->mVertices[face->mIndices[0]]);
-            aiVector3D* v2 = &(mesh->mVertices[face->mIndices[1]]);
-            aiVector3D* v3 = &(mesh->mVertices[face->mIndices[2]]);
-            aiVector3D dv12 = *v2 - *v1;
-            aiVector3D dv23 = *v3 - *v2;
-            aiVector3D dv31 = *v1 - *v3;
-            aiVector3D dv13 = *v3 - *v1;
-            dv12.Normalize();
-            dv23.Normalize();
-            dv31.Normalize();
-            dv13.Normalize();
+            std::vector<int> pidArray(numIndices, -1); // vertex id
+            std::vector<aiVector3D> dvArray(numIndices); // edge dir
+            for (int k = 0; k < numIndices; ++k)
+            {
+                aiVector3D *v1 = &(mesh->mVertices[face->mIndices[k]]);
+                pidArray[k] = uniqueVerts.find(v1)->second;
 
-            int pid1 = uniqueVerts.find(v1)->second;
-            int pid2 = uniqueVerts.find(v2)->second;
-            int pid3 = uniqueVerts.find(v3)->second;
+                aiVector3D *v2 = nullptr;
+                if (k + 1 == numIndices)
+                    v2 = &(mesh->mVertices[face->mIndices[0]]);
+                else
+                    v2 = &(mesh->mVertices[face->mIndices[k + 1]]);
+                dvArray[k] = *v2 - *v1;
+                dvArray[k].Normalize();
+            }
+
+            aiVector3D dvY = dvArray[1];
+            aiVector3D dvX = dvY ^ dvArray[0];
+            dvX.Normalize();
 
             // mean vertex color for the face if available
             if (mesh->HasVertexColors(0))
@@ -335,35 +344,62 @@ void StepExporter::WriteFile()
 
             /* 2 directions of the plane */
             mOutput << "#" << sid+9 << "=PLANE('',#" << sid+10 << ")" << endstr;
-            mOutput << "#" << sid+10 << "=AXIS2_PLACEMENT_3D('',#" << pid1 << ", #" << sid+11 << ",#" << sid+12 << ")" << endstr;
+            mOutput << "#" << sid+10 << "=AXIS2_PLACEMENT_3D('',#" << pidArray[0] << ",#" << sid+11 << ",#" << sid+12 << ")" << endstr;
 
-            mOutput << "#" << sid+11 << "=DIRECTION('',(" << dv12.x << "," << dv12.y << "," << dv12.z << "))" << endstr;
-            mOutput << "#" << sid+12 << "=DIRECTION('',(" << dv13.x << "," << dv13.y << "," << dv13.z << "))" << endstr;
+            mOutput << "#" << sid + 11 << "=DIRECTION('',(" << dvX.x << "," << dvX.y << "," << dvX.z << "))" << endstr;
+            mOutput << "#" << sid + 12 << "=DIRECTION('',(" << dvY.x << "," << dvY.y << "," << dvY.z << "))" << endstr;
 
             mOutput << "#" << sid+13 << "=FACE_BOUND('',#" << sid+14 << ",.T.)" << endstr;
-            mOutput << "#" << sid+14 << "=EDGE_LOOP('',(#" << sid+15 << ",#" << sid+16 << ",#" << sid+17 << "))" << endstr;
+            mOutput << "#" << sid+14 << "=EDGE_LOOP('',(";
+            int edgeLoopStart = sid + 15;
+            for (int k = 0; k < numIndices; ++k)
+            {
+                if (k == 0)
+                    mOutput << "#";
+                else
+                    mOutput << ",#";
+                mOutput << edgeLoopStart + k;
+            }
+            mOutput << "))" << endstr;
 
             /* edge loop  */
-            mOutput << "#" << sid+15 << "=ORIENTED_EDGE('',*,*,#" << sid+18 << ",.T.)" << endstr;
-            mOutput << "#" << sid+16 << "=ORIENTED_EDGE('',*,*,#" << sid+19 << ",.T.)" << endstr;
-            mOutput << "#" << sid+17 << "=ORIENTED_EDGE('',*,*,#" << sid+20 << ",.T.)" << endstr;
+            int orientedEdgesStart = edgeLoopStart + numIndices;
+            for (int k=0; k < numIndices; k++)
+            {
+                mOutput << "#" << edgeLoopStart+k << "=ORIENTED_EDGE('',*,*,#" << orientedEdgesStart + k << ",.T.)" << endstr;
+            }
 
             /* oriented edges */
-            mOutput << "#" << sid+18 << "=EDGE_CURVE('',#" << pid1+1 << ",#" << pid2+1 << ",#" << sid+21 << ",.F.)" << endstr;
-            mOutput << "#" << sid+19 << "=EDGE_CURVE('',#" << pid2+1 << ",#" << pid3+1 << ",#" << sid+22 << ",.T.)" << endstr;
-            mOutput << "#" << sid+20 << "=EDGE_CURVE('',#" << pid3+1 << ",#" << pid1+1 << ",#" << sid+23 << ",.T.)" << endstr;
+            int lineStart = orientedEdgesStart + numIndices;
+            for (int k=0; k < numIndices; ++k)
+            {
+                if (k == 0)
+                    mOutput << "#" << orientedEdgesStart+k << "=EDGE_CURVE('',#" << pidArray[k]+1 << ",#" << pidArray[k+1]+1 << ",#" << lineStart+k << ",.F.)" << endstr;
+                else if (k+1 == numIndices)
+                    mOutput << "#" << orientedEdgesStart+k << "=EDGE_CURVE('',#" << pidArray[k]+1 << ",#" << pidArray[0]+1 << ",#" << lineStart+k << ",.T.)" << endstr;
+                else
+                    mOutput << "#" << orientedEdgesStart+k << "=EDGE_CURVE('',#" << pidArray[k]+1 << ",#" << pidArray[k+1]+1 << ",#" << lineStart+k << ",.T.)" << endstr;
+            }
 
-            /* 3 lines and 3 vectors for the lines for the 3 edge curves */
-            mOutput << "#" << sid+21 << "=LINE('',#" << pid1 << ",#" << sid+24 << ")" << endstr;
-            mOutput << "#" << sid+22 << "=LINE('',#" << pid2 << ",#" << sid+25 << ")" << endstr;
-            mOutput << "#" << sid+23 << "=LINE('',#" << pid3 << ",#" << sid+26 << ")" << endstr;
-            mOutput << "#" << sid+24 << "=VECTOR('',#" << sid+27 << ",1.0)" << endstr;
-            mOutput << "#" << sid+25 << "=VECTOR('',#" << sid+28 << ",1.0)" << endstr;
-            mOutput << "#" << sid+26 << "=VECTOR('',#" << sid+29 << ",1.0)" << endstr;
-            mOutput << "#" << sid+27 << "=DIRECTION('',(" << dv12.x << "," << dv12.y << "," << dv12.z << "))" << endstr;
-            mOutput << "#" << sid+28 << "=DIRECTION('',(" << dv23.x << "," << dv23.y << "," << dv23.z << "))" << endstr;
-            mOutput << "#" << sid+29 << "=DIRECTION('',(" << dv31.x << "," << dv31.y << "," << dv31.z << "))" << endstr;
-            ind += faceEntryLen; // increase counter
+            /* n lines and n vectors for the lines for the n edge curves */
+            int vectorStart = lineStart + numIndices;
+            for (int k=0; k < numIndices; ++k)
+            {
+                mOutput << "#" << lineStart+k << "=LINE('',#" << pidArray[k] << ",#" << vectorStart+k << ")" << endstr;
+            }
+
+            int directionStart = vectorStart + numIndices;
+            for (int k=0; k < numIndices; ++k)
+            {
+                mOutput << "#" << vectorStart+k << "=VECTOR('',#" << directionStart+k << ",1.0)" << endstr;
+            }
+
+            for (int k=0; k < numIndices; ++k)
+            {
+                const aiVector3D &dv = dvArray[k];
+                mOutput << "#" << directionStart + k << "=DIRECTION('',(" << dv.x << "," << dv.y << "," << dv.z << "))" << endstr;
+            }
+            ind += 15 + 5*numIndices; // increase counter
         }
     }
 
diff --git a/Engine/lib/assimp/code/Step/StepExporter.h b/Engine/lib/assimp/code/AssetLib/Step/StepExporter.h
similarity index 98%
rename from Engine/lib/assimp/code/Step/StepExporter.h
rename to Engine/lib/assimp/code/AssetLib/Step/StepExporter.h
index f96a0d2b5..a02262659 100644
--- a/Engine/lib/assimp/code/Step/StepExporter.h
+++ b/Engine/lib/assimp/code/AssetLib/Step/StepExporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Terragen/TerragenLoader.cpp b/Engine/lib/assimp/code/AssetLib/Terragen/TerragenLoader.cpp
similarity index 58%
rename from Engine/lib/assimp/code/Terragen/TerragenLoader.cpp
rename to Engine/lib/assimp/code/AssetLib/Terragen/TerragenLoader.cpp
index 9b0873c68..c9c91db8f 100644
--- a/Engine/lib/assimp/code/Terragen/TerragenLoader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/Terragen/TerragenLoader.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,17 +41,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** @file Implementation of the Terragen importer class */
 
-
-
 #ifndef ASSIMP_BUILD_NO_TERRAGEN_IMPORTER
 
 #include "TerragenLoader.h"
 #include <assimp/StreamReader.h>
-#include <assimp/Importer.hpp>
-#include <assimp/IOSystem.hpp>
+#include <assimp/importerdesc.h>
 #include <assimp/scene.h>
 #include <assimp/DefaultLogger.hpp>
-#include <assimp/importerdesc.h>
+#include <assimp/IOSystem.hpp>
+#include <assimp/Importer.hpp>
 
 using namespace Assimp;
 
@@ -72,78 +68,62 @@ static const aiImporterDesc desc = {
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-TerragenImporter::TerragenImporter()
-: configComputeUVs (false)
-{}
+TerragenImporter::TerragenImporter() :
+        configComputeUVs(false) {
+    // empty
+}
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-TerragenImporter::~TerragenImporter()
-{}
+TerragenImporter::~TerragenImporter() {
+    // empty
+}
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool TerragenImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
-{
-    // check file extension
-    std::string extension = GetExtension(pFile);
-
-    if( extension == "ter")
-        return true;
-
-    if(  !extension.length() || checkSig)   {
-        /*  If CanRead() is called in order to check whether we
-         *  support a specific file extension in general pIOHandler
-         *  might be NULL and it's our duty to return true here.
-         */
-        if (!pIOHandler)return true;
-        const char* tokens[] = {"terragen"};
-        return SearchFileHeaderForToken(pIOHandler,pFile,tokens,1);
-    }
-    return false;
+bool TerragenImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
+    static const char *tokens[] = { "terragen" };
+    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------
 // Build a string of all file extensions supported
-const aiImporterDesc* TerragenImporter::GetInfo () const
-{
+const aiImporterDesc *TerragenImporter::GetInfo() const {
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup import properties
-void TerragenImporter::SetupProperties(const Importer* pImp)
-{
+void TerragenImporter::SetupProperties(const Importer *pImp) {
     // AI_CONFIG_IMPORT_TER_MAKE_UVS
-    configComputeUVs = ( 0 != pImp->GetPropertyInteger(AI_CONFIG_IMPORT_TER_MAKE_UVS,0) );
+    configComputeUVs = (0 != pImp->GetPropertyInteger(AI_CONFIG_IMPORT_TER_MAKE_UVS, 0));
 }
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void TerragenImporter::InternReadFile( const std::string& pFile,
-    aiScene* pScene, IOSystem* pIOHandler)
-{
-    IOStream* file = pIOHandler->Open( pFile, "rb");
+void TerragenImporter::InternReadFile(const std::string &pFile,
+        aiScene *pScene, IOSystem *pIOHandler) {
+    IOStream *file = pIOHandler->Open(pFile, "rb");
 
     // Check whether we can read from the file
-    if( file == NULL)
-        throw DeadlyImportError( "Failed to open TERRAGEN TERRAIN file " + pFile + ".");
+    if (file == nullptr)
+        throw DeadlyImportError("Failed to open TERRAGEN TERRAIN file ", pFile, ".");
 
     // Construct a stream reader to read all data in the correct endianness
     StreamReaderLE reader(file);
-    if(reader.GetRemainingSize() < 16)
-        throw DeadlyImportError( "TER: file is too small" );
+    if (reader.GetRemainingSize() < 16)
+        throw DeadlyImportError("TER: file is too small");
 
     // Check for the existence of the two magic strings 'TERRAGEN' and 'TERRAIN '
-    if (::strncmp((const char*)reader.GetPtr(),AI_TERR_BASE_STRING,8))
-        throw DeadlyImportError( "TER: Magic string \'TERRAGEN\' not found" );
+    if (::strncmp((const char *)reader.GetPtr(), AI_TERR_BASE_STRING, 8))
+        throw DeadlyImportError("TER: Magic string \'TERRAGEN\' not found");
 
-    if (::strncmp((const char*)reader.GetPtr()+8,AI_TERR_TERRAIN_STRING,8))
-        throw DeadlyImportError( "TER: Magic string \'TERRAIN\' not found" );
+    if (::strncmp((const char *)reader.GetPtr() + 8, AI_TERR_TERRAIN_STRING, 8))
+        throw DeadlyImportError("TER: Magic string \'TERRAIN\' not found");
 
-    unsigned int x = 0,y = 0,mode = 0;
+    unsigned int x = 0, y = 0, mode = 0;
 
-    aiNode* root = pScene->mRootNode = new aiNode();
+    aiNode *root = pScene->mRootNode = new aiNode();
     root->mName.Set("<TERRAGEN.TERRAIN>");
 
     // Default scaling is 30
@@ -151,104 +131,98 @@ void TerragenImporter::InternReadFile( const std::string& pFile,
 
     // Now read all chunks until we're finished or an EOF marker is encountered
     reader.IncPtr(16);
-    while (reader.GetRemainingSize() >= 4)
-    {
-        const char* head = (const char*)reader.GetPtr();
+    while (reader.GetRemainingSize() >= 4) {
+        const char *head = (const char *)reader.GetPtr();
         reader.IncPtr(4);
 
         // EOF, break in every case
-        if (!::strncmp(head,AI_TERR_EOF_STRING,4))
+        if (!::strncmp(head, AI_TERR_EOF_STRING, 4))
             break;
 
         // Number of x-data points
-        if (!::strncmp(head,AI_TERR_CHUNK_XPTS,4))
-        {
+        if (!::strncmp(head, AI_TERR_CHUNK_XPTS, 4)) {
             x = (uint16_t)reader.GetI2();
         }
         // Number of y-data points
-        else if (!::strncmp(head,AI_TERR_CHUNK_YPTS,4))
-        {
+        else if (!::strncmp(head, AI_TERR_CHUNK_YPTS, 4)) {
             y = (uint16_t)reader.GetI2();
         }
         // Squared terrains width-1.
-        else if (!::strncmp(head,AI_TERR_CHUNK_SIZE,4))
-        {
-            x = y = (uint16_t)reader.GetI2()+1;
+        else if (!::strncmp(head, AI_TERR_CHUNK_SIZE, 4)) {
+            x = y = (uint16_t)reader.GetI2() + 1;
         }
         // terrain scaling
-        else if (!::strncmp(head,AI_TERR_CHUNK_SCAL,4))
-        {
+        else if (!::strncmp(head, AI_TERR_CHUNK_SCAL, 4)) {
             root->mTransformation.a1 = reader.GetF4();
             root->mTransformation.b2 = reader.GetF4();
             root->mTransformation.c3 = reader.GetF4();
         }
         // mapping == 1: earth radius
-        else if (!::strncmp(head,AI_TERR_CHUNK_CRAD,4))
-        {
+        else if (!::strncmp(head, AI_TERR_CHUNK_CRAD, 4)) {
             reader.GetF4();
         }
         // mapping mode
-        else if (!::strncmp(head,AI_TERR_CHUNK_CRVM,4))
-        {
+        else if (!::strncmp(head, AI_TERR_CHUNK_CRVM, 4)) {
             mode = reader.GetI1();
             if (0 != mode)
                 ASSIMP_LOG_ERROR("TER: Unsupported mapping mode, a flat terrain is returned");
         }
         // actual terrain data
-        else if (!::strncmp(head,AI_TERR_CHUNK_ALTW,4))
-        {
-            float hscale  = (float)reader.GetI2()  / 65536;
+        else if (!::strncmp(head, AI_TERR_CHUNK_ALTW, 4)) {
+            float hscale = (float)reader.GetI2() / 65536;
             float bheight = (float)reader.GetI2();
 
-            if (!hscale)hscale = 1;
+            if (!hscale) hscale = 1;
 
             // Ensure we have enough data
-            if (reader.GetRemainingSize() < x*y*2)
+            if (reader.GetRemainingSize() < x * y * 2)
                 throw DeadlyImportError("TER: ALTW chunk is too small");
 
             if (x <= 1 || y <= 1)
                 throw DeadlyImportError("TER: Invalid terrain size");
 
             // Allocate the output mesh
-            pScene->mMeshes = new aiMesh*[pScene->mNumMeshes = 1];
-            aiMesh* m = pScene->mMeshes[0] = new aiMesh();
+            pScene->mMeshes = new aiMesh *[pScene->mNumMeshes = 1];
+            aiMesh *m = pScene->mMeshes[0] = new aiMesh();
 
             // We return quads
-            aiFace* f = m->mFaces = new aiFace[m->mNumFaces = (x-1)*(y-1)];
-            aiVector3D* pv = m->mVertices = new aiVector3D[m->mNumVertices = m->mNumFaces*4];
+            aiFace *f = m->mFaces = new aiFace[m->mNumFaces = (x - 1) * (y - 1)];
+            aiVector3D *pv = m->mVertices = new aiVector3D[m->mNumVertices = m->mNumFaces * 4];
 
-            aiVector3D *uv( NULL );
-            float step_y( 0.0f ), step_x( 0.0f );
+            aiVector3D *uv(nullptr);
+            float step_y(0.0f), step_x(0.0f);
             if (configComputeUVs) {
                 uv = m->mTextureCoords[0] = new aiVector3D[m->mNumVertices];
-                step_y = 1.f/y;
-                step_x = 1.f/x;
+                step_y = 1.f / y;
+                step_x = 1.f / x;
             }
-            const int16_t* data = (const int16_t*)reader.GetPtr();
+            const int16_t *data = (const int16_t *)reader.GetPtr();
 
-            for (unsigned int yy = 0, t = 0; yy < y-1;++yy) {
-                for (unsigned int xx = 0; xx < x-1;++xx,++f)    {
+            for (unsigned int yy = 0, t = 0; yy < y - 1; ++yy) {
+                for (unsigned int xx = 0; xx < x - 1; ++xx, ++f) {
 
                     // make verts
                     const float fy = (float)yy, fx = (float)xx;
-                    unsigned tmp,tmp2;
-                    *pv++ = aiVector3D(fx,fy,    (float)data[(tmp2=x*yy)    + xx] * hscale + bheight);
-                    *pv++ = aiVector3D(fx,fy+1,  (float)data[(tmp=x*(yy+1)) + xx] * hscale + bheight);
-                    *pv++ = aiVector3D(fx+1,fy+1,(float)data[tmp  + xx+1]         * hscale + bheight);
-                    *pv++ = aiVector3D(fx+1,fy,  (float)data[tmp2 + xx+1]         * hscale + bheight);
+                    unsigned tmp, tmp2;
+                    *pv++ = aiVector3D(fx, fy, (float)data[(tmp2 = x * yy) + xx] * hscale + bheight);
+                    *pv++ = aiVector3D(fx, fy + 1, (float)data[(tmp = x * (yy + 1)) + xx] * hscale + bheight);
+                    *pv++ = aiVector3D(fx + 1, fy + 1, (float)data[tmp + xx + 1] * hscale + bheight);
+                    *pv++ = aiVector3D(fx + 1, fy, (float)data[tmp2 + xx + 1] * hscale + bheight);
 
                     // also make texture coordinates, if necessary
                     if (configComputeUVs) {
-                        *uv++ = aiVector3D( step_x*xx,     step_y*yy,     0.f );
-                        *uv++ = aiVector3D( step_x*xx,     step_y*(yy+1), 0.f );
-                        *uv++ = aiVector3D( step_x*(xx+1), step_y*(yy+1), 0.f );
-                        *uv++ = aiVector3D( step_x*(xx+1), step_y*yy,     0.f );
+                        *uv++ = aiVector3D(step_x * xx, step_y * yy, 0.f);
+                        *uv++ = aiVector3D(step_x * xx, step_y * (yy + 1), 0.f);
+                        *uv++ = aiVector3D(step_x * (xx + 1), step_y * (yy + 1), 0.f);
+                        *uv++ = aiVector3D(step_x * (xx + 1), step_y * yy, 0.f);
                     }
 
                     // make indices
                     f->mIndices = new unsigned int[f->mNumIndices = 4];
-                    for (unsigned int i = 0; i < 4;++i)
-                        f->mIndices[i] = t++;
+                    for (unsigned int i = 0; i < 4; ++i) {
+                        f->mIndices[i] = t;
+                        t++;
+                    }
                 }
             }
 
@@ -258,9 +232,10 @@ void TerragenImporter::InternReadFile( const std::string& pFile,
         }
 
         // Get to the next chunk (4 byte aligned)
-        unsigned dtt;
-        if ((dtt = reader.GetCurrentPos() & 0x3))
-            reader.IncPtr(4-dtt);
+        unsigned dtt = reader.GetCurrentPos();
+        if (dtt & 0x3) {
+            reader.IncPtr(4 - dtt);
+        }
     }
 
     // Check whether we have a mesh now
diff --git a/Engine/lib/assimp/code/Terragen/TerragenLoader.h b/Engine/lib/assimp/code/AssetLib/Terragen/TerragenLoader.h
similarity index 75%
rename from Engine/lib/assimp/code/Terragen/TerragenLoader.h
rename to Engine/lib/assimp/code/AssetLib/Terragen/TerragenLoader.h
index a478c0dcd..cb9ff9166 100644
--- a/Engine/lib/assimp/code/Terragen/TerragenLoader.h
+++ b/Engine/lib/assimp/code/AssetLib/Terragen/TerragenLoader.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,25 +42,27 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file  TerragenLoader.h
  *  @brief Declaration of the .ter importer class.
  */
+#pragma once
 #ifndef INCLUDED_AI_TERRAGEN_TERRAIN_LOADER_H
 #define INCLUDED_AI_TERRAGEN_TERRAIN_LOADER_H
 
 #include <assimp/BaseImporter.h>
-namespace Assimp    {
+
+namespace Assimp {
 
 // Magic strings
-#define AI_TERR_BASE_STRING         "TERRAGEN"
-#define AI_TERR_TERRAIN_STRING      "TERRAIN "
-#define AI_TERR_EOF_STRING          "EOF "
+#define AI_TERR_BASE_STRING "TERRAGEN"
+#define AI_TERR_TERRAIN_STRING "TERRAIN "
+#define AI_TERR_EOF_STRING "EOF "
 
 // Chunka
-#define AI_TERR_CHUNK_XPTS          "XPTS"
-#define AI_TERR_CHUNK_YPTS          "YPTS"
-#define AI_TERR_CHUNK_SIZE          "SIZE"
-#define AI_TERR_CHUNK_SCAL          "SCAL"
-#define AI_TERR_CHUNK_CRAD          "CRAD"
-#define AI_TERR_CHUNK_CRVM          "CRVM"
-#define AI_TERR_CHUNK_ALTW          "ALTW"
+#define AI_TERR_CHUNK_XPTS "XPTS"
+#define AI_TERR_CHUNK_YPTS "YPTS"
+#define AI_TERR_CHUNK_SIZE "SIZE"
+#define AI_TERR_CHUNK_SCAL "SCAL"
+#define AI_TERR_CHUNK_CRAD "CRAD"
+#define AI_TERR_CHUNK_CRVM "CRVM"
+#define AI_TERR_CHUNK_ALTW "ALTW"
 
 // ---------------------------------------------------------------------------
 /** @brief Importer class to load Terragen (0.9) terrain files.
@@ -69,33 +70,27 @@ namespace Assimp    {
  *  The loader is basing on the information found here:
  *  http://www.planetside.co.uk/terragen/dev/tgterrain.html#chunks
 */
-class TerragenImporter : public BaseImporter
-{
+class TerragenImporter : public BaseImporter {
 public:
     TerragenImporter();
-    ~TerragenImporter();
-
-
-public:
+    ~TerragenImporter() override;
 
     // -------------------------------------------------------------------
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
+            bool checkSig) const override;
 
 protected:
+    // -------------------------------------------------------------------
+    const aiImporterDesc *GetInfo() const override;
 
     // -------------------------------------------------------------------
-    const aiImporterDesc* GetInfo () const;
+    void InternReadFile(const std::string &pFile, aiScene *pScene,
+            IOSystem *pIOHandler) override;
 
     // -------------------------------------------------------------------
-    void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
-
-    // -------------------------------------------------------------------
-    void SetupProperties(const Importer* pImp);
+    void SetupProperties(const Importer *pImp) override;
 
 private:
-
     bool configComputeUVs;
 
 }; //! class TerragenImporter
diff --git a/Engine/lib/assimp/code/Unreal/UnrealLoader.cpp b/Engine/lib/assimp/code/AssetLib/Unreal/UnrealLoader.cpp
similarity index 53%
rename from Engine/lib/assimp/code/Unreal/UnrealLoader.cpp
rename to Engine/lib/assimp/code/AssetLib/Unreal/UnrealLoader.cpp
index 0bd4650d0..661952b3d 100644
--- a/Engine/lib/assimp/code/Unreal/UnrealLoader.cpp
+++ b/Engine/lib/assimp/code/AssetLib/Unreal/UnrealLoader.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -48,26 +46,112 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *    http://local.wasp.uwa.edu.au/~pbourke/dataformats/unreal/
  */
 
-
-
 #ifndef ASSIMP_BUILD_NO_3D_IMPORTER
 
-#include "Unreal/UnrealLoader.h"
+#include "AssetLib/Unreal/UnrealLoader.h"
 #include "PostProcessing/ConvertToLHProcess.h"
 
-#include <assimp/StreamReader.h>
 #include <assimp/ParsingUtils.h>
+#include <assimp/StreamReader.h>
 #include <assimp/fast_atof.h>
-#include <assimp/Importer.hpp>
+#include <assimp/importerdesc.h>
+#include <assimp/scene.h>
 #include <assimp/DefaultLogger.hpp>
 #include <assimp/IOSystem.hpp>
-#include <assimp/scene.h>
-#include <assimp/importerdesc.h>
+#include <assimp/Importer.hpp>
 
+#include <cstdint>
 #include <memory>
 
 using namespace Assimp;
 
+namespace Unreal {
+
+/*
+    0 = Normal one-sided
+    1 = Normal two-sided
+    2 = Translucent two-sided
+    3 = Masked two-sided
+    4 = Modulation blended two-sided
+    8 = Placeholder triangle for weapon positioning (invisible)
+*/
+enum MeshFlags {
+    MF_NORMAL_OS = 0,
+    MF_NORMAL_TS = 1,
+    MF_NORMAL_TRANS_TS = 2,
+    MF_NORMAL_MASKED_TS = 3,
+    MF_NORMAL_MOD_TS = 4,
+    MF_WEAPON_PLACEHOLDER = 8
+};
+
+// a single triangle
+struct Triangle {
+    uint16_t mVertex[3]; // Vertex indices
+    char mType; // James' Mesh Type
+    char mColor; // Color for flat and Gourand Shaded
+    unsigned char mTex[3][2]; // Texture UV coordinates
+    unsigned char mTextureNum; // Source texture offset
+    char mFlags; // Unreal Mesh Flags (unused)
+    unsigned int matIndex;
+};
+
+// temporary representation for a material
+struct TempMat {
+    TempMat() :
+            type(MF_NORMAL_OS), tex(), numFaces(0) {}
+
+    explicit TempMat(const Triangle &in) :
+            type((Unreal::MeshFlags)in.mType), tex(in.mTextureNum), numFaces(0) {}
+
+    // type of mesh
+    Unreal::MeshFlags type;
+
+    // index of texture
+    unsigned int tex;
+
+    // number of faces using us
+    unsigned int numFaces;
+
+    // for std::find
+    bool operator==(const TempMat &o) {
+        return (tex == o.tex && type == o.type);
+    }
+};
+
+struct Vertex {
+    int32_t X : 11;
+    int32_t Y : 11;
+    int32_t Z : 10;
+};
+
+// UNREAL vertex compression
+inline void CompressVertex(const aiVector3D &v, uint32_t &out) {
+    union {
+        Vertex n;
+        int32_t t;
+    };
+    t = 0;
+    n.X = (int32_t)v.x;
+    n.Y = (int32_t)v.y;
+    n.Z = (int32_t)v.z;
+    ::memcpy(&out, &t, sizeof(int32_t));
+}
+
+// UNREAL vertex decompression
+inline void DecompressVertex(aiVector3D &v, int32_t in) {
+    union {
+        Vertex n;
+        int32_t i;
+    };
+    i = in;
+
+    v.x = (float)n.X;
+    v.y = (float)n.Y;
+    v.z = (float)n.Z;
+}
+
+} // end namespace Unreal
+
 static const aiImporterDesc desc = {
     "Unreal Mesh Importer",
     "",
@@ -81,81 +165,76 @@ static const aiImporterDesc desc = {
     "3d uc"
 };
 
-
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-UnrealImporter::UnrealImporter()
-:   configFrameID   (0)
-,   configHandleFlags (true)
-{}
+UnrealImporter::UnrealImporter() :
+        mConfigFrameID(0), mConfigHandleFlags(true) {
+    // empty
+}
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-UnrealImporter::~UnrealImporter()
-{}
+UnrealImporter::~UnrealImporter() {
+    // empty
+}
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool UnrealImporter::CanRead( const std::string& pFile, IOSystem* /*pIOHandler*/, bool /*checkSig*/) const
-{
-    return  SimpleExtensionCheck(pFile,"3d","uc");
+bool UnrealImporter::CanRead(const std::string & filename, IOSystem * /*pIOHandler*/, bool /*checkSig*/) const {
+    return SimpleExtensionCheck(filename, "3d", "uc");
 }
 
 // ------------------------------------------------------------------------------------------------
 // Build a string of all file extensions supported
-const aiImporterDesc* UnrealImporter::GetInfo () const
-{
+const aiImporterDesc *UnrealImporter::GetInfo() const {
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup configuration properties for the loader
-void UnrealImporter::SetupProperties(const Importer* pImp)
-{
+void UnrealImporter::SetupProperties(const Importer *pImp) {
     // The
     // AI_CONFIG_IMPORT_UNREAL_KEYFRAME option overrides the
     // AI_CONFIG_IMPORT_GLOBAL_KEYFRAME option.
-    configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_UNREAL_KEYFRAME,-1);
-    if(static_cast<unsigned int>(-1) == configFrameID)  {
-        configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_GLOBAL_KEYFRAME,0);
+    mConfigFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_UNREAL_KEYFRAME, -1);
+    if (static_cast<unsigned int>(-1) == mConfigFrameID) {
+        mConfigFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_GLOBAL_KEYFRAME, 0);
     }
 
     // AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS, default is true
-    configHandleFlags = (0 != pImp->GetPropertyInteger(AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS,1));
+    mConfigHandleFlags = (0 != pImp->GetPropertyInteger(AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS, 1));
 }
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void UnrealImporter::InternReadFile( const std::string& pFile,
-    aiScene* pScene, IOSystem* pIOHandler)
-{
+void UnrealImporter::InternReadFile(const std::string &pFile,
+        aiScene *pScene, IOSystem *pIOHandler) {
     // For any of the 3 files being passed get the three correct paths
     // First of all, determine file extension
     std::string::size_type pos = pFile.find_last_of('.');
     std::string extension = GetExtension(pFile);
 
-    std::string d_path,a_path,uc_path;
-    if (extension == "3d")      {
+    std::string d_path, a_path, uc_path;
+    if (extension == "3d") {
         // jjjj_d.3d
         // jjjj_a.3d
         pos = pFile.find_last_of('_');
         if (std::string::npos == pos) {
             throw DeadlyImportError("UNREAL: Unexpected naming scheme");
         }
-        extension = pFile.substr(0,pos);
-    }
-    else {
-        extension = pFile.substr(0,pos);
+        extension = pFile.substr(0, pos);
+    } else {
+        extension = pFile.substr(0, pos);
     }
 
     // build proper paths
-    d_path  = extension+"_d.3d";
-    a_path  = extension+"_a.3d";
-    uc_path = extension+".uc";
+    d_path = extension + "_d.3d";
+    a_path = extension + "_a.3d";
+    uc_path = extension + ".uc";
 
-    ASSIMP_LOG_DEBUG_F( "UNREAL: data file is ", d_path);
-    ASSIMP_LOG_DEBUG_F("UNREAL: aniv file is ", a_path);
-    ASSIMP_LOG_DEBUG_F("UNREAL: uc file is ", uc_path);
+    ASSIMP_LOG_DEBUG("UNREAL: data file is ", d_path);
+    ASSIMP_LOG_DEBUG("UNREAL: aniv file is ", a_path);
+    ASSIMP_LOG_DEBUG("UNREAL: uc file is ", uc_path);
 
     // and open the files ... we can't live without them
     std::unique_ptr<IOStream> p(pIOHandler->Open(d_path));
@@ -174,11 +253,11 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
 
     // collect triangles
     std::vector<Unreal::Triangle> triangles(numTris);
-    for (auto & tri : triangles) {
-        for (unsigned int i = 0; i < 3;++i) {
+    for (auto &tri : triangles) {
+        for (unsigned int i = 0; i < 3; ++i) {
 
             tri.mVertex[i] = d_reader.GetI2();
-            if (tri.mVertex[i] >= numTris)  {
+            if (tri.mVertex[i] >= numTris) {
                 ASSIMP_LOG_WARN("UNREAL: vertex index out of range");
                 tri.mVertex[i] = 0;
             }
@@ -186,7 +265,7 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
         tri.mType = d_reader.GetI1();
 
         // handle mesh flagss?
-        if (configHandleFlags)
+        if (mConfigHandleFlags)
             tri.mType = Unreal::MF_NORMAL_OS;
         else {
             // ignore MOD and MASKED for the moment, treat them as two-sided
@@ -195,12 +274,12 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
         }
         d_reader.IncPtr(1);
 
-        for (unsigned int i = 0; i < 3;++i)
-            for (unsigned int i2 = 0; i2 < 2;++i2)
+        for (unsigned int i = 0; i < 3; ++i)
+            for (unsigned int i2 = 0; i2 < 2; ++i2)
                 tri.mTex[i][i2] = d_reader.GetI1();
 
         tri.mTextureNum = d_reader.GetI1();
-        maxTexIdx = std::max(maxTexIdx,(unsigned int)tri.mTextureNum);
+        maxTexIdx = std::max(maxTexIdx, (unsigned int)tri.mTextureNum);
         d_reader.IncPtr(1);
     }
 
@@ -211,62 +290,64 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
 
     // read number of frames
     const uint32_t numFrames = a_reader.GetI2();
-    if (configFrameID >= numFrames)
+    if (mConfigFrameID >= numFrames) {
         throw DeadlyImportError("UNREAL: The requested frame does not exist");
+    }
 
     uint32_t st = a_reader.GetI2();
-    if (st != numVert*4)
+    if (st != numVert * 4u)
         throw DeadlyImportError("UNREAL: Unexpected aniv file length");
 
     // skip to our frame
-    a_reader.IncPtr(configFrameID *numVert*4);
+    a_reader.IncPtr(mConfigFrameID * numVert * 4);
 
     // collect vertices
     std::vector<aiVector3D> vertices(numVert);
-    for (auto &vertex : vertices)    {
+    for (auto &vertex : vertices) {
         int32_t val = a_reader.GetI4();
-        Unreal::DecompressVertex(vertex ,val);
+        Unreal::DecompressVertex(vertex, val);
     }
 
     // list of textures.
-    std::vector< std::pair<unsigned int, std::string> > textures;
+    std::vector<std::pair<unsigned int, std::string>> textures;
 
     // allocate the output scene
-    aiNode* nd = pScene->mRootNode = new aiNode();
+    aiNode *nd = pScene->mRootNode = new aiNode();
     nd->mName.Set("<UnrealRoot>");
 
     // we can live without the uc file if necessary
-    std::unique_ptr<IOStream> pb (pIOHandler->Open(uc_path));
-    if (pb.get())   {
+    std::unique_ptr<IOStream> pb(pIOHandler->Open(uc_path));
+    if (pb.get()) {
 
         std::vector<char> _data;
-        TextFileToBuffer(pb.get(),_data);
-        const char* data = &_data[0];
+        TextFileToBuffer(pb.get(), _data);
+        const char *data = &_data[0];
 
-        std::vector< std::pair< std::string,std::string > > tempTextures;
+        std::vector<std::pair<std::string, std::string>> tempTextures;
 
         // do a quick search in the UC file for some known, usually texture-related, tags
-        for (;*data;++data) {
-            if (TokenMatchI(data,"#exec",5))    {
+        for (; *data; ++data) {
+            if (TokenMatchI(data, "#exec", 5)) {
                 SkipSpacesAndLineEnd(&data);
 
                 // #exec TEXTURE IMPORT [...] NAME=jjjjj [...] FILE=jjjj.pcx [...]
-                if (TokenMatchI(data,"TEXTURE",7))  {
+                if (TokenMatchI(data, "TEXTURE", 7)) {
                     SkipSpacesAndLineEnd(&data);
 
-                    if (TokenMatchI(data,"IMPORT",6))   {
-                        tempTextures.push_back(std::pair< std::string,std::string >());
-                        std::pair< std::string,std::string >& me = tempTextures.back();
-                        for (;!IsLineEnd(*data);++data) {
-                            if (!::ASSIMP_strincmp(data,"NAME=",5)) {
-                                const char *d = data+=5;
-                                for (;!IsSpaceOrNewLine(*data);++data);
-                                me.first = std::string(d,(size_t)(data-d));
-                            }
-                            else if (!::ASSIMP_strincmp(data,"FILE=",5))    {
-                                const char *d = data+=5;
-                                for (;!IsSpaceOrNewLine(*data);++data);
-                                me.second = std::string(d,(size_t)(data-d));
+                    if (TokenMatchI(data, "IMPORT", 6)) {
+                        tempTextures.push_back(std::pair<std::string, std::string>());
+                        std::pair<std::string, std::string> &me = tempTextures.back();
+                        for (; !IsLineEnd(*data); ++data) {
+                            if (!::ASSIMP_strincmp(data, "NAME=", 5)) {
+                                const char *d = data += 5;
+                                for (; !IsSpaceOrNewLine(*data); ++data)
+                                    ;
+                                me.first = std::string(d, (size_t)(data - d));
+                            } else if (!::ASSIMP_strincmp(data, "FILE=", 5)) {
+                                const char *d = data += 5;
+                                for (; !IsSpaceOrNewLine(*data); ++data)
+                                    ;
+                                me.second = std::string(d, (size_t)(data - d));
                             }
                         }
                         if (!me.first.length() || !me.second.length())
@@ -275,65 +356,61 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
                 }
                 // #exec MESHMAP SETTEXTURE MESHMAP=box NUM=1 TEXTURE=Jtex1
                 // #exec MESHMAP SCALE MESHMAP=box X=0.1 Y=0.1 Z=0.2
-                else if (TokenMatchI(data,"MESHMAP",7)) {
+                else if (TokenMatchI(data, "MESHMAP", 7)) {
                     SkipSpacesAndLineEnd(&data);
 
-                    if (TokenMatchI(data,"SETTEXTURE",10)) {
+                    if (TokenMatchI(data, "SETTEXTURE", 10)) {
 
                         textures.push_back(std::pair<unsigned int, std::string>());
-                        std::pair<unsigned int, std::string>& me = textures.back();
+                        std::pair<unsigned int, std::string> &me = textures.back();
 
-                        for (;!IsLineEnd(*data);++data) {
-                            if (!::ASSIMP_strincmp(data,"NUM=",4))  {
+                        for (; !IsLineEnd(*data); ++data) {
+                            if (!::ASSIMP_strincmp(data, "NUM=", 4)) {
                                 data += 4;
-                                me.first = strtoul10(data,&data);
-                            }
-                            else if (!::ASSIMP_strincmp(data,"TEXTURE=",8)) {
+                                me.first = strtoul10(data, &data);
+                            } else if (!::ASSIMP_strincmp(data, "TEXTURE=", 8)) {
                                 data += 8;
                                 const char *d = data;
-                                for (;!IsSpaceOrNewLine(*data);++data);
-                                me.second = std::string(d,(size_t)(data-d));
+                                for (; !IsSpaceOrNewLine(*data); ++data)
+                                    ;
+                                me.second = std::string(d, (size_t)(data - d));
 
                                 // try to find matching path names, doesn't care if we don't find them
-                                for (std::vector< std::pair< std::string,std::string > >::const_iterator it = tempTextures.begin();
-                                     it != tempTextures.end(); ++it)    {
-                                    if ((*it).first == me.second)   {
+                                for (std::vector<std::pair<std::string, std::string>>::const_iterator it = tempTextures.begin();
+                                        it != tempTextures.end(); ++it) {
+                                    if ((*it).first == me.second) {
                                         me.second = (*it).second;
                                         break;
                                     }
                                 }
                             }
                         }
-                    }
-                    else if (TokenMatchI(data,"SCALE",5)) {
+                    } else if (TokenMatchI(data, "SCALE", 5)) {
 
-                        for (;!IsLineEnd(*data);++data) {
-                            if (data[0] == 'X' && data[1] == '=')   {
-                                data = fast_atoreal_move<float>(data+2,(float&)nd->mTransformation.a1);
-                            }
-                            else if (data[0] == 'Y' && data[1] == '=')  {
-                                data = fast_atoreal_move<float>(data+2,(float&)nd->mTransformation.b2);
-                            }
-                            else if (data[0] == 'Z' && data[1] == '=')  {
-                                data = fast_atoreal_move<float>(data+2,(float&)nd->mTransformation.c3);
+                        for (; !IsLineEnd(*data); ++data) {
+                            if (data[0] == 'X' && data[1] == '=') {
+                                data = fast_atoreal_move<float>(data + 2, (float &)nd->mTransformation.a1);
+                            } else if (data[0] == 'Y' && data[1] == '=') {
+                                data = fast_atoreal_move<float>(data + 2, (float &)nd->mTransformation.b2);
+                            } else if (data[0] == 'Z' && data[1] == '=') {
+                                data = fast_atoreal_move<float>(data + 2, (float &)nd->mTransformation.c3);
                             }
                         }
                     }
                 }
             }
         }
-    }
-    else    {
+    } else {
         ASSIMP_LOG_ERROR("Unable to open .uc file");
     }
 
     std::vector<Unreal::TempMat> materials;
-    materials.reserve(textures.size()*2+5);
+    materials.reserve(textures.size() * 2 + 5);
 
     // find out how many output meshes and materials we'll have and build material indices
-	for (Unreal::Triangle &tri : triangles) {
+    for (Unreal::Triangle &tri : triangles) {
         Unreal::TempMat mat(tri);
-        std::vector<Unreal::TempMat>::iterator nt = std::find(materials.begin(),materials.end(),mat);
+        std::vector<Unreal::TempMat>::iterator nt = std::find(materials.begin(), materials.end(), mat);
         if (nt == materials.end()) {
             // add material
             tri.matIndex = static_cast<unsigned int>(materials.size());
@@ -341,9 +418,8 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
             materials.push_back(mat);
 
             ++pScene->mNumMeshes;
-        }
-        else {
-            tri.matIndex = static_cast<unsigned int>(nt-materials.begin());
+        } else {
+            tri.matIndex = static_cast<unsigned int>(nt - materials.begin());
             ++nt->numFaces;
         }
     }
@@ -353,65 +429,65 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
     }
 
     // allocate meshes and bind them to the node graph
-    pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];
-    pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials = pScene->mNumMeshes];
+    pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
+    pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials = pScene->mNumMeshes];
 
-    nd->mNumMeshes  = pScene->mNumMeshes;
+    nd->mNumMeshes = pScene->mNumMeshes;
     nd->mMeshes = new unsigned int[nd->mNumMeshes];
-    for (unsigned int i = 0; i < pScene->mNumMeshes;++i) {
-        aiMesh* m = pScene->mMeshes[i] =  new aiMesh();
+    for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
+        aiMesh *m = pScene->mMeshes[i] = new aiMesh();
         m->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
 
         const unsigned int num = materials[i].numFaces;
-        m->mFaces            = new aiFace     [num];
-        m->mVertices         = new aiVector3D [num*3];
-        m->mTextureCoords[0] = new aiVector3D [num*3];
+        m->mFaces = new aiFace[num];
+        m->mVertices = new aiVector3D[num * 3];
+        m->mTextureCoords[0] = new aiVector3D[num * 3];
 
         nd->mMeshes[i] = i;
 
         // create materials, too
-        aiMaterial* mat = new aiMaterial();
+        aiMaterial *mat = new aiMaterial();
         pScene->mMaterials[i] = mat;
 
         // all white by default - texture rulez
-        aiColor3D color(1.f,1.f,1.f);
+        aiColor3D color(1.f, 1.f, 1.f);
 
         aiString s;
-        ::ai_snprintf( s.data, MAXLEN, "mat%u_tx%u_",i,materials[i].tex );
+        ::ai_snprintf(s.data, MAXLEN, "mat%u_tx%u_", i, materials[i].tex);
 
         // set the two-sided flag
         if (materials[i].type == Unreal::MF_NORMAL_TS) {
             const int twosided = 1;
-            mat->AddProperty(&twosided,1,AI_MATKEY_TWOSIDED);
-            ::strcat(s.data,"ts_");
-        }
-        else ::strcat(s.data,"os_");
+            mat->AddProperty(&twosided, 1, AI_MATKEY_TWOSIDED);
+            ::strcat(s.data, "ts_");
+        } else
+            ::strcat(s.data, "os_");
 
         // make TRANS faces 90% opaque that RemRedundantMaterials won't catch us
-        if (materials[i].type == Unreal::MF_NORMAL_TRANS_TS)    {
+        if (materials[i].type == Unreal::MF_NORMAL_TRANS_TS) {
             const float opac = 0.9f;
-            mat->AddProperty(&opac,1,AI_MATKEY_OPACITY);
-            ::strcat(s.data,"tran_");
-        }
-        else ::strcat(s.data,"opaq_");
+            mat->AddProperty(&opac, 1, AI_MATKEY_OPACITY);
+            ::strcat(s.data, "tran_");
+        } else
+            ::strcat(s.data, "opaq_");
 
         // a special name for the weapon attachment point
         if (materials[i].type == Unreal::MF_WEAPON_PLACEHOLDER) {
-            s.length = ::ai_snprintf( s.data, MAXLEN, "$WeaponTag$" );
-            color = aiColor3D(0.f,0.f,0.f);
+            s.length = ::ai_snprintf(s.data, MAXLEN, "$WeaponTag$");
+            color = aiColor3D(0.f, 0.f, 0.f);
         }
 
         // set color and name
-        mat->AddProperty(&color,1,AI_MATKEY_COLOR_DIFFUSE);
-        s.length = ::strlen(s.data);
-        mat->AddProperty(&s,AI_MATKEY_NAME);
+        mat->AddProperty(&color, 1, AI_MATKEY_COLOR_DIFFUSE);
+        s.length = static_cast<ai_uint32>(::strlen(s.data));
+        mat->AddProperty(&s, AI_MATKEY_NAME);
 
         // set texture, if any
         const unsigned int tex = materials[i].tex;
-        for (std::vector< std::pair< unsigned int, std::string > >::const_iterator it = textures.begin();it != textures.end();++it) {
+        for (std::vector<std::pair<unsigned int, std::string>>::const_iterator it = textures.begin(); it != textures.end(); ++it) {
             if ((*it).first == tex) {
                 s.Set((*it).second);
-                mat->AddProperty(&s,AI_MATKEY_TEXTURE_DIFFUSE(0));
+                mat->AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(0));
                 break;
             }
         }
@@ -420,17 +496,17 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
     // fill them.
     for (const Unreal::Triangle &tri : triangles) {
         Unreal::TempMat mat(tri);
-        std::vector<Unreal::TempMat>::iterator nt = std::find(materials.begin(),materials.end(),mat);
+        std::vector<Unreal::TempMat>::iterator nt = std::find(materials.begin(), materials.end(), mat);
 
-        aiMesh* mesh = pScene->mMeshes[nt-materials.begin()];
-        aiFace& f    = mesh->mFaces[mesh->mNumFaces++];
-        f.mIndices   = new unsigned int[f.mNumIndices = 3];
+        aiMesh *mesh = pScene->mMeshes[nt - materials.begin()];
+        aiFace &f = mesh->mFaces[mesh->mNumFaces++];
+        f.mIndices = new unsigned int[f.mNumIndices = 3];
 
-        for (unsigned int i = 0; i < 3;++i,mesh->mNumVertices++) {
+        for (unsigned int i = 0; i < 3; ++i, mesh->mNumVertices++) {
             f.mIndices[i] = mesh->mNumVertices;
 
-            mesh->mVertices[mesh->mNumVertices] = vertices[ tri.mVertex[i] ];
-            mesh->mTextureCoords[0][mesh->mNumVertices] = aiVector3D( tri.mTex[i][0] / 255.f, 1.f - tri.mTex[i][1] / 255.f, 0.f);
+            mesh->mVertices[mesh->mNumVertices] = vertices[tri.mVertex[i]];
+            mesh->mTextureCoords[0][mesh->mNumVertices] = aiVector3D(tri.mTex[i][0] / 255.f, 1.f - tri.mTex[i][1] / 255.f, 0.f);
         }
     }
 
diff --git a/Engine/lib/assimp/code/Unreal/UnrealLoader.h b/Engine/lib/assimp/code/AssetLib/Unreal/UnrealLoader.h
similarity index 52%
rename from Engine/lib/assimp/code/Unreal/UnrealLoader.h
rename to Engine/lib/assimp/code/AssetLib/Unreal/UnrealLoader.h
index 678aaa76b..a931a86dd 100644
--- a/Engine/lib/assimp/code/Unreal/UnrealLoader.h
+++ b/Engine/lib/assimp/code/AssetLib/Unreal/UnrealLoader.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -47,161 +46,57 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define INCLUDED_AI_3D_LOADER_H
 
 #include <assimp/BaseImporter.h>
-#include <stdint.h>
 
-namespace Assimp    {
-namespace Unreal {
-
-    /*
-    0 = Normal one-sided
-    1 = Normal two-sided
-    2 = Translucent two-sided
-    3 = Masked two-sided
-    4 = Modulation blended two-sided
-    8 = Placeholder triangle for weapon positioning (invisible)
-    */
-enum MeshFlags {
-    MF_NORMAL_OS            = 0,
-    MF_NORMAL_TS            = 1,
-    MF_NORMAL_TRANS_TS      = 2,
-    MF_NORMAL_MASKED_TS     = 3,
-    MF_NORMAL_MOD_TS        = 4,
-    MF_WEAPON_PLACEHOLDER   = 8
-};
-
-    // a single triangle
-struct Triangle {
-   uint16_t mVertex[3];       // Vertex indices
-   char mType;                // James' Mesh Type
-   char mColor;               // Color for flat and Gourand Shaded
-   unsigned char mTex[3][2];  // Texture UV coordinates
-   unsigned char mTextureNum; // Source texture offset
-   char mFlags;               // Unreal Mesh Flags (unused)
-
-   unsigned int matIndex;
-};
-
-// temporary representation for a material
-struct TempMat  {
-    TempMat()
-        :   type()
-        ,   tex()
-        ,   numFaces    (0)
-    {}
-
-    explicit TempMat(const Triangle& in)
-        :   type        ((Unreal::MeshFlags)in.mType)
-        ,   tex         (in.mTextureNum)
-        ,   numFaces    (0)
-    {}
-
-    // type of mesh
-    Unreal::MeshFlags type;
-
-    // index of texture
-    unsigned int tex;
-
-    // number of faces using us
-    unsigned int numFaces;
-
-    // for std::find
-    bool operator == (const TempMat& o )    {
-        return (tex == o.tex && type == o.type);
-    }
-};
-
-struct Vertex
-{
-    int32_t X : 11;
-    int32_t Y : 11;
-    int32_t Z : 10;
-};
-
-    // UNREAL vertex compression
-inline void CompressVertex(const aiVector3D& v, uint32_t& out)
-{
-    union {
-        Vertex n;
-        int32_t t;
-    };
-    n.X = (int32_t)v.x;
-    n.Y = (int32_t)v.y;
-    n.Z = (int32_t)v.z;
-    ::memcpy( &out, &t, sizeof(int32_t));
-    //out = t;
-}
-
-    // UNREAL vertex decompression
-inline void DecompressVertex(aiVector3D& v, int32_t in)
-{
-    union {
-        Vertex n;
-        int32_t i;
-    };
-    i = in;
-
-    v.x = (float)n.X;
-    v.y = (float)n.Y;
-    v.z = (float)n.Z;
-}
-
-} // end namespace Unreal
+namespace Assimp {
 
 // ---------------------------------------------------------------------------
-/** @brief Importer class to load UNREAL files (*.3d)
-*/
-class UnrealImporter : public BaseImporter
-{
+/**
+ *  @brief Importer class to load UNREAL files (*.3d)
+ */
+class UnrealImporter : public BaseImporter {
 public:
     UnrealImporter();
     ~UnrealImporter();
 
-
-public:
-
     // -------------------------------------------------------------------
     /** @brief Returns whether we can handle the format of the given file
      *
      *  See BaseImporter::CanRead() for details.
      **/
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const override;
 
 protected:
-
     // -------------------------------------------------------------------
     /** @brief Called by Importer::GetExtensionList()
      *
-     * See #BaseImporter::GetInfo for the details
+     * @see #BaseImporter::GetInfo for the details
      */
-    const aiImporterDesc* GetInfo () const;
-
+    const aiImporterDesc *GetInfo() const override;
 
     // -------------------------------------------------------------------
     /** @brief Setup properties for the importer
      *
      * See BaseImporter::SetupProperties() for details
      */
-    void SetupProperties(const Importer* pImp);
-
+    void SetupProperties(const Importer *pImp) override;
 
     // -------------------------------------------------------------------
     /** @brief Imports the given file into the given scene structure.
      *
      * See BaseImporter::InternReadFile() for details
      */
-    void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
+    void InternReadFile(const std::string &pFile, aiScene *pScene,
+            IOSystem *pIOHandler) override;
 
 private:
-
     //! frame to be loaded
-    uint32_t configFrameID;
+    uint32_t mConfigFrameID;
 
     //! process surface flags
-    bool configHandleFlags;
+    bool mConfigHandleFlags;
 
 }; // !class UnrealImporter
 
 } // end of namespace Assimp
+
 #endif // AI_UNREALIMPORTER_H_INC
diff --git a/Engine/lib/assimp/code/X/XFileExporter.cpp b/Engine/lib/assimp/code/AssetLib/X/XFileExporter.cpp
similarity index 99%
rename from Engine/lib/assimp/code/X/XFileExporter.cpp
rename to Engine/lib/assimp/code/AssetLib/X/XFileExporter.cpp
index ae9fd58fc..f0b1608c1 100644
--- a/Engine/lib/assimp/code/X/XFileExporter.cpp
+++ b/Engine/lib/assimp/code/AssetLib/X/XFileExporter.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -45,7 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_EXPORT
 #ifndef ASSIMP_BUILD_NO_X_EXPORTER
 
-#include "X/XFileExporter.h"
+#include "AssetLib/X/XFileExporter.h"
 #include "PostProcessing/ConvertToLHProcess.h"
 
 #include <assimp/Bitmap.h>
@@ -86,10 +86,10 @@ void ExportSceneXFile(const char* pFile,IOSystem* pIOSystem, const aiScene* pSce
     if (iDoTheExportThing.mOutput.fail()) {
         throw DeadlyExportError("output data creation failed. Most likely the file became too large: " + std::string(pFile));
     }
-    
+
     // we're still here - export successfully completed. Write result to the given IOSYstem
     std::unique_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wt"));
-    if(outfile == NULL) {
+    if (outfile == nullptr) {
         throw DeadlyExportError("could not open output .x file: " + std::string(pFile));
     }
 
@@ -530,8 +530,8 @@ void XFileExporter::writePath(const aiString &path)
     while( str.find( "\\\\") != std::string::npos)
         str.replace( str.find( "\\\\"), 2, "\\");
 
-    while( str.find( "\\") != std::string::npos)
-        str.replace( str.find( "\\"), 1, "/");
+    while (str.find('\\') != std::string::npos)
+        str.replace(str.find('\\'), 1, "/");
 
     mOutput << str;
 
diff --git a/Engine/lib/assimp/code/X/XFileExporter.h b/Engine/lib/assimp/code/AssetLib/X/XFileExporter.h
similarity index 96%
rename from Engine/lib/assimp/code/X/XFileExporter.h
rename to Engine/lib/assimp/code/AssetLib/X/XFileExporter.h
index 322440af8..1d9a5ae77 100644
--- a/Engine/lib/assimp/code/X/XFileExporter.h
+++ b/Engine/lib/assimp/code/AssetLib/X/XFileExporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -94,9 +94,9 @@ protected:
     void PushTag() { startstr.append( "  "); }
 
     /// Leaves an element, decreasing the indentation
-    void PopTag() { 
-        ai_assert( startstr.length() > 1); 
-        startstr.erase( startstr.length() - 2); 
+    void PopTag() {
+        ai_assert( startstr.length() > 1);
+        startstr.erase( startstr.length() - 2);
     }
 
 public:
diff --git a/Engine/lib/assimp/code/X/XFileHelper.h b/Engine/lib/assimp/code/AssetLib/X/XFileHelper.h
similarity index 72%
rename from Engine/lib/assimp/code/X/XFileHelper.h
rename to Engine/lib/assimp/code/AssetLib/X/XFileHelper.h
index 0365280f0..3830eb483 100644
--- a/Engine/lib/assimp/code/X/XFileHelper.h
+++ b/Engine/lib/assimp/code/AssetLib/X/XFileHelper.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -40,20 +40,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
-
 /** @file Defines the helper data structures for importing XFiles */
 #ifndef AI_XFILEHELPER_H_INC
 #define AI_XFILEHELPER_H_INC
 
+#include <cstdint>
 #include <string>
 #include <vector>
-#include <stdint.h>
 
-#include <assimp/types.h>
-#include <assimp/quaternion.h>
-#include <assimp/mesh.h>
 #include <assimp/anim.h>
-#include <assimp/Defines.h>
+#include <assimp/mesh.h>
+#include <assimp/quaternion.h>
+#include <assimp/types.h>
 
 namespace Assimp {
 namespace XFile {
@@ -68,14 +66,13 @@ struct TexEntry {
     std::string mName;
     bool mIsNormalMap; // true if the texname was specified in a NormalmapFilename tag
 
-    TexEntry() AI_NO_EXCEPT
-    : mName()
-    , mIsNormalMap(false) {
+    TexEntry() AI_NO_EXCEPT :
+            mName(),
+            mIsNormalMap(false) {
         // empty
     }
-    TexEntry(const std::string& pName, bool pIsNormalMap = false)
-    : mName(pName)
-    , mIsNormalMap(pIsNormalMap) {
+    TexEntry(const std::string &pName, bool pIsNormalMap = false) :
+            mName(pName), mIsNormalMap(pIsNormalMap) {
         // empty
     }
 };
@@ -91,10 +88,10 @@ struct Material {
     std::vector<TexEntry> mTextures;
     size_t sceneIndex; ///< the index under which it was stored in the scene's material list
 
-    Material() AI_NO_EXCEPT
-    : mIsReference(false)
-    , mSpecularExponent()
-    , sceneIndex(SIZE_MAX) {
+    Material() AI_NO_EXCEPT :
+            mIsReference(false),
+            mSpecularExponent(),
+            sceneIndex(SIZE_MAX) {
         // empty
     }
 };
@@ -106,8 +103,7 @@ struct BoneWeight {
 };
 
 /** Helper structure to represent a bone in a mesh */
-struct Bone
-{
+struct Bone {
     std::string mName;
     std::vector<BoneWeight> mWeights;
     aiMatrix4x4 mOffsetMatrix;
@@ -130,19 +126,19 @@ struct Mesh {
 
     std::vector<Bone> mBones;
 
-    explicit Mesh(const std::string &pName = "") AI_NO_EXCEPT
-    : mName( pName )
-    , mPositions()
-    , mPosFaces()
-    , mNormals()
-    , mNormFaces()
-    , mNumTextures(0)
-    , mTexCoords{}
-    , mNumColorSets(0)
-    , mColors{}
-    , mFaceMaterials()
-    , mMaterials()
-    , mBones() {
+    explicit Mesh(const std::string &pName = std::string()) AI_NO_EXCEPT
+            : mName(pName),
+              mPositions(),
+              mPosFaces(),
+              mNormals(),
+              mNormFaces(),
+              mNumTextures(0),
+              mTexCoords{},
+              mNumColorSets(0),
+              mColors{},
+              mFaceMaterials(),
+              mMaterials(),
+              mBones() {
         // empty
     }
 };
@@ -151,29 +147,25 @@ struct Mesh {
 struct Node {
     std::string mName;
     aiMatrix4x4 mTrafoMatrix;
-    Node* mParent;
-    std::vector<Node*> mChildren;
-    std::vector<Mesh*> mMeshes;
+    Node *mParent;
+    std::vector<Node *> mChildren;
+    std::vector<Mesh *> mMeshes;
 
     Node() AI_NO_EXCEPT
-    : mName()
-    , mTrafoMatrix()
-    , mParent(nullptr)
-    , mChildren()
-    , mMeshes() {
+            : mName(),
+              mTrafoMatrix(),
+              mParent(nullptr),
+              mChildren(),
+              mMeshes() {
         // empty
     }
-    explicit Node( Node* pParent)
-    : mName()
-    , mTrafoMatrix()
-    , mParent(pParent)
-    , mChildren()
-    , mMeshes() {
+    explicit Node(Node *pParent) :
+            mName(), mTrafoMatrix(), mParent(pParent), mChildren(), mMeshes() {
         // empty
     }
 
     ~Node() {
-        for (unsigned int a = 0; a < mChildren.size(); ++a ) {
+        for (unsigned int a = 0; a < mChildren.size(); ++a) {
             delete mChildren[a];
         }
         for (unsigned int a = 0; a < mMeshes.size(); ++a) {
@@ -190,50 +182,47 @@ struct MatrixKey {
 /** Helper structure representing a single animated bone in a XFile */
 struct AnimBone {
     std::string mBoneName;
-    std::vector<aiVectorKey> mPosKeys;  // either three separate key sequences for position, rotation, scaling
+    std::vector<aiVectorKey> mPosKeys; // either three separate key sequences for position, rotation, scaling
     std::vector<aiQuatKey> mRotKeys;
     std::vector<aiVectorKey> mScaleKeys;
     std::vector<MatrixKey> mTrafoKeys; // or a combined key sequence of transformation matrices.
 };
 
 /** Helper structure to represent an animation set in a XFile */
-struct Animation
-{
+struct Animation {
     std::string mName;
-    std::vector<AnimBone*> mAnims;
+    std::vector<AnimBone *> mAnims;
 
-    ~Animation()
-    {
-        for( unsigned int a = 0; a < mAnims.size(); a++)
+    ~Animation() {
+        for (unsigned int a = 0; a < mAnims.size(); a++)
             delete mAnims[a];
     }
 };
 
 /** Helper structure analogue to aiScene */
-struct Scene
-{
-    Node* mRootNode;
+struct Scene {
+    Node *mRootNode;
 
-    std::vector<Mesh*> mGlobalMeshes; // global meshes found outside of any frames
+    std::vector<Mesh *> mGlobalMeshes; // global meshes found outside of any frames
     std::vector<Material> mGlobalMaterials; // global materials found outside of any meshes.
 
-    std::vector<Animation*> mAnims;
+    std::vector<Animation *> mAnims;
     unsigned int mAnimTicksPerSecond;
 
     Scene() AI_NO_EXCEPT
-    : mRootNode(nullptr)
-    , mGlobalMeshes()
-    , mGlobalMaterials()
-    , mAnimTicksPerSecond(0) {
+            : mRootNode(nullptr),
+              mGlobalMeshes(),
+              mGlobalMaterials(),
+              mAnimTicksPerSecond(0) {
         // empty
     }
     ~Scene() {
         delete mRootNode;
         mRootNode = nullptr;
-        for (unsigned int a = 0; a < mGlobalMeshes.size(); ++a ) {
+        for (unsigned int a = 0; a < mGlobalMeshes.size(); ++a) {
             delete mGlobalMeshes[a];
         }
-        for (unsigned int a = 0; a < mAnims.size(); ++a ) {
+        for (unsigned int a = 0; a < mAnims.size(); ++a) {
             delete mAnims[a];
         }
     }
diff --git a/Engine/lib/assimp/code/X/XFileImporter.cpp b/Engine/lib/assimp/code/AssetLib/X/XFileImporter.cpp
similarity index 93%
rename from Engine/lib/assimp/code/X/XFileImporter.cpp
rename to Engine/lib/assimp/code/AssetLib/X/XFileImporter.cpp
index be7256d5c..d23eb576c 100644
--- a/Engine/lib/assimp/code/X/XFileImporter.cpp
+++ b/Engine/lib/assimp/code/AssetLib/X/XFileImporter.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -44,12 +44,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_X_IMPORTER
 
-#include "X/XFileImporter.h"
-#include "X/XFileParser.h"
+#include "AssetLib/X/XFileImporter.h"
+#include "AssetLib/X/XFileParser.h"
 #include "PostProcessing/ConvertToLHProcess.h"
 
 #include <assimp/TinyFormatter.h>
-#include <assimp/Defines.h>
 #include <assimp/IOSystem.hpp>
 #include <assimp/scene.h>
 #include <assimp/DefaultLogger.hpp>
@@ -89,17 +88,9 @@ XFileImporter::~XFileImporter() {
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool XFileImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const {
-    std::string extension = GetExtension(pFile);
-    if(extension == "x") {
-        return true;
-    }
-    if (!extension.length() || checkSig) {
-        uint32_t token[1];
-        token[0] = AI_MAKE_MAGIC("xof ");
-        return CheckMagicToken(pIOHandler,pFile,token,1,0);
-    }
-    return false;
+bool XFileImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/) const {
+    static const uint32_t token[] = { AI_MAKE_MAGIC("xof ") };
+    return CheckMagicToken(pIOHandler,pFile,token,AI_COUNT_OF(token));
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -113,8 +104,8 @@ const aiImporterDesc* XFileImporter::GetInfo () const {
 void XFileImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) {
     // read file into memory
     std::unique_ptr<IOStream> file( pIOHandler->Open( pFile));
-    if ( file.get() == NULL ) {
-        throw DeadlyImportError( "Failed to open file " + pFile + "." );
+    if ( file.get() == nullptr ) {
+        throw DeadlyImportError( "Failed to open file ", pFile, "." );
     }
 
     static const size_t MinSize = 16;
@@ -211,7 +202,7 @@ aiNode* XFileImporter::CreateNodes( aiScene* pScene, aiNode* pParent, const XFil
 
     // create node
     aiNode* node = new aiNode;
-    node->mName.length = pNode->mName.length();
+    node->mName.length = (ai_uint32)pNode->mName.length();
     node->mParent = pParent;
     memcpy( node->mName.data, pNode->mName.c_str(), pNode->mName.length());
     node->mName.data[node->mName.length] = 0;
@@ -220,7 +211,7 @@ aiNode* XFileImporter::CreateNodes( aiScene* pScene, aiNode* pParent, const XFil
     // convert meshes from the source node
     CreateMeshes( pScene, node, pNode->mMeshes);
 
-    // handle childs
+    // handle children
     if( !pNode->mChildren.empty() ) {
         node->mNumChildren = (unsigned int)pNode->mChildren.size();
         node->mChildren = new aiNode* [node->mNumChildren];
@@ -513,30 +504,36 @@ void XFileImporter::CreateAnimations( aiScene* pScene, const XFile::Scene* pData
             } else {
                 // separate key sequences for position, rotation, scaling
                 nbone->mNumPositionKeys = (unsigned int)bone->mPosKeys.size();
-                nbone->mPositionKeys = new aiVectorKey[nbone->mNumPositionKeys];
-                for( unsigned int c = 0; c < nbone->mNumPositionKeys; ++c ) {
-                    aiVector3D pos = bone->mPosKeys[c].mValue;
+                if (nbone->mNumPositionKeys != 0) {
+                    nbone->mPositionKeys = new aiVectorKey[nbone->mNumPositionKeys];
+                    for( unsigned int c = 0; c < nbone->mNumPositionKeys; ++c ) {
+                        aiVector3D pos = bone->mPosKeys[c].mValue;
 
-                    nbone->mPositionKeys[c].mTime = bone->mPosKeys[c].mTime;
-                    nbone->mPositionKeys[c].mValue = pos;
+                        nbone->mPositionKeys[c].mTime = bone->mPosKeys[c].mTime;
+                        nbone->mPositionKeys[c].mValue = pos;
+                    }
                 }
 
                 // rotation
                 nbone->mNumRotationKeys = (unsigned int)bone->mRotKeys.size();
-                nbone->mRotationKeys = new aiQuatKey[nbone->mNumRotationKeys];
-                for( unsigned int c = 0; c < nbone->mNumRotationKeys; ++c ) {
-                    aiMatrix3x3 rotmat = bone->mRotKeys[c].mValue.GetMatrix();
+                if (nbone->mNumRotationKeys != 0) {
+                    nbone->mRotationKeys = new aiQuatKey[nbone->mNumRotationKeys];
+                    for( unsigned int c = 0; c < nbone->mNumRotationKeys; ++c ) {
+                        aiMatrix3x3 rotmat = bone->mRotKeys[c].mValue.GetMatrix();
 
-                    nbone->mRotationKeys[c].mTime = bone->mRotKeys[c].mTime;
-                    nbone->mRotationKeys[c].mValue = aiQuaternion( rotmat);
-                    nbone->mRotationKeys[c].mValue.w *= -1.0f; // needs quat inversion
+                        nbone->mRotationKeys[c].mTime = bone->mRotKeys[c].mTime;
+                        nbone->mRotationKeys[c].mValue = aiQuaternion( rotmat);
+                        nbone->mRotationKeys[c].mValue.w *= -1.0f; // needs quat inversion
+                    }
                 }
 
                 // scaling
                 nbone->mNumScalingKeys = (unsigned int)bone->mScaleKeys.size();
-                nbone->mScalingKeys = new aiVectorKey[nbone->mNumScalingKeys];
-                for( unsigned int c = 0; c < nbone->mNumScalingKeys; c++)
-                    nbone->mScalingKeys[c] = bone->mScaleKeys[c];
+                if (nbone->mNumScalingKeys != 0) {
+                    nbone->mScalingKeys = new aiVectorKey[nbone->mNumScalingKeys];
+                    for( unsigned int c = 0; c < nbone->mNumScalingKeys; c++)
+                        nbone->mScalingKeys[c] = bone->mScaleKeys[c];
+                }
 
                 // longest lasting key sequence determines duration
                 if( bone->mPosKeys.size() > 0)
@@ -586,9 +583,9 @@ void XFileImporter::ConvertMaterials( aiScene* pScene, std::vector<XFile::Materi
         XFile::Material& oldMat = pMaterials[a];
         if( oldMat.mIsReference) {
             // find the material it refers to by name, and store its index
-            for( size_t a = 0; a < pScene->mNumMaterials; ++a ) {
+            for( size_t b = 0; b < pScene->mNumMaterials; ++b ) {
                 aiString name;
-                pScene->mMaterials[a]->Get( AI_MATKEY_NAME, name);
+                pScene->mMaterials[b]->Get( AI_MATKEY_NAME, name);
                 if( strcmp( name.C_Str(), oldMat.mName.data()) == 0 ) {
                     oldMat.sceneIndex = a;
                     break;
@@ -596,7 +593,7 @@ void XFileImporter::ConvertMaterials( aiScene* pScene, std::vector<XFile::Materi
             }
 
             if( oldMat.sceneIndex == SIZE_MAX ) {
-                ASSIMP_LOG_WARN_F( "Could not resolve global material reference \"", oldMat.mName, "\"" );
+                ASSIMP_LOG_WARN( "Could not resolve global material reference \"", oldMat.mName, "\"" );
                 oldMat.sceneIndex = 0;
             }
 
@@ -661,9 +658,7 @@ void XFileImporter::ConvertMaterials( aiScene* pScene, std::vector<XFile::Materi
 
                 // convert to lower case for easier comparison
                 for ( unsigned int c = 0; c < sz.length(); ++c ) {
-                    if ( isalpha( sz[ c ] ) ) {
-                        sz[ c ] = tolower( sz[ c ] );
-                    }
+                    sz[ c ] = (char) tolower( (unsigned char) sz[ c ] );
                 }
 
                 // Place texture filename property under the corresponding name
diff --git a/Engine/lib/assimp/code/X/XFileImporter.h b/Engine/lib/assimp/code/AssetLib/X/XFileImporter.h
similarity index 95%
rename from Engine/lib/assimp/code/X/XFileImporter.h
rename to Engine/lib/assimp/code/AssetLib/X/XFileImporter.h
index 7d12b6fdf..648139002 100644
--- a/Engine/lib/assimp/code/X/XFileImporter.h
+++ b/Engine/lib/assimp/code/AssetLib/X/XFileImporter.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,6 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file  XFileImporter.h
  *  @brief Definition of the XFile importer class.
  */
+#pragma once
 #ifndef AI_XFILEIMPORTER_H_INC
 #define AI_XFILEIMPORTER_H_INC
 
@@ -69,28 +69,27 @@ namespace XFile {
 class XFileImporter : public BaseImporter {
 public:
     XFileImporter();
-    ~XFileImporter();
+    ~XFileImporter() override;
 
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
      * See BaseImporter::CanRead() for details. */
     bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool CheckSig) const;
+        bool CheckSig) const override;
 
 protected:
-
     // -------------------------------------------------------------------
     /** Return importer meta information.
      * See #BaseImporter::GetInfo for the details
      */
-    const aiImporterDesc* GetInfo () const;
+    const aiImporterDesc* GetInfo () const override;
 
     // -------------------------------------------------------------------
     /** Imports the given file into the given scene structure.
      * See BaseImporter::InternReadFile() for details
      */
     void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
+        IOSystem* pIOHandler) override;
 
     // -------------------------------------------------------------------
     /** Constructs the return data structure out of the imported data.
@@ -140,7 +139,7 @@ protected:
     void ConvertMaterials( aiScene* pScene, std::vector<XFile::Material>& pMaterials);
 
 protected:
-    /** Buffer to hold the loaded file */
+    /// Buffer to hold the loaded file
     std::vector<char> mBuffer;
 };
 
diff --git a/Engine/lib/assimp/code/X/XFileParser.cpp b/Engine/lib/assimp/code/AssetLib/X/XFileParser.cpp
similarity index 50%
rename from Engine/lib/assimp/code/X/XFileParser.cpp
rename to Engine/lib/assimp/code/AssetLib/X/XFileParser.cpp
index 8fcf87cf6..558b97958 100644
--- a/Engine/lib/assimp/code/X/XFileParser.cpp
+++ b/Engine/lib/assimp/code/AssetLib/X/XFileParser.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,58 +41,46 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** @file Implementation of the XFile parser helper class */
 
-
 #ifndef ASSIMP_BUILD_NO_X_IMPORTER
 
 #include "XFileParser.h"
 #include "XFileHelper.h"
-#include <assimp/fast_atof.h>
-#include <assimp/Exceptional.h>
-#include <assimp/TinyFormatter.h>
 #include <assimp/ByteSwapper.h>
+#include <assimp/Exceptional.h>
 #include <assimp/StringUtils.h>
+#include <assimp/TinyFormatter.h>
+#include <assimp/fast_atof.h>
 #include <assimp/DefaultLogger.hpp>
 
-
 using namespace Assimp;
 using namespace Assimp::XFile;
 using namespace Assimp::Formatter;
 
 #ifndef ASSIMP_BUILD_NO_COMPRESSED_X
 
-#   ifdef ASSIMP_BUILD_NO_OWN_ZLIB
-#       include <zlib.h>
-#   else
-#       include "../contrib/zlib/zlib.h"
-#   endif
+#include "Common/Compression.h"
 
 // Magic identifier for MSZIP compressed data
-#define MSZIP_MAGIC 0x4B43
-#define MSZIP_BLOCK 32786
-
-// ------------------------------------------------------------------------------------------------
-// Dummy memory wrappers for use with zlib
-static void* dummy_alloc (void* /*opaque*/, unsigned int items, unsigned int size)  {
-    return ::operator new(items*size);
-}
-
-static void  dummy_free  (void* /*opaque*/, void* address)  {
-    return ::operator delete(address);
-}
+constexpr unsigned int MSZIP_MAGIC = 0x4B43;
+constexpr size_t MSZIP_BLOCK = 32786l;
 
 #endif // !! ASSIMP_BUILD_NO_COMPRESSED_X
 
+// ------------------------------------------------------------------------------------------------
+// Throws an exception with a line number and the given text.
+template<typename... T>
+AI_WONT_RETURN void XFileParser::ThrowException(T&&... args) {
+    if (mIsBinaryFormat) {
+        throw DeadlyImportError(args...);
+    } else {
+        throw DeadlyImportError("Line ", mLineNumber, ": ", args...);
+    }
+}
+
 // ------------------------------------------------------------------------------------------------
 // Constructor. Creates a data structure out of the XFile given in the memory block.
-XFileParser::XFileParser( const std::vector<char>& pBuffer)
-: mMajorVersion( 0 )
-, mMinorVersion( 0 )
-, mIsBinaryFormat( false )
-, mBinaryNumCount( 0 )
-, mP( nullptr )
-, mEnd( nullptr )
-, mLineNumber( 0 )
-, mScene( nullptr ) {
+XFileParser::XFileParser(const std::vector<char> &pBuffer) :
+        mMajorVersion(0), mMinorVersion(0), mIsBinaryFormat(false), mBinaryNumCount(0), mP(nullptr), mEnd(nullptr), mLineNumber(0), mScene(nullptr) {
     // vector to store uncompressed file for INFLATE'd X files
     std::vector<char> uncompressed;
 
@@ -103,8 +89,8 @@ XFileParser::XFileParser( const std::vector<char>& pBuffer)
     mEnd = mP + pBuffer.size() - 1;
 
     // check header
-    if ( 0 != strncmp( mP, "xof ", 4 ) ) {
-        throw DeadlyImportError( "Header mismatch, file is not an XFile." );
+    if (0 != strncmp(mP, "xof ", 4)) {
+        throw DeadlyImportError("Header mismatch, file is not an XFile.");
     }
 
     // read version. It comes in a four byte format such as "0302"
@@ -114,36 +100,30 @@ XFileParser::XFileParser( const std::vector<char>& pBuffer)
     bool compressed = false;
 
     // txt - pure ASCII text format
-    if( strncmp( mP + 8, "txt ", 4) == 0)
+    if (strncmp(mP + 8, "txt ", 4) == 0)
         mIsBinaryFormat = false;
 
     // bin - Binary format
-    else if( strncmp( mP + 8, "bin ", 4) == 0)
+    else if (strncmp(mP + 8, "bin ", 4) == 0)
         mIsBinaryFormat = true;
 
     // tzip - Inflate compressed text format
-    else if( strncmp( mP + 8, "tzip", 4) == 0)
-    {
+    else if (strncmp(mP + 8, "tzip", 4) == 0) {
         mIsBinaryFormat = false;
         compressed = true;
     }
     // bzip - Inflate compressed binary format
-    else if( strncmp( mP + 8, "bzip", 4) == 0)
-    {
+    else if (strncmp(mP + 8, "bzip", 4) == 0) {
         mIsBinaryFormat = true;
         compressed = true;
-    }
-    else ThrowException( format() << "Unsupported xfile format '" <<
-       mP[8] << mP[9] << mP[10] << mP[11] << "'");
+    } else
+        ThrowException("Unsupported x-file format '", mP[8], mP[9], mP[10], mP[11], "'");
 
     // float size
-    mBinaryFloatSize = (unsigned int)(mP[12] - 48) * 1000
-        + (unsigned int)(mP[13] - 48) * 100
-        + (unsigned int)(mP[14] - 48) * 10
-        + (unsigned int)(mP[15] - 48);
+    mBinaryFloatSize = (unsigned int)(mP[12] - 48) * 1000 + (unsigned int)(mP[13] - 48) * 100 + (unsigned int)(mP[14] - 48) * 10 + (unsigned int)(mP[15] - 48);
 
-    if( mBinaryFloatSize != 32 && mBinaryFloatSize != 64)
-        ThrowException( format() << "Unknown float size " << mBinaryFloatSize << " specified in xfile header." );
+    if (mBinaryFloatSize != 32 && mBinaryFloatSize != 64)
+        ThrowException("Unknown float size ", mBinaryFloatSize, " specified in x-file header.");
 
     // The x format specifies size in bits, but we work in bytes
     mBinaryFloatSize /= 8;
@@ -151,8 +131,7 @@ XFileParser::XFileParser( const std::vector<char>& pBuffer)
     mP += 16;
 
     // If this is a compressed X file, apply the inflate algorithm to it
-    if (compressed)
-    {
+    if (compressed) {
 #ifdef ASSIMP_BUILD_NO_COMPRESSED_X
         throw DeadlyImportError("Assimp was built without compressed X support");
 #else
@@ -176,79 +155,55 @@ XFileParser::XFileParser( const std::vector<char>& pBuffer)
          * ///////////////////////////////////////////////////////////////////////
          */
 
-        // build a zlib stream
-        z_stream stream;
-        stream.opaque = NULL;
-        stream.zalloc = &dummy_alloc;
-        stream.zfree  = &dummy_free;
-        stream.data_type = (mIsBinaryFormat ? Z_BINARY : Z_ASCII);
-
-        // initialize the inflation algorithm
-        ::inflateInit2(&stream, -MAX_WBITS);
-
         // skip unknown data (checksum, flags?)
         mP += 6;
 
         // First find out how much storage we'll need. Count sections.
-        const char* P1       = mP;
+        const char *P1 = mP;
         unsigned int est_out = 0;
 
-        while (P1 + 3 < mEnd)
-        {
+        while (P1 + 3 < mEnd) {
             // read next offset
-            uint16_t ofs = *((uint16_t*)P1);
-            AI_SWAP2(ofs); P1 += 2;
+            uint16_t ofs = *((uint16_t *)P1);
+            AI_SWAP2(ofs);
+            P1 += 2;
 
             if (ofs >= MSZIP_BLOCK)
                 throw DeadlyImportError("X: Invalid offset to next MSZIP compressed block");
 
             // check magic word
-            uint16_t magic = *((uint16_t*)P1);
-            AI_SWAP2(magic); P1 += 2;
+            uint16_t magic = *((uint16_t *)P1);
+            AI_SWAP2(magic);
+            P1 += 2;
 
             if (magic != MSZIP_MAGIC)
                 throw DeadlyImportError("X: Unsupported compressed format, expected MSZIP header");
 
             // and advance to the next offset
             P1 += ofs;
-            est_out += MSZIP_BLOCK; // one decompressed block is 32786 in size
+            est_out += MSZIP_BLOCK; // one decompressed block is 327861 in size
         }
-
+        
         // Allocate storage and terminating zero and do the actual uncompressing
+        Compression compression;
         uncompressed.resize(est_out + 1);
-        char* out = &uncompressed.front();
-        while (mP + 3 < mEnd)
-        {
-            uint16_t ofs = *((uint16_t*)mP);
-            AI_SWAP2(ofs);
-            mP += 4;
+        char *out = &uncompressed.front();
+        if (compression.open(mIsBinaryFormat ? Compression::Format::Binary : Compression::Format::ASCII,
+                Compression::FlushMode::SyncFlush, -Compression::MaxWBits)) {
+            while (mP + 3 < mEnd) {
+                uint16_t ofs = *((uint16_t *)mP);
+                AI_SWAP2(ofs);
+                mP += 4;
 
-            if (mP + ofs > mEnd + 2) {
-                throw DeadlyImportError("X: Unexpected EOF in compressed chunk");
+                if (mP + ofs > mEnd + 2) {
+                    throw DeadlyImportError("X: Unexpected EOF in compressed chunk");
+                }
+                out += compression.decompressBlock(mP, ofs, out, MSZIP_BLOCK);
+                mP += ofs;
             }
-
-            // push data to the stream
-            stream.next_in   = (Bytef*)mP;
-            stream.avail_in  = ofs;
-            stream.next_out  = (Bytef*)out;
-            stream.avail_out = MSZIP_BLOCK;
-
-            // and decompress the data ....
-            int ret = ::inflate( &stream, Z_SYNC_FLUSH );
-            if (ret != Z_OK && ret != Z_STREAM_END)
-                throw DeadlyImportError("X: Failed to decompress MSZIP-compressed data");
-
-            ::inflateReset( &stream );
-            ::inflateSetDictionary( &stream, (const Bytef*)out , MSZIP_BLOCK - stream.avail_out );
-
-            // and advance to the next offset
-            out +=  MSZIP_BLOCK - stream.avail_out;
-            mP   += ofs;
+            compression.close();
         }
 
-        // terminate zlib
-        ::inflateEnd(&stream);
-
         // ok, update pointers to point to the uncompressed file data
         mP = &uncompressed[0];
         mEnd = out;
@@ -257,9 +212,7 @@ XFileParser::XFileParser( const std::vector<char>& pBuffer)
         // it already for better memory usage. Consider breaking const-co.
         ASSIMP_LOG_INFO("Successfully decompressed MSZIP-compressed file");
 #endif // !! ASSIMP_BUILD_NO_COMPRESSED_X
-    }
-    else
-    {
+    } else {
         // start reading here
         ReadUntilEndOfLine();
     }
@@ -268,63 +221,51 @@ XFileParser::XFileParser( const std::vector<char>& pBuffer)
     ParseFile();
 
     // filter the imported hierarchy for some degenerated cases
-    if( mScene->mRootNode) {
-        FilterHierarchy( mScene->mRootNode);
+    if (mScene->mRootNode) {
+        FilterHierarchy(mScene->mRootNode);
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Destructor. Destroys all imported data along with it
-XFileParser::~XFileParser()
-{
+XFileParser::~XFileParser() {
     // kill everything we created
     delete mScene;
 }
 
 // ------------------------------------------------------------------------------------------------
-void XFileParser::ParseFile()
-{
+void XFileParser::ParseFile() {
     bool running = true;
-    while( running )
-    {
+    while (running) {
         // read name of next object
         std::string objectName = GetNextToken();
-        if (objectName.length() == 0)
+        if (objectName.length() == 0) {
             break;
+        }
 
         // parse specific object
-        if( objectName == "template")
+        if (objectName == "template") {
             ParseDataObjectTemplate();
-        else
-        if( objectName == "Frame")
-            ParseDataObjectFrame( NULL);
-        else
-        if( objectName == "Mesh")
-        {
+        } else if (objectName == "Frame") {
+            ParseDataObjectFrame(nullptr);
+        } else if (objectName == "Mesh") {
             // some meshes have no frames at all
-            Mesh* mesh = new Mesh;
-            ParseDataObjectMesh( mesh);
-            mScene->mGlobalMeshes.push_back( mesh);
-        } else
-        if( objectName == "AnimTicksPerSecond")
+            Mesh *mesh = new Mesh;
+            ParseDataObjectMesh(mesh);
+            mScene->mGlobalMeshes.push_back(mesh);
+        } else if (objectName == "AnimTicksPerSecond")
             ParseDataObjectAnimTicksPerSecond();
-        else
-        if( objectName == "AnimationSet")
+        else if (objectName == "AnimationSet")
             ParseDataObjectAnimationSet();
-        else
-        if( objectName == "Material")
-        {
+        else if (objectName == "Material") {
             // Material outside of a mesh or node
             Material material;
-            ParseDataObjectMaterial( &material);
-            mScene->mGlobalMaterials.push_back( material);
-        } else
-        if( objectName == "}")
-        {
+            ParseDataObjectMaterial(&material);
+            mScene->mGlobalMaterials.push_back(material);
+        } else if (objectName == "}") {
             // whatever?
             ASSIMP_LOG_WARN("} found in dataObject");
-        } else
-        {
+        } else {
             // unknown format
             ASSIMP_LOG_WARN("Unknown data object in animation of .x file");
             ParseUnknownDataObject();
@@ -333,32 +274,31 @@ void XFileParser::ParseFile()
 }
 
 // ------------------------------------------------------------------------------------------------
-void XFileParser::ParseDataObjectTemplate()
-{
+void XFileParser::ParseDataObjectTemplate() {
     // parse a template data object. Currently not stored.
     std::string name;
-    readHeadOfDataObject( &name);
+    readHeadOfDataObject(&name);
 
     // read GUID
     std::string guid = GetNextToken();
 
     // read and ignore data members
     bool running = true;
-    while ( running )
-    {
+    while (running) {
         std::string s = GetNextToken();
 
-        if( s == "}")
+        if (s == "}") {
             break;
+        }
 
-        if( s.length() == 0)
-            ThrowException( "Unexpected end of file reached while parsing template definition");
+        if (s.length() == 0) {
+            ThrowException("Unexpected end of file reached while parsing template definition");
+        }
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void XFileParser::ParseDataObjectFrame( Node* pParent)
-{
+void XFileParser::ParseDataObjectFrame(Node *pParent) {
     // A coordinate frame, or "frame of reference." The Frame template
     // is open and can contain any object. The Direct3D extensions (D3DX)
     // mesh-loading functions recognize Mesh, FrameTransformMatrix, and
@@ -368,30 +308,25 @@ void XFileParser::ParseDataObjectFrame( Node* pParent)
     readHeadOfDataObject(&name);
 
     // create a named node and place it at its parent, if given
-    Node* node = new Node( pParent);
+    Node *node = new Node(pParent);
     node->mName = name;
-    if( pParent)
-    {
-        pParent->mChildren.push_back( node);
-    } else
-    {
+    if (pParent) {
+        pParent->mChildren.push_back(node);
+    } else {
         // there might be multiple root nodes
-        if( mScene->mRootNode != NULL)
-        {
+        if (mScene->mRootNode != nullptr) {
             // place a dummy root if not there
-            if( mScene->mRootNode->mName != "$dummy_root")
-            {
-                Node* exroot = mScene->mRootNode;
-                mScene->mRootNode = new Node( NULL);
+            if (mScene->mRootNode->mName != "$dummy_root") {
+                Node *exroot = mScene->mRootNode;
+                mScene->mRootNode = new Node(nullptr);
                 mScene->mRootNode->mName = "$dummy_root";
-                mScene->mRootNode->mChildren.push_back( exroot);
+                mScene->mRootNode->mChildren.push_back(exroot);
                 exroot->mParent = mScene->mRootNode;
             }
             // put the new node as its child instead
-            mScene->mRootNode->mChildren.push_back( node);
+            mScene->mRootNode->mChildren.push_back(node);
             node->mParent = mScene->mRootNode;
-        } else
-        {
+        } else {
             // it's the first node imported. place it as root
             mScene->mRootNode = node;
         }
@@ -400,28 +335,22 @@ void XFileParser::ParseDataObjectFrame( Node* pParent)
     // Now inside a frame.
     // read tokens until closing brace is reached.
     bool running = true;
-    while ( running )
-    {
+    while (running) {
         std::string objectName = GetNextToken();
         if (objectName.size() == 0)
-            ThrowException( "Unexpected end of file reached while parsing frame");
+            ThrowException("Unexpected end of file reached while parsing frame");
 
-        if( objectName == "}")
+        if (objectName == "}")
             break; // frame finished
-        else
-        if( objectName == "Frame")
-            ParseDataObjectFrame( node); // child frame
-        else
-        if( objectName == "FrameTransformMatrix")
-            ParseDataObjectTransformationMatrix( node->mTrafoMatrix);
-        else
-        if( objectName == "Mesh")
-        {
-            Mesh* mesh = new Mesh(name);
-            node->mMeshes.push_back( mesh);
-            ParseDataObjectMesh( mesh);
-        } else
-        {
+        else if (objectName == "Frame")
+            ParseDataObjectFrame(node); // child frame
+        else if (objectName == "FrameTransformMatrix")
+            ParseDataObjectTransformationMatrix(node->mTrafoMatrix);
+        else if (objectName == "Mesh") {
+            Mesh *mesh = new Mesh(name);
+            node->mMeshes.push_back(mesh);
+            ParseDataObjectMesh(mesh);
+        } else {
             ASSIMP_LOG_WARN("Unknown data object in frame in x file");
             ParseUnknownDataObject();
         }
@@ -429,20 +358,27 @@ void XFileParser::ParseDataObjectFrame( Node* pParent)
 }
 
 // ------------------------------------------------------------------------------------------------
-void XFileParser::ParseDataObjectTransformationMatrix( aiMatrix4x4& pMatrix)
-{
+void XFileParser::ParseDataObjectTransformationMatrix(aiMatrix4x4 &pMatrix) {
     // read header, we're not interested if it has a name
     readHeadOfDataObject();
 
     // read its components
-    pMatrix.a1 = ReadFloat(); pMatrix.b1 = ReadFloat();
-    pMatrix.c1 = ReadFloat(); pMatrix.d1 = ReadFloat();
-    pMatrix.a2 = ReadFloat(); pMatrix.b2 = ReadFloat();
-    pMatrix.c2 = ReadFloat(); pMatrix.d2 = ReadFloat();
-    pMatrix.a3 = ReadFloat(); pMatrix.b3 = ReadFloat();
-    pMatrix.c3 = ReadFloat(); pMatrix.d3 = ReadFloat();
-    pMatrix.a4 = ReadFloat(); pMatrix.b4 = ReadFloat();
-    pMatrix.c4 = ReadFloat(); pMatrix.d4 = ReadFloat();
+    pMatrix.a1 = ReadFloat();
+    pMatrix.b1 = ReadFloat();
+    pMatrix.c1 = ReadFloat();
+    pMatrix.d1 = ReadFloat();
+    pMatrix.a2 = ReadFloat();
+    pMatrix.b2 = ReadFloat();
+    pMatrix.c2 = ReadFloat();
+    pMatrix.d2 = ReadFloat();
+    pMatrix.a3 = ReadFloat();
+    pMatrix.b3 = ReadFloat();
+    pMatrix.c3 = ReadFloat();
+    pMatrix.d3 = ReadFloat();
+    pMatrix.a4 = ReadFloat();
+    pMatrix.b4 = ReadFloat();
+    pMatrix.c4 = ReadFloat();
+    pMatrix.d4 = ReadFloat();
 
     // trailing symbols
     CheckForSemicolon();
@@ -450,30 +386,29 @@ void XFileParser::ParseDataObjectTransformationMatrix( aiMatrix4x4& pMatrix)
 }
 
 // ------------------------------------------------------------------------------------------------
-void XFileParser::ParseDataObjectMesh( Mesh* pMesh)
-{
+void XFileParser::ParseDataObjectMesh(Mesh *pMesh) {
     std::string name;
-    readHeadOfDataObject( &name);
+    readHeadOfDataObject(&name);
 
     // read vertex count
     unsigned int numVertices = ReadInt();
-    pMesh->mPositions.resize( numVertices);
+    pMesh->mPositions.resize(numVertices);
 
     // read vertices
-    for( unsigned int a = 0; a < numVertices; a++)
+    for (unsigned int a = 0; a < numVertices; a++)
         pMesh->mPositions[a] = ReadVector3();
 
     // read position faces
     unsigned int numPosFaces = ReadInt();
-    pMesh->mPosFaces.resize( numPosFaces);
-    for( unsigned int a = 0; a < numPosFaces; ++a) {
+    pMesh->mPosFaces.resize(numPosFaces);
+    for (unsigned int a = 0; a < numPosFaces; ++a) {
         // read indices
         unsigned int numIndices = ReadInt();
-        Face& face = pMesh->mPosFaces[a];
+        Face &face = pMesh->mPosFaces[a];
         for (unsigned int b = 0; b < numIndices; ++b) {
-            const int idx( ReadInt() );
-            if ( static_cast<unsigned int>( idx ) <= numVertices ) {
-                face.mIndices.push_back( idx );
+            const int idx(ReadInt());
+            if (static_cast<unsigned int>(idx) <= numVertices) {
+                face.mIndices.push_back(idx);
             }
         }
         TestForSeparator();
@@ -481,37 +416,28 @@ void XFileParser::ParseDataObjectMesh( Mesh* pMesh)
 
     // here, other data objects may follow
     bool running = true;
-    while ( running ) {
+    while (running) {
         std::string objectName = GetNextToken();
 
-        if( objectName.empty() )
-            ThrowException( "Unexpected end of file while parsing mesh structure");
-        else
-        if( objectName == "}")
+        if (objectName.empty())
+            ThrowException("Unexpected end of file while parsing mesh structure");
+        else if (objectName == "}")
             break; // mesh finished
-        else
-        if( objectName == "MeshNormals")
-            ParseDataObjectMeshNormals( pMesh);
-        else
-        if( objectName == "MeshTextureCoords")
-            ParseDataObjectMeshTextureCoords( pMesh);
-        else
-        if( objectName == "MeshVertexColors")
-            ParseDataObjectMeshVertexColors( pMesh);
-        else
-        if( objectName == "MeshMaterialList")
-            ParseDataObjectMeshMaterialList( pMesh);
-        else
-        if( objectName == "VertexDuplicationIndices")
+        else if (objectName == "MeshNormals")
+            ParseDataObjectMeshNormals(pMesh);
+        else if (objectName == "MeshTextureCoords")
+            ParseDataObjectMeshTextureCoords(pMesh);
+        else if (objectName == "MeshVertexColors")
+            ParseDataObjectMeshVertexColors(pMesh);
+        else if (objectName == "MeshMaterialList")
+            ParseDataObjectMeshMaterialList(pMesh);
+        else if (objectName == "VertexDuplicationIndices")
             ParseUnknownDataObject(); // we'll ignore vertex duplication indices
-        else
-        if( objectName == "XSkinMeshHeader")
-            ParseDataObjectSkinMeshHeader( pMesh);
-        else
-        if( objectName == "SkinWeights")
-            ParseDataObjectSkinWeights( pMesh);
-        else
-        {
+        else if (objectName == "XSkinMeshHeader")
+            ParseDataObjectSkinMeshHeader(pMesh);
+        else if (objectName == "SkinWeights")
+            ParseDataObjectSkinWeights(pMesh);
+        else {
             ASSIMP_LOG_WARN("Unknown data object in mesh in x file");
             ParseUnknownDataObject();
         }
@@ -519,90 +445,95 @@ void XFileParser::ParseDataObjectMesh( Mesh* pMesh)
 }
 
 // ------------------------------------------------------------------------------------------------
-void XFileParser::ParseDataObjectSkinWeights( Mesh *pMesh) {
-    if ( nullptr == pMesh ) {
+void XFileParser::ParseDataObjectSkinWeights(Mesh *pMesh) {
+    if (nullptr == pMesh) {
         return;
     }
     readHeadOfDataObject();
 
     std::string transformNodeName;
-    GetNextTokenAsString( transformNodeName);
+    GetNextTokenAsString(transformNodeName);
 
-    pMesh->mBones.push_back( Bone());
-    Bone& bone = pMesh->mBones.back();
+    pMesh->mBones.push_back(Bone());
+    Bone &bone = pMesh->mBones.back();
     bone.mName = transformNodeName;
 
     // read vertex weights
     unsigned int numWeights = ReadInt();
-    bone.mWeights.reserve( numWeights);
+    bone.mWeights.reserve(numWeights);
 
-    for( unsigned int a = 0; a < numWeights; a++)
-    {
-        BoneWeight weight;
+    for (unsigned int a = 0; a < numWeights; a++) {
+        BoneWeight weight = {};
         weight.mVertex = ReadInt();
-        bone.mWeights.push_back( weight);
+        bone.mWeights.push_back(weight);
     }
 
     // read vertex weights
-    for( unsigned int a = 0; a < numWeights; a++)
+    for (unsigned int a = 0; a < numWeights; a++)
         bone.mWeights[a].mWeight = ReadFloat();
 
     // read matrix offset
-    bone.mOffsetMatrix.a1 = ReadFloat(); bone.mOffsetMatrix.b1 = ReadFloat();
-    bone.mOffsetMatrix.c1 = ReadFloat(); bone.mOffsetMatrix.d1 = ReadFloat();
-    bone.mOffsetMatrix.a2 = ReadFloat(); bone.mOffsetMatrix.b2 = ReadFloat();
-    bone.mOffsetMatrix.c2 = ReadFloat(); bone.mOffsetMatrix.d2 = ReadFloat();
-    bone.mOffsetMatrix.a3 = ReadFloat(); bone.mOffsetMatrix.b3 = ReadFloat();
-    bone.mOffsetMatrix.c3 = ReadFloat(); bone.mOffsetMatrix.d3 = ReadFloat();
-    bone.mOffsetMatrix.a4 = ReadFloat(); bone.mOffsetMatrix.b4 = ReadFloat();
-    bone.mOffsetMatrix.c4 = ReadFloat(); bone.mOffsetMatrix.d4 = ReadFloat();
+    bone.mOffsetMatrix.a1 = ReadFloat();
+    bone.mOffsetMatrix.b1 = ReadFloat();
+    bone.mOffsetMatrix.c1 = ReadFloat();
+    bone.mOffsetMatrix.d1 = ReadFloat();
+    bone.mOffsetMatrix.a2 = ReadFloat();
+    bone.mOffsetMatrix.b2 = ReadFloat();
+    bone.mOffsetMatrix.c2 = ReadFloat();
+    bone.mOffsetMatrix.d2 = ReadFloat();
+    bone.mOffsetMatrix.a3 = ReadFloat();
+    bone.mOffsetMatrix.b3 = ReadFloat();
+    bone.mOffsetMatrix.c3 = ReadFloat();
+    bone.mOffsetMatrix.d3 = ReadFloat();
+    bone.mOffsetMatrix.a4 = ReadFloat();
+    bone.mOffsetMatrix.b4 = ReadFloat();
+    bone.mOffsetMatrix.c4 = ReadFloat();
+    bone.mOffsetMatrix.d4 = ReadFloat();
 
     CheckForSemicolon();
     CheckForClosingBrace();
 }
 
 // ------------------------------------------------------------------------------------------------
-void XFileParser::ParseDataObjectSkinMeshHeader( Mesh* /*pMesh*/ )
-{
+void XFileParser::ParseDataObjectSkinMeshHeader(Mesh * /*pMesh*/) {
     readHeadOfDataObject();
 
-    /*unsigned int maxSkinWeightsPerVertex =*/ ReadInt();
-    /*unsigned int maxSkinWeightsPerFace =*/ ReadInt();
-    /*unsigned int numBonesInMesh = */ReadInt();
+    /*unsigned int maxSkinWeightsPerVertex =*/ReadInt();
+    /*unsigned int maxSkinWeightsPerFace =*/ReadInt();
+    /*unsigned int numBonesInMesh = */ ReadInt();
 
     CheckForClosingBrace();
 }
 
 // ------------------------------------------------------------------------------------------------
-void XFileParser::ParseDataObjectMeshNormals( Mesh* pMesh)
-{
+void XFileParser::ParseDataObjectMeshNormals(Mesh *pMesh) {
     readHeadOfDataObject();
 
     // read count
     unsigned int numNormals = ReadInt();
-    pMesh->mNormals.resize( numNormals);
+    pMesh->mNormals.resize(numNormals);
 
     // read normal vectors
-    for( unsigned int a = 0; a < numNormals; ++a) {
+    for (unsigned int a = 0; a < numNormals; ++a) {
         pMesh->mNormals[a] = ReadVector3();
     }
 
     // read normal indices
     unsigned int numFaces = ReadInt();
-    if( numFaces != pMesh->mPosFaces.size()) {
-        ThrowException( "Normal face count does not match vertex face count.");
+    if (numFaces != pMesh->mPosFaces.size()) {
+        ThrowException("Normal face count does not match vertex face count.");
     }
 
     // do not crah when no face definitions are there
     if (numFaces > 0) {
         // normal face creation
-        pMesh->mNormFaces.resize( numFaces );
-        for( unsigned int a = 0; a < numFaces; ++a ) {
+        pMesh->mNormFaces.resize(numFaces);
+        for (unsigned int a = 0; a < numFaces; ++a) {
             unsigned int numIndices = ReadInt();
             pMesh->mNormFaces[a] = Face();
-            Face& face = pMesh->mNormFaces[a];
-            for( unsigned int b = 0; b < numIndices; ++b ) {
-                face.mIndices.push_back( ReadInt());
+            Face &face = pMesh->mNormFaces[a];
+            for (unsigned int b = 0; b < numIndices; ++b) {
+                face.mIndices.push_back(ReadInt());
             }
 
             TestForSeparator();
@@ -613,51 +544,47 @@ void XFileParser::ParseDataObjectMeshNormals( Mesh* pMesh)
 }
 
 // ------------------------------------------------------------------------------------------------
-void XFileParser::ParseDataObjectMeshTextureCoords( Mesh* pMesh)
-{
+void XFileParser::ParseDataObjectMeshTextureCoords(Mesh *pMesh) {
     readHeadOfDataObject();
-    if( pMesh->mNumTextures + 1 > AI_MAX_NUMBER_OF_TEXTURECOORDS)
-        ThrowException( "Too many sets of texture coordinates");
+    if (pMesh->mNumTextures + 1 > AI_MAX_NUMBER_OF_TEXTURECOORDS)
+        ThrowException("Too many sets of texture coordinates");
 
-    std::vector<aiVector2D>& coords = pMesh->mTexCoords[pMesh->mNumTextures++];
+    std::vector<aiVector2D> &coords = pMesh->mTexCoords[pMesh->mNumTextures++];
 
     unsigned int numCoords = ReadInt();
-    if( numCoords != pMesh->mPositions.size())
-        ThrowException( "Texture coord count does not match vertex count");
+    if (numCoords != pMesh->mPositions.size())
+        ThrowException("Texture coord count does not match vertex count");
 
-    coords.resize( numCoords);
-    for( unsigned int a = 0; a < numCoords; a++)
+    coords.resize(numCoords);
+    for (unsigned int a = 0; a < numCoords; a++)
         coords[a] = ReadVector2();
 
     CheckForClosingBrace();
 }
 
 // ------------------------------------------------------------------------------------------------
-void XFileParser::ParseDataObjectMeshVertexColors( Mesh* pMesh)
-{
+void XFileParser::ParseDataObjectMeshVertexColors(Mesh *pMesh) {
     readHeadOfDataObject();
-    if( pMesh->mNumColorSets + 1 > AI_MAX_NUMBER_OF_COLOR_SETS)
-        ThrowException( "Too many colorsets");
-    std::vector<aiColor4D>& colors = pMesh->mColors[pMesh->mNumColorSets++];
+    if (pMesh->mNumColorSets + 1 > AI_MAX_NUMBER_OF_COLOR_SETS)
+        ThrowException("Too many colorsets");
+    std::vector<aiColor4D> &colors = pMesh->mColors[pMesh->mNumColorSets++];
 
     unsigned int numColors = ReadInt();
-    if( numColors != pMesh->mPositions.size())
-        ThrowException( "Vertex color count does not match vertex count");
+    if (numColors != pMesh->mPositions.size())
+        ThrowException("Vertex color count does not match vertex count");
 
-    colors.resize( numColors, aiColor4D( 0, 0, 0, 1));
-    for( unsigned int a = 0; a < numColors; a++)
-    {
+    colors.resize(numColors, aiColor4D(0, 0, 0, 1));
+    for (unsigned int a = 0; a < numColors; a++) {
         unsigned int index = ReadInt();
-        if( index >= pMesh->mPositions.size())
-            ThrowException( "Vertex color index out of bounds");
+        if (index >= pMesh->mPositions.size())
+            ThrowException("Vertex color index out of bounds");
 
         colors[index] = ReadRGBA();
         // HACK: (thom) Maxon Cinema XPort plugin puts a third separator here, kwxPort puts a comma.
         // Ignore gracefully.
-        if( !mIsBinaryFormat)
-        {
+        if (!mIsBinaryFormat) {
             FindNextNoneWhiteSpace();
-            if( *mP == ';' || *mP == ',')
+            if (*mP == ';' || *mP == ',')
                 mP++;
         }
     }
@@ -666,68 +593,58 @@ void XFileParser::ParseDataObjectMeshVertexColors( Mesh* pMesh)
 }
 
 // ------------------------------------------------------------------------------------------------
-void XFileParser::ParseDataObjectMeshMaterialList( Mesh* pMesh)
-{
+void XFileParser::ParseDataObjectMeshMaterialList(Mesh *pMesh) {
     readHeadOfDataObject();
 
     // read material count
-    /*unsigned int numMaterials =*/ ReadInt();
+    /*unsigned int numMaterials =*/ReadInt();
     // read non triangulated face material index count
     unsigned int numMatIndices = ReadInt();
 
     // some models have a material index count of 1... to be able to read them we
     // replicate this single material index on every face
-    if( numMatIndices != pMesh->mPosFaces.size() && numMatIndices != 1)
-        ThrowException( "Per-Face material index count does not match face count.");
+    if (numMatIndices != pMesh->mPosFaces.size() && numMatIndices != 1)
+        ThrowException("Per-Face material index count does not match face count.");
 
     // read per-face material indices
-    for( unsigned int a = 0; a < numMatIndices; a++)
-        pMesh->mFaceMaterials.push_back( ReadInt());
+    for (unsigned int a = 0; a < numMatIndices; a++)
+        pMesh->mFaceMaterials.push_back(ReadInt());
 
     // in version 03.02, the face indices end with two semicolons.
     // commented out version check, as version 03.03 exported from blender also has 2 semicolons
-    if( !mIsBinaryFormat) // && MajorVersion == 3 && MinorVersion <= 2)
+    if (!mIsBinaryFormat) // && MajorVersion == 3 && MinorVersion <= 2)
     {
-        if(mP < mEnd && *mP == ';')
+        if (mP < mEnd && *mP == ';')
             ++mP;
     }
 
     // if there was only a single material index, replicate it on all faces
-    while( pMesh->mFaceMaterials.size() < pMesh->mPosFaces.size())
-        pMesh->mFaceMaterials.push_back( pMesh->mFaceMaterials.front());
+    while (pMesh->mFaceMaterials.size() < pMesh->mPosFaces.size())
+        pMesh->mFaceMaterials.push_back(pMesh->mFaceMaterials.front());
 
     // read following data objects
     bool running = true;
-    while ( running )
-    {
+    while (running) {
         std::string objectName = GetNextToken();
-        if( objectName.size() == 0)
-            ThrowException( "Unexpected end of file while parsing mesh material list.");
-        else
-        if( objectName == "}")
+        if (objectName.size() == 0)
+            ThrowException("Unexpected end of file while parsing mesh material list.");
+        else if (objectName == "}")
             break; // material list finished
-        else
-        if( objectName == "{")
-        {
+        else if (objectName == "{") {
             // template materials
             std::string matName = GetNextToken();
             Material material;
             material.mIsReference = true;
             material.mName = matName;
-            pMesh->mMaterials.push_back( material);
+            pMesh->mMaterials.push_back(material);
 
             CheckForClosingBrace(); // skip }
-        } else
-        if( objectName == "Material")
-        {
-            pMesh->mMaterials.push_back( Material());
-            ParseDataObjectMaterial( &pMesh->mMaterials.back());
-        } else
-        if( objectName == ";")
-        {
+        } else if (objectName == "Material") {
+            pMesh->mMaterials.push_back(Material());
+            ParseDataObjectMaterial(&pMesh->mMaterials.back());
+        } else if (objectName == ";") {
             // ignore
-        } else
-        {
+        } else {
             ASSIMP_LOG_WARN("Unknown data object in material list in x file");
             ParseUnknownDataObject();
         }
@@ -735,12 +652,11 @@ void XFileParser::ParseDataObjectMeshMaterialList( Mesh* pMesh)
 }
 
 // ------------------------------------------------------------------------------------------------
-void XFileParser::ParseDataObjectMaterial( Material* pMaterial)
-{
+void XFileParser::ParseDataObjectMaterial(Material *pMaterial) {
     std::string matName;
-    readHeadOfDataObject( &matName);
-    if( matName.empty())
-        matName = std::string( "material") + to_string( mLineNumber );
+    readHeadOfDataObject(&matName);
+    if (matName.empty())
+        matName = std::string("material") + ai_to_string(mLineNumber);
     pMaterial->mName = matName;
     pMaterial->mIsReference = false;
 
@@ -752,30 +668,23 @@ void XFileParser::ParseDataObjectMaterial( Material* pMaterial)
 
     // read other data objects
     bool running = true;
-    while ( running )
-    {
+    while (running) {
         std::string objectName = GetNextToken();
-        if( objectName.size() == 0)
-            ThrowException( "Unexpected end of file while parsing mesh material");
-        else
-        if( objectName == "}")
+        if (objectName.size() == 0)
+            ThrowException("Unexpected end of file while parsing mesh material");
+        else if (objectName == "}")
             break; // material finished
-        else
-        if( objectName == "TextureFilename" || objectName == "TextureFileName")
-        {
+        else if (objectName == "TextureFilename" || objectName == "TextureFileName") {
             // some exporters write "TextureFileName" instead.
             std::string texname;
-            ParseDataObjectTextureFilename( texname);
-            pMaterial->mTextures.push_back( TexEntry( texname));
-        } else
-        if( objectName == "NormalmapFilename" || objectName == "NormalmapFileName")
-        {
+            ParseDataObjectTextureFilename(texname);
+            pMaterial->mTextures.push_back(TexEntry(texname));
+        } else if (objectName == "NormalmapFilename" || objectName == "NormalmapFileName") {
             // one exporter writes out the normal map in a separate filename tag
             std::string texname;
-            ParseDataObjectTextureFilename( texname);
-            pMaterial->mTextures.push_back( TexEntry( texname, true));
-        } else
-        {
+            ParseDataObjectTextureFilename(texname);
+            pMaterial->mTextures.push_back(TexEntry(texname, true));
+        } else {
             ASSIMP_LOG_WARN("Unknown data object in material in x file");
             ParseUnknownDataObject();
         }
@@ -783,37 +692,31 @@ void XFileParser::ParseDataObjectMaterial( Material* pMaterial)
 }
 
 // ------------------------------------------------------------------------------------------------
-void XFileParser::ParseDataObjectAnimTicksPerSecond()
-{
+void XFileParser::ParseDataObjectAnimTicksPerSecond() {
     readHeadOfDataObject();
     mScene->mAnimTicksPerSecond = ReadInt();
     CheckForClosingBrace();
 }
 
 // ------------------------------------------------------------------------------------------------
-void XFileParser::ParseDataObjectAnimationSet()
-{
+void XFileParser::ParseDataObjectAnimationSet() {
     std::string animName;
-    readHeadOfDataObject( &animName);
+    readHeadOfDataObject(&animName);
 
-    Animation* anim = new Animation;
-    mScene->mAnims.push_back( anim);
+    Animation *anim = new Animation;
+    mScene->mAnims.push_back(anim);
     anim->mName = animName;
 
     bool running = true;
-    while ( running )
-    {
+    while (running) {
         std::string objectName = GetNextToken();
-        if( objectName.length() == 0)
-            ThrowException( "Unexpected end of file while parsing animation set.");
-        else
-        if( objectName == "}")
+        if (objectName.length() == 0)
+            ThrowException("Unexpected end of file while parsing animation set.");
+        else if (objectName == "}")
             break; // animation set finished
-        else
-        if( objectName == "Animation")
-            ParseDataObjectAnimation( anim);
-        else
-        {
+        else if (objectName == "Animation")
+            ParseDataObjectAnimation(anim);
+        else {
             ASSIMP_LOG_WARN("Unknown data object in animation set in x file");
             ParseUnknownDataObject();
         }
@@ -821,36 +724,28 @@ void XFileParser::ParseDataObjectAnimationSet()
 }
 
 // ------------------------------------------------------------------------------------------------
-void XFileParser::ParseDataObjectAnimation( Animation* pAnim)
-{
+void XFileParser::ParseDataObjectAnimation(Animation *pAnim) {
     readHeadOfDataObject();
-    AnimBone* banim = new AnimBone;
-    pAnim->mAnims.push_back( banim);
+    AnimBone *banim = new AnimBone;
+    pAnim->mAnims.push_back(banim);
 
     bool running = true;
-    while( running )
-    {
+    while (running) {
         std::string objectName = GetNextToken();
 
-        if( objectName.length() == 0)
-            ThrowException( "Unexpected end of file while parsing animation.");
-        else
-        if( objectName == "}")
+        if (objectName.length() == 0)
+            ThrowException("Unexpected end of file while parsing animation.");
+        else if (objectName == "}")
             break; // animation finished
-        else
-        if( objectName == "AnimationKey")
-            ParseDataObjectAnimationKey( banim);
-        else
-        if( objectName == "AnimationOptions")
+        else if (objectName == "AnimationKey")
+            ParseDataObjectAnimationKey(banim);
+        else if (objectName == "AnimationOptions")
             ParseUnknownDataObject(); // not interested
-        else
-        if( objectName == "{")
-        {
+        else if (objectName == "{") {
             // read frame name
             banim->mBoneName = GetNextToken();
             CheckForClosingBrace();
-        } else
-        {
+        } else {
             ASSIMP_LOG_WARN("Unknown data object in animation in x file");
             ParseUnknownDataObject();
         }
@@ -858,8 +753,7 @@ void XFileParser::ParseDataObjectAnimation( Animation* pAnim)
 }
 
 // ------------------------------------------------------------------------------------------------
-void XFileParser::ParseDataObjectAnimationKey( AnimBone* pAnimBone)
-{
+void XFileParser::ParseDataObjectAnimationKey(AnimBone *pAnimBone) {
     readHeadOfDataObject();
 
     // read key type
@@ -868,78 +762,84 @@ void XFileParser::ParseDataObjectAnimationKey( AnimBone* pAnimBone)
     // read number of keys
     unsigned int numKeys = ReadInt();
 
-    for( unsigned int a = 0; a < numKeys; a++)
-    {
+    for (unsigned int a = 0; a < numKeys; a++) {
         // read time
         unsigned int time = ReadInt();
 
         // read keys
-        switch( keyType)
+        switch (keyType) {
+        case 0: // rotation quaternion
         {
-            case 0: // rotation quaternion
-            {
-                // read count
-                if( ReadInt() != 4)
-                    ThrowException( "Invalid number of arguments for quaternion key in animation");
+            // read count
+            if (ReadInt() != 4)
+                ThrowException("Invalid number of arguments for quaternion key in animation");
 
-                aiQuatKey key;
-                key.mTime = double( time);
-                key.mValue.w = ReadFloat();
-                key.mValue.x = ReadFloat();
-                key.mValue.y = ReadFloat();
-                key.mValue.z = ReadFloat();
-                pAnimBone->mRotKeys.push_back( key);
+            aiQuatKey key;
+            key.mTime = double(time);
+            key.mValue.w = ReadFloat();
+            key.mValue.x = ReadFloat();
+            key.mValue.y = ReadFloat();
+            key.mValue.z = ReadFloat();
+            pAnimBone->mRotKeys.push_back(key);
 
-                CheckForSemicolon();
-                break;
-            }
+            CheckForSemicolon();
+            break;
+        }
 
-            case 1: // scale vector
-            case 2: // position vector
-            {
-                // read count
-                if( ReadInt() != 3)
-                    ThrowException( "Invalid number of arguments for vector key in animation");
+        case 1: // scale vector
+        case 2: // position vector
+        {
+            // read count
+            if (ReadInt() != 3)
+                ThrowException("Invalid number of arguments for vector key in animation");
 
-                aiVectorKey key;
-                key.mTime = double( time);
-                key.mValue = ReadVector3();
+            aiVectorKey key;
+            key.mTime = double(time);
+            key.mValue = ReadVector3();
 
-                if( keyType == 2)
-                    pAnimBone->mPosKeys.push_back( key);
-                else
-                    pAnimBone->mScaleKeys.push_back( key);
+            if (keyType == 2)
+                pAnimBone->mPosKeys.push_back(key);
+            else
+                pAnimBone->mScaleKeys.push_back(key);
 
-                break;
-            }
+            break;
+        }
 
-            case 3: // combined transformation matrix
-            case 4: // denoted both as 3 or as 4
-            {
-                // read count
-                if( ReadInt() != 16)
-                    ThrowException( "Invalid number of arguments for matrix key in animation");
+        case 3: // combined transformation matrix
+        case 4: // denoted both as 3 or as 4
+        {
+            // read count
+            if (ReadInt() != 16)
+                ThrowException("Invalid number of arguments for matrix key in animation");
 
-                // read matrix
-                MatrixKey key;
-                key.mTime = double( time);
-                key.mMatrix.a1 = ReadFloat(); key.mMatrix.b1 = ReadFloat();
-                key.mMatrix.c1 = ReadFloat(); key.mMatrix.d1 = ReadFloat();
-                key.mMatrix.a2 = ReadFloat(); key.mMatrix.b2 = ReadFloat();
-                key.mMatrix.c2 = ReadFloat(); key.mMatrix.d2 = ReadFloat();
-                key.mMatrix.a3 = ReadFloat(); key.mMatrix.b3 = ReadFloat();
-                key.mMatrix.c3 = ReadFloat(); key.mMatrix.d3 = ReadFloat();
-                key.mMatrix.a4 = ReadFloat(); key.mMatrix.b4 = ReadFloat();
-                key.mMatrix.c4 = ReadFloat(); key.mMatrix.d4 = ReadFloat();
-                pAnimBone->mTrafoKeys.push_back( key);
+            // read matrix
+            MatrixKey key;
+            key.mTime = double(time);
+            key.mMatrix.a1 = ReadFloat();
+            key.mMatrix.b1 = ReadFloat();
+            key.mMatrix.c1 = ReadFloat();
+            key.mMatrix.d1 = ReadFloat();
+            key.mMatrix.a2 = ReadFloat();
+            key.mMatrix.b2 = ReadFloat();
+            key.mMatrix.c2 = ReadFloat();
+            key.mMatrix.d2 = ReadFloat();
+            key.mMatrix.a3 = ReadFloat();
+            key.mMatrix.b3 = ReadFloat();
+            key.mMatrix.c3 = ReadFloat();
+            key.mMatrix.d3 = ReadFloat();
+            key.mMatrix.a4 = ReadFloat();
+            key.mMatrix.b4 = ReadFloat();
+            key.mMatrix.c4 = ReadFloat();
+            key.mMatrix.d4 = ReadFloat();
+            pAnimBone->mTrafoKeys.push_back(key);
 
-                CheckForSemicolon();
-                break;
-            }
+            CheckForSemicolon();
+            break;
+        }
 
-            default:
-                ThrowException( format() << "Unknown key type " << keyType << " in animation." );
-                break;
+        default:
+            ThrowException("Unknown key type ", keyType, " in animation.");
+            break;
         } // end switch
 
         // key separator
@@ -950,115 +850,103 @@ void XFileParser::ParseDataObjectAnimationKey( AnimBone* pAnimBone)
 }
 
 // ------------------------------------------------------------------------------------------------
-void XFileParser::ParseDataObjectTextureFilename( std::string& pName)
-{
+void XFileParser::ParseDataObjectTextureFilename(std::string &pName) {
     readHeadOfDataObject();
-    GetNextTokenAsString( pName);
+    GetNextTokenAsString(pName);
     CheckForClosingBrace();
 
     // FIX: some files (e.g. AnimationTest.x) have "" as texture file name
-    if (!pName.length())
-    {
+    if (!pName.length()) {
         ASSIMP_LOG_WARN("Length of texture file name is zero. Skipping this texture.");
     }
 
     // some exporters write double backslash paths out. We simply replace them if we find them
-    while( pName.find( "\\\\") != std::string::npos)
-        pName.replace( pName.find( "\\\\"), 2, "\\");
+    while (pName.find("\\\\") != std::string::npos)
+        pName.replace(pName.find("\\\\"), 2, "\\");
 }
 
 // ------------------------------------------------------------------------------------------------
-void XFileParser::ParseUnknownDataObject()
-{
+void XFileParser::ParseUnknownDataObject() {
     // find opening delimiter
     bool running = true;
-    while( running )
-    {
+    while (running) {
         std::string t = GetNextToken();
-        if( t.length() == 0)
-            ThrowException( "Unexpected end of file while parsing unknown segment.");
+        if (t.length() == 0)
+            ThrowException("Unexpected end of file while parsing unknown segment.");
 
-        if( t == "{")
+        if (t == "{")
             break;
     }
 
     unsigned int counter = 1;
 
     // parse until closing delimiter
-    while( counter > 0)
-    {
+    while (counter > 0) {
         std::string t = GetNextToken();
 
-        if( t.length() == 0)
-            ThrowException( "Unexpected end of file while parsing unknown segment.");
+        if (t.length() == 0)
+            ThrowException("Unexpected end of file while parsing unknown segment.");
 
-        if( t == "{")
+        if (t == "{")
             ++counter;
-        else
-        if( t == "}")
+        else if (t == "}")
             --counter;
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 //! checks for closing curly brace
-void XFileParser::CheckForClosingBrace()
-{
-    if( GetNextToken() != "}")
-        ThrowException( "Closing brace expected.");
+void XFileParser::CheckForClosingBrace() {
+    if (GetNextToken() != "}")
+        ThrowException("Closing brace expected.");
 }
 
 // ------------------------------------------------------------------------------------------------
 //! checks for one following semicolon
-void XFileParser::CheckForSemicolon()
-{
-    if( mIsBinaryFormat)
+void XFileParser::CheckForSemicolon() {
+    if (mIsBinaryFormat)
         return;
 
-    if( GetNextToken() != ";")
-        ThrowException( "Semicolon expected.");
+    if (GetNextToken() != ";")
+        ThrowException("Semicolon expected.");
 }
 
 // ------------------------------------------------------------------------------------------------
 //! checks for a separator char, either a ',' or a ';'
-void XFileParser::CheckForSeparator()
-{
-    if( mIsBinaryFormat)
+void XFileParser::CheckForSeparator() {
+    if (mIsBinaryFormat)
         return;
 
     std::string token = GetNextToken();
-    if( token != "," && token != ";")
-        ThrowException( "Separator character (';' or ',') expected.");
+    if (token != "," && token != ";")
+        ThrowException("Separator character (';' or ',') expected.");
 }
 
 // ------------------------------------------------------------------------------------------------
 // tests and possibly consumes a separator char, but does nothing if there was no separator
-void XFileParser::TestForSeparator()
-{
-  if( mIsBinaryFormat)
-    return;
+void XFileParser::TestForSeparator() {
+    if (mIsBinaryFormat)
+        return;
 
-  FindNextNoneWhiteSpace();
-  if( mP >= mEnd)
-    return;
+    FindNextNoneWhiteSpace();
+    if (mP >= mEnd)
+        return;
 
-  // test and skip
-  if( *mP == ';' || *mP == ',')
-    mP++;
+    // test and skip
+    if (*mP == ';' || *mP == ',')
+        mP++;
 }
 
 // ------------------------------------------------------------------------------------------------
-void XFileParser::readHeadOfDataObject( std::string* poName)
-{
+void XFileParser::readHeadOfDataObject(std::string *poName) {
     std::string nameOrBrace = GetNextToken();
-    if( nameOrBrace != "{")
-    {
-        if( poName)
+    if (nameOrBrace != "{") {
+        if (poName)
             *poName = nameOrBrace;
 
-        if ( GetNextToken() != "{" ) {
+        if (GetNextToken() != "{") {
             delete mScene;
-            ThrowException( "Opening brace expected." );
+            ThrowException("Opening brace expected.");
         }
     }
 }
@@ -1068,157 +956,151 @@ std::string XFileParser::GetNextToken() {
     std::string s;
 
     // process binary-formatted file
-    if( mIsBinaryFormat) {
+    if (mIsBinaryFormat) {
         // in binary mode it will only return NAME and STRING token
         // and (correctly) skip over other tokens.
-        if ( mEnd - mP < 2 ) {
+        if (mEnd - mP < 2) {
             return s;
         }
         unsigned int tok = ReadBinWord();
         unsigned int len;
 
         // standalone tokens
-        switch( tok ) {
-            case 1: {
-                // name token
-                if ( mEnd - mP < 4 ) {
-                    return s;
-                }
-                len = ReadBinDWord();
-                const int bounds = int( mEnd - mP );
-                const int iLen   = int( len );
-                if ( iLen < 0 ) {
-                    return s;
-                }
-                if ( bounds < iLen ) {
-                    return s;
-                }
-                s = std::string( mP, len );
-                mP += len;
+        switch (tok) {
+        case 1: {
+            // name token
+            if (mEnd - mP < 4) {
+                return s;
             }
+            len = ReadBinDWord();
+            const int bounds = int(mEnd - mP);
+            const int iLen = int(len);
+            if (iLen < 0) {
+                return s;
+            }
+            if (bounds < iLen) {
+                return s;
+            }
+            s = std::string(mP, len);
+            mP += len;
+        }
             return s;
 
-            case 2:
-                // string token
-                if( mEnd - mP < 4) return s;
-                len = ReadBinDWord();
-                if( mEnd - mP < int(len)) return s;
-                s = std::string(mP, len);
-                mP += (len + 2);
-                return s;
-            case 3:
-                // integer token
-                mP += 4;
-                return "<integer>";
-            case 5:
-                // GUID token
-                mP += 16;
-                return "<guid>";
-            case 6:
-                if( mEnd - mP < 4) return s;
-                len = ReadBinDWord();
-                mP += (len * 4);
-                return "<int_list>";
-            case 7:
-                if( mEnd - mP < 4) return s;
-                len = ReadBinDWord();
-                mP += (len * mBinaryFloatSize);
-                return "<flt_list>";
-            case 0x0a:
-                return "{";
-            case 0x0b:
-                return "}";
-            case 0x0c:
-                return "(";
-            case 0x0d:
-                return ")";
-            case 0x0e:
-                return "[";
-            case 0x0f:
-                return "]";
-            case 0x10:
-                return "<";
-            case 0x11:
-                return ">";
-            case 0x12:
-                return ".";
-            case 0x13:
-                return ",";
-            case 0x14:
-                return ";";
-            case 0x1f:
-                return "template";
-            case 0x28:
-                return "WORD";
-            case 0x29:
-                return "DWORD";
-            case 0x2a:
-                return "FLOAT";
-            case 0x2b:
-                return "DOUBLE";
-            case 0x2c:
-                return "CHAR";
-            case 0x2d:
-                return "UCHAR";
-            case 0x2e:
-                return "SWORD";
-            case 0x2f:
-                return "SDWORD";
-            case 0x30:
-                return "void";
-            case 0x31:
-                return "string";
-            case 0x32:
-                return "unicode";
-            case 0x33:
-                return "cstring";
-            case 0x34:
-                return "array";
+        case 2:
+            // string token
+            if (mEnd - mP < 4) return s;
+            len = ReadBinDWord();
+            if (mEnd - mP < int(len)) return s;
+            s = std::string(mP, len);
+            mP += (len + 2);
+            return s;
+        case 3:
+            // integer token
+            mP += 4;
+            return "<integer>";
+        case 5:
+            // GUID token
+            mP += 16;
+            return "<guid>";
+        case 6:
+            if (mEnd - mP < 4) return s;
+            len = ReadBinDWord();
+            mP += (len * 4);
+            return "<int_list>";
+        case 7:
+            if (mEnd - mP < 4) return s;
+            len = ReadBinDWord();
+            mP += (len * mBinaryFloatSize);
+            return "<flt_list>";
+        case 0x0a:
+            return "{";
+        case 0x0b:
+            return "}";
+        case 0x0c:
+            return "(";
+        case 0x0d:
+            return ")";
+        case 0x0e:
+            return "[";
+        case 0x0f:
+            return "]";
+        case 0x10:
+            return "<";
+        case 0x11:
+            return ">";
+        case 0x12:
+            return ".";
+        case 0x13:
+            return ",";
+        case 0x14:
+            return ";";
+        case 0x1f:
+            return "template";
+        case 0x28:
+            return "WORD";
+        case 0x29:
+            return "DWORD";
+        case 0x2a:
+            return "FLOAT";
+        case 0x2b:
+            return "DOUBLE";
+        case 0x2c:
+            return "CHAR";
+        case 0x2d:
+            return "UCHAR";
+        case 0x2e:
+            return "SWORD";
+        case 0x2f:
+            return "SDWORD";
+        case 0x30:
+            return "void";
+        case 0x31:
+            return "string";
+        case 0x32:
+            return "unicode";
+        case 0x33:
+            return "cstring";
+        case 0x34:
+            return "array";
         }
     }
     // process text-formatted file
-    else
-    {
+    else {
         FindNextNoneWhiteSpace();
-        if( mP >= mEnd)
+        if (mP >= mEnd)
             return s;
 
-        while( (mP < mEnd) && !isspace( (unsigned char) *mP))
-        {
+        while ((mP < mEnd) && !isspace((unsigned char)*mP)) {
             // either keep token delimiters when already holding a token, or return if first valid char
-            if( *mP == ';' || *mP == '}' || *mP == '{' || *mP == ',')
-            {
-                if( !s.size())
-                    s.append( mP++, 1);
+            if (*mP == ';' || *mP == '}' || *mP == '{' || *mP == ',') {
+                if (!s.size())
+                    s.append(mP++, 1);
                 break; // stop for delimiter
             }
-            s.append( mP++, 1);
+            s.append(mP++, 1);
         }
     }
     return s;
 }
 
 // ------------------------------------------------------------------------------------------------
-void XFileParser::FindNextNoneWhiteSpace()
-{
-    if( mIsBinaryFormat)
+void XFileParser::FindNextNoneWhiteSpace() {
+    if (mIsBinaryFormat)
         return;
 
     bool running = true;
-    while( running )
-    {
-        while( mP < mEnd && isspace( (unsigned char) *mP))
-        {
-            if( *mP == '\n')
+    while (running) {
+        while (mP < mEnd && isspace((unsigned char)*mP)) {
+            if (*mP == '\n')
                 mLineNumber++;
             ++mP;
         }
 
-        if( mP >= mEnd)
+        if (mP >= mEnd)
             return;
 
         // check if this is a comment
-        if( (mP[0] == '/' && mP[1] == '/') || mP[0] == '#')
+        if ((mP[0] == '/' && mP[1] == '/') || mP[0] == '#')
             ReadUntilEndOfLine();
         else
             break;
@@ -1226,52 +1108,48 @@ void XFileParser::FindNextNoneWhiteSpace()
 }
 
 // ------------------------------------------------------------------------------------------------
-void XFileParser::GetNextTokenAsString( std::string& poString)
-{
-    if( mIsBinaryFormat)
-    {
+void XFileParser::GetNextTokenAsString(std::string &poString) {
+    if (mIsBinaryFormat) {
         poString = GetNextToken();
         return;
     }
 
     FindNextNoneWhiteSpace();
-    if ( mP >= mEnd ) {
+    if (mP >= mEnd) {
         delete mScene;
-        ThrowException( "Unexpected end of file while parsing string" );
+        ThrowException("Unexpected end of file while parsing string");
     }
 
-    if ( *mP != '"' ) {
+    if (*mP != '"') {
         delete mScene;
-        ThrowException( "Expected quotation mark." );
+        ThrowException("Expected quotation mark.");
     }
     ++mP;
 
-    while( mP < mEnd && *mP != '"')
-        poString.append( mP++, 1);
+    while (mP < mEnd && *mP != '"')
+        poString.append(mP++, 1);
 
-    if ( mP >= mEnd - 1 ) {
+    if (mP >= mEnd - 1) {
         delete mScene;
-        ThrowException( "Unexpected end of file while parsing string" );
+        ThrowException("Unexpected end of file while parsing string");
     }
 
-    if ( mP[ 1 ] != ';' || mP[ 0 ] != '"' ) {
+    if (mP[1] != ';' || mP[0] != '"') {
         delete mScene;
-        ThrowException( "Expected quotation mark and semicolon at the end of a string." );
+        ThrowException("Expected quotation mark and semicolon at the end of a string.");
     }
-    mP+=2;
+    mP += 2;
 }
 
 // ------------------------------------------------------------------------------------------------
-void XFileParser::ReadUntilEndOfLine()
-{
-    if( mIsBinaryFormat)
+void XFileParser::ReadUntilEndOfLine() {
+    if (mIsBinaryFormat)
         return;
 
-    while( mP < mEnd)
-    {
-        if( *mP == '\n' || *mP == '\r')
-        {
-            ++mP; mLineNumber++;
+    while (mP < mEnd) {
+        if (*mP == '\n' || *mP == '\r') {
+            ++mP;
+            mLineNumber++;
             return;
         }
 
@@ -1280,10 +1158,9 @@ void XFileParser::ReadUntilEndOfLine()
 }
 
 // ------------------------------------------------------------------------------------------------
-unsigned short XFileParser::ReadBinWord()
-{
+unsigned short XFileParser::ReadBinWord() {
     ai_assert(mEnd - mP >= 2);
-    const unsigned char* q = (const unsigned char*) mP;
+    const unsigned char *q = (const unsigned char *)mP;
     unsigned short tmp = q[0] | (q[1] << 8);
     mP += 2;
     return tmp;
@@ -1293,57 +1170,51 @@ unsigned short XFileParser::ReadBinWord()
 unsigned int XFileParser::ReadBinDWord() {
     ai_assert(mEnd - mP >= 4);
 
-    const unsigned char* q = (const unsigned char*) mP;
+    const unsigned char *q = (const unsigned char *)mP;
     unsigned int tmp = q[0] | (q[1] << 8) | (q[2] << 16) | (q[3] << 24);
     mP += 4;
     return tmp;
 }
 
 // ------------------------------------------------------------------------------------------------
-unsigned int XFileParser::ReadInt()
-{
-   if( mIsBinaryFormat)
-    {
-        if( mBinaryNumCount == 0 && mEnd - mP >= 2)
-        {
+unsigned int XFileParser::ReadInt() {
+    if (mIsBinaryFormat) {
+        if (mBinaryNumCount == 0 && mEnd - mP >= 2) {
             unsigned short tmp = ReadBinWord(); // 0x06 or 0x03
-            if( tmp == 0x06 && mEnd - mP >= 4) // array of ints follows
+            if (tmp == 0x06 && mEnd - mP >= 4) // array of ints follows
                 mBinaryNumCount = ReadBinDWord();
             else // single int follows
                 mBinaryNumCount = 1;
         }
 
         --mBinaryNumCount;
-        const size_t len( mEnd - mP );
-        if ( len >= 4) {
+        const size_t len(mEnd - mP);
+        if (len >= 4) {
             return ReadBinDWord();
         } else {
             mP = mEnd;
             return 0;
         }
-    } else
-    {
+    } else {
         FindNextNoneWhiteSpace();
 
         // TODO: consider using strtol10 instead???
 
         // check preceding minus sign
         bool isNegative = false;
-        if( *mP == '-')
-        {
+        if (*mP == '-') {
             isNegative = true;
             mP++;
         }
 
         // at least one digit expected
-        if( !isdigit( *mP))
-            ThrowException( "Number expected.");
+        if (!isdigit((unsigned char)*mP))
+            ThrowException("Number expected.");
 
         // read digits
         unsigned int number = 0;
-        while( mP < mEnd)
-        {
-            if( !isdigit( *mP))
+        while (mP < mEnd) {
+            if (!isdigit((unsigned char)*mP))
                 break;
             number = number * 10 + (*mP - 48);
             mP++;
@@ -1351,40 +1222,37 @@ unsigned int XFileParser::ReadInt()
 
         CheckForSeparator();
 
-        return isNegative ? ((unsigned int) -int( number)) : number;
+        return isNegative ? ((unsigned int)-int(number)) : number;
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-ai_real XFileParser::ReadFloat()
-{
-    if( mIsBinaryFormat)
-    {
-        if( mBinaryNumCount == 0 && mEnd - mP >= 2)
-        {
+ai_real XFileParser::ReadFloat() {
+    if (mIsBinaryFormat) {
+        if (mBinaryNumCount == 0 && mEnd - mP >= 2) {
             unsigned short tmp = ReadBinWord(); // 0x07 or 0x42
-            if( tmp == 0x07 && mEnd - mP >= 4) // array of floats following
+            if (tmp == 0x07 && mEnd - mP >= 4) // array of floats following
                 mBinaryNumCount = ReadBinDWord();
             else // single float following
                 mBinaryNumCount = 1;
         }
 
         --mBinaryNumCount;
-        if( mBinaryFloatSize == 8) {
-            if( mEnd - mP >= 8) {
+        if (mBinaryFloatSize == 8) {
+            if (mEnd - mP >= 8) {
                 double res;
-                ::memcpy( &res, mP, 8 );
+                ::memcpy(&res, mP, 8);
                 mP += 8;
-                const ai_real result( static_cast<ai_real>( res ) );
+                const ai_real result(static_cast<ai_real>(res));
                 return result;
             } else {
                 mP = mEnd;
                 return 0;
             }
         } else {
-            if( mEnd - mP >= 4) {
+            if (mEnd - mP >= 4) {
                 ai_real result;
-                ::memcpy( &result, mP, 4 );
+                ::memcpy(&result, mP, 4);
                 mP += 4;
                 return result;
             } else {
@@ -1399,21 +1267,18 @@ ai_real XFileParser::ReadFloat()
     // check for various special strings to allow reading files from faulty exporters
     // I mean you, Blender!
     // Reading is safe because of the terminating zero
-    if( strncmp( mP, "-1.#IND00", 9) == 0 || strncmp( mP, "1.#IND00", 8) == 0)
-    {
+    if (strncmp(mP, "-1.#IND00", 9) == 0 || strncmp(mP, "1.#IND00", 8) == 0) {
         mP += 9;
         CheckForSeparator();
         return 0.0;
-    } else
-    if( strncmp( mP, "1.#QNAN0", 8) == 0)
-    {
+    } else if (strncmp(mP, "1.#QNAN0", 8) == 0) {
         mP += 8;
         CheckForSeparator();
         return 0.0;
     }
 
     ai_real result = 0.0;
-    mP = fast_atoreal_move<ai_real>( mP, result);
+    mP = fast_atoreal_move<ai_real>(mP, result);
 
     CheckForSeparator();
 
@@ -1421,8 +1286,7 @@ ai_real XFileParser::ReadFloat()
 }
 
 // ------------------------------------------------------------------------------------------------
-aiVector2D XFileParser::ReadVector2()
-{
+aiVector2D XFileParser::ReadVector2() {
     aiVector2D vector;
     vector.x = ReadFloat();
     vector.y = ReadFloat();
@@ -1432,8 +1296,7 @@ aiVector2D XFileParser::ReadVector2()
 }
 
 // ------------------------------------------------------------------------------------------------
-aiVector3D XFileParser::ReadVector3()
-{
+aiVector3D XFileParser::ReadVector3() {
     aiVector3D vector;
     vector.x = ReadFloat();
     vector.y = ReadFloat();
@@ -1444,8 +1307,7 @@ aiVector3D XFileParser::ReadVector3()
 }
 
 // ------------------------------------------------------------------------------------------------
-aiColor4D XFileParser::ReadRGBA()
-{
+aiColor4D XFileParser::ReadRGBA() {
     aiColor4D color;
     color.r = ReadFloat();
     color.g = ReadFloat();
@@ -1457,8 +1319,7 @@ aiColor4D XFileParser::ReadRGBA()
 }
 
 // ------------------------------------------------------------------------------------------------
-aiColor3D XFileParser::ReadRGB()
-{
+aiColor3D XFileParser::ReadRGB() {
     aiColor3D color;
     color.r = ReadFloat();
     color.g = ReadFloat();
@@ -1468,31 +1329,18 @@ aiColor3D XFileParser::ReadRGB()
     return color;
 }
 
-// ------------------------------------------------------------------------------------------------
-// Throws an exception with a line number and the given text.
-AI_WONT_RETURN void XFileParser::ThrowException( const std::string& pText) {
-    if ( mIsBinaryFormat ) {
-        throw DeadlyImportError( pText );
-    } else {
-        throw DeadlyImportError( format() << "Line " << mLineNumber << ": " << pText );
-    }
-}
-
 // ------------------------------------------------------------------------------------------------
 // Filters the imported hierarchy for some degenerated cases that some exporters produce.
-void XFileParser::FilterHierarchy( XFile::Node* pNode)
-{
+void XFileParser::FilterHierarchy(XFile::Node *pNode) {
     // if the node has just a single unnamed child containing a mesh, remove
     // the anonymous node between. The 3DSMax kwXport plugin seems to produce this
     // mess in some cases
-    if( pNode->mChildren.size() == 1 && pNode->mMeshes.empty() )
-    {
-        XFile::Node* child = pNode->mChildren.front();
-        if( child->mName.length() == 0 && child->mMeshes.size() > 0)
-        {
+    if (pNode->mChildren.size() == 1 && pNode->mMeshes.empty()) {
+        XFile::Node *child = pNode->mChildren.front();
+        if (child->mName.length() == 0 && child->mMeshes.size() > 0) {
             // transfer its meshes to us
-            for( unsigned int a = 0; a < child->mMeshes.size(); a++)
-                pNode->mMeshes.push_back( child->mMeshes[a]);
+            for (unsigned int a = 0; a < child->mMeshes.size(); a++)
+                pNode->mMeshes.push_back(child->mMeshes[a]);
             child->mMeshes.clear();
 
             // transfer the transform as well
@@ -1505,8 +1353,8 @@ void XFileParser::FilterHierarchy( XFile::Node* pNode)
     }
 
     // recurse
-    for( unsigned int a = 0; a < pNode->mChildren.size(); a++)
-        FilterHierarchy( pNode->mChildren[a]);
+    for (unsigned int a = 0; a < pNode->mChildren.size(); a++)
+        FilterHierarchy(pNode->mChildren[a]);
 }
 
 #endif // !! ASSIMP_BUILD_NO_X_IMPORTER
diff --git a/Engine/lib/assimp/code/X/XFileParser.h b/Engine/lib/assimp/code/AssetLib/X/XFileParser.h
similarity index 96%
rename from Engine/lib/assimp/code/X/XFileParser.h
rename to Engine/lib/assimp/code/AssetLib/X/XFileParser.h
index 993bae6a1..36eac2ada 100644
--- a/Engine/lib/assimp/code/X/XFileParser.h
+++ b/Engine/lib/assimp/code/AssetLib/X/XFileParser.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -104,7 +104,7 @@ protected:
     //! reads header of data object including the opening brace.
     //! returns false if error happened, and writes name of object
     //! if there is one
-    void readHeadOfDataObject( std::string* poName = NULL);
+    void readHeadOfDataObject(std::string *poName = nullptr);
 
     //! checks for closing curly brace, throws exception if not there
     void CheckForClosingBrace();
@@ -133,7 +133,8 @@ protected:
     aiColor4D ReadRGBA();
 
     /** Throws an exception with a line number and the given text. */
-    AI_WONT_RETURN void ThrowException( const std::string& pText) AI_WONT_RETURN_SUFFIX;
+    template<typename... T>
+    AI_WONT_RETURN void ThrowException(T&&... args) AI_WONT_RETURN_SUFFIX;
 
     /**
       * @brief  Filters the imported hierarchy for some degenerated cases that some exporters produce.
diff --git a/Engine/lib/assimp/code/AssetLib/X3D/X3DExporter.cpp b/Engine/lib/assimp/code/AssetLib/X3D/X3DExporter.cpp
new file mode 100644
index 000000000..b3278a528
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/X3D/X3DExporter.cpp
@@ -0,0 +1,675 @@
+/// \file   X3DExporter.cpp
+/// \brief  X3D-format files exporter for Assimp. Implementation.
+/// \date   2016
+/// \author smal.root@gmail.com
+
+#ifndef ASSIMP_BUILD_NO_EXPORT
+#ifndef ASSIMP_BUILD_NO_X3D_EXPORTER
+
+#include "X3DExporter.hpp"
+
+// Header files, Assimp.
+#include <assimp/Exceptional.h>
+#include <assimp/StringUtils.h>
+#include <assimp/Exporter.hpp>
+#include <assimp/IOSystem.hpp>
+
+using namespace std;
+
+namespace Assimp {
+
+void ExportSceneX3D(const char *pFile, IOSystem *pIOSystem, const aiScene *pScene, const ExportProperties *pProperties) {
+    X3DExporter exporter(pFile, pIOSystem, pScene, pProperties);
+}
+
+} // namespace Assimp
+
+namespace Assimp {
+
+void X3DExporter::IndentationStringSet(const size_t pNewLevel) {
+    if (pNewLevel > mIndentationString.size()) {
+        if (pNewLevel > mIndentationString.capacity()) mIndentationString.reserve(pNewLevel + 1);
+
+        for (size_t i = 0, i_e = pNewLevel - mIndentationString.size(); i < i_e; i++)
+            mIndentationString.push_back('\t');
+    } else if (pNewLevel < mIndentationString.size()) {
+        mIndentationString.resize(pNewLevel);
+    }
+}
+
+void X3DExporter::XML_Write(const string &pData) {
+    if (pData.size() == 0) return;
+    if (mOutFile->Write((void *)pData.data(), pData.length(), 1) != 1) throw DeadlyExportError("Failed to write scene data!");
+}
+
+aiMatrix4x4 X3DExporter::Matrix_GlobalToCurrent(const aiNode &pNode) const {
+    aiNode *cur_node;
+    std::list<aiMatrix4x4> matr;
+    aiMatrix4x4 out_matr;
+
+    // starting walk from current element to root
+    matr.push_back(pNode.mTransformation);
+    cur_node = pNode.mParent;
+    if (cur_node != nullptr) {
+        do {
+            matr.push_back(cur_node->mTransformation);
+            cur_node = cur_node->mParent;
+        } while (cur_node != nullptr);
+    }
+
+    // multiplicate all matrices in reverse order
+    for (std::list<aiMatrix4x4>::reverse_iterator rit = matr.rbegin(); rit != matr.rend(); ++rit)
+        out_matr = out_matr * (*rit);
+
+    return out_matr;
+}
+
+void X3DExporter::AttrHelper_FloatToString(const float pValue, std::string &pTargetString) {
+    pTargetString = to_string(pValue);
+    AttrHelper_CommaToPoint(pTargetString);
+}
+
+void X3DExporter::AttrHelper_Vec3DArrToString(const aiVector3D *pArray, const size_t pArray_Size, string &pTargetString) {
+    pTargetString.clear();
+    pTargetString.reserve(pArray_Size * 6); // (Number + space) * 3.
+    for (size_t idx = 0; idx < pArray_Size; idx++)
+        pTargetString.append(to_string(pArray[idx].x) + " " + to_string(pArray[idx].y) + " " + to_string(pArray[idx].z) + " ");
+
+    // remove last space symbol.
+    pTargetString.resize(pTargetString.length() - 1);
+    AttrHelper_CommaToPoint(pTargetString);
+}
+
+void X3DExporter::AttrHelper_Vec2DArrToString(const aiVector2D *pArray, const size_t pArray_Size, std::string &pTargetString) {
+    pTargetString.clear();
+    pTargetString.reserve(pArray_Size * 4); // (Number + space) * 2.
+    for (size_t idx = 0; idx < pArray_Size; idx++)
+        pTargetString.append(to_string(pArray[idx].x) + " " + to_string(pArray[idx].y) + " ");
+
+    // remove last space symbol.
+    pTargetString.resize(pTargetString.length() - 1);
+    AttrHelper_CommaToPoint(pTargetString);
+}
+
+void X3DExporter::AttrHelper_Vec3DAsVec2fArrToString(const aiVector3D *pArray, const size_t pArray_Size, string &pTargetString) {
+    pTargetString.clear();
+    pTargetString.reserve(pArray_Size * 4); // (Number + space) * 2.
+    for (size_t idx = 0; idx < pArray_Size; idx++)
+        pTargetString.append(to_string(pArray[idx].x) + " " + to_string(pArray[idx].y) + " ");
+
+    // remove last space symbol.
+    pTargetString.resize(pTargetString.length() - 1);
+    AttrHelper_CommaToPoint(pTargetString);
+}
+
+void X3DExporter::AttrHelper_Col4DArrToString(const aiColor4D *pArray, const size_t pArray_Size, string &pTargetString) {
+    pTargetString.clear();
+    pTargetString.reserve(pArray_Size * 8); // (Number + space) * 4.
+    for (size_t idx = 0; idx < pArray_Size; idx++)
+        pTargetString.append(to_string(pArray[idx].r) + " " + to_string(pArray[idx].g) + " " + to_string(pArray[idx].b) + " " +
+                             to_string(pArray[idx].a) + " ");
+
+    // remove last space symbol.
+    pTargetString.resize(pTargetString.length() - 1);
+    AttrHelper_CommaToPoint(pTargetString);
+}
+
+void X3DExporter::AttrHelper_Col3DArrToString(const aiColor3D *pArray, const size_t pArray_Size, std::string &pTargetString) {
+    pTargetString.clear();
+    pTargetString.reserve(pArray_Size * 6); // (Number + space) * 3.
+    for (size_t idx = 0; idx < pArray_Size; idx++)
+        pTargetString.append(to_string(pArray[idx].r) + " " + to_string(pArray[idx].g) + " " + to_string(pArray[idx].b) + " ");
+
+    // remove last space symbol.
+    pTargetString.resize(pTargetString.length() - 1);
+    AttrHelper_CommaToPoint(pTargetString);
+}
+
+void X3DExporter::AttrHelper_Color3ToAttrList(std::list<SAttribute> &pList, const std::string &pName, const aiColor3D &pValue, const aiColor3D &pDefaultValue) {
+    string tstr;
+
+    if (pValue == pDefaultValue) return;
+
+    AttrHelper_Col3DArrToString(&pValue, 1, tstr);
+    pList.push_back({ pName, tstr });
+}
+
+void X3DExporter::AttrHelper_FloatToAttrList(std::list<SAttribute> &pList, const string &pName, const float pValue, const float pDefaultValue) {
+    string tstr;
+
+    if (pValue == pDefaultValue) return;
+
+    AttrHelper_FloatToString(pValue, tstr);
+    pList.push_back({ pName, tstr });
+}
+
+void X3DExporter::NodeHelper_OpenNode(const string &pNodeName, const size_t pTabLevel, const bool pEmptyElement, const list<SAttribute> &pAttrList) {
+    // Write indentation.
+    IndentationStringSet(pTabLevel);
+    XML_Write(mIndentationString);
+    // Begin of the element
+    XML_Write("<" + pNodeName);
+    // Write attributes
+    for (const SAttribute &attr : pAttrList) {
+        XML_Write(" " + attr.Name + "='" + attr.Value + "'");
+    }
+
+    // End of the element
+    if (pEmptyElement) {
+        XML_Write("/>\n");
+    } else {
+        XML_Write(">\n");
+    }
+}
+
+void X3DExporter::NodeHelper_OpenNode(const string &pNodeName, const size_t pTabLevel, const bool pEmptyElement) {
+    const list<SAttribute> attr_list;
+
+    NodeHelper_OpenNode(pNodeName, pTabLevel, pEmptyElement, attr_list);
+}
+
+void X3DExporter::NodeHelper_CloseNode(const string &pNodeName, const size_t pTabLevel) {
+    // Write indentation.
+    IndentationStringSet(pTabLevel);
+    XML_Write(mIndentationString);
+    // Write element
+    XML_Write("</" + pNodeName + ">\n");
+}
+
+void X3DExporter::Export_Node(const aiNode *pNode, const size_t pTabLevel) {
+    bool transform = false;
+    list<SAttribute> attr_list;
+
+    // In Assimp lights is stored in next way: light source store in mScene->mLights and in node tree must present aiNode with name same as
+    // light source has. Considering it we must compare every aiNode name with light sources names. Why not to look where ligths is present
+    // and save them to fili? Because corresponding aiNode can be already written to file and we can only add information to file not to edit.
+    if (CheckAndExport_Light(*pNode, pTabLevel)) return;
+
+    // Check if need DEF.
+    if (pNode->mName.length) attr_list.push_back({ "DEF", pNode->mName.C_Str() });
+
+    // Check if need <Transformation> node against <Group>.
+    if (!pNode->mTransformation.IsIdentity()) {
+        auto Vector2String = [this](const aiVector3D pVector) -> string {
+            string tstr = to_string(pVector.x) + " " + to_string(pVector.y) + " " + to_string(pVector.z);
+
+            AttrHelper_CommaToPoint(tstr);
+
+            return tstr;
+        };
+
+        auto Rotation2String = [this](const aiVector3D pAxis, const ai_real pAngle) -> string {
+            string tstr = to_string(pAxis.x) + " " + to_string(pAxis.y) + " " + to_string(pAxis.z) + " " + to_string(pAngle);
+
+            AttrHelper_CommaToPoint(tstr);
+
+            return tstr;
+        };
+
+        aiVector3D scale, translate, rotate_axis;
+        ai_real rotate_angle;
+
+        transform = true;
+        pNode->mTransformation.Decompose(scale, rotate_axis, rotate_angle, translate);
+        // Check if values different from default
+        if ((rotate_angle != 0) && (rotate_axis.Length() > 0))
+            attr_list.push_back({ "rotation", Rotation2String(rotate_axis, rotate_angle) });
+
+        if (!scale.Equal({ 1.0, 1.0, 1.0 })) {
+            attr_list.push_back({ "scale", Vector2String(scale) });
+        }
+        if (translate.Length() > 0) {
+            attr_list.push_back({ "translation", Vector2String(translate) });
+        }
+    }
+
+    // Begin node if need.
+    if (transform)
+        NodeHelper_OpenNode("Transform", pTabLevel, false, attr_list);
+    else
+        NodeHelper_OpenNode("Group", pTabLevel);
+
+    // Export metadata
+    if (pNode->mMetaData != nullptr) {
+        for (size_t idx_prop = 0; idx_prop < pNode->mMetaData->mNumProperties; idx_prop++) {
+            const aiString *key;
+            const aiMetadataEntry *entry;
+
+            if (pNode->mMetaData->Get(idx_prop, key, entry)) {
+                switch (entry->mType) {
+                case AI_BOOL:
+                    Export_MetadataBoolean(*key, *static_cast<bool *>(entry->mData), pTabLevel + 1);
+                    break;
+                case AI_DOUBLE:
+                    Export_MetadataDouble(*key, *static_cast<double *>(entry->mData), pTabLevel + 1);
+                    break;
+                case AI_FLOAT:
+                    Export_MetadataFloat(*key, *static_cast<float *>(entry->mData), pTabLevel + 1);
+                    break;
+                case AI_INT32:
+                    Export_MetadataInteger(*key, *static_cast<int32_t *>(entry->mData), pTabLevel + 1);
+                    break;
+                case AI_AISTRING:
+                    Export_MetadataString(*key, *static_cast<aiString *>(entry->mData), pTabLevel + 1);
+                    break;
+                default:
+                    LogError("Unsupported metadata type: " + to_string(entry->mType));
+                    break;
+                } // switch(entry->mType)
+            }
+        }
+    } // if(pNode->mMetaData != nullptr)
+
+    // Export meshes.
+    for (size_t idx_mesh = 0; idx_mesh < pNode->mNumMeshes; idx_mesh++)
+        Export_Mesh(pNode->mMeshes[idx_mesh], pTabLevel + 1);
+    // Export children.
+    for (size_t idx_node = 0; idx_node < pNode->mNumChildren; idx_node++)
+        Export_Node(pNode->mChildren[idx_node], pTabLevel + 1);
+
+    // End node if need.
+    if (transform)
+        NodeHelper_CloseNode("Transform", pTabLevel);
+    else
+        NodeHelper_CloseNode("Group", pTabLevel);
+}
+
+void X3DExporter::Export_Mesh(const size_t pIdxMesh, const size_t pTabLevel) {
+    const char *NodeName_IFS = "IndexedFaceSet";
+    const char *NodeName_Shape = "Shape";
+
+    list<SAttribute> attr_list;
+    aiMesh &mesh = *mScene->mMeshes[pIdxMesh]; // create alias for convenience.
+
+    // Check if mesh already defined early.
+    if (mDEF_Map_Mesh.find(pIdxMesh) != mDEF_Map_Mesh.end()) {
+        // Mesh already defined, just refer to it
+        attr_list.push_back({ "USE", mDEF_Map_Mesh.at(pIdxMesh) });
+        NodeHelper_OpenNode(NodeName_Shape, pTabLevel, true, attr_list);
+
+        return;
+    }
+
+    string mesh_name(mesh.mName.C_Str() + string("_IDX_") + to_string(pIdxMesh)); // Create mesh name
+
+    // Define mesh name.
+    attr_list.push_back({ "DEF", mesh_name });
+    mDEF_Map_Mesh[pIdxMesh] = mesh_name;
+
+    //
+    // "Shape" node.
+    //
+    NodeHelper_OpenNode(NodeName_Shape, pTabLevel, false, attr_list);
+    attr_list.clear();
+
+    //
+    // "Appearance" node.
+    //
+    Export_Material(mesh.mMaterialIndex, pTabLevel + 1);
+
+    //
+    // "IndexedFaceSet" node.
+    //
+    // Fill attributes which differ from default. In Assimp for colors, vertices and normals used one indices set. So, only "coordIndex" must be set.
+    string coordIndex;
+
+    // fill coordinates index.
+    coordIndex.reserve(mesh.mNumVertices * 4); // Index + space + Face delimiter
+    for (size_t idx_face = 0; idx_face < mesh.mNumFaces; idx_face++) {
+        const aiFace &face_cur = mesh.mFaces[idx_face];
+
+        for (size_t idx_vert = 0; idx_vert < face_cur.mNumIndices; idx_vert++) {
+            coordIndex.append(to_string(face_cur.mIndices[idx_vert]) + " ");
+        }
+
+        coordIndex.append("-1 "); // face delimiter.
+    }
+
+    // remove last space symbol.
+    coordIndex.resize(coordIndex.length() - 1);
+    attr_list.push_back({ "coordIndex", coordIndex });
+    // create node
+    NodeHelper_OpenNode(NodeName_IFS, pTabLevel + 1, false, attr_list);
+    attr_list.clear();
+    // Child nodes for "IndexedFaceSet" needed when used colors, textures or normals.
+    string attr_value;
+
+    // Export <Coordinate>
+    AttrHelper_Vec3DArrToString(mesh.mVertices, mesh.mNumVertices, attr_value);
+    attr_list.push_back({ "point", attr_value });
+    NodeHelper_OpenNode("Coordinate", pTabLevel + 2, true, attr_list);
+    attr_list.clear();
+
+    // Export <ColorRGBA>
+    if (mesh.HasVertexColors(0)) {
+        AttrHelper_Col4DArrToString(mesh.mColors[0], mesh.mNumVertices, attr_value);
+        attr_list.push_back({ "color", attr_value });
+        NodeHelper_OpenNode("ColorRGBA", pTabLevel + 2, true, attr_list);
+        attr_list.clear();
+    }
+
+    // Export <TextureCoordinate>
+    if (mesh.HasTextureCoords(0)) {
+        AttrHelper_Vec3DAsVec2fArrToString(mesh.mTextureCoords[0], mesh.mNumVertices, attr_value);
+        attr_list.push_back({ "point", attr_value });
+        NodeHelper_OpenNode("TextureCoordinate", pTabLevel + 2, true, attr_list);
+        attr_list.clear();
+    }
+
+    // Export <Normal>
+    if (mesh.HasNormals()) {
+        AttrHelper_Vec3DArrToString(mesh.mNormals, mesh.mNumVertices, attr_value);
+        attr_list.push_back({ "vector", attr_value });
+        NodeHelper_OpenNode("Normal", pTabLevel + 2, true, attr_list);
+        attr_list.clear();
+    }
+
+    //
+    // Close opened nodes.
+    //
+    NodeHelper_CloseNode(NodeName_IFS, pTabLevel + 1);
+    NodeHelper_CloseNode(NodeName_Shape, pTabLevel);
+}
+
+void X3DExporter::Export_Material(const size_t pIdxMaterial, const size_t pTabLevel) {
+    const char *NodeName_A = "Appearance";
+
+    list<SAttribute> attr_list;
+    aiMaterial &material = *mScene->mMaterials[pIdxMaterial]; // create alias for convenience.
+
+    // Check if material already defined early.
+    if (mDEF_Map_Material.find(pIdxMaterial) != mDEF_Map_Material.end()) {
+        // Material already defined, just refer to it
+        attr_list.push_back({ "USE", mDEF_Map_Material.at(pIdxMaterial) });
+        NodeHelper_OpenNode(NodeName_A, pTabLevel, true, attr_list);
+
+        return;
+    }
+
+    string material_name(string("_IDX_") + to_string(pIdxMaterial)); // Create material name
+    aiString ai_mat_name;
+
+    if (material.Get(AI_MATKEY_NAME, ai_mat_name) == AI_SUCCESS) material_name.insert(0, ai_mat_name.C_Str());
+
+    // Define material name.
+    attr_list.push_back({ "DEF", material_name });
+    mDEF_Map_Material[pIdxMaterial] = material_name;
+
+    //
+    // "Appearance" node.
+    //
+    NodeHelper_OpenNode(NodeName_A, pTabLevel, false, attr_list);
+    attr_list.clear();
+
+    //
+    // "Material" node.
+    //
+    {
+        auto Color4ToAttrList = [&](const string &pAttrName, const aiColor4D &pAttrValue, const aiColor3D &pAttrDefaultValue) {
+            string tstr;
+
+            if (aiColor3D(pAttrValue.r, pAttrValue.g, pAttrValue.b) != pAttrDefaultValue) {
+                AttrHelper_Col4DArrToString(&pAttrValue, 1, tstr);
+                attr_list.push_back({ pAttrName, tstr });
+            }
+        };
+
+        float tvalf;
+        aiColor3D color3;
+        aiColor4D color4;
+
+        // ambientIntensity="0.2"     SFFloat [inputOutput]
+        if (material.Get(AI_MATKEY_COLOR_AMBIENT, color3) == AI_SUCCESS)
+            AttrHelper_FloatToAttrList(attr_list, "ambientIntensity", (color3.r + color3.g + color3.b) / 3.0f, 0.2f);
+        else if (material.Get(AI_MATKEY_COLOR_AMBIENT, color4) == AI_SUCCESS)
+            AttrHelper_FloatToAttrList(attr_list, "ambientIntensity", (color4.r + color4.g + color4.b) / 3.0f, 0.2f);
+
+        // diffuseColor="0.8 0.8 0.8" SFColor [inputOutput]
+        if (material.Get(AI_MATKEY_COLOR_DIFFUSE, color3) == AI_SUCCESS)
+            AttrHelper_Color3ToAttrList(attr_list, "diffuseColor", color3, aiColor3D(0.8f, 0.8f, 0.8f));
+        else if (material.Get(AI_MATKEY_COLOR_DIFFUSE, color4) == AI_SUCCESS)
+            Color4ToAttrList("diffuseColor", color4, aiColor3D(0.8f, 0.8f, 0.8f));
+
+        // emissiveColor="0 0 0"      SFColor [inputOutput]
+        if (material.Get(AI_MATKEY_COLOR_EMISSIVE, color3) == AI_SUCCESS)
+            AttrHelper_Color3ToAttrList(attr_list, "emissiveColor", color3, aiColor3D(0, 0, 0));
+        else if (material.Get(AI_MATKEY_COLOR_EMISSIVE, color4) == AI_SUCCESS)
+            Color4ToAttrList("emissiveColor", color4, aiColor3D(0, 0, 0));
+
+        // shininess="0.2"            SFFloat [inputOutput]
+        if (material.Get(AI_MATKEY_SHININESS, tvalf) == AI_SUCCESS) AttrHelper_FloatToAttrList(attr_list, "shininess", tvalf, 0.2f);
+
+        // specularColor="0 0 0"      SFColor [inputOutput]
+        if (material.Get(AI_MATKEY_COLOR_SPECULAR, color3) == AI_SUCCESS)
+            AttrHelper_Color3ToAttrList(attr_list, "specularColor", color3, aiColor3D(0, 0, 0));
+        else if (material.Get(AI_MATKEY_COLOR_SPECULAR, color4) == AI_SUCCESS)
+            Color4ToAttrList("specularColor", color4, aiColor3D(0, 0, 0));
+
+        // transparency="0"           SFFloat [inputOutput]
+        if (material.Get(AI_MATKEY_OPACITY, tvalf) == AI_SUCCESS) {
+            if (tvalf > 1) tvalf = 1;
+
+            tvalf = 1.0f - tvalf;
+            AttrHelper_FloatToAttrList(attr_list, "transparency", tvalf, 0);
+        }
+
+        NodeHelper_OpenNode("Material", pTabLevel + 1, true, attr_list);
+        attr_list.clear();
+    } // "Material" node. END.
+
+    //
+    // "ImageTexture" node.
+    //
+    {
+        auto RepeatToAttrList = [&](const string &pAttrName, const bool pAttrValue) {
+            if (!pAttrValue) attr_list.push_back({ pAttrName, "false" });
+        };
+
+        bool tvalb;
+        aiString tstring;
+
+        // url=""         MFString
+        if (material.Get(AI_MATKEY_TEXTURE_DIFFUSE(0), tstring) == AI_SUCCESS) {
+            if (strncmp(tstring.C_Str(), AI_EMBEDDED_TEXNAME_PREFIX, strlen(AI_EMBEDDED_TEXNAME_PREFIX)) == 0)
+                LogError("Embedded texture is not supported");
+            else
+                attr_list.push_back({ "url", string("\"") + tstring.C_Str() + "\"" });
+        }
+
+        // repeatS="true" SFBool
+        if (material.Get(AI_MATKEY_MAPPINGMODE_U_DIFFUSE(0), tvalb) == AI_SUCCESS) RepeatToAttrList("repeatS", tvalb);
+
+        // repeatT="true" SFBool
+        if (material.Get(AI_MATKEY_MAPPINGMODE_V_DIFFUSE(0), tvalb) == AI_SUCCESS) RepeatToAttrList("repeatT", tvalb);
+
+        NodeHelper_OpenNode("ImageTexture", pTabLevel + 1, true, attr_list);
+        attr_list.clear();
+    } // "ImageTexture" node. END.
+
+    //
+    // "TextureTransform" node.
+    //
+    {
+        auto Vec2ToAttrList = [&](const string &pAttrName, const aiVector2D &pAttrValue, const aiVector2D &pAttrDefaultValue) {
+            string tstr;
+
+            if (pAttrValue != pAttrDefaultValue) {
+                AttrHelper_Vec2DArrToString(&pAttrValue, 1, tstr);
+                attr_list.push_back({ pAttrName, tstr });
+            }
+        };
+
+        aiUVTransform transform;
+
+        if (material.Get(AI_MATKEY_UVTRANSFORM_DIFFUSE(0), transform) == AI_SUCCESS) {
+            Vec2ToAttrList("translation", transform.mTranslation, aiVector2D(0, 0));
+            AttrHelper_FloatToAttrList(attr_list, "rotation", transform.mRotation, 0);
+            Vec2ToAttrList("scale", transform.mScaling, aiVector2D(1, 1));
+
+            NodeHelper_OpenNode("TextureTransform", pTabLevel + 1, true, attr_list);
+            attr_list.clear();
+        }
+    } // "TextureTransform" node. END.
+
+    //
+    // Close opened nodes.
+    //
+    NodeHelper_CloseNode(NodeName_A, pTabLevel);
+}
+
+void X3DExporter::Export_MetadataBoolean(const aiString &pKey, const bool pValue, const size_t pTabLevel) {
+    list<SAttribute> attr_list;
+
+    attr_list.push_back({ "name", pKey.C_Str() });
+    attr_list.push_back({ "value", pValue ? "true" : "false" });
+    NodeHelper_OpenNode("MetadataBoolean", pTabLevel, true, attr_list);
+}
+
+void X3DExporter::Export_MetadataDouble(const aiString &pKey, const double pValue, const size_t pTabLevel) {
+    list<SAttribute> attr_list;
+
+    attr_list.push_back({ "name", pKey.C_Str() });
+    attr_list.push_back({ "value", to_string(pValue) });
+    NodeHelper_OpenNode("MetadataDouble", pTabLevel, true, attr_list);
+}
+
+void X3DExporter::Export_MetadataFloat(const aiString &pKey, const float pValue, const size_t pTabLevel) {
+    list<SAttribute> attr_list;
+
+    attr_list.push_back({ "name", pKey.C_Str() });
+    attr_list.push_back({ "value", to_string(pValue) });
+    NodeHelper_OpenNode("MetadataFloat", pTabLevel, true, attr_list);
+}
+
+void X3DExporter::Export_MetadataInteger(const aiString &pKey, const int32_t pValue, const size_t pTabLevel) {
+    list<SAttribute> attr_list;
+
+    attr_list.push_back({ "name", pKey.C_Str() });
+    attr_list.push_back({ "value", to_string(pValue) });
+    NodeHelper_OpenNode("MetadataInteger", pTabLevel, true, attr_list);
+}
+
+void X3DExporter::Export_MetadataString(const aiString &pKey, const aiString &pValue, const size_t pTabLevel) {
+    list<SAttribute> attr_list;
+
+    attr_list.push_back({ "name", pKey.C_Str() });
+    attr_list.push_back({ "value", pValue.C_Str() });
+    NodeHelper_OpenNode("MetadataString", pTabLevel, true, attr_list);
+}
+
+bool X3DExporter::CheckAndExport_Light(const aiNode &pNode, const size_t pTabLevel) {
+    list<SAttribute> attr_list;
+
+    auto Vec3ToAttrList = [&](const string &pAttrName, const aiVector3D &pAttrValue, const aiVector3D &pAttrDefaultValue) {
+        string tstr;
+
+        if (pAttrValue != pAttrDefaultValue) {
+            AttrHelper_Vec3DArrToString(&pAttrValue, 1, tstr);
+            attr_list.push_back({ pAttrName, tstr });
+        }
+    };
+
+    size_t idx_light;
+    bool found = false;
+
+    // Name of the light source can not be empty.
+    if (pNode.mName.length == 0) return false;
+
+    // search for light with name like node has.
+    for (idx_light = 0; mScene->mNumLights; idx_light++) {
+        if (pNode.mName == mScene->mLights[idx_light]->mName) {
+            found = true;
+            break;
+        }
+    }
+
+    if (!found) return false;
+
+    // Light source is found.
+    const aiLight &light = *mScene->mLights[idx_light]; // Alias for convenience.
+
+    aiMatrix4x4 trafo_mat = Matrix_GlobalToCurrent(pNode).Inverse();
+
+    attr_list.push_back({ "DEF", light.mName.C_Str() });
+    attr_list.push_back({ "global", "true" }); // "false" is not supported.
+    // ambientIntensity="0" SFFloat [inputOutput]
+    AttrHelper_FloatToAttrList(attr_list, "ambientIntensity", aiVector3D(light.mColorAmbient.r, light.mColorAmbient.g, light.mColorAmbient.b).Length(), 0);
+    // color="1 1 1"        SFColor [inputOutput]
+    AttrHelper_Color3ToAttrList(attr_list, "color", light.mColorDiffuse, aiColor3D(1, 1, 1));
+
+    switch (light.mType) {
+    case aiLightSource_DIRECTIONAL: {
+        aiVector3D direction = trafo_mat * light.mDirection;
+
+        Vec3ToAttrList("direction", direction, aiVector3D(0, 0, -1));
+        NodeHelper_OpenNode("DirectionalLight", pTabLevel, true, attr_list);
+    }
+
+    break;
+    case aiLightSource_POINT: {
+        aiVector3D attenuation(light.mAttenuationConstant, light.mAttenuationLinear, light.mAttenuationQuadratic);
+        aiVector3D location = trafo_mat * light.mPosition;
+
+        Vec3ToAttrList("attenuation", attenuation, aiVector3D(1, 0, 0));
+        Vec3ToAttrList("location", location, aiVector3D(0, 0, 0));
+        NodeHelper_OpenNode("PointLight", pTabLevel, true, attr_list);
+    }
+
+    break;
+    case aiLightSource_SPOT: {
+        aiVector3D attenuation(light.mAttenuationConstant, light.mAttenuationLinear, light.mAttenuationQuadratic);
+        aiVector3D location = trafo_mat * light.mPosition;
+        aiVector3D direction = trafo_mat * light.mDirection;
+
+        Vec3ToAttrList("attenuation", attenuation, aiVector3D(1, 0, 0));
+        Vec3ToAttrList("location", location, aiVector3D(0, 0, 0));
+        Vec3ToAttrList("direction", direction, aiVector3D(0, 0, -1));
+        AttrHelper_FloatToAttrList(attr_list, "beamWidth", light.mAngleInnerCone, 0.7854f);
+        AttrHelper_FloatToAttrList(attr_list, "cutOffAngle", light.mAngleOuterCone, 1.570796f);
+        NodeHelper_OpenNode("SpotLight", pTabLevel, true, attr_list);
+    }
+
+    break;
+    default:
+        throw DeadlyExportError("Unknown light type: " + to_string(light.mType));
+    } // switch(light.mType)
+
+    return true;
+}
+
+X3DExporter::X3DExporter(const char *pFileName, IOSystem *pIOSystem, const aiScene *pScene, const ExportProperties * /*pProperties*/) :
+        mScene(pScene) {
+    list<SAttribute> attr_list;
+
+    mOutFile = pIOSystem->Open(pFileName, "wt");
+    if (mOutFile == nullptr) throw DeadlyExportError("Could not open output .x3d file: " + string(pFileName));
+
+    // Begin document
+    XML_Write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
+    XML_Write("<!DOCTYPE X3D PUBLIC \"ISO//Web3D//DTD X3D 3.3//EN\" \"http://www.web3d.org/specifications/x3d-3.3.dtd\">\n");
+    // Root node
+    attr_list.push_back({ "profile", "Interchange" });
+    attr_list.push_back({ "version", "3.3" });
+    attr_list.push_back({ "xmlns:xsd", "http://www.w3.org/2001/XMLSchema-instance" });
+    attr_list.push_back({ "xsd:noNamespaceSchemaLocation", "http://www.web3d.org/specifications/x3d-3.3.xsd" });
+    NodeHelper_OpenNode("X3D", 0, false, attr_list);
+    attr_list.clear();
+    // <head>: meta data.
+    NodeHelper_OpenNode("head", 1);
+    XML_Write(mIndentationString + "<!-- All \"meta\" from this section tou will found in <Scene> node as MetadataString nodes. -->\n");
+    NodeHelper_CloseNode("head", 1);
+    // Scene node.
+    NodeHelper_OpenNode("Scene", 1);
+    Export_Node(mScene->mRootNode, 2);
+    NodeHelper_CloseNode("Scene", 1);
+    // Close Root node.
+    NodeHelper_CloseNode("X3D", 0);
+    // Cleanup
+    pIOSystem->Close(mOutFile);
+    mOutFile = nullptr;
+}
+
+} // namespace Assimp
+
+#endif // ASSIMP_BUILD_NO_X3D_EXPORTER
+#endif // ASSIMP_BUILD_NO_EXPORT
diff --git a/Engine/lib/assimp/code/AssetLib/X3D/X3DExporter.hpp b/Engine/lib/assimp/code/AssetLib/X3D/X3DExporter.hpp
new file mode 100644
index 000000000..fefaba9f3
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/X3D/X3DExporter.hpp
@@ -0,0 +1,250 @@
+/// \file   X3DExporter.hpp
+/// \brief  X3D-format files exporter for Assimp.
+/// \date   2016
+/// \author smal.root@gmail.com
+// Thanks to acorn89 for support.
+
+#ifndef INCLUDED_AI_X3D_EXPORTER_H
+#define INCLUDED_AI_X3D_EXPORTER_H
+
+// Header files, Assimp.
+#include <assimp/material.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/Exporter.hpp>
+
+// Header files, stdlib.
+#include <list>
+#include <string>
+
+namespace Assimp {
+
+/// \class X3DExporter
+/// Class which export aiScene to X3D file.
+///
+/// Limitations.
+///
+/// Pay attention that X3D is format for interactive graphic and simulations for web browsers. aiScene can not contain all features of the X3D format.
+/// Also, aiScene contain rasterized-like data. For example, X3D can describe circle all cylinder with one tag, but aiScene contain result of tessellation:
+/// vertices, faces etc. Yes, you can use algorithm for detecting figures or shapes, but that's not a good idea at all.
+///
+/// Supported nodes:
+///		Core component:
+///			"MetadataBoolean", "MetadataDouble", "MetadataFloat", "MetadataInteger", "MetadataSet", "MetadataString"
+///		Geometry3D component:
+///			"IndexedFaceSet"
+///		Grouping component:
+///			"Group", "Transform"
+///		Lighting component:
+///			"DirectionalLight", "PointLight", "SpotLight"
+///		Rendering component:
+///			"ColorRGBA", "Coordinate", "Normal"
+///		Shape component:
+///			"Shape", "Appearance", "Material"
+///		Texturing component:
+///			"ImageTexture", "TextureCoordinate", "TextureTransform"
+///
+class X3DExporter {
+    /***********************************************/
+    /******************** Types ********************/
+    /***********************************************/
+
+    struct SAttribute {
+        const std::string Name;
+        const std::string Value;
+        SAttribute() :
+                Name(),
+                Value() {
+            // empty
+        }
+        SAttribute(const std::string &name, const std::string &value) :
+                Name(name),
+                Value(value) {
+            // empty
+        }
+
+        SAttribute(SAttribute &&rhs) AI_NO_EXCEPT :
+                Name(rhs.Name),
+                Value(rhs.Value) {
+            // empty
+        }
+    };
+
+    /***********************************************/
+    /****************** Constants ******************/
+    /***********************************************/
+
+    const aiScene *const mScene;
+
+    /***********************************************/
+    /****************** Variables ******************/
+    /***********************************************/
+
+    IOStream *mOutFile;
+    std::map<size_t, std::string> mDEF_Map_Mesh;
+    std::map<size_t, std::string> mDEF_Map_Material;
+
+private:
+    std::string mIndentationString;
+
+    /***********************************************/
+    /****************** Functions ******************/
+    /***********************************************/
+
+    /// \fn void IndentationStringSet(const size_t pNewLevel)
+    /// Set value of the indentation string.
+    /// \param [in] pNewLevel - new level of the indentation.
+    void IndentationStringSet(const size_t pNewLevel);
+
+    /// \fn void XML_Write(const std::string& pData)
+    /// Write data to XML-file.
+    /// \param [in] pData - reference to string which must be written.
+    void XML_Write(const std::string &pData);
+
+    /// \fn aiMatrix4x4 Matrix_GlobalToCurrent(const aiNode& pNode) const
+    /// Calculate transformation matrix for transformation from global coordinate system to pointed aiNode.
+    /// \param [in] pNode - reference to local node.
+    /// \return calculated matrix.
+    aiMatrix4x4 Matrix_GlobalToCurrent(const aiNode &pNode) const;
+
+    /// \fn void AttrHelper_CommaToPoint(std::string& pStringWithComma)
+    /// Convert commas in string to points. That's needed because "std::to_string" result depends on locale (regional settings).
+    /// \param [in, out] pStringWithComma - reference to string, which must be modified.
+    void AttrHelper_CommaToPoint(std::string &pStringWithComma) {
+        for (char &c : pStringWithComma) {
+            if (c == ',') c = '.';
+        }
+    }
+
+    /// \fn void AttrHelper_FloatToString(const float pValue, std::string& pTargetString)
+    /// Converts float to string.
+    /// \param [in] pValue - value for converting.
+    /// \param [out] pTargetString - reference to string where result will be placed. Will be cleared before using.
+    void AttrHelper_FloatToString(const float pValue, std::string &pTargetString);
+
+    /// \fn void AttrHelper_Vec3DArrToString(const aiVector3D* pArray, const size_t pArray_Size, std::string& pTargetString)
+    /// Converts array of vectors to string.
+    /// \param [in] pArray - pointer to array of vectors.
+    /// \param [in] pArray_Size - count of elements in array.
+    /// \param [out] pTargetString - reference to string where result will be placed. Will be cleared before using.
+    void AttrHelper_Vec3DArrToString(const aiVector3D *pArray, const size_t pArray_Size, std::string &pTargetString);
+
+    /// \fn void AttrHelper_Vec2DArrToString(const aiVector2D* pArray, const size_t pArray_Size, std::string& pTargetString)
+    /// \overload void AttrHelper_Vec3DArrToString(const aiVector3D* pArray, const size_t pArray_Size, std::string& pTargetString)
+    void AttrHelper_Vec2DArrToString(const aiVector2D *pArray, const size_t pArray_Size, std::string &pTargetString);
+
+    /// \fn void AttrHelper_Vec3DAsVec2fArrToString(const aiVector3D* pArray, const size_t pArray_Size, std::string& pTargetString)
+    /// \overload void AttrHelper_Vec3DArrToString(const aiVector3D* pArray, const size_t pArray_Size, std::string& pTargetString)
+    /// Only x, y is used from aiVector3D.
+    void AttrHelper_Vec3DAsVec2fArrToString(const aiVector3D *pArray, const size_t pArray_Size, std::string &pTargetString);
+
+    /// \fn void AttrHelper_Col4DArrToString(const aiColor4D* pArray, const size_t pArray_Size, std::string& pTargetString)
+    /// \overload void AttrHelper_Vec3DArrToString(const aiVector3D* pArray, const size_t pArray_Size, std::string& pTargetString)
+    /// Converts array of colors to string.
+    void AttrHelper_Col4DArrToString(const aiColor4D *pArray, const size_t pArray_Size, std::string &pTargetString);
+
+    /// \fn void AttrHelper_Col3DArrToString(const aiColor3D* pArray, const size_t pArray_Size, std::string& pTargetString)
+    /// \overload void AttrHelper_Col4DArrToString(const aiColor4D* pArray, const size_t pArray_Size, std::string& pTargetString)
+    /// Converts array of colors to string.
+    void AttrHelper_Col3DArrToString(const aiColor3D *pArray, const size_t pArray_Size, std::string &pTargetString);
+
+    /// \fn void AttrHelper_FloatToAttrList(std::list<SAttribute> pList, const std::string& pName, const float pValue, const float pDefaultValue)
+    /// \overload void AttrHelper_Col3DArrToString(const aiColor3D* pArray, const size_t pArray_Size, std::string& pTargetString)
+    void AttrHelper_FloatToAttrList(std::list<SAttribute> &pList, const std::string &pName, const float pValue, const float pDefaultValue);
+
+    /// \fn void AttrHelper_Color3ToAttrList(std::list<SAttribute> pList, const std::string& pName, const aiColor3D& pValue, const aiColor3D& pDefaultValue)
+    /// Add attribute to list if value not equal to default.
+    /// \param [in] pList - target list of the attributes.
+    /// \param [in] pName - name of new attribute.
+    /// \param [in] pValue - value of the new attribute.
+    /// \param [in] pDefaultValue - default value for checking: if pValue is equal to pDefaultValue then attribute will not be added.
+    void AttrHelper_Color3ToAttrList(std::list<SAttribute> &pList, const std::string &pName, const aiColor3D &pValue, const aiColor3D &pDefaultValue);
+
+    /// \fn void NodeHelper_OpenNode(const std::string& pNodeName, const size_t pTabLevel, const bool pEmptyElement, const std::list<SAttribute>& pAttrList)
+    /// Begin new XML-node element.
+    /// \param [in] pNodeName - name of the element.
+    /// \param [in] pTabLevel - indentation level.
+    /// \param [in] pEmtyElement - if true then empty element will be created.
+    /// \param [in] pAttrList - list of the attributes for element.
+    void NodeHelper_OpenNode(const std::string &pNodeName, const size_t pTabLevel, const bool pEmptyElement, const std::list<SAttribute> &pAttrList);
+
+    /// \fn void NodeHelper_OpenNode(const std::string& pNodeName, const size_t pTabLevel, const bool pEmptyElement = false)
+    /// \overload void NodeHelper_OpenNode(const std::string& pNodeName, const size_t pTabLevel, const bool pEmptyElement, const std::list<SAttribute>& pAttrList)
+    void NodeHelper_OpenNode(const std::string &pNodeName, const size_t pTabLevel, const bool pEmptyElement = false);
+
+    /// \fn void NodeHelper_CloseNode(const std::string& pNodeName, const size_t pTabLevel)
+    /// End XML-node element.
+    /// \param [in] pNodeName - name of the element.
+    /// \param [in] pTabLevel - indentation level.
+    void NodeHelper_CloseNode(const std::string &pNodeName, const size_t pTabLevel);
+
+    /// \fn void Export_Node(const aiNode* pNode, const size_t pTabLevel)
+    /// Export data from scene to XML-file: aiNode.
+    /// \param [in] pNode - source aiNode.
+    /// \param [in] pTabLevel - indentation level.
+    void Export_Node(const aiNode *pNode, const size_t pTabLevel);
+
+    /// \fn void Export_Mesh(const size_t pIdxMesh, const size_t pTabLevel)
+    /// Export data from scene to XML-file: aiMesh.
+    /// \param [in] pMesh - index of the source aiMesh.
+    /// \param [in] pTabLevel - indentation level.
+    void Export_Mesh(const size_t pIdxMesh, const size_t pTabLevel);
+
+    /// \fn void Export_Material(const size_t pIdxMaterial, const size_t pTabLevel)
+    /// Export data from scene to XML-file: aiMaterial.
+    /// \param [in] pIdxMaterial - index of the source aiMaterial.
+    /// \param [in] pTabLevel - indentation level.
+    void Export_Material(const size_t pIdxMaterial, const size_t pTabLevel);
+
+    /// \fn void Export_MetadataBoolean(const aiString& pKey, const bool pValue, const size_t pTabLevel)
+    /// Export data from scene to XML-file: aiMetadata.
+    /// \param [in] pKey - source data: value of the metadata key.
+    /// \param [in] pValue - source data: value of the metadata value.
+    /// \param [in] pTabLevel - indentation level.
+    void Export_MetadataBoolean(const aiString &pKey, const bool pValue, const size_t pTabLevel);
+
+    /// \fn void Export_MetadataDouble(const aiString& pKey, const double pValue, const size_t pTabLevel)
+    /// \overload void Export_MetadataBoolean(const aiString& pKey, const bool pValue, const size_t pTabLevel)
+    void Export_MetadataDouble(const aiString &pKey, const double pValue, const size_t pTabLevel);
+
+    /// \fn void Export_MetadataFloat(const aiString& pKey, const float pValue, const size_t pTabLevel)
+    /// \overload void Export_MetadataBoolean(const aiString& pKey, const bool pValue, const size_t pTabLevel)
+    void Export_MetadataFloat(const aiString &pKey, const float pValue, const size_t pTabLevel);
+
+    /// \fn void Export_MetadataInteger(const aiString& pKey, const int32_t pValue, const size_t pTabLevel)
+    /// \overload void Export_MetadataBoolean(const aiString& pKey, const bool pValue, const size_t pTabLevel)
+    void Export_MetadataInteger(const aiString &pKey, const int32_t pValue, const size_t pTabLevel);
+
+    /// \fn void Export_MetadataString(const aiString& pKey, const aiString& pValue, const size_t pTabLevel)
+    /// \overload void Export_MetadataBoolean(const aiString& pKey, const bool pValue, const size_t pTabLevel)
+    void Export_MetadataString(const aiString &pKey, const aiString &pValue, const size_t pTabLevel);
+
+    /// \fn bool CheckAndExport_Light(const aiNode& pNode, const size_t pTabLevel)
+    /// Check if node point to light source. If yes then export light source.
+    /// \param [in] pNode - reference to node for checking.
+    /// \param [in] pTabLevel - indentation level.
+    /// \return true - if node assigned with light and it was exported, else - return false.
+    bool CheckAndExport_Light(const aiNode &pNode, const size_t pTabLevel);
+
+    /***********************************************/
+    /************** Functions: LOG set *************/
+    /***********************************************/
+
+    /// \fn void LogError(const std::string& pMessage)
+    /// Short variant for calling \ref DefaultLogger::get()->error()
+    void LogError(const std::string &pMessage) { DefaultLogger::get()->error(pMessage); }
+
+public:
+    /// \fn X3DExporter()
+    /// Default constructor.
+    X3DExporter(const char *pFileName, IOSystem *pIOSystem, const aiScene *pScene, const ExportProperties *pProperties);
+
+    /// \fn ~X3DExporter()
+    /// Default destructor.
+    ~X3DExporter() {}
+
+}; // class X3DExporter
+
+} // namespace Assimp
+
+#endif // INCLUDED_AI_X3D_EXPORTER_H
diff --git a/Engine/lib/assimp/code/AssetLib/X3D/X3DGeoHelper.cpp b/Engine/lib/assimp/code/AssetLib/X3D/X3DGeoHelper.cpp
new file mode 100644
index 000000000..a9ac57e06
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/X3D/X3DGeoHelper.cpp
@@ -0,0 +1,531 @@
+#include "X3DGeoHelper.h"
+#include "X3DImporter.hpp"
+
+#include <assimp/vector3.h>
+#include <assimp/Exceptional.h>
+#include <assimp/StringUtils.h>
+
+#include <vector>
+
+namespace Assimp {
+
+aiVector3D X3DGeoHelper::make_point2D(float angle, float radius) {
+    return aiVector3D(radius * std::cos(angle), radius * std::sin(angle), 0);
+}
+
+void X3DGeoHelper::make_arc2D(float pStartAngle, float pEndAngle, float pRadius, size_t numSegments, std::list<aiVector3D> &pVertices) {
+    // check argument values ranges.
+    if ((pStartAngle < -AI_MATH_TWO_PI_F) || (pStartAngle > AI_MATH_TWO_PI_F)) {
+        throw DeadlyImportError("GeometryHelper_Make_Arc2D.pStartAngle");
+    }
+    if ((pEndAngle < -AI_MATH_TWO_PI_F) || (pEndAngle > AI_MATH_TWO_PI_F)) {
+        throw DeadlyImportError("GeometryHelper_Make_Arc2D.pEndAngle");
+    }
+    if (pRadius <= 0) {
+        throw DeadlyImportError("GeometryHelper_Make_Arc2D.pRadius");
+    }
+
+    // calculate arc angle and check type of arc
+    float angle_full = std::fabs(pEndAngle - pStartAngle);
+    if ((angle_full > AI_MATH_TWO_PI_F) || (angle_full == 0.0f)) {
+        angle_full = AI_MATH_TWO_PI_F;
+    }
+
+    // calculate angle for one step - angle to next point of line.
+    float angle_step = angle_full / (float)numSegments;
+    // make points
+    for (size_t pi = 0; pi <= numSegments; pi++) {
+        float tangle = pStartAngle + pi * angle_step;
+        pVertices.emplace_back(make_point2D(tangle, pRadius));
+    } // for(size_t pi = 0; pi <= pNumSegments; pi++)
+
+    // if we making full circle then add last vertex equal to first vertex
+    if (angle_full == AI_MATH_TWO_PI_F) pVertices.push_back(*pVertices.begin());
+}
+
+void X3DGeoHelper::extend_point_to_line(const std::list<aiVector3D> &pPoint, std::list<aiVector3D> &pLine) {
+    std::list<aiVector3D>::const_iterator pit = pPoint.begin();
+    std::list<aiVector3D>::const_iterator pit_last = pPoint.end();
+
+    --pit_last;
+
+    if (pPoint.size() < 2) {
+        throw DeadlyImportError("GeometryHelper_Extend_PointToLine.pPoint.size() can not be less than 2.");
+    }
+
+    // add first point of first line.
+    pLine.push_back(*pit++);
+    // add internal points
+    while (pit != pit_last) {
+        pLine.push_back(*pit); // second point of previous line
+        pLine.push_back(*pit); // first point of next line
+        ++pit;
+    }
+    // add last point of last line
+    pLine.push_back(*pit);
+}
+
+void X3DGeoHelper::polylineIdx_to_lineIdx(const std::list<int32_t> &pPolylineCoordIdx, std::list<int32_t> &pLineCoordIdx) {
+    std::list<int32_t>::const_iterator plit = pPolylineCoordIdx.begin();
+
+    while (plit != pPolylineCoordIdx.end()) {
+        // add first point of polyline
+        pLineCoordIdx.push_back(*plit++);
+        while ((*plit != (-1)) && (plit != pPolylineCoordIdx.end())) {
+            std::list<int32_t>::const_iterator plit_next;
+
+            plit_next = plit, ++plit_next;
+            pLineCoordIdx.push_back(*plit); // second point of previous line.
+            pLineCoordIdx.push_back(-1); // delimiter
+            if ((*plit_next == (-1)) || (plit_next == pPolylineCoordIdx.end())) break; // current polyline is finished
+
+            pLineCoordIdx.push_back(*plit); // first point of next line.
+            plit = plit_next;
+        } // while((*plit != (-1)) && (plit != pPolylineCoordIdx.end()))
+    } // while(plit != pPolylineCoordIdx.end())
+}
+
+#define MACRO_FACE_ADD_QUAD_FA(pCCW, pOut, pIn, pP1, pP2, pP3, pP4) \
+    do {                                                            \
+        if (pCCW) {                                                 \
+            pOut.push_back(pIn[pP1]);                               \
+            pOut.push_back(pIn[pP2]);                               \
+            pOut.push_back(pIn[pP3]);                               \
+            pOut.push_back(pIn[pP4]);                               \
+        } else {                                                    \
+            pOut.push_back(pIn[pP4]);                               \
+            pOut.push_back(pIn[pP3]);                               \
+            pOut.push_back(pIn[pP2]);                               \
+            pOut.push_back(pIn[pP1]);                               \
+        }                                                           \
+    } while (false)
+
+#define MESH_RectParallelepiped_CREATE_VERT \
+    aiVector3D vert_set[8];                 \
+    float x1, x2, y1, y2, z1, z2, hs;       \
+                                            \
+    hs = pSize.x / 2, x1 = -hs, x2 = hs;    \
+    hs = pSize.y / 2, y1 = -hs, y2 = hs;    \
+    hs = pSize.z / 2, z1 = -hs, z2 = hs;    \
+    vert_set[0].Set(x2, y1, z2);            \
+    vert_set[1].Set(x2, y2, z2);            \
+    vert_set[2].Set(x2, y2, z1);            \
+    vert_set[3].Set(x2, y1, z1);            \
+    vert_set[4].Set(x1, y1, z2);            \
+    vert_set[5].Set(x1, y2, z2);            \
+    vert_set[6].Set(x1, y2, z1);            \
+    vert_set[7].Set(x1, y1, z1)
+
+void X3DGeoHelper::rect_parallel_epiped(const aiVector3D &pSize, std::list<aiVector3D> &pVertices) {
+    MESH_RectParallelepiped_CREATE_VERT;
+    MACRO_FACE_ADD_QUAD_FA(true, pVertices, vert_set, 3, 2, 1, 0); // front
+    MACRO_FACE_ADD_QUAD_FA(true, pVertices, vert_set, 6, 7, 4, 5); // back
+    MACRO_FACE_ADD_QUAD_FA(true, pVertices, vert_set, 7, 3, 0, 4); // left
+    MACRO_FACE_ADD_QUAD_FA(true, pVertices, vert_set, 2, 6, 5, 1); // right
+    MACRO_FACE_ADD_QUAD_FA(true, pVertices, vert_set, 0, 1, 5, 4); // top
+    MACRO_FACE_ADD_QUAD_FA(true, pVertices, vert_set, 7, 6, 2, 3); // bottom
+}
+
+#undef MESH_RectParallelepiped_CREATE_VERT
+
+void X3DGeoHelper::coordIdx_str2faces_arr(const std::vector<int32_t> &pCoordIdx, std::vector<aiFace> &pFaces, unsigned int &pPrimitiveTypes) {
+    std::vector<int32_t> f_data(pCoordIdx);
+    std::vector<unsigned int> inds;
+    unsigned int prim_type = 0;
+
+    if (f_data.back() != (-1)) {
+        f_data.push_back(-1);
+    }
+
+    // reserve average size.
+    pFaces.reserve(f_data.size() / 3);
+    inds.reserve(4);
+    //PrintVectorSet("build. ci", pCoordIdx);
+    for (std::vector<int32_t>::iterator it = f_data.begin(); it != f_data.end(); ++it) {
+        // when face is got count how many indices in it.
+        if (*it == (-1)) {
+            aiFace tface;
+            size_t ts;
+
+            ts = inds.size();
+            switch (ts) {
+                case 0:
+                    goto mg_m_err;
+                case 1:
+                    prim_type |= aiPrimitiveType_POINT;
+                    break;
+                case 2:
+                    prim_type |= aiPrimitiveType_LINE;
+                    break;
+                case 3:
+                    prim_type |= aiPrimitiveType_TRIANGLE;
+                    break;
+                default:
+                    prim_type |= aiPrimitiveType_POLYGON;
+                    break;
+            }
+
+            tface.mNumIndices = static_cast<unsigned int>(ts);
+            tface.mIndices = new unsigned int[ts];
+            memcpy(tface.mIndices, inds.data(), ts * sizeof(unsigned int));
+            pFaces.push_back(tface);
+            inds.clear();
+        } // if(*it == (-1))
+        else {
+            inds.push_back(*it);
+        } // if(*it == (-1)) else
+    } // for(std::list<int32_t>::iterator it = f_data.begin(); it != f_data.end(); it++)
+    //PrintVectorSet("build. faces", pCoordIdx);
+
+    pPrimitiveTypes = prim_type;
+
+    return;
+
+mg_m_err:
+    for (size_t i = 0, i_e = pFaces.size(); i < i_e; i++)
+        delete[] pFaces.at(i).mIndices;
+
+    pFaces.clear();
+}
+
+void X3DGeoHelper::add_color(aiMesh &pMesh, const std::list<aiColor3D> &pColors, const bool pColorPerVertex) {
+    std::list<aiColor4D> tcol;
+
+    // create RGBA array from RGB.
+    for (std::list<aiColor3D>::const_iterator it = pColors.begin(); it != pColors.end(); ++it)
+        tcol.push_back(aiColor4D((*it).r, (*it).g, (*it).b, 1));
+
+    // call existing function for adding RGBA colors
+    add_color(pMesh, tcol, pColorPerVertex);
+}
+
+void X3DGeoHelper::add_color(aiMesh &pMesh, const std::list<aiColor4D> &pColors, const bool pColorPerVertex) {
+    std::list<aiColor4D>::const_iterator col_it = pColors.begin();
+
+    if (pColorPerVertex) {
+        if (pColors.size() < pMesh.mNumVertices) {
+            throw DeadlyImportError("MeshGeometry_AddColor1. Colors count(" + ai_to_string(pColors.size()) + ") can not be less than Vertices count(" +
+                                    ai_to_string(pMesh.mNumVertices) + ").");
+        }
+
+        // copy colors to mesh
+        pMesh.mColors[0] = new aiColor4D[pMesh.mNumVertices];
+        for (size_t i = 0; i < pMesh.mNumVertices; i++)
+            pMesh.mColors[0][i] = *col_it++;
+    } // if(pColorPerVertex)
+    else {
+        if (pColors.size() < pMesh.mNumFaces) {
+            throw DeadlyImportError("MeshGeometry_AddColor1. Colors count(" + ai_to_string(pColors.size()) + ") can not be less than Faces count(" +
+                                    ai_to_string(pMesh.mNumFaces) + ").");
+        }
+
+        // copy colors to mesh
+        pMesh.mColors[0] = new aiColor4D[pMesh.mNumVertices];
+        for (size_t fi = 0; fi < pMesh.mNumFaces; fi++) {
+            // apply color to all vertices of face
+            for (size_t vi = 0, vi_e = pMesh.mFaces[fi].mNumIndices; vi < vi_e; vi++) {
+                pMesh.mColors[0][pMesh.mFaces[fi].mIndices[vi]] = *col_it;
+            }
+
+            ++col_it;
+        }
+    } // if(pColorPerVertex) else
+}
+
+void X3DGeoHelper::add_color(aiMesh &pMesh, const std::vector<int32_t> &pCoordIdx, const std::vector<int32_t> &pColorIdx,
+        const std::list<aiColor3D> &pColors, const bool pColorPerVertex) {
+    std::list<aiColor4D> tcol;
+
+    // create RGBA array from RGB.
+    for (std::list<aiColor3D>::const_iterator it = pColors.begin(); it != pColors.end(); ++it) {
+        tcol.push_back(aiColor4D((*it).r, (*it).g, (*it).b, 1));
+    }
+
+    // call existing function for adding RGBA colors
+    add_color(pMesh, pCoordIdx, pColorIdx, tcol, pColorPerVertex);
+}
+
+void X3DGeoHelper::add_color(aiMesh &pMesh, const std::vector<int32_t> &coordIdx, const std::vector<int32_t> &colorIdx,
+        const std::list<aiColor4D> &colors, bool pColorPerVertex) {
+    std::vector<aiColor4D> col_tgt_arr;
+    std::list<aiColor4D> col_tgt_list;
+    std::vector<aiColor4D> col_arr_copy;
+
+    if (coordIdx.size() == 0) {
+        throw DeadlyImportError("MeshGeometry_AddColor2. pCoordIdx can not be empty.");
+    }
+
+    // copy list to array because we are need indexed access to colors.
+    col_arr_copy.reserve(colors.size());
+    for (std::list<aiColor4D>::const_iterator it = colors.begin(); it != colors.end(); ++it) {
+        col_arr_copy.push_back(*it);
+    }
+
+    if (pColorPerVertex) {
+        if (colorIdx.size() > 0) {
+            // check indices array count.
+            if (colorIdx.size() < coordIdx.size()) {
+                throw DeadlyImportError("MeshGeometry_AddColor2. Colors indices count(" + ai_to_string(colorIdx.size()) +
+                                        ") can not be less than Coords indices count(" + ai_to_string(coordIdx.size()) + ").");
+            }
+            // create list with colors for every vertex.
+            col_tgt_arr.resize(pMesh.mNumVertices);
+            for (std::vector<int32_t>::const_iterator colidx_it = colorIdx.begin(), coordidx_it = coordIdx.begin(); colidx_it != colorIdx.end(); ++colidx_it, ++coordidx_it) {
+                if (*colidx_it == (-1)) {
+                    continue; // skip faces delimiter
+                }
+                if ((unsigned int)(*coordidx_it) > pMesh.mNumVertices) {
+                    throw DeadlyImportError("MeshGeometry_AddColor2. Coordinate idx is out of range.");
+                }
+                if ((unsigned int)*colidx_it > pMesh.mNumVertices) {
+                    throw DeadlyImportError("MeshGeometry_AddColor2. Color idx is out of range.");
+                }
+
+                col_tgt_arr[*coordidx_it] = col_arr_copy[*colidx_it];
+            }
+        } // if(pColorIdx.size() > 0)
+        else {
+            // when color indices list is absent use CoordIdx.
+            // check indices array count.
+            if (colors.size() < pMesh.mNumVertices) {
+                throw DeadlyImportError("MeshGeometry_AddColor2. Colors count(" + ai_to_string(colors.size()) + ") can not be less than Vertices count(" +
+                                        ai_to_string(pMesh.mNumVertices) + ").");
+            }
+            // create list with colors for every vertex.
+            col_tgt_arr.resize(pMesh.mNumVertices);
+            for (size_t i = 0; i < pMesh.mNumVertices; i++) {
+                col_tgt_arr[i] = col_arr_copy[i];
+            }
+        } // if(pColorIdx.size() > 0) else
+    } // if(pColorPerVertex)
+    else {
+        if (colorIdx.size() > 0) {
+            // check indices array count.
+            if (colorIdx.size() < pMesh.mNumFaces) {
+                throw DeadlyImportError("MeshGeometry_AddColor2. Colors indices count(" + ai_to_string(colorIdx.size()) +
+                                        ") can not be less than Faces count(" + ai_to_string(pMesh.mNumFaces) + ").");
+            }
+            // create list with colors for every vertex using faces indices.
+            col_tgt_arr.resize(pMesh.mNumFaces);
+
+            std::vector<int32_t>::const_iterator colidx_it = colorIdx.begin();
+            for (size_t fi = 0; fi < pMesh.mNumFaces; fi++) {
+                if ((unsigned int)*colidx_it > pMesh.mNumFaces) throw DeadlyImportError("MeshGeometry_AddColor2. Face idx is out of range.");
+
+                col_tgt_arr[fi] = col_arr_copy[*colidx_it++];
+            }
+        } // if(pColorIdx.size() > 0)
+        else {
+            // when color indices list is absent use CoordIdx.
+            // check indices array count.
+            if (colors.size() < pMesh.mNumFaces) {
+                throw DeadlyImportError("MeshGeometry_AddColor2. Colors count(" + ai_to_string(colors.size()) + ") can not be less than Faces count(" +
+                                        ai_to_string(pMesh.mNumFaces) + ").");
+            }
+            // create list with colors for every vertex using faces indices.
+            col_tgt_arr.resize(pMesh.mNumFaces);
+            for (size_t fi = 0; fi < pMesh.mNumFaces; fi++)
+                col_tgt_arr[fi] = col_arr_copy[fi];
+
+        } // if(pColorIdx.size() > 0) else
+    } // if(pColorPerVertex) else
+
+    // copy array to list for calling function that add colors.
+    for (std::vector<aiColor4D>::const_iterator it = col_tgt_arr.begin(); it != col_tgt_arr.end(); ++it)
+        col_tgt_list.push_back(*it);
+    // add prepared colors list to mesh.
+    add_color(pMesh, col_tgt_list, pColorPerVertex);
+}
+
+void X3DGeoHelper::add_normal(aiMesh &pMesh, const std::vector<int32_t> &pCoordIdx, const std::vector<int32_t> &pNormalIdx,
+        const std::list<aiVector3D> &pNormals, const bool pNormalPerVertex) {
+    std::vector<size_t> tind;
+    std::vector<aiVector3D> norm_arr_copy;
+
+    // copy list to array because we are need indexed access to normals.
+    norm_arr_copy.reserve(pNormals.size());
+    for (std::list<aiVector3D>::const_iterator it = pNormals.begin(); it != pNormals.end(); ++it) {
+        norm_arr_copy.push_back(*it);
+    }
+
+    if (pNormalPerVertex) {
+        if (pNormalIdx.size() > 0) {
+            // check indices array count.
+            if (pNormalIdx.size() != pCoordIdx.size()) throw DeadlyImportError("Normals and Coords inidces count must be equal.");
+
+            tind.reserve(pNormalIdx.size());
+            for (std::vector<int32_t>::const_iterator it = pNormalIdx.begin(); it != pNormalIdx.end(); ++it) {
+                if (*it != (-1)) tind.push_back(*it);
+            }
+
+            // copy normals to mesh
+            pMesh.mNormals = new aiVector3D[pMesh.mNumVertices];
+            for (size_t i = 0; (i < pMesh.mNumVertices) && (i < tind.size()); i++) {
+                if (tind[i] >= norm_arr_copy.size())
+                    throw DeadlyImportError("MeshGeometry_AddNormal. Normal index(" + ai_to_string(tind[i]) +
+                                            ") is out of range. Normals count: " + ai_to_string(norm_arr_copy.size()) + ".");
+
+                pMesh.mNormals[i] = norm_arr_copy[tind[i]];
+            }
+        } else {
+            if (pNormals.size() != pMesh.mNumVertices) throw DeadlyImportError("MeshGeometry_AddNormal. Normals and vertices count must be equal.");
+
+            // copy normals to mesh
+            pMesh.mNormals = new aiVector3D[pMesh.mNumVertices];
+            std::list<aiVector3D>::const_iterator norm_it = pNormals.begin();
+            for (size_t i = 0; i < pMesh.mNumVertices; i++)
+                pMesh.mNormals[i] = *norm_it++;
+        }
+    } // if(pNormalPerVertex)
+    else {
+        if (pNormalIdx.size() > 0) {
+            if (pMesh.mNumFaces != pNormalIdx.size()) throw DeadlyImportError("Normals faces count must be equal to mesh faces count.");
+
+            std::vector<int32_t>::const_iterator normidx_it = pNormalIdx.begin();
+
+            tind.reserve(pNormalIdx.size());
+            for (size_t i = 0, i_e = pNormalIdx.size(); i < i_e; i++)
+                tind.push_back(*normidx_it++);
+
+        } else {
+            tind.reserve(pMesh.mNumFaces);
+            for (size_t i = 0; i < pMesh.mNumFaces; i++)
+                tind.push_back(i);
+        }
+
+        // copy normals to mesh
+        pMesh.mNormals = new aiVector3D[pMesh.mNumVertices];
+        for (size_t fi = 0; fi < pMesh.mNumFaces; fi++) {
+            aiVector3D tnorm;
+
+            tnorm = norm_arr_copy[tind[fi]];
+            for (size_t vi = 0, vi_e = pMesh.mFaces[fi].mNumIndices; vi < vi_e; vi++)
+                pMesh.mNormals[pMesh.mFaces[fi].mIndices[vi]] = tnorm;
+        }
+    } // if(pNormalPerVertex) else
+}
+
+void X3DGeoHelper::add_normal(aiMesh &pMesh, const std::list<aiVector3D> &pNormals, const bool pNormalPerVertex) {
+    std::list<aiVector3D>::const_iterator norm_it = pNormals.begin();
+
+    if (pNormalPerVertex) {
+        if (pNormals.size() != pMesh.mNumVertices) throw DeadlyImportError("MeshGeometry_AddNormal. Normals and vertices count must be equal.");
+
+        // copy normals to mesh
+        pMesh.mNormals = new aiVector3D[pMesh.mNumVertices];
+        for (size_t i = 0; i < pMesh.mNumVertices; i++)
+            pMesh.mNormals[i] = *norm_it++;
+    } // if(pNormalPerVertex)
+    else {
+        if (pNormals.size() != pMesh.mNumFaces) throw DeadlyImportError("MeshGeometry_AddNormal. Normals and faces count must be equal.");
+
+        // copy normals to mesh
+        pMesh.mNormals = new aiVector3D[pMesh.mNumVertices];
+        for (size_t fi = 0; fi < pMesh.mNumFaces; fi++) {
+            // apply color to all vertices of face
+            for (size_t vi = 0, vi_e = pMesh.mFaces[fi].mNumIndices; vi < vi_e; vi++)
+                pMesh.mNormals[pMesh.mFaces[fi].mIndices[vi]] = *norm_it;
+
+            ++norm_it;
+        }
+    } // if(pNormalPerVertex) else
+}
+
+void X3DGeoHelper::add_tex_coord(aiMesh &pMesh, const std::vector<int32_t> &pCoordIdx, const std::vector<int32_t> &pTexCoordIdx,
+        const std::list<aiVector2D> &pTexCoords) {
+    std::vector<aiVector3D> texcoord_arr_copy;
+    std::vector<aiFace> faces;
+    unsigned int prim_type;
+
+    // copy list to array because we are need indexed access to normals.
+    texcoord_arr_copy.reserve(pTexCoords.size());
+    for (std::list<aiVector2D>::const_iterator it = pTexCoords.begin(); it != pTexCoords.end(); ++it) {
+        texcoord_arr_copy.push_back(aiVector3D((*it).x, (*it).y, 0));
+    }
+
+    if (pTexCoordIdx.size() > 0) {
+        coordIdx_str2faces_arr(pTexCoordIdx, faces, prim_type);
+        if (faces.empty()) {
+            throw DeadlyImportError("Failed to add texture coordinates to mesh, faces list is empty.");
+        }
+        if (faces.size() != pMesh.mNumFaces) {
+            throw DeadlyImportError("Texture coordinates faces count must be equal to mesh faces count.");
+        }
+    } else {
+        coordIdx_str2faces_arr(pCoordIdx, faces, prim_type);
+    }
+
+    pMesh.mTextureCoords[0] = new aiVector3D[pMesh.mNumVertices];
+    pMesh.mNumUVComponents[0] = 2;
+    for (size_t fi = 0, fi_e = faces.size(); fi < fi_e; fi++) {
+        if (pMesh.mFaces[fi].mNumIndices != faces.at(fi).mNumIndices)
+            throw DeadlyImportError("Number of indices in texture face and mesh face must be equal. Invalid face index: " + ai_to_string(fi) + ".");
+
+        for (size_t ii = 0; ii < pMesh.mFaces[fi].mNumIndices; ii++) {
+            size_t vert_idx = pMesh.mFaces[fi].mIndices[ii];
+            size_t tc_idx = faces.at(fi).mIndices[ii];
+
+            pMesh.mTextureCoords[0][vert_idx] = texcoord_arr_copy.at(tc_idx);
+        }
+    } // for(size_t fi = 0, fi_e = faces.size(); fi < fi_e; fi++)
+}
+
+void X3DGeoHelper::add_tex_coord(aiMesh &pMesh, const std::list<aiVector2D> &pTexCoords) {
+    std::vector<aiVector3D> tc_arr_copy;
+
+    if (pTexCoords.size() != pMesh.mNumVertices) {
+        throw DeadlyImportError("MeshGeometry_AddTexCoord. Texture coordinates and vertices count must be equal.");
+    }
+
+    // copy list to array because we are need convert aiVector2D to aiVector3D and also get indexed access as a bonus.
+    tc_arr_copy.reserve(pTexCoords.size());
+    for (std::list<aiVector2D>::const_iterator it = pTexCoords.begin(); it != pTexCoords.end(); ++it) {
+        tc_arr_copy.push_back(aiVector3D((*it).x, (*it).y, 0));
+    }
+
+    // copy texture coordinates to mesh
+    pMesh.mTextureCoords[0] = new aiVector3D[pMesh.mNumVertices];
+    pMesh.mNumUVComponents[0] = 2;
+    for (size_t i = 0; i < pMesh.mNumVertices; i++) {
+        pMesh.mTextureCoords[0][i] = tc_arr_copy[i];
+    }
+}
+
+aiMesh *X3DGeoHelper::make_mesh(const std::vector<int32_t> &pCoordIdx, const std::list<aiVector3D> &pVertices) {
+    std::vector<aiFace> faces;
+    unsigned int prim_type = 0;
+
+    // create faces array from input string with vertices indices.
+    X3DGeoHelper::coordIdx_str2faces_arr(pCoordIdx, faces, prim_type);
+    if (!faces.size()) {
+        throw DeadlyImportError("Failed to create mesh, faces list is empty.");
+    }
+
+    //
+    // Create new mesh and copy geometry data.
+    //
+    aiMesh *tmesh = new aiMesh;
+    size_t ts = faces.size();
+    // faces
+    tmesh->mFaces = new aiFace[ts];
+    tmesh->mNumFaces = static_cast<unsigned int>(ts);
+    for (size_t i = 0; i < ts; i++)
+        tmesh->mFaces[i] = faces.at(i);
+
+    // vertices
+    std::list<aiVector3D>::const_iterator vit = pVertices.begin();
+
+    ts = pVertices.size();
+    tmesh->mVertices = new aiVector3D[ts];
+    tmesh->mNumVertices = static_cast<unsigned int>(ts);
+    for (size_t i = 0; i < ts; i++) {
+        tmesh->mVertices[i] = *vit++;
+    }
+
+    // set primitives type and return result.
+    tmesh->mPrimitiveTypes = prim_type;
+
+    return tmesh;
+}
+
+} // namespace Assimp
diff --git a/Engine/lib/assimp/code/AssetLib/X3D/X3DGeoHelper.h b/Engine/lib/assimp/code/AssetLib/X3D/X3DGeoHelper.h
new file mode 100644
index 000000000..78e57f9da
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/X3D/X3DGeoHelper.h
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <assimp/vector2.h>
+#include <assimp/vector3.h>
+#include <assimp/color4.h>
+#include <assimp/types.h>
+
+#include <list>
+#include <vector>
+
+struct aiFace;
+struct aiMesh;
+
+namespace Assimp {
+
+class X3DGeoHelper {
+public:
+    static aiVector3D make_point2D(float angle, float radius);
+    static void make_arc2D(float pStartAngle, float pEndAngle, float pRadius, size_t numSegments, std::list<aiVector3D> &pVertices);
+    static void extend_point_to_line(const std::list<aiVector3D> &pPoint, std::list<aiVector3D> &pLine);
+    static void polylineIdx_to_lineIdx(const std::list<int32_t> &pPolylineCoordIdx, std::list<int32_t> &pLineCoordIdx);
+    static void rect_parallel_epiped(const aiVector3D &pSize, std::list<aiVector3D> &pVertices);
+    static void coordIdx_str2faces_arr(const std::vector<int32_t> &pCoordIdx, std::vector<aiFace> &pFaces, unsigned int &pPrimitiveTypes);
+    static void add_color(aiMesh &pMesh, const std::list<aiColor3D> &pColors, const bool pColorPerVertex);
+    static void add_color(aiMesh &pMesh, const std::list<aiColor4D> &pColors, const bool pColorPerVertex);
+    static void add_color(aiMesh &pMesh, const std::vector<int32_t> &pCoordIdx, const std::vector<int32_t> &pColorIdx,
+            const std::list<aiColor3D> &pColors, const bool pColorPerVertex);
+    static void add_color(aiMesh &pMesh, const std::vector<int32_t> &pCoordIdx, const std::vector<int32_t> &pColorIdx,
+            const std::list<aiColor4D> &pColors, const bool pColorPerVertex);
+    static void add_normal(aiMesh &pMesh, const std::vector<int32_t> &pCoordIdx, const std::vector<int32_t> &pNormalIdx,
+            const std::list<aiVector3D> &pNormals, const bool pNormalPerVertex);
+    static void add_normal(aiMesh &pMesh, const std::list<aiVector3D> &pNormals, const bool pNormalPerVertex);
+    static void add_tex_coord(aiMesh &pMesh, const std::vector<int32_t> &pCoordIdx, const std::vector<int32_t> &pTexCoordIdx,
+            const std::list<aiVector2D> &pTexCoords);
+    static void add_tex_coord(aiMesh &pMesh, const std::list<aiVector2D> &pTexCoords);
+    static aiMesh *make_mesh(const std::vector<int32_t> &pCoordIdx, const std::list<aiVector3D> &pVertices);
+};
+
+} // namespace Assimp
diff --git a/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter.cpp b/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter.cpp
new file mode 100644
index 000000000..b34f361ae
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter.cpp
@@ -0,0 +1,488 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+/// \file   X3DImporter.cpp
+/// \brief  X3D-format files importer for Assimp: main algorithm implementation.
+/// \date   2015-2016
+/// \author smal.root@gmail.com
+
+#ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
+
+#include "X3DImporter.hpp"
+#include "X3DImporter_Macro.hpp"
+
+#include <assimp/DefaultIOSystem.h>
+
+// Header files, stdlib.
+#include <iterator>
+#include <memory>
+
+namespace Assimp {
+
+/// Constant which holds the importer description
+const aiImporterDesc X3DImporter::Description = {
+    "Extensible 3D(X3D) Importer",
+    "smalcom",
+    "",
+    "See documentation in source code. Chapter: Limitations.",
+    aiImporterFlags_SupportTextFlavour | aiImporterFlags_SupportBinaryFlavour | aiImporterFlags_LimitedSupport | aiImporterFlags_Experimental,
+    0,
+    0,
+    0,
+    0,
+    "x3d x3db"
+};
+
+bool X3DImporter::isNodeEmpty(XmlNode &node) {
+    return node.first_child().empty();
+}
+
+void X3DImporter::checkNodeMustBeEmpty(XmlNode &node) {
+    if (!isNodeEmpty(node)) throw DeadlyImportError(std::string("Node <") + node.name() + "> must be empty.");
+}
+
+void X3DImporter::skipUnsupportedNode(const std::string &pParentNodeName, XmlNode &node) {
+    static const size_t Uns_Skip_Len = 192;
+    static const char *Uns_Skip[Uns_Skip_Len] = {
+        // CAD geometry component
+        "CADAssembly", "CADFace", "CADLayer", "CADPart", "IndexedQuadSet", "QuadSet",
+        // Core
+        "ROUTE", "ExternProtoDeclare", "ProtoDeclare", "ProtoInstance", "ProtoInterface", "WorldInfo",
+        // Distributed interactive simulation (DIS) component
+        "DISEntityManager", "DISEntityTypeMapping", "EspduTransform", "ReceiverPdu", "SignalPdu", "TransmitterPdu",
+        // Cube map environmental texturing component
+        "ComposedCubeMapTexture", "GeneratedCubeMapTexture", "ImageCubeMapTexture",
+        // Environmental effects component
+        "Background", "Fog", "FogCoordinate", "LocalFog", "TextureBackground",
+        // Environmental sensor component
+        "ProximitySensor", "TransformSensor", "VisibilitySensor",
+        // Followers component
+        "ColorChaser", "ColorDamper", "CoordinateChaser", "CoordinateDamper", "OrientationChaser", "OrientationDamper", "PositionChaser", "PositionChaser2D",
+        "PositionDamper", "PositionDamper2D", "ScalarChaser", "ScalarDamper", "TexCoordChaser2D", "TexCoordDamper2D",
+        // Geospatial component
+        "GeoCoordinate", "GeoElevationGrid", "GeoLocation", "GeoLOD", "GeoMetadata", "GeoOrigin", "GeoPositionInterpolator", "GeoProximitySensor",
+        "GeoTouchSensor", "GeoTransform", "GeoViewpoint",
+        // Humanoid Animation (H-Anim) component
+        "HAnimDisplacer", "HAnimHumanoid", "HAnimJoint", "HAnimSegment", "HAnimSite",
+        // Interpolation component
+        "ColorInterpolator", "CoordinateInterpolator", "CoordinateInterpolator2D", "EaseInEaseOut", "NormalInterpolator", "OrientationInterpolator",
+        "PositionInterpolator", "PositionInterpolator2D", "ScalarInterpolator", "SplinePositionInterpolator", "SplinePositionInterpolator2D",
+        "SplineScalarInterpolator", "SquadOrientationInterpolator",
+        // Key device sensor component
+        "KeySensor", "StringSensor",
+        // Layering component
+        "Layer", "LayerSet", "Viewport",
+        // Layout component
+        "Layout", "LayoutGroup", "LayoutLayer", "ScreenFontStyle", "ScreenGroup",
+        // Navigation component
+        "Billboard", "Collision", "LOD", "NavigationInfo", "OrthoViewpoint", "Viewpoint", "ViewpointGroup",
+        // Networking component
+        "EXPORT", "IMPORT", "Anchor", "LoadSensor",
+        // NURBS component
+        "Contour2D", "ContourPolyline2D", "CoordinateDouble", "NurbsCurve", "NurbsCurve2D", "NurbsOrientationInterpolator", "NurbsPatchSurface",
+        "NurbsPositionInterpolator", "NurbsSet", "NurbsSurfaceInterpolator", "NurbsSweptSurface", "NurbsSwungSurface", "NurbsTextureCoordinate",
+        "NurbsTrimmedSurface",
+        // Particle systems component
+        "BoundedPhysicsModel", "ConeEmitter", "ExplosionEmitter", "ForcePhysicsModel", "ParticleSystem", "PointEmitter", "PolylineEmitter", "SurfaceEmitter",
+        "VolumeEmitter", "WindPhysicsModel",
+        // Picking component
+        "LinePickSensor", "PickableGroup", "PointPickSensor", "PrimitivePickSensor", "VolumePickSensor",
+        // Pointing device sensor component
+        "CylinderSensor", "PlaneSensor", "SphereSensor", "TouchSensor",
+        // Rendering component
+        "ClipPlane",
+        // Rigid body physics
+        "BallJoint", "CollidableOffset", "CollidableShape", "CollisionCollection", "CollisionSensor", "CollisionSpace", "Contact", "DoubleAxisHingeJoint",
+        "MotorJoint", "RigidBody", "RigidBodyCollection", "SingleAxisHingeJoint", "SliderJoint", "UniversalJoint",
+        // Scripting component
+        "Script",
+        // Programmable shaders component
+        "ComposedShader", "FloatVertexAttribute", "Matrix3VertexAttribute", "Matrix4VertexAttribute", "PackagedShader", "ProgramShader", "ShaderPart",
+        "ShaderProgram",
+        // Shape component
+        "FillProperties", "LineProperties", "TwoSidedMaterial",
+        // Sound component
+        "AudioClip", "Sound",
+        // Text component
+        "FontStyle", "Text",
+        // Texturing3D Component
+        "ComposedTexture3D", "ImageTexture3D", "PixelTexture3D", "TextureCoordinate3D", "TextureCoordinate4D", "TextureTransformMatrix3D", "TextureTransform3D",
+        // Texturing component
+        "MovieTexture", "MultiTexture", "MultiTextureCoordinate", "MultiTextureTransform", "PixelTexture", "TextureCoordinateGenerator", "TextureProperties",
+        // Time component
+        "TimeSensor",
+        // Event Utilities component
+        "BooleanFilter", "BooleanSequencer", "BooleanToggle", "BooleanTrigger", "IntegerSequencer", "IntegerTrigger", "TimeTrigger",
+        // Volume rendering component
+        "BlendedVolumeStyle", "BoundaryEnhancementVolumeStyle", "CartoonVolumeStyle", "ComposedVolumeStyle", "EdgeEnhancementVolumeStyle", "IsoSurfaceVolumeData",
+        "OpacityMapVolumeStyle", "ProjectionVolumeStyle", "SegmentedVolumeData", "ShadedVolumeStyle", "SilhouetteEnhancementVolumeStyle", "ToneMappedVolumeStyle",
+        "VolumeData"
+    };
+
+    const std::string nn = node.name();
+
+    if (nn.empty()) {
+        const std::string nv = node.value();
+        if (!nv.empty()) {
+            LogInfo("Ignoring comment \"" + nv + "\" in " + pParentNodeName + ".");
+            return;
+        }
+    }
+
+    bool found = false;
+
+    for (size_t i = 0; i < Uns_Skip_Len; i++) {
+        if (nn == Uns_Skip[i]) {
+            found = true;
+        }
+    }
+
+    if (!found) throw DeadlyImportError("Unknown node \"" + nn + "\" in " + pParentNodeName + ".");
+
+    LogInfo("Skipping node \"" + nn + "\" in " + pParentNodeName + ".");
+}
+
+X3DImporter::X3DImporter() :
+        mNodeElementCur(nullptr),
+        mScene(nullptr),
+        mpIOHandler(nullptr) {
+    // empty
+}
+
+X3DImporter::~X3DImporter() {
+    // Clear() is accounting if data already is deleted. So, just check again if all data is deleted.
+    Clear();
+}
+
+void X3DImporter::Clear() {
+    mNodeElementCur = nullptr;
+    // Delete all elements
+    if (!NodeElement_List.empty()) {
+        for (std::list<X3DNodeElementBase *>::iterator it = NodeElement_List.begin(); it != NodeElement_List.end(); ++it) {
+            delete *it;
+        }
+        NodeElement_List.clear();
+    }
+}
+
+void X3DImporter::ParseFile(const std::string &file, IOSystem *pIOHandler) {
+    ai_assert(nullptr != pIOHandler);
+
+    static const std::string mode = "rb";
+    std::unique_ptr<IOStream> fileStream(pIOHandler->Open(file, mode));
+    if (!fileStream.get()) {
+        throw DeadlyImportError("Failed to open file " + file + ".");
+    }
+
+    XmlParser theParser;
+    if (!theParser.parse(fileStream.get())) {
+        return;
+    }
+
+    XmlNode *node = theParser.findNode("X3D");
+    if (nullptr == node) {
+        return;
+    }
+
+    for (auto &currentNode : node->children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "head") {
+            readHead(currentNode);
+        } else if (currentName == "Scene") {
+            readScene(currentNode);
+        } else {
+            skipUnsupportedNode("X3D", currentNode);
+        }
+    }
+}
+
+bool X3DImporter::CanRead(const std::string &pFile, IOSystem * /*pIOHandler*/, bool checkSig) const {
+    if (checkSig) {
+        if (GetExtension(pFile) == "x3d")
+            return true;
+    }
+
+    return false;
+}
+
+void X3DImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
+    mpIOHandler = pIOHandler;
+
+    Clear();
+    std::shared_ptr<IOStream> stream(pIOHandler->Open(pFile, "rb"));
+    if (!stream) {
+        throw DeadlyImportError("Could not open file for reading");
+    }
+    std::string::size_type slashPos = pFile.find_last_of("\\/");
+
+    mScene = pScene;
+    pScene->mRootNode = new aiNode(pFile);
+    pScene->mRootNode->mParent = nullptr;
+    pScene->mFlags |= AI_SCENE_FLAGS_ALLOW_SHARED;
+
+    pIOHandler->PushDirectory(slashPos == std::string::npos ? std::string() : pFile.substr(0, slashPos + 1));
+    ParseFile(pFile, pIOHandler);
+    pIOHandler->PopDirectory();
+
+    //search for root node element
+
+    mNodeElementCur = NodeElement_List.front();
+    if (mNodeElementCur == nullptr) {
+        return;
+    }
+    while (mNodeElementCur->Parent != nullptr) {
+        mNodeElementCur = mNodeElementCur->Parent;
+    }
+
+    { // fill aiScene with objects.
+        std::list<aiMesh *> mesh_list;
+        std::list<aiMaterial *> mat_list;
+        std::list<aiLight *> light_list;
+
+        // create nodes tree
+        Postprocess_BuildNode(*mNodeElementCur, *pScene->mRootNode, mesh_list, mat_list, light_list);
+        // copy needed data to scene
+        if (!mesh_list.empty()) {
+            std::list<aiMesh *>::const_iterator it = mesh_list.begin();
+
+            pScene->mNumMeshes = static_cast<unsigned int>(mesh_list.size());
+            pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
+            for (size_t i = 0; i < pScene->mNumMeshes; i++)
+                pScene->mMeshes[i] = *it++;
+        }
+
+        if (!mat_list.empty()) {
+            std::list<aiMaterial *>::const_iterator it = mat_list.begin();
+
+            pScene->mNumMaterials = static_cast<unsigned int>(mat_list.size());
+            pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials];
+            for (size_t i = 0; i < pScene->mNumMaterials; i++)
+                pScene->mMaterials[i] = *it++;
+        }
+
+        if (!light_list.empty()) {
+            std::list<aiLight *>::const_iterator it = light_list.begin();
+
+            pScene->mNumLights = static_cast<unsigned int>(light_list.size());
+            pScene->mLights = new aiLight *[pScene->mNumLights];
+            for (size_t i = 0; i < pScene->mNumLights; i++)
+                pScene->mLights[i] = *it++;
+        }
+    }
+}
+
+const aiImporterDesc *X3DImporter::GetInfo() const {
+    return &Description;
+}
+
+struct meta_entry {
+    std::string name;
+    std::string value;
+};
+
+void X3DImporter::readHead(XmlNode &node) {
+    std::vector<meta_entry> metaArray;
+    for (auto currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "meta") {
+            //checkNodeMustBeEmpty(node);
+            meta_entry entry;
+            if (XmlParser::getStdStrAttribute(currentNode, "name", entry.name)) {
+                XmlParser::getStdStrAttribute(currentNode, "content", entry.value);
+                metaArray.emplace_back(entry);
+            }
+        }
+        // TODO: check if other node types in head should be supported
+    }
+    mScene->mMetaData = aiMetadata::Alloc(static_cast<unsigned int>(metaArray.size()));
+    unsigned int i = 0;
+    for (auto currentMeta : metaArray) {
+        mScene->mMetaData->Set(i, currentMeta.name, aiString(currentMeta.value));
+        ++i;
+    }
+}
+
+void X3DImporter::readChildNodes(XmlNode &node, const std::string &pParentNodeName) {
+    if (node.empty()) {
+        return;
+    }
+    for (auto currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "Shape")
+            readShape(currentNode);
+        else if (currentName == "Group") {
+            startReadGroup(currentNode);
+            readChildNodes(currentNode, "Group");
+            endReadGroup();
+        } else if (currentName == "StaticGroup") {
+            startReadStaticGroup(currentNode);
+            readChildNodes(currentNode, "StaticGroup");
+            endReadStaticGroup();
+        } else if (currentName == "Transform") {
+            startReadTransform(currentNode);
+            readChildNodes(currentNode, "Transform");
+            endReadTransform();
+        } else if (currentName == "Switch") {
+            startReadSwitch(currentNode);
+            readChildNodes(currentNode, "Switch");
+            endReadSwitch();
+        } else if (currentName == "DirectionalLight") {
+            readDirectionalLight(currentNode);
+        } else if (currentName == "PointLight") {
+            readPointLight(currentNode);
+        } else if (currentName == "SpotLight") {
+            readSpotLight(currentNode);
+        } else if (currentName == "Inline") {
+            readInline(currentNode);
+        } else if (!checkForMetadataNode(currentNode)) {
+            skipUnsupportedNode(pParentNodeName, currentNode);
+        }
+    }
+}
+
+void X3DImporter::readScene(XmlNode &node) {
+    ParseHelper_Group_Begin(true);
+    readChildNodes(node, "Scene");
+    ParseHelper_Node_Exit();
+}
+
+/*********************************************************************************************************************************************/
+/************************************************************ Functions: find set ************************************************************/
+/*********************************************************************************************************************************************/
+
+bool X3DImporter::FindNodeElement_FromRoot(const std::string &pID, const X3DElemType pType, X3DNodeElementBase **pElement) {
+    for (std::list<X3DNodeElementBase *>::iterator it = NodeElement_List.begin(); it != NodeElement_List.end(); ++it) {
+        if (((*it)->Type == pType) && ((*it)->ID == pID)) {
+            if (pElement != nullptr) *pElement = *it;
+
+            return true;
+        }
+    } // for(std::list<CX3DImporter_NodeElement*>::iterator it = NodeElement_List.begin(); it != NodeElement_List.end(); it++)
+
+    return false;
+}
+
+bool X3DImporter::FindNodeElement_FromNode(X3DNodeElementBase *pStartNode, const std::string &pID,
+        const X3DElemType pType, X3DNodeElementBase **pElement) {
+    bool found = false; // flag: true - if requested element is found.
+
+    // Check if pStartNode - this is the element, we are looking for.
+    if ((pStartNode->Type == pType) && (pStartNode->ID == pID)) {
+        found = true;
+        if (pElement != nullptr) {
+            *pElement = pStartNode;
+        }
+
+        goto fne_fn_end;
+    } // if((pStartNode->Type() == pType) && (pStartNode->ID() == pID))
+
+    // Check childs of pStartNode.
+    for (std::list<X3DNodeElementBase *>::iterator ch_it = pStartNode->Children.begin(); ch_it != pStartNode->Children.end(); ++ch_it) {
+        found = FindNodeElement_FromNode(*ch_it, pID, pType, pElement);
+        if (found) {
+            break;
+        }
+    } // for(std::list<CX3DImporter_NodeElement*>::iterator ch_it = it->Children.begin(); ch_it != it->Children.end(); ch_it++)
+
+fne_fn_end:
+
+    return found;
+}
+
+bool X3DImporter::FindNodeElement(const std::string &pID, const X3DElemType pType, X3DNodeElementBase **pElement) {
+    X3DNodeElementBase *tnd = mNodeElementCur; // temporary pointer to node.
+    bool static_search = false; // flag: true if searching in static node.
+
+    // At first check if we have deal with static node. Go up through parent nodes and check flag.
+    while (tnd != nullptr) {
+        if (tnd->Type == X3DElemType::ENET_Group) {
+            if (((X3DNodeElementGroup *)tnd)->Static) {
+                static_search = true; // Flag found, stop walking up. Node with static flag will holded in tnd variable.
+                break;
+            }
+        }
+
+        tnd = tnd->Parent; // go up in graph.
+    } // while (tnd != nullptr)
+
+    // at now call appropriate search function.
+    if (static_search) {
+        return FindNodeElement_FromNode(tnd, pID, pType, pElement);
+    } else {
+        return FindNodeElement_FromRoot(pID, pType, pElement);
+    }
+}
+
+/*********************************************************************************************************************************************/
+/************************************************************ Functions: parse set ***********************************************************/
+/*********************************************************************************************************************************************/
+
+void X3DImporter::ParseHelper_Group_Begin(const bool pStatic) {
+    X3DNodeElementGroup *new_group = new X3DNodeElementGroup(mNodeElementCur, pStatic); // create new node with current node as parent.
+
+    // if we are adding not the root element then add new element to current element child list.
+    if (mNodeElementCur != nullptr) {
+        mNodeElementCur->Children.push_back(new_group);
+    }
+
+    NodeElement_List.push_back(new_group); // it's a new element - add it to list.
+    mNodeElementCur = new_group; // switch current element to new one.
+}
+
+void X3DImporter::ParseHelper_Node_Enter(X3DNodeElementBase *pNode) {
+    ai_assert(nullptr != pNode);
+
+    mNodeElementCur->Children.push_back(pNode); // add new element to current element child list.
+    mNodeElementCur = pNode; // switch current element to new one.
+}    
+
+void X3DImporter::ParseHelper_Node_Exit() {
+    // check if we can walk up.
+    if (mNodeElementCur != nullptr) {
+        mNodeElementCur = mNodeElementCur->Parent;
+    } else {
+        int i = 0;
+        ++i;
+    }
+}
+
+} // namespace Assimp
+
+#endif // !ASSIMP_BUILD_NO_X3D_IMPORTER
diff --git a/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter.hpp b/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter.hpp
new file mode 100644
index 000000000..d9aed70d8
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter.hpp
@@ -0,0 +1,383 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+#ifndef INCLUDED_AI_X3D_IMPORTER_H
+#define INCLUDED_AI_X3D_IMPORTER_H
+
+#include "X3DImporter_Node.hpp"
+
+#include <assimp/BaseImporter.h>
+#include <assimp/XmlParser.h>
+#include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/types.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/ProgressHandler.hpp>
+
+#include <list>
+#include <string>
+
+namespace Assimp {
+
+inline void Throw_ArgOutOfRange(const std::string &argument) {
+    throw DeadlyImportError("Argument value is out of range for: \"" + argument + "\".");
+}
+
+inline void Throw_CloseNotFound(const std::string &node) {
+    throw DeadlyImportError("Close tag for node <" + node + "> not found. Seems file is corrupt.");
+}
+
+inline void Throw_ConvertFail_Str2ArrF(const std::string &nodeName, const std::string &pAttrValue) {
+    throw DeadlyImportError("In <" + nodeName + "> failed to convert attribute value \"" + pAttrValue +
+                            "\" from string to array of floats.");
+}
+
+inline void Throw_ConvertFail_Str2ArrD(const std::string &nodeName, const std::string &pAttrValue) {
+    throw DeadlyImportError("In <" + nodeName + "> failed to convert attribute value \"" + pAttrValue +
+                            "\" from string to array of doubles.");
+}
+
+inline void Throw_ConvertFail_Str2ArrB(const std::string &nodeName, const std::string &pAttrValue) {
+    throw DeadlyImportError("In <" + nodeName + "> failed to convert attribute value \"" + pAttrValue +
+                            "\" from string to array of booleans.");
+}
+
+inline void Throw_ConvertFail_Str2ArrI(const std::string &nodeName, const std::string &pAttrValue) {
+    throw DeadlyImportError("In <" + nodeName + "> failed to convert attribute value \"" + pAttrValue +
+                            "\" from string to array of integers.");
+}
+
+inline void Throw_DEF_And_USE(const std::string &nodeName) {
+    throw DeadlyImportError("\"DEF\" and \"USE\" can not be defined both in <" + nodeName + ">.");
+}
+
+inline void Throw_IncorrectAttr(const std::string &nodeName, const std::string &pAttrName) {
+    throw DeadlyImportError("Node <" + nodeName + "> has incorrect attribute \"" + pAttrName + "\".");
+}
+
+inline void Throw_IncorrectAttrValue(const std::string &nodeName, const std::string &pAttrName) {
+    throw DeadlyImportError("Attribute \"" + pAttrName + "\" in node <" + nodeName + "> has incorrect value.");
+}
+
+inline void Throw_MoreThanOnceDefined(const std::string &nodeName, const std::string &pNodeType, const std::string &pDescription) {
+    throw DeadlyImportError("\"" + pNodeType + "\" node can be used only once in " + nodeName + ". Description: " + pDescription);
+}
+
+inline void Throw_TagCountIncorrect(const std::string &pNode) {
+    throw DeadlyImportError("Count of open and close tags for node <" + pNode + "> are not equivalent. Seems file is corrupt.");
+}
+
+inline void Throw_USE_NotFound(const std::string &nodeName, const std::string &pAttrValue) {
+    throw DeadlyImportError("Not found node with name \"" + pAttrValue + "\" in <" + nodeName + ">.");
+}
+
+inline void LogInfo(const std::string &message) {
+    DefaultLogger::get()->info(message);
+}
+
+/// \class X3DImporter
+/// Class that holding scene graph which include: groups, geometry, metadata etc.
+///
+/// Limitations.
+///
+/// Pay attention that X3D is format for interactive graphic and simulations for web browsers.
+/// So not all features can be imported using Assimp.
+///
+/// Unsupported nodes:
+/// 	CAD geometry component:
+///			"CADAssembly", "CADFace", "CADLayer", "CADPart", "IndexedQuadSet", "QuadSet"
+///		Core component:
+///			"ROUTE", "ExternProtoDeclare", "ProtoDeclare", "ProtoInstance", "ProtoInterface", "WorldInfo"
+///		Distributed interactive simulation (DIS) component:
+///			"DISEntityManager", "DISEntityTypeMapping", "EspduTransform", "ReceiverPdu", "SignalPdu", "TransmitterPdu"
+///		Cube map environmental texturing component:
+///			"ComposedCubeMapTexture", "GeneratedCubeMapTexture", "ImageCubeMapTexture"
+///		Environmental effects component:
+///			"Background", "Fog", "FogCoordinate", "LocalFog", "TextureBackground"
+///		Environmental sensor component:
+///			"ProximitySensor", "TransformSensor", "VisibilitySensor"
+///		Followers component:
+///			"ColorChaser", "ColorDamper", "CoordinateChaser", "CoordinateDamper", "OrientationChaser", "OrientationDamper", "PositionChaser",
+///			"PositionChaser2D", "PositionDamper", "PositionDamper2D", "ScalarChaser", "ScalarDamper", "TexCoordChaser2D", "TexCoordDamper2D"
+///		Geospatial component:
+///			"GeoCoordinate", "GeoElevationGrid", "GeoLocation", "GeoLOD", "GeoMetadata", "GeoOrigin", "GeoPositionInterpolator", "GeoProximitySensor",
+///			"GeoTouchSensor", "GeoTransform", "GeoViewpoint"
+///		Humanoid Animation (H-Anim) component:
+///			"HAnimDisplacer", "HAnimHumanoid", "HAnimJoint", "HAnimSegment", "HAnimSite"
+///		Interpolation component:
+///			"ColorInterpolator", "CoordinateInterpolator", "CoordinateInterpolator2D", "EaseInEaseOut", "NormalInterpolator", "OrientationInterpolator",
+///			"PositionInterpolator", "PositionInterpolator2D", "ScalarInterpolator", "SplinePositionInterpolator", "SplinePositionInterpolator2D",
+///			"SplineScalarInterpolator", "SquadOrientationInterpolator",
+///		Key device sensor component:
+///			"KeySensor", "StringSensor"
+///		Layering component:
+///			"Layer", "LayerSet", "Viewport"
+///		Layout component:
+///			"Layout", "LayoutGroup", "LayoutLayer", "ScreenFontStyle", "ScreenGroup"
+///		Navigation component:
+///			"Billboard", "Collision", "LOD", "NavigationInfo", "OrthoViewpoint", "Viewpoint", "ViewpointGroup"
+///		Networking component:
+///			"EXPORT", "IMPORT", "Anchor", "LoadSensor"
+///		NURBS component:
+///			"Contour2D", "ContourPolyline2D", "CoordinateDouble", "NurbsCurve", "NurbsCurve2D", "NurbsOrientationInterpolator", "NurbsPatchSurface",
+///			"NurbsPositionInterpolator", "NurbsSet", "NurbsSurfaceInterpolator", "NurbsSweptSurface", "NurbsSwungSurface", "NurbsTextureCoordinate",
+///			"NurbsTrimmedSurface"
+///		Particle systems component:
+///			"BoundedPhysicsModel", "ConeEmitter", "ExplosionEmitter", "ForcePhysicsModel", "ParticleSystem", "PointEmitter", "PolylineEmitter",
+///			"SurfaceEmitter", "VolumeEmitter", "WindPhysicsModel"
+///		Picking component:
+///			"LinePickSensor", "PickableGroup", "PointPickSensor", "PrimitivePickSensor", "VolumePickSensor"
+///		Pointing device sensor component:
+///			"CylinderSensor", "PlaneSensor", "SphereSensor", "TouchSensor"
+///		Rendering component:
+///			"ClipPlane"
+///		Rigid body physics:
+///			"BallJoint", "CollidableOffset", "CollidableShape", "CollisionCollection", "CollisionSensor", "CollisionSpace", "Contact", "DoubleAxisHingeJoint",
+///			"MotorJoint", "RigidBody", "RigidBodyCollection", "SingleAxisHingeJoint", "SliderJoint", "UniversalJoint"
+///		Scripting component:
+///			"Script"
+///		Programmable shaders component:
+///			"ComposedShader", "FloatVertexAttribute", "Matrix3VertexAttribute", "Matrix4VertexAttribute", "PackagedShader", "ProgramShader", "ShaderPart",
+///			"ShaderProgram",
+///		Shape component:
+///			"FillProperties", "LineProperties", "TwoSidedMaterial"
+///		Sound component:
+///			"AudioClip", "Sound"
+///		Text component:
+///			"FontStyle", "Text"
+///		Texturing3D Component:
+///			"ComposedTexture3D", "ImageTexture3D", "PixelTexture3D", "TextureCoordinate3D", "TextureCoordinate4D", "TextureTransformMatrix3D",
+///			"TextureTransform3D"
+///		Texturing component:
+///			"MovieTexture", "MultiTexture", "MultiTextureCoordinate", "MultiTextureTransform", "PixelTexture", "TextureCoordinateGenerator",
+///			"TextureProperties",
+///		Time component:
+///			"TimeSensor"
+///		Event Utilities component:
+///			"BooleanFilter", "BooleanSequencer", "BooleanToggle", "BooleanTrigger", "IntegerSequencer", "IntegerTrigger", "TimeTrigger",
+///		Volume rendering component:
+///			"BlendedVolumeStyle", "BoundaryEnhancementVolumeStyle", "CartoonVolumeStyle", "ComposedVolumeStyle", "EdgeEnhancementVolumeStyle",
+///			"IsoSurfaceVolumeData", "OpacityMapVolumeStyle", "ProjectionVolumeStyle", "SegmentedVolumeData", "ShadedVolumeStyle",
+///			"SilhouetteEnhancementVolumeStyle", "ToneMappedVolumeStyle", "VolumeData"
+///
+/// Supported nodes:
+///		Core component:
+///			"MetadataBoolean", "MetadataDouble", "MetadataFloat", "MetadataInteger", "MetadataSet", "MetadataString"
+///		Geometry2D component:
+///			"Arc2D", "ArcClose2D", "Circle2D", "Disk2D", "Polyline2D", "Polypoint2D", "Rectangle2D", "TriangleSet2D"
+///		Geometry3D component:
+///			"Box", "Cone", "Cylinder", "ElevationGrid", "Extrusion", "IndexedFaceSet", "Sphere"
+///		Grouping component:
+///			"Group", "StaticGroup", "Switch", "Transform"
+///		Lighting component:
+///			"DirectionalLight", "PointLight", "SpotLight"
+///		Networking component:
+///			"Inline"
+///		Rendering component:
+///			"Color", "ColorRGBA", "Coordinate", "IndexedLineSet", "IndexedTriangleFanSet", "IndexedTriangleSet", "IndexedTriangleStripSet", "LineSet",
+///			"PointSet", "TriangleFanSet", "TriangleSet", "TriangleStripSet", "Normal"
+///		Shape component:
+///			"Shape", "Appearance", "Material"
+///		Texturing component:
+///			"ImageTexture", "TextureCoordinate", "TextureTransform"
+///
+/// Limitations of attribute "USE".
+/// If "USE" is set then node must be empty, like that:
+///		<Node USE='name'/>
+/// not the
+///		<Node USE='name'><!-- something --> </Node>
+///
+/// Ignored attributes: "creaseAngle", "convex", "solid".
+///
+/// Texture coordinates generating: only for Sphere, Cone, Cylinder. In all other case used PLANE mapping.
+///		It's better that Assimp main code has powerful texture coordinates generator. Then is not needed to
+///		duplicate this code in every importer.
+///
+/// Lighting limitations.
+///		If light source placed in some group with "DEF" set. And after that some node is use it group with "USE" attribute then
+///		you will get error about duplicate light sources. That's happening because Assimp require names for lights but do not like
+///		duplicates of it )).
+///
+///	Color for faces.
+/// That's happening when attribute "colorPerVertex" is set to "false". But Assimp do not hold how many colors has mesh and require
+/// equal length for mVertices and mColors. You will see the colors but vertices will use call which last used in "colorIdx".
+///
+///	That's all for now. Enjoy
+///
+
+using X3DElementList = std::list<X3DNodeElementBase *>;
+
+class X3DImporter : public BaseImporter {
+public:
+    std::list<X3DNodeElementBase *> NodeElement_List; ///< All elements of scene graph.
+
+public:
+    /// Default constructor.
+    X3DImporter();
+
+    /// Default destructor.
+    ~X3DImporter();
+
+    /***********************************************/
+    /******** Functions: parse set, public *********/
+    /***********************************************/
+
+    /// Parse X3D file and fill scene graph. The function has no return value. Result can be found by analyzing the generated graph.
+    /// Also exception can be thrown if trouble will found.
+    /// \param [in] pFile - name of file to be parsed.
+    /// \param [in] pIOHandler - pointer to IO helper object.
+    void ParseFile(const std::string &pFile, IOSystem *pIOHandler);
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool pCheckSig) const;
+    void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler);
+    const aiImporterDesc *GetInfo() const;
+    void Clear();
+
+private:
+    X3DNodeElementBase *MACRO_USE_CHECKANDAPPLY(XmlNode &node, std::string pDEF, std::string pUSE, X3DElemType pType, X3DNodeElementBase *pNE);
+    bool isNodeEmpty(XmlNode &node);
+    void checkNodeMustBeEmpty(XmlNode &node);
+    void skipUnsupportedNode(const std::string &pParentNodeName, XmlNode &node);
+    void readHead(XmlNode &node);
+    void readChildNodes(XmlNode &node, const std::string &pParentNodeName);
+    void readScene(XmlNode &node);
+
+    bool FindNodeElement_FromRoot(const std::string &pID, const X3DElemType pType, X3DNodeElementBase **pElement);
+    bool FindNodeElement_FromNode(X3DNodeElementBase *pStartNode, const std::string &pID,
+            const X3DElemType pType, X3DNodeElementBase **pElement);
+    bool FindNodeElement(const std::string &pID, const X3DElemType pType, X3DNodeElementBase **pElement);
+    void ParseHelper_Group_Begin(const bool pStatic = false);
+    void ParseHelper_Node_Enter(X3DNodeElementBase *pNode);
+    void ParseHelper_Node_Exit();
+
+    // 2D geometry
+    void readArc2D(XmlNode &node);
+    void readArcClose2D(XmlNode &node);
+    void readCircle2D(XmlNode &node);
+    void readDisk2D(XmlNode &node);
+    void readPolyline2D(XmlNode &node);
+    void readPolypoint2D(XmlNode &node);
+    void readRectangle2D(XmlNode &node);
+    void readTriangleSet2D(XmlNode &node);
+
+    // 3D geometry
+    void readBox(XmlNode &node);
+    void readCone(XmlNode &node);
+    void readCylinder(XmlNode &node);
+    void readElevationGrid(XmlNode &node);
+    void readExtrusion(XmlNode &node);
+    void readIndexedFaceSet(XmlNode &node);
+    void readSphere(XmlNode &node);
+
+    // group
+    void startReadGroup(XmlNode &node);
+    void endReadGroup();
+    void startReadStaticGroup(XmlNode &node);
+    void endReadStaticGroup();
+    void startReadSwitch(XmlNode &node);
+    void endReadSwitch();
+    void startReadTransform(XmlNode &node);
+    void endReadTransform();
+
+    // light
+    void readDirectionalLight(XmlNode &node);
+    void readPointLight(XmlNode &node);
+    void readSpotLight(XmlNode &node);
+
+    // metadata
+    bool checkForMetadataNode(XmlNode &node);
+    void childrenReadMetadata(XmlNode &node, X3DNodeElementBase *pParentElement, const std::string &pNodeName);
+    void readMetadataBoolean(XmlNode &node);
+    void readMetadataDouble(XmlNode &node);
+    void readMetadataFloat(XmlNode &node);
+    void readMetadataInteger(XmlNode &node);
+    void readMetadataSet(XmlNode &node);
+    void readMetadataString(XmlNode &node);
+
+    // networking
+    void readInline(XmlNode &node);
+
+    // postprocessing
+    aiMatrix4x4 PostprocessHelper_Matrix_GlobalToCurrent() const;
+    void PostprocessHelper_CollectMetadata(const X3DNodeElementBase &pNodeElement, std::list<X3DNodeElementBase *> &pList) const;
+    bool PostprocessHelper_ElementIsMetadata(const X3DElemType pType) const;
+    bool PostprocessHelper_ElementIsMesh(const X3DElemType pType) const;
+    void Postprocess_BuildLight(const X3DNodeElementBase &pNodeElement, std::list<aiLight *> &pSceneLightList) const;
+    void Postprocess_BuildMaterial(const X3DNodeElementBase &pNodeElement, aiMaterial **pMaterial) const;
+    void Postprocess_BuildMesh(const X3DNodeElementBase &pNodeElement, aiMesh **pMesh) const;
+    void Postprocess_BuildNode(const X3DNodeElementBase &pNodeElement, aiNode &pSceneNode, std::list<aiMesh *> &pSceneMeshList,
+            std::list<aiMaterial *> &pSceneMaterialList, std::list<aiLight *> &pSceneLightList) const;
+    void Postprocess_BuildShape(const X3DNodeElementShape &pShapeNodeElement, std::list<unsigned int> &pNodeMeshInd,
+            std::list<aiMesh *> &pSceneMeshList, std::list<aiMaterial *> &pSceneMaterialList) const;
+    void Postprocess_CollectMetadata(const X3DNodeElementBase &pNodeElement, aiNode &pSceneNode) const;
+
+    // rendering
+    void readColor(XmlNode &node);
+    void readColorRGBA(XmlNode &node);
+    void readCoordinate(XmlNode &node);
+    void readIndexedLineSet(XmlNode &node);
+    void readIndexedTriangleFanSet(XmlNode &node);
+    void readIndexedTriangleSet(XmlNode &node);
+    void readIndexedTriangleStripSet(XmlNode &node);
+    void readLineSet(XmlNode &node);
+    void readPointSet(XmlNode &node);
+    void readTriangleFanSet(XmlNode &node);
+    void readTriangleSet(XmlNode &node);
+    void readTriangleStripSet(XmlNode &node);
+    void readNormal(XmlNode &node);
+
+    // shape
+    void readShape(XmlNode &node);
+    void readAppearance(XmlNode &node);
+    void readMaterial(XmlNode &node);
+
+    // texturing
+    void readImageTexture(XmlNode &node);
+    void readTextureCoordinate(XmlNode &node);
+    void readTextureTransform(XmlNode &node);
+
+    static const aiImporterDesc Description;
+    X3DNodeElementBase *mNodeElementCur;
+    aiScene *mScene;
+    IOSystem *mpIOHandler;
+}; // class X3DImporter
+
+} // namespace Assimp
+
+#endif // INCLUDED_AI_X3D_IMPORTER_H
diff --git a/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Geometry2D.cpp b/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Geometry2D.cpp
new file mode 100644
index 000000000..8d0f5bad9
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Geometry2D.cpp
@@ -0,0 +1,467 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2019, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+/// \file   X3DImporter_Geometry2D.cpp
+/// \brief  Parsing data from nodes of "Geometry2D" set of X3D.
+/// date   2015-2016
+/// author smal.root@gmail.com
+
+#ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
+
+#include "X3DImporter.hpp"
+#include "X3DImporter_Macro.hpp"
+#include "X3DXmlHelper.h"
+#include "X3DGeoHelper.h"
+
+namespace Assimp {
+
+// <Arc2D
+// DEF=""              ID
+// USE=""              IDREF
+// endAngle="1.570796" SFFloat [initializeOnly]
+// radius="1"          SFFloat [initializeOnly]
+// startAngle="0"      SFFloat [initializeOnly]
+// />
+// The Arc2D node specifies a linear circular arc whose center is at (0,0) and whose angles are measured starting at the positive x-axis and sweeping
+// towards the positive y-axis. The radius field specifies the radius of the circle of which the arc is a portion. The arc extends from the startAngle
+// counterclockwise to the endAngle. The values of startAngle and endAngle shall be in the range [-2pi, 2pi] radians (or the equivalent if a different
+// angle base unit has been specified). If startAngle and endAngle have the same value, a circle is specified.
+void X3DImporter::readArc2D(XmlNode &node) {
+    std::string def, use;
+    float endAngle = AI_MATH_HALF_PI_F;
+    float radius = 1;
+    float startAngle = 0;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    XmlParser::getFloatAttribute(node, "endAngle", endAngle);
+    XmlParser::getFloatAttribute(node, "radius", radius);
+    XmlParser::getFloatAttribute(node, "startAngle", startAngle);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_Arc2D, ne);
+    } else {
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementGeometry2D(X3DElemType::ENET_Arc2D, mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        // create point list of geometry object and convert it to line set.
+        std::list<aiVector3D> tlist;
+
+        X3DGeoHelper::make_arc2D(startAngle, endAngle, radius, 10, tlist); ///TODO: IME - AI_CONFIG for NumSeg
+        X3DGeoHelper::extend_point_to_line(tlist, ((X3DNodeElementGeometry2D *)ne)->Vertices);
+        ((X3DNodeElementGeometry2D *)ne)->NumIndices = 2;
+        // check for X3DMetadataObject childs.
+        if (!isNodeEmpty(node))
+            childrenReadMetadata(node, ne, "Arc2D");
+        else
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+// <ArcClose2D
+// DEF=""              ID
+// USE=""              IDREF
+// closureType="PIE"   SFString [initializeOnly], {"PIE", "CHORD"}
+// endAngle="1.570796" SFFloat  [initializeOnly]
+// radius="1"          SFFloat  [initializeOnly]
+// solid="false"       SFBool   [initializeOnly]
+// startAngle="0"      SFFloat  [initializeOnly]
+// />
+// The ArcClose node specifies a portion of a circle whose center is at (0,0) and whose angles are measured starting at the positive x-axis and sweeping
+// towards the positive y-axis. The end points of the arc specified are connected as defined by the closureType field. The radius field specifies the radius
+// of the circle of which the arc is a portion. The arc extends from the startAngle counterclockwise to the endAngle. The value of radius shall be greater
+// than zero. The values of startAngle and endAngle shall be in the range [-2pi, 2pi] radians (or the equivalent if a different default angle base unit has
+// been specified). If startAngle and endAngle have the same value, a circle is specified and closureType is ignored. If the absolute difference between
+// startAngle and endAngle is greater than or equal to 2pi, a complete circle is produced with no chord or radial line(s) drawn from the center.
+// A closureType of "PIE" connects the end point to the start point by defining two straight line segments first from the end point to the center and then
+// the center to the start point. A closureType of "CHORD" connects the end point to the start point by defining a straight line segment from the end point
+// to the start point. Textures are applied individually to each face of the ArcClose2D. On the front (+Z) and back (-Z) faces of the ArcClose2D, when
+// viewed from the +Z-axis, the texture is mapped onto each face with the same orientation as if the image were displayed normally in 2D.
+void X3DImporter::readArcClose2D(XmlNode &node) {
+    std::string def, use;
+    std::string closureType("PIE");
+    float endAngle = AI_MATH_HALF_PI_F;
+    float radius = 1;
+    bool solid = false;
+    float startAngle = 0;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    XmlParser::getStdStrAttribute(node, "closureType", closureType);
+    XmlParser::getFloatAttribute(node, "endAngle", endAngle);
+    XmlParser::getFloatAttribute(node, "endAngle", endAngle);
+    XmlParser::getFloatAttribute(node, "radius", radius);
+    XmlParser::getBoolAttribute(node, "solid", solid);
+    XmlParser::getFloatAttribute(node, "startAngle", startAngle);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_ArcClose2D, ne);
+    } else {
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementGeometry2D(X3DElemType::ENET_ArcClose2D, mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        ((X3DNodeElementGeometry2D *)ne)->Solid = solid;
+        // create point list of geometry object.
+        X3DGeoHelper::make_arc2D(startAngle, endAngle, radius, 10, ((X3DNodeElementGeometry2D *)ne)->Vertices); ///TODO: IME - AI_CONFIG for NumSeg
+        // add chord or two radiuses only if not a circle was defined
+        if (!((std::fabs(endAngle - startAngle) >= AI_MATH_TWO_PI_F) || (endAngle == startAngle))) {
+            std::list<aiVector3D> &vlist = ((X3DNodeElementGeometry2D *)ne)->Vertices; // just short alias.
+
+            if ((closureType == "PIE") || (closureType == "\"PIE\""))
+                vlist.push_back(aiVector3D(0, 0, 0)); // center point - first radial line
+            else if ((closureType != "CHORD") && (closureType != "\"CHORD\""))
+                Throw_IncorrectAttrValue("ArcClose2D", "closureType");
+
+            vlist.push_back(*vlist.begin()); // arc first point - chord from first to last point of arc(if CHORD) or second radial line(if PIE).
+        }
+
+        ((X3DNodeElementGeometry2D *)ne)->NumIndices = ((X3DNodeElementGeometry2D *)ne)->Vertices.size();
+        // check for X3DMetadataObject childs.
+        if (!isNodeEmpty(node))
+            childrenReadMetadata(node, ne, "ArcClose2D");
+        else
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+// <Circle2D
+// DEF=""     ID
+// USE=""     IDREF
+// radius="1" SFFloat  [initializeOnly]
+// />
+void X3DImporter::readCircle2D(XmlNode &node) {
+    std::string def, use;
+    float radius = 1;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    XmlParser::getFloatAttribute(node, "radius", radius);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_Circle2D, ne);
+    } else {
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementGeometry2D(X3DElemType::ENET_Circle2D, mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        // create point list of geometry object and convert it to line set.
+        std::list<aiVector3D> tlist;
+
+        X3DGeoHelper::make_arc2D(0, 0, radius, 10, tlist); ///TODO: IME - AI_CONFIG for NumSeg
+        X3DGeoHelper::extend_point_to_line(tlist, ((X3DNodeElementGeometry2D *)ne)->Vertices);
+        ((X3DNodeElementGeometry2D *)ne)->NumIndices = 2;
+        // check for X3DMetadataObject childs.
+        if (!isNodeEmpty(node))
+            childrenReadMetadata(node, ne, "Circle2D");
+        else
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+// <Disk2D
+// DEF=""          ID
+// USE=""          IDREF
+// innerRadius="0" SFFloat  [initializeOnly]
+// outerRadius="1" SFFloat  [initializeOnly]
+// solid="false"   SFBool   [initializeOnly]
+// />
+// The Disk2D node specifies a circular disk which is centred at (0, 0) in the local coordinate system. The outerRadius field specifies the radius of the
+// outer dimension of the Disk2D. The innerRadius field specifies the inner dimension of the Disk2D. The value of outerRadius shall be greater than zero.
+// The value of innerRadius shall be greater than or equal to zero and less than or equal to outerRadius. If innerRadius is zero, the Disk2D is completely
+// filled. Otherwise, the area within the innerRadius forms a hole in the Disk2D. If innerRadius is equal to outerRadius, a solid circular line shall
+// be drawn using the current line properties. Textures are applied individually to each face of the Disk2D. On the front (+Z) and back (-Z) faces of
+// the Disk2D, when viewed from the +Z-axis, the texture is mapped onto each face with the same orientation as if the image were displayed normally in 2D.
+void X3DImporter::readDisk2D(XmlNode &node) {
+    std::string def, use;
+    float innerRadius = 0;
+    float outerRadius = 1;
+    bool solid = false;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    XmlParser::getFloatAttribute(node, "innerRadius", innerRadius);
+    XmlParser::getFloatAttribute(node, "outerRadius", outerRadius);
+    XmlParser::getBoolAttribute(node, "solid", solid);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_Disk2D, ne);
+    } else {
+        std::list<aiVector3D> tlist_o, tlist_i;
+
+        if (innerRadius > outerRadius) Throw_IncorrectAttrValue("Disk2D", "innerRadius");
+
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementGeometry2D(X3DElemType::ENET_Disk2D, mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        // create point list of geometry object.
+        ///TODO: IME - AI_CONFIG for NumSeg
+        X3DGeoHelper::make_arc2D(0, 0, outerRadius, 10, tlist_o); // outer circle
+        if (innerRadius == 0.0f) { // make filled disk
+            // in tlist_o we already have points of circle. just copy it and sign as polygon.
+            ((X3DNodeElementGeometry2D *)ne)->Vertices = tlist_o;
+            ((X3DNodeElementGeometry2D *)ne)->NumIndices = tlist_o.size();
+        } else if (innerRadius == outerRadius) { // make circle
+            // in tlist_o we already have points of circle. convert it to line set.
+            X3DGeoHelper::extend_point_to_line(tlist_o, ((X3DNodeElementGeometry2D *)ne)->Vertices);
+            ((X3DNodeElementGeometry2D *)ne)->NumIndices = 2;
+        } else { // make disk
+            std::list<aiVector3D> &vlist = ((X3DNodeElementGeometry2D *)ne)->Vertices; // just short alias.
+
+            X3DGeoHelper::make_arc2D(0, 0, innerRadius, 10, tlist_i); // inner circle
+            //
+            // create quad list from two point lists
+            //
+            if (tlist_i.size() < 2) throw DeadlyImportError("Disk2D. Not enough points for creating quad list."); // tlist_i and tlist_o has equal size.
+
+            // add all quads except last
+            for (std::list<aiVector3D>::iterator it_i = tlist_i.begin(), it_o = tlist_o.begin(); it_i != tlist_i.end();) {
+                // do not forget - CCW direction
+                vlist.push_back(*it_i++); // 1st point
+                vlist.push_back(*it_o++); // 2nd point
+                vlist.push_back(*it_o); // 3rd point
+                vlist.push_back(*it_i); // 4th point
+            }
+
+            // add last quad
+            vlist.push_back(*tlist_i.end()); // 1st point
+            vlist.push_back(*tlist_o.end()); // 2nd point
+            vlist.push_back(*tlist_o.begin()); // 3rd point
+            vlist.push_back(*tlist_o.begin()); // 4th point
+
+            ((X3DNodeElementGeometry2D *)ne)->NumIndices = 4;
+        }
+
+        ((X3DNodeElementGeometry2D *)ne)->Solid = solid;
+        // check for X3DMetadataObject childs.
+        if (!isNodeEmpty(node))
+            childrenReadMetadata(node, ne, "Disk2D");
+        else
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+// <Polyline2D
+// DEF=""          ID
+// USE=""          IDREF
+// lineSegments="" MFVec2F [intializeOnly]
+// />
+void X3DImporter::readPolyline2D(XmlNode &node) {
+    std::string def, use;
+    std::list<aiVector2D> lineSegments;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    X3DXmlHelper::getVector2DListAttribute(node, "lineSegments", lineSegments);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_Polyline2D, ne);
+    } else {
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementGeometry2D(X3DElemType::ENET_Polyline2D, mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        //
+        // convert read point list of geometry object to line set.
+        //
+        std::list<aiVector3D> tlist;
+
+        // convert vec2 to vec3
+        for (std::list<aiVector2D>::iterator it2 = lineSegments.begin(); it2 != lineSegments.end(); ++it2)
+            tlist.push_back(aiVector3D(it2->x, it2->y, 0));
+
+        // convert point set to line set
+        X3DGeoHelper::extend_point_to_line(tlist, ((X3DNodeElementGeometry2D *)ne)->Vertices);
+        ((X3DNodeElementGeometry2D *)ne)->NumIndices = 2;
+        // check for X3DMetadataObject childs.
+        if (!isNodeEmpty(node))
+            childrenReadMetadata(node, ne, "Polyline2D");
+        else
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+// <Polypoint2D
+// DEF=""   ID
+// USE=""   IDREF
+// point="" MFVec2F [inputOutput]
+// />
+void X3DImporter::readPolypoint2D(XmlNode &node) {
+    std::string def, use;
+    std::list<aiVector2D> point;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    X3DXmlHelper::getVector2DListAttribute(node, "point", point);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_Polypoint2D, ne);
+    } else {
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementGeometry2D(X3DElemType::ENET_Polypoint2D, mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        // convert vec2 to vec3
+        for (std::list<aiVector2D>::iterator it2 = point.begin(); it2 != point.end(); ++it2) {
+            ((X3DNodeElementGeometry2D *)ne)->Vertices.push_back(aiVector3D(it2->x, it2->y, 0));
+        }
+
+        ((X3DNodeElementGeometry2D *)ne)->NumIndices = 1;
+        // check for X3DMetadataObject childs.
+        if (!isNodeEmpty(node))
+            childrenReadMetadata(node, ne, "Polypoint2D");
+        else
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+// <Rectangle2D
+// DEF=""        ID
+// USE=""        IDREF
+// size="2 2"    SFVec2f [initializeOnly]
+// solid="false" SFBool  [initializeOnly]
+// />
+void X3DImporter::readRectangle2D(XmlNode &node) {
+    std::string def, use;
+    aiVector2D size(2, 2);
+    bool solid = false;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    X3DXmlHelper::getVector2DAttribute(node, "size", size);
+    XmlParser::getBoolAttribute(node, "solid", solid);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_Rectangle2D, ne);
+    } else {
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementGeometry2D(X3DElemType::ENET_Rectangle2D, mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        float x1 = -size.x / 2.0f;
+        float x2 = size.x / 2.0f;
+        float y1 = -size.y / 2.0f;
+        float y2 = size.y / 2.0f;
+        std::list<aiVector3D> &vlist = ((X3DNodeElementGeometry2D *)ne)->Vertices; // just short alias.
+
+        vlist.push_back(aiVector3D(x2, y1, 0)); // 1st point
+        vlist.push_back(aiVector3D(x2, y2, 0)); // 2nd point
+        vlist.push_back(aiVector3D(x1, y2, 0)); // 3rd point
+        vlist.push_back(aiVector3D(x1, y1, 0)); // 4th point
+        ((X3DNodeElementGeometry2D *)ne)->Solid = solid;
+        ((X3DNodeElementGeometry2D *)ne)->NumIndices = 4;
+        // check for X3DMetadataObject childs.
+        if (!isNodeEmpty(node))
+            childrenReadMetadata(node, ne, "Rectangle2D");
+        else
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+// <TriangleSet2D
+// DEF=""        ID
+// USE=""        IDREF
+// solid="false" SFBool  [initializeOnly]
+// vertices=""   MFVec2F [inputOutput]
+// />
+void X3DImporter::readTriangleSet2D(XmlNode &node) {
+    std::string def, use;
+    bool solid = false;
+    std::list<aiVector2D> vertices;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    X3DXmlHelper::getVector2DListAttribute(node, "vertices", vertices);
+    XmlParser::getBoolAttribute(node, "solid", solid);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_TriangleSet2D, ne);
+    } else {
+        if (vertices.size() % 3) throw DeadlyImportError("TriangleSet2D. Not enough points for defining triangle.");
+
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementGeometry2D(X3DElemType::ENET_TriangleSet2D, mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        // convert vec2 to vec3
+        for (std::list<aiVector2D>::iterator it2 = vertices.begin(); it2 != vertices.end(); ++it2) {
+            ((X3DNodeElementGeometry2D *)ne)->Vertices.push_back(aiVector3D(it2->x, it2->y, 0));
+        }
+
+        ((X3DNodeElementGeometry2D *)ne)->Solid = solid;
+        ((X3DNodeElementGeometry2D *)ne)->NumIndices = 3;
+        // check for X3DMetadataObject childs.
+        if (!isNodeEmpty(node))
+            childrenReadMetadata(node, ne, "TriangleSet2D");
+        else
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+} // namespace Assimp
+
+#endif // !ASSIMP_BUILD_NO_X3D_IMPORTER
diff --git a/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Geometry3D.cpp b/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Geometry3D.cpp
new file mode 100644
index 000000000..b9fc2a4d8
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Geometry3D.cpp
@@ -0,0 +1,918 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2019, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+/// \file   X3DImporter_Geometry3D.cpp
+/// \brief  Parsing data from nodes of "Geometry3D" set of X3D.
+/// \date   2015-2016
+/// \author smal.root@gmail.com
+
+#ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
+
+#include "X3DGeoHelper.h"
+#include "X3DImporter.hpp"
+#include "X3DImporter_Macro.hpp"
+#include "X3DXmlHelper.h"
+
+// Header files, Assimp.
+#include <assimp/StandardShapes.h>
+
+namespace Assimp {
+
+// <Box
+// DEF=""       ID
+// USE=""       IDREF
+// size="2 2 2" SFVec3f [initializeOnly]
+// solid="true" SFBool  [initializeOnly]
+// />
+// The Box node specifies a rectangular parallelepiped box centred at (0, 0, 0) in the local coordinate system and aligned with the local coordinate axes.
+// By default, the box measures 2 units in each dimension, from -1 to +1. The size field specifies the extents of the box along the X-, Y-, and Z-axes
+// respectively and each component value shall be greater than zero.
+void X3DImporter::readBox(XmlNode &node) {
+    std::string def, use;
+    bool solid = true;
+    aiVector3D size(2, 2, 2);
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    X3DXmlHelper::getVector3DAttribute(node, "size", size);
+    XmlParser::getBoolAttribute(node, "solid", solid);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_Box, ne);
+    } else {
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementGeometry3D(X3DElemType::ENET_Box, mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        X3DGeoHelper::rect_parallel_epiped(size, ((X3DNodeElementGeometry3D *)ne)->Vertices); // get quad list
+        ((X3DNodeElementGeometry3D *)ne)->Solid = solid;
+        ((X3DNodeElementGeometry3D *)ne)->NumIndices = 4;
+        // check for X3DMetadataObject childs.
+        if (!isNodeEmpty(node))
+            childrenReadMetadata(node, ne, "Box");
+        else
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+// <Cone
+// DEF=""           ID
+// USE=""           IDREF
+// bottom="true"    SFBool [initializeOnly]
+// bottomRadius="1" SFloat [initializeOnly]
+// height="2"       SFloat [initializeOnly]
+// side="true"      SFBool [initializeOnly]
+// solid="true"     SFBool [initializeOnly]
+// />
+void X3DImporter::readCone(XmlNode &node) {
+    std::string use, def;
+    bool bottom = true;
+    float bottomRadius = 1;
+    float height = 2;
+    bool side = true;
+    bool solid = true;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    XmlParser::getBoolAttribute(node, "solid", solid);
+    XmlParser::getBoolAttribute(node, "side", side);
+    XmlParser::getBoolAttribute(node, "bottom", bottom);
+    XmlParser::getFloatAttribute(node, "height", height);
+    XmlParser::getFloatAttribute(node, "bottomRadius", bottomRadius);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_Cone, ne);
+    } else {
+        const unsigned int tess = 30; ///TODO: IME tessellation factor through ai_property
+
+        std::vector<aiVector3D> tvec; // temp array for vertices.
+
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementGeometry3D(X3DElemType::ENET_Cone, mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        // make cone or parts according to flags.
+        if (side) {
+            StandardShapes::MakeCone(height, 0, bottomRadius, tess, tvec, !bottom);
+        } else if (bottom) {
+            StandardShapes::MakeCircle(bottomRadius, tess, tvec);
+            height = -(height / 2);
+            for (std::vector<aiVector3D>::iterator it = tvec.begin(); it != tvec.end(); ++it)
+                it->y = height; // y - because circle made in oXZ.
+        }
+
+        // copy data from temp array
+        for (std::vector<aiVector3D>::iterator it = tvec.begin(); it != tvec.end(); ++it)
+            ((X3DNodeElementGeometry3D *)ne)->Vertices.push_back(*it);
+
+        ((X3DNodeElementGeometry3D *)ne)->Solid = solid;
+        ((X3DNodeElementGeometry3D *)ne)->NumIndices = 3;
+        // check for X3DMetadataObject childs.
+        if (!isNodeEmpty(node))
+            childrenReadMetadata(node, ne, "Cone");
+        else
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+// <Cylinder
+// DEF=""        ID
+// USE=""        IDREF
+// bottom="true" SFBool [initializeOnly]
+// height="2"    SFloat [initializeOnly]
+// radius="1"    SFloat [initializeOnly]
+// side="true"   SFBool [initializeOnly]
+// solid="true"  SFBool [initializeOnly]
+// top="true"    SFBool [initializeOnly]
+// />
+void X3DImporter::readCylinder(XmlNode &node) {
+    std::string use, def;
+    bool bottom = true;
+    float height = 2;
+    float radius = 1;
+    bool side = true;
+    bool solid = true;
+    bool top = true;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    XmlParser::getFloatAttribute(node, "radius", radius);
+    XmlParser::getBoolAttribute(node, "solid", solid);
+    XmlParser::getBoolAttribute(node, "bottom", bottom);
+    XmlParser::getBoolAttribute(node, "top", top);
+    XmlParser::getBoolAttribute(node, "side", side);
+    XmlParser::getFloatAttribute(node, "height", height);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_Cylinder, ne);
+    } else {
+        const unsigned int tess = 30; ///TODO: IME tessellation factor through ai_property
+
+        std::vector<aiVector3D> tside; // temp array for vertices of side.
+        std::vector<aiVector3D> tcir; // temp array for vertices of circle.
+
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementGeometry3D(X3DElemType::ENET_Cylinder, mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        // make cilynder or parts according to flags.
+        if (side) StandardShapes::MakeCone(height, radius, radius, tess, tside, true);
+
+        height /= 2; // height defined for whole cylinder, when creating top and bottom circle we are using just half of height.
+        if (top || bottom) StandardShapes::MakeCircle(radius, tess, tcir);
+        // copy data from temp arrays
+        std::list<aiVector3D> &vlist = ((X3DNodeElementGeometry3D *)ne)->Vertices; // just short alias.
+
+        for (std::vector<aiVector3D>::iterator it = tside.begin(); it != tside.end(); ++it)
+            vlist.push_back(*it);
+
+        if (top) {
+            for (std::vector<aiVector3D>::iterator it = tcir.begin(); it != tcir.end(); ++it) {
+                (*it).y = height; // y - because circle made in oXZ.
+                vlist.push_back(*it);
+            }
+        } // if(top)
+
+        if (bottom) {
+            for (std::vector<aiVector3D>::iterator it = tcir.begin(); it != tcir.end(); ++it) {
+                (*it).y = -height; // y - because circle made in oXZ.
+                vlist.push_back(*it);
+            }
+        } // if(top)
+
+        ((X3DNodeElementGeometry3D *)ne)->Solid = solid;
+        ((X3DNodeElementGeometry3D *)ne)->NumIndices = 3;
+        // check for X3DMetadataObject childs.
+        if (!isNodeEmpty(node))
+            childrenReadMetadata(node, ne, "Cylinder");
+        else
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+// <ElevationGrid
+// DEF=""                 ID
+// USE=""                 IDREF
+// ccw="true"             SFBool  [initializeOnly]
+// colorPerVertex="true"  SFBool  [initializeOnly]
+// creaseAngle="0"        SFloat  [initializeOnly]
+// height=""              MFloat  [initializeOnly]
+// normalPerVertex="true" SFBool  [initializeOnly]
+// solid="true"           SFBool  [initializeOnly]
+// xDimension="0"         SFInt32 [initializeOnly]
+// xSpacing="1.0"         SFloat  [initializeOnly]
+// zDimension="0"         SFInt32 [initializeOnly]
+// zSpacing="1.0"         SFloat  [initializeOnly]
+// >
+//   <!-- ColorNormalTexCoordContentModel -->
+// ColorNormalTexCoordContentModel can contain Color (or ColorRGBA), Normal and TextureCoordinate, in any order. No more than one instance of any single
+// node type is allowed. A ProtoInstance node (with the proper node type) can be substituted for any node in this content model.
+// </ElevationGrid>
+// The ElevationGrid node specifies a uniform rectangular grid of varying height in the Y=0 plane of the local coordinate system. The geometry is described
+// by a scalar array of height values that specify the height of a surface above each point of the grid. The xDimension and zDimension fields indicate
+// the number of elements of the grid height array in the X and Z directions. Both xDimension and zDimension shall be greater than or equal to zero.
+// If either the xDimension or the zDimension is less than two, the ElevationGrid contains no quadrilaterals.
+void X3DImporter::readElevationGrid(XmlNode &node) {
+    std::string use, def;
+    bool ccw = true;
+    bool colorPerVertex = true;
+    float creaseAngle = 0;
+    std::vector<float> height;
+    bool normalPerVertex = true;
+    bool solid = true;
+    int32_t xDimension = 0;
+    float xSpacing = 1;
+    int32_t zDimension = 0;
+    float zSpacing = 1;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    XmlParser::getBoolAttribute(node, "solid", solid);
+    XmlParser::getBoolAttribute(node, "ccw", ccw);
+    XmlParser::getBoolAttribute(node, "colorPerVertex", colorPerVertex);
+    XmlParser::getBoolAttribute(node, "normalPerVertex", normalPerVertex);
+    XmlParser::getFloatAttribute(node, "creaseAngle", creaseAngle);
+    X3DXmlHelper::getFloatArrayAttribute(node, "height", height);
+    XmlParser::getIntAttribute(node, "xDimension", xDimension);
+    XmlParser::getFloatAttribute(node, "xSpacing", xSpacing);
+    XmlParser::getIntAttribute(node, "zDimension", zDimension);
+    XmlParser::getFloatAttribute(node, "zSpacing", zSpacing);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_ElevationGrid, ne);
+    } else {
+        if ((xSpacing == 0.0f) || (zSpacing == 0.0f)) throw DeadlyImportError("Spacing in <ElevationGrid> must be grater than zero.");
+        if ((xDimension <= 0) || (zDimension <= 0)) throw DeadlyImportError("Dimension in <ElevationGrid> must be grater than zero.");
+        if ((size_t)(xDimension * zDimension) != height.size()) DeadlyImportError("Heights count must be equal to \"xDimension * zDimension\" in <ElevationGrid>");
+
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementElevationGrid(X3DElemType::ENET_ElevationGrid, mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        X3DNodeElementElevationGrid &grid_alias = *((X3DNodeElementElevationGrid *)ne); // create alias for conveience
+
+        { // create grid vertices list
+            std::vector<float>::const_iterator he_it = height.begin();
+
+            for (int32_t zi = 0; zi < zDimension; zi++) // rows
+            {
+                for (int32_t xi = 0; xi < xDimension; xi++) // columns
+                {
+                    aiVector3D tvec(xSpacing * xi, *he_it, zSpacing * zi);
+
+                    grid_alias.Vertices.push_back(tvec);
+                    ++he_it;
+                }
+            }
+        } // END: create grid vertices list
+        //
+        // create faces list. In "coordIdx" format
+        //
+        // check if we have quads
+        if ((xDimension < 2) || (zDimension < 2)) // only one element in dimension is set, create line set.
+        {
+            ((X3DNodeElementElevationGrid *)ne)->NumIndices = 2; // will be holded as line set.
+            for (size_t i = 0, i_e = (grid_alias.Vertices.size() - 1); i < i_e; i++) {
+                grid_alias.CoordIdx.push_back(static_cast<int32_t>(i));
+                grid_alias.CoordIdx.push_back(static_cast<int32_t>(i + 1));
+                grid_alias.CoordIdx.push_back(-1);
+            }
+        } else // two or more elements in every dimension is set. create quad set.
+        {
+            ((X3DNodeElementElevationGrid *)ne)->NumIndices = 4;
+            for (int32_t fzi = 0, fzi_e = (zDimension - 1); fzi < fzi_e; fzi++) // rows
+            {
+                for (int32_t fxi = 0, fxi_e = (xDimension - 1); fxi < fxi_e; fxi++) // columns
+                {
+                    // points direction in face.
+                    if (ccw) {
+                        // CCW:
+                        //	3 2
+                        //	0 1
+                        grid_alias.CoordIdx.push_back((fzi + 1) * xDimension + fxi);
+                        grid_alias.CoordIdx.push_back((fzi + 1) * xDimension + (fxi + 1));
+                        grid_alias.CoordIdx.push_back(fzi * xDimension + (fxi + 1));
+                        grid_alias.CoordIdx.push_back(fzi * xDimension + fxi);
+                    } else {
+                        // CW:
+                        //	0 1
+                        //	3 2
+                        grid_alias.CoordIdx.push_back(fzi * xDimension + fxi);
+                        grid_alias.CoordIdx.push_back(fzi * xDimension + (fxi + 1));
+                        grid_alias.CoordIdx.push_back((fzi + 1) * xDimension + (fxi + 1));
+                        grid_alias.CoordIdx.push_back((fzi + 1) * xDimension + fxi);
+                    } // if(ccw) else
+
+                    grid_alias.CoordIdx.push_back(-1);
+                } // for(int32_t fxi = 0, fxi_e = (xDimension - 1); fxi < fxi_e; fxi++)
+            } // for(int32_t fzi = 0, fzi_e = (zDimension - 1); fzi < fzi_e; fzi++)
+        } // if((xDimension < 2) || (zDimension < 2)) else
+
+        grid_alias.ColorPerVertex = colorPerVertex;
+        grid_alias.NormalPerVertex = normalPerVertex;
+        grid_alias.CreaseAngle = creaseAngle;
+        grid_alias.Solid = solid;
+        // check for child nodes
+        if (!isNodeEmpty(node)) {
+            ParseHelper_Node_Enter(ne);
+            for (auto currentChildNode : node.children()) {
+                const std::string &currentChildName = currentChildNode.name();
+                // check for X3DComposedGeometryNodes
+                if (currentChildName == "Color")
+                    readColor(currentChildNode);
+                else if (currentChildName == "ColorRGBA")
+                    readColorRGBA(currentChildNode);
+                else if (currentChildName == "Normal")
+                    readNormal(currentChildNode);
+                else if (currentChildName == "TextureCoordinate")
+                    readTextureCoordinate(currentChildNode);
+                // check for X3DMetadataObject
+                else if (!checkForMetadataNode(currentChildNode))
+                    skipUnsupportedNode("ElevationGrid", currentChildNode);
+            }
+            ParseHelper_Node_Exit();
+        } // if(!mReader->isEmptyElement())
+        else {
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+        } // if(!mReader->isEmptyElement()) else
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+template <typename TVector>
+static void GeometryHelper_Extrusion_CurveIsClosed(std::vector<TVector> &pCurve, const bool pDropTail, const bool pRemoveLastPoint, bool &pCurveIsClosed) {
+    size_t cur_sz = pCurve.size();
+
+    pCurveIsClosed = false;
+    // for curve with less than four points checking is have no sense,
+    if (cur_sz < 4) return;
+
+    for (size_t s = 3, s_e = cur_sz; s < s_e; s++) {
+        // search for first point of duplicated part.
+        if (pCurve[0] == pCurve[s]) {
+            bool found = true;
+
+            // check if tail(indexed by b2) is duplicate of head(indexed by b1).
+            for (size_t b1 = 1, b2 = (s + 1); b2 < cur_sz; b1++, b2++) {
+                if (pCurve[b1] != pCurve[b2]) { // points not match: clear flag and break loop.
+                    found = false;
+
+                    break;
+                }
+            } // for(size_t b1 = 1, b2 = (s + 1); b2 < cur_sz; b1++, b2++)
+
+            // if duplicate tail is found then drop or not it depending on flags.
+            if (found) {
+                pCurveIsClosed = true;
+                if (pDropTail) {
+                    if (!pRemoveLastPoint) s++; // prepare value for iterator's arithmetics.
+
+                    pCurve.erase(pCurve.begin() + s, pCurve.end()); // remove tail
+                }
+
+                break;
+            } // if(found)
+        } // if(pCurve[0] == pCurve[s])
+    } // for(size_t s = 3, s_e = (cur_sz - 1); s < s_e; s++)
+}
+
+static aiVector3D GeometryHelper_Extrusion_GetNextY(const size_t pSpine_PointIdx, const std::vector<aiVector3D> &pSpine, const bool pSpine_Closed) {
+    const size_t spine_idx_last = pSpine.size() - 1;
+    aiVector3D tvec;
+
+    if ((pSpine_PointIdx == 0) || (pSpine_PointIdx == spine_idx_last)) // at first special cases
+    {
+        if (pSpine_Closed) { // If the spine curve is closed: The SCP for the first and last points is the same and is found using (spine[1] - spine[n - 2]) to compute the Y-axis.
+            // As we even for closed spine curve last and first point in pSpine are not the same: duplicates(spine[n - 1] which are equivalent to spine[0])
+            // in tail are removed.
+            // So, last point in pSpine is a spine[n - 2]
+            tvec = pSpine[1] - pSpine[spine_idx_last];
+        } else if (pSpine_PointIdx == 0) { // The Y-axis used for the first point is the vector from spine[0] to spine[1]
+            tvec = pSpine[1] - pSpine[0];
+        } else { // The Y-axis used for the last point it is the vector from spine[n-2] to spine[n-1]. In our case(see above about dropping tail) spine[n - 1] is
+            // the spine[0].
+            tvec = pSpine[spine_idx_last] - pSpine[spine_idx_last - 1];
+        }
+    } // if((pSpine_PointIdx == 0) || (pSpine_PointIdx == spine_idx_last))
+    else { // For all points other than the first or last: The Y-axis for spine[i] is found by normalizing the vector defined by (spine[i+1] - spine[i-1]).
+        tvec = pSpine[pSpine_PointIdx + 1] - pSpine[pSpine_PointIdx - 1];
+    } // if((pSpine_PointIdx == 0) || (pSpine_PointIdx == spine_idx_last)) else
+
+    return tvec.Normalize();
+}
+
+static aiVector3D GeometryHelper_Extrusion_GetNextZ(const size_t pSpine_PointIdx, const std::vector<aiVector3D> &pSpine, const bool pSpine_Closed,
+        const aiVector3D pVecZ_Prev) {
+    const aiVector3D zero_vec(0);
+    const size_t spine_idx_last = pSpine.size() - 1;
+
+    aiVector3D tvec;
+
+    // at first special cases
+    if (pSpine.size() < 3) // spine have not enough points for vector calculations.
+    {
+        tvec.Set(0, 0, 1);
+    } else if (pSpine_PointIdx == 0) // special case: first point
+    {
+        if (pSpine_Closed) // for calculating use previous point in curve s[n - 2]. In list it's a last point, because point s[n - 1] was removed as duplicate.
+        {
+            tvec = (pSpine[1] - pSpine[0]) ^ (pSpine[spine_idx_last] - pSpine[0]);
+        } else // for not closed curve first and next point(s[0] and s[1]) has the same vector Z.
+        {
+            bool found = false;
+
+            // As said: "If the Z-axis of the first point is undefined (because the spine is not closed and the first two spine segments are collinear)
+            // then the Z-axis for the first spine point with a defined Z-axis is used."
+            // Walk through spine and find Z.
+            for (size_t next_point = 2; (next_point <= spine_idx_last) && !found; next_point++) {
+                // (pSpine[2] - pSpine[1]) ^ (pSpine[0] - pSpine[1])
+                tvec = (pSpine[next_point] - pSpine[next_point - 1]) ^ (pSpine[next_point - 2] - pSpine[next_point - 1]);
+                found = !tvec.Equal(zero_vec);
+            }
+
+            // if entire spine are collinear then use OZ axis.
+            if (!found) tvec.Set(0, 0, 1);
+        } // if(pSpine_Closed) else
+    } // else if(pSpine_PointIdx == 0)
+    else if (pSpine_PointIdx == spine_idx_last) // special case: last point
+    {
+        if (pSpine_Closed) { // do not forget that real last point s[n - 1] is removed as duplicated. And in this case we are calculating vector Z for point s[n - 2].
+            tvec = (pSpine[0] - pSpine[pSpine_PointIdx]) ^ (pSpine[pSpine_PointIdx - 1] - pSpine[pSpine_PointIdx]);
+            // if taken spine vectors are collinear then use previous vector Z.
+            if (tvec.Equal(zero_vec)) tvec = pVecZ_Prev;
+        } else { // vector Z for last point of not closed curve is previous vector Z.
+            tvec = pVecZ_Prev;
+        }
+    } else // regular point
+    {
+        tvec = (pSpine[pSpine_PointIdx + 1] - pSpine[pSpine_PointIdx]) ^ (pSpine[pSpine_PointIdx - 1] - pSpine[pSpine_PointIdx]);
+        // if taken spine vectors are collinear then use previous vector Z.
+        if (tvec.Equal(zero_vec)) tvec = pVecZ_Prev;
+    }
+
+    // After determining the Z-axis, its dot product with the Z-axis of the previous spine point is computed. If this value is negative, the Z-axis
+    // is flipped (multiplied by -1).
+    if ((tvec * pVecZ_Prev) < 0) tvec = -tvec;
+
+    return tvec.Normalize();
+}
+
+// <Extrusion
+// DEF=""                                 ID
+// USE=""                                 IDREF
+// beginCap="true"                        SFBool     [initializeOnly]
+// ccw="true"                             SFBool     [initializeOnly]
+// convex="true"                          SFBool     [initializeOnly]
+// creaseAngle="0.0"                      SFloat     [initializeOnly]
+// crossSection="1 1 1 -1 -1 -1 -1 1 1 1" MFVec2f    [initializeOnly]
+// endCap="true"                          SFBool     [initializeOnly]
+// orientation="0 0 1 0"                  MFRotation [initializeOnly]
+// scale="1 1"                            MFVec2f    [initializeOnly]
+// solid="true"                           SFBool     [initializeOnly]
+// spine="0 0 0 0 1 0"                    MFVec3f    [initializeOnly]
+// />
+void X3DImporter::readExtrusion(XmlNode &node) {
+    std::string use, def;
+    bool beginCap = true;
+    bool ccw = true;
+    bool convex = true;
+    float creaseAngle = 0;
+    std::vector<aiVector2D> crossSection;
+    bool endCap = true;
+    std::vector<float> orientation;
+    std::vector<aiVector2D> scale;
+    bool solid = true;
+    std::vector<aiVector3D> spine;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    XmlParser::getBoolAttribute(node, "beginCap", beginCap);
+    XmlParser::getBoolAttribute(node, "ccw", ccw);
+    XmlParser::getBoolAttribute(node, "convex", convex);
+    XmlParser::getFloatAttribute(node, "creaseAngle", creaseAngle);
+    X3DXmlHelper::getVector2DArrayAttribute(node, "crossSection", crossSection);
+    XmlParser::getBoolAttribute(node, "endCap", endCap);
+    X3DXmlHelper::getFloatArrayAttribute(node, "orientation", orientation);
+    X3DXmlHelper::getVector2DArrayAttribute(node, "scale", scale);
+    XmlParser::getBoolAttribute(node, "solid", solid);
+    X3DXmlHelper::getVector3DArrayAttribute(node, "spine", spine);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_Extrusion, ne);
+    } else {
+        //
+        // check if default values must be assigned
+        //
+        if (spine.size() == 0) {
+            spine.resize(2);
+            spine[0].Set(0, 0, 0), spine[1].Set(0, 1, 0);
+        } else if (spine.size() == 1) {
+            throw DeadlyImportError("ParseNode_Geometry3D_Extrusion. Spine must have at least two points.");
+        }
+
+        if (crossSection.size() == 0) {
+            crossSection.resize(5);
+            crossSection[0].Set(1, 1), crossSection[1].Set(1, -1), crossSection[2].Set(-1, -1), crossSection[3].Set(-1, 1), crossSection[4].Set(1, 1);
+        }
+
+        { // orientation
+            size_t ori_size = orientation.size() / 4;
+
+            if (ori_size < spine.size()) {
+                float add_ori[4]; // values that will be added
+
+                if (ori_size == 1) // if "orientation" has one element(means one MFRotation with four components) then use it value for all spine points.
+                {
+                    add_ori[0] = orientation[0], add_ori[1] = orientation[1], add_ori[2] = orientation[2], add_ori[3] = orientation[3];
+                } else // else - use default values
+                {
+                    add_ori[0] = 0, add_ori[1] = 0, add_ori[2] = 1, add_ori[3] = 0;
+                }
+
+                orientation.reserve(spine.size() * 4);
+                for (size_t i = 0, i_e = (spine.size() - ori_size); i < i_e; i++)
+                    orientation.push_back(add_ori[0]), orientation.push_back(add_ori[1]), orientation.push_back(add_ori[2]), orientation.push_back(add_ori[3]);
+            }
+
+            if (orientation.size() % 4) throw DeadlyImportError("Attribute \"orientation\" in <Extrusion> must has multiple four quantity of numbers.");
+        } // END: orientation
+
+        { // scale
+            if (scale.size() < spine.size()) {
+                aiVector2D add_sc;
+
+                if (scale.size() == 1) // if "scale" has one element then use it value for all spine points.
+                    add_sc = scale[0];
+                else // else - use default values
+                    add_sc.Set(1, 1);
+
+                scale.reserve(spine.size());
+                for (size_t i = 0, i_e = (spine.size() - scale.size()); i < i_e; i++)
+                    scale.push_back(add_sc);
+            }
+        } // END: scale
+        //
+        // create and if needed - define new geometry object.
+        //
+        ne = new X3DNodeElementIndexedSet(X3DElemType::ENET_Extrusion, mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        X3DNodeElementIndexedSet &ext_alias = *((X3DNodeElementIndexedSet *)ne); // create alias for conveience
+        // assign part of input data
+        ext_alias.CCW = ccw;
+        ext_alias.Convex = convex;
+        ext_alias.CreaseAngle = creaseAngle;
+        ext_alias.Solid = solid;
+
+        //
+        // How we done it at all?
+        // 1. At first we will calculate array of basises for every point in spine(look SCP in ISO-dic). Also "orientation" vector
+        // are applied vor every basis.
+        // 2. After that we can create array of point sets: which are scaled, transferred to basis of relative basis and at final translated to real position
+        // using relative spine point.
+        // 3. Next step is creating CoordIdx array(do not forget "-1" delimiter). While creating CoordIdx also created faces for begin and end caps, if
+        // needed. While createing CootdIdx is taking in account CCW flag.
+        // 4. The last step: create Vertices list.
+        //
+        bool spine_closed; // flag: true if spine curve is closed.
+        bool cross_closed; // flag: true if cross curve is closed.
+        std::vector<aiMatrix3x3> basis_arr; // array of basises. ROW_a - X, ROW_b - Y, ROW_c - Z.
+        std::vector<std::vector<aiVector3D>> pointset_arr; // array of point sets: cross curves.
+
+        // detect closed curves
+        GeometryHelper_Extrusion_CurveIsClosed(crossSection, true, true, cross_closed); // true - drop tail, true - remove duplicate end.
+        GeometryHelper_Extrusion_CurveIsClosed(spine, true, true, spine_closed); // true - drop tail, true - remove duplicate end.
+        // If both cap are requested and spine curve is closed then we can make only one cap. Because second cap will be the same surface.
+        if (spine_closed) {
+            beginCap |= endCap;
+            endCap = false;
+        }
+
+        { // 1. Calculate array of basises.
+            aiMatrix4x4 rotmat;
+            aiVector3D vecX(0), vecY(0), vecZ(0);
+
+            basis_arr.resize(spine.size());
+            for (size_t i = 0, i_e = spine.size(); i < i_e; i++) {
+                aiVector3D tvec;
+
+                // get axises of basis.
+                vecY = GeometryHelper_Extrusion_GetNextY(i, spine, spine_closed);
+                vecZ = GeometryHelper_Extrusion_GetNextZ(i, spine, spine_closed, vecZ);
+                vecX = (vecY ^ vecZ).Normalize();
+                // get rotation matrix and apply "orientation" to basis
+                aiMatrix4x4::Rotation(orientation[i * 4 + 3], aiVector3D(orientation[i * 4], orientation[i * 4 + 1], orientation[i * 4 + 2]), rotmat);
+                tvec = vecX, tvec *= rotmat, basis_arr[i].a1 = tvec.x, basis_arr[i].a2 = tvec.y, basis_arr[i].a3 = tvec.z;
+                tvec = vecY, tvec *= rotmat, basis_arr[i].b1 = tvec.x, basis_arr[i].b2 = tvec.y, basis_arr[i].b3 = tvec.z;
+                tvec = vecZ, tvec *= rotmat, basis_arr[i].c1 = tvec.x, basis_arr[i].c2 = tvec.y, basis_arr[i].c3 = tvec.z;
+            } // for(size_t i = 0, i_e = spine.size(); i < i_e; i++)
+        } // END: 1. Calculate array of basises
+
+        { // 2. Create array of point sets.
+            aiMatrix4x4 scmat;
+            std::vector<aiVector3D> tcross(crossSection.size());
+
+            pointset_arr.resize(spine.size());
+            for (size_t spi = 0, spi_e = spine.size(); spi < spi_e; spi++) {
+                aiVector3D tc23vec;
+
+                tc23vec.Set(scale[spi].x, 0, scale[spi].y);
+                aiMatrix4x4::Scaling(tc23vec, scmat);
+                for (size_t cri = 0, cri_e = crossSection.size(); cri < cri_e; cri++) {
+                    aiVector3D tvecX, tvecY, tvecZ;
+
+                    tc23vec.Set(crossSection[cri].x, 0, crossSection[cri].y);
+                    // apply scaling to point
+                    tcross[cri] = scmat * tc23vec;
+                    //
+                    // transfer point to new basis
+                    // calculate coordinate in new basis
+                    tvecX.Set(basis_arr[spi].a1, basis_arr[spi].a2, basis_arr[spi].a3), tvecX *= tcross[cri].x;
+                    tvecY.Set(basis_arr[spi].b1, basis_arr[spi].b2, basis_arr[spi].b3), tvecY *= tcross[cri].y;
+                    tvecZ.Set(basis_arr[spi].c1, basis_arr[spi].c2, basis_arr[spi].c3), tvecZ *= tcross[cri].z;
+                    // apply new coordinates and translate it to spine point.
+                    tcross[cri] = tvecX + tvecY + tvecZ + spine[spi];
+                } // for(size_t cri = 0, cri_e = crossSection.size(); cri < cri_e; i++)
+
+                pointset_arr[spi] = tcross; // store transferred point set
+            } // for(size_t spi = 0, spi_e = spine.size(); spi < spi_e; i++)
+        } // END: 2. Create array of point sets.
+
+        { // 3. Create CoordIdx.
+            // add caps if needed
+            if (beginCap) {
+                // add cap as polygon. vertices of cap are places at begin, so just add numbers from zero.
+                for (size_t i = 0, i_e = crossSection.size(); i < i_e; i++)
+                    ext_alias.CoordIndex.push_back(static_cast<int32_t>(i));
+
+                // add delimiter
+                ext_alias.CoordIndex.push_back(-1);
+            } // if(beginCap)
+
+            if (endCap) {
+                // add cap as polygon. vertices of cap are places at end, as for beginCap use just sequence of numbers but with offset.
+                size_t beg = (pointset_arr.size() - 1) * crossSection.size();
+
+                for (size_t i = beg, i_e = (beg + crossSection.size()); i < i_e; i++)
+                    ext_alias.CoordIndex.push_back(static_cast<int32_t>(i));
+
+                // add delimiter
+                ext_alias.CoordIndex.push_back(-1);
+            } // if(beginCap)
+
+            // add quads
+            for (size_t spi = 0, spi_e = (spine.size() - 1); spi <= spi_e; spi++) {
+                const size_t cr_sz = crossSection.size();
+                const size_t cr_last = crossSection.size() - 1;
+
+                size_t right_col; // hold index basis for points of quad placed in right column;
+
+                if (spi != spi_e)
+                    right_col = spi + 1;
+                else if (spine_closed) // if spine curve is closed then one more quad is needed: between first and last points of curve.
+                    right_col = 0;
+                else
+                    break; // if spine curve is not closed then break the loop, because spi is out of range for that type of spine.
+
+                for (size_t cri = 0; cri < cr_sz; cri++) {
+                    if (cri != cr_last) {
+                        MACRO_FACE_ADD_QUAD(ccw, ext_alias.CoordIndex,
+                                static_cast<int32_t>(spi * cr_sz + cri),
+                                static_cast<int32_t>(right_col * cr_sz + cri),
+                                static_cast<int32_t>(right_col * cr_sz + cri + 1),
+                                static_cast<int32_t>(spi * cr_sz + cri + 1));
+                        // add delimiter
+                        ext_alias.CoordIndex.push_back(-1);
+                    } else if (cross_closed) // if cross curve is closed then one more quad is needed: between first and last points of curve.
+                    {
+                        MACRO_FACE_ADD_QUAD(ccw, ext_alias.CoordIndex,
+                                static_cast<int32_t>(spi * cr_sz + cri),
+                                static_cast<int32_t>(right_col * cr_sz + cri),
+                                static_cast<int32_t>(right_col * cr_sz + 0),
+                                static_cast<int32_t>(spi * cr_sz + 0));
+                        // add delimiter
+                        ext_alias.CoordIndex.push_back(-1);
+                    }
+                } // for(size_t cri = 0; cri < cr_sz; cri++)
+            } // for(size_t spi = 0, spi_e = (spine.size() - 2); spi < spi_e; spi++)
+        } // END: 3. Create CoordIdx.
+
+        { // 4. Create vertices list.
+            // just copy all vertices
+            for (size_t spi = 0, spi_e = spine.size(); spi < spi_e; spi++) {
+                for (size_t cri = 0, cri_e = crossSection.size(); cri < cri_e; cri++) {
+                    ext_alias.Vertices.emplace_back(pointset_arr[spi][cri]);
+                }
+            }
+        } // END: 4. Create vertices list.
+        //PrintVectorSet("Ext. CoordIdx", ext_alias.CoordIndex);
+        //PrintVectorSet("Ext. Vertices", ext_alias.Vertices);
+        // check for child nodes
+        if (!isNodeEmpty(node))
+            childrenReadMetadata(node, ne, "Extrusion");
+        else
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+// <IndexedFaceSet
+// DEF=""                         ID
+// USE=""                         IDREF
+// ccw="true"             SFBool  [initializeOnly]
+// colorIndex=""          MFInt32 [initializeOnly]
+// colorPerVertex="true"  SFBool  [initializeOnly]
+// convex="true"          SFBool  [initializeOnly]
+// coordIndex=""          MFInt32 [initializeOnly]
+// creaseAngle="0"        SFFloat [initializeOnly]
+// normalIndex=""         MFInt32 [initializeOnly]
+// normalPerVertex="true" SFBool  [initializeOnly]
+// solid="true"           SFBool  [initializeOnly]
+// texCoordIndex=""       MFInt32 [initializeOnly]
+// >
+//    <!-- ComposedGeometryContentModel -->
+// ComposedGeometryContentModel is the child-node content model corresponding to X3DComposedGeometryNodes. It can contain Color (or ColorRGBA), Coordinate,
+// Normal and TextureCoordinate, in any order. No more than one instance of these nodes is allowed. Multiple VertexAttribute (FloatVertexAttribute,
+// Matrix3VertexAttribute, Matrix4VertexAttribute) nodes can also be contained.
+// A ProtoInstance node (with the proper node type) can be substituted for any node in this content model.
+// </IndexedFaceSet>
+void X3DImporter::readIndexedFaceSet(XmlNode &node) {
+    std::string use, def;
+    bool ccw = true;
+    std::vector<int32_t> colorIndex;
+    bool colorPerVertex = true;
+    bool convex = true;
+    std::vector<int32_t> coordIndex;
+    float creaseAngle = 0;
+    std::vector<int32_t> normalIndex;
+    bool normalPerVertex = true;
+    bool solid = true;
+    std::vector<int32_t> texCoordIndex;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    XmlParser::getBoolAttribute(node, "ccw", ccw);
+    X3DXmlHelper::getInt32ArrayAttribute(node, "colorIndex", colorIndex);
+    XmlParser::getBoolAttribute(node, "colorPerVertex", colorPerVertex);
+    XmlParser::getBoolAttribute(node, "convex", convex);
+    X3DXmlHelper::getInt32ArrayAttribute(node, "coordIndex", coordIndex);
+    XmlParser::getFloatAttribute(node, "creaseAngle", creaseAngle);
+    X3DXmlHelper::getInt32ArrayAttribute(node, "normalIndex", normalIndex);
+    XmlParser::getBoolAttribute(node, "normalPerVertex", normalPerVertex);
+    XmlParser::getBoolAttribute(node, "solid", solid);
+    X3DXmlHelper::getInt32ArrayAttribute(node, "texCoordIndex", texCoordIndex);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_IndexedFaceSet, ne);
+    } else {
+        // check data
+        if (coordIndex.size() == 0) throw DeadlyImportError("IndexedFaceSet must contain not empty \"coordIndex\" attribute.");
+
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementIndexedSet(X3DElemType::ENET_IndexedFaceSet, mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        X3DNodeElementIndexedSet &ne_alias = *((X3DNodeElementIndexedSet *)ne);
+
+        ne_alias.CCW = ccw;
+        ne_alias.ColorIndex = colorIndex;
+        ne_alias.ColorPerVertex = colorPerVertex;
+        ne_alias.Convex = convex;
+        ne_alias.CoordIndex = coordIndex;
+        ne_alias.CreaseAngle = creaseAngle;
+        ne_alias.NormalIndex = normalIndex;
+        ne_alias.NormalPerVertex = normalPerVertex;
+        ne_alias.Solid = solid;
+        ne_alias.TexCoordIndex = texCoordIndex;
+        // check for child nodes
+        if (!isNodeEmpty(node)) {
+            ParseHelper_Node_Enter(ne);
+            for (auto currentChildNode : node.children()) {
+                const std::string &currentChildName = currentChildNode.name();
+                // check for X3DComposedGeometryNodes
+                if (currentChildName == "Color")
+                    readColor(currentChildNode);
+                else if (currentChildName == "ColorRGBA")
+                    readColorRGBA(currentChildNode);
+                else if (currentChildName == "Coordinate")
+                    readCoordinate(currentChildNode);
+                else if (currentChildName == "Normal")
+                    readNormal(currentChildNode);
+                else if (currentChildName == "TextureCoordinate")
+                    readTextureCoordinate(currentChildNode);
+                // check for X3DMetadataObject
+                else if (!checkForMetadataNode(currentChildNode))
+                    skipUnsupportedNode("IndexedFaceSet", currentChildNode);
+            }
+            ParseHelper_Node_Exit();
+        } // if(!isNodeEmpty(node))
+        else {
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+        }
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+// <Sphere
+// DEF=""       ID
+// USE=""       IDREF
+// radius="1"   SFloat [initializeOnly]
+// solid="true" SFBool [initializeOnly]
+// />
+void X3DImporter::readSphere(XmlNode &node) {
+    std::string use, def;
+    ai_real radius = 1;
+    bool solid = true;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    XmlParser::getRealAttribute(node, "radius", radius);
+    XmlParser::getBoolAttribute(node, "solid", solid);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_Sphere, ne);
+    } else {
+        const unsigned int tess = 3; ///TODO: IME tessellation factor through ai_property
+
+        std::vector<aiVector3D> tlist;
+
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementGeometry3D(X3DElemType::ENET_Sphere, mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        StandardShapes::MakeSphere(tess, tlist);
+        // copy data from temp array and apply scale
+        for (std::vector<aiVector3D>::iterator it = tlist.begin(); it != tlist.end(); ++it) {
+            aiVector3D v = *it;
+            ((X3DNodeElementGeometry3D *)ne)->Vertices.emplace_back(v * radius);
+        }
+
+        ((X3DNodeElementGeometry3D *)ne)->Solid = solid;
+        ((X3DNodeElementGeometry3D *)ne)->NumIndices = 3;
+        // check for X3DMetadataObject childs.
+        if (!isNodeEmpty(node))
+            childrenReadMetadata(node, ne, "Sphere");
+        else
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+} // namespace Assimp
+
+#endif // !ASSIMP_BUILD_NO_X3D_IMPORTER
diff --git a/Engine/lib/assimp/code/X3D/X3DImporter_Group.cpp b/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Group.cpp
similarity index 50%
rename from Engine/lib/assimp/code/X3D/X3DImporter_Group.cpp
rename to Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Group.cpp
index de3610caf..e7a2e917e 100644
--- a/Engine/lib/assimp/code/X3D/X3DImporter_Group.cpp
+++ b/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Group.cpp
@@ -41,16 +41,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 /// \file   X3DImporter_Group.cpp
 /// \brief  Parsing data from nodes of "Grouping" set of X3D.
-/// \date   2015-2016
-/// \author smal.root@gmail.com
+/// date   2015-2016
+/// author smal.root@gmail.com
 
 #ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
 
 #include "X3DImporter.hpp"
 #include "X3DImporter_Macro.hpp"
+#include "X3DXmlHelper.h"
 
-namespace Assimp
-{
+namespace Assimp {
 
 // <Group
 // DEF=""              ID
@@ -58,43 +58,35 @@ namespace Assimp
 // bboxCenter="0 0 0"  SFVec3f [initializeOnly]
 // bboxSize="-1 -1 -1" SFVec3f [initializeOnly]
 // >
-//    <!-- ChildContentModel -->
+//    <\!-- ChildContentModel -->
 // ChildContentModel is the child-node content model corresponding to X3DChildNode, combining all profiles. ChildContentModel can contain most nodes,
 // other Grouping nodes, Prototype declarations and ProtoInstances in any order and any combination. When the assigned profile is less than Full, the
 // precise palette of legal nodes that are available depends on assigned profile and components.
 // A ProtoInstance node (with the proper node type) can be substituted for any node in this content model.
 // </Group>
 // A Group node contains children nodes without introducing a new transformation. It is equivalent to a Transform node containing an identity transform.
-void X3DImporter::ParseNode_Grouping_Group()
-{
+void X3DImporter::startReadGroup(XmlNode &node) {
     std::string def, use;
 
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-	MACRO_ATTRREAD_LOOPEND;
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
 
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		CX3DImporter_NodeElement* ne;
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        X3DNodeElementBase *ne(nullptr);
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_Group, ne);
+    } else {
+        ParseHelper_Group_Begin(); // create new grouping element and go deeper if node has children.
+        // at this place new group mode created and made current, so we can name it.
+        if (!def.empty()) mNodeElementCur->ID = def;
+        // in grouping set of nodes check X3DMetadataObject is not needed, because it is done in <Scene> parser function.
 
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_Group, ne);
-	}
-	else
-	{
-		ParseHelper_Group_Begin();// create new grouping element and go deeper if node has children.
-		// at this place new group mode created and made current, so we can name it.
-		if(!def.empty()) NodeElement_Cur->ID = def;
-		// in grouping set of nodes check X3DMetadataObject is not needed, because it is done in <Scene> parser function.
-
-		// for empty element exit from node in that place
-		if(mReader->isEmptyElement()) ParseHelper_Node_Exit();
-	}// if(!use.empty()) else
+        // for empty element exit from node in that place
+        if (isNodeEmpty(node)) ParseHelper_Node_Exit();
+    } // if(!use.empty()) else
 }
 
-void X3DImporter::ParseNode_Grouping_GroupEnd()
-{
-	ParseHelper_Node_Exit();// go up in scene graph
+void X3DImporter::endReadGroup() {
+    ParseHelper_Node_Exit(); // go up in scene graph
 }
 
 // <StaticGroup
@@ -103,7 +95,7 @@ void X3DImporter::ParseNode_Grouping_GroupEnd()
 // bboxCenter="0 0 0"  SFVec3f [initializeOnly]
 // bboxSize="-1 -1 -1" SFVec3f [initializeOnly]
 // >
-//    <!-- ChildContentModel -->
+//    <\!-- ChildContentModel -->
 // ChildContentModel is the child-node content model corresponding to X3DChildNode, combining all profiles. ChildContentModel can contain most nodes,
 // other Grouping nodes, Prototype declarations and ProtoInstances in any order and any combination. When the assigned profile is less than Full, the
 // precise palette of legal nodes that are available depends on assigned profile and components.
@@ -111,36 +103,29 @@ void X3DImporter::ParseNode_Grouping_GroupEnd()
 // </StaticGroup>
 // The StaticGroup node contains children nodes which cannot be modified. StaticGroup children are guaranteed to not change, send events, receive events or
 // contain any USE references outside the StaticGroup.
-void X3DImporter::ParseNode_Grouping_StaticGroup()
-{
+void X3DImporter::startReadStaticGroup(XmlNode &node) {
     std::string def, use;
 
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-	MACRO_ATTRREAD_LOOPEND;
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
 
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		CX3DImporter_NodeElement* ne;
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        X3DNodeElementBase *ne(nullptr);
 
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_Group, ne);
-	}
-	else
-	{
-		ParseHelper_Group_Begin(true);// create new grouping element and go deeper if node has children.
-		// at this place new group mode created and made current, so we can name it.
-		if(!def.empty()) NodeElement_Cur->ID = def;
-		// in grouping set of nodes check X3DMetadataObject is not needed, because it is done in <Scene> parser function.
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_Group, ne);
+    } else {
+        ParseHelper_Group_Begin(true); // create new grouping element and go deeper if node has children.
+        // at this place new group mode created and made current, so we can name it.
+        if (!def.empty()) mNodeElementCur->ID = def;
+        // in grouping set of nodes check X3DMetadataObject is not needed, because it is done in <Scene> parser function.
 
-		// for empty element exit from node in that place
-		if(mReader->isEmptyElement()) ParseHelper_Node_Exit();
-	}// if(!use.empty()) else
+        // for empty element exit from node in that place
+        if (isNodeEmpty(node)) ParseHelper_Node_Exit();
+    } // if(!use.empty()) else
 }
 
-void X3DImporter::ParseNode_Grouping_StaticGroupEnd()
-{
-	ParseHelper_Node_Exit();// go up in scene graph
+void X3DImporter::endReadStaticGroup() {
+    ParseHelper_Node_Exit(); // go up in scene graph
 }
 
 // <Switch
@@ -150,7 +135,7 @@ void X3DImporter::ParseNode_Grouping_StaticGroupEnd()
 // bboxSize="-1 -1 -1" SFVec3f [initializeOnly]
 // whichChoice="-1"    SFInt32 [inputOutput]
 // >
-//    <!-- ChildContentModel -->
+//    <\!-- ChildContentModel -->
 // ChildContentModel is the child-node content model corresponding to X3DChildNode, combining all profiles. ChildContentModel can contain most nodes,
 // other Grouping nodes, Prototype declarations and ProtoInstances in any order and any combination. When the assigned profile is less than Full, the
 // precise palette of legal nodes that are available depends on assigned profile and components.
@@ -159,43 +144,36 @@ void X3DImporter::ParseNode_Grouping_StaticGroupEnd()
 // The Switch grouping node traverses zero or one of the nodes specified in the children field. The whichChoice field specifies the index of the child
 // to traverse, with the first child having index 0. If whichChoice is less than zero or greater than the number of nodes in the children field, nothing
 // is chosen.
-void X3DImporter::ParseNode_Grouping_Switch()
-{
+void X3DImporter::startReadSwitch(XmlNode &node) {
     std::string def, use;
     int32_t whichChoice = -1;
 
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_RET("whichChoice", whichChoice, XML_ReadNode_GetAttrVal_AsI32);
-	MACRO_ATTRREAD_LOOPEND;
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    XmlParser::getIntAttribute(node, "whichChoice", whichChoice);
 
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		CX3DImporter_NodeElement* ne;
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        X3DNodeElementBase *ne(nullptr);
 
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_Group, ne);
-	}
-	else
-	{
-		ParseHelper_Group_Begin();// create new grouping element and go deeper if node has children.
-		// at this place new group mode created and made current, so we can name it.
-		if(!def.empty()) NodeElement_Cur->ID = def;
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_Group, ne);
+    } else {
+        ParseHelper_Group_Begin(); // create new grouping element and go deeper if node has children.
+        // at this place new group mode created and made current, so we can name it.
+        if (!def.empty()) mNodeElementCur->ID = def;
 
-		// also set values specific to this type of group
-		((CX3DImporter_NodeElement_Group*)NodeElement_Cur)->UseChoice = true;
-		((CX3DImporter_NodeElement_Group*)NodeElement_Cur)->Choice = whichChoice;
-		// in grouping set of nodes check X3DMetadataObject is not needed, because it is done in <Scene> parser function.
+        // also set values specific to this type of group
+        ((X3DNodeElementGroup *)mNodeElementCur)->UseChoice = true;
+        ((X3DNodeElementGroup *)mNodeElementCur)->Choice = whichChoice;
+        // in grouping set of nodes check X3DMetadataObject is not needed, because it is done in <Scene> parser function.
 
-		// for empty element exit from node in that place
-		if(mReader->isEmptyElement()) ParseHelper_Node_Exit();
-	}// if(!use.empty()) else
+        // for empty element exit from node in that place
+        if (isNodeEmpty(node)) ParseHelper_Node_Exit();
+    } // if(!use.empty()) else
 }
 
-void X3DImporter::ParseNode_Grouping_SwitchEnd()
-{
-	// just exit from node. Defined choice will be accepted at postprocessing stage.
-	ParseHelper_Node_Exit();// go up in scene graph
+void X3DImporter::endReadSwitch() {
+    // just exit from node. Defined choice will be accepted at postprocessing stage.
+    ParseHelper_Node_Exit(); // go up in scene graph
 }
 
 // <Transform
@@ -209,7 +187,7 @@ void X3DImporter::ParseNode_Grouping_SwitchEnd()
 // scaleOrientation="0 0 1 0" SFRotation [inputOutput]
 // translation="0 0 0"        SFVec3f    [inputOutput]
 // >
-//    <!-- ChildContentModel -->
+//    <\!-- ChildContentModel -->
 // ChildContentModel is the child-node content model corresponding to X3DChildNode, combining all profiles. ChildContentModel can contain most nodes,
 // other Grouping nodes, Prototype declarations and ProtoInstances in any order and any combination. When the assigned profile is less than Full, the
 // precise palette of legal nodes that are available depends on assigned profile and components.
@@ -220,99 +198,80 @@ void X3DImporter::ParseNode_Grouping_SwitchEnd()
 // transformations. In matrix transformation notation, where C (center), SR (scaleOrientation), T (translation), R (rotation), and S (scale) are the
 // equivalent transformation matrices,
 //   P' = T * C * R * SR * S * -SR * -C * P
-void X3DImporter::ParseNode_Grouping_Transform()
-{
+void X3DImporter::startReadTransform(XmlNode &node) {
     aiVector3D center(0, 0, 0);
-    float rotation[4] = {0, 0, 1, 0};
-    aiVector3D scale(1, 1, 1);// A value of zero indicates that any child geometry shall not be displayed
-    float scale_orientation[4] = {0, 0, 1, 0};
+    float rotation[4] = { 0, 0, 1, 0 };
+    aiVector3D scale(1, 1, 1); // A value of zero indicates that any child geometry shall not be displayed
+    float scale_orientation[4] = { 0, 0, 1, 0 };
     aiVector3D translation(0, 0, 0);
     aiMatrix4x4 matr, tmatr;
     std::string use, def;
 
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_REF("center", center, XML_ReadNode_GetAttrVal_AsVec3f);
-		MACRO_ATTRREAD_CHECK_REF("scale", scale, XML_ReadNode_GetAttrVal_AsVec3f);
-		MACRO_ATTRREAD_CHECK_REF("translation", translation, XML_ReadNode_GetAttrVal_AsVec3f);
-		if(an == "rotation")
-		{
-			std::vector<float> tvec;
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    X3DXmlHelper::getVector3DAttribute(node, "center", center);
+    X3DXmlHelper::getVector3DAttribute(node, "scale", scale);
+    X3DXmlHelper::getVector3DAttribute(node, "translation", translation);
+    std::vector<float> tvec;
+    if (X3DXmlHelper::getFloatArrayAttribute(node, "rotation", tvec)) {
+        if (tvec.size() != 4) throw DeadlyImportError("<Transform>: rotation vector must have 4 elements.");
+        memcpy(rotation, tvec.data(), sizeof(rotation));
+        tvec.clear();
+    }
+    if (X3DXmlHelper::getFloatArrayAttribute(node, "scaleOrientation", tvec)) {
+        if (tvec.size() != 4) throw DeadlyImportError("<Transform>: scaleOrientation vector must have 4 elements.");
+        memcpy(scale_orientation, tvec.data(), sizeof(scale_orientation));
+        tvec.clear();
+    }
 
-			XML_ReadNode_GetAttrVal_AsArrF(idx, tvec);
-			if(tvec.size() != 4) throw DeadlyImportError("<Transform>: rotation vector must have 4 elements.");
-
-			memcpy(rotation, tvec.data(), sizeof(rotation));
-
-			continue;
-		}
-
-		if(an == "scaleOrientation")
-		{
-			std::vector<float> tvec;
-			XML_ReadNode_GetAttrVal_AsArrF(idx, tvec);
-            if ( tvec.size() != 4 )
-            {
-                throw DeadlyImportError( "<Transform>: scaleOrientation vector must have 4 elements." );
-            }
-
-			::memcpy(scale_orientation, tvec.data(), sizeof(scale_orientation) );
-
-			continue;
-		}
-
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		CX3DImporter_NodeElement* ne( nullptr );
-
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_Group, ne);
-	}
-	else
-	{
-		ParseHelper_Group_Begin();// create new grouping element and go deeper if node has children.
-		// at this place new group mode created and made current, so we can name it.
-        if ( !def.empty() )
-        {
-            NodeElement_Cur->ID = def;
-        }
-
-		//
-		// also set values specific to this type of group
-		//
-		// calculate transformation matrix
-		aiMatrix4x4::Translation(translation, matr);// T
-		aiMatrix4x4::Translation(center, tmatr);// C
-		matr *= tmatr;
-		aiMatrix4x4::Rotation(rotation[3], aiVector3D(rotation[0], rotation[1], rotation[2]), tmatr);// R
-		matr *= tmatr;
-		aiMatrix4x4::Rotation(scale_orientation[3], aiVector3D(scale_orientation[0], scale_orientation[1], scale_orientation[2]), tmatr);// SR
-		matr *= tmatr;
-		aiMatrix4x4::Scaling(scale, tmatr);// S
-		matr *= tmatr;
-		aiMatrix4x4::Rotation(-scale_orientation[3], aiVector3D(scale_orientation[0], scale_orientation[1], scale_orientation[2]), tmatr);// -SR
-		matr *= tmatr;
-		aiMatrix4x4::Translation(-center, tmatr);// -C
-		matr *= tmatr;
-		// and assign it
-		((CX3DImporter_NodeElement_Group*)NodeElement_Cur)->Transformation = matr;
-		// in grouping set of nodes check X3DMetadataObject is not needed, because it is done in <Scene> parser function.
-
-		// for empty element exit from node in that place
-        if ( mReader->isEmptyElement() )
-        {
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        X3DNodeElementBase *ne(nullptr);
+        bool newgroup = (nullptr == mNodeElementCur);
+        if(newgroup)
+            ParseHelper_Group_Begin();
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_Group, ne);
+        if (newgroup && isNodeEmpty(node)) {
             ParseHelper_Node_Exit();
         }
-	}// if(!use.empty()) else
+    } else {
+        ParseHelper_Group_Begin(); // create new grouping element and go deeper if node has children.
+        // at this place new group mode created and made current, so we can name it.
+        if (!def.empty()) {
+            mNodeElementCur->ID = def;
+        }
+
+        //
+        // also set values specific to this type of group
+        //
+        // calculate transformation matrix
+        aiMatrix4x4::Translation(translation, matr); // T
+        aiMatrix4x4::Translation(center, tmatr); // C
+        matr *= tmatr;
+        aiMatrix4x4::Rotation(rotation[3], aiVector3D(rotation[0], rotation[1], rotation[2]), tmatr); // R
+        matr *= tmatr;
+        aiMatrix4x4::Rotation(scale_orientation[3], aiVector3D(scale_orientation[0], scale_orientation[1], scale_orientation[2]), tmatr); // SR
+        matr *= tmatr;
+        aiMatrix4x4::Scaling(scale, tmatr); // S
+        matr *= tmatr;
+        aiMatrix4x4::Rotation(-scale_orientation[3], aiVector3D(scale_orientation[0], scale_orientation[1], scale_orientation[2]), tmatr); // -SR
+        matr *= tmatr;
+        aiMatrix4x4::Translation(-center, tmatr); // -C
+        matr *= tmatr;
+        // and assign it
+        ((X3DNodeElementGroup *)mNodeElementCur)->Transformation = matr;
+        // in grouping set of nodes check X3DMetadataObject is not needed, because it is done in <Scene> parser function.
+
+        // for empty element exit from node in that place
+        if (isNodeEmpty(node)) {
+            ParseHelper_Node_Exit();
+        }
+    } // if(!use.empty()) else
 }
 
-void X3DImporter::ParseNode_Grouping_TransformEnd()
-{
-	ParseHelper_Node_Exit();// go up in scene graph
+void X3DImporter::endReadTransform() {
+    ParseHelper_Node_Exit(); // go up in scene graph
 }
 
-}// namespace Assimp
+} // namespace Assimp
 
 #endif // !ASSIMP_BUILD_NO_X3D_IMPORTER
diff --git a/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Light.cpp b/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Light.cpp
new file mode 100644
index 000000000..f1ed5e4cd
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Light.cpp
@@ -0,0 +1,270 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2019, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+/// \file   X3DImporter_Light.cpp
+/// \brief  Parsing data from nodes of "Lighting" set of X3D.
+/// date   2015-2016
+/// author smal.root@gmail.com
+
+#ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
+
+#include "X3DImporter.hpp"
+#include "X3DImporter_Macro.hpp"
+#include "X3DXmlHelper.h"
+#include <assimp/StringUtils.h>
+
+namespace Assimp {
+
+// <DirectionalLight
+// DEF=""               ID
+// USE=""               IDREF
+// ambientIntensity="0" SFFloat [inputOutput]
+// color="1 1 1"        SFColor [inputOutput]
+// direction="0 0 -1"   SFVec3f [inputOutput]
+// global="false"       SFBool  [inputOutput]
+// intensity="1"        SFFloat [inputOutput]
+// on="true"            SFBool  [inputOutput]
+// />
+void X3DImporter::readDirectionalLight(XmlNode &node) {
+    std::string def, use;
+    float ambientIntensity = 0;
+    aiColor3D color(1, 1, 1);
+    aiVector3D direction(0, 0, -1);
+    bool global = false;
+    float intensity = 1;
+    bool on = true;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    XmlParser::getFloatAttribute(node, "ambientIntensity", ambientIntensity);
+    X3DXmlHelper::getColor3DAttribute(node, "color", color);
+    X3DXmlHelper::getVector3DAttribute(node, "direction", direction);
+    XmlParser::getBoolAttribute(node, "global", global);
+    XmlParser::getFloatAttribute(node, "intensity", intensity);
+    XmlParser::getBoolAttribute(node, "on", on);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_DirectionalLight, ne);
+    } else {
+        if (on) {
+            // create and if needed - define new geometry object.
+            ne = new X3DNodeElementLight(X3DElemType::ENET_DirectionalLight, mNodeElementCur);
+            if (!def.empty())
+                ne->ID = def;
+            else
+                ne->ID = "DirectionalLight_" + ai_to_string((size_t)ne); // make random name
+
+            ((X3DNodeElementLight *)ne)->AmbientIntensity = ambientIntensity;
+            ((X3DNodeElementLight *)ne)->Color = color;
+            ((X3DNodeElementLight *)ne)->Direction = direction;
+            ((X3DNodeElementLight *)ne)->Global = global;
+            ((X3DNodeElementLight *)ne)->Intensity = intensity;
+            // Assimp want a node with name similar to a light. "Why? I don't no." )
+            ParseHelper_Group_Begin(false);
+
+            mNodeElementCur->ID = ne->ID; // assign name to node and return to light element.
+            ParseHelper_Node_Exit();
+            // check for child nodes
+            if (!isNodeEmpty(node))
+                childrenReadMetadata(node, ne, "DirectionalLight");
+            else
+                mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+
+            NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+        } // if(on)
+    } // if(!use.empty()) else
+}
+
+// <PointLight
+// DEF=""               ID
+// USE=""               IDREF
+// ambientIntensity="0" SFFloat [inputOutput]
+// attenuation="1 0 0"  SFVec3f [inputOutput]
+// color="1 1 1"        SFColor [inputOutput]
+// global="true"        SFBool  [inputOutput]
+// intensity="1"        SFFloat [inputOutput]
+// location="0 0 0"     SFVec3f [inputOutput]
+// on="true"            SFBool  [inputOutput]
+// radius="100"         SFFloat [inputOutput]
+// />
+void X3DImporter::readPointLight(XmlNode &node) {
+    std::string def, use;
+    float ambientIntensity = 0;
+    aiVector3D attenuation(1, 0, 0);
+    aiColor3D color(1, 1, 1);
+    bool global = true;
+    float intensity = 1;
+    aiVector3D location(0, 0, 0);
+    bool on = true;
+    float radius = 100;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    XmlParser::getFloatAttribute(node, "ambientIntensity", ambientIntensity);
+    X3DXmlHelper::getVector3DAttribute(node, "attenuation", attenuation);
+    X3DXmlHelper::getColor3DAttribute(node, "color", color);
+    XmlParser::getBoolAttribute(node, "global", global);
+    XmlParser::getFloatAttribute(node, "intensity", intensity);
+    X3DXmlHelper::getVector3DAttribute(node, "location", location);
+    XmlParser::getBoolAttribute(node, "on", on);
+    XmlParser::getFloatAttribute(node, "radius", radius);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_PointLight, ne);
+    } else {
+        if (on) {
+            // create and if needed - define new geometry object.
+            ne = new X3DNodeElementLight(X3DElemType::ENET_PointLight, mNodeElementCur);
+            if (!def.empty()) ne->ID = def;
+
+            ((X3DNodeElementLight *)ne)->AmbientIntensity = ambientIntensity;
+            ((X3DNodeElementLight *)ne)->Attenuation = attenuation;
+            ((X3DNodeElementLight *)ne)->Color = color;
+            ((X3DNodeElementLight *)ne)->Global = global;
+            ((X3DNodeElementLight *)ne)->Intensity = intensity;
+            ((X3DNodeElementLight *)ne)->Location = location;
+            ((X3DNodeElementLight *)ne)->Radius = radius;
+            // Assimp want a node with name similar to a light. "Why? I don't no." )
+            ParseHelper_Group_Begin(false);
+            // make random name
+            if (ne->ID.empty()) ne->ID = "PointLight_" + ai_to_string((size_t)ne);
+
+            mNodeElementCur->ID = ne->ID; // assign name to node and return to light element.
+            ParseHelper_Node_Exit();
+            // check for child nodes
+            if (!isNodeEmpty(node))
+                childrenReadMetadata(node, ne, "PointLight");
+            else
+                mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+
+            NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+        } // if(on)
+    } // if(!use.empty()) else
+}
+
+// <SpotLight
+// DEF=""                 ID
+// USE=""                 IDREF
+// ambientIntensity="0"   SFFloat [inputOutput]
+// attenuation="1 0 0"    SFVec3f [inputOutput]
+// beamWidth="0.7854"     SFFloat [inputOutput]
+// color="1 1 1"          SFColor [inputOutput]
+// cutOffAngle="1.570796" SFFloat [inputOutput]
+// direction="0 0 -1"     SFVec3f [inputOutput]
+// global="true"          SFBool  [inputOutput]
+// intensity="1"          SFFloat [inputOutput]
+// location="0 0 0"       SFVec3f [inputOutput]
+// on="true"              SFBool  [inputOutput]
+// radius="100"           SFFloat [inputOutput]
+// />
+void X3DImporter::readSpotLight(XmlNode &node) {
+    std::string def, use;
+    float ambientIntensity = 0;
+    aiVector3D attenuation(1, 0, 0);
+    float beamWidth = 0.7854f;
+    aiColor3D color(1, 1, 1);
+    float cutOffAngle = 1.570796f;
+    aiVector3D direction(0, 0, -1);
+    bool global = true;
+    float intensity = 1;
+    aiVector3D location(0, 0, 0);
+    bool on = true;
+    float radius = 100;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    XmlParser::getFloatAttribute(node, "ambientIntensity", ambientIntensity);
+    X3DXmlHelper::getVector3DAttribute(node, "attenuation", attenuation);
+    XmlParser::getFloatAttribute(node, "beamWidth", beamWidth);
+    X3DXmlHelper::getColor3DAttribute(node, "color", color);
+    XmlParser::getFloatAttribute(node, "cutOffAngle", cutOffAngle);
+    X3DXmlHelper::getVector3DAttribute(node, "direction", direction);
+    XmlParser::getBoolAttribute(node, "global", global);
+    XmlParser::getFloatAttribute(node, "intensity", intensity);
+    X3DXmlHelper::getVector3DAttribute(node, "location", location);
+    XmlParser::getBoolAttribute(node, "on", on);
+    XmlParser::getFloatAttribute(node, "radius", radius);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_SpotLight, ne);
+    } else {
+        if (on) {
+            // create and if needed - define new geometry object.
+            ne = new X3DNodeElementLight(X3DElemType::ENET_SpotLight, mNodeElementCur);
+            if (!def.empty()) ne->ID = def;
+
+            if (beamWidth > cutOffAngle) beamWidth = cutOffAngle;
+
+            ((X3DNodeElementLight *)ne)->AmbientIntensity = ambientIntensity;
+            ((X3DNodeElementLight *)ne)->Attenuation = attenuation;
+            ((X3DNodeElementLight *)ne)->BeamWidth = beamWidth;
+            ((X3DNodeElementLight *)ne)->Color = color;
+            ((X3DNodeElementLight *)ne)->CutOffAngle = cutOffAngle;
+            ((X3DNodeElementLight *)ne)->Direction = direction;
+            ((X3DNodeElementLight *)ne)->Global = global;
+            ((X3DNodeElementLight *)ne)->Intensity = intensity;
+            ((X3DNodeElementLight *)ne)->Location = location;
+            ((X3DNodeElementLight *)ne)->Radius = radius;
+
+            // Assimp want a node with name similar to a light. "Why? I don't no." )
+            ParseHelper_Group_Begin(false);
+            // make random name
+            if (ne->ID.empty()) ne->ID = "SpotLight_" + ai_to_string((size_t)ne);
+
+            mNodeElementCur->ID = ne->ID; // assign name to node and return to light element.
+            ParseHelper_Node_Exit();
+            // check for child nodes
+            if (!isNodeEmpty(node))
+                childrenReadMetadata(node, ne, "SpotLight");
+            else
+                mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+
+            NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+        } // if(on)
+    } // if(!use.empty()) else
+}
+
+} // namespace Assimp
+
+#endif // !ASSIMP_BUILD_NO_X3D_IMPORTER
diff --git a/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Macro.hpp b/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Macro.hpp
new file mode 100644
index 000000000..a84a739a3
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Macro.hpp
@@ -0,0 +1,121 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2019, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+/// \file X3DImporter_Macro.hpp
+/// \brief Useful macrodefines.
+/// \date 2015-2016
+/// \author smal.root@gmail.com
+
+#ifndef X3DIMPORTER_MACRO_HPP_INCLUDED
+#define X3DIMPORTER_MACRO_HPP_INCLUDED
+
+#include <assimp/XmlParser.h>
+#include "X3DImporter.hpp"
+#include <string>
+
+namespace Assimp {
+
+/// Used for regular checking while attribute "USE" is defined.
+/// \param [in] pNode - pugi xml node to read.
+/// \param [in] pDEF - string holding "DEF" value.
+/// \param [in] pUSE - string holding "USE" value.
+/// \param [in] pType - type of element to find.
+/// \param [out] pNE - pointer to found node element.
+inline X3DNodeElementBase *X3DImporter::MACRO_USE_CHECKANDAPPLY(XmlNode &node, std::string pDEF, std::string pUSE, X3DElemType pType, X3DNodeElementBase *pNE) {
+    checkNodeMustBeEmpty(node);
+    if (!pDEF.empty())
+        Assimp::Throw_DEF_And_USE(node.name());
+    if (!FindNodeElement(pUSE, pType, &pNE))
+        Assimp::Throw_USE_NotFound(node.name(), pUSE);
+    ai_assert(nullptr != mNodeElementCur);
+    mNodeElementCur->Children.push_back(pNE); /* add found object as child to current element */
+
+    return pNE;
+}
+
+} // namespace Assimp
+
+/// \def MACRO_ATTRREAD_CHECKUSEDEF_RET
+/// Compact variant for checking "USE" and "DEF".
+/// \param [in] pNode - pugi xml node to read.
+/// \param [out] pDEF_Var - output variable name for "DEF" value.
+/// \param [out] pUSE_Var - output variable name for "USE" value.
+#define MACRO_ATTRREAD_CHECKUSEDEF_RET(pNode, pDEF_Var, pUSE_Var) \
+    do {                                                          \
+    XmlParser::getStdStrAttribute(pNode, "DEF", pDEF_Var);        \
+    XmlParser::getStdStrAttribute(pNode, "USE", pUSE_Var);        \
+    } while (false)
+
+/// \def MACRO_FACE_ADD_QUAD_FA(pCCW, pOut, pIn, pP1, pP2, pP3, pP4)
+/// Add points as quad. Means that pP1..pP4 set in CCW order.
+#define MACRO_FACE_ADD_QUAD_FA(pCCW, pOut, pIn, pP1, pP2, pP3, pP4) \
+    do {                                                            \
+        if (pCCW) {                                                 \
+            pOut.push_back(pIn[pP1]);                               \
+            pOut.push_back(pIn[pP2]);                               \
+            pOut.push_back(pIn[pP3]);                               \
+            pOut.push_back(pIn[pP4]);                               \
+        } else {                                                    \
+            pOut.push_back(pIn[pP4]);                               \
+            pOut.push_back(pIn[pP3]);                               \
+            pOut.push_back(pIn[pP2]);                               \
+            pOut.push_back(pIn[pP1]);                               \
+        }                                                           \
+    } while (false)
+
+/// \def MACRO_FACE_ADD_QUAD(pCCW, pOut, pP1, pP2, pP3, pP4)
+/// Add points as quad. Means that pP1..pP4 set in CCW order.
+#define MACRO_FACE_ADD_QUAD(pCCW, pOut, pP1, pP2, pP3, pP4) \
+    do {                                                    \
+        if (pCCW) {                                         \
+            pOut.push_back(pP1);                            \
+            pOut.push_back(pP2);                            \
+            pOut.push_back(pP3);                            \
+            pOut.push_back(pP4);                            \
+        } else {                                            \
+            pOut.push_back(pP4);                            \
+            pOut.push_back(pP3);                            \
+            pOut.push_back(pP2);                            \
+            pOut.push_back(pP1);                            \
+        }                                                   \
+    } while (false)
+
+#endif // X3DIMPORTER_MACRO_HPP_INCLUDED
diff --git a/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Metadata.cpp b/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Metadata.cpp
new file mode 100644
index 000000000..8e07d8bb8
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Metadata.cpp
@@ -0,0 +1,255 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2019, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+/// \file   X3DImporter_Metadata.cpp
+/// \brief  Parsing data from nodes of "Metadata" set of X3D.
+/// \date   2015-2016
+/// \author smal.root@gmail.com
+
+#ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
+
+#include "X3DImporter.hpp"
+#include "X3DImporter_Macro.hpp"
+#include "X3DXmlHelper.h"
+
+namespace Assimp {
+
+bool X3DImporter::checkForMetadataNode(XmlNode &node) {
+    const std::string &name = node.name();
+    if (name == "MetadataBoolean") {
+        readMetadataBoolean(node);
+    } else if (name == "MetadataDouble") {
+        readMetadataDouble(node);
+    } else if (name == "MetadataFloat") {
+        readMetadataFloat(node);
+    } else if (name == "MetadataInteger") {
+        readMetadataInteger(node);
+    } else if (name == "MetadataSet") {
+        readMetadataSet(node);
+    } else if (name == "MetadataString") {
+        readMetadataString(node);
+    } else
+        return false;
+    return true;
+}
+
+void X3DImporter::childrenReadMetadata(XmlNode &node, X3DNodeElementBase *pParentElement, const std::string &pNodeName) {
+    ParseHelper_Node_Enter(pParentElement);
+    for (auto childNode : node.children()) {
+        if (!checkForMetadataNode(childNode)) skipUnsupportedNode(pNodeName, childNode);
+    }
+    ParseHelper_Node_Exit();
+}
+
+/// \def MACRO_METADATA_FINDCREATE(pDEF_Var, pUSE_Var, pReference, pValue, pNE, pMetaName)
+/// Find element by "USE" or create new one.
+/// \param [in] pNode - pugi xml node to read.
+/// \param [in] pDEF_Var - variable name with "DEF" value.
+/// \param [in] pUSE_Var - variable name with "USE" value.
+/// \param [in] pReference - variable name with "reference" value.
+/// \param [in] pValue - variable name with "value" value.
+/// \param [in, out] pNE - pointer to node element.
+/// \param [in] pMetaClass - Class of node.
+/// \param [in] pMetaName - Name of node.
+/// \param [in] pType - type of element to find.
+#define MACRO_METADATA_FINDCREATE(pNode, pDEF_Var, pUSE_Var, pReference, pValue, pNE, pMetaClass, pMetaName, pType)                            \
+    /* if "USE" defined then find already defined element. */                                                                                  \
+    if (!pUSE_Var.empty()) {                                                                                                                   \
+        ne = MACRO_USE_CHECKANDAPPLY(pNode, pDEF_Var, pUSE_Var, pType, pNE);                                                                        \
+    } else {                                                                                                                                   \
+        pNE = new pMetaClass(mNodeElementCur);                                                                                                 \
+        if (!pDEF_Var.empty()) pNE->ID = pDEF_Var;                                                                                             \
+                                                                                                                                               \
+        ((pMetaClass *)pNE)->Reference = pReference;                                                                                           \
+        ((pMetaClass *)pNE)->Value = pValue;                                                                                                   \
+        /* also metadata node can contain childs */                                                                                            \
+        if (!isNodeEmpty(pNode))                                                                                                               \
+            childrenReadMetadata(pNode, pNE, pMetaName); /* in that case node element will be added to child elements list of current node. */ \
+        else                                                                                                                                   \
+            mNodeElementCur->Children.push_back(pNE); /* else - add element to child list manually */                                          \
+                                                                                                                                               \
+        NodeElement_List.push_back(pNE); /* add new element to elements list. */                                                               \
+    } /* if(!pUSE_Var.empty()) else */                                                                                                         \
+                                                                                                                                               \
+    do {                                                                                                                                       \
+    } while (false)
+
+// <MetadataBoolean
+// DEF=""       ID
+// USE=""       IDREF
+// name=""      SFString [inputOutput]
+// reference="" SFString [inputOutput]
+// value=""     MFBool   [inputOutput]
+// />
+void X3DImporter::readMetadataBoolean(XmlNode &node) {
+    std::string def, use;
+    std::string name, reference;
+    std::vector<bool> value;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    XmlParser::getStdStrAttribute(node, "name", name);
+    XmlParser::getStdStrAttribute(node, "reference", reference);
+    X3DXmlHelper::getBooleanArrayAttribute(node, "value", value);
+
+    MACRO_METADATA_FINDCREATE(node, def, use, reference, value, ne, X3DNodeElementMetaBoolean, "MetadataBoolean", ENET_MetaBoolean);
+}
+
+// <MetadataDouble
+// DEF=""       ID
+// USE=""       IDREF
+// name=""      SFString [inputOutput]
+// reference="" SFString [inputOutput]
+// value=""     MFDouble [inputOutput]
+// />
+void X3DImporter::readMetadataDouble(XmlNode &node) {
+    std::string def, use;
+    std::string name, reference;
+    std::vector<double> value;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    XmlParser::getStdStrAttribute(node, "name", name);
+    XmlParser::getStdStrAttribute(node, "reference", reference);
+    X3DXmlHelper::getDoubleArrayAttribute(node, "value", value);
+
+    MACRO_METADATA_FINDCREATE(node, def, use, reference, value, ne, X3DNodeElementMetaDouble, "MetadataDouble", ENET_MetaDouble);
+}
+
+// <MetadataFloat
+// DEF=""       ID
+// USE=""       IDREF
+// name=""      SFString [inputOutput]
+// reference="" SFString [inputOutput]
+// value=""     MFFloat  [inputOutput]
+// />
+void X3DImporter::readMetadataFloat(XmlNode &node) {
+    std::string def, use;
+    std::string name, reference;
+    std::vector<float> value;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    XmlParser::getStdStrAttribute(node, "name", name);
+    XmlParser::getStdStrAttribute(node, "reference", reference);
+    X3DXmlHelper::getFloatArrayAttribute(node, "value", value);
+
+    MACRO_METADATA_FINDCREATE(node, def, use, reference, value, ne, X3DNodeElementMetaFloat, "MetadataFloat", ENET_MetaFloat);
+}
+
+// <MetadataInteger
+// DEF=""       ID
+// USE=""       IDREF
+// name=""      SFString  [inputOutput]
+// reference="" SFString  [inputOutput]
+// value=""     MFInteger [inputOutput]
+// />
+void X3DImporter::readMetadataInteger(XmlNode &node) {
+    std::string def, use;
+    std::string name, reference;
+    std::vector<int32_t> value;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    XmlParser::getStdStrAttribute(node, "name", name);
+    XmlParser::getStdStrAttribute(node, "reference", reference);
+    X3DXmlHelper::getInt32ArrayAttribute(node, "value", value);
+
+    MACRO_METADATA_FINDCREATE(node, def, use, reference, value, ne, X3DNodeElementMetaInt, "MetadataInteger", ENET_MetaInteger);
+}
+
+// <MetadataSet
+// DEF=""       ID
+// USE=""       IDREF
+// name=""      SFString [inputOutput]
+// reference="" SFString [inputOutput]
+// />
+void X3DImporter::readMetadataSet(XmlNode &node) {
+    std::string def, use;
+    std::string name, reference;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    XmlParser::getStdStrAttribute(node, "name", name);
+    XmlParser::getStdStrAttribute(node, "reference", reference);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_MetaSet, ne);
+    } else {
+        ne = new X3DNodeElementMetaSet(mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        ((X3DNodeElementMetaSet *)ne)->Reference = reference;
+        // also metadata node can contain children
+        if (!isNodeEmpty(node))
+            childrenReadMetadata(node, ne, "MetadataSet");
+        else
+            mNodeElementCur->Children.push_back(ne); // made object as child to current element
+
+        NodeElement_List.push_back(ne); // add new element to elements list.
+    } // if(!use.empty()) else
+}
+
+// <MetadataString
+// DEF=""       ID
+// USE=""       IDREF
+// name=""      SFString [inputOutput]
+// reference="" SFString [inputOutput]
+// value=""     MFString [inputOutput]
+// />
+void X3DImporter::readMetadataString(XmlNode &node) {
+    std::string def, use;
+    std::string name, reference;
+    std::vector<std::string> value;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    XmlParser::getStdStrAttribute(node, "name", name);
+    XmlParser::getStdStrAttribute(node, "reference", reference);
+    X3DXmlHelper::getStringArrayAttribute(node, "value", value);
+
+    MACRO_METADATA_FINDCREATE(node, def, use, reference, value, ne, X3DNodeElementMetaString, "MetadataString", ENET_MetaString);
+}
+
+}// namespace Assimp
+
+#endif // !ASSIMP_BUILD_NO_X3D_IMPORTER
diff --git a/Engine/lib/assimp/code/X3D/X3DImporter_Networking.cpp b/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Networking.cpp
similarity index 52%
rename from Engine/lib/assimp/code/X3D/X3DImporter_Networking.cpp
rename to Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Networking.cpp
index a7a200675..f2b471692 100644
--- a/Engine/lib/assimp/code/X3D/X3DImporter_Networking.cpp
+++ b/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Networking.cpp
@@ -41,21 +41,21 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 /// \file   X3DImporter_Networking.cpp
 /// \brief  Parsing data from nodes of "Networking" set of X3D.
-/// \date   2015-2016
-/// \author smal.root@gmail.com
+/// date   2015-2016
+/// author smal.root@gmail.com
 
 #ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
 
 #include "X3DImporter.hpp"
 #include "X3DImporter_Macro.hpp"
+#include "X3DXmlHelper.h"
 
 // Header files, Assimp.
 #include <assimp/DefaultIOSystem.h>
 
 //#include <regex>
 
-namespace Assimp
-{
+namespace Assimp {
 
 //static std::regex pattern_parentDir(R"((^|/)[^/]+/../)");
 static std::string parentDir("/../");
@@ -68,67 +68,57 @@ static std::string parentDir("/../");
 // load="true"         SFBool   [inputOutput]
 // url=""              MFString [inputOutput]
 // />
-void X3DImporter::ParseNode_Networking_Inline()
-{
+void X3DImporter::readInline(XmlNode &node) {
     std::string def, use;
     bool load = true;
     std::list<std::string> url;
 
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_RET("load", load, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_REF("url", url, XML_ReadNode_GetAttrVal_AsListS);
-	MACRO_ATTRREAD_LOOPEND;
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    XmlParser::getBoolAttribute(node, "load", load);
+    X3DXmlHelper::getStringListAttribute(node, "url", url);
 
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		CX3DImporter_NodeElement* ne;
+    // if "USE" defined then find already defined element.
+    X3DNodeElementBase *ne = nullptr;
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_Group, ne);
+    } else {
+        ParseHelper_Group_Begin(true); // create new grouping element and go deeper if node has children.
+        // at this place new group mode created and made current, so we can name it.
+        if (!def.empty()) mNodeElementCur->ID = def;
 
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_Group, ne);
-	}
-	else
-	{
-		ParseHelper_Group_Begin(true);// create new grouping element and go deeper if node has children.
-		// at this place new group mode created and made current, so we can name it.
-		if(!def.empty()) NodeElement_Cur->ID = def;
+        if (load && !url.empty()) {
+            std::string full_path = mpIOHandler->CurrentDirectory() + url.front();
 
-		if(load && !url.empty())
-		{
-			std::string full_path = mpIOHandler->CurrentDirectory() + url.front();
+            //full_path = std::regex_replace(full_path, pattern_parentDir, "$1");
+            for (std::string::size_type pos = full_path.find(parentDir); pos != std::string::npos; pos = full_path.find(parentDir, pos)) {
+                if (pos > 0) {
+                    std::string::size_type pos2 = full_path.rfind('/', pos - 1);
+                    if (pos2 != std::string::npos) {
+                        full_path.erase(pos2, pos - pos2 + 3);
+                        pos = pos2;
+                    } else {
+                        full_path.erase(0, pos + 4);
+                        pos = 0;
+                    }
+                } else {
+                    pos += 3;
+                }
+            }
+            // Attribute "url" can contain list of strings. But we need only one - first.
+            std::string::size_type slashPos = full_path.find_last_of("\\/");
+            mpIOHandler->PushDirectory(slashPos == std::string::npos ? std::string() : full_path.substr(0, slashPos + 1));
+            ParseFile(full_path, mpIOHandler);
+            mpIOHandler->PopDirectory();
+        }
 
-			//full_path = std::regex_replace(full_path, pattern_parentDir, "$1");
-			for (std::string::size_type pos = full_path.find(parentDir); pos != std::string::npos; pos = full_path.find(parentDir, pos)) {
-				if (pos > 0) {
-					std::string::size_type pos2 = full_path.rfind('/', pos - 1);
-					if (pos2 != std::string::npos) {
-						full_path.erase(pos2, pos - pos2 + 3);
-						pos = pos2;
-					}
-					else {
-						full_path.erase(0, pos + 4);
-						pos = 0;
-					}
-				}
-				else {
-					pos += 3;
-				}
-			}
-			// Attribute "url" can contain list of strings. But we need only one - first.
-			std::string::size_type slashPos = full_path.find_last_of("\\/");
-			mpIOHandler->PushDirectory(slashPos == std::string::npos ? std::string() : full_path.substr(0, slashPos + 1));
-			ParseFile(full_path, mpIOHandler);
-			mpIOHandler->PopDirectory();
-		}
+        // check for X3DMetadataObject childs.
+        if (!isNodeEmpty(node)) childrenReadMetadata(node, mNodeElementCur, "Inline");
 
-		// check for X3DMetadataObject childs.
-		if(!mReader->isEmptyElement()) ParseNode_Metadata(NodeElement_Cur, "Inline");
-
-		// exit from node in that place
-		ParseHelper_Node_Exit();
-	}// if(!use.empty()) else
+        // exit from node in that place
+        ParseHelper_Node_Exit();
+    } // if(!use.empty()) else
 }
 
-}// namespace Assimp
+} // namespace Assimp
 
 #endif // !ASSIMP_BUILD_NO_X3D_IMPORTER
diff --git a/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Node.hpp b/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Node.hpp
new file mode 100644
index 000000000..8d33c4b7a
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Node.hpp
@@ -0,0 +1,463 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2019, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+/// \file   X3DImporter_Node.hpp
+/// \brief  Elements of scene graph.
+/// \date   2015-2016
+/// \author smal.root@gmail.com
+
+#ifndef INCLUDED_AI_X3D_IMPORTER_NODE_H
+#define INCLUDED_AI_X3D_IMPORTER_NODE_H
+
+// Header files, Assimp.
+#include <assimp/types.h>
+
+#include <list>
+#include <vector>
+
+enum X3DElemType {
+    ENET_Group, ///< Element has type "Group".
+    ENET_MetaBoolean, ///< Element has type "Metadata boolean".
+    ENET_MetaDouble, ///< Element has type "Metadata double".
+    ENET_MetaFloat, ///< Element has type "Metadata float".
+    ENET_MetaInteger, ///< Element has type "Metadata integer".
+    ENET_MetaSet, ///< Element has type "Metadata set".
+    ENET_MetaString, ///< Element has type "Metadata string".
+    ENET_Arc2D, ///< Element has type "Arc2D".
+    ENET_ArcClose2D, ///< Element has type "ArcClose2D".
+    ENET_Circle2D, ///< Element has type "Circle2D".
+    ENET_Disk2D, ///< Element has type "Disk2D".
+    ENET_Polyline2D, ///< Element has type "Polyline2D".
+    ENET_Polypoint2D, ///< Element has type "Polypoint2D".
+    ENET_Rectangle2D, ///< Element has type "Rectangle2D".
+    ENET_TriangleSet2D, ///< Element has type "TriangleSet2D".
+    ENET_Box, ///< Element has type "Box".
+    ENET_Cone, ///< Element has type "Cone".
+    ENET_Cylinder, ///< Element has type "Cylinder".
+    ENET_Sphere, ///< Element has type "Sphere".
+    ENET_ElevationGrid, ///< Element has type "ElevationGrid".
+    ENET_Extrusion, ///< Element has type "Extrusion".
+    ENET_Coordinate, ///< Element has type "Coordinate".
+    ENET_Normal, ///< Element has type "Normal".
+    ENET_TextureCoordinate, ///< Element has type "TextureCoordinate".
+    ENET_IndexedFaceSet, ///< Element has type "IndexedFaceSet".
+    ENET_IndexedLineSet, ///< Element has type "IndexedLineSet".
+    ENET_IndexedTriangleSet, ///< Element has type "IndexedTriangleSet".
+    ENET_IndexedTriangleFanSet, ///< Element has type "IndexedTriangleFanSet".
+    ENET_IndexedTriangleStripSet, ///< Element has type "IndexedTriangleStripSet".
+    ENET_LineSet, ///< Element has type "LineSet".
+    ENET_PointSet, ///< Element has type "PointSet".
+    ENET_TriangleSet, ///< Element has type "TriangleSet".
+    ENET_TriangleFanSet, ///< Element has type "TriangleFanSet".
+    ENET_TriangleStripSet, ///< Element has type "TriangleStripSet".
+    ENET_Color, ///< Element has type "Color".
+    ENET_ColorRGBA, ///< Element has type "ColorRGBA".
+    ENET_Shape, ///< Element has type "Shape".
+    ENET_Appearance, ///< Element has type "Appearance".
+    ENET_Material, ///< Element has type "Material".
+    ENET_ImageTexture, ///< Element has type "ImageTexture".
+    ENET_TextureTransform, ///< Element has type "TextureTransform".
+    ENET_DirectionalLight, ///< Element has type "DirectionalLight".
+    ENET_PointLight, ///< Element has type "PointLight".
+    ENET_SpotLight, ///< Element has type "SpotLight".
+
+    ENET_Invalid ///< Element has invalid type and possible contain invalid data.
+};
+
+struct X3DNodeElementBase {
+    X3DNodeElementBase *Parent;
+    std::string ID;
+    std::list<X3DNodeElementBase *> Children;
+    X3DElemType Type;
+
+    virtual ~X3DNodeElementBase() {
+        // empty
+    }
+
+protected:
+    X3DNodeElementBase(X3DElemType type, X3DNodeElementBase *pParent) :
+            Parent(pParent), Type(type) {
+        // empty
+    }
+};
+
+/// This struct hold <Color> value.
+struct X3DNodeElementColor : X3DNodeElementBase {
+    std::list<aiColor3D> Value; ///< Stored value.
+
+    /// Constructor
+    /// \param [in] pParent - pointer to parent node.
+    X3DNodeElementColor(X3DNodeElementBase *pParent) :
+            X3DNodeElementBase(X3DElemType::ENET_Color, pParent) {}
+
+}; // struct X3DNodeElementColor
+
+/// This struct hold <ColorRGBA> value.
+struct X3DNodeElementColorRGBA : X3DNodeElementBase {
+    std::list<aiColor4D> Value; ///< Stored value.
+
+    /// Constructor
+    /// \param [in] pParent - pointer to parent node.
+    X3DNodeElementColorRGBA(X3DNodeElementBase *pParent) :
+            X3DNodeElementBase(X3DElemType::ENET_ColorRGBA, pParent) {}
+
+}; // struct X3DNodeElementColorRGBA
+
+/// This struct hold <Coordinate> value.
+struct X3DNodeElementCoordinate : public X3DNodeElementBase {
+    std::list<aiVector3D> Value; ///< Stored value.
+
+    /// Constructor
+    /// \param [in] pParent - pointer to parent node.
+    X3DNodeElementCoordinate(X3DNodeElementBase *pParent) :
+            X3DNodeElementBase(X3DElemType::ENET_Coordinate, pParent) {}
+
+}; // struct X3DNodeElementCoordinate
+
+/// This struct hold <Normal> value.
+struct X3DNodeElementNormal : X3DNodeElementBase {
+    std::list<aiVector3D> Value; ///< Stored value.
+
+    /// Constructor
+    /// \param [in] pParent - pointer to parent node.
+    X3DNodeElementNormal(X3DNodeElementBase *pParent) :
+            X3DNodeElementBase(X3DElemType::ENET_Normal, pParent) {}
+
+}; // struct X3DNodeElementNormal
+
+/// This struct hold <TextureCoordinate> value.
+struct X3DNodeElementTextureCoordinate : X3DNodeElementBase {
+    std::list<aiVector2D> Value; ///< Stored value.
+
+    /// Constructor
+    /// \param [in] pParent - pointer to parent node.
+    X3DNodeElementTextureCoordinate(X3DNodeElementBase *pParent) :
+            X3DNodeElementBase(X3DElemType::ENET_TextureCoordinate, pParent) {}
+
+}; // struct X3DNodeElementTextureCoordinate
+
+/// Two-dimensional figure.
+struct X3DNodeElementGeometry2D : X3DNodeElementBase {
+    std::list<aiVector3D> Vertices; ///< Vertices list.
+    size_t NumIndices; ///< Number of indices in one face.
+    bool Solid; ///< Flag: if true then render must use back-face culling, else render must draw both sides of object.
+
+    /// Constructor.
+    /// \param [in] pParent - pointer to parent node.
+    /// \param [in] pType - type of geometry object.
+    X3DNodeElementGeometry2D(X3DElemType pType, X3DNodeElementBase *pParent) :
+            X3DNodeElementBase(pType, pParent), Solid(true) {}
+
+}; // class X3DNodeElementGeometry2D
+
+/// Three-dimensional body.
+struct X3DNodeElementGeometry3D : X3DNodeElementBase {
+    std::list<aiVector3D> Vertices; ///< Vertices list.
+    size_t NumIndices; ///< Number of indices in one face.
+    bool Solid; ///< Flag: if true then render must use back-face culling, else render must draw both sides of object.
+
+    /// Constructor.
+    /// \param [in] pParent - pointer to parent node.
+    /// \param [in] pType - type of geometry object.
+    X3DNodeElementGeometry3D(X3DElemType pType, X3DNodeElementBase *pParent) :
+            X3DNodeElementBase(pType, pParent), Vertices(), NumIndices(0), Solid(true) {
+        // empty
+    }
+}; // class X3DNodeElementGeometry3D
+
+/// Uniform rectangular grid of varying height.
+struct X3DNodeElementElevationGrid : X3DNodeElementGeometry3D {
+    bool NormalPerVertex; ///< If true then normals are defined for every vertex, else for every face(line).
+    bool ColorPerVertex; ///< If true then colors are defined for every vertex, else for every face(line).
+    /// If the angle between the geometric normals of two adjacent faces is less than the crease angle, normals shall be calculated so that the faces are
+    /// shaded smoothly across the edge; otherwise, normals shall be calculated so that a lighting discontinuity across the edge is produced.
+    float CreaseAngle;
+    std::vector<int32_t> CoordIdx; ///< Coordinates list by faces. In X3D format: "-1" - delimiter for faces.
+
+    /// Constructor.
+    /// \param [in] pParent - pointer to parent node.
+    /// \param [in] pType - type of geometry object.
+    X3DNodeElementElevationGrid(X3DElemType pType, X3DNodeElementBase *pParent) :
+            X3DNodeElementGeometry3D(pType, pParent) {}
+}; // class X3DNodeElementIndexedSet
+
+/// Shape with indexed vertices.
+struct X3DNodeElementIndexedSet : public X3DNodeElementGeometry3D {
+    /// The ccw field defines the ordering of the vertex coordinates of the geometry with respect to user-given or automatically generated normal vectors
+    /// used in the lighting model equations. If ccw is TRUE, the normals shall follow the right hand rule; the orientation of each normal with respect to
+    /// the vertices (taken in order) shall be such that the vertices appear to be oriented in a counterclockwise order when the vertices are viewed (in the
+    /// local coordinate system of the Shape) from the opposite direction as the normal. If ccw is FALSE, the normals shall be oriented in the opposite
+    /// direction. If normals are not generated but are supplied using a Normal node, and the orientation of the normals does not match the setting of the
+    /// ccw field, results are undefined.
+    bool CCW;
+    std::vector<int32_t> ColorIndex; ///< Field to specify the polygonal faces by indexing into the <Color> or <ColorRGBA>.
+    bool ColorPerVertex; ///< If true then colors are defined for every vertex, else for every face(line).
+    /// The convex field indicates whether all polygons in the shape are convex (TRUE). A polygon is convex if it is planar, does not intersect itself,
+    /// and all of the interior angles at its vertices are less than 180 degrees. Non planar and self intersecting polygons may produce undefined results
+    /// even if the convex field is FALSE.
+    bool Convex;
+    std::vector<int32_t> CoordIndex; ///< Field to specify the polygonal faces by indexing into the <Coordinate>.
+    /// If the angle between the geometric normals of two adjacent faces is less than the crease angle, normals shall be calculated so that the faces are
+    /// shaded smoothly across the edge; otherwise, normals shall be calculated so that a lighting discontinuity across the edge is produced.
+    float CreaseAngle;
+    std::vector<int32_t> NormalIndex; ///< Field to specify the polygonal faces by indexing into the <Normal>.
+    bool NormalPerVertex; ///< If true then normals are defined for every vertex, else for every face(line).
+    std::vector<int32_t> TexCoordIndex; ///< Field to specify the polygonal faces by indexing into the <TextureCoordinate>.
+
+    /// Constructor.
+    /// \param [in] pParent - pointer to parent node.
+    /// \param [in] pType - type of geometry object.
+    X3DNodeElementIndexedSet(X3DElemType pType, X3DNodeElementBase *pParent) :
+            X3DNodeElementGeometry3D(pType, pParent) {}
+}; // class X3DNodeElementIndexedSet
+
+/// Shape with set of vertices.
+struct X3DNodeElementSet : X3DNodeElementGeometry3D {
+    /// The ccw field defines the ordering of the vertex coordinates of the geometry with respect to user-given or automatically generated normal vectors
+    /// used in the lighting model equations. If ccw is TRUE, the normals shall follow the right hand rule; the orientation of each normal with respect to
+    /// the vertices (taken in order) shall be such that the vertices appear to be oriented in a counterclockwise order when the vertices are viewed (in the
+    /// local coordinate system of the Shape) from the opposite direction as the normal. If ccw is FALSE, the normals shall be oriented in the opposite
+    /// direction. If normals are not generated but are supplied using a Normal node, and the orientation of the normals does not match the setting of the
+    /// ccw field, results are undefined.
+    bool CCW;
+    bool ColorPerVertex; ///< If true then colors are defined for every vertex, else for every face(line).
+    bool NormalPerVertex; ///< If true then normals are defined for every vertex, else for every face(line).
+    std::vector<int32_t> CoordIndex; ///< Field to specify the polygonal faces by indexing into the <Coordinate>.
+    std::vector<int32_t> NormalIndex; ///< Field to specify the polygonal faces by indexing into the <Normal>.
+    std::vector<int32_t> TexCoordIndex; ///< Field to specify the polygonal faces by indexing into the <TextureCoordinate>.
+    std::vector<int32_t> VertexCount; ///< Field describes how many vertices are to be used in each polyline(polygon) from the <Coordinate> field.
+
+    /// Constructor.
+    /// \param [in] pParent - pointer to parent node.
+    /// \param [in] pType - type of geometry object.
+    X3DNodeElementSet(X3DElemType type, X3DNodeElementBase *pParent) :
+            X3DNodeElementGeometry3D(type, pParent) {}
+
+}; // class X3DNodeElementSet
+
+/// This struct hold <Shape> value.
+struct X3DNodeElementShape : X3DNodeElementBase {
+
+    /// Constructor
+    /// \param [in] pParent - pointer to parent node.
+    X3DNodeElementShape(X3DNodeElementBase *pParent) :
+            X3DNodeElementBase(X3DElemType::ENET_Shape, pParent) {}
+}; // struct X3DNodeElementShape
+
+/// This struct hold <Appearance> value.
+struct X3DNodeElementAppearance : public X3DNodeElementBase {
+
+    /// Constructor
+    /// \param [in] pParent - pointer to parent node.
+    X3DNodeElementAppearance(X3DNodeElementBase *pParent) :
+            X3DNodeElementBase(X3DElemType::ENET_Appearance, pParent) {}
+
+}; // struct X3DNodeElementAppearance
+
+struct X3DNodeElementMaterial : public X3DNodeElementBase {
+    float AmbientIntensity; ///< Specifies how much ambient light from light sources this surface shall reflect.
+    aiColor3D DiffuseColor; ///< Reflects all X3D light sources depending on the angle of the surface with respect to the light source.
+    aiColor3D EmissiveColor; ///< Models "glowing" objects. This can be useful for displaying pre-lit models.
+    float Shininess; ///< Lower shininess values produce soft glows, while higher values result in sharper, smaller highlights.
+    aiColor3D SpecularColor; ///< The specularColor and shininess fields determine the specular highlights.
+    float Transparency; ///< Specifies how "clear" an object is, with 1.0 being completely transparent, and 0.0 completely opaque.
+
+    /// Constructor.
+    /// \param [in] pParent - pointer to parent node.
+    /// \param [in] pType - type of geometry object.
+    X3DNodeElementMaterial(X3DNodeElementBase *pParent) :
+            X3DNodeElementBase(X3DElemType::ENET_Material, pParent),
+            AmbientIntensity(0.0f),
+            DiffuseColor(),
+            EmissiveColor(),
+            Shininess(0.0f),
+            SpecularColor(),
+            Transparency(1.0f) {
+        // empty
+    }
+}; // class X3DNodeElementMaterial
+
+/// This struct hold <ImageTexture> value.
+struct X3DNodeElementImageTexture : X3DNodeElementBase {
+    /// RepeatS and RepeatT, that specify how the texture wraps in the S and T directions. If repeatS is TRUE (the default), the texture map is repeated
+    /// outside the [0.0, 1.0] texture coordinate range in the S direction so that it fills the shape. If repeatS is FALSE, the texture coordinates are
+    /// clamped in the S direction to lie within the [0.0, 1.0] range. The repeatT field is analogous to the repeatS field.
+    bool RepeatS;
+    bool RepeatT; ///< See \ref RepeatS.
+    std::string URL; ///< URL of the texture.
+
+    /// Constructor
+    /// \param [in] pParent - pointer to parent node.
+    X3DNodeElementImageTexture(X3DNodeElementBase *pParent) :
+            X3DNodeElementBase(X3DElemType::ENET_ImageTexture, pParent) {}
+
+}; // struct X3DNodeElementImageTexture
+
+/// This struct hold <TextureTransform> value.
+struct X3DNodeElementTextureTransform : X3DNodeElementBase {
+    aiVector2D Center; ///< Specifies a translation offset in texture coordinate space about which the rotation and scale fields are applied.
+    float Rotation; ///< Specifies a rotation in angle base units of the texture coordinates about the center point after the scale has been applied.
+    aiVector2D Scale; ///< Specifies a scaling factor in S and T of the texture coordinates about the center point.
+    aiVector2D Translation; ///<  Specifies a translation of the texture coordinates.
+
+    /// Constructor
+    /// \param [in] pParent - pointer to parent node.
+    X3DNodeElementTextureTransform(X3DNodeElementBase *pParent) :
+            X3DNodeElementBase(X3DElemType::ENET_TextureTransform, pParent) {}
+
+}; // struct X3DNodeElementTextureTransform
+
+struct X3DNodeElementGroup : X3DNodeElementBase {
+    aiMatrix4x4 Transformation; ///< Transformation matrix.
+
+    /// As you know node elements can use already defined node elements when attribute "USE" is defined.
+    /// Standard search when looking for an element in the whole scene graph, existing at this moment.
+    /// If a node is marked as static, the children(or lower) can not search for elements in the nodes upper then static.
+    bool Static;
+
+    bool UseChoice; ///< Flag: if true then use number from \ref Choice to choose what the child will be kept.
+    int32_t Choice; ///< Number of the child which will be kept.
+
+    /// Constructor.
+    /// \param [in] pParent - pointer to parent node.
+    /// \param [in] pStatic - static node flag.
+    X3DNodeElementGroup(X3DNodeElementBase *pParent, const bool pStatic = false) :
+            X3DNodeElementBase(X3DElemType::ENET_Group, pParent), Static(pStatic), UseChoice(false) {}
+};
+
+struct X3DNodeElementMeta : X3DNodeElementBase {
+    std::string Name; ///< Name of metadata object.
+    std::string Reference;
+
+    virtual ~X3DNodeElementMeta() {
+        // empty
+    }
+
+protected:
+    X3DNodeElementMeta(X3DElemType type, X3DNodeElementBase *parent) :
+            X3DNodeElementBase(type, parent) {
+        // empty
+    }
+};
+
+struct X3DNodeElementMetaBoolean : X3DNodeElementMeta {
+    std::vector<bool> Value; ///< Stored value.
+
+    explicit X3DNodeElementMetaBoolean(X3DNodeElementBase *pParent) :
+            X3DNodeElementMeta(X3DElemType::ENET_MetaBoolean, pParent) {
+        // empty
+    }
+};
+
+struct X3DNodeElementMetaDouble : X3DNodeElementMeta {
+    std::vector<double> Value; ///< Stored value.
+
+    explicit X3DNodeElementMetaDouble(X3DNodeElementBase *pParent) :
+            X3DNodeElementMeta(X3DElemType::ENET_MetaDouble, pParent) {
+        // empty
+    }
+};
+
+struct X3DNodeElementMetaFloat : public X3DNodeElementMeta {
+    std::vector<float> Value; ///< Stored value.
+
+    explicit X3DNodeElementMetaFloat(X3DNodeElementBase *pParent) :
+            X3DNodeElementMeta(X3DElemType::ENET_MetaFloat, pParent) {
+        // empty
+    }
+};
+
+struct X3DNodeElementMetaInt : public X3DNodeElementMeta {
+    std::vector<int32_t> Value; ///< Stored value.
+
+    explicit X3DNodeElementMetaInt(X3DNodeElementBase *pParent) :
+            X3DNodeElementMeta(X3DElemType::ENET_MetaInteger, pParent) {
+        // empty
+    }
+};
+
+struct X3DNodeElementMetaSet : public X3DNodeElementMeta {
+    std::list<X3DNodeElementMeta> Value; ///< Stored value.
+
+    explicit X3DNodeElementMetaSet(X3DNodeElementBase *pParent) :
+            X3DNodeElementMeta(X3DElemType::ENET_MetaSet, pParent) {
+        // empty
+    }
+};
+
+struct X3DNodeElementMetaString : X3DNodeElementMeta {
+    std::vector<std::string> Value; ///< Stored value.
+
+    explicit X3DNodeElementMetaString(X3DNodeElementBase *pParent) :
+            X3DNodeElementMeta(X3DElemType::ENET_MetaString, pParent) {
+        // empty
+    }
+};
+
+/// \struct X3DNodeElementLight
+/// This struct hold <TextureTransform> value.
+struct X3DNodeElementLight : X3DNodeElementBase {
+    float AmbientIntensity; ///< Specifies the intensity of the ambient emission from the light.
+    aiColor3D Color; ///< specifies the spectral colour properties of both the direct and ambient light emission as an RGB value.
+    aiVector3D Direction; ///< Specifies the direction vector of the illumination emanating from the light source in the local coordinate system.
+    /// \var Global
+    /// Field that determines whether the light is global or scoped. Global lights illuminate all objects that fall within their volume of lighting influence.
+    /// Scoped lights only illuminate objects that are in the same transformation hierarchy as the light.
+    bool Global;
+    float Intensity; ///< Specifies the brightness of the direct emission from the light.
+    /// \var Attenuation
+    /// PointLight node's illumination falls off with distance as specified by three attenuation coefficients. The attenuation factor
+    /// is: "1 / max(attenuation[0] + attenuation[1] * r + attenuation[2] * r2, 1)", where r is the distance from the light to the surface being illuminated.
+    aiVector3D Attenuation;
+    aiVector3D Location; ///< Specifies a translation offset of the centre point of the light source from the light's local coordinate system origin.
+    float Radius; ///< Specifies the radial extent of the solid angle and the maximum distance from location that may be illuminated by the light source.
+    float BeamWidth; ///< Specifies an inner solid angle in which the light source emits light at uniform full intensity.
+    float CutOffAngle; ///< The light source's emission intensity drops off from the inner solid angle (beamWidth) to the outer solid angle (cutOffAngle).
+
+    /// Constructor
+    /// \param [in] pParent - pointer to parent node.
+    /// \param [in] pLightType - type of the light source.
+    X3DNodeElementLight(X3DElemType pLightType, X3DNodeElementBase *pParent) :
+            X3DNodeElementBase(pLightType, pParent) {}
+
+}; // struct X3DNodeElementLight
+
+#endif // INCLUDED_AI_X3D_IMPORTER_NODE_H
diff --git a/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Postprocess.cpp b/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Postprocess.cpp
new file mode 100644
index 000000000..87121ef5f
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Postprocess.cpp
@@ -0,0 +1,731 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2019, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+/// \file   X3DImporter_Postprocess.cpp
+/// \brief  Convert built scenegraph and objects to Assimp scenegraph.
+/// \date   2015-2016
+/// \author smal.root@gmail.com
+
+#ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
+
+#include "X3DGeoHelper.h"
+#include "X3DImporter.hpp"
+
+// Header files, Assimp.
+#include <assimp/StandardShapes.h>
+#include <assimp/StringUtils.h>
+#include <assimp/ai_assert.h>
+
+// Header files, stdlib.
+#include <algorithm>
+#include <iterator>
+#include <string>
+
+namespace Assimp {
+
+aiMatrix4x4 X3DImporter::PostprocessHelper_Matrix_GlobalToCurrent() const {
+    X3DNodeElementBase *cur_node;
+    std::list<aiMatrix4x4> matr;
+    aiMatrix4x4 out_matr;
+
+    // starting walk from current element to root
+    cur_node = mNodeElementCur;
+    if (cur_node != nullptr) {
+        do {
+            // if cur_node is group then store group transformation matrix in list.
+            if (cur_node->Type == X3DElemType::ENET_Group) matr.push_back(((X3DNodeElementGroup *)cur_node)->Transformation);
+
+            cur_node = cur_node->Parent;
+        } while (cur_node != nullptr);
+    }
+
+    // multiplicate all matrices in reverse order
+    for (std::list<aiMatrix4x4>::reverse_iterator rit = matr.rbegin(); rit != matr.rend(); ++rit)
+        out_matr = out_matr * (*rit);
+
+    return out_matr;
+}
+
+void X3DImporter::PostprocessHelper_CollectMetadata(const X3DNodeElementBase &pNodeElement, std::list<X3DNodeElementBase *> &pList) const {
+    // walk through childs and find for metadata.
+    for (std::list<X3DNodeElementBase *>::const_iterator el_it = pNodeElement.Children.begin(); el_it != pNodeElement.Children.end(); ++el_it) {
+        if (((*el_it)->Type == X3DElemType::ENET_MetaBoolean) || ((*el_it)->Type == X3DElemType::ENET_MetaDouble) ||
+                ((*el_it)->Type == X3DElemType::ENET_MetaFloat) || ((*el_it)->Type == X3DElemType::ENET_MetaInteger) ||
+                ((*el_it)->Type == X3DElemType::ENET_MetaString)) {
+            pList.push_back(*el_it);
+        } else if ((*el_it)->Type == X3DElemType::ENET_MetaSet) {
+            PostprocessHelper_CollectMetadata(**el_it, pList);
+        }
+    } // for(std::list<X3DNodeElementBase*>::const_iterator el_it = pNodeElement.Children.begin(); el_it != pNodeElement.Children.end(); el_it++)
+}
+
+bool X3DImporter::PostprocessHelper_ElementIsMetadata(const X3DElemType pType) const {
+    if ((pType == X3DElemType::ENET_MetaBoolean) || (pType == X3DElemType::ENET_MetaDouble) ||
+            (pType == X3DElemType::ENET_MetaFloat) || (pType == X3DElemType::ENET_MetaInteger) ||
+            (pType == X3DElemType::ENET_MetaString) || (pType == X3DElemType::ENET_MetaSet)) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+bool X3DImporter::PostprocessHelper_ElementIsMesh(const X3DElemType pType) const {
+    if ((pType == X3DElemType::ENET_Arc2D) || (pType == X3DElemType::ENET_ArcClose2D) ||
+            (pType == X3DElemType::ENET_Box) || (pType == X3DElemType::ENET_Circle2D) ||
+            (pType == X3DElemType::ENET_Cone) || (pType == X3DElemType::ENET_Cylinder) ||
+            (pType == X3DElemType::ENET_Disk2D) || (pType == X3DElemType::ENET_ElevationGrid) ||
+            (pType == X3DElemType::ENET_Extrusion) || (pType == X3DElemType::ENET_IndexedFaceSet) ||
+            (pType == X3DElemType::ENET_IndexedLineSet) || (pType == X3DElemType::ENET_IndexedTriangleFanSet) ||
+            (pType == X3DElemType::ENET_IndexedTriangleSet) || (pType == X3DElemType::ENET_IndexedTriangleStripSet) ||
+            (pType == X3DElemType::ENET_PointSet) || (pType == X3DElemType::ENET_LineSet) ||
+            (pType == X3DElemType::ENET_Polyline2D) || (pType == X3DElemType::ENET_Polypoint2D) ||
+            (pType == X3DElemType::ENET_Rectangle2D) || (pType == X3DElemType::ENET_Sphere) ||
+            (pType == X3DElemType::ENET_TriangleFanSet) || (pType == X3DElemType::ENET_TriangleSet) ||
+            (pType == X3DElemType::ENET_TriangleSet2D) || (pType == X3DElemType::ENET_TriangleStripSet)) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+void X3DImporter::Postprocess_BuildLight(const X3DNodeElementBase &pNodeElement, std::list<aiLight *> &pSceneLightList) const {
+    const X3DNodeElementLight &ne = *((X3DNodeElementLight *)&pNodeElement);
+    aiMatrix4x4 transform_matr = PostprocessHelper_Matrix_GlobalToCurrent();
+    aiLight *new_light = new aiLight;
+
+    new_light->mName = ne.ID;
+    new_light->mColorAmbient = ne.Color * ne.AmbientIntensity;
+    new_light->mColorDiffuse = ne.Color * ne.Intensity;
+    new_light->mColorSpecular = ne.Color * ne.Intensity;
+    switch (pNodeElement.Type) {
+    case X3DElemType::ENET_DirectionalLight:
+        new_light->mType = aiLightSource_DIRECTIONAL;
+        new_light->mDirection = ne.Direction, new_light->mDirection *= transform_matr;
+
+        break;
+    case X3DElemType::ENET_PointLight:
+        new_light->mType = aiLightSource_POINT;
+        new_light->mPosition = ne.Location, new_light->mPosition *= transform_matr;
+        new_light->mAttenuationConstant = ne.Attenuation.x;
+        new_light->mAttenuationLinear = ne.Attenuation.y;
+        new_light->mAttenuationQuadratic = ne.Attenuation.z;
+
+        break;
+    case X3DElemType::ENET_SpotLight:
+        new_light->mType = aiLightSource_SPOT;
+        new_light->mPosition = ne.Location, new_light->mPosition *= transform_matr;
+        new_light->mDirection = ne.Direction, new_light->mDirection *= transform_matr;
+        new_light->mAttenuationConstant = ne.Attenuation.x;
+        new_light->mAttenuationLinear = ne.Attenuation.y;
+        new_light->mAttenuationQuadratic = ne.Attenuation.z;
+        new_light->mAngleInnerCone = ne.BeamWidth;
+        new_light->mAngleOuterCone = ne.CutOffAngle;
+
+        break;
+    default:
+        throw DeadlyImportError("Postprocess_BuildLight. Unknown type of light: " + ai_to_string(pNodeElement.Type) + ".");
+    }
+
+    pSceneLightList.push_back(new_light);
+}
+
+void X3DImporter::Postprocess_BuildMaterial(const X3DNodeElementBase &pNodeElement, aiMaterial **pMaterial) const {
+    // check argument
+    if (pMaterial == nullptr) throw DeadlyImportError("Postprocess_BuildMaterial. pMaterial is nullptr.");
+    if (*pMaterial != nullptr) throw DeadlyImportError("Postprocess_BuildMaterial. *pMaterial must be nullptr.");
+
+    *pMaterial = new aiMaterial;
+    aiMaterial &taimat = **pMaterial; // creating alias for convenience.
+
+    // at this point pNodeElement point to <Appearance> node. Walk through childs and add all stored data.
+    for (std::list<X3DNodeElementBase *>::const_iterator el_it = pNodeElement.Children.begin(); el_it != pNodeElement.Children.end(); ++el_it) {
+        if ((*el_it)->Type == X3DElemType::ENET_Material) {
+            aiColor3D tcol3;
+            float tvalf;
+            X3DNodeElementMaterial &tnemat = *((X3DNodeElementMaterial *)*el_it);
+
+            tcol3.r = tnemat.AmbientIntensity, tcol3.g = tnemat.AmbientIntensity, tcol3.b = tnemat.AmbientIntensity;
+            taimat.AddProperty(&tcol3, 1, AI_MATKEY_COLOR_AMBIENT);
+            taimat.AddProperty(&tnemat.DiffuseColor, 1, AI_MATKEY_COLOR_DIFFUSE);
+            taimat.AddProperty(&tnemat.EmissiveColor, 1, AI_MATKEY_COLOR_EMISSIVE);
+            taimat.AddProperty(&tnemat.SpecularColor, 1, AI_MATKEY_COLOR_SPECULAR);
+            tvalf = 1;
+            taimat.AddProperty(&tvalf, 1, AI_MATKEY_SHININESS_STRENGTH);
+            taimat.AddProperty(&tnemat.Shininess, 1, AI_MATKEY_SHININESS);
+            tvalf = 1.0f - tnemat.Transparency;
+            taimat.AddProperty(&tvalf, 1, AI_MATKEY_OPACITY);
+        } // if((*el_it)->Type == X3DElemType::ENET_Material)
+        else if ((*el_it)->Type == X3DElemType::ENET_ImageTexture) {
+            X3DNodeElementImageTexture &tnetex = *((X3DNodeElementImageTexture *)*el_it);
+            aiString url_str(tnetex.URL.c_str());
+            int mode = aiTextureOp_Multiply;
+
+            taimat.AddProperty(&url_str, AI_MATKEY_TEXTURE_DIFFUSE(0));
+            taimat.AddProperty(&tnetex.RepeatS, 1, AI_MATKEY_MAPPINGMODE_U_DIFFUSE(0));
+            taimat.AddProperty(&tnetex.RepeatT, 1, AI_MATKEY_MAPPINGMODE_V_DIFFUSE(0));
+            taimat.AddProperty(&mode, 1, AI_MATKEY_TEXOP_DIFFUSE(0));
+        } // else if((*el_it)->Type == X3DElemType::ENET_ImageTexture)
+        else if ((*el_it)->Type == X3DElemType::ENET_TextureTransform) {
+            aiUVTransform trans;
+            X3DNodeElementTextureTransform &tnetextr = *((X3DNodeElementTextureTransform *)*el_it);
+
+            trans.mTranslation = tnetextr.Translation - tnetextr.Center;
+            trans.mScaling = tnetextr.Scale;
+            trans.mRotation = tnetextr.Rotation;
+            taimat.AddProperty(&trans, 1, AI_MATKEY_UVTRANSFORM_DIFFUSE(0));
+        } // else if((*el_it)->Type == X3DElemType::ENET_TextureTransform)
+    } // for(std::list<X3DNodeElementBase*>::const_iterator el_it = pNodeElement.Children.begin(); el_it != pNodeElement.Children.end(); el_it++)
+}
+
+void X3DImporter::Postprocess_BuildMesh(const X3DNodeElementBase &pNodeElement, aiMesh **pMesh) const {
+    // check argument
+    if (pMesh == nullptr) throw DeadlyImportError("Postprocess_BuildMesh. pMesh is nullptr.");
+    if (*pMesh != nullptr) throw DeadlyImportError("Postprocess_BuildMesh. *pMesh must be nullptr.");
+
+    /************************************************************************************************************************************/
+    /************************************************************ Geometry2D ************************************************************/
+    /************************************************************************************************************************************/
+    if ((pNodeElement.Type == X3DElemType::ENET_Arc2D) || (pNodeElement.Type == X3DElemType::ENET_ArcClose2D) ||
+            (pNodeElement.Type == X3DElemType::ENET_Circle2D) || (pNodeElement.Type == X3DElemType::ENET_Disk2D) ||
+            (pNodeElement.Type == X3DElemType::ENET_Polyline2D) || (pNodeElement.Type == X3DElemType::ENET_Polypoint2D) ||
+            (pNodeElement.Type == X3DElemType::ENET_Rectangle2D) || (pNodeElement.Type == X3DElemType::ENET_TriangleSet2D)) {
+        X3DNodeElementGeometry2D &tnemesh = *((X3DNodeElementGeometry2D *)&pNodeElement); // create alias for convenience
+        std::vector<aiVector3D> tarr;
+
+        tarr.reserve(tnemesh.Vertices.size());
+        for (std::list<aiVector3D>::iterator it = tnemesh.Vertices.begin(); it != tnemesh.Vertices.end(); ++it)
+            tarr.push_back(*it);
+        *pMesh = StandardShapes::MakeMesh(tarr, static_cast<unsigned int>(tnemesh.NumIndices)); // create mesh from vertices using Assimp help.
+
+        return; // mesh is build, nothing to do anymore.
+    }
+    /************************************************************************************************************************************/
+    /************************************************************ Geometry3D ************************************************************/
+    /************************************************************************************************************************************/
+    //
+    // Predefined figures
+    //
+    if ((pNodeElement.Type == X3DElemType::ENET_Box) || (pNodeElement.Type == X3DElemType::ENET_Cone) ||
+            (pNodeElement.Type == X3DElemType::ENET_Cylinder) || (pNodeElement.Type == X3DElemType::ENET_Sphere)) {
+        X3DNodeElementGeometry3D &tnemesh = *((X3DNodeElementGeometry3D *)&pNodeElement); // create alias for convenience
+        std::vector<aiVector3D> tarr;
+
+        tarr.reserve(tnemesh.Vertices.size());
+        for (std::list<aiVector3D>::iterator it = tnemesh.Vertices.begin(); it != tnemesh.Vertices.end(); ++it)
+            tarr.push_back(*it);
+
+        *pMesh = StandardShapes::MakeMesh(tarr, static_cast<unsigned int>(tnemesh.NumIndices)); // create mesh from vertices using Assimp help.
+
+        return; // mesh is build, nothing to do anymore.
+    }
+    //
+    // Parametric figures
+    //
+    if (pNodeElement.Type == X3DElemType::ENET_ElevationGrid) {
+        X3DNodeElementElevationGrid &tnemesh = *((X3DNodeElementElevationGrid *)&pNodeElement); // create alias for convenience
+
+        // at first create mesh from existing vertices.
+        *pMesh = X3DGeoHelper::make_mesh(tnemesh.CoordIdx, tnemesh.Vertices);
+        // copy additional information from children
+        for (std::list<X3DNodeElementBase *>::iterator ch_it = tnemesh.Children.begin(); ch_it != tnemesh.Children.end(); ++ch_it) {
+            if ((*ch_it)->Type == X3DElemType::ENET_Color)
+                X3DGeoHelper::add_color(**pMesh, ((X3DNodeElementColor *)*ch_it)->Value, tnemesh.ColorPerVertex);
+            else if ((*ch_it)->Type == X3DElemType::ENET_ColorRGBA)
+                X3DGeoHelper::add_color(**pMesh, ((X3DNodeElementColorRGBA *)*ch_it)->Value, tnemesh.ColorPerVertex);
+            else if ((*ch_it)->Type == X3DElemType::ENET_Normal)
+                X3DGeoHelper::add_normal(**pMesh, ((X3DNodeElementNormal *)*ch_it)->Value, tnemesh.NormalPerVertex);
+            else if ((*ch_it)->Type == X3DElemType::ENET_TextureCoordinate)
+                X3DGeoHelper::add_tex_coord(**pMesh, ((X3DNodeElementTextureCoordinate *)*ch_it)->Value);
+            else
+                throw DeadlyImportError("Postprocess_BuildMesh. Unknown child of ElevationGrid: " + ai_to_string((*ch_it)->Type) + ".");
+        } // for(std::list<X3DNodeElementBase*>::iterator ch_it = tnemesh.Children.begin(); ch_it != tnemesh.Children.end(); ++ch_it)
+
+        return; // mesh is build, nothing to do anymore.
+    } // if(pNodeElement.Type == X3DElemType::ENET_ElevationGrid)
+    //
+    // Indexed primitives sets
+    //
+    if (pNodeElement.Type == X3DElemType::ENET_IndexedFaceSet) {
+        X3DNodeElementIndexedSet &tnemesh = *((X3DNodeElementIndexedSet *)&pNodeElement); // create alias for convenience
+
+        // at first search for <Coordinate> node and create mesh.
+        for (std::list<X3DNodeElementBase *>::iterator ch_it = tnemesh.Children.begin(); ch_it != tnemesh.Children.end(); ++ch_it) {
+            if ((*ch_it)->Type == X3DElemType::ENET_Coordinate) {
+                *pMesh = X3DGeoHelper::make_mesh(tnemesh.CoordIndex, ((X3DNodeElementCoordinate *)*ch_it)->Value);
+            }
+        }
+
+        // copy additional information from children
+        for (std::list<X3DNodeElementBase *>::iterator ch_it = tnemesh.Children.begin(); ch_it != tnemesh.Children.end(); ++ch_it) {
+            if ((*ch_it)->Type == X3DElemType::ENET_Color)
+                X3DGeoHelper::add_color(**pMesh, tnemesh.CoordIndex, tnemesh.ColorIndex, ((X3DNodeElementColor *)*ch_it)->Value, tnemesh.ColorPerVertex);
+            else if ((*ch_it)->Type == X3DElemType::ENET_ColorRGBA)
+                X3DGeoHelper::add_color(**pMesh, tnemesh.CoordIndex, tnemesh.ColorIndex, ((X3DNodeElementColorRGBA *)*ch_it)->Value,
+                        tnemesh.ColorPerVertex);
+            else if ((*ch_it)->Type == X3DElemType::ENET_Coordinate) {
+            } // skip because already read when mesh created.
+            else if ((*ch_it)->Type == X3DElemType::ENET_Normal)
+                X3DGeoHelper::add_normal(**pMesh, tnemesh.CoordIndex, tnemesh.NormalIndex, ((X3DNodeElementNormal *)*ch_it)->Value,
+                        tnemesh.NormalPerVertex);
+            else if ((*ch_it)->Type == X3DElemType::ENET_TextureCoordinate)
+                X3DGeoHelper::add_tex_coord(**pMesh, tnemesh.CoordIndex, tnemesh.TexCoordIndex, ((X3DNodeElementTextureCoordinate *)*ch_it)->Value);
+            else
+                throw DeadlyImportError("Postprocess_BuildMesh. Unknown child of IndexedFaceSet: " + ai_to_string((*ch_it)->Type) + ".");
+        } // for(std::list<X3DNodeElementBase*>::iterator ch_it = tnemesh.Children.begin(); ch_it != tnemesh.Children.end(); ++ch_it)
+
+        return; // mesh is build, nothing to do anymore.
+    } // if(pNodeElement.Type == X3DElemType::ENET_IndexedFaceSet)
+
+    if (pNodeElement.Type == X3DElemType::ENET_IndexedLineSet) {
+        X3DNodeElementIndexedSet &tnemesh = *((X3DNodeElementIndexedSet *)&pNodeElement); // create alias for convenience
+
+        // at first search for <Coordinate> node and create mesh.
+        for (std::list<X3DNodeElementBase *>::iterator ch_it = tnemesh.Children.begin(); ch_it != tnemesh.Children.end(); ++ch_it) {
+            if ((*ch_it)->Type == X3DElemType::ENET_Coordinate) {
+                *pMesh = X3DGeoHelper::make_mesh(tnemesh.CoordIndex, ((X3DNodeElementCoordinate *)*ch_it)->Value);
+            }
+        }
+
+        // copy additional information from children
+        for (std::list<X3DNodeElementBase *>::iterator ch_it = tnemesh.Children.begin(); ch_it != tnemesh.Children.end(); ++ch_it) {
+            ai_assert(*pMesh);
+            if ((*ch_it)->Type == X3DElemType::ENET_Color)
+                X3DGeoHelper::add_color(**pMesh, tnemesh.CoordIndex, tnemesh.ColorIndex, ((X3DNodeElementColor *)*ch_it)->Value, tnemesh.ColorPerVertex);
+            else if ((*ch_it)->Type == X3DElemType::ENET_ColorRGBA)
+                X3DGeoHelper::add_color(**pMesh, tnemesh.CoordIndex, tnemesh.ColorIndex, ((X3DNodeElementColorRGBA *)*ch_it)->Value,
+                        tnemesh.ColorPerVertex);
+            else if ((*ch_it)->Type == X3DElemType::ENET_Coordinate) {
+            } // skip because already read when mesh created.
+            else
+                throw DeadlyImportError("Postprocess_BuildMesh. Unknown child of IndexedLineSet: " + ai_to_string((*ch_it)->Type) + ".");
+        } // for(std::list<X3DNodeElementBase*>::iterator ch_it = tnemesh.Children.begin(); ch_it != tnemesh.Children.end(); ++ch_it)
+
+        return; // mesh is build, nothing to do anymore.
+    } // if(pNodeElement.Type == X3DElemType::ENET_IndexedLineSet)
+
+    if ((pNodeElement.Type == X3DElemType::ENET_IndexedTriangleSet) ||
+            (pNodeElement.Type == X3DElemType::ENET_IndexedTriangleFanSet) ||
+            (pNodeElement.Type == X3DElemType::ENET_IndexedTriangleStripSet)) {
+        X3DNodeElementIndexedSet &tnemesh = *((X3DNodeElementIndexedSet *)&pNodeElement); // create alias for convenience
+
+        // at first search for <Coordinate> node and create mesh.
+        for (std::list<X3DNodeElementBase *>::iterator ch_it = tnemesh.Children.begin(); ch_it != tnemesh.Children.end(); ++ch_it) {
+            if ((*ch_it)->Type == X3DElemType::ENET_Coordinate) {
+                *pMesh = X3DGeoHelper::make_mesh(tnemesh.CoordIndex, ((X3DNodeElementCoordinate *)*ch_it)->Value);
+            }
+        }
+
+        // copy additional information from children
+        for (std::list<X3DNodeElementBase *>::iterator ch_it = tnemesh.Children.begin(); ch_it != tnemesh.Children.end(); ++ch_it) {
+            ai_assert(*pMesh);
+            if ((*ch_it)->Type == X3DElemType::ENET_Color)
+                X3DGeoHelper::add_color(**pMesh, tnemesh.CoordIndex, tnemesh.ColorIndex, ((X3DNodeElementColor *)*ch_it)->Value, tnemesh.ColorPerVertex);
+            else if ((*ch_it)->Type == X3DElemType::ENET_ColorRGBA)
+                X3DGeoHelper::add_color(**pMesh, tnemesh.CoordIndex, tnemesh.ColorIndex, ((X3DNodeElementColorRGBA *)*ch_it)->Value,
+                        tnemesh.ColorPerVertex);
+            else if ((*ch_it)->Type == X3DElemType::ENET_Coordinate) {
+            } // skip because already read when mesh created.
+            else if ((*ch_it)->Type == X3DElemType::ENET_Normal)
+                X3DGeoHelper::add_normal(**pMesh, tnemesh.CoordIndex, tnemesh.NormalIndex, ((X3DNodeElementNormal *)*ch_it)->Value,
+                        tnemesh.NormalPerVertex);
+            else if ((*ch_it)->Type == X3DElemType::ENET_TextureCoordinate)
+                X3DGeoHelper::add_tex_coord(**pMesh, tnemesh.CoordIndex, tnemesh.TexCoordIndex, ((X3DNodeElementTextureCoordinate *)*ch_it)->Value);
+            else
+                throw DeadlyImportError("Postprocess_BuildMesh. Unknown child of IndexedTriangleSet or IndexedTriangleFanSet, or \
+                                                                    IndexedTriangleStripSet: " +
+                                        ai_to_string((*ch_it)->Type) + ".");
+        } // for(std::list<X3DNodeElementBase*>::iterator ch_it = tnemesh.Children.begin(); ch_it != tnemesh.Children.end(); ++ch_it)
+
+        return; // mesh is build, nothing to do anymore.
+    } // if((pNodeElement.Type == X3DElemType::ENET_IndexedTriangleFanSet) || (pNodeElement.Type == X3DElemType::ENET_IndexedTriangleStripSet))
+
+    if (pNodeElement.Type == X3DElemType::ENET_Extrusion) {
+        X3DNodeElementIndexedSet &tnemesh = *((X3DNodeElementIndexedSet *)&pNodeElement); // create alias for convenience
+
+        *pMesh = X3DGeoHelper::make_mesh(tnemesh.CoordIndex, tnemesh.Vertices);
+
+        return; // mesh is build, nothing to do anymore.
+    } // if(pNodeElement.Type == X3DElemType::ENET_Extrusion)
+
+    //
+    // Primitives sets
+    //
+    if (pNodeElement.Type == X3DElemType::ENET_PointSet) {
+        X3DNodeElementSet &tnemesh = *((X3DNodeElementSet *)&pNodeElement); // create alias for convenience
+
+        // at first search for <Coordinate> node and create mesh.
+        for (std::list<X3DNodeElementBase *>::iterator ch_it = tnemesh.Children.begin(); ch_it != tnemesh.Children.end(); ++ch_it) {
+            if ((*ch_it)->Type == X3DElemType::ENET_Coordinate) {
+                std::vector<aiVector3D> vec_copy;
+
+                vec_copy.reserve(((X3DNodeElementCoordinate *)*ch_it)->Value.size());
+                for (std::list<aiVector3D>::const_iterator it = ((X3DNodeElementCoordinate *)*ch_it)->Value.begin();
+                        it != ((X3DNodeElementCoordinate *)*ch_it)->Value.end(); ++it) {
+                    vec_copy.push_back(*it);
+                }
+
+                *pMesh = StandardShapes::MakeMesh(vec_copy, 1);
+            }
+        }
+
+        // copy additional information from children
+        for (std::list<X3DNodeElementBase *>::iterator ch_it = tnemesh.Children.begin(); ch_it != tnemesh.Children.end(); ++ch_it) {
+            ai_assert(*pMesh);
+            if ((*ch_it)->Type == X3DElemType::ENET_Color)
+                X3DGeoHelper::add_color(**pMesh, ((X3DNodeElementColor *)*ch_it)->Value, true);
+            else if ((*ch_it)->Type == X3DElemType::ENET_ColorRGBA)
+                X3DGeoHelper::add_color(**pMesh, ((X3DNodeElementColorRGBA *)*ch_it)->Value, true);
+            else if ((*ch_it)->Type == X3DElemType::ENET_Coordinate) {
+            } // skip because already read when mesh created.
+            else
+                throw DeadlyImportError("Postprocess_BuildMesh. Unknown child of PointSet: " + ai_to_string((*ch_it)->Type) + ".");
+        } // for(std::list<X3DNodeElementBase*>::iterator ch_it = tnemesh.Children.begin(); ch_it != tnemesh.Children.end(); ++ch_it)
+
+        return; // mesh is build, nothing to do anymore.
+    } // if(pNodeElement.Type == X3DElemType::ENET_PointSet)
+
+    if (pNodeElement.Type == X3DElemType::ENET_LineSet) {
+        X3DNodeElementSet &tnemesh = *((X3DNodeElementSet *)&pNodeElement); // create alias for convenience
+
+        // at first search for <Coordinate> node and create mesh.
+        for (std::list<X3DNodeElementBase *>::iterator ch_it = tnemesh.Children.begin(); ch_it != tnemesh.Children.end(); ++ch_it) {
+            if ((*ch_it)->Type == X3DElemType::ENET_Coordinate) {
+                *pMesh = X3DGeoHelper::make_mesh(tnemesh.CoordIndex, ((X3DNodeElementCoordinate *)*ch_it)->Value);
+            }
+        }
+
+        // copy additional information from children
+        for (std::list<X3DNodeElementBase *>::iterator ch_it = tnemesh.Children.begin(); ch_it != tnemesh.Children.end(); ++ch_it) {
+            ai_assert(*pMesh);
+            if ((*ch_it)->Type == X3DElemType::ENET_Color)
+                X3DGeoHelper::add_color(**pMesh, ((X3DNodeElementColor *)*ch_it)->Value, true);
+            else if ((*ch_it)->Type == X3DElemType::ENET_ColorRGBA)
+                X3DGeoHelper::add_color(**pMesh, ((X3DNodeElementColorRGBA *)*ch_it)->Value, true);
+            else if ((*ch_it)->Type == X3DElemType::ENET_Coordinate) {
+            } // skip because already read when mesh created.
+            else
+                throw DeadlyImportError("Postprocess_BuildMesh. Unknown child of LineSet: " + ai_to_string((*ch_it)->Type) + ".");
+        } // for(std::list<X3DNodeElementBase*>::iterator ch_it = tnemesh.Children.begin(); ch_it != tnemesh.Children.end(); ++ch_it)
+
+        return; // mesh is build, nothing to do anymore.
+    } // if(pNodeElement.Type == X3DElemType::ENET_LineSet)
+
+    if (pNodeElement.Type == X3DElemType::ENET_TriangleFanSet) {
+        X3DNodeElementSet &tnemesh = *((X3DNodeElementSet *)&pNodeElement); // create alias for convenience
+
+        // at first search for <Coordinate> node and create mesh.
+        for (std::list<X3DNodeElementBase *>::iterator ch_it = tnemesh.Children.begin(); ch_it != tnemesh.Children.end(); ++ch_it) {
+            if ((*ch_it)->Type == X3DElemType::ENET_Coordinate) {
+                *pMesh = X3DGeoHelper::make_mesh(tnemesh.CoordIndex, ((X3DNodeElementCoordinate *)*ch_it)->Value);
+            }
+        }
+
+        // copy additional information from children
+        for (std::list<X3DNodeElementBase *>::iterator ch_it = tnemesh.Children.begin(); ch_it != tnemesh.Children.end(); ++ch_it) {
+            if (nullptr == *pMesh) {
+                break;
+            }
+            if ((*ch_it)->Type == X3DElemType::ENET_Color)
+                X3DGeoHelper::add_color(**pMesh, ((X3DNodeElementColor *)*ch_it)->Value, tnemesh.ColorPerVertex);
+            else if ((*ch_it)->Type == X3DElemType::ENET_ColorRGBA)
+                X3DGeoHelper::add_color(**pMesh, ((X3DNodeElementColorRGBA *)*ch_it)->Value, tnemesh.ColorPerVertex);
+            else if ((*ch_it)->Type == X3DElemType::ENET_Coordinate) {
+            } // skip because already read when mesh created.
+            else if ((*ch_it)->Type == X3DElemType::ENET_Normal)
+                X3DGeoHelper::add_normal(**pMesh, tnemesh.CoordIndex, tnemesh.NormalIndex, ((X3DNodeElementNormal *)*ch_it)->Value,
+                        tnemesh.NormalPerVertex);
+            else if ((*ch_it)->Type == X3DElemType::ENET_TextureCoordinate)
+                X3DGeoHelper::add_tex_coord(**pMesh, tnemesh.CoordIndex, tnemesh.TexCoordIndex, ((X3DNodeElementTextureCoordinate *)*ch_it)->Value);
+            else
+                throw DeadlyImportError("Postprocess_BuildMesh. Unknown child of TrianlgeFanSet: " + ai_to_string((*ch_it)->Type) + ".");
+        } // for(std::list<X3DNodeElementBase*>::iterator ch_it = tnemesh.Children.begin(); ch_it != tnemesh.Children.end(); ++ch_it)
+
+        return; // mesh is build, nothing to do anymore.
+    } // if(pNodeElement.Type == X3DElemType::ENET_TriangleFanSet)
+
+    if (pNodeElement.Type == X3DElemType::ENET_TriangleSet) {
+        X3DNodeElementSet &tnemesh = *((X3DNodeElementSet *)&pNodeElement); // create alias for convenience
+
+        // at first search for <Coordinate> node and create mesh.
+        for (std::list<X3DNodeElementBase *>::iterator ch_it = tnemesh.Children.begin(); ch_it != tnemesh.Children.end(); ++ch_it) {
+            if ((*ch_it)->Type == X3DElemType::ENET_Coordinate) {
+                std::vector<aiVector3D> vec_copy;
+
+                vec_copy.reserve(((X3DNodeElementCoordinate *)*ch_it)->Value.size());
+                for (std::list<aiVector3D>::const_iterator it = ((X3DNodeElementCoordinate *)*ch_it)->Value.begin();
+                        it != ((X3DNodeElementCoordinate *)*ch_it)->Value.end(); ++it) {
+                    vec_copy.push_back(*it);
+                }
+
+                *pMesh = StandardShapes::MakeMesh(vec_copy, 3);
+            }
+        }
+
+        // copy additional information from children
+        for (std::list<X3DNodeElementBase *>::iterator ch_it = tnemesh.Children.begin(); ch_it != tnemesh.Children.end(); ++ch_it) {
+            ai_assert(*pMesh);
+            if ((*ch_it)->Type == X3DElemType::ENET_Color)
+                X3DGeoHelper::add_color(**pMesh, ((X3DNodeElementColor *)*ch_it)->Value, tnemesh.ColorPerVertex);
+            else if ((*ch_it)->Type == X3DElemType::ENET_ColorRGBA)
+                X3DGeoHelper::add_color(**pMesh, ((X3DNodeElementColorRGBA *)*ch_it)->Value, tnemesh.ColorPerVertex);
+            else if ((*ch_it)->Type == X3DElemType::ENET_Coordinate) {
+            } // skip because already read when mesh created.
+            else if ((*ch_it)->Type == X3DElemType::ENET_Normal)
+                X3DGeoHelper::add_normal(**pMesh, tnemesh.CoordIndex, tnemesh.NormalIndex, ((X3DNodeElementNormal *)*ch_it)->Value,
+                        tnemesh.NormalPerVertex);
+            else if ((*ch_it)->Type == X3DElemType::ENET_TextureCoordinate)
+                X3DGeoHelper::add_tex_coord(**pMesh, tnemesh.CoordIndex, tnemesh.TexCoordIndex, ((X3DNodeElementTextureCoordinate *)*ch_it)->Value);
+            else
+                throw DeadlyImportError("Postprocess_BuildMesh. Unknown child of TrianlgeSet: " + ai_to_string((*ch_it)->Type) + ".");
+        } // for(std::list<X3DNodeElementBase*>::iterator ch_it = tnemesh.Children.begin(); ch_it != tnemesh.Children.end(); ++ch_it)
+
+        return; // mesh is build, nothing to do anymore.
+    } // if(pNodeElement.Type == X3DElemType::ENET_TriangleSet)
+
+    if (pNodeElement.Type == X3DElemType::ENET_TriangleStripSet) {
+        X3DNodeElementSet &tnemesh = *((X3DNodeElementSet *)&pNodeElement); // create alias for convenience
+
+        // at first search for <Coordinate> node and create mesh.
+        for (std::list<X3DNodeElementBase *>::iterator ch_it = tnemesh.Children.begin(); ch_it != tnemesh.Children.end(); ++ch_it) {
+            if ((*ch_it)->Type == X3DElemType::ENET_Coordinate) {
+                *pMesh = X3DGeoHelper::make_mesh(tnemesh.CoordIndex, ((X3DNodeElementCoordinate *)*ch_it)->Value);
+            }
+        }
+
+        // copy additional information from children
+        for (std::list<X3DNodeElementBase *>::iterator ch_it = tnemesh.Children.begin(); ch_it != tnemesh.Children.end(); ++ch_it) {
+            ai_assert(*pMesh);
+            if ((*ch_it)->Type == X3DElemType::ENET_Color)
+                X3DGeoHelper::add_color(**pMesh, ((X3DNodeElementColor *)*ch_it)->Value, tnemesh.ColorPerVertex);
+            else if ((*ch_it)->Type == X3DElemType::ENET_ColorRGBA)
+                X3DGeoHelper::add_color(**pMesh, ((X3DNodeElementColorRGBA *)*ch_it)->Value, tnemesh.ColorPerVertex);
+            else if ((*ch_it)->Type == X3DElemType::ENET_Coordinate) {
+            } // skip because already read when mesh created.
+            else if ((*ch_it)->Type == X3DElemType::ENET_Normal)
+                X3DGeoHelper::add_normal(**pMesh, tnemesh.CoordIndex, tnemesh.NormalIndex, ((X3DNodeElementNormal *)*ch_it)->Value,
+                        tnemesh.NormalPerVertex);
+            else if ((*ch_it)->Type == X3DElemType::ENET_TextureCoordinate)
+                X3DGeoHelper::add_tex_coord(**pMesh, tnemesh.CoordIndex, tnemesh.TexCoordIndex, ((X3DNodeElementTextureCoordinate *)*ch_it)->Value);
+            else
+                throw DeadlyImportError("Postprocess_BuildMesh. Unknown child of TriangleStripSet: " + ai_to_string((*ch_it)->Type) + ".");
+        } // for(std::list<X3DNodeElementBase*>::iterator ch_it = tnemesh.Children.begin(); ch_it != tnemesh.Children.end(); ++ch_it)
+
+        return; // mesh is build, nothing to do anymore.
+    } // if(pNodeElement.Type == X3DElemType::ENET_TriangleStripSet)
+
+    throw DeadlyImportError("Postprocess_BuildMesh. Unknown mesh type: " + ai_to_string(pNodeElement.Type) + ".");
+}
+
+void X3DImporter::Postprocess_BuildNode(const X3DNodeElementBase &pNodeElement, aiNode &pSceneNode, std::list<aiMesh *> &pSceneMeshList,
+        std::list<aiMaterial *> &pSceneMaterialList, std::list<aiLight *> &pSceneLightList) const {
+    std::list<X3DNodeElementBase *>::const_iterator chit_begin = pNodeElement.Children.begin();
+    std::list<X3DNodeElementBase *>::const_iterator chit_end = pNodeElement.Children.end();
+    std::list<aiNode *> SceneNode_Child;
+    std::list<unsigned int> SceneNode_Mesh;
+
+    // At first read all metadata
+    Postprocess_CollectMetadata(pNodeElement, pSceneNode);
+    // check if we have deal with grouping node. Which can contain transformation or switch
+    if (pNodeElement.Type == X3DElemType::ENET_Group) {
+        const X3DNodeElementGroup &tne_group = *((X3DNodeElementGroup *)&pNodeElement); // create alias for convenience
+
+        pSceneNode.mTransformation = tne_group.Transformation;
+        if (tne_group.UseChoice) {
+            // If Choice is less than zero or greater than the number of nodes in the children field, nothing is chosen.
+            if ((tne_group.Choice < 0) || ((size_t)tne_group.Choice >= pNodeElement.Children.size())) {
+                chit_begin = pNodeElement.Children.end();
+                chit_end = pNodeElement.Children.end();
+            } else {
+                for (size_t i = 0; i < (size_t)tne_group.Choice; i++)
+                    ++chit_begin; // forward iterator to chosen node.
+
+                chit_end = chit_begin;
+                ++chit_end; // point end iterator to next element after chosen node.
+            }
+        } // if(tne_group.UseChoice)
+    } // if(pNodeElement.Type == X3DElemType::ENET_Group)
+
+    // Reserve memory for fast access and check children.
+    for (std::list<X3DNodeElementBase *>::const_iterator it = chit_begin; it != chit_end; ++it) { // in this loop we do not read metadata because it's already read at begin.
+        if ((*it)->Type == X3DElemType::ENET_Group) {
+            // if child is group then create new node and do recursive call.
+            aiNode *new_node = new aiNode;
+
+            new_node->mName = (*it)->ID;
+            new_node->mParent = &pSceneNode;
+            SceneNode_Child.push_back(new_node);
+            Postprocess_BuildNode(**it, *new_node, pSceneMeshList, pSceneMaterialList, pSceneLightList);
+        } else if ((*it)->Type == X3DElemType::ENET_Shape) {
+            // shape can contain only one geometry and one appearance nodes.
+            Postprocess_BuildShape(*((X3DNodeElementShape *)*it), SceneNode_Mesh, pSceneMeshList, pSceneMaterialList);
+        } else if (((*it)->Type == X3DElemType::ENET_DirectionalLight) || ((*it)->Type == X3DElemType::ENET_PointLight) ||
+                   ((*it)->Type == X3DElemType::ENET_SpotLight)) {
+            Postprocess_BuildLight(*((X3DNodeElementLight *)*it), pSceneLightList);
+        } else if (!PostprocessHelper_ElementIsMetadata((*it)->Type)) // skip metadata
+        {
+            throw DeadlyImportError("Postprocess_BuildNode. Unknown type: " + ai_to_string((*it)->Type) + ".");
+        }
+    } // for(std::list<X3DNodeElementBase*>::const_iterator it = chit_begin; it != chit_end; it++)
+
+    // copy data about children and meshes to aiNode.
+    if (!SceneNode_Child.empty()) {
+        std::list<aiNode *>::const_iterator it = SceneNode_Child.begin();
+
+        pSceneNode.mNumChildren = static_cast<unsigned int>(SceneNode_Child.size());
+        pSceneNode.mChildren = new aiNode *[pSceneNode.mNumChildren];
+        for (size_t i = 0; i < pSceneNode.mNumChildren; i++)
+            pSceneNode.mChildren[i] = *it++;
+    }
+
+    if (!SceneNode_Mesh.empty()) {
+        std::list<unsigned int>::const_iterator it = SceneNode_Mesh.begin();
+
+        pSceneNode.mNumMeshes = static_cast<unsigned int>(SceneNode_Mesh.size());
+        pSceneNode.mMeshes = new unsigned int[pSceneNode.mNumMeshes];
+        for (size_t i = 0; i < pSceneNode.mNumMeshes; i++)
+            pSceneNode.mMeshes[i] = *it++;
+    }
+
+    // that's all. return to previous deals
+}
+
+void X3DImporter::Postprocess_BuildShape(const X3DNodeElementShape &pShapeNodeElement, std::list<unsigned int> &pNodeMeshInd,
+        std::list<aiMesh *> &pSceneMeshList, std::list<aiMaterial *> &pSceneMaterialList) const {
+    aiMaterial *tmat = nullptr;
+    aiMesh *tmesh = nullptr;
+    X3DElemType mesh_type = X3DElemType::ENET_Invalid;
+    unsigned int mat_ind = 0;
+
+    for (std::list<X3DNodeElementBase *>::const_iterator it = pShapeNodeElement.Children.begin(); it != pShapeNodeElement.Children.end(); ++it) {
+        if (PostprocessHelper_ElementIsMesh((*it)->Type)) {
+            Postprocess_BuildMesh(**it, &tmesh);
+            if (tmesh != nullptr) {
+                // if mesh successfully built then add data about it to arrays
+                pNodeMeshInd.push_back(static_cast<unsigned int>(pSceneMeshList.size()));
+                pSceneMeshList.push_back(tmesh);
+                // keep mesh type. Need above for texture coordinate generation.
+                mesh_type = (*it)->Type;
+            }
+        } else if ((*it)->Type == X3DElemType::ENET_Appearance) {
+            Postprocess_BuildMaterial(**it, &tmat);
+            if (tmat != nullptr) {
+                // if material successfully built then add data about it to array
+                mat_ind = static_cast<unsigned int>(pSceneMaterialList.size());
+                pSceneMaterialList.push_back(tmat);
+            }
+        }
+    } // for(std::list<X3DNodeElementBase*>::const_iterator it = pShapeNodeElement.Children.begin(); it != pShapeNodeElement.Children.end(); it++)
+
+    // associate read material with read mesh.
+    if ((tmesh != nullptr) && (tmat != nullptr)) {
+        tmesh->mMaterialIndex = mat_ind;
+        // Check texture mapping. If material has texture but mesh has no texture coordinate then try to ask Assimp to generate texture coordinates.
+        if ((tmat->GetTextureCount(aiTextureType_DIFFUSE) != 0) && !tmesh->HasTextureCoords(0)) {
+            int32_t tm;
+            aiVector3D tvec3;
+
+            switch (mesh_type) {
+            case X3DElemType::ENET_Box:
+                tm = aiTextureMapping_BOX;
+                break;
+            case X3DElemType::ENET_Cone:
+            case X3DElemType::ENET_Cylinder:
+                tm = aiTextureMapping_CYLINDER;
+                break;
+            case X3DElemType::ENET_Sphere:
+                tm = aiTextureMapping_SPHERE;
+                break;
+            default:
+                tm = aiTextureMapping_PLANE;
+                break;
+            } // switch(mesh_type)
+
+            tmat->AddProperty(&tm, 1, AI_MATKEY_MAPPING_DIFFUSE(0));
+        } // if((tmat->GetTextureCount(aiTextureType_DIFFUSE) != 0) && !tmesh->HasTextureCoords(0))
+    } // if((tmesh != nullptr) && (tmat != nullptr))
+}
+
+void X3DImporter::Postprocess_CollectMetadata(const X3DNodeElementBase &pNodeElement, aiNode &pSceneNode) const {
+    std::list<X3DNodeElementBase *> meta_list;
+    size_t meta_idx;
+
+    PostprocessHelper_CollectMetadata(pNodeElement, meta_list); // find metadata in current node element.
+    if (!meta_list.empty()) {
+        if (pSceneNode.mMetaData != nullptr) {
+            throw DeadlyImportError("Postprocess. MetaData member in node are not nullptr. Something went wrong.");
+        }
+
+        // copy collected metadata to output node.
+        pSceneNode.mMetaData = aiMetadata::Alloc(static_cast<unsigned int>(meta_list.size()));
+        meta_idx = 0;
+        for (std::list<X3DNodeElementBase *>::const_iterator it = meta_list.begin(); it != meta_list.end(); ++it, ++meta_idx) {
+            X3DNodeElementMeta *cur_meta = (X3DNodeElementMeta *)*it;
+
+            // due to limitations we can add only first element of value list.
+            // Add an element according to its type.
+            if ((*it)->Type == X3DElemType::ENET_MetaBoolean) {
+                if (((X3DNodeElementMetaBoolean *)cur_meta)->Value.size() > 0)
+                    pSceneNode.mMetaData->Set(static_cast<unsigned int>(meta_idx), cur_meta->Name, *(((X3DNodeElementMetaBoolean *)cur_meta)->Value.begin()) == true);
+            } else if ((*it)->Type == X3DElemType::ENET_MetaDouble) {
+                if (((X3DNodeElementMetaDouble *)cur_meta)->Value.size() > 0)
+                    pSceneNode.mMetaData->Set(static_cast<unsigned int>(meta_idx), cur_meta->Name, (float)*(((X3DNodeElementMetaDouble *)cur_meta)->Value.begin()));
+            } else if ((*it)->Type == X3DElemType::ENET_MetaFloat) {
+                if (((X3DNodeElementMetaFloat *)cur_meta)->Value.size() > 0)
+                    pSceneNode.mMetaData->Set(static_cast<unsigned int>(meta_idx), cur_meta->Name, *(((X3DNodeElementMetaFloat *)cur_meta)->Value.begin()));
+            } else if ((*it)->Type == X3DElemType::ENET_MetaInteger) {
+                if (((X3DNodeElementMetaInt *)cur_meta)->Value.size() > 0)
+                    pSceneNode.mMetaData->Set(static_cast<unsigned int>(meta_idx), cur_meta->Name, *(((X3DNodeElementMetaInt *)cur_meta)->Value.begin()));
+            } else if ((*it)->Type == X3DElemType::ENET_MetaString) {
+                if (((X3DNodeElementMetaString *)cur_meta)->Value.size() > 0) {
+                    aiString tstr(((X3DNodeElementMetaString *)cur_meta)->Value.begin()->data());
+
+                    pSceneNode.mMetaData->Set(static_cast<unsigned int>(meta_idx), cur_meta->Name, tstr);
+                }
+            } else {
+                throw DeadlyImportError("Postprocess. Unknown metadata type.");
+            } // if((*it)->Type == X3DElemType::ENET_Meta*) else
+        } // for(std::list<X3DNodeElementBase*>::const_iterator it = meta_list.begin(); it != meta_list.end(); it++)
+    } // if( !meta_list.empty() )
+}
+
+} // namespace Assimp
+
+#endif // !ASSIMP_BUILD_NO_X3D_IMPORTER
diff --git a/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Rendering.cpp b/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Rendering.cpp
new file mode 100644
index 000000000..66a30a916
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Rendering.cpp
@@ -0,0 +1,993 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2019, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+/// \file   X3DImporter_Rendering.cpp
+/// \brief  Parsing data from nodes of "Rendering" set of X3D.
+/// \date   2015-2016
+/// \author smal.root@gmail.com
+
+#ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
+
+#include "X3DImporter.hpp"
+#include "X3DImporter_Macro.hpp"
+#include "X3DXmlHelper.h"
+
+namespace Assimp {
+
+// <Color
+// DEF=""           ID
+// USE=""           IDREF
+// color="" MFColor [inputOutput]
+// />
+void X3DImporter::readColor(XmlNode &node) {
+    std::string use, def;
+    std::list<aiColor3D> color;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    X3DXmlHelper::getColor3DListAttribute(node, "color", color);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_Color, ne);
+    } else {
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementColor(mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        ((X3DNodeElementColor *)ne)->Value = color;
+        // check for X3DMetadataObject childs.
+        if (!isNodeEmpty(node))
+            childrenReadMetadata(node, ne, "Color");
+        else
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+// <ColorRGBA
+// DEF=""               ID
+// USE=""               IDREF
+// color="" MFColorRGBA [inputOutput]
+// />
+void X3DImporter::readColorRGBA(XmlNode &node) {
+    std::string use, def;
+    std::list<aiColor4D> color;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    X3DXmlHelper::getColor4DListAttribute(node, "color", color);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_ColorRGBA, ne);
+    } else {
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementColorRGBA(mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        ((X3DNodeElementColorRGBA *)ne)->Value = color;
+        // check for X3DMetadataObject childs.
+        if (!isNodeEmpty(node))
+            childrenReadMetadata(node, ne, "ColorRGBA");
+        else
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+// <Coordinate
+// DEF=""      ID
+// USE=""      IDREF
+// point=""    MFVec3f [inputOutput]
+// />
+void X3DImporter::readCoordinate(XmlNode &node) {
+    std::string use, def;
+    std::list<aiVector3D> point;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    X3DXmlHelper::getVector3DListAttribute(node, "point", point);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_Coordinate, ne);
+    } else {
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementCoordinate(mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        ((X3DNodeElementCoordinate *)ne)->Value = point;
+        // check for X3DMetadataObject childs.
+        if (!isNodeEmpty(node))
+            childrenReadMetadata(node, ne, "Coordinate");
+        else
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+// <IndexedLineSet
+// DEF=""                ID
+// USE=""                IDREF
+// colorIndex=""         MFInt32 [initializeOnly]
+// colorPerVertex="true" SFBool  [initializeOnly]
+// coordIndex=""         MFInt32 [initializeOnly]
+// >
+//    <!-- ColorCoordinateContentModel -->
+// ColorCoordinateContentModel is the child-node content model corresponding to IndexedLineSet, LineSet and PointSet. ColorCoordinateContentModel can
+// contain any-order Coordinate node with Color (or ColorRGBA) node. No more than one instance of any single node type is allowed.
+// A ProtoInstance node (with the proper node type) can be substituted for any node in this content model.
+// </IndexedLineSet>
+void X3DImporter::readIndexedLineSet(XmlNode &node) {
+    std::string use, def;
+    std::vector<int32_t> colorIndex;
+    bool colorPerVertex = true;
+    std::vector<int32_t> coordIndex;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    X3DXmlHelper::getInt32ArrayAttribute(node, "colorIndex", colorIndex);
+    XmlParser::getBoolAttribute(node, "colorPerVertex", colorPerVertex);
+    X3DXmlHelper::getInt32ArrayAttribute(node, "coordIndex", coordIndex);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_IndexedLineSet, ne);
+    } else {
+        // check data
+        if ((coordIndex.size() < 2) || ((coordIndex.back() == (-1)) && (coordIndex.size() < 3)))
+            throw DeadlyImportError("IndexedLineSet must contain not empty \"coordIndex\" attribute.");
+
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementIndexedSet(X3DElemType::ENET_IndexedLineSet, mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        X3DNodeElementIndexedSet &ne_alias = *((X3DNodeElementIndexedSet *)ne);
+
+        ne_alias.ColorIndex = colorIndex;
+        ne_alias.ColorPerVertex = colorPerVertex;
+        ne_alias.CoordIndex = coordIndex;
+        // check for child nodes
+        if (!isNodeEmpty(node)) {
+            ParseHelper_Node_Enter(ne);
+            for (auto currentChildNode : node.children()) {
+                const std::string &currentChildName = currentChildNode.name();
+                // check for Color and Coordinate nodes
+                if (currentChildName == "Color")
+                    readColor(currentChildNode);
+                else if (currentChildName == "ColorRGBA")
+                    readColorRGBA(currentChildNode);
+                else if (currentChildName == "Coordinate")
+                    readCoordinate(currentChildNode);
+                // check for X3DMetadataObject
+                else if (!checkForMetadataNode(currentChildNode))
+                    skipUnsupportedNode("IndexedLineSet", currentChildNode);
+            }
+            ParseHelper_Node_Exit();
+        } // if(!isNodeEmpty(node))
+        else {
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+        }
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+// <IndexedTriangleFanSet
+// DEF=""                 ID
+// USE=""                 IDREF
+// ccw="true"             SFBool  [initializeOnly]
+// colorPerVertex="true"  SFBool  [initializeOnly]
+// index=""               MFInt32 [initializeOnly]
+// normalPerVertex="true" SFBool  [initializeOnly]
+// solid="true"           SFBool  [initializeOnly]
+// >
+//    <!-- ComposedGeometryContentModel -->
+// ComposedGeometryContentModel is the child-node content model corresponding to X3DComposedGeometryNodes. It can contain Color (or ColorRGBA), Coordinate,
+// Normal and TextureCoordinate, in any order. No more than one instance of these nodes is allowed. Multiple VertexAttribute (FloatVertexAttribute,
+// Matrix3VertexAttribute, Matrix4VertexAttribute) nodes can also be contained.
+// A ProtoInstance node (with the proper node type) can be substituted for any node in this content model.
+// </IndexedTriangleFanSet>
+void X3DImporter::readIndexedTriangleFanSet(XmlNode &node) {
+    std::string use, def;
+    bool ccw = true;
+    bool colorPerVertex = true;
+    std::vector<int32_t> index;
+    bool normalPerVertex = true;
+    bool solid = true;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    XmlParser::getBoolAttribute(node, "ccw", ccw);
+    XmlParser::getBoolAttribute(node, "colorPerVertex", colorPerVertex);
+    X3DXmlHelper::getInt32ArrayAttribute(node, "index", index);
+    XmlParser::getBoolAttribute(node, "normalPerVertex", normalPerVertex);
+    XmlParser::getBoolAttribute(node, "solid", solid);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_IndexedTriangleFanSet, ne);
+    } else {
+        // check data
+        if (index.size() == 0) throw DeadlyImportError("IndexedTriangleFanSet must contain not empty \"index\" attribute.");
+
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementIndexedSet(X3DElemType::ENET_IndexedTriangleFanSet, mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        X3DNodeElementIndexedSet &ne_alias = *((X3DNodeElementIndexedSet *)ne);
+
+        ne_alias.CCW = ccw;
+        ne_alias.ColorPerVertex = colorPerVertex;
+        ne_alias.NormalPerVertex = normalPerVertex;
+        ne_alias.Solid = solid;
+
+        ne_alias.CoordIndex.clear();
+        int counter = 0;
+        int32_t idx[3];
+        for (std::vector<int32_t>::const_iterator idx_it = index.begin(); idx_it != index.end(); ++idx_it) {
+            idx[2] = *idx_it;
+            if (idx[2] < 0) {
+                counter = 0;
+            } else {
+                if (counter >= 2) {
+                    if (ccw) {
+                        ne_alias.CoordIndex.push_back(idx[0]);
+                        ne_alias.CoordIndex.push_back(idx[1]);
+                        ne_alias.CoordIndex.push_back(idx[2]);
+                    } else {
+                        ne_alias.CoordIndex.push_back(idx[0]);
+                        ne_alias.CoordIndex.push_back(idx[2]);
+                        ne_alias.CoordIndex.push_back(idx[1]);
+                    }
+                    ne_alias.CoordIndex.push_back(-1);
+                    idx[1] = idx[2];
+                } else {
+                    idx[counter] = idx[2];
+                }
+                ++counter;
+            }
+        } // for(std::list<int32_t>::const_iterator idx_it = index.begin(); idx_it != ne_alias.index.end(); idx_it++)
+
+        // check for child nodes
+        if (!isNodeEmpty(node)) {
+            ParseHelper_Node_Enter(ne);
+            for (auto currentChildNode : node.children()) {
+                const std::string &currentChildName = currentChildNode.name();
+                // check for X3DComposedGeometryNodes
+                if (currentChildName == "Color")
+                    readColor(currentChildNode);
+                else if (currentChildName == "ColorRGBA")
+                    readColorRGBA(currentChildNode);
+                else if (currentChildName == "Coordinate")
+                    readCoordinate(currentChildNode);
+                else if (currentChildName == "Normal")
+                    readNormal(currentChildNode);
+                else if (currentChildName == "TextureCoordinate")
+                    readTextureCoordinate(currentChildNode);
+                // check for X3DMetadataObject
+                else if (!checkForMetadataNode(currentChildNode))
+                    skipUnsupportedNode("IndexedTriangleFanSet", currentChildNode);
+            }
+            ParseHelper_Node_Exit();
+        } // if(!isNodeEmpty(node))
+        else {
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+        }
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+// <IndexedTriangleSet
+// DEF=""                 ID
+// USE=""                 IDREF
+// ccw="true"             SFBool  [initializeOnly]
+// colorPerVertex="true"  SFBool  [initializeOnly]
+// index=""               MFInt32 [initializeOnly]
+// normalPerVertex="true" SFBool  [initializeOnly]
+// solid="true"           SFBool  [initializeOnly]
+// >
+//    <!-- ComposedGeometryContentModel -->
+// ComposedGeometryContentModel is the child-node content model corresponding to X3DComposedGeometryNodes. It can contain Color (or ColorRGBA), Coordinate,
+// Normal and TextureCoordinate, in any order. No more than one instance of these nodes is allowed. Multiple VertexAttribute (FloatVertexAttribute,
+// Matrix3VertexAttribute, Matrix4VertexAttribute) nodes can also be contained.
+// A ProtoInstance node (with the proper node type) can be substituted for any node in this content model.
+// </IndexedTriangleSet>
+void X3DImporter::readIndexedTriangleSet(XmlNode &node) {
+    std::string use, def;
+    bool ccw = true;
+    bool colorPerVertex = true;
+    std::vector<int32_t> index;
+    bool normalPerVertex = true;
+    bool solid = true;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    XmlParser::getBoolAttribute(node, "ccw", ccw);
+    XmlParser::getBoolAttribute(node, "colorPerVertex", colorPerVertex);
+    X3DXmlHelper::getInt32ArrayAttribute(node, "index", index);
+    XmlParser::getBoolAttribute(node, "normalPerVertex", normalPerVertex);
+    XmlParser::getBoolAttribute(node, "solid", solid);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_IndexedTriangleSet, ne);
+    } else {
+        // check data
+        if (index.size() == 0) throw DeadlyImportError("IndexedTriangleSet must contain not empty \"index\" attribute.");
+
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementIndexedSet(X3DElemType::ENET_IndexedTriangleSet, mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        X3DNodeElementIndexedSet &ne_alias = *((X3DNodeElementIndexedSet *)ne);
+
+        ne_alias.CCW = ccw;
+        ne_alias.ColorPerVertex = colorPerVertex;
+        ne_alias.NormalPerVertex = normalPerVertex;
+        ne_alias.Solid = solid;
+
+        ne_alias.CoordIndex.clear();
+        int counter = 0;
+        int32_t idx[3];
+        for (std::vector<int32_t>::const_iterator idx_it = index.begin(); idx_it != index.end(); ++idx_it) {
+            idx[counter++] = *idx_it;
+            if (counter > 2) {
+                counter = 0;
+                if (ccw) {
+                    ne_alias.CoordIndex.push_back(idx[0]);
+                    ne_alias.CoordIndex.push_back(idx[1]);
+                    ne_alias.CoordIndex.push_back(idx[2]);
+                } else {
+                    ne_alias.CoordIndex.push_back(idx[0]);
+                    ne_alias.CoordIndex.push_back(idx[2]);
+                    ne_alias.CoordIndex.push_back(idx[1]);
+                }
+                ne_alias.CoordIndex.push_back(-1);
+            }
+        } // for(std::list<int32_t>::const_iterator idx_it = index.begin(); idx_it != ne_alias.index.end(); idx_it++)
+
+        // check for child nodes
+        if (!isNodeEmpty(node)) {
+            ParseHelper_Node_Enter(ne);
+            for (auto currentChildNode : node.children()) {
+                const std::string &currentChildName = currentChildNode.name();
+                // check for X3DComposedGeometryNodes
+                if (currentChildName == "Color")
+                    readColor(currentChildNode);
+                else if (currentChildName == "ColorRGBA")
+                    readColorRGBA(currentChildNode);
+                else if (currentChildName == "Coordinate")
+                    readCoordinate(currentChildNode);
+                else if (currentChildName == "Normal")
+                    readNormal(currentChildNode);
+                else if (currentChildName == "TextureCoordinate")
+                    readTextureCoordinate(currentChildNode);
+                // check for X3DMetadataObject
+                else if (!checkForMetadataNode(currentChildNode))
+                    skipUnsupportedNode("IndexedTriangleSet", currentChildNode);
+            }
+            ParseHelper_Node_Exit();
+        } // if(!isNodeEmpty(node))
+        else {
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+        }
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+// <IndexedTriangleStripSet
+// DEF=""                 ID
+// USE=""                 IDREF
+// ccw="true"             SFBool  [initializeOnly]
+// colorPerVertex="true"  SFBool  [initializeOnly]
+// index=""               MFInt32 [initializeOnly]
+// normalPerVertex="true" SFBool  [initializeOnly]
+// solid="true"           SFBool  [initializeOnly]
+// >
+//    <!-- ComposedGeometryContentModel -->
+// ComposedGeometryContentModel is the child-node content model corresponding to X3DComposedGeometryNodes. It can contain Color (or ColorRGBA), Coordinate,
+// Normal and TextureCoordinate, in any order. No more than one instance of these nodes is allowed. Multiple VertexAttribute (FloatVertexAttribute,
+// Matrix3VertexAttribute, Matrix4VertexAttribute) nodes can also be contained.
+// A ProtoInstance node (with the proper node type) can be substituted for any node in this content model.
+// </IndexedTriangleStripSet>
+void X3DImporter::readIndexedTriangleStripSet(XmlNode &node) {
+    std::string use, def;
+    bool ccw = true;
+    bool colorPerVertex = true;
+    std::vector<int32_t> index;
+    bool normalPerVertex = true;
+    bool solid = true;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    XmlParser::getBoolAttribute(node, "ccw", ccw);
+    XmlParser::getBoolAttribute(node, "colorPerVertex", colorPerVertex);
+    X3DXmlHelper::getInt32ArrayAttribute(node, "index", index);
+    XmlParser::getBoolAttribute(node, "normalPerVertex", normalPerVertex);
+    XmlParser::getBoolAttribute(node, "solid", solid);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_IndexedTriangleStripSet, ne);
+    } else {
+        // check data
+        if (index.empty()) {
+            throw DeadlyImportError("IndexedTriangleStripSet must contain not empty \"index\" attribute.");
+        }
+
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementIndexedSet(X3DElemType::ENET_IndexedTriangleStripSet, mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        X3DNodeElementIndexedSet &ne_alias = *((X3DNodeElementIndexedSet *)ne);
+
+        ne_alias.CCW = ccw;
+        ne_alias.ColorPerVertex = colorPerVertex;
+        ne_alias.NormalPerVertex = normalPerVertex;
+        ne_alias.Solid = solid;
+
+        ne_alias.CoordIndex.clear();
+        int counter = 0;
+        int32_t idx[3];
+        for (std::vector<int32_t>::const_iterator idx_it = index.begin(); idx_it != index.end(); ++idx_it) {
+            idx[2] = *idx_it;
+            if (idx[2] < 0) {
+                counter = 0;
+            } else {
+                if (counter >= 2) {
+                    if (ccw) {
+                        ne_alias.CoordIndex.push_back(idx[0]);
+                        ne_alias.CoordIndex.push_back(idx[1]);
+                        ne_alias.CoordIndex.push_back(idx[2]);
+                    } else {
+                        ne_alias.CoordIndex.push_back(idx[0]);
+                        ne_alias.CoordIndex.push_back(idx[2]);
+                        ne_alias.CoordIndex.push_back(idx[1]);
+                    }
+                    ne_alias.CoordIndex.push_back(-1);
+                }
+                idx[counter & 1] = idx[2];
+                ++counter;
+            }
+        } // for(std::list<int32_t>::const_iterator idx_it = index.begin(); idx_it != ne_alias.index.end(); idx_it++)
+
+        // check for child nodes
+        if (!isNodeEmpty(node)) {
+            ParseHelper_Node_Enter(ne);
+            for (auto currentChildNode : node.children()) {
+                const std::string &currentChildName = currentChildNode.name();
+                // check for X3DComposedGeometryNodes
+                if (currentChildName == "Color")
+                    readColor(currentChildNode);
+                else if (currentChildName == "ColorRGBA")
+                    readColorRGBA(currentChildNode);
+                else if (currentChildName == "Coordinate")
+                    readCoordinate(currentChildNode);
+                else if (currentChildName == "Normal")
+                    readNormal(currentChildNode);
+                else if (currentChildName == "TextureCoordinate")
+                    readTextureCoordinate(currentChildNode);
+                // check for X3DMetadataObject
+                else if (!checkForMetadataNode(currentChildNode))
+                    skipUnsupportedNode("IndexedTriangleStripSet", currentChildNode);
+            }
+            ParseHelper_Node_Exit();
+        } // if(!isNodeEmpty(node))
+        else {
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+        }
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+// <LineSet
+// DEF=""         ID
+// USE=""         IDREF
+// vertexCount="" MFInt32 [initializeOnly]
+// >
+//    <!-- ColorCoordinateContentModel -->
+// ColorCoordinateContentModel is the child-node content model corresponding to IndexedLineSet, LineSet and PointSet. ColorCoordinateContentModel can
+// contain any-order Coordinate node with Color (or ColorRGBA) node. No more than one instance of any single node type is allowed.
+// A ProtoInstance node (with the proper node type) can be substituted for any node in this content model.
+// </LineSet>
+void X3DImporter::readLineSet(XmlNode &node) {
+    std::string use, def;
+    std::vector<int32_t> vertexCount;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    X3DXmlHelper::getInt32ArrayAttribute(node, "vertexCount", vertexCount);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_LineSet, ne);
+    } else {
+        // check data
+        if (vertexCount.empty()) {
+            throw DeadlyImportError("LineSet must contain not empty \"vertexCount\" attribute.");
+        }
+
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementSet(X3DElemType::ENET_LineSet, mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        X3DNodeElementSet &ne_alias = *((X3DNodeElementSet *)ne);
+
+        ne_alias.VertexCount = vertexCount;
+        // create CoordIdx
+        size_t coord_num = 0;
+
+        ne_alias.CoordIndex.clear();
+        for (std::vector<int32_t>::const_iterator vc_it = ne_alias.VertexCount.begin(); vc_it != ne_alias.VertexCount.end(); ++vc_it) {
+            if (*vc_it < 2) throw DeadlyImportError("LineSet. vertexCount shall be greater than or equal to two.");
+
+            for (int32_t i = 0; i < *vc_it; i++)
+                ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num++)); // add vertices indices
+
+            ne_alias.CoordIndex.push_back(-1); // add face delimiter.
+        }
+
+        // check for child nodes
+        if (!isNodeEmpty(node)) {
+            ParseHelper_Node_Enter(ne);
+            for (auto currentChildNode : node.children()) {
+                const std::string &currentChildName = currentChildNode.name();
+                // check for X3DComposedGeometryNodes
+                if (currentChildName == "Color")
+                    readColor(currentChildNode);
+                else if (currentChildName == "ColorRGBA")
+                    readColorRGBA(currentChildNode);
+                else if (currentChildName == "Coordinate")
+                    readCoordinate(currentChildNode);
+                // check for X3DMetadataObject
+                else if (!checkForMetadataNode(currentChildNode))
+                    skipUnsupportedNode("LineSet", currentChildNode);
+            }
+            ParseHelper_Node_Exit();
+        } // if(!isNodeEmpty(node))
+        else {
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+        }
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+// <PointSet
+// DEF="" ID
+// USE="" IDREF
+// >
+//    <!-- ColorCoordinateContentModel -->
+// ColorCoordinateContentModel is the child-node content model corresponding to IndexedLineSet, LineSet and PointSet. ColorCoordinateContentModel can
+// contain any-order Coordinate node with Color (or ColorRGBA) node. No more than one instance of any single node type is allowed.
+// A ProtoInstance node (with the proper node type) can be substituted for any node in this content model.
+// </PointSet>
+void X3DImporter::readPointSet(XmlNode &node) {
+    std::string use, def;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_PointSet, ne);
+    } else {
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementIndexedSet(X3DElemType::ENET_PointSet, mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        // check for child nodes
+        if (!isNodeEmpty(node)) {
+            ParseHelper_Node_Enter(ne);
+            for (auto currentChildNode : node.children()) {
+                const std::string &currentChildName = currentChildNode.name();
+                // check for X3DComposedGeometryNodes
+                if (currentChildName == "Color")
+                    readColor(currentChildNode);
+                else if (currentChildName == "ColorRGBA")
+                    readColorRGBA(currentChildNode);
+                else if (currentChildName == "Coordinate")
+                    readCoordinate(currentChildNode);
+                // check for X3DMetadataObject
+                else if (!checkForMetadataNode(currentChildNode))
+                    skipUnsupportedNode("PointSet", currentChildNode);
+            }
+            ParseHelper_Node_Exit();
+        } // if(!isNodeEmpty(node))
+        else {
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+        }
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+// <TriangleFanSet
+// DEF=""                 ID
+// USE=""                 IDREF
+// ccw="true"             SFBool  [initializeOnly]
+// colorPerVertex="true"  SFBool  [initializeOnly]
+// fanCount=""            MFInt32 [inputOutput]
+// normalPerVertex="true" SFBool  [initializeOnly]
+// solid="true"           SFBool  [initializeOnly]
+// >
+//    <!-- ComposedGeometryContentModel -->
+// ComposedGeometryContentModel is the child-node content model corresponding to X3DComposedGeometryNodes. It can contain Color (or ColorRGBA), Coordinate,
+// Normal and TextureCoordinate, in any order. No more than one instance of these nodes is allowed. Multiple VertexAttribute (FloatVertexAttribute,
+// Matrix3VertexAttribute, Matrix4VertexAttribute) nodes can also be contained.
+// A ProtoInstance node (with the proper node type) can be substituted for any node in this content model.
+// </TriangleFanSet>
+void X3DImporter::readTriangleFanSet(XmlNode &node) {
+    std::string use, def;
+    bool ccw = true;
+    bool colorPerVertex = true;
+    std::vector<int32_t> fanCount;
+    bool normalPerVertex = true;
+    bool solid = true;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    XmlParser::getBoolAttribute(node, "ccw", ccw);
+    XmlParser::getBoolAttribute(node, "colorPerVertex", colorPerVertex);
+    X3DXmlHelper::getInt32ArrayAttribute(node, "fanCount", fanCount);
+    XmlParser::getBoolAttribute(node, "normalPerVertex", normalPerVertex);
+    XmlParser::getBoolAttribute(node, "solid", solid);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_TriangleFanSet, ne);
+    } else {
+        // check data
+        if (fanCount.empty()) {
+            throw DeadlyImportError("TriangleFanSet must contain not empty \"fanCount\" attribute.");
+        }
+
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementSet(X3DElemType::ENET_TriangleFanSet, mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        X3DNodeElementSet &ne_alias = *((X3DNodeElementSet *)ne);
+
+        ne_alias.CCW = ccw;
+        ne_alias.ColorPerVertex = colorPerVertex;
+        ne_alias.VertexCount = fanCount;
+        ne_alias.NormalPerVertex = normalPerVertex;
+        ne_alias.Solid = solid;
+        // create CoordIdx
+        size_t coord_num_first, coord_num_prev;
+
+        ne_alias.CoordIndex.clear();
+        // assign indices for first triangle
+        coord_num_first = 0;
+        coord_num_prev = 1;
+        for (std::vector<int32_t>::const_iterator vc_it = ne_alias.VertexCount.begin(); vc_it != ne_alias.VertexCount.end(); ++vc_it) {
+            if (*vc_it < 3) throw DeadlyImportError("TriangleFanSet. fanCount shall be greater than or equal to three.");
+
+            for (int32_t vc = 2; vc < *vc_it; vc++) {
+                if (ccw) {
+                    // 2 1
+                    //  0
+                    ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num_first)); // first vertex is a center and always is [0].
+                    ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num_prev++));
+                    ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num_prev));
+                } else {
+                    // 1 2
+                    //  0
+                    ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num_first)); // first vertex is a center and always is [0].
+                    ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num_prev + 1));
+                    ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num_prev++));
+                } // if(ccw) else
+
+                ne_alias.CoordIndex.push_back(-1); // add face delimiter.
+            } // for(int32_t vc = 2; vc < *vc_it; vc++)
+
+            coord_num_prev++; // that index will be center of next fan
+            coord_num_first = coord_num_prev++; // forward to next point - second point of fan
+        } // for(std::list<int32_t>::const_iterator vc_it = ne_alias.VertexCount.begin(); vc_it != ne_alias.VertexCount.end(); vc_it++)
+        // check for child nodes
+        if (!isNodeEmpty(node)) {
+            ParseHelper_Node_Enter(ne);
+            for (auto currentChildNode : node.children()) {
+                const std::string &currentChildName = currentChildNode.name();
+                // check for X3DComposedGeometryNodes
+                if (currentChildName == "Color")
+                    readColor(currentChildNode);
+                else if (currentChildName == "ColorRGBA")
+                    readColorRGBA(currentChildNode);
+                else if (currentChildName == "Coordinate")
+                    readCoordinate(currentChildNode);
+                else if (currentChildName == "Normal")
+                    readNormal(currentChildNode);
+                else if (currentChildName == "TextureCoordinate")
+                    readTextureCoordinate(currentChildNode);
+                // check for X3DMetadataObject
+                else if (!checkForMetadataNode(currentChildNode))
+                    skipUnsupportedNode("TriangleFanSet", currentChildNode);
+            }
+            ParseHelper_Node_Exit();
+        } // if(!isNodeEmpty(node))
+        else {
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+        }
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+// <TriangleSet
+// DEF=""                 ID
+// USE=""                 IDREF
+// ccw="true"             SFBool  [initializeOnly]
+// colorPerVertex="true"  SFBool  [initializeOnly]
+// normalPerVertex="true" SFBool  [initializeOnly]
+// solid="true"           SFBool  [initializeOnly]
+// >
+//    <!-- ComposedGeometryContentModel -->
+// ComposedGeometryContentModel is the child-node content model corresponding to X3DComposedGeometryNodes. It can contain Color (or ColorRGBA), Coordinate,
+// Normal and TextureCoordinate, in any order. No more than one instance of these nodes is allowed. Multiple VertexAttribute (FloatVertexAttribute,
+// Matrix3VertexAttribute, Matrix4VertexAttribute) nodes can also be contained.
+// A ProtoInstance node (with the proper node type) can be substituted for any node in this content model.
+// </TriangleSet>
+void X3DImporter::readTriangleSet(XmlNode &node) {
+    std::string use, def;
+    bool ccw = true;
+    bool colorPerVertex = true;
+    bool normalPerVertex = true;
+    bool solid = true;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    XmlParser::getBoolAttribute(node, "ccw", ccw);
+    XmlParser::getBoolAttribute(node, "colorPerVertex", colorPerVertex);
+    XmlParser::getBoolAttribute(node, "normalPerVertex", normalPerVertex);
+    XmlParser::getBoolAttribute(node, "solid", solid);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_TriangleSet, ne);
+    } else {
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementIndexedSet(X3DElemType::ENET_TriangleSet, mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        X3DNodeElementSet &ne_alias = *((X3DNodeElementSet *)ne);
+
+        ne_alias.CCW = ccw;
+        ne_alias.ColorPerVertex = colorPerVertex;
+        ne_alias.NormalPerVertex = normalPerVertex;
+        ne_alias.Solid = solid;
+        // check for child nodes
+        if (!isNodeEmpty(node)) {
+            ParseHelper_Node_Enter(ne);
+            for (auto currentChildNode : node.children()) {
+                const std::string &currentChildName = currentChildNode.name();
+                // check for X3DComposedGeometryNodes
+                if (currentChildName == "Color")
+                    readColor(currentChildNode);
+                else if (currentChildName == "ColorRGBA")
+                    readColorRGBA(currentChildNode);
+                else if (currentChildName == "Coordinate")
+                    readCoordinate(currentChildNode);
+                else if (currentChildName == "Normal")
+                    readNormal(currentChildNode);
+                else if (currentChildName == "TextureCoordinate")
+                    readTextureCoordinate(currentChildNode);
+                // check for X3DMetadataObject
+                else if (!checkForMetadataNode(currentChildNode))
+                    skipUnsupportedNode("TriangleSet", currentChildNode);
+            }
+            ParseHelper_Node_Exit();
+        } // if(!isNodeEmpty(node))
+        else {
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+        }
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+// <TriangleStripSet
+// DEF=""                 ID
+// USE=""                 IDREF
+// ccw="true"             SFBool  [initializeOnly]
+// colorPerVertex="true"  SFBool  [initializeOnly]
+// normalPerVertex="true" SFBool  [initializeOnly]
+// solid="true"           SFBool  [initializeOnly]
+// stripCount=""          MFInt32 [inputOutput]
+// >
+//    <!-- ComposedGeometryContentModel -->
+// ComposedGeometryContentModel is the child-node content model corresponding to X3DComposedGeometryNodes. It can contain Color (or ColorRGBA), Coordinate,
+// Normal and TextureCoordinate, in any order. No more than one instance of these nodes is allowed. Multiple VertexAttribute (FloatVertexAttribute,
+// Matrix3VertexAttribute, Matrix4VertexAttribute) nodes can also be contained.
+// A ProtoInstance node (with the proper node type) can be substituted for any node in this content model.
+// </TriangleStripSet>
+void X3DImporter::readTriangleStripSet(XmlNode &node) {
+    std::string use, def;
+    bool ccw = true;
+    bool colorPerVertex = true;
+    std::vector<int32_t> stripCount;
+    bool normalPerVertex = true;
+    bool solid = true;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    XmlParser::getBoolAttribute(node, "ccw", ccw);
+    XmlParser::getBoolAttribute(node, "colorPerVertex", colorPerVertex);
+    X3DXmlHelper::getInt32ArrayAttribute(node, "stripCount", stripCount);
+    XmlParser::getBoolAttribute(node, "normalPerVertex", normalPerVertex);
+    XmlParser::getBoolAttribute(node, "solid", solid);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_TriangleStripSet, ne);
+    } else {
+        // check data
+        if (stripCount.size() == 0) throw DeadlyImportError("TriangleStripSet must contain not empty \"stripCount\" attribute.");
+
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementSet(X3DElemType::ENET_TriangleStripSet, mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        X3DNodeElementSet &ne_alias = *((X3DNodeElementSet *)ne);
+
+        ne_alias.CCW = ccw;
+        ne_alias.ColorPerVertex = colorPerVertex;
+        ne_alias.VertexCount = stripCount;
+        ne_alias.NormalPerVertex = normalPerVertex;
+        ne_alias.Solid = solid;
+        // create CoordIdx
+        size_t coord_num0, coord_num1, coord_num2; // indices of current triangle
+        bool odd_tri; // sequence of current triangle
+        size_t coord_num_sb; // index of first point of strip
+
+        ne_alias.CoordIndex.clear();
+        coord_num_sb = 0;
+        for (std::vector<int32_t>::const_iterator vc_it = ne_alias.VertexCount.begin(); vc_it != ne_alias.VertexCount.end(); ++vc_it) {
+            if (*vc_it < 3) throw DeadlyImportError("TriangleStripSet. stripCount shall be greater than or equal to three.");
+
+            // set initial values for first triangle
+            coord_num0 = coord_num_sb;
+            coord_num1 = coord_num_sb + 1;
+            coord_num2 = coord_num_sb + 2;
+            odd_tri = true;
+
+            for (int32_t vc = 2; vc < *vc_it; vc++) {
+                if (ccw) {
+                    // 0 2
+                    //  1
+                    ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num0));
+                    ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num1));
+                    ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num2));
+                } else {
+                    // 0 1
+                    //  2
+                    ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num0));
+                    ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num2));
+                    ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num1));
+                } // if(ccw) else
+
+                ne_alias.CoordIndex.push_back(-1); // add face delimiter.
+                // prepare values for next triangle
+                if (odd_tri) {
+                    coord_num0 = coord_num2;
+                    coord_num2++;
+                } else {
+                    coord_num1 = coord_num2;
+                    coord_num2 = coord_num1 + 1;
+                }
+
+                odd_tri = !odd_tri;
+                coord_num_sb = coord_num2; // that index will be start of next strip
+            } // for(int32_t vc = 2; vc < *vc_it; vc++)
+        } // for(std::list<int32_t>::const_iterator vc_it = ne_alias.VertexCount.begin(); vc_it != ne_alias.VertexCount.end(); vc_it++)
+        // check for child nodes
+        if (!isNodeEmpty(node)) {
+            ParseHelper_Node_Enter(ne);
+            for (auto currentChildNode : node.children()) {
+                const std::string &currentChildName = currentChildNode.name();
+                // check for X3DComposedGeometryNodes
+                if (currentChildName == "Color")
+                    readColor(currentChildNode);
+                else if (currentChildName == "ColorRGBA")
+                    readColorRGBA(currentChildNode);
+                else if (currentChildName == "Coordinate")
+                    readCoordinate(currentChildNode);
+                else if (currentChildName == "Normal")
+                    readNormal(currentChildNode);
+                else if (currentChildName == "TextureCoordinate")
+                    readTextureCoordinate(currentChildNode);
+                // check for X3DMetadataObject
+                else if (!checkForMetadataNode(currentChildNode))
+                    skipUnsupportedNode("TriangleStripSet", currentChildNode);
+            }
+            ParseHelper_Node_Exit();
+        } // if(!isNodeEmpty(node))
+        else {
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+        }
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+// <Normal
+// DEF=""      ID
+// USE=""      IDREF
+// vector=""   MFVec3f [inputOutput]
+// />
+void X3DImporter::readNormal(XmlNode &node) {
+    std::string use, def;
+    std::list<aiVector3D> vector;
+    X3DNodeElementBase *ne=nullptr;
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    X3DXmlHelper::getVector3DListAttribute(node, "vector", vector);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_Normal, ne);
+    } else {
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementNormal(mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        ((X3DNodeElementNormal *)ne)->Value = vector;
+        // check for X3DMetadataObject childs.
+        if (!isNodeEmpty(node))
+            childrenReadMetadata(node, ne, "Normal");
+        else
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+} // namespace Assimp
+
+#endif // !ASSIMP_BUILD_NO_X3D_IMPORTER
diff --git a/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Shape.cpp b/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Shape.cpp
new file mode 100644
index 000000000..1c472e14b
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Shape.cpp
@@ -0,0 +1,241 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2019, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+/// \file   X3DImporter_Shape.cpp
+/// \brief  Parsing data from nodes of "Shape" set of X3D.
+/// \date   2015-2016
+/// \author smal.root@gmail.com
+
+#ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
+
+#include "X3DImporter.hpp"
+#include "X3DImporter_Macro.hpp"
+#include "X3DXmlHelper.h"
+
+namespace Assimp {
+
+void X3DImporter::readShape(XmlNode &node) {
+    std::string use, def;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_Shape, ne);
+    } else {
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementShape(mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        // check for child nodes
+        if (!isNodeEmpty(node)) {
+            ParseHelper_Node_Enter(ne);
+            for (auto currentChildNode : node.children()) {
+                const std::string &currentChildName = currentChildNode.name();
+                // check for appearance node
+                if (currentChildName == "Appearance") readAppearance(currentChildNode);
+                // check for X3DGeometryNodes
+                else if (currentChildName == "Arc2D")
+                    readArc2D(currentChildNode);
+                else if (currentChildName == "ArcClose2D")
+                    readArcClose2D(currentChildNode);
+                else if (currentChildName == "Circle2D")
+                    readCircle2D(currentChildNode);
+                else if (currentChildName == "Disk2D")
+                    readDisk2D(currentChildNode);
+                else if (currentChildName == "Polyline2D")
+                    readPolyline2D(currentChildNode);
+                else if (currentChildName == "Polypoint2D")
+                    readPolypoint2D(currentChildNode);
+                else if (currentChildName == "Rectangle2D")
+                    readRectangle2D(currentChildNode);
+                else if (currentChildName == "TriangleSet2D")
+                    readTriangleSet2D(currentChildNode);
+                else if (currentChildName == "Box")
+                    readBox(currentChildNode);
+                else if (currentChildName == "Cone")
+                    readCone(currentChildNode);
+                else if (currentChildName == "Cylinder")
+                    readCylinder(currentChildNode);
+                else if (currentChildName == "ElevationGrid")
+                    readElevationGrid(currentChildNode);
+                else if (currentChildName == "Extrusion")
+                    readExtrusion(currentChildNode);
+                else if (currentChildName == "IndexedFaceSet")
+                    readIndexedFaceSet(currentChildNode);
+                else if (currentChildName == "Sphere")
+                    readSphere(currentChildNode);
+                else if (currentChildName == "IndexedLineSet")
+                    readIndexedLineSet(currentChildNode);
+                else if (currentChildName == "LineSet")
+                    readLineSet(currentChildNode);
+                else if (currentChildName == "PointSet")
+                    readPointSet(currentChildNode);
+                else if (currentChildName == "IndexedTriangleFanSet")
+                    readIndexedTriangleFanSet(currentChildNode);
+                else if (currentChildName == "IndexedTriangleSet")
+                    readIndexedTriangleSet(currentChildNode);
+                else if (currentChildName == "IndexedTriangleStripSet")
+                    readIndexedTriangleStripSet(currentChildNode);
+                else if (currentChildName == "TriangleFanSet")
+                    readTriangleFanSet(currentChildNode);
+                else if (currentChildName == "TriangleSet")
+                    readTriangleSet(currentChildNode);
+                // check for X3DMetadataObject
+                else if (!checkForMetadataNode(currentChildNode))
+                    skipUnsupportedNode("Shape", currentChildNode);
+            }
+
+            ParseHelper_Node_Exit();
+        } // if (!isNodeEmpty(node))
+        else {
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+        }
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+// <Appearance
+// DEF="" ID
+// USE="" IDREF
+// >
+// <!-- AppearanceChildContentModel -->
+// "Child-node content model corresponding to X3DAppearanceChildNode. Appearance can contain FillProperties, LineProperties, Material, any Texture node and
+// any TextureTransform node, in any order. No more than one instance of these nodes is allowed. Appearance may also contain multiple shaders (ComposedShader,
+// PackagedShader, ProgramShader).
+// A ProtoInstance node (with the proper node type) can be substituted for any node in this content model."
+// </Appearance>
+void X3DImporter::readAppearance(XmlNode &node) {
+    std::string use, def;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_Appearance, ne);
+    } else {
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementAppearance(mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        // check for child nodes
+        if (!isNodeEmpty(node)) {
+            ParseHelper_Node_Enter(ne);
+            for (auto currentChildNode : node.children()) {
+                const std::string &currentChildName = currentChildNode.name();
+                if (currentChildName == "Material")
+                    readMaterial(currentChildNode);
+                else if (currentChildName == "ImageTexture")
+                    readImageTexture(currentChildNode);
+                else if (currentChildName == "TextureTransform")
+                    readTextureTransform(currentChildNode);
+                // check for X3DMetadataObject
+                else if (!checkForMetadataNode(currentChildNode))
+                    skipUnsupportedNode("Appearance", currentChildNode);
+            }
+            ParseHelper_Node_Exit();
+        } // if(!isNodeEmpty(node))
+        else {
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+        }
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+// <Material
+// DEF=""                     ID
+// USE=""                     IDREF
+// ambientIntensity="0.2"     SFFloat [inputOutput]
+// diffuseColor="0.8 0.8 0.8" SFColor [inputOutput]
+// emissiveColor="0 0 0"      SFColor [inputOutput]
+// shininess="0.2"            SFFloat [inputOutput]
+// specularColor="0 0 0"      SFColor [inputOutput]
+// transparency="0"           SFFloat [inputOutput]
+// />
+void X3DImporter::readMaterial(XmlNode &node) {
+    std::string use, def;
+    float ambientIntensity = 0.2f;
+    float shininess = 0.2f;
+    float transparency = 0;
+    aiColor3D diffuseColor(0.8f, 0.8f, 0.8f);
+    aiColor3D emissiveColor(0, 0, 0);
+    aiColor3D specularColor(0, 0, 0);
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    XmlParser::getFloatAttribute(node, "ambientIntensity", ambientIntensity);
+    XmlParser::getFloatAttribute(node, "shininess", shininess);
+    XmlParser::getFloatAttribute(node, "transparency", transparency);
+    X3DXmlHelper::getColor3DAttribute(node, "diffuseColor", diffuseColor);
+    X3DXmlHelper::getColor3DAttribute(node, "emissiveColor", emissiveColor);
+    X3DXmlHelper::getColor3DAttribute(node, "specularColor", specularColor);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_Material, ne);
+    } else {
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementMaterial(mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        ((X3DNodeElementMaterial *)ne)->AmbientIntensity = ambientIntensity;
+        ((X3DNodeElementMaterial *)ne)->Shininess = shininess;
+        ((X3DNodeElementMaterial *)ne)->Transparency = transparency;
+        ((X3DNodeElementMaterial *)ne)->DiffuseColor = diffuseColor;
+        ((X3DNodeElementMaterial *)ne)->EmissiveColor = emissiveColor;
+        ((X3DNodeElementMaterial *)ne)->SpecularColor = specularColor;
+        // check for child nodes
+        if (!isNodeEmpty(node))
+            childrenReadMetadata(node, ne, "Material");
+        else
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+} // namespace Assimp
+
+#endif // !ASSIMP_BUILD_NO_X3D_IMPORTER
diff --git a/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Texturing.cpp b/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Texturing.cpp
new file mode 100644
index 000000000..32c1a90d7
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/X3D/X3DImporter_Texturing.cpp
@@ -0,0 +1,179 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2019, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+/// \file   X3DImporter_Texturing.cpp
+/// \brief  Parsing data from nodes of "Texturing" set of X3D.
+/// \date   2015-2016
+/// \author smal.root@gmail.com
+
+#ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
+
+#include "X3DImporter.hpp"
+#include "X3DImporter_Macro.hpp"
+#include "X3DXmlHelper.h"
+
+namespace Assimp {
+
+// <ImageTexture
+// DEF=""         ID
+// USE=""         IDREF
+// repeatS="true" SFBool
+// repeatT="true" SFBool
+// url=""         MFString
+// />
+// When the url field contains no values ([]), texturing is disabled.
+void X3DImporter::readImageTexture(XmlNode &node) {
+    std::string use, def;
+    bool repeatS = true;
+    bool repeatT = true;
+    std::list<std::string> url;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    XmlParser::getBoolAttribute(node, "repeatS", repeatS);
+    XmlParser::getBoolAttribute(node, "repeatT", repeatT);
+    X3DXmlHelper::getStringListAttribute(node, "url", url);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_ImageTexture, ne);
+    } else {
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementImageTexture(mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        ((X3DNodeElementImageTexture *)ne)->RepeatS = repeatS;
+        ((X3DNodeElementImageTexture *)ne)->RepeatT = repeatT;
+        // Attribute "url" can contain list of strings. But we need only one - first.
+        if (!url.empty())
+            ((X3DNodeElementImageTexture *)ne)->URL = url.front();
+        else
+            ((X3DNodeElementImageTexture *)ne)->URL = "";
+
+        // check for X3DMetadataObject childs.
+        if (!isNodeEmpty(node))
+            childrenReadMetadata(node, ne, "ImageTexture");
+        else
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+// <TextureCoordinate
+// DEF=""      ID
+// USE=""      IDREF
+// point=""    MFVec3f [inputOutput]
+// />
+void X3DImporter::readTextureCoordinate(XmlNode &node) {
+    std::string use, def;
+    std::list<aiVector2D> point;
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    X3DXmlHelper::getVector2DListAttribute(node, "point", point);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_TextureCoordinate, ne);
+    } else {
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementTextureCoordinate(mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        ((X3DNodeElementTextureCoordinate *)ne)->Value = point;
+        // check for X3DMetadataObject childs.
+        if (!isNodeEmpty(node))
+            childrenReadMetadata(node, ne, "TextureCoordinate");
+        else
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+// <TextureTransform
+// DEF=""            ID
+// USE=""            IDREF
+// center="0 0"      SFVec2f [inputOutput]
+// rotation="0"      SFFloat [inputOutput]
+// scale="1 1"       SFVec2f [inputOutput]
+// translation="0 0" SFVec2f [inputOutput]
+// />
+void X3DImporter::readTextureTransform(XmlNode &node) {
+    std::string use, def;
+    aiVector2D center(0, 0);
+    float rotation = 0;
+    aiVector2D scale(1, 1);
+    aiVector2D translation(0, 0);
+    X3DNodeElementBase *ne(nullptr);
+
+    MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
+    X3DXmlHelper::getVector2DAttribute(node, "center", center);
+    XmlParser::getFloatAttribute(node, "rotation", rotation);
+    X3DXmlHelper::getVector2DAttribute(node, "scale", scale);
+    X3DXmlHelper::getVector2DAttribute(node, "translation", translation);
+
+    // if "USE" defined then find already defined element.
+    if (!use.empty()) {
+        ne = MACRO_USE_CHECKANDAPPLY(node, def, use, ENET_TextureTransform, ne);
+    } else {
+        // create and if needed - define new geometry object.
+        ne = new X3DNodeElementTextureTransform(mNodeElementCur);
+        if (!def.empty()) ne->ID = def;
+
+        ((X3DNodeElementTextureTransform *)ne)->Center = center;
+        ((X3DNodeElementTextureTransform *)ne)->Rotation = rotation;
+        ((X3DNodeElementTextureTransform *)ne)->Scale = scale;
+        ((X3DNodeElementTextureTransform *)ne)->Translation = translation;
+        // check for X3DMetadataObject childs.
+        if (!isNodeEmpty(node))
+            childrenReadMetadata(node, ne, "TextureTransform");
+        else
+            mNodeElementCur->Children.push_back(ne); // add made object as child to current element
+
+        NodeElement_List.push_back(ne); // add element to node element list because its a new object in graph
+    } // if(!use.empty()) else
+}
+
+} // namespace Assimp
+
+#endif // !ASSIMP_BUILD_NO_X3D_IMPORTER
diff --git a/Engine/lib/assimp/code/AssetLib/X3D/X3DXmlHelper.cpp b/Engine/lib/assimp/code/AssetLib/X3D/X3DXmlHelper.cpp
new file mode 100644
index 000000000..ff24b74b3
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/X3D/X3DXmlHelper.cpp
@@ -0,0 +1,294 @@
+#include "X3DXmlHelper.h"
+#include "X3DImporter.hpp"
+
+#include <assimp/ParsingUtils.h>
+
+namespace Assimp {
+
+bool X3DXmlHelper::getColor3DAttribute(XmlNode &node, const char *attributeName, aiColor3D &color) {
+    std::string val;
+    if (XmlParser::getStdStrAttribute(node, attributeName, val)) {
+        std::vector<std::string> values;
+        tokenize<std::string>(val, values, " ");
+        if (values.size() != 3) {
+            Throw_ConvertFail_Str2ArrF(node.name(), attributeName);
+            return false;
+        }
+        auto it = values.begin();
+        color.r = stof(*it++);
+        color.g = stof(*it++);
+        color.b = stof(*it);
+        return true;
+    }
+    return false;
+}
+
+bool X3DXmlHelper::getVector2DAttribute(XmlNode &node, const char *attributeName, aiVector2D &color) {
+    std::string val;
+    if (XmlParser::getStdStrAttribute(node, attributeName, val)) {
+        std::vector<std::string> values;
+        tokenize<std::string>(val, values, " ");
+        if (values.size() != 2) {
+            Throw_ConvertFail_Str2ArrF(node.name(), attributeName);
+            return false;
+        }
+        auto it = values.begin();
+        color.x = stof(*it++);
+        color.y = stof(*it);
+        return true;
+    }
+    return false;
+}
+
+bool X3DXmlHelper::getVector3DAttribute(XmlNode &node, const char *attributeName, aiVector3D &color) {
+    std::string val;
+    if (XmlParser::getStdStrAttribute(node, attributeName, val)) {
+        std::vector<std::string> values;
+        tokenize<std::string>(val, values, " ");
+        if (values.size() != 3) {
+            Throw_ConvertFail_Str2ArrF(node.name(), attributeName);
+            return false;
+        }
+        auto it = values.begin();
+        color.x = stof(*it++);
+        color.y = stof(*it++);
+        color.z = stof(*it);
+        return true;
+    }
+    return false;
+}
+
+bool X3DXmlHelper::getBooleanArrayAttribute(XmlNode &node, const char *attributeName, std::vector<bool> &boolArray) {
+    std::string val;
+    if (XmlParser::getStdStrAttribute(node, attributeName, val)) {
+        std::vector<std::string> values;
+        tokenize<std::string>(val, values, " ");
+        auto it = values.begin();
+        while (it != values.end()) {
+            auto s = *it++;
+            if (!s.empty())
+                boolArray.push_back(s[0] == 't' || s[0] == '1');
+            else
+                Throw_ConvertFail_Str2ArrB(node.name(), attributeName);
+        }
+        return true;
+    }
+    return false;
+}
+
+bool X3DXmlHelper::getDoubleArrayAttribute(XmlNode &node, const char *attributeName, std::vector<double> &doubleArray) {
+    std::string val;
+    if (XmlParser::getStdStrAttribute(node, attributeName, val)) {
+        std::vector<std::string> values;
+        tokenize<std::string>(val, values, " ");
+        auto it = values.begin();
+        while (it != values.end()) {
+            auto s = *it++;
+            if (!s.empty())
+                doubleArray.push_back(atof(s.c_str()));
+            else
+                Throw_ConvertFail_Str2ArrD(node.name(), attributeName);
+        }
+        return true;
+    }
+    return false;
+}
+
+bool X3DXmlHelper::getFloatArrayAttribute(XmlNode &node, const char *attributeName, std::vector<float> &floatArray) {
+    std::string val;
+    if (XmlParser::getStdStrAttribute(node, attributeName, val)) {
+        std::vector<std::string> values;
+        tokenize<std::string>(val, values, " ");
+        auto it = values.begin();
+        while (it != values.end()) {
+            auto s = *it++;
+            if (!s.empty())
+                floatArray.push_back((float)atof(s.c_str()));
+            else
+                Throw_ConvertFail_Str2ArrF(node.name(), attributeName);
+        }
+        return true;
+    }
+    return false;
+}
+
+bool X3DXmlHelper::getInt32ArrayAttribute(XmlNode &node, const char *attributeName, std::vector<int32_t> &intArray) {
+    std::string val;
+    if (XmlParser::getStdStrAttribute(node, attributeName, val)) {
+        std::vector<std::string> values;
+        tokenize<std::string>(val, values, " ");
+        auto it = values.begin();
+        while (it != values.end()) {
+            auto s = *it++;
+            if (!s.empty())
+                intArray.push_back((int32_t)atof(s.c_str()));
+            else
+                Throw_ConvertFail_Str2ArrI(node.name(), attributeName);
+        }
+        return true;
+    }
+    return false;
+}
+
+bool X3DXmlHelper::getStringListAttribute(XmlNode &node, const char *attributeName, std::list<std::string> &stringList) {
+    std::string val;
+    if (XmlParser::getStdStrAttribute(node, attributeName, val)) {
+        std::vector<std::string> values;
+        tokenize<std::string>(val, values, " ");
+        auto it = values.begin();
+        std::string currentConcat = "";
+        bool inQuotes = false;
+        while (it != values.end()) {
+            auto s = *it++;
+            if (!s.empty()) {
+                if (inQuotes) {
+                    if (*(s.rbegin()) == '"') {
+                        stringList.push_back(currentConcat + s.substr(0, s.length() - 1));
+                        currentConcat = "";
+                        inQuotes = false;
+                    } else {
+                        currentConcat += " " + s;
+                    }
+                } else {
+                    if (s[0] == '"') {
+                        currentConcat = s.substr(1);
+                        inQuotes = true;
+                    } else {
+                        stringList.push_back(s);
+                    }
+                }
+            } else if (!inQuotes)
+                Throw_ConvertFail_Str2ArrI(node.name(), attributeName);
+        }
+        if (inQuotes) Throw_ConvertFail_Str2ArrI(node.name(), attributeName);
+        return true;
+    }
+    return false;
+}
+
+bool X3DXmlHelper::getStringArrayAttribute(XmlNode &node, const char *attributeName, std::vector<std::string> &stringArray) {
+    std::list<std::string> tlist;
+
+    if (getStringListAttribute(node, attributeName, tlist)) {
+        if (!tlist.empty()) {
+            stringArray.reserve(tlist.size());
+            for (std::list<std::string>::iterator it = tlist.begin(); it != tlist.end(); ++it) {
+                stringArray.push_back(*it);
+            }
+            return true;
+        }
+    }
+    return false;
+}
+
+bool X3DXmlHelper::getVector2DListAttribute(XmlNode &node, const char *attributeName, std::list<aiVector2D> &vectorList) {
+    std::string val;
+    if (XmlParser::getStdStrAttribute(node, attributeName, val)) {
+        std::vector<std::string> values;
+        tokenize<std::string>(val, values, " ");
+        if (values.size() % 2) Throw_ConvertFail_Str2ArrF(node.name(), attributeName);
+        auto it = values.begin();
+        while (it != values.end()) {
+            aiVector2D tvec;
+
+            tvec.x = (float)atof((*it++).c_str());
+            tvec.y = (float)atof((*it++).c_str());
+            vectorList.push_back(tvec);
+        }
+        return true;
+    }
+    return false;
+}
+
+bool X3DXmlHelper::getVector2DArrayAttribute(XmlNode &node, const char *attributeName, std::vector<aiVector2D> &vectorArray) {
+    std::list<aiVector2D> tlist;
+
+    if (getVector2DListAttribute(node, attributeName, tlist)) {
+        if (!tlist.empty()) {
+            vectorArray.reserve(tlist.size());
+            for (std::list<aiVector2D>::iterator it = tlist.begin(); it != tlist.end(); ++it) {
+                vectorArray.push_back(*it);
+            }
+            return true;
+        }
+    }
+    return false;
+}
+
+bool X3DXmlHelper::getVector3DListAttribute(XmlNode &node, const char *attributeName, std::list<aiVector3D> &vectorList) {
+    std::string val;
+    if (XmlParser::getStdStrAttribute(node, attributeName, val)) {
+        std::vector<std::string> values;
+        tokenize<std::string>(val, values, " ");
+        if (values.size() % 3 != 0) Throw_ConvertFail_Str2ArrF(node.name(), attributeName);
+        auto it = values.begin();
+        while (it != values.end()) {
+            aiVector3D tvec;
+
+            tvec.x = (float)atof((*it++).c_str());
+            tvec.y = (float)atof((*it++).c_str());
+            tvec.z = (float)atof((*it++).c_str());
+            vectorList.push_back(tvec);
+        }
+        return true;
+    }
+    return false;
+}
+
+bool X3DXmlHelper::getVector3DArrayAttribute(XmlNode &node, const char *attributeName, std::vector<aiVector3D> &vectorArray) {
+    std::list<aiVector3D> tlist;
+
+    if (getVector3DListAttribute(node, attributeName, tlist)) {
+        if (!tlist.empty()) {
+            vectorArray.reserve(tlist.size());
+            for (std::list<aiVector3D>::iterator it = tlist.begin(); it != tlist.end(); ++it) {
+                vectorArray.push_back(*it);
+            }
+            return true;
+        }
+    }
+    return false;
+}
+
+bool X3DXmlHelper::getColor3DListAttribute(XmlNode &node, const char *attributeName, std::list<aiColor3D> &colorList) {
+    std::string val;
+    if (XmlParser::getStdStrAttribute(node, attributeName, val)) {
+        std::vector<std::string> values;
+        tokenize<std::string>(val, values, " ");
+        if (values.size() % 3 != 0) Throw_ConvertFail_Str2ArrF(node.name(), attributeName);
+        auto it = values.begin();
+        while (it != values.end()) {
+            aiColor3D tvec;
+
+            tvec.r = (float)atof((*it++).c_str());
+            tvec.g = (float)atof((*it++).c_str());
+            tvec.b = (float)atof((*it++).c_str());
+            colorList.push_back(tvec);
+        }
+        return true;
+    }
+    return false;
+}
+
+bool X3DXmlHelper::getColor4DListAttribute(XmlNode &node, const char *attributeName, std::list<aiColor4D> &colorList) {
+    std::string val;
+    if (XmlParser::getStdStrAttribute(node, attributeName, val)) {
+        std::vector<std::string> values;
+        tokenize<std::string>(val, values, " ");
+        if (values.size() % 4 != 0) Throw_ConvertFail_Str2ArrF(node.name(), attributeName);
+        auto it = values.begin();
+        while (it != values.end()) {
+            aiColor4D tvec;
+
+            tvec.r = (float)atof((*it++).c_str());
+            tvec.g = (float)atof((*it++).c_str());
+            tvec.b = (float)atof((*it++).c_str());
+            tvec.a = (float)atof((*it++).c_str());
+            colorList.push_back(tvec);
+        }
+        return true;
+    }
+    return false;
+}
+
+} // namespace Assimp
diff --git a/Engine/lib/assimp/code/AssetLib/X3D/X3DXmlHelper.h b/Engine/lib/assimp/code/AssetLib/X3D/X3DXmlHelper.h
new file mode 100644
index 000000000..dd305f883
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/X3D/X3DXmlHelper.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <assimp/XmlParser.h>
+#include <assimp/types.h>
+#include <list>
+
+namespace Assimp {
+
+class X3DXmlHelper {
+public:
+    static bool getColor3DAttribute(XmlNode &node, const char *attributeName, aiColor3D &color);
+    static bool getVector2DAttribute(XmlNode &node, const char *attributeName, aiVector2D &vector);
+    static bool getVector3DAttribute(XmlNode &node, const char *attributeName, aiVector3D &vector);
+
+    static bool getBooleanArrayAttribute(XmlNode &node, const char *attributeName, std::vector<bool> &boolArray);
+    static bool getDoubleArrayAttribute(XmlNode &node, const char *attributeName, std::vector<double> &doubleArray);
+    static bool getFloatArrayAttribute(XmlNode &node, const char *attributeName, std::vector<float> &floatArray);
+    static bool getInt32ArrayAttribute(XmlNode &node, const char *attributeName, std::vector<int32_t> &intArray);
+    static bool getStringListAttribute(XmlNode &node, const char *attributeName, std::list<std::string> &stringArray);
+    static bool getStringArrayAttribute(XmlNode &node, const char *attributeName, std::vector<std::string> &stringArray);
+
+    static bool getVector2DListAttribute(XmlNode &node, const char *attributeName, std::list<aiVector2D> &vectorList);
+    static bool getVector2DArrayAttribute(XmlNode &node, const char *attributeName, std::vector<aiVector2D> &vectorArray);
+    static bool getVector3DListAttribute(XmlNode &node, const char *attributeName, std::list<aiVector3D> &vectorList);
+    static bool getVector3DArrayAttribute(XmlNode &node, const char *attributeName, std::vector<aiVector3D> &vectorArray);
+    static bool getColor3DListAttribute(XmlNode &node, const char *attributeName, std::list<aiColor3D> &colorList);
+    static bool getColor4DListAttribute(XmlNode &node, const char *attributeName, std::list<aiColor4D> &colorList);
+};
+
+} // namespace Assimp
diff --git a/Engine/lib/assimp/code/AssetLib/XGL/XGLLoader.cpp b/Engine/lib/assimp/code/AssetLib/XGL/XGLLoader.cpp
new file mode 100644
index 000000000..154af9854
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/XGL/XGLLoader.cpp
@@ -0,0 +1,787 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file Implementation of the XGL/ZGL importer class */
+
+#ifndef ASSIMP_BUILD_NO_XGL_IMPORTER
+
+#include "XGLLoader.h"
+#include "Common/Compression.h"
+
+#include <assimp/ParsingUtils.h>
+#include <assimp/fast_atof.h>
+#include <assimp/MemoryIOWrapper.h>
+#include <assimp/StreamReader.h>
+#include <assimp/importerdesc.h>
+#include <assimp/mesh.h>
+#include <assimp/scene.h>
+//#include <cctype>
+//#include <memory>
+
+using namespace Assimp;
+
+namespace Assimp { // this has to be in here because LogFunctions is in ::Assimp
+
+template <>
+const char *LogFunctions<XGLImporter>::Prefix() {
+    static auto prefix = "XGL: ";
+	return prefix;
+}
+
+} // namespace Assimp
+
+static const aiImporterDesc desc = {
+	"XGL Importer",
+	"",
+	"",
+	"",
+	aiImporterFlags_SupportTextFlavour | aiImporterFlags_SupportCompressedFlavour,
+	0,
+	0,
+	0,
+	0,
+	"xgl zgl"
+};
+
+// ------------------------------------------------------------------------------------------------
+// Constructor to be privately used by Importer
+XGLImporter::XGLImporter() :
+        mXmlParser(nullptr),
+        m_scene(nullptr) {
+    // empty
+}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor, private as well
+XGLImporter::~XGLImporter() {
+	delete mXmlParser;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Returns whether the class can handle the format of the given file.
+bool XGLImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
+	static const char *tokens[] = { "<world>", "<World>", "<WORLD>" };
+	return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
+}
+
+// ------------------------------------------------------------------------------------------------
+// Get a list of all file extensions which are handled by this class
+const aiImporterDesc *XGLImporter::GetInfo() const {
+	return &desc;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Imports the given file into the given scene structure.
+void XGLImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
+ #ifndef ASSIMP_BUILD_NO_COMPRESSED_XGL
+	std::vector<char> uncompressed;
+#endif
+
+	m_scene = pScene;
+	std::shared_ptr<IOStream> stream(pIOHandler->Open(pFile, "rb"));
+
+	// check whether we can read from the file
+	if (stream.get() == NULL) {
+		throw DeadlyImportError("Failed to open XGL/ZGL file " + pFile);
+	}
+
+	// see if its compressed, if so uncompress it
+	if (GetExtension(pFile) == "zgl") {
+#ifdef ASSIMP_BUILD_NO_COMPRESSED_XGL
+		ThrowException("Cannot read ZGL file since Assimp was built without compression support");
+#else
+		std::unique_ptr<StreamReaderLE> raw_reader(new StreamReaderLE(stream));
+
+        Compression compression;
+        size_t total = 0l;
+        if (compression.open(Compression::Format::Binary, Compression::FlushMode::NoFlush, -Compression::MaxWBits)) {
+            // skip two extra bytes, zgl files do carry a crc16 upfront (I think)
+            raw_reader->IncPtr(2);
+            total = compression.decompress((unsigned char *)raw_reader->GetPtr(), raw_reader->GetRemainingSize(), uncompressed);
+            compression.close();
+        }
+		// replace the input stream with a memory stream
+		stream.reset(new MemoryIOStream(reinterpret_cast<uint8_t*>(uncompressed.data()), total));
+#endif
+	}
+
+	// parse the XML file
+    mXmlParser = new XmlParser;
+    if (!mXmlParser->parse(stream.get())) {
+        throw DeadlyImportError("XML parse error while loading XGL file ", pFile);
+	}
+
+	TempScope scope;
+    XmlNode *worldNode = mXmlParser->findNode("WORLD");
+    if (nullptr != worldNode) {
+		ReadWorld(*worldNode, scope);
+	}
+
+	std::vector<aiMesh *> &meshes = scope.meshes_linear;
+	std::vector<aiMaterial *> &materials = scope.materials_linear;
+	if (!meshes.size() || !materials.size()) {
+		ThrowException("failed to extract data from XGL file, no meshes loaded");
+	}
+
+	// copy meshes
+	m_scene->mNumMeshes = static_cast<unsigned int>(meshes.size());
+	m_scene->mMeshes = new aiMesh *[m_scene->mNumMeshes]();
+	std::copy(meshes.begin(), meshes.end(), m_scene->mMeshes);
+
+	// copy materials
+	m_scene->mNumMaterials = static_cast<unsigned int>(materials.size());
+	m_scene->mMaterials = new aiMaterial *[m_scene->mNumMaterials]();
+	std::copy(materials.begin(), materials.end(), m_scene->mMaterials);
+
+	if (scope.light) {
+		m_scene->mNumLights = 1;
+		m_scene->mLights = new aiLight *[1];
+		m_scene->mLights[0] = scope.light;
+
+		scope.light->mName = m_scene->mRootNode->mName;
+	}
+
+	scope.dismiss();
+}
+
+// ------------------------------------------------------------------------------------------------
+void XGLImporter::ReadWorld(XmlNode &node, TempScope &scope) {
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &s = ai_stdStrToLower(currentNode.name());
+
+		// XXX right now we'd skip <lighting> if it comes after
+		// <object> or <mesh>
+		if (s == "lighting") {
+            ReadLighting(currentNode, scope);
+		} else if (s == "object" || s == "mesh" || s == "mat") {
+			break;
+		}
+	}
+
+	aiNode *const nd = ReadObject(node, scope);
+	if (!nd) {
+		ThrowException("failure reading <world>");
+	}
+	if (nd->mName.length == 0) {
+		nd->mName.Set("WORLD");
+	}
+
+	m_scene->mRootNode = nd;
+}
+
+// ------------------------------------------------------------------------------------------------
+void XGLImporter::ReadLighting(XmlNode &node, TempScope &scope) {
+    const std::string &s = ai_stdStrToLower(node.name());
+	if (s == "directionallight") {
+		scope.light = ReadDirectionalLight(node);
+	} else if (s == "ambient") {
+		LogWarn("ignoring <ambient> tag");
+	} else if (s == "spheremap") {
+		LogWarn("ignoring <spheremap> tag");
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+aiLight *XGLImporter::ReadDirectionalLight(XmlNode &node) {
+	std::unique_ptr<aiLight> l(new aiLight());
+	l->mType = aiLightSource_DIRECTIONAL;
+	find_node_by_name_predicate predicate("directionallight");
+	XmlNode child = node.find_child(predicate);
+	if (child.empty()) {
+		return nullptr;
+	}
+
+	const std::string &s = ai_stdStrToLower(child.name());
+	if (s == "direction") {
+		l->mDirection = ReadVec3(child);
+	} else if (s == "diffuse") {
+		l->mColorDiffuse = ReadCol3(child);
+	} else if (s == "specular") {
+		l->mColorSpecular = ReadCol3(child);
+	}
+
+	return l.release();
+}
+
+// ------------------------------------------------------------------------------------------------
+aiNode *XGLImporter::ReadObject(XmlNode &node, TempScope &scope) {
+	aiNode *nd = new aiNode;
+	std::vector<aiNode *> children;
+	std::vector<unsigned int> meshes;
+
+	try {
+		for (XmlNode &child : node.children()) {
+			const std::string &s = ai_stdStrToLower(child.name());
+			if (s == "mesh") {
+				const size_t prev = scope.meshes_linear.size();
+                bool empty;
+				if (ReadMesh(child, scope, empty)) {
+					const size_t newc = scope.meshes_linear.size();
+					for (size_t i = 0; i < newc - prev; ++i) {
+						meshes.push_back(static_cast<unsigned int>(i + prev));
+					}
+				}
+			} else if (s == "mat") {
+				ReadMaterial(child, scope);
+			} else if (s == "object") {
+				children.push_back(ReadObject(child, scope));
+			} else if (s == "objectref") {
+				// XXX
+			} else if (s == "meshref") {
+				const unsigned int id = static_cast<unsigned int>(ReadIndexFromText(child));
+
+				std::multimap<unsigned int, aiMesh *>::iterator it = scope.meshes.find(id), end = scope.meshes.end();
+				if (it == end) {
+					ThrowException("<meshref> index out of range");
+				}
+
+				for (; it != end && (*it).first == id; ++it) {
+					// ok, this is n^2 and should get optimized one day
+					aiMesh *const m = it->second;
+					unsigned int i = 0, mcount = static_cast<unsigned int>(scope.meshes_linear.size());
+					for (; i < mcount; ++i) {
+						if (scope.meshes_linear[i] == m) {
+							meshes.push_back(i);
+							break;
+						}
+					}
+
+					ai_assert(i < mcount);
+				}
+			} else if (s == "transform") {
+				nd->mTransformation = ReadTrafo(child);
+			}
+		}
+	} catch (...) {
+		for (aiNode *ch : children) {
+			delete ch;
+		}
+		throw;
+	}
+
+	// FIX: since we used std::multimap<> to keep meshes by id, mesh order now depends on the behaviour
+	// of the multimap implementation with respect to the ordering of entries with same values.
+	// C++11 gives the guarantee that it uses insertion order, before it is implementation-specific.
+	// Sort by material id to always guarantee a deterministic result.
+	std::sort(meshes.begin(), meshes.end(), SortMeshByMaterialId(scope));
+
+	// link meshes to node
+	nd->mNumMeshes = static_cast<unsigned int>(meshes.size());
+	if (0 != nd->mNumMeshes) {
+		nd->mMeshes = new unsigned int[nd->mNumMeshes]();
+		for (unsigned int i = 0; i < nd->mNumMeshes; ++i) {
+			nd->mMeshes[i] = meshes[i];
+		}
+	}
+
+	// link children to parent
+	nd->mNumChildren = static_cast<unsigned int>(children.size());
+	if (nd->mNumChildren) {
+		nd->mChildren = new aiNode *[nd->mNumChildren]();
+		for (unsigned int i = 0; i < nd->mNumChildren; ++i) {
+			nd->mChildren[i] = children[i];
+			children[i]->mParent = nd;
+		}
+	}
+
+	return nd;
+}
+
+// ------------------------------------------------------------------------------------------------
+aiMatrix4x4 XGLImporter::ReadTrafo(XmlNode &node) {
+	aiVector3D forward, up, right, position;
+	float scale = 1.0f;
+
+	aiMatrix4x4 m;
+	XmlNode child = node.child("TRANSFORM");
+	if (child.empty()) {
+		return m;
+	}
+
+	for (XmlNode &sub_child : child.children()) {
+        const std::string &s = ai_stdStrToLower(sub_child.name());
+		if (s == "forward") {
+			forward = ReadVec3(sub_child);
+		} else if (s == "up") {
+			up = ReadVec3(sub_child);
+		} else if (s == "position") {
+			position = ReadVec3(sub_child);
+		}
+		if (s == "scale") {
+			scale = ReadFloat(sub_child);
+			if (scale < 0.f) {
+				// this is wrong, but we can leave the value and pass it to the caller
+				LogError("found negative scaling in <transform>, ignoring");
+			}
+		}
+	}
+
+    if (forward.SquareLength() < 1e-4 || up.SquareLength() < 1e-4) {
+	    LogError("A direction vector in <transform> is zero, ignoring trafo");
+	    return m;
+    }
+
+    forward.Normalize();
+    up.Normalize();
+
+    right = forward ^ up;
+    if (std::fabs(up * forward) > 1e-4) {
+	    // this is definitely wrong - a degenerate coordinate space ruins everything
+	    // so substitute identity transform.
+	    LogError("<forward> and <up> vectors in <transform> are skewing, ignoring trafo");
+	    return m;
+    }
+
+    right *= scale;
+    up *= scale;
+    forward *= scale;
+
+    m.a1 = right.x;
+    m.b1 = right.y;
+    m.c1 = right.z;
+
+    m.a2 = up.x;
+    m.b2 = up.y;
+    m.c2 = up.z;
+
+    m.a3 = forward.x;
+    m.b3 = forward.y;
+    m.c3 = forward.z;
+
+    m.a4 = position.x;
+    m.b4 = position.y;
+    m.c4 = position.z;
+
+	return m;
+}
+
+// ------------------------------------------------------------------------------------------------
+aiMesh *XGLImporter::ToOutputMesh(const TempMaterialMesh &m) {
+	std::unique_ptr<aiMesh> mesh(new aiMesh());
+
+	mesh->mNumVertices = static_cast<unsigned int>(m.positions.size());
+	mesh->mVertices = new aiVector3D[mesh->mNumVertices];
+	std::copy(m.positions.begin(), m.positions.end(), mesh->mVertices);
+
+	if (!m.normals.empty()) {
+		mesh->mNormals = new aiVector3D[mesh->mNumVertices];
+		std::copy(m.normals.begin(), m.normals.end(), mesh->mNormals);
+	}
+
+	if (!m.uvs.empty()) {
+		mesh->mNumUVComponents[0] = 2;
+		mesh->mTextureCoords[0] = new aiVector3D[mesh->mNumVertices];
+
+		for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
+			mesh->mTextureCoords[0][i] = aiVector3D(m.uvs[i].x, m.uvs[i].y, 0.f);
+		}
+	}
+
+	mesh->mNumFaces = static_cast<unsigned int>(m.vcounts.size());
+	mesh->mFaces = new aiFace[m.vcounts.size()];
+
+	unsigned int idx = 0;
+	for (unsigned int i = 0; i < mesh->mNumFaces; ++i) {
+		aiFace &f = mesh->mFaces[i];
+		f.mNumIndices = m.vcounts[i];
+		f.mIndices = new unsigned int[f.mNumIndices];
+		for (unsigned int c = 0; c < f.mNumIndices; ++c) {
+			f.mIndices[c] = idx++;
+		}
+	}
+
+	ai_assert(idx == mesh->mNumVertices);
+
+	mesh->mPrimitiveTypes = m.pflags;
+	mesh->mMaterialIndex = m.matid;
+
+    return mesh.release();
+}
+
+// ------------------------------------------------------------------------------------------------
+bool XGLImporter::ReadMesh(XmlNode &node, TempScope &scope, bool &empty) {
+	TempMesh t;
+
+	std::map<unsigned int, TempMaterialMesh> bymat;
+    const unsigned int mesh_id = ReadIDAttr(node);
+    bool empty_mesh = true;
+	for (XmlNode &child : node.children()) {
+        const std::string &s = ai_stdStrToLower(child.name());
+
+		if (s == "mat") {
+			ReadMaterial(child, scope);
+		} else if (s == "p") {
+			pugi::xml_attribute attr = child.attribute("ID");
+			if (attr.empty()) {
+				LogWarn("no ID attribute on <p>, ignoring");
+			} else {
+				int id = attr.as_int();
+				t.points[id] = ReadVec3(child);
+			}
+		} else if (s == "n") {
+			pugi::xml_attribute attr = child.attribute("ID");
+			if (attr.empty()) {
+				LogWarn("no ID attribute on <n>, ignoring");
+			} else {
+				int id = attr.as_int();
+				t.normals[id] = ReadVec3(child);
+			}
+		} else if (s == "tc") {
+			pugi::xml_attribute attr = child.attribute("ID");
+			if (attr.empty()) {
+				LogWarn("no ID attribute on <tc>, ignoring");
+			} else {
+				int id = attr.as_int();
+				t.uvs[id] = ReadVec2(child);
+			}
+		} else if (s == "f" || s == "l" || s == "p") {
+			const unsigned int vcount = s == "f" ? 3 : (s == "l" ? 2 : 1);
+
+			unsigned int mid = ~0u;
+			TempFace tf[3];
+			bool has[3] = { false };
+			for (XmlNode &sub_child : child.children()) {
+                const std::string &scn = ai_stdStrToLower(sub_child.name());
+                if (scn == "fv1" || scn == "lv1" || scn == "pv1") {
+					ReadFaceVertex(sub_child, t, tf[0]);
+					has[0] = true;
+                } else if (scn == "fv2" || scn == "lv2") {
+					ReadFaceVertex(sub_child, t, tf[1]);
+					has[1] = true;
+                } else if (scn == "fv3") {
+					ReadFaceVertex(sub_child, t, tf[2]);
+					has[2] = true;
+                } else if (scn == "mat") {
+					if (mid != ~0u) {
+						LogWarn("only one material tag allowed per <f>");
+					}
+					mid = ResolveMaterialRef(sub_child, scope);
+                } else if (scn == "matref") {
+					if (mid != ~0u) {
+						LogWarn("only one material tag allowed per <f>");
+					}
+					mid = ResolveMaterialRef(sub_child, scope);
+				}
+			}
+            if (has[0] || has[1] || has[2]) {
+                empty_mesh = false;
+            }
+
+			if (mid == ~0u) {
+				ThrowException("missing material index");
+			}
+
+			bool nor = false;
+			bool uv = false;
+			for (unsigned int i = 0; i < vcount; ++i) {
+				if (!has[i]) {
+					ThrowException("missing face vertex data");
+				}
+
+				nor = nor || tf[i].has_normal;
+				uv = uv || tf[i].has_uv;
+			}
+
+			if (mid >= (1 << 30)) {
+				LogWarn("material indices exhausted, this may cause errors in the output");
+			}
+			unsigned int meshId = mid | ((nor ? 1 : 0) << 31) | ((uv ? 1 : 0) << 30);
+
+			TempMaterialMesh &mesh = bymat[meshId];
+			mesh.matid = mid;
+
+			for (unsigned int i = 0; i < vcount; ++i) {
+				mesh.positions.push_back(tf[i].pos);
+				if (nor) {
+					mesh.normals.push_back(tf[i].normal);
+				}
+				if (uv) {
+					mesh.uvs.push_back(tf[i].uv);
+				}
+
+				mesh.pflags |= 1 << (vcount - 1);
+			}
+
+			mesh.vcounts.push_back(vcount);
+		}
+	}
+
+	// finally extract output meshes and add them to the scope
+	using pairt = std::pair<const unsigned int, TempMaterialMesh>;
+	for (const pairt &p : bymat) {
+		aiMesh *const m = ToOutputMesh(p.second);
+		scope.meshes_linear.push_back(m);
+
+		// if this is a definition, keep it on the stack
+		if (mesh_id != ~0u) {
+			scope.meshes.insert(std::pair<unsigned int, aiMesh *>(mesh_id, m));
+		}
+	}
+    if (empty_mesh) {
+        LogWarn("Mesh is empty, skipping.");
+        empty = empty_mesh;
+        return false;
+    }
+
+	// no id == not a reference, insert this mesh right *here*
+	return mesh_id == ~0u;
+}
+
+// ----------------------------------------------------------------------------------------------
+unsigned int XGLImporter::ResolveMaterialRef(XmlNode &node, TempScope &scope) {
+	const std::string &s = node.name();
+	if (s == "mat") {
+		ReadMaterial(node, scope);
+		return static_cast<unsigned int>(scope.materials_linear.size() - 1);
+	}
+
+	const int id = ReadIndexFromText(node);
+
+	auto it = scope.materials.find(id), end = scope.materials.end();
+	if (it == end) {
+		ThrowException("<matref> index out of range");
+	}
+
+	// ok, this is n^2 and should get optimized one day
+	aiMaterial *const m = it->second;
+
+	unsigned int i = 0, mcount = static_cast<unsigned int>(scope.materials_linear.size());
+	for (; i < mcount; ++i) {
+		if (scope.materials_linear[i] == m) {
+			return i;
+		}
+	}
+
+	ai_assert(false);
+
+	return 0;
+}
+
+// ------------------------------------------------------------------------------------------------
+void XGLImporter::ReadMaterial(XmlNode &node, TempScope &scope) {
+    const unsigned int mat_id = ReadIDAttr(node);
+
+	auto *mat(new aiMaterial);
+	for (XmlNode &child : node.children()) {
+        const std::string &s = ai_stdStrToLower(child.name());
+		if (s == "amb") {
+			const aiColor3D c = ReadCol3(child);
+			mat->AddProperty(&c, 1, AI_MATKEY_COLOR_AMBIENT);
+		} else if (s == "diff") {
+			const aiColor3D c = ReadCol3(child);
+			mat->AddProperty(&c, 1, AI_MATKEY_COLOR_DIFFUSE);
+		} else if (s == "spec") {
+			const aiColor3D c = ReadCol3(child);
+			mat->AddProperty(&c, 1, AI_MATKEY_COLOR_SPECULAR);
+		} else if (s == "emiss") {
+			const aiColor3D c = ReadCol3(child);
+			mat->AddProperty(&c, 1, AI_MATKEY_COLOR_EMISSIVE);
+		} else if (s == "alpha") {
+			const float f = ReadFloat(child);
+			mat->AddProperty(&f, 1, AI_MATKEY_OPACITY);
+		} else if (s == "shine") {
+			const float f = ReadFloat(child);
+			mat->AddProperty(&f, 1, AI_MATKEY_SHININESS);
+		}
+	}
+
+	scope.materials[mat_id] = mat;
+	scope.materials_linear.push_back(mat);
+}
+
+// ----------------------------------------------------------------------------------------------
+void XGLImporter::ReadFaceVertex(XmlNode &node, const TempMesh &t, TempFace &out) {
+	bool havep = false;
+	for (XmlNode &child : node.children()) {
+        const std::string &s = ai_stdStrToLower(child.name());
+		if (s == "pref") {
+			const unsigned int id = ReadIndexFromText(child);
+			std::map<unsigned int, aiVector3D>::const_iterator it = t.points.find(id);
+			if (it == t.points.end()) {
+				ThrowException("point index out of range");
+			}
+
+			out.pos = (*it).second;
+			havep = true;
+		} else if (s == "nref") {
+			const unsigned int id = ReadIndexFromText(child);
+			std::map<unsigned int, aiVector3D>::const_iterator it = t.normals.find(id);
+			if (it == t.normals.end()) {
+				ThrowException("normal index out of range");
+			}
+
+			out.normal = (*it).second;
+			out.has_normal = true;
+		} else if (s == "tcref") {
+			const unsigned int id = ReadIndexFromText(child);
+			std::map<unsigned int, aiVector2D>::const_iterator it = t.uvs.find(id);
+			if (it == t.uvs.end()) {
+				ThrowException("uv index out of range");
+			}
+
+			out.uv = (*it).second;
+			out.has_uv = true;
+		} else if (s == "p") {
+			out.pos = ReadVec3(child);
+		} else if (s == "n") {
+			out.normal = ReadVec3(child);
+		} else if (s == "tc") {
+			out.uv = ReadVec2(child);
+		}
+	}
+
+	if (!havep) {
+		ThrowException("missing <pref> in <fvN> element");
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+unsigned int XGLImporter::ReadIDAttr(XmlNode &node) {
+	for (pugi::xml_attribute attr : node.attributes()) {
+		if (!ASSIMP_stricmp(attr.name(), "id")) {
+			return attr.as_int();
+		}
+	}
+
+	return ~0u;
+}
+
+// ------------------------------------------------------------------------------------------------
+float XGLImporter::ReadFloat(XmlNode &node) {
+    std::string v;
+    XmlParser::getValueAsString(node, v);
+    const char *s = v.c_str(), *se;
+	if (!SkipSpaces(&s)) {
+		LogError("unexpected EOL, failed to parse index element");
+		return 0.f;
+	}
+	float t;
+	se = fast_atoreal_move(s, t);
+	if (se == s) {
+		LogError("failed to read float text");
+		return 0.f;
+	}
+
+	return t;
+}
+
+// ------------------------------------------------------------------------------------------------
+unsigned int XGLImporter::ReadIndexFromText(XmlNode &node) {
+    std::string v;
+    XmlParser::getValueAsString(node, v);
+    const char *s = v.c_str();
+	if (!SkipSpaces(&s)) {
+		LogError("unexpected EOL, failed to parse index element");
+		return ~0u;
+	}
+	const char *se;
+	const unsigned int t = strtoul10(s, &se);
+
+	if (se == s) {
+		LogError("failed to read index");
+		return ~0u;
+	}
+
+	return t;
+}
+
+// ------------------------------------------------------------------------------------------------
+aiVector2D XGLImporter::ReadVec2(XmlNode &node) {
+	aiVector2D vec;
+    std::string val;
+    XmlParser::getValueAsString(node, val);
+    const char *s = val.c_str();
+    ai_real v[2] = {};
+	for (int i = 0; i < 2; ++i) {
+		if (!SkipSpaces(&s)) {
+			LogError("unexpected EOL, failed to parse vec2");
+			return vec;
+		}
+
+		v[i] = fast_atof(&s);
+
+		SkipSpaces(&s);
+		if (i != 1 && *s != ',') {
+			LogError("expected comma, failed to parse vec2");
+			return vec;
+		}
+		++s;
+	}
+	vec.x = v[0];
+	vec.y = v[1];
+
+	return vec;
+}
+
+// ------------------------------------------------------------------------------------------------
+aiVector3D XGLImporter::ReadVec3(XmlNode &node) {
+	aiVector3D vec;
+    std::string v;
+    XmlParser::getValueAsString(node, v);
+	const char *s = v.c_str();
+	for (int i = 0; i < 3; ++i) {
+		if (!SkipSpaces(&s)) {
+			LogError("unexpected EOL, failed to parse vec3");
+			return vec;
+		}
+		vec[i] = fast_atof(&s);
+
+		SkipSpaces(&s);
+		if (i != 2 && *s != ',') {
+			LogError("expected comma, failed to parse vec3");
+			return vec;
+		}
+		++s;
+	}
+
+	return vec;
+}
+
+// ------------------------------------------------------------------------------------------------
+aiColor3D XGLImporter::ReadCol3(XmlNode &node) {
+	const aiVector3D &v = ReadVec3(node);
+	if (v.x < 0.f || v.x > 1.0f || v.y < 0.f || v.y > 1.0f || v.z < 0.f || v.z > 1.0f) {
+		LogWarn("color values out of range, ignoring");
+	}
+	return aiColor3D(v.x, v.y, v.z);
+}
+
+#endif // ASSIMP_BUILD_NO_XGL_IMPORTER
diff --git a/Engine/lib/assimp/code/XGL/XGLLoader.h b/Engine/lib/assimp/code/AssetLib/XGL/XGLLoader.h
similarity index 63%
rename from Engine/lib/assimp/code/XGL/XGLLoader.h
rename to Engine/lib/assimp/code/AssetLib/XGL/XGLLoader.h
index bba2a643c..ae7ccddc2 100644
--- a/Engine/lib/assimp/code/XGL/XGLLoader.h
+++ b/Engine/lib/assimp/code/AssetLib/XGL/XGLLoader.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -47,69 +46,63 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define AI_XGLLOADER_H_INCLUDED
 
 #include <assimp/BaseImporter.h>
-#include <assimp/irrXMLWrapper.h>
+#include <assimp/XmlParser.h>
 #include <assimp/LogAux.h>
+#include <assimp/light.h>
 #include <assimp/material.h>
-#include <assimp/Importer.hpp>
 #include <assimp/mesh.h>
 #include <assimp/light.h>
-#include <memory>
+#include <assimp/Importer.hpp>
+#include <assimp/XmlParser.h>
+
 #include <map>
+#include <memory>
 
 struct aiNode;
 
-namespace Assimp    {
+namespace Assimp {
 
 // ---------------------------------------------------------------------------
 /** XGL/ZGL importer.
  *
  * Spec: http://vizstream.aveva.com/release/vsplatform/XGLSpec.htm
  */
-class XGLImporter : public BaseImporter, public LogFunctions<XGLImporter>
-{
+class XGLImporter : public BaseImporter, public LogFunctions<XGLImporter> {
 public:
-
     XGLImporter();
-    ~XGLImporter();
-
-
-public:
+    ~XGLImporter() override;
 
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
      *  See BaseImporter::CanRead() for details.    */
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
+            bool checkSig) const override;
 
 protected:
-
     // -------------------------------------------------------------------
     /** Return importer meta information.
      * See #BaseImporter::GetInfo for the details  */
-    const aiImporterDesc* GetInfo () const;
+    const aiImporterDesc *GetInfo() const override;
 
     // -------------------------------------------------------------------
     /** Imports the given file into the given scene structure.
      * See BaseImporter::InternReadFile() for details */
-    void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
+    void InternReadFile(const std::string &pFile, aiScene *pScene,
+            IOSystem *pIOHandler) override;
 
 private:
+    struct TempScope {
+        TempScope() :
+                light() {
+            // empty
+        }
 
-
-    struct TempScope
-    {
-        TempScope()
-            : light()
-        {}
-
-        ~TempScope()
-        {
-            for(aiMesh* m : meshes_linear) {
+        ~TempScope() {
+            for (aiMesh *m : meshes_linear) {
                 delete m;
             }
 
-            for(aiMaterial* m : materials_linear) {
+            for (aiMaterial *m : materials_linear) {
                 delete m;
             }
 
@@ -117,45 +110,46 @@ private:
         }
 
         void dismiss() {
-            light = NULL;
+            light = nullptr;
             meshes_linear.clear();
             materials_linear.clear();
             meshes.clear();
             materials.clear();
         }
 
-        std::multimap<unsigned int, aiMesh*> meshes;
-        std::map<unsigned int, aiMaterial*> materials;
+        std::multimap<unsigned int, aiMesh *> meshes;
+        std::map<unsigned int, aiMaterial *> materials;
 
-        std::vector<aiMesh*> meshes_linear;
-        std::vector<aiMaterial*> materials_linear;
+        std::vector<aiMesh *> meshes_linear;
+        std::vector<aiMaterial *> materials_linear;
 
-        aiLight* light;
+        aiLight *light;
     };
 
-
     struct SortMeshByMaterialId {
-        SortMeshByMaterialId(const TempScope& scope) : scope(scope) {}
+        SortMeshByMaterialId(const TempScope &scope) :
+                scope(scope) {
+            // empty
+        }
         bool operator()(unsigned int a, unsigned int b) const {
             return scope.meshes_linear[a]->mMaterialIndex < scope.meshes_linear[b]->mMaterialIndex;
         };
 
-        const TempScope& scope;
+        const TempScope &scope;
     };
 
-    struct TempMesh
-    {
+    struct TempMesh {
         std::map<unsigned int, aiVector3D> points;
         std::map<unsigned int, aiVector3D> normals;
         std::map<unsigned int, aiVector2D> uvs;
     };
 
-    struct TempMaterialMesh
-    {
-        TempMaterialMesh()
-            : pflags()
-            , matid()
-        {}
+    struct TempMaterialMesh {
+        TempMaterialMesh() :
+                pflags(),
+                matid() {
+            // empty
+        }
 
         std::vector<aiVector3D> positions, normals;
         std::vector<aiVector2D> uvs;
@@ -165,12 +159,12 @@ private:
         unsigned int matid;
     };
 
-    struct TempFace
-    {
-        TempFace()
-            : has_uv()
-            , has_normal()
-        {}
+    struct TempFace {
+        TempFace() :
+                has_uv(),
+                has_normal() {
+            // empty
+        }
 
         aiVector3D pos;
         aiVector3D normal;
@@ -180,35 +174,34 @@ private:
     };
 
 private:
-
     void Cleanup();
 
     std::string GetElementName();
     bool ReadElement();
-    bool ReadElementUpToClosing(const char* closetag);
+    bool ReadElementUpToClosing(const char *closetag);
     bool SkipToText();
-    unsigned int ReadIDAttr();
+    unsigned int ReadIDAttr(XmlNode &node);
 
-    void ReadWorld(TempScope& scope);
-    void ReadLighting(TempScope& scope);
-    aiLight* ReadDirectionalLight();
-    aiNode* ReadObject(TempScope& scope,bool skipFirst = false,const char* closetag = "object");
-    bool ReadMesh(TempScope& scope);
-    void ReadMaterial(TempScope& scope);
-    aiVector2D ReadVec2();
-    aiVector3D ReadVec3();
-    aiColor3D ReadCol3();
-    aiMatrix4x4 ReadTrafo();
-    unsigned int ReadIndexFromText();
-    float ReadFloat();
+    void ReadWorld(XmlNode &node, TempScope &scope);
+    void ReadLighting(XmlNode &node, TempScope &scope);
+    aiLight *ReadDirectionalLight(XmlNode &node);
+    aiNode *ReadObject(XmlNode &node, TempScope &scope);
+    bool ReadMesh(XmlNode &node, TempScope &scope, bool &empty);
+    void ReadMaterial(XmlNode &node, TempScope &scope);
+    aiVector2D ReadVec2(XmlNode &node);
+    aiVector3D ReadVec3(XmlNode &node);
+    aiColor3D ReadCol3(XmlNode &node);
+    aiMatrix4x4 ReadTrafo(XmlNode &node);
+    unsigned int ReadIndexFromText(XmlNode &node);
+    float ReadFloat(XmlNode &node);
 
-    aiMesh* ToOutputMesh(const TempMaterialMesh& m);
-    void ReadFaceVertex(const TempMesh& t, TempFace& out);
-    unsigned int ResolveMaterialRef(TempScope& scope);
+    aiMesh *ToOutputMesh(const TempMaterialMesh &m);
+    void ReadFaceVertex(XmlNode &node, const TempMesh &t, TempFace &out);
+    unsigned int ResolveMaterialRef(XmlNode &node, TempScope &scope);
 
 private:
-    std::shared_ptr<irr::io::IrrXMLReader> m_reader;
-    aiScene* m_scene;
+    XmlParser *mXmlParser;
+    aiScene *m_scene;
 };
 
 } // end of namespace Assimp
diff --git a/Engine/lib/assimp/code/AssetLib/glTF/glTFAsset.h b/Engine/lib/assimp/code/AssetLib/glTF/glTFAsset.h
new file mode 100644
index 000000000..1a42e9020
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/glTF/glTFAsset.h
@@ -0,0 +1,1017 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file glTFAsset.h
+ * Declares a glTF class to handle gltf/glb files
+ *
+ * glTF Extensions Support:
+ *   KHR_binary_glTF: full
+ *   KHR_materials_common: full
+ */
+#ifndef GLTFASSET_H_INC
+#define GLTFASSET_H_INC
+
+#if !defined(ASSIMP_BUILD_NO_GLTF_IMPORTER) && !defined(ASSIMP_BUILD_NO_GLTF1_IMPORTER)
+
+#include "glTFCommon.h"
+#include <assimp/Exceptional.h>
+#include <algorithm>
+#include <list>
+#include <map>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+// clang-format off
+
+#if (__GNUC__ == 8 && __GNUC_MINOR__ >= 0)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wclass-memaccess"
+#endif
+
+#include <rapidjson/rapidjson.h>
+#include <rapidjson/document.h>
+#include <rapidjson/error/en.h>
+
+#if (__GNUC__ == 8 && __GNUC_MINOR__ >= 0)
+#pragma GCC diagnostic pop
+#endif
+
+#ifdef ASSIMP_API
+#   include <memory>
+#   include <assimp/DefaultIOSystem.h>
+#   include <assimp/ByteSwapper.h>
+#else
+#   include <memory>
+#   define AI_SWAP4(p)
+#   define ai_assert
+#endif
+
+
+#if _MSC_VER > 1500 || (defined __GNUC___)
+#       define ASSIMP_GLTF_USE_UNORDERED_MULTIMAP
+#   else
+#       define gltf_unordered_map map
+#endif
+
+#ifdef ASSIMP_GLTF_USE_UNORDERED_MULTIMAP
+#   include <unordered_map>
+#   if defined(_MSC_VER) && _MSC_VER <= 1600
+#       define gltf_unordered_map tr1::unordered_map
+#   else
+#       define gltf_unordered_map unordered_map
+#   endif
+#endif
+
+// clang-format on
+
+#include "AssetLib/glTF/glTFCommon.h"
+
+namespace glTF {
+
+using glTFCommon::IOStream;
+using glTFCommon::IOSystem;
+using glTFCommon::Nullable;
+using glTFCommon::Ref;
+using glTFCommon::shared_ptr;
+
+using rapidjson::Document;
+using rapidjson::Value;
+
+class Asset;
+class AssetWriter;
+
+struct BufferView; // here due to cross-reference
+struct Texture;
+struct Light;
+struct Skin;
+
+using glTFCommon::mat4;
+using glTFCommon::vec3;
+using glTFCommon::vec4;
+
+//! Magic number for GLB files
+#define AI_GLB_MAGIC_NUMBER "glTF"
+
+// clang-format off
+#ifdef ASSIMP_API
+#   include <assimp/Compiler/pushpack1.h>
+#endif
+// clang-format on
+
+//! For the KHR_binary_glTF extension (binary .glb file)
+//! 20-byte header (+ the JSON + a "body" data section)
+struct GLB_Header {
+    uint8_t magic[4]; //!< Magic number: "glTF"
+    uint32_t version; //!< Version number (always 1 as of the last update)
+    uint32_t length; //!< Total length of the Binary glTF, including header, scene, and body, in bytes
+    uint32_t sceneLength; //!< Length, in bytes, of the glTF scene
+    uint32_t sceneFormat; //!< Specifies the format of the glTF scene (see the SceneFormat enum)
+} PACK_STRUCT;
+
+// clang-format off
+#ifdef ASSIMP_API
+#   include <assimp/Compiler/poppack1.h>
+#endif
+// clang-format on
+
+//! Values for the GLB_Header::sceneFormat field
+enum SceneFormat {
+    SceneFormat_JSON = 0
+};
+
+//! Values for the mesh primitive modes
+enum PrimitiveMode {
+    PrimitiveMode_POINTS = 0,
+    PrimitiveMode_LINES = 1,
+    PrimitiveMode_LINE_LOOP = 2,
+    PrimitiveMode_LINE_STRIP = 3,
+    PrimitiveMode_TRIANGLES = 4,
+    PrimitiveMode_TRIANGLE_STRIP = 5,
+    PrimitiveMode_TRIANGLE_FAN = 6
+};
+
+//! Values for the Accessor::componentType field
+enum ComponentType {
+    ComponentType_BYTE = 5120,
+    ComponentType_UNSIGNED_BYTE = 5121,
+    ComponentType_SHORT = 5122,
+    ComponentType_UNSIGNED_SHORT = 5123,
+    ComponentType_UNSIGNED_INT = 5125,
+    ComponentType_FLOAT = 5126
+};
+
+inline unsigned int ComponentTypeSize(ComponentType t) {
+    switch (t) {
+    case ComponentType_SHORT:
+    case ComponentType_UNSIGNED_SHORT:
+        return 2;
+
+    case ComponentType_UNSIGNED_INT:
+    case ComponentType_FLOAT:
+        return 4;
+
+    case ComponentType_BYTE:
+    case ComponentType_UNSIGNED_BYTE:
+        return 1;
+    default:
+        std::string err = "GLTF: Unsupported Component Type ";
+        err += std::to_string(t);
+        throw DeadlyImportError(err);
+    }
+}
+
+//! Values for the BufferView::target field
+enum BufferViewTarget {
+    BufferViewTarget_NONE = 0,
+    BufferViewTarget_ARRAY_BUFFER = 34962,
+    BufferViewTarget_ELEMENT_ARRAY_BUFFER = 34963
+};
+
+//! Values for the Sampler::magFilter field
+enum SamplerMagFilter {
+    SamplerMagFilter_Nearest = 9728,
+    SamplerMagFilter_Linear = 9729
+};
+
+//! Values for the Sampler::minFilter field
+enum SamplerMinFilter {
+    SamplerMinFilter_Nearest = 9728,
+    SamplerMinFilter_Linear = 9729,
+    SamplerMinFilter_Nearest_Mipmap_Nearest = 9984,
+    SamplerMinFilter_Linear_Mipmap_Nearest = 9985,
+    SamplerMinFilter_Nearest_Mipmap_Linear = 9986,
+    SamplerMinFilter_Linear_Mipmap_Linear = 9987
+};
+
+//! Values for the Sampler::wrapS and Sampler::wrapT field
+enum SamplerWrap {
+    SamplerWrap_Clamp_To_Edge = 33071,
+    SamplerWrap_Mirrored_Repeat = 33648,
+    SamplerWrap_Repeat = 10497
+};
+
+//! Values for the Texture::format and Texture::internalFormat fields
+enum TextureFormat {
+    TextureFormat_ALPHA = 6406,
+    TextureFormat_RGB = 6407,
+    TextureFormat_RGBA = 6408,
+    TextureFormat_LUMINANCE = 6409,
+    TextureFormat_LUMINANCE_ALPHA = 6410
+};
+
+//! Values for the Texture::target field
+enum TextureTarget {
+    TextureTarget_TEXTURE_2D = 3553
+};
+
+//! Values for the Texture::type field
+enum TextureType {
+    TextureType_UNSIGNED_BYTE = 5121,
+    TextureType_UNSIGNED_SHORT_5_6_5 = 33635,
+    TextureType_UNSIGNED_SHORT_4_4_4_4 = 32819,
+    TextureType_UNSIGNED_SHORT_5_5_5_1 = 32820
+};
+
+//! Values for the Accessor::type field (helper class)
+class AttribType {
+public:
+    enum Value { SCALAR,
+        VEC2,
+        VEC3,
+        VEC4,
+        MAT2,
+        MAT3,
+        MAT4 
+    };
+
+    inline static Value FromString(const char *str) {
+        for (size_t i = 0; i < NUM_VALUES; ++i) {
+            if (strcmp(data<0>::infos[i].name, str) == 0) {
+                return static_cast<Value>(i);
+            }
+        }
+        return SCALAR;
+    }
+
+    inline static const char *ToString(Value type) {
+        return data<0>::infos[static_cast<size_t>(type)].name;
+    }
+
+    inline static unsigned int GetNumComponents(Value type) {
+        return data<0>::infos[static_cast<size_t>(type)].numComponents;
+    }
+
+private:
+    static const size_t NUM_VALUES = static_cast<size_t>(MAT4) + 1;
+    struct Info {
+        const char *name;
+        unsigned int numComponents;
+    };
+
+    template <int N>
+    struct data { 
+        static const Info infos[NUM_VALUES]; 
+    };
+};
+
+// must match the order of the AttribTypeTraits::Value enum!
+template <int N>
+const AttribType::Info AttribType::data<N>::infos[AttribType::NUM_VALUES] = {
+    { "SCALAR", 1 },
+    { "VEC2", 2 }, 
+    { "VEC3", 3 }, 
+    { "VEC4", 4 }, 
+    { "MAT2", 4 }, 
+    { "MAT3", 9 }, 
+    { "MAT4", 16 }
+};
+
+//! Base class for all glTF top-level objects
+struct Object {
+    std::string id; //!< The globally unique ID used to reference this object
+    std::string name; //!< The user-defined name of this object
+
+    //! Objects marked as special are not exported (used to emulate the binary body buffer)
+    virtual bool IsSpecial() const { return false; }
+
+    Object() = default;
+    virtual ~Object() {}
+
+    //! Maps special IDs to another ID, where needed. Subclasses may override it (statically)
+    static const char *TranslateId(Asset & /*r*/, const char *id) { return id; }
+};
+
+//
+// Classes for each glTF top-level object type
+//
+
+//! A typed view into a BufferView. A BufferView contains raw binary data.
+//! An accessor provides a typed view into a BufferView or a subset of a BufferView
+//! similar to how WebGL's vertexAttribPointer() defines an attribute in a buffer.
+struct Accessor : public Object {
+    Ref<BufferView> bufferView; //!< The ID of the bufferView. (required)
+    unsigned int byteOffset; //!< The offset relative to the start of the bufferView in bytes. (required)
+    unsigned int byteStride; //!< The stride, in bytes, between attributes referenced by this accessor. (default: 0)
+    ComponentType componentType; //!< The datatype of components in the attribute. (required)
+    unsigned int count; //!< The number of attributes referenced by this accessor. (required)
+    AttribType::Value type; //!< Specifies if the attribute is a scalar, vector, or matrix. (required)
+    std::vector<double> max; //!< Maximum value of each component in this attribute.
+    std::vector<double> min; //!< Minimum value of each component in this attribute.
+
+    unsigned int GetNumComponents();
+    unsigned int GetBytesPerComponent();
+    unsigned int GetElementSize();
+
+    inline uint8_t *GetPointer();
+
+    template <class T>
+    bool ExtractData(T *&outData);
+
+    void WriteData(size_t count, const void *src_buffer, size_t src_stride);
+
+    //! Helper class to iterate the data
+    class Indexer {
+        friend struct Accessor;
+
+        // This field is reported as not used, making it protectd is the easiest way to work around it without going to the bottom of what the problem is:
+        // ../code/glTF2/glTF2Asset.h:392:19: error: private field 'accessor' is not used [-Werror,-Wunused-private-field]
+    protected:
+        Accessor &accessor;
+
+    private:
+        uint8_t *data;
+        size_t elemSize, stride;
+
+        Indexer(Accessor &acc);
+
+    public:
+        //! Accesses the i-th value as defined by the accessor
+        template <class T>
+        T GetValue(int i);
+
+        //! Accesses the i-th value as defined by the accessor
+        inline unsigned int GetUInt(int i) {
+            return GetValue<unsigned int>(i);
+        }
+
+        inline bool IsValid() const {
+            return data != 0;
+        }
+    };
+
+    inline Indexer GetIndexer() {
+        return Indexer(*this);
+    }
+
+    Accessor() = default;
+    void Read(Value &obj, Asset &r);
+};
+
+//! A buffer points to binary geometry, animation, or skins.
+struct Buffer : public Object {
+    /********************* Types *********************/
+    enum Type {
+        Type_arraybuffer,
+        Type_text
+    };
+
+    /// @brief  Descriptor of encoded region in "bufferView".
+    struct SEncodedRegion {
+        const size_t Offset; ///< Offset from begin of "bufferView" to encoded region, in bytes.
+        const size_t EncodedData_Length; ///< Size of encoded region, in bytes.
+        uint8_t *const DecodedData; ///< Cached encoded data.
+        const size_t DecodedData_Length; ///< Size of decoded region, in bytes.
+        const std::string ID; ///< ID of the region.
+
+        /// @brief Constructor.
+        /// \param [in] pOffset - offset from begin of "bufferView" to encoded region, in bytes.
+        /// \param [in] pEncodedData_Length - size of encoded region, in bytes.
+        /// \param [in] pDecodedData - pointer to decoded data array.
+        /// \param [in] pDecodedData_Length - size of encoded region, in bytes.
+        /// \param [in] pID - ID of the region.
+        SEncodedRegion(const size_t pOffset, const size_t pEncodedData_Length, uint8_t *pDecodedData, const size_t pDecodedData_Length, const std::string &pID) :
+                Offset(pOffset), EncodedData_Length(pEncodedData_Length), DecodedData(pDecodedData), DecodedData_Length(pDecodedData_Length), ID(pID) {}
+
+        /// Destructor.
+        ~SEncodedRegion() { delete[] DecodedData; }
+    };
+
+    /******************* Variables *******************/
+
+    size_t byteLength; //!< The length of the buffer in bytes. (default: 0)
+
+    Type type;
+
+    /// \var EncodedRegion_Current
+    /// Pointer to currently active encoded region.
+    /// Why not decoding all regions at once and not to set one buffer with decoded data?
+    /// Yes, why not? Even "accessor" point to decoded data. I mean that fields "byteOffset", "byteStride" and "count" has values which describes decoded
+    /// data array. But only in range of mesh while is active parameters from "compressedData". For another mesh accessors point to decoded data too. But
+    /// offset is counted for another regions is encoded.
+    /// Example. You have two meshes. For every of it you have 4 bytes of data. That data compressed to 2 bytes. So, you have buffer with encoded data:
+    /// M1_E0, M1_E1, M2_E0, M2_E1.
+    /// After decoding you'll get:
+    /// M1_D0, M1_D1, M1_D2, M1_D3, M2_D0, M2_D1, M2_D2, M2_D3.
+    /// "accessors" must to use values that point to decoded data - obviously. So, you'll expect "accessors" like
+    /// "accessor_0" : { byteOffset: 0, byteLength: 4}, "accessor_1" : { byteOffset: 4, byteLength: 4}
+    /// but in real life you'll get:
+    /// "accessor_0" : { byteOffset: 0, byteLength: 4}, "accessor_1" : { byteOffset: 2, byteLength: 4}
+    /// Yes, accessor of next mesh has offset and length which mean: current mesh data is decoded, all other data is encoded.
+    /// And when before you start to read data of current mesh (with encoded data ofcourse) you must decode region of "bufferView", after read finished
+    /// delete encoding mark. And after that you can repeat process: decode data of mesh, read, delete decoded data.
+    ///
+    /// Remark. Encoding all data at once is good in world with computers which do not has RAM limitation. So, you must use step by step encoding in
+    /// exporter and importer. And, thanks to such way, there is no need to load whole file into memory.
+    SEncodedRegion *EncodedRegion_Current;
+
+private:
+    shared_ptr<uint8_t> mData; //!< Pointer to the data
+    bool mIsSpecial; //!< Set to true for special cases (e.g. the body buffer)
+    size_t capacity = 0; //!< The capacity of the buffer in bytes. (default: 0)
+    /// \var EncodedRegion_List
+    /// List of encoded regions.
+    std::list<SEncodedRegion *> EncodedRegion_List;
+
+    /******************* Functions *******************/
+
+public:
+    Buffer();
+    ~Buffer();
+
+    void Read(Value &obj, Asset &r);
+
+    bool LoadFromStream(IOStream &stream, size_t length = 0, size_t baseOffset = 0);
+
+    /// Mark region of "bufferView" as encoded. When data is request from such region then "bufferView" use decoded data.
+    /// \param [in] pOffset - offset from begin of "bufferView" to encoded region, in bytes.
+    /// \param [in] pEncodedData_Length - size of encoded region, in bytes.
+    /// \param [in] pDecodedData - pointer to decoded data array.
+    /// \param [in] pDecodedData_Length - size of encoded region, in bytes.
+    /// \param [in] pID - ID of the region.
+    void EncodedRegion_Mark(const size_t pOffset, const size_t pEncodedData_Length, uint8_t *pDecodedData, const size_t pDecodedData_Length, const std::string &pID);
+
+    /// Select current encoded region by ID. \sa EncodedRegion_Current.
+    /// \param [in] pID - ID of the region.
+    void EncodedRegion_SetCurrent(const std::string &pID);
+
+    /// Replace part of buffer data. Pay attention that function work with original array of data (\ref mData) not with encoded regions.
+    /// \param [in] pBufferData_Offset - index of first element in buffer from which new data will be placed.
+    /// \param [in] pBufferData_Count - count of bytes in buffer which will be replaced.
+    /// \param [in] pReplace_Data - pointer to array with new data for buffer.
+    /// \param [in] pReplace_Count - count of bytes in new data.
+    /// \return true - if successfully replaced, false if input arguments is out of range.
+    bool ReplaceData(const size_t pBufferData_Offset, const size_t pBufferData_Count, const uint8_t *pReplace_Data, const size_t pReplace_Count);
+
+    size_t AppendData(uint8_t *data, size_t length);
+    void Grow(size_t amount);
+
+    uint8_t *GetPointer() { return mData.get(); }
+
+    void MarkAsSpecial() { mIsSpecial = true; }
+
+    bool IsSpecial() const { return mIsSpecial; }
+
+    std::string GetURI() { return std::string(this->id) + ".bin"; }
+
+    static const char *TranslateId(Asset &r, const char *id);
+};
+
+//! A view into a buffer generally representing a subset of the buffer.
+struct BufferView : public Object {
+    Ref<Buffer> buffer; //! The ID of the buffer. (required)
+    size_t byteOffset; //! The offset into the buffer in bytes. (required)
+    size_t byteLength; //! The length of the bufferView in bytes. (default: 0)
+
+    BufferViewTarget target; //! The target that the WebGL buffer should be bound to.
+
+    void Read(Value &obj, Asset &r);
+};
+
+struct Camera : public Object {
+    enum Type {
+        Perspective,
+        Orthographic
+    };
+
+    Type type;
+
+    union {
+        struct {
+            float aspectRatio; //!<The floating - point aspect ratio of the field of view. (0 = undefined = use the canvas one)
+            float yfov; //!<The floating - point vertical field of view in radians. (required)
+            float zfar; //!<The floating - point distance to the far clipping plane. (required)
+            float znear; //!< The floating - point distance to the near clipping plane. (required)
+        } perspective;
+
+        struct {
+            float xmag; //! The floating-point horizontal magnification of the view. (required)
+            float ymag; //! The floating-point vertical magnification of the view. (required)
+            float zfar; //! The floating-point distance to the far clipping plane. (required)
+            float znear; //! The floating-point distance to the near clipping plane. (required)
+        } ortographic;
+    };
+
+    Camera() = default;
+    void Read(Value &obj, Asset &r);
+};
+
+//! Image data used to create a texture.
+struct Image : public Object {
+    std::string uri; //! The uri of the image, that can be a file path, a data URI, etc.. (required)
+    Ref<BufferView> bufferView;
+    std::string mimeType;
+    int width, height;
+
+public:
+    Image();
+    void Read(Value &obj, Asset &r);
+    inline bool HasData() const { return mDataLength > 0; }
+    inline size_t GetDataLength() const { return mDataLength; }
+    inline const uint8_t *GetData() const { return mData.get(); }
+    inline uint8_t *StealData();
+    inline void SetData(uint8_t *data, size_t length, Asset &r);
+
+private:
+    std::unique_ptr<uint8_t[]> mData;
+    size_t mDataLength;
+};
+
+//! Holds a material property that can be a texture or a color
+struct TexProperty {
+    Ref<Texture> texture;
+    vec4 color;
+};
+
+//! The material appearance of a primitive.
+struct Material : public Object {
+    //Ref<Sampler> source; //!< The ID of the technique.
+    //std::gltf_unordered_map<std::string, std::string> values; //!< A dictionary object of parameter values.
+
+    //! Techniques defined by KHR_materials_common
+    enum Technique {
+        Technique_undefined = 0,
+        Technique_BLINN,
+        Technique_PHONG,
+        Technique_LAMBERT,
+        Technique_CONSTANT
+    };
+
+    TexProperty ambient;
+    TexProperty diffuse;
+    TexProperty specular;
+    TexProperty emission;
+
+    bool doubleSided;
+    bool transparent;
+    float transparency;
+    float shininess;
+
+    Technique technique;
+
+    Material() { SetDefaults(); }
+    void Read(Value &obj, Asset &r);
+    void SetDefaults();
+};
+
+//! A set of primitives to be rendered. A node can contain one or more meshes. A node's transform places the mesh in the scene.
+struct Mesh : public Object {
+    typedef std::vector<Ref<Accessor>> AccessorList;
+
+    struct Primitive {
+        PrimitiveMode mode;
+
+        struct Attributes {
+            AccessorList position, normal, texcoord, color, joint, jointmatrix, weight;
+        } attributes;
+
+        Ref<Accessor> indices;
+
+        Ref<Material> material;
+    };
+
+    /// \struct SExtension
+    /// Extension used for mesh.
+    struct SExtension {
+        /// \enum EType
+        /// Type of extension.
+        enum EType {
+#ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC
+            Compression_Open3DGC, ///< Compression of mesh data using Open3DGC algorithm.
+#endif
+
+            Unknown
+        };
+
+        EType Type; ///< Type of extension.
+
+        /// \fn SExtension
+        /// Constructor.
+        /// \param [in] pType - type of extension.
+        SExtension(const EType pType) :
+                Type(pType) {}
+
+        virtual ~SExtension() {
+            // empty
+        }
+    };
+
+#ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC
+
+    /// \struct SCompression_Open3DGC
+    /// Compression of mesh data using Open3DGC algorithm.
+    struct SCompression_Open3DGC : public SExtension {
+        using SExtension::Type;
+
+        std::string Buffer; ///< ID of "buffer" used for storing compressed data.
+        size_t Offset; ///< Offset in "bufferView" where compressed data are stored.
+        size_t Count; ///< Count of elements in compressed data. Is always equivalent to size in bytes: look comments for "Type" and "Component_Type".
+        bool Binary; ///< If true then "binary" mode is used for coding, if false - "ascii" mode.
+        size_t IndicesCount; ///< Count of indices in mesh.
+        size_t VerticesCount; ///< Count of vertices in mesh.
+        // AttribType::Value Type;///< Is always "SCALAR".
+        // ComponentType Component_Type;///< Is always "ComponentType_UNSIGNED_BYTE" (5121).
+
+        /// \fn SCompression_Open3DGC
+        /// Constructor.
+        SCompression_Open3DGC() :
+                SExtension(Compression_Open3DGC) {
+            // empty
+        }
+
+        virtual ~SCompression_Open3DGC() {
+            // empty
+        }
+    };
+#endif
+
+    std::vector<Primitive> primitives;
+    std::list<SExtension *> Extension; ///< List of extensions used in mesh.
+
+    Mesh() {}
+
+    /// Destructor.
+    ~Mesh() {
+        for (std::list<SExtension *>::iterator it = Extension.begin(), it_end = Extension.end(); it != it_end; it++) {
+            delete *it;
+        };
+    }
+
+    /// @brief Get mesh data from JSON-object and place them to root asset.
+    /// \param [in] pJSON_Object - reference to pJSON-object from which data are read.
+    /// \param [out] pAsset_Root - reference to root asset where data will be stored.
+    void Read(Value &pJSON_Object, Asset &pAsset_Root);
+
+#ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC
+    /// @brief Decode part of "buffer" which encoded with Open3DGC algorithm.
+    /// \param [in] pCompression_Open3DGC - reference to structure which describe encoded region.
+    /// \param [out] pAsset_Root - reference to root assed where data will be stored.
+    void Decode_O3DGC(const SCompression_Open3DGC &pCompression_Open3DGC, Asset &pAsset_Root);
+#endif
+};
+
+struct Node : public Object {
+    std::vector<Ref<Node>> children;
+    std::vector<Ref<Mesh>> meshes;
+
+    Nullable<mat4> matrix;
+    Nullable<vec3> translation;
+    Nullable<vec4> rotation;
+    Nullable<vec3> scale;
+
+    Ref<Camera> camera;
+    Ref<Light> light;
+
+    std::vector<Ref<Node>> skeletons; //!< The ID of skeleton nodes. Each of which is the root of a node hierarchy.
+    Ref<Skin> skin; //!< The ID of the skin referenced by this node.
+    std::string jointName; //!< Name used when this node is a joint in a skin.
+
+    Ref<Node> parent; //!< This is not part of the glTF specification. Used as a helper.
+
+    Node() {}
+    void Read(Value &obj, Asset &r);
+};
+
+struct Program : public Object {
+    Program() {}
+    void Read(Value &obj, Asset &r);
+};
+
+struct Sampler : public Object {
+    SamplerMagFilter magFilter; //!< The texture magnification filter. (required)
+    SamplerMinFilter minFilter; //!< The texture minification filter. (required)
+    SamplerWrap wrapS; //!< The texture wrapping in the S direction. (required)
+    SamplerWrap wrapT; //!< The texture wrapping in the T direction. (required)
+
+    Sampler() = default;
+    void Read(Value &obj, Asset &r);
+    void SetDefaults();
+};
+
+struct Scene : public Object {
+    std::vector<Ref<Node>> nodes;
+
+    Scene() = default;
+    void Read(Value &obj, Asset &r);
+};
+
+struct Shader : public Object {
+    Shader() = default;
+    void Read(Value &obj, Asset &r);
+};
+
+struct Skin : public Object {
+    Nullable<mat4> bindShapeMatrix; //!< Floating-point 4x4 transformation matrix stored in column-major order.
+    Ref<Accessor> inverseBindMatrices; //!< The ID of the accessor containing the floating-point 4x4 inverse-bind matrices.
+    std::vector<Ref<Node>> jointNames; //!< Joint names of the joints (nodes with a jointName property) in this skin.
+    std::string name; //!< The user-defined name of this object.
+
+    Skin() = default;
+    void Read(Value &obj, Asset &r);
+};
+
+struct Technique : public Object {
+    struct Parameters {
+    };
+
+    struct States {
+    };
+
+    struct Functions {
+    };
+
+    Technique() = default;
+    void Read(Value &obj, Asset &r);
+};
+
+//! A texture and its sampler.
+struct Texture : public Object {
+    Ref<Sampler> sampler; //!< The ID of the sampler used by this texture. (required)
+    Ref<Image> source; //!< The ID of the image used by this texture. (required)
+
+    Texture() = default;
+    void Read(Value &obj, Asset &r);
+};
+
+//! A light (from KHR_materials_common extension)
+struct Light : public Object {
+    enum Type {
+        Type_undefined,
+        Type_ambient,
+        Type_directional,
+        Type_point,
+        Type_spot
+    };
+
+    Type type;
+    vec4 color;
+    float distance;
+    float constantAttenuation;
+    float linearAttenuation;
+    float quadraticAttenuation;
+    float falloffAngle;
+    float falloffExponent;
+
+    Light() = default;
+    void Read(Value &obj, Asset &r);
+    void SetDefaults();
+};
+
+struct Animation : public Object {
+    struct AnimSampler {
+        std::string id; //!< The ID of this sampler.
+        std::string input; //!< The ID of a parameter in this animation to use as key-frame input.
+        std::string interpolation; //!< Type of interpolation algorithm to use between key-frames.
+        std::string output; //!< The ID of a parameter in this animation to use as key-frame output.
+    };
+
+    struct AnimChannel {
+        std::string sampler; //!< The ID of one sampler present in the containing animation's samplers property.
+
+        struct AnimTarget {
+            Ref<Node> id; //!< The ID of the node to animate.
+            std::string path; //!< The name of property of the node to animate ("translation", "rotation", or "scale").
+        } target;
+    };
+
+    struct AnimParameters {
+        Ref<Accessor> TIME; //!< Accessor reference to a buffer storing a array of floating point scalar values.
+        Ref<Accessor> rotation; //!< Accessor reference to a buffer storing a array of four-component floating-point vectors.
+        Ref<Accessor> scale; //!< Accessor reference to a buffer storing a array of three-component floating-point vectors.
+        Ref<Accessor> translation; //!< Accessor reference to a buffer storing a array of three-component floating-point vectors.
+    };
+
+    std::vector<AnimChannel> Channels; //!< Connect the output values of the key-frame animation to a specific node in the hierarchy.
+    AnimParameters Parameters; //!< The samplers that interpolate between the key-frames.
+    std::vector<AnimSampler> Samplers; //!< The parameterized inputs representing the key-frame data.
+
+    Animation() = default;
+    void Read(Value &obj, Asset &r);
+};
+
+//! Base class for LazyDict that acts as an interface
+class LazyDictBase {
+public:
+    virtual ~LazyDictBase() {}
+
+    virtual void AttachToDocument(Document &doc) = 0;
+    virtual void DetachFromDocument() = 0;
+
+#if !defined(ASSIMP_BUILD_NO_EXPORT)
+    virtual void WriteObjects(AssetWriter &writer) = 0;
+#endif
+};
+
+template <class T>
+class LazyDict;
+
+//! (Implemented in glTFAssetWriter.h)
+template <class T>
+void WriteLazyDict(LazyDict<T> &d, AssetWriter &w);
+
+//! Manages lazy loading of the glTF top-level objects, and keeps a reference to them by ID
+//! It is the owner the loaded objects, so when it is destroyed it also deletes them
+template <class T>
+class LazyDict : public LazyDictBase {
+    friend class Asset;
+    friend class AssetWriter;
+
+    typedef typename std::gltf_unordered_map<std::string, unsigned int> Dict;
+
+    std::vector<T *> mObjs; //! The read objects
+    Dict mObjsById; //! The read objects accessible by id
+    const char *mDictId; //! ID of the dictionary object
+    const char *mExtId; //! ID of the extension defining the dictionary
+    Value *mDict; //! JSON dictionary object
+    Asset &mAsset; //! The asset instance
+
+    void AttachToDocument(Document &doc);
+    void DetachFromDocument();
+
+#if !defined(ASSIMP_BUILD_NO_EXPORT)
+    void WriteObjects(AssetWriter &writer) { WriteLazyDict<T>(*this, writer); }
+#endif
+
+    Ref<T> Add(T *obj);
+
+public:
+    LazyDict(Asset &asset, const char *dictId, const char *extId = 0);
+    ~LazyDict();
+
+    Ref<T> Get(const char *id);
+    Ref<T> Get(unsigned int i);
+    Ref<T> Get(const std::string &pID) { return Get(pID.c_str()); }
+
+    Ref<T> Create(const char *id);
+    Ref<T> Create(const std::string &id) { return Create(id.c_str()); }
+
+    inline unsigned int Size() const { return unsigned(mObjs.size()); }
+
+    inline T &operator[](size_t i) { return *mObjs[i]; }
+};
+
+struct AssetMetadata {
+    std::string copyright; //!< A copyright message suitable for display to credit the content creator.
+    std::string generator; //!< Tool that generated this glTF model.Useful for debugging.
+    bool premultipliedAlpha; //!< Specifies if the shaders were generated with premultiplied alpha. (default: false)
+
+    struct {
+        std::string api; //!< Specifies the target rendering API (default: "WebGL")
+        std::string version; //!< Specifies the target rendering API (default: "1.0.3")
+    } profile; //!< Specifies the target rendering API and version, e.g., WebGL 1.0.3. (default: {})
+
+    std::string version; //!< The glTF format version (should be 1.0)
+
+    void Read(Document &doc);
+
+    AssetMetadata() :
+            premultipliedAlpha(false), version() {
+    }
+};
+
+//
+// glTF Asset class
+//
+
+//! Root object for a glTF asset
+class Asset {
+    using IdMap = std::gltf_unordered_map<std::string, int>;
+
+    template <class T>
+    friend class LazyDict;
+    friend struct Buffer; // To access OpenFile
+    friend class AssetWriter;
+
+private:
+    IOSystem *mIOSystem;
+
+    std::string mCurrentAssetDir;
+
+    size_t mSceneLength;
+    size_t mBodyOffset, mBodyLength;
+
+    std::vector<LazyDictBase *> mDicts;
+
+    IdMap mUsedIds;
+
+    Ref<Buffer> mBodyBuffer;
+
+    Asset(Asset &);
+    Asset &operator=(const Asset &);
+
+public:
+    //! Keeps info about the enabled extensions
+    struct Extensions {
+        bool KHR_binary_glTF;
+        bool KHR_materials_common;
+
+    } extensionsUsed;
+
+    AssetMetadata asset;
+
+    // Dictionaries for each type of object
+
+    LazyDict<Accessor> accessors;
+    LazyDict<Animation> animations;
+    LazyDict<Buffer> buffers;
+    LazyDict<BufferView> bufferViews;
+    LazyDict<Camera> cameras;
+    LazyDict<Image> images;
+    LazyDict<Material> materials;
+    LazyDict<Mesh> meshes;
+    LazyDict<Node> nodes;
+    LazyDict<Sampler> samplers;
+    LazyDict<Scene> scenes;
+    LazyDict<Skin> skins;
+    LazyDict<Texture> textures;
+
+    LazyDict<Light> lights; // KHR_materials_common ext
+
+    Ref<Scene> scene;
+
+public:
+    Asset(IOSystem *io = 0) :
+            mIOSystem(io), 
+            asset(), 
+            accessors(*this, "accessors"), 
+            animations(*this, "animations"), 
+            buffers(*this, "buffers"), 
+            bufferViews(*this, "bufferViews"), 
+            cameras(*this, "cameras"), 
+            images(*this, "images"), 
+            materials(*this, "materials"), 
+            meshes(*this, "meshes"), 
+            nodes(*this, "nodes"),
+            samplers(*this, "samplers"),
+            scenes(*this, "scenes"),
+            skins(*this, "skins"),
+            textures(*this, "textures"),
+            lights(*this, "lights", "KHR_materials_common") {
+        memset(&extensionsUsed, 0, sizeof(extensionsUsed));
+    }
+
+    //! Main function
+    void Load(const std::string &file, bool isBinary = false);
+
+    //! Enables the "KHR_binary_glTF" extension on the asset
+    void SetAsBinary();
+
+    //! Search for an available name, starting from the given strings
+    std::string FindUniqueID(const std::string &str, const char *suffix);
+
+    Ref<Buffer> GetBodyBuffer() { return mBodyBuffer; }
+
+private:
+    void ReadBinaryHeader(IOStream &stream);
+
+    void ReadExtensionsUsed(Document &doc);
+
+    IOStream *OpenFile(const std::string &path, const char *mode, bool absolute = false);
+};
+
+} // namespace glTF
+
+// Include the implementation of the methods
+#include "glTFAsset.inl"
+
+#endif // ASSIMP_BUILD_NO_GLTF_IMPORTER
+
+#endif // GLTFASSET_H_INC
diff --git a/Engine/lib/assimp/code/AssetLib/glTF/glTFAsset.inl b/Engine/lib/assimp/code/AssetLib/glTF/glTFAsset.inl
new file mode 100644
index 000000000..2b76a30ab
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/glTF/glTFAsset.inl
@@ -0,0 +1,1316 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#include <assimp/MemoryIOWrapper.h>
+#include <assimp/StringUtils.h>
+#include <iomanip>
+
+// Header files, Assimp
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/Base64.hpp>
+
+#ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC
+// Header files, Open3DGC.
+#include <Open3DGC/o3dgcSC3DMCDecoder.h>
+#endif
+
+using namespace Assimp;
+using namespace glTFCommon;
+
+namespace glTF {
+
+#if _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4706)
+#endif // _MSC_VER
+
+//
+// LazyDict methods
+//
+
+template <class T>
+inline LazyDict<T>::LazyDict(Asset &asset, const char *dictId, const char *extId) :
+        mDictId(dictId), mExtId(extId), mDict(0), mAsset(asset) {
+    asset.mDicts.push_back(this); // register to the list of dictionaries
+}
+
+template <class T>
+inline LazyDict<T>::~LazyDict() {
+    for (size_t i = 0; i < mObjs.size(); ++i) {
+        delete mObjs[i];
+    }
+}
+
+template <class T>
+inline void LazyDict<T>::AttachToDocument(Document &doc) {
+    Value *container = 0;
+
+    if (mExtId) {
+        if (Value *exts = FindObject(doc, "extensions")) {
+            container = FindObject(*exts, mExtId);
+        }
+    } else {
+        container = &doc;
+    }
+
+    if (container) {
+        mDict = FindObject(*container, mDictId);
+    }
+}
+
+template <class T>
+inline void LazyDict<T>::DetachFromDocument() {
+    mDict = 0;
+}
+
+template <class T>
+Ref<T> LazyDict<T>::Get(unsigned int i) {
+    return Ref<T>(mObjs, i);
+}
+
+template <class T>
+Ref<T> LazyDict<T>::Get(const char *id) {
+    id = T::TranslateId(mAsset, id);
+
+    typename Dict::iterator it = mObjsById.find(id);
+    if (it != mObjsById.end()) { // already created?
+        return Ref<T>(mObjs, it->second);
+    }
+
+    // read it from the JSON object
+    if (!mDict) {
+        throw DeadlyImportError("GLTF: Missing section \"", mDictId, "\"");
+    }
+
+    Value::MemberIterator obj = mDict->FindMember(id);
+    if (obj == mDict->MemberEnd()) {
+        throw DeadlyImportError("GLTF: Missing object with id \"", id, "\" in \"", mDictId, "\"");
+    }
+    if (!obj->value.IsObject()) {
+        throw DeadlyImportError("GLTF: Object with id \"", id, "\" is not a JSON object");
+    }
+
+    // create an instance of the given type
+    T *inst = new T();
+    inst->id = id;
+    ReadMember(obj->value, "name", inst->name);
+    inst->Read(obj->value, mAsset);
+    return Add(inst);
+}
+
+template <class T>
+Ref<T> LazyDict<T>::Add(T *obj) {
+    unsigned int idx = unsigned(mObjs.size());
+    mObjs.push_back(obj);
+    mObjsById[obj->id] = idx;
+    mAsset.mUsedIds[obj->id] = true;
+    return Ref<T>(mObjs, idx);
+}
+
+template <class T>
+Ref<T> LazyDict<T>::Create(const char *id) {
+    Asset::IdMap::iterator it = mAsset.mUsedIds.find(id);
+    if (it != mAsset.mUsedIds.end()) {
+        throw DeadlyImportError("GLTF: two objects with the same ID exist");
+    }
+    T *inst = new T();
+    inst->id = id;
+    return Add(inst);
+}
+
+//
+// glTF dictionary objects methods
+//
+
+inline Buffer::Buffer() :
+        byteLength(0), type(Type_arraybuffer), EncodedRegion_Current(nullptr), mIsSpecial(false) {}
+
+inline Buffer::~Buffer() {
+    for (SEncodedRegion *reg : EncodedRegion_List)
+        delete reg;
+}
+
+inline const char *Buffer::TranslateId(Asset &r, const char *id) {
+    // Compatibility with old spec
+    if (r.extensionsUsed.KHR_binary_glTF && strcmp(id, "KHR_binary_glTF") == 0) {
+        return "binary_glTF";
+    }
+
+    return id;
+}
+
+inline void Buffer::Read(Value &obj, Asset &r) {
+    size_t statedLength = MemberOrDefault<size_t>(obj, "byteLength", 0);
+    byteLength = statedLength;
+
+    Value *it = FindString(obj, "uri");
+    if (!it) {
+        if (statedLength > 0) {
+            throw DeadlyImportError("GLTF: buffer with non-zero length missing the \"uri\" attribute");
+        }
+        return;
+    }
+
+    const char *uri = it->GetString();
+
+    glTFCommon::Util::DataURI dataURI;
+    if (ParseDataURI(uri, it->GetStringLength(), dataURI)) {
+        if (dataURI.base64) {
+            uint8_t *data = 0;
+            this->byteLength = Base64::Decode(dataURI.data, dataURI.dataLength, data);
+            this->mData.reset(data, std::default_delete<uint8_t[]>());
+
+            if (statedLength > 0 && this->byteLength != statedLength) {
+                throw DeadlyImportError("GLTF: buffer \"", id, "\", expected ", ai_to_string(statedLength),
+                        " bytes, but found ", ai_to_string(dataURI.dataLength));
+            }
+        } else { // assume raw data
+            if (statedLength != dataURI.dataLength) {
+                throw DeadlyImportError("GLTF: buffer \"", id, "\", expected ", ai_to_string(statedLength),
+                        " bytes, but found ", ai_to_string(dataURI.dataLength));
+            }
+
+            this->mData.reset(new uint8_t[dataURI.dataLength], std::default_delete<uint8_t[]>());
+            memcpy(this->mData.get(), dataURI.data, dataURI.dataLength);
+        }
+    } else { // Local file
+        if (byteLength > 0) {
+            std::string dir = !r.mCurrentAssetDir.empty() ? (
+                                                                    r.mCurrentAssetDir.back() == '/' ?
+                                                                            r.mCurrentAssetDir :
+                                                                            r.mCurrentAssetDir + '/') :
+                                                            "";
+
+            IOStream *file = r.OpenFile(dir + uri, "rb");
+            if (file) {
+                bool ok = LoadFromStream(*file, byteLength);
+                delete file;
+
+                if (!ok)
+                    throw DeadlyImportError("GLTF: error while reading referenced file \"", uri, "\"");
+            } else {
+                throw DeadlyImportError("GLTF: could not open referenced file \"", uri, "\"");
+            }
+        }
+    }
+}
+
+inline bool Buffer::LoadFromStream(IOStream &stream, size_t length, size_t baseOffset) {
+    byteLength = length ? length : stream.FileSize();
+
+    if (baseOffset) {
+        stream.Seek(baseOffset, aiOrigin_SET);
+    }
+
+    mData.reset(new uint8_t[byteLength], std::default_delete<uint8_t[]>());
+
+    if (stream.Read(mData.get(), byteLength, 1) != 1) {
+        return false;
+    }
+    return true;
+}
+
+inline void Buffer::EncodedRegion_Mark(const size_t pOffset, const size_t pEncodedData_Length, uint8_t *pDecodedData, const size_t pDecodedData_Length, const std::string &pID) {
+    // Check pointer to data
+    if (pDecodedData == nullptr) throw DeadlyImportError("GLTF: for marking encoded region pointer to decoded data must be provided.");
+
+    // Check offset
+    if (pOffset > byteLength) {
+        const uint8_t val_size = 32;
+
+        char val[val_size];
+
+        ai_snprintf(val, val_size, AI_SIZEFMT, pOffset);
+        throw DeadlyImportError("GLTF: incorrect offset value (", val, ") for marking encoded region.");
+    }
+
+    // Check length
+    if ((pOffset + pEncodedData_Length) > byteLength) {
+        const uint8_t val_size = 64;
+
+        char val[val_size];
+
+        ai_snprintf(val, val_size, AI_SIZEFMT "/" AI_SIZEFMT, pOffset, pEncodedData_Length);
+        throw DeadlyImportError("GLTF: encoded region with offset/length (", val, ") is out of range.");
+    }
+
+    // Add new region
+    EncodedRegion_List.push_back(new SEncodedRegion(pOffset, pEncodedData_Length, pDecodedData, pDecodedData_Length, pID));
+    // And set new value for "byteLength"
+    byteLength += (pDecodedData_Length - pEncodedData_Length);
+}
+
+inline void Buffer::EncodedRegion_SetCurrent(const std::string &pID) {
+    if ((EncodedRegion_Current != nullptr) && (EncodedRegion_Current->ID == pID)) return;
+
+    for (SEncodedRegion *reg : EncodedRegion_List) {
+        if (reg->ID == pID) {
+            EncodedRegion_Current = reg;
+
+            return;
+        }
+    }
+
+    throw DeadlyImportError("GLTF: EncodedRegion with ID: \"", pID, "\" not found.");
+}
+
+inline bool Buffer::ReplaceData(const size_t pBufferData_Offset, const size_t pBufferData_Count, const uint8_t *pReplace_Data, const size_t pReplace_Count) {
+    const size_t new_data_size = byteLength + pReplace_Count - pBufferData_Count;
+
+    uint8_t *new_data;
+
+    if ((pBufferData_Count == 0) || (pReplace_Count == 0) || (pReplace_Data == nullptr)) return false;
+
+    new_data = new uint8_t[new_data_size];
+    // Copy data which place before replacing part.
+    memcpy(new_data, mData.get(), pBufferData_Offset);
+    // Copy new data.
+    memcpy(&new_data[pBufferData_Offset], pReplace_Data, pReplace_Count);
+    // Copy data which place after replacing part.
+    memcpy(&new_data[pBufferData_Offset + pReplace_Count], &mData.get()[pBufferData_Offset + pBufferData_Count], pBufferData_Offset);
+    // Apply new data
+    mData.reset(new_data, std::default_delete<uint8_t[]>());
+    byteLength = new_data_size;
+
+    return true;
+}
+
+inline size_t Buffer::AppendData(uint8_t *data, size_t length) {
+    size_t offset = this->byteLength;
+    Grow(length);
+    memcpy(mData.get() + offset, data, length);
+    return offset;
+}
+
+inline void Buffer::Grow(size_t amount) {
+    if (amount <= 0) return;
+    if (capacity >= byteLength + amount) {
+        byteLength += amount;
+        return;
+    }
+
+    // Shift operation is standard way to divide integer by 2, it doesn't cast it to float back and forth, also works for odd numbers,
+    // originally it would look like: static_cast<size_t>(capacity * 1.5f)
+    capacity = std::max(capacity + (capacity >> 1), byteLength + amount);
+
+    uint8_t *b = new uint8_t[capacity];
+    if (mData) memcpy(b, mData.get(), byteLength);
+    mData.reset(b, std::default_delete<uint8_t[]>());
+    byteLength += amount;
+}
+
+//
+// struct BufferView
+//
+
+inline void BufferView::Read(Value &obj, Asset &r) {
+    const char *bufferId = MemberOrDefault<const char *>(obj, "buffer", 0);
+    if (bufferId) {
+        buffer = r.buffers.Get(bufferId);
+    }
+
+    byteOffset = MemberOrDefault(obj, "byteOffset", 0u);
+    byteLength = MemberOrDefault(obj, "byteLength", 0u);
+}
+
+//
+// struct Accessor
+//
+
+inline void Accessor::Read(Value &obj, Asset &r) {
+    const char *bufferViewId = MemberOrDefault<const char *>(obj, "bufferView", 0);
+    if (bufferViewId) {
+        bufferView = r.bufferViews.Get(bufferViewId);
+    }
+
+    byteOffset = MemberOrDefault(obj, "byteOffset", 0u);
+    byteStride = MemberOrDefault(obj, "byteStride", 0u);
+    componentType = MemberOrDefault(obj, "componentType", ComponentType_BYTE);
+    count = MemberOrDefault(obj, "count", 0u);
+
+    const char *typestr;
+    type = ReadMember(obj, "type", typestr) ? AttribType::FromString(typestr) : AttribType::SCALAR;
+}
+
+inline unsigned int Accessor::GetNumComponents() {
+    return AttribType::GetNumComponents(type);
+}
+
+inline unsigned int Accessor::GetBytesPerComponent() {
+    return int(ComponentTypeSize(componentType));
+}
+
+inline unsigned int Accessor::GetElementSize() {
+    return GetNumComponents() * GetBytesPerComponent();
+}
+
+inline uint8_t *Accessor::GetPointer() {
+    if (!bufferView || !bufferView->buffer) return 0;
+    uint8_t *basePtr = bufferView->buffer->GetPointer();
+    if (!basePtr) return 0;
+
+    size_t offset = byteOffset + bufferView->byteOffset;
+
+    // Check if region is encoded.
+    if (bufferView->buffer->EncodedRegion_Current != nullptr) {
+        const size_t begin = bufferView->buffer->EncodedRegion_Current->Offset;
+        const size_t end = begin + bufferView->buffer->EncodedRegion_Current->DecodedData_Length;
+
+        if ((offset >= begin) && (offset < end))
+            return &bufferView->buffer->EncodedRegion_Current->DecodedData[offset - begin];
+    }
+
+    return basePtr + offset;
+}
+
+namespace {
+inline void CopyData(size_t count,
+        const uint8_t *src, size_t src_stride,
+        uint8_t *dst, size_t dst_stride) {
+    if (src_stride == dst_stride) {
+        memcpy(dst, src, count * src_stride);
+    } else {
+        size_t sz = std::min(src_stride, dst_stride);
+        for (size_t i = 0; i < count; ++i) {
+            memcpy(dst, src, sz);
+            if (sz < dst_stride) {
+                memset(dst + sz, 0, dst_stride - sz);
+            }
+            src += src_stride;
+            dst += dst_stride;
+        }
+    }
+}
+} // namespace
+
+template <class T>
+bool Accessor::ExtractData(T *&outData) {
+    uint8_t *data = GetPointer();
+    if (!data) return false;
+
+    const size_t elemSize = GetElementSize();
+    const size_t totalSize = elemSize * count;
+
+    const size_t stride = byteStride ? byteStride : elemSize;
+
+    const size_t targetElemSize = sizeof(T);
+    ai_assert(elemSize <= targetElemSize);
+
+    ai_assert(count * stride <= bufferView->byteLength);
+
+    outData = new T[count];
+    if (stride == elemSize && targetElemSize == elemSize) {
+        memcpy(outData, data, totalSize);
+    } else {
+        for (size_t i = 0; i < count; ++i) {
+            memcpy(outData + i, data + i * stride, elemSize);
+        }
+    }
+
+    return true;
+}
+
+inline void Accessor::WriteData(size_t cnt, const void *src_buffer, size_t src_stride) {
+    uint8_t *buffer_ptr = bufferView->buffer->GetPointer();
+    size_t offset = byteOffset + bufferView->byteOffset;
+
+    size_t dst_stride = GetNumComponents() * GetBytesPerComponent();
+
+    const uint8_t *src = reinterpret_cast<const uint8_t *>(src_buffer);
+    uint8_t *dst = reinterpret_cast<uint8_t *>(buffer_ptr + offset);
+
+    ai_assert(dst + count * dst_stride <= buffer_ptr + bufferView->buffer->byteLength);
+    CopyData(cnt, src, src_stride, dst, dst_stride);
+}
+
+inline Accessor::Indexer::Indexer(Accessor &acc) :
+        accessor(acc), data(acc.GetPointer()), elemSize(acc.GetElementSize()), stride(acc.byteStride ? acc.byteStride : elemSize) {
+}
+
+//! Accesses the i-th value as defined by the accessor
+template <class T>
+T Accessor::Indexer::GetValue(int i) {
+    ai_assert(data);
+    ai_assert(i * stride < accessor.bufferView->byteLength);
+    T value = T();
+    memcpy(&value, data + i * stride, elemSize);
+    //value >>= 8 * (sizeof(T) - elemSize);
+    return value;
+}
+
+inline Image::Image() :
+        width(0), height(0), mDataLength(0) {
+}
+
+inline void Image::Read(Value &obj, Asset &r) {
+    // Check for extensions first (to detect binary embedded data)
+    if (Value *extensions = FindObject(obj, "extensions")) {
+        if (r.extensionsUsed.KHR_binary_glTF) {
+            if (Value *ext = FindObject(*extensions, "KHR_binary_glTF")) {
+
+                width = MemberOrDefault(*ext, "width", 0);
+                height = MemberOrDefault(*ext, "height", 0);
+
+                ReadMember(*ext, "mimeType", mimeType);
+
+                const char *bufferViewId;
+                if (ReadMember(*ext, "bufferView", bufferViewId)) {
+                    Ref<BufferView> bv = r.bufferViews.Get(bufferViewId);
+                    if (bv) {
+                        mDataLength = bv->byteLength;
+                        mData.reset(new uint8_t[mDataLength]);
+                        memcpy(mData.get(), bv->buffer->GetPointer() + bv->byteOffset, mDataLength);
+                    }
+                }
+            }
+        }
+    }
+
+    if (!mDataLength) {
+        Value *curUri = FindString(obj, "uri");
+        if (nullptr != curUri) {
+            const char *uristr = curUri->GetString();
+
+            glTFCommon::Util::DataURI dataURI;
+            if (ParseDataURI(uristr, curUri->GetStringLength(), dataURI)) {
+                mimeType = dataURI.mediaType;
+                if (dataURI.base64) {
+                    uint8_t *ptr = nullptr;
+                    mDataLength = Base64::Decode(dataURI.data, dataURI.dataLength, ptr);
+                    mData.reset(ptr);
+                }
+            } else {
+                this->uri = uristr;
+            }
+        }
+    }
+}
+
+inline uint8_t *Image::StealData() {
+    mDataLength = 0;
+    return mData.release();
+}
+
+inline void Image::SetData(uint8_t *data, size_t length, Asset &r) {
+    Ref<Buffer> b = r.GetBodyBuffer();
+    if (b) { // binary file: append to body
+        std::string bvId = r.FindUniqueID(this->id, "imgdata");
+        bufferView = r.bufferViews.Create(bvId);
+
+        bufferView->buffer = b;
+        bufferView->byteLength = length;
+        bufferView->byteOffset = b->AppendData(data, length);
+    } else { // text file: will be stored as a data uri
+        uint8_t *temp = new uint8_t[length];
+        memcpy(temp, data, length);
+        this->mData.reset(temp);
+        this->mDataLength = length;
+    }
+}
+
+inline void Sampler::Read(Value &obj, Asset & /*r*/) {
+    SetDefaults();
+
+    ReadMember(obj, "magFilter", magFilter);
+    ReadMember(obj, "minFilter", minFilter);
+    ReadMember(obj, "wrapS", wrapS);
+    ReadMember(obj, "wrapT", wrapT);
+}
+
+inline void Sampler::SetDefaults() {
+    magFilter = SamplerMagFilter_Linear;
+    minFilter = SamplerMinFilter_Linear;
+    wrapS = SamplerWrap_Repeat;
+    wrapT = SamplerWrap_Repeat;
+}
+
+inline void Texture::Read(Value &obj, Asset &r) {
+    const char *sourcestr;
+    if (ReadMember(obj, "source", sourcestr)) {
+        source = r.images.Get(sourcestr);
+    }
+
+    const char *samplerstr;
+    if (ReadMember(obj, "sampler", samplerstr)) {
+        sampler = r.samplers.Get(samplerstr);
+    }
+}
+
+namespace {
+inline void ReadMaterialProperty(Asset &r, Value &vals, const char *propName, TexProperty &out) {
+    if (Value *prop = FindMember(vals, propName)) {
+        if (prop->IsString()) {
+            out.texture = r.textures.Get(prop->GetString());
+        } else {
+            ReadValue(*prop, out.color);
+        }
+    }
+}
+} // namespace
+
+inline void Material::Read(Value &material, Asset &r) {
+    SetDefaults();
+
+    if (Value *values = FindObject(material, "values")) {
+        ReadMaterialProperty(r, *values, "ambient", this->ambient);
+        ReadMaterialProperty(r, *values, "diffuse", this->diffuse);
+        ReadMaterialProperty(r, *values, "specular", this->specular);
+
+        ReadMember(*values, "transparency", transparency);
+        ReadMember(*values, "shininess", shininess);
+    }
+
+    if (Value *extensions = FindObject(material, "extensions")) {
+        if (r.extensionsUsed.KHR_materials_common) {
+            if (Value *ext = FindObject(*extensions, "KHR_materials_common")) {
+                if (Value *tnq = FindString(*ext, "technique")) {
+                    const char *t = tnq->GetString();
+                    if (strcmp(t, "BLINN") == 0)
+                        technique = Technique_BLINN;
+                    else if (strcmp(t, "PHONG") == 0)
+                        technique = Technique_PHONG;
+                    else if (strcmp(t, "LAMBERT") == 0)
+                        technique = Technique_LAMBERT;
+                    else if (strcmp(t, "CONSTANT") == 0)
+                        technique = Technique_CONSTANT;
+                }
+
+                if (Value *values = FindObject(*ext, "values")) {
+                    ReadMaterialProperty(r, *values, "ambient", this->ambient);
+                    ReadMaterialProperty(r, *values, "diffuse", this->diffuse);
+                    ReadMaterialProperty(r, *values, "specular", this->specular);
+
+                    ReadMember(*values, "doubleSided", doubleSided);
+                    ReadMember(*values, "transparent", transparent);
+                    ReadMember(*values, "transparency", transparency);
+                    ReadMember(*values, "shininess", shininess);
+                }
+            }
+        }
+    }
+}
+
+namespace {
+void SetVector(vec4 &v, float x, float y, float z, float w) {
+    v[0] = x;
+    v[1] = y;
+    v[2] = z;
+    v[3] = w;
+}
+} // namespace
+
+inline void Material::SetDefaults() {
+    SetVector(ambient.color, 0, 0, 0, 1);
+    SetVector(diffuse.color, 0, 0, 0, 1);
+    SetVector(specular.color, 0, 0, 0, 1);
+    SetVector(emission.color, 0, 0, 0, 1);
+
+    doubleSided = false;
+    transparent = false;
+    transparency = 1.0;
+    shininess = 0.0;
+
+    technique = Technique_undefined;
+}
+
+namespace {
+
+template <int N>
+inline int Compare(const char *attr, const char (&str)[N]) {
+    return (strncmp(attr, str, N - 1) == 0) ? N - 1 : 0;
+}
+
+inline bool GetAttribVector(Mesh::Primitive &p, const char *attr, Mesh::AccessorList *&v, int &pos) {
+    if ((pos = Compare(attr, "POSITION"))) {
+        v = &(p.attributes.position);
+    } else if ((pos = Compare(attr, "NORMAL"))) {
+        v = &(p.attributes.normal);
+    } else if ((pos = Compare(attr, "TEXCOORD"))) {
+        v = &(p.attributes.texcoord);
+    } else if ((pos = Compare(attr, "COLOR"))) {
+        v = &(p.attributes.color);
+    } else if ((pos = Compare(attr, "JOINT"))) {
+        v = &(p.attributes.joint);
+    } else if ((pos = Compare(attr, "JOINTMATRIX"))) {
+        v = &(p.attributes.jointmatrix);
+    } else if ((pos = Compare(attr, "WEIGHT"))) {
+        v = &(p.attributes.weight);
+    } else
+        return false;
+    return true;
+}
+} // namespace
+
+inline void Mesh::Read(Value &pJSON_Object, Asset &pAsset_Root) {
+    /****************** Mesh primitives ******************/
+    Value *curPrimitives = FindArray(pJSON_Object, "primitives");
+    if (nullptr != curPrimitives) {
+        this->primitives.resize(curPrimitives->Size());
+        for (unsigned int i = 0; i < curPrimitives->Size(); ++i) {
+            Value &primitive = (*curPrimitives)[i];
+
+            Primitive &prim = this->primitives[i];
+            prim.mode = MemberOrDefault(primitive, "mode", PrimitiveMode_TRIANGLES);
+
+            if (Value *attrs = FindObject(primitive, "attributes")) {
+                for (Value::MemberIterator it = attrs->MemberBegin(); it != attrs->MemberEnd(); ++it) {
+                    if (!it->value.IsString()) continue;
+                    const char *attr = it->name.GetString();
+                    // Valid attribute semantics include POSITION, NORMAL, TEXCOORD, COLOR, JOINT, JOINTMATRIX,
+                    // and WEIGHT.Attribute semantics can be of the form[semantic]_[set_index], e.g., TEXCOORD_0, TEXCOORD_1, etc.
+
+                    int undPos = 0;
+                    Mesh::AccessorList *vec = 0;
+                    if (GetAttribVector(prim, attr, vec, undPos)) {
+                        size_t idx = (attr[undPos] == '_') ? atoi(attr + undPos + 1) : 0;
+                        if ((*vec).size() <= idx) (*vec).resize(idx + 1);
+                        (*vec)[idx] = pAsset_Root.accessors.Get(it->value.GetString());
+                    }
+                }
+            }
+
+            if (Value *indices = FindString(primitive, "indices")) {
+                prim.indices = pAsset_Root.accessors.Get(indices->GetString());
+            }
+
+            if (Value *material = FindString(primitive, "material")) {
+                prim.material = pAsset_Root.materials.Get(material->GetString());
+            }
+        }
+    }
+
+    /****************** Mesh extensions ******************/
+    Value *json_extensions = FindObject(pJSON_Object, "extensions");
+
+    if (json_extensions == nullptr) goto mr_skip_extensions;
+
+#ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC
+    for (Value::MemberIterator it_memb = json_extensions->MemberBegin(); it_memb != json_extensions->MemberEnd(); it_memb++) {
+        if (it_memb->name.GetString() == std::string("Open3DGC-compression")) {
+            // Search for compressed data.
+            // Compressed data contain description of part of "buffer" which is encoded. This part must be decoded and
+            // new data will replace old encoded part by request. In fact \"compressedData\" is kind of "accessor" structure.
+            Value *comp_data = FindObject(it_memb->value, "compressedData");
+
+            if (comp_data == nullptr) throw DeadlyImportError("GLTF: \"Open3DGC-compression\" must has \"compressedData\".");
+
+            ASSIMP_LOG_INFO("GLTF: Decompressing Open3DGC data.");
+
+/************** Read data from JSON-document **************/
+#define MESH_READ_COMPRESSEDDATA_MEMBER(pFieldName, pOut)                                   \
+    if (!ReadMember(*comp_data, pFieldName, pOut)) {                                        \
+        throw DeadlyImportError("GLTF: \"compressedData\" must has \"", pFieldName, "\"."); \
+    }
+
+            const char *mode_str;
+            const char *type_str;
+            ComponentType component_type;
+            SCompression_Open3DGC *ext_o3dgc = new SCompression_Open3DGC;
+
+            MESH_READ_COMPRESSEDDATA_MEMBER("buffer", ext_o3dgc->Buffer);
+            MESH_READ_COMPRESSEDDATA_MEMBER("byteOffset", ext_o3dgc->Offset);
+            MESH_READ_COMPRESSEDDATA_MEMBER("componentType", component_type);
+            MESH_READ_COMPRESSEDDATA_MEMBER("type", type_str);
+            MESH_READ_COMPRESSEDDATA_MEMBER("count", ext_o3dgc->Count);
+            MESH_READ_COMPRESSEDDATA_MEMBER("mode", mode_str);
+            MESH_READ_COMPRESSEDDATA_MEMBER("indicesCount", ext_o3dgc->IndicesCount);
+            MESH_READ_COMPRESSEDDATA_MEMBER("verticesCount", ext_o3dgc->VerticesCount);
+
+#undef MESH_READ_COMPRESSEDDATA_MEMBER
+
+            // Check some values
+            if (strcmp(type_str, "SCALAR")) throw DeadlyImportError("GLTF: only \"SCALAR\" type is supported for compressed data.");
+            if (component_type != ComponentType_UNSIGNED_BYTE) throw DeadlyImportError("GLTF: only \"UNSIGNED_BYTE\" component type is supported for compressed data.");
+
+            // Set read/write data mode.
+            if (strcmp(mode_str, "binary") == 0)
+                ext_o3dgc->Binary = true;
+            else if (strcmp(mode_str, "ascii") == 0)
+                ext_o3dgc->Binary = false;
+            else
+                throw DeadlyImportError("GLTF: for compressed data supported modes is: \"ascii\", \"binary\". Not the: \"", mode_str, "\".");
+
+            /************************ Decoding ************************/
+            Decode_O3DGC(*ext_o3dgc, pAsset_Root);
+            Extension.push_back(ext_o3dgc); // store info in mesh extensions list.
+        } // if(it_memb->name.GetString() == "Open3DGC-compression")
+        else {
+            throw DeadlyImportError("GLTF: Unknown mesh extension: \"", it_memb->name.GetString(), "\".");
+        }
+    } // for(Value::MemberIterator it_memb = json_extensions->MemberBegin(); it_memb != json_extensions->MemberEnd(); json_extensions++)
+#endif
+
+mr_skip_extensions:
+
+    return; // After label some operators must be present.
+}
+
+#ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC
+inline void Mesh::Decode_O3DGC(const SCompression_Open3DGC &pCompression_Open3DGC, Asset &pAsset_Root) {
+    typedef unsigned short IndicesType; ///< \sa glTFExporter::ExportMeshes.
+
+    o3dgc::SC3DMCDecoder<IndicesType> decoder;
+    o3dgc::IndexedFaceSet<IndicesType> ifs;
+    o3dgc::BinaryStream bstream;
+    uint8_t *decoded_data;
+    size_t decoded_data_size = 0;
+    Ref<Buffer> buf = pAsset_Root.buffers.Get(pCompression_Open3DGC.Buffer);
+
+    // Read data from buffer and place it in BinaryStream for decoder.
+    // Just "Count" because always is used type equivalent to uint8_t.
+    bstream.LoadFromBuffer(&buf->GetPointer()[pCompression_Open3DGC.Offset], static_cast<unsigned long>(pCompression_Open3DGC.Count));
+
+    // After decoding header we can get size of primitives.
+    if (decoder.DecodeHeader(ifs, bstream) != o3dgc::O3DGC_OK) throw DeadlyImportError("GLTF: can not decode Open3DGC header.");
+
+    /****************** Get sizes of arrays and check sizes ******************/
+    // Note. See "Limitations for meshes when using Open3DGC-compression".
+
+    // Indices
+    size_t size_coordindex = ifs.GetNCoordIndex() * 3; // See float attributes note.
+
+    if (primitives[0].indices->count != size_coordindex)
+        throw DeadlyImportError("GLTF: Open3DGC. Compressed indices count (", ai_to_string(size_coordindex),
+                ") not equal to uncompressed (", ai_to_string(primitives[0].indices->count), ").");
+
+    size_coordindex *= sizeof(IndicesType);
+    // Coordinates
+    size_t size_coord = ifs.GetNCoord(); // See float attributes note.
+
+    if (primitives[0].attributes.position[0]->count != size_coord)
+        throw DeadlyImportError("GLTF: Open3DGC. Compressed positions count (", ai_to_string(size_coord),
+                ") not equal to uncompressed (", ai_to_string(primitives[0].attributes.position[0]->count), ").");
+
+    size_coord *= 3 * sizeof(float);
+    // Normals
+    size_t size_normal = ifs.GetNNormal(); // See float attributes note.
+
+    if (primitives[0].attributes.normal[0]->count != size_normal)
+        throw DeadlyImportError("GLTF: Open3DGC. Compressed normals count (", ai_to_string(size_normal),
+                ") not equal to uncompressed (", ai_to_string(primitives[0].attributes.normal[0]->count), ").");
+
+    size_normal *= 3 * sizeof(float);
+    // Additional attributes.
+    std::vector<size_t> size_floatattr;
+    std::vector<size_t> size_intattr;
+
+    size_floatattr.resize(ifs.GetNumFloatAttributes());
+    size_intattr.resize(ifs.GetNumIntAttributes());
+
+    decoded_data_size = size_coordindex + size_coord + size_normal;
+    for (size_t idx = 0, idx_end = size_floatattr.size(), idx_texcoord = 0; idx < idx_end; idx++) {
+        // size = number_of_elements * components_per_element * size_of_component.
+        // Note. But as you can see above, at first we are use this variable in meaning "count". After checking count of objects...
+        size_t tval = ifs.GetNFloatAttribute(static_cast<unsigned long>(idx));
+
+        switch (ifs.GetFloatAttributeType(static_cast<unsigned long>(idx))) {
+        case o3dgc::O3DGC_IFS_FLOAT_ATTRIBUTE_TYPE_TEXCOORD:
+            // Check situation when encoded data contain texture coordinates but primitive not.
+            if (idx_texcoord < primitives[0].attributes.texcoord.size()) {
+                if (primitives[0].attributes.texcoord[idx]->count != tval)
+                    throw DeadlyImportError("GLTF: Open3DGC. Compressed texture coordinates count (", ai_to_string(tval),
+                            ") not equal to uncompressed (", ai_to_string(primitives[0].attributes.texcoord[idx]->count), ").");
+
+                idx_texcoord++;
+            } else {
+                ifs.SetNFloatAttribute(static_cast<unsigned long>(idx), 0ul); // Disable decoding this attribute.
+            }
+
+            break;
+        default:
+            throw DeadlyImportError("GLTF: Open3DGC. Unsupported type of float attribute: ", ai_to_string(ifs.GetFloatAttributeType(static_cast<unsigned long>(idx))));
+        }
+
+        tval *= ifs.GetFloatAttributeDim(static_cast<unsigned long>(idx)) * sizeof(o3dgc::Real); // After checking count of objects we can get size of array.
+        size_floatattr[idx] = tval;
+        decoded_data_size += tval;
+    }
+
+    for (size_t idx = 0, idx_end = size_intattr.size(); idx < idx_end; idx++) {
+        // size = number_of_elements * components_per_element * size_of_component. See float attributes note.
+        size_t tval = ifs.GetNIntAttribute(static_cast<unsigned long>(idx));
+        switch (ifs.GetIntAttributeType(static_cast<unsigned long>(idx))) {
+        case o3dgc::O3DGC_IFS_INT_ATTRIBUTE_TYPE_UNKOWN:
+        case o3dgc::O3DGC_IFS_INT_ATTRIBUTE_TYPE_INDEX:
+        case o3dgc::O3DGC_IFS_INT_ATTRIBUTE_TYPE_JOINT_ID:
+        case o3dgc::O3DGC_IFS_INT_ATTRIBUTE_TYPE_INDEX_BUFFER_ID:
+            break;
+
+        default:
+            throw DeadlyImportError("GLTF: Open3DGC. Unsupported type of int attribute: ", ai_to_string(ifs.GetIntAttributeType(static_cast<unsigned long>(idx))));
+        }
+
+        tval *= ifs.GetIntAttributeDim(static_cast<unsigned long>(idx)) * sizeof(long); // See float attributes note.
+        size_intattr[idx] = tval;
+        decoded_data_size += tval;
+    }
+
+    // Create array for decoded data.
+    decoded_data = new uint8_t[decoded_data_size];
+
+    /****************** Set right array regions for decoder ******************/
+
+    auto get_buf_offset = [](Ref<Accessor> &pAccessor) -> size_t { return pAccessor->byteOffset + pAccessor->bufferView->byteOffset; };
+
+    // Indices
+    ifs.SetCoordIndex((IndicesType *const)(decoded_data + get_buf_offset(primitives[0].indices)));
+    // Coordinates
+    ifs.SetCoord((o3dgc::Real *const)(decoded_data + get_buf_offset(primitives[0].attributes.position[0])));
+    // Normals
+    if (size_normal) {
+        ifs.SetNormal((o3dgc::Real *const)(decoded_data + get_buf_offset(primitives[0].attributes.normal[0])));
+    }
+
+    for (size_t idx = 0, idx_end = size_floatattr.size(), idx_texcoord = 0; idx < idx_end; idx++) {
+        switch (ifs.GetFloatAttributeType(static_cast<unsigned long>(idx))) {
+        case o3dgc::O3DGC_IFS_FLOAT_ATTRIBUTE_TYPE_TEXCOORD:
+            if (idx_texcoord < primitives[0].attributes.texcoord.size()) {
+                // See above about absent attributes.
+                ifs.SetFloatAttribute(static_cast<unsigned long>(idx), (o3dgc::Real *const)(decoded_data + get_buf_offset(primitives[0].attributes.texcoord[idx])));
+                idx_texcoord++;
+            }
+
+            break;
+        default:
+            throw DeadlyImportError("GLTF: Open3DGC. Unsupported type of float attribute: ", ai_to_string(ifs.GetFloatAttributeType(static_cast<unsigned long>(idx))));
+        }
+    }
+
+    for (size_t idx = 0, idx_end = size_intattr.size(); idx < idx_end; idx++) {
+        switch (ifs.GetIntAttributeType(static_cast<unsigned int>(idx))) {
+        case o3dgc::O3DGC_IFS_INT_ATTRIBUTE_TYPE_UNKOWN:
+        case o3dgc::O3DGC_IFS_INT_ATTRIBUTE_TYPE_INDEX:
+        case o3dgc::O3DGC_IFS_INT_ATTRIBUTE_TYPE_JOINT_ID:
+        case o3dgc::O3DGC_IFS_INT_ATTRIBUTE_TYPE_INDEX_BUFFER_ID:
+            break;
+
+        // ifs.SetIntAttribute(idx, (long* const)(decoded_data + get_buf_offset(primitives[0].attributes.joint)));
+        default:
+            throw DeadlyImportError("GLTF: Open3DGC. Unsupported type of int attribute: ", ai_to_string(ifs.GetIntAttributeType(static_cast<unsigned long>(idx))));
+        }
+    }
+
+    //
+    // Decode data
+    //
+    if (decoder.DecodePayload(ifs, bstream) != o3dgc::O3DGC_OK) {
+        throw DeadlyImportError("GLTF: can not decode Open3DGC data.");
+    }
+
+    // Set encoded region for "buffer".
+    buf->EncodedRegion_Mark(pCompression_Open3DGC.Offset, pCompression_Open3DGC.Count, decoded_data, decoded_data_size, id);
+    // No. Do not delete "output_data". After calling "EncodedRegion_Mark" bufferView is owner of "output_data".
+    // "delete [] output_data;"
+}
+#endif
+
+inline void Camera::Read(Value &obj, Asset & /*r*/) {
+    type = MemberOrDefault(obj, "type", Camera::Perspective);
+
+    const char *subobjId = (type == Camera::Orthographic) ? "orthographic" : "perspective";
+
+    Value *it = FindObject(obj, subobjId);
+    if (!it) throw DeadlyImportError("GLTF: Camera missing its parameters");
+
+    if (type == Camera::Perspective) {
+        perspective.aspectRatio = MemberOrDefault(*it, "aspectRatio", 0.f);
+        perspective.yfov = MemberOrDefault(*it, "yfov", 3.1415f / 2.f);
+        perspective.zfar = MemberOrDefault(*it, "zfar", 100.f);
+        perspective.znear = MemberOrDefault(*it, "znear", 0.01f);
+    } else {
+        ortographic.xmag = MemberOrDefault(*it, "xmag", 1.f);
+        ortographic.ymag = MemberOrDefault(*it, "ymag", 1.f);
+        ortographic.zfar = MemberOrDefault(*it, "zfar", 100.f);
+        ortographic.znear = MemberOrDefault(*it, "znear", 0.01f);
+    }
+}
+
+inline void Light::Read(Value &obj, Asset & /*r*/) {
+    SetDefaults();
+
+    Value *curType = FindString(obj, "type");
+    if (nullptr != curType) {
+        const char *t = curType->GetString();
+        if (strcmp(t, "ambient") == 0)
+            this->type = Type_ambient;
+        else if (strcmp(t, "directional") == 0)
+            this->type = Type_directional;
+        else if (strcmp(t, "point") == 0)
+            this->type = Type_point;
+        else if (strcmp(t, "spot") == 0)
+            this->type = Type_spot;
+
+        if (this->type != Type_undefined) {
+            if (Value *vals = FindString(obj, t)) {
+                ReadMember(*vals, "color", color);
+
+                ReadMember(*vals, "constantAttenuation", constantAttenuation);
+                ReadMember(*vals, "linearAttenuation", linearAttenuation);
+                ReadMember(*vals, "quadraticAttenuation", quadraticAttenuation);
+                ReadMember(*vals, "distance", distance);
+
+                ReadMember(*vals, "falloffAngle", falloffAngle);
+                ReadMember(*vals, "falloffExponent", falloffExponent);
+            }
+        }
+    }
+}
+
+inline void Light::SetDefaults() {
+#ifndef M_PI
+    const float M_PI = 3.14159265358979323846f;
+#endif
+
+    type = Type_undefined;
+
+    SetVector(color, 0.f, 0.f, 0.f, 1.f);
+
+    constantAttenuation = 0.f;
+    linearAttenuation = 1.f;
+    quadraticAttenuation = 1.f;
+    distance = 0.f;
+
+    falloffAngle = static_cast<float>(M_PI / 2.f);
+    falloffExponent = 0.f;
+}
+
+inline void Node::Read(Value &obj, Asset &r) {
+    if (name.empty()) {
+        name = id;
+    }
+
+    Value *curChildren = FindArray(obj, "children");
+    if (nullptr != curChildren) {
+        this->children.reserve(curChildren->Size());
+        for (unsigned int i = 0; i < curChildren->Size(); ++i) {
+            Value &child = (*curChildren)[i];
+            if (child.IsString()) {
+                // get/create the child node
+                Ref<Node> chn = r.nodes.Get(child.GetString());
+                if (chn) this->children.push_back(chn);
+            }
+        }
+    }
+
+    Value *curMatrix = FindArray(obj, "matrix");
+    if (nullptr != curMatrix) {
+        ReadValue(*curMatrix, this->matrix);
+    } else {
+        ReadMember(obj, "translation", translation);
+        ReadMember(obj, "scale", scale);
+        ReadMember(obj, "rotation", rotation);
+    }
+
+    Value *curMeshes = FindArray(obj, "meshes");
+    if (nullptr != curMeshes) {
+        unsigned int numMeshes = (unsigned int)curMeshes->Size();
+
+        std::vector<unsigned int> meshList;
+
+        this->meshes.reserve(numMeshes);
+        for (unsigned i = 0; i < numMeshes; ++i) {
+            if ((*curMeshes)[i].IsString()) {
+                Ref<Mesh> mesh = r.meshes.Get((*curMeshes)[i].GetString());
+                if (mesh) {
+                    this->meshes.push_back(mesh);
+                }
+            }
+        }
+    }
+
+    Value *curCamera = FindString(obj, "camera");
+    if (nullptr != curCamera) {
+        this->camera = r.cameras.Get(curCamera->GetString());
+        if (this->camera) {
+            this->camera->id = this->id;
+        }
+    }
+
+    // TODO load "skeletons", "skin", "jointName"
+
+    if (Value *extensions = FindObject(obj, "extensions")) {
+        if (r.extensionsUsed.KHR_materials_common) {
+
+            if (Value *ext = FindObject(*extensions, "KHR_materials_common")) {
+                Value *curLight = FindString(*ext, "light");
+                if (nullptr != curLight) {
+                    this->light = r.lights.Get(curLight->GetString());
+                }
+            }
+        }
+    }
+}
+
+inline void Scene::Read(Value &obj, Asset &r) {
+    if (Value *array = FindArray(obj, "nodes")) {
+        for (unsigned int i = 0; i < array->Size(); ++i) {
+            if (!(*array)[i].IsString()) continue;
+            Ref<Node> node = r.nodes.Get((*array)[i].GetString());
+            if (node)
+                this->nodes.push_back(node);
+        }
+    }
+}
+
+inline void AssetMetadata::Read(Document &doc) {
+    // read the version, etc.
+    if (Value *obj = FindObject(doc, "asset")) {
+        ReadMember(*obj, "copyright", copyright);
+        ReadMember(*obj, "generator", generator);
+
+        premultipliedAlpha = MemberOrDefault(*obj, "premultipliedAlpha", false);
+
+        if (Value *versionString = FindString(*obj, "version")) {
+            version = versionString->GetString();
+        } else if (Value *versionNumber = FindNumber(*obj, "version")) {
+            char buf[4];
+
+            ai_snprintf(buf, 4, "%.1f", versionNumber->GetDouble());
+
+            version = buf;
+        }
+
+        Value *curProfile = FindObject(*obj, "profile");
+        if (nullptr != curProfile) {
+            ReadMember(*curProfile, "api", this->profile.api);
+            ReadMember(*curProfile, "version", this->profile.version);
+        }
+    }
+
+    if (version.empty() || version[0] != '1') {
+        throw DeadlyImportError("GLTF: Unsupported glTF version: ", version);
+    }
+}
+
+//
+// Asset methods implementation
+//
+
+inline void Asset::ReadBinaryHeader(IOStream &stream) {
+    GLB_Header header;
+    if (stream.Read(&header, sizeof(header), 1) != 1) {
+        throw DeadlyImportError("GLTF: Unable to read the file header");
+    }
+
+    if (strncmp((char *)header.magic, AI_GLB_MAGIC_NUMBER, sizeof(header.magic)) != 0) {
+        throw DeadlyImportError("GLTF: Invalid binary glTF file");
+    }
+
+    AI_SWAP4(header.version);
+    asset.version = ai_to_string(header.version);
+    if (header.version != 1) {
+        throw DeadlyImportError("GLTF: Unsupported binary glTF version");
+    }
+
+    AI_SWAP4(header.sceneFormat);
+    if (header.sceneFormat != SceneFormat_JSON) {
+        throw DeadlyImportError("GLTF: Unsupported binary glTF scene format");
+    }
+
+    AI_SWAP4(header.length);
+    AI_SWAP4(header.sceneLength);
+
+    static_assert(std::numeric_limits<uint32_t>::max() <= std::numeric_limits<size_t>::max(), "size_t must be at least 32bits");
+    mSceneLength = static_cast<size_t>(header.sceneLength); // Can't be larger than 4GB (max. uint32_t)
+
+    mBodyOffset = sizeof(header) + mSceneLength;
+    mBodyOffset = (mBodyOffset + 3) & ~3; // Round up to next multiple of 4
+
+    mBodyLength = header.length - mBodyOffset;
+}
+
+inline void Asset::Load(const std::string &pFile, bool isBinary) {
+    mCurrentAssetDir.clear();
+
+    /*int pos = std::max(int(pFile.rfind('/')), int(pFile.rfind('\\')));
+    if (pos != int(std::string::npos)) mCurrentAssetDir = pFile.substr(0, pos + 1);*/
+    if (0 != strncmp(pFile.c_str(), AI_MEMORYIO_MAGIC_FILENAME, AI_MEMORYIO_MAGIC_FILENAME_LENGTH)) {
+        mCurrentAssetDir = getCurrentAssetDir(pFile);
+    }
+
+    shared_ptr<IOStream> stream(OpenFile(pFile.c_str(), "rb", true));
+    if (!stream) {
+        throw DeadlyImportError("GLTF: Could not open file for reading");
+    }
+
+    // is binary? then read the header
+    if (isBinary) {
+        SetAsBinary(); // also creates the body buffer
+        ReadBinaryHeader(*stream);
+    } else {
+        mSceneLength = stream->FileSize();
+        mBodyLength = 0;
+    }
+
+    // Smallest legal JSON file is "{}" Smallest loadable glTF file is larger than that but catch it later
+    if (mSceneLength < 2) {
+        throw DeadlyImportError("GLTF: No JSON file contents");
+    }
+
+    // Binary format only supports up to 4GB of JSON so limit it there to avoid extreme memory allocation
+    if (mSceneLength >= std::numeric_limits<uint32_t>::max()) {
+        throw DeadlyImportError("GLTF: JSON size greater than 4GB");
+    }
+
+    // read the scene data, ensure null termination
+    std::vector<char> sceneData(mSceneLength + 1);
+    sceneData[mSceneLength] = '\0';
+
+    if (stream->Read(&sceneData[0], 1, mSceneLength) != mSceneLength) {
+        throw DeadlyImportError("GLTF: Could not read the file contents");
+    }
+
+    // parse the JSON document
+
+    Document doc;
+    doc.ParseInsitu(&sceneData[0]);
+
+    if (doc.HasParseError()) {
+        char buffer[32];
+        ai_snprintf(buffer, 32, "%d", static_cast<int>(doc.GetErrorOffset()));
+        throw DeadlyImportError("GLTF: JSON parse error, offset ", buffer, ": ", GetParseError_En(doc.GetParseError()));
+    }
+
+    if (!doc.IsObject()) {
+        throw DeadlyImportError("GLTF: JSON document root must be a JSON object");
+    }
+
+    // Fill the buffer instance for the current file embedded contents
+    if (mBodyLength > 0) {
+        if (!mBodyBuffer->LoadFromStream(*stream, mBodyLength, mBodyOffset)) {
+            throw DeadlyImportError("GLTF: Unable to read gltf file");
+        }
+    }
+
+    // Load the metadata
+    asset.Read(doc);
+    ReadExtensionsUsed(doc);
+
+    // Prepare the dictionaries
+    for (size_t i = 0; i < mDicts.size(); ++i) {
+        mDicts[i]->AttachToDocument(doc);
+    }
+
+    // Read the "scene" property, which specifies which scene to load
+    // and recursively load everything referenced by it
+    Value *curScene = FindString(doc, "scene");
+    if (nullptr != curScene) {
+        this->scene = scenes.Get(curScene->GetString());
+    }
+
+    // Clean up
+    for (size_t i = 0; i < mDicts.size(); ++i) {
+        mDicts[i]->DetachFromDocument();
+    }
+}
+
+inline void Asset::SetAsBinary() {
+    if (!extensionsUsed.KHR_binary_glTF) {
+        extensionsUsed.KHR_binary_glTF = true;
+        mBodyBuffer = buffers.Create("binary_glTF");
+        mBodyBuffer->MarkAsSpecial();
+    }
+}
+
+inline void Asset::ReadExtensionsUsed(Document &doc) {
+    Value *extsUsed = FindArray(doc, "extensionsUsed");
+    if (!extsUsed) return;
+
+    std::gltf_unordered_map<std::string, bool> exts;
+
+    for (unsigned int i = 0; i < extsUsed->Size(); ++i) {
+        if ((*extsUsed)[i].IsString()) {
+            exts[(*extsUsed)[i].GetString()] = true;
+        }
+    }
+
+    CHECK_EXT(KHR_binary_glTF);
+    CHECK_EXT(KHR_materials_common);
+
+#undef CHECK_EXT
+}
+
+inline IOStream *Asset::OpenFile(const std::string &path, const char *mode, bool absolute) {
+#ifdef ASSIMP_API
+    (void)absolute;
+    return mIOSystem->Open(path, mode);
+#else
+    if (path.size() < 2) return 0;
+    if (!absolute && path[1] != ':' && path[0] != '/') { // relative?
+        path = mCurrentAssetDir + path;
+    }
+    FILE *f = fopen(path.c_str(), mode);
+    return f ? new IOStream(f) : 0;
+#endif
+}
+
+inline std::string Asset::FindUniqueID(const std::string &str, const char *suffix) {
+    std::string id = str;
+
+    if (!id.empty()) {
+        if (mUsedIds.find(id) == mUsedIds.end())
+            return id;
+
+        id += "_";
+    }
+
+    id += suffix;
+
+    Asset::IdMap::iterator it = mUsedIds.find(id);
+    if (it == mUsedIds.end())
+        return id;
+
+    char buffer[1024];
+    int offset = ai_snprintf(buffer, sizeof(buffer), "%s_", id.c_str());
+    for (int i = 0; it != mUsedIds.end(); ++i) {
+        ai_snprintf(buffer + offset, sizeof(buffer) - offset, "%d", i);
+        id = buffer;
+        it = mUsedIds.find(id);
+    }
+
+    return id;
+}
+
+#if _MSC_VER
+#pragma warning(pop)
+#endif // _MSC_VER
+
+} // namespace glTF
diff --git a/Engine/lib/assimp/code/glTF/glTFAssetWriter.h b/Engine/lib/assimp/code/AssetLib/glTF/glTFAssetWriter.h
similarity index 95%
rename from Engine/lib/assimp/code/glTF/glTFAssetWriter.h
rename to Engine/lib/assimp/code/AssetLib/glTF/glTFAssetWriter.h
index 03aee7d4c..6dbc42420 100644
--- a/Engine/lib/assimp/code/glTF/glTFAssetWriter.h
+++ b/Engine/lib/assimp/code/AssetLib/glTF/glTFAssetWriter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -50,7 +50,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef GLTFASSETWRITER_H_INC
 #define GLTFASSETWRITER_H_INC
 
-#ifndef ASSIMP_BUILD_NO_GLTF_IMPORTER
+#if !defined(ASSIMP_BUILD_NO_GLTF_IMPORTER) && !defined(ASSIMP_BUILD_NO_GLTF1_IMPORTER)
 
 #include "glTFAsset.h"
 
diff --git a/Engine/lib/assimp/code/glTF/glTFAssetWriter.inl b/Engine/lib/assimp/code/AssetLib/glTF/glTFAssetWriter.inl
similarity index 92%
rename from Engine/lib/assimp/code/glTF/glTFAssetWriter.inl
rename to Engine/lib/assimp/code/AssetLib/glTF/glTFAssetWriter.inl
index 1bbb8fd8c..a1265fb4f 100644
--- a/Engine/lib/assimp/code/glTF/glTFAssetWriter.inl
+++ b/Engine/lib/assimp/code/AssetLib/glTF/glTFAssetWriter.inl
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -40,10 +39,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
+#include <assimp/Base64.hpp>
+
 #include <rapidjson/stringbuffer.h>
 #include <rapidjson/writer.h>
 #include <rapidjson/prettywriter.h>
 
+#if _MSC_VER
+#    pragma warning(push)
+#    pragma warning( disable : 4706)
+#endif // _MSC_VER
+
 namespace glTF {
 
     using rapidjson::StringBuffer;
@@ -54,9 +60,9 @@ namespace glTF {
 
     namespace {
 
-        template<size_t N>
-        inline 
-        Value& MakeValue(Value& val, float(&r)[N], MemoryPoolAllocator<>& al) {
+        template<typename T, size_t N>
+        inline
+        Value& MakeValue(Value& val, T(&r)[N], MemoryPoolAllocator<>& al) {
             val.SetArray();
             val.Reserve(N, al);
             for (decltype(N) i = 0; i < N; ++i) {
@@ -65,8 +71,9 @@ namespace glTF {
             return val;
         }
 
-        inline 
-        Value& MakeValue(Value& val, const std::vector<float> & r, MemoryPoolAllocator<>& al) {
+        template<typename T>
+        inline
+        Value& MakeValue(Value& val, const std::vector<T> & r, MemoryPoolAllocator<>& al) {
             val.SetArray();
             val.Reserve(static_cast<rapidjson::SizeType>(r.size()), al);
             for (unsigned int i = 0; i < r.size(); ++i) {
@@ -75,6 +82,16 @@ namespace glTF {
             return val;
         }
 
+        template<typename C, typename T>
+        inline Value& MakeValueCast(Value& val, const std::vector<T> & r, MemoryPoolAllocator<>& al) {
+            val.SetArray();
+            val.Reserve(static_cast<rapidjson::SizeType>(r.size()), al);
+            for (unsigned int i = 0; i < r.size(); ++i) {
+                val.PushBack(static_cast<C>(r[i]), al);
+            }
+            return val;
+        }
+
         template<class T>
         inline void AddRefsVector(Value& obj, const char* fieldId, std::vector< Ref<T> >& v, MemoryPoolAllocator<>& al) {
             if (v.empty()) return;
@@ -100,8 +117,13 @@ namespace glTF {
         obj.AddMember("type", StringRef(AttribType::ToString(a.type)), w.mAl);
 
         Value vTmpMax, vTmpMin;
-        obj.AddMember("max", MakeValue(vTmpMax, a.max, w.mAl), w.mAl);
-        obj.AddMember("min", MakeValue(vTmpMin, a.min, w.mAl), w.mAl);
+		if (a.componentType == ComponentType_FLOAT) {
+			obj.AddMember("max", MakeValue(vTmpMax, a.max, w.mAl), w.mAl);
+			obj.AddMember("min", MakeValue(vTmpMin, a.min, w.mAl), w.mAl);
+		} else {
+			obj.AddMember("max", MakeValueCast<int64_t>(vTmpMax, a.max, w.mAl), w.mAl);
+			obj.AddMember("min", MakeValueCast<int64_t>(vTmpMin, a.min, w.mAl), w.mAl);
+		}
     }
 
     inline void Write(Value& obj, Animation& a, AssetWriter& w)
@@ -187,7 +209,9 @@ namespace glTF {
         obj.AddMember("buffer", Value(bv.buffer->id, w.mAl).Move(), w.mAl);
         obj.AddMember("byteOffset", static_cast<uint64_t>(bv.byteOffset), w.mAl);
         obj.AddMember("byteLength", static_cast<uint64_t>(bv.byteLength), w.mAl);
-        obj.AddMember("target", int(bv.target), w.mAl);
+        if (bv.target != BufferViewTarget_NONE) {
+            obj.AddMember("target", int(bv.target), w.mAl);
+        }
     }
 
     inline void Write(Value& /*obj*/, Camera& /*c*/, AssetWriter& /*w*/)
@@ -215,7 +239,7 @@ namespace glTF {
         else if (img.HasData()) {
             uri = "data:" + (img.mimeType.empty() ? "application/octet-stream" : img.mimeType);
             uri += ";base64,";
-            glTFCommon::Util::EncodeBase64(img.GetData(), img.GetDataLength(), uri);
+            Base64::Encode(img.GetData(), img.GetDataLength(), uri);
         }
         else {
             uri = img.uri;
@@ -283,11 +307,11 @@ namespace glTF {
 			Value json_extensions;
 
 			json_extensions.SetObject();
+#ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC
 			for(Mesh::SExtension* ptr_ext : m.Extension)
 			{
 				switch(ptr_ext->Type)
 				{
-#ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC
 					case Mesh::SExtension::EType::Compression_Open3DGC:
 						{
 							Value json_comp_data;
@@ -317,11 +341,11 @@ namespace glTF {
 						}
 
 						break;
-#endif
 					default:
 						throw DeadlyImportError("GLTF: Can not write mesh: unknown mesh extension, only Open3DGC is supported.");
 				}// switch(ptr_ext->Type)
 			}// for(Mesh::SExtension* ptr_ext : m.Extension)
+#endif
 
 			// Add extensions to mesh
 			obj.AddMember("extensions", json_extensions, w.mAl);
@@ -508,7 +532,9 @@ namespace glTF {
         StringBuffer docBuffer;
 
         PrettyWriter<StringBuffer> writer(docBuffer);
-        mDoc.Accept(writer);
+        if (!mDoc.Accept(writer)) {
+            throw DeadlyExportError("Failed to write scene data!");
+        }
 
         if (jsonOutFile->Write(docBuffer.GetString(), docBuffer.GetSize(), 1) != 1) {
             throw DeadlyExportError("Failed to write scene data!");
@@ -547,7 +573,9 @@ namespace glTF {
 
         StringBuffer docBuffer;
         Writer<StringBuffer> writer(docBuffer);
-        mDoc.Accept(writer);
+        if (!mDoc.Accept(writer)) {
+            throw DeadlyExportError("Failed to write scene data!");
+        }
 
         if (outfile->Write(docBuffer.GetString(), docBuffer.GetSize(), 1) != 1) {
             throw DeadlyExportError("Failed to write scene data!");
@@ -611,6 +639,9 @@ namespace glTF {
         asset.SetObject();
         asset.AddMember("version", Value(mAsset.asset.version, mAl).Move(), mAl);
         asset.AddMember("generator", Value(mAsset.asset.generator, mAl).Move(), mAl);
+        if (!mAsset.asset.copyright.empty())
+            asset.AddMember("copyright", Value(mAsset.asset.copyright, mAl).Move(), mAl);
+
         mDoc.AddMember("asset", asset, mAl);
     }
 
@@ -678,6 +709,8 @@ namespace glTF {
         w.WriteObjects(d);
     }
 
+#if _MSC_VER
+#    pragma warning(pop)
+#endif // _WIN32
+
 }
-
-
diff --git a/Engine/lib/assimp/code/glTF/glTFCommon.cpp b/Engine/lib/assimp/code/AssetLib/glTF/glTFCommon.cpp
similarity index 53%
rename from Engine/lib/assimp/code/glTF/glTFCommon.cpp
rename to Engine/lib/assimp/code/AssetLib/glTF/glTFCommon.cpp
index cd03224e4..fea680cd3 100644
--- a/Engine/lib/assimp/code/glTF/glTFCommon.cpp
+++ b/Engine/lib/assimp/code/AssetLib/glTF/glTFCommon.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -38,7 +38,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 ----------------------------------------------------------------------
 */
-#include "glTF/glTFCommon.h"
+#ifndef ASSIMP_BUILD_NO_GLTF_IMPORTER
+
+#include "AssetLib/glTF/glTFCommon.h"
 
 namespace glTFCommon {
 
@@ -46,85 +48,7 @@ using namespace glTFCommon::Util;
 
 namespace Util {
 
-size_t DecodeBase64(const char* in, size_t inLength, uint8_t*& out) {
-    ai_assert(inLength % 4 == 0);
-
-    if (inLength < 4) {
-        out = 0;
-        return 0;
-    }
-
-    int nEquals = int(in[inLength - 1] == '=') +
-        int(in[inLength - 2] == '=');
-
-    size_t outLength = (inLength * 3) / 4 - nEquals;
-    out = new uint8_t[outLength];
-    memset(out, 0, outLength);
-
-    size_t i, j = 0;
-
-    for (i = 0; i + 4 < inLength; i += 4) {
-        uint8_t b0 = DecodeCharBase64(in[i]);
-        uint8_t b1 = DecodeCharBase64(in[i + 1]);
-        uint8_t b2 = DecodeCharBase64(in[i + 2]);
-        uint8_t b3 = DecodeCharBase64(in[i + 3]);
-
-        out[j++] = (uint8_t)((b0 << 2) | (b1 >> 4));
-        out[j++] = (uint8_t)((b1 << 4) | (b2 >> 2));
-        out[j++] = (uint8_t)((b2 << 6) | b3);
-    }
-
-    {
-        uint8_t b0 = DecodeCharBase64(in[i]);
-        uint8_t b1 = DecodeCharBase64(in[i + 1]);
-        uint8_t b2 = DecodeCharBase64(in[i + 2]);
-        uint8_t b3 = DecodeCharBase64(in[i + 3]);
-
-        out[j++] = (uint8_t)((b0 << 2) | (b1 >> 4));
-        if (b2 < 64) out[j++] = (uint8_t)((b1 << 4) | (b2 >> 2));
-        if (b3 < 64) out[j++] = (uint8_t)((b2 << 6) | b3);
-    }
-
-    return outLength;
-}
-
-void EncodeBase64(const uint8_t* in, size_t inLength, std::string& out) {
-    size_t outLength = ((inLength + 2) / 3) * 4;
-
-    size_t j = out.size();
-    out.resize(j + outLength);
-
-    for (size_t i = 0; i < inLength; i += 3) {
-        uint8_t b = (in[i] & 0xFC) >> 2;
-        out[j++] = EncodeCharBase64(b);
-
-        b = (in[i] & 0x03) << 4;
-        if (i + 1 < inLength) {
-            b |= (in[i + 1] & 0xF0) >> 4;
-            out[j++] = EncodeCharBase64(b);
-
-            b = (in[i + 1] & 0x0F) << 2;
-            if (i + 2 < inLength) {
-                b |= (in[i + 2] & 0xC0) >> 6;
-                out[j++] = EncodeCharBase64(b);
-
-                b = in[i + 2] & 0x3F;
-                out[j++] = EncodeCharBase64(b);
-            }
-            else {
-                out[j++] = EncodeCharBase64(b);
-                out[j++] = '=';
-            }
-        }
-        else {
-            out[j++] = EncodeCharBase64(b);
-            out[j++] = '=';
-            out[j++] = '=';
-        }
-    }
-}
-
-bool ParseDataURI(const char* const_uri, size_t uriLen, DataURI& out) {
+bool ParseDataURI(const char *const_uri, size_t uriLen, DataURI &out) {
     if (nullptr == const_uri) {
         return false;
     }
@@ -139,7 +63,7 @@ bool ParseDataURI(const char* const_uri, size_t uriLen, DataURI& out) {
     out.charset = "US-ASCII";
     out.base64 = false;
 
-    char* uri = const_cast<char*>(const_uri);
+    char *uri = const_cast<char *>(const_uri);
     if (uri[0] != 0x10) {
         uri[0] = 0x10;
         uri[1] = uri[2] = uri[3] = uri[4] = 0;
@@ -147,28 +71,26 @@ bool ParseDataURI(const char* const_uri, size_t uriLen, DataURI& out) {
         size_t i = 5, j;
         if (uri[i] != ';' && uri[i] != ',') { // has media type?
             uri[1] = char(i);
-            for (; uri[i] != ';' && uri[i] != ',' && i < uriLen; ++i) {
+            for (;i < uriLen && uri[i] != ';' && uri[i] != ','; ++i) {
                 // nothing to do!
             }
         }
-        while (uri[i] == ';' && i < uriLen) {
+        while (i < uriLen && uri[i] == ';') {
             uri[i++] = '\0';
-            for (j = i; uri[i] != ';' && uri[i] != ',' && i < uriLen; ++i) {
+            for (j = i; i < uriLen && uri[i] != ';' && uri[i] != ','; ++i) {
                 // nothing to do!
             }
 
             if (strncmp(uri + j, "charset=", 8) == 0) {
                 uri[2] = char(j + 8);
-            }
-            else if (strncmp(uri + j, "base64", 6) == 0) {
+            } else if (strncmp(uri + j, "base64", 6) == 0) {
                 uri[3] = char(j);
             }
         }
         if (i < uriLen) {
             uri[i++] = '\0';
             uri[4] = char(i);
-        }
-        else {
+        } else {
             uri[1] = uri[2] = uri[3] = 0;
             uri[4] = 5;
         }
@@ -189,5 +111,7 @@ bool ParseDataURI(const char* const_uri, size_t uriLen, DataURI& out) {
     return true;
 }
 
-}
-}
+} // namespace Util
+} // namespace glTFCommon
+
+#endif
diff --git a/Engine/lib/assimp/code/AssetLib/glTF/glTFCommon.h b/Engine/lib/assimp/code/AssetLib/glTF/glTFCommon.h
new file mode 100644
index 000000000..edc3c7e03
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/glTF/glTFCommon.h
@@ -0,0 +1,520 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+#ifndef AI_GLFTCOMMON_H_INC
+#define AI_GLFTCOMMON_H_INC
+
+#ifndef ASSIMP_BUILD_NO_GLTF_IMPORTER
+
+#include <assimp/Exceptional.h>
+
+#include <algorithm>
+#include <list>
+#include <map>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include <rapidjson/document.h>
+#include <rapidjson/error/en.h>
+#include <rapidjson/rapidjson.h>
+
+// clang-format off
+
+#ifdef ASSIMP_API
+#   include <assimp/ByteSwapper.h>
+#   include <assimp/DefaultIOSystem.h>
+#   include <memory>
+#else
+#   include <memory>
+#   define AI_SWAP4(p)
+#   define ai_assert
+#endif
+
+#if _MSC_VER > 1500 || (defined __GNUC___)
+#   define ASSIMP_GLTF_USE_UNORDERED_MULTIMAP
+#else
+#   define gltf_unordered_map map
+#endif
+
+#ifdef ASSIMP_GLTF_USE_UNORDERED_MULTIMAP
+#   include <unordered_map>
+#   if defined(_MSC_VER) && _MSC_VER <= 1600
+#       define gltf_unordered_map tr1::unordered_map
+#   else
+#       define gltf_unordered_map unordered_map
+#   endif
+#endif
+// clang-format on
+
+
+namespace glTFCommon {
+
+using rapidjson::Document;
+using rapidjson::Value;
+
+#ifdef ASSIMP_API
+using Assimp::IOStream;
+using Assimp::IOSystem;
+using std::shared_ptr;
+#else
+using std::shared_ptr;
+
+typedef std::runtime_error DeadlyImportError;
+typedef std::runtime_error DeadlyExportError;
+
+enum aiOrigin {
+    aiOrigin_SET = 0,
+    aiOrigin_CUR = 1,
+    aiOrigin_END = 2
+};
+
+class IOSystem;
+
+class IOStream {
+public:
+    IOStream(FILE *file) :
+            f(file) {}
+    ~IOStream() {
+        fclose(f);
+    }
+
+    size_t Read(void *b, size_t sz, size_t n) { return fread(b, sz, n, f); }
+    size_t Write(const void *b, size_t sz, size_t n) { return fwrite(b, sz, n, f); }
+    int Seek(size_t off, aiOrigin orig) { return fseek(f, off, int(orig)); }
+    size_t Tell() const { return ftell(f); }
+
+    size_t FileSize() {
+        long p = Tell(), len = (Seek(0, aiOrigin_END), Tell());
+        return size_t((Seek(p, aiOrigin_SET), len));
+    }
+
+private:
+    FILE *f;
+};
+#endif
+
+// Vec/matrix types, as raw float arrays
+typedef float(vec3)[3];
+typedef float(vec4)[4];
+typedef float(mat4)[16];
+
+inline void CopyValue(const glTFCommon::vec3 &v, aiColor4D &out) {
+    out.r = v[0];
+    out.g = v[1];
+    out.b = v[2];
+    out.a = 1.0;
+}
+
+inline void CopyValue(const glTFCommon::vec4 &v, aiColor4D &out) {
+    out.r = v[0];
+    out.g = v[1];
+    out.b = v[2];
+    out.a = v[3];
+}
+
+inline void CopyValue(const glTFCommon::vec4 &v, aiColor3D &out) {
+    out.r = v[0];
+    out.g = v[1];
+    out.b = v[2];
+}
+
+inline void CopyValue(const glTFCommon::vec3 &v, aiColor3D &out) {
+    out.r = v[0];
+    out.g = v[1];
+    out.b = v[2];
+}
+
+inline void CopyValue(const glTFCommon::vec3 &v, aiVector3D &out) {
+    out.x = v[0];
+    out.y = v[1];
+    out.z = v[2];
+}
+
+inline void CopyValue(const glTFCommon::vec4 &v, aiQuaternion &out) {
+    out.x = v[0];
+    out.y = v[1];
+    out.z = v[2];
+    out.w = v[3];
+}
+
+inline void CopyValue(const glTFCommon::mat4 &v, aiMatrix4x4 &o) {
+    o.a1 = v[0];
+    o.b1 = v[1];
+    o.c1 = v[2];
+    o.d1 = v[3];
+    o.a2 = v[4];
+    o.b2 = v[5];
+    o.c2 = v[6];
+    o.d2 = v[7];
+    o.a3 = v[8];
+    o.b3 = v[9];
+    o.c3 = v[10];
+    o.d3 = v[11];
+    o.a4 = v[12];
+    o.b4 = v[13];
+    o.c4 = v[14];
+    o.d4 = v[15];
+}
+
+#if _MSC_VER
+#    pragma warning(push)
+#    pragma warning(disable : 4310)
+#endif // _MSC_VER
+
+inline std::string getCurrentAssetDir(const std::string &pFile) {
+    int pos = std::max(int(pFile.rfind('/')), int(pFile.rfind('\\')));
+    if (pos == int(std::string::npos)) {
+        return std::string();
+    }
+
+    return pFile.substr(0, pos + 1);
+}
+#if _MSC_VER
+#    pragma warning(pop)
+#endif // _MSC_VER
+
+namespace Util {
+
+void EncodeBase64(const uint8_t *in, size_t inLength, std::string &out);
+
+size_t DecodeBase64(const char *in, size_t inLength, uint8_t *&out);
+
+inline size_t DecodeBase64(const char *in, uint8_t *&out) {
+    return DecodeBase64(in, strlen(in), out);
+}
+
+struct DataURI {
+    const char *mediaType;
+    const char *charset;
+    bool base64;
+    const char *data;
+    size_t dataLength;
+};
+
+//! Check if a uri is a data URI
+bool ParseDataURI(const char *const_uri, size_t uriLen, DataURI &out);
+
+} // namespace Util
+
+#define CHECK_EXT(EXT) \
+    if (exts.find(#EXT) != exts.end()) extensionsUsed.EXT = true;
+
+//! Helper struct to represent values that might not be present
+template <class T>
+struct Nullable {
+    T value;
+    bool isPresent;
+
+    Nullable() :
+            isPresent(false) {}
+    Nullable(T &val) :
+            value(val),
+            isPresent(true) {}
+};
+
+//! A reference to one top-level object, which is valid
+//! until the Asset instance is destroyed
+template <class T>
+class Ref {
+    std::vector<T *> *vector;
+    unsigned int index;
+
+public:
+    Ref() :
+            vector(0),
+            index(0) {}
+    Ref(std::vector<T *> &vec, unsigned int idx) :
+            vector(&vec),
+            index(idx) {}
+
+    inline unsigned int GetIndex() const { return index; }
+
+    operator bool() const { return vector != nullptr && index < vector->size(); }
+
+    T *operator->() { return (*vector)[index]; }
+
+    T &operator*() { return *((*vector)[index]); }
+};
+
+//
+// JSON Value reading helpers
+//
+
+template <class T>
+struct ReadHelper {
+    static bool Read(Value &val, T &out) {
+        return val.IsInt() ? out = static_cast<T>(val.GetInt()), true : false;
+    }
+};
+
+template <>
+struct ReadHelper<bool> {
+    static bool Read(Value &val, bool &out) {
+        return val.IsBool() ? out = val.GetBool(), true : false;
+    }
+};
+
+template <>
+struct ReadHelper<float> {
+    static bool Read(Value &val, float &out) {
+        return val.IsNumber() ? out = static_cast<float>(val.GetDouble()), true : false;
+    }
+};
+
+template <unsigned int N>
+struct ReadHelper<float[N]> {
+    static bool Read(Value &val, float (&out)[N]) {
+        if (!val.IsArray() || val.Size() != N) return false;
+        for (unsigned int i = 0; i < N; ++i) {
+            if (val[i].IsNumber())
+                out[i] = static_cast<float>(val[i].GetDouble());
+        }
+        return true;
+    }
+};
+
+template <>
+struct ReadHelper<const char *> {
+    static bool Read(Value &val, const char *&out) {
+        return val.IsString() ? (out = val.GetString(), true) : false;
+    }
+};
+
+template <>
+struct ReadHelper<std::string> {
+    static bool Read(Value &val, std::string &out) {
+        return val.IsString() ? (out = std::string(val.GetString(), val.GetStringLength()), true) : false;
+    }
+};
+
+template <class T>
+struct ReadHelper<Nullable<T>> {
+    static bool Read(Value &val, Nullable<T> &out) {
+        return out.isPresent = ReadHelper<T>::Read(val, out.value);
+    }
+};
+
+template <>
+struct ReadHelper<uint64_t> {
+    static bool Read(Value &val, uint64_t &out) {
+        return val.IsUint64() ? out = val.GetUint64(), true : false;
+    }
+};
+
+template <>
+struct ReadHelper<int64_t> {
+    static bool Read(Value &val, int64_t &out) {
+        return val.IsInt64() ? out = val.GetInt64(), true : false;
+    }
+};
+
+template <class T>
+inline static bool ReadValue(Value &val, T &out) {
+    return ReadHelper<T>::Read(val, out);
+}
+
+template <class T>
+inline static bool ReadMember(Value &obj, const char *id, T &out) {
+    if (!obj.IsObject()) {
+        return false;
+    }
+    Value::MemberIterator it = obj.FindMember(id);
+    if (it != obj.MemberEnd()) {
+        return ReadHelper<T>::Read(it->value, out);
+    }
+    return false;
+}
+
+template <class T>
+inline static T MemberOrDefault(Value &obj, const char *id, T defaultValue) {
+    T out;
+    return ReadMember(obj, id, out) ? out : defaultValue;
+}
+
+inline Value *FindMember(Value &val, const char *id) {
+    if (!val.IsObject()) {
+        return nullptr;
+    }
+    Value::MemberIterator it = val.FindMember(id);
+    return (it != val.MemberEnd()) ? &it->value : nullptr;
+}
+
+template <int N>
+inline void throwUnexpectedTypeError(const char (&expectedTypeName)[N], const char *memberId, const char *context, const char *extraContext) {
+    std::string fullContext = context;
+    if (extraContext && (strlen(extraContext) > 0)) {
+        fullContext = fullContext + " (" + extraContext + ")";
+    }
+    throw DeadlyImportError("Member \"", memberId, "\" was not of type \"", expectedTypeName, "\" when reading ", fullContext);
+}
+
+// Look-up functions with type checks. Context and extra context help the user identify the problem if there's an error.
+
+inline Value *FindStringInContext(Value &val, const char *memberId, const char *context, const char *extraContext = nullptr) {
+    if (!val.IsObject()) {
+        return nullptr;
+    }
+    Value::MemberIterator it = val.FindMember(memberId);
+    if (it == val.MemberEnd()) {
+        return nullptr;
+    }
+    if (!it->value.IsString()) {
+        throwUnexpectedTypeError("string", memberId, context, extraContext);
+    }
+    return &it->value;
+}
+
+inline Value *FindNumberInContext(Value &val, const char *memberId, const char *context, const char *extraContext = nullptr) {
+    if (!val.IsObject()) {
+        return nullptr;
+    }
+    Value::MemberIterator it = val.FindMember(memberId);
+    if (it == val.MemberEnd()) {
+        return nullptr;
+    }
+    if (!it->value.IsNumber()) {
+        throwUnexpectedTypeError("number", memberId, context, extraContext);
+    }
+    return &it->value;
+}
+
+inline Value *FindUIntInContext(Value &val, const char *memberId, const char *context, const char *extraContext = nullptr) {
+    if (!val.IsObject()) {
+        return nullptr;
+    }
+    Value::MemberIterator it = val.FindMember(memberId);
+    if (it == val.MemberEnd()) {
+        return nullptr;
+    }
+    if (!it->value.IsUint()) {
+        throwUnexpectedTypeError("uint", memberId, context, extraContext);
+    }
+    return &it->value;
+}
+
+inline Value *FindArrayInContext(Value &val, const char *memberId, const char *context, const char *extraContext = nullptr) {
+    if (!val.IsObject()) {
+        return nullptr;
+    }
+    Value::MemberIterator it = val.FindMember(memberId);
+    if (it == val.MemberEnd()) {
+        return nullptr;
+    }
+    if (!it->value.IsArray()) {
+        throwUnexpectedTypeError("array", memberId, context, extraContext);
+    }
+    return &it->value;
+}
+
+inline Value *FindObjectInContext(Value &val, const char *memberId, const char *context, const char *extraContext = nullptr) {
+    if (!val.IsObject()) {
+        return nullptr;
+    }
+    Value::MemberIterator it = val.FindMember(memberId);
+    if (it == val.MemberEnd()) {
+        return nullptr;
+    }
+    if (!it->value.IsObject()) {
+        throwUnexpectedTypeError("object", memberId, context, extraContext);
+    }
+    return &it->value;
+}
+
+inline Value *FindExtensionInContext(Value &val, const char *extensionId, const char *context, const char *extraContext = nullptr) {
+    if (Value *extensionList = FindObjectInContext(val, "extensions", context, extraContext)) {
+        if (Value *extension = FindObjectInContext(*extensionList, extensionId, context, extraContext)) {
+            return extension;
+        }
+    }
+    return nullptr;
+}
+
+// Overloads when the value is the document.
+
+inline Value *FindString(Document &doc, const char *memberId) {
+    return FindStringInContext(doc, memberId, "the document");
+}
+
+inline Value *FindNumber(Document &doc, const char *memberId) {
+    return FindNumberInContext(doc, memberId, "the document");
+}
+
+inline Value *FindUInt(Document &doc, const char *memberId) {
+    return FindUIntInContext(doc, memberId, "the document");
+}
+
+inline Value *FindArray(Document &val, const char *memberId) {
+    return FindArrayInContext(val, memberId, "the document");
+}
+
+inline Value *FindObject(Document &doc, const char *memberId) {
+    return FindObjectInContext(doc, memberId, "the document");
+}
+
+inline Value *FindExtension(Value &val, const char *extensionId) {
+    return FindExtensionInContext(val, extensionId, "the document");
+}
+
+inline Value *FindString(Value &val, const char *id) {
+    Value::MemberIterator it = val.FindMember(id);
+    return (it != val.MemberEnd() && it->value.IsString()) ? &it->value : 0;
+}
+
+inline Value *FindObject(Value &val, const char *id) {
+    Value::MemberIterator it = val.FindMember(id);
+    return (it != val.MemberEnd() && it->value.IsObject()) ? &it->value : 0;
+}
+
+inline Value *FindArray(Value &val, const char *id) {
+    Value::MemberIterator it = val.FindMember(id);
+    return (it != val.MemberEnd() && it->value.IsArray()) ? &it->value : 0;
+}
+
+inline Value *FindNumber(Value &val, const char *id) {
+    Value::MemberIterator it = val.FindMember(id);
+    return (it != val.MemberEnd() && it->value.IsNumber()) ? &it->value : 0;
+}
+
+} // namespace glTFCommon
+
+#endif // ASSIMP_BUILD_NO_GLTF_IMPORTER
+
+#endif // AI_GLFTCOMMON_H_INC
diff --git a/Engine/lib/assimp/code/glTF/glTFExporter.cpp b/Engine/lib/assimp/code/AssetLib/glTF/glTFExporter.cpp
similarity index 89%
rename from Engine/lib/assimp/code/glTF/glTFExporter.cpp
rename to Engine/lib/assimp/code/AssetLib/glTF/glTFExporter.cpp
index 034f91f3b..afcfb1223 100644
--- a/Engine/lib/assimp/code/glTF/glTFExporter.cpp
+++ b/Engine/lib/assimp/code/AssetLib/glTF/glTFExporter.cpp
@@ -1,8 +1,8 @@
-/*
+/*
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -42,10 +42,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_EXPORT
 #ifndef ASSIMP_BUILD_NO_GLTF_EXPORTER
 
-#include "glTF/glTFExporter.h"
-#include "glTF/glTFAssetWriter.h"
+#include "AssetLib/glTF/glTFExporter.h"
+#include "AssetLib/glTF/glTFAssetWriter.h"
 #include "PostProcessing/SplitLargeMeshes.h"
 
+#include <assimp/commonMetaData.h>
 #include <assimp/Exceptional.h>
 #include <assimp/StringComparison.h>
 #include <assimp/ByteSwapper.h>
@@ -58,6 +59,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // Header files, standard library.
 #include <memory>
+#include <limits>
 #include <inttypes.h>
 
 #ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC
@@ -98,17 +100,16 @@ glTFExporter::glTFExporter(const char* filename, IOSystem* pIOSystem, const aiSc
 {
     aiScene* sceneCopy_tmp;
     SceneCombiner::CopyScene(&sceneCopy_tmp, pScene);
-    aiScene *sceneCopy(sceneCopy_tmp);
 
     SplitLargeMeshesProcess_Triangle tri_splitter;
     tri_splitter.SetLimit(0xffff);
-    tri_splitter.Execute(sceneCopy);
+    tri_splitter.Execute(sceneCopy_tmp);
 
     SplitLargeMeshesProcess_Vertex vert_splitter;
     vert_splitter.SetLimit(0xffff);
-    vert_splitter.Execute(sceneCopy);
+    vert_splitter.Execute(sceneCopy_tmp);
 
-    mScene = sceneCopy;
+    mScene.reset(sceneCopy_tmp);
 
     mAsset.reset( new glTF::Asset( pIOSystem ) );
 
@@ -159,10 +160,7 @@ static void CopyValue(const aiMatrix4x4& v, glTF::mat4& o)
 
 static void CopyValue(const aiMatrix4x4& v, aiMatrix4x4& o)
 {
-    o.a1 = v.a1; o.a2 = v.a2; o.a3 = v.a3; o.a4 = v.a4;
-    o.b1 = v.b1; o.b2 = v.b2; o.b3 = v.b3; o.b4 = v.b4;
-    o.c1 = v.c1; o.c2 = v.c2; o.c3 = v.c3; o.c4 = v.c4;
-    o.d1 = v.d1; o.d2 = v.d2; o.d3 = v.d3; o.d4 = v.d4;
+    memcpy(&o, &v, sizeof(aiMatrix4x4));
 }
 
 static void IdentityMatrix4(glTF::mat4& o)
@@ -173,9 +171,64 @@ static void IdentityMatrix4(glTF::mat4& o)
     o[12] = 0; o[13] = 0; o[14] = 0; o[15] = 1;
 }
 
-inline Ref<Accessor> ExportData(Asset& a, std::string& meshName, Ref<Buffer>& buffer,
-    unsigned int count, void* data, AttribType::Value typeIn, AttribType::Value typeOut, ComponentType compType, bool isIndices = false)
+template<typename T>
+void SetAccessorRange(Ref<Accessor> acc, void* data, unsigned int count,
+	unsigned int numCompsIn, unsigned int numCompsOut)
 {
+	ai_assert(numCompsOut <= numCompsIn);
+
+	// Allocate and initialize with large values.
+	for (unsigned int i = 0 ; i < numCompsOut ; i++) {
+		acc->min.push_back( std::numeric_limits<double>::max());
+		acc->max.push_back(-std::numeric_limits<double>::max());
+	}
+
+	size_t totalComps = count * numCompsIn;
+	T* buffer_ptr = static_cast<T*>(data);
+	T* buffer_end = buffer_ptr + totalComps;
+
+	// Search and set extreme values.
+	for (; buffer_ptr < buffer_end ; buffer_ptr += numCompsIn) {
+		for (unsigned int j = 0 ; j < numCompsOut ; j++) {
+			double valueTmp = buffer_ptr[j];
+
+			if (valueTmp < acc->min[j]) {
+				acc->min[j] = valueTmp;
+			}
+			if (valueTmp > acc->max[j]) {
+				acc->max[j] = valueTmp;
+			}
+		}
+	}
+}
+
+inline void SetAccessorRange(ComponentType compType, Ref<Accessor> acc, void* data,
+		unsigned int count, unsigned int numCompsIn, unsigned int numCompsOut)
+{
+	switch (compType) {
+		case ComponentType_SHORT:
+			SetAccessorRange<short>(acc, data, count, numCompsIn, numCompsOut);
+			return;
+		case ComponentType_UNSIGNED_SHORT:
+			SetAccessorRange<unsigned short>(acc, data, count, numCompsIn, numCompsOut);
+			return;
+		case ComponentType_UNSIGNED_INT:
+			SetAccessorRange<unsigned int>(acc, data, count, numCompsIn, numCompsOut);
+			return;
+		case ComponentType_FLOAT:
+			SetAccessorRange<float>(acc, data, count, numCompsIn, numCompsOut);
+			return;
+		case ComponentType_BYTE:
+			SetAccessorRange<int8_t>(acc, data, count, numCompsIn, numCompsOut);
+			return;
+		case ComponentType_UNSIGNED_BYTE:
+			SetAccessorRange<uint8_t>(acc, data, count, numCompsIn, numCompsOut);
+			return;
+	}
+}
+
+inline Ref<Accessor> ExportData(Asset &a, std::string &meshName, Ref<Buffer> &buffer,
+        unsigned int count, void *data, AttribType::Value typeIn, AttribType::Value typeOut, ComponentType compType, BufferViewTarget target = BufferViewTarget_NONE) {
     if (!count || !data) return Ref<Accessor>();
 
     unsigned int numCompsIn = AttribType::GetNumComponents(typeIn);
@@ -194,7 +247,7 @@ inline Ref<Accessor> ExportData(Asset& a, std::string& meshName, Ref<Buffer>& bu
     bv->buffer = buffer;
     bv->byteOffset = unsigned(offset);
     bv->byteLength = length; //! The target that the WebGL buffer should be bound to.
-    bv->target = isIndices ? BufferViewTarget_ELEMENT_ARRAY_BUFFER : BufferViewTarget_ARRAY_BUFFER;
+    bv->target = target;
 
     // accessor
     Ref<Accessor> acc = a.accessors.Create(a.FindUniqueID(meshName, "accessor"));
@@ -206,33 +259,7 @@ inline Ref<Accessor> ExportData(Asset& a, std::string& meshName, Ref<Buffer>& bu
     acc->type = typeOut;
 
     // calculate min and max values
-    {
-        // Allocate and initialize with large values.
-        float float_MAX = 10000000000000.0f;
-        for (unsigned int i = 0 ; i < numCompsOut ; i++) {
-            acc->min.push_back( float_MAX);
-            acc->max.push_back(-float_MAX);
-        }
-
-        // Search and set extreme values.
-        float valueTmp;
-        for (unsigned int i = 0 ; i < count       ; i++) {
-            for (unsigned int j = 0 ; j < numCompsOut ; j++) {
-                if (numCompsOut == 1) {
-                  valueTmp = static_cast<unsigned short*>(data)[i];
-                } else {
-                  valueTmp = static_cast<aiVector3D*>(data)[i][j];
-                }
-
-                if (valueTmp < acc->min[j]) {
-                    acc->min[j] = valueTmp;
-                }
-                if (valueTmp > acc->max[j]) {
-                    acc->max[j] = valueTmp;
-                }
-            }
-        }
-    }
+	SetAccessorRange(compType, acc, data, count, numCompsIn, numCompsOut);
 
     // copy the data
     acc->WriteData(count, data, numCompsIn*bytesPerComp);
@@ -295,8 +322,8 @@ void glTFExporter::GetTexSampler(const aiMaterial* mat, glTF::TexProperty& prop)
     prop.texture->sampler->minFilter = SamplerMinFilter_Linear;
 }
 
-void glTFExporter::GetMatColorOrTex(const aiMaterial* mat, glTF::TexProperty& prop, const char* propName, int type, int idx, aiTextureType tt)
-{
+void glTFExporter::GetMatColorOrTex(const aiMaterial* mat, glTF::TexProperty& prop, 
+        const char* propName, int type, int idx, aiTextureType tt) {
     aiString tex;
     aiColor4D col;
     if (mat->GetTextureCount(tt) > 0) {
@@ -320,18 +347,19 @@ void glTFExporter::GetMatColorOrTex(const aiMaterial* mat, glTF::TexProperty& pr
                     prop.texture->source = mAsset->images.Create(imgId);
 
                     if (path[0] == '*') { // embedded
-                        aiTexture* tex = mScene->mTextures[atoi(&path[1])];
+                        aiTexture* curTex = mScene->mTextures[atoi(&path[1])];
 
-                        uint8_t* data = reinterpret_cast<uint8_t*>(tex->pcData);
-                        prop.texture->source->SetData(data, tex->mWidth, *mAsset);
+                        prop.texture->source->name = curTex->mFilename.C_Str();
 
-                        if (tex->achFormatHint[0]) {
+                        uint8_t *data = reinterpret_cast<uint8_t *>(curTex->pcData);
+                        prop.texture->source->SetData(data, curTex->mWidth, *mAsset);
+
+                        if (curTex->achFormatHint[0]) {
                             std::string mimeType = "image/";
-                            mimeType += (memcmp(tex->achFormatHint, "jpg", 3) == 0) ? "jpeg" : tex->achFormatHint;
+                            mimeType += (memcmp(curTex->achFormatHint, "jpg", 3) == 0) ? "jpeg" : curTex->achFormatHint;
                             prop.texture->source->mimeType = mimeType;
                         }
-                    }
-                    else {
+                    } else {
                         prop.texture->source->uri = path;
                     }
 
@@ -342,7 +370,10 @@ void glTFExporter::GetMatColorOrTex(const aiMaterial* mat, glTF::TexProperty& pr
     }
 
     if (mat->Get(propName, type, idx, col) == AI_SUCCESS) {
-        prop.color[0] = col.r; prop.color[1] = col.g; prop.color[2] = col.b; prop.color[3] = col.a;
+        prop.color[0] = col.r; 
+        prop.color[1] = col.g;
+        prop.color[2] = col.b; 
+        prop.color[3] = col.a;
     }
 }
 
@@ -377,8 +408,7 @@ void glTFExporter::ExportMaterials()
  * Search through node hierarchy and find the node containing the given meshID.
  * Returns true on success, and false otherwise.
  */
-bool FindMeshNode(Ref<Node>& nodeIn, Ref<Node>& meshNode, std::string meshID)
-{
+bool FindMeshNode(Ref<Node> &nodeIn, Ref<Node> &meshNode, const std::string &meshID) {
     for (unsigned int i = 0; i < nodeIn->meshes.size(); ++i) {
         if (meshID.compare(nodeIn->meshes[i]->id) == 0) {
           meshNode = nodeIn;
@@ -497,6 +527,13 @@ void ExportSkin(Asset& mAsset, const aiMesh* aimesh, Ref<Mesh>& meshRef, Ref<Buf
     delete[] vertexJointData;
 }
 
+#if defined(__has_warning)
+#if __has_warning("-Wunused-but-set-variable")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#endif
+
 void glTFExporter::ExportMeshes()
 {
     // Not for
@@ -508,10 +545,12 @@ void glTFExporter::ExportMeshes()
 
     // Variables needed for compression. BEGIN.
     // Indices, not pointers - because pointer to buffer is changing while writing to it.
+#ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC
     size_t idx_srcdata_begin = 0; // Index of buffer before writing mesh data. Also, index of begin of coordinates array in buffer.
     size_t idx_srcdata_normal = SIZE_MAX;// Index of begin of normals array in buffer. SIZE_MAX - mean that mesh has no normals.
-    std::vector<size_t> idx_srcdata_tc;// Array of indices. Every index point to begin of texture coordinates array in buffer.
     size_t idx_srcdata_ind;// Index of begin of coordinates indices array in buffer.
+#endif
+    std::vector<size_t> idx_srcdata_tc;// Array of indices. Every index point to begin of texture coordinates array in buffer.
     bool comp_allow;// Point that data of current mesh can be compressed.
     // Variables needed for compression. END.
 
@@ -568,7 +607,7 @@ void glTFExporter::ExportMeshes()
 			else
 				msg = "mesh must has vertices and faces.";
 
-            ASSIMP_LOG_WARN_F("GLTF: can not use Open3DGC-compression: ", msg);
+            ASSIMP_LOG_WARN("GLTF: can not use Open3DGC-compression: ", msg);
             comp_allow = false;
 		}
 
@@ -581,15 +620,19 @@ void glTFExporter::ExportMeshes()
 
 		/******************* Vertices ********************/
 		// If compression is used then you need parameters of uncompressed region: begin and size. At this step "begin" is stored.
+#ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC
 		if(comp_allow) idx_srcdata_begin = b->byteLength;
+#endif
 
-        Ref<Accessor> v = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mVertices, AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT);
+        Ref<Accessor> v = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mVertices, AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT, BufferViewTarget_ARRAY_BUFFER);
 		if (v) p.attributes.position.push_back(v);
 
 		/******************** Normals ********************/
+#ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC
 		if(comp_allow && (aim->mNormals != 0)) idx_srcdata_normal = b->byteLength;// Store index of normals array.
+#endif
 
-		Ref<Accessor> n = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mNormals, AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT);
+		Ref<Accessor> n = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mNormals, AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT, BufferViewTarget_ARRAY_BUFFER);
 		if (n) p.attributes.normal.push_back(n);
 
 		/************** Texture coordinates **************/
@@ -606,13 +649,15 @@ void glTFExporter::ExportMeshes()
 
 				if(comp_allow) idx_srcdata_tc.push_back(b->byteLength);// Store index of texture coordinates array.
 
-				Ref<Accessor> tc = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mTextureCoords[i], AttribType::VEC3, type, ComponentType_FLOAT, false);
+				Ref<Accessor> tc = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mTextureCoords[i], AttribType::VEC3, type, ComponentType_FLOAT, BufferViewTarget_ARRAY_BUFFER);
 				if (tc) p.attributes.texcoord.push_back(tc);
 			}
 		}
 
 		/*************** Vertices indices ****************/
+#ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC
 		idx_srcdata_ind = b->byteLength;// Store index of indices array.
+#endif
 
 		if (aim->mNumFaces > 0) {
 			std::vector<IndicesType> indices;
@@ -624,7 +669,7 @@ void glTFExporter::ExportMeshes()
                 }
             }
 
-			p.indices = ExportData(*mAsset, meshId, b, unsigned(indices.size()), &indices[0], AttribType::SCALAR, AttribType::SCALAR, ComponentType_UNSIGNED_SHORT, true);
+			p.indices = ExportData(*mAsset, meshId, b, unsigned(indices.size()), &indices[0], AttribType::SCALAR, AttribType::SCALAR, ComponentType_UNSIGNED_SHORT, BufferViewTarget_ELEMENT_ARRAY_BUFFER);
 		}
 
         switch (aim->mPrimitiveTypes) {
@@ -649,7 +694,7 @@ void glTFExporter::ExportMeshes()
 		{
 #ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC
 			// Only one type of compression supported at now - Open3DGC.
-			//
+		//
 			o3dgc::BinaryStream bs;
 			o3dgc::SC3DMCEncoder<IndicesType> encoder;
 			o3dgc::IndexedFaceSet<IndicesType> comp_o3dgc_ifs;
@@ -765,6 +810,12 @@ void glTFExporter::ExportMeshes()
     }
 }
 
+#if defined(__has_warning)
+#if __has_warning("-Wunused-but-set-variable")
+#pragma GCC diagnostic pop
+#endif
+#endif
+
 /*
  * Export the root node of the node hierarchy.
  * Calls ExportNode for all children.
@@ -838,10 +889,16 @@ void glTFExporter::ExportMetadata()
     asset.version = "1.0";
 
     char buffer[256];
-    ai_snprintf(buffer, 256, "Open Asset Import Library (assimp v%d.%d.%d)",
+    ai_snprintf(buffer, 256, "Open Asset Import Library (assimp v%d.%d.%x)",
         aiGetVersionMajor(), aiGetVersionMinor(), aiGetVersionRevision());
 
     asset.generator = buffer;
+
+	// Copyright
+	aiString copyright_str;
+	if (mScene->mMetaData != nullptr && mScene->mMetaData->Get(AI_METADATA_SOURCE_COPYRIGHT, copyright_str)) {
+		asset.copyright = copyright_str.C_Str();
+	}
 }
 
 inline void ExtractAnimationData(Asset& mAsset, std::string& animId, Ref<Animation>& animRef, Ref<Buffer>& buffer, const aiNodeAnim* nodeChannel, float ticksPerSecond)
@@ -949,7 +1006,7 @@ void glTFExporter::ExportAnimations()
 
             // It appears that assimp stores this type of animation as multiple animations.
             // where each aiNodeAnim in mChannels animates a specific node.
-            std::string name = nameAnim + "_" + to_string(channelIndex);
+            std::string name = nameAnim + "_" + ai_to_string(channelIndex);
             name = mAsset->FindUniqueID(name, "animation");
             Ref<Animation> animRef = mAsset->animations.Create(name);
 
@@ -958,7 +1015,7 @@ void glTFExporter::ExportAnimations()
 
             for (unsigned int j = 0; j < 3; ++j) {
                 std::string channelType;
-                int channelSize;
+                int channelSize=0;
                 switch (j) {
                     case 0:
                         channelType = "rotation";
diff --git a/Engine/lib/assimp/code/AssetLib/glTF/glTFExporter.h b/Engine/lib/assimp/code/AssetLib/glTF/glTFExporter.h
new file mode 100644
index 000000000..a52695402
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/glTF/glTFExporter.h
@@ -0,0 +1,118 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file GltfExporter.h
+ * Declares the exporter class to write a scene to a gltf/glb file
+ */
+#pragma once
+#ifndef AI_GLTFEXPORTER_H_INC
+#define AI_GLTFEXPORTER_H_INC
+
+#if !defined(ASSIMP_BUILD_NO_GLTF_EXPORTER) && !defined(ASSIMP_BUILD_NO_GLTF1_EXPORTER)
+
+#include <assimp/material.h>
+#include <assimp/types.h>
+
+#include <map>
+#include <memory>
+#include <sstream>
+#include <vector>
+
+struct aiScene;
+struct aiNode;
+
+namespace glTFCommon {
+template <class T>
+class Ref;
+
+}
+
+namespace glTF {
+class Asset;
+struct TexProperty;
+struct Node;
+
+} // namespace glTF
+
+namespace Assimp {
+class IOSystem;
+class IOStream;
+class ExportProperties;
+
+// ------------------------------------------------------------------------------------------------
+/** Helper class to export a given scene to an glTF file. */
+// ------------------------------------------------------------------------------------------------
+class glTFExporter {
+public:
+    /// Constructor for a specific scene to export
+    glTFExporter(const char *filename, IOSystem *pIOSystem, const aiScene *pScene,
+            const ExportProperties *pProperties, bool binary);
+
+private:
+    const char *mFilename;
+    IOSystem *mIOSystem;
+    std::shared_ptr<const aiScene> mScene;
+    const ExportProperties *mProperties;
+
+    std::map<std::string, unsigned int> mTexturesByPath;
+
+    std::shared_ptr<glTF::Asset> mAsset;
+
+    std::vector<unsigned char> mBodyData;
+
+    void WriteBinaryData(IOStream *outfile, std::size_t sceneLength);
+
+    void GetTexSampler(const aiMaterial *mat, glTF::TexProperty &prop);
+    void GetMatColorOrTex(const aiMaterial *mat, glTF::TexProperty &prop, const char *propName, int type, int idx, aiTextureType tt);
+    void ExportMetadata();
+    void ExportMaterials();
+    void ExportMeshes();
+    unsigned int ExportNodeHierarchy(const aiNode *n);
+    unsigned int ExportNode(const aiNode *node, glTFCommon::Ref<glTF::Node> & parent);
+    void ExportScene();
+    void ExportAnimations();
+};
+
+} // namespace Assimp
+
+#endif // ASSIMP_BUILD_NO_GLTF_EXPORTER
+
+#endif // AI_GLTFEXPORTER_H_INC
diff --git a/Engine/lib/assimp/code/glTF/glTFImporter.cpp b/Engine/lib/assimp/code/AssetLib/glTF/glTFImporter.cpp
similarity index 55%
rename from Engine/lib/assimp/code/glTF/glTFImporter.cpp
rename to Engine/lib/assimp/code/AssetLib/glTF/glTFImporter.cpp
index 9ecd742f6..81db12eba 100644
--- a/Engine/lib/assimp/code/glTF/glTFImporter.cpp
+++ b/Engine/lib/assimp/code/AssetLib/glTF/glTFImporter.cpp
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -40,20 +39,23 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
-#ifndef ASSIMP_BUILD_NO_GLTF_IMPORTER
+#if !defined(ASSIMP_BUILD_NO_GLTF_IMPORTER) && !defined(ASSIMP_BUILD_NO_GLTF1_IMPORTER)
 
-#include "glTF/glTFImporter.h"
-#include "glTF/glTFAsset.h"
-#include "glTF/glTFAssetWriter.h"
+#include "AssetLib/glTF/glTFImporter.h"
+#include "AssetLib/glTF/glTFAsset.h"
+#if !defined(ASSIMP_BUILD_NO_EXPORT)
+#include "AssetLib/glTF/glTFAssetWriter.h"
+#endif
 #include "PostProcessing/MakeVerboseFormat.h"
 
 #include <assimp/StringComparison.h>
 #include <assimp/StringUtils.h>
-#include <assimp/Importer.hpp>
-#include <assimp/scene.h>
 #include <assimp/ai_assert.h>
-#include <assimp/DefaultLogger.hpp>
+#include <assimp/commonMetaData.h>
 #include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/Importer.hpp>
 
 #include <memory>
 
@@ -69,8 +71,7 @@ static const aiImporterDesc desc = {
     "",
     "",
     "",
-    aiImporterFlags_SupportTextFlavour | aiImporterFlags_SupportBinaryFlavour | aiImporterFlags_SupportCompressedFlavour
-        | aiImporterFlags_LimitedSupport | aiImporterFlags_Experimental,
+    aiImporterFlags_SupportTextFlavour | aiImporterFlags_SupportBinaryFlavour | aiImporterFlags_SupportCompressedFlavour | aiImporterFlags_LimitedSupport | aiImporterFlags_Experimental,
     0,
     0,
     0,
@@ -78,11 +79,8 @@ static const aiImporterDesc desc = {
     "gltf glb"
 };
 
-glTFImporter::glTFImporter()
-: BaseImporter()
-, meshOffsets()
-, embeddedTexIdxs()
-, mScene( nullptr ) {
+glTFImporter::glTFImporter() :
+        BaseImporter(), meshOffsets(), embeddedTexIdxs(), mScene(nullptr) {
     // empty
 }
 
@@ -90,34 +88,23 @@ glTFImporter::~glTFImporter() {
     // empty
 }
 
-const aiImporterDesc* glTFImporter::GetInfo() const {
+const aiImporterDesc *glTFImporter::GetInfo() const {
     return &desc;
 }
 
-bool glTFImporter::CanRead(const std::string& pFile, IOSystem* pIOHandler, bool /* checkSig */) const {
-    const std::string &extension = GetExtension(pFile);
-
-    if (extension != "gltf" && extension != "glb") {
+bool glTFImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /* checkSig */) const {
+    glTF::Asset asset(pIOHandler);
+    try {
+        asset.Load(pFile, GetExtension(pFile) == "glb");
+        std::string version = asset.asset.version;
+        return !version.empty() && version[0] == '1';
+    } catch (...) {
         return false;
     }
-
-    if (pIOHandler) {
-        glTF::Asset asset(pIOHandler);
-        try {
-            asset.Load(pFile, extension == "glb");
-            std::string version = asset.asset.version;
-            return !version.empty() && version[0] == '1';
-        } catch (...) {
-            return false;
-        }
-    }
-
-    return false;
 }
 
-inline
-void SetMaterialColorProperty(std::vector<int>& embeddedTexIdxs, Asset& /*r*/, glTF::TexProperty prop, aiMaterial* mat,
-        aiTextureType texType, const char* pKey, unsigned int type, unsigned int idx) {
+inline void SetMaterialColorProperty(std::vector<int> &embeddedTexIdxs, Asset & /*r*/, glTF::TexProperty prop, aiMaterial *mat,
+        aiTextureType texType, const char *pKey, unsigned int type, unsigned int idx) {
     if (prop.texture) {
         if (prop.texture->source) {
             aiString uri(prop.texture->source->uri);
@@ -138,22 +125,22 @@ void SetMaterialColorProperty(std::vector<int>& embeddedTexIdxs, Asset& /*r*/, g
     }
 }
 
-void glTFImporter::ImportMaterials(glTF::Asset& r) {
+void glTFImporter::ImportMaterials(glTF::Asset &r) {
     mScene->mNumMaterials = unsigned(r.materials.Size());
-    mScene->mMaterials = new aiMaterial*[mScene->mNumMaterials];
+    mScene->mMaterials = new aiMaterial *[mScene->mNumMaterials];
 
     for (unsigned int i = 0; i < mScene->mNumMaterials; ++i) {
-        aiMaterial* aimat = mScene->mMaterials[i] = new aiMaterial();
+        aiMaterial *aimat = mScene->mMaterials[i] = new aiMaterial();
 
-        Material& mat = r.materials[i];
+        Material &mat = r.materials[i];
 
         /*if (!mat.name.empty())*/ {
             aiString str(mat.id /*mat.name*/);
             aimat->AddProperty(&str, AI_MATKEY_NAME);
         }
 
-        SetMaterialColorProperty(embeddedTexIdxs, r, mat.ambient,  aimat, aiTextureType_AMBIENT,  AI_MATKEY_COLOR_AMBIENT );
-        SetMaterialColorProperty(embeddedTexIdxs, r, mat.diffuse,  aimat, aiTextureType_DIFFUSE,  AI_MATKEY_COLOR_DIFFUSE );
+        SetMaterialColorProperty(embeddedTexIdxs, r, mat.ambient, aimat, aiTextureType_AMBIENT, AI_MATKEY_COLOR_AMBIENT);
+        SetMaterialColorProperty(embeddedTexIdxs, r, mat.diffuse, aimat, aiTextureType_DIFFUSE, AI_MATKEY_COLOR_DIFFUSE);
         SetMaterialColorProperty(embeddedTexIdxs, r, mat.specular, aimat, aiTextureType_SPECULAR, AI_MATKEY_COLOR_SPECULAR);
         SetMaterialColorProperty(embeddedTexIdxs, r, mat.emission, aimat, aiTextureType_EMISSIVE, AI_MATKEY_COLOR_EMISSIVE);
 
@@ -170,29 +157,27 @@ void glTFImporter::ImportMaterials(glTF::Asset& r) {
 
     if (mScene->mNumMaterials == 0) {
         mScene->mNumMaterials = 1;
-        mScene->mMaterials = new aiMaterial*[1];
+        // Delete the array of length zero created above.
+        delete[] mScene->mMaterials;
+        mScene->mMaterials = new aiMaterial *[1];
         mScene->mMaterials[0] = new aiMaterial();
     }
 }
 
-
-static inline void SetFace(aiFace& face, int a)
-{
+static inline void SetFace(aiFace &face, int a) {
     face.mNumIndices = 1;
     face.mIndices = new unsigned int[1];
     face.mIndices[0] = a;
 }
 
-static inline void SetFace(aiFace& face, int a, int b)
-{
+static inline void SetFace(aiFace &face, int a, int b) {
     face.mNumIndices = 2;
     face.mIndices = new unsigned int[2];
     face.mIndices[0] = a;
     face.mIndices[1] = b;
 }
 
-static inline void SetFace(aiFace& face, int a, int b, int c)
-{
+static inline void SetFace(aiFace &face, int a, int b, int c) {
     face.mNumIndices = 3;
     face.mIndices = new unsigned int[3];
     face.mIndices[0] = a;
@@ -200,9 +185,7 @@ static inline void SetFace(aiFace& face, int a, int b, int c)
     face.mIndices[2] = c;
 }
 
-#ifdef ASSIMP_BUILD_DEBUG
-static inline bool CheckValidFacesIndices(aiFace* faces, unsigned nFaces, unsigned nVerts)
-{
+static inline bool CheckValidFacesIndices(aiFace *faces, unsigned nFaces, unsigned nVerts) {
     for (unsigned i = 0; i < nFaces; ++i) {
         for (unsigned j = 0; j < faces[i].mNumIndices; ++j) {
             unsigned idx = faces[i].mIndices[j];
@@ -212,104 +195,98 @@ static inline bool CheckValidFacesIndices(aiFace* faces, unsigned nFaces, unsign
     }
     return true;
 }
-#endif // ASSIMP_BUILD_DEBUG
 
-void glTFImporter::ImportMeshes(glTF::Asset& r)
-{
-    std::vector<aiMesh*> meshes;
+void glTFImporter::ImportMeshes(glTF::Asset &r) {
+    std::vector<aiMesh *> meshes;
 
     unsigned int k = 0;
+    meshOffsets.clear();
 
     for (unsigned int m = 0; m < r.meshes.Size(); ++m) {
-        Mesh& mesh = r.meshes[m];
+        Mesh &mesh = r.meshes[m];
 
-		// Check if mesh extensions is used
-		if(mesh.Extension.size() > 0)
-		{
-			for(Mesh::SExtension* cur_ext : mesh.Extension)
-			{
+        // Check if mesh extensions is used
+        if (mesh.Extension.size() > 0) {
 #ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC
-				if(cur_ext->Type == Mesh::SExtension::EType::Compression_Open3DGC)
-				{
-					// Limitations for meshes when using Open3DGC-compression.
-					// It's a current limitation of sp... Specification have not this part still - about mesh compression. Why only one primitive?
-					// Because glTF is very flexibly. But in fact it ugly flexible. Every primitive can has own set of accessors and accessors can
-					// point to a-a-a-a-any part of buffer (through bufferview of course) and even to another buffer. We know that "Open3DGC-compression"
-					// is applicable only to part of buffer. As we can't guaranty continuity of the data for decoder, we will limit quantity of primitives.
-					// Yes indices, coordinates etc. still can br stored in different buffers, but with current specification it's a exporter problem.
-					// Also primitive can has only one of "POSITION", "NORMAL" and less then "AI_MAX_NUMBER_OF_TEXTURECOORDS" of "TEXCOORD". All accessor
-					// of primitive must point to one continuous region of the buffer.
-					if(mesh.primitives.size() > 2) throw DeadlyImportError("GLTF: When using Open3DGC compression then only one primitive per mesh are allowed.");
+            for (Mesh::SExtension *cur_ext : mesh.Extension) {
+                if (cur_ext->Type == Mesh::SExtension::EType::Compression_Open3DGC) {
+                    // Limitations for meshes when using Open3DGC-compression.
+                    // It's a current limitation of sp... Specification have not this part still - about mesh compression. Why only one primitive?
+                    // Because glTF is very flexibly. But in fact it ugly flexible. Every primitive can has own set of accessors and accessors can
+                    // point to a-a-a-a-any part of buffer (through bufferview of course) and even to another buffer. We know that "Open3DGC-compression"
+                    // is applicable only to part of buffer. As we can't guaranty continuity of the data for decoder, we will limit quantity of primitives.
+                    // Yes indices, coordinates etc. still can br stored in different buffers, but with current specification it's a exporter problem.
+                    // Also primitive can has only one of "POSITION", "NORMAL" and less then "AI_MAX_NUMBER_OF_TEXTURECOORDS" of "TEXCOORD". All accessor
+                    // of primitive must point to one continuous region of the buffer.
+                    if (mesh.primitives.size() > 2) throw DeadlyImportError("GLTF: When using Open3DGC compression then only one primitive per mesh are allowed.");
 
-					Mesh::SCompression_Open3DGC* o3dgc_ext = (Mesh::SCompression_Open3DGC*)cur_ext;
-					Ref<Buffer> buf = r.buffers.Get(o3dgc_ext->Buffer);
+                    Mesh::SCompression_Open3DGC *o3dgc_ext = (Mesh::SCompression_Open3DGC *)cur_ext;
+                    Ref<Buffer> buf = r.buffers.Get(o3dgc_ext->Buffer);
 
-					buf->EncodedRegion_SetCurrent(mesh.id);
-				}
-				else
+                    buf->EncodedRegion_SetCurrent(mesh.id);
+                } else
+                {
+                    throw DeadlyImportError("GLTF: Can not import mesh: unknown mesh extension (code: \"", ai_to_string(cur_ext->Type),
+                                            "\"), only Open3DGC is supported.");
+                }
+            }
 #endif
-				{
-					throw DeadlyImportError("GLTF: Can not import mesh: unknown mesh extension (code: \"" + to_string(cur_ext->Type) +
-											"\"), only Open3DGC is supported.");
-				}
-			}
-		}// if(mesh.Extension.size() > 0)
+        } // if(mesh.Extension.size() > 0)
 
-		meshOffsets.push_back(k);
+        meshOffsets.push_back(k);
         k += unsigned(mesh.primitives.size());
 
         for (unsigned int p = 0; p < mesh.primitives.size(); ++p) {
-            Mesh::Primitive& prim = mesh.primitives[p];
+            Mesh::Primitive &prim = mesh.primitives[p];
 
-            aiMesh* aim = new aiMesh();
+            aiMesh *aim = new aiMesh();
             meshes.push_back(aim);
 
             aim->mName = mesh.id;
             if (mesh.primitives.size() > 1) {
-                ai_uint32& len = aim->mName.length;
+                ai_uint32 &len = aim->mName.length;
                 aim->mName.data[len] = '-';
                 len += 1 + ASSIMP_itoa10(aim->mName.data + len + 1, unsigned(MAXLEN - len - 1), p);
             }
 
             switch (prim.mode) {
-                case PrimitiveMode_POINTS:
-                    aim->mPrimitiveTypes |= aiPrimitiveType_POINT;
-                    break;
+            case PrimitiveMode_POINTS:
+                aim->mPrimitiveTypes |= aiPrimitiveType_POINT;
+                break;
 
-                case PrimitiveMode_LINES:
-                case PrimitiveMode_LINE_LOOP:
-                case PrimitiveMode_LINE_STRIP:
-                    aim->mPrimitiveTypes |= aiPrimitiveType_LINE;
-                    break;
+            case PrimitiveMode_LINES:
+            case PrimitiveMode_LINE_LOOP:
+            case PrimitiveMode_LINE_STRIP:
+                aim->mPrimitiveTypes |= aiPrimitiveType_LINE;
+                break;
 
-                case PrimitiveMode_TRIANGLES:
-                case PrimitiveMode_TRIANGLE_STRIP:
-                case PrimitiveMode_TRIANGLE_FAN:
-                    aim->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
-                    break;
+            case PrimitiveMode_TRIANGLES:
+            case PrimitiveMode_TRIANGLE_STRIP:
+            case PrimitiveMode_TRIANGLE_FAN:
+                aim->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
+                break;
             }
 
-            Mesh::Primitive::Attributes& attr = prim.attributes;
+            Mesh::Primitive::Attributes &attr = prim.attributes;
 
-			if (attr.position.size() > 0 && attr.position[0]) {
+            if (attr.position.size() > 0 && attr.position[0]) {
                 aim->mNumVertices = attr.position[0]->count;
                 attr.position[0]->ExtractData(aim->mVertices);
-			}
+            }
 
-			if (attr.normal.size() > 0 && attr.normal[0]) attr.normal[0]->ExtractData(aim->mNormals);
+            if (attr.normal.size() > 0 && attr.normal[0]) attr.normal[0]->ExtractData(aim->mNormals);
 
             for (size_t tc = 0; tc < attr.texcoord.size() && tc < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++tc) {
                 attr.texcoord[tc]->ExtractData(aim->mTextureCoords[tc]);
                 aim->mNumUVComponents[tc] = attr.texcoord[tc]->GetNumComponents();
 
-                aiVector3D* values = aim->mTextureCoords[tc];
+                aiVector3D *values = aim->mTextureCoords[tc];
                 for (unsigned int i = 0; i < aim->mNumVertices; ++i) {
                     values[i].y = 1 - values[i].y; // Flip Y coords
                 }
             }
 
-
-            aiFace* faces = 0;
+            aiFace *faces = 0;
             unsigned int nFaces = 0;
 
             if (prim.indices) {
@@ -319,68 +296,75 @@ void glTFImporter::ImportMeshes(glTF::Asset& r)
                 ai_assert(data.IsValid());
 
                 switch (prim.mode) {
-                    case PrimitiveMode_POINTS: {
-                        nFaces = count;
-                        faces = new aiFace[nFaces];
-                        for (unsigned int i = 0; i < count; ++i) {
-                            SetFace(faces[i], data.GetUInt(i));
-                        }
-                        break;
+                case PrimitiveMode_POINTS: {
+                    nFaces = count;
+                    faces = new aiFace[nFaces];
+                    for (unsigned int i = 0; i < count; ++i) {
+                        SetFace(faces[i], data.GetUInt(i));
                     }
-
-                    case PrimitiveMode_LINES: {
-                        nFaces = count / 2;
-                        faces = new aiFace[nFaces];
-                        for (unsigned int i = 0; i < count; i += 2) {
-                            SetFace(faces[i / 2], data.GetUInt(i), data.GetUInt(i + 1));
-                        }
-                        break;
-                    }
-
-                    case PrimitiveMode_LINE_LOOP:
-                    case PrimitiveMode_LINE_STRIP: {
-                        nFaces = count - ((prim.mode == PrimitiveMode_LINE_STRIP) ? 1 : 0);
-                        faces = new aiFace[nFaces];
-                        SetFace(faces[0], data.GetUInt(0), data.GetUInt(1));
-                        for (unsigned int i = 2; i < count; ++i) {
-                            SetFace(faces[i - 1], faces[i - 2].mIndices[1], data.GetUInt(i));
-                        }
-                        if (prim.mode == PrimitiveMode_LINE_LOOP) { // close the loop
-                            SetFace(faces[count - 1], faces[count - 2].mIndices[1], faces[0].mIndices[0]);
-                        }
-                        break;
-                    }
-
-                    case PrimitiveMode_TRIANGLES: {
-                        nFaces = count / 3;
-                        faces = new aiFace[nFaces];
-                        for (unsigned int i = 0; i < count; i += 3) {
-                            SetFace(faces[i / 3], data.GetUInt(i), data.GetUInt(i + 1), data.GetUInt(i + 2));
-                        }
-                        break;
-                    }
-                    case PrimitiveMode_TRIANGLE_STRIP: {
-                        nFaces = count - 2;
-                        faces = new aiFace[nFaces];
-                        SetFace(faces[0], data.GetUInt(0), data.GetUInt(1), data.GetUInt(2));
-                        for (unsigned int i = 3; i < count; ++i) {
-                            SetFace(faces[i - 2], faces[i - 1].mIndices[1], faces[i - 1].mIndices[2], data.GetUInt(i));
-                        }
-                        break;
-                    }
-                    case PrimitiveMode_TRIANGLE_FAN:
-                        nFaces = count - 2;
-                        faces = new aiFace[nFaces];
-                        SetFace(faces[0], data.GetUInt(0), data.GetUInt(1), data.GetUInt(2));
-                        for (unsigned int i = 3; i < count; ++i) {
-                            SetFace(faces[i - 2], faces[0].mIndices[0], faces[i - 1].mIndices[2], data.GetUInt(i));
-                        }
-                        break;
+                    break;
                 }
-            }
-            else { // no indices provided so directly generate from counts
 
-                // use the already determined count as it includes checks 
+                case PrimitiveMode_LINES: {
+                    nFaces = count / 2;
+                    if (nFaces * 2 != count) {
+                        ASSIMP_LOG_WARN("The number of vertices was not compatible with the LINES mode. Some vertices were dropped.");
+                        count = nFaces * 2;
+                    }
+                    faces = new aiFace[nFaces];
+                    for (unsigned int i = 0; i < count; i += 2) {
+                        SetFace(faces[i / 2], data.GetUInt(i), data.GetUInt(i + 1));
+                    }
+                    break;
+                }
+
+                case PrimitiveMode_LINE_LOOP:
+                case PrimitiveMode_LINE_STRIP: {
+                    nFaces = count - ((prim.mode == PrimitiveMode_LINE_STRIP) ? 1 : 0);
+                    faces = new aiFace[nFaces];
+                    SetFace(faces[0], data.GetUInt(0), data.GetUInt(1));
+                    for (unsigned int i = 2; i < count; ++i) {
+                        SetFace(faces[i - 1], faces[i - 2].mIndices[1], data.GetUInt(i));
+                    }
+                    if (prim.mode == PrimitiveMode_LINE_LOOP) { // close the loop
+                        SetFace(faces[count - 1], faces[count - 2].mIndices[1], faces[0].mIndices[0]);
+                    }
+                    break;
+                }
+
+                case PrimitiveMode_TRIANGLES: {
+                    nFaces = count / 3;
+                    if (nFaces * 3 != count) {
+                        ASSIMP_LOG_WARN("The number of vertices was not compatible with the TRIANGLES mode. Some vertices were dropped.");
+                        count = nFaces * 3;
+                    }
+                    faces = new aiFace[nFaces];
+                    for (unsigned int i = 0; i < count; i += 3) {
+                        SetFace(faces[i / 3], data.GetUInt(i), data.GetUInt(i + 1), data.GetUInt(i + 2));
+                    }
+                    break;
+                }
+                case PrimitiveMode_TRIANGLE_STRIP: {
+                    nFaces = count - 2;
+                    faces = new aiFace[nFaces];
+                    SetFace(faces[0], data.GetUInt(0), data.GetUInt(1), data.GetUInt(2));
+                    for (unsigned int i = 3; i < count; ++i) {
+                        SetFace(faces[i - 2], faces[i - 1].mIndices[1], faces[i - 1].mIndices[2], data.GetUInt(i));
+                    }
+                    break;
+                }
+                case PrimitiveMode_TRIANGLE_FAN:
+                    nFaces = count - 2;
+                    faces = new aiFace[nFaces];
+                    SetFace(faces[0], data.GetUInt(0), data.GetUInt(1), data.GetUInt(2));
+                    for (unsigned int i = 3; i < count; ++i) {
+                        SetFace(faces[i - 2], faces[0].mIndices[0], faces[i - 1].mIndices[2], data.GetUInt(i));
+                    }
+                    break;
+                }
+            } else { // no indices provided so directly generate from counts
+
+                // use the already determined count as it includes checks
                 unsigned int count = aim->mNumVertices;
 
                 switch (prim.mode) {
@@ -395,6 +379,10 @@ void glTFImporter::ImportMeshes(glTF::Asset& r)
 
                 case PrimitiveMode_LINES: {
                     nFaces = count / 2;
+                    if (nFaces * 2 != count) {
+                        ASSIMP_LOG_WARN("The number of vertices was not compatible with the LINES mode. Some vertices were dropped.");
+                        count = nFaces * 2;
+                    }
                     faces = new aiFace[nFaces];
                     for (unsigned int i = 0; i < count; i += 2) {
                         SetFace(faces[i / 2], i, i + 1);
@@ -418,6 +406,10 @@ void glTFImporter::ImportMeshes(glTF::Asset& r)
 
                 case PrimitiveMode_TRIANGLES: {
                     nFaces = count / 3;
+                    if (nFaces * 3 != count) {
+                        ASSIMP_LOG_WARN("The number of vertices was not compatible with the TRIANGLES mode. Some vertices were dropped.");
+                        count = nFaces * 3;
+                    }
                     faces = new aiFace[nFaces];
                     for (unsigned int i = 0; i < count; i += 3) {
                         SetFace(faces[i / 3], i, i + 1, i + 2);
@@ -447,7 +439,11 @@ void glTFImporter::ImportMeshes(glTF::Asset& r)
             if (faces) {
                 aim->mFaces = faces;
                 aim->mNumFaces = nFaces;
-                ai_assert(CheckValidFacesIndices(faces, nFaces, aim->mNumVertices));
+                const bool validRes = CheckValidFacesIndices(faces, nFaces, aim->mNumVertices);
+                if (!validRes) {
+                    ai_assert(validRes);
+                    ASSIMP_LOG_WARN("Invalid number of faces detected.");
+                }
             }
 
             if (prim.material) {
@@ -461,22 +457,22 @@ void glTFImporter::ImportMeshes(glTF::Asset& r)
     CopyVector(meshes, mScene->mMeshes, mScene->mNumMeshes);
 }
 
-void glTFImporter::ImportCameras(glTF::Asset& r) {
+void glTFImporter::ImportCameras(glTF::Asset &r) {
     if (!r.cameras.Size()) {
         return;
     }
 
     mScene->mNumCameras = r.cameras.Size();
-    mScene->mCameras = new aiCamera*[r.cameras.Size()];
+    mScene->mCameras = new aiCamera *[r.cameras.Size()];
     for (size_t i = 0; i < r.cameras.Size(); ++i) {
-        Camera& cam = r.cameras[i];
+        Camera &cam = r.cameras[i];
 
-        aiCamera* aicam = mScene->mCameras[i] = new aiCamera();
+        aiCamera *aicam = mScene->mCameras[i] = new aiCamera();
 
         if (cam.type == Camera::Perspective) {
-            aicam->mAspect        = cam.perspective.aspectRatio;
+            aicam->mAspect = cam.perspective.aspectRatio;
             aicam->mHorizontalFOV = cam.perspective.yfov * ((aicam->mAspect == 0.f) ? 1.f : aicam->mAspect);
-            aicam->mClipPlaneFar  = cam.perspective.zfar;
+            aicam->mClipPlaneFar = cam.perspective.zfar;
             aicam->mClipPlaneNear = cam.perspective.znear;
         } else {
             aicam->mClipPlaneFar = cam.ortographic.zfar;
@@ -490,30 +486,33 @@ void glTFImporter::ImportCameras(glTF::Asset& r) {
     }
 }
 
-void glTFImporter::ImportLights(glTF::Asset& r)
-{
+void glTFImporter::ImportLights(glTF::Asset &r) {
     if (!r.lights.Size()) return;
 
     mScene->mNumLights = r.lights.Size();
-    mScene->mLights = new aiLight*[r.lights.Size()];
+    mScene->mLights = new aiLight *[r.lights.Size()];
 
     for (size_t i = 0; i < r.lights.Size(); ++i) {
-        Light& l = r.lights[i];
+        Light &l = r.lights[i];
 
-        aiLight* ail = mScene->mLights[i] = new aiLight();
+        aiLight *ail = mScene->mLights[i] = new aiLight();
 
         switch (l.type) {
-            case Light::Type_directional:
-                ail->mType = aiLightSource_DIRECTIONAL; break;
+        case Light::Type_directional:
+            ail->mType = aiLightSource_DIRECTIONAL;
+            break;
 
-            case Light::Type_spot:
-                ail->mType = aiLightSource_SPOT; break;
+        case Light::Type_spot:
+            ail->mType = aiLightSource_SPOT;
+            break;
 
-            case Light::Type_ambient:
-                ail->mType = aiLightSource_AMBIENT; break;
+        case Light::Type_ambient:
+            ail->mType = aiLightSource_AMBIENT;
+            break;
 
-            default: // Light::Type_point
-                ail->mType = aiLightSource_POINT; break;
+        default: // Light::Type_point
+            ail->mType = aiLightSource_POINT;
+            break;
         }
 
         CopyValue(l.color, ail->mColorAmbient);
@@ -523,35 +522,32 @@ void glTFImporter::ImportLights(glTF::Asset& r)
         ail->mAngleOuterCone = l.falloffAngle;
         ail->mAngleInnerCone = l.falloffExponent; // TODO fix this, it does not look right at all
 
-        ail->mAttenuationConstant  = l.constantAttenuation;
-        ail->mAttenuationLinear    = l.linearAttenuation;
+        ail->mAttenuationConstant = l.constantAttenuation;
+        ail->mAttenuationLinear = l.linearAttenuation;
         ail->mAttenuationQuadratic = l.quadraticAttenuation;
     }
 }
 
+aiNode *ImportNode(aiScene *pScene, glTF::Asset &r, std::vector<unsigned int> &meshOffsets, glTF::Ref<glTF::Node> &ptr) {
+    Node &node = *ptr;
 
-aiNode* ImportNode(aiScene* pScene, glTF::Asset& r, std::vector<unsigned int>& meshOffsets, glTF::Ref<glTF::Node>& ptr)
-{
-    Node& node = *ptr;
-
-    aiNode* ainode = new aiNode(node.id);
+    aiNode *ainode = new aiNode(node.id);
 
     if (!node.children.empty()) {
         ainode->mNumChildren = unsigned(node.children.size());
-        ainode->mChildren = new aiNode*[ainode->mNumChildren];
+        ainode->mChildren = new aiNode *[ainode->mNumChildren];
 
         for (unsigned int i = 0; i < ainode->mNumChildren; ++i) {
-            aiNode* child = ImportNode(pScene, r, meshOffsets, node.children[i]);
+            aiNode *child = ImportNode(pScene, r, meshOffsets, node.children[i]);
             child->mParent = ainode;
             ainode->mChildren[i] = child;
         }
     }
 
-    aiMatrix4x4& matrix = ainode->mTransformation;
+    aiMatrix4x4 &matrix = ainode->mTransformation;
     if (node.matrix.isPresent) {
         CopyValue(node.matrix.value, matrix);
-    }
-    else {
+    } else {
         if (node.translation.isPresent) {
             aiVector3D trans;
             CopyValue(node.translation.value, trans);
@@ -568,7 +564,6 @@ aiNode* ImportNode(aiScene* pScene, glTF::Asset& r, std::vector<unsigned int>& m
             matrix = s * matrix;
         }
 
-
         if (node.rotation.isPresent) {
             aiQuaternion rot;
             CopyValue(node.rotation.value, rot);
@@ -606,22 +601,20 @@ aiNode* ImportNode(aiScene* pScene, glTF::Asset& r, std::vector<unsigned int>& m
     return ainode;
 }
 
-void glTFImporter::ImportNodes(glTF::Asset& r)
-{
+void glTFImporter::ImportNodes(glTF::Asset &r) {
     if (!r.scene) return;
 
-    std::vector< Ref<Node> > rootNodes = r.scene->nodes;
+    std::vector<Ref<Node>> rootNodes = r.scene->nodes;
 
     // The root nodes
     unsigned int numRootNodes = unsigned(rootNodes.size());
     if (numRootNodes == 1) { // a single root node: use it
         mScene->mRootNode = ImportNode(mScene, r, meshOffsets, rootNodes[0]);
-    }
-    else if (numRootNodes > 1) { // more than one root node: create a fake root
-        aiNode* root = new aiNode("ROOT");
-        root->mChildren = new aiNode*[numRootNodes];
+    } else if (numRootNodes > 1) { // more than one root node: create a fake root
+        aiNode *root = new aiNode("ROOT");
+        root->mChildren = new aiNode *[numRootNodes];
         for (unsigned int i = 0; i < numRootNodes; ++i) {
-            aiNode* node = ImportNode(mScene, r, meshOffsets, rootNodes[i]);
+            aiNode *node = ImportNode(mScene, r, meshOffsets, rootNodes[i]);
             node->mParent = root;
             root->mChildren[root->mNumChildren++] = node;
         }
@@ -633,8 +626,7 @@ void glTFImporter::ImportNodes(glTF::Asset& r)
     //}
 }
 
-void glTFImporter::ImportEmbeddedTextures(glTF::Asset& r)
-{
+void glTFImporter::ImportEmbeddedTextures(glTF::Asset &r) {
     embeddedTexIdxs.resize(r.images.Size(), -1);
 
     int numEmbeddedTexs = 0;
@@ -646,7 +638,7 @@ void glTFImporter::ImportEmbeddedTextures(glTF::Asset& r)
     if (numEmbeddedTexs == 0)
         return;
 
-    mScene->mTextures = new aiTexture*[numEmbeddedTexs];
+    mScene->mTextures = new aiTexture *[numEmbeddedTexs];
 
     // Add the embedded textures
     for (size_t i = 0; i < r.images.Size(); ++i) {
@@ -656,17 +648,18 @@ void glTFImporter::ImportEmbeddedTextures(glTF::Asset& r)
         int idx = mScene->mNumTextures++;
         embeddedTexIdxs[i] = idx;
 
-        aiTexture* tex = mScene->mTextures[idx] = new aiTexture();
+        aiTexture *tex = mScene->mTextures[idx] = new aiTexture();
 
         size_t length = img.GetDataLength();
-        void* data = img.StealData();
+        void *data = img.StealData();
 
+        tex->mFilename = img.name;
         tex->mWidth = static_cast<unsigned int>(length);
         tex->mHeight = 0;
-        tex->pcData = reinterpret_cast<aiTexel*>(data);
+        tex->pcData = reinterpret_cast<aiTexel *>(data);
 
         if (!img.mimeType.empty()) {
-            const char* ext = strchr(img.mimeType.c_str(), '/') + 1;
+            const char *ext = strchr(img.mimeType.c_str(), '/') + 1;
             if (ext) {
                 if (strcmp(ext, "jpeg") == 0) ext = "jpg";
 
@@ -679,8 +672,26 @@ void glTFImporter::ImportEmbeddedTextures(glTF::Asset& r)
     }
 }
 
-void glTFImporter::InternReadFile(const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler)
-{
+void glTFImporter::ImportCommonMetadata(glTF::Asset &a) {
+    ai_assert(mScene->mMetaData == nullptr);
+    const bool hasVersion = !a.asset.version.empty();
+    const bool hasGenerator = !a.asset.generator.empty();
+    const bool hasCopyright = !a.asset.copyright.empty();
+    if (hasVersion || hasGenerator || hasCopyright) {
+        mScene->mMetaData = new aiMetadata;
+        if (hasVersion) {
+            mScene->mMetaData->Add(AI_METADATA_SOURCE_FORMAT_VERSION, aiString(a.asset.version));
+        }
+        if (hasGenerator) {
+            mScene->mMetaData->Add(AI_METADATA_SOURCE_GENERATOR, aiString(a.asset.generator));
+        }
+        if (hasCopyright) {
+            mScene->mMetaData->Add(AI_METADATA_SOURCE_COPYRIGHT, aiString(a.asset.copyright));
+        }
+    }
+}
+
+void glTFImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
     // clean all member arrays
     meshOffsets.clear();
     embeddedTexIdxs.clear();
@@ -691,7 +702,6 @@ void glTFImporter::InternReadFile(const std::string& pFile, aiScene* pScene, IOS
     glTF::Asset asset(pIOHandler);
     asset.Load(pFile, GetExtension(pFile) == "glb");
 
-
     //
     // Copy the data out
     //
@@ -705,7 +715,7 @@ void glTFImporter::InternReadFile(const std::string& pFile, aiScene* pScene, IOS
     ImportLights(asset);
 
     ImportNodes(asset);
-
+    ImportCommonMetadata(asset);
 
     if (pScene->mNumMeshes == 0) {
         pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
@@ -713,4 +723,3 @@ void glTFImporter::InternReadFile(const std::string& pFile, aiScene* pScene, IOS
 }
 
 #endif // ASSIMP_BUILD_NO_GLTF_IMPORTER
-
diff --git a/Engine/lib/assimp/code/glTF/glTFImporter.h b/Engine/lib/assimp/code/AssetLib/glTF/glTFImporter.h
similarity index 74%
rename from Engine/lib/assimp/code/glTF/glTFImporter.h
rename to Engine/lib/assimp/code/AssetLib/glTF/glTFImporter.h
index ce8a000dc..529da53cc 100644
--- a/Engine/lib/assimp/code/glTF/glTFImporter.h
+++ b/Engine/lib/assimp/code/AssetLib/glTF/glTFImporter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -39,6 +39,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 ----------------------------------------------------------------------
 */
+#pragma once
 #ifndef AI_GLTFIMPORTER_H_INC
 #define AI_GLTFIMPORTER_H_INC
 
@@ -47,10 +48,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 struct aiNode;
 
-
-namespace glTF
-{
+namespace glTF {
     class Asset;
+
 }
 
 namespace Assimp {
@@ -59,34 +59,31 @@ namespace Assimp {
  * Load the glTF format.
  * https://github.com/KhronosGroup/glTF/tree/master/specification
  */
-class glTFImporter : public BaseImporter{
+class glTFImporter : public BaseImporter {
 public:
     glTFImporter();
-    virtual ~glTFImporter();
-    virtual bool CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig ) const;
+    ~glTFImporter() override;
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const override;
 
 protected:
-    virtual const aiImporterDesc* GetInfo() const;
-    virtual void InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler );
+    const aiImporterDesc *GetInfo() const override;
+    void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) override;
 
 private:
+    void ImportEmbeddedTextures(glTF::Asset &a);
+    void ImportMaterials(glTF::Asset &a);
+    void ImportMeshes(glTF::Asset &a);
+    void ImportCameras(glTF::Asset &a);
+    void ImportLights(glTF::Asset &a);
+    void ImportNodes(glTF::Asset &a);
+    void ImportCommonMetadata(glTF::Asset &a);
 
+private:
     std::vector<unsigned int> meshOffsets;
-
     std::vector<int> embeddedTexIdxs;
-
-    aiScene* mScene;
-
-    void ImportEmbeddedTextures(glTF::Asset& a);
-    void ImportMaterials(glTF::Asset& a);
-    void ImportMeshes(glTF::Asset& a);
-    void ImportCameras(glTF::Asset& a);
-    void ImportLights(glTF::Asset& a);
-    void ImportNodes(glTF::Asset& a);
-
+    aiScene *mScene;
 };
 
-} // Namespace assimp
+} // namespace Assimp
 
 #endif // AI_GLTFIMPORTER_H_INC
-
diff --git a/Engine/lib/assimp/code/AssetLib/glTF2/glTF2Asset.h b/Engine/lib/assimp/code/AssetLib/glTF2/glTF2Asset.h
new file mode 100644
index 000000000..c597fc951
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/glTF2/glTF2Asset.h
@@ -0,0 +1,1242 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file glTFAsset.h
+ * Declares a glTF class to handle gltf/glb files
+ *
+ * glTF Extensions Support:
+ *   KHR_materials_pbrSpecularGlossiness full
+ *   KHR_materials_unlit full
+ *   KHR_lights_punctual full
+ *   KHR_materials_sheen full
+ *   KHR_materials_clearcoat full
+ *   KHR_materials_transmission full
+ *   KHR_materials_volume full
+ *   KHR_materials_ior full
+ */
+#ifndef GLTF2ASSET_H_INC
+#define GLTF2ASSET_H_INC
+
+#if !defined(ASSIMP_BUILD_NO_GLTF_IMPORTER) && !defined(ASSIMP_BUILD_NO_GLTF2_IMPORTER)
+
+#include <assimp/Exceptional.h>
+
+#include <algorithm>
+#include <list>
+#include <map>
+#include <set>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+// clang-format off
+#if (__GNUC__ == 8 && __GNUC_MINOR__ >= 0)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wclass-memaccess"
+#endif
+
+#include <rapidjson/document.h>
+#include <rapidjson/error/en.h>
+#include <rapidjson/rapidjson.h>
+#include <rapidjson/schema.h>
+
+#if (__GNUC__ == 8 && __GNUC_MINOR__ >= 0)
+#   pragma GCC diagnostic pop
+#endif
+
+#ifdef ASSIMP_API
+#   include <assimp/ByteSwapper.h>
+#   include <assimp/DefaultIOSystem.h>
+#   include <memory>
+#else
+#   include <memory>
+#   define AI_SWAP4(p)
+#   define ai_assert
+#endif
+
+#if _MSC_VER > 1500 || (defined __GNUC___)
+#   define ASSIMP_GLTF_USE_UNORDERED_MULTIMAP
+#else
+#   define gltf_unordered_map map
+#   define gltf_unordered_set set
+#endif
+
+#ifdef ASSIMP_GLTF_USE_UNORDERED_MULTIMAP
+#   include <unordered_map>
+#   include <unordered_set>
+#   if defined(_MSC_VER) && _MSC_VER <= 1600
+#       define gltf_unordered_map tr1::unordered_map
+#       define gltf_unordered_set tr1::unordered_set
+#   else
+#       define gltf_unordered_map unordered_map
+#       define gltf_unordered_set unordered_set
+#   endif
+#endif
+// clang-format on
+
+#include <assimp/StringUtils.h>
+#include <assimp/material.h>
+#include <assimp/GltfMaterial.h>
+
+#include "AssetLib/glTF/glTFCommon.h"
+
+namespace glTF2 {
+
+using glTFCommon::Nullable;
+using glTFCommon::Ref;
+using glTFCommon::IOStream;
+using glTFCommon::IOSystem;
+using glTFCommon::shared_ptr;
+
+using rapidjson::Document;
+using rapidjson::Value;
+
+class Asset;
+class AssetWriter;
+
+struct BufferView; // here due to cross-reference
+struct Texture;
+struct Skin;
+
+using glTFCommon::mat4;
+using glTFCommon::vec3;
+using glTFCommon::vec4;
+
+//! Magic number for GLB files
+#define AI_GLB_MAGIC_NUMBER "glTF"
+
+#ifdef ASSIMP_API
+#include <assimp/Compiler/pushpack1.h>
+#endif
+
+//! For binary .glb files
+//! 12-byte header (+ the JSON + a "body" data section)
+struct GLB_Header {
+    uint8_t magic[4]; //!< Magic number: "glTF"
+    uint32_t version; //!< Version number (always 2 as of the last update)
+    uint32_t length; //!< Total length of the Binary glTF, including header, scene, and body, in bytes
+} PACK_STRUCT;
+
+struct GLB_Chunk {
+    uint32_t chunkLength;
+    uint32_t chunkType;
+} PACK_STRUCT;
+
+#ifdef ASSIMP_API
+#include <assimp/Compiler/poppack1.h>
+#endif
+
+//! Values for the GLB_Chunk::chunkType field
+enum ChunkType {
+    ChunkType_JSON = 0x4E4F534A,
+    ChunkType_BIN = 0x004E4942
+};
+
+//! Values for the mesh primitive modes
+enum PrimitiveMode {
+    PrimitiveMode_POINTS = 0,
+    PrimitiveMode_LINES = 1,
+    PrimitiveMode_LINE_LOOP = 2,
+    PrimitiveMode_LINE_STRIP = 3,
+    PrimitiveMode_TRIANGLES = 4,
+    PrimitiveMode_TRIANGLE_STRIP = 5,
+    PrimitiveMode_TRIANGLE_FAN = 6
+};
+
+//! Values for the Accessor::componentType field
+enum ComponentType {
+    ComponentType_BYTE = 5120,
+    ComponentType_UNSIGNED_BYTE = 5121,
+    ComponentType_SHORT = 5122,
+    ComponentType_UNSIGNED_SHORT = 5123,
+    ComponentType_UNSIGNED_INT = 5125,
+    ComponentType_FLOAT = 5126
+};
+
+inline unsigned int ComponentTypeSize(ComponentType t) {
+    switch (t) {
+    case ComponentType_SHORT:
+    case ComponentType_UNSIGNED_SHORT:
+        return 2;
+
+    case ComponentType_UNSIGNED_INT:
+    case ComponentType_FLOAT:
+        return 4;
+
+    case ComponentType_BYTE:
+    case ComponentType_UNSIGNED_BYTE:
+        return 1;
+    default:
+        throw DeadlyImportError("GLTF: Unsupported Component Type ", ai_to_string(t));
+    }
+}
+
+//! Values for the BufferView::target field
+enum BufferViewTarget {
+    BufferViewTarget_NONE = 0,
+    BufferViewTarget_ARRAY_BUFFER = 34962,
+    BufferViewTarget_ELEMENT_ARRAY_BUFFER = 34963
+};
+
+//! Values for the Sampler::magFilter field
+enum class SamplerMagFilter : unsigned int {
+    UNSET = 0,
+    SamplerMagFilter_Nearest = 9728,
+    SamplerMagFilter_Linear = 9729
+};
+
+//! Values for the Sampler::minFilter field
+enum class SamplerMinFilter : unsigned int {
+    UNSET = 0,
+    SamplerMinFilter_Nearest = 9728,
+    SamplerMinFilter_Linear = 9729,
+    SamplerMinFilter_Nearest_Mipmap_Nearest = 9984,
+    SamplerMinFilter_Linear_Mipmap_Nearest = 9985,
+    SamplerMinFilter_Nearest_Mipmap_Linear = 9986,
+    SamplerMinFilter_Linear_Mipmap_Linear = 9987
+};
+
+//! Values for the Sampler::wrapS and Sampler::wrapT field
+enum class SamplerWrap : unsigned int {
+    UNSET = 0,
+    Clamp_To_Edge = 33071,
+    Mirrored_Repeat = 33648,
+    Repeat = 10497
+};
+
+//! Values for the Texture::format and Texture::internalFormat fields
+enum TextureFormat {
+    TextureFormat_ALPHA = 6406,
+    TextureFormat_RGB = 6407,
+    TextureFormat_RGBA = 6408,
+    TextureFormat_LUMINANCE = 6409,
+    TextureFormat_LUMINANCE_ALPHA = 6410
+};
+
+//! Values for the Texture::target field
+enum TextureTarget {
+    TextureTarget_TEXTURE_2D = 3553
+};
+
+//! Values for the Texture::type field
+enum TextureType {
+    TextureType_UNSIGNED_BYTE = 5121,
+    TextureType_UNSIGNED_SHORT_5_6_5 = 33635,
+    TextureType_UNSIGNED_SHORT_4_4_4_4 = 32819,
+    TextureType_UNSIGNED_SHORT_5_5_5_1 = 32820
+};
+
+//! Values for the Animation::Target::path field
+enum AnimationPath {
+    AnimationPath_TRANSLATION,
+    AnimationPath_ROTATION,
+    AnimationPath_SCALE,
+    AnimationPath_WEIGHTS,
+};
+
+//! Values for the Animation::Sampler::interpolation field
+enum Interpolation {
+    Interpolation_LINEAR,
+    Interpolation_STEP,
+    Interpolation_CUBICSPLINE,
+};
+
+//! Values for the Accessor::type field (helper class)
+class AttribType {
+public:
+    enum Value { SCALAR,
+        VEC2,
+        VEC3,
+        VEC4,
+        MAT2,
+        MAT3,
+        MAT4 };
+
+private:
+    static const size_t NUM_VALUES = static_cast<size_t>(MAT4) + 1;
+
+    struct Info {
+        const char *name;
+        unsigned int numComponents;
+    };
+
+    template <int N>
+    struct data { static const Info infos[NUM_VALUES]; };
+
+public:
+    inline static Value FromString(const char *str) {
+        for (size_t i = 0; i < NUM_VALUES; ++i) {
+            if (strcmp(data<0>::infos[i].name, str) == 0) {
+                return static_cast<Value>(i);
+            }
+        }
+        return SCALAR;
+    }
+
+    inline static const char *ToString(Value type) {
+        return data<0>::infos[static_cast<size_t>(type)].name;
+    }
+
+    inline static unsigned int GetNumComponents(Value type) {
+        return data<0>::infos[static_cast<size_t>(type)].numComponents;
+    }
+};
+
+// must match the order of the AttribTypeTraits::Value enum!
+template <int N>
+const AttribType::Info
+        AttribType::data<N>::infos[AttribType::NUM_VALUES] = {
+            { "SCALAR", 1 }, { "VEC2", 2 }, { "VEC3", 3 }, { "VEC4", 4 }, { "MAT2", 4 }, { "MAT3", 9 }, { "MAT4", 16 }
+        };
+
+
+struct CustomExtension {
+
+    //
+    // A struct containing custom extension data added to a glTF2 file
+    // Has to contain Object, Array, String, Double, Uint64, and Int64 at a minimum
+    // String, Double, Uint64, and Int64 are stored in the Nullables
+    // Object and Array are stored in the std::vector
+    //
+    std::string name;
+
+    Nullable<std::string> mStringValue;
+    Nullable<double> mDoubleValue;
+    Nullable<uint64_t> mUint64Value;
+    Nullable<int64_t> mInt64Value;
+    Nullable<bool> mBoolValue;
+
+    // std::vector<CustomExtension> handles both Object and Array
+    Nullable<std::vector<CustomExtension>> mValues;
+
+    operator bool() const {
+        return Size() != 0;
+    }
+
+    size_t Size() const {
+        if (mValues.isPresent) {
+            return mValues.value.size();
+        } else if (mStringValue.isPresent || mDoubleValue.isPresent || mUint64Value.isPresent || mInt64Value.isPresent || mBoolValue.isPresent) {
+            return 1;
+        }
+        return 0;
+    }
+
+    CustomExtension() = default;
+
+    ~CustomExtension() = default;
+
+    CustomExtension(const CustomExtension &other) :
+            name(other.name),
+            mStringValue(other.mStringValue),
+            mDoubleValue(other.mDoubleValue),
+            mUint64Value(other.mUint64Value),
+            mInt64Value(other.mInt64Value),
+            mBoolValue(other.mBoolValue),
+            mValues(other.mValues) {
+        // empty
+    }
+};
+
+//! Base class for all glTF top-level objects
+struct Object {
+    int index; //!< The index of this object within its property container
+    int oIndex; //!< The original index of this object defined in the JSON
+    std::string id; //!< The globally unique ID used to reference this object
+    std::string name; //!< The user-defined name of this object
+
+    CustomExtension customExtensions;
+    CustomExtension extras;
+
+    //! Objects marked as special are not exported (used to emulate the binary body buffer)
+    virtual bool IsSpecial() const { return false; }
+
+    virtual ~Object() {}
+
+    //! Maps special IDs to another ID, where needed. Subclasses may override it (statically)
+    static const char *TranslateId(Asset & /*r*/, const char *id) { return id; }
+
+    inline Value *FindString(Value &val, const char *id);
+    inline Value *FindNumber(Value &val, const char *id);
+    inline Value *FindUInt(Value &val, const char *id);
+    inline Value *FindArray(Value &val, const char *id);
+    inline Value *FindObject(Value &val, const char *id);
+    inline Value *FindExtension(Value &val, const char *extensionId);
+
+    inline void ReadExtensions(Value &val);
+    inline void ReadExtras(Value &val);
+};
+
+//
+// Classes for each glTF top-level object type
+//
+
+//! A buffer points to binary geometry, animation, or skins.
+struct Buffer : public Object {
+    /********************* Types *********************/
+public:
+    enum Type {
+        Type_arraybuffer,
+        Type_text
+    };
+
+    /// \struct SEncodedRegion
+    /// Descriptor of encoded region in "bufferView".
+    struct SEncodedRegion {
+        const size_t Offset; ///< Offset from begin of "bufferView" to encoded region, in bytes.
+        const size_t EncodedData_Length; ///< Size of encoded region, in bytes.
+        uint8_t *const DecodedData; ///< Cached encoded data.
+        const size_t DecodedData_Length; ///< Size of decoded region, in bytes.
+        const std::string ID; ///< ID of the region.
+
+        /// \fn SEncodedRegion(const size_t pOffset, const size_t pEncodedData_Length, uint8_t* pDecodedData, const size_t pDecodedData_Length, const std::string pID)
+        /// Constructor.
+        /// \param [in] pOffset - offset from begin of "bufferView" to encoded region, in bytes.
+        /// \param [in] pEncodedData_Length - size of encoded region, in bytes.
+        /// \param [in] pDecodedData - pointer to decoded data array.
+        /// \param [in] pDecodedData_Length - size of encoded region, in bytes.
+        /// \param [in] pID - ID of the region.
+        SEncodedRegion(const size_t pOffset, const size_t pEncodedData_Length, uint8_t *pDecodedData, const size_t pDecodedData_Length, const std::string &pID) :
+                Offset(pOffset),
+                EncodedData_Length(pEncodedData_Length),
+                DecodedData(pDecodedData),
+                DecodedData_Length(pDecodedData_Length),
+                ID(pID) {}
+
+        /// \fn ~SEncodedRegion()
+        /// Destructor.
+        ~SEncodedRegion() { delete[] DecodedData; }
+    };
+
+    /******************* Variables *******************/
+
+    //std::string uri; //!< The uri of the buffer. Can be a filepath, a data uri, etc. (required)
+    size_t byteLength; //!< The length of the buffer in bytes. (default: 0)
+    //std::string type; //!< XMLHttpRequest responseType (default: "arraybuffer")
+    size_t capacity = 0; //!< The capacity of the buffer in bytes. (default: 0)
+
+    Type type;
+
+    /// \var EncodedRegion_Current
+    /// Pointer to currently active encoded region.
+    /// Why not decoding all regions at once and not to set one buffer with decoded data?
+    /// Yes, why not? Even "accessor" point to decoded data. I mean that fields "byteOffset", "byteStride" and "count" has values which describes decoded
+    /// data array. But only in range of mesh while is active parameters from "compressedData". For another mesh accessors point to decoded data too. But
+    /// offset is counted for another regions is encoded.
+    /// Example. You have two meshes. For every of it you have 4 bytes of data. That data compressed to 2 bytes. So, you have buffer with encoded data:
+    /// M1_E0, M1_E1, M2_E0, M2_E1.
+    /// After decoding you'll get:
+    /// M1_D0, M1_D1, M1_D2, M1_D3, M2_D0, M2_D1, M2_D2, M2_D3.
+    /// "accessors" must to use values that point to decoded data - obviously. So, you'll expect "accessors" like
+    /// "accessor_0" : { byteOffset: 0, byteLength: 4}, "accessor_1" : { byteOffset: 4, byteLength: 4}
+    /// but in real life you'll get:
+    /// "accessor_0" : { byteOffset: 0, byteLength: 4}, "accessor_1" : { byteOffset: 2, byteLength: 4}
+    /// Yes, accessor of next mesh has offset and length which mean: current mesh data is decoded, all other data is encoded.
+    /// And when before you start to read data of current mesh (with encoded data of course) you must decode region of "bufferView", after read finished
+    /// delete encoding mark. And after that you can repeat process: decode data of mesh, read, delete decoded data.
+    ///
+    /// Remark. Encoding all data at once is good in world with computers which do not has RAM limitation. So, you must use step by step encoding in
+    /// exporter and importer. And, thanks to such way, there is no need to load whole file into memory.
+    SEncodedRegion *EncodedRegion_Current;
+
+private:
+    shared_ptr<uint8_t> mData; //!< Pointer to the data
+    bool mIsSpecial; //!< Set to true for special cases (e.g. the body buffer)
+
+    /// \var EncodedRegion_List
+    /// List of encoded regions.
+    std::list<SEncodedRegion *> EncodedRegion_List;
+
+    /******************* Functions *******************/
+
+public:
+    Buffer();
+    ~Buffer();
+
+    void Read(Value &obj, Asset &r);
+
+    bool LoadFromStream(IOStream &stream, size_t length = 0, size_t baseOffset = 0);
+
+    /// \fn void EncodedRegion_Mark(const size_t pOffset, const size_t pEncodedData_Length, uint8_t* pDecodedData, const size_t pDecodedData_Length, const std::string& pID)
+    /// Mark region of "bufferView" as encoded. When data is request from such region then "bufferView" use decoded data.
+    /// \param [in] pOffset - offset from begin of "bufferView" to encoded region, in bytes.
+    /// \param [in] pEncodedData_Length - size of encoded region, in bytes.
+    /// \param [in] pDecodedData - pointer to decoded data array.
+    /// \param [in] pDecodedData_Length - size of encoded region, in bytes.
+    /// \param [in] pID - ID of the region.
+    void EncodedRegion_Mark(const size_t pOffset, const size_t pEncodedData_Length, uint8_t *pDecodedData, const size_t pDecodedData_Length, const std::string &pID);
+
+    /// \fn void EncodedRegion_SetCurrent(const std::string& pID)
+    /// Select current encoded region by ID. \sa EncodedRegion_Current.
+    /// \param [in] pID - ID of the region.
+    void EncodedRegion_SetCurrent(const std::string &pID);
+
+    /// \fn bool ReplaceData(const size_t pBufferData_Offset, const size_t pBufferData_Count, const uint8_t* pReplace_Data, const size_t pReplace_Count)
+    /// Replace part of buffer data. Pay attention that function work with original array of data (\ref mData) not with encoded regions.
+    /// \param [in] pBufferData_Offset - index of first element in buffer from which new data will be placed.
+    /// \param [in] pBufferData_Count - count of bytes in buffer which will be replaced.
+    /// \param [in] pReplace_Data - pointer to array with new data for buffer.
+    /// \param [in] pReplace_Count - count of bytes in new data.
+    /// \return true - if successfully replaced, false if input arguments is out of range.
+    bool ReplaceData(const size_t pBufferData_Offset, const size_t pBufferData_Count, const uint8_t *pReplace_Data, const size_t pReplace_Count);
+    bool ReplaceData_joint(const size_t pBufferData_Offset, const size_t pBufferData_Count, const uint8_t *pReplace_Data, const size_t pReplace_Count);
+
+    size_t AppendData(uint8_t *data, size_t length);
+    void Grow(size_t amount);
+
+    uint8_t *GetPointer() { return mData.get(); }
+
+    void MarkAsSpecial() { mIsSpecial = true; }
+
+    bool IsSpecial() const override { return mIsSpecial; }
+
+    std::string GetURI() { return std::string(this->id) + ".bin"; }
+
+    static const char *TranslateId(Asset &r, const char *id);
+};
+
+//! A view into a buffer generally representing a subset of the buffer.
+struct BufferView : public Object {
+    Ref<Buffer> buffer; //! The ID of the buffer. (required)
+    size_t byteOffset; //! The offset into the buffer in bytes. (required)
+    size_t byteLength; //! The length of the bufferView in bytes. (default: 0)
+    unsigned int byteStride; //!< The stride, in bytes, between attributes referenced by this accessor. (default: 0)
+
+    BufferViewTarget target; //! The target that the WebGL buffer should be bound to.
+
+    void Read(Value &obj, Asset &r);
+    uint8_t *GetPointer(size_t accOffset);
+};
+
+//! A typed view into a BufferView. A BufferView contains raw binary data.
+//! An accessor provides a typed view into a BufferView or a subset of a BufferView
+//! similar to how WebGL's vertexAttribPointer() defines an attribute in a buffer.
+struct Accessor : public Object {
+    struct Sparse;
+
+    Ref<BufferView> bufferView; //!< The ID of the bufferView. (required)
+    size_t byteOffset; //!< The offset relative to the start of the bufferView in bytes. (required)
+    ComponentType componentType; //!< The datatype of components in the attribute. (required)
+    size_t count; //!< The number of attributes referenced by this accessor. (required)
+    AttribType::Value type; //!< Specifies if the attribute is a scalar, vector, or matrix. (required)
+    std::vector<double> max; //!< Maximum value of each component in this attribute.
+    std::vector<double> min; //!< Minimum value of each component in this attribute.
+    std::unique_ptr<Sparse> sparse;
+    std::unique_ptr<Buffer> decodedBuffer; // Packed decoded data, returned instead of original bufferView if present
+
+    unsigned int GetNumComponents();
+    unsigned int GetBytesPerComponent();
+    unsigned int GetElementSize();
+
+    inline uint8_t *GetPointer();
+    inline size_t GetStride();
+    inline size_t GetMaxByteSize();
+
+    template <class T>
+    void ExtractData(T *&outData);
+
+    void WriteData(size_t count, const void *src_buffer, size_t src_stride);
+    void WriteSparseValues(size_t count, const void *src_data, size_t src_dataStride);
+    void WriteSparseIndices(size_t count, const void *src_idx, size_t src_idxStride);
+
+    //! Helper class to iterate the data
+    class Indexer {
+        friend struct Accessor;
+
+        // This field is reported as not used, making it protectd is the easiest way to work around it without going to the bottom of what the problem is:
+        // ../code/glTF2/glTF2Asset.h:392:19: error: private field 'accessor' is not used [-Werror,-Wunused-private-field]
+    protected:
+        Accessor &accessor;
+
+    private:
+        uint8_t *data;
+        size_t elemSize, stride;
+
+        Indexer(Accessor &acc);
+
+    public:
+        //! Accesses the i-th value as defined by the accessor
+        template <class T>
+        T GetValue(int i);
+
+        //! Accesses the i-th value as defined by the accessor
+        inline unsigned int GetUInt(int i) {
+            return GetValue<unsigned int>(i);
+        }
+
+        inline bool IsValid() const {
+            return data != nullptr;
+        }
+    };
+
+    inline Indexer GetIndexer() {
+        return Indexer(*this);
+    }
+
+    Accessor() {}
+    void Read(Value &obj, Asset &r);
+
+    //sparse
+    struct Sparse {
+        size_t count;
+        ComponentType indicesType;
+        Ref<BufferView> indices;
+        size_t indicesByteOffset;
+        Ref<BufferView> values;
+        size_t valuesByteOffset;
+
+        std::vector<uint8_t> data; //!< Actual data, which may be defaulted to an array of zeros or the original data, with the sparse buffer view applied on top of it.
+
+        void PopulateData(size_t numBytes, uint8_t *bytes);
+        void PatchData(unsigned int elementSize);
+    };
+};
+
+struct Camera : public Object {
+    enum Type {
+        Perspective,
+        Orthographic
+    };
+
+    Type type;
+
+    union {
+        struct {
+            float aspectRatio; //!<The floating - point aspect ratio of the field of view. (0 = undefined = use the canvas one)
+            float yfov; //!<The floating - point vertical field of view in radians. (required)
+            float zfar; //!<The floating - point distance to the far clipping plane. (required)
+            float znear; //!< The floating - point distance to the near clipping plane. (required)
+        } perspective;
+
+        struct {
+            float xmag; //! The floating-point horizontal magnification of the view. (required)
+            float ymag; //! The floating-point vertical magnification of the view. (required)
+            float zfar; //! The floating-point distance to the far clipping plane. (required)
+            float znear; //! The floating-point distance to the near clipping plane. (required)
+        } ortographic;
+    } cameraProperties;
+
+    Camera() :
+            type(Perspective),
+            cameraProperties() {
+        // empty
+    }
+    void Read(Value &obj, Asset &r);
+};
+
+//! A light (from KHR_lights_punctual extension)
+struct Light : public Object {
+    enum Type {
+        Directional,
+        Point,
+        Spot
+    };
+
+    Type type;
+
+    vec3 color;
+    float intensity;
+    Nullable<float> range;
+
+    float innerConeAngle;
+    float outerConeAngle;
+
+    Light() {}
+    void Read(Value &obj, Asset &r);
+};
+
+//! Image data used to create a texture.
+struct Image : public Object {
+    std::string uri; //! The uri of the image, that can be a file path, a data URI, etc.. (required)
+
+    Ref<BufferView> bufferView;
+
+    std::string mimeType;
+
+    int width, height;
+
+private:
+    std::unique_ptr<uint8_t[]> mData;
+    size_t mDataLength;
+
+public:
+    Image();
+    void Read(Value &obj, Asset &r);
+
+    inline bool HasData() const { return mDataLength > 0; }
+
+    inline size_t GetDataLength() const { return mDataLength; }
+
+    inline const uint8_t *GetData() const { return mData.get(); }
+
+    inline uint8_t *StealData();
+
+    inline void SetData(uint8_t *data, size_t length, Asset &r);
+};
+
+const vec4 defaultBaseColor = { 1, 1, 1, 1 };
+const vec3 defaultEmissiveFactor = { 0, 0, 0 };
+const vec4 defaultDiffuseFactor = { 1, 1, 1, 1 };
+const vec3 defaultSpecularFactor = { 1, 1, 1 };
+const vec3 defaultSheenFactor = { 0, 0, 0 };
+const vec3 defaultAttenuationColor = { 1, 1, 1 };
+
+struct TextureInfo {
+    Ref<Texture> texture;
+    unsigned int index;
+    unsigned int texCoord = 0;
+
+    bool textureTransformSupported = false;
+    struct TextureTransformExt {
+        float offset[2];
+        float rotation;
+        float scale[2];
+    } TextureTransformExt_t;
+};
+
+struct NormalTextureInfo : TextureInfo {
+    float scale = 1;
+};
+
+struct OcclusionTextureInfo : TextureInfo {
+    float strength = 1;
+};
+
+struct PbrMetallicRoughness {
+    vec4 baseColorFactor;
+    TextureInfo baseColorTexture;
+    TextureInfo metallicRoughnessTexture;
+    float metallicFactor;
+    float roughnessFactor;
+};
+
+struct PbrSpecularGlossiness {
+    vec4 diffuseFactor;
+    vec3 specularFactor;
+    float glossinessFactor;
+    TextureInfo diffuseTexture;
+    TextureInfo specularGlossinessTexture;
+
+    PbrSpecularGlossiness() { SetDefaults(); }
+    void SetDefaults();
+};
+
+struct MaterialSheen {
+    vec3 sheenColorFactor;
+    float sheenRoughnessFactor;
+    TextureInfo sheenColorTexture;
+    TextureInfo sheenRoughnessTexture;
+
+    MaterialSheen() { SetDefaults(); }
+    void SetDefaults();
+};
+
+struct MaterialClearcoat {
+    float clearcoatFactor = 0.f;
+    float clearcoatRoughnessFactor = 0.f;
+    TextureInfo clearcoatTexture;
+    TextureInfo clearcoatRoughnessTexture;
+    NormalTextureInfo clearcoatNormalTexture;
+};
+
+struct MaterialTransmission {
+    TextureInfo transmissionTexture;
+    float transmissionFactor = 0.f;
+};
+
+struct MaterialVolume {
+    float thicknessFactor = 0.f;
+    TextureInfo thicknessTexture;
+    float attenuationDistance = 0.f;
+    vec3 attenuationColor;
+
+    MaterialVolume() { SetDefaults(); }
+    void SetDefaults();
+};
+
+struct MaterialIOR {
+    float ior = 0.f;
+
+    MaterialIOR() { SetDefaults(); }
+    void SetDefaults();
+};
+
+//! The material appearance of a primitive.
+struct Material : public Object {
+    //PBR metallic roughness properties
+    PbrMetallicRoughness pbrMetallicRoughness;
+
+    //other basic material properties
+    NormalTextureInfo normalTexture;
+    OcclusionTextureInfo occlusionTexture;
+    TextureInfo emissiveTexture;
+    vec3 emissiveFactor;
+    std::string alphaMode;
+    float alphaCutoff;
+    bool doubleSided;
+
+    //extension: KHR_materials_pbrSpecularGlossiness
+    Nullable<PbrSpecularGlossiness> pbrSpecularGlossiness;
+
+    //extension: KHR_materials_sheen
+    Nullable<MaterialSheen> materialSheen;
+
+    //extension: KHR_materials_clearcoat
+    Nullable<MaterialClearcoat> materialClearcoat;
+
+    //extension: KHR_materials_transmission
+    Nullable<MaterialTransmission> materialTransmission;
+
+    //extension: KHR_materials_volume
+    Nullable<MaterialVolume> materialVolume;
+
+    //extension: KHR_materials_ior
+    Nullable<MaterialIOR> materialIOR;
+    
+    //extension: KHR_materials_unlit
+    bool unlit;
+
+    Material() { SetDefaults(); }
+    void Read(Value &obj, Asset &r);
+    void SetDefaults();
+
+    inline void SetTextureProperties(Asset &r, Value *prop, TextureInfo &out);
+    inline void ReadTextureProperty(Asset &r, Value &vals, const char *propName, TextureInfo &out);
+    inline void ReadTextureProperty(Asset &r, Value &vals, const char *propName, NormalTextureInfo &out);
+    inline void ReadTextureProperty(Asset &r, Value &vals, const char *propName, OcclusionTextureInfo &out);
+};
+
+//! A set of primitives to be rendered. A node can contain one or more meshes. A node's transform places the mesh in the scene.
+struct Mesh : public Object {
+    using AccessorList = std::vector<Ref<Accessor>>;
+
+    struct Primitive {
+        PrimitiveMode mode;
+
+        struct Attributes {
+            AccessorList position, normal, tangent, texcoord, color, joint, jointmatrix, weight;
+        } attributes;
+
+        Ref<Accessor> indices;
+
+        Ref<Material> material;
+
+        struct Target {
+            AccessorList position, normal, tangent;
+        };
+        std::vector<Target> targets;
+
+        // extension: FB_ngon_encoding
+        bool ngonEncoded;
+
+        Primitive(): ngonEncoded(false) {}
+    };
+
+    std::vector<Primitive> primitives;
+
+    std::vector<float> weights;
+    std::vector<std::string> targetNames;
+
+    Mesh() {}
+
+    /// Get mesh data from JSON-object and place them to root asset.
+    /// \param [in] pJSON_Object - reference to pJSON-object from which data are read.
+    /// \param [out] pAsset_Root - reference to root asset where data will be stored.
+    void Read(Value &pJSON_Object, Asset &pAsset_Root);
+};
+
+struct Node : public Object {
+    std::vector<Ref<Node>> children;
+    std::vector<Ref<Mesh>> meshes;
+
+    Nullable<mat4> matrix;
+    Nullable<vec3> translation;
+    Nullable<vec4> rotation;
+    Nullable<vec3> scale;
+
+    Ref<Camera> camera;
+    Ref<Light> light;
+
+    std::vector<Ref<Node>> skeletons; //!< The ID of skeleton nodes. Each of which is the root of a node hierarchy.
+    Ref<Skin> skin; //!< The ID of the skin referenced by this node.
+    std::string jointName; //!< Name used when this node is a joint in a skin.
+
+    Ref<Node> parent; //!< This is not part of the glTF specification. Used as a helper.
+
+    Node() {}
+    void Read(Value &obj, Asset &r);
+};
+
+struct Program : public Object {
+    Program() {}
+    void Read(Value &obj, Asset &r);
+};
+
+struct Sampler : public Object {
+    SamplerMagFilter magFilter; //!< The texture magnification filter.
+    SamplerMinFilter minFilter; //!< The texture minification filter.
+    SamplerWrap wrapS; //!< The texture wrapping in the S direction.
+    SamplerWrap wrapT; //!< The texture wrapping in the T direction.
+
+    Sampler() { SetDefaults(); }
+    void Read(Value &obj, Asset &r);
+    void SetDefaults();
+};
+
+struct Scene : public Object {
+    std::string name;
+    std::vector<Ref<Node>> nodes;
+
+    Scene() {}
+    void Read(Value &obj, Asset &r);
+};
+
+struct Shader : public Object {
+    Shader() {}
+    void Read(Value &obj, Asset &r);
+};
+
+struct Skin : public Object {
+    Nullable<mat4> bindShapeMatrix; //!< Floating-point 4x4 transformation matrix stored in column-major order.
+    Ref<Accessor> inverseBindMatrices; //!< The ID of the accessor containing the floating-point 4x4 inverse-bind matrices.
+    std::vector<Ref<Node>> jointNames; //!< Joint names of the joints (nodes with a jointName property) in this skin.
+    std::string name; //!< The user-defined name of this object.
+
+    Skin() {}
+    void Read(Value &obj, Asset &r);
+};
+
+//! A texture and its sampler.
+struct Texture : public Object {
+    Ref<Sampler> sampler; //!< The ID of the sampler used by this texture. (required)
+    Ref<Image> source; //!< The ID of the image used by this texture. (required)
+
+    //TextureFormat format; //!< The texture's format. (default: TextureFormat_RGBA)
+    //TextureFormat internalFormat; //!< The texture's internal format. (default: TextureFormat_RGBA)
+
+    //TextureTarget target; //!< The target that the WebGL texture should be bound to. (default: TextureTarget_TEXTURE_2D)
+    //TextureType type; //!< Texel datatype. (default: TextureType_UNSIGNED_BYTE)
+
+    Texture() {}
+    void Read(Value &obj, Asset &r);
+};
+
+struct Animation : public Object {
+    struct Sampler {
+        Sampler() :
+                interpolation(Interpolation_LINEAR) {}
+
+        Ref<Accessor> input; //!< Accessor reference to the buffer storing the key-frame times.
+        Ref<Accessor> output; //!< Accessor reference to the buffer storing the key-frame values.
+        Interpolation interpolation; //!< Type of interpolation algorithm to use between key-frames.
+    };
+
+    struct Target {
+        Target() :
+                path(AnimationPath_TRANSLATION) {}
+
+        Ref<Node> node; //!< The node to animate.
+        AnimationPath path; //!< The property of the node to animate.
+    };
+
+    struct Channel {
+        Channel() :
+                sampler(-1) {}
+
+        int sampler; //!< The sampler index containing the animation data.
+        Target target; //!< The node and property to animate.
+    };
+
+    std::vector<Sampler> samplers; //!< All the key-frame data for this animation.
+    std::vector<Channel> channels; //!< Data to connect nodes to key-frames.
+
+    Animation() {}
+    void Read(Value &obj, Asset &r);
+};
+
+//! Base class for LazyDict that acts as an interface
+class LazyDictBase {
+public:
+    virtual ~LazyDictBase() {}
+
+    virtual void AttachToDocument(Document &doc) = 0;
+    virtual void DetachFromDocument() = 0;
+
+#if !defined(ASSIMP_BUILD_NO_EXPORT)
+    virtual void WriteObjects(AssetWriter &writer) = 0;
+#endif
+};
+
+template <class T>
+class LazyDict;
+
+//! (Implemented in glTFAssetWriter.h)
+template <class T>
+void WriteLazyDict(LazyDict<T> &d, AssetWriter &w);
+
+//! Manages lazy loading of the glTF top-level objects, and keeps a reference to them by ID
+//! It is the owner the loaded objects, so when it is destroyed it also deletes them
+template <class T>
+class LazyDict : public LazyDictBase {
+    friend class Asset;
+    friend class AssetWriter;
+
+    using Dict = typename std::gltf_unordered_map<unsigned int, unsigned int>;
+    using IdDict = typename std::gltf_unordered_map<std::string, unsigned int>;
+
+    std::vector<T *> mObjs; //! The read objects
+    Dict mObjsByOIndex; //! The read objects accessible by original index
+    IdDict mObjsById; //! The read objects accessible by id
+    const char *mDictId; //! ID of the dictionary object
+    const char *mExtId; //! ID of the extension defining the dictionary
+    Value *mDict; //! JSON dictionary object
+    Asset &mAsset; //! The asset instance
+
+    std::gltf_unordered_set<unsigned int> mRecursiveReferenceCheck; //! Used by Retrieve to prevent recursive lookups
+
+    void AttachToDocument(Document &doc);
+    void DetachFromDocument();
+
+#if !defined(ASSIMP_BUILD_NO_EXPORT)
+    void WriteObjects(AssetWriter &writer) { WriteLazyDict<T>(*this, writer); }
+#endif
+
+    Ref<T> Add(T *obj);
+
+public:
+    LazyDict(Asset &asset, const char *dictId, const char *extId = 0);
+    ~LazyDict();
+
+    Ref<T> Retrieve(unsigned int i);
+
+    Ref<T> Get(unsigned int i);
+    Ref<T> Get(const char *id);
+
+    Ref<T> Create(const char *id);
+    Ref<T> Create(const std::string &id) { return Create(id.c_str()); }
+
+    unsigned int Remove(const char *id);
+
+    inline unsigned int Size() const { return unsigned(mObjs.size()); }
+
+    inline T &operator[](size_t i) { return *mObjs[i]; }
+};
+
+struct AssetMetadata {
+    std::string copyright; //!< A copyright message suitable for display to credit the content creator.
+    std::string generator; //!< Tool that generated this glTF model.Useful for debugging.
+
+    struct {
+        std::string api; //!< Specifies the target rendering API (default: "WebGL")
+        std::string version; //!< Specifies the target rendering API (default: "1.0.3")
+    } profile; //!< Specifies the target rendering API and version, e.g., WebGL 1.0.3. (default: {})
+
+    std::string version; //!< The glTF format version
+
+    void Read(Document &doc);
+
+    AssetMetadata() :
+            version() {}
+};
+
+//
+// glTF Asset class
+//
+
+//! Root object for a glTF asset
+class Asset {
+    using IdMap = std::gltf_unordered_map<std::string, int>;
+
+    template <class T>
+    friend class LazyDict;
+    friend struct Buffer; // To access OpenFile
+    friend class AssetWriter;
+
+    std::vector<LazyDictBase *> mDicts;
+
+public:
+    //! Keeps info about the enabled extensions
+    struct Extensions {
+        bool KHR_materials_pbrSpecularGlossiness;
+        bool KHR_materials_unlit;
+        bool KHR_lights_punctual;
+        bool KHR_texture_transform;
+        bool KHR_materials_sheen;
+        bool KHR_materials_clearcoat;
+        bool KHR_materials_transmission;
+        bool KHR_materials_volume;
+        bool KHR_materials_ior;
+        bool KHR_draco_mesh_compression;
+        bool FB_ngon_encoding;
+        bool KHR_texture_basisu;
+
+        Extensions() :
+                KHR_materials_pbrSpecularGlossiness(false), 
+                KHR_materials_unlit(false), 
+                KHR_lights_punctual(false), 
+                KHR_texture_transform(false), 
+                KHR_materials_sheen(false), 
+                KHR_materials_clearcoat(false), 
+                KHR_materials_transmission(false), 
+                KHR_materials_volume(false),
+                KHR_materials_ior(false),
+                KHR_draco_mesh_compression(false),
+                FB_ngon_encoding(false),
+                KHR_texture_basisu(false) {
+            // empty
+        }
+    } extensionsUsed;
+
+    //! Keeps info about the required extensions
+    struct RequiredExtensions {
+        bool KHR_draco_mesh_compression;
+        bool KHR_texture_basisu;
+
+        RequiredExtensions() : KHR_draco_mesh_compression(false), KHR_texture_basisu(false) {
+            // empty
+        }
+    } extensionsRequired;
+
+    AssetMetadata asset;
+    Value *extras;
+
+    // Dictionaries for each type of object
+
+    LazyDict<Accessor> accessors;
+    LazyDict<Animation> animations;
+    LazyDict<Buffer> buffers;
+    LazyDict<BufferView> bufferViews;
+    LazyDict<Camera> cameras;
+    LazyDict<Light> lights;
+    LazyDict<Image> images;
+    LazyDict<Material> materials;
+    LazyDict<Mesh> meshes;
+    LazyDict<Node> nodes;
+    LazyDict<Sampler> samplers;
+    LazyDict<Scene> scenes;
+    LazyDict<Skin> skins;
+    LazyDict<Texture> textures;
+
+    Ref<Scene> scene;
+
+public:
+    Asset(IOSystem *io = nullptr, rapidjson::IRemoteSchemaDocumentProvider *schemaDocumentProvider = nullptr) :
+            mDicts(),
+            extensionsUsed(),
+            extensionsRequired(),
+            asset(),
+            extras(nullptr),
+            accessors(*this, "accessors"),
+            animations(*this, "animations"),
+            buffers(*this, "buffers"),
+            bufferViews(*this, "bufferViews"),
+            cameras(*this, "cameras"),
+            lights(*this, "lights", "KHR_lights_punctual"),
+            images(*this, "images"),
+            materials(*this, "materials"),
+            meshes(*this, "meshes"),
+            nodes(*this, "nodes"),
+            samplers(*this, "samplers"),
+            scenes(*this, "scenes"),
+            skins(*this, "skins"),
+            textures(*this, "textures") ,
+            mIOSystem(io),
+            mSchemaDocumentProvider(schemaDocumentProvider) {
+        // empty
+    }
+
+    //! Main function
+    void Load(const std::string &file, bool isBinary = false);
+
+    //! Parse the AssetMetadata and check that the version is 2.
+    bool CanRead(const std::string &pFile, bool isBinary = false);
+
+    //! Enables binary encoding on the asset
+    void SetAsBinary();
+
+    //! Search for an available name, starting from the given strings
+    std::string FindUniqueID(const std::string &str, const char *suffix);
+
+    Ref<Buffer> GetBodyBuffer() { return mBodyBuffer; }
+
+    Asset(Asset &) = delete;
+    Asset &operator=(const Asset &) = delete;
+
+private:
+    void ReadBinaryHeader(IOStream &stream, std::vector<char> &sceneData);
+
+    /// Obtain a JSON document from the stream.
+    /// \param second argument is a buffer used by the document. It must be kept
+    /// alive while the document is in use.
+    Document ReadDocument(IOStream& stream, bool isBinary, std::vector<char>& sceneData);
+
+    void ReadExtensionsUsed(Document &doc);
+    void ReadExtensionsRequired(Document &doc);
+
+    IOStream *OpenFile(const std::string &path, const char *mode, bool absolute = false);
+
+private:
+    IOSystem *mIOSystem;
+    rapidjson::IRemoteSchemaDocumentProvider *mSchemaDocumentProvider;
+    std::string mCurrentAssetDir;
+    size_t mSceneLength;
+    size_t mBodyOffset;
+    size_t mBodyLength;
+    IdMap mUsedIds;
+    Ref<Buffer> mBodyBuffer;
+};
+
+inline std::string getContextForErrorMessages(const std::string &id, const std::string &name) {
+    std::string context = id;
+    if (!name.empty()) {
+        context += " (\"" + name + "\")";
+    }
+    return context;
+}
+
+} // namespace glTF2
+
+// Include the implementation of the methods
+#include "glTF2Asset.inl"
+
+#endif // ASSIMP_BUILD_NO_GLTF_IMPORTER
+
+#endif // GLTF2ASSET_H_INC
diff --git a/Engine/lib/assimp/code/AssetLib/glTF2/glTF2Asset.inl b/Engine/lib/assimp/code/AssetLib/glTF2/glTF2Asset.inl
new file mode 100644
index 000000000..a74866e6c
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/glTF2/glTF2Asset.inl
@@ -0,0 +1,2069 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#include "AssetLib/glTF/glTFCommon.h"
+
+#include <assimp/MemoryIOWrapper.h>
+#include <assimp/StringUtils.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/Base64.hpp>
+
+// clang-format off
+#ifdef ASSIMP_ENABLE_DRACO
+
+// Google draco library headers spew many warnings. Bad Google, no cookie
+#   if _MSC_VER
+#       pragma warning(push)
+#       pragma warning(disable : 4018) // Signed/unsigned mismatch
+#       pragma warning(disable : 4804) // Unsafe use of type 'bool'
+#   elif defined(__clang__)
+#       pragma clang diagnostic push
+#       pragma clang diagnostic ignored "-Wsign-compare"
+#   elif defined(__GNUC__)
+#       pragma GCC diagnostic push
+#       if (__GNUC__ > 4)
+#           pragma GCC diagnostic ignored "-Wbool-compare"
+#       endif
+#   pragma GCC diagnostic ignored "-Wsign-compare"
+#endif
+
+#include "draco/compression/decode.h"
+#include "draco/core/decoder_buffer.h"
+
+#if _MSC_VER
+#   pragma warning(pop)
+#elif defined(__clang__)
+#   pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic pop
+#endif
+#ifndef DRACO_MESH_COMPRESSION_SUPPORTED
+#   error glTF: KHR_draco_mesh_compression: draco library must have DRACO_MESH_COMPRESSION_SUPPORTED
+#endif
+#endif
+// clang-format on
+
+using namespace Assimp;
+using namespace glTFCommon;
+
+namespace glTF2 {
+
+namespace {
+
+//
+// JSON Value reading helpers
+//
+inline CustomExtension ReadExtensions(const char *name, Value &obj) {
+    CustomExtension ret;
+    ret.name = name;
+    if (obj.IsObject()) {
+        ret.mValues.isPresent = true;
+        for (auto it = obj.MemberBegin(); it != obj.MemberEnd(); ++it) {
+            auto &val = it->value;
+            ret.mValues.value.push_back(ReadExtensions(it->name.GetString(), val));
+        }
+    } else if (obj.IsArray()) {
+        ret.mValues.value.reserve(obj.Size());
+        ret.mValues.isPresent = true;
+        for (unsigned int i = 0; i < obj.Size(); ++i) {
+            ret.mValues.value.push_back(ReadExtensions(name, obj[i]));
+        }
+    } else if (obj.IsNumber()) {
+        if (obj.IsUint64()) {
+            ret.mUint64Value.value = obj.GetUint64();
+            ret.mUint64Value.isPresent = true;
+        } else if (obj.IsInt64()) {
+            ret.mInt64Value.value = obj.GetInt64();
+            ret.mInt64Value.isPresent = true;
+        } else if (obj.IsDouble()) {
+            ret.mDoubleValue.value = obj.GetDouble();
+            ret.mDoubleValue.isPresent = true;
+        }
+    } else if (obj.IsString()) {
+        ReadValue(obj, ret.mStringValue);
+        ret.mStringValue.isPresent = true;
+    } else if (obj.IsBool()) {
+        ret.mBoolValue.value = obj.GetBool();
+        ret.mBoolValue.isPresent = true;
+    }
+    return ret;
+}
+
+inline void CopyData(size_t count, const uint8_t *src, size_t src_stride,
+        uint8_t *dst, size_t dst_stride) {
+    if (src_stride == dst_stride) {
+        memcpy(dst, src, count * src_stride);
+        return;
+    }
+
+    size_t sz = std::min(src_stride, dst_stride);
+    for (size_t i = 0; i < count; ++i) {
+        memcpy(dst, src, sz);
+        if (sz < dst_stride) {
+            memset(dst + sz, 0, dst_stride - sz);
+        }
+        src += src_stride;
+        dst += dst_stride;
+    }
+}
+
+void SetVector(vec4 &v, const float (&in)[4]) {
+    v[0] = in[0];
+    v[1] = in[1];
+    v[2] = in[2];
+    v[3] = in[3];
+}
+
+void SetVector(vec3 &v, const float (&in)[3]) {
+    v[0] = in[0];
+    v[1] = in[1];
+    v[2] = in[2];
+}
+
+template <int N>
+inline int Compare(const char *attr, const char (&str)[N]) {
+    return (strncmp(attr, str, N - 1) == 0) ? N - 1 : 0;
+}
+
+#if _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4706)
+#endif // _MSC_VER
+
+inline bool GetAttribVector(Mesh::Primitive &p, const char *attr, Mesh::AccessorList *&v, int &pos) {
+    if ((pos = Compare(attr, "POSITION"))) {
+        v = &(p.attributes.position);
+    } else if ((pos = Compare(attr, "NORMAL"))) {
+        v = &(p.attributes.normal);
+    } else if ((pos = Compare(attr, "TANGENT"))) {
+        v = &(p.attributes.tangent);
+    } else if ((pos = Compare(attr, "TEXCOORD"))) {
+        v = &(p.attributes.texcoord);
+    } else if ((pos = Compare(attr, "COLOR"))) {
+        v = &(p.attributes.color);
+    } else if ((pos = Compare(attr, "JOINTS"))) {
+        v = &(p.attributes.joint);
+    } else if ((pos = Compare(attr, "JOINTMATRIX"))) {
+        v = &(p.attributes.jointmatrix);
+    } else if ((pos = Compare(attr, "WEIGHTS"))) {
+        v = &(p.attributes.weight);
+    } else
+        return false;
+    return true;
+}
+
+inline bool GetAttribTargetVector(Mesh::Primitive &p, const int targetIndex, const char *attr, Mesh::AccessorList *&v, int &pos) {
+    if ((pos = Compare(attr, "POSITION"))) {
+        v = &(p.targets[targetIndex].position);
+    } else if ((pos = Compare(attr, "NORMAL"))) {
+        v = &(p.targets[targetIndex].normal);
+    } else if ((pos = Compare(attr, "TANGENT"))) {
+        v = &(p.targets[targetIndex].tangent);
+    } else
+        return false;
+    return true;
+}
+
+} // namespace
+
+inline Value *Object::FindString(Value &val, const char *memberId) {
+    return FindStringInContext(val, memberId, id.c_str(), name.c_str());
+}
+
+inline Value *Object::FindNumber(Value &val, const char *memberId) {
+    return FindNumberInContext(val, memberId, id.c_str(), name.c_str());
+}
+
+inline Value *Object::FindUInt(Value &val, const char *memberId) {
+    return FindUIntInContext(val, memberId, id.c_str(), name.c_str());
+}
+
+inline Value *Object::FindArray(Value &val, const char *memberId) {
+    return FindArrayInContext(val, memberId, id.c_str(), name.c_str());
+}
+
+inline Value *Object::FindObject(Value &val, const char *memberId) {
+    return FindObjectInContext(val, memberId, id.c_str(), name.c_str());
+}
+
+inline Value *Object::FindExtension(Value &val, const char *extensionId) {
+    return FindExtensionInContext(val, extensionId, id.c_str(), name.c_str());
+}
+
+inline void Object::ReadExtensions(Value &val) {
+    if (Value *curExtensions = FindObject(val, "extensions")) {
+        this->customExtensions = glTF2::ReadExtensions("extensions", *curExtensions);
+    }
+}
+
+inline void Object::ReadExtras(Value &val) {
+    if (Value *curExtras = FindObject(val, "extras")) {
+        this->extras = glTF2::ReadExtensions("extras", *curExtras);
+    }
+}
+
+#ifdef ASSIMP_ENABLE_DRACO
+
+template <typename T>
+inline void CopyFaceIndex_Draco(Buffer &decodedIndexBuffer, const draco::Mesh &draco_mesh) {
+    const size_t faceStride = sizeof(T) * 3;
+    for (draco::FaceIndex f(0); f < draco_mesh.num_faces(); ++f) {
+        const draco::Mesh::Face &face = draco_mesh.face(f);
+        T indices[3] = { static_cast<T>(face[0].value()), static_cast<T>(face[1].value()), static_cast<T>(face[2].value()) };
+        memcpy(decodedIndexBuffer.GetPointer() + (f.value() * faceStride), &indices[0], faceStride);
+    }
+}
+
+inline void SetDecodedIndexBuffer_Draco(const draco::Mesh &dracoMesh, Mesh::Primitive &prim) {
+    if (!prim.indices || dracoMesh.num_faces() == 0)
+        return;
+
+    // Create a decoded Index buffer (if there is one)
+    size_t componentBytes = prim.indices->GetBytesPerComponent();
+
+    std::unique_ptr<Buffer> decodedIndexBuffer(new Buffer());
+    decodedIndexBuffer->Grow(dracoMesh.num_faces() * 3 * componentBytes);
+
+    // If accessor uses the same size as draco implementation, copy the draco buffer directly
+
+    // Usually uint32_t but shouldn't assume
+    if (sizeof(dracoMesh.face(draco::FaceIndex(0))[0]) == componentBytes) {
+        memcpy(decodedIndexBuffer->GetPointer(), &dracoMesh.face(draco::FaceIndex(0))[0], decodedIndexBuffer->byteLength);
+        return;
+    }
+
+    // Not same size, convert
+    switch (componentBytes) {
+    case sizeof(uint32_t):
+        CopyFaceIndex_Draco<uint32_t>(*decodedIndexBuffer, dracoMesh);
+        break;
+    case sizeof(uint16_t):
+        CopyFaceIndex_Draco<uint16_t>(*decodedIndexBuffer, dracoMesh);
+        break;
+    case sizeof(uint8_t):
+        CopyFaceIndex_Draco<uint8_t>(*decodedIndexBuffer, dracoMesh);
+        break;
+    default:
+        ai_assert(false);
+        break;
+    }
+
+    // Assign this alternate data buffer to the accessor
+    prim.indices->decodedBuffer.swap(decodedIndexBuffer);
+}
+
+template <typename T>
+static bool GetAttributeForAllPoints_Draco(const draco::Mesh &dracoMesh,
+        const draco::PointAttribute &dracoAttribute,
+        Buffer &outBuffer) {
+    size_t byteOffset = 0;
+    T values[4] = { 0, 0, 0, 0 };
+    for (draco::PointIndex i(0); i < dracoMesh.num_points(); ++i) {
+        const draco::AttributeValueIndex val_index = dracoAttribute.mapped_index(i);
+        if (!dracoAttribute.ConvertValue<T>(val_index, dracoAttribute.num_components(), values)) {
+            return false;
+        }
+
+        memcpy(outBuffer.GetPointer() + byteOffset, &values[0], sizeof(T) * dracoAttribute.num_components());
+        byteOffset += sizeof(T) * dracoAttribute.num_components();
+    }
+
+    return true;
+}
+
+inline void SetDecodedAttributeBuffer_Draco(const draco::Mesh &dracoMesh, uint32_t dracoAttribId, Accessor &accessor) {
+    // Create decoded buffer
+    const draco::PointAttribute *pDracoAttribute = dracoMesh.GetAttributeByUniqueId(dracoAttribId);
+    if (pDracoAttribute == nullptr) {
+        throw DeadlyImportError("GLTF: Invalid draco attribute id: ", dracoAttribId);
+    }
+
+    size_t componentBytes = accessor.GetBytesPerComponent();
+
+    std::unique_ptr<Buffer> decodedAttribBuffer(new Buffer());
+    decodedAttribBuffer->Grow(dracoMesh.num_points() * pDracoAttribute->num_components() * componentBytes);
+
+    switch (accessor.componentType) {
+    case ComponentType_BYTE:
+        GetAttributeForAllPoints_Draco<int8_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer);
+        break;
+    case ComponentType_UNSIGNED_BYTE:
+        GetAttributeForAllPoints_Draco<uint8_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer);
+        break;
+    case ComponentType_SHORT:
+        GetAttributeForAllPoints_Draco<int16_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer);
+        break;
+    case ComponentType_UNSIGNED_SHORT:
+        GetAttributeForAllPoints_Draco<uint16_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer);
+        break;
+    case ComponentType_UNSIGNED_INT:
+        GetAttributeForAllPoints_Draco<uint32_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer);
+        break;
+    case ComponentType_FLOAT:
+        GetAttributeForAllPoints_Draco<float>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer);
+        break;
+    default:
+        ai_assert(false);
+        break;
+    }
+
+    // Assign this alternate data buffer to the accessor
+    accessor.decodedBuffer.swap(decodedAttribBuffer);
+}
+
+#endif // ASSIMP_ENABLE_DRACO
+
+//
+// LazyDict methods
+//
+
+template <class T>
+inline LazyDict<T>::LazyDict(Asset &asset, const char *dictId, const char *extId) :
+        mDictId(dictId),
+        mExtId(extId),
+        mDict(0),
+        mAsset(asset) {
+    asset.mDicts.push_back(this); // register to the list of dictionaries
+}
+
+template <class T>
+inline LazyDict<T>::~LazyDict() {
+    for (size_t i = 0; i < mObjs.size(); ++i) {
+        delete mObjs[i];
+    }
+}
+
+template <class T>
+inline void LazyDict<T>::AttachToDocument(Document &doc) {
+    Value *container = nullptr;
+    const char *context = nullptr;
+
+    if (mExtId) {
+        if (Value *exts = FindObject(doc, "extensions")) {
+            container = FindObjectInContext(*exts, mExtId, "extensions");
+            context = mExtId;
+        }
+    } else {
+        container = &doc;
+        context = "the document";
+    }
+
+    if (container) {
+        mDict = FindArrayInContext(*container, mDictId, context);
+    }
+}
+
+template <class T>
+inline void LazyDict<T>::DetachFromDocument() {
+    mDict = nullptr;
+}
+
+template <class T>
+unsigned int LazyDict<T>::Remove(const char *id) {
+    id = T::TranslateId(mAsset, id);
+
+    typename IdDict::iterator objIt = mObjsById.find(id);
+
+    if (objIt == mObjsById.end()) {
+        throw DeadlyExportError("GLTF: Object with id \"" + std::string(id) + "\" is not found");
+    }
+
+    const unsigned int index = objIt->second;
+
+    mAsset.mUsedIds[id] = false;
+    mObjsById.erase(id);
+    mObjsByOIndex.erase(index);
+    delete mObjs[index];
+    mObjs.erase(mObjs.begin() + index);
+
+    //update index of object in mObjs;
+    for (unsigned int i = index; i < mObjs.size(); ++i) {
+        T *obj = mObjs[i];
+
+        obj->index = i;
+    }
+
+    for (IdDict::iterator it = mObjsById.begin(); it != mObjsById.end(); ++it) {
+        if (it->second <= index) {
+            continue;
+        }
+
+        mObjsById[it->first] = it->second - 1;
+    }
+
+    for (Dict::iterator it = mObjsByOIndex.begin(); it != mObjsByOIndex.end(); ++it) {
+        if (it->second <= index) {
+            continue;
+        }
+
+        mObjsByOIndex[it->first] = it->second - 1;
+    }
+
+    return index;
+}
+
+template <class T>
+Ref<T> LazyDict<T>::Retrieve(unsigned int i) {
+
+    typename Dict::iterator it = mObjsByOIndex.find(i);
+    if (it != mObjsByOIndex.end()) { // already created?
+        return Ref<T>(mObjs, it->second);
+    }
+
+    // read it from the JSON object
+    if (!mDict) {
+        throw DeadlyImportError("GLTF: Missing section \"", mDictId, "\"");
+    }
+
+    if (!mDict->IsArray()) {
+        throw DeadlyImportError("GLTF: Field \"", mDictId, "\"  is not an array");
+    }
+
+    if (i >= mDict->Size()) {
+        throw DeadlyImportError("GLTF: Array index ", i, " is out of bounds (", mDict->Size(), ") for \"", mDictId, "\"");
+    }
+
+    Value &obj = (*mDict)[i];
+
+    if (!obj.IsObject()) {
+        throw DeadlyImportError("GLTF: Object at index ", i, " in array \"", mDictId, "\" is not a JSON object");
+    }
+
+    if (mRecursiveReferenceCheck.find(i) != mRecursiveReferenceCheck.end()) {
+        throw DeadlyImportError("GLTF: Object at index ", i, " in array \"", mDictId, "\" has recursive reference to itself");
+    }
+    mRecursiveReferenceCheck.insert(i);
+
+    // Unique ptr prevents memory leak in case of Read throws an exception
+    auto inst = std::unique_ptr<T>(new T());
+    // Try to make this human readable so it can be used in error messages.
+    inst->id = std::string(mDictId) + "[" + ai_to_string(i) + "]";
+    inst->oIndex = i;
+    ReadMember(obj, "name", inst->name);
+    inst->Read(obj, mAsset);
+    inst->ReadExtensions(obj);
+    inst->ReadExtras(obj);
+
+    Ref<T> result = Add(inst.release());
+    mRecursiveReferenceCheck.erase(i);
+    return result;
+}
+
+template <class T>
+Ref<T> LazyDict<T>::Get(unsigned int i) {
+    return Ref<T>(mObjs, i);
+}
+
+template <class T>
+Ref<T> LazyDict<T>::Get(const char *id) {
+    id = T::TranslateId(mAsset, id);
+
+    typename IdDict::iterator it = mObjsById.find(id);
+    if (it != mObjsById.end()) { // already created?
+        return Ref<T>(mObjs, it->second);
+    }
+
+    return Ref<T>();
+}
+
+template <class T>
+Ref<T> LazyDict<T>::Add(T *obj) {
+    unsigned int idx = unsigned(mObjs.size());
+    mObjs.push_back(obj);
+    mObjsByOIndex[obj->oIndex] = idx;
+    mObjsById[obj->id] = idx;
+    mAsset.mUsedIds[obj->id] = true;
+    return Ref<T>(mObjs, idx);
+}
+
+template <class T>
+Ref<T> LazyDict<T>::Create(const char *id) {
+    Asset::IdMap::iterator it = mAsset.mUsedIds.find(id);
+    if (it != mAsset.mUsedIds.end()) {
+        throw DeadlyImportError("GLTF: two objects with the same ID exist");
+    }
+    T *inst = new T();
+    unsigned int idx = unsigned(mObjs.size());
+    inst->id = id;
+    inst->index = idx;
+    inst->oIndex = idx;
+    return Add(inst);
+}
+
+//
+// glTF dictionary objects methods
+//
+inline Buffer::Buffer() :
+        byteLength(0),
+        type(Type_arraybuffer),
+        EncodedRegion_Current(nullptr),
+        mIsSpecial(false) {}
+
+inline Buffer::~Buffer() {
+    for (SEncodedRegion *reg : EncodedRegion_List)
+        delete reg;
+}
+
+inline const char *Buffer::TranslateId(Asset & /*r*/, const char *id) {
+    return id;
+}
+
+inline void Buffer::Read(Value &obj, Asset &r) {
+    size_t statedLength = MemberOrDefault<size_t>(obj, "byteLength", 0);
+    byteLength = statedLength;
+
+    Value *it = FindString(obj, "uri");
+    if (!it) {
+        if (statedLength > 0) {
+            throw DeadlyImportError("GLTF: buffer with non-zero length missing the \"uri\" attribute");
+        }
+        return;
+    }
+
+    const char *uri = it->GetString();
+
+    glTFCommon::Util::DataURI dataURI;
+    if (ParseDataURI(uri, it->GetStringLength(), dataURI)) {
+        if (dataURI.base64) {
+            uint8_t *data = nullptr;
+            this->byteLength = Base64::Decode(dataURI.data, dataURI.dataLength, data);
+            this->mData.reset(data, std::default_delete<uint8_t[]>());
+
+            if (statedLength > 0 && this->byteLength != statedLength) {
+                throw DeadlyImportError("GLTF: buffer \"", id, "\", expected ", ai_to_string(statedLength),
+                        " bytes, but found ", ai_to_string(dataURI.dataLength));
+            }
+        } else { // assume raw data
+            if (statedLength != dataURI.dataLength) {
+                throw DeadlyImportError("GLTF: buffer \"", id, "\", expected ", ai_to_string(statedLength),
+                        " bytes, but found ", ai_to_string(dataURI.dataLength));
+            }
+
+            this->mData.reset(new uint8_t[dataURI.dataLength], std::default_delete<uint8_t[]>());
+            memcpy(this->mData.get(), dataURI.data, dataURI.dataLength);
+        }
+    } else { // Local file
+        if (byteLength > 0) {
+            std::string dir = !r.mCurrentAssetDir.empty() ? (r.mCurrentAssetDir.back() == '/' ? r.mCurrentAssetDir : r.mCurrentAssetDir + '/') : "";
+
+            IOStream *file = r.OpenFile(dir + uri, "rb");
+            if (file) {
+                bool ok = LoadFromStream(*file, byteLength);
+                delete file;
+
+                if (!ok)
+                    throw DeadlyImportError("GLTF: error while reading referenced file \"", uri, "\"");
+            } else {
+                throw DeadlyImportError("GLTF: could not open referenced file \"", uri, "\"");
+            }
+        }
+    }
+}
+
+inline bool Buffer::LoadFromStream(IOStream &stream, size_t length, size_t baseOffset) {
+    byteLength = length ? length : stream.FileSize();
+
+    if (byteLength > stream.FileSize()) {
+        throw DeadlyImportError("GLTF: Invalid byteLength exceeds size of actual data.");
+    }
+
+    if (baseOffset) {
+        stream.Seek(baseOffset, aiOrigin_SET);
+    }
+
+    mData.reset(new uint8_t[byteLength], std::default_delete<uint8_t[]>());
+
+    if (stream.Read(mData.get(), byteLength, 1) != 1) {
+        return false;
+    }
+    return true;
+}
+
+inline void Buffer::EncodedRegion_Mark(const size_t pOffset, const size_t pEncodedData_Length, uint8_t *pDecodedData, const size_t pDecodedData_Length, const std::string &pID) {
+    // Check pointer to data
+    if (pDecodedData == nullptr) throw DeadlyImportError("GLTF: for marking encoded region pointer to decoded data must be provided.");
+
+    // Check offset
+    if (pOffset > byteLength) {
+        const uint8_t val_size = 32;
+
+        char val[val_size];
+
+        ai_snprintf(val, val_size, AI_SIZEFMT, pOffset);
+        throw DeadlyImportError("GLTF: incorrect offset value (", val, ") for marking encoded region.");
+    }
+
+    // Check length
+    if ((pOffset + pEncodedData_Length) > byteLength) {
+        const uint8_t val_size = 64;
+
+        char val[val_size];
+
+        ai_snprintf(val, val_size, AI_SIZEFMT "/" AI_SIZEFMT, pOffset, pEncodedData_Length);
+        throw DeadlyImportError("GLTF: encoded region with offset/length (", val, ") is out of range.");
+    }
+
+    // Add new region
+    EncodedRegion_List.push_back(new SEncodedRegion(pOffset, pEncodedData_Length, pDecodedData, pDecodedData_Length, pID));
+    // And set new value for "byteLength"
+    byteLength += (pDecodedData_Length - pEncodedData_Length);
+}
+
+inline void Buffer::EncodedRegion_SetCurrent(const std::string &pID) {
+    if ((EncodedRegion_Current != nullptr) && (EncodedRegion_Current->ID == pID)) {
+        return;
+    }
+
+    for (SEncodedRegion *reg : EncodedRegion_List) {
+        if (reg->ID == pID) {
+            EncodedRegion_Current = reg;
+            return;
+        }
+    }
+
+    throw DeadlyImportError("GLTF: EncodedRegion with ID: \"", pID, "\" not found.");
+}
+
+inline bool Buffer::ReplaceData(const size_t pBufferData_Offset, const size_t pBufferData_Count, const uint8_t *pReplace_Data, const size_t pReplace_Count) {
+
+    if ((pBufferData_Count == 0) || (pReplace_Count == 0) || (pReplace_Data == nullptr)) {
+        return false;
+    }
+
+    const size_t new_data_size = byteLength + pReplace_Count - pBufferData_Count;
+    uint8_t *new_data = new uint8_t[new_data_size];
+    // Copy data which place before replacing part.
+    ::memcpy(new_data, mData.get(), pBufferData_Offset);
+    // Copy new data.
+    ::memcpy(&new_data[pBufferData_Offset], pReplace_Data, pReplace_Count);
+    // Copy data which place after replacing part.
+    ::memcpy(&new_data[pBufferData_Offset + pReplace_Count], &mData.get()[pBufferData_Offset + pBufferData_Count], pBufferData_Offset);
+    // Apply new data
+    mData.reset(new_data, std::default_delete<uint8_t[]>());
+    byteLength = new_data_size;
+
+    return true;
+}
+
+inline bool Buffer::ReplaceData_joint(const size_t pBufferData_Offset, const size_t pBufferData_Count, const uint8_t *pReplace_Data, const size_t pReplace_Count) {
+    if ((pBufferData_Count == 0) || (pReplace_Count == 0) || (pReplace_Data == nullptr)) {
+        return false;
+    }
+
+    const size_t new_data_size = byteLength + pReplace_Count - pBufferData_Count;
+    uint8_t *new_data = new uint8_t[new_data_size];
+    // Copy data which place before replacing part.
+    memcpy(new_data, mData.get(), pBufferData_Offset);
+    // Copy new data.
+    memcpy(&new_data[pBufferData_Offset], pReplace_Data, pReplace_Count);
+    // Copy data which place after replacing part.
+    memcpy(&new_data[pBufferData_Offset + pReplace_Count], &mData.get()[pBufferData_Offset + pBufferData_Count], new_data_size - (pBufferData_Offset + pReplace_Count));
+    // Apply new data
+    mData.reset(new_data, std::default_delete<uint8_t[]>());
+    byteLength = new_data_size;
+
+    return true;
+}
+
+inline size_t Buffer::AppendData(uint8_t *data, size_t length) {
+    const size_t offset = this->byteLength;
+
+    // Force alignment to 4 bits
+    const size_t paddedLength = (length + 3) & ~3;
+    Grow(paddedLength);
+    memcpy(mData.get() + offset, data, length);
+    memset(mData.get() + offset + length, 0, paddedLength - length);
+    return offset;
+}
+
+inline void Buffer::Grow(size_t amount) {
+    if (amount <= 0) {
+        return;
+    }
+
+    // Capacity is big enough
+    if (capacity >= byteLength + amount) {
+        byteLength += amount;
+        return;
+    }
+
+    // Just allocate data which we need
+    capacity = byteLength + amount;
+
+    uint8_t *b = new uint8_t[capacity];
+    if (nullptr != mData) {
+        memcpy(b, mData.get(), byteLength);
+    }
+    mData.reset(b, std::default_delete<uint8_t[]>());
+    byteLength += amount;
+}
+
+//
+// struct BufferView
+//
+inline void BufferView::Read(Value &obj, Asset &r) {
+    if (Value *bufferVal = FindUInt(obj, "buffer")) {
+        buffer = r.buffers.Retrieve(bufferVal->GetUint());
+    }
+
+    if (!buffer) {
+        throw DeadlyImportError("GLTF: Buffer view without valid buffer.");
+    }
+
+    byteOffset = MemberOrDefault(obj, "byteOffset", size_t(0));
+    byteLength = MemberOrDefault(obj, "byteLength", size_t(0));
+    byteStride = MemberOrDefault(obj, "byteStride", 0u);
+
+    // Check length
+    if ((byteOffset + byteLength) > buffer->byteLength) {
+        throw DeadlyImportError("GLTF: Buffer view with offset/length (", byteOffset, "/", byteLength, ") is out of range.");
+    }
+}
+
+inline uint8_t *BufferView::GetPointer(size_t accOffset) {
+    if (!buffer) {
+        return nullptr;
+    }
+    uint8_t *basePtr = buffer->GetPointer();
+    if (!basePtr) {
+        return nullptr;
+    }
+
+    size_t offset = accOffset + byteOffset;
+    if (buffer->EncodedRegion_Current != nullptr) {
+        const size_t begin = buffer->EncodedRegion_Current->Offset;
+        const size_t end = begin + buffer->EncodedRegion_Current->DecodedData_Length;
+        if ((offset >= begin) && (offset < end)) {
+            return &buffer->EncodedRegion_Current->DecodedData[offset - begin];
+        }
+    }
+
+    return basePtr + offset;
+}
+
+//
+// struct Accessor
+//
+inline void Accessor::Sparse::PopulateData(size_t numBytes, uint8_t *bytes) {
+    if (bytes) {
+        data.assign(bytes, bytes + numBytes);
+    } else {
+        data.resize(numBytes, 0x00);
+    }
+}
+
+inline void Accessor::Sparse::PatchData(unsigned int elementSize) {
+    uint8_t *pIndices = indices->GetPointer(indicesByteOffset);
+    const unsigned int indexSize = int(ComponentTypeSize(indicesType));
+    uint8_t *indicesEnd = pIndices + count * indexSize;
+
+    uint8_t *pValues = values->GetPointer(valuesByteOffset);
+    while (pIndices != indicesEnd) {
+        size_t offset;
+        switch (indicesType) {
+        case ComponentType_UNSIGNED_BYTE:
+            offset = *pIndices;
+            break;
+        case ComponentType_UNSIGNED_SHORT:
+            offset = *reinterpret_cast<uint16_t *>(pIndices);
+            break;
+        case ComponentType_UNSIGNED_INT:
+            offset = *reinterpret_cast<uint32_t *>(pIndices);
+            break;
+        default:
+            // have fun with float and negative values from signed types as indices.
+            throw DeadlyImportError("Unsupported component type in index.");
+        }
+
+        offset *= elementSize;
+
+        if (offset + elementSize > data.size()) {
+            throw DeadlyImportError("Invalid sparse accessor. Byte offset for patching points outside allocated memory.");
+        }
+
+        std::memcpy(data.data() + offset, pValues, elementSize);
+
+        pValues += elementSize;
+        pIndices += indexSize;
+    }
+}
+
+inline void Accessor::Read(Value &obj, Asset &r) {
+    if (Value *bufferViewVal = FindUInt(obj, "bufferView")) {
+        bufferView = r.bufferViews.Retrieve(bufferViewVal->GetUint());
+    }
+
+    byteOffset = MemberOrDefault(obj, "byteOffset", size_t(0));
+    componentType = MemberOrDefault(obj, "componentType", ComponentType_BYTE);
+    {
+        const Value *countValue = FindUInt(obj, "count");
+        if (!countValue) {
+            throw DeadlyImportError("A count value is required, when reading ", id.c_str(), name.empty() ? "" : " (" + name + ")");
+        }
+        count = countValue->GetUint();
+    }
+
+    const char *typestr;
+    type = ReadMember(obj, "type", typestr) ? AttribType::FromString(typestr) : AttribType::SCALAR;
+
+    if (bufferView) {
+        // Check length
+        unsigned long long byteLength = (unsigned long long)GetBytesPerComponent() * (unsigned long long)count;
+
+        // handle integer overflow
+        if (byteLength < count) {
+            throw DeadlyImportError("GLTF: Accessor with offset/count (", byteOffset, "/", count, ") is out of range.");
+        }
+
+        if ((byteOffset + byteLength) > bufferView->byteLength || (bufferView->byteOffset + byteOffset + byteLength) > bufferView->buffer->byteLength) {
+            throw DeadlyImportError("GLTF: Accessor with offset/length (", byteOffset, "/", byteLength, ") is out of range.");
+        }
+    }
+
+    if (Value *sparseValue = FindObject(obj, "sparse")) {
+        sparse.reset(new Sparse);
+        // count
+        ReadMember(*sparseValue, "count", sparse->count);
+
+        // indices
+        if (Value *indicesValue = FindObject(*sparseValue, "indices")) {
+            //indices bufferView
+            Value *indiceViewID = FindUInt(*indicesValue, "bufferView");
+            sparse->indices = r.bufferViews.Retrieve(indiceViewID->GetUint());
+            //indices byteOffset
+            sparse->indicesByteOffset = MemberOrDefault(*indicesValue, "byteOffset", size_t(0));
+            //indices componentType
+            sparse->indicesType = MemberOrDefault(*indicesValue, "componentType", ComponentType_BYTE);
+            //sparse->indices->Read(*indicesValue, r);
+        } else {
+            // indicesType
+            sparse->indicesType = MemberOrDefault(*sparseValue, "componentType", ComponentType_UNSIGNED_SHORT);
+        }
+
+        // value
+        if (Value *valuesValue = FindObject(*sparseValue, "values")) {
+            //value bufferView
+            Value *valueViewID = FindUInt(*valuesValue, "bufferView");
+            sparse->values = r.bufferViews.Retrieve(valueViewID->GetUint());
+            //value byteOffset
+            sparse->valuesByteOffset = MemberOrDefault(*valuesValue, "byteOffset", size_t(0));
+            //sparse->values->Read(*valuesValue, r);
+        }
+
+
+        const unsigned int elementSize = GetElementSize();
+        const size_t dataSize = count * elementSize;
+        sparse->PopulateData(dataSize, bufferView ? bufferView->GetPointer(byteOffset) : 0);
+        sparse->PatchData(elementSize);
+    }
+}
+
+inline unsigned int Accessor::GetNumComponents() {
+    return AttribType::GetNumComponents(type);
+}
+
+inline unsigned int Accessor::GetBytesPerComponent() {
+    return int(ComponentTypeSize(componentType));
+}
+
+inline unsigned int Accessor::GetElementSize() {
+    return GetNumComponents() * GetBytesPerComponent();
+}
+
+inline uint8_t *Accessor::GetPointer() {
+    if (decodedBuffer)
+        return decodedBuffer->GetPointer();
+
+    if (sparse)
+        return sparse->data.data();
+
+    if (!bufferView || !bufferView->buffer) return nullptr;
+    uint8_t *basePtr = bufferView->buffer->GetPointer();
+    if (!basePtr) return nullptr;
+
+    size_t offset = byteOffset + bufferView->byteOffset;
+
+    // Check if region is encoded.
+    if (bufferView->buffer->EncodedRegion_Current != nullptr) {
+        const size_t begin = bufferView->buffer->EncodedRegion_Current->Offset;
+        const size_t end = begin + bufferView->buffer->EncodedRegion_Current->DecodedData_Length;
+
+        if ((offset >= begin) && (offset < end))
+            return &bufferView->buffer->EncodedRegion_Current->DecodedData[offset - begin];
+    }
+
+    return basePtr + offset;
+}
+
+inline size_t Accessor::GetStride() {
+    // Decoded buffer is always packed
+    if (decodedBuffer)
+        return GetElementSize();
+
+    // Sparse and normal bufferView
+    return (bufferView && bufferView->byteStride ? bufferView->byteStride : GetElementSize());
+}
+
+inline size_t Accessor::GetMaxByteSize() {
+    if (decodedBuffer)
+        return decodedBuffer->byteLength;
+
+    return (bufferView ? bufferView->byteLength : sparse->data.size());
+}
+
+template <class T>
+void Accessor::ExtractData(T *&outData) {
+    uint8_t *data = GetPointer();
+    if (!data) {
+        throw DeadlyImportError("GLTF2: data is null when extracting data from ", getContextForErrorMessages(id, name));
+    }
+
+    const size_t elemSize = GetElementSize();
+    const size_t totalSize = elemSize * count;
+
+    const size_t stride = GetStride();
+
+    const size_t targetElemSize = sizeof(T);
+
+    if (elemSize > targetElemSize) {
+        throw DeadlyImportError("GLTF: elemSize ", elemSize, " > targetElemSize ", targetElemSize, " in ", getContextForErrorMessages(id, name));
+    }
+
+    const size_t maxSize = GetMaxByteSize();
+    if (count * stride > maxSize) {
+        throw DeadlyImportError("GLTF: count*stride ", (count * stride), " > maxSize ", maxSize, " in ", getContextForErrorMessages(id, name));
+    }
+
+    outData = new T[count];
+    if (stride == elemSize && targetElemSize == elemSize) {
+        memcpy(outData, data, totalSize);
+    } else {
+        for (size_t i = 0; i < count; ++i) {
+            memcpy(outData + i, data + i * stride, elemSize);
+        }
+    }
+}
+
+inline void Accessor::WriteData(size_t _count, const void *src_buffer, size_t src_stride) {
+    uint8_t *buffer_ptr = bufferView->buffer->GetPointer();
+    size_t offset = byteOffset + bufferView->byteOffset;
+
+    size_t dst_stride = GetNumComponents() * GetBytesPerComponent();
+
+    const uint8_t *src = reinterpret_cast<const uint8_t *>(src_buffer);
+    uint8_t *dst = reinterpret_cast<uint8_t *>(buffer_ptr + offset);
+
+    ai_assert(dst + _count * dst_stride <= buffer_ptr + bufferView->buffer->byteLength);
+    CopyData(_count, src, src_stride, dst, dst_stride);
+}
+
+inline void Accessor::WriteSparseValues(size_t _count, const void *src_data, size_t src_dataStride) {
+    if (!sparse)
+        return;
+
+    // values
+    uint8_t *value_buffer_ptr = sparse->values->buffer->GetPointer();
+    size_t value_offset = sparse->valuesByteOffset + sparse->values->byteOffset;
+    size_t value_dst_stride = GetNumComponents() * GetBytesPerComponent();
+    const uint8_t *value_src = reinterpret_cast<const uint8_t *>(src_data);
+    uint8_t *value_dst = reinterpret_cast<uint8_t *>(value_buffer_ptr + value_offset);
+    ai_assert(value_dst + _count * value_dst_stride <= value_buffer_ptr + sparse->values->buffer->byteLength);
+    CopyData(_count, value_src, src_dataStride, value_dst, value_dst_stride);
+}
+
+inline void Accessor::WriteSparseIndices(size_t _count, const void *src_idx, size_t src_idxStride) {
+    if (!sparse)
+        return;
+
+    // indices
+    uint8_t *indices_buffer_ptr = sparse->indices->buffer->GetPointer();
+    size_t indices_offset = sparse->indicesByteOffset + sparse->indices->byteOffset;
+    size_t indices_dst_stride = 1 * sizeof(unsigned short);
+    const uint8_t *indices_src = reinterpret_cast<const uint8_t *>(src_idx);
+    uint8_t *indices_dst = reinterpret_cast<uint8_t *>(indices_buffer_ptr + indices_offset);
+    ai_assert(indices_dst + _count * indices_dst_stride <= indices_buffer_ptr + sparse->indices->buffer->byteLength);
+    CopyData(_count, indices_src, src_idxStride, indices_dst, indices_dst_stride);
+}
+
+inline Accessor::Indexer::Indexer(Accessor &acc) :
+    accessor(acc),
+    data(acc.GetPointer()),
+    elemSize(acc.GetElementSize()),
+    stride(acc.GetStride()) {
+}
+
+//! Accesses the i-th value as defined by the accessor
+template <class T>
+T Accessor::Indexer::GetValue(int i) {
+    ai_assert(data);
+    if (i * stride >= accessor.GetMaxByteSize()) {
+        throw DeadlyImportError("GLTF: Invalid index ", i, ", count out of range for buffer with stride ", stride, " and size ", accessor.GetMaxByteSize(), ".");
+    }
+    // Ensure that the memcpy doesn't overwrite the local.
+    const size_t sizeToCopy = std::min(elemSize, sizeof(T));
+    T value = T();
+    // Assume platform endianness matches GLTF binary data (which is little-endian).
+    memcpy(&value, data + i * stride, sizeToCopy);
+    return value;
+}
+
+inline Image::Image() :
+        width(0),
+        height(0),
+        mDataLength(0) {
+}
+
+inline void Image::Read(Value &obj, Asset &r) {
+    //basisu: no need to handle .ktx2, .basis, load as is
+    if (!mDataLength) {
+        Value *curUri = FindString(obj, "uri");
+        if (nullptr != curUri) {
+            const char *uristr = curUri->GetString();
+
+            glTFCommon::Util::DataURI dataURI;
+            if (ParseDataURI(uristr, curUri->GetStringLength(), dataURI)) {
+                mimeType = dataURI.mediaType;
+                if (dataURI.base64) {
+                    uint8_t *ptr = nullptr;
+                    mDataLength = Base64::Decode(dataURI.data, dataURI.dataLength, ptr);
+                    mData.reset(ptr);
+                }
+            } else {
+                this->uri = uristr;
+            }
+        } else if (Value *bufferViewVal = FindUInt(obj, "bufferView")) {
+            this->bufferView = r.bufferViews.Retrieve(bufferViewVal->GetUint());
+            if (Value *mtype = FindString(obj, "mimeType")) {
+                this->mimeType = mtype->GetString();
+            }
+            if (!this->bufferView || this->mimeType.empty()) {
+                throw DeadlyImportError("GLTF2: ", getContextForErrorMessages(id, name), " does not have a URI, so it must have a valid bufferView and mimetype");
+            }
+
+            Ref<Buffer> buffer = this->bufferView->buffer;
+
+            this->mDataLength = this->bufferView->byteLength;
+            // maybe this memcpy could be avoided if aiTexture does not delete[] pcData at destruction.
+
+            this->mData.reset(new uint8_t[this->mDataLength]);
+            memcpy(this->mData.get(), buffer->GetPointer() + this->bufferView->byteOffset, this->mDataLength);
+        } else {
+            throw DeadlyImportError("GLTF2: ", getContextForErrorMessages(id, name), " should have either a URI of a bufferView and mimetype");
+        }
+    }
+}
+
+inline uint8_t *Image::StealData() {
+    mDataLength = 0;
+    return mData.release();
+}
+
+// Never take over the ownership of data whenever binary or not
+inline void Image::SetData(uint8_t *data, size_t length, Asset &r) {
+    Ref<Buffer> b = r.GetBodyBuffer();
+    if (b) { // binary file: append to body
+        std::string bvId = r.FindUniqueID(this->id, "imgdata");
+        bufferView = r.bufferViews.Create(bvId);
+
+        bufferView->buffer = b;
+        bufferView->byteLength = length;
+        bufferView->byteOffset = b->AppendData(data, length);
+    } else { // text file: will be stored as a data uri
+        uint8_t *temp = new uint8_t[length];
+        memcpy(temp, data, length);
+        this->mData.reset(temp);
+        this->mDataLength = length;
+    }
+}
+
+inline void Sampler::Read(Value &obj, Asset & /*r*/) {
+    SetDefaults();
+
+    ReadMember(obj, "name", name);
+    ReadMember(obj, "magFilter", magFilter);
+    ReadMember(obj, "minFilter", minFilter);
+    ReadMember(obj, "wrapS", wrapS);
+    ReadMember(obj, "wrapT", wrapT);
+}
+
+inline void Sampler::SetDefaults() {
+    //only wrapping modes have defaults
+    wrapS = SamplerWrap::Repeat;
+    wrapT = SamplerWrap::Repeat;
+    magFilter = SamplerMagFilter::UNSET;
+    minFilter = SamplerMinFilter::UNSET;
+}
+
+inline void Texture::Read(Value &obj, Asset &r) {
+    if (Value *sourceVal = FindUInt(obj, "source")) {
+        source = r.images.Retrieve(sourceVal->GetUint());
+    }
+
+    if (Value *samplerVal = FindUInt(obj, "sampler")) {
+        sampler = r.samplers.Retrieve(samplerVal->GetUint());
+    }
+}
+
+void Material::SetTextureProperties(Asset &r, Value *prop, TextureInfo &out) {
+    if (r.extensionsUsed.KHR_texture_transform) {
+        if (Value *pKHR_texture_transform = FindExtension(*prop, "KHR_texture_transform")) {
+            out.textureTransformSupported = true;
+            if (Value *array = FindArray(*pKHR_texture_transform, "offset")) {
+                out.TextureTransformExt_t.offset[0] = (*array)[0].GetFloat();
+                out.TextureTransformExt_t.offset[1] = (*array)[1].GetFloat();
+            } else {
+                out.TextureTransformExt_t.offset[0] = 0;
+                out.TextureTransformExt_t.offset[1] = 0;
+            }
+
+            if (!ReadMember(*pKHR_texture_transform, "rotation", out.TextureTransformExt_t.rotation)) {
+                out.TextureTransformExt_t.rotation = 0;
+            }
+
+            if (Value *array = FindArray(*pKHR_texture_transform, "scale")) {
+                out.TextureTransformExt_t.scale[0] = (*array)[0].GetFloat();
+                out.TextureTransformExt_t.scale[1] = (*array)[1].GetFloat();
+            } else {
+                out.TextureTransformExt_t.scale[0] = 1;
+                out.TextureTransformExt_t.scale[1] = 1;
+            }
+        }
+    }
+
+    if (Value *indexProp = FindUInt(*prop, "index")) {
+        out.texture = r.textures.Retrieve(indexProp->GetUint());
+    }
+
+    if (Value *texcoord = FindUInt(*prop, "texCoord")) {
+        out.texCoord = texcoord->GetUint();
+    }
+}
+
+inline void Material::ReadTextureProperty(Asset &r, Value &vals, const char *propName, TextureInfo &out) {
+    if (Value *prop = FindMember(vals, propName)) {
+        SetTextureProperties(r, prop, out);
+    }
+}
+
+inline void Material::ReadTextureProperty(Asset &r, Value &vals, const char *propName, NormalTextureInfo &out) {
+    if (Value *prop = FindMember(vals, propName)) {
+        SetTextureProperties(r, prop, out);
+
+        if (Value *scale = FindNumber(*prop, "scale")) {
+            out.scale = static_cast<float>(scale->GetDouble());
+        }
+    }
+}
+
+inline void Material::ReadTextureProperty(Asset &r, Value &vals, const char *propName, OcclusionTextureInfo &out) {
+    if (Value *prop = FindMember(vals, propName)) {
+        SetTextureProperties(r, prop, out);
+
+        if (Value *strength = FindNumber(*prop, "strength")) {
+            out.strength = static_cast<float>(strength->GetDouble());
+        }
+    }
+}
+
+inline void Material::Read(Value &material, Asset &r) {
+    SetDefaults();
+
+    if (Value *curPbrMetallicRoughness = FindObject(material, "pbrMetallicRoughness")) {
+        ReadMember(*curPbrMetallicRoughness, "baseColorFactor", this->pbrMetallicRoughness.baseColorFactor);
+        ReadTextureProperty(r, *curPbrMetallicRoughness, "baseColorTexture", this->pbrMetallicRoughness.baseColorTexture);
+        ReadTextureProperty(r, *curPbrMetallicRoughness, "metallicRoughnessTexture", this->pbrMetallicRoughness.metallicRoughnessTexture);
+        ReadMember(*curPbrMetallicRoughness, "metallicFactor", this->pbrMetallicRoughness.metallicFactor);
+        ReadMember(*curPbrMetallicRoughness, "roughnessFactor", this->pbrMetallicRoughness.roughnessFactor);
+    }
+
+    ReadTextureProperty(r, material, "normalTexture", this->normalTexture);
+    ReadTextureProperty(r, material, "occlusionTexture", this->occlusionTexture);
+    ReadTextureProperty(r, material, "emissiveTexture", this->emissiveTexture);
+    ReadMember(material, "emissiveFactor", this->emissiveFactor);
+
+    ReadMember(material, "doubleSided", this->doubleSided);
+    ReadMember(material, "alphaMode", this->alphaMode);
+    ReadMember(material, "alphaCutoff", this->alphaCutoff);
+
+    if (Value *extensions = FindObject(material, "extensions")) {
+        if (r.extensionsUsed.KHR_materials_pbrSpecularGlossiness) {
+            if (Value *curPbrSpecularGlossiness = FindObject(*extensions, "KHR_materials_pbrSpecularGlossiness")) {
+                PbrSpecularGlossiness pbrSG;
+
+                ReadMember(*curPbrSpecularGlossiness, "diffuseFactor", pbrSG.diffuseFactor);
+                ReadTextureProperty(r, *curPbrSpecularGlossiness, "diffuseTexture", pbrSG.diffuseTexture);
+                ReadTextureProperty(r, *curPbrSpecularGlossiness, "specularGlossinessTexture", pbrSG.specularGlossinessTexture);
+                ReadMember(*curPbrSpecularGlossiness, "specularFactor", pbrSG.specularFactor);
+                ReadMember(*curPbrSpecularGlossiness, "glossinessFactor", pbrSG.glossinessFactor);
+
+                this->pbrSpecularGlossiness = Nullable<PbrSpecularGlossiness>(pbrSG);
+            }
+        }
+
+        // Extension KHR_texture_transform is handled in ReadTextureProperty
+
+        if (r.extensionsUsed.KHR_materials_sheen) {
+            if (Value *curMaterialSheen = FindObject(*extensions, "KHR_materials_sheen")) {
+                MaterialSheen sheen;
+
+                ReadMember(*curMaterialSheen, "sheenColorFactor", sheen.sheenColorFactor);
+                ReadTextureProperty(r, *curMaterialSheen, "sheenColorTexture", sheen.sheenColorTexture);
+                ReadMember(*curMaterialSheen, "sheenRoughnessFactor", sheen.sheenRoughnessFactor);
+                ReadTextureProperty(r, *curMaterialSheen, "sheenRoughnessTexture", sheen.sheenRoughnessTexture);
+
+                this->materialSheen = Nullable<MaterialSheen>(sheen);
+            }
+        }
+
+        if (r.extensionsUsed.KHR_materials_clearcoat) {
+            if (Value *curMaterialClearcoat = FindObject(*extensions, "KHR_materials_clearcoat")) {
+                MaterialClearcoat clearcoat;
+
+                ReadMember(*curMaterialClearcoat, "clearcoatFactor", clearcoat.clearcoatFactor);
+                ReadTextureProperty(r, *curMaterialClearcoat, "clearcoatTexture", clearcoat.clearcoatTexture);
+                ReadMember(*curMaterialClearcoat, "clearcoatRoughnessFactor", clearcoat.clearcoatRoughnessFactor);
+                ReadTextureProperty(r, *curMaterialClearcoat, "clearcoatRoughnessTexture", clearcoat.clearcoatRoughnessTexture);
+                ReadTextureProperty(r, *curMaterialClearcoat, "clearcoatNormalTexture", clearcoat.clearcoatNormalTexture);
+
+                this->materialClearcoat = Nullable<MaterialClearcoat>(clearcoat);
+            }
+        }
+
+        if (r.extensionsUsed.KHR_materials_transmission) {
+            if (Value *curMaterialTransmission = FindObject(*extensions, "KHR_materials_transmission")) {
+                MaterialTransmission transmission;
+
+                ReadMember(*curMaterialTransmission, "transmissionFactor", transmission.transmissionFactor);
+                ReadTextureProperty(r, *curMaterialTransmission, "transmissionTexture", transmission.transmissionTexture);
+
+                this->materialTransmission = Nullable<MaterialTransmission>(transmission);
+            }
+        }
+
+        if (r.extensionsUsed.KHR_materials_volume) {
+            if (Value *curMaterialVolume = FindObject(*extensions, "KHR_materials_volume")) {
+                MaterialVolume volume;
+
+                ReadMember(*curMaterialVolume, "thicknessFactor", volume.thicknessFactor);
+                ReadTextureProperty(r, *curMaterialVolume, "thicknessTexture", volume.thicknessTexture);
+                ReadMember(*curMaterialVolume, "attenuationDistance", volume.attenuationDistance);
+                ReadMember(*curMaterialVolume, "attenuationColor", volume.attenuationColor);
+
+                this->materialVolume = Nullable<MaterialVolume>(volume);
+            }
+        }
+
+        if (r.extensionsUsed.KHR_materials_ior) {
+            if (Value *curMaterialIOR = FindObject(*extensions, "KHR_materials_ior")) {
+                MaterialIOR ior;
+
+                ReadMember(*curMaterialIOR, "ior", ior.ior);
+
+                this->materialIOR = Nullable<MaterialIOR>(ior);
+            }
+        }
+
+        unlit = nullptr != FindObject(*extensions, "KHR_materials_unlit");
+    }
+}
+
+inline void Material::SetDefaults() {
+    //pbr materials
+    SetVector(pbrMetallicRoughness.baseColorFactor, defaultBaseColor);
+    pbrMetallicRoughness.metallicFactor = 1.0f;
+    pbrMetallicRoughness.roughnessFactor = 1.0f;
+
+    SetVector(emissiveFactor, defaultEmissiveFactor);
+    alphaMode = "OPAQUE";
+    alphaCutoff = 0.5f;
+    doubleSided = false;
+    unlit = false;
+}
+
+inline void PbrSpecularGlossiness::SetDefaults() {
+    //pbrSpecularGlossiness properties
+    SetVector(diffuseFactor, defaultDiffuseFactor);
+    SetVector(specularFactor, defaultSpecularFactor);
+    glossinessFactor = 1.0f;
+}
+
+inline void MaterialSheen::SetDefaults() {
+    //KHR_materials_sheen properties
+    SetVector(sheenColorFactor, defaultSheenFactor);
+    sheenRoughnessFactor = 0.f;
+}
+
+inline void MaterialVolume::SetDefaults() {
+    //KHR_materials_volume properties
+    thicknessFactor = 0.f;
+    attenuationDistance = INFINITY;
+    SetVector(attenuationColor, defaultAttenuationColor);
+}
+
+inline void MaterialIOR::SetDefaults() {
+    //KHR_materials_ior properties
+    ior = 1.5f;
+}
+
+inline void Mesh::Read(Value &pJSON_Object, Asset &pAsset_Root) {
+    Value *curName = FindMember(pJSON_Object, "name");
+    if (nullptr != curName && curName->IsString()) {
+        name = curName->GetString();
+    }
+
+    /****************** Mesh primitives ******************/
+    Value *curPrimitives = FindArray(pJSON_Object, "primitives");
+    if (nullptr != curPrimitives) {
+        this->primitives.resize(curPrimitives->Size());
+        for (unsigned int i = 0; i < curPrimitives->Size(); ++i) {
+            Value &primitive = (*curPrimitives)[i];
+
+            Primitive &prim = this->primitives[i];
+            prim.mode = MemberOrDefault(primitive, "mode", PrimitiveMode_TRIANGLES);
+
+            if (Value *indices = FindUInt(primitive, "indices")) {
+                prim.indices = pAsset_Root.accessors.Retrieve(indices->GetUint());
+            }
+
+            if (Value *material = FindUInt(primitive, "material")) {
+                prim.material = pAsset_Root.materials.Retrieve(material->GetUint());
+            }
+
+            if (Value *attrs = FindObject(primitive, "attributes")) {
+                for (Value::MemberIterator it = attrs->MemberBegin(); it != attrs->MemberEnd(); ++it) {
+                    if (!it->value.IsUint()) continue;
+                    const char *attr = it->name.GetString();
+                    // Valid attribute semantics include POSITION, NORMAL, TANGENT, TEXCOORD, COLOR, JOINT, JOINTMATRIX,
+                    // and WEIGHT.Attribute semantics can be of the form[semantic]_[set_index], e.g., TEXCOORD_0, TEXCOORD_1, etc.
+
+                    int undPos = 0;
+                    Mesh::AccessorList *vec = nullptr;
+                    if (GetAttribVector(prim, attr, vec, undPos)) {
+                        size_t idx = (attr[undPos] == '_') ? atoi(attr + undPos + 1) : 0;
+                        if ((*vec).size() != idx) {
+                            throw DeadlyImportError("GLTF: Invalid attribute in mesh: ", name, " primitive: ", i, "attrib: ", attr,
+                                    ". All indices for indexed attribute semantics must start with 0 and be continuous positive integers: TEXCOORD_0, TEXCOORD_1, etc.");
+                        }
+                        (*vec).resize(idx + 1);
+                        (*vec)[idx] = pAsset_Root.accessors.Retrieve(it->value.GetUint());
+                    }
+                }
+            }
+
+#ifdef ASSIMP_ENABLE_DRACO
+            // KHR_draco_mesh_compression spec: Draco can only be used for glTF Triangles or Triangle Strips
+            if (pAsset_Root.extensionsUsed.KHR_draco_mesh_compression && (prim.mode == PrimitiveMode_TRIANGLES || prim.mode == PrimitiveMode_TRIANGLE_STRIP)) {
+                // Look for draco mesh compression extension and bufferView
+                // Skip if any missing
+                if (Value *dracoExt = FindExtension(primitive, "KHR_draco_mesh_compression")) {
+                    if (Value *bufView = FindUInt(*dracoExt, "bufferView")) {
+                        // Attempt to load indices and attributes using draco compression
+                        auto bufferView = pAsset_Root.bufferViews.Retrieve(bufView->GetUint());
+                        // Attempt to perform the draco decode on the buffer data
+                        const char *bufferViewData = reinterpret_cast<const char *>(bufferView->buffer->GetPointer() + bufferView->byteOffset);
+                        draco::DecoderBuffer decoderBuffer;
+                        decoderBuffer.Init(bufferViewData, bufferView->byteLength);
+                        draco::Decoder decoder;
+                        auto decodeResult = decoder.DecodeMeshFromBuffer(&decoderBuffer);
+                        if (!decodeResult.ok()) {
+                            // A corrupt Draco isn't actually fatal if the primitive data is also provided in a standard buffer, but does anyone do that?
+                            throw DeadlyImportError("GLTF: Invalid Draco mesh compression in mesh: ", name, " primitive: ", i, ": ", decodeResult.status().error_msg_string());
+                        }
+
+                        // Now we have a draco mesh
+                        const std::unique_ptr<draco::Mesh> &pDracoMesh = decodeResult.value();
+
+                        // Redirect the accessors to the decoded data
+
+                        // Indices
+                        SetDecodedIndexBuffer_Draco(*pDracoMesh, prim);
+
+                        // Vertex attributes
+                        if (Value *attrs = FindObject(*dracoExt, "attributes")) {
+                            for (Value::MemberIterator it = attrs->MemberBegin(); it != attrs->MemberEnd(); ++it) {
+                                if (!it->value.IsUint()) continue;
+                                const char *attr = it->name.GetString();
+
+                                int undPos = 0;
+                                Mesh::AccessorList *vec = nullptr;
+                                if (GetAttribVector(prim, attr, vec, undPos)) {
+                                    size_t idx = (attr[undPos] == '_') ? atoi(attr + undPos + 1) : 0;
+                                    if (idx >= (*vec).size()) {
+                                        throw DeadlyImportError("GLTF: Invalid draco attribute in mesh: ", name, " primitive: ", i, " attrib: ", attr,
+                                                ". All indices for indexed attribute semantics must start with 0 and be continuous positive integers: TEXCOORD_0, TEXCOORD_1, etc.");
+                                    }
+
+                                    if (!(*vec)[idx]) {
+                                        throw DeadlyImportError("GLTF: Invalid draco attribute in mesh: ", name, " primitive: ", i, " attrib: ", attr,
+                                                ". All draco-encoded attributes must also define an accessor.");
+                                    }
+
+                                    Accessor &attribAccessor = *(*vec)[idx];
+                                    if (attribAccessor.count == 0)
+                                        throw DeadlyImportError("GLTF: Invalid draco attribute in mesh: ", name, " primitive: ", i, " attrib: ", attr);
+
+                                    // Redirect this accessor to the appropriate Draco vertex attribute data
+                                    const uint32_t dracoAttribId = it->value.GetUint();
+                                    SetDecodedAttributeBuffer_Draco(*pDracoMesh, dracoAttribId, attribAccessor);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+#endif
+
+            Value *targetsArray = FindArray(primitive, "targets");
+            if (nullptr != targetsArray) {
+                prim.targets.resize(targetsArray->Size());
+                for (unsigned int j = 0; j < targetsArray->Size(); ++j) {
+                    Value &target = (*targetsArray)[j];
+                    if (!target.IsObject()) {
+                        continue;
+                    }
+                    for (Value::MemberIterator it = target.MemberBegin(); it != target.MemberEnd(); ++it) {
+                        if (!it->value.IsUint()) {
+                            continue;
+                        }
+                        const char *attr = it->name.GetString();
+                        // Valid attribute semantics include POSITION, NORMAL, TANGENT
+                        int undPos = 0;
+                        Mesh::AccessorList *vec = nullptr;
+                        if (GetAttribTargetVector(prim, j, attr, vec, undPos)) {
+                            size_t idx = (attr[undPos] == '_') ? atoi(attr + undPos + 1) : 0;
+                            if ((*vec).size() <= idx) {
+                                (*vec).resize(idx + 1);
+                            }
+                            (*vec)[idx] = pAsset_Root.accessors.Retrieve(it->value.GetUint());
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    Value *curWeights = FindArray(pJSON_Object, "weights");
+    if (nullptr != curWeights) {
+        this->weights.resize(curWeights->Size());
+        for (unsigned int i = 0; i < curWeights->Size(); ++i) {
+            Value &weightValue = (*curWeights)[i];
+            if (weightValue.IsNumber()) {
+                this->weights[i] = weightValue.GetFloat();
+            }
+        }
+    }
+
+    Value *curExtras = FindObject(pJSON_Object, "extras");
+    if (nullptr != curExtras) {
+        if (Value *curTargetNames = FindArray(*curExtras, "targetNames")) {
+            this->targetNames.resize(curTargetNames->Size());
+            for (unsigned int i = 0; i < curTargetNames->Size(); ++i) {
+                Value &targetNameValue = (*curTargetNames)[i];
+                if (targetNameValue.IsString()) {
+                    this->targetNames[i] = targetNameValue.GetString();
+                }
+            }
+        }
+    }
+}
+
+inline void Camera::Read(Value &obj, Asset & /*r*/) {
+    std::string type_string = std::string(MemberOrDefault(obj, "type", "perspective"));
+    if (type_string == "orthographic") {
+        type = Camera::Orthographic;
+    } else {
+        type = Camera::Perspective;
+    }
+
+    const char *subobjId = (type == Camera::Orthographic) ? "orthographic" : "perspective";
+
+    Value *it = FindObject(obj, subobjId);
+    if (!it) throw DeadlyImportError("GLTF: Camera missing its parameters");
+
+    if (type == Camera::Perspective) {
+        cameraProperties.perspective.aspectRatio = MemberOrDefault(*it, "aspectRatio", 0.f);
+        cameraProperties.perspective.yfov = MemberOrDefault(*it, "yfov", 3.1415f / 2.f);
+        cameraProperties.perspective.zfar = MemberOrDefault(*it, "zfar", 100.f);
+        cameraProperties.perspective.znear = MemberOrDefault(*it, "znear", 0.01f);
+    } else {
+        cameraProperties.ortographic.xmag = MemberOrDefault(*it, "xmag", 1.f);
+        cameraProperties.ortographic.ymag = MemberOrDefault(*it, "ymag", 1.f);
+        cameraProperties.ortographic.zfar = MemberOrDefault(*it, "zfar", 100.f);
+        cameraProperties.ortographic.znear = MemberOrDefault(*it, "znear", 0.01f);
+    }
+}
+
+inline void Light::Read(Value &obj, Asset & /*r*/) {
+#ifndef M_PI
+    const float M_PI = 3.14159265358979323846f;
+#endif
+
+    std::string type_string;
+    ReadMember(obj, "type", type_string);
+    if (type_string == "directional")
+        type = Light::Directional;
+    else if (type_string == "point")
+        type = Light::Point;
+    else
+        type = Light::Spot;
+
+    name = MemberOrDefault(obj, "name", "");
+
+    SetVector(color, vec3{ 1.0f, 1.0f, 1.0f });
+    ReadMember(obj, "color", color);
+
+    intensity = MemberOrDefault(obj, "intensity", 1.0f);
+
+    ReadMember(obj, "range", range);
+
+    if (type == Light::Spot) {
+        Value *spot = FindObject(obj, "spot");
+        if (!spot) throw DeadlyImportError("GLTF: Light missing its spot parameters");
+        innerConeAngle = MemberOrDefault(*spot, "innerConeAngle", 0.0f);
+        outerConeAngle = MemberOrDefault(*spot, "outerConeAngle", static_cast<float>(M_PI / 4.0f));
+    }
+}
+
+inline void Node::Read(Value &obj, Asset &r) {
+    if (name.empty()) {
+        name = id;
+    }
+
+    Value *curChildren = FindArray(obj, "children");
+    if (nullptr != curChildren) {
+        this->children.reserve(curChildren->Size());
+        for (unsigned int i = 0; i < curChildren->Size(); ++i) {
+            Value &child = (*curChildren)[i];
+            if (child.IsUint()) {
+                // get/create the child node
+                Ref<Node> chn = r.nodes.Retrieve(child.GetUint());
+                if (chn) {
+                    this->children.push_back(chn);
+                }
+            }
+        }
+    }
+
+    Value *curMatrix = FindArray(obj, "matrix");
+    if (nullptr != curMatrix) {
+        ReadValue(*curMatrix, this->matrix);
+    } else {
+        ReadMember(obj, "translation", translation);
+        ReadMember(obj, "scale", scale);
+        ReadMember(obj, "rotation", rotation);
+    }
+
+    Value *curMesh = FindUInt(obj, "mesh");
+    if (nullptr != curMesh) {
+        unsigned int numMeshes = 1;
+        this->meshes.reserve(numMeshes);
+        Ref<Mesh> meshRef = r.meshes.Retrieve((*curMesh).GetUint());
+        if (meshRef) {
+            this->meshes.push_back(meshRef);
+        }
+    }
+
+    // Do not retrieve a skin here, just take a reference, to avoid infinite recursion
+    // Skins will be properly loaded later
+    Value *curSkin = FindUInt(obj, "skin");
+    if (nullptr != curSkin) {
+        this->skin = r.skins.Get(curSkin->GetUint());
+    }
+
+    Value *curCamera = FindUInt(obj, "camera");
+    if (nullptr != curCamera) {
+        this->camera = r.cameras.Retrieve(curCamera->GetUint());
+        if (this->camera) {
+            this->camera->id = this->id;
+        }
+    }
+
+    Value *curExtensions = FindObject(obj, "extensions");
+    if (nullptr != curExtensions) {
+        if (r.extensionsUsed.KHR_lights_punctual) {
+            if (Value *ext = FindObject(*curExtensions, "KHR_lights_punctual")) {
+                Value *curLight = FindUInt(*ext, "light");
+                if (nullptr != curLight) {
+                    this->light = r.lights.Retrieve(curLight->GetUint());
+                    if (this->light) {
+                        this->light->id = this->id;
+                    }
+                }
+            }
+        }
+    }
+}
+
+inline void Scene::Read(Value &obj, Asset &r) {
+    if (Value *scene_name = FindString(obj, "name")) {
+        if (scene_name->IsString()) {
+            this->name = scene_name->GetString();
+        }
+    }
+    if (Value *array = FindArray(obj, "nodes")) {
+        for (unsigned int i = 0; i < array->Size(); ++i) {
+            if (!(*array)[i].IsUint()) continue;
+            Ref<Node> node = r.nodes.Retrieve((*array)[i].GetUint());
+            if (node)
+                this->nodes.push_back(node);
+        }
+    }
+}
+
+inline void Skin::Read(Value &obj, Asset &r) {
+    if (Value *matrices = FindUInt(obj, "inverseBindMatrices")) {
+        inverseBindMatrices = r.accessors.Retrieve(matrices->GetUint());
+    }
+
+    if (Value *joints = FindArray(obj, "joints")) {
+        for (unsigned i = 0; i < joints->Size(); ++i) {
+            if (!(*joints)[i].IsUint()) continue;
+            Ref<Node> node = r.nodes.Retrieve((*joints)[i].GetUint());
+            if (node) {
+                this->jointNames.push_back(node);
+            }
+        }
+    }
+}
+
+inline void Animation::Read(Value &obj, Asset &r) {
+    Value *curSamplers = FindArray(obj, "samplers");
+    if (nullptr != curSamplers) {
+        for (unsigned i = 0; i < curSamplers->Size(); ++i) {
+            Value &sampler = (*curSamplers)[i];
+
+            Sampler s;
+            if (Value *input = FindUInt(sampler, "input")) {
+                s.input = r.accessors.Retrieve(input->GetUint());
+            }
+            if (Value *output = FindUInt(sampler, "output")) {
+                s.output = r.accessors.Retrieve(output->GetUint());
+            }
+            s.interpolation = Interpolation_LINEAR;
+            if (Value *interpolation = FindString(sampler, "interpolation")) {
+                const std::string interp = interpolation->GetString();
+                if (interp == "LINEAR") {
+                    s.interpolation = Interpolation_LINEAR;
+                } else if (interp == "STEP") {
+                    s.interpolation = Interpolation_STEP;
+                } else if (interp == "CUBICSPLINE") {
+                    s.interpolation = Interpolation_CUBICSPLINE;
+                }
+            }
+            this->samplers.push_back(s);
+        }
+    }
+
+    Value *curChannels = FindArray(obj, "channels");
+    if (nullptr != curChannels) {
+        for (unsigned i = 0; i < curChannels->Size(); ++i) {
+            Value &channel = (*curChannels)[i];
+
+            Channel c;
+            Value *curSampler = FindUInt(channel, "sampler");
+            if (nullptr != curSampler) {
+                c.sampler = curSampler->GetUint();
+            }
+
+            if (Value *target = FindObject(channel, "target")) {
+                if (Value *node = FindUInt(*target, "node")) {
+                    c.target.node = r.nodes.Retrieve(node->GetUint());
+                }
+                if (Value *path = FindString(*target, "path")) {
+                    const std::string p = path->GetString();
+                    if (p == "translation") {
+                        c.target.path = AnimationPath_TRANSLATION;
+                    } else if (p == "rotation") {
+                        c.target.path = AnimationPath_ROTATION;
+                    } else if (p == "scale") {
+                        c.target.path = AnimationPath_SCALE;
+                    } else if (p == "weights") {
+                        c.target.path = AnimationPath_WEIGHTS;
+                    }
+                }
+            }
+            this->channels.push_back(c);
+        }
+    }
+}
+
+inline void AssetMetadata::Read(Document &doc) {
+    if (Value *obj = FindObject(doc, "asset")) {
+        ReadMember(*obj, "copyright", copyright);
+        ReadMember(*obj, "generator", generator);
+
+        if (Value *versionString = FindStringInContext(*obj, "version", "\"asset\"")) {
+            version = versionString->GetString();
+        }
+        Value *curProfile = FindObjectInContext(*obj, "profile", "\"asset\"");
+        if (nullptr != curProfile) {
+            ReadMember(*curProfile, "api", this->profile.api);
+            ReadMember(*curProfile, "version", this->profile.version);
+        }
+    }
+
+    if (version.empty() || version[0] != '2') {
+        throw DeadlyImportError("GLTF: Unsupported glTF version: ", version);
+    }
+}
+
+//
+// Asset methods implementation
+//
+
+inline void Asset::ReadBinaryHeader(IOStream &stream, std::vector<char> &sceneData) {
+    ASSIMP_LOG_DEBUG("Reading GLTF2 binary");
+    GLB_Header header;
+    if (stream.Read(&header, sizeof(header), 1) != 1) {
+        throw DeadlyImportError("GLTF: Unable to read the file header");
+    }
+
+    if (strncmp((char *)header.magic, AI_GLB_MAGIC_NUMBER, sizeof(header.magic)) != 0) {
+        throw DeadlyImportError("GLTF: Invalid binary glTF file");
+    }
+
+    AI_SWAP4(header.version);
+    asset.version = ai_to_string(header.version);
+    if (header.version != 2) {
+        throw DeadlyImportError("GLTF: Unsupported binary glTF version");
+    }
+
+    GLB_Chunk chunk;
+    if (stream.Read(&chunk, sizeof(chunk), 1) != 1) {
+        throw DeadlyImportError("GLTF: Unable to read JSON chunk");
+    }
+
+    AI_SWAP4(chunk.chunkLength);
+    AI_SWAP4(chunk.chunkType);
+
+    if (chunk.chunkType != ChunkType_JSON) {
+        throw DeadlyImportError("GLTF: JSON chunk missing");
+    }
+
+    // read the scene data, ensure null termination
+    static_assert(std::numeric_limits<uint32_t>::max() <= std::numeric_limits<size_t>::max(), "size_t must be at least 32bits");
+    mSceneLength = chunk.chunkLength; // Can't be larger than 4GB (max. uint32_t)
+    sceneData.resize(mSceneLength + 1);
+    sceneData[mSceneLength] = '\0';
+
+    if (stream.Read(&sceneData[0], 1, mSceneLength) != mSceneLength) {
+        throw DeadlyImportError("GLTF: Could not read the file contents");
+    }
+
+    uint32_t padding = ((chunk.chunkLength + 3) & ~3) - chunk.chunkLength;
+    if (padding > 0) {
+        stream.Seek(padding, aiOrigin_CUR);
+    }
+
+    AI_SWAP4(header.length);
+    mBodyOffset = 12 + 8 + chunk.chunkLength + padding + 8;
+    if (header.length >= mBodyOffset) {
+        if (stream.Read(&chunk, sizeof(chunk), 1) != 1) {
+            throw DeadlyImportError("GLTF: Unable to read BIN chunk");
+        }
+
+        AI_SWAP4(chunk.chunkLength);
+        AI_SWAP4(chunk.chunkType);
+
+        if (chunk.chunkType != ChunkType_BIN) {
+            throw DeadlyImportError("GLTF: BIN chunk missing");
+        }
+
+        mBodyLength = chunk.chunkLength;
+    } else {
+        mBodyOffset = mBodyLength = 0;
+    }
+}
+
+inline rapidjson::Document Asset::ReadDocument(IOStream &stream, bool isBinary, std::vector<char> &sceneData) {
+    ASSIMP_LOG_DEBUG("Loading GLTF2 asset");
+
+    // is binary? then read the header
+    if (isBinary) {
+        SetAsBinary(); // also creates the body buffer
+        ReadBinaryHeader(stream, sceneData);
+    } else {
+        mSceneLength = stream.FileSize();
+        mBodyLength = 0;
+
+        // Binary format only supports up to 4GB of JSON, use that as a maximum
+        if (mSceneLength >= std::numeric_limits<uint32_t>::max()) {
+            throw DeadlyImportError("GLTF: JSON size greater than 4GB");
+        }
+
+        // read the scene data, ensure null termination
+        sceneData.resize(mSceneLength + 1);
+        sceneData[mSceneLength] = '\0';
+
+        if (stream.Read(&sceneData[0], 1, mSceneLength) != mSceneLength) {
+            throw DeadlyImportError("GLTF: Could not read the file contents");
+        }
+    }
+
+    // Smallest legal JSON file is "{}" Smallest loadable glTF file is larger than that but catch it later
+    if (mSceneLength < 2) {
+        throw DeadlyImportError("GLTF: No JSON file contents");
+    }
+
+    // parse the JSON document
+    ASSIMP_LOG_DEBUG("Parsing GLTF2 JSON");
+    Document doc;
+    doc.ParseInsitu(&sceneData[0]);
+
+    if (doc.HasParseError()) {
+        char buffer[32];
+        ai_snprintf(buffer, 32, "%d", static_cast<int>(doc.GetErrorOffset()));
+        throw DeadlyImportError("GLTF: JSON parse error, offset ", buffer, ": ", GetParseError_En(doc.GetParseError()));
+    }
+
+    if (!doc.IsObject()) {
+        throw DeadlyImportError("GLTF: JSON document root must be a JSON object");
+    }
+
+    return doc;
+}
+
+inline void Asset::Load(const std::string &pFile, bool isBinary)
+{
+    mCurrentAssetDir.clear();
+    if (0 != strncmp(pFile.c_str(), AI_MEMORYIO_MAGIC_FILENAME, AI_MEMORYIO_MAGIC_FILENAME_LENGTH)) {
+        mCurrentAssetDir = glTFCommon::getCurrentAssetDir(pFile);
+    }
+
+    shared_ptr<IOStream> stream(OpenFile(pFile.c_str(), "rb", true));
+    if (!stream) {
+        throw DeadlyImportError("GLTF: Could not open file for reading");
+    }
+
+    std::vector<char> sceneData;
+    rapidjson::Document doc = ReadDocument(*stream, isBinary, sceneData);
+
+    // If a schemaDocumentProvider is available, see if the glTF schema is present. 
+    // If so, use it to validate the document.
+    if (mSchemaDocumentProvider) {
+        if (const rapidjson::SchemaDocument *gltfSchema = mSchemaDocumentProvider->GetRemoteDocument("glTF.schema.json", 16)) {
+            // The schemas are found here: https://github.com/KhronosGroup/glTF/tree/main/specification/2.0/schema
+            rapidjson::SchemaValidator validator(*gltfSchema);
+            if (!doc.Accept(validator)) {
+                rapidjson::StringBuffer pathBuffer;
+                validator.GetInvalidSchemaPointer().StringifyUriFragment(pathBuffer);
+                rapidjson::StringBuffer argumentBuffer;
+                validator.GetInvalidDocumentPointer().StringifyUriFragment(argumentBuffer);
+                throw DeadlyImportError("GLTF: The JSON document did not satisfy the glTF2 schema. Schema keyword: ", validator.GetInvalidSchemaKeyword(), ", document path: ", pathBuffer.GetString(), ", argument: ", argumentBuffer.GetString());
+            }
+        }
+    }
+
+    // Fill the buffer instance for the current file embedded contents
+    if (mBodyLength > 0) {
+        if (!mBodyBuffer->LoadFromStream(*stream, mBodyLength, mBodyOffset)) {
+            throw DeadlyImportError("GLTF: Unable to read gltf file");
+        }
+    }
+
+    // Load the metadata
+    asset.Read(doc);
+    ReadExtensionsUsed(doc);
+    ReadExtensionsRequired(doc);
+
+#ifndef ASSIMP_ENABLE_DRACO
+    // Is Draco required?
+    if (extensionsRequired.KHR_draco_mesh_compression) {
+        throw DeadlyImportError("GLTF: Draco mesh compression not supported.");
+    }
+#endif
+
+    // Prepare the dictionaries
+    for (size_t i = 0; i < mDicts.size(); ++i) {
+        mDicts[i]->AttachToDocument(doc);
+    }
+
+    // Read the "scene" property, which specifies which scene to load
+    // and recursively load everything referenced by it
+    unsigned int sceneIndex = 0;
+    Value *curScene = FindUInt(doc, "scene");
+    if (nullptr != curScene) {
+        sceneIndex = curScene->GetUint();
+    }
+
+    if (Value *scenesArray = FindArray(doc, "scenes")) {
+        if (sceneIndex < scenesArray->Size()) {
+            this->scene = scenes.Retrieve(sceneIndex);
+        }
+    }
+
+    if (Value *skinsArray = FindArray(doc, "skins")) {
+        for (unsigned int i = 0; i < skinsArray->Size(); ++i) {
+            skins.Retrieve(i);
+        }
+    }
+
+    if (Value *animsArray = FindArray(doc, "animations")) {
+        for (unsigned int i = 0; i < animsArray->Size(); ++i) {
+            animations.Retrieve(i);
+        }
+    }
+
+    // Clean up
+    for (size_t i = 0; i < mDicts.size(); ++i) {
+        mDicts[i]->DetachFromDocument();
+    }
+}
+
+inline bool Asset::CanRead(const std::string &pFile, bool isBinary) {
+    try {
+        shared_ptr<IOStream> stream(OpenFile(pFile.c_str(), "rb", true));
+        if (!stream) {
+            return false;
+        }
+        std::vector<char> sceneData;
+        rapidjson::Document doc = ReadDocument(*stream, isBinary, sceneData);
+        asset.Read(doc);
+    } catch (...) {
+        return false;
+    }
+    return true;
+}
+
+inline void Asset::SetAsBinary() {
+    if (!mBodyBuffer) {
+        mBodyBuffer = buffers.Create("binary_glTF");
+        mBodyBuffer->MarkAsSpecial();
+    }
+}
+
+// As required extensions are only a concept in glTF 2.0, this is here
+// instead of glTFCommon.h
+#define CHECK_REQUIRED_EXT(EXT) \
+    if (exts.find(#EXT) != exts.end()) extensionsRequired.EXT = true;
+
+inline void Asset::ReadExtensionsRequired(Document &doc) {
+    Value *extsRequired = FindArray(doc, "extensionsRequired");
+    if (nullptr == extsRequired) {
+        return;
+    }
+
+    std::gltf_unordered_map<std::string, bool> exts;
+    for (unsigned int i = 0; i < extsRequired->Size(); ++i) {
+        if ((*extsRequired)[i].IsString()) {
+            exts[(*extsRequired)[i].GetString()] = true;
+        }
+    }
+
+    CHECK_REQUIRED_EXT(KHR_draco_mesh_compression);
+
+#undef CHECK_REQUIRED_EXT
+}
+
+inline void Asset::ReadExtensionsUsed(Document &doc) {
+    Value *extsUsed = FindArray(doc, "extensionsUsed");
+    if (!extsUsed) return;
+
+    std::gltf_unordered_map<std::string, bool> exts;
+
+    for (unsigned int i = 0; i < extsUsed->Size(); ++i) {
+        if ((*extsUsed)[i].IsString()) {
+            exts[(*extsUsed)[i].GetString()] = true;
+        }
+    }
+
+    CHECK_EXT(KHR_materials_pbrSpecularGlossiness);
+    CHECK_EXT(KHR_materials_unlit);
+    CHECK_EXT(KHR_lights_punctual);
+    CHECK_EXT(KHR_texture_transform);
+    CHECK_EXT(KHR_materials_sheen);
+    CHECK_EXT(KHR_materials_clearcoat);
+    CHECK_EXT(KHR_materials_transmission);
+    CHECK_EXT(KHR_materials_volume);
+    CHECK_EXT(KHR_materials_ior);
+    CHECK_EXT(KHR_draco_mesh_compression);
+    CHECK_EXT(KHR_texture_basisu);
+
+#undef CHECK_EXT
+}
+
+inline IOStream *Asset::OpenFile(const std::string &path, const char *mode, bool /*absolute*/) {
+#ifdef ASSIMP_API
+    return mIOSystem->Open(path, mode);
+#else
+    if (path.size() < 2) return nullptr;
+    if (!absolute && path[1] != ':' && path[0] != '/') { // relative?
+        path = mCurrentAssetDir + path;
+    }
+    FILE *f = fopen(path.c_str(), mode);
+    return f ? new IOStream(f) : nullptr;
+#endif
+}
+
+inline std::string Asset::FindUniqueID(const std::string &str, const char *suffix) {
+    std::string id = str;
+
+    if (!id.empty()) {
+        if (mUsedIds.find(id) == mUsedIds.end())
+            return id;
+
+        id += "_";
+    }
+
+    id += suffix;
+
+    Asset::IdMap::iterator it = mUsedIds.find(id);
+    if (it == mUsedIds.end()) {
+        return id;
+    }
+
+    std::vector<char> buffer;
+    buffer.resize(id.size() + 16);
+    int offset = ai_snprintf(buffer.data(), buffer.size(), "%s_", id.c_str());
+    for (int i = 0; it != mUsedIds.end(); ++i) {
+        ai_snprintf(buffer.data() + offset, buffer.size() - offset, "%d", i);
+        id = buffer.data();
+        it = mUsedIds.find(id);
+    }
+
+    return id;
+}
+
+#if _MSC_VER
+#   pragma warning(pop)
+#endif // _MSC_VER
+
+} // namespace glTF2
diff --git a/Engine/lib/assimp/code/glTF2/glTF2AssetWriter.h b/Engine/lib/assimp/code/AssetLib/glTF2/glTF2AssetWriter.h
similarity index 90%
rename from Engine/lib/assimp/code/glTF2/glTF2AssetWriter.h
rename to Engine/lib/assimp/code/AssetLib/glTF2/glTF2AssetWriter.h
index 928b6e71b..089a15844 100644
--- a/Engine/lib/assimp/code/glTF2/glTF2AssetWriter.h
+++ b/Engine/lib/assimp/code/AssetLib/glTF2/glTF2AssetWriter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -46,11 +46,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  * glTF Extensions Support:
  *   KHR_materials_pbrSpecularGlossiness: full
  *   KHR_materials_unlit: full
+ *   KHR_materials_sheen: full
+ *   KHR_materials_clearcoat: full
+ *   KHR_materials_transmission: full
+ *   KHR_materials_volume: full
+ *   KHR_materials_ior: full
  */
 #ifndef GLTF2ASSETWRITER_H_INC
 #define GLTF2ASSETWRITER_H_INC
 
-#ifndef ASSIMP_BUILD_NO_GLTF_IMPORTER
+#if !defined(ASSIMP_BUILD_NO_GLTF_IMPORTER) && !defined(ASSIMP_BUILD_NO_GLTF2_IMPORTER)
 
 #include "glTF2Asset.h"
 
diff --git a/Engine/lib/assimp/code/glTF2/glTF2AssetWriter.inl b/Engine/lib/assimp/code/AssetLib/glTF2/glTF2AssetWriter.inl
similarity index 68%
rename from Engine/lib/assimp/code/glTF2/glTF2AssetWriter.inl
rename to Engine/lib/assimp/code/AssetLib/glTF2/glTF2AssetWriter.inl
index 5d1b22064..0be139595 100644
--- a/Engine/lib/assimp/code/glTF2/glTF2AssetWriter.inl
+++ b/Engine/lib/assimp/code/AssetLib/glTF2/glTF2AssetWriter.inl
@@ -1,9 +1,8 @@
-/*
+/*
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -40,6 +39,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
+#include <assimp/Base64.hpp>
 #include <rapidjson/stringbuffer.h>
 #include <rapidjson/writer.h>
 #include <rapidjson/prettywriter.h>
@@ -54,8 +54,8 @@ namespace glTF2 {
 
     namespace {
 
-        template<size_t N>
-        inline Value& MakeValue(Value& val, float(&r)[N], MemoryPoolAllocator<>& al) {
+        template<typename T, size_t N>
+        inline Value& MakeValue(Value& val, T(&r)[N], MemoryPoolAllocator<>& al) {
             val.SetArray();
             val.Reserve(N, al);
             for (decltype(N) i = 0; i < N; ++i) {
@@ -64,7 +64,8 @@ namespace glTF2 {
             return val;
         }
 
-        inline Value& MakeValue(Value& val, const std::vector<float> & r, MemoryPoolAllocator<>& al) {
+        template<typename T>
+        inline Value& MakeValue(Value& val, const std::vector<T> & r, MemoryPoolAllocator<>& al) {
             val.SetArray();
             val.Reserve(static_cast<rapidjson::SizeType>(r.size()), al);
             for (unsigned int i = 0; i < r.size(); ++i) {
@@ -73,8 +74,19 @@ namespace glTF2 {
             return val;
         }
 
-        inline Value& MakeValue(Value& val, float r, MemoryPoolAllocator<>& /*al*/) {
-            val.SetDouble(r);
+        template<typename C, typename T>
+        inline Value& MakeValueCast(Value& val, const std::vector<T> & r, MemoryPoolAllocator<>& al) {
+            val.SetArray();
+            val.Reserve(static_cast<rapidjson::SizeType>(r.size()), al);
+            for (unsigned int i = 0; i < r.size(); ++i) {
+                val.PushBack(static_cast<C>(r[i]), al);
+            }
+            return val;
+        }
+
+        template<typename T>
+        inline Value& MakeValue(Value& val, T r, MemoryPoolAllocator<>& /*al*/) {
+            val.Set(r);
 
             return val;
         }
@@ -96,16 +108,46 @@ namespace glTF2 {
 
     inline void Write(Value& obj, Accessor& a, AssetWriter& w)
     {
-        obj.AddMember("bufferView", a.bufferView->index, w.mAl);
-        obj.AddMember("byteOffset", (unsigned int)a.byteOffset, w.mAl);
-
+        if (a.bufferView) {
+            obj.AddMember("bufferView", a.bufferView->index, w.mAl);
+            obj.AddMember("byteOffset", (unsigned int)a.byteOffset, w.mAl);
+        }
         obj.AddMember("componentType", int(a.componentType), w.mAl);
         obj.AddMember("count", (unsigned int)a.count, w.mAl);
         obj.AddMember("type", StringRef(AttribType::ToString(a.type)), w.mAl);
-
         Value vTmpMax, vTmpMin;
-        obj.AddMember("max", MakeValue(vTmpMax, a.max, w.mAl), w.mAl);
-        obj.AddMember("min", MakeValue(vTmpMin, a.min, w.mAl), w.mAl);
+        if (a.componentType == ComponentType_FLOAT) {
+            obj.AddMember("max", MakeValue(vTmpMax, a.max, w.mAl), w.mAl);
+            obj.AddMember("min", MakeValue(vTmpMin, a.min, w.mAl), w.mAl);
+        } else {
+            obj.AddMember("max", MakeValueCast<int64_t>(vTmpMax, a.max, w.mAl), w.mAl);
+            obj.AddMember("min", MakeValueCast<int64_t>(vTmpMin, a.min, w.mAl), w.mAl);
+        }
+
+        if (a.sparse) {
+            Value sparseValue;
+            sparseValue.SetObject();
+
+            //count
+            sparseValue.AddMember("count", (unsigned int)a.sparse->count, w.mAl);
+
+            //indices
+            Value indices;
+            indices.SetObject();
+            indices.AddMember("bufferView", a.sparse->indices->index, w.mAl);
+            indices.AddMember("byteOffset", (unsigned int)a.sparse->indicesByteOffset, w.mAl);
+            indices.AddMember("componentType", int(a.sparse->indicesType), w.mAl);
+            sparseValue.AddMember("indices", indices, w.mAl);
+
+            //values
+            Value values;
+            values.SetObject();
+            values.AddMember("bufferView", a.sparse->values->index, w.mAl);
+            values.AddMember("byteOffset", (unsigned int)a.sparse->valuesByteOffset, w.mAl);
+            sparseValue.AddMember("values", values, w.mAl);
+
+            obj.AddMember("sparse", sparseValue, w.mAl);
+        }
     }
 
     inline void Write(Value& obj, Animation& a, AssetWriter& w)
@@ -159,13 +201,13 @@ namespace glTF2 {
                 valSampler.AddMember("input", s.input->index, w.mAl);
                 switch (s.interpolation) {
                     case Interpolation_LINEAR:
-                        valSampler.AddMember("path", "LINEAR", w.mAl);
+                        valSampler.AddMember("interpolation", "LINEAR", w.mAl);
                         break;
                     case Interpolation_STEP:
-                        valSampler.AddMember("path", "STEP", w.mAl);
+                        valSampler.AddMember("interpolation", "STEP", w.mAl);
                         break;
                     case Interpolation_CUBICSPLINE:
-                        valSampler.AddMember("path", "CUBICSPLINE", w.mAl);
+                        valSampler.AddMember("interpolation", "CUBICSPLINE", w.mAl);
                         break;
                 }
                 valSampler.AddMember("output", s.output->index, w.mAl);
@@ -192,7 +234,7 @@ namespace glTF2 {
         if (bv.byteStride != 0) {
             obj.AddMember("byteStride", bv.byteStride, w.mAl);
         }
-        if (bv.target != 0) {
+        if (bv.target != BufferViewTarget_NONE) {
             obj.AddMember("target", int(bv.target), w.mAl);
         }
     }
@@ -209,6 +251,7 @@ namespace glTF2 {
 
     inline void Write(Value& obj, Image& img, AssetWriter& w)
     {
+        //basisu: no need to handle .ktx2, .basis, write as is
         if (img.bufferView) {
             obj.AddMember("bufferView", img.bufferView->index, w.mAl);
             obj.AddMember("mimeType", Value(img.mimeType, w.mAl).Move(), w.mAl);
@@ -218,7 +261,7 @@ namespace glTF2 {
             if (img.HasData()) {
                 uri = "data:" + (img.mimeType.empty() ? "application/octet-stream" : img.mimeType);
                 uri += ";base64,";
-                glTFCommon::Util::EncodeBase64(img.GetData(), img.GetDataLength(), uri);
+                Base64::Encode(img.GetData(), img.GetDataLength(), uri);
             }
             else {
                 uri = img.uri;
@@ -358,7 +401,7 @@ namespace glTF2 {
             WriteVec(pbrSpecularGlossiness, pbrSG.specularFactor, "specularFactor", defaultSpecularFactor, w.mAl);
 
             if (pbrSG.glossinessFactor != 1) {
-                WriteFloat(obj, pbrSG.glossinessFactor, "glossinessFactor", w.mAl);
+                WriteFloat(pbrSpecularGlossiness, pbrSG.glossinessFactor, "glossinessFactor", w.mAl);
             }
 
             WriteTex(pbrSpecularGlossiness, pbrSG.diffuseTexture, "diffuseTexture", w.mAl);
@@ -375,6 +418,99 @@ namespace glTF2 {
           exts.AddMember("KHR_materials_unlit", unlit, w.mAl);
         }
 
+        if (m.materialSheen.isPresent) {
+            Value materialSheen(rapidjson::Type::kObjectType);
+
+            MaterialSheen &sheen = m.materialSheen.value;
+
+            WriteVec(materialSheen, sheen.sheenColorFactor, "sheenColorFactor", defaultSheenFactor, w.mAl);
+
+            if (sheen.sheenRoughnessFactor != 0.f) {
+                WriteFloat(materialSheen, sheen.sheenRoughnessFactor, "sheenRoughnessFactor", w.mAl);
+            }
+
+            WriteTex(materialSheen, sheen.sheenColorTexture, "sheenColorTexture", w.mAl);
+            WriteTex(materialSheen, sheen.sheenRoughnessTexture, "sheenRoughnessTexture", w.mAl);
+
+            if (!materialSheen.ObjectEmpty()) {
+                exts.AddMember("KHR_materials_sheen", materialSheen, w.mAl);
+            }
+        }
+
+        if (m.materialClearcoat.isPresent) {
+            Value materialClearcoat(rapidjson::Type::kObjectType);
+
+            MaterialClearcoat &clearcoat = m.materialClearcoat.value;
+
+            if (clearcoat.clearcoatFactor != 0.f) {
+                WriteFloat(materialClearcoat, clearcoat.clearcoatFactor, "clearcoatFactor", w.mAl);
+            }
+
+            if (clearcoat.clearcoatRoughnessFactor != 0.f) {
+                WriteFloat(materialClearcoat, clearcoat.clearcoatRoughnessFactor, "clearcoatRoughnessFactor", w.mAl);
+            }
+
+            WriteTex(materialClearcoat, clearcoat.clearcoatTexture, "clearcoatTexture", w.mAl);
+            WriteTex(materialClearcoat, clearcoat.clearcoatRoughnessTexture, "clearcoatRoughnessTexture", w.mAl);
+            WriteTex(materialClearcoat, clearcoat.clearcoatNormalTexture, "clearcoatNormalTexture", w.mAl);
+
+            if (!materialClearcoat.ObjectEmpty()) {
+                exts.AddMember("KHR_materials_clearcoat", materialClearcoat, w.mAl);
+            }
+        }
+
+        if (m.materialTransmission.isPresent) {
+            Value materialTransmission(rapidjson::Type::kObjectType);
+
+            MaterialTransmission &transmission = m.materialTransmission.value;
+
+            if (transmission.transmissionFactor != 0.f) {
+                WriteFloat(materialTransmission, transmission.transmissionFactor, "transmissionFactor", w.mAl);
+            }
+
+            WriteTex(materialTransmission, transmission.transmissionTexture, "transmissionTexture", w.mAl);
+
+            if (!materialTransmission.ObjectEmpty()) {
+                exts.AddMember("KHR_materials_transmission", materialTransmission, w.mAl);
+            }
+        }
+
+        if (m.materialVolume.isPresent) {
+            Value materialVolume(rapidjson::Type::kObjectType);
+
+            MaterialVolume &volume = m.materialVolume.value;
+
+            if (volume.thicknessFactor != 0.f) {
+                WriteFloat(materialVolume, volume.thicknessFactor, "thicknessFactor", w.mAl);
+            }
+
+            WriteTex(materialVolume, volume.thicknessTexture, "thicknessTexture", w.mAl);
+
+            if (volume.attenuationDistance != INFINITY) {
+                WriteFloat(materialVolume, volume.attenuationDistance, "attenuationDistance", w.mAl);
+            }
+
+            WriteVec(materialVolume, volume.attenuationColor, "attenuationColor", defaultAttenuationColor, w.mAl);
+
+            if (!materialVolume.ObjectEmpty()) {
+                exts.AddMember("KHR_materials_volume", materialVolume, w.mAl);
+            }
+        }
+
+        if (m.materialIOR.isPresent) {
+            Value materialIOR(rapidjson::Type::kObjectType);
+
+            MaterialIOR &ior = m.materialIOR.value;
+
+            if (ior.ior != 1.5f) {
+                WriteFloat(materialIOR, ior.ior, "ior", w.mAl);
+            }
+
+            if (!materialIOR.ObjectEmpty()) {
+                exts.AddMember("KHR_materials_ior", materialIOR, w.mAl);
+            }
+        }
+
         if (!exts.ObjectEmpty()) {
             obj.AddMember("extensions", exts, w.mAl);
         }
@@ -409,6 +545,20 @@ namespace glTF2 {
             Mesh::Primitive& p = m.primitives[i];
             Value prim;
             prim.SetObject();
+
+            // Extensions
+            if (p.ngonEncoded)
+            {
+                Value exts;
+                exts.SetObject();
+
+                Value FB_ngon_encoding;
+                FB_ngon_encoding.SetObject();
+
+                exts.AddMember(StringRef("FB_ngon_encoding"), FB_ngon_encoding, w.mAl);
+                prim.AddMember("extensions", exts, w.mAl);
+            }
+
             {
                 prim.AddMember("mode", Value(int(p.mode)).Move(), w.mAl);
 
@@ -429,16 +579,49 @@ namespace glTF2 {
                     WriteAttrs(w, attrs, p.attributes.weight, "WEIGHTS", true);
                 }
                 prim.AddMember("attributes", attrs, w.mAl);
+
+                // targets for blendshapes
+                if (p.targets.size() > 0) {
+                    Value tjs;
+                    tjs.SetArray();
+                    tjs.Reserve(unsigned(p.targets.size()), w.mAl);
+                    for (unsigned int t = 0; t < p.targets.size(); ++t) {
+                        Value tj;
+                        tj.SetObject();
+                        {
+                            WriteAttrs(w, tj, p.targets[t].position, "POSITION");
+                            WriteAttrs(w, tj, p.targets[t].normal, "NORMAL");
+                            WriteAttrs(w, tj, p.targets[t].tangent, "TANGENT");
+                        }
+                        tjs.PushBack(tj, w.mAl);
+                    }
+                    prim.AddMember("targets", tjs, w.mAl);
+                }
             }
             primitives.PushBack(prim, w.mAl);
         }
 
         obj.AddMember("primitives", primitives, w.mAl);
+        // targetNames
+        if (m.targetNames.size() > 0) {
+            Value extras;
+            extras.SetObject();
+            Value targetNames;
+            targetNames.SetArray();
+            targetNames.Reserve(unsigned(m.targetNames.size()), w.mAl);
+            for (unsigned int n = 0; n < m.targetNames.size(); ++n) {
+                std::string name = m.targetNames[n];
+                Value tname;
+                tname.SetString(name.c_str(), w.mAl);
+                targetNames.PushBack(tname, w.mAl);
+            }
+            extras.AddMember("targetNames", targetNames, w.mAl);
+            obj.AddMember("extras", extras, w.mAl);
+        }
     }
 
     inline void Write(Value& obj, Node& n, AssetWriter& w)
     {
-
         if (n.matrix.isPresent) {
             Value val;
             obj.AddMember("matrix", MakeValue(val, n.matrix.value, w.mAl).Move(), w.mAl);
@@ -464,14 +647,13 @@ namespace glTF2 {
             obj.AddMember("mesh", n.meshes[0]->index, w.mAl);
         }
 
-        AddRefsVector(obj, "skeletons", n.skeletons, w.mAl);
-
         if (n.skin) {
             obj.AddMember("skin", n.skin->index, w.mAl);
         }
 
-        if (!n.jointName.empty()) {
-          obj.AddMember("jointName", n.jointName, w.mAl);
+        //gltf2 spec does not support "skeletons" under node
+        if(n.skeletons.size()) {
+            AddRefsVector(obj, "skeletons", n.skeletons, w.mAl);
         }
     }
 
@@ -566,6 +748,10 @@ namespace glTF2 {
         if (mAsset.scene) {
             mDoc.AddMember("scene", mAsset.scene->index, mAl);
         }
+
+        if(mAsset.extras) {
+            mDoc.AddMember("extras", *mAsset.extras, mAl);
+        }
     }
 
     inline void AssetWriter::WriteFile(const char* path)
@@ -579,7 +765,9 @@ namespace glTF2 {
         StringBuffer docBuffer;
 
         PrettyWriter<StringBuffer> writer(docBuffer);
-        mDoc.Accept(writer);
+        if (!mDoc.Accept(writer)) {
+            throw DeadlyExportError("Failed to write scene data!");
+        }
 
         if (jsonOutFile->Write(docBuffer.GetString(), docBuffer.GetSize(), 1) != 1) {
             throw DeadlyExportError("Failed to write scene data!");
@@ -630,7 +818,9 @@ namespace glTF2 {
 
         StringBuffer docBuffer;
         Writer<StringBuffer> writer(docBuffer);
-        mDoc.Accept(writer);
+        if (!mDoc.Accept(writer)) {
+            throw DeadlyExportError("Failed to write scene data!");
+        }
 
         uint32_t jsonChunkLength = (docBuffer.GetSize() + 3) & ~3; // Round up to next multiple of 4
         auto paddingLength = jsonChunkLength - docBuffer.GetSize();
@@ -655,10 +845,13 @@ namespace glTF2 {
         // Binary chunk
         //
 
+        int GLB_Chunk_count = 1;
         uint32_t binaryChunkLength = 0;
         if (bodyBuffer->byteLength > 0) {
             binaryChunkLength = (bodyBuffer->byteLength + 3) & ~3; // Round up to next multiple of 4
-            auto paddingLength = binaryChunkLength - bodyBuffer->byteLength;
+
+            auto curPaddingLength = binaryChunkLength - bodyBuffer->byteLength;
+            ++GLB_Chunk_count;
 
             GLB_Chunk binaryChunk;
             binaryChunk.chunkLength = binaryChunkLength;
@@ -673,7 +866,7 @@ namespace glTF2 {
             if (outfile->Write(bodyBuffer->GetPointer(), 1, bodyBuffer->byteLength) != bodyBuffer->byteLength) {
                 throw DeadlyExportError("Failed to write body data!");
             }
-            if (paddingLength && outfile->Write(&padding, 1, paddingLength) != paddingLength) {
+            if (curPaddingLength && outfile->Write(&padding, 1, paddingLength) != paddingLength) {
                 throw DeadlyExportError("Failed to write body data padding!");
             }
         }
@@ -688,7 +881,7 @@ namespace glTF2 {
         header.version = 2;
         AI_SWAP4(header.version);
 
-        header.length = uint32_t(sizeof(GLB_Header) + 2 * sizeof(GLB_Chunk) + jsonChunkLength + binaryChunkLength);
+        header.length = uint32_t(sizeof(GLB_Header) + GLB_Chunk_count * sizeof(GLB_Chunk) + jsonChunkLength + binaryChunkLength);
         AI_SWAP4(header.length);
 
         outfile->Seek(0, aiOrigin_SET);
@@ -703,6 +896,8 @@ namespace glTF2 {
         asset.SetObject();
         asset.AddMember("version", Value(mAsset.asset.version, mAl).Move(), mAl);
         asset.AddMember("generator", Value(mAsset.asset.generator, mAl).Move(), mAl);
+        if (!mAsset.asset.copyright.empty())
+            asset.AddMember("copyright", Value(mAsset.asset.copyright, mAl).Move(), mAl);
         mDoc.AddMember("asset", asset, mAl);
     }
 
@@ -719,10 +914,46 @@ namespace glTF2 {
             if (this->mAsset.extensionsUsed.KHR_materials_unlit) {
               exts.PushBack(StringRef("KHR_materials_unlit"), mAl);
             }
+
+            if (this->mAsset.extensionsUsed.KHR_materials_sheen) {
+                exts.PushBack(StringRef("KHR_materials_sheen"), mAl);
+            }
+
+            if (this->mAsset.extensionsUsed.KHR_materials_clearcoat) {
+                exts.PushBack(StringRef("KHR_materials_clearcoat"), mAl);
+            }
+
+            if (this->mAsset.extensionsUsed.KHR_materials_transmission) {
+                exts.PushBack(StringRef("KHR_materials_transmission"), mAl);
+            }
+
+            if (this->mAsset.extensionsUsed.KHR_materials_volume) {
+                exts.PushBack(StringRef("KHR_materials_volume"), mAl);
+            }
+
+            if (this->mAsset.extensionsUsed.KHR_materials_ior) {
+                exts.PushBack(StringRef("KHR_materials_ior"), mAl);
+            }
+
+            if (this->mAsset.extensionsUsed.FB_ngon_encoding) {
+                exts.PushBack(StringRef("FB_ngon_encoding"), mAl);
+            }
+
+            if (this->mAsset.extensionsUsed.KHR_texture_basisu) {
+                exts.PushBack(StringRef("KHR_texture_basisu"), mAl);
+            }
         }
 
         if (!exts.Empty())
             mDoc.AddMember("extensionsUsed", exts, mAl);
+
+        //basisu extensionRequired
+        Value extsReq;
+        extsReq.SetArray();
+        if (this->mAsset.extensionsUsed.KHR_texture_basisu) {
+            extsReq.PushBack(StringRef("KHR_texture_basisu"), mAl);
+            mDoc.AddMember("extensionsRequired", extsReq, mAl);
+        }
     }
 
     template<class T>
@@ -731,31 +962,36 @@ namespace glTF2 {
         if (d.mObjs.empty()) return;
 
         Value* container = &mDoc;
+		const char* context = "Document";
 
         if (d.mExtId) {
             Value* exts = FindObject(mDoc, "extensions");
-            if (!exts) {
+            if (nullptr != exts) {
                 mDoc.AddMember("extensions", Value().SetObject().Move(), mDoc.GetAllocator());
                 exts = FindObject(mDoc, "extensions");
             }
 
-            if (!(container = FindObject(*exts, d.mExtId))) {
+            container = FindObjectInContext(*exts, d.mExtId, "extensions");
+            if (nullptr != container) {
                 exts->AddMember(StringRef(d.mExtId), Value().SetObject().Move(), mDoc.GetAllocator());
-                container = FindObject(*exts, d.mExtId);
+                container = FindObjectInContext(*exts, d.mExtId, "extensions");
+                context = d.mExtId;
             }
         }
 
-        Value* dict;
-        if (!(dict = FindArray(*container, d.mDictId))) {
+        Value *dict = FindArrayInContext(*container, d.mDictId, context);
+        if (nullptr == dict) {
             container->AddMember(StringRef(d.mDictId), Value().SetArray().Move(), mDoc.GetAllocator());
-            dict = FindArray(*container, d.mDictId);
+            dict = FindArrayInContext(*container, d.mDictId, context);
             if (nullptr == dict) {
                 return;
             }
         }
 
         for (size_t i = 0; i < d.mObjs.size(); ++i) {
-            if (d.mObjs[i]->IsSpecial()) continue;
+            if (d.mObjs[i]->IsSpecial()) {
+                continue;
+            }
 
             Value obj;
             obj.SetObject();
@@ -777,5 +1013,3 @@ namespace glTF2 {
     }
 
 }
-
-
diff --git a/Engine/lib/assimp/code/AssetLib/glTF2/glTF2Exporter.cpp b/Engine/lib/assimp/code/AssetLib/glTF2/glTF2Exporter.cpp
new file mode 100644
index 000000000..ffd8d223e
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/glTF2/glTF2Exporter.cpp
@@ -0,0 +1,1542 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+#ifndef ASSIMP_BUILD_NO_EXPORT
+#ifndef ASSIMP_BUILD_NO_GLTF_EXPORTER
+
+#include "AssetLib/glTF2/glTF2Exporter.h"
+#include "AssetLib/glTF2/glTF2AssetWriter.h"
+#include "PostProcessing/SplitLargeMeshes.h"
+
+#include <assimp/ByteSwapper.h>
+#include <assimp/Exceptional.h>
+#include <assimp/SceneCombiner.h>
+#include <assimp/StringComparison.h>
+#include <assimp/commonMetaData.h>
+#include <assimp/material.h>
+#include <assimp/scene.h>
+#include <assimp/version.h>
+#include <assimp/Exporter.hpp>
+#include <assimp/IOSystem.hpp>
+
+// Header files, standard library.
+#include <cinttypes>
+#include <limits>
+#include <memory>
+
+using namespace rapidjson;
+
+using namespace Assimp;
+using namespace glTF2;
+
+namespace Assimp {
+
+// ------------------------------------------------------------------------------------------------
+// Worker function for exporting a scene to GLTF. Prototyped and registered in Exporter.cpp
+void ExportSceneGLTF2(const char *pFile, IOSystem *pIOSystem, const aiScene *pScene, const ExportProperties *pProperties) {
+    // invoke the exporter
+    glTF2Exporter exporter(pFile, pIOSystem, pScene, pProperties, false);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Worker function for exporting a scene to GLB. Prototyped and registered in Exporter.cpp
+void ExportSceneGLB2(const char *pFile, IOSystem *pIOSystem, const aiScene *pScene, const ExportProperties *pProperties) {
+    // invoke the exporter
+    glTF2Exporter exporter(pFile, pIOSystem, pScene, pProperties, true);
+}
+
+} // end of namespace Assimp
+
+glTF2Exporter::glTF2Exporter(const char *filename, IOSystem *pIOSystem, const aiScene *pScene,
+        const ExportProperties *pProperties, bool isBinary) :
+        mFilename(filename), mIOSystem(pIOSystem), mScene(pScene), mProperties(pProperties), mAsset(new Asset(pIOSystem)) {
+    // Always on as our triangulation process is aware of this type of encoding
+    mAsset->extensionsUsed.FB_ngon_encoding = true;
+
+    if (isBinary) {
+        mAsset->SetAsBinary();
+    }
+
+    ExportMetadata();
+
+    ExportMaterials();
+
+    if (mScene->mRootNode) {
+        ExportNodeHierarchy(mScene->mRootNode);
+    }
+
+    ExportMeshes();
+    MergeMeshes();
+
+    ExportScene();
+
+    ExportAnimations();
+
+    // export extras
+    if (mProperties->HasPropertyCallback("extras")) {
+        std::function<void *(void *)> ExportExtras = mProperties->GetPropertyCallback("extras");
+        mAsset->extras = (rapidjson::Value *)ExportExtras(0);
+    }
+
+    AssetWriter writer(*mAsset);
+
+    if (isBinary) {
+        writer.WriteGLBFile(filename);
+    } else {
+        writer.WriteFile(filename);
+    }
+}
+
+glTF2Exporter::~glTF2Exporter() {
+    // empty
+}
+
+/*
+ * Copy a 4x4 matrix from struct aiMatrix to typedef mat4.
+ * Also converts from row-major to column-major storage.
+ */
+static void CopyValue(const aiMatrix4x4 &v, mat4 &o) {
+    o[0] = v.a1;
+    o[1] = v.b1;
+    o[2] = v.c1;
+    o[3] = v.d1;
+    o[4] = v.a2;
+    o[5] = v.b2;
+    o[6] = v.c2;
+    o[7] = v.d2;
+    o[8] = v.a3;
+    o[9] = v.b3;
+    o[10] = v.c3;
+    o[11] = v.d3;
+    o[12] = v.a4;
+    o[13] = v.b4;
+    o[14] = v.c4;
+    o[15] = v.d4;
+}
+
+static void CopyValue(const aiMatrix4x4 &v, aiMatrix4x4 &o) {
+    memcpy(&o, &v, sizeof(aiMatrix4x4));
+}
+
+static void IdentityMatrix4(mat4 &o) {
+    o[0] = 1;
+    o[1] = 0;
+    o[2] = 0;
+    o[3] = 0;
+    o[4] = 0;
+    o[5] = 1;
+    o[6] = 0;
+    o[7] = 0;
+    o[8] = 0;
+    o[9] = 0;
+    o[10] = 1;
+    o[11] = 0;
+    o[12] = 0;
+    o[13] = 0;
+    o[14] = 0;
+    o[15] = 1;
+}
+
+static bool IsBoneWeightFitted(vec4 &weight) {
+    return weight[0] + weight[1] + weight[2] + weight[3] >= 1.f;
+}
+
+static int FitBoneWeight(vec4 &weight, float value) {
+    int i = 0;
+    for (; i < 4; ++i) {
+        if (weight[i] < value) {
+            weight[i] = value;
+            return i;
+        }
+    }
+
+    return -1;
+}
+
+template <typename T>
+void SetAccessorRange(Ref<Accessor> acc, void *data, size_t count,
+        unsigned int numCompsIn, unsigned int numCompsOut) {
+    ai_assert(numCompsOut <= numCompsIn);
+
+    // Allocate and initialize with large values.
+    for (unsigned int i = 0; i < numCompsOut; i++) {
+        acc->min.push_back(std::numeric_limits<double>::max());
+        acc->max.push_back(-std::numeric_limits<double>::max());
+    }
+
+    size_t totalComps = count * numCompsIn;
+    T *buffer_ptr = static_cast<T *>(data);
+    T *buffer_end = buffer_ptr + totalComps;
+
+    // Search and set extreme values.
+    for (; buffer_ptr < buffer_end; buffer_ptr += numCompsIn) {
+        for (unsigned int j = 0; j < numCompsOut; j++) {
+            double valueTmp = buffer_ptr[j];
+
+            // Gracefully tolerate rogue NaN's in buffer data
+            // Any NaNs/Infs introduced in accessor bounds will end up in
+            // document and prevent rapidjson from writing out valid JSON
+            if (!std::isfinite(valueTmp)) {
+                continue;
+            }
+
+            if (valueTmp < acc->min[j]) {
+                acc->min[j] = valueTmp;
+            }
+            if (valueTmp > acc->max[j]) {
+                acc->max[j] = valueTmp;
+            }
+        }
+    }
+}
+
+inline void SetAccessorRange(ComponentType compType, Ref<Accessor> acc, void *data,
+        size_t count, unsigned int numCompsIn, unsigned int numCompsOut) {
+    switch (compType) {
+    case ComponentType_SHORT:
+        SetAccessorRange<short>(acc, data, count, numCompsIn, numCompsOut);
+        return;
+    case ComponentType_UNSIGNED_SHORT:
+        SetAccessorRange<unsigned short>(acc, data, count, numCompsIn, numCompsOut);
+        return;
+    case ComponentType_UNSIGNED_INT:
+        SetAccessorRange<unsigned int>(acc, data, count, numCompsIn, numCompsOut);
+        return;
+    case ComponentType_FLOAT:
+        SetAccessorRange<float>(acc, data, count, numCompsIn, numCompsOut);
+        return;
+    case ComponentType_BYTE:
+        SetAccessorRange<int8_t>(acc, data, count, numCompsIn, numCompsOut);
+        return;
+    case ComponentType_UNSIGNED_BYTE:
+        SetAccessorRange<uint8_t>(acc, data, count, numCompsIn, numCompsOut);
+        return;
+    }
+}
+
+// compute the (data-dataBase), store the non-zero data items
+template <typename T>
+size_t NZDiff(void *data, void *dataBase, size_t count, unsigned int numCompsIn, unsigned int numCompsOut, void *&outputNZDiff, void *&outputNZIdx) {
+    std::vector<T> vNZDiff;
+    std::vector<unsigned short> vNZIdx;
+    size_t totalComps = count * numCompsIn;
+    T *bufferData_ptr = static_cast<T *>(data);
+    T *bufferData_end = bufferData_ptr + totalComps;
+    T *bufferBase_ptr = static_cast<T *>(dataBase);
+
+    // Search and set extreme values.
+    for (short idx = 0; bufferData_ptr < bufferData_end; idx += 1, bufferData_ptr += numCompsIn) {
+        bool bNonZero = false;
+
+        //for the data, check any component Non Zero
+        for (unsigned int j = 0; j < numCompsOut; j++) {
+            double valueData = bufferData_ptr[j];
+            double valueBase = bufferBase_ptr ? bufferBase_ptr[j] : 0;
+            if ((valueData - valueBase) != 0) {
+                bNonZero = true;
+                break;
+            }
+        }
+
+        //all zeros, continue
+        if (!bNonZero)
+            continue;
+
+        //non zero, store the data
+        for (unsigned int j = 0; j < numCompsOut; j++) {
+            T valueData = bufferData_ptr[j];
+            T valueBase = bufferBase_ptr ? bufferBase_ptr[j] : 0;
+            vNZDiff.push_back(valueData - valueBase);
+        }
+        vNZIdx.push_back(idx);
+    }
+
+    //avoid all-0, put 1 item
+    if (vNZDiff.size() == 0) {
+        for (unsigned int j = 0; j < numCompsOut; j++)
+            vNZDiff.push_back(0);
+        vNZIdx.push_back(0);
+    }
+
+    //process data
+    outputNZDiff = new T[vNZDiff.size()];
+    memcpy(outputNZDiff, vNZDiff.data(), vNZDiff.size() * sizeof(T));
+
+    outputNZIdx = new unsigned short[vNZIdx.size()];
+    memcpy(outputNZIdx, vNZIdx.data(), vNZIdx.size() * sizeof(unsigned short));
+    return vNZIdx.size();
+}
+
+inline size_t NZDiff(ComponentType compType, void *data, void *dataBase, size_t count, unsigned int numCompsIn, unsigned int numCompsOut, void *&nzDiff, void *&nzIdx) {
+    switch (compType) {
+    case ComponentType_SHORT:
+        return NZDiff<short>(data, dataBase, count, numCompsIn, numCompsOut, nzDiff, nzIdx);
+    case ComponentType_UNSIGNED_SHORT:
+        return NZDiff<unsigned short>(data, dataBase, count, numCompsIn, numCompsOut, nzDiff, nzIdx);
+    case ComponentType_UNSIGNED_INT:
+        return NZDiff<unsigned int>(data, dataBase, count, numCompsIn, numCompsOut, nzDiff, nzIdx);
+    case ComponentType_FLOAT:
+        return NZDiff<float>(data, dataBase, count, numCompsIn, numCompsOut, nzDiff, nzIdx);
+    case ComponentType_BYTE:
+        return NZDiff<int8_t>(data, dataBase, count, numCompsIn, numCompsOut, nzDiff, nzIdx);
+    case ComponentType_UNSIGNED_BYTE:
+        return NZDiff<uint8_t>(data, dataBase, count, numCompsIn, numCompsOut, nzDiff, nzIdx);
+    }
+    return 0;
+}
+
+inline Ref<Accessor> ExportDataSparse(Asset &a, std::string &meshName, Ref<Buffer> &buffer,
+        size_t count, void *data, AttribType::Value typeIn, AttribType::Value typeOut, ComponentType compType, BufferViewTarget target = BufferViewTarget_NONE, void *dataBase = 0) {
+    if (!count || !data) {
+        return Ref<Accessor>();
+    }
+
+    unsigned int numCompsIn = AttribType::GetNumComponents(typeIn);
+    unsigned int numCompsOut = AttribType::GetNumComponents(typeOut);
+    unsigned int bytesPerComp = ComponentTypeSize(compType);
+
+    // accessor
+    Ref<Accessor> acc = a.accessors.Create(a.FindUniqueID(meshName, "accessor"));
+
+    // if there is a basic data vector
+    if (dataBase) {
+        size_t base_offset = buffer->byteLength;
+        size_t base_padding = base_offset % bytesPerComp;
+        base_offset += base_padding;
+        size_t base_length = count * numCompsOut * bytesPerComp;
+        buffer->Grow(base_length + base_padding);
+
+        Ref<BufferView> bv = a.bufferViews.Create(a.FindUniqueID(meshName, "view"));
+        bv->buffer = buffer;
+        bv->byteOffset = base_offset;
+        bv->byteLength = base_length; //! The target that the WebGL buffer should be bound to.
+        bv->byteStride = 0;
+        bv->target = target;
+        acc->bufferView = bv;
+        acc->WriteData(count, dataBase, numCompsIn * bytesPerComp);
+    }
+    acc->byteOffset = 0;
+    acc->componentType = compType;
+    acc->count = count;
+    acc->type = typeOut;
+
+    if (data) {
+        void *nzDiff = 0, *nzIdx = 0;
+        size_t nzCount = NZDiff(compType, data, dataBase, count, numCompsIn, numCompsOut, nzDiff, nzIdx);
+        acc->sparse.reset(new Accessor::Sparse);
+        acc->sparse->count = nzCount;
+
+        //indices
+        unsigned int bytesPerIdx = sizeof(unsigned short);
+        size_t indices_offset = buffer->byteLength;
+        size_t indices_padding = indices_offset % bytesPerIdx;
+        indices_offset += indices_padding;
+        size_t indices_length = nzCount * 1 * bytesPerIdx;
+        buffer->Grow(indices_length + indices_padding);
+
+        Ref<BufferView> indicesBV = a.bufferViews.Create(a.FindUniqueID(meshName, "view"));
+        indicesBV->buffer = buffer;
+        indicesBV->byteOffset = indices_offset;
+        indicesBV->byteLength = indices_length;
+        indicesBV->byteStride = 0;
+        acc->sparse->indices = indicesBV;
+        acc->sparse->indicesType = ComponentType_UNSIGNED_SHORT;
+        acc->sparse->indicesByteOffset = 0;
+        acc->WriteSparseIndices(nzCount, nzIdx, 1 * bytesPerIdx);
+
+        //values
+        size_t values_offset = buffer->byteLength;
+        size_t values_padding = values_offset % bytesPerComp;
+        values_offset += values_padding;
+        size_t values_length = nzCount * numCompsOut * bytesPerComp;
+        buffer->Grow(values_length + values_padding);
+
+        Ref<BufferView> valuesBV = a.bufferViews.Create(a.FindUniqueID(meshName, "view"));
+        valuesBV->buffer = buffer;
+        valuesBV->byteOffset = values_offset;
+        valuesBV->byteLength = values_length;
+        valuesBV->byteStride = 0;
+        acc->sparse->values = valuesBV;
+        acc->sparse->valuesByteOffset = 0;
+        acc->WriteSparseValues(nzCount, nzDiff, numCompsIn * bytesPerComp);
+
+        //clear
+        delete[](char *) nzDiff;
+        delete[](char *) nzIdx;
+    }
+    return acc;
+}
+inline Ref<Accessor> ExportData(Asset &a, std::string &meshName, Ref<Buffer> &buffer,
+        size_t count, void *data, AttribType::Value typeIn, AttribType::Value typeOut, ComponentType compType, BufferViewTarget target = BufferViewTarget_NONE) {
+    if (!count || !data) {
+        return Ref<Accessor>();
+    }
+
+    unsigned int numCompsIn = AttribType::GetNumComponents(typeIn);
+    unsigned int numCompsOut = AttribType::GetNumComponents(typeOut);
+    unsigned int bytesPerComp = ComponentTypeSize(compType);
+
+    size_t offset = buffer->byteLength;
+    // make sure offset is correctly byte-aligned, as required by spec
+    size_t padding = offset % bytesPerComp;
+    offset += padding;
+    size_t length = count * numCompsOut * bytesPerComp;
+    buffer->Grow(length + padding);
+
+    // bufferView
+    Ref<BufferView> bv = a.bufferViews.Create(a.FindUniqueID(meshName, "view"));
+    bv->buffer = buffer;
+    bv->byteOffset = offset;
+    bv->byteLength = length; //! The target that the WebGL buffer should be bound to.
+    bv->byteStride = 0;
+    bv->target = target;
+
+    // accessor
+    Ref<Accessor> acc = a.accessors.Create(a.FindUniqueID(meshName, "accessor"));
+    acc->bufferView = bv;
+    acc->byteOffset = 0;
+    acc->componentType = compType;
+    acc->count = count;
+    acc->type = typeOut;
+
+    // calculate min and max values
+    SetAccessorRange(compType, acc, data, count, numCompsIn, numCompsOut);
+
+    // copy the data
+    acc->WriteData(count, data, numCompsIn * bytesPerComp);
+
+    return acc;
+}
+
+inline void SetSamplerWrap(SamplerWrap &wrap, aiTextureMapMode map) {
+    switch (map) {
+    case aiTextureMapMode_Clamp:
+        wrap = SamplerWrap::Clamp_To_Edge;
+        break;
+    case aiTextureMapMode_Mirror:
+        wrap = SamplerWrap::Mirrored_Repeat;
+        break;
+    case aiTextureMapMode_Wrap:
+    case aiTextureMapMode_Decal:
+    default:
+        wrap = SamplerWrap::Repeat;
+        break;
+    };
+}
+
+void glTF2Exporter::GetTexSampler(const aiMaterial &mat, Ref<Texture> texture, aiTextureType tt, unsigned int slot) {
+    aiString aId;
+    std::string id;
+    if (aiGetMaterialString(&mat, AI_MATKEY_GLTF_MAPPINGID(tt, slot), &aId) == AI_SUCCESS) {
+        id = aId.C_Str();
+    }
+
+    if (Ref<Sampler> ref = mAsset->samplers.Get(id.c_str())) {
+        texture->sampler = ref;
+    } else {
+        id = mAsset->FindUniqueID(id, "sampler");
+
+        texture->sampler = mAsset->samplers.Create(id.c_str());
+
+        aiTextureMapMode mapU, mapV;
+        SamplerMagFilter filterMag;
+        SamplerMinFilter filterMin;
+
+        if (aiGetMaterialInteger(&mat, AI_MATKEY_MAPPINGMODE_U(tt, slot), (int *)&mapU) == AI_SUCCESS) {
+            SetSamplerWrap(texture->sampler->wrapS, mapU);
+        }
+
+        if (aiGetMaterialInteger(&mat, AI_MATKEY_MAPPINGMODE_V(tt, slot), (int *)&mapV) == AI_SUCCESS) {
+            SetSamplerWrap(texture->sampler->wrapT, mapV);
+        }
+
+        if (aiGetMaterialInteger(&mat, AI_MATKEY_GLTF_MAPPINGFILTER_MAG(tt, slot), (int *)&filterMag) == AI_SUCCESS) {
+            texture->sampler->magFilter = filterMag;
+        }
+
+        if (aiGetMaterialInteger(&mat, AI_MATKEY_GLTF_MAPPINGFILTER_MIN(tt, slot), (int *)&filterMin) == AI_SUCCESS) {
+            texture->sampler->minFilter = filterMin;
+        }
+
+        aiString name;
+        if (aiGetMaterialString(&mat, AI_MATKEY_GLTF_MAPPINGNAME(tt, slot), &name) == AI_SUCCESS) {
+            texture->sampler->name = name.C_Str();
+        }
+    }
+}
+
+void glTF2Exporter::GetMatTexProp(const aiMaterial &mat, unsigned int &prop, const char *propName, aiTextureType tt, unsigned int slot) {
+    std::string textureKey = std::string(_AI_MATKEY_TEXTURE_BASE) + "." + propName;
+
+    mat.Get(textureKey.c_str(), tt, slot, prop);
+}
+
+void glTF2Exporter::GetMatTexProp(const aiMaterial &mat, float &prop, const char *propName, aiTextureType tt, unsigned int slot) {
+    std::string textureKey = std::string(_AI_MATKEY_TEXTURE_BASE) + "." + propName;
+
+    mat.Get(textureKey.c_str(), tt, slot, prop);
+}
+
+void glTF2Exporter::GetMatTex(const aiMaterial &mat, Ref<Texture> &texture, unsigned int &texCoord, aiTextureType tt, unsigned int slot = 0) {
+    if (mat.GetTextureCount(tt) == 0) {
+        return;
+    }
+        
+    aiString tex;
+
+    // Read texcoord (UV map index)
+    mat.Get(AI_MATKEY_UVWSRC(tt, slot), texCoord);
+
+    if (mat.Get(AI_MATKEY_TEXTURE(tt, slot), tex) == AI_SUCCESS) {
+        std::string path = tex.C_Str();
+
+        if (path.size() > 0) {
+            std::map<std::string, unsigned int>::iterator it = mTexturesByPath.find(path);
+            if (it != mTexturesByPath.end()) {
+                texture = mAsset->textures.Get(it->second);
+            }
+
+            bool useBasisUniversal = false;
+            if (!texture) {
+                std::string texId = mAsset->FindUniqueID("", "texture");
+                texture = mAsset->textures.Create(texId);
+                mTexturesByPath[path] = texture.GetIndex();
+
+                std::string imgId = mAsset->FindUniqueID("", "image");
+                texture->source = mAsset->images.Create(imgId);
+
+                const aiTexture *curTex = mScene->GetEmbeddedTexture(path.c_str());
+                if (curTex != nullptr) { // embedded
+                    texture->source->name = curTex->mFilename.C_Str();
+
+                    //basisu: embedded ktx2, bu
+                    if (curTex->achFormatHint[0]) {
+                        std::string mimeType = "image/";
+                        if (memcmp(curTex->achFormatHint, "jpg", 3) == 0)
+                            mimeType += "jpeg";
+                        else if (memcmp(curTex->achFormatHint, "ktx", 3) == 0) {
+                            useBasisUniversal = true;
+                            mimeType += "ktx";
+                        } else if (memcmp(curTex->achFormatHint, "kx2", 3) == 0) {
+                            useBasisUniversal = true;
+                            mimeType += "ktx2";
+                        } else if (memcmp(curTex->achFormatHint, "bu", 2) == 0) {
+                            useBasisUniversal = true;
+                            mimeType += "basis";
+                        } else
+                            mimeType += curTex->achFormatHint;
+                        texture->source->mimeType = mimeType;
+                    }
+
+                    // The asset has its own buffer, see Image::SetData
+                    //basisu: "image/ktx2", "image/basis" as is
+                    texture->source->SetData(reinterpret_cast<uint8_t *>(curTex->pcData), curTex->mWidth, *mAsset);
+                } else {
+                    texture->source->uri = path;
+                    if (texture->source->uri.find(".ktx") != std::string::npos ||
+                            texture->source->uri.find(".basis") != std::string::npos) {
+                        useBasisUniversal = true;
+                    }
+                }
+
+                //basisu
+                if (useBasisUniversal) {
+                    mAsset->extensionsUsed.KHR_texture_basisu = true;
+                    mAsset->extensionsRequired.KHR_texture_basisu = true;
+                }
+
+                GetTexSampler(mat, texture, tt, slot);
+            }
+        }
+    }
+}
+
+void glTF2Exporter::GetMatTex(const aiMaterial &mat, TextureInfo &prop, aiTextureType tt, unsigned int slot = 0) {
+    Ref<Texture> &texture = prop.texture;
+    GetMatTex(mat, texture, prop.texCoord, tt, slot);
+}
+
+void glTF2Exporter::GetMatTex(const aiMaterial &mat, NormalTextureInfo &prop, aiTextureType tt, unsigned int slot = 0) {
+    Ref<Texture> &texture = prop.texture;
+
+    GetMatTex(mat, texture, prop.texCoord, tt, slot);
+
+    if (texture) {
+        //GetMatTexProp(mat, prop.texCoord, "texCoord", tt, slot);
+        GetMatTexProp(mat, prop.scale, "scale", tt, slot);
+    }
+}
+
+void glTF2Exporter::GetMatTex(const aiMaterial &mat, OcclusionTextureInfo &prop, aiTextureType tt, unsigned int slot = 0) {
+    Ref<Texture> &texture = prop.texture;
+
+    GetMatTex(mat, texture, prop.texCoord, tt, slot);
+
+    if (texture) {
+        //GetMatTexProp(mat, prop.texCoord, "texCoord", tt, slot);
+        GetMatTexProp(mat, prop.strength, "strength", tt, slot);
+    }
+}
+
+aiReturn glTF2Exporter::GetMatColor(const aiMaterial &mat, vec4 &prop, const char *propName, int type, int idx) const {
+    aiColor4D col;
+    aiReturn result = mat.Get(propName, type, idx, col);
+
+    if (result == AI_SUCCESS) {
+        prop[0] = col.r;
+        prop[1] = col.g;
+        prop[2] = col.b;
+        prop[3] = col.a;
+    }
+
+    return result;
+}
+
+aiReturn glTF2Exporter::GetMatColor(const aiMaterial &mat, vec3 &prop, const char *propName, int type, int idx) const {
+    aiColor3D col;
+    aiReturn result = mat.Get(propName, type, idx, col);
+
+    if (result == AI_SUCCESS) {
+        prop[0] = col.r;
+        prop[1] = col.g;
+        prop[2] = col.b;
+    }
+
+    return result;
+}
+
+bool glTF2Exporter::GetMatSpecGloss(const aiMaterial &mat, glTF2::PbrSpecularGlossiness &pbrSG) {
+    bool result = false;
+    // If has Glossiness, a Specular Color or Specular Texture, use the KHR_materials_pbrSpecularGlossiness extension
+    // NOTE: This extension is being considered for deprecation (Dec 2020), may be replaced by KHR_material_specular
+
+    if (mat.Get(AI_MATKEY_GLOSSINESS_FACTOR, pbrSG.glossinessFactor) == AI_SUCCESS) {
+        result = true;
+    } else {
+        // Don't have explicit glossiness, convert from pbr roughness or legacy shininess
+        float shininess;
+        if (mat.Get(AI_MATKEY_ROUGHNESS_FACTOR, shininess) == AI_SUCCESS) {
+            pbrSG.glossinessFactor = 1.0f - shininess; // Extension defines this way
+        } else if (mat.Get(AI_MATKEY_SHININESS, shininess) == AI_SUCCESS) {
+            pbrSG.glossinessFactor = shininess / 1000;
+        }
+    }
+
+    if (GetMatColor(mat, pbrSG.specularFactor, AI_MATKEY_COLOR_SPECULAR) == AI_SUCCESS) {
+        result = true;
+    }
+    // Add any appropriate textures
+    GetMatTex(mat, pbrSG.specularGlossinessTexture, aiTextureType_SPECULAR);
+
+    result = result || pbrSG.specularGlossinessTexture.texture;
+
+    if (result) {
+        // Likely to always have diffuse
+        GetMatTex(mat, pbrSG.diffuseTexture, aiTextureType_DIFFUSE);
+        GetMatColor(mat, pbrSG.diffuseFactor, AI_MATKEY_COLOR_DIFFUSE);
+    }
+
+    return result;
+}
+
+bool glTF2Exporter::GetMatSheen(const aiMaterial &mat, glTF2::MaterialSheen &sheen) {
+    // Return true if got any valid Sheen properties or textures
+    if (GetMatColor(mat, sheen.sheenColorFactor, AI_MATKEY_SHEEN_COLOR_FACTOR) != aiReturn_SUCCESS) {
+        return false;
+    }
+
+    // Default Sheen color factor {0,0,0} disables Sheen, so do not export
+    if (sheen.sheenColorFactor == defaultSheenFactor) {
+        return false;
+    }
+
+    mat.Get(AI_MATKEY_SHEEN_ROUGHNESS_FACTOR, sheen.sheenRoughnessFactor);
+
+    GetMatTex(mat, sheen.sheenColorTexture, AI_MATKEY_SHEEN_COLOR_TEXTURE);
+    GetMatTex(mat, sheen.sheenRoughnessTexture, AI_MATKEY_SHEEN_ROUGHNESS_TEXTURE);
+
+    return true;
+}
+
+bool glTF2Exporter::GetMatClearcoat(const aiMaterial &mat, glTF2::MaterialClearcoat &clearcoat) {
+    if (mat.Get(AI_MATKEY_CLEARCOAT_FACTOR, clearcoat.clearcoatFactor) != aiReturn_SUCCESS) {
+        return false;
+    }
+
+    // Clearcoat factor of zero disables Clearcoat, so do not export
+    if (clearcoat.clearcoatFactor == 0.0f)
+        return false;
+
+    mat.Get(AI_MATKEY_CLEARCOAT_ROUGHNESS_FACTOR, clearcoat.clearcoatRoughnessFactor);
+
+    GetMatTex(mat, clearcoat.clearcoatTexture, AI_MATKEY_CLEARCOAT_TEXTURE);
+    GetMatTex(mat, clearcoat.clearcoatRoughnessTexture, AI_MATKEY_CLEARCOAT_ROUGHNESS_TEXTURE);
+    GetMatTex(mat, clearcoat.clearcoatNormalTexture, AI_MATKEY_CLEARCOAT_NORMAL_TEXTURE);
+
+    return true;
+}
+
+bool glTF2Exporter::GetMatTransmission(const aiMaterial &mat, glTF2::MaterialTransmission &transmission) {
+    bool result = mat.Get(AI_MATKEY_TRANSMISSION_FACTOR, transmission.transmissionFactor) == aiReturn_SUCCESS;
+    GetMatTex(mat, transmission.transmissionTexture, AI_MATKEY_TRANSMISSION_TEXTURE);
+    return result || transmission.transmissionTexture.texture;
+}
+
+bool glTF2Exporter::GetMatVolume(const aiMaterial &mat, glTF2::MaterialVolume &volume) {
+    bool result = mat.Get(AI_MATKEY_VOLUME_THICKNESS_FACTOR, volume.thicknessFactor) != aiReturn_SUCCESS;
+
+    GetMatTex(mat, volume.thicknessTexture, AI_MATKEY_VOLUME_THICKNESS_TEXTURE);
+
+    result = result || mat.Get(AI_MATKEY_VOLUME_ATTENUATION_DISTANCE, volume.attenuationDistance);
+    result = result || GetMatColor(mat, volume.attenuationColor, AI_MATKEY_VOLUME_ATTENUATION_COLOR) != aiReturn_SUCCESS;
+
+    // Valid if any of these properties are available
+    return result || volume.thicknessTexture.texture;
+}
+
+bool glTF2Exporter::GetMatIOR(const aiMaterial &mat, glTF2::MaterialIOR &ior) {
+    return mat.Get(AI_MATKEY_REFRACTI, ior.ior) == aiReturn_SUCCESS;
+}
+
+void glTF2Exporter::ExportMaterials() {
+    aiString aiName;
+    for (unsigned int i = 0; i < mScene->mNumMaterials; ++i) {
+        ai_assert(mScene->mMaterials[i] != nullptr);
+
+        const aiMaterial &mat = *(mScene->mMaterials[i]);
+
+        std::string id = "material_" + ai_to_string(i);
+
+        Ref<Material> m = mAsset->materials.Create(id);
+
+        std::string name;
+        if (mat.Get(AI_MATKEY_NAME, aiName) == AI_SUCCESS) {
+            name = aiName.C_Str();
+        }
+        name = mAsset->FindUniqueID(name, "material");
+
+        m->name = name;
+
+        GetMatTex(mat, m->pbrMetallicRoughness.baseColorTexture, aiTextureType_BASE_COLOR);
+
+        if (!m->pbrMetallicRoughness.baseColorTexture.texture) {
+            //if there wasn't a baseColorTexture defined in the source, fallback to any diffuse texture
+            GetMatTex(mat, m->pbrMetallicRoughness.baseColorTexture, aiTextureType_DIFFUSE);
+        }
+
+        GetMatTex(mat, m->pbrMetallicRoughness.metallicRoughnessTexture, AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_METALLICROUGHNESS_TEXTURE);
+
+        if (GetMatColor(mat, m->pbrMetallicRoughness.baseColorFactor, AI_MATKEY_BASE_COLOR) != AI_SUCCESS) {
+            // if baseColorFactor wasn't defined, then the source is likely not a metallic roughness material.
+            //a fallback to any diffuse color should be used instead
+            GetMatColor(mat, m->pbrMetallicRoughness.baseColorFactor, AI_MATKEY_COLOR_DIFFUSE);
+        }
+
+        if (mat.Get(AI_MATKEY_METALLIC_FACTOR, m->pbrMetallicRoughness.metallicFactor) != AI_SUCCESS) {
+            //if metallicFactor wasn't defined, then the source is likely not a PBR file, and the metallicFactor should be 0
+            m->pbrMetallicRoughness.metallicFactor = 0;
+        }
+
+        // get roughness if source is gltf2 file
+        if (mat.Get(AI_MATKEY_ROUGHNESS_FACTOR, m->pbrMetallicRoughness.roughnessFactor) != AI_SUCCESS) {
+            // otherwise, try to derive and convert from specular + shininess values
+            aiColor4D specularColor;
+            ai_real shininess;
+
+            if (mat.Get(AI_MATKEY_COLOR_SPECULAR, specularColor) == AI_SUCCESS && mat.Get(AI_MATKEY_SHININESS, shininess) == AI_SUCCESS) {
+                // convert specular color to luminance
+                float specularIntensity = specularColor[0] * 0.2125f + specularColor[1] * 0.7154f + specularColor[2] * 0.0721f;
+                //normalize shininess (assuming max is 1000) with an inverse exponentional curve
+                float normalizedShininess = std::sqrt(shininess / 1000);
+
+                //clamp the shininess value between 0 and 1
+                normalizedShininess = std::min(std::max(normalizedShininess, 0.0f), 1.0f);
+                // low specular intensity values should produce a rough material even if shininess is high.
+                normalizedShininess = normalizedShininess * specularIntensity;
+
+                m->pbrMetallicRoughness.roughnessFactor = 1 - normalizedShininess;
+            }
+        }
+
+        GetMatTex(mat, m->normalTexture, aiTextureType_NORMALS);
+        GetMatTex(mat, m->occlusionTexture, aiTextureType_LIGHTMAP);
+        GetMatTex(mat, m->emissiveTexture, aiTextureType_EMISSIVE);
+        GetMatColor(mat, m->emissiveFactor, AI_MATKEY_COLOR_EMISSIVE);
+
+        mat.Get(AI_MATKEY_TWOSIDED, m->doubleSided);
+        mat.Get(AI_MATKEY_GLTF_ALPHACUTOFF, m->alphaCutoff);
+
+        float opacity;
+        aiString alphaMode;
+
+        if (mat.Get(AI_MATKEY_OPACITY, opacity) == AI_SUCCESS) {
+            if (opacity < 1) {
+                m->alphaMode = "BLEND";
+                m->pbrMetallicRoughness.baseColorFactor[3] *= opacity;
+            }
+        }
+        if (mat.Get(AI_MATKEY_GLTF_ALPHAMODE, alphaMode) == AI_SUCCESS) {
+            m->alphaMode = alphaMode.C_Str();
+        }
+
+        {
+            // KHR_materials_pbrSpecularGlossiness extension
+            // NOTE: This extension is being considered for deprecation (Dec 2020)
+            PbrSpecularGlossiness pbrSG;
+            if (GetMatSpecGloss(mat, pbrSG)) {
+                mAsset->extensionsUsed.KHR_materials_pbrSpecularGlossiness = true;
+                m->pbrSpecularGlossiness = Nullable<PbrSpecularGlossiness>(pbrSG);
+            }
+        }
+
+        // glTFv2 is either PBR or Unlit
+        aiShadingMode shadingMode = aiShadingMode_PBR_BRDF;
+        mat.Get(AI_MATKEY_SHADING_MODEL, shadingMode);
+        if (shadingMode == aiShadingMode_Unlit) {
+            mAsset->extensionsUsed.KHR_materials_unlit = true;
+            m->unlit = true;
+        } else {
+            // These extensions are not compatible with KHR_materials_unlit or KHR_materials_pbrSpecularGlossiness
+            if (!m->pbrSpecularGlossiness.isPresent) {
+                // Sheen
+                MaterialSheen sheen;
+                if (GetMatSheen(mat, sheen)) {
+                    mAsset->extensionsUsed.KHR_materials_sheen = true;
+                    m->materialSheen = Nullable<MaterialSheen>(sheen);
+                }
+
+                MaterialClearcoat clearcoat;
+                if (GetMatClearcoat(mat, clearcoat)) {
+                    mAsset->extensionsUsed.KHR_materials_clearcoat = true;
+                    m->materialClearcoat = Nullable<MaterialClearcoat>(clearcoat);
+                }
+
+                MaterialTransmission transmission;
+                if (GetMatTransmission(mat, transmission)) {
+                    mAsset->extensionsUsed.KHR_materials_transmission = true;
+                    m->materialTransmission = Nullable<MaterialTransmission>(transmission);
+                }
+                
+                MaterialVolume volume;
+                if (GetMatVolume(mat, volume)) {
+                    mAsset->extensionsUsed.KHR_materials_volume = true;
+                    m->materialVolume = Nullable<MaterialVolume>(volume);
+                }
+                                
+                MaterialIOR ior;
+                if (GetMatIOR(mat, ior)) {
+                    mAsset->extensionsUsed.KHR_materials_ior = true;
+                    m->materialIOR = Nullable<MaterialIOR>(ior);
+                }
+            }
+        }
+    }
+}
+
+/*
+ * Search through node hierarchy and find the node containing the given meshID.
+ * Returns true on success, and false otherwise.
+ */
+bool FindMeshNode(Ref<Node> &nodeIn, Ref<Node> &meshNode, const std::string &meshID) {
+    for (unsigned int i = 0; i < nodeIn->meshes.size(); ++i) {
+        if (meshID.compare(nodeIn->meshes[i]->id) == 0) {
+            meshNode = nodeIn;
+            return true;
+        }
+    }
+
+    for (unsigned int i = 0; i < nodeIn->children.size(); ++i) {
+        if (FindMeshNode(nodeIn->children[i], meshNode, meshID)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+/*
+ * Find the root joint of the skeleton.
+ * Starts will any joint node and traces up the tree,
+ * until a parent is found that does not have a jointName.
+ * Returns the first parent Ref<Node> found that does not have a jointName.
+ */
+Ref<Node> FindSkeletonRootJoint(Ref<Skin> &skinRef) {
+    Ref<Node> startNodeRef;
+    Ref<Node> parentNodeRef;
+
+    // Arbitrarily use the first joint to start the search.
+    startNodeRef = skinRef->jointNames[0];
+    parentNodeRef = skinRef->jointNames[0];
+
+    do {
+        startNodeRef = parentNodeRef;
+        parentNodeRef = startNodeRef->parent;
+    } while (!parentNodeRef->jointName.empty());
+
+    return parentNodeRef;
+}
+
+void ExportSkin(Asset &mAsset, const aiMesh *aimesh, Ref<Mesh> &meshRef, Ref<Buffer> &bufferRef, Ref<Skin> &skinRef, 
+        std::vector<aiMatrix4x4> &inverseBindMatricesData) {
+    if (aimesh->mNumBones < 1) {
+        return;
+    }
+
+    // Store the vertex joint and weight data.
+    const size_t NumVerts(aimesh->mNumVertices);
+    vec4 *vertexJointData = new vec4[NumVerts];
+    vec4 *vertexWeightData = new vec4[NumVerts];
+    int *jointsPerVertex = new int[NumVerts];
+    for (size_t i = 0; i < NumVerts; ++i) {
+        jointsPerVertex[i] = 0;
+        for (size_t j = 0; j < 4; ++j) {
+            vertexJointData[i][j] = 0;
+            vertexWeightData[i][j] = 0;
+        }
+    }
+
+    for (unsigned int idx_bone = 0; idx_bone < aimesh->mNumBones; ++idx_bone) {
+        const aiBone *aib = aimesh->mBones[idx_bone];
+
+        // aib->mName   =====>  skinRef->jointNames
+        // Find the node with id = mName.
+        Ref<Node> nodeRef = mAsset.nodes.Get(aib->mName.C_Str());
+        nodeRef->jointName = nodeRef->name;
+
+        unsigned int jointNamesIndex = 0;
+        bool addJointToJointNames = true;
+        for (unsigned int idx_joint = 0; idx_joint < skinRef->jointNames.size(); ++idx_joint) {
+            if (skinRef->jointNames[idx_joint]->jointName.compare(nodeRef->jointName) == 0) {
+                addJointToJointNames = false;
+                jointNamesIndex = idx_joint;
+            }
+        }
+
+        if (addJointToJointNames) {
+            skinRef->jointNames.push_back(nodeRef);
+
+            // aib->mOffsetMatrix   =====>  skinRef->inverseBindMatrices
+            aiMatrix4x4 tmpMatrix4;
+            CopyValue(aib->mOffsetMatrix, tmpMatrix4);
+            inverseBindMatricesData.push_back(tmpMatrix4);
+            jointNamesIndex = static_cast<unsigned int>(inverseBindMatricesData.size() - 1);
+        }
+
+        // aib->mWeights   =====>  vertexWeightData
+        for (unsigned int idx_weights = 0; idx_weights < aib->mNumWeights; ++idx_weights) {
+            unsigned int vertexId = aib->mWeights[idx_weights].mVertexId;
+            float vertWeight = aib->mWeights[idx_weights].mWeight;
+
+            // A vertex can only have at most four joint weights, which ideally sum up to 1
+            if (IsBoneWeightFitted(vertexWeightData[vertexId])) {
+                continue;
+            }
+            if (jointsPerVertex[vertexId] > 3) {
+                int boneIndexFitted = FitBoneWeight(vertexWeightData[vertexId], vertWeight);
+                if (boneIndexFitted != -1) {
+                    vertexJointData[vertexId][boneIndexFitted] = static_cast<float>(jointNamesIndex);
+                }
+            }else {
+                vertexJointData[vertexId][jointsPerVertex[vertexId]] = static_cast<float>(jointNamesIndex);
+                vertexWeightData[vertexId][jointsPerVertex[vertexId]] = vertWeight;
+
+                jointsPerVertex[vertexId] += 1;   
+            }
+        }
+
+    } // End: for-loop mNumMeshes
+
+    Mesh::Primitive &p = meshRef->primitives.back();
+    Ref<Accessor> vertexJointAccessor = ExportData(mAsset, skinRef->id, bufferRef, aimesh->mNumVertices, 
+        vertexJointData, AttribType::VEC4, AttribType::VEC4, ComponentType_FLOAT);
+    if (vertexJointAccessor) {
+        size_t offset = vertexJointAccessor->bufferView->byteOffset;
+        size_t bytesLen = vertexJointAccessor->bufferView->byteLength;
+        unsigned int s_bytesPerComp = ComponentTypeSize(ComponentType_UNSIGNED_SHORT);
+        unsigned int bytesPerComp = ComponentTypeSize(vertexJointAccessor->componentType);
+        size_t s_bytesLen = bytesLen * s_bytesPerComp / bytesPerComp;
+        Ref<Buffer> buf = vertexJointAccessor->bufferView->buffer;
+        uint8_t *arrys = new uint8_t[bytesLen];
+        unsigned int i = 0;
+        for (unsigned int j = 0; j < bytesLen; j += bytesPerComp) {
+            size_t len_p = offset + j;
+            float f_value = *(float *)&buf->GetPointer()[len_p];
+            unsigned short c = static_cast<unsigned short>(f_value);
+            memcpy(&arrys[i * s_bytesPerComp], &c, s_bytesPerComp);
+            ++i;
+        }
+        buf->ReplaceData_joint(offset, bytesLen, arrys, bytesLen);
+        vertexJointAccessor->componentType = ComponentType_UNSIGNED_SHORT;
+        vertexJointAccessor->bufferView->byteLength = s_bytesLen;
+
+        p.attributes.joint.push_back(vertexJointAccessor);
+        delete[] arrys;
+    }
+
+    Ref<Accessor> vertexWeightAccessor = ExportData(mAsset, skinRef->id, bufferRef, aimesh->mNumVertices,
+            vertexWeightData, AttribType::VEC4, AttribType::VEC4, ComponentType_FLOAT);
+    if (vertexWeightAccessor) {
+        p.attributes.weight.push_back(vertexWeightAccessor);
+    }
+    delete[] jointsPerVertex;
+    delete[] vertexWeightData;
+    delete[] vertexJointData;
+}
+
+void glTF2Exporter::ExportMeshes() {
+    typedef decltype(aiFace::mNumIndices) IndicesType;
+
+    std::string fname = std::string(mFilename);
+    std::string bufferIdPrefix = fname.substr(0, fname.rfind(".gltf"));
+    std::string bufferId = mAsset->FindUniqueID("", bufferIdPrefix.c_str());
+
+    Ref<Buffer> b = mAsset->GetBodyBuffer();
+    if (!b) {
+        b = mAsset->buffers.Create(bufferId);
+    }
+
+    //----------------------------------------
+    // Initialize variables for the skin
+    bool createSkin = false;
+    for (unsigned int idx_mesh = 0; idx_mesh < mScene->mNumMeshes; ++idx_mesh) {
+        const aiMesh *aim = mScene->mMeshes[idx_mesh];
+        if (aim->HasBones()) {
+            createSkin = true;
+            break;
+        }
+    }
+
+    Ref<Skin> skinRef;
+    std::string skinName = mAsset->FindUniqueID("skin", "skin");
+    std::vector<aiMatrix4x4> inverseBindMatricesData;
+    if (createSkin) {
+        skinRef = mAsset->skins.Create(skinName);
+        skinRef->name = skinName;
+    }
+    //----------------------------------------
+
+    for (unsigned int idx_mesh = 0; idx_mesh < mScene->mNumMeshes; ++idx_mesh) {
+        const aiMesh *aim = mScene->mMeshes[idx_mesh];
+
+        std::string name = aim->mName.C_Str();
+
+        std::string meshId = mAsset->FindUniqueID(name, "mesh");
+        Ref<Mesh> m = mAsset->meshes.Create(meshId);
+        m->primitives.resize(1);
+        Mesh::Primitive &p = m->primitives.back();
+
+        m->name = name;
+
+        p.material = mAsset->materials.Get(aim->mMaterialIndex);
+        p.ngonEncoded = (aim->mPrimitiveTypes & aiPrimitiveType_NGONEncodingFlag) != 0;
+
+        /******************* Vertices ********************/
+        Ref<Accessor> v = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mVertices, AttribType::VEC3,
+            AttribType::VEC3, ComponentType_FLOAT, BufferViewTarget_ARRAY_BUFFER);
+        if (v) {
+            p.attributes.position.push_back(v);
+        }
+
+        /******************** Normals ********************/
+        // Normalize all normals as the validator can emit a warning otherwise
+        if (nullptr != aim->mNormals) {
+            for (auto i = 0u; i < aim->mNumVertices; ++i) {
+                aim->mNormals[i].NormalizeSafe();
+            }
+        }
+
+        Ref<Accessor> n = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mNormals, AttribType::VEC3, 
+            AttribType::VEC3, ComponentType_FLOAT, BufferViewTarget_ARRAY_BUFFER);
+        if (n) {
+            p.attributes.normal.push_back(n);
+        }
+
+        /************** Texture coordinates **************/
+        for (int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
+            if (!aim->HasTextureCoords(i)) {
+                continue;
+            }
+
+            // Flip UV y coords
+            if (aim->mNumUVComponents[i] > 1) {
+                for (unsigned int j = 0; j < aim->mNumVertices; ++j) {
+                    aim->mTextureCoords[i][j].y = 1 - aim->mTextureCoords[i][j].y;
+                }
+            }
+
+            if (aim->mNumUVComponents[i] > 0) {
+                AttribType::Value type = (aim->mNumUVComponents[i] == 2) ? AttribType::VEC2 : AttribType::VEC3;
+
+                Ref<Accessor> tc = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mTextureCoords[i], 
+                    AttribType::VEC3, type, ComponentType_FLOAT, BufferViewTarget_ARRAY_BUFFER);
+                if (tc) {
+                    p.attributes.texcoord.push_back(tc);
+                }
+            }
+        }
+
+        /*************** Vertex colors ****************/
+        for (unsigned int indexColorChannel = 0; indexColorChannel < aim->GetNumColorChannels(); ++indexColorChannel) {
+            Ref<Accessor> c = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mColors[indexColorChannel],
+                AttribType::VEC4, AttribType::VEC4, ComponentType_FLOAT, BufferViewTarget_ARRAY_BUFFER);
+            if (c) {
+                p.attributes.color.push_back(c);
+            }
+        }
+
+        /*************** Vertices indices ****************/
+        if (aim->mNumFaces > 0) {
+            std::vector<IndicesType> indices;
+            unsigned int nIndicesPerFace = aim->mFaces[0].mNumIndices;
+            indices.resize(aim->mNumFaces * nIndicesPerFace);
+            for (size_t i = 0; i < aim->mNumFaces; ++i) {
+                for (size_t j = 0; j < nIndicesPerFace; ++j) {
+                    indices[i * nIndicesPerFace + j] = IndicesType(aim->mFaces[i].mIndices[j]);
+                }
+            }
+
+            p.indices = ExportData(*mAsset, meshId, b, indices.size(), &indices[0], AttribType::SCALAR, AttribType::SCALAR, 
+                ComponentType_UNSIGNED_INT, BufferViewTarget_ELEMENT_ARRAY_BUFFER);
+        }
+
+        switch (aim->mPrimitiveTypes) {
+        case aiPrimitiveType_POLYGON:
+            p.mode = PrimitiveMode_TRIANGLES;
+            break; // TODO implement this
+        case aiPrimitiveType_LINE:
+            p.mode = PrimitiveMode_LINES;
+            break;
+        case aiPrimitiveType_POINT:
+            p.mode = PrimitiveMode_POINTS;
+            break;
+        default: // aiPrimitiveType_TRIANGLE
+            p.mode = PrimitiveMode_TRIANGLES;
+            break;
+        }
+
+        /*************** Skins ****************/
+        if (aim->HasBones()) {
+            ExportSkin(*mAsset, aim, m, b, skinRef, inverseBindMatricesData);
+        }
+
+        /*************** Targets for blendshapes ****************/
+        if (aim->mNumAnimMeshes > 0) {
+            bool bUseSparse = this->mProperties->HasPropertyBool("GLTF2_SPARSE_ACCESSOR_EXP") &&
+                              this->mProperties->GetPropertyBool("GLTF2_SPARSE_ACCESSOR_EXP");
+            bool bIncludeNormal = this->mProperties->HasPropertyBool("GLTF2_TARGET_NORMAL_EXP") &&
+                                  this->mProperties->GetPropertyBool("GLTF2_TARGET_NORMAL_EXP");
+            bool bExportTargetNames = this->mProperties->HasPropertyBool("GLTF2_TARGETNAMES_EXP") &&
+                                      this->mProperties->GetPropertyBool("GLTF2_TARGETNAMES_EXP");
+
+            p.targets.resize(aim->mNumAnimMeshes);
+            for (unsigned int am = 0; am < aim->mNumAnimMeshes; ++am) {
+                aiAnimMesh *pAnimMesh = aim->mAnimMeshes[am];
+                if (bExportTargetNames) {
+                    m->targetNames.emplace_back(pAnimMesh->mName.data);
+                }
+                // position
+                if (pAnimMesh->HasPositions()) {
+                    // NOTE: in gltf it is the diff stored
+                    aiVector3D *pPositionDiff = new aiVector3D[pAnimMesh->mNumVertices];
+                    for (unsigned int vt = 0; vt < pAnimMesh->mNumVertices; ++vt) {
+                        pPositionDiff[vt] = pAnimMesh->mVertices[vt] - aim->mVertices[vt];
+                    }
+                    Ref<Accessor> vec;
+                    if (bUseSparse) {
+                        vec = ExportDataSparse(*mAsset, meshId, b,
+                                pAnimMesh->mNumVertices, pPositionDiff,
+                                AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT);
+                    } else {
+                        vec = ExportData(*mAsset, meshId, b,
+                                pAnimMesh->mNumVertices, pPositionDiff,
+                                AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT);
+                    }
+                    if (vec) {
+                        p.targets[am].position.push_back(vec);
+                    }
+                    delete[] pPositionDiff;
+                }
+
+                // normal
+                if (pAnimMesh->HasNormals() && bIncludeNormal) {
+                    aiVector3D *pNormalDiff = new aiVector3D[pAnimMesh->mNumVertices];
+                    for (unsigned int vt = 0; vt < pAnimMesh->mNumVertices; ++vt) {
+                        pNormalDiff[vt] = pAnimMesh->mNormals[vt] - aim->mNormals[vt];
+                    }
+                    Ref<Accessor> vec;
+                    if (bUseSparse) {
+                        vec = ExportDataSparse(*mAsset, meshId, b,
+                                pAnimMesh->mNumVertices, pNormalDiff,
+                                AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT);
+                    } else {
+                        vec = ExportData(*mAsset, meshId, b,
+                                pAnimMesh->mNumVertices, pNormalDiff,
+                                AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT);
+                    }
+                    if (vec) {
+                        p.targets[am].normal.push_back(vec);
+                    }
+                    delete[] pNormalDiff;
+                }
+
+                // tangent?
+            }
+        }
+    }
+
+    //----------------------------------------
+    // Finish the skin
+    // Create the Accessor for skinRef->inverseBindMatrices
+    bool bAddCustomizedProperty = this->mProperties->HasPropertyBool("GLTF2_CUSTOMIZE_PROPERTY");
+    if (createSkin) {
+        mat4 *invBindMatrixData = new mat4[inverseBindMatricesData.size()];
+        for (unsigned int idx_joint = 0; idx_joint < inverseBindMatricesData.size(); ++idx_joint) {
+            CopyValue(inverseBindMatricesData[idx_joint], invBindMatrixData[idx_joint]);
+        }
+
+        Ref<Accessor> invBindMatrixAccessor = ExportData(*mAsset, skinName, b,
+                static_cast<unsigned int>(inverseBindMatricesData.size()),
+                invBindMatrixData, AttribType::MAT4, AttribType::MAT4, ComponentType_FLOAT);
+        if (invBindMatrixAccessor) {
+            skinRef->inverseBindMatrices = invBindMatrixAccessor;
+        }
+
+        // Identity Matrix   =====>  skinRef->bindShapeMatrix
+        // Temporary. Hard-coded identity matrix here
+        skinRef->bindShapeMatrix.isPresent = bAddCustomizedProperty;
+        IdentityMatrix4(skinRef->bindShapeMatrix.value);
+
+        // Find nodes that contain a mesh with bones and add "skeletons" and "skin" attributes to those nodes.
+        Ref<Node> rootNode = mAsset->nodes.Get(unsigned(0));
+        Ref<Node> meshNode;
+        for (unsigned int meshIndex = 0; meshIndex < mAsset->meshes.Size(); ++meshIndex) {
+            Ref<Mesh> mesh = mAsset->meshes.Get(meshIndex);
+            bool hasBones = false;
+            for (unsigned int i = 0; i < mesh->primitives.size(); ++i) {
+                if (!mesh->primitives[i].attributes.weight.empty()) {
+                    hasBones = true;
+                    break;
+                }
+            }
+            if (!hasBones) {
+                continue;
+            }
+            std::string meshID = mesh->id;
+            FindMeshNode(rootNode, meshNode, meshID);
+            Ref<Node> rootJoint = FindSkeletonRootJoint(skinRef);
+            if (bAddCustomizedProperty)
+                meshNode->skeletons.push_back(rootJoint);
+            meshNode->skin = skinRef;
+        }
+        delete[] invBindMatrixData;
+    }
+}
+
+// Merges a node's multiple meshes (with one primitive each) into one mesh with multiple primitives
+void glTF2Exporter::MergeMeshes() {
+    for (unsigned int n = 0; n < mAsset->nodes.Size(); ++n) {
+        Ref<Node> node = mAsset->nodes.Get(n);
+
+        unsigned int nMeshes = static_cast<unsigned int>(node->meshes.size());
+
+        //skip if it's 1 or less meshes per node
+        if (nMeshes > 1) {
+            Ref<Mesh> firstMesh = node->meshes.at(0);
+
+            //loop backwards to allow easy removal of a mesh from a node once it's merged
+            for (unsigned int m = nMeshes - 1; m >= 1; --m) {
+                Ref<Mesh> mesh = node->meshes.at(m);
+
+                //append this mesh's primitives to the first mesh's primitives
+                firstMesh->primitives.insert(
+                        firstMesh->primitives.end(),
+                        mesh->primitives.begin(),
+                        mesh->primitives.end());
+
+                //remove the mesh from the list of meshes
+                unsigned int removedIndex = mAsset->meshes.Remove(mesh->id.c_str());
+
+                //find the presence of the removed mesh in other nodes
+                for (unsigned int nn = 0; nn < mAsset->nodes.Size(); ++nn) {
+                    Ref<Node> curNode = mAsset->nodes.Get(nn);
+
+                    for (unsigned int mm = 0; mm < curNode->meshes.size(); ++mm) {
+                        Ref<Mesh> &meshRef = curNode->meshes.at(mm);
+                        unsigned int meshIndex = meshRef.GetIndex();
+
+                        if (meshIndex == removedIndex) {
+                            curNode->meshes.erase(curNode->meshes.begin() + mm);
+                        } else if (meshIndex > removedIndex) {
+                            Ref<Mesh> newMeshRef = mAsset->meshes.Get(meshIndex - 1);
+
+                            meshRef = newMeshRef;
+                        }
+                    }
+                }
+            }
+
+            //since we were looping backwards, reverse the order of merged primitives to their original order
+            std::reverse(firstMesh->primitives.begin() + 1, firstMesh->primitives.end());
+        }
+    }
+}
+
+/*
+ * Export the root node of the node hierarchy.
+ * Calls ExportNode for all children.
+ */
+unsigned int glTF2Exporter::ExportNodeHierarchy(const aiNode *n) {
+    Ref<Node> node = mAsset->nodes.Create(mAsset->FindUniqueID(n->mName.C_Str(), "node"));
+
+    node->name = n->mName.C_Str();
+
+    if (!n->mTransformation.IsIdentity()) {
+        node->matrix.isPresent = true;
+        CopyValue(n->mTransformation, node->matrix.value);
+    }
+
+    for (unsigned int i = 0; i < n->mNumMeshes; ++i) {
+        node->meshes.emplace_back(mAsset->meshes.Get(n->mMeshes[i]));
+    }
+
+    for (unsigned int i = 0; i < n->mNumChildren; ++i) {
+        unsigned int idx = ExportNode(n->mChildren[i], node);
+        node->children.emplace_back(mAsset->nodes.Get(idx));
+    }
+
+    return node.GetIndex();
+}
+
+/*
+ * Export node and recursively calls ExportNode for all children.
+ * Since these nodes are not the root node, we also export the parent Ref<Node>
+ */
+unsigned int glTF2Exporter::ExportNode(const aiNode *n, Ref<Node> &parent) {
+    std::string name = mAsset->FindUniqueID(n->mName.C_Str(), "node");
+    Ref<Node> node = mAsset->nodes.Create(name);
+
+    node->parent = parent;
+    node->name = name;
+
+    if (!n->mTransformation.IsIdentity()) {
+        if (mScene->mNumAnimations > 0 || (mProperties && mProperties->HasPropertyBool("GLTF2_NODE_IN_TRS"))) {
+            aiQuaternion quaternion;
+            n->mTransformation.Decompose(*reinterpret_cast<aiVector3D *>(&node->scale.value), quaternion, *reinterpret_cast<aiVector3D *>(&node->translation.value));
+
+            aiVector3D vector(static_cast<ai_real>(1.0f), static_cast<ai_real>(1.0f), static_cast<ai_real>(1.0f));
+            if (!reinterpret_cast<aiVector3D *>(&node->scale.value)->Equal(vector)) {
+                node->scale.isPresent = true;
+            }
+            if (!reinterpret_cast<aiVector3D *>(&node->translation.value)->Equal(vector)) {
+                node->translation.isPresent = true;
+            }
+            node->rotation.isPresent = true;
+            node->rotation.value[0] = quaternion.x;
+            node->rotation.value[1] = quaternion.y;
+            node->rotation.value[2] = quaternion.z;
+            node->rotation.value[3] = quaternion.w;
+            node->matrix.isPresent = false;
+        } else {
+            node->matrix.isPresent = true;
+            CopyValue(n->mTransformation, node->matrix.value);
+        }
+    }
+
+    for (unsigned int i = 0; i < n->mNumMeshes; ++i) {
+        node->meshes.emplace_back(mAsset->meshes.Get(n->mMeshes[i]));
+    }
+
+    for (unsigned int i = 0; i < n->mNumChildren; ++i) {
+        unsigned int idx = ExportNode(n->mChildren[i], node);
+        node->children.emplace_back(mAsset->nodes.Get(idx));
+    }
+
+    return node.GetIndex();
+}
+
+void glTF2Exporter::ExportScene() {
+    // Use the name of the scene if specified
+    const std::string sceneName = (mScene->mName.length > 0) ? mScene->mName.C_Str() : "defaultScene";
+
+    // Ensure unique
+    Ref<Scene> scene = mAsset->scenes.Create(mAsset->FindUniqueID(sceneName, ""));
+
+    // root node will be the first one exported (idx 0)
+    if (mAsset->nodes.Size() > 0) {
+        scene->nodes.emplace_back(mAsset->nodes.Get(0u));
+    }
+
+    // set as the default scene
+    mAsset->scene = scene;
+}
+
+void glTF2Exporter::ExportMetadata() {
+    AssetMetadata &asset = mAsset->asset;
+    asset.version = "2.0";
+
+    char buffer[256];
+    ai_snprintf(buffer, 256, "Open Asset Import Library (assimp v%d.%d.%x)",
+            aiGetVersionMajor(), aiGetVersionMinor(), aiGetVersionRevision());
+
+    asset.generator = buffer;
+
+    // Copyright
+    aiString copyright_str;
+    if (mScene->mMetaData != nullptr && mScene->mMetaData->Get(AI_METADATA_SOURCE_COPYRIGHT, copyright_str)) {
+        asset.copyright = copyright_str.C_Str();
+    }
+}
+
+inline Ref<Accessor> GetSamplerInputRef(Asset &asset, std::string &animId, Ref<Buffer> &buffer, std::vector<ai_real> &times) {
+    return ExportData(asset, animId, buffer, (unsigned int)times.size(), &times[0], AttribType::SCALAR, AttribType::SCALAR, ComponentType_FLOAT);
+}
+
+inline void ExtractTranslationSampler(Asset &asset, std::string &animId, Ref<Buffer> &buffer, const aiNodeAnim *nodeChannel, float ticksPerSecond, Animation::Sampler &sampler) {
+    const unsigned int numKeyframes = nodeChannel->mNumPositionKeys;
+
+    std::vector<ai_real> times(numKeyframes);
+    std::vector<ai_real> values(numKeyframes * 3);
+    for (unsigned int i = 0; i < numKeyframes; ++i) {
+        const aiVectorKey &key = nodeChannel->mPositionKeys[i];
+        // mTime is measured in ticks, but GLTF time is measured in seconds, so convert.
+        times[i] = static_cast<float>(key.mTime / ticksPerSecond);
+        values[(i * 3) + 0] = (ai_real) key.mValue.x;
+        values[(i * 3) + 1] = (ai_real) key.mValue.y;
+        values[(i * 3) + 2] = (ai_real) key.mValue.z;
+    }
+
+    sampler.input = GetSamplerInputRef(asset, animId, buffer, times);
+    sampler.output = ExportData(asset, animId, buffer, numKeyframes, &values[0], AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT);
+    sampler.interpolation = Interpolation_LINEAR;
+}
+
+inline void ExtractScaleSampler(Asset &asset, std::string &animId, Ref<Buffer> &buffer, const aiNodeAnim *nodeChannel, float ticksPerSecond, Animation::Sampler &sampler) {
+    const unsigned int numKeyframes = nodeChannel->mNumScalingKeys;
+
+    std::vector<ai_real> times(numKeyframes);
+    std::vector<ai_real> values(numKeyframes * 3);
+    for (unsigned int i = 0; i < numKeyframes; ++i) {
+        const aiVectorKey &key = nodeChannel->mScalingKeys[i];
+        // mTime is measured in ticks, but GLTF time is measured in seconds, so convert.
+        times[i] = static_cast<float>(key.mTime / ticksPerSecond);
+        values[(i * 3) + 0] = (ai_real) key.mValue.x;
+        values[(i * 3) + 1] = (ai_real) key.mValue.y;
+        values[(i * 3) + 2] = (ai_real) key.mValue.z;
+    }
+
+    sampler.input = GetSamplerInputRef(asset, animId, buffer, times);
+    sampler.output = ExportData(asset, animId, buffer, numKeyframes, &values[0], AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT);
+    sampler.interpolation = Interpolation_LINEAR;
+}
+
+inline void ExtractRotationSampler(Asset &asset, std::string &animId, Ref<Buffer> &buffer, const aiNodeAnim *nodeChannel, float ticksPerSecond, Animation::Sampler &sampler) {
+    const unsigned int numKeyframes = nodeChannel->mNumRotationKeys;
+
+    std::vector<ai_real> times(numKeyframes);
+    std::vector<ai_real> values(numKeyframes * 4);
+    for (unsigned int i = 0; i < numKeyframes; ++i) {
+        const aiQuatKey &key = nodeChannel->mRotationKeys[i];
+        // mTime is measured in ticks, but GLTF time is measured in seconds, so convert.
+        times[i] = static_cast<float>(key.mTime / ticksPerSecond);
+        values[(i * 4) + 0] = (ai_real) key.mValue.x;
+        values[(i * 4) + 1] = (ai_real) key.mValue.y;
+        values[(i * 4) + 2] = (ai_real) key.mValue.z;
+        values[(i * 4) + 3] = (ai_real) key.mValue.w;
+    }
+
+    sampler.input = GetSamplerInputRef(asset, animId, buffer, times);
+    sampler.output = ExportData(asset, animId, buffer, numKeyframes, &values[0], AttribType::VEC4, AttribType::VEC4, ComponentType_FLOAT);
+    sampler.interpolation = Interpolation_LINEAR;
+}
+
+static void AddSampler(Ref<Animation> &animRef, Ref<Node> &nodeRef, Animation::Sampler &sampler, AnimationPath path) {
+    Animation::Channel channel;
+    channel.sampler = static_cast<int>(animRef->samplers.size());
+    channel.target.path = path;
+    channel.target.node = nodeRef;
+    animRef->channels.push_back(channel);
+    animRef->samplers.push_back(sampler);
+}
+
+void glTF2Exporter::ExportAnimations() {
+    Ref<Buffer> bufferRef = mAsset->buffers.Get(unsigned(0));
+
+    for (unsigned int i = 0; i < mScene->mNumAnimations; ++i) {
+        const aiAnimation *anim = mScene->mAnimations[i];
+        const float ticksPerSecond = static_cast<float>(anim->mTicksPerSecond);
+
+        std::string nameAnim = "anim";
+        if (anim->mName.length > 0) {
+            nameAnim = anim->mName.C_Str();
+        }
+        Ref<Animation> animRef = mAsset->animations.Create(nameAnim);
+        animRef->name = nameAnim;
+
+        for (unsigned int channelIndex = 0; channelIndex < anim->mNumChannels; ++channelIndex) {
+            const aiNodeAnim *nodeChannel = anim->mChannels[channelIndex];
+
+            std::string name = nameAnim + "_" + ai_to_string(channelIndex);
+            name = mAsset->FindUniqueID(name, "animation");
+
+            Ref<Node> animNode = mAsset->nodes.Get(nodeChannel->mNodeName.C_Str());
+
+            if (nodeChannel->mNumPositionKeys > 0) {
+                Animation::Sampler translationSampler;
+                ExtractTranslationSampler(*mAsset, name, bufferRef, nodeChannel, ticksPerSecond, translationSampler);
+                AddSampler(animRef, animNode, translationSampler, AnimationPath_TRANSLATION);
+            }
+
+            if (nodeChannel->mNumRotationKeys > 0) {
+                Animation::Sampler rotationSampler;
+                ExtractRotationSampler(*mAsset, name, bufferRef, nodeChannel, ticksPerSecond, rotationSampler);
+                AddSampler(animRef, animNode, rotationSampler, AnimationPath_ROTATION);
+            }
+
+            if (nodeChannel->mNumScalingKeys > 0) {
+                Animation::Sampler scaleSampler;
+                ExtractScaleSampler(*mAsset, name, bufferRef, nodeChannel, ticksPerSecond, scaleSampler);
+                AddSampler(animRef, animNode, scaleSampler, AnimationPath_SCALE);
+            }
+        }
+    } // End: for-loop mNumAnimations
+}
+
+#endif // ASSIMP_BUILD_NO_GLTF_EXPORTER
+#endif // ASSIMP_BUILD_NO_EXPORT
diff --git a/Engine/lib/assimp/code/AssetLib/glTF2/glTF2Exporter.h b/Engine/lib/assimp/code/AssetLib/glTF2/glTF2Exporter.h
new file mode 100644
index 000000000..99425228e
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/glTF2/glTF2Exporter.h
@@ -0,0 +1,147 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file GltfExporter.h
+* Declares the exporter class to write a scene to a gltf/glb file
+*/
+#ifndef AI_GLTF2EXPORTER_H_INC
+#define AI_GLTF2EXPORTER_H_INC
+
+#if !defined(ASSIMP_BUILD_NO_GLTF_IMPORTER) && !defined(ASSIMP_BUILD_NO_GLTF2_IMPORTER)
+
+#include <assimp/material.h>
+#include <assimp/types.h>
+
+#include <map>
+#include <memory>
+#include <sstream>
+#include <vector>
+
+struct aiScene;
+struct aiNode;
+struct aiMaterial;
+
+namespace glTFCommon {
+template <class T>
+class Ref;
+
+}
+
+namespace glTF2 {
+
+class Asset;
+
+struct TexProperty;
+struct TextureInfo;
+struct NormalTextureInfo;
+struct OcclusionTextureInfo;
+struct Node;
+struct Texture;
+struct PbrSpecularGlossiness;
+struct MaterialSheen;
+struct MaterialClearcoat;
+struct MaterialTransmission;
+struct MaterialVolume;
+struct MaterialIOR;
+
+// Vec/matrix types, as raw float arrays
+typedef float(vec2)[2];
+typedef float(vec3)[3];
+typedef float(vec4)[4];
+
+} // namespace glTF2
+
+namespace Assimp {
+class IOSystem;
+class IOStream;
+class ExportProperties;
+
+// ------------------------------------------------------------------------------------------------
+/** Helper class to export a given scene to an glTF file. */
+// ------------------------------------------------------------------------------------------------
+class glTF2Exporter {
+public:
+    /// Constructor for a specific scene to export
+    glTF2Exporter(const char *filename, IOSystem *pIOSystem, const aiScene *pScene,
+            const ExportProperties *pProperties, bool binary);
+    ~glTF2Exporter();
+
+protected:
+    void WriteBinaryData(IOStream *outfile, std::size_t sceneLength);
+    void GetTexSampler(const aiMaterial &mat, glTFCommon::Ref<glTF2::Texture> texture, aiTextureType tt, unsigned int slot);
+    void GetMatTexProp(const aiMaterial &mat, unsigned int &prop, const char *propName, aiTextureType tt, unsigned int idx);
+    void GetMatTexProp(const aiMaterial &mat, float &prop, const char *propName, aiTextureType tt, unsigned int idx);
+    void GetMatTex(const aiMaterial &mat, glTFCommon::Ref<glTF2::Texture> &texture, unsigned int &texCoord, aiTextureType tt, unsigned int slot);
+    void GetMatTex(const aiMaterial &mat, glTF2::TextureInfo &prop, aiTextureType tt, unsigned int slot);
+    void GetMatTex(const aiMaterial &mat, glTF2::NormalTextureInfo &prop, aiTextureType tt, unsigned int slot);
+    void GetMatTex(const aiMaterial &mat, glTF2::OcclusionTextureInfo &prop, aiTextureType tt, unsigned int slot);
+    aiReturn GetMatColor(const aiMaterial &mat, glTF2::vec4 &prop, const char *propName, int type, int idx) const;
+    aiReturn GetMatColor(const aiMaterial &mat, glTF2::vec3 &prop, const char *propName, int type, int idx) const;
+    bool GetMatSpecGloss(const aiMaterial &mat, glTF2::PbrSpecularGlossiness &pbrSG);
+    bool GetMatSheen(const aiMaterial &mat, glTF2::MaterialSheen &sheen);
+    bool GetMatClearcoat(const aiMaterial &mat, glTF2::MaterialClearcoat &clearcoat);
+    bool GetMatTransmission(const aiMaterial &mat, glTF2::MaterialTransmission &transmission);
+    bool GetMatVolume(const aiMaterial &mat, glTF2::MaterialVolume &volume);
+    bool GetMatIOR(const aiMaterial &mat, glTF2::MaterialIOR &ior);
+    void ExportMetadata();
+    void ExportMaterials();
+    void ExportMeshes();
+    void MergeMeshes();
+    unsigned int ExportNodeHierarchy(const aiNode *n);
+    unsigned int ExportNode(const aiNode *node, glTFCommon::Ref<glTF2::Node> &parent);
+    void ExportScene();
+    void ExportAnimations();
+
+private:
+    const char *mFilename;
+    IOSystem *mIOSystem;
+    const aiScene *mScene;
+    const ExportProperties *mProperties;
+    std::map<std::string, unsigned int> mTexturesByPath;
+    std::shared_ptr<glTF2::Asset> mAsset;
+    std::vector<unsigned char> mBodyData;
+};
+
+} // namespace Assimp
+
+#endif // ASSIMP_BUILD_NO_GLTF_IMPORTER
+
+#endif // AI_GLTF2EXPORTER_H_INC
diff --git a/Engine/lib/assimp/code/AssetLib/glTF2/glTF2Importer.cpp b/Engine/lib/assimp/code/AssetLib/glTF2/glTF2Importer.cpp
new file mode 100644
index 000000000..e8b8562e6
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/glTF2/glTF2Importer.cpp
@@ -0,0 +1,1638 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#if !defined(ASSIMP_BUILD_NO_GLTF_IMPORTER) && !defined(ASSIMP_BUILD_NO_GLTF2_IMPORTER)
+
+#include "AssetLib/glTF2/glTF2Importer.h"
+#include "AssetLib/glTF2/glTF2Asset.h"
+#include "PostProcessing/MakeVerboseFormat.h"
+
+#if !defined(ASSIMP_BUILD_NO_EXPORT)
+#include "AssetLib/glTF2/glTF2AssetWriter.h"
+#endif
+
+#include <assimp/CreateAnimMesh.h>
+#include <assimp/DefaultIOSystem.h>
+#include <assimp/StringComparison.h>
+#include <assimp/StringUtils.h>
+#include <assimp/ai_assert.h>
+#include <assimp/commonMetaData.h>
+#include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/Importer.hpp>
+
+#include <memory>
+#include <unordered_map>
+
+#include <rapidjson/document.h>
+#include <rapidjson/rapidjson.h>
+
+using namespace Assimp;
+using namespace glTF2;
+using namespace glTFCommon;
+
+namespace {
+// generate bi-tangents from normals and tangents according to spec
+struct Tangent {
+    aiVector3D xyz;
+    ai_real w;
+};
+} // namespace
+
+//
+// glTF2Importer
+//
+
+static const aiImporterDesc desc = {
+    "glTF2 Importer",
+    "",
+    "",
+    "",
+    aiImporterFlags_SupportTextFlavour | aiImporterFlags_SupportBinaryFlavour | aiImporterFlags_LimitedSupport | aiImporterFlags_Experimental,
+    0,
+    0,
+    0,
+    0,
+    "gltf glb"
+};
+
+glTF2Importer::glTF2Importer() :
+        BaseImporter(),
+        meshOffsets(),
+        mEmbeddedTexIdxs(),
+        mScene(nullptr) {
+    // empty
+}
+
+glTF2Importer::~glTF2Importer() {
+    // empty
+}
+
+const aiImporterDesc *glTF2Importer::GetInfo() const {
+    return &desc;
+}
+
+bool glTF2Importer::CanRead(const std::string &filename, IOSystem *pIOHandler, bool checkSig) const {
+    const std::string extension = GetExtension(filename);
+    if (!checkSig && (extension != "gltf") && (extension != "glb")) {
+        return false;
+    }
+
+    if (pIOHandler) {
+        glTF2::Asset asset(pIOHandler);
+        return asset.CanRead(filename, extension == "glb");
+    }
+
+    return false;
+}
+
+static inline aiTextureMapMode ConvertWrappingMode(SamplerWrap gltfWrapMode) {
+    switch (gltfWrapMode) {
+    case SamplerWrap::Mirrored_Repeat:
+        return aiTextureMapMode_Mirror;
+
+    case SamplerWrap::Clamp_To_Edge:
+        return aiTextureMapMode_Clamp;
+
+    case SamplerWrap::UNSET:
+    case SamplerWrap::Repeat:
+    default:
+        return aiTextureMapMode_Wrap;
+    }
+}
+
+static inline void SetMaterialColorProperty(Asset & /*r*/, vec4 &prop, aiMaterial *mat,
+        const char *pKey, unsigned int type, unsigned int idx) {
+    aiColor4D col;
+    CopyValue(prop, col);
+    mat->AddProperty(&col, 1, pKey, type, idx);
+}
+
+static inline void SetMaterialColorProperty(Asset & /*r*/, vec3 &prop, aiMaterial *mat,
+        const char *pKey, unsigned int type, unsigned int idx) {
+    aiColor4D col;
+    glTFCommon::CopyValue(prop, col);
+    mat->AddProperty(&col, 1, pKey, type, idx);
+}
+
+static void SetMaterialTextureProperty(std::vector<int> &embeddedTexIdxs, Asset & /*r*/,
+        glTF2::TextureInfo prop, aiMaterial *mat, aiTextureType texType,
+        unsigned int texSlot = 0) {
+    if (prop.texture && prop.texture->source) {
+        aiString uri(prop.texture->source->uri);
+
+        int texIdx = embeddedTexIdxs[prop.texture->source.GetIndex()];
+        if (texIdx != -1) { // embedded
+            // setup texture reference string (copied from ColladaLoader::FindFilenameForEffectTexture)
+            uri.data[0] = '*';
+            uri.length = 1 + ASSIMP_itoa10(uri.data + 1, MAXLEN - 1, texIdx);
+        }
+
+        mat->AddProperty(&uri, AI_MATKEY_TEXTURE(texType, texSlot));
+        const int uvIndex = static_cast<int>(prop.texCoord);
+        mat->AddProperty(&uvIndex, 1, AI_MATKEY_UVWSRC(texType, texSlot));
+
+        if (prop.textureTransformSupported) {
+            aiUVTransform transform;
+            transform.mScaling.x = prop.TextureTransformExt_t.scale[0];
+            transform.mScaling.y = prop.TextureTransformExt_t.scale[1];
+            transform.mRotation = -prop.TextureTransformExt_t.rotation; // must be negated
+
+            // A change of coordinates is required to map glTF UV transformations into the space used by
+            // Assimp. In glTF all UV origins are at 0,1 (top left of texture) in Assimp space. In Assimp
+            // rotation occurs around the image center (0.5,0.5) where as in glTF rotation is around the
+            // texture origin. All three can be corrected for solely by a change of the translation since
+            // the transformations available are shape preserving. Note the importer already flips the V
+            // coordinate of the actual meshes during import.
+            const ai_real rcos(cos(-transform.mRotation));
+            const ai_real rsin(sin(-transform.mRotation));
+            transform.mTranslation.x = (static_cast<ai_real>(0.5) * transform.mScaling.x) * (-rcos + rsin + 1) + prop.TextureTransformExt_t.offset[0];
+            transform.mTranslation.y = ((static_cast<ai_real>(0.5) * transform.mScaling.y) * (rsin + rcos - 1)) + 1 - transform.mScaling.y - prop.TextureTransformExt_t.offset[1];
+            ;
+
+            mat->AddProperty(&transform, 1, _AI_MATKEY_UVTRANSFORM_BASE, texType, texSlot);
+        }
+
+        if (prop.texture->sampler) {
+            Ref<Sampler> sampler = prop.texture->sampler;
+
+            aiString name(sampler->name);
+            aiString id(sampler->id);
+
+            mat->AddProperty(&name, AI_MATKEY_GLTF_MAPPINGNAME(texType, texSlot));
+            mat->AddProperty(&id, AI_MATKEY_GLTF_MAPPINGID(texType, texSlot));
+
+            aiTextureMapMode wrapS = ConvertWrappingMode(sampler->wrapS);
+            aiTextureMapMode wrapT = ConvertWrappingMode(sampler->wrapT);
+            mat->AddProperty(&wrapS, 1, AI_MATKEY_MAPPINGMODE_U(texType, texSlot));
+            mat->AddProperty(&wrapT, 1, AI_MATKEY_MAPPINGMODE_V(texType, texSlot));
+
+            if (sampler->magFilter != SamplerMagFilter::UNSET) {
+                mat->AddProperty(&sampler->magFilter, 1, AI_MATKEY_GLTF_MAPPINGFILTER_MAG(texType, texSlot));
+            }
+
+            if (sampler->minFilter != SamplerMinFilter::UNSET) {
+                mat->AddProperty(&sampler->minFilter, 1, AI_MATKEY_GLTF_MAPPINGFILTER_MIN(texType, texSlot));
+            }
+        } else {
+            // Use glTFv2 default sampler
+            const aiTextureMapMode default_wrap = aiTextureMapMode_Wrap;
+            mat->AddProperty(&default_wrap, 1, AI_MATKEY_MAPPINGMODE_U(texType, texSlot));
+            mat->AddProperty(&default_wrap, 1, AI_MATKEY_MAPPINGMODE_V(texType, texSlot));
+        }
+    }
+}
+
+inline void SetMaterialTextureProperty(std::vector<int> &embeddedTexIdxs, Asset &r,
+        NormalTextureInfo &prop, aiMaterial *mat, aiTextureType texType,
+        unsigned int texSlot = 0) {
+    SetMaterialTextureProperty(embeddedTexIdxs, r, (glTF2::TextureInfo)prop, mat, texType, texSlot);
+
+    if (prop.texture && prop.texture->source) {
+        mat->AddProperty(&prop.scale, 1, AI_MATKEY_GLTF_TEXTURE_SCALE(texType, texSlot));
+    }
+}
+
+inline void SetMaterialTextureProperty(std::vector<int> &embeddedTexIdxs, Asset &r,
+        OcclusionTextureInfo &prop, aiMaterial *mat, aiTextureType texType,
+        unsigned int texSlot = 0) {
+    SetMaterialTextureProperty(embeddedTexIdxs, r, (glTF2::TextureInfo)prop, mat, texType, texSlot);
+
+    if (prop.texture && prop.texture->source) {
+        mat->AddProperty(&prop.strength, 1, AI_MATKEY_GLTF_TEXTURE_STRENGTH(texType, texSlot));
+    }
+}
+
+static aiMaterial *ImportMaterial(std::vector<int> &embeddedTexIdxs, Asset &r, Material &mat) {
+    aiMaterial *aimat = new aiMaterial();
+
+    try {
+        if (!mat.name.empty()) {
+            aiString str(mat.name);
+
+            aimat->AddProperty(&str, AI_MATKEY_NAME);
+        }
+
+        // Set Assimp DIFFUSE and BASE COLOR to the pbrMetallicRoughness base color and texture for backwards compatibility
+        // Technically should not load any pbrMetallicRoughness if extensionsRequired contains KHR_materials_pbrSpecularGlossiness
+        SetMaterialColorProperty(r, mat.pbrMetallicRoughness.baseColorFactor, aimat, AI_MATKEY_COLOR_DIFFUSE);
+        SetMaterialColorProperty(r, mat.pbrMetallicRoughness.baseColorFactor, aimat, AI_MATKEY_BASE_COLOR);
+
+        SetMaterialTextureProperty(embeddedTexIdxs, r, mat.pbrMetallicRoughness.baseColorTexture, aimat, aiTextureType_DIFFUSE);
+        SetMaterialTextureProperty(embeddedTexIdxs, r, mat.pbrMetallicRoughness.baseColorTexture, aimat, aiTextureType_BASE_COLOR);
+
+        // Keep AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_METALLICROUGHNESS_TEXTURE for backwards compatibility
+        SetMaterialTextureProperty(embeddedTexIdxs, r, mat.pbrMetallicRoughness.metallicRoughnessTexture, aimat, AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_METALLICROUGHNESS_TEXTURE);
+        SetMaterialTextureProperty(embeddedTexIdxs, r, mat.pbrMetallicRoughness.metallicRoughnessTexture, aimat, aiTextureType_METALNESS);
+        SetMaterialTextureProperty(embeddedTexIdxs, r, mat.pbrMetallicRoughness.metallicRoughnessTexture, aimat, aiTextureType_DIFFUSE_ROUGHNESS);
+
+        aimat->AddProperty(&mat.pbrMetallicRoughness.metallicFactor, 1, AI_MATKEY_METALLIC_FACTOR);
+        aimat->AddProperty(&mat.pbrMetallicRoughness.roughnessFactor, 1, AI_MATKEY_ROUGHNESS_FACTOR);
+
+        float roughnessAsShininess = 1 - mat.pbrMetallicRoughness.roughnessFactor;
+        roughnessAsShininess *= roughnessAsShininess * 1000;
+        aimat->AddProperty(&roughnessAsShininess, 1, AI_MATKEY_SHININESS);
+
+        SetMaterialTextureProperty(embeddedTexIdxs, r, mat.normalTexture, aimat, aiTextureType_NORMALS);
+        SetMaterialTextureProperty(embeddedTexIdxs, r, mat.occlusionTexture, aimat, aiTextureType_LIGHTMAP);
+        SetMaterialTextureProperty(embeddedTexIdxs, r, mat.emissiveTexture, aimat, aiTextureType_EMISSIVE);
+        SetMaterialColorProperty(r, mat.emissiveFactor, aimat, AI_MATKEY_COLOR_EMISSIVE);
+
+        aimat->AddProperty(&mat.doubleSided, 1, AI_MATKEY_TWOSIDED);
+        aimat->AddProperty(&mat.pbrMetallicRoughness.baseColorFactor[3], 1, AI_MATKEY_OPACITY);
+
+        aiString alphaMode(mat.alphaMode);
+        aimat->AddProperty(&alphaMode, AI_MATKEY_GLTF_ALPHAMODE);
+        aimat->AddProperty(&mat.alphaCutoff, 1, AI_MATKEY_GLTF_ALPHACUTOFF);
+
+        //pbrSpecularGlossiness
+        if (mat.pbrSpecularGlossiness.isPresent) {
+            PbrSpecularGlossiness &pbrSG = mat.pbrSpecularGlossiness.value;
+
+            SetMaterialColorProperty(r, pbrSG.diffuseFactor, aimat, AI_MATKEY_COLOR_DIFFUSE);
+            SetMaterialColorProperty(r, pbrSG.specularFactor, aimat, AI_MATKEY_COLOR_SPECULAR);
+
+            float glossinessAsShininess = pbrSG.glossinessFactor * 1000.0f;
+            aimat->AddProperty(&glossinessAsShininess, 1, AI_MATKEY_SHININESS);
+            aimat->AddProperty(&pbrSG.glossinessFactor, 1, AI_MATKEY_GLOSSINESS_FACTOR);
+
+            SetMaterialTextureProperty(embeddedTexIdxs, r, pbrSG.diffuseTexture, aimat, aiTextureType_DIFFUSE);
+
+            SetMaterialTextureProperty(embeddedTexIdxs, r, pbrSG.specularGlossinessTexture, aimat, aiTextureType_SPECULAR);
+        }
+
+        // glTFv2 is either PBR or Unlit
+        aiShadingMode shadingMode = aiShadingMode_PBR_BRDF;
+        if (mat.unlit) {
+            aimat->AddProperty(&mat.unlit, 1, "$mat.gltf.unlit", 0, 0); // TODO: Remove this property, it is kept for backwards compatibility with assimp 5.0.1
+            shadingMode = aiShadingMode_Unlit;
+        }
+
+        aimat->AddProperty(&shadingMode, 1, AI_MATKEY_SHADING_MODEL);
+
+        // KHR_materials_sheen
+        if (mat.materialSheen.isPresent) {
+            MaterialSheen &sheen = mat.materialSheen.value;
+            // Default value {0,0,0} disables Sheen
+            if (std::memcmp(sheen.sheenColorFactor, defaultSheenFactor, sizeof(glTFCommon::vec3)) != 0) {
+                SetMaterialColorProperty(r, sheen.sheenColorFactor, aimat, AI_MATKEY_SHEEN_COLOR_FACTOR);
+                aimat->AddProperty(&sheen.sheenRoughnessFactor, 1, AI_MATKEY_SHEEN_ROUGHNESS_FACTOR);
+                SetMaterialTextureProperty(embeddedTexIdxs, r, sheen.sheenColorTexture, aimat, AI_MATKEY_SHEEN_COLOR_TEXTURE);
+                SetMaterialTextureProperty(embeddedTexIdxs, r, sheen.sheenRoughnessTexture, aimat, AI_MATKEY_SHEEN_ROUGHNESS_TEXTURE);
+            }
+        }
+
+        // KHR_materials_clearcoat
+        if (mat.materialClearcoat.isPresent) {
+            MaterialClearcoat &clearcoat = mat.materialClearcoat.value;
+            // Default value 0.0 disables clearcoat
+            if (clearcoat.clearcoatFactor != 0.0f) {
+                aimat->AddProperty(&clearcoat.clearcoatFactor, 1, AI_MATKEY_CLEARCOAT_FACTOR);
+                aimat->AddProperty(&clearcoat.clearcoatRoughnessFactor, 1, AI_MATKEY_CLEARCOAT_ROUGHNESS_FACTOR);
+                SetMaterialTextureProperty(embeddedTexIdxs, r, clearcoat.clearcoatTexture, aimat, AI_MATKEY_CLEARCOAT_TEXTURE);
+                SetMaterialTextureProperty(embeddedTexIdxs, r, clearcoat.clearcoatRoughnessTexture, aimat, AI_MATKEY_CLEARCOAT_ROUGHNESS_TEXTURE);
+                SetMaterialTextureProperty(embeddedTexIdxs, r, clearcoat.clearcoatNormalTexture, aimat, AI_MATKEY_CLEARCOAT_NORMAL_TEXTURE);
+            }
+        }
+
+        // KHR_materials_transmission
+        if (mat.materialTransmission.isPresent) {
+            MaterialTransmission &transmission = mat.materialTransmission.value;
+
+            aimat->AddProperty(&transmission.transmissionFactor, 1, AI_MATKEY_TRANSMISSION_FACTOR);
+            SetMaterialTextureProperty(embeddedTexIdxs, r, transmission.transmissionTexture, aimat, AI_MATKEY_TRANSMISSION_TEXTURE);
+        }
+
+        // KHR_materials_volume
+        if (mat.materialVolume.isPresent) {
+            MaterialVolume &volume = mat.materialVolume.value;
+
+            aimat->AddProperty(&volume.thicknessFactor, 1, AI_MATKEY_VOLUME_THICKNESS_FACTOR);
+            SetMaterialTextureProperty(embeddedTexIdxs, r, volume.thicknessTexture, aimat, AI_MATKEY_VOLUME_THICKNESS_TEXTURE);
+            aimat->AddProperty(&volume.attenuationDistance, 1, AI_MATKEY_VOLUME_ATTENUATION_DISTANCE);
+            SetMaterialColorProperty(r, volume.attenuationColor, aimat, AI_MATKEY_VOLUME_ATTENUATION_COLOR);
+        }
+
+        // KHR_materials_ior
+        if (mat.materialIOR.isPresent) {
+            MaterialIOR &ior = mat.materialIOR.value;
+
+            aimat->AddProperty(&ior.ior, 1, AI_MATKEY_REFRACTI);
+        }
+
+        return aimat;
+    } catch (...) {
+        delete aimat;
+        throw;
+    }
+}
+
+void glTF2Importer::ImportMaterials(Asset &r) {
+    const unsigned int numImportedMaterials = unsigned(r.materials.Size());
+    ASSIMP_LOG_DEBUG("Importing ", numImportedMaterials, " materials");
+    Material defaultMaterial;
+
+    mScene->mNumMaterials = numImportedMaterials + 1;
+    mScene->mMaterials = new aiMaterial *[mScene->mNumMaterials];
+    std::fill(mScene->mMaterials, mScene->mMaterials + mScene->mNumMaterials, nullptr);
+    mScene->mMaterials[numImportedMaterials] = ImportMaterial(mEmbeddedTexIdxs, r, defaultMaterial);
+
+    for (unsigned int i = 0; i < numImportedMaterials; ++i) {
+        mScene->mMaterials[i] = ImportMaterial(mEmbeddedTexIdxs, r, r.materials[i]);
+    }
+}
+
+static inline void SetFaceAndAdvance1(aiFace *&face, unsigned int numVertices, unsigned int a) {
+    if (a >= numVertices) {
+        return;
+    }
+    face->mNumIndices = 1;
+    face->mIndices = new unsigned int[1];
+    face->mIndices[0] = a;
+    ++face;
+}
+
+static inline void SetFaceAndAdvance2(aiFace *&face, unsigned int numVertices,
+        unsigned int a, unsigned int b) {
+    if ((a >= numVertices) || (b >= numVertices)) {
+        return;
+    }
+    face->mNumIndices = 2;
+    face->mIndices = new unsigned int[2];
+    face->mIndices[0] = a;
+    face->mIndices[1] = b;
+    ++face;
+}
+
+static inline void SetFaceAndAdvance3(aiFace *&face, unsigned int numVertices, unsigned int a,
+        unsigned int b, unsigned int c) {
+    if ((a >= numVertices) || (b >= numVertices) || (c >= numVertices)) {
+        return;
+    }
+    face->mNumIndices = 3;
+    face->mIndices = new unsigned int[3];
+    face->mIndices[0] = a;
+    face->mIndices[1] = b;
+    face->mIndices[2] = c;
+    ++face;
+}
+
+#ifdef ASSIMP_BUILD_DEBUG
+static inline bool CheckValidFacesIndices(aiFace *faces, unsigned nFaces, unsigned nVerts) {
+    for (unsigned i = 0; i < nFaces; ++i) {
+        for (unsigned j = 0; j < faces[i].mNumIndices; ++j) {
+            unsigned idx = faces[i].mIndices[j];
+            if (idx >= nVerts) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+#endif // ASSIMP_BUILD_DEBUG
+
+template <typename T>
+aiColor4D *GetVertexColorsForType(Ref<Accessor> input) {
+    constexpr float max = std::numeric_limits<T>::max();
+    aiColor4t<T> *colors;
+    input->ExtractData(colors);
+    auto output = new aiColor4D[input->count];
+    for (size_t i = 0; i < input->count; i++) {
+        output[i] = aiColor4D(
+                colors[i].r / max, colors[i].g / max,
+                colors[i].b / max, colors[i].a / max);
+    }
+    delete[] colors;
+    return output;
+}
+
+void glTF2Importer::ImportMeshes(glTF2::Asset &r) {
+    ASSIMP_LOG_DEBUG("Importing ", r.meshes.Size(), " meshes");
+    std::vector<std::unique_ptr<aiMesh>> meshes;
+
+    unsigned int k = 0;
+    meshOffsets.clear();
+
+    for (unsigned int m = 0; m < r.meshes.Size(); ++m) {
+        Mesh &mesh = r.meshes[m];
+
+        meshOffsets.push_back(k);
+        k += unsigned(mesh.primitives.size());
+
+        for (unsigned int p = 0; p < mesh.primitives.size(); ++p) {
+            Mesh::Primitive &prim = mesh.primitives[p];
+
+            aiMesh *aim = new aiMesh();
+            meshes.push_back(std::unique_ptr<aiMesh>(aim));
+
+            aim->mName = mesh.name.empty() ? mesh.id : mesh.name;
+
+            if (mesh.primitives.size() > 1) {
+                ai_uint32 &len = aim->mName.length;
+                aim->mName.data[len] = '-';
+                len += 1 + ASSIMP_itoa10(aim->mName.data + len + 1, unsigned(MAXLEN - len - 1), p);
+            }
+
+            switch (prim.mode) {
+            case PrimitiveMode_POINTS:
+                aim->mPrimitiveTypes |= aiPrimitiveType_POINT;
+                break;
+
+            case PrimitiveMode_LINES:
+            case PrimitiveMode_LINE_LOOP:
+            case PrimitiveMode_LINE_STRIP:
+                aim->mPrimitiveTypes |= aiPrimitiveType_LINE;
+                break;
+
+            case PrimitiveMode_TRIANGLES:
+            case PrimitiveMode_TRIANGLE_STRIP:
+            case PrimitiveMode_TRIANGLE_FAN:
+                aim->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
+                break;
+            }
+
+            Mesh::Primitive::Attributes &attr = prim.attributes;
+
+            if (!attr.position.empty() && attr.position[0]) {
+                aim->mNumVertices = static_cast<unsigned int>(attr.position[0]->count);
+                attr.position[0]->ExtractData(aim->mVertices);
+            }
+
+            if (!attr.normal.empty() && attr.normal[0]) {
+                if (attr.normal[0]->count != aim->mNumVertices) {
+                    DefaultLogger::get()->warn("Normal count in mesh \"", mesh.name, "\" does not match the vertex count, normals ignored.");
+                } else {
+                    attr.normal[0]->ExtractData(aim->mNormals);
+
+                    // only extract tangents if normals are present
+                    if (!attr.tangent.empty() && attr.tangent[0]) {
+                        if (attr.tangent[0]->count != aim->mNumVertices) {
+                            DefaultLogger::get()->warn("Tangent count in mesh \"", mesh.name, "\" does not match the vertex count, tangents ignored.");
+                        } else {
+                            // generate bitangents from normals and tangents according to spec
+                            Tangent *tangents = nullptr;
+
+                            attr.tangent[0]->ExtractData(tangents);
+
+                            aim->mTangents = new aiVector3D[aim->mNumVertices];
+                            aim->mBitangents = new aiVector3D[aim->mNumVertices];
+
+                            for (unsigned int i = 0; i < aim->mNumVertices; ++i) {
+                                aim->mTangents[i] = tangents[i].xyz;
+                                aim->mBitangents[i] = (aim->mNormals[i] ^ tangents[i].xyz) * tangents[i].w;
+                            }
+
+                            delete[] tangents;
+                        }
+                    }
+                }
+            }
+
+            for (size_t c = 0; c < attr.color.size() && c < AI_MAX_NUMBER_OF_COLOR_SETS; ++c) {
+                if (attr.color[c]->count != aim->mNumVertices) {
+                    DefaultLogger::get()->warn("Color stream size in mesh \"", mesh.name,
+                            "\" does not match the vertex count");
+                    continue;
+                }
+
+                auto componentType = attr.color[c]->componentType;
+                if (componentType == glTF2::ComponentType_FLOAT) {
+                    attr.color[c]->ExtractData(aim->mColors[c]);
+                } else {
+                    if (componentType == glTF2::ComponentType_UNSIGNED_BYTE) {
+                        aim->mColors[c] = GetVertexColorsForType<unsigned char>(attr.color[c]);
+                    } else if (componentType == glTF2::ComponentType_UNSIGNED_SHORT) {
+                        aim->mColors[c] = GetVertexColorsForType<unsigned short>(attr.color[c]);
+                    }
+                }
+            }
+            for (size_t tc = 0; tc < attr.texcoord.size() && tc < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++tc) {
+                if (!attr.texcoord[tc]) {
+                    DefaultLogger::get()->warn("Texture coordinate accessor not found or non-contiguous texture coordinate sets.");
+                    continue;
+                }
+
+                if (attr.texcoord[tc]->count != aim->mNumVertices) {
+                    DefaultLogger::get()->warn("Texcoord stream size in mesh \"", mesh.name,
+                            "\" does not match the vertex count");
+                    continue;
+                }
+
+                attr.texcoord[tc]->ExtractData(aim->mTextureCoords[tc]);
+                aim->mNumUVComponents[tc] = attr.texcoord[tc]->GetNumComponents();
+
+                aiVector3D *values = aim->mTextureCoords[tc];
+                for (unsigned int i = 0; i < aim->mNumVertices; ++i) {
+                    values[i].y = 1 - values[i].y; // Flip Y coords
+                }
+            }
+
+            std::vector<Mesh::Primitive::Target> &targets = prim.targets;
+            if (!targets.empty()) {
+                aim->mNumAnimMeshes = (unsigned int)targets.size();
+                aim->mAnimMeshes = new aiAnimMesh *[aim->mNumAnimMeshes];
+                std::fill(aim->mAnimMeshes, aim->mAnimMeshes + aim->mNumAnimMeshes, nullptr);
+                for (size_t i = 0; i < targets.size(); i++) {
+                    bool needPositions = targets[i].position.size() > 0;
+                    bool needNormals = (targets[i].normal.size() > 0) && aim->HasNormals();
+                    bool needTangents = (targets[i].tangent.size() > 0) && aim->HasTangentsAndBitangents();
+                    // GLTF morph does not support colors and texCoords
+                    aim->mAnimMeshes[i] = aiCreateAnimMesh(aim,
+                            needPositions, needNormals, needTangents, false, false);
+                    aiAnimMesh &aiAnimMesh = *(aim->mAnimMeshes[i]);
+                    Mesh::Primitive::Target &target = targets[i];
+
+                    if (needPositions) {
+                        if (target.position[0]->count != aim->mNumVertices) {
+                            ASSIMP_LOG_WARN("Positions of target ", i, " in mesh \"", mesh.name, "\" does not match the vertex count");
+                        } else {
+                            aiVector3D *positionDiff = nullptr;
+                            target.position[0]->ExtractData(positionDiff);
+                            for (unsigned int vertexId = 0; vertexId < aim->mNumVertices; vertexId++) {
+                                aiAnimMesh.mVertices[vertexId] += positionDiff[vertexId];
+                            }
+                            delete[] positionDiff;
+                        }
+                    }
+                    if (needNormals) {
+                        if (target.normal[0]->count != aim->mNumVertices) {
+                            ASSIMP_LOG_WARN("Normals of target ", i, " in mesh \"", mesh.name, "\" does not match the vertex count");
+                        } else {
+                            aiVector3D *normalDiff = nullptr;
+                            target.normal[0]->ExtractData(normalDiff);
+                            for (unsigned int vertexId = 0; vertexId < aim->mNumVertices; vertexId++) {
+                                aiAnimMesh.mNormals[vertexId] += normalDiff[vertexId];
+                            }
+                            delete[] normalDiff;
+                        }
+                    }
+                    if (needTangents) {
+                        if (target.tangent[0]->count != aim->mNumVertices) {
+                            ASSIMP_LOG_WARN("Tangents of target ", i, " in mesh \"", mesh.name, "\" does not match the vertex count");
+                        } else {
+                            Tangent *tangent = nullptr;
+                            attr.tangent[0]->ExtractData(tangent);
+
+                            aiVector3D *tangentDiff = nullptr;
+                            target.tangent[0]->ExtractData(tangentDiff);
+
+                            for (unsigned int vertexId = 0; vertexId < aim->mNumVertices; ++vertexId) {
+                                tangent[vertexId].xyz += tangentDiff[vertexId];
+                                aiAnimMesh.mTangents[vertexId] = tangent[vertexId].xyz;
+                                aiAnimMesh.mBitangents[vertexId] = (aiAnimMesh.mNormals[vertexId] ^ tangent[vertexId].xyz) * tangent[vertexId].w;
+                            }
+                            delete[] tangent;
+                            delete[] tangentDiff;
+                        }
+                    }
+                    if (mesh.weights.size() > i) {
+                        aiAnimMesh.mWeight = mesh.weights[i];
+                    }
+                    if (mesh.targetNames.size() > i) {
+                        aiAnimMesh.mName = mesh.targetNames[i];
+                    }
+                }
+            }
+
+            aiFace *faces = nullptr;
+            aiFace *facePtr = nullptr;
+            size_t nFaces = 0;
+
+            if (prim.indices) {
+                size_t count = prim.indices->count;
+
+                Accessor::Indexer data = prim.indices->GetIndexer();
+                if (!data.IsValid()) {
+                    throw DeadlyImportError("GLTF: Invalid accessor without data in mesh ", getContextForErrorMessages(mesh.id, mesh.name));
+                }
+
+                switch (prim.mode) {
+                case PrimitiveMode_POINTS: {
+                    nFaces = count;
+                    facePtr = faces = new aiFace[nFaces];
+                    for (unsigned int i = 0; i < count; ++i) {
+                        SetFaceAndAdvance1(facePtr, aim->mNumVertices, data.GetUInt(i));
+                    }
+                    break;
+                }
+
+                case PrimitiveMode_LINES: {
+                    nFaces = count / 2;
+                    if (nFaces * 2 != count) {
+                        ASSIMP_LOG_WARN("The number of vertices was not compatible with the LINES mode. Some vertices were dropped.");
+                        count = nFaces * 2;
+                    }
+                    facePtr = faces = new aiFace[nFaces];
+                    for (unsigned int i = 0; i < count; i += 2) {
+                        SetFaceAndAdvance2(facePtr, aim->mNumVertices, data.GetUInt(i), data.GetUInt(i + 1));
+                    }
+                    break;
+                }
+
+                case PrimitiveMode_LINE_LOOP:
+                case PrimitiveMode_LINE_STRIP: {
+                    nFaces = count - ((prim.mode == PrimitiveMode_LINE_STRIP) ? 1 : 0);
+                    facePtr = faces = new aiFace[nFaces];
+                    SetFaceAndAdvance2(facePtr, aim->mNumVertices, data.GetUInt(0), data.GetUInt(1));
+                    for (unsigned int i = 2; i < count; ++i) {
+                        SetFaceAndAdvance2(facePtr, aim->mNumVertices, data.GetUInt(i - 1), data.GetUInt(i));
+                    }
+                    if (prim.mode == PrimitiveMode_LINE_LOOP) { // close the loop
+                        SetFaceAndAdvance2(facePtr, aim->mNumVertices, data.GetUInt(static_cast<int>(count) - 1), faces[0].mIndices[0]);
+                    }
+                    break;
+                }
+
+                case PrimitiveMode_TRIANGLES: {
+                    nFaces = count / 3;
+                    if (nFaces * 3 != count) {
+                        ASSIMP_LOG_WARN("The number of vertices was not compatible with the TRIANGLES mode. Some vertices were dropped.");
+                        count = nFaces * 3;
+                    }
+                    facePtr = faces = new aiFace[nFaces];
+                    for (unsigned int i = 0; i < count; i += 3) {
+                        SetFaceAndAdvance3(facePtr, aim->mNumVertices, data.GetUInt(i), data.GetUInt(i + 1), data.GetUInt(i + 2));
+                    }
+                    break;
+                }
+                case PrimitiveMode_TRIANGLE_STRIP: {
+                    nFaces = count - 2;
+                    facePtr = faces = new aiFace[nFaces];
+                    for (unsigned int i = 0; i < nFaces; ++i) {
+                        //The ordering is to ensure that the triangles are all drawn with the same orientation
+                        if ((i + 1) % 2 == 0) {
+                            //For even n, vertices n + 1, n, and n + 2 define triangle n
+                            SetFaceAndAdvance3(facePtr, aim->mNumVertices, data.GetUInt(i + 1), data.GetUInt(i), data.GetUInt(i + 2));
+                        } else {
+                            //For odd n, vertices n, n+1, and n+2 define triangle n
+                            SetFaceAndAdvance3(facePtr, aim->mNumVertices, data.GetUInt(i), data.GetUInt(i + 1), data.GetUInt(i + 2));
+                        }
+                    }
+                    break;
+                }
+                case PrimitiveMode_TRIANGLE_FAN:
+                    nFaces = count - 2;
+                    facePtr = faces = new aiFace[nFaces];
+                    SetFaceAndAdvance3(facePtr, aim->mNumVertices, data.GetUInt(0), data.GetUInt(1), data.GetUInt(2));
+                    for (unsigned int i = 1; i < nFaces; ++i) {
+                        SetFaceAndAdvance3(facePtr, aim->mNumVertices, data.GetUInt(0), data.GetUInt(i + 1), data.GetUInt(i + 2));
+                    }
+                    break;
+                }
+            } else { // no indices provided so directly generate from counts
+
+                // use the already determined count as it includes checks
+                unsigned int count = aim->mNumVertices;
+
+                switch (prim.mode) {
+                case PrimitiveMode_POINTS: {
+                    nFaces = count;
+                    facePtr = faces = new aiFace[nFaces];
+                    for (unsigned int i = 0; i < count; ++i) {
+                        SetFaceAndAdvance1(facePtr, aim->mNumVertices, i);
+                    }
+                    break;
+                }
+
+                case PrimitiveMode_LINES: {
+                    nFaces = count / 2;
+                    if (nFaces * 2 != count) {
+                        ASSIMP_LOG_WARN("The number of vertices was not compatible with the LINES mode. Some vertices were dropped.");
+                        count = (unsigned int)nFaces * 2;
+                    }
+                    facePtr = faces = new aiFace[nFaces];
+                    for (unsigned int i = 0; i < count; i += 2) {
+                        SetFaceAndAdvance2(facePtr, aim->mNumVertices, i, i + 1);
+                    }
+                    break;
+                }
+
+                case PrimitiveMode_LINE_LOOP:
+                case PrimitiveMode_LINE_STRIP: {
+                    nFaces = count - ((prim.mode == PrimitiveMode_LINE_STRIP) ? 1 : 0);
+                    facePtr = faces = new aiFace[nFaces];
+                    SetFaceAndAdvance2(facePtr, aim->mNumVertices, 0, 1);
+                    for (unsigned int i = 2; i < count; ++i) {
+                        SetFaceAndAdvance2(facePtr, aim->mNumVertices, i - 1, i);
+                    }
+                    if (prim.mode == PrimitiveMode_LINE_LOOP) { // close the loop
+                        SetFaceAndAdvance2(facePtr, aim->mNumVertices, count - 1, 0);
+                    }
+                    break;
+                }
+
+                case PrimitiveMode_TRIANGLES: {
+                    nFaces = count / 3;
+                    if (nFaces * 3 != count) {
+                        ASSIMP_LOG_WARN("The number of vertices was not compatible with the TRIANGLES mode. Some vertices were dropped.");
+                        count = (unsigned int)nFaces * 3;
+                    }
+                    facePtr = faces = new aiFace[nFaces];
+                    for (unsigned int i = 0; i < count; i += 3) {
+                        SetFaceAndAdvance3(facePtr, aim->mNumVertices, i, i + 1, i + 2);
+                    }
+                    break;
+                }
+                case PrimitiveMode_TRIANGLE_STRIP: {
+                    nFaces = count - 2;
+                    facePtr = faces = new aiFace[nFaces];
+                    for (unsigned int i = 0; i < nFaces; ++i) {
+                        //The ordering is to ensure that the triangles are all drawn with the same orientation
+                        if ((i + 1) % 2 == 0) {
+                            //For even n, vertices n + 1, n, and n + 2 define triangle n
+                            SetFaceAndAdvance3(facePtr, aim->mNumVertices, i + 1, i, i + 2);
+                        } else {
+                            //For odd n, vertices n, n+1, and n+2 define triangle n
+                            SetFaceAndAdvance3(facePtr, aim->mNumVertices, i, i + 1, i + 2);
+                        }
+                    }
+                    break;
+                }
+                case PrimitiveMode_TRIANGLE_FAN:
+                    nFaces = count - 2;
+                    facePtr = faces = new aiFace[nFaces];
+                    SetFaceAndAdvance3(facePtr, aim->mNumVertices, 0, 1, 2);
+                    for (unsigned int i = 1; i < nFaces; ++i) {
+                        SetFaceAndAdvance3(facePtr, aim->mNumVertices, 0, i + 1, i + 2);
+                    }
+                    break;
+                }
+            }
+
+            if (faces) {
+                aim->mFaces = faces;
+                const unsigned int actualNumFaces = static_cast<unsigned int>(facePtr - faces);
+                if (actualNumFaces < nFaces) {
+                    ASSIMP_LOG_WARN("Some faces had out-of-range indices. Those faces were dropped.");
+                }
+                if (actualNumFaces == 0) {
+                    throw DeadlyImportError("Mesh \"", aim->mName.C_Str(), "\" has no faces");
+                }
+                aim->mNumFaces = actualNumFaces;
+                ai_assert(CheckValidFacesIndices(faces, actualNumFaces, aim->mNumVertices));
+            }
+
+            if (prim.material) {
+                aim->mMaterialIndex = prim.material.GetIndex();
+            } else {
+                aim->mMaterialIndex = mScene->mNumMaterials - 1;
+            }
+        }
+    }
+
+    meshOffsets.push_back(k);
+
+    CopyVector(meshes, mScene->mMeshes, mScene->mNumMeshes);
+}
+
+void glTF2Importer::ImportCameras(glTF2::Asset &r) {
+    if (!r.cameras.Size()) {
+        return;
+    }
+
+    const unsigned int numCameras = r.cameras.Size();
+    ASSIMP_LOG_DEBUG("Importing ", numCameras, " cameras");
+    mScene->mNumCameras = numCameras;
+    mScene->mCameras = new aiCamera *[numCameras];
+    std::fill(mScene->mCameras, mScene->mCameras + numCameras, nullptr);
+
+    for (size_t i = 0; i < numCameras; ++i) {
+        Camera &cam = r.cameras[i];
+
+        aiCamera *aicam = mScene->mCameras[i] = new aiCamera();
+
+        // cameras point in -Z by default, rest is specified in node transform
+        aicam->mLookAt = aiVector3D(0.f, 0.f, -1.f);
+
+        if (cam.type == Camera::Perspective) {
+            aicam->mAspect = cam.cameraProperties.perspective.aspectRatio;
+            aicam->mHorizontalFOV = cam.cameraProperties.perspective.yfov * ((aicam->mAspect == 0.f) ? 1.f : aicam->mAspect);
+            aicam->mClipPlaneFar = cam.cameraProperties.perspective.zfar;
+            aicam->mClipPlaneNear = cam.cameraProperties.perspective.znear;
+        } else {
+            aicam->mClipPlaneFar = cam.cameraProperties.ortographic.zfar;
+            aicam->mClipPlaneNear = cam.cameraProperties.ortographic.znear;
+            aicam->mHorizontalFOV = 0.0;
+            aicam->mOrthographicWidth = cam.cameraProperties.ortographic.xmag;
+            aicam->mAspect = 1.0f;
+            if (0.f != cam.cameraProperties.ortographic.ymag) {
+                aicam->mAspect = cam.cameraProperties.ortographic.xmag / cam.cameraProperties.ortographic.ymag;
+            }
+        }
+    }
+}
+
+void glTF2Importer::ImportLights(glTF2::Asset &r) {
+    if (!r.lights.Size()) {
+        return;
+    }
+
+    const unsigned int numLights = r.lights.Size();
+    ASSIMP_LOG_DEBUG("Importing ", numLights, " lights");
+    mScene->mNumLights = numLights;
+    mScene->mLights = new aiLight *[numLights];
+    std::fill(mScene->mLights, mScene->mLights + numLights, nullptr);
+
+    for (size_t i = 0; i < numLights; ++i) {
+        Light &light = r.lights[i];
+
+        aiLight *ail = mScene->mLights[i] = new aiLight();
+
+        switch (light.type) {
+        case Light::Directional:
+            ail->mType = aiLightSource_DIRECTIONAL;
+            break;
+        case Light::Point:
+            ail->mType = aiLightSource_POINT;
+            break;
+        case Light::Spot:
+            ail->mType = aiLightSource_SPOT;
+            break;
+        }
+
+        if (ail->mType != aiLightSource_POINT) {
+            ail->mDirection = aiVector3D(0.0f, 0.0f, -1.0f);
+            ail->mUp = aiVector3D(0.0f, 1.0f, 0.0f);
+        }
+
+        vec3 colorWithIntensity = { light.color[0] * light.intensity, light.color[1] * light.intensity, light.color[2] * light.intensity };
+        CopyValue(colorWithIntensity, ail->mColorAmbient);
+        CopyValue(colorWithIntensity, ail->mColorDiffuse);
+        CopyValue(colorWithIntensity, ail->mColorSpecular);
+
+        if (ail->mType == aiLightSource_DIRECTIONAL) {
+            ail->mAttenuationConstant = 1.0;
+            ail->mAttenuationLinear = 0.0;
+            ail->mAttenuationQuadratic = 0.0;
+        } else {
+            //in PBR attenuation is calculated using inverse square law which can be expressed
+            //using assimps equation: 1/(att0 + att1 * d + att2 * d*d) with the following parameters
+            //this is correct equation for the case when range (see
+            //https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_lights_punctual)
+            //is not present. When range is not present it is assumed that it is infinite and so numerator is 1.
+            //When range is present then numerator might be any value in range [0,1] and then assimps equation
+            //will not suffice. In this case range is added into metadata in ImportNode function
+            //and its up to implementation to read it when it wants to
+            ail->mAttenuationConstant = 0.0;
+            ail->mAttenuationLinear = 0.0;
+            ail->mAttenuationQuadratic = 1.0;
+        }
+
+        if (ail->mType == aiLightSource_SPOT) {
+            ail->mAngleInnerCone = light.innerConeAngle;
+            ail->mAngleOuterCone = light.outerConeAngle;
+        }
+    }
+}
+
+static void GetNodeTransform(aiMatrix4x4 &matrix, const glTF2::Node &node) {
+    if (node.matrix.isPresent) {
+        CopyValue(node.matrix.value, matrix);
+        return;
+    }
+
+    if (node.translation.isPresent) {
+        aiVector3D trans;
+        CopyValue(node.translation.value, trans);
+        aiMatrix4x4 t;
+        aiMatrix4x4::Translation(trans, t);
+        matrix = matrix * t;
+    }
+
+    if (node.rotation.isPresent) {
+        aiQuaternion rot;
+        CopyValue(node.rotation.value, rot);
+        matrix = matrix * aiMatrix4x4(rot.GetMatrix());
+    }
+
+    if (node.scale.isPresent) {
+        aiVector3D scal(1.f);
+        CopyValue(node.scale.value, scal);
+        aiMatrix4x4 s;
+        aiMatrix4x4::Scaling(scal, s);
+        matrix = matrix * s;
+    }
+}
+
+static void BuildVertexWeightMapping(Mesh::Primitive &primitive, std::vector<std::vector<aiVertexWeight>> &map) {
+    Mesh::Primitive::Attributes &attr = primitive.attributes;
+    if (attr.weight.empty() || attr.joint.empty()) {
+        return;
+    }
+    if (attr.weight[0]->count != attr.joint[0]->count) {
+        return;
+    }
+
+    size_t num_vertices = attr.weight[0]->count;
+
+    struct Weights {
+        float values[4];
+    };
+    Weights *weights = nullptr;
+    attr.weight[0]->ExtractData(weights);
+
+    struct Indices8 {
+        uint8_t values[4];
+    };
+    struct Indices16 {
+        uint16_t values[4];
+    };
+    Indices8 *indices8 = nullptr;
+    Indices16 *indices16 = nullptr;
+    if (attr.joint[0]->GetElementSize() == 4) {
+        attr.joint[0]->ExtractData(indices8);
+    } else {
+        attr.joint[0]->ExtractData(indices16);
+    }
+    //
+    if (nullptr == indices8 && nullptr == indices16) {
+        // Something went completely wrong!
+        ai_assert(false);
+        return;
+    }
+
+    for (size_t i = 0; i < num_vertices; ++i) {
+        for (int j = 0; j < 4; ++j) {
+            const unsigned int bone = (indices8 != nullptr) ? indices8[i].values[j] : indices16[i].values[j];
+            const float weight = weights[i].values[j];
+            if (weight > 0 && bone < map.size()) {
+                map[bone].reserve(8);
+                map[bone].emplace_back(static_cast<unsigned int>(i), weight);
+            }
+        }
+    }
+
+    delete[] weights;
+    delete[] indices8;
+    delete[] indices16;
+}
+
+static std::string GetNodeName(const Node &node) {
+    return node.name.empty() ? node.id : node.name;
+}
+
+void ParseExtensions(aiMetadata *metadata, const CustomExtension &extension) {
+    if (extension.mStringValue.isPresent) {
+        metadata->Add(extension.name, aiString(extension.mStringValue.value));
+    } else if (extension.mDoubleValue.isPresent) {
+        metadata->Add(extension.name, extension.mDoubleValue.value);
+    } else if (extension.mUint64Value.isPresent) {
+        metadata->Add(extension.name, extension.mUint64Value.value);
+    } else if (extension.mInt64Value.isPresent) {
+        metadata->Add(extension.name, static_cast<int32_t>(extension.mInt64Value.value));
+    } else if (extension.mBoolValue.isPresent) {
+        metadata->Add(extension.name, extension.mBoolValue.value);
+    } else if (extension.mValues.isPresent) {
+        aiMetadata val;
+        for (auto const &subExtension : extension.mValues.value) {
+            ParseExtensions(&val, subExtension);
+        }
+        metadata->Add(extension.name, val);
+    }
+}
+
+void ParseExtras(aiMetadata *metadata, const CustomExtension &extension) {
+    if (extension.mValues.isPresent) {
+        for (auto const &subExtension : extension.mValues.value) {
+            ParseExtensions(metadata, subExtension);
+        }
+    }
+}
+
+aiNode *ImportNode(aiScene *pScene, glTF2::Asset &r, std::vector<unsigned int> &meshOffsets, glTF2::Ref<glTF2::Node> &ptr) {
+    Node &node = *ptr;
+
+    aiNode *ainode = new aiNode(GetNodeName(node));
+
+    try {
+        if (!node.children.empty()) {
+            ainode->mNumChildren = unsigned(node.children.size());
+            ainode->mChildren = new aiNode *[ainode->mNumChildren];
+            std::fill(ainode->mChildren, ainode->mChildren + ainode->mNumChildren, nullptr);
+
+            for (unsigned int i = 0; i < ainode->mNumChildren; ++i) {
+                aiNode *child = ImportNode(pScene, r, meshOffsets, node.children[i]);
+                child->mParent = ainode;
+                ainode->mChildren[i] = child;
+            }
+        }
+
+        if (node.customExtensions || node.extras) {
+            ainode->mMetaData = new aiMetadata;
+            if (node.customExtensions) {
+                ParseExtensions(ainode->mMetaData, node.customExtensions);
+            }
+            if (node.extras) {
+                ParseExtras(ainode->mMetaData, node.extras);
+            }
+        }
+
+        GetNodeTransform(ainode->mTransformation, node);
+
+        if (!node.meshes.empty()) {
+            // GLTF files contain at most 1 mesh per node.
+            if (node.meshes.size() > 1) {
+                throw DeadlyImportError("GLTF: Invalid input, found ", node.meshes.size(),
+                        " meshes in ", getContextForErrorMessages(node.id, node.name),
+                        ", but only 1 mesh per node allowed.");
+            }
+            int mesh_idx = node.meshes[0].GetIndex();
+            int count = meshOffsets[mesh_idx + 1] - meshOffsets[mesh_idx];
+
+            ainode->mNumMeshes = count;
+            ainode->mMeshes = new unsigned int[count];
+
+            if (node.skin) {
+                for (int primitiveNo = 0; primitiveNo < count; ++primitiveNo) {
+                    aiMesh *mesh = pScene->mMeshes[meshOffsets[mesh_idx] + primitiveNo];
+                    unsigned int numBones = static_cast<unsigned int>(node.skin->jointNames.size());
+
+                    std::vector<std::vector<aiVertexWeight>> weighting(numBones);
+                    BuildVertexWeightMapping(node.meshes[0]->primitives[primitiveNo], weighting);
+
+                    mesh->mNumBones = static_cast<unsigned int>(numBones);
+                    mesh->mBones = new aiBone *[mesh->mNumBones];
+                    std::fill(mesh->mBones, mesh->mBones + mesh->mNumBones, nullptr);
+
+                    // GLTF and Assimp choose to store bone weights differently.
+                    // GLTF has each vertex specify which bones influence the vertex.
+                    // Assimp has each bone specify which vertices it has influence over.
+                    // To convert this data, we first read over the vertex data and pull
+                    // out the bone-to-vertex mapping.  Then, when creating the aiBones,
+                    // we copy the bone-to-vertex mapping into the bone.  This is unfortunate
+                    // both because it's somewhat slow and because, for many applications,
+                    // we then need to reconvert the data back into the vertex-to-bone
+                    // mapping which makes things doubly-slow.
+
+                    mat4 *pbindMatrices = nullptr;
+                    node.skin->inverseBindMatrices->ExtractData(pbindMatrices);
+
+                    for (uint32_t i = 0; i < numBones; ++i) {
+                        const std::vector<aiVertexWeight> &weights = weighting[i];
+                        aiBone *bone = new aiBone();
+
+                        Ref<Node> joint = node.skin->jointNames[i];
+                        if (!joint->name.empty()) {
+                            bone->mName = joint->name;
+                        } else {
+                            // Assimp expects each bone to have a unique name.
+                            static const std::string kDefaultName = "bone_";
+                            char postfix[10] = { 0 };
+                            ASSIMP_itoa10(postfix, i);
+                            bone->mName = (kDefaultName + postfix);
+                        }
+                        GetNodeTransform(bone->mOffsetMatrix, *joint);
+                        CopyValue(pbindMatrices[i], bone->mOffsetMatrix);
+                        bone->mNumWeights = static_cast<uint32_t>(weights.size());
+
+                        if (bone->mNumWeights > 0) {
+                            bone->mWeights = new aiVertexWeight[bone->mNumWeights];
+                            memcpy(bone->mWeights, weights.data(), bone->mNumWeights * sizeof(aiVertexWeight));
+                        } else {
+                            // Assimp expects all bones to have at least 1 weight.
+                            bone->mWeights = new aiVertexWeight[1];
+                            bone->mNumWeights = 1;
+                            bone->mWeights->mVertexId = 0;
+                            bone->mWeights->mWeight = 0.f;
+                        }
+                        mesh->mBones[i] = bone;
+                    }
+
+                    if (pbindMatrices) {
+                        delete[] pbindMatrices;
+                    }
+                }
+            }
+
+            int k = 0;
+            for (unsigned int j = meshOffsets[mesh_idx]; j < meshOffsets[mesh_idx + 1]; ++j, ++k) {
+                ainode->mMeshes[k] = j;
+            }
+        }
+
+        if (node.camera) {
+            pScene->mCameras[node.camera.GetIndex()]->mName = ainode->mName;
+            if (node.translation.isPresent) {
+                aiVector3D trans;
+                CopyValue(node.translation.value, trans);
+                pScene->mCameras[node.camera.GetIndex()]->mPosition = trans;
+            }
+        }
+
+        if (node.light) {
+            pScene->mLights[node.light.GetIndex()]->mName = ainode->mName;
+
+            //range is optional - see https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_lights_punctual
+            //it is added to meta data of parent node, because there is no other place to put it
+            if (node.light->range.isPresent) {
+                if (!ainode->mMetaData) {
+                    ainode->mMetaData = aiMetadata::Alloc(1);
+                    ainode->mMetaData->Set(0, "PBR_LightRange", node.light->range.value);
+                } else {
+                    ainode->mMetaData->Add("PBR_LightRange", node.light->range.value);
+                }
+            }
+        }
+
+        return ainode;
+    } catch (...) {
+        delete ainode;
+        throw;
+    }
+}
+
+void glTF2Importer::ImportNodes(glTF2::Asset &r) {
+    if (!r.scene) {
+        throw DeadlyImportError("GLTF: No scene");
+    }
+    ASSIMP_LOG_DEBUG("Importing nodes");
+
+    std::vector<Ref<Node>> rootNodes = r.scene->nodes;
+
+    // The root nodes
+    unsigned int numRootNodes = unsigned(rootNodes.size());
+    if (numRootNodes == 1) { // a single root node: use it
+        mScene->mRootNode = ImportNode(mScene, r, meshOffsets, rootNodes[0]);
+    } else if (numRootNodes > 1) { // more than one root node: create a fake root
+        aiNode *root = mScene->mRootNode = new aiNode("ROOT");
+
+        root->mChildren = new aiNode *[numRootNodes];
+        std::fill(root->mChildren, root->mChildren + numRootNodes, nullptr);
+
+        for (unsigned int i = 0; i < numRootNodes; ++i) {
+            aiNode *node = ImportNode(mScene, r, meshOffsets, rootNodes[i]);
+            node->mParent = root;
+            root->mChildren[root->mNumChildren++] = node;
+        }
+    } else {
+        mScene->mRootNode = new aiNode("ROOT");
+    }
+}
+
+struct AnimationSamplers {
+    AnimationSamplers() :
+            translation(nullptr),
+            rotation(nullptr),
+            scale(nullptr),
+            weight(nullptr) {
+        // empty
+    }
+
+    Animation::Sampler *translation;
+    Animation::Sampler *rotation;
+    Animation::Sampler *scale;
+    Animation::Sampler *weight;
+};
+
+aiNodeAnim *CreateNodeAnim(glTF2::Asset &, Node &node, AnimationSamplers &samplers) {
+    aiNodeAnim *anim = new aiNodeAnim();
+
+    try {
+        anim->mNodeName = GetNodeName(node);
+
+        static const float kMillisecondsFromSeconds = 1000.f;
+
+        if (samplers.translation && samplers.translation->input && samplers.translation->output) {
+            float *times = nullptr;
+            samplers.translation->input->ExtractData(times);
+            aiVector3D *values = nullptr;
+            samplers.translation->output->ExtractData(values);
+            anim->mNumPositionKeys = static_cast<uint32_t>(samplers.translation->input->count);
+            anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys];
+            unsigned int ii = (samplers.translation->interpolation == Interpolation_CUBICSPLINE) ? 1 : 0;
+            for (unsigned int i = 0; i < anim->mNumPositionKeys; ++i) {
+                anim->mPositionKeys[i].mTime = times[i] * kMillisecondsFromSeconds;
+                anim->mPositionKeys[i].mValue = values[ii];
+                ii += (samplers.translation->interpolation == Interpolation_CUBICSPLINE) ? 3 : 1;
+            }
+            delete[] times;
+            delete[] values;
+        } else if (node.translation.isPresent) {
+            anim->mNumPositionKeys = 1;
+            anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys];
+            anim->mPositionKeys->mTime = 0.f;
+            anim->mPositionKeys->mValue.x = node.translation.value[0];
+            anim->mPositionKeys->mValue.y = node.translation.value[1];
+            anim->mPositionKeys->mValue.z = node.translation.value[2];
+        }
+
+        if (samplers.rotation && samplers.rotation->input && samplers.rotation->output) {
+            float *times = nullptr;
+            samplers.rotation->input->ExtractData(times);
+            aiQuaternion *values = nullptr;
+            samplers.rotation->output->ExtractData(values);
+            anim->mNumRotationKeys = static_cast<uint32_t>(samplers.rotation->input->count);
+            anim->mRotationKeys = new aiQuatKey[anim->mNumRotationKeys];
+            unsigned int ii = (samplers.rotation->interpolation == Interpolation_CUBICSPLINE) ? 1 : 0;
+            for (unsigned int i = 0; i < anim->mNumRotationKeys; ++i) {
+                anim->mRotationKeys[i].mTime = times[i] * kMillisecondsFromSeconds;
+                anim->mRotationKeys[i].mValue.x = values[ii].w;
+                anim->mRotationKeys[i].mValue.y = values[ii].x;
+                anim->mRotationKeys[i].mValue.z = values[ii].y;
+                anim->mRotationKeys[i].mValue.w = values[ii].z;
+                ii += (samplers.rotation->interpolation == Interpolation_CUBICSPLINE) ? 3 : 1;
+            }
+            delete[] times;
+            delete[] values;
+        } else if (node.rotation.isPresent) {
+            anim->mNumRotationKeys = 1;
+            anim->mRotationKeys = new aiQuatKey[anim->mNumRotationKeys];
+            anim->mRotationKeys->mTime = 0.f;
+            anim->mRotationKeys->mValue.x = node.rotation.value[0];
+            anim->mRotationKeys->mValue.y = node.rotation.value[1];
+            anim->mRotationKeys->mValue.z = node.rotation.value[2];
+            anim->mRotationKeys->mValue.w = node.rotation.value[3];
+        }
+
+        if (samplers.scale && samplers.scale->input && samplers.scale->output) {
+            float *times = nullptr;
+            samplers.scale->input->ExtractData(times);
+            aiVector3D *values = nullptr;
+            samplers.scale->output->ExtractData(values);
+            anim->mNumScalingKeys = static_cast<uint32_t>(samplers.scale->input->count);
+            anim->mScalingKeys = new aiVectorKey[anim->mNumScalingKeys];
+            unsigned int ii = (samplers.scale->interpolation == Interpolation_CUBICSPLINE) ? 1 : 0;
+            for (unsigned int i = 0; i < anim->mNumScalingKeys; ++i) {
+                anim->mScalingKeys[i].mTime = times[i] * kMillisecondsFromSeconds;
+                anim->mScalingKeys[i].mValue = values[ii];
+                ii += (samplers.scale->interpolation == Interpolation_CUBICSPLINE) ? 3 : 1;
+            }
+            delete[] times;
+            delete[] values;
+        } else if (node.scale.isPresent) {
+            anim->mNumScalingKeys = 1;
+            anim->mScalingKeys = new aiVectorKey[anim->mNumScalingKeys];
+            anim->mScalingKeys->mTime = 0.f;
+            anim->mScalingKeys->mValue.x = node.scale.value[0];
+            anim->mScalingKeys->mValue.y = node.scale.value[1];
+            anim->mScalingKeys->mValue.z = node.scale.value[2];
+        }
+
+        return anim;
+    } catch (...) {
+        delete anim;
+        throw;
+    }
+}
+
+aiMeshMorphAnim *CreateMeshMorphAnim(glTF2::Asset &, Node &node, AnimationSamplers &samplers) {
+    auto *anim = new aiMeshMorphAnim();
+
+    try {
+        anim->mName = GetNodeName(node);
+
+        static const float kMillisecondsFromSeconds = 1000.f;
+
+        if (samplers.weight && samplers.weight->input && samplers.weight->output) {
+            float *times = nullptr;
+            samplers.weight->input->ExtractData(times);
+            float *values = nullptr;
+            samplers.weight->output->ExtractData(values);
+            anim->mNumKeys = static_cast<uint32_t>(samplers.weight->input->count);
+
+            // for Interpolation_CUBICSPLINE can have more outputs
+            const unsigned int weightStride = (unsigned int)samplers.weight->output->count / anim->mNumKeys;
+            const unsigned int numMorphs = (samplers.weight->interpolation == Interpolation_CUBICSPLINE) ? weightStride - 2 : weightStride;
+
+            anim->mKeys = new aiMeshMorphKey[anim->mNumKeys];
+            unsigned int ii = (samplers.weight->interpolation == Interpolation_CUBICSPLINE) ? 1 : 0;
+            for (unsigned int i = 0u; i < anim->mNumKeys; ++i) {
+                unsigned int k = weightStride * i + ii;
+                anim->mKeys[i].mTime = times[i] * kMillisecondsFromSeconds;
+                anim->mKeys[i].mNumValuesAndWeights = numMorphs;
+                anim->mKeys[i].mValues = new unsigned int[numMorphs];
+                anim->mKeys[i].mWeights = new double[numMorphs];
+
+                for (unsigned int j = 0u; j < numMorphs; ++j, ++k) {
+                    anim->mKeys[i].mValues[j] = j;
+                    anim->mKeys[i].mWeights[j] = (0.f > values[k]) ? 0.f : values[k];
+                }
+            }
+
+            delete[] times;
+            delete[] values;
+        }
+
+        return anim;
+    } catch (...) {
+        delete anim;
+        throw;
+    }
+}
+
+std::unordered_map<unsigned int, AnimationSamplers> GatherSamplers(Animation &anim) {
+    std::unordered_map<unsigned int, AnimationSamplers> samplers;
+    for (unsigned int c = 0; c < anim.channels.size(); ++c) {
+        Animation::Channel &channel = anim.channels[c];
+        if (channel.sampler < 0 || channel.sampler >= static_cast<int>(anim.samplers.size())) {
+            continue;
+        }
+
+        auto &animsampler = anim.samplers[channel.sampler];
+
+        if (!animsampler.input) {
+            ASSIMP_LOG_WARN("Animation ", anim.name, ": Missing sampler input. Skipping.");
+            continue;
+        }
+
+        if (!animsampler.output) {
+            ASSIMP_LOG_WARN("Animation ", anim.name, ": Missing sampler output. Skipping.");
+            continue;
+        }
+
+        if (animsampler.input->count > animsampler.output->count) {
+            ASSIMP_LOG_WARN("Animation ", anim.name, ": Number of keyframes in sampler input ", animsampler.input->count, " exceeds number of keyframes in sampler output ", animsampler.output->count);
+            continue;
+        }
+
+        const unsigned int node_index = channel.target.node.GetIndex();
+
+        AnimationSamplers &sampler = samplers[node_index];
+        if (channel.target.path == AnimationPath_TRANSLATION) {
+            sampler.translation = &anim.samplers[channel.sampler];
+        } else if (channel.target.path == AnimationPath_ROTATION) {
+            sampler.rotation = &anim.samplers[channel.sampler];
+        } else if (channel.target.path == AnimationPath_SCALE) {
+            sampler.scale = &anim.samplers[channel.sampler];
+        } else if (channel.target.path == AnimationPath_WEIGHTS) {
+            sampler.weight = &anim.samplers[channel.sampler];
+        }
+    }
+
+    return samplers;
+}
+
+void glTF2Importer::ImportAnimations(glTF2::Asset &r) {
+    if (!r.scene) return;
+
+    const unsigned numAnimations = r.animations.Size();
+    ASSIMP_LOG_DEBUG("Importing ", numAnimations, " animations");
+    mScene->mNumAnimations = numAnimations;
+    if (mScene->mNumAnimations == 0) {
+        return;
+    }
+
+    mScene->mAnimations = new aiAnimation *[numAnimations];
+    std::fill(mScene->mAnimations, mScene->mAnimations + numAnimations, nullptr);
+
+    for (unsigned int i = 0; i < numAnimations; ++i) {
+        aiAnimation *ai_anim = mScene->mAnimations[i] = new aiAnimation();
+
+        Animation &anim = r.animations[i];
+
+        ai_anim->mName = anim.name;
+        ai_anim->mDuration = 0;
+        ai_anim->mTicksPerSecond = 0;
+
+        std::unordered_map<unsigned int, AnimationSamplers> samplers = GatherSamplers(anim);
+
+        uint32_t numChannels = 0u;
+        uint32_t numMorphMeshChannels = 0u;
+
+        for (auto &iter : samplers) {
+            if ((nullptr != iter.second.rotation) || (nullptr != iter.second.scale) || (nullptr != iter.second.translation)) {
+                ++numChannels;
+            }
+            if (nullptr != iter.second.weight) {
+                ++numMorphMeshChannels;
+            }
+        }
+
+        ai_anim->mNumChannels = numChannels;
+        if (ai_anim->mNumChannels > 0) {
+            ai_anim->mChannels = new aiNodeAnim *[ai_anim->mNumChannels];
+            std::fill(ai_anim->mChannels, ai_anim->mChannels + ai_anim->mNumChannels, nullptr);
+            int j = 0;
+            for (auto &iter : samplers) {
+                if ((nullptr != iter.second.rotation) || (nullptr != iter.second.scale) || (nullptr != iter.second.translation)) {
+                    ai_anim->mChannels[j] = CreateNodeAnim(r, r.nodes[iter.first], iter.second);
+                    ++j;
+                }
+            }
+        }
+
+        ai_anim->mNumMorphMeshChannels = numMorphMeshChannels;
+        if (ai_anim->mNumMorphMeshChannels > 0) {
+            ai_anim->mMorphMeshChannels = new aiMeshMorphAnim *[ai_anim->mNumMorphMeshChannels];
+            std::fill(ai_anim->mMorphMeshChannels, ai_anim->mMorphMeshChannels + ai_anim->mNumMorphMeshChannels, nullptr);
+            int j = 0;
+            for (auto &iter : samplers) {
+                if (nullptr != iter.second.weight) {
+                    ai_anim->mMorphMeshChannels[j] = CreateMeshMorphAnim(r, r.nodes[iter.first], iter.second);
+                    ++j;
+                }
+            }
+        }
+
+        // Use the latest key-frame for the duration of the animation
+        double maxDuration = 0;
+        unsigned int maxNumberOfKeys = 0;
+        for (unsigned int j = 0; j < ai_anim->mNumChannels; ++j) {
+            auto chan = ai_anim->mChannels[j];
+            if (chan->mNumPositionKeys) {
+                auto lastPosKey = chan->mPositionKeys[chan->mNumPositionKeys - 1];
+                if (lastPosKey.mTime > maxDuration) {
+                    maxDuration = lastPosKey.mTime;
+                }
+                maxNumberOfKeys = std::max(maxNumberOfKeys, chan->mNumPositionKeys);
+            }
+            if (chan->mNumRotationKeys) {
+                auto lastRotKey = chan->mRotationKeys[chan->mNumRotationKeys - 1];
+                if (lastRotKey.mTime > maxDuration) {
+                    maxDuration = lastRotKey.mTime;
+                }
+                maxNumberOfKeys = std::max(maxNumberOfKeys, chan->mNumRotationKeys);
+            }
+            if (chan->mNumScalingKeys) {
+                auto lastScaleKey = chan->mScalingKeys[chan->mNumScalingKeys - 1];
+                if (lastScaleKey.mTime > maxDuration) {
+                    maxDuration = lastScaleKey.mTime;
+                }
+                maxNumberOfKeys = std::max(maxNumberOfKeys, chan->mNumScalingKeys);
+            }
+        }
+
+        for (unsigned int j = 0; j < ai_anim->mNumMorphMeshChannels; ++j) {
+            const auto *const chan = ai_anim->mMorphMeshChannels[j];
+
+            if (0u != chan->mNumKeys) {
+                const auto &lastKey = chan->mKeys[chan->mNumKeys - 1u];
+                if (lastKey.mTime > maxDuration) {
+                    maxDuration = lastKey.mTime;
+                }
+                maxNumberOfKeys = std::max(maxNumberOfKeys, chan->mNumKeys);
+            }
+        }
+
+        ai_anim->mDuration = maxDuration;
+        ai_anim->mTicksPerSecond = 1000.0;
+    }
+}
+
+static unsigned int countEmbeddedTextures(glTF2::Asset &r) {
+    unsigned int numEmbeddedTexs = 0;
+    for (size_t i = 0; i < r.images.Size(); ++i) {
+        if (r.images[i].HasData()) {
+            numEmbeddedTexs += 1;
+        }
+    }
+
+    return numEmbeddedTexs;
+}
+
+void glTF2Importer::ImportEmbeddedTextures(glTF2::Asset &r) {
+    mEmbeddedTexIdxs.resize(r.images.Size(), -1);
+    const unsigned int numEmbeddedTexs = countEmbeddedTextures(r);
+    if (numEmbeddedTexs == 0) {
+        return;
+    }
+
+    ASSIMP_LOG_DEBUG("Importing ", numEmbeddedTexs, " embedded textures");
+
+    mScene->mTextures = new aiTexture *[numEmbeddedTexs];
+    std::fill(mScene->mTextures, mScene->mTextures + numEmbeddedTexs, nullptr);
+
+    // Add the embedded textures
+    for (size_t i = 0; i < r.images.Size(); ++i) {
+        Image &img = r.images[i];
+        if (!img.HasData()) {
+            continue;
+        }
+
+        int idx = mScene->mNumTextures++;
+        mEmbeddedTexIdxs[i] = idx;
+
+        aiTexture *tex = mScene->mTextures[idx] = new aiTexture();
+
+        size_t length = img.GetDataLength();
+        void *data = img.StealData();
+
+        tex->mFilename = img.name;
+        tex->mWidth = static_cast<unsigned int>(length);
+        tex->mHeight = 0;
+        tex->pcData = reinterpret_cast<aiTexel *>(data);
+
+        if (!img.mimeType.empty()) {
+            const char *ext = strchr(img.mimeType.c_str(), '/') + 1;
+            if (ext) {
+                if (strcmp(ext, "jpeg") == 0) {
+                    ext = "jpg";
+                } else if (strcmp(ext, "ktx2") == 0) { //basisu: ktx remains
+                    ext = "kx2";
+                } else if (strcmp(ext, "basis") == 0) { //basisu
+                    ext = "bu";
+                }
+
+                size_t len = strlen(ext);
+                if (len <= 3) {
+                    strcpy(tex->achFormatHint, ext);
+                }
+            }
+        }
+    }
+}
+
+void glTF2Importer::ImportCommonMetadata(glTF2::Asset &a) {
+    ASSIMP_LOG_DEBUG("Importing metadata");
+    ai_assert(mScene->mMetaData == nullptr);
+    const bool hasVersion = !a.asset.version.empty();
+    const bool hasGenerator = !a.asset.generator.empty();
+    const bool hasCopyright = !a.asset.copyright.empty();
+    const bool hasSceneMetadata = a.scene->customExtensions;
+    if (hasVersion || hasGenerator || hasCopyright || hasSceneMetadata) {
+        mScene->mMetaData = new aiMetadata;
+        if (hasVersion) {
+            mScene->mMetaData->Add(AI_METADATA_SOURCE_FORMAT_VERSION, aiString(a.asset.version));
+        }
+        if (hasGenerator) {
+            mScene->mMetaData->Add(AI_METADATA_SOURCE_GENERATOR, aiString(a.asset.generator));
+        }
+        if (hasCopyright) {
+            mScene->mMetaData->Add(AI_METADATA_SOURCE_COPYRIGHT, aiString(a.asset.copyright));
+        }
+        if (hasSceneMetadata) {
+            ParseExtensions(mScene->mMetaData, a.scene->customExtensions);
+        }
+    }
+}
+
+void glTF2Importer::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
+    ASSIMP_LOG_DEBUG("Reading GLTF2 file");
+
+    // clean all member arrays
+    meshOffsets.clear();
+    mEmbeddedTexIdxs.clear();
+
+    this->mScene = pScene;
+
+    // read the asset file
+    glTF2::Asset asset(pIOHandler, static_cast<rapidjson::IRemoteSchemaDocumentProvider *>(mSchemaDocumentProvider));
+    asset.Load(pFile, GetExtension(pFile) == "glb");
+    if (asset.scene) {
+        pScene->mName = asset.scene->name;
+    }
+
+    // Copy the data out
+    ImportEmbeddedTextures(asset);
+    ImportMaterials(asset);
+
+    ImportMeshes(asset);
+
+    ImportCameras(asset);
+    ImportLights(asset);
+
+    ImportNodes(asset);
+
+    ImportAnimations(asset);
+
+    ImportCommonMetadata(asset);
+
+    if (pScene->mNumMeshes == 0) {
+        pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
+    }
+}
+
+void glTF2Importer::SetupProperties(const Importer *pImp) {
+    mSchemaDocumentProvider = static_cast<rapidjson::IRemoteSchemaDocumentProvider *>(pImp->GetPropertyPointer(AI_CONFIG_IMPORT_SCHEMA_DOCUMENT_PROVIDER));
+}
+
+#endif // ASSIMP_BUILD_NO_GLTF_IMPORTER
diff --git a/Engine/lib/assimp/code/glTF2/glTF2Importer.h b/Engine/lib/assimp/code/AssetLib/glTF2/glTF2Importer.h
similarity index 67%
rename from Engine/lib/assimp/code/glTF2/glTF2Importer.h
rename to Engine/lib/assimp/code/AssetLib/glTF2/glTF2Importer.h
index 091b61ee6..831bcd7d2 100644
--- a/Engine/lib/assimp/code/glTF2/glTF2Importer.h
+++ b/Engine/lib/assimp/code/AssetLib/glTF2/glTF2Importer.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -43,13 +43,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define AI_GLTF2IMPORTER_H_INC
 
 #include <assimp/BaseImporter.h>
-#include <assimp/DefaultIOSystem.h>
 
 struct aiNode;
 
-
-namespace glTF2
-{
+namespace glTF2 {
     class Asset;
 }
 
@@ -59,34 +56,36 @@ namespace Assimp {
  * Load the glTF2 format.
  * https://github.com/KhronosGroup/glTF/tree/master/specification
  */
-class glTF2Importer : public BaseImporter{
+class glTF2Importer : public BaseImporter {
 public:
     glTF2Importer();
-    virtual ~glTF2Importer();
-    virtual bool CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig ) const;
+    ~glTF2Importer() override;
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const override;
 
 protected:
-    virtual const aiImporterDesc* GetInfo() const;
-    virtual void InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler );
+    const aiImporterDesc *GetInfo() const override;
+    void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) override;
+    virtual void SetupProperties(const Importer *pImp) override;
 
 private:
+    void ImportEmbeddedTextures(glTF2::Asset &a);
+    void ImportMaterials(glTF2::Asset &a);
+    void ImportMeshes(glTF2::Asset &a);
+    void ImportCameras(glTF2::Asset &a);
+    void ImportLights(glTF2::Asset &a);
+    void ImportNodes(glTF2::Asset &a);
+    void ImportAnimations(glTF2::Asset &a);
+    void ImportCommonMetadata(glTF2::Asset &a);
 
+private:
     std::vector<unsigned int> meshOffsets;
+    std::vector<int> mEmbeddedTexIdxs;
+    aiScene *mScene;
 
-    std::vector<int> embeddedTexIdxs;
-
-    aiScene* mScene;
-
-    void ImportEmbeddedTextures(glTF2::Asset& a);
-    void ImportMaterials(glTF2::Asset& a);
-    void ImportMeshes(glTF2::Asset& a);
-    void ImportCameras(glTF2::Asset& a);
-    void ImportLights(glTF2::Asset& a);
-    void ImportNodes(glTF2::Asset& a);
-    void ImportAnimations(glTF2::Asset& a);
+    /// An instance of rapidjson::IRemoteSchemaDocumentProvider
+    void *mSchemaDocumentProvider = nullptr;
 };
 
-} // Namespace assimp
+} // namespace Assimp
 
 #endif // AI_GLTF2IMPORTER_H_INC
-
diff --git a/Engine/lib/assimp/code/Assxml/AssxmlExporter.cpp b/Engine/lib/assimp/code/Assxml/AssxmlExporter.cpp
deleted file mode 100644
index afdecbaf6..000000000
--- a/Engine/lib/assimp/code/Assxml/AssxmlExporter.cpp
+++ /dev/null
@@ -1,655 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-/** @file  AssxmlExporter.cpp
- *  ASSXML exporter main code
- */
-
-#ifndef ASSIMP_BUILD_NO_EXPORT
-#ifndef ASSIMP_BUILD_NO_ASSXML_EXPORTER
-
-#include "PostProcessing/ProcessHelper.h"
-
-#include <assimp/version.h>
-#include <assimp/IOStream.hpp>
-#include <assimp/IOSystem.hpp>
-#include <assimp/Exporter.hpp>
-
-#include <stdarg.h>
-
-#ifdef ASSIMP_BUILD_NO_OWN_ZLIB
-#   include <zlib.h>
-#else
-#   include <contrib/zlib/zlib.h>
-#endif
-
-#include <time.h>
-#include <stdio.h>
-
-using namespace Assimp;
-
-namespace Assimp    {
-
-namespace AssxmlExport  {
-
-// -----------------------------------------------------------------------------------
-static int ioprintf( IOStream * io, const char *format, ... ) {
-	using namespace std;
-    if ( nullptr == io ) {
-        return -1;
-    }
-
-    static const int Size = 4096;
-    char sz[ Size ];
-    ::memset( sz, '\0', Size );
-    va_list va;
-    va_start( va, format );
-    const unsigned int nSize = vsnprintf( sz, Size-1, format, va );
-    ai_assert( nSize < Size );
-    va_end( va );
-
-    io->Write( sz, sizeof(char), nSize );
-
-    return nSize;
-}
-
-// -----------------------------------------------------------------------------------
-// Convert a name to standard XML format
-static void ConvertName(aiString& out, const aiString& in) {
-    out.length = 0;
-    for (unsigned int i = 0; i < in.length; ++i)  {
-        switch (in.data[i]) {
-            case '<':
-                out.Append("&lt;");break;
-            case '>':
-                out.Append("&gt;");break;
-            case '&':
-                out.Append("&amp;");break;
-            case '\"':
-                out.Append("&quot;");break;
-            case '\'':
-                out.Append("&apos;");break;
-            default:
-                out.data[out.length++] = in.data[i];
-        }
-    }
-    out.data[out.length] = 0;
-}
-
-// -----------------------------------------------------------------------------------
-// Write a single node as text dump
-static void WriteNode(const aiNode* node, IOStream * io, unsigned int depth) {
-    char prefix[512];
-    for (unsigned int i = 0; i < depth;++i)
-        prefix[i] = '\t';
-    prefix[depth] = '\0';
-
-    const aiMatrix4x4& m = node->mTransformation;
-
-    aiString name;
-    ConvertName(name,node->mName);
-    ioprintf(io,"%s<Node name=\"%s\"> \n"
-        "%s\t<Matrix4> \n"
-        "%s\t\t%0 6f %0 6f %0 6f %0 6f\n"
-        "%s\t\t%0 6f %0 6f %0 6f %0 6f\n"
-        "%s\t\t%0 6f %0 6f %0 6f %0 6f\n"
-        "%s\t\t%0 6f %0 6f %0 6f %0 6f\n"
-        "%s\t</Matrix4> \n",
-        prefix,name.data,prefix,
-        prefix,m.a1,m.a2,m.a3,m.a4,
-        prefix,m.b1,m.b2,m.b3,m.b4,
-        prefix,m.c1,m.c2,m.c3,m.c4,
-        prefix,m.d1,m.d2,m.d3,m.d4,prefix);
-
-    if (node->mNumMeshes) {
-        ioprintf(io, "%s\t<MeshRefs num=\"%i\">\n%s\t",
-            prefix,node->mNumMeshes,prefix);
-
-        for (unsigned int i = 0; i < node->mNumMeshes;++i) {
-            ioprintf(io,"%i ",node->mMeshes[i]);
-        }
-        ioprintf(io,"\n%s\t</MeshRefs>\n",prefix);
-    }
-
-    if (node->mNumChildren) {
-        ioprintf(io,"%s\t<NodeList num=\"%i\">\n",
-            prefix,node->mNumChildren);
-
-        for (unsigned int i = 0; i < node->mNumChildren;++i) {
-            WriteNode(node->mChildren[i],io,depth+2);
-        }
-        ioprintf(io,"%s\t</NodeList>\n",prefix);
-    }
-    ioprintf(io,"%s</Node>\n",prefix);
-}
-
-
-// -----------------------------------------------------------------------------------
-// Some chuncks of text will need to be encoded for XML
-// http://stackoverflow.com/questions/5665231/most-efficient-way-to-escape-xml-html-in-c-string#5665377
-static std::string encodeXML(const std::string& data) {
-    std::string buffer;
-    buffer.reserve(data.size());
-    for(size_t pos = 0; pos != data.size(); ++pos) {
-            switch(data[pos]) {
-                    case '&':  buffer.append("&amp;");              break;
-                    case '\"': buffer.append("&quot;");             break;
-                    case '\'': buffer.append("&apos;");             break;
-                    case '<':  buffer.append("&lt;");                   break;
-                    case '>':  buffer.append("&gt;");                   break;
-                    default:   buffer.append(&data[pos], 1);    break;
-            }
-    }
-    return buffer;
-}
-
-// -----------------------------------------------------------------------------------
-// Write a text model dump
-static
-void WriteDump(const aiScene* scene, IOStream* io, bool shortened) {
-    time_t tt = ::time( NULL );
-#if _WIN32
-    tm* p = gmtime(&tt);
-#else
-    struct tm now;
-    tm* p = gmtime_r(&tt, &now);
-#endif
-    ai_assert(nullptr != p);
-
-    // write header
-    std::string header(
-        "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
-        "<ASSIMP format_id=\"1\">\n\n"
-        "<!-- XML Model dump produced by assimp dump\n"
-        "  Library version: %i.%i.%i\n"
-        "  %s\n"
-        "-->"
-        " \n\n"
-        "<Scene flags=\"%d\" postprocessing=\"%i\">\n"
-    );
-
-    const unsigned int majorVersion( aiGetVersionMajor() );
-    const unsigned int minorVersion( aiGetVersionMinor() );
-    const unsigned int rev( aiGetVersionRevision() );
-    const char *curtime( asctime( p ) );
-    ioprintf( io, header.c_str(), majorVersion, minorVersion, rev, curtime, scene->mFlags, 0 );
-
-    // write the node graph
-    WriteNode(scene->mRootNode, io, 0);
-
-#if 0
-        // write cameras
-    for (unsigned int i = 0; i < scene->mNumCameras;++i) {
-        aiCamera* cam  = scene->mCameras[i];
-        ConvertName(name,cam->mName);
-
-        // camera header
-        ioprintf(io,"\t<Camera parent=\"%s\">\n"
-            "\t\t<Vector3 name=\"up\"        > %0 8f %0 8f %0 8f </Vector3>\n"
-            "\t\t<Vector3 name=\"lookat\"    > %0 8f %0 8f %0 8f </Vector3>\n"
-            "\t\t<Vector3 name=\"pos\"       > %0 8f %0 8f %0 8f </Vector3>\n"
-            "\t\t<Float   name=\"fov\"       > %f </Float>\n"
-            "\t\t<Float   name=\"aspect\"    > %f </Float>\n"
-            "\t\t<Float   name=\"near_clip\" > %f </Float>\n"
-            "\t\t<Float   name=\"far_clip\"  > %f </Float>\n"
-            "\t</Camera>\n",
-            name.data,
-            cam->mUp.x,cam->mUp.y,cam->mUp.z,
-            cam->mLookAt.x,cam->mLookAt.y,cam->mLookAt.z,
-            cam->mPosition.x,cam->mPosition.y,cam->mPosition.z,
-            cam->mHorizontalFOV,cam->mAspect,cam->mClipPlaneNear,cam->mClipPlaneFar,i);
-    }
-
-    // write lights
-    for (unsigned int i = 0; i < scene->mNumLights;++i) {
-        aiLight* l  = scene->mLights[i];
-        ConvertName(name,l->mName);
-
-        // light header
-        ioprintf(io,"\t<Light parent=\"%s\"> type=\"%s\"\n"
-            "\t\t<Vector3 name=\"diffuse\"   > %0 8f %0 8f %0 8f </Vector3>\n"
-            "\t\t<Vector3 name=\"specular\"  > %0 8f %0 8f %0 8f </Vector3>\n"
-            "\t\t<Vector3 name=\"ambient\"   > %0 8f %0 8f %0 8f </Vector3>\n",
-            name.data,
-            (l->mType == aiLightSource_DIRECTIONAL ? "directional" :
-            (l->mType == aiLightSource_POINT ? "point" : "spot" )),
-            l->mColorDiffuse.r, l->mColorDiffuse.g, l->mColorDiffuse.b,
-            l->mColorSpecular.r,l->mColorSpecular.g,l->mColorSpecular.b,
-            l->mColorAmbient.r, l->mColorAmbient.g, l->mColorAmbient.b);
-
-        if (l->mType != aiLightSource_DIRECTIONAL) {
-            ioprintf(io,
-                "\t\t<Vector3 name=\"pos\"       > %0 8f %0 8f %0 8f </Vector3>\n"
-                "\t\t<Float   name=\"atten_cst\" > %f </Float>\n"
-                "\t\t<Float   name=\"atten_lin\" > %f </Float>\n"
-                "\t\t<Float   name=\"atten_sqr\" > %f </Float>\n",
-                l->mPosition.x,l->mPosition.y,l->mPosition.z,
-                l->mAttenuationConstant,l->mAttenuationLinear,l->mAttenuationQuadratic);
-        }
-
-        if (l->mType != aiLightSource_POINT) {
-            ioprintf(io,
-                "\t\t<Vector3 name=\"lookat\"    > %0 8f %0 8f %0 8f </Vector3>\n",
-                l->mDirection.x,l->mDirection.y,l->mDirection.z);
-        }
-
-        if (l->mType == aiLightSource_SPOT) {
-            ioprintf(io,
-                "\t\t<Float   name=\"cone_out\" > %f </Float>\n"
-                "\t\t<Float   name=\"cone_inn\" > %f </Float>\n",
-                l->mAngleOuterCone,l->mAngleInnerCone);
-        }
-        ioprintf(io,"\t</Light>\n");
-    }
-#endif
-    aiString name;
-
-    // write textures
-    if (scene->mNumTextures) {
-        ioprintf(io,"<TextureList num=\"%i\">\n",scene->mNumTextures);
-        for (unsigned int i = 0; i < scene->mNumTextures;++i) {
-            aiTexture* tex  = scene->mTextures[i];
-            bool compressed = (tex->mHeight == 0);
-
-            // mesh header
-            ioprintf(io,"\t<Texture width=\"%i\" height=\"%i\" compressed=\"%s\"> \n",
-                (compressed ? -1 : tex->mWidth),(compressed ? -1 : tex->mHeight),
-                (compressed ? "true" : "false"));
-
-            if (compressed) {
-                ioprintf(io,"\t\t<Data length=\"%i\"> \n",tex->mWidth);
-
-                if (!shortened) {
-                    for (unsigned int n = 0; n < tex->mWidth;++n) {
-                        ioprintf(io,"\t\t\t%2x",reinterpret_cast<uint8_t*>(tex->pcData)[n]);
-                        if (n && !(n % 50)) {
-                            ioprintf(io,"\n");
-                        }
-                    }
-                }
-            }
-            else if (!shortened){
-                ioprintf(io,"\t\t<Data length=\"%i\"> \n",tex->mWidth*tex->mHeight*4);
-
-                // const unsigned int width = (unsigned int)std::log10((double)std::max(tex->mHeight,tex->mWidth))+1;
-                for (unsigned int y = 0; y < tex->mHeight;++y) {
-                    for (unsigned int x = 0; x < tex->mWidth;++x) {
-                        aiTexel* tx = tex->pcData + y*tex->mWidth+x;
-                        unsigned int r = tx->r,g=tx->g,b=tx->b,a=tx->a;
-                        ioprintf(io,"\t\t\t%2x %2x %2x %2x",r,g,b,a);
-
-                        // group by four for readability
-                        if ( 0 == ( x + y*tex->mWidth ) % 4 ) {
-                            ioprintf( io, "\n" );
-                        }
-                    }
-                }
-            }
-            ioprintf(io,"\t\t</Data>\n\t</Texture>\n");
-        }
-        ioprintf(io,"</TextureList>\n");
-    }
-
-    // write materials
-    if (scene->mNumMaterials) {
-        ioprintf(io,"<MaterialList num=\"%i\">\n",scene->mNumMaterials);
-        for (unsigned int i = 0; i< scene->mNumMaterials; ++i) {
-            const aiMaterial* mat = scene->mMaterials[i];
-
-            ioprintf(io,"\t<Material>\n");
-            ioprintf(io,"\t\t<MatPropertyList  num=\"%i\">\n",mat->mNumProperties);
-            for (unsigned int n = 0; n < mat->mNumProperties;++n) {
-
-                const aiMaterialProperty* prop = mat->mProperties[n];
-                const char* sz = "";
-                if (prop->mType == aiPTI_Float) {
-                    sz = "float";
-                }
-                else if (prop->mType == aiPTI_Integer) {
-                    sz = "integer";
-                }
-                else if (prop->mType == aiPTI_String) {
-                    sz = "string";
-                }
-                else if (prop->mType == aiPTI_Buffer) {
-                    sz = "binary_buffer";
-                }
-
-                ioprintf(io,"\t\t\t<MatProperty key=\"%s\" \n\t\t\ttype=\"%s\" tex_usage=\"%s\" tex_index=\"%i\"",
-                    prop->mKey.data, sz,
-                    ::TextureTypeToString((aiTextureType)prop->mSemantic),prop->mIndex);
-
-                if (prop->mType == aiPTI_Float) {
-                    ioprintf(io," size=\"%i\">\n\t\t\t\t",
-                        static_cast<int>(prop->mDataLength/sizeof(float)));
-
-                    for (unsigned int p = 0; p < prop->mDataLength/sizeof(float);++p) {
-                        ioprintf(io,"%f ",*((float*)(prop->mData+p*sizeof(float))));
-                    }
-                }
-                else if (prop->mType == aiPTI_Integer) {
-                    ioprintf(io," size=\"%i\">\n\t\t\t\t",
-                        static_cast<int>(prop->mDataLength/sizeof(int)));
-
-                    for (unsigned int p = 0; p < prop->mDataLength/sizeof(int);++p) {
-                        ioprintf(io,"%i ",*((int*)(prop->mData+p*sizeof(int))));
-                    }
-                }
-                else if (prop->mType == aiPTI_Buffer) {
-                    ioprintf(io," size=\"%i\">\n\t\t\t\t",
-                        static_cast<int>(prop->mDataLength));
-
-                    for (unsigned int p = 0; p < prop->mDataLength;++p) {
-                        ioprintf(io,"%2x ",prop->mData[p]);
-                        if (p && 0 == p%30) {
-                            ioprintf(io,"\n\t\t\t\t");
-                        }
-                    }
-                }
-                else if (prop->mType == aiPTI_String) {
-                    ioprintf(io,">\n\t\t\t\t\"%s\"",encodeXML(prop->mData+4).c_str() /* skip length */);
-                }
-                ioprintf(io,"\n\t\t\t</MatProperty>\n");
-            }
-            ioprintf(io,"\t\t</MatPropertyList>\n");
-            ioprintf(io,"\t</Material>\n");
-        }
-        ioprintf(io,"</MaterialList>\n");
-    }
-
-    // write animations
-    if (scene->mNumAnimations) {
-        ioprintf(io,"<AnimationList num=\"%i\">\n",scene->mNumAnimations);
-        for (unsigned int i = 0; i < scene->mNumAnimations;++i) {
-            aiAnimation* anim = scene->mAnimations[i];
-
-            // anim header
-            ConvertName(name,anim->mName);
-            ioprintf(io,"\t<Animation name=\"%s\" duration=\"%e\" tick_cnt=\"%e\">\n",
-                name.data, anim->mDuration, anim->mTicksPerSecond);
-
-            // write bone animation channels
-            if (anim->mNumChannels) {
-                ioprintf(io,"\t\t<NodeAnimList num=\"%i\">\n",anim->mNumChannels);
-                for (unsigned int n = 0; n < anim->mNumChannels;++n) {
-                    aiNodeAnim* nd = anim->mChannels[n];
-
-                    // node anim header
-                    ConvertName(name,nd->mNodeName);
-                    ioprintf(io,"\t\t\t<NodeAnim node=\"%s\">\n",name.data);
-
-                    if (!shortened) {
-                        // write position keys
-                        if (nd->mNumPositionKeys) {
-                            ioprintf(io,"\t\t\t\t<PositionKeyList num=\"%i\">\n",nd->mNumPositionKeys);
-                            for (unsigned int a = 0; a < nd->mNumPositionKeys;++a) {
-                                aiVectorKey* vc = nd->mPositionKeys+a;
-                                ioprintf(io,"\t\t\t\t\t<PositionKey time=\"%e\">\n"
-                                    "\t\t\t\t\t\t%0 8f %0 8f %0 8f\n\t\t\t\t\t</PositionKey>\n",
-                                    vc->mTime,vc->mValue.x,vc->mValue.y,vc->mValue.z);
-                            }
-                            ioprintf(io,"\t\t\t\t</PositionKeyList>\n");
-                        }
-
-                        // write scaling keys
-                        if (nd->mNumScalingKeys) {
-                            ioprintf(io,"\t\t\t\t<ScalingKeyList num=\"%i\">\n",nd->mNumScalingKeys);
-                            for (unsigned int a = 0; a < nd->mNumScalingKeys;++a) {
-                                aiVectorKey* vc = nd->mScalingKeys+a;
-                                ioprintf(io,"\t\t\t\t\t<ScalingKey time=\"%e\">\n"
-                                    "\t\t\t\t\t\t%0 8f %0 8f %0 8f\n\t\t\t\t\t</ScalingKey>\n",
-                                    vc->mTime,vc->mValue.x,vc->mValue.y,vc->mValue.z);
-                            }
-                            ioprintf(io,"\t\t\t\t</ScalingKeyList>\n");
-                        }
-
-                        // write rotation keys
-                        if (nd->mNumRotationKeys) {
-                            ioprintf(io,"\t\t\t\t<RotationKeyList num=\"%i\">\n",nd->mNumRotationKeys);
-                            for (unsigned int a = 0; a < nd->mNumRotationKeys;++a) {
-                                aiQuatKey* vc = nd->mRotationKeys+a;
-                                ioprintf(io,"\t\t\t\t\t<RotationKey time=\"%e\">\n"
-                                    "\t\t\t\t\t\t%0 8f %0 8f %0 8f %0 8f\n\t\t\t\t\t</RotationKey>\n",
-                                    vc->mTime,vc->mValue.x,vc->mValue.y,vc->mValue.z,vc->mValue.w);
-                            }
-                            ioprintf(io,"\t\t\t\t</RotationKeyList>\n");
-                        }
-                    }
-                    ioprintf(io,"\t\t\t</NodeAnim>\n");
-                }
-                ioprintf(io,"\t\t</NodeAnimList>\n");
-            }
-            ioprintf(io,"\t</Animation>\n");
-        }
-        ioprintf(io,"</AnimationList>\n");
-    }
-
-    // write meshes
-    if (scene->mNumMeshes) {
-        ioprintf(io,"<MeshList num=\"%i\">\n",scene->mNumMeshes);
-        for (unsigned int i = 0; i < scene->mNumMeshes;++i) {
-            aiMesh* mesh = scene->mMeshes[i];
-            // const unsigned int width = (unsigned int)std::log10((double)mesh->mNumVertices)+1;
-
-            // mesh header
-            ioprintf(io,"\t<Mesh types=\"%s %s %s %s\" material_index=\"%i\">\n",
-                (mesh->mPrimitiveTypes & aiPrimitiveType_POINT    ? "points"    : ""),
-                (mesh->mPrimitiveTypes & aiPrimitiveType_LINE     ? "lines"     : ""),
-                (mesh->mPrimitiveTypes & aiPrimitiveType_TRIANGLE ? "triangles" : ""),
-                (mesh->mPrimitiveTypes & aiPrimitiveType_POLYGON  ? "polygons"  : ""),
-                mesh->mMaterialIndex);
-
-            // bones
-            if (mesh->mNumBones) {
-                ioprintf(io,"\t\t<BoneList num=\"%i\">\n",mesh->mNumBones);
-
-                for (unsigned int n = 0; n < mesh->mNumBones;++n) {
-                    aiBone* bone = mesh->mBones[n];
-
-                    ConvertName(name,bone->mName);
-                    // bone header
-                    ioprintf(io,"\t\t\t<Bone name=\"%s\">\n"
-                        "\t\t\t\t<Matrix4> \n"
-                        "\t\t\t\t\t%0 6f %0 6f %0 6f %0 6f\n"
-                        "\t\t\t\t\t%0 6f %0 6f %0 6f %0 6f\n"
-                        "\t\t\t\t\t%0 6f %0 6f %0 6f %0 6f\n"
-                        "\t\t\t\t\t%0 6f %0 6f %0 6f %0 6f\n"
-                        "\t\t\t\t</Matrix4> \n",
-                        name.data,
-                        bone->mOffsetMatrix.a1,bone->mOffsetMatrix.a2,bone->mOffsetMatrix.a3,bone->mOffsetMatrix.a4,
-                        bone->mOffsetMatrix.b1,bone->mOffsetMatrix.b2,bone->mOffsetMatrix.b3,bone->mOffsetMatrix.b4,
-                        bone->mOffsetMatrix.c1,bone->mOffsetMatrix.c2,bone->mOffsetMatrix.c3,bone->mOffsetMatrix.c4,
-                        bone->mOffsetMatrix.d1,bone->mOffsetMatrix.d2,bone->mOffsetMatrix.d3,bone->mOffsetMatrix.d4);
-
-                    if (!shortened && bone->mNumWeights) {
-                        ioprintf(io,"\t\t\t\t<WeightList num=\"%i\">\n",bone->mNumWeights);
-
-                        // bone weights
-                        for (unsigned int a = 0; a < bone->mNumWeights;++a) {
-                            aiVertexWeight* wght = bone->mWeights+a;
-
-                            ioprintf(io,"\t\t\t\t\t<Weight index=\"%i\">\n\t\t\t\t\t\t%f\n\t\t\t\t\t</Weight>\n",
-                                wght->mVertexId,wght->mWeight);
-                        }
-                        ioprintf(io,"\t\t\t\t</WeightList>\n");
-                    }
-                    ioprintf(io,"\t\t\t</Bone>\n");
-                }
-                ioprintf(io,"\t\t</BoneList>\n");
-            }
-
-            // faces
-            if (!shortened && mesh->mNumFaces) {
-                ioprintf(io,"\t\t<FaceList num=\"%i\">\n",mesh->mNumFaces);
-                for (unsigned int n = 0; n < mesh->mNumFaces; ++n) {
-                    aiFace& f = mesh->mFaces[n];
-                    ioprintf(io,"\t\t\t<Face num=\"%i\">\n"
-                        "\t\t\t\t",f.mNumIndices);
-
-                    for (unsigned int j = 0; j < f.mNumIndices;++j)
-                        ioprintf(io,"%i ",f.mIndices[j]);
-
-                    ioprintf(io,"\n\t\t\t</Face>\n");
-                }
-                ioprintf(io,"\t\t</FaceList>\n");
-            }
-
-            // vertex positions
-            if (mesh->HasPositions()) {
-                ioprintf(io,"\t\t<Positions num=\"%i\" set=\"0\" num_components=\"3\"> \n",mesh->mNumVertices);
-                if (!shortened) {
-                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
-                        ioprintf(io,"\t\t%0 8f %0 8f %0 8f\n",
-                            mesh->mVertices[n].x,
-                            mesh->mVertices[n].y,
-                            mesh->mVertices[n].z);
-                    }
-                }
-                ioprintf(io,"\t\t</Positions>\n");
-            }
-
-            // vertex normals
-            if (mesh->HasNormals()) {
-                ioprintf(io,"\t\t<Normals num=\"%i\" set=\"0\" num_components=\"3\"> \n",mesh->mNumVertices);
-                if (!shortened) {
-                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
-                        ioprintf(io,"\t\t%0 8f %0 8f %0 8f\n",
-                            mesh->mNormals[n].x,
-                            mesh->mNormals[n].y,
-                            mesh->mNormals[n].z);
-                    }
-                }
-                ioprintf(io,"\t\t</Normals>\n");
-            }
-
-            // vertex tangents and bitangents
-            if (mesh->HasTangentsAndBitangents()) {
-                ioprintf(io,"\t\t<Tangents num=\"%i\" set=\"0\" num_components=\"3\"> \n",mesh->mNumVertices);
-                if (!shortened) {
-                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
-                        ioprintf(io,"\t\t%0 8f %0 8f %0 8f\n",
-                            mesh->mTangents[n].x,
-                            mesh->mTangents[n].y,
-                            mesh->mTangents[n].z);
-                    }
-                }
-                ioprintf(io,"\t\t</Tangents>\n");
-
-                ioprintf(io,"\t\t<Bitangents num=\"%i\" set=\"0\" num_components=\"3\"> \n",mesh->mNumVertices);
-                if (!shortened) {
-                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
-                        ioprintf(io,"\t\t%0 8f %0 8f %0 8f\n",
-                            mesh->mBitangents[n].x,
-                            mesh->mBitangents[n].y,
-                            mesh->mBitangents[n].z);
-                    }
-                }
-                ioprintf(io,"\t\t</Bitangents>\n");
-            }
-
-            // texture coordinates
-            for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
-                if (!mesh->mTextureCoords[a])
-                    break;
-
-                ioprintf(io,"\t\t<TextureCoords num=\"%i\" set=\"%i\" num_components=\"%i\"> \n",mesh->mNumVertices,
-                    a,mesh->mNumUVComponents[a]);
-
-                if (!shortened) {
-                    if (mesh->mNumUVComponents[a] == 3) {
-                        for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
-                            ioprintf(io,"\t\t%0 8f %0 8f %0 8f\n",
-                                mesh->mTextureCoords[a][n].x,
-                                mesh->mTextureCoords[a][n].y,
-                                mesh->mTextureCoords[a][n].z);
-                        }
-                    }
-                    else {
-                        for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
-                            ioprintf(io,"\t\t%0 8f %0 8f\n",
-                                mesh->mTextureCoords[a][n].x,
-                                mesh->mTextureCoords[a][n].y);
-                        }
-                    }
-                }
-                ioprintf(io,"\t\t</TextureCoords>\n");
-            }
-
-            // vertex colors
-            for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a) {
-                if (!mesh->mColors[a])
-                    break;
-                ioprintf(io,"\t\t<Colors num=\"%i\" set=\"%i\" num_components=\"4\"> \n",mesh->mNumVertices,a);
-                if (!shortened) {
-                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
-                        ioprintf(io,"\t\t%0 8f %0 8f %0 8f %0 8f\n",
-                            mesh->mColors[a][n].r,
-                            mesh->mColors[a][n].g,
-                            mesh->mColors[a][n].b,
-                            mesh->mColors[a][n].a);
-                    }
-                }
-                ioprintf(io,"\t\t</Colors>\n");
-            }
-            ioprintf(io,"\t</Mesh>\n");
-        }
-        ioprintf(io,"</MeshList>\n");
-    }
-    ioprintf(io,"</Scene>\n</ASSIMP>");
-}
-
-} // end of namespace AssxmlExport
-
-void ExportSceneAssxml(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/)
-{
-    IOStream * out = pIOSystem->Open( pFile, "wt" );
-    if (!out) return;
-
-    bool shortened = false;
-    AssxmlExport::WriteDump( pScene, out, shortened );
-
-    pIOSystem->Close( out );
-}
-
-} // end of namespace Assimp
-
-#endif // ASSIMP_BUILD_NO_ASSXML_EXPORTER
-#endif // ASSIMP_BUILD_NO_EXPORT
diff --git a/Engine/lib/assimp/code/B3D/B3DImporter.cpp b/Engine/lib/assimp/code/B3D/B3DImporter.cpp
deleted file mode 100644
index ba484ca00..000000000
--- a/Engine/lib/assimp/code/B3D/B3DImporter.cpp
+++ /dev/null
@@ -1,740 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-/** @file  B3DImporter.cpp
- *  @brief Implementation of the b3d importer class
- */
-
-
-#ifndef ASSIMP_BUILD_NO_B3D_IMPORTER
-
-// internal headers
-#include "B3D/B3DImporter.h"
-#include "PostProcessing/TextureTransform.h"
-#include "PostProcessing/ConvertToLHProcess.h"
-
-#include <assimp/StringUtils.h>
-#include <assimp/IOSystem.hpp>
-#include <assimp/anim.h>
-#include <assimp/scene.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/importerdesc.h>
-
-#include <memory>
-
-using namespace Assimp;
-using namespace std;
-
-static const aiImporterDesc desc = {
-    "BlitzBasic 3D Importer",
-    "",
-    "",
-    "http://www.blitzbasic.com/",
-    aiImporterFlags_SupportBinaryFlavour,
-    0,
-    0,
-    0,
-    0,
-    "b3d"
-};
-
-// (fixme, Aramis) quick workaround to get rid of all those signed to unsigned warnings
-#ifdef _MSC_VER
-#	pragma warning (disable: 4018)
-#endif
-
-//#define DEBUG_B3D
-
-template<typename T>
-void DeleteAllBarePointers(std::vector<T>& x)
-{
-    for(auto p : x)
-    {
-        delete p;
-    }
-}
-
-B3DImporter::~B3DImporter()
-{
-}
-
-// ------------------------------------------------------------------------------------------------
-bool B3DImporter::CanRead( const std::string& pFile, IOSystem* /*pIOHandler*/, bool /*checkSig*/) const{
-
-    size_t pos=pFile.find_last_of( '.' );
-    if( pos==string::npos ) return false;
-
-    string ext=pFile.substr( pos+1 );
-    if( ext.size()!=3 ) return false;
-
-    return (ext[0]=='b' || ext[0]=='B') && (ext[1]=='3') && (ext[2]=='d' || ext[2]=='D');
-}
-
-// ------------------------------------------------------------------------------------------------
-// Loader meta information
-const aiImporterDesc* B3DImporter::GetInfo () const
-{
-    return &desc;
-}
-
-#ifdef DEBUG_B3D
-    extern "C"{ void _stdcall AllocConsole(); }
-#endif
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler){
-
-#ifdef DEBUG_B3D
-    AllocConsole();
-    freopen( "conin$","r",stdin );
-    freopen( "conout$","w",stdout );
-    freopen( "conout$","w",stderr );
-    cout<<"Hello world from the B3DImporter!"<<endl;
-#endif
-
-    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile));
-
-    // Check whether we can read from the file
-    if( file.get() == NULL)
-        throw DeadlyImportError( "Failed to open B3D file " + pFile + ".");
-
-    // check whether the .b3d file is large enough to contain
-    // at least one chunk.
-    size_t fileSize = file->FileSize();
-    if( fileSize<8 ) throw DeadlyImportError( "B3D File is too small.");
-
-    _pos=0;
-    _buf.resize( fileSize );
-    file->Read( &_buf[0],1,fileSize );
-    _stack.clear();
-
-    ReadBB3D( pScene );
-}
-
-// ------------------------------------------------------------------------------------------------
-AI_WONT_RETURN void B3DImporter::Oops(){
-    throw DeadlyImportError( "B3D Importer - INTERNAL ERROR" );
-}
-
-// ------------------------------------------------------------------------------------------------
-AI_WONT_RETURN void B3DImporter::Fail( string str ){
-#ifdef DEBUG_B3D
-    cout<<"Error in B3D file data: "<<str<<endl;
-#endif
-    throw DeadlyImportError( "B3D Importer - error in B3D file data: "+str );
-}
-
-// ------------------------------------------------------------------------------------------------
-int B3DImporter::ReadByte(){
-    if( _pos<_buf.size() ) return _buf[_pos++];
-    Fail( "EOF" );
-    return 0;
-}
-
-// ------------------------------------------------------------------------------------------------
-int B3DImporter::ReadInt(){
-    if( _pos+4<=_buf.size() ){
-        int n;
-        memcpy(&n, &_buf[_pos], 4);
-        _pos+=4;
-        return n;
-    }
-    Fail( "EOF" );
-    return 0;
-}
-
-// ------------------------------------------------------------------------------------------------
-float B3DImporter::ReadFloat(){
-    if( _pos+4<=_buf.size() ){
-        float n;
-        memcpy(&n, &_buf[_pos], 4);
-        _pos+=4;
-        return n;
-    }
-    Fail( "EOF" );
-    return 0.0f;
-}
-
-// ------------------------------------------------------------------------------------------------
-aiVector2D B3DImporter::ReadVec2(){
-    float x=ReadFloat();
-    float y=ReadFloat();
-    return aiVector2D( x,y );
-}
-
-// ------------------------------------------------------------------------------------------------
-aiVector3D B3DImporter::ReadVec3(){
-    float x=ReadFloat();
-    float y=ReadFloat();
-    float z=ReadFloat();
-    return aiVector3D( x,y,z );
-}
-
-// ------------------------------------------------------------------------------------------------
-aiQuaternion B3DImporter::ReadQuat(){
-    // (aramis_acg) Fix to adapt the loader to changed quat orientation
-    float w=-ReadFloat();
-    float x=ReadFloat();
-    float y=ReadFloat();
-    float z=ReadFloat();
-    return aiQuaternion( w,x,y,z );
-}
-
-// ------------------------------------------------------------------------------------------------
-string B3DImporter::ReadString(){
-    string str;
-    while( _pos<_buf.size() ){
-        char c=(char)ReadByte();
-        if( !c ) return str;
-        str+=c;
-    }
-    Fail( "EOF" );
-    return string();
-}
-
-// ------------------------------------------------------------------------------------------------
-string B3DImporter::ReadChunk(){
-    string tag;
-    for( int i=0;i<4;++i ){
-        tag+=char( ReadByte() );
-    }
-#ifdef DEBUG_B3D
-//	cout<<"ReadChunk:"<<tag<<endl;
-#endif
-    unsigned sz=(unsigned)ReadInt();
-    _stack.push_back( _pos+sz );
-    return tag;
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ExitChunk(){
-    _pos=_stack.back();
-    _stack.pop_back();
-}
-
-// ------------------------------------------------------------------------------------------------
-unsigned B3DImporter::ChunkSize(){
-    return _stack.back()-_pos;
-}
-// ------------------------------------------------------------------------------------------------
-
-template<class T>
-T *B3DImporter::to_array( const vector<T> &v ){
-    if( v.empty() ) {
-        return 0;
-    }
-    T *p=new T[ v.size() ];
-    for( size_t i=0;i<v.size();++i ){
-        p[i]=v[i];
-    }
-    return p;
-}
-
-
-// ------------------------------------------------------------------------------------------------
-template<class T>
-T **unique_to_array( vector<std::unique_ptr<T> > &v ){
-    if( v.empty() ) {
-        return 0;
-    }
-    T **p = new T*[ v.size() ];
-    for( size_t i = 0; i < v.size(); ++i ){
-        p[i] = v[i].release();
-    }
-    return p;
-}
-
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ReadTEXS(){
-    while( ChunkSize() ){
-        string name=ReadString();
-        /*int flags=*/ReadInt();
-        /*int blend=*/ReadInt();
-        /*aiVector2D pos=*/ReadVec2();
-        /*aiVector2D scale=*/ReadVec2();
-        /*float rot=*/ReadFloat();
-
-        _textures.push_back( name );
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ReadBRUS(){
-    int n_texs=ReadInt();
-    if( n_texs<0 || n_texs>8 ){
-        Fail( "Bad texture count" );
-    }
-    while( ChunkSize() ){
-        string name=ReadString();
-        aiVector3D color=ReadVec3();
-        float alpha=ReadFloat();
-        float shiny=ReadFloat();
-        /*int blend=**/ReadInt();
-        int fx=ReadInt();
-
-        std::unique_ptr<aiMaterial> mat(new aiMaterial);
-
-        // Name
-        aiString ainame( name );
-        mat->AddProperty( &ainame,AI_MATKEY_NAME );
-
-        // Diffuse color
-        mat->AddProperty( &color,1,AI_MATKEY_COLOR_DIFFUSE );
-
-        // Opacity
-        mat->AddProperty( &alpha,1,AI_MATKEY_OPACITY );
-
-        // Specular color
-        aiColor3D speccolor( shiny,shiny,shiny );
-        mat->AddProperty( &speccolor,1,AI_MATKEY_COLOR_SPECULAR );
-
-        // Specular power
-        float specpow=shiny*128;
-        mat->AddProperty( &specpow,1,AI_MATKEY_SHININESS );
-
-        // Double sided
-        if( fx & 0x10 ){
-            int i=1;
-            mat->AddProperty( &i,1,AI_MATKEY_TWOSIDED );
-        }
-
-        //Textures
-        for( int i=0;i<n_texs;++i ){
-            int texid=ReadInt();
-            if( texid<-1 || (texid>=0 && texid>=static_cast<int>(_textures.size())) ){
-                Fail( "Bad texture id" );
-            }
-            if( i==0 && texid>=0 ){
-                aiString texname( _textures[texid] );
-                mat->AddProperty( &texname,AI_MATKEY_TEXTURE_DIFFUSE(0) );
-            }
-        }
-        _materials.emplace_back( std::move(mat) );
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ReadVRTS(){
-    _vflags=ReadInt();
-    _tcsets=ReadInt();
-    _tcsize=ReadInt();
-    if( _tcsets<0 || _tcsets>4 || _tcsize<0 || _tcsize>4 ){
-        Fail( "Bad texcoord data" );
-    }
-
-    int sz=12+(_vflags&1?12:0)+(_vflags&2?16:0)+(_tcsets*_tcsize*4);
-    int n_verts=ChunkSize()/sz;
-
-    int v0=static_cast<int>(_vertices.size());
-    _vertices.resize( v0+n_verts );
-
-    for( int i=0;i<n_verts;++i ){
-        Vertex &v=_vertices[v0+i];
-
-        memset( v.bones,0,sizeof(v.bones) );
-        memset( v.weights,0,sizeof(v.weights) );
-
-        v.vertex=ReadVec3();
-
-        if( _vflags & 1 ) v.normal=ReadVec3();
-
-        if( _vflags & 2 ) ReadQuat();	//skip v 4bytes...
-
-        for( int i=0;i<_tcsets;++i ){
-            float t[4]={0,0,0,0};
-            for( int j=0;j<_tcsize;++j ){
-                t[j]=ReadFloat();
-            }
-            t[1]=1-t[1];
-            if( !i ) v.texcoords=aiVector3D( t[0],t[1],t[2] );
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ReadTRIS( int v0 ){
-    int matid=ReadInt();
-    if( matid==-1 ){
-        matid=0;
-    }else if( matid<0 || matid>=(int)_materials.size() ){
-#ifdef DEBUG_B3D
-        cout<<"material id="<<matid<<endl;
-#endif
-        Fail( "Bad material id" );
-    }
-
-    std::unique_ptr<aiMesh> mesh(new aiMesh);
-
-    mesh->mMaterialIndex=matid;
-    mesh->mNumFaces=0;
-    mesh->mPrimitiveTypes=aiPrimitiveType_TRIANGLE;
-
-    int n_tris=ChunkSize()/12;
-    aiFace *face=mesh->mFaces=new aiFace[n_tris];
-
-    for( int i=0;i<n_tris;++i ){
-        int i0=ReadInt()+v0;
-        int i1=ReadInt()+v0;
-        int i2=ReadInt()+v0;
-        if( i0<0 || i0>=(int)_vertices.size() || i1<0 || i1>=(int)_vertices.size() || i2<0 || i2>=(int)_vertices.size() ){
-#ifdef DEBUG_B3D
-            cout<<"Bad triangle index: i0="<<i0<<", i1="<<i1<<", i2="<<i2<<endl;
-#endif
-            Fail( "Bad triangle index" );
-            continue;
-        }
-        face->mNumIndices=3;
-        face->mIndices=new unsigned[3];
-        face->mIndices[0]=i0;
-        face->mIndices[1]=i1;
-        face->mIndices[2]=i2;
-        ++mesh->mNumFaces;
-        ++face;
-    }
-
-    _meshes.emplace_back( std::move(mesh) );
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ReadMESH(){
-    /*int matid=*/ReadInt();
-
-    int v0= static_cast<int>(_vertices.size());
-
-    while( ChunkSize() ){
-        string t=ReadChunk();
-        if( t=="VRTS" ){
-            ReadVRTS();
-        }else if( t=="TRIS" ){
-            ReadTRIS( v0 );
-        }
-        ExitChunk();
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ReadBONE( int id ){
-    while( ChunkSize() ){
-        int vertex=ReadInt();
-        float weight=ReadFloat();
-        if( vertex<0 || vertex>=(int)_vertices.size() ){
-            Fail( "Bad vertex index" );
-        }
-
-        Vertex &v=_vertices[vertex];
-        int i;
-        for( i=0;i<4;++i ){
-            if( !v.weights[i] ){
-                v.bones[i]=id;
-                v.weights[i]=weight;
-                break;
-            }
-        }
-#ifdef DEBUG_B3D
-        if( i==4 ){
-            cout<<"Too many bone weights"<<endl;
-        }
-#endif
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ReadKEYS( aiNodeAnim *nodeAnim ){
-    vector<aiVectorKey> trans,scale;
-    vector<aiQuatKey> rot;
-    int flags=ReadInt();
-    while( ChunkSize() ){
-        int frame=ReadInt();
-        if( flags & 1 ){
-            trans.push_back( aiVectorKey( frame,ReadVec3() ) );
-        }
-        if( flags & 2 ){
-            scale.push_back( aiVectorKey( frame,ReadVec3() ) );
-        }
-        if( flags & 4 ){
-            rot.push_back( aiQuatKey( frame,ReadQuat() ) );
-        }
-    }
-
-    if( flags & 1 ){
-        nodeAnim->mNumPositionKeys=static_cast<unsigned int>(trans.size());
-        nodeAnim->mPositionKeys=to_array( trans );
-    }
-
-    if( flags & 2 ){
-        nodeAnim->mNumScalingKeys=static_cast<unsigned int>(scale.size());
-        nodeAnim->mScalingKeys=to_array( scale );
-    }
-
-    if( flags & 4 ){
-        nodeAnim->mNumRotationKeys=static_cast<unsigned int>(rot.size());
-        nodeAnim->mRotationKeys=to_array( rot );
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ReadANIM(){
-    /*int flags=*/ReadInt();
-    int frames=ReadInt();
-    float fps=ReadFloat();
-
-    std::unique_ptr<aiAnimation> anim(new aiAnimation);
-
-    anim->mDuration=frames;
-    anim->mTicksPerSecond=fps;
-    _animations.emplace_back( std::move(anim) );
-}
-
-// ------------------------------------------------------------------------------------------------
-aiNode *B3DImporter::ReadNODE( aiNode *parent ){
-
-    string name=ReadString();
-    aiVector3D t=ReadVec3();
-    aiVector3D s=ReadVec3();
-    aiQuaternion r=ReadQuat();
-
-    aiMatrix4x4 trans,scale,rot;
-
-    aiMatrix4x4::Translation( t,trans );
-    aiMatrix4x4::Scaling( s,scale );
-    rot=aiMatrix4x4( r.GetMatrix() );
-
-    aiMatrix4x4 tform=trans * rot * scale;
-
-    int nodeid=static_cast<int>(_nodes.size());
-
-    aiNode *node=new aiNode( name );
-    _nodes.push_back( node );
-
-    node->mParent=parent;
-    node->mTransformation=tform;
-
-    std::unique_ptr<aiNodeAnim> nodeAnim;
-    vector<unsigned> meshes;
-    vector<aiNode*> children;
-
-    while( ChunkSize() ){
-        string t=ReadChunk();
-        if( t=="MESH" ){
-            unsigned int n= static_cast<unsigned int>(_meshes.size());
-            ReadMESH();
-            for( unsigned int i=n;i<static_cast<unsigned int>(_meshes.size());++i ){
-                meshes.push_back( i );
-            }
-        }else if( t=="BONE" ){
-            ReadBONE( nodeid );
-        }else if( t=="ANIM" ){
-            ReadANIM();
-        }else if( t=="KEYS" ){
-            if( !nodeAnim ){
-                nodeAnim.reset(new aiNodeAnim);
-                nodeAnim->mNodeName=node->mName;
-            }
-            ReadKEYS( nodeAnim.get() );
-        }else if( t=="NODE" ){
-            aiNode *child=ReadNODE( node );
-            children.push_back( child );
-        }
-        ExitChunk();
-    }
-
-    if (nodeAnim) {
-        _nodeAnims.emplace_back( std::move(nodeAnim) );
-    }
-
-    node->mNumMeshes= static_cast<unsigned int>(meshes.size());
-    node->mMeshes=to_array( meshes );
-
-    node->mNumChildren=static_cast<unsigned int>(children.size());
-    node->mChildren=to_array( children );
-
-    return node;
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ReadBB3D( aiScene *scene ){
-
-    _textures.clear();
-
-    _materials.clear();
-
-    _vertices.clear();
-
-    _meshes.clear();
-
-    DeleteAllBarePointers(_nodes);
-    _nodes.clear();
-
-    _nodeAnims.clear();
-
-    _animations.clear();
-
-    string t=ReadChunk();
-    if( t=="BB3D" ){
-        int version=ReadInt();
-
-        if (!DefaultLogger::isNullLogger()) {
-            char dmp[128];
-            ai_snprintf(dmp, 128, "B3D file format version: %i",version);
-            ASSIMP_LOG_INFO(dmp);
-        }
-
-        while( ChunkSize() ){
-            string t=ReadChunk();
-            if( t=="TEXS" ){
-                ReadTEXS();
-            }else if( t=="BRUS" ){
-                ReadBRUS();
-            }else if( t=="NODE" ){
-                ReadNODE( 0 );
-            }
-            ExitChunk();
-        }
-    }
-    ExitChunk();
-
-    if( !_nodes.size() ) Fail( "No nodes" );
-
-    if( !_meshes.size() ) Fail( "No meshes" );
-
-    //Fix nodes/meshes/bones
-    for(size_t i=0;i<_nodes.size();++i ){
-        aiNode *node=_nodes[i];
-
-        for( size_t j=0;j<node->mNumMeshes;++j ){
-            aiMesh *mesh = _meshes[node->mMeshes[j]].get();
-
-            int n_tris=mesh->mNumFaces;
-            int n_verts=mesh->mNumVertices=n_tris * 3;
-
-            aiVector3D *mv=mesh->mVertices=new aiVector3D[ n_verts ],*mn=0,*mc=0;
-            if( _vflags & 1 ) mn=mesh->mNormals=new aiVector3D[ n_verts ];
-            if( _tcsets ) mc=mesh->mTextureCoords[0]=new aiVector3D[ n_verts ];
-
-            aiFace *face=mesh->mFaces;
-
-            vector< vector<aiVertexWeight> > vweights( _nodes.size() );
-
-            for( int i=0;i<n_verts;i+=3 ){
-                for( int j=0;j<3;++j ){
-                    Vertex &v=_vertices[face->mIndices[j]];
-
-                    *mv++=v.vertex;
-                    if( mn ) *mn++=v.normal;
-                    if( mc ) *mc++=v.texcoords;
-
-                    face->mIndices[j]=i+j;
-
-                    for( int k=0;k<4;++k ){
-                        if( !v.weights[k] ) break;
-
-                        int bone=v.bones[k];
-                        float weight=v.weights[k];
-
-                        vweights[bone].push_back( aiVertexWeight(i+j,weight) );
-                    }
-                }
-                ++face;
-            }
-
-            vector<aiBone*> bones;
-            for(size_t i=0;i<vweights.size();++i ){
-                vector<aiVertexWeight> &weights=vweights[i];
-                if( !weights.size() ) continue;
-
-                aiBone *bone=new aiBone;
-                bones.push_back( bone );
-
-                aiNode *bnode=_nodes[i];
-
-                bone->mName=bnode->mName;
-                bone->mNumWeights= static_cast<unsigned int>(weights.size());
-                bone->mWeights=to_array( weights );
-
-                aiMatrix4x4 mat=bnode->mTransformation;
-                while( bnode->mParent ){
-                    bnode=bnode->mParent;
-                    mat=bnode->mTransformation * mat;
-                }
-                bone->mOffsetMatrix=mat.Inverse();
-            }
-            mesh->mNumBones= static_cast<unsigned int>(bones.size());
-            mesh->mBones=to_array( bones );
-        }
-    }
-
-    //nodes
-    scene->mRootNode=_nodes[0];
-    _nodes.clear();  // node ownership now belongs to scene
-
-    //material
-    if( !_materials.size() ){
-        _materials.emplace_back( std::unique_ptr<aiMaterial>(new aiMaterial) );
-    }
-    scene->mNumMaterials= static_cast<unsigned int>(_materials.size());
-    scene->mMaterials = unique_to_array( _materials );
-
-    //meshes
-    scene->mNumMeshes= static_cast<unsigned int>(_meshes.size());
-    scene->mMeshes = unique_to_array( _meshes );
-
-    //animations
-    if( _animations.size()==1 && _nodeAnims.size() ){
-
-        aiAnimation *anim = _animations.back().get();
-        anim->mNumChannels=static_cast<unsigned int>(_nodeAnims.size());
-        anim->mChannels = unique_to_array( _nodeAnims );
-
-        scene->mNumAnimations=static_cast<unsigned int>(_animations.size());
-        scene->mAnimations=unique_to_array( _animations );
-    }
-
-    // convert to RH
-    MakeLeftHandedProcess makeleft;
-    makeleft.Execute( scene );
-
-    FlipWindingOrderProcess flip;
-    flip.Execute( scene );
-}
-
-#endif // !! ASSIMP_BUILD_NO_B3D_IMPORTER
diff --git a/Engine/lib/assimp/code/BVH/BVHLoader.cpp b/Engine/lib/assimp/code/BVH/BVHLoader.cpp
deleted file mode 100644
index cd9ab0843..000000000
--- a/Engine/lib/assimp/code/BVH/BVHLoader.cpp
+++ /dev/null
@@ -1,578 +0,0 @@
-/** Implementation of the BVH loader */
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-
-#ifndef ASSIMP_BUILD_NO_BVH_IMPORTER
-
-#include "BVHLoader.h"
-#include <assimp/fast_atof.h>
-#include <assimp/SkeletonMeshBuilder.h>
-#include <assimp/Importer.hpp>
-#include <memory>
-#include <assimp/TinyFormatter.h>
-#include <assimp/IOSystem.hpp>
-#include <assimp/scene.h>
-#include <assimp/importerdesc.h>
-#include <map>
-
-using namespace Assimp;
-using namespace Assimp::Formatter;
-
-static const aiImporterDesc desc = {
-    "BVH Importer (MoCap)",
-    "",
-    "",
-    "",
-    aiImporterFlags_SupportTextFlavour,
-    0,
-    0,
-    0,
-    0,
-    "bvh"
-};
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-BVHLoader::BVHLoader()
-    : mLine(),
-    mAnimTickDuration(),
-    mAnimNumFrames(),
-    noSkeletonMesh()
-{}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-BVHLoader::~BVHLoader()
-{}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the class can handle the format of the given file.
-bool BVHLoader::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool cs) const
-{
-    // check file extension
-    const std::string extension = GetExtension(pFile);
-
-    if( extension == "bvh")
-        return true;
-
-    if ((!extension.length() || cs) && pIOHandler) {
-        const char* tokens[] = {"HIERARCHY"};
-        return SearchFileHeaderForToken(pIOHandler,pFile,tokens,1);
-    }
-    return false;
-}
-
-// ------------------------------------------------------------------------------------------------
-void BVHLoader::SetupProperties(const Importer* pImp)
-{
-    noSkeletonMesh = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_NO_SKELETON_MESHES,0) != 0;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Loader meta information
-const aiImporterDesc* BVHLoader::GetInfo () const
-{
-    return &desc;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Imports the given file into the given scene structure.
-void BVHLoader::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler)
-{
-    mFileName = pFile;
-
-    // read file into memory
-    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile));
-    if( file.get() == NULL)
-        throw DeadlyImportError( "Failed to open file " + pFile + ".");
-
-    size_t fileSize = file->FileSize();
-    if( fileSize == 0)
-        throw DeadlyImportError( "File is too small.");
-
-    mBuffer.resize( fileSize);
-    file->Read( &mBuffer.front(), 1, fileSize);
-
-    // start reading
-    mReader = mBuffer.begin();
-    mLine = 1;
-    ReadStructure( pScene);
-
-    if (!noSkeletonMesh) {
-        // build a dummy mesh for the skeleton so that we see something at least
-        SkeletonMeshBuilder meshBuilder( pScene);
-    }
-
-    // construct an animation from all the motion data we read
-    CreateAnimation( pScene);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the file
-void BVHLoader::ReadStructure( aiScene* pScene)
-{
-    // first comes hierarchy
-    std::string header = GetNextToken();
-    if( header != "HIERARCHY")
-        ThrowException( "Expected header string \"HIERARCHY\".");
-    ReadHierarchy( pScene);
-
-    // then comes the motion data
-    std::string motion = GetNextToken();
-    if( motion != "MOTION")
-        ThrowException( "Expected beginning of motion data \"MOTION\".");
-    ReadMotion( pScene);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the hierarchy
-void BVHLoader::ReadHierarchy( aiScene* pScene)
-{
-    std::string root = GetNextToken();
-    if( root != "ROOT")
-        ThrowException( "Expected root node \"ROOT\".");
-
-    // Go read the hierarchy from here
-    pScene->mRootNode = ReadNode();
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads a node and recursively its childs and returns the created node;
-aiNode* BVHLoader::ReadNode()
-{
-    // first token is name
-    std::string nodeName = GetNextToken();
-    if( nodeName.empty() || nodeName == "{")
-        ThrowException( format() << "Expected node name, but found \"" << nodeName << "\"." );
-
-    // then an opening brace should follow
-    std::string openBrace = GetNextToken();
-    if( openBrace != "{")
-        ThrowException( format() << "Expected opening brace \"{\", but found \"" << openBrace << "\"." );
-
-    // Create a node
-    aiNode* node = new aiNode( nodeName);
-    std::vector<aiNode*> childNodes;
-
-    // and create an bone entry for it
-    mNodes.push_back( Node( node));
-    Node& internNode = mNodes.back();
-
-    // now read the node's contents
-    std::string siteToken;
-    while( 1)
-    {
-        std::string token = GetNextToken();
-
-        // node offset to parent node
-        if( token == "OFFSET")
-            ReadNodeOffset( node);
-        else if( token == "CHANNELS")
-            ReadNodeChannels( internNode);
-        else if( token == "JOINT")
-        {
-            // child node follows
-            aiNode* child = ReadNode();
-            child->mParent = node;
-            childNodes.push_back( child);
-        }
-        else if( token == "End")
-        {
-            // The real symbol is "End Site". Second part comes in a separate token
-            siteToken.clear();
-            siteToken = GetNextToken();
-            if( siteToken != "Site")
-                ThrowException( format() << "Expected \"End Site\" keyword, but found \"" << token << " " << siteToken << "\"." );
-
-            aiNode* child = ReadEndSite( nodeName);
-            child->mParent = node;
-            childNodes.push_back( child);
-        }
-        else if( token == "}")
-        {
-            // we're done with that part of the hierarchy
-            break;
-        } else
-        {
-            // everything else is a parse error
-            ThrowException( format() << "Unknown keyword \"" << token << "\"." );
-        }
-    }
-
-    // add the child nodes if there are any
-    if( childNodes.size() > 0)
-    {
-        node->mNumChildren = static_cast<unsigned int>(childNodes.size());
-        node->mChildren = new aiNode*[node->mNumChildren];
-        std::copy( childNodes.begin(), childNodes.end(), node->mChildren);
-    }
-
-    // and return the sub-hierarchy we built here
-    return node;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads an end node and returns the created node.
-aiNode* BVHLoader::ReadEndSite( const std::string& pParentName)
-{
-    // check opening brace
-    std::string openBrace = GetNextToken();
-    if( openBrace != "{")
-        ThrowException( format() << "Expected opening brace \"{\", but found \"" << openBrace << "\".");
-
-    // Create a node
-    aiNode* node = new aiNode( "EndSite_" + pParentName);
-
-    // now read the node's contents. Only possible entry is "OFFSET"
-    std::string token;
-    while( 1) {
-        token.clear();
-        token = GetNextToken();
-
-        // end node's offset
-        if( token == "OFFSET") {
-            ReadNodeOffset( node);
-        } else if( token == "}") {
-            // we're done with the end node
-            break;
-        } else {
-            // everything else is a parse error
-            ThrowException( format() << "Unknown keyword \"" << token << "\"." );
-        }
-    }
-
-    // and return the sub-hierarchy we built here
-    return node;
-}
-// ------------------------------------------------------------------------------------------------
-// Reads a node offset for the given node
-void BVHLoader::ReadNodeOffset( aiNode* pNode)
-{
-    // Offset consists of three floats to read
-    aiVector3D offset;
-    offset.x = GetNextTokenAsFloat();
-    offset.y = GetNextTokenAsFloat();
-    offset.z = GetNextTokenAsFloat();
-
-    // build a transformation matrix from it
-    pNode->mTransformation = aiMatrix4x4( 1.0f, 0.0f, 0.0f, offset.x,
-                                          0.0f, 1.0f, 0.0f, offset.y,
-                                          0.0f, 0.0f, 1.0f, offset.z,
-                                          0.0f, 0.0f, 0.0f, 1.0f);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the animation channels for the given node
-void BVHLoader::ReadNodeChannels( BVHLoader::Node& pNode)
-{
-    // number of channels. Use the float reader because we're lazy
-    float numChannelsFloat = GetNextTokenAsFloat();
-    unsigned int numChannels = (unsigned int) numChannelsFloat;
-
-    for( unsigned int a = 0; a < numChannels; a++)
-    {
-        std::string channelToken = GetNextToken();
-
-        if( channelToken == "Xposition")
-            pNode.mChannels.push_back( Channel_PositionX);
-        else if( channelToken == "Yposition")
-            pNode.mChannels.push_back( Channel_PositionY);
-        else if( channelToken == "Zposition")
-            pNode.mChannels.push_back( Channel_PositionZ);
-        else if( channelToken == "Xrotation")
-            pNode.mChannels.push_back( Channel_RotationX);
-        else if( channelToken == "Yrotation")
-            pNode.mChannels.push_back( Channel_RotationY);
-        else if( channelToken == "Zrotation")
-            pNode.mChannels.push_back( Channel_RotationZ);
-        else
-            ThrowException( format() << "Invalid channel specifier \"" << channelToken << "\"." );
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the motion data
-void BVHLoader::ReadMotion( aiScene* /*pScene*/)
-{
-    // Read number of frames
-    std::string tokenFrames = GetNextToken();
-    if( tokenFrames != "Frames:")
-        ThrowException( format() << "Expected frame count \"Frames:\", but found \"" << tokenFrames << "\".");
-
-    float numFramesFloat = GetNextTokenAsFloat();
-    mAnimNumFrames = (unsigned int) numFramesFloat;
-
-    // Read frame duration
-    std::string tokenDuration1 = GetNextToken();
-    std::string tokenDuration2 = GetNextToken();
-    if( tokenDuration1 != "Frame" || tokenDuration2 != "Time:")
-        ThrowException( format() << "Expected frame duration \"Frame Time:\", but found \"" << tokenDuration1 << " " << tokenDuration2 << "\"." );
-
-    mAnimTickDuration = GetNextTokenAsFloat();
-
-    // resize value vectors for each node
-    for( std::vector<Node>::iterator it = mNodes.begin(); it != mNodes.end(); ++it)
-        it->mChannelValues.reserve( it->mChannels.size() * mAnimNumFrames);
-
-    // now read all the data and store it in the corresponding node's value vector
-    for( unsigned int frame = 0; frame < mAnimNumFrames; ++frame)
-    {
-        // on each line read the values for all nodes
-        for( std::vector<Node>::iterator it = mNodes.begin(); it != mNodes.end(); ++it)
-        {
-            // get as many values as the node has channels
-            for( unsigned int c = 0; c < it->mChannels.size(); ++c)
-                it->mChannelValues.push_back( GetNextTokenAsFloat());
-        }
-
-        // after one frame worth of values for all nodes there should be a newline, but we better don't rely on it
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Retrieves the next token
-std::string BVHLoader::GetNextToken()
-{
-    // skip any preceding whitespace
-    while( mReader != mBuffer.end())
-    {
-        if( !isspace( *mReader))
-            break;
-
-        // count lines
-        if( *mReader == '\n')
-            mLine++;
-
-        ++mReader;
-    }
-
-    // collect all chars till the next whitespace. BVH is easy in respect to that.
-    std::string token;
-    while( mReader != mBuffer.end())
-    {
-        if( isspace( *mReader))
-            break;
-
-        token.push_back( *mReader);
-        ++mReader;
-
-        // little extra logic to make sure braces are counted correctly
-        if( token == "{" || token == "}")
-            break;
-    }
-
-    // empty token means end of file, which is just fine
-    return token;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the next token as a float
-float BVHLoader::GetNextTokenAsFloat()
-{
-    std::string token = GetNextToken();
-    if( token.empty())
-        ThrowException( "Unexpected end of file while trying to read a float");
-
-    // check if the float is valid by testing if the atof() function consumed every char of the token
-    const char* ctoken = token.c_str();
-    float result = 0.0f;
-    ctoken = fast_atoreal_move<float>( ctoken, result);
-
-    if( ctoken != token.c_str() + token.length())
-        ThrowException( format() << "Expected a floating point number, but found \"" << token << "\"." );
-
-    return result;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Aborts the file reading with an exception
-AI_WONT_RETURN void BVHLoader::ThrowException( const std::string& pError)
-{
-    throw DeadlyImportError( format() << mFileName << ":" << mLine << " - " << pError);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Constructs an animation for the motion data and stores it in the given scene
-void BVHLoader::CreateAnimation( aiScene* pScene)
-{
-    // create the animation
-    pScene->mNumAnimations = 1;
-    pScene->mAnimations = new aiAnimation*[1];
-    aiAnimation* anim = new aiAnimation;
-    pScene->mAnimations[0] = anim;
-
-    // put down the basic parameters
-    anim->mName.Set( "Motion");
-    anim->mTicksPerSecond = 1.0 / double( mAnimTickDuration);
-    anim->mDuration = double( mAnimNumFrames - 1);
-
-    // now generate the tracks for all nodes
-    anim->mNumChannels = static_cast<unsigned int>(mNodes.size());
-    anim->mChannels = new aiNodeAnim*[anim->mNumChannels];
-
-    // FIX: set the array elements to NULL to ensure proper deletion if an exception is thrown
-    for (unsigned int i = 0; i < anim->mNumChannels;++i)
-        anim->mChannels[i] = NULL;
-
-    for( unsigned int a = 0; a < anim->mNumChannels; a++)
-    {
-        const Node& node = mNodes[a];
-        const std::string nodeName = std::string( node.mNode->mName.data );
-        aiNodeAnim* nodeAnim = new aiNodeAnim;
-        anim->mChannels[a] = nodeAnim;
-        nodeAnim->mNodeName.Set( nodeName);
-		std::map<BVHLoader::ChannelType, int> channelMap;
-
-		//Build map of channels 
-		for (unsigned int channel = 0; channel < node.mChannels.size(); ++channel)
-		{
-			channelMap[node.mChannels[channel]] = channel;
-		}
-
-        // translational part, if given
-        if( node.mChannels.size() == 6)
-        {
-            nodeAnim->mNumPositionKeys = mAnimNumFrames;
-            nodeAnim->mPositionKeys = new aiVectorKey[mAnimNumFrames];
-            aiVectorKey* poskey = nodeAnim->mPositionKeys;
-            for( unsigned int fr = 0; fr < mAnimNumFrames; ++fr)
-            {
-                poskey->mTime = double( fr);
-
-                // Now compute all translations 
-                for(BVHLoader::ChannelType channel = Channel_PositionX; channel <= Channel_PositionZ; channel = (BVHLoader::ChannelType)(channel +1))
-                {
-					//Find channel in node
-					std::map<BVHLoader::ChannelType, int>::iterator mapIter = channelMap.find(channel);
-
-					if (mapIter == channelMap.end())
-						throw DeadlyImportError("Missing position channel in node " + nodeName);
-					else {
-						int channelIdx = mapIter->second;
-						switch (channel) {
-						    case Channel_PositionX: 
-                                poskey->mValue.x = node.mChannelValues[fr * node.mChannels.size() + channelIdx]; 
-                                break;
-						    case Channel_PositionY: 
-                                poskey->mValue.y = node.mChannelValues[fr * node.mChannels.size() + channelIdx]; 
-                                break;
-						    case Channel_PositionZ: 
-                                poskey->mValue.z = node.mChannelValues[fr * node.mChannels.size() + channelIdx]; 
-                                break;
-                                
-                            default:
-                                break;
-						}
-
-					}
-                }
-                ++poskey;
-            }
-        } else
-        {
-            // if no translation part is given, put a default sequence
-            aiVector3D nodePos( node.mNode->mTransformation.a4, node.mNode->mTransformation.b4, node.mNode->mTransformation.c4);
-            nodeAnim->mNumPositionKeys = 1;
-            nodeAnim->mPositionKeys = new aiVectorKey[1];
-            nodeAnim->mPositionKeys[0].mTime = 0.0;
-            nodeAnim->mPositionKeys[0].mValue = nodePos;
-        }
-
-        // rotation part. Always present. First find value offsets
-        {
-
-            // Then create the number of rotation keys
-            nodeAnim->mNumRotationKeys = mAnimNumFrames;
-            nodeAnim->mRotationKeys = new aiQuatKey[mAnimNumFrames];
-            aiQuatKey* rotkey = nodeAnim->mRotationKeys;
-            for( unsigned int fr = 0; fr < mAnimNumFrames; ++fr)
-            {
-                aiMatrix4x4 temp;
-                aiMatrix3x3 rotMatrix;
-				for (BVHLoader::ChannelType channel = Channel_RotationX; channel <= Channel_RotationZ; channel = (BVHLoader::ChannelType)(channel + 1))
-				{
-					//Find channel in node
-					std::map<BVHLoader::ChannelType, int>::iterator mapIter = channelMap.find(channel);
-
-					if (mapIter == channelMap.end())
-						throw DeadlyImportError("Missing rotation channel in node " + nodeName);
-					else {
-						int channelIdx = mapIter->second;
-						// translate ZXY euler angels into a quaternion
-						const float angle = node.mChannelValues[fr * node.mChannels.size() + channelIdx] * float(AI_MATH_PI) / 180.0f;
-
-						// Compute rotation transformations in the right order
-						switch (channel)
-						{
-							case Channel_RotationX: 
-                                aiMatrix4x4::RotationX(angle, temp); rotMatrix *= aiMatrix3x3(temp); 
-                                break;
-							case Channel_RotationY: 
-                                aiMatrix4x4::RotationY(angle, temp); rotMatrix *= aiMatrix3x3(temp);  
-                                break;
-							case Channel_RotationZ: aiMatrix4x4::RotationZ(angle, temp); rotMatrix *= aiMatrix3x3(temp); 
-                                break;
-                            default:
-                                break;
-						}
-					}
-                }
-
-                rotkey->mTime = double( fr);
-                rotkey->mValue = aiQuaternion( rotMatrix);
-                ++rotkey;
-            }
-        }
-
-        // scaling part. Always just a default track
-        {
-            nodeAnim->mNumScalingKeys = 1;
-            nodeAnim->mScalingKeys = new aiVectorKey[1];
-            nodeAnim->mScalingKeys[0].mTime = 0.0;
-            nodeAnim->mScalingKeys[0].mValue.Set( 1.0f, 1.0f, 1.0f);
-        }
-    }
-}
-
-#endif // !! ASSIMP_BUILD_NO_BVH_IMPORTER
diff --git a/Engine/lib/assimp/code/Blender/BlenderCustomData.cpp b/Engine/lib/assimp/code/Blender/BlenderCustomData.cpp
deleted file mode 100644
index 6561eaf22..000000000
--- a/Engine/lib/assimp/code/Blender/BlenderCustomData.cpp
+++ /dev/null
@@ -1,189 +0,0 @@
-#include "BlenderCustomData.h"
-#include "BlenderDNA.h"
-#include <array>
-#include <functional>
-
-namespace Assimp {
-    namespace Blender {
-        /**
-        *   @brief  read/convert of Structure array to memory
-        */
-        template<typename T>
-        bool read(const Structure &s, T *p, const size_t cnt, const FileDatabase &db) {
-            for (size_t i = 0; i < cnt; ++i) {
-                T read;
-                s.Convert(read, db);
-                *p = read;
-                p++;
-            }
-            return true;
-        }
-
-        /**
-        *   @brief  pointer to function read memory for n CustomData types
-        */
-        typedef bool        (*PRead)(ElemBase *pOut, const size_t cnt, const FileDatabase &db);
-        typedef ElemBase *  (*PCreate)(const size_t cnt);
-        typedef void(*PDestroy)(ElemBase *);
-
-#define IMPL_STRUCT_READ(ty)                                                    \
-        bool read##ty(ElemBase *v, const size_t cnt, const FileDatabase &db) {  \
-        ty *ptr = dynamic_cast<ty*>(v);                                         \
-        if (nullptr == ptr) {                                                   \
-            return false;                                                       \
-        }                                                                       \
-        return read<ty>(db.dna[#ty], ptr, cnt, db);                             \
-        }
-
-#define IMPL_STRUCT_CREATE(ty)                                                  \
-        ElemBase *create##ty(const size_t cnt) {                                \
-            return new ty[cnt];                                                 \
-        }
-
-#define IMPL_STRUCT_DESTROY(ty)                                                 \
-        void destroy##ty(ElemBase *pE) {                                        \
-            ty *p = dynamic_cast<ty *>(pE);                                     \
-            delete[]p;                                                          \
-        }
-
-        /**
-        *   @brief  helper macro to define Structure functions
-        */
-#define IMPL_STRUCT(ty)                                                         \
-        IMPL_STRUCT_READ(ty)                                                    \
-        IMPL_STRUCT_CREATE(ty)                                                  \
-        IMPL_STRUCT_DESTROY(ty)
-
-        // supported structures for CustomData
-        IMPL_STRUCT(MVert)
-        IMPL_STRUCT(MEdge)
-        IMPL_STRUCT(MFace)
-        IMPL_STRUCT(MTFace)
-        IMPL_STRUCT(MTexPoly)
-        IMPL_STRUCT(MLoopUV)
-        IMPL_STRUCT(MLoopCol)
-        IMPL_STRUCT(MPoly)
-        IMPL_STRUCT(MLoop)
-
-        /**
-        *   @brief  describes the size of data and the read function to be used for single CustomerData.type
-        */
-        struct CustomDataTypeDescription {
-            PRead Read;                         ///< function to read one CustomData type element
-            PCreate Create;                       ///< function to allocate n type elements
-            PDestroy Destroy;
-
-            CustomDataTypeDescription(PRead read, PCreate create, PDestroy destroy)
-                : Read(read)
-                , Create(create)
-                , Destroy(destroy)
-            {}
-        };
-
-
-        /**
-        *   @brief  helper macro to define Structure type specific CustomDataTypeDescription
-        *   @note   IMPL_STRUCT_READ for same ty must be used earlier to implement the typespecific read function
-        */
-#define DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(ty)           \
-        CustomDataTypeDescription{&read##ty, &create##ty, &destroy##ty}
-
-        /**
-        *   @brief  helper macro to define CustomDataTypeDescription for UNSUPPORTED type
-        */
-#define DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION          \
-        CustomDataTypeDescription{nullptr, nullptr, nullptr}
-
-        /**
-        *   @brief  descriptors for data pointed to from CustomDataLayer.data
-        *   @note   some of the CustomData uses already well defined Structures
-        *           other (like CD_ORCO, ...) uses arrays of rawtypes or even arrays of Structures
-        *           use a special readfunction for that cases
-        */
-        std::array<CustomDataTypeDescription, CD_NUMTYPES> customDataTypeDescriptions = { {
-            DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MVert),
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MEdge),
-            DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MFace),
-            DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MTFace),
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MTexPoly),
-            DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MLoopUV),
-            DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MLoopCol),
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MPoly),
-            DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MLoop),
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION
-        }};
-
-
-        bool isValidCustomDataType(const int cdtype) {
-            return cdtype >= 0 && cdtype < CD_NUMTYPES;
-        }
-
-        bool readCustomData(std::shared_ptr<ElemBase> &out, const int cdtype, const size_t cnt, const FileDatabase &db) {
-            if (!isValidCustomDataType(cdtype)) {
-                throw Error((Formatter::format(), "CustomData.type ", cdtype, " out of index"));
-            }
-
-            const CustomDataTypeDescription cdtd = customDataTypeDescriptions[cdtype];
-            if (cdtd.Read && cdtd.Create && cdtd.Destroy && cnt > 0) {
-                // allocate cnt elements and parse them from file
-                out.reset(cdtd.Create(cnt), cdtd.Destroy);
-                return cdtd.Read(out.get(), cnt, db);
-            }
-            return false;
-        }
-
-        std::shared_ptr<CustomDataLayer> getCustomDataLayer(const CustomData &customdata, const CustomDataType cdtype, const std::string &name) {
-            for (auto it = customdata.layers.begin(); it != customdata.layers.end(); ++it) {
-                if (it->get()->type == cdtype && name == it->get()->name) {
-                    return *it;
-                }
-            }
-            return nullptr;
-        }
-
-        const ElemBase * getCustomDataLayerData(const CustomData &customdata, const CustomDataType cdtype, const std::string &name)
-        {
-            const std::shared_ptr<CustomDataLayer> pLayer = getCustomDataLayer(customdata, cdtype, name);
-            if (pLayer && pLayer->data) {
-                return pLayer->data.get();
-            }
-            return nullptr;
-        }
-    }
-}
diff --git a/Engine/lib/assimp/code/Blender/BlenderLoader.h b/Engine/lib/assimp/code/Blender/BlenderLoader.h
deleted file mode 100644
index d85a82842..000000000
--- a/Engine/lib/assimp/code/Blender/BlenderLoader.h
+++ /dev/null
@@ -1,240 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file  BlenderLoader.h
- *  @brief Declaration of the Blender 3D (*.blend) importer class.
- */
-#ifndef INCLUDED_AI_BLEND_LOADER_H
-#define INCLUDED_AI_BLEND_LOADER_H
-
-#include <assimp/BaseImporter.h>
-#include <assimp/LogAux.h>
-#include <memory>
-
-struct aiNode;
-struct aiMesh;
-struct aiLight;
-struct aiCamera;
-struct aiMaterial;
-
-namespace Assimp    {
-
-    // TinyFormatter.h
-    namespace Formatter {
-        template <typename T,typename TR, typename A> class basic_formatter;
-        typedef class basic_formatter< char, std::char_traits<char>, std::allocator<char> > format;
-    }
-
-    // BlenderDNA.h
-    namespace Blender {
-        class  FileDatabase;
-        struct ElemBase;
-    }
-
-    // BlenderScene.h
-    namespace Blender {
-        struct Scene;
-        struct Object;
-        struct Mesh;
-        struct Camera;
-        struct Lamp;
-        struct MTex;
-        struct Image;
-        struct Material;
-    }
-
-    // BlenderIntermediate.h
-    namespace Blender {
-        struct ConversionData;
-        template <template <typename,typename> class TCLASS, typename T> struct TempArray;
-    }
-
-    // BlenderModifier.h
-    namespace Blender {
-        class BlenderModifierShowcase;
-        class BlenderModifier;
-    }
-
-
-
-// -------------------------------------------------------------------------------------------
-/** Load blenders official binary format. The actual file structure (the `DNA` how they
- *  call it is outsourced to BlenderDNA.cpp/BlenderDNA.h. This class only performs the
- *  conversion from intermediate format to aiScene. */
-// -------------------------------------------------------------------------------------------
-class BlenderImporter : public BaseImporter, public LogFunctions<BlenderImporter>
-{
-public:
-    BlenderImporter();
-    ~BlenderImporter();
-
-public:
-
-    // --------------------
-    bool CanRead( const std::string& pFile,
-        IOSystem* pIOHandler,
-        bool checkSig
-    ) const;
-
-protected:
-
-    // --------------------
-    const aiImporterDesc* GetInfo () const;
-
-    // --------------------
-    void GetExtensionList(std::set<std::string>& app);
-
-    // --------------------
-    void SetupProperties(const Importer* pImp);
-
-    // --------------------
-    void InternReadFile( const std::string& pFile,
-        aiScene* pScene,
-        IOSystem* pIOHandler
-    );
-
-    // --------------------
-    void ParseBlendFile(Blender::FileDatabase& out,
-        std::shared_ptr<IOStream> stream
-    );
-
-    // --------------------
-    void ExtractScene(Blender::Scene& out,
-        const Blender::FileDatabase& file
-    );
-
-    // --------------------
-    void ConvertBlendFile(aiScene* out,
-        const Blender::Scene& in,
-        const Blender::FileDatabase& file
-    );
-
-private:
-
-    // --------------------
-    aiNode* ConvertNode(const Blender::Scene& in,
-        const Blender::Object* obj,
-        Blender::ConversionData& conv_info,
-        const aiMatrix4x4& parentTransform
-    );
-
-    // --------------------
-    void ConvertMesh(const Blender::Scene& in,
-        const Blender::Object* obj,
-        const Blender::Mesh* mesh,
-        Blender::ConversionData& conv_data,
-        Blender::TempArray<std::vector,aiMesh>& temp
-    );
-
-    // --------------------
-    aiLight* ConvertLight(const Blender::Scene& in,
-        const Blender::Object* obj,
-        const Blender::Lamp* mesh,
-        Blender::ConversionData& conv_data
-    );
-
-    // --------------------
-    aiCamera* ConvertCamera(const Blender::Scene& in,
-        const Blender::Object* obj,
-        const Blender::Camera* mesh,
-        Blender::ConversionData& conv_data
-    );
-
-    // --------------------
-    void BuildDefaultMaterial(
-        Blender::ConversionData& conv_data
-    );
-
-    void AddBlendParams(
-        aiMaterial* result,
-        const Blender::Material* source
-    );
-
-    void BuildMaterials(
-        Blender::ConversionData& conv_data
-    );
-
-    // --------------------
-    void ResolveTexture(
-        aiMaterial* out,
-        const Blender::Material* mat,
-        const Blender::MTex* tex,
-        Blender::ConversionData& conv_data
-    );
-
-    // --------------------
-    void ResolveImage(
-        aiMaterial* out,
-        const Blender::Material* mat,
-        const Blender::MTex* tex,
-        const Blender::Image* img,
-        Blender::ConversionData& conv_data
-    );
-
-    void AddSentinelTexture(
-        aiMaterial* out,
-        const Blender::Material* mat,
-        const Blender::MTex* tex,
-        Blender::ConversionData& conv_data
-    );
-
-private: // static stuff, mostly logging and error reporting.
-
-    // --------------------
-    static void CheckActualType(const Blender::ElemBase* dt,
-        const char* check
-    );
-
-    // --------------------
-    static void NotSupportedObjectType(const Blender::Object* obj,
-        const char* type
-    );
-
-
-private:
-
-    Blender::BlenderModifierShowcase* modifier_cache;
-
-}; // !class BlenderImporter
-
-} // end of namespace Assimp
-#endif // AI_UNREALIMPORTER_H_INC
diff --git a/Engine/lib/assimp/code/Blender/BlenderScene.cpp b/Engine/lib/assimp/code/Blender/BlenderScene.cpp
deleted file mode 100644
index 39c2793d5..000000000
--- a/Engine/lib/assimp/code/Blender/BlenderScene.cpp
+++ /dev/null
@@ -1,875 +0,0 @@
-/*
-Open Asset Import Library (ASSIMP)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2016, ASSIMP Development Team
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the ASSIMP team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the ASSIMP Development Team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file  BlenderScene.cpp
- *  @brief MACHINE GENERATED BY ./scripts/BlenderImporter/genblenddna.py
- */
-
-#ifndef ASSIMP_BUILD_NO_BLEND_IMPORTER
-
-#include "BlenderScene.h"
-#include "BlenderSceneGen.h"
-#include "BlenderDNA.h"
-#include "BlenderCustomData.h"
-
-using namespace Assimp;
-using namespace Assimp::Blender;
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<Object> (
-    Object& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
-    int temp = 0;
-    ReadField<ErrorPolicy_Fail>(temp,"type",db);
-    dest.type = static_cast<Assimp::Blender::Object::Type>(temp);
-    ReadFieldArray2<ErrorPolicy_Warn>(dest.obmat,"obmat",db);
-    ReadFieldArray2<ErrorPolicy_Warn>(dest.parentinv,"parentinv",db);
-    ReadFieldArray<ErrorPolicy_Warn>(dest.parsubstr,"parsubstr",db);
-    {
-        std::shared_ptr<Object> parent;
-        ReadFieldPtr<ErrorPolicy_Warn>(parent,"*parent",db);
-        dest.parent = parent.get();
-    }
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.track,"*track",db);
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.proxy,"*proxy",db);
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.proxy_from,"*proxy_from",db);
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.proxy_group,"*proxy_group",db);
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.dup_group,"*dup_group",db);
-    ReadFieldPtr<ErrorPolicy_Fail>(dest.data,"*data",db);
-    ReadField<ErrorPolicy_Igno>(dest.modifiers,"modifiers",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<Group> (
-    Group& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
-    ReadField<ErrorPolicy_Igno>(dest.layer,"layer",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.gobject,"*gobject",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<MTex> (
-    MTex& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    int temp_short = 0;
-    ReadField<ErrorPolicy_Igno>(temp_short,"mapto",db);
-    dest.mapto = static_cast<Assimp::Blender::MTex::MapType>(temp_short);
-    int temp = 0;
-    ReadField<ErrorPolicy_Igno>(temp,"blendtype",db);
-    dest.blendtype = static_cast<Assimp::Blender::MTex::BlendType>(temp);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.object,"*object",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.tex,"*tex",db);
-    ReadFieldArray<ErrorPolicy_Igno>(dest.uvname,"uvname",db);
-    ReadField<ErrorPolicy_Igno>(temp,"projx",db);
-    dest.projx = static_cast<Assimp::Blender::MTex::Projection>(temp);
-    ReadField<ErrorPolicy_Igno>(temp,"projy",db);
-    dest.projy = static_cast<Assimp::Blender::MTex::Projection>(temp);
-    ReadField<ErrorPolicy_Igno>(temp,"projz",db);
-    dest.projz = static_cast<Assimp::Blender::MTex::Projection>(temp);
-    ReadField<ErrorPolicy_Igno>(dest.mapping,"mapping",db);
-    ReadFieldArray<ErrorPolicy_Igno>(dest.ofs,"ofs",db);
-    ReadFieldArray<ErrorPolicy_Igno>(dest.size,"size",db);
-    ReadField<ErrorPolicy_Igno>(dest.rot,"rot",db);
-    ReadField<ErrorPolicy_Igno>(dest.texflag,"texflag",db);
-    ReadField<ErrorPolicy_Igno>(dest.colormodel,"colormodel",db);
-    ReadField<ErrorPolicy_Igno>(dest.pmapto,"pmapto",db);
-    ReadField<ErrorPolicy_Igno>(dest.pmaptoneg,"pmaptoneg",db);
-    ReadField<ErrorPolicy_Warn>(dest.r,"r",db);
-    ReadField<ErrorPolicy_Warn>(dest.g,"g",db);
-    ReadField<ErrorPolicy_Warn>(dest.b,"b",db);
-    ReadField<ErrorPolicy_Warn>(dest.k,"k",db);
-    ReadField<ErrorPolicy_Igno>(dest.colspecfac,"colspecfac",db);
-    ReadField<ErrorPolicy_Igno>(dest.mirrfac,"mirrfac",db);
-    ReadField<ErrorPolicy_Igno>(dest.alphafac,"alphafac",db);
-    ReadField<ErrorPolicy_Igno>(dest.difffac,"difffac",db);
-    ReadField<ErrorPolicy_Igno>(dest.specfac,"specfac",db);
-    ReadField<ErrorPolicy_Igno>(dest.emitfac,"emitfac",db);
-    ReadField<ErrorPolicy_Igno>(dest.hardfac,"hardfac",db);
-    ReadField<ErrorPolicy_Igno>(dest.norfac,"norfac",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<TFace> (
-    TFace& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadFieldArray2<ErrorPolicy_Fail>(dest.uv,"uv",db);
-    ReadFieldArray<ErrorPolicy_Fail>(dest.col,"col",db);
-    ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
-    ReadField<ErrorPolicy_Igno>(dest.mode,"mode",db);
-    ReadField<ErrorPolicy_Igno>(dest.tile,"tile",db);
-    ReadField<ErrorPolicy_Igno>(dest.unwrap,"unwrap",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<SubsurfModifierData> (
-    SubsurfModifierData& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.modifier,"modifier",db);
-    ReadField<ErrorPolicy_Warn>(dest.subdivType,"subdivType",db);
-    ReadField<ErrorPolicy_Fail>(dest.levels,"levels",db);
-    ReadField<ErrorPolicy_Igno>(dest.renderLevels,"renderLevels",db);
-    ReadField<ErrorPolicy_Igno>(dest.flags,"flags",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<MFace> (
-    MFace& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.v1,"v1",db);
-    ReadField<ErrorPolicy_Fail>(dest.v2,"v2",db);
-    ReadField<ErrorPolicy_Fail>(dest.v3,"v3",db);
-    ReadField<ErrorPolicy_Fail>(dest.v4,"v4",db);
-    ReadField<ErrorPolicy_Fail>(dest.mat_nr,"mat_nr",db);
-    ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<Lamp> (
-    Lamp& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
-    int temp = 0;
-    ReadField<ErrorPolicy_Fail>(temp,"type",db);
-    dest.type = static_cast<Assimp::Blender::Lamp::Type>(temp);
-    ReadField<ErrorPolicy_Igno>(dest.flags,"flag",db);
-    ReadField<ErrorPolicy_Igno>(dest.colormodel,"colormodel",db);
-    ReadField<ErrorPolicy_Igno>(dest.totex,"totex",db);
-    ReadField<ErrorPolicy_Warn>(dest.r,"r",db);
-    ReadField<ErrorPolicy_Warn>(dest.g,"g",db);
-    ReadField<ErrorPolicy_Warn>(dest.b,"b",db);
-    ReadField<ErrorPolicy_Warn>(dest.k,"k",db);
-    ReadField<ErrorPolicy_Igno>(dest.energy,"energy",db);
-    ReadField<ErrorPolicy_Warn>(dest.dist,"dist",db);
-    ReadField<ErrorPolicy_Igno>(dest.spotsize,"spotsize",db);
-    ReadField<ErrorPolicy_Igno>(dest.spotblend,"spotblend",db);
-    ReadField<ErrorPolicy_Warn>(dest.constant_coefficient, "coeff_const", db);
-    ReadField<ErrorPolicy_Warn>(dest.linear_coefficient, "coeff_lin", db);
-    ReadField<ErrorPolicy_Warn>(dest.quadratic_coefficient, "coeff_quad", db);
-    ReadField<ErrorPolicy_Igno>(dest.att1,"att1",db);
-    ReadField<ErrorPolicy_Igno>(dest.att2,"att2",db);
-    ReadField<ErrorPolicy_Igno>(temp,"falloff_type",db);
-    dest.falloff_type = static_cast<Assimp::Blender::Lamp::FalloffType>(temp);
-    ReadField<ErrorPolicy_Igno>(dest.sun_brightness,"sun_brightness",db);
-    ReadField<ErrorPolicy_Igno>(dest.area_size,"area_size",db);
-    ReadField<ErrorPolicy_Igno>(dest.area_sizey,"area_sizey",db);
-    ReadField<ErrorPolicy_Igno>(dest.area_sizez,"area_sizez",db);
-    ReadField<ErrorPolicy_Igno>(dest.area_shape,"area_shape",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<MDeformWeight> (
-    MDeformWeight& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.def_nr,"def_nr",db);
-    ReadField<ErrorPolicy_Fail>(dest.weight,"weight",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<PackedFile> (
-    PackedFile& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Warn>(dest.size,"size",db);
-    ReadField<ErrorPolicy_Warn>(dest.seek,"seek",db);
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.data,"*data",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<Base> (
-    Base& dest,
-    const FileDatabase& db
-    ) const
-{
-    // note: as per https://github.com/assimp/assimp/issues/128,
-    // reading the Object linked list recursively is prone to stack overflow.
-    // This structure converter is therefore an hand-written exception that
-    // does it iteratively.
-
-    const int initial_pos = db.reader->GetCurrentPos();
-
-    std::pair<Base*, int> todo = std::make_pair(&dest, initial_pos);
-    for ( ;; ) {
-
-        Base& cur_dest = *todo.first;
-        db.reader->SetCurrentPos(todo.second);
-
-        // we know that this is a double-linked, circular list which we never
-        // traverse backwards, so don't bother resolving the back links.
-        cur_dest.prev = NULL;
-
-        ReadFieldPtr<ErrorPolicy_Warn>(cur_dest.object,"*object",db);
-
-        // the return value of ReadFieldPtr indicates whether the object
-        // was already cached. In this case, we don't need to resolve
-        // it again.
-        if(!ReadFieldPtr<ErrorPolicy_Warn>(cur_dest.next,"*next",db, true) && cur_dest.next) {
-            todo = std::make_pair(&*cur_dest.next, db.reader->GetCurrentPos());
-            continue;
-        }
-        break;
-    }
-
-    db.reader->SetCurrentPos(initial_pos + size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<MTFace> (
-    MTFace& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadFieldArray2<ErrorPolicy_Fail>(dest.uv,"uv",db);
-    ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
-    ReadField<ErrorPolicy_Igno>(dest.mode,"mode",db);
-    ReadField<ErrorPolicy_Igno>(dest.tile,"tile",db);
-    ReadField<ErrorPolicy_Igno>(dest.unwrap,"unwrap",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<Material> (
-    Material& dest,
-    const FileDatabase& db
-    ) const
-{
-    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
-    ReadField<ErrorPolicy_Warn>(dest.r,"r",db);
-    ReadField<ErrorPolicy_Warn>(dest.g,"g",db);
-    ReadField<ErrorPolicy_Warn>(dest.b,"b",db);
-    ReadField<ErrorPolicy_Warn>(dest.specr,"specr",db);
-    ReadField<ErrorPolicy_Warn>(dest.specg,"specg",db);
-    ReadField<ErrorPolicy_Warn>(dest.specb,"specb",db);
-    ReadField<ErrorPolicy_Igno>(dest.har,"har",db);
-    ReadField<ErrorPolicy_Warn>(dest.ambr,"ambr",db);
-    ReadField<ErrorPolicy_Warn>(dest.ambg,"ambg",db);
-    ReadField<ErrorPolicy_Warn>(dest.ambb,"ambb",db);
-    ReadField<ErrorPolicy_Igno>(dest.mirr,"mirr",db);
-    ReadField<ErrorPolicy_Igno>(dest.mirg,"mirg",db);
-    ReadField<ErrorPolicy_Igno>(dest.mirb,"mirb",db);
-    ReadField<ErrorPolicy_Warn>(dest.emit,"emit",db);
-    ReadField<ErrorPolicy_Igno>(dest.ray_mirror,"ray_mirror",db);
-    ReadField<ErrorPolicy_Warn>(dest.alpha,"alpha",db);
-    ReadField<ErrorPolicy_Igno>(dest.ref,"ref",db);
-    ReadField<ErrorPolicy_Igno>(dest.translucency,"translucency",db);
-    ReadField<ErrorPolicy_Igno>(dest.mode,"mode",db);
-    ReadField<ErrorPolicy_Igno>(dest.roughness,"roughness",db);
-    ReadField<ErrorPolicy_Igno>(dest.darkness,"darkness",db);
-    ReadField<ErrorPolicy_Igno>(dest.refrac,"refrac",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.group,"*group",db);
-    ReadField<ErrorPolicy_Warn>(dest.diff_shader,"diff_shader",db);
-    ReadField<ErrorPolicy_Warn>(dest.spec_shader,"spec_shader",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.mtex,"*mtex",db);
-
-
-    ReadField<ErrorPolicy_Igno>(dest.amb, "amb", db);
-    ReadField<ErrorPolicy_Igno>(dest.ang, "ang", db);
-    ReadField<ErrorPolicy_Igno>(dest.spectra, "spectra", db);
-    ReadField<ErrorPolicy_Igno>(dest.spec, "spec", db);
-    ReadField<ErrorPolicy_Igno>(dest.zoffs, "zoffs", db);
-    ReadField<ErrorPolicy_Igno>(dest.add, "add", db);
-    ReadField<ErrorPolicy_Igno>(dest.fresnel_mir, "fresnel_mir", db);
-    ReadField<ErrorPolicy_Igno>(dest.fresnel_mir_i, "fresnel_mir_i", db);
-    ReadField<ErrorPolicy_Igno>(dest.fresnel_tra, "fresnel_tra", db);
-    ReadField<ErrorPolicy_Igno>(dest.fresnel_tra_i, "fresnel_tra_i", db);
-    ReadField<ErrorPolicy_Igno>(dest.filter, "filter", db);
-    ReadField<ErrorPolicy_Igno>(dest.tx_limit, "tx_limit", db);
-    ReadField<ErrorPolicy_Igno>(dest.tx_falloff, "tx_falloff", db);
-    ReadField<ErrorPolicy_Igno>(dest.gloss_mir, "gloss_mir", db);
-    ReadField<ErrorPolicy_Igno>(dest.gloss_tra, "gloss_tra", db);
-    ReadField<ErrorPolicy_Igno>(dest.adapt_thresh_mir, "adapt_thresh_mir", db);
-    ReadField<ErrorPolicy_Igno>(dest.adapt_thresh_tra, "adapt_thresh_tra", db);
-    ReadField<ErrorPolicy_Igno>(dest.aniso_gloss_mir, "aniso_gloss_mir", db);
-    ReadField<ErrorPolicy_Igno>(dest.dist_mir, "dist_mir", db);
-    ReadField<ErrorPolicy_Igno>(dest.hasize, "hasize", db);
-    ReadField<ErrorPolicy_Igno>(dest.flaresize, "flaresize", db);
-    ReadField<ErrorPolicy_Igno>(dest.subsize, "subsize", db);
-    ReadField<ErrorPolicy_Igno>(dest.flareboost, "flareboost", db);
-    ReadField<ErrorPolicy_Igno>(dest.strand_sta, "strand_sta", db);
-    ReadField<ErrorPolicy_Igno>(dest.strand_end, "strand_end", db);
-    ReadField<ErrorPolicy_Igno>(dest.strand_ease, "strand_ease", db);
-    ReadField<ErrorPolicy_Igno>(dest.strand_surfnor, "strand_surfnor", db);
-    ReadField<ErrorPolicy_Igno>(dest.strand_min, "strand_min", db);
-    ReadField<ErrorPolicy_Igno>(dest.strand_widthfade, "strand_widthfade", db);
-    ReadField<ErrorPolicy_Igno>(dest.sbias, "sbias", db);
-    ReadField<ErrorPolicy_Igno>(dest.lbias, "lbias", db);
-    ReadField<ErrorPolicy_Igno>(dest.shad_alpha, "shad_alpha", db);
-    ReadField<ErrorPolicy_Igno>(dest.param, "param", db);
-    ReadField<ErrorPolicy_Igno>(dest.rms, "rms", db);
-    ReadField<ErrorPolicy_Igno>(dest.rampfac_col, "rampfac_col", db);
-    ReadField<ErrorPolicy_Igno>(dest.rampfac_spec, "rampfac_spec", db);
-    ReadField<ErrorPolicy_Igno>(dest.friction, "friction", db);
-    ReadField<ErrorPolicy_Igno>(dest.fh, "fh", db);
-    ReadField<ErrorPolicy_Igno>(dest.reflect, "reflect", db);
-    ReadField<ErrorPolicy_Igno>(dest.fhdist, "fhdist", db);
-    ReadField<ErrorPolicy_Igno>(dest.xyfrict, "xyfrict", db);
-    ReadField<ErrorPolicy_Igno>(dest.sss_radius, "sss_radius", db);
-    ReadField<ErrorPolicy_Igno>(dest.sss_col, "sss_col", db);
-    ReadField<ErrorPolicy_Igno>(dest.sss_error, "sss_error", db);
-    ReadField<ErrorPolicy_Igno>(dest.sss_scale, "sss_scale", db);
-    ReadField<ErrorPolicy_Igno>(dest.sss_ior, "sss_ior", db);
-    ReadField<ErrorPolicy_Igno>(dest.sss_colfac, "sss_colfac", db);
-    ReadField<ErrorPolicy_Igno>(dest.sss_texfac, "sss_texfac", db);
-    ReadField<ErrorPolicy_Igno>(dest.sss_front, "sss_front", db);
-    ReadField<ErrorPolicy_Igno>(dest.sss_back, "sss_back", db);
-
-    ReadField<ErrorPolicy_Igno>(dest.material_type, "material_type", db);
-    ReadField<ErrorPolicy_Igno>(dest.flag, "flag", db);
-    ReadField<ErrorPolicy_Igno>(dest.ray_depth, "ray_depth", db);
-    ReadField<ErrorPolicy_Igno>(dest.ray_depth_tra, "ray_depth_tra", db);
-    ReadField<ErrorPolicy_Igno>(dest.samp_gloss_mir, "samp_gloss_mir", db);
-    ReadField<ErrorPolicy_Igno>(dest.samp_gloss_tra, "samp_gloss_tra", db);
-    ReadField<ErrorPolicy_Igno>(dest.fadeto_mir, "fadeto_mir", db);
-    ReadField<ErrorPolicy_Igno>(dest.shade_flag, "shade_flag", db);
-    ReadField<ErrorPolicy_Igno>(dest.flarec, "flarec", db);
-    ReadField<ErrorPolicy_Igno>(dest.starc, "starc", db);
-    ReadField<ErrorPolicy_Igno>(dest.linec, "linec", db);
-    ReadField<ErrorPolicy_Igno>(dest.ringc, "ringc", db);
-    ReadField<ErrorPolicy_Igno>(dest.pr_lamp, "pr_lamp", db);
-    ReadField<ErrorPolicy_Igno>(dest.pr_texture, "pr_texture", db);
-    ReadField<ErrorPolicy_Igno>(dest.ml_flag, "ml_flag", db);
-    ReadField<ErrorPolicy_Igno>(dest.diff_shader, "diff_shader", db);
-    ReadField<ErrorPolicy_Igno>(dest.spec_shader, "spec_shader", db);
-    ReadField<ErrorPolicy_Igno>(dest.texco, "texco", db);
-    ReadField<ErrorPolicy_Igno>(dest.mapto, "mapto", db);
-    ReadField<ErrorPolicy_Igno>(dest.ramp_show, "ramp_show", db);
-    ReadField<ErrorPolicy_Igno>(dest.pad3, "pad3", db);
-    ReadField<ErrorPolicy_Igno>(dest.dynamode, "dynamode", db);
-    ReadField<ErrorPolicy_Igno>(dest.pad2, "pad2", db);
-    ReadField<ErrorPolicy_Igno>(dest.sss_flag, "sss_flag", db);
-    ReadField<ErrorPolicy_Igno>(dest.sss_preset, "sss_preset", db);
-    ReadField<ErrorPolicy_Igno>(dest.shadowonly_flag, "shadowonly_flag", db);
-    ReadField<ErrorPolicy_Igno>(dest.index, "index", db);
-    ReadField<ErrorPolicy_Igno>(dest.vcol_alpha, "vcol_alpha", db);
-    ReadField<ErrorPolicy_Igno>(dest.pad4, "pad4", db);
-
-    ReadField<ErrorPolicy_Igno>(dest.seed1, "seed1", db);
-    ReadField<ErrorPolicy_Igno>(dest.seed2, "seed2", db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<MTexPoly> (
-    MTexPoly& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    {
-        std::shared_ptr<Image> tpage;
-        ReadFieldPtr<ErrorPolicy_Igno>(tpage,"*tpage",db);
-        dest.tpage = tpage.get();
-    }
-    ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
-    ReadField<ErrorPolicy_Igno>(dest.transp,"transp",db);
-    ReadField<ErrorPolicy_Igno>(dest.mode,"mode",db);
-    ReadField<ErrorPolicy_Igno>(dest.tile,"tile",db);
-    ReadField<ErrorPolicy_Igno>(dest.pad,"pad",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<Mesh> (
-    Mesh& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
-    ReadField<ErrorPolicy_Fail>(dest.totface,"totface",db);
-    ReadField<ErrorPolicy_Fail>(dest.totedge,"totedge",db);
-    ReadField<ErrorPolicy_Fail>(dest.totvert,"totvert",db);
-    ReadField<ErrorPolicy_Igno>(dest.totloop,"totloop",db);
-    ReadField<ErrorPolicy_Igno>(dest.totpoly,"totpoly",db);
-    ReadField<ErrorPolicy_Igno>(dest.subdiv,"subdiv",db);
-    ReadField<ErrorPolicy_Igno>(dest.subdivr,"subdivr",db);
-    ReadField<ErrorPolicy_Igno>(dest.subsurftype,"subsurftype",db);
-    ReadField<ErrorPolicy_Igno>(dest.smoothresh,"smoothresh",db);
-    ReadFieldPtr<ErrorPolicy_Fail>(dest.mface,"*mface",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.mtface,"*mtface",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.tface,"*tface",db);
-    ReadFieldPtr<ErrorPolicy_Fail>(dest.mvert,"*mvert",db);
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.medge,"*medge",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.mloop,"*mloop",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.mloopuv,"*mloopuv",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.mloopcol,"*mloopcol",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.mpoly,"*mpoly",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.mtpoly,"*mtpoly",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.dvert,"*dvert",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.mcol,"*mcol",db);
-    ReadFieldPtr<ErrorPolicy_Fail>(dest.mat,"**mat",db);
-
-    ReadField<ErrorPolicy_Igno>(dest.vdata, "vdata", db);
-    ReadField<ErrorPolicy_Igno>(dest.edata, "edata", db);
-    ReadField<ErrorPolicy_Igno>(dest.fdata, "fdata", db);
-    ReadField<ErrorPolicy_Igno>(dest.pdata, "pdata", db);
-    ReadField<ErrorPolicy_Warn>(dest.ldata, "ldata", db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<MDeformVert> (
-    MDeformVert& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.dw,"*dw",db);
-    ReadField<ErrorPolicy_Igno>(dest.totweight,"totweight",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<World> (
-    World& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<MLoopCol> (
-    MLoopCol& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Igno>(dest.r,"r",db);
-    ReadField<ErrorPolicy_Igno>(dest.g,"g",db);
-    ReadField<ErrorPolicy_Igno>(dest.b,"b",db);
-    ReadField<ErrorPolicy_Igno>(dest.a,"a",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<MVert> (
-    MVert& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadFieldArray<ErrorPolicy_Fail>(dest.co,"co",db);
-    ReadFieldArray<ErrorPolicy_Fail>(dest.no,"no",db);
-    ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
-    //ReadField<ErrorPolicy_Warn>(dest.mat_nr,"mat_nr",db);
-    ReadField<ErrorPolicy_Igno>(dest.bweight,"bweight",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<MEdge> (
-    MEdge& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.v1,"v1",db);
-    ReadField<ErrorPolicy_Fail>(dest.v2,"v2",db);
-    ReadField<ErrorPolicy_Igno>(dest.crease,"crease",db);
-    ReadField<ErrorPolicy_Igno>(dest.bweight,"bweight",db);
-    ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<MLoopUV> (
-    MLoopUV& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadFieldArray<ErrorPolicy_Igno>(dest.uv,"uv",db);
-    ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<GroupObject> (
-    GroupObject& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadFieldPtr<ErrorPolicy_Fail>(dest.prev,"*prev",db);
-    ReadFieldPtr<ErrorPolicy_Fail>(dest.next,"*next",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.ob,"*ob",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<ListBase> (
-    ListBase& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.first,"*first",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.last,"*last",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<MLoop> (
-    MLoop& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Igno>(dest.v,"v",db);
-    ReadField<ErrorPolicy_Igno>(dest.e,"e",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<ModifierData> (
-    ModifierData& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.next,"*next",db);
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.prev,"*prev",db);
-    ReadField<ErrorPolicy_Igno>(dest.type,"type",db);
-    ReadField<ErrorPolicy_Igno>(dest.mode,"mode",db);
-    ReadFieldArray<ErrorPolicy_Igno>(dest.name,"name",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<ID> (
-    ID& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadFieldArray<ErrorPolicy_Warn>(dest.name,"name",db);
-    ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<MCol> (
-    MCol& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.r,"r",db);
-    ReadField<ErrorPolicy_Fail>(dest.g,"g",db);
-    ReadField<ErrorPolicy_Fail>(dest.b,"b",db);
-    ReadField<ErrorPolicy_Fail>(dest.a,"a",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<MPoly> (
-    MPoly& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Igno>(dest.loopstart,"loopstart",db);
-    ReadField<ErrorPolicy_Igno>(dest.totloop,"totloop",db);
-    ReadField<ErrorPolicy_Igno>(dest.mat_nr,"mat_nr",db);
-    ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<Scene> (
-    Scene& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.camera,"*camera",db);
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.world,"*world",db);
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.basact,"*basact",db);
-    ReadField<ErrorPolicy_Igno>(dest.base,"base",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<Library> (
-    Library& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
-    ReadFieldArray<ErrorPolicy_Warn>(dest.name,"name",db);
-    ReadFieldArray<ErrorPolicy_Fail>(dest.filename,"filename",db);
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.parent,"*parent",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<Tex> (
-    Tex& dest,
-    const FileDatabase& db
-    ) const
-{
-    short temp_short = 0;
-    ReadField<ErrorPolicy_Igno>(temp_short,"imaflag",db);
-    dest.imaflag = static_cast<Assimp::Blender::Tex::ImageFlags>(temp_short);
-    int temp = 0;
-    ReadField<ErrorPolicy_Fail>(temp,"type",db);
-    dest.type = static_cast<Assimp::Blender::Tex::Type>(temp);
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.ima,"*ima",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<Camera> (
-    Camera& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
-    int temp = 0;
-    ReadField<ErrorPolicy_Warn>(temp,"type",db);
-    dest.type = static_cast<Assimp::Blender::Camera::Type>(temp);
-    ReadField<ErrorPolicy_Warn>(temp,"flag",db);
-    dest.flag = static_cast<Assimp::Blender::Camera::Type>(temp);
-    ReadField<ErrorPolicy_Warn>(dest.lens,"lens",db);
-    ReadField<ErrorPolicy_Warn>(dest.sensor_x,"sensor_x",db);
-    ReadField<ErrorPolicy_Igno>(dest.clipsta,"clipsta",db);
-    ReadField<ErrorPolicy_Igno>(dest.clipend,"clipend",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<MirrorModifierData> (
-    MirrorModifierData& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.modifier,"modifier",db);
-    ReadField<ErrorPolicy_Igno>(dest.axis,"axis",db);
-    ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
-    ReadField<ErrorPolicy_Igno>(dest.tolerance,"tolerance",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.mirror_ob,"*mirror_ob",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<Image> (
-    Image& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
-    ReadFieldArray<ErrorPolicy_Warn>(dest.name,"name",db);
-    ReadField<ErrorPolicy_Igno>(dest.ok,"ok",db);
-    ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
-    ReadField<ErrorPolicy_Igno>(dest.source,"source",db);
-    ReadField<ErrorPolicy_Igno>(dest.type,"type",db);
-    ReadField<ErrorPolicy_Igno>(dest.pad,"pad",db);
-    ReadField<ErrorPolicy_Igno>(dest.pad1,"pad1",db);
-    ReadField<ErrorPolicy_Igno>(dest.lastframe,"lastframe",db);
-    ReadField<ErrorPolicy_Igno>(dest.tpageflag,"tpageflag",db);
-    ReadField<ErrorPolicy_Igno>(dest.totbind,"totbind",db);
-    ReadField<ErrorPolicy_Igno>(dest.xrep,"xrep",db);
-    ReadField<ErrorPolicy_Igno>(dest.yrep,"yrep",db);
-    ReadField<ErrorPolicy_Igno>(dest.twsta,"twsta",db);
-    ReadField<ErrorPolicy_Igno>(dest.twend,"twend",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.packedfile,"*packedfile",db);
-    ReadField<ErrorPolicy_Igno>(dest.lastupdate,"lastupdate",db);
-    ReadField<ErrorPolicy_Igno>(dest.lastused,"lastused",db);
-    ReadField<ErrorPolicy_Igno>(dest.animspeed,"animspeed",db);
-    ReadField<ErrorPolicy_Igno>(dest.gen_x,"gen_x",db);
-    ReadField<ErrorPolicy_Igno>(dest.gen_y,"gen_y",db);
-    ReadField<ErrorPolicy_Igno>(dest.gen_type,"gen_type",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure::Convert<CustomData>(
-    CustomData& dest,
-    const FileDatabase& db
-    ) const
-{
-    ReadFieldArray<ErrorPolicy_Warn>(dest.typemap, "typemap", db);
-    ReadField<ErrorPolicy_Warn>(dest.totlayer, "totlayer", db);
-    ReadField<ErrorPolicy_Warn>(dest.maxlayer, "maxlayer", db);
-    ReadField<ErrorPolicy_Warn>(dest.totsize, "totsize", db);
-    ReadFieldPtrVector<ErrorPolicy_Warn>(dest.layers, "*layers", db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure::Convert<CustomDataLayer>(
-    CustomDataLayer& dest,
-    const FileDatabase& db
-    ) const
-{
-    ReadField<ErrorPolicy_Fail>(dest.type, "type", db);
-    ReadField<ErrorPolicy_Fail>(dest.offset, "offset", db);
-    ReadField<ErrorPolicy_Fail>(dest.flag, "flag", db);
-    ReadField<ErrorPolicy_Fail>(dest.active, "active", db);
-    ReadField<ErrorPolicy_Fail>(dest.active_rnd, "active_rnd", db);
-    ReadField<ErrorPolicy_Fail>(dest.active_clone, "active_clone", db);
-    ReadField<ErrorPolicy_Fail>(dest.active_mask, "active_mask", db);
-    ReadField<ErrorPolicy_Fail>(dest.uid, "uid", db);
-    ReadFieldArray<ErrorPolicy_Warn>(dest.name, "name", db);
-    ReadCustomDataPtr<ErrorPolicy_Fail>(dest.data, dest.type, "*data", db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-void DNA::RegisterConverters() {
-
-    converters["Object"] = DNA::FactoryPair( &Structure::Allocate<Object>, &Structure::Convert<Object> );
-    converters["Group"] = DNA::FactoryPair( &Structure::Allocate<Group>, &Structure::Convert<Group> );
-    converters["MTex"] = DNA::FactoryPair( &Structure::Allocate<MTex>, &Structure::Convert<MTex> );
-    converters["TFace"] = DNA::FactoryPair( &Structure::Allocate<TFace>, &Structure::Convert<TFace> );
-    converters["SubsurfModifierData"] = DNA::FactoryPair( &Structure::Allocate<SubsurfModifierData>, &Structure::Convert<SubsurfModifierData> );
-    converters["MFace"] = DNA::FactoryPair( &Structure::Allocate<MFace>, &Structure::Convert<MFace> );
-    converters["Lamp"] = DNA::FactoryPair( &Structure::Allocate<Lamp>, &Structure::Convert<Lamp> );
-    converters["MDeformWeight"] = DNA::FactoryPair( &Structure::Allocate<MDeformWeight>, &Structure::Convert<MDeformWeight> );
-    converters["PackedFile"] = DNA::FactoryPair( &Structure::Allocate<PackedFile>, &Structure::Convert<PackedFile> );
-    converters["Base"] = DNA::FactoryPair( &Structure::Allocate<Base>, &Structure::Convert<Base> );
-    converters["MTFace"] = DNA::FactoryPair( &Structure::Allocate<MTFace>, &Structure::Convert<MTFace> );
-    converters["Material"] = DNA::FactoryPair( &Structure::Allocate<Material>, &Structure::Convert<Material> );
-    converters["MTexPoly"] = DNA::FactoryPair( &Structure::Allocate<MTexPoly>, &Structure::Convert<MTexPoly> );
-    converters["Mesh"] = DNA::FactoryPair( &Structure::Allocate<Mesh>, &Structure::Convert<Mesh> );
-    converters["MDeformVert"] = DNA::FactoryPair( &Structure::Allocate<MDeformVert>, &Structure::Convert<MDeformVert> );
-    converters["World"] = DNA::FactoryPair( &Structure::Allocate<World>, &Structure::Convert<World> );
-    converters["MLoopCol"] = DNA::FactoryPair( &Structure::Allocate<MLoopCol>, &Structure::Convert<MLoopCol> );
-    converters["MVert"] = DNA::FactoryPair( &Structure::Allocate<MVert>, &Structure::Convert<MVert> );
-    converters["MEdge"] = DNA::FactoryPair( &Structure::Allocate<MEdge>, &Structure::Convert<MEdge> );
-    converters["MLoopUV"] = DNA::FactoryPair( &Structure::Allocate<MLoopUV>, &Structure::Convert<MLoopUV> );
-    converters["GroupObject"] = DNA::FactoryPair( &Structure::Allocate<GroupObject>, &Structure::Convert<GroupObject> );
-    converters["ListBase"] = DNA::FactoryPair( &Structure::Allocate<ListBase>, &Structure::Convert<ListBase> );
-    converters["MLoop"] = DNA::FactoryPair( &Structure::Allocate<MLoop>, &Structure::Convert<MLoop> );
-    converters["ModifierData"] = DNA::FactoryPair( &Structure::Allocate<ModifierData>, &Structure::Convert<ModifierData> );
-    converters["ID"] = DNA::FactoryPair( &Structure::Allocate<ID>, &Structure::Convert<ID> );
-    converters["MCol"] = DNA::FactoryPair( &Structure::Allocate<MCol>, &Structure::Convert<MCol> );
-    converters["MPoly"] = DNA::FactoryPair( &Structure::Allocate<MPoly>, &Structure::Convert<MPoly> );
-    converters["Scene"] = DNA::FactoryPair( &Structure::Allocate<Scene>, &Structure::Convert<Scene> );
-    converters["Library"] = DNA::FactoryPair( &Structure::Allocate<Library>, &Structure::Convert<Library> );
-    converters["Tex"] = DNA::FactoryPair( &Structure::Allocate<Tex>, &Structure::Convert<Tex> );
-    converters["Camera"] = DNA::FactoryPair( &Structure::Allocate<Camera>, &Structure::Convert<Camera> );
-    converters["MirrorModifierData"] = DNA::FactoryPair( &Structure::Allocate<MirrorModifierData>, &Structure::Convert<MirrorModifierData> );
-    converters["Image"] = DNA::FactoryPair( &Structure::Allocate<Image>, &Structure::Convert<Image> );
-    converters["CustomData"] = DNA::FactoryPair(&Structure::Allocate<CustomData>, &Structure::Convert<CustomData>);
-    converters["CustomDataLayer"] = DNA::FactoryPair(&Structure::Allocate<CustomDataLayer>, &Structure::Convert<CustomDataLayer>);
-}
-
-#endif // ASSIMP_BUILD_NO_BLEND_IMPORTER
-
diff --git a/Engine/lib/assimp/code/CApi/AssimpCExport.cpp b/Engine/lib/assimp/code/CApi/AssimpCExport.cpp
index 7557edcfc..5e43958d0 100644
--- a/Engine/lib/assimp/code/CApi/AssimpCExport.cpp
+++ b/Engine/lib/assimp/code/CApi/AssimpCExport.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -48,108 +48,96 @@ Assimp C export interface. See Exporter.cpp for some notes.
 #ifndef ASSIMP_BUILD_NO_EXPORT
 
 #include "CInterfaceIOWrapper.h"
-#include <assimp/SceneCombiner.h>
 #include "Common/ScenePrivate.h"
+#include <assimp/SceneCombiner.h>
 #include <assimp/Exporter.hpp>
 
 using namespace Assimp;
 
 // ------------------------------------------------------------------------------------------------
-ASSIMP_API size_t aiGetExportFormatCount(void)
-{
+ASSIMP_API size_t aiGetExportFormatCount(void) {
     return Exporter().GetExportFormatCount();
 }
 
 // ------------------------------------------------------------------------------------------------
-ASSIMP_API const aiExportFormatDesc* aiGetExportFormatDescription( size_t index)
-{
+ASSIMP_API const aiExportFormatDesc *aiGetExportFormatDescription(size_t index) {
     // Note: this is valid as the index always pertains to a built-in exporter,
     // for which the returned structure is guaranteed to be of static storage duration.
     Exporter exporter;
-    const aiExportFormatDesc* orig( exporter.GetExportFormatDescription( index ) );
-    if (NULL == orig) {
-        return NULL;
+    const aiExportFormatDesc *orig(exporter.GetExportFormatDescription(index));
+    if (nullptr == orig) {
+        return nullptr;
     }
 
     aiExportFormatDesc *desc = new aiExportFormatDesc;
-    desc->description = new char[ strlen( orig->description ) + 1 ]();
-    ::strncpy( (char*) desc->description, orig->description, strlen( orig->description ) );
-    desc->fileExtension = new char[ strlen( orig->fileExtension ) + 1 ]();
-    ::strncpy( ( char* ) desc->fileExtension, orig->fileExtension, strlen( orig->fileExtension ) );
-    desc->id = new char[ strlen( orig->id ) + 1 ]();
-    ::strncpy( ( char* ) desc->id, orig->id, strlen( orig->id ) );
+    desc->description = new char[strlen(orig->description) + 1]();
+    ::memcpy((char *)desc->description, orig->description, strlen(orig->description));
+    desc->fileExtension = new char[strlen(orig->fileExtension) + 1]();
+    ::memcpy((char *)desc->fileExtension, orig->fileExtension, strlen(orig->fileExtension));
+    desc->id = new char[strlen(orig->id) + 1]();
+    ::memcpy((char *)desc->id, orig->id, strlen(orig->id));
 
     return desc;
 }
 
 // ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiReleaseExportFormatDescription( const aiExportFormatDesc *desc ) {
-    if (NULL == desc) {
+ASSIMP_API void aiReleaseExportFormatDescription(const aiExportFormatDesc *desc) {
+    if (nullptr == desc) {
         return;
     }
 
-    delete [] desc->description;
-    delete [] desc->fileExtension;
-    delete [] desc->id;
+    delete[] desc->description;
+    delete[] desc->fileExtension;
+    delete[] desc->id;
     delete desc;
 }
 
 // ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiCopyScene(const aiScene* pIn, aiScene** pOut)
-{
+ASSIMP_API void aiCopyScene(const aiScene *pIn, aiScene **pOut) {
     if (!pOut || !pIn) {
         return;
     }
 
-    SceneCombiner::CopyScene(pOut,pIn,true);
+    SceneCombiner::CopyScene(pOut, pIn, true);
     ScenePriv(*pOut)->mIsCopy = true;
 }
 
-
 // ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiFreeScene(const C_STRUCT aiScene* pIn)
-{
+ASSIMP_API void aiFreeScene(const C_STRUCT aiScene *pIn) {
     // note: aiReleaseImport() is also able to delete scene copies, but in addition
     // it also handles scenes with import metadata.
     delete pIn;
 }
 
-
 // ------------------------------------------------------------------------------------------------
-ASSIMP_API aiReturn aiExportScene( const aiScene* pScene, const char* pFormatId, const char* pFileName, unsigned int pPreprocessing )
-{
-    return ::aiExportSceneEx(pScene,pFormatId,pFileName,NULL,pPreprocessing);
+ASSIMP_API aiReturn aiExportScene(const aiScene *pScene, const char *pFormatId, const char *pFileName, unsigned int pPreprocessing) {
+    return ::aiExportSceneEx(pScene, pFormatId, pFileName, nullptr, pPreprocessing);
 }
 
-
 // ------------------------------------------------------------------------------------------------
-ASSIMP_API aiReturn aiExportSceneEx( const aiScene* pScene, const char* pFormatId, const char* pFileName, aiFileIO* pIO, unsigned int pPreprocessing )
-{
+ASSIMP_API aiReturn aiExportSceneEx(const aiScene *pScene, const char *pFormatId, const char *pFileName, aiFileIO *pIO, unsigned int pPreprocessing) {
     Exporter exp;
 
     if (pIO) {
         exp.SetIOHandler(new CIOSystemWrapper(pIO));
     }
-    return exp.Export(pScene,pFormatId,pFileName,pPreprocessing);
+    return exp.Export(pScene, pFormatId, pFileName, pPreprocessing);
 }
 
-
 // ------------------------------------------------------------------------------------------------
-ASSIMP_API const C_STRUCT aiExportDataBlob* aiExportSceneToBlob( const aiScene* pScene, const char* pFormatId, unsigned int pPreprocessing  )
-{
+ASSIMP_API const C_STRUCT aiExportDataBlob *aiExportSceneToBlob(const aiScene *pScene, const char *pFormatId, unsigned int pPreprocessing) {
     Exporter exp;
-    if (!exp.ExportToBlob(pScene,pFormatId,pPreprocessing)) {
-        return NULL;
+    if (!exp.ExportToBlob(pScene, pFormatId, pPreprocessing)) {
+        return nullptr;
     }
-    const aiExportDataBlob* blob = exp.GetOrphanedBlob();
+    const aiExportDataBlob *blob = exp.GetOrphanedBlob();
     ai_assert(blob);
 
     return blob;
 }
 
 // ------------------------------------------------------------------------------------------------
-ASSIMP_API C_STRUCT void aiReleaseExportBlob( const aiExportDataBlob* pData )
-{
+ASSIMP_API C_STRUCT void aiReleaseExportBlob(const aiExportDataBlob *pData) {
     delete pData;
 }
 
diff --git a/Engine/lib/assimp/code/CApi/CInterfaceIOWrapper.cpp b/Engine/lib/assimp/code/CApi/CInterfaceIOWrapper.cpp
index 5a3a49565..579545ecc 100644
--- a/Engine/lib/assimp/code/CApi/CInterfaceIOWrapper.cpp
+++ b/Engine/lib/assimp/code/CApi/CInterfaceIOWrapper.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -45,44 +45,39 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "CInterfaceIOWrapper.h"
 
-namespace Assimp    {
+namespace Assimp {
 
-CIOStreamWrapper::~CIOStreamWrapper(void)
-{
+CIOStreamWrapper::~CIOStreamWrapper() {
     /* Various places depend on this destructor to close the file */
     if (mFile) {
         mIO->mFileSystem->CloseProc(mIO->mFileSystem, mFile);
-        mFile = nullptr;
     }
 }
 
 // ...................................................................
-size_t CIOStreamWrapper::Read(void* pvBuffer,
-    size_t pSize,
-    size_t pCount
-){
+size_t CIOStreamWrapper::Read(void *pvBuffer,
+        size_t pSize,
+        size_t pCount) {
     // need to typecast here as C has no void*
-    return mFile->ReadProc(mFile,(char*)pvBuffer,pSize,pCount);
+    return mFile->ReadProc(mFile, (char *)pvBuffer, pSize, pCount);
 }
 
 // ...................................................................
-size_t CIOStreamWrapper::Write(const void* pvBuffer,
-    size_t pSize,
-    size_t pCount
-){
+size_t CIOStreamWrapper::Write(const void *pvBuffer,
+        size_t pSize,
+        size_t pCount) {
     // need to typecast here as C has no void*
-    return mFile->WriteProc(mFile,(const char*)pvBuffer,pSize,pCount);
+    return mFile->WriteProc(mFile, (const char *)pvBuffer, pSize, pCount);
 }
 
 // ...................................................................
 aiReturn CIOStreamWrapper::Seek(size_t pOffset,
-    aiOrigin pOrigin
-){
-    return mFile->SeekProc(mFile,pOffset,pOrigin);
+        aiOrigin pOrigin) {
+    return mFile->SeekProc(mFile, pOffset, pOrigin);
 }
 
 // ...................................................................
-size_t CIOStreamWrapper::Tell(void) const {
+size_t CIOStreamWrapper::Tell() const {
     return mFile->TellProc(mFile);
 }
 
@@ -92,16 +87,16 @@ size_t CIOStreamWrapper::FileSize() const {
 }
 
 // ...................................................................
-void CIOStreamWrapper::Flush () {
+void CIOStreamWrapper::Flush() {
     return mFile->FlushProc(mFile);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Custom IOStream implementation for the C-API
-bool CIOSystemWrapper::Exists( const char* pFile) const {
-    aiFile* p = mFileSystem->OpenProc(mFileSystem,pFile,"rb");
-    if (p){
-        mFileSystem->CloseProc(mFileSystem,p);
+bool CIOSystemWrapper::Exists(const char *pFile) const {
+    aiFile *p = mFileSystem->OpenProc(mFileSystem, pFile, "rb");
+    if (p) {
+        mFileSystem->CloseProc(mFileSystem, p);
         return true;
     }
     return false;
@@ -117,20 +112,20 @@ char CIOSystemWrapper::getOsSeparator() const {
 }
 
 // ...................................................................
-IOStream* CIOSystemWrapper::Open(const char* pFile,const char* pMode) {
-    aiFile* p = mFileSystem->OpenProc(mFileSystem,pFile,pMode);
+IOStream *CIOSystemWrapper::Open(const char *pFile, const char *pMode) {
+    aiFile *p = mFileSystem->OpenProc(mFileSystem, pFile, pMode);
     if (!p) {
-        return NULL;
+        return nullptr;
     }
     return new CIOStreamWrapper(p, this);
 }
 
 // ...................................................................
-void CIOSystemWrapper::Close( IOStream* pFile) {
+void CIOSystemWrapper::Close(IOStream *pFile) {
     if (!pFile) {
         return;
     }
     delete pFile;
 }
 
-}
+} // namespace Assimp
diff --git a/Engine/lib/assimp/code/CApi/CInterfaceIOWrapper.h b/Engine/lib/assimp/code/CApi/CInterfaceIOWrapper.h
index 216232030..768be3746 100644
--- a/Engine/lib/assimp/code/CApi/CInterfaceIOWrapper.h
+++ b/Engine/lib/assimp/code/CApi/CInterfaceIOWrapper.h
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -50,50 +48,47 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/IOStream.hpp>
 #include <assimp/IOSystem.hpp>
 
-namespace Assimp    {
+namespace Assimp {
 
 class CIOSystemWrapper;
 
 // ------------------------------------------------------------------------------------------------
 // Custom IOStream implementation for the C-API
-class CIOStreamWrapper : public IOStream
-{
+class CIOStreamWrapper : public IOStream {
 public:
-    explicit CIOStreamWrapper(aiFile* pFile, CIOSystemWrapper* io)
-        : mFile(pFile),
-        mIO(io)
-    {}
+    explicit CIOStreamWrapper(aiFile *pFile, CIOSystemWrapper *io) :
+            mFile(pFile),
+            mIO(io) {}
     ~CIOStreamWrapper(void);
 
-    size_t Read(void* pvBuffer, size_t pSize, size_t pCount);
-    size_t Write(const void* pvBuffer, size_t pSize, size_t pCount);
+    size_t Read(void *pvBuffer, size_t pSize, size_t pCount);
+    size_t Write(const void *pvBuffer, size_t pSize, size_t pCount);
     aiReturn Seek(size_t pOffset, aiOrigin pOrigin);
     size_t Tell(void) const;
     size_t FileSize() const;
     void Flush();
 
 private:
-    aiFile* mFile;
-    CIOSystemWrapper* mIO;
+    aiFile *mFile;
+    CIOSystemWrapper *mIO;
 };
 
-class CIOSystemWrapper : public IOSystem
-{
+class CIOSystemWrapper : public IOSystem {
     friend class CIOStreamWrapper;
-public:
-    explicit CIOSystemWrapper(aiFileIO* pFile)
-        : mFileSystem(pFile)
-    {}
 
-    bool Exists( const char* pFile) const;
+public:
+    explicit CIOSystemWrapper(aiFileIO *pFile) :
+            mFileSystem(pFile) {}
+
+    bool Exists(const char *pFile) const;
     char getOsSeparator() const;
-    IOStream* Open(const char* pFile,const char* pMode = "rb");
-    void Close( IOStream* pFile);
+    IOStream *Open(const char *pFile, const char *pMode = "rb");
+    void Close(IOStream *pFile);
+
 private:
-    aiFileIO* mFileSystem;
+    aiFileIO *mFileSystem;
 };
 
-}
+} // namespace Assimp
 
 #endif
-
diff --git a/Engine/lib/assimp/code/CMakeLists.txt b/Engine/lib/assimp/code/CMakeLists.txt
index 55538d965..2eff6117f 100644
--- a/Engine/lib/assimp/code/CMakeLists.txt
+++ b/Engine/lib/assimp/code/CMakeLists.txt
@@ -1,7 +1,7 @@
 # Open Asset Import Library (assimp)
 # ----------------------------------------------------------------------
 #
-# Copyright (c) 2006-2019, assimp team
+# Copyright (c) 2006-2022, assimp team
 #
 # All rights reserved.
 #
@@ -43,13 +43,13 @@
 # 3) Add libassimp using the file lists (eliminates duplication of file names between
 #    source groups and library command)
 #
-cmake_minimum_required( VERSION 3.0 )
+cmake_minimum_required( VERSION 3.10 )
 SET( HEADER_PATH ../include/assimp )
 
 if(NOT ANDROID AND ASSIMP_ANDROID_JNIIOSYSTEM)
     message(WARNING "Requesting Android JNI I/O-System in non-Android toolchain. Resetting ASSIMP_ANDROID_JNIIOSYSTEM to OFF.")
     set(ASSIMP_ANDROID_JNIIOSYSTEM OFF)
-endif(NOT ANDROID AND ASSIMP_ANDROID_JNIIOSYSTEM)
+endif()
 
 SET( COMPILER_HEADERS
   ${HEADER_PATH}/Compiler/pushpack1.h
@@ -66,8 +66,9 @@ SET( PUBLIC_HEADERS
   ${HEADER_PATH}/color4.h
   ${HEADER_PATH}/color4.inl
   ${CMAKE_CURRENT_BINARY_DIR}/../include/assimp/config.h
+  ${HEADER_PATH}/ColladaMetaData.h
+  ${HEADER_PATH}/commonMetaData.h
   ${HEADER_PATH}/defs.h
-  ${HEADER_PATH}/Defines.h
   ${HEADER_PATH}/cfileio.h
   ${HEADER_PATH}/light.h
   ${HEADER_PATH}/material.h
@@ -77,7 +78,9 @@ SET( PUBLIC_HEADERS
   ${HEADER_PATH}/matrix4x4.h
   ${HEADER_PATH}/matrix4x4.inl
   ${HEADER_PATH}/mesh.h
+  ${HEADER_PATH}/ObjMaterial.h
   ${HEADER_PATH}/pbrmaterial.h
+  ${HEADER_PATH}/GltfMaterial.h
   ${HEADER_PATH}/postprocess.h
   ${HEADER_PATH}/quaternion.h
   ${HEADER_PATH}/quaternion.inl
@@ -120,6 +123,7 @@ SET( PUBLIC_HEADERS
   ${HEADER_PATH}/GenericProperty.h
   ${HEADER_PATH}/SpatialSort.h
   ${HEADER_PATH}/SkeletonMeshBuilder.h
+  ${HEADER_PATH}/SmallVector.h
   ${HEADER_PATH}/SmoothingGroups.h
   ${HEADER_PATH}/SmoothingGroups.inl
   ${HEADER_PATH}/StandardShapes.h
@@ -134,12 +138,12 @@ SET( PUBLIC_HEADERS
   ${HEADER_PATH}/XMLTools.h
   ${HEADER_PATH}/IOStreamBuffer.h
   ${HEADER_PATH}/CreateAnimMesh.h
-  ${HEADER_PATH}/irrXMLWrapper.h
+  ${HEADER_PATH}/XmlParser.h
   ${HEADER_PATH}/BlobIOSystem.h
   ${HEADER_PATH}/MathFunctions.h
-  ${HEADER_PATH}/Macros.h
   ${HEADER_PATH}/Exceptional.h
   ${HEADER_PATH}/ByteSwapper.h
+  ${HEADER_PATH}/Base64.hpp
 )
 
 SET( Core_SRCS
@@ -148,7 +152,7 @@ SET( Core_SRCS
 
 IF(MSVC)
   list(APPEND Core_SRCS "res/assimp.rc")
-ENDIF(MSVC)
+ENDIF()
 
 SET( Logging_SRCS
   ${HEADER_PATH}/DefaultLogger.hpp
@@ -163,6 +167,8 @@ SET( Logging_SRCS
 SOURCE_GROUP(Logging FILES ${Logging_SRCS})
 
 SET( Common_SRCS
+  Common/Compression.cpp
+  Common/Compression.h
   Common/BaseImporter.cpp
   Common/BaseProcess.cpp
   Common/BaseProcess.h
@@ -172,6 +178,7 @@ SET( Common_SRCS
   Common/ImporterRegistry.cpp
   Common/DefaultProgressHandler.h
   Common/DefaultIOStream.cpp
+  Common/IOSystem.cpp
   Common/DefaultIOSystem.cpp
   Common/ZipArchiveIOSystem.cpp
   Common/PolyTools.h
@@ -185,8 +192,6 @@ SET( Common_SRCS
   Common/ScenePreprocessor.cpp
   Common/ScenePreprocessor.h
   Common/SkeletonMeshBuilder.cpp
-  Common/SplitByBoneCountProcess.cpp
-  Common/SplitByBoneCountProcess.h
   Common/StandardShapes.cpp
   Common/TargetAnimation.cpp
   Common/TargetAnimation.h
@@ -198,6 +203,10 @@ SET( Common_SRCS
   Common/CreateAnimMesh.cpp
   Common/simd.h
   Common/simd.cpp
+  Common/material.cpp
+  Common/AssertHandler.cpp
+  Common/Exceptional.cpp
+  Common/Base64.cpp
 )
 SOURCE_GROUP(Common FILES ${Common_SRCS})
 
@@ -208,20 +217,20 @@ SET( CApi_SRCS
 SOURCE_GROUP(CApi FILES ${CApi_SRCS})
 
 SET( STEPParser_SRCS
-  Importer/STEPParser/STEPFileReader.h
-  Importer/STEPParser/STEPFileReader.cpp
-  Importer/STEPParser/STEPFileEncoding.cpp
-  Importer/STEPParser/STEPFileEncoding.h
+  AssetLib/STEPParser/STEPFileReader.h
+  AssetLib/STEPParser/STEPFileReader.cpp
+  AssetLib/STEPParser/STEPFileEncoding.cpp
+  AssetLib/STEPParser/STEPFileEncoding.h
 )
 SOURCE_GROUP(STEPParser FILES ${STEPParser_SRCS})
 
 IF ( ASSIMP_BUILD_NONFREE_C4D_IMPORTER )
   SET( C4D_SRCS
-    C4D/C4DImporter.cpp
-    C4D/C4DImporter.h
+    AssetLib/C4D/C4DImporter.cpp
+    AssetLib/C4D/C4DImporter.h
   )
   SOURCE_GROUP( C4D FILES ${C4D_SRCS})
-ENDIF ( ASSIMP_BUILD_NONFREE_C4D_IMPORTER )
+ENDIF ()
 
 # if this variable is set to TRUE, the user can manually disable importers by setting
 # ASSIMP_BUILD_XXX_IMPORTER to FALSE for each importer
@@ -243,7 +252,7 @@ MACRO(ADD_ASSIMP_IMPORTER name)
   IF (ASSIMP_IMPORTER_ENABLED)
     LIST(APPEND ASSIMP_LOADER_SRCS ${ARGN})
     SET(ASSIMP_IMPORTERS_ENABLED "${ASSIMP_IMPORTERS_ENABLED} ${name}")
-    SOURCE_GROUP(${name} FILES ${ARGN})
+    SOURCE_GROUP(AssetLib\\${name} FILES ${ARGN})
   ELSE()
     SET(${name}_SRC "")
     SET(ASSIMP_IMPORTERS_DISABLED "${ASSIMP_IMPORTERS_DISABLED} ${name}")
@@ -251,35 +260,39 @@ MACRO(ADD_ASSIMP_IMPORTER name)
   ENDIF()
 ENDMACRO()
 
-# if this variable is set to TRUE, the user can manually disable exporters by setting
-# ASSIMP_BUILD_XXX_EXPORTER to FALSE for each exporter
-# if this variable is set to FALSE, the user can manually enable exporters by setting
-# ASSIMP_BUILD_XXX_EXPORTER to TRUE for each exporter
-OPTION(ASSIMP_BUILD_ALL_EXPORTERS_BY_DEFAULT "default value of all ASSIMP_BUILD_XXX_EXPORTER values" TRUE)
+if (NOT ASSIMP_NO_EXPORT)
 
-# macro to add the CMake Option ADD_ASSIMP_IMPORTER_<name> which enables compile of loader
-# this way selective loaders can be compiled (reduces filesize + compile time)
-MACRO(ADD_ASSIMP_EXPORTER name)
-  IF (ASSIMP_NO_EXPORT)
-	set(ASSIMP_EXPORTER_ENABLED FALSE)
-  ELSEIF (ASSIMP_BUILD_ALL_EXPORTERS_BY_DEFAULT)
-    set(ASSIMP_EXPORTER_ENABLED TRUE)
-    IF (DEFINED ASSIMP_BUILD_${name}_EXPORTER AND NOT ASSIMP_BUILD_${name}_EXPORTER)
+  # if this variable is set to TRUE, the user can manually disable exporters by setting
+  # ASSIMP_BUILD_XXX_EXPORTER to FALSE for each exporter
+  # if this variable is set to FALSE, the user can manually enable exporters by setting
+  # ASSIMP_BUILD_XXX_EXPORTER to TRUE for each exporter
+  OPTION(ASSIMP_BUILD_ALL_EXPORTERS_BY_DEFAULT "default value of all ASSIMP_BUILD_XXX_EXPORTER values" TRUE)
+
+  # macro to add the CMake Option ADD_ASSIMP_IMPORTER_<name> which enables compile of loader
+  # this way selective loaders can be compiled (reduces filesize + compile time)
+  MACRO(ADD_ASSIMP_EXPORTER name)
+    IF (ASSIMP_NO_EXPORT)
       set(ASSIMP_EXPORTER_ENABLED FALSE)
+    ELSEIF (ASSIMP_BUILD_ALL_EXPORTERS_BY_DEFAULT)
+      set(ASSIMP_EXPORTER_ENABLED TRUE)
+      IF (DEFINED ASSIMP_BUILD_${name}_EXPORTER AND NOT ASSIMP_BUILD_${name}_EXPORTER)
+        set(ASSIMP_EXPORTER_ENABLED FALSE)
+      ENDIF ()
+    ELSE ()
+      set(ASSIMP_EXPORTER_ENABLED ${ASSIMP_BUILD_${name}_EXPORTER})
     ENDIF ()
-  ELSE ()
-    set(ASSIMP_EXPORTER_ENABLED ${ASSIMP_BUILD_${name}_EXPORTER})
-  ENDIF ()
 
-  IF (ASSIMP_EXPORTER_ENABLED)
-    SET(ASSIMP_EXPORTERS_ENABLED "${ASSIMP_EXPORTERS_ENABLED} ${name}")
-	LIST(APPEND ASSIMP_EXPORTER_SRCS ${ARGN})
-    SOURCE_GROUP(${name}_EXPORTER FILES ${ARGN})
-  ELSE()
-    SET(ASSIMP_EXPORTERS_DISABLED "${ASSIMP_EXPORTERS_DISABLED} ${name}")
-    add_definitions(-DASSIMP_BUILD_NO_${name}_EXPORTER)
-  ENDIF()
-ENDMACRO()
+    IF (ASSIMP_EXPORTER_ENABLED)
+      SET(ASSIMP_EXPORTERS_ENABLED "${ASSIMP_EXPORTERS_ENABLED} ${name}")
+      LIST(APPEND ASSIMP_EXPORTER_SRCS ${ARGN})
+      SOURCE_GROUP(AssetLib\\${name} FILES ${ARGN})
+    ELSE()
+      SET(ASSIMP_EXPORTERS_DISABLED "${ASSIMP_EXPORTERS_DISABLED} ${name}")
+      add_definitions(-DASSIMP_BUILD_NO_${name}_EXPORTER)
+    ENDIF()
+  ENDMACRO()
+
+endif()
 
 SET(ASSIMP_LOADER_SRCS "")
 SET(ASSIMP_IMPORTERS_ENABLED "") # list of enabled importers
@@ -290,157 +303,162 @@ SET(ASSIMP_EXPORTERS_ENABLED "") # list of enabled exporters
 SET(ASSIMP_EXPORTERS_DISABLED "") # disabled exporters list (used to print)
 
 ADD_ASSIMP_IMPORTER( AMF
-  AMF/AMFImporter.hpp
-  AMF/AMFImporter_Macro.hpp
-  AMF/AMFImporter_Node.hpp
-  AMF/AMFImporter.cpp
-  AMF/AMFImporter_Geometry.cpp
-  AMF/AMFImporter_Material.cpp
-  AMF/AMFImporter_Postprocess.cpp
+  AssetLib/AMF/AMFImporter.hpp
+  AssetLib/AMF/AMFImporter_Node.hpp
+  AssetLib/AMF/AMFImporter.cpp
+  AssetLib/AMF/AMFImporter_Geometry.cpp
+  AssetLib/AMF/AMFImporter_Material.cpp
+  AssetLib/AMF/AMFImporter_Postprocess.cpp
 )
 
 ADD_ASSIMP_IMPORTER( 3DS
-  3DS/3DSConverter.cpp
-  3DS/3DSHelper.h
-  3DS/3DSLoader.cpp
-  3DS/3DSLoader.h
-)
-
-ADD_ASSIMP_EXPORTER( 3DS
-  3DS/3DSExporter.h
-  3DS/3DSExporter.cpp
+  AssetLib/3DS/3DSConverter.cpp
+  AssetLib/3DS/3DSHelper.h
+  AssetLib/3DS/3DSLoader.cpp
+  AssetLib/3DS/3DSLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( AC
-  AC/ACLoader.cpp
-  AC/ACLoader.h
+  AssetLib/AC/ACLoader.cpp
+  AssetLib/AC/ACLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( ASE
-  ASE/ASELoader.cpp
-  ASE/ASELoader.h
-  ASE/ASEParser.cpp
-  ASE/ASEParser.h
+  AssetLib/ASE/ASELoader.cpp
+  AssetLib/ASE/ASELoader.h
+  AssetLib/ASE/ASEParser.cpp
+  AssetLib/ASE/ASEParser.h
 )
 
 ADD_ASSIMP_IMPORTER( ASSBIN
-  Assbin/AssbinLoader.h
-  Assbin/AssbinLoader.cpp
-)
-
-ADD_ASSIMP_EXPORTER( ASSBIN
-  Assbin/AssbinExporter.h
-  Assbin/AssbinExporter.cpp
-)
-
-ADD_ASSIMP_EXPORTER( ASSXML
-  Assxml/AssxmlExporter.h
-  Assxml/AssxmlExporter.cpp
+  AssetLib/Assbin/AssbinLoader.h
+  AssetLib/Assbin/AssbinLoader.cpp
 )
 
 ADD_ASSIMP_IMPORTER( B3D
-  B3D/B3DImporter.cpp
-  B3D/B3DImporter.h
+  AssetLib/B3D/B3DImporter.cpp
+  AssetLib/B3D/B3DImporter.h
 )
 
 ADD_ASSIMP_IMPORTER( BVH
-  BVH/BVHLoader.cpp
-  BVH/BVHLoader.h
+  AssetLib/BVH/BVHLoader.cpp
+  AssetLib/BVH/BVHLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( COLLADA
-  Collada/ColladaHelper.h
-  Collada/ColladaLoader.cpp
-  Collada/ColladaLoader.h
-  Collada/ColladaParser.cpp
-  Collada/ColladaParser.h
-)
-
-ADD_ASSIMP_EXPORTER( COLLADA
-  Collada/ColladaExporter.h
-  Collada/ColladaExporter.cpp
+  AssetLib/Collada/ColladaHelper.cpp
+  AssetLib/Collada/ColladaHelper.h
+  AssetLib/Collada/ColladaLoader.cpp
+  AssetLib/Collada/ColladaLoader.h
+  AssetLib/Collada/ColladaParser.cpp
+  AssetLib/Collada/ColladaParser.h
 )
 
 ADD_ASSIMP_IMPORTER( DXF
-  DXF/DXFLoader.cpp
-  DXF/DXFLoader.h
-  DXF/DXFHelper.h
+  AssetLib/DXF/DXFLoader.cpp
+  AssetLib/DXF/DXFLoader.h
+  AssetLib/DXF/DXFHelper.h
 )
 
 ADD_ASSIMP_IMPORTER( CSM
-  CSM/CSMLoader.cpp
-  CSM/CSMLoader.h
+  AssetLib/CSM/CSMLoader.cpp
+  AssetLib/CSM/CSMLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( HMP
-  HMP/HMPFileData.h
-  HMP/HMPLoader.cpp
-  HMP/HMPLoader.h
-  HMP/HalfLifeFileData.h
+  AssetLib/HMP/HMPFileData.h
+  AssetLib/HMP/HMPLoader.cpp
+  AssetLib/HMP/HMPLoader.h
+  AssetLib/HMP/HalfLifeFileData.h
 )
 
 ADD_ASSIMP_IMPORTER( IRRMESH
-  Irr/IRRMeshLoader.cpp
-  Irr/IRRMeshLoader.h
-  Irr/IRRShared.cpp
-  Irr/IRRShared.h
+  AssetLib/Irr/IRRMeshLoader.cpp
+  AssetLib/Irr/IRRMeshLoader.h
+  AssetLib/Irr/IRRShared.cpp
+  AssetLib/Irr/IRRShared.h
+)
+
+ADD_ASSIMP_IMPORTER( IQM
+  AssetLib/IQM/IQMImporter.cpp
+  AssetLib/IQM/iqm.h
+  AssetLib/IQM/IQMImporter.h
 )
 
 ADD_ASSIMP_IMPORTER( IRR
-  Irr/IRRLoader.cpp
-  Irr/IRRLoader.h
-  Irr/IRRShared.cpp
-  Irr/IRRShared.h
+  AssetLib/Irr/IRRLoader.cpp
+  AssetLib/Irr/IRRLoader.h
+  AssetLib/Irr/IRRShared.cpp
+  AssetLib/Irr/IRRShared.h
 )
 
 ADD_ASSIMP_IMPORTER( LWO
-  LWO/LWOAnimation.cpp
-  LWO/LWOAnimation.h
-  LWO/LWOBLoader.cpp
-  LWO/LWOFileData.h
-  LWO/LWOLoader.cpp
-  LWO/LWOLoader.h
-  LWO/LWOMaterial.cpp
+  AssetLib/LWO/LWOAnimation.cpp
+  AssetLib/LWO/LWOAnimation.h
+  AssetLib/LWO/LWOBLoader.cpp
+  AssetLib/LWO/LWOFileData.h
+  AssetLib/LWO/LWOLoader.cpp
+  AssetLib/LWO/LWOLoader.h
+  AssetLib/LWO/LWOMaterial.cpp
 )
 
 ADD_ASSIMP_IMPORTER( LWS
-  LWS/LWSLoader.cpp
-  LWS/LWSLoader.h
+  AssetLib/LWS/LWSLoader.cpp
+  AssetLib/LWS/LWSLoader.h
+)
+
+ADD_ASSIMP_IMPORTER( M3D
+  AssetLib/M3D/M3DMaterials.h
+  AssetLib/M3D/M3DImporter.h
+  AssetLib/M3D/M3DImporter.cpp
+  AssetLib/M3D/M3DWrapper.h
+  AssetLib/M3D/M3DWrapper.cpp
+  AssetLib/M3D/m3d.h
 )
 
 ADD_ASSIMP_IMPORTER( MD2
-  MD2/MD2FileData.h
-  MD2/MD2Loader.cpp
-  MD2/MD2Loader.h
-  MD2/MD2NormalTable.h
+  AssetLib/MD2/MD2FileData.h
+  AssetLib/MD2/MD2Loader.cpp
+  AssetLib/MD2/MD2Loader.h
+  AssetLib/MD2/MD2NormalTable.h
 )
 
 ADD_ASSIMP_IMPORTER( MD3
-  MD3/MD3FileData.h
-  MD3/MD3Loader.cpp
-  MD3/MD3Loader.h
+  AssetLib/MD3/MD3FileData.h
+  AssetLib/MD3/MD3Loader.cpp
+  AssetLib/MD3/MD3Loader.h
 )
 
 ADD_ASSIMP_IMPORTER( MD5
-  MD5/MD5Loader.cpp
-  MD5/MD5Loader.h
-  MD5/MD5Parser.cpp
-  MD5/MD5Parser.h
+  AssetLib/MD5/MD5Loader.cpp
+  AssetLib/MD5/MD5Loader.h
+  AssetLib/MD5/MD5Parser.cpp
+  AssetLib/MD5/MD5Parser.h
 )
 
 ADD_ASSIMP_IMPORTER( MDC
-  MDC/MDCFileData.h
-  MDC/MDCLoader.cpp
-  MDC/MDCLoader.h
-  MDC/MDCNormalTable.h
+  AssetLib/MDC/MDCFileData.h
+  AssetLib/MDC/MDCLoader.cpp
+  AssetLib/MDC/MDCLoader.h
+  AssetLib/MDC/MDCNormalTable.h
 )
 
 ADD_ASSIMP_IMPORTER( MDL
-  MDL/MDLDefaultColorMap.h
-  MDL/MDLFileData.h
-  MDL/MDLLoader.cpp
-  MDL/MDLLoader.h
-  MDL/MDLMaterialLoader.cpp
+  AssetLib/MDL/MDLDefaultColorMap.h
+  AssetLib/MDL/MDLFileData.h
+  AssetLib/MDL/MDLLoader.cpp
+  AssetLib/MDL/MDLLoader.h
+  AssetLib/MDL/MDLMaterialLoader.cpp
+  AssetLib/MDL/HalfLife/HalfLifeMDLBaseHeader.h
+  AssetLib/MDL/HalfLife/HL1FileData.h
+  AssetLib/MDL/HalfLife/HL1MDLLoader.cpp
+  AssetLib/MDL/HalfLife/HL1MDLLoader.h
+  AssetLib/MDL/HalfLife/HL1ImportDefinitions.h
+  AssetLib/MDL/HalfLife/HL1ImportSettings.h
+  AssetLib/MDL/HalfLife/HL1MeshTrivert.h
+  AssetLib/MDL/HalfLife/LogFunctions.h
+  AssetLib/MDL/HalfLife/UniqueNameGenerator.cpp
+  AssetLib/MDL/HalfLife/UniqueNameGenerator.h
 )
 
 SET( MaterialSystem_SRCS
@@ -450,169 +468,230 @@ SET( MaterialSystem_SRCS
 SOURCE_GROUP( MaterialSystem FILES ${MaterialSystem_SRCS})
 
 ADD_ASSIMP_IMPORTER( NFF
-  NFF/NFFLoader.cpp
-  NFF/NFFLoader.h
+  AssetLib/NFF/NFFLoader.cpp
+  AssetLib/NFF/NFFLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( NDO
-  NDO/NDOLoader.cpp
-  NDO/NDOLoader.h
+  AssetLib/NDO/NDOLoader.cpp
+  AssetLib/NDO/NDOLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( OFF
-  OFF/OFFLoader.cpp
-  OFF/OFFLoader.h
+  AssetLib/OFF/OFFLoader.cpp
+  AssetLib/OFF/OFFLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( OBJ
-  Obj/ObjFileData.h
-  Obj/ObjFileImporter.cpp
-  Obj/ObjFileImporter.h
-  Obj/ObjFileMtlImporter.cpp
-  Obj/ObjFileMtlImporter.h
-  Obj/ObjFileParser.cpp
-  Obj/ObjFileParser.h
-  Obj/ObjTools.h
-)
-
-ADD_ASSIMP_EXPORTER( OBJ
-  Obj/ObjExporter.h
-  Obj/ObjExporter.cpp
+  AssetLib/Obj/ObjFileData.h
+  AssetLib/Obj/ObjFileImporter.cpp
+  AssetLib/Obj/ObjFileImporter.h
+  AssetLib/Obj/ObjFileMtlImporter.cpp
+  AssetLib/Obj/ObjFileMtlImporter.h
+  AssetLib/Obj/ObjFileParser.cpp
+  AssetLib/Obj/ObjFileParser.h
+  AssetLib/Obj/ObjTools.h
 )
 
 ADD_ASSIMP_IMPORTER( OGRE
-  Ogre/OgreImporter.h
-  Ogre/OgreStructs.h
-  Ogre/OgreParsingUtils.h
-  Ogre/OgreBinarySerializer.h
-  Ogre/OgreXmlSerializer.h
-  Ogre/OgreImporter.cpp
-  Ogre/OgreStructs.cpp
-  Ogre/OgreBinarySerializer.cpp
-  Ogre/OgreXmlSerializer.cpp
-  Ogre/OgreMaterial.cpp
+  AssetLib/Ogre/OgreImporter.h
+  AssetLib/Ogre/OgreStructs.h
+  AssetLib/Ogre/OgreParsingUtils.h
+  AssetLib/Ogre/OgreBinarySerializer.h
+  AssetLib/Ogre/OgreXmlSerializer.h
+  AssetLib/Ogre/OgreImporter.cpp
+  AssetLib/Ogre/OgreStructs.cpp
+  AssetLib/Ogre/OgreBinarySerializer.cpp
+  AssetLib/Ogre/OgreXmlSerializer.cpp
+  AssetLib/Ogre/OgreMaterial.cpp
 )
 
 ADD_ASSIMP_IMPORTER( OPENGEX
-  OpenGEX/OpenGEXImporter.cpp
-  OpenGEX/OpenGEXImporter.h
-  OpenGEX/OpenGEXStructs.h
-)
-
-ADD_ASSIMP_EXPORTER( OPENGEX
-  OpenGEX/OpenGEXExporter.cpp
-  OpenGEX/OpenGEXExporter.h
+  AssetLib/OpenGEX/OpenGEXImporter.cpp
+  AssetLib/OpenGEX/OpenGEXImporter.h
+  AssetLib/OpenGEX/OpenGEXStructs.h
 )
 
 ADD_ASSIMP_IMPORTER( PLY
-  Ply/PlyLoader.cpp
-  Ply/PlyLoader.h
-  Ply/PlyParser.cpp
-  Ply/PlyParser.h
-)
-
-ADD_ASSIMP_EXPORTER( PLY
-  Ply/PlyExporter.cpp
-  Ply/PlyExporter.h
+  AssetLib/Ply/PlyLoader.cpp
+  AssetLib/Ply/PlyLoader.h
+  AssetLib/Ply/PlyParser.cpp
+  AssetLib/Ply/PlyParser.h
 )
 
 ADD_ASSIMP_IMPORTER( MS3D
-  MS3D/MS3DLoader.cpp
-  MS3D/MS3DLoader.h
+  AssetLib/MS3D/MS3DLoader.cpp
+  AssetLib/MS3D/MS3DLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( COB
-  COB/COBLoader.cpp
-  COB/COBLoader.h
-  COB/COBScene.h
+  AssetLib/COB/COBLoader.cpp
+  AssetLib/COB/COBLoader.h
+  AssetLib/COB/COBScene.h
 )
 
 ADD_ASSIMP_IMPORTER( BLEND
-  Blender/BlenderLoader.cpp
-  Blender/BlenderLoader.h
-  Blender/BlenderDNA.cpp
-  Blender/BlenderDNA.h
-  Blender/BlenderDNA.inl
-  Blender/BlenderScene.cpp
-  Blender/BlenderScene.h
-  Blender/BlenderSceneGen.h
-  Blender/BlenderIntermediate.h
-  Blender/BlenderModifier.h
-  Blender/BlenderModifier.cpp
-  Blender/BlenderBMesh.h
-  Blender/BlenderBMesh.cpp
-  Blender/BlenderTessellator.h
-  Blender/BlenderTessellator.cpp
-  Blender/BlenderCustomData.h
-  Blender/BlenderCustomData.cpp
+  AssetLib/Blender/BlenderLoader.cpp
+  AssetLib/Blender/BlenderLoader.h
+  AssetLib/Blender/BlenderDNA.cpp
+  AssetLib/Blender/BlenderDNA.h
+  AssetLib/Blender/BlenderDNA.inl
+  AssetLib/Blender/BlenderScene.cpp
+  AssetLib/Blender/BlenderScene.h
+  AssetLib/Blender/BlenderSceneGen.h
+  AssetLib/Blender/BlenderIntermediate.h
+  AssetLib/Blender/BlenderModifier.h
+  AssetLib/Blender/BlenderModifier.cpp
+  AssetLib/Blender/BlenderBMesh.h
+  AssetLib/Blender/BlenderBMesh.cpp
+  AssetLib/Blender/BlenderTessellator.h
+  AssetLib/Blender/BlenderTessellator.cpp
+  AssetLib/Blender/BlenderCustomData.h
+  AssetLib/Blender/BlenderCustomData.cpp
 )
 
 ADD_ASSIMP_IMPORTER( IFC
-  Importer/IFC/IFCLoader.cpp
-  Importer/IFC/IFCLoader.h
-  Importer/IFC/IFCReaderGen1_2x3.cpp
-  Importer/IFC/IFCReaderGen2_2x3.cpp
-  Importer/IFC/IFCReaderGen_2x3.h
-  Importer/IFC/IFCUtil.h
-  Importer/IFC/IFCUtil.cpp
-  Importer/IFC/IFCGeometry.cpp
-  Importer/IFC/IFCMaterial.cpp
-  Importer/IFC/IFCProfile.cpp
-  Importer/IFC/IFCCurve.cpp
-  Importer/IFC/IFCBoolean.cpp
-  Importer/IFC/IFCOpenings.cpp
+  AssetLib/IFC/IFCLoader.cpp
+  AssetLib/IFC/IFCLoader.h
+  AssetLib/IFC/IFCReaderGen1_2x3.cpp
+  AssetLib/IFC/IFCReaderGen2_2x3.cpp
+  AssetLib/IFC/IFCReaderGen_2x3.h
+  AssetLib/IFC/IFCUtil.h
+  AssetLib/IFC/IFCUtil.cpp
+  AssetLib/IFC/IFCGeometry.cpp
+  AssetLib/IFC/IFCMaterial.cpp
+  AssetLib/IFC/IFCProfile.cpp
+  AssetLib/IFC/IFCCurve.cpp
+  AssetLib/IFC/IFCBoolean.cpp
+  AssetLib/IFC/IFCOpenings.cpp
 )
 
 if (ASSIMP_BUILD_IFC_IMPORTER)
   if (MSVC)
     set_source_files_properties(Importer/IFC/IFCReaderGen1_2x3.cpp Importer/IFC/IFCReaderGen2_2x3.cpp PROPERTIES COMPILE_FLAGS "/bigobj")
-  elseif(CMAKE_COMPILER_IS_MINGW)
+  elseif(MINGW)
     set_source_files_properties(Importer/IFC/IFCReaderGen1_2x3.cpp Importer/IFC/IFCReaderGen2_2x3.cpp PROPERTIES COMPILE_FLAGS "-O2 -Wa,-mbig-obj")
   endif()
-endif (ASSIMP_BUILD_IFC_IMPORTER)
+endif ()
 
 ADD_ASSIMP_IMPORTER( XGL
-  XGL/XGLLoader.cpp
-  XGL/XGLLoader.h
+  AssetLib/XGL/XGLLoader.cpp
+  AssetLib/XGL/XGLLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( FBX
-  FBX/FBXImporter.cpp
-  FBX/FBXCompileConfig.h
-  FBX/FBXImporter.h
-  FBX/FBXParser.cpp
-  FBX/FBXParser.h
-  FBX/FBXTokenizer.cpp
-  FBX/FBXTokenizer.h
-  FBX/FBXImportSettings.h
-  FBX/FBXConverter.h
-  FBX/FBXConverter.cpp
-  FBX/FBXUtil.h
-  FBX/FBXUtil.cpp
-  FBX/FBXDocument.h
-  FBX/FBXDocument.cpp
-  FBX/FBXProperties.h
-  FBX/FBXProperties.cpp
-  FBX/FBXMeshGeometry.h
-  FBX/FBXMeshGeometry.cpp
-  FBX/FBXMaterial.cpp
-  FBX/FBXModel.cpp
-  FBX/FBXAnimation.cpp
-  FBX/FBXNodeAttribute.cpp
-  FBX/FBXDeformer.cpp
-  FBX/FBXBinaryTokenizer.cpp
-  FBX/FBXDocumentUtil.cpp
-  FBX/FBXCommon.h
+  AssetLib/FBX/FBXImporter.cpp
+  AssetLib/FBX/FBXCompileConfig.h
+  AssetLib/FBX/FBXImporter.h
+  AssetLib/FBX/FBXParser.cpp
+  AssetLib/FBX/FBXParser.h
+  AssetLib/FBX/FBXTokenizer.cpp
+  AssetLib/FBX/FBXTokenizer.h
+  AssetLib/FBX/FBXImportSettings.h
+  AssetLib/FBX/FBXConverter.h
+  AssetLib/FBX/FBXConverter.cpp
+  AssetLib/FBX/FBXUtil.h
+  AssetLib/FBX/FBXUtil.cpp
+  AssetLib/FBX/FBXDocument.h
+  AssetLib/FBX/FBXDocument.cpp
+  AssetLib/FBX/FBXProperties.h
+  AssetLib/FBX/FBXProperties.cpp
+  AssetLib/FBX/FBXMeshGeometry.h
+  AssetLib/FBX/FBXMeshGeometry.cpp
+  AssetLib/FBX/FBXMaterial.cpp
+  AssetLib/FBX/FBXModel.cpp
+  AssetLib/FBX/FBXAnimation.cpp
+  AssetLib/FBX/FBXNodeAttribute.cpp
+  AssetLib/FBX/FBXDeformer.cpp
+  AssetLib/FBX/FBXBinaryTokenizer.cpp
+  AssetLib/FBX/FBXDocumentUtil.cpp
+  AssetLib/FBX/FBXCommon.h
 )
 
-ADD_ASSIMP_EXPORTER( FBX
-  FBX/FBXExporter.h
-  FBX/FBXExporter.cpp
-  FBX/FBXExportNode.h
-  FBX/FBXExportNode.cpp
-  FBX/FBXExportProperty.h
-  FBX/FBXExportProperty.cpp
-)
+if (NOT ASSIMP_NO_EXPORT)
+
+  ADD_ASSIMP_EXPORTER( OBJ
+    AssetLib/Obj/ObjExporter.h
+    AssetLib/Obj/ObjExporter.cpp)
+
+  ADD_ASSIMP_EXPORTER( OPENGEX
+    AssetLib/OpenGEX/OpenGEXExporter.cpp
+    AssetLib/OpenGEX/OpenGEXExporter.h)
+
+  ADD_ASSIMP_EXPORTER( PLY
+    AssetLib/Ply/PlyExporter.cpp
+    AssetLib/Ply/PlyExporter.h)
+
+  ADD_ASSIMP_EXPORTER( 3DS
+    AssetLib/3DS/3DSExporter.h
+    AssetLib/3DS/3DSExporter.cpp)
+
+  ADD_ASSIMP_EXPORTER( ASSBIN
+    AssetLib/Assbin/AssbinExporter.h
+    AssetLib/Assbin/AssbinExporter.cpp
+    AssetLib/Assbin/AssbinFileWriter.h
+    AssetLib/Assbin/AssbinFileWriter.cpp)
+
+  ADD_ASSIMP_EXPORTER( ASSXML
+    AssetLib/Assxml/AssxmlExporter.h
+    AssetLib/Assxml/AssxmlExporter.cpp
+    AssetLib/Assxml/AssxmlFileWriter.h
+    AssetLib/Assxml/AssxmlFileWriter.cpp)
+
+  ADD_ASSIMP_EXPORTER(M3D
+    AssetLib/M3D/M3DExporter.h
+    AssetLib/M3D/M3DExporter.cpp)
+
+  ADD_ASSIMP_EXPORTER(COLLADA
+    AssetLib/Collada/ColladaExporter.h
+    AssetLib/Collada/ColladaExporter.cpp)
+
+  ADD_ASSIMP_EXPORTER( FBX
+    AssetLib/FBX/FBXExporter.h
+    AssetLib/FBX/FBXExporter.cpp
+    AssetLib/FBX/FBXExportNode.h
+    AssetLib/FBX/FBXExportNode.cpp
+    AssetLib/FBX/FBXExportProperty.h
+    AssetLib/FBX/FBXExportProperty.cpp)
+
+  ADD_ASSIMP_EXPORTER( STL
+    AssetLib/STL/STLExporter.h
+    AssetLib/STL/STLExporter.cpp)
+
+  ADD_ASSIMP_EXPORTER( X
+    AssetLib/X/XFileExporter.h
+    AssetLib/X/XFileExporter.cpp)
+
+  ADD_ASSIMP_EXPORTER( X3D
+    AssetLib/X3D/X3DExporter.cpp
+    AssetLib/X3D/X3DExporter.hpp)
+
+  ADD_ASSIMP_EXPORTER( GLTF
+    AssetLib/glTF/glTFExporter.h
+    AssetLib/glTF/glTFExporter.cpp
+    AssetLib/glTF2/glTF2Exporter.h
+    AssetLib/glTF2/glTF2Exporter.cpp)
+
+  ADD_ASSIMP_EXPORTER( 3MF
+    AssetLib/3MF/D3MFExporter.h
+    AssetLib/3MF/D3MFExporter.cpp)
+
+  ADD_ASSIMP_EXPORTER( PBRT
+    Pbrt/PbrtExporter.h
+    Pbrt/PbrtExporter.cpp)
+
+  ADD_ASSIMP_EXPORTER( ASSJSON
+    AssetLib/Assjson/cencode.c
+    AssetLib/Assjson/cencode.h
+    AssetLib/Assjson/json_exporter.cpp
+    AssetLib/Assjson/mesh_splitter.cpp
+    AssetLib/Assjson/mesh_splitter.h)
+
+  ADD_ASSIMP_EXPORTER( STEP
+    AssetLib/Step/StepExporter.h
+    AssetLib/Step/StepExporter.cpp)
+
+endif()
 
 SET( PostProcessing_SRCS
   PostProcessing/CalcTangentsProcess.cpp
@@ -671,153 +750,123 @@ SET( PostProcessing_SRCS
   PostProcessing/MakeVerboseFormat.h
   PostProcessing/ScaleProcess.cpp
   PostProcessing/ScaleProcess.h
+  PostProcessing/ArmaturePopulate.cpp
+  PostProcessing/ArmaturePopulate.h
   PostProcessing/GenBoundingBoxesProcess.cpp
   PostProcessing/GenBoundingBoxesProcess.h
+  PostProcessing/SplitByBoneCountProcess.cpp
+  PostProcessing/SplitByBoneCountProcess.h
 )
 SOURCE_GROUP( PostProcessing FILES ${PostProcessing_SRCS})
 
-SET( IrrXML_SRCS ${HEADER_PATH}/irrXMLWrapper.h )
-SOURCE_GROUP( IrrXML FILES ${IrrXML_SRCS})
-
 ADD_ASSIMP_IMPORTER( Q3D
-  Q3D/Q3DLoader.cpp
-  Q3D/Q3DLoader.h
+  AssetLib/Q3D/Q3DLoader.cpp
+  AssetLib/Q3D/Q3DLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( Q3BSP
-  Q3BSP/Q3BSPFileData.h
-  Q3BSP/Q3BSPFileParser.h
-  Q3BSP/Q3BSPFileParser.cpp
-  Q3BSP/Q3BSPFileImporter.h
-  Q3BSP/Q3BSPFileImporter.cpp
+  AssetLib/Q3BSP/Q3BSPFileData.h
+  AssetLib/Q3BSP/Q3BSPFileParser.h
+  AssetLib/Q3BSP/Q3BSPFileParser.cpp
+  AssetLib/Q3BSP/Q3BSPFileImporter.h
+  AssetLib/Q3BSP/Q3BSPFileImporter.cpp
 )
 
 ADD_ASSIMP_IMPORTER( RAW
-  Raw/RawLoader.cpp
-  Raw/RawLoader.h
+  AssetLib/Raw/RawLoader.cpp
+  AssetLib/Raw/RawLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( SIB
-  SIB/SIBImporter.cpp
-  SIB/SIBImporter.h
+  AssetLib/SIB/SIBImporter.cpp
+  AssetLib/SIB/SIBImporter.h
 )
 
 ADD_ASSIMP_IMPORTER( SMD
-  SMD/SMDLoader.cpp
-  SMD/SMDLoader.h
+  AssetLib/SMD/SMDLoader.cpp
+  AssetLib/SMD/SMDLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( STL
-  STL/STLLoader.cpp
-  STL/STLLoader.h
-)
-
-ADD_ASSIMP_EXPORTER( STL
-  STL/STLExporter.h
-  STL/STLExporter.cpp
+  AssetLib/STL/STLLoader.cpp
+  AssetLib/STL/STLLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( TERRAGEN
-  Terragen/TerragenLoader.cpp
-  Terragen/TerragenLoader.h
+  AssetLib/Terragen/TerragenLoader.cpp
+  AssetLib/Terragen/TerragenLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( 3D
-  Unreal/UnrealLoader.cpp
-  Unreal/UnrealLoader.h
+  AssetLib/Unreal/UnrealLoader.cpp
+  AssetLib/Unreal/UnrealLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( X
-  X/XFileHelper.h
-  X/XFileImporter.cpp
-  X/XFileImporter.h
-  X/XFileParser.cpp
-  X/XFileParser.h
-)
-
-ADD_ASSIMP_EXPORTER( X
-  X/XFileExporter.h
-  X/XFileExporter.cpp
+  AssetLib/X/XFileHelper.h
+  AssetLib/X/XFileImporter.cpp
+  AssetLib/X/XFileImporter.h
+  AssetLib/X/XFileParser.cpp
+  AssetLib/X/XFileParser.h
 )
 
 ADD_ASSIMP_IMPORTER( X3D
-  X3D/X3DImporter.cpp
-  X3D/X3DImporter.hpp
-  X3D/X3DImporter_Geometry2D.cpp
-  X3D/X3DImporter_Geometry3D.cpp
-  X3D/X3DImporter_Group.cpp
-  X3D/X3DImporter_Light.cpp
-  X3D/X3DImporter_Macro.hpp
-  X3D/X3DImporter_Metadata.cpp
-  X3D/X3DImporter_Networking.cpp
-  X3D/X3DImporter_Node.hpp
-  X3D/X3DImporter_Postprocess.cpp
-  X3D/X3DImporter_Rendering.cpp
-  X3D/X3DImporter_Shape.cpp
-  X3D/X3DImporter_Texturing.cpp
-  X3D/FIReader.hpp
-  X3D/FIReader.cpp
-  X3D/X3DVocabulary.cpp
-)
-
-ADD_ASSIMP_EXPORTER( X3D
-  X3D/X3DExporter.cpp
-  X3D/X3DExporter.hpp
+  AssetLib/X3D/X3DImporter.cpp
+  AssetLib/X3D/X3DImporter_Geometry2D.cpp
+  AssetLib/X3D/X3DImporter_Geometry3D.cpp
+  AssetLib/X3D/X3DImporter_Group.cpp
+  AssetLib/X3D/X3DImporter_Light.cpp
+  AssetLib/X3D/X3DImporter_Metadata.cpp
+  AssetLib/X3D/X3DImporter_Networking.cpp
+  AssetLib/X3D/X3DImporter_Postprocess.cpp
+  AssetLib/X3D/X3DImporter_Rendering.cpp
+  AssetLib/X3D/X3DImporter_Shape.cpp
+  AssetLib/X3D/X3DImporter_Texturing.cpp
+  AssetLib/X3D/X3DImporter.hpp
+  AssetLib/X3D/X3DImporter_Macro.hpp
+  AssetLib/X3D/X3DImporter_Node.hpp
+  AssetLib/X3D/X3DGeoHelper.cpp
+  AssetLib/X3D/X3DGeoHelper.h
+  AssetLib/X3D/X3DXmlHelper.cpp
+  AssetLib/X3D/X3DXmlHelper.h
 )
 
 ADD_ASSIMP_IMPORTER( GLTF
-  glTF/glTFCommon.h
-  glTF/glTFCommon.cpp
-  glTF/glTFAsset.h
-  glTF/glTFAsset.inl
-  glTF/glTFAssetWriter.h
-  glTF/glTFAssetWriter.inl
-  glTF/glTFImporter.cpp
-  glTF/glTFImporter.h
-  glTF2/glTF2Asset.h
-  glTF2/glTF2Asset.inl
-  glTF2/glTF2AssetWriter.h
-  glTF2/glTF2AssetWriter.inl
-  glTF2/glTF2Importer.cpp
-  glTF2/glTF2Importer.h
+  AssetLib/glTF/glTFCommon.h
+  AssetLib/glTF/glTFCommon.cpp
+  AssetLib/glTF/glTFAsset.h
+  AssetLib/glTF/glTFAsset.inl
+  AssetLib/glTF/glTFAssetWriter.h
+  AssetLib/glTF/glTFAssetWriter.inl
+  AssetLib/glTF/glTFImporter.cpp
+  AssetLib/glTF/glTFImporter.h
+  AssetLib/glTF2/glTF2Asset.h
+  AssetLib/glTF2/glTF2Asset.inl
+  AssetLib/glTF2/glTF2AssetWriter.h
+  AssetLib/glTF2/glTF2AssetWriter.inl
+  AssetLib/glTF2/glTF2Importer.cpp
+  AssetLib/glTF2/glTF2Importer.h
 )
 
-ADD_ASSIMP_EXPORTER( GLTF
-  glTF/glTFExporter.h
-  glTF/glTFExporter.cpp
-  glTF2/glTF2Exporter.h
-  glTF2/glTF2Exporter.cpp
-)
-
-ADD_ASSIMP_IMPORTER( 3MF
-  3MF/D3MFImporter.h
-  3MF/D3MFImporter.cpp
-  3MF/D3MFOpcPackage.h
-  3MF/D3MFOpcPackage.cpp
-  3MF/3MFXmlTags.h
-)
-
-ADD_ASSIMP_EXPORTER( 3MF
-  3MF/D3MFExporter.h
-  3MF/D3MFExporter.cpp
+ADD_ASSIMP_IMPORTER(3MF
+  AssetLib/3MF/3MFTypes.h
+  AssetLib/3MF/XmlSerializer.h
+  AssetLib/3MF/XmlSerializer.cpp
+  AssetLib/3MF/D3MFImporter.h
+  AssetLib/3MF/D3MFImporter.cpp
+  AssetLib/3MF/D3MFOpcPackage.h
+  AssetLib/3MF/D3MFOpcPackage.cpp
+  AssetLib/3MF/3MFXmlTags.h
 )
 
 ADD_ASSIMP_IMPORTER( MMD
-  MMD/MMDCpp14.h
-  MMD/MMDImporter.cpp
-  MMD/MMDImporter.h
-  MMD/MMDPmdParser.h
-  MMD/MMDPmxParser.h
-  MMD/MMDPmxParser.cpp
-  MMD/MMDVmdParser.h
-)
-
-ADD_ASSIMP_EXPORTER( ASSJSON
-  Assjson/cencode.c
-  Assjson/cencode.h
-  Assjson/json_exporter.cpp
-  Assjson/mesh_splitter.cpp
-  Assjson/mesh_splitter.h
+  AssetLib/MMD/MMDCpp14.h
+  AssetLib/MMD/MMDImporter.cpp
+  AssetLib/MMD/MMDImporter.h
+  AssetLib/MMD/MMDPmdParser.h
+  AssetLib/MMD/MMDPmxParser.h
+  AssetLib/MMD/MMDPmxParser.cpp
+  AssetLib/MMD/MMDVmdParser.h
 )
 
 # Workaround for issue #2406 - force problematic large file to be optimized to prevent string table overflow error
@@ -825,28 +874,13 @@ ADD_ASSIMP_EXPORTER( ASSJSON
 # optimizations that take up extra space. Given that the issue is a string table overflowing, -Os seemed appropriate
 # Also, I'm not positive if both link & compile flags are needed, but this hopefully ensures that the issue should not
 # recur for edge cases such as static builds.
-if ((CMAKE_COMPILER_IS_MINGW) AND (CMAKE_BUILD_TYPE MATCHES Debug))
+if ((MINGW) AND (CMAKE_BUILD_TYPE MATCHES Debug))
   message("-- Applying MinGW StepFileGen1.cpp Debug Workaround")
   SET_SOURCE_FILES_PROPERTIES(Importer/StepFile/StepFileGen1.cpp PROPERTIES COMPILE_FLAGS -Os )
   SET_SOURCE_FILES_PROPERTIES(Importer/StepFile/StepFileGen1.cpp PROPERTIES LINK_FLAGS -Os )
   SET_SOURCE_FILES_PROPERTIES(Importer/StepFile/StepFileGen1.cpp PROPERTIES STATIC_LIBRARY_FLAGS -Os )
 endif()
 
-ADD_ASSIMP_IMPORTER( STEP
-    Step/STEPFile.h
-    Importer/StepFile/StepFileImporter.h
-    Importer/StepFile/StepFileImporter.cpp
-    Importer/StepFile/StepFileGen1.cpp
-    Importer/StepFile/StepFileGen2.cpp
-    Importer/StepFile/StepFileGen3.cpp
-    Importer/StepFile/StepReaderGen.h
-)
-
-ADD_ASSIMP_EXPORTER( STEP
-    Step/StepExporter.h
-    Step/StepExporter.cpp
-)
-
 if ((NOT ASSIMP_NO_EXPORT) OR (NOT ASSIMP_EXPORTERS_ENABLED STREQUAL ""))
 	SET( Exporter_SRCS
 	  Common/Exporter.cpp
@@ -861,39 +895,44 @@ SET( Extra_SRCS
 )
 SOURCE_GROUP( Extra FILES ${Extra_SRCS})
 
-# irrXML
-IF(HUNTER_ENABLED)
-  hunter_add_package(irrXML)
-  find_package(irrXML CONFIG REQUIRED)
-ELSE(HUNTER_ENABLED)
-  # irrXML already included in contrib directory by parent CMakeLists.txt.
-ENDIF(HUNTER_ENABLED)
+# pugixml
+IF(ASSIMP_HUNTER_ENABLED)
+  hunter_add_package(pugixml)
+  find_package(pugixml CONFIG REQUIRED)
+ELSE()
+  SET( Pugixml_SRCS
+    ../contrib/pugixml/src/pugiconfig.hpp
+    ../contrib/pugixml/src/pugixml.hpp
+  )
+  INCLUDE_DIRECTORIES("../contrib/pugixml/src")
+  SOURCE_GROUP( Contrib\\Pugixml FILES ${Pugixml_SRCS})
+ENDIF()
 
 # utf8
-IF(HUNTER_ENABLED)
+IF(ASSIMP_HUNTER_ENABLED)
   hunter_add_package(utf8)
-  find_package(utf8 CONFIG REQUIRED)
-ELSE(HUNTER_ENABLED)
+  find_package(utf8cpp CONFIG REQUIRED)
+ELSE()
   # utf8 is header-only, so Assimp doesn't need to do anything.
-ENDIF(HUNTER_ENABLED)
+ENDIF()
 
 # polyclipping
-IF(HUNTER_ENABLED)
+IF(ASSIMP_HUNTER_ENABLED)
   hunter_add_package(polyclipping)
   find_package(polyclipping CONFIG REQUIRED)
-ELSE(HUNTER_ENABLED)
+ELSE()
   SET( Clipper_SRCS
     ../contrib/clipper/clipper.hpp
     ../contrib/clipper/clipper.cpp
   )
   SOURCE_GROUP( Contrib\\Clipper FILES ${Clipper_SRCS})
-ENDIF(HUNTER_ENABLED)
+ENDIF()
 
 # poly2tri
-IF(HUNTER_ENABLED)
+IF(ASSIMP_HUNTER_ENABLED)
   hunter_add_package(poly2tri)
   find_package(poly2tri CONFIG REQUIRED)
-ELSE(HUNTER_ENABLED)
+ELSE()
   SET( Poly2Tri_SRCS
     ../contrib/poly2tri/poly2tri/common/shapes.cc
     ../contrib/poly2tri/poly2tri/common/shapes.h
@@ -908,14 +947,15 @@ ELSE(HUNTER_ENABLED)
     ../contrib/poly2tri/poly2tri/sweep/sweep_context.h
   )
   SOURCE_GROUP( Contrib\\Poly2Tri FILES ${Poly2Tri_SRCS})
-ENDIF(HUNTER_ENABLED)
+ENDIF()
 
 # minizip/unzip
-IF(HUNTER_ENABLED)
+IF(ASSIMP_HUNTER_ENABLED)
   hunter_add_package(minizip)
   find_package(minizip CONFIG REQUIRED)
-ELSE(HUNTER_ENABLED)
+ELSE()
   SET( unzip_SRCS
+    ../contrib/unzip/crypt.c
     ../contrib/unzip/crypt.h
     ../contrib/unzip/ioapi.c
     ../contrib/unzip/ioapi.h
@@ -923,34 +963,37 @@ ELSE(HUNTER_ENABLED)
     ../contrib/unzip/unzip.h
   )
   SOURCE_GROUP(Contrib\\unzip FILES ${unzip_SRCS})
-ENDIF(HUNTER_ENABLED)
+ENDIF()
 
 # zip (https://github.com/kuba--/zip)
-IF(HUNTER_ENABLED)
-  hunter_add_package(zip)
-  find_package(zip CONFIG REQUIRED)
-ELSE(HUNTER_ENABLED)
-  SET( ziplib_SRCS
-    ../contrib/zip/src/miniz.h
-    ../contrib/zip/src/zip.c
-    ../contrib/zip/src/zip.h
-  )
+separate_arguments(ASSIMP_EXPORTERS_LIST UNIX_COMMAND ${ASSIMP_EXPORTERS_ENABLED})
+IF(3MF IN_LIST ASSIMP_EXPORTERS_LIST)
+  IF(ASSIMP_HUNTER_ENABLED)
+    hunter_add_package(zip)
+    find_package(zip CONFIG REQUIRED)
+  ELSE()
+    SET( ziplib_SRCS
+      ../contrib/zip/src/miniz.h
+      ../contrib/zip/src/zip.c
+      ../contrib/zip/src/zip.h
+    )
 
-  # TODO if cmake required version has been updated to >3.12.0, collapse this to the second case only
-  if(${CMAKE_VERSION} VERSION_LESS "3.12.0")
-  	add_definitions(-DMINIZ_USE_UNALIGNED_LOADS_AND_STORES=0)
-  else()
-  	add_compile_definitions(MINIZ_USE_UNALIGNED_LOADS_AND_STORES=0)
-  endif()
+    # TODO if cmake required version has been updated to >3.12.0, collapse this to the second case only
+    if(${CMAKE_VERSION} VERSION_LESS "3.12.0")
+      add_definitions(-DMINIZ_USE_UNALIGNED_LOADS_AND_STORES=0)
+    else()
+      add_compile_definitions(MINIZ_USE_UNALIGNED_LOADS_AND_STORES=0)
+    endif()
 
-  SOURCE_GROUP( ziplib FILES ${ziplib_SRCS} )
-ENDIF(HUNTER_ENABLED)
+    SOURCE_GROUP( ziplib FILES ${ziplib_SRCS} )
+  ENDIF()
+ENDIF()
 
 # openddlparser
-IF(HUNTER_ENABLED)
+IF(ASSIMP_HUNTER_ENABLED)
   hunter_add_package(openddlparser)
   find_package(openddlparser CONFIG REQUIRED)
-ELSE(HUNTER_ENABLED)
+ELSE()
   SET ( openddl_parser_SRCS
     ../contrib/openddlparser/code/OpenDDLParser.cpp
     ../contrib/openddlparser/code/DDLNode.cpp
@@ -967,12 +1010,12 @@ ELSE(HUNTER_ENABLED)
     ../contrib/openddlparser/include/openddlparser/Value.h
   )
   SOURCE_GROUP( Contrib\\openddl_parser FILES ${openddl_parser_SRCS})
-ENDIF(HUNTER_ENABLED)
+ENDIF()
 
 # Open3DGC
-IF(HUNTER_ENABLED)
+IF(ASSIMP_HUNTER_ENABLED)
   # Nothing to do, not available in Hunter yet.
-ELSE(HUNTER_ENABLED)
+ELSE()
   SET ( open3dgc_SRCS
     ../contrib/Open3DGC/o3dgcAdjacencyInfo.h
     ../contrib/Open3DGC/o3dgcArithmeticCodec.cpp
@@ -1005,13 +1048,13 @@ ELSE(HUNTER_ENABLED)
     ../contrib/Open3DGC/o3dgcVector.inl
   )
   SOURCE_GROUP( Contrib\\open3dgc FILES ${open3dgc_SRCS})
-ENDIF(HUNTER_ENABLED)
+ENDIF()
 
 # Check dependencies for glTF importer with Open3DGC-compression.
 # RT-extensions is used in "contrib/Open3DGC/o3dgcTimer.h" for collecting statistics. Pointed file
 # has implementation for different platforms: WIN32, __MACH__ and other ("else" block).
 FIND_PACKAGE(RT QUIET)
-IF (NOT HUNTER_ENABLED AND (RT_FOUND OR MSVC))
+IF (NOT ASSIMP_HUNTER_ENABLED AND (RT_FOUND OR WIN32))
   SET( ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC 1 )
   ADD_DEFINITIONS( -DASSIMP_IMPORTER_GLTF_USE_OPEN3DGC=1 )
 ELSE ()
@@ -1021,43 +1064,63 @@ ELSE ()
 ENDIF ()
 
 # RapidJSON
-IF(HUNTER_ENABLED)
+IF(ASSIMP_HUNTER_ENABLED)
   hunter_add_package(RapidJSON)
   find_package(RapidJSON CONFIG REQUIRED)
-ELSE(HUNTER_ENABLED)
-  INCLUDE_DIRECTORIES( "../contrib/rapidjson/include" )
-  INCLUDE_DIRECTORIES( "../contrib" )
-ENDIF(HUNTER_ENABLED)
+ELSE()
+  INCLUDE_DIRECTORIES("../contrib/rapidjson/include")
+  ADD_DEFINITIONS( -DRAPIDJSON_HAS_STDSTRING=1)
+  option( ASSIMP_RAPIDJSON_NO_MEMBER_ITERATOR "Suppress rapidjson warning on MSVC (NOTE: breaks android build)" ON )
+  if(ASSIMP_RAPIDJSON_NO_MEMBER_ITERATOR)
+    ADD_DEFINITIONS( -DRAPIDJSON_NOMEMBERITERATORCLASS )
+  endif()
+ENDIF()
+
+# stb
+IF(ASSIMP_HUNTER_ENABLED)
+  hunter_add_package(stb)
+  find_package(stb CONFIG REQUIRED)
+ELSE()
+  SET( stb_SRCS
+    ../contrib/stb/stb_image.h
+  )
+  INCLUDE_DIRECTORIES("../contrib")
+  SOURCE_GROUP( Contrib\\stb FILES ${stb_SRCS})
+ENDIF()
 
 # VC2010 fixes
 if(MSVC10)
   option( VC10_STDINT_FIX "Fix for VC10 Compiler regarding pstdint.h redefinition errors" OFF )
   if( VC10_STDINT_FIX )
     ADD_DEFINITIONS( -D_STDINT )
-  endif( VC10_STDINT_FIX )
-endif(MSVC10)
+  endif()
+endif()
 
 ADD_DEFINITIONS( -DASSIMP_BUILD_DLL_EXPORT )
 
-if ( MSVC )
+IF( MSVC OR "${CMAKE_CXX_SIMULATE_ID}" MATCHES "MSVC") # clang with MSVC ABI
   ADD_DEFINITIONS( -D_SCL_SECURE_NO_WARNINGS )
   ADD_DEFINITIONS( -D_CRT_SECURE_NO_WARNINGS )
-endif ( MSVC )
+endif ()
 
-IF(NOT HUNTER_ENABLED)
+IF(NOT ASSIMP_HUNTER_ENABLED)
   if (UNZIP_FOUND)
     SET (unzip_compile_SRCS "")
-  else (UNZIP_FOUND)
+  else ()
     SET (unzip_compile_SRCS ${unzip_SRCS})
     INCLUDE_DIRECTORIES( "../contrib/unzip/" )
-  endif (UNZIP_FOUND)
-ENDIF(NOT HUNTER_ENABLED)
+  endif ()
+ENDIF()
 
 MESSAGE(STATUS "Enabled importer formats:${ASSIMP_IMPORTERS_ENABLED}")
 MESSAGE(STATUS "Disabled importer formats:${ASSIMP_IMPORTERS_DISABLED}")
 
-MESSAGE(STATUS "Enabled exporter formats:${ASSIMP_EXPORTERS_ENABLED}")
-MESSAGE(STATUS "Disabled exporter formats:${ASSIMP_EXPORTERS_DISABLED}")
+if (NOT ASSIMP_NO_EXPORT)
+  MESSAGE(STATUS "Enabled exporter formats:${ASSIMP_EXPORTERS_ENABLED}")
+  MESSAGE(STATUS "Disabled exporter formats:${ASSIMP_EXPORTERS_DISABLED}")
+endif()
+
+SOURCE_GROUP( include\\assimp    FILES ${PUBLIC_HEADERS} )
 
 SET( assimp_src
   # Assimp Files
@@ -1076,13 +1139,14 @@ SET( assimp_src
   ${ASSIMP_EXPORTER_SRCS}
 
   # Third-party libraries
-  ${IrrXML_SRCS}
   ${unzip_compile_SRCS}
   ${Poly2Tri_SRCS}
   ${Clipper_SRCS}
   ${openddl_parser_SRCS}
   ${open3dgc_SRCS}
   ${ziplib_SRCS}
+  ${Pugixml_SRCS}
+  ${stb_SRCS}
   # Necessary to show the headers in the project when using the VC++ generator:
 
   ${PUBLIC_HEADERS}
@@ -1090,55 +1154,82 @@ SET( assimp_src
 )
 ADD_DEFINITIONS( -DOPENDDLPARSER_BUILD )
 
-IF(NOT HUNTER_ENABLED)
+IF(NOT ASSIMP_HUNTER_ENABLED)
   INCLUDE_DIRECTORIES(
       ${IRRXML_INCLUDE_DIR}
       ../contrib/openddlparser/include
   )
-ENDIF(NOT HUNTER_ENABLED)
+ENDIF()
 
 IF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
   SET( assimp_src ${assimp_src} ${C4D_SRCS})
   INCLUDE_DIRECTORIES(${C4D_INCLUDES})
-ENDIF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
+ENDIF ()
+
+IF (ASSIMP_BUILD_DRACO)
+  INCLUDE_DIRECTORIES(${draco_INCLUDE_DIRS})
+  ADD_DEFINITIONS( -DASSIMP_ENABLE_DRACO )
+ENDIF()
 
 ADD_LIBRARY( assimp ${assimp_src} )
 ADD_LIBRARY(assimp::assimp ALIAS assimp)
 
+TARGET_USE_COMMON_OUTPUT_DIRECTORY(assimp)
+
+# enable warnings as errors ########################################
+IF (MSVC)
+  TARGET_COMPILE_OPTIONS(assimp PRIVATE /WX)
+ELSE()
+  TARGET_COMPILE_OPTIONS(assimp PRIVATE -Werror)
+ENDIF()
+
+# adds C_FLAGS required to compile zip.c on old GCC 4.x compiler
+TARGET_COMPILE_FEATURES(assimp PRIVATE c_std_99)
+
 TARGET_INCLUDE_DIRECTORIES ( assimp PUBLIC
   $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../include>
   $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/../include>
-  $<INSTALL_INTERFACE:include>
+  $<INSTALL_INTERFACE:${ASSIMP_INCLUDE_INSTALL_DIR}>
 )
 
-IF(HUNTER_ENABLED)
+IF(ASSIMP_HUNTER_ENABLED)
   TARGET_LINK_LIBRARIES(assimp
       PUBLIC
       polyclipping::polyclipping
-      irrXML::irrXML
       openddlparser::openddl_parser
       poly2tri::poly2tri
       minizip::minizip
       ZLIB::zlib
       RapidJSON::rapidjson
-      utf8::utf8
-      zip::zip
+      utf8cpp
+      pugixml
+      stb::stb
   )
-ELSE(HUNTER_ENABLED)
-  TARGET_LINK_LIBRARIES(assimp ${ZLIB_LIBRARIES} ${OPENDDL_PARSER_LIBRARIES} ${IRRXML_LIBRARY} )
-ENDIF(HUNTER_ENABLED)
+  if(TARGET zip::zip)
+    target_link_libraries(assimp PUBLIC zip::zip)
+  endif()
+
+  if (ASSIMP_BUILD_DRACO)
+    target_link_libraries(assimp PUBLIC ${draco_LIBRARIES})
+  endif()
+ELSE()
+  TARGET_LINK_LIBRARIES(assimp ${ZLIB_LIBRARIES} ${OPENDDL_PARSER_LIBRARIES})
+  if (ASSIMP_BUILD_DRACO)
+    target_link_libraries(assimp ${draco_LIBRARIES})
+  endif()
+ENDIF()
 
 if(ASSIMP_ANDROID_JNIIOSYSTEM)
   set(ASSIMP_ANDROID_JNIIOSYSTEM_PATH port/AndroidJNI)
   add_subdirectory(../${ASSIMP_ANDROID_JNIIOSYSTEM_PATH}/ ../${ASSIMP_ANDROID_JNIIOSYSTEM_PATH}/)
   target_link_libraries(assimp android_jniiosystem)
-endif(ASSIMP_ANDROID_JNIIOSYSTEM)
+endif()
 
 IF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
   TARGET_LINK_LIBRARIES(assimp optimized ${C4D_RELEASE_LIBRARIES})
   TARGET_LINK_LIBRARIES(assimp debug ${C4D_DEBUG_LIBRARIES})
   TARGET_LINK_LIBRARIES(assimp ${C4D_EXTRA_LIBRARIES})
-ENDIF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
+ENDIF ()
 
 if( MSVC )
   # in order to prevent DLL hell, each of the DLLs have to be suffixed with the major version and msvc prefix
@@ -1175,20 +1266,22 @@ endif()
 if (${CMAKE_SYSTEM_NAME} MATCHES "WindowsStore")
     target_compile_definitions(assimp PUBLIC WindowsStore)
     TARGET_LINK_LIBRARIES(assimp advapi32)
-    #set(WindowsStore TRUE)
 endif()
+
 SET_TARGET_PROPERTIES( assimp PROPERTIES
   VERSION ${ASSIMP_VERSION}
   SOVERSION ${ASSIMP_SOVERSION} # use full version
   OUTPUT_NAME assimp${LIBRARY_SUFFIX}
 )
 
-if (APPLE)
-  SET_TARGET_PROPERTIES( assimp PROPERTIES
-    INSTALL_NAME_DIR "${CMAKE_INSTALL_PREFIX}/${ASSIMP_LIB_INSTALL_DIR}"
+if (WIN32 AND CMAKE_COMPILER_IS_GNUCXX AND BUILD_SHARED_LIBS)
+  set_target_properties(assimp PROPERTIES
+    SUFFIX "-${ASSIMP_SOVERSION}${CMAKE_SHARED_LIBRARY_SUFFIX}"
   )
+endif()
 
-  if (BUILD_FRAMEWORK)
+if (APPLE)
+  if (ASSIMP_BUILD_FRAMEWORK)
     SET_TARGET_PROPERTIES( assimp PROPERTIES
       FRAMEWORK TRUE
       FRAMEWORK_VERSION C
@@ -1200,45 +1293,37 @@ if (APPLE)
     # add ./Compiler/*.h to assimp.framework via copy command
     ADD_CUSTOM_COMMAND(TARGET assimp POST_BUILD
       COMMAND "${CMAKE_COMMAND}" -E copy_directory
-         "../${HEADER_PATH}/Compiler"
+         "${HEADER_PATH}/Compiler"
          assimp.framework/Headers/Compiler
       COMMENT "Copying public ./Compiler/ header files to framework bundle's Headers/Compiler/")
-  ENDIF(BUILD_FRAMEWORK)
-ENDIF(APPLE)
+  ENDIF()
+ENDIF()
 
 # Build against external unzip, or add ../contrib/unzip so
 # assimp can #include "unzip.h"
-IF(NOT HUNTER_ENABLED)
+IF(NOT ASSIMP_HUNTER_ENABLED)
   if (UNZIP_FOUND)
     INCLUDE_DIRECTORIES(${UNZIP_INCLUDE_DIRS})
     TARGET_LINK_LIBRARIES(assimp ${UNZIP_LIBRARIES})
-  else (UNZIP_FOUND)
+  else ()
     INCLUDE_DIRECTORIES("../")
-  endif (UNZIP_FOUND)
-ENDIF(NOT HUNTER_ENABLED)
+  endif ()
+ENDIF()
 
 # Add RT-extension library for glTF importer with Open3DGC-compression.
 IF (RT_FOUND AND ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC)
   TARGET_LINK_LIBRARIES(assimp ${RT_LIBRARY})
-ENDIF (RT_FOUND AND ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC)
+ENDIF ()
+
 
-IF(HUNTER_ENABLED)
-  INSTALL( TARGETS assimp
-    EXPORT "${TARGETS_EXPORT_NAME}"
-    LIBRARY DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
-    ARCHIVE DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
-    RUNTIME DESTINATION ${ASSIMP_BIN_INSTALL_DIR}
-    FRAMEWORK DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
-    COMPONENT ${LIBASSIMP_COMPONENT}
-    INCLUDES DESTINATION "include")
-ELSE(HUNTER_ENABLED)
 INSTALL( TARGETS assimp
-    LIBRARY DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
-    ARCHIVE DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
-    RUNTIME DESTINATION ${ASSIMP_BIN_INSTALL_DIR}
-    FRAMEWORK DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
-    COMPONENT ${LIBASSIMP_COMPONENT})
-ENDIF(HUNTER_ENABLED)
+  EXPORT "${TARGETS_EXPORT_NAME}"
+  LIBRARY DESTINATION ${ASSIMP_LIB_INSTALL_DIR} COMPONENT ${LIBASSIMP_COMPONENT}
+  ARCHIVE DESTINATION ${ASSIMP_LIB_INSTALL_DIR} COMPONENT ${LIBASSIMP-DEV_COMPONENT}
+  RUNTIME DESTINATION ${ASSIMP_BIN_INSTALL_DIR} COMPONENT ${LIBASSIMP_COMPONENT}
+  FRAMEWORK DESTINATION ${ASSIMP_LIB_INSTALL_DIR} COMPONENT ${LIBASSIMP_COMPONENT}
+  INCLUDES DESTINATION ${ASSIMP_INCLUDE_INSTALL_DIR}
+)
 INSTALL( FILES ${PUBLIC_HEADERS} DESTINATION ${ASSIMP_INCLUDE_INSTALL_DIR}/assimp COMPONENT assimp-dev)
 INSTALL( FILES ${COMPILER_HEADERS} DESTINATION ${ASSIMP_INCLUDE_INSTALL_DIR}/assimp/Compiler COMPONENT assimp-dev)
 
@@ -1246,7 +1331,7 @@ if (ASSIMP_ANDROID_JNIIOSYSTEM)
   INSTALL(FILES ${HEADER_PATH}/${ASSIMP_ANDROID_JNIIOSYSTEM_PATH}/AndroidJNIIOSystem.h
     DESTINATION ${ASSIMP_INCLUDE_INSTALL_DIR}
     COMPONENT assimp-dev)
-ENDIF(ASSIMP_ANDROID_JNIIOSYSTEM)
+ENDIF()
 
 if(MSVC AND ASSIMP_INSTALL_PDB)
   # When only the static library is built, these properties must
diff --git a/Engine/lib/assimp/code/COB/COBLoader.h b/Engine/lib/assimp/code/COB/COBLoader.h
deleted file mode 100644
index 40fed324b..000000000
--- a/Engine/lib/assimp/code/COB/COBLoader.h
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file  COBLoader.h
- *  @brief Declaration of the TrueSpace (*.cob,*.scn) importer class.
- */
-#ifndef INCLUDED_AI_COB_LOADER_H
-#define INCLUDED_AI_COB_LOADER_H
-
-#include <assimp/BaseImporter.h>
-#include <assimp/StreamReader.h>
-
-struct aiNode;
-
-namespace Assimp    {
-    class LineSplitter;
-
-    // TinyFormatter.h
-    namespace Formatter {
-        template <typename T,typename TR, typename A> class basic_formatter;
-        typedef class basic_formatter< char, std::char_traits<char>, std::allocator<char> > format;
-    }
-
-    // COBScene.h
-    namespace COB {
-        struct ChunkInfo;
-        struct Node;
-        struct Scene;
-    }
-
-// -------------------------------------------------------------------------------------------
-/** Importer class to load TrueSpace files (cob,scn) up to v6.
- *
- *  Currently relatively limited, loads only ASCII files and needs more test coverage. */
-// -------------------------------------------------------------------------------------------
-class COBImporter : public BaseImporter
-{
-public:
-    COBImporter();
-    ~COBImporter();
-    
-    // --------------------
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
-
-protected:
-
-    // --------------------
-    const aiImporterDesc* GetInfo () const;
-
-    // --------------------
-    void SetupProperties(const Importer* pImp);
-
-    // --------------------
-    void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
-
-private:
-
-    // -------------------------------------------------------------------
-    /** Prepend 'COB: ' and throw msg.*/
-    AI_WONT_RETURN static void ThrowException(const std::string& msg) AI_WONT_RETURN_SUFFIX;
-
-    // -------------------------------------------------------------------
-    /** @brief Read from an ascii scene/object file
-     *  @param out Receives output data.
-     *  @param stream Stream to read from. */
-    void ReadAsciiFile(COB::Scene& out, StreamReaderLE* stream);
-
-    // -------------------------------------------------------------------
-    /** @brief Read from a binary scene/object file
-     *  @param out Receives output data.
-     *  @param stream Stream to read from.  */
-    void ReadBinaryFile(COB::Scene& out, StreamReaderLE* stream);
-
-    // Conversion to Assimp output format
-
-    aiNode* BuildNodes(const COB::Node& root,const COB::Scene& scin,aiScene* fill);
-
-private:
-    // ASCII file support
-
-    void UnsupportedChunk_Ascii(LineSplitter& splitter, const COB::ChunkInfo& nfo, const char* name);
-    void ReadChunkInfo_Ascii(COB::ChunkInfo& out, const LineSplitter& splitter);
-    void ReadBasicNodeInfo_Ascii(COB::Node& msh, LineSplitter& splitter, const COB::ChunkInfo& nfo);
-    template <typename T> void ReadFloat3Tuple_Ascii(T& fill, const char** in);
-
-    void ReadPolH_Ascii(COB::Scene& out, LineSplitter& splitter, const COB::ChunkInfo& nfo);
-    void ReadBitM_Ascii(COB::Scene& out, LineSplitter& splitter, const COB::ChunkInfo& nfo);
-    void ReadMat1_Ascii(COB::Scene& out, LineSplitter& splitter, const COB::ChunkInfo& nfo);
-    void ReadGrou_Ascii(COB::Scene& out, LineSplitter& splitter, const COB::ChunkInfo& nfo);
-    void ReadBone_Ascii(COB::Scene& out, LineSplitter& splitter, const COB::ChunkInfo& nfo);
-    void ReadCame_Ascii(COB::Scene& out, LineSplitter& splitter, const COB::ChunkInfo& nfo);
-    void ReadLght_Ascii(COB::Scene& out, LineSplitter& splitter, const COB::ChunkInfo& nfo);
-    void ReadUnit_Ascii(COB::Scene& out, LineSplitter& splitter, const COB::ChunkInfo& nfo);
-    void ReadChan_Ascii(COB::Scene& out, LineSplitter& splitter, const COB::ChunkInfo& nfo);
-
-
-    // Binary file support
-
-    void UnsupportedChunk_Binary(StreamReaderLE& reader, const COB::ChunkInfo& nfo, const char* name);
-    void ReadString_Binary(std::string& out, StreamReaderLE& reader);
-    void ReadBasicNodeInfo_Binary(COB::Node& msh, StreamReaderLE& reader, const COB::ChunkInfo& nfo);
-
-    void ReadPolH_Binary(COB::Scene& out, StreamReaderLE& reader, const COB::ChunkInfo& nfo);
-    void ReadBitM_Binary(COB::Scene& out, StreamReaderLE& reader, const COB::ChunkInfo& nfo);
-    void ReadMat1_Binary(COB::Scene& out, StreamReaderLE& reader, const COB::ChunkInfo& nfo);
-    void ReadCame_Binary(COB::Scene& out, StreamReaderLE& reader, const COB::ChunkInfo& nfo);
-    void ReadLght_Binary(COB::Scene& out, StreamReaderLE& reader, const COB::ChunkInfo& nfo);
-    void ReadGrou_Binary(COB::Scene& out, StreamReaderLE& reader, const COB::ChunkInfo& nfo);
-    void ReadUnit_Binary(COB::Scene& out, StreamReaderLE& reader, const COB::ChunkInfo& nfo);
-
-
-}; // !class COBImporter
-
-} // end of namespace Assimp
-#endif // AI_UNREALIMPORTER_H_INC
diff --git a/Engine/lib/assimp/code/Collada/ColladaExporter.cpp b/Engine/lib/assimp/code/Collada/ColladaExporter.cpp
deleted file mode 100644
index 6fd31ed3b..000000000
--- a/Engine/lib/assimp/code/Collada/ColladaExporter.cpp
+++ /dev/null
@@ -1,1675 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-#ifndef ASSIMP_BUILD_NO_EXPORT
-#ifndef ASSIMP_BUILD_NO_COLLADA_EXPORTER
-
-#include "ColladaExporter.h"
-#include <assimp/Bitmap.h>
-#include <assimp/MathFunctions.h>
-#include <assimp/fast_atof.h>
-#include <assimp/SceneCombiner.h>
-#include <assimp/StringUtils.h>
-#include <assimp/XMLTools.h>
-#include <assimp/DefaultIOSystem.h>
-#include <assimp/IOSystem.hpp>
-#include <assimp/Exporter.hpp>
-#include <assimp/scene.h>
-
-#include <assimp/Exceptional.h>
-
-#include <memory>
-#include <ctime>
-#include <set>
-#include <vector>
-#include <iostream>
-
-using namespace Assimp;
-
-namespace Assimp {
-
-// ------------------------------------------------------------------------------------------------
-// Worker function for exporting a scene to Collada. Prototyped and registered in Exporter.cpp
-void ExportSceneCollada(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/) {
-    std::string path = DefaultIOSystem::absolutePath(std::string(pFile));
-    std::string file = DefaultIOSystem::completeBaseName(std::string(pFile));
-
-    // invoke the exporter
-    ColladaExporter iDoTheExportThing( pScene, pIOSystem, path, file);
-    
-    if (iDoTheExportThing.mOutput.fail()) {
-        throw DeadlyExportError("output data creation failed. Most likely the file became too large: " + std::string(pFile));
-    }
-
-    // we're still here - export successfully completed. Write result to the given IOSYstem
-    std::unique_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wt"));
-    if(outfile == NULL) {
-        throw DeadlyExportError("could not open output .dae file: " + std::string(pFile));
-    }
-
-    // XXX maybe use a small wrapper around IOStream that behaves like std::stringstream in order to avoid the extra copy.
-    outfile->Write( iDoTheExportThing.mOutput.str().c_str(), static_cast<size_t>(iDoTheExportThing.mOutput.tellp()),1);
-}
-
-} // end of namespace Assimp
-
-// ------------------------------------------------------------------------------------------------
-// Constructor for a specific scene to export
-ColladaExporter::ColladaExporter( const aiScene* pScene, IOSystem* pIOSystem, const std::string& path, const std::string& file) 
-: mIOSystem(pIOSystem)
-, mPath(path)
-, mFile(file) {
-    // make sure that all formatting happens using the standard, C locale and not the user's current locale
-    mOutput.imbue( std::locale("C") );
-    mOutput.precision(ASSIMP_AI_REAL_TEXT_PRECISION);
-
-    mScene = pScene;
-    mSceneOwned = false;
-
-    // set up strings
-    endstr = "\n";
-
-    // start writing the file
-    WriteFile();
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor
-ColladaExporter::~ColladaExporter() {
-    if ( mSceneOwned ) {
-        delete mScene;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Starts writing the contents
-void ColladaExporter::WriteFile() {
-    // write the DTD
-    mOutput << "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>" << endstr;
-    // COLLADA element start
-    mOutput << "<COLLADA xmlns=\"http://www.collada.org/2005/11/COLLADASchema\" version=\"1.4.1\">" << endstr;
-    PushTag();
-
-    WriteTextures();
-    WriteHeader();
-
-    WriteCamerasLibrary();
-    WriteLightsLibrary();
-    WriteMaterials();
-    WriteGeometryLibrary();
-    WriteControllerLibrary();
-
-    WriteSceneLibrary();
-	
-	// customized, Writes the animation library
-	WriteAnimationsLibrary();
-
-    // useless Collada fu at the end, just in case we haven't had enough indirections, yet.
-    mOutput << startstr << "<scene>" << endstr;
-    PushTag();
-    mOutput << startstr << "<instance_visual_scene url=\"#" + XMLEscape(mScene->mRootNode->mName.C_Str()) + "\" />" << endstr;
-    PopTag();
-    mOutput << startstr << "</scene>" << endstr;
-    PopTag();
-    mOutput << "</COLLADA>" << endstr;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Writes the asset header
-void ColladaExporter::WriteHeader() {
-    static const ai_real epsilon = Math::getEpsilon<ai_real>();
-    static const aiQuaternion x_rot(aiMatrix3x3(
-        0, -1,  0,
-        1,  0,  0,
-        0,  0,  1));
-    static const aiQuaternion y_rot(aiMatrix3x3(
-        1,  0,  0,
-        0,  1,  0,
-        0,  0,  1));
-    static const aiQuaternion z_rot(aiMatrix3x3(
-        1,  0,  0,
-        0,  0,  1,
-        0, -1,  0));
-
-    static const unsigned int date_nb_chars = 20;
-    char date_str[date_nb_chars];
-    std::time_t date = std::time(NULL);
-    std::strftime(date_str, date_nb_chars, "%Y-%m-%dT%H:%M:%S", std::localtime(&date));
-
-    aiVector3D scaling;
-    aiQuaternion rotation;
-    aiVector3D position;
-    mScene->mRootNode->mTransformation.Decompose(scaling, rotation, position);
-    rotation.Normalize();
-
-    bool add_root_node = false;
-
-    ai_real scale = 1.0;
-    if(std::abs(scaling.x - scaling.y) <= epsilon && std::abs(scaling.x - scaling.z) <= epsilon && std::abs(scaling.y - scaling.z) <= epsilon) {
-        scale = (ai_real) ((((double) scaling.x) + ((double) scaling.y) + ((double) scaling.z)) / 3.0);
-    } else {
-        add_root_node = true;
-    }
-
-    std::string up_axis = "Y_UP";
-    if(rotation.Equal(x_rot, epsilon)) {
-        up_axis = "X_UP";
-    } else if(rotation.Equal(y_rot, epsilon)) {
-        up_axis = "Y_UP";
-    } else if(rotation.Equal(z_rot, epsilon)) {
-        up_axis = "Z_UP";
-    } else {
-        add_root_node = true;
-    }
-
-    if(! position.Equal(aiVector3D(0, 0, 0))) {
-        add_root_node = true;
-    }
-
-    if(mScene->mRootNode->mNumChildren == 0) {
-        add_root_node = true;
-    }
-
-    if(add_root_node) {
-        aiScene* scene;
-        SceneCombiner::CopyScene(&scene, mScene);
-
-        aiNode* root = new aiNode("Scene");
-
-        root->mNumChildren = 1;
-        root->mChildren = new aiNode*[root->mNumChildren];
-
-        root->mChildren[0] = scene->mRootNode;
-        scene->mRootNode->mParent = root;
-        scene->mRootNode = root;
-
-        mScene = scene;
-        mSceneOwned = true;
-
-        up_axis = "Y_UP";
-        scale = 1.0;
-    }
-
-    mOutput << startstr << "<asset>" << endstr;
-    PushTag();
-    mOutput << startstr << "<contributor>" << endstr;
-    PushTag();
-
-    // If no Scene metadata, use root node metadata
-    aiMetadata* meta = mScene->mMetaData;
-    if (nullptr == meta) {
-        meta = mScene->mRootNode->mMetaData;
-    }
-
-    aiString value;
-    if (!meta || !meta->Get("Author", value)) {
-        mOutput << startstr << "<author>" << "Assimp" << "</author>" << endstr;
-    } else {
-        mOutput << startstr << "<author>" << XMLEscape(value.C_Str()) << "</author>" << endstr;
-    }
-
-    if (nullptr == meta || !meta->Get("AuthoringTool", value)) {
-        mOutput << startstr << "<authoring_tool>" << "Assimp Exporter" << "</authoring_tool>" << endstr;
-    } else {
-        mOutput << startstr << "<authoring_tool>" << XMLEscape(value.C_Str()) << "</authoring_tool>" << endstr;
-    }
-
-    if (meta) {
-        if (meta->Get("Comments", value)) {
-            mOutput << startstr << "<comments>" << XMLEscape(value.C_Str()) << "</comments>" << endstr;
-        }
-        if (meta->Get("Copyright", value)) {
-            mOutput << startstr << "<copyright>" << XMLEscape(value.C_Str()) << "</copyright>" << endstr;
-        }
-        if (meta->Get("SourceData", value)) {
-            mOutput << startstr << "<source_data>" << XMLEscape(value.C_Str()) << "</source_data>" << endstr;
-        }
-    }
-
-    PopTag();
-    mOutput << startstr << "</contributor>" << endstr;
-
-    if (nullptr == meta || !meta->Get("Created", value)) {
-        mOutput << startstr << "<created>" << date_str << "</created>" << endstr;
-    } else {
-        mOutput << startstr << "<created>" << XMLEscape(value.C_Str()) << "</created>" << endstr;
-    }
-
-    // Modified date is always the date saved
-    mOutput << startstr << "<modified>" << date_str << "</modified>" << endstr;
-
-    if (meta) {
-        if (meta->Get("Keywords", value)) {
-            mOutput << startstr << "<keywords>" << XMLEscape(value.C_Str()) << "</keywords>" << endstr;
-        }
-        if (meta->Get("Revision", value)) {
-            mOutput << startstr << "<revision>" << XMLEscape(value.C_Str()) << "</revision>" << endstr;
-        }
-        if (meta->Get("Subject", value)) {
-            mOutput << startstr << "<subject>" << XMLEscape(value.C_Str()) << "</subject>" << endstr;
-        }
-        if (meta->Get("Title", value)) {
-            mOutput << startstr << "<title>" << XMLEscape(value.C_Str()) << "</title>" << endstr;
-        }
-    }
-
-    mOutput << startstr << "<unit name=\"meter\" meter=\"" << scale << "\" />" << endstr;
-    mOutput << startstr << "<up_axis>" << up_axis << "</up_axis>" << endstr;
-    PopTag();
-    mOutput << startstr << "</asset>" << endstr;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Write the embedded textures
-void ColladaExporter::WriteTextures() {
-    static const unsigned int buffer_size = 1024;
-    char str[buffer_size];
-
-    if (mScene->HasTextures()) {
-        for(unsigned int i = 0; i < mScene->mNumTextures; i++) {
-            // It would be great to be able to create a directory in portable standard C++, but it's not the case,
-            // so we just write the textures in the current directory.
-
-            aiTexture* texture = mScene->mTextures[i];
-            if ( nullptr == texture ) {
-                continue;
-            }
-
-            ASSIMP_itoa10(str, buffer_size, i + 1);
-
-            std::string name = mFile + "_texture_" + (i < 1000 ? "0" : "") + (i < 100 ? "0" : "") + (i < 10 ? "0" : "") + str + "." + ((const char*) texture->achFormatHint);
-
-            std::unique_ptr<IOStream> outfile(mIOSystem->Open(mPath + mIOSystem->getOsSeparator() + name, "wb"));
-            if(outfile == NULL) {
-                throw DeadlyExportError("could not open output texture file: " + mPath + name);
-            }
-
-            if(texture->mHeight == 0) {
-                outfile->Write((void*) texture->pcData, texture->mWidth, 1);
-            } else {
-                Bitmap::Save(texture, outfile.get());
-            }
-
-            outfile->Flush();
-
-            textures.insert(std::make_pair(i, name));
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Write the embedded textures
-void ColladaExporter::WriteCamerasLibrary() {
-    if(mScene->HasCameras()) {
-
-        mOutput << startstr << "<library_cameras>" << endstr;
-        PushTag();
-
-        for( size_t a = 0; a < mScene->mNumCameras; ++a)
-            WriteCamera( a);
-
-        PopTag();
-        mOutput << startstr << "</library_cameras>" << endstr;
-
-    }
-}
-
-void ColladaExporter::WriteCamera(size_t pIndex){
-
-    const aiCamera *cam = mScene->mCameras[pIndex];
-    const std::string idstrEscaped = XMLEscape(cam->mName.C_Str());
-
-    mOutput << startstr << "<camera id=\"" << idstrEscaped << "-camera\" name=\"" << idstrEscaped << "_name\" >" << endstr;
-    PushTag();
-    mOutput << startstr << "<optics>" << endstr;
-    PushTag();
-    mOutput << startstr << "<technique_common>" << endstr;
-    PushTag();
-    //assimp doesn't support the import of orthographic cameras! se we write
-    //always perspective
-    mOutput << startstr << "<perspective>" << endstr;
-    PushTag();
-    mOutput << startstr << "<xfov sid=\"xfov\">"<<
-                                AI_RAD_TO_DEG(cam->mHorizontalFOV)
-                        <<"</xfov>" << endstr;
-    mOutput << startstr << "<aspect_ratio>"
-                        <<      cam->mAspect
-                        << "</aspect_ratio>" << endstr;
-    mOutput << startstr << "<znear sid=\"znear\">"
-                        <<      cam->mClipPlaneNear
-                        <<  "</znear>" << endstr;
-    mOutput << startstr << "<zfar sid=\"zfar\">"
-                        <<      cam->mClipPlaneFar
-                        << "</zfar>" << endstr;
-    PopTag();
-    mOutput << startstr << "</perspective>" << endstr;
-    PopTag();
-    mOutput << startstr << "</technique_common>" << endstr;
-    PopTag();
-    mOutput << startstr << "</optics>" << endstr;
-    PopTag();
-    mOutput << startstr << "</camera>" << endstr;
-
-}
-
-
-// ------------------------------------------------------------------------------------------------
-// Write the embedded textures
-void ColladaExporter::WriteLightsLibrary() {
-    if(mScene->HasLights()) {
-
-        mOutput << startstr << "<library_lights>" << endstr;
-        PushTag();
-
-        for( size_t a = 0; a < mScene->mNumLights; ++a)
-            WriteLight( a);
-
-        PopTag();
-        mOutput << startstr << "</library_lights>" << endstr;
-
-    }
-}
-
-void ColladaExporter::WriteLight(size_t pIndex){
-
-    const aiLight *light = mScene->mLights[pIndex];
-    const std::string idstrEscaped = XMLEscape(light->mName.C_Str());
-
-    mOutput << startstr << "<light id=\"" << idstrEscaped << "-light\" name=\""
-            << idstrEscaped << "_name\" >" << endstr;
-    PushTag();
-    mOutput << startstr << "<technique_common>" << endstr;
-    PushTag();
-    switch(light->mType){
-        case aiLightSource_AMBIENT:
-            WriteAmbienttLight(light);
-            break;
-        case aiLightSource_DIRECTIONAL:
-            WriteDirectionalLight(light);
-            break;
-        case aiLightSource_POINT:
-            WritePointLight(light);
-            break;
-        case aiLightSource_SPOT:
-            WriteSpotLight(light);
-            break;
-        case aiLightSource_AREA:
-        case aiLightSource_UNDEFINED:
-        case _aiLightSource_Force32Bit:
-            break;
-    }
-    PopTag();
-    mOutput << startstr << "</technique_common>" << endstr;
-
-    PopTag();
-    mOutput << startstr << "</light>" << endstr;
-
-}
-
-void ColladaExporter::WritePointLight(const aiLight *const light){
-    const aiColor3D &color=  light->mColorDiffuse;
-    mOutput << startstr << "<point>" << endstr;
-    PushTag();
-    mOutput << startstr << "<color sid=\"color\">"
-                            << color.r<<" "<<color.g<<" "<<color.b
-                        <<"</color>" << endstr;
-    mOutput << startstr << "<constant_attenuation>"
-                            << light->mAttenuationConstant
-                        <<"</constant_attenuation>" << endstr;
-    mOutput << startstr << "<linear_attenuation>"
-                            << light->mAttenuationLinear
-                        <<"</linear_attenuation>" << endstr;
-    mOutput << startstr << "<quadratic_attenuation>"
-                            << light->mAttenuationQuadratic
-                        <<"</quadratic_attenuation>" << endstr;
-
-    PopTag();
-    mOutput << startstr << "</point>" << endstr;
-
-}
-
-void ColladaExporter::WriteDirectionalLight(const aiLight *const light){
-    const aiColor3D &color=  light->mColorDiffuse;
-    mOutput << startstr << "<directional>" << endstr;
-    PushTag();
-    mOutput << startstr << "<color sid=\"color\">"
-                            << color.r<<" "<<color.g<<" "<<color.b
-                        <<"</color>" << endstr;
-
-    PopTag();
-    mOutput << startstr << "</directional>" << endstr;
-
-}
-
-void ColladaExporter::WriteSpotLight(const aiLight *const light){
-
-    const aiColor3D &color=  light->mColorDiffuse;
-    mOutput << startstr << "<spot>" << endstr;
-    PushTag();
-    mOutput << startstr << "<color sid=\"color\">"
-                            << color.r<<" "<<color.g<<" "<<color.b
-                        <<"</color>" << endstr;
-    mOutput << startstr << "<constant_attenuation>"
-                                << light->mAttenuationConstant
-                            <<"</constant_attenuation>" << endstr;
-    mOutput << startstr << "<linear_attenuation>"
-                            << light->mAttenuationLinear
-                        <<"</linear_attenuation>" << endstr;
-    mOutput << startstr << "<quadratic_attenuation>"
-                            << light->mAttenuationQuadratic
-                        <<"</quadratic_attenuation>" << endstr;
-    /*
-    out->mAngleOuterCone = AI_DEG_TO_RAD (std::acos(std::pow(0.1f,1.f/srcLight->mFalloffExponent))+
-                            srcLight->mFalloffAngle);
-    */
-
-    const ai_real fallOffAngle = AI_RAD_TO_DEG(light->mAngleInnerCone);
-    mOutput << startstr <<"<falloff_angle sid=\"fall_off_angle\">"
-                                << fallOffAngle
-                        <<"</falloff_angle>" << endstr;
-    double temp = light->mAngleOuterCone-light->mAngleInnerCone;
-
-    temp = std::cos(temp);
-    temp = std::log(temp)/std::log(0.1);
-    temp = 1/temp;
-    mOutput << startstr << "<falloff_exponent sid=\"fall_off_exponent\">"
-                            << temp
-                        <<"</falloff_exponent>" << endstr;
-
-
-    PopTag();
-    mOutput << startstr << "</spot>" << endstr;
-
-}
-
-void ColladaExporter::WriteAmbienttLight(const aiLight *const light){
-
-    const aiColor3D &color=  light->mColorAmbient;
-    mOutput << startstr << "<ambient>" << endstr;
-    PushTag();
-    mOutput << startstr << "<color sid=\"color\">"
-                            << color.r<<" "<<color.g<<" "<<color.b
-                        <<"</color>" << endstr;
-
-    PopTag();
-    mOutput << startstr << "</ambient>" << endstr;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads a single surface entry from the given material keys
-void ColladaExporter::ReadMaterialSurface( Surface& poSurface, const aiMaterial* pSrcMat, 
-                                          aiTextureType pTexture, const char* pKey, size_t pType, size_t pIndex) {
-  if( pSrcMat->GetTextureCount( pTexture) > 0 ) {
-    aiString texfile;
-    unsigned int uvChannel = 0;
-    pSrcMat->GetTexture( pTexture, 0, &texfile, NULL, &uvChannel);
-
-    std::string index_str(texfile.C_Str());
-
-    if(index_str.size() != 0 && index_str[0] == '*') {
-        unsigned int index;
-
-        index_str = index_str.substr(1, std::string::npos);
-
-        try {
-            index = (unsigned int) strtoul10_64(index_str.c_str());
-        } catch(std::exception& error) {
-            throw DeadlyExportError(error.what());
-        }
-
-        std::map<unsigned int, std::string>::const_iterator name = textures.find(index);
-
-        if(name != textures.end()) {
-            poSurface.texture = name->second;
-        } else {
-            throw DeadlyExportError("could not find embedded texture at index " + index_str);
-        }
-    } else {
-        poSurface.texture = texfile.C_Str();
-    }
-
-    poSurface.channel = uvChannel;
-    poSurface.exist = true;
-  } else {
-    if( pKey )
-      poSurface.exist = pSrcMat->Get( pKey, static_cast<unsigned int>(pType), static_cast<unsigned int>(pIndex), poSurface.color) == aiReturn_SUCCESS;
-  }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reimplementation of isalnum(,C locale), because AppVeyor does not see standard version.
-static bool isalnum_C(char c) {
-  return ( nullptr != strchr("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",c) );
-}
-
-// ------------------------------------------------------------------------------------------------
-// Writes an image entry for the given surface
-void ColladaExporter::WriteImageEntry( const Surface& pSurface, const std::string& pNameAdd) {
-  if( !pSurface.texture.empty() )
-  {
-    mOutput << startstr << "<image id=\"" << XMLEscape(pNameAdd) << "\">" << endstr;
-    PushTag();
-    mOutput << startstr << "<init_from>";
-
-    // URL encode image file name first, then XML encode on top
-    std::stringstream imageUrlEncoded;
-    for( std::string::const_iterator it = pSurface.texture.begin(); it != pSurface.texture.end(); ++it )
-    {
-      if( isalnum_C( (unsigned char) *it) || *it == ':' || *it == '_' || *it == '-' || *it == '.' || *it == '/' || *it == '\\' )
-        imageUrlEncoded << *it;
-      else
-        imageUrlEncoded << '%' << std::hex << size_t( (unsigned char) *it) << std::dec;
-    }
-    mOutput << XMLEscape(imageUrlEncoded.str());
-    mOutput << "</init_from>" << endstr;
-    PopTag();
-    mOutput << startstr << "</image>" << endstr;
-  }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Writes a color-or-texture entry into an effect definition
-void ColladaExporter::WriteTextureColorEntry( const Surface& pSurface, const std::string& pTypeName, const std::string& pImageName)
-{
-  if(pSurface.exist) {
-    mOutput << startstr << "<" << pTypeName << ">" << endstr;
-    PushTag();
-    if( pSurface.texture.empty() )
-    {
-      mOutput << startstr << "<color sid=\"" << pTypeName << "\">" << pSurface.color.r << "   " << pSurface.color.g << "   " << pSurface.color.b << "   " << pSurface.color.a << "</color>" << endstr;
-    }
-    else
-    {
-      mOutput << startstr << "<texture texture=\"" << XMLEscape(pImageName) << "\" texcoord=\"CHANNEL" << pSurface.channel << "\" />" << endstr;
-    }
-    PopTag();
-    mOutput << startstr << "</" << pTypeName << ">" << endstr;
-  }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Writes the two parameters necessary for referencing a texture in an effect entry
-void ColladaExporter::WriteTextureParamEntry( const Surface& pSurface, const std::string& pTypeName, const std::string& pMatName)
-{
-  // if surface is a texture, write out the sampler and the surface parameters necessary to reference the texture
-  if( !pSurface.texture.empty() )
-  {
-    mOutput << startstr << "<newparam sid=\"" << XMLEscape(pMatName) << "-" << pTypeName << "-surface\">" << endstr;
-    PushTag();
-    mOutput << startstr << "<surface type=\"2D\">" << endstr;
-    PushTag();
-    mOutput << startstr << "<init_from>" << XMLEscape(pMatName) << "-" << pTypeName << "-image</init_from>" << endstr;
-    PopTag();
-    mOutput << startstr << "</surface>" << endstr;
-    PopTag();
-    mOutput << startstr << "</newparam>" << endstr;
-
-    mOutput << startstr << "<newparam sid=\"" << XMLEscape(pMatName) << "-" << pTypeName << "-sampler\">" << endstr;
-    PushTag();
-    mOutput << startstr << "<sampler2D>" << endstr;
-    PushTag();
-    mOutput << startstr << "<source>" << XMLEscape(pMatName) << "-" << pTypeName << "-surface</source>" << endstr;
-    PopTag();
-    mOutput << startstr << "</sampler2D>" << endstr;
-    PopTag();
-    mOutput << startstr << "</newparam>" << endstr;
-  }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Writes a scalar property
-void ColladaExporter::WriteFloatEntry( const Property& pProperty, const std::string& pTypeName)
-{
-    if(pProperty.exist) {
-        mOutput << startstr << "<" << pTypeName << ">" << endstr;
-        PushTag();
-        mOutput << startstr << "<float sid=\"" << pTypeName << "\">" << pProperty.value << "</float>" << endstr;
-        PopTag();
-        mOutput << startstr << "</" << pTypeName << ">" << endstr;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Writes the material setup
-void ColladaExporter::WriteMaterials()
-{
-  materials.resize( mScene->mNumMaterials);
-
-  /// collect all materials from the scene
-  size_t numTextures = 0;
-  for( size_t a = 0; a < mScene->mNumMaterials; ++a )
-  {
-    const aiMaterial* mat = mScene->mMaterials[a];
-
-    aiString name;
-    if( mat->Get( AI_MATKEY_NAME, name) != aiReturn_SUCCESS ) {
-      name = "mat";
-      materials[a].name = std::string( "m") + to_string(a) + name.C_Str();
-    } else {
-      // try to use the material's name if no other material has already taken it, else append #
-      std::string testName = name.C_Str();
-      size_t materialCountWithThisName = 0;
-      for( size_t i = 0; i < a; i ++ ) {
-        if( materials[i].name == testName ) {
-          materialCountWithThisName ++;
-        }
-      }
-      if( materialCountWithThisName == 0 ) {
-        materials[a].name = name.C_Str();
-      } else {
-        materials[a].name = std::string(name.C_Str()) + to_string(materialCountWithThisName);
-      }
-    }
-    for( std::string::iterator it = materials[a].name.begin(); it != materials[a].name.end(); ++it ) {
-      if( !isalnum_C( *it ) ) {
-        *it = '_';
-      }
-    }
-
-    aiShadingMode shading = aiShadingMode_Flat;
-    materials[a].shading_model = "phong";
-    if(mat->Get( AI_MATKEY_SHADING_MODEL, shading) == aiReturn_SUCCESS) {
-        if(shading == aiShadingMode_Phong) {
-            materials[a].shading_model = "phong";
-        } else if(shading == aiShadingMode_Blinn) {
-            materials[a].shading_model = "blinn";
-        } else if(shading == aiShadingMode_NoShading) {
-            materials[a].shading_model = "constant";
-        } else if(shading == aiShadingMode_Gouraud) {
-            materials[a].shading_model = "lambert";
-        }
-    }
-
-    ReadMaterialSurface( materials[a].ambient, mat, aiTextureType_AMBIENT, AI_MATKEY_COLOR_AMBIENT);
-    if( !materials[a].ambient.texture.empty() ) numTextures++;
-    ReadMaterialSurface( materials[a].diffuse, mat, aiTextureType_DIFFUSE, AI_MATKEY_COLOR_DIFFUSE);
-    if( !materials[a].diffuse.texture.empty() ) numTextures++;
-    ReadMaterialSurface( materials[a].specular, mat, aiTextureType_SPECULAR, AI_MATKEY_COLOR_SPECULAR);
-    if( !materials[a].specular.texture.empty() ) numTextures++;
-    ReadMaterialSurface( materials[a].emissive, mat, aiTextureType_EMISSIVE, AI_MATKEY_COLOR_EMISSIVE);
-    if( !materials[a].emissive.texture.empty() ) numTextures++;
-    ReadMaterialSurface( materials[a].reflective, mat, aiTextureType_REFLECTION, AI_MATKEY_COLOR_REFLECTIVE);
-    if( !materials[a].reflective.texture.empty() ) numTextures++;
-    ReadMaterialSurface( materials[a].transparent, mat, aiTextureType_OPACITY, AI_MATKEY_COLOR_TRANSPARENT);
-    if( !materials[a].transparent.texture.empty() ) numTextures++;
-    ReadMaterialSurface( materials[a].normal, mat, aiTextureType_NORMALS, NULL, 0, 0);
-    if( !materials[a].normal.texture.empty() ) numTextures++;
-
-    materials[a].shininess.exist = mat->Get( AI_MATKEY_SHININESS, materials[a].shininess.value) == aiReturn_SUCCESS;
-    materials[a].transparency.exist = mat->Get( AI_MATKEY_OPACITY, materials[a].transparency.value) == aiReturn_SUCCESS;
-    materials[a].index_refraction.exist = mat->Get( AI_MATKEY_REFRACTI, materials[a].index_refraction.value) == aiReturn_SUCCESS;
-  }
-
-  // output textures if present
-  if( numTextures > 0 )
-  {
-    mOutput << startstr << "<library_images>" << endstr;
-    PushTag();
-    for( std::vector<Material>::const_iterator it = materials.begin(); it != materials.end(); ++it )
-    {
-      const Material& mat = *it;
-      WriteImageEntry( mat.ambient, mat.name + "-ambient-image");
-      WriteImageEntry( mat.diffuse, mat.name + "-diffuse-image");
-      WriteImageEntry( mat.specular, mat.name + "-specular-image");
-      WriteImageEntry( mat.emissive, mat.name + "-emission-image");
-      WriteImageEntry( mat.reflective, mat.name + "-reflective-image");
-      WriteImageEntry( mat.transparent, mat.name + "-transparent-image");
-      WriteImageEntry( mat.normal, mat.name + "-normal-image");
-    }
-    PopTag();
-    mOutput << startstr << "</library_images>" << endstr;
-  }
-
-  // output effects - those are the actual carriers of information
-  if( !materials.empty() )
-  {
-    mOutput << startstr << "<library_effects>" << endstr;
-    PushTag();
-    for( std::vector<Material>::const_iterator it = materials.begin(); it != materials.end(); ++it )
-    {
-      const Material& mat = *it;
-      // this is so ridiculous it must be right
-      mOutput << startstr << "<effect id=\"" << XMLEscape(mat.name) << "-fx\" name=\"" << XMLEscape(mat.name) << "\">" << endstr;
-      PushTag();
-      mOutput << startstr << "<profile_COMMON>" << endstr;
-      PushTag();
-
-      // write sampler- and surface params for the texture entries
-      WriteTextureParamEntry( mat.emissive, "emission", mat.name);
-      WriteTextureParamEntry( mat.ambient, "ambient", mat.name);
-      WriteTextureParamEntry( mat.diffuse, "diffuse", mat.name);
-      WriteTextureParamEntry( mat.specular, "specular", mat.name);
-      WriteTextureParamEntry( mat.reflective, "reflective", mat.name);
-      WriteTextureParamEntry( mat.transparent, "transparent", mat.name);
-      WriteTextureParamEntry( mat.normal, "normal", mat.name);
-
-      mOutput << startstr << "<technique sid=\"standard\">" << endstr;
-      PushTag();
-      mOutput << startstr << "<" << mat.shading_model << ">" << endstr;
-      PushTag();
-
-      WriteTextureColorEntry( mat.emissive, "emission", mat.name + "-emission-sampler");
-      WriteTextureColorEntry( mat.ambient, "ambient", mat.name + "-ambient-sampler");
-      WriteTextureColorEntry( mat.diffuse, "diffuse", mat.name + "-diffuse-sampler");
-      WriteTextureColorEntry( mat.specular, "specular", mat.name + "-specular-sampler");
-      WriteFloatEntry(mat.shininess, "shininess");
-      WriteTextureColorEntry( mat.reflective, "reflective", mat.name + "-reflective-sampler");
-      WriteTextureColorEntry( mat.transparent, "transparent", mat.name + "-transparent-sampler");
-      WriteFloatEntry(mat.transparency, "transparency");
-      WriteFloatEntry(mat.index_refraction, "index_of_refraction");
-
-      if(! mat.normal.texture.empty()) {
-        WriteTextureColorEntry( mat.normal, "bump", mat.name + "-normal-sampler");
-      }
-
-      PopTag();
-      mOutput << startstr << "</" << mat.shading_model << ">" << endstr;
-      PopTag();
-      mOutput << startstr << "</technique>" << endstr;
-      PopTag();
-      mOutput << startstr << "</profile_COMMON>" << endstr;
-      PopTag();
-      mOutput << startstr << "</effect>" << endstr;
-    }
-    PopTag();
-    mOutput << startstr << "</library_effects>" << endstr;
-
-    // write materials - they're just effect references
-    mOutput << startstr << "<library_materials>" << endstr;
-    PushTag();
-    for( std::vector<Material>::const_iterator it = materials.begin(); it != materials.end(); ++it )
-    {
-      const Material& mat = *it;
-      mOutput << startstr << "<material id=\"" << XMLEscape(mat.name) << "\" name=\"" << mat.name << "\">" << endstr;
-      PushTag();
-      mOutput << startstr << "<instance_effect url=\"#" << XMLEscape(mat.name) << "-fx\"/>" << endstr;
-      PopTag();
-      mOutput << startstr << "</material>" << endstr;
-    }
-    PopTag();
-    mOutput << startstr << "</library_materials>" << endstr;
-  }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Writes the controller library
-void ColladaExporter::WriteControllerLibrary()
-{
-    mOutput << startstr << "<library_controllers>" << endstr;
-    PushTag();
-    
-    for( size_t a = 0; a < mScene->mNumMeshes; ++a) {
-        WriteController( a);
-    }
-
-    PopTag();
-    mOutput << startstr << "</library_controllers>" << endstr;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Writes a skin controller of the given mesh
-void ColladaExporter::WriteController( size_t pIndex)
-{
-    const aiMesh* mesh = mScene->mMeshes[pIndex];
-    const std::string idstr = GetMeshId( pIndex);
-    const std::string idstrEscaped = XMLEscape(idstr);
-
-    if ( mesh->mNumFaces == 0 || mesh->mNumVertices == 0 )
-        return;
-
-    if ( mesh->mNumBones == 0 )
-        return;
-
-    mOutput << startstr << "<controller id=\"" << idstrEscaped << "-skin\" ";
-    mOutput << "name=\"skinCluster" << pIndex << "\">"<< endstr;
-    PushTag();
-
-    mOutput << startstr << "<skin source=\"#" << idstrEscaped << "\">" << endstr;
-    PushTag();
-
-    // bind pose matrix
-    mOutput << startstr << "<bind_shape_matrix>" << endstr;
-    PushTag();
-
-    // I think it is identity in general cases.
-    aiMatrix4x4 mat;
-    mOutput << startstr << mat.a1 << " " << mat.a2 << " " << mat.a3 << " " << mat.a4 << endstr;
-    mOutput << startstr << mat.b1 << " " << mat.b2 << " " << mat.b3 << " " << mat.b4 << endstr;
-    mOutput << startstr << mat.c1 << " " << mat.c2 << " " << mat.c3 << " " << mat.c4 << endstr;
-    mOutput << startstr << mat.d1 << " " << mat.d2 << " " << mat.d3 << " " << mat.d4 << endstr;
-
-    PopTag();
-    mOutput << startstr << "</bind_shape_matrix>" << endstr;
-
-    mOutput << startstr << "<source id=\"" << idstrEscaped << "-skin-joints\" name=\"" << idstrEscaped << "-skin-joints\">" << endstr;
-    PushTag();
-
-    mOutput << startstr << "<Name_array id=\"" << idstrEscaped << "-skin-joints-array\" count=\"" << mesh->mNumBones << "\">";
-
-    for( size_t i = 0; i < mesh->mNumBones; ++i )
-        mOutput << XMLEscape(mesh->mBones[i]->mName.C_Str()) << " ";
-
-    mOutput << "</Name_array>" << endstr;
-
-    mOutput << startstr << "<technique_common>" << endstr;
-    PushTag();
-    
-    mOutput << startstr << "<accessor source=\"#" << idstrEscaped << "-skin-joints-array\" count=\"" << mesh->mNumBones << "\" stride=\"" << 1 << "\">" << endstr;
-    PushTag();
-
-    mOutput << startstr << "<param name=\"JOINT\" type=\"Name\"></param>" << endstr;
-
-    PopTag();
-    mOutput << startstr << "</accessor>" << endstr;
-
-    PopTag();
-    mOutput << startstr << "</technique_common>" << endstr;
-
-    PopTag();
-    mOutput << startstr << "</source>" << endstr;
-
-    std::vector<ai_real> bind_poses;
-    bind_poses.reserve(mesh->mNumBones * 16);
-    for(unsigned int i = 0; i < mesh->mNumBones; ++i)
-        for( unsigned int j = 0; j < 4; ++j)
-            bind_poses.insert(bind_poses.end(), mesh->mBones[i]->mOffsetMatrix[j], mesh->mBones[i]->mOffsetMatrix[j] + 4);
-
-    WriteFloatArray( idstr + "-skin-bind_poses", FloatType_Mat4x4, (const ai_real*) bind_poses.data(), bind_poses.size() / 16);
-
-    bind_poses.clear();
-    
-    std::vector<ai_real> skin_weights;
-    skin_weights.reserve(mesh->mNumVertices * mesh->mNumBones);
-    for( size_t i = 0; i < mesh->mNumBones; ++i)
-        for( size_t j = 0; j < mesh->mBones[i]->mNumWeights; ++j)
-            skin_weights.push_back(mesh->mBones[i]->mWeights[j].mWeight);
-
-    WriteFloatArray( idstr + "-skin-weights", FloatType_Weight, (const ai_real*) skin_weights.data(), skin_weights.size());
-
-    skin_weights.clear();
-
-    mOutput << startstr << "<joints>" << endstr;
-    PushTag();
-
-    mOutput << startstr << "<input semantic=\"JOINT\" source=\"#" << idstrEscaped << "-skin-joints\"></input>" << endstr;
-    mOutput << startstr << "<input semantic=\"INV_BIND_MATRIX\" source=\"#" << idstrEscaped << "-skin-bind_poses\"></input>" << endstr;
-
-    PopTag();
-    mOutput << startstr << "</joints>" << endstr;
-
-    mOutput << startstr << "<vertex_weights count=\"" << mesh->mNumVertices << "\">" << endstr;
-    PushTag();
-
-    mOutput << startstr << "<input semantic=\"JOINT\" source=\"#" << idstrEscaped << "-skin-joints\" offset=\"0\"></input>" << endstr;
-    mOutput << startstr << "<input semantic=\"WEIGHT\" source=\"#" << idstrEscaped << "-skin-weights\" offset=\"1\"></input>" << endstr;
-
-    mOutput << startstr << "<vcount>";
-
-    std::vector<ai_uint> num_influences(mesh->mNumVertices, (ai_uint)0);
-    for( size_t i = 0; i < mesh->mNumBones; ++i)
-        for( size_t j = 0; j < mesh->mBones[i]->mNumWeights; ++j)
-            ++num_influences[mesh->mBones[i]->mWeights[j].mVertexId];
-
-    for( size_t i = 0; i < mesh->mNumVertices; ++i)
-        mOutput << num_influences[i] << " ";
-
-    mOutput << "</vcount>" << endstr;
-
-    mOutput << startstr << "<v>";
-
-    ai_uint joint_weight_indices_length = 0;
-    std::vector<ai_uint> accum_influences;
-    accum_influences.reserve(num_influences.size());
-    for( size_t i = 0; i < num_influences.size(); ++i)
-    {
-        accum_influences.push_back(joint_weight_indices_length);
-        joint_weight_indices_length += num_influences[i];
-    }
-
-    ai_uint weight_index = 0;
-    std::vector<ai_int> joint_weight_indices(2 * joint_weight_indices_length, (ai_int)-1);
-    for( unsigned int i = 0; i < mesh->mNumBones; ++i)
-        for( unsigned j = 0; j < mesh->mBones[i]->mNumWeights; ++j)
-        {
-            unsigned int vId = mesh->mBones[i]->mWeights[j].mVertexId;
-            for( ai_uint k = 0; k < num_influences[vId]; ++k)
-            {
-                if (joint_weight_indices[2 * (accum_influences[vId] + k)] == -1)
-                {
-                    joint_weight_indices[2 * (accum_influences[vId] + k)] = i;
-                    joint_weight_indices[2 * (accum_influences[vId] + k) + 1] = weight_index;
-                    break;
-                }
-            }
-            ++weight_index;
-        }
-
-    for( size_t i = 0; i < joint_weight_indices.size(); ++i)
-        mOutput << joint_weight_indices[i] << " ";
-
-    num_influences.clear();
-    accum_influences.clear();
-    joint_weight_indices.clear();
-
-    mOutput << "</v>" << endstr;
-
-    PopTag();
-    mOutput << startstr << "</vertex_weights>" << endstr;
-
-    PopTag();
-    mOutput << startstr << "</skin>" << endstr;
-    
-    PopTag();
-    mOutput << startstr << "</controller>" << endstr;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Writes the geometry library
-void ColladaExporter::WriteGeometryLibrary()
-{
-    mOutput << startstr << "<library_geometries>" << endstr;
-    PushTag();
-
-    for( size_t a = 0; a < mScene->mNumMeshes; ++a)
-        WriteGeometry( a);
-
-    PopTag();
-    mOutput << startstr << "</library_geometries>" << endstr;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Writes the given mesh
-void ColladaExporter::WriteGeometry( size_t pIndex)
-{
-    const aiMesh* mesh = mScene->mMeshes[pIndex];
-    const std::string idstr = GetMeshId( pIndex);
-    const std::string idstrEscaped = XMLEscape(idstr);
-
-    if ( mesh->mNumFaces == 0 || mesh->mNumVertices == 0 )
-        return;
-
-    // opening tag
-    mOutput << startstr << "<geometry id=\"" << idstrEscaped << "\" name=\"" << idstrEscaped << "_name\" >" << endstr;
-    PushTag();
-
-    mOutput << startstr << "<mesh>" << endstr;
-    PushTag();
-
-    // Positions
-    WriteFloatArray( idstr + "-positions", FloatType_Vector, (ai_real*) mesh->mVertices, mesh->mNumVertices);
-    // Normals, if any
-    if( mesh->HasNormals() )
-        WriteFloatArray( idstr + "-normals", FloatType_Vector, (ai_real*) mesh->mNormals, mesh->mNumVertices);
-
-    // texture coords
-    for( size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a)
-    {
-        if( mesh->HasTextureCoords(static_cast<unsigned int>(a)) )
-        {
-            WriteFloatArray( idstr + "-tex" + to_string(a), mesh->mNumUVComponents[a] == 3 ? FloatType_TexCoord3 : FloatType_TexCoord2,
-                (ai_real*) mesh->mTextureCoords[a], mesh->mNumVertices);
-        }
-    }
-
-    // vertex colors
-    for( size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a)
-    {
-        if( mesh->HasVertexColors(static_cast<unsigned int>(a)) )
-            WriteFloatArray( idstr + "-color" + to_string(a), FloatType_Color, (ai_real*) mesh->mColors[a], mesh->mNumVertices);
-    }
-
-    // assemble vertex structure
-    // Only write input for POSITION since we will write other as shared inputs in polygon definition
-    mOutput << startstr << "<vertices id=\"" << idstrEscaped << "-vertices" << "\">" << endstr;
-    PushTag();
-    mOutput << startstr << "<input semantic=\"POSITION\" source=\"#" << idstrEscaped << "-positions\" />" << endstr;
-    PopTag();
-    mOutput << startstr << "</vertices>" << endstr;
-
-    // count the number of lines, triangles and polygon meshes
-    int countLines = 0;
-    int countPoly = 0;
-    for( size_t a = 0; a < mesh->mNumFaces; ++a )
-    {
-        if (mesh->mFaces[a].mNumIndices == 2) countLines++;
-        else if (mesh->mFaces[a].mNumIndices >= 3) countPoly++;
-    }
-
-    // lines
-    if (countLines)
-    {
-        mOutput << startstr << "<lines count=\"" << countLines << "\" material=\"defaultMaterial\">" << endstr;
-        PushTag();
-        mOutput << startstr << "<input offset=\"0\" semantic=\"VERTEX\" source=\"#" << idstrEscaped << "-vertices\" />" << endstr;
-        if( mesh->HasNormals() )
-            mOutput << startstr << "<input semantic=\"NORMAL\" source=\"#" << idstrEscaped << "-normals\" />" << endstr;
-        for( size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a )
-        {
-            if( mesh->HasTextureCoords(static_cast<unsigned int>(a)) )
-                mOutput << startstr << "<input semantic=\"TEXCOORD\" source=\"#" << idstrEscaped << "-tex" << a << "\" " << "set=\"" << a << "\""  << " />" << endstr;
-        }
-        for( size_t a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a )
-        {
-            if( mesh->HasVertexColors(static_cast<unsigned int>(a) ) )
-                mOutput << startstr << "<input semantic=\"COLOR\" source=\"#" << idstrEscaped << "-color" << a << "\" " << "set=\"" << a << "\""  << " />" << endstr;
-        }
-
-        mOutput << startstr << "<p>";
-        for( size_t a = 0; a < mesh->mNumFaces; ++a )
-        {
-            const aiFace& face = mesh->mFaces[a];
-            if (face.mNumIndices != 2) continue;
-            for( size_t b = 0; b < face.mNumIndices; ++b )
-                mOutput << face.mIndices[b] << " ";
-        }
-        mOutput << "</p>" << endstr;
-        PopTag();
-        mOutput << startstr << "</lines>" << endstr;
-    }
-
-    // triangle - don't use it, because compatibility problems
-
-    // polygons
-    if (countPoly)
-    {
-        mOutput << startstr << "<polylist count=\"" << countPoly << "\" material=\"defaultMaterial\">" << endstr;
-        PushTag();
-        mOutput << startstr << "<input offset=\"0\" semantic=\"VERTEX\" source=\"#" << idstrEscaped << "-vertices\" />" << endstr;
-        if( mesh->HasNormals() )
-            mOutput << startstr << "<input offset=\"0\" semantic=\"NORMAL\" source=\"#" << idstrEscaped << "-normals\" />" << endstr;
-        for( size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a )
-        {
-            if( mesh->HasTextureCoords(static_cast<unsigned int>(a)) )
-                mOutput << startstr << "<input offset=\"0\" semantic=\"TEXCOORD\" source=\"#" << idstrEscaped << "-tex" << a << "\" " << "set=\"" << a << "\""  << " />" << endstr;
-        }
-        for( size_t a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a )
-        {
-            if( mesh->HasVertexColors(static_cast<unsigned int>(a) ) )
-                mOutput << startstr << "<input offset=\"0\" semantic=\"COLOR\" source=\"#" << idstrEscaped << "-color" << a << "\" " << "set=\"" << a << "\""  << " />" << endstr;
-        }
-
-        mOutput << startstr << "<vcount>";
-        for( size_t a = 0; a < mesh->mNumFaces; ++a )
-        {
-            if (mesh->mFaces[a].mNumIndices < 3) continue;
-            mOutput << mesh->mFaces[a].mNumIndices << " ";
-        }
-        mOutput << "</vcount>" << endstr;
-
-        mOutput << startstr << "<p>";
-        for( size_t a = 0; a < mesh->mNumFaces; ++a )
-        {
-            const aiFace& face = mesh->mFaces[a];
-            if (face.mNumIndices < 3) continue;
-            for( size_t b = 0; b < face.mNumIndices; ++b )
-                mOutput << face.mIndices[b] << " ";
-        }
-        mOutput << "</p>" << endstr;
-        PopTag();
-        mOutput << startstr << "</polylist>" << endstr;
-    }
-
-    // closing tags
-    PopTag();
-    mOutput << startstr << "</mesh>" << endstr;
-    PopTag();
-    mOutput << startstr << "</geometry>" << endstr;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Writes a float array of the given type
-void ColladaExporter::WriteFloatArray( const std::string& pIdString, FloatDataType pType, const ai_real* pData, size_t pElementCount)
-{
-    size_t floatsPerElement = 0;
-    switch( pType )
-    {
-        case FloatType_Vector: floatsPerElement = 3; break;
-        case FloatType_TexCoord2: floatsPerElement = 2; break;
-        case FloatType_TexCoord3: floatsPerElement = 3; break;
-        case FloatType_Color: floatsPerElement = 3; break;
-        case FloatType_Mat4x4: floatsPerElement = 16; break;
-        case FloatType_Weight: floatsPerElement = 1; break;
-		case FloatType_Time: floatsPerElement = 1; break;
-        default:
-            return;
-    }
-
-    std::string arrayId = pIdString + "-array";
-
-    mOutput << startstr << "<source id=\"" << XMLEscape(pIdString) << "\" name=\"" << XMLEscape(pIdString) << "\">" << endstr;
-    PushTag();
-
-    // source array
-    mOutput << startstr << "<float_array id=\"" << XMLEscape(arrayId) << "\" count=\"" << pElementCount * floatsPerElement << "\"> ";
-    PushTag();
-
-    if( pType == FloatType_TexCoord2 )
-    {
-        for( size_t a = 0; a < pElementCount; ++a )
-        {
-            mOutput << pData[a*3+0] << " ";
-            mOutput << pData[a*3+1] << " ";
-        }
-    }
-    else if( pType == FloatType_Color )
-    {
-        for( size_t a = 0; a < pElementCount; ++a )
-        {
-            mOutput << pData[a*4+0] << " ";
-            mOutput << pData[a*4+1] << " ";
-            mOutput << pData[a*4+2] << " ";
-        }
-    }
-    else
-    {
-        for( size_t a = 0; a < pElementCount * floatsPerElement; ++a )
-            mOutput << pData[a] << " ";
-    }
-    mOutput << "</float_array>" << endstr;
-    PopTag();
-
-    // the usual Collada fun. Let's bloat it even more!
-    mOutput << startstr << "<technique_common>" << endstr;
-    PushTag();
-    mOutput << startstr << "<accessor count=\"" << pElementCount << "\" offset=\"0\" source=\"#" << arrayId << "\" stride=\"" << floatsPerElement << "\">" << endstr;
-    PushTag();
-
-    switch( pType )
-    {
-        case FloatType_Vector:
-            mOutput << startstr << "<param name=\"X\" type=\"float\" />" << endstr;
-            mOutput << startstr << "<param name=\"Y\" type=\"float\" />" << endstr;
-            mOutput << startstr << "<param name=\"Z\" type=\"float\" />" << endstr;
-            break;
-
-        case FloatType_TexCoord2:
-            mOutput << startstr << "<param name=\"S\" type=\"float\" />" << endstr;
-            mOutput << startstr << "<param name=\"T\" type=\"float\" />" << endstr;
-            break;
-
-        case FloatType_TexCoord3:
-            mOutput << startstr << "<param name=\"S\" type=\"float\" />" << endstr;
-            mOutput << startstr << "<param name=\"T\" type=\"float\" />" << endstr;
-            mOutput << startstr << "<param name=\"P\" type=\"float\" />" << endstr;
-            break;
-
-        case FloatType_Color:
-            mOutput << startstr << "<param name=\"R\" type=\"float\" />" << endstr;
-            mOutput << startstr << "<param name=\"G\" type=\"float\" />" << endstr;
-            mOutput << startstr << "<param name=\"B\" type=\"float\" />" << endstr;
-            break;
-
-        case FloatType_Mat4x4:
-            mOutput << startstr << "<param name=\"TRANSFORM\" type=\"float4x4\" />" << endstr;
-            break;
-
-        case FloatType_Weight:
-            mOutput << startstr << "<param name=\"WEIGHT\" type=\"float\" />" << endstr;
-            break;
-
-		// customized, add animation related
-		case FloatType_Time:
-			mOutput << startstr << "<param name=\"TIME\" type=\"float\" />" << endstr;
-			break;
-
-	}
-
-    PopTag();
-    mOutput << startstr << "</accessor>" << endstr;
-    PopTag();
-    mOutput << startstr << "</technique_common>" << endstr;
-    PopTag();
-    mOutput << startstr << "</source>" << endstr;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Writes the scene library
-void ColladaExporter::WriteSceneLibrary()
-{
-    const std::string scene_name_escaped = XMLEscape(mScene->mRootNode->mName.C_Str());
-
-    mOutput << startstr << "<library_visual_scenes>" << endstr;
-    PushTag();
-    mOutput << startstr << "<visual_scene id=\"" + scene_name_escaped + "\" name=\"" + scene_name_escaped + "\">" << endstr;
-    PushTag();
-
-    // start recursive write at the root node
-    for( size_t a = 0; a < mScene->mRootNode->mNumChildren; ++a )
-        WriteNode( mScene, mScene->mRootNode->mChildren[a]);
-
-    PopTag();
-    mOutput << startstr << "</visual_scene>" << endstr;
-    PopTag();
-    mOutput << startstr << "</library_visual_scenes>" << endstr;
-}
-// ------------------------------------------------------------------------------------------------
-void ColladaExporter::WriteAnimationLibrary(size_t pIndex)
-{
-	const aiAnimation * anim = mScene->mAnimations[pIndex];
-	
-	if ( anim->mNumChannels == 0 && anim->mNumMeshChannels == 0 && anim->mNumMorphMeshChannels ==0 )
-		return;
-	
-	const std::string animation_name_escaped = XMLEscape( anim->mName.C_Str() );
-	std::string idstr = anim->mName.C_Str();
-	std::string ending = std::string( "AnimId" ) + to_string(pIndex);
-	if (idstr.length() >= ending.length()) {
-		if (0 != idstr.compare (idstr.length() - ending.length(), ending.length(), ending)) {
-			idstr = idstr + ending;
-		}
-	} else {
-		idstr = idstr + ending;
-	}
-
-	const std::string idstrEscaped = XMLEscape(idstr);
-	
-	mOutput << startstr << "<animation id=\"" + idstrEscaped + "\" name=\"" + animation_name_escaped + "\">" << endstr;
-	PushTag();
-
-    std::string node_idstr;
-	for (size_t a = 0; a < anim->mNumChannels; ++a) {
-		const aiNodeAnim * nodeAnim = anim->mChannels[a];
-		
-		// sanity check
-		if ( nodeAnim->mNumPositionKeys != nodeAnim->mNumScalingKeys ||  nodeAnim->mNumPositionKeys != nodeAnim->mNumRotationKeys ) continue;
-		
-		{
-            node_idstr.clear();
-            node_idstr += nodeAnim->mNodeName.data;
-            node_idstr += std::string( "_matrix-input" );
-
-			std::vector<ai_real> frames;
-			for( size_t i = 0; i < nodeAnim->mNumPositionKeys; ++i) {
-				frames.push_back(static_cast<ai_real>(nodeAnim->mPositionKeys[i].mTime));
-			}
-			
-			WriteFloatArray( node_idstr , FloatType_Time, (const ai_real*) frames.data(), frames.size());
-			frames.clear();
-		}
-		
-		{
-            node_idstr.clear();
-
-            node_idstr += nodeAnim->mNodeName.data;
-            node_idstr += std::string("_matrix-output");
-			
-			std::vector<ai_real> keyframes;
-			keyframes.reserve(nodeAnim->mNumPositionKeys * 16);
-			for( size_t i = 0; i < nodeAnim->mNumPositionKeys; ++i) {
-				aiVector3D Scaling = nodeAnim->mScalingKeys[i].mValue;
-				aiMatrix4x4 ScalingM;  // identity
-				ScalingM[0][0] = Scaling.x; ScalingM[1][1] = Scaling.y; ScalingM[2][2] = Scaling.z;
-				
-				aiQuaternion RotationQ = nodeAnim->mRotationKeys[i].mValue;
-				aiMatrix4x4 s = aiMatrix4x4( RotationQ.GetMatrix() );
-				aiMatrix4x4 RotationM(s.a1, s.a2, s.a3, 0, s.b1, s.b2, s.b3, 0, s.c1, s.c2, s.c3, 0, 0, 0, 0, 1);
-				
-				aiVector3D Translation = nodeAnim->mPositionKeys[i].mValue;
-				aiMatrix4x4 TranslationM;	// identity
-				TranslationM[0][3] = Translation.x; TranslationM[1][3] = Translation.y; TranslationM[2][3] = Translation.z;
-				
-				// Combine the above transformations
-				aiMatrix4x4 mat = TranslationM * RotationM * ScalingM;
-				
-				for( unsigned int j = 0; j < 4; ++j) {
-					keyframes.insert(keyframes.end(), mat[j], mat[j] + 4);
-                }
-			}
-			
-			WriteFloatArray( node_idstr, FloatType_Mat4x4, (const ai_real*) keyframes.data(), keyframes.size() / 16);
-		}
-		
-		{
-			std::vector<std::string> names;
-			for ( size_t i = 0; i < nodeAnim->mNumPositionKeys; ++i) {
-				if ( nodeAnim->mPreState == aiAnimBehaviour_DEFAULT
-					|| nodeAnim->mPreState == aiAnimBehaviour_LINEAR
-					|| nodeAnim->mPreState == aiAnimBehaviour_REPEAT
-					) {
-					names.push_back( "LINEAR" );
-				} else if (nodeAnim->mPostState == aiAnimBehaviour_CONSTANT) {
-					names.push_back( "STEP" );
-				}
-			}
-			
-			const std::string node_idstr = nodeAnim->mNodeName.data + std::string("_matrix-interpolation");
-			std::string arrayId = node_idstr + "-array";
-			
-			mOutput << startstr << "<source id=\"" << XMLEscape(node_idstr) << "\">" << endstr;
-			PushTag();
-			
-			// source array
-			mOutput << startstr << "<Name_array id=\"" << XMLEscape(arrayId) << "\" count=\"" << names.size() << "\"> ";
-			for( size_t a = 0; a < names.size(); ++a ) {
-				mOutput << names[a] << " ";
-            }
-			mOutput << "</Name_array>" << endstr;
-			
-			mOutput << startstr << "<technique_common>" << endstr;
-			PushTag();
-
-			mOutput << startstr << "<accessor source=\"#" << XMLEscape(arrayId) << "\" count=\"" << names.size() << "\" stride=\"" << 1 << "\">" << endstr;
-			PushTag();
-			
-			mOutput << startstr << "<param name=\"INTERPOLATION\" type=\"name\"></param>" << endstr;
-			
-			PopTag();
-			mOutput << startstr << "</accessor>" << endstr;
-			
-			PopTag();
-			mOutput << startstr << "</technique_common>" << endstr;
-
-			PopTag();
-			mOutput << startstr << "</source>" << endstr;
-		}
-	}
-	
-	for (size_t a = 0; a < anim->mNumChannels; ++a) {
-		const aiNodeAnim * nodeAnim = anim->mChannels[a];
-		
-		{
-		// samplers
-			const std::string node_idstr = nodeAnim->mNodeName.data + std::string("_matrix-sampler");
-			mOutput << startstr << "<sampler id=\"" << XMLEscape(node_idstr) << "\">" << endstr;
-			PushTag();
-			
-			mOutput << startstr << "<input semantic=\"INPUT\" source=\"#" << XMLEscape( nodeAnim->mNodeName.data + std::string("_matrix-input") ) << "\"/>" << endstr;
-			mOutput << startstr << "<input semantic=\"OUTPUT\" source=\"#" << XMLEscape( nodeAnim->mNodeName.data + std::string("_matrix-output") ) << "\"/>" << endstr;
-			mOutput << startstr << "<input semantic=\"INTERPOLATION\" source=\"#" << XMLEscape( nodeAnim->mNodeName.data + std::string("_matrix-interpolation") ) << "\"/>" << endstr;
-			
-			PopTag();
-			mOutput << startstr << "</sampler>" << endstr;
-		}
-	}
-	
-	for (size_t a = 0; a < anim->mNumChannels; ++a) {
-		const aiNodeAnim * nodeAnim = anim->mChannels[a];
-		
-		{
-		// channels
-			mOutput << startstr << "<channel source=\"#" << XMLEscape( nodeAnim->mNodeName.data + std::string("_matrix-sampler") ) << "\" target=\"" << XMLEscape(nodeAnim->mNodeName.data) << "/matrix\"/>" << endstr;
-		}
-	}
-	
-	PopTag();
-	mOutput << startstr << "</animation>" << endstr;
-	
-}
-// ------------------------------------------------------------------------------------------------
-void ColladaExporter::WriteAnimationsLibrary()
-{
-	const std::string scene_name_escaped = XMLEscape(mScene->mRootNode->mName.C_Str());
-	
-	if ( mScene->mNumAnimations > 0 ) {
-		mOutput << startstr << "<library_animations>" << endstr;
-		PushTag();
-		
-		// start recursive write at the root node
-		for( size_t a = 0; a < mScene->mNumAnimations; ++a)
-			WriteAnimationLibrary( a );
-
-		PopTag();
-		mOutput << startstr << "</library_animations>" << endstr;
-	}
-}
-// ------------------------------------------------------------------------------------------------
-// Helper to find a bone by name in the scene
-aiBone* findBone( const aiScene* scene, const char * name) {
-    for (size_t m=0; m<scene->mNumMeshes; m++) {
-        aiMesh * mesh = scene->mMeshes[m];
-        for (size_t b=0; b<mesh->mNumBones; b++) {
-            aiBone * bone = mesh->mBones[b];
-            if (0 == strcmp(name, bone->mName.C_Str())) {
-                return bone;
-            }
-        }
-    }
-    return NULL;
-}
-
-// ------------------------------------------------------------------------------------------------
-const aiNode * findBoneNode( const aiNode* aNode, const aiBone* bone)
-{
-	if ( aNode && bone && aNode->mName == bone->mName ) {
-		return aNode;
-	}
-	
-	if ( aNode && bone ) {
-		for (unsigned int i=0; i < aNode->mNumChildren; ++i) {
-			aiNode * aChild = aNode->mChildren[i];
-			const aiNode * foundFromChild = 0;
-			if ( aChild ) {
-				foundFromChild = findBoneNode( aChild, bone );
-				if ( foundFromChild ) return foundFromChild;
-			}
-		}
-	}
-	
-	return NULL;
-}
-
-const aiNode * findSkeletonRootNode( const aiScene* scene, const aiMesh * mesh)
-{
-	std::set<const aiNode*> topParentBoneNodes;
-	if ( mesh && mesh->mNumBones > 0 ) {
-		for (unsigned int i=0; i < mesh->mNumBones; ++i) {
-			aiBone * bone = mesh->mBones[i];
-
-			const aiNode * node = findBoneNode( scene->mRootNode, bone);
-			if ( node ) {
-				while ( node->mParent && findBone(scene, node->mParent->mName.C_Str() ) != 0 ) {
-					node = node->mParent;
-				}
-				topParentBoneNodes.insert( node );
-			}
-		}
-	}
-	
-	if ( !topParentBoneNodes.empty() ) {
-		const aiNode * parentBoneNode = *topParentBoneNodes.begin();
-		if ( topParentBoneNodes.size() == 1 ) {
-			return parentBoneNode;
-		} else {
-			for (auto it : topParentBoneNodes) {
-				if ( it->mParent ) return it->mParent;
-			}
-			return parentBoneNode;
-		}
-	}
-	
-	return NULL;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Recursively writes the given node
-void ColladaExporter::WriteNode( const aiScene* pScene, aiNode* pNode)
-{
-    // the node must have a name
-    if (pNode->mName.length == 0)
-    {
-        std::stringstream ss;
-        ss << "Node_" << pNode;
-        pNode->mName.Set(ss.str());
-    }
-
-    // If the node is associated with a bone, it is a joint node (JOINT)
-    // otherwise it is a normal node (NODE)
-    const char * node_type;
-    bool is_joint, is_skeleton_root = false;
-    if (nullptr == findBone(pScene, pNode->mName.C_Str())) {
-        node_type = "NODE";
-        is_joint = false;
-    } else {
-        node_type = "JOINT";
-        is_joint = true;
-        if (!pNode->mParent || nullptr == findBone(pScene, pNode->mParent->mName.C_Str())) {
-            is_skeleton_root = true;
-        }
-    }
-
-    const std::string node_name_escaped = XMLEscape(pNode->mName.data);
-	mOutput << startstr << "<node ";
-	if(is_skeleton_root) {
-		mOutput << "id=\"" << node_name_escaped << "\" " << (is_joint ? "sid=\"" + node_name_escaped +"\"" : "") ; // For now, only support one skeleton in a scene.
-		mFoundSkeletonRootNodeID = node_name_escaped;
-	} else {
-		mOutput << "id=\"" << node_name_escaped << "\" " << (is_joint ? "sid=\"" + node_name_escaped +"\"": "") ;
-	}
-	
-    mOutput << " name=\"" << node_name_escaped
-            << "\" type=\"" << node_type
-            << "\">" << endstr;
-    PushTag();
-
-    // write transformation - we can directly put the matrix there
-    // TODO: (thom) decompose into scale - rot - quad to allow addressing it by animations afterwards
-    aiMatrix4x4 mat = pNode->mTransformation;
-
-    // If this node is a Camera node, the camera coordinate system needs to be multiplied in.
-    // When importing from Collada, the mLookAt is set to 0, 0, -1, and the node transform is unchanged.
-    // When importing from a different format, mLookAt is set to 0, 0, 1. Therefore, the local camera
-    // coordinate system must be changed to matche the Collada specification.
-    for (size_t i = 0; i<mScene->mNumCameras; i++){
-        if (mScene->mCameras[i]->mName == pNode->mName){
-            aiMatrix4x4 sourceView;
-            mScene->mCameras[i]->GetCameraMatrix(sourceView);
-
-            aiMatrix4x4 colladaView;
-            colladaView.a1 = colladaView.c3 = -1; // move into -z space.
-            mat *= (sourceView * colladaView);
-            break;
-        }
-    }
-	
-	// customized, sid should be 'matrix' to match with loader code.
-    //mOutput << startstr << "<matrix sid=\"transform\">";
-	mOutput << startstr << "<matrix sid=\"matrix\">";
-	
-    mOutput << mat.a1 << " " << mat.a2 << " " << mat.a3 << " " << mat.a4 << " ";
-    mOutput << mat.b1 << " " << mat.b2 << " " << mat.b3 << " " << mat.b4 << " ";
-    mOutput << mat.c1 << " " << mat.c2 << " " << mat.c3 << " " << mat.c4 << " ";
-    mOutput << mat.d1 << " " << mat.d2 << " " << mat.d3 << " " << mat.d4;
-    mOutput << "</matrix>" << endstr;
-
-    if(pNode->mNumMeshes==0){
-        //check if it is a camera node
-        for(size_t i=0; i<mScene->mNumCameras; i++){
-            if(mScene->mCameras[i]->mName == pNode->mName){
-                mOutput << startstr <<"<instance_camera url=\"#" << node_name_escaped << "-camera\"/>" << endstr;
-                break;
-            }
-        }
-        //check if it is a light node
-        for(size_t i=0; i<mScene->mNumLights; i++){
-            if(mScene->mLights[i]->mName == pNode->mName){
-                mOutput << startstr <<"<instance_light url=\"#" << node_name_escaped << "-light\"/>" << endstr;
-                break;
-            }
-        }
-
-    }else
-    // instance every geometry
-    for( size_t a = 0; a < pNode->mNumMeshes; ++a )
-    {
-        const aiMesh* mesh = mScene->mMeshes[pNode->mMeshes[a]];
-        // do not instantiate mesh if empty. I wonder how this could happen
-        if( mesh->mNumFaces == 0 || mesh->mNumVertices == 0 )
-            continue;
-
-        if( mesh->mNumBones == 0 )
-        {
-            mOutput << startstr << "<instance_geometry url=\"#" << XMLEscape(GetMeshId( pNode->mMeshes[a])) << "\">" << endstr;
-            PushTag();
-        }
-        else
-        {
-            mOutput << startstr
-                    << "<instance_controller url=\"#" << XMLEscape(GetMeshId( pNode->mMeshes[a])) << "-skin\">"
-                    << endstr;
-            PushTag();
-
-			// note! this mFoundSkeletonRootNodeID some how affects animation, it makes the mesh attaches to armature skeleton root node.
-			// use the first bone to find skeleton root
-			const aiNode * skeletonRootBoneNode = findSkeletonRootNode( pScene, mesh );
-			if ( skeletonRootBoneNode ) {
-				mFoundSkeletonRootNodeID = XMLEscape( skeletonRootBoneNode->mName.C_Str() );
-			}
-            mOutput << startstr << "<skeleton>#" << mFoundSkeletonRootNodeID << "</skeleton>" << endstr;
-        }
-        mOutput << startstr << "<bind_material>" << endstr;
-        PushTag();
-        mOutput << startstr << "<technique_common>" << endstr;
-        PushTag();
-        mOutput << startstr << "<instance_material symbol=\"defaultMaterial\" target=\"#" << XMLEscape(materials[mesh->mMaterialIndex].name) << "\">" << endstr;
-        PushTag();
-        for( size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a )
-        {
-            if( mesh->HasTextureCoords( static_cast<unsigned int>(a) ) )
-                // semantic       as in <texture texcoord=...>
-                // input_semantic as in <input semantic=...>
-                // input_set      as in <input set=...>
-                mOutput << startstr << "<bind_vertex_input semantic=\"CHANNEL" << a << "\" input_semantic=\"TEXCOORD\" input_set=\"" << a << "\"/>" << endstr;
-        }
-        PopTag();
-        mOutput << startstr << "</instance_material>" << endstr;
-        PopTag();
-        mOutput << startstr << "</technique_common>" << endstr;
-        PopTag();
-        mOutput << startstr << "</bind_material>" << endstr;
-        
-        PopTag();
-        if( mesh->mNumBones == 0)
-            mOutput << startstr << "</instance_geometry>" << endstr;
-        else
-            mOutput << startstr << "</instance_controller>" << endstr;
-    }
-
-    // recurse into subnodes
-    for( size_t a = 0; a < pNode->mNumChildren; ++a )
-        WriteNode( pScene, pNode->mChildren[a]);
-
-    PopTag();
-    mOutput << startstr << "</node>" << endstr;
-}
-
-#endif
-#endif
diff --git a/Engine/lib/assimp/code/Collada/ColladaExporter.h b/Engine/lib/assimp/code/Collada/ColladaExporter.h
deleted file mode 100644
index 0b4fa59a3..000000000
--- a/Engine/lib/assimp/code/Collada/ColladaExporter.h
+++ /dev/null
@@ -1,222 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file ColladaExporter.h
- * Declares the exporter class to write a scene to a Collada file
- */
-#ifndef AI_COLLADAEXPORTER_H_INC
-#define AI_COLLADAEXPORTER_H_INC
-
-#include <assimp/ai_assert.h>
-#include <assimp/material.h>
-#include <assimp/mesh.h>
-#include <assimp/light.h>
-#include <assimp/Exporter.hpp>
-#include <sstream>
-#include <vector>
-#include <map>
-
-#include <assimp/StringUtils.h>
-
-struct aiScene;
-struct aiNode;
-
-namespace Assimp
-{
-
-/// Helper class to export a given scene to a Collada file. Just for my personal
-/// comfort when implementing it.
-class ColladaExporter
-{
-public:
-    /// Constructor for a specific scene to export
-    ColladaExporter( const aiScene* pScene, IOSystem* pIOSystem, const std::string& path, const std::string& file);
-
-    /// Destructor
-    virtual ~ColladaExporter();
-
-protected:
-    /// Starts writing the contents
-    void WriteFile();
-
-    /// Writes the asset header
-    void WriteHeader();
-
-    /// Writes the embedded textures
-    void WriteTextures();
-
-    /// Writes the material setup
-    void WriteMaterials();
-
-    /// Writes the cameras library
-    void WriteCamerasLibrary();
-
-    // Write a camera entry
-    void WriteCamera(size_t pIndex);
-
-    /// Writes the cameras library
-    void WriteLightsLibrary();
-
-    // Write a camera entry
-    void WriteLight(size_t pIndex);
-    void WritePointLight(const aiLight *const light);
-    void WriteDirectionalLight(const aiLight *const light);
-    void WriteSpotLight(const aiLight *const light);
-    void WriteAmbienttLight(const aiLight *const light);
-
-    /// Writes the controller library
-    void WriteControllerLibrary();
-
-    /// Writes a skin controller of the given mesh
-    void WriteController( size_t pIndex);
-
-    /// Writes the geometry library
-    void WriteGeometryLibrary();
-
-    /// Writes the given mesh
-    void WriteGeometry( size_t pIndex);
-
-    //enum FloatDataType { FloatType_Vector, FloatType_TexCoord2, FloatType_TexCoord3, FloatType_Color, FloatType_Mat4x4, FloatType_Weight };
-    // customized to add animation related type
-	enum FloatDataType { FloatType_Vector, FloatType_TexCoord2, FloatType_TexCoord3, FloatType_Color, FloatType_Mat4x4, FloatType_Weight, FloatType_Time };
-
-    /// Writes a float array of the given type
-    void WriteFloatArray( const std::string& pIdString, FloatDataType pType, const ai_real* pData, size_t pElementCount);
-
-    /// Writes the scene library
-    void WriteSceneLibrary();
-
-	// customized, Writes the animation library
-	void WriteAnimationsLibrary();
-	void WriteAnimationLibrary( size_t pIndex);
-	std::string mFoundSkeletonRootNodeID = "skeleton_root";	 	// will be replaced by found node id in the WriteNode call.
-	
-    /// Recursively writes the given node
-    void WriteNode( const aiScene* scene, aiNode* pNode);
-
-    /// Enters a new xml element, which increases the indentation
-    void PushTag() { startstr.append( "  "); }
-    /// Leaves an element, decreasing the indentation
-    void PopTag() { 
-        ai_assert( startstr.length() > 1); 
-        startstr.erase( startstr.length() - 2); 
-    }
-
-    /// Creates a mesh ID for the given mesh
-    std::string GetMeshId( size_t pIndex) const {
-        return std::string( "meshId" ) + to_string(pIndex);
-    }
-
-public:
-    /// Stringstream to write all output into
-    std::stringstream mOutput;
-
-    /// The IOSystem for output
-    IOSystem* mIOSystem;
-
-    /// Path of the directory where the scene will be exported
-    const std::string mPath;
-
-    /// Name of the file (without extension) where the scene will be exported
-    const std::string mFile;
-
-    /// The scene to be written
-    const aiScene* mScene;
-    bool mSceneOwned;
-
-    /// current line start string, contains the current indentation for simple stream insertion
-    std::string startstr;
-    /// current line end string for simple stream insertion
-    std::string endstr;
-
-  // pair of color and texture - texture precedences color
-  struct Surface
-  {
-    bool exist;
-    aiColor4D color;
-    std::string texture;
-    size_t channel;
-    Surface() { exist = false; channel = 0; }
-  };
-
-  struct Property
-  {
-    bool exist;
-     ai_real value;
-     Property()
-         : exist(false)
-         , value(0.0)
-     {}
-  };
-
-  // summarize a material in an convenient way.
-  struct Material
-  {
-    std::string name;
-    std::string shading_model;
-    Surface ambient, diffuse, specular, emissive, reflective, transparent, normal;
-    Property shininess, transparency, index_refraction;
-
-    Material() {}
-  };
-
-  std::vector<Material> materials;
-
-  std::map<unsigned int, std::string> textures;
-
-public:
-  /// Dammit C++ - y u no compile two-pass? No I have to add all methods below the struct definitions
-  /// Reads a single surface entry from the given material keys
-  void ReadMaterialSurface( Surface& poSurface, const aiMaterial* pSrcMat, aiTextureType pTexture, const char* pKey, size_t pType, size_t pIndex);
-  /// Writes an image entry for the given surface
-  void WriteImageEntry( const Surface& pSurface, const std::string& pNameAdd);
-  /// Writes the two parameters necessary for referencing a texture in an effect entry
-  void WriteTextureParamEntry( const Surface& pSurface, const std::string& pTypeName, const std::string& pMatName);
-  /// Writes a color-or-texture entry into an effect definition
-  void WriteTextureColorEntry( const Surface& pSurface, const std::string& pTypeName, const std::string& pImageName);
-  /// Writes a scalar property
-  void WriteFloatEntry( const Property& pProperty, const std::string& pTypeName);
-};
-
-}
-
-#endif // !! AI_COLLADAEXPORTER_H_INC
diff --git a/Engine/lib/assimp/code/Collada/ColladaHelper.h b/Engine/lib/assimp/code/Collada/ColladaHelper.h
deleted file mode 100644
index 66cff2d20..000000000
--- a/Engine/lib/assimp/code/Collada/ColladaHelper.h
+++ /dev/null
@@ -1,701 +0,0 @@
-/** Helper structures for the Collada loader */
-
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-#ifndef AI_COLLADAHELPER_H_INC
-#define AI_COLLADAHELPER_H_INC
-
-#include <map>
-#include <vector>
-#include <stdint.h>
-#include <assimp/light.h>
-#include <assimp/mesh.h>
-#include <assimp/material.h>
-
-struct aiMaterial;
-
-namespace Assimp    {
-namespace Collada       {
-
-/** Collada file versions which evolved during the years ... */
-enum FormatVersion
-{
-    FV_1_5_n,
-    FV_1_4_n,
-    FV_1_3_n
-};
-
-
-/** Transformation types that can be applied to a node */
-enum TransformType
-{
-    TF_LOOKAT,
-    TF_ROTATE,
-    TF_TRANSLATE,
-    TF_SCALE,
-    TF_SKEW,
-    TF_MATRIX
-};
-
-/** Different types of input data to a vertex or face */
-enum InputType
-{
-    IT_Invalid,
-    IT_Vertex,  // special type for per-index data referring to the <vertices> element carrying the per-vertex data.
-    IT_Position,
-    IT_Normal,
-    IT_Texcoord,
-    IT_Color,
-    IT_Tangent,
-    IT_Bitangent
-};
-
-/** Supported controller types */
-enum ControllerType
-{
-    Skin,
-    Morph
-};
-
-/** Supported morph methods */
-enum MorphMethod
-{
-    Normalized,
-    Relative
-};
-
-
-/** Contains all data for one of the different transformation types */
-struct Transform
-{
-    std::string mID;  ///< SID of the transform step, by which anim channels address their target node
-    TransformType mType;
-    ai_real f[16]; ///< Interpretation of data depends on the type of the transformation
-};
-
-/** A collada camera. */
-struct Camera
-{
-    Camera()
-        :   mOrtho  (false)
-        ,   mHorFov (10e10f)
-        ,   mVerFov (10e10f)
-        ,   mAspect (10e10f)
-        ,   mZNear  (0.1f)
-        ,   mZFar   (1000.f)
-    {}
-
-    // Name of camera
-    std::string mName;
-
-    // True if it is an orthografic camera
-    bool mOrtho;
-
-    //! Horizontal field of view in degrees
-    ai_real mHorFov;
-
-    //! Vertical field of view in degrees
-    ai_real mVerFov;
-
-    //! Screen aspect
-    ai_real mAspect;
-
-    //! Near& far z
-    ai_real mZNear, mZFar;
-};
-
-#define ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET 1e9f
-
-/** A collada light source. */
-struct Light
-{
-    Light()
-        :   mType            (aiLightSource_UNDEFINED)
-        ,   mAttConstant     (1.f)
-        ,   mAttLinear       (0.f)
-        ,   mAttQuadratic    (0.f)
-        ,   mFalloffAngle    (180.f)
-        ,   mFalloffExponent (0.f)
-        ,   mPenumbraAngle   (ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET)
-        ,   mOuterAngle      (ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET)
-        ,   mIntensity       (1.f)
-    {}
-
-    //! Type of the light source aiLightSourceType + ambient
-    unsigned int mType;
-
-    //! Color of the light
-    aiColor3D mColor;
-
-    //! Light attenuation
-    ai_real mAttConstant,mAttLinear,mAttQuadratic;
-
-    //! Spot light falloff
-    ai_real mFalloffAngle;
-    ai_real mFalloffExponent;
-
-    // -----------------------------------------------------
-    // FCOLLADA extension from here
-
-    //! ... related stuff from maja and max extensions
-    ai_real mPenumbraAngle;
-    ai_real mOuterAngle;
-
-    //! Common light intensity
-    ai_real mIntensity;
-};
-
-/** Short vertex index description */
-struct InputSemanticMapEntry
-{
-    InputSemanticMapEntry()
-        :   mSet(0)
-        ,   mType(IT_Invalid)
-    {}
-
-    //! Index of set, optional
-    unsigned int mSet;
-
-    //! Type of referenced vertex input
-    InputType mType;
-};
-
-/** Table to map from effect to vertex input semantics */
-struct SemanticMappingTable
-{
-    //! Name of material
-    std::string mMatName;
-
-    //! List of semantic map commands, grouped by effect semantic name
-    std::map<std::string, InputSemanticMapEntry> mMap;
-
-    //! For std::find
-    bool operator == (const std::string& s) const {
-        return s == mMatName;
-    }
-};
-
-/** A reference to a mesh inside a node, including materials assigned to the various subgroups.
- * The ID refers to either a mesh or a controller which specifies the mesh
- */
-struct MeshInstance
-{
-    ///< ID of the mesh or controller to be instanced
-    std::string mMeshOrController;
-
-    ///< Map of materials by the subgroup ID they're applied to
-    std::map<std::string, SemanticMappingTable> mMaterials;
-};
-
-/** A reference to a camera inside a node*/
-struct CameraInstance
-{
-     ///< ID of the camera
-    std::string mCamera;
-};
-
-/** A reference to a light inside a node*/
-struct LightInstance
-{
-     ///< ID of the camera
-    std::string mLight;
-};
-
-/** A reference to a node inside a node*/
-struct NodeInstance
-{
-     ///< ID of the node
-    std::string mNode;
-};
-
-/** A node in a scene hierarchy */
-struct Node
-{
-    std::string mName;
-    std::string mID;
-    std::string mSID;
-    Node* mParent;
-    std::vector<Node*> mChildren;
-
-    /** Operations in order to calculate the resulting transformation to parent. */
-    std::vector<Transform> mTransforms;
-
-    /** Meshes at this node */
-    std::vector<MeshInstance> mMeshes;
-
-    /** Lights at this node */
-    std::vector<LightInstance> mLights;
-
-    /** Cameras at this node */
-    std::vector<CameraInstance> mCameras;
-
-    /** Node instances at this node */
-    std::vector<NodeInstance> mNodeInstances;
-
-    /** Root-nodes: Name of primary camera, if any */
-    std::string mPrimaryCamera;
-
-    //! Constructor. Begin with a zero parent
-    Node()
-    : mParent( nullptr ){
-        // empty
-    }
-
-    //! Destructor: delete all children subsequently
-    ~Node() {
-        for( std::vector<Node*>::iterator it = mChildren.begin(); it != mChildren.end(); ++it)
-            delete *it;
-    }
-};
-
-/** Data source array: either floats or strings */
-struct Data
-{
-    bool mIsStringArray;
-    std::vector<ai_real> mValues;
-    std::vector<std::string> mStrings;
-};
-
-/** Accessor to a data array */
-struct Accessor
-{
-    size_t mCount;   // in number of objects
-    size_t mSize;    // size of an object, in elements (floats or strings, mostly 1)
-    size_t mOffset;  // in number of values
-    size_t mStride;  // Stride in number of values
-    std::vector<std::string> mParams; // names of the data streams in the accessors. Empty string tells to ignore.
-    size_t mSubOffset[4]; // Suboffset inside the object for the common 4 elements. For a vector, that's XYZ, for a color RGBA and so on.
-                          // For example, SubOffset[0] denotes which of the values inside the object is the vector X component.
-    std::string mSource;   // URL of the source array
-    mutable const Data* mData; // Pointer to the source array, if resolved. NULL else
-
-    Accessor()
-    {
-        mCount = 0; mSize = 0; mOffset = 0; mStride = 0; mData = NULL;
-        mSubOffset[0] = mSubOffset[1] = mSubOffset[2] = mSubOffset[3] = 0;
-    }
-};
-
-/** A single face in a mesh */
-struct Face
-{
-    std::vector<size_t> mIndices;
-};
-
-/** An input channel for mesh data, referring to a single accessor */
-struct InputChannel
-{
-    InputType mType;      // Type of the data
-    size_t mIndex;        // Optional index, if multiple sets of the same data type are given
-    size_t mOffset;       // Index offset in the indices array of per-face indices. Don't ask, can't explain that any better.
-    std::string mAccessor; // ID of the accessor where to read the actual values from.
-    mutable const Accessor* mResolved; // Pointer to the accessor, if resolved. NULL else
-
-    InputChannel() { mType = IT_Invalid; mIndex = 0; mOffset = 0; mResolved = NULL; }
-};
-
-/** Subset of a mesh with a certain material */
-struct SubMesh
-{
-    std::string mMaterial; ///< subgroup identifier
-    size_t mNumFaces; ///< number of faces in this submesh
-};
-
-/** Contains data for a single mesh */
-struct Mesh
-{
-    Mesh()
-    {
-        for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS;++i)
-            mNumUVComponents[i] = 2;
-    }
-
-    std::string mName;
-
-    // just to check if there's some sophisticated addressing involved...
-    // which we don't support, and therefore should warn about.
-    std::string mVertexID;
-
-    // Vertex data addressed by vertex indices
-    std::vector<InputChannel> mPerVertexData;
-
-    // actual mesh data, assembled on encounter of a <p> element. Verbose format, not indexed
-    std::vector<aiVector3D> mPositions;
-    std::vector<aiVector3D> mNormals;
-    std::vector<aiVector3D> mTangents;
-    std::vector<aiVector3D> mBitangents;
-    std::vector<aiVector3D> mTexCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS];
-    std::vector<aiColor4D>  mColors[AI_MAX_NUMBER_OF_COLOR_SETS];
-
-    unsigned int mNumUVComponents[AI_MAX_NUMBER_OF_TEXTURECOORDS];
-
-    // Faces. Stored are only the number of vertices for each face.
-    // 1 == point, 2 == line, 3 == triangle, 4+ == poly
-    std::vector<size_t> mFaceSize;
-
-    // Position indices for all faces in the sequence given in mFaceSize -
-    // necessary for bone weight assignment
-    std::vector<size_t> mFacePosIndices;
-
-    // Submeshes in this mesh, each with a given material
-    std::vector<SubMesh> mSubMeshes;
-};
-
-/** Which type of primitives the ReadPrimitives() function is going to read */
-enum PrimitiveType
-{
-    Prim_Invalid,
-    Prim_Lines,
-    Prim_LineStrip,
-    Prim_Triangles,
-    Prim_TriStrips,
-    Prim_TriFans,
-    Prim_Polylist,
-    Prim_Polygon
-};
-
-/** A skeleton controller to deform a mesh with the use of joints */
-struct Controller
-{
-    // controller type
-    ControllerType mType;
-
-    // Morphing method if type is Morph
-    MorphMethod mMethod;
-
-    // the URL of the mesh deformed by the controller.
-    std::string mMeshId;
-
-    // accessor URL of the joint names
-    std::string mJointNameSource;
-
-    ///< The bind shape matrix, as array of floats. I'm not sure what this matrix actually describes, but it can't be ignored in all cases
-    ai_real mBindShapeMatrix[16];
-
-    // accessor URL of the joint inverse bind matrices
-    std::string mJointOffsetMatrixSource;
-
-    // input channel: joint names.
-    InputChannel mWeightInputJoints;
-    // input channel: joint weights
-    InputChannel mWeightInputWeights;
-
-    // Number of weights per vertex.
-    std::vector<size_t> mWeightCounts;
-
-    // JointIndex-WeightIndex pairs for all vertices
-    std::vector< std::pair<size_t, size_t> > mWeights;
-
-    std::string mMorphTarget;
-    std::string mMorphWeight;
-};
-
-/** A collada material. Pretty much the only member is a reference to an effect. */
-struct Material
-{
-    std::string mName;
-    std::string mEffect;
-};
-
-/** Type of the effect param */
-enum ParamType
-{
-    Param_Sampler,
-    Param_Surface
-};
-
-/** A param for an effect. Might be of several types, but they all just refer to each other, so I summarize them */
-struct EffectParam
-{
-    ParamType mType;
-    std::string mReference; // to which other thing the param is referring to.
-};
-
-/** Shading type supported by the standard effect spec of Collada */
-enum ShadeType
-{
-    Shade_Invalid,
-    Shade_Constant,
-    Shade_Lambert,
-    Shade_Phong,
-    Shade_Blinn
-};
-
-/** Represents a texture sampler in collada */
-struct Sampler
-{
-    Sampler()
-        :   mWrapU      (true)
-        ,   mWrapV      (true)
-        ,   mMirrorU    ()
-        ,   mMirrorV    ()
-        ,   mOp         (aiTextureOp_Multiply)
-        ,   mUVId       (UINT_MAX)
-        ,   mWeighting  (1.f)
-        ,   mMixWithPrevious (1.f)
-    {}
-
-    /** Name of image reference
-     */
-    std::string mName;
-
-    /** Wrap U?
-     */
-    bool mWrapU;
-
-    /** Wrap V?
-     */
-    bool mWrapV;
-
-    /** Mirror U?
-     */
-    bool mMirrorU;
-
-    /** Mirror V?
-     */
-    bool mMirrorV;
-
-    /** Blend mode
-     */
-    aiTextureOp mOp;
-
-    /** UV transformation
-     */
-    aiUVTransform mTransform;
-
-    /** Name of source UV channel
-     */
-    std::string mUVChannel;
-
-    /** Resolved UV channel index or UINT_MAX if not known
-     */
-    unsigned int mUVId;
-
-    // OKINO/MAX3D extensions from here
-    // -------------------------------------------------------
-
-    /** Weighting factor
-     */
-    ai_real mWeighting;
-
-    /** Mixing factor from OKINO
-     */
-    ai_real mMixWithPrevious;
-};
-
-/** A collada effect. Can contain about anything according to the Collada spec,
-    but we limit our version to a reasonable subset. */
-struct Effect
-{
-    // Shading mode
-    ShadeType mShadeType;
-
-    // Colors
-    aiColor4D mEmissive, mAmbient, mDiffuse, mSpecular,
-        mTransparent, mReflective;
-
-    // Textures
-    Sampler mTexEmissive, mTexAmbient, mTexDiffuse, mTexSpecular,
-        mTexTransparent, mTexBump, mTexReflective;
-
-    // Scalar factory
-    ai_real mShininess, mRefractIndex, mReflectivity;
-    ai_real mTransparency;
-    bool mHasTransparency;
-    bool mRGBTransparency;
-    bool mInvertTransparency;
-
-    // local params referring to each other by their SID
-    typedef std::map<std::string, Collada::EffectParam> ParamLibrary;
-    ParamLibrary mParams;
-
-    // MAX3D extensions
-    // ---------------------------------------------------------
-    // Double-sided?
-    bool mDoubleSided, mWireframe, mFaceted;
-
-    Effect()
-        : mShadeType    (Shade_Phong)
-        , mEmissive     ( 0, 0, 0, 1)
-        , mAmbient      ( 0.1f, 0.1f, 0.1f, 1)
-        , mDiffuse      ( 0.6f, 0.6f, 0.6f, 1)
-        , mSpecular     ( 0.4f, 0.4f, 0.4f, 1)
-        , mTransparent  ( 0, 0, 0, 1)
-        , mShininess    (10.0f)
-        , mRefractIndex (1.f)
-        , mReflectivity (0.f)
-        , mTransparency (1.f)
-        , mHasTransparency (false)
-        , mRGBTransparency(false)
-        , mInvertTransparency(false)
-        , mDoubleSided  (false)
-        , mWireframe    (false)
-        , mFaceted      (false)
-    {
-    }
-};
-
-/** An image, meaning texture */
-struct Image
-{
-    std::string mFileName;
-
-    /** Embedded image data */
-    std::vector<uint8_t> mImageData;
-
-    /** File format hint ofembedded image data */
-    std::string mEmbeddedFormat;
-};
-
-/** An animation channel. */
-struct AnimationChannel
-{
-    /** URL of the data to animate. Could be about anything, but we support only the
-     * "NodeID/TransformID.SubElement" notation
-     */
-    std::string mTarget;
-
-    /** Source URL of the time values. Collada calls them "input". Meh. */
-    std::string mSourceTimes;
-    /** Source URL of the value values. Collada calls them "output". */
-    std::string mSourceValues;
-    /** Source URL of the IN_TANGENT semantic values. */
-    std::string mInTanValues;
-    /** Source URL of the OUT_TANGENT semantic values. */
-    std::string mOutTanValues;
-    /** Source URL of the INTERPOLATION semantic values. */
-    std::string mInterpolationValues;
-};
-
-/** An animation. Container for 0-x animation channels or 0-x animations */
-struct Animation
-{
-    /** Anim name */
-    std::string mName;
-
-    /** the animation channels, if any */
-    std::vector<AnimationChannel> mChannels;
-
-    /** the sub-animations, if any */
-    std::vector<Animation*> mSubAnims;
-
-    /** Destructor */
-    ~Animation()
-    {
-        for( std::vector<Animation*>::iterator it = mSubAnims.begin(); it != mSubAnims.end(); ++it)
-            delete *it;
-    }
-
-	/** Collect all channels in the animation hierarchy into a single channel list. */
-	void CollectChannelsRecursively(std::vector<AnimationChannel> &channels)
-	{
-		channels.insert(channels.end(), mChannels.begin(), mChannels.end());
-
-		for (std::vector<Animation*>::iterator it = mSubAnims.begin(); it != mSubAnims.end(); ++it)
-		{
-			Animation *pAnim = (*it);
-
-			pAnim->CollectChannelsRecursively(channels);
-		}
-	}
-
-	/** Combine all single-channel animations' channel into the same (parent) animation channel list. */
-	void CombineSingleChannelAnimations()
-	{
-		CombineSingleChannelAnimationsRecursively(this);
-	}
-
-	void CombineSingleChannelAnimationsRecursively(Animation *pParent)
-	{
-		for (std::vector<Animation*>::iterator it = pParent->mSubAnims.begin(); it != pParent->mSubAnims.end();)
-		{
-			Animation *anim = *it;
-
-			CombineSingleChannelAnimationsRecursively(anim);
-
-			if (anim->mChannels.size() == 1)
-			{
-				pParent->mChannels.push_back(anim->mChannels[0]);
-
-				it = pParent->mSubAnims.erase(it);
-
-				delete anim;
-			}
-			else
-			{
-				++it;
-			}
-		}
-	}
-};
-
-/** Description of a collada animation channel which has been determined to affect the current node */
-struct ChannelEntry
-{
-    const Collada::AnimationChannel* mChannel; ///> the source channel
-    std::string mTargetId;
-    std::string mTransformId;   // the ID of the transformation step of the node which is influenced
-    size_t mTransformIndex; // Index into the node's transform chain to apply the channel to
-    size_t mSubElement; // starting index inside the transform data
-
-    // resolved data references
-    const Collada::Accessor* mTimeAccessor; ///> Collada accessor to the time values
-    const Collada::Data* mTimeData; ///> Source data array for the time values
-    const Collada::Accessor* mValueAccessor; ///> Collada accessor to the key value values
-    const Collada::Data* mValueData; ///> Source datat array for the key value values
-
-    ChannelEntry()
-      : mChannel()
-      , mTransformIndex()
-      , mSubElement()
-      , mTimeAccessor()
-      , mTimeData()
-      , mValueAccessor()
-      , mValueData()
-   {}
-};
-
-} // end of namespace Collada
-} // end of namespace Assimp
-
-#endif // AI_COLLADAHELPER_H_INC
diff --git a/Engine/lib/assimp/code/Collada/ColladaParser.cpp b/Engine/lib/assimp/code/Collada/ColladaParser.cpp
deleted file mode 100644
index 646ec473d..000000000
--- a/Engine/lib/assimp/code/Collada/ColladaParser.cpp
+++ /dev/null
@@ -1,3409 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-/** @file ColladaParser.cpp
- *  @brief Implementation of the Collada parser helper
- */
-
-#ifndef ASSIMP_BUILD_NO_COLLADA_IMPORTER
-
-#include <sstream>
-#include <stdarg.h>
-#include "ColladaParser.h"
-#include <assimp/fast_atof.h>
-#include <assimp/ParsingUtils.h>
-#include <assimp/StringUtils.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/IOSystem.hpp>
-#include <assimp/light.h>
-#include <assimp/TinyFormatter.h>
-#include <assimp/ZipArchiveIOSystem.h>
-
-#include <memory>
-
-using namespace Assimp;
-using namespace Assimp::Collada;
-using namespace Assimp::Formatter;
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-ColladaParser::ColladaParser(IOSystem* pIOHandler, const std::string& pFile)
-    : mFileName(pFile)
-    , mReader(nullptr)
-    , mDataLibrary()
-    , mAccessorLibrary()
-    , mMeshLibrary()
-    , mNodeLibrary()
-    , mImageLibrary()
-    , mEffectLibrary()
-    , mMaterialLibrary()
-    , mLightLibrary()
-    , mCameraLibrary()
-    , mControllerLibrary()
-    , mRootNode(nullptr)
-    , mAnims()
-    , mUnitSize(1.0f)
-    , mUpDirection(UP_Y)
-    , mFormat(FV_1_5_n)    // We assume the newest file format by default
-{
-    // validate io-handler instance
-    if (nullptr == pIOHandler) {
-        throw DeadlyImportError("IOSystem is NULL.");
-    }
-
-    std::unique_ptr<IOStream> daefile;
-    std::unique_ptr<ZipArchiveIOSystem> zip_archive;
-
-    // Determine type
-    std::string extension = BaseImporter::GetExtension(pFile);
-    if (extension != "dae") {
-        zip_archive.reset(new ZipArchiveIOSystem(pIOHandler, pFile));
-    }
-
-    if (zip_archive && zip_archive->isOpen()) {
-        std::string dae_filename = ReadZaeManifest(*zip_archive);
-
-        if (dae_filename.empty()) {
-            ThrowException(std::string("Invalid ZAE"));
-        }
-
-        daefile.reset(zip_archive->Open(dae_filename.c_str()));
-        if (daefile == nullptr) {
-            ThrowException(std::string("Invalid ZAE manifest: '") + std::string(dae_filename) + std::string("' is missing"));
-        }
-    }
-    else {
-        // attempt to open the file directly
-        daefile.reset(pIOHandler->Open(pFile));
-        if (daefile.get() == nullptr) {
-            throw DeadlyImportError("Failed to open file '" + pFile + "'.");
-        }
-    }
-
-    // generate a XML reader for it
-    std::unique_ptr<CIrrXML_IOStreamReader> mIOWrapper(new CIrrXML_IOStreamReader(daefile.get()));
-    mReader = irr::io::createIrrXMLReader(mIOWrapper.get());
-    if (!mReader) {
-        ThrowException("Unable to read file, malformed XML");
-    }
-
-    // start reading
-    ReadContents();
-
-    // read embedded textures
-    if (zip_archive && zip_archive->isOpen()) {
-        ReadEmbeddedTextures(*zip_archive);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-ColladaParser::~ColladaParser()
-{
-    delete mReader;
-    for (NodeLibrary::iterator it = mNodeLibrary.begin(); it != mNodeLibrary.end(); ++it)
-        delete it->second;
-    for (MeshLibrary::iterator it = mMeshLibrary.begin(); it != mMeshLibrary.end(); ++it)
-        delete it->second;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Read a ZAE manifest and return the filename to attempt to open
-std::string ColladaParser::ReadZaeManifest(ZipArchiveIOSystem &zip_archive) {
-    // Open the manifest
-    std::unique_ptr<IOStream> manifestfile(zip_archive.Open("manifest.xml"));
-    if (manifestfile == nullptr)
-    {
-        // No manifest, hope there is only one .DAE inside
-        std::vector<std::string> file_list;
-        zip_archive.getFileListExtension(file_list, "dae");
-
-        if (file_list.empty())
-            return std::string();
-
-        return file_list.front();
-    }
-
-    std::unique_ptr<CIrrXML_IOStreamReader> mIOWrapper(new CIrrXML_IOStreamReader(manifestfile.get()));
-    std::unique_ptr<irr::io::IrrXMLReader> manifest_reader(irr::io::createIrrXMLReader(mIOWrapper.get()));
-
-    while (manifest_reader->read())
-    {
-        // find the manifest "dae_root" element
-        if (manifest_reader->getNodeType() == irr::io::EXN_ELEMENT)
-        {
-            if (::strcmp(manifest_reader->getNodeName(), "dae_root") == 0)
-            {
-                if (!manifest_reader->read())
-                    return std::string();
-                if (manifest_reader->getNodeType() != irr::io::EXN_TEXT && manifest_reader->getNodeType() != irr::io::EXN_CDATA)
-                    return std::string();
-
-                const char* filepath = manifest_reader->getNodeData();
-                if (filepath == nullptr)
-                    return std::string();
-
-                return std::string(filepath);
-            }
-        }
-    }
-    return std::string();
-}
-
-// ------------------------------------------------------------------------------------------------
-// Read bool from text contents of current element
-bool ColladaParser::ReadBoolFromTextContent()
-{
-    const char* cur = GetTextContent();
-    return (!ASSIMP_strincmp(cur, "true", 4) || '0' != *cur);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Read float from text contents of current element
-ai_real ColladaParser::ReadFloatFromTextContent()
-{
-    const char* cur = GetTextContent();
-    return fast_atof(cur);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the contents of the file
-void ColladaParser::ReadContents()
-{
-    while (mReader->read())
-    {
-        // handle the root element "COLLADA"
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
-        {
-            if (IsElement("COLLADA"))
-            {
-                // check for 'version' attribute
-                const int attrib = TestAttribute("version");
-                if (attrib != -1) {
-                    const char* version = mReader->getAttributeValue(attrib);
-
-                    if (!::strncmp(version, "1.5", 3)) {
-                        mFormat = FV_1_5_n;
-                        ASSIMP_LOG_DEBUG("Collada schema version is 1.5.n");
-                    }
-                    else if (!::strncmp(version, "1.4", 3)) {
-                        mFormat = FV_1_4_n;
-                        ASSIMP_LOG_DEBUG("Collada schema version is 1.4.n");
-                    }
-                    else if (!::strncmp(version, "1.3", 3)) {
-                        mFormat = FV_1_3_n;
-                        ASSIMP_LOG_DEBUG("Collada schema version is 1.3.n");
-                    }
-                }
-
-                ReadStructure();
-            }
-            else
-            {
-                ASSIMP_LOG_DEBUG_F("Ignoring global element <", mReader->getNodeName(), ">.");
-                SkipElement();
-            }
-        }
-        else
-        {
-            // skip everything else silently
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the structure of the file
-void ColladaParser::ReadStructure()
-{
-    while (mReader->read())
-    {
-        // beginning of elements
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
-        {
-            if (IsElement("asset"))
-                ReadAssetInfo();
-            else if (IsElement("library_animations"))
-                ReadAnimationLibrary();
-            else if (IsElement("library_animation_clips"))
-                ReadAnimationClipLibrary();
-            else if (IsElement("library_controllers"))
-                ReadControllerLibrary();
-            else if (IsElement("library_images"))
-                ReadImageLibrary();
-            else if (IsElement("library_materials"))
-                ReadMaterialLibrary();
-            else if (IsElement("library_effects"))
-                ReadEffectLibrary();
-            else if (IsElement("library_geometries"))
-                ReadGeometryLibrary();
-            else if (IsElement("library_visual_scenes"))
-                ReadSceneLibrary();
-            else if (IsElement("library_lights"))
-                ReadLightLibrary();
-            else if (IsElement("library_cameras"))
-                ReadCameraLibrary();
-            else if (IsElement("library_nodes"))
-                ReadSceneNode(NULL); /* some hacking to reuse this piece of code */
-            else if (IsElement("scene"))
-                ReadScene();
-            else
-                SkipElement();
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
-        {
-            break;
-        }
-    }
-
-    PostProcessRootAnimations();
-    PostProcessControllers();
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads asset information such as coordinate system information and legal blah
-void ColladaParser::ReadAssetInfo()
-{
-    if (mReader->isEmptyElement())
-        return;
-
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
-        {
-            if (IsElement("unit"))
-            {
-                // read unit data from the element's attributes
-                const int attrIndex = TestAttribute("meter");
-                if (attrIndex == -1) {
-                    mUnitSize = 1.f;
-                }
-                else {
-                    mUnitSize = mReader->getAttributeValueAsFloat(attrIndex);
-                }
-
-                // consume the trailing stuff
-                if (!mReader->isEmptyElement())
-                    SkipElement();
-            }
-            else if (IsElement("up_axis"))
-            {
-                // read content, strip whitespace, compare
-                const char* content = GetTextContent();
-                if (strncmp(content, "X_UP", 4) == 0)
-                    mUpDirection = UP_X;
-                else if (strncmp(content, "Z_UP", 4) == 0)
-                    mUpDirection = UP_Z;
-                else
-                    mUpDirection = UP_Y;
-
-                // check element end
-                TestClosing("up_axis");
-            }
-            else if (IsElement("contributor"))
-            {
-                ReadContributorInfo();
-            }
-            else
-            {
-                ReadMetaDataItem(mAssetMetaData);
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
-        {
-            if (strcmp(mReader->getNodeName(), "asset") != 0)
-                ThrowException("Expected end of <asset> element.");
-
-            break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the contributor info
-void ColladaParser::ReadContributorInfo()
-{
-    if (mReader->isEmptyElement())
-        return;
-
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
-        {
-            ReadMetaDataItem(mAssetMetaData);
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
-        {
-            if (strcmp(mReader->getNodeName(), "contributor") != 0)
-                ThrowException("Expected end of <contributor> element.");
-            break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads a single string metadata item
-void ColladaParser::ReadMetaDataItem(StringMetaData &metadata)
-{
-    // Metadata such as created, keywords, subject etc
-    const char* key_char = mReader->getNodeName();
-    if (key_char != nullptr)
-    {
-        const std::string key_str(key_char);
-        const char* value_char = TestTextContent();
-        if (value_char != nullptr)
-        {
-            std::string camel_key_str = key_str;
-            ToCamelCase(camel_key_str);
-            aiString aistr;
-            aistr.Set(value_char);
-            metadata.emplace(camel_key_str, aistr);
-        }
-        TestClosing(key_str.c_str());
-    }
-    else
-        SkipElement();
-}
-
-// ------------------------------------------------------------------------------------------------
-// Convert underscore_seperated to CamelCase: "authoring_tool" becomes "AuthoringTool"
-void ColladaParser::ToCamelCase(std::string &text)
-{
-    if (text.empty())
-        return;
-    // Capitalise first character
-    text[0] = ToUpper(text[0]);
-    for (auto it = text.begin(); it != text.end(); /*iterated below*/)
-    {
-        if ((*it) == '_')
-        {
-            it = text.erase(it);
-            if (it != text.end())
-                (*it) = ToUpper(*it);
-        }
-        else
-            ++it;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the animation clips
-void ColladaParser::ReadAnimationClipLibrary()
-{
-    if (mReader->isEmptyElement())
-        return;
-
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
-        {
-            if (IsElement("animation_clip"))
-            {
-                // optional name given as an attribute
-                std::string animName;
-                int indexName = TestAttribute("name");
-                int indexID = TestAttribute("id");
-                if (indexName >= 0)
-                    animName = mReader->getAttributeValue(indexName);
-                else if (indexID >= 0)
-                    animName = mReader->getAttributeValue(indexID);
-                else
-                    animName = std::string("animation_") + to_string(mAnimationClipLibrary.size());
-
-                std::pair<std::string, std::vector<std::string> > clip;
-
-                clip.first = animName;
-
-                while (mReader->read())
-                {
-                    if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
-                    {
-                        if (IsElement("instance_animation"))
-                        {
-                            int indexUrl = TestAttribute("url");
-                            if (indexUrl >= 0)
-                            {
-                                const char* url = mReader->getAttributeValue(indexUrl);
-                                if (url[0] != '#')
-                                    ThrowException("Unknown reference format");
-
-                                url++;
-
-                                clip.second.push_back(url);
-                            }
-                        }
-                        else
-                        {
-                            // ignore the rest
-                            SkipElement();
-                        }
-                    }
-                    else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
-                    {
-                        if (strcmp(mReader->getNodeName(), "animation_clip") != 0)
-                            ThrowException("Expected end of <animation_clip> element.");
-
-                        break;
-                    }
-                }
-
-                if (clip.second.size() > 0)
-                {
-                    mAnimationClipLibrary.push_back(clip);
-                }
-            }
-            else
-            {
-                // ignore the rest
-                SkipElement();
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
-        {
-            if (strcmp(mReader->getNodeName(), "library_animation_clips") != 0)
-                ThrowException("Expected end of <library_animation_clips> element.");
-
-            break;
-        }
-    }
-}
-
-void ColladaParser::PostProcessControllers()
-{
-    std::string meshId;
-    for (ControllerLibrary::iterator it = mControllerLibrary.begin(); it != mControllerLibrary.end(); ++it) {
-        meshId = it->second.mMeshId;
-        ControllerLibrary::iterator findItr = mControllerLibrary.find(meshId);
-        while (findItr != mControllerLibrary.end()) {
-            meshId = findItr->second.mMeshId;
-            findItr = mControllerLibrary.find(meshId);
-        }
-
-        it->second.mMeshId = meshId;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Re-build animations from animation clip library, if present, otherwise combine single-channel animations
-void ColladaParser::PostProcessRootAnimations()
-{
-    if (mAnimationClipLibrary.size() > 0)
-    {
-        Animation temp;
-
-        for (AnimationClipLibrary::iterator it = mAnimationClipLibrary.begin(); it != mAnimationClipLibrary.end(); ++it)
-        {
-            std::string clipName = it->first;
-
-            Animation *clip = new Animation();
-            clip->mName = clipName;
-
-            temp.mSubAnims.push_back(clip);
-
-            for (std::vector<std::string>::iterator a = it->second.begin(); a != it->second.end(); ++a)
-            {
-                std::string animationID = *a;
-
-                AnimationLibrary::iterator animation = mAnimationLibrary.find(animationID);
-
-                if (animation != mAnimationLibrary.end())
-                {
-                    Animation *pSourceAnimation = animation->second;
-
-                    pSourceAnimation->CollectChannelsRecursively(clip->mChannels);
-                }
-            }
-        }
-
-        mAnims = temp;
-
-        // Ensure no double deletes.
-        temp.mSubAnims.clear();
-    }
-    else
-    {
-        mAnims.CombineSingleChannelAnimations();
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the animation library
-void ColladaParser::ReadAnimationLibrary()
-{
-    if (mReader->isEmptyElement())
-        return;
-
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
-        {
-            if (IsElement("animation"))
-            {
-                // delegate the reading. Depending on the inner elements it will be a container or a anim channel
-                ReadAnimation(&mAnims);
-            }
-            else
-            {
-                // ignore the rest
-                SkipElement();
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
-        {
-            if (strcmp(mReader->getNodeName(), "library_animations") != 0)
-                ThrowException("Expected end of <library_animations> element.");
-
-            break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads an animation into the given parent structure
-void ColladaParser::ReadAnimation(Collada::Animation* pParent)
-{
-    if (mReader->isEmptyElement())
-        return;
-
-    // an <animation> element may be a container for grouping sub-elements or an animation channel
-    // this is the channel collection by ID, in case it has channels
-    typedef std::map<std::string, AnimationChannel> ChannelMap;
-    ChannelMap channels;
-    // this is the anim container in case we're a container
-    Animation* anim = NULL;
-
-    // optional name given as an attribute
-    std::string animName;
-    std::string animID;
-    int indexName = TestAttribute("name");
-    int indexID = TestAttribute("id");
-
-    if (indexID >= 0)
-        animID = mReader->getAttributeValue(indexID);
-
-    if (indexName >= 0)
-        animName = mReader->getAttributeValue(indexName);
-    else if (indexID >= 0)
-        animName = animID;
-    else
-        animName = "animation";
-
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
-        {
-            // we have subanimations
-            if (IsElement("animation"))
-            {
-                // create container from our element
-                if (!anim)
-                {
-                    anim = new Animation;
-                    anim->mName = animName;
-                    pParent->mSubAnims.push_back(anim);
-                }
-
-                // recurse into the subelement
-                ReadAnimation(anim);
-            }
-            else if (IsElement("source"))
-            {
-                // possible animation data - we'll never know. Better store it
-                ReadSource();
-            }
-            else if (IsElement("sampler"))
-            {
-                // read the ID to assign the corresponding collada channel afterwards.
-                int indexID = GetAttribute("id");
-                std::string id = mReader->getAttributeValue(indexID);
-                ChannelMap::iterator newChannel = channels.insert(std::make_pair(id, AnimationChannel())).first;
-
-                // have it read into a channel
-                ReadAnimationSampler(newChannel->second);
-            }
-            else if (IsElement("channel"))
-            {
-                // the binding element whose whole purpose is to provide the target to animate
-                // Thanks, Collada! A directly posted information would have been too simple, I guess.
-                // Better add another indirection to that! Can't have enough of those.
-                int indexTarget = GetAttribute("target");
-                int indexSource = GetAttribute("source");
-                const char* sourceId = mReader->getAttributeValue(indexSource);
-                if (sourceId[0] == '#')
-                    sourceId++;
-                ChannelMap::iterator cit = channels.find(sourceId);
-                if (cit != channels.end())
-                    cit->second.mTarget = mReader->getAttributeValue(indexTarget);
-
-                if (!mReader->isEmptyElement())
-                    SkipElement();
-            }
-            else
-            {
-                // ignore the rest
-                SkipElement();
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
-        {
-            if (strcmp(mReader->getNodeName(), "animation") != 0)
-                ThrowException("Expected end of <animation> element.");
-
-            break;
-        }
-    }
-
-    // it turned out to have channels - add them
-    if (!channels.empty())
-    {
-        // FIXME: Is this essentially doing the same as "single-anim-node" codepath in
-        //        ColladaLoader::StoreAnimations? For now, this has been deferred to after
-        //        all animations and all clips have been read. Due to handling of
-        //        <library_animation_clips> this cannot be done here, as the channel owner
-        //        is lost, and some exporters make up animations by referring to multiple
-        //        single-channel animations from an <instance_animation>.
-/*
-        // special filtering for stupid exporters packing each channel into a separate animation
-        if( channels.size() == 1)
-        {
-            pParent->mChannels.push_back( channels.begin()->second);
-        } else
-*/
-        {
-            // else create the animation, if not done yet, and store the channels
-            if (!anim)
-            {
-                anim = new Animation;
-                anim->mName = animName;
-                pParent->mSubAnims.push_back(anim);
-            }
-            for (ChannelMap::const_iterator it = channels.begin(); it != channels.end(); ++it)
-                anim->mChannels.push_back(it->second);
-
-            if (indexID >= 0)
-            {
-                mAnimationLibrary[animID] = anim;
-            }
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads an animation sampler into the given anim channel
-void ColladaParser::ReadAnimationSampler(Collada::AnimationChannel& pChannel)
-{
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
-        {
-            if (IsElement("input"))
-            {
-                int indexSemantic = GetAttribute("semantic");
-                const char* semantic = mReader->getAttributeValue(indexSemantic);
-                int indexSource = GetAttribute("source");
-                const char* source = mReader->getAttributeValue(indexSource);
-                if (source[0] != '#')
-                    ThrowException("Unsupported URL format");
-                source++;
-
-                if (strcmp(semantic, "INPUT") == 0)
-                    pChannel.mSourceTimes = source;
-                else if (strcmp(semantic, "OUTPUT") == 0)
-                    pChannel.mSourceValues = source;
-                else if (strcmp(semantic, "IN_TANGENT") == 0)
-                    pChannel.mInTanValues = source;
-                else if (strcmp(semantic, "OUT_TANGENT") == 0)
-                    pChannel.mOutTanValues = source;
-                else if (strcmp(semantic, "INTERPOLATION") == 0)
-                    pChannel.mInterpolationValues = source;
-
-                if (!mReader->isEmptyElement())
-                    SkipElement();
-            }
-            else
-            {
-                // ignore the rest
-                SkipElement();
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
-        {
-            if (strcmp(mReader->getNodeName(), "sampler") != 0)
-                ThrowException("Expected end of <sampler> element.");
-
-            break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the skeleton controller library
-void ColladaParser::ReadControllerLibrary()
-{
-    if (mReader->isEmptyElement())
-        return;
-
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
-        {
-            if (IsElement("controller"))
-            {
-                // read ID. Ask the spec if it's necessary or optional... you might be surprised.
-                int attrID = GetAttribute("id");
-                std::string id = mReader->getAttributeValue(attrID);
-
-                // create an entry and store it in the library under its ID
-                mControllerLibrary[id] = Controller();
-
-                // read on from there
-                ReadController(mControllerLibrary[id]);
-            }
-            else
-            {
-                // ignore the rest
-                SkipElement();
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
-        {
-            if (strcmp(mReader->getNodeName(), "library_controllers") != 0)
-                ThrowException("Expected end of <library_controllers> element.");
-
-            break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads a controller into the given mesh structure
-void ColladaParser::ReadController(Collada::Controller& pController)
-{
-    // initial values
-    pController.mType = Skin;
-    pController.mMethod = Normalized;
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
-        {
-            // two types of controllers: "skin" and "morph". Only the first one is relevant, we skip the other
-            if (IsElement("morph"))
-            {
-                pController.mType = Morph;
-                int baseIndex = GetAttribute("source");
-                pController.mMeshId = mReader->getAttributeValue(baseIndex) + 1;
-                int methodIndex = GetAttribute("method");
-                if (methodIndex > 0) {
-                    const char *method = mReader->getAttributeValue(methodIndex);
-                    if (strcmp(method, "RELATIVE") == 0)
-                        pController.mMethod = Relative;
-                }
-            }
-            else if (IsElement("skin"))
-            {
-                // read the mesh it refers to. According to the spec this could also be another
-                // controller, but I refuse to implement every single idea they've come up with
-                int sourceIndex = GetAttribute("source");
-                pController.mMeshId = mReader->getAttributeValue(sourceIndex) + 1;
-            }
-            else if (IsElement("bind_shape_matrix"))
-            {
-                // content is 16 floats to define a matrix... it seems to be important for some models
-                const char* content = GetTextContent();
-
-                // read the 16 floats
-                for (unsigned int a = 0; a < 16; a++)
-                {
-                    // read a number
-                    content = fast_atoreal_move<ai_real>(content, pController.mBindShapeMatrix[a]);
-                    // skip whitespace after it
-                    SkipSpacesAndLineEnd(&content);
-                }
-
-                TestClosing("bind_shape_matrix");
-            }
-            else if (IsElement("source"))
-            {
-                // data array - we have specialists to handle this
-                ReadSource();
-            }
-            else if (IsElement("joints"))
-            {
-                ReadControllerJoints(pController);
-            }
-            else if (IsElement("vertex_weights"))
-            {
-                ReadControllerWeights(pController);
-            }
-            else if (IsElement("targets"))
-            {
-                while (mReader->read()) {
-                    if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
-                        if (IsElement("input")) {
-                            int semanticsIndex = GetAttribute("semantic");
-                            int sourceIndex = GetAttribute("source");
-
-                            const char *semantics = mReader->getAttributeValue(semanticsIndex);
-                            const char *source = mReader->getAttributeValue(sourceIndex);
-                            if (strcmp(semantics, "MORPH_TARGET") == 0) {
-                                pController.mMorphTarget = source + 1;
-                            }
-                            else if (strcmp(semantics, "MORPH_WEIGHT") == 0)
-                            {
-                                pController.mMorphWeight = source + 1;
-                            }
-                        }
-                    }
-                    else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
-                        if (strcmp(mReader->getNodeName(), "targets") == 0)
-                            break;
-                        else
-                            ThrowException("Expected end of <targets> element.");
-                    }
-                }
-            }
-            else
-            {
-                // ignore the rest
-                SkipElement();
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
-        {
-            if (strcmp(mReader->getNodeName(), "controller") == 0)
-                break;
-            else if (strcmp(mReader->getNodeName(), "skin") != 0 && strcmp(mReader->getNodeName(), "morph") != 0)
-                ThrowException("Expected end of <controller> element.");
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the joint definitions for the given controller
-void ColladaParser::ReadControllerJoints(Collada::Controller& pController)
-{
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
-        {
-            // Input channels for joint data. Two possible semantics: "JOINT" and "INV_BIND_MATRIX"
-            if (IsElement("input"))
-            {
-                int indexSemantic = GetAttribute("semantic");
-                const char* attrSemantic = mReader->getAttributeValue(indexSemantic);
-                int indexSource = GetAttribute("source");
-                const char* attrSource = mReader->getAttributeValue(indexSource);
-
-                // local URLS always start with a '#'. We don't support global URLs
-                if (attrSource[0] != '#')
-                    ThrowException(format() << "Unsupported URL format in \"" << attrSource << "\" in source attribute of <joints> data <input> element");
-                attrSource++;
-
-                // parse source URL to corresponding source
-                if (strcmp(attrSemantic, "JOINT") == 0)
-                    pController.mJointNameSource = attrSource;
-                else if (strcmp(attrSemantic, "INV_BIND_MATRIX") == 0)
-                    pController.mJointOffsetMatrixSource = attrSource;
-                else
-                    ThrowException(format() << "Unknown semantic \"" << attrSemantic << "\" in <joints> data <input> element");
-
-                // skip inner data, if present
-                if (!mReader->isEmptyElement())
-                    SkipElement();
-            }
-            else
-            {
-                // ignore the rest
-                SkipElement();
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
-        {
-            if (strcmp(mReader->getNodeName(), "joints") != 0)
-                ThrowException("Expected end of <joints> element.");
-
-            break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the joint weights for the given controller
-void ColladaParser::ReadControllerWeights(Collada::Controller& pController)
-{
-    // read vertex count from attributes and resize the array accordingly
-    int indexCount = GetAttribute("count");
-    size_t vertexCount = (size_t)mReader->getAttributeValueAsInt(indexCount);
-    pController.mWeightCounts.resize(vertexCount);
-
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
-        {
-            // Input channels for weight data. Two possible semantics: "JOINT" and "WEIGHT"
-            if (IsElement("input") && vertexCount > 0)
-            {
-                InputChannel channel;
-
-                int indexSemantic = GetAttribute("semantic");
-                const char* attrSemantic = mReader->getAttributeValue(indexSemantic);
-                int indexSource = GetAttribute("source");
-                const char* attrSource = mReader->getAttributeValue(indexSource);
-                int indexOffset = TestAttribute("offset");
-                if (indexOffset >= 0)
-                    channel.mOffset = mReader->getAttributeValueAsInt(indexOffset);
-
-                // local URLS always start with a '#'. We don't support global URLs
-                if (attrSource[0] != '#')
-                    ThrowException(format() << "Unsupported URL format in \"" << attrSource << "\" in source attribute of <vertex_weights> data <input> element");
-                channel.mAccessor = attrSource + 1;
-
-                // parse source URL to corresponding source
-                if (strcmp(attrSemantic, "JOINT") == 0)
-                    pController.mWeightInputJoints = channel;
-                else if (strcmp(attrSemantic, "WEIGHT") == 0)
-                    pController.mWeightInputWeights = channel;
-                else
-                    ThrowException(format() << "Unknown semantic \"" << attrSemantic << "\" in <vertex_weights> data <input> element");
-
-                // skip inner data, if present
-                if (!mReader->isEmptyElement())
-                    SkipElement();
-            }
-            else if (IsElement("vcount") && vertexCount > 0)
-            {
-                // read weight count per vertex
-                const char* text = GetTextContent();
-                size_t numWeights = 0;
-                for (std::vector<size_t>::iterator it = pController.mWeightCounts.begin(); it != pController.mWeightCounts.end(); ++it)
-                {
-                    if (*text == 0)
-                        ThrowException("Out of data while reading <vcount>");
-
-                    *it = strtoul10(text, &text);
-                    numWeights += *it;
-                    SkipSpacesAndLineEnd(&text);
-                }
-
-                TestClosing("vcount");
-
-                // reserve weight count
-                pController.mWeights.resize(numWeights);
-            }
-            else if (IsElement("v") && vertexCount > 0)
-            {
-                // read JointIndex - WeightIndex pairs
-                const char* text = GetTextContent();
-
-                for (std::vector< std::pair<size_t, size_t> >::iterator it = pController.mWeights.begin(); it != pController.mWeights.end(); ++it)
-                {
-                    if (*text == 0)
-                        ThrowException("Out of data while reading <vertex_weights>");
-                    it->first = strtoul10(text, &text);
-                    SkipSpacesAndLineEnd(&text);
-                    if (*text == 0)
-                        ThrowException("Out of data while reading <vertex_weights>");
-                    it->second = strtoul10(text, &text);
-                    SkipSpacesAndLineEnd(&text);
-                }
-
-                TestClosing("v");
-            }
-            else
-            {
-                // ignore the rest
-                SkipElement();
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
-        {
-            if (strcmp(mReader->getNodeName(), "vertex_weights") != 0)
-                ThrowException("Expected end of <vertex_weights> element.");
-
-            break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the image library contents
-void ColladaParser::ReadImageLibrary()
-{
-    if (mReader->isEmptyElement())
-        return;
-
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
-            if (IsElement("image"))
-            {
-                // read ID. Another entry which is "optional" by design but obligatory in reality
-                int attrID = GetAttribute("id");
-                std::string id = mReader->getAttributeValue(attrID);
-
-                // create an entry and store it in the library under its ID
-                mImageLibrary[id] = Image();
-
-                // read on from there
-                ReadImage(mImageLibrary[id]);
-            }
-            else
-            {
-                // ignore the rest
-                SkipElement();
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
-            if (strcmp(mReader->getNodeName(), "library_images") != 0)
-                ThrowException("Expected end of <library_images> element.");
-
-            break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads an image entry into the given image
-void ColladaParser::ReadImage(Collada::Image& pImage)
-{
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
-            // Need to run different code paths here, depending on the Collada XSD version
-            if (IsElement("image")) {
-                SkipElement();
-            }
-            else if (IsElement("init_from"))
-            {
-                if (mFormat == FV_1_4_n)
-                {
-                    // FIX: C4D exporter writes empty <init_from/> tags
-                    if (!mReader->isEmptyElement()) {
-                        // element content is filename - hopefully
-                        const char* sz = TestTextContent();
-                        if (sz)pImage.mFileName = sz;
-                        TestClosing("init_from");
-                    }
-                    if (!pImage.mFileName.length()) {
-                        pImage.mFileName = "unknown_texture";
-                    }
-                }
-                else if (mFormat == FV_1_5_n)
-                {
-                    // make sure we skip over mip and array initializations, which
-                    // we don't support, but which could confuse the loader if
-                    // they're not skipped.
-                    int attrib = TestAttribute("array_index");
-                    if (attrib != -1 && mReader->getAttributeValueAsInt(attrib) > 0) {
-                        ASSIMP_LOG_WARN("Collada: Ignoring texture array index");
-                        continue;
-                    }
-
-                    attrib = TestAttribute("mip_index");
-                    if (attrib != -1 && mReader->getAttributeValueAsInt(attrib) > 0) {
-                        ASSIMP_LOG_WARN("Collada: Ignoring MIP map layer");
-                        continue;
-                    }
-
-                    // TODO: correctly jump over cube and volume maps?
-                }
-            }
-            else if (mFormat == FV_1_5_n)
-            {
-                if (IsElement("ref"))
-                {
-                    // element content is filename - hopefully
-                    const char* sz = TestTextContent();
-                    if (sz)pImage.mFileName = sz;
-                    TestClosing("ref");
-                }
-                else if (IsElement("hex") && !pImage.mFileName.length())
-                {
-                    // embedded image. get format
-                    const int attrib = TestAttribute("format");
-                    if (-1 == attrib)
-                        ASSIMP_LOG_WARN("Collada: Unknown image file format");
-                    else pImage.mEmbeddedFormat = mReader->getAttributeValue(attrib);
-
-                    const char* data = GetTextContent();
-
-                    // hexadecimal-encoded binary octets. First of all, find the
-                    // required buffer size to reserve enough storage.
-                    const char* cur = data;
-                    while (!IsSpaceOrNewLine(*cur)) cur++;
-
-                    const unsigned int size = (unsigned int)(cur - data) * 2;
-                    pImage.mImageData.resize(size);
-                    for (unsigned int i = 0; i < size; ++i)
-                        pImage.mImageData[i] = HexOctetToDecimal(data + (i << 1));
-
-                    TestClosing("hex");
-                }
-            }
-            else
-            {
-                // ignore the rest
-                SkipElement();
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
-            if (strcmp(mReader->getNodeName(), "image") == 0)
-                break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the material library
-void ColladaParser::ReadMaterialLibrary()
-{
-    if (mReader->isEmptyElement())
-        return;
-
-    std::map<std::string, int> names;
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
-        {
-            if (IsElement("material"))
-            {
-                // read ID. By now you probably know my opinion about this "specification"
-                int attrID = GetAttribute("id");
-                std::string id = mReader->getAttributeValue(attrID);
-
-                std::string name;
-                int attrName = TestAttribute("name");
-                if (attrName >= 0)
-                    name = mReader->getAttributeValue(attrName);
-
-                // create an entry and store it in the library under its ID
-                mMaterialLibrary[id] = Material();
-
-                if (!name.empty())
-                {
-                    std::map<std::string, int>::iterator it = names.find(name);
-                    if (it != names.end())
-                    {
-                        std::ostringstream strStream;
-                        strStream << ++it->second;
-                        name.append(" " + strStream.str());
-                    }
-                    else
-                    {
-                        names[name] = 0;
-                    }
-
-                    mMaterialLibrary[id].mName = name;
-                }
-
-                ReadMaterial(mMaterialLibrary[id]);
-            }
-            else
-            {
-                // ignore the rest
-                SkipElement();
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
-        {
-            if (strcmp(mReader->getNodeName(), "library_materials") != 0)
-                ThrowException("Expected end of <library_materials> element.");
-
-            break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the light library
-void ColladaParser::ReadLightLibrary()
-{
-    if (mReader->isEmptyElement())
-        return;
-
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
-            if (IsElement("light"))
-            {
-                // read ID. By now you probably know my opinion about this "specification"
-                int attrID = GetAttribute("id");
-                std::string id = mReader->getAttributeValue(attrID);
-
-                // create an entry and store it in the library under its ID
-                ReadLight(mLightLibrary[id] = Light());
-
-            }
-            else
-            {
-                // ignore the rest
-                SkipElement();
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
-            if (strcmp(mReader->getNodeName(), "library_lights") != 0)
-                ThrowException("Expected end of <library_lights> element.");
-
-            break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the camera library
-void ColladaParser::ReadCameraLibrary()
-{
-    if (mReader->isEmptyElement())
-        return;
-
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
-            if (IsElement("camera"))
-            {
-                // read ID. By now you probably know my opinion about this "specification"
-                int attrID = GetAttribute("id");
-                std::string id = mReader->getAttributeValue(attrID);
-
-                // create an entry and store it in the library under its ID
-                Camera& cam = mCameraLibrary[id];
-                attrID = TestAttribute("name");
-                if (attrID != -1)
-                    cam.mName = mReader->getAttributeValue(attrID);
-
-                ReadCamera(cam);
-
-            }
-            else
-            {
-                // ignore the rest
-                SkipElement();
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
-            if (strcmp(mReader->getNodeName(), "library_cameras") != 0)
-                ThrowException("Expected end of <library_cameras> element.");
-
-            break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads a material entry into the given material
-void ColladaParser::ReadMaterial(Collada::Material& pMaterial)
-{
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
-            if (IsElement("material")) {
-                SkipElement();
-            }
-            else if (IsElement("instance_effect"))
-            {
-                // referred effect by URL
-                int attrUrl = GetAttribute("url");
-                const char* url = mReader->getAttributeValue(attrUrl);
-                if (url[0] != '#')
-                    ThrowException("Unknown reference format");
-
-                pMaterial.mEffect = url + 1;
-
-                SkipElement();
-            }
-            else
-            {
-                // ignore the rest
-                SkipElement();
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
-            if (strcmp(mReader->getNodeName(), "material") != 0)
-                ThrowException("Expected end of <material> element.");
-
-            break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads a light entry into the given light
-void ColladaParser::ReadLight(Collada::Light& pLight)
-{
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
-            if (IsElement("light")) {
-                SkipElement();
-            }
-            else if (IsElement("spot")) {
-                pLight.mType = aiLightSource_SPOT;
-            }
-            else if (IsElement("ambient")) {
-                pLight.mType = aiLightSource_AMBIENT;
-            }
-            else if (IsElement("directional")) {
-                pLight.mType = aiLightSource_DIRECTIONAL;
-            }
-            else if (IsElement("point")) {
-                pLight.mType = aiLightSource_POINT;
-            }
-            else if (IsElement("color")) {
-                // text content contains 3 floats
-                const char* content = GetTextContent();
-
-                content = fast_atoreal_move<ai_real>(content, (ai_real&)pLight.mColor.r);
-                SkipSpacesAndLineEnd(&content);
-
-                content = fast_atoreal_move<ai_real>(content, (ai_real&)pLight.mColor.g);
-                SkipSpacesAndLineEnd(&content);
-
-                content = fast_atoreal_move<ai_real>(content, (ai_real&)pLight.mColor.b);
-                SkipSpacesAndLineEnd(&content);
-
-                TestClosing("color");
-            }
-            else if (IsElement("constant_attenuation")) {
-                pLight.mAttConstant = ReadFloatFromTextContent();
-                TestClosing("constant_attenuation");
-            }
-            else if (IsElement("linear_attenuation")) {
-                pLight.mAttLinear = ReadFloatFromTextContent();
-                TestClosing("linear_attenuation");
-            }
-            else if (IsElement("quadratic_attenuation")) {
-                pLight.mAttQuadratic = ReadFloatFromTextContent();
-                TestClosing("quadratic_attenuation");
-            }
-            else if (IsElement("falloff_angle")) {
-                pLight.mFalloffAngle = ReadFloatFromTextContent();
-                TestClosing("falloff_angle");
-            }
-            else if (IsElement("falloff_exponent")) {
-                pLight.mFalloffExponent = ReadFloatFromTextContent();
-                TestClosing("falloff_exponent");
-            }
-            // FCOLLADA extensions
-            // -------------------------------------------------------
-            else if (IsElement("outer_cone")) {
-                pLight.mOuterAngle = ReadFloatFromTextContent();
-                TestClosing("outer_cone");
-            }
-            // ... and this one is even deprecated
-            else if (IsElement("penumbra_angle")) {
-                pLight.mPenumbraAngle = ReadFloatFromTextContent();
-                TestClosing("penumbra_angle");
-            }
-            else if (IsElement("intensity")) {
-                pLight.mIntensity = ReadFloatFromTextContent();
-                TestClosing("intensity");
-            }
-            else if (IsElement("falloff")) {
-                pLight.mOuterAngle = ReadFloatFromTextContent();
-                TestClosing("falloff");
-            }
-            else if (IsElement("hotspot_beam")) {
-                pLight.mFalloffAngle = ReadFloatFromTextContent();
-                TestClosing("hotspot_beam");
-            }
-            // OpenCOLLADA extensions
-            // -------------------------------------------------------
-            else if (IsElement("decay_falloff")) {
-                pLight.mOuterAngle = ReadFloatFromTextContent();
-                TestClosing("decay_falloff");
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
-            if (strcmp(mReader->getNodeName(), "light") == 0)
-                break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads a camera entry into the given light
-void ColladaParser::ReadCamera(Collada::Camera& pCamera)
-{
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
-            if (IsElement("camera")) {
-                SkipElement();
-            }
-            else if (IsElement("orthographic")) {
-                pCamera.mOrtho = true;
-            }
-            else if (IsElement("xfov") || IsElement("xmag")) {
-                pCamera.mHorFov = ReadFloatFromTextContent();
-                TestClosing((pCamera.mOrtho ? "xmag" : "xfov"));
-            }
-            else if (IsElement("yfov") || IsElement("ymag")) {
-                pCamera.mVerFov = ReadFloatFromTextContent();
-                TestClosing((pCamera.mOrtho ? "ymag" : "yfov"));
-            }
-            else if (IsElement("aspect_ratio")) {
-                pCamera.mAspect = ReadFloatFromTextContent();
-                TestClosing("aspect_ratio");
-            }
-            else if (IsElement("znear")) {
-                pCamera.mZNear = ReadFloatFromTextContent();
-                TestClosing("znear");
-            }
-            else if (IsElement("zfar")) {
-                pCamera.mZFar = ReadFloatFromTextContent();
-                TestClosing("zfar");
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
-            if (strcmp(mReader->getNodeName(), "camera") == 0)
-                break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the effect library
-void ColladaParser::ReadEffectLibrary()
-{
-    if (mReader->isEmptyElement()) {
-        return;
-    }
-
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
-            if (IsElement("effect"))
-            {
-                // read ID. Do I have to repeat my ranting about "optional" attributes?
-                int attrID = GetAttribute("id");
-                std::string id = mReader->getAttributeValue(attrID);
-
-                // create an entry and store it in the library under its ID
-                mEffectLibrary[id] = Effect();
-                // read on from there
-                ReadEffect(mEffectLibrary[id]);
-            }
-            else
-            {
-                // ignore the rest
-                SkipElement();
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
-            if (strcmp(mReader->getNodeName(), "library_effects") != 0)
-                ThrowException("Expected end of <library_effects> element.");
-
-            break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads an effect entry into the given effect
-void ColladaParser::ReadEffect(Collada::Effect& pEffect)
-{
-    // for the moment we don't support any other type of effect.
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
-        {
-            if (IsElement("profile_COMMON"))
-                ReadEffectProfileCommon(pEffect);
-            else
-                SkipElement();
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
-        {
-            if (strcmp(mReader->getNodeName(), "effect") != 0)
-                ThrowException("Expected end of <effect> element.");
-
-            break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads an COMMON effect profile
-void ColladaParser::ReadEffectProfileCommon(Collada::Effect& pEffect)
-{
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
-        {
-            if (IsElement("newparam")) {
-                // save ID
-                int attrSID = GetAttribute("sid");
-                std::string sid = mReader->getAttributeValue(attrSID);
-                pEffect.mParams[sid] = EffectParam();
-                ReadEffectParam(pEffect.mParams[sid]);
-            }
-            else if (IsElement("technique") || IsElement("extra"))
-            {
-                // just syntactic sugar
-            }
-
-            else if (mFormat == FV_1_4_n && IsElement("image"))
-            {
-                // read ID. Another entry which is "optional" by design but obligatory in reality
-                int attrID = GetAttribute("id");
-                std::string id = mReader->getAttributeValue(attrID);
-
-                // create an entry and store it in the library under its ID
-                mImageLibrary[id] = Image();
-
-                // read on from there
-                ReadImage(mImageLibrary[id]);
-            }
-
-            /* Shading modes */
-            else if (IsElement("phong"))
-                pEffect.mShadeType = Shade_Phong;
-            else if (IsElement("constant"))
-                pEffect.mShadeType = Shade_Constant;
-            else if (IsElement("lambert"))
-                pEffect.mShadeType = Shade_Lambert;
-            else if (IsElement("blinn"))
-                pEffect.mShadeType = Shade_Blinn;
-
-            /* Color + texture properties */
-            else if (IsElement("emission"))
-                ReadEffectColor(pEffect.mEmissive, pEffect.mTexEmissive);
-            else if (IsElement("ambient"))
-                ReadEffectColor(pEffect.mAmbient, pEffect.mTexAmbient);
-            else if (IsElement("diffuse"))
-                ReadEffectColor(pEffect.mDiffuse, pEffect.mTexDiffuse);
-            else if (IsElement("specular"))
-                ReadEffectColor(pEffect.mSpecular, pEffect.mTexSpecular);
-            else if (IsElement("reflective")) {
-                ReadEffectColor(pEffect.mReflective, pEffect.mTexReflective);
-            }
-            else if (IsElement("transparent")) {
-                pEffect.mHasTransparency = true;
-
-                const char* opaque = mReader->getAttributeValueSafe("opaque");
-
-                if (::strcmp(opaque, "RGB_ZERO") == 0 || ::strcmp(opaque, "RGB_ONE") == 0) {
-                    pEffect.mRGBTransparency = true;
-                }
-
-                // In RGB_ZERO mode, the transparency is interpreted in reverse, go figure...
-                if (::strcmp(opaque, "RGB_ZERO") == 0 || ::strcmp(opaque, "A_ZERO") == 0) {
-                    pEffect.mInvertTransparency = true;
-                }
-
-                ReadEffectColor(pEffect.mTransparent, pEffect.mTexTransparent);
-            }
-            else if (IsElement("shininess"))
-                ReadEffectFloat(pEffect.mShininess);
-            else if (IsElement("reflectivity"))
-                ReadEffectFloat(pEffect.mReflectivity);
-
-            /* Single scalar properties */
-            else if (IsElement("transparency"))
-                ReadEffectFloat(pEffect.mTransparency);
-            else if (IsElement("index_of_refraction"))
-                ReadEffectFloat(pEffect.mRefractIndex);
-
-            // GOOGLEEARTH/OKINO extensions
-            // -------------------------------------------------------
-            else if (IsElement("double_sided"))
-                pEffect.mDoubleSided = ReadBoolFromTextContent();
-
-            // FCOLLADA extensions
-            // -------------------------------------------------------
-            else if (IsElement("bump")) {
-                aiColor4D dummy;
-                ReadEffectColor(dummy, pEffect.mTexBump);
-            }
-
-            // MAX3D extensions
-            // -------------------------------------------------------
-            else if (IsElement("wireframe")) {
-                pEffect.mWireframe = ReadBoolFromTextContent();
-                TestClosing("wireframe");
-            }
-            else if (IsElement("faceted")) {
-                pEffect.mFaceted = ReadBoolFromTextContent();
-                TestClosing("faceted");
-            }
-            else
-            {
-                // ignore the rest
-                SkipElement();
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
-            if (strcmp(mReader->getNodeName(), "profile_COMMON") == 0)
-            {
-                break;
-            }
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Read texture wrapping + UV transform settings from a profile==Maya chunk
-void ColladaParser::ReadSamplerProperties(Sampler& out)
-{
-    if (mReader->isEmptyElement()) {
-        return;
-    }
-
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
-
-            // MAYA extensions
-            // -------------------------------------------------------
-            if (IsElement("wrapU")) {
-                out.mWrapU = ReadBoolFromTextContent();
-                TestClosing("wrapU");
-            }
-            else if (IsElement("wrapV")) {
-                out.mWrapV = ReadBoolFromTextContent();
-                TestClosing("wrapV");
-            }
-            else if (IsElement("mirrorU")) {
-                out.mMirrorU = ReadBoolFromTextContent();
-                TestClosing("mirrorU");
-            }
-            else if (IsElement("mirrorV")) {
-                out.mMirrorV = ReadBoolFromTextContent();
-                TestClosing("mirrorV");
-            }
-            else if (IsElement("repeatU")) {
-                out.mTransform.mScaling.x = ReadFloatFromTextContent();
-                TestClosing("repeatU");
-            }
-            else if (IsElement("repeatV")) {
-                out.mTransform.mScaling.y = ReadFloatFromTextContent();
-                TestClosing("repeatV");
-            }
-            else if (IsElement("offsetU")) {
-                out.mTransform.mTranslation.x = ReadFloatFromTextContent();
-                TestClosing("offsetU");
-            }
-            else if (IsElement("offsetV")) {
-                out.mTransform.mTranslation.y = ReadFloatFromTextContent();
-                TestClosing("offsetV");
-            }
-            else if (IsElement("rotateUV")) {
-                out.mTransform.mRotation = ReadFloatFromTextContent();
-                TestClosing("rotateUV");
-            }
-            else if (IsElement("blend_mode")) {
-
-                const char* sz = GetTextContent();
-                // http://www.feelingsoftware.com/content/view/55/72/lang,en/
-                // NONE, OVER, IN, OUT, ADD, SUBTRACT, MULTIPLY, DIFFERENCE, LIGHTEN, DARKEN, SATURATE, DESATURATE and ILLUMINATE
-                if (0 == ASSIMP_strincmp(sz, "ADD", 3))
-                    out.mOp = aiTextureOp_Add;
-
-                else if (0 == ASSIMP_strincmp(sz, "SUBTRACT", 8))
-                    out.mOp = aiTextureOp_Subtract;
-
-                else if (0 == ASSIMP_strincmp(sz, "MULTIPLY", 8))
-                    out.mOp = aiTextureOp_Multiply;
-
-                else {
-                    ASSIMP_LOG_WARN("Collada: Unsupported MAYA texture blend mode");
-                }
-                TestClosing("blend_mode");
-            }
-            // OKINO extensions
-            // -------------------------------------------------------
-            else if (IsElement("weighting")) {
-                out.mWeighting = ReadFloatFromTextContent();
-                TestClosing("weighting");
-            }
-            else if (IsElement("mix_with_previous_layer")) {
-                out.mMixWithPrevious = ReadFloatFromTextContent();
-                TestClosing("mix_with_previous_layer");
-            }
-            // MAX3D extensions
-            // -------------------------------------------------------
-            else if (IsElement("amount")) {
-                out.mWeighting = ReadFloatFromTextContent();
-                TestClosing("amount");
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
-            if (strcmp(mReader->getNodeName(), "technique") == 0)
-                break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads an effect entry containing a color or a texture defining that color
-void ColladaParser::ReadEffectColor(aiColor4D& pColor, Sampler& pSampler)
-{
-    if (mReader->isEmptyElement())
-        return;
-
-    // Save current element name
-    const std::string curElem = mReader->getNodeName();
-
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
-            if (IsElement("color"))
-            {
-                // text content contains 4 floats
-                const char* content = GetTextContent();
-
-                content = fast_atoreal_move<ai_real>(content, (ai_real&)pColor.r);
-                SkipSpacesAndLineEnd(&content);
-
-                content = fast_atoreal_move<ai_real>(content, (ai_real&)pColor.g);
-                SkipSpacesAndLineEnd(&content);
-
-                content = fast_atoreal_move<ai_real>(content, (ai_real&)pColor.b);
-                SkipSpacesAndLineEnd(&content);
-
-                content = fast_atoreal_move<ai_real>(content, (ai_real&)pColor.a);
-                SkipSpacesAndLineEnd(&content);
-                TestClosing("color");
-            }
-            else if (IsElement("texture"))
-            {
-                // get name of source texture/sampler
-                int attrTex = GetAttribute("texture");
-                pSampler.mName = mReader->getAttributeValue(attrTex);
-
-                // get name of UV source channel. Specification demands it to be there, but some exporters
-                // don't write it. It will be the default UV channel in case it's missing.
-                attrTex = TestAttribute("texcoord");
-                if (attrTex >= 0)
-                    pSampler.mUVChannel = mReader->getAttributeValue(attrTex);
-                //SkipElement();
-
-                // as we've read texture, the color needs to be 1,1,1,1
-                pColor = aiColor4D(1.f, 1.f, 1.f, 1.f);
-            }
-            else if (IsElement("technique"))
-            {
-                const int _profile = GetAttribute("profile");
-                const char* profile = mReader->getAttributeValue(_profile);
-
-                // Some extensions are quite useful ... ReadSamplerProperties processes
-                // several extensions in MAYA, OKINO and MAX3D profiles.
-                if (!::strcmp(profile, "MAYA") || !::strcmp(profile, "MAX3D") || !::strcmp(profile, "OKINO"))
-                {
-                    // get more information on this sampler
-                    ReadSamplerProperties(pSampler);
-                }
-                else SkipElement();
-            }
-            else if (!IsElement("extra"))
-            {
-                // ignore the rest
-                SkipElement();
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
-            if (mReader->getNodeName() == curElem)
-                break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads an effect entry containing a float
-void ColladaParser::ReadEffectFloat(ai_real& pFloat)
-{
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
-            if (IsElement("float"))
-            {
-                // text content contains a single floats
-                const char* content = GetTextContent();
-                content = fast_atoreal_move<ai_real>(content, pFloat);
-                SkipSpacesAndLineEnd(&content);
-
-                TestClosing("float");
-            }
-            else
-            {
-                // ignore the rest
-                SkipElement();
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
-            break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads an effect parameter specification of any kind
-void ColladaParser::ReadEffectParam(Collada::EffectParam& pParam)
-{
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
-            if (IsElement("surface"))
-            {
-                // image ID given inside <init_from> tags
-                TestOpening("init_from");
-                const char* content = GetTextContent();
-                pParam.mType = Param_Surface;
-                pParam.mReference = content;
-                TestClosing("init_from");
-
-                // don't care for remaining stuff
-                SkipElement("surface");
-            }
-            else if (IsElement("sampler2D") && (FV_1_4_n == mFormat || FV_1_3_n == mFormat))
-            {
-                // surface ID is given inside <source> tags
-                TestOpening("source");
-                const char* content = GetTextContent();
-                pParam.mType = Param_Sampler;
-                pParam.mReference = content;
-                TestClosing("source");
-
-                // don't care for remaining stuff
-                SkipElement("sampler2D");
-            }
-            else if (IsElement("sampler2D"))
-            {
-                // surface ID is given inside <instance_image> tags
-                TestOpening("instance_image");
-                int attrURL = GetAttribute("url");
-                const char* url = mReader->getAttributeValue(attrURL);
-                if (url[0] != '#')
-                    ThrowException("Unsupported URL format in instance_image");
-                url++;
-                pParam.mType = Param_Sampler;
-                pParam.mReference = url;
-                SkipElement("sampler2D");
-            }
-            else
-            {
-                // ignore unknown element
-                SkipElement();
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
-            break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the geometry library contents
-void ColladaParser::ReadGeometryLibrary()
-{
-    if (mReader->isEmptyElement())
-        return;
-
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
-        {
-            if (IsElement("geometry"))
-            {
-                // read ID. Another entry which is "optional" by design but obligatory in reality
-                int indexID = GetAttribute("id");
-                std::string id = mReader->getAttributeValue(indexID);
-
-                // TODO: (thom) support SIDs
-                // ai_assert( TestAttribute( "sid") == -1);
-
-                // create a mesh and store it in the library under its ID
-                Mesh* mesh = new Mesh;
-                mMeshLibrary[id] = mesh;
-
-                // read the mesh name if it exists
-                const int nameIndex = TestAttribute("name");
-                if (nameIndex != -1)
-                {
-                    mesh->mName = mReader->getAttributeValue(nameIndex);
-                }
-
-                // read on from there
-                ReadGeometry(mesh);
-            }
-            else
-            {
-                // ignore the rest
-                SkipElement();
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
-        {
-            if (strcmp(mReader->getNodeName(), "library_geometries") != 0)
-                ThrowException("Expected end of <library_geometries> element.");
-
-            break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads a geometry from the geometry library.
-void ColladaParser::ReadGeometry(Collada::Mesh* pMesh)
-{
-    if (mReader->isEmptyElement())
-        return;
-
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
-        {
-            if (IsElement("mesh"))
-            {
-                // read on from there
-                ReadMesh(pMesh);
-            }
-            else
-            {
-                // ignore the rest
-                SkipElement();
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
-        {
-            if (strcmp(mReader->getNodeName(), "geometry") != 0)
-                ThrowException("Expected end of <geometry> element.");
-
-            break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads a mesh from the geometry library
-void ColladaParser::ReadMesh(Mesh* pMesh)
-{
-    if (mReader->isEmptyElement())
-        return;
-
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
-        {
-            if (IsElement("source"))
-            {
-                // we have professionals dealing with this
-                ReadSource();
-            }
-            else if (IsElement("vertices"))
-            {
-                // read per-vertex mesh data
-                ReadVertexData(pMesh);
-            }
-            else if (IsElement("triangles") || IsElement("lines") || IsElement("linestrips")
-                || IsElement("polygons") || IsElement("polylist") || IsElement("trifans") || IsElement("tristrips"))
-            {
-                // read per-index mesh data and faces setup
-                ReadIndexData(pMesh);
-            }
-            else
-            {
-                // ignore the restf
-                SkipElement();
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
-        {
-            if (strcmp(mReader->getNodeName(), "technique_common") == 0)
-            {
-                // end of another meaningless element - read over it
-            }
-            else if (strcmp(mReader->getNodeName(), "mesh") == 0)
-            {
-                // end of <mesh> element - we're done here
-                break;
-            }
-            else
-            {
-                // everything else should be punished
-                ThrowException("Expected end of <mesh> element.");
-            }
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads a source element
-void ColladaParser::ReadSource()
-{
-    int indexID = GetAttribute("id");
-    std::string sourceID = mReader->getAttributeValue(indexID);
-
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
-        {
-            if (IsElement("float_array") || IsElement("IDREF_array") || IsElement("Name_array"))
-            {
-                ReadDataArray();
-            }
-            else if (IsElement("technique_common"))
-            {
-                // I don't care for your profiles
-            }
-            else if (IsElement("accessor"))
-            {
-                ReadAccessor(sourceID);
-            }
-            else
-            {
-                // ignore the rest
-                SkipElement();
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
-        {
-            if (strcmp(mReader->getNodeName(), "source") == 0)
-            {
-                // end of <source> - we're done
-                break;
-            }
-            else if (strcmp(mReader->getNodeName(), "technique_common") == 0)
-            {
-                // end of another meaningless element - read over it
-            }
-            else
-            {
-                // everything else should be punished
-                ThrowException("Expected end of <source> element.");
-            }
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads a data array holding a number of floats, and stores it in the global library
-void ColladaParser::ReadDataArray()
-{
-    std::string elmName = mReader->getNodeName();
-    bool isStringArray = (elmName == "IDREF_array" || elmName == "Name_array");
-    bool isEmptyElement = mReader->isEmptyElement();
-
-    // read attributes
-    int indexID = GetAttribute("id");
-    std::string id = mReader->getAttributeValue(indexID);
-    int indexCount = GetAttribute("count");
-    unsigned int count = (unsigned int)mReader->getAttributeValueAsInt(indexCount);
-    const char* content = TestTextContent();
-
-    // read values and store inside an array in the data library
-    mDataLibrary[id] = Data();
-    Data& data = mDataLibrary[id];
-    data.mIsStringArray = isStringArray;
-
-    // some exporters write empty data arrays, but we need to conserve them anyways because others might reference them
-    if (content)
-    {
-        if (isStringArray)
-        {
-            data.mStrings.reserve(count);
-            std::string s;
-
-            for (unsigned int a = 0; a < count; a++)
-            {
-                if (*content == 0)
-                    ThrowException("Expected more values while reading IDREF_array contents.");
-
-                s.clear();
-                while (!IsSpaceOrNewLine(*content))
-                    s += *content++;
-                data.mStrings.push_back(s);
-
-                SkipSpacesAndLineEnd(&content);
-            }
-        }
-        else
-        {
-            data.mValues.reserve(count);
-
-            for (unsigned int a = 0; a < count; a++)
-            {
-                if (*content == 0)
-                    ThrowException("Expected more values while reading float_array contents.");
-
-                ai_real value;
-                // read a number
-                content = fast_atoreal_move<ai_real>(content, value);
-                data.mValues.push_back(value);
-                // skip whitespace after it
-                SkipSpacesAndLineEnd(&content);
-            }
-        }
-    }
-
-    // test for closing tag
-    if (!isEmptyElement)
-        TestClosing(elmName.c_str());
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads an accessor and stores it in the global library
-void ColladaParser::ReadAccessor(const std::string& pID)
-{
-    // read accessor attributes
-    int attrSource = GetAttribute("source");
-    const char* source = mReader->getAttributeValue(attrSource);
-    if (source[0] != '#')
-        ThrowException(format() << "Unknown reference format in url \"" << source << "\" in source attribute of <accessor> element.");
-    int attrCount = GetAttribute("count");
-    unsigned int count = (unsigned int)mReader->getAttributeValueAsInt(attrCount);
-    int attrOffset = TestAttribute("offset");
-    unsigned int offset = 0;
-    if (attrOffset > -1)
-        offset = (unsigned int)mReader->getAttributeValueAsInt(attrOffset);
-    int attrStride = TestAttribute("stride");
-    unsigned int stride = 1;
-    if (attrStride > -1)
-        stride = (unsigned int)mReader->getAttributeValueAsInt(attrStride);
-
-    // store in the library under the given ID
-    mAccessorLibrary[pID] = Accessor();
-    Accessor& acc = mAccessorLibrary[pID];
-    acc.mCount = count;
-    acc.mOffset = offset;
-    acc.mStride = stride;
-    acc.mSource = source + 1; // ignore the leading '#'
-    acc.mSize = 0; // gets incremented with every param
-
-    // and read the components
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
-        {
-            if (IsElement("param"))
-            {
-                // read data param
-                int attrName = TestAttribute("name");
-                std::string name;
-                if (attrName > -1)
-                {
-                    name = mReader->getAttributeValue(attrName);
-
-                    // analyse for common type components and store it's sub-offset in the corresponding field
-
-                    /* Cartesian coordinates */
-                    if (name == "X") acc.mSubOffset[0] = acc.mParams.size();
-                    else if (name == "Y") acc.mSubOffset[1] = acc.mParams.size();
-                    else if (name == "Z") acc.mSubOffset[2] = acc.mParams.size();
-
-                    /* RGBA colors */
-                    else if (name == "R") acc.mSubOffset[0] = acc.mParams.size();
-                    else if (name == "G") acc.mSubOffset[1] = acc.mParams.size();
-                    else if (name == "B") acc.mSubOffset[2] = acc.mParams.size();
-                    else if (name == "A") acc.mSubOffset[3] = acc.mParams.size();
-
-                    /* UVWQ (STPQ) texture coordinates */
-                    else if (name == "S") acc.mSubOffset[0] = acc.mParams.size();
-                    else if (name == "T") acc.mSubOffset[1] = acc.mParams.size();
-                    else if (name == "P") acc.mSubOffset[2] = acc.mParams.size();
-                    //  else if( name == "Q") acc.mSubOffset[3] = acc.mParams.size();
-                        /* 4D uv coordinates are not supported in Assimp */
-
-                        /* Generic extra data, interpreted as UV data, too*/
-                    else if (name == "U") acc.mSubOffset[0] = acc.mParams.size();
-                    else if (name == "V") acc.mSubOffset[1] = acc.mParams.size();
-                    //else
-                    //  DefaultLogger::get()->warn( format() << "Unknown accessor parameter \"" << name << "\". Ignoring data channel." );
-                }
-
-                // read data type
-                int attrType = TestAttribute("type");
-                if (attrType > -1)
-                {
-                    // for the moment we only distinguish between a 4x4 matrix and anything else.
-                    // TODO: (thom) I don't have a spec here at work. Check if there are other multi-value types
-                    // which should be tested for here.
-                    std::string type = mReader->getAttributeValue(attrType);
-                    if (type == "float4x4")
-                        acc.mSize += 16;
-                    else
-                        acc.mSize += 1;
-                }
-
-                acc.mParams.push_back(name);
-
-                // skip remaining stuff of this element, if any
-                SkipElement();
-            }
-            else
-            {
-                ThrowException(format() << "Unexpected sub element <" << mReader->getNodeName() << "> in tag <accessor>");
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
-        {
-            if (strcmp(mReader->getNodeName(), "accessor") != 0)
-                ThrowException("Expected end of <accessor> element.");
-            break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads input declarations of per-vertex mesh data into the given mesh
-void ColladaParser::ReadVertexData(Mesh* pMesh)
-{
-    // extract the ID of the <vertices> element. Not that we care, but to catch strange referencing schemes we should warn about
-    int attrID = GetAttribute("id");
-    pMesh->mVertexID = mReader->getAttributeValue(attrID);
-
-    // a number of <input> elements
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
-        {
-            if (IsElement("input"))
-            {
-                ReadInputChannel(pMesh->mPerVertexData);
-            }
-            else
-            {
-                ThrowException(format() << "Unexpected sub element <" << mReader->getNodeName() << "> in tag <vertices>");
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
-        {
-            if (strcmp(mReader->getNodeName(), "vertices") != 0)
-                ThrowException("Expected end of <vertices> element.");
-
-            break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads input declarations of per-index mesh data into the given mesh
-void ColladaParser::ReadIndexData(Mesh* pMesh)
-{
-    std::vector<size_t> vcount;
-    std::vector<InputChannel> perIndexData;
-
-    // read primitive count from the attribute
-    int attrCount = GetAttribute("count");
-    size_t numPrimitives = (size_t)mReader->getAttributeValueAsInt(attrCount);
-    // some mesh types (e.g. tristrips) don't specify primitive count upfront,
-    // so we need to sum up the actual number of primitives while we read the <p>-tags
-    size_t actualPrimitives = 0;
-
-    // material subgroup
-    int attrMaterial = TestAttribute("material");
-    SubMesh subgroup;
-    if (attrMaterial > -1)
-        subgroup.mMaterial = mReader->getAttributeValue(attrMaterial);
-
-    // distinguish between polys and triangles
-    std::string elementName = mReader->getNodeName();
-    PrimitiveType primType = Prim_Invalid;
-    if (IsElement("lines"))
-        primType = Prim_Lines;
-    else if (IsElement("linestrips"))
-        primType = Prim_LineStrip;
-    else if (IsElement("polygons"))
-        primType = Prim_Polygon;
-    else if (IsElement("polylist"))
-        primType = Prim_Polylist;
-    else if (IsElement("triangles"))
-        primType = Prim_Triangles;
-    else if (IsElement("trifans"))
-        primType = Prim_TriFans;
-    else if (IsElement("tristrips"))
-        primType = Prim_TriStrips;
-
-    ai_assert(primType != Prim_Invalid);
-
-    // also a number of <input> elements, but in addition a <p> primitive collection and probably index counts for all primitives
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
-        {
-            if (IsElement("input"))
-            {
-                ReadInputChannel(perIndexData);
-            }
-            else if (IsElement("vcount"))
-            {
-                if (!mReader->isEmptyElement())
-                {
-                    if (numPrimitives)  // It is possible to define a mesh without any primitives
-                    {
-                        // case <polylist> - specifies the number of indices for each polygon
-                        const char* content = GetTextContent();
-                        vcount.reserve(numPrimitives);
-                        for (unsigned int a = 0; a < numPrimitives; a++)
-                        {
-                            if (*content == 0)
-                                ThrowException("Expected more values while reading <vcount> contents.");
-                            // read a number
-                            vcount.push_back((size_t)strtoul10(content, &content));
-                            // skip whitespace after it
-                            SkipSpacesAndLineEnd(&content);
-                        }
-                    }
-
-                    TestClosing("vcount");
-                }
-            }
-            else if (IsElement("p"))
-            {
-                if (!mReader->isEmptyElement())
-                {
-                    // now here the actual fun starts - these are the indices to construct the mesh data from
-                    actualPrimitives += ReadPrimitives(pMesh, perIndexData, numPrimitives, vcount, primType);
-                }
-            }
-            else if (IsElement("extra"))
-            {
-                SkipElement("extra");
-            }
-            else if (IsElement("ph")) {
-                SkipElement("ph");
-            }
-            else {
-                ThrowException(format() << "Unexpected sub element <" << mReader->getNodeName() << "> in tag <" << elementName << ">");
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
-        {
-            if (mReader->getNodeName() != elementName)
-                ThrowException(format() << "Expected end of <" << elementName << "> element.");
-
-            break;
-        }
-    }
-
-#ifdef ASSIMP_BUILD_DEBUG
-    if (primType != Prim_TriFans && primType != Prim_TriStrips && primType != Prim_LineStrip &&
-        primType != Prim_Lines) { // this is ONLY to workaround a bug in SketchUp 15.3.331 where it writes the wrong 'count' when it writes out the 'lines'.
-        ai_assert(actualPrimitives == numPrimitives);
-    }
-#endif
-
-    // only when we're done reading all <p> tags (and thus know the final vertex count) can we commit the submesh
-    subgroup.mNumFaces = actualPrimitives;
-    pMesh->mSubMeshes.push_back(subgroup);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads a single input channel element and stores it in the given array, if valid
-void ColladaParser::ReadInputChannel(std::vector<InputChannel>& poChannels)
-{
-    InputChannel channel;
-
-    // read semantic
-    int attrSemantic = GetAttribute("semantic");
-    std::string semantic = mReader->getAttributeValue(attrSemantic);
-    channel.mType = GetTypeForSemantic(semantic);
-
-    // read source
-    int attrSource = GetAttribute("source");
-    const char* source = mReader->getAttributeValue(attrSource);
-    if (source[0] != '#')
-        ThrowException(format() << "Unknown reference format in url \"" << source << "\" in source attribute of <input> element.");
-    channel.mAccessor = source + 1; // skipping the leading #, hopefully the remaining text is the accessor ID only
-
-    // read index offset, if per-index <input>
-    int attrOffset = TestAttribute("offset");
-    if (attrOffset > -1)
-        channel.mOffset = mReader->getAttributeValueAsInt(attrOffset);
-
-    // read set if texture coordinates
-    if (channel.mType == IT_Texcoord || channel.mType == IT_Color) {
-        int attrSet = TestAttribute("set");
-        if (attrSet > -1) {
-            attrSet = mReader->getAttributeValueAsInt(attrSet);
-            if (attrSet < 0)
-                ThrowException(format() << "Invalid index \"" << (attrSet) << "\" in set attribute of <input> element");
-
-            channel.mIndex = attrSet;
-        }
-    }
-
-    // store, if valid type
-    if (channel.mType != IT_Invalid)
-        poChannels.push_back(channel);
-
-    // skip remaining stuff of this element, if any
-    SkipElement();
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads a <p> primitive index list and assembles the mesh data into the given mesh
-size_t ColladaParser::ReadPrimitives(Mesh* pMesh, std::vector<InputChannel>& pPerIndexChannels,
-    size_t pNumPrimitives, const std::vector<size_t>& pVCount, PrimitiveType pPrimType)
-{
-    // determine number of indices coming per vertex
-    // find the offset index for all per-vertex channels
-    size_t numOffsets = 1;
-    size_t perVertexOffset = SIZE_MAX; // invalid value
-    for (const InputChannel& channel : pPerIndexChannels)
-    {
-        numOffsets = std::max(numOffsets, channel.mOffset + 1);
-        if (channel.mType == IT_Vertex)
-            perVertexOffset = channel.mOffset;
-    }
-
-    // determine the expected number of indices
-    size_t expectedPointCount = 0;
-    switch (pPrimType)
-    {
-    case Prim_Polylist:
-    {
-        for (size_t i : pVCount)
-            expectedPointCount += i;
-        break;
-    }
-    case Prim_Lines:
-        expectedPointCount = 2 * pNumPrimitives;
-        break;
-    case Prim_Triangles:
-        expectedPointCount = 3 * pNumPrimitives;
-        break;
-    default:
-        // other primitive types don't state the index count upfront... we need to guess
-        break;
-    }
-
-    // and read all indices into a temporary array
-    std::vector<size_t> indices;
-    if (expectedPointCount > 0)
-        indices.reserve(expectedPointCount * numOffsets);
-
-    if (pNumPrimitives > 0) // It is possible to not contain any indices
-    {
-        const char* content = GetTextContent();
-        while (*content != 0)
-        {
-            // read a value.
-            // Hack: (thom) Some exporters put negative indices sometimes. We just try to carry on anyways.
-            int value = std::max(0, strtol10(content, &content));
-            indices.push_back(size_t(value));
-            // skip whitespace after it
-            SkipSpacesAndLineEnd(&content);
-        }
-    }
-
-    // complain if the index count doesn't fit
-    if (expectedPointCount > 0 && indices.size() != expectedPointCount * numOffsets) {
-        if (pPrimType == Prim_Lines) {
-            // HACK: We just fix this number since SketchUp 15.3.331 writes the wrong 'count' for 'lines'
-            ReportWarning("Expected different index count in <p> element, %zu instead of %zu.", indices.size(), expectedPointCount * numOffsets);
-            pNumPrimitives = (indices.size() / numOffsets) / 2;
-        }
-        else
-            ThrowException("Expected different index count in <p> element.");
-
-    }
-    else if (expectedPointCount == 0 && (indices.size() % numOffsets) != 0)
-        ThrowException("Expected different index count in <p> element.");
-
-    // find the data for all sources
-    for (std::vector<InputChannel>::iterator it = pMesh->mPerVertexData.begin(); it != pMesh->mPerVertexData.end(); ++it)
-    {
-        InputChannel& input = *it;
-        if (input.mResolved)
-            continue;
-
-        // find accessor
-        input.mResolved = &ResolveLibraryReference(mAccessorLibrary, input.mAccessor);
-        // resolve accessor's data pointer as well, if necessary
-        const Accessor* acc = input.mResolved;
-        if (!acc->mData)
-            acc->mData = &ResolveLibraryReference(mDataLibrary, acc->mSource);
-    }
-    // and the same for the per-index channels
-    for (std::vector<InputChannel>::iterator it = pPerIndexChannels.begin(); it != pPerIndexChannels.end(); ++it)
-    {
-        InputChannel& input = *it;
-        if (input.mResolved)
-            continue;
-
-        // ignore vertex pointer, it doesn't refer to an accessor
-        if (input.mType == IT_Vertex)
-        {
-            // warn if the vertex channel does not refer to the <vertices> element in the same mesh
-            if (input.mAccessor != pMesh->mVertexID)
-                ThrowException("Unsupported vertex referencing scheme.");
-            continue;
-        }
-
-        // find accessor
-        input.mResolved = &ResolveLibraryReference(mAccessorLibrary, input.mAccessor);
-        // resolve accessor's data pointer as well, if necessary
-        const Accessor* acc = input.mResolved;
-        if (!acc->mData)
-            acc->mData = &ResolveLibraryReference(mDataLibrary, acc->mSource);
-    }
-
-    // For continued primitives, the given count does not come all in one <p>, but only one primitive per <p>
-    size_t numPrimitives = pNumPrimitives;
-    if (pPrimType == Prim_TriFans || pPrimType == Prim_Polygon)
-        numPrimitives = 1;
-    // For continued primitives, the given count is actually the number of <p>'s inside the parent tag
-    if (pPrimType == Prim_TriStrips) {
-        size_t numberOfVertices = indices.size() / numOffsets;
-        numPrimitives = numberOfVertices - 2;
-    }
-    if (pPrimType == Prim_LineStrip) {
-        size_t numberOfVertices = indices.size() / numOffsets;
-        numPrimitives = numberOfVertices - 1;
-    }
-
-    pMesh->mFaceSize.reserve(numPrimitives);
-    pMesh->mFacePosIndices.reserve(indices.size() / numOffsets);
-
-    size_t polylistStartVertex = 0;
-    for (size_t currentPrimitive = 0; currentPrimitive < numPrimitives; currentPrimitive++)
-    {
-        // determine number of points for this primitive
-        size_t numPoints = 0;
-        switch (pPrimType)
-        {
-        case Prim_Lines:
-            numPoints = 2;
-            for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++)
-                CopyVertex(currentVertex, numOffsets, numPoints, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
-            break;
-        case Prim_LineStrip:
-            numPoints = 2;
-            for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++)
-                CopyVertex(currentVertex, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
-            break;
-        case Prim_Triangles:
-            numPoints = 3;
-            for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++)
-                CopyVertex(currentVertex, numOffsets, numPoints, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
-            break;
-        case Prim_TriStrips:
-            numPoints = 3;
-            ReadPrimTriStrips(numOffsets, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
-            break;
-        case Prim_Polylist:
-            numPoints = pVCount[currentPrimitive];
-            for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++)
-                CopyVertex(polylistStartVertex + currentVertex, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, 0, indices);
-            polylistStartVertex += numPoints;
-            break;
-        case Prim_TriFans:
-        case Prim_Polygon:
-            numPoints = indices.size() / numOffsets;
-            for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++)
-                CopyVertex(currentVertex, numOffsets, numPoints, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
-            break;
-        default:
-            // LineStrip is not supported due to expected index unmangling
-            ThrowException("Unsupported primitive type.");
-            break;
-        }
-
-        // store the face size to later reconstruct the face from
-        pMesh->mFaceSize.push_back(numPoints);
-    }
-
-    // if I ever get my hands on that guy who invented this steaming pile of indirection...
-    TestClosing("p");
-    return numPrimitives;
-}
-
-///@note This function willn't work correctly if both PerIndex and PerVertex channels have same channels.
-///For example if TEXCOORD present in both <vertices> and <polylist> tags this function will create wrong uv coordinates.
-///It's not clear from COLLADA documentation is this allowed or not. For now only exporter fixed to avoid such behavior
-void ColladaParser::CopyVertex(size_t currentVertex, size_t numOffsets, size_t numPoints, size_t perVertexOffset, Mesh* pMesh, std::vector<InputChannel>& pPerIndexChannels, size_t currentPrimitive, const std::vector<size_t>& indices) {
-    // calculate the base offset of the vertex whose attributes we ant to copy
-    size_t baseOffset = currentPrimitive * numOffsets * numPoints + currentVertex * numOffsets;
-
-    // don't overrun the boundaries of the index list
-    ai_assert((baseOffset + numOffsets - 1) < indices.size());
-
-    // extract per-vertex channels using the global per-vertex offset
-    for (std::vector<InputChannel>::iterator it = pMesh->mPerVertexData.begin(); it != pMesh->mPerVertexData.end(); ++it)
-        ExtractDataObjectFromChannel(*it, indices[baseOffset + perVertexOffset], pMesh);
-    // and extract per-index channels using there specified offset
-    for (std::vector<InputChannel>::iterator it = pPerIndexChannels.begin(); it != pPerIndexChannels.end(); ++it)
-        ExtractDataObjectFromChannel(*it, indices[baseOffset + it->mOffset], pMesh);
-
-    // store the vertex-data index for later assignment of bone vertex weights
-    pMesh->mFacePosIndices.push_back(indices[baseOffset + perVertexOffset]);
-}
-
-void ColladaParser::ReadPrimTriStrips(size_t numOffsets, size_t perVertexOffset, Mesh* pMesh, std::vector<InputChannel>& pPerIndexChannels, size_t currentPrimitive, const std::vector<size_t>& indices) {
-    if (currentPrimitive % 2 != 0) {
-        //odd tristrip triangles need their indices mangled, to preserve winding direction
-        CopyVertex(1, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
-        CopyVertex(0, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
-        CopyVertex(2, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
-    }
-    else {//for non tristrips or even tristrip triangles
-        CopyVertex(0, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
-        CopyVertex(1, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
-        CopyVertex(2, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Extracts a single object from an input channel and stores it in the appropriate mesh data array
-void ColladaParser::ExtractDataObjectFromChannel(const InputChannel& pInput, size_t pLocalIndex, Mesh* pMesh)
-{
-    // ignore vertex referrer - we handle them that separate
-    if (pInput.mType == IT_Vertex)
-        return;
-
-    const Accessor& acc = *pInput.mResolved;
-    if (pLocalIndex >= acc.mCount)
-        ThrowException(format() << "Invalid data index (" << pLocalIndex << "/" << acc.mCount << ") in primitive specification");
-
-    // get a pointer to the start of the data object referred to by the accessor and the local index
-    const ai_real* dataObject = &(acc.mData->mValues[0]) + acc.mOffset + pLocalIndex * acc.mStride;
-
-    // assemble according to the accessors component sub-offset list. We don't care, yet,
-    // what kind of object exactly we're extracting here
-    ai_real obj[4];
-    for (size_t c = 0; c < 4; ++c)
-        obj[c] = dataObject[acc.mSubOffset[c]];
-
-    // now we reinterpret it according to the type we're reading here
-    switch (pInput.mType)
-    {
-    case IT_Position: // ignore all position streams except 0 - there can be only one position
-        if (pInput.mIndex == 0)
-            pMesh->mPositions.push_back(aiVector3D(obj[0], obj[1], obj[2]));
-        else
-            ASSIMP_LOG_ERROR("Collada: just one vertex position stream supported");
-        break;
-    case IT_Normal:
-        // pad to current vertex count if necessary
-        if (pMesh->mNormals.size() < pMesh->mPositions.size() - 1)
-            pMesh->mNormals.insert(pMesh->mNormals.end(), pMesh->mPositions.size() - pMesh->mNormals.size() - 1, aiVector3D(0, 1, 0));
-
-        // ignore all normal streams except 0 - there can be only one normal
-        if (pInput.mIndex == 0)
-            pMesh->mNormals.push_back(aiVector3D(obj[0], obj[1], obj[2]));
-        else
-            ASSIMP_LOG_ERROR("Collada: just one vertex normal stream supported");
-        break;
-    case IT_Tangent:
-        // pad to current vertex count if necessary
-        if (pMesh->mTangents.size() < pMesh->mPositions.size() - 1)
-            pMesh->mTangents.insert(pMesh->mTangents.end(), pMesh->mPositions.size() - pMesh->mTangents.size() - 1, aiVector3D(1, 0, 0));
-
-        // ignore all tangent streams except 0 - there can be only one tangent
-        if (pInput.mIndex == 0)
-            pMesh->mTangents.push_back(aiVector3D(obj[0], obj[1], obj[2]));
-        else
-            ASSIMP_LOG_ERROR("Collada: just one vertex tangent stream supported");
-        break;
-    case IT_Bitangent:
-        // pad to current vertex count if necessary
-        if (pMesh->mBitangents.size() < pMesh->mPositions.size() - 1)
-            pMesh->mBitangents.insert(pMesh->mBitangents.end(), pMesh->mPositions.size() - pMesh->mBitangents.size() - 1, aiVector3D(0, 0, 1));
-
-        // ignore all bitangent streams except 0 - there can be only one bitangent
-        if (pInput.mIndex == 0)
-            pMesh->mBitangents.push_back(aiVector3D(obj[0], obj[1], obj[2]));
-        else
-            ASSIMP_LOG_ERROR("Collada: just one vertex bitangent stream supported");
-        break;
-    case IT_Texcoord:
-        // up to 4 texture coord sets are fine, ignore the others
-        if (pInput.mIndex < AI_MAX_NUMBER_OF_TEXTURECOORDS)
-        {
-            // pad to current vertex count if necessary
-            if (pMesh->mTexCoords[pInput.mIndex].size() < pMesh->mPositions.size() - 1)
-                pMesh->mTexCoords[pInput.mIndex].insert(pMesh->mTexCoords[pInput.mIndex].end(),
-                    pMesh->mPositions.size() - pMesh->mTexCoords[pInput.mIndex].size() - 1, aiVector3D(0, 0, 0));
-
-            pMesh->mTexCoords[pInput.mIndex].push_back(aiVector3D(obj[0], obj[1], obj[2]));
-            if (0 != acc.mSubOffset[2] || 0 != acc.mSubOffset[3]) /* hack ... consider cleaner solution */
-                pMesh->mNumUVComponents[pInput.mIndex] = 3;
-        }
-        else
-        {
-            ASSIMP_LOG_ERROR("Collada: too many texture coordinate sets. Skipping.");
-        }
-        break;
-    case IT_Color:
-        // up to 4 color sets are fine, ignore the others
-        if (pInput.mIndex < AI_MAX_NUMBER_OF_COLOR_SETS)
-        {
-            // pad to current vertex count if necessary
-            if (pMesh->mColors[pInput.mIndex].size() < pMesh->mPositions.size() - 1)
-                pMesh->mColors[pInput.mIndex].insert(pMesh->mColors[pInput.mIndex].end(),
-                    pMesh->mPositions.size() - pMesh->mColors[pInput.mIndex].size() - 1, aiColor4D(0, 0, 0, 1));
-
-            aiColor4D result(0, 0, 0, 1);
-            for (size_t i = 0; i < pInput.mResolved->mSize; ++i)
-            {
-                result[static_cast<unsigned int>(i)] = obj[pInput.mResolved->mSubOffset[i]];
-            }
-            pMesh->mColors[pInput.mIndex].push_back(result);
-        }
-        else
-        {
-            ASSIMP_LOG_ERROR("Collada: too many vertex color sets. Skipping.");
-        }
-
-        break;
-    default:
-        // IT_Invalid and IT_Vertex
-        ai_assert(false && "shouldn't ever get here");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the library of node hierarchies and scene parts
-void ColladaParser::ReadSceneLibrary()
-{
-    if (mReader->isEmptyElement())
-        return;
-
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
-        {
-            // a visual scene - generate root node under its ID and let ReadNode() do the recursive work
-            if (IsElement("visual_scene"))
-            {
-                // read ID. Is optional according to the spec, but how on earth should a scene_instance refer to it then?
-                int indexID = GetAttribute("id");
-                const char* attrID = mReader->getAttributeValue(indexID);
-
-                // read name if given.
-                int indexName = TestAttribute("name");
-                const char* attrName = "unnamed";
-                if (indexName > -1)
-                    attrName = mReader->getAttributeValue(indexName);
-
-                // create a node and store it in the library under its ID
-                Node* node = new Node;
-                node->mID = attrID;
-                node->mName = attrName;
-                mNodeLibrary[node->mID] = node;
-
-                ReadSceneNode(node);
-            }
-            else
-            {
-                // ignore the rest
-                SkipElement();
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
-        {
-            if (strcmp(mReader->getNodeName(), "library_visual_scenes") == 0)
-                //ThrowException( "Expected end of \"library_visual_scenes\" element.");
-
-                break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads a scene node's contents including children and stores it in the given node
-void ColladaParser::ReadSceneNode(Node* pNode)
-{
-    // quit immediately on <bla/> elements
-    if (mReader->isEmptyElement())
-        return;
-
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
-        {
-            if (IsElement("node"))
-            {
-                Node* child = new Node;
-                int attrID = TestAttribute("id");
-                if (attrID > -1)
-                    child->mID = mReader->getAttributeValue(attrID);
-                int attrSID = TestAttribute("sid");
-                if (attrSID > -1)
-                    child->mSID = mReader->getAttributeValue(attrSID);
-
-                int attrName = TestAttribute("name");
-                if (attrName > -1)
-                    child->mName = mReader->getAttributeValue(attrName);
-
-                // TODO: (thom) support SIDs
-                // ai_assert( TestAttribute( "sid") == -1);
-
-                if (pNode)
-                {
-                    pNode->mChildren.push_back(child);
-                    child->mParent = pNode;
-                }
-                else
-                {
-                    // no parent node given, probably called from <library_nodes> element.
-                    // create new node in node library
-                    mNodeLibrary[child->mID] = child;
-                }
-
-                // read on recursively from there
-                ReadSceneNode(child);
-                continue;
-            }
-            // For any further stuff we need a valid node to work on
-            else if (!pNode)
-                continue;
-
-            if (IsElement("lookat"))
-                ReadNodeTransformation(pNode, TF_LOOKAT);
-            else if (IsElement("matrix"))
-                ReadNodeTransformation(pNode, TF_MATRIX);
-            else if (IsElement("rotate"))
-                ReadNodeTransformation(pNode, TF_ROTATE);
-            else if (IsElement("scale"))
-                ReadNodeTransformation(pNode, TF_SCALE);
-            else if (IsElement("skew"))
-                ReadNodeTransformation(pNode, TF_SKEW);
-            else if (IsElement("translate"))
-                ReadNodeTransformation(pNode, TF_TRANSLATE);
-            else if (IsElement("render") && pNode->mParent == NULL && 0 == pNode->mPrimaryCamera.length())
-            {
-                // ... scene evaluation or, in other words, postprocessing pipeline,
-                // or, again in other words, a turing-complete description how to
-                // render a Collada scene. The only thing that is interesting for
-                // us is the primary camera.
-                int attrId = TestAttribute("camera_node");
-                if (-1 != attrId)
-                {
-                    const char* s = mReader->getAttributeValue(attrId);
-                    if (s[0] != '#')
-                        ASSIMP_LOG_ERROR("Collada: Unresolved reference format of camera");
-                    else
-                        pNode->mPrimaryCamera = s + 1;
-                }
-            }
-            else if (IsElement("instance_node"))
-            {
-                // find the node in the library
-                int attrID = TestAttribute("url");
-                if (attrID != -1)
-                {
-                    const char* s = mReader->getAttributeValue(attrID);
-                    if (s[0] != '#')
-                        ASSIMP_LOG_ERROR("Collada: Unresolved reference format of node");
-                    else
-                    {
-                        pNode->mNodeInstances.push_back(NodeInstance());
-                        pNode->mNodeInstances.back().mNode = s + 1;
-                    }
-                }
-            }
-            else if (IsElement("instance_geometry") || IsElement("instance_controller"))
-            {
-                // Reference to a mesh or controller, with possible material associations
-                ReadNodeGeometry(pNode);
-            }
-            else if (IsElement("instance_light"))
-            {
-                // Reference to a light, name given in 'url' attribute
-                int attrID = TestAttribute("url");
-                if (-1 == attrID)
-                    ASSIMP_LOG_WARN("Collada: Expected url attribute in <instance_light> element");
-                else
-                {
-                    const char* url = mReader->getAttributeValue(attrID);
-                    if (url[0] != '#')
-                        ThrowException("Unknown reference format in <instance_light> element");
-
-                    pNode->mLights.push_back(LightInstance());
-                    pNode->mLights.back().mLight = url + 1;
-                }
-            }
-            else if (IsElement("instance_camera"))
-            {
-                // Reference to a camera, name given in 'url' attribute
-                int attrID = TestAttribute("url");
-                if (-1 == attrID)
-                    ASSIMP_LOG_WARN("Collada: Expected url attribute in <instance_camera> element");
-                else
-                {
-                    const char* url = mReader->getAttributeValue(attrID);
-                    if (url[0] != '#')
-                        ThrowException("Unknown reference format in <instance_camera> element");
-
-                    pNode->mCameras.push_back(CameraInstance());
-                    pNode->mCameras.back().mCamera = url + 1;
-                }
-            }
-            else
-            {
-                // skip everything else for the moment
-                SkipElement();
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
-            break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads a node transformation entry of the given type and adds it to the given node's transformation list.
-void ColladaParser::ReadNodeTransformation(Node* pNode, TransformType pType)
-{
-    if (mReader->isEmptyElement())
-        return;
-
-    std::string tagName = mReader->getNodeName();
-
-    Transform tf;
-    tf.mType = pType;
-
-    // read SID
-    int indexSID = TestAttribute("sid");
-    if (indexSID >= 0)
-        tf.mID = mReader->getAttributeValue(indexSID);
-
-    // how many parameters to read per transformation type
-    static const unsigned int sNumParameters[] = { 9, 4, 3, 3, 7, 16 };
-    const char* content = GetTextContent();
-
-    // read as many parameters and store in the transformation
-    for (unsigned int a = 0; a < sNumParameters[pType]; a++)
-    {
-        // read a number
-        content = fast_atoreal_move<ai_real>(content, tf.f[a]);
-        // skip whitespace after it
-        SkipSpacesAndLineEnd(&content);
-    }
-
-    // place the transformation at the queue of the node
-    pNode->mTransforms.push_back(tf);
-
-    // and consume the closing tag
-    TestClosing(tagName.c_str());
-}
-
-// ------------------------------------------------------------------------------------------------
-// Processes bind_vertex_input and bind elements
-void ColladaParser::ReadMaterialVertexInputBinding(Collada::SemanticMappingTable& tbl)
-{
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
-            if (IsElement("bind_vertex_input"))
-            {
-                Collada::InputSemanticMapEntry vn;
-
-                // effect semantic
-                int n = GetAttribute("semantic");
-                std::string s = mReader->getAttributeValue(n);
-
-                // input semantic
-                n = GetAttribute("input_semantic");
-                vn.mType = GetTypeForSemantic(mReader->getAttributeValue(n));
-
-                // index of input set
-                n = TestAttribute("input_set");
-                if (-1 != n)
-                    vn.mSet = mReader->getAttributeValueAsInt(n);
-
-                tbl.mMap[s] = vn;
-            }
-            else if (IsElement("bind")) {
-                ASSIMP_LOG_WARN("Collada: Found unsupported <bind> element");
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
-            if (strcmp(mReader->getNodeName(), "instance_material") == 0)
-                break;
-        }
-    }
-}
-
-void Assimp::ColladaParser::ReadEmbeddedTextures(ZipArchiveIOSystem& zip_archive)
-{
-    // Attempt to load any undefined Collada::Image in ImageLibrary
-    for (ImageLibrary::iterator it = mImageLibrary.begin(); it != mImageLibrary.end(); ++it) {
-        Collada::Image &image = (*it).second;
-
-        if (image.mImageData.empty()) {
-            std::unique_ptr<IOStream> image_file(zip_archive.Open(image.mFileName.c_str()));
-            if (image_file) {
-                image.mImageData.resize(image_file->FileSize());
-                image_file->Read(image.mImageData.data(), image_file->FileSize(), 1);
-                image.mEmbeddedFormat = BaseImporter::GetExtension(image.mFileName);
-                if (image.mEmbeddedFormat == "jpeg") {
-                    image.mEmbeddedFormat = "jpg";
-                }
-            }
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads a mesh reference in a node and adds it to the node's mesh list
-void ColladaParser::ReadNodeGeometry(Node* pNode)
-{
-    // referred mesh is given as an attribute of the <instance_geometry> element
-    int attrUrl = GetAttribute("url");
-    const char* url = mReader->getAttributeValue(attrUrl);
-    if (url[0] != '#')
-        ThrowException("Unknown reference format");
-
-    Collada::MeshInstance instance;
-    instance.mMeshOrController = url + 1; // skipping the leading #
-
-    if (!mReader->isEmptyElement())
-    {
-        // read material associations. Ignore additional elements in between
-        while (mReader->read())
-        {
-            if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
-            {
-                if (IsElement("instance_material"))
-                {
-                    // read ID of the geometry subgroup and the target material
-                    int attrGroup = GetAttribute("symbol");
-                    std::string group = mReader->getAttributeValue(attrGroup);
-                    int attrMaterial = GetAttribute("target");
-                    const char* urlMat = mReader->getAttributeValue(attrMaterial);
-                    Collada::SemanticMappingTable s;
-                    if (urlMat[0] == '#')
-                        urlMat++;
-
-                    s.mMatName = urlMat;
-
-                    // resolve further material details + THIS UGLY AND NASTY semantic mapping stuff
-                    if (!mReader->isEmptyElement())
-                        ReadMaterialVertexInputBinding(s);
-
-                    // store the association
-                    instance.mMaterials[group] = s;
-                }
-            }
-            else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
-            {
-                if (strcmp(mReader->getNodeName(), "instance_geometry") == 0
-                    || strcmp(mReader->getNodeName(), "instance_controller") == 0)
-                    break;
-            }
-        }
-    }
-
-    // store it
-    pNode->mMeshes.push_back(instance);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the collada scene
-void ColladaParser::ReadScene()
-{
-    if (mReader->isEmptyElement())
-        return;
-
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
-            if (IsElement("instance_visual_scene"))
-            {
-                // should be the first and only occurrence
-                if (mRootNode)
-                    ThrowException("Invalid scene containing multiple root nodes in <instance_visual_scene> element");
-
-                // read the url of the scene to instance. Should be of format "#some_name"
-                int urlIndex = GetAttribute("url");
-                const char* url = mReader->getAttributeValue(urlIndex);
-                if (url[0] != '#')
-                    ThrowException("Unknown reference format in <instance_visual_scene> element");
-
-                // find the referred scene, skip the leading #
-                NodeLibrary::const_iterator sit = mNodeLibrary.find(url + 1);
-                if (sit == mNodeLibrary.end())
-                    ThrowException("Unable to resolve visual_scene reference \"" + std::string(url) + "\" in <instance_visual_scene> element.");
-                mRootNode = sit->second;
-            }
-            else {
-                SkipElement();
-            }
-        }
-        else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
-            break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Aborts the file reading with an exception
-AI_WONT_RETURN void ColladaParser::ThrowException(const std::string& pError) const
-{
-    throw DeadlyImportError(format() << "Collada: " << mFileName << " - " << pError);
-}
-void ColladaParser::ReportWarning(const char* msg, ...)
-{
-    ai_assert(NULL != msg);
-
-    va_list args;
-    va_start(args, msg);
-
-    char szBuffer[3000];
-    const int iLen = vsprintf(szBuffer, msg, args);
-    ai_assert(iLen > 0);
-
-    va_end(args);
-    ASSIMP_LOG_WARN_F("Validation warning: ", std::string(szBuffer, iLen));
-}
-
-// ------------------------------------------------------------------------------------------------
-// Skips all data until the end node of the current element
-void ColladaParser::SkipElement()
-{
-    // nothing to skip if it's an <element />
-    if (mReader->isEmptyElement())
-        return;
-
-    // reroute
-    SkipElement(mReader->getNodeName());
-}
-
-// ------------------------------------------------------------------------------------------------
-// Skips all data until the end node of the given element
-void ColladaParser::SkipElement(const char* pElement)
-{
-    // copy the current node's name because it'a pointer to the reader's internal buffer,
-    // which is going to change with the upcoming parsing
-    std::string element = pElement;
-    while (mReader->read())
-    {
-        if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
-            if (mReader->getNodeName() == element)
-                break;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Tests for an opening element of the given name, throws an exception if not found
-void ColladaParser::TestOpening(const char* pName)
-{
-    // read element start
-    if (!mReader->read())
-        ThrowException(format() << "Unexpected end of file while beginning of <" << pName << "> element.");
-    // whitespace in front is ok, just read again if found
-    if (mReader->getNodeType() == irr::io::EXN_TEXT)
-        if (!mReader->read())
-            ThrowException(format() << "Unexpected end of file while reading beginning of <" << pName << "> element.");
-
-    if (mReader->getNodeType() != irr::io::EXN_ELEMENT || strcmp(mReader->getNodeName(), pName) != 0)
-        ThrowException(format() << "Expected start of <" << pName << "> element.");
-}
-
-// ------------------------------------------------------------------------------------------------
-// Tests for the closing tag of the given element, throws an exception if not found
-void ColladaParser::TestClosing(const char* pName)
-{
-    // check if we're already on the closing tag and return right away
-    if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END && strcmp(mReader->getNodeName(), pName) == 0)
-        return;
-
-    // if not, read some more
-    if (!mReader->read())
-        ThrowException(format() << "Unexpected end of file while reading end of <" << pName << "> element.");
-    // whitespace in front is ok, just read again if found
-    if (mReader->getNodeType() == irr::io::EXN_TEXT)
-        if (!mReader->read())
-            ThrowException(format() << "Unexpected end of file while reading end of <" << pName << "> element.");
-
-    // but this has the be the closing tag, or we're lost
-    if (mReader->getNodeType() != irr::io::EXN_ELEMENT_END || strcmp(mReader->getNodeName(), pName) != 0)
-        ThrowException(format() << "Expected end of <" << pName << "> element.");
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns the index of the named attribute or -1 if not found. Does not throw, therefore useful for optional attributes
-int ColladaParser::GetAttribute(const char* pAttr) const
-{
-    int index = TestAttribute(pAttr);
-    if (index != -1)
-        return index;
-
-    // attribute not found -> throw an exception
-    ThrowException(format() << "Expected attribute \"" << pAttr << "\" for element <" << mReader->getNodeName() << ">.");
-    return -1;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Tests the present element for the presence of one attribute, returns its index or throws an exception if not found
-int ColladaParser::TestAttribute(const char* pAttr) const
-{
-    for (int a = 0; a < mReader->getAttributeCount(); a++)
-        if (strcmp(mReader->getAttributeName(a), pAttr) == 0)
-            return a;
-
-    return -1;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the text contents of an element, throws an exception if not given. Skips leading whitespace.
-const char* ColladaParser::GetTextContent()
-{
-    const char* sz = TestTextContent();
-    if (!sz) {
-        ThrowException("Invalid contents in element \"n\".");
-    }
-    return sz;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the text contents of an element, returns NULL if not given. Skips leading whitespace.
-const char* ColladaParser::TestTextContent()
-{
-    // present node should be the beginning of an element
-    if (mReader->getNodeType() != irr::io::EXN_ELEMENT || mReader->isEmptyElement())
-        return NULL;
-
-    // read contents of the element
-    if (!mReader->read())
-        return NULL;
-    if (mReader->getNodeType() != irr::io::EXN_TEXT && mReader->getNodeType() != irr::io::EXN_CDATA)
-        return NULL;
-
-    // skip leading whitespace
-    const char* text = mReader->getNodeData();
-    SkipSpacesAndLineEnd(&text);
-
-    return text;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Calculates the resulting transformation fromm all the given transform steps
-aiMatrix4x4 ColladaParser::CalculateResultTransform(const std::vector<Transform>& pTransforms) const
-{
-    aiMatrix4x4 res;
-
-    for (std::vector<Transform>::const_iterator it = pTransforms.begin(); it != pTransforms.end(); ++it)
-    {
-        const Transform& tf = *it;
-        switch (tf.mType)
-        {
-        case TF_LOOKAT:
-        {
-            aiVector3D pos(tf.f[0], tf.f[1], tf.f[2]);
-            aiVector3D dstPos(tf.f[3], tf.f[4], tf.f[5]);
-            aiVector3D up = aiVector3D(tf.f[6], tf.f[7], tf.f[8]).Normalize();
-            aiVector3D dir = aiVector3D(dstPos - pos).Normalize();
-            aiVector3D right = (dir ^ up).Normalize();
-
-            res *= aiMatrix4x4(
-                right.x, up.x, -dir.x, pos.x,
-                right.y, up.y, -dir.y, pos.y,
-                right.z, up.z, -dir.z, pos.z,
-                0, 0, 0, 1);
-            break;
-        }
-        case TF_ROTATE:
-        {
-            aiMatrix4x4 rot;
-            ai_real angle = tf.f[3] * ai_real(AI_MATH_PI) / ai_real(180.0);
-            aiVector3D axis(tf.f[0], tf.f[1], tf.f[2]);
-            aiMatrix4x4::Rotation(angle, axis, rot);
-            res *= rot;
-            break;
-        }
-        case TF_TRANSLATE:
-        {
-            aiMatrix4x4 trans;
-            aiMatrix4x4::Translation(aiVector3D(tf.f[0], tf.f[1], tf.f[2]), trans);
-            res *= trans;
-            break;
-        }
-        case TF_SCALE:
-        {
-            aiMatrix4x4 scale(tf.f[0], 0.0f, 0.0f, 0.0f, 0.0f, tf.f[1], 0.0f, 0.0f, 0.0f, 0.0f, tf.f[2], 0.0f,
-                0.0f, 0.0f, 0.0f, 1.0f);
-            res *= scale;
-            break;
-        }
-        case TF_SKEW:
-            // TODO: (thom)
-            ai_assert(false);
-            break;
-        case TF_MATRIX:
-        {
-            aiMatrix4x4 mat(tf.f[0], tf.f[1], tf.f[2], tf.f[3], tf.f[4], tf.f[5], tf.f[6], tf.f[7],
-                tf.f[8], tf.f[9], tf.f[10], tf.f[11], tf.f[12], tf.f[13], tf.f[14], tf.f[15]);
-            res *= mat;
-            break;
-        }
-        default:
-            ai_assert(false);
-            break;
-        }
-    }
-
-    return res;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Determines the input data type for the given semantic string
-Collada::InputType ColladaParser::GetTypeForSemantic(const std::string& semantic)
-{
-    if (semantic.empty()) {
-        ASSIMP_LOG_WARN("Vertex input type is empty.");
-        return IT_Invalid;
-    }
-
-    if (semantic == "POSITION")
-        return IT_Position;
-    else if (semantic == "TEXCOORD")
-        return IT_Texcoord;
-    else if (semantic == "NORMAL")
-        return IT_Normal;
-    else if (semantic == "COLOR")
-        return IT_Color;
-    else if (semantic == "VERTEX")
-        return IT_Vertex;
-    else if (semantic == "BINORMAL" || semantic == "TEXBINORMAL")
-        return IT_Bitangent;
-    else if (semantic == "TANGENT" || semantic == "TEXTANGENT")
-        return IT_Tangent;
-
-    ASSIMP_LOG_WARN_F("Unknown vertex input type \"", semantic, "\". Ignoring.");
-    return IT_Invalid;
-}
-
-#endif // !! ASSIMP_BUILD_NO_DAE_IMPORTER
diff --git a/Engine/lib/assimp/code/Collada/ColladaParser.h b/Engine/lib/assimp/code/Collada/ColladaParser.h
deleted file mode 100644
index a2c9a4ff2..000000000
--- a/Engine/lib/assimp/code/Collada/ColladaParser.h
+++ /dev/null
@@ -1,393 +0,0 @@
-/*
- Open Asset Import Library (assimp)
- ----------------------------------------------------------------------
-
- Copyright (c) 2006-2019, assimp team
-
-
- All rights reserved.
-
- Redistribution and use of this software in source and binary forms,
- with or without modification, are permitted provided that the
- following conditions are met:
-
- * Redistributions of source code must retain the above
- copyright notice, this list of conditions and the
- following disclaimer.
-
- * Redistributions in binary form must reproduce the above
- copyright notice, this list of conditions and the
- following disclaimer in the documentation and/or other
- materials provided with the distribution.
-
- * Neither the name of the assimp team, nor the names of its
- contributors may be used to endorse or promote products
- derived from this software without specific prior
- written permission of the assimp team.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
- ----------------------------------------------------------------------
- */
-
-/** @file ColladaParser.h
- *  @brief Defines the parser helper class for the collada loader
- */
-
-#ifndef AI_COLLADAPARSER_H_INC
-#define AI_COLLADAPARSER_H_INC
-
-#include <assimp/irrXMLWrapper.h>
-#include "ColladaHelper.h"
-#include <assimp/ai_assert.h>
-#include <assimp/TinyFormatter.h>
-
-namespace Assimp
-{
-    class ZipArchiveIOSystem;
-
-    // ------------------------------------------------------------------------------------------
-    /** Parser helper class for the Collada loader.
-     *
-     *  Does all the XML reading and builds internal data structures from it,
-     *  but leaves the resolving of all the references to the loader.
-     */
-    class ColladaParser
-    {
-        friend class ColladaLoader;
-
-    protected:
-        /** Map for generic metadata as aiString */
-        typedef std::map<std::string, aiString> StringMetaData;
-
-        /** Constructor from XML file */
-        ColladaParser( IOSystem* pIOHandler, const std::string& pFile);
-
-        /** Destructor */
-        ~ColladaParser();
-
-        /** Attempts to read the ZAE manifest and returns the DAE to open */
-        static std::string ReadZaeManifest(ZipArchiveIOSystem &zip_archive);
-
-        /** Reads the contents of the file */
-        void ReadContents();
-
-        /** Reads the structure of the file */
-        void ReadStructure();
-
-        /** Reads asset information such as coordinate system information and legal blah */
-        void ReadAssetInfo();
-
-        /** Reads contributor information such as author and legal blah */
-        void ReadContributorInfo();
-
-        /** Reads generic metadata into provided map */
-        void ReadMetaDataItem(StringMetaData &metadata);
-
-        /** Convert underscore_seperated to CamelCase "authoring_tool" becomes "AuthoringTool" */
-        static void ToCamelCase(std::string &text);
-
-        /** Reads the animation library */
-        void ReadAnimationLibrary();
-
-		/** Reads the animation clip library */
-		void ReadAnimationClipLibrary();
-
-        /** Unwrap controllers dependency hierarchy */
-        void PostProcessControllers();
-    
-		/** Re-build animations from animation clip library, if present, otherwise combine single-channel animations */
-		void PostProcessRootAnimations();
-
-        /** Reads an animation into the given parent structure */
-        void ReadAnimation( Collada::Animation* pParent);
-
-        /** Reads an animation sampler into the given anim channel */
-        void ReadAnimationSampler( Collada::AnimationChannel& pChannel);
-
-        /** Reads the skeleton controller library */
-        void ReadControllerLibrary();
-
-        /** Reads a controller into the given mesh structure */
-        void ReadController( Collada::Controller& pController);
-
-        /** Reads the joint definitions for the given controller */
-        void ReadControllerJoints( Collada::Controller& pController);
-
-        /** Reads the joint weights for the given controller */
-        void ReadControllerWeights( Collada::Controller& pController);
-
-        /** Reads the image library contents */
-        void ReadImageLibrary();
-
-        /** Reads an image entry into the given image */
-        void ReadImage( Collada::Image& pImage);
-
-        /** Reads the material library */
-        void ReadMaterialLibrary();
-
-        /** Reads a material entry into the given material */
-        void ReadMaterial( Collada::Material& pMaterial);
-
-        /** Reads the camera library */
-        void ReadCameraLibrary();
-
-        /** Reads a camera entry into the given camera */
-        void ReadCamera( Collada::Camera& pCamera);
-
-        /** Reads the light library */
-        void ReadLightLibrary();
-
-        /** Reads a light entry into the given light */
-        void ReadLight( Collada::Light& pLight);
-
-        /** Reads the effect library */
-        void ReadEffectLibrary();
-
-        /** Reads an effect entry into the given effect*/
-        void ReadEffect( Collada::Effect& pEffect);
-
-        /** Reads an COMMON effect profile */
-        void ReadEffectProfileCommon( Collada::Effect& pEffect);
-
-        /** Read sampler properties */
-        void ReadSamplerProperties( Collada::Sampler& pSampler);
-
-        /** Reads an effect entry containing a color or a texture defining that color */
-        void ReadEffectColor( aiColor4D& pColor, Collada::Sampler& pSampler);
-
-        /** Reads an effect entry containing a float */
-        void ReadEffectFloat( ai_real& pFloat);
-
-        /** Reads an effect parameter specification of any kind */
-        void ReadEffectParam( Collada::EffectParam& pParam);
-
-        /** Reads the geometry library contents */
-        void ReadGeometryLibrary();
-
-        /** Reads a geometry from the geometry library. */
-        void ReadGeometry( Collada::Mesh* pMesh);
-
-        /** Reads a mesh from the geometry library */
-        void ReadMesh( Collada::Mesh* pMesh);
-
-        /** Reads a source element - a combination of raw data and an accessor defining
-         * things that should not be redefinable. Yes, that's another rant.
-         */
-        void ReadSource();
-
-        /** Reads a data array holding a number of elements, and stores it in the global library.
-         * Currently supported are array of floats and arrays of strings.
-         */
-        void ReadDataArray();
-
-        /** Reads an accessor and stores it in the global library under the given ID -
-         * accessors use the ID of the parent <source> element
-         */
-        void ReadAccessor( const std::string& pID);
-
-        /** Reads input declarations of per-vertex mesh data into the given mesh */
-        void ReadVertexData( Collada::Mesh* pMesh);
-
-        /** Reads input declarations of per-index mesh data into the given mesh */
-        void ReadIndexData( Collada::Mesh* pMesh);
-
-        /** Reads a single input channel element and stores it in the given array, if valid */
-        void ReadInputChannel( std::vector<Collada::InputChannel>& poChannels);
-
-        /** Reads a <p> primitive index list and assembles the mesh data into the given mesh */
-        size_t ReadPrimitives( Collada::Mesh* pMesh, std::vector<Collada::InputChannel>& pPerIndexChannels,
-                              size_t pNumPrimitives, const std::vector<size_t>& pVCount, Collada::PrimitiveType pPrimType);
-
-        /** Copies the data for a single primitive into the mesh, based on the InputChannels */
-        void CopyVertex(size_t currentVertex, size_t numOffsets, size_t numPoints, size_t perVertexOffset,
-                        Collada::Mesh* pMesh, std::vector<Collada::InputChannel>& pPerIndexChannels,
-                        size_t currentPrimitive, const std::vector<size_t>& indices);
-
-        /** Reads one triangle of a tristrip into the mesh */
-        void ReadPrimTriStrips(size_t numOffsets, size_t perVertexOffset, Collada::Mesh* pMesh,
-                               std::vector<Collada::InputChannel>& pPerIndexChannels, size_t currentPrimitive, const std::vector<size_t>& indices);
-
-        /** Extracts a single object from an input channel and stores it in the appropriate mesh data array */
-        void ExtractDataObjectFromChannel( const Collada::InputChannel& pInput, size_t pLocalIndex, Collada::Mesh* pMesh);
-
-        /** Reads the library of node hierarchies and scene parts */
-        void ReadSceneLibrary();
-
-        /** Reads a scene node's contents including children and stores it in the given node */
-        void ReadSceneNode( Collada::Node* pNode);
-
-        /** Reads a node transformation entry of the given type and adds it to the given node's transformation list. */
-        void ReadNodeTransformation( Collada::Node* pNode, Collada::TransformType pType);
-
-        /** Reads a mesh reference in a node and adds it to the node's mesh list */
-        void ReadNodeGeometry( Collada::Node* pNode);
-
-        /** Reads the collada scene */
-        void ReadScene();
-
-        // Processes bind_vertex_input and bind elements
-        void ReadMaterialVertexInputBinding( Collada::SemanticMappingTable& tbl);
-
-        /** Reads embedded textures from a ZAE archive*/
-        void ReadEmbeddedTextures(ZipArchiveIOSystem &zip_archive);
-
-    protected:
-        /** Aborts the file reading with an exception */
-        AI_WONT_RETURN void ThrowException( const std::string& pError) const AI_WONT_RETURN_SUFFIX;
-        void ReportWarning(const char* msg,...);
-
-        /** Skips all data until the end node of the current element */
-        void SkipElement();
-
-        /** Skips all data until the end node of the given element */
-        void SkipElement( const char* pElement);
-
-        /** Compares the current xml element name to the given string and returns true if equal */
-        bool IsElement( const char* pName) const;
-
-        /** Tests for the opening tag of the given element, throws an exception if not found */
-        void TestOpening( const char* pName);
-
-        /** Tests for the closing tag of the given element, throws an exception if not found */
-        void TestClosing( const char* pName);
-
-        /** Checks the present element for the presence of the attribute, returns its index
-         or throws an exception if not found */
-        int GetAttribute( const char* pAttr) const;
-
-        /** Returns the index of the named attribute or -1 if not found. Does not throw,
-         therefore useful for optional attributes */
-        int TestAttribute( const char* pAttr) const;
-
-        /** Reads the text contents of an element, throws an exception if not given.
-         Skips leading whitespace. */
-        const char* GetTextContent();
-
-        /** Reads the text contents of an element, returns NULL if not given.
-         Skips leading whitespace. */
-        const char* TestTextContent();
-
-        /** Reads a single bool from current text content */
-        bool ReadBoolFromTextContent();
-
-        /** Reads a single float from current text content */
-        ai_real ReadFloatFromTextContent();
-
-        /** Calculates the resulting transformation from all the given transform steps */
-        aiMatrix4x4 CalculateResultTransform( const std::vector<Collada::Transform>& pTransforms) const;
-
-        /** Determines the input data type for the given semantic string */
-        Collada::InputType GetTypeForSemantic( const std::string& pSemantic);
-
-        /** Finds the item in the given library by its reference, throws if not found */
-        template <typename Type> const Type& ResolveLibraryReference( const std::map<std::string, Type>& pLibrary, const std::string& pURL) const;
-
-    protected:
-        /** Filename, for a verbose error message */
-        std::string mFileName;
-
-        /** XML reader, member for everyday use */
-        irr::io::IrrXMLReader* mReader;
-
-        /** All data arrays found in the file by ID. Might be referred to by actually
-         everyone. Collada, you are a steaming pile of indirection. */
-        typedef std::map<std::string, Collada::Data> DataLibrary;
-        DataLibrary mDataLibrary;
-
-        /** Same for accessors which define how the data in a data array is accessed. */
-        typedef std::map<std::string, Collada::Accessor> AccessorLibrary;
-        AccessorLibrary mAccessorLibrary;
-
-        /** Mesh library: mesh by ID */
-        typedef std::map<std::string, Collada::Mesh*> MeshLibrary;
-        MeshLibrary mMeshLibrary;
-
-        /** node library: root node of the hierarchy part by ID */
-        typedef std::map<std::string, Collada::Node*> NodeLibrary;
-        NodeLibrary mNodeLibrary;
-
-        /** Image library: stores texture properties by ID */
-        typedef std::map<std::string, Collada::Image> ImageLibrary;
-        ImageLibrary mImageLibrary;
-
-        /** Effect library: surface attributes by ID */
-        typedef std::map<std::string, Collada::Effect> EffectLibrary;
-        EffectLibrary mEffectLibrary;
-
-        /** Material library: surface material by ID */
-        typedef std::map<std::string, Collada::Material> MaterialLibrary;
-        MaterialLibrary mMaterialLibrary;
-
-        /** Light library: surface light by ID */
-        typedef std::map<std::string, Collada::Light> LightLibrary;
-        LightLibrary mLightLibrary;
-
-        /** Camera library: surface material by ID */
-        typedef std::map<std::string, Collada::Camera> CameraLibrary;
-        CameraLibrary mCameraLibrary;
-
-        /** Controller library: joint controllers by ID */
-        typedef std::map<std::string, Collada::Controller> ControllerLibrary;
-        ControllerLibrary mControllerLibrary;
-
-		/** Animation library: animation references by ID */
-		typedef std::map<std::string, Collada::Animation*> AnimationLibrary;
-		AnimationLibrary mAnimationLibrary;
-
-		/** Animation clip library: clip animation references by ID */
-		typedef std::vector<std::pair<std::string, std::vector<std::string> > > AnimationClipLibrary;
-		AnimationClipLibrary mAnimationClipLibrary;
-
-        /** Pointer to the root node. Don't delete, it just points to one of
-         the nodes in the node library. */
-        Collada::Node* mRootNode;
-
-        /** Root animation container */
-        Collada::Animation mAnims;
-
-        /** Size unit: how large compared to a meter */
-        ai_real mUnitSize;
-
-        /** Which is the up vector */
-        enum { UP_X, UP_Y, UP_Z } mUpDirection;
-
-        /** Asset metadata (global for scene) */
-        StringMetaData mAssetMetaData;
-
-        /** Collada file format version */
-        Collada::FormatVersion mFormat;
-    };
-
-    // ------------------------------------------------------------------------------------------------
-    // Check for element match
-    inline bool ColladaParser::IsElement( const char* pName) const
-    {
-        ai_assert( mReader->getNodeType() == irr::io::EXN_ELEMENT);
-        return ::strcmp( mReader->getNodeName(), pName) == 0;
-    }
-
-    // ------------------------------------------------------------------------------------------------
-    // Finds the item in the given library by its reference, throws if not found
-    template <typename Type>
-    const Type& ColladaParser::ResolveLibraryReference( const std::map<std::string, Type>& pLibrary, const std::string& pURL) const
-    {
-        typename std::map<std::string, Type>::const_iterator it = pLibrary.find( pURL);
-        if( it == pLibrary.end())
-            ThrowException( Formatter::format() << "Unable to resolve library reference \"" << pURL << "\"." );
-        return it->second;
-    }
-
-} // end of namespace Assimp
-
-#endif // AI_COLLADAPARSER_H_INC
diff --git a/Engine/lib/assimp/code/Common/AssertHandler.cpp b/Engine/lib/assimp/code/Common/AssertHandler.cpp
new file mode 100644
index 000000000..d0bd6ccad
--- /dev/null
+++ b/Engine/lib/assimp/code/Common/AssertHandler.cpp
@@ -0,0 +1,72 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file  AssertHandler.cpp
+ *  @brief Implementation of assert handling logic.
+ */
+
+#include "AssertHandler.h"
+
+#include <iostream>
+#include <cstdlib>
+
+void Assimp::defaultAiAssertHandler(const char* failedExpression, const char* file, int line)
+{
+    std::cerr << "ai_assert failure in " << file << "(" << line << "): " << failedExpression << std::endl;
+    std::abort();
+}
+
+namespace
+{
+    Assimp::AiAssertHandler s_handler = Assimp::defaultAiAssertHandler;
+}
+
+void Assimp::setAiAssertHandler(AiAssertHandler handler)
+{
+    s_handler = handler;
+}
+
+void Assimp::aiAssertViolation(const char* failedExpression, const char* file, int line)
+{
+    s_handler(failedExpression, file, line);
+}
diff --git a/Engine/lib/assimp/code/Common/AssertHandler.h b/Engine/lib/assimp/code/Common/AssertHandler.h
new file mode 100644
index 000000000..2515f0bf2
--- /dev/null
+++ b/Engine/lib/assimp/code/Common/AssertHandler.h
@@ -0,0 +1,75 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2020, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file Provides facilities to replace the default assert handler. */
+
+#ifndef INCLUDED_AI_ASSERTHANDLER_H
+#define INCLUDED_AI_ASSERTHANDLER_H
+
+#include <assimp/ai_assert.h>
+#include <assimp/defs.h>
+
+namespace Assimp
+{
+    // ---------------------------------------------------------------------------
+    /** Signature of functions which handle assert violations.
+     */
+    using AiAssertHandler = void (*)(const char* failedExpression, const char* file, int line);
+
+    // ---------------------------------------------------------------------------
+    /** Set the assert handler.
+     */
+    ASSIMP_API void setAiAssertHandler(AiAssertHandler handler);
+
+    // ---------------------------------------------------------------------------
+    /** The assert handler which is set by default.
+     *
+     * This issues a message to stderr and calls abort.
+     */
+    ASSIMP_API void defaultAiAssertHandler(const char* failedExpression, const char* file, int line);
+
+    // ---------------------------------------------------------------------------
+    /** Dispatches an assert violation to the assert handler.
+     */
+    ASSIMP_API void aiAssertViolation(const char* failedExpression, const char* file, int line);
+} // end of namespace Assimp
+
+#endif // INCLUDED_AI_ASSERTHANDLER_H
\ No newline at end of file
diff --git a/Engine/lib/assimp/code/Common/Assimp.cpp b/Engine/lib/assimp/code/Common/Assimp.cpp
index 178b2c01d..71e312cee 100644
--- a/Engine/lib/assimp/code/Common/Assimp.cpp
+++ b/Engine/lib/assimp/code/Common/Assimp.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -44,15 +44,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Implementation of the Plain-C API
  */
 
+#include <assimp/BaseImporter.h>
+#include <assimp/Exceptional.h>
+#include <assimp/GenericProperty.h>
 #include <assimp/cimport.h>
-#include <assimp/LogStream.hpp>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/Importer.hpp>
 #include <assimp/importerdesc.h>
 #include <assimp/scene.h>
-#include <assimp/GenericProperty.h>
-#include <assimp/Exceptional.h>
-#include <assimp/BaseImporter.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/Importer.hpp>
+#include <assimp/LogStream.hpp>
 
 #include "CApi/CInterfaceIOWrapper.h"
 #include "Importer.h"
@@ -62,46 +62,58 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // ------------------------------------------------------------------------------------------------
 #ifndef ASSIMP_BUILD_SINGLETHREADED
-#   include <thread>
-#   include <mutex>
+#include <mutex>
+#include <thread>
 #endif
 // ------------------------------------------------------------------------------------------------
 using namespace Assimp;
 
 namespace Assimp {
-    // underlying structure for aiPropertyStore
-    typedef BatchLoader::PropertyMap PropertyMap;
+// underlying structure for aiPropertyStore
+typedef BatchLoader::PropertyMap PropertyMap;
 
-    /** Stores the LogStream objects for all active C log streams */
-    struct mpred {
-        bool operator  () (const aiLogStream& s0, const aiLogStream& s1) const  {
-            return s0.callback<s1.callback&&s0.user<s1.user;
-        }
-    };
-    typedef std::map<aiLogStream, Assimp::LogStream*, mpred> LogStreamMap;
+#if defined(__has_warning)
+#if __has_warning("-Wordered-compare-function-pointers")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wordered-compare-function-pointers"
+#endif
+#endif
 
-    /** Stores the LogStream objects allocated by #aiGetPredefinedLogStream */
-    typedef std::list<Assimp::LogStream*> PredefLogStreamMap;
+/** Stores the LogStream objects for all active C log streams */
+struct mpred {
+    bool operator()(const aiLogStream &s0, const aiLogStream &s1) const {
+        return s0.callback < s1.callback && s0.user < s1.user;
+    }
+};
 
-    /** Local storage of all active log streams */
-    static LogStreamMap gActiveLogStreams;
+#if defined(__has_warning)
+#if __has_warning("-Wordered-compare-function-pointers")
+#pragma GCC diagnostic pop
+#endif
+#endif
+typedef std::map<aiLogStream, Assimp::LogStream *, mpred> LogStreamMap;
 
-    /** Local storage of LogStreams allocated by #aiGetPredefinedLogStream */
-    static PredefLogStreamMap gPredefinedStreams;
+/** Stores the LogStream objects allocated by #aiGetPredefinedLogStream */
+typedef std::list<Assimp::LogStream *> PredefLogStreamMap;
 
-    /** Error message of the last failed import process */
-    static std::string gLastErrorString;
+/** Local storage of all active log streams */
+static LogStreamMap gActiveLogStreams;
 
-    /** Verbose logging active or not? */
-    static aiBool gVerboseLogging = false;
+/** Local storage of LogStreams allocated by #aiGetPredefinedLogStream */
+static PredefLogStreamMap gPredefinedStreams;
 
-    /** will return all registered importers. */
-    void GetImporterInstanceList(std::vector< BaseImporter* >& out);
+/** Error message of the last failed import process */
+static std::string gLastErrorString;
 
-    /** will delete all registered importers. */
-    void DeleteImporterInstanceList(std::vector< BaseImporter* >& out);
-} // namespace assimp
+/** Verbose logging active or not? */
+static aiBool gVerboseLogging = false;
 
+/** will return all registered importers. */
+void GetImporterInstanceList(std::vector<BaseImporter *> &out);
+
+/** will delete all registered importers. */
+void DeleteImporterInstanceList(std::vector<BaseImporter *> &out);
+} // namespace Assimp
 
 #ifndef ASSIMP_BUILD_SINGLETHREADED
 /** Global mutex to manage the access to the log-stream map */
@@ -112,12 +124,12 @@ static std::mutex gLogStreamMutex;
 // Custom LogStream implementation for the C-API
 class LogToCallbackRedirector : public LogStream {
 public:
-    explicit LogToCallbackRedirector(const aiLogStream& s)
-    : stream (s)    {
-        ai_assert(NULL != s.callback);
+    explicit LogToCallbackRedirector(const aiLogStream &s) :
+            stream(s) {
+        ai_assert(nullptr != s.callback);
     }
 
-    ~LogToCallbackRedirector()  {
+    ~LogToCallbackRedirector() {
 #ifndef ASSIMP_BUILD_SINGLETHREADED
         std::lock_guard<std::mutex> lock(gLogStreamMutex);
 #endif
@@ -127,7 +139,7 @@ public:
         // might cause strange problems, but the chance is quite low.
 
         PredefLogStreamMap::iterator it = std::find(gPredefinedStreams.begin(),
-            gPredefinedStreams.end(), (Assimp::LogStream*)stream.user);
+                gPredefinedStreams.end(), (Assimp::LogStream *)stream.user);
 
         if (it != gPredefinedStreams.end()) {
             delete *it;
@@ -136,8 +148,8 @@ public:
     }
 
     /** @copydoc LogStream::write */
-    void write(const char* message) {
-        stream.callback(message,stream.user);
+    void write(const char *message) {
+        stream.callback(message, stream.user);
     }
 
 private:
@@ -147,37 +159,37 @@ private:
 // ------------------------------------------------------------------------------------------------
 void ReportSceneNotFoundError() {
     ASSIMP_LOG_ERROR("Unable to find the Assimp::Importer for this aiScene. "
-        "The C-API does not accept scenes produced by the C++ API and vice versa");
+                     "The C-API does not accept scenes produced by the C++ API and vice versa");
 
     ai_assert(false);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Reads the given file and returns its content.
-const aiScene* aiImportFile( const char* pFile, unsigned int pFlags) {
-    return aiImportFileEx(pFile,pFlags,NULL);
+const aiScene *aiImportFile(const char *pFile, unsigned int pFlags) {
+    return aiImportFileEx(pFile, pFlags, nullptr);
 }
 
 // ------------------------------------------------------------------------------------------------
-const aiScene* aiImportFileEx( const char* pFile, unsigned int pFlags,  aiFileIO* pFS) {
-    return aiImportFileExWithProperties(pFile, pFlags, pFS, NULL);
+const aiScene *aiImportFileEx(const char *pFile, unsigned int pFlags, aiFileIO *pFS) {
+    return aiImportFileExWithProperties(pFile, pFlags, pFS, nullptr);
 }
 
 // ------------------------------------------------------------------------------------------------
-const aiScene* aiImportFileExWithProperties( const char* pFile, unsigned int pFlags, 
-        aiFileIO* pFS, const aiPropertyStore* props) {
-    ai_assert(NULL != pFile);
+const aiScene *aiImportFileExWithProperties(const char *pFile, unsigned int pFlags,
+        aiFileIO *pFS, const aiPropertyStore *props) {
+    ai_assert(nullptr != pFile);
 
-    const aiScene* scene = NULL;
+    const aiScene *scene = nullptr;
     ASSIMP_BEGIN_EXCEPTION_REGION();
 
     // create an Importer for this file
-    Assimp::Importer* imp = new Assimp::Importer();
+    Assimp::Importer *imp = new Assimp::Importer();
 
     // copy properties
-    if(props) {
-        const PropertyMap* pp = reinterpret_cast<const PropertyMap*>(props);
-        ImporterPimpl* pimpl = imp->Pimpl();
+    if (props) {
+        const PropertyMap *pp = reinterpret_cast<const PropertyMap *>(props);
+        ImporterPimpl *pimpl = imp->Pimpl();
         pimpl->mIntProperties = pp->ints;
         pimpl->mFloatProperties = pp->floats;
         pimpl->mStringProperties = pp->strings;
@@ -185,15 +197,15 @@ const aiScene* aiImportFileExWithProperties( const char* pFile, unsigned int pFl
     }
     // setup a custom IO system if necessary
     if (pFS) {
-        imp->SetIOHandler( new CIOSystemWrapper (pFS) );
+        imp->SetIOHandler(new CIOSystemWrapper(pFS));
     }
 
     // and have it read the file
-    scene = imp->ReadFile( pFile, pFlags);
+    scene = imp->ReadFile(pFile, pFlags);
 
     // if succeeded, store the importer in the scene and keep it alive
-    if( scene)  {
-        ScenePrivateData* priv = const_cast<ScenePrivateData*>( ScenePriv(scene) );
+    if (scene) {
+        ScenePrivateData *priv = const_cast<ScenePrivateData *>(ScenePriv(scene));
         priv->mOrigImporter = imp;
     } else {
         // if failed, extract error code and destroy the import
@@ -201,43 +213,41 @@ const aiScene* aiImportFileExWithProperties( const char* pFile, unsigned int pFl
         delete imp;
     }
 
-    // return imported data. If the import failed the pointer is NULL anyways
-    ASSIMP_END_EXCEPTION_REGION(const aiScene*);
-    
+    // return imported data. If the import failed the pointer is nullptr anyways
+    ASSIMP_END_EXCEPTION_REGION(const aiScene *);
+
     return scene;
 }
 
 // ------------------------------------------------------------------------------------------------
-const aiScene* aiImportFileFromMemory(
-    const char* pBuffer,
-    unsigned int pLength,
-    unsigned int pFlags,
-    const char* pHint)
-{
-    return aiImportFileFromMemoryWithProperties(pBuffer, pLength, pFlags, pHint, NULL);
+const aiScene *aiImportFileFromMemory(
+        const char *pBuffer,
+        unsigned int pLength,
+        unsigned int pFlags,
+        const char *pHint) {
+    return aiImportFileFromMemoryWithProperties(pBuffer, pLength, pFlags, pHint, nullptr);
 }
 
 // ------------------------------------------------------------------------------------------------
-const aiScene* aiImportFileFromMemoryWithProperties(
-    const char* pBuffer,
-    unsigned int pLength,
-    unsigned int pFlags,
-    const char* pHint,
-    const aiPropertyStore* props)
-{
-    ai_assert( NULL != pBuffer );
-    ai_assert( 0 != pLength );
+const aiScene *aiImportFileFromMemoryWithProperties(
+        const char *pBuffer,
+        unsigned int pLength,
+        unsigned int pFlags,
+        const char *pHint,
+        const aiPropertyStore *props) {
+    ai_assert(nullptr != pBuffer);
+    ai_assert(0 != pLength);
 
-    const aiScene* scene = NULL;
+    const aiScene *scene = nullptr;
     ASSIMP_BEGIN_EXCEPTION_REGION();
 
     // create an Importer for this file
-    Assimp::Importer* imp = new Assimp::Importer();
+    Assimp::Importer *imp = new Assimp::Importer();
 
     // copy properties
-    if(props) {
-        const PropertyMap* pp = reinterpret_cast<const PropertyMap*>(props);
-        ImporterPimpl* pimpl = imp->Pimpl();
+    if (props) {
+        const PropertyMap *pp = reinterpret_cast<const PropertyMap *>(props);
+        ImporterPimpl *pimpl = imp->Pimpl();
         pimpl->mIntProperties = pp->ints;
         pimpl->mFloatProperties = pp->floats;
         pimpl->mStringProperties = pp->strings;
@@ -245,27 +255,25 @@ const aiScene* aiImportFileFromMemoryWithProperties(
     }
 
     // and have it read the file from the memory buffer
-    scene = imp->ReadFileFromMemory( pBuffer, pLength, pFlags,pHint);
+    scene = imp->ReadFileFromMemory(pBuffer, pLength, pFlags, pHint);
 
     // if succeeded, store the importer in the scene and keep it alive
-    if( scene)  {
-         ScenePrivateData* priv = const_cast<ScenePrivateData*>( ScenePriv(scene) );
-         priv->mOrigImporter = imp;
-    }
-    else    {
+    if (scene) {
+        ScenePrivateData *priv = const_cast<ScenePrivateData *>(ScenePriv(scene));
+        priv->mOrigImporter = imp;
+    } else {
         // if failed, extract error code and destroy the import
         gLastErrorString = imp->GetErrorString();
         delete imp;
     }
-    // return imported data. If the import failed the pointer is NULL anyways
-    ASSIMP_END_EXCEPTION_REGION(const aiScene*);
+    // return imported data. If the import failed the pointer is nullptr anyways
+    ASSIMP_END_EXCEPTION_REGION(const aiScene *);
     return scene;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Releases all resources associated with the given import process.
-void aiReleaseImport( const aiScene* pScene)
-{
+void aiReleaseImport(const aiScene *pScene) {
     if (!pScene) {
         return;
     }
@@ -273,15 +281,14 @@ void aiReleaseImport( const aiScene* pScene)
     ASSIMP_BEGIN_EXCEPTION_REGION();
 
     // find the importer associated with this data
-    const ScenePrivateData* priv = ScenePriv(pScene);
-    if( !priv || !priv->mOrigImporter)  {
+    const ScenePrivateData *priv = ScenePriv(pScene);
+    if (!priv || !priv->mOrigImporter) {
         delete pScene;
-    }
-    else {
+    } else {
         // deleting the Importer also deletes the scene
         // Note: the reason that this is not written as 'delete priv->mOrigImporter'
         // is a suspected bug in gcc 4.4+ (http://gcc.gnu.org/bugzilla/show_bug.cgi?id=52339)
-        Importer* importer = priv->mOrigImporter;
+        Importer *importer = priv->mOrigImporter;
         delete importer;
     }
 
@@ -289,83 +296,78 @@ void aiReleaseImport( const aiScene* pScene)
 }
 
 // ------------------------------------------------------------------------------------------------
-ASSIMP_API const aiScene* aiApplyPostProcessing(const aiScene* pScene,
-    unsigned int pFlags)
-{
-    const aiScene* sc = NULL;
-
+ASSIMP_API const aiScene *aiApplyPostProcessing(const aiScene *pScene,
+        unsigned int pFlags) {
+    const aiScene *sc = nullptr;
 
     ASSIMP_BEGIN_EXCEPTION_REGION();
 
     // find the importer associated with this data
-    const ScenePrivateData* priv = ScenePriv(pScene);
-    if( !priv || !priv->mOrigImporter)  {
+    const ScenePrivateData *priv = ScenePriv(pScene);
+    if (!priv || !priv->mOrigImporter) {
         ReportSceneNotFoundError();
-        return NULL;
+        return nullptr;
     }
 
     sc = priv->mOrigImporter->ApplyPostProcessing(pFlags);
 
     if (!sc) {
         aiReleaseImport(pScene);
-        return NULL;
+        return nullptr;
     }
 
-    ASSIMP_END_EXCEPTION_REGION(const aiScene*);
+    ASSIMP_END_EXCEPTION_REGION(const aiScene *);
     return sc;
 }
 
 // ------------------------------------------------------------------------------------------------
-ASSIMP_API const aiScene *aiApplyCustomizedPostProcessing( const aiScene *scene,
-                                                           BaseProcess* process,
-                                                           bool requestValidation ) {
-    const aiScene* sc( NULL );
+ASSIMP_API const aiScene *aiApplyCustomizedPostProcessing(const aiScene *scene,
+        BaseProcess *process,
+        bool requestValidation) {
+    const aiScene *sc(nullptr);
 
     ASSIMP_BEGIN_EXCEPTION_REGION();
 
     // find the importer associated with this data
-    const ScenePrivateData* priv = ScenePriv( scene );
-    if ( NULL == priv || NULL == priv->mOrigImporter ) {
+    const ScenePrivateData *priv = ScenePriv(scene);
+    if (nullptr == priv || nullptr == priv->mOrigImporter) {
         ReportSceneNotFoundError();
-        return NULL;
+        return nullptr;
     }
 
-    sc = priv->mOrigImporter->ApplyCustomizedPostProcessing( process, requestValidation );
+    sc = priv->mOrigImporter->ApplyCustomizedPostProcessing(process, requestValidation);
 
-    if ( !sc ) {
-        aiReleaseImport( scene );
-        return NULL;
+    if (!sc) {
+        aiReleaseImport(scene);
+        return nullptr;
     }
 
-    ASSIMP_END_EXCEPTION_REGION( const aiScene* );
+    ASSIMP_END_EXCEPTION_REGION(const aiScene *);
 
     return sc;
 }
 
 // ------------------------------------------------------------------------------------------------
-void CallbackToLogRedirector (const char* msg, char* dt)
-{
-    ai_assert( NULL != msg );
-    ai_assert( NULL != dt );
-    LogStream* s = (LogStream*)dt;
+void CallbackToLogRedirector(const char *msg, char *dt) {
+    ai_assert(nullptr != msg);
+    ai_assert(nullptr != dt);
+    LogStream *s = (LogStream *)dt;
 
     s->write(msg);
 }
 
 // ------------------------------------------------------------------------------------------------
-ASSIMP_API aiLogStream aiGetPredefinedLogStream(aiDefaultLogStream pStream,const char* file)
-{
+ASSIMP_API aiLogStream aiGetPredefinedLogStream(aiDefaultLogStream pStream, const char *file) {
     aiLogStream sout;
 
     ASSIMP_BEGIN_EXCEPTION_REGION();
-    LogStream* stream = LogStream::createDefaultStream(pStream,file);
+    LogStream *stream = LogStream::createDefaultStream(pStream, file);
     if (!stream) {
-        sout.callback = NULL;
-        sout.user = NULL;
-    }
-    else {
+        sout.callback = nullptr;
+        sout.user = nullptr;
+    } else {
         sout.callback = &CallbackToLogRedirector;
-        sout.user = (char*)stream;
+        sout.user = (char *)stream;
     }
     gPredefinedStreams.push_back(stream);
     ASSIMP_END_EXCEPTION_REGION(aiLogStream);
@@ -373,42 +375,40 @@ ASSIMP_API aiLogStream aiGetPredefinedLogStream(aiDefaultLogStream pStream,const
 }
 
 // ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiAttachLogStream( const aiLogStream* stream )
-{
+ASSIMP_API void aiAttachLogStream(const aiLogStream *stream) {
     ASSIMP_BEGIN_EXCEPTION_REGION();
 
 #ifndef ASSIMP_BUILD_SINGLETHREADED
     std::lock_guard<std::mutex> lock(gLogStreamMutex);
 #endif
 
-    LogStream* lg = new LogToCallbackRedirector(*stream);
+    LogStream *lg = new LogToCallbackRedirector(*stream);
     gActiveLogStreams[*stream] = lg;
 
     if (DefaultLogger::isNullLogger()) {
-        DefaultLogger::create(NULL,(gVerboseLogging == AI_TRUE ? Logger::VERBOSE : Logger::NORMAL));
+        DefaultLogger::create(nullptr, (gVerboseLogging == AI_TRUE ? Logger::VERBOSE : Logger::NORMAL));
     }
     DefaultLogger::get()->attachStream(lg);
     ASSIMP_END_EXCEPTION_REGION(void);
 }
 
 // ------------------------------------------------------------------------------------------------
-ASSIMP_API aiReturn aiDetachLogStream( const aiLogStream* stream)
-{
+ASSIMP_API aiReturn aiDetachLogStream(const aiLogStream *stream) {
     ASSIMP_BEGIN_EXCEPTION_REGION();
 
 #ifndef ASSIMP_BUILD_SINGLETHREADED
     std::lock_guard<std::mutex> lock(gLogStreamMutex);
 #endif
     // find the log-stream associated with this data
-    LogStreamMap::iterator it = gActiveLogStreams.find( *stream);
+    LogStreamMap::iterator it = gActiveLogStreams.find(*stream);
     // it should be there... else the user is playing fools with us
-    if( it == gActiveLogStreams.end())  {
+    if (it == gActiveLogStreams.end()) {
         return AI_FAILURE;
     }
-    DefaultLogger::get()->detatchStream( it->second );
+    DefaultLogger::get()->detachStream(it->second);
     delete it->second;
 
-    gActiveLogStreams.erase( it);
+    gActiveLogStreams.erase(it);
 
     if (gActiveLogStreams.empty()) {
         DefaultLogger::kill();
@@ -418,19 +418,18 @@ ASSIMP_API aiReturn aiDetachLogStream( const aiLogStream* stream)
 }
 
 // ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiDetachAllLogStreams(void)
-{
+ASSIMP_API void aiDetachAllLogStreams(void) {
     ASSIMP_BEGIN_EXCEPTION_REGION();
 #ifndef ASSIMP_BUILD_SINGLETHREADED
     std::lock_guard<std::mutex> lock(gLogStreamMutex);
 #endif
-    Logger *logger( DefaultLogger::get() );
-    if ( NULL == logger ) {
+    Logger *logger(DefaultLogger::get());
+    if (nullptr == logger) {
         return;
     }
 
     for (LogStreamMap::iterator it = gActiveLogStreams.begin(); it != gActiveLogStreams.end(); ++it) {
-        logger->detatchStream( it->second );
+        logger->detachStream(it->second);
         delete it->second;
     }
     gActiveLogStreams.clear();
@@ -440,8 +439,7 @@ ASSIMP_API void aiDetachAllLogStreams(void)
 }
 
 // ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiEnableVerboseLogging(aiBool d)
-{
+ASSIMP_API void aiEnableVerboseLogging(aiBool d) {
     if (!DefaultLogger::isNullLogger()) {
         DefaultLogger::get()->setLogSeverity((d == AI_TRUE ? Logger::VERBOSE : Logger::NORMAL));
     }
@@ -450,31 +448,27 @@ ASSIMP_API void aiEnableVerboseLogging(aiBool d)
 
 // ------------------------------------------------------------------------------------------------
 // Returns the error text of the last failed import process.
-const char* aiGetErrorString()
-{
+const char *aiGetErrorString() {
     return gLastErrorString.c_str();
 }
 
 // -----------------------------------------------------------------------------------------------
 // Return the description of a importer given its index
-const aiImporterDesc* aiGetImportFormatDescription( size_t pIndex)
-{
+const aiImporterDesc *aiGetImportFormatDescription(size_t pIndex) {
     return Importer().GetImporterInfo(pIndex);
 }
 
 // -----------------------------------------------------------------------------------------------
 // Return the number of importers
-size_t aiGetImportFormatCount(void)
-{
+size_t aiGetImportFormatCount(void) {
     return Importer().GetImporterCount();
 }
 
 // ------------------------------------------------------------------------------------------------
 // Returns the error text of the last failed import process.
-aiBool aiIsExtensionSupported(const char* szExtension)
-{
-    ai_assert(NULL != szExtension);
-    aiBool candoit=AI_FALSE;
+aiBool aiIsExtensionSupported(const char *szExtension) {
+    ai_assert(nullptr != szExtension);
+    aiBool candoit = AI_FALSE;
     ASSIMP_BEGIN_EXCEPTION_REGION();
 
     // FIXME: no need to create a temporary Importer instance just for that ..
@@ -487,9 +481,8 @@ aiBool aiIsExtensionSupported(const char* szExtension)
 
 // ------------------------------------------------------------------------------------------------
 // Get a list of all file extensions supported by ASSIMP
-void aiGetExtensionList(aiString* szOut)
-{
-    ai_assert(NULL != szOut);
+void aiGetExtensionList(aiString *szOut) {
+    ai_assert(nullptr != szOut);
     ASSIMP_BEGIN_EXCEPTION_REGION();
 
     // FIXME: no need to create a temporary Importer instance just for that ..
@@ -501,14 +494,13 @@ void aiGetExtensionList(aiString* szOut)
 
 // ------------------------------------------------------------------------------------------------
 // Get the memory requirements for a particular import.
-void aiGetMemoryRequirements(const C_STRUCT aiScene* pIn,
-    C_STRUCT aiMemoryInfo* in)
-{
+void aiGetMemoryRequirements(const C_STRUCT aiScene *pIn,
+        C_STRUCT aiMemoryInfo *in) {
     ASSIMP_BEGIN_EXCEPTION_REGION();
 
     // find the importer associated with this data
-    const ScenePrivateData* priv = ScenePriv(pIn);
-    if( !priv || !priv->mOrigImporter)  {
+    const ScenePrivateData *priv = ScenePriv(pIn);
+    if (!priv || !priv->mOrigImporter) {
         ReportSceneNotFoundError();
         return;
     }
@@ -518,118 +510,106 @@ void aiGetMemoryRequirements(const C_STRUCT aiScene* pIn,
 }
 
 // ------------------------------------------------------------------------------------------------
-ASSIMP_API aiPropertyStore* aiCreatePropertyStore(void)
-{
-    return reinterpret_cast<aiPropertyStore*>( new PropertyMap() );
+ASSIMP_API aiPropertyStore *aiCreatePropertyStore(void) {
+    return reinterpret_cast<aiPropertyStore *>(new PropertyMap());
 }
 
 // ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiReleasePropertyStore(aiPropertyStore* p)
-{
-    delete reinterpret_cast<PropertyMap*>(p);
+ASSIMP_API void aiReleasePropertyStore(aiPropertyStore *p) {
+    delete reinterpret_cast<PropertyMap *>(p);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Importer::SetPropertyInteger
-ASSIMP_API void aiSetImportPropertyInteger(aiPropertyStore* p, const char* szName, int value)
-{
+ASSIMP_API void aiSetImportPropertyInteger(aiPropertyStore *p, const char *szName, int value) {
     ASSIMP_BEGIN_EXCEPTION_REGION();
-    PropertyMap* pp = reinterpret_cast<PropertyMap*>(p);
-    SetGenericProperty<int>(pp->ints,szName,value);
+    PropertyMap *pp = reinterpret_cast<PropertyMap *>(p);
+    SetGenericProperty<int>(pp->ints, szName, value);
     ASSIMP_END_EXCEPTION_REGION(void);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Importer::SetPropertyFloat
-ASSIMP_API void aiSetImportPropertyFloat(aiPropertyStore* p, const char* szName, ai_real value)
-{
+ASSIMP_API void aiSetImportPropertyFloat(aiPropertyStore *p, const char *szName, ai_real value) {
     ASSIMP_BEGIN_EXCEPTION_REGION();
-    PropertyMap* pp = reinterpret_cast<PropertyMap*>(p);
-    SetGenericProperty<ai_real>(pp->floats,szName,value);
+    PropertyMap *pp = reinterpret_cast<PropertyMap *>(p);
+    SetGenericProperty<ai_real>(pp->floats, szName, value);
     ASSIMP_END_EXCEPTION_REGION(void);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Importer::SetPropertyString
-ASSIMP_API void aiSetImportPropertyString(aiPropertyStore* p, const char* szName,
-    const C_STRUCT aiString* st)
-{
+ASSIMP_API void aiSetImportPropertyString(aiPropertyStore *p, const char *szName,
+        const C_STRUCT aiString *st) {
     if (!st) {
         return;
     }
     ASSIMP_BEGIN_EXCEPTION_REGION();
-    PropertyMap* pp = reinterpret_cast<PropertyMap*>(p);
-    SetGenericProperty<std::string>(pp->strings,szName,std::string(st->C_Str()));
+    PropertyMap *pp = reinterpret_cast<PropertyMap *>(p);
+    SetGenericProperty<std::string>(pp->strings, szName, std::string(st->C_Str()));
     ASSIMP_END_EXCEPTION_REGION(void);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Importer::SetPropertyMatrix
-ASSIMP_API void aiSetImportPropertyMatrix(aiPropertyStore* p, const char* szName,
-    const C_STRUCT aiMatrix4x4* mat)
-{
+ASSIMP_API void aiSetImportPropertyMatrix(aiPropertyStore *p, const char *szName,
+        const C_STRUCT aiMatrix4x4 *mat) {
     if (!mat) {
         return;
     }
     ASSIMP_BEGIN_EXCEPTION_REGION();
-    PropertyMap* pp = reinterpret_cast<PropertyMap*>(p);
-    SetGenericProperty<aiMatrix4x4>(pp->matrices,szName,*mat);
+    PropertyMap *pp = reinterpret_cast<PropertyMap *>(p);
+    SetGenericProperty<aiMatrix4x4>(pp->matrices, szName, *mat);
     ASSIMP_END_EXCEPTION_REGION(void);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Rotation matrix to quaternion
-ASSIMP_API void aiCreateQuaternionFromMatrix(aiQuaternion* quat,const aiMatrix3x3* mat)
-{
-    ai_assert( NULL != quat );
-    ai_assert( NULL != mat );
+ASSIMP_API void aiCreateQuaternionFromMatrix(aiQuaternion *quat, const aiMatrix3x3 *mat) {
+    ai_assert(nullptr != quat);
+    ai_assert(nullptr != mat);
     *quat = aiQuaternion(*mat);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Matrix decomposition
-ASSIMP_API void aiDecomposeMatrix(const aiMatrix4x4* mat,aiVector3D* scaling,
-    aiQuaternion* rotation,
-    aiVector3D* position)
-{
-    ai_assert( NULL != rotation );
-    ai_assert( NULL != position );
-    ai_assert( NULL != scaling );
-    ai_assert( NULL != mat );
-    mat->Decompose(*scaling,*rotation,*position);
+ASSIMP_API void aiDecomposeMatrix(const aiMatrix4x4 *mat, aiVector3D *scaling,
+        aiQuaternion *rotation,
+        aiVector3D *position) {
+    ai_assert(nullptr != rotation);
+    ai_assert(nullptr != position);
+    ai_assert(nullptr != scaling);
+    ai_assert(nullptr != mat);
+    mat->Decompose(*scaling, *rotation, *position);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Matrix transpose
-ASSIMP_API void aiTransposeMatrix3(aiMatrix3x3* mat)
-{
-    ai_assert(NULL != mat);
+ASSIMP_API void aiTransposeMatrix3(aiMatrix3x3 *mat) {
+    ai_assert(nullptr != mat);
     mat->Transpose();
 }
 
 // ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiTransposeMatrix4(aiMatrix4x4* mat)
-{
-    ai_assert(NULL != mat);
+ASSIMP_API void aiTransposeMatrix4(aiMatrix4x4 *mat) {
+    ai_assert(nullptr != mat);
     mat->Transpose();
 }
 
 // ------------------------------------------------------------------------------------------------
 // Vector transformation
-ASSIMP_API void aiTransformVecByMatrix3(aiVector3D* vec,
-    const aiMatrix3x3* mat)
-{
-    ai_assert( NULL != mat );
-    ai_assert( NULL != vec);
+ASSIMP_API void aiTransformVecByMatrix3(aiVector3D *vec,
+        const aiMatrix3x3 *mat) {
+    ai_assert(nullptr != mat);
+    ai_assert(nullptr != vec);
     *vec *= (*mat);
 }
 
 // ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiTransformVecByMatrix4(aiVector3D* vec,
-    const aiMatrix4x4* mat)
-{
-    ai_assert( NULL != mat );
-    ai_assert( NULL != vec );
+ASSIMP_API void aiTransformVecByMatrix4(aiVector3D *vec,
+        const aiMatrix4x4 *mat) {
+    ai_assert(nullptr != mat);
+    ai_assert(nullptr != vec);
 
     *vec *= (*mat);
 }
@@ -637,52 +617,48 @@ ASSIMP_API void aiTransformVecByMatrix4(aiVector3D* vec,
 // ------------------------------------------------------------------------------------------------
 // Matrix multiplication
 ASSIMP_API void aiMultiplyMatrix4(
-    aiMatrix4x4* dst,
-    const aiMatrix4x4* src)
-{
-    ai_assert( NULL != dst );
-    ai_assert( NULL != src );
+        aiMatrix4x4 *dst,
+        const aiMatrix4x4 *src) {
+    ai_assert(nullptr != dst);
+    ai_assert(nullptr != src);
     *dst = (*dst) * (*src);
 }
 
 // ------------------------------------------------------------------------------------------------
 ASSIMP_API void aiMultiplyMatrix3(
-    aiMatrix3x3* dst,
-    const aiMatrix3x3* src)
-{
-    ai_assert( NULL != dst );
-    ai_assert( NULL != src );
+        aiMatrix3x3 *dst,
+        const aiMatrix3x3 *src) {
+    ai_assert(nullptr != dst);
+    ai_assert(nullptr != src);
     *dst = (*dst) * (*src);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Matrix identity
 ASSIMP_API void aiIdentityMatrix3(
-    aiMatrix3x3* mat)
-{
-    ai_assert(NULL != mat);
+        aiMatrix3x3 *mat) {
+    ai_assert(nullptr != mat);
     *mat = aiMatrix3x3();
 }
 
 // ------------------------------------------------------------------------------------------------
 ASSIMP_API void aiIdentityMatrix4(
-    aiMatrix4x4* mat)
-{
-    ai_assert(NULL != mat);
+        aiMatrix4x4 *mat) {
+    ai_assert(nullptr != mat);
     *mat = aiMatrix4x4();
 }
 
 // ------------------------------------------------------------------------------------------------
-ASSIMP_API C_STRUCT const aiImporterDesc* aiGetImporterDesc( const char *extension ) {
-    if( NULL == extension ) {
-        return NULL;
+ASSIMP_API C_STRUCT const aiImporterDesc *aiGetImporterDesc(const char *extension) {
+    if (nullptr == extension) {
+        return nullptr;
     }
-    const aiImporterDesc *desc( NULL );
-    std::vector< BaseImporter* > out;
-    GetImporterInstanceList( out );
-    for( size_t i = 0; i < out.size(); ++i ) {
-        if( 0 == strncmp( out[ i ]->GetInfo()->mFileExtensions, extension, strlen( extension ) ) ) {
-            desc = out[ i ]->GetInfo();
+    const aiImporterDesc *desc(nullptr);
+    std::vector<BaseImporter *> out;
+    GetImporterInstanceList(out);
+    for (size_t i = 0; i < out.size(); ++i) {
+        if (0 == strncmp(out[i]->GetInfo()->mFileExtensions, extension, strlen(extension))) {
+            desc = out[i]->GetInfo();
             break;
         }
     }
@@ -693,3 +669,631 @@ ASSIMP_API C_STRUCT const aiImporterDesc* aiGetImporterDesc( const char *extensi
 }
 
 // ------------------------------------------------------------------------------------------------
+ASSIMP_API int aiVector2AreEqual(
+        const C_STRUCT aiVector2D *a,
+        const C_STRUCT aiVector2D *b) {
+    ai_assert(nullptr != a);
+    ai_assert(nullptr != b);
+    return *a == *b;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API int aiVector2AreEqualEpsilon(
+        const C_STRUCT aiVector2D *a,
+        const C_STRUCT aiVector2D *b,
+        const float epsilon) {
+    ai_assert(nullptr != a);
+    ai_assert(nullptr != b);
+    return a->Equal(*b, epsilon);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector2Add(
+        C_STRUCT aiVector2D *dst,
+        const C_STRUCT aiVector2D *src) {
+    ai_assert(nullptr != dst);
+    ai_assert(nullptr != src);
+    *dst = *dst + *src;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector2Subtract(
+        C_STRUCT aiVector2D *dst,
+        const C_STRUCT aiVector2D *src) {
+    ai_assert(nullptr != dst);
+    ai_assert(nullptr != src);
+    *dst = *dst - *src;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector2Scale(
+        C_STRUCT aiVector2D *dst,
+        const float s) {
+    ai_assert(nullptr != dst);
+    *dst *= s;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector2SymMul(
+        C_STRUCT aiVector2D *dst,
+        const C_STRUCT aiVector2D *other) {
+    ai_assert(nullptr != dst);
+    ai_assert(nullptr != other);
+    *dst = dst->SymMul(*other);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector2DivideByScalar(
+        C_STRUCT aiVector2D *dst,
+        const float s) {
+    ai_assert(nullptr != dst);
+    *dst /= s;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector2DivideByVector(
+        C_STRUCT aiVector2D *dst,
+        C_STRUCT aiVector2D *v) {
+    ai_assert(nullptr != dst);
+    ai_assert(nullptr != v);
+    *dst = *dst / *v;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API float aiVector2Length(
+        const C_STRUCT aiVector2D *v) {
+    ai_assert(nullptr != v);
+    return v->Length();
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API float aiVector2SquareLength(
+        const C_STRUCT aiVector2D *v) {
+    ai_assert(nullptr != v);
+    return v->SquareLength();
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector2Negate(
+        C_STRUCT aiVector2D *dst) {
+    ai_assert(nullptr != dst);
+    *dst = -(*dst);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API float aiVector2DotProduct(
+        const C_STRUCT aiVector2D *a,
+        const C_STRUCT aiVector2D *b) {
+    ai_assert(nullptr != a);
+    ai_assert(nullptr != b);
+    return (*a) * (*b);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector2Normalize(
+        C_STRUCT aiVector2D *v) {
+    ai_assert(nullptr != v);
+    v->Normalize();
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API int aiVector3AreEqual(
+        const C_STRUCT aiVector3D *a,
+        const C_STRUCT aiVector3D *b) {
+    ai_assert(nullptr != a);
+    ai_assert(nullptr != b);
+    return *a == *b;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API int aiVector3AreEqualEpsilon(
+        const C_STRUCT aiVector3D *a,
+        const C_STRUCT aiVector3D *b,
+        const float epsilon) {
+    ai_assert(nullptr != a);
+    ai_assert(nullptr != b);
+    return a->Equal(*b, epsilon);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API int aiVector3LessThan(
+        const C_STRUCT aiVector3D *a,
+        const C_STRUCT aiVector3D *b) {
+    ai_assert(nullptr != a);
+    ai_assert(nullptr != b);
+    return *a < *b;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector3Add(
+        C_STRUCT aiVector3D *dst,
+        const C_STRUCT aiVector3D *src) {
+    ai_assert(nullptr != dst);
+    ai_assert(nullptr != src);
+    *dst = *dst + *src;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector3Subtract(
+        C_STRUCT aiVector3D *dst,
+        const C_STRUCT aiVector3D *src) {
+    ai_assert(nullptr != dst);
+    ai_assert(nullptr != src);
+    *dst = *dst - *src;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector3Scale(
+        C_STRUCT aiVector3D *dst,
+        const float s) {
+    ai_assert(nullptr != dst);
+    *dst *= s;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector3SymMul(
+        C_STRUCT aiVector3D *dst,
+        const C_STRUCT aiVector3D *other) {
+    ai_assert(nullptr != dst);
+    ai_assert(nullptr != other);
+    *dst = dst->SymMul(*other);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector3DivideByScalar(
+        C_STRUCT aiVector3D *dst, const float s) {
+    ai_assert(nullptr != dst);
+    *dst /= s;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector3DivideByVector(
+        C_STRUCT aiVector3D *dst,
+        C_STRUCT aiVector3D *v) {
+    ai_assert(nullptr != dst);
+    ai_assert(nullptr != v);
+    *dst = *dst / *v;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API float aiVector3Length(
+        const C_STRUCT aiVector3D *v) {
+    ai_assert(nullptr != v);
+    return v->Length();
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API float aiVector3SquareLength(
+        const C_STRUCT aiVector3D *v) {
+    ai_assert(nullptr != v);
+    return v->SquareLength();
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector3Negate(
+        C_STRUCT aiVector3D *dst) {
+    ai_assert(nullptr != dst);
+    *dst = -(*dst);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API float aiVector3DotProduct(
+        const C_STRUCT aiVector3D *a,
+        const C_STRUCT aiVector3D *b) {
+    ai_assert(nullptr != a);
+    ai_assert(nullptr != b);
+    return (*a) * (*b);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector3CrossProduct(
+        C_STRUCT aiVector3D *dst,
+        const C_STRUCT aiVector3D *a,
+        const C_STRUCT aiVector3D *b) {
+    ai_assert(nullptr != dst);
+    ai_assert(nullptr != a);
+    ai_assert(nullptr != b);
+    *dst = *a ^ *b;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector3Normalize(
+        C_STRUCT aiVector3D *v) {
+    ai_assert(nullptr != v);
+    v->Normalize();
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector3NormalizeSafe(
+        C_STRUCT aiVector3D *v) {
+    ai_assert(nullptr != v);
+    v->NormalizeSafe();
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector3RotateByQuaternion(
+        C_STRUCT aiVector3D *v,
+        const C_STRUCT aiQuaternion *q) {
+    ai_assert(nullptr != v);
+    ai_assert(nullptr != q);
+    *v = q->Rotate(*v);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix3FromMatrix4(
+        C_STRUCT aiMatrix3x3 *dst,
+        const C_STRUCT aiMatrix4x4 *mat) {
+    ai_assert(nullptr != dst);
+    ai_assert(nullptr != mat);
+    *dst = aiMatrix3x3(*mat);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix3FromQuaternion(
+        C_STRUCT aiMatrix3x3 *mat,
+        const C_STRUCT aiQuaternion *q) {
+    ai_assert(nullptr != mat);
+    ai_assert(nullptr != q);
+    *mat = q->GetMatrix();
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API int aiMatrix3AreEqual(
+        const C_STRUCT aiMatrix3x3 *a,
+        const C_STRUCT aiMatrix3x3 *b) {
+    ai_assert(nullptr != a);
+    ai_assert(nullptr != b);
+    return *a == *b;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API int aiMatrix3AreEqualEpsilon(
+        const C_STRUCT aiMatrix3x3 *a,
+        const C_STRUCT aiMatrix3x3 *b,
+        const float epsilon) {
+    ai_assert(nullptr != a);
+    ai_assert(nullptr != b);
+    return a->Equal(*b, epsilon);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix3Inverse(C_STRUCT aiMatrix3x3 *mat) {
+    ai_assert(nullptr != mat);
+    mat->Inverse();
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API float aiMatrix3Determinant(const C_STRUCT aiMatrix3x3 *mat) {
+    ai_assert(nullptr != mat);
+    return mat->Determinant();
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix3RotationZ(
+        C_STRUCT aiMatrix3x3 *mat,
+        const float angle) {
+    ai_assert(nullptr != mat);
+    aiMatrix3x3::RotationZ(angle, *mat);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix3FromRotationAroundAxis(
+        C_STRUCT aiMatrix3x3 *mat,
+        const C_STRUCT aiVector3D *axis,
+        const float angle) {
+    ai_assert(nullptr != mat);
+    ai_assert(nullptr != axis);
+    aiMatrix3x3::Rotation(angle, *axis, *mat);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix3Translation(
+        C_STRUCT aiMatrix3x3 *mat,
+        const C_STRUCT aiVector2D *translation) {
+    ai_assert(nullptr != mat);
+    ai_assert(nullptr != translation);
+    aiMatrix3x3::Translation(*translation, *mat);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix3FromTo(
+        C_STRUCT aiMatrix3x3 *mat,
+        const C_STRUCT aiVector3D *from,
+        const C_STRUCT aiVector3D *to) {
+    ai_assert(nullptr != mat);
+    ai_assert(nullptr != from);
+    ai_assert(nullptr != to);
+    aiMatrix3x3::FromToMatrix(*from, *to, *mat);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix4FromMatrix3(
+        C_STRUCT aiMatrix4x4 *dst,
+        const C_STRUCT aiMatrix3x3 *mat) {
+    ai_assert(nullptr != dst);
+    ai_assert(nullptr != mat);
+    *dst = aiMatrix4x4(*mat);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix4FromScalingQuaternionPosition(
+        C_STRUCT aiMatrix4x4 *mat,
+        const C_STRUCT aiVector3D *scaling,
+        const C_STRUCT aiQuaternion *rotation,
+        const C_STRUCT aiVector3D *position) {
+    ai_assert(nullptr != mat);
+    ai_assert(nullptr != scaling);
+    ai_assert(nullptr != rotation);
+    ai_assert(nullptr != position);
+    *mat = aiMatrix4x4(*scaling, *rotation, *position);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix4Add(
+        C_STRUCT aiMatrix4x4 *dst,
+        const C_STRUCT aiMatrix4x4 *src) {
+    ai_assert(nullptr != dst);
+    ai_assert(nullptr != src);
+    *dst = *dst + *src;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API int aiMatrix4AreEqual(
+        const C_STRUCT aiMatrix4x4 *a,
+        const C_STRUCT aiMatrix4x4 *b) {
+    ai_assert(nullptr != a);
+    ai_assert(nullptr != b);
+    return *a == *b;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API int aiMatrix4AreEqualEpsilon(
+        const C_STRUCT aiMatrix4x4 *a,
+        const C_STRUCT aiMatrix4x4 *b,
+        const float epsilon) {
+    ai_assert(nullptr != a);
+    ai_assert(nullptr != b);
+    return a->Equal(*b, epsilon);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix4Inverse(C_STRUCT aiMatrix4x4 *mat) {
+    ai_assert(nullptr != mat);
+    mat->Inverse();
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API float aiMatrix4Determinant(const C_STRUCT aiMatrix4x4 *mat) {
+    ai_assert(nullptr != mat);
+    return mat->Determinant();
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API int aiMatrix4IsIdentity(const C_STRUCT aiMatrix4x4 *mat) {
+    ai_assert(nullptr != mat);
+    return mat->IsIdentity();
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix4DecomposeIntoScalingEulerAnglesPosition(
+        const C_STRUCT aiMatrix4x4 *mat,
+        C_STRUCT aiVector3D *scaling,
+        C_STRUCT aiVector3D *rotation,
+        C_STRUCT aiVector3D *position) {
+    ai_assert(nullptr != mat);
+    ai_assert(nullptr != scaling);
+    ai_assert(nullptr != rotation);
+    ai_assert(nullptr != position);
+    mat->Decompose(*scaling, *rotation, *position);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix4DecomposeIntoScalingAxisAnglePosition(
+        const C_STRUCT aiMatrix4x4 *mat,
+        C_STRUCT aiVector3D *scaling,
+        C_STRUCT aiVector3D *axis,
+        ai_real *angle,
+        C_STRUCT aiVector3D *position) {
+    ai_assert(nullptr != mat);
+    ai_assert(nullptr != scaling);
+    ai_assert(nullptr != axis);
+    ai_assert(nullptr != angle);
+    ai_assert(nullptr != position);
+    mat->Decompose(*scaling, *axis, *angle, *position);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix4DecomposeNoScaling(
+        const C_STRUCT aiMatrix4x4 *mat,
+        C_STRUCT aiQuaternion *rotation,
+        C_STRUCT aiVector3D *position) {
+    ai_assert(nullptr != mat);
+    ai_assert(nullptr != rotation);
+    ai_assert(nullptr != position);
+    mat->DecomposeNoScaling(*rotation, *position);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix4FromEulerAngles(
+        C_STRUCT aiMatrix4x4 *mat,
+        float x, float y, float z) {
+    ai_assert(nullptr != mat);
+    mat->FromEulerAnglesXYZ(x, y, z);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix4RotationX(
+        C_STRUCT aiMatrix4x4 *mat,
+        const float angle) {
+    ai_assert(nullptr != mat);
+    aiMatrix4x4::RotationX(angle, *mat);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix4RotationY(
+        C_STRUCT aiMatrix4x4 *mat,
+        const float angle) {
+    ai_assert(NULL != mat);
+    aiMatrix4x4::RotationY(angle, *mat);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix4RotationZ(
+        C_STRUCT aiMatrix4x4 *mat,
+        const float angle) {
+    ai_assert(nullptr != mat);
+    aiMatrix4x4::RotationZ(angle, *mat);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix4FromRotationAroundAxis(
+        C_STRUCT aiMatrix4x4 *mat,
+        const C_STRUCT aiVector3D *axis,
+        const float angle) {
+    ai_assert(nullptr != mat);
+    ai_assert(nullptr != axis);
+    aiMatrix4x4::Rotation(angle, *axis, *mat);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix4Translation(
+        C_STRUCT aiMatrix4x4 *mat,
+        const C_STRUCT aiVector3D *translation) {
+    ai_assert(nullptr != mat);
+    ai_assert(nullptr != translation);
+    aiMatrix4x4::Translation(*translation, *mat);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix4Scaling(
+        C_STRUCT aiMatrix4x4 *mat,
+        const C_STRUCT aiVector3D *scaling) {
+    ai_assert(nullptr != mat);
+    ai_assert(nullptr != scaling);
+    aiMatrix4x4::Scaling(*scaling, *mat);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix4FromTo(
+        C_STRUCT aiMatrix4x4 *mat,
+        const C_STRUCT aiVector3D *from,
+        const C_STRUCT aiVector3D *to) {
+    ai_assert(nullptr != mat);
+    ai_assert(nullptr != from);
+    ai_assert(nullptr != to);
+    aiMatrix4x4::FromToMatrix(*from, *to, *mat);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiQuaternionFromEulerAngles(
+        C_STRUCT aiQuaternion *q,
+        float x, float y, float z) {
+    ai_assert(nullptr != q);
+    *q = aiQuaternion(x, y, z);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiQuaternionFromAxisAngle(
+        C_STRUCT aiQuaternion *q,
+        const C_STRUCT aiVector3D *axis,
+        const float angle) {
+    ai_assert(nullptr != q);
+    ai_assert(nullptr != axis);
+    *q = aiQuaternion(*axis, angle);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiQuaternionFromNormalizedQuaternion(
+        C_STRUCT aiQuaternion *q,
+        const C_STRUCT aiVector3D *normalized) {
+    ai_assert(nullptr != q);
+    ai_assert(nullptr != normalized);
+    *q = aiQuaternion(*normalized);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API int aiQuaternionAreEqual(
+        const C_STRUCT aiQuaternion *a,
+        const C_STRUCT aiQuaternion *b) {
+    ai_assert(nullptr != a);
+    ai_assert(nullptr != b);
+    return *a == *b;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API int aiQuaternionAreEqualEpsilon(
+        const C_STRUCT aiQuaternion *a,
+        const C_STRUCT aiQuaternion *b,
+        const float epsilon) {
+    ai_assert(nullptr != a);
+    ai_assert(nullptr != b);
+    return a->Equal(*b, epsilon);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiQuaternionNormalize(
+        C_STRUCT aiQuaternion *q) {
+    ai_assert(nullptr != q);
+    q->Normalize();
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiQuaternionConjugate(
+        C_STRUCT aiQuaternion *q) {
+    ai_assert(nullptr != q);
+    q->Conjugate();
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiQuaternionMultiply(
+        C_STRUCT aiQuaternion *dst,
+        const C_STRUCT aiQuaternion *q) {
+    ai_assert(nullptr != dst);
+    ai_assert(nullptr != q);
+    *dst = (*dst) * (*q);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiQuaternionInterpolate(
+        C_STRUCT aiQuaternion *dst,
+        const C_STRUCT aiQuaternion *start,
+        const C_STRUCT aiQuaternion *end,
+        const float factor) {
+    ai_assert(nullptr != dst);
+    ai_assert(nullptr != start);
+    ai_assert(nullptr != end);
+    aiQuaternion::Interpolate(*dst, *start, *end, factor);
+}
+
+
+// stb_image is a lightweight image loader. It is shared by:
+//  - M3D import
+//  - PBRT export
+// Since it's a header-only library, its implementation must be instantiated in some cpp file.
+// Don't scatter this task over multiple importers/exporters. Maintain it in a central place (here!).
+
+#define ASSIMP_HAS_PBRT_EXPORT (!ASSIMP_BUILD_NO_EXPORT && !ASSIMP_BUILD_NO_PBRT_EXPORTER)
+#define ASSIMP_HAS_M3D ((!ASSIMP_BUILD_NO_EXPORT && !ASSIMP_BUILD_NO_M3D_EXPORTER) || !ASSIMP_BUILD_NO_M3D_IMPORTER)
+
+#if ASSIMP_HAS_PBRT_EXPORT
+#   define ASSIMP_NEEDS_STB_IMAGE 1
+#elif ASSIMP_HAS_M3D
+#   define ASSIMP_NEEDS_STB_IMAGE 1
+#   define STBI_ONLY_PNG
+#endif
+
+#if ASSIMP_NEEDS_STB_IMAGE
+
+#   if _MSC_VER // "unreferenced function has been removed" (SSE2 detection routine in x64 builds)
+#       pragma warning(push)
+#       pragma warning(disable: 4505)
+#   endif
+
+#   define STB_IMAGE_IMPLEMENTATION
+#   include "stb/stb_image.h"
+
+#   if _MSC_VER
+#       pragma warning(pop)
+#   endif
+
+#endif
diff --git a/Engine/lib/assimp/code/Common/Base64.cpp b/Engine/lib/assimp/code/Common/Base64.cpp
new file mode 100644
index 000000000..3e9c47405
--- /dev/null
+++ b/Engine/lib/assimp/code/Common/Base64.cpp
@@ -0,0 +1,179 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+#include <assimp/Base64.hpp>
+#include <assimp/Exceptional.h>
+
+namespace Assimp {
+
+namespace Base64 {
+
+static const uint8_t tableDecodeBase64[128] = {
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 0, 63,
+    52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 0, 0, 0, 64, 0, 0,
+    0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 0, 0, 0,
+    0, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+    41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 0, 0, 0, 0, 0
+};
+
+static const char *tableEncodeBase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+
+static inline char EncodeChar(uint8_t b) {
+    return tableEncodeBase64[size_t(b)];
+}
+
+inline uint8_t DecodeChar(char c) {
+    if (c & 0x80) {
+        throw DeadlyImportError("Invalid base64 char value: ", size_t(c));
+    }
+    return tableDecodeBase64[size_t(c & 0x7F)]; // TODO faster with lookup table or ifs?
+}
+
+void Encode(const uint8_t *in, size_t inLength, std::string &out) {
+    size_t outLength = ((inLength + 2) / 3) * 4;
+
+    size_t j = out.size();
+    out.resize(j + outLength);
+
+    for (size_t i = 0; i < inLength; i += 3) {
+        uint8_t b = (in[i] & 0xFC) >> 2;
+        out[j++] = EncodeChar(b);
+
+        b = (in[i] & 0x03) << 4;
+        if (i + 1 < inLength) {
+            b |= (in[i + 1] & 0xF0) >> 4;
+            out[j++] = EncodeChar(b);
+
+            b = (in[i + 1] & 0x0F) << 2;
+            if (i + 2 < inLength) {
+                b |= (in[i + 2] & 0xC0) >> 6;
+                out[j++] = EncodeChar(b);
+
+                b = in[i + 2] & 0x3F;
+                out[j++] = EncodeChar(b);
+            } else {
+                out[j++] = EncodeChar(b);
+                out[j++] = '=';
+            }
+        } else {
+            out[j++] = EncodeChar(b);
+            out[j++] = '=';
+            out[j++] = '=';
+        }
+    }
+}
+
+void Encode(const std::vector<uint8_t> &in, std::string &out) {
+    Encode(in.data(), in.size(), out);
+}
+
+std::string Encode(const std::vector<uint8_t> &in) {
+    std::string encoded;
+    Encode(in, encoded);
+    return encoded;
+}
+
+size_t Decode(const char *in, size_t inLength, uint8_t *&out) {
+    if (inLength % 4 != 0) {
+        throw DeadlyImportError("Invalid base64 encoded data: \"", std::string(in, std::min(size_t(32), inLength)), "\", length:", inLength);
+    }
+
+    if (inLength < 4) {
+        out = nullptr;
+        return 0;
+    }
+
+    int nEquals = int(in[inLength - 1] == '=') +
+                  int(in[inLength - 2] == '=');
+
+    size_t outLength = (inLength * 3) / 4 - nEquals;
+    out = new uint8_t[outLength];
+    memset(out, 0, outLength);
+
+    size_t i, j = 0;
+
+    for (i = 0; i + 4 < inLength; i += 4) {
+        uint8_t b0 = DecodeChar(in[i]);
+        uint8_t b1 = DecodeChar(in[i + 1]);
+        uint8_t b2 = DecodeChar(in[i + 2]);
+        uint8_t b3 = DecodeChar(in[i + 3]);
+
+        out[j++] = (uint8_t)((b0 << 2) | (b1 >> 4));
+        out[j++] = (uint8_t)((b1 << 4) | (b2 >> 2));
+        out[j++] = (uint8_t)((b2 << 6) | b3);
+    }
+
+    {
+        uint8_t b0 = DecodeChar(in[i]);
+        uint8_t b1 = DecodeChar(in[i + 1]);
+        uint8_t b2 = DecodeChar(in[i + 2]);
+        uint8_t b3 = DecodeChar(in[i + 3]);
+
+        out[j++] = (uint8_t)((b0 << 2) | (b1 >> 4));
+        if (b2 < 64) out[j++] = (uint8_t)((b1 << 4) | (b2 >> 2));
+        if (b3 < 64) out[j++] = (uint8_t)((b2 << 6) | b3);
+    }
+
+    return outLength;
+}
+
+size_t Decode(const std::string &in, std::vector<uint8_t> &out) {
+    uint8_t *outPtr = nullptr;
+    size_t decodedSize = Decode(in.data(), in.size(), outPtr);
+    if (outPtr == nullptr) {
+        return 0;
+    }
+    out.assign(outPtr, outPtr + decodedSize);
+    delete[] outPtr;
+    return decodedSize;
+}
+
+std::vector<uint8_t> Decode(const std::string &in) {
+    std::vector<uint8_t> result;
+    Decode(in, result);
+    return result;
+}
+
+} // namespace Base64
+} // namespace Assimp
diff --git a/Engine/lib/assimp/code/Common/BaseImporter.cpp b/Engine/lib/assimp/code/Common/BaseImporter.cpp
index b77bbfe23..383300ef1 100644
--- a/Engine/lib/assimp/code/Common/BaseImporter.cpp
+++ b/Engine/lib/assimp/code/Common/BaseImporter.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -45,29 +43,29 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Implementation of BaseImporter
  */
 
-#include <assimp/BaseImporter.h>
-#include <assimp/ParsingUtils.h>
 #include "FileSystemFilter.h"
 #include "Importer.h"
+#include <assimp/BaseImporter.h>
 #include <assimp/ByteSwapper.h>
+#include <assimp/ParsingUtils.h>
+#include <assimp/importerdesc.h>
+#include <assimp/postprocess.h>
 #include <assimp/scene.h>
 #include <assimp/Importer.hpp>
-#include <assimp/postprocess.h>
-#include <assimp/importerdesc.h>
 
+#include <cctype>
 #include <ios>
 #include <list>
 #include <memory>
 #include <sstream>
-#include <cctype>
 
 using namespace Assimp;
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 BaseImporter::BaseImporter() AI_NO_EXCEPT
-: m_progress() {
-    // nothing to do here
+        : m_progress() {
+    // empty
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -76,8 +74,7 @@ BaseImporter::~BaseImporter() {
     // nothing to do here
 }
 
-void BaseImporter::UpdateImporterScale( Importer* pImp )
-{
+void BaseImporter::UpdateImporterScale(Importer *pImp) {
     ai_assert(pImp != nullptr);
     ai_assert(importerScale != 0.0);
     ai_assert(fileScale != 0.0);
@@ -85,15 +82,14 @@ void BaseImporter::UpdateImporterScale( Importer* pImp )
     double activeScale = importerScale * fileScale;
 
     // Set active scaling
-    pImp->SetPropertyFloat( AI_CONFIG_APP_SCALE_KEY, static_cast<float>( activeScale) );
+    pImp->SetPropertyFloat(AI_CONFIG_APP_SCALE_KEY, static_cast<float>(activeScale));
 
-    ASSIMP_LOG_DEBUG_F("UpdateImporterScale scale set: %f", activeScale );
+    ASSIMP_LOG_DEBUG("UpdateImporterScale scale set: ", activeScale);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file and returns the imported data.
-aiScene* BaseImporter::ReadFile(Importer* pImp, const std::string& pFile, IOSystem* pIOHandler) {
-
+aiScene *BaseImporter::ReadFile(Importer *pImp, const std::string &pFile, IOSystem *pIOHandler) {
 
     m_progress = pImp->GetProgressHandler();
     if (nullptr == m_progress) {
@@ -103,28 +99,27 @@ aiScene* BaseImporter::ReadFile(Importer* pImp, const std::string& pFile, IOSyst
     ai_assert(m_progress);
 
     // Gather configuration properties for this run
-    SetupProperties( pImp );
+    SetupProperties(pImp);
 
     // Construct a file system filter to improve our success ratio at reading external files
-    FileSystemFilter filter(pFile,pIOHandler);
+    FileSystemFilter filter(pFile, pIOHandler);
 
     // create a scene object to hold the data
     std::unique_ptr<aiScene> sc(new aiScene());
 
     // dispatch importing
-    try
-    {
-        InternReadFile( pFile, sc.get(), &filter);
+    try {
+        InternReadFile(pFile, sc.get(), &filter);
 
         // Calculate import scale hook - required because pImp not available anywhere else
         // passes scale into ScaleProcess
         UpdateImporterScale(pImp);
 
-
-    } catch( const std::exception& err )    {
+    } catch( const std::exception &err ) {
         // extract error description
         m_ErrorText = err.what();
-        ASSIMP_LOG_ERROR(m_ErrorText);
+        ASSIMP_LOG_ERROR(err.what());
+        m_Exception = std::current_exception();
         return nullptr;
     }
 
@@ -133,69 +128,66 @@ aiScene* BaseImporter::ReadFile(Importer* pImp, const std::string& pFile, IOSyst
 }
 
 // ------------------------------------------------------------------------------------------------
-void BaseImporter::SetupProperties(const Importer* pImp)
-{
+void BaseImporter::SetupProperties(const Importer *) {
     // the default implementation does nothing
 }
 
 // ------------------------------------------------------------------------------------------------
-void BaseImporter::GetExtensionList(std::set<std::string>& extensions) {
-    const aiImporterDesc* desc = GetInfo();
+void BaseImporter::GetExtensionList(std::set<std::string> &extensions) {
+    const aiImporterDesc *desc = GetInfo();
     ai_assert(desc != nullptr);
 
-    const char* ext = desc->mFileExtensions;
-    ai_assert(ext != nullptr );
+    const char *ext = desc->mFileExtensions;
+    ai_assert(ext != nullptr);
 
-    const char* last = ext;
+    const char *last = ext;
     do {
         if (!*ext || *ext == ' ') {
-            extensions.insert(std::string(last,ext-last));
-            ai_assert(ext-last > 0);
+            extensions.insert(std::string(last, ext - last));
+            ai_assert(ext - last > 0);
             last = ext;
-            while(*last == ' ') {
+            while (*last == ' ') {
                 ++last;
             }
         }
-    }
-    while(*ext++);
+    } while (*ext++);
 }
 
 // ------------------------------------------------------------------------------------------------
-/*static*/ bool BaseImporter::SearchFileHeaderForToken( IOSystem* pIOHandler,
-    const std::string&  pFile,
-    const char**        tokens,
-    unsigned int        numTokens,
-    unsigned int        searchBytes /* = 200 */,
-    bool                tokensSol /* false */,
-    bool                noAlphaBeforeTokens /* false */)
-{
-    ai_assert( nullptr != tokens );
-    ai_assert( 0 != numTokens );
-    ai_assert( 0 != searchBytes);
+/*static*/ bool BaseImporter::SearchFileHeaderForToken(IOSystem *pIOHandler,
+        const std::string &pFile,
+        const char **tokens,
+        std::size_t numTokens,
+        unsigned int searchBytes /* = 200 */,
+        bool tokensSol /* false */,
+        bool noAlphaBeforeTokens /* false */) {
+    ai_assert(nullptr != tokens);
+    ai_assert(0 != numTokens);
+    ai_assert(0 != searchBytes);
 
-    if ( nullptr == pIOHandler ) {
+    if (nullptr == pIOHandler) {
         return false;
     }
 
-    std::unique_ptr<IOStream> pStream (pIOHandler->Open(pFile));
-    if (pStream.get() ) {
+    std::unique_ptr<IOStream> pStream(pIOHandler->Open(pFile));
+    if (pStream) {
         // read 200 characters from the file
-        std::unique_ptr<char[]> _buffer (new char[searchBytes+1 /* for the '\0' */]);
-        char *buffer( _buffer.get() );
-        const size_t read( pStream->Read(buffer,1,searchBytes) );
-        if( 0 == read ) {
+        std::unique_ptr<char[]> _buffer(new char[searchBytes + 1 /* for the '\0' */]);
+        char *buffer(_buffer.get());
+        const size_t read(pStream->Read(buffer, 1, searchBytes));
+        if (0 == read) {
             return false;
         }
 
-        for( size_t i = 0; i < read; ++i ) {
-            buffer[ i ] = static_cast<char>( ::tolower( buffer[ i ] ) );
+        for (size_t i = 0; i < read; ++i) {
+            buffer[i] = static_cast<char>(::tolower((unsigned char)buffer[i]));
         }
 
         // It is not a proper handling of unicode files here ...
         // ehm ... but it works in most cases.
-        char* cur = buffer,*cur2 = buffer,*end = &buffer[read];
-        while (cur != end)  {
-            if( *cur ) {
+        char *cur = buffer, *cur2 = buffer, *end = &buffer[read];
+        while (cur != end) {
+            if (*cur) {
                 *cur2++ = *cur;
             }
             ++cur;
@@ -203,28 +195,28 @@ void BaseImporter::GetExtensionList(std::set<std::string>& extensions) {
         *cur2 = '\0';
 
         std::string token;
-        for (unsigned int i = 0; i < numTokens; ++i ) {
-            ai_assert( nullptr != tokens[i] );
-            const size_t len( strlen( tokens[ i ] ) );
+        for (unsigned int i = 0; i < numTokens; ++i) {
+            ai_assert(nullptr != tokens[i]);
+            const size_t len(strlen(tokens[i]));
             token.clear();
-            const char *ptr( tokens[ i ] );
-            for ( size_t tokIdx = 0; tokIdx < len; ++tokIdx ) {
-                token.push_back( static_cast<char>( tolower( *ptr ) ) );
+            const char *ptr(tokens[i]);
+            for (size_t tokIdx = 0; tokIdx < len; ++tokIdx) {
+                token.push_back(static_cast<char>(tolower(static_cast<unsigned char>(*ptr))));
                 ++ptr;
             }
-            const char* r = strstr( buffer, token.c_str() );
-            if( !r ) {
+            const char *r = strstr(buffer, token.c_str());
+            if (!r) {
                 continue;
             }
-            // We need to make sure that we didn't accidentially identify the end of another token as our token,
+            // We need to make sure that we didn't accidentally identify the end of another token as our token,
             // e.g. in a previous version the "gltf " present in some gltf files was detected as "f "
-            if (noAlphaBeforeTokens && (r != buffer && isalpha(r[-1]))) {
+            if (noAlphaBeforeTokens && (r != buffer && isalpha(static_cast<unsigned char>(r[-1])))) {
                 continue;
             }
             // We got a match, either we don't care where it is, or it happens to
             // be in the beginning of the file / line
             if (!tokensSol || r == buffer || r[-1] == '\r' || r[-1] == '\n') {
-                ASSIMP_LOG_DEBUG_F( "Found positive match for header keyword: ", tokens[i] );
+                ASSIMP_LOG_DEBUG("Found positive match for header keyword: ", tokens[i]);
                 return true;
             }
         }
@@ -235,26 +227,25 @@ void BaseImporter::GetExtensionList(std::set<std::string>& extensions) {
 
 // ------------------------------------------------------------------------------------------------
 // Simple check for file extension
-/*static*/ bool BaseImporter::SimpleExtensionCheck (const std::string& pFile,
-    const char* ext0,
-    const char* ext1,
-    const char* ext2)
-{
+/*static*/ bool BaseImporter::SimpleExtensionCheck(const std::string &pFile,
+        const char *ext0,
+        const char *ext1,
+        const char *ext2) {
     std::string::size_type pos = pFile.find_last_of('.');
 
     // no file extension - can't read
-    if( pos == std::string::npos)
+    if (pos == std::string::npos)
         return false;
 
-    const char* ext_real = & pFile[ pos+1 ];
-    if( !ASSIMP_stricmp(ext_real,ext0) )
+    const char *ext_real = &pFile[pos + 1];
+    if (!ASSIMP_stricmp(ext_real, ext0))
         return true;
 
     // check for other, optional, file extensions
-    if (ext1 && !ASSIMP_stricmp(ext_real,ext1))
+    if (ext1 && !ASSIMP_stricmp(ext_real, ext1))
         return true;
 
-    if (ext2 && !ASSIMP_stricmp(ext_real,ext2))
+    if (ext2 && !ASSIMP_stricmp(ext_real, ext2))
         return true;
 
     return false;
@@ -262,44 +253,43 @@ void BaseImporter::GetExtensionList(std::set<std::string>& extensions) {
 
 // ------------------------------------------------------------------------------------------------
 // Get file extension from path
-std::string BaseImporter::GetExtension( const std::string& file ) {
+std::string BaseImporter::GetExtension(const std::string &file) {
     std::string::size_type pos = file.find_last_of('.');
 
     // no file extension at all
     if (pos == std::string::npos) {
-        return "";
+        return std::string();
     }
 
-
     // thanks to Andy Maloney for the hint
-    std::string ret = file.substr( pos + 1 );
-    std::transform( ret.begin(), ret.end(), ret.begin(), ToLower<char>);
+    std::string ret = file.substr(pos + 1);
+    ret = ai_tolower(ret);
 
     return ret;
 }
 
+
 // ------------------------------------------------------------------------------------------------
 // Check for magic bytes at the beginning of the file.
-/* static */ bool BaseImporter::CheckMagicToken(IOSystem* pIOHandler, const std::string& pFile,
-    const void* _magic, unsigned int num, unsigned int offset, unsigned int size)
-{
-    ai_assert( size <= 16 );
-    ai_assert( _magic );
+/* static */ bool BaseImporter::CheckMagicToken(IOSystem *pIOHandler, const std::string &pFile,
+        const void *_magic, std::size_t num, unsigned int offset, unsigned int size) {
+    ai_assert(size <= 16);
+    ai_assert(_magic);
 
     if (!pIOHandler) {
         return false;
     }
     union {
-        const char* magic;
-        const uint16_t* magic_u16;
-        const uint32_t* magic_u32;
+        const char *magic;
+        const uint16_t *magic_u16;
+        const uint32_t *magic_u32;
     };
-    magic = reinterpret_cast<const char*>(_magic);
-    std::unique_ptr<IOStream> pStream (pIOHandler->Open(pFile));
-    if (pStream.get() ) {
+    magic = reinterpret_cast<const char *>(_magic);
+    std::unique_ptr<IOStream> pStream(pIOHandler->Open(pFile));
+    if (pStream) {
 
         // skip to offset
-        pStream->Seek(offset,aiOrigin_SET);
+        pStream->Seek(offset, aiOrigin_SET);
 
         // read 'size' characters from the file
         union {
@@ -307,7 +297,7 @@ std::string BaseImporter::GetExtension( const std::string& file ) {
             uint16_t data_u16[8];
             uint32_t data_u32[4];
         };
-        if(size != pStream->Read(data,1,size)) {
+        if (size != pStream->Read(data, 1, size)) {
             return false;
         }
 
@@ -321,17 +311,15 @@ std::string BaseImporter::GetExtension( const std::string& file ) {
                 if (data_u16[0] == *magic_u16 || data_u16[0] == rev) {
                     return true;
                 }
-            }
-            else if (4 == size) {
+            } else if (4 == size) {
                 uint32_t rev = *magic_u32;
                 ByteSwap::Swap(&rev);
                 if (data_u32[0] == *magic_u32 || data_u32[0] == rev) {
                     return true;
                 }
-            }
-            else {
+            } else {
                 // any length ... just compare
-                if(!memcmp(magic,data,size)) {
+                if (!memcmp(magic, data, size)) {
                     return true;
                 }
             }
@@ -342,61 +330,62 @@ std::string BaseImporter::GetExtension( const std::string& file ) {
 }
 
 #ifdef ASSIMP_USE_HUNTER
-#  include <utf8/utf8.h>
+#include <utf8.h>
 #else
-#  include "../contrib/utf8cpp/source/utf8.h"
+#include "../contrib/utf8cpp/source/utf8.h"
 #endif
 
 // ------------------------------------------------------------------------------------------------
 // Convert to UTF8 data
-void BaseImporter::ConvertToUTF8(std::vector<char>& data)
-{
+void BaseImporter::ConvertToUTF8(std::vector<char> &data) {
     //ConversionResult result;
-    if(data.size() < 8) {
+    if (data.size() < 8) {
         throw DeadlyImportError("File is too small");
     }
 
     // UTF 8 with BOM
-    if((uint8_t)data[0] == 0xEF && (uint8_t)data[1] == 0xBB && (uint8_t)data[2] == 0xBF) {
+    if ((uint8_t)data[0] == 0xEF && (uint8_t)data[1] == 0xBB && (uint8_t)data[2] == 0xBF) {
         ASSIMP_LOG_DEBUG("Found UTF-8 BOM ...");
 
-        std::copy(data.begin()+3,data.end(),data.begin());
-        data.resize(data.size()-3);
+        std::copy(data.begin() + 3, data.end(), data.begin());
+        data.resize(data.size() - 3);
         return;
     }
-    
-    
+
     // UTF 32 BE with BOM
-    if(*((uint32_t*)&data.front()) == 0xFFFE0000) {
+    if (*((uint32_t *)&data.front()) == 0xFFFE0000) {
 
         // swap the endianness ..
-        for(uint32_t* p = (uint32_t*)&data.front(), *end = (uint32_t*)&data.back(); p <= end; ++p) {
+        for (uint32_t *p = (uint32_t *)&data.front(), *end = (uint32_t *)&data.back(); p <= end; ++p) {
             AI_SWAP4P(p);
         }
     }
 
     // UTF 32 LE with BOM
-    if(*((uint32_t*)&data.front()) == 0x0000FFFE) {
+    if (*((uint32_t *)&data.front()) == 0x0000FFFE) {
         ASSIMP_LOG_DEBUG("Found UTF-32 BOM ...");
 
         std::vector<char> output;
-        int *ptr = (int*)&data[ 0 ];
-        int *end = ptr + ( data.size() / sizeof(int) ) +1;
-        utf8::utf32to8( ptr, end, back_inserter(output));
+        int *ptr = (int *)&data[0];
+        int *end = ptr + (data.size() / sizeof(int)) + 1;
+        utf8::utf32to8(ptr, end, back_inserter(output));
         return;
     }
 
     // UTF 16 BE with BOM
-    if(*((uint16_t*)&data.front()) == 0xFFFE) {
-
+    if (*((uint16_t *)&data.front()) == 0xFFFE) {
+        // Check to ensure no overflow can happen
+        if(data.size() % 2 != 0) {
+            return;
+        }
         // swap the endianness ..
-        for(uint16_t* p = (uint16_t*)&data.front(), *end = (uint16_t*)&data.back(); p <= end; ++p) {
+        for (uint16_t *p = (uint16_t *)&data.front(), *end = (uint16_t *)&data.back(); p <= end; ++p) {
             ByteSwap::Swap2(p);
         }
     }
 
     // UTF 16 LE with BOM
-    if(*((uint16_t*)&data.front()) == 0xFEFF) {
+    if (*((uint16_t *)&data.front()) == 0xFEFF) {
         ASSIMP_LOG_DEBUG("Found UTF-16 BOM ...");
 
         std::vector<unsigned char> output;
@@ -407,23 +396,22 @@ void BaseImporter::ConvertToUTF8(std::vector<char>& data)
 
 // ------------------------------------------------------------------------------------------------
 // Convert to UTF8 data to ISO-8859-1
-void BaseImporter::ConvertUTF8toISO8859_1(std::string& data)
-{
+void BaseImporter::ConvertUTF8toISO8859_1(std::string &data) {
     size_t size = data.size();
     size_t i = 0, j = 0;
 
-    while(i < size) {
-        if ((unsigned char) data[i] < (size_t) 0x80) {
+    while (i < size) {
+        if ((unsigned char)data[i] < (size_t)0x80) {
             data[j] = data[i];
-        } else if(i < size - 1) {
-            if((unsigned char) data[i] == 0xC2) {
+        } else if (i < size - 1) {
+            if ((unsigned char)data[i] == 0xC2) {
                 data[j] = data[++i];
-            } else if((unsigned char) data[i] == 0xC3) {
-                data[j] = ((unsigned char) data[++i] + 0x40);
+            } else if ((unsigned char)data[i] == 0xC3) {
+                data[j] = ((unsigned char)data[++i] + 0x40);
             } else {
                 std::stringstream stream;
                 stream << "UTF8 code " << std::hex << data[i] << data[i + 1] << " can not be converted into ISA-8859-1.";
-                ASSIMP_LOG_ERROR( stream.str() );
+                ASSIMP_LOG_ERROR(stream.str());
 
                 data[j++] = data[i++];
                 data[j] = data[i];
@@ -434,30 +422,30 @@ void BaseImporter::ConvertUTF8toISO8859_1(std::string& data)
             data[j] = data[i];
         }
 
-        i++; j++;
+        i++;
+        j++;
     }
 
     data.resize(j);
 }
 
 // ------------------------------------------------------------------------------------------------
-void BaseImporter::TextFileToBuffer(IOStream* stream,
-    std::vector<char>& data,
-    TextFileMode mode)
-{
+void BaseImporter::TextFileToBuffer(IOStream *stream,
+        std::vector<char> &data,
+        TextFileMode mode) {
     ai_assert(nullptr != stream);
 
     const size_t fileSize = stream->FileSize();
     if (mode == FORBID_EMPTY) {
-        if(!fileSize) {
+        if (!fileSize) {
             throw DeadlyImportError("File is empty");
         }
     }
 
-    data.reserve(fileSize+1);
+    data.reserve(fileSize + 1);
     data.resize(fileSize);
-    if(fileSize > 0) {
-        if(fileSize != stream->Read( &data[0], 1, fileSize)) {
+    if (fileSize > 0) {
+        if (fileSize != stream->Read(&data[0], 1, fileSize)) {
             throw DeadlyImportError("File read error");
         }
 
@@ -470,58 +458,55 @@ void BaseImporter::TextFileToBuffer(IOStream* stream,
 
 // ------------------------------------------------------------------------------------------------
 namespace Assimp {
-    // Represents an import request
-    struct LoadRequest {
-        LoadRequest(const std::string& _file, unsigned int _flags,const BatchLoader::PropertyMap* _map, unsigned int _id)
-        : file(_file)
-        , flags(_flags)
-        , refCnt(1)
-        , scene(NULL)
-        , loaded(false)
-        , id(_id) {
-            if ( _map ) {
-                map = *_map;
-            }
+// Represents an import request
+struct LoadRequest {
+    LoadRequest(const std::string &_file, unsigned int _flags, const BatchLoader::PropertyMap *_map, unsigned int _id) :
+            file(_file),
+            flags(_flags),
+            refCnt(1),
+            scene(nullptr),
+            loaded(false),
+            id(_id) {
+        if (_map) {
+            map = *_map;
         }
+    }
 
-        bool operator== ( const std::string& f ) const {
-            return file == f;
-        }
+    bool operator==(const std::string &f) const {
+        return file == f;
+    }
 
-        const std::string        file;
-        unsigned int             flags;
-        unsigned int             refCnt;
-        aiScene                 *scene;
-        bool                     loaded;
-        BatchLoader::PropertyMap map;
-        unsigned int             id;
-    };
-}
+    const std::string file;
+    unsigned int flags;
+    unsigned int refCnt;
+    aiScene *scene;
+    bool loaded;
+    BatchLoader::PropertyMap map;
+    unsigned int id;
+};
+} // namespace Assimp
 
 // ------------------------------------------------------------------------------------------------
 // BatchLoader::pimpl data structure
 struct Assimp::BatchData {
-    BatchData( IOSystem* pIO, bool validate )
-    : pIOSystem( pIO )
-    , pImporter( nullptr )
-    , next_id(0xffff)
-    , validate( validate ) {
-        ai_assert( nullptr != pIO );
-        
+    BatchData(IOSystem *pIO, bool validate) :
+            pIOSystem(pIO), pImporter(nullptr), next_id(0xffff), validate(validate) {
+        ai_assert(nullptr != pIO);
+
         pImporter = new Importer();
-        pImporter->SetIOHandler( pIO );
+        pImporter->SetIOHandler(pIO);
     }
 
     ~BatchData() {
-        pImporter->SetIOHandler( nullptr ); /* get pointer back into our possession */
+        pImporter->SetIOHandler(nullptr); /* get pointer back into our possession */
         delete pImporter;
     }
 
     // IO system to be used for all imports
-    IOSystem* pIOSystem;
+    IOSystem *pIOSystem;
 
     // Importer used to load all meshes
-    Importer* pImporter;
+    Importer *pImporter;
 
     // List of all imports
     std::list<LoadRequest> requests;
@@ -539,24 +524,23 @@ struct Assimp::BatchData {
 typedef std::list<LoadRequest>::iterator LoadReqIt;
 
 // ------------------------------------------------------------------------------------------------
-BatchLoader::BatchLoader(IOSystem* pIO, bool validate ) {
+BatchLoader::BatchLoader(IOSystem *pIO, bool validate) {
     ai_assert(nullptr != pIO);
 
-    m_data = new BatchData( pIO, validate );
+    m_data = new BatchData(pIO, validate);
 }
 
 // ------------------------------------------------------------------------------------------------
-BatchLoader::~BatchLoader()
-{
+BatchLoader::~BatchLoader() {
     // delete all scenes what have not been polled by the user
-    for ( LoadReqIt it = m_data->requests.begin();it != m_data->requests.end(); ++it) {
+    for (LoadReqIt it = m_data->requests.begin(); it != m_data->requests.end(); ++it) {
         delete (*it).scene;
     }
     delete m_data;
 }
 
 // ------------------------------------------------------------------------------------------------
-void BatchLoader::setValidation( bool enabled ) {
+void BatchLoader::setValidation(bool enabled) {
     m_data->validate = enabled;
 }
 
@@ -566,21 +550,19 @@ bool BatchLoader::getValidation() const {
 }
 
 // ------------------------------------------------------------------------------------------------
-unsigned int BatchLoader::AddLoadRequest(const std::string& file,
-    unsigned int steps /*= 0*/, const PropertyMap* map /*= NULL*/)
-{
+unsigned int BatchLoader::AddLoadRequest(const std::string &file,
+        unsigned int steps /*= 0*/, const PropertyMap *map /*= nullptr*/) {
     ai_assert(!file.empty());
 
     // check whether we have this loading request already
-    for ( LoadReqIt it = m_data->requests.begin();it != m_data->requests.end(); ++it)  {
+    for (LoadReqIt it = m_data->requests.begin(); it != m_data->requests.end(); ++it) {
         // Call IOSystem's path comparison function here
-        if ( m_data->pIOSystem->ComparePaths((*it).file,file)) {
+        if (m_data->pIOSystem->ComparePaths((*it).file, file)) {
             if (map) {
-                if ( !( ( *it ).map == *map ) ) {
+                if (!((*it).map == *map)) {
                     continue;
                 }
-            }
-            else if ( !( *it ).map.empty() ) {
+            } else if (!(*it).map.empty()) {
                 continue;
             }
 
@@ -590,17 +572,16 @@ unsigned int BatchLoader::AddLoadRequest(const std::string& file,
     }
 
     // no, we don't have it. So add it to the queue ...
-    m_data->requests.push_back(LoadRequest(file,steps,map, m_data->next_id));
+    m_data->requests.emplace_back(file, steps, map, m_data->next_id);
     return m_data->next_id++;
 }
 
 // ------------------------------------------------------------------------------------------------
-aiScene* BatchLoader::GetImport( unsigned int which )
-{
-    for ( LoadReqIt it = m_data->requests.begin();it != m_data->requests.end(); ++it) {
-        if ((*it).id == which && (*it).loaded)  {
-            aiScene* sc = (*it).scene;
-            if (!(--(*it).refCnt))  {
+aiScene *BatchLoader::GetImport(unsigned int which) {
+    for (LoadReqIt it = m_data->requests.begin(); it != m_data->requests.end(); ++it) {
+        if ((*it).id == which && (*it).loaded) {
+            aiScene *sc = (*it).scene;
+            if (!(--(*it).refCnt)) {
                 m_data->requests.erase(it);
             }
             return sc;
@@ -609,32 +590,28 @@ aiScene* BatchLoader::GetImport( unsigned int which )
     return nullptr;
 }
 
-
-
 // ------------------------------------------------------------------------------------------------
-void BatchLoader::LoadAll()
-{
+void BatchLoader::LoadAll() {
     // no threaded implementation for the moment
-    for ( LoadReqIt it = m_data->requests.begin();it != m_data->requests.end(); ++it) {
+    for (LoadReqIt it = m_data->requests.begin(); it != m_data->requests.end(); ++it) {
         // force validation in debug builds
         unsigned int pp = (*it).flags;
-        if ( m_data->validate ) {
+        if (m_data->validate) {
             pp |= aiProcess_ValidateDataStructure;
         }
 
         // setup config properties if necessary
-        ImporterPimpl* pimpl = m_data->pImporter->Pimpl();
-        pimpl->mFloatProperties  = (*it).map.floats;
-        pimpl->mIntProperties    = (*it).map.ints;
+        ImporterPimpl *pimpl = m_data->pImporter->Pimpl();
+        pimpl->mFloatProperties = (*it).map.floats;
+        pimpl->mIntProperties = (*it).map.ints;
         pimpl->mStringProperties = (*it).map.strings;
         pimpl->mMatrixProperties = (*it).map.matrices;
 
-        if (!DefaultLogger::isNullLogger())
-        {
+        if (!DefaultLogger::isNullLogger()) {
             ASSIMP_LOG_INFO("%%% BEGIN EXTERNAL FILE %%%");
-            ASSIMP_LOG_INFO_F("File: ", (*it).file);
+            ASSIMP_LOG_INFO("File: ", (*it).file);
         }
-        m_data->pImporter->ReadFile((*it).file,pp);
+        m_data->pImporter->ReadFile((*it).file, pp);
         (*it).scene = m_data->pImporter->GetOrphanedScene();
         (*it).loaded = true;
 
diff --git a/Engine/lib/assimp/code/Common/BaseProcess.cpp b/Engine/lib/assimp/code/Common/BaseProcess.cpp
index e247be418..48895b9f3 100644
--- a/Engine/lib/assimp/code/Common/BaseProcess.cpp
+++ b/Engine/lib/assimp/code/Common/BaseProcess.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,45 +41,43 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** @file Implementation of BaseProcess */
 
-#include <assimp/BaseImporter.h>
 #include "BaseProcess.h"
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/scene.h>
 #include "Importer.h"
+#include <assimp/BaseImporter.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
 
 using namespace Assimp;
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 BaseProcess::BaseProcess() AI_NO_EXCEPT
-: shared()
-, progress()
-{
+        : shared(),
+          progress() {
+    // empty
 }
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-BaseProcess::~BaseProcess()
-{
+BaseProcess::~BaseProcess() {
     // nothing to do here
 }
 
 // ------------------------------------------------------------------------------------------------
-void BaseProcess::ExecuteOnScene( Importer* pImp)
-{
-    ai_assert(NULL != pImp && NULL != pImp->Pimpl()->mScene);
+void BaseProcess::ExecuteOnScene(Importer *pImp) {
+    ai_assert( nullptr != pImp );
+    ai_assert( nullptr != pImp->Pimpl()->mScene);
 
     progress = pImp->GetProgressHandler();
-    ai_assert(progress);
+    ai_assert(nullptr != progress);
 
-    SetupProperties( pImp );
+    SetupProperties(pImp);
 
     // catch exceptions thrown inside the PostProcess-Step
-    try
-    {
+    try {
         Execute(pImp->Pimpl()->mScene);
 
-    } catch( const std::exception& err )    {
+    } catch (const std::exception &err) {
 
         // extract error description
         pImp->Pimpl()->mErrorString = err.what();
@@ -94,14 +90,11 @@ void BaseProcess::ExecuteOnScene( Importer* pImp)
 }
 
 // ------------------------------------------------------------------------------------------------
-void BaseProcess::SetupProperties(const Importer* /*pImp*/)
-{
+void BaseProcess::SetupProperties(const Importer * /*pImp*/) {
     // the default implementation does nothing
 }
 
 // ------------------------------------------------------------------------------------------------
-bool BaseProcess::RequireVerboseFormat() const
-{
+bool BaseProcess::RequireVerboseFormat() const {
     return true;
 }
-
diff --git a/Engine/lib/assimp/code/Common/BaseProcess.h b/Engine/lib/assimp/code/Common/BaseProcess.h
index 4d5c7a76b..64403567a 100644
--- a/Engine/lib/assimp/code/Common/BaseProcess.h
+++ b/Engine/lib/assimp/code/Common/BaseProcess.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -44,12 +43,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef INCLUDED_AI_BASEPROCESS_H
 #define INCLUDED_AI_BASEPROCESS_H
 
-#include <map>
 #include <assimp/GenericProperty.h>
 
+#include <map>
+
 struct aiScene;
 
-namespace Assimp    {
+namespace Assimp {
 
 class Importer;
 
@@ -60,64 +60,50 @@ class Importer;
  *  to provide additional information to other steps. This is primarily
  *  intended for cross-step optimizations.
  */
-class SharedPostProcessInfo
-{
+class SharedPostProcessInfo {
 public:
-
-    struct Base
-    {
-        virtual ~Base()
-        {}
+    struct Base {
+        virtual ~Base() {}
     };
 
     //! Represents data that is allocated on the heap, thus needs to be deleted
     template <typename T>
-    struct THeapData : public Base
-    {
-        explicit THeapData(T* in)
-            : data (in)
-        {}
+    struct THeapData : public Base {
+        explicit THeapData(T *in) :
+                data(in) {}
 
-        ~THeapData()
-        {
+        ~THeapData() {
             delete data;
         }
-        T* data;
+        T *data;
     };
 
     //! Represents static, by-value data not allocated on the heap
     template <typename T>
-    struct TStaticData : public Base
-    {
-        explicit TStaticData(T in)
-            : data (in)
-        {}
+    struct TStaticData : public Base {
+        explicit TStaticData(T in) :
+                data(in) {}
 
-        ~TStaticData()
-        {}
+        ~TStaticData() {}
 
         T data;
     };
 
     // some typedefs for cleaner code
     typedef unsigned int KeyType;
-    typedef std::map<KeyType, Base*>  PropertyMap;
+    typedef std::map<KeyType, Base *> PropertyMap;
 
 public:
-
     //! Destructor
-    ~SharedPostProcessInfo()
-    {
+    ~SharedPostProcessInfo() {
         Clean();
     }
 
     //! Remove all stored properties from the table
-    void Clean()
-    {
+    void Clean() {
         // invoke the virtual destructor for all stored properties
         for (PropertyMap::iterator it = pmap.begin(), end = pmap.end();
-             it != end; ++it)
-        {
+                it != end; ++it) {
             delete (*it).second;
         }
         pmap.clear();
@@ -125,25 +111,22 @@ public:
 
     //! Add a heap property to the list
     template <typename T>
-    void AddProperty( const char* name, T* in ){
-        AddProperty(name,(Base*)new THeapData<T>(in));
+    void AddProperty(const char *name, T *in) {
+        AddProperty(name, (Base *)new THeapData<T>(in));
     }
 
     //! Add a static by-value property to the list
     template <typename T>
-    void AddProperty( const char* name, T in ){
-        AddProperty(name,(Base*)new TStaticData<T>(in));
+    void AddProperty(const char *name, T in) {
+        AddProperty(name, (Base *)new TStaticData<T>(in));
     }
 
-
     //! Get a heap property
     template <typename T>
-    bool GetProperty( const char* name, T*& out ) const
-    {
-        THeapData<T>* t = (THeapData<T>*)GetPropertyInternal(name);
-        if(!t)
-        {
-            out = NULL;
+    bool GetProperty(const char *name, T *&out) const {
+        THeapData<T> *t = (THeapData<T> *)GetPropertyInternal(name);
+        if (!t) {
+            out = nullptr;
             return false;
         }
         out = t->data;
@@ -152,53 +135,34 @@ public:
 
     //! Get a static, by-value property
     template <typename T>
-    bool GetProperty( const char* name, T& out ) const
-    {
-        TStaticData<T>* t = (TStaticData<T>*)GetPropertyInternal(name);
-        if(!t)return false;
+    bool GetProperty(const char *name, T &out) const {
+        TStaticData<T> *t = (TStaticData<T> *)GetPropertyInternal(name);
+        if ( nullptr == t) {
+            return false;
+        }
         out = t->data;
         return true;
     }
 
     //! Remove a property of a specific type
-    void RemoveProperty( const char* name)  {
-        SetGenericPropertyPtr<Base>(pmap,name,NULL);
+    void RemoveProperty(const char *name) {
+        SetGenericPropertyPtr<Base>(pmap, name, nullptr );
     }
 
 private:
-
-    void AddProperty( const char* name, Base* data) {
-        SetGenericPropertyPtr<Base>(pmap,name,data);
+    void AddProperty(const char *name, Base *data) {
+        SetGenericPropertyPtr<Base>(pmap, name, data);
     }
 
-    Base* GetPropertyInternal( const char* name) const  {
-        return GetGenericProperty<Base*>(pmap,name,NULL);
+    Base *GetPropertyInternal(const char *name) const {
+        return GetGenericProperty<Base *>(pmap, name, nullptr );
     }
 
 private:
-
     //! Map of all stored properties
     PropertyMap pmap;
 };
 
-#if 0
-
-// ---------------------------------------------------------------------------
-/** @brief Represents a dependency table for a postprocessing steps.
- *
- *  For future use.
- */
- struct PPDependencyTable
- {
-     unsigned int execute_me_before_these;
-     unsigned int execute_me_after_these;
-     unsigned int only_if_these_are_not_specified;
-     unsigned int mutually_exclusive_with;
- };
-
-#endif
-
-
 #define AI_SPP_SPATIAL_SORT "$Spat"
 
 // ---------------------------------------------------------------------------
@@ -228,7 +192,7 @@ public:
      * @return true if the process is present in this flag fields,
      *   false if not.
     */
-    virtual bool IsActive( unsigned int pFlags) const = 0;
+    virtual bool IsActive(unsigned int pFlags) const = 0;
 
     // -------------------------------------------------------------------
     /** Check whether this step expects its input vertex data to be
@@ -238,17 +202,17 @@ public:
     // -------------------------------------------------------------------
     /** Executes the post processing step on the given imported data.
     * The function deletes the scene if the postprocess step fails (
-    * the object pointer will be set to NULL).
+    * the object pointer will be set to nullptr).
     * @param pImp Importer instance (pImp->mScene must be valid)
     */
-    void ExecuteOnScene( Importer* pImp);
+    void ExecuteOnScene(Importer *pImp);
 
     // -------------------------------------------------------------------
     /** Called prior to ExecuteOnScene().
     * The function is a request to the process to update its configuration
     * basing on the Importer's configuration property list.
     */
-    virtual void SetupProperties(const Importer* pImp);
+    virtual void SetupProperties(const Importer *pImp);
 
     // -------------------------------------------------------------------
     /** Executes the post processing step on the given imported data.
@@ -256,35 +220,32 @@ public:
     * This method must be implemented by deriving classes.
     * @param pScene The imported data to work at.
     */
-    virtual void Execute( aiScene* pScene) = 0;
-
+    virtual void Execute(aiScene *pScene) = 0;
 
     // -------------------------------------------------------------------
     /** Assign a new SharedPostProcessInfo to the step. This object
      *  allows multiple postprocess steps to share data.
-     * @param sh May be NULL
+     * @param sh May be nullptr
     */
-    inline void SetSharedData(SharedPostProcessInfo* sh)    {
+    inline void SetSharedData(SharedPostProcessInfo *sh) {
         shared = sh;
     }
 
     // -------------------------------------------------------------------
     /** Get the shared data that is assigned to the step.
     */
-    inline SharedPostProcessInfo* GetSharedData()   {
+    inline SharedPostProcessInfo *GetSharedData() {
         return shared;
     }
 
 protected:
-
     /** See the doc of #SharedPostProcessInfo for more details */
-    SharedPostProcessInfo* shared;
+    SharedPostProcessInfo *shared;
 
     /** Currently active progress handler */
-    ProgressHandler* progress;
+    ProgressHandler *progress;
 };
 
-
 } // end of namespace Assimp
 
 #endif // AI_BASEPROCESS_H_INC
diff --git a/Engine/lib/assimp/code/Common/Bitmap.cpp b/Engine/lib/assimp/code/Common/Bitmap.cpp
index b22b71ea9..65dfd1754 100644
--- a/Engine/lib/assimp/code/Common/Bitmap.cpp
+++ b/Engine/lib/assimp/code/Common/Bitmap.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -47,109 +45,112 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  * Used for file formats which embed their textures into the model file.
  */
 
-
 #include <assimp/Bitmap.h>
+#include <assimp/ByteSwapper.h>
 #include <assimp/texture.h>
 #include <assimp/IOStream.hpp>
-#include <assimp/ByteSwapper.h>
 
 namespace Assimp {
 
-    void Bitmap::Save(aiTexture* texture, IOStream* file) {
-        if(file != NULL) {
-            Header header;
-            DIB dib;
-
-            dib.size = DIB::dib_size;
-            dib.width = texture->mWidth;
-            dib.height = texture->mHeight;
-            dib.planes = 1;
-            dib.bits_per_pixel = 8 * mBytesPerPixel;
-            dib.compression = 0;
-            dib.image_size = (((dib.width * mBytesPerPixel) + 3) & 0x0000FFFC) * dib.height;
-            dib.x_resolution = 0;
-            dib.y_resolution = 0;
-            dib.nb_colors = 0;
-            dib.nb_important_colors = 0;
-
-            header.type = 0x4D42; // 'BM'
-            header.offset = Header::header_size + DIB::dib_size;
-            header.size = header.offset + dib.image_size;
-            header.reserved1 = 0;
-            header.reserved2 = 0;
-
-            WriteHeader(header, file);
-            WriteDIB(dib, file);
-            WriteData(texture, file);
-        }
+bool Bitmap::Save(aiTexture *texture, IOStream *file) {
+    if (file == nullptr) {
+        return false;
     }
 
-    template<typename T>
-    inline 
-    std::size_t Copy(uint8_t* data, const T &field) {
-#ifdef AI_BUILD_BIG_ENDIAN
-        T field_swapped=AI_BE(field);
-        std::memcpy(data, &field_swapped, sizeof(field)); return sizeof(field);
-#else
-        std::memcpy(data, &AI_BE(field), sizeof(field)); return sizeof(field);
-#endif
-    }
+    Header header;
+    DIB dib;
+    dib.size = DIB::dib_size;
+    dib.width = texture->mWidth;
+    dib.height = texture->mHeight;
+    dib.planes = 1;
+    dib.bits_per_pixel = 8 * mBytesPerPixel;
+    dib.compression = 0;
+    dib.image_size = (((dib.width * mBytesPerPixel) + 3) & 0x0000FFFC) * dib.height;
+    dib.x_resolution = 0;
+    dib.y_resolution = 0;
+    dib.nb_colors = 0;
+    dib.nb_important_colors = 0;
 
-    void Bitmap::WriteHeader(Header& header, IOStream* file) {
-        uint8_t data[Header::header_size];
+    header.type = 0x4D42; // 'BM'
+    header.offset = Header::header_size + DIB::dib_size;
+    header.size = header.offset + dib.image_size;
+    header.reserved1 = 0;
+    header.reserved2 = 0;
 
-        std::size_t offset = 0;
-
-        offset += Copy(&data[offset], header.type);
-        offset += Copy(&data[offset], header.size);
-        offset += Copy(&data[offset], header.reserved1);
-        offset += Copy(&data[offset], header.reserved2);
-                  Copy(&data[offset], header.offset);
-
-        file->Write(data, Header::header_size, 1);
-    }
-
-    void Bitmap::WriteDIB(DIB& dib, IOStream* file) {
-        uint8_t data[DIB::dib_size];
-
-        std::size_t offset = 0;
-
-        offset += Copy(&data[offset], dib.size);
-        offset += Copy(&data[offset], dib.width);
-        offset += Copy(&data[offset], dib.height);
-        offset += Copy(&data[offset], dib.planes);
-        offset += Copy(&data[offset], dib.bits_per_pixel);
-        offset += Copy(&data[offset], dib.compression);
-        offset += Copy(&data[offset], dib.image_size);
-        offset += Copy(&data[offset], dib.x_resolution);
-        offset += Copy(&data[offset], dib.y_resolution);
-        offset += Copy(&data[offset], dib.nb_colors);
-                  Copy(&data[offset], dib.nb_important_colors);
-
-        file->Write(data, DIB::dib_size, 1);
-    }
-
-    void Bitmap::WriteData(aiTexture* texture, IOStream* file) {
-        static const std::size_t padding_offset = 4;
-        static const uint8_t padding_data[padding_offset] = {0x0, 0x0, 0x0, 0x0};
-
-        unsigned int padding = (padding_offset - ((mBytesPerPixel * texture->mWidth) % padding_offset)) % padding_offset;
-        uint8_t pixel[mBytesPerPixel];
-
-        for(std::size_t i = 0; i < texture->mHeight; ++i) {
-            for(std::size_t j = 0; j < texture->mWidth; ++j) {
-                const aiTexel& texel = texture->pcData[(texture->mHeight - i - 1) * texture->mWidth + j]; // Bitmap files are stored in bottom-up format
-
-                pixel[0] = texel.r;
-                pixel[1] = texel.g;
-                pixel[2] = texel.b;
-                pixel[3] = texel.a;
-
-                file->Write(pixel, mBytesPerPixel, 1);
-            }
-
-            file->Write(padding_data, padding, 1);
-        }
-    }
+    WriteHeader(header, file);
+    WriteDIB(dib, file);
+    WriteData(texture, file);
 
+    return true;
 }
+
+template <typename T>
+inline std::size_t Copy(uint8_t *data, const T &field) {
+#ifdef AI_BUILD_BIG_ENDIAN
+    T field_swapped = AI_BE(field);
+    std::memcpy(data, &field_swapped, sizeof(field));
+    return sizeof(field);
+#else
+    std::memcpy(data, &AI_BE(field), sizeof(field));
+    return sizeof(field);
+#endif
+}
+
+void Bitmap::WriteHeader(Header &header, IOStream *file) {
+    uint8_t data[Header::header_size];
+
+    std::size_t offset = 0;
+
+    offset += Copy(&data[offset], header.type);
+    offset += Copy(&data[offset], header.size);
+    offset += Copy(&data[offset], header.reserved1);
+    offset += Copy(&data[offset], header.reserved2);
+    Copy(&data[offset], header.offset);
+
+    file->Write(data, Header::header_size, 1);
+}
+
+void Bitmap::WriteDIB(DIB &dib, IOStream *file) {
+    uint8_t data[DIB::dib_size];
+
+    std::size_t offset = 0;
+
+    offset += Copy(&data[offset], dib.size);
+    offset += Copy(&data[offset], dib.width);
+    offset += Copy(&data[offset], dib.height);
+    offset += Copy(&data[offset], dib.planes);
+    offset += Copy(&data[offset], dib.bits_per_pixel);
+    offset += Copy(&data[offset], dib.compression);
+    offset += Copy(&data[offset], dib.image_size);
+    offset += Copy(&data[offset], dib.x_resolution);
+    offset += Copy(&data[offset], dib.y_resolution);
+    offset += Copy(&data[offset], dib.nb_colors);
+    Copy(&data[offset], dib.nb_important_colors);
+
+    file->Write(data, DIB::dib_size, 1);
+}
+
+void Bitmap::WriteData(aiTexture *texture, IOStream *file) {
+    static const std::size_t padding_offset = 4;
+    static const uint8_t padding_data[padding_offset] = { 0x0, 0x0, 0x0, 0x0 };
+
+    unsigned int padding = (padding_offset - ((mBytesPerPixel * texture->mWidth) % padding_offset)) % padding_offset;
+    uint8_t pixel[mBytesPerPixel];
+
+    for (std::size_t i = 0; i < texture->mHeight; ++i) {
+        for (std::size_t j = 0; j < texture->mWidth; ++j) {
+            const aiTexel &texel = texture->pcData[(texture->mHeight - i - 1) * texture->mWidth + j]; // Bitmap files are stored in bottom-up format
+
+            pixel[0] = texel.r;
+            pixel[1] = texel.g;
+            pixel[2] = texel.b;
+            pixel[3] = texel.a;
+
+            file->Write(pixel, mBytesPerPixel, 1);
+        }
+
+        file->Write(padding_data, padding, 1);
+    }
+}
+
+} // namespace Assimp
diff --git a/Engine/lib/assimp/code/Common/Compression.cpp b/Engine/lib/assimp/code/Common/Compression.cpp
new file mode 100644
index 000000000..3bf306dee
--- /dev/null
+++ b/Engine/lib/assimp/code/Common/Compression.cpp
@@ -0,0 +1,214 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#include "Compression.h"
+#include <assimp/ai_assert.h>
+#include <assimp/Exceptional.h>
+
+namespace Assimp {
+
+struct Compression::impl {
+    bool mOpen;
+    z_stream mZSstream;
+    FlushMode mFlushMode;
+
+    impl() :
+            mOpen(false),
+            mZSstream(),
+            mFlushMode(Compression::FlushMode::NoFlush) {
+        // empty
+    }
+};
+
+Compression::Compression() :
+        mImpl(new impl) {
+    // empty
+}
+
+Compression::~Compression() {
+    ai_assert(mImpl != nullptr);
+
+    delete mImpl;
+}
+
+bool Compression::open(Format format, FlushMode flush, int windowBits) {
+    ai_assert(mImpl != nullptr);
+
+    if (mImpl->mOpen) {
+        return false;
+    }
+
+    // build a zlib stream
+    mImpl->mZSstream.opaque = Z_NULL;
+    mImpl->mZSstream.zalloc = Z_NULL;
+    mImpl->mZSstream.zfree = Z_NULL;
+    mImpl->mFlushMode = flush;
+    if (format == Format::Binary) {
+        mImpl->mZSstream.data_type = Z_BINARY;
+    } else {
+        mImpl->mZSstream.data_type = Z_ASCII;
+    }
+
+    // raw decompression without a zlib or gzip header
+    if (windowBits == 0) {
+        inflateInit(&mImpl->mZSstream);
+    } else {
+        inflateInit2(&mImpl->mZSstream, windowBits);
+    }
+    mImpl->mOpen = true;
+
+    return mImpl->mOpen;
+}
+
+static int getFlushMode(Compression::FlushMode flush) {
+    int z_flush = 0;
+    switch (flush) {
+        case Compression::FlushMode::NoFlush:
+            z_flush = Z_NO_FLUSH;
+            break;
+        case Compression::FlushMode::Block:
+            z_flush = Z_BLOCK;
+            break;
+        case Compression::FlushMode::Tree:
+            z_flush = Z_TREES;
+            break;
+        case Compression::FlushMode::SyncFlush:
+            z_flush = Z_SYNC_FLUSH;
+            break;
+        case Compression::FlushMode::Finish:
+            z_flush = Z_FINISH;
+            break;
+        default:
+            ai_assert(false);
+            break;
+    }
+
+    return z_flush;
+}
+
+constexpr size_t MYBLOCK = 32786;
+
+size_t Compression::decompress(const void *data, size_t in, std::vector<char> &uncompressed) {
+    ai_assert(mImpl != nullptr);
+    if (data == nullptr || in == 0) {
+        return 0l;
+    }
+
+    mImpl->mZSstream.next_in = (Bytef*)(data);
+    mImpl->mZSstream.avail_in = (uInt)in;
+
+    int ret = 0;
+    size_t total = 0l;
+    const int flushMode = getFlushMode(mImpl->mFlushMode);
+    if (flushMode == Z_FINISH) {
+        mImpl->mZSstream.avail_out = static_cast<uInt>(uncompressed.size());
+        mImpl->mZSstream.next_out = reinterpret_cast<Bytef *>(&*uncompressed.begin());
+        ret = inflate(&mImpl->mZSstream, Z_FINISH);
+
+        if (ret != Z_STREAM_END && ret != Z_OK) {
+            throw DeadlyImportError("Compression", "Failure decompressing this file using gzip.");
+        }
+        total = mImpl->mZSstream.avail_out;
+    } else {
+        do {
+            Bytef block[MYBLOCK] = {};
+            mImpl->mZSstream.avail_out = MYBLOCK;
+            mImpl->mZSstream.next_out = block;
+
+            ret = inflate(&mImpl->mZSstream, flushMode);
+
+            if (ret != Z_STREAM_END && ret != Z_OK) {
+                throw DeadlyImportError("Compression", "Failure decompressing this file using gzip.");
+            }
+            const size_t have = MYBLOCK - mImpl->mZSstream.avail_out;
+            total += have;
+            uncompressed.resize(total);
+            ::memcpy(uncompressed.data() + total - have, block, have);
+        } while (ret != Z_STREAM_END);
+    }
+
+    return total;
+}
+
+size_t Compression::decompressBlock(const void *data, size_t in, char *out, size_t availableOut) {
+    ai_assert(mImpl != nullptr);
+    if (data == nullptr || in == 0 || out == nullptr || availableOut == 0) {
+        return 0l;
+    }
+
+    // push data to the stream
+    mImpl->mZSstream.next_in = (Bytef *)data;
+    mImpl->mZSstream.avail_in = (uInt)in;
+    mImpl->mZSstream.next_out = (Bytef *)out;
+    mImpl->mZSstream.avail_out = (uInt)availableOut;
+
+    // and decompress the data ....
+    int ret = ::inflate(&mImpl->mZSstream, Z_SYNC_FLUSH);
+    if (ret != Z_OK && ret != Z_STREAM_END) {
+        throw DeadlyImportError("X: Failed to decompress MSZIP-compressed data");
+    }
+
+    ::inflateReset(&mImpl->mZSstream);
+    ::inflateSetDictionary(&mImpl->mZSstream, (const Bytef *)out, (uInt)availableOut - mImpl->mZSstream.avail_out);
+
+    return availableOut - (size_t)mImpl->mZSstream.avail_out;
+}
+
+bool Compression::isOpen() const {
+    ai_assert(mImpl != nullptr);
+
+    return mImpl->mOpen;
+}
+
+bool Compression::close() {
+    ai_assert(mImpl != nullptr);
+
+    if (!mImpl->mOpen) {
+        return false;
+    }
+
+    inflateEnd(&mImpl->mZSstream);
+    mImpl->mOpen = false;
+
+    return true;
+}
+
+} // namespace Assimp
diff --git a/Engine/lib/assimp/code/Common/Compression.h b/Engine/lib/assimp/code/Common/Compression.h
new file mode 100644
index 000000000..edf1d232f
--- /dev/null
+++ b/Engine/lib/assimp/code/Common/Compression.h
@@ -0,0 +1,121 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#pragma once
+
+#ifdef ASSIMP_BUILD_NO_OWN_ZLIB
+#include <zlib.h>
+#else
+#include "../contrib/zlib/zlib.h"
+#endif
+
+#include <vector>
+#include <cstddef> // size_t
+
+namespace Assimp {
+
+/// @brief This class provides the decompression of zlib-compressed data.
+class Compression {
+public:
+    static const int MaxWBits = MAX_WBITS;
+
+    /// @brief Describes the format data type
+    enum class Format {
+        InvalidFormat = -1, ///< Invalid enum type.
+        Binary = 0,         ///< Binary format.
+        ASCII,              ///< ASCII format.
+
+        NumFormats          ///< The number of supported formats.
+    };
+
+    /// @brief The supported flush mode, used for blocked access.
+    enum class FlushMode {
+        InvalidFormat = -1, ///< Invalid enum type.
+        NoFlush = 0,        ///< No flush, will be done on inflate end.
+        Block,              ///< Assists in combination of compress.
+        Tree,               ///< Assists in combination of compress and returns if stream is finish.
+        SyncFlush,          ///< Synced flush mode.
+        Finish,             ///< Finish mode, all in once, no block access.
+
+        NumModes            ///< The number of supported modes.
+    };
+
+    /// @brief  The class constructor.
+    Compression();
+
+    ///	@brief  The class destructor.
+    ~Compression();
+
+    /// @brief  Will open the access to the compression.
+    /// @param[in] format       The format type
+    /// @param[in] flush        The flush mode.
+    /// @param[in] windowBits   The windows history working size, shall be between 8 and 15.
+    /// @return true if close was successful, false if not.
+    bool open(Format format, FlushMode flush, int windowBits);
+
+    /// @brief  Will return the open state.
+    /// @return true if the access is opened, false if not.
+    bool isOpen() const;
+
+    /// @brief  Will close the decompress access.
+    /// @return true if close was successful, false if not.
+    bool close();
+
+    /// @brief Will decompress the data buffer in one step.
+    /// @param[in] data         The data to decompress
+    /// @param[in] in           The size of the data.
+    /// @param[out uncompressed A std::vector containing the decompressed data.
+    size_t decompress(const void *data, size_t in, std::vector<char> &uncompressed);
+
+    /// @brief Will decompress the data buffer block-wise.
+    /// @param[in]  data         The compressed data
+    /// @param[in]  in           The size of the data buffer
+    /// @param[out] out          The output buffer
+    /// @param[out] availableOut The upper limit of the output buffer.
+    /// @return The size of the decompressed data buffer.
+    size_t decompressBlock(const void *data, size_t in, char *out, size_t availableOut);
+
+private:
+    struct impl;
+    impl *mImpl;
+};
+
+} // namespace Assimp
diff --git a/Engine/lib/assimp/code/Common/CreateAnimMesh.cpp b/Engine/lib/assimp/code/Common/CreateAnimMesh.cpp
index 98b60e531..58f3d909d 100644
--- a/Engine/lib/assimp/code/Common/CreateAnimMesh.cpp
+++ b/Engine/lib/assimp/code/Common/CreateAnimMesh.cpp
@@ -4,7 +4,7 @@ Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
 Copyright (C) 2016 The Qt Company Ltd.
-Copyright (c) 2006-2012, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -44,42 +44,46 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 namespace Assimp    {
 
-aiAnimMesh *aiCreateAnimMesh(const aiMesh *mesh)
+aiAnimMesh *aiCreateAnimMesh(const aiMesh *mesh, bool needPositions, bool needNormals, bool needTangents, bool needColors, bool needTexCoords)
 {
     aiAnimMesh *animesh = new aiAnimMesh;
     animesh->mNumVertices = mesh->mNumVertices;
-    if (mesh->mVertices) {
+    if (needPositions && mesh->mVertices) {
         animesh->mVertices = new aiVector3D[animesh->mNumVertices];
         std::memcpy(animesh->mVertices, mesh->mVertices, mesh->mNumVertices * sizeof(aiVector3D));
     }
-    if (mesh->mNormals) {
+    if (needNormals && mesh->mNormals) {
         animesh->mNormals = new aiVector3D[animesh->mNumVertices];
         std::memcpy(animesh->mNormals, mesh->mNormals, mesh->mNumVertices * sizeof(aiVector3D));
     }
-    if (mesh->mTangents) {
+    if (needTangents && mesh->mTangents) {
         animesh->mTangents = new aiVector3D[animesh->mNumVertices];
         std::memcpy(animesh->mTangents, mesh->mTangents, mesh->mNumVertices * sizeof(aiVector3D));
     }
-    if (mesh->mBitangents) {
+    if (needTangents && mesh->mBitangents) {
         animesh->mBitangents = new aiVector3D[animesh->mNumVertices];
         std::memcpy(animesh->mBitangents, mesh->mBitangents, mesh->mNumVertices * sizeof(aiVector3D));
     }
 
-    for (int i = 0; i < AI_MAX_NUMBER_OF_COLOR_SETS; ++i) {
-        if (mesh->mColors[i]) {
-            animesh->mColors[i] = new aiColor4D[animesh->mNumVertices];
-            std::memcpy(animesh->mColors[i], mesh->mColors[i], mesh->mNumVertices * sizeof(aiColor4D));
-        } else {
-            animesh->mColors[i] = NULL;
+    if (needColors) {
+        for (int i = 0; i < AI_MAX_NUMBER_OF_COLOR_SETS; ++i) {
+            if (mesh->mColors[i]) {
+                animesh->mColors[i] = new aiColor4D[animesh->mNumVertices];
+                std::memcpy(animesh->mColors[i], mesh->mColors[i], mesh->mNumVertices * sizeof(aiColor4D));
+            } else {
+                animesh->mColors[i] = nullptr;
+            }
         }
     }
 
-    for (int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
-        if (mesh->mTextureCoords[i]) {
-            animesh->mTextureCoords[i] = new aiVector3D[animesh->mNumVertices];
-            std::memcpy(animesh->mTextureCoords[i], mesh->mTextureCoords[i], mesh->mNumVertices * sizeof(aiVector3D));
-        } else {
-            animesh->mTextureCoords[i] = NULL;
+    if (needTexCoords) {
+        for (int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
+            if (mesh->mTextureCoords[i]) {
+                animesh->mTextureCoords[i] = new aiVector3D[animesh->mNumVertices];
+                std::memcpy(animesh->mTextureCoords[i], mesh->mTextureCoords[i], mesh->mNumVertices * sizeof(aiVector3D));
+            } else {
+                animesh->mTextureCoords[i] = nullptr;
+            }
         }
     }
     return animesh;
diff --git a/Engine/lib/assimp/code/Common/DefaultIOStream.cpp b/Engine/lib/assimp/code/Common/DefaultIOStream.cpp
index 1c100b618..e30f26acd 100644
--- a/Engine/lib/assimp/code/Common/DefaultIOStream.cpp
+++ b/Engine/lib/assimp/code/Common/DefaultIOStream.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -44,75 +42,104 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Default File I/O implementation for #Importer
  */
 
-
-#include <assimp/ai_assert.h>
 #include <assimp/DefaultIOStream.h>
-#include <sys/types.h>
+#include <assimp/ai_assert.h>
 #include <sys/stat.h>
+#include <sys/types.h>
 
 using namespace Assimp;
 
+namespace {
+
+template <size_t sizeOfPointer>
+inline size_t select_ftell(FILE *file) {
+    return ::ftell(file);
+}
+
+template <size_t sizeOfPointer>
+inline int select_fseek(FILE *file, int64_t offset, int origin) {
+    return ::fseek(file, static_cast<long>(offset), origin);
+}
+
+
+
+#if defined _WIN32 && (!defined __GNUC__ || __MSVCRT_VERSION__ >= 0x0601)
+template <>
+inline size_t select_ftell<8>(FILE *file) {
+    return (size_t)::_ftelli64(file);
+}
+
+template <>
+inline int select_fseek<8>(FILE *file, int64_t offset, int origin) {
+    return ::_fseeki64(file, offset, origin);
+}
+
+#endif // #if defined _WIN32 && (!defined __GNUC__ || __MSVCRT_VERSION__ >= 0x0601)
+
+} // namespace
+
 // ----------------------------------------------------------------------------------
-DefaultIOStream::~DefaultIOStream()
-{
+DefaultIOStream::~DefaultIOStream() {
     if (mFile) {
         ::fclose(mFile);
-        mFile = nullptr;
     }
 }
 
 // ----------------------------------------------------------------------------------
-size_t DefaultIOStream::Read(void* pvBuffer,
-    size_t pSize,
-    size_t pCount)
-{
-    ai_assert(NULL != pvBuffer && 0 != pSize && 0 != pCount);
+size_t DefaultIOStream::Read(void *pvBuffer,
+        size_t pSize,
+        size_t pCount) {
+    if (0 == pCount) {
+        return 0;
+    }
+    ai_assert(nullptr != pvBuffer);
+    ai_assert(0 != pSize);
+
     return (mFile ? ::fread(pvBuffer, pSize, pCount, mFile) : 0);
 }
 
 // ----------------------------------------------------------------------------------
-size_t DefaultIOStream::Write(const void* pvBuffer,
-    size_t pSize,
-    size_t pCount)
-{
-    ai_assert(NULL != pvBuffer && 0 != pSize && 0 != pCount);
+size_t DefaultIOStream::Write(const void *pvBuffer,
+        size_t pSize,
+        size_t pCount) {
+    ai_assert(nullptr != pvBuffer);
+    ai_assert(0 != pSize);
+
     return (mFile ? ::fwrite(pvBuffer, pSize, pCount, mFile) : 0);
 }
 
 // ----------------------------------------------------------------------------------
 aiReturn DefaultIOStream::Seek(size_t pOffset,
-     aiOrigin pOrigin)
-{
+        aiOrigin pOrigin) {
     if (!mFile) {
         return AI_FAILURE;
     }
 
     // Just to check whether our enum maps one to one with the CRT constants
     static_assert(aiOrigin_CUR == SEEK_CUR &&
-        aiOrigin_END == SEEK_END && aiOrigin_SET == SEEK_SET, "aiOrigin_CUR == SEEK_CUR && \
+                          aiOrigin_END == SEEK_END && aiOrigin_SET == SEEK_SET,
+            "aiOrigin_CUR == SEEK_CUR && \
         aiOrigin_END == SEEK_END && aiOrigin_SET == SEEK_SET");
 
     // do the seek
-    return (0 == ::fseek(mFile, (long)pOffset,(int)pOrigin) ? AI_SUCCESS : AI_FAILURE);
+    return (0 == select_fseek<sizeof(void *)>(mFile, (int64_t)pOffset, (int)pOrigin) ? AI_SUCCESS : AI_FAILURE);
 }
 
 // ----------------------------------------------------------------------------------
-size_t DefaultIOStream::Tell() const
-{
+size_t DefaultIOStream::Tell() const {
     if (!mFile) {
         return 0;
     }
-    return ::ftell(mFile);
+    return select_ftell<sizeof(void *)>(mFile);
 }
 
 // ----------------------------------------------------------------------------------
-size_t DefaultIOStream::FileSize() const
-{
-    if (! mFile || mFilename.empty()) {
+size_t DefaultIOStream::FileSize() const {
+    if (!mFile || mFilename.empty()) {
         return 0;
     }
 
-    if (SIZE_MAX == mCachedSize ) {
+    if (SIZE_MAX == mCachedSize) {
 
         // Although fseek/ftell would allow us to reuse the existing file handle here,
         // it is generally unsafe because:
@@ -125,27 +152,26 @@ size_t DefaultIOStream::FileSize() const
 #if defined _WIN32 && (!defined __GNUC__ || __MSVCRT_VERSION__ >= 0x0601)
         struct __stat64 fileStat;
         //using fileno + fstat avoids having to handle the filename
-        int err = _fstat64(  _fileno(mFile), &fileStat );
+        int err = _fstat64(_fileno(mFile), &fileStat);
         if (0 != err)
             return 0;
-        mCachedSize = (size_t) (fileStat.st_size);
+        mCachedSize = (size_t)(fileStat.st_size);
 #elif defined __GNUC__ || defined __APPLE__ || defined __MACH__ || defined __FreeBSD__
         struct stat fileStat;
-        int err = stat(mFilename.c_str(), &fileStat );
+        int err = stat(mFilename.c_str(), &fileStat);
         if (0 != err)
             return 0;
         const unsigned long long cachedSize = fileStat.st_size;
-        mCachedSize = static_cast< size_t >( cachedSize );
+        mCachedSize = static_cast<size_t>(cachedSize);
 #else
-#   error "Unknown platform"
+#error "Unknown platform"
 #endif
     }
     return mCachedSize;
 }
 
 // ----------------------------------------------------------------------------------
-void DefaultIOStream::Flush()
-{
+void DefaultIOStream::Flush() {
     if (mFile) {
         ::fflush(mFile);
     }
diff --git a/Engine/lib/assimp/code/Common/DefaultIOSystem.cpp b/Engine/lib/assimp/code/Common/DefaultIOSystem.cpp
index 6fdc24dd8..b28910c70 100644
--- a/Engine/lib/assimp/code/Common/DefaultIOSystem.cpp
+++ b/Engine/lib/assimp/code/Common/DefaultIOSystem.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -44,91 +42,106 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <assimp/StringComparison.h>
 
-#include <assimp/DefaultIOSystem.h>
 #include <assimp/DefaultIOStream.h>
-#include <assimp/DefaultLogger.hpp>
+#include <assimp/DefaultIOSystem.h>
 #include <assimp/ai_assert.h>
 #include <stdlib.h>
+#include <assimp/DefaultLogger.hpp>
 
 #ifdef __unix__
-#include <sys/param.h>
-#include <stdlib.h>
+#    include <stdlib.h>
+#    include <sys/param.h>
 #endif
 
 #ifdef _WIN32
-#include <windows.h>
+#    include <windows.h>
 #endif
 
 using namespace Assimp;
 
 #ifdef _WIN32
-static std::wstring Utf8ToWide(const char* in)
-{
+
+const std::wstring wdummy;
+
+static std::wstring Utf8ToWide(const char *in) {
+    if (nullptr == in) {
+        return wdummy;
+    }
     int size = MultiByteToWideChar(CP_UTF8, 0, in, -1, nullptr, 0);
     // size includes terminating null; std::wstring adds null automatically
     std::wstring out(static_cast<size_t>(size) - 1, L'\0');
     MultiByteToWideChar(CP_UTF8, 0, in, -1, &out[0], size);
+
     return out;
 }
 
-static std::string WideToUtf8(const wchar_t* in)
-{
+const std::string dummy;
+
+static std::string WideToUtf8(const wchar_t *in) {
+    if (nullptr == in) {
+        return dummy;
+    }
     int size = WideCharToMultiByte(CP_UTF8, 0, in, -1, nullptr, 0, nullptr, nullptr);
     // size includes terminating null; std::string adds null automatically
     std::string out(static_cast<size_t>(size) - 1, '\0');
     WideCharToMultiByte(CP_UTF8, 0, in, -1, &out[0], size, nullptr, nullptr);
+
     return out;
 }
 #endif
 
 // ------------------------------------------------------------------------------------------------
 // Tests for the existence of a file at the given path.
-bool DefaultIOSystem::Exists(const char* pFile) const
-{
+bool DefaultIOSystem::Exists(const char *pFile) const {
 #ifdef _WIN32
     struct __stat64 filestat;
     if (_wstat64(Utf8ToWide(pFile).c_str(), &filestat) != 0) {
         return false;
     }
 #else
-    FILE* file = ::fopen(pFile, "rb");
-    if (!file)
+    FILE *file = ::fopen(pFile, "rb");
+    if (!file) {
         return false;
+    }
 
     ::fclose(file);
 #endif
+
     return true;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Open a new file with a given path.
-IOStream* DefaultIOSystem::Open(const char* strFile, const char* strMode)
-{
+IOStream *DefaultIOSystem::Open(const char *strFile, const char *strMode) {
     ai_assert(strFile != nullptr);
     ai_assert(strMode != nullptr);
-    FILE* file;
+    FILE *file;
 #ifdef _WIN32
-    file = ::_wfopen(Utf8ToWide(strFile).c_str(), Utf8ToWide(strMode).c_str());
+    std::wstring name = Utf8ToWide(strFile);
+    if (name.empty()) {
+        return nullptr;
+    }
+
+    file = ::_wfopen(name.c_str(), Utf8ToWide(strMode).c_str());
 #else
     file = ::fopen(strFile, strMode);
 #endif
-    if (!file)
+    if (!file) {
         return nullptr;
+    }
 
     return new DefaultIOStream(file, strFile);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Closes the given file and releases all resources associated with it.
-void DefaultIOSystem::Close(IOStream* pFile)
-{
+void DefaultIOSystem::Close(IOStream *pFile) {
     delete pFile;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Returns the operation specific directory separator
-char DefaultIOSystem::getOsSeparator() const
-{
+char DefaultIOSystem::getOsSeparator() const {
 #ifndef _WIN32
     return '/';
 #else
@@ -138,34 +151,32 @@ char DefaultIOSystem::getOsSeparator() const
 
 // ------------------------------------------------------------------------------------------------
 // IOSystem default implementation (ComparePaths isn't a pure virtual function)
-bool IOSystem::ComparePaths(const char* one, const char* second) const
-{
+bool IOSystem::ComparePaths(const char *one, const char *second) const {
     return !ASSIMP_stricmp(one, second);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Convert a relative path into an absolute path
-inline static std::string MakeAbsolutePath(const char* in)
-{
+inline static std::string MakeAbsolutePath(const char *in) {
     ai_assert(in);
     std::string out;
 #ifdef _WIN32
-    wchar_t* ret = ::_wfullpath(nullptr, Utf8ToWide(in).c_str(), 0);
+    wchar_t *ret = ::_wfullpath(nullptr, Utf8ToWide(in).c_str(), 0);
     if (ret) {
         out = WideToUtf8(ret);
         free(ret);
     }
 #else
-    char* ret = realpath(in, nullptr);
+    char *ret = realpath(in, nullptr);
     if (ret) {
         out = ret;
         free(ret);
     }
 #endif
-    if (!ret) {
+    else {
         // preserve the input path, maybe someone else is able to fix
         // the path before it is accessed (e.g. our file system filter)
-        ASSIMP_LOG_WARN_F("Invalid path: ", std::string(in));
+        ASSIMP_LOG_WARN("Invalid path: ", std::string(in));
         out = in;
     }
     return out;
@@ -173,8 +184,7 @@ inline static std::string MakeAbsolutePath(const char* in)
 
 // ------------------------------------------------------------------------------------------------
 // DefaultIOSystem's more specialized implementation
-bool DefaultIOSystem::ComparePaths(const char* one, const char* second) const
-{
+bool DefaultIOSystem::ComparePaths(const char *one, const char *second) const {
     // chances are quite good both paths are formatted identically,
     // so we can hopefully return here already
     if (!ASSIMP_stricmp(one, second))
@@ -187,8 +197,7 @@ bool DefaultIOSystem::ComparePaths(const char* one, const char* second) const
 }
 
 // ------------------------------------------------------------------------------------------------
-std::string DefaultIOSystem::fileName(const std::string& path)
-{
+std::string DefaultIOSystem::fileName(const std::string &path) {
     std::string ret = path;
     std::size_t last = ret.find_last_of("\\/");
     if (last != std::string::npos) ret = ret.substr(last + 1);
@@ -196,8 +205,7 @@ std::string DefaultIOSystem::fileName(const std::string& path)
 }
 
 // ------------------------------------------------------------------------------------------------
-std::string DefaultIOSystem::completeBaseName(const std::string& path)
-{
+std::string DefaultIOSystem::completeBaseName(const std::string &path) {
     std::string ret = fileName(path);
     std::size_t pos = ret.find_last_of('.');
     if (pos != std::string::npos) ret = ret.substr(0, pos);
@@ -205,8 +213,7 @@ std::string DefaultIOSystem::completeBaseName(const std::string& path)
 }
 
 // ------------------------------------------------------------------------------------------------
-std::string DefaultIOSystem::absolutePath(const std::string& path)
-{
+std::string DefaultIOSystem::absolutePath(const std::string &path) {
     std::string ret = path;
     std::size_t last = ret.find_last_of("\\/");
     if (last != std::string::npos) ret = ret.substr(0, last);
diff --git a/Engine/lib/assimp/code/Common/DefaultLogger.cpp b/Engine/lib/assimp/code/Common/DefaultLogger.cpp
index de3528d2b..5cb32d38f 100644
--- a/Engine/lib/assimp/code/Common/DefaultLogger.cpp
+++ b/Engine/lib/assimp/code/Common/DefaultLogger.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -46,25 +46,25 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 // Default log streams
-#include "Win32DebugLogStream.h"
-#include "StdOStreamLogStream.h"
 #include "FileLogStream.h"
+#include "StdOStreamLogStream.h"
+#include "Win32DebugLogStream.h"
 #include <assimp/StringUtils.h>
 
 #include <assimp/DefaultIOSystem.h>
-#include <assimp/NullLogger.hpp>
-#include <assimp/DefaultLogger.hpp>
 #include <assimp/ai_assert.h>
-#include <iostream>
 #include <stdio.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/NullLogger.hpp>
+#include <iostream>
 
 #ifndef ASSIMP_BUILD_SINGLETHREADED
-#   include <thread>
-#   include <mutex>
-    std::mutex loggerMutex;
+#include <mutex>
+#include <thread>
+std::mutex loggerMutex;
 #endif
 
-namespace Assimp    {
+namespace Assimp {
 
 // ----------------------------------------------------------------------------------
 NullLogger DefaultLogger::s_pNullLogger;
@@ -75,13 +75,13 @@ static const unsigned int SeverityAll = Logger::Info | Logger::Err | Logger::War
 // ----------------------------------------------------------------------------------
 // Represents a log-stream + its error severity
 struct LogStreamInfo {
-    unsigned int  m_uiErrorSeverity;
-    LogStream    *m_pStream;
+    unsigned int m_uiErrorSeverity;
+    LogStream *m_pStream;
 
     // Constructor
-    LogStreamInfo( unsigned int uiErrorSev, LogStream *pStream ) :
-        m_uiErrorSeverity( uiErrorSev ),
-        m_pStream( pStream ) {
+    LogStreamInfo(unsigned int uiErrorSev, LogStream *pStream) :
+            m_uiErrorSeverity(uiErrorSev),
+            m_pStream(pStream) {
         // empty
     }
 
@@ -93,12 +93,10 @@ struct LogStreamInfo {
 
 // ----------------------------------------------------------------------------------
 // Construct a default log stream
-LogStream* LogStream::createDefaultStream(aiDefaultLogStream    streams,
-    const char* name /*= "AssimpLog.txt"*/,
-    IOSystem* io            /*= NULL*/)
-{
-    switch (streams)
-    {
+LogStream *LogStream::createDefaultStream(aiDefaultLogStream streams,
+        const char *name /*= "AssimpLog.txt"*/,
+        IOSystem *io /*= nullptr*/) {
+    switch (streams) {
         // This is a platform-specific feature
     case aiDefaultLogStream_DEBUGGER:
 #ifdef WIN32
@@ -107,116 +105,125 @@ LogStream* LogStream::createDefaultStream(aiDefaultLogStream    streams,
         return nullptr;
 #endif
 
-        // Platform-independent default streams
+    // Platform-independent default streams
     case aiDefaultLogStream_STDERR:
         return new StdOStreamLogStream(std::cerr);
     case aiDefaultLogStream_STDOUT:
         return new StdOStreamLogStream(std::cout);
     case aiDefaultLogStream_FILE:
-        return (name && *name ? new FileLogStream(name,io) : nullptr );
+        return (name && *name ? new FileLogStream(name, io) : nullptr);
     default:
         // We don't know this default log stream, so raise an assertion
         ai_assert(false);
-
     };
 
     // For compilers without dead code path detection
-    return NULL;
+    return nullptr;
 }
 
 // ----------------------------------------------------------------------------------
 //  Creates the only singleton instance
-Logger *DefaultLogger::create(const char* name /*= "AssimpLog.txt"*/,
-    LogSeverity severity                       /*= NORMAL*/,
-    unsigned int defStreams                    /*= aiDefaultLogStream_DEBUGGER | aiDefaultLogStream_FILE*/,
-    IOSystem* io                               /*= NULL*/) {
+Logger *DefaultLogger::create(const char *name /*= "AssimpLog.txt"*/,
+        LogSeverity severity /*= NORMAL*/,
+        unsigned int defStreams /*= aiDefaultLogStream_DEBUGGER | aiDefaultLogStream_FILE*/,
+        IOSystem *io /*= nullptr*/) {
     // enter the mutex here to avoid concurrency problems
 #ifndef ASSIMP_BUILD_SINGLETHREADED
     std::lock_guard<std::mutex> lock(loggerMutex);
 #endif
 
-    if ( m_pLogger && !isNullLogger() ) {
+    if (m_pLogger && !isNullLogger()) {
         delete m_pLogger;
     }
 
-    m_pLogger = new DefaultLogger( severity );
+    m_pLogger = new DefaultLogger(severity);
 
     // Attach default log streams
     // Stream the log to the MSVC debugger?
-    if ( defStreams & aiDefaultLogStream_DEBUGGER ) {
-        m_pLogger->attachStream( LogStream::createDefaultStream( aiDefaultLogStream_DEBUGGER ) );
+    if (defStreams & aiDefaultLogStream_DEBUGGER) {
+        m_pLogger->attachStream(LogStream::createDefaultStream(aiDefaultLogStream_DEBUGGER));
     }
 
     // Stream the log to COUT?
-    if ( defStreams & aiDefaultLogStream_STDOUT ) {
-        m_pLogger->attachStream( LogStream::createDefaultStream( aiDefaultLogStream_STDOUT ) );
+    if (defStreams & aiDefaultLogStream_STDOUT) {
+        m_pLogger->attachStream(LogStream::createDefaultStream(aiDefaultLogStream_STDOUT));
     }
 
     // Stream the log to CERR?
-    if ( defStreams & aiDefaultLogStream_STDERR ) {
-        m_pLogger->attachStream( LogStream::createDefaultStream( aiDefaultLogStream_STDERR ) );
+    if (defStreams & aiDefaultLogStream_STDERR) {
+        m_pLogger->attachStream(LogStream::createDefaultStream(aiDefaultLogStream_STDERR));
     }
 
     // Stream the log to a file
-    if ( defStreams & aiDefaultLogStream_FILE && name && *name ) {
-        m_pLogger->attachStream( LogStream::createDefaultStream( aiDefaultLogStream_FILE, name, io ) );
+    if (defStreams & aiDefaultLogStream_FILE && name && *name) {
+        m_pLogger->attachStream(LogStream::createDefaultStream(aiDefaultLogStream_FILE, name, io));
     }
 
     return m_pLogger;
 }
 
 // ----------------------------------------------------------------------------------
-void Logger::debug(const char* message) {
+void Logger::debug(const char *message) {
 
     // SECURITY FIX: otherwise it's easy to produce overruns since
     // sometimes importers will include data from the input file
     // (i.e. node names) in their messages.
-    if (strlen(message)>MAX_LOG_MESSAGE_LENGTH) {
-        return;
+    if (strlen(message) > MAX_LOG_MESSAGE_LENGTH) {
+        return OnDebug("<fixme: long message discarded>");
     }
     return OnDebug(message);
 }
 
 // ----------------------------------------------------------------------------------
-void Logger::info(const char* message)  {
+void Logger::verboseDebug(const char *message) {
 
     // SECURITY FIX: see above
-    if (strlen(message)>MAX_LOG_MESSAGE_LENGTH) {
-        return;
+    if (strlen(message) > MAX_LOG_MESSAGE_LENGTH) {
+        return OnVerboseDebug("<fixme: long message discarded>");
+    }
+    return OnVerboseDebug(message);
+}
+
+// ----------------------------------------------------------------------------------
+void Logger::info(const char *message) {
+
+    // SECURITY FIX: see above
+    if (strlen(message) > MAX_LOG_MESSAGE_LENGTH) {
+        return OnInfo("<fixme: long message discarded>");
     }
     return OnInfo(message);
 }
 
 // ----------------------------------------------------------------------------------
-void Logger::warn(const char* message)  {
+void Logger::warn(const char *message) {
 
     // SECURITY FIX: see above
-    if (strlen(message)>MAX_LOG_MESSAGE_LENGTH) {
-        return;
+    if (strlen(message) > MAX_LOG_MESSAGE_LENGTH) {
+        return OnWarn("<fixme: long message discarded>");
     }
     return OnWarn(message);
 }
 
 // ----------------------------------------------------------------------------------
-void Logger::error(const char* message) {
+void Logger::error(const char *message) {
     // SECURITY FIX: see above
-    if (strlen(message)>MAX_LOG_MESSAGE_LENGTH) {
-        return;
+    if (strlen(message) > MAX_LOG_MESSAGE_LENGTH) {
+        return OnError("<fixme: long message discarded>");
     }
     return OnError(message);
 }
 
 // ----------------------------------------------------------------------------------
-void DefaultLogger::set( Logger *logger ) {
+void DefaultLogger::set(Logger *logger) {
     // enter the mutex here to avoid concurrency problems
 #ifndef ASSIMP_BUILD_SINGLETHREADED
     std::lock_guard<std::mutex> lock(loggerMutex);
 #endif
 
-    if ( nullptr == logger ) {
+    if (nullptr == logger) {
         logger = &s_pNullLogger;
     }
-    if ( nullptr != m_pLogger && !isNullLogger() ) {
+    if (nullptr != m_pLogger && !isNullLogger()) {
         delete m_pLogger;
     }
 
@@ -241,103 +248,115 @@ void DefaultLogger::kill() {
     std::lock_guard<std::mutex> lock(loggerMutex);
 #endif
 
-	if ( m_pLogger == &s_pNullLogger ) {
-		return;
-	}
+    if (m_pLogger == &s_pNullLogger) {
+        return;
+    }
     delete m_pLogger;
     m_pLogger = &s_pNullLogger;
 }
 
 // ----------------------------------------------------------------------------------
 //  Debug message
-void DefaultLogger::OnDebug( const char* message ) {
-    if ( m_Severity == Logger::NORMAL ) {
+void DefaultLogger::OnDebug(const char *message) {
+    if (m_Severity < Logger::DEBUGGING) {
         return;
     }
 
-	static const size_t Size = MAX_LOG_MESSAGE_LENGTH + 16;
-	char msg[Size];
-	ai_snprintf(msg, Size, "Debug, T%u: %s", GetThreadID(), message);
+    static const size_t Size = MAX_LOG_MESSAGE_LENGTH + 16;
+    char msg[Size];
+    ai_snprintf(msg, Size, "Debug, T%u: %s", GetThreadID(), message);
 
-    WriteToStreams( msg, Logger::Debugging );
+    WriteToStreams(msg, Logger::Debugging);
+}
+
+//  Verbose debug message
+void DefaultLogger::OnVerboseDebug(const char *message) {
+    if (m_Severity < Logger::VERBOSE) {
+        return;
+    }
+
+    static const size_t Size = MAX_LOG_MESSAGE_LENGTH + 16;
+    char msg[Size];
+    ai_snprintf(msg, Size, "Debug, T%u: %s", GetThreadID(), message);
+
+    WriteToStreams(msg, Logger::Debugging);
 }
 
 // ----------------------------------------------------------------------------------
 //  Logs an info
-void DefaultLogger::OnInfo( const char* message ){
-	static const size_t Size = MAX_LOG_MESSAGE_LENGTH + 16;
-	char msg[Size];
-    ai_snprintf(msg, Size, "Info,  T%u: %s", GetThreadID(), message );
+void DefaultLogger::OnInfo(const char *message) {
+    static const size_t Size = MAX_LOG_MESSAGE_LENGTH + 16;
+    char msg[Size];
+    ai_snprintf(msg, Size, "Info,  T%u: %s", GetThreadID(), message);
 
-    WriteToStreams( msg , Logger::Info );
+    WriteToStreams(msg, Logger::Info);
 }
 
 // ----------------------------------------------------------------------------------
 //  Logs a warning
-void DefaultLogger::OnWarn( const char* message ) {
-	static const size_t Size = MAX_LOG_MESSAGE_LENGTH + 16;
-	char msg[Size];
-	ai_snprintf(msg, Size, "Warn,  T%u: %s", GetThreadID(), message );
+void DefaultLogger::OnWarn(const char *message) {
+    static const size_t Size = MAX_LOG_MESSAGE_LENGTH + 16;
+    char msg[Size];
+    ai_snprintf(msg, Size, "Warn,  T%u: %s", GetThreadID(), message);
 
-    WriteToStreams( msg, Logger::Warn );
+    WriteToStreams(msg, Logger::Warn);
 }
 
 // ----------------------------------------------------------------------------------
 //  Logs an error
-void DefaultLogger::OnError( const char* message ) {
-	static const size_t Size = MAX_LOG_MESSAGE_LENGTH + 16;
-	char msg[ Size ];
-    ai_snprintf(msg, Size, "Error, T%u: %s", GetThreadID(), message );
+void DefaultLogger::OnError(const char *message) {
+    static const size_t Size = MAX_LOG_MESSAGE_LENGTH + 16;
+    char msg[Size];
+    ai_snprintf(msg, Size, "Error, T%u: %s", GetThreadID(), message);
 
-    WriteToStreams( msg, Logger::Err );
+    WriteToStreams(msg, Logger::Err);
 }
 
 // ----------------------------------------------------------------------------------
 //  Will attach a new stream
-bool DefaultLogger::attachStream( LogStream *pStream, unsigned int severity ) {
-    if ( nullptr == pStream ) {
+bool DefaultLogger::attachStream(LogStream *pStream, unsigned int severity) {
+    if (nullptr == pStream) {
         return false;
     }
 
-    if (0 == severity)  {
+    if (0 == severity) {
         severity = Logger::Info | Logger::Err | Logger::Warn | Logger::Debugging;
     }
 
-    for ( StreamIt it = m_StreamArray.begin();
-        it != m_StreamArray.end();
-        ++it )
-    {
-        if ( (*it)->m_pStream == pStream ) {
+    for (StreamIt it = m_StreamArray.begin();
+            it != m_StreamArray.end();
+            ++it) {
+        if ((*it)->m_pStream == pStream) {
             (*it)->m_uiErrorSeverity |= severity;
             return true;
         }
     }
 
-    LogStreamInfo *pInfo = new LogStreamInfo( severity, pStream );
-    m_StreamArray.push_back( pInfo );
+    LogStreamInfo *pInfo = new LogStreamInfo(severity, pStream);
+    m_StreamArray.push_back(pInfo);
     return true;
 }
 
 // ----------------------------------------------------------------------------------
 //  Detach a stream
-bool DefaultLogger::detatchStream( LogStream *pStream, unsigned int severity ) {
-    if ( nullptr == pStream ) {
+bool DefaultLogger::detachStream(LogStream *pStream, unsigned int severity) {
+    if (nullptr == pStream) {
         return false;
     }
 
-    if (0 == severity)  {
+    if (0 == severity) {
         severity = SeverityAll;
     }
 
-    bool res( false );
-    for ( StreamIt it = m_StreamArray.begin(); it != m_StreamArray.end(); ++it ) {
-        if ( (*it)->m_pStream == pStream ) {
+    bool res(false);
+    for (StreamIt it = m_StreamArray.begin(); it != m_StreamArray.end(); ++it) {
+        if ((*it)->m_pStream == pStream) {
             (*it)->m_uiErrorSeverity &= ~severity;
-            if ( (*it)->m_uiErrorSeverity == 0 ) {
+            if ((*it)->m_uiErrorSeverity == 0) {
                 // don't delete the underlying stream 'cause the caller gains ownership again
                 (**it).m_pStream = nullptr;
                 delete *it;
-                m_StreamArray.erase( it );
+                m_StreamArray.erase(it);
                 res = true;
                 break;
             }
@@ -349,17 +368,15 @@ bool DefaultLogger::detatchStream( LogStream *pStream, unsigned int severity ) {
 
 // ----------------------------------------------------------------------------------
 //  Constructor
-DefaultLogger::DefaultLogger(LogSeverity severity)
-    :   Logger  ( severity )
-    ,   noRepeatMsg (false)
-    ,   lastLen( 0 ) {
+DefaultLogger::DefaultLogger(LogSeverity severity) :
+        Logger(severity), noRepeatMsg(false), lastLen(0) {
     lastMsg[0] = '\0';
 }
 
 // ----------------------------------------------------------------------------------
 //  Destructor
 DefaultLogger::~DefaultLogger() {
-    for ( StreamIt it = m_StreamArray.begin(); it != m_StreamArray.end(); ++it ) {
+    for (StreamIt it = m_StreamArray.begin(); it != m_StreamArray.end(); ++it) {
         // also frees the underlying stream, we are its owner.
         delete *it;
     }
@@ -367,43 +384,38 @@ DefaultLogger::~DefaultLogger() {
 
 // ----------------------------------------------------------------------------------
 //  Writes message to stream
-void DefaultLogger::WriteToStreams(const char *message, ErrorSeverity ErrorSev ) {
+void DefaultLogger::WriteToStreams(const char *message, ErrorSeverity ErrorSev) {
     ai_assert(nullptr != message);
 
     // Check whether this is a repeated message
-    if (! ::strncmp( message,lastMsg, lastLen-1))
-    {
-        if (!noRepeatMsg)
-        {
+    auto thisLen = ::strlen(message);
+    if (thisLen == lastLen - 1 && !::strncmp(message, lastMsg, lastLen - 1)) {
+        if (!noRepeatMsg) {
             noRepeatMsg = true;
             message = "Skipping one or more lines with the same contents\n";
         }
-        else return;
-    }
-    else
-    {
+        return;
+    } else {
         // append a new-line character to the message to be printed
-        lastLen = ::strlen(message);
-        ::memcpy(lastMsg,message,lastLen+1);
-        ::strcat(lastMsg+lastLen,"\n");
+        lastLen = thisLen;
+        ::memcpy(lastMsg, message, lastLen + 1);
+        ::strcat(lastMsg + lastLen, "\n");
 
         message = lastMsg;
         noRepeatMsg = false;
         ++lastLen;
     }
-    for ( ConstStreamIt it = m_StreamArray.begin();
-        it != m_StreamArray.end();
-        ++it)
-    {
-        if ( ErrorSev & (*it)->m_uiErrorSeverity )
-            (*it)->m_pStream->write( message);
+    for (ConstStreamIt it = m_StreamArray.begin();
+            it != m_StreamArray.end();
+            ++it) {
+        if (ErrorSev & (*it)->m_uiErrorSeverity)
+            (*it)->m_pStream->write(message);
     }
 }
 
 // ----------------------------------------------------------------------------------
 //  Returns thread id, if not supported only a zero will be returned.
-unsigned int DefaultLogger::GetThreadID()
-{
+unsigned int DefaultLogger::GetThreadID() {
     // fixme: we can get this value via std::threads
     // std::this_thread::get_id().hash() returns a (big) size_t, not sure if this is useful in this case.
 #ifdef WIN32
@@ -415,4 +427,4 @@ unsigned int DefaultLogger::GetThreadID()
 
 // ----------------------------------------------------------------------------------
 
-} // !namespace Assimp
+} // namespace Assimp
diff --git a/Engine/lib/assimp/code/Common/DefaultProgressHandler.h b/Engine/lib/assimp/code/Common/DefaultProgressHandler.h
index bd2cce00b..ac1bb68db 100644
--- a/Engine/lib/assimp/code/Common/DefaultProgressHandler.h
+++ b/Engine/lib/assimp/code/Common/DefaultProgressHandler.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -48,18 +47,20 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <assimp/ProgressHandler.hpp>
 
-namespace Assimp    {
+namespace Assimp {
 
 // ------------------------------------------------------------------------------------
-/** @brief Internal default implementation of the #ProgressHandler interface. */
+/**
+ *  @brief Internal default implementation of the #ProgressHandler interface.
+ */
 class DefaultProgressHandler : public ProgressHandler    {
-
-    virtual bool Update(float /*percentage*/) {
+public:
+    ///	@brief Ignores the update callback.
+    bool Update(float) override {
         return false;
     }
+};
 
-
-}; // !class DefaultProgressHandler
 } // Namespace Assimp
 
-#endif
+#endif // INCLUDED_AI_DEFAULTPROGRESSHANDLER_H
diff --git a/Engine/lib/assimp/include/assimp/Macros.h b/Engine/lib/assimp/code/Common/Exceptional.cpp
similarity index 86%
rename from Engine/lib/assimp/include/assimp/Macros.h
rename to Engine/lib/assimp/code/Common/Exceptional.cpp
index 651530337..b25281a97 100644
--- a/Engine/lib/assimp/include/assimp/Macros.h
+++ b/Engine/lib/assimp/code/Common/Exceptional.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -39,11 +39,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
 
-/* Helper macro to set a pointer to NULL in debug builds
- */
-#if (defined ASSIMP_BUILD_DEBUG)
-#   define AI_DEBUG_INVALIDATE_PTR(x) x = NULL;
-#else
-#   define AI_DEBUG_INVALIDATE_PTR(x)
-#endif
+/** @file Exceptional.cpp
 
+Implementations of the exception classes.
+
+*/
+
+#include <assimp/Exceptional.h>
+#include <assimp/TinyFormatter.h>
+
+DeadlyErrorBase::DeadlyErrorBase(Assimp::Formatter::format f) :
+        runtime_error(std::string(f)){}
diff --git a/Engine/lib/assimp/code/Common/Exporter.cpp b/Engine/lib/assimp/code/Common/Exporter.cpp
index 34d49c472..9a4e2cf3d 100644
--- a/Engine/lib/assimp/code/Common/Exporter.cpp
+++ b/Engine/lib/assimp/code/Common/Exporter.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -76,120 +74,164 @@ Here we implement only the C++ interface (Assimp::Exporter).
 
 namespace Assimp {
 
+#ifdef _MSC_VER
+#    pragma warning( disable : 4800 )
+#endif // _MSC_VER
+
+
 // PostStepRegistry.cpp
 void GetPostProcessingStepInstanceList(std::vector< BaseProcess* >& out);
 
 // ------------------------------------------------------------------------------------------------
-// Exporter worker function prototypes. Should not be necessary to #ifndef them, it's just a prototype
-// do not use const, because some exporter need to convert the scene temporary
+// Exporter worker function prototypes. Do not use const, because some exporter need to convert
+// the scene temporary
+#ifndef ASSIMP_BUILD_NO_COLLADA_EXPORTER
 void ExportSceneCollada(const char*,IOSystem*, const aiScene*, const ExportProperties*);
+#endif
+#ifndef ASSIMP_BUILD_NO_X_EXPORTER
 void ExportSceneXFile(const char*,IOSystem*, const aiScene*, const ExportProperties*);
+#endif
+#ifndef ASSIMP_BUILD_NO_STEP_EXPORTER
 void ExportSceneStep(const char*,IOSystem*, const aiScene*, const ExportProperties*);
+#endif
+#ifndef ASSIMP_BUILD_NO_OBJ_EXPORTER
 void ExportSceneObj(const char*,IOSystem*, const aiScene*, const ExportProperties*);
 void ExportSceneObjNoMtl(const char*,IOSystem*, const aiScene*, const ExportProperties*);
+#endif
+#ifndef ASSIMP_BUILD_NO_STL_EXPORTER
 void ExportSceneSTL(const char*,IOSystem*, const aiScene*, const ExportProperties*);
 void ExportSceneSTLBinary(const char*,IOSystem*, const aiScene*, const ExportProperties*);
+#endif
+#ifndef ASSIMP_BUILD_NO_PLY_EXPORTER
 void ExportScenePly(const char*,IOSystem*, const aiScene*, const ExportProperties*);
 void ExportScenePlyBinary(const char*, IOSystem*, const aiScene*, const ExportProperties*);
+#endif
+#ifndef ASSIMP_BUILD_NO_3DS_EXPORTER
 void ExportScene3DS(const char*, IOSystem*, const aiScene*, const ExportProperties*);
+#endif
+#ifndef ASSIMP_BUILD_NO_GLTF_EXPORTER
 void ExportSceneGLTF(const char*, IOSystem*, const aiScene*, const ExportProperties*);
 void ExportSceneGLB(const char*, IOSystem*, const aiScene*, const ExportProperties*);
 void ExportSceneGLTF2(const char*, IOSystem*, const aiScene*, const ExportProperties*);
 void ExportSceneGLB2(const char*, IOSystem*, const aiScene*, const ExportProperties*);
+#endif
+#ifndef ASSIMP_BUILD_NO_ASSBIN_EXPORTER
 void ExportSceneAssbin(const char*, IOSystem*, const aiScene*, const ExportProperties*);
+#endif
+#ifndef ASSIMP_BUILD_NO_ASSXML_EXPORTER
 void ExportSceneAssxml(const char*, IOSystem*, const aiScene*, const ExportProperties*);
+#endif
+#ifndef ASSIMP_BUILD_NO_X3D_EXPORTER
 void ExportSceneX3D(const char*, IOSystem*, const aiScene*, const ExportProperties*);
+#endif
+#ifndef ASSIMP_BUILD_NO_FBX_EXPORTER
 void ExportSceneFBX(const char*, IOSystem*, const aiScene*, const ExportProperties*);
 void ExportSceneFBXA(const char*, IOSystem*, const aiScene*, const ExportProperties*);
+#endif
+#ifndef ASSIMP_BUILD_NO_3MF_EXPORTER
 void ExportScene3MF( const char*, IOSystem*, const aiScene*, const ExportProperties* );
+#endif
+#ifndef ASSIMP_BUILD_NO_M3D_EXPORTER
+void ExportSceneM3D(const char*, IOSystem*, const aiScene*, const ExportProperties*);
+void ExportSceneM3DA(const char*, IOSystem*, const aiScene*, const ExportProperties*);
+#endif
+#ifndef ASSIMP_BUILD_NO_ASSJSON_EXPORTER
 void ExportAssimp2Json(const char* , IOSystem*, const aiScene* , const Assimp::ExportProperties*);
+#endif
+#ifndef ASSIMP_BUILD_NO_PBRT_EXPORTER
+void ExportScenePbrt(const char*, IOSystem*, const aiScene*, const ExportProperties*);
+#endif
+
+static void setupExporterArray(std::vector<Exporter::ExportFormatEntry> &exporters) {
+	(void)exporters;
 
-// ------------------------------------------------------------------------------------------------
-// global array of all export formats which Assimp supports in its current build
-Exporter::ExportFormatEntry gExporters[] =
-{
 #ifndef ASSIMP_BUILD_NO_COLLADA_EXPORTER
-    Exporter::ExportFormatEntry( "collada", "COLLADA - Digital Asset Exchange Schema", "dae", &ExportSceneCollada ),
+	exporters.push_back(Exporter::ExportFormatEntry("collada", "COLLADA - Digital Asset Exchange Schema", "dae", &ExportSceneCollada));
 #endif
 
 #ifndef ASSIMP_BUILD_NO_X_EXPORTER
-    Exporter::ExportFormatEntry( "x", "X Files", "x", &ExportSceneXFile,
-        aiProcess_MakeLeftHanded | aiProcess_FlipWindingOrder | aiProcess_FlipUVs ),
+	exporters.push_back(Exporter::ExportFormatEntry("x", "X Files", "x", &ExportSceneXFile,
+			aiProcess_MakeLeftHanded | aiProcess_FlipWindingOrder | aiProcess_FlipUVs));
 #endif
 
 #ifndef ASSIMP_BUILD_NO_STEP_EXPORTER
-    Exporter::ExportFormatEntry( "stp", "Step Files", "stp", &ExportSceneStep, 0 ),
+	exporters.push_back(Exporter::ExportFormatEntry("stp", "Step Files", "stp", &ExportSceneStep, 0));
 #endif
 
 #ifndef ASSIMP_BUILD_NO_OBJ_EXPORTER
-    Exporter::ExportFormatEntry( "obj", "Wavefront OBJ format", "obj", &ExportSceneObj,
-        aiProcess_GenSmoothNormals /*| aiProcess_PreTransformVertices */ ),
-    Exporter::ExportFormatEntry( "objnomtl", "Wavefront OBJ format without material file", "obj", &ExportSceneObjNoMtl,
-        aiProcess_GenSmoothNormals /*| aiProcess_PreTransformVertices */ ),
+	exporters.push_back(Exporter::ExportFormatEntry("obj", "Wavefront OBJ format", "obj", &ExportSceneObj,
+			aiProcess_GenSmoothNormals /*| aiProcess_PreTransformVertices */));
+	exporters.push_back(Exporter::ExportFormatEntry("objnomtl", "Wavefront OBJ format without material file", "obj", &ExportSceneObjNoMtl,
+			aiProcess_GenSmoothNormals /*| aiProcess_PreTransformVertices */));
 #endif
 
 #ifndef ASSIMP_BUILD_NO_STL_EXPORTER
-    Exporter::ExportFormatEntry( "stl", "Stereolithography", "stl" , &ExportSceneSTL,
-        aiProcess_Triangulate | aiProcess_GenNormals | aiProcess_PreTransformVertices
-    ),
-    Exporter::ExportFormatEntry( "stlb", "Stereolithography (binary)", "stl" , &ExportSceneSTLBinary,
-        aiProcess_Triangulate | aiProcess_GenNormals | aiProcess_PreTransformVertices
-    ),
+	exporters.push_back(Exporter::ExportFormatEntry("stl", "Stereolithography", "stl", &ExportSceneSTL,
+			aiProcess_Triangulate | aiProcess_GenNormals | aiProcess_PreTransformVertices));
+	exporters.push_back(Exporter::ExportFormatEntry("stlb", "Stereolithography (binary)", "stl", &ExportSceneSTLBinary,
+			aiProcess_Triangulate | aiProcess_GenNormals | aiProcess_PreTransformVertices));
 #endif
 
 #ifndef ASSIMP_BUILD_NO_PLY_EXPORTER
-    Exporter::ExportFormatEntry( "ply", "Stanford Polygon Library", "ply" , &ExportScenePly,
-        aiProcess_PreTransformVertices
-    ),
-    Exporter::ExportFormatEntry( "plyb", "Stanford Polygon Library (binary)", "ply", &ExportScenePlyBinary,
-        aiProcess_PreTransformVertices
-    ),
+	exporters.push_back(Exporter::ExportFormatEntry("ply", "Stanford Polygon Library", "ply", &ExportScenePly,
+			aiProcess_PreTransformVertices));
+	exporters.push_back(Exporter::ExportFormatEntry("plyb", "Stanford Polygon Library (binary)", "ply", &ExportScenePlyBinary,
+			aiProcess_PreTransformVertices));
 #endif
 
 #ifndef ASSIMP_BUILD_NO_3DS_EXPORTER
-    Exporter::ExportFormatEntry( "3ds", "Autodesk 3DS (legacy)", "3ds" , &ExportScene3DS,
-        aiProcess_Triangulate | aiProcess_SortByPType | aiProcess_JoinIdenticalVertices ),
+	exporters.push_back(Exporter::ExportFormatEntry("3ds", "Autodesk 3DS (legacy)", "3ds", &ExportScene3DS,
+			aiProcess_Triangulate | aiProcess_SortByPType | aiProcess_JoinIdenticalVertices));
 #endif
 
-#ifndef ASSIMP_BUILD_NO_GLTF_EXPORTER
-    Exporter::ExportFormatEntry( "gltf2", "GL Transmission Format v. 2", "gltf", &ExportSceneGLTF2,
-        aiProcess_JoinIdenticalVertices | aiProcess_Triangulate | aiProcess_SortByPType ),
-    Exporter::ExportFormatEntry( "glb2", "GL Transmission Format v. 2 (binary)", "glb", &ExportSceneGLB2,
-        aiProcess_JoinIdenticalVertices | aiProcess_Triangulate | aiProcess_SortByPType ),
-    Exporter::ExportFormatEntry( "gltf", "GL Transmission Format", "gltf", &ExportSceneGLTF,
-        aiProcess_JoinIdenticalVertices | aiProcess_Triangulate | aiProcess_SortByPType ),
-    Exporter::ExportFormatEntry( "glb", "GL Transmission Format (binary)", "glb", &ExportSceneGLB,
-        aiProcess_JoinIdenticalVertices | aiProcess_Triangulate | aiProcess_SortByPType ),
+#if !defined(ASSIMP_BUILD_NO_GLTF_EXPORTER) && !defined(ASSIMP_BUILD_NO_GLTF2_EXPORTER)
+	exporters.push_back(Exporter::ExportFormatEntry("gltf2", "GL Transmission Format v. 2", "gltf", &ExportSceneGLTF2,
+			aiProcess_JoinIdenticalVertices | aiProcess_Triangulate | aiProcess_SortByPType));
+	exporters.push_back(Exporter::ExportFormatEntry("glb2", "GL Transmission Format v. 2 (binary)", "glb", &ExportSceneGLB2,
+			aiProcess_JoinIdenticalVertices | aiProcess_Triangulate | aiProcess_SortByPType));
+#endif
+
+#if !defined(ASSIMP_BUILD_NO_GLTF_EXPORTER) && !defined(ASSIMP_BUILD_NO_GLTF1_EXPORTER)
+	exporters.push_back(Exporter::ExportFormatEntry("gltf", "GL Transmission Format", "gltf", &ExportSceneGLTF,
+			aiProcess_JoinIdenticalVertices | aiProcess_Triangulate | aiProcess_SortByPType));
+	exporters.push_back(Exporter::ExportFormatEntry("glb", "GL Transmission Format (binary)", "glb", &ExportSceneGLB,
+			aiProcess_JoinIdenticalVertices | aiProcess_Triangulate | aiProcess_SortByPType));
 #endif
 
 #ifndef ASSIMP_BUILD_NO_ASSBIN_EXPORTER
-    Exporter::ExportFormatEntry( "assbin", "Assimp Binary File", "assbin" , &ExportSceneAssbin, 0 ),
+	exporters.push_back(Exporter::ExportFormatEntry("assbin", "Assimp Binary File", "assbin", &ExportSceneAssbin, 0));
 #endif
 
 #ifndef ASSIMP_BUILD_NO_ASSXML_EXPORTER
-    Exporter::ExportFormatEntry( "assxml", "Assimp XML Document", "assxml" , &ExportSceneAssxml, 0 ),
+	exporters.push_back(Exporter::ExportFormatEntry("assxml", "Assimp XML Document", "assxml", &ExportSceneAssxml, 0));
 #endif
 
 #ifndef ASSIMP_BUILD_NO_X3D_EXPORTER
-    Exporter::ExportFormatEntry( "x3d", "Extensible 3D", "x3d" , &ExportSceneX3D, 0 ),
+	exporters.push_back(Exporter::ExportFormatEntry("x3d", "Extensible 3D", "x3d", &ExportSceneX3D, 0));
 #endif
 
 #ifndef ASSIMP_BUILD_NO_FBX_EXPORTER
-    Exporter::ExportFormatEntry( "fbx", "Autodesk FBX (binary)", "fbx", &ExportSceneFBX, 0 ),
-    Exporter::ExportFormatEntry( "fbxa", "Autodesk FBX (ascii)", "fbx", &ExportSceneFBXA, 0 ),
+	exporters.push_back(Exporter::ExportFormatEntry("fbx", "Autodesk FBX (binary)", "fbx", &ExportSceneFBX, 0));
+	exporters.push_back(Exporter::ExportFormatEntry("fbxa", "Autodesk FBX (ascii)", "fbx", &ExportSceneFBXA, 0));
+#endif
+
+#ifndef ASSIMP_BUILD_NO_M3D_EXPORTER
+	exporters.push_back(Exporter::ExportFormatEntry("m3d", "Model 3D (binary)", "m3d", &ExportSceneM3D, 0));
+	exporters.push_back(Exporter::ExportFormatEntry("m3da", "Model 3D (ascii)", "a3d", &ExportSceneM3DA, 0));
 #endif
 
 #ifndef ASSIMP_BUILD_NO_3MF_EXPORTER
-    Exporter::ExportFormatEntry( "3mf", "The 3MF-File-Format", "3mf", &ExportScene3MF, 0 ),
+	exporters.push_back(Exporter::ExportFormatEntry("3mf", "The 3MF-File-Format", "3mf", &ExportScene3MF, 0));
+#endif
+
+#ifndef ASSIMP_BUILD_NO_PBRT_EXPORTER
+	exporters.push_back(Exporter::ExportFormatEntry("pbrt", "pbrt-v4 scene description file", "pbrt", &ExportScenePbrt, aiProcess_Triangulate | aiProcess_SortByPType));
 #endif
 
 #ifndef ASSIMP_BUILD_NO_ASSJSON_EXPORTER
-    Exporter::ExportFormatEntry( "assjson", "Assimp JSON Document", "json", &ExportAssimp2Json, 0)
+	exporters.push_back(Exporter::ExportFormatEntry("assjson", "Assimp JSON Document", "json", &ExportAssimp2Json, 0));
 #endif
-};
-
-#define ASSIMP_NUM_EXPORTERS (sizeof(gExporters)/sizeof(gExporters[0]))
-
+}
 
 class ExporterPimpl {
 public:
@@ -205,10 +247,7 @@ public:
         GetPostProcessingStepInstanceList(mPostProcessingSteps);
 
         // grab all built-in exporters
-        if ( 0 != ( ASSIMP_NUM_EXPORTERS ) ) {
-            mExporters.resize( ASSIMP_NUM_EXPORTERS );
-            std::copy( gExporters, gExporters + ASSIMP_NUM_EXPORTERS, mExporters.begin() );
-        }
+		setupExporterArray(mExporters);
     }
 
     ~ExporterPimpl() {
@@ -252,24 +291,28 @@ Exporter :: Exporter()
 
 // ------------------------------------------------------------------------------------------------
 Exporter::~Exporter() {
-    FreeBlob();
+	ai_assert(nullptr != pimpl);
+	FreeBlob();
     delete pimpl;
 }
 
 // ------------------------------------------------------------------------------------------------
 void Exporter::SetIOHandler( IOSystem* pIOHandler) {
-    pimpl->mIsDefaultIOHandler = !pIOHandler;
+	ai_assert(nullptr != pimpl);
+	pimpl->mIsDefaultIOHandler = !pIOHandler;
     pimpl->mIOSystem.reset(pIOHandler);
 }
 
 // ------------------------------------------------------------------------------------------------
 IOSystem* Exporter::GetIOHandler() const {
-    return pimpl->mIOSystem.get();
+	ai_assert(nullptr != pimpl);
+	return pimpl->mIOSystem.get();
 }
 
 // ------------------------------------------------------------------------------------------------
 bool Exporter::IsDefaultIOHandler() const {
-    return pimpl->mIsDefaultIOHandler;
+	ai_assert(nullptr != pimpl);
+	return pimpl->mIsDefaultIOHandler;
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -295,13 +338,16 @@ void Exporter::SetProgressHandler(ProgressHandler* pHandler) {
 // ------------------------------------------------------------------------------------------------
 const aiExportDataBlob* Exporter::ExportToBlob( const aiScene* pScene, const char* pFormatId,
                                                 unsigned int pPreprocessing, const ExportProperties* pProperties) {
+	ai_assert(nullptr != pimpl);
     if (pimpl->blob) {
         delete pimpl->blob;
         pimpl->blob = nullptr;
     }
 
+    auto baseName = pProperties ? pProperties->GetPropertyString(AI_CONFIG_EXPORT_BLOB_NAME, AI_BLOBIO_MAGIC) : AI_BLOBIO_MAGIC;
+
     std::shared_ptr<IOSystem> old = pimpl->mIOSystem;
-    BlobIOSystem* blobio = new BlobIOSystem();
+    BlobIOSystem *blobio = new BlobIOSystem(baseName);
     pimpl->mIOSystem = std::shared_ptr<IOSystem>( blobio );
 
     if (AI_SUCCESS != Export(pScene,pFormatId,blobio->GetMagicFileName(), pPreprocessing, pProperties)) {
@@ -319,7 +365,7 @@ const aiExportDataBlob* Exporter::ExportToBlob( const aiScene* pScene, const cha
 aiReturn Exporter::Export( const aiScene* pScene, const char* pFormatId, const char* pPath,
         unsigned int pPreprocessing, const ExportProperties* pProperties) {
     ASSIMP_BEGIN_EXCEPTION_REGION();
-
+	ai_assert(nullptr != pimpl);
     // when they create scenes from scratch, users will likely create them not in verbose
     // format. They will likely not be aware that there is a flag in the scene to indicate
     // this, however. To avoid surprises and bug reports, we check for duplicates in
@@ -443,10 +489,9 @@ aiReturn Exporter::Export( const aiScene* pScene, const char* pFormatId, const c
                     proc.Execute(scenecopy.get());
                 }
 
-                ExportProperties emptyProperties;  // Never pass NULL ExportProperties so Exporters don't have to worry.
+                ExportProperties emptyProperties;  // Never pass nullptr ExportProperties so Exporters don't have to worry.
                 ExportProperties* pProp = pProperties ? (ExportProperties*)pProperties : &emptyProperties;
-                                pProp->SetPropertyBool("bJoinIdenticalVertices", must_join_again);
-                                exp.mExportFunction(pPath,pimpl->mIOSystem.get(),scenecopy.get(), pProp);
+        		pProp->SetPropertyBool("bJoinIdenticalVertices", pp & aiProcess_JoinIdenticalVertices);
                 exp.mExportFunction(pPath,pimpl->mIOSystem.get(),scenecopy.get(), pProp);
 
                 pimpl->mProgressHandler->UpdateFileWrite(4, 4);
@@ -466,11 +511,13 @@ aiReturn Exporter::Export( const aiScene* pScene, const char* pFormatId, const c
 
 // ------------------------------------------------------------------------------------------------
 const char* Exporter::GetErrorString() const {
+	ai_assert(nullptr != pimpl);
     return pimpl->mError.c_str();
 }
 
 // ------------------------------------------------------------------------------------------------
 void Exporter::FreeBlob() {
+	ai_assert(nullptr != pimpl);
     delete pimpl->blob;
     pimpl->blob = nullptr;
 
@@ -479,30 +526,34 @@ void Exporter::FreeBlob() {
 
 // ------------------------------------------------------------------------------------------------
 const aiExportDataBlob* Exporter::GetBlob() const {
-    return pimpl->blob;
+	ai_assert(nullptr != pimpl);
+	return pimpl->blob;
 }
 
 // ------------------------------------------------------------------------------------------------
 const aiExportDataBlob* Exporter::GetOrphanedBlob() const {
-    const aiExportDataBlob* tmp = pimpl->blob;
+	ai_assert(nullptr != pimpl);
+	const aiExportDataBlob *tmp = pimpl->blob;
     pimpl->blob = nullptr;
     return tmp;
 }
 
 // ------------------------------------------------------------------------------------------------
 size_t Exporter::GetExportFormatCount() const {
+	ai_assert(nullptr != pimpl);
     return pimpl->mExporters.size();
 }
 
 // ------------------------------------------------------------------------------------------------
 const aiExportFormatDesc* Exporter::GetExportFormatDescription( size_t index ) const {
-    if (index >= GetExportFormatCount()) {
+	ai_assert(nullptr != pimpl);
+	if (index >= GetExportFormatCount()) {
         return nullptr;
     }
 
     // Return from static storage if the requested index is built-in.
-    if (index < sizeof(gExporters) / sizeof(gExporters[0])) {
-        return &gExporters[index].mDescription;
+	if (index < pimpl->mExporters.size()) {
+		return &pimpl->mExporters[index].mDescription;
     }
 
     return &pimpl->mExporters[index].mDescription;
@@ -510,7 +561,8 @@ const aiExportFormatDesc* Exporter::GetExportFormatDescription( size_t index ) c
 
 // ------------------------------------------------------------------------------------------------
 aiReturn Exporter::RegisterExporter(const ExportFormatEntry& desc) {
-    for(const ExportFormatEntry& e : pimpl->mExporters) {
+	ai_assert(nullptr != pimpl);
+	for (const ExportFormatEntry &e : pimpl->mExporters) {
         if (!strcmp(e.mDescription.id,desc.mDescription.id)) {
             return aiReturn_FAILURE;
         }
@@ -522,7 +574,8 @@ aiReturn Exporter::RegisterExporter(const ExportFormatEntry& desc) {
 
 // ------------------------------------------------------------------------------------------------
 void Exporter::UnregisterExporter(const char* id) {
-    for(std::vector<ExportFormatEntry>::iterator it = pimpl->mExporters.begin();
+	ai_assert(nullptr != pimpl);
+	for (std::vector<ExportFormatEntry>::iterator it = pimpl->mExporters.begin();
             it != pimpl->mExporters.end(); ++it) {
         if (!strcmp((*it).mDescription.id,id)) {
             pimpl->mExporters.erase(it);
@@ -541,10 +594,23 @@ ExportProperties::ExportProperties(const ExportProperties &other)
 : mIntProperties(other.mIntProperties)
 , mFloatProperties(other.mFloatProperties)
 , mStringProperties(other.mStringProperties)
-, mMatrixProperties(other.mMatrixProperties) {
+, mMatrixProperties(other.mMatrixProperties)
+, mCallbackProperties(other.mCallbackProperties){
     // empty
 }
 
+bool ExportProperties::SetPropertyCallback(const char *szName, const std::function<void *(void *)> &f) {
+    return SetGenericProperty<std::function<void *(void *)>>(mCallbackProperties, szName, f);
+}
+
+std::function<void *(void *)> ExportProperties::GetPropertyCallback(const char *szName) const {
+    return GetGenericProperty<std::function<void *(void *)>>(mCallbackProperties, szName, 0);
+}
+
+bool ExportProperties::HasPropertyCallback(const char *szName) const {
+    return HasGenericProperty<std::function<void *(void *)>>(mCallbackProperties, szName);
+}
+
 // ------------------------------------------------------------------------------------------------
 // Set a configuration property
 bool ExportProperties::SetPropertyInteger(const char* szName, int iValue) {
diff --git a/Engine/lib/assimp/code/Common/FileLogStream.h b/Engine/lib/assimp/code/Common/FileLogStream.h
index 740c50319..334541485 100644
--- a/Engine/lib/assimp/code/Common/FileLogStream.h
+++ b/Engine/lib/assimp/code/Common/FileLogStream.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,23 +43,21 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_FILELOGSTREAM_H_INC
 #define ASSIMP_FILELOGSTREAM_H_INC
 
-#include <assimp/LogStream.hpp>
-#include <assimp/IOStream.hpp>
 #include <assimp/DefaultIOSystem.h>
+#include <assimp/IOStream.hpp>
+#include <assimp/LogStream.hpp>
 
-namespace Assimp    {
+namespace Assimp {
 
 // ----------------------------------------------------------------------------------
 /** @class  FileLogStream
  *  @brief  Logstream to write into a file.
  */
-class FileLogStream :
-    public LogStream
-{
+class FileLogStream : public LogStream {
 public:
-    FileLogStream( const char* file, IOSystem* io = NULL );
+    FileLogStream(const char *file, IOSystem *io = nullptr);
     ~FileLogStream();
-    void write( const char* message );
+    void write(const char *message);
 
 private:
     IOStream *m_pStream;
@@ -67,41 +65,36 @@ private:
 
 // ----------------------------------------------------------------------------------
 //  Constructor
-inline FileLogStream::FileLogStream( const char* file, IOSystem* io ) :
-    m_pStream(NULL)
-{
-    if ( !file || 0 == *file )
+inline FileLogStream::FileLogStream(const char *file, IOSystem *io) :
+        m_pStream(nullptr) {
+    if (!file || 0 == *file)
         return;
 
     // If no IOSystem is specified: take a default one
-    if (!io)
-    {
+    if (!io) {
         DefaultIOSystem FileSystem;
-        m_pStream = FileSystem.Open( file, "wt");
-    }
-    else m_pStream = io->Open( file, "wt" );
+        m_pStream = FileSystem.Open(file, "wt");
+    } else
+        m_pStream = io->Open(file, "wt");
 }
 
 // ----------------------------------------------------------------------------------
 //  Destructor
-inline FileLogStream::~FileLogStream()
-{
+inline FileLogStream::~FileLogStream() {
     // The virtual d'tor should destroy the underlying file
     delete m_pStream;
 }
 
 // ----------------------------------------------------------------------------------
 //  Write method
-inline void FileLogStream::write( const char* message )
-{
-    if (m_pStream != NULL)
-    {
+inline void FileLogStream::write(const char *message) {
+    if (m_pStream != nullptr) {
         m_pStream->Write(message, sizeof(char), ::strlen(message));
         m_pStream->Flush();
     }
 }
 
 // ----------------------------------------------------------------------------------
-} // !Namespace Assimp
+} // namespace Assimp
 
 #endif // !! ASSIMP_FILELOGSTREAM_H_INC
diff --git a/Engine/lib/assimp/code/Common/FileSystemFilter.h b/Engine/lib/assimp/code/Common/FileSystemFilter.h
index 9923cdbdd..81576aa6c 100644
--- a/Engine/lib/assimp/code/Common/FileSystemFilter.h
+++ b/Engine/lib/assimp/code/Common/FileSystemFilter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2008, assimp team
+Copyright (c) 2006-2020, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -76,7 +76,7 @@ public:
         if (std::string::npos != (ss2 = mBase.find_last_of("\\/")))  {
             mBase.erase(ss2,mBase.length()-ss2);
         } else {
-            mBase = "";
+            mBase = std::string();
         }
 
         // make sure the directory is terminated properly
@@ -89,7 +89,7 @@ public:
             mBase += getOsSeparator();
         }
 
-        DefaultLogger::get()->info("Import root directory is \'" + mBase + "\'");
+        DefaultLogger::get()->info("Import root directory is \'", mBase, "\'");
     }
 
     /** Destructor. */
@@ -101,7 +101,7 @@ public:
     /** Tests for the existence of a file at the given path. */
     bool Exists( const char* pFile) const {
         ai_assert( nullptr != mWrapped );
-        
+
         std::string tmp = pFile;
 
         // Currently this IOSystem is also used to open THE ONE FILE.
@@ -126,7 +126,7 @@ public:
         if ( nullptr == pFile || nullptr == pMode ) {
             return nullptr;
         }
-        
+
         ai_assert( nullptr != pFile );
         ai_assert( nullptr != pMode );
 
@@ -300,13 +300,14 @@ private:
 
         const char separator = getOsSeparator();
         for (it = in.begin(); it != in.end(); ++it) {
+            int remaining = std::distance(in.end(), it);
             // Exclude :// and \\, which remain untouched.
             // https://sourceforge.net/tracker/?func=detail&aid=3031725&group_id=226462&atid=1067632
-            if ( !strncmp(&*it, "://", 3 )) {
+            if (remaining >= 3 && !strncmp(&*it, "://", 3 )) {
                 it += 3;
                 continue;
             }
-            if (it == in.begin() && !strncmp(&*it, "\\\\", 2)) {
+            if (it == in.begin() && remaining >= 2 && !strncmp(&*it, "\\\\", 2)) {
                 it += 2;
                 continue;
             }
diff --git a/Engine/lib/assimp/code/Common/IFF.h b/Engine/lib/assimp/code/Common/IFF.h
index 91d7d4828..cf07f9833 100644
--- a/Engine/lib/assimp/code/Common/IFF.h
+++ b/Engine/lib/assimp/code/Common/IFF.h
@@ -35,6 +35,17 @@ struct SubChunkHeader
     uint16_t length;
 };
 
+/////////////////////////////////////////////////////////////////////////////////
+//! Describes an IFF form header
+/////////////////////////////////////////////////////////////////////////////////
+struct FormHeader
+{
+    //! Length of the chunk data, in bytes
+    uint32_t length;
+
+    //! Type of the chunk header - FourCC
+    uint32_t type;
+};
 
 #define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \
     ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d)))
@@ -77,6 +88,24 @@ inline SubChunkHeader LoadSubChunk(uint8_t*& outFile)
     return head;
 }
 
+/////////////////////////////////////////////////////////////////////////////////
+//! Load a chunk header
+//! @param outFile Pointer to the file data - points to the chunk data afterwards
+//! @return Copy of the chunk header
+/////////////////////////////////////////////////////////////////////////////////
+inline ChunkHeader LoadForm(uint8_t*& outFile)
+{
+    ChunkHeader head;
+    outFile += 4;
+    ::memcpy(&head.length, outFile, 4);
+    outFile += 4;
+    ::memcpy(&head.type, outFile, 4);
+
+    AI_LSWAP4(head.length);
+    AI_LSWAP4(head.type);
+    return head;
+}
+
 /////////////////////////////////////////////////////////////////////////////////
 //! Read the file header and return the type of the file and its size
 //! @param outFile Pointer to the file data. The buffer must at
diff --git a/Engine/lib/assimp/code/Common/IOSystem.cpp b/Engine/lib/assimp/code/Common/IOSystem.cpp
new file mode 100644
index 000000000..1e63827ba
--- /dev/null
+++ b/Engine/lib/assimp/code/Common/IOSystem.cpp
@@ -0,0 +1,53 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+/** @file Default implementation of IOSystem using the standard C file functions */
+
+#include <assimp/IOSystem.hpp>
+
+using namespace Assimp;
+
+const std::string &IOSystem::CurrentDirectory() const {
+    if ( m_pathStack.empty() ) {
+        static const std::string Dummy = std::string();
+        return Dummy;
+    }
+    return m_pathStack[ m_pathStack.size()-1 ];
+}
diff --git a/Engine/lib/assimp/code/Common/Importer.cpp b/Engine/lib/assimp/code/Common/Importer.cpp
index 91b50859a..52b6097e7 100644
--- a/Engine/lib/assimp/code/Common/Importer.cpp
+++ b/Engine/lib/assimp/code/Common/Importer.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -78,6 +76,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/TinyFormatter.h>
 #include <assimp/Exceptional.h>
 #include <assimp/Profiler.h>
+#include <assimp/commonMetaData.h>
+
+#include <exception>
 #include <set>
 #include <memory>
 #include <cctype>
@@ -119,7 +120,7 @@ void* AllocateFromAssimpHeap::operator new ( size_t num_bytes, const std::nothro
         return AllocateFromAssimpHeap::operator new( num_bytes );
     }
     catch( ... )    {
-        return NULL;
+        return nullptr;
     }
 }
 
@@ -134,9 +135,8 @@ void* AllocateFromAssimpHeap::operator new[] ( size_t num_bytes)    {
 void* AllocateFromAssimpHeap::operator new[] ( size_t num_bytes, const std::nothrow_t& ) throw() {
     try {
         return AllocateFromAssimpHeap::operator new[]( num_bytes );
-    }
-    catch( ... )    {
-        return NULL;
+    } catch( ... )    {
+        return nullptr;
     }
 }
 
@@ -148,8 +148,8 @@ void AllocateFromAssimpHeap::operator delete[] ( void* data)    {
 // Importer constructor.
 Importer::Importer()
  : pimpl( new ImporterPimpl ) {
-    pimpl->mScene = NULL;
-    pimpl->mErrorString = "";
+    pimpl->mScene = nullptr;
+    pimpl->mErrorString = std::string();
 
     // Allocate a default IO handler
     pimpl->mIOHandler = new DefaultIOSystem;
@@ -174,14 +174,14 @@ Importer::Importer()
 
 // ------------------------------------------------------------------------------------------------
 // Destructor of Importer
-Importer::~Importer()
-{
+Importer::~Importer() {
     // Delete all import plugins
 	DeleteImporterInstanceList(pimpl->mImporter);
 
     // Delete all post-processing plug-ins
-    for( unsigned int a = 0; a < pimpl->mPostProcessingSteps.size(); a++)
+    for( unsigned int a = 0; a < pimpl->mPostProcessingSteps.size(); ++a ) {
         delete pimpl->mPostProcessingSteps[a];
+    }
 
     // Delete the assigned IO and progress handler
     delete pimpl->mIOHandler;
@@ -199,9 +199,9 @@ Importer::~Importer()
 
 // ------------------------------------------------------------------------------------------------
 // Register a custom post-processing step
-aiReturn Importer::RegisterPPStep(BaseProcess* pImp)
-{
-    ai_assert(NULL != pImp);
+aiReturn Importer::RegisterPPStep(BaseProcess* pImp) {
+    ai_assert( nullptr != pImp );
+
     ASSIMP_BEGIN_EXCEPTION_REGION();
 
         pimpl->mPostProcessingSteps.push_back(pImp);
@@ -213,9 +213,9 @@ aiReturn Importer::RegisterPPStep(BaseProcess* pImp)
 
 // ------------------------------------------------------------------------------------------------
 // Register a custom loader plugin
-aiReturn Importer::RegisterLoader(BaseImporter* pImp)
-{
-    ai_assert(NULL != pImp);
+aiReturn Importer::RegisterLoader(BaseImporter* pImp) {
+    ai_assert(nullptr != pImp);
+
     ASSIMP_BEGIN_EXCEPTION_REGION();
 
     // --------------------------------------------------------------------
@@ -232,7 +232,7 @@ aiReturn Importer::RegisterLoader(BaseImporter* pImp)
 
 #ifdef ASSIMP_BUILD_DEBUG
         if (IsExtensionSupported(*it)) {
-            ASSIMP_LOG_WARN_F("The file extension ", *it, " is already in use");
+            ASSIMP_LOG_WARN("The file extension ", *it, " is already in use");
         }
 #endif
         baked += *it;
@@ -240,17 +240,17 @@ aiReturn Importer::RegisterLoader(BaseImporter* pImp)
 
     // add the loader
     pimpl->mImporter.push_back(pImp);
-    ASSIMP_LOG_INFO_F("Registering custom importer for these file extensions: ", baked);
+    ASSIMP_LOG_INFO("Registering custom importer for these file extensions: ", baked);
     ASSIMP_END_EXCEPTION_REGION(aiReturn);
+
     return AI_SUCCESS;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Unregister a custom loader plugin
-aiReturn Importer::UnregisterLoader(BaseImporter* pImp)
-{
+aiReturn Importer::UnregisterLoader(BaseImporter* pImp) {
     if(!pImp) {
-        // unregistering a NULL importer is no problem for us ... really!
+        // unregistering a nullptr importer is no problem for us ... really!
         return AI_SUCCESS;
     }
 
@@ -265,15 +265,15 @@ aiReturn Importer::UnregisterLoader(BaseImporter* pImp)
     }
     ASSIMP_LOG_WARN("Unable to remove custom importer: I can't find you ...");
     ASSIMP_END_EXCEPTION_REGION(aiReturn);
+
     return AI_FAILURE;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Unregister a custom loader plugin
-aiReturn Importer::UnregisterPPStep(BaseProcess* pImp)
-{
+aiReturn Importer::UnregisterPPStep(BaseProcess* pImp) {
     if(!pImp) {
-        // unregistering a NULL ppstep is no problem for us ... really!
+        // unregistering a nullptr ppstep is no problem for us ... really!
         return AI_SUCCESS;
     }
 
@@ -288,24 +288,22 @@ aiReturn Importer::UnregisterPPStep(BaseProcess* pImp)
     }
     ASSIMP_LOG_WARN("Unable to remove custom post-processing step: I can't find you ..");
     ASSIMP_END_EXCEPTION_REGION(aiReturn);
+
     return AI_FAILURE;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Supplies a custom IO handler to the importer to open and access files.
-void Importer::SetIOHandler( IOSystem* pIOHandler)
-{
+void Importer::SetIOHandler( IOSystem* pIOHandler) {
+    ai_assert(nullptr != pimpl);
+
     ASSIMP_BEGIN_EXCEPTION_REGION();
     // If the new handler is zero, allocate a default IO implementation.
-    if (!pIOHandler)
-    {
+    if (!pIOHandler) {
         // Release pointer in the possession of the caller
         pimpl->mIOHandler = new DefaultIOSystem();
         pimpl->mIsDefaultHandler = true;
-    }
-    // Otherwise register the custom handler
-    else if (pimpl->mIOHandler != pIOHandler)
-    {
+    } else if (pimpl->mIOHandler != pIOHandler) { // Otherwise register the custom handler
         delete pimpl->mIOHandler;
         pimpl->mIOHandler = pIOHandler;
         pimpl->mIsDefaultHandler = false;
@@ -316,29 +314,32 @@ void Importer::SetIOHandler( IOSystem* pIOHandler)
 // ------------------------------------------------------------------------------------------------
 // Get the currently set IO handler
 IOSystem* Importer::GetIOHandler() const {
+    ai_assert(nullptr != pimpl);
+
     return pimpl->mIOHandler;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Check whether a custom IO handler is currently set
 bool Importer::IsDefaultIOHandler() const {
+    ai_assert(nullptr != pimpl);
+
     return pimpl->mIsDefaultHandler;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Supplies a custom progress handler to get regular callbacks during importing
-void Importer::SetProgressHandler ( ProgressHandler* pHandler ) {
+void Importer::SetProgressHandler(ProgressHandler* pHandler) {
+    ai_assert(nullptr != pimpl);
+
     ASSIMP_BEGIN_EXCEPTION_REGION();
+
     // If the new handler is zero, allocate a default implementation.
-    if (!pHandler)
-    {
+    if (!pHandler) {
         // Release pointer in the possession of the caller
         pimpl->mProgressHandler = new DefaultProgressHandler();
         pimpl->mIsDefaultProgressHandler = true;
-    }
-    // Otherwise register the custom handler
-    else if (pimpl->mProgressHandler != pHandler)
-    {
+    } else if (pimpl->mProgressHandler != pHandler) { // Otherwise register the custom handler
         delete pimpl->mProgressHandler;
         pimpl->mProgressHandler = pHandler;
         pimpl->mIsDefaultProgressHandler = false;
@@ -349,19 +350,22 @@ void Importer::SetProgressHandler ( ProgressHandler* pHandler ) {
 // ------------------------------------------------------------------------------------------------
 // Get the currently set progress handler
 ProgressHandler* Importer::GetProgressHandler() const {
+    ai_assert(nullptr != pimpl);
+
     return pimpl->mProgressHandler;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Check whether a custom progress handler is currently set
 bool Importer::IsDefaultProgressHandler() const {
+    ai_assert(nullptr != pimpl);
+
     return pimpl->mIsDefaultProgressHandler;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Validate post process step flags
-bool _ValidateFlags(unsigned int pFlags)
-{
+bool _ValidateFlags(unsigned int pFlags) {
     if (pFlags & aiProcess_GenSmoothNormals && pFlags & aiProcess_GenNormals)   {
         ASSIMP_LOG_ERROR("#aiProcess_GenSmoothNormals and #aiProcess_GenNormals are incompatible");
         return false;
@@ -375,57 +379,71 @@ bool _ValidateFlags(unsigned int pFlags)
 
 // ------------------------------------------------------------------------------------------------
 // Free the current scene
-void Importer::FreeScene( )
-{
+void Importer::FreeScene( ) {
+    ai_assert(nullptr != pimpl);
+
     ASSIMP_BEGIN_EXCEPTION_REGION();
 
     delete pimpl->mScene;
-    pimpl->mScene = NULL;
+    pimpl->mScene = nullptr;
 
-    pimpl->mErrorString = "";
+    pimpl->mErrorString = std::string();
+    pimpl->mException = std::exception_ptr();
     ASSIMP_END_EXCEPTION_REGION(void);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get the current error string, if any
-const char* Importer::GetErrorString() const
-{
-     /* Must remain valid as long as ReadFile() or FreeFile() are not called */
+const char* Importer::GetErrorString() const {
+    ai_assert(nullptr != pimpl);
+
+    // Must remain valid as long as ReadFile() or FreeFile() are not called
     return pimpl->mErrorString.c_str();
 }
 
+const std::exception_ptr& Importer::GetException() const {
+    ai_assert(nullptr != pimpl);
+
+    // Must remain valid as long as ReadFile() or FreeFile() are not called
+    return pimpl->mException;
+}
+
 // ------------------------------------------------------------------------------------------------
 // Enable extra-verbose mode
-void Importer::SetExtraVerbose(bool bDo)
-{
+void Importer::SetExtraVerbose(bool bDo) {
+    ai_assert(nullptr != pimpl);
+
     pimpl->bExtraVerbose = bDo;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get the current scene
-const aiScene* Importer::GetScene() const
-{
+const aiScene* Importer::GetScene() const {
+    ai_assert(nullptr != pimpl);
+
     return pimpl->mScene;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Orphan the current scene and return it.
-aiScene* Importer::GetOrphanedScene()
-{
+aiScene* Importer::GetOrphanedScene() {
+    ai_assert(nullptr != pimpl);
+
     aiScene* s = pimpl->mScene;
 
     ASSIMP_BEGIN_EXCEPTION_REGION();
-    pimpl->mScene = NULL;
+    pimpl->mScene = nullptr;
 
-    pimpl->mErrorString = ""; /* reset error string */
+    pimpl->mErrorString = std::string();
+    pimpl->mException = std::exception_ptr();
     ASSIMP_END_EXCEPTION_REGION(aiScene*);
+
     return s;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Validate post-processing flags
-bool Importer::ValidateFlags(unsigned int pFlags) const
-{
+bool Importer::ValidateFlags(unsigned int pFlags) const {
     ASSIMP_BEGIN_EXCEPTION_REGION();
     // run basic checks for mutually exclusive flags
     if(!_ValidateFlags(pFlags)) {
@@ -467,8 +485,9 @@ bool Importer::ValidateFlags(unsigned int pFlags) const
 const aiScene* Importer::ReadFileFromMemory( const void* pBuffer,
     size_t pLength,
     unsigned int pFlags,
-    const char* pHint /*= ""*/)
-{
+    const char* pHint /*= ""*/) {
+    ai_assert(nullptr != pimpl);
+
     ASSIMP_BEGIN_EXCEPTION_REGION();
     if (!pHint) {
         pHint = "";
@@ -476,12 +495,12 @@ const aiScene* Importer::ReadFileFromMemory( const void* pBuffer,
 
     if (!pBuffer || !pLength || strlen(pHint) > MaxLenHint ) {
         pimpl->mErrorString = "Invalid parameters passed to ReadFileFromMemory()";
-        return NULL;
+        return nullptr;
     }
 
     // prevent deletion of the previous IOHandler
     IOSystem* io = pimpl->mIOHandler;
-    pimpl->mIOHandler = NULL;
+    pimpl->mIOHandler = nullptr;
 
     SetIOHandler(new MemoryIOSystem((const uint8_t*)pBuffer,pLength,io));
 
@@ -493,65 +512,75 @@ const aiScene* Importer::ReadFileFromMemory( const void* pBuffer,
     ReadFile(fbuff,pFlags);
     SetIOHandler(io);
 
-    ASSIMP_END_EXCEPTION_REGION(const aiScene*);
+    ASSIMP_END_EXCEPTION_REGION_WITH_ERROR_STRING(const aiScene*, pimpl->mErrorString, pimpl->mException);
     return pimpl->mScene;
 }
 
 // ------------------------------------------------------------------------------------------------
-void WriteLogOpening(const std::string& file)
-{
-    ASSIMP_LOG_INFO_F("Load ", file);
+void WriteLogOpening(const std::string& file) {
+
+    ASSIMP_LOG_INFO("Load ", file);
 
     // print a full version dump. This is nice because we don't
     // need to ask the authors of incoming bug reports for
     // the library version they're using - a log dump is
     // sufficient.
-    const unsigned int flags( aiGetCompileFlags() );
+    const unsigned int flags = aiGetCompileFlags();
     std::stringstream stream;
     stream << "Assimp " << aiGetVersionMajor() << "." << aiGetVersionMinor() << "." << aiGetVersionRevision() << " "
 #if defined(ASSIMP_BUILD_ARCHITECTURE)
-        << ASSIMP_BUILD_ARCHITECTURE
+           << ASSIMP_BUILD_ARCHITECTURE
 #elif defined(_M_IX86) || defined(__x86_32__) || defined(__i386__)
-        << "x86"
+           << "x86"
 #elif defined(_M_X64) || defined(__x86_64__)
-        << "amd64"
+           << "amd64"
 #elif defined(_M_IA64) || defined(__ia64__)
-        << "itanium"
+           << "itanium"
 #elif defined(__ppc__) || defined(__powerpc__)
-        << "ppc32"
+           << "ppc32"
 #elif defined(__powerpc64__)
-        << "ppc64"
+           << "ppc64"
 #elif defined(__arm__)
-        << "arm"
+           << "arm"
 #else
-        << "<unknown architecture>"
+           << "<unknown architecture>"
 #endif
-        << " "
+           << " "
 #if defined(ASSIMP_BUILD_COMPILER)
-        << ( ASSIMP_BUILD_COMPILER )
+           << (ASSIMP_BUILD_COMPILER)
 #elif defined(_MSC_VER)
-        << "msvc"
+           << "msvc"
 #elif defined(__GNUC__)
-        << "gcc"
+           << "gcc"
+#elif defined(__clang__)
+           << "clang"
+#elif defined(__EMSCRIPTEN__)
+           << "emscripten"
+#elif defined(__MINGW32__)
+           << "MinGW-w64 32bit"
+#elif defined(__MINGW64__)
+           << "MinGW-w64 64bit"
 #else
-        << "<unknown compiler>"
+           << "<unknown compiler>"
 #endif
 
 #ifdef ASSIMP_BUILD_DEBUG
-        << " debug"
+           << " debug"
 #endif
 
-        << (flags & ASSIMP_CFLAGS_NOBOOST ? " noboost" : "")
-        << (flags & ASSIMP_CFLAGS_SHARED  ? " shared" : "")
-        << (flags & ASSIMP_CFLAGS_SINGLETHREADED  ? " singlethreaded" : "");
+           << (flags & ASSIMP_CFLAGS_NOBOOST ? " noboost" : "")
+           << (flags & ASSIMP_CFLAGS_SHARED ? " shared" : "")
+           << (flags & ASSIMP_CFLAGS_SINGLETHREADED ? " singlethreaded" : "")
+           << (flags & ASSIMP_CFLAGS_DOUBLE_SUPPORT ? " double : " : "single : ");
 
-        ASSIMP_LOG_DEBUG(stream.str());
+    ASSIMP_LOG_DEBUG(stream.str());
 }
 
 // ------------------------------------------------------------------------------------------------
 // Reads the given file and returns its contents if successful.
-const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags)
-{
+const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags) {
+    ai_assert(nullptr != pimpl);
+
     ASSIMP_BEGIN_EXCEPTION_REGION();
     const std::string pFile(_pFile);
 
@@ -580,44 +609,86 @@ const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags)
 
             pimpl->mErrorString = "Unable to open file \"" + pFile + "\".";
             ASSIMP_LOG_ERROR(pimpl->mErrorString);
-            return NULL;
+            return nullptr;
         }
 
-        std::unique_ptr<Profiler> profiler(GetPropertyInteger(AI_CONFIG_GLOB_MEASURE_TIME,0)?new Profiler():NULL);
+        std::unique_ptr<Profiler> profiler(GetPropertyInteger(AI_CONFIG_GLOB_MEASURE_TIME, 0) ? new Profiler() : nullptr);
         if (profiler) {
             profiler->BeginRegion("total");
         }
 
-        // Find an worker class which can handle the file
-        BaseImporter* imp = NULL;
+        // Find an worker class which can handle the file extension.
+        // Multiple importers may be able to handle the same extension (.xml!); gather them all.
         SetPropertyInteger("importerIndex", -1);
-        for( unsigned int a = 0; a < pimpl->mImporter.size(); a++)  {
+        struct ImporterAndIndex {
+            BaseImporter * importer;
+            unsigned int   index;
+        };
+        std::vector<ImporterAndIndex> possibleImporters;
+        for (unsigned int a = 0; a < pimpl->mImporter.size(); a++)  {
+
+            // Every importer has a list of supported extensions.
+            std::set<std::string> extensions;
+            pimpl->mImporter[a]->GetExtensionList(extensions);
+
+            // CAUTION: Do not just search for the extension!
+            // GetExtension() returns the part after the *last* dot, but some extensions have dots
+            // inside them, e.g. ogre.mesh.xml. Compare the entire end of the string.
+            for (std::set<std::string>::const_iterator it = extensions.cbegin(); it != extensions.cend(); ++it) {
+
+                // Yay for C++<20 not having std::string::ends_with()
+                std::string extension = "." + *it;
+                if (extension.length() <= pFile.length()) {
+                    // Possible optimization: Fetch the lowercase filename!
+                    if (0 == ASSIMP_stricmp(pFile.c_str() + pFile.length() - extension.length(), extension.c_str())) {
+                        ImporterAndIndex candidate = { pimpl->mImporter[a], a };
+                        possibleImporters.push_back(candidate);
+                        break;
+                    }
+                }
 
-            if( pimpl->mImporter[a]->CanRead( pFile, pimpl->mIOHandler, false)) {
-                imp = pimpl->mImporter[a];
-                SetPropertyInteger("importerIndex", a);
-                break;
             }
+
+        }
+
+        // If just one importer supports this extension, pick it and close the case.
+        BaseImporter* imp = nullptr;
+        if (1 == possibleImporters.size()) {
+            imp = possibleImporters[0].importer;
+            SetPropertyInteger("importerIndex", possibleImporters[0].index);
+        }
+        // If multiple importers claim this file extension, ask them to look at the actual file data to decide.
+        // This can happen e.g. with XML (COLLADA vs. Irrlicht).
+        else {
+            for (std::vector<ImporterAndIndex>::const_iterator it = possibleImporters.begin(); it < possibleImporters.end(); ++it) {
+                BaseImporter & importer = *it->importer;
+
+                ASSIMP_LOG_INFO("Found a possible importer: " + std::string(importer.GetInfo()->mName) + "; trying signature-based detection");
+                if (importer.CanRead( pFile, pimpl->mIOHandler, true)) {
+                    imp = &importer;
+                    SetPropertyInteger("importerIndex", it->index);
+                    break;
+                }
+
+            }
+
         }
 
         if (!imp)   {
             // not so bad yet ... try format auto detection.
-            const std::string::size_type s = pFile.find_last_of('.');
-            if (s != std::string::npos) {
-                ASSIMP_LOG_INFO("File extension not known, trying signature-based detection");
-                for( unsigned int a = 0; a < pimpl->mImporter.size(); a++)  {
-                    if( pimpl->mImporter[a]->CanRead( pFile, pimpl->mIOHandler, true)) {
-                        imp = pimpl->mImporter[a];
-                        SetPropertyInteger("importerIndex", a);
-                        break;
-                    }
+            ASSIMP_LOG_INFO("File extension not known, trying signature-based detection");
+            for( unsigned int a = 0; a < pimpl->mImporter.size(); a++)  {
+                if( pimpl->mImporter[a]->CanRead( pFile, pimpl->mIOHandler, true)) {
+                    imp = pimpl->mImporter[a];
+                    SetPropertyInteger("importerIndex", a);
+                    break;
                 }
             }
             // Put a proper error message if no suitable importer was found
             if( !imp)   {
                 pimpl->mErrorString = "No suitable reader found for the file format of file \"" + pFile + "\".";
                 ASSIMP_LOG_ERROR(pimpl->mErrorString);
-                return NULL;
+                return nullptr;
             }
         }
 
@@ -633,10 +704,10 @@ const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags)
         // Dispatch the reading to the worker class for this format
         const aiImporterDesc *desc( imp->GetInfo() );
         std::string ext( "unknown" );
-        if ( NULL != desc ) {
+        if ( nullptr != desc ) {
             ext = desc->mName;
         }
-        ASSIMP_LOG_INFO("Found a matching importer for this file format: " + ext + "." );
+        ASSIMP_LOG_INFO("Found a matching importer for this file format: ", ext, "." );
         pimpl->mProgressHandler->UpdateFileRead( 0, fileSize );
 
         if (profiler) {
@@ -654,15 +725,20 @@ const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags)
 
         // If successful, apply all active post processing steps to the imported data
         if( pimpl->mScene)  {
+            if (!pimpl->mScene->mMetaData || !pimpl->mScene->mMetaData->HasKey(AI_METADATA_SOURCE_FORMAT)) {
+                if (!pimpl->mScene->mMetaData) {
+                    pimpl->mScene->mMetaData = new aiMetadata;
+                }
+                pimpl->mScene->mMetaData->Add(AI_METADATA_SOURCE_FORMAT, aiString(ext));
+            }
 
 #ifndef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
             // The ValidateDS process is an exception. It is executed first, even before ScenePreprocessor is called.
-            if (pFlags & aiProcess_ValidateDataStructure)
-            {
+            if (pFlags & aiProcess_ValidateDataStructure) {
                 ValidateDSProcess ds;
                 ds.ExecuteOnScene (this);
                 if (!pimpl->mScene) {
-                    return NULL;
+                    return nullptr;
                 }
             }
 #endif // no validation
@@ -685,6 +761,7 @@ const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags)
         // if failed, extract the error string
         else if( !pimpl->mScene) {
             pimpl->mErrorString = imp->GetErrorText();
+            pimpl->mException = imp->GetException();
         }
 
         // clear any data allocated by post-process steps
@@ -695,8 +772,7 @@ const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags)
         }
     }
 #ifdef ASSIMP_CATCH_GLOBAL_EXCEPTIONS
-    catch (std::exception &e)
-    {
+    catch (std::exception &e) {
 #if (defined _MSC_VER) &&   (defined _CPPRTTI)
         // if we have RTTI get the full name of the exception that occurred
         pimpl->mErrorString = std::string(typeid( e ).name()) + ": " + e.what();
@@ -705,24 +781,26 @@ const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags)
 #endif
 
         ASSIMP_LOG_ERROR(pimpl->mErrorString);
-        delete pimpl->mScene; pimpl->mScene = NULL;
+        delete pimpl->mScene; pimpl->mScene = nullptr;
     }
 #endif // ! ASSIMP_CATCH_GLOBAL_EXCEPTIONS
 
     // either successful or failure - the pointer expresses it anyways
-    ASSIMP_END_EXCEPTION_REGION(const aiScene*);
+    ASSIMP_END_EXCEPTION_REGION_WITH_ERROR_STRING(const aiScene*, pimpl->mErrorString, pimpl->mException);
+
     return pimpl->mScene;
 }
 
 
 // ------------------------------------------------------------------------------------------------
 // Apply post-processing to the currently bound scene
-const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags)
-{
+const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags) {
+    ai_assert(nullptr != pimpl);
+
     ASSIMP_BEGIN_EXCEPTION_REGION();
     // Return immediately if no scene is active
     if (!pimpl->mScene) {
-        return NULL;
+        return nullptr;
     }
 
     // If no flags are given, return the current scene with no further action
@@ -737,12 +815,11 @@ const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags)
 #ifndef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
     // The ValidateDS process plays an exceptional role. It isn't contained in the global
     // list of post-processing steps, so we need to call it manually.
-    if (pFlags & aiProcess_ValidateDataStructure)
-    {
+    if (pFlags & aiProcess_ValidateDataStructure) {
         ValidateDSProcess ds;
         ds.ExecuteOnScene (this);
         if (!pimpl->mScene) {
-            return NULL;
+            return nullptr;
         }
     }
 #endif // no validation
@@ -760,13 +837,11 @@ const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags)
     }
 #endif // ! DEBUG
 
-    std::unique_ptr<Profiler> profiler(GetPropertyInteger(AI_CONFIG_GLOB_MEASURE_TIME,0)?new Profiler():NULL);
+    std::unique_ptr<Profiler> profiler(GetPropertyInteger(AI_CONFIG_GLOB_MEASURE_TIME, 0) ? new Profiler() : nullptr);
     for( unsigned int a = 0; a < pimpl->mPostProcessingSteps.size(); a++)   {
-
         BaseProcess* process = pimpl->mPostProcessingSteps[a];
         pimpl->mProgressHandler->UpdatePostProcess(static_cast<int>(a), static_cast<int>(pimpl->mPostProcessingSteps.size()) );
         if( process->IsActive( pFlags)) {
-
             if (profiler) {
                 profiler->BeginRegion("postprocess");
             }
@@ -799,32 +874,36 @@ const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags)
         }
 #endif // ! DEBUG
     }
-    pimpl->mProgressHandler->UpdatePostProcess( static_cast<int>(pimpl->mPostProcessingSteps.size()), 
+    pimpl->mProgressHandler->UpdatePostProcess( static_cast<int>(pimpl->mPostProcessingSteps.size()),
         static_cast<int>(pimpl->mPostProcessingSteps.size()) );
 
     // update private scene flags
-    if( pimpl->mScene )
+    if( pimpl->mScene ) {
       ScenePriv(pimpl->mScene)->mPPStepsApplied |= pFlags;
+    }
 
     // clear any data allocated by post-process steps
     pimpl->mPPShared->Clean();
     ASSIMP_LOG_INFO("Leaving post processing pipeline");
 
     ASSIMP_END_EXCEPTION_REGION(const aiScene*);
+
     return pimpl->mScene;
 }
 
 // ------------------------------------------------------------------------------------------------
 const aiScene* Importer::ApplyCustomizedPostProcessing( BaseProcess *rootProcess, bool requestValidation ) {
+    ai_assert(nullptr != pimpl);
+
     ASSIMP_BEGIN_EXCEPTION_REGION();
 
     // Return immediately if no scene is active
-    if ( NULL == pimpl->mScene ) {
-        return NULL;
+    if ( nullptr == pimpl->mScene ) {
+        return nullptr;
     }
 
     // If no flags are given, return the current scene with no further action
-    if ( NULL == rootProcess ) {
+    if (nullptr == rootProcess) {
         return pimpl->mScene;
     }
 
@@ -839,7 +918,7 @@ const aiScene* Importer::ApplyCustomizedPostProcessing( BaseProcess *rootProcess
         ValidateDSProcess ds;
         ds.ExecuteOnScene( this );
         if ( !pimpl->mScene ) {
-            return NULL;
+            return nullptr;
         }
     }
 #endif // no validation
@@ -856,7 +935,7 @@ const aiScene* Importer::ApplyCustomizedPostProcessing( BaseProcess *rootProcess
     }
 #endif // ! DEBUG
 
-    std::unique_ptr<Profiler> profiler( GetPropertyInteger( AI_CONFIG_GLOB_MEASURE_TIME, 0 ) ? new Profiler() : NULL );
+    std::unique_ptr<Profiler> profiler(GetPropertyInteger(AI_CONFIG_GLOB_MEASURE_TIME, 0) ? new Profiler() : nullptr);
 
     if ( profiler ) {
         profiler->BeginRegion( "postprocess" );
@@ -890,59 +969,62 @@ const aiScene* Importer::ApplyCustomizedPostProcessing( BaseProcess *rootProcess
 
 // ------------------------------------------------------------------------------------------------
 // Helper function to check whether an extension is supported by ASSIMP
-bool Importer::IsExtensionSupported(const char* szExtension) const
-{
+bool Importer::IsExtensionSupported(const char* szExtension) const {
     return nullptr != GetImporter(szExtension);
 }
 
 // ------------------------------------------------------------------------------------------------
-size_t Importer::GetImporterCount() const
-{
+size_t Importer::GetImporterCount() const {
+    ai_assert(nullptr != pimpl);
+
     return pimpl->mImporter.size();
 }
 
 // ------------------------------------------------------------------------------------------------
-const aiImporterDesc* Importer::GetImporterInfo(size_t index) const
-{
+const aiImporterDesc* Importer::GetImporterInfo(size_t index) const {
+    ai_assert(nullptr != pimpl);
+
     if (index >= pimpl->mImporter.size()) {
-        return NULL;
+        return nullptr;
     }
     return pimpl->mImporter[index]->GetInfo();
 }
 
 
 // ------------------------------------------------------------------------------------------------
-BaseImporter* Importer::GetImporter (size_t index) const
-{
+BaseImporter* Importer::GetImporter (size_t index) const {
+    ai_assert(nullptr != pimpl);
+
     if (index >= pimpl->mImporter.size()) {
-        return NULL;
+        return nullptr;
     }
     return pimpl->mImporter[index];
 }
 
 // ------------------------------------------------------------------------------------------------
 // Find a loader plugin for a given file extension
-BaseImporter* Importer::GetImporter (const char* szExtension) const
-{
+BaseImporter* Importer::GetImporter (const char* szExtension) const {
+    ai_assert(nullptr != pimpl);
+
     return GetImporter(GetImporterIndex(szExtension));
 }
 
 // ------------------------------------------------------------------------------------------------
 // Find a loader plugin for a given file extension
 size_t Importer::GetImporterIndex (const char* szExtension) const {
+    ai_assert(nullptr != pimpl);
     ai_assert(nullptr != szExtension);
 
     ASSIMP_BEGIN_EXCEPTION_REGION();
 
-    // skip over wildcard and dot characters at string head --
+    // skip over wild-card and dot characters at string head --
     for ( ; *szExtension == '*' || *szExtension == '.'; ++szExtension );
 
     std::string ext(szExtension);
     if (ext.empty()) {
         return static_cast<size_t>(-1);
     }
-    std::transform( ext.begin(), ext.end(), ext.begin(), ToLower<char> );
-
+    ext = ai_tolower(ext);
     std::set<std::string> str;
     for (std::vector<BaseImporter*>::const_iterator i =  pimpl->mImporter.begin();i != pimpl->mImporter.end();++i)  {
         str.clear();
@@ -960,8 +1042,9 @@ size_t Importer::GetImporterIndex (const char* szExtension) const {
 
 // ------------------------------------------------------------------------------------------------
 // Helper function to build a list of all file extensions supported by ASSIMP
-void Importer::GetExtensionList(aiString& szOut) const
-{
+void Importer::GetExtensionList(aiString& szOut) const {
+    ai_assert(nullptr != pimpl);
+
     ASSIMP_BEGIN_EXCEPTION_REGION();
     std::set<std::string> str;
     for (std::vector<BaseImporter*>::const_iterator i =  pimpl->mImporter.begin();i != pimpl->mImporter.end();++i)  {
@@ -985,8 +1068,9 @@ void Importer::GetExtensionList(aiString& szOut) const
 
 // ------------------------------------------------------------------------------------------------
 // Set a configuration property
-bool Importer::SetPropertyInteger(const char* szName, int iValue)
-{
+bool Importer::SetPropertyInteger(const char* szName, int iValue) {
+    ai_assert(nullptr != pimpl);
+
     bool existing;
     ASSIMP_BEGIN_EXCEPTION_REGION();
         existing = SetGenericProperty<int>(pimpl->mIntProperties, szName,iValue);
@@ -996,8 +1080,9 @@ bool Importer::SetPropertyInteger(const char* szName, int iValue)
 
 // ------------------------------------------------------------------------------------------------
 // Set a configuration property
-bool Importer::SetPropertyFloat(const char* szName, ai_real iValue)
-{
+bool Importer::SetPropertyFloat(const char* szName, ai_real iValue) {
+    ai_assert(nullptr != pimpl);
+
     bool existing;
     ASSIMP_BEGIN_EXCEPTION_REGION();
         existing = SetGenericProperty<ai_real>(pimpl->mFloatProperties, szName,iValue);
@@ -1007,8 +1092,9 @@ bool Importer::SetPropertyFloat(const char* szName, ai_real iValue)
 
 // ------------------------------------------------------------------------------------------------
 // Set a configuration property
-bool Importer::SetPropertyString(const char* szName, const std::string& value)
-{
+bool Importer::SetPropertyString(const char* szName, const std::string& value) {
+    ai_assert(nullptr != pimpl);
+
     bool existing;
     ASSIMP_BEGIN_EXCEPTION_REGION();
         existing = SetGenericProperty<std::string>(pimpl->mStringProperties, szName,value);
@@ -1018,8 +1104,9 @@ bool Importer::SetPropertyString(const char* szName, const std::string& value)
 
 // ------------------------------------------------------------------------------------------------
 // Set a configuration property
-bool Importer::SetPropertyMatrix(const char* szName, const aiMatrix4x4& value)
-{
+bool Importer::SetPropertyMatrix(const char* szName, const aiMatrix4x4& value) {
+    ai_assert(nullptr != pimpl);
+
     bool existing;
     ASSIMP_BEGIN_EXCEPTION_REGION();
         existing = SetGenericProperty<aiMatrix4x4>(pimpl->mMatrixProperties, szName,value);
@@ -1027,42 +1114,65 @@ bool Importer::SetPropertyMatrix(const char* szName, const aiMatrix4x4& value)
     return existing;
 }
 
+// ------------------------------------------------------------------------------------------------
+// Set a configuration property
+bool Importer::SetPropertyPointer(const char* szName, void* value) {
+    ai_assert(nullptr != pimpl);
+    
+    bool existing;
+    ASSIMP_BEGIN_EXCEPTION_REGION();
+        existing = SetGenericProperty<void*>(pimpl->mPointerProperties, szName,value);
+    ASSIMP_END_EXCEPTION_REGION(bool);
+    return existing;
+}
+
 // ------------------------------------------------------------------------------------------------
 // Get a configuration property
-int Importer::GetPropertyInteger(const char* szName,
-    int iErrorReturn /*= 0xffffffff*/) const
-{
+int Importer::GetPropertyInteger(const char* szName, int iErrorReturn /*= 0xffffffff*/) const {
+    ai_assert(nullptr != pimpl);
+
     return GetGenericProperty<int>(pimpl->mIntProperties,szName,iErrorReturn);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get a configuration property
-ai_real Importer::GetPropertyFloat(const char* szName,
-    ai_real iErrorReturn /*= 10e10*/) const
-{
+ai_real Importer::GetPropertyFloat(const char* szName, ai_real iErrorReturn /*= 10e10*/) const {
+    ai_assert(nullptr != pimpl);
+
     return GetGenericProperty<ai_real>(pimpl->mFloatProperties,szName,iErrorReturn);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get a configuration property
-const std::string Importer::GetPropertyString(const char* szName,
-    const std::string& iErrorReturn /*= ""*/) const
-{
+std::string Importer::GetPropertyString(const char* szName, const std::string& iErrorReturn /*= ""*/) const {
+    ai_assert(nullptr != pimpl);
+
     return GetGenericProperty<std::string>(pimpl->mStringProperties,szName,iErrorReturn);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get a configuration property
-const aiMatrix4x4 Importer::GetPropertyMatrix(const char* szName,
-    const aiMatrix4x4& iErrorReturn /*= aiMatrix4x4()*/) const
-{
+aiMatrix4x4 Importer::GetPropertyMatrix(const char* szName, const aiMatrix4x4& iErrorReturn /*= aiMatrix4x4()*/) const {
+    ai_assert(nullptr != pimpl);
+
     return GetGenericProperty<aiMatrix4x4>(pimpl->mMatrixProperties,szName,iErrorReturn);
 }
 
+// ------------------------------------------------------------------------------------------------
+// Get a configuration property
+void* Importer::GetPropertyPointer(const char* szName, void* iErrorReturn /*= nullptr*/) const {
+    ai_assert(nullptr != pimpl);
+    
+    return GetGenericProperty<void*>(pimpl->mPointerProperties,szName,iErrorReturn);
+}
+
 // ------------------------------------------------------------------------------------------------
 // Get the memory requirements of a single node
-inline void AddNodeWeight(unsigned int& iScene,const aiNode* pcNode)
-{
+inline
+void AddNodeWeight(unsigned int& iScene,const aiNode* pcNode) {
+    if ( nullptr == pcNode ) {
+        return;
+    }
     iScene += sizeof(aiNode);
     iScene += sizeof(unsigned int) * pcNode->mNumMeshes;
     iScene += sizeof(void*) * pcNode->mNumChildren;
@@ -1074,21 +1184,20 @@ inline void AddNodeWeight(unsigned int& iScene,const aiNode* pcNode)
 
 // ------------------------------------------------------------------------------------------------
 // Get the memory requirements of the scene
-void Importer::GetMemoryRequirements(aiMemoryInfo& in) const
-{
+void Importer::GetMemoryRequirements(aiMemoryInfo& in) const {
+    ai_assert(nullptr != pimpl);
+
     in = aiMemoryInfo();
     aiScene* mScene = pimpl->mScene;
 
     // return if we have no scene loaded
-    if (!pimpl->mScene)
+    if (!mScene)
         return;
 
-
     in.total = sizeof(aiScene);
 
     // add all meshes
-    for (unsigned int i = 0; i < mScene->mNumMeshes;++i)
-    {
+    for (unsigned int i = 0; i < mScene->mNumMeshes;++i) {
         in.meshes += sizeof(aiMesh);
         if (mScene->mMeshes[i]->HasPositions()) {
             in.meshes += sizeof(aiVector3D) * mScene->mMeshes[i]->mNumVertices;
@@ -1105,14 +1214,16 @@ void Importer::GetMemoryRequirements(aiMemoryInfo& in) const
         for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS;++a) {
             if (mScene->mMeshes[i]->HasVertexColors(a)) {
                 in.meshes += sizeof(aiColor4D) * mScene->mMeshes[i]->mNumVertices;
+            } else {
+                break;
             }
-            else break;
         }
         for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS;++a) {
             if (mScene->mMeshes[i]->HasTextureCoords(a)) {
                 in.meshes += sizeof(aiVector3D) * mScene->mMeshes[i]->mNumVertices;
+            } else {
+                break;
             }
-            else break;
         }
         if (mScene->mMeshes[i]->HasBones()) {
             in.meshes += sizeof(void*) * mScene->mMeshes[i]->mNumBones;
@@ -1131,8 +1242,9 @@ void Importer::GetMemoryRequirements(aiMemoryInfo& in) const
         in.textures += sizeof(aiTexture);
         if (pc->mHeight) {
             in.textures += 4 * pc->mHeight * pc->mWidth;
+        } else {
+            in.textures += pc->mWidth;
         }
-        else in.textures += pc->mWidth;
     }
     in.total += in.textures;
 
@@ -1143,7 +1255,7 @@ void Importer::GetMemoryRequirements(aiMemoryInfo& in) const
 
         // add all bone anims
         for (unsigned int a = 0; a < pc->mNumChannels; ++a) {
-            const aiNodeAnim* pc2 = pc->mChannels[i];
+            const aiNodeAnim* pc2 = pc->mChannels[a];
             in.animations += sizeof(aiNodeAnim);
             in.animations += pc2->mNumPositionKeys * sizeof(aiVectorKey);
             in.animations += pc2->mNumScalingKeys * sizeof(aiVectorKey);
@@ -1170,5 +1282,6 @@ void Importer::GetMemoryRequirements(aiMemoryInfo& in) const
             in.materials += pc->mProperties[a]->mDataLength;
         }
     }
+
     in.total += in.materials;
 }
diff --git a/Engine/lib/assimp/code/Common/Importer.h b/Engine/lib/assimp/code/Common/Importer.h
index a439d99c2..ab7e3a6b3 100644
--- a/Engine/lib/assimp/code/Common/Importer.h
+++ b/Engine/lib/assimp/code/Common/Importer.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -45,6 +44,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef INCLUDED_AI_IMPORTER_H
 #define INCLUDED_AI_IMPORTER_H
 
+#include <exception>
 #include <map>
 #include <vector>
 #include <string>
@@ -73,12 +73,12 @@ public:
     // Data type to store the key hash
     typedef unsigned int KeyType;
 
-    // typedefs for our four configuration maps.
-    // We don't need more, so there is no need for a generic solution
+    // typedefs for our configuration maps.
     typedef std::map<KeyType, int> IntPropertyMap;
     typedef std::map<KeyType, ai_real> FloatPropertyMap;
     typedef std::map<KeyType, std::string> StringPropertyMap;
     typedef std::map<KeyType, aiMatrix4x4> MatrixPropertyMap;
+    typedef std::map<KeyType, void*> PointerPropertyMap;
 
     /** IO handler to use for all file accesses. */
     IOSystem* mIOHandler;
@@ -94,12 +94,16 @@ public:
     /** Post processing steps we can apply at the imported data. */
     std::vector< BaseProcess* > mPostProcessingSteps;
 
-    /** The imported data, if ReadFile() was successful, NULL otherwise. */
+    /** The imported data, if ReadFile() was successful, nullptr otherwise. */
     aiScene* mScene;
 
-    /** The error description, if there was one. */
+    /** The error description, if there was one. In the case of an exception,
+     *  mException will carry the full details. */
     std::string mErrorString;
 
+    /** Any exception which occurred */
+    std::exception_ptr mException;
+
     /** List of integer properties */
     IntPropertyMap mIntProperties;
 
@@ -112,6 +116,9 @@ public:
     /** List of Matrix properties */
     MatrixPropertyMap mMatrixProperties;
 
+    /** List of pointer properties */
+    PointerPropertyMap mPointerProperties;
+
     /** Used for testing - extra verbose mode causes the ValidateDataStructure-Step
      *  to be executed before and after every single post-process step */
     bool bExtraVerbose;
@@ -124,26 +131,27 @@ public:
 };
 
 inline
-ImporterPimpl::ImporterPimpl() AI_NO_EXCEPT
-: mIOHandler( nullptr )
-, mIsDefaultHandler( false )
-, mProgressHandler( nullptr )
-, mIsDefaultProgressHandler( false )
-, mImporter()
-, mPostProcessingSteps()
-, mScene( nullptr )
-, mErrorString()
-, mIntProperties()
-, mFloatProperties()
-, mStringProperties()
-, mMatrixProperties()
-, bExtraVerbose( false )
-, mPPShared( nullptr ) {
+ImporterPimpl::ImporterPimpl() AI_NO_EXCEPT :
+        mIOHandler( nullptr ),
+        mIsDefaultHandler( false ),
+        mProgressHandler( nullptr ),
+        mIsDefaultProgressHandler( false ),
+        mImporter(),
+        mPostProcessingSteps(),
+        mScene( nullptr ),
+        mErrorString(),
+        mException(),
+        mIntProperties(),
+        mFloatProperties(),
+        mStringProperties(),
+        mMatrixProperties(),
+        mPointerProperties(),
+        bExtraVerbose( false ),
+        mPPShared( nullptr ) {
     // empty
 }
 //! @endcond
 
-
 struct BatchData;
 
 // ---------------------------------------------------------------------------
@@ -154,17 +162,13 @@ struct BatchData;
  *  could, this has not yet been implemented at the moment).
  *
  *  @note The class may not be used by more than one thread*/
-class ASSIMP_API BatchLoader
-{
-    // friend of Importer
-
+class ASSIMP_API BatchLoader {
 public:
     //! @cond never
     // -------------------------------------------------------------------
     /** Wraps a full list of configuration properties for an importer.
      *  Properties can be set using SetGenericProperty */
-    struct PropertyMap
-    {
+    struct PropertyMap {
         ImporterPimpl::IntPropertyMap     ints;
         ImporterPimpl::FloatPropertyMap   floats;
         ImporterPimpl::StringPropertyMap  strings;
@@ -181,10 +185,9 @@ public:
     };
     //! @endcond
 
-public:
     // -------------------------------------------------------------------
     /** Construct a batch loader from a given IO system to be used
-     *  to access external files 
+     *  to access external files
      */
     explicit BatchLoader(IOSystem* pIO, bool validate = false );
 
@@ -198,13 +201,13 @@ public:
      *  @param  enable  True for validation.
      */
     void setValidation( bool enabled );
-    
+
     // -------------------------------------------------------------------
     /** Returns the current validation step.
      *  @return The current validation step.
      */
     bool getValidation() const;
-    
+
     // -------------------------------------------------------------------
     /** Add a new file to the list of files to be loaded.
      *  @param file File to be loaded
@@ -216,7 +219,7 @@ public:
     unsigned int AddLoadRequest (
         const std::string& file,
         unsigned int steps = 0,
-        const PropertyMap* map = NULL
+            const PropertyMap *map = nullptr
         );
 
     // -------------------------------------------------------------------
@@ -226,7 +229,7 @@ public:
      *  can be called several times, too.
      *
      *  @param which LRWC returned by AddLoadRequest().
-     *  @return NULL if there is no scene with this file name
+     *  @return nullptr if there is no scene with this file name
      *  in the queue of the scene hasn't been loaded yet. */
     aiScene* GetImport(
         unsigned int which
diff --git a/Engine/lib/assimp/code/Common/ImporterRegistry.cpp b/Engine/lib/assimp/code/Common/ImporterRegistry.cpp
index 32ac3b416..78c02d96d 100644
--- a/Engine/lib/assimp/code/Common/ImporterRegistry.cpp
+++ b/Engine/lib/assimp/code/Common/ImporterRegistry.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -48,324 +46,348 @@ directly (unless you are adding new loaders), instead use the
 corresponding preprocessor flag to selectively disable formats.
 */
 
-#include <vector>
+#include <assimp/anim.h>
 #include <assimp/BaseImporter.h>
+#include <vector>
+#include <cstdlib>
 
 // ------------------------------------------------------------------------------------------------
 // Importers
 // (include_new_importers_here)
 // ------------------------------------------------------------------------------------------------
 #ifndef ASSIMP_BUILD_NO_X_IMPORTER
-#   include "X/XFileImporter.h"
+#include "AssetLib/X/XFileImporter.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_AMF_IMPORTER
-#   include "AMF/AMFImporter.hpp"
+#include "AssetLib/AMF/AMFImporter.hpp"
 #endif
 #ifndef ASSIMP_BUILD_NO_3DS_IMPORTER
-#   include "3DS/3DSLoader.h"
+#include "AssetLib/3DS/3DSLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_MD3_IMPORTER
-#   include "MD3/MD3Loader.h"
+#include "AssetLib/MD3/MD3Loader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_MDL_IMPORTER
-#   include "MDL/MDLLoader.h"
+#include "AssetLib/MDL/MDLLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_MD2_IMPORTER
-#   include "MD2/MD2Loader.h"
+#include "AssetLib/MD2/MD2Loader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_PLY_IMPORTER
-#   include "Ply/PlyLoader.h"
+#include "AssetLib/Ply/PlyLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_ASE_IMPORTER
-#   include "ASE/ASELoader.h"
+#include "AssetLib/ASE/ASELoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_OBJ_IMPORTER
-#   include "Obj/ObjFileImporter.h"
+#include "AssetLib/Obj/ObjFileImporter.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_HMP_IMPORTER
-#   include "HMP/HMPLoader.h"
+#include "AssetLib/HMP/HMPLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_SMD_IMPORTER
-#   include "SMD/SMDLoader.h"
+#include "AssetLib/SMD/SMDLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_MDC_IMPORTER
-#   include "MDC/MDCLoader.h"
+#include "AssetLib/MDC/MDCLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_MD5_IMPORTER
-#   include "MD5/MD5Loader.h"
+#include "AssetLib/MD5/MD5Loader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_STL_IMPORTER
-#   include "STL/STLLoader.h"
+#include "AssetLib/STL/STLLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_LWO_IMPORTER
-#   include "LWO/LWOLoader.h"
+#include "AssetLib/LWO/LWOLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_DXF_IMPORTER
-#   include "DXF/DXFLoader.h"
+#include "AssetLib/DXF/DXFLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_NFF_IMPORTER
-#   include "NFF/NFFLoader.h"
+#include "AssetLib/NFF/NFFLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_RAW_IMPORTER
-#   include "Raw/RawLoader.h"
+#include "AssetLib/Raw/RawLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_SIB_IMPORTER
-#   include "SIB/SIBImporter.h"
+#include "AssetLib/SIB/SIBImporter.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_OFF_IMPORTER
-#   include "OFF/OFFLoader.h"
+#include "AssetLib/OFF/OFFLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_AC_IMPORTER
-#   include "AC/ACLoader.h"
+#include "AssetLib/AC/ACLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_BVH_IMPORTER
-#   include "BVH/BVHLoader.h"
+#include "AssetLib/BVH/BVHLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_IRRMESH_IMPORTER
-#   include "Irr/IRRMeshLoader.h"
+#include "AssetLib/Irr/IRRMeshLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_IRR_IMPORTER
-#   include "Irr/IRRLoader.h"
+#include "AssetLib/Irr/IRRLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_Q3D_IMPORTER
-#   include "Q3D/Q3DLoader.h"
+#include "AssetLib/Q3D/Q3DLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_B3D_IMPORTER
-#   include "B3D/B3DImporter.h"
+#include "AssetLib/B3D/B3DImporter.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_COLLADA_IMPORTER
-#   include "Collada/ColladaLoader.h"
+#include "AssetLib/Collada/ColladaLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_TERRAGEN_IMPORTER
-#   include "Terragen/TerragenLoader.h"
+#include "AssetLib/Terragen/TerragenLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_CSM_IMPORTER
-#   include "CSM/CSMLoader.h"
+#include "AssetLib/CSM/CSMLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_3D_IMPORTER
-#   include "Unreal/UnrealLoader.h"
+#include "AssetLib/Unreal/UnrealLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_LWS_IMPORTER
-#   include "LWS/LWSLoader.h"
+#include "AssetLib/LWS/LWSLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_OGRE_IMPORTER
-#   include "Ogre/OgreImporter.h"
+#include "AssetLib/Ogre/OgreImporter.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_OPENGEX_IMPORTER
-#   include "OpenGEX/OpenGEXImporter.h"
+#include "AssetLib/OpenGEX/OpenGEXImporter.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_MS3D_IMPORTER
-#   include "MS3D/MS3DLoader.h"
+#include "AssetLib/MS3D/MS3DLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_COB_IMPORTER
-#   include "COB/COBLoader.h"
+#include "AssetLib/COB/COBLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_BLEND_IMPORTER
-#   include "Blender/BlenderLoader.h"
+#include "AssetLib/Blender/BlenderLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_Q3BSP_IMPORTER
-#   include "Q3BSP/Q3BSPFileImporter.h"
+#include "AssetLib/Q3BSP/Q3BSPFileImporter.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_NDO_IMPORTER
-#   include "NDO/NDOLoader.h"
+#include "AssetLib/NDO/NDOLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
-#   include "Importer/IFC/IFCLoader.h"
+#include "AssetLib/IFC/IFCLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_XGL_IMPORTER
-#   include "XGL/XGLLoader.h"
+#include "AssetLib/XGL/XGLLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_FBX_IMPORTER
-#   include "FBX/FBXImporter.h"
+#include "AssetLib/FBX/FBXImporter.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_ASSBIN_IMPORTER
-#   include "Assbin/AssbinLoader.h"
+#include "AssetLib/Assbin/AssbinLoader.h"
 #endif
-#ifndef ASSIMP_BUILD_NO_GLTF_IMPORTER
-#   include "glTF/glTFImporter.h"
-#   include "glTF2/glTF2Importer.h"
+#if !defined(ASSIMP_BUILD_NO_GLTF_IMPORTER) && !defined(ASSIMP_BUILD_NO_GLTF1_IMPORTER)
+#include "AssetLib/glTF/glTFImporter.h"
+#endif
+#if !defined(ASSIMP_BUILD_NO_GLTF_IMPORTER) && !defined(ASSIMP_BUILD_NO_GLTF2_IMPORTER)
+#include "AssetLib/glTF2/glTF2Importer.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_C4D_IMPORTER
-#   include "C4D/C4DImporter.h"
+#include "AssetLib/C4D/C4DImporter.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_3MF_IMPORTER
-#   include "3MF/D3MFImporter.h"
+#include "AssetLib/3MF/D3MFImporter.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
-#   include "X3D/X3DImporter.hpp"
+#include "AssetLib/X3D/X3DImporter.hpp"
 #endif
 #ifndef ASSIMP_BUILD_NO_MMD_IMPORTER
-#   include "MMD/MMDImporter.h"
+#include "AssetLib/MMD/MMDImporter.h"
 #endif
-#ifndef ASSIMP_BUILD_NO_STEP_IMPORTER
-#   include "Importer/StepFile/StepFileImporter.h"
+#ifndef ASSIMP_BUILD_NO_M3D_IMPORTER
+#include "AssetLib/M3D/M3DImporter.h"
+#endif
+#ifndef ASSIMP_BUILD_NO_IQM_IMPORTER
+#include "AssetLib/IQM/IQMImporter.h"
 #endif
 
 namespace Assimp {
 
 // ------------------------------------------------------------------------------------------------
-void GetImporterInstanceList(std::vector< BaseImporter* >& out)
-{
+void GetImporterInstanceList(std::vector<BaseImporter *> &out) {
+
+    // Some importers may be unimplemented or otherwise unsuitable for general use
+    // in their current state. Devs can set ASSIMP_ENABLE_DEV_IMPORTERS in their
+    // local environment to enable them, otherwise they're left out of the registry.
+    const char *envStr = std::getenv("ASSIMP_ENABLE_DEV_IMPORTERS");
+    bool devImportersEnabled = envStr && strcmp(envStr, "0");
+
+    // Ensure no unused var warnings if all uses are #ifndef'd away below:
+    (void)devImportersEnabled;
+
     // ----------------------------------------------------------------------------
     // Add an instance of each worker class here
     // (register_new_importers_here)
     // ----------------------------------------------------------------------------
     out.reserve(64);
 #if (!defined ASSIMP_BUILD_NO_X_IMPORTER)
-    out.push_back( new XFileImporter());
+    out.push_back(new XFileImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_OBJ_IMPORTER)
-    out.push_back( new ObjFileImporter());
+    out.push_back(new ObjFileImporter());
 #endif
 #ifndef ASSIMP_BUILD_NO_AMF_IMPORTER
-	out.push_back( new AMFImporter() );
+    out.push_back(new AMFImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_3DS_IMPORTER)
-    out.push_back( new Discreet3DSImporter());
+    out.push_back(new Discreet3DSImporter());
+#endif
+#if (!defined ASSIMP_BUILD_NO_M3D_IMPORTER)
+    out.push_back(new M3DImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_MD3_IMPORTER)
-    out.push_back( new MD3Importer());
+    out.push_back(new MD3Importer());
 #endif
 #if (!defined ASSIMP_BUILD_NO_MD2_IMPORTER)
-    out.push_back( new MD2Importer());
+    out.push_back(new MD2Importer());
 #endif
 #if (!defined ASSIMP_BUILD_NO_PLY_IMPORTER)
-    out.push_back( new PLYImporter());
+    out.push_back(new PLYImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_MDL_IMPORTER)
-    out.push_back( new MDLImporter());
+    out.push_back(new MDLImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_ASE_IMPORTER)
-  #if (!defined ASSIMP_BUILD_NO_3DS_IMPORTER)
-    out.push_back( new ASEImporter());
-#  endif
+#if (!defined ASSIMP_BUILD_NO_3DS_IMPORTER)
+    out.push_back(new ASEImporter());
+#endif
 #endif
 #if (!defined ASSIMP_BUILD_NO_HMP_IMPORTER)
-    out.push_back( new HMPImporter());
+    out.push_back(new HMPImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_SMD_IMPORTER)
-    out.push_back( new SMDImporter());
+    out.push_back(new SMDImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_MDC_IMPORTER)
-    out.push_back( new MDCImporter());
+    out.push_back(new MDCImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_MD5_IMPORTER)
-    out.push_back( new MD5Importer());
+    out.push_back(new MD5Importer());
 #endif
 #if (!defined ASSIMP_BUILD_NO_STL_IMPORTER)
-    out.push_back( new STLImporter());
+    out.push_back(new STLImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_LWO_IMPORTER)
-    out.push_back( new LWOImporter());
+    out.push_back(new LWOImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_DXF_IMPORTER)
-    out.push_back( new DXFImporter());
+    out.push_back(new DXFImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_NFF_IMPORTER)
-    out.push_back( new NFFImporter());
+    out.push_back(new NFFImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_RAW_IMPORTER)
-    out.push_back( new RAWImporter());
+    out.push_back(new RAWImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_SIB_IMPORTER)
-    out.push_back( new SIBImporter());
+    out.push_back(new SIBImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_OFF_IMPORTER)
-    out.push_back( new OFFImporter());
+    out.push_back(new OFFImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_AC_IMPORTER)
-    out.push_back( new AC3DImporter());
+    out.push_back(new AC3DImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_BVH_IMPORTER)
-    out.push_back( new BVHLoader());
+    out.push_back(new BVHLoader());
 #endif
 #if (!defined ASSIMP_BUILD_NO_IRRMESH_IMPORTER)
-    out.push_back( new IRRMeshImporter());
+    out.push_back(new IRRMeshImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_IRR_IMPORTER)
-    out.push_back( new IRRImporter());
+    out.push_back(new IRRImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_Q3D_IMPORTER)
-    out.push_back( new Q3DImporter());
+    out.push_back(new Q3DImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_B3D_IMPORTER)
-    out.push_back( new B3DImporter());
+    out.push_back(new B3DImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_COLLADA_IMPORTER)
-    out.push_back( new ColladaLoader());
+    out.push_back(new ColladaLoader());
 #endif
 #if (!defined ASSIMP_BUILD_NO_TERRAGEN_IMPORTER)
-    out.push_back( new TerragenImporter());
+    out.push_back(new TerragenImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_CSM_IMPORTER)
-    out.push_back( new CSMImporter());
+    out.push_back(new CSMImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_3D_IMPORTER)
-    out.push_back( new UnrealImporter());
+    out.push_back(new UnrealImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_LWS_IMPORTER)
-    out.push_back( new LWSImporter());
+    out.push_back(new LWSImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_OGRE_IMPORTER)
-    out.push_back( new Ogre::OgreImporter());
+    out.push_back(new Ogre::OgreImporter());
 #endif
-#if (!defined ASSIMP_BUILD_NO_OPENGEX_IMPORTER )
-    out.push_back( new OpenGEX::OpenGEXImporter() );
+#if (!defined ASSIMP_BUILD_NO_OPENGEX_IMPORTER)
+    out.push_back(new OpenGEX::OpenGEXImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_MS3D_IMPORTER)
-    out.push_back( new MS3DImporter());
+    out.push_back(new MS3DImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_COB_IMPORTER)
-    out.push_back( new COBImporter());
+    out.push_back(new COBImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_BLEND_IMPORTER)
-    out.push_back( new BlenderImporter());
+    out.push_back(new BlenderImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_Q3BSP_IMPORTER)
-    out.push_back( new Q3BSPFileImporter() );
+    out.push_back(new Q3BSPFileImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_NDO_IMPORTER)
-    out.push_back( new NDOImporter() );
+    out.push_back(new NDOImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_IFC_IMPORTER)
-    out.push_back( new IFCImporter() );
+    out.push_back(new IFCImporter());
 #endif
-#if ( !defined ASSIMP_BUILD_NO_XGL_IMPORTER )
-    out.push_back( new XGLImporter() );
+#if (!defined ASSIMP_BUILD_NO_XGL_IMPORTER)
+    out.push_back(new XGLImporter());
 #endif
-#if ( !defined ASSIMP_BUILD_NO_FBX_IMPORTER )
-    out.push_back( new FBXImporter() );
+#if (!defined ASSIMP_BUILD_NO_FBX_IMPORTER)
+    out.push_back(new FBXImporter());
 #endif
-#if ( !defined ASSIMP_BUILD_NO_ASSBIN_IMPORTER )
-    out.push_back( new AssbinImporter() );
+#if (!defined ASSIMP_BUILD_NO_ASSBIN_IMPORTER)
+    out.push_back(new AssbinImporter());
 #endif
-#if ( !defined ASSIMP_BUILD_NO_GLTF_IMPORTER )
-    out.push_back( new glTFImporter() );
-    out.push_back( new glTF2Importer() );
+#if (!defined ASSIMP_BUILD_NO_GLTF_IMPORTER && !defined ASSIMP_BUILD_NO_GLTF1_IMPORTER)
+    out.push_back(new glTFImporter());
 #endif
-#if ( !defined ASSIMP_BUILD_NO_C4D_IMPORTER )
-    out.push_back( new C4DImporter() );
+#if (!defined ASSIMP_BUILD_NO_GLTF_IMPORTER && !defined ASSIMP_BUILD_NO_GLTF2_IMPORTER)
+    out.push_back(new glTF2Importer());
 #endif
-#if ( !defined ASSIMP_BUILD_NO_3MF_IMPORTER )
-    out.push_back( new D3MFImporter() );
+#if (!defined ASSIMP_BUILD_NO_C4D_IMPORTER)
+    out.push_back(new C4DImporter());
+#endif
+#if (!defined ASSIMP_BUILD_NO_3MF_IMPORTER)
+    out.push_back(new D3MFImporter());
 #endif
 #ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
-    out.push_back( new X3DImporter() );
+    out.push_back(new X3DImporter());
 #endif
 #ifndef ASSIMP_BUILD_NO_MMD_IMPORTER
-    out.push_back( new MMDImporter() );
+    out.push_back(new MMDImporter());
 #endif
-#ifndef ASSIMP_BUILD_NO_STEP_IMPORTER
-    out.push_back(new StepFile::StepFileImporter());
+#ifndef ASSIMP_BUILD_NO_IQM_IMPORTER
+    out.push_back(new IQMImporter());
 #endif
+    //#ifndef ASSIMP_BUILD_NO_STEP_IMPORTER
+    //    out.push_back(new StepFile::StepFileImporter());
+    //#endif
 }
 
 /** will delete all registered importers. */
-void DeleteImporterInstanceList(std::vector< BaseImporter* >& deleteList){
-	for(size_t i= 0; i<deleteList.size();++i){
-		delete deleteList[i];
-		deleteList[i]=nullptr;
-	}//for
+void DeleteImporterInstanceList(std::vector<BaseImporter *> &deleteList) {
+    for (size_t i = 0; i < deleteList.size(); ++i) {
+        delete deleteList[i];
+        deleteList[i] = nullptr;
+    } //for
 }
 
 } // namespace Assimp
diff --git a/Engine/lib/assimp/code/Common/PolyTools.h b/Engine/lib/assimp/code/Common/PolyTools.h
index fbbda0e7d..11f627392 100644
--- a/Engine/lib/assimp/code/Common/PolyTools.h
+++ b/Engine/lib/assimp/code/Common/PolyTools.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -42,6 +41,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** @file PolyTools.h, various utilities for our dealings with arbitrary polygons */
 
+#pragma once
 #ifndef AI_POLYTOOLS_H_INCLUDED
 #define AI_POLYTOOLS_H_INCLUDED
 
@@ -55,8 +55,7 @@ namespace Assimp {
  *  The function accepts an unconstrained template parameter for use with
  *  both aiVector3D and aiVector2D, but generally ignores the third coordinate.*/
 template <typename T>
-inline double GetArea2D(const T& v1, const T& v2, const T& v3)
-{
+inline double GetArea2D(const T& v1, const T& v2, const T& v3) {
     return 0.5 * (v1.x * ((double)v3.y - v2.y) + v2.x * ((double)v1.y - v3.y) + v3.x * ((double)v2.y - v1.y));
 }
 
@@ -65,8 +64,7 @@ inline double GetArea2D(const T& v1, const T& v2, const T& v3)
  *  The function accepts an unconstrained template parameter for use with
  *  both aiVector3D and aiVector2D, but generally ignores the third coordinate.*/
 template <typename T>
-inline bool OnLeftSideOfLine2D(const T& p0, const T& p1,const T& p2)
-{
+inline bool OnLeftSideOfLine2D(const T& p0, const T& p1,const T& p2) {
     return GetArea2D(p0,p2,p1) > 0;
 }
 
@@ -75,20 +73,23 @@ inline bool OnLeftSideOfLine2D(const T& p0, const T& p1,const T& p2)
  * The function accepts an unconstrained template parameter for use with
  *  both aiVector3D and aiVector2D, but generally ignores the third coordinate.*/
 template <typename T>
-inline bool PointInTriangle2D(const T& p0, const T& p1,const T& p2, const T& pp)
-{
+inline bool PointInTriangle2D(const T& p0, const T& p1,const T& p2, const T& pp) {
     // Point in triangle test using baryzentric coordinates
     const aiVector2D v0 = p1 - p0;
     const aiVector2D v1 = p2 - p0;
     const aiVector2D v2 = pp - p0;
 
     double dot00 = v0 * v0;
-    double dot01 = v0 * v1;
-    double dot02 = v0 * v2;
     double dot11 = v1 * v1;
-    double dot12 = v1 * v2;
-
-    const double invDenom = 1 / (dot00 * dot11 - dot01 * dot01);
+    const double dot01 = v0 * v1;
+    const double dot02 = v0 * v2;
+    const double dot12 = v1 * v2;
+    const double denom = dot00 * dot11 - dot01 * dot01;
+    if (denom == 0.0) {
+        return false;
+    }
+    
+    const double invDenom = 1.0 / denom;
     dot11 = (dot11 * dot02 - dot01 * dot12) * invDenom;
     dot00 = (dot00 * dot12 - dot01 * dot02) * invDenom;
 
@@ -133,8 +134,7 @@ inline bool IsCCW(T* in, size_t npoints) {
             //      in[i+2].x, in[i+2].y)) {
             convex_turn = AI_MATH_PI_F - theta;
             convex_sum += convex_turn;
-        }
-        else {
+        } else {
             convex_sum -= AI_MATH_PI_F - theta;
         }
     }
@@ -161,15 +161,13 @@ inline bool IsCCW(T* in, size_t npoints) {
     if (OnLeftSideOfLine2D(in[npoints-2],in[1],in[0])) {
         convex_turn = AI_MATH_PI_F - theta;
         convex_sum += convex_turn;
-    }
-    else {
+    } else {
         convex_sum -= AI_MATH_PI_F - theta;
     }
 
     return convex_sum >= (2 * AI_MATH_PI_F);
 }
 
-
 // -------------------------------------------------------------------------------
 /** Compute the normal of an arbitrary polygon in R3.
  *
@@ -186,8 +184,7 @@ inline bool IsCCW(T* in, size_t npoints) {
  *  this method is much faster than the 'other' NewellNormal()
  */
 template <int ofs_x, int ofs_y, int ofs_z, typename TReal>
-inline void NewellNormal (aiVector3t<TReal>& out, int num, TReal* x, TReal* y, TReal* z)
-{
+inline void NewellNormal (aiVector3t<TReal>& out, int num, TReal* x, TReal* y, TReal* z) {
     // Duplicate the first two vertices at the end
     x[(num+0)*ofs_x] = x[0];
     x[(num+1)*ofs_x] = x[ofs_x];
@@ -224,6 +221,6 @@ inline void NewellNormal (aiVector3t<TReal>& out, int num, TReal* x, TReal* y, T
     out = aiVector3t<TReal>(sum_yz,sum_zx,sum_xy);
 }
 
-} // ! Assimp
+} // ! namespace Assimp
 
-#endif
+#endif // AI_POLYTOOLS_H_INCLUDED
diff --git a/Engine/lib/assimp/code/Common/PostStepRegistry.cpp b/Engine/lib/assimp/code/Common/PostStepRegistry.cpp
index ef58f8ddf..de4f39083 100644
--- a/Engine/lib/assimp/code/Common/PostStepRegistry.cpp
+++ b/Engine/lib/assimp/code/Common/PostStepRegistry.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -123,7 +123,7 @@ corresponding preprocessor flag to selectively disable steps.
 #   include "PostProcessing/OptimizeGraph.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_SPLITBYBONECOUNT_PROCESS
-#   include "Common/SplitByBoneCountProcess.h"
+#   include "PostProcessing/SplitByBoneCountProcess.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_DEBONE_PROCESS
 #   include "PostProcessing/DeboneProcess.h"
@@ -131,11 +131,15 @@ corresponding preprocessor flag to selectively disable steps.
 #if (!defined ASSIMP_BUILD_NO_GLOBALSCALE_PROCESS)
 #   include "PostProcessing/ScaleProcess.h"
 #endif
+#if (!defined ASSIMP_BUILD_NO_ARMATUREPOPULATE_PROCESS)
+#   include "PostProcessing/ArmaturePopulate.h"
+#endif
 #if (!defined ASSIMP_BUILD_NO_GENBOUNDINGBOXES_PROCESS)
 #   include "PostProcessing/GenBoundingBoxesProcess.h"
 #endif
 
 
+
 namespace Assimp {
 
 // ------------------------------------------------------------------------------------------------
@@ -180,6 +184,9 @@ void GetPostProcessingStepInstanceList(std::vector< BaseProcess* >& out)
 #if (!defined ASSIMP_BUILD_NO_GLOBALSCALE_PROCESS)
     out.push_back( new ScaleProcess());
 #endif
+#if (!defined ASSIMP_BUILD_NO_ARMATUREPOPULATE_PROCESS)
+    out.push_back( new ArmaturePopulate());
+#endif
 #if (!defined ASSIMP_BUILD_NO_PRETRANSFORMVERTICES_PROCESS)
     out.push_back( new PretransformVertices());
 #endif
diff --git a/Engine/lib/assimp/code/Common/RemoveComments.cpp b/Engine/lib/assimp/code/Common/RemoveComments.cpp
index 91700a769..4fae21c95 100644
--- a/Engine/lib/assimp/code/Common/RemoveComments.cpp
+++ b/Engine/lib/assimp/code/Common/RemoveComments.cpp
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -40,69 +39,78 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
-/** @file  RemoveComments.cpp
+/** 
+ *  @file  RemoveComments.cpp
  *  @brief Defines the CommentRemover utility class
  */
 
 #include <assimp/RemoveComments.h>
 #include <assimp/ParsingUtils.h>
 
-namespace Assimp    {
+namespace Assimp {
 
 // ------------------------------------------------------------------------------------------------
 // Remove line comments from a file
-void CommentRemover::RemoveLineComments(const char* szComment,
-    char* szBuffer, char chReplacement /* = ' ' */)
-{
+void CommentRemover::RemoveLineComments(const char* szComment, char* szBuffer, char chReplacement /* = ' ' */) {
     // validate parameters
-    ai_assert(NULL != szComment && NULL != szBuffer && *szComment);
+    ai_assert(nullptr != szComment);
+    ai_assert(nullptr != szBuffer);
+    ai_assert(*szComment);
 
-    const size_t len = strlen(szComment);
-    while (*szBuffer)   {
+    size_t len = strlen(szComment);
+    const size_t lenBuffer = strlen(szBuffer);
+    if (len > lenBuffer) {
+        len = lenBuffer;
+    }
 
+    for(size_t i = 0; i < lenBuffer; i++) {
         // skip over quotes
-        if (*szBuffer == '\"' || *szBuffer == '\'')
-            while (*szBuffer++ && *szBuffer != '\"' && *szBuffer != '\'');
+        if (szBuffer[i] == '\"' || szBuffer[i] == '\'')
+            while (++i < lenBuffer && szBuffer[i] != '\"' && szBuffer[i] != '\'');
 
-        if (!strncmp(szBuffer,szComment,len)) {
-            while (!IsLineEnd(*szBuffer))
-                *szBuffer++ = chReplacement;
+        if(lenBuffer - i < len) {
+            break;
+        }
 
-            if (!*szBuffer) {
-                break;
+        if (!strncmp(szBuffer + i,szComment,len)) {
+            while (i < lenBuffer && !IsLineEnd(szBuffer[i])) {
+                szBuffer[i++] = chReplacement;
             }
         }
-        ++szBuffer;
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Remove multi-line comments from a file
 void CommentRemover::RemoveMultiLineComments(const char* szCommentStart,
-    const char* szCommentEnd,char* szBuffer,
-    char chReplacement)
-{
+        const char* szCommentEnd,char* szBuffer,
+        char chReplacement) {
     // validate parameters
-    ai_assert(NULL != szCommentStart && NULL != szCommentEnd &&
-        NULL != szBuffer && *szCommentStart && *szCommentEnd);
+    ai_assert(nullptr != szCommentStart);
+    ai_assert(nullptr != szCommentEnd);
+    ai_assert(nullptr != szBuffer);
+    ai_assert(*szCommentStart);
+    ai_assert(*szCommentEnd);
 
     const size_t len  = strlen(szCommentEnd);
     const size_t len2 = strlen(szCommentStart);
 
     while (*szBuffer)   {
         // skip over quotes
-        if (*szBuffer == '\"' || *szBuffer == '\'')
+        if (*szBuffer == '\"' || *szBuffer == '\'') {
             while (*szBuffer++ && *szBuffer != '\"' && *szBuffer != '\'');
+        }
 
         if (!strncmp(szBuffer,szCommentStart,len2))  {
             while (*szBuffer) {
                 if (!::strncmp(szBuffer,szCommentEnd,len)) {
-                    for (unsigned int i = 0; i < len;++i)
+                    for (unsigned int i = 0; i < len;++i) {
                         *szBuffer++ = chReplacement;
+                    }
 
                     break;
                 }
-            *szBuffer++ = chReplacement;
+                *szBuffer++ = chReplacement;
             }
             continue;
         }
diff --git a/Engine/lib/assimp/code/Common/SGSpatialSort.cpp b/Engine/lib/assimp/code/Common/SGSpatialSort.cpp
index 120070b0a..0d16d6fe8 100644
--- a/Engine/lib/assimp/code/Common/SGSpatialSort.cpp
+++ b/Engine/lib/assimp/code/Common/SGSpatialSort.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -52,7 +52,7 @@ using namespace Assimp;
 // ------------------------------------------------------------------------------------------------
 SGSpatialSort::SGSpatialSort()
 {
-    // define the reference plane. We choose some arbitrary vector away from all basic axises
+    // define the reference plane. We choose some arbitrary vector away from all basic axes
     // in the hope that no model spreads all its vertices along this plane.
     mPlaneNormal.Set( 0.8523f, 0.34321f, 0.5736f);
     mPlaneNormal.Normalize();
@@ -121,7 +121,7 @@ void SGSpatialSort::FindPositions( const aiVector3D& pPosition,
         index++;
 
     // Mow start iterating from there until the first position lays outside of the distance range.
-    // Add all positions inside the distance range within the given radius to the result aray
+    // Add all positions inside the distance range within the given radius to the result array
 
     float squareEpsilon = pRadius * pRadius;
     std::vector<Entry>::const_iterator it  = mPositions.begin() + index;
diff --git a/Engine/lib/assimp/code/Common/SceneCombiner.cpp b/Engine/lib/assimp/code/Common/SceneCombiner.cpp
index 4e6bc5b47..2c2539e54 100644
--- a/Engine/lib/assimp/code/Common/SceneCombiner.cpp
+++ b/Engine/lib/assimp/code/Common/SceneCombiner.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -45,44 +45,48 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // possible as new fields are added to assimp structures.
 
 // ----------------------------------------------------------------------------
-/** 
+/**
   * @file Implements Assimp::SceneCombiner. This is a smart utility
   *       class that combines multiple scenes, meshes, ... into one. Currently
   *       these utilities are used by the IRR and LWS loaders and the
   *       OptimizeGraph step.
   */
 // ----------------------------------------------------------------------------
+#include "ScenePrivate.h"
+#include "time.h"
+#include <assimp/Hash.h>
 #include <assimp/SceneCombiner.h>
 #include <assimp/StringUtils.h>
 #include <assimp/fast_atof.h>
-#include <assimp/metadata.h>
-#include <assimp/Hash.h>
-#include "time.h"
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/scene.h>
 #include <assimp/mesh.h>
+#include <assimp/metadata.h>
+#include <assimp/scene.h>
 #include <stdio.h>
-#include "ScenePrivate.h"
+#include <assimp/DefaultLogger.hpp>
 
 namespace Assimp {
 
+#if (__GNUC__ >= 8 && __GNUC_MINOR__ >= 0)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wclass-memaccess"
+#endif
+
 // ------------------------------------------------------------------------------------------------
 // Add a prefix to a string
-inline
-void PrefixString(aiString& string,const char* prefix, unsigned int len) {
+inline void PrefixString(aiString &string, const char *prefix, unsigned int len) {
     // If the string is already prefixed, we won't prefix it a second time
     if (string.length >= 1 && string.data[0] == '$')
         return;
 
-    if (len+string.length>=MAXLEN-1) {
-        ASSIMP_LOG_DEBUG("Can't add an unique prefix because the string is too long");
+    if (len + string.length >= MAXLEN - 1) {
+        ASSIMP_LOG_VERBOSE_DEBUG("Can't add an unique prefix because the string is too long");
         ai_assert(false);
         return;
     }
 
     // Add the prefix
-    ::memmove(string.data+len,string.data,string.length+1);
-    ::memcpy (string.data, prefix, len);
+    ::memmove(string.data + len, string.data, string.length + 1);
+    ::memcpy(string.data, prefix, len);
 
     // And update the string's length
     string.length += len;
@@ -90,33 +94,35 @@ void PrefixString(aiString& string,const char* prefix, unsigned int len) {
 
 // ------------------------------------------------------------------------------------------------
 // Add node identifiers to a hashing set
-void SceneCombiner::AddNodeHashes(aiNode* node, std::set<unsigned int>& hashes) {
+void SceneCombiner::AddNodeHashes(aiNode *node, std::set<unsigned int> &hashes) {
     // Add node name to hashing set if it is non-empty - empty nodes are allowed
     // and they can't have any anims assigned so its absolutely safe to duplicate them.
     if (node->mName.length) {
-        hashes.insert( SuperFastHash(node->mName.data, static_cast<uint32_t>(node->mName.length)) );
+        hashes.insert(SuperFastHash(node->mName.data, static_cast<uint32_t>(node->mName.length)));
     }
 
     // Process all children recursively
-    for (unsigned int i = 0; i < node->mNumChildren;++i)
-        AddNodeHashes(node->mChildren[i],hashes);
+    for (unsigned int i = 0; i < node->mNumChildren; ++i) {
+        AddNodeHashes(node->mChildren[i], hashes);
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Add a name prefix to all nodes in a hierarchy
-void SceneCombiner::AddNodePrefixes(aiNode* node, const char* prefix, unsigned int len) {
-    ai_assert(NULL != prefix);
-    PrefixString(node->mName,prefix,len);
+void SceneCombiner::AddNodePrefixes(aiNode *node, const char *prefix, unsigned int len) {
+    ai_assert(nullptr != prefix);
+
+    PrefixString(node->mName, prefix, len);
 
     // Process all children recursively
-    for ( unsigned int i = 0; i < node->mNumChildren; ++i ) {
-        AddNodePrefixes( node->mChildren[ i ], prefix, len );
+    for (unsigned int i = 0; i < node->mNumChildren; ++i) {
+        AddNodePrefixes(node->mChildren[i], prefix, len);
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Search for matching names
-bool SceneCombiner::FindNameMatch(const aiString& name, std::vector<SceneHelper>& input, unsigned int cur) {
+bool SceneCombiner::FindNameMatch(const aiString &name, std::vector<SceneHelper> &input, unsigned int cur) {
     const unsigned int hash = SuperFastHash(name.data, static_cast<uint32_t>(name.length));
 
     // Check whether we find a positive match in one of the given sets
@@ -130,87 +136,91 @@ bool SceneCombiner::FindNameMatch(const aiString& name, std::vector<SceneHelper>
 
 // ------------------------------------------------------------------------------------------------
 // Add a name prefix to all nodes in a hierarchy if a hash match is found
-void SceneCombiner::AddNodePrefixesChecked(aiNode* node, const char* prefix, unsigned int len,
-        std::vector<SceneHelper>& input, unsigned int cur) {
-    ai_assert(NULL != prefix);
+void SceneCombiner::AddNodePrefixesChecked(aiNode *node, const char *prefix, unsigned int len,
+        std::vector<SceneHelper> &input, unsigned int cur) {
+    ai_assert(nullptr != prefix);
+
     const unsigned int hash = SuperFastHash(node->mName.data, static_cast<uint32_t>(node->mName.length));
 
     // Check whether we find a positive match in one of the given sets
     for (unsigned int i = 0; i < input.size(); ++i) {
         if (cur != i && input[i].hashes.find(hash) != input[i].hashes.end()) {
-            PrefixString(node->mName,prefix,len);
+            PrefixString(node->mName, prefix, len);
             break;
         }
     }
 
     // Process all children recursively
-    for (unsigned int i = 0; i < node->mNumChildren;++i)
-        AddNodePrefixesChecked(node->mChildren[i],prefix,len,input,cur);
+    for (unsigned int i = 0; i < node->mNumChildren; ++i) {
+        AddNodePrefixesChecked(node->mChildren[i], prefix, len, input, cur);
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Add an offset to all mesh indices in a node graph
-void SceneCombiner::OffsetNodeMeshIndices (aiNode* node, unsigned int offset) {
-    for (unsigned int i = 0; i < node->mNumMeshes;++i)
+void SceneCombiner::OffsetNodeMeshIndices(aiNode *node, unsigned int offset) {
+    for (unsigned int i = 0; i < node->mNumMeshes; ++i)
         node->mMeshes[i] += offset;
 
-    for ( unsigned int i = 0; i < node->mNumChildren; ++i ) {
-        OffsetNodeMeshIndices( node->mChildren[ i ], offset );
+    for (unsigned int i = 0; i < node->mNumChildren; ++i) {
+        OffsetNodeMeshIndices(node->mChildren[i], offset);
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Merges two scenes. Currently only used by the LWS loader.
-void SceneCombiner::MergeScenes(aiScene** _dest,std::vector<aiScene*>& src, unsigned int flags) {
-    if ( nullptr == _dest ) {
+void SceneCombiner::MergeScenes(aiScene **_dest, std::vector<aiScene *> &src, unsigned int flags) {
+    if (nullptr == _dest) {
         return;
     }
 
-    // if _dest points to NULL allocate a new scene. Otherwise clear the old and reuse it
+    // if _dest points to nullptr allocate a new scene. Otherwise clear the old and reuse it
     if (src.empty()) {
         if (*_dest) {
             (*_dest)->~aiScene();
-            SceneCombiner::CopySceneFlat(_dest,src[0]);
-        }
-        else *_dest = src[0];
+            SceneCombiner::CopySceneFlat(_dest, src[0]);
+        } else
+            *_dest = src[0];
         return;
     }
-    if (*_dest)(*_dest)->~aiScene();
-    else *_dest = new aiScene();
+    if (*_dest) {
+        (*_dest)->~aiScene();
+        new (*_dest) aiScene();
+    } else
+        *_dest = new aiScene();
 
     // Create a dummy scene to serve as master for the others
-    aiScene* master = new aiScene();
+    aiScene *master = new aiScene();
     master->mRootNode = new aiNode();
     master->mRootNode->mName.Set("<MergeRoot>");
 
-    std::vector<AttachmentInfo> srcList (src.size());
-    for (unsigned int i = 0; i < srcList.size();++i)    {
-        srcList[i] = AttachmentInfo(src[i],master->mRootNode);
+    std::vector<AttachmentInfo> srcList(src.size());
+    for (unsigned int i = 0; i < srcList.size(); ++i) {
+        srcList[i] = AttachmentInfo(src[i], master->mRootNode);
     }
 
     // 'master' will be deleted afterwards
-    MergeScenes (_dest, master, srcList, flags);
+    MergeScenes(_dest, master, srcList, flags);
 }
 
 // ------------------------------------------------------------------------------------------------
-void SceneCombiner::AttachToGraph (aiNode* attach, std::vector<NodeAttachmentInfo>& srcList) {
+void SceneCombiner::AttachToGraph(aiNode *attach, std::vector<NodeAttachmentInfo> &srcList) {
     unsigned int cnt;
-    for ( cnt = 0; cnt < attach->mNumChildren; ++cnt ) {
-        AttachToGraph( attach->mChildren[ cnt ], srcList );
+    for (cnt = 0; cnt < attach->mNumChildren; ++cnt) {
+        AttachToGraph(attach->mChildren[cnt], srcList);
     }
 
     cnt = 0;
     for (std::vector<NodeAttachmentInfo>::iterator it = srcList.begin();
-         it != srcList.end(); ++it)
-    {
+            it != srcList.end(); ++it) {
         if ((*it).attachToNode == attach && !(*it).resolved)
             ++cnt;
     }
 
-    if (cnt)    {
-        aiNode** n = new aiNode*[cnt+attach->mNumChildren];
-        if (attach->mNumChildren)   {
-            ::memcpy(n,attach->mChildren,sizeof(void*)*attach->mNumChildren);
+    if (cnt) {
+        aiNode **n = new aiNode *[cnt + attach->mNumChildren];
+        if (attach->mNumChildren) {
+            ::memcpy(n, attach->mChildren, sizeof(void *) * attach->mNumChildren);
             delete[] attach->mChildren;
         }
         attach->mChildren = n;
@@ -218,9 +228,9 @@ void SceneCombiner::AttachToGraph (aiNode* attach, std::vector<NodeAttachmentInf
         n += attach->mNumChildren;
         attach->mNumChildren += cnt;
 
-        for (unsigned int i = 0; i < srcList.size();++i)    {
-            NodeAttachmentInfo& att = srcList[i];
-            if (att.attachToNode == attach && !att.resolved)    {
+        for (unsigned int i = 0; i < srcList.size(); ++i) {
+            NodeAttachmentInfo &att = srcList[i];
+            if (att.attachToNode == attach && !att.resolved) {
                 *n = att.node;
                 (**n).mParent = attach;
                 ++n;
@@ -233,53 +243,54 @@ void SceneCombiner::AttachToGraph (aiNode* attach, std::vector<NodeAttachmentInf
 }
 
 // ------------------------------------------------------------------------------------------------
-void SceneCombiner::AttachToGraph ( aiScene* master, std::vector<NodeAttachmentInfo>& src) {
-    ai_assert(NULL != master);
-    AttachToGraph(master->mRootNode,src);
+void SceneCombiner::AttachToGraph(aiScene *master, std::vector<NodeAttachmentInfo> &src) {
+    ai_assert(nullptr != master);
+
+    AttachToGraph(master->mRootNode, src);
 }
 
 // ------------------------------------------------------------------------------------------------
-void SceneCombiner::MergeScenes(aiScene** _dest, aiScene* master, std::vector<AttachmentInfo>& srcList, unsigned int flags) {
-    if ( nullptr == _dest ) {
+void SceneCombiner::MergeScenes(aiScene **_dest, aiScene *master, std::vector<AttachmentInfo> &srcList, unsigned int flags) {
+    if (nullptr == _dest) {
         return;
     }
 
-    // if _dest points to NULL allocate a new scene. Otherwise clear the old and reuse it
-    if (srcList.empty())    {
+    // if _dest points to nullptr allocate a new scene. Otherwise clear the old and reuse it
+    if (srcList.empty()) {
         if (*_dest) {
-            SceneCombiner::CopySceneFlat(_dest,master);
-        }
-        else *_dest = master;
+            SceneCombiner::CopySceneFlat(_dest, master);
+        } else
+            *_dest = master;
         return;
     }
     if (*_dest) {
         (*_dest)->~aiScene();
         new (*_dest) aiScene();
-    }
-    else *_dest = new aiScene();
+    } else
+        *_dest = new aiScene();
 
-    aiScene* dest = *_dest;
+    aiScene *dest = *_dest;
 
-    std::vector<SceneHelper> src (srcList.size()+1);
+    std::vector<SceneHelper> src(srcList.size() + 1);
     src[0].scene = master;
-    for (unsigned int i = 0; i < srcList.size();++i)    {
-        src[i+1] = SceneHelper( srcList[i].scene );
+    for (unsigned int i = 0; i < srcList.size(); ++i) {
+        src[i + 1] = SceneHelper(srcList[i].scene);
     }
 
     // this helper array specifies which scenes are duplicates of others
-    std::vector<unsigned int> duplicates(src.size(),UINT_MAX);
+    std::vector<unsigned int> duplicates(src.size(), UINT_MAX);
 
     // this helper array is used as lookup table several times
     std::vector<unsigned int> offset(src.size());
 
     // Find duplicate scenes
-    for (unsigned int i = 0; i < src.size();++i) {
+    for (unsigned int i = 0; i < src.size(); ++i) {
         if (duplicates[i] != i && duplicates[i] != UINT_MAX) {
             continue;
         }
 
         duplicates[i] = i;
-        for ( unsigned int a = i+1; a < src.size(); ++a)    {
+        for (unsigned int a = i + 1; a < src.size(); ++a) {
             if (src[i].scene == src[a].scene) {
                 duplicates[a] = i;
             }
@@ -287,16 +298,14 @@ void SceneCombiner::MergeScenes(aiScene** _dest, aiScene* master, std::vector<At
     }
 
     // Generate unique names for all named stuff?
-    if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES)
-    {
+    if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES) {
 #if 0
         // Construct a proper random number generator
         boost::mt19937 rng(  );
         boost::uniform_int<> dist(1u,1 << 24u);
         boost::variate_generator<boost::mt19937&, boost::uniform_int<> > rndGen(rng, dist);
 #endif
-        for (unsigned int i = 1; i < src.size();++i)
-        {
+        for (unsigned int i = 1; i < src.size(); ++i) {
             //if (i != duplicates[i])
             //{
             //  // duplicate scenes share the same UID
@@ -306,7 +315,7 @@ void SceneCombiner::MergeScenes(aiScene** _dest, aiScene* master, std::vector<At
             //  continue;
             //}
 
-            src[i].idlen = ai_snprintf(src[i].id, 32, "$%.6X$_",i);
+            src[i].idlen = ai_snprintf(src[i].id, 32, "$%.6X$_", i);
 
             if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY) {
 
@@ -314,11 +323,11 @@ void SceneCombiner::MergeScenes(aiScene** _dest, aiScene* master, std::vector<At
                 // in a sorted table (for convenience I'm using std::set). We hash
                 // just the node and animation channel names, all identifiers except
                 // the material names should be caught by doing this.
-                AddNodeHashes(src[i]->mRootNode,src[i].hashes);
+                AddNodeHashes(src[i]->mRootNode, src[i].hashes);
 
-                for (unsigned int a = 0; a < src[i]->mNumAnimations;++a) {
-                    aiAnimation* anim = src[i]->mAnimations[a];
-                    src[i].hashes.insert(SuperFastHash(anim->mName.data,static_cast<uint32_t>(anim->mName.length)));
+                for (unsigned int a = 0; a < src[i]->mNumAnimations; ++a) {
+                    aiAnimation *anim = src[i]->mAnimations[a];
+                    src[i].hashes.insert(SuperFastHash(anim->mName.data, static_cast<uint32_t>(anim->mName.length)));
                 }
             }
         }
@@ -327,18 +336,17 @@ void SceneCombiner::MergeScenes(aiScene** _dest, aiScene* master, std::vector<At
     unsigned int cnt;
 
     // First find out how large the respective output arrays must be
-    for ( unsigned int n = 0; n < src.size();++n )
-    {
-        SceneHelper* cur = &src[n];
+    for (unsigned int n = 0; n < src.size(); ++n) {
+        SceneHelper *cur = &src[n];
 
-        if (n == duplicates[n] || flags & AI_INT_MERGE_SCENE_DUPLICATES_DEEP_CPY)   {
-            dest->mNumTextures   += (*cur)->mNumTextures;
-            dest->mNumMaterials  += (*cur)->mNumMaterials;
-            dest->mNumMeshes     += (*cur)->mNumMeshes;
+        if (n == duplicates[n] || flags & AI_INT_MERGE_SCENE_DUPLICATES_DEEP_CPY) {
+            dest->mNumTextures += (*cur)->mNumTextures;
+            dest->mNumMaterials += (*cur)->mNumMaterials;
+            dest->mNumMeshes += (*cur)->mNumMeshes;
         }
 
-        dest->mNumLights     += (*cur)->mNumLights;
-        dest->mNumCameras    += (*cur)->mNumCameras;
+        dest->mNumLights += (*cur)->mNumLights;
+        dest->mNumCameras += (*cur)->mNumCameras;
         dest->mNumAnimations += (*cur)->mNumAnimations;
 
         // Combine the flags of all scenes
@@ -350,23 +358,20 @@ void SceneCombiner::MergeScenes(aiScene** _dest, aiScene* master, std::vector<At
     }
 
     // generate the output texture list + an offset table for all texture indices
-    if (dest->mNumTextures)
-    {
-        aiTexture** pip = dest->mTextures = new aiTexture*[dest->mNumMaterials];
+    if (dest->mNumTextures) {
+        aiTexture **pip = dest->mTextures = new aiTexture *[dest->mNumTextures];
         cnt = 0;
-        for ( unsigned int n = 0; n < src.size();++n )
-        {
-            SceneHelper* cur = &src[n];
-            for (unsigned int i = 0; i < (*cur)->mNumTextures;++i)
-            {
-                if (n != duplicates[n])
-                {
-                    if ( flags & AI_INT_MERGE_SCENE_DUPLICATES_DEEP_CPY)
-                        Copy(pip,(*cur)->mTextures[i]);
+        for (unsigned int n = 0; n < src.size(); ++n) {
+            SceneHelper *cur = &src[n];
+            for (unsigned int i = 0; i < (*cur)->mNumTextures; ++i) {
+                if (n != duplicates[n]) {
+                    if (flags & AI_INT_MERGE_SCENE_DUPLICATES_DEEP_CPY)
+                        Copy(pip, (*cur)->mTextures[i]);
 
-                    else continue;
-                }
-                else *pip = (*cur)->mTextures[i];
+                    else
+                        continue;
+                } else
+                    *pip = (*cur)->mTextures[i];
                 ++pip;
             }
 
@@ -376,47 +381,56 @@ void SceneCombiner::MergeScenes(aiScene** _dest, aiScene* master, std::vector<At
     }
 
     // generate the output material list + an offset table for all material indices
-    if (dest->mNumMaterials)
-    {
-        aiMaterial** pip = dest->mMaterials = new aiMaterial*[dest->mNumMaterials];
+    if (dest->mNumMaterials) {
+        aiMaterial **pip = dest->mMaterials = new aiMaterial *[dest->mNumMaterials];
         cnt = 0;
-        for ( unsigned int n = 0; n < src.size();++n )  {
-            SceneHelper* cur = &src[n];
-            for (unsigned int i = 0; i < (*cur)->mNumMaterials;++i)
-            {
-                if (n != duplicates[n])
-                {
-                    if ( flags & AI_INT_MERGE_SCENE_DUPLICATES_DEEP_CPY)
-                        Copy(pip,(*cur)->mMaterials[i]);
+        for (unsigned int n = 0; n < src.size(); ++n) {
+            SceneHelper *cur = &src[n];
+            for (unsigned int i = 0; i < (*cur)->mNumMaterials; ++i) {
+                if (n != duplicates[n]) {
+                    if (flags & AI_INT_MERGE_SCENE_DUPLICATES_DEEP_CPY)
+                        Copy(pip, (*cur)->mMaterials[i]);
 
-                    else continue;
-                }
-                else *pip = (*cur)->mMaterials[i];
+                    else
+                        continue;
+                } else
+                    *pip = (*cur)->mMaterials[i];
 
-                if ((*cur)->mNumTextures != dest->mNumTextures)     {
+                if ((*cur)->mNumTextures != dest->mNumTextures) {
                     // We need to update all texture indices of the mesh. So we need to search for
                     // a material property called '$tex.file'
 
-                    for (unsigned int a = 0; a < (*pip)->mNumProperties;++a)
-                    {
-                        aiMaterialProperty* prop = (*pip)->mProperties[a];
-                        if (!strncmp(prop->mKey.data,"$tex.file",9))
-                        {
+                    for (unsigned int a = 0; a < (*pip)->mNumProperties; ++a) {
+                        aiMaterialProperty *prop = (*pip)->mProperties[a];
+                        if (!strncmp(prop->mKey.data, "$tex.file", 9)) {
                             // Check whether this texture is an embedded texture.
                             // In this case the property looks like this: *<n>,
                             // where n is the index of the texture.
-                            aiString& s = *((aiString*)prop->mData);
-                            if ('*' == s.data[0])   {
+                            // Copy here because we overwrite the string data in-place and the buffer inside of aiString
+                            // will be a lie if we just reinterpret from prop->mData. The size of mData is not guaranteed to be
+                            // MAXLEN in size.
+                            aiString s(*(aiString *)prop->mData);
+                            if ('*' == s.data[0]) {
                                 // Offset the index and write it back ..
                                 const unsigned int idx = strtoul10(&s.data[1]) + offset[n];
-                                ASSIMP_itoa10(&s.data[1],sizeof(s.data)-1,idx);
+                                const unsigned int oldLen = s.length;
+
+                                s.length = 1 + ASSIMP_itoa10(&s.data[1], sizeof(s.data) - 1, idx);
+
+                                // The string changed in size so we need to reallocate the buffer for the property.
+                                if (oldLen < s.length) {
+                                    prop->mDataLength += s.length - oldLen;
+                                    delete[] prop->mData;
+                                    prop->mData = new char[prop->mDataLength];
+                                }
+
+                                memcpy(prop->mData, static_cast<void*>(&s), prop->mDataLength);
                             }
                         }
 
                         // Need to generate new, unique material names?
-                        else if (!::strcmp( prop->mKey.data,"$mat.name" ) && flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_MATNAMES)
-                        {
-                            aiString* pcSrc = (aiString*) prop->mData;
+                        else if (!::strcmp(prop->mKey.data, "$mat.name") && flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_MATNAMES) {
+                            aiString *pcSrc = (aiString *)prop->mData;
                             PrefixString(*pcSrc, (*cur).id, (*cur).idlen);
                         }
                     }
@@ -430,25 +444,23 @@ void SceneCombiner::MergeScenes(aiScene** _dest, aiScene* master, std::vector<At
     }
 
     // generate the output mesh list + again an offset table for all mesh indices
-    if (dest->mNumMeshes)
-    {
-        aiMesh** pip = dest->mMeshes = new aiMesh*[dest->mNumMeshes];
+    if (dest->mNumMeshes) {
+        aiMesh **pip = dest->mMeshes = new aiMesh *[dest->mNumMeshes];
         cnt = 0;
-        for ( unsigned int n = 0; n < src.size();++n )
-        {
-            SceneHelper* cur = &src[n];
-            for (unsigned int i = 0; i < (*cur)->mNumMeshes;++i)
-            {
+        for (unsigned int n = 0; n < src.size(); ++n) {
+            SceneHelper *cur = &src[n];
+            for (unsigned int i = 0; i < (*cur)->mNumMeshes; ++i) {
                 if (n != duplicates[n]) {
-                    if ( flags & AI_INT_MERGE_SCENE_DUPLICATES_DEEP_CPY)
+                    if (flags & AI_INT_MERGE_SCENE_DUPLICATES_DEEP_CPY)
                         Copy(pip, (*cur)->mMeshes[i]);
 
-                    else continue;
-                }
-                else *pip = (*cur)->mMeshes[i];
+                    else
+                        continue;
+                } else
+                    *pip = (*cur)->mMeshes[i];
 
                 // update the material index of the mesh
-                (*pip)->mMaterialIndex +=  offset[n];
+                (*pip)->mMaterialIndex += offset[n];
                 ++pip;
             }
 
@@ -458,7 +470,7 @@ void SceneCombiner::MergeScenes(aiScene** _dest, aiScene* master, std::vector<At
         }
     }
 
-    std::vector <NodeAttachmentInfo> nodes;
+    std::vector<NodeAttachmentInfo> nodes;
     nodes.reserve(srcList.size());
 
     // ----------------------------------------------------------------------------
@@ -471,180 +483,179 @@ void SceneCombiner::MergeScenes(aiScene** _dest, aiScene* master, std::vector<At
     // ----------------------------------------------------------------------------
 
     // Allocate space for light sources, cameras and animations
-    aiLight** ppLights = dest->mLights = (dest->mNumLights
-        ? new aiLight*[dest->mNumLights] : NULL);
+    aiLight **ppLights = dest->mLights = (dest->mNumLights ? new aiLight *[dest->mNumLights] : nullptr);
 
-    aiCamera** ppCameras = dest->mCameras = (dest->mNumCameras
-        ? new aiCamera*[dest->mNumCameras] : NULL);
+    aiCamera **ppCameras = dest->mCameras = (dest->mNumCameras ? new aiCamera *[dest->mNumCameras] : nullptr);
 
-    aiAnimation** ppAnims = dest->mAnimations = (dest->mNumAnimations
-        ? new aiAnimation*[dest->mNumAnimations] : NULL);
+    aiAnimation **ppAnims = dest->mAnimations = (dest->mNumAnimations ? new aiAnimation *[dest->mNumAnimations] : nullptr);
 
-    for ( int n = static_cast<int>(src.size()-1); n >= 0 ;--n ) /* !!! important !!! */
+    for (int n = static_cast<int>(src.size() - 1); n >= 0; --n) /* !!! important !!! */
     {
-        SceneHelper* cur = &src[n];
-        aiNode* node;
+        SceneHelper *cur = &src[n];
+        aiNode *node;
 
         // To offset or not to offset, this is the question
-        if (n != (int)duplicates[n])
-        {
+        if (n != (int)duplicates[n]) {
             // Get full scene-graph copy
-            Copy( &node, (*cur)->mRootNode );
-            OffsetNodeMeshIndices(node,offset[duplicates[n]]);
+            Copy(&node, (*cur)->mRootNode);
+            OffsetNodeMeshIndices(node, offset[duplicates[n]]);
 
             if (flags & AI_INT_MERGE_SCENE_DUPLICATES_DEEP_CPY) {
                 // (note:) they are already 'offseted' by offset[duplicates[n]]
-                OffsetNodeMeshIndices(node,offset[n] - offset[duplicates[n]]);
+                OffsetNodeMeshIndices(node, offset[n] - offset[duplicates[n]]);
             }
-        }
-        else // if (n == duplicates[n])
+        } else // if (n == duplicates[n])
         {
             node = (*cur)->mRootNode;
-            OffsetNodeMeshIndices(node,offset[n]);
+            OffsetNodeMeshIndices(node, offset[n]);
         }
         if (n) // src[0] is the master node
-            nodes.push_back(NodeAttachmentInfo( node,srcList[n-1].attachToNode,n ));
+            nodes.push_back(NodeAttachmentInfo(node, srcList[n - 1].attachToNode, n));
 
         // add name prefixes?
         if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES) {
 
             // or the whole scenegraph
             if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY) {
-                AddNodePrefixesChecked(node,(*cur).id,(*cur).idlen,src,n);
-            }
-            else AddNodePrefixes(node,(*cur).id,(*cur).idlen);
+                AddNodePrefixesChecked(node, (*cur).id, (*cur).idlen, src, n);
+            } else
+                AddNodePrefixes(node, (*cur).id, (*cur).idlen);
 
             // meshes
-            for (unsigned int i = 0; i < (*cur)->mNumMeshes;++i)    {
-                aiMesh* mesh = (*cur)->mMeshes[i];
+            for (unsigned int i = 0; i < (*cur)->mNumMeshes; ++i) {
+                aiMesh *mesh = (*cur)->mMeshes[i];
 
                 // rename all bones
-                for (unsigned int a = 0; a < mesh->mNumBones;++a)   {
+                for (unsigned int a = 0; a < mesh->mNumBones; ++a) {
                     if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY) {
-                        if (!FindNameMatch(mesh->mBones[a]->mName,src,n))
+                        if (!FindNameMatch(mesh->mBones[a]->mName, src, n))
                             continue;
                     }
-                    PrefixString(mesh->mBones[a]->mName,(*cur).id,(*cur).idlen);
+                    PrefixString(mesh->mBones[a]->mName, (*cur).id, (*cur).idlen);
                 }
             }
         }
 
         // --------------------------------------------------------------------
         // Copy light sources
-        for (unsigned int i = 0; i < (*cur)->mNumLights;++i,++ppLights)
-        {
+        for (unsigned int i = 0; i < (*cur)->mNumLights; ++i, ++ppLights) {
             if (n != (int)duplicates[n]) // duplicate scene?
             {
                 Copy(ppLights, (*cur)->mLights[i]);
-            }
-            else *ppLights = (*cur)->mLights[i];
-
+            } else
+                *ppLights = (*cur)->mLights[i];
 
             // Add name prefixes?
             if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES) {
                 if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY) {
-                    if (!FindNameMatch((*ppLights)->mName,src,n))
+                    if (!FindNameMatch((*ppLights)->mName, src, n))
                         continue;
                 }
 
-                PrefixString((*ppLights)->mName,(*cur).id,(*cur).idlen);
+                PrefixString((*ppLights)->mName, (*cur).id, (*cur).idlen);
             }
         }
 
         // --------------------------------------------------------------------
         // Copy cameras
-        for (unsigned int i = 0; i < (*cur)->mNumCameras;++i,++ppCameras)   {
+        for (unsigned int i = 0; i < (*cur)->mNumCameras; ++i, ++ppCameras) {
             if (n != (int)duplicates[n]) // duplicate scene?
             {
                 Copy(ppCameras, (*cur)->mCameras[i]);
-            }
-            else *ppCameras = (*cur)->mCameras[i];
+            } else
+                *ppCameras = (*cur)->mCameras[i];
 
             // Add name prefixes?
             if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES) {
                 if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY) {
-                    if (!FindNameMatch((*ppCameras)->mName,src,n))
+                    if (!FindNameMatch((*ppCameras)->mName, src, n))
                         continue;
                 }
 
-                PrefixString((*ppCameras)->mName,(*cur).id,(*cur).idlen);
+                PrefixString((*ppCameras)->mName, (*cur).id, (*cur).idlen);
             }
         }
 
         // --------------------------------------------------------------------
         // Copy animations
-        for (unsigned int i = 0; i < (*cur)->mNumAnimations;++i,++ppAnims)  {
+        for (unsigned int i = 0; i < (*cur)->mNumAnimations; ++i, ++ppAnims) {
             if (n != (int)duplicates[n]) // duplicate scene?
             {
                 Copy(ppAnims, (*cur)->mAnimations[i]);
-            }
-            else *ppAnims = (*cur)->mAnimations[i];
+            } else
+                *ppAnims = (*cur)->mAnimations[i];
 
             // Add name prefixes?
             if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES) {
                 if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY) {
-                    if (!FindNameMatch((*ppAnims)->mName,src,n))
+                    if (!FindNameMatch((*ppAnims)->mName, src, n))
                         continue;
                 }
 
-                PrefixString((*ppAnims)->mName,(*cur).id,(*cur).idlen);
+                PrefixString((*ppAnims)->mName, (*cur).id, (*cur).idlen);
 
                 // don't forget to update all node animation channels
-                for (unsigned int a = 0; a < (*ppAnims)->mNumChannels;++a) {
+                for (unsigned int a = 0; a < (*ppAnims)->mNumChannels; ++a) {
                     if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY) {
-                        if (!FindNameMatch((*ppAnims)->mChannels[a]->mNodeName,src,n))
+                        if (!FindNameMatch((*ppAnims)->mChannels[a]->mNodeName, src, n))
                             continue;
                     }
 
-                    PrefixString((*ppAnims)->mChannels[a]->mNodeName,(*cur).id,(*cur).idlen);
+                    PrefixString((*ppAnims)->mChannels[a]->mNodeName, (*cur).id, (*cur).idlen);
                 }
             }
         }
     }
 
     // Now build the output graph
-    AttachToGraph ( master, nodes);
+    AttachToGraph(master, nodes);
     dest->mRootNode = master->mRootNode;
 
     // Check whether we succeeded at building the output graph
-    for (std::vector <NodeAttachmentInfo> ::iterator it = nodes.begin();
-        it != nodes.end(); ++it)
-    {
+    for (std::vector<NodeAttachmentInfo>::iterator it = nodes.begin();
+            it != nodes.end(); ++it) {
         if (!(*it).resolved) {
             if (flags & AI_INT_MERGE_SCENE_RESOLVE_CROSS_ATTACHMENTS) {
                 // search for this attachment point in all other imported scenes, too.
-                for ( unsigned int n = 0; n < src.size();++n ) {
+                for (unsigned int n = 0; n < src.size(); ++n) {
                     if (n != (*it).src_idx) {
-                        AttachToGraph(src[n].scene,nodes);
+                        AttachToGraph(src[n].scene, nodes);
                         if ((*it).resolved)
                             break;
                     }
                 }
             }
             if (!(*it).resolved) {
-                ASSIMP_LOG_ERROR_F( "SceneCombiner: Failed to resolve attachment ", (*it).node->mName.data,
-                    " ", (*it).attachToNode->mName.data );
+                ASSIMP_LOG_ERROR("SceneCombiner: Failed to resolve attachment ", (*it).node->mName.data,
+                        " ", (*it).attachToNode->mName.data);
             }
         }
     }
 
     // now delete all input scenes. Make sure duplicate scenes aren't
     // deleted more than one time
-    for ( unsigned int n = 0; n < src.size();++n )  {
+    for (unsigned int n = 0; n < src.size(); ++n) {
         if (n != duplicates[n]) // duplicate scene?
             continue;
 
-        aiScene* deleteMe = src[n].scene;
+        aiScene *deleteMe = src[n].scene;
 
         // We need to delete the arrays before the destructor is called -
         // we are reusing the array members
-        delete[] deleteMe->mMeshes;     deleteMe->mMeshes     = NULL;
-        delete[] deleteMe->mCameras;    deleteMe->mCameras    = NULL;
-        delete[] deleteMe->mLights;     deleteMe->mLights     = NULL;
-        delete[] deleteMe->mMaterials;  deleteMe->mMaterials  = NULL;
-        delete[] deleteMe->mAnimations; deleteMe->mAnimations = NULL;
+        delete[] deleteMe->mMeshes;
+        deleteMe->mMeshes = nullptr;
+        delete[] deleteMe->mCameras;
+        deleteMe->mCameras = nullptr;
+        delete[] deleteMe->mLights;
+        deleteMe->mLights = nullptr;
+        delete[] deleteMe->mMaterials;
+        deleteMe->mMaterials = nullptr;
+        delete[] deleteMe->mAnimations;
+        deleteMe->mAnimations = nullptr;
+        delete[] deleteMe->mTextures;
+        deleteMe->mTextures = nullptr;
 
-        deleteMe->mRootNode = NULL;
+        deleteMe->mRootNode = nullptr;
 
         // Now we can safely delete the scene
         delete deleteMe;
@@ -660,34 +671,33 @@ void SceneCombiner::MergeScenes(aiScene** _dest, aiScene* master, std::vector<At
 
 // ------------------------------------------------------------------------------------------------
 // Build a list of unique bones
-void SceneCombiner::BuildUniqueBoneList(std::list<BoneWithHash>& asBones,
-    std::vector<aiMesh*>::const_iterator it,
-    std::vector<aiMesh*>::const_iterator end)
-{
+void SceneCombiner::BuildUniqueBoneList(std::list<BoneWithHash> &asBones,
+        std::vector<aiMesh *>::const_iterator it,
+        std::vector<aiMesh *>::const_iterator end) {
     unsigned int iOffset = 0;
-    for (; it != end;++it)  {
-        for (unsigned int l = 0; l < (*it)->mNumBones;++l)  {
-            aiBone* p = (*it)->mBones[l];
-            uint32_t itml = SuperFastHash(p->mName.data,(unsigned int)p->mName.length);
+    for (; it != end; ++it) {
+        for (unsigned int l = 0; l < (*it)->mNumBones; ++l) {
+            aiBone *p = (*it)->mBones[l];
+            uint32_t itml = SuperFastHash(p->mName.data, (unsigned int)p->mName.length);
 
-            std::list<BoneWithHash>::iterator it2  = asBones.begin();
+            std::list<BoneWithHash>::iterator it2 = asBones.begin();
             std::list<BoneWithHash>::iterator end2 = asBones.end();
 
-            for (;it2 != end2;++it2)    {
-                if ((*it2).first == itml)   {
-                    (*it2).pSrcBones.push_back(BoneSrcIndex(p,iOffset));
+            for (; it2 != end2; ++it2) {
+                if ((*it2).first == itml) {
+                    (*it2).pSrcBones.push_back(BoneSrcIndex(p, iOffset));
                     break;
                 }
             }
-            if (end2 == it2)    {
+            if (end2 == it2) {
                 // need to begin a new bone entry
                 asBones.push_back(BoneWithHash());
-                BoneWithHash& btz = asBones.back();
+                BoneWithHash &btz = asBones.back();
 
                 // setup members
                 btz.first = itml;
                 btz.second = &p->mName;
-                btz.pSrcBones.push_back(BoneSrcIndex(p,iOffset));
+                btz.pSrcBones.push_back(BoneSrcIndex(p, iOffset));
             }
         }
         iOffset += (*it)->mNumVertices;
@@ -696,10 +706,9 @@ void SceneCombiner::BuildUniqueBoneList(std::list<BoneWithHash>& asBones,
 
 // ------------------------------------------------------------------------------------------------
 // Merge a list of bones
-void SceneCombiner::MergeBones(aiMesh* out,std::vector<aiMesh*>::const_iterator it,
-    std::vector<aiMesh*>::const_iterator end)
-{
-    if ( nullptr == out || out->mNumBones == 0 ) {
+void SceneCombiner::MergeBones(aiMesh *out, std::vector<aiMesh *>::const_iterator it,
+        std::vector<aiMesh *>::const_iterator end) {
+    if (nullptr == out || out->mNumBones == 0) {
         return;
     }
 
@@ -707,21 +716,21 @@ void SceneCombiner::MergeBones(aiMesh* out,std::vector<aiMesh*>::const_iterator
     // we work with hashes to make the comparisons MUCH faster,
     // at least if we have many bones.
     std::list<BoneWithHash> asBones;
-    BuildUniqueBoneList( asBones, it, end );
+    BuildUniqueBoneList(asBones, it, end);
 
     // now create the output bones
     out->mNumBones = 0;
-    out->mBones = new aiBone*[asBones.size()];
+    out->mBones = new aiBone *[asBones.size()];
 
-    for (std::list<BoneWithHash>::const_iterator boneIt = asBones.begin(),boneEnd = asBones.end(); boneIt != boneEnd; ++boneIt )  {
+    for (std::list<BoneWithHash>::const_iterator boneIt = asBones.begin(), boneEnd = asBones.end(); boneIt != boneEnd; ++boneIt) {
         // Allocate a bone and setup it's name
-        aiBone* pc = out->mBones[out->mNumBones++] = new aiBone();
-        pc->mName = aiString( *( boneIt->second ));
+        aiBone *pc = out->mBones[out->mNumBones++] = new aiBone();
+        pc->mName = aiString(*(boneIt->second));
 
-        std::vector< BoneSrcIndex >::const_iterator wend = boneIt->pSrcBones.end();
+        std::vector<BoneSrcIndex>::const_iterator wend = boneIt->pSrcBones.end();
 
         // Loop through all bones to be joined for this bone
-        for (std::vector< BoneSrcIndex >::const_iterator wmit = boneIt->pSrcBones.begin(); wmit != wend; ++wmit)  {
+        for (std::vector<BoneSrcIndex>::const_iterator wmit = boneIt->pSrcBones.begin(); wmit != wend; ++wmit) {
             pc->mNumWeights += (*wmit).first->mNumWeights;
 
             // NOTE: different offset matrices for bones with equal names
@@ -734,18 +743,18 @@ void SceneCombiner::MergeBones(aiMesh* out,std::vector<aiMesh*>::const_iterator
         }
 
         // Allocate the vertex weight array
-        aiVertexWeight* avw = pc->mWeights = new aiVertexWeight[pc->mNumWeights];
+        aiVertexWeight *avw = pc->mWeights = new aiVertexWeight[pc->mNumWeights];
 
         // And copy the final weights - adjust the vertex IDs by the
         // face index offset of the corresponding mesh.
-        for (std::vector< BoneSrcIndex >::const_iterator wmit = (*boneIt).pSrcBones.begin(); wmit != (*boneIt).pSrcBones.end(); ++wmit) {
+        for (std::vector<BoneSrcIndex>::const_iterator wmit = (*boneIt).pSrcBones.begin(); wmit != (*boneIt).pSrcBones.end(); ++wmit) {
             if (wmit == wend) {
                 break;
             }
 
-            aiBone* pip = (*wmit).first;
-            for (unsigned int mp = 0; mp < pip->mNumWeights;++mp,++avw) {
-                const aiVertexWeight& vfi = pip->mWeights[mp];
+            aiBone *pip = (*wmit).first;
+            for (unsigned int mp = 0; mp < pip->mNumWeights; ++mp, ++avw) {
+                const aiVertexWeight &vfi = pip->mWeights[mp];
                 avw->mWeight = vfi.mWeight;
                 avw->mVertexId = vfi.mVertexId + (*wmit).second;
             }
@@ -755,52 +764,51 @@ void SceneCombiner::MergeBones(aiMesh* out,std::vector<aiMesh*>::const_iterator
 
 // ------------------------------------------------------------------------------------------------
 // Merge a list of meshes
-void SceneCombiner::MergeMeshes(aiMesh** _out, unsigned int /*flags*/,
-    std::vector<aiMesh*>::const_iterator begin,
-    std::vector<aiMesh*>::const_iterator end)
-{
-    if ( nullptr == _out ) {
+void SceneCombiner::MergeMeshes(aiMesh **_out, unsigned int /*flags*/,
+        std::vector<aiMesh *>::const_iterator begin,
+        std::vector<aiMesh *>::const_iterator end) {
+    if (nullptr == _out) {
         return;
     }
 
-    if (begin == end)   {
-        *_out = NULL; // no meshes ...
+    if (begin == end) {
+        *_out = nullptr; // no meshes ...
         return;
     }
 
     // Allocate the output mesh
-    aiMesh* out = *_out = new aiMesh();
+    aiMesh *out = *_out = new aiMesh();
     out->mMaterialIndex = (*begin)->mMaterialIndex;
 
     std::string name;
     // Find out how much output storage we'll need
-    for (std::vector<aiMesh*>::const_iterator it = begin; it != end; ++it) {
-        const char *meshName( (*it)->mName.C_Str() );
-        name += std::string( meshName );
-        if ( it != end - 1 ) {
+    for (std::vector<aiMesh *>::const_iterator it = begin; it != end; ++it) {
+        const char *meshName((*it)->mName.C_Str());
+        name += std::string(meshName);
+        if (it != end - 1) {
             name += ".";
         }
-        out->mNumVertices   += (*it)->mNumVertices;
-        out->mNumFaces      += (*it)->mNumFaces;
-        out->mNumBones      += (*it)->mNumBones;
+        out->mNumVertices += (*it)->mNumVertices;
+        out->mNumFaces += (*it)->mNumFaces;
+        out->mNumBones += (*it)->mNumBones;
 
         // combine primitive type flags
         out->mPrimitiveTypes |= (*it)->mPrimitiveTypes;
     }
-    out->mName.Set( name.c_str() );
+    out->mName.Set(name.c_str());
 
     if (out->mNumVertices) {
-        aiVector3D* pv2;
+        aiVector3D *pv2;
 
         // copy vertex positions
-        if ((**begin).HasPositions())   {
+        if ((**begin).HasPositions()) {
 
             pv2 = out->mVertices = new aiVector3D[out->mNumVertices];
-            for (std::vector<aiMesh*>::const_iterator it = begin; it != end; ++it)  {
-                if ((*it)->mVertices)   {
-                    ::memcpy(pv2,(*it)->mVertices,(*it)->mNumVertices*sizeof(aiVector3D));
-                }
-                else ASSIMP_LOG_WARN("JoinMeshes: Positions expected but input mesh contains no positions");
+            for (std::vector<aiMesh *>::const_iterator it = begin; it != end; ++it) {
+                if ((*it)->mVertices) {
+                    ::memcpy(pv2, (*it)->mVertices, (*it)->mNumVertices * sizeof(aiVector3D));
+                } else
+                    ASSIMP_LOG_WARN("JoinMeshes: Positions expected but input mesh contains no positions");
                 pv2 += (*it)->mNumVertices;
             }
         }
@@ -808,29 +816,29 @@ void SceneCombiner::MergeMeshes(aiMesh** _out, unsigned int /*flags*/,
         if ((**begin).HasNormals()) {
 
             pv2 = out->mNormals = new aiVector3D[out->mNumVertices];
-            for (std::vector<aiMesh*>::const_iterator it = begin; it != end;++it)   {
-                if ((*it)->mNormals)    {
-                    ::memcpy(pv2,(*it)->mNormals,(*it)->mNumVertices*sizeof(aiVector3D));
+            for (std::vector<aiMesh *>::const_iterator it = begin; it != end; ++it) {
+                if ((*it)->mNormals) {
+                    ::memcpy(pv2, (*it)->mNormals, (*it)->mNumVertices * sizeof(aiVector3D));
                 } else {
-                    ASSIMP_LOG_WARN( "JoinMeshes: Normals expected but input mesh contains no normals" );
+                    ASSIMP_LOG_WARN("JoinMeshes: Normals expected but input mesh contains no normals");
                 }
                 pv2 += (*it)->mNumVertices;
             }
         }
         // copy tangents and bi-tangents
-        if ((**begin).HasTangentsAndBitangents())   {
+        if ((**begin).HasTangentsAndBitangents()) {
 
             pv2 = out->mTangents = new aiVector3D[out->mNumVertices];
-            aiVector3D* pv2b = out->mBitangents = new aiVector3D[out->mNumVertices];
+            aiVector3D *pv2b = out->mBitangents = new aiVector3D[out->mNumVertices];
 
-            for (std::vector<aiMesh*>::const_iterator it = begin; it != end;++it) {
-                if ((*it)->mTangents)   {
-                    ::memcpy(pv2, (*it)->mTangents,  (*it)->mNumVertices*sizeof(aiVector3D));
-                    ::memcpy(pv2b,(*it)->mBitangents,(*it)->mNumVertices*sizeof(aiVector3D));
+            for (std::vector<aiMesh *>::const_iterator it = begin; it != end; ++it) {
+                if ((*it)->mTangents) {
+                    ::memcpy(pv2, (*it)->mTangents, (*it)->mNumVertices * sizeof(aiVector3D));
+                    ::memcpy(pv2b, (*it)->mBitangents, (*it)->mNumVertices * sizeof(aiVector3D));
                 } else {
-                    ASSIMP_LOG_WARN( "JoinMeshes: Tangents expected but input mesh contains no tangents" );
+                    ASSIMP_LOG_WARN("JoinMeshes: Tangents expected but input mesh contains no tangents");
                 }
-                pv2  += (*it)->mNumVertices;
+                pv2 += (*it)->mNumVertices;
                 pv2b += (*it)->mNumVertices;
             }
         }
@@ -840,11 +848,11 @@ void SceneCombiner::MergeMeshes(aiMesh** _out, unsigned int /*flags*/,
             out->mNumUVComponents[n] = (*begin)->mNumUVComponents[n];
 
             pv2 = out->mTextureCoords[n] = new aiVector3D[out->mNumVertices];
-            for (std::vector<aiMesh*>::const_iterator it = begin; it != end;++it)   {
-                if ((*it)->mTextureCoords[n])   {
-                    ::memcpy(pv2,(*it)->mTextureCoords[n],(*it)->mNumVertices*sizeof(aiVector3D));
+            for (std::vector<aiMesh *>::const_iterator it = begin; it != end; ++it) {
+                if ((*it)->mTextureCoords[n]) {
+                    ::memcpy(pv2, (*it)->mTextureCoords[n], (*it)->mNumVertices * sizeof(aiVector3D));
                 } else {
-                    ASSIMP_LOG_WARN( "JoinMeshes: UVs expected but input mesh contains no UVs" );
+                    ASSIMP_LOG_WARN("JoinMeshes: UVs expected but input mesh contains no UVs");
                 }
                 pv2 += (*it)->mNumVertices;
             }
@@ -852,13 +860,13 @@ void SceneCombiner::MergeMeshes(aiMesh** _out, unsigned int /*flags*/,
         }
         // copy vertex colors
         n = 0;
-        while ((**begin).HasVertexColors(n))    {
+        while ((**begin).HasVertexColors(n)) {
             aiColor4D *pVec2 = out->mColors[n] = new aiColor4D[out->mNumVertices];
-            for ( std::vector<aiMesh*>::const_iterator it = begin; it != end; ++it )   {
-                if ((*it)->mColors[n])  {
-                    ::memcpy( pVec2, (*it)->mColors[ n ], (*it)->mNumVertices * sizeof( aiColor4D ) ) ;
+            for (std::vector<aiMesh *>::const_iterator it = begin; it != end; ++it) {
+                if ((*it)->mColors[n]) {
+                    ::memcpy(pVec2, (*it)->mColors[n], (*it)->mNumVertices * sizeof(aiColor4D));
                 } else {
-                    ASSIMP_LOG_WARN( "JoinMeshes: VCs expected but input mesh contains no VCs" );
+                    ASSIMP_LOG_WARN("JoinMeshes: VCs expected but input mesh contains no VCs");
                 }
                 pVec2 += (*it)->mNumVertices;
             }
@@ -870,21 +878,22 @@ void SceneCombiner::MergeMeshes(aiMesh** _out, unsigned int /*flags*/,
     {
         // copy faces
         out->mFaces = new aiFace[out->mNumFaces];
-        aiFace* pf2 = out->mFaces;
+        aiFace *pf2 = out->mFaces;
 
         unsigned int ofs = 0;
-        for (std::vector<aiMesh*>::const_iterator it = begin; it != end;++it)   {
-            for (unsigned int m = 0; m < (*it)->mNumFaces;++m,++pf2)    {
-                aiFace& face = (*it)->mFaces[m];
+        for (std::vector<aiMesh *>::const_iterator it = begin; it != end; ++it) {
+            for (unsigned int m = 0; m < (*it)->mNumFaces; ++m, ++pf2) {
+                aiFace &face = (*it)->mFaces[m];
                 pf2->mNumIndices = face.mNumIndices;
                 pf2->mIndices = face.mIndices;
 
-                if (ofs)    {
+                if (ofs) {
                     // add the offset to the vertex
-                    for (unsigned int q = 0; q < face.mNumIndices; ++q)
+                    for (unsigned int q = 0; q < face.mNumIndices; ++q) {
                         face.mIndices[q] += ofs;
+                    }
                 }
-                face.mIndices = NULL;
+                face.mIndices = nullptr;
             }
             ofs += (*it)->mNumVertices;
         }
@@ -892,33 +901,32 @@ void SceneCombiner::MergeMeshes(aiMesh** _out, unsigned int /*flags*/,
 
     // bones - as this is quite lengthy, I moved the code to a separate function
     if (out->mNumBones)
-        MergeBones(out,begin,end);
+        MergeBones(out, begin, end);
 
     // delete all source meshes
-    for (std::vector<aiMesh*>::const_iterator it = begin; it != end;++it)
+    for (std::vector<aiMesh *>::const_iterator it = begin; it != end; ++it)
         delete *it;
 }
 
 // ------------------------------------------------------------------------------------------------
-void SceneCombiner::MergeMaterials(aiMaterial** dest,
-        std::vector<aiMaterial*>::const_iterator begin,
-        std::vector<aiMaterial*>::const_iterator end)
-{
-    if ( nullptr == dest ) {
+void SceneCombiner::MergeMaterials(aiMaterial **dest,
+        std::vector<aiMaterial *>::const_iterator begin,
+        std::vector<aiMaterial *>::const_iterator end) {
+    if (nullptr == dest) {
         return;
     }
 
-    if (begin == end)   {
-        *dest = NULL; // no materials ...
+    if (begin == end) {
+        *dest = nullptr; // no materials ...
         return;
     }
 
     // Allocate the output material
-    aiMaterial* out = *dest = new aiMaterial();
+    aiMaterial *out = *dest = new aiMaterial();
 
     // Get the maximal number of properties
     unsigned int size = 0;
-    for (std::vector<aiMaterial*>::const_iterator it = begin; it != end; ++it) {
+    for (std::vector<aiMaterial *>::const_iterator it = begin; it != end; ++it) {
         size += (*it)->mNumProperties;
     }
 
@@ -927,26 +935,26 @@ void SceneCombiner::MergeMaterials(aiMaterial** dest,
 
     out->mNumAllocated = size;
     out->mNumProperties = 0;
-    out->mProperties = new aiMaterialProperty*[out->mNumAllocated];
+    out->mProperties = new aiMaterialProperty *[out->mNumAllocated];
 
-    for (std::vector<aiMaterial*>::const_iterator it = begin; it != end; ++it) {
-        for(unsigned int i = 0; i < (*it)->mNumProperties; ++i) {
-            aiMaterialProperty* sprop = (*it)->mProperties[i];
+    for (std::vector<aiMaterial *>::const_iterator it = begin; it != end; ++it) {
+        for (unsigned int i = 0; i < (*it)->mNumProperties; ++i) {
+            aiMaterialProperty *sprop = (*it)->mProperties[i];
 
             // Test if we already have a matching property
-            const aiMaterialProperty* prop_exist;
-            if(aiGetMaterialProperty(out, sprop->mKey.C_Str(), sprop->mSemantic, sprop->mIndex, &prop_exist) != AI_SUCCESS) {
+            const aiMaterialProperty *prop_exist;
+            if (aiGetMaterialProperty(out, sprop->mKey.C_Str(), sprop->mSemantic, sprop->mIndex, &prop_exist) != AI_SUCCESS) {
                 // If not, we add it to the new material
-                aiMaterialProperty* prop = out->mProperties[out->mNumProperties] = new aiMaterialProperty();
+                aiMaterialProperty *prop = out->mProperties[out->mNumProperties] = new aiMaterialProperty();
 
                 prop->mDataLength = sprop->mDataLength;
                 prop->mData = new char[prop->mDataLength];
                 ::memcpy(prop->mData, sprop->mData, prop->mDataLength);
 
-                prop->mIndex    = sprop->mIndex;
+                prop->mIndex = sprop->mIndex;
                 prop->mSemantic = sprop->mSemantic;
-                prop->mKey      = sprop->mKey;
-                prop->mType     = sprop->mType;
+                prop->mKey = sprop->mKey;
+                prop->mType = sprop->mType;
 
                 out->mNumProperties++;
             }
@@ -956,34 +964,32 @@ void SceneCombiner::MergeMaterials(aiMaterial** dest,
 
 // ------------------------------------------------------------------------------------------------
 template <typename Type>
-inline
-void CopyPtrArray (Type**& dest, const Type* const * src, ai_uint num) {
+inline void CopyPtrArray(Type **&dest, const Type *const *src, ai_uint num) {
     if (!num) {
-        dest = NULL;
+        dest = nullptr;
         return;
     }
-    dest = new Type*[num];
-    for (ai_uint i = 0; i < num;++i) {
-        SceneCombiner::Copy(&dest[i],src[i]);
+    dest = new Type *[num];
+    for (ai_uint i = 0; i < num; ++i) {
+        SceneCombiner::Copy(&dest[i], src[i]);
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename Type>
-inline
-void GetArrayCopy(Type*& dest, ai_uint num ) {
-    if ( !dest ) {
+inline void GetArrayCopy(Type *&dest, ai_uint num) {
+    if (!dest) {
         return;
     }
-    Type* old = dest;
+    Type *old = dest;
 
     dest = new Type[num];
     ::memcpy(dest, old, sizeof(Type) * num);
 }
 
 // ------------------------------------------------------------------------------------------------
-void SceneCombiner::CopySceneFlat(aiScene** _dest,const aiScene* src) {
-    if ( nullptr == _dest || nullptr == src ) {
+void SceneCombiner::CopySceneFlat(aiScene **_dest, const aiScene *src) {
+    if (nullptr == _dest || nullptr == src) {
         return;
     }
 
@@ -994,118 +1000,127 @@ void SceneCombiner::CopySceneFlat(aiScene** _dest,const aiScene* src) {
     } else {
         *_dest = new aiScene();
     }
-
-    ::memcpy(*_dest,src,sizeof(aiScene));
+    CopyScene(_dest, src, false);
 }
 
 // ------------------------------------------------------------------------------------------------
-void SceneCombiner::CopyScene(aiScene** _dest,const aiScene* src,bool allocate) {
-    if ( nullptr == _dest || nullptr == src ) {
+void SceneCombiner::CopyScene(aiScene **_dest, const aiScene *src, bool allocate) {
+    if (nullptr == _dest || nullptr == src) {
         return;
     }
 
     if (allocate) {
         *_dest = new aiScene();
     }
-    aiScene* dest = *_dest;
+    aiScene *dest = *_dest;
     ai_assert(nullptr != dest);
 
     // copy metadata
-    if ( nullptr != src->mMetaData ) {
-        dest->mMetaData = new aiMetadata( *src->mMetaData );
+    if (nullptr != src->mMetaData) {
+        dest->mMetaData = new aiMetadata(*src->mMetaData);
     }
 
     // copy animations
     dest->mNumAnimations = src->mNumAnimations;
-    CopyPtrArray(dest->mAnimations,src->mAnimations,
-        dest->mNumAnimations);
+    CopyPtrArray(dest->mAnimations, src->mAnimations,
+            dest->mNumAnimations);
 
     // copy textures
     dest->mNumTextures = src->mNumTextures;
-    CopyPtrArray(dest->mTextures,src->mTextures,
-        dest->mNumTextures);
+    CopyPtrArray(dest->mTextures, src->mTextures,
+            dest->mNumTextures);
 
     // copy materials
     dest->mNumMaterials = src->mNumMaterials;
-    CopyPtrArray(dest->mMaterials,src->mMaterials,
-        dest->mNumMaterials);
+    CopyPtrArray(dest->mMaterials, src->mMaterials,
+            dest->mNumMaterials);
 
     // copy lights
     dest->mNumLights = src->mNumLights;
-    CopyPtrArray(dest->mLights,src->mLights,
-        dest->mNumLights);
+    CopyPtrArray(dest->mLights, src->mLights,
+            dest->mNumLights);
 
     // copy cameras
     dest->mNumCameras = src->mNumCameras;
-    CopyPtrArray(dest->mCameras,src->mCameras,
-        dest->mNumCameras);
+    CopyPtrArray(dest->mCameras, src->mCameras,
+            dest->mNumCameras);
 
     // copy meshes
     dest->mNumMeshes = src->mNumMeshes;
-    CopyPtrArray(dest->mMeshes,src->mMeshes,
-        dest->mNumMeshes);
+    CopyPtrArray(dest->mMeshes, src->mMeshes,
+            dest->mNumMeshes);
 
     // now - copy the root node of the scene (deep copy, too)
-    Copy( &dest->mRootNode, src->mRootNode);
+    Copy(&dest->mRootNode, src->mRootNode);
 
     // and keep the flags ...
     dest->mFlags = src->mFlags;
 
-    // source private data might be NULL if the scene is user-allocated (i.e. for use with the export API)
-    if (dest->mPrivate != NULL) {
+    // source private data might be nullptr if the scene is user-allocated (i.e. for use with the export API)
+    if (dest->mPrivate != nullptr) {
         ScenePriv(dest)->mPPStepsApplied = ScenePriv(src) ? ScenePriv(src)->mPPStepsApplied : 0;
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void SceneCombiner::Copy( aiMesh** _dest, const aiMesh* src ) {
-    if ( nullptr == _dest || nullptr == src ) {
-        return;
-    }
-
-    aiMesh* dest = *_dest = new aiMesh();
-
-    // get a flat copy
-    ::memcpy(dest,src,sizeof(aiMesh));
-
-    // and reallocate all arrays
-    GetArrayCopy( dest->mVertices,   dest->mNumVertices );
-    GetArrayCopy( dest->mNormals ,   dest->mNumVertices );
-    GetArrayCopy( dest->mTangents,   dest->mNumVertices );
-    GetArrayCopy( dest->mBitangents, dest->mNumVertices );
-
-    unsigned int n = 0;
-    while (dest->HasTextureCoords(n))
-        GetArrayCopy( dest->mTextureCoords[n++],   dest->mNumVertices );
-
-    n = 0;
-    while (dest->HasVertexColors(n))
-        GetArrayCopy( dest->mColors[n++],   dest->mNumVertices );
-
-    // make a deep copy of all bones
-    CopyPtrArray(dest->mBones,dest->mBones,dest->mNumBones);
-
-    // make a deep copy of all faces
-    GetArrayCopy(dest->mFaces,dest->mNumFaces);
-    for (unsigned int i = 0; i < dest->mNumFaces;++i) {
-        aiFace& f = dest->mFaces[i];
-        GetArrayCopy(f.mIndices,f.mNumIndices);
-    }
-
-    // make a deep copy of all blend shapes
-    CopyPtrArray(dest->mAnimMeshes, dest->mAnimMeshes, dest->mNumAnimMeshes);
-}
-
-// ------------------------------------------------------------------------------------------------
-void SceneCombiner::Copy(aiAnimMesh** _dest, const aiAnimMesh* src) {
+void SceneCombiner::Copy(aiMesh **_dest, const aiMesh *src) {
     if (nullptr == _dest || nullptr == src) {
         return;
     }
 
-    aiAnimMesh* dest = *_dest = new aiAnimMesh();
+    aiMesh *dest = *_dest = new aiMesh();
 
     // get a flat copy
-    ::memcpy(dest, src, sizeof(aiAnimMesh));
+    *dest = *src;
+
+    // and reallocate all arrays
+    GetArrayCopy(dest->mVertices, dest->mNumVertices);
+    GetArrayCopy(dest->mNormals, dest->mNumVertices);
+    GetArrayCopy(dest->mTangents, dest->mNumVertices);
+    GetArrayCopy(dest->mBitangents, dest->mNumVertices);
+
+    unsigned int n = 0;
+    while (dest->HasTextureCoords(n)) {
+        GetArrayCopy(dest->mTextureCoords[n++], dest->mNumVertices);
+    }
+
+    n = 0;
+    while (dest->HasVertexColors(n)) {
+        GetArrayCopy(dest->mColors[n++], dest->mNumVertices);
+    }
+
+    // make a deep copy of all bones
+    CopyPtrArray(dest->mBones, dest->mBones, dest->mNumBones);
+
+    // make a deep copy of all faces
+    GetArrayCopy(dest->mFaces, dest->mNumFaces);
+    for (unsigned int i = 0; i < dest->mNumFaces; ++i) {
+        aiFace &f = dest->mFaces[i];
+        GetArrayCopy(f.mIndices, f.mNumIndices);
+    }
+
+    // make a deep copy of all blend shapes
+    CopyPtrArray(dest->mAnimMeshes, dest->mAnimMeshes, dest->mNumAnimMeshes);
+
+    // make a deep copy of all texture coordinate names
+    if (src->mTextureCoordsNames != nullptr) {
+        dest->mTextureCoordsNames = new aiString *[AI_MAX_NUMBER_OF_TEXTURECOORDS] {};
+        for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
+            Copy(&dest->mTextureCoordsNames[i], src->mTextureCoordsNames[i]);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void SceneCombiner::Copy(aiAnimMesh **_dest, const aiAnimMesh *src) {
+    if (nullptr == _dest || nullptr == src) {
+        return;
+    }
+
+    aiAnimMesh *dest = *_dest = new aiAnimMesh();
+
+    // get a flat copy
+    *dest = *src;
 
     // and reallocate all arrays
     GetArrayCopy(dest->mVertices, dest->mNumVertices);
@@ -1123,207 +1138,238 @@ void SceneCombiner::Copy(aiAnimMesh** _dest, const aiAnimMesh* src) {
 }
 
 // ------------------------------------------------------------------------------------------------
-void SceneCombiner::Copy (aiMaterial** _dest, const aiMaterial* src) {
-    if ( nullptr == _dest || nullptr == src ) {
+void SceneCombiner::Copy(aiMaterial **_dest, const aiMaterial *src) {
+    if (nullptr == _dest || nullptr == src) {
         return;
     }
 
-    aiMaterial* dest = (aiMaterial*) ( *_dest = new aiMaterial() );
+    aiMaterial *dest = (aiMaterial *)(*_dest = new aiMaterial());
 
     dest->Clear();
     delete[] dest->mProperties;
 
-    dest->mNumAllocated  =  src->mNumAllocated;
-    dest->mNumProperties =  src->mNumProperties;
-    dest->mProperties    =  new aiMaterialProperty* [dest->mNumAllocated];
+    dest->mNumAllocated = src->mNumAllocated;
+    dest->mNumProperties = src->mNumProperties;
+    dest->mProperties = new aiMaterialProperty *[dest->mNumAllocated];
 
-    for (unsigned int i = 0; i < dest->mNumProperties;++i)
-    {
-        aiMaterialProperty* prop  = dest->mProperties[i] = new aiMaterialProperty();
-        aiMaterialProperty* sprop = src->mProperties[i];
+    for (unsigned int i = 0; i < dest->mNumProperties; ++i) {
+        aiMaterialProperty *prop = dest->mProperties[i] = new aiMaterialProperty();
+        aiMaterialProperty *sprop = src->mProperties[i];
 
         prop->mDataLength = sprop->mDataLength;
         prop->mData = new char[prop->mDataLength];
-        ::memcpy(prop->mData,sprop->mData,prop->mDataLength);
+        ::memcpy(prop->mData, sprop->mData, prop->mDataLength);
 
-        prop->mIndex    = sprop->mIndex;
+        prop->mIndex = sprop->mIndex;
         prop->mSemantic = sprop->mSemantic;
-        prop->mKey      = sprop->mKey;
-        prop->mType     = sprop->mType;
+        prop->mKey = sprop->mKey;
+        prop->mType = sprop->mType;
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void SceneCombiner::Copy(aiTexture** _dest, const aiTexture* src) {
-    if ( nullptr == _dest || nullptr == src ) {
+void SceneCombiner::Copy(aiTexture **_dest, const aiTexture *src) {
+    if (nullptr == _dest || nullptr == src) {
         return;
     }
 
-    aiTexture* dest = *_dest = new aiTexture();
+    aiTexture *dest = *_dest = new aiTexture();
 
     // get a flat copy
-    ::memcpy(dest,src,sizeof(aiTexture));
+    *dest = *src;
 
     // and reallocate all arrays. We must do it manually here
-    const char* old = (const char*)dest->pcData;
-    if (old)
-    {
+    const char *old = (const char *)dest->pcData;
+    if (old) {
         unsigned int cpy;
-        if (!dest->mHeight)cpy = dest->mWidth;
-        else cpy = dest->mHeight * dest->mWidth * sizeof(aiTexel);
+        if (!dest->mHeight)
+            cpy = dest->mWidth;
+        else
+            cpy = dest->mHeight * dest->mWidth * sizeof(aiTexel);
 
-        if (!cpy)
-        {
-            dest->pcData = NULL;
+        if (!cpy) {
+            dest->pcData = nullptr;
             return;
         }
         // the cast is legal, the aiTexel c'tor does nothing important
-        dest->pcData = (aiTexel*) new char[cpy];
+        dest->pcData = (aiTexel *)new char[cpy];
         ::memcpy(dest->pcData, old, cpy);
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void SceneCombiner::Copy( aiAnimation** _dest, const aiAnimation* src ) {
-    if ( nullptr == _dest || nullptr == src ) {
+void SceneCombiner::Copy(aiAnimation **_dest, const aiAnimation *src) {
+    if (nullptr == _dest || nullptr == src) {
         return;
     }
 
-    aiAnimation* dest = *_dest = new aiAnimation();
+    aiAnimation *dest = *_dest = new aiAnimation();
 
     // get a flat copy
-    ::memcpy(dest,src,sizeof(aiAnimation));
+    *dest = *src;
 
     // and reallocate all arrays
-    CopyPtrArray( dest->mChannels, src->mChannels, dest->mNumChannels );
+    CopyPtrArray(dest->mChannels, src->mChannels, dest->mNumChannels);
+    CopyPtrArray(dest->mMorphMeshChannels, src->mMorphMeshChannels, dest->mNumMorphMeshChannels);
 }
 
 // ------------------------------------------------------------------------------------------------
-void SceneCombiner::Copy(aiNodeAnim** _dest, const aiNodeAnim* src) {
-    if ( nullptr == _dest || nullptr == src ) {
+void SceneCombiner::Copy(aiNodeAnim **_dest, const aiNodeAnim *src) {
+    if (nullptr == _dest || nullptr == src) {
         return;
     }
 
-    aiNodeAnim* dest = *_dest = new aiNodeAnim();
+    aiNodeAnim *dest = *_dest = new aiNodeAnim();
 
     // get a flat copy
-    ::memcpy(dest,src,sizeof(aiNodeAnim));
+    *dest = *src;
 
     // and reallocate all arrays
-    GetArrayCopy( dest->mPositionKeys, dest->mNumPositionKeys );
-    GetArrayCopy( dest->mScalingKeys,  dest->mNumScalingKeys );
-    GetArrayCopy( dest->mRotationKeys, dest->mNumRotationKeys );
+    GetArrayCopy(dest->mPositionKeys, dest->mNumPositionKeys);
+    GetArrayCopy(dest->mScalingKeys, dest->mNumScalingKeys);
+    GetArrayCopy(dest->mRotationKeys, dest->mNumRotationKeys);
+}
+
+void SceneCombiner::Copy(aiMeshMorphAnim **_dest, const aiMeshMorphAnim *src) {
+    if (nullptr == _dest || nullptr == src) {
+        return;
+    }
+
+    aiMeshMorphAnim *dest = *_dest = new aiMeshMorphAnim();
+
+    // get a flat copy
+    *dest = *src;
+
+    // and reallocate all arrays
+    GetArrayCopy(dest->mKeys, dest->mNumKeys);
+    for (ai_uint i = 0; i < dest->mNumKeys; ++i) {
+        dest->mKeys[i].mValues = new unsigned int[dest->mKeys[i].mNumValuesAndWeights];
+        dest->mKeys[i].mWeights = new double[dest->mKeys[i].mNumValuesAndWeights];
+        ::memcpy(dest->mKeys[i].mValues, src->mKeys[i].mValues, dest->mKeys[i].mNumValuesAndWeights * sizeof(unsigned int));
+        ::memcpy(dest->mKeys[i].mWeights, src->mKeys[i].mWeights, dest->mKeys[i].mNumValuesAndWeights * sizeof(double));
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
-void SceneCombiner::Copy( aiCamera** _dest,const  aiCamera* src) {
-    if ( nullptr == _dest || nullptr == src ) {
+void SceneCombiner::Copy(aiCamera **_dest, const aiCamera *src) {
+    if (nullptr == _dest || nullptr == src) {
         return;
     }
 
-    aiCamera* dest = *_dest = new aiCamera();
+    aiCamera *dest = *_dest = new aiCamera();
 
     // get a flat copy, that's already OK
-    ::memcpy(dest,src,sizeof(aiCamera));
+    *dest = *src;
 }
 
 // ------------------------------------------------------------------------------------------------
-void SceneCombiner::Copy(aiLight** _dest, const aiLight* src) {
-    if ( nullptr == _dest || nullptr == src ) {
+void SceneCombiner::Copy(aiLight **_dest, const aiLight *src) {
+    if (nullptr == _dest || nullptr == src) {
         return;
     }
 
-    aiLight* dest = *_dest = new aiLight();
+    aiLight *dest = *_dest = new aiLight();
 
     // get a flat copy, that's already OK
-    ::memcpy(dest,src,sizeof(aiLight));
+    *dest = *src;
 }
 
 // ------------------------------------------------------------------------------------------------
-void SceneCombiner::Copy(aiBone** _dest, const aiBone* src) {
-    if ( nullptr == _dest || nullptr == src ) {
+void SceneCombiner::Copy(aiBone **_dest, const aiBone *src) {
+    if (nullptr == _dest || nullptr == src) {
         return;
     }
 
-    aiBone* dest = *_dest = new aiBone();
+    aiBone *dest = *_dest = new aiBone();
 
     // get a flat copy
-    ::memcpy(dest,src,sizeof(aiBone));
-
-    // and reallocate all arrays
-    GetArrayCopy( dest->mWeights, dest->mNumWeights );
+    *dest = *src;
 }
 
 // ------------------------------------------------------------------------------------------------
-void SceneCombiner::Copy     (aiNode** _dest, const aiNode* src)
-{
-    ai_assert(NULL != _dest && NULL != src);
+void SceneCombiner::Copy(aiNode **_dest, const aiNode *src) {
+    ai_assert(nullptr != _dest);
+    ai_assert(nullptr != src);
 
-    aiNode* dest = *_dest = new aiNode();
+    aiNode *dest = *_dest = new aiNode();
 
     // get a flat copy
-    ::memcpy(dest,src,sizeof(aiNode));
+    *dest = *src;
 
     if (src->mMetaData) {
         Copy(&dest->mMetaData, src->mMetaData);
     }
 
     // and reallocate all arrays
-    GetArrayCopy( dest->mMeshes, dest->mNumMeshes );
-    CopyPtrArray( dest->mChildren, src->mChildren,dest->mNumChildren);
+    GetArrayCopy(dest->mMeshes, dest->mNumMeshes);
+    CopyPtrArray(dest->mChildren, src->mChildren, dest->mNumChildren);
 
-	// need to set the mParent fields to the created aiNode.
-	for( unsigned int i = 0; i < dest->mNumChildren; i ++ ) {
-		dest->mChildren[i]->mParent = dest;
-	}
+    // need to set the mParent fields to the created aiNode.
+    for (unsigned int i = 0; i < dest->mNumChildren; i++) {
+        dest->mChildren[i]->mParent = dest;
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
-void SceneCombiner::Copy(aiMetadata** _dest, const aiMetadata* src) {
-    if ( nullptr == _dest || nullptr == src ) {
+void SceneCombiner::Copy(aiMetadata **_dest, const aiMetadata *src) {
+    if (nullptr == _dest || nullptr == src) {
         return;
     }
 
-    if ( 0 == src->mNumProperties ) {
+    if (0 == src->mNumProperties) {
         return;
     }
 
-    aiMetadata* dest = *_dest = aiMetadata::Alloc( src->mNumProperties );
+    aiMetadata *dest = *_dest = aiMetadata::Alloc(src->mNumProperties);
     std::copy(src->mKeys, src->mKeys + src->mNumProperties, dest->mKeys);
 
-    dest->mValues = new aiMetadataEntry[src->mNumProperties];
     for (unsigned int i = 0; i < src->mNumProperties; ++i) {
-        aiMetadataEntry& in = src->mValues[i];
-        aiMetadataEntry& out = dest->mValues[i];
+        aiMetadataEntry &in = src->mValues[i];
+        aiMetadataEntry &out = dest->mValues[i];
         out.mType = in.mType;
         switch (dest->mValues[i].mType) {
-            case AI_BOOL:
-                out.mData = new bool(*static_cast<bool*>(in.mData));
-                break;
-            case AI_INT32:
-                out.mData = new int32_t(*static_cast<int32_t*>(in.mData));
-                break;
-            case AI_UINT64:
-                out.mData = new uint64_t(*static_cast<uint64_t*>(in.mData));
-                break;
-            case AI_FLOAT:
-                out.mData = new float(*static_cast<float*>(in.mData));
-                break;
-            case AI_DOUBLE:
-                out.mData = new double(*static_cast<double*>(in.mData));
-                break;
-            case AI_AISTRING:
-                out.mData = new aiString(*static_cast<aiString*>(in.mData));
-                break;
-            case AI_AIVECTOR3D:
-                out.mData = new aiVector3D(*static_cast<aiVector3D*>(in.mData));
-                break;
-            default:
-                ai_assert(false);
-                break;
+        case AI_BOOL:
+            out.mData = new bool(*static_cast<bool *>(in.mData));
+            break;
+        case AI_INT32:
+            out.mData = new int32_t(*static_cast<int32_t *>(in.mData));
+            break;
+        case AI_UINT64:
+            out.mData = new uint64_t(*static_cast<uint64_t *>(in.mData));
+            break;
+        case AI_FLOAT:
+            out.mData = new float(*static_cast<float *>(in.mData));
+            break;
+        case AI_DOUBLE:
+            out.mData = new double(*static_cast<double *>(in.mData));
+            break;
+        case AI_AISTRING:
+            out.mData = new aiString(*static_cast<aiString *>(in.mData));
+            break;
+        case AI_AIVECTOR3D:
+            out.mData = new aiVector3D(*static_cast<aiVector3D *>(in.mData));
+            break;
+        default:
+            ai_assert(false);
+            break;
         }
     }
 }
 
-} // Namespace Assimp
+// ------------------------------------------------------------------------------------------------
+void SceneCombiner::Copy(aiString **_dest, const aiString *src) {
+    if (nullptr == _dest || nullptr == src) {
+        return;
+    }
 
+    aiString *dest = *_dest = new aiString();
+
+    // get a flat copy
+    *dest = *src;
+}
+
+#if (__GNUC__ >= 8 && __GNUC_MINOR__ >= 0)
+#pragma GCC diagnostic pop
+#endif
+
+} // Namespace Assimp
diff --git a/Engine/lib/assimp/code/Common/ScenePreprocessor.cpp b/Engine/lib/assimp/code/Common/ScenePreprocessor.cpp
index 432a3d766..2ef291eeb 100644
--- a/Engine/lib/assimp/code/Common/ScenePreprocessor.cpp
+++ b/Engine/lib/assimp/code/Common/ScenePreprocessor.cpp
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -45,17 +44,19 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/scene.h>
 #include <assimp/DefaultLogger.hpp>
 
-
 using namespace Assimp;
 
 // ---------------------------------------------------------------------------------------------
-void ScenePreprocessor::ProcessScene ()
-{
-    ai_assert(scene != NULL);
+void ScenePreprocessor::ProcessScene() {
+    ai_assert(scene != nullptr);
 
     // Process all meshes
-    for (unsigned int i = 0; i < scene->mNumMeshes;++i)
+    for (unsigned int i = 0; i < scene->mNumMeshes; ++i) {
+        if (nullptr == scene->mMeshes[i]) {
+            continue;
+        }
         ProcessMesh(scene->mMeshes[i]);
+    }
 
     // - nothing to do for nodes for the moment
     // - nothing to do for textures for the moment
@@ -63,27 +64,34 @@ void ScenePreprocessor::ProcessScene ()
     // - nothing to do for cameras for the moment
 
     // Process all animations
-    for (unsigned int i = 0; i < scene->mNumAnimations;++i)
+    for (unsigned int i = 0; i < scene->mNumAnimations; ++i) {
+        if (nullptr == scene->mAnimations[i]) {
+            continue;
+        }
         ProcessAnimation(scene->mAnimations[i]);
+    }
 
     // Generate a default material if none was specified
     if (!scene->mNumMaterials && scene->mNumMeshes) {
-        scene->mMaterials      = new aiMaterial*[2];
-        aiMaterial* helper;
+        scene->mMaterials = new aiMaterial *[2];
+        aiMaterial *helper;
 
         aiString name;
 
         scene->mMaterials[scene->mNumMaterials] = helper = new aiMaterial();
-        aiColor3D clr(0.6f,0.6f,0.6f);
-        helper->AddProperty(&clr,1,AI_MATKEY_COLOR_DIFFUSE);
+        aiColor3D clr(0.6f, 0.6f, 0.6f);
+        helper->AddProperty(&clr, 1, AI_MATKEY_COLOR_DIFFUSE);
 
         // setup the default name to make this material identifiable
         name.Set(AI_DEFAULT_MATERIAL_NAME);
-        helper->AddProperty(&name,AI_MATKEY_NAME);
+        helper->AddProperty(&name, AI_MATKEY_NAME);
 
-        ASSIMP_LOG_DEBUG("ScenePreprocessor: Adding default material \'" AI_DEFAULT_MATERIAL_NAME  "\'");
+        ASSIMP_LOG_DEBUG("ScenePreprocessor: Adding default material \'" AI_DEFAULT_MATERIAL_NAME "\'");
 
-        for (unsigned int i = 0; i < scene->mNumMeshes;++i) {
+        for (unsigned int i = 0; i < scene->mNumMeshes; ++i) {
+            if (nullptr == scene->mMeshes[i]) {
+                continue;
+            }
             scene->mMeshes[i]->mMaterialIndex = scene->mNumMaterials;
         }
 
@@ -92,34 +100,35 @@ void ScenePreprocessor::ProcessScene ()
 }
 
 // ---------------------------------------------------------------------------------------------
-void ScenePreprocessor::ProcessMesh (aiMesh* mesh)
-{
+void ScenePreprocessor::ProcessMesh(aiMesh *mesh) {
     // If aiMesh::mNumUVComponents is *not* set assign the default value of 2
-    for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i)   {
+    for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
         if (!mesh->mTextureCoords[i]) {
             mesh->mNumUVComponents[i] = 0;
         } else {
-            if (!mesh->mNumUVComponents[i])
+            if (!mesh->mNumUVComponents[i]) {
                 mesh->mNumUVComponents[i] = 2;
+            }
 
-            aiVector3D* p = mesh->mTextureCoords[i], *end = p+mesh->mNumVertices;
+            aiVector3D *p = mesh->mTextureCoords[i], *end = p + mesh->mNumVertices;
 
             // Ensure unused components are zeroed. This will make 1D texture channels work
             // as if they were 2D channels .. just in case an application doesn't handle
             // this case
             if (2 == mesh->mNumUVComponents[i]) {
-                for (; p != end; ++p)
+                for (; p != end; ++p) {
                     p->z = 0.f;
-            }
-            else if (1 == mesh->mNumUVComponents[i]) {
-                for (; p != end; ++p)
+                }
+            } else if (1 == mesh->mNumUVComponents[i]) {
+                for (; p != end; ++p) {
                     p->z = p->y = 0.f;
-            }
-            else if (3 == mesh->mNumUVComponents[i]) {
+                }
+            } else if (3 == mesh->mNumUVComponents[i]) {
                 // Really 3D coordinates? Check whether the third coordinate is != 0 for at least one element
                 for (; p != end; ++p) {
-                    if (p->z != 0)
+                    if (p->z != 0) {
                         break;
+                    }
                 }
                 if (p == end) {
                     ASSIMP_LOG_WARN("ScenePreprocessor: UVs are declared to be 3D but they're obviously not. Reverting to 2D.");
@@ -132,10 +141,9 @@ void ScenePreprocessor::ProcessMesh (aiMesh* mesh)
     // If the information which primitive types are there in the
     // mesh is currently not available, compute it.
     if (!mesh->mPrimitiveTypes) {
-        for (unsigned int a = 0; a < mesh->mNumFaces; ++a)  {
-            aiFace& face = mesh->mFaces[a];
-            switch (face.mNumIndices)
-            {
+        for (unsigned int a = 0; a < mesh->mNumFaces; ++a) {
+            aiFace &face = mesh->mFaces[a];
+            switch (face.mNumIndices) {
             case 3u:
                 mesh->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
                 break;
@@ -156,106 +164,122 @@ void ScenePreprocessor::ProcessMesh (aiMesh* mesh)
     }
 
     // If tangents and normals are given but no bitangents compute them
-    if (mesh->mTangents && mesh->mNormals && !mesh->mBitangents)    {
-
+    if (mesh->mTangents && mesh->mNormals && !mesh->mBitangents) {
         mesh->mBitangents = new aiVector3D[mesh->mNumVertices];
-        for (unsigned int i = 0; i < mesh->mNumVertices;++i)    {
+        for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
             mesh->mBitangents[i] = mesh->mNormals[i] ^ mesh->mTangents[i];
         }
     }
 }
 
 // ---------------------------------------------------------------------------------------------
-void ScenePreprocessor::ProcessAnimation (aiAnimation* anim)
-{
+void ScenePreprocessor::ProcessAnimation(aiAnimation *anim) {
     double first = 10e10, last = -10e10;
-    for (unsigned int i = 0; i < anim->mNumChannels;++i)    {
-        aiNodeAnim* channel = anim->mChannels[i];
+    for (unsigned int i = 0; i < anim->mNumChannels; ++i) {
+        aiNodeAnim *channel = anim->mChannels[i];
 
-        /*  If the exact duration of the animation is not given
-         *  compute it now.
-         */
+        //  If the exact duration of the animation is not given
+        //  compute it now.
         if (anim->mDuration == -1.) {
-
             // Position keys
-            for (unsigned int j = 0; j < channel->mNumPositionKeys;++j) {
-                aiVectorKey& key = channel->mPositionKeys[j];
-                first = std::min (first, key.mTime);
-                last  = std::max (last,  key.mTime);
+            for (unsigned int j = 0; j < channel->mNumPositionKeys; ++j) {
+                aiVectorKey &key = channel->mPositionKeys[j];
+                first = std::min(first, key.mTime);
+                last = std::max(last, key.mTime);
             }
 
             // Scaling keys
-            for (unsigned int j = 0; j < channel->mNumScalingKeys;++j )  {
-                aiVectorKey& key = channel->mScalingKeys[j];
-                first = std::min (first, key.mTime);
-                last  = std::max (last,  key.mTime);
+            for (unsigned int j = 0; j < channel->mNumScalingKeys; ++j) {
+                aiVectorKey &key = channel->mScalingKeys[j];
+                first = std::min(first, key.mTime);
+                last = std::max(last, key.mTime);
             }
 
             // Rotation keys
-            for (unsigned int j = 0; j < channel->mNumRotationKeys;++j ) {
-                aiQuatKey& key = channel->mRotationKeys[ j ];
-                first = std::min (first, key.mTime);
-                last  = std::max (last,  key.mTime);
+            for (unsigned int j = 0; j < channel->mNumRotationKeys; ++j) {
+                aiQuatKey &key = channel->mRotationKeys[j];
+                first = std::min(first, key.mTime);
+                last = std::max(last, key.mTime);
             }
         }
 
-        /*  Check whether the animation channel has no rotation
-         *  or position tracks. In this case we generate a dummy
-         *  track from the information we have in the transformation
-         *  matrix of the corresponding node.
-         */
-        if (!channel->mNumRotationKeys || !channel->mNumPositionKeys || !channel->mNumScalingKeys)  {
+        // Check whether the animation channel has no rotation
+        // or position tracks. In this case we generate a dummy
+        // track from the information we have in the transformation
+        // matrix of the corresponding node.
+        if (!channel->mNumRotationKeys || !channel->mNumPositionKeys || !channel->mNumScalingKeys) {
             // Find the node that belongs to this animation
-            aiNode* node = scene->mRootNode->FindNode(channel->mNodeName);
-            if (node) // ValidateDS will complain later if 'node' is NULL
+            aiNode *node = scene->mRootNode->FindNode(channel->mNodeName);
+            if (node) // ValidateDS will complain later if 'node' is nullptr
             {
                 // Decompose the transformation matrix of the node
                 aiVector3D scaling, position;
                 aiQuaternion rotation;
 
-                node->mTransformation.Decompose(scaling, rotation,position);
+                node->mTransformation.Decompose(scaling, rotation, position);
 
                 // No rotation keys? Generate a dummy track
                 if (!channel->mNumRotationKeys) {
+                    if (channel->mRotationKeys) {
+                        delete[] channel->mRotationKeys;
+                        channel->mRotationKeys = nullptr;
+                    }
+                    ai_assert(!channel->mRotationKeys);
                     channel->mNumRotationKeys = 1;
                     channel->mRotationKeys = new aiQuatKey[1];
-                    aiQuatKey& q = channel->mRotationKeys[0];
+                    aiQuatKey &q = channel->mRotationKeys[0];
 
-                    q.mTime  = 0.;
+                    q.mTime = 0.;
                     q.mValue = rotation;
 
-                    ASSIMP_LOG_DEBUG("ScenePreprocessor: Dummy rotation track has been generated");
+                    ASSIMP_LOG_VERBOSE_DEBUG("ScenePreprocessor: Dummy rotation track has been generated");
+                } else {
+                    ai_assert(channel->mRotationKeys);
                 }
 
                 // No scaling keys? Generate a dummy track
-                if (!channel->mNumScalingKeys)  {
+                if (!channel->mNumScalingKeys) {
+                    if (channel->mScalingKeys) {
+                        delete[] channel->mScalingKeys;
+                        channel->mScalingKeys = nullptr;
+                    }
+                    ai_assert(!channel->mScalingKeys);
                     channel->mNumScalingKeys = 1;
                     channel->mScalingKeys = new aiVectorKey[1];
-                    aiVectorKey& q = channel->mScalingKeys[0];
+                    aiVectorKey &q = channel->mScalingKeys[0];
 
-                    q.mTime  = 0.;
+                    q.mTime = 0.;
                     q.mValue = scaling;
 
-                    ASSIMP_LOG_DEBUG("ScenePreprocessor: Dummy scaling track has been generated");
+                    ASSIMP_LOG_VERBOSE_DEBUG("ScenePreprocessor: Dummy scaling track has been generated");
+                } else {
+                    ai_assert(channel->mScalingKeys);
                 }
 
                 // No position keys? Generate a dummy track
                 if (!channel->mNumPositionKeys) {
+                    if (channel->mPositionKeys) {
+                        delete[] channel->mPositionKeys;
+                        channel->mPositionKeys = nullptr;
+                    }
+                    ai_assert(!channel->mPositionKeys);
                     channel->mNumPositionKeys = 1;
                     channel->mPositionKeys = new aiVectorKey[1];
-                    aiVectorKey& q = channel->mPositionKeys[0];
+                    aiVectorKey &q = channel->mPositionKeys[0];
 
-                    q.mTime  = 0.;
+                    q.mTime = 0.;
                     q.mValue = position;
 
-                    ASSIMP_LOG_DEBUG("ScenePreprocessor: Dummy position track has been generated");
+                    ASSIMP_LOG_VERBOSE_DEBUG("ScenePreprocessor: Dummy position track has been generated");
+                } else {
+                    ai_assert(channel->mPositionKeys);
                 }
             }
         }
     }
 
-    if (anim->mDuration == -1.)     {
-        ASSIMP_LOG_DEBUG("ScenePreprocessor: Setting animation duration");
-        anim->mDuration = last - std::min( first, 0. );
+    if (anim->mDuration == -1.) {
+        ASSIMP_LOG_VERBOSE_DEBUG("ScenePreprocessor: Setting animation duration");
+        anim->mDuration = last - std::min(first, 0.);
     }
 }
diff --git a/Engine/lib/assimp/code/Common/ScenePreprocessor.h b/Engine/lib/assimp/code/Common/ScenePreprocessor.h
index 3f4c8d7c3..49e06ed1c 100644
--- a/Engine/lib/assimp/code/Common/ScenePreprocessor.h
+++ b/Engine/lib/assimp/code/Common/ScenePreprocessor.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -53,7 +53,7 @@ struct aiAnimation;
 struct aiMesh;
 
 class ScenePreprocessorTest;
-namespace Assimp    {
+namespace Assimp {
 
 // ----------------------------------------------------------------------------------
 /** ScenePreprocessor: Preprocess a scene before any post-processing
@@ -63,24 +63,21 @@ namespace Assimp    {
  *  importer, such as aiMesh::mPrimitiveTypes.
 */
 // ----------------------------------------------------------------------------------
-class ASSIMP_API ScenePreprocessor
-{
+class ASSIMP_API ScenePreprocessor {
     // Make ourselves a friend of the corresponding test unit.
     friend class ::ScenePreprocessorTest;
-public:
 
+public:
     // ----------------------------------------------------------------
     /** Default c'tpr. Use SetScene() to assign a scene to the object.
      */
-    ScenePreprocessor()
-        :   scene   (NULL)
-    {}
+    ScenePreprocessor() :
+            scene(nullptr) {}
 
     /** Constructs the object and assigns a specific scene to it
      */
-    ScenePreprocessor(aiScene* _scene)
-        :   scene   (_scene)
-    {}
+    ScenePreprocessor(aiScene *_scene) :
+            scene(_scene) {}
 
     // ----------------------------------------------------------------
     /** Assign a (new) scene to the object.
@@ -89,37 +86,33 @@ public:
      *  Call ProcessScene to have the scene preprocessed.
      *  @param sc Scene to be processed.
      */
-    void SetScene (aiScene* sc) {
+    void SetScene(aiScene *sc) {
         scene = sc;
     }
 
     // ----------------------------------------------------------------
     /** Preprocess the current scene
      */
-    void ProcessScene ();
+    void ProcessScene();
 
 protected:
-
     // ----------------------------------------------------------------
     /** Preprocess an animation in the scene
      *  @param anim Anim to be preprocessed.
      */
-    void ProcessAnimation (aiAnimation* anim);
-
+    void ProcessAnimation(aiAnimation *anim);
 
     // ----------------------------------------------------------------
     /** Preprocess a mesh in the scene
      *  @param mesh Mesh to be preprocessed.
      */
-    void ProcessMesh (aiMesh* mesh);
+    void ProcessMesh(aiMesh *mesh);
 
 protected:
-
     //! Scene we're currently working on
-    aiScene* scene;
+    aiScene *scene;
 };
 
-
-} // ! end namespace Assimp
+} // namespace Assimp
 
 #endif // include guard
diff --git a/Engine/lib/assimp/code/Common/ScenePrivate.h b/Engine/lib/assimp/code/Common/ScenePrivate.h
index f336aafc9..3910db78c 100644
--- a/Engine/lib/assimp/code/Common/ScenePrivate.h
+++ b/Engine/lib/assimp/code/Common/ScenePrivate.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Common/SkeletonMeshBuilder.cpp b/Engine/lib/assimp/code/Common/SkeletonMeshBuilder.cpp
index 06cfe034e..5ea30d9c7 100644
--- a/Engine/lib/assimp/code/Common/SkeletonMeshBuilder.cpp
+++ b/Engine/lib/assimp/code/Common/SkeletonMeshBuilder.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -44,30 +44,31 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Implementation of a little class to construct a dummy mesh for a skeleton
  */
 
-#include <assimp/scene.h>
 #include <assimp/SkeletonMeshBuilder.h>
+#include <assimp/scene.h>
 
 using namespace Assimp;
 
 // ------------------------------------------------------------------------------------------------
 // The constructor processes the given scene and adds a mesh there.
-SkeletonMeshBuilder::SkeletonMeshBuilder( aiScene* pScene, aiNode* root, bool bKnobsOnly)
-{
+SkeletonMeshBuilder::SkeletonMeshBuilder(aiScene *pScene, aiNode *root, bool bKnobsOnly) {
     // nothing to do if there's mesh data already present at the scene
-    if( pScene->mNumMeshes > 0 || pScene->mRootNode == NULL)
+    if (pScene->mNumMeshes > 0 || pScene->mRootNode == nullptr) {
         return;
+    }
 
-    if (!root)
+    if (!root) {
         root = pScene->mRootNode;
+    }
 
     mKnobsOnly = bKnobsOnly;
 
     // build some faces around each node
-    CreateGeometry( root );
+    CreateGeometry(root);
 
     // create a mesh to hold all the generated faces
     pScene->mNumMeshes = 1;
-    pScene->mMeshes = new aiMesh*[1];
+    pScene->mMeshes = new aiMesh *[1];
     pScene->mMeshes[0] = CreateMesh();
     // and install it at the root node
     root->mNumMeshes = 1;
@@ -75,154 +76,146 @@ SkeletonMeshBuilder::SkeletonMeshBuilder( aiScene* pScene, aiNode* root, bool bK
     root->mMeshes[0] = 0;
 
     // create a dummy material for the mesh
-    if(pScene->mNumMaterials==0){
-		pScene->mNumMaterials = 1;
-		pScene->mMaterials = new aiMaterial*[1];
-		pScene->mMaterials[0] = CreateMaterial();
+    if (pScene->mNumMaterials == 0) {
+        pScene->mNumMaterials = 1;
+        pScene->mMaterials = new aiMaterial *[1];
+        pScene->mMaterials[0] = CreateMaterial();
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Recursively builds a simple mesh representation for the given node
-void SkeletonMeshBuilder::CreateGeometry( const aiNode* pNode)
-{
+void SkeletonMeshBuilder::CreateGeometry(const aiNode *pNode) {
     // add a joint entry for the node.
     const unsigned int vertexStartIndex = static_cast<unsigned int>(mVertices.size());
 
     // now build the geometry.
-    if( pNode->mNumChildren > 0 && !mKnobsOnly)
-    {
+    if (pNode->mNumChildren > 0 && !mKnobsOnly) {
         // If the node has children, we build little pointers to each of them
-        for( unsigned int a = 0; a < pNode->mNumChildren; a++)
-        {
+        for (unsigned int a = 0; a < pNode->mNumChildren; a++) {
             // find a suitable coordinate system
-            const aiMatrix4x4& childTransform = pNode->mChildren[a]->mTransformation;
-            aiVector3D childpos( childTransform.a4, childTransform.b4, childTransform.c4);
+            const aiMatrix4x4 &childTransform = pNode->mChildren[a]->mTransformation;
+            aiVector3D childpos(childTransform.a4, childTransform.b4, childTransform.c4);
             ai_real distanceToChild = childpos.Length();
-            if( distanceToChild < 0.0001)
+            if (distanceToChild < 0.0001)
                 continue;
-            aiVector3D up = aiVector3D( childpos).Normalize();
+            aiVector3D up = aiVector3D(childpos).Normalize();
 
-            aiVector3D orth( 1.0, 0.0, 0.0);
-            if( std::fabs( orth * up) > 0.99)
-                orth.Set( 0.0, 1.0, 0.0);
+            aiVector3D orth(1.0, 0.0, 0.0);
+            if (std::fabs(orth * up) > 0.99)
+                orth.Set(0.0, 1.0, 0.0);
 
             aiVector3D front = (up ^ orth).Normalize();
             aiVector3D side = (front ^ up).Normalize();
 
             unsigned int localVertexStart = static_cast<unsigned int>(mVertices.size());
-            mVertices.push_back( -front * distanceToChild * (ai_real)0.1);
-            mVertices.push_back( childpos);
-            mVertices.push_back( -side * distanceToChild * (ai_real)0.1);
-            mVertices.push_back( -side * distanceToChild * (ai_real)0.1);
-            mVertices.push_back( childpos);
-            mVertices.push_back( front * distanceToChild * (ai_real)0.1);
-            mVertices.push_back( front * distanceToChild * (ai_real)0.1);
-            mVertices.push_back( childpos);
-            mVertices.push_back( side * distanceToChild * (ai_real)0.1);
-            mVertices.push_back( side * distanceToChild * (ai_real)0.1);
-            mVertices.push_back( childpos);
-            mVertices.push_back( -front * distanceToChild * (ai_real)0.1);
+            mVertices.push_back(-front * distanceToChild * (ai_real)0.1);
+            mVertices.push_back(childpos);
+            mVertices.push_back(-side * distanceToChild * (ai_real)0.1);
+            mVertices.push_back(-side * distanceToChild * (ai_real)0.1);
+            mVertices.push_back(childpos);
+            mVertices.push_back(front * distanceToChild * (ai_real)0.1);
+            mVertices.push_back(front * distanceToChild * (ai_real)0.1);
+            mVertices.push_back(childpos);
+            mVertices.push_back(side * distanceToChild * (ai_real)0.1);
+            mVertices.push_back(side * distanceToChild * (ai_real)0.1);
+            mVertices.push_back(childpos);
+            mVertices.push_back(-front * distanceToChild * (ai_real)0.1);
 
-            mFaces.push_back( Face( localVertexStart + 0, localVertexStart + 1, localVertexStart + 2));
-            mFaces.push_back( Face( localVertexStart + 3, localVertexStart + 4, localVertexStart + 5));
-            mFaces.push_back( Face( localVertexStart + 6, localVertexStart + 7, localVertexStart + 8));
-            mFaces.push_back( Face( localVertexStart + 9, localVertexStart + 10, localVertexStart + 11));
+            mFaces.push_back(Face(localVertexStart + 0, localVertexStart + 1, localVertexStart + 2));
+            mFaces.push_back(Face(localVertexStart + 3, localVertexStart + 4, localVertexStart + 5));
+            mFaces.push_back(Face(localVertexStart + 6, localVertexStart + 7, localVertexStart + 8));
+            mFaces.push_back(Face(localVertexStart + 9, localVertexStart + 10, localVertexStart + 11));
         }
-    }
-    else
-    {
+    } else {
         // if the node has no children, it's an end node. Put a little knob there instead
-        aiVector3D ownpos( pNode->mTransformation.a4, pNode->mTransformation.b4, pNode->mTransformation.c4);
-        ai_real sizeEstimate = ownpos.Length() * ai_real( 0.18 );
+        aiVector3D ownpos(pNode->mTransformation.a4, pNode->mTransformation.b4, pNode->mTransformation.c4);
+        ai_real sizeEstimate = ownpos.Length() * ai_real(0.18);
 
-        mVertices.push_back( aiVector3D( -sizeEstimate, 0.0, 0.0));
-        mVertices.push_back( aiVector3D( 0.0, sizeEstimate, 0.0));
-        mVertices.push_back( aiVector3D( 0.0, 0.0, -sizeEstimate));
-        mVertices.push_back( aiVector3D( 0.0, sizeEstimate, 0.0));
-        mVertices.push_back( aiVector3D( sizeEstimate, 0.0, 0.0));
-        mVertices.push_back( aiVector3D( 0.0, 0.0, -sizeEstimate));
-        mVertices.push_back( aiVector3D( sizeEstimate, 0.0, 0.0));
-        mVertices.push_back( aiVector3D( 0.0, -sizeEstimate, 0.0));
-        mVertices.push_back( aiVector3D( 0.0, 0.0, -sizeEstimate));
-        mVertices.push_back( aiVector3D( 0.0, -sizeEstimate, 0.0));
-        mVertices.push_back( aiVector3D( -sizeEstimate, 0.0, 0.0));
-        mVertices.push_back( aiVector3D( 0.0, 0.0, -sizeEstimate));
+        mVertices.push_back(aiVector3D(-sizeEstimate, 0.0, 0.0));
+        mVertices.push_back(aiVector3D(0.0, sizeEstimate, 0.0));
+        mVertices.push_back(aiVector3D(0.0, 0.0, -sizeEstimate));
+        mVertices.push_back(aiVector3D(0.0, sizeEstimate, 0.0));
+        mVertices.push_back(aiVector3D(sizeEstimate, 0.0, 0.0));
+        mVertices.push_back(aiVector3D(0.0, 0.0, -sizeEstimate));
+        mVertices.push_back(aiVector3D(sizeEstimate, 0.0, 0.0));
+        mVertices.push_back(aiVector3D(0.0, -sizeEstimate, 0.0));
+        mVertices.push_back(aiVector3D(0.0, 0.0, -sizeEstimate));
+        mVertices.push_back(aiVector3D(0.0, -sizeEstimate, 0.0));
+        mVertices.push_back(aiVector3D(-sizeEstimate, 0.0, 0.0));
+        mVertices.push_back(aiVector3D(0.0, 0.0, -sizeEstimate));
 
-        mVertices.push_back( aiVector3D( -sizeEstimate, 0.0, 0.0));
-        mVertices.push_back( aiVector3D( 0.0, 0.0, sizeEstimate));
-        mVertices.push_back( aiVector3D( 0.0, sizeEstimate, 0.0));
-        mVertices.push_back( aiVector3D( 0.0, sizeEstimate, 0.0));
-        mVertices.push_back( aiVector3D( 0.0, 0.0, sizeEstimate));
-        mVertices.push_back( aiVector3D( sizeEstimate, 0.0, 0.0));
-        mVertices.push_back( aiVector3D( sizeEstimate, 0.0, 0.0));
-        mVertices.push_back( aiVector3D( 0.0, 0.0, sizeEstimate));
-        mVertices.push_back( aiVector3D( 0.0, -sizeEstimate, 0.0));
-        mVertices.push_back( aiVector3D( 0.0, -sizeEstimate, 0.0));
-        mVertices.push_back( aiVector3D( 0.0, 0.0, sizeEstimate));
-        mVertices.push_back( aiVector3D( -sizeEstimate, 0.0, 0.0));
+        mVertices.push_back(aiVector3D(-sizeEstimate, 0.0, 0.0));
+        mVertices.push_back(aiVector3D(0.0, 0.0, sizeEstimate));
+        mVertices.push_back(aiVector3D(0.0, sizeEstimate, 0.0));
+        mVertices.push_back(aiVector3D(0.0, sizeEstimate, 0.0));
+        mVertices.push_back(aiVector3D(0.0, 0.0, sizeEstimate));
+        mVertices.push_back(aiVector3D(sizeEstimate, 0.0, 0.0));
+        mVertices.push_back(aiVector3D(sizeEstimate, 0.0, 0.0));
+        mVertices.push_back(aiVector3D(0.0, 0.0, sizeEstimate));
+        mVertices.push_back(aiVector3D(0.0, -sizeEstimate, 0.0));
+        mVertices.push_back(aiVector3D(0.0, -sizeEstimate, 0.0));
+        mVertices.push_back(aiVector3D(0.0, 0.0, sizeEstimate));
+        mVertices.push_back(aiVector3D(-sizeEstimate, 0.0, 0.0));
 
-        mFaces.push_back( Face( vertexStartIndex + 0, vertexStartIndex + 1, vertexStartIndex + 2));
-        mFaces.push_back( Face( vertexStartIndex + 3, vertexStartIndex + 4, vertexStartIndex + 5));
-        mFaces.push_back( Face( vertexStartIndex + 6, vertexStartIndex + 7, vertexStartIndex + 8));
-        mFaces.push_back( Face( vertexStartIndex + 9, vertexStartIndex + 10, vertexStartIndex + 11));
-        mFaces.push_back( Face( vertexStartIndex + 12, vertexStartIndex + 13, vertexStartIndex + 14));
-        mFaces.push_back( Face( vertexStartIndex + 15, vertexStartIndex + 16, vertexStartIndex + 17));
-        mFaces.push_back( Face( vertexStartIndex + 18, vertexStartIndex + 19, vertexStartIndex + 20));
-        mFaces.push_back( Face( vertexStartIndex + 21, vertexStartIndex + 22, vertexStartIndex + 23));
+        mFaces.push_back(Face(vertexStartIndex + 0, vertexStartIndex + 1, vertexStartIndex + 2));
+        mFaces.push_back(Face(vertexStartIndex + 3, vertexStartIndex + 4, vertexStartIndex + 5));
+        mFaces.push_back(Face(vertexStartIndex + 6, vertexStartIndex + 7, vertexStartIndex + 8));
+        mFaces.push_back(Face(vertexStartIndex + 9, vertexStartIndex + 10, vertexStartIndex + 11));
+        mFaces.push_back(Face(vertexStartIndex + 12, vertexStartIndex + 13, vertexStartIndex + 14));
+        mFaces.push_back(Face(vertexStartIndex + 15, vertexStartIndex + 16, vertexStartIndex + 17));
+        mFaces.push_back(Face(vertexStartIndex + 18, vertexStartIndex + 19, vertexStartIndex + 20));
+        mFaces.push_back(Face(vertexStartIndex + 21, vertexStartIndex + 22, vertexStartIndex + 23));
     }
 
     unsigned int numVertices = static_cast<unsigned int>(mVertices.size() - vertexStartIndex);
-    if( numVertices > 0)
-    {
+    if (numVertices > 0) {
         // create a bone affecting all the newly created vertices
-        aiBone* bone = new aiBone;
-        mBones.push_back( bone);
+        aiBone *bone = new aiBone;
+        mBones.push_back(bone);
         bone->mName = pNode->mName;
 
         // calculate the bone offset matrix by concatenating the inverse transformations of all parents
-        bone->mOffsetMatrix = aiMatrix4x4( pNode->mTransformation).Inverse();
-        for( aiNode* parent = pNode->mParent; parent != NULL; parent = parent->mParent)
-            bone->mOffsetMatrix = aiMatrix4x4( parent->mTransformation).Inverse() * bone->mOffsetMatrix;
+        bone->mOffsetMatrix = aiMatrix4x4(pNode->mTransformation).Inverse();
+        for (aiNode *parent = pNode->mParent; parent != nullptr; parent = parent->mParent)
+            bone->mOffsetMatrix = aiMatrix4x4(parent->mTransformation).Inverse() * bone->mOffsetMatrix;
 
         // add all the vertices to the bone's influences
         bone->mNumWeights = numVertices;
         bone->mWeights = new aiVertexWeight[numVertices];
-        for( unsigned int a = 0; a < numVertices; a++)
-            bone->mWeights[a] = aiVertexWeight( vertexStartIndex + a, 1.0);
+        for (unsigned int a = 0; a < numVertices; a++)
+            bone->mWeights[a] = aiVertexWeight(vertexStartIndex + a, 1.0);
 
         // HACK: (thom) transform all vertices to the bone's local space. Should be done before adding
         // them to the array, but I'm tired now and I'm annoyed.
-        aiMatrix4x4 boneToMeshTransform = aiMatrix4x4( bone->mOffsetMatrix).Inverse();
-        for( unsigned int a = vertexStartIndex; a < mVertices.size(); a++)
+        aiMatrix4x4 boneToMeshTransform = aiMatrix4x4(bone->mOffsetMatrix).Inverse();
+        for (unsigned int a = vertexStartIndex; a < mVertices.size(); a++)
             mVertices[a] = boneToMeshTransform * mVertices[a];
     }
 
     // and finally recurse into the children list
-    for( unsigned int a = 0; a < pNode->mNumChildren; a++)
-        CreateGeometry( pNode->mChildren[a]);
+    for (unsigned int a = 0; a < pNode->mNumChildren; a++)
+        CreateGeometry(pNode->mChildren[a]);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Creates the mesh from the internally accumulated stuff and returns it.
-aiMesh* SkeletonMeshBuilder::CreateMesh()
-{
-    aiMesh* mesh = new aiMesh();
+aiMesh *SkeletonMeshBuilder::CreateMesh() {
+    aiMesh *mesh = new aiMesh();
 
     // add points
     mesh->mNumVertices = static_cast<unsigned int>(mVertices.size());
     mesh->mVertices = new aiVector3D[mesh->mNumVertices];
-    std::copy( mVertices.begin(), mVertices.end(), mesh->mVertices);
+    std::copy(mVertices.begin(), mVertices.end(), mesh->mVertices);
 
     mesh->mNormals = new aiVector3D[mesh->mNumVertices];
 
     // add faces
     mesh->mNumFaces = static_cast<unsigned int>(mFaces.size());
     mesh->mFaces = new aiFace[mesh->mNumFaces];
-    for( unsigned int a = 0; a < mesh->mNumFaces; a++)
-    {
-        const Face& inface = mFaces[a];
-        aiFace& outface = mesh->mFaces[a];
+    for (unsigned int a = 0; a < mesh->mNumFaces; a++) {
+        const Face &inface = mFaces[a];
+        aiFace &outface = mesh->mFaces[a];
         outface.mNumIndices = 3;
         outface.mIndices = new unsigned int[3];
         outface.mIndices[0] = inface.mIndices[0];
@@ -232,10 +225,10 @@ aiMesh* SkeletonMeshBuilder::CreateMesh()
         // Compute per-face normals ... we don't want the bones to be smoothed ... they're built to visualize
         // the skeleton, so it's good if there's a visual difference to the rest of the geometry
         aiVector3D nor = ((mVertices[inface.mIndices[2]] - mVertices[inface.mIndices[0]]) ^
-            (mVertices[inface.mIndices[1]] - mVertices[inface.mIndices[0]]));
+                          (mVertices[inface.mIndices[1]] - mVertices[inface.mIndices[0]]));
 
         if (nor.Length() < 1e-5) /* ensure that FindInvalidData won't remove us ...*/
-            nor = aiVector3D(1.0,0.0,0.0);
+            nor = aiVector3D(1.0, 0.0, 0.0);
 
         for (unsigned int n = 0; n < 3; ++n)
             mesh->mNormals[inface.mIndices[n]] = nor;
@@ -243,8 +236,8 @@ aiMesh* SkeletonMeshBuilder::CreateMesh()
 
     // add the bones
     mesh->mNumBones = static_cast<unsigned int>(mBones.size());
-    mesh->mBones = new aiBone*[mesh->mNumBones];
-    std::copy( mBones.begin(), mBones.end(), mesh->mBones);
+    mesh->mBones = new aiBone *[mesh->mNumBones];
+    std::copy(mBones.begin(), mBones.end(), mesh->mBones);
 
     // default
     mesh->mMaterialIndex = 0;
@@ -254,17 +247,16 @@ aiMesh* SkeletonMeshBuilder::CreateMesh()
 
 // ------------------------------------------------------------------------------------------------
 // Creates a dummy material and returns it.
-aiMaterial* SkeletonMeshBuilder::CreateMaterial()
-{
-    aiMaterial* matHelper = new aiMaterial;
+aiMaterial *SkeletonMeshBuilder::CreateMaterial() {
+    aiMaterial *matHelper = new aiMaterial;
 
     // Name
-    aiString matName( std::string( "SkeletonMaterial"));
-    matHelper->AddProperty( &matName, AI_MATKEY_NAME);
+    aiString matName(std::string("SkeletonMaterial"));
+    matHelper->AddProperty(&matName, AI_MATKEY_NAME);
 
     // Prevent backface culling
     const int no_cull = 1;
-    matHelper->AddProperty(&no_cull,1,AI_MATKEY_TWOSIDED);
+    matHelper->AddProperty(&no_cull, 1, AI_MATKEY_TWOSIDED);
 
     return matHelper;
 }
diff --git a/Engine/lib/assimp/code/Common/SpatialSort.cpp b/Engine/lib/assimp/code/Common/SpatialSort.cpp
index a4f3a4e4b..6103002cc 100644
--- a/Engine/lib/assimp/code/Common/SpatialSort.cpp
+++ b/Engine/lib/assimp/code/Common/SpatialSort.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -50,67 +48,75 @@ using namespace Assimp;
 
 // CHAR_BIT seems to be defined under MVSC, but not under GCC. Pray that the correct value is 8.
 #ifndef CHAR_BIT
-#   define CHAR_BIT 8
+#define CHAR_BIT 8
 #endif
 
+const aiVector3D PlaneInit(0.8523f, 0.34321f, 0.5736f);
+
 // ------------------------------------------------------------------------------------------------
 // Constructs a spatially sorted representation from the given position array.
-SpatialSort::SpatialSort( const aiVector3D* pPositions, unsigned int pNumPositions,
-    unsigned int pElementOffset)
-
-    // define the reference plane. We choose some arbitrary vector away from all basic axises
-    // in the hope that no model spreads all its vertices along this plane.
-    : mPlaneNormal(0.8523f, 0.34321f, 0.5736f)
-{
+// define the reference plane. We choose some arbitrary vector away from all basic axes
+// in the hope that no model spreads all its vertices along this plane.
+SpatialSort::SpatialSort(const aiVector3D *pPositions, unsigned int pNumPositions, unsigned int pElementOffset) :
+        mPlaneNormal(PlaneInit),
+        mFinalized(false) {
     mPlaneNormal.Normalize();
-    Fill(pPositions,pNumPositions,pElementOffset);
+    Fill(pPositions, pNumPositions, pElementOffset);
 }
 
 // ------------------------------------------------------------------------------------------------
-SpatialSort :: SpatialSort()
-: mPlaneNormal(0.8523f, 0.34321f, 0.5736f)
-{
+SpatialSort::SpatialSort() :
+        mPlaneNormal(PlaneInit),
+        mFinalized(false) {
     mPlaneNormal.Normalize();
 }
 
 // ------------------------------------------------------------------------------------------------
 // Destructor
-SpatialSort::~SpatialSort()
-{
-    // nothing to do here, everything destructs automatically
+SpatialSort::~SpatialSort() {
+    // empty
 }
 
 // ------------------------------------------------------------------------------------------------
-void SpatialSort::Fill( const aiVector3D* pPositions, unsigned int pNumPositions,
-    unsigned int pElementOffset,
-    bool pFinalize /*= true */)
-{
+void SpatialSort::Fill(const aiVector3D *pPositions, unsigned int pNumPositions,
+        unsigned int pElementOffset,
+        bool pFinalize /*= true */) {
     mPositions.clear();
-    Append(pPositions,pNumPositions,pElementOffset,pFinalize);
+    mFinalized = false;
+    Append(pPositions, pNumPositions, pElementOffset, pFinalize);
+    mFinalized = pFinalize;
 }
 
 // ------------------------------------------------------------------------------------------------
-void SpatialSort :: Finalize()
-{
-    std::sort( mPositions.begin(), mPositions.end());
+ai_real SpatialSort::CalculateDistance(const aiVector3D &pPosition) const {
+    return (pPosition - mCentroid) * mPlaneNormal;
 }
 
 // ------------------------------------------------------------------------------------------------
-void SpatialSort::Append( const aiVector3D* pPositions, unsigned int pNumPositions,
-    unsigned int pElementOffset,
-    bool pFinalize /*= true */)
-{
+void SpatialSort::Finalize() {
+    const ai_real scale = 1.0f / mPositions.size();
+    for (unsigned int i = 0; i < mPositions.size(); i++) {
+        mCentroid += scale * mPositions[i].mPosition; 
+    }
+    for (unsigned int i = 0; i < mPositions.size(); i++) {
+        mPositions[i].mDistance = CalculateDistance(mPositions[i].mPosition);
+    }
+    std::sort(mPositions.begin(), mPositions.end());
+    mFinalized = true;
+}
+
+// ------------------------------------------------------------------------------------------------
+void SpatialSort::Append(const aiVector3D *pPositions, unsigned int pNumPositions,
+        unsigned int pElementOffset,
+        bool pFinalize /*= true */) {
+    ai_assert(!mFinalized && "You cannot add positions to the SpatialSort object after it has been finalized.");
     // store references to all given positions along with their distance to the reference plane
     const size_t initial = mPositions.size();
-    mPositions.reserve(initial + (pFinalize?pNumPositions:pNumPositions*2));
-    for( unsigned int a = 0; a < pNumPositions; a++)
-    {
-        const char* tempPointer = reinterpret_cast<const char*> (pPositions);
-        const aiVector3D* vec   = reinterpret_cast<const aiVector3D*> (tempPointer + a * pElementOffset);
-
-        // store position by index and distance
-        ai_real distance = *vec * mPlaneNormal;
-        mPositions.push_back( Entry( static_cast<unsigned int>(a+initial), *vec, distance));
+    mPositions.reserve(initial + pNumPositions);
+    for (unsigned int a = 0; a < pNumPositions; a++) {
+        const char *tempPointer = reinterpret_cast<const char *>(pPositions);
+        const aiVector3D *vec = reinterpret_cast<const aiVector3D *>(tempPointer + a * pElementOffset);
+        mPositions.push_back(Entry(static_cast<unsigned int>(a + initial), *vec));
     }
 
     if (pFinalize) {
@@ -121,29 +127,28 @@ void SpatialSort::Append( const aiVector3D* pPositions, unsigned int pNumPositio
 
 // ------------------------------------------------------------------------------------------------
 // Returns an iterator for all positions close to the given position.
-void SpatialSort::FindPositions( const aiVector3D& pPosition,
-    ai_real pRadius, std::vector<unsigned int>& poResults) const
-{
-    const ai_real dist = pPosition * mPlaneNormal;
+void SpatialSort::FindPositions(const aiVector3D &pPosition,
+        ai_real pRadius, std::vector<unsigned int> &poResults) const {
+    ai_assert(mFinalized && "The SpatialSort object must be finalized before FindPositions can be called.");
+    const ai_real dist = CalculateDistance(pPosition);
     const ai_real minDist = dist - pRadius, maxDist = dist + pRadius;
 
     // clear the array
     poResults.clear();
 
     // quick check for positions outside the range
-    if( mPositions.size() == 0)
+    if (mPositions.size() == 0)
         return;
-    if( maxDist < mPositions.front().mDistance)
+    if (maxDist < mPositions.front().mDistance)
         return;
-    if( minDist > mPositions.back().mDistance)
+    if (minDist > mPositions.back().mDistance)
         return;
 
     // do a binary search for the minimal distance to start the iteration there
     unsigned int index = (unsigned int)mPositions.size() / 2;
     unsigned int binaryStepSize = (unsigned int)mPositions.size() / 4;
-    while( binaryStepSize > 1)
-    {
-        if( mPositions[index].mDistance < minDist)
+    while (binaryStepSize > 1) {
+        if (mPositions[index].mDistance < minDist)
             index += binaryStepSize;
         else
             index -= binaryStepSize;
@@ -153,21 +158,20 @@ void SpatialSort::FindPositions( const aiVector3D& pPosition,
 
     // depending on the direction of the last step we need to single step a bit back or forth
     // to find the actual beginning element of the range
-    while( index > 0 && mPositions[index].mDistance > minDist)
+    while (index > 0 && mPositions[index].mDistance > minDist)
         index--;
-    while( index < (mPositions.size() - 1) && mPositions[index].mDistance < minDist)
+    while (index < (mPositions.size() - 1) && mPositions[index].mDistance < minDist)
         index++;
 
     // Mow start iterating from there until the first position lays outside of the distance range.
-    // Add all positions inside the distance range within the given radius to the result aray
+    // Add all positions inside the distance range within the given radius to the result array
     std::vector<Entry>::const_iterator it = mPositions.begin() + index;
-    const ai_real pSquared = pRadius*pRadius;
-    while( it->mDistance < maxDist)
-    {
-        if( (it->mPosition - pPosition).SquareLength() < pSquared)
-            poResults.push_back( it->mIndex);
+    const ai_real pSquared = pRadius * pRadius;
+    while (it->mDistance < maxDist) {
+        if ((it->mPosition - pPosition).SquareLength() < pSquared)
+            poResults.push_back(it->mIndex);
         ++it;
-        if( it == mPositions.end())
+        if (it == mPositions.end())
             break;
     }
 
@@ -176,70 +180,72 @@ void SpatialSort::FindPositions( const aiVector3D& pPosition,
 
 namespace {
 
-    // Binary, signed-integer representation of a single-precision floating-point value.
-    // IEEE 754 says: "If two floating-point numbers in the same format are ordered then they are
-    //  ordered the same way when their bits are reinterpreted as sign-magnitude integers."
-    // This allows us to convert all floating-point numbers to signed integers of arbitrary size
-    //  and then use them to work with ULPs (Units in the Last Place, for high-precision
-    //  computations) or to compare them (integer comparisons are faster than floating-point
-    //  comparisons on many platforms).
-    typedef ai_int BinFloat;
+// Binary, signed-integer representation of a single-precision floating-point value.
+// IEEE 754 says: "If two floating-point numbers in the same format are ordered then they are
+//  ordered the same way when their bits are reinterpreted as sign-magnitude integers."
+// This allows us to convert all floating-point numbers to signed integers of arbitrary size
+//  and then use them to work with ULPs (Units in the Last Place, for high-precision
+//  computations) or to compare them (integer comparisons are faster than floating-point
+//  comparisons on many platforms).
+typedef ai_int BinFloat;
 
-    // --------------------------------------------------------------------------------------------
-    // Converts the bit pattern of a floating-point number to its signed integer representation.
-    BinFloat ToBinary( const ai_real & pValue) {
+// --------------------------------------------------------------------------------------------
+// Converts the bit pattern of a floating-point number to its signed integer representation.
+BinFloat ToBinary(const ai_real &pValue) {
 
-        // If this assertion fails, signed int is not big enough to store a float on your platform.
-        //  Please correct the declaration of BinFloat a few lines above - but do it in a portable,
-        //  #ifdef'd manner!
-        static_assert( sizeof(BinFloat) >= sizeof(ai_real), "sizeof(BinFloat) >= sizeof(ai_real)");
+    // If this assertion fails, signed int is not big enough to store a float on your platform.
+    //  Please correct the declaration of BinFloat a few lines above - but do it in a portable,
+    //  #ifdef'd manner!
+    static_assert(sizeof(BinFloat) >= sizeof(ai_real), "sizeof(BinFloat) >= sizeof(ai_real)");
 
-        #if defined( _MSC_VER)
-            // If this assertion fails, Visual C++ has finally moved to ILP64. This means that this
-            //  code has just become legacy code! Find out the current value of _MSC_VER and modify
-            //  the #if above so it evaluates false on the current and all upcoming VC versions (or
-            //  on the current platform, if LP64 or LLP64 are still used on other platforms).
-            static_assert( sizeof(BinFloat) == sizeof(ai_real), "sizeof(BinFloat) == sizeof(ai_real)");
+#if defined(_MSC_VER)
+    // If this assertion fails, Visual C++ has finally moved to ILP64. This means that this
+    //  code has just become legacy code! Find out the current value of _MSC_VER and modify
+    //  the #if above so it evaluates false on the current and all upcoming VC versions (or
+    //  on the current platform, if LP64 or LLP64 are still used on other platforms).
+    static_assert(sizeof(BinFloat) == sizeof(ai_real), "sizeof(BinFloat) == sizeof(ai_real)");
 
-            // This works best on Visual C++, but other compilers have their problems with it.
-            const BinFloat binValue = reinterpret_cast<BinFloat const &>(pValue);
-        #else
-            // On many compilers, reinterpreting a float address as an integer causes aliasing
-            // problems. This is an ugly but more or less safe way of doing it.
-            union {
-                ai_real     asFloat;
-                BinFloat    asBin;
-            } conversion;
-            conversion.asBin    = 0; // zero empty space in case sizeof(BinFloat) > sizeof(float)
-            conversion.asFloat  = pValue;
-            const BinFloat binValue = conversion.asBin;
-        #endif
+    // This works best on Visual C++, but other compilers have their problems with it.
+    const BinFloat binValue = reinterpret_cast<BinFloat const &>(pValue);
+    //::memcpy(&binValue, &pValue, sizeof(pValue));
+    //return binValue;
+#else
+    // On many compilers, reinterpreting a float address as an integer causes aliasing
+    // problems. This is an ugly but more or less safe way of doing it.
+    union {
+        ai_real asFloat;
+        BinFloat asBin;
+    } conversion;
+    conversion.asBin = 0; // zero empty space in case sizeof(BinFloat) > sizeof(float)
+    conversion.asFloat = pValue;
+    const BinFloat binValue = conversion.asBin;
+#endif
 
-        // floating-point numbers are of sign-magnitude format, so find out what signed number
-        //  representation we must convert negative values to.
-        // See http://en.wikipedia.org/wiki/Signed_number_representations.
+    // floating-point numbers are of sign-magnitude format, so find out what signed number
+    //  representation we must convert negative values to.
+    // See http://en.wikipedia.org/wiki/Signed_number_representations.
+    const BinFloat mask = BinFloat(1) << (CHAR_BIT * sizeof(BinFloat) - 1);
 
-        // Two's complement?
-        if( (-42 == (~42 + 1)) && (binValue & 0x80000000))
-            return BinFloat(1 << (CHAR_BIT * sizeof(BinFloat) - 1)) - binValue;
-        // One's complement?
-        else if ( (-42 == ~42) && (binValue & 0x80000000))
-            return BinFloat(-0) - binValue;
-        // Sign-magnitude?
-        else if( (-42 == (42 | (-0))) && (binValue & 0x80000000)) // -0 = 1000... binary
-            return binValue;
-        else
-            return binValue;
-    }
+    // Two's complement?
+    const bool DefaultValue = ((-42 == (~42 + 1)) && (binValue & mask));
+    const bool OneComplement = ((-42 == ~42) && (binValue & mask));
+
+    if (DefaultValue)
+        return mask - binValue;
+    // One's complement?
+    else if (OneComplement)
+        return BinFloat(-0) - binValue;
+    // Sign-magnitude? -0 = 1000... binary
+    return binValue;
+}
 
 } // namespace
 
 // ------------------------------------------------------------------------------------------------
 // Fills an array with indices of all positions identical to the given position. In opposite to
 // FindPositions(), not an epsilon is used but a (very low) tolerance of four floating-point units.
-void SpatialSort::FindIdenticalPositions( const aiVector3D& pPosition,
-    std::vector<unsigned int>& poResults) const
-{
+void SpatialSort::FindIdenticalPositions(const aiVector3D &pPosition, std::vector<unsigned int> &poResults) const {
+    ai_assert(mFinalized && "The SpatialSort object must be finalized before FindIdenticalPositions can be called.");
     // Epsilons have a huge disadvantage: they are of constant precision, while floating-point
     //  values are of log2 precision. If you apply e=0.01 to 100, the epsilon is rather small, but
     //  if you apply it to 0.001, it is enormous.
@@ -265,20 +271,19 @@ void SpatialSort::FindIdenticalPositions( const aiVector3D& pPosition,
 
     // Convert the plane distance to its signed integer representation so the ULPs tolerance can be
     //  applied. For some reason, VC won't optimize two calls of the bit pattern conversion.
-    const BinFloat minDistBinary = ToBinary( pPosition * mPlaneNormal) - distanceToleranceInULPs;
+    const BinFloat minDistBinary = ToBinary(CalculateDistance(pPosition)) - distanceToleranceInULPs;
     const BinFloat maxDistBinary = minDistBinary + 2 * distanceToleranceInULPs;
 
     // clear the array in this strange fashion because a simple clear() would also deallocate
     // the array which we want to avoid
-    poResults.resize( 0 );
+    poResults.resize(0);
 
     // do a binary search for the minimal distance to start the iteration there
     unsigned int index = (unsigned int)mPositions.size() / 2;
     unsigned int binaryStepSize = (unsigned int)mPositions.size() / 4;
-    while( binaryStepSize > 1)
-    {
+    while (binaryStepSize > 1) {
         // Ugly, but conditional jumps are faster with integers than with floats
-        if( minDistBinary > ToBinary(mPositions[index].mDistance))
+        if (minDistBinary > ToBinary(mPositions[index].mDistance))
             index += binaryStepSize;
         else
             index -= binaryStepSize;
@@ -288,20 +293,19 @@ void SpatialSort::FindIdenticalPositions( const aiVector3D& pPosition,
 
     // depending on the direction of the last step we need to single step a bit back or forth
     // to find the actual beginning element of the range
-    while( index > 0 && minDistBinary < ToBinary(mPositions[index].mDistance) )
+    while (index > 0 && minDistBinary < ToBinary(mPositions[index].mDistance))
         index--;
-    while( index < (mPositions.size() - 1) && minDistBinary > ToBinary(mPositions[index].mDistance))
+    while (index < (mPositions.size() - 1) && minDistBinary > ToBinary(mPositions[index].mDistance))
         index++;
 
     // Now start iterating from there until the first position lays outside of the distance range.
     // Add all positions inside the distance range within the tolerance to the result array
     std::vector<Entry>::const_iterator it = mPositions.begin() + index;
-    while( ToBinary(it->mDistance) < maxDistBinary)
-    {
-        if( distance3DToleranceInULPs >= ToBinary((it->mPosition - pPosition).SquareLength()))
+    while (ToBinary(it->mDistance) < maxDistBinary) {
+        if (distance3DToleranceInULPs >= ToBinary((it->mPosition - pPosition).SquareLength()))
             poResults.push_back(it->mIndex);
         ++it;
-        if( it == mPositions.end())
+        if (it == mPositions.end())
             break;
     }
 
@@ -309,22 +313,20 @@ void SpatialSort::FindIdenticalPositions( const aiVector3D& pPosition,
 }
 
 // ------------------------------------------------------------------------------------------------
-unsigned int SpatialSort::GenerateMappingTable(std::vector<unsigned int>& fill, ai_real pRadius) const
-{
-    fill.resize(mPositions.size(),UINT_MAX);
+unsigned int SpatialSort::GenerateMappingTable(std::vector<unsigned int> &fill, ai_real pRadius) const {
+    ai_assert(mFinalized && "The SpatialSort object must be finalized before GenerateMappingTable can be called.");
+    fill.resize(mPositions.size(), UINT_MAX);
     ai_real dist, maxDist;
 
-    unsigned int t=0;
-    const ai_real pSquared = pRadius*pRadius;
+    unsigned int t = 0;
+    const ai_real pSquared = pRadius * pRadius;
     for (size_t i = 0; i < mPositions.size();) {
-        dist = mPositions[i].mPosition * mPlaneNormal;
+        dist = (mPositions[i].mPosition - mCentroid) * mPlaneNormal;
         maxDist = dist + pRadius;
 
         fill[mPositions[i].mIndex] = t;
-        const aiVector3D& oldpos = mPositions[i].mPosition;
-        for (++i; i < fill.size() && mPositions[i].mDistance < maxDist
-            && (mPositions[i].mPosition - oldpos).SquareLength() < pSquared; ++i)
-        {
+        const aiVector3D &oldpos = mPositions[i].mPosition;
+        for (++i; i < fill.size() && mPositions[i].mDistance < maxDist && (mPositions[i].mPosition - oldpos).SquareLength() < pSquared; ++i) {
             fill[mPositions[i].mIndex] = t;
         }
         ++t;
@@ -334,7 +336,7 @@ unsigned int SpatialSort::GenerateMappingTable(std::vector<unsigned int>& fill,
 
     // debug invariant: mPositions[i].mIndex values must range from 0 to mPositions.size()-1
     for (size_t i = 0; i < fill.size(); ++i) {
-        ai_assert(fill[i]<mPositions.size());
+        ai_assert(fill[i] < mPositions.size());
     }
 
 #endif
diff --git a/Engine/lib/assimp/code/Common/StandardShapes.cpp b/Engine/lib/assimp/code/Common/StandardShapes.cpp
index 2e5100130..e94b5b9af 100644
--- a/Engine/lib/assimp/code/Common/StandardShapes.cpp
+++ b/Engine/lib/assimp/code/Common/StandardShapes.cpp
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -49,69 +48,59 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <assimp/StandardShapes.h>
 #include <assimp/StringComparison.h>
-#include <stddef.h>
-#include <assimp/Defines.h>
 #include <assimp/mesh.h>
 
-namespace Assimp    {
+namespace Assimp {
 
-
-# define ADD_TRIANGLE(n0,n1,n2) \
-    positions.push_back(n0); \
-    positions.push_back(n1); \
+#define ADD_TRIANGLE(n0, n1, n2) \
+    positions.push_back(n0);     \
+    positions.push_back(n1);     \
     positions.push_back(n2);
 
-#   define ADD_PENTAGON(n0,n1,n2,n3,n4) \
-    if (polygons) \
-    { \
+#define ADD_PENTAGON(n0, n1, n2, n3, n4) \
+    if (polygons) {                      \
+        positions.push_back(n0);         \
+        positions.push_back(n1);         \
+        positions.push_back(n2);         \
+        positions.push_back(n3);         \
+        positions.push_back(n4);         \
+    } else {                             \
+        ADD_TRIANGLE(n0, n1, n2)         \
+        ADD_TRIANGLE(n0, n2, n3)         \
+        ADD_TRIANGLE(n0, n3, n4)         \
+    }
+
+#define ADD_QUAD(n0, n1, n2, n3) \
+    if (polygons) {              \
         positions.push_back(n0); \
         positions.push_back(n1); \
         positions.push_back(n2); \
         positions.push_back(n3); \
-        positions.push_back(n4); \
-    } \
-    else \
-    { \
-        ADD_TRIANGLE(n0, n1, n2) \
-        ADD_TRIANGLE(n0, n2, n3) \
-        ADD_TRIANGLE(n0, n3, n4) \
-    }
-
-#   define ADD_QUAD(n0,n1,n2,n3) \
-    if (polygons) \
-    { \
-        positions.push_back(n0); \
-        positions.push_back(n1); \
-        positions.push_back(n2); \
-        positions.push_back(n3); \
-    } \
-    else \
-    { \
+    } else {                     \
         ADD_TRIANGLE(n0, n1, n2) \
         ADD_TRIANGLE(n0, n2, n3) \
     }
 
-
 // ------------------------------------------------------------------------------------------------
 // Fast subdivision for a mesh whose verts have a magnitude of 1
-void Subdivide(std::vector<aiVector3D>& positions)
-{
+void Subdivide(std::vector<aiVector3D> &positions) {
     // assume this to be constant - (fixme: must be 1.0? I think so)
     const ai_real fl1 = positions[0].Length();
 
     unsigned int origSize = (unsigned int)positions.size();
-    for (unsigned int i = 0 ; i < origSize ; i+=3)
-    {
-        aiVector3D& tv0 = positions[i];
-        aiVector3D& tv1 = positions[i+1];
-        aiVector3D& tv2 = positions[i+2];
+    for (unsigned int i = 0; i < origSize; i += 3) {
+        aiVector3D &tv0 = positions[i];
+        aiVector3D &tv1 = positions[i + 1];
+        aiVector3D &tv2 = positions[i + 2];
 
         aiVector3D a = tv0, b = tv1, c = tv2;
-        aiVector3D v1 = aiVector3D(a.x+b.x, a.y+b.y, a.z+b.z).Normalize()*fl1;
-        aiVector3D v2 = aiVector3D(a.x+c.x, a.y+c.y, a.z+c.z).Normalize()*fl1;
-        aiVector3D v3 = aiVector3D(b.x+c.x, b.y+c.y, b.z+c.z).Normalize()*fl1;
+        aiVector3D v1 = aiVector3D(a.x + b.x, a.y + b.y, a.z + b.z).Normalize() * fl1;
+        aiVector3D v2 = aiVector3D(a.x + c.x, a.y + c.y, a.z + c.z).Normalize() * fl1;
+        aiVector3D v3 = aiVector3D(b.x + c.x, b.y + c.y, b.z + c.z).Normalize() * fl1;
 
-        tv0 = v1; tv1 = v3; tv2 = v2; // overwrite the original
+        tv0 = v1;
+        tv1 = v3;
+        tv2 = v2; // overwrite the original
         ADD_TRIANGLE(v1, v2, a);
         ADD_TRIANGLE(v2, v3, c);
         ADD_TRIANGLE(v3, v1, b);
@@ -120,147 +109,143 @@ void Subdivide(std::vector<aiVector3D>& positions)
 
 // ------------------------------------------------------------------------------------------------
 // Construct a mesh from given vertex positions
-aiMesh* StandardShapes::MakeMesh(const std::vector<aiVector3D>& positions,
-    unsigned int numIndices)
-{
-    if (positions.empty() || !numIndices) return NULL;
+aiMesh *StandardShapes::MakeMesh(const std::vector<aiVector3D> &positions,
+        unsigned int numIndices) {
+    if (positions.empty() || !numIndices) {
+        return nullptr;
+    }
 
     // Determine which kinds of primitives the mesh consists of
-    aiMesh* out = new aiMesh();
+    aiMesh *out = new aiMesh();
     switch (numIndices) {
-        case 1:
-            out->mPrimitiveTypes = aiPrimitiveType_POINT;
-            break;
-        case 2:
-            out->mPrimitiveTypes = aiPrimitiveType_LINE;
-            break;
-        case 3:
-            out->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
-            break;
-        default:
-            out->mPrimitiveTypes = aiPrimitiveType_POLYGON;
-            break;
+    case 1:
+        out->mPrimitiveTypes = aiPrimitiveType_POINT;
+        break;
+    case 2:
+        out->mPrimitiveTypes = aiPrimitiveType_LINE;
+        break;
+    case 3:
+        out->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
+        break;
+    default:
+        out->mPrimitiveTypes = aiPrimitiveType_POLYGON;
+        break;
     };
 
     out->mNumFaces = (unsigned int)positions.size() / numIndices;
     out->mFaces = new aiFace[out->mNumFaces];
-    for (unsigned int i = 0, a = 0; i < out->mNumFaces;++i) {
-        aiFace& f = out->mFaces[i];
+    for (unsigned int i = 0, a = 0; i < out->mNumFaces; ++i) {
+        aiFace &f = out->mFaces[i];
         f.mNumIndices = numIndices;
         f.mIndices = new unsigned int[numIndices];
-        for (unsigned int j = 0; i < numIndices; ++i, ++a) {
+        for (unsigned int j = 0; j < numIndices; ++j, ++a) {
             f.mIndices[j] = a;
         }
     }
     out->mNumVertices = (unsigned int)positions.size();
     out->mVertices = new aiVector3D[out->mNumVertices];
-    ::memcpy(out->mVertices,&positions[0],out->mNumVertices*sizeof(aiVector3D));
+    ::memcpy(out->mVertices, &positions[0], out->mNumVertices * sizeof(aiVector3D));
 
     return out;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Construct a mesh with a specific shape (callback)
-aiMesh* StandardShapes::MakeMesh ( unsigned int (*GenerateFunc)(
-    std::vector<aiVector3D>&))
-{
+aiMesh *StandardShapes::MakeMesh(unsigned int (*GenerateFunc)(
+        std::vector<aiVector3D> &)) {
     std::vector<aiVector3D> temp;
     unsigned num = (*GenerateFunc)(temp);
-    return MakeMesh(temp,num);
+    return MakeMesh(temp, num);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Construct a mesh with a specific shape (callback)
-aiMesh* StandardShapes::MakeMesh ( unsigned int (*GenerateFunc)(
-    std::vector<aiVector3D>&, bool))
-{
+aiMesh *StandardShapes::MakeMesh(unsigned int (*GenerateFunc)(
+        std::vector<aiVector3D> &, bool)) {
     std::vector<aiVector3D> temp;
-    unsigned num = (*GenerateFunc)(temp,true);
-    return MakeMesh(temp,num);
+    unsigned num = (*GenerateFunc)(temp, true);
+    return MakeMesh(temp, num);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Construct a mesh with a specific shape (callback)
-aiMesh* StandardShapes::MakeMesh (unsigned int num,  void (*GenerateFunc)(
-    unsigned int,std::vector<aiVector3D>&))
-{
+aiMesh *StandardShapes::MakeMesh(unsigned int num, void (*GenerateFunc)(
+                                                           unsigned int, std::vector<aiVector3D> &)) {
     std::vector<aiVector3D> temp;
-    (*GenerateFunc)(num,temp);
-    return MakeMesh(temp,3);
+    (*GenerateFunc)(num, temp);
+    return MakeMesh(temp, 3);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Build an incosahedron with points.magnitude == 1
-unsigned int StandardShapes::MakeIcosahedron(std::vector<aiVector3D>& positions)
-{
-    positions.reserve(positions.size()+60);
+unsigned int StandardShapes::MakeIcosahedron(std::vector<aiVector3D> &positions) {
+    positions.reserve(positions.size() + 60);
 
-    const ai_real t = ( ai_real( 1.0 )+ ai_real( 2.236067977 ) ) / ai_real( 2.0 );
-    const ai_real s = std::sqrt(ai_real(1.0) + t*t);
+    const ai_real t = (ai_real(1.0) + ai_real(2.236067977)) / ai_real(2.0);
+    const ai_real s = std::sqrt(ai_real(1.0) + t * t);
 
-    const aiVector3D v0  = aiVector3D(t,1.0, 0.0)/s;
-    const aiVector3D v1  = aiVector3D(-t,1.0, 0.0)/s;
-    const aiVector3D v2  = aiVector3D(t,-1.0, 0.0)/s;
-    const aiVector3D v3  = aiVector3D(-t,-1.0, 0.0)/s;
-    const aiVector3D v4  = aiVector3D(1.0, 0.0, t)/s;
-    const aiVector3D v5  = aiVector3D(1.0, 0.0,-t)/s;
-    const aiVector3D v6  = aiVector3D(-1.0, 0.0,t)/s;
-    const aiVector3D v7  = aiVector3D(-1.0, 0.0,-t)/s;
-    const aiVector3D v8  = aiVector3D(0.0, t, 1.0)/s;
-    const aiVector3D v9  = aiVector3D(0.0,-t, 1.0)/s;
-    const aiVector3D v10 = aiVector3D(0.0, t,-1.0)/s;
-    const aiVector3D v11 = aiVector3D(0.0,-t,-1.0)/s;
+    const aiVector3D v0 = aiVector3D(t, 1.0, 0.0) / s;
+    const aiVector3D v1 = aiVector3D(-t, 1.0, 0.0) / s;
+    const aiVector3D v2 = aiVector3D(t, -1.0, 0.0) / s;
+    const aiVector3D v3 = aiVector3D(-t, -1.0, 0.0) / s;
+    const aiVector3D v4 = aiVector3D(1.0, 0.0, t) / s;
+    const aiVector3D v5 = aiVector3D(1.0, 0.0, -t) / s;
+    const aiVector3D v6 = aiVector3D(-1.0, 0.0, t) / s;
+    const aiVector3D v7 = aiVector3D(-1.0, 0.0, -t) / s;
+    const aiVector3D v8 = aiVector3D(0.0, t, 1.0) / s;
+    const aiVector3D v9 = aiVector3D(0.0, -t, 1.0) / s;
+    const aiVector3D v10 = aiVector3D(0.0, t, -1.0) / s;
+    const aiVector3D v11 = aiVector3D(0.0, -t, -1.0) / s;
 
-    ADD_TRIANGLE(v0,v8,v4);
-    ADD_TRIANGLE(v0,v5,v10);
-    ADD_TRIANGLE(v2,v4,v9);
-    ADD_TRIANGLE(v2,v11,v5);
+    ADD_TRIANGLE(v0, v8, v4);
+    ADD_TRIANGLE(v0, v5, v10);
+    ADD_TRIANGLE(v2, v4, v9);
+    ADD_TRIANGLE(v2, v11, v5);
 
-    ADD_TRIANGLE(v1,v6,v8);
-    ADD_TRIANGLE(v1,v10,v7);
-    ADD_TRIANGLE(v3,v9,v6);
-    ADD_TRIANGLE(v3,v7,v11);
+    ADD_TRIANGLE(v1, v6, v8);
+    ADD_TRIANGLE(v1, v10, v7);
+    ADD_TRIANGLE(v3, v9, v6);
+    ADD_TRIANGLE(v3, v7, v11);
 
-    ADD_TRIANGLE(v0,v10,v8);
-    ADD_TRIANGLE(v1,v8,v10);
-    ADD_TRIANGLE(v2,v9,v11);
-    ADD_TRIANGLE(v3,v11,v9);
+    ADD_TRIANGLE(v0, v10, v8);
+    ADD_TRIANGLE(v1, v8, v10);
+    ADD_TRIANGLE(v2, v9, v11);
+    ADD_TRIANGLE(v3, v11, v9);
 
-    ADD_TRIANGLE(v4,v2,v0);
-    ADD_TRIANGLE(v5,v0,v2);
-    ADD_TRIANGLE(v6,v1,v3);
-    ADD_TRIANGLE(v7,v3,v1);
+    ADD_TRIANGLE(v4, v2, v0);
+    ADD_TRIANGLE(v5, v0, v2);
+    ADD_TRIANGLE(v6, v1, v3);
+    ADD_TRIANGLE(v7, v3, v1);
 
-    ADD_TRIANGLE(v8,v6,v4);
-    ADD_TRIANGLE(v9,v4,v6);
-    ADD_TRIANGLE(v10,v5,v7);
-    ADD_TRIANGLE(v11,v7,v5);
+    ADD_TRIANGLE(v8, v6, v4);
+    ADD_TRIANGLE(v9, v4, v6);
+    ADD_TRIANGLE(v10, v5, v7);
+    ADD_TRIANGLE(v11, v7, v5);
     return 3;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Build a dodecahedron with points.magnitude == 1
-unsigned int StandardShapes::MakeDodecahedron(std::vector<aiVector3D>& positions,
-    bool polygons /*= false*/)
-{
-    positions.reserve(positions.size()+108);
+unsigned int StandardShapes::MakeDodecahedron(std::vector<aiVector3D> &positions,
+        bool polygons /*= false*/) {
+    positions.reserve(positions.size() + 108);
 
-    const ai_real a = ai_real( 1.0 ) / ai_real(1.7320508);
-    const ai_real b = std::sqrt(( ai_real( 3.0 )- ai_real( 2.23606797))/ ai_real( 6.0) );
-    const ai_real c = std::sqrt(( ai_real( 3.0 )+ ai_real( 2.23606797f))/ ai_real( 6.0) );
+    const ai_real a = ai_real(1.0) / ai_real(1.7320508);
+    const ai_real b = std::sqrt((ai_real(3.0) - ai_real(2.23606797)) / ai_real(6.0));
+    const ai_real c = std::sqrt((ai_real(3.0) + ai_real(2.23606797f)) / ai_real(6.0));
 
-    const aiVector3D v0  = aiVector3D(a,a,a);
-    const aiVector3D v1  = aiVector3D(a,a,-a);
-    const aiVector3D v2  = aiVector3D(a,-a,a);
-    const aiVector3D v3  = aiVector3D(a,-a,-a);
-    const aiVector3D v4  = aiVector3D(-a,a,a);
-    const aiVector3D v5  = aiVector3D(-a,a,-a);
-    const aiVector3D v6  = aiVector3D(-a,-a,a);
-    const aiVector3D v7  = aiVector3D(-a,-a,-a);
-    const aiVector3D v8  = aiVector3D(b,c,0.0);
-    const aiVector3D v9  = aiVector3D(-b,c,0.0);
-    const aiVector3D v10 = aiVector3D(b,-c,0.0);
-    const aiVector3D v11 = aiVector3D(-b,-c,0.0);
+    const aiVector3D v0 = aiVector3D(a, a, a);
+    const aiVector3D v1 = aiVector3D(a, a, -a);
+    const aiVector3D v2 = aiVector3D(a, -a, a);
+    const aiVector3D v3 = aiVector3D(a, -a, -a);
+    const aiVector3D v4 = aiVector3D(-a, a, a);
+    const aiVector3D v5 = aiVector3D(-a, a, -a);
+    const aiVector3D v6 = aiVector3D(-a, -a, a);
+    const aiVector3D v7 = aiVector3D(-a, -a, -a);
+    const aiVector3D v8 = aiVector3D(b, c, 0.0);
+    const aiVector3D v9 = aiVector3D(-b, c, 0.0);
+    const aiVector3D v10 = aiVector3D(b, -c, 0.0);
+    const aiVector3D v11 = aiVector3D(-b, -c, 0.0);
     const aiVector3D v12 = aiVector3D(c, 0.0, b);
     const aiVector3D v13 = aiVector3D(c, 0.0, -b);
     const aiVector3D v14 = aiVector3D(-c, 0.0, b);
@@ -288,74 +273,71 @@ unsigned int StandardShapes::MakeDodecahedron(std::vector<aiVector3D>& positions
 
 // ------------------------------------------------------------------------------------------------
 // Build an octahedron with points.magnitude == 1
-unsigned int StandardShapes::MakeOctahedron(std::vector<aiVector3D>& positions)
-{
-    positions.reserve(positions.size()+24);
+unsigned int StandardShapes::MakeOctahedron(std::vector<aiVector3D> &positions) {
+    positions.reserve(positions.size() + 24);
 
-    const aiVector3D v0  = aiVector3D(1.0, 0.0, 0.0) ;
-    const aiVector3D v1  = aiVector3D(-1.0, 0.0, 0.0);
-    const aiVector3D v2  = aiVector3D(0.0, 1.0, 0.0);
-    const aiVector3D v3  = aiVector3D(0.0, -1.0, 0.0);
-    const aiVector3D v4  = aiVector3D(0.0, 0.0, 1.0);
-    const aiVector3D v5  = aiVector3D(0.0, 0.0, -1.0);
+    const aiVector3D v0 = aiVector3D(1.0, 0.0, 0.0);
+    const aiVector3D v1 = aiVector3D(-1.0, 0.0, 0.0);
+    const aiVector3D v2 = aiVector3D(0.0, 1.0, 0.0);
+    const aiVector3D v3 = aiVector3D(0.0, -1.0, 0.0);
+    const aiVector3D v4 = aiVector3D(0.0, 0.0, 1.0);
+    const aiVector3D v5 = aiVector3D(0.0, 0.0, -1.0);
 
-    ADD_TRIANGLE(v4,v0,v2);
-    ADD_TRIANGLE(v4,v2,v1);
-    ADD_TRIANGLE(v4,v1,v3);
-    ADD_TRIANGLE(v4,v3,v0);
+    ADD_TRIANGLE(v4, v0, v2);
+    ADD_TRIANGLE(v4, v2, v1);
+    ADD_TRIANGLE(v4, v1, v3);
+    ADD_TRIANGLE(v4, v3, v0);
 
-    ADD_TRIANGLE(v5,v2,v0);
-    ADD_TRIANGLE(v5,v1,v2);
-    ADD_TRIANGLE(v5,v3,v1);
-    ADD_TRIANGLE(v5,v0,v3);
+    ADD_TRIANGLE(v5, v2, v0);
+    ADD_TRIANGLE(v5, v1, v2);
+    ADD_TRIANGLE(v5, v3, v1);
+    ADD_TRIANGLE(v5, v0, v3);
     return 3;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Build a tetrahedron with points.magnitude == 1
-unsigned int StandardShapes::MakeTetrahedron(std::vector<aiVector3D>& positions)
-{
-    positions.reserve(positions.size()+9);
+unsigned int StandardShapes::MakeTetrahedron(std::vector<aiVector3D> &positions) {
+    positions.reserve(positions.size() + 9);
 
-    const ai_real invThree = ai_real( 1.0 ) / ai_real( 3.0 );
-    const ai_real a = ai_real( 1.41421 ) * invThree;
-    const ai_real b = ai_real( 2.4494 ) * invThree;
+    const ai_real invThree = ai_real(1.0) / ai_real(3.0);
+    const ai_real a = ai_real(1.41421) * invThree;
+    const ai_real b = ai_real(2.4494) * invThree;
 
-    const aiVector3D v0  = aiVector3D(0.0,0.0,1.0);
-    const aiVector3D v1  = aiVector3D(2*a,0,-invThree );
-    const aiVector3D v2  = aiVector3D(-a,b,-invThree );
-    const aiVector3D v3  = aiVector3D(-a,-b,-invThree );
+    const aiVector3D v0 = aiVector3D(0.0, 0.0, 1.0);
+    const aiVector3D v1 = aiVector3D(2 * a, 0, -invThree);
+    const aiVector3D v2 = aiVector3D(-a, b, -invThree);
+    const aiVector3D v3 = aiVector3D(-a, -b, -invThree);
 
-    ADD_TRIANGLE(v0,v1,v2);
-    ADD_TRIANGLE(v0,v2,v3);
-    ADD_TRIANGLE(v0,v3,v1);
-    ADD_TRIANGLE(v1,v3,v2);
+    ADD_TRIANGLE(v0, v1, v2);
+    ADD_TRIANGLE(v0, v2, v3);
+    ADD_TRIANGLE(v0, v3, v1);
+    ADD_TRIANGLE(v1, v3, v2);
     return 3;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Build a hexahedron with points.magnitude == 1
-unsigned int StandardShapes::MakeHexahedron(std::vector<aiVector3D>& positions,
-    bool polygons /*= false*/)
-{
-    positions.reserve(positions.size()+36);
-    const ai_real length = ai_real(1.0)/ai_real(1.73205080);
+unsigned int StandardShapes::MakeHexahedron(std::vector<aiVector3D> &positions,
+        bool polygons /*= false*/) {
+    positions.reserve(positions.size() + 36);
+    const ai_real length = ai_real(1.0) / ai_real(1.73205080);
 
-    const aiVector3D v0  = aiVector3D(-1.0,-1.0,-1.0)*length;
-    const aiVector3D v1  = aiVector3D(1.0,-1.0,-1.0)*length;
-    const aiVector3D v2  = aiVector3D(1.0,1.0,-1.0)*length;
-    const aiVector3D v3  = aiVector3D(-1.0,1.0,-1.0)*length;
-    const aiVector3D v4  = aiVector3D(-1.0,-1.0,1.0)*length;
-    const aiVector3D v5  = aiVector3D(1.0,-1.0,1.0)*length;
-    const aiVector3D v6  = aiVector3D(1.0,1.0,1.0)*length;
-    const aiVector3D v7  = aiVector3D(-1.0,1.0,1.0)*length;
+    const aiVector3D v0 = aiVector3D(-1.0, -1.0, -1.0) * length;
+    const aiVector3D v1 = aiVector3D(1.0, -1.0, -1.0) * length;
+    const aiVector3D v2 = aiVector3D(1.0, 1.0, -1.0) * length;
+    const aiVector3D v3 = aiVector3D(-1.0, 1.0, -1.0) * length;
+    const aiVector3D v4 = aiVector3D(-1.0, -1.0, 1.0) * length;
+    const aiVector3D v5 = aiVector3D(1.0, -1.0, 1.0) * length;
+    const aiVector3D v6 = aiVector3D(1.0, 1.0, 1.0) * length;
+    const aiVector3D v7 = aiVector3D(-1.0, 1.0, 1.0) * length;
 
-    ADD_QUAD(v0,v3,v2,v1);
-    ADD_QUAD(v0,v1,v5,v4);
-    ADD_QUAD(v0,v4,v7,v3);
-    ADD_QUAD(v6,v5,v1,v2);
-    ADD_QUAD(v6,v2,v3,v7);
-    ADD_QUAD(v6,v7,v4,v5);
+    ADD_QUAD(v0, v3, v2, v1);
+    ADD_QUAD(v0, v1, v5, v4);
+    ADD_QUAD(v0, v4, v7, v3);
+    ADD_QUAD(v6, v5, v1, v2);
+    ADD_QUAD(v6, v2, v3, v7);
+    ADD_QUAD(v6, v7, v4, v5);
     return (polygons ? 4 : 3);
 }
 
@@ -366,28 +348,26 @@ unsigned int StandardShapes::MakeHexahedron(std::vector<aiVector3D>& positions,
 
 // ------------------------------------------------------------------------------------------------
 // Create a subdivision sphere
-void StandardShapes::MakeSphere(unsigned int    tess,
-    std::vector<aiVector3D>& positions)
-{
+void StandardShapes::MakeSphere(unsigned int tess,
+        std::vector<aiVector3D> &positions) {
     // Reserve enough storage. Every subdivision
     // splits each triangle in 4, the icosahedron consists of 60 verts
-    positions.reserve(positions.size()+60 * integer_pow(4, tess));
+    positions.reserve(positions.size() + 60 * integer_pow(4, tess));
 
     // Construct an icosahedron to start with
     MakeIcosahedron(positions);
 
     // ... and subdivide it until the requested output
     // tessellation is reached
-    for (unsigned int i = 0; i<tess;++i)
+    for (unsigned int i = 0; i < tess; ++i)
         Subdivide(positions);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Build a cone
-void StandardShapes::MakeCone(ai_real height,ai_real radius1,
-    ai_real radius2,unsigned int tess,
-    std::vector<aiVector3D>& positions,bool bOpen /*= false */)
-{
+void StandardShapes::MakeCone(ai_real height, ai_real radius1,
+        ai_real radius2, unsigned int tess,
+        std::vector<aiVector3D> &positions, bool bOpen /*= false */) {
     // Sorry, a cone with less than 3 segments makes ABSOLUTELY NO SENSE
     if (tess < 3 || !height)
         return;
@@ -401,39 +381,37 @@ void StandardShapes::MakeCone(ai_real height,ai_real radius1,
     ai_real halfHeight = height / ai_real(2.0);
 
     // radius1 is always the smaller one
-    if (radius2 > radius1)
-    {
-        std::swap(radius2,radius1);
+    if (radius2 > radius1) {
+        std::swap(radius2, radius1);
         halfHeight = -halfHeight;
-    }
-    else old = SIZE_MAX;
+    } else
+        old = SIZE_MAX;
 
     // Use a large epsilon to check whether the cone is pointy
-    if (radius1 < (radius2-radius1)*10e-3)radius1 = 0.0;
+    if (radius1 < (radius2 - radius1) * 10e-3) radius1 = 0.0;
 
     // We will need 3*2 verts per segment + 3*2 verts per segment
     // if the cone is closed
-    const unsigned int mem = tess*6 + (!bOpen ? tess*3 * (radius1 ? 2 : 1) : 0);
-    positions.reserve(positions.size () + mem);
+    const unsigned int mem = tess * 6 + (!bOpen ? tess * 3 * (radius1 ? 2 : 1) : 0);
+    positions.reserve(positions.size() + mem);
 
     // Now construct all segments
     const ai_real angle_delta = (ai_real)AI_MATH_TWO_PI / tess;
-    const ai_real angle_max   = (ai_real)AI_MATH_TWO_PI;
+    const ai_real angle_max = (ai_real)AI_MATH_TWO_PI;
 
     ai_real s = 1.0; // std::cos(angle == 0);
     ai_real t = 0.0; // std::sin(angle == 0);
 
-    for (ai_real angle = 0.0; angle < angle_max; )
-    {
-        const aiVector3D v1 = aiVector3D (s * radius1, -halfHeight, t * radius1 );
-        const aiVector3D v2 = aiVector3D (s * radius2,  halfHeight, t * radius2 );
+    for (ai_real angle = 0.0; angle < angle_max;) {
+        const aiVector3D v1 = aiVector3D(s * radius1, -halfHeight, t * radius1);
+        const aiVector3D v2 = aiVector3D(s * radius2, halfHeight, t * radius2);
 
         const ai_real next = angle + angle_delta;
         ai_real s2 = std::cos(next);
         ai_real t2 = std::sin(next);
 
-        const aiVector3D v3 = aiVector3D (s2 * radius2,  halfHeight, t2 * radius2 );
-        const aiVector3D v4 = aiVector3D (s2 * radius1, -halfHeight, t2 * radius1 );
+        const aiVector3D v3 = aiVector3D(s2 * radius2, halfHeight, t2 * radius2);
+        const aiVector3D v4 = aiVector3D(s2 * radius1, -halfHeight, t2 * radius1);
 
         positions.push_back(v1);
         positions.push_back(v2);
@@ -442,21 +420,17 @@ void StandardShapes::MakeCone(ai_real height,ai_real radius1,
         positions.push_back(v1);
         positions.push_back(v3);
 
-        if (!bOpen)
-        {
+        if (!bOpen) {
             // generate the end 'cap'
-            positions.push_back(aiVector3D(s * radius2,  halfHeight, t * radius2 ));
-            positions.push_back(aiVector3D(s2 * radius2,  halfHeight, t2 * radius2 ));
+            positions.push_back(aiVector3D(s * radius2, halfHeight, t * radius2));
+            positions.push_back(aiVector3D(s2 * radius2, halfHeight, t2 * radius2));
             positions.push_back(aiVector3D(0.0, halfHeight, 0.0));
 
-
-            if (radius1)
-            {
+            if (radius1) {
                 // generate the other end 'cap'
-                positions.push_back(aiVector3D(s * radius1,  -halfHeight, t * radius1 ));
-                positions.push_back(aiVector3D(s2 * radius1,  -halfHeight, t2 * radius1 ));
+                positions.push_back(aiVector3D(s * radius1, -halfHeight, t * radius1));
+                positions.push_back(aiVector3D(s2 * radius1, -halfHeight, t2 * radius1));
                 positions.push_back(aiVector3D(0.0, -halfHeight, 0.0));
-
             }
         }
         s = s2;
@@ -465,9 +439,9 @@ void StandardShapes::MakeCone(ai_real height,ai_real radius1,
     }
 
     // Need to flip face order?
-    if ( SIZE_MAX != old )  {
-        for (size_t p = old; p < positions.size();p += 3) {
-            std::swap(positions[p],positions[p+1]);
+    if (SIZE_MAX != old) {
+        for (size_t p = old; p < positions.size(); p += 3) {
+            std::swap(positions[p], positions[p + 1]);
         }
     }
 }
@@ -475,8 +449,7 @@ void StandardShapes::MakeCone(ai_real height,ai_real radius1,
 // ------------------------------------------------------------------------------------------------
 // Build a circle
 void StandardShapes::MakeCircle(ai_real radius, unsigned int tess,
-    std::vector<aiVector3D>& positions)
-{
+        std::vector<aiVector3D> &positions) {
     // Sorry, a circle with less than 3 segments makes ABSOLUTELY NO SENSE
     if (tess < 3 || !radius)
         return;
@@ -484,24 +457,23 @@ void StandardShapes::MakeCircle(ai_real radius, unsigned int tess,
     radius = std::fabs(radius);
 
     // We will need 3 vertices per segment
-    positions.reserve(positions.size()+tess*3);
+    positions.reserve(positions.size() + tess * 3);
 
     const ai_real angle_delta = (ai_real)AI_MATH_TWO_PI / tess;
-    const ai_real angle_max   = (ai_real)AI_MATH_TWO_PI;
+    const ai_real angle_max = (ai_real)AI_MATH_TWO_PI;
 
     ai_real s = 1.0; // std::cos(angle == 0);
     ai_real t = 0.0; // std::sin(angle == 0);
 
-    for (ai_real angle = 0.0; angle < angle_max;  )
-    {
-        positions.push_back(aiVector3D(s * radius,0.0,t * radius));
+    for (ai_real angle = 0.0; angle < angle_max;) {
+        positions.push_back(aiVector3D(s * radius, 0.0, t * radius));
         angle += angle_delta;
         s = std::cos(angle);
         t = std::sin(angle);
-        positions.push_back(aiVector3D(s * radius,0.0,t * radius));
+        positions.push_back(aiVector3D(s * radius, 0.0, t * radius));
 
-        positions.push_back(aiVector3D(0.0,0.0,0.0));
+        positions.push_back(aiVector3D(0.0, 0.0, 0.0));
     }
 }
 
-} // ! Assimp
+} // namespace Assimp
diff --git a/Engine/lib/assimp/code/Common/StdOStreamLogStream.h b/Engine/lib/assimp/code/Common/StdOStreamLogStream.h
index 893e261a2..cc0e06263 100644
--- a/Engine/lib/assimp/code/Common/StdOStreamLogStream.h
+++ b/Engine/lib/assimp/code/Common/StdOStreamLogStream.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/Common/Subdivision.cpp b/Engine/lib/assimp/code/Common/Subdivision.cpp
index 60c54939f..705ea3fb3 100644
--- a/Engine/lib/assimp/code/Common/Subdivision.cpp
+++ b/Engine/lib/assimp/code/Common/Subdivision.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -53,6 +53,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 using namespace Assimp;
 void mydummy() {}
 
+#ifdef _MSC_VER
+#pragma warning(disable : 4709)
+#endif // _MSC_VER
 // ------------------------------------------------------------------------------------------------
 /** Subdivider stub class to implement the Catmull-Clarke subdivision algorithm. The
  *  implementation is basing on recursive refinement. Directly evaluating the result is also
@@ -60,24 +63,22 @@ void mydummy() {}
 // ------------------------------------------------------------------------------------------------
 class CatmullClarkSubdivider : public Subdivider {
 public:
-    void Subdivide (aiMesh* mesh, aiMesh*& out, unsigned int num, bool discard_input);
-    void Subdivide (aiMesh** smesh, size_t nmesh,
-        aiMesh** out, unsigned int num, bool discard_input);
+    void Subdivide(aiMesh *mesh, aiMesh *&out, unsigned int num, bool discard_input);
+    void Subdivide(aiMesh **smesh, size_t nmesh,
+            aiMesh **out, unsigned int num, bool discard_input);
 
     // ---------------------------------------------------------------------------
     /** Intermediate description of an edge between two corners of a polygon*/
     // ---------------------------------------------------------------------------
-    struct Edge
-    {
-        Edge()
-            : ref(0)
-        {}
+    struct Edge {
+        Edge() :
+                ref(0) {}
         Vertex edge_point, midpoint;
         unsigned int ref;
     };
 
     typedef std::vector<unsigned int> UIntVector;
-    typedef std::map<uint64_t,Edge> EdgeMap;
+    typedef std::map<uint64_t, Edge> EdgeMap;
 
     // ---------------------------------------------------------------------------
     // Hashing function to derive an index into an #EdgeMap from two given
@@ -91,80 +92,72 @@ public:
     // invariant id0<id1 to identify an edge - else two hashes would refer
     // to the same edge.
     // ---------------------------------------------------------------------------
-#define MAKE_EDGE_HASH(id0,id1) (eh_tmp0__=id0,eh_tmp1__=id1,\
-    (eh_tmp0__<eh_tmp1__?std::swap(eh_tmp0__,eh_tmp1__):mydummy()),(uint64_t)eh_tmp0__^((uint64_t)eh_tmp1__<<32u))
+#define MAKE_EDGE_HASH(id0, id1) (eh_tmp0__ = id0, eh_tmp1__ = id1, \
+        (eh_tmp0__ < eh_tmp1__ ? std::swap(eh_tmp0__, eh_tmp1__) : mydummy()), (uint64_t)eh_tmp0__ ^ ((uint64_t)eh_tmp1__ << 32u))
 
-
-#define INIT_EDGE_HASH_TEMPORARIES()\
+#define INIT_EDGE_HASH_TEMPORARIES() \
     unsigned int eh_tmp0__, eh_tmp1__;
 
 private:
-    void InternSubdivide (const aiMesh* const * smesh,
-        size_t nmesh,aiMesh** out, unsigned int num);
+    void InternSubdivide(const aiMesh *const *smesh,
+            size_t nmesh, aiMesh **out, unsigned int num);
 };
 
-
 // ------------------------------------------------------------------------------------------------
 // Construct a subdivider of a specific type
-Subdivider* Subdivider::Create (Algorithm algo)
-{
-    switch (algo)
-    {
+Subdivider *Subdivider::Create(Algorithm algo) {
+    switch (algo) {
     case CATMULL_CLARKE:
         return new CatmullClarkSubdivider();
     };
 
     ai_assert(false);
-    return NULL; // shouldn't happen
+
+    return nullptr; // shouldn't happen
 }
 
 // ------------------------------------------------------------------------------------------------
 // Call the Catmull Clark subdivision algorithm for one mesh
-void  CatmullClarkSubdivider::Subdivide (
-    aiMesh* mesh,
-    aiMesh*& out,
-    unsigned int num,
-    bool discard_input
-    )
-{
+void CatmullClarkSubdivider::Subdivide(
+        aiMesh *mesh,
+        aiMesh *&out,
+        unsigned int num,
+        bool discard_input) {
     ai_assert(mesh != out);
-    
-    Subdivide(&mesh,1,&out,num,discard_input);
+
+    Subdivide(&mesh, 1, &out, num, discard_input);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Call the Catmull Clark subdivision algorithm for multiple meshes
-void CatmullClarkSubdivider::Subdivide (
-    aiMesh** smesh,
-    size_t nmesh,
-    aiMesh** out,
-    unsigned int num,
-    bool discard_input
-    )
-{
-    ai_assert( NULL != smesh );
-    ai_assert( NULL != out );
+void CatmullClarkSubdivider::Subdivide(
+        aiMesh **smesh,
+        size_t nmesh,
+        aiMesh **out,
+        unsigned int num,
+        bool discard_input) {
+    ai_assert(nullptr != smesh);
+    ai_assert(nullptr != out);
 
     // course, both regions may not overlap
-    ai_assert(smesh<out || smesh+nmesh>out+nmesh);
+    ai_assert(smesh < out || smesh + nmesh > out + nmesh);
     if (!num) {
         // No subdivision at all. Need to copy all the meshes .. argh.
         if (discard_input) {
             for (size_t s = 0; s < nmesh; ++s) {
                 out[s] = smesh[s];
-                smesh[s] = NULL;
+                smesh[s] = nullptr;
             }
-        }
-        else {
+        } else {
             for (size_t s = 0; s < nmesh; ++s) {
-                SceneCombiner::Copy(out+s,smesh[s]);
+                SceneCombiner::Copy(out + s, smesh[s]);
             }
         }
         return;
     }
 
-    std::vector<aiMesh*> inmeshes;
-    std::vector<aiMesh*> outmeshes;
+    std::vector<aiMesh *> inmeshes;
+    std::vector<aiMesh *> outmeshes;
     std::vector<unsigned int> maptbl;
 
     inmeshes.reserve(nmesh);
@@ -175,34 +168,35 @@ void CatmullClarkSubdivider::Subdivide (
     // number of edge cases the subdivider is forced to deal with. Line and
     // point meshes are simply passed through.
     for (size_t s = 0; s < nmesh; ++s) {
-        aiMesh* i = smesh[s];
+        aiMesh *i = smesh[s];
         // FIX - mPrimitiveTypes might not yet be initialized
-        if (i->mPrimitiveTypes && (i->mPrimitiveTypes & (aiPrimitiveType_LINE|aiPrimitiveType_POINT))==i->mPrimitiveTypes) {
-            ASSIMP_LOG_DEBUG("Catmull-Clark Subdivider: Skipping pure line/point mesh");
+        if (i->mPrimitiveTypes && (i->mPrimitiveTypes & (aiPrimitiveType_LINE | aiPrimitiveType_POINT)) == i->mPrimitiveTypes) {
+            ASSIMP_LOG_VERBOSE_DEBUG("Catmull-Clark Subdivider: Skipping pure line/point mesh");
 
             if (discard_input) {
                 out[s] = i;
-                smesh[s] = NULL;
-            }
-            else {
-                SceneCombiner::Copy(out+s,i);
+                smesh[s] = nullptr;
+            } else {
+                SceneCombiner::Copy(out + s, i);
             }
             continue;
         }
 
-        outmeshes.push_back(NULL);inmeshes.push_back(i);
+        outmeshes.push_back(nullptr);
+        inmeshes.push_back(i);
         maptbl.push_back(static_cast<unsigned int>(s));
     }
 
     // Do the actual subdivision on the preallocated storage. InternSubdivide
     // *always* assumes that enough storage is available, it does not bother
     // checking any ranges.
-    ai_assert(inmeshes.size()==outmeshes.size()&&inmeshes.size()==maptbl.size());
+    ai_assert(inmeshes.size() == outmeshes.size());
+    ai_assert(inmeshes.size() == maptbl.size());
     if (inmeshes.empty()) {
         ASSIMP_LOG_WARN("Catmull-Clark Subdivider: Pure point/line scene, I can't do anything");
         return;
     }
-    InternSubdivide(&inmeshes.front(),inmeshes.size(),&outmeshes.front(),num);
+    InternSubdivide(&inmeshes.front(), inmeshes.size(), &outmeshes.front(), num);
     for (unsigned int i = 0; i < maptbl.size(); ++i) {
         ai_assert(nullptr != outmeshes[i]);
         out[maptbl[i]] = outmeshes[i];
@@ -226,14 +220,14 @@ void CatmullClarkSubdivider::Subdivide (
 // in-place unless 'smesh' and 'out' are equal (no strange overlaps or reorderings).
 // Previous data is replaced/deleted then.
 // ------------------------------------------------------------------------------------------------
-void CatmullClarkSubdivider::InternSubdivide (
-    const aiMesh* const * smesh,
-    size_t nmesh,
-    aiMesh** out,
-    unsigned int num
-    )
-{
-    ai_assert(NULL != smesh && NULL != out);
+void CatmullClarkSubdivider::InternSubdivide(
+        const aiMesh *const *smesh,
+        size_t nmesh,
+        aiMesh **out,
+        unsigned int num) {
+    ai_assert(nullptr != smesh);
+    ai_assert(nullptr != out);
+
     INIT_EDGE_HASH_TEMPORARIES();
 
     // no subdivision requested or end of recursive refinement
@@ -248,25 +242,24 @@ void CatmullClarkSubdivider::InternSubdivide (
     // 0. Offset table to index all meshes continuously, generate a spatially
     // sorted representation of all vertices in all meshes.
     // ---------------------------------------------------------------------
-    typedef std::pair<unsigned int,unsigned int> IntPair;
+    typedef std::pair<unsigned int, unsigned int> IntPair;
     std::vector<IntPair> moffsets(nmesh);
     unsigned int totfaces = 0, totvert = 0;
     for (size_t t = 0; t < nmesh; ++t) {
-        const aiMesh* mesh = smesh[t];
+        const aiMesh *mesh = smesh[t];
 
-        spatial.Append(mesh->mVertices,mesh->mNumVertices,sizeof(aiVector3D),false);
-        moffsets[t] = IntPair(totfaces,totvert);
+        spatial.Append(mesh->mVertices, mesh->mNumVertices, sizeof(aiVector3D), false);
+        moffsets[t] = IntPair(totfaces, totvert);
 
         totfaces += mesh->mNumFaces;
-        totvert  += mesh->mNumVertices;
+        totvert += mesh->mNumVertices;
     }
 
     spatial.Finalize();
-    const unsigned int num_unique = spatial.GenerateMappingTable(maptbl,ComputePositionEpsilon(smesh,nmesh));
+    const unsigned int num_unique = spatial.GenerateMappingTable(maptbl, ComputePositionEpsilon(smesh, nmesh));
 
-
-#define FLATTEN_VERTEX_IDX(mesh_idx, vert_idx) (moffsets[mesh_idx].second+vert_idx)
-#define   FLATTEN_FACE_IDX(mesh_idx, face_idx) (moffsets[mesh_idx].first+face_idx)
+#define FLATTEN_VERTEX_IDX(mesh_idx, vert_idx) (moffsets[mesh_idx].second + vert_idx)
+#define FLATTEN_FACE_IDX(mesh_idx, face_idx) (moffsets[mesh_idx].first + face_idx)
 
     // ---------------------------------------------------------------------
     // 1. Compute the centroid point for all faces
@@ -274,14 +267,13 @@ void CatmullClarkSubdivider::InternSubdivide (
     std::vector<Vertex> centroids(totfaces);
     unsigned int nfacesout = 0;
     for (size_t t = 0, n = 0; t < nmesh; ++t) {
-        const aiMesh* mesh = smesh[t];
-        for (unsigned int i = 0; i < mesh->mNumFaces;++i,++n)
-        {
-            const aiFace& face = mesh->mFaces[i];
-            Vertex& c = centroids[n];
+        const aiMesh *mesh = smesh[t];
+        for (unsigned int i = 0; i < mesh->mNumFaces; ++i, ++n) {
+            const aiFace &face = mesh->mFaces[i];
+            Vertex &c = centroids[n];
 
-            for (unsigned int a = 0; a < face.mNumIndices;++a) {
-                c += Vertex(mesh,face.mIndices[a]);
+            for (unsigned int a = 0; a < face.mNumIndices; ++a) {
+                c += Vertex(mesh, face.mIndices[a]);
             }
 
             c /= static_cast<float>(face.mNumIndices);
@@ -290,297 +282,297 @@ void CatmullClarkSubdivider::InternSubdivide (
     }
 
     {
-    // we want edges to go away before the recursive calls so begin a new scope
-    EdgeMap edges;
+        // we want edges to go away before the recursive calls so begin a new scope
+        EdgeMap edges;
 
-    // ---------------------------------------------------------------------
-    // 2. Set each edge point to be the average of all neighbouring
-    // face points and original points. Every edge exists twice
-    // if there is a neighboring face.
-    // ---------------------------------------------------------------------
-    for (size_t t = 0; t < nmesh; ++t) {
-        const aiMesh* mesh = smesh[t];
+        // ---------------------------------------------------------------------
+        // 2. Set each edge point to be the average of all neighbouring
+        // face points and original points. Every edge exists twice
+        // if there is a neighboring face.
+        // ---------------------------------------------------------------------
+        for (size_t t = 0; t < nmesh; ++t) {
+            const aiMesh *mesh = smesh[t];
 
-        for (unsigned int i = 0; i < mesh->mNumFaces;++i)   {
-            const aiFace& face = mesh->mFaces[i];
+            for (unsigned int i = 0; i < mesh->mNumFaces; ++i) {
+                const aiFace &face = mesh->mFaces[i];
 
-            for (unsigned int p =0; p< face.mNumIndices; ++p) {
-                const unsigned int id[] = {
-                    face.mIndices[p],
-                    face.mIndices[p==face.mNumIndices-1?0:p+1]
-                };
-                const unsigned int mp[] = {
-                    maptbl[FLATTEN_VERTEX_IDX(t,id[0])],
-                    maptbl[FLATTEN_VERTEX_IDX(t,id[1])]
-                };
+                for (unsigned int p = 0; p < face.mNumIndices; ++p) {
+                    const unsigned int id[] = {
+                        face.mIndices[p],
+                        face.mIndices[p == face.mNumIndices - 1 ? 0 : p + 1]
+                    };
+                    const unsigned int mp[] = {
+                        maptbl[FLATTEN_VERTEX_IDX(t, id[0])],
+                        maptbl[FLATTEN_VERTEX_IDX(t, id[1])]
+                    };
 
-                Edge& e = edges[MAKE_EDGE_HASH(mp[0],mp[1])];
-                e.ref++;
-                if (e.ref<=2) {
-                    if (e.ref==1) { // original points (end points) - add only once
-                        e.edge_point = e.midpoint = Vertex(mesh,id[0])+Vertex(mesh,id[1]);
-                        e.midpoint *= 0.5f;
+                    Edge &e = edges[MAKE_EDGE_HASH(mp[0], mp[1])];
+                    e.ref++;
+                    if (e.ref <= 2) {
+                        if (e.ref == 1) { // original points (end points) - add only once
+                            e.edge_point = e.midpoint = Vertex(mesh, id[0]) + Vertex(mesh, id[1]);
+                            e.midpoint *= 0.5f;
+                        }
+                        e.edge_point += centroids[FLATTEN_FACE_IDX(t, i)];
                     }
-                    e.edge_point += centroids[FLATTEN_FACE_IDX(t,i)];
                 }
             }
         }
-    }
 
-    // ---------------------------------------------------------------------
-    // 3. Normalize edge points
-    // ---------------------------------------------------------------------
-    {unsigned int bad_cnt = 0;
-    for (EdgeMap::iterator it = edges.begin(); it != edges.end(); ++it) {
-        if ((*it).second.ref < 2) {
-            ai_assert((*it).second.ref);
-            ++bad_cnt;
-        }
-        (*it).second.edge_point *= 1.f/((*it).second.ref+2.f);
-    }
+        // ---------------------------------------------------------------------
+        // 3. Normalize edge points
+        // ---------------------------------------------------------------------
+        {
+            unsigned int bad_cnt = 0;
+            for (EdgeMap::iterator it = edges.begin(); it != edges.end(); ++it) {
+                if ((*it).second.ref < 2) {
+                    ai_assert((*it).second.ref);
+                    ++bad_cnt;
+                }
+                (*it).second.edge_point *= 1.f / ((*it).second.ref + 2.f);
+            }
 
-    if (bad_cnt) {
-        // Report the number of bad edges. bad edges are referenced by less than two
-        // faces in the mesh. They occur at outer model boundaries in non-closed
-        // shapes.
-        ASSIMP_LOG_DEBUG_F("Catmull-Clark Subdivider: got ", bad_cnt, " bad edges touching only one face (totally ", 
-            static_cast<unsigned int>(edges.size()), " edges). ");
-    }}
-
-    // ---------------------------------------------------------------------
-    // 4. Compute a vertex-face adjacency table. We can't reuse the code
-    // from VertexTriangleAdjacency because we need the table for multiple
-    // meshes and out vertex indices need to be mapped to distinct values
-    // first.
-    // ---------------------------------------------------------------------
-    UIntVector faceadjac(nfacesout), cntadjfac(maptbl.size(),0), ofsadjvec(maptbl.size()+1,0); {
-    for (size_t t = 0; t < nmesh; ++t) {
-        const aiMesh* const minp = smesh[t];
-        for (unsigned int i = 0; i < minp->mNumFaces; ++i) {
-
-            const aiFace& f = minp->mFaces[i];
-            for (unsigned int n = 0; n < f.mNumIndices; ++n) {
-                ++cntadjfac[maptbl[FLATTEN_VERTEX_IDX(t,f.mIndices[n])]];
+            if (bad_cnt) {
+                // Report the number of bad edges. bad edges are referenced by less than two
+                // faces in the mesh. They occur at outer model boundaries in non-closed
+                // shapes.
+                ASSIMP_LOG_VERBOSE_DEBUG("Catmull-Clark Subdivider: got ", bad_cnt, " bad edges touching only one face (totally ",
+                        static_cast<unsigned int>(edges.size()), " edges). ");
             }
         }
-    }
-    unsigned int cur = 0;
-    for (size_t i = 0; i < cntadjfac.size(); ++i) {
-        ofsadjvec[i+1] = cur;
-        cur += cntadjfac[i];
-    }
-    for (size_t t = 0; t < nmesh; ++t) {
-        const aiMesh* const minp = smesh[t];
-        for (unsigned int i = 0; i < minp->mNumFaces; ++i) {
 
-            const aiFace& f = minp->mFaces[i];
-            for (unsigned int n = 0; n < f.mNumIndices; ++n) {
-                faceadjac[ofsadjvec[1+maptbl[FLATTEN_VERTEX_IDX(t,f.mIndices[n])]]++] = FLATTEN_FACE_IDX(t,i);
+        // ---------------------------------------------------------------------
+        // 4. Compute a vertex-face adjacency table. We can't reuse the code
+        // from VertexTriangleAdjacency because we need the table for multiple
+        // meshes and out vertex indices need to be mapped to distinct values
+        // first.
+        // ---------------------------------------------------------------------
+        UIntVector faceadjac(nfacesout), cntadjfac(maptbl.size(), 0), ofsadjvec(maptbl.size() + 1, 0);
+        {
+            for (size_t t = 0; t < nmesh; ++t) {
+                const aiMesh *const minp = smesh[t];
+                for (unsigned int i = 0; i < minp->mNumFaces; ++i) {
+
+                    const aiFace &f = minp->mFaces[i];
+                    for (unsigned int n = 0; n < f.mNumIndices; ++n) {
+                        ++cntadjfac[maptbl[FLATTEN_VERTEX_IDX(t, f.mIndices[n])]];
+                    }
+                }
             }
-        }
-    }
+            unsigned int cur = 0;
+            for (size_t i = 0; i < cntadjfac.size(); ++i) {
+                ofsadjvec[i + 1] = cur;
+                cur += cntadjfac[i];
+            }
+            for (size_t t = 0; t < nmesh; ++t) {
+                const aiMesh *const minp = smesh[t];
+                for (unsigned int i = 0; i < minp->mNumFaces; ++i) {
 
-    // check the other way round for consistency
+                    const aiFace &f = minp->mFaces[i];
+                    for (unsigned int n = 0; n < f.mNumIndices; ++n) {
+                        faceadjac[ofsadjvec[1 + maptbl[FLATTEN_VERTEX_IDX(t, f.mIndices[n])]]++] = FLATTEN_FACE_IDX(t, i);
+                    }
+                }
+            }
+
+            // check the other way round for consistency
 #ifdef ASSIMP_BUILD_DEBUG
 
-    for (size_t t = 0; t < ofsadjvec.size()-1; ++t) {
-        for (unsigned int m = 0; m <  cntadjfac[t]; ++m) {
-            const unsigned int fidx = faceadjac[ofsadjvec[t]+m];
-            ai_assert(fidx < totfaces);
-            for (size_t n = 1; n < nmesh; ++n) {
+            for (size_t t = 0; t < ofsadjvec.size() - 1; ++t) {
+                for (unsigned int m = 0; m < cntadjfac[t]; ++m) {
+                    const unsigned int fidx = faceadjac[ofsadjvec[t] + m];
+                    ai_assert(fidx < totfaces);
+                    for (size_t n = 1; n < nmesh; ++n) {
 
-                if (moffsets[n].first > fidx) {
-                    const aiMesh* msh = smesh[--n];
-                    const aiFace& f = msh->mFaces[fidx-moffsets[n].first];
+                        if (moffsets[n].first > fidx) {
+                            const aiMesh *msh = smesh[--n];
+                            const aiFace &f = msh->mFaces[fidx - moffsets[n].first];
 
-                    bool haveit = false;
-                    for (unsigned int i = 0; i < f.mNumIndices; ++i) {
-                        if (maptbl[FLATTEN_VERTEX_IDX(n,f.mIndices[i])]==(unsigned int)t) {
-                            haveit = true;
-                            break;
-                        }
-                    }
-                    ai_assert(haveit);
-                    if (!haveit) {
-                        ASSIMP_LOG_DEBUG("Catmull-Clark Subdivider: Index not used");
-                    }
-                    break;
-                }
-            }
-        }
-    }
-
-#endif
-    }
-
-#define GET_ADJACENT_FACES_AND_CNT(vidx,fstartout,numout) \
-    fstartout = &faceadjac[ofsadjvec[vidx]], numout = cntadjfac[vidx]
-
-    typedef std::pair<bool,Vertex> TouchedOVertex;
-    std::vector<TouchedOVertex > new_points(num_unique,TouchedOVertex(false,Vertex()));
-    // ---------------------------------------------------------------------
-    // 5. Spawn a quad from each face point to the corresponding edge points
-    // the original points being the fourth quad points.
-    // ---------------------------------------------------------------------
-    for (size_t t = 0; t < nmesh; ++t) {
-        const aiMesh* const minp = smesh[t];
-        aiMesh* const mout = out[t] = new aiMesh();
-
-        for (unsigned int a  = 0; a < minp->mNumFaces; ++a) {
-            mout->mNumFaces += minp->mFaces[a].mNumIndices;
-        }
-
-        // We need random access to the old face buffer, so reuse is not possible.
-        mout->mFaces = new aiFace[mout->mNumFaces];
-
-        mout->mNumVertices = mout->mNumFaces*4;
-        mout->mVertices = new aiVector3D[mout->mNumVertices];
-
-        // quads only, keep material index
-        mout->mPrimitiveTypes = aiPrimitiveType_POLYGON;
-        mout->mMaterialIndex = minp->mMaterialIndex;
-
-        if (minp->HasNormals()) {
-            mout->mNormals = new aiVector3D[mout->mNumVertices];
-        }
-
-        if (minp->HasTangentsAndBitangents()) {
-            mout->mTangents = new aiVector3D[mout->mNumVertices];
-            mout->mBitangents = new aiVector3D[mout->mNumVertices];
-        }
-
-        for(unsigned int i = 0; minp->HasTextureCoords(i); ++i) {
-            mout->mTextureCoords[i] = new aiVector3D[mout->mNumVertices];
-            mout->mNumUVComponents[i] = minp->mNumUVComponents[i];
-        }
-
-        for(unsigned int i = 0; minp->HasVertexColors(i); ++i) {
-            mout->mColors[i] = new aiColor4D[mout->mNumVertices];
-        }
-
-        mout->mNumVertices = mout->mNumFaces<<2u;
-        for (unsigned int i = 0, v = 0, n = 0; i < minp->mNumFaces;++i) {
-
-            const aiFace& face = minp->mFaces[i];
-            for (unsigned int a = 0; a < face.mNumIndices;++a)  {
-
-                // Get a clean new face.
-                aiFace& faceOut = mout->mFaces[n++];
-                faceOut.mIndices = new unsigned int [faceOut.mNumIndices = 4];
-
-                // Spawn a new quadrilateral (ccw winding) for this original point between:
-                // a) face centroid
-                centroids[FLATTEN_FACE_IDX(t,i)].SortBack(mout,faceOut.mIndices[0]=v++);
-
-                // b) adjacent edge on the left, seen from the centroid
-                const Edge& e0 = edges[MAKE_EDGE_HASH(maptbl[FLATTEN_VERTEX_IDX(t,face.mIndices[a])],
-                    maptbl[FLATTEN_VERTEX_IDX(t,face.mIndices[a==face.mNumIndices-1?0:a+1])
-                    ])];  // fixme: replace with mod face.mNumIndices?
-
-                // c) adjacent edge on the right, seen from the centroid
-                const Edge& e1 = edges[MAKE_EDGE_HASH(maptbl[FLATTEN_VERTEX_IDX(t,face.mIndices[a])],
-                    maptbl[FLATTEN_VERTEX_IDX(t,face.mIndices[!a?face.mNumIndices-1:a-1])
-                    ])];  // fixme: replace with mod face.mNumIndices?
-
-                e0.edge_point.SortBack(mout,faceOut.mIndices[3]=v++);
-                e1.edge_point.SortBack(mout,faceOut.mIndices[1]=v++);
-
-                // d= original point P with distinct index i
-                // F := 0
-                // R := 0
-                // n := 0
-                // for each face f containing i
-                //    F := F+ centroid of f
-                //    R := R+ midpoint of edge of f from i to i+1
-                //    n := n+1
-                //
-                // (F+2R+(n-3)P)/n
-                const unsigned int org = maptbl[FLATTEN_VERTEX_IDX(t,face.mIndices[a])];
-                TouchedOVertex& ov = new_points[org];
-
-                if (!ov.first) {
-                    ov.first = true;
-
-                    const unsigned int* adj; unsigned int cnt;
-                    GET_ADJACENT_FACES_AND_CNT(org,adj,cnt);
-
-                    if (cnt < 3) {
-                        ov.second = Vertex(minp,face.mIndices[a]);
-                    }
-                    else {
-
-                        Vertex F,R;
-                        for (unsigned int o = 0; o < cnt; ++o) {
-                            ai_assert(adj[o] < totfaces);
-                            F += centroids[adj[o]];
-
-                            // adj[0] is a global face index - search the face in the mesh list
-                            const aiMesh* mp = NULL;
-                            size_t nidx;
-
-                            if (adj[o] < moffsets[0].first) {
-                                mp = smesh[nidx=0];
-                            }
-                            else {
-                                for (nidx = 1; nidx<= nmesh; ++nidx) {
-                                    if (nidx == nmesh ||moffsets[nidx].first > adj[o]) {
-                                        mp = smesh[--nidx];
-                                        break;
-                                    }
-                                }
-                            }
-
-                            ai_assert(adj[o]-moffsets[nidx].first < mp->mNumFaces);
-                            const aiFace& f = mp->mFaces[adj[o]-moffsets[nidx].first];
                             bool haveit = false;
-
-                            // find our original point in the face
-                            for (unsigned int m = 0; m < f.mNumIndices; ++m) {
-                                if (maptbl[FLATTEN_VERTEX_IDX(nidx,f.mIndices[m])] == org) {
-
-                                    // add *both* edges. this way, we can be sure that we add
-                                    // *all* adjacent edges to R. In a closed shape, every
-                                    // edge is added twice - so we simply leave out the
-                                    // factor 2.f in the amove formula and get the right
-                                    // result.
-
-                                    const Edge& c0 = edges[MAKE_EDGE_HASH(org,maptbl[FLATTEN_VERTEX_IDX(
-                                        nidx,f.mIndices[!m?f.mNumIndices-1:m-1])])];
-                                    // fixme: replace with mod face.mNumIndices?
-
-                                    const Edge& c1 = edges[MAKE_EDGE_HASH(org,maptbl[FLATTEN_VERTEX_IDX(
-                                        nidx,f.mIndices[m==f.mNumIndices-1?0:m+1])])];
-                                    // fixme: replace with mod face.mNumIndices?
-                                    R += c0.midpoint+c1.midpoint;
-
+                            for (unsigned int i = 0; i < f.mNumIndices; ++i) {
+                                if (maptbl[FLATTEN_VERTEX_IDX(n, f.mIndices[i])] == (unsigned int)t) {
                                     haveit = true;
                                     break;
                                 }
                             }
-
-                            // this invariant *must* hold if the vertex-to-face adjacency table is valid
                             ai_assert(haveit);
-                            if ( !haveit ) {
-                                ASSIMP_LOG_WARN( "OBJ: no name for material library specified." );
+                            if (!haveit) {
+                                ASSIMP_LOG_VERBOSE_DEBUG("Catmull-Clark Subdivider: Index not used");
                             }
+                            break;
                         }
-
-                        const float div = static_cast<float>(cnt), divsq = 1.f/(div*div);
-                        ov.second = Vertex(minp,face.mIndices[a])*((div-3.f) / div) + R*divsq + F*divsq;
                     }
                 }
-                ov.second.SortBack(mout,faceOut.mIndices[2]=v++);
+            }
+
+#endif
+        }
+
+#define GET_ADJACENT_FACES_AND_CNT(vidx, fstartout, numout) \
+    fstartout = &faceadjac[ofsadjvec[vidx]], numout = cntadjfac[vidx]
+
+        typedef std::pair<bool, Vertex> TouchedOVertex;
+        std::vector<TouchedOVertex> new_points(num_unique, TouchedOVertex(false, Vertex()));
+        // ---------------------------------------------------------------------
+        // 5. Spawn a quad from each face point to the corresponding edge points
+        // the original points being the fourth quad points.
+        // ---------------------------------------------------------------------
+        for (size_t t = 0; t < nmesh; ++t) {
+            const aiMesh *const minp = smesh[t];
+            aiMesh *const mout = out[t] = new aiMesh();
+
+            for (unsigned int a = 0; a < minp->mNumFaces; ++a) {
+                mout->mNumFaces += minp->mFaces[a].mNumIndices;
+            }
+
+            // We need random access to the old face buffer, so reuse is not possible.
+            mout->mFaces = new aiFace[mout->mNumFaces];
+
+            mout->mNumVertices = mout->mNumFaces * 4;
+            mout->mVertices = new aiVector3D[mout->mNumVertices];
+
+            // quads only, keep material index
+            mout->mPrimitiveTypes = aiPrimitiveType_POLYGON;
+            mout->mMaterialIndex = minp->mMaterialIndex;
+
+            if (minp->HasNormals()) {
+                mout->mNormals = new aiVector3D[mout->mNumVertices];
+            }
+
+            if (minp->HasTangentsAndBitangents()) {
+                mout->mTangents = new aiVector3D[mout->mNumVertices];
+                mout->mBitangents = new aiVector3D[mout->mNumVertices];
+            }
+
+            for (unsigned int i = 0; minp->HasTextureCoords(i); ++i) {
+                mout->mTextureCoords[i] = new aiVector3D[mout->mNumVertices];
+                mout->mNumUVComponents[i] = minp->mNumUVComponents[i];
+            }
+
+            for (unsigned int i = 0; minp->HasVertexColors(i); ++i) {
+                mout->mColors[i] = new aiColor4D[mout->mNumVertices];
+            }
+
+            mout->mNumVertices = mout->mNumFaces << 2u;
+            for (unsigned int i = 0, v = 0, n = 0; i < minp->mNumFaces; ++i) {
+
+                const aiFace &face = minp->mFaces[i];
+                for (unsigned int a = 0; a < face.mNumIndices; ++a) {
+
+                    // Get a clean new face.
+                    aiFace &faceOut = mout->mFaces[n++];
+                    faceOut.mIndices = new unsigned int[faceOut.mNumIndices = 4];
+
+                    // Spawn a new quadrilateral (ccw winding) for this original point between:
+                    // a) face centroid
+                    centroids[FLATTEN_FACE_IDX(t, i)].SortBack(mout, faceOut.mIndices[0] = v++);
+
+                    // b) adjacent edge on the left, seen from the centroid
+                    const Edge &e0 = edges[MAKE_EDGE_HASH(maptbl[FLATTEN_VERTEX_IDX(t, face.mIndices[a])],
+                            maptbl[FLATTEN_VERTEX_IDX(t, face.mIndices[a == face.mNumIndices - 1 ? 0 : a + 1])])]; // fixme: replace with mod face.mNumIndices?
+
+                    // c) adjacent edge on the right, seen from the centroid
+                    const Edge &e1 = edges[MAKE_EDGE_HASH(maptbl[FLATTEN_VERTEX_IDX(t, face.mIndices[a])],
+                            maptbl[FLATTEN_VERTEX_IDX(t, face.mIndices[!a ? face.mNumIndices - 1 : a - 1])])]; // fixme: replace with mod face.mNumIndices?
+
+                    e0.edge_point.SortBack(mout, faceOut.mIndices[3] = v++);
+                    e1.edge_point.SortBack(mout, faceOut.mIndices[1] = v++);
+
+                    // d= original point P with distinct index i
+                    // F := 0
+                    // R := 0
+                    // n := 0
+                    // for each face f containing i
+                    //    F := F+ centroid of f
+                    //    R := R+ midpoint of edge of f from i to i+1
+                    //    n := n+1
+                    //
+                    // (F+2R+(n-3)P)/n
+                    const unsigned int org = maptbl[FLATTEN_VERTEX_IDX(t, face.mIndices[a])];
+                    TouchedOVertex &ov = new_points[org];
+
+                    if (!ov.first) {
+                        ov.first = true;
+
+                        const unsigned int *adj;
+                        unsigned int cnt;
+                        GET_ADJACENT_FACES_AND_CNT(org, adj, cnt);
+
+                        if (cnt < 3) {
+                            ov.second = Vertex(minp, face.mIndices[a]);
+                        } else {
+
+                            Vertex F, R;
+                            for (unsigned int o = 0; o < cnt; ++o) {
+                                ai_assert(adj[o] < totfaces);
+                                F += centroids[adj[o]];
+
+                                // adj[0] is a global face index - search the face in the mesh list
+                                const aiMesh *mp = nullptr;
+                                size_t nidx;
+
+                                if (adj[o] < moffsets[0].first) {
+                                    mp = smesh[nidx = 0];
+                                } else {
+                                    for (nidx = 1; nidx <= nmesh; ++nidx) {
+                                        if (nidx == nmesh || moffsets[nidx].first > adj[o]) {
+                                            mp = smesh[--nidx];
+                                            break;
+                                        }
+                                    }
+                                }
+
+                                ai_assert(adj[o] - moffsets[nidx].first < mp->mNumFaces);
+                                const aiFace &f = mp->mFaces[adj[o] - moffsets[nidx].first];
+                                bool haveit = false;
+
+                                // find our original point in the face
+                                for (unsigned int m = 0; m < f.mNumIndices; ++m) {
+                                    if (maptbl[FLATTEN_VERTEX_IDX(nidx, f.mIndices[m])] == org) {
+
+                                        // add *both* edges. this way, we can be sure that we add
+                                        // *all* adjacent edges to R. In a closed shape, every
+                                        // edge is added twice - so we simply leave out the
+                                        // factor 2.f in the amove formula and get the right
+                                        // result.
+
+                                        const Edge &c0 = edges[MAKE_EDGE_HASH(org, maptbl[FLATTEN_VERTEX_IDX(
+                                                                                           nidx, f.mIndices[!m ? f.mNumIndices - 1 : m - 1])])];
+                                        // fixme: replace with mod face.mNumIndices?
+
+                                        const Edge &c1 = edges[MAKE_EDGE_HASH(org, maptbl[FLATTEN_VERTEX_IDX(
+                                                                                           nidx, f.mIndices[m == f.mNumIndices - 1 ? 0 : m + 1])])];
+                                        // fixme: replace with mod face.mNumIndices?
+                                        R += c0.midpoint + c1.midpoint;
+
+                                        haveit = true;
+                                        break;
+                                    }
+                                }
+
+                                // this invariant *must* hold if the vertex-to-face adjacency table is valid
+                                ai_assert(haveit);
+                                if (!haveit) {
+                                    ASSIMP_LOG_WARN("OBJ: no name for material library specified.");
+                                }
+                            }
+
+                            const float div = static_cast<float>(cnt), divsq = 1.f / (div * div);
+                            ov.second = Vertex(minp, face.mIndices[a]) * ((div - 3.f) / div) + R * divsq + F * divsq;
+                        }
+                    }
+                    ov.second.SortBack(mout, faceOut.mIndices[2] = v++);
+                }
             }
         }
-    }
-    }  // end of scope for edges, freeing its memory
+    } // end of scope for edges, freeing its memory
 
     // ---------------------------------------------------------------------
     // 7. Apply the next subdivision step.
     // ---------------------------------------------------------------------
     if (num != 1) {
-        std::vector<aiMesh*> tmp(nmesh);
-        InternSubdivide (out,nmesh,&tmp.front(),num-1);
+        std::vector<aiMesh *> tmp(nmesh);
+        InternSubdivide(out, nmesh, &tmp.front(), num - 1);
         for (size_t i = 0; i < nmesh; ++i) {
             delete out[i];
             out[i] = tmp[i];
diff --git a/Engine/lib/assimp/code/Common/TargetAnimation.cpp b/Engine/lib/assimp/code/Common/TargetAnimation.cpp
index b8062499f..5f6d9bad0 100644
--- a/Engine/lib/assimp/code/Common/TargetAnimation.cpp
+++ b/Engine/lib/assimp/code/Common/TargetAnimation.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -41,58 +41,51 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "TargetAnimation.h"
-#include <algorithm>
 #include <assimp/ai_assert.h>
+#include <algorithm>
 
 using namespace Assimp;
 
-
 // ------------------------------------------------------------------------------------------------
-KeyIterator::KeyIterator(const std::vector<aiVectorKey>* _objPos,
-    const std::vector<aiVectorKey>* _targetObjPos,
-    const aiVector3D*  defaultObjectPos /*= NULL*/,
-    const aiVector3D*  defaultTargetPos /*= NULL*/)
-
-        :   reachedEnd      (false)
-        ,   curTime         (-1.)
-        ,   objPos          (_objPos)
-        ,   targetObjPos    (_targetObjPos)
-        ,   nextObjPos      (0)
-        ,   nextTargetObjPos(0)
-{
+KeyIterator::KeyIterator(const std::vector<aiVectorKey> *_objPos,
+    const std::vector<aiVectorKey> *_targetObjPos,
+    const aiVector3D *defaultObjectPos /*= nullptr*/,
+    const aiVector3D *defaultTargetPos /*= nullptr*/) :
+        reachedEnd(false),
+        curTime(-1.),
+        objPos(_objPos),
+        targetObjPos(_targetObjPos),
+        nextObjPos(0),
+        nextTargetObjPos(0) {
     // Generate default transformation tracks if necessary
-    if (!objPos || objPos->empty())
-    {
+    if (!objPos || objPos->empty()) {
         defaultObjPos.resize(1);
-        defaultObjPos.front().mTime  = 10e10;
+        defaultObjPos.front().mTime = 10e10;
 
         if (defaultObjectPos)
             defaultObjPos.front().mValue = *defaultObjectPos;
 
-        objPos = & defaultObjPos;
+        objPos = &defaultObjPos;
     }
-    if (!targetObjPos || targetObjPos->empty())
-    {
+    if (!targetObjPos || targetObjPos->empty()) {
         defaultTargetObjPos.resize(1);
-        defaultTargetObjPos.front().mTime  = 10e10;
+        defaultTargetObjPos.front().mTime = 10e10;
 
         if (defaultTargetPos)
             defaultTargetObjPos.front().mValue = *defaultTargetPos;
 
-        targetObjPos = & defaultTargetObjPos;
+        targetObjPos = &defaultTargetObjPos;
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 template <class T>
-inline T Interpolate(const T& one, const T& two, ai_real val)
-{
-    return one + (two-one)*val;
+inline T Interpolate(const T &one, const T &two, ai_real val) {
+    return one + (two - one) * val;
 }
 
 // ------------------------------------------------------------------------------------------------
-void KeyIterator::operator ++()
-{
+void KeyIterator::operator++() {
     // If we are already at the end of all keyframes, return
     if (reachedEnd) {
         return;
@@ -100,113 +93,102 @@ void KeyIterator::operator ++()
 
     // Now search in all arrays for the time value closest
     // to our current position on the time line
-    double d0,d1;
+    double d0, d1;
 
-    d0 = objPos->at      ( std::min ( nextObjPos, static_cast<unsigned int>(objPos->size()-1))             ).mTime;
-    d1 = targetObjPos->at( std::min ( nextTargetObjPos, static_cast<unsigned int>(targetObjPos->size()-1)) ).mTime;
+    d0 = objPos->at(std::min(nextObjPos, static_cast<unsigned int>(objPos->size() - 1))).mTime;
+    d1 = targetObjPos->at(std::min(nextTargetObjPos, static_cast<unsigned int>(targetObjPos->size() - 1))).mTime;
 
     // Easiest case - all are identical. In this
     // case we don't need to interpolate so we can
     // return earlier
-    if ( d0 == d1 )
-    {
+    if (d0 == d1) {
         curTime = d0;
         curPosition = objPos->at(nextObjPos).mValue;
         curTargetPosition = targetObjPos->at(nextTargetObjPos).mValue;
 
         // increment counters
-        if (objPos->size() != nextObjPos-1)
+        if (objPos->size() != nextObjPos - 1)
             ++nextObjPos;
 
-        if (targetObjPos->size() != nextTargetObjPos-1)
+        if (targetObjPos->size() != nextTargetObjPos - 1)
             ++nextTargetObjPos;
     }
 
     // An object position key is closest to us
-    else if (d0 < d1)
-    {
+    else if (d0 < d1) {
         curTime = d0;
 
         // interpolate the other
         if (1 == targetObjPos->size() || !nextTargetObjPos) {
             curTargetPosition = targetObjPos->at(0).mValue;
-        }
-        else
-        {
-            const aiVectorKey& last  = targetObjPos->at(nextTargetObjPos);
-            const aiVectorKey& first = targetObjPos->at(nextTargetObjPos-1);
+        } else {
+            const aiVectorKey &last = targetObjPos->at(nextTargetObjPos);
+            const aiVectorKey &first = targetObjPos->at(nextTargetObjPos - 1);
 
-            curTargetPosition = Interpolate(first.mValue, last.mValue, (ai_real) (
-                (curTime-first.mTime) / (last.mTime-first.mTime) ));
+            curTargetPosition = Interpolate(first.mValue, last.mValue, (ai_real)((curTime - first.mTime) / (last.mTime - first.mTime)));
         }
 
-        if (objPos->size() != nextObjPos-1)
+        if (objPos->size() != nextObjPos - 1)
             ++nextObjPos;
     }
     // A target position key is closest to us
-    else
-    {
+    else {
         curTime = d1;
 
         // interpolate the other
         if (1 == objPos->size() || !nextObjPos) {
             curPosition = objPos->at(0).mValue;
-        }
-        else
-        {
-            const aiVectorKey& last  = objPos->at(nextObjPos);
-            const aiVectorKey& first = objPos->at(nextObjPos-1);
+        } else {
+            const aiVectorKey &last = objPos->at(nextObjPos);
+            const aiVectorKey &first = objPos->at(nextObjPos - 1);
 
-            curPosition = Interpolate(first.mValue, last.mValue, (ai_real) (
-                (curTime-first.mTime) / (last.mTime-first.mTime)));
+            curPosition = Interpolate(first.mValue, last.mValue, (ai_real)((curTime - first.mTime) / (last.mTime - first.mTime)));
         }
 
-        if (targetObjPos->size() != nextTargetObjPos-1)
+        if (targetObjPos->size() != nextTargetObjPos - 1)
             ++nextTargetObjPos;
     }
 
-    if (nextObjPos >= objPos->size()-1 &&
-        nextTargetObjPos >= targetObjPos->size()-1)
-    {
+    if (nextObjPos >= objPos->size() - 1 &&
+            nextTargetObjPos >= targetObjPos->size() - 1) {
         // We reached the very last keyframe
         reachedEnd = true;
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void TargetAnimationHelper::SetTargetAnimationChannel (
-    const std::vector<aiVectorKey>* _targetPositions)
-{
-    ai_assert(NULL != _targetPositions);
+void TargetAnimationHelper::SetTargetAnimationChannel(
+        const std::vector<aiVectorKey> *_targetPositions) {
+    ai_assert(nullptr != _targetPositions);
+
     targetPositions = _targetPositions;
 }
 
 // ------------------------------------------------------------------------------------------------
-void TargetAnimationHelper::SetMainAnimationChannel (
-    const std::vector<aiVectorKey>* _objectPositions)
-{
-    ai_assert(NULL != _objectPositions);
+void TargetAnimationHelper::SetMainAnimationChannel(
+        const std::vector<aiVectorKey> *_objectPositions) {
+    ai_assert(nullptr != _objectPositions);
+
     objectPositions = _objectPositions;
 }
 
 // ------------------------------------------------------------------------------------------------
 void TargetAnimationHelper::SetFixedMainAnimationChannel(
-    const aiVector3D& fixed)
-{
-    objectPositions = NULL; // just to avoid confusion
+        const aiVector3D &fixed) {
+    objectPositions = nullptr; // just to avoid confusion
     fixedMain = fixed;
 }
 
 // ------------------------------------------------------------------------------------------------
-void TargetAnimationHelper::Process(std::vector<aiVectorKey>* distanceTrack)
-{
-    ai_assert(NULL != targetPositions && NULL != distanceTrack);
+void TargetAnimationHelper::Process(std::vector<aiVectorKey> *distanceTrack) {
+    ai_assert(nullptr != targetPositions);
+    ai_assert(nullptr != distanceTrack);
 
     // TODO: in most cases we won't need the extra array
-    std::vector<aiVectorKey>  real;
+    std::vector<aiVectorKey> real;
 
-    std::vector<aiVectorKey>* fill = (distanceTrack == objectPositions ? &real : distanceTrack);
-    fill->reserve(std::max( objectPositions->size(), targetPositions->size() ));
+    std::vector<aiVectorKey> *fill = (distanceTrack == objectPositions ? &real : distanceTrack);
+    fill->reserve(std::max(objectPositions->size(), targetPositions->size()));
 
     // Iterate through all object keys and interpolate their values if necessary.
     // Then get the corresponding target position, compute the difference
@@ -214,28 +196,24 @@ void TargetAnimationHelper::Process(std::vector<aiVectorKey>* distanceTrack)
     // that rotates the base vector of the object coordinate system at that time
     // to match the diff vector.
 
-    KeyIterator iter(objectPositions,targetPositions,&fixedMain);
-    for (;!iter.Finished();++iter)
-    {
-        const aiVector3D&  position  = iter.GetCurPosition();
-        const aiVector3D&  tposition = iter.GetCurTargetPosition();
+    KeyIterator iter(objectPositions, targetPositions, &fixedMain);
+    for (; !iter.Finished(); ++iter) {
+        const aiVector3D &position = iter.GetCurPosition();
+        const aiVector3D &tposition = iter.GetCurTargetPosition();
 
         // diff vector
         aiVector3D diff = tposition - position;
         ai_real f = diff.Length();
 
         // output distance vector
-        if (f)
-        {
+        if (f) {
             fill->push_back(aiVectorKey());
-            aiVectorKey& v = fill->back();
-            v.mTime  = iter.GetCurTime();
+            aiVectorKey &v = fill->back();
+            v.mTime = iter.GetCurTime();
             v.mValue = diff;
 
             diff /= f;
-        }
-        else
-        {
+        } else {
             // FIXME: handle this
         }
 
diff --git a/Engine/lib/assimp/code/Common/TargetAnimation.h b/Engine/lib/assimp/code/Common/TargetAnimation.h
index 91634ab5a..863406b94 100644
--- a/Engine/lib/assimp/code/Common/TargetAnimation.h
+++ b/Engine/lib/assimp/code/Common/TargetAnimation.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -48,9 +48,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/anim.h>
 #include <vector>
 
-namespace Assimp    {
-
-
+namespace Assimp {
 
 // ---------------------------------------------------------------------------
 /** Helper class to iterate through all keys in an animation channel.
@@ -58,55 +56,44 @@ namespace Assimp    {
  *  Missing tracks are interpolated. This is a helper class for
  *  TargetAnimationHelper, but it can be freely used for other purposes.
 */
-class KeyIterator
-{
+class KeyIterator {
 public:
-
-
     // ------------------------------------------------------------------
     /** Constructs a new key iterator
      *
-     *  @param _objPos Object position track. May be NULL.
-     *  @param _targetObjPos Target object position track. May be NULL.
+     *  @param _objPos Object position track. May be nullptr.
+     *  @param _targetObjPos Target object position track. May be nullptr.
      *  @param defaultObjectPos Default object position to be used if
-     *    no animated track is available. May be NULL.
+     *    no animated track is available. May be nullptr.
      *  @param defaultTargetPos Default target position to be used if
-     *    no animated track is available. May be NULL.
+     *    no animated track is available. May be nullptr.
      */
-    KeyIterator(const std::vector<aiVectorKey>* _objPos,
-        const std::vector<aiVectorKey>* _targetObjPos,
-        const aiVector3D*  defaultObjectPos = NULL,
-        const aiVector3D*  defaultTargetPos = NULL);
+    KeyIterator(const std::vector<aiVectorKey> *_objPos,
+            const std::vector<aiVectorKey> *_targetObjPos,
+            const aiVector3D *defaultObjectPos = nullptr,
+            const aiVector3D *defaultTargetPos = nullptr);
 
     // ------------------------------------------------------------------
     /** Returns true if all keys have been processed
      */
-    bool Finished() const
-        {return reachedEnd;}
+    bool Finished() const { return reachedEnd; }
 
     // ------------------------------------------------------------------
     /** Increment the iterator
      */
     void operator++();
-    inline void operator++(int)
-        {return ++(*this);}
-
-
+    inline void operator++(int) { return ++(*this); }
 
     // ------------------------------------------------------------------
     /** Getters to retrieve the current state of the iterator
      */
-    inline const aiVector3D& GetCurPosition() const
-        {return curPosition;}
+    inline const aiVector3D &GetCurPosition() const { return curPosition; }
 
-    inline const aiVector3D& GetCurTargetPosition() const
-        {return curTargetPosition;}
+    inline const aiVector3D &GetCurTargetPosition() const { return curTargetPosition; }
 
-    inline double GetCurTime() const
-        {return curTime;}
+    inline double GetCurTime() const { return curTime; }
 
 private:
-
     //! Did we reach the end?
     bool reachedEnd;
 
@@ -116,10 +103,10 @@ private:
     double curTime;
 
     //! Input tracks and the next key to process
-    const std::vector<aiVectorKey>* objPos,*targetObjPos;
+    const std::vector<aiVectorKey> *objPos, *targetObjPos;
 
     unsigned int nextObjPos, nextTargetObjPos;
-    std::vector<aiVectorKey> defaultObjPos,defaultTargetObjPos;
+    std::vector<aiVectorKey> defaultObjPos, defaultTargetObjPos;
 };
 
 // ---------------------------------------------------------------------------
@@ -130,15 +117,13 @@ private:
  * channel for the camera/spot light itself and a separate position
  * animation channels specifying the position of the camera/spot light
  * look-at target */
-class TargetAnimationHelper
-{
+class TargetAnimationHelper {
 public:
-
-    TargetAnimationHelper()
-        :   targetPositions     (NULL)
-        ,   objectPositions     (NULL)
-    {}
-
+    TargetAnimationHelper() :
+            targetPositions(nullptr),
+            objectPositions(nullptr) {
+        // empty
+    }
 
     // ------------------------------------------------------------------
     /** Sets the target animation channel
@@ -147,37 +132,30 @@ public:
      *  target at a specific position.
      *
      *  @param targetPositions Translation channel*/
-    void SetTargetAnimationChannel (const
-        std::vector<aiVectorKey>* targetPositions);
-
+    void SetTargetAnimationChannel(const std::vector<aiVectorKey> *targetPositions);
 
     // ------------------------------------------------------------------
     /** Sets the main animation channel
      *
      *  @param objectPositions Translation channel */
-    void SetMainAnimationChannel ( const
-        std::vector<aiVectorKey>* objectPositions);
+    void SetMainAnimationChannel(const std::vector<aiVectorKey> *objectPositions);
 
     // ------------------------------------------------------------------
     /** Sets the main animation channel to a fixed value
      *
      *  @param fixed Fixed value for the main animation channel*/
-    void SetFixedMainAnimationChannel(const aiVector3D& fixed);
-
+    void SetFixedMainAnimationChannel(const aiVector3D &fixed);
 
     // ------------------------------------------------------------------
     /** Computes final animation channels
-     * @param distanceTrack Receive camera translation keys ... != NULL. */
-    void Process( std::vector<aiVectorKey>* distanceTrack );
-
+     * @param distanceTrack Receive camera translation keys ... != nullptr. */
+    void Process(std::vector<aiVectorKey> *distanceTrack);
 
 private:
-
-    const std::vector<aiVectorKey>* targetPositions,*objectPositions;
+    const std::vector<aiVectorKey> *targetPositions, *objectPositions;
     aiVector3D fixedMain;
 };
 
-
-} // ! end namespace Assimp
+} // namespace Assimp
 
 #endif // include guard
diff --git a/Engine/lib/assimp/code/Common/Version.cpp b/Engine/lib/assimp/code/Common/Version.cpp
index 5f72fd319..86d3f2220 100644
--- a/Engine/lib/assimp/code/Common/Version.cpp
+++ b/Engine/lib/assimp/code/Common/Version.cpp
@@ -3,8 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -40,48 +39,50 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
 
-// Actually just a dummy, used by the compiler to build the precompiled header.
+// Actually just a dummy, used by the compiler to build the pre-compiled header.
 
-#include <assimp/version.h>
-#include <assimp/scene.h>
 #include "ScenePrivate.h"
+#include <assimp/scene.h>
+#include <assimp/version.h>
 
-static const unsigned int MajorVersion = 5;
-static const unsigned int MinorVersion = 0;
+#include "revision.h"
 
 // --------------------------------------------------------------------------------
 // Legal information string - don't remove this.
-static const char* LEGAL_INFORMATION =
-
-"Open Asset Import Library (Assimp).\n"
-"A free C/C++ library to import various 3D file formats into applications\n\n"
-
-"(c) 2008-2020, assimp team\n"
-"License under the terms and conditions of the 3-clause BSD license\n"
-"https://github.com/assimp/assimp\n"
-;
+static const char *LEGAL_INFORMATION =
+        "Open Asset Import Library (Assimp).\n"
+        "A free C/C++ library to import various 3D file formats into applications\n\n"
+        "(c) 2006-2022, Assimp team\n"
+        "License under the terms and conditions of the 3-clause BSD license\n"
+        "https://www.assimp.org\n";
 
 // ------------------------------------------------------------------------------------------------
 // Get legal string
-ASSIMP_API const char*  aiGetLegalString  ()    {
+ASSIMP_API const char *aiGetLegalString() {
     return LEGAL_INFORMATION;
 }
 
+// ------------------------------------------------------------------------------------------------
+// Get Assimp patch version
+ASSIMP_API unsigned int aiGetVersionPatch() {
+    return VER_PATCH;
+}
+
 // ------------------------------------------------------------------------------------------------
 // Get Assimp minor version
-ASSIMP_API unsigned int aiGetVersionMinor ()    {
-    return MinorVersion;
+ASSIMP_API unsigned int aiGetVersionMinor() {
+    return VER_MINOR;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get Assimp major version
-ASSIMP_API unsigned int aiGetVersionMajor ()    {
-    return MajorVersion;
+ASSIMP_API unsigned int aiGetVersionMajor() {
+    return VER_MAJOR;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get flags used for compilation
-ASSIMP_API unsigned int aiGetCompileFlags ()    {
+ASSIMP_API unsigned int aiGetCompileFlags() {
 
     unsigned int flags = 0;
 
@@ -100,41 +101,42 @@ ASSIMP_API unsigned int aiGetCompileFlags ()    {
 #ifdef _STLPORT_VERSION
     flags |= ASSIMP_CFLAGS_STLPORT;
 #endif
+#ifdef ASSIMP_DOUBLE_PRECISION
+    flags |= ASSIMP_CFLAGS_DOUBLE_SUPPORT;
+#endif
 
     return flags;
 }
 
-// include current build revision, which is even updated from time to time -- :-)
-#include "revision.h"
-
 // ------------------------------------------------------------------------------------------------
 ASSIMP_API unsigned int aiGetVersionRevision() {
     return GitVersion;
 }
 
+// ------------------------------------------------------------------------------------------------
 ASSIMP_API const char *aiGetBranchName() {
     return GitBranch;
 }
 
 // ------------------------------------------------------------------------------------------------
-ASSIMP_API aiScene::aiScene()
-: mFlags(0)
-, mRootNode(nullptr)
-, mNumMeshes(0)
-, mMeshes(nullptr)
-, mNumMaterials(0)
-, mMaterials(nullptr)
-, mNumAnimations(0)
-, mAnimations(nullptr)
-, mNumTextures(0)
-, mTextures(nullptr)
-, mNumLights(0)
-, mLights(nullptr)
-, mNumCameras(0)
-, mCameras(nullptr)
-, mMetaData(nullptr)
-, mPrivate(new Assimp::ScenePrivateData()) {
-	// empty
+ASSIMP_API aiScene::aiScene() :
+        mFlags(0),
+        mRootNode(nullptr),
+        mNumMeshes(0),
+        mMeshes(nullptr),
+        mNumMaterials(0),
+        mMaterials(nullptr),
+        mNumAnimations(0),
+        mAnimations(nullptr),
+        mNumTextures(0),
+        mTextures(nullptr),
+        mNumLights(0),
+        mLights(nullptr),
+        mNumCameras(0),
+        mCameras(nullptr),
+        mMetaData(nullptr),
+        mPrivate(new Assimp::ScenePrivateData()) {
+    // empty
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -146,40 +148,39 @@ ASSIMP_API aiScene::~aiScene() {
     // much better to check whether both mNumXXX and mXXX are
     // valid instead of relying on just one of them.
     if (mNumMeshes && mMeshes)
-        for( unsigned int a = 0; a < mNumMeshes; a++)
+        for (unsigned int a = 0; a < mNumMeshes; a++)
             delete mMeshes[a];
-    delete [] mMeshes;
+    delete[] mMeshes;
 
     if (mNumMaterials && mMaterials) {
-        for (unsigned int a = 0; a < mNumMaterials; ++a ) {
-            delete mMaterials[ a ];
+        for (unsigned int a = 0; a < mNumMaterials; ++a) {
+            delete mMaterials[a];
         }
     }
-    delete [] mMaterials;
+    delete[] mMaterials;
 
     if (mNumAnimations && mAnimations)
-        for( unsigned int a = 0; a < mNumAnimations; a++)
+        for (unsigned int a = 0; a < mNumAnimations; a++)
             delete mAnimations[a];
-    delete [] mAnimations;
+    delete[] mAnimations;
 
     if (mNumTextures && mTextures)
-        for( unsigned int a = 0; a < mNumTextures; a++)
+        for (unsigned int a = 0; a < mNumTextures; a++)
             delete mTextures[a];
-    delete [] mTextures;
+    delete[] mTextures;
 
     if (mNumLights && mLights)
-        for( unsigned int a = 0; a < mNumLights; a++)
+        for (unsigned int a = 0; a < mNumLights; a++)
             delete mLights[a];
-    delete [] mLights;
+    delete[] mLights;
 
     if (mNumCameras && mCameras)
-        for( unsigned int a = 0; a < mNumCameras; a++)
+        for (unsigned int a = 0; a < mNumCameras; a++)
             delete mCameras[a];
-    delete [] mCameras;
+    delete[] mCameras;
 
     aiMetadata::Dealloc(mMetaData);
     mMetaData = nullptr;
 
-    delete static_cast<Assimp::ScenePrivateData*>( mPrivate );
+    delete static_cast<Assimp::ScenePrivateData *>(mPrivate);
 }
-
diff --git a/Engine/lib/assimp/code/Common/VertexTriangleAdjacency.cpp b/Engine/lib/assimp/code/Common/VertexTriangleAdjacency.cpp
index 7cfd1a350..555e3e386 100644
--- a/Engine/lib/assimp/code/Common/VertexTriangleAdjacency.cpp
+++ b/Engine/lib/assimp/code/Common/VertexTriangleAdjacency.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -52,46 +52,44 @@ using namespace Assimp;
 
 // ------------------------------------------------------------------------------------------------
 VertexTriangleAdjacency::VertexTriangleAdjacency(aiFace *pcFaces,
-    unsigned int iNumFaces,
-    unsigned int iNumVertices /*= 0*/,
-    bool bComputeNumTriangles /*= false*/)
-{
+        unsigned int iNumFaces,
+        unsigned int iNumVertices /*= 0*/,
+        bool bComputeNumTriangles /*= false*/) {
     // compute the number of referenced vertices if it wasn't specified by the caller
-    const aiFace* const pcFaceEnd = pcFaces + iNumFaces;
-    if (!iNumVertices)  {
-        for (aiFace* pcFace = pcFaces; pcFace != pcFaceEnd; ++pcFace)   {
-            ai_assert( nullptr != pcFace );
+    const aiFace *const pcFaceEnd = pcFaces + iNumFaces;
+    if (0 == iNumVertices) {
+        for (aiFace *pcFace = pcFaces; pcFace != pcFaceEnd; ++pcFace) {
+            ai_assert(nullptr != pcFace);
             ai_assert(3 == pcFace->mNumIndices);
-            iNumVertices = std::max(iNumVertices,pcFace->mIndices[0]);
-            iNumVertices = std::max(iNumVertices,pcFace->mIndices[1]);
-            iNumVertices = std::max(iNumVertices,pcFace->mIndices[2]);
+            iNumVertices = std::max(iNumVertices, pcFace->mIndices[0]);
+            iNumVertices = std::max(iNumVertices, pcFace->mIndices[1]);
+            iNumVertices = std::max(iNumVertices, pcFace->mIndices[2]);
         }
     }
 
-    mNumVertices = iNumVertices;
+    mNumVertices = iNumVertices + 1;
 
-    unsigned int* pi;
+    unsigned int *pi;
 
     // allocate storage
-    if (bComputeNumTriangles)   {
-        pi = mLiveTriangles = new unsigned int[iNumVertices+1];
-        ::memset(mLiveTriangles,0,sizeof(unsigned int)*(iNumVertices+1));
-        mOffsetTable = new unsigned int[iNumVertices+2]+1;
+    if (bComputeNumTriangles) {
+        pi = mLiveTriangles = new unsigned int[iNumVertices + 1];
+        ::memset(mLiveTriangles, 0, sizeof(unsigned int) * (iNumVertices + 1));
+        mOffsetTable = new unsigned int[iNumVertices + 2] + 1;
     } else {
-        pi = mOffsetTable = new unsigned int[iNumVertices+2]+1;
-        ::memset(mOffsetTable,0,sizeof(unsigned int)*(iNumVertices+1));
-        mLiveTriangles = NULL; // important, otherwise the d'tor would crash
+        pi = mOffsetTable = new unsigned int[iNumVertices + 2] + 1;
+        ::memset(mOffsetTable, 0, sizeof(unsigned int) * (iNumVertices + 1));
+        mLiveTriangles = nullptr; // important, otherwise the d'tor would crash
     }
 
     // get a pointer to the end of the buffer
-    unsigned int* piEnd = pi+iNumVertices;
+    unsigned int *piEnd = pi + iNumVertices;
     *piEnd++ = 0u;
 
     // first pass: compute the number of faces referencing each vertex
-    for (aiFace* pcFace = pcFaces; pcFace != pcFaceEnd; ++pcFace)
-    {
+    for (aiFace *pcFace = pcFaces; pcFace != pcFaceEnd; ++pcFace) {
         unsigned nind = pcFace->mNumIndices;
-        unsigned * ind = pcFace->mIndices;
+        unsigned *ind = pcFace->mIndices;
         if (nind > 0) pi[ind[0]]++;
         if (nind > 1) pi[ind[1]]++;
         if (nind > 2) pi[ind[2]]++;
@@ -99,8 +97,8 @@ VertexTriangleAdjacency::VertexTriangleAdjacency(aiFace *pcFaces,
 
     // second pass: compute the final offset table
     unsigned int iSum = 0;
-    unsigned int* piCurOut = this->mOffsetTable;
-    for (unsigned int* piCur = pi; piCur != piEnd;++piCur,++piCurOut)   {
+    unsigned int *piCurOut = this->mOffsetTable;
+    for (unsigned int *piCur = pi; piCur != piEnd; ++piCur, ++piCurOut) {
 
         unsigned int iLastSum = iSum;
         iSum += *piCur;
@@ -111,9 +109,9 @@ VertexTriangleAdjacency::VertexTriangleAdjacency(aiFace *pcFaces,
     // third pass: compute the final table
     this->mAdjacencyTable = new unsigned int[iSum];
     iSum = 0;
-    for (aiFace* pcFace = pcFaces; pcFace != pcFaceEnd; ++pcFace,++iSum)    {
+    for (aiFace *pcFace = pcFaces; pcFace != pcFaceEnd; ++pcFace, ++iSum) {
         unsigned nind = pcFace->mNumIndices;
-        unsigned * ind = pcFace->mIndices;
+        unsigned *ind = pcFace->mIndices;
 
         if (nind > 0) mAdjacencyTable[pi[ind[0]]++] = iSum;
         if (nind > 1) mAdjacencyTable[pi[ind[1]]++] = iSum;
@@ -125,8 +123,7 @@ VertexTriangleAdjacency::VertexTriangleAdjacency(aiFace *pcFaces,
     *mOffsetTable = 0u;
 }
 // ------------------------------------------------------------------------------------------------
-VertexTriangleAdjacency::~VertexTriangleAdjacency()
-{
+VertexTriangleAdjacency::~VertexTriangleAdjacency() {
     // delete allocated storage
     delete[] mOffsetTable;
     delete[] mAdjacencyTable;
diff --git a/Engine/lib/assimp/code/Common/VertexTriangleAdjacency.h b/Engine/lib/assimp/code/Common/VertexTriangleAdjacency.h
index f3be47612..41d809450 100644
--- a/Engine/lib/assimp/code/Common/VertexTriangleAdjacency.h
+++ b/Engine/lib/assimp/code/Common/VertexTriangleAdjacency.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Common/Win32DebugLogStream.h b/Engine/lib/assimp/code/Common/Win32DebugLogStream.h
index a6063a261..34d849e83 100644
--- a/Engine/lib/assimp/code/Common/Win32DebugLogStream.h
+++ b/Engine/lib/assimp/code/Common/Win32DebugLogStream.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -71,19 +71,19 @@ public:
 };
 
 // ---------------------------------------------------------------------------
-inline 
-Win32DebugLogStream::Win32DebugLogStream(){ 
+inline
+Win32DebugLogStream::Win32DebugLogStream(){
     // empty
 }
 
 // ---------------------------------------------------------------------------
-inline 
+inline
 Win32DebugLogStream::~Win32DebugLogStream(){
     // empty
 }
 
 // ---------------------------------------------------------------------------
-inline 
+inline
 void Win32DebugLogStream::write(const char* message) {
     ::OutputDebugStringA( message);
 }
diff --git a/Engine/lib/assimp/code/Common/ZipArchiveIOSystem.cpp b/Engine/lib/assimp/code/Common/ZipArchiveIOSystem.cpp
index 7c37a05f9..e0c9883d2 100644
--- a/Engine/lib/assimp/code/Common/ZipArchiveIOSystem.cpp
+++ b/Engine/lib/assimp/code/Common/ZipArchiveIOSystem.cpp
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -44,8 +43,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Zip File I/O implementation for #Importer
  */
 
-#include <assimp/ZipArchiveIOSystem.h>
 #include <assimp/BaseImporter.h>
+#include <assimp/ZipArchiveIOSystem.h>
 
 #include <assimp/ai_assert.h>
 
@@ -53,70 +52,118 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <memory>
 
 #ifdef ASSIMP_USE_HUNTER
-#  include <minizip/unzip.h>
+#    include <minizip/unzip.h>
 #else
-#  include <unzip.h>
+#    include <unzip.h>
 #endif
 
 namespace Assimp {
-    // ----------------------------------------------------------------
-    // Wraps an existing Assimp::IOSystem for unzip
-    class IOSystem2Unzip {
-    public:
-        static voidpf open(voidpf opaque, const char* filename, int mode);
-        static uLong read(voidpf opaque, voidpf stream, void* buf, uLong size);
-        static uLong write(voidpf opaque, voidpf stream, const void* buf, uLong size);
-        static long tell(voidpf opaque, voidpf stream);
-        static long seek(voidpf opaque, voidpf stream, uLong offset, int origin);
-        static int close(voidpf opaque, voidpf stream);
-        static int testerror(voidpf opaque, voidpf stream);
-        static zlib_filefunc_def get(IOSystem* pIOHandler);
-    };
 
-    voidpf IOSystem2Unzip::open(voidpf opaque, const char* filename, int mode) {
-        IOSystem* io_system = reinterpret_cast<IOSystem*>(opaque);
+// ----------------------------------------------------------------
+// A read-only file inside a ZIP
 
-        const char* mode_fopen = nullptr;
-        if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER) == ZLIB_FILEFUNC_MODE_READ) {
-            mode_fopen = "rb";
-        }
-        else {
-            if (mode & ZLIB_FILEFUNC_MODE_EXISTING) {
-                mode_fopen = "r+b";
-            }
-            else {
-                if (mode & ZLIB_FILEFUNC_MODE_CREATE) {
-                    mode_fopen = "wb";
-                }
+class ZipFile : public IOStream {
+    friend class ZipFileInfo;
+    explicit ZipFile(std::string &filename, size_t size);
+
+public:
+    std::string m_Filename;
+    virtual ~ZipFile();
+
+    // IOStream interface
+    size_t Read(void *pvBuffer, size_t pSize, size_t pCount) override;
+    size_t Write(const void * /*pvBuffer*/, size_t /*pSize*/, size_t /*pCount*/) override { return 0; }
+    size_t FileSize() const override;
+    aiReturn Seek(size_t pOffset, aiOrigin pOrigin) override;
+    size_t Tell() const override;
+    void Flush() override {}
+
+private:
+    size_t m_Size = 0;
+    size_t m_SeekPtr = 0;
+    std::unique_ptr<uint8_t[]> m_Buffer;
+};
+
+
+// ----------------------------------------------------------------
+// Wraps an existing Assimp::IOSystem for unzip
+class IOSystem2Unzip {
+public:
+    static voidpf open(voidpf opaque, const char *filename, int mode);
+    static voidpf opendisk(voidpf opaque, voidpf stream, uint32_t number_disk, int mode);
+    static uLong read(voidpf opaque, voidpf stream, void *buf, uLong size);
+    static uLong write(voidpf opaque, voidpf stream, const void *buf, uLong size);
+    static long tell(voidpf opaque, voidpf stream);
+    static long seek(voidpf opaque, voidpf stream, uLong offset, int origin);
+    static int close(voidpf opaque, voidpf stream);
+    static int testerror(voidpf opaque, voidpf stream);
+    static zlib_filefunc_def get(IOSystem *pIOHandler);
+};
+
+voidpf IOSystem2Unzip::open(voidpf opaque, const char *filename, int mode) {
+    IOSystem *io_system = reinterpret_cast<IOSystem *>(opaque);
+
+    const char *mode_fopen = nullptr;
+    if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER) == ZLIB_FILEFUNC_MODE_READ) {
+        mode_fopen = "rb";
+    } else {
+        if (mode & ZLIB_FILEFUNC_MODE_EXISTING) {
+            mode_fopen = "r+b";
+        } else {
+            if (mode & ZLIB_FILEFUNC_MODE_CREATE) {
+                mode_fopen = "wb";
             }
         }
-
-        return (voidpf)io_system->Open(filename, mode_fopen);
     }
 
-    uLong IOSystem2Unzip::read(voidpf /*opaque*/, voidpf stream, void* buf, uLong size) {
-        IOStream* io_stream = (IOStream*)stream;
+    return (voidpf)io_system->Open(filename, mode_fopen);
+}
 
-        return static_cast<uLong>(io_stream->Read(buf, 1, size));
+voidpf IOSystem2Unzip::opendisk(voidpf opaque, voidpf stream, uint32_t number_disk, int mode) {
+    ZipFile *io_stream = (ZipFile *)stream;
+    voidpf ret = NULL;
+    int i;
+
+    char *disk_filename = (char*)malloc(io_stream->m_Filename.length() + 1);
+    strncpy(disk_filename, io_stream->m_Filename.c_str(), io_stream->m_Filename.length() + 1);
+    for (i = (int)io_stream->m_Filename.length() - 1; i >= 0; i -= 1)
+    {
+        if (disk_filename[i] != '.')
+            continue;
+        snprintf(&disk_filename[i], io_stream->m_Filename.length() - size_t(i), ".z%02u", number_disk + 1);
+        break;
     }
 
-    uLong IOSystem2Unzip::write(voidpf /*opaque*/, voidpf stream, const void* buf, uLong size) {
-        IOStream* io_stream = (IOStream*)stream;
+    if (i >= 0)
+        ret = open(opaque, disk_filename, mode);
 
-        return static_cast<uLong>(io_stream->Write(buf, 1, size));
-    }
+    free(disk_filename);
+    return ret;
+}
 
-    long IOSystem2Unzip::tell(voidpf /*opaque*/, voidpf stream) {
-        IOStream* io_stream = (IOStream*)stream;
+uLong IOSystem2Unzip::read(voidpf /*opaque*/, voidpf stream, void *buf, uLong size) {
+    IOStream *io_stream = (IOStream *)stream;
 
-        return static_cast<long>(io_stream->Tell());
-    }
+    return static_cast<uLong>(io_stream->Read(buf, 1, size));
+}
 
-    long IOSystem2Unzip::seek(voidpf /*opaque*/, voidpf stream, uLong offset, int origin) {
-        IOStream* io_stream = (IOStream*)stream;
+uLong IOSystem2Unzip::write(voidpf /*opaque*/, voidpf stream, const void *buf, uLong size) {
+    IOStream *io_stream = (IOStream *)stream;
 
-        aiOrigin assimp_origin;
-        switch (origin) {
+    return static_cast<uLong>(io_stream->Write(buf, 1, size));
+}
+
+long IOSystem2Unzip::tell(voidpf /*opaque*/, voidpf stream) {
+    IOStream *io_stream = (IOStream *)stream;
+
+    return static_cast<long>(io_stream->Tell());
+}
+
+long IOSystem2Unzip::seek(voidpf /*opaque*/, voidpf stream, uLong offset, int origin) {
+    IOStream *io_stream = (IOStream *)stream;
+
+    aiOrigin assimp_origin;
+    switch (origin) {
         default:
         case ZLIB_FILEFUNC_SEEK_CUR:
             assimp_origin = aiOrigin_CUR;
@@ -127,157 +174,142 @@ namespace Assimp {
         case ZLIB_FILEFUNC_SEEK_SET:
             assimp_origin = aiOrigin_SET;
             break;
+    }
+
+    return (io_stream->Seek(offset, assimp_origin) == aiReturn_SUCCESS ? 0 : -1);
+}
+
+int IOSystem2Unzip::close(voidpf opaque, voidpf stream) {
+    IOSystem *io_system = (IOSystem *)opaque;
+    IOStream *io_stream = (IOStream *)stream;
+
+    io_system->Close(io_stream);
+
+    return 0;
+}
+
+int IOSystem2Unzip::testerror(voidpf /*opaque*/, voidpf /*stream*/) {
+    return 0;
+}
+
+zlib_filefunc_def IOSystem2Unzip::get(IOSystem *pIOHandler) {
+    zlib_filefunc_def mapping;
+
+    mapping.zopen_file = (open_file_func)open;
+    mapping.zopendisk_file = (opendisk_file_func)opendisk;
+    mapping.zread_file = (read_file_func)read;
+    mapping.zwrite_file = (write_file_func)write;
+    mapping.ztell_file = (tell_file_func)tell;
+    mapping.zseek_file = (seek_file_func)seek;
+    mapping.zclose_file = (close_file_func)close;
+    mapping.zerror_file = testerror;
+
+    mapping.opaque = reinterpret_cast<voidpf>(pIOHandler);
+
+    return mapping;
+}
+
+// ----------------------------------------------------------------
+// Info about a read-only file inside a ZIP
+class ZipFileInfo {
+public:
+    explicit ZipFileInfo(unzFile zip_handle, size_t size);
+
+    // Allocate and Extract data from the ZIP
+    ZipFile *Extract(std::string &filename, unzFile zip_handle) const;
+
+private:
+    size_t m_Size = 0;
+    unz_file_pos_s m_ZipFilePos;
+};
+
+ZipFileInfo::ZipFileInfo(unzFile zip_handle, size_t size) :
+        m_Size(size) {
+    ai_assert(m_Size != 0);
+    // Workaround for MSVC 2013 - C2797
+    m_ZipFilePos.num_of_file = 0;
+    m_ZipFilePos.pos_in_zip_directory = 0;
+    unzGetFilePos(zip_handle, &(m_ZipFilePos));
+}
+
+ZipFile *ZipFileInfo::Extract(std::string &filename, unzFile zip_handle) const {
+    // Find in the ZIP. This cannot fail
+    unz_file_pos_s *filepos = const_cast<unz_file_pos_s *>(&(m_ZipFilePos));
+    if (unzGoToFilePos(zip_handle, filepos) != UNZ_OK)
+        return nullptr;
+
+    if (unzOpenCurrentFile(zip_handle) != UNZ_OK)
+        return nullptr;
+
+    ZipFile *zip_file = new ZipFile(filename, m_Size);
+
+    // Unzip has a limit of UINT16_MAX bytes buffer
+    uint16_t unzipBufferSize = zip_file->m_Size <= UINT16_MAX ? static_cast<uint16_t>(zip_file->m_Size) : UINT16_MAX;
+    std::unique_ptr<uint8_t[]> unzipBuffer = std::unique_ptr<uint8_t[]>(new uint8_t[unzipBufferSize]);
+    size_t readCount = 0;
+    while (readCount < zip_file->m_Size)
+    {
+        size_t bufferSize = zip_file->m_Size - readCount;
+        if (bufferSize > UINT16_MAX) {
+            bufferSize = UINT16_MAX;
         }
 
-        return (io_stream->Seek(offset, assimp_origin) == aiReturn_SUCCESS ? 0 : -1);
-    }
-
-    int IOSystem2Unzip::close(voidpf opaque, voidpf stream) {
-        IOSystem* io_system = (IOSystem*)opaque;
-        IOStream* io_stream = (IOStream*)stream;
-
-        io_system->Close(io_stream);
-
-        return 0;
-    }
-
-    int IOSystem2Unzip::testerror(voidpf /*opaque*/, voidpf /*stream*/) {
-        return 0;
-    }
-
-    zlib_filefunc_def IOSystem2Unzip::get(IOSystem* pIOHandler) {
-        zlib_filefunc_def mapping;
-
-#ifdef ASSIMP_USE_HUNTER
-        mapping.zopen_file = (open_file_func)open;
-        mapping.zread_file = (read_file_func)read;
-        mapping.zwrite_file = (write_file_func)write;
-        mapping.ztell_file = (tell_file_func)tell;
-        mapping.zseek_file = (seek_file_func)seek;
-        mapping.zclose_file = (close_file_func)close;
-        mapping.zerror_file = (error_file_func)testerror;
-#else
-        mapping.zopen_file = open;
-        mapping.zread_file = read;
-        mapping.zwrite_file = write;
-        mapping.ztell_file = tell;
-        mapping.zseek_file = seek;
-        mapping.zclose_file = close;
-        mapping.zerror_file = testerror;
-#endif
-        mapping.opaque = reinterpret_cast<voidpf>(pIOHandler);
-
-        return mapping;
-    }
-
-    // ----------------------------------------------------------------
-    // A read-only file inside a ZIP
-
-    class ZipFile : public IOStream {
-        friend class ZipFileInfo;
-        explicit ZipFile(size_t size);
-    public:
-        virtual ~ZipFile();
-
-        // IOStream interface
-        size_t Read(void* pvBuffer, size_t pSize, size_t pCount) override;
-        size_t Write(const void* /*pvBuffer*/, size_t /*pSize*/, size_t /*pCount*/) override { return 0; }
-        size_t FileSize() const override;
-        aiReturn Seek(size_t pOffset, aiOrigin pOrigin) override;
-        size_t Tell() const override;
-        void Flush() override {}
-
-    private:
-        size_t m_Size = 0;
-        size_t m_SeekPtr = 0;
-        std::unique_ptr<uint8_t[]> m_Buffer;
-    };
-
-
-    // ----------------------------------------------------------------
-    // Info about a read-only file inside a ZIP
-    class ZipFileInfo
-    {
-    public:
-        explicit ZipFileInfo(unzFile zip_handle, size_t size);
-
-        // Allocate and Extract data from the ZIP
-        ZipFile * Extract(unzFile zip_handle) const;
-
-    private:
-        size_t m_Size = 0;
-        unz_file_pos_s m_ZipFilePos;
-    };
-
-    ZipFileInfo::ZipFileInfo(unzFile zip_handle, size_t size)
-        : m_Size(size) {
-        ai_assert(m_Size != 0);
-        // Workaround for MSVC 2013 - C2797
-        m_ZipFilePos.num_of_file = 0;
-        m_ZipFilePos.pos_in_zip_directory = 0;
-        unzGetFilePos(zip_handle, &(m_ZipFilePos));
-    }
-
-    ZipFile * ZipFileInfo::Extract(unzFile zip_handle) const {
-        // Find in the ZIP. This cannot fail
-        unz_file_pos_s *filepos = const_cast<unz_file_pos_s*>(&(m_ZipFilePos));
-        if (unzGoToFilePos(zip_handle, filepos) != UNZ_OK)
-            return nullptr;
-
-        if (unzOpenCurrentFile(zip_handle) != UNZ_OK)
-            return nullptr;
-
-        ZipFile *zip_file = new ZipFile(m_Size);
-
-        if (unzReadCurrentFile(zip_handle, zip_file->m_Buffer.get(), static_cast<unsigned int>(m_Size)) != static_cast<int>(m_Size))
+        int ret = unzReadCurrentFile(zip_handle, unzipBuffer.get(), static_cast<unsigned int>(bufferSize));
+        if (ret != static_cast<int>(bufferSize))
         {
             // Failed, release the memory
             delete zip_file;
             zip_file = nullptr;
+            break;
         }
 
-        ai_assert(unzCloseCurrentFile(zip_handle) == UNZ_OK);
-        return zip_file;
+        std::memcpy(zip_file->m_Buffer.get() + readCount, unzipBuffer.get(), ret);
+        readCount += ret;
     }
 
-    ZipFile::ZipFile(size_t size)
-        : m_Size(size) {
-        ai_assert(m_Size != 0);
-        m_Buffer = std::unique_ptr<uint8_t[]>(new uint8_t[m_Size]);
-    }
+    ai_assert(unzCloseCurrentFile(zip_handle) == UNZ_OK);
+    return zip_file;
+}
 
-    ZipFile::~ZipFile() {
-    }
+ZipFile::ZipFile(std::string &filename, size_t size) :
+        m_Filename(filename), m_Size(size) {
+    ai_assert(m_Size != 0);
+    m_Buffer = std::unique_ptr<uint8_t[]>(new uint8_t[m_Size]);
+}
 
-    size_t ZipFile::Read(void* pvBuffer, size_t pSize, size_t pCount) {
-        // Should be impossible
-        ai_assert(m_Buffer != nullptr);
-        ai_assert(NULL != pvBuffer && 0 != pSize && 0 != pCount);
+ZipFile::~ZipFile() {
+}
 
-        // Clip down to file size
-        size_t byteSize = pSize * pCount;
-        if ((byteSize + m_SeekPtr) > m_Size)
-        {
-            pCount = (m_Size - m_SeekPtr) / pSize;
-            byteSize = pSize * pCount;
-            if (byteSize == 0)
-                return 0;
+size_t ZipFile::Read(void *pvBuffer, size_t pSize, size_t pCount) {
+    // Should be impossible
+    ai_assert(m_Buffer != nullptr);
+    ai_assert(nullptr != pvBuffer);
+    ai_assert(0 != pSize);
+    ai_assert(0 != pCount);
+
+    // Clip down to file size
+    size_t byteSize = pSize * pCount;
+    if ((byteSize + m_SeekPtr) > m_Size) {
+        pCount = (m_Size - m_SeekPtr) / pSize;
+        byteSize = pSize * pCount;
+        if (byteSize == 0) {
+            return 0;
         }
-
-        std::memcpy(pvBuffer, m_Buffer.get() + m_SeekPtr, byteSize);
-
-        m_SeekPtr += byteSize;
-
-        return pCount;
     }
 
-    size_t ZipFile::FileSize() const {
-        return m_Size;
-    }
+    std::memcpy(pvBuffer, m_Buffer.get() + m_SeekPtr, byteSize);
 
-    aiReturn ZipFile::Seek(size_t pOffset, aiOrigin pOrigin) {
-        switch (pOrigin)
-        {
+    m_SeekPtr += byteSize;
+
+    return pCount;
+}
+
+size_t ZipFile::FileSize() const {
+    return m_Size;
+}
+
+aiReturn ZipFile::Seek(size_t pOffset, aiOrigin pOrigin) {
+    switch (pOrigin) {
         case aiOrigin_SET: {
             if (pOffset > m_Size) return aiReturn_FAILURE;
             m_SeekPtr = pOffset;
@@ -296,244 +328,236 @@ namespace Assimp {
             return aiReturn_SUCCESS;
         }
         default:;
-        }
-
-        return aiReturn_FAILURE;
-    }
-
-    size_t ZipFile::Tell() const {
-        return m_SeekPtr;
-    }
-
-    // ----------------------------------------------------------------
-    // pImpl of the Zip Archive IO
-    class ZipArchiveIOSystem::Implement {
-    public:
-        static const unsigned int FileNameSize = 256;
-
-        Implement(IOSystem* pIOHandler, const char* pFilename, const char* pMode);
-        ~Implement();
-
-        bool isOpen() const;
-        void getFileList(std::vector<std::string>& rFileList);
-        void getFileListExtension(std::vector<std::string>& rFileList, const std::string& extension);
-        bool Exists(std::string& filename);
-        IOStream* OpenFile(std::string& filename);
-
-        static void SimplifyFilename(std::string& filename);
-
-    private:
-        void MapArchive();
-
-    private:
-        typedef std::map<std::string, ZipFileInfo> ZipFileInfoMap;
-
-        unzFile m_ZipFileHandle = nullptr;
-        ZipFileInfoMap m_ArchiveMap;
-    };
-
-    ZipArchiveIOSystem::Implement::Implement(IOSystem* pIOHandler, const char* pFilename, const char* pMode) {
-        ai_assert(strcmp(pMode, "r") == 0);
-        ai_assert(pFilename != nullptr);
-        if (pFilename[0] == 0)
-            return;
-
-        zlib_filefunc_def mapping = IOSystem2Unzip::get(pIOHandler);
-        m_ZipFileHandle = unzOpen2(pFilename, &mapping);
-    }
-
-    ZipArchiveIOSystem::Implement::~Implement() {
-        m_ArchiveMap.clear();
-
-        if (m_ZipFileHandle != nullptr) {
-            unzClose(m_ZipFileHandle);
-            m_ZipFileHandle = nullptr;
-        }
-    }
-
-    void ZipArchiveIOSystem::Implement::MapArchive() {
-        if (m_ZipFileHandle == nullptr)
-            return;
-
-        if (!m_ArchiveMap.empty())
-            return;
-
-        //  At first ensure file is already open
-        if (unzGoToFirstFile(m_ZipFileHandle) != UNZ_OK)
-            return;
-
-        // Loop over all files
-        do {
-            char filename[FileNameSize];
-            unz_file_info fileInfo;
-
-            if (unzGetCurrentFileInfo(m_ZipFileHandle, &fileInfo, filename, FileNameSize, nullptr, 0, nullptr, 0) == UNZ_OK) {
-                if (fileInfo.uncompressed_size != 0) {
-                    std::string filename_string(filename, fileInfo.size_filename);
-                    SimplifyFilename(filename_string);
-                    m_ArchiveMap.emplace(filename_string, ZipFileInfo(m_ZipFileHandle, fileInfo.uncompressed_size));
-                }
-            }
-        } while (unzGoToNextFile(m_ZipFileHandle) != UNZ_END_OF_LIST_OF_FILE);
-    }
-
-    bool ZipArchiveIOSystem::Implement::isOpen() const {
-        return (m_ZipFileHandle != nullptr);
-    }
-
-    void ZipArchiveIOSystem::Implement::getFileList(std::vector<std::string>& rFileList) {
-        MapArchive();
-        rFileList.clear();
-
-        for (const auto &file : m_ArchiveMap) {
-            rFileList.push_back(file.first);
-        }
-    }
-
-    void ZipArchiveIOSystem::Implement::getFileListExtension(std::vector<std::string>& rFileList, const std::string& extension) {
-        MapArchive();
-        rFileList.clear();
-
-        for (const auto &file : m_ArchiveMap) {
-            if (extension == BaseImporter::GetExtension(file.first))
-                rFileList.push_back(file.first);
-        }
-    }
-
-    bool ZipArchiveIOSystem::Implement::Exists(std::string& filename) {
-        MapArchive();
-
-        ZipFileInfoMap::const_iterator it = m_ArchiveMap.find(filename);
-        return (it != m_ArchiveMap.end());
-    }
-
-    IOStream * ZipArchiveIOSystem::Implement::OpenFile(std::string& filename) {
-        MapArchive();
-
-        SimplifyFilename(filename);
-
-        // Find in the map
-        ZipFileInfoMap::const_iterator zip_it = m_ArchiveMap.find(filename);
-        if (zip_it == m_ArchiveMap.cend())
-            return nullptr;
-
-        const ZipFileInfo &zip_file = (*zip_it).second;
-        return zip_file.Extract(m_ZipFileHandle);
-    }
-
-    inline void ReplaceAll(std::string& data, const std::string& before, const std::string& after) {
-        size_t pos = data.find(before);
-        while (pos != std::string::npos)
-        {
-            data.replace(pos, before.size(), after);
-            pos = data.find(before, pos + after.size());
-        }
-    }
-
-    inline void ReplaceAllChar(std::string& data, const char before, const char after) {
-        size_t pos = data.find(before);
-        while (pos != std::string::npos)
-        {
-            data[pos] = after;
-            pos = data.find(before, pos + 1);
-        }
-    }
-
-    void ZipArchiveIOSystem::Implement::SimplifyFilename(std::string& filename)
-    {
-        ReplaceAllChar(filename, '\\', '/');
-
-        // Remove all . and / from the beginning of the path
-        size_t pos = filename.find_first_not_of("./");
-        if (pos != 0)
-            filename.erase(0, pos);
-
-        // Simplify "my/folder/../file.png" constructions, if any
-        static const std::string relative("/../");
-        const size_t relsize = relative.size() - 1;
-        pos = filename.find(relative);
-        while (pos != std::string::npos)
-        {
-            // Previous slash
-            size_t prevpos = filename.rfind('/', pos - 1);
-            if (prevpos == pos)
-                filename.erase(0, pos + relative.size());
-            else
-                filename.erase(prevpos, pos + relsize - prevpos);
-
-            pos = filename.find(relative);
-        }
-    }
-
-    ZipArchiveIOSystem::ZipArchiveIOSystem(IOSystem* pIOHandler, const char* pFilename, const char* pMode)
-        : pImpl(new Implement(pIOHandler, pFilename, pMode)) {
-    }
-
-    // ----------------------------------------------------------------
-    // The ZipArchiveIO
-    ZipArchiveIOSystem::ZipArchiveIOSystem(IOSystem* pIOHandler, const std::string& rFilename, const char* pMode)
-        : pImpl(new Implement(pIOHandler, rFilename.c_str(), pMode))
-    {
-    }
-
-    ZipArchiveIOSystem::~ZipArchiveIOSystem() {
-        delete pImpl;
-    }
-
-    bool ZipArchiveIOSystem::Exists(const char* pFilename) const {
-        ai_assert(pFilename != nullptr);
-
-        if (pFilename == nullptr) {
-            return false;
-        }
-
-        std::string filename(pFilename);
-        return pImpl->Exists(filename);
-    }
-
-    // This is always '/' in a ZIP
-    char ZipArchiveIOSystem::getOsSeparator() const {
-        return '/';
-    }
-
-    // Only supports Reading
-    IOStream * ZipArchiveIOSystem::Open(const char* pFilename, const char* pMode) {
-        ai_assert(pFilename != nullptr);
-
-        for (size_t i = 0; pMode[i] != 0; ++i)
-        {
-            ai_assert(pMode[i] != 'w');
-            if (pMode[i] == 'w')
-                return nullptr;
-        }
-
-        std::string filename(pFilename);
-        return pImpl->OpenFile(filename);
-    }
-
-    void ZipArchiveIOSystem::Close(IOStream* pFile) {
-        delete pFile;
-    }
-
-    bool ZipArchiveIOSystem::isOpen() const {
-        return (pImpl->isOpen());
-    }
-
-    void ZipArchiveIOSystem::getFileList(std::vector<std::string>& rFileList) const {
-        return pImpl->getFileList(rFileList);
-    }
-
-    void ZipArchiveIOSystem::getFileListExtension(std::vector<std::string>& rFileList, const std::string& extension) const {
-        return pImpl->getFileListExtension(rFileList, extension);
-    }
-
-    bool ZipArchiveIOSystem::isZipArchive(IOSystem* pIOHandler, const char* pFilename) {
-        Implement tmp(pIOHandler, pFilename, "r");
-        return tmp.isOpen();
-    }
-
-    bool ZipArchiveIOSystem::isZipArchive(IOSystem* pIOHandler, const std::string& rFilename) {
-        return isZipArchive(pIOHandler, rFilename.c_str());
     }
 
+    return aiReturn_FAILURE;
 }
+
+size_t ZipFile::Tell() const {
+    return m_SeekPtr;
+}
+
+// ----------------------------------------------------------------
+// pImpl of the Zip Archive IO
+class ZipArchiveIOSystem::Implement {
+public:
+    static const unsigned int FileNameSize = 256;
+
+    Implement(IOSystem *pIOHandler, const char *pFilename, const char *pMode);
+    ~Implement();
+
+    bool isOpen() const;
+    void getFileList(std::vector<std::string> &rFileList);
+    void getFileListExtension(std::vector<std::string> &rFileList, const std::string &extension);
+    bool Exists(std::string &filename);
+    IOStream *OpenFile(std::string &filename);
+
+    static void SimplifyFilename(std::string &filename);
+
+private:
+    void MapArchive();
+
+private:
+    typedef std::map<std::string, ZipFileInfo> ZipFileInfoMap;
+
+    unzFile m_ZipFileHandle = nullptr;
+    ZipFileInfoMap m_ArchiveMap;
+};
+
+ZipArchiveIOSystem::Implement::Implement(IOSystem *pIOHandler, const char *pFilename, const char *pMode) {
+    ai_assert(strcmp(pMode, "r") == 0);
+    ai_assert(pFilename != nullptr);
+    if (pFilename[0] == 0 || nullptr == pMode) {
+        return;
+    }
+
+    zlib_filefunc_def mapping = IOSystem2Unzip::get(pIOHandler);
+    m_ZipFileHandle = unzOpen2(pFilename, &mapping);
+}
+
+ZipArchiveIOSystem::Implement::~Implement() {
+    if (m_ZipFileHandle != nullptr) {
+        unzClose(m_ZipFileHandle);
+    }
+}
+
+void ZipArchiveIOSystem::Implement::MapArchive() {
+    if (m_ZipFileHandle == nullptr)
+        return;
+
+    if (!m_ArchiveMap.empty())
+        return;
+
+    //  At first ensure file is already open
+    if (unzGoToFirstFile(m_ZipFileHandle) != UNZ_OK)
+        return;
+
+    // Loop over all files
+    do {
+        char filename[FileNameSize];
+        unz_file_info fileInfo;
+
+        if (unzGetCurrentFileInfo(m_ZipFileHandle, &fileInfo, filename, FileNameSize, nullptr, 0, nullptr, 0) == UNZ_OK) {
+            if (fileInfo.uncompressed_size != 0 && fileInfo.size_filename <= FileNameSize) {
+                std::string filename_string(filename, fileInfo.size_filename);
+                SimplifyFilename(filename_string);
+                m_ArchiveMap.emplace(filename_string, ZipFileInfo(m_ZipFileHandle, fileInfo.uncompressed_size));
+            }
+        }
+    } while (unzGoToNextFile(m_ZipFileHandle) != UNZ_END_OF_LIST_OF_FILE);
+}
+
+bool ZipArchiveIOSystem::Implement::isOpen() const {
+    return (m_ZipFileHandle != nullptr);
+}
+
+void ZipArchiveIOSystem::Implement::getFileList(std::vector<std::string> &rFileList) {
+    MapArchive();
+    rFileList.clear();
+
+    for (const auto &file : m_ArchiveMap) {
+        rFileList.push_back(file.first);
+    }
+}
+
+void ZipArchiveIOSystem::Implement::getFileListExtension(std::vector<std::string> &rFileList, const std::string &extension) {
+    MapArchive();
+    rFileList.clear();
+
+    for (const auto &file : m_ArchiveMap) {
+        if (extension == BaseImporter::GetExtension(file.first))
+            rFileList.push_back(file.first);
+    }
+}
+
+bool ZipArchiveIOSystem::Implement::Exists(std::string &filename) {
+    MapArchive();
+
+    ZipFileInfoMap::const_iterator it = m_ArchiveMap.find(filename);
+    return (it != m_ArchiveMap.end());
+}
+
+IOStream *ZipArchiveIOSystem::Implement::OpenFile(std::string &filename) {
+    MapArchive();
+
+    SimplifyFilename(filename);
+
+    // Find in the map
+    ZipFileInfoMap::const_iterator zip_it = m_ArchiveMap.find(filename);
+    if (zip_it == m_ArchiveMap.cend())
+        return nullptr;
+
+    const ZipFileInfo &zip_file = (*zip_it).second;
+    return zip_file.Extract(filename, m_ZipFileHandle);
+}
+
+inline void ReplaceAll(std::string &data, const std::string &before, const std::string &after) {
+    size_t pos = data.find(before);
+    while (pos != std::string::npos) {
+        data.replace(pos, before.size(), after);
+        pos = data.find(before, pos + after.size());
+    }
+}
+
+inline void ReplaceAllChar(std::string &data, const char before, const char after) {
+    size_t pos = data.find(before);
+    while (pos != std::string::npos) {
+        data[pos] = after;
+        pos = data.find(before, pos + 1);
+    }
+}
+
+void ZipArchiveIOSystem::Implement::SimplifyFilename(std::string &filename) {
+    ReplaceAllChar(filename, '\\', '/');
+
+    // Remove all . and / from the beginning of the path
+    size_t pos = filename.find_first_not_of("./");
+    if (pos != 0)
+        filename.erase(0, pos);
+
+    // Simplify "my/folder/../file.png" constructions, if any
+    static const std::string relative("/../");
+    const size_t relsize = relative.size() - 1;
+    pos = filename.find(relative);
+    while (pos != std::string::npos) {
+        // Previous slash
+        size_t prevpos = filename.rfind('/', pos - 1);
+        if (prevpos == pos)
+            filename.erase(0, pos + relative.size());
+        else
+            filename.erase(prevpos, pos + relsize - prevpos);
+
+        pos = filename.find(relative);
+    }
+}
+
+ZipArchiveIOSystem::ZipArchiveIOSystem(IOSystem *pIOHandler, const char *pFilename, const char *pMode) :
+        pImpl(new Implement(pIOHandler, pFilename, pMode)) {
+}
+
+// ----------------------------------------------------------------
+// The ZipArchiveIO
+ZipArchiveIOSystem::ZipArchiveIOSystem(IOSystem *pIOHandler, const std::string &rFilename, const char *pMode) :
+        pImpl(new Implement(pIOHandler, rFilename.c_str(), pMode)) {
+}
+
+ZipArchiveIOSystem::~ZipArchiveIOSystem() {
+    delete pImpl;
+}
+
+bool ZipArchiveIOSystem::Exists(const char *pFilename) const {
+    ai_assert(pFilename != nullptr);
+
+    if (pFilename == nullptr) {
+        return false;
+    }
+
+    std::string filename(pFilename);
+    return pImpl->Exists(filename);
+}
+
+// This is always '/' in a ZIP
+char ZipArchiveIOSystem::getOsSeparator() const {
+    return '/';
+}
+
+// Only supports Reading
+IOStream *ZipArchiveIOSystem::Open(const char *pFilename, const char *pMode) {
+    ai_assert(pFilename != nullptr);
+
+    for (size_t i = 0; pMode[i] != 0; ++i) {
+        ai_assert(pMode[i] != 'w');
+        if (pMode[i] == 'w')
+            return nullptr;
+    }
+
+    std::string filename(pFilename);
+    return pImpl->OpenFile(filename);
+}
+
+void ZipArchiveIOSystem::Close(IOStream *pFile) {
+    delete pFile;
+}
+
+bool ZipArchiveIOSystem::isOpen() const {
+    return (pImpl->isOpen());
+}
+
+void ZipArchiveIOSystem::getFileList(std::vector<std::string> &rFileList) const {
+    return pImpl->getFileList(rFileList);
+}
+
+void ZipArchiveIOSystem::getFileListExtension(std::vector<std::string> &rFileList, const std::string &extension) const {
+    return pImpl->getFileListExtension(rFileList, extension);
+}
+
+bool ZipArchiveIOSystem::isZipArchive(IOSystem *pIOHandler, const char *pFilename) {
+    Implement tmp(pIOHandler, pFilename, "r");
+    return tmp.isOpen();
+}
+
+bool ZipArchiveIOSystem::isZipArchive(IOSystem *pIOHandler, const std::string &rFilename) {
+    return isZipArchive(pIOHandler, rFilename.c_str());
+}
+
+} // namespace Assimp
diff --git a/Engine/lib/assimp/code/Common/assbin_chunks.h b/Engine/lib/assimp/code/Common/assbin_chunks.h
index 15e4af5e7..822df5198 100644
--- a/Engine/lib/assimp/code/Common/assbin_chunks.h
+++ b/Engine/lib/assimp/code/Common/assbin_chunks.h
@@ -37,7 +37,7 @@ The ASSBIN file format is composed of chunks to represent the hierarchical aiSce
 This makes the format extensible and allows backward-compatibility with future data structure
 versions. The <tt>&lt;root&gt;/code/assbin_chunks.h</tt> header contains some magic constants
 for use by stand-alone ASSBIN loaders. Also, Assimp's own file writer can be found
-in <tt>&lt;root&gt;/tools/assimp_cmd/WriteDumb.cpp</tt> (yes, the 'b' is no typo ...).
+in <tt>&lt;root&gt;/tools/assimp_cmd/WriteDump.cpp</tt> (yes, the 'b' is no typo ...).
 
 @verbatim
 
diff --git a/Engine/lib/assimp/code/Common/material.cpp b/Engine/lib/assimp/code/Common/material.cpp
new file mode 100644
index 000000000..a7541d4f1
--- /dev/null
+++ b/Engine/lib/assimp/code/Common/material.cpp
@@ -0,0 +1,100 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/// @file material.cpp
+/** Implement common material related functions. */
+
+#include <assimp/ai_assert.h>
+#include <assimp/material.h>
+
+// -------------------------------------------------------------------------------
+const char *TextureTypeToString(aiTextureType in) {
+    switch (in) {
+    case aiTextureType_NONE:
+        return "n/a";
+    case aiTextureType_DIFFUSE:
+        return "Diffuse";
+    case aiTextureType_SPECULAR:
+        return "Specular";
+    case aiTextureType_AMBIENT:
+        return "Ambient";
+    case aiTextureType_EMISSIVE:
+        return "Emissive";
+    case aiTextureType_OPACITY:
+        return "Opacity";
+    case aiTextureType_NORMALS:
+        return "Normals";
+    case aiTextureType_HEIGHT:
+        return "Height";
+    case aiTextureType_SHININESS:
+        return "Shininess";
+    case aiTextureType_DISPLACEMENT:
+        return "Displacement";
+    case aiTextureType_LIGHTMAP:
+        return "Lightmap";
+    case aiTextureType_REFLECTION:
+        return "Reflection";
+    case aiTextureType_BASE_COLOR:
+        return "BaseColor";
+    case aiTextureType_NORMAL_CAMERA:
+        return "NormalCamera";
+    case aiTextureType_EMISSION_COLOR:
+        return "EmissionColor";
+    case aiTextureType_METALNESS:
+        return "Metalness";
+    case aiTextureType_DIFFUSE_ROUGHNESS:
+        return "DiffuseRoughness";
+    case aiTextureType_AMBIENT_OCCLUSION:
+        return "AmbientOcclusion";
+    case aiTextureType_SHEEN:
+        return "Sheen";
+    case aiTextureType_CLEARCOAT:
+        return "Clearcoat";
+    case aiTextureType_TRANSMISSION:
+        return "Transmission";
+    case aiTextureType_UNKNOWN:
+        return "Unknown";
+    default:
+        break;
+    }
+    ai_assert(false);
+    return "BUG";
+}
diff --git a/Engine/lib/assimp/code/Common/scene.cpp b/Engine/lib/assimp/code/Common/scene.cpp
index 2acb348d8..b0e882154 100644
--- a/Engine/lib/assimp/code/Common/scene.cpp
+++ b/Engine/lib/assimp/code/Common/scene.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -42,25 +40,25 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 #include <assimp/scene.h>
 
-aiNode::aiNode()
-: mName("")
-, mParent(NULL)
-, mNumChildren(0)
-, mChildren(NULL)
-, mNumMeshes(0)
-, mMeshes(NULL)
-, mMetaData(NULL) {
+aiNode::aiNode() :
+        mName(""),
+        mParent(nullptr),
+        mNumChildren(0),
+        mChildren(nullptr),
+        mNumMeshes(0),
+        mMeshes(nullptr),
+        mMetaData(nullptr) {
     // empty
 }
 
-aiNode::aiNode(const std::string& name)
-: mName(name)
-, mParent(NULL)
-, mNumChildren(0)
-, mChildren(NULL)
-, mNumMeshes(0)
-, mMeshes(NULL)
-, mMetaData(NULL) {
+aiNode::aiNode(const std::string &name) :
+        mName(name),
+        mParent(nullptr),
+        mNumChildren(0),
+        mChildren(nullptr),
+        mNumMeshes(0),
+        mMeshes(nullptr),
+        mMetaData(nullptr) {
     // empty
 }
 
@@ -68,8 +66,7 @@ aiNode::aiNode(const std::string& name)
 aiNode::~aiNode() {
     // delete all children recursively
     // to make sure we won't crash if the data is invalid ...
-    if (mChildren && mNumChildren)
-    {
+    if (mNumChildren && mChildren) {
         for (unsigned int a = 0; a < mNumChildren; a++)
             delete mChildren[a];
     }
@@ -78,7 +75,7 @@ aiNode::~aiNode() {
     delete mMetaData;
 }
 
-const aiNode *aiNode::FindNode(const char* name) const {
+const aiNode *aiNode::FindNode(const char *name) const {
     if (nullptr == name) {
         return nullptr;
     }
@@ -86,7 +83,7 @@ const aiNode *aiNode::FindNode(const char* name) const {
         return this;
     }
     for (unsigned int i = 0; i < mNumChildren; ++i) {
-        const aiNode* const p = mChildren[i]->FindNode(name);
+        const aiNode *const p = mChildren[i]->FindNode(name);
         if (p) {
             return p;
         }
@@ -95,11 +92,10 @@ const aiNode *aiNode::FindNode(const char* name) const {
     return nullptr;
 }
 
-aiNode *aiNode::FindNode(const char* name) {
-    if (!::strcmp(mName.data, name))return this;
-    for (unsigned int i = 0; i < mNumChildren; ++i)
-    {
-        aiNode* const p = mChildren[i]->FindNode(name);
+aiNode *aiNode::FindNode(const char *name) {
+    if (!::strcmp(mName.data, name)) return this;
+    for (unsigned int i = 0; i < mNumChildren; ++i) {
+        aiNode *const p = mChildren[i]->FindNode(name);
         if (p) {
             return p;
         }
@@ -121,17 +117,16 @@ void aiNode::addChildren(unsigned int numChildren, aiNode **children) {
     }
 
     if (mNumChildren > 0) {
-        aiNode **tmp = new aiNode*[mNumChildren];
-        ::memcpy(tmp, mChildren, sizeof(aiNode*) * mNumChildren);
+        aiNode **tmp = new aiNode *[mNumChildren];
+        ::memcpy(tmp, mChildren, sizeof(aiNode *) * mNumChildren);
         delete[] mChildren;
-        mChildren = new aiNode*[mNumChildren + numChildren];
-        ::memcpy(mChildren, tmp, sizeof(aiNode*) * mNumChildren);
-        ::memcpy(&mChildren[mNumChildren], children, sizeof(aiNode*)* numChildren);
+        mChildren = new aiNode *[mNumChildren + numChildren];
+        ::memcpy(mChildren, tmp, sizeof(aiNode *) * mNumChildren);
+        ::memcpy(&mChildren[mNumChildren], children, sizeof(aiNode *) * numChildren);
         mNumChildren += numChildren;
         delete[] tmp;
-    }
-    else {
-        mChildren = new aiNode*[numChildren];
+    } else {
+        mChildren = new aiNode *[numChildren];
         for (unsigned int i = 0; i < numChildren; i++) {
             mChildren[i] = children[i];
         }
diff --git a/Engine/lib/assimp/code/Common/simd.cpp b/Engine/lib/assimp/code/Common/simd.cpp
index 04615f408..0dd437d26 100644
--- a/Engine/lib/assimp/code/Common/simd.cpp
+++ b/Engine/lib/assimp/code/Common/simd.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/Engine/lib/assimp/code/Common/simd.h b/Engine/lib/assimp/code/Common/simd.h
index 3eecdd458..0a062a248 100644
--- a/Engine/lib/assimp/code/Common/simd.h
+++ b/Engine/lib/assimp/code/Common/simd.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
diff --git a/Engine/lib/assimp/code/FBX/FBXConverter.cpp b/Engine/lib/assimp/code/FBX/FBXConverter.cpp
deleted file mode 100644
index 152be3277..000000000
--- a/Engine/lib/assimp/code/FBX/FBXConverter.cpp
+++ /dev/null
@@ -1,3615 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file  FBXConverter.cpp
- *  @brief Implementation of the FBX DOM -> aiScene converter
- */
-
-#ifndef ASSIMP_BUILD_NO_FBX_IMPORTER
-
-#include "FBXConverter.h"
-#include "FBXParser.h"
-#include "FBXMeshGeometry.h"
-#include "FBXDocument.h"
-#include "FBXUtil.h"
-#include "FBXProperties.h"
-#include "FBXImporter.h"
-
-#include <assimp/StringComparison.h>
-#include <assimp/MathFunctions.h>
-
-#include <assimp/scene.h>
-
-#include <assimp/CreateAnimMesh.h>
-
-#include <tuple>
-#include <memory>
-#include <iterator>
-#include <vector>
-#include <sstream>
-#include <iomanip>
-#include <cstdint>
-
-
-namespace Assimp {
-    namespace FBX {
-
-        using namespace Util;
-
-#define MAGIC_NODE_TAG "_$AssimpFbx$"
-
-#define CONVERT_FBX_TIME(time) static_cast<double>(time) / 46186158000L
-
-        FBXConverter::FBXConverter(aiScene* out, const Document& doc, bool removeEmptyBones )
-        : defaultMaterialIndex()
-        , lights()
-        , cameras()
-        , textures()
-        , materials_converted()
-        , textures_converted()
-        , meshes_converted()
-        , node_anim_chain_bits()
-        , mNodeNames()
-        , anim_fps()
-        , out(out)
-        , doc(doc) {
-            // animations need to be converted first since this will
-            // populate the node_anim_chain_bits map, which is needed
-            // to determine which nodes need to be generated.
-            ConvertAnimations();
-            ConvertRootNode();
-
-            if (doc.Settings().readAllMaterials) {
-                // unfortunately this means we have to evaluate all objects
-                for (const ObjectMap::value_type& v : doc.Objects()) {
-
-                    const Object* ob = v.second->Get();
-                    if (!ob) {
-                        continue;
-                    }
-
-                    const Material* mat = dynamic_cast<const Material*>(ob);
-                    if (mat) {
-
-                        if (materials_converted.find(mat) == materials_converted.end()) {
-                            ConvertMaterial(*mat, 0);
-                        }
-                    }
-                }
-            }
-
-            ConvertGlobalSettings();
-            TransferDataToScene();
-
-            // if we didn't read any meshes set the AI_SCENE_FLAGS_INCOMPLETE
-            // to make sure the scene passes assimp's validation. FBX files
-            // need not contain geometry (i.e. camera animations, raw armatures).
-            if (out->mNumMeshes == 0) {
-                out->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
-            }
-        }
-
-
-        FBXConverter::~FBXConverter() {
-            std::for_each(meshes.begin(), meshes.end(), Util::delete_fun<aiMesh>());
-            std::for_each(materials.begin(), materials.end(), Util::delete_fun<aiMaterial>());
-            std::for_each(animations.begin(), animations.end(), Util::delete_fun<aiAnimation>());
-            std::for_each(lights.begin(), lights.end(), Util::delete_fun<aiLight>());
-            std::for_each(cameras.begin(), cameras.end(), Util::delete_fun<aiCamera>());
-            std::for_each(textures.begin(), textures.end(), Util::delete_fun<aiTexture>());
-        }
-
-        void FBXConverter::ConvertRootNode() {
-            out->mRootNode = new aiNode();
-            std::string unique_name;
-            GetUniqueName("RootNode", unique_name);
-            out->mRootNode->mName.Set(unique_name);
-
-            // root has ID 0
-            ConvertNodes(0L, *out->mRootNode);
-        }
-
-        static std::string getAncestorBaseName(const aiNode* node)
-        {
-            const char* nodeName = nullptr;
-            size_t length = 0;
-            while (node && (!nodeName || length == 0))
-            {
-                nodeName = node->mName.C_Str();
-                length = node->mName.length;
-                node = node->mParent;
-            }
-
-            if (!nodeName || length == 0)
-            {
-                return {};
-            }
-            // could be std::string_view if c++17 available
-            return std::string(nodeName, length);
-        }
-
-        // Make unique name
-        std::string FBXConverter::MakeUniqueNodeName(const Model* const model, const aiNode& parent)
-        {
-            std::string original_name = FixNodeName(model->Name());
-            if (original_name.empty())
-            {
-                original_name = getAncestorBaseName(&parent);
-            }
-            std::string unique_name;
-            GetUniqueName(original_name, unique_name);
-            return unique_name;
-        }
-
-        void FBXConverter::ConvertNodes(uint64_t id, aiNode& parent, const aiMatrix4x4& parent_transform) {
-            const std::vector<const Connection*>& conns = doc.GetConnectionsByDestinationSequenced(id, "Model");
-
-            std::vector<aiNode*> nodes;
-            nodes.reserve(conns.size());
-
-            std::vector<aiNode*> nodes_chain;
-            std::vector<aiNode*> post_nodes_chain;
-
-            try {
-                for (const Connection* con : conns) {
-
-                    // ignore object-property links
-                    if (con->PropertyName().length()) {
-                        continue;
-                    }
-
-                    const Object* const object = con->SourceObject();
-                    if (nullptr == object) {
-                        FBXImporter::LogWarn("failed to convert source object for Model link");
-                        continue;
-                    }
-
-                    const Model* const model = dynamic_cast<const Model*>(object);
-
-                    if (nullptr != model) {
-                        nodes_chain.clear();
-                        post_nodes_chain.clear();
-
-                        aiMatrix4x4 new_abs_transform = parent_transform;
-
-                        std::string unique_name = MakeUniqueNodeName(model, parent);
-
-                        // even though there is only a single input node, the design of
-                        // assimp (or rather: the complicated transformation chain that
-                        // is employed by fbx) means that we may need multiple aiNode's
-                        // to represent a fbx node's transformation.
-                        const bool need_additional_node = GenerateTransformationNodeChain(*model, unique_name, nodes_chain, post_nodes_chain);
-
-                        ai_assert(nodes_chain.size());
-
-                        if (need_additional_node) {
-                            nodes_chain.push_back(new aiNode(unique_name));
-                        }
-
-                        //setup metadata on newest node
-                        SetupNodeMetadata(*model, *nodes_chain.back());
-
-                        // link all nodes in a row
-                        aiNode* last_parent = &parent;
-                        for (aiNode* prenode : nodes_chain) {
-                            ai_assert(prenode);
-
-                            if (last_parent != &parent) {
-                                last_parent->mNumChildren = 1;
-                                last_parent->mChildren = new aiNode*[1];
-                                last_parent->mChildren[0] = prenode;
-                            }
-
-                            prenode->mParent = last_parent;
-                            last_parent = prenode;
-
-                            new_abs_transform *= prenode->mTransformation;
-                        }
-
-                        // attach geometry
-                        ConvertModel(*model, *nodes_chain.back(), new_abs_transform);
-
-                        // check if there will be any child nodes
-                        const std::vector<const Connection*>& child_conns
-                            = doc.GetConnectionsByDestinationSequenced(model->ID(), "Model");
-
-                        // if so, link the geometric transform inverse nodes
-                        // before we attach any child nodes
-                        if (child_conns.size()) {
-                            for (aiNode* postnode : post_nodes_chain) {
-                                ai_assert(postnode);
-
-                                if (last_parent != &parent) {
-                                    last_parent->mNumChildren = 1;
-                                    last_parent->mChildren = new aiNode*[1];
-                                    last_parent->mChildren[0] = postnode;
-                                }
-
-                                postnode->mParent = last_parent;
-                                last_parent = postnode;
-
-                                new_abs_transform *= postnode->mTransformation;
-                            }
-                        }
-                        else {
-                            // free the nodes we allocated as we don't need them
-                            Util::delete_fun<aiNode> deleter;
-                            std::for_each(
-                                post_nodes_chain.begin(),
-                                post_nodes_chain.end(),
-                                deleter
-                            );
-                        }
-
-                        // attach sub-nodes (if any)
-                        ConvertNodes(model->ID(), *last_parent, new_abs_transform);
-
-                        if (doc.Settings().readLights) {
-                            ConvertLights(*model, unique_name);
-                        }
-
-                        if (doc.Settings().readCameras) {
-                            ConvertCameras(*model, unique_name);
-                        }
-
-                        nodes.push_back(nodes_chain.front());
-                        nodes_chain.clear();
-                    }
-                }
-
-                if (nodes.size()) {
-                    parent.mChildren = new aiNode*[nodes.size()]();
-                    parent.mNumChildren = static_cast<unsigned int>(nodes.size());
-
-                    std::swap_ranges(nodes.begin(), nodes.end(), parent.mChildren);
-                }
-            }
-            catch (std::exception&) {
-                Util::delete_fun<aiNode> deleter;
-                std::for_each(nodes.begin(), nodes.end(), deleter);
-                std::for_each(nodes_chain.begin(), nodes_chain.end(), deleter);
-                std::for_each(post_nodes_chain.begin(), post_nodes_chain.end(), deleter);
-            }
-        }
-
-
-        void FBXConverter::ConvertLights(const Model& model, const std::string &orig_name) {
-            const std::vector<const NodeAttribute*>& node_attrs = model.GetAttributes();
-            for (const NodeAttribute* attr : node_attrs) {
-                const Light* const light = dynamic_cast<const Light*>(attr);
-                if (light) {
-                    ConvertLight(*light, orig_name);
-                }
-            }
-        }
-
-        void FBXConverter::ConvertCameras(const Model& model, const std::string &orig_name) {
-            const std::vector<const NodeAttribute*>& node_attrs = model.GetAttributes();
-            for (const NodeAttribute* attr : node_attrs) {
-                const Camera* const cam = dynamic_cast<const Camera*>(attr);
-                if (cam) {
-                    ConvertCamera(*cam, orig_name);
-                }
-            }
-        }
-
-        void FBXConverter::ConvertLight(const Light& light, const std::string &orig_name) {
-            lights.push_back(new aiLight());
-            aiLight* const out_light = lights.back();
-
-            out_light->mName.Set(orig_name);
-
-            const float intensity = light.Intensity() / 100.0f;
-            const aiVector3D& col = light.Color();
-
-            out_light->mColorDiffuse = aiColor3D(col.x, col.y, col.z);
-            out_light->mColorDiffuse.r *= intensity;
-            out_light->mColorDiffuse.g *= intensity;
-            out_light->mColorDiffuse.b *= intensity;
-
-            out_light->mColorSpecular = out_light->mColorDiffuse;
-
-            //lights are defined along negative y direction
-            out_light->mPosition = aiVector3D(0.0f);
-            out_light->mDirection = aiVector3D(0.0f, -1.0f, 0.0f);
-            out_light->mUp = aiVector3D(0.0f, 0.0f, -1.0f);
-
-            switch (light.LightType())
-            {
-            case Light::Type_Point:
-                out_light->mType = aiLightSource_POINT;
-                break;
-
-            case Light::Type_Directional:
-                out_light->mType = aiLightSource_DIRECTIONAL;
-                break;
-
-            case Light::Type_Spot:
-                out_light->mType = aiLightSource_SPOT;
-                out_light->mAngleOuterCone = AI_DEG_TO_RAD(light.OuterAngle());
-                out_light->mAngleInnerCone = AI_DEG_TO_RAD(light.InnerAngle());
-                break;
-
-            case Light::Type_Area:
-                FBXImporter::LogWarn("cannot represent area light, set to UNDEFINED");
-                out_light->mType = aiLightSource_UNDEFINED;
-                break;
-
-            case Light::Type_Volume:
-                FBXImporter::LogWarn("cannot represent volume light, set to UNDEFINED");
-                out_light->mType = aiLightSource_UNDEFINED;
-                break;
-            default:
-                ai_assert(false);
-            }
-
-            float decay = light.DecayStart();
-            switch (light.DecayType())
-            {
-            case Light::Decay_None:
-                out_light->mAttenuationConstant = decay;
-                out_light->mAttenuationLinear = 0.0f;
-                out_light->mAttenuationQuadratic = 0.0f;
-                break;
-            case Light::Decay_Linear:
-                out_light->mAttenuationConstant = 0.0f;
-                out_light->mAttenuationLinear = 2.0f / decay;
-                out_light->mAttenuationQuadratic = 0.0f;
-                break;
-            case Light::Decay_Quadratic:
-                out_light->mAttenuationConstant = 0.0f;
-                out_light->mAttenuationLinear = 0.0f;
-                out_light->mAttenuationQuadratic = 2.0f / (decay * decay);
-                break;
-            case Light::Decay_Cubic:
-                FBXImporter::LogWarn("cannot represent cubic attenuation, set to Quadratic");
-                out_light->mAttenuationQuadratic = 1.0f;
-                break;
-            default:
-                ai_assert(false);
-                break;
-            }
-        }
-
-        void FBXConverter::ConvertCamera(const Camera& cam, const std::string &orig_name)
-        {
-            cameras.push_back(new aiCamera());
-            aiCamera* const out_camera = cameras.back();
-
-            out_camera->mName.Set(orig_name);
-
-            out_camera->mAspect = cam.AspectWidth() / cam.AspectHeight();
-
-            out_camera->mPosition = aiVector3D(0.0f);
-            out_camera->mLookAt = aiVector3D(1.0f, 0.0f, 0.0f);
-            out_camera->mUp = aiVector3D(0.0f, 1.0f, 0.0f);
-
-            out_camera->mHorizontalFOV = AI_DEG_TO_RAD(cam.FieldOfView());
-
-            out_camera->mClipPlaneNear = cam.NearPlane();
-            out_camera->mClipPlaneFar = cam.FarPlane();
-
-            out_camera->mHorizontalFOV = AI_DEG_TO_RAD(cam.FieldOfView());
-            out_camera->mClipPlaneNear = cam.NearPlane();
-            out_camera->mClipPlaneFar = cam.FarPlane();
-        }
-
-        void FBXConverter::GetUniqueName(const std::string &name, std::string &uniqueName)
-        {
-            uniqueName = name;
-            auto it_pair = mNodeNames.insert({ name, 0 }); // duplicate node name instance count
-            unsigned int& i = it_pair.first->second;
-            while (!it_pair.second)
-            {
-                i++;
-                std::ostringstream ext;
-                ext << name << std::setfill('0') << std::setw(3) << i;
-                uniqueName = ext.str();
-                it_pair = mNodeNames.insert({ uniqueName, 0 });
-            }
-        }
-
-        const char* FBXConverter::NameTransformationComp(TransformationComp comp) {
-            switch (comp) {
-            case TransformationComp_Translation:
-                return "Translation";
-            case TransformationComp_RotationOffset:
-                return "RotationOffset";
-            case TransformationComp_RotationPivot:
-                return "RotationPivot";
-            case TransformationComp_PreRotation:
-                return "PreRotation";
-            case TransformationComp_Rotation:
-                return "Rotation";
-            case TransformationComp_PostRotation:
-                return "PostRotation";
-            case TransformationComp_RotationPivotInverse:
-                return "RotationPivotInverse";
-            case TransformationComp_ScalingOffset:
-                return "ScalingOffset";
-            case TransformationComp_ScalingPivot:
-                return "ScalingPivot";
-            case TransformationComp_Scaling:
-                return "Scaling";
-            case TransformationComp_ScalingPivotInverse:
-                return "ScalingPivotInverse";
-            case TransformationComp_GeometricScaling:
-                return "GeometricScaling";
-            case TransformationComp_GeometricRotation:
-                return "GeometricRotation";
-            case TransformationComp_GeometricTranslation:
-                return "GeometricTranslation";
-            case TransformationComp_GeometricScalingInverse:
-                return "GeometricScalingInverse";
-            case TransformationComp_GeometricRotationInverse:
-                return "GeometricRotationInverse";
-            case TransformationComp_GeometricTranslationInverse:
-                return "GeometricTranslationInverse";
-            case TransformationComp_MAXIMUM: // this is to silence compiler warnings
-            default:
-                break;
-            }
-
-            ai_assert(false);
-
-            return nullptr;
-        }
-
-        const char* FBXConverter::NameTransformationCompProperty(TransformationComp comp) {
-            switch (comp) {
-            case TransformationComp_Translation:
-                return "Lcl Translation";
-            case TransformationComp_RotationOffset:
-                return "RotationOffset";
-            case TransformationComp_RotationPivot:
-                return "RotationPivot";
-            case TransformationComp_PreRotation:
-                return "PreRotation";
-            case TransformationComp_Rotation:
-                return "Lcl Rotation";
-            case TransformationComp_PostRotation:
-                return "PostRotation";
-            case TransformationComp_RotationPivotInverse:
-                return "RotationPivotInverse";
-            case TransformationComp_ScalingOffset:
-                return "ScalingOffset";
-            case TransformationComp_ScalingPivot:
-                return "ScalingPivot";
-            case TransformationComp_Scaling:
-                return "Lcl Scaling";
-            case TransformationComp_ScalingPivotInverse:
-                return "ScalingPivotInverse";
-            case TransformationComp_GeometricScaling:
-                return "GeometricScaling";
-            case TransformationComp_GeometricRotation:
-                return "GeometricRotation";
-            case TransformationComp_GeometricTranslation:
-                return "GeometricTranslation";
-            case TransformationComp_GeometricScalingInverse:
-                return "GeometricScalingInverse";
-            case TransformationComp_GeometricRotationInverse:
-                return "GeometricRotationInverse";
-            case TransformationComp_GeometricTranslationInverse:
-                return "GeometricTranslationInverse";
-            case TransformationComp_MAXIMUM: // this is to silence compiler warnings
-                break;
-            }
-
-            ai_assert(false);
-
-            return nullptr;
-        }
-
-        aiVector3D FBXConverter::TransformationCompDefaultValue(TransformationComp comp)
-        {
-            // XXX a neat way to solve the never-ending special cases for scaling
-            // would be to do everything in log space!
-            return comp == TransformationComp_Scaling ? aiVector3D(1.f, 1.f, 1.f) : aiVector3D();
-        }
-
-        void FBXConverter::GetRotationMatrix(Model::RotOrder mode, const aiVector3D& rotation, aiMatrix4x4& out)
-        {
-            if (mode == Model::RotOrder_SphericXYZ) {
-                FBXImporter::LogError("Unsupported RotationMode: SphericXYZ");
-                out = aiMatrix4x4();
-                return;
-            }
-
-            const float angle_epsilon = Math::getEpsilon<float>();
-
-            out = aiMatrix4x4();
-
-            bool is_id[3] = { true, true, true };
-
-            aiMatrix4x4 temp[3];
-            if (std::fabs(rotation.z) > angle_epsilon) {
-                aiMatrix4x4::RotationZ(AI_DEG_TO_RAD(rotation.z), temp[2]);
-                is_id[2] = false;
-            }
-            if (std::fabs(rotation.y) > angle_epsilon) {
-                aiMatrix4x4::RotationY(AI_DEG_TO_RAD(rotation.y), temp[1]);
-                is_id[1] = false;
-            }
-            if (std::fabs(rotation.x) > angle_epsilon) {
-                aiMatrix4x4::RotationX(AI_DEG_TO_RAD(rotation.x), temp[0]);
-                is_id[0] = false;
-            }
-
-            int order[3] = { -1, -1, -1 };
-
-            // note: rotation order is inverted since we're left multiplying as is usual in assimp
-            switch (mode)
-            {
-            case Model::RotOrder_EulerXYZ:
-                order[0] = 2;
-                order[1] = 1;
-                order[2] = 0;
-                break;
-
-            case Model::RotOrder_EulerXZY:
-                order[0] = 1;
-                order[1] = 2;
-                order[2] = 0;
-                break;
-
-            case Model::RotOrder_EulerYZX:
-                order[0] = 0;
-                order[1] = 2;
-                order[2] = 1;
-                break;
-
-            case Model::RotOrder_EulerYXZ:
-                order[0] = 2;
-                order[1] = 0;
-                order[2] = 1;
-                break;
-
-            case Model::RotOrder_EulerZXY:
-                order[0] = 1;
-                order[1] = 0;
-                order[2] = 2;
-                break;
-
-            case Model::RotOrder_EulerZYX:
-                order[0] = 0;
-                order[1] = 1;
-                order[2] = 2;
-                break;
-
-            default:
-                ai_assert(false);
-                break;
-            }
-
-            ai_assert(order[0] >= 0);
-            ai_assert(order[0] <= 2);
-            ai_assert(order[1] >= 0);
-            ai_assert(order[1] <= 2);
-            ai_assert(order[2] >= 0);
-            ai_assert(order[2] <= 2);
-
-            if (!is_id[order[0]]) {
-                out = temp[order[0]];
-            }
-
-            if (!is_id[order[1]]) {
-                out = out * temp[order[1]];
-            }
-
-            if (!is_id[order[2]]) {
-                out = out * temp[order[2]];
-            }
-        }
-
-        bool FBXConverter::NeedsComplexTransformationChain(const Model& model)
-        {
-            const PropertyTable& props = model.Props();
-            bool ok;
-
-            const float zero_epsilon = 1e-6f;
-            const aiVector3D all_ones(1.0f, 1.0f, 1.0f);
-            for (size_t i = 0; i < TransformationComp_MAXIMUM; ++i) {
-                const TransformationComp comp = static_cast<TransformationComp>(i);
-
-                if (comp == TransformationComp_Rotation || comp == TransformationComp_Scaling || comp == TransformationComp_Translation) {
-                    continue;
-                }
-
-                bool scale_compare = (comp == TransformationComp_GeometricScaling || comp == TransformationComp_Scaling);
-
-                const aiVector3D& v = PropertyGet<aiVector3D>(props, NameTransformationCompProperty(comp), ok);
-                if (ok && scale_compare) {
-                    if ((v - all_ones).SquareLength() > zero_epsilon) {
-                        return true;
-                    }
-                } else if (ok) {
-                    if (v.SquareLength() > zero_epsilon) {
-                        return true;
-                    }
-                }
-            }
-
-            return false;
-        }
-
-        std::string FBXConverter::NameTransformationChainNode(const std::string& name, TransformationComp comp)
-        {
-            return name + std::string(MAGIC_NODE_TAG) + "_" + NameTransformationComp(comp);
-        }
-
-        bool FBXConverter::GenerateTransformationNodeChain(const Model& model, const std::string& name, std::vector<aiNode*>& output_nodes,
-            std::vector<aiNode*>& post_output_nodes) {
-            const PropertyTable& props = model.Props();
-            const Model::RotOrder rot = model.RotationOrder();
-
-            bool ok;
-
-            aiMatrix4x4 chain[TransformationComp_MAXIMUM];
-
-            ai_assert(TransformationComp_MAXIMUM < 32);
-            std::uint32_t chainBits = 0;
-            // A node won't need a node chain if it only has these.
-            const std::uint32_t chainMaskSimple = (1 << TransformationComp_Translation) + (1 << TransformationComp_Scaling) + (1 << TransformationComp_Rotation);
-            // A node will need a node chain if it has any of these.
-            const std::uint32_t chainMaskComplex = ((1 << (TransformationComp_MAXIMUM)) - 1) - chainMaskSimple;
-
-            std::fill_n(chain, static_cast<unsigned int>(TransformationComp_MAXIMUM), aiMatrix4x4());
-
-            // generate transformation matrices for all the different transformation components
-            const float zero_epsilon = Math::getEpsilon<float>();
-            const aiVector3D all_ones(1.0f, 1.0f, 1.0f);
-
-            const aiVector3D& PreRotation = PropertyGet<aiVector3D>(props, "PreRotation", ok);
-            if (ok && PreRotation.SquareLength() > zero_epsilon) {
-                chainBits = chainBits | (1 << TransformationComp_PreRotation);
-
-                GetRotationMatrix(Model::RotOrder::RotOrder_EulerXYZ, PreRotation, chain[TransformationComp_PreRotation]);
-            }
-
-            const aiVector3D& PostRotation = PropertyGet<aiVector3D>(props, "PostRotation", ok);
-            if (ok && PostRotation.SquareLength() > zero_epsilon) {
-                chainBits = chainBits | (1 << TransformationComp_PostRotation);
-
-                GetRotationMatrix(Model::RotOrder::RotOrder_EulerXYZ, PostRotation, chain[TransformationComp_PostRotation]);
-            }
-
-            const aiVector3D& RotationPivot = PropertyGet<aiVector3D>(props, "RotationPivot", ok);
-            if (ok && RotationPivot.SquareLength() > zero_epsilon) {
-                chainBits = chainBits | (1 << TransformationComp_RotationPivot) | (1 << TransformationComp_RotationPivotInverse);
-
-                aiMatrix4x4::Translation(RotationPivot, chain[TransformationComp_RotationPivot]);
-                aiMatrix4x4::Translation(-RotationPivot, chain[TransformationComp_RotationPivotInverse]);
-            }
-
-            const aiVector3D& RotationOffset = PropertyGet<aiVector3D>(props, "RotationOffset", ok);
-            if (ok && RotationOffset.SquareLength() > zero_epsilon) {
-                chainBits = chainBits | (1 << TransformationComp_RotationOffset);
-
-                aiMatrix4x4::Translation(RotationOffset, chain[TransformationComp_RotationOffset]);
-            }
-
-            const aiVector3D& ScalingOffset = PropertyGet<aiVector3D>(props, "ScalingOffset", ok);
-            if (ok && ScalingOffset.SquareLength() > zero_epsilon) {
-                chainBits = chainBits | (1 << TransformationComp_ScalingOffset);
-
-                aiMatrix4x4::Translation(ScalingOffset, chain[TransformationComp_ScalingOffset]);
-            }
-
-            const aiVector3D& ScalingPivot = PropertyGet<aiVector3D>(props, "ScalingPivot", ok);
-            if (ok && ScalingPivot.SquareLength() > zero_epsilon) {
-                chainBits = chainBits | (1 << TransformationComp_ScalingPivot) | (1 << TransformationComp_ScalingPivotInverse);
-
-                aiMatrix4x4::Translation(ScalingPivot, chain[TransformationComp_ScalingPivot]);
-                aiMatrix4x4::Translation(-ScalingPivot, chain[TransformationComp_ScalingPivotInverse]);
-            }
-
-            const aiVector3D& Translation = PropertyGet<aiVector3D>(props, "Lcl Translation", ok);
-            if (ok && Translation.SquareLength() > zero_epsilon) {
-                chainBits = chainBits | (1 << TransformationComp_Translation);
-
-                aiMatrix4x4::Translation(Translation, chain[TransformationComp_Translation]);
-            }
-
-            const aiVector3D& Scaling = PropertyGet<aiVector3D>(props, "Lcl Scaling", ok);
-            if (ok && (Scaling - all_ones).SquareLength() > zero_epsilon) {
-                chainBits = chainBits | (1 << TransformationComp_Scaling);
-
-                aiMatrix4x4::Scaling(Scaling, chain[TransformationComp_Scaling]);
-            }
-
-            const aiVector3D& Rotation = PropertyGet<aiVector3D>(props, "Lcl Rotation", ok);
-            if (ok && Rotation.SquareLength() > zero_epsilon) {
-                chainBits = chainBits | (1 << TransformationComp_Rotation);
-
-                GetRotationMatrix(rot, Rotation, chain[TransformationComp_Rotation]);
-            }
-
-            const aiVector3D& GeometricScaling = PropertyGet<aiVector3D>(props, "GeometricScaling", ok);
-            if (ok && (GeometricScaling - all_ones).SquareLength() > zero_epsilon) {
-                chainBits = chainBits | (1 << TransformationComp_GeometricScaling);
-                aiMatrix4x4::Scaling(GeometricScaling, chain[TransformationComp_GeometricScaling]);
-                aiVector3D GeometricScalingInverse = GeometricScaling;
-                bool canscale = true;
-                for (unsigned int i = 0; i < 3; ++i) {
-                    if (std::fabs(GeometricScalingInverse[i]) > zero_epsilon) {
-                        GeometricScalingInverse[i] = 1.0f / GeometricScaling[i];
-                    }
-                    else {
-                        FBXImporter::LogError("cannot invert geometric scaling matrix with a 0.0 scale component");
-                        canscale = false;
-                        break;
-                    }
-                }
-                if (canscale) {
-                    chainBits = chainBits | (1 << TransformationComp_GeometricScalingInverse);
-                    aiMatrix4x4::Scaling(GeometricScalingInverse, chain[TransformationComp_GeometricScalingInverse]);
-                }
-            }
-
-            const aiVector3D& GeometricRotation = PropertyGet<aiVector3D>(props, "GeometricRotation", ok);
-            if (ok && GeometricRotation.SquareLength() > zero_epsilon) {
-                chainBits = chainBits | (1 << TransformationComp_GeometricRotation) | (1 << TransformationComp_GeometricRotationInverse);
-                GetRotationMatrix(rot, GeometricRotation, chain[TransformationComp_GeometricRotation]);
-                GetRotationMatrix(rot, GeometricRotation, chain[TransformationComp_GeometricRotationInverse]);
-                chain[TransformationComp_GeometricRotationInverse].Inverse();
-            }
-
-            const aiVector3D& GeometricTranslation = PropertyGet<aiVector3D>(props, "GeometricTranslation", ok);
-            if (ok && GeometricTranslation.SquareLength() > zero_epsilon) {
-                chainBits = chainBits | (1 << TransformationComp_GeometricTranslation) | (1 << TransformationComp_GeometricTranslationInverse);
-                aiMatrix4x4::Translation(GeometricTranslation, chain[TransformationComp_GeometricTranslation]);
-                aiMatrix4x4::Translation(-GeometricTranslation, chain[TransformationComp_GeometricTranslationInverse]);
-            }
-
-            // is_complex needs to be consistent with NeedsComplexTransformationChain()
-            // or the interplay between this code and the animation converter would
-            // not be guaranteed.
-            ai_assert(NeedsComplexTransformationChain(model) == ((chainBits & chainMaskComplex) != 0));
-
-            // now, if we have more than just Translation, Scaling and Rotation,
-            // we need to generate a full node chain to accommodate for assimp's
-            // lack to express pivots and offsets.
-            if ((chainBits & chainMaskComplex) && doc.Settings().preservePivots) {
-                FBXImporter::LogInfo("generating full transformation chain for node: " + name);
-
-                // query the anim_chain_bits dictionary to find out which chain elements
-                // have associated node animation channels. These can not be dropped
-                // even if they have identity transform in bind pose.
-                NodeAnimBitMap::const_iterator it = node_anim_chain_bits.find(name);
-                const unsigned int anim_chain_bitmask = (it == node_anim_chain_bits.end() ? 0 : (*it).second);
-
-                unsigned int bit = 0x1;
-                for (size_t i = 0; i < TransformationComp_MAXIMUM; ++i, bit <<= 1) {
-                    const TransformationComp comp = static_cast<TransformationComp>(i);
-
-                    if ((chainBits & bit) == 0 && (anim_chain_bitmask & bit) == 0) {
-                        continue;
-                    }
-
-                    if (comp == TransformationComp_PostRotation) {
-                        chain[i] = chain[i].Inverse();
-                    }
-
-                    aiNode* nd = new aiNode();
-                    nd->mName.Set(NameTransformationChainNode(name, comp));
-                    nd->mTransformation = chain[i];
-
-                    // geometric inverses go in a post-node chain
-                    if (comp == TransformationComp_GeometricScalingInverse ||
-                        comp == TransformationComp_GeometricRotationInverse ||
-                        comp == TransformationComp_GeometricTranslationInverse
-                        ) {
-                        post_output_nodes.push_back(nd);
-                    }
-                    else {
-                        output_nodes.push_back(nd);
-                    }
-                }
-
-                ai_assert(output_nodes.size());
-                return true;
-            }
-
-            // else, we can just multiply the matrices together
-            aiNode* nd = new aiNode();
-            output_nodes.push_back(nd);
-
-            // name passed to the method is already unique
-            nd->mName.Set(name);
-
-            for (const auto &transform : chain) {
-                nd->mTransformation = nd->mTransformation * transform;
-            }
-            return false;
-        }
-
-        void FBXConverter::SetupNodeMetadata(const Model& model, aiNode& nd)
-        {
-            const PropertyTable& props = model.Props();
-            DirectPropertyMap unparsedProperties = props.GetUnparsedProperties();
-
-            // create metadata on node
-            const std::size_t numStaticMetaData = 2;
-            aiMetadata* data = aiMetadata::Alloc(static_cast<unsigned int>(unparsedProperties.size() + numStaticMetaData));
-            nd.mMetaData = data;
-            int index = 0;
-
-            // find user defined properties (3ds Max)
-            data->Set(index++, "UserProperties", aiString(PropertyGet<std::string>(props, "UDP3DSMAX", "")));
-            // preserve the info that a node was marked as Null node in the original file.
-            data->Set(index++, "IsNull", model.IsNull() ? true : false);
-
-            // add unparsed properties to the node's metadata
-            for (const DirectPropertyMap::value_type& prop : unparsedProperties) {
-                // Interpret the property as a concrete type
-                if (const TypedProperty<bool>* interpreted = prop.second->As<TypedProperty<bool> >()) {
-                    data->Set(index++, prop.first, interpreted->Value());
-                }
-                else if (const TypedProperty<int>* interpreted = prop.second->As<TypedProperty<int> >()) {
-                    data->Set(index++, prop.first, interpreted->Value());
-                }
-                else if (const TypedProperty<uint64_t>* interpreted = prop.second->As<TypedProperty<uint64_t> >()) {
-                    data->Set(index++, prop.first, interpreted->Value());
-                }
-                else if (const TypedProperty<float>* interpreted = prop.second->As<TypedProperty<float> >()) {
-                    data->Set(index++, prop.first, interpreted->Value());
-                }
-                else if (const TypedProperty<std::string>* interpreted = prop.second->As<TypedProperty<std::string> >()) {
-                    data->Set(index++, prop.first, aiString(interpreted->Value()));
-                }
-                else if (const TypedProperty<aiVector3D>* interpreted = prop.second->As<TypedProperty<aiVector3D> >()) {
-                    data->Set(index++, prop.first, interpreted->Value());
-                }
-                else {
-                    ai_assert(false);
-                }
-            }
-        }
-
-        void FBXConverter::ConvertModel(const Model& model, aiNode& nd, const aiMatrix4x4& node_global_transform)
-        {
-            const std::vector<const Geometry*>& geos = model.GetGeometry();
-
-            std::vector<unsigned int> meshes;
-            meshes.reserve(geos.size());
-
-            for (const Geometry* geo : geos) {
-
-                const MeshGeometry* const mesh = dynamic_cast<const MeshGeometry*>(geo);
-                const LineGeometry* const line = dynamic_cast<const LineGeometry*>(geo);
-                if (mesh) {
-                    const std::vector<unsigned int>& indices = ConvertMesh(*mesh, model, node_global_transform, nd);
-                    std::copy(indices.begin(), indices.end(), std::back_inserter(meshes));
-                }
-                else if (line) {
-                    const std::vector<unsigned int>& indices = ConvertLine(*line, model, node_global_transform, nd);
-                    std::copy(indices.begin(), indices.end(), std::back_inserter(meshes));
-                }
-                else {
-                    FBXImporter::LogWarn("ignoring unrecognized geometry: " + geo->Name());
-                }
-            }
-
-            if (meshes.size()) {
-                nd.mMeshes = new unsigned int[meshes.size()]();
-                nd.mNumMeshes = static_cast<unsigned int>(meshes.size());
-
-                std::swap_ranges(meshes.begin(), meshes.end(), nd.mMeshes);
-            }
-        }
-
-        std::vector<unsigned int> FBXConverter::ConvertMesh(const MeshGeometry& mesh, const Model& model,
-            const aiMatrix4x4& node_global_transform, aiNode& nd)
-        {
-            std::vector<unsigned int> temp;
-
-            MeshMap::const_iterator it = meshes_converted.find(&mesh);
-            if (it != meshes_converted.end()) {
-                std::copy((*it).second.begin(), (*it).second.end(), std::back_inserter(temp));
-                return temp;
-            }
-
-            const std::vector<aiVector3D>& vertices = mesh.GetVertices();
-            const std::vector<unsigned int>& faces = mesh.GetFaceIndexCounts();
-            if (vertices.empty() || faces.empty()) {
-                FBXImporter::LogWarn("ignoring empty geometry: " + mesh.Name());
-                return temp;
-            }
-
-            // one material per mesh maps easily to aiMesh. Multiple material
-            // meshes need to be split.
-            const MatIndexArray& mindices = mesh.GetMaterialIndices();
-            if (doc.Settings().readMaterials && !mindices.empty()) {
-                const MatIndexArray::value_type base = mindices[0];
-                for (MatIndexArray::value_type index : mindices) {
-                    if (index != base) {
-                        return ConvertMeshMultiMaterial(mesh, model, node_global_transform, nd);
-                    }
-                }
-            }
-
-            // faster code-path, just copy the data
-            temp.push_back(ConvertMeshSingleMaterial(mesh, model, node_global_transform, nd));
-            return temp;
-        }
-
-        std::vector<unsigned int> FBXConverter::ConvertLine(const LineGeometry& line, const Model& model,
-            const aiMatrix4x4& node_global_transform, aiNode& nd)
-        {
-            std::vector<unsigned int> temp;
-
-            const std::vector<aiVector3D>& vertices = line.GetVertices();
-            const std::vector<int>& indices = line.GetIndices();
-            if (vertices.empty() || indices.empty()) {
-                FBXImporter::LogWarn("ignoring empty line: " + line.Name());
-                return temp;
-            }
-
-            aiMesh* const out_mesh = SetupEmptyMesh(line, nd);
-            out_mesh->mPrimitiveTypes |= aiPrimitiveType_LINE;
-
-            // copy vertices
-            out_mesh->mNumVertices = static_cast<unsigned int>(vertices.size());
-            out_mesh->mVertices = new aiVector3D[out_mesh->mNumVertices];
-            std::copy(vertices.begin(), vertices.end(), out_mesh->mVertices);
-
-            //Number of line segments (faces) is "Number of Points - Number of Endpoints"
-            //N.B.: Endpoints in FbxLine are denoted by negative indices.
-            //If such an Index is encountered, add 1 and multiply by -1 to get the real index.
-            unsigned int epcount = 0;
-            for (unsigned i = 0; i < indices.size(); i++)
-            {
-                if (indices[i] < 0) {
-                    epcount++;
-                }
-            }
-            unsigned int pcount = static_cast<unsigned int>( indices.size() );
-            unsigned int scount = out_mesh->mNumFaces = pcount - epcount;
-
-            aiFace* fac = out_mesh->mFaces = new aiFace[scount]();
-            for (unsigned int i = 0; i < pcount; ++i) {
-                if (indices[i] < 0) continue;
-                aiFace& f = *fac++;
-                f.mNumIndices = 2; //2 == aiPrimitiveType_LINE 
-                f.mIndices = new unsigned int[2];
-                f.mIndices[0] = indices[i];
-                int segid = indices[(i + 1 == pcount ? 0 : i + 1)];   //If we have reached he last point, wrap around
-                f.mIndices[1] = (segid < 0 ? (segid + 1)*-1 : segid); //Convert EndPoint Index to normal Index
-            }
-            temp.push_back(static_cast<unsigned int>(meshes.size() - 1));
-            return temp;
-        }
-
-        aiMesh* FBXConverter::SetupEmptyMesh(const Geometry& mesh, aiNode& nd)
-        {
-            aiMesh* const out_mesh = new aiMesh();
-            meshes.push_back(out_mesh);
-            meshes_converted[&mesh].push_back(static_cast<unsigned int>(meshes.size() - 1));
-
-            // set name
-            std::string name = mesh.Name();
-            if (name.substr(0, 10) == "Geometry::") {
-                name = name.substr(10);
-            }
-
-            if (name.length()) {
-                out_mesh->mName.Set(name);
-            }
-            else
-            {
-                out_mesh->mName = nd.mName;
-            }
-
-            return out_mesh;
-        }
-
-        unsigned int FBXConverter::ConvertMeshSingleMaterial(const MeshGeometry& mesh, const Model& model,
-            const aiMatrix4x4& node_global_transform, aiNode& nd)
-        {
-            const MatIndexArray& mindices = mesh.GetMaterialIndices();
-            aiMesh* const out_mesh = SetupEmptyMesh(mesh, nd);
-
-            const std::vector<aiVector3D>& vertices = mesh.GetVertices();
-            const std::vector<unsigned int>& faces = mesh.GetFaceIndexCounts();
-
-            // copy vertices
-            out_mesh->mNumVertices = static_cast<unsigned int>(vertices.size());
-            out_mesh->mVertices = new aiVector3D[vertices.size()];
-
-            std::copy(vertices.begin(), vertices.end(), out_mesh->mVertices);
-
-            // generate dummy faces
-            out_mesh->mNumFaces = static_cast<unsigned int>(faces.size());
-            aiFace* fac = out_mesh->mFaces = new aiFace[faces.size()]();
-
-            unsigned int cursor = 0;
-            for (unsigned int pcount : faces) {
-                aiFace& f = *fac++;
-                f.mNumIndices = pcount;
-                f.mIndices = new unsigned int[pcount];
-                switch (pcount)
-                {
-                case 1:
-                    out_mesh->mPrimitiveTypes |= aiPrimitiveType_POINT;
-                    break;
-                case 2:
-                    out_mesh->mPrimitiveTypes |= aiPrimitiveType_LINE;
-                    break;
-                case 3:
-                    out_mesh->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
-                    break;
-                default:
-                    out_mesh->mPrimitiveTypes |= aiPrimitiveType_POLYGON;
-                    break;
-                }
-                for (unsigned int i = 0; i < pcount; ++i) {
-                    f.mIndices[i] = cursor++;
-                }
-            }
-
-            // copy normals
-            const std::vector<aiVector3D>& normals = mesh.GetNormals();
-            if (normals.size()) {
-                ai_assert(normals.size() == vertices.size());
-
-                out_mesh->mNormals = new aiVector3D[vertices.size()];
-                std::copy(normals.begin(), normals.end(), out_mesh->mNormals);
-            }
-
-            // copy tangents - assimp requires both tangents and bitangents (binormals)
-            // to be present, or neither of them. Compute binormals from normals
-            // and tangents if needed.
-            const std::vector<aiVector3D>& tangents = mesh.GetTangents();
-            const std::vector<aiVector3D>* binormals = &mesh.GetBinormals();
-
-            if (tangents.size()) {
-                std::vector<aiVector3D> tempBinormals;
-                if (!binormals->size()) {
-                    if (normals.size()) {
-                        tempBinormals.resize(normals.size());
-                        for (unsigned int i = 0; i < tangents.size(); ++i) {
-                            tempBinormals[i] = normals[i] ^ tangents[i];
-                        }
-
-                        binormals = &tempBinormals;
-                    }
-                    else {
-                        binormals = NULL;
-                    }
-                }
-
-                if (binormals) {
-                    ai_assert(tangents.size() == vertices.size());
-                    ai_assert(binormals->size() == vertices.size());
-
-                    out_mesh->mTangents = new aiVector3D[vertices.size()];
-                    std::copy(tangents.begin(), tangents.end(), out_mesh->mTangents);
-
-                    out_mesh->mBitangents = new aiVector3D[vertices.size()];
-                    std::copy(binormals->begin(), binormals->end(), out_mesh->mBitangents);
-                }
-            }
-
-            // copy texture coords
-            for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
-                const std::vector<aiVector2D>& uvs = mesh.GetTextureCoords(i);
-                if (uvs.empty()) {
-                    break;
-                }
-
-                aiVector3D* out_uv = out_mesh->mTextureCoords[i] = new aiVector3D[vertices.size()];
-                for (const aiVector2D& v : uvs) {
-                    *out_uv++ = aiVector3D(v.x, v.y, 0.0f);
-                }
-
-                out_mesh->mNumUVComponents[i] = 2;
-            }
-
-            // copy vertex colors
-            for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_COLOR_SETS; ++i) {
-                const std::vector<aiColor4D>& colors = mesh.GetVertexColors(i);
-                if (colors.empty()) {
-                    break;
-                }
-
-                out_mesh->mColors[i] = new aiColor4D[vertices.size()];
-                std::copy(colors.begin(), colors.end(), out_mesh->mColors[i]);
-            }
-
-            if (!doc.Settings().readMaterials || mindices.empty()) {
-                FBXImporter::LogError("no material assigned to mesh, setting default material");
-                out_mesh->mMaterialIndex = GetDefaultMaterial();
-            }
-            else {
-                ConvertMaterialForMesh(out_mesh, model, mesh, mindices[0]);
-            }
-
-            if (doc.Settings().readWeights && mesh.DeformerSkin() != NULL) {
-                ConvertWeights(out_mesh, model, mesh, node_global_transform, NO_MATERIAL_SEPARATION);
-            }
-
-            std::vector<aiAnimMesh*> animMeshes;
-            for (const BlendShape* blendShape : mesh.GetBlendShapes()) {
-                for (const BlendShapeChannel* blendShapeChannel : blendShape->BlendShapeChannels()) {
-                    const std::vector<const ShapeGeometry*>& shapeGeometries = blendShapeChannel->GetShapeGeometries();
-                    for (size_t i = 0; i < shapeGeometries.size(); i++) {
-                        aiAnimMesh *animMesh = aiCreateAnimMesh(out_mesh);
-                        const ShapeGeometry* shapeGeometry = shapeGeometries.at(i);
-                        const std::vector<aiVector3D>& vertices = shapeGeometry->GetVertices();
-                        const std::vector<aiVector3D>& normals = shapeGeometry->GetNormals();
-                        const std::vector<unsigned int>& indices = shapeGeometry->GetIndices();
-                        animMesh->mName.Set(FixAnimMeshName(shapeGeometry->Name()));
-                        for (size_t j = 0; j < indices.size(); j++) {
-                            unsigned int index = indices.at(j);
-                            aiVector3D vertex = vertices.at(j);
-                            aiVector3D normal = normals.at(j);
-                            unsigned int count = 0;
-                            const unsigned int* outIndices = mesh.ToOutputVertexIndex(index, count);
-                            for (unsigned int k = 0; k < count; k++) {
-                                unsigned int index = outIndices[k];
-                                animMesh->mVertices[index] += vertex;
-                                if (animMesh->mNormals != nullptr) {
-                                    animMesh->mNormals[index] += normal;
-                                    animMesh->mNormals[index].NormalizeSafe();
-                                }
-                            }
-                        }
-                        animMesh->mWeight = shapeGeometries.size() > 1 ? blendShapeChannel->DeformPercent() / 100.0f : 1.0f;
-                        animMeshes.push_back(animMesh);
-                    }
-                }
-            }
-            const size_t numAnimMeshes = animMeshes.size();
-            if (numAnimMeshes > 0) {
-                out_mesh->mNumAnimMeshes = static_cast<unsigned int>(numAnimMeshes);
-                out_mesh->mAnimMeshes = new aiAnimMesh*[numAnimMeshes];
-                for (size_t i = 0; i < numAnimMeshes; i++) {
-                    out_mesh->mAnimMeshes[i] = animMeshes.at(i);
-                }
-            }
-            return static_cast<unsigned int>(meshes.size() - 1);
-        }
-
-        std::vector<unsigned int> FBXConverter::ConvertMeshMultiMaterial(const MeshGeometry& mesh, const Model& model,
-            const aiMatrix4x4& node_global_transform, aiNode& nd)
-        {
-            const MatIndexArray& mindices = mesh.GetMaterialIndices();
-            ai_assert(mindices.size());
-
-            std::set<MatIndexArray::value_type> had;
-            std::vector<unsigned int> indices;
-
-            for (MatIndexArray::value_type index : mindices) {
-                if (had.find(index) == had.end()) {
-
-                    indices.push_back(ConvertMeshMultiMaterial(mesh, model, index, node_global_transform, nd));
-                    had.insert(index);
-                }
-            }
-
-            return indices;
-        }
-
-        unsigned int FBXConverter::ConvertMeshMultiMaterial(const MeshGeometry& mesh, const Model& model,
-            MatIndexArray::value_type index,
-            const aiMatrix4x4& node_global_transform,
-            aiNode& nd)
-        {
-            aiMesh* const out_mesh = SetupEmptyMesh(mesh, nd);
-
-            const MatIndexArray& mindices = mesh.GetMaterialIndices();
-            const std::vector<aiVector3D>& vertices = mesh.GetVertices();
-            const std::vector<unsigned int>& faces = mesh.GetFaceIndexCounts();
-
-            const bool process_weights = doc.Settings().readWeights && mesh.DeformerSkin() != NULL;
-
-            unsigned int count_faces = 0;
-            unsigned int count_vertices = 0;
-
-            // count faces
-            std::vector<unsigned int>::const_iterator itf = faces.begin();
-            for (MatIndexArray::const_iterator it = mindices.begin(),
-                end = mindices.end(); it != end; ++it, ++itf)
-            {
-                if ((*it) != index) {
-                    continue;
-                }
-                ++count_faces;
-                count_vertices += *itf;
-            }
-
-            ai_assert(count_faces);
-            ai_assert(count_vertices);
-
-            // mapping from output indices to DOM indexing, needed to resolve weights or blendshapes
-            std::vector<unsigned int> reverseMapping;
-            std::map<unsigned int, unsigned int> translateIndexMap;
-            if (process_weights || mesh.GetBlendShapes().size() > 0) {
-                reverseMapping.resize(count_vertices);
-            }
-
-            // allocate output data arrays, but don't fill them yet
-            out_mesh->mNumVertices = count_vertices;
-            out_mesh->mVertices = new aiVector3D[count_vertices];
-
-            out_mesh->mNumFaces = count_faces;
-            aiFace* fac = out_mesh->mFaces = new aiFace[count_faces]();
-
-
-            // allocate normals
-            const std::vector<aiVector3D>& normals = mesh.GetNormals();
-            if (normals.size()) {
-                ai_assert(normals.size() == vertices.size());
-                out_mesh->mNormals = new aiVector3D[vertices.size()];
-            }
-
-            // allocate tangents, binormals.
-            const std::vector<aiVector3D>& tangents = mesh.GetTangents();
-            const std::vector<aiVector3D>* binormals = &mesh.GetBinormals();
-            std::vector<aiVector3D> tempBinormals;
-
-            if (tangents.size()) {
-                if (!binormals->size()) {
-                    if (normals.size()) {
-                        // XXX this computes the binormals for the entire mesh, not only
-                        // the part for which we need them.
-                        tempBinormals.resize(normals.size());
-                        for (unsigned int i = 0; i < tangents.size(); ++i) {
-                            tempBinormals[i] = normals[i] ^ tangents[i];
-                        }
-
-                        binormals = &tempBinormals;
-                    }
-                    else {
-                        binormals = NULL;
-                    }
-                }
-
-                if (binormals) {
-                    ai_assert(tangents.size() == vertices.size() && binormals->size() == vertices.size());
-
-                    out_mesh->mTangents = new aiVector3D[vertices.size()];
-                    out_mesh->mBitangents = new aiVector3D[vertices.size()];
-                }
-            }
-
-            // allocate texture coords
-            unsigned int num_uvs = 0;
-            for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i, ++num_uvs) {
-                const std::vector<aiVector2D>& uvs = mesh.GetTextureCoords(i);
-                if (uvs.empty()) {
-                    break;
-                }
-
-                out_mesh->mTextureCoords[i] = new aiVector3D[vertices.size()];
-                out_mesh->mNumUVComponents[i] = 2;
-            }
-
-            // allocate vertex colors
-            unsigned int num_vcs = 0;
-            for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_COLOR_SETS; ++i, ++num_vcs) {
-                const std::vector<aiColor4D>& colors = mesh.GetVertexColors(i);
-                if (colors.empty()) {
-                    break;
-                }
-
-                out_mesh->mColors[i] = new aiColor4D[vertices.size()];
-            }
-
-            unsigned int cursor = 0, in_cursor = 0;
-
-            itf = faces.begin();
-            for (MatIndexArray::const_iterator it = mindices.begin(), end = mindices.end(); it != end; ++it, ++itf)
-            {
-                const unsigned int pcount = *itf;
-                if ((*it) != index) {
-                    in_cursor += pcount;
-                    continue;
-                }
-
-                aiFace& f = *fac++;
-
-                f.mNumIndices = pcount;
-                f.mIndices = new unsigned int[pcount];
-                switch (pcount)
-                {
-                case 1:
-                    out_mesh->mPrimitiveTypes |= aiPrimitiveType_POINT;
-                    break;
-                case 2:
-                    out_mesh->mPrimitiveTypes |= aiPrimitiveType_LINE;
-                    break;
-                case 3:
-                    out_mesh->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
-                    break;
-                default:
-                    out_mesh->mPrimitiveTypes |= aiPrimitiveType_POLYGON;
-                    break;
-                }
-                for (unsigned int i = 0; i < pcount; ++i, ++cursor, ++in_cursor) {
-                    f.mIndices[i] = cursor;
-
-                    if (reverseMapping.size()) {
-                        reverseMapping[cursor] = in_cursor;
-                        translateIndexMap[in_cursor] = cursor;
-                    }
-
-                    out_mesh->mVertices[cursor] = vertices[in_cursor];
-
-                    if (out_mesh->mNormals) {
-                        out_mesh->mNormals[cursor] = normals[in_cursor];
-                    }
-
-                    if (out_mesh->mTangents) {
-                        out_mesh->mTangents[cursor] = tangents[in_cursor];
-                        out_mesh->mBitangents[cursor] = (*binormals)[in_cursor];
-                    }
-
-                    for (unsigned int j = 0; j < num_uvs; ++j) {
-                        const std::vector<aiVector2D>& uvs = mesh.GetTextureCoords(j);
-                        out_mesh->mTextureCoords[j][cursor] = aiVector3D(uvs[in_cursor].x, uvs[in_cursor].y, 0.0f);
-                    }
-
-                    for (unsigned int j = 0; j < num_vcs; ++j) {
-                        const std::vector<aiColor4D>& cols = mesh.GetVertexColors(j);
-                        out_mesh->mColors[j][cursor] = cols[in_cursor];
-                    }
-                }
-            }
-
-            ConvertMaterialForMesh(out_mesh, model, mesh, index);
-
-            if (process_weights) {
-                ConvertWeights(out_mesh, model, mesh, node_global_transform, index, &reverseMapping);
-            }
-
-            std::vector<aiAnimMesh*> animMeshes;
-            for (const BlendShape* blendShape : mesh.GetBlendShapes()) {
-                for (const BlendShapeChannel* blendShapeChannel : blendShape->BlendShapeChannels()) {
-                    const std::vector<const ShapeGeometry*>& shapeGeometries = blendShapeChannel->GetShapeGeometries();
-                    for (size_t i = 0; i < shapeGeometries.size(); i++) {
-                        aiAnimMesh* animMesh = aiCreateAnimMesh(out_mesh);
-                        const ShapeGeometry* shapeGeometry = shapeGeometries.at(i);
-                        const std::vector<aiVector3D>& vertices = shapeGeometry->GetVertices();
-                        const std::vector<aiVector3D>& normals = shapeGeometry->GetNormals();
-                        const std::vector<unsigned int>& indices = shapeGeometry->GetIndices();
-                        animMesh->mName.Set(FixAnimMeshName(shapeGeometry->Name()));
-                        for (size_t j = 0; j < indices.size(); j++) {
-                            unsigned int index = indices.at(j);
-                            aiVector3D vertex = vertices.at(j);
-                            aiVector3D normal = normals.at(j);
-                            unsigned int count = 0;
-                            const unsigned int* outIndices = mesh.ToOutputVertexIndex(index, count);
-                            for (unsigned int k = 0; k < count; k++) {
-                                unsigned int outIndex = outIndices[k];
-                                if (translateIndexMap.find(outIndex) == translateIndexMap.end())
-                                    continue;
-                                unsigned int index = translateIndexMap[outIndex];
-                                animMesh->mVertices[index] += vertex;
-                                if (animMesh->mNormals != nullptr) {
-                                    animMesh->mNormals[index] += normal;
-                                    animMesh->mNormals[index].NormalizeSafe();
-                                }
-                            }
-                        }
-                        animMesh->mWeight = shapeGeometries.size() > 1 ? blendShapeChannel->DeformPercent() / 100.0f : 1.0f;
-                        animMeshes.push_back(animMesh);
-                    }
-                }
-            }
-
-            const size_t numAnimMeshes = animMeshes.size();
-            if (numAnimMeshes > 0) {
-                out_mesh->mNumAnimMeshes = static_cast<unsigned int>(numAnimMeshes);
-                out_mesh->mAnimMeshes = new aiAnimMesh*[numAnimMeshes];
-                for (size_t i = 0; i < numAnimMeshes; i++) {
-                    out_mesh->mAnimMeshes[i] = animMeshes.at(i);
-                }
-            }
-
-            return static_cast<unsigned int>(meshes.size() - 1);
-        }
-
-        void FBXConverter::ConvertWeights(aiMesh* out, const Model& model, const MeshGeometry& geo,
-            const aiMatrix4x4& node_global_transform,
-            unsigned int materialIndex,
-            std::vector<unsigned int>* outputVertStartIndices)
-        {
-            ai_assert(geo.DeformerSkin());
-
-            std::vector<size_t> out_indices;
-            std::vector<size_t> index_out_indices;
-            std::vector<size_t> count_out_indices;
-
-            const Skin& sk = *geo.DeformerSkin();
-
-            std::vector<aiBone*> bones;
-            bones.reserve(sk.Clusters().size());
-
-            const bool no_mat_check = materialIndex == NO_MATERIAL_SEPARATION;
-            ai_assert(no_mat_check || outputVertStartIndices);
-
-            try {
-
-                for (const Cluster* cluster : sk.Clusters()) {
-                    ai_assert(cluster);
-
-                    const WeightIndexArray& indices = cluster->GetIndices();
-
-                    const MatIndexArray& mats = geo.GetMaterialIndices();
-
-                    const size_t no_index_sentinel = std::numeric_limits<size_t>::max();
-
-                    count_out_indices.clear();
-                    index_out_indices.clear();
-                    out_indices.clear();
-
-                    // now check if *any* of these weights is contained in the output mesh,
-                    // taking notes so we don't need to do it twice.
-                    for (WeightIndexArray::value_type index : indices) {
-
-                        unsigned int count = 0;
-                        const unsigned int* const out_idx = geo.ToOutputVertexIndex(index, count);
-                        // ToOutputVertexIndex only returns NULL if index is out of bounds
-                        // which should never happen
-                        ai_assert(out_idx != NULL);
-
-                        index_out_indices.push_back(no_index_sentinel);
-                        count_out_indices.push_back(0);
-
-                        for (unsigned int i = 0; i < count; ++i) {
-                            if (no_mat_check || static_cast<size_t>(mats[geo.FaceForVertexIndex(out_idx[i])]) == materialIndex) {
-
-                                if (index_out_indices.back() == no_index_sentinel) {
-                                    index_out_indices.back() = out_indices.size();
-                                }
-
-                                if (no_mat_check) {
-                                    out_indices.push_back(out_idx[i]);
-                                } else {
-                                    // this extra lookup is in O(logn), so the entire algorithm becomes O(nlogn)
-                                    const std::vector<unsigned int>::iterator it = std::lower_bound(
-                                        outputVertStartIndices->begin(),
-                                        outputVertStartIndices->end(),
-                                        out_idx[i]
-                                    );
-
-                                    out_indices.push_back(std::distance(outputVertStartIndices->begin(), it));
-                                }
-
-                                ++count_out_indices.back();                               
-                            }
-                        }
-                    }
-                    
-                    // if we found at least one, generate the output bones
-                    // XXX this could be heavily simplified by collecting the bone
-                    // data in a single step.
-                    ConvertCluster(bones, model, *cluster, out_indices, index_out_indices,
-                            count_out_indices, node_global_transform);
-                }
-            }
-            catch (std::exception&) {
-                std::for_each(bones.begin(), bones.end(), Util::delete_fun<aiBone>());
-                throw;
-            }
-
-            if (bones.empty()) {
-                return;
-            }
-
-            out->mBones = new aiBone*[bones.size()]();
-            out->mNumBones = static_cast<unsigned int>(bones.size());
-
-            std::swap_ranges(bones.begin(), bones.end(), out->mBones);
-        }
-
-        void FBXConverter::ConvertCluster(std::vector<aiBone*>& bones, const Model& /*model*/, const Cluster& cl,
-            std::vector<size_t>& out_indices,
-            std::vector<size_t>& index_out_indices,
-            std::vector<size_t>& count_out_indices,
-            const aiMatrix4x4& node_global_transform)
-        {
-
-            aiBone* const bone = new aiBone();
-            bones.push_back(bone);
-
-            bone->mName = FixNodeName(cl.TargetNode()->Name());
-
-            bone->mOffsetMatrix = cl.TransformLink();
-            bone->mOffsetMatrix.Inverse();
-
-            bone->mOffsetMatrix = bone->mOffsetMatrix * node_global_transform;
-
-            bone->mNumWeights = static_cast<unsigned int>(out_indices.size());
-            aiVertexWeight* cursor = bone->mWeights = new aiVertexWeight[out_indices.size()];
-
-            const size_t no_index_sentinel = std::numeric_limits<size_t>::max();
-            const WeightArray& weights = cl.GetWeights();
-
-            const size_t c = index_out_indices.size();
-            for (size_t i = 0; i < c; ++i) {
-                const size_t index_index = index_out_indices[i];
-
-                if (index_index == no_index_sentinel) {
-                    continue;
-                }
-
-                const size_t cc = count_out_indices[i];
-                for (size_t j = 0; j < cc; ++j) {
-                    aiVertexWeight& out_weight = *cursor++;
-
-                    out_weight.mVertexId = static_cast<unsigned int>(out_indices[index_index + j]);
-                    out_weight.mWeight = weights[i];
-                }
-            }
-        }
-
-        void FBXConverter::ConvertMaterialForMesh(aiMesh* out, const Model& model, const MeshGeometry& geo,
-            MatIndexArray::value_type materialIndex)
-        {
-            // locate source materials for this mesh
-            const std::vector<const Material*>& mats = model.GetMaterials();
-            if (static_cast<unsigned int>(materialIndex) >= mats.size() || materialIndex < 0) {
-                FBXImporter::LogError("material index out of bounds, setting default material");
-                out->mMaterialIndex = GetDefaultMaterial();
-                return;
-            }
-
-            const Material* const mat = mats[materialIndex];
-            MaterialMap::const_iterator it = materials_converted.find(mat);
-            if (it != materials_converted.end()) {
-                out->mMaterialIndex = (*it).second;
-                return;
-            }
-
-            out->mMaterialIndex = ConvertMaterial(*mat, &geo);
-            materials_converted[mat] = out->mMaterialIndex;
-        }
-
-        unsigned int FBXConverter::GetDefaultMaterial()
-        {
-            if (defaultMaterialIndex) {
-                return defaultMaterialIndex - 1;
-            }
-
-            aiMaterial* out_mat = new aiMaterial();
-            materials.push_back(out_mat);
-
-            const aiColor3D diffuse = aiColor3D(0.8f, 0.8f, 0.8f);
-            out_mat->AddProperty(&diffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
-
-            aiString s;
-            s.Set(AI_DEFAULT_MATERIAL_NAME);
-
-            out_mat->AddProperty(&s, AI_MATKEY_NAME);
-
-            defaultMaterialIndex = static_cast<unsigned int>(materials.size());
-            return defaultMaterialIndex - 1;
-        }
-
-
-        unsigned int FBXConverter::ConvertMaterial(const Material& material, const MeshGeometry* const mesh)
-        {
-            const PropertyTable& props = material.Props();
-
-            // generate empty output material
-            aiMaterial* out_mat = new aiMaterial();
-            materials_converted[&material] = static_cast<unsigned int>(materials.size());
-
-            materials.push_back(out_mat);
-
-            aiString str;
-
-            // strip Material:: prefix
-            std::string name = material.Name();
-            if (name.substr(0, 10) == "Material::") {
-                name = name.substr(10);
-            }
-
-            // set material name if not empty - this could happen
-            // and there should be no key for it in this case.
-            if (name.length()) {
-                str.Set(name);
-                out_mat->AddProperty(&str, AI_MATKEY_NAME);
-            }
-
-            // Set the shading mode as best we can: The FBX specification only mentions Lambert and Phong, and only Phong is mentioned in Assimp's aiShadingMode enum.
-            if (material.GetShadingModel() == "phong")
-            {
-                aiShadingMode shadingMode = aiShadingMode_Phong;
-                out_mat->AddProperty<aiShadingMode>(&shadingMode, 1, AI_MATKEY_SHADING_MODEL);               
-            }
-
-            // shading stuff and colors
-            SetShadingPropertiesCommon(out_mat, props);
-            SetShadingPropertiesRaw( out_mat, props, material.Textures(), mesh );
-
-            // texture assignments
-            SetTextureProperties(out_mat, material.Textures(), mesh);
-            SetTextureProperties(out_mat, material.LayeredTextures(), mesh);
-
-            return static_cast<unsigned int>(materials.size() - 1);
-        }
-
-        unsigned int FBXConverter::ConvertVideo(const Video& video)
-        {
-            // generate empty output texture
-            aiTexture* out_tex = new aiTexture();
-            textures.push_back(out_tex);
-
-            // assuming the texture is compressed
-            out_tex->mWidth = static_cast<unsigned int>(video.ContentLength()); // total data size
-            out_tex->mHeight = 0; // fixed to 0
-
-            // steal the data from the Video to avoid an additional copy
-            out_tex->pcData = reinterpret_cast<aiTexel*>(const_cast<Video&>(video).RelinquishContent());
-
-            // try to extract a hint from the file extension
-            const std::string& filename = video.RelativeFilename().empty() ? video.FileName() : video.RelativeFilename();
-            std::string ext = BaseImporter::GetExtension(filename);
-
-            if (ext == "jpeg") {
-                ext = "jpg";
-            }
-
-            if (ext.size() <= 3) {
-                memcpy(out_tex->achFormatHint, ext.c_str(), ext.size());
-            }
-
-            out_tex->mFilename.Set(filename.c_str());
-
-            return static_cast<unsigned int>(textures.size() - 1);
-        }
-
-        aiString FBXConverter::GetTexturePath(const Texture* tex)
-        {
-            aiString path;
-            path.Set(tex->RelativeFilename());
-
-            const Video* media = tex->Media();
-            if (media != nullptr) {
-                bool textureReady = false; //tells if our texture is ready (if it was loaded or if it was found)
-                unsigned int index;
-
-                VideoMap::const_iterator it = textures_converted.find(media);
-                if (it != textures_converted.end()) {
-                    index = (*it).second;
-                    textureReady = true;
-                }
-                else {
-                    if (media->ContentLength() > 0) {
-                        index = ConvertVideo(*media);
-                        textures_converted[media] = index;
-                        textureReady = true;
-                    }
-                }
-
-                // setup texture reference string (copied from ColladaLoader::FindFilenameForEffectTexture), if the texture is ready
-                if (doc.Settings().useLegacyEmbeddedTextureNaming) {
-                    if (textureReady) {
-                        // TODO: check the possibility of using the flag "AI_CONFIG_IMPORT_FBX_EMBEDDED_TEXTURES_LEGACY_NAMING"
-                        // In FBX files textures are now stored internally by Assimp with their filename included
-                        // Now Assimp can lookup through the loaded textures after all data is processed
-                        // We need to load all textures before referencing them, as FBX file format order may reference a texture before loading it
-                        // This may occur on this case too, it has to be studied
-                        path.data[0] = '*';
-                        path.length = 1 + ASSIMP_itoa10(path.data + 1, MAXLEN - 1, index);
-                    }
-                }
-            }
-
-            return path;
-        }
-
-        void FBXConverter::TrySetTextureProperties(aiMaterial* out_mat, const TextureMap& textures,
-                const std::string& propName,
-                aiTextureType target, const MeshGeometry* const mesh) {
-            TextureMap::const_iterator it = textures.find(propName);
-            if (it == textures.end()) {
-                return;
-            }
-
-            const Texture* const tex = (*it).second;
-            if (tex != 0)
-            {
-                aiString path = GetTexturePath(tex);
-                out_mat->AddProperty(&path, _AI_MATKEY_TEXTURE_BASE, target, 0);
-
-                aiUVTransform uvTrafo;
-                // XXX handle all kinds of UV transformations
-                uvTrafo.mScaling = tex->UVScaling();
-                uvTrafo.mTranslation = tex->UVTranslation();
-                out_mat->AddProperty(&uvTrafo, 1, _AI_MATKEY_UVTRANSFORM_BASE, target, 0);
-
-                const PropertyTable& props = tex->Props();
-
-                int uvIndex = 0;
-
-                bool ok;
-                const std::string& uvSet = PropertyGet<std::string>(props, "UVSet", ok);
-                if (ok) {
-                    // "default" is the name which usually appears in the FbxFileTexture template
-                    if (uvSet != "default" && uvSet.length()) {
-                        // this is a bit awkward - we need to find a mesh that uses this
-                        // material and scan its UV channels for the given UV name because
-                        // assimp references UV channels by index, not by name.
-
-                        // XXX: the case that UV channels may appear in different orders
-                        // in meshes is unhandled. A possible solution would be to sort
-                        // the UV channels alphabetically, but this would have the side
-                        // effect that the primary (first) UV channel would sometimes
-                        // be moved, causing trouble when users read only the first
-                        // UV channel and ignore UV channel assignments altogether.
-
-                        const unsigned int matIndex = static_cast<unsigned int>(std::distance(materials.begin(),
-                            std::find(materials.begin(), materials.end(), out_mat)
-                        ));
-
-
-                        uvIndex = -1;
-                        if (!mesh)
-                        {
-                            for (const MeshMap::value_type& v : meshes_converted) {
-                                const MeshGeometry* const meshGeom = dynamic_cast<const MeshGeometry*> (v.first);
-                                if (!meshGeom) {
-                                    continue;
-                                }
-
-                                const MatIndexArray& mats = meshGeom->GetMaterialIndices();
-                                if (std::find(mats.begin(), mats.end(), matIndex) == mats.end()) {
-                                    continue;
-                                }
-
-                                int index = -1;
-                                for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
-                                    if (meshGeom->GetTextureCoords(i).empty()) {
-                                        break;
-                                    }
-                                    const std::string& name = meshGeom->GetTextureCoordChannelName(i);
-                                    if (name == uvSet) {
-                                        index = static_cast<int>(i);
-                                        break;
-                                    }
-                                }
-                                if (index == -1) {
-                                    FBXImporter::LogWarn("did not find UV channel named " + uvSet + " in a mesh using this material");
-                                    continue;
-                                }
-
-                                if (uvIndex == -1) {
-                                    uvIndex = index;
-                                }
-                                else {
-                                    FBXImporter::LogWarn("the UV channel named " + uvSet +
-                                        " appears at different positions in meshes, results will be wrong");
-                                }
-                            }
-                        }
-                        else
-                        {
-                            int index = -1;
-                            for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
-                                if (mesh->GetTextureCoords(i).empty()) {
-                                    break;
-                                }
-                                const std::string& name = mesh->GetTextureCoordChannelName(i);
-                                if (name == uvSet) {
-                                    index = static_cast<int>(i);
-                                    break;
-                                }
-                            }
-                            if (index == -1) {
-                                FBXImporter::LogWarn("did not find UV channel named " + uvSet + " in a mesh using this material");
-                            }
-
-                            if (uvIndex == -1) {
-                                uvIndex = index;
-                            }
-                        }
-
-                        if (uvIndex == -1) {
-                            FBXImporter::LogWarn("failed to resolve UV channel " + uvSet + ", using first UV channel");
-                            uvIndex = 0;
-                        }
-                    }
-                }
-
-                out_mat->AddProperty(&uvIndex, 1, _AI_MATKEY_UVWSRC_BASE, target, 0);
-            }
-        }
-
-        void FBXConverter::TrySetTextureProperties(aiMaterial* out_mat, const LayeredTextureMap& layeredTextures,
-            const std::string& propName,
-            aiTextureType target, const MeshGeometry* const mesh) {
-            LayeredTextureMap::const_iterator it = layeredTextures.find(propName);
-            if (it == layeredTextures.end()) {
-                return;
-            }
-
-            int texCount = (*it).second->textureCount();
-
-            // Set the blend mode for layered textures
-            int blendmode = (*it).second->GetBlendMode();
-            out_mat->AddProperty(&blendmode, 1, _AI_MATKEY_TEXOP_BASE, target, 0);
-
-            for (int texIndex = 0; texIndex < texCount; texIndex++) {
-
-                const Texture* const tex = (*it).second->getTexture(texIndex);
-
-                aiString path = GetTexturePath(tex);
-                out_mat->AddProperty(&path, _AI_MATKEY_TEXTURE_BASE, target, texIndex);
-
-                aiUVTransform uvTrafo;
-                // XXX handle all kinds of UV transformations
-                uvTrafo.mScaling = tex->UVScaling();
-                uvTrafo.mTranslation = tex->UVTranslation();
-                out_mat->AddProperty(&uvTrafo, 1, _AI_MATKEY_UVTRANSFORM_BASE, target, texIndex);
-
-                const PropertyTable& props = tex->Props();
-
-                int uvIndex = 0;
-
-                bool ok;
-                const std::string& uvSet = PropertyGet<std::string>(props, "UVSet", ok);
-                if (ok) {
-                    // "default" is the name which usually appears in the FbxFileTexture template
-                    if (uvSet != "default" && uvSet.length()) {
-                        // this is a bit awkward - we need to find a mesh that uses this
-                        // material and scan its UV channels for the given UV name because
-                        // assimp references UV channels by index, not by name.
-
-                        // XXX: the case that UV channels may appear in different orders
-                        // in meshes is unhandled. A possible solution would be to sort
-                        // the UV channels alphabetically, but this would have the side
-                        // effect that the primary (first) UV channel would sometimes
-                        // be moved, causing trouble when users read only the first
-                        // UV channel and ignore UV channel assignments altogether.
-
-                        const unsigned int matIndex = static_cast<unsigned int>(std::distance(materials.begin(),
-                            std::find(materials.begin(), materials.end(), out_mat)
-                        ));
-
-                        uvIndex = -1;
-                        if (!mesh)
-                        {
-                            for (const MeshMap::value_type& v : meshes_converted) {
-                                const MeshGeometry* const meshGeom = dynamic_cast<const MeshGeometry*> (v.first);
-                                if (!meshGeom) {
-                                    continue;
-                                }
-
-                                const MatIndexArray& mats = meshGeom->GetMaterialIndices();
-                                if (std::find(mats.begin(), mats.end(), matIndex) == mats.end()) {
-                                    continue;
-                                }
-
-                                int index = -1;
-                                for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
-                                    if (meshGeom->GetTextureCoords(i).empty()) {
-                                        break;
-                                    }
-                                    const std::string& name = meshGeom->GetTextureCoordChannelName(i);
-                                    if (name == uvSet) {
-                                        index = static_cast<int>(i);
-                                        break;
-                                    }
-                                }
-                                if (index == -1) {
-                                    FBXImporter::LogWarn("did not find UV channel named " + uvSet + " in a mesh using this material");
-                                    continue;
-                                }
-
-                                if (uvIndex == -1) {
-                                    uvIndex = index;
-                                }
-                                else {
-                                    FBXImporter::LogWarn("the UV channel named " + uvSet +
-                                        " appears at different positions in meshes, results will be wrong");
-                                }
-                            }
-                        }
-                        else
-                        {
-                            int index = -1;
-                            for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
-                                if (mesh->GetTextureCoords(i).empty()) {
-                                    break;
-                                }
-                                const std::string& name = mesh->GetTextureCoordChannelName(i);
-                                if (name == uvSet) {
-                                    index = static_cast<int>(i);
-                                    break;
-                                }
-                            }
-                            if (index == -1) {
-                                FBXImporter::LogWarn("did not find UV channel named " + uvSet + " in a mesh using this material");
-                            }
-
-                            if (uvIndex == -1) {
-                                uvIndex = index;
-                            }
-                        }
-
-                        if (uvIndex == -1) {
-                            FBXImporter::LogWarn("failed to resolve UV channel " + uvSet + ", using first UV channel");
-                            uvIndex = 0;
-                        }
-                    }
-                }
-
-                out_mat->AddProperty(&uvIndex, 1, _AI_MATKEY_UVWSRC_BASE, target, texIndex);
-            }
-        }
-
-        void FBXConverter::SetTextureProperties(aiMaterial* out_mat, const TextureMap& textures, const MeshGeometry* const mesh)
-        {
-            TrySetTextureProperties(out_mat, textures, "DiffuseColor", aiTextureType_DIFFUSE, mesh);
-            TrySetTextureProperties(out_mat, textures, "AmbientColor", aiTextureType_AMBIENT, mesh);
-            TrySetTextureProperties(out_mat, textures, "EmissiveColor", aiTextureType_EMISSIVE, mesh);
-            TrySetTextureProperties(out_mat, textures, "SpecularColor", aiTextureType_SPECULAR, mesh);
-            TrySetTextureProperties(out_mat, textures, "SpecularFactor", aiTextureType_SPECULAR, mesh);
-            TrySetTextureProperties(out_mat, textures, "TransparentColor", aiTextureType_OPACITY, mesh);
-            TrySetTextureProperties(out_mat, textures, "ReflectionColor", aiTextureType_REFLECTION, mesh);
-            TrySetTextureProperties(out_mat, textures, "DisplacementColor", aiTextureType_DISPLACEMENT, mesh);
-            TrySetTextureProperties(out_mat, textures, "NormalMap", aiTextureType_NORMALS, mesh);
-            TrySetTextureProperties(out_mat, textures, "Bump", aiTextureType_HEIGHT, mesh);
-            TrySetTextureProperties(out_mat, textures, "ShininessExponent", aiTextureType_SHININESS, mesh);
-			TrySetTextureProperties( out_mat, textures, "TransparencyFactor", aiTextureType_OPACITY, mesh );
-			TrySetTextureProperties( out_mat, textures, "EmissiveFactor", aiTextureType_EMISSIVE, mesh );
-            //Maya counterparts
-            TrySetTextureProperties(out_mat, textures, "Maya|DiffuseTexture", aiTextureType_DIFFUSE, mesh);
-            TrySetTextureProperties(out_mat, textures, "Maya|NormalTexture", aiTextureType_NORMALS, mesh);
-            TrySetTextureProperties(out_mat, textures, "Maya|SpecularTexture", aiTextureType_SPECULAR, mesh);
-            TrySetTextureProperties(out_mat, textures, "Maya|FalloffTexture", aiTextureType_OPACITY, mesh);
-            TrySetTextureProperties(out_mat, textures, "Maya|ReflectionMapTexture", aiTextureType_REFLECTION, mesh);
-            
-            // Maya PBR
-            TrySetTextureProperties(out_mat, textures, "Maya|baseColor|file", aiTextureType_BASE_COLOR, mesh);
-            TrySetTextureProperties(out_mat, textures, "Maya|normalCamera|file", aiTextureType_NORMAL_CAMERA, mesh);
-            TrySetTextureProperties(out_mat, textures, "Maya|emissionColor|file", aiTextureType_EMISSION_COLOR, mesh);
-            TrySetTextureProperties(out_mat, textures, "Maya|metalness|file", aiTextureType_METALNESS, mesh);
-            TrySetTextureProperties(out_mat, textures, "Maya|diffuseRoughness|file", aiTextureType_DIFFUSE_ROUGHNESS, mesh);
-            
-            // Maya stingray
-            TrySetTextureProperties(out_mat, textures, "Maya|TEX_color_map|file", aiTextureType_BASE_COLOR, mesh);
-            TrySetTextureProperties(out_mat, textures, "Maya|TEX_normal_map|file", aiTextureType_NORMAL_CAMERA, mesh);
-            TrySetTextureProperties(out_mat, textures, "Maya|TEX_emissive_map|file", aiTextureType_EMISSION_COLOR, mesh);
-            TrySetTextureProperties(out_mat, textures, "Maya|TEX_metallic_map|file", aiTextureType_METALNESS, mesh);
-            TrySetTextureProperties(out_mat, textures, "Maya|TEX_roughness_map|file", aiTextureType_DIFFUSE_ROUGHNESS, mesh);
-            TrySetTextureProperties(out_mat, textures, "Maya|TEX_ao_map|file", aiTextureType_AMBIENT_OCCLUSION, mesh);            
-        }
-
-        void FBXConverter::SetTextureProperties(aiMaterial* out_mat, const LayeredTextureMap& layeredTextures, const MeshGeometry* const mesh)
-        {
-            TrySetTextureProperties(out_mat, layeredTextures, "DiffuseColor", aiTextureType_DIFFUSE, mesh);
-            TrySetTextureProperties(out_mat, layeredTextures, "AmbientColor", aiTextureType_AMBIENT, mesh);
-            TrySetTextureProperties(out_mat, layeredTextures, "EmissiveColor", aiTextureType_EMISSIVE, mesh);
-            TrySetTextureProperties(out_mat, layeredTextures, "SpecularColor", aiTextureType_SPECULAR, mesh);
-            TrySetTextureProperties(out_mat, layeredTextures, "SpecularFactor", aiTextureType_SPECULAR, mesh);
-            TrySetTextureProperties(out_mat, layeredTextures, "TransparentColor", aiTextureType_OPACITY, mesh);
-            TrySetTextureProperties(out_mat, layeredTextures, "ReflectionColor", aiTextureType_REFLECTION, mesh);
-            TrySetTextureProperties(out_mat, layeredTextures, "DisplacementColor", aiTextureType_DISPLACEMENT, mesh);
-            TrySetTextureProperties(out_mat, layeredTextures, "NormalMap", aiTextureType_NORMALS, mesh);
-            TrySetTextureProperties(out_mat, layeredTextures, "Bump", aiTextureType_HEIGHT, mesh);
-            TrySetTextureProperties(out_mat, layeredTextures, "ShininessExponent", aiTextureType_SHININESS, mesh);
-			TrySetTextureProperties( out_mat, layeredTextures, "EmissiveFactor", aiTextureType_EMISSIVE, mesh );
-			TrySetTextureProperties( out_mat, layeredTextures, "TransparencyFactor", aiTextureType_OPACITY, mesh );
-        }
-
-        aiColor3D FBXConverter::GetColorPropertyFactored(const PropertyTable& props, const std::string& colorName,
-            const std::string& factorName, bool& result, bool useTemplate)
-        {
-            result = true;
-
-            bool ok;
-            aiVector3D BaseColor = PropertyGet<aiVector3D>(props, colorName, ok, useTemplate);
-            if (!ok) {
-                result = false;
-                return aiColor3D(0.0f, 0.0f, 0.0f);
-            }
-
-            // if no factor name, return the colour as is
-            if (factorName.empty()) {
-                return aiColor3D(BaseColor.x, BaseColor.y, BaseColor.z);
-            }
-
-            // otherwise it should be multiplied by the factor, if found.
-            float factor = PropertyGet<float>(props, factorName, ok, useTemplate);
-            if (ok) {
-                BaseColor *= factor;
-            }
-            return aiColor3D(BaseColor.x, BaseColor.y, BaseColor.z);
-        }
-
-        aiColor3D FBXConverter::GetColorPropertyFromMaterial(const PropertyTable& props, const std::string& baseName,
-            bool& result)
-        {
-            return GetColorPropertyFactored(props, baseName + "Color", baseName + "Factor", result, true);
-        }
-
-        aiColor3D FBXConverter::GetColorProperty(const PropertyTable& props, const std::string& colorName,
-            bool& result, bool useTemplate)
-        {
-            result = true;
-            bool ok;
-            const aiVector3D& ColorVec = PropertyGet<aiVector3D>(props, colorName, ok, useTemplate);
-            if (!ok) {
-                result = false;
-                return aiColor3D(0.0f, 0.0f, 0.0f);
-            }
-            return aiColor3D(ColorVec.x, ColorVec.y, ColorVec.z);
-        }
-
-        void FBXConverter::SetShadingPropertiesCommon(aiMaterial* out_mat, const PropertyTable& props)
-        {
-            // Set shading properties.
-            // Modern FBX Files have two separate systems for defining these,
-            // with only the more comprehensive one described in the property template.
-            // Likely the other values are a legacy system,
-            // which is still always exported by the official FBX SDK.
-            //
-            // Blender's FBX import and export mostly ignore this legacy system,
-            // and as we only support recent versions of FBX anyway, we can do the same.
-            bool ok;
-
-            const aiColor3D& Diffuse = GetColorPropertyFromMaterial(props, "Diffuse", ok);
-            if (ok) {
-                out_mat->AddProperty(&Diffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
-            }
-
-            const aiColor3D& Emissive = GetColorPropertyFromMaterial(props, "Emissive", ok);
-            if (ok) {
-                out_mat->AddProperty(&Emissive, 1, AI_MATKEY_COLOR_EMISSIVE);
-            }
-
-            const aiColor3D& Ambient = GetColorPropertyFromMaterial(props, "Ambient", ok);
-            if (ok) {
-                out_mat->AddProperty(&Ambient, 1, AI_MATKEY_COLOR_AMBIENT);
-            }
-
-            // we store specular factor as SHININESS_STRENGTH, so just get the color
-            const aiColor3D& Specular = GetColorProperty(props, "SpecularColor", ok, true);
-            if (ok) {
-                out_mat->AddProperty(&Specular, 1, AI_MATKEY_COLOR_SPECULAR);
-            }
-
-            // and also try to get SHININESS_STRENGTH
-            const float SpecularFactor = PropertyGet<float>(props, "SpecularFactor", ok, true);
-            if (ok) {
-                out_mat->AddProperty(&SpecularFactor, 1, AI_MATKEY_SHININESS_STRENGTH);
-            }
-
-            // and the specular exponent
-            const float ShininessExponent = PropertyGet<float>(props, "ShininessExponent", ok);
-            if (ok) {
-                out_mat->AddProperty(&ShininessExponent, 1, AI_MATKEY_SHININESS);
-            }
-
-            // TransparentColor / TransparencyFactor... gee thanks FBX :rolleyes:
-            const aiColor3D& Transparent = GetColorPropertyFactored(props, "TransparentColor", "TransparencyFactor", ok);
-            float CalculatedOpacity = 1.0f;
-            if (ok) {
-                out_mat->AddProperty(&Transparent, 1, AI_MATKEY_COLOR_TRANSPARENT);
-                // as calculated by FBX SDK 2017:
-                CalculatedOpacity = 1.0f - ((Transparent.r + Transparent.g + Transparent.b) / 3.0f);
-            }
-
-            // try to get the transparency factor
-            const float TransparencyFactor = PropertyGet<float>(props, "TransparencyFactor", ok);
-            if (ok) {
-                out_mat->AddProperty(&TransparencyFactor, 1, AI_MATKEY_TRANSPARENCYFACTOR);
-            }
-
-            // use of TransparencyFactor is inconsistent.
-            // Maya always stores it as 1.0,
-            // so we can't use it to set AI_MATKEY_OPACITY.
-            // Blender is more sensible and stores it as the alpha value.
-            // However both the FBX SDK and Blender always write an additional
-            // legacy "Opacity" field, so we can try to use that.
-            //
-            // If we can't find it,
-            // we can fall back to the value which the FBX SDK calculates
-            // from transparency colour (RGB) and factor (F) as
-            // 1.0 - F*((R+G+B)/3).
-            //
-            // There's no consistent way to interpret this opacity value,
-            // so it's up to clients to do the correct thing.
-            const float Opacity = PropertyGet<float>(props, "Opacity", ok);
-            if (ok) {
-                out_mat->AddProperty(&Opacity, 1, AI_MATKEY_OPACITY);
-            }
-            else if (CalculatedOpacity != 1.0) {
-                out_mat->AddProperty(&CalculatedOpacity, 1, AI_MATKEY_OPACITY);
-            }
-
-            // reflection color and factor are stored separately
-            const aiColor3D& Reflection = GetColorProperty(props, "ReflectionColor", ok, true);
-            if (ok) {
-                out_mat->AddProperty(&Reflection, 1, AI_MATKEY_COLOR_REFLECTIVE);
-            }
-
-            float ReflectionFactor = PropertyGet<float>(props, "ReflectionFactor", ok, true);
-            if (ok) {
-                out_mat->AddProperty(&ReflectionFactor, 1, AI_MATKEY_REFLECTIVITY);
-            }
-
-            const float BumpFactor = PropertyGet<float>(props, "BumpFactor", ok);
-            if (ok) {
-                out_mat->AddProperty(&BumpFactor, 1, AI_MATKEY_BUMPSCALING);
-            }
-
-            const float DispFactor = PropertyGet<float>(props, "DisplacementFactor", ok);
-            if (ok) {
-                out_mat->AddProperty(&DispFactor, 1, "$mat.displacementscaling", 0, 0);
-    }
-}
-
-
-void FBXConverter::SetShadingPropertiesRaw(aiMaterial* out_mat, const PropertyTable& props, const TextureMap& textures, const MeshGeometry* const mesh)
-{
-    // Add all the unparsed properties with a "$raw." prefix
-
-    const std::string prefix = "$raw.";
-
-    for (const DirectPropertyMap::value_type& prop : props.GetUnparsedProperties()) {
-
-        std::string name = prefix + prop.first;
-
-        if (const TypedProperty<aiVector3D>* interpreted = prop.second->As<TypedProperty<aiVector3D> >())
-        {
-            out_mat->AddProperty(&interpreted->Value(), 1, name.c_str(), 0, 0);
-        }
-        else if (const TypedProperty<aiColor3D>* interpreted = prop.second->As<TypedProperty<aiColor3D> >())
-        {
-            out_mat->AddProperty(&interpreted->Value(), 1, name.c_str(), 0, 0);
-        }
-        else if (const TypedProperty<aiColor4D>* interpreted = prop.second->As<TypedProperty<aiColor4D> >())
-        {
-            out_mat->AddProperty(&interpreted->Value(), 1, name.c_str(), 0, 0);
-        }
-        else if (const TypedProperty<float>* interpreted = prop.second->As<TypedProperty<float> >())
-        {
-            out_mat->AddProperty(&interpreted->Value(), 1, name.c_str(), 0, 0);
-        }
-        else if (const TypedProperty<int>* interpreted = prop.second->As<TypedProperty<int> >())
-        {
-            out_mat->AddProperty(&interpreted->Value(), 1, name.c_str(), 0, 0);
-        }
-        else if (const TypedProperty<bool>* interpreted = prop.second->As<TypedProperty<bool> >())
-        {
-            int value = interpreted->Value() ? 1 : 0;
-            out_mat->AddProperty(&value, 1, name.c_str(), 0, 0);
-        }
-        else if (const TypedProperty<std::string>* interpreted = prop.second->As<TypedProperty<std::string> >())
-        {
-            const aiString value = aiString(interpreted->Value());
-            out_mat->AddProperty(&value, name.c_str(), 0, 0);
-        }
-    }
-
-    // Add the textures' properties
-
-    for (TextureMap::const_iterator it = textures.begin(); it != textures.end(); it++) {
-
-        std::string name = prefix + it->first;
-
-        const Texture* const tex = (*it).second;
-        if (tex != nullptr)
-        {
-            aiString path;
-            path.Set(tex->RelativeFilename());
-
-            const Video* media = tex->Media();
-            if (media != nullptr && media->ContentLength() > 0) {
-                unsigned int index;
-
-                VideoMap::const_iterator it = textures_converted.find(media);
-                if (it != textures_converted.end()) {
-                    index = (*it).second;
-                }
-                else {
-                    index = ConvertVideo(*media);
-                    textures_converted[media] = index;
-                }
-
-                // setup texture reference string (copied from ColladaLoader::FindFilenameForEffectTexture)
-                path.data[0] = '*';
-                path.length = 1 + ASSIMP_itoa10(path.data + 1, MAXLEN - 1, index);
-            }
-
-            out_mat->AddProperty(&path, (name + "|file").c_str(), aiTextureType_UNKNOWN, 0);
-
-            aiUVTransform uvTrafo;
-            // XXX handle all kinds of UV transformations
-            uvTrafo.mScaling = tex->UVScaling();
-            uvTrafo.mTranslation = tex->UVTranslation();
-            out_mat->AddProperty(&uvTrafo, 1, (name + "|uvtrafo").c_str(), aiTextureType_UNKNOWN, 0);
- 
-            int uvIndex = 0;
-
-            bool uvFound = false;
-            const std::string& uvSet = PropertyGet<std::string>(tex->Props(), "UVSet", uvFound);
-            if (uvFound) {
-                // "default" is the name which usually appears in the FbxFileTexture template
-                if (uvSet != "default" && uvSet.length()) {
-                    // this is a bit awkward - we need to find a mesh that uses this
-                    // material and scan its UV channels for the given UV name because
-                    // assimp references UV channels by index, not by name.
-
-                    // XXX: the case that UV channels may appear in different orders
-                    // in meshes is unhandled. A possible solution would be to sort
-                    // the UV channels alphabetically, but this would have the side
-                    // effect that the primary (first) UV channel would sometimes
-                    // be moved, causing trouble when users read only the first
-                    // UV channel and ignore UV channel assignments altogether.
-
-                    std::vector<aiMaterial*>::iterator materialIt = std::find(materials.begin(), materials.end(), out_mat);
-                    const unsigned int matIndex = static_cast<unsigned int>(std::distance(materials.begin(), materialIt));
-
-                    uvIndex = -1;
-                    if (!mesh)
-                    {
-                        for (const MeshMap::value_type& v : meshes_converted) {
-                            const MeshGeometry* const meshGeom = dynamic_cast<const MeshGeometry*>(v.first);
-                            if (!meshGeom) {
-                                continue;
-                            }
-
-                            const MatIndexArray& mats = meshGeom->GetMaterialIndices();
-                            if (std::find(mats.begin(), mats.end(), matIndex) == mats.end()) {
-                                continue;
-                            }
-
-                            int index = -1;
-                            for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
-                                if (meshGeom->GetTextureCoords(i).empty()) {
-                                    break;
-                                }
-                                const std::string& name = meshGeom->GetTextureCoordChannelName(i);
-                                if (name == uvSet) {
-                                    index = static_cast<int>(i);
-                                    break;
-                                }
-                            }
-                            if (index == -1) {
-                                FBXImporter::LogWarn("did not find UV channel named " + uvSet + " in a mesh using this material");
-                                continue;
-                            }
-
-                            if (uvIndex == -1) {
-                                uvIndex = index;
-                            }
-                            else {
-                                FBXImporter::LogWarn("the UV channel named " + uvSet + " appears at different positions in meshes, results will be wrong");
-                            }
-                        }
-                    }
-                    else
-                    {
-                        int index = -1;
-                        for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
-                            if (mesh->GetTextureCoords(i).empty()) {
-                                break;
-                            }
-                            const std::string& name = mesh->GetTextureCoordChannelName(i);
-                            if (name == uvSet) {
-                                index = static_cast<int>(i);
-                                break;
-                            }
-                        }
-                        if (index == -1) {
-                            FBXImporter::LogWarn("did not find UV channel named " + uvSet + " in a mesh using this material");
-                        }
-
-                        if (uvIndex == -1) {
-                            uvIndex = index;
-                        }
-                    }
-
-                    if (uvIndex == -1) {
-                        FBXImporter::LogWarn("failed to resolve UV channel " + uvSet + ", using first UV channel");
-                        uvIndex = 0;
-                    }
-                }
-            }
-
-            out_mat->AddProperty(&uvIndex, 1, (name + "|uvwsrc").c_str(), aiTextureType_UNKNOWN, 0);
-        }
-            }
-        }
-
-
-        double FBXConverter::FrameRateToDouble(FileGlobalSettings::FrameRate fp, double customFPSVal) {
-            switch (fp) {
-            case FileGlobalSettings::FrameRate_DEFAULT:
-                return 1.0;
-
-            case FileGlobalSettings::FrameRate_120:
-                return 120.0;
-
-            case FileGlobalSettings::FrameRate_100:
-                return 100.0;
-
-            case FileGlobalSettings::FrameRate_60:
-                return 60.0;
-
-            case FileGlobalSettings::FrameRate_50:
-                return 50.0;
-
-            case FileGlobalSettings::FrameRate_48:
-                return 48.0;
-
-            case FileGlobalSettings::FrameRate_30:
-            case FileGlobalSettings::FrameRate_30_DROP:
-                return 30.0;
-
-            case FileGlobalSettings::FrameRate_NTSC_DROP_FRAME:
-            case FileGlobalSettings::FrameRate_NTSC_FULL_FRAME:
-                return 29.9700262;
-
-            case FileGlobalSettings::FrameRate_PAL:
-                return 25.0;
-
-            case FileGlobalSettings::FrameRate_CINEMA:
-                return 24.0;
-
-            case FileGlobalSettings::FrameRate_1000:
-                return 1000.0;
-
-            case FileGlobalSettings::FrameRate_CINEMA_ND:
-                return 23.976;
-
-            case FileGlobalSettings::FrameRate_CUSTOM:
-                return customFPSVal;
-
-            case FileGlobalSettings::FrameRate_MAX: // this is to silence compiler warnings
-                break;
-            }
-
-            ai_assert(false);
-
-            return -1.0f;
-        }
-
-
-        void FBXConverter::ConvertAnimations()
-        {
-            // first of all determine framerate
-            const FileGlobalSettings::FrameRate fps = doc.GlobalSettings().TimeMode();
-            const float custom = doc.GlobalSettings().CustomFrameRate();
-            anim_fps = FrameRateToDouble(fps, custom);
-
-            const std::vector<const AnimationStack*>& animations = doc.AnimationStacks();
-            for (const AnimationStack* stack : animations) {
-                ConvertAnimationStack(*stack);
-            }
-        }
-
-        std::string FBXConverter::FixNodeName(const std::string& name) {
-            // strip Model:: prefix, avoiding ambiguities (i.e. don't strip if
-            // this causes ambiguities, well possible between empty identifiers,
-            // such as "Model::" and ""). Make sure the behaviour is consistent
-            // across multiple calls to FixNodeName().
-            if (name.substr(0, 7) == "Model::") {
-                std::string temp = name.substr(7);
-                return temp;
-            }
-
-            return name;
-        }
-
-        std::string FBXConverter::FixAnimMeshName(const std::string& name) {
-            if (name.length()) {
-                size_t indexOf = name.find_first_of("::");
-                if (indexOf != std::string::npos && indexOf < name.size() - 2) {
-                    return name.substr(indexOf + 2);
-                }
-            }
-            return name.length() ? name : "AnimMesh";
-        }
-
-        void FBXConverter::ConvertAnimationStack(const AnimationStack& st)
-        {
-            const AnimationLayerList& layers = st.Layers();
-            if (layers.empty()) {
-                return;
-            }
-
-            aiAnimation* const anim = new aiAnimation();
-            animations.push_back(anim);
-
-            // strip AnimationStack:: prefix
-            std::string name = st.Name();
-            if (name.substr(0, 16) == "AnimationStack::") {
-                name = name.substr(16);
-            }
-            else if (name.substr(0, 11) == "AnimStack::") {
-                name = name.substr(11);
-            }
-
-            anim->mName.Set(name);
-
-            // need to find all nodes for which we need to generate node animations -
-            // it may happen that we need to merge multiple layers, though.
-            NodeMap node_map;
-
-            // reverse mapping from curves to layers, much faster than querying
-            // the FBX DOM for it.
-            LayerMap layer_map;
-
-            const char* prop_whitelist[] = {
-                "Lcl Scaling",
-                "Lcl Rotation",
-                "Lcl Translation",
-                "DeformPercent"
-            };
-
-            std::map<std::string, morphAnimData*> morphAnimDatas;
-
-            for (const AnimationLayer* layer : layers) {
-                ai_assert(layer);
-                const AnimationCurveNodeList& nodes = layer->Nodes(prop_whitelist, 4);
-                for (const AnimationCurveNode* node : nodes) {
-                    ai_assert(node);
-                    const Model* const model = dynamic_cast<const Model*>(node->Target());
-                    if (model) {
-                        const std::string& name = FixNodeName(model->Name());
-                        node_map[name].push_back(node);
-                        layer_map[node] = layer;
-                        continue;
-                    }
-                    const BlendShapeChannel* const bsc = dynamic_cast<const BlendShapeChannel*>(node->Target());
-                    if (bsc) {
-                        ProcessMorphAnimDatas(&morphAnimDatas, bsc, node);
-                    }
-                }
-            }
-
-            // generate node animations
-            std::vector<aiNodeAnim*> node_anims;
-
-            double min_time = 1e10;
-            double max_time = -1e10;
-
-            int64_t start_time = st.LocalStart();
-            int64_t stop_time = st.LocalStop();
-            bool has_local_startstop = start_time != 0 || stop_time != 0;
-            if (!has_local_startstop) {
-                // no time range given, so accept every keyframe and use the actual min/max time
-                // the numbers are INT64_MIN/MAX, the 20000 is for safety because GenerateNodeAnimations uses an epsilon of 10000
-                start_time = -9223372036854775807ll + 20000;
-                stop_time = 9223372036854775807ll - 20000;
-            }
-
-            try {
-                for (const NodeMap::value_type& kv : node_map) {
-                    GenerateNodeAnimations(node_anims,
-                        kv.first,
-                        kv.second,
-                        layer_map,
-                        start_time, stop_time,
-                        max_time,
-                        min_time);
-                }
-            }
-            catch (std::exception&) {
-                std::for_each(node_anims.begin(), node_anims.end(), Util::delete_fun<aiNodeAnim>());
-                throw;
-            }
-
-            if (node_anims.size() || morphAnimDatas.size()) {
-                if (node_anims.size()) {
-                    anim->mChannels = new aiNodeAnim*[node_anims.size()]();
-                    anim->mNumChannels = static_cast<unsigned int>(node_anims.size());
-                    std::swap_ranges(node_anims.begin(), node_anims.end(), anim->mChannels);
-                }
-                if (morphAnimDatas.size()) {
-                    unsigned int numMorphMeshChannels = static_cast<unsigned int>(morphAnimDatas.size());
-                    anim->mMorphMeshChannels = new aiMeshMorphAnim*[numMorphMeshChannels];
-                    anim->mNumMorphMeshChannels = numMorphMeshChannels;
-                    unsigned int i = 0;
-                    for (auto morphAnimIt : morphAnimDatas) {
-                        morphAnimData* animData = morphAnimIt.second;
-                        unsigned int numKeys = static_cast<unsigned int>(animData->size());
-                        aiMeshMorphAnim* meshMorphAnim = new aiMeshMorphAnim();
-                        meshMorphAnim->mName.Set(morphAnimIt.first);
-                        meshMorphAnim->mNumKeys = numKeys;
-                        meshMorphAnim->mKeys = new aiMeshMorphKey[numKeys];
-                        unsigned int j = 0;
-                        for (auto animIt : *animData) {
-                            morphKeyData* keyData = animIt.second;
-                            unsigned int numValuesAndWeights = static_cast<unsigned int>(keyData->values.size());
-                            meshMorphAnim->mKeys[j].mNumValuesAndWeights = numValuesAndWeights;
-                            meshMorphAnim->mKeys[j].mValues = new unsigned int[numValuesAndWeights];
-                            meshMorphAnim->mKeys[j].mWeights = new double[numValuesAndWeights];
-                            meshMorphAnim->mKeys[j].mTime = CONVERT_FBX_TIME(animIt.first) * anim_fps;
-                            for (unsigned int k = 0; k < numValuesAndWeights; k++) {
-                                meshMorphAnim->mKeys[j].mValues[k] = keyData->values.at(k);
-                                meshMorphAnim->mKeys[j].mWeights[k] = keyData->weights.at(k);
-                            }
-                            j++;
-                        }
-                        anim->mMorphMeshChannels[i++] = meshMorphAnim;
-                    }
-                }
-            }
-            else {
-                // empty animations would fail validation, so drop them
-                delete anim;
-                animations.pop_back();
-                FBXImporter::LogInfo("ignoring empty AnimationStack (using IK?): " + name);
-                return;
-            }
-
-            double start_time_fps = has_local_startstop ? (CONVERT_FBX_TIME(start_time) * anim_fps) : min_time;
-            double stop_time_fps = has_local_startstop ? (CONVERT_FBX_TIME(stop_time) * anim_fps) : max_time;
-
-            // adjust relative timing for animation
-            for (unsigned int c = 0; c < anim->mNumChannels; c++) {
-                aiNodeAnim* channel = anim->mChannels[c];
-                for (uint32_t i = 0; i < channel->mNumPositionKeys; i++) {
-                    channel->mPositionKeys[i].mTime -= start_time_fps;
-                }
-                for (uint32_t i = 0; i < channel->mNumRotationKeys; i++) {
-                    channel->mRotationKeys[i].mTime -= start_time_fps;
-                }
-                for (uint32_t i = 0; i < channel->mNumScalingKeys; i++) {
-                    channel->mScalingKeys[i].mTime -= start_time_fps;
-                }
-            }
-            for (unsigned int c = 0; c < anim->mNumMorphMeshChannels; c++) {
-                aiMeshMorphAnim* channel = anim->mMorphMeshChannels[c];
-                for (uint32_t i = 0; i < channel->mNumKeys; i++) {
-                    channel->mKeys[i].mTime -= start_time_fps;
-                }
-            }
-
-            // for some mysterious reason, mDuration is simply the maximum key -- the
-            // validator always assumes animations to start at zero.
-            anim->mDuration = stop_time_fps - start_time_fps;
-            anim->mTicksPerSecond = anim_fps;
-        }
-
-        // ------------------------------------------------------------------------------------------------
-        void FBXConverter::ProcessMorphAnimDatas(std::map<std::string, morphAnimData*>* morphAnimDatas, const BlendShapeChannel* bsc, const AnimationCurveNode* node) {
-            std::vector<const Connection*> bscConnections = doc.GetConnectionsBySourceSequenced(bsc->ID(), "Deformer");
-            for (const Connection* bscConnection : bscConnections) {
-                auto bs = dynamic_cast<const BlendShape*>(bscConnection->DestinationObject());
-                if (bs) {
-                    auto channelIt = std::find(bs->BlendShapeChannels().begin(), bs->BlendShapeChannels().end(), bsc);
-                    if (channelIt != bs->BlendShapeChannels().end()) {
-                        auto channelIndex = static_cast<unsigned int>(std::distance(bs->BlendShapeChannels().begin(), channelIt));
-                        std::vector<const Connection*> bsConnections = doc.GetConnectionsBySourceSequenced(bs->ID(), "Geometry");
-                        for (const Connection* bsConnection : bsConnections) {
-                            auto geo = dynamic_cast<const Geometry*>(bsConnection->DestinationObject());
-                            if (geo) {
-                                std::vector<const Connection*> geoConnections = doc.GetConnectionsBySourceSequenced(geo->ID(), "Model");
-                                for (const Connection* geoConnection : geoConnections) {
-                                    auto model = dynamic_cast<const Model*>(geoConnection->DestinationObject());
-                                    if (model) {
-                                        auto geoIt = std::find(model->GetGeometry().begin(), model->GetGeometry().end(), geo);
-                                        auto geoIndex = static_cast<unsigned int>(std::distance(model->GetGeometry().begin(), geoIt));
-                                        auto name = aiString(FixNodeName(model->Name() + "*"));
-                                        name.length = 1 + ASSIMP_itoa10(name.data + name.length, MAXLEN - 1, geoIndex);
-                                        morphAnimData* animData;
-                                        auto animIt = morphAnimDatas->find(name.C_Str());
-                                        if (animIt == morphAnimDatas->end()) {
-                                            animData = new morphAnimData();
-                                            morphAnimDatas->insert(std::make_pair(name.C_Str(), animData));
-                                        }
-                                        else {
-                                            animData = animIt->second;
-                                        }
-                                        for (std::pair<std::string, const AnimationCurve*> curvesIt : node->Curves()) {
-                                            if (curvesIt.first == "d|DeformPercent") {
-                                                const AnimationCurve* animationCurve = curvesIt.second;
-                                                const KeyTimeList& keys = animationCurve->GetKeys();
-                                                const KeyValueList& values = animationCurve->GetValues();
-                                                unsigned int k = 0;
-                                                for (auto key : keys) {
-                                                    morphKeyData* keyData;
-                                                    auto keyIt = animData->find(key);
-                                                    if (keyIt == animData->end()) {
-                                                        keyData = new morphKeyData();
-                                                        animData->insert(std::make_pair(key, keyData));
-                                                    }
-                                                    else {
-                                                        keyData = keyIt->second;
-                                                    }
-                                                    keyData->values.push_back(channelIndex);
-                                                    keyData->weights.push_back(values.at(k) / 100.0f);
-                                                    k++;
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        // ------------------------------------------------------------------------------------------------
-#ifdef ASSIMP_BUILD_DEBUG
-        // ------------------------------------------------------------------------------------------------
-        // sanity check whether the input is ok
-        static void validateAnimCurveNodes(const std::vector<const AnimationCurveNode*>& curves,
-            bool strictMode) {
-            const Object* target(NULL);
-            for (const AnimationCurveNode* node : curves) {
-                if (!target) {
-                    target = node->Target();
-                }
-                if (node->Target() != target) {
-                    FBXImporter::LogWarn("Node target is nullptr type.");
-                }
-                if (strictMode) {
-                    ai_assert(node->Target() == target);
-                }
-            }
-        }
-#endif // ASSIMP_BUILD_DEBUG
-
-        // ------------------------------------------------------------------------------------------------
-        void FBXConverter::GenerateNodeAnimations(std::vector<aiNodeAnim*>& node_anims,
-            const std::string& fixed_name,
-            const std::vector<const AnimationCurveNode*>& curves,
-            const LayerMap& layer_map,
-            int64_t start, int64_t stop,
-            double& max_time,
-            double& min_time)
-        {
-
-            NodeMap node_property_map;
-            ai_assert(curves.size());
-
-#ifdef ASSIMP_BUILD_DEBUG
-            validateAnimCurveNodes(curves, doc.Settings().strictMode);
-#endif
-            const AnimationCurveNode* curve_node = NULL;
-            for (const AnimationCurveNode* node : curves) {
-                ai_assert(node);
-
-                if (node->TargetProperty().empty()) {
-                    FBXImporter::LogWarn("target property for animation curve not set: " + node->Name());
-                    continue;
-                }
-
-                curve_node = node;
-                if (node->Curves().empty()) {
-                    FBXImporter::LogWarn("no animation curves assigned to AnimationCurveNode: " + node->Name());
-                    continue;
-                }
-
-                node_property_map[node->TargetProperty()].push_back(node);
-            }
-
-            ai_assert(curve_node);
-            ai_assert(curve_node->TargetAsModel());
-
-            const Model& target = *curve_node->TargetAsModel();
-
-            // check for all possible transformation components
-            NodeMap::const_iterator chain[TransformationComp_MAXIMUM];
-
-            bool has_any = false;
-            bool has_complex = false;
-
-            for (size_t i = 0; i < TransformationComp_MAXIMUM; ++i) {
-                const TransformationComp comp = static_cast<TransformationComp>(i);
-
-                // inverse pivots don't exist in the input, we just generate them
-                if (comp == TransformationComp_RotationPivotInverse || comp == TransformationComp_ScalingPivotInverse) {
-                    chain[i] = node_property_map.end();
-                    continue;
-                }
-
-                chain[i] = node_property_map.find(NameTransformationCompProperty(comp));
-                if (chain[i] != node_property_map.end()) {
-
-                    // check if this curves contains redundant information by looking
-                    // up the corresponding node's transformation chain.
-                    if (doc.Settings().optimizeEmptyAnimationCurves &&
-                        IsRedundantAnimationData(target, comp, (*chain[i]).second)) {
-
-                        FBXImporter::LogDebug("dropping redundant animation channel for node " + target.Name());
-                        continue;
-                    }
-
-                    has_any = true;
-
-                    if (comp != TransformationComp_Rotation && comp != TransformationComp_Scaling && comp != TransformationComp_Translation)
-                    {
-                        has_complex = true;
-                    }
-                }
-            }
-
-            if (!has_any) {
-                FBXImporter::LogWarn("ignoring node animation, did not find any transformation key frames");
-                return;
-            }
-
-            // this needs to play nicely with GenerateTransformationNodeChain() which will
-            // be invoked _later_ (animations come first). If this node has only rotation,
-            // scaling and translation _and_ there are no animated other components either,
-            // we can use a single node and also a single node animation channel.
-            if (!has_complex && !NeedsComplexTransformationChain(target)) {
-
-                aiNodeAnim* const nd = GenerateSimpleNodeAnim(fixed_name, target, chain,
-                    node_property_map.end(),
-                    layer_map,
-                    start, stop,
-                    max_time,
-                    min_time,
-                    true // input is TRS order, assimp is SRT
-                );
-
-                ai_assert(nd);
-                if (nd->mNumPositionKeys == 0 && nd->mNumRotationKeys == 0 && nd->mNumScalingKeys == 0) {
-                    delete nd;
-                }
-                else {
-                    node_anims.push_back(nd);
-                }
-                return;
-            }
-
-            // otherwise, things get gruesome and we need separate animation channels
-            // for each part of the transformation chain. Remember which channels
-            // we generated and pass this information to the node conversion
-            // code to avoid nodes that have identity transform, but non-identity
-            // animations, being dropped.
-            unsigned int flags = 0, bit = 0x1;
-            for (size_t i = 0; i < TransformationComp_MAXIMUM; ++i, bit <<= 1) {
-                const TransformationComp comp = static_cast<TransformationComp>(i);
-
-                if (chain[i] != node_property_map.end()) {
-                    flags |= bit;
-
-                    ai_assert(comp != TransformationComp_RotationPivotInverse);
-                    ai_assert(comp != TransformationComp_ScalingPivotInverse);
-
-                    const std::string& chain_name = NameTransformationChainNode(fixed_name, comp);
-
-                    aiNodeAnim* na = nullptr;
-                    switch (comp)
-                    {
-                    case TransformationComp_Rotation:
-                    case TransformationComp_PreRotation:
-                    case TransformationComp_PostRotation:
-                    case TransformationComp_GeometricRotation:
-                        na = GenerateRotationNodeAnim(chain_name,
-                            target,
-                            (*chain[i]).second,
-                            layer_map,
-                            start, stop,
-                            max_time,
-                            min_time);
-
-                        break;
-
-                    case TransformationComp_RotationOffset:
-                    case TransformationComp_RotationPivot:
-                    case TransformationComp_ScalingOffset:
-                    case TransformationComp_ScalingPivot:
-                    case TransformationComp_Translation:
-                    case TransformationComp_GeometricTranslation:
-                        na = GenerateTranslationNodeAnim(chain_name,
-                            target,
-                            (*chain[i]).second,
-                            layer_map,
-                            start, stop,
-                            max_time,
-                            min_time);
-
-                        // pivoting requires us to generate an implicit inverse channel to undo the pivot translation
-                        if (comp == TransformationComp_RotationPivot) {
-                            const std::string& invName = NameTransformationChainNode(fixed_name,
-                                TransformationComp_RotationPivotInverse);
-
-                            aiNodeAnim* const inv = GenerateTranslationNodeAnim(invName,
-                                target,
-                                (*chain[i]).second,
-                                layer_map,
-                                start, stop,
-                                max_time,
-                                min_time,
-                                true);
-
-                            ai_assert(inv);
-                            if (inv->mNumPositionKeys == 0 && inv->mNumRotationKeys == 0 && inv->mNumScalingKeys == 0) {
-                                delete inv;
-                            }
-                            else {
-                                node_anims.push_back(inv);
-                            }
-
-                            ai_assert(TransformationComp_RotationPivotInverse > i);
-                            flags |= bit << (TransformationComp_RotationPivotInverse - i);
-                        }
-                        else if (comp == TransformationComp_ScalingPivot) {
-                            const std::string& invName = NameTransformationChainNode(fixed_name,
-                                TransformationComp_ScalingPivotInverse);
-
-                            aiNodeAnim* const inv = GenerateTranslationNodeAnim(invName,
-                                target,
-                                (*chain[i]).second,
-                                layer_map,
-                                start, stop,
-                                max_time,
-                                min_time,
-                                true);
-
-                            ai_assert(inv);
-                            if (inv->mNumPositionKeys == 0 && inv->mNumRotationKeys == 0 && inv->mNumScalingKeys == 0) {
-                                delete inv;
-                            }
-                            else {
-                                node_anims.push_back(inv);
-                            }
-
-                            ai_assert(TransformationComp_RotationPivotInverse > i);
-                            flags |= bit << (TransformationComp_RotationPivotInverse - i);
-                        }
-
-                        break;
-
-                    case TransformationComp_Scaling:
-                    case TransformationComp_GeometricScaling:
-                        na = GenerateScalingNodeAnim(chain_name,
-                            target,
-                            (*chain[i]).second,
-                            layer_map,
-                            start, stop,
-                            max_time,
-                            min_time);
-
-                        break;
-
-                    default:
-                        ai_assert(false);
-                    }
-
-                    ai_assert(na);
-                    if (na->mNumPositionKeys == 0 && na->mNumRotationKeys == 0 && na->mNumScalingKeys == 0) {
-                        delete na;
-                    }
-                    else {
-                        node_anims.push_back(na);
-                    }
-                    continue;
-                }
-            }
-
-            node_anim_chain_bits[fixed_name] = flags;
-        }
-
-
-        bool FBXConverter::IsRedundantAnimationData(const Model& target,
-            TransformationComp comp,
-            const std::vector<const AnimationCurveNode*>& curves) {
-            ai_assert(curves.size());
-
-            // look for animation nodes with
-            //  * sub channels for all relevant components set
-            //  * one key/value pair per component
-            //  * combined values match up the corresponding value in the bind pose node transformation
-            // only such nodes are 'redundant' for this function.
-
-            if (curves.size() > 1) {
-                return false;
-            }
-
-            const AnimationCurveNode& nd = *curves.front();
-            const AnimationCurveMap& sub_curves = nd.Curves();
-
-            const AnimationCurveMap::const_iterator dx = sub_curves.find("d|X");
-            const AnimationCurveMap::const_iterator dy = sub_curves.find("d|Y");
-            const AnimationCurveMap::const_iterator dz = sub_curves.find("d|Z");
-
-            if (dx == sub_curves.end() || dy == sub_curves.end() || dz == sub_curves.end()) {
-                return false;
-            }
-
-            const KeyValueList& vx = (*dx).second->GetValues();
-            const KeyValueList& vy = (*dy).second->GetValues();
-            const KeyValueList& vz = (*dz).second->GetValues();
-
-            if (vx.size() != 1 || vy.size() != 1 || vz.size() != 1) {
-                return false;
-            }
-
-            const aiVector3D dyn_val = aiVector3D(vx[0], vy[0], vz[0]);
-            const aiVector3D& static_val = PropertyGet<aiVector3D>(target.Props(),
-                NameTransformationCompProperty(comp),
-                TransformationCompDefaultValue(comp)
-                );
-
-            const float epsilon = Math::getEpsilon<float>();
-            return (dyn_val - static_val).SquareLength() < epsilon;
-        }
-
-
-        aiNodeAnim* FBXConverter::GenerateRotationNodeAnim(const std::string& name,
-            const Model& target,
-            const std::vector<const AnimationCurveNode*>& curves,
-            const LayerMap& layer_map,
-            int64_t start, int64_t stop,
-            double& max_time,
-            double& min_time)
-        {
-            std::unique_ptr<aiNodeAnim> na(new aiNodeAnim());
-            na->mNodeName.Set(name);
-
-            ConvertRotationKeys(na.get(), curves, layer_map, start, stop, max_time, min_time, target.RotationOrder());
-
-            // dummy scaling key
-            na->mScalingKeys = new aiVectorKey[1];
-            na->mNumScalingKeys = 1;
-
-            na->mScalingKeys[0].mTime = 0.;
-            na->mScalingKeys[0].mValue = aiVector3D(1.0f, 1.0f, 1.0f);
-
-            // dummy position key
-            na->mPositionKeys = new aiVectorKey[1];
-            na->mNumPositionKeys = 1;
-
-            na->mPositionKeys[0].mTime = 0.;
-            na->mPositionKeys[0].mValue = aiVector3D();
-
-            return na.release();
-        }
-
-        aiNodeAnim* FBXConverter::GenerateScalingNodeAnim(const std::string& name,
-            const Model& /*target*/,
-            const std::vector<const AnimationCurveNode*>& curves,
-            const LayerMap& layer_map,
-            int64_t start, int64_t stop,
-            double& max_time,
-            double& min_time)
-        {
-            std::unique_ptr<aiNodeAnim> na(new aiNodeAnim());
-            na->mNodeName.Set(name);
-
-            ConvertScaleKeys(na.get(), curves, layer_map, start, stop, max_time, min_time);
-
-            // dummy rotation key
-            na->mRotationKeys = new aiQuatKey[1];
-            na->mNumRotationKeys = 1;
-
-            na->mRotationKeys[0].mTime = 0.;
-            na->mRotationKeys[0].mValue = aiQuaternion();
-
-            // dummy position key
-            na->mPositionKeys = new aiVectorKey[1];
-            na->mNumPositionKeys = 1;
-
-            na->mPositionKeys[0].mTime = 0.;
-            na->mPositionKeys[0].mValue = aiVector3D();
-
-            return na.release();
-        }
-
-        aiNodeAnim* FBXConverter::GenerateTranslationNodeAnim(const std::string& name,
-            const Model& /*target*/,
-            const std::vector<const AnimationCurveNode*>& curves,
-            const LayerMap& layer_map,
-            int64_t start, int64_t stop,
-            double& max_time,
-            double& min_time,
-            bool inverse) {
-            std::unique_ptr<aiNodeAnim> na(new aiNodeAnim());
-            na->mNodeName.Set(name);
-
-            ConvertTranslationKeys(na.get(), curves, layer_map, start, stop, max_time, min_time);
-
-            if (inverse) {
-                for (unsigned int i = 0; i < na->mNumPositionKeys; ++i) {
-                    na->mPositionKeys[i].mValue *= -1.0f;
-                }
-            }
-
-            // dummy scaling key
-            na->mScalingKeys = new aiVectorKey[1];
-            na->mNumScalingKeys = 1;
-
-            na->mScalingKeys[0].mTime = 0.;
-            na->mScalingKeys[0].mValue = aiVector3D(1.0f, 1.0f, 1.0f);
-
-            // dummy rotation key
-            na->mRotationKeys = new aiQuatKey[1];
-            na->mNumRotationKeys = 1;
-
-            na->mRotationKeys[0].mTime = 0.;
-            na->mRotationKeys[0].mValue = aiQuaternion();
-
-            return na.release();
-        }
-
-        aiNodeAnim* FBXConverter::GenerateSimpleNodeAnim(const std::string& name,
-            const Model& target,
-            NodeMap::const_iterator chain[TransformationComp_MAXIMUM],
-            NodeMap::const_iterator iter_end,
-            const LayerMap& layer_map,
-            int64_t start, int64_t stop,
-            double& max_time,
-            double& min_time,
-            bool reverse_order)
-
-        {
-            std::unique_ptr<aiNodeAnim> na(new aiNodeAnim());
-            na->mNodeName.Set(name);
-
-            const PropertyTable& props = target.Props();
-
-            // need to convert from TRS order to SRT?
-            if (reverse_order) {
-
-                aiVector3D def_scale = PropertyGet(props, "Lcl Scaling", aiVector3D(1.f, 1.f, 1.f));
-                aiVector3D def_translate = PropertyGet(props, "Lcl Translation", aiVector3D(0.f, 0.f, 0.f));
-                aiVector3D def_rot = PropertyGet(props, "Lcl Rotation", aiVector3D(0.f, 0.f, 0.f));
-
-                KeyFrameListList scaling;
-                KeyFrameListList translation;
-                KeyFrameListList rotation;
-
-                if (chain[TransformationComp_Scaling] != iter_end) {
-                    scaling = GetKeyframeList((*chain[TransformationComp_Scaling]).second, start, stop);
-                }
-
-                if (chain[TransformationComp_Translation] != iter_end) {
-                    translation = GetKeyframeList((*chain[TransformationComp_Translation]).second, start, stop);
-                }
-
-                if (chain[TransformationComp_Rotation] != iter_end) {
-                    rotation = GetKeyframeList((*chain[TransformationComp_Rotation]).second, start, stop);
-                }
-
-                KeyFrameListList joined;
-                joined.insert(joined.end(), scaling.begin(), scaling.end());
-                joined.insert(joined.end(), translation.begin(), translation.end());
-                joined.insert(joined.end(), rotation.begin(), rotation.end());
-
-                const KeyTimeList& times = GetKeyTimeList(joined);
-
-                aiQuatKey* out_quat = new aiQuatKey[times.size()];
-                aiVectorKey* out_scale = new aiVectorKey[times.size()];
-                aiVectorKey* out_translation = new aiVectorKey[times.size()];
-
-                if (times.size())
-                {
-                    ConvertTransformOrder_TRStoSRT(out_quat, out_scale, out_translation,
-                        scaling,
-                        translation,
-                        rotation,
-                        times,
-                        max_time,
-                        min_time,
-                        target.RotationOrder(),
-                        def_scale,
-                        def_translate,
-                        def_rot);
-                }
-
-                // XXX remove duplicates / redundant keys which this operation did
-                // likely produce if not all three channels were equally dense.
-
-                na->mNumScalingKeys = static_cast<unsigned int>(times.size());
-                na->mNumRotationKeys = na->mNumScalingKeys;
-                na->mNumPositionKeys = na->mNumScalingKeys;
-
-                na->mScalingKeys = out_scale;
-                na->mRotationKeys = out_quat;
-                na->mPositionKeys = out_translation;
-            }
-            else {
-
-                // if a particular transformation is not given, grab it from
-                // the corresponding node to meet the semantics of aiNodeAnim,
-                // which requires all of rotation, scaling and translation
-                // to be set.
-                if (chain[TransformationComp_Scaling] != iter_end) {
-                    ConvertScaleKeys(na.get(), (*chain[TransformationComp_Scaling]).second,
-                        layer_map,
-                        start, stop,
-                        max_time,
-                        min_time);
-                }
-                else {
-                    na->mScalingKeys = new aiVectorKey[1];
-                    na->mNumScalingKeys = 1;
-
-                    na->mScalingKeys[0].mTime = 0.;
-                    na->mScalingKeys[0].mValue = PropertyGet(props, "Lcl Scaling",
-                        aiVector3D(1.f, 1.f, 1.f));
-                }
-
-                if (chain[TransformationComp_Rotation] != iter_end) {
-                    ConvertRotationKeys(na.get(), (*chain[TransformationComp_Rotation]).second,
-                        layer_map,
-                        start, stop,
-                        max_time,
-                        min_time,
-                        target.RotationOrder());
-                }
-                else {
-                    na->mRotationKeys = new aiQuatKey[1];
-                    na->mNumRotationKeys = 1;
-
-                    na->mRotationKeys[0].mTime = 0.;
-                    na->mRotationKeys[0].mValue = EulerToQuaternion(
-                        PropertyGet(props, "Lcl Rotation", aiVector3D(0.f, 0.f, 0.f)),
-                        target.RotationOrder());
-                }
-
-                if (chain[TransformationComp_Translation] != iter_end) {
-                    ConvertTranslationKeys(na.get(), (*chain[TransformationComp_Translation]).second,
-                        layer_map,
-                        start, stop,
-                        max_time,
-                        min_time);
-                }
-                else {
-                    na->mPositionKeys = new aiVectorKey[1];
-                    na->mNumPositionKeys = 1;
-
-                    na->mPositionKeys[0].mTime = 0.;
-                    na->mPositionKeys[0].mValue = PropertyGet(props, "Lcl Translation",
-                        aiVector3D(0.f, 0.f, 0.f));
-                }
-
-            }
-            return na.release();
-        }
-
-        FBXConverter::KeyFrameListList FBXConverter::GetKeyframeList(const std::vector<const AnimationCurveNode*>& nodes, int64_t start, int64_t stop)
-        {
-            KeyFrameListList inputs;
-            inputs.reserve(nodes.size() * 3);
-
-            //give some breathing room for rounding errors
-            int64_t adj_start = start - 10000;
-            int64_t adj_stop = stop + 10000;
-
-            for (const AnimationCurveNode* node : nodes) {
-                ai_assert(node);
-
-                const AnimationCurveMap& curves = node->Curves();
-                for (const AnimationCurveMap::value_type& kv : curves) {
-
-                    unsigned int mapto;
-                    if (kv.first == "d|X") {
-                        mapto = 0;
-                    }
-                    else if (kv.first == "d|Y") {
-                        mapto = 1;
-                    }
-                    else if (kv.first == "d|Z") {
-                        mapto = 2;
-                    }
-                    else {
-                        FBXImporter::LogWarn("ignoring scale animation curve, did not recognize target component");
-                        continue;
-                    }
-
-                    const AnimationCurve* const curve = kv.second;
-                    ai_assert(curve->GetKeys().size() == curve->GetValues().size() && curve->GetKeys().size());
-
-                    //get values within the start/stop time window
-                    std::shared_ptr<KeyTimeList> Keys(new KeyTimeList());
-                    std::shared_ptr<KeyValueList> Values(new KeyValueList());
-                    const size_t count = curve->GetKeys().size();
-                    Keys->reserve(count);
-                    Values->reserve(count);
-                    for (size_t n = 0; n < count; n++)
-                    {
-                        int64_t k = curve->GetKeys().at(n);
-                        if (k >= adj_start && k <= adj_stop)
-                        {
-                            Keys->push_back(k);
-                            Values->push_back(curve->GetValues().at(n));
-                        }
-                    }
-
-                    inputs.push_back(std::make_tuple(Keys, Values, mapto));
-                }
-            }
-            return inputs; // pray for NRVO :-)
-        }
-
-
-        KeyTimeList FBXConverter::GetKeyTimeList(const KeyFrameListList& inputs) {
-            ai_assert(!inputs.empty());
-
-            // reserve some space upfront - it is likely that the key-frame lists
-            // have matching time values, so max(of all key-frame lists) should
-            // be a good estimate.
-            KeyTimeList keys;
-
-            size_t estimate = 0;
-            for (const KeyFrameList& kfl : inputs) {
-                estimate = std::max(estimate, std::get<0>(kfl)->size());
-            }
-
-            keys.reserve(estimate);
-
-            std::vector<unsigned int> next_pos;
-            next_pos.resize(inputs.size(), 0);
-
-            const size_t count = inputs.size();
-            while (true) {
-
-                int64_t min_tick = std::numeric_limits<int64_t>::max();
-                for (size_t i = 0; i < count; ++i) {
-                    const KeyFrameList& kfl = inputs[i];
-
-                    if (std::get<0>(kfl)->size() > next_pos[i] && std::get<0>(kfl)->at(next_pos[i]) < min_tick) {
-                        min_tick = std::get<0>(kfl)->at(next_pos[i]);
-                    }
-                }
-
-                if (min_tick == std::numeric_limits<int64_t>::max()) {
-                    break;
-                }
-                keys.push_back(min_tick);
-
-                for (size_t i = 0; i < count; ++i) {
-                    const KeyFrameList& kfl = inputs[i];
-
-
-                    while (std::get<0>(kfl)->size() > next_pos[i] && std::get<0>(kfl)->at(next_pos[i]) == min_tick) {
-                        ++next_pos[i];
-                    }
-                }
-            }
-
-            return keys;
-        }
-
-        void FBXConverter::InterpolateKeys(aiVectorKey* valOut, const KeyTimeList& keys, const KeyFrameListList& inputs,
-            const aiVector3D& def_value,
-            double& max_time,
-            double& min_time) {
-            ai_assert(!keys.empty());
-            ai_assert(nullptr != valOut);
-
-            std::vector<unsigned int> next_pos;
-            const size_t count(inputs.size());
-
-            next_pos.resize(inputs.size(), 0);
-
-            for (KeyTimeList::value_type time : keys) {
-                ai_real result[3] = { def_value.x, def_value.y, def_value.z };
-
-                for (size_t i = 0; i < count; ++i) {
-                    const KeyFrameList& kfl = inputs[i];
-
-                    const size_t ksize = std::get<0>(kfl)->size();
-                    if (ksize == 0) {
-                        continue;
-                    }
-                    if (ksize > next_pos[i] && std::get<0>(kfl)->at(next_pos[i]) == time) {
-                        ++next_pos[i];
-                    }
-
-                    const size_t id0 = next_pos[i] > 0 ? next_pos[i] - 1 : 0;
-                    const size_t id1 = next_pos[i] == ksize ? ksize - 1 : next_pos[i];
-
-                    // use lerp for interpolation
-                    const KeyValueList::value_type valueA = std::get<1>(kfl)->at(id0);
-                    const KeyValueList::value_type valueB = std::get<1>(kfl)->at(id1);
-
-                    const KeyTimeList::value_type timeA = std::get<0>(kfl)->at(id0);
-                    const KeyTimeList::value_type timeB = std::get<0>(kfl)->at(id1);
-
-                    const ai_real factor = timeB == timeA ? ai_real(0.) : static_cast<ai_real>((time - timeA)) / (timeB - timeA);
-                    const ai_real interpValue = static_cast<ai_real>(valueA + (valueB - valueA) * factor);
-
-                    result[std::get<2>(kfl)] = interpValue;
-                }
-
-                // magic value to convert fbx times to seconds
-                valOut->mTime = CONVERT_FBX_TIME(time) * anim_fps;
-
-                min_time = std::min(min_time, valOut->mTime);
-                max_time = std::max(max_time, valOut->mTime);
-
-                valOut->mValue.x = result[0];
-                valOut->mValue.y = result[1];
-                valOut->mValue.z = result[2];
-
-                ++valOut;
-            }
-        }
-
-        void FBXConverter::InterpolateKeys(aiQuatKey* valOut, const KeyTimeList& keys, const KeyFrameListList& inputs,
-            const aiVector3D& def_value,
-            double& maxTime,
-            double& minTime,
-            Model::RotOrder order)
-        {
-            ai_assert(!keys.empty());
-            ai_assert(nullptr != valOut);
-
-            std::unique_ptr<aiVectorKey[]> temp(new aiVectorKey[keys.size()]);
-            InterpolateKeys(temp.get(), keys, inputs, def_value, maxTime, minTime);
-
-            aiMatrix4x4 m;
-
-            aiQuaternion lastq;
-
-            for (size_t i = 0, c = keys.size(); i < c; ++i) {
-
-                valOut[i].mTime = temp[i].mTime;
-
-                GetRotationMatrix(order, temp[i].mValue, m);
-                aiQuaternion quat = aiQuaternion(aiMatrix3x3(m));
-
-                // take shortest path by checking the inner product
-                // http://www.3dkingdoms.com/weekly/weekly.php?a=36
-                if (quat.x * lastq.x + quat.y * lastq.y + quat.z * lastq.z + quat.w * lastq.w < 0)
-                {
-                    quat.x = -quat.x;
-                    quat.y = -quat.y;
-                    quat.z = -quat.z;
-                    quat.w = -quat.w;
-                }
-                lastq = quat;
-
-                valOut[i].mValue = quat;
-            }
-        }
-
-        void FBXConverter::ConvertTransformOrder_TRStoSRT(aiQuatKey* out_quat, aiVectorKey* out_scale,
-            aiVectorKey* out_translation,
-            const KeyFrameListList& scaling,
-            const KeyFrameListList& translation,
-            const KeyFrameListList& rotation,
-            const KeyTimeList& times,
-            double& maxTime,
-            double& minTime,
-            Model::RotOrder order,
-            const aiVector3D& def_scale,
-            const aiVector3D& def_translate,
-            const aiVector3D& def_rotation)
-        {
-            if (rotation.size()) {
-                InterpolateKeys(out_quat, times, rotation, def_rotation, maxTime, minTime, order);
-            }
-            else {
-                for (size_t i = 0; i < times.size(); ++i) {
-                    out_quat[i].mTime = CONVERT_FBX_TIME(times[i]) * anim_fps;
-                    out_quat[i].mValue = EulerToQuaternion(def_rotation, order);
-                }
-            }
-
-            if (scaling.size()) {
-                InterpolateKeys(out_scale, times, scaling, def_scale, maxTime, minTime);
-            }
-            else {
-                for (size_t i = 0; i < times.size(); ++i) {
-                    out_scale[i].mTime = CONVERT_FBX_TIME(times[i]) * anim_fps;
-                    out_scale[i].mValue = def_scale;
-                }
-            }
-
-            if (translation.size()) {
-                InterpolateKeys(out_translation, times, translation, def_translate, maxTime, minTime);
-            }
-            else {
-                for (size_t i = 0; i < times.size(); ++i) {
-                    out_translation[i].mTime = CONVERT_FBX_TIME(times[i]) * anim_fps;
-                    out_translation[i].mValue = def_translate;
-                }
-            }
-
-            const size_t count = times.size();
-            for (size_t i = 0; i < count; ++i) {
-                aiQuaternion& r = out_quat[i].mValue;
-                aiVector3D& s = out_scale[i].mValue;
-                aiVector3D& t = out_translation[i].mValue;
-
-                aiMatrix4x4 mat, temp;
-                aiMatrix4x4::Translation(t, mat);
-                mat *= aiMatrix4x4(r.GetMatrix());
-                mat *= aiMatrix4x4::Scaling(s, temp);
-
-                mat.Decompose(s, r, t);
-            }
-        }
-
-        aiQuaternion FBXConverter::EulerToQuaternion(const aiVector3D& rot, Model::RotOrder order)
-        {
-            aiMatrix4x4 m;
-            GetRotationMatrix(order, rot, m);
-
-            return aiQuaternion(aiMatrix3x3(m));
-        }
-
-        void FBXConverter::ConvertScaleKeys(aiNodeAnim* na, const std::vector<const AnimationCurveNode*>& nodes, const LayerMap& /*layers*/,
-            int64_t start, int64_t stop,
-            double& maxTime,
-            double& minTime)
-        {
-            ai_assert(nodes.size());
-
-            // XXX for now, assume scale should be blended geometrically (i.e. two
-            // layers should be multiplied with each other). There is a FBX
-            // property in the layer to specify the behaviour, though.
-
-            const KeyFrameListList& inputs = GetKeyframeList(nodes, start, stop);
-            const KeyTimeList& keys = GetKeyTimeList(inputs);
-
-            na->mNumScalingKeys = static_cast<unsigned int>(keys.size());
-            na->mScalingKeys = new aiVectorKey[keys.size()];
-            if (keys.size() > 0) {
-                InterpolateKeys(na->mScalingKeys, keys, inputs, aiVector3D(1.0f, 1.0f, 1.0f), maxTime, minTime);
-            }
-        }
-
-        void FBXConverter::ConvertTranslationKeys(aiNodeAnim* na, const std::vector<const AnimationCurveNode*>& nodes,
-            const LayerMap& /*layers*/,
-            int64_t start, int64_t stop,
-            double& maxTime,
-            double& minTime)
-        {
-            ai_assert(nodes.size());
-
-            // XXX see notes in ConvertScaleKeys()
-            const KeyFrameListList& inputs = GetKeyframeList(nodes, start, stop);
-            const KeyTimeList& keys = GetKeyTimeList(inputs);
-
-            na->mNumPositionKeys = static_cast<unsigned int>(keys.size());
-            na->mPositionKeys = new aiVectorKey[keys.size()];
-            if (keys.size() > 0)
-                InterpolateKeys(na->mPositionKeys, keys, inputs, aiVector3D(0.0f, 0.0f, 0.0f), maxTime, minTime);
-        }
-
-        void FBXConverter::ConvertRotationKeys(aiNodeAnim* na, const std::vector<const AnimationCurveNode*>& nodes,
-            const LayerMap& /*layers*/,
-            int64_t start, int64_t stop,
-            double& maxTime,
-            double& minTime,
-            Model::RotOrder order)
-        {
-            ai_assert(nodes.size());
-
-            // XXX see notes in ConvertScaleKeys()
-            const std::vector< KeyFrameList >& inputs = GetKeyframeList(nodes, start, stop);
-            const KeyTimeList& keys = GetKeyTimeList(inputs);
-
-            na->mNumRotationKeys = static_cast<unsigned int>(keys.size());
-            na->mRotationKeys = new aiQuatKey[keys.size()];
-            if (!keys.empty()) {
-                InterpolateKeys(na->mRotationKeys, keys, inputs, aiVector3D(0.0f, 0.0f, 0.0f), maxTime, minTime, order);
-            }
-        }
-
-        void FBXConverter::ConvertGlobalSettings() {
-            if (nullptr == out) {
-                return;
-            }
-
-            out->mMetaData = aiMetadata::Alloc(15);
-            out->mMetaData->Set(0, "UpAxis", doc.GlobalSettings().UpAxis());
-            out->mMetaData->Set(1, "UpAxisSign", doc.GlobalSettings().UpAxisSign());
-            out->mMetaData->Set(2, "FrontAxis", doc.GlobalSettings().FrontAxis());
-            out->mMetaData->Set(3, "FrontAxisSign", doc.GlobalSettings().FrontAxisSign());
-            out->mMetaData->Set(4, "CoordAxis", doc.GlobalSettings().CoordAxis());
-            out->mMetaData->Set(5, "CoordAxisSign", doc.GlobalSettings().CoordAxisSign());
-            out->mMetaData->Set(6, "OriginalUpAxis", doc.GlobalSettings().OriginalUpAxis());
-            out->mMetaData->Set(7, "OriginalUpAxisSign", doc.GlobalSettings().OriginalUpAxisSign());
-            out->mMetaData->Set(8, "UnitScaleFactor", (double)doc.GlobalSettings().UnitScaleFactor());
-            out->mMetaData->Set(9, "OriginalUnitScaleFactor", doc.GlobalSettings().OriginalUnitScaleFactor());
-            out->mMetaData->Set(10, "AmbientColor", doc.GlobalSettings().AmbientColor());
-            out->mMetaData->Set(11, "FrameRate", (int)doc.GlobalSettings().TimeMode());
-            out->mMetaData->Set(12, "TimeSpanStart", doc.GlobalSettings().TimeSpanStart());
-            out->mMetaData->Set(13, "TimeSpanStop", doc.GlobalSettings().TimeSpanStop());
-            out->mMetaData->Set(14, "CustomFrameRate", doc.GlobalSettings().CustomFrameRate());
-        }
-
-        void FBXConverter::TransferDataToScene()
-        {
-            ai_assert(!out->mMeshes);
-            ai_assert(!out->mNumMeshes);
-
-            // note: the trailing () ensures initialization with NULL - not
-            // many C++ users seem to know this, so pointing it out to avoid
-            // confusion why this code works.
-
-            if (meshes.size()) {
-                out->mMeshes = new aiMesh*[meshes.size()]();
-                out->mNumMeshes = static_cast<unsigned int>(meshes.size());
-
-                std::swap_ranges(meshes.begin(), meshes.end(), out->mMeshes);
-            }
-
-            if (materials.size()) {
-                out->mMaterials = new aiMaterial*[materials.size()]();
-                out->mNumMaterials = static_cast<unsigned int>(materials.size());
-
-                std::swap_ranges(materials.begin(), materials.end(), out->mMaterials);
-            }
-
-            if (animations.size()) {
-                out->mAnimations = new aiAnimation*[animations.size()]();
-                out->mNumAnimations = static_cast<unsigned int>(animations.size());
-
-                std::swap_ranges(animations.begin(), animations.end(), out->mAnimations);
-            }
-
-            if (lights.size()) {
-                out->mLights = new aiLight*[lights.size()]();
-                out->mNumLights = static_cast<unsigned int>(lights.size());
-
-                std::swap_ranges(lights.begin(), lights.end(), out->mLights);
-            }
-
-            if (cameras.size()) {
-                out->mCameras = new aiCamera*[cameras.size()]();
-                out->mNumCameras = static_cast<unsigned int>(cameras.size());
-
-                std::swap_ranges(cameras.begin(), cameras.end(), out->mCameras);
-            }
-
-            if (textures.size()) {
-                out->mTextures = new aiTexture*[textures.size()]();
-                out->mNumTextures = static_cast<unsigned int>(textures.size());
-
-                std::swap_ranges(textures.begin(), textures.end(), out->mTextures);
-            }
-        }
-
-        // ------------------------------------------------------------------------------------------------
-        void ConvertToAssimpScene(aiScene* out, const Document& doc, bool removeEmptyBones)
-        {
-            FBXConverter converter(out, doc, removeEmptyBones);
-        }
-
-    } // !FBX
-} // !Assimp
-
-#endif
diff --git a/Engine/lib/assimp/code/FBX/FBXImporter.cpp b/Engine/lib/assimp/code/FBX/FBXImporter.cpp
deleted file mode 100644
index c8c1a6853..000000000
--- a/Engine/lib/assimp/code/FBX/FBXImporter.cpp
+++ /dev/null
@@ -1,206 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-r
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file  FBXImporter.cpp
- *  @brief Implementation of the FBX importer.
- */
-
-#ifndef ASSIMP_BUILD_NO_FBX_IMPORTER
-
-#include "FBXImporter.h"
-
-#include "FBXTokenizer.h"
-#include "FBXParser.h"
-#include "FBXUtil.h"
-#include "FBXDocument.h"
-#include "FBXConverter.h"
-
-#include <assimp/StreamReader.h>
-#include <assimp/MemoryIOWrapper.h>
-#include <assimp/Importer.hpp>
-#include <assimp/importerdesc.h>
-
-namespace Assimp {
-
-template<>
-const char* LogFunctions<FBXImporter>::Prefix() {
-    static auto prefix = "FBX: ";
-    return prefix;
-}
-
-}
-
-using namespace Assimp;
-using namespace Assimp::Formatter;
-using namespace Assimp::FBX;
-
-namespace {
-
-static const aiImporterDesc desc = {
-    "Autodesk FBX Importer",
-    "",
-    "",
-    "",
-    aiImporterFlags_SupportTextFlavour,
-    0,
-    0,
-    0,
-    0,
-    "fbx"
-};
-}
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by #Importer
-FBXImporter::FBXImporter()
-{
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-FBXImporter::~FBXImporter()
-{
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the class can handle the format of the given file.
-bool FBXImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
-{
-    const std::string& extension = GetExtension(pFile);
-    if (extension == std::string( desc.mFileExtensions ) ) {
-        return true;
-    }
-
-    else if ((!extension.length() || checkSig) && pIOHandler)   {
-        // at least ASCII-FBX files usually have a 'FBX' somewhere in their head
-        const char* tokens[] = {"fbx"};
-        return SearchFileHeaderForToken(pIOHandler,pFile,tokens,1);
-    }
-    return false;
-}
-
-// ------------------------------------------------------------------------------------------------
-// List all extensions handled by this loader
-const aiImporterDesc* FBXImporter::GetInfo () const
-{
-    return &desc;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Setup configuration properties for the loader
-void FBXImporter::SetupProperties(const Importer* pImp)
-{
-    settings.readAllLayers = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_ALL_GEOMETRY_LAYERS, true);
-    settings.readAllMaterials = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_ALL_MATERIALS, false);
-    settings.readMaterials = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_MATERIALS, true);
-    settings.readTextures = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_TEXTURES, true);
-    settings.readCameras = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_CAMERAS, true);
-    settings.readLights = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_LIGHTS, true);
-    settings.readAnimations = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_ANIMATIONS, true);
-    settings.strictMode = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_STRICT_MODE, false);
-    settings.preservePivots = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_PRESERVE_PIVOTS, true);
-    settings.optimizeEmptyAnimationCurves = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_OPTIMIZE_EMPTY_ANIMATION_CURVES, true);
-    settings.useLegacyEmbeddedTextureNaming = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_EMBEDDED_TEXTURES_LEGACY_NAMING, false);
-    settings.removeEmptyBones = pImp->GetPropertyBool(AI_CONFIG_IMPORT_REMOVE_EMPTY_BONES, true);
-    settings.convertToMeters = pImp->GetPropertyBool(AI_CONFIG_FBX_CONVERT_TO_M, false);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Imports the given file into the given scene structure.
-void FBXImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler)
-{
-    std::unique_ptr<IOStream> stream(pIOHandler->Open(pFile,"rb"));
-    if (!stream) {
-        ThrowException("Could not open file for reading");
-    }
-
-    // read entire file into memory - no streaming for this, fbx
-    // files can grow large, but the assimp output data structure
-    // then becomes very large, too. Assimp doesn't support
-    // streaming for its output data structures so the net win with
-    // streaming input data would be very low.
-    std::vector<char> contents;
-    contents.resize(stream->FileSize()+1);
-    stream->Read( &*contents.begin(), 1, contents.size()-1 );
-    contents[ contents.size() - 1 ] = 0;
-    const char* const begin = &*contents.begin();
-
-    // broadphase tokenizing pass in which we identify the core
-    // syntax elements of FBX (brackets, commas, key:value mappings)
-    TokenList tokens;
-    try {
-
-        bool is_binary = false;
-        if (!strncmp(begin,"Kaydara FBX Binary",18)) {
-            is_binary = true;
-            TokenizeBinary(tokens,begin,contents.size());
-        }
-        else {
-            Tokenize(tokens,begin);
-        }
-
-        // use this information to construct a very rudimentary
-        // parse-tree representing the FBX scope structure
-        Parser parser(tokens, is_binary);
-
-        // take the raw parse-tree and convert it to a FBX DOM
-        Document doc(parser,settings);
-
-        // convert the FBX DOM to aiScene
-        ConvertToAssimpScene(pScene, doc, settings.removeEmptyBones);
-
-        // size relative to cm
-        float size_relative_to_cm = doc.GlobalSettings().UnitScaleFactor();
-
-        // Set FBX file scale is relative to CM must be converted to M for
-        // assimp universal format (M)
-        SetFileScale( size_relative_to_cm * 0.01f);
-
-        std::for_each(tokens.begin(),tokens.end(),Util::delete_fun<Token>());
-    }
-    catch(std::exception&) {
-        std::for_each(tokens.begin(),tokens.end(),Util::delete_fun<Token>());
-        throw;
-    }
-}
-
-#endif // !ASSIMP_BUILD_NO_FBX_IMPORTER
diff --git a/Engine/lib/assimp/code/Importer/StepFile/StepFileGen1.cpp b/Engine/lib/assimp/code/Importer/StepFile/StepFileGen1.cpp
deleted file mode 100644
index 50c54818e..000000000
--- a/Engine/lib/assimp/code/Importer/StepFile/StepFileGen1.cpp
+++ /dev/null
@@ -1,2195 +0,0 @@
-/*
-Open Asset Import Library (ASSIMP)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2018, ASSIMP Development Team
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms, 
-with or without modification, are permitted provided that the 
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the ASSIMP team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the ASSIMP Development Team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** MACHINE-GENERATED by scripts/ICFImporter/CppGenerator.py */
-
-#ifndef ASSIMP_BUILD_NO_STEP_IMPORTER
-
-#include "code/Importer/StepFile/StepReaderGen.h"
-
-namespace Assimp {
-using namespace StepFile;
-
-namespace {
-
-	typedef EXPRESS::ConversionSchema::SchemaEntry SchemaEntry;
-
-	const SchemaEntry schema_raw[] =  {
-		SchemaEntry("absorbed_dose_measure",NULL )
-,		SchemaEntry("acceleration_measure",NULL )
-,		SchemaEntry("action_items",NULL )
-,		SchemaEntry("action_method_items",NULL )
-,		SchemaEntry("action_request_item",NULL )
-,		SchemaEntry("ahead_or_behind",NULL )
-,		SchemaEntry("amount_of_substance_measure",NULL )
-,		SchemaEntry("angle_direction_reference_select",NULL )
-,		SchemaEntry("angle_direction_reference_with_a2p3d_select",NULL )
-,		SchemaEntry("angle_relator",NULL )
-,		SchemaEntry("annotation_plane_element",NULL )
-,		SchemaEntry("annotation_representation_select",NULL )
-,		SchemaEntry("annotation_symbol_occurrence_item",NULL )
-,		SchemaEntry("annotation_text_occurrence_item",NULL )
-,		SchemaEntry("approval_item",NULL )
-,		SchemaEntry("approved_item",NULL )
-,		SchemaEntry("area_measure",NULL )
-,		SchemaEntry("area_or_view",NULL )
-,		SchemaEntry("attribute_classification_item",NULL )
-,		SchemaEntry("attribute_language_item",NULL )
-,		SchemaEntry("attribute_type",NULL )
-,		SchemaEntry("axis2_placement",NULL )
-,		SchemaEntry("b_spline_curve_form",NULL )
-,		SchemaEntry("b_spline_surface_form",NULL )
-,		SchemaEntry("base_solid_select",NULL )
-,		SchemaEntry("blend_end_condition_select",NULL )
-,		SchemaEntry("blend_radius_variation_type",NULL )
-,		SchemaEntry("boolean_operand",NULL )
-,		SchemaEntry("boolean_operator",NULL )
-,		SchemaEntry("box_characteristic_select",NULL )
-,		SchemaEntry("box_height",NULL )
-,		SchemaEntry("box_rotate_angle",NULL )
-,		SchemaEntry("box_slant_angle",NULL )
-,		SchemaEntry("box_width",NULL )
-,		SchemaEntry("camera_model_d3_multi_clipping_interection_select",NULL )
-,		SchemaEntry("camera_model_d3_multi_clipping_union_select",NULL )
-,		SchemaEntry("capacitance_measure",NULL )
-,		SchemaEntry("category_usage_item",NULL )
-,		SchemaEntry("cc_classified_item",NULL )
-,		SchemaEntry("cc_person_organization_item",NULL )
-,		SchemaEntry("cc_specified_item",NULL )
-,		SchemaEntry("celsius_temperature_measure",NULL )
-,		SchemaEntry("central_or_parallel",NULL )
-,		SchemaEntry("certification_item",NULL )
-,		SchemaEntry("certified_item",NULL )
-,		SchemaEntry("change_request_item",NULL )
-,		SchemaEntry("character_spacing_select",NULL )
-,		SchemaEntry("character_style_select",NULL )
-,		SchemaEntry("characterized_action_definition",NULL )
-,		SchemaEntry("characterized_definition",NULL )
-,		SchemaEntry("characterized_material_property",NULL )
-,		SchemaEntry("characterized_product_composition_value",NULL )
-,		SchemaEntry("characterized_product_definition",NULL )
-,		SchemaEntry("class_usage_effectivity_context_item",NULL )
-,		SchemaEntry("classification_item",NULL )
-,		SchemaEntry("classified_item",NULL )
-,		SchemaEntry("compound_item_definition",NULL )
-,		SchemaEntry("conductance_measure",NULL )
-,		SchemaEntry("configuration_design_item",NULL )
-,		SchemaEntry("configured_effectivity_context_item",NULL )
-,		SchemaEntry("configured_effectivity_item",NULL )
-,		SchemaEntry("constructive_geometry_representation_or_shape_represenation",NULL )
-,		SchemaEntry("context_dependent_measure",NULL )
-,		SchemaEntry("contract_item",NULL )
-,		SchemaEntry("contracted_item",NULL )
-,		SchemaEntry("count_measure",NULL )
-,		SchemaEntry("csg_primitive",NULL )
-,		SchemaEntry("csg_select",NULL )
-,		SchemaEntry("curve_font_or_scaled_curve_font_select",NULL )
-,		SchemaEntry("curve_on_surface",NULL )
-,		SchemaEntry("curve_or_annotation_curve_occurrence",NULL )
-,		SchemaEntry("curve_or_render",NULL )
-,		SchemaEntry("curve_style_font_select",NULL )
-,		SchemaEntry("date_and_time_item",NULL )
-,		SchemaEntry("date_item",NULL )
-,		SchemaEntry("date_time_item",NULL )
-,		SchemaEntry("date_time_or_event_occurrence",NULL )
-,		SchemaEntry("date_time_select",NULL )
-,		SchemaEntry("day_in_month_number",NULL )
-,		SchemaEntry("day_in_week_number",NULL )
-,		SchemaEntry("day_in_year_number",NULL )
-,		SchemaEntry("defined_symbol_select",NULL )
-,		SchemaEntry("derived_property_select",NULL )
-,		SchemaEntry("description_attribute_select",NULL )
-,		SchemaEntry("descriptive_measure",NULL )
-,		SchemaEntry("dimension_count",NULL )
-,		SchemaEntry("dimension_extent_usage",NULL )
-,		SchemaEntry("dimensional_characteristic",NULL )
-,		SchemaEntry("direction_count_select",NULL )
-,		SchemaEntry("document_identifier_assigned_item",NULL )
-,		SchemaEntry("document_reference_item",NULL )
-,		SchemaEntry("dose_equivalent_measure",NULL )
-,		SchemaEntry("draughting_callout_element",NULL )
-,		SchemaEntry("draughting_model_item_association_select",NULL )
-,		SchemaEntry("draughting_model_item_select",NULL )
-,		SchemaEntry("draughting_titled_item",NULL )
-,		SchemaEntry("effectivity_item",NULL )
-,		SchemaEntry("electric_charge_measure",NULL )
-,		SchemaEntry("electric_current_measure",NULL )
-,		SchemaEntry("electric_potential_measure",NULL )
-,		SchemaEntry("energy_measure",NULL )
-,		SchemaEntry("event_occurrence_item",NULL )
-,		SchemaEntry("external_identification_item",NULL )
-,		SchemaEntry("fill_area_style_tile_shape_select",NULL )
-,		SchemaEntry("fill_style_select",NULL )
-,		SchemaEntry("font_select",NULL )
-,		SchemaEntry("force_measure",NULL )
-,		SchemaEntry("founded_item_select",NULL )
-,		SchemaEntry("frequency_measure",NULL )
-,		SchemaEntry("generalized_surface_select",NULL )
-,		SchemaEntry("geometric_item_specific_usage_select",NULL )
-,		SchemaEntry("geometric_set_select",NULL )
-,		SchemaEntry("groupable_item",NULL )
-,		SchemaEntry("hour_in_day",NULL )
-,		SchemaEntry("id_attribute_select",NULL )
-,		SchemaEntry("identification_item",NULL )
-,		SchemaEntry("identifier",NULL )
-,		SchemaEntry("illuminance_measure",NULL )
-,		SchemaEntry("inductance_measure",NULL )
-,		SchemaEntry("instance_usage_context_select",NULL )
-,		SchemaEntry("invisibility_context",NULL )
-,		SchemaEntry("invisible_item",NULL )
-,		SchemaEntry("ir_usage_item",NULL )
-,		SchemaEntry("knot_type",NULL )
-,		SchemaEntry("label",NULL )
-,		SchemaEntry("layered_item",NULL )
-,		SchemaEntry("length_measure",NULL )
-,		SchemaEntry("limit_condition",NULL )
-,		SchemaEntry("list_of_reversible_topology_item",NULL )
-,		SchemaEntry("list_representation_item",NULL )
-,		SchemaEntry("luminous_flux_measure",NULL )
-,		SchemaEntry("luminous_intensity_measure",NULL )
-,		SchemaEntry("magnetic_flux_density_measure",NULL )
-,		SchemaEntry("magnetic_flux_measure",NULL )
-,		SchemaEntry("marker_select",NULL )
-,		SchemaEntry("marker_type",NULL )
-,		SchemaEntry("mass_measure",NULL )
-,		SchemaEntry("measure_value",NULL )
-,		SchemaEntry("mechanical_design_and_draughting_relationship_select",NULL )
-,		SchemaEntry("mechanical_design_geometric_presentation_area_items",NULL )
-,		SchemaEntry("mechanical_design_geometric_presentation_representation_items",NULL )
-,		SchemaEntry("message",NULL )
-,		SchemaEntry("minute_in_hour",NULL )
-,		SchemaEntry("month_in_year_number",NULL )
-,		SchemaEntry("multi_language_attribute_item",NULL )
-,		SchemaEntry("name_attribute_select",NULL )
-,		SchemaEntry("name_item",NULL )
-,		SchemaEntry("non_negative_length_measure",NULL )
-,		SchemaEntry("nonnegative_integer",NULL )
-,		SchemaEntry("null_style",NULL )
-,		SchemaEntry("numeric_measure",NULL )
-,		SchemaEntry("organization_item",NULL )
-,		SchemaEntry("orientation_basis_select",NULL )
-,		SchemaEntry("parameter_value",NULL )
-,		SchemaEntry("pcurve_or_surface",NULL )
-,		SchemaEntry("person_and_organization_item",NULL )
-,		SchemaEntry("person_organization_select",NULL )
-,		SchemaEntry("picture_representation_item_select",NULL )
-,		SchemaEntry("plane_angle_measure",NULL )
-,		SchemaEntry("plane_or_planar_box",NULL )
-,		SchemaEntry("point_and_vector_member",NULL )
-,		SchemaEntry("point_and_vector_members",NULL )
-,		SchemaEntry("point_path_members",NULL )
-,		SchemaEntry("positive_integer",NULL )
-,		SchemaEntry("positive_length_measure",NULL )
-,		SchemaEntry("positive_plane_angle_measure",NULL )
-,		SchemaEntry("positive_ratio_measure",NULL )
-,		SchemaEntry("power_measure",NULL )
-,		SchemaEntry("preferred_surface_curve_representation",NULL )
-,		SchemaEntry("presentable_text",NULL )
-,		SchemaEntry("presentation_representation_select",NULL )
-,		SchemaEntry("presentation_size_assignment_select",NULL )
-,		SchemaEntry("presentation_style_select",NULL )
-,		SchemaEntry("presented_item_select",NULL )
-,		SchemaEntry("pressure_measure",NULL )
-,		SchemaEntry("product_definition_or_assembly_relationship",NULL )
-,		SchemaEntry("product_definition_or_breakdown_element_usage",NULL )
-,		SchemaEntry("product_definition_or_product_definition_relationship",NULL )
-,		SchemaEntry("product_or_formation_or_definition",NULL )
-,		SchemaEntry("project_item",NULL )
-,		SchemaEntry("radioactivity_measure",NULL )
-,		SchemaEntry("ratio_measure",NULL )
-,		SchemaEntry("rendering_properties_select",NULL )
-,		SchemaEntry("represented_definition",NULL )
-,		SchemaEntry("requirement_assigned_item",NULL )
-,		SchemaEntry("requirement_satisfaction_item",NULL )
-,		SchemaEntry("requirement_source_item",NULL )
-,		SchemaEntry("resistance_measure",NULL )
-,		SchemaEntry("reversible_topology",NULL )
-,		SchemaEntry("reversible_topology_item",NULL )
-,		SchemaEntry("role_select",NULL )
-,		SchemaEntry("rule_superseded_item",NULL )
-,		SchemaEntry("second_in_minute",NULL )
-,		SchemaEntry("security_classification_item",NULL )
-,		SchemaEntry("set_of_reversible_topology_item",NULL )
-,		SchemaEntry("set_representation_item",NULL )
-,		SchemaEntry("shading_curve_method",NULL )
-,		SchemaEntry("shading_surface_method",NULL )
-,		SchemaEntry("shape_definition",NULL )
-,		SchemaEntry("shell",NULL )
-,		SchemaEntry("si_prefix",NULL )
-,		SchemaEntry("si_unit_name",NULL )
-,		SchemaEntry("size_select",NULL )
-,		SchemaEntry("sketch_basis_select",NULL )
-,		SchemaEntry("solid_angle_measure",NULL )
-,		SchemaEntry("source",NULL )
-,		SchemaEntry("source_item",NULL )
-,		SchemaEntry("start_request_item",NULL )
-,		SchemaEntry("string_representation_item_select",NULL )
-,		SchemaEntry("style_context_select",NULL )
-,		SchemaEntry("surface_side",NULL )
-,		SchemaEntry("surface_side_style_select",NULL )
-,		SchemaEntry("surface_style_element_select",NULL )
-,		SchemaEntry("symbol_style_select",NULL )
-,		SchemaEntry("text",NULL )
-,		SchemaEntry("text_alignment",NULL )
-,		SchemaEntry("text_delineation",NULL )
-,		SchemaEntry("text_or_character",NULL )
-,		SchemaEntry("text_path",NULL )
-,		SchemaEntry("text_string_representation_item",NULL )
-,		SchemaEntry("thermodynamic_temperature_measure",NULL )
-,		SchemaEntry("time_interval_item",NULL )
-,		SchemaEntry("time_measure",NULL )
-,		SchemaEntry("tolerance_method_definition",NULL )
-,		SchemaEntry("transformation",NULL )
-,		SchemaEntry("transition_code",NULL )
-,		SchemaEntry("trim_condition_select",NULL )
-,		SchemaEntry("trim_intent",NULL )
-,		SchemaEntry("trimming_preference",NULL )
-,		SchemaEntry("trimming_select",NULL )
-,		SchemaEntry("u_direction_count",NULL )
-,		SchemaEntry("unit",NULL )
-,		SchemaEntry("v_direction_count",NULL )
-,		SchemaEntry("value_qualifier",NULL )
-,		SchemaEntry("vector_or_direction",NULL )
-,		SchemaEntry("velocity_measure",NULL )
-,		SchemaEntry("volume_measure",NULL )
-,		SchemaEntry("week_in_year_number",NULL )
-,		SchemaEntry("work_item",NULL )
-,		SchemaEntry("year_number",NULL )
-,		SchemaEntry("measure_with_unit",&STEP::ObjectHelper<measure_with_unit,2>::Construct )
-,		SchemaEntry("absorbed_dose_measure_with_unit",&STEP::ObjectHelper<absorbed_dose_measure_with_unit,0>::Construct )
-,		SchemaEntry("derived_unit",&STEP::ObjectHelper<derived_unit,1>::Construct )
-,		SchemaEntry("absorbed_dose_unit",&STEP::ObjectHelper<absorbed_dose_unit,0>::Construct )
-,		SchemaEntry("abstract_variable",&STEP::ObjectHelper<abstract_variable,0>::Construct )
-,		SchemaEntry("acceleration_measure_with_unit",&STEP::ObjectHelper<acceleration_measure_with_unit,0>::Construct )
-,		SchemaEntry("acceleration_unit",&STEP::ObjectHelper<acceleration_unit,0>::Construct )
-,		SchemaEntry("action",&STEP::ObjectHelper<action,3>::Construct )
-,		SchemaEntry("action_assignment",&STEP::ObjectHelper<action_assignment,1>::Construct )
-,		SchemaEntry("action_directive",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("action_method",&STEP::ObjectHelper<action_method,4>::Construct )
-,		SchemaEntry("action_method_assignment",&STEP::ObjectHelper<action_method_assignment,2>::Construct )
-,		SchemaEntry("action_method_relationship",&STEP::ObjectHelper<action_method_relationship,4>::Construct )
-,		SchemaEntry("action_method_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("action_property",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("action_property_representation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("action_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("action_request_assignment",&STEP::ObjectHelper<action_request_assignment,1>::Construct )
-,		SchemaEntry("action_request_solution",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("action_request_status",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("action_status",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("address",&STEP::ObjectHelper<address,12>::Construct )
-,		SchemaEntry("representation",&STEP::ObjectHelper<representation,3>::Construct )
-,		SchemaEntry("shape_representation",&STEP::ObjectHelper<shape_representation,0>::Construct )
-,		SchemaEntry("advanced_brep_shape_representation",&STEP::ObjectHelper<advanced_brep_shape_representation,0>::Construct )
-,		SchemaEntry("face_surface",&STEP::ObjectHelper<face_surface,2>::Construct )
-,		SchemaEntry("advanced_face",&STEP::ObjectHelper<advanced_face,0>::Construct )
-,		SchemaEntry("alternate_product_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("amount_of_substance_measure_with_unit",&STEP::ObjectHelper<amount_of_substance_measure_with_unit,0>::Construct )
-,		SchemaEntry("named_unit",&STEP::ObjectHelper<named_unit,1>::Construct )
-,		SchemaEntry("amount_of_substance_unit",&STEP::ObjectHelper<amount_of_substance_unit,0>::Construct )
-,		SchemaEntry("angle_direction_reference",&STEP::ObjectHelper<angle_direction_reference,0>::Construct )
-,		SchemaEntry("representation_item",&STEP::ObjectHelper<representation_item,1>::Construct )
-,		SchemaEntry("geometric_representation_item",&STEP::ObjectHelper<geometric_representation_item,0>::Construct )
-,		SchemaEntry("draughting_callout",&STEP::ObjectHelper<draughting_callout,1>::Construct )
-,		SchemaEntry("dimension_curve_directed_callout",&STEP::ObjectHelper<dimension_curve_directed_callout,0>::Construct )
-,		SchemaEntry("angular_dimension",&STEP::ObjectHelper<angular_dimension,0>::Construct )
-,		SchemaEntry("shape_aspect_relationship",&STEP::ObjectHelper<shape_aspect_relationship,4>::Construct )
-,		SchemaEntry("dimensional_location",&STEP::ObjectHelper<dimensional_location,0>::Construct )
-,		SchemaEntry("angular_location",&STEP::ObjectHelper<angular_location,1>::Construct )
-,		SchemaEntry("dimensional_size",&STEP::ObjectHelper<dimensional_size,2>::Construct )
-,		SchemaEntry("angular_size",&STEP::ObjectHelper<angular_size,1>::Construct )
-,		SchemaEntry("geometric_tolerance",&STEP::ObjectHelper<geometric_tolerance,4>::Construct )
-,		SchemaEntry("geometric_tolerance_with_datum_reference",&STEP::ObjectHelper<geometric_tolerance_with_datum_reference,1>::Construct )
-,		SchemaEntry("angularity_tolerance",&STEP::ObjectHelper<angularity_tolerance,0>::Construct )
-,		SchemaEntry("styled_item",&STEP::ObjectHelper<styled_item,2>::Construct )
-,		SchemaEntry("annotation_occurrence",&STEP::ObjectHelper<annotation_occurrence,0>::Construct )
-,		SchemaEntry("annotation_curve_occurrence",&STEP::ObjectHelper<annotation_curve_occurrence,0>::Construct )
-,		SchemaEntry("annotation_fill_area",&STEP::ObjectHelper<annotation_fill_area,1>::Construct )
-,		SchemaEntry("annotation_fill_area_occurrence",&STEP::ObjectHelper<annotation_fill_area_occurrence,1>::Construct )
-,		SchemaEntry("annotation_occurrence_relationship",&STEP::ObjectHelper<annotation_occurrence_relationship,4>::Construct )
-,		SchemaEntry("annotation_occurrence_associativity",&STEP::ObjectHelper<annotation_occurrence_associativity,0>::Construct )
-,		SchemaEntry("annotation_plane",&STEP::ObjectHelper<annotation_plane,1>::Construct )
-,		SchemaEntry("annotation_symbol_occurrence",&STEP::ObjectHelper<annotation_symbol_occurrence,0>::Construct )
-,		SchemaEntry("annotation_subfigure_occurrence",&STEP::ObjectHelper<annotation_subfigure_occurrence,0>::Construct )
-,		SchemaEntry("mapped_item",&STEP::ObjectHelper<mapped_item,2>::Construct )
-,		SchemaEntry("annotation_symbol",&STEP::ObjectHelper<annotation_symbol,0>::Construct )
-,		SchemaEntry("annotation_text",&STEP::ObjectHelper<annotation_text,0>::Construct )
-,		SchemaEntry("annotation_text_character",&STEP::ObjectHelper<annotation_text_character,1>::Construct )
-,		SchemaEntry("annotation_text_occurrence",&STEP::ObjectHelper<annotation_text_occurrence,0>::Construct )
-,		SchemaEntry("shape_aspect",&STEP::ObjectHelper<shape_aspect,4>::Construct )
-,		SchemaEntry("derived_shape_aspect",&STEP::ObjectHelper<derived_shape_aspect,0>::Construct )
-,		SchemaEntry("apex",&STEP::ObjectHelper<apex,0>::Construct )
-,		SchemaEntry("application_context",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("application_context_element",&STEP::ObjectHelper<application_context_element,2>::Construct )
-,		SchemaEntry("application_protocol_definition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("applied_action_assignment",&STEP::ObjectHelper<applied_action_assignment,1>::Construct )
-,		SchemaEntry("applied_action_method_assignment",&STEP::ObjectHelper<applied_action_method_assignment,1>::Construct )
-,		SchemaEntry("applied_action_request_assignment",&STEP::ObjectHelper<applied_action_request_assignment,1>::Construct )
-,		SchemaEntry("approval_assignment",&STEP::ObjectHelper<approval_assignment,1>::Construct )
-,		SchemaEntry("applied_approval_assignment",&STEP::ObjectHelper<applied_approval_assignment,1>::Construct )
-,		SchemaEntry("attribute_classification_assignment",&STEP::ObjectHelper<attribute_classification_assignment,3>::Construct )
-,		SchemaEntry("applied_attribute_classification_assignment",&STEP::ObjectHelper<applied_attribute_classification_assignment,1>::Construct )
-,		SchemaEntry("certification_assignment",&STEP::ObjectHelper<certification_assignment,1>::Construct )
-,		SchemaEntry("applied_certification_assignment",&STEP::ObjectHelper<applied_certification_assignment,1>::Construct )
-,		SchemaEntry("classification_assignment",&STEP::ObjectHelper<classification_assignment,2>::Construct )
-,		SchemaEntry("applied_classification_assignment",&STEP::ObjectHelper<applied_classification_assignment,1>::Construct )
-,		SchemaEntry("contract_assignment",&STEP::ObjectHelper<contract_assignment,1>::Construct )
-,		SchemaEntry("applied_contract_assignment",&STEP::ObjectHelper<applied_contract_assignment,1>::Construct )
-,		SchemaEntry("date_and_time_assignment",&STEP::ObjectHelper<date_and_time_assignment,2>::Construct )
-,		SchemaEntry("applied_date_and_time_assignment",&STEP::ObjectHelper<applied_date_and_time_assignment,1>::Construct )
-,		SchemaEntry("date_assignment",&STEP::ObjectHelper<date_assignment,2>::Construct )
-,		SchemaEntry("applied_date_assignment",&STEP::ObjectHelper<applied_date_assignment,1>::Construct )
-,		SchemaEntry("document_reference",&STEP::ObjectHelper<document_reference,2>::Construct )
-,		SchemaEntry("applied_document_reference",&STEP::ObjectHelper<applied_document_reference,1>::Construct )
-,		SchemaEntry("document_usage_constraint_assignment",&STEP::ObjectHelper<document_usage_constraint_assignment,2>::Construct )
-,		SchemaEntry("applied_document_usage_constraint_assignment",&STEP::ObjectHelper<applied_document_usage_constraint_assignment,1>::Construct )
-,		SchemaEntry("effectivity_assignment",&STEP::ObjectHelper<effectivity_assignment,1>::Construct )
-,		SchemaEntry("applied_effectivity_assignment",&STEP::ObjectHelper<applied_effectivity_assignment,1>::Construct )
-,		SchemaEntry("event_occurrence_assignment",&STEP::ObjectHelper<event_occurrence_assignment,2>::Construct )
-,		SchemaEntry("applied_event_occurrence_assignment",&STEP::ObjectHelper<applied_event_occurrence_assignment,1>::Construct )
-,		SchemaEntry("identification_assignment",&STEP::ObjectHelper<identification_assignment,2>::Construct )
-,		SchemaEntry("external_identification_assignment",&STEP::ObjectHelper<external_identification_assignment,1>::Construct )
-,		SchemaEntry("applied_external_identification_assignment",&STEP::ObjectHelper<applied_external_identification_assignment,1>::Construct )
-,		SchemaEntry("group_assignment",&STEP::ObjectHelper<group_assignment,1>::Construct )
-,		SchemaEntry("applied_group_assignment",&STEP::ObjectHelper<applied_group_assignment,1>::Construct )
-,		SchemaEntry("applied_identification_assignment",&STEP::ObjectHelper<applied_identification_assignment,1>::Construct )
-,		SchemaEntry("name_assignment",&STEP::ObjectHelper<name_assignment,1>::Construct )
-,		SchemaEntry("applied_name_assignment",&STEP::ObjectHelper<applied_name_assignment,1>::Construct )
-,		SchemaEntry("organization_assignment",&STEP::ObjectHelper<organization_assignment,2>::Construct )
-,		SchemaEntry("applied_organization_assignment",&STEP::ObjectHelper<applied_organization_assignment,1>::Construct )
-,		SchemaEntry("organizational_project_assignment",&STEP::ObjectHelper<organizational_project_assignment,2>::Construct )
-,		SchemaEntry("applied_organizational_project_assignment",&STEP::ObjectHelper<applied_organizational_project_assignment,1>::Construct )
-,		SchemaEntry("person_and_organization_assignment",&STEP::ObjectHelper<person_and_organization_assignment,2>::Construct )
-,		SchemaEntry("applied_person_and_organization_assignment",&STEP::ObjectHelper<applied_person_and_organization_assignment,1>::Construct )
-,		SchemaEntry("presented_item",&STEP::ObjectHelper<presented_item,0>::Construct )
-,		SchemaEntry("applied_presented_item",&STEP::ObjectHelper<applied_presented_item,1>::Construct )
-,		SchemaEntry("security_classification_assignment",&STEP::ObjectHelper<security_classification_assignment,1>::Construct )
-,		SchemaEntry("applied_security_classification_assignment",&STEP::ObjectHelper<applied_security_classification_assignment,1>::Construct )
-,		SchemaEntry("time_interval_assignment",&STEP::ObjectHelper<time_interval_assignment,2>::Construct )
-,		SchemaEntry("applied_time_interval_assignment",&STEP::ObjectHelper<applied_time_interval_assignment,1>::Construct )
-,		SchemaEntry("applied_usage_right",&STEP::ObjectHelper<applied_usage_right,0>::Construct )
-,		SchemaEntry("approval",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("approval_date_time",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("approval_person_organization",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("approval_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("approval_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("approval_status",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("area_in_set",&STEP::ObjectHelper<area_in_set,2>::Construct )
-,		SchemaEntry("area_measure_with_unit",&STEP::ObjectHelper<area_measure_with_unit,0>::Construct )
-,		SchemaEntry("area_unit",&STEP::ObjectHelper<area_unit,0>::Construct )
-,		SchemaEntry("product_definition_relationship",&STEP::ObjectHelper<product_definition_relationship,5>::Construct )
-,		SchemaEntry("product_definition_usage",&STEP::ObjectHelper<product_definition_usage,0>::Construct )
-,		SchemaEntry("assembly_component_usage",&STEP::ObjectHelper<assembly_component_usage,1>::Construct )
-,		SchemaEntry("assembly_component_usage_substitute",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("assigned_requirement",&STEP::ObjectHelper<assigned_requirement,1>::Construct )
-,		SchemaEntry("compound_representation_item",&STEP::ObjectHelper<compound_representation_item,1>::Construct )
-,		SchemaEntry("atomic_formula",&STEP::ObjectHelper<atomic_formula,0>::Construct )
-,		SchemaEntry("attribute_assertion",&STEP::ObjectHelper<attribute_assertion,0>::Construct )
-,		SchemaEntry("attribute_language_assignment",&STEP::ObjectHelper<attribute_language_assignment,1>::Construct )
-,		SchemaEntry("attribute_value_assignment",&STEP::ObjectHelper<attribute_value_assignment,3>::Construct )
-,		SchemaEntry("attribute_value_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("auxiliary_geometric_representation_item",&STEP::ObjectHelper<auxiliary_geometric_representation_item,0>::Construct )
-,		SchemaEntry("placement",&STEP::ObjectHelper<placement,1>::Construct )
-,		SchemaEntry("axis1_placement",&STEP::ObjectHelper<axis1_placement,1>::Construct )
-,		SchemaEntry("axis2_placement_2d",&STEP::ObjectHelper<axis2_placement_2d,1>::Construct )
-,		SchemaEntry("axis2_placement_3d",&STEP::ObjectHelper<axis2_placement_3d,2>::Construct )
-,		SchemaEntry("curve",&STEP::ObjectHelper<curve,0>::Construct )
-,		SchemaEntry("bounded_curve",&STEP::ObjectHelper<bounded_curve,0>::Construct )
-,		SchemaEntry("b_spline_curve",&STEP::ObjectHelper<b_spline_curve,5>::Construct )
-,		SchemaEntry("b_spline_curve_with_knots",&STEP::ObjectHelper<b_spline_curve_with_knots,3>::Construct )
-,		SchemaEntry("surface",&STEP::ObjectHelper<surface,0>::Construct )
-,		SchemaEntry("bounded_surface",&STEP::ObjectHelper<bounded_surface,0>::Construct )
-,		SchemaEntry("b_spline_surface",&STEP::ObjectHelper<b_spline_surface,6>::Construct )
-,		SchemaEntry("b_spline_surface_with_knots",&STEP::ObjectHelper<b_spline_surface_with_knots,5>::Construct )
-,		SchemaEntry("product_definition",&STEP::ObjectHelper<product_definition,4>::Construct )
-,		SchemaEntry("rule_software_definition",&STEP::ObjectHelper<rule_software_definition,0>::Construct )
-,		SchemaEntry("rule_definition",&STEP::ObjectHelper<rule_definition,0>::Construct )
-,		SchemaEntry("back_chaining_rule",&STEP::ObjectHelper<back_chaining_rule,0>::Construct )
-,		SchemaEntry("back_chaining_rule_body",&STEP::ObjectHelper<back_chaining_rule_body,0>::Construct )
-,		SchemaEntry("colour",&STEP::ObjectHelper<colour,0>::Construct )
-,		SchemaEntry("background_colour",&STEP::ObjectHelper<background_colour,1>::Construct )
-,		SchemaEntry("beveled_sheet_representation",&STEP::ObjectHelper<beveled_sheet_representation,0>::Construct )
-,		SchemaEntry("bezier_curve",&STEP::ObjectHelper<bezier_curve,0>::Construct )
-,		SchemaEntry("bezier_surface",&STEP::ObjectHelper<bezier_surface,0>::Construct )
-,		SchemaEntry("generic_expression",&STEP::ObjectHelper<generic_expression,0>::Construct )
-,		SchemaEntry("binary_generic_expression",&STEP::ObjectHelper<binary_generic_expression,1>::Construct )
-,		SchemaEntry("binary_numeric_expression",&STEP::ObjectHelper<binary_numeric_expression,0>::Construct )
-,		SchemaEntry("binary_representation_item",&STEP::ObjectHelper<binary_representation_item,1>::Construct )
-,		SchemaEntry("block",&STEP::ObjectHelper<block,4>::Construct )
-,		SchemaEntry("expression",&STEP::ObjectHelper<expression,0>::Construct )
-,		SchemaEntry("boolean_expression",&STEP::ObjectHelper<boolean_expression,0>::Construct )
-,		SchemaEntry("boolean_literal",&STEP::ObjectHelper<boolean_literal,1>::Construct )
-,		SchemaEntry("boolean_representation_item",&STEP::ObjectHelper<boolean_representation_item,0>::Construct )
-,		SchemaEntry("boolean_result",&STEP::ObjectHelper<boolean_result,3>::Construct )
-,		SchemaEntry("composite_curve",&STEP::ObjectHelper<composite_curve,2>::Construct )
-,		SchemaEntry("composite_curve_on_surface",&STEP::ObjectHelper<composite_curve_on_surface,0>::Construct )
-,		SchemaEntry("boundary_curve",&STEP::ObjectHelper<boundary_curve,0>::Construct )
-,		SchemaEntry("bounded_pcurve",&STEP::ObjectHelper<bounded_pcurve,0>::Construct )
-,		SchemaEntry("bounded_surface_curve",&STEP::ObjectHelper<bounded_surface_curve,0>::Construct )
-,		SchemaEntry("founded_item",&STEP::ObjectHelper<founded_item,0>::Construct )
-,		SchemaEntry("box_domain",&STEP::ObjectHelper<box_domain,4>::Construct )
-,		SchemaEntry("half_space_solid",&STEP::ObjectHelper<half_space_solid,2>::Construct )
-,		SchemaEntry("boxed_half_space",&STEP::ObjectHelper<boxed_half_space,1>::Construct )
-,		SchemaEntry("breakdown_context",&STEP::ObjectHelper<breakdown_context,0>::Construct )
-,		SchemaEntry("breakdown_element_group_assignment",&STEP::ObjectHelper<breakdown_element_group_assignment,1>::Construct )
-,		SchemaEntry("breakdown_element_realization",&STEP::ObjectHelper<breakdown_element_realization,0>::Construct )
-,		SchemaEntry("breakdown_element_usage",&STEP::ObjectHelper<breakdown_element_usage,0>::Construct )
-,		SchemaEntry("breakdown_of",&STEP::ObjectHelper<breakdown_of,0>::Construct )
-,		SchemaEntry("solid_model",&STEP::ObjectHelper<solid_model,0>::Construct )
-,		SchemaEntry("manifold_solid_brep",&STEP::ObjectHelper<manifold_solid_brep,1>::Construct )
-,		SchemaEntry("brep_with_voids",&STEP::ObjectHelper<brep_with_voids,1>::Construct )
-,		SchemaEntry("bytes_representation_item",&STEP::ObjectHelper<bytes_representation_item,0>::Construct )
-,		SchemaEntry("date",&STEP::ObjectHelper<date,1>::Construct )
-,		SchemaEntry("calendar_date",&STEP::ObjectHelper<calendar_date,2>::Construct )
-,		SchemaEntry("camera_image",&STEP::ObjectHelper<camera_image,0>::Construct )
-,		SchemaEntry("camera_image_3d_with_scale",&STEP::ObjectHelper<camera_image_3d_with_scale,0>::Construct )
-,		SchemaEntry("camera_model",&STEP::ObjectHelper<camera_model,0>::Construct )
-,		SchemaEntry("camera_model_d3",&STEP::ObjectHelper<camera_model_d3,2>::Construct )
-,		SchemaEntry("camera_model_d3_multi_clipping",&STEP::ObjectHelper<camera_model_d3_multi_clipping,1>::Construct )
-,		SchemaEntry("camera_model_d3_multi_clipping_intersection",&STEP::ObjectHelper<camera_model_d3_multi_clipping_intersection,1>::Construct )
-,		SchemaEntry("camera_model_d3_multi_clipping_union",&STEP::ObjectHelper<camera_model_d3_multi_clipping_union,1>::Construct )
-,		SchemaEntry("camera_model_d3_with_hlhsr",&STEP::ObjectHelper<camera_model_d3_with_hlhsr,1>::Construct )
-,		SchemaEntry("camera_model_with_light_sources",&STEP::ObjectHelper<camera_model_with_light_sources,1>::Construct )
-,		SchemaEntry("representation_map",&STEP::ObjectHelper<representation_map,2>::Construct )
-,		SchemaEntry("camera_usage",&STEP::ObjectHelper<camera_usage,0>::Construct )
-,		SchemaEntry("capacitance_measure_with_unit",&STEP::ObjectHelper<capacitance_measure_with_unit,0>::Construct )
-,		SchemaEntry("capacitance_unit",&STEP::ObjectHelper<capacitance_unit,0>::Construct )
-,		SchemaEntry("point",&STEP::ObjectHelper<point,0>::Construct )
-,		SchemaEntry("cartesian_point",&STEP::ObjectHelper<cartesian_point,1>::Construct )
-,		SchemaEntry("cartesian_transformation_operator",&STEP::ObjectHelper<cartesian_transformation_operator,4>::Construct )
-,		SchemaEntry("cartesian_transformation_operator_2d",&STEP::ObjectHelper<cartesian_transformation_operator_2d,0>::Construct )
-,		SchemaEntry("cartesian_transformation_operator_3d",&STEP::ObjectHelper<cartesian_transformation_operator_3d,1>::Construct )
-,		SchemaEntry("cc_design_approval",&STEP::ObjectHelper<cc_design_approval,1>::Construct )
-,		SchemaEntry("cc_design_certification",&STEP::ObjectHelper<cc_design_certification,1>::Construct )
-,		SchemaEntry("cc_design_contract",&STEP::ObjectHelper<cc_design_contract,1>::Construct )
-,		SchemaEntry("cc_design_date_and_time_assignment",&STEP::ObjectHelper<cc_design_date_and_time_assignment,1>::Construct )
-,		SchemaEntry("cc_design_person_and_organization_assignment",&STEP::ObjectHelper<cc_design_person_and_organization_assignment,1>::Construct )
-,		SchemaEntry("cc_design_security_classification",&STEP::ObjectHelper<cc_design_security_classification,1>::Construct )
-,		SchemaEntry("cc_design_specification_reference",&STEP::ObjectHelper<cc_design_specification_reference,1>::Construct )
-,		SchemaEntry("celsius_temperature_measure_with_unit",&STEP::ObjectHelper<celsius_temperature_measure_with_unit,0>::Construct )
-,		SchemaEntry("centre_of_symmetry",&STEP::ObjectHelper<centre_of_symmetry,0>::Construct )
-,		SchemaEntry("certification",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("certification_type",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("change",&STEP::ObjectHelper<change,1>::Construct )
-,		SchemaEntry("change_request",&STEP::ObjectHelper<change_request,1>::Construct )
-,		SchemaEntry("character_glyph_font_usage",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("character_glyph_style_outline",&STEP::ObjectHelper<character_glyph_style_outline,1>::Construct )
-,		SchemaEntry("character_glyph_style_stroke",&STEP::ObjectHelper<character_glyph_style_stroke,1>::Construct )
-,		SchemaEntry("symbol_representation",&STEP::ObjectHelper<symbol_representation,0>::Construct )
-,		SchemaEntry("generic_character_glyph_symbol",&STEP::ObjectHelper<generic_character_glyph_symbol,0>::Construct )
-,		SchemaEntry("character_glyph_symbol",&STEP::ObjectHelper<character_glyph_symbol,2>::Construct )
-,		SchemaEntry("character_glyph_symbol_outline",&STEP::ObjectHelper<character_glyph_symbol_outline,1>::Construct )
-,		SchemaEntry("character_glyph_symbol_stroke",&STEP::ObjectHelper<character_glyph_symbol_stroke,1>::Construct )
-,		SchemaEntry("general_property",&STEP::ObjectHelper<general_property,3>::Construct )
-,		SchemaEntry("characteristic_data_column_header",&STEP::ObjectHelper<characteristic_data_column_header,0>::Construct )
-,		SchemaEntry("general_property_relationship",&STEP::ObjectHelper<general_property_relationship,4>::Construct )
-,		SchemaEntry("characteristic_data_column_header_link",&STEP::ObjectHelper<characteristic_data_column_header_link,0>::Construct )
-,		SchemaEntry("characteristic_data_table_header",&STEP::ObjectHelper<characteristic_data_table_header,0>::Construct )
-,		SchemaEntry("characteristic_data_table_header_decomposition",&STEP::ObjectHelper<characteristic_data_table_header_decomposition,0>::Construct )
-,		SchemaEntry("group",&STEP::ObjectHelper<group,2>::Construct )
-,		SchemaEntry("characteristic_type",&STEP::ObjectHelper<characteristic_type,0>::Construct )
-,		SchemaEntry("characterized_class",&STEP::ObjectHelper<characterized_class,0>::Construct )
-,		SchemaEntry("characterized_object",&STEP::ObjectHelper<characterized_object,2>::Construct )
-,		SchemaEntry("conic",&STEP::ObjectHelper<conic,1>::Construct )
-,		SchemaEntry("circle",&STEP::ObjectHelper<circle,1>::Construct )
-,		SchemaEntry("circular_runout_tolerance",&STEP::ObjectHelper<circular_runout_tolerance,0>::Construct )
-,		SchemaEntry("class_t",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("class_by_extension",&STEP::ObjectHelper<class_by_extension,0>::Construct )
-,		SchemaEntry("class_by_intension",&STEP::ObjectHelper<class_by_intension,0>::Construct )
-,		SchemaEntry("class_system",&STEP::ObjectHelper<class_system,0>::Construct )
-,		SchemaEntry("effectivity_context_assignment",&STEP::ObjectHelper<effectivity_context_assignment,2>::Construct )
-,		SchemaEntry("class_usage_effectivity_context_assignment",&STEP::ObjectHelper<class_usage_effectivity_context_assignment,1>::Construct )
-,		SchemaEntry("classification_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("topological_representation_item",&STEP::ObjectHelper<topological_representation_item,0>::Construct )
-,		SchemaEntry("connected_face_set",&STEP::ObjectHelper<connected_face_set,1>::Construct )
-,		SchemaEntry("closed_shell",&STEP::ObjectHelper<closed_shell,0>::Construct )
-,		SchemaEntry("coaxiality_tolerance",&STEP::ObjectHelper<coaxiality_tolerance,0>::Construct )
-,		SchemaEntry("colour_specification",&STEP::ObjectHelper<colour_specification,1>::Construct )
-,		SchemaEntry("colour_rgb",&STEP::ObjectHelper<colour_rgb,3>::Construct )
-,		SchemaEntry("common_datum",&STEP::ObjectHelper<common_datum,0>::Construct )
-,		SchemaEntry("comparison_expression",&STEP::ObjectHelper<comparison_expression,0>::Construct )
-,		SchemaEntry("complex_clause",&STEP::ObjectHelper<complex_clause,0>::Construct )
-,		SchemaEntry("complex_conjunctive_clause",&STEP::ObjectHelper<complex_conjunctive_clause,0>::Construct )
-,		SchemaEntry("complex_disjunctive_clause",&STEP::ObjectHelper<complex_disjunctive_clause,0>::Construct )
-,		SchemaEntry("modified_solid",&STEP::ObjectHelper<modified_solid,2>::Construct )
-,		SchemaEntry("shelled_solid",&STEP::ObjectHelper<shelled_solid,2>::Construct )
-,		SchemaEntry("complex_shelled_solid",&STEP::ObjectHelper<complex_shelled_solid,1>::Construct )
-,		SchemaEntry("composite_assembly_definition",&STEP::ObjectHelper<composite_assembly_definition,0>::Construct )
-,		SchemaEntry("composite_assembly_sequence_definition",&STEP::ObjectHelper<composite_assembly_sequence_definition,0>::Construct )
-,		SchemaEntry("laminate_table",&STEP::ObjectHelper<laminate_table,0>::Construct )
-,		SchemaEntry("part_laminate_table",&STEP::ObjectHelper<part_laminate_table,0>::Construct )
-,		SchemaEntry("composite_assembly_table",&STEP::ObjectHelper<composite_assembly_table,0>::Construct )
-,		SchemaEntry("composite_curve_segment",&STEP::ObjectHelper<composite_curve_segment,3>::Construct )
-,		SchemaEntry("material_designation",&STEP::ObjectHelper<material_designation,2>::Construct )
-,		SchemaEntry("composite_material_designation",&STEP::ObjectHelper<composite_material_designation,0>::Construct )
-,		SchemaEntry("composite_shape_aspect",&STEP::ObjectHelper<composite_shape_aspect,0>::Construct )
-,		SchemaEntry("composite_sheet_representation",&STEP::ObjectHelper<composite_sheet_representation,0>::Construct )
-,		SchemaEntry("composite_text",&STEP::ObjectHelper<composite_text,1>::Construct )
-,		SchemaEntry("composite_text_with_associated_curves",&STEP::ObjectHelper<composite_text_with_associated_curves,1>::Construct )
-,		SchemaEntry("composite_text_with_blanking_box",&STEP::ObjectHelper<composite_text_with_blanking_box,1>::Construct )
-,		SchemaEntry("composite_text_with_delineation",&STEP::ObjectHelper<composite_text_with_delineation,1>::Construct )
-,		SchemaEntry("composite_text_with_extent",&STEP::ObjectHelper<composite_text_with_extent,1>::Construct )
-,		SchemaEntry("compound_shape_representation",&STEP::ObjectHelper<compound_shape_representation,0>::Construct )
-,		SchemaEntry("concentricity_tolerance",&STEP::ObjectHelper<concentricity_tolerance,0>::Construct )
-,		SchemaEntry("concept_feature_operator",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("concept_feature_relationship",&STEP::ObjectHelper<concept_feature_relationship,4>::Construct )
-,		SchemaEntry("concept_feature_relationship_with_condition",&STEP::ObjectHelper<concept_feature_relationship_with_condition,1>::Construct )
-,		SchemaEntry("product_concept_feature",&STEP::ObjectHelper<product_concept_feature,3>::Construct )
-,		SchemaEntry("conditional_concept_feature",&STEP::ObjectHelper<conditional_concept_feature,1>::Construct )
-,		SchemaEntry("conductance_measure_with_unit",&STEP::ObjectHelper<conductance_measure_with_unit,0>::Construct )
-,		SchemaEntry("conductance_unit",&STEP::ObjectHelper<conductance_unit,0>::Construct )
-,		SchemaEntry("configuration_item",&STEP::ObjectHelper<configuration_item,5>::Construct )
-,		SchemaEntry("configurable_item",&STEP::ObjectHelper<configurable_item,1>::Construct )
-,		SchemaEntry("configuration_design",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("effectivity",&STEP::ObjectHelper<effectivity,1>::Construct )
-,		SchemaEntry("product_definition_effectivity",&STEP::ObjectHelper<product_definition_effectivity,1>::Construct )
-,		SchemaEntry("configuration_effectivity",&STEP::ObjectHelper<configuration_effectivity,1>::Construct )
-,		SchemaEntry("configuration_item_relationship",&STEP::ObjectHelper<configuration_item_relationship,4>::Construct )
-,		SchemaEntry("configuration_item_hierarchical_relationship",&STEP::ObjectHelper<configuration_item_hierarchical_relationship,0>::Construct )
-,		SchemaEntry("configuration_item_revision_sequence",&STEP::ObjectHelper<configuration_item_revision_sequence,0>::Construct )
-,		SchemaEntry("configured_effectivity_assignment",&STEP::ObjectHelper<configured_effectivity_assignment,1>::Construct )
-,		SchemaEntry("configured_effectivity_context_assignment",&STEP::ObjectHelper<configured_effectivity_context_assignment,1>::Construct )
-,		SchemaEntry("conical_stepped_hole_transition",&STEP::ObjectHelper<conical_stepped_hole_transition,3>::Construct )
-,		SchemaEntry("elementary_surface",&STEP::ObjectHelper<elementary_surface,1>::Construct )
-,		SchemaEntry("conical_surface",&STEP::ObjectHelper<conical_surface,2>::Construct )
-,		SchemaEntry("connected_edge_set",&STEP::ObjectHelper<connected_edge_set,1>::Construct )
-,		SchemaEntry("connected_face_sub_set",&STEP::ObjectHelper<connected_face_sub_set,1>::Construct )
-,		SchemaEntry("constructive_geometry_representation",&STEP::ObjectHelper<constructive_geometry_representation,0>::Construct )
-,		SchemaEntry("representation_relationship",&STEP::ObjectHelper<representation_relationship,4>::Construct )
-,		SchemaEntry("constructive_geometry_representation_relationship",&STEP::ObjectHelper<constructive_geometry_representation_relationship,0>::Construct )
-,		SchemaEntry("contact_ratio_representation",&STEP::ObjectHelper<contact_ratio_representation,0>::Construct )
-,		SchemaEntry("invisibility",&STEP::ObjectHelper<invisibility,1>::Construct )
-,		SchemaEntry("context_dependent_invisibility",&STEP::ObjectHelper<context_dependent_invisibility,1>::Construct )
-,		SchemaEntry("over_riding_styled_item",&STEP::ObjectHelper<over_riding_styled_item,1>::Construct )
-,		SchemaEntry("context_dependent_over_riding_styled_item",&STEP::ObjectHelper<context_dependent_over_riding_styled_item,1>::Construct )
-,		SchemaEntry("context_dependent_shape_representation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("context_dependent_unit",&STEP::ObjectHelper<context_dependent_unit,1>::Construct )
-,		SchemaEntry("contract",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("contract_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("contract_type",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("conversion_based_unit",&STEP::ObjectHelper<conversion_based_unit,2>::Construct )
-,		SchemaEntry("coordinated_universal_time_offset",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("csg_shape_representation",&STEP::ObjectHelper<csg_shape_representation,0>::Construct )
-,		SchemaEntry("csg_solid",&STEP::ObjectHelper<csg_solid,1>::Construct )
-,		SchemaEntry("currency",&STEP::ObjectHelper<currency,0>::Construct )
-,		SchemaEntry("currency_measure_with_unit",&STEP::ObjectHelper<currency_measure_with_unit,0>::Construct )
-,		SchemaEntry("curve_bounded_surface",&STEP::ObjectHelper<curve_bounded_surface,3>::Construct )
-,		SchemaEntry("curve_dimension",&STEP::ObjectHelper<curve_dimension,0>::Construct )
-,		SchemaEntry("curve_replica",&STEP::ObjectHelper<curve_replica,2>::Construct )
-,		SchemaEntry("curve_style",&STEP::ObjectHelper<curve_style,4>::Construct )
-,		SchemaEntry("curve_style_font",&STEP::ObjectHelper<curve_style_font,2>::Construct )
-,		SchemaEntry("curve_style_font_and_scaling",&STEP::ObjectHelper<curve_style_font_and_scaling,3>::Construct )
-,		SchemaEntry("curve_style_font_pattern",&STEP::ObjectHelper<curve_style_font_pattern,2>::Construct )
-,		SchemaEntry("curve_style_rendering",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("curve_swept_solid_shape_representation",&STEP::ObjectHelper<curve_swept_solid_shape_representation,0>::Construct )
-,		SchemaEntry("cylindrical_surface",&STEP::ObjectHelper<cylindrical_surface,1>::Construct )
-,		SchemaEntry("cylindricity_tolerance",&STEP::ObjectHelper<cylindricity_tolerance,0>::Construct )
-,		SchemaEntry("data_environment",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("date_and_time",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("date_representation_item",&STEP::ObjectHelper<date_representation_item,0>::Construct )
-,		SchemaEntry("date_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("date_time_representation_item",&STEP::ObjectHelper<date_time_representation_item,0>::Construct )
-,		SchemaEntry("date_time_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("dated_effectivity",&STEP::ObjectHelper<dated_effectivity,2>::Construct )
-,		SchemaEntry("datum",&STEP::ObjectHelper<datum,1>::Construct )
-,		SchemaEntry("datum_feature",&STEP::ObjectHelper<datum_feature,0>::Construct )
-,		SchemaEntry("datum_feature_callout",&STEP::ObjectHelper<datum_feature_callout,0>::Construct )
-,		SchemaEntry("datum_reference",&STEP::ObjectHelper<datum_reference,2>::Construct )
-,		SchemaEntry("datum_target",&STEP::ObjectHelper<datum_target,1>::Construct )
-,		SchemaEntry("datum_target_callout",&STEP::ObjectHelper<datum_target_callout,0>::Construct )
-,		SchemaEntry("default_tolerance_table",&STEP::ObjectHelper<default_tolerance_table,0>::Construct )
-,		SchemaEntry("default_tolerance_table_cell",&STEP::ObjectHelper<default_tolerance_table_cell,0>::Construct )
-,		SchemaEntry("defined_symbol",&STEP::ObjectHelper<defined_symbol,2>::Construct )
-,		SchemaEntry("definitional_representation",&STEP::ObjectHelper<definitional_representation,0>::Construct )
-,		SchemaEntry("definitional_representation_relationship",&STEP::ObjectHelper<definitional_representation_relationship,0>::Construct )
-,		SchemaEntry("definitional_representation_relationship_with_same_context",&STEP::ObjectHelper<definitional_representation_relationship_with_same_context,0>::Construct )
-,		SchemaEntry("degenerate_pcurve",&STEP::ObjectHelper<degenerate_pcurve,2>::Construct )
-,		SchemaEntry("toroidal_surface",&STEP::ObjectHelper<toroidal_surface,2>::Construct )
-,		SchemaEntry("degenerate_toroidal_surface",&STEP::ObjectHelper<degenerate_toroidal_surface,1>::Construct )
-,		SchemaEntry("derived_unit_element",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("description_attribute",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("descriptive_representation_item",&STEP::ObjectHelper<descriptive_representation_item,1>::Construct )
-,		SchemaEntry("product_definition_context",&STEP::ObjectHelper<product_definition_context,1>::Construct )
-,		SchemaEntry("design_context",&STEP::ObjectHelper<design_context,0>::Construct )
-,		SchemaEntry("design_make_from_relationship",&STEP::ObjectHelper<design_make_from_relationship,0>::Construct )
-,		SchemaEntry("diameter_dimension",&STEP::ObjectHelper<diameter_dimension,0>::Construct )
-,		SchemaEntry("ratio_measure_with_unit",&STEP::ObjectHelper<ratio_measure_with_unit,0>::Construct )
-,		SchemaEntry("dielectric_constant_measure_with_unit",&STEP::ObjectHelper<dielectric_constant_measure_with_unit,0>::Construct )
-,		SchemaEntry("dimension_callout",&STEP::ObjectHelper<dimension_callout,0>::Construct )
-,		SchemaEntry("draughting_callout_relationship",&STEP::ObjectHelper<draughting_callout_relationship,4>::Construct )
-,		SchemaEntry("dimension_callout_component_relationship",&STEP::ObjectHelper<dimension_callout_component_relationship,0>::Construct )
-,		SchemaEntry("dimension_callout_relationship",&STEP::ObjectHelper<dimension_callout_relationship,0>::Construct )
-,		SchemaEntry("dimension_curve",&STEP::ObjectHelper<dimension_curve,0>::Construct )
-,		SchemaEntry("terminator_symbol",&STEP::ObjectHelper<terminator_symbol,1>::Construct )
-,		SchemaEntry("dimension_curve_terminator",&STEP::ObjectHelper<dimension_curve_terminator,1>::Construct )
-,		SchemaEntry("dimension_curve_terminator_to_projection_curve_associativity",&STEP::ObjectHelper<dimension_curve_terminator_to_projection_curve_associativity,0>::Construct )
-,		SchemaEntry("dimension_pair",&STEP::ObjectHelper<dimension_pair,0>::Construct )
-,		SchemaEntry("dimension_related_tolerance_zone_element",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("dimension_text_associativity",&STEP::ObjectHelper<dimension_text_associativity,0>::Construct )
-,		SchemaEntry("dimensional_characteristic_representation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("dimensional_exponents",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("dimensional_location_with_path",&STEP::ObjectHelper<dimensional_location_with_path,1>::Construct )
-,		SchemaEntry("dimensional_size_with_path",&STEP::ObjectHelper<dimensional_size_with_path,1>::Construct )
-,		SchemaEntry("executed_action",&STEP::ObjectHelper<executed_action,0>::Construct )
-,		SchemaEntry("directed_action",&STEP::ObjectHelper<directed_action,1>::Construct )
-,		SchemaEntry("directed_dimensional_location",&STEP::ObjectHelper<directed_dimensional_location,0>::Construct )
-,		SchemaEntry("direction",&STEP::ObjectHelper<direction,1>::Construct )
-,		SchemaEntry("document",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("document_file",&STEP::ObjectHelper<document_file,0>::Construct )
-,		SchemaEntry("document_identifier",&STEP::ObjectHelper<document_identifier,0>::Construct )
-,		SchemaEntry("document_identifier_assignment",&STEP::ObjectHelper<document_identifier_assignment,1>::Construct )
-,		SchemaEntry("document_product_association",&STEP::ObjectHelper<document_product_association,4>::Construct )
-,		SchemaEntry("document_product_equivalence",&STEP::ObjectHelper<document_product_equivalence,0>::Construct )
-,		SchemaEntry("document_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("document_representation_type",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("document_type",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("document_usage_constraint",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("document_usage_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("dose_equivalent_measure_with_unit",&STEP::ObjectHelper<dose_equivalent_measure_with_unit,0>::Construct )
-,		SchemaEntry("dose_equivalent_unit",&STEP::ObjectHelper<dose_equivalent_unit,0>::Construct )
-,		SchemaEntry("double_offset_shelled_solid",&STEP::ObjectHelper<double_offset_shelled_solid,1>::Construct )
-,		SchemaEntry("item_defined_transformation",&STEP::ObjectHelper<item_defined_transformation,4>::Construct )
-,		SchemaEntry("transformation_with_derived_angle",&STEP::ObjectHelper<transformation_with_derived_angle,0>::Construct )
-,		SchemaEntry("draped_defined_transformation",&STEP::ObjectHelper<draped_defined_transformation,0>::Construct )
-,		SchemaEntry("draughting_annotation_occurrence",&STEP::ObjectHelper<draughting_annotation_occurrence,0>::Construct )
-,		SchemaEntry("draughting_elements",&STEP::ObjectHelper<draughting_elements,0>::Construct )
-,		SchemaEntry("draughting_model",&STEP::ObjectHelper<draughting_model,0>::Construct )
-,		SchemaEntry("item_identified_representation_usage",&STEP::ObjectHelper<item_identified_representation_usage,5>::Construct )
-,		SchemaEntry("draughting_model_item_association",&STEP::ObjectHelper<draughting_model_item_association,0>::Construct )
-,		SchemaEntry("pre_defined_colour",&STEP::ObjectHelper<pre_defined_colour,0>::Construct )
-,		SchemaEntry("draughting_pre_defined_colour",&STEP::ObjectHelper<draughting_pre_defined_colour,0>::Construct )
-,		SchemaEntry("pre_defined_item",&STEP::ObjectHelper<pre_defined_item,1>::Construct )
-,		SchemaEntry("pre_defined_curve_font",&STEP::ObjectHelper<pre_defined_curve_font,0>::Construct )
-,		SchemaEntry("draughting_pre_defined_curve_font",&STEP::ObjectHelper<draughting_pre_defined_curve_font,0>::Construct )
-,		SchemaEntry("pre_defined_text_font",&STEP::ObjectHelper<pre_defined_text_font,0>::Construct )
-,		SchemaEntry("draughting_pre_defined_text_font",&STEP::ObjectHelper<draughting_pre_defined_text_font,0>::Construct )
-,		SchemaEntry("draughting_subfigure_representation",&STEP::ObjectHelper<draughting_subfigure_representation,0>::Construct )
-,		SchemaEntry("draughting_symbol_representation",&STEP::ObjectHelper<draughting_symbol_representation,0>::Construct )
-,		SchemaEntry("text_literal",&STEP::ObjectHelper<text_literal,5>::Construct )
-,		SchemaEntry("text_literal_with_delineation",&STEP::ObjectHelper<text_literal_with_delineation,1>::Construct )
-,		SchemaEntry("draughting_text_literal_with_delineation",&STEP::ObjectHelper<draughting_text_literal_with_delineation,0>::Construct )
-,		SchemaEntry("draughting_title",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("drawing_definition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("presentation_set",&STEP::ObjectHelper<presentation_set,0>::Construct )
-,		SchemaEntry("drawing_revision",&STEP::ObjectHelper<drawing_revision,3>::Construct )
-,		SchemaEntry("drawing_revision_sequence",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("presentation_representation",&STEP::ObjectHelper<presentation_representation,0>::Construct )
-,		SchemaEntry("presentation_area",&STEP::ObjectHelper<presentation_area,0>::Construct )
-,		SchemaEntry("drawing_sheet_revision",&STEP::ObjectHelper<drawing_sheet_revision,1>::Construct )
-,		SchemaEntry("drawing_sheet_revision_sequence",&STEP::ObjectHelper<drawing_sheet_revision_sequence,0>::Construct )
-,		SchemaEntry("drawing_sheet_revision_usage",&STEP::ObjectHelper<drawing_sheet_revision_usage,1>::Construct )
-,		SchemaEntry("edge",&STEP::ObjectHelper<edge,2>::Construct )
-,		SchemaEntry("edge_based_wireframe_model",&STEP::ObjectHelper<edge_based_wireframe_model,1>::Construct )
-,		SchemaEntry("edge_based_wireframe_shape_representation",&STEP::ObjectHelper<edge_based_wireframe_shape_representation,0>::Construct )
-,		SchemaEntry("edge_blended_solid",&STEP::ObjectHelper<edge_blended_solid,1>::Construct )
-,		SchemaEntry("edge_curve",&STEP::ObjectHelper<edge_curve,2>::Construct )
-,		SchemaEntry("edge_loop",&STEP::ObjectHelper<edge_loop,0>::Construct )
-,		SchemaEntry("effectivity_context_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("effectivity_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("electric_charge_measure_with_unit",&STEP::ObjectHelper<electric_charge_measure_with_unit,0>::Construct )
-,		SchemaEntry("electric_charge_unit",&STEP::ObjectHelper<electric_charge_unit,0>::Construct )
-,		SchemaEntry("electric_current_measure_with_unit",&STEP::ObjectHelper<electric_current_measure_with_unit,0>::Construct )
-,		SchemaEntry("electric_current_unit",&STEP::ObjectHelper<electric_current_unit,0>::Construct )
-,		SchemaEntry("electric_potential_measure_with_unit",&STEP::ObjectHelper<electric_potential_measure_with_unit,0>::Construct )
-,		SchemaEntry("electric_potential_unit",&STEP::ObjectHelper<electric_potential_unit,0>::Construct )
-,		SchemaEntry("elementary_brep_shape_representation",&STEP::ObjectHelper<elementary_brep_shape_representation,0>::Construct )
-,		SchemaEntry("ellipse",&STEP::ObjectHelper<ellipse,2>::Construct )
-,		SchemaEntry("energy_measure_with_unit",&STEP::ObjectHelper<energy_measure_with_unit,0>::Construct )
-,		SchemaEntry("energy_unit",&STEP::ObjectHelper<energy_unit,0>::Construct )
-,		SchemaEntry("property_definition",&STEP::ObjectHelper<property_definition,3>::Construct )
-,		SchemaEntry("fact_type",&STEP::ObjectHelper<fact_type,0>::Construct )
-,		SchemaEntry("entity_assertion",&STEP::ObjectHelper<entity_assertion,0>::Construct )
-,		SchemaEntry("enum_reference_prefix",&STEP::ObjectHelper<enum_reference_prefix,0>::Construct )
-,		SchemaEntry("environment",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("evaluated_characteristic",&STEP::ObjectHelper<evaluated_characteristic,0>::Construct )
-,		SchemaEntry("evaluated_degenerate_pcurve",&STEP::ObjectHelper<evaluated_degenerate_pcurve,1>::Construct )
-,		SchemaEntry("evaluation_product_definition",&STEP::ObjectHelper<evaluation_product_definition,0>::Construct )
-,		SchemaEntry("event_occurrence",&STEP::ObjectHelper<event_occurrence,3>::Construct )
-,		SchemaEntry("event_occurrence_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("event_occurrence_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("product_concept_feature_category",&STEP::ObjectHelper<product_concept_feature_category,0>::Construct )
-,		SchemaEntry("exclusive_product_concept_feature_category",&STEP::ObjectHelper<exclusive_product_concept_feature_category,0>::Construct )
-,		SchemaEntry("uncertainty_qualifier",&STEP::ObjectHelper<uncertainty_qualifier,2>::Construct )
-,		SchemaEntry("standard_uncertainty",&STEP::ObjectHelper<standard_uncertainty,1>::Construct )
-,		SchemaEntry("expanded_uncertainty",&STEP::ObjectHelper<expanded_uncertainty,1>::Construct )
-,		SchemaEntry("representation_item_relationship",&STEP::ObjectHelper<representation_item_relationship,4>::Construct )
-,		SchemaEntry("explicit_procedural_representation_item_relationship",&STEP::ObjectHelper<explicit_procedural_representation_item_relationship,0>::Construct )
-,		SchemaEntry("explicit_procedural_geometric_representation_item_relationship",&STEP::ObjectHelper<explicit_procedural_geometric_representation_item_relationship,0>::Construct )
-,		SchemaEntry("explicit_procedural_representation_relationship",&STEP::ObjectHelper<explicit_procedural_representation_relationship,0>::Construct )
-,		SchemaEntry("explicit_procedural_shape_representation_relationship",&STEP::ObjectHelper<explicit_procedural_shape_representation_relationship,0>::Construct )
-,		SchemaEntry("expression_conversion_based_unit",&STEP::ObjectHelper<expression_conversion_based_unit,0>::Construct )
-,		SchemaEntry("extension",&STEP::ObjectHelper<extension,0>::Construct )
-,		SchemaEntry("extent",&STEP::ObjectHelper<extent,0>::Construct )
-,		SchemaEntry("external_source",&STEP::ObjectHelper<external_source,1>::Construct )
-,		SchemaEntry("external_class_library",&STEP::ObjectHelper<external_class_library,0>::Construct )
-,		SchemaEntry("external_source_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("externally_defined_class",&STEP::ObjectHelper<externally_defined_class,0>::Construct )
-,		SchemaEntry("externally_defined_colour",&STEP::ObjectHelper<externally_defined_colour,0>::Construct )
-,		SchemaEntry("externally_defined_context_dependent_unit",&STEP::ObjectHelper<externally_defined_context_dependent_unit,0>::Construct )
-,		SchemaEntry("externally_defined_conversion_based_unit",&STEP::ObjectHelper<externally_defined_conversion_based_unit,0>::Construct )
-,		SchemaEntry("externally_defined_currency",&STEP::ObjectHelper<externally_defined_currency,0>::Construct )
-,		SchemaEntry("externally_defined_item",&STEP::ObjectHelper<externally_defined_item,2>::Construct )
-,		SchemaEntry("externally_defined_curve_font",&STEP::ObjectHelper<externally_defined_curve_font,0>::Construct )
-,		SchemaEntry("externally_defined_dimension_definition",&STEP::ObjectHelper<externally_defined_dimension_definition,0>::Construct )
-,		SchemaEntry("externally_defined_general_property",&STEP::ObjectHelper<externally_defined_general_property,0>::Construct )
-,		SchemaEntry("externally_defined_hatch_style",&STEP::ObjectHelper<externally_defined_hatch_style,0>::Construct )
-,		SchemaEntry("externally_defined_item_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("externally_defined_marker",&STEP::ObjectHelper<externally_defined_marker,0>::Construct )
-,		SchemaEntry("picture_representation_item",&STEP::ObjectHelper<picture_representation_item,0>::Construct )
-,		SchemaEntry("externally_defined_picture_representation_item",&STEP::ObjectHelper<externally_defined_picture_representation_item,0>::Construct )
-,		SchemaEntry("externally_defined_representation_item",&STEP::ObjectHelper<externally_defined_representation_item,0>::Construct )
-,		SchemaEntry("externally_defined_string",&STEP::ObjectHelper<externally_defined_string,0>::Construct )
-,		SchemaEntry("externally_defined_symbol",&STEP::ObjectHelper<externally_defined_symbol,0>::Construct )
-,		SchemaEntry("externally_defined_terminator_symbol",&STEP::ObjectHelper<externally_defined_terminator_symbol,0>::Construct )
-,		SchemaEntry("externally_defined_text_font",&STEP::ObjectHelper<externally_defined_text_font,0>::Construct )
-,		SchemaEntry("externally_defined_tile",&STEP::ObjectHelper<externally_defined_tile,0>::Construct )
-,		SchemaEntry("externally_defined_tile_style",&STEP::ObjectHelper<externally_defined_tile_style,0>::Construct )
-,		SchemaEntry("swept_area_solid",&STEP::ObjectHelper<swept_area_solid,1>::Construct )
-,		SchemaEntry("extruded_area_solid",&STEP::ObjectHelper<extruded_area_solid,2>::Construct )
-,		SchemaEntry("swept_face_solid",&STEP::ObjectHelper<swept_face_solid,1>::Construct )
-,		SchemaEntry("extruded_face_solid",&STEP::ObjectHelper<extruded_face_solid,2>::Construct )
-,		SchemaEntry("extruded_face_solid_with_trim_conditions",&STEP::ObjectHelper<extruded_face_solid_with_trim_conditions,6>::Construct )
-,		SchemaEntry("extruded_face_solid_with_draft_angle",&STEP::ObjectHelper<extruded_face_solid_with_draft_angle,1>::Construct )
-,		SchemaEntry("extruded_face_solid_with_multiple_draft_angles",&STEP::ObjectHelper<extruded_face_solid_with_multiple_draft_angles,1>::Construct )
-,		SchemaEntry("face",&STEP::ObjectHelper<face,1>::Construct )
-,		SchemaEntry("face_based_surface_model",&STEP::ObjectHelper<face_based_surface_model,1>::Construct )
-,		SchemaEntry("face_bound",&STEP::ObjectHelper<face_bound,2>::Construct )
-,		SchemaEntry("face_outer_bound",&STEP::ObjectHelper<face_outer_bound,0>::Construct )
-,		SchemaEntry("faceted_brep",&STEP::ObjectHelper<faceted_brep,0>::Construct )
-,		SchemaEntry("faceted_brep_shape_representation",&STEP::ObjectHelper<faceted_brep_shape_representation,0>::Construct )
-,		SchemaEntry("fill_area_style",&STEP::ObjectHelper<fill_area_style,2>::Construct )
-,		SchemaEntry("fill_area_style_colour",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("fill_area_style_hatching",&STEP::ObjectHelper<fill_area_style_hatching,5>::Construct )
-,		SchemaEntry("fill_area_style_tile_coloured_region",&STEP::ObjectHelper<fill_area_style_tile_coloured_region,2>::Construct )
-,		SchemaEntry("fill_area_style_tile_curve_with_style",&STEP::ObjectHelper<fill_area_style_tile_curve_with_style,1>::Construct )
-,		SchemaEntry("fill_area_style_tile_symbol_with_style",&STEP::ObjectHelper<fill_area_style_tile_symbol_with_style,1>::Construct )
-,		SchemaEntry("fill_area_style_tiles",&STEP::ObjectHelper<fill_area_style_tiles,3>::Construct )
-,		SchemaEntry("shape_representation_relationship",&STEP::ObjectHelper<shape_representation_relationship,0>::Construct )
-,		SchemaEntry("flat_pattern_ply_representation_relationship",&STEP::ObjectHelper<flat_pattern_ply_representation_relationship,0>::Construct )
-,		SchemaEntry("flatness_tolerance",&STEP::ObjectHelper<flatness_tolerance,0>::Construct )
-,		SchemaEntry("force_measure_with_unit",&STEP::ObjectHelper<force_measure_with_unit,0>::Construct )
-,		SchemaEntry("force_unit",&STEP::ObjectHelper<force_unit,0>::Construct )
-,		SchemaEntry("forward_chaining_rule",&STEP::ObjectHelper<forward_chaining_rule,0>::Construct )
-,		SchemaEntry("forward_chaining_rule_premise",&STEP::ObjectHelper<forward_chaining_rule_premise,0>::Construct )
-,		SchemaEntry("frequency_measure_with_unit",&STEP::ObjectHelper<frequency_measure_with_unit,0>::Construct )
-,		SchemaEntry("frequency_unit",&STEP::ObjectHelper<frequency_unit,0>::Construct )
-,		SchemaEntry("func",&STEP::ObjectHelper<func,0>::Construct )
-,		SchemaEntry("functional_breakdown_context",&STEP::ObjectHelper<functional_breakdown_context,0>::Construct )
-,		SchemaEntry("functional_element_usage",&STEP::ObjectHelper<functional_element_usage,0>::Construct )
-,		SchemaEntry("functionally_defined_transformation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("general_material_property",&STEP::ObjectHelper<general_material_property,0>::Construct )
-,		SchemaEntry("general_property_association",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("simple_generic_expression",&STEP::ObjectHelper<simple_generic_expression,0>::Construct )
-,		SchemaEntry("generic_literal",&STEP::ObjectHelper<generic_literal,0>::Construct )
-,		SchemaEntry("generic_variable",&STEP::ObjectHelper<generic_variable,0>::Construct )
-,		SchemaEntry("geometric_alignment",&STEP::ObjectHelper<geometric_alignment,0>::Construct )
-,		SchemaEntry("geometric_set",&STEP::ObjectHelper<geometric_set,1>::Construct )
-,		SchemaEntry("geometric_curve_set",&STEP::ObjectHelper<geometric_curve_set,0>::Construct )
-,		SchemaEntry("geometric_intersection",&STEP::ObjectHelper<geometric_intersection,0>::Construct )
-,		SchemaEntry("geometric_item_specific_usage",&STEP::ObjectHelper<geometric_item_specific_usage,0>::Construct )
-,		SchemaEntry("geometric_model_element_relationship",&STEP::ObjectHelper<geometric_model_element_relationship,0>::Construct )
-,		SchemaEntry("representation_context",&STEP::ObjectHelper<representation_context,2>::Construct )
-,		SchemaEntry("geometric_representation_context",&STEP::ObjectHelper<geometric_representation_context,1>::Construct )
-,		SchemaEntry("geometric_tolerance_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("geometric_tolerance_with_defined_unit",&STEP::ObjectHelper<geometric_tolerance_with_defined_unit,1>::Construct )
-,		SchemaEntry("geometrical_tolerance_callout",&STEP::ObjectHelper<geometrical_tolerance_callout,0>::Construct )
-,		SchemaEntry("geometrically_bounded_2d_wireframe_representation",&STEP::ObjectHelper<geometrically_bounded_2d_wireframe_representation,0>::Construct )
-,		SchemaEntry("geometrically_bounded_surface_shape_representation",&STEP::ObjectHelper<geometrically_bounded_surface_shape_representation,0>::Construct )
-,		SchemaEntry("geometrically_bounded_wireframe_shape_representation",&STEP::ObjectHelper<geometrically_bounded_wireframe_shape_representation,0>::Construct )
-,		SchemaEntry("global_assignment",&STEP::ObjectHelper<global_assignment,0>::Construct )
-,		SchemaEntry("global_uncertainty_assigned_context",&STEP::ObjectHelper<global_uncertainty_assigned_context,1>::Construct )
-,		SchemaEntry("global_unit_assigned_context",&STEP::ObjectHelper<global_unit_assigned_context,1>::Construct )
-,		SchemaEntry("ground_fact",&STEP::ObjectHelper<ground_fact,0>::Construct )
-,		SchemaEntry("group_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("hardness_representation",&STEP::ObjectHelper<hardness_representation,0>::Construct )
-,		SchemaEntry("hidden_element_over_riding_styled_item",&STEP::ObjectHelper<hidden_element_over_riding_styled_item,0>::Construct )
-,		SchemaEntry("hyperbola",&STEP::ObjectHelper<hyperbola,2>::Construct )
-,		SchemaEntry("id_attribute",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("identification_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("illuminance_measure_with_unit",&STEP::ObjectHelper<illuminance_measure_with_unit,0>::Construct )
-,		SchemaEntry("illuminance_unit",&STEP::ObjectHelper<illuminance_unit,0>::Construct )
-,		SchemaEntry("included_text_block",&STEP::ObjectHelper<included_text_block,0>::Construct )
-,		SchemaEntry("inclusion_product_concept_feature",&STEP::ObjectHelper<inclusion_product_concept_feature,0>::Construct )
-,		SchemaEntry("user_selected_elements",&STEP::ObjectHelper<user_selected_elements,1>::Construct )
-,		SchemaEntry("indirectly_selected_elements",&STEP::ObjectHelper<indirectly_selected_elements,1>::Construct )
-,		SchemaEntry("indirectly_selected_shape_elements",&STEP::ObjectHelper<indirectly_selected_shape_elements,0>::Construct )
-,		SchemaEntry("inductance_measure_with_unit",&STEP::ObjectHelper<inductance_measure_with_unit,0>::Construct )
-,		SchemaEntry("inductance_unit",&STEP::ObjectHelper<inductance_unit,0>::Construct )
-,		SchemaEntry("information_right",&STEP::ObjectHelper<information_right,0>::Construct )
-,		SchemaEntry("information_usage_right",&STEP::ObjectHelper<information_usage_right,0>::Construct )
-,		SchemaEntry("instance_usage_context_assignment",&STEP::ObjectHelper<instance_usage_context_assignment,1>::Construct )
-,		SchemaEntry("instanced_feature",&STEP::ObjectHelper<instanced_feature,0>::Construct )
-,		SchemaEntry("literal_number",&STEP::ObjectHelper<literal_number,1>::Construct )
-,		SchemaEntry("int_literal",&STEP::ObjectHelper<int_literal,0>::Construct )
-,		SchemaEntry("integer_representation_item",&STEP::ObjectHelper<integer_representation_item,0>::Construct )
-,		SchemaEntry("surface_curve",&STEP::ObjectHelper<surface_curve,3>::Construct )
-,		SchemaEntry("intersection_curve",&STEP::ObjectHelper<intersection_curve,0>::Construct )
-,		SchemaEntry("interval_expression",&STEP::ObjectHelper<interval_expression,0>::Construct )
-,		SchemaEntry("iso4217_currency",&STEP::ObjectHelper<iso4217_currency,0>::Construct )
-,		SchemaEntry("known_source",&STEP::ObjectHelper<known_source,0>::Construct )
-,		SchemaEntry("laid_defined_transformation",&STEP::ObjectHelper<laid_defined_transformation,0>::Construct )
-,		SchemaEntry("language",&STEP::ObjectHelper<language,0>::Construct )
-,		SchemaEntry("leader_curve",&STEP::ObjectHelper<leader_curve,0>::Construct )
-,		SchemaEntry("leader_directed_callout",&STEP::ObjectHelper<leader_directed_callout,0>::Construct )
-,		SchemaEntry("leader_directed_dimension",&STEP::ObjectHelper<leader_directed_dimension,0>::Construct )
-,		SchemaEntry("leader_terminator",&STEP::ObjectHelper<leader_terminator,0>::Construct )
-,		SchemaEntry("length_measure_with_unit",&STEP::ObjectHelper<length_measure_with_unit,0>::Construct )
-,		SchemaEntry("length_unit",&STEP::ObjectHelper<length_unit,0>::Construct )
-,		SchemaEntry("light_source",&STEP::ObjectHelper<light_source,1>::Construct )
-,		SchemaEntry("light_source_ambient",&STEP::ObjectHelper<light_source_ambient,0>::Construct )
-,		SchemaEntry("light_source_directional",&STEP::ObjectHelper<light_source_directional,1>::Construct )
-,		SchemaEntry("light_source_positional",&STEP::ObjectHelper<light_source_positional,3>::Construct )
-,		SchemaEntry("light_source_spot",&STEP::ObjectHelper<light_source_spot,6>::Construct )
-,		SchemaEntry("limits_and_fits",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("line",&STEP::ObjectHelper<line,2>::Construct )
-,		SchemaEntry("line_profile_tolerance",&STEP::ObjectHelper<line_profile_tolerance,0>::Construct )
-,		SchemaEntry("linear_dimension",&STEP::ObjectHelper<linear_dimension,0>::Construct )
-,		SchemaEntry("simple_clause",&STEP::ObjectHelper<simple_clause,0>::Construct )
-,		SchemaEntry("literal_conjunction",&STEP::ObjectHelper<literal_conjunction,0>::Construct )
-,		SchemaEntry("literal_disjunction",&STEP::ObjectHelper<literal_disjunction,0>::Construct )
-,		SchemaEntry("local_time",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("logical_literal",&STEP::ObjectHelper<logical_literal,1>::Construct )
-,		SchemaEntry("logical_representation_item",&STEP::ObjectHelper<logical_representation_item,0>::Construct )
-,		SchemaEntry("loop",&STEP::ObjectHelper<loop,0>::Construct )
-,		SchemaEntry("loss_tangent_measure_with_unit",&STEP::ObjectHelper<loss_tangent_measure_with_unit,0>::Construct )
-,		SchemaEntry("lot_effectivity",&STEP::ObjectHelper<lot_effectivity,2>::Construct )
-,		SchemaEntry("luminous_flux_measure_with_unit",&STEP::ObjectHelper<luminous_flux_measure_with_unit,0>::Construct )
-,		SchemaEntry("luminous_flux_unit",&STEP::ObjectHelper<luminous_flux_unit,0>::Construct )
-,		SchemaEntry("luminous_intensity_measure_with_unit",&STEP::ObjectHelper<luminous_intensity_measure_with_unit,0>::Construct )
-,		SchemaEntry("luminous_intensity_unit",&STEP::ObjectHelper<luminous_intensity_unit,0>::Construct )
-,		SchemaEntry("magnetic_flux_density_measure_with_unit",&STEP::ObjectHelper<magnetic_flux_density_measure_with_unit,0>::Construct )
-,		SchemaEntry("magnetic_flux_density_unit",&STEP::ObjectHelper<magnetic_flux_density_unit,0>::Construct )
-,		SchemaEntry("magnetic_flux_measure_with_unit",&STEP::ObjectHelper<magnetic_flux_measure_with_unit,0>::Construct )
-,		SchemaEntry("magnetic_flux_unit",&STEP::ObjectHelper<magnetic_flux_unit,0>::Construct )
-,		SchemaEntry("make_from_usage_option",&STEP::ObjectHelper<make_from_usage_option,3>::Construct )
-,		SchemaEntry("manifold_subsurface_shape_representation",&STEP::ObjectHelper<manifold_subsurface_shape_representation,0>::Construct )
-,		SchemaEntry("manifold_surface_shape_representation",&STEP::ObjectHelper<manifold_surface_shape_representation,0>::Construct )
-,		SchemaEntry("mass_measure_with_unit",&STEP::ObjectHelper<mass_measure_with_unit,0>::Construct )
-,		SchemaEntry("mass_unit",&STEP::ObjectHelper<mass_unit,0>::Construct )
-,		SchemaEntry("material_designation_characterization",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("material_property",&STEP::ObjectHelper<material_property,0>::Construct )
-,		SchemaEntry("property_definition_representation",&STEP::ObjectHelper<property_definition_representation,2>::Construct )
-,		SchemaEntry("material_property_representation",&STEP::ObjectHelper<material_property_representation,1>::Construct )
-,		SchemaEntry("measure_qualification",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("measure_representation_item",&STEP::ObjectHelper<measure_representation_item,0>::Construct )
-,		SchemaEntry("product_context",&STEP::ObjectHelper<product_context,1>::Construct )
-,		SchemaEntry("mechanical_context",&STEP::ObjectHelper<mechanical_context,0>::Construct )
-,		SchemaEntry("mechanical_design_and_draughting_relationship",&STEP::ObjectHelper<mechanical_design_and_draughting_relationship,0>::Construct )
-,		SchemaEntry("mechanical_design_geometric_presentation_area",&STEP::ObjectHelper<mechanical_design_geometric_presentation_area,0>::Construct )
-,		SchemaEntry("mechanical_design_geometric_presentation_representation",&STEP::ObjectHelper<mechanical_design_geometric_presentation_representation,0>::Construct )
-,		SchemaEntry("mechanical_design_presentation_representation_with_draughting",&STEP::ObjectHelper<mechanical_design_presentation_representation_with_draughting,0>::Construct )
-,		SchemaEntry("mechanical_design_shaded_presentation_area",&STEP::ObjectHelper<mechanical_design_shaded_presentation_area,0>::Construct )
-,		SchemaEntry("mechanical_design_shaded_presentation_representation",&STEP::ObjectHelper<mechanical_design_shaded_presentation_representation,0>::Construct )
-,		SchemaEntry("min_and_major_ply_orientation_basis",&STEP::ObjectHelper<min_and_major_ply_orientation_basis,0>::Construct )
-,		SchemaEntry("modified_geometric_tolerance",&STEP::ObjectHelper<modified_geometric_tolerance,1>::Construct )
-,		SchemaEntry("modified_solid_with_placed_configuration",&STEP::ObjectHelper<modified_solid_with_placed_configuration,1>::Construct )
-,		SchemaEntry("moments_of_inertia_representation",&STEP::ObjectHelper<moments_of_inertia_representation,0>::Construct )
-,		SchemaEntry("multi_language_attribute_assignment",&STEP::ObjectHelper<multi_language_attribute_assignment,1>::Construct )
-,		SchemaEntry("multiple_arity_boolean_expression",&STEP::ObjectHelper<multiple_arity_boolean_expression,0>::Construct )
-,		SchemaEntry("multiple_arity_generic_expression",&STEP::ObjectHelper<multiple_arity_generic_expression,1>::Construct )
-,		SchemaEntry("multiple_arity_numeric_expression",&STEP::ObjectHelper<multiple_arity_numeric_expression,0>::Construct )
-,		SchemaEntry("name_attribute",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("next_assembly_usage_occurrence",&STEP::ObjectHelper<next_assembly_usage_occurrence,0>::Construct )
-,		SchemaEntry("non_manifold_surface_shape_representation",&STEP::ObjectHelper<non_manifold_surface_shape_representation,0>::Construct )
-,		SchemaEntry("null_representation_item",&STEP::ObjectHelper<null_representation_item,0>::Construct )
-,		SchemaEntry("numeric_expression",&STEP::ObjectHelper<numeric_expression,0>::Construct )
-,		SchemaEntry("object_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("offset_curve_2d",&STEP::ObjectHelper<offset_curve_2d,3>::Construct )
-,		SchemaEntry("offset_curve_3d",&STEP::ObjectHelper<offset_curve_3d,4>::Construct )
-,		SchemaEntry("offset_surface",&STEP::ObjectHelper<offset_surface,3>::Construct )
-,		SchemaEntry("one_direction_repeat_factor",&STEP::ObjectHelper<one_direction_repeat_factor,1>::Construct )
-,		SchemaEntry("open_shell",&STEP::ObjectHelper<open_shell,0>::Construct )
-,		SchemaEntry("ordinal_date",&STEP::ObjectHelper<ordinal_date,1>::Construct )
-,		SchemaEntry("projection_directed_callout",&STEP::ObjectHelper<projection_directed_callout,0>::Construct )
-,		SchemaEntry("ordinate_dimension",&STEP::ObjectHelper<ordinate_dimension,0>::Construct )
-,		SchemaEntry("organization",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("organization_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("organization_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("organizational_address",&STEP::ObjectHelper<organizational_address,2>::Construct )
-,		SchemaEntry("organizational_project",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("organizational_project_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("organizational_project_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("oriented_closed_shell",&STEP::ObjectHelper<oriented_closed_shell,2>::Construct )
-,		SchemaEntry("oriented_edge",&STEP::ObjectHelper<oriented_edge,2>::Construct )
-,		SchemaEntry("oriented_face",&STEP::ObjectHelper<oriented_face,2>::Construct )
-,		SchemaEntry("oriented_open_shell",&STEP::ObjectHelper<oriented_open_shell,2>::Construct )
-,		SchemaEntry("path",&STEP::ObjectHelper<path,1>::Construct )
-,		SchemaEntry("oriented_path",&STEP::ObjectHelper<oriented_path,2>::Construct )
-,		SchemaEntry("oriented_surface",&STEP::ObjectHelper<oriented_surface,1>::Construct )
-,		SchemaEntry("outer_boundary_curve",&STEP::ObjectHelper<outer_boundary_curve,0>::Construct )
-,		SchemaEntry("package_product_concept_feature",&STEP::ObjectHelper<package_product_concept_feature,0>::Construct )
-,		SchemaEntry("parabola",&STEP::ObjectHelper<parabola,1>::Construct )
-,		SchemaEntry("parallel_offset",&STEP::ObjectHelper<parallel_offset,1>::Construct )
-,		SchemaEntry("parallelism_tolerance",&STEP::ObjectHelper<parallelism_tolerance,0>::Construct )
-,		SchemaEntry("parametric_representation_context",&STEP::ObjectHelper<parametric_representation_context,0>::Construct )
-,		SchemaEntry("partial_document_with_structured_text_representation_assignment",&STEP::ObjectHelper<partial_document_with_structured_text_representation_assignment,0>::Construct )
-,		SchemaEntry("pcurve",&STEP::ObjectHelper<pcurve,2>::Construct )
-,		SchemaEntry("percentage_laminate_definition",&STEP::ObjectHelper<percentage_laminate_definition,0>::Construct )
-,		SchemaEntry("zone_structural_makeup",&STEP::ObjectHelper<zone_structural_makeup,0>::Construct )
-,		SchemaEntry("percentage_laminate_table",&STEP::ObjectHelper<percentage_laminate_table,0>::Construct )
-,		SchemaEntry("percentage_ply_definition",&STEP::ObjectHelper<percentage_ply_definition,0>::Construct )
-,		SchemaEntry("perpendicular_to",&STEP::ObjectHelper<perpendicular_to,0>::Construct )
-,		SchemaEntry("perpendicularity_tolerance",&STEP::ObjectHelper<perpendicularity_tolerance,0>::Construct )
-,		SchemaEntry("person",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("person_and_organization",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("person_and_organization_address",&STEP::ObjectHelper<person_and_organization_address,0>::Construct )
-,		SchemaEntry("person_and_organization_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("personal_address",&STEP::ObjectHelper<personal_address,2>::Construct )
-,		SchemaEntry("physical_breakdown_context",&STEP::ObjectHelper<physical_breakdown_context,0>::Construct )
-,		SchemaEntry("physical_element_usage",&STEP::ObjectHelper<physical_element_usage,0>::Construct )
-,		SchemaEntry("presentation_view",&STEP::ObjectHelper<presentation_view,0>::Construct )
-,		SchemaEntry("picture_representation",&STEP::ObjectHelper<picture_representation,0>::Construct )
-,		SchemaEntry("placed_datum_target_feature",&STEP::ObjectHelper<placed_datum_target_feature,0>::Construct )
-,		SchemaEntry("placed_feature",&STEP::ObjectHelper<placed_feature,0>::Construct )
-,		SchemaEntry("planar_extent",&STEP::ObjectHelper<planar_extent,2>::Construct )
-,		SchemaEntry("planar_box",&STEP::ObjectHelper<planar_box,1>::Construct )
-,		SchemaEntry("plane",&STEP::ObjectHelper<plane,0>::Construct )
-,		SchemaEntry("plane_angle_measure_with_unit",&STEP::ObjectHelper<plane_angle_measure_with_unit,0>::Construct )
-,		SchemaEntry("plane_angle_unit",&STEP::ObjectHelper<plane_angle_unit,0>::Construct )
-,		SchemaEntry("plus_minus_tolerance",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ply_laminate_definition",&STEP::ObjectHelper<ply_laminate_definition,0>::Construct )
-,		SchemaEntry("ply_laminate_sequence_definition",&STEP::ObjectHelper<ply_laminate_sequence_definition,0>::Construct )
-,		SchemaEntry("ply_laminate_table",&STEP::ObjectHelper<ply_laminate_table,0>::Construct )
-,		SchemaEntry("point_and_vector",&STEP::ObjectHelper<point_and_vector,0>::Construct )
-,		SchemaEntry("point_on_curve",&STEP::ObjectHelper<point_on_curve,2>::Construct )
-,		SchemaEntry("point_on_surface",&STEP::ObjectHelper<point_on_surface,3>::Construct )
-,		SchemaEntry("point_path",&STEP::ObjectHelper<point_path,0>::Construct )
-,		SchemaEntry("point_replica",&STEP::ObjectHelper<point_replica,2>::Construct )
-,		SchemaEntry("point_style",&STEP::ObjectHelper<point_style,4>::Construct )
-,		SchemaEntry("polar_complex_number_literal",&STEP::ObjectHelper<polar_complex_number_literal,2>::Construct )
-,		SchemaEntry("poly_loop",&STEP::ObjectHelper<poly_loop,1>::Construct )
-,		SchemaEntry("polyline",&STEP::ObjectHelper<polyline,1>::Construct )
-,		SchemaEntry("position_tolerance",&STEP::ObjectHelper<position_tolerance,0>::Construct )
-,		SchemaEntry("positioned_sketch",&STEP::ObjectHelper<positioned_sketch,2>::Construct )
-,		SchemaEntry("power_measure_with_unit",&STEP::ObjectHelper<power_measure_with_unit,0>::Construct )
-,		SchemaEntry("power_unit",&STEP::ObjectHelper<power_unit,0>::Construct )
-,		SchemaEntry("pre_defined_symbol",&STEP::ObjectHelper<pre_defined_symbol,0>::Construct )
-,		SchemaEntry("pre_defined_dimension_symbol",&STEP::ObjectHelper<pre_defined_dimension_symbol,0>::Construct )
-,		SchemaEntry("pre_defined_geometrical_tolerance_symbol",&STEP::ObjectHelper<pre_defined_geometrical_tolerance_symbol,0>::Construct )
-,		SchemaEntry("pre_defined_marker",&STEP::ObjectHelper<pre_defined_marker,0>::Construct )
-,		SchemaEntry("pre_defined_point_marker_symbol",&STEP::ObjectHelper<pre_defined_point_marker_symbol,0>::Construct )
-,		SchemaEntry("pre_defined_surface_condition_symbol",&STEP::ObjectHelper<pre_defined_surface_condition_symbol,0>::Construct )
-,		SchemaEntry("pre_defined_surface_side_style",&STEP::ObjectHelper<pre_defined_surface_side_style,0>::Construct )
-,		SchemaEntry("pre_defined_terminator_symbol",&STEP::ObjectHelper<pre_defined_terminator_symbol,0>::Construct )
-,		SchemaEntry("pre_defined_tile",&STEP::ObjectHelper<pre_defined_tile,0>::Construct )
-,		SchemaEntry("precision_qualifier",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("predefined_picture_representation_item",&STEP::ObjectHelper<predefined_picture_representation_item,0>::Construct )
-,		SchemaEntry("presentation_layer_assignment",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("presentation_size",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("presentation_style_assignment",&STEP::ObjectHelper<presentation_style_assignment,1>::Construct )
-,		SchemaEntry("presentation_style_by_context",&STEP::ObjectHelper<presentation_style_by_context,1>::Construct )
-,		SchemaEntry("presented_item_representation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("pressure_measure_with_unit",&STEP::ObjectHelper<pressure_measure_with_unit,0>::Construct )
-,		SchemaEntry("pressure_unit",&STEP::ObjectHelper<pressure_unit,0>::Construct )
-,		SchemaEntry("procedural_representation",&STEP::ObjectHelper<procedural_representation,0>::Construct )
-,		SchemaEntry("procedural_representation_sequence",&STEP::ObjectHelper<procedural_representation_sequence,3>::Construct )
-,		SchemaEntry("procedural_shape_representation",&STEP::ObjectHelper<procedural_shape_representation,0>::Construct )
-,		SchemaEntry("procedural_shape_representation_sequence",&STEP::ObjectHelper<procedural_shape_representation_sequence,0>::Construct )
-,		SchemaEntry("product",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("product_category",&STEP::ObjectHelper<product_category,2>::Construct )
-,		SchemaEntry("product_class",&STEP::ObjectHelper<product_class,0>::Construct )
-,		SchemaEntry("product_concept",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("product_concept_context",&STEP::ObjectHelper<product_concept_context,1>::Construct )
-,		SchemaEntry("product_concept_feature_association",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("product_concept_feature_category_usage",&STEP::ObjectHelper<product_concept_feature_category_usage,1>::Construct )
-,		SchemaEntry("product_concept_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("product_definition_context_association",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("product_definition_context_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("product_definition_element_relationship",&STEP::ObjectHelper<product_definition_element_relationship,0>::Construct )
-,		SchemaEntry("product_definition_formation",&STEP::ObjectHelper<product_definition_formation,3>::Construct )
-,		SchemaEntry("product_definition_formation_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("product_definition_formation_with_specified_source",&STEP::ObjectHelper<product_definition_formation_with_specified_source,1>::Construct )
-,		SchemaEntry("product_definition_group_assignment",&STEP::ObjectHelper<product_definition_group_assignment,1>::Construct )
-,		SchemaEntry("product_definition_occurrence_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("product_definition_shape",&STEP::ObjectHelper<product_definition_shape,0>::Construct )
-,		SchemaEntry("product_definition_substitute",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("product_definition_with_associated_documents",&STEP::ObjectHelper<product_definition_with_associated_documents,1>::Construct )
-,		SchemaEntry("product_identification",&STEP::ObjectHelper<product_identification,0>::Construct )
-,		SchemaEntry("product_material_composition_relationship",&STEP::ObjectHelper<product_material_composition_relationship,4>::Construct )
-,		SchemaEntry("product_related_product_category",&STEP::ObjectHelper<product_related_product_category,1>::Construct )
-,		SchemaEntry("product_specification",&STEP::ObjectHelper<product_specification,0>::Construct )
-,		SchemaEntry("tolerance_zone_definition",&STEP::ObjectHelper<tolerance_zone_definition,2>::Construct )
-,		SchemaEntry("projected_zone_definition",&STEP::ObjectHelper<projected_zone_definition,2>::Construct )
-,		SchemaEntry("projection_curve",&STEP::ObjectHelper<projection_curve,0>::Construct )
-,		SchemaEntry("promissory_usage_occurrence",&STEP::ObjectHelper<promissory_usage_occurrence,0>::Construct )
-,		SchemaEntry("property_definition_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("qualified_representation_item",&STEP::ObjectHelper<qualified_representation_item,1>::Construct )
-,		SchemaEntry("qualitative_uncertainty",&STEP::ObjectHelper<qualitative_uncertainty,1>::Construct )
-,		SchemaEntry("quantified_assembly_component_usage",&STEP::ObjectHelper<quantified_assembly_component_usage,1>::Construct )
-,		SchemaEntry("quasi_uniform_curve",&STEP::ObjectHelper<quasi_uniform_curve,0>::Construct )
-,		SchemaEntry("quasi_uniform_surface",&STEP::ObjectHelper<quasi_uniform_surface,0>::Construct )
-,		SchemaEntry("radioactivity_measure_with_unit",&STEP::ObjectHelper<radioactivity_measure_with_unit,0>::Construct )
-,		SchemaEntry("radioactivity_unit",&STEP::ObjectHelper<radioactivity_unit,0>::Construct )
-,		SchemaEntry("radius_dimension",&STEP::ObjectHelper<radius_dimension,0>::Construct )
-,		SchemaEntry("range_characteristic",&STEP::ObjectHelper<range_characteristic,0>::Construct )
-,		SchemaEntry("ratio_unit",&STEP::ObjectHelper<ratio_unit,0>::Construct )
-,		SchemaEntry("rational_b_spline_curve",&STEP::ObjectHelper<rational_b_spline_curve,1>::Construct )
-,		SchemaEntry("rational_b_spline_surface",&STEP::ObjectHelper<rational_b_spline_surface,0>::Construct )
-,		SchemaEntry("rational_representation_item",&STEP::ObjectHelper<rational_representation_item,0>::Construct )
-,		SchemaEntry("real_literal",&STEP::ObjectHelper<real_literal,0>::Construct )
-,		SchemaEntry("real_representation_item",&STEP::ObjectHelper<real_representation_item,0>::Construct )
-,		SchemaEntry("rectangular_composite_surface",&STEP::ObjectHelper<rectangular_composite_surface,0>::Construct )
-,		SchemaEntry("rectangular_trimmed_surface",&STEP::ObjectHelper<rectangular_trimmed_surface,7>::Construct )
-,		SchemaEntry("referenced_modified_datum",&STEP::ObjectHelper<referenced_modified_datum,1>::Construct )
-,		SchemaEntry("relative_event_occurrence",&STEP::ObjectHelper<relative_event_occurrence,2>::Construct )
-,		SchemaEntry("rep_item_group",&STEP::ObjectHelper<rep_item_group,0>::Construct )
-,		SchemaEntry("reparametrised_composite_curve_segment",&STEP::ObjectHelper<reparametrised_composite_curve_segment,1>::Construct )
-,		SchemaEntry("representation_relationship_with_transformation",&STEP::ObjectHelper<representation_relationship_with_transformation,1>::Construct )
-,		SchemaEntry("requirement_assigned_object",&STEP::ObjectHelper<requirement_assigned_object,1>::Construct )
-,		SchemaEntry("requirement_assignment",&STEP::ObjectHelper<requirement_assignment,0>::Construct )
-,		SchemaEntry("requirement_source",&STEP::ObjectHelper<requirement_source,0>::Construct )
-,		SchemaEntry("requirement_view_definition_relationship",&STEP::ObjectHelper<requirement_view_definition_relationship,0>::Construct )
-,		SchemaEntry("resistance_measure_with_unit",&STEP::ObjectHelper<resistance_measure_with_unit,0>::Construct )
-,		SchemaEntry("resistance_unit",&STEP::ObjectHelper<resistance_unit,0>::Construct )
-,		SchemaEntry("revolved_area_solid",&STEP::ObjectHelper<revolved_area_solid,2>::Construct )
-,		SchemaEntry("revolved_face_solid",&STEP::ObjectHelper<revolved_face_solid,2>::Construct )
-,		SchemaEntry("revolved_face_solid_with_trim_conditions",&STEP::ObjectHelper<revolved_face_solid_with_trim_conditions,2>::Construct )
-,		SchemaEntry("right_angular_wedge",&STEP::ObjectHelper<right_angular_wedge,5>::Construct )
-,		SchemaEntry("right_circular_cone",&STEP::ObjectHelper<right_circular_cone,4>::Construct )
-,		SchemaEntry("right_circular_cylinder",&STEP::ObjectHelper<right_circular_cylinder,3>::Construct )
-,		SchemaEntry("right_to_usage_association",&STEP::ObjectHelper<right_to_usage_association,0>::Construct )
-,		SchemaEntry("role_association",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("roundness_tolerance",&STEP::ObjectHelper<roundness_tolerance,0>::Construct )
-,		SchemaEntry("row_representation_item",&STEP::ObjectHelper<row_representation_item,0>::Construct )
-,		SchemaEntry("row_value",&STEP::ObjectHelper<row_value,0>::Construct )
-,		SchemaEntry("row_variable",&STEP::ObjectHelper<row_variable,0>::Construct )
-,		SchemaEntry("rule_action",&STEP::ObjectHelper<rule_action,0>::Construct )
-,		SchemaEntry("rule_condition",&STEP::ObjectHelper<rule_condition,0>::Construct )
-,		SchemaEntry("rule_set",&STEP::ObjectHelper<rule_set,0>::Construct )
-,		SchemaEntry("rule_set_group",&STEP::ObjectHelper<rule_set_group,0>::Construct )
-,		SchemaEntry("rule_superseded_assignment",&STEP::ObjectHelper<rule_superseded_assignment,1>::Construct )
-,		SchemaEntry("rule_supersedence",&STEP::ObjectHelper<rule_supersedence,0>::Construct )
-,		SchemaEntry("surface_curve_swept_area_solid",&STEP::ObjectHelper<surface_curve_swept_area_solid,4>::Construct )
-,		SchemaEntry("ruled_surface_swept_area_solid",&STEP::ObjectHelper<ruled_surface_swept_area_solid,0>::Construct )
-,		SchemaEntry("runout_zone_definition",&STEP::ObjectHelper<runout_zone_definition,1>::Construct )
-,		SchemaEntry("runout_zone_orientation",&STEP::ObjectHelper<runout_zone_orientation,1>::Construct )
-,		SchemaEntry("runout_zone_orientation_reference_direction",&STEP::ObjectHelper<runout_zone_orientation_reference_direction,1>::Construct )
-,		SchemaEntry("satisfied_requirement",&STEP::ObjectHelper<satisfied_requirement,1>::Construct )
-,		SchemaEntry("satisfies_requirement",&STEP::ObjectHelper<satisfies_requirement,0>::Construct )
-,		SchemaEntry("satisfying_item",&STEP::ObjectHelper<satisfying_item,1>::Construct )
-,		SchemaEntry("scalar_variable",&STEP::ObjectHelper<scalar_variable,0>::Construct )
-,		SchemaEntry("scattering_parameter",&STEP::ObjectHelper<scattering_parameter,0>::Construct )
-,		SchemaEntry("sculptured_solid",&STEP::ObjectHelper<sculptured_solid,2>::Construct )
-,		SchemaEntry("seam_curve",&STEP::ObjectHelper<seam_curve,0>::Construct )
-,		SchemaEntry("security_classification",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("security_classification_level",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("serial_numbered_effectivity",&STEP::ObjectHelper<serial_numbered_effectivity,2>::Construct )
-,		SchemaEntry("shape_aspect_associativity",&STEP::ObjectHelper<shape_aspect_associativity,0>::Construct )
-,		SchemaEntry("shape_aspect_deriving_relationship",&STEP::ObjectHelper<shape_aspect_deriving_relationship,0>::Construct )
-,		SchemaEntry("shape_definition_representation",&STEP::ObjectHelper<shape_definition_representation,0>::Construct )
-,		SchemaEntry("shape_dimension_representation",&STEP::ObjectHelper<shape_dimension_representation,0>::Construct )
-,		SchemaEntry("shape_feature_definition",&STEP::ObjectHelper<shape_feature_definition,0>::Construct )
-,		SchemaEntry("shape_representation_with_parameters",&STEP::ObjectHelper<shape_representation_with_parameters,0>::Construct )
-,		SchemaEntry("shell_based_surface_model",&STEP::ObjectHelper<shell_based_surface_model,1>::Construct )
-,		SchemaEntry("shell_based_wireframe_model",&STEP::ObjectHelper<shell_based_wireframe_model,1>::Construct )
-,		SchemaEntry("shell_based_wireframe_shape_representation",&STEP::ObjectHelper<shell_based_wireframe_shape_representation,0>::Construct )
-,		SchemaEntry("si_absorbed_dose_unit",&STEP::ObjectHelper<si_absorbed_dose_unit,0>::Construct )
-,		SchemaEntry("si_capacitance_unit",&STEP::ObjectHelper<si_capacitance_unit,0>::Construct )
-,		SchemaEntry("si_conductance_unit",&STEP::ObjectHelper<si_conductance_unit,0>::Construct )
-,		SchemaEntry("si_dose_equivalent_unit",&STEP::ObjectHelper<si_dose_equivalent_unit,0>::Construct )
-,		SchemaEntry("si_electric_charge_unit",&STEP::ObjectHelper<si_electric_charge_unit,0>::Construct )
-,		SchemaEntry("si_electric_potential_unit",&STEP::ObjectHelper<si_electric_potential_unit,0>::Construct )
-,		SchemaEntry("si_energy_unit",&STEP::ObjectHelper<si_energy_unit,0>::Construct )
-,		SchemaEntry("si_force_unit",&STEP::ObjectHelper<si_force_unit,0>::Construct )
-,		SchemaEntry("si_frequency_unit",&STEP::ObjectHelper<si_frequency_unit,0>::Construct )
-,		SchemaEntry("si_illuminance_unit",&STEP::ObjectHelper<si_illuminance_unit,0>::Construct )
-,		SchemaEntry("si_inductance_unit",&STEP::ObjectHelper<si_inductance_unit,0>::Construct )
-,		SchemaEntry("si_magnetic_flux_density_unit",&STEP::ObjectHelper<si_magnetic_flux_density_unit,0>::Construct )
-,		SchemaEntry("si_magnetic_flux_unit",&STEP::ObjectHelper<si_magnetic_flux_unit,0>::Construct )
-,		SchemaEntry("si_power_unit",&STEP::ObjectHelper<si_power_unit,0>::Construct )
-,		SchemaEntry("si_pressure_unit",&STEP::ObjectHelper<si_pressure_unit,0>::Construct )
-,		SchemaEntry("si_radioactivity_unit",&STEP::ObjectHelper<si_radioactivity_unit,0>::Construct )
-,		SchemaEntry("si_resistance_unit",&STEP::ObjectHelper<si_resistance_unit,0>::Construct )
-,		SchemaEntry("si_unit",&STEP::ObjectHelper<si_unit,2>::Construct )
-,		SchemaEntry("simple_boolean_expression",&STEP::ObjectHelper<simple_boolean_expression,0>::Construct )
-,		SchemaEntry("simple_numeric_expression",&STEP::ObjectHelper<simple_numeric_expression,0>::Construct )
-,		SchemaEntry("slash_expression",&STEP::ObjectHelper<slash_expression,0>::Construct )
-,		SchemaEntry("smeared_material_definition",&STEP::ObjectHelper<smeared_material_definition,0>::Construct )
-,		SchemaEntry("solid_angle_measure_with_unit",&STEP::ObjectHelper<solid_angle_measure_with_unit,0>::Construct )
-,		SchemaEntry("solid_angle_unit",&STEP::ObjectHelper<solid_angle_unit,0>::Construct )
-,		SchemaEntry("solid_curve_font",&STEP::ObjectHelper<solid_curve_font,0>::Construct )
-,		SchemaEntry("solid_replica",&STEP::ObjectHelper<solid_replica,2>::Construct )
-,		SchemaEntry("solid_with_chamfered_edges",&STEP::ObjectHelper<solid_with_chamfered_edges,0>::Construct )
-,		SchemaEntry("solid_with_angle_based_chamfer",&STEP::ObjectHelper<solid_with_angle_based_chamfer,3>::Construct )
-,		SchemaEntry("solid_with_shape_element_pattern",&STEP::ObjectHelper<solid_with_shape_element_pattern,1>::Construct )
-,		SchemaEntry("solid_with_circular_pattern",&STEP::ObjectHelper<solid_with_circular_pattern,4>::Construct )
-,		SchemaEntry("solid_with_depression",&STEP::ObjectHelper<solid_with_depression,1>::Construct )
-,		SchemaEntry("solid_with_pocket",&STEP::ObjectHelper<solid_with_pocket,2>::Construct )
-,		SchemaEntry("solid_with_circular_pocket",&STEP::ObjectHelper<solid_with_circular_pocket,1>::Construct )
-,		SchemaEntry("solid_with_protrusion",&STEP::ObjectHelper<solid_with_protrusion,2>::Construct )
-,		SchemaEntry("solid_with_circular_protrusion",&STEP::ObjectHelper<solid_with_circular_protrusion,1>::Construct )
-,		SchemaEntry("solid_with_hole",&STEP::ObjectHelper<solid_with_hole,0>::Construct )
-,		SchemaEntry("solid_with_stepped_round_hole",&STEP::ObjectHelper<solid_with_stepped_round_hole,1>::Construct )
-,		SchemaEntry("solid_with_conical_bottom_round_hole",&STEP::ObjectHelper<solid_with_conical_bottom_round_hole,2>::Construct )
-,		SchemaEntry("solid_with_constant_radius_edge_blend",&STEP::ObjectHelper<solid_with_constant_radius_edge_blend,1>::Construct )
-,		SchemaEntry("solid_with_slot",&STEP::ObjectHelper<solid_with_slot,2>::Construct )
-,		SchemaEntry("solid_with_curved_slot",&STEP::ObjectHelper<solid_with_curved_slot,1>::Construct )
-,		SchemaEntry("solid_with_double_offset_chamfer",&STEP::ObjectHelper<solid_with_double_offset_chamfer,2>::Construct )
-,		SchemaEntry("solid_with_flat_bottom_round_hole",&STEP::ObjectHelper<solid_with_flat_bottom_round_hole,1>::Construct )
-,		SchemaEntry("solid_with_general_pocket",&STEP::ObjectHelper<solid_with_general_pocket,2>::Construct )
-,		SchemaEntry("solid_with_general_protrusion",&STEP::ObjectHelper<solid_with_general_protrusion,2>::Construct )
-,		SchemaEntry("solid_with_groove",&STEP::ObjectHelper<solid_with_groove,5>::Construct )
-,		SchemaEntry("solid_with_incomplete_circular_pattern",&STEP::ObjectHelper<solid_with_incomplete_circular_pattern,1>::Construct )
-,		SchemaEntry("solid_with_rectangular_pattern",&STEP::ObjectHelper<solid_with_rectangular_pattern,4>::Construct )
-,		SchemaEntry("solid_with_incomplete_rectangular_pattern",&STEP::ObjectHelper<solid_with_incomplete_rectangular_pattern,0>::Construct )
-,		SchemaEntry("solid_with_rectangular_pocket",&STEP::ObjectHelper<solid_with_rectangular_pocket,3>::Construct )
-,		SchemaEntry("solid_with_rectangular_protrusion",&STEP::ObjectHelper<solid_with_rectangular_protrusion,3>::Construct )
-,		SchemaEntry("solid_with_single_offset_chamfer",&STEP::ObjectHelper<solid_with_single_offset_chamfer,1>::Construct )
-,		SchemaEntry("solid_with_spherical_bottom_round_hole",&STEP::ObjectHelper<solid_with_spherical_bottom_round_hole,1>::Construct )
-,		SchemaEntry("solid_with_stepped_round_hole_and_conical_transitions",&STEP::ObjectHelper<solid_with_stepped_round_hole_and_conical_transitions,1>::Construct )
-,		SchemaEntry("solid_with_straight_slot",&STEP::ObjectHelper<solid_with_straight_slot,1>::Construct )
-,		SchemaEntry("solid_with_tee_section_slot",&STEP::ObjectHelper<solid_with_tee_section_slot,2>::Construct )
-,		SchemaEntry("solid_with_through_depression",&STEP::ObjectHelper<solid_with_through_depression,1>::Construct )
-,		SchemaEntry("solid_with_trapezoidal_section_slot",&STEP::ObjectHelper<solid_with_trapezoidal_section_slot,2>::Construct )
-,		SchemaEntry("solid_with_variable_radius_edge_blend",&STEP::ObjectHelper<solid_with_variable_radius_edge_blend,3>::Construct )
-,		SchemaEntry("source_for_requirement",&STEP::ObjectHelper<source_for_requirement,1>::Construct )
-,		SchemaEntry("sourced_requirement",&STEP::ObjectHelper<sourced_requirement,1>::Construct )
-,		SchemaEntry("specification_definition",&STEP::ObjectHelper<specification_definition,0>::Construct )
-,		SchemaEntry("specified_higher_usage_occurrence",&STEP::ObjectHelper<specified_higher_usage_occurrence,2>::Construct )
-,		SchemaEntry("sphere",&STEP::ObjectHelper<sphere,2>::Construct )
-,		SchemaEntry("spherical_surface",&STEP::ObjectHelper<spherical_surface,1>::Construct )
-,		SchemaEntry("start_request",&STEP::ObjectHelper<start_request,1>::Construct )
-,		SchemaEntry("start_work",&STEP::ObjectHelper<start_work,1>::Construct )
-,		SchemaEntry("straightness_tolerance",&STEP::ObjectHelper<straightness_tolerance,0>::Construct )
-,		SchemaEntry("structured_dimension_callout",&STEP::ObjectHelper<structured_dimension_callout,0>::Construct )
-,		SchemaEntry("structured_text_composition",&STEP::ObjectHelper<structured_text_composition,0>::Construct )
-,		SchemaEntry("structured_text_representation",&STEP::ObjectHelper<structured_text_representation,0>::Construct )
-,		SchemaEntry("subedge",&STEP::ObjectHelper<subedge,1>::Construct )
-,		SchemaEntry("subface",&STEP::ObjectHelper<subface,1>::Construct )
-,		SchemaEntry("supplied_part_relationship",&STEP::ObjectHelper<supplied_part_relationship,0>::Construct )
-,		SchemaEntry("surface_condition_callout",&STEP::ObjectHelper<surface_condition_callout,0>::Construct )
-,		SchemaEntry("swept_surface",&STEP::ObjectHelper<swept_surface,1>::Construct )
-,		SchemaEntry("surface_of_linear_extrusion",&STEP::ObjectHelper<surface_of_linear_extrusion,1>::Construct )
-,		SchemaEntry("surface_of_revolution",&STEP::ObjectHelper<surface_of_revolution,1>::Construct )
-,		SchemaEntry("surface_patch",&STEP::ObjectHelper<surface_patch,5>::Construct )
-,		SchemaEntry("surface_profile_tolerance",&STEP::ObjectHelper<surface_profile_tolerance,0>::Construct )
-,		SchemaEntry("surface_rendering_properties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("surface_replica",&STEP::ObjectHelper<surface_replica,2>::Construct )
-,		SchemaEntry("surface_side_style",&STEP::ObjectHelper<surface_side_style,2>::Construct )
-,		SchemaEntry("surface_style_boundary",&STEP::ObjectHelper<surface_style_boundary,1>::Construct )
-,		SchemaEntry("surface_style_control_grid",&STEP::ObjectHelper<surface_style_control_grid,1>::Construct )
-,		SchemaEntry("surface_style_fill_area",&STEP::ObjectHelper<surface_style_fill_area,1>::Construct )
-,		SchemaEntry("surface_style_parameter_line",&STEP::ObjectHelper<surface_style_parameter_line,2>::Construct )
-,		SchemaEntry("surface_style_reflectance_ambient",&STEP::ObjectHelper<surface_style_reflectance_ambient,1>::Construct )
-,		SchemaEntry("surface_style_reflectance_ambient_diffuse",&STEP::ObjectHelper<surface_style_reflectance_ambient_diffuse,1>::Construct )
-,		SchemaEntry("surface_style_reflectance_ambient_diffuse_specular",&STEP::ObjectHelper<surface_style_reflectance_ambient_diffuse_specular,3>::Construct )
-,		SchemaEntry("surface_style_rendering",&STEP::ObjectHelper<surface_style_rendering,2>::Construct )
-,		SchemaEntry("surface_style_rendering_with_properties",&STEP::ObjectHelper<surface_style_rendering_with_properties,1>::Construct )
-,		SchemaEntry("surface_style_segmentation_curve",&STEP::ObjectHelper<surface_style_segmentation_curve,1>::Construct )
-,		SchemaEntry("surface_style_silhouette",&STEP::ObjectHelper<surface_style_silhouette,1>::Construct )
-,		SchemaEntry("surface_style_transparent",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("surface_style_usage",&STEP::ObjectHelper<surface_style_usage,2>::Construct )
-,		SchemaEntry("surface_texture_representation",&STEP::ObjectHelper<surface_texture_representation,0>::Construct )
-,		SchemaEntry("surfaced_open_shell",&STEP::ObjectHelper<surfaced_open_shell,0>::Construct )
-,		SchemaEntry("swept_disk_solid",&STEP::ObjectHelper<swept_disk_solid,5>::Construct )
-,		SchemaEntry("symbol",&STEP::ObjectHelper<symbol,0>::Construct )
-,		SchemaEntry("symbol_colour",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("symbol_representation_map",&STEP::ObjectHelper<symbol_representation_map,0>::Construct )
-,		SchemaEntry("symbol_style",&STEP::ObjectHelper<symbol_style,2>::Construct )
-,		SchemaEntry("symbol_target",&STEP::ObjectHelper<symbol_target,3>::Construct )
-,		SchemaEntry("symmetric_shape_aspect",&STEP::ObjectHelper<symmetric_shape_aspect,0>::Construct )
-,		SchemaEntry("symmetry_tolerance",&STEP::ObjectHelper<symmetry_tolerance,0>::Construct )
-,		SchemaEntry("table_representation_item",&STEP::ObjectHelper<table_representation_item,0>::Construct )
-,		SchemaEntry("tactile_appearance_representation",&STEP::ObjectHelper<tactile_appearance_representation,0>::Construct )
-,		SchemaEntry("tagged_text_format",&STEP::ObjectHelper<tagged_text_format,0>::Construct )
-,		SchemaEntry("tagged_text_item",&STEP::ObjectHelper<tagged_text_item,0>::Construct )
-,		SchemaEntry("tangent",&STEP::ObjectHelper<tangent,0>::Construct )
-,		SchemaEntry("text_font",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("text_font_family",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("text_font_in_family",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("text_literal_with_associated_curves",&STEP::ObjectHelper<text_literal_with_associated_curves,1>::Construct )
-,		SchemaEntry("text_literal_with_blanking_box",&STEP::ObjectHelper<text_literal_with_blanking_box,1>::Construct )
-,		SchemaEntry("text_literal_with_extent",&STEP::ObjectHelper<text_literal_with_extent,1>::Construct )
-,		SchemaEntry("text_string_representation",&STEP::ObjectHelper<text_string_representation,0>::Construct )
-,		SchemaEntry("text_style",&STEP::ObjectHelper<text_style,2>::Construct )
-,		SchemaEntry("text_style_for_defined_font",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("text_style_with_box_characteristics",&STEP::ObjectHelper<text_style_with_box_characteristics,1>::Construct )
-,		SchemaEntry("text_style_with_mirror",&STEP::ObjectHelper<text_style_with_mirror,1>::Construct )
-,		SchemaEntry("text_style_with_spacing",&STEP::ObjectHelper<text_style_with_spacing,1>::Construct )
-,		SchemaEntry("thermal_resistance_measure_with_unit",&STEP::ObjectHelper<thermal_resistance_measure_with_unit,0>::Construct )
-,		SchemaEntry("thermal_resistance_unit",&STEP::ObjectHelper<thermal_resistance_unit,0>::Construct )
-,		SchemaEntry("thermodynamic_temperature_measure_with_unit",&STEP::ObjectHelper<thermodynamic_temperature_measure_with_unit,0>::Construct )
-,		SchemaEntry("thermodynamic_temperature_unit",&STEP::ObjectHelper<thermodynamic_temperature_unit,0>::Construct )
-,		SchemaEntry("thickened_face_solid",&STEP::ObjectHelper<thickened_face_solid,3>::Construct )
-,		SchemaEntry("thickness_laminate_definition",&STEP::ObjectHelper<thickness_laminate_definition,0>::Construct )
-,		SchemaEntry("thickness_laminate_table",&STEP::ObjectHelper<thickness_laminate_table,0>::Construct )
-,		SchemaEntry("time_interval",&STEP::ObjectHelper<time_interval,3>::Construct )
-,		SchemaEntry("time_interval_based_effectivity",&STEP::ObjectHelper<time_interval_based_effectivity,1>::Construct )
-,		SchemaEntry("time_interval_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("time_interval_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("time_interval_with_bounds",&STEP::ObjectHelper<time_interval_with_bounds,3>::Construct )
-,		SchemaEntry("time_measure_with_unit",&STEP::ObjectHelper<time_measure_with_unit,0>::Construct )
-,		SchemaEntry("time_unit",&STEP::ObjectHelper<time_unit,0>::Construct )
-,		SchemaEntry("tolerance_value",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("tolerance_zone",&STEP::ObjectHelper<tolerance_zone,2>::Construct )
-,		SchemaEntry("tolerance_zone_form",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("torus",&STEP::ObjectHelper<torus,3>::Construct )
-,		SchemaEntry("total_runout_tolerance",&STEP::ObjectHelper<total_runout_tolerance,0>::Construct )
-,		SchemaEntry("track_blended_solid",&STEP::ObjectHelper<track_blended_solid,0>::Construct )
-,		SchemaEntry("track_blended_solid_with_end_conditions",&STEP::ObjectHelper<track_blended_solid_with_end_conditions,1>::Construct )
-,		SchemaEntry("trimmed_curve",&STEP::ObjectHelper<trimmed_curve,5>::Construct )
-,		SchemaEntry("two_direction_repeat_factor",&STEP::ObjectHelper<two_direction_repeat_factor,1>::Construct )
-,		SchemaEntry("type_qualifier",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("unary_generic_expression",&STEP::ObjectHelper<unary_generic_expression,1>::Construct )
-,		SchemaEntry("unary_numeric_expression",&STEP::ObjectHelper<unary_numeric_expression,0>::Construct )
-,		SchemaEntry("uncertainty_assigned_representation",&STEP::ObjectHelper<uncertainty_assigned_representation,1>::Construct )
-,		SchemaEntry("uncertainty_measure_with_unit",&STEP::ObjectHelper<uncertainty_measure_with_unit,2>::Construct )
-,		SchemaEntry("uniform_curve",&STEP::ObjectHelper<uniform_curve,0>::Construct )
-,		SchemaEntry("uniform_resource_identifier",&STEP::ObjectHelper<uniform_resource_identifier,0>::Construct )
-,		SchemaEntry("uniform_surface",&STEP::ObjectHelper<uniform_surface,0>::Construct )
-,		SchemaEntry("usage_association",&STEP::ObjectHelper<usage_association,0>::Construct )
-,		SchemaEntry("user_defined_curve_font",&STEP::ObjectHelper<user_defined_curve_font,0>::Construct )
-,		SchemaEntry("user_defined_marker",&STEP::ObjectHelper<user_defined_marker,0>::Construct )
-,		SchemaEntry("user_defined_terminator_symbol",&STEP::ObjectHelper<user_defined_terminator_symbol,0>::Construct )
-,		SchemaEntry("user_selected_shape_elements",&STEP::ObjectHelper<user_selected_shape_elements,0>::Construct )
-,		SchemaEntry("value_range",&STEP::ObjectHelper<value_range,0>::Construct )
-,		SchemaEntry("value_representation_item",&STEP::ObjectHelper<value_representation_item,1>::Construct )
-,		SchemaEntry("variable_semantics",&STEP::ObjectHelper<variable_semantics,0>::Construct )
-,		SchemaEntry("variational_representation_item",&STEP::ObjectHelper<variational_representation_item,0>::Construct )
-,		SchemaEntry("vector",&STEP::ObjectHelper<vector,2>::Construct )
-,		SchemaEntry("vector_style",&STEP::ObjectHelper<vector_style,0>::Construct )
-,		SchemaEntry("velocity_measure_with_unit",&STEP::ObjectHelper<velocity_measure_with_unit,0>::Construct )
-,		SchemaEntry("velocity_unit",&STEP::ObjectHelper<velocity_unit,0>::Construct )
-,		SchemaEntry("versioned_action_request",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("vertex",&STEP::ObjectHelper<vertex,0>::Construct )
-,		SchemaEntry("vertex_loop",&STEP::ObjectHelper<vertex_loop,1>::Construct )
-,		SchemaEntry("vertex_point",&STEP::ObjectHelper<vertex_point,1>::Construct )
-,		SchemaEntry("vertex_shell",&STEP::ObjectHelper<vertex_shell,1>::Construct )
-,		SchemaEntry("view_volume",&STEP::ObjectHelper<view_volume,9>::Construct )
-,		SchemaEntry("visual_appearance_representation",&STEP::ObjectHelper<visual_appearance_representation,0>::Construct )
-,		SchemaEntry("volume_measure_with_unit",&STEP::ObjectHelper<volume_measure_with_unit,0>::Construct )
-,		SchemaEntry("volume_unit",&STEP::ObjectHelper<volume_unit,0>::Construct )
-,		SchemaEntry("week_of_year_and_day_date",&STEP::ObjectHelper<week_of_year_and_day_date,2>::Construct )
-,		SchemaEntry("wire_shell",&STEP::ObjectHelper<wire_shell,1>::Construct )
-,		SchemaEntry("year_month",&STEP::ObjectHelper<year_month,1>::Construct )
-
-	};
-}
-
-// -----------------------------------------------------------------------------------------------------------
-void StepFile::GetSchema(EXPRESS::ConversionSchema& out)
-{
-	out = EXPRESS::ConversionSchema(schema_raw);
-}
-
-namespace STEP {
-
-    // -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<NotImplemented>(const STEP::DB& db, const LIST& params, NotImplemented* in)
-{
-	return 0;
-}
-
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<measure_with_unit>(const DB& db, const LIST& params, measure_with_unit* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to measure_with_unit"); }    do { // convert the 'value_component' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::measure_with_unit,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->value_component, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to measure_with_unit to be a `measure_value`")); }
-    } while(0);
-    do { // convert the 'unit_component' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::measure_with_unit,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->unit_component, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to measure_with_unit to be a `unit`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<absorbed_dose_measure_with_unit>(const DB& db, const LIST& params, absorbed_dose_measure_with_unit* in)
-{
-	size_t base = GenericFill(db,params,static_cast<measure_with_unit*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to absorbed_dose_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<derived_unit>(const DB& db, const LIST& params, derived_unit* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to derived_unit"); }    do { // convert the 'elements' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::derived_unit,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->elements, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to derived_unit to be a `SET [1:?] OF derived_unit_element`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<absorbed_dose_unit>(const DB& db, const LIST& params, absorbed_dose_unit* in)
-{
-	size_t base = GenericFill(db,params,static_cast<derived_unit*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to absorbed_dose_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<abstract_variable>(const DB& db, const LIST& params, abstract_variable* in)
-{
-	size_t base = 0;
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<acceleration_measure_with_unit>(const DB& db, const LIST& params, acceleration_measure_with_unit* in)
-{
-	size_t base = GenericFill(db,params,static_cast<measure_with_unit*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to acceleration_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<acceleration_unit>(const DB& db, const LIST& params, acceleration_unit* in)
-{
-	size_t base = GenericFill(db,params,static_cast<derived_unit*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to acceleration_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<action>(const DB& db, const LIST& params, action* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to action"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action,3>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->name, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to action to be a `label`")); }
-    } while(0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action,3>::aux_is_derived[1]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->description, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to action to be a `text`")); }
-    } while(0);
-    do { // convert the 'chosen_method' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action,3>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->chosen_method, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to action to be a `action_method`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<action_assignment>(const DB& db, const LIST& params, action_assignment* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to action_assignment"); }    do { // convert the 'assigned_action' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_assignment,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->assigned_action, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to action_assignment to be a `action`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<action_method>(const DB& db, const LIST& params, action_method* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to action_method"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method,4>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->name, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to action_method to be a `label`")); }
-    } while(0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method,4>::aux_is_derived[1]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->description, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to action_method to be a `text`")); }
-    } while(0);
-    do { // convert the 'consequence' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method,4>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->consequence, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to action_method to be a `text`")); }
-    } while(0);
-    do { // convert the 'purpose' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method,4>::aux_is_derived[3]=true; break; }
-        try { GenericConvert( in->purpose, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to action_method to be a `text`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<action_method_assignment>(const DB& db, const LIST& params, action_method_assignment* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to action_method_assignment"); }    do { // convert the 'assigned_action_method' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method_assignment,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->assigned_action_method, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to action_method_assignment to be a `action_method`")); }
-    } while(0);
-    do { // convert the 'role' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method_assignment,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->role, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to action_method_assignment to be a `action_method_role`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<action_method_relationship>(const DB& db, const LIST& params, action_method_relationship* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to action_method_relationship"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method_relationship,4>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->name, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to action_method_relationship to be a `label`")); }
-    } while(0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method_relationship,4>::aux_is_derived[1]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->description, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to action_method_relationship to be a `text`")); }
-    } while(0);
-    do { // convert the 'relating_method' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method_relationship,4>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->relating_method, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to action_method_relationship to be a `action_method`")); }
-    } while(0);
-    do { // convert the 'related_method' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method_relationship,4>::aux_is_derived[3]=true; break; }
-        try { GenericConvert( in->related_method, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to action_method_relationship to be a `action_method`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<action_request_assignment>(const DB& db, const LIST& params, action_request_assignment* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to action_request_assignment"); }    do { // convert the 'assigned_action_request' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_request_assignment,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->assigned_action_request, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to action_request_assignment to be a `versioned_action_request`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<address>(const DB& db, const LIST& params, address* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 12) { throw STEP::TypeError("expected 12 arguments to address"); }    do { // convert the 'internal_location' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[0]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->internal_location, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to address to be a `label`")); }
-    } while(0);
-    do { // convert the 'street_number' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[1]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->street_number, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to address to be a `label`")); }
-    } while(0);
-    do { // convert the 'street' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[2]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->street, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to address to be a `label`")); }
-    } while(0);
-    do { // convert the 'postal_box' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[3]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->postal_box, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to address to be a `label`")); }
-    } while(0);
-    do { // convert the 'town' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[4]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->town, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to address to be a `label`")); }
-    } while(0);
-    do { // convert the 'region' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[5]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->region, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to address to be a `label`")); }
-    } while(0);
-    do { // convert the 'postal_code' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[6]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->postal_code, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to address to be a `label`")); }
-    } while(0);
-    do { // convert the 'country' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[7]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->country, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to address to be a `label`")); }
-    } while(0);
-    do { // convert the 'facsimile_number' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[8]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->facsimile_number, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to address to be a `label`")); }
-    } while(0);
-    do { // convert the 'telephone_number' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[9]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->telephone_number, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to address to be a `label`")); }
-    } while(0);
-    do { // convert the 'electronic_mail_address' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[10]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->electronic_mail_address, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to address to be a `label`")); }
-    } while(0);
-    do { // convert the 'telex_number' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[11]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->telex_number, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 11 to address to be a `label`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<representation>(const DB& db, const LIST& params, representation* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to representation"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation,3>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->name, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to representation to be a `label`")); }
-    } while(0);
-    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation,3>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->items, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to representation to be a `SET [1:?] OF representation_item`")); }
-    } while(0);
-    do { // convert the 'context_of_items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation,3>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->context_of_items, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to representation to be a `representation_context`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<shape_representation>(const DB& db, const LIST& params, shape_representation* in)
-{
-	size_t base = GenericFill(db,params,static_cast<representation*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to shape_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<advanced_brep_shape_representation>(const DB& db, const LIST& params, advanced_brep_shape_representation* in)
-{
-	size_t base = GenericFill(db,params,static_cast<shape_representation*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to advanced_brep_shape_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<face_surface>(const DB& db, const LIST& params, face_surface* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to face_surface"); }    do { // convert the 'face_geometry' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::face_surface,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->face_geometry, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to face_surface to be a `surface`")); }
-    } while(0);
-    do { // convert the 'same_sense' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::face_surface,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->same_sense, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to face_surface to be a `BOOLEAN`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<advanced_face>(const DB& db, const LIST& params, advanced_face* in)
-{
-	size_t base = GenericFill(db,params,static_cast<face_surface*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to advanced_face"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<amount_of_substance_measure_with_unit>(const DB& db, const LIST& params, amount_of_substance_measure_with_unit* in)
-{
-	size_t base = GenericFill(db,params,static_cast<measure_with_unit*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to amount_of_substance_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<named_unit>(const DB& db, const LIST& params, named_unit* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to named_unit"); }    do { // convert the 'dimensions' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::named_unit,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->dimensions, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to named_unit to be a `dimensional_exponents`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<amount_of_substance_unit>(const DB& db, const LIST& params, amount_of_substance_unit* in)
-{
-	size_t base = GenericFill(db,params,static_cast<named_unit*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to amount_of_substance_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<angle_direction_reference>(const DB& db, const LIST& params, angle_direction_reference* in)
-{
-	size_t base = 0;
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<representation_item>(const DB& db, const LIST& params, representation_item* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to representation_item"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_item,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->name, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to representation_item to be a `label`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<geometric_representation_item>(const DB& db, const LIST& params, geometric_representation_item* in)
-{
-	size_t base = GenericFill(db,params,static_cast<representation_item*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to geometric_representation_item"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<draughting_callout>(const DB& db, const LIST& params, draughting_callout* in)
-{
-	size_t base = GenericFill(db,params,static_cast<geometric_representation_item*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to draughting_callout"); }    do { // convert the 'contents' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::draughting_callout,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->contents, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to draughting_callout to be a `SET [1:?] OF draughting_callout_element`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dimension_curve_directed_callout>(const DB& db, const LIST& params, dimension_curve_directed_callout* in)
-{
-	size_t base = GenericFill(db,params,static_cast<draughting_callout*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to dimension_curve_directed_callout"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<angular_dimension>(const DB& db, const LIST& params, angular_dimension* in)
-{
-	size_t base = GenericFill(db,params,static_cast<dimension_curve_directed_callout*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to angular_dimension"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<shape_aspect_relationship>(const DB& db, const LIST& params, shape_aspect_relationship* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to shape_aspect_relationship"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shape_aspect_relationship,4>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->name, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to shape_aspect_relationship to be a `label`")); }
-    } while(0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shape_aspect_relationship,4>::aux_is_derived[1]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->description, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to shape_aspect_relationship to be a `text`")); }
-    } while(0);
-    do { // convert the 'relating_shape_aspect' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shape_aspect_relationship,4>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->relating_shape_aspect, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to shape_aspect_relationship to be a `shape_aspect`")); }
-    } while(0);
-    do { // convert the 'related_shape_aspect' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shape_aspect_relationship,4>::aux_is_derived[3]=true; break; }
-        try { GenericConvert( in->related_shape_aspect, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to shape_aspect_relationship to be a `shape_aspect`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dimensional_location>(const DB& db, const LIST& params, dimensional_location* in)
-{
-	size_t base = GenericFill(db,params,static_cast<shape_aspect_relationship*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to dimensional_location"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<angular_location>(const DB& db, const LIST& params, angular_location* in)
-{
-	size_t base = GenericFill(db,params,static_cast<dimensional_location*>(in));
-	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to angular_location"); }    do { // convert the 'angle_selection' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->angle_selection, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to angular_location to be a `angle_relator`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dimensional_size>(const DB& db, const LIST& params, dimensional_size* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to dimensional_size"); }    do { // convert the 'applies_to' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::dimensional_size,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->applies_to, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to dimensional_size to be a `shape_aspect`")); }
-    } while(0);
-    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::dimensional_size,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->name, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to dimensional_size to be a `label`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<angular_size>(const DB& db, const LIST& params, angular_size* in)
-{
-	size_t base = GenericFill(db,params,static_cast<dimensional_size*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to angular_size"); }    do { // convert the 'angle_selection' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->angle_selection, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to angular_size to be a `angle_relator`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<geometric_tolerance>(const DB& db, const LIST& params, geometric_tolerance* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to geometric_tolerance"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::geometric_tolerance,4>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->name, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to geometric_tolerance to be a `label`")); }
-    } while(0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::geometric_tolerance,4>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->description, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to geometric_tolerance to be a `text`")); }
-    } while(0);
-    do { // convert the 'magnitude' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::geometric_tolerance,4>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->magnitude, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to geometric_tolerance to be a `measure_with_unit`")); }
-    } while(0);
-    do { // convert the 'toleranced_shape_aspect' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::geometric_tolerance,4>::aux_is_derived[3]=true; break; }
-        try { GenericConvert( in->toleranced_shape_aspect, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to geometric_tolerance to be a `shape_aspect`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<geometric_tolerance_with_datum_reference>(const DB& db, const LIST& params, geometric_tolerance_with_datum_reference* in)
-{
-	size_t base = GenericFill(db,params,static_cast<geometric_tolerance*>(in));
-	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to geometric_tolerance_with_datum_reference"); }    do { // convert the 'datum_system' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::geometric_tolerance_with_datum_reference,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->datum_system, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to geometric_tolerance_with_datum_reference to be a `SET [1:?] OF datum_reference`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<angularity_tolerance>(const DB& db, const LIST& params, angularity_tolerance* in)
-{
-	size_t base = GenericFill(db,params,static_cast<geometric_tolerance_with_datum_reference*>(in));
-	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to angularity_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<styled_item>(const DB& db, const LIST& params, styled_item* in)
-{
-	size_t base = GenericFill(db,params,static_cast<representation_item*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to styled_item"); }    do { // convert the 'styles' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::styled_item,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->styles, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to styled_item to be a `SET [1:?] OF presentation_style_assignment`")); }
-    } while(0);
-    do { // convert the 'item' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::styled_item,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->item, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to styled_item to be a `representation_item`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<annotation_occurrence>(const DB& db, const LIST& params, annotation_occurrence* in)
-{
-	size_t base = GenericFill(db,params,static_cast<styled_item*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to annotation_occurrence"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<annotation_curve_occurrence>(const DB& db, const LIST& params, annotation_curve_occurrence* in)
-{
-	size_t base = GenericFill(db,params,static_cast<annotation_occurrence*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to annotation_curve_occurrence"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<annotation_fill_area>(const DB& db, const LIST& params, annotation_fill_area* in)
-{
-	size_t base = GenericFill(db,params,static_cast<geometric_representation_item*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to annotation_fill_area"); }    do { // convert the 'boundaries' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->boundaries, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to annotation_fill_area to be a `SET [1:?] OF curve`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<annotation_fill_area_occurrence>(const DB& db, const LIST& params, annotation_fill_area_occurrence* in)
-{
-	size_t base = GenericFill(db,params,static_cast<annotation_occurrence*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to annotation_fill_area_occurrence"); }    do { // convert the 'fill_style_target' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->fill_style_target, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to annotation_fill_area_occurrence to be a `point`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<annotation_occurrence_relationship>(const DB& db, const LIST& params, annotation_occurrence_relationship* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to annotation_occurrence_relationship"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::annotation_occurrence_relationship,4>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->name, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to annotation_occurrence_relationship to be a `label`")); }
-    } while(0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::annotation_occurrence_relationship,4>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->description, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to annotation_occurrence_relationship to be a `text`")); }
-    } while(0);
-    do { // convert the 'relating_annotation_occurrence' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::annotation_occurrence_relationship,4>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->relating_annotation_occurrence, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to annotation_occurrence_relationship to be a `annotation_occurrence`")); }
-    } while(0);
-    do { // convert the 'related_annotation_occurrence' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::annotation_occurrence_relationship,4>::aux_is_derived[3]=true; break; }
-        try { GenericConvert( in->related_annotation_occurrence, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to annotation_occurrence_relationship to be a `annotation_occurrence`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<annotation_occurrence_associativity>(const DB& db, const LIST& params, annotation_occurrence_associativity* in)
-{
-	size_t base = GenericFill(db,params,static_cast<annotation_occurrence_relationship*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to annotation_occurrence_associativity"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<annotation_plane>(const DB& db, const LIST& params, annotation_plane* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to annotation_plane"); }    do { // convert the 'elements' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->elements, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to annotation_plane to be a `SET [1:?] OF annotation_plane_element`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<annotation_symbol_occurrence>(const DB& db, const LIST& params, annotation_symbol_occurrence* in)
-{
-	size_t base = GenericFill(db,params,static_cast<annotation_occurrence*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to annotation_symbol_occurrence"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<annotation_subfigure_occurrence>(const DB& db, const LIST& params, annotation_subfigure_occurrence* in)
-{
-	size_t base = GenericFill(db,params,static_cast<annotation_symbol_occurrence*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to annotation_subfigure_occurrence"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<mapped_item>(const DB& db, const LIST& params, mapped_item* in)
-{
-	size_t base = GenericFill(db,params,static_cast<representation_item*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to mapped_item"); }    do { // convert the 'mapping_source' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::mapped_item,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->mapping_source, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to mapped_item to be a `representation_map`")); }
-    } while(0);
-    do { // convert the 'mapping_target' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::mapped_item,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->mapping_target, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to mapped_item to be a `representation_item`")); }
-    } while(0);
-	return base;
-}
-
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<annotation_symbol>(const DB& db, const LIST& params, annotation_symbol* in)
-{
-    size_t base = GenericFill(db, params, static_cast<mapped_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to annotation_symbol"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<annotation_text>(const DB& db, const LIST& params, annotation_text* in)
-{
-    size_t base = GenericFill(db, params, static_cast<mapped_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to annotation_text"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<annotation_text_character>(const DB& db, const LIST& params, annotation_text_character* in)
-{
-    size_t base = GenericFill(db, params, static_cast<mapped_item*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to annotation_text_character"); }    do { // convert the 'alignment' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->alignment, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to annotation_text_character to be a `text_alignment`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<annotation_text_occurrence>(const DB& db, const LIST& params, annotation_text_occurrence* in)
-{
-    size_t base = GenericFill(db, params, static_cast<annotation_occurrence*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to annotation_text_occurrence"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<shape_aspect>(const DB& db, const LIST& params, shape_aspect* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to shape_aspect"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shape_aspect, 4>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to shape_aspect to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shape_aspect, 4>::aux_is_derived[1] = true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to shape_aspect to be a `text`")); }
-    } while (0);
-    do { // convert the 'of_shape' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shape_aspect, 4>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->of_shape, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to shape_aspect to be a `product_definition_shape`")); }
-    } while (0);
-    do { // convert the 'product_definitional' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shape_aspect, 4>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->product_definitional, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to shape_aspect to be a `LOGICAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<derived_shape_aspect>(const DB& db, const LIST& params, derived_shape_aspect* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_aspect*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to derived_shape_aspect"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<apex>(const DB& db, const LIST& params, apex* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_shape_aspect*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to apex"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<application_context_element>(const DB& db, const LIST& params, application_context_element* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to application_context_element"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::application_context_element, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to application_context_element to be a `label`")); }
-    } while (0);
-    do { // convert the 'frame_of_reference' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::application_context_element, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->frame_of_reference, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to application_context_element to be a `application_context`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_action_assignment>(const DB& db, const LIST& params, applied_action_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<action_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_action_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::applied_action_assignment, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_action_assignment to be a `SET [1:?] OF action_items`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_action_method_assignment>(const DB& db, const LIST& params, applied_action_method_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<action_method_assignment*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_action_method_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_action_method_assignment to be a `SET [1:?] OF action_method_items`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_action_request_assignment>(const DB& db, const LIST& params, applied_action_request_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<action_request_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_action_request_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_action_request_assignment to be a `SET [1:?] OF action_request_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<approval_assignment>(const DB& db, const LIST& params, approval_assignment* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to approval_assignment"); }    do { // convert the 'assigned_approval' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::approval_assignment, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->assigned_approval, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to approval_assignment to be a `approval`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_approval_assignment>(const DB& db, const LIST& params, applied_approval_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<approval_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_approval_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_approval_assignment to be a `SET [1:?] OF approval_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<attribute_classification_assignment>(const DB& db, const LIST& params, attribute_classification_assignment* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to attribute_classification_assignment"); }    do { // convert the 'assigned_class' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::attribute_classification_assignment, 3>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->assigned_class, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to attribute_classification_assignment to be a `group`")); }
-    } while (0);
-    do { // convert the 'attribute_name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::attribute_classification_assignment, 3>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->attribute_name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to attribute_classification_assignment to be a `label`")); }
-    } while (0);
-    do { // convert the 'role' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::attribute_classification_assignment, 3>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->role, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to attribute_classification_assignment to be a `classification_role`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_attribute_classification_assignment>(const DB& db, const LIST& params, applied_attribute_classification_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<attribute_classification_assignment*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to applied_attribute_classification_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to applied_attribute_classification_assignment to be a `SET [1:?] OF attribute_classification_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<certification_assignment>(const DB& db, const LIST& params, certification_assignment* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to certification_assignment"); }    do { // convert the 'assigned_certification' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::certification_assignment, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->assigned_certification, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to certification_assignment to be a `certification`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_certification_assignment>(const DB& db, const LIST& params, applied_certification_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<certification_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_certification_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_certification_assignment to be a `SET [1:?] OF certification_item`")); }
-    } while (0);
-    return base;
-}
-
-} // ! STEP
-} // ! Assimp
-
-#endif
diff --git a/Engine/lib/assimp/code/Importer/StepFile/StepFileGen2.cpp b/Engine/lib/assimp/code/Importer/StepFile/StepFileGen2.cpp
deleted file mode 100644
index eca09e4e1..000000000
--- a/Engine/lib/assimp/code/Importer/StepFile/StepFileGen2.cpp
+++ /dev/null
@@ -1,3067 +0,0 @@
-/*
-Open Asset Import Library (ASSIMP)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2010, ASSIMP Development Team
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the ASSIMP team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the ASSIMP Development Team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-#include "code/Importer/StepFile/StepReaderGen.h"
-
-namespace Assimp {
-using namespace StepFile;
-namespace STEP {
-
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<classification_assignment>(const DB& db, const LIST& params, classification_assignment* in)
-    {
-        size_t base = 0;
-        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to classification_assignment"); }    do { // convert the 'assigned_class' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::classification_assignment, 2>::aux_is_derived[0] = true; break; }
-            try { GenericConvert(in->assigned_class, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to classification_assignment to be a `group`")); }
-        } while (0);
-        do { // convert the 'role' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::classification_assignment, 2>::aux_is_derived[1] = true; break; }
-            try { GenericConvert(in->role, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to classification_assignment to be a `classification_role`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<applied_classification_assignment>(const DB& db, const LIST& params, applied_classification_assignment* in)
-    {
-        size_t base = GenericFill(db, params, static_cast<classification_assignment*>(in));
-        if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_classification_assignment"); }    do { // convert the 'items' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            try { GenericConvert(in->items, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_classification_assignment to be a `SET [1:?] OF classification_item`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<contract_assignment>(const DB& db, const LIST& params, contract_assignment* in)
-    {
-        size_t base = 0;
-        if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to contract_assignment"); }    do { // convert the 'assigned_contract' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::contract_assignment, 1>::aux_is_derived[0] = true; break; }
-            try { GenericConvert(in->assigned_contract, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to contract_assignment to be a `contract`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<applied_contract_assignment>(const DB& db, const LIST& params, applied_contract_assignment* in)
-    {
-        size_t base = GenericFill(db, params, static_cast<contract_assignment*>(in));
-        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_contract_assignment"); }    do { // convert the 'items' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            try { GenericConvert(in->items, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_contract_assignment to be a `SET [1:?] OF contract_item`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<date_and_time_assignment>(const DB& db, const LIST& params, date_and_time_assignment* in)
-    {
-        size_t base = 0;
-        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to date_and_time_assignment"); }    do { // convert the 'assigned_date_and_time' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::date_and_time_assignment, 2>::aux_is_derived[0] = true; break; }
-            try { GenericConvert(in->assigned_date_and_time, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to date_and_time_assignment to be a `date_and_time`")); }
-        } while (0);
-        do { // convert the 'role' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::date_and_time_assignment, 2>::aux_is_derived[1] = true; break; }
-            try { GenericConvert(in->role, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to date_and_time_assignment to be a `date_time_role`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<applied_date_and_time_assignment>(const DB& db, const LIST& params, applied_date_and_time_assignment* in)
-    {
-        size_t base = GenericFill(db, params, static_cast<date_and_time_assignment*>(in));
-        if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_date_and_time_assignment"); }    do { // convert the 'items' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            try { GenericConvert(in->items, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_date_and_time_assignment to be a `SET [1:?] OF date_and_time_item`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<date_assignment>(const DB& db, const LIST& params, date_assignment* in)
-    {
-        size_t base = 0;
-        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to date_assignment"); }    do { // convert the 'assigned_date' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::date_assignment, 2>::aux_is_derived[0] = true; break; }
-            try { GenericConvert(in->assigned_date, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to date_assignment to be a `date`")); }
-        } while (0);
-        do { // convert the 'role' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::date_assignment, 2>::aux_is_derived[1] = true; break; }
-            try { GenericConvert(in->role, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to date_assignment to be a `date_role`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<applied_date_assignment>(const DB& db, const LIST& params, applied_date_assignment* in)
-    {
-        size_t base = GenericFill(db, params, static_cast<date_assignment*>(in));
-        if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_date_assignment"); }    do { // convert the 'items' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            try { GenericConvert(in->items, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_date_assignment to be a `SET [1:?] OF date_item`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<document_reference>(const DB& db, const LIST& params, document_reference* in)
-    {
-        size_t base = 0;
-        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to document_reference"); }    do { // convert the 'assigned_document' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::document_reference, 2>::aux_is_derived[0] = true; break; }
-            try { GenericConvert(in->assigned_document, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to document_reference to be a `document`")); }
-        } while (0);
-        do { // convert the 'source' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::document_reference, 2>::aux_is_derived[1] = true; break; }
-            try { GenericConvert(in->source, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to document_reference to be a `label`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<applied_document_reference>(const DB& db, const LIST& params, applied_document_reference* in)
-    {
-        size_t base = GenericFill(db, params, static_cast<document_reference*>(in));
-        if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_document_reference"); }    do { // convert the 'items' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            try { GenericConvert(in->items, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_document_reference to be a `SET [1:?] OF document_reference_item`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<document_usage_constraint_assignment>(const DB& db, const LIST& params, document_usage_constraint_assignment* in)
-    {
-        size_t base = 0;
-        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to document_usage_constraint_assignment"); }    do { // convert the 'assigned_document_usage' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::document_usage_constraint_assignment, 2>::aux_is_derived[0] = true; break; }
-            try { GenericConvert(in->assigned_document_usage, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to document_usage_constraint_assignment to be a `document_usage_constraint`")); }
-        } while (0);
-        do { // convert the 'role' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::document_usage_constraint_assignment, 2>::aux_is_derived[1] = true; break; }
-            try { GenericConvert(in->role, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to document_usage_constraint_assignment to be a `document_usage_role`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<applied_document_usage_constraint_assignment>(const DB& db, const LIST& params, applied_document_usage_constraint_assignment* in)
-    {
-        size_t base = GenericFill(db, params, static_cast<document_usage_constraint_assignment*>(in));
-        if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_document_usage_constraint_assignment"); }    do { // convert the 'items' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            try { GenericConvert(in->items, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_document_usage_constraint_assignment to be a `SET [1:?] OF document_reference_item`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<effectivity_assignment>(const DB& db, const LIST& params, effectivity_assignment* in)
-    {
-        size_t base = 0;
-        if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to effectivity_assignment"); }    do { // convert the 'assigned_effectivity' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::effectivity_assignment, 1>::aux_is_derived[0] = true; break; }
-            try { GenericConvert(in->assigned_effectivity, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to effectivity_assignment to be a `effectivity`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<applied_effectivity_assignment>(const DB& db, const LIST& params, applied_effectivity_assignment* in)
-    {
-        size_t base = GenericFill(db, params, static_cast<effectivity_assignment*>(in));
-        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_effectivity_assignment"); }    do { // convert the 'items' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            try { GenericConvert(in->items, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_effectivity_assignment to be a `SET [1:?] OF effectivity_item`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<event_occurrence_assignment>(const DB& db, const LIST& params, event_occurrence_assignment* in)
-    {
-        size_t base = 0;
-        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to event_occurrence_assignment"); }    do { // convert the 'assigned_event_occurrence' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::event_occurrence_assignment, 2>::aux_is_derived[0] = true; break; }
-            try { GenericConvert(in->assigned_event_occurrence, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to event_occurrence_assignment to be a `event_occurrence`")); }
-        } while (0);
-        do { // convert the 'role' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::event_occurrence_assignment, 2>::aux_is_derived[1] = true; break; }
-            try { GenericConvert(in->role, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to event_occurrence_assignment to be a `event_occurrence_role`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<applied_event_occurrence_assignment>(const DB& db, const LIST& params, applied_event_occurrence_assignment* in)
-    {
-        size_t base = GenericFill(db, params, static_cast<event_occurrence_assignment*>(in));
-        if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_event_occurrence_assignment"); }    do { // convert the 'items' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            try { GenericConvert(in->items, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_event_occurrence_assignment to be a `SET [1:?] OF event_occurrence_item`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<identification_assignment>(const DB& db, const LIST& params, identification_assignment* in)
-    {
-        size_t base = 0;
-        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to identification_assignment"); }    do { // convert the 'assigned_id' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::identification_assignment, 2>::aux_is_derived[0] = true; break; }
-            try { GenericConvert(in->assigned_id, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to identification_assignment to be a `identifier`")); }
-        } while (0);
-        do { // convert the 'role' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::identification_assignment, 2>::aux_is_derived[1] = true; break; }
-            try { GenericConvert(in->role, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to identification_assignment to be a `identification_role`")); }
-        } while (0);
-        return base;
-    }
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<external_identification_assignment>(const DB& db, const LIST& params, external_identification_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<identification_assignment*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to external_identification_assignment"); }    do { // convert the 'source' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::external_identification_assignment, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->source, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to external_identification_assignment to be a `external_source`")); }
-    } while (0);
-    return base;
-}
-
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_external_identification_assignment>(const DB& db, const LIST& params, applied_external_identification_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<external_identification_assignment*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to applied_external_identification_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to applied_external_identification_assignment to be a `SET [1:?] OF external_identification_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<group_assignment>(const DB& db, const LIST& params, group_assignment* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to group_assignment"); }    do { // convert the 'assigned_group' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::group_assignment, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->assigned_group, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to group_assignment to be a `group`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_group_assignment>(const DB& db, const LIST& params, applied_group_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_group_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_group_assignment to be a `SET [1:?] OF groupable_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_identification_assignment>(const DB& db, const LIST& params, applied_identification_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<identification_assignment*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_identification_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_identification_assignment to be a `SET [1:?] OF identification_item`")); }
-    } while (0);
-    return base;
-}
-
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<name_assignment>(const DB& db, const LIST& params, name_assignment* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to name_assignment"); }    do { // convert the 'assigned_name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::name_assignment, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->assigned_name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to name_assignment to be a `label`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_name_assignment>(const DB& db, const LIST& params, applied_name_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<name_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_name_assignment"); }    do { // convert the 'item' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->item, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_name_assignment to be a `name_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<organization_assignment>(const DB& db, const LIST& params, organization_assignment* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to organization_assignment"); }    do { // convert the 'assigned_organization' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::organization_assignment, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->assigned_organization, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to organization_assignment to be a `organization`")); }
-    } while (0);
-    do { // convert the 'role' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::organization_assignment, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->role, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to organization_assignment to be a `organization_role`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_organization_assignment>(const DB& db, const LIST& params, applied_organization_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<organization_assignment*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_organization_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_organization_assignment to be a `SET [1:?] OF organization_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<organizational_project_assignment>(const DB& db, const LIST& params, organizational_project_assignment* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to organizational_project_assignment"); }    do { // convert the 'assigned_organizational_project' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::organizational_project_assignment, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->assigned_organizational_project, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to organizational_project_assignment to be a `organizational_project`")); }
-    } while (0);
-    do { // convert the 'role' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::organizational_project_assignment, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->role, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to organizational_project_assignment to be a `organizational_project_role`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_organizational_project_assignment>(const DB& db, const LIST& params, applied_organizational_project_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<organizational_project_assignment*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_organizational_project_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_organizational_project_assignment to be a `SET [1:?] OF project_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<person_and_organization_assignment>(const DB& db, const LIST& params, person_and_organization_assignment* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to person_and_organization_assignment"); }    do { // convert the 'assigned_person_and_organization' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::person_and_organization_assignment, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->assigned_person_and_organization, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to person_and_organization_assignment to be a `person_and_organization`")); }
-    } while (0);
-    do { // convert the 'role' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::person_and_organization_assignment, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->role, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to person_and_organization_assignment to be a `person_and_organization_role`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_person_and_organization_assignment>(const DB& db, const LIST& params, applied_person_and_organization_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<person_and_organization_assignment*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_person_and_organization_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_person_and_organization_assignment to be a `SET [1:?] OF person_and_organization_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<presented_item>(const DB& db, const LIST& params, presented_item* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_presented_item>(const DB& db, const LIST& params, applied_presented_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<presented_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to applied_presented_item"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to applied_presented_item to be a `SET [1:?] OF presented_item_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<security_classification_assignment>(const DB& db, const LIST& params, security_classification_assignment* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to security_classification_assignment"); }    do { // convert the 'assigned_security_classification' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::security_classification_assignment, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->assigned_security_classification, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to security_classification_assignment to be a `security_classification`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_security_classification_assignment>(const DB& db, const LIST& params, applied_security_classification_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<security_classification_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_security_classification_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_security_classification_assignment to be a `SET [1:?] OF security_classification_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<time_interval_assignment>(const DB& db, const LIST& params, time_interval_assignment* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to time_interval_assignment"); }    do { // convert the 'assigned_time_interval' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::time_interval_assignment, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->assigned_time_interval, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to time_interval_assignment to be a `time_interval`")); }
-    } while (0);
-    do { // convert the 'role' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::time_interval_assignment, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->role, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to time_interval_assignment to be a `time_interval_role`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_time_interval_assignment>(const DB& db, const LIST& params, applied_time_interval_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<time_interval_assignment*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_time_interval_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_time_interval_assignment to be a `SET [0:?] OF time_interval_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_usage_right>(const DB& db, const LIST& params, applied_usage_right* in)
-{
-    size_t base = GenericFill(db, params, static_cast<applied_action_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_usage_right"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<area_in_set>(const DB& db, const LIST& params, area_in_set* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to area_in_set"); }    do { // convert the 'area' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::area_in_set, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->area, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to area_in_set to be a `presentation_area`")); }
-    } while (0);
-    do { // convert the 'in_set' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::area_in_set, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->in_set, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to area_in_set to be a `presentation_set`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<area_measure_with_unit>(const DB& db, const LIST& params, area_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to area_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<area_unit>(const DB& db, const LIST& params, area_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to area_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_definition_relationship>(const DB& db, const LIST& params, product_definition_relationship* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to product_definition_relationship"); }    do { // convert the 'id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_relationship, 5>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to product_definition_relationship to be a `identifier`")); }
-    } while (0);
-    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_relationship, 5>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to product_definition_relationship to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_relationship, 5>::aux_is_derived[2] = true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to product_definition_relationship to be a `text`")); }
-    } while (0);
-    do { // convert the 'relating_product_definition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_relationship, 5>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->relating_product_definition, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to product_definition_relationship to be a `product_definition`")); }
-    } while (0);
-    do { // convert the 'related_product_definition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_relationship, 5>::aux_is_derived[4] = true; break; }
-        try { GenericConvert(in->related_product_definition, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to product_definition_relationship to be a `product_definition`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_definition_usage>(const DB& db, const LIST& params, product_definition_usage* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition_relationship*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to product_definition_usage"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<assembly_component_usage>(const DB& db, const LIST& params, assembly_component_usage* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition_usage*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to assembly_component_usage"); }    do { // convert the 'reference_designator' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::assembly_component_usage, 1>::aux_is_derived[0] = true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->reference_designator, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to assembly_component_usage to be a `identifier`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<assigned_requirement>(const DB& db, const LIST& params, assigned_requirement* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to assigned_requirement"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to assigned_requirement to be a `SET [1:1] OF product_definition`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<compound_representation_item>(const DB& db, const LIST& params, compound_representation_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to compound_representation_item"); }    do { // convert the 'item_element' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::compound_representation_item, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->item_element, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to compound_representation_item to be a `compound_item_definition`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<atomic_formula>(const DB& db, const LIST& params, atomic_formula* in)
-{
-    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to atomic_formula"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<attribute_assertion>(const DB& db, const LIST& params, attribute_assertion* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<attribute_language_assignment>(const DB& db, const LIST& params, attribute_language_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<attribute_classification_assignment*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to attribute_language_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to attribute_language_assignment to be a `SET [1:?] OF attribute_language_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<attribute_value_assignment>(const DB& db, const LIST& params, attribute_value_assignment* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to attribute_value_assignment"); }    do { // convert the 'attribute_name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::attribute_value_assignment, 3>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->attribute_name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to attribute_value_assignment to be a `label`")); }
-    } while (0);
-    do { // convert the 'attribute_value' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::attribute_value_assignment, 3>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->attribute_value, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to attribute_value_assignment to be a `attribute_type`")); }
-    } while (0);
-    do { // convert the 'role' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::attribute_value_assignment, 3>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->role, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to attribute_value_assignment to be a `attribute_value_role`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<auxiliary_geometric_representation_item>(const DB& db, const LIST& params, auxiliary_geometric_representation_item* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<placement>(const DB& db, const LIST& params, placement* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to placement"); }    do { // convert the 'location' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::placement, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->location, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to placement to be a `cartesian_point`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<axis1_placement>(const DB& db, const LIST& params, axis1_placement* in)
-{
-    size_t base = GenericFill(db, params, static_cast<placement*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to axis1_placement"); }    do { // convert the 'axis' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->axis, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to axis1_placement to be a `direction`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<axis2_placement_2d>(const DB& db, const LIST& params, axis2_placement_2d* in)
-{
-    size_t base = GenericFill(db, params, static_cast<placement*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to axis2_placement_2d"); }    do { // convert the 'ref_direction' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->ref_direction, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to axis2_placement_2d to be a `direction`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<axis2_placement_3d>(const DB& db, const LIST& params, axis2_placement_3d* in)
-{
-    size_t base = GenericFill(db, params, static_cast<placement*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to axis2_placement_3d"); }    do { // convert the 'axis' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->axis, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to axis2_placement_3d to be a `direction`")); }
-    } while (0);
-    do { // convert the 'ref_direction' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->ref_direction, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to axis2_placement_3d to be a `direction`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<curve>(const DB& db, const LIST& params, curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to curve"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<bounded_curve>(const DB& db, const LIST& params, bounded_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<curve*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to bounded_curve"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<b_spline_curve>(const DB& db, const LIST& params, b_spline_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<bounded_curve*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to b_spline_curve"); }    do { // convert the 'degree' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_curve, 5>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->degree, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to b_spline_curve to be a `INTEGER`")); }
-    } while (0);
-    do { // convert the 'control_points_list' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_curve, 5>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->control_points_list, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to b_spline_curve to be a `LIST [2:?] OF cartesian_point`")); }
-    } while (0);
-    do { // convert the 'curve_form' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_curve, 5>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->curve_form, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to b_spline_curve to be a `b_spline_curve_form`")); }
-    } while (0);
-    do { // convert the 'closed_curve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_curve, 5>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->closed_curve, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to b_spline_curve to be a `LOGICAL`")); }
-    } while (0);
-    do { // convert the 'self_intersect' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_curve, 5>::aux_is_derived[4] = true; break; }
-        try { GenericConvert(in->self_intersect, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to b_spline_curve to be a `LOGICAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<b_spline_curve_with_knots>(const DB& db, const LIST& params, b_spline_curve_with_knots* in)
-{
-    size_t base = GenericFill(db, params, static_cast<b_spline_curve*>(in));
-    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to b_spline_curve_with_knots"); }    do { // convert the 'knot_multiplicities' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->knot_multiplicities, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to b_spline_curve_with_knots to be a `LIST [2:?] OF INTEGER`")); }
-    } while (0);
-    do { // convert the 'knots' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->knots, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to b_spline_curve_with_knots to be a `LIST [2:?] OF parameter_value`")); }
-    } while (0);
-    do { // convert the 'knot_spec' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->knot_spec, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to b_spline_curve_with_knots to be a `knot_type`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface>(const DB& db, const LIST& params, surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to surface"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<bounded_surface>(const DB& db, const LIST& params, bounded_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<surface*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to bounded_surface"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<b_spline_surface>(const DB& db, const LIST& params, b_spline_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<bounded_surface*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to b_spline_surface"); }    do { // convert the 'u_degree' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_surface, 6>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->u_degree, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to b_spline_surface to be a `INTEGER`")); }
-    } while (0);
-    do { // convert the 'v_degree' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_surface, 6>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->v_degree, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to b_spline_surface to be a `INTEGER`")); }
-    } while (0);
-    do { // convert the 'surface_form' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_surface, 6>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->surface_form, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to b_spline_surface to be a `b_spline_surface_form`")); }
-    } while (0);
-    do { // convert the 'u_closed' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_surface, 6>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->u_closed, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to b_spline_surface to be a `LOGICAL`")); }
-    } while (0);
-    do { // convert the 'v_closed' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_surface, 6>::aux_is_derived[4] = true; break; }
-        try { GenericConvert(in->v_closed, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to b_spline_surface to be a `LOGICAL`")); }
-    } while (0);
-    do { // convert the 'self_intersect' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_surface, 6>::aux_is_derived[5] = true; break; }
-        try { GenericConvert(in->self_intersect, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to b_spline_surface to be a `LOGICAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<b_spline_surface_with_knots>(const DB& db, const LIST& params, b_spline_surface_with_knots* in)
-{
-    size_t base = GenericFill(db, params, static_cast<b_spline_surface*>(in));
-    if (params.GetSize() < 12) { throw STEP::TypeError("expected 12 arguments to b_spline_surface_with_knots"); }    do { // convert the 'u_multiplicities' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->u_multiplicities, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to b_spline_surface_with_knots to be a `LIST [2:?] OF INTEGER`")); }
-    } while (0);
-    do { // convert the 'v_multiplicities' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->v_multiplicities, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to b_spline_surface_with_knots to be a `LIST [2:?] OF INTEGER`")); }
-    } while (0);
-    do { // convert the 'u_knots' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->u_knots, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to b_spline_surface_with_knots to be a `LIST [2:?] OF parameter_value`")); }
-    } while (0);
-    do { // convert the 'v_knots' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->v_knots, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to b_spline_surface_with_knots to be a `LIST [2:?] OF parameter_value`")); }
-    } while (0);
-    do { // convert the 'knot_spec' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->knot_spec, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 11 to b_spline_surface_with_knots to be a `knot_type`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_definition>(const DB& db, const LIST& params, product_definition* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to product_definition"); }    do { // convert the 'id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition, 4>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to product_definition to be a `identifier`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition, 4>::aux_is_derived[1] = true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to product_definition to be a `text`")); }
-    } while (0);
-    do { // convert the 'formation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition, 4>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->formation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to product_definition to be a `product_definition_formation`")); }
-    } while (0);
-    do { // convert the 'frame_of_reference' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition, 4>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->frame_of_reference, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to product_definition to be a `product_definition_context`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<rule_software_definition>(const DB& db, const LIST& params, rule_software_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to rule_software_definition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<rule_definition>(const DB& db, const LIST& params, rule_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<rule_software_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to rule_definition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<back_chaining_rule>(const DB& db, const LIST& params, back_chaining_rule* in)
-{
-    size_t base = GenericFill(db, params, static_cast<rule_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to back_chaining_rule"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<back_chaining_rule_body>(const DB& db, const LIST& params, back_chaining_rule_body* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<colour>(const DB& db, const LIST& params, colour* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<background_colour>(const DB& db, const LIST& params, background_colour* in)
-{
-    size_t base = GenericFill(db, params, static_cast<colour*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to background_colour"); }    do { // convert the 'presentation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->presentation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to background_colour to be a `area_or_view`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<beveled_sheet_representation>(const DB& db, const LIST& params, beveled_sheet_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to beveled_sheet_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<bezier_curve>(const DB& db, const LIST& params, bezier_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<b_spline_curve*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to bezier_curve"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<bezier_surface>(const DB& db, const LIST& params, bezier_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<b_spline_surface*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to bezier_surface"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<generic_expression>(const DB& db, const LIST& params, generic_expression* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<binary_generic_expression>(const DB& db, const LIST& params, binary_generic_expression* in)
-{
-    size_t base = GenericFill(db, params, static_cast<generic_expression*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to binary_generic_expression"); }    do { // convert the 'operands' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->operands, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to binary_generic_expression to be a `LIST [2:2] OF generic_expression`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<binary_numeric_expression>(const DB& db, const LIST& params, binary_numeric_expression* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<binary_representation_item>(const DB& db, const LIST& params, binary_representation_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to binary_representation_item"); }    do { // convert the 'binary_value' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::binary_representation_item, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->binary_value, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to binary_representation_item to be a `BINARY`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<block>(const DB& db, const LIST& params, block* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to block"); }    do { // convert the 'position' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->position, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to block to be a `axis2_placement_3d`")); }
-    } while (0);
-    do { // convert the 'x' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->x, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to block to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'y' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->y, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to block to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'z' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->z, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to block to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<expression>(const DB& db, const LIST& params, expression* in)
-{
-    size_t base = GenericFill(db, params, static_cast<generic_expression*>(in));
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<boolean_expression>(const DB& db, const LIST& params, boolean_expression* in)
-{
-    size_t base = GenericFill(db, params, static_cast<expression*>(in));
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<boolean_literal>(const DB& db, const LIST& params, boolean_literal* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to boolean_literal"); }    do { // convert the 'the_value' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->the_value, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to boolean_literal to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<boolean_representation_item>(const DB& db, const LIST& params, boolean_representation_item* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<boolean_result>(const DB& db, const LIST& params, boolean_result* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to boolean_result"); }    do { // convert the 'operator' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->operator_, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to boolean_result to be a `boolean_operator`")); }
-    } while (0);
-    do { // convert the 'first_operand' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->first_operand, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to boolean_result to be a `boolean_operand`")); }
-    } while (0);
-    do { // convert the 'second_operand' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->second_operand, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to boolean_result to be a `boolean_operand`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<composite_curve>(const DB& db, const LIST& params, composite_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<bounded_curve*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_curve"); }    do { // convert the 'segments' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::composite_curve, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->segments, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to composite_curve to be a `LIST [1:?] OF composite_curve_segment`")); }
-    } while (0);
-    do { // convert the 'self_intersect' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::composite_curve, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->self_intersect, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to composite_curve to be a `LOGICAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<composite_curve_on_surface>(const DB& db, const LIST& params, composite_curve_on_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<composite_curve*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_curve_on_surface"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<boundary_curve>(const DB& db, const LIST& params, boundary_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<composite_curve_on_surface*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to boundary_curve"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<bounded_pcurve>(const DB& db, const LIST& params, bounded_pcurve* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<bounded_surface_curve>(const DB& db, const LIST& params, bounded_surface_curve* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<founded_item>(const DB& db, const LIST& params, founded_item* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<box_domain>(const DB& db, const LIST& params, box_domain* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to box_domain"); }    do { // convert the 'corner' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->corner, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to box_domain to be a `cartesian_point`")); }
-    } while (0);
-    do { // convert the 'xlength' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->xlength, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to box_domain to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'ylength' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->ylength, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to box_domain to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'zlength' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->zlength, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to box_domain to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<half_space_solid>(const DB& db, const LIST& params, half_space_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to half_space_solid"); }    do { // convert the 'base_surface' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::half_space_solid, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->base_surface, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to half_space_solid to be a `surface`")); }
-    } while (0);
-    do { // convert the 'agreement_flag' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::half_space_solid, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->agreement_flag, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to half_space_solid to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<boxed_half_space>(const DB& db, const LIST& params, boxed_half_space* in)
-{
-    size_t base = GenericFill(db, params, static_cast<half_space_solid*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to boxed_half_space"); }    do { // convert the 'enclosure' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->enclosure, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to boxed_half_space to be a `box_domain`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<breakdown_context>(const DB& db, const LIST& params, breakdown_context* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition_relationship*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to breakdown_context"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<breakdown_element_group_assignment>(const DB& db, const LIST& params, breakdown_element_group_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to breakdown_element_group_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to breakdown_element_group_assignment to be a `SET [1:1] OF product_definition_or_breakdown_element_usage`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<breakdown_element_realization>(const DB& db, const LIST& params, breakdown_element_realization* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<breakdown_element_usage>(const DB& db, const LIST& params, breakdown_element_usage* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition_relationship*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to breakdown_element_usage"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<breakdown_of>(const DB& db, const LIST& params, breakdown_of* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition_relationship*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to breakdown_of"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_model>(const DB& db, const LIST& params, solid_model* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to solid_model"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<manifold_solid_brep>(const DB& db, const LIST& params, manifold_solid_brep* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_model*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to manifold_solid_brep"); }    do { // convert the 'outer' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::manifold_solid_brep, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->outer, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to manifold_solid_brep to be a `closed_shell`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<brep_with_voids>(const DB& db, const LIST& params, brep_with_voids* in)
-{
-    size_t base = GenericFill(db, params, static_cast<manifold_solid_brep*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to brep_with_voids"); }    do { // convert the 'voids' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->voids, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to brep_with_voids to be a `SET [1:?] OF oriented_closed_shell`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<bytes_representation_item>(const DB& db, const LIST& params, bytes_representation_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<binary_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to bytes_representation_item"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<date>(const DB& db, const LIST& params, date* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to date"); }    do { // convert the 'year_component' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::date, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->year_component, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to date to be a `year_number`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<calendar_date>(const DB& db, const LIST& params, calendar_date* in)
-{
-    size_t base = GenericFill(db, params, static_cast<date*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to calendar_date"); }    do { // convert the 'day_component' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->day_component, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to calendar_date to be a `day_in_month_number`")); }
-    } while (0);
-    do { // convert the 'month_component' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->month_component, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to calendar_date to be a `month_in_year_number`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<camera_image>(const DB& db, const LIST& params, camera_image* in)
-{
-    size_t base = GenericFill(db, params, static_cast<mapped_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to camera_image"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<camera_image_3d_with_scale>(const DB& db, const LIST& params, camera_image_3d_with_scale* in)
-{
-    size_t base = GenericFill(db, params, static_cast<camera_image*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to camera_image_3d_with_scale"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<camera_model>(const DB& db, const LIST& params, camera_model* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to camera_model"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<camera_model_d3>(const DB& db, const LIST& params, camera_model_d3* in)
-{
-    size_t base = GenericFill(db, params, static_cast<camera_model*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to camera_model_d3"); }    do { // convert the 'view_reference_system' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::camera_model_d3, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->view_reference_system, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to camera_model_d3 to be a `axis2_placement_3d`")); }
-    } while (0);
-    do { // convert the 'perspective_of_volume' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::camera_model_d3, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->perspective_of_volume, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to camera_model_d3 to be a `view_volume`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<camera_model_d3_multi_clipping>(const DB& db, const LIST& params, camera_model_d3_multi_clipping* in)
-{
-    size_t base = GenericFill(db, params, static_cast<camera_model_d3*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to camera_model_d3_multi_clipping"); }    do { // convert the 'shape_clipping' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->shape_clipping, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to camera_model_d3_multi_clipping to be a `SET [1:?] OF camera_model_d3_multi_clipping_interection_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<camera_model_d3_multi_clipping_intersection>(const DB& db, const LIST& params, camera_model_d3_multi_clipping_intersection* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to camera_model_d3_multi_clipping_intersection"); }    do { // convert the 'shape_clipping' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->shape_clipping, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to camera_model_d3_multi_clipping_intersection to be a `SET [2:?] OF camera_model_d3_multi_clipping_interection_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<camera_model_d3_multi_clipping_union>(const DB& db, const LIST& params, camera_model_d3_multi_clipping_union* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to camera_model_d3_multi_clipping_union"); }    do { // convert the 'shape_clipping' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->shape_clipping, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to camera_model_d3_multi_clipping_union to be a `SET [2:?] OF camera_model_d3_multi_clipping_union_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<camera_model_d3_with_hlhsr>(const DB& db, const LIST& params, camera_model_d3_with_hlhsr* in)
-{
-    size_t base = GenericFill(db, params, static_cast<camera_model_d3*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to camera_model_d3_with_hlhsr"); }    do { // convert the 'hidden_line_surface_removal' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->hidden_line_surface_removal, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to camera_model_d3_with_hlhsr to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<camera_model_with_light_sources>(const DB& db, const LIST& params, camera_model_with_light_sources* in)
-{
-    size_t base = GenericFill(db, params, static_cast<camera_model_d3*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to camera_model_with_light_sources"); }    do { // convert the 'sources' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->sources, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to camera_model_with_light_sources to be a `SET [1:?] OF light_source`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<representation_map>(const DB& db, const LIST& params, representation_map* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to representation_map"); }    do { // convert the 'mapping_origin' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_map, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->mapping_origin, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to representation_map to be a `representation_item`")); }
-    } while (0);
-    do { // convert the 'mapped_representation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_map, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->mapped_representation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to representation_map to be a `representation`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<camera_usage>(const DB& db, const LIST& params, camera_usage* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_map*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to camera_usage"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<capacitance_measure_with_unit>(const DB& db, const LIST& params, capacitance_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to capacitance_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<capacitance_unit>(const DB& db, const LIST& params, capacitance_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to capacitance_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<point>(const DB& db, const LIST& params, point* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to point"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<cartesian_point>(const DB& db, const LIST& params, cartesian_point* in)
-{
-    size_t base = GenericFill(db, params, static_cast<point*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to cartesian_point"); }    do { // convert the 'coordinates' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->coordinates, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to cartesian_point to be a `LIST [1:3] OF length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<cartesian_transformation_operator>(const DB& db, const LIST& params, cartesian_transformation_operator* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to cartesian_transformation_operator"); }    do { // convert the 'axis1' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::cartesian_transformation_operator, 4>::aux_is_derived[0] = true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->axis1, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to cartesian_transformation_operator to be a `direction`")); }
-    } while (0);
-    do { // convert the 'axis2' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::cartesian_transformation_operator, 4>::aux_is_derived[1] = true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->axis2, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to cartesian_transformation_operator to be a `direction`")); }
-    } while (0);
-    do { // convert the 'local_origin' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::cartesian_transformation_operator, 4>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->local_origin, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to cartesian_transformation_operator to be a `cartesian_point`")); }
-    } while (0);
-    do { // convert the 'scale' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::cartesian_transformation_operator, 4>::aux_is_derived[3] = true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->scale, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to cartesian_transformation_operator to be a `REAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<cartesian_transformation_operator_2d>(const DB& db, const LIST& params, cartesian_transformation_operator_2d* in)
-{
-    size_t base = GenericFill(db, params, static_cast<cartesian_transformation_operator*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to cartesian_transformation_operator_2d"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<cartesian_transformation_operator_3d>(const DB& db, const LIST& params, cartesian_transformation_operator_3d* in)
-{
-    size_t base = GenericFill(db, params, static_cast<cartesian_transformation_operator*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to cartesian_transformation_operator_3d"); }    do { // convert the 'axis3' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->axis3, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to cartesian_transformation_operator_3d to be a `direction`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<cc_design_approval>(const DB& db, const LIST& params, cc_design_approval* in)
-{
-    size_t base = GenericFill(db, params, static_cast<approval_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to cc_design_approval"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to cc_design_approval to be a `SET [1:?] OF approved_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<cc_design_certification>(const DB& db, const LIST& params, cc_design_certification* in)
-{
-    size_t base = GenericFill(db, params, static_cast<certification_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to cc_design_certification"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to cc_design_certification to be a `SET [1:?] OF certified_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<cc_design_contract>(const DB& db, const LIST& params, cc_design_contract* in)
-{
-    size_t base = GenericFill(db, params, static_cast<contract_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to cc_design_contract"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to cc_design_contract to be a `SET [1:?] OF contracted_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<cc_design_date_and_time_assignment>(const DB& db, const LIST& params, cc_design_date_and_time_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<date_and_time_assignment*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to cc_design_date_and_time_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to cc_design_date_and_time_assignment to be a `SET [1:?] OF date_time_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<cc_design_person_and_organization_assignment>(const DB& db, const LIST& params, cc_design_person_and_organization_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<person_and_organization_assignment*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to cc_design_person_and_organization_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to cc_design_person_and_organization_assignment to be a `SET [1:?] OF cc_person_organization_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<cc_design_security_classification>(const DB& db, const LIST& params, cc_design_security_classification* in)
-{
-    size_t base = GenericFill(db, params, static_cast<security_classification_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to cc_design_security_classification"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to cc_design_security_classification to be a `SET [1:?] OF cc_classified_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<cc_design_specification_reference>(const DB& db, const LIST& params, cc_design_specification_reference* in)
-{
-    size_t base = GenericFill(db, params, static_cast<document_reference*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to cc_design_specification_reference"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to cc_design_specification_reference to be a `SET [1:?] OF cc_specified_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<celsius_temperature_measure_with_unit>(const DB& db, const LIST& params, celsius_temperature_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to celsius_temperature_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<centre_of_symmetry>(const DB& db, const LIST& params, centre_of_symmetry* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_shape_aspect*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to centre_of_symmetry"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<change>(const DB& db, const LIST& params, change* in)
-{
-    size_t base = GenericFill(db, params, static_cast<action_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to change"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to change to be a `SET [1:?] OF work_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<change_request>(const DB& db, const LIST& params, change_request* in)
-{
-    size_t base = GenericFill(db, params, static_cast<action_request_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to change_request"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to change_request to be a `SET [1:?] OF change_request_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<character_glyph_style_outline>(const DB& db, const LIST& params, character_glyph_style_outline* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to character_glyph_style_outline"); }    do { // convert the 'outline_style' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->outline_style, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to character_glyph_style_outline to be a `curve_style`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<character_glyph_style_stroke>(const DB& db, const LIST& params, character_glyph_style_stroke* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to character_glyph_style_stroke"); }    do { // convert the 'stroke_style' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->stroke_style, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to character_glyph_style_stroke to be a `curve_style`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<symbol_representation>(const DB& db, const LIST& params, symbol_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to symbol_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<generic_character_glyph_symbol>(const DB& db, const LIST& params, generic_character_glyph_symbol* in)
-{
-    size_t base = GenericFill(db, params, static_cast<symbol_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to generic_character_glyph_symbol"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<character_glyph_symbol>(const DB& db, const LIST& params, character_glyph_symbol* in)
-{
-    size_t base = GenericFill(db, params, static_cast<generic_character_glyph_symbol*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to character_glyph_symbol"); }    do { // convert the 'character_box' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::character_glyph_symbol, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->character_box, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to character_glyph_symbol to be a `planar_extent`")); }
-    } while (0);
-    do { // convert the 'baseline_ratio' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::character_glyph_symbol, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->baseline_ratio, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to character_glyph_symbol to be a `ratio_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<character_glyph_symbol_outline>(const DB& db, const LIST& params, character_glyph_symbol_outline* in)
-{
-    size_t base = GenericFill(db, params, static_cast<character_glyph_symbol*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to character_glyph_symbol_outline"); }    do { // convert the 'outlines' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->outlines, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to character_glyph_symbol_outline to be a `SET [1:?] OF annotation_fill_area`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<character_glyph_symbol_stroke>(const DB& db, const LIST& params, character_glyph_symbol_stroke* in)
-{
-    size_t base = GenericFill(db, params, static_cast<character_glyph_symbol*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to character_glyph_symbol_stroke"); }    do { // convert the 'strokes' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->strokes, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to character_glyph_symbol_stroke to be a `SET [1:?] OF curve`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<general_property>(const DB& db, const LIST& params, general_property* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to general_property"); }    do { // convert the 'id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::general_property, 3>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to general_property to be a `identifier`")); }
-    } while (0);
-    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::general_property, 3>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to general_property to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::general_property, 3>::aux_is_derived[2] = true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to general_property to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<characteristic_data_column_header>(const DB& db, const LIST& params, characteristic_data_column_header* in)
-{
-    size_t base = GenericFill(db, params, static_cast<general_property*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to characteristic_data_column_header"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<general_property_relationship>(const DB& db, const LIST& params, general_property_relationship* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to general_property_relationship"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::general_property_relationship, 4>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to general_property_relationship to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::general_property_relationship, 4>::aux_is_derived[1] = true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to general_property_relationship to be a `text`")); }
-    } while (0);
-    do { // convert the 'relating_property' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::general_property_relationship, 4>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->relating_property, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to general_property_relationship to be a `general_property`")); }
-    } while (0);
-    do { // convert the 'related_property' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::general_property_relationship, 4>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->related_property, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to general_property_relationship to be a `general_property`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<characteristic_data_column_header_link>(const DB& db, const LIST& params, characteristic_data_column_header_link* in)
-{
-    size_t base = GenericFill(db, params, static_cast<general_property_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to characteristic_data_column_header_link"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<characteristic_data_table_header>(const DB& db, const LIST& params, characteristic_data_table_header* in)
-{
-    size_t base = GenericFill(db, params, static_cast<general_property*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to characteristic_data_table_header"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<characteristic_data_table_header_decomposition>(const DB& db, const LIST& params, characteristic_data_table_header_decomposition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<general_property_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to characteristic_data_table_header_decomposition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<group>(const DB& db, const LIST& params, group* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to group"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::group, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to group to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::group, 2>::aux_is_derived[1] = true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to group to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<characteristic_type>(const DB& db, const LIST& params, characteristic_type* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to characteristic_type"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<characterized_class>(const DB& db, const LIST& params, characterized_class* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<characterized_object>(const DB& db, const LIST& params, characterized_object* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to characterized_object"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::characterized_object, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to characterized_object to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::characterized_object, 2>::aux_is_derived[1] = true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to characterized_object to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<conic>(const DB& db, const LIST& params, conic* in)
-{
-    size_t base = GenericFill(db, params, static_cast<curve*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to conic"); }    do { // convert the 'position' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::conic, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->position, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to conic to be a `axis2_placement`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<circle>(const DB& db, const LIST& params, circle* in)
-{
-    size_t base = GenericFill(db, params, static_cast<conic*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to circle"); }    do { // convert the 'radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to circle to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<circular_runout_tolerance>(const DB& db, const LIST& params, circular_runout_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance_with_datum_reference*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to circular_runout_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<class_by_extension>(const DB& db, const LIST& params, class_by_extension* in)
-{
-    size_t base = GenericFill(db, params, static_cast<class_t*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to class_by_extension"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<class_by_intension>(const DB& db, const LIST& params, class_by_intension* in)
-{
-    size_t base = GenericFill(db, params, static_cast<class_t*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to class_by_intension"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<class_system>(const DB& db, const LIST& params, class_system* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to class_system"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<effectivity_context_assignment>(const DB& db, const LIST& params, effectivity_context_assignment* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to effectivity_context_assignment"); }    do { // convert the 'assigned_effectivity_assignment' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::effectivity_context_assignment, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->assigned_effectivity_assignment, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to effectivity_context_assignment to be a `effectivity_assignment`")); }
-    } while (0);
-    do { // convert the 'role' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::effectivity_context_assignment, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->role, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to effectivity_context_assignment to be a `effectivity_context_role`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<class_usage_effectivity_context_assignment>(const DB& db, const LIST& params, class_usage_effectivity_context_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<effectivity_context_assignment*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to class_usage_effectivity_context_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to class_usage_effectivity_context_assignment to be a `SET [1:?] OF class_usage_effectivity_context_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<topological_representation_item>(const DB& db, const LIST& params, topological_representation_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to topological_representation_item"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<connected_face_set>(const DB& db, const LIST& params, connected_face_set* in)
-{
-    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to connected_face_set"); }    do { // convert the 'cfs_faces' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::connected_face_set, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->cfs_faces, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to connected_face_set to be a `SET [1:?] OF face`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<closed_shell>(const DB& db, const LIST& params, closed_shell* in)
-{
-    size_t base = GenericFill(db, params, static_cast<connected_face_set*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to closed_shell"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<coaxiality_tolerance>(const DB& db, const LIST& params, coaxiality_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance_with_datum_reference*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to coaxiality_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<colour_specification>(const DB& db, const LIST& params, colour_specification* in)
-{
-    size_t base = GenericFill(db, params, static_cast<colour*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to colour_specification"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::colour_specification, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to colour_specification to be a `label`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<colour_rgb>(const DB& db, const LIST& params, colour_rgb* in)
-{
-    size_t base = GenericFill(db, params, static_cast<colour_specification*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to colour_rgb"); }    do { // convert the 'red' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->red, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to colour_rgb to be a `REAL`")); }
-    } while (0);
-    do { // convert the 'green' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->green, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to colour_rgb to be a `REAL`")); }
-    } while (0);
-    do { // convert the 'blue' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->blue, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to colour_rgb to be a `REAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<common_datum>(const DB& db, const LIST& params, common_datum* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<comparison_expression>(const DB& db, const LIST& params, comparison_expression* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<complex_clause>(const DB& db, const LIST& params, complex_clause* in)
-{
-    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to complex_clause"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<complex_conjunctive_clause>(const DB& db, const LIST& params, complex_conjunctive_clause* in)
-{
-    size_t base = GenericFill(db, params, static_cast<complex_clause*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to complex_conjunctive_clause"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<complex_disjunctive_clause>(const DB& db, const LIST& params, complex_disjunctive_clause* in)
-{
-    size_t base = GenericFill(db, params, static_cast<complex_clause*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to complex_disjunctive_clause"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<modified_solid>(const DB& db, const LIST& params, modified_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_model*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to modified_solid"); }    do { // convert the 'rationale' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::modified_solid, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->rationale, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to modified_solid to be a `text`")); }
-    } while (0);
-    do { // convert the 'base_solid' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::modified_solid, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->base_solid, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to modified_solid to be a `base_solid_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<shelled_solid>(const DB& db, const LIST& params, shelled_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<modified_solid*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to shelled_solid"); }    do { // convert the 'deleted_face_set' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shelled_solid, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->deleted_face_set, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to shelled_solid to be a `SET [1:?] OF face_surface`")); }
-    } while (0);
-    do { // convert the 'thickness' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shelled_solid, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->thickness, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to shelled_solid to be a `length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<complex_shelled_solid>(const DB& db, const LIST& params, complex_shelled_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shelled_solid*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to complex_shelled_solid"); }    do { // convert the 'thickness_list' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->thickness_list, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to complex_shelled_solid to be a `LIST [1:?] OF length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<composite_assembly_definition>(const DB& db, const LIST& params, composite_assembly_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to composite_assembly_definition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<composite_assembly_sequence_definition>(const DB& db, const LIST& params, composite_assembly_sequence_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to composite_assembly_sequence_definition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<laminate_table>(const DB& db, const LIST& params, laminate_table* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to laminate_table"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<part_laminate_table>(const DB& db, const LIST& params, part_laminate_table* in)
-{
-    size_t base = GenericFill(db, params, static_cast<laminate_table*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to part_laminate_table"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<composite_assembly_table>(const DB& db, const LIST& params, composite_assembly_table* in)
-{
-    size_t base = GenericFill(db, params, static_cast<part_laminate_table*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to composite_assembly_table"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<composite_curve_segment>(const DB& db, const LIST& params, composite_curve_segment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_curve_segment"); }    do { // convert the 'transition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::composite_curve_segment, 3>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->transition, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to composite_curve_segment to be a `transition_code`")); }
-    } while (0);
-    do { // convert the 'same_sense' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::composite_curve_segment, 3>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->same_sense, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to composite_curve_segment to be a `BOOLEAN`")); }
-    } while (0);
-    do { // convert the 'parent_curve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::composite_curve_segment, 3>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->parent_curve, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to composite_curve_segment to be a `curve`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<material_designation>(const DB& db, const LIST& params, material_designation* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to material_designation"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::material_designation, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to material_designation to be a `label`")); }
-    } while (0);
-    do { // convert the 'definitions' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::material_designation, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->definitions, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to material_designation to be a `SET [1:?] OF characterized_definition`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<composite_material_designation>(const DB& db, const LIST& params, composite_material_designation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<material_designation*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to composite_material_designation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<composite_shape_aspect>(const DB& db, const LIST& params, composite_shape_aspect* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_aspect*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to composite_shape_aspect"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<composite_sheet_representation>(const DB& db, const LIST& params, composite_sheet_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_sheet_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<composite_text>(const DB& db, const LIST& params, composite_text* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to composite_text"); }    do { // convert the 'collected_text' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::composite_text, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->collected_text, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to composite_text to be a `SET [2:?] OF text_or_character`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<composite_text_with_associated_curves>(const DB& db, const LIST& params, composite_text_with_associated_curves* in)
-{
-    size_t base = GenericFill(db, params, static_cast<composite_text*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_text_with_associated_curves"); }    do { // convert the 'associated_curves' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->associated_curves, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to composite_text_with_associated_curves to be a `SET [1:?] OF curve`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<composite_text_with_blanking_box>(const DB& db, const LIST& params, composite_text_with_blanking_box* in)
-{
-    size_t base = GenericFill(db, params, static_cast<composite_text*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_text_with_blanking_box"); }    do { // convert the 'blanking' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->blanking, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to composite_text_with_blanking_box to be a `planar_box`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<composite_text_with_delineation>(const DB& db, const LIST& params, composite_text_with_delineation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<composite_text*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_text_with_delineation"); }    do { // convert the 'delineation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->delineation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to composite_text_with_delineation to be a `text_delineation`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<composite_text_with_extent>(const DB& db, const LIST& params, composite_text_with_extent* in)
-{
-    size_t base = GenericFill(db, params, static_cast<composite_text*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_text_with_extent"); }    do { // convert the 'extent' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->extent, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to composite_text_with_extent to be a `planar_extent`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<compound_shape_representation>(const DB& db, const LIST& params, compound_shape_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to compound_shape_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<concentricity_tolerance>(const DB& db, const LIST& params, concentricity_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance_with_datum_reference*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to concentricity_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<concept_feature_relationship>(const DB& db, const LIST& params, concept_feature_relationship* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to concept_feature_relationship"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::concept_feature_relationship, 4>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to concept_feature_relationship to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::concept_feature_relationship, 4>::aux_is_derived[1] = true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to concept_feature_relationship to be a `text`")); }
-    } while (0);
-    do { // convert the 'relating_product_concept_feature' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::concept_feature_relationship, 4>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->relating_product_concept_feature, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to concept_feature_relationship to be a `product_concept_feature`")); }
-    } while (0);
-    do { // convert the 'related_product_concept_feature' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::concept_feature_relationship, 4>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->related_product_concept_feature, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to concept_feature_relationship to be a `product_concept_feature`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<concept_feature_relationship_with_condition>(const DB& db, const LIST& params, concept_feature_relationship_with_condition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<concept_feature_relationship*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to concept_feature_relationship_with_condition"); }    do { // convert the 'conditional_operator' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->conditional_operator, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to concept_feature_relationship_with_condition to be a `concept_feature_operator`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_concept_feature>(const DB& db, const LIST& params, product_concept_feature* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to product_concept_feature"); }    do { // convert the 'id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_concept_feature, 3>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to product_concept_feature to be a `identifier`")); }
-    } while (0);
-    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_concept_feature, 3>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to product_concept_feature to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_concept_feature, 3>::aux_is_derived[2] = true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to product_concept_feature to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<conditional_concept_feature>(const DB& db, const LIST& params, conditional_concept_feature* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_concept_feature*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to conditional_concept_feature"); }    do { // convert the 'condition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::conditional_concept_feature, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->condition, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to conditional_concept_feature to be a `concept_feature_relationship_with_condition`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<conductance_measure_with_unit>(const DB& db, const LIST& params, conductance_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to conductance_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<conductance_unit>(const DB& db, const LIST& params, conductance_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to conductance_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<configuration_item>(const DB& db, const LIST& params, configuration_item* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to configuration_item"); }    do { // convert the 'id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item, 5>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to configuration_item to be a `identifier`")); }
-    } while (0);
-    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item, 5>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to configuration_item to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item, 5>::aux_is_derived[2] = true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to configuration_item to be a `text`")); }
-    } while (0);
-    do { // convert the 'item_concept' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item, 5>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->item_concept, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to configuration_item to be a `product_concept`")); }
-    } while (0);
-    do { // convert the 'purpose' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item, 5>::aux_is_derived[4] = true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->purpose, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to configuration_item to be a `label`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<configurable_item>(const DB& db, const LIST& params, configurable_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<configuration_item*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to configurable_item"); }    do { // convert the 'item_concept_feature' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->item_concept_feature, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to configurable_item to be a `SET [1:?] OF product_concept_feature_association`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<effectivity>(const DB& db, const LIST& params, effectivity* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to effectivity"); }    do { // convert the 'id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::effectivity, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to effectivity to be a `identifier`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_definition_effectivity>(const DB& db, const LIST& params, product_definition_effectivity* in)
-{
-    size_t base = GenericFill(db, params, static_cast<effectivity*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to product_definition_effectivity"); }    do { // convert the 'usage' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_effectivity, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->usage, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to product_definition_effectivity to be a `product_definition_relationship`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<configuration_effectivity>(const DB& db, const LIST& params, configuration_effectivity* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition_effectivity*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to configuration_effectivity"); }    do { // convert the 'configuration' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->configuration, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to configuration_effectivity to be a `configuration_design`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<configuration_item_relationship>(const DB& db, const LIST& params, configuration_item_relationship* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to configuration_item_relationship"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item_relationship, 4>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to configuration_item_relationship to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item_relationship, 4>::aux_is_derived[1] = true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to configuration_item_relationship to be a `text`")); }
-    } while (0);
-    do { // convert the 'relating_configuration_item' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item_relationship, 4>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->relating_configuration_item, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to configuration_item_relationship to be a `configuration_item`")); }
-    } while (0);
-    do { // convert the 'related_configuration_item' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item_relationship, 4>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->related_configuration_item, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to configuration_item_relationship to be a `configuration_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<configuration_item_hierarchical_relationship>(const DB& db, const LIST& params, configuration_item_hierarchical_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<configuration_item_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to configuration_item_hierarchical_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<configuration_item_revision_sequence>(const DB& db, const LIST& params, configuration_item_revision_sequence* in)
-{
-    size_t base = GenericFill(db, params, static_cast<configuration_item_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to configuration_item_revision_sequence"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<configured_effectivity_assignment>(const DB& db, const LIST& params, configured_effectivity_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<effectivity_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to configured_effectivity_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to configured_effectivity_assignment to be a `SET [1:?] OF configured_effectivity_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<configured_effectivity_context_assignment>(const DB& db, const LIST& params, configured_effectivity_context_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<effectivity_context_assignment*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to configured_effectivity_context_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to configured_effectivity_context_assignment to be a `SET [1:?] OF configured_effectivity_context_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<conical_stepped_hole_transition>(const DB& db, const LIST& params, conical_stepped_hole_transition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to conical_stepped_hole_transition"); }    do { // convert the 'transition_number' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->transition_number, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to conical_stepped_hole_transition to be a `positive_integer`")); }
-    } while (0);
-    do { // convert the 'cone_apex_angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->cone_apex_angle, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to conical_stepped_hole_transition to be a `plane_angle_measure`")); }
-    } while (0);
-    do { // convert the 'cone_base_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->cone_base_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to conical_stepped_hole_transition to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<elementary_surface>(const DB& db, const LIST& params, elementary_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<surface*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to elementary_surface"); }    do { // convert the 'position' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::elementary_surface, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->position, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to elementary_surface to be a `axis2_placement_3d`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<conical_surface>(const DB& db, const LIST& params, conical_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<elementary_surface*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to conical_surface"); }    do { // convert the 'radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to conical_surface to be a `length_measure`")); }
-    } while (0);
-    do { // convert the 'semi_angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->semi_angle, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to conical_surface to be a `plane_angle_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<connected_edge_set>(const DB& db, const LIST& params, connected_edge_set* in)
-{
-    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to connected_edge_set"); }    do { // convert the 'ces_edges' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->ces_edges, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to connected_edge_set to be a `SET [1:?] OF edge`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<connected_face_sub_set>(const DB& db, const LIST& params, connected_face_sub_set* in)
-{
-    size_t base = GenericFill(db, params, static_cast<connected_face_set*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to connected_face_sub_set"); }    do { // convert the 'parent_face_set' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->parent_face_set, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to connected_face_sub_set to be a `connected_face_set`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<constructive_geometry_representation>(const DB& db, const LIST& params, constructive_geometry_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to constructive_geometry_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<representation_relationship>(const DB& db, const LIST& params, representation_relationship* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to representation_relationship"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_relationship, 4>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to representation_relationship to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_relationship, 4>::aux_is_derived[1] = true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to representation_relationship to be a `text`")); }
-    } while (0);
-    do { // convert the 'rep_1' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_relationship, 4>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->rep_1, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to representation_relationship to be a `representation`")); }
-    } while (0);
-    do { // convert the 'rep_2' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_relationship, 4>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->rep_2, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to representation_relationship to be a `representation`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<constructive_geometry_representation_relationship>(const DB& db, const LIST& params, constructive_geometry_representation_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to constructive_geometry_representation_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<contact_ratio_representation>(const DB& db, const LIST& params, contact_ratio_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to contact_ratio_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<invisibility>(const DB& db, const LIST& params, invisibility* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to invisibility"); }    do { // convert the 'invisible_items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::invisibility, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->invisible_items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to invisibility to be a `SET [1:?] OF invisible_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<context_dependent_invisibility>(const DB& db, const LIST& params, context_dependent_invisibility* in)
-{
-    size_t base = GenericFill(db, params, static_cast<invisibility*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to context_dependent_invisibility"); }    do { // convert the 'presentation_context' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->presentation_context, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to context_dependent_invisibility to be a `invisibility_context`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<over_riding_styled_item>(const DB& db, const LIST& params, over_riding_styled_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<styled_item*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to over_riding_styled_item"); }    do { // convert the 'over_ridden_style' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::over_riding_styled_item, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->over_ridden_style, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to over_riding_styled_item to be a `styled_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<context_dependent_over_riding_styled_item>(const DB& db, const LIST& params, context_dependent_over_riding_styled_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<over_riding_styled_item*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to context_dependent_over_riding_styled_item"); }    do { // convert the 'style_context' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::context_dependent_over_riding_styled_item, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->style_context, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to context_dependent_over_riding_styled_item to be a `LIST [1:?] OF style_context_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<context_dependent_unit>(const DB& db, const LIST& params, context_dependent_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to context_dependent_unit"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::context_dependent_unit, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to context_dependent_unit to be a `label`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<conversion_based_unit>(const DB& db, const LIST& params, conversion_based_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to conversion_based_unit"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to conversion_based_unit to be a `label`")); }
-    } while (0);
-    do { // convert the 'conversion_factor' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->conversion_factor, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to conversion_based_unit to be a `measure_with_unit`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<csg_shape_representation>(const DB& db, const LIST& params, csg_shape_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to csg_shape_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<csg_solid>(const DB& db, const LIST& params, csg_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_model*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to csg_solid"); }    do { // convert the 'tree_root_expression' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->tree_root_expression, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to csg_solid to be a `csg_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<currency>(const DB& db, const LIST& params, currency* in)
-{
-    size_t base = GenericFill(db, params, static_cast<context_dependent_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to currency"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<currency_measure_with_unit>(const DB& db, const LIST& params, currency_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to currency_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<curve_bounded_surface>(const DB& db, const LIST& params, curve_bounded_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<bounded_surface*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to curve_bounded_surface"); }    do { // convert the 'basis_surface' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->basis_surface, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to curve_bounded_surface to be a `surface`")); }
-    } while (0);
-    do { // convert the 'boundaries' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->boundaries, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to curve_bounded_surface to be a `SET [1:?] OF boundary_curve`")); }
-    } while (0);
-    do { // convert the 'implicit_outer' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->implicit_outer, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to curve_bounded_surface to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<curve_dimension>(const DB& db, const LIST& params, curve_dimension* in)
-{
-    size_t base = GenericFill(db, params, static_cast<dimension_curve_directed_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to curve_dimension"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<curve_replica>(const DB& db, const LIST& params, curve_replica* in)
-{
-    size_t base = GenericFill(db, params, static_cast<curve*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to curve_replica"); }    do { // convert the 'parent_curve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->parent_curve, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to curve_replica to be a `curve`")); }
-    } while (0);
-    do { // convert the 'transformation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->transformation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to curve_replica to be a `cartesian_transformation_operator`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<curve_style>(const DB& db, const LIST& params, curve_style* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to curve_style"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to curve_style to be a `label`")); }
-    } while (0);
-    do { // convert the 'curve_font' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->curve_font, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to curve_style to be a `curve_font_or_scaled_curve_font_select`")); }
-    } while (0);
-    do { // convert the 'curve_width' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->curve_width, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to curve_style to be a `size_select`")); }
-    } while (0);
-    do { // convert the 'curve_colour' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->curve_colour, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to curve_style to be a `colour`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<curve_style_font>(const DB& db, const LIST& params, curve_style_font* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to curve_style_font"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to curve_style_font to be a `label`")); }
-    } while (0);
-    do { // convert the 'pattern_list' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->pattern_list, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to curve_style_font to be a `LIST [1:?] OF curve_style_font_pattern`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<curve_style_font_and_scaling>(const DB& db, const LIST& params, curve_style_font_and_scaling* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to curve_style_font_and_scaling"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to curve_style_font_and_scaling to be a `label`")); }
-    } while (0);
-    do { // convert the 'curve_font' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->curve_font, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to curve_style_font_and_scaling to be a `curve_style_font_select`")); }
-    } while (0);
-    do { // convert the 'curve_font_scaling' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->curve_font_scaling, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to curve_style_font_and_scaling to be a `REAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<curve_style_font_pattern>(const DB& db, const LIST& params, curve_style_font_pattern* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to curve_style_font_pattern"); }    do { // convert the 'visible_segment_length' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->visible_segment_length, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to curve_style_font_pattern to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'invisible_segment_length' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->invisible_segment_length, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to curve_style_font_pattern to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<curve_swept_solid_shape_representation>(const DB& db, const LIST& params, curve_swept_solid_shape_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to curve_swept_solid_shape_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<cylindrical_surface>(const DB& db, const LIST& params, cylindrical_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<elementary_surface*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to cylindrical_surface"); }    do { // convert the 'radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to cylindrical_surface to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<cylindricity_tolerance>(const DB& db, const LIST& params, cylindricity_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to cylindricity_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<date_representation_item>(const DB& db, const LIST& params, date_representation_item* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<date_time_representation_item>(const DB& db, const LIST& params, date_time_representation_item* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dated_effectivity>(const DB& db, const LIST& params, dated_effectivity* in)
-{
-    size_t base = GenericFill(db, params, static_cast<effectivity*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to dated_effectivity"); }    do { // convert the 'effectivity_end_date' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->effectivity_end_date, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to dated_effectivity to be a `date_time_or_event_occurrence`")); }
-    } while (0);
-    do { // convert the 'effectivity_start_date' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->effectivity_start_date, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to dated_effectivity to be a `date_time_or_event_occurrence`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<datum>(const DB& db, const LIST& params, datum* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_aspect*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to datum"); }    do { // convert the 'identification' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->identification, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to datum to be a `identifier`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<datum_feature>(const DB& db, const LIST& params, datum_feature* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_aspect*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to datum_feature"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<datum_feature_callout>(const DB& db, const LIST& params, datum_feature_callout* in)
-{
-    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to datum_feature_callout"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<datum_reference>(const DB& db, const LIST& params, datum_reference* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to datum_reference"); }    do { // convert the 'precedence' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::datum_reference, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->precedence, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to datum_reference to be a `INTEGER`")); }
-    } while (0);
-    do { // convert the 'referenced_datum' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::datum_reference, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->referenced_datum, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to datum_reference to be a `datum`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<datum_target>(const DB& db, const LIST& params, datum_target* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_aspect*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to datum_target"); }    do { // convert the 'target_id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::datum_target, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->target_id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to datum_target to be a `identifier`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<datum_target_callout>(const DB& db, const LIST& params, datum_target_callout* in)
-{
-    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to datum_target_callout"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<default_tolerance_table>(const DB& db, const LIST& params, default_tolerance_table* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to default_tolerance_table"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<default_tolerance_table_cell>(const DB& db, const LIST& params, default_tolerance_table_cell* in)
-{
-    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to default_tolerance_table_cell"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<defined_symbol>(const DB& db, const LIST& params, defined_symbol* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to defined_symbol"); }    do { // convert the 'definition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->definition, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to defined_symbol to be a `defined_symbol_select`")); }
-    } while (0);
-    do { // convert the 'target' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->target, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to defined_symbol to be a `symbol_target`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<definitional_representation>(const DB& db, const LIST& params, definitional_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to definitional_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<definitional_representation_relationship>(const DB& db, const LIST& params, definitional_representation_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to definitional_representation_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<definitional_representation_relationship_with_same_context>(const DB& db, const LIST& params, definitional_representation_relationship_with_same_context* in)
-{
-    size_t base = GenericFill(db, params, static_cast<definitional_representation_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to definitional_representation_relationship_with_same_context"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<degenerate_pcurve>(const DB& db, const LIST& params, degenerate_pcurve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<point*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to degenerate_pcurve"); }    do { // convert the 'basis_surface' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::degenerate_pcurve, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->basis_surface, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to degenerate_pcurve to be a `surface`")); }
-    } while (0);
-    do { // convert the 'reference_to_curve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::degenerate_pcurve, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->reference_to_curve, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to degenerate_pcurve to be a `definitional_representation`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<toroidal_surface>(const DB& db, const LIST& params, toroidal_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<elementary_surface*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to toroidal_surface"); }    do { // convert the 'major_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::toroidal_surface, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->major_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to toroidal_surface to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'minor_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::toroidal_surface, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->minor_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to toroidal_surface to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<degenerate_toroidal_surface>(const DB& db, const LIST& params, degenerate_toroidal_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<toroidal_surface*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to degenerate_toroidal_surface"); }    do { // convert the 'select_outer' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->select_outer, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to degenerate_toroidal_surface to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<descriptive_representation_item>(const DB& db, const LIST& params, descriptive_representation_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to descriptive_representation_item"); }    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::descriptive_representation_item, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to descriptive_representation_item to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_definition_context>(const DB& db, const LIST& params, product_definition_context* in)
-{
-    size_t base = GenericFill(db, params, static_cast<application_context_element*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to product_definition_context"); }    do { // convert the 'life_cycle_stage' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_context, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->life_cycle_stage, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to product_definition_context to be a `label`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<design_context>(const DB& db, const LIST& params, design_context* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition_context*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to design_context"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<design_make_from_relationship>(const DB& db, const LIST& params, design_make_from_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition_relationship*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to design_make_from_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<diameter_dimension>(const DB& db, const LIST& params, diameter_dimension* in)
-{
-    size_t base = GenericFill(db, params, static_cast<dimension_curve_directed_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to diameter_dimension"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<ratio_measure_with_unit>(const DB& db, const LIST& params, ratio_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to ratio_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dielectric_constant_measure_with_unit>(const DB& db, const LIST& params, dielectric_constant_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<ratio_measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to dielectric_constant_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dimension_callout>(const DB& db, const LIST& params, dimension_callout* in)
-{
-    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to dimension_callout"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<draughting_callout_relationship>(const DB& db, const LIST& params, draughting_callout_relationship* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to draughting_callout_relationship"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::draughting_callout_relationship, 4>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to draughting_callout_relationship to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::draughting_callout_relationship, 4>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to draughting_callout_relationship to be a `text`")); }
-    } while (0);
-    do { // convert the 'relating_draughting_callout' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::draughting_callout_relationship, 4>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->relating_draughting_callout, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to draughting_callout_relationship to be a `draughting_callout`")); }
-    } while (0);
-    do { // convert the 'related_draughting_callout' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::draughting_callout_relationship, 4>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->related_draughting_callout, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to draughting_callout_relationship to be a `draughting_callout`")); }
-    } while (0);
-    return base;
-}
-
-}
-}
diff --git a/Engine/lib/assimp/code/Importer/StepFile/StepFileGen3.cpp b/Engine/lib/assimp/code/Importer/StepFile/StepFileGen3.cpp
deleted file mode 100644
index d8d81141f..000000000
--- a/Engine/lib/assimp/code/Importer/StepFile/StepFileGen3.cpp
+++ /dev/null
@@ -1,5746 +0,0 @@
-/*
-Open Asset Import Library (ASSIMP)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2010, ASSIMP Development Team
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the ASSIMP team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the ASSIMP Development Team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-#include "code/Importer/StepFile/StepReaderGen.h"
-
-namespace Assimp {
-using namespace StepFile;
-namespace STEP {
-
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dimension_callout_component_relationship>(const DB& db, const LIST& params, dimension_callout_component_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<draughting_callout_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to dimension_callout_component_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dimension_callout_relationship>(const DB& db, const LIST& params, dimension_callout_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<draughting_callout_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to dimension_callout_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dimension_curve>(const DB& db, const LIST& params, dimension_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<annotation_curve_occurrence*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to dimension_curve"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<terminator_symbol>(const DB& db, const LIST& params, terminator_symbol* in)
-{
-    size_t base = GenericFill(db, params, static_cast<annotation_symbol_occurrence*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to terminator_symbol"); }    do { // convert the 'annotated_curve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::terminator_symbol, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->annotated_curve, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to terminator_symbol to be a `annotation_curve_occurrence`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dimension_curve_terminator>(const DB& db, const LIST& params, dimension_curve_terminator* in)
-{
-    size_t base = GenericFill(db, params, static_cast<terminator_symbol*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to dimension_curve_terminator"); }    do { // convert the 'role' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->role, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to dimension_curve_terminator to be a `dimension_extent_usage`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dimension_curve_terminator_to_projection_curve_associativity>(const DB& db, const LIST& params, dimension_curve_terminator_to_projection_curve_associativity* in)
-{
-    size_t base = GenericFill(db, params, static_cast<annotation_occurrence_associativity*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to dimension_curve_terminator_to_projection_curve_associativity"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dimension_pair>(const DB& db, const LIST& params, dimension_pair* in)
-{
-    size_t base = GenericFill(db, params, static_cast<draughting_callout_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to dimension_pair"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dimension_text_associativity>(const DB& db, const LIST& params, dimension_text_associativity* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dimensional_location_with_path>(const DB& db, const LIST& params, dimensional_location_with_path* in)
-{
-    size_t base = GenericFill(db, params, static_cast<dimensional_location*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to dimensional_location_with_path"); }    do { // convert the 'path' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->path, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to dimensional_location_with_path to be a `shape_aspect`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dimensional_size_with_path>(const DB& db, const LIST& params, dimensional_size_with_path* in)
-{
-    size_t base = GenericFill(db, params, static_cast<dimensional_size*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to dimensional_size_with_path"); }    do { // convert the 'path' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->path, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to dimensional_size_with_path to be a `shape_aspect`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<executed_action>(const DB& db, const LIST& params, executed_action* in)
-{
-    size_t base = GenericFill(db, params, static_cast<action*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to executed_action"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<directed_action>(const DB& db, const LIST& params, directed_action* in)
-{
-    size_t base = GenericFill(db, params, static_cast<executed_action*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to directed_action"); }    do { // convert the 'directive' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->directive, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to directed_action to be a `action_directive`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<directed_dimensional_location>(const DB& db, const LIST& params, directed_dimensional_location* in)
-{
-    size_t base = GenericFill(db, params, static_cast<dimensional_location*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to directed_dimensional_location"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<direction>(const DB& db, const LIST& params, direction* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to direction"); }    do { // convert the 'direction_ratios' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->direction_ratios, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to direction to be a `LIST [2:3] OF REAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<document_file>(const DB& db, const LIST& params, document_file* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<document_identifier>(const DB& db, const LIST& params, document_identifier* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to document_identifier"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<document_identifier_assignment>(const DB& db, const LIST& params, document_identifier_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to document_identifier_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to document_identifier_assignment to be a `SET [1:?] OF document_identifier_assigned_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<document_product_association>(const DB& db, const LIST& params, document_product_association* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to document_product_association"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::document_product_association, 4>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to document_product_association to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::document_product_association, 4>::aux_is_derived[1] = true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to document_product_association to be a `text`")); }
-    } while (0);
-    do { // convert the 'relating_document' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::document_product_association, 4>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->relating_document, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to document_product_association to be a `document`")); }
-    } while (0);
-    do { // convert the 'related_product' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::document_product_association, 4>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->related_product, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to document_product_association to be a `product_or_formation_or_definition`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<document_product_equivalence>(const DB& db, const LIST& params, document_product_equivalence* in)
-{
-    size_t base = GenericFill(db, params, static_cast<document_product_association*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to document_product_equivalence"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dose_equivalent_measure_with_unit>(const DB& db, const LIST& params, dose_equivalent_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to dose_equivalent_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dose_equivalent_unit>(const DB& db, const LIST& params, dose_equivalent_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to dose_equivalent_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<double_offset_shelled_solid>(const DB& db, const LIST& params, double_offset_shelled_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shelled_solid*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to double_offset_shelled_solid"); }    do { // convert the 'thickness2' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->thickness2, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to double_offset_shelled_solid to be a `length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<item_defined_transformation>(const DB& db, const LIST& params, item_defined_transformation* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to item_defined_transformation"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::item_defined_transformation, 4>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to item_defined_transformation to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::item_defined_transformation, 4>::aux_is_derived[1] = true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to item_defined_transformation to be a `text`")); }
-    } while (0);
-    do { // convert the 'transform_item_1' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::item_defined_transformation, 4>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->transform_item_1, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to item_defined_transformation to be a `representation_item`")); }
-    } while (0);
-    do { // convert the 'transform_item_2' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::item_defined_transformation, 4>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->transform_item_2, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to item_defined_transformation to be a `representation_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<transformation_with_derived_angle>(const DB& db, const LIST& params, transformation_with_derived_angle* in)
-{
-    size_t base = GenericFill(db, params, static_cast<item_defined_transformation*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to transformation_with_derived_angle"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<draped_defined_transformation>(const DB& db, const LIST& params, draped_defined_transformation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<transformation_with_derived_angle*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to draped_defined_transformation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<draughting_annotation_occurrence>(const DB& db, const LIST& params, draughting_annotation_occurrence* in)
-{
-    size_t base = GenericFill(db, params, static_cast<annotation_occurrence*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to draughting_annotation_occurrence"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<draughting_elements>(const DB& db, const LIST& params, draughting_elements* in)
-{
-    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to draughting_elements"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<draughting_model>(const DB& db, const LIST& params, draughting_model* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to draughting_model"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<item_identified_representation_usage>(const DB& db, const LIST& params, item_identified_representation_usage* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to item_identified_representation_usage"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::item_identified_representation_usage, 5>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to item_identified_representation_usage to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::item_identified_representation_usage, 5>::aux_is_derived[1] = true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to item_identified_representation_usage to be a `text`")); }
-    } while (0);
-    do { // convert the 'definition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::item_identified_representation_usage, 5>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->definition, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to item_identified_representation_usage to be a `represented_definition`")); }
-    } while (0);
-    do { // convert the 'used_representation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::item_identified_representation_usage, 5>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->used_representation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to item_identified_representation_usage to be a `representation`")); }
-    } while (0);
-    do { // convert the 'identified_item' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::item_identified_representation_usage, 5>::aux_is_derived[4] = true; break; }
-        try { GenericConvert(in->identified_item, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to item_identified_representation_usage to be a `representation_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<draughting_model_item_association>(const DB& db, const LIST& params, draughting_model_item_association* in)
-{
-    size_t base = GenericFill(db, params, static_cast<item_identified_representation_usage*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to draughting_model_item_association"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pre_defined_colour>(const DB& db, const LIST& params, pre_defined_colour* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<draughting_pre_defined_colour>(const DB& db, const LIST& params, draughting_pre_defined_colour* in)
-{
-    size_t base = GenericFill(db, params, static_cast<pre_defined_colour*>(in));
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pre_defined_item>(const DB& db, const LIST& params, pre_defined_item* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_item"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::pre_defined_item, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to pre_defined_item to be a `label`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pre_defined_curve_font>(const DB& db, const LIST& params, pre_defined_curve_font* in)
-{
-    size_t base = GenericFill(db, params, static_cast<pre_defined_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_curve_font"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<draughting_pre_defined_curve_font>(const DB& db, const LIST& params, draughting_pre_defined_curve_font* in)
-{
-    size_t base = GenericFill(db, params, static_cast<pre_defined_curve_font*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to draughting_pre_defined_curve_font"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pre_defined_text_font>(const DB& db, const LIST& params, pre_defined_text_font* in)
-{
-    size_t base = GenericFill(db, params, static_cast<pre_defined_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_text_font"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<draughting_pre_defined_text_font>(const DB& db, const LIST& params, draughting_pre_defined_text_font* in)
-{
-    size_t base = GenericFill(db, params, static_cast<pre_defined_text_font*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to draughting_pre_defined_text_font"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<draughting_subfigure_representation>(const DB& db, const LIST& params, draughting_subfigure_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<symbol_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to draughting_subfigure_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<draughting_symbol_representation>(const DB& db, const LIST& params, draughting_symbol_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<symbol_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to draughting_symbol_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<text_literal>(const DB& db, const LIST& params, text_literal* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to text_literal"); }    do { // convert the 'literal' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::text_literal, 5>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->literal, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to text_literal to be a `presentable_text`")); }
-    } while (0);
-    do { // convert the 'placement' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::text_literal, 5>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->placement, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to text_literal to be a `axis2_placement`")); }
-    } while (0);
-    do { // convert the 'alignment' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::text_literal, 5>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->alignment, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to text_literal to be a `text_alignment`")); }
-    } while (0);
-    do { // convert the 'path' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::text_literal, 5>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->path, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to text_literal to be a `text_path`")); }
-    } while (0);
-    do { // convert the 'font' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::text_literal, 5>::aux_is_derived[4] = true; break; }
-        try { GenericConvert(in->font, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to text_literal to be a `font_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<text_literal_with_delineation>(const DB& db, const LIST& params, text_literal_with_delineation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<text_literal*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to text_literal_with_delineation"); }    do { // convert the 'delineation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::text_literal_with_delineation, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->delineation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to text_literal_with_delineation to be a `text_delineation`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<draughting_text_literal_with_delineation>(const DB& db, const LIST& params, draughting_text_literal_with_delineation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<text_literal_with_delineation*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to draughting_text_literal_with_delineation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<presentation_set>(const DB& db, const LIST& params, presentation_set* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<drawing_revision>(const DB& db, const LIST& params, drawing_revision* in)
-{
-    size_t base = GenericFill(db, params, static_cast<presentation_set*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to drawing_revision"); }    do { // convert the 'revision_identifier' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->revision_identifier, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to drawing_revision to be a `identifier`")); }
-    } while (0);
-    do { // convert the 'drawing_identifier' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->drawing_identifier, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to drawing_revision to be a `drawing_definition`")); }
-    } while (0);
-    do { // convert the 'intended_scale' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->intended_scale, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to drawing_revision to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<presentation_representation>(const DB& db, const LIST& params, presentation_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to presentation_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<presentation_area>(const DB& db, const LIST& params, presentation_area* in)
-{
-    size_t base = GenericFill(db, params, static_cast<presentation_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to presentation_area"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<drawing_sheet_revision>(const DB& db, const LIST& params, drawing_sheet_revision* in)
-{
-    size_t base = GenericFill(db, params, static_cast<presentation_area*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to drawing_sheet_revision"); }    do { // convert the 'revision_identifier' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->revision_identifier, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to drawing_sheet_revision to be a `identifier`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<drawing_sheet_revision_sequence>(const DB& db, const LIST& params, drawing_sheet_revision_sequence* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to drawing_sheet_revision_sequence"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<drawing_sheet_revision_usage>(const DB& db, const LIST& params, drawing_sheet_revision_usage* in)
-{
-    size_t base = GenericFill(db, params, static_cast<area_in_set*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to drawing_sheet_revision_usage"); }    do { // convert the 'sheet_number' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->sheet_number, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to drawing_sheet_revision_usage to be a `identifier`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<edge>(const DB& db, const LIST& params, edge* in)
-{
-    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to edge"); }    do { // convert the 'edge_start' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::edge, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->edge_start, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to edge to be a `vertex`")); }
-    } while (0);
-    do { // convert the 'edge_end' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::edge, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->edge_end, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to edge to be a `vertex`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<edge_based_wireframe_model>(const DB& db, const LIST& params, edge_based_wireframe_model* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to edge_based_wireframe_model"); }    do { // convert the 'ebwm_boundary' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->ebwm_boundary, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to edge_based_wireframe_model to be a `SET [1:?] OF connected_edge_set`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<edge_based_wireframe_shape_representation>(const DB& db, const LIST& params, edge_based_wireframe_shape_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to edge_based_wireframe_shape_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<edge_blended_solid>(const DB& db, const LIST& params, edge_blended_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<modified_solid*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to edge_blended_solid"); }    do { // convert the 'blended_edges' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::edge_blended_solid, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->blended_edges, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to edge_blended_solid to be a `LIST [1:?] OF edge_curve`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<edge_curve>(const DB& db, const LIST& params, edge_curve* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to edge_curve"); }    do { // convert the 'edge_geometry' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->edge_geometry, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to edge_curve to be a `curve`")); }
-    } while (0);
-    do { // convert the 'same_sense' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->same_sense, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to edge_curve to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<edge_loop>(const DB& db, const LIST& params, edge_loop* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<electric_charge_measure_with_unit>(const DB& db, const LIST& params, electric_charge_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to electric_charge_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<electric_charge_unit>(const DB& db, const LIST& params, electric_charge_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to electric_charge_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<electric_current_measure_with_unit>(const DB& db, const LIST& params, electric_current_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to electric_current_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<electric_current_unit>(const DB& db, const LIST& params, electric_current_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to electric_current_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<electric_potential_measure_with_unit>(const DB& db, const LIST& params, electric_potential_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to electric_potential_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<electric_potential_unit>(const DB& db, const LIST& params, electric_potential_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to electric_potential_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<elementary_brep_shape_representation>(const DB& db, const LIST& params, elementary_brep_shape_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to elementary_brep_shape_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<ellipse>(const DB& db, const LIST& params, ellipse* in)
-{
-    size_t base = GenericFill(db, params, static_cast<conic*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to ellipse"); }    do { // convert the 'semi_axis_1' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->semi_axis_1, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to ellipse to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'semi_axis_2' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->semi_axis_2, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to ellipse to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<energy_measure_with_unit>(const DB& db, const LIST& params, energy_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to energy_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<energy_unit>(const DB& db, const LIST& params, energy_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to energy_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<property_definition>(const DB& db, const LIST& params, property_definition* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to property_definition"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::property_definition, 3>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to property_definition to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::property_definition, 3>::aux_is_derived[1] = true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to property_definition to be a `text`")); }
-    } while (0);
-    do { // convert the 'definition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::property_definition, 3>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->definition, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to property_definition to be a `characterized_definition`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<fact_type>(const DB& db, const LIST& params, fact_type* in)
-{
-    size_t base = GenericFill(db, params, static_cast<property_definition*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to fact_type"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<entity_assertion>(const DB& db, const LIST& params, entity_assertion* in)
-{
-    size_t base = GenericFill(db, params, static_cast<fact_type*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to entity_assertion"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<enum_reference_prefix>(const DB& db, const LIST& params, enum_reference_prefix* in)
-{
-    size_t base = GenericFill(db, params, static_cast<descriptive_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to enum_reference_prefix"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<evaluated_characteristic>(const DB& db, const LIST& params, evaluated_characteristic* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<evaluated_degenerate_pcurve>(const DB& db, const LIST& params, evaluated_degenerate_pcurve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<degenerate_pcurve*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to evaluated_degenerate_pcurve"); }    do { // convert the 'equivalent_point' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->equivalent_point, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to evaluated_degenerate_pcurve to be a `cartesian_point`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<evaluation_product_definition>(const DB& db, const LIST& params, evaluation_product_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to evaluation_product_definition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<event_occurrence>(const DB& db, const LIST& params, event_occurrence* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to event_occurrence"); }    do { // convert the 'id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::event_occurrence, 3>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to event_occurrence to be a `identifier`")); }
-    } while (0);
-    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::event_occurrence, 3>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to event_occurrence to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::event_occurrence, 3>::aux_is_derived[2] = true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to event_occurrence to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_concept_feature_category>(const DB& db, const LIST& params, product_concept_feature_category* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to product_concept_feature_category"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<exclusive_product_concept_feature_category>(const DB& db, const LIST& params, exclusive_product_concept_feature_category* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_concept_feature_category*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to exclusive_product_concept_feature_category"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<uncertainty_qualifier>(const DB& db, const LIST& params, uncertainty_qualifier* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to uncertainty_qualifier"); }    do { // convert the 'measure_name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::uncertainty_qualifier, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->measure_name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to uncertainty_qualifier to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::uncertainty_qualifier, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to uncertainty_qualifier to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<standard_uncertainty>(const DB& db, const LIST& params, standard_uncertainty* in)
-{
-    size_t base = GenericFill(db, params, static_cast<uncertainty_qualifier*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to standard_uncertainty"); }    do { // convert the 'uncertainty_value' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::standard_uncertainty, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->uncertainty_value, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to standard_uncertainty to be a `REAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<expanded_uncertainty>(const DB& db, const LIST& params, expanded_uncertainty* in)
-{
-    size_t base = GenericFill(db, params, static_cast<standard_uncertainty*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to expanded_uncertainty"); }    do { // convert the 'coverage_factor' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->coverage_factor, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to expanded_uncertainty to be a `REAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<representation_item_relationship>(const DB& db, const LIST& params, representation_item_relationship* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to representation_item_relationship"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_item_relationship, 4>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to representation_item_relationship to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_item_relationship, 4>::aux_is_derived[1] = true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to representation_item_relationship to be a `text`")); }
-    } while (0);
-    do { // convert the 'relating_representation_item' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_item_relationship, 4>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->relating_representation_item, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to representation_item_relationship to be a `representation_item`")); }
-    } while (0);
-    do { // convert the 'related_representation_item' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_item_relationship, 4>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->related_representation_item, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to representation_item_relationship to be a `representation_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<explicit_procedural_representation_item_relationship>(const DB& db, const LIST& params, explicit_procedural_representation_item_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_item_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to explicit_procedural_representation_item_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<explicit_procedural_geometric_representation_item_relationship>(const DB& db, const LIST& params, explicit_procedural_geometric_representation_item_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<explicit_procedural_representation_item_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to explicit_procedural_geometric_representation_item_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<explicit_procedural_representation_relationship>(const DB& db, const LIST& params, explicit_procedural_representation_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to explicit_procedural_representation_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<explicit_procedural_shape_representation_relationship>(const DB& db, const LIST& params, explicit_procedural_shape_representation_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<explicit_procedural_representation_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to explicit_procedural_shape_representation_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<expression_conversion_based_unit>(const DB& db, const LIST& params, expression_conversion_based_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<extension>(const DB& db, const LIST& params, extension* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_shape_aspect*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to extension"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<extent>(const DB& db, const LIST& params, extent* in)
-{
-    size_t base = GenericFill(db, params, static_cast<characterized_object*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to extent"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<external_source>(const DB& db, const LIST& params, external_source* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to external_source"); }    do { // convert the 'source_id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::external_source, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->source_id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to external_source to be a `source_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<external_class_library>(const DB& db, const LIST& params, external_class_library* in)
-{
-    size_t base = GenericFill(db, params, static_cast<external_source*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to external_class_library"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_class>(const DB& db, const LIST& params, externally_defined_class* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_colour>(const DB& db, const LIST& params, externally_defined_colour* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_context_dependent_unit>(const DB& db, const LIST& params, externally_defined_context_dependent_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_conversion_based_unit>(const DB& db, const LIST& params, externally_defined_conversion_based_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_currency>(const DB& db, const LIST& params, externally_defined_currency* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_item>(const DB& db, const LIST& params, externally_defined_item* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to externally_defined_item"); }    do { // convert the 'item_id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::externally_defined_item, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->item_id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to externally_defined_item to be a `source_item`")); }
-    } while (0);
-    do { // convert the 'source' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::externally_defined_item, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->source, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to externally_defined_item to be a `external_source`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_curve_font>(const DB& db, const LIST& params, externally_defined_curve_font* in)
-{
-    size_t base = GenericFill(db, params, static_cast<externally_defined_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to externally_defined_curve_font"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_dimension_definition>(const DB& db, const LIST& params, externally_defined_dimension_definition* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_general_property>(const DB& db, const LIST& params, externally_defined_general_property* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_hatch_style>(const DB& db, const LIST& params, externally_defined_hatch_style* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_marker>(const DB& db, const LIST& params, externally_defined_marker* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<picture_representation_item>(const DB& db, const LIST& params, picture_representation_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<bytes_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to picture_representation_item"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_picture_representation_item>(const DB& db, const LIST& params, externally_defined_picture_representation_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<picture_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to externally_defined_picture_representation_item"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_representation_item>(const DB& db, const LIST& params, externally_defined_representation_item* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_string>(const DB& db, const LIST& params, externally_defined_string* in)
-{
-    size_t base = GenericFill(db, params, static_cast<externally_defined_representation_item*>(in));
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_symbol>(const DB& db, const LIST& params, externally_defined_symbol* in)
-{
-    size_t base = GenericFill(db, params, static_cast<externally_defined_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to externally_defined_symbol"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_terminator_symbol>(const DB& db, const LIST& params, externally_defined_terminator_symbol* in)
-{
-    size_t base = GenericFill(db, params, static_cast<externally_defined_symbol*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to externally_defined_terminator_symbol"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_text_font>(const DB& db, const LIST& params, externally_defined_text_font* in)
-{
-    size_t base = GenericFill(db, params, static_cast<externally_defined_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to externally_defined_text_font"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_tile>(const DB& db, const LIST& params, externally_defined_tile* in)
-{
-    size_t base = GenericFill(db, params, static_cast<externally_defined_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to externally_defined_tile"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_tile_style>(const DB& db, const LIST& params, externally_defined_tile_style* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<swept_area_solid>(const DB& db, const LIST& params, swept_area_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_model*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to swept_area_solid"); }    do { // convert the 'swept_area' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::swept_area_solid, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->swept_area, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to swept_area_solid to be a `curve_bounded_surface`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<extruded_area_solid>(const DB& db, const LIST& params, extruded_area_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<swept_area_solid*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to extruded_area_solid"); }    do { // convert the 'extruded_direction' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->extruded_direction, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to extruded_area_solid to be a `direction`")); }
-    } while (0);
-    do { // convert the 'depth' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->depth, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to extruded_area_solid to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<swept_face_solid>(const DB& db, const LIST& params, swept_face_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_model*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to swept_face_solid"); }    do { // convert the 'swept_face' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::swept_face_solid, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->swept_face, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to swept_face_solid to be a `face_surface`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<extruded_face_solid>(const DB& db, const LIST& params, extruded_face_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<swept_face_solid*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to extruded_face_solid"); }    do { // convert the 'extruded_direction' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::extruded_face_solid, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->extruded_direction, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to extruded_face_solid to be a `direction`")); }
-    } while (0);
-    do { // convert the 'depth' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::extruded_face_solid, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->depth, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to extruded_face_solid to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<extruded_face_solid_with_trim_conditions>(const DB& db, const LIST& params, extruded_face_solid_with_trim_conditions* in)
-{
-    size_t base = GenericFill(db, params, static_cast<extruded_face_solid*>(in));
-    if (params.GetSize() < 10) { throw STEP::TypeError("expected 10 arguments to extruded_face_solid_with_trim_conditions"); }    do { // convert the 'first_trim_condition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::extruded_face_solid_with_trim_conditions, 6>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->first_trim_condition, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to extruded_face_solid_with_trim_conditions to be a `trim_condition_select`")); }
-    } while (0);
-    do { // convert the 'second_trim_condition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::extruded_face_solid_with_trim_conditions, 6>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->second_trim_condition, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to extruded_face_solid_with_trim_conditions to be a `trim_condition_select`")); }
-    } while (0);
-    do { // convert the 'first_trim_intent' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::extruded_face_solid_with_trim_conditions, 6>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->first_trim_intent, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to extruded_face_solid_with_trim_conditions to be a `trim_intent`")); }
-    } while (0);
-    do { // convert the 'second_trim_intent' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::extruded_face_solid_with_trim_conditions, 6>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->second_trim_intent, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to extruded_face_solid_with_trim_conditions to be a `trim_intent`")); }
-    } while (0);
-    do { // convert the 'first_offset' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::extruded_face_solid_with_trim_conditions, 6>::aux_is_derived[4] = true; break; }
-        try { GenericConvert(in->first_offset, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to extruded_face_solid_with_trim_conditions to be a `non_negative_length_measure`")); }
-    } while (0);
-    do { // convert the 'second_offset' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::extruded_face_solid_with_trim_conditions, 6>::aux_is_derived[5] = true; break; }
-        try { GenericConvert(in->second_offset, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to extruded_face_solid_with_trim_conditions to be a `non_negative_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<extruded_face_solid_with_draft_angle>(const DB& db, const LIST& params, extruded_face_solid_with_draft_angle* in)
-{
-    size_t base = GenericFill(db, params, static_cast<extruded_face_solid_with_trim_conditions*>(in));
-    if (params.GetSize() < 11) { throw STEP::TypeError("expected 11 arguments to extruded_face_solid_with_draft_angle"); }    do { // convert the 'draft_angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->draft_angle, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to extruded_face_solid_with_draft_angle to be a `plane_angle_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<extruded_face_solid_with_multiple_draft_angles>(const DB& db, const LIST& params, extruded_face_solid_with_multiple_draft_angles* in)
-{
-    size_t base = GenericFill(db, params, static_cast<extruded_face_solid_with_trim_conditions*>(in));
-    if (params.GetSize() < 11) { throw STEP::TypeError("expected 11 arguments to extruded_face_solid_with_multiple_draft_angles"); }    do { // convert the 'draft_angles' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->draft_angles, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to extruded_face_solid_with_multiple_draft_angles to be a `LIST [2:?] OF plane_angle_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<face>(const DB& db, const LIST& params, face* in)
-{
-    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to face"); }    do { // convert the 'bounds' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::face, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->bounds, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to face to be a `SET [1:?] OF face_bound`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<face_based_surface_model>(const DB& db, const LIST& params, face_based_surface_model* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to face_based_surface_model"); }    do { // convert the 'fbsm_faces' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->fbsm_faces, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to face_based_surface_model to be a `SET [1:?] OF connected_face_set`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<face_bound>(const DB& db, const LIST& params, face_bound* in)
-{
-    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to face_bound"); }    do { // convert the 'bound' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::face_bound, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->bound, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to face_bound to be a `loop`")); }
-    } while (0);
-    do { // convert the 'orientation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::face_bound, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->orientation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to face_bound to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<face_outer_bound>(const DB& db, const LIST& params, face_outer_bound* in)
-{
-    size_t base = GenericFill(db, params, static_cast<face_bound*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to face_outer_bound"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<faceted_brep>(const DB& db, const LIST& params, faceted_brep* in)
-{
-    size_t base = GenericFill(db, params, static_cast<manifold_solid_brep*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to faceted_brep"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<faceted_brep_shape_representation>(const DB& db, const LIST& params, faceted_brep_shape_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to faceted_brep_shape_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<fill_area_style>(const DB& db, const LIST& params, fill_area_style* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to fill_area_style"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to fill_area_style to be a `label`")); }
-    } while (0);
-    do { // convert the 'fill_styles' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->fill_styles, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to fill_area_style to be a `SET [1:?] OF fill_style_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<fill_area_style_hatching>(const DB& db, const LIST& params, fill_area_style_hatching* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to fill_area_style_hatching"); }    do { // convert the 'hatch_line_appearance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->hatch_line_appearance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to fill_area_style_hatching to be a `curve_style`")); }
-    } while (0);
-    do { // convert the 'start_of_next_hatch_line' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->start_of_next_hatch_line, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to fill_area_style_hatching to be a `one_direction_repeat_factor`")); }
-    } while (0);
-    do { // convert the 'point_of_reference_hatch_line' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->point_of_reference_hatch_line, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to fill_area_style_hatching to be a `cartesian_point`")); }
-    } while (0);
-    do { // convert the 'pattern_start' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->pattern_start, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to fill_area_style_hatching to be a `cartesian_point`")); }
-    } while (0);
-    do { // convert the 'hatch_line_angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->hatch_line_angle, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to fill_area_style_hatching to be a `plane_angle_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<fill_area_style_tile_coloured_region>(const DB& db, const LIST& params, fill_area_style_tile_coloured_region* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to fill_area_style_tile_coloured_region"); }    do { // convert the 'closed_curve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->closed_curve, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to fill_area_style_tile_coloured_region to be a `curve_or_annotation_curve_occurrence`")); }
-    } while (0);
-    do { // convert the 'region_colour' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->region_colour, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to fill_area_style_tile_coloured_region to be a `colour`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<fill_area_style_tile_curve_with_style>(const DB& db, const LIST& params, fill_area_style_tile_curve_with_style* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to fill_area_style_tile_curve_with_style"); }    do { // convert the 'styled_curve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->styled_curve, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to fill_area_style_tile_curve_with_style to be a `annotation_curve_occurrence`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<fill_area_style_tile_symbol_with_style>(const DB& db, const LIST& params, fill_area_style_tile_symbol_with_style* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to fill_area_style_tile_symbol_with_style"); }    do { // convert the 'symbol' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->symbol, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to fill_area_style_tile_symbol_with_style to be a `annotation_symbol_occurrence`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<fill_area_style_tiles>(const DB& db, const LIST& params, fill_area_style_tiles* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to fill_area_style_tiles"); }    do { // convert the 'tiling_pattern' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->tiling_pattern, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to fill_area_style_tiles to be a `two_direction_repeat_factor`")); }
-    } while (0);
-    do { // convert the 'tiles' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->tiles, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to fill_area_style_tiles to be a `SET [1:?] OF fill_area_style_tile_shape_select`")); }
-    } while (0);
-    do { // convert the 'tiling_scale' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->tiling_scale, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to fill_area_style_tiles to be a `positive_ratio_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<shape_representation_relationship>(const DB& db, const LIST& params, shape_representation_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to shape_representation_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<flat_pattern_ply_representation_relationship>(const DB& db, const LIST& params, flat_pattern_ply_representation_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to flat_pattern_ply_representation_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<flatness_tolerance>(const DB& db, const LIST& params, flatness_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to flatness_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<force_measure_with_unit>(const DB& db, const LIST& params, force_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to force_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<force_unit>(const DB& db, const LIST& params, force_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to force_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<forward_chaining_rule>(const DB& db, const LIST& params, forward_chaining_rule* in)
-{
-    size_t base = GenericFill(db, params, static_cast<rule_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to forward_chaining_rule"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<forward_chaining_rule_premise>(const DB& db, const LIST& params, forward_chaining_rule_premise* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<frequency_measure_with_unit>(const DB& db, const LIST& params, frequency_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to frequency_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<frequency_unit>(const DB& db, const LIST& params, frequency_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to frequency_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<func>(const DB& db, const LIST& params, func* in)
-{
-    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to func"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<functional_breakdown_context>(const DB& db, const LIST& params, functional_breakdown_context* in)
-{
-    size_t base = GenericFill(db, params, static_cast<breakdown_context*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to functional_breakdown_context"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<functional_element_usage>(const DB& db, const LIST& params, functional_element_usage* in)
-{
-    size_t base = GenericFill(db, params, static_cast<breakdown_element_usage*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to functional_element_usage"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<general_material_property>(const DB& db, const LIST& params, general_material_property* in)
-{
-    size_t base = GenericFill(db, params, static_cast<general_property*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to general_material_property"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<simple_generic_expression>(const DB& db, const LIST& params, simple_generic_expression* in)
-{
-    size_t base = GenericFill(db, params, static_cast<generic_expression*>(in));
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<generic_literal>(const DB& db, const LIST& params, generic_literal* in)
-{
-    size_t base = GenericFill(db, params, static_cast<simple_generic_expression*>(in));
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<generic_variable>(const DB& db, const LIST& params, generic_variable* in)
-{
-    size_t base = GenericFill(db, params, static_cast<simple_generic_expression*>(in));
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<geometric_alignment>(const DB& db, const LIST& params, geometric_alignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_shape_aspect*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to geometric_alignment"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<geometric_set>(const DB& db, const LIST& params, geometric_set* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to geometric_set"); }    do { // convert the 'elements' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::geometric_set, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->elements, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to geometric_set to be a `SET [1:?] OF geometric_set_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<geometric_curve_set>(const DB& db, const LIST& params, geometric_curve_set* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_set*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to geometric_curve_set"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<geometric_intersection>(const DB& db, const LIST& params, geometric_intersection* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_shape_aspect*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to geometric_intersection"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<geometric_item_specific_usage>(const DB& db, const LIST& params, geometric_item_specific_usage* in)
-{
-    size_t base = GenericFill(db, params, static_cast<item_identified_representation_usage*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to geometric_item_specific_usage"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<geometric_model_element_relationship>(const DB& db, const LIST& params, geometric_model_element_relationship* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<representation_context>(const DB& db, const LIST& params, representation_context* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to representation_context"); }    do { // convert the 'context_identifier' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_context, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->context_identifier, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to representation_context to be a `identifier`")); }
-    } while (0);
-    do { // convert the 'context_type' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_context, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->context_type, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to representation_context to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<geometric_representation_context>(const DB& db, const LIST& params, geometric_representation_context* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_context*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to geometric_representation_context"); }    do { // convert the 'coordinate_space_dimension' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->coordinate_space_dimension, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to geometric_representation_context to be a `dimension_count`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<geometric_tolerance_with_defined_unit>(const DB& db, const LIST& params, geometric_tolerance_with_defined_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to geometric_tolerance_with_defined_unit"); }    do { // convert the 'unit_size' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->unit_size, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to geometric_tolerance_with_defined_unit to be a `measure_with_unit`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<geometrical_tolerance_callout>(const DB& db, const LIST& params, geometrical_tolerance_callout* in)
-{
-    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to geometrical_tolerance_callout"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<geometrically_bounded_2d_wireframe_representation>(const DB& db, const LIST& params, geometrically_bounded_2d_wireframe_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to geometrically_bounded_2d_wireframe_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<geometrically_bounded_surface_shape_representation>(const DB& db, const LIST& params, geometrically_bounded_surface_shape_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to geometrically_bounded_surface_shape_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<geometrically_bounded_wireframe_shape_representation>(const DB& db, const LIST& params, geometrically_bounded_wireframe_shape_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to geometrically_bounded_wireframe_shape_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<global_assignment>(const DB& db, const LIST& params, global_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_item_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to global_assignment"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<global_uncertainty_assigned_context>(const DB& db, const LIST& params, global_uncertainty_assigned_context* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_context*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to global_uncertainty_assigned_context"); }    do { // convert the 'uncertainty' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->uncertainty, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to global_uncertainty_assigned_context to be a `SET [1:?] OF uncertainty_measure_with_unit`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<global_unit_assigned_context>(const DB& db, const LIST& params, global_unit_assigned_context* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_context*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to global_unit_assigned_context"); }    do { // convert the 'units' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->units, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to global_unit_assigned_context to be a `SET [1:?] OF unit`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<ground_fact>(const DB& db, const LIST& params, ground_fact* in)
-{
-    size_t base = GenericFill(db, params, static_cast<atomic_formula*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to ground_fact"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<hardness_representation>(const DB& db, const LIST& params, hardness_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to hardness_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<hidden_element_over_riding_styled_item>(const DB& db, const LIST& params, hidden_element_over_riding_styled_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<context_dependent_over_riding_styled_item*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to hidden_element_over_riding_styled_item"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<hyperbola>(const DB& db, const LIST& params, hyperbola* in)
-{
-    size_t base = GenericFill(db, params, static_cast<conic*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to hyperbola"); }    do { // convert the 'semi_axis' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->semi_axis, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to hyperbola to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'semi_imag_axis' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->semi_imag_axis, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to hyperbola to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<illuminance_measure_with_unit>(const DB& db, const LIST& params, illuminance_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to illuminance_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<illuminance_unit>(const DB& db, const LIST& params, illuminance_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to illuminance_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<included_text_block>(const DB& db, const LIST& params, included_text_block* in)
-{
-    size_t base = GenericFill(db, params, static_cast<mapped_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to included_text_block"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<inclusion_product_concept_feature>(const DB& db, const LIST& params, inclusion_product_concept_feature* in)
-{
-    size_t base = GenericFill(db, params, static_cast<conditional_concept_feature*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to inclusion_product_concept_feature"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<user_selected_elements>(const DB& db, const LIST& params, user_selected_elements* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to user_selected_elements"); }    do { // convert the 'picked_items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::user_selected_elements, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->picked_items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to user_selected_elements to be a `SET [1:?] OF representation_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<indirectly_selected_elements>(const DB& db, const LIST& params, indirectly_selected_elements* in)
-{
-    size_t base = GenericFill(db, params, static_cast<user_selected_elements*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to indirectly_selected_elements"); }    do { // convert the 'indirectly_picked_items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->indirectly_picked_items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to indirectly_selected_elements to be a `SET [1:?] OF representation_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<indirectly_selected_shape_elements>(const DB& db, const LIST& params, indirectly_selected_shape_elements* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<inductance_measure_with_unit>(const DB& db, const LIST& params, inductance_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to inductance_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<inductance_unit>(const DB& db, const LIST& params, inductance_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to inductance_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<information_right>(const DB& db, const LIST& params, information_right* in)
-{
-    size_t base = GenericFill(db, params, static_cast<action_method*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to information_right"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<information_usage_right>(const DB& db, const LIST& params, information_usage_right* in)
-{
-    size_t base = GenericFill(db, params, static_cast<action_method*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to information_usage_right"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<instance_usage_context_assignment>(const DB& db, const LIST& params, instance_usage_context_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition_context*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to instance_usage_context_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to instance_usage_context_assignment to be a `SET [1:?] OF instance_usage_context_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<instanced_feature>(const DB& db, const LIST& params, instanced_feature* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<literal_number>(const DB& db, const LIST& params, literal_number* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to literal_number"); }    do { // convert the 'the_value' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::literal_number, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->the_value, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to literal_number to be a `NUMBER`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<int_literal>(const DB& db, const LIST& params, int_literal* in)
-{
-    size_t base = GenericFill(db, params, static_cast<literal_number*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to int_literal"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<integer_representation_item>(const DB& db, const LIST& params, integer_representation_item* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_curve>(const DB& db, const LIST& params, surface_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<curve*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to surface_curve"); }    do { // convert the 'curve_3d' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_curve, 3>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->curve_3d, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to surface_curve to be a `curve`")); }
-    } while (0);
-    do { // convert the 'associated_geometry' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_curve, 3>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->associated_geometry, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to surface_curve to be a `LIST [1:2] OF pcurve_or_surface`")); }
-    } while (0);
-    do { // convert the 'master_representation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_curve, 3>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->master_representation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to surface_curve to be a `preferred_surface_curve_representation`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<intersection_curve>(const DB& db, const LIST& params, intersection_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<surface_curve*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to intersection_curve"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<interval_expression>(const DB& db, const LIST& params, interval_expression* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<iso4217_currency>(const DB& db, const LIST& params, iso4217_currency* in)
-{
-    size_t base = GenericFill(db, params, static_cast<currency*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to iso4217_currency"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<known_source>(const DB& db, const LIST& params, known_source* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<laid_defined_transformation>(const DB& db, const LIST& params, laid_defined_transformation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<transformation_with_derived_angle*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to laid_defined_transformation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<language>(const DB& db, const LIST& params, language* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to language"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<leader_curve>(const DB& db, const LIST& params, leader_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<annotation_curve_occurrence*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to leader_curve"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<leader_directed_callout>(const DB& db, const LIST& params, leader_directed_callout* in)
-{
-    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to leader_directed_callout"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<leader_directed_dimension>(const DB& db, const LIST& params, leader_directed_dimension* in)
-{
-    size_t base = GenericFill(db, params, static_cast<leader_directed_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to leader_directed_dimension"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<leader_terminator>(const DB& db, const LIST& params, leader_terminator* in)
-{
-    size_t base = GenericFill(db, params, static_cast<terminator_symbol*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to leader_terminator"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<length_measure_with_unit>(const DB& db, const LIST& params, length_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to length_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<length_unit>(const DB& db, const LIST& params, length_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to length_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<light_source>(const DB& db, const LIST& params, light_source* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to light_source"); }    do { // convert the 'light_colour' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::light_source, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->light_colour, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to light_source to be a `colour`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<light_source_ambient>(const DB& db, const LIST& params, light_source_ambient* in)
-{
-    size_t base = GenericFill(db, params, static_cast<light_source*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to light_source_ambient"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<light_source_directional>(const DB& db, const LIST& params, light_source_directional* in)
-{
-    size_t base = GenericFill(db, params, static_cast<light_source*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to light_source_directional"); }    do { // convert the 'orientation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->orientation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to light_source_directional to be a `direction`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<light_source_positional>(const DB& db, const LIST& params, light_source_positional* in)
-{
-    size_t base = GenericFill(db, params, static_cast<light_source*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to light_source_positional"); }    do { // convert the 'position' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->position, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to light_source_positional to be a `cartesian_point`")); }
-    } while (0);
-    do { // convert the 'constant_attenuation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->constant_attenuation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to light_source_positional to be a `REAL`")); }
-    } while (0);
-    do { // convert the 'distance_attenuation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->distance_attenuation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to light_source_positional to be a `REAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<light_source_spot>(const DB& db, const LIST& params, light_source_spot* in)
-{
-    size_t base = GenericFill(db, params, static_cast<light_source*>(in));
-    if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to light_source_spot"); }    do { // convert the 'position' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->position, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to light_source_spot to be a `cartesian_point`")); }
-    } while (0);
-    do { // convert the 'orientation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->orientation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to light_source_spot to be a `direction`")); }
-    } while (0);
-    do { // convert the 'concentration_exponent' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->concentration_exponent, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to light_source_spot to be a `REAL`")); }
-    } while (0);
-    do { // convert the 'constant_attenuation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->constant_attenuation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to light_source_spot to be a `REAL`")); }
-    } while (0);
-    do { // convert the 'distance_attenuation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->distance_attenuation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to light_source_spot to be a `REAL`")); }
-    } while (0);
-    do { // convert the 'spread_angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->spread_angle, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to light_source_spot to be a `positive_plane_angle_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<line>(const DB& db, const LIST& params, line* in)
-{
-    size_t base = GenericFill(db, params, static_cast<curve*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to line"); }    do { // convert the 'pnt' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->pnt, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to line to be a `cartesian_point`")); }
-    } while (0);
-    do { // convert the 'dir' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->dir, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to line to be a `vector`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<line_profile_tolerance>(const DB& db, const LIST& params, line_profile_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to line_profile_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<linear_dimension>(const DB& db, const LIST& params, linear_dimension* in)
-{
-    size_t base = GenericFill(db, params, static_cast<dimension_curve_directed_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to linear_dimension"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<simple_clause>(const DB& db, const LIST& params, simple_clause* in)
-{
-    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to simple_clause"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<literal_conjunction>(const DB& db, const LIST& params, literal_conjunction* in)
-{
-    size_t base = GenericFill(db, params, static_cast<simple_clause*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to literal_conjunction"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<literal_disjunction>(const DB& db, const LIST& params, literal_disjunction* in)
-{
-    size_t base = GenericFill(db, params, static_cast<simple_clause*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to literal_disjunction"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<logical_literal>(const DB& db, const LIST& params, logical_literal* in)
-{
-    size_t base = GenericFill(db, params, static_cast<generic_literal*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to logical_literal"); }    do { // convert the 'lit_value' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->lit_value, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to logical_literal to be a `LOGICAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<logical_representation_item>(const DB& db, const LIST& params, logical_representation_item* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<loop>(const DB& db, const LIST& params, loop* in)
-{
-    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to loop"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<loss_tangent_measure_with_unit>(const DB& db, const LIST& params, loss_tangent_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<ratio_measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to loss_tangent_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<lot_effectivity>(const DB& db, const LIST& params, lot_effectivity* in)
-{
-    size_t base = GenericFill(db, params, static_cast<effectivity*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to lot_effectivity"); }    do { // convert the 'effectivity_lot_id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->effectivity_lot_id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to lot_effectivity to be a `identifier`")); }
-    } while (0);
-    do { // convert the 'effectivity_lot_size' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->effectivity_lot_size, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to lot_effectivity to be a `measure_with_unit`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<luminous_flux_measure_with_unit>(const DB& db, const LIST& params, luminous_flux_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to luminous_flux_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<luminous_flux_unit>(const DB& db, const LIST& params, luminous_flux_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to luminous_flux_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<luminous_intensity_measure_with_unit>(const DB& db, const LIST& params, luminous_intensity_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to luminous_intensity_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<luminous_intensity_unit>(const DB& db, const LIST& params, luminous_intensity_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to luminous_intensity_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<magnetic_flux_density_measure_with_unit>(const DB& db, const LIST& params, magnetic_flux_density_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to magnetic_flux_density_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<magnetic_flux_density_unit>(const DB& db, const LIST& params, magnetic_flux_density_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to magnetic_flux_density_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<magnetic_flux_measure_with_unit>(const DB& db, const LIST& params, magnetic_flux_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to magnetic_flux_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<magnetic_flux_unit>(const DB& db, const LIST& params, magnetic_flux_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to magnetic_flux_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<make_from_usage_option>(const DB& db, const LIST& params, make_from_usage_option* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition_usage*>(in));
-    if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to make_from_usage_option"); }    do { // convert the 'ranking' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->ranking, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to make_from_usage_option to be a `INTEGER`")); }
-    } while (0);
-    do { // convert the 'ranking_rationale' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->ranking_rationale, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to make_from_usage_option to be a `text`")); }
-    } while (0);
-    do { // convert the 'quantity' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->quantity, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to make_from_usage_option to be a `measure_with_unit`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<manifold_subsurface_shape_representation>(const DB& db, const LIST& params, manifold_subsurface_shape_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to manifold_subsurface_shape_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<manifold_surface_shape_representation>(const DB& db, const LIST& params, manifold_surface_shape_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to manifold_surface_shape_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<mass_measure_with_unit>(const DB& db, const LIST& params, mass_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to mass_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<mass_unit>(const DB& db, const LIST& params, mass_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to mass_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<material_property>(const DB& db, const LIST& params, material_property* in)
-{
-    size_t base = GenericFill(db, params, static_cast<property_definition*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to material_property"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<property_definition_representation>(const DB& db, const LIST& params, property_definition_representation* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to property_definition_representation"); }    do { // convert the 'definition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::property_definition_representation, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->definition, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to property_definition_representation to be a `represented_definition`")); }
-    } while (0);
-    do { // convert the 'used_representation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::property_definition_representation, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->used_representation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to property_definition_representation to be a `representation`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<material_property_representation>(const DB& db, const LIST& params, material_property_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<property_definition_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to material_property_representation"); }    do { // convert the 'dependent_environment' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->dependent_environment, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to material_property_representation to be a `data_environment`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<measure_representation_item>(const DB& db, const LIST& params, measure_representation_item* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_context>(const DB& db, const LIST& params, product_context* in)
-{
-    size_t base = GenericFill(db, params, static_cast<application_context_element*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to product_context"); }    do { // convert the 'discipline_type' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_context, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->discipline_type, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to product_context to be a `label`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<mechanical_context>(const DB& db, const LIST& params, mechanical_context* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_context*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to mechanical_context"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<mechanical_design_and_draughting_relationship>(const DB& db, const LIST& params, mechanical_design_and_draughting_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<definitional_representation_relationship_with_same_context*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to mechanical_design_and_draughting_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<mechanical_design_geometric_presentation_area>(const DB& db, const LIST& params, mechanical_design_geometric_presentation_area* in)
-{
-    size_t base = GenericFill(db, params, static_cast<presentation_area*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to mechanical_design_geometric_presentation_area"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<mechanical_design_geometric_presentation_representation>(const DB& db, const LIST& params, mechanical_design_geometric_presentation_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to mechanical_design_geometric_presentation_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<mechanical_design_presentation_representation_with_draughting>(const DB& db, const LIST& params, mechanical_design_presentation_representation_with_draughting* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to mechanical_design_presentation_representation_with_draughting"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<mechanical_design_shaded_presentation_area>(const DB& db, const LIST& params, mechanical_design_shaded_presentation_area* in)
-{
-    size_t base = GenericFill(db, params, static_cast<presentation_area*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to mechanical_design_shaded_presentation_area"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<mechanical_design_shaded_presentation_representation>(const DB& db, const LIST& params, mechanical_design_shaded_presentation_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to mechanical_design_shaded_presentation_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<min_and_major_ply_orientation_basis>(const DB& db, const LIST& params, min_and_major_ply_orientation_basis* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<modified_geometric_tolerance>(const DB& db, const LIST& params, modified_geometric_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to modified_geometric_tolerance"); }    do { // convert the 'modifier' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->modifier, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to modified_geometric_tolerance to be a `limit_condition`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<modified_solid_with_placed_configuration>(const DB& db, const LIST& params, modified_solid_with_placed_configuration* in)
-{
-    size_t base = GenericFill(db, params, static_cast<modified_solid*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to modified_solid_with_placed_configuration"); }    do { // convert the 'placing' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::modified_solid_with_placed_configuration, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->placing, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to modified_solid_with_placed_configuration to be a `axis2_placement_3d`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<moments_of_inertia_representation>(const DB& db, const LIST& params, moments_of_inertia_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to moments_of_inertia_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<multi_language_attribute_assignment>(const DB& db, const LIST& params, multi_language_attribute_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<attribute_value_assignment*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to multi_language_attribute_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to multi_language_attribute_assignment to be a `SET [1:?] OF multi_language_attribute_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<multiple_arity_boolean_expression>(const DB& db, const LIST& params, multiple_arity_boolean_expression* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<multiple_arity_generic_expression>(const DB& db, const LIST& params, multiple_arity_generic_expression* in)
-{
-    size_t base = GenericFill(db, params, static_cast<generic_expression*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to multiple_arity_generic_expression"); }    do { // convert the 'operands' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->operands, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to multiple_arity_generic_expression to be a `LIST [2:?] OF generic_expression`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<multiple_arity_numeric_expression>(const DB& db, const LIST& params, multiple_arity_numeric_expression* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<next_assembly_usage_occurrence>(const DB& db, const LIST& params, next_assembly_usage_occurrence* in)
-{
-    size_t base = GenericFill(db, params, static_cast<assembly_component_usage*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to next_assembly_usage_occurrence"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<non_manifold_surface_shape_representation>(const DB& db, const LIST& params, non_manifold_surface_shape_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to non_manifold_surface_shape_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<null_representation_item>(const DB& db, const LIST& params, null_representation_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to null_representation_item"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<numeric_expression>(const DB& db, const LIST& params, numeric_expression* in)
-{
-    size_t base = GenericFill(db, params, static_cast<expression*>(in));
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<offset_curve_2d>(const DB& db, const LIST& params, offset_curve_2d* in)
-{
-    size_t base = GenericFill(db, params, static_cast<curve*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to offset_curve_2d"); }    do { // convert the 'basis_curve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->basis_curve, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to offset_curve_2d to be a `curve`")); }
-    } while (0);
-    do { // convert the 'distance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->distance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to offset_curve_2d to be a `length_measure`")); }
-    } while (0);
-    do { // convert the 'self_intersect' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->self_intersect, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to offset_curve_2d to be a `LOGICAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<offset_curve_3d>(const DB& db, const LIST& params, offset_curve_3d* in)
-{
-    size_t base = GenericFill(db, params, static_cast<curve*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to offset_curve_3d"); }    do { // convert the 'basis_curve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->basis_curve, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to offset_curve_3d to be a `curve`")); }
-    } while (0);
-    do { // convert the 'distance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->distance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to offset_curve_3d to be a `length_measure`")); }
-    } while (0);
-    do { // convert the 'self_intersect' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->self_intersect, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to offset_curve_3d to be a `LOGICAL`")); }
-    } while (0);
-    do { // convert the 'ref_direction' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->ref_direction, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to offset_curve_3d to be a `direction`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<offset_surface>(const DB& db, const LIST& params, offset_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<surface*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to offset_surface"); }    do { // convert the 'basis_surface' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->basis_surface, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to offset_surface to be a `surface`")); }
-    } while (0);
-    do { // convert the 'distance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->distance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to offset_surface to be a `length_measure`")); }
-    } while (0);
-    do { // convert the 'self_intersect' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->self_intersect, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to offset_surface to be a `LOGICAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<one_direction_repeat_factor>(const DB& db, const LIST& params, one_direction_repeat_factor* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to one_direction_repeat_factor"); }    do { // convert the 'repeat_factor' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::one_direction_repeat_factor, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->repeat_factor, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to one_direction_repeat_factor to be a `vector`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<open_shell>(const DB& db, const LIST& params, open_shell* in)
-{
-    size_t base = GenericFill(db, params, static_cast<connected_face_set*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to open_shell"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<ordinal_date>(const DB& db, const LIST& params, ordinal_date* in)
-{
-    size_t base = GenericFill(db, params, static_cast<date*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to ordinal_date"); }    do { // convert the 'day_component' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->day_component, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to ordinal_date to be a `day_in_year_number`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<projection_directed_callout>(const DB& db, const LIST& params, projection_directed_callout* in)
-{
-    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to projection_directed_callout"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<ordinate_dimension>(const DB& db, const LIST& params, ordinate_dimension* in)
-{
-    size_t base = GenericFill(db, params, static_cast<projection_directed_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to ordinate_dimension"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<organizational_address>(const DB& db, const LIST& params, organizational_address* in)
-{
-    size_t base = GenericFill(db, params, static_cast<address*>(in));
-    if (params.GetSize() < 14) { throw STEP::TypeError("expected 14 arguments to organizational_address"); }    do { // convert the 'organizations' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->organizations, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 12 to organizational_address to be a `SET [1:?] OF organization`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 13 to organizational_address to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<oriented_closed_shell>(const DB& db, const LIST& params, oriented_closed_shell* in)
-{
-    size_t base = GenericFill(db, params, static_cast<closed_shell*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to oriented_closed_shell"); }    do { // convert the 'closed_shell_element' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->closed_shell_element, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to oriented_closed_shell to be a `closed_shell`")); }
-    } while (0);
-    do { // convert the 'orientation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->orientation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to oriented_closed_shell to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<oriented_edge>(const DB& db, const LIST& params, oriented_edge* in)
-{
-    size_t base = GenericFill(db, params, static_cast<edge*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to oriented_edge"); }    do { // convert the 'edge_element' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->edge_element, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to oriented_edge to be a `edge`")); }
-    } while (0);
-    do { // convert the 'orientation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->orientation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to oriented_edge to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<oriented_face>(const DB& db, const LIST& params, oriented_face* in)
-{
-    size_t base = GenericFill(db, params, static_cast<face*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to oriented_face"); }    do { // convert the 'face_element' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->face_element, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to oriented_face to be a `face`")); }
-    } while (0);
-    do { // convert the 'orientation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->orientation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to oriented_face to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<oriented_open_shell>(const DB& db, const LIST& params, oriented_open_shell* in)
-{
-    size_t base = GenericFill(db, params, static_cast<open_shell*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to oriented_open_shell"); }    do { // convert the 'open_shell_element' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->open_shell_element, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to oriented_open_shell to be a `open_shell`")); }
-    } while (0);
-    do { // convert the 'orientation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->orientation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to oriented_open_shell to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<path>(const DB& db, const LIST& params, path* in)
-{
-    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to path"); }    do { // convert the 'edge_list' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::path, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->edge_list, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to path to be a `LIST [1:?] OF oriented_edge`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<oriented_path>(const DB& db, const LIST& params, oriented_path* in)
-{
-    size_t base = GenericFill(db, params, static_cast<path*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to oriented_path"); }    do { // convert the 'path_element' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->path_element, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to oriented_path to be a `path`")); }
-    } while (0);
-    do { // convert the 'orientation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->orientation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to oriented_path to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<oriented_surface>(const DB& db, const LIST& params, oriented_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<surface*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to oriented_surface"); }    do { // convert the 'orientation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->orientation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to oriented_surface to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<outer_boundary_curve>(const DB& db, const LIST& params, outer_boundary_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<boundary_curve*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to outer_boundary_curve"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<package_product_concept_feature>(const DB& db, const LIST& params, package_product_concept_feature* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_concept_feature*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to package_product_concept_feature"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<parabola>(const DB& db, const LIST& params, parabola* in)
-{
-    size_t base = GenericFill(db, params, static_cast<conic*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to parabola"); }    do { // convert the 'focal_dist' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->focal_dist, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to parabola to be a `length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<parallel_offset>(const DB& db, const LIST& params, parallel_offset* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_shape_aspect*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to parallel_offset"); }    do { // convert the 'offset' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->offset, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to parallel_offset to be a `measure_with_unit`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<parallelism_tolerance>(const DB& db, const LIST& params, parallelism_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance_with_datum_reference*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to parallelism_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<parametric_representation_context>(const DB& db, const LIST& params, parametric_representation_context* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_context*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to parametric_representation_context"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<partial_document_with_structured_text_representation_assignment>(const DB& db, const LIST& params, partial_document_with_structured_text_representation_assignment* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pcurve>(const DB& db, const LIST& params, pcurve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<curve*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to pcurve"); }    do { // convert the 'basis_surface' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->basis_surface, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to pcurve to be a `surface`")); }
-    } while (0);
-    do { // convert the 'reference_to_curve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->reference_to_curve, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to pcurve to be a `definitional_representation`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<percentage_laminate_definition>(const DB& db, const LIST& params, percentage_laminate_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to percentage_laminate_definition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<zone_structural_makeup>(const DB& db, const LIST& params, zone_structural_makeup* in)
-{
-    size_t base = GenericFill(db, params, static_cast<laminate_table*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to zone_structural_makeup"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<percentage_laminate_table>(const DB& db, const LIST& params, percentage_laminate_table* in)
-{
-    size_t base = GenericFill(db, params, static_cast<zone_structural_makeup*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to percentage_laminate_table"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<percentage_ply_definition>(const DB& db, const LIST& params, percentage_ply_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to percentage_ply_definition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<perpendicular_to>(const DB& db, const LIST& params, perpendicular_to* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_shape_aspect*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to perpendicular_to"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<perpendicularity_tolerance>(const DB& db, const LIST& params, perpendicularity_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance_with_datum_reference*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to perpendicularity_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<person_and_organization_address>(const DB& db, const LIST& params, person_and_organization_address* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<personal_address>(const DB& db, const LIST& params, personal_address* in)
-{
-    size_t base = GenericFill(db, params, static_cast<address*>(in));
-    if (params.GetSize() < 14) { throw STEP::TypeError("expected 14 arguments to personal_address"); }    do { // convert the 'people' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->people, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 12 to personal_address to be a `SET [1:?] OF person`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 13 to personal_address to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<physical_breakdown_context>(const DB& db, const LIST& params, physical_breakdown_context* in)
-{
-    size_t base = GenericFill(db, params, static_cast<breakdown_context*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to physical_breakdown_context"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<physical_element_usage>(const DB& db, const LIST& params, physical_element_usage* in)
-{
-    size_t base = GenericFill(db, params, static_cast<breakdown_element_usage*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to physical_element_usage"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<presentation_view>(const DB& db, const LIST& params, presentation_view* in)
-{
-    size_t base = GenericFill(db, params, static_cast<presentation_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to presentation_view"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<picture_representation>(const DB& db, const LIST& params, picture_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<presentation_view*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to picture_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<placed_datum_target_feature>(const DB& db, const LIST& params, placed_datum_target_feature* in)
-{
-    size_t base = GenericFill(db, params, static_cast<datum_target*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to placed_datum_target_feature"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<placed_feature>(const DB& db, const LIST& params, placed_feature* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_aspect*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to placed_feature"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<planar_extent>(const DB& db, const LIST& params, planar_extent* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to planar_extent"); }    do { // convert the 'size_in_x' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::planar_extent, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->size_in_x, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to planar_extent to be a `length_measure`")); }
-    } while (0);
-    do { // convert the 'size_in_y' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::planar_extent, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->size_in_y, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to planar_extent to be a `length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<planar_box>(const DB& db, const LIST& params, planar_box* in)
-{
-    size_t base = GenericFill(db, params, static_cast<planar_extent*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to planar_box"); }    do { // convert the 'placement' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->placement, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to planar_box to be a `axis2_placement`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<plane>(const DB& db, const LIST& params, plane* in)
-{
-    size_t base = GenericFill(db, params, static_cast<elementary_surface*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to plane"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<plane_angle_measure_with_unit>(const DB& db, const LIST& params, plane_angle_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to plane_angle_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<plane_angle_unit>(const DB& db, const LIST& params, plane_angle_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to plane_angle_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<ply_laminate_definition>(const DB& db, const LIST& params, ply_laminate_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to ply_laminate_definition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<ply_laminate_sequence_definition>(const DB& db, const LIST& params, ply_laminate_sequence_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to ply_laminate_sequence_definition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<ply_laminate_table>(const DB& db, const LIST& params, ply_laminate_table* in)
-{
-    size_t base = GenericFill(db, params, static_cast<part_laminate_table*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to ply_laminate_table"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<point_and_vector>(const DB& db, const LIST& params, point_and_vector* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<point_on_curve>(const DB& db, const LIST& params, point_on_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<point*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to point_on_curve"); }    do { // convert the 'basis_curve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->basis_curve, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to point_on_curve to be a `curve`")); }
-    } while (0);
-    do { // convert the 'point_parameter' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->point_parameter, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to point_on_curve to be a `parameter_value`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<point_on_surface>(const DB& db, const LIST& params, point_on_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<point*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to point_on_surface"); }    do { // convert the 'basis_surface' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->basis_surface, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to point_on_surface to be a `surface`")); }
-    } while (0);
-    do { // convert the 'point_parameter_u' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->point_parameter_u, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to point_on_surface to be a `parameter_value`")); }
-    } while (0);
-    do { // convert the 'point_parameter_v' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->point_parameter_v, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to point_on_surface to be a `parameter_value`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<point_path>(const DB& db, const LIST& params, point_path* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<point_replica>(const DB& db, const LIST& params, point_replica* in)
-{
-    size_t base = GenericFill(db, params, static_cast<point*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to point_replica"); }    do { // convert the 'parent_pt' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->parent_pt, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to point_replica to be a `point`")); }
-    } while (0);
-    do { // convert the 'transformation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->transformation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to point_replica to be a `cartesian_transformation_operator`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<point_style>(const DB& db, const LIST& params, point_style* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to point_style"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to point_style to be a `label`")); }
-    } while (0);
-    do { // convert the 'marker' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->marker, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to point_style to be a `marker_select`")); }
-    } while (0);
-    do { // convert the 'marker_size' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->marker_size, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to point_style to be a `size_select`")); }
-    } while (0);
-    do { // convert the 'marker_colour' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->marker_colour, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to point_style to be a `colour`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<polar_complex_number_literal>(const DB& db, const LIST& params, polar_complex_number_literal* in)
-{
-    size_t base = GenericFill(db, params, static_cast<generic_literal*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to polar_complex_number_literal"); }    do { // convert the 'radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::polar_complex_number_literal, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to polar_complex_number_literal to be a `REAL`")); }
-    } while (0);
-    do { // convert the 'angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::polar_complex_number_literal, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->angle, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to polar_complex_number_literal to be a `REAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<poly_loop>(const DB& db, const LIST& params, poly_loop* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to poly_loop"); }    do { // convert the 'polygon' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->polygon, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to poly_loop to be a `LIST [3:?] OF cartesian_point`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<polyline>(const DB& db, const LIST& params, polyline* in)
-{
-    size_t base = GenericFill(db, params, static_cast<bounded_curve*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to polyline"); }    do { // convert the 'points' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->points, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to polyline to be a `LIST [2:?] OF cartesian_point`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<position_tolerance>(const DB& db, const LIST& params, position_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to position_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<positioned_sketch>(const DB& db, const LIST& params, positioned_sketch* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to positioned_sketch"); }    do { // convert the 'sketch_basis' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->sketch_basis, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to positioned_sketch to be a `sketch_basis_select`")); }
-    } while (0);
-    do { // convert the 'auxiliary_elements' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->auxiliary_elements, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to positioned_sketch to be a `SET [0:?] OF auxiliary_geometric_representation_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<power_measure_with_unit>(const DB& db, const LIST& params, power_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to power_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<power_unit>(const DB& db, const LIST& params, power_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to power_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pre_defined_symbol>(const DB& db, const LIST& params, pre_defined_symbol* in)
-{
-    size_t base = GenericFill(db, params, static_cast<pre_defined_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_symbol"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pre_defined_dimension_symbol>(const DB& db, const LIST& params, pre_defined_dimension_symbol* in)
-{
-    size_t base = GenericFill(db, params, static_cast<pre_defined_symbol*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_dimension_symbol"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pre_defined_geometrical_tolerance_symbol>(const DB& db, const LIST& params, pre_defined_geometrical_tolerance_symbol* in)
-{
-    size_t base = GenericFill(db, params, static_cast<pre_defined_symbol*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_geometrical_tolerance_symbol"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pre_defined_marker>(const DB& db, const LIST& params, pre_defined_marker* in)
-{
-    size_t base = GenericFill(db, params, static_cast<pre_defined_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_marker"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pre_defined_point_marker_symbol>(const DB& db, const LIST& params, pre_defined_point_marker_symbol* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pre_defined_surface_condition_symbol>(const DB& db, const LIST& params, pre_defined_surface_condition_symbol* in)
-{
-    size_t base = GenericFill(db, params, static_cast<pre_defined_symbol*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_surface_condition_symbol"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pre_defined_surface_side_style>(const DB& db, const LIST& params, pre_defined_surface_side_style* in)
-{
-    size_t base = GenericFill(db, params, static_cast<pre_defined_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_surface_side_style"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pre_defined_terminator_symbol>(const DB& db, const LIST& params, pre_defined_terminator_symbol* in)
-{
-    size_t base = GenericFill(db, params, static_cast<pre_defined_symbol*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_terminator_symbol"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pre_defined_tile>(const DB& db, const LIST& params, pre_defined_tile* in)
-{
-    size_t base = GenericFill(db, params, static_cast<pre_defined_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_tile"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<predefined_picture_representation_item>(const DB& db, const LIST& params, predefined_picture_representation_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<picture_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to predefined_picture_representation_item"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<presentation_style_assignment>(const DB& db, const LIST& params, presentation_style_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to presentation_style_assignment"); }    do { // convert the 'styles' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::presentation_style_assignment, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->styles, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to presentation_style_assignment to be a `SET [1:?] OF presentation_style_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<presentation_style_by_context>(const DB& db, const LIST& params, presentation_style_by_context* in)
-{
-    size_t base = GenericFill(db, params, static_cast<presentation_style_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to presentation_style_by_context"); }    do { // convert the 'style_context' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->style_context, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to presentation_style_by_context to be a `style_context_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pressure_measure_with_unit>(const DB& db, const LIST& params, pressure_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to pressure_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pressure_unit>(const DB& db, const LIST& params, pressure_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pressure_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<procedural_representation>(const DB& db, const LIST& params, procedural_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to procedural_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<procedural_representation_sequence>(const DB& db, const LIST& params, procedural_representation_sequence* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to procedural_representation_sequence"); }    do { // convert the 'elements' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->elements, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to procedural_representation_sequence to be a `LIST [1:?] OF representation_item`")); }
-    } while (0);
-    do { // convert the 'suppressed_items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->suppressed_items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to procedural_representation_sequence to be a `SET [0:?] OF representation_item`")); }
-    } while (0);
-    do { // convert the 'rationale' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->rationale, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to procedural_representation_sequence to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<procedural_shape_representation>(const DB& db, const LIST& params, procedural_shape_representation* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<procedural_shape_representation_sequence>(const DB& db, const LIST& params, procedural_shape_representation_sequence* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_category>(const DB& db, const LIST& params, product_category* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to product_category"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_category, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to product_category to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_category, 2>::aux_is_derived[1] = true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to product_category to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_class>(const DB& db, const LIST& params, product_class* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_concept_context>(const DB& db, const LIST& params, product_concept_context* in)
-{
-    size_t base = GenericFill(db, params, static_cast<application_context_element*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to product_concept_context"); }    do { // convert the 'market_segment_type' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->market_segment_type, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to product_concept_context to be a `label`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_concept_feature_category_usage>(const DB& db, const LIST& params, product_concept_feature_category_usage* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to product_concept_feature_category_usage"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to product_concept_feature_category_usage to be a `SET [1:?] OF category_usage_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_definition_element_relationship>(const DB& db, const LIST& params, product_definition_element_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to product_definition_element_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_definition_formation>(const DB& db, const LIST& params, product_definition_formation* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to product_definition_formation"); }    do { // convert the 'id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_formation, 3>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to product_definition_formation to be a `identifier`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_formation, 3>::aux_is_derived[1] = true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to product_definition_formation to be a `text`")); }
-    } while (0);
-    do { // convert the 'of_product' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_formation, 3>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->of_product, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to product_definition_formation to be a `product`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_definition_formation_with_specified_source>(const DB& db, const LIST& params, product_definition_formation_with_specified_source* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition_formation*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to product_definition_formation_with_specified_source"); }    do { // convert the 'make_or_buy' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->make_or_buy, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to product_definition_formation_with_specified_source to be a `source`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_definition_group_assignment>(const DB& db, const LIST& params, product_definition_group_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to product_definition_group_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to product_definition_group_assignment to be a `SET [1:1] OF product_definition_or_product_definition_relationship`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_definition_shape>(const DB& db, const LIST& params, product_definition_shape* in)
-{
-    size_t base = GenericFill(db, params, static_cast<property_definition*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to product_definition_shape"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_definition_with_associated_documents>(const DB& db, const LIST& params, product_definition_with_associated_documents* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to product_definition_with_associated_documents"); }    do { // convert the 'documentation_ids' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->documentation_ids, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to product_definition_with_associated_documents to be a `SET [1:?] OF document`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_identification>(const DB& db, const LIST& params, product_identification* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_material_composition_relationship>(const DB& db, const LIST& params, product_material_composition_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition_relationship*>(in));
-    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to product_material_composition_relationship"); }    do { // convert the 'class' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->class_, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to product_material_composition_relationship to be a `label`")); }
-    } while (0);
-    do { // convert the 'constituent_amount' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->constituent_amount, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to product_material_composition_relationship to be a `SET [1:?] OF characterized_product_composition_value`")); }
-    } while (0);
-    do { // convert the 'composition_basis' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->composition_basis, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to product_material_composition_relationship to be a `label`")); }
-    } while (0);
-    do { // convert the 'determination_method' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->determination_method, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to product_material_composition_relationship to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_related_product_category>(const DB& db, const LIST& params, product_related_product_category* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_category*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to product_related_product_category"); }    do { // convert the 'products' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->products, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to product_related_product_category to be a `SET [1:?] OF product`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_specification>(const DB& db, const LIST& params, product_specification* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<tolerance_zone_definition>(const DB& db, const LIST& params, tolerance_zone_definition* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to tolerance_zone_definition"); }    do { // convert the 'zone' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::tolerance_zone_definition, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->zone, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to tolerance_zone_definition to be a `tolerance_zone`")); }
-    } while (0);
-    do { // convert the 'boundaries' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::tolerance_zone_definition, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->boundaries, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to tolerance_zone_definition to be a `SET [1:?] OF shape_aspect`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<projected_zone_definition>(const DB& db, const LIST& params, projected_zone_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<tolerance_zone_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to projected_zone_definition"); }    do { // convert the 'projection_end' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->projection_end, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to projected_zone_definition to be a `shape_aspect`")); }
-    } while (0);
-    do { // convert the 'projected_length' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->projected_length, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to projected_zone_definition to be a `measure_with_unit`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<projection_curve>(const DB& db, const LIST& params, projection_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<annotation_curve_occurrence*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to projection_curve"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<promissory_usage_occurrence>(const DB& db, const LIST& params, promissory_usage_occurrence* in)
-{
-    size_t base = GenericFill(db, params, static_cast<assembly_component_usage*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to promissory_usage_occurrence"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<qualified_representation_item>(const DB& db, const LIST& params, qualified_representation_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to qualified_representation_item"); }    do { // convert the 'qualifiers' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->qualifiers, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to qualified_representation_item to be a `SET [1:?] OF value_qualifier`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<qualitative_uncertainty>(const DB& db, const LIST& params, qualitative_uncertainty* in)
-{
-    size_t base = GenericFill(db, params, static_cast<uncertainty_qualifier*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to qualitative_uncertainty"); }    do { // convert the 'uncertainty_value' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->uncertainty_value, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to qualitative_uncertainty to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<quantified_assembly_component_usage>(const DB& db, const LIST& params, quantified_assembly_component_usage* in)
-{
-    size_t base = GenericFill(db, params, static_cast<assembly_component_usage*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to quantified_assembly_component_usage"); }    do { // convert the 'quantity' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->quantity, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to quantified_assembly_component_usage to be a `measure_with_unit`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<quasi_uniform_curve>(const DB& db, const LIST& params, quasi_uniform_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<b_spline_curve*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to quasi_uniform_curve"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<quasi_uniform_surface>(const DB& db, const LIST& params, quasi_uniform_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<b_spline_surface*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to quasi_uniform_surface"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<radioactivity_measure_with_unit>(const DB& db, const LIST& params, radioactivity_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to radioactivity_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<radioactivity_unit>(const DB& db, const LIST& params, radioactivity_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to radioactivity_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<radius_dimension>(const DB& db, const LIST& params, radius_dimension* in)
-{
-    size_t base = GenericFill(db, params, static_cast<dimension_curve_directed_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to radius_dimension"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<range_characteristic>(const DB& db, const LIST& params, range_characteristic* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<ratio_unit>(const DB& db, const LIST& params, ratio_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to ratio_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<rational_b_spline_curve>(const DB& db, const LIST& params, rational_b_spline_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<b_spline_curve*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to rational_b_spline_curve"); }    do { // convert the 'weights_data' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->weights_data, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to rational_b_spline_curve to be a `LIST [2:?] OF REAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<rational_b_spline_surface>(const DB& db, const LIST& params, rational_b_spline_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<b_spline_surface*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to rational_b_spline_surface"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<rational_representation_item>(const DB& db, const LIST& params, rational_representation_item* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<real_literal>(const DB& db, const LIST& params, real_literal* in)
-{
-    size_t base = GenericFill(db, params, static_cast<literal_number*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to real_literal"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<real_representation_item>(const DB& db, const LIST& params, real_representation_item* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<rectangular_composite_surface>(const DB& db, const LIST& params, rectangular_composite_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<bounded_surface*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to rectangular_composite_surface"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<rectangular_trimmed_surface>(const DB& db, const LIST& params, rectangular_trimmed_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<bounded_surface*>(in));
-    if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to rectangular_trimmed_surface"); }    do { // convert the 'basis_surface' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->basis_surface, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to rectangular_trimmed_surface to be a `surface`")); }
-    } while (0);
-    do { // convert the 'u1' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->u1, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to rectangular_trimmed_surface to be a `parameter_value`")); }
-    } while (0);
-    do { // convert the 'u2' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->u2, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to rectangular_trimmed_surface to be a `parameter_value`")); }
-    } while (0);
-    do { // convert the 'v1' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->v1, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to rectangular_trimmed_surface to be a `parameter_value`")); }
-    } while (0);
-    do { // convert the 'v2' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->v2, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to rectangular_trimmed_surface to be a `parameter_value`")); }
-    } while (0);
-    do { // convert the 'usense' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->usense, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to rectangular_trimmed_surface to be a `BOOLEAN`")); }
-    } while (0);
-    do { // convert the 'vsense' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->vsense, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to rectangular_trimmed_surface to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<referenced_modified_datum>(const DB& db, const LIST& params, referenced_modified_datum* in)
-{
-    size_t base = GenericFill(db, params, static_cast<datum_reference*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to referenced_modified_datum"); }    do { // convert the 'modifier' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->modifier, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to referenced_modified_datum to be a `limit_condition`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<relative_event_occurrence>(const DB& db, const LIST& params, relative_event_occurrence* in)
-{
-    size_t base = GenericFill(db, params, static_cast<event_occurrence*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to relative_event_occurrence"); }    do { // convert the 'base_event' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->base_event, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to relative_event_occurrence to be a `event_occurrence`")); }
-    } while (0);
-    do { // convert the 'offset' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->offset, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to relative_event_occurrence to be a `time_measure_with_unit`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<rep_item_group>(const DB& db, const LIST& params, rep_item_group* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<reparametrised_composite_curve_segment>(const DB& db, const LIST& params, reparametrised_composite_curve_segment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<composite_curve_segment*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to reparametrised_composite_curve_segment"); }    do { // convert the 'param_length' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->param_length, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to reparametrised_composite_curve_segment to be a `parameter_value`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<representation_relationship_with_transformation>(const DB& db, const LIST& params, representation_relationship_with_transformation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_relationship*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to representation_relationship_with_transformation"); }    do { // convert the 'transformation_operator' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->transformation_operator, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to representation_relationship_with_transformation to be a `transformation`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<requirement_assigned_object>(const DB& db, const LIST& params, requirement_assigned_object* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to requirement_assigned_object"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to requirement_assigned_object to be a `SET [1:1] OF requirement_assigned_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<requirement_assignment>(const DB& db, const LIST& params, requirement_assignment* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<requirement_source>(const DB& db, const LIST& params, requirement_source* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to requirement_source"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<requirement_view_definition_relationship>(const DB& db, const LIST& params, requirement_view_definition_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition_relationship*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to requirement_view_definition_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<resistance_measure_with_unit>(const DB& db, const LIST& params, resistance_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to resistance_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<resistance_unit>(const DB& db, const LIST& params, resistance_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to resistance_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<revolved_area_solid>(const DB& db, const LIST& params, revolved_area_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<swept_area_solid*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to revolved_area_solid"); }    do { // convert the 'axis' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->axis, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to revolved_area_solid to be a `axis1_placement`")); }
-    } while (0);
-    do { // convert the 'angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->angle, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to revolved_area_solid to be a `plane_angle_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<revolved_face_solid>(const DB& db, const LIST& params, revolved_face_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<swept_face_solid*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to revolved_face_solid"); }    do { // convert the 'axis' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::revolved_face_solid, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->axis, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to revolved_face_solid to be a `axis1_placement`")); }
-    } while (0);
-    do { // convert the 'angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::revolved_face_solid, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->angle, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to revolved_face_solid to be a `plane_angle_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<revolved_face_solid_with_trim_conditions>(const DB& db, const LIST& params, revolved_face_solid_with_trim_conditions* in)
-{
-    size_t base = GenericFill(db, params, static_cast<revolved_face_solid*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to revolved_face_solid_with_trim_conditions"); }    do { // convert the 'first_trim_condition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->first_trim_condition, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to revolved_face_solid_with_trim_conditions to be a `trim_condition_select`")); }
-    } while (0);
-    do { // convert the 'second_trim_condition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->second_trim_condition, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to revolved_face_solid_with_trim_conditions to be a `trim_condition_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<right_angular_wedge>(const DB& db, const LIST& params, right_angular_wedge* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to right_angular_wedge"); }    do { // convert the 'position' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->position, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to right_angular_wedge to be a `axis2_placement_3d`")); }
-    } while (0);
-    do { // convert the 'x' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->x, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to right_angular_wedge to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'y' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->y, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to right_angular_wedge to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'z' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->z, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to right_angular_wedge to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'ltx' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->ltx, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to right_angular_wedge to be a `length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<right_circular_cone>(const DB& db, const LIST& params, right_circular_cone* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to right_circular_cone"); }    do { // convert the 'position' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->position, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to right_circular_cone to be a `axis1_placement`")); }
-    } while (0);
-    do { // convert the 'height' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->height, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to right_circular_cone to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to right_circular_cone to be a `length_measure`")); }
-    } while (0);
-    do { // convert the 'semi_angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->semi_angle, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to right_circular_cone to be a `plane_angle_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<right_circular_cylinder>(const DB& db, const LIST& params, right_circular_cylinder* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to right_circular_cylinder"); }    do { // convert the 'position' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->position, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to right_circular_cylinder to be a `axis1_placement`")); }
-    } while (0);
-    do { // convert the 'height' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->height, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to right_circular_cylinder to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to right_circular_cylinder to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<right_to_usage_association>(const DB& db, const LIST& params, right_to_usage_association* in)
-{
-    size_t base = GenericFill(db, params, static_cast<action_method_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to right_to_usage_association"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<roundness_tolerance>(const DB& db, const LIST& params, roundness_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to roundness_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<row_representation_item>(const DB& db, const LIST& params, row_representation_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to row_representation_item"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<row_value>(const DB& db, const LIST& params, row_value* in)
-{
-    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to row_value"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<row_variable>(const DB& db, const LIST& params, row_variable* in)
-{
-    size_t base = GenericFill(db, params, static_cast<abstract_variable*>(in));
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<rule_action>(const DB& db, const LIST& params, rule_action* in)
-{
-    size_t base = GenericFill(db, params, static_cast<action*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to rule_action"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<rule_condition>(const DB& db, const LIST& params, rule_condition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<atomic_formula*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to rule_condition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<rule_set>(const DB& db, const LIST& params, rule_set* in)
-{
-    size_t base = GenericFill(db, params, static_cast<rule_software_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to rule_set"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<rule_set_group>(const DB& db, const LIST& params, rule_set_group* in)
-{
-    size_t base = GenericFill(db, params, static_cast<rule_software_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to rule_set_group"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<rule_superseded_assignment>(const DB& db, const LIST& params, rule_superseded_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<action_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to rule_superseded_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to rule_superseded_assignment to be a `SET [1:?] OF rule_superseded_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<rule_supersedence>(const DB& db, const LIST& params, rule_supersedence* in)
-{
-    size_t base = GenericFill(db, params, static_cast<rule_action*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to rule_supersedence"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_curve_swept_area_solid>(const DB& db, const LIST& params, surface_curve_swept_area_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<swept_area_solid*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to surface_curve_swept_area_solid"); }    do { // convert the 'directrix' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_curve_swept_area_solid, 4>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->directrix, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to surface_curve_swept_area_solid to be a `curve`")); }
-    } while (0);
-    do { // convert the 'start_param' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_curve_swept_area_solid, 4>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->start_param, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to surface_curve_swept_area_solid to be a `REAL`")); }
-    } while (0);
-    do { // convert the 'end_param' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_curve_swept_area_solid, 4>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->end_param, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to surface_curve_swept_area_solid to be a `REAL`")); }
-    } while (0);
-    do { // convert the 'reference_surface' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_curve_swept_area_solid, 4>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->reference_surface, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to surface_curve_swept_area_solid to be a `surface`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<ruled_surface_swept_area_solid>(const DB& db, const LIST& params, ruled_surface_swept_area_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<surface_curve_swept_area_solid*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to ruled_surface_swept_area_solid"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<runout_zone_definition>(const DB& db, const LIST& params, runout_zone_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<tolerance_zone_definition*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to runout_zone_definition"); }    do { // convert the 'orientation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->orientation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to runout_zone_definition to be a `runout_zone_orientation`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<runout_zone_orientation>(const DB& db, const LIST& params, runout_zone_orientation* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to runout_zone_orientation"); }    do { // convert the 'angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::runout_zone_orientation, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->angle, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to runout_zone_orientation to be a `measure_with_unit`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<runout_zone_orientation_reference_direction>(const DB& db, const LIST& params, runout_zone_orientation_reference_direction* in)
-{
-    size_t base = GenericFill(db, params, static_cast<runout_zone_orientation*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to runout_zone_orientation_reference_direction"); }    do { // convert the 'orientation_defining_relationship' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->orientation_defining_relationship, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to runout_zone_orientation_reference_direction to be a `shape_aspect_relationship`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<satisfied_requirement>(const DB& db, const LIST& params, satisfied_requirement* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to satisfied_requirement"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to satisfied_requirement to be a `SET [1:1] OF product_definition`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<satisfies_requirement>(const DB& db, const LIST& params, satisfies_requirement* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to satisfies_requirement"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<satisfying_item>(const DB& db, const LIST& params, satisfying_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to satisfying_item"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to satisfying_item to be a `SET [1:1] OF requirement_satisfaction_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<scalar_variable>(const DB& db, const LIST& params, scalar_variable* in)
-{
-    size_t base = GenericFill(db, params, static_cast<abstract_variable*>(in));
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<scattering_parameter>(const DB& db, const LIST& params, scattering_parameter* in)
-{
-    size_t base = GenericFill(db, params, static_cast<polar_complex_number_literal*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to scattering_parameter"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<sculptured_solid>(const DB& db, const LIST& params, sculptured_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<modified_solid*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to sculptured_solid"); }    do { // convert the 'sculpturing_element' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->sculpturing_element, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to sculptured_solid to be a `generalized_surface_select`")); }
-    } while (0);
-    do { // convert the 'positive_side' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->positive_side, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to sculptured_solid to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<seam_curve>(const DB& db, const LIST& params, seam_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<surface_curve*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to seam_curve"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<serial_numbered_effectivity>(const DB& db, const LIST& params, serial_numbered_effectivity* in)
-{
-    size_t base = GenericFill(db, params, static_cast<effectivity*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to serial_numbered_effectivity"); }    do { // convert the 'effectivity_start_id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->effectivity_start_id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to serial_numbered_effectivity to be a `identifier`")); }
-    } while (0);
-    do { // convert the 'effectivity_end_id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->effectivity_end_id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to serial_numbered_effectivity to be a `identifier`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<shape_aspect_associativity>(const DB& db, const LIST& params, shape_aspect_associativity* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_aspect_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to shape_aspect_associativity"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<shape_aspect_deriving_relationship>(const DB& db, const LIST& params, shape_aspect_deriving_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_aspect_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to shape_aspect_deriving_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<shape_definition_representation>(const DB& db, const LIST& params, shape_definition_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<property_definition_representation*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to shape_definition_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<shape_dimension_representation>(const DB& db, const LIST& params, shape_dimension_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to shape_dimension_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<shape_feature_definition>(const DB& db, const LIST& params, shape_feature_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<characterized_object*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to shape_feature_definition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<shape_representation_with_parameters>(const DB& db, const LIST& params, shape_representation_with_parameters* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to shape_representation_with_parameters"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<shell_based_surface_model>(const DB& db, const LIST& params, shell_based_surface_model* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to shell_based_surface_model"); }    do { // convert the 'sbsm_boundary' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->sbsm_boundary, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to shell_based_surface_model to be a `SET [1:?] OF shell`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<shell_based_wireframe_model>(const DB& db, const LIST& params, shell_based_wireframe_model* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to shell_based_wireframe_model"); }    do { // convert the 'sbwm_boundary' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->sbwm_boundary, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to shell_based_wireframe_model to be a `SET [1:?] OF shell`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<shell_based_wireframe_shape_representation>(const DB& db, const LIST& params, shell_based_wireframe_shape_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to shell_based_wireframe_shape_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_absorbed_dose_unit>(const DB& db, const LIST& params, si_absorbed_dose_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_capacitance_unit>(const DB& db, const LIST& params, si_capacitance_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_conductance_unit>(const DB& db, const LIST& params, si_conductance_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_dose_equivalent_unit>(const DB& db, const LIST& params, si_dose_equivalent_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_electric_charge_unit>(const DB& db, const LIST& params, si_electric_charge_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_electric_potential_unit>(const DB& db, const LIST& params, si_electric_potential_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_energy_unit>(const DB& db, const LIST& params, si_energy_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_force_unit>(const DB& db, const LIST& params, si_force_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_frequency_unit>(const DB& db, const LIST& params, si_frequency_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_illuminance_unit>(const DB& db, const LIST& params, si_illuminance_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_inductance_unit>(const DB& db, const LIST& params, si_inductance_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_magnetic_flux_density_unit>(const DB& db, const LIST& params, si_magnetic_flux_density_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_magnetic_flux_unit>(const DB& db, const LIST& params, si_magnetic_flux_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_power_unit>(const DB& db, const LIST& params, si_power_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_pressure_unit>(const DB& db, const LIST& params, si_pressure_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_radioactivity_unit>(const DB& db, const LIST& params, si_radioactivity_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_resistance_unit>(const DB& db, const LIST& params, si_resistance_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_unit>(const DB& db, const LIST& params, si_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to si_unit"); }    do { // convert the 'prefix' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->prefix, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to si_unit to be a `si_prefix`")); }
-    } while (0);
-    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to si_unit to be a `si_unit_name`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<simple_boolean_expression>(const DB& db, const LIST& params, simple_boolean_expression* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<simple_numeric_expression>(const DB& db, const LIST& params, simple_numeric_expression* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<slash_expression>(const DB& db, const LIST& params, slash_expression* in)
-{
-    size_t base = GenericFill(db, params, static_cast<binary_numeric_expression*>(in));
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<smeared_material_definition>(const DB& db, const LIST& params, smeared_material_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<zone_structural_makeup*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to smeared_material_definition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_angle_measure_with_unit>(const DB& db, const LIST& params, solid_angle_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to solid_angle_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_angle_unit>(const DB& db, const LIST& params, solid_angle_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to solid_angle_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_curve_font>(const DB& db, const LIST& params, solid_curve_font* in)
-{
-    size_t base = GenericFill(db, params, static_cast<pre_defined_curve_font*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to solid_curve_font"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_replica>(const DB& db, const LIST& params, solid_replica* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_model*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to solid_replica"); }    do { // convert the 'parent_solid' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->parent_solid, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to solid_replica to be a `solid_model`")); }
-    } while (0);
-    do { // convert the 'transformation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->transformation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to solid_replica to be a `cartesian_transformation_operator_3d`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_chamfered_edges>(const DB& db, const LIST& params, solid_with_chamfered_edges* in)
-{
-    size_t base = GenericFill(db, params, static_cast<edge_blended_solid*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to solid_with_chamfered_edges"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_angle_based_chamfer>(const DB& db, const LIST& params, solid_with_angle_based_chamfer* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_chamfered_edges*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to solid_with_angle_based_chamfer"); }    do { // convert the 'offset_distance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->offset_distance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to solid_with_angle_based_chamfer to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'left_offset' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->left_offset, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to solid_with_angle_based_chamfer to be a `BOOLEAN`")); }
-    } while (0);
-    do { // convert the 'offset_angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->offset_angle, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_angle_based_chamfer to be a `positive_plane_angle_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_shape_element_pattern>(const DB& db, const LIST& params, solid_with_shape_element_pattern* in)
-{
-    size_t base = GenericFill(db, params, static_cast<modified_solid_with_placed_configuration*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to solid_with_shape_element_pattern"); }    do { // convert the 'replicated_element' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_shape_element_pattern, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->replicated_element, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to solid_with_shape_element_pattern to be a `modified_solid_with_placed_configuration`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_circular_pattern>(const DB& db, const LIST& params, solid_with_circular_pattern* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_shape_element_pattern*>(in));
-    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to solid_with_circular_pattern"); }    do { // convert the 'replicate_count' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_circular_pattern, 4>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->replicate_count, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to solid_with_circular_pattern to be a `positive_integer`")); }
-    } while (0);
-    do { // convert the 'angular_spacing' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_circular_pattern, 4>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->angular_spacing, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_circular_pattern to be a `plane_angle_measure`")); }
-    } while (0);
-    do { // convert the 'radial_alignment' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_circular_pattern, 4>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->radial_alignment, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_circular_pattern to be a `BOOLEAN`")); }
-    } while (0);
-    do { // convert the 'reference_point' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_circular_pattern, 4>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->reference_point, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to solid_with_circular_pattern to be a `point`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_depression>(const DB& db, const LIST& params, solid_with_depression* in)
-{
-    size_t base = GenericFill(db, params, static_cast<modified_solid_with_placed_configuration*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to solid_with_depression"); }    do { // convert the 'depth' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_depression, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->depth, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to solid_with_depression to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_pocket>(const DB& db, const LIST& params, solid_with_pocket* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_depression*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to solid_with_pocket"); }    do { // convert the 'floor_blend_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_pocket, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->floor_blend_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to solid_with_pocket to be a `non_negative_length_measure`")); }
-    } while (0);
-    do { // convert the 'draft_angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_pocket, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->draft_angle, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_pocket to be a `plane_angle_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_circular_pocket>(const DB& db, const LIST& params, solid_with_circular_pocket* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_pocket*>(in));
-    if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to solid_with_circular_pocket"); }    do { // convert the 'pocket_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->pocket_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_circular_pocket to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_protrusion>(const DB& db, const LIST& params, solid_with_protrusion* in)
-{
-    size_t base = GenericFill(db, params, static_cast<modified_solid_with_placed_configuration*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to solid_with_protrusion"); }    do { // convert the 'protrusion_height' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_protrusion, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->protrusion_height, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to solid_with_protrusion to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'protrusion_draft_angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_protrusion, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->protrusion_draft_angle, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to solid_with_protrusion to be a `plane_angle_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_circular_protrusion>(const DB& db, const LIST& params, solid_with_circular_protrusion* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_protrusion*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to solid_with_circular_protrusion"); }    do { // convert the 'protrusion_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->protrusion_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_circular_protrusion to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_hole>(const DB& db, const LIST& params, solid_with_hole* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_depression*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to solid_with_hole"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_stepped_round_hole>(const DB& db, const LIST& params, solid_with_stepped_round_hole* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_hole*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to solid_with_stepped_round_hole"); }    do { // convert the 'segments' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_stepped_round_hole, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->segments, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to solid_with_stepped_round_hole to be a `positive_integer`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_conical_bottom_round_hole>(const DB& db, const LIST& params, solid_with_conical_bottom_round_hole* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_stepped_round_hole*>(in));
-    if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to solid_with_conical_bottom_round_hole"); }    do { // convert the 'semi_apex_angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->semi_apex_angle, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_conical_bottom_round_hole to be a `positive_plane_angle_measure`")); }
-    } while (0);
-    do { // convert the 'tip_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->tip_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_conical_bottom_round_hole to be a `non_negative_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_constant_radius_edge_blend>(const DB& db, const LIST& params, solid_with_constant_radius_edge_blend* in)
-{
-    size_t base = GenericFill(db, params, static_cast<edge_blended_solid*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to solid_with_constant_radius_edge_blend"); }    do { // convert the 'radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to solid_with_constant_radius_edge_blend to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_slot>(const DB& db, const LIST& params, solid_with_slot* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_depression*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to solid_with_slot"); }    do { // convert the 'slot_width' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_slot, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->slot_width, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to solid_with_slot to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'closed_ends' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_slot, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->closed_ends, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_slot to be a `LIST [2:2] OF LOGICAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_curved_slot>(const DB& db, const LIST& params, solid_with_curved_slot* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_slot*>(in));
-    if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to solid_with_curved_slot"); }    do { // convert the 'slot_centreline' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->slot_centreline, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_curved_slot to be a `bounded_curve`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_double_offset_chamfer>(const DB& db, const LIST& params, solid_with_double_offset_chamfer* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_chamfered_edges*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to solid_with_double_offset_chamfer"); }    do { // convert the 'left_offset_distance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->left_offset_distance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to solid_with_double_offset_chamfer to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'right_offset_distance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->right_offset_distance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to solid_with_double_offset_chamfer to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_flat_bottom_round_hole>(const DB& db, const LIST& params, solid_with_flat_bottom_round_hole* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_stepped_round_hole*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to solid_with_flat_bottom_round_hole"); }    do { // convert the 'fillet_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->fillet_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_flat_bottom_round_hole to be a `non_negative_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_general_pocket>(const DB& db, const LIST& params, solid_with_general_pocket* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_pocket*>(in));
-    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to solid_with_general_pocket"); }    do { // convert the 'profile' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->profile, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_general_pocket to be a `positioned_sketch`")); }
-    } while (0);
-    do { // convert the 'reference_point' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->reference_point, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to solid_with_general_pocket to be a `point`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_general_protrusion>(const DB& db, const LIST& params, solid_with_general_protrusion* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_protrusion*>(in));
-    if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to solid_with_general_protrusion"); }    do { // convert the 'profile' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->profile, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_general_protrusion to be a `positioned_sketch`")); }
-    } while (0);
-    do { // convert the 'reference_point' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->reference_point, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_general_protrusion to be a `point`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_groove>(const DB& db, const LIST& params, solid_with_groove* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_depression*>(in));
-    if (params.GetSize() < 10) { throw STEP::TypeError("expected 10 arguments to solid_with_groove"); }    do { // convert the 'groove_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->groove_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to solid_with_groove to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'groove_width' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->groove_width, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_groove to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'draft_angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->draft_angle, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_groove to be a `plane_angle_measure`")); }
-    } while (0);
-    do { // convert the 'floor_fillet_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->floor_fillet_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to solid_with_groove to be a `non_negative_length_measure`")); }
-    } while (0);
-    do { // convert the 'external_groove' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->external_groove, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to solid_with_groove to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_incomplete_circular_pattern>(const DB& db, const LIST& params, solid_with_incomplete_circular_pattern* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_circular_pattern*>(in));
-    if (params.GetSize() < 10) { throw STEP::TypeError("expected 10 arguments to solid_with_incomplete_circular_pattern"); }    do { // convert the 'omitted_instances' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->omitted_instances, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to solid_with_incomplete_circular_pattern to be a `SET [1:?] OF positive_integer`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_rectangular_pattern>(const DB& db, const LIST& params, solid_with_rectangular_pattern* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_shape_element_pattern*>(in));
-    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to solid_with_rectangular_pattern"); }    do { // convert the 'row_count' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_rectangular_pattern, 4>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->row_count, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to solid_with_rectangular_pattern to be a `positive_integer`")); }
-    } while (0);
-    do { // convert the 'column_count' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_rectangular_pattern, 4>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->column_count, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_rectangular_pattern to be a `positive_integer`")); }
-    } while (0);
-    do { // convert the 'row_spacing' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_rectangular_pattern, 4>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->row_spacing, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_rectangular_pattern to be a `length_measure`")); }
-    } while (0);
-    do { // convert the 'column_spacing' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_rectangular_pattern, 4>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->column_spacing, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to solid_with_rectangular_pattern to be a `length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_incomplete_rectangular_pattern>(const DB& db, const LIST& params, solid_with_incomplete_rectangular_pattern* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_rectangular_pattern*>(in));
-    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to solid_with_incomplete_rectangular_pattern"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_rectangular_pocket>(const DB& db, const LIST& params, solid_with_rectangular_pocket* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_pocket*>(in));
-    if (params.GetSize() < 10) { throw STEP::TypeError("expected 10 arguments to solid_with_rectangular_pocket"); }    do { // convert the 'pocket_length' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->pocket_length, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_rectangular_pocket to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'pocket_width' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->pocket_width, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to solid_with_rectangular_pocket to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'corner_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->corner_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to solid_with_rectangular_pocket to be a `non_negative_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_rectangular_protrusion>(const DB& db, const LIST& params, solid_with_rectangular_protrusion* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_protrusion*>(in));
-    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to solid_with_rectangular_protrusion"); }    do { // convert the 'protrusion_length' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->protrusion_length, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_rectangular_protrusion to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'protrusion_width' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->protrusion_width, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_rectangular_protrusion to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'protrusion_corner_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->protrusion_corner_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to solid_with_rectangular_protrusion to be a `non_negative_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_single_offset_chamfer>(const DB& db, const LIST& params, solid_with_single_offset_chamfer* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_chamfered_edges*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to solid_with_single_offset_chamfer"); }    do { // convert the 'offset_distance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->offset_distance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to solid_with_single_offset_chamfer to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_spherical_bottom_round_hole>(const DB& db, const LIST& params, solid_with_spherical_bottom_round_hole* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_stepped_round_hole*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to solid_with_spherical_bottom_round_hole"); }    do { // convert the 'sphere_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->sphere_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_spherical_bottom_round_hole to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_stepped_round_hole_and_conical_transitions>(const DB& db, const LIST& params, solid_with_stepped_round_hole_and_conical_transitions* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_stepped_round_hole*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to solid_with_stepped_round_hole_and_conical_transitions"); }    do { // convert the 'conical_transitions' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->conical_transitions, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_stepped_round_hole_and_conical_transitions to be a `SET [1:?] OF conical_stepped_hole_transition`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_straight_slot>(const DB& db, const LIST& params, solid_with_straight_slot* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_slot*>(in));
-    if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to solid_with_straight_slot"); }    do { // convert the 'slot_length' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->slot_length, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_straight_slot to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_tee_section_slot>(const DB& db, const LIST& params, solid_with_tee_section_slot* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_slot*>(in));
-    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to solid_with_tee_section_slot"); }    do { // convert the 'tee_section_width' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->tee_section_width, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_tee_section_slot to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'collar_depth' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->collar_depth, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to solid_with_tee_section_slot to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_through_depression>(const DB& db, const LIST& params, solid_with_through_depression* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_depression*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to solid_with_through_depression"); }    do { // convert the 'exit_faces' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->exit_faces, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to solid_with_through_depression to be a `SET [1:?] OF face_surface`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_trapezoidal_section_slot>(const DB& db, const LIST& params, solid_with_trapezoidal_section_slot* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_slot*>(in));
-    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to solid_with_trapezoidal_section_slot"); }    do { // convert the 'draft_angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->draft_angle, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_trapezoidal_section_slot to be a `plane_angle_measure`")); }
-    } while (0);
-    do { // convert the 'floor_fillet_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->floor_fillet_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to solid_with_trapezoidal_section_slot to be a `non_negative_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_variable_radius_edge_blend>(const DB& db, const LIST& params, solid_with_variable_radius_edge_blend* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to solid_with_variable_radius_edge_blend"); }    do { // convert the 'point_list' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->point_list, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to solid_with_variable_radius_edge_blend to be a `LIST [2:?] OF point`")); }
-    } while (0);
-    do { // convert the 'radius_list' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->radius_list, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to solid_with_variable_radius_edge_blend to be a `LIST [2:?] OF positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'edge_function_list' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->edge_function_list, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to solid_with_variable_radius_edge_blend to be a `LIST [1:?] OF blend_radius_variation_type`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<source_for_requirement>(const DB& db, const LIST& params, source_for_requirement* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to source_for_requirement"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to source_for_requirement to be a `SET [1:1] OF requirement_source_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<sourced_requirement>(const DB& db, const LIST& params, sourced_requirement* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to sourced_requirement"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to sourced_requirement to be a `SET [1:1] OF product_definition`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<specification_definition>(const DB& db, const LIST& params, specification_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to specification_definition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<specified_higher_usage_occurrence>(const DB& db, const LIST& params, specified_higher_usage_occurrence* in)
-{
-    size_t base = GenericFill(db, params, static_cast<assembly_component_usage*>(in));
-    if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to specified_higher_usage_occurrence"); }    do { // convert the 'upper_usage' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->upper_usage, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to specified_higher_usage_occurrence to be a `assembly_component_usage`")); }
-    } while (0);
-    do { // convert the 'next_usage' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->next_usage, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to specified_higher_usage_occurrence to be a `next_assembly_usage_occurrence`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<sphere>(const DB& db, const LIST& params, sphere* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to sphere"); }    do { // convert the 'radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to sphere to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'centre' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->centre, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to sphere to be a `point`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<spherical_surface>(const DB& db, const LIST& params, spherical_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<elementary_surface*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to spherical_surface"); }    do { // convert the 'radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to spherical_surface to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<start_request>(const DB& db, const LIST& params, start_request* in)
-{
-    size_t base = GenericFill(db, params, static_cast<action_request_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to start_request"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to start_request to be a `SET [1:?] OF start_request_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<start_work>(const DB& db, const LIST& params, start_work* in)
-{
-    size_t base = GenericFill(db, params, static_cast<action_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to start_work"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to start_work to be a `SET [1:?] OF work_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<straightness_tolerance>(const DB& db, const LIST& params, straightness_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to straightness_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<structured_dimension_callout>(const DB& db, const LIST& params, structured_dimension_callout* in)
-{
-    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to structured_dimension_callout"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<structured_text_composition>(const DB& db, const LIST& params, structured_text_composition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to structured_text_composition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<structured_text_representation>(const DB& db, const LIST& params, structured_text_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to structured_text_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<subedge>(const DB& db, const LIST& params, subedge* in)
-{
-    size_t base = GenericFill(db, params, static_cast<edge*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to subedge"); }    do { // convert the 'parent_edge' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->parent_edge, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to subedge to be a `edge`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<subface>(const DB& db, const LIST& params, subface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<face*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to subface"); }    do { // convert the 'parent_face' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->parent_face, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to subface to be a `face`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<supplied_part_relationship>(const DB& db, const LIST& params, supplied_part_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition_relationship*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to supplied_part_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_condition_callout>(const DB& db, const LIST& params, surface_condition_callout* in)
-{
-    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to surface_condition_callout"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<swept_surface>(const DB& db, const LIST& params, swept_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<surface*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to swept_surface"); }    do { // convert the 'swept_curve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::swept_surface, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->swept_curve, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to swept_surface to be a `curve`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_of_linear_extrusion>(const DB& db, const LIST& params, surface_of_linear_extrusion* in)
-{
-    size_t base = GenericFill(db, params, static_cast<swept_surface*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to surface_of_linear_extrusion"); }    do { // convert the 'extrusion_axis' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->extrusion_axis, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to surface_of_linear_extrusion to be a `vector`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_of_revolution>(const DB& db, const LIST& params, surface_of_revolution* in)
-{
-    size_t base = GenericFill(db, params, static_cast<swept_surface*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to surface_of_revolution"); }    do { // convert the 'axis_position' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->axis_position, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to surface_of_revolution to be a `axis1_placement`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_patch>(const DB& db, const LIST& params, surface_patch* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to surface_patch"); }    do { // convert the 'parent_surface' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->parent_surface, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_patch to be a `bounded_surface`")); }
-    } while (0);
-    do { // convert the 'u_transition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->u_transition, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to surface_patch to be a `transition_code`")); }
-    } while (0);
-    do { // convert the 'v_transition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->v_transition, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to surface_patch to be a `transition_code`")); }
-    } while (0);
-    do { // convert the 'u_sense' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->u_sense, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to surface_patch to be a `BOOLEAN`")); }
-    } while (0);
-    do { // convert the 'v_sense' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->v_sense, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to surface_patch to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_profile_tolerance>(const DB& db, const LIST& params, surface_profile_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to surface_profile_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_replica>(const DB& db, const LIST& params, surface_replica* in)
-{
-    size_t base = GenericFill(db, params, static_cast<surface*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to surface_replica"); }    do { // convert the 'parent_surface' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->parent_surface, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to surface_replica to be a `surface`")); }
-    } while (0);
-    do { // convert the 'transformation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->transformation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to surface_replica to be a `cartesian_transformation_operator_3d`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_side_style>(const DB& db, const LIST& params, surface_side_style* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to surface_side_style"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_side_style to be a `label`")); }
-    } while (0);
-    do { // convert the 'styles' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->styles, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to surface_side_style to be a `SET [1:7] OF surface_style_element_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_style_boundary>(const DB& db, const LIST& params, surface_style_boundary* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to surface_style_boundary"); }    do { // convert the 'style_of_boundary' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->style_of_boundary, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_style_boundary to be a `curve_or_render`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_style_control_grid>(const DB& db, const LIST& params, surface_style_control_grid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to surface_style_control_grid"); }    do { // convert the 'style_of_control_grid' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->style_of_control_grid, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_style_control_grid to be a `curve_or_render`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_style_fill_area>(const DB& db, const LIST& params, surface_style_fill_area* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to surface_style_fill_area"); }    do { // convert the 'fill_area' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->fill_area, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_style_fill_area to be a `fill_area_style`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_style_parameter_line>(const DB& db, const LIST& params, surface_style_parameter_line* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to surface_style_parameter_line"); }    do { // convert the 'style_of_parameter_lines' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->style_of_parameter_lines, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_style_parameter_line to be a `curve_or_render`")); }
-    } while (0);
-    do { // convert the 'direction_counts' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->direction_counts, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to surface_style_parameter_line to be a `SET [1:2] OF direction_count_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_style_reflectance_ambient>(const DB& db, const LIST& params, surface_style_reflectance_ambient* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to surface_style_reflectance_ambient"); }    do { // convert the 'ambient_reflectance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_style_reflectance_ambient, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->ambient_reflectance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_style_reflectance_ambient to be a `REAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_style_reflectance_ambient_diffuse>(const DB& db, const LIST& params, surface_style_reflectance_ambient_diffuse* in)
-{
-    size_t base = GenericFill(db, params, static_cast<surface_style_reflectance_ambient*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to surface_style_reflectance_ambient_diffuse"); }    do { // convert the 'diffuse_reflectance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_style_reflectance_ambient_diffuse, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->diffuse_reflectance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to surface_style_reflectance_ambient_diffuse to be a `REAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_style_reflectance_ambient_diffuse_specular>(const DB& db, const LIST& params, surface_style_reflectance_ambient_diffuse_specular* in)
-{
-    size_t base = GenericFill(db, params, static_cast<surface_style_reflectance_ambient_diffuse*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to surface_style_reflectance_ambient_diffuse_specular"); }    do { // convert the 'specular_reflectance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->specular_reflectance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to surface_style_reflectance_ambient_diffuse_specular to be a `REAL`")); }
-    } while (0);
-    do { // convert the 'specular_exponent' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->specular_exponent, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to surface_style_reflectance_ambient_diffuse_specular to be a `REAL`")); }
-    } while (0);
-    do { // convert the 'specular_colour' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->specular_colour, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to surface_style_reflectance_ambient_diffuse_specular to be a `colour`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_style_rendering>(const DB& db, const LIST& params, surface_style_rendering* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to surface_style_rendering"); }    do { // convert the 'rendering_method' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_style_rendering, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->rendering_method, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_style_rendering to be a `shading_surface_method`")); }
-    } while (0);
-    do { // convert the 'surface_colour' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_style_rendering, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->surface_colour, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to surface_style_rendering to be a `colour`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_style_rendering_with_properties>(const DB& db, const LIST& params, surface_style_rendering_with_properties* in)
-{
-    size_t base = GenericFill(db, params, static_cast<surface_style_rendering*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to surface_style_rendering_with_properties"); }    do { // convert the 'properties' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->properties, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to surface_style_rendering_with_properties to be a `SET [1:2] OF rendering_properties_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_style_segmentation_curve>(const DB& db, const LIST& params, surface_style_segmentation_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to surface_style_segmentation_curve"); }    do { // convert the 'style_of_segmentation_curve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->style_of_segmentation_curve, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_style_segmentation_curve to be a `curve_or_render`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_style_silhouette>(const DB& db, const LIST& params, surface_style_silhouette* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to surface_style_silhouette"); }    do { // convert the 'style_of_silhouette' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->style_of_silhouette, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_style_silhouette to be a `curve_or_render`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_style_usage>(const DB& db, const LIST& params, surface_style_usage* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to surface_style_usage"); }    do { // convert the 'side' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->side, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_style_usage to be a `surface_side`")); }
-    } while (0);
-    do { // convert the 'style' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->style, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to surface_style_usage to be a `surface_side_style_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_texture_representation>(const DB& db, const LIST& params, surface_texture_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to surface_texture_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surfaced_open_shell>(const DB& db, const LIST& params, surfaced_open_shell* in)
-{
-    size_t base = GenericFill(db, params, static_cast<open_shell*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to surfaced_open_shell"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<swept_disk_solid>(const DB& db, const LIST& params, swept_disk_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_model*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to swept_disk_solid"); }    do { // convert the 'directrix' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->directrix, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to swept_disk_solid to be a `curve`")); }
-    } while (0);
-    do { // convert the 'radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to swept_disk_solid to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'inner_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->inner_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to swept_disk_solid to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'start_param' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->start_param, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to swept_disk_solid to be a `REAL`")); }
-    } while (0);
-    do { // convert the 'end_param' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->end_param, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to swept_disk_solid to be a `REAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<symbol>(const DB& db, const LIST& params, symbol* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to symbol"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<symbol_representation_map>(const DB& db, const LIST& params, symbol_representation_map* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_map*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to symbol_representation_map"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<symbol_style>(const DB& db, const LIST& params, symbol_style* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to symbol_style"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to symbol_style to be a `label`")); }
-    } while (0);
-    do { // convert the 'style_of_symbol' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->style_of_symbol, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to symbol_style to be a `symbol_style_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<symbol_target>(const DB& db, const LIST& params, symbol_target* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to symbol_target"); }    do { // convert the 'placement' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->placement, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to symbol_target to be a `axis2_placement`")); }
-    } while (0);
-    do { // convert the 'x_scale' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->x_scale, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to symbol_target to be a `positive_ratio_measure`")); }
-    } while (0);
-    do { // convert the 'y_scale' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->y_scale, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to symbol_target to be a `positive_ratio_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<symmetric_shape_aspect>(const DB& db, const LIST& params, symmetric_shape_aspect* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_aspect*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to symmetric_shape_aspect"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<symmetry_tolerance>(const DB& db, const LIST& params, symmetry_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance_with_datum_reference*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to symmetry_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<table_representation_item>(const DB& db, const LIST& params, table_representation_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to table_representation_item"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<tactile_appearance_representation>(const DB& db, const LIST& params, tactile_appearance_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to tactile_appearance_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<tagged_text_format>(const DB& db, const LIST& params, tagged_text_format* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_context*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to tagged_text_format"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<tagged_text_item>(const DB& db, const LIST& params, tagged_text_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<descriptive_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to tagged_text_item"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<tangent>(const DB& db, const LIST& params, tangent* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_shape_aspect*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to tangent"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<text_literal_with_associated_curves>(const DB& db, const LIST& params, text_literal_with_associated_curves* in)
-{
-    size_t base = GenericFill(db, params, static_cast<text_literal*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to text_literal_with_associated_curves"); }    do { // convert the 'associated_curves' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->associated_curves, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to text_literal_with_associated_curves to be a `SET [1:?] OF curve`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<text_literal_with_blanking_box>(const DB& db, const LIST& params, text_literal_with_blanking_box* in)
-{
-    size_t base = GenericFill(db, params, static_cast<text_literal*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to text_literal_with_blanking_box"); }    do { // convert the 'blanking' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->blanking, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to text_literal_with_blanking_box to be a `planar_box`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<text_literal_with_extent>(const DB& db, const LIST& params, text_literal_with_extent* in)
-{
-    size_t base = GenericFill(db, params, static_cast<text_literal*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to text_literal_with_extent"); }    do { // convert the 'extent' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->extent, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to text_literal_with_extent to be a `planar_extent`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<text_string_representation>(const DB& db, const LIST& params, text_string_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to text_string_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<text_style>(const DB& db, const LIST& params, text_style* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to text_style"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::text_style, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to text_style to be a `label`")); }
-    } while (0);
-    do { // convert the 'character_appearance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::text_style, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->character_appearance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to text_style to be a `character_style_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<text_style_with_box_characteristics>(const DB& db, const LIST& params, text_style_with_box_characteristics* in)
-{
-    size_t base = GenericFill(db, params, static_cast<text_style*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to text_style_with_box_characteristics"); }    do { // convert the 'characteristics' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->characteristics, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to text_style_with_box_characteristics to be a `SET [1:4] OF box_characteristic_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<text_style_with_mirror>(const DB& db, const LIST& params, text_style_with_mirror* in)
-{
-    size_t base = GenericFill(db, params, static_cast<text_style*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to text_style_with_mirror"); }    do { // convert the 'mirror_placement' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->mirror_placement, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to text_style_with_mirror to be a `axis2_placement`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<text_style_with_spacing>(const DB& db, const LIST& params, text_style_with_spacing* in)
-{
-    size_t base = GenericFill(db, params, static_cast<text_style*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to text_style_with_spacing"); }    do { // convert the 'character_spacing' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->character_spacing, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to text_style_with_spacing to be a `character_spacing_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<thermal_resistance_measure_with_unit>(const DB& db, const LIST& params, thermal_resistance_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to thermal_resistance_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<thermal_resistance_unit>(const DB& db, const LIST& params, thermal_resistance_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to thermal_resistance_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<thermodynamic_temperature_measure_with_unit>(const DB& db, const LIST& params, thermodynamic_temperature_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to thermodynamic_temperature_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<thermodynamic_temperature_unit>(const DB& db, const LIST& params, thermodynamic_temperature_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to thermodynamic_temperature_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<thickened_face_solid>(const DB& db, const LIST& params, thickened_face_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_model*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to thickened_face_solid"); }    do { // convert the 'base_element' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->base_element, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to thickened_face_solid to be a `generalized_surface_select`")); }
-    } while (0);
-    do { // convert the 'offset1' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->offset1, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to thickened_face_solid to be a `length_measure`")); }
-    } while (0);
-    do { // convert the 'offset2' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->offset2, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to thickened_face_solid to be a `length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<thickness_laminate_definition>(const DB& db, const LIST& params, thickness_laminate_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to thickness_laminate_definition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<thickness_laminate_table>(const DB& db, const LIST& params, thickness_laminate_table* in)
-{
-    size_t base = GenericFill(db, params, static_cast<zone_structural_makeup*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to thickness_laminate_table"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<time_interval>(const DB& db, const LIST& params, time_interval* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to time_interval"); }    do { // convert the 'id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::time_interval, 3>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to time_interval to be a `identifier`")); }
-    } while (0);
-    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::time_interval, 3>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to time_interval to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::time_interval, 3>::aux_is_derived[2] = true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to time_interval to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<time_interval_based_effectivity>(const DB& db, const LIST& params, time_interval_based_effectivity* in)
-{
-    size_t base = GenericFill(db, params, static_cast<effectivity*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to time_interval_based_effectivity"); }    do { // convert the 'effectivity_period' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->effectivity_period, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to time_interval_based_effectivity to be a `time_interval`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<time_interval_with_bounds>(const DB& db, const LIST& params, time_interval_with_bounds* in)
-{
-    size_t base = GenericFill(db, params, static_cast<time_interval*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to time_interval_with_bounds"); }    do { // convert the 'primary_bound' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->primary_bound, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to time_interval_with_bounds to be a `date_time_or_event_occurrence`")); }
-    } while (0);
-    do { // convert the 'secondary_bound' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->secondary_bound, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to time_interval_with_bounds to be a `date_time_or_event_occurrence`")); }
-    } while (0);
-    do { // convert the 'duration' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->duration, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to time_interval_with_bounds to be a `time_measure_with_unit`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<time_measure_with_unit>(const DB& db, const LIST& params, time_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to time_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<time_unit>(const DB& db, const LIST& params, time_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to time_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<tolerance_zone>(const DB& db, const LIST& params, tolerance_zone* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_aspect*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to tolerance_zone"); }    do { // convert the 'defining_tolerance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->defining_tolerance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to tolerance_zone to be a `SET [1:?] OF geometric_tolerance`")); }
-    } while (0);
-    do { // convert the 'form' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->form, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to tolerance_zone to be a `tolerance_zone_form`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<torus>(const DB& db, const LIST& params, torus* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to torus"); }    do { // convert the 'position' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->position, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to torus to be a `axis1_placement`")); }
-    } while (0);
-    do { // convert the 'major_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->major_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to torus to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'minor_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->minor_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to torus to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<total_runout_tolerance>(const DB& db, const LIST& params, total_runout_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance_with_datum_reference*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to total_runout_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<track_blended_solid>(const DB& db, const LIST& params, track_blended_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<edge_blended_solid*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to track_blended_solid"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<track_blended_solid_with_end_conditions>(const DB& db, const LIST& params, track_blended_solid_with_end_conditions* in)
-{
-    size_t base = GenericFill(db, params, static_cast<track_blended_solid*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to track_blended_solid_with_end_conditions"); }    do { // convert the 'end_conditions' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->end_conditions, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to track_blended_solid_with_end_conditions to be a `LIST [2:2] OF blend_end_condition_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<trimmed_curve>(const DB& db, const LIST& params, trimmed_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<bounded_curve*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to trimmed_curve"); }    do { // convert the 'basis_curve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->basis_curve, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to trimmed_curve to be a `curve`")); }
-    } while (0);
-    do { // convert the 'trim_1' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->trim_1, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to trimmed_curve to be a `SET [1:2] OF trimming_select`")); }
-    } while (0);
-    do { // convert the 'trim_2' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->trim_2, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to trimmed_curve to be a `SET [1:2] OF trimming_select`")); }
-    } while (0);
-    do { // convert the 'sense_agreement' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->sense_agreement, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to trimmed_curve to be a `BOOLEAN`")); }
-    } while (0);
-    do { // convert the 'master_representation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->master_representation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to trimmed_curve to be a `trimming_preference`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<two_direction_repeat_factor>(const DB& db, const LIST& params, two_direction_repeat_factor* in)
-{
-    size_t base = GenericFill(db, params, static_cast<one_direction_repeat_factor*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to two_direction_repeat_factor"); }    do { // convert the 'second_repeat_factor' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->second_repeat_factor, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to two_direction_repeat_factor to be a `vector`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<unary_generic_expression>(const DB& db, const LIST& params, unary_generic_expression* in)
-{
-    size_t base = GenericFill(db, params, static_cast<generic_expression*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to unary_generic_expression"); }    do { // convert the 'operand' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->operand, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to unary_generic_expression to be a `generic_expression`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<unary_numeric_expression>(const DB& db, const LIST& params, unary_numeric_expression* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<uncertainty_assigned_representation>(const DB& db, const LIST& params, uncertainty_assigned_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to uncertainty_assigned_representation"); }    do { // convert the 'uncertainty' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->uncertainty, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to uncertainty_assigned_representation to be a `SET [1:?] OF uncertainty_measure_with_unit`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<uncertainty_measure_with_unit>(const DB& db, const LIST& params, uncertainty_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to uncertainty_measure_with_unit"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to uncertainty_measure_with_unit to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to uncertainty_measure_with_unit to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<uniform_curve>(const DB& db, const LIST& params, uniform_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<b_spline_curve*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to uniform_curve"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<uniform_resource_identifier>(const DB& db, const LIST& params, uniform_resource_identifier* in)
-{
-    size_t base = GenericFill(db, params, static_cast<descriptive_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to uniform_resource_identifier"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<uniform_surface>(const DB& db, const LIST& params, uniform_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<b_spline_surface*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to uniform_surface"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<usage_association>(const DB& db, const LIST& params, usage_association* in)
-{
-    size_t base = GenericFill(db, params, static_cast<action_method_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to usage_association"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<user_defined_curve_font>(const DB& db, const LIST& params, user_defined_curve_font* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<user_defined_marker>(const DB& db, const LIST& params, user_defined_marker* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<user_defined_terminator_symbol>(const DB& db, const LIST& params, user_defined_terminator_symbol* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<user_selected_shape_elements>(const DB& db, const LIST& params, user_selected_shape_elements* in)
-{
-    size_t base = GenericFill(db, params, static_cast<user_selected_elements*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to user_selected_shape_elements"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<value_range>(const DB& db, const LIST& params, value_range* in)
-{
-    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to value_range"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<value_representation_item>(const DB& db, const LIST& params, value_representation_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to value_representation_item"); }    do { // convert the 'value_component' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->value_component, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to value_representation_item to be a `measure_value`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<variable_semantics>(const DB& db, const LIST& params, variable_semantics* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<variational_representation_item>(const DB& db, const LIST& params, variational_representation_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to variational_representation_item"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<vector>(const DB& db, const LIST& params, vector* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to vector"); }    do { // convert the 'orientation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->orientation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to vector to be a `direction`")); }
-    } while (0);
-    do { // convert the 'magnitude' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->magnitude, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to vector to be a `length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<vector_style>(const DB& db, const LIST& params, vector_style* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<velocity_measure_with_unit>(const DB& db, const LIST& params, velocity_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to velocity_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<velocity_unit>(const DB& db, const LIST& params, velocity_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to velocity_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<vertex>(const DB& db, const LIST& params, vertex* in)
-{
-    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to vertex"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<vertex_loop>(const DB& db, const LIST& params, vertex_loop* in)
-{
-    size_t base = GenericFill(db, params, static_cast<loop*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to vertex_loop"); }    do { // convert the 'loop_vertex' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->loop_vertex, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to vertex_loop to be a `vertex`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<vertex_point>(const DB& db, const LIST& params, vertex_point* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to vertex_point"); }    do { // convert the 'vertex_geometry' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->vertex_geometry, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to vertex_point to be a `point`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<vertex_shell>(const DB& db, const LIST& params, vertex_shell* in)
-{
-    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to vertex_shell"); }    do { // convert the 'vertex_shell_extent' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->vertex_shell_extent, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to vertex_shell to be a `vertex_loop`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<view_volume>(const DB& db, const LIST& params, view_volume* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to view_volume"); }    do { // convert the 'projection_type' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->projection_type, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to view_volume to be a `central_or_parallel`")); }
-    } while (0);
-    do { // convert the 'projection_point' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->projection_point, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to view_volume to be a `cartesian_point`")); }
-    } while (0);
-    do { // convert the 'view_plane_distance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->view_plane_distance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to view_volume to be a `length_measure`")); }
-    } while (0);
-    do { // convert the 'front_plane_distance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->front_plane_distance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to view_volume to be a `length_measure`")); }
-    } while (0);
-    do { // convert the 'front_plane_clipping' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->front_plane_clipping, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to view_volume to be a `BOOLEAN`")); }
-    } while (0);
-    do { // convert the 'back_plane_distance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->back_plane_distance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to view_volume to be a `length_measure`")); }
-    } while (0);
-    do { // convert the 'back_plane_clipping' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->back_plane_clipping, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to view_volume to be a `BOOLEAN`")); }
-    } while (0);
-    do { // convert the 'view_volume_sides_clipping' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->view_volume_sides_clipping, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to view_volume to be a `BOOLEAN`")); }
-    } while (0);
-    do { // convert the 'view_window' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->view_window, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to view_volume to be a `planar_box`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<visual_appearance_representation>(const DB& db, const LIST& params, visual_appearance_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to visual_appearance_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<volume_measure_with_unit>(const DB& db, const LIST& params, volume_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to volume_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<volume_unit>(const DB& db, const LIST& params, volume_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to volume_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<week_of_year_and_day_date>(const DB& db, const LIST& params, week_of_year_and_day_date* in)
-{
-    size_t base = GenericFill(db, params, static_cast<date*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to week_of_year_and_day_date"); }    do { // convert the 'week_component' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->week_component, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to week_of_year_and_day_date to be a `week_in_year_number`")); }
-    } while (0);
-    do { // convert the 'day_component' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->day_component, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to week_of_year_and_day_date to be a `day_in_week_number`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<wire_shell>(const DB& db, const LIST& params, wire_shell* in)
-{
-    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to wire_shell"); }    do { // convert the 'wire_shell_extent' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->wire_shell_extent, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to wire_shell to be a `SET [1:?] OF loop`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<year_month>(const DB& db, const LIST& params, year_month* in)
-{
-    size_t base = GenericFill(db, params, static_cast<date*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to year_month"); }    do { // convert the 'month_component' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->month_component, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to year_month to be a `month_in_year_number`")); }
-    } while (0);
-    return base;
-}
-
-}
-}
diff --git a/Engine/lib/assimp/code/Importer/StepFile/StepFileImporter.cpp b/Engine/lib/assimp/code/Importer/StepFile/StepFileImporter.cpp
deleted file mode 100644
index 26c456ac9..000000000
--- a/Engine/lib/assimp/code/Importer/StepFile/StepFileImporter.cpp
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-#ifndef ASSIMP_BUILD_NO_STEP_IMPORTER
-
-#include "StepFileImporter.h"
-#include "../../Importer/STEPParser/STEPFileReader.h"
-#include <assimp/importerdesc.h>
-#include <assimp/DefaultIOSystem.h>
-
-namespace Assimp {
-namespace StepFile {
-
-using namespace STEP;
-
-static const aiImporterDesc desc = { "StepFile Importer",
-                                "",
-                                "",
-                                "",
-                                0,
-                                0,
-                                0,
-                                0,
-                                0,
-                                "stp" };
-
-StepFileImporter::StepFileImporter()
-: BaseImporter() {
-
-}
-
-StepFileImporter::~StepFileImporter() {
-
-}
-
-bool StepFileImporter::CanRead(const std::string& file, IOSystem* pIOHandler, bool checkSig) const {
-    const std::string &extension = GetExtension(file);
-    if ( extension == "stp" || extension == "step" ) {
-        return true;
-    } else if ((!extension.length() || checkSig) && pIOHandler) {
-        const char* tokens[] = { "ISO-10303-21" };
-        const bool found(SearchFileHeaderForToken(pIOHandler, file, tokens, 1));
-        return found;
-    }
-
-    return false;
-}
-
-const aiImporterDesc *StepFileImporter::GetInfo() const {
-    return &desc;
-}
-
-static const std::string mode = "rb";
-static const std::string StepFileSchema = "CONFIG_CONTROL_DESIGN";
-
-void StepFileImporter::InternReadFile(const std::string &file, aiScene* pScene, IOSystem* pIOHandler) {
-    // Read file into memory
-    std::shared_ptr<IOStream> fileStream(pIOHandler->Open(file, mode));
-    if (!fileStream.get()) {
-        throw DeadlyImportError("Failed to open file " + file + ".");
-    }
-
-    std::unique_ptr<STEP::DB> db(STEP::ReadFileHeader(fileStream));
-    const STEP::HeaderInfo& head = static_cast<const STEP::DB&>(*db).GetHeader();
-    if (!head.fileSchema.size() || head.fileSchema != StepFileSchema) {
-        DeadlyImportError("Unrecognized file schema: " + head.fileSchema);
-    }
-}
-
-} // Namespace StepFile
-} // Namespace Assimp
-
-#endif // ASSIMP_BUILD_NO_STEP_IMPORTER
-
diff --git a/Engine/lib/assimp/code/Importer/StepFile/StepReaderGen.h b/Engine/lib/assimp/code/Importer/StepFile/StepReaderGen.h
deleted file mode 100644
index 9eb86c332..000000000
--- a/Engine/lib/assimp/code/Importer/StepFile/StepReaderGen.h
+++ /dev/null
@@ -1,7288 +0,0 @@
-/*
-Open Asset Import Library (ASSIMP)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2018, ASSIMP Development Team
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms, 
-with or without modification, are permitted provided that the 
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the ASSIMP team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the ASSIMP Development Team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** MACHINE-GENERATED by scripts/ICFImporter/CppGenerator.py */
-
-#ifndef INCLUDED_STEPFILE_READER_GEN_H
-#define INCLUDED_STEPFILE_READER_GEN_H
-
-#include "code/Step/STEPFile.h"
-
-namespace Assimp {
-namespace StepFile {
-	using namespace STEP;
-	using namespace STEP::EXPRESS;
-	
-	
-	struct NotImplemented : public ObjectHelper<NotImplemented,0> {
-		
-	};
-	
-
-	// ******************************************************************************
-	// StepFile Custom data types
-	// ******************************************************************************
-
-
-    // C++ wrapper type for absorbed_dose_measure
-    typedef REAL absorbed_dose_measure;
-    // C++ wrapper type for acceleration_measure
-    typedef REAL acceleration_measure;
-    // C++ wrapper type for action_items
-    typedef SELECT action_items;
-    // C++ wrapper type for action_method_items
-    typedef SELECT action_method_items;
-    // C++ wrapper type for action_request_item
-    typedef SELECT action_request_item;
-    // C++ wrapper type for ahead_or_behind
-    typedef ENUMERATION ahead_or_behind;
-    // C++ wrapper type for amount_of_substance_measure
-    typedef REAL amount_of_substance_measure;
-    // C++ wrapper type for angle_direction_reference_select
-    typedef SELECT angle_direction_reference_select;
-    // C++ wrapper type for angle_direction_reference_with_a2p3d_select
-    typedef SELECT angle_direction_reference_with_a2p3d_select;
-    // C++ wrapper type for angle_relator
-    typedef ENUMERATION angle_relator;
-    // C++ wrapper type for annotation_plane_element
-    typedef SELECT annotation_plane_element;
-    // C++ wrapper type for annotation_representation_select
-    typedef SELECT annotation_representation_select;
-    // C++ wrapper type for annotation_symbol_occurrence_item
-    typedef SELECT annotation_symbol_occurrence_item;
-    // C++ wrapper type for annotation_text_occurrence_item
-    typedef SELECT annotation_text_occurrence_item;
-    // C++ wrapper type for approval_item
-    typedef SELECT approval_item;
-    // C++ wrapper type for approved_item
-    typedef SELECT approved_item;
-    // C++ wrapper type for area_measure
-    typedef REAL area_measure;
-    // C++ wrapper type for area_or_view
-    typedef SELECT area_or_view;
-    // C++ wrapper type for attribute_classification_item
-    typedef SELECT attribute_classification_item;
-    // C++ wrapper type for attribute_language_item
-    typedef SELECT attribute_language_item;
-    // C++ wrapper type for attribute_type
-    typedef SELECT attribute_type;
-    // C++ wrapper type for axis2_placement
-    typedef SELECT axis2_placement;
-    // C++ wrapper type for b_spline_curve_form
-    typedef ENUMERATION b_spline_curve_form;
-    // C++ wrapper type for b_spline_surface_form
-    typedef ENUMERATION b_spline_surface_form;
-    // C++ wrapper type for base_solid_select
-    typedef SELECT base_solid_select;
-    // C++ wrapper type for blend_end_condition_select
-    typedef SELECT blend_end_condition_select;
-    // C++ wrapper type for blend_radius_variation_type
-    typedef ENUMERATION blend_radius_variation_type;
-    // C++ wrapper type for boolean_operand
-    typedef SELECT boolean_operand;
-    // C++ wrapper type for boolean_operator
-    typedef ENUMERATION boolean_operator;
-    // C++ wrapper type for box_characteristic_select
-    typedef SELECT box_characteristic_select;
-    // C++ wrapper type for box_height
-    typedef REAL box_height;
-    // C++ wrapper type for box_rotate_angle
-    typedef REAL box_rotate_angle;
-    // C++ wrapper type for box_slant_angle
-    typedef REAL box_slant_angle;
-    // C++ wrapper type for box_width
-    typedef REAL box_width;
-    // C++ wrapper type for camera_model_d3_multi_clipping_interection_select
-    typedef SELECT camera_model_d3_multi_clipping_interection_select;
-    // C++ wrapper type for camera_model_d3_multi_clipping_union_select
-    typedef SELECT camera_model_d3_multi_clipping_union_select;
-    // C++ wrapper type for capacitance_measure
-    typedef REAL capacitance_measure;
-    // C++ wrapper type for category_usage_item
-    typedef SELECT category_usage_item;
-    // C++ wrapper type for cc_classified_item
-    typedef SELECT cc_classified_item;
-    // C++ wrapper type for cc_person_organization_item
-    typedef SELECT cc_person_organization_item;
-    // C++ wrapper type for cc_specified_item
-    typedef SELECT cc_specified_item;
-    // C++ wrapper type for celsius_temperature_measure
-    typedef REAL celsius_temperature_measure;
-    // C++ wrapper type for central_or_parallel
-    typedef ENUMERATION central_or_parallel;
-    // C++ wrapper type for certification_item
-    typedef SELECT certification_item;
-    // C++ wrapper type for certified_item
-    typedef SELECT certified_item;
-    // C++ wrapper type for change_request_item
-    typedef SELECT change_request_item;
-    // C++ wrapper type for character_spacing_select
-    typedef SELECT character_spacing_select;
-    // C++ wrapper type for character_style_select
-    typedef SELECT character_style_select;
-    // C++ wrapper type for characterized_action_definition
-    typedef SELECT characterized_action_definition;
-    // C++ wrapper type for characterized_definition
-    typedef SELECT characterized_definition;
-    // C++ wrapper type for characterized_material_property
-    typedef SELECT characterized_material_property;
-    // C++ wrapper type for characterized_product_composition_value
-    typedef SELECT characterized_product_composition_value;
-    // C++ wrapper type for characterized_product_definition
-    typedef SELECT characterized_product_definition;
-    // C++ wrapper type for class_usage_effectivity_context_item
-    typedef SELECT class_usage_effectivity_context_item;
-    // C++ wrapper type for classification_item
-    typedef SELECT classification_item;
-    // C++ wrapper type for classified_item
-    typedef SELECT classified_item;
-    // C++ wrapper type for compound_item_definition
-    typedef SELECT compound_item_definition;
-    // C++ wrapper type for conductance_measure
-    typedef REAL conductance_measure;
-    // C++ wrapper type for configuration_design_item
-    typedef SELECT configuration_design_item;
-    // C++ wrapper type for configured_effectivity_context_item
-    typedef SELECT configured_effectivity_context_item;
-    // C++ wrapper type for configured_effectivity_item
-    typedef SELECT configured_effectivity_item;
-    // C++ wrapper type for constructive_geometry_representation_or_shape_represenation
-    typedef SELECT constructive_geometry_representation_or_shape_represenation;
-    // C++ wrapper type for context_dependent_measure
-    typedef REAL context_dependent_measure;
-    // C++ wrapper type for contract_item
-    typedef SELECT contract_item;
-    // C++ wrapper type for contracted_item
-    typedef SELECT contracted_item;
-    // C++ wrapper type for count_measure
-    typedef NUMBER count_measure;
-    // C++ wrapper type for csg_primitive
-    typedef SELECT csg_primitive;
-    // C++ wrapper type for csg_select
-    typedef SELECT csg_select;
-    // C++ wrapper type for curve_font_or_scaled_curve_font_select
-    typedef SELECT curve_font_or_scaled_curve_font_select;
-    // C++ wrapper type for curve_on_surface
-    typedef SELECT curve_on_surface;
-    // C++ wrapper type for curve_or_annotation_curve_occurrence
-    typedef SELECT curve_or_annotation_curve_occurrence;
-    // C++ wrapper type for curve_or_render
-    typedef SELECT curve_or_render;
-    // C++ wrapper type for curve_style_font_select
-    typedef SELECT curve_style_font_select;
-    // C++ wrapper type for date_and_time_item
-    typedef SELECT date_and_time_item;
-    // C++ wrapper type for date_item
-    typedef SELECT date_item;
-    // C++ wrapper type for date_time_item
-    typedef SELECT date_time_item;
-    // C++ wrapper type for date_time_or_event_occurrence
-    typedef SELECT date_time_or_event_occurrence;
-    // C++ wrapper type for date_time_select
-    typedef SELECT date_time_select;
-    // C++ wrapper type for day_in_month_number
-    typedef INTEGER day_in_month_number;
-    // C++ wrapper type for day_in_week_number
-    typedef INTEGER day_in_week_number;
-    // C++ wrapper type for day_in_year_number
-    typedef INTEGER day_in_year_number;
-    // C++ wrapper type for defined_symbol_select
-    typedef SELECT defined_symbol_select;
-    // C++ wrapper type for derived_property_select
-    typedef SELECT derived_property_select;
-    // C++ wrapper type for description_attribute_select
-    typedef SELECT description_attribute_select;
-    // C++ wrapper type for descriptive_measure
-    typedef STRING descriptive_measure;
-    // C++ wrapper type for dimension_count
-    typedef INTEGER dimension_count;
-    // C++ wrapper type for dimension_extent_usage
-    typedef ENUMERATION dimension_extent_usage;
-    // C++ wrapper type for dimensional_characteristic
-    typedef SELECT dimensional_characteristic;
-    // C++ wrapper type for direction_count_select
-    typedef SELECT direction_count_select;
-    // C++ wrapper type for document_identifier_assigned_item
-    typedef SELECT document_identifier_assigned_item;
-    // C++ wrapper type for document_reference_item
-    typedef SELECT document_reference_item;
-    // C++ wrapper type for dose_equivalent_measure
-    typedef REAL dose_equivalent_measure;
-    // C++ wrapper type for draughting_callout_element
-    typedef SELECT draughting_callout_element;
-    // C++ wrapper type for draughting_model_item_association_select
-    typedef SELECT draughting_model_item_association_select;
-    // C++ wrapper type for draughting_model_item_select
-    typedef SELECT draughting_model_item_select;
-    // C++ wrapper type for draughting_titled_item
-    typedef SELECT draughting_titled_item;
-    // C++ wrapper type for effectivity_item
-    typedef SELECT effectivity_item;
-    // C++ wrapper type for electric_charge_measure
-    typedef REAL electric_charge_measure;
-    // C++ wrapper type for electric_current_measure
-    typedef REAL electric_current_measure;
-    // C++ wrapper type for electric_potential_measure
-    typedef REAL electric_potential_measure;
-    // C++ wrapper type for energy_measure
-    typedef REAL energy_measure;
-    // C++ wrapper type for event_occurrence_item
-    typedef SELECT event_occurrence_item;
-    // C++ wrapper type for external_identification_item
-    typedef SELECT external_identification_item;
-    // C++ wrapper type for fill_area_style_tile_shape_select
-    typedef SELECT fill_area_style_tile_shape_select;
-    // C++ wrapper type for fill_style_select
-    typedef SELECT fill_style_select;
-    // C++ wrapper type for font_select
-    typedef SELECT font_select;
-    // C++ wrapper type for force_measure
-    typedef REAL force_measure;
-    // C++ wrapper type for founded_item_select
-    typedef SELECT founded_item_select;
-    // C++ wrapper type for frequency_measure
-    typedef REAL frequency_measure;
-    // C++ wrapper type for generalized_surface_select
-    typedef SELECT generalized_surface_select;
-    // C++ wrapper type for geometric_item_specific_usage_select
-    typedef SELECT geometric_item_specific_usage_select;
-    // C++ wrapper type for geometric_set_select
-    typedef SELECT geometric_set_select;
-    // C++ wrapper type for groupable_item
-    typedef SELECT groupable_item;
-    // C++ wrapper type for hour_in_day
-    typedef INTEGER hour_in_day;
-    // C++ wrapper type for id_attribute_select
-    typedef SELECT id_attribute_select;
-    // C++ wrapper type for identification_item
-    typedef SELECT identification_item;
-    // C++ wrapper type for identifier
-    typedef STRING identifier;
-    // C++ wrapper type for illuminance_measure
-    typedef REAL illuminance_measure;
-    // C++ wrapper type for inductance_measure
-    typedef REAL inductance_measure;
-    // C++ wrapper type for instance_usage_context_select
-    typedef SELECT instance_usage_context_select;
-    // C++ wrapper type for invisibility_context
-    typedef SELECT invisibility_context;
-    // C++ wrapper type for invisible_item
-    typedef SELECT invisible_item;
-    // C++ wrapper type for ir_usage_item
-    typedef SELECT ir_usage_item;
-    // C++ wrapper type for knot_type
-    typedef ENUMERATION knot_type;
-    // C++ wrapper type for label
-    typedef STRING label;
-    // C++ wrapper type for layered_item
-    typedef SELECT layered_item;
-    // C++ wrapper type for length_measure
-    typedef REAL length_measure;
-    // C++ wrapper type for limit_condition
-    typedef ENUMERATION limit_condition;
-    // C++ wrapper type for list_of_reversible_topology_item
-    typedef ListOf< SELECT, 0, 0 > list_of_reversible_topology_item;
-    // C++ wrapper type for luminous_flux_measure
-    typedef REAL luminous_flux_measure;
-    // C++ wrapper type for luminous_intensity_measure
-    typedef REAL luminous_intensity_measure;
-    // C++ wrapper type for magnetic_flux_density_measure
-    typedef REAL magnetic_flux_density_measure;
-    // C++ wrapper type for magnetic_flux_measure
-    typedef REAL magnetic_flux_measure;
-    // C++ wrapper type for marker_select
-    typedef SELECT marker_select;
-    // C++ wrapper type for marker_type
-    typedef ENUMERATION marker_type;
-    // C++ wrapper type for mass_measure
-    typedef REAL mass_measure;
-    // C++ wrapper type for measure_value
-    typedef SELECT measure_value;
-    // C++ wrapper type for mechanical_design_and_draughting_relationship_select
-    typedef SELECT mechanical_design_and_draughting_relationship_select;
-    // C++ wrapper type for mechanical_design_geometric_presentation_area_items
-    typedef SELECT mechanical_design_geometric_presentation_area_items;
-    // C++ wrapper type for mechanical_design_geometric_presentation_representation_items
-    typedef SELECT mechanical_design_geometric_presentation_representation_items;
-    // C++ wrapper type for message
-    typedef STRING message;
-    // C++ wrapper type for minute_in_hour
-    typedef INTEGER minute_in_hour;
-    // C++ wrapper type for month_in_year_number
-    typedef INTEGER month_in_year_number;
-    // C++ wrapper type for multi_language_attribute_item
-    typedef SELECT multi_language_attribute_item;
-    // C++ wrapper type for name_attribute_select
-    typedef SELECT name_attribute_select;
-    // C++ wrapper type for name_item
-    typedef SELECT name_item;
-    // C++ wrapper type for non_negative_length_measure
-    typedef REAL non_negative_length_measure;
-    // C++ wrapper type for nonnegative_integer
-    typedef INTEGER nonnegative_integer;
-    // C++ wrapper type for null_style
-    typedef ENUMERATION null_style;
-    // C++ wrapper type for numeric_measure
-    typedef NUMBER numeric_measure;
-    // C++ wrapper type for organization_item
-    typedef SELECT organization_item;
-    // C++ wrapper type for orientation_basis_select
-    typedef SELECT orientation_basis_select;
-    // C++ wrapper type for parameter_value
-    typedef REAL parameter_value;
-    // C++ wrapper type for pcurve_or_surface
-    typedef SELECT pcurve_or_surface;
-    // C++ wrapper type for person_and_organization_item
-    typedef SELECT person_and_organization_item;
-    // C++ wrapper type for person_organization_select
-    typedef SELECT person_organization_select;
-    // C++ wrapper type for picture_representation_item_select
-    typedef SELECT picture_representation_item_select;
-    // C++ wrapper type for plane_angle_measure
-    typedef REAL plane_angle_measure;
-    // C++ wrapper type for plane_or_planar_box
-    typedef SELECT plane_or_planar_box;
-    // C++ wrapper type for point_and_vector_member
-    typedef SELECT point_and_vector_member;
-    // C++ wrapper type for point_and_vector_members
-    typedef ListOf< SELECT, 2, 3 > point_and_vector_members;
-    // C++ wrapper type for positive_integer
-    typedef INTEGER positive_integer;
-    // C++ wrapper type for positive_length_measure
-    typedef REAL positive_length_measure;
-    // C++ wrapper type for positive_plane_angle_measure
-    typedef REAL positive_plane_angle_measure;
-    // C++ wrapper type for positive_ratio_measure
-    typedef REAL positive_ratio_measure;
-    // C++ wrapper type for power_measure
-    typedef REAL power_measure;
-    // C++ wrapper type for preferred_surface_curve_representation
-    typedef ENUMERATION preferred_surface_curve_representation;
-    // C++ wrapper type for presentable_text
-    typedef STRING presentable_text;
-    // C++ wrapper type for presentation_representation_select
-    typedef SELECT presentation_representation_select;
-    // C++ wrapper type for presentation_size_assignment_select
-    typedef SELECT presentation_size_assignment_select;
-    // C++ wrapper type for presentation_style_select
-    typedef SELECT presentation_style_select;
-    // C++ wrapper type for presented_item_select
-    typedef SELECT presented_item_select;
-    // C++ wrapper type for pressure_measure
-    typedef REAL pressure_measure;
-    // C++ wrapper type for product_definition_or_assembly_relationship
-    typedef SELECT product_definition_or_assembly_relationship;
-    // C++ wrapper type for product_definition_or_breakdown_element_usage
-    typedef SELECT product_definition_or_breakdown_element_usage;
-    // C++ wrapper type for product_definition_or_product_definition_relationship
-    typedef SELECT product_definition_or_product_definition_relationship;
-    // C++ wrapper type for product_or_formation_or_definition
-    typedef SELECT product_or_formation_or_definition;
-    // C++ wrapper type for project_item
-    typedef SELECT project_item;
-    // C++ wrapper type for radioactivity_measure
-    typedef REAL radioactivity_measure;
-    // C++ wrapper type for ratio_measure
-    typedef REAL ratio_measure;
-    // C++ wrapper type for rendering_properties_select
-    typedef SELECT rendering_properties_select;
-    // C++ wrapper type for represented_definition
-    typedef SELECT represented_definition;
-    // C++ wrapper type for requirement_assigned_item
-    typedef SELECT requirement_assigned_item;
-    // C++ wrapper type for requirement_satisfaction_item
-    typedef SELECT requirement_satisfaction_item;
-    // C++ wrapper type for requirement_source_item
-    typedef SELECT requirement_source_item;
-    // C++ wrapper type for resistance_measure
-    typedef REAL resistance_measure;
-    // C++ wrapper type for reversible_topology
-    typedef SELECT reversible_topology;
-    // C++ wrapper type for reversible_topology_item
-    typedef SELECT reversible_topology_item;
-    // C++ wrapper type for role_select
-    typedef SELECT role_select;
-    // C++ wrapper type for rule_superseded_item
-    typedef SELECT rule_superseded_item;
-    // C++ wrapper type for second_in_minute
-    typedef REAL second_in_minute;
-    // C++ wrapper type for security_classification_item
-    typedef SELECT security_classification_item;
-    // C++ wrapper type for set_of_reversible_topology_item
-    typedef ListOf< SELECT, 0, 0 > set_of_reversible_topology_item;
-    // C++ wrapper type for shading_curve_method
-    typedef ENUMERATION shading_curve_method;
-    // C++ wrapper type for shading_surface_method
-    typedef ENUMERATION shading_surface_method;
-    // C++ wrapper type for shape_definition
-    typedef SELECT shape_definition;
-    // C++ wrapper type for shell
-    typedef SELECT shell;
-    // C++ wrapper type for si_prefix
-    typedef ENUMERATION si_prefix;
-    // C++ wrapper type for si_unit_name
-    typedef ENUMERATION si_unit_name;
-    // C++ wrapper type for size_select
-    typedef SELECT size_select;
-    // C++ wrapper type for sketch_basis_select
-    typedef SELECT sketch_basis_select;
-    // C++ wrapper type for solid_angle_measure
-    typedef REAL solid_angle_measure;
-    // C++ wrapper type for source
-    typedef ENUMERATION source;
-    // C++ wrapper type for source_item
-    typedef SELECT source_item;
-    // C++ wrapper type for start_request_item
-    typedef SELECT start_request_item;
-    // C++ wrapper type for string_representation_item_select
-    typedef SELECT string_representation_item_select;
-    // C++ wrapper type for style_context_select
-    typedef SELECT style_context_select;
-    // C++ wrapper type for surface_side
-    typedef ENUMERATION surface_side;
-    // C++ wrapper type for surface_side_style_select
-    typedef SELECT surface_side_style_select;
-    // C++ wrapper type for surface_style_element_select
-    typedef SELECT surface_style_element_select;
-    // C++ wrapper type for symbol_style_select
-    typedef SELECT symbol_style_select;
-    // C++ wrapper type for text
-    typedef STRING text;
-    // C++ wrapper type for text_alignment
-    typedef STRING text_alignment;
-    // C++ wrapper type for text_delineation
-    typedef STRING text_delineation;
-    // C++ wrapper type for text_or_character
-    typedef SELECT text_or_character;
-    // C++ wrapper type for text_path
-    typedef ENUMERATION text_path;
-    // C++ wrapper type for text_string_representation_item
-    typedef SELECT text_string_representation_item;
-    // C++ wrapper type for thermodynamic_temperature_measure
-    typedef REAL thermodynamic_temperature_measure;
-    // C++ wrapper type for time_interval_item
-    typedef SELECT time_interval_item;
-    // C++ wrapper type for time_measure
-    typedef REAL time_measure;
-    // C++ wrapper type for tolerance_method_definition
-    typedef SELECT tolerance_method_definition;
-    // C++ wrapper type for transformation
-    typedef SELECT transformation;
-    // C++ wrapper type for transition_code
-    typedef ENUMERATION transition_code;
-    // C++ wrapper type for trim_condition_select
-    typedef SELECT trim_condition_select;
-    // C++ wrapper type for trim_intent
-    typedef ENUMERATION trim_intent;
-    // C++ wrapper type for trimming_preference
-    typedef ENUMERATION trimming_preference;
-    // C++ wrapper type for trimming_select
-    typedef SELECT trimming_select;
-    // C++ wrapper type for u_direction_count
-    typedef INTEGER u_direction_count;
-    // C++ wrapper type for unit
-    typedef SELECT unit;
-    // C++ wrapper type for v_direction_count
-    typedef INTEGER v_direction_count;
-    // C++ wrapper type for value_qualifier
-    typedef SELECT value_qualifier;
-    // C++ wrapper type for vector_or_direction
-    typedef SELECT vector_or_direction;
-    // C++ wrapper type for velocity_measure
-    typedef REAL velocity_measure;
-    // C++ wrapper type for volume_measure
-    typedef REAL volume_measure;
-    // C++ wrapper type for week_in_year_number
-    typedef INTEGER week_in_year_number;
-    // C++ wrapper type for work_item
-    typedef SELECT work_item;
-    // C++ wrapper type for year_number
-    typedef INTEGER year_number;
-
-
-	// ******************************************************************************
-	// StepFile Entities
-	// ******************************************************************************
-
-	struct measure_with_unit;
-	struct absorbed_dose_measure_with_unit;
-	struct derived_unit;
-	struct absorbed_dose_unit;
-	struct abstract_variable;
-	struct acceleration_measure_with_unit;
-	struct acceleration_unit;
-	struct action;
-	struct action_assignment;
-	typedef NotImplemented action_directive; // (not currently used by Assimp)
-	struct action_method;
-	struct action_method_assignment;
-	struct action_method_relationship;
-	typedef NotImplemented action_method_role; // (not currently used by Assimp)
-	typedef NotImplemented action_property; // (not currently used by Assimp)
-	typedef NotImplemented action_property_representation; // (not currently used by Assimp)
-	typedef NotImplemented action_relationship; // (not currently used by Assimp)
-	struct action_request_assignment;
-	typedef NotImplemented action_request_solution; // (not currently used by Assimp)
-	typedef NotImplemented action_request_status; // (not currently used by Assimp)
-	typedef NotImplemented action_status; // (not currently used by Assimp)
-	struct address;
-	struct representation;
-	struct shape_representation;
-	struct advanced_brep_shape_representation;
-	struct face_surface;
-	struct advanced_face;
-	typedef NotImplemented alternate_product_relationship; // (not currently used by Assimp)
-	struct amount_of_substance_measure_with_unit;
-	struct named_unit;
-	struct amount_of_substance_unit;
-	struct angle_direction_reference;
-	struct representation_item;
-	struct geometric_representation_item;
-	struct draughting_callout;
-	struct dimension_curve_directed_callout;
-	struct angular_dimension;
-	struct shape_aspect_relationship;
-	struct dimensional_location;
-	struct angular_location;
-	struct dimensional_size;
-	struct angular_size;
-	struct geometric_tolerance;
-	struct geometric_tolerance_with_datum_reference;
-	struct angularity_tolerance;
-	struct styled_item;
-	struct annotation_occurrence;
-	struct annotation_curve_occurrence;
-	struct annotation_fill_area;
-	struct annotation_fill_area_occurrence;
-	struct annotation_occurrence_relationship;
-	struct annotation_occurrence_associativity;
-	struct annotation_plane;
-	struct annotation_symbol_occurrence;
-	struct annotation_subfigure_occurrence;
-	struct mapped_item;
-	struct annotation_symbol;
-	struct annotation_text;
-	struct annotation_text_character;
-	struct annotation_text_occurrence;
-	struct shape_aspect;
-	struct derived_shape_aspect;
-	struct apex;
-	typedef NotImplemented application_context; // (not currently used by Assimp)
-	struct application_context_element;
-	typedef NotImplemented application_protocol_definition; // (not currently used by Assimp)
-	struct applied_action_assignment;
-	struct applied_action_method_assignment;
-	struct applied_action_request_assignment;
-	struct approval_assignment;
-	struct applied_approval_assignment;
-	struct attribute_classification_assignment;
-	struct applied_attribute_classification_assignment;
-	struct certification_assignment;
-	struct applied_certification_assignment;
-	struct classification_assignment;
-	struct applied_classification_assignment;
-	struct contract_assignment;
-	struct applied_contract_assignment;
-	struct date_and_time_assignment;
-	struct applied_date_and_time_assignment;
-	struct date_assignment;
-	struct applied_date_assignment;
-	struct document_reference;
-	struct applied_document_reference;
-	struct document_usage_constraint_assignment;
-	struct applied_document_usage_constraint_assignment;
-	struct effectivity_assignment;
-	struct applied_effectivity_assignment;
-	struct event_occurrence_assignment;
-	struct applied_event_occurrence_assignment;
-	struct identification_assignment;
-	struct external_identification_assignment;
-	struct applied_external_identification_assignment;
-	struct group_assignment;
-	struct applied_group_assignment;
-	struct applied_identification_assignment;
-	struct name_assignment;
-	struct applied_name_assignment;
-	struct organization_assignment;
-	struct applied_organization_assignment;
-	struct organizational_project_assignment;
-	struct applied_organizational_project_assignment;
-	struct person_and_organization_assignment;
-	struct applied_person_and_organization_assignment;
-	struct presented_item;
-	struct applied_presented_item;
-	struct security_classification_assignment;
-	struct applied_security_classification_assignment;
-	struct time_interval_assignment;
-	struct applied_time_interval_assignment;
-	struct applied_usage_right;
-	typedef NotImplemented approval; // (not currently used by Assimp)
-	typedef NotImplemented approval_date_time; // (not currently used by Assimp)
-	typedef NotImplemented approval_person_organization; // (not currently used by Assimp)
-	typedef NotImplemented approval_relationship; // (not currently used by Assimp)
-	typedef NotImplemented approval_role; // (not currently used by Assimp)
-	typedef NotImplemented approval_status; // (not currently used by Assimp)
-	struct area_in_set;
-	struct area_measure_with_unit;
-	struct area_unit;
-	struct product_definition_relationship;
-	struct product_definition_usage;
-	struct assembly_component_usage;
-	typedef NotImplemented assembly_component_usage_substitute; // (not currently used by Assimp)
-	struct assigned_requirement;
-	struct compound_representation_item;
-	struct atomic_formula;
-	struct attribute_assertion;
-	struct attribute_language_assignment;
-	struct attribute_value_assignment;
-	typedef NotImplemented attribute_value_role; // (not currently used by Assimp)
-	struct auxiliary_geometric_representation_item;
-	struct placement;
-	struct axis1_placement;
-	struct axis2_placement_2d;
-	struct axis2_placement_3d;
-	struct curve;
-	struct bounded_curve;
-	struct b_spline_curve;
-	struct b_spline_curve_with_knots;
-	struct surface;
-	struct bounded_surface;
-	struct b_spline_surface;
-	struct b_spline_surface_with_knots;
-	struct product_definition;
-	struct rule_software_definition;
-	struct rule_definition;
-	struct back_chaining_rule;
-	struct back_chaining_rule_body;
-	struct colour;
-	struct background_colour;
-	struct beveled_sheet_representation;
-	struct bezier_curve;
-	struct bezier_surface;
-	struct generic_expression;
-	struct binary_generic_expression;
-	struct binary_numeric_expression;
-	struct binary_representation_item;
-	struct block;
-	struct expression;
-	struct boolean_expression;
-	struct boolean_literal;
-	struct boolean_representation_item;
-	struct boolean_result;
-	struct composite_curve;
-	struct composite_curve_on_surface;
-	struct boundary_curve;
-	struct bounded_pcurve;
-	struct bounded_surface_curve;
-	struct founded_item;
-	struct box_domain;
-	struct half_space_solid;
-	struct boxed_half_space;
-	struct breakdown_context;
-	struct breakdown_element_group_assignment;
-	struct breakdown_element_realization;
-	struct breakdown_element_usage;
-	struct breakdown_of;
-	struct solid_model;
-	struct manifold_solid_brep;
-	struct brep_with_voids;
-	struct bytes_representation_item;
-	struct date;
-	struct calendar_date;
-	struct camera_image;
-	struct camera_image_3d_with_scale;
-	struct camera_model;
-	struct camera_model_d3;
-	struct camera_model_d3_multi_clipping;
-	struct camera_model_d3_multi_clipping_intersection;
-	struct camera_model_d3_multi_clipping_union;
-	struct camera_model_d3_with_hlhsr;
-	struct camera_model_with_light_sources;
-	struct representation_map;
-	struct camera_usage;
-	struct capacitance_measure_with_unit;
-	struct capacitance_unit;
-	struct point;
-	struct cartesian_point;
-	struct cartesian_transformation_operator;
-	struct cartesian_transformation_operator_2d;
-	struct cartesian_transformation_operator_3d;
-	struct cc_design_approval;
-	struct cc_design_certification;
-	struct cc_design_contract;
-	struct cc_design_date_and_time_assignment;
-	struct cc_design_person_and_organization_assignment;
-	struct cc_design_security_classification;
-	struct cc_design_specification_reference;
-	struct celsius_temperature_measure_with_unit;
-	struct centre_of_symmetry;
-	typedef NotImplemented certification; // (not currently used by Assimp)
-	typedef NotImplemented certification_type; // (not currently used by Assimp)
-	struct change;
-	struct change_request;
-	typedef NotImplemented character_glyph_font_usage; // (not currently used by Assimp)
-	struct character_glyph_style_outline;
-	struct character_glyph_style_stroke;
-	struct symbol_representation;
-	struct generic_character_glyph_symbol;
-	struct character_glyph_symbol;
-	struct character_glyph_symbol_outline;
-	struct character_glyph_symbol_stroke;
-	struct general_property;
-	struct characteristic_data_column_header;
-	struct general_property_relationship;
-	struct characteristic_data_column_header_link;
-	struct characteristic_data_table_header;
-	struct characteristic_data_table_header_decomposition;
-	struct group;
-	struct characteristic_type;
-	struct characterized_class;
-	struct characterized_object;
-	struct conic;
-	struct circle;
-	struct circular_runout_tolerance;
-	typedef NotImplemented class_t; // (not currently used by Assimp)
-	struct class_by_extension;
-	struct class_by_intension;
-	struct class_system;
-	struct effectivity_context_assignment;
-	struct class_usage_effectivity_context_assignment;
-	typedef NotImplemented classification_role; // (not currently used by Assimp)
-	struct topological_representation_item;
-	struct connected_face_set;
-	struct closed_shell;
-	struct coaxiality_tolerance;
-	struct colour_specification;
-	struct colour_rgb;
-	struct common_datum;
-	struct comparison_expression;
-	struct complex_clause;
-	struct complex_conjunctive_clause;
-	struct complex_disjunctive_clause;
-	struct modified_solid;
-	struct shelled_solid;
-	struct complex_shelled_solid;
-	struct composite_assembly_definition;
-	struct composite_assembly_sequence_definition;
-	struct laminate_table;
-	struct part_laminate_table;
-	struct composite_assembly_table;
-	struct composite_curve_segment;
-	struct material_designation;
-	struct composite_material_designation;
-	struct composite_shape_aspect;
-	struct composite_sheet_representation;
-	struct composite_text;
-	struct composite_text_with_associated_curves;
-	struct composite_text_with_blanking_box;
-	struct composite_text_with_delineation;
-	struct composite_text_with_extent;
-	struct compound_shape_representation;
-	struct concentricity_tolerance;
-	typedef NotImplemented concept_feature_operator; // (not currently used by Assimp)
-	struct concept_feature_relationship;
-	struct concept_feature_relationship_with_condition;
-	struct product_concept_feature;
-	struct conditional_concept_feature;
-	struct conductance_measure_with_unit;
-	struct conductance_unit;
-	struct configuration_item;
-	struct configurable_item;
-	typedef NotImplemented configuration_design; // (not currently used by Assimp)
-	struct effectivity;
-	struct product_definition_effectivity;
-	struct configuration_effectivity;
-	struct configuration_item_relationship;
-	struct configuration_item_hierarchical_relationship;
-	struct configuration_item_revision_sequence;
-	struct configured_effectivity_assignment;
-	struct configured_effectivity_context_assignment;
-	struct conical_stepped_hole_transition;
-	struct elementary_surface;
-	struct conical_surface;
-	struct connected_edge_set;
-	struct connected_face_sub_set;
-	struct constructive_geometry_representation;
-	struct representation_relationship;
-	struct constructive_geometry_representation_relationship;
-	struct contact_ratio_representation;
-	struct invisibility;
-	struct context_dependent_invisibility;
-	struct over_riding_styled_item;
-	struct context_dependent_over_riding_styled_item;
-	typedef NotImplemented context_dependent_shape_representation; // (not currently used by Assimp)
-	struct context_dependent_unit;
-	typedef NotImplemented contract; // (not currently used by Assimp)
-	typedef NotImplemented contract_relationship; // (not currently used by Assimp)
-	typedef NotImplemented contract_type; // (not currently used by Assimp)
-	struct conversion_based_unit;
-	typedef NotImplemented coordinated_universal_time_offset; // (not currently used by Assimp)
-	struct csg_shape_representation;
-	struct csg_solid;
-	struct currency;
-	struct currency_measure_with_unit;
-	struct curve_bounded_surface;
-	struct curve_dimension;
-	struct curve_replica;
-	struct curve_style;
-	struct curve_style_font;
-	struct curve_style_font_and_scaling;
-	struct curve_style_font_pattern;
-	typedef NotImplemented curve_style_rendering; // (not currently used by Assimp)
-	struct curve_swept_solid_shape_representation;
-	struct cylindrical_surface;
-	struct cylindricity_tolerance;
-	typedef NotImplemented data_environment; // (not currently used by Assimp)
-	typedef NotImplemented date_and_time; // (not currently used by Assimp)
-	struct date_representation_item;
-	typedef NotImplemented date_role; // (not currently used by Assimp)
-	struct date_time_representation_item;
-	typedef NotImplemented date_time_role; // (not currently used by Assimp)
-	struct dated_effectivity;
-	struct datum;
-	struct datum_feature;
-	struct datum_feature_callout;
-	struct datum_reference;
-	struct datum_target;
-	struct datum_target_callout;
-	struct default_tolerance_table;
-	struct default_tolerance_table_cell;
-	struct defined_symbol;
-	struct definitional_representation;
-	struct definitional_representation_relationship;
-	struct definitional_representation_relationship_with_same_context;
-	struct degenerate_pcurve;
-	struct toroidal_surface;
-	struct degenerate_toroidal_surface;
-	typedef NotImplemented derived_unit_element; // (not currently used by Assimp)
-	typedef NotImplemented description_attribute; // (not currently used by Assimp)
-	struct descriptive_representation_item;
-	struct product_definition_context;
-	struct design_context;
-	struct design_make_from_relationship;
-	struct diameter_dimension;
-	struct ratio_measure_with_unit;
-	struct dielectric_constant_measure_with_unit;
-	struct dimension_callout;
-	struct draughting_callout_relationship;
-	struct dimension_callout_component_relationship;
-	struct dimension_callout_relationship;
-	struct dimension_curve;
-	struct terminator_symbol;
-	struct dimension_curve_terminator;
-	struct dimension_curve_terminator_to_projection_curve_associativity;
-	struct dimension_pair;
-	typedef NotImplemented dimension_related_tolerance_zone_element; // (not currently used by Assimp)
-	struct dimension_text_associativity;
-	typedef NotImplemented dimensional_characteristic_representation; // (not currently used by Assimp)
-	typedef NotImplemented dimensional_exponents; // (not currently used by Assimp)
-	struct dimensional_location_with_path;
-	struct dimensional_size_with_path;
-	struct executed_action;
-	struct directed_action;
-	struct directed_dimensional_location;
-	struct direction;
-	typedef NotImplemented document; // (not currently used by Assimp)
-	struct document_file;
-	struct document_identifier;
-	struct document_identifier_assignment;
-	struct document_product_association;
-	struct document_product_equivalence;
-	typedef NotImplemented document_relationship; // (not currently used by Assimp)
-	typedef NotImplemented document_representation_type; // (not currently used by Assimp)
-	typedef NotImplemented document_type; // (not currently used by Assimp)
-	typedef NotImplemented document_usage_constraint; // (not currently used by Assimp)
-	typedef NotImplemented document_usage_role; // (not currently used by Assimp)
-	struct dose_equivalent_measure_with_unit;
-	struct dose_equivalent_unit;
-	struct double_offset_shelled_solid;
-	struct item_defined_transformation;
-	struct transformation_with_derived_angle;
-	struct draped_defined_transformation;
-	struct draughting_annotation_occurrence;
-	struct draughting_elements;
-	struct draughting_model;
-	struct item_identified_representation_usage;
-	struct draughting_model_item_association;
-	struct pre_defined_colour;
-	struct draughting_pre_defined_colour;
-	struct pre_defined_item;
-	struct pre_defined_curve_font;
-	struct draughting_pre_defined_curve_font;
-	struct pre_defined_text_font;
-	struct draughting_pre_defined_text_font;
-	struct draughting_subfigure_representation;
-	struct draughting_symbol_representation;
-	struct text_literal;
-	struct text_literal_with_delineation;
-	struct draughting_text_literal_with_delineation;
-	typedef NotImplemented draughting_title; // (not currently used by Assimp)
-	typedef NotImplemented drawing_definition; // (not currently used by Assimp)
-	struct presentation_set;
-	struct drawing_revision;
-	typedef NotImplemented drawing_revision_sequence; // (not currently used by Assimp)
-	struct presentation_representation;
-	struct presentation_area;
-	struct drawing_sheet_revision;
-	struct drawing_sheet_revision_sequence;
-	struct drawing_sheet_revision_usage;
-	struct edge;
-	struct edge_based_wireframe_model;
-	struct edge_based_wireframe_shape_representation;
-	struct edge_blended_solid;
-	struct edge_curve;
-	struct edge_loop;
-	typedef NotImplemented effectivity_context_role; // (not currently used by Assimp)
-	typedef NotImplemented effectivity_relationship; // (not currently used by Assimp)
-	struct electric_charge_measure_with_unit;
-	struct electric_charge_unit;
-	struct electric_current_measure_with_unit;
-	struct electric_current_unit;
-	struct electric_potential_measure_with_unit;
-	struct electric_potential_unit;
-	struct elementary_brep_shape_representation;
-	struct ellipse;
-	struct energy_measure_with_unit;
-	struct energy_unit;
-	struct property_definition;
-	struct fact_type;
-	struct entity_assertion;
-	struct enum_reference_prefix;
-	typedef NotImplemented environment; // (not currently used by Assimp)
-	struct evaluated_characteristic;
-	struct evaluated_degenerate_pcurve;
-	struct evaluation_product_definition;
-	struct event_occurrence;
-	typedef NotImplemented event_occurrence_relationship; // (not currently used by Assimp)
-	typedef NotImplemented event_occurrence_role; // (not currently used by Assimp)
-	struct product_concept_feature_category;
-	struct exclusive_product_concept_feature_category;
-	struct uncertainty_qualifier;
-	struct standard_uncertainty;
-	struct expanded_uncertainty;
-	struct representation_item_relationship;
-	struct explicit_procedural_representation_item_relationship;
-	struct explicit_procedural_geometric_representation_item_relationship;
-	struct explicit_procedural_representation_relationship;
-	struct explicit_procedural_shape_representation_relationship;
-	struct expression_conversion_based_unit;
-	struct extension;
-	struct extent;
-	struct external_source;
-	struct external_class_library;
-	typedef NotImplemented external_source_relationship; // (not currently used by Assimp)
-	struct externally_defined_class;
-	struct externally_defined_colour;
-	struct externally_defined_context_dependent_unit;
-	struct externally_defined_conversion_based_unit;
-	struct externally_defined_currency;
-	struct externally_defined_item;
-	struct externally_defined_curve_font;
-	struct externally_defined_dimension_definition;
-	struct externally_defined_general_property;
-	struct externally_defined_hatch_style;
-	typedef NotImplemented externally_defined_item_relationship; // (not currently used by Assimp)
-	struct externally_defined_marker;
-	struct picture_representation_item;
-	struct externally_defined_picture_representation_item;
-	struct externally_defined_representation_item;
-	struct externally_defined_string;
-	struct externally_defined_symbol;
-	struct externally_defined_terminator_symbol;
-	struct externally_defined_text_font;
-	struct externally_defined_tile;
-	struct externally_defined_tile_style;
-	struct swept_area_solid;
-	struct extruded_area_solid;
-	struct swept_face_solid;
-	struct extruded_face_solid;
-	struct extruded_face_solid_with_trim_conditions;
-	struct extruded_face_solid_with_draft_angle;
-	struct extruded_face_solid_with_multiple_draft_angles;
-	struct face;
-	struct face_based_surface_model;
-	struct face_bound;
-	struct face_outer_bound;
-	struct faceted_brep;
-	struct faceted_brep_shape_representation;
-	struct fill_area_style;
-	typedef NotImplemented fill_area_style_colour; // (not currently used by Assimp)
-	struct fill_area_style_hatching;
-	struct fill_area_style_tile_coloured_region;
-	struct fill_area_style_tile_curve_with_style;
-	struct fill_area_style_tile_symbol_with_style;
-	struct fill_area_style_tiles;
-	struct shape_representation_relationship;
-	struct flat_pattern_ply_representation_relationship;
-	struct flatness_tolerance;
-	struct force_measure_with_unit;
-	struct force_unit;
-	struct forward_chaining_rule;
-	struct forward_chaining_rule_premise;
-	struct frequency_measure_with_unit;
-	struct frequency_unit;
-	struct func;
-	struct functional_breakdown_context;
-	struct functional_element_usage;
-	typedef NotImplemented functionally_defined_transformation; // (not currently used by Assimp)
-	struct general_material_property;
-	typedef NotImplemented general_property_association; // (not currently used by Assimp)
-	struct simple_generic_expression;
-	struct generic_literal;
-	struct generic_variable;
-	struct geometric_alignment;
-	struct geometric_set;
-	struct geometric_curve_set;
-	struct geometric_intersection;
-	struct geometric_item_specific_usage;
-	struct geometric_model_element_relationship;
-	struct representation_context;
-	struct geometric_representation_context;
-	typedef NotImplemented geometric_tolerance_relationship; // (not currently used by Assimp)
-	struct geometric_tolerance_with_defined_unit;
-	struct geometrical_tolerance_callout;
-	struct geometrically_bounded_2d_wireframe_representation;
-	struct geometrically_bounded_surface_shape_representation;
-	struct geometrically_bounded_wireframe_shape_representation;
-	struct global_assignment;
-	struct global_uncertainty_assigned_context;
-	struct global_unit_assigned_context;
-	struct ground_fact;
-	typedef NotImplemented group_relationship; // (not currently used by Assimp)
-	struct hardness_representation;
-	struct hidden_element_over_riding_styled_item;
-	struct hyperbola;
-	typedef NotImplemented id_attribute; // (not currently used by Assimp)
-	typedef NotImplemented identification_role; // (not currently used by Assimp)
-	struct illuminance_measure_with_unit;
-	struct illuminance_unit;
-	struct included_text_block;
-	struct inclusion_product_concept_feature;
-	struct user_selected_elements;
-	struct indirectly_selected_elements;
-	struct indirectly_selected_shape_elements;
-	struct inductance_measure_with_unit;
-	struct inductance_unit;
-	struct information_right;
-	struct information_usage_right;
-	struct instance_usage_context_assignment;
-	struct instanced_feature;
-	struct literal_number;
-	struct int_literal;
-	struct integer_representation_item;
-	struct surface_curve;
-	struct intersection_curve;
-	struct interval_expression;
-	struct iso4217_currency;
-	struct known_source;
-	struct laid_defined_transformation;
-	struct language;
-	struct leader_curve;
-	struct leader_directed_callout;
-	struct leader_directed_dimension;
-	struct leader_terminator;
-	struct length_measure_with_unit;
-	struct length_unit;
-	struct light_source;
-	struct light_source_ambient;
-	struct light_source_directional;
-	struct light_source_positional;
-	struct light_source_spot;
-	typedef NotImplemented limits_and_fits; // (not currently used by Assimp)
-	struct line;
-	struct line_profile_tolerance;
-	struct linear_dimension;
-	struct simple_clause;
-	struct literal_conjunction;
-	struct literal_disjunction;
-	typedef NotImplemented local_time; // (not currently used by Assimp)
-	struct logical_literal;
-	struct logical_representation_item;
-	struct loop;
-	struct loss_tangent_measure_with_unit;
-	struct lot_effectivity;
-	struct luminous_flux_measure_with_unit;
-	struct luminous_flux_unit;
-	struct luminous_intensity_measure_with_unit;
-	struct luminous_intensity_unit;
-	struct magnetic_flux_density_measure_with_unit;
-	struct magnetic_flux_density_unit;
-	struct magnetic_flux_measure_with_unit;
-	struct magnetic_flux_unit;
-	struct make_from_usage_option;
-	struct manifold_subsurface_shape_representation;
-	struct manifold_surface_shape_representation;
-	struct mass_measure_with_unit;
-	struct mass_unit;
-	typedef NotImplemented material_designation_characterization; // (not currently used by Assimp)
-	struct material_property;
-	struct property_definition_representation;
-	struct material_property_representation;
-	typedef NotImplemented measure_qualification; // (not currently used by Assimp)
-	struct measure_representation_item;
-	struct product_context;
-	struct mechanical_context;
-	struct mechanical_design_and_draughting_relationship;
-	struct mechanical_design_geometric_presentation_area;
-	struct mechanical_design_geometric_presentation_representation;
-	struct mechanical_design_presentation_representation_with_draughting;
-	struct mechanical_design_shaded_presentation_area;
-	struct mechanical_design_shaded_presentation_representation;
-	struct min_and_major_ply_orientation_basis;
-	struct modified_geometric_tolerance;
-	struct modified_solid_with_placed_configuration;
-	struct moments_of_inertia_representation;
-	struct multi_language_attribute_assignment;
-	struct multiple_arity_boolean_expression;
-	struct multiple_arity_generic_expression;
-	struct multiple_arity_numeric_expression;
-	typedef NotImplemented name_attribute; // (not currently used by Assimp)
-	struct next_assembly_usage_occurrence;
-	struct non_manifold_surface_shape_representation;
-	struct null_representation_item;
-	struct numeric_expression;
-	typedef NotImplemented object_role; // (not currently used by Assimp)
-	struct offset_curve_2d;
-	struct offset_curve_3d;
-	struct offset_surface;
-	struct one_direction_repeat_factor;
-	struct open_shell;
-	struct ordinal_date;
-	struct projection_directed_callout;
-	struct ordinate_dimension;
-	typedef NotImplemented organization; // (not currently used by Assimp)
-	typedef NotImplemented organization_relationship; // (not currently used by Assimp)
-	typedef NotImplemented organization_role; // (not currently used by Assimp)
-	struct organizational_address;
-	typedef NotImplemented organizational_project; // (not currently used by Assimp)
-	typedef NotImplemented organizational_project_relationship; // (not currently used by Assimp)
-	typedef NotImplemented organizational_project_role; // (not currently used by Assimp)
-	struct oriented_closed_shell;
-	struct oriented_edge;
-	struct oriented_face;
-	struct oriented_open_shell;
-	struct path;
-	struct oriented_path;
-	struct oriented_surface;
-	struct outer_boundary_curve;
-	struct package_product_concept_feature;
-	struct parabola;
-	struct parallel_offset;
-	struct parallelism_tolerance;
-	struct parametric_representation_context;
-	struct partial_document_with_structured_text_representation_assignment;
-	struct pcurve;
-	struct percentage_laminate_definition;
-	struct zone_structural_makeup;
-	struct percentage_laminate_table;
-	struct percentage_ply_definition;
-	struct perpendicular_to;
-	struct perpendicularity_tolerance;
-	typedef NotImplemented person; // (not currently used by Assimp)
-	typedef NotImplemented person_and_organization; // (not currently used by Assimp)
-	struct person_and_organization_address;
-	typedef NotImplemented person_and_organization_role; // (not currently used by Assimp)
-	struct personal_address;
-	struct physical_breakdown_context;
-	struct physical_element_usage;
-	struct presentation_view;
-	struct picture_representation;
-	struct placed_datum_target_feature;
-	struct placed_feature;
-	struct planar_extent;
-	struct planar_box;
-	struct plane;
-	struct plane_angle_measure_with_unit;
-	struct plane_angle_unit;
-	typedef NotImplemented plus_minus_tolerance; // (not currently used by Assimp)
-	struct ply_laminate_definition;
-	struct ply_laminate_sequence_definition;
-	struct ply_laminate_table;
-	struct point_and_vector;
-	struct point_on_curve;
-	struct point_on_surface;
-	struct point_path;
-	struct point_replica;
-	struct point_style;
-	struct polar_complex_number_literal;
-	struct poly_loop;
-	struct polyline;
-	struct position_tolerance;
-	struct positioned_sketch;
-	struct power_measure_with_unit;
-	struct power_unit;
-	struct pre_defined_symbol;
-	struct pre_defined_dimension_symbol;
-	struct pre_defined_geometrical_tolerance_symbol;
-	struct pre_defined_marker;
-	struct pre_defined_point_marker_symbol;
-	struct pre_defined_surface_condition_symbol;
-	struct pre_defined_surface_side_style;
-	struct pre_defined_terminator_symbol;
-	struct pre_defined_tile;
-	typedef NotImplemented precision_qualifier; // (not currently used by Assimp)
-	struct predefined_picture_representation_item;
-	typedef NotImplemented presentation_layer_assignment; // (not currently used by Assimp)
-	typedef NotImplemented presentation_size; // (not currently used by Assimp)
-	struct presentation_style_assignment;
-	struct presentation_style_by_context;
-	typedef NotImplemented presented_item_representation; // (not currently used by Assimp)
-	struct pressure_measure_with_unit;
-	struct pressure_unit;
-	struct procedural_representation;
-	struct procedural_representation_sequence;
-	struct procedural_shape_representation;
-	struct procedural_shape_representation_sequence;
-	typedef NotImplemented product; // (not currently used by Assimp)
-	struct product_category;
-	struct product_class;
-	typedef NotImplemented product_concept; // (not currently used by Assimp)
-	struct product_concept_context;
-	typedef NotImplemented product_concept_feature_association; // (not currently used by Assimp)
-	struct product_concept_feature_category_usage;
-	typedef NotImplemented product_concept_relationship; // (not currently used by Assimp)
-	typedef NotImplemented product_definition_context_association; // (not currently used by Assimp)
-	typedef NotImplemented product_definition_context_role; // (not currently used by Assimp)
-	struct product_definition_element_relationship;
-	struct product_definition_formation;
-	typedef NotImplemented product_definition_formation_relationship; // (not currently used by Assimp)
-	struct product_definition_formation_with_specified_source;
-	struct product_definition_group_assignment;
-	typedef NotImplemented product_definition_occurrence_relationship; // (not currently used by Assimp)
-	struct product_definition_shape;
-	typedef NotImplemented product_definition_substitute; // (not currently used by Assimp)
-	struct product_definition_with_associated_documents;
-	struct product_identification;
-	struct product_material_composition_relationship;
-	struct product_related_product_category;
-	struct product_specification;
-	struct tolerance_zone_definition;
-	struct projected_zone_definition;
-	struct projection_curve;
-	struct promissory_usage_occurrence;
-	typedef NotImplemented property_definition_relationship; // (not currently used by Assimp)
-	struct qualified_representation_item;
-	struct qualitative_uncertainty;
-	struct quantified_assembly_component_usage;
-	struct quasi_uniform_curve;
-	struct quasi_uniform_surface;
-	struct radioactivity_measure_with_unit;
-	struct radioactivity_unit;
-	struct radius_dimension;
-	struct range_characteristic;
-	struct ratio_unit;
-	struct rational_b_spline_curve;
-	struct rational_b_spline_surface;
-	struct rational_representation_item;
-	struct real_literal;
-	struct real_representation_item;
-	struct rectangular_composite_surface;
-	struct rectangular_trimmed_surface;
-	struct referenced_modified_datum;
-	struct relative_event_occurrence;
-	struct rep_item_group;
-	struct reparametrised_composite_curve_segment;
-	struct representation_relationship_with_transformation;
-	struct requirement_assigned_object;
-	struct requirement_assignment;
-	struct requirement_source;
-	struct requirement_view_definition_relationship;
-	struct resistance_measure_with_unit;
-	struct resistance_unit;
-	struct revolved_area_solid;
-	struct revolved_face_solid;
-	struct revolved_face_solid_with_trim_conditions;
-	struct right_angular_wedge;
-	struct right_circular_cone;
-	struct right_circular_cylinder;
-	struct right_to_usage_association;
-	typedef NotImplemented role_association; // (not currently used by Assimp)
-	struct roundness_tolerance;
-	struct row_representation_item;
-	struct row_value;
-	struct row_variable;
-	struct rule_action;
-	struct rule_condition;
-	struct rule_set;
-	struct rule_set_group;
-	struct rule_superseded_assignment;
-	struct rule_supersedence;
-	struct surface_curve_swept_area_solid;
-	struct ruled_surface_swept_area_solid;
-	struct runout_zone_definition;
-	struct runout_zone_orientation;
-	struct runout_zone_orientation_reference_direction;
-	struct satisfied_requirement;
-	struct satisfies_requirement;
-	struct satisfying_item;
-	struct scalar_variable;
-	struct scattering_parameter;
-	struct sculptured_solid;
-	struct seam_curve;
-	typedef NotImplemented security_classification; // (not currently used by Assimp)
-	typedef NotImplemented security_classification_level; // (not currently used by Assimp)
-	struct serial_numbered_effectivity;
-	struct shape_aspect_associativity;
-	struct shape_aspect_deriving_relationship;
-	struct shape_definition_representation;
-	struct shape_dimension_representation;
-	struct shape_feature_definition;
-	struct shape_representation_with_parameters;
-	struct shell_based_surface_model;
-	struct shell_based_wireframe_model;
-	struct shell_based_wireframe_shape_representation;
-	struct si_absorbed_dose_unit;
-	struct si_capacitance_unit;
-	struct si_conductance_unit;
-	struct si_dose_equivalent_unit;
-	struct si_electric_charge_unit;
-	struct si_electric_potential_unit;
-	struct si_energy_unit;
-	struct si_force_unit;
-	struct si_frequency_unit;
-	struct si_illuminance_unit;
-	struct si_inductance_unit;
-	struct si_magnetic_flux_density_unit;
-	struct si_magnetic_flux_unit;
-	struct si_power_unit;
-	struct si_pressure_unit;
-	struct si_radioactivity_unit;
-	struct si_resistance_unit;
-	struct si_unit;
-	struct simple_boolean_expression;
-	struct simple_numeric_expression;
-	struct slash_expression;
-	struct smeared_material_definition;
-	struct solid_angle_measure_with_unit;
-	struct solid_angle_unit;
-	struct solid_curve_font;
-	struct solid_replica;
-	struct solid_with_chamfered_edges;
-	struct solid_with_angle_based_chamfer;
-	struct solid_with_shape_element_pattern;
-	struct solid_with_circular_pattern;
-	struct solid_with_depression;
-	struct solid_with_pocket;
-	struct solid_with_circular_pocket;
-	struct solid_with_protrusion;
-	struct solid_with_circular_protrusion;
-	struct solid_with_hole;
-	struct solid_with_stepped_round_hole;
-	struct solid_with_conical_bottom_round_hole;
-	struct solid_with_constant_radius_edge_blend;
-	struct solid_with_slot;
-	struct solid_with_curved_slot;
-	struct solid_with_double_offset_chamfer;
-	struct solid_with_flat_bottom_round_hole;
-	struct solid_with_general_pocket;
-	struct solid_with_general_protrusion;
-	struct solid_with_groove;
-	struct solid_with_incomplete_circular_pattern;
-	struct solid_with_rectangular_pattern;
-	struct solid_with_incomplete_rectangular_pattern;
-	struct solid_with_rectangular_pocket;
-	struct solid_with_rectangular_protrusion;
-	struct solid_with_single_offset_chamfer;
-	struct solid_with_spherical_bottom_round_hole;
-	struct solid_with_stepped_round_hole_and_conical_transitions;
-	struct solid_with_straight_slot;
-	struct solid_with_tee_section_slot;
-	struct solid_with_through_depression;
-	struct solid_with_trapezoidal_section_slot;
-	struct solid_with_variable_radius_edge_blend;
-	struct source_for_requirement;
-	struct sourced_requirement;
-	struct specification_definition;
-	struct specified_higher_usage_occurrence;
-	struct sphere;
-	struct spherical_surface;
-	struct start_request;
-	struct start_work;
-	struct straightness_tolerance;
-	struct structured_dimension_callout;
-	struct structured_text_composition;
-	struct structured_text_representation;
-	struct subedge;
-	struct subface;
-	struct supplied_part_relationship;
-	struct surface_condition_callout;
-	struct swept_surface;
-	struct surface_of_linear_extrusion;
-	struct surface_of_revolution;
-	struct surface_patch;
-	struct surface_profile_tolerance;
-	typedef NotImplemented surface_rendering_properties; // (not currently used by Assimp)
-	struct surface_replica;
-	struct surface_side_style;
-	struct surface_style_boundary;
-	struct surface_style_control_grid;
-	struct surface_style_fill_area;
-	struct surface_style_parameter_line;
-	struct surface_style_reflectance_ambient;
-	struct surface_style_reflectance_ambient_diffuse;
-	struct surface_style_reflectance_ambient_diffuse_specular;
-	struct surface_style_rendering;
-	struct surface_style_rendering_with_properties;
-	struct surface_style_segmentation_curve;
-	struct surface_style_silhouette;
-	typedef NotImplemented surface_style_transparent; // (not currently used by Assimp)
-	struct surface_style_usage;
-	struct surface_texture_representation;
-	struct surfaced_open_shell;
-	struct swept_disk_solid;
-	struct symbol;
-	typedef NotImplemented symbol_colour; // (not currently used by Assimp)
-	struct symbol_representation_map;
-	struct symbol_style;
-	struct symbol_target;
-	struct symmetric_shape_aspect;
-	struct symmetry_tolerance;
-	struct table_representation_item;
-	struct tactile_appearance_representation;
-	struct tagged_text_format;
-	struct tagged_text_item;
-	struct tangent;
-	typedef NotImplemented text_font; // (not currently used by Assimp)
-	typedef NotImplemented text_font_family; // (not currently used by Assimp)
-	typedef NotImplemented text_font_in_family; // (not currently used by Assimp)
-	struct text_literal_with_associated_curves;
-	struct text_literal_with_blanking_box;
-	struct text_literal_with_extent;
-	struct text_string_representation;
-	struct text_style;
-	typedef NotImplemented text_style_for_defined_font; // (not currently used by Assimp)
-	struct text_style_with_box_characteristics;
-	struct text_style_with_mirror;
-	struct text_style_with_spacing;
-	struct thermal_resistance_measure_with_unit;
-	struct thermal_resistance_unit;
-	struct thermodynamic_temperature_measure_with_unit;
-	struct thermodynamic_temperature_unit;
-	struct thickened_face_solid;
-	struct thickness_laminate_definition;
-	struct thickness_laminate_table;
-	struct time_interval;
-	struct time_interval_based_effectivity;
-	typedef NotImplemented time_interval_relationship; // (not currently used by Assimp)
-	typedef NotImplemented time_interval_role; // (not currently used by Assimp)
-	struct time_interval_with_bounds;
-	struct time_measure_with_unit;
-	struct time_unit;
-	typedef NotImplemented tolerance_value; // (not currently used by Assimp)
-	struct tolerance_zone;
-	typedef NotImplemented tolerance_zone_form; // (not currently used by Assimp)
-	struct torus;
-	struct total_runout_tolerance;
-	struct track_blended_solid;
-	struct track_blended_solid_with_end_conditions;
-	struct trimmed_curve;
-	struct two_direction_repeat_factor;
-	typedef NotImplemented type_qualifier; // (not currently used by Assimp)
-	struct unary_generic_expression;
-	struct unary_numeric_expression;
-	struct uncertainty_assigned_representation;
-	struct uncertainty_measure_with_unit;
-	struct uniform_curve;
-	struct uniform_resource_identifier;
-	struct uniform_surface;
-	struct usage_association;
-	struct user_defined_curve_font;
-	struct user_defined_marker;
-	struct user_defined_terminator_symbol;
-	struct user_selected_shape_elements;
-	struct value_range;
-	struct value_representation_item;
-	struct variable_semantics;
-	struct variational_representation_item;
-	struct vector;
-	struct vector_style;
-	struct velocity_measure_with_unit;
-	struct velocity_unit;
-	typedef NotImplemented versioned_action_request; // (not currently used by Assimp)
-	struct vertex;
-	struct vertex_loop;
-	struct vertex_point;
-	struct vertex_shell;
-	struct view_volume;
-	struct visual_appearance_representation;
-	struct volume_measure_with_unit;
-	struct volume_unit;
-	struct week_of_year_and_day_date;
-	struct wire_shell;
-	struct year_month;
-
-
-
-    // C++ wrapper for measure_with_unit
-    struct measure_with_unit :  ObjectHelper<measure_with_unit,2> { measure_with_unit() : Object("measure_with_unit") {}
-		measure_value::Out value_component;
-		unit::Out unit_component;
-    };
-
-    // C++ wrapper for absorbed_dose_measure_with_unit
-    struct absorbed_dose_measure_with_unit : measure_with_unit, ObjectHelper<absorbed_dose_measure_with_unit,0> { absorbed_dose_measure_with_unit() : Object("absorbed_dose_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for derived_unit
-    struct derived_unit :  ObjectHelper<derived_unit,1> { derived_unit() : Object("derived_unit") {}
-		ListOf< Lazy< NotImplemented >, 1, 0 > elements;
-    };
-
-    // C++ wrapper for absorbed_dose_unit
-    struct absorbed_dose_unit : derived_unit, ObjectHelper<absorbed_dose_unit,0> { absorbed_dose_unit() : Object("absorbed_dose_unit") {}
-
-    };
-
-    // C++ wrapper for abstract_variable
-    struct abstract_variable :  ObjectHelper<abstract_variable,0> { abstract_variable() : Object("abstract_variable") {}
-
-    };
-
-    // C++ wrapper for acceleration_measure_with_unit
-    struct acceleration_measure_with_unit : measure_with_unit, ObjectHelper<acceleration_measure_with_unit,0> { acceleration_measure_with_unit() : Object("acceleration_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for acceleration_unit
-    struct acceleration_unit : derived_unit, ObjectHelper<acceleration_unit,0> { acceleration_unit() : Object("acceleration_unit") {}
-
-    };
-
-    // C++ wrapper for action
-    struct action :  ObjectHelper<action,3> { action() : Object("action") {}
-		label::Out name;
-		Maybe< text::Out > description;
-		Lazy< action_method > chosen_method;
-    };
-
-    // C++ wrapper for action_assignment
-    struct action_assignment :  ObjectHelper<action_assignment,1> { action_assignment() : Object("action_assignment") {}
-		Lazy< action > assigned_action;
-    };
-
-    // C++ wrapper for action_method
-    struct action_method :  ObjectHelper<action_method,4> { action_method() : Object("action_method") {}
-		label::Out name;
-		Maybe< text::Out > description;
-		text::Out consequence;
-		text::Out purpose;
-    };
-
-    // C++ wrapper for action_method_assignment
-    struct action_method_assignment :  ObjectHelper<action_method_assignment,2> { action_method_assignment() : Object("action_method_assignment") {}
-		Lazy< action_method > assigned_action_method;
-		Lazy< NotImplemented > role;
-    };
-
-    // C++ wrapper for action_method_relationship
-    struct action_method_relationship :  ObjectHelper<action_method_relationship,4> { action_method_relationship() : Object("action_method_relationship") {}
-		label::Out name;
-		Maybe< text::Out > description;
-		Lazy< action_method > relating_method;
-		Lazy< action_method > related_method;
-    };
-
-    // C++ wrapper for action_request_assignment
-    struct action_request_assignment :  ObjectHelper<action_request_assignment,1> { action_request_assignment() : Object("action_request_assignment") {}
-		Lazy< NotImplemented > assigned_action_request;
-    };
-
-    // C++ wrapper for address
-    struct address :  ObjectHelper<address,12> { address() : Object("address") {}
-		Maybe< label::Out > internal_location;
-		Maybe< label::Out > street_number;
-		Maybe< label::Out > street;
-		Maybe< label::Out > postal_box;
-		Maybe< label::Out > town;
-		Maybe< label::Out > region;
-		Maybe< label::Out > postal_code;
-		Maybe< label::Out > country;
-		Maybe< label::Out > facsimile_number;
-		Maybe< label::Out > telephone_number;
-		Maybe< label::Out > electronic_mail_address;
-		Maybe< label::Out > telex_number;
-    };
-
-    // C++ wrapper for representation
-    struct representation :  ObjectHelper<representation,3> { representation() : Object("representation") {}
-		label::Out name;
-		ListOf< Lazy< representation_item >, 1, 0 > items;
-		Lazy< representation_context > context_of_items;
-    };
-
-    // C++ wrapper for shape_representation
-    struct shape_representation : representation, ObjectHelper<shape_representation,0> { shape_representation() : Object("shape_representation") {}
-
-    };
-
-    // C++ wrapper for advanced_brep_shape_representation
-    struct advanced_brep_shape_representation : shape_representation, ObjectHelper<advanced_brep_shape_representation,0> { advanced_brep_shape_representation() : Object("advanced_brep_shape_representation") {}
-
-    };
-
-    // C++ wrapper for face_surface
-    struct face_surface :  ObjectHelper<face_surface,2> { face_surface() : Object("face_surface") {}
-		Lazy< surface > face_geometry;
-		BOOLEAN::Out same_sense;
-    };
-
-    // C++ wrapper for advanced_face
-    struct advanced_face : face_surface, ObjectHelper<advanced_face,0> { advanced_face() : Object("advanced_face") {}
-
-    };
-
-    // C++ wrapper for amount_of_substance_measure_with_unit
-    struct amount_of_substance_measure_with_unit : measure_with_unit, ObjectHelper<amount_of_substance_measure_with_unit,0> { amount_of_substance_measure_with_unit() : Object("amount_of_substance_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for named_unit
-    struct named_unit :  ObjectHelper<named_unit,1> { named_unit() : Object("named_unit") {}
-		Lazy< NotImplemented > dimensions;
-    };
-
-    // C++ wrapper for amount_of_substance_unit
-    struct amount_of_substance_unit : named_unit, ObjectHelper<amount_of_substance_unit,0> { amount_of_substance_unit() : Object("amount_of_substance_unit") {}
-
-    };
-
-    // C++ wrapper for angle_direction_reference
-    struct angle_direction_reference :  ObjectHelper<angle_direction_reference,0> { angle_direction_reference() : Object("angle_direction_reference") {}
-
-    };
-
-    // C++ wrapper for representation_item
-    struct representation_item :  ObjectHelper<representation_item,1> { representation_item() : Object("representation_item") {}
-		label::Out name;
-    };
-
-    // C++ wrapper for geometric_representation_item
-    struct geometric_representation_item : representation_item, ObjectHelper<geometric_representation_item,0> { geometric_representation_item() : Object("geometric_representation_item") {}
-
-    };
-
-    // C++ wrapper for draughting_callout
-    struct draughting_callout : geometric_representation_item, ObjectHelper<draughting_callout,1> { draughting_callout() : Object("draughting_callout") {}
-		ListOf< draughting_callout_element, 1, 0 >::Out contents;
-    };
-
-    // C++ wrapper for dimension_curve_directed_callout
-    struct dimension_curve_directed_callout : draughting_callout, ObjectHelper<dimension_curve_directed_callout,0> { dimension_curve_directed_callout() : Object("dimension_curve_directed_callout") {}
-
-    };
-
-    // C++ wrapper for angular_dimension
-    struct angular_dimension : dimension_curve_directed_callout, ObjectHelper<angular_dimension,0> { angular_dimension() : Object("angular_dimension") {}
-
-    };
-
-    // C++ wrapper for shape_aspect_relationship
-    struct shape_aspect_relationship :  ObjectHelper<shape_aspect_relationship,4> { shape_aspect_relationship() : Object("shape_aspect_relationship") {}
-		label::Out name;
-		Maybe< text::Out > description;
-		Lazy< shape_aspect > relating_shape_aspect;
-		Lazy< shape_aspect > related_shape_aspect;
-    };
-
-    // C++ wrapper for dimensional_location
-    struct dimensional_location : shape_aspect_relationship, ObjectHelper<dimensional_location,0> { dimensional_location() : Object("dimensional_location") {}
-
-    };
-
-    // C++ wrapper for angular_location
-    struct angular_location : dimensional_location, ObjectHelper<angular_location,1> { angular_location() : Object("angular_location") {}
-		angle_relator::Out angle_selection;
-    };
-
-    // C++ wrapper for dimensional_size
-    struct dimensional_size :  ObjectHelper<dimensional_size,2> { dimensional_size() : Object("dimensional_size") {}
-		Lazy< shape_aspect > applies_to;
-		label::Out name;
-    };
-
-    // C++ wrapper for angular_size
-    struct angular_size : dimensional_size, ObjectHelper<angular_size,1> { angular_size() : Object("angular_size") {}
-		angle_relator::Out angle_selection;
-    };
-
-    // C++ wrapper for geometric_tolerance
-    struct geometric_tolerance :  ObjectHelper<geometric_tolerance,4> { geometric_tolerance() : Object("geometric_tolerance") {}
-		label::Out name;
-		text::Out description;
-		Lazy< measure_with_unit > magnitude;
-		Lazy< shape_aspect > toleranced_shape_aspect;
-    };
-
-    // C++ wrapper for geometric_tolerance_with_datum_reference
-    struct geometric_tolerance_with_datum_reference : geometric_tolerance, ObjectHelper<geometric_tolerance_with_datum_reference,1> { geometric_tolerance_with_datum_reference() : Object("geometric_tolerance_with_datum_reference") {}
-		ListOf< Lazy< datum_reference >, 1, 0 > datum_system;
-    };
-
-    // C++ wrapper for angularity_tolerance
-    struct angularity_tolerance : geometric_tolerance_with_datum_reference, ObjectHelper<angularity_tolerance,0> { angularity_tolerance() : Object("angularity_tolerance") {}
-
-    };
-
-    // C++ wrapper for styled_item
-    struct styled_item : representation_item, ObjectHelper<styled_item,2> { styled_item() : Object("styled_item") {}
-		ListOf< Lazy< presentation_style_assignment >, 1, 0 > styles;
-		Lazy< representation_item > item;
-    };
-
-    // C++ wrapper for annotation_occurrence
-    struct annotation_occurrence : styled_item, ObjectHelper<annotation_occurrence,0> { annotation_occurrence() : Object("annotation_occurrence") {}
-
-    };
-
-    // C++ wrapper for annotation_curve_occurrence
-    struct annotation_curve_occurrence : annotation_occurrence, ObjectHelper<annotation_curve_occurrence,0> { annotation_curve_occurrence() : Object("annotation_curve_occurrence") {}
-
-    };
-
-    // C++ wrapper for annotation_fill_area
-    struct annotation_fill_area : geometric_representation_item, ObjectHelper<annotation_fill_area,1> { annotation_fill_area() : Object("annotation_fill_area") {}
-		ListOf< Lazy< curve >, 1, 0 > boundaries;
-    };
-
-    // C++ wrapper for annotation_fill_area_occurrence
-    struct annotation_fill_area_occurrence : annotation_occurrence, ObjectHelper<annotation_fill_area_occurrence,1> { annotation_fill_area_occurrence() : Object("annotation_fill_area_occurrence") {}
-		Lazy< point > fill_style_target;
-    };
-
-    // C++ wrapper for annotation_occurrence_relationship
-    struct annotation_occurrence_relationship :  ObjectHelper<annotation_occurrence_relationship,4> { annotation_occurrence_relationship() : Object("annotation_occurrence_relationship") {}
-		label::Out name;
-		text::Out description;
-		Lazy< annotation_occurrence > relating_annotation_occurrence;
-		Lazy< annotation_occurrence > related_annotation_occurrence;
-    };
-
-    // C++ wrapper for annotation_occurrence_associativity
-    struct annotation_occurrence_associativity : annotation_occurrence_relationship, ObjectHelper<annotation_occurrence_associativity,0> { annotation_occurrence_associativity() : Object("annotation_occurrence_associativity") {}
-
-    };
-
-    // C++ wrapper for annotation_plane
-    struct annotation_plane :  ObjectHelper<annotation_plane,1> { annotation_plane() : Object("annotation_plane") {}
-		Maybe< ListOf< annotation_plane_element, 1, 0 >::Out > elements;
-    };
-
-    // C++ wrapper for annotation_symbol_occurrence
-    struct annotation_symbol_occurrence : annotation_occurrence, ObjectHelper<annotation_symbol_occurrence,0> { annotation_symbol_occurrence() : Object("annotation_symbol_occurrence") {}
-
-    };
-
-    // C++ wrapper for annotation_subfigure_occurrence
-    struct annotation_subfigure_occurrence : annotation_symbol_occurrence, ObjectHelper<annotation_subfigure_occurrence,0> { annotation_subfigure_occurrence() : Object("annotation_subfigure_occurrence") {}
-
-    };
-
-    // C++ wrapper for mapped_item
-    struct mapped_item : representation_item, ObjectHelper<mapped_item,2> { mapped_item() : Object("mapped_item") {}
-		Lazy< representation_map > mapping_source;
-		Lazy< representation_item > mapping_target;
-    };
-
-    // C++ wrapper for annotation_symbol
-    struct annotation_symbol : mapped_item, ObjectHelper<annotation_symbol,0> { annotation_symbol() : Object("annotation_symbol") {}
-
-    };
-
-    // C++ wrapper for annotation_text
-    struct annotation_text : mapped_item, ObjectHelper<annotation_text,0> { annotation_text() : Object("annotation_text") {}
-
-    };
-
-    // C++ wrapper for annotation_text_character
-    struct annotation_text_character : mapped_item, ObjectHelper<annotation_text_character,1> { annotation_text_character() : Object("annotation_text_character") {}
-		text_alignment::Out alignment;
-    };
-
-    // C++ wrapper for annotation_text_occurrence
-    struct annotation_text_occurrence : annotation_occurrence, ObjectHelper<annotation_text_occurrence,0> { annotation_text_occurrence() : Object("annotation_text_occurrence") {}
-
-    };
-
-    // C++ wrapper for shape_aspect
-    struct shape_aspect :  ObjectHelper<shape_aspect,4> { shape_aspect() : Object("shape_aspect") {}
-		label::Out name;
-		Maybe< text::Out > description;
-		Lazy< product_definition_shape > of_shape;
-		LOGICAL::Out product_definitional;
-    };
-
-    // C++ wrapper for derived_shape_aspect
-    struct derived_shape_aspect : shape_aspect, ObjectHelper<derived_shape_aspect,0> { derived_shape_aspect() : Object("derived_shape_aspect") {}
-
-    };
-
-    // C++ wrapper for apex
-    struct apex : derived_shape_aspect, ObjectHelper<apex,0> { apex() : Object("apex") {}
-
-    };
-
-    // C++ wrapper for application_context_element
-    struct application_context_element :  ObjectHelper<application_context_element,2> { application_context_element() : Object("application_context_element") {}
-		label::Out name;
-		Lazy< NotImplemented > frame_of_reference;
-    };
-
-    // C++ wrapper for applied_action_assignment
-    struct applied_action_assignment : action_assignment, ObjectHelper<applied_action_assignment,1> { applied_action_assignment() : Object("applied_action_assignment") {}
-		ListOf< action_items, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for applied_action_method_assignment
-    struct applied_action_method_assignment : action_method_assignment, ObjectHelper<applied_action_method_assignment,1> { applied_action_method_assignment() : Object("applied_action_method_assignment") {}
-		ListOf< action_method_items, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for applied_action_request_assignment
-    struct applied_action_request_assignment : action_request_assignment, ObjectHelper<applied_action_request_assignment,1> { applied_action_request_assignment() : Object("applied_action_request_assignment") {}
-		ListOf< action_request_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for approval_assignment
-    struct approval_assignment :  ObjectHelper<approval_assignment,1> { approval_assignment() : Object("approval_assignment") {}
-		Lazy< NotImplemented > assigned_approval;
-    };
-
-    // C++ wrapper for applied_approval_assignment
-    struct applied_approval_assignment : approval_assignment, ObjectHelper<applied_approval_assignment,1> { applied_approval_assignment() : Object("applied_approval_assignment") {}
-		ListOf< approval_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for attribute_classification_assignment
-    struct attribute_classification_assignment :  ObjectHelper<attribute_classification_assignment,3> { attribute_classification_assignment() : Object("attribute_classification_assignment") {}
-		Lazy< group > assigned_class;
-		label::Out attribute_name;
-		Lazy< NotImplemented > role;
-    };
-
-    // C++ wrapper for applied_attribute_classification_assignment
-    struct applied_attribute_classification_assignment : attribute_classification_assignment, ObjectHelper<applied_attribute_classification_assignment,1> { applied_attribute_classification_assignment() : Object("applied_attribute_classification_assignment") {}
-		ListOf< attribute_classification_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for certification_assignment
-    struct certification_assignment :  ObjectHelper<certification_assignment,1> { certification_assignment() : Object("certification_assignment") {}
-		Lazy< NotImplemented > assigned_certification;
-    };
-
-    // C++ wrapper for applied_certification_assignment
-    struct applied_certification_assignment : certification_assignment, ObjectHelper<applied_certification_assignment,1> { applied_certification_assignment() : Object("applied_certification_assignment") {}
-		ListOf< certification_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for classification_assignment
-    struct classification_assignment :  ObjectHelper<classification_assignment,2> { classification_assignment() : Object("classification_assignment") {}
-		Lazy< group > assigned_class;
-		Lazy< NotImplemented > role;
-    };
-
-    // C++ wrapper for applied_classification_assignment
-    struct applied_classification_assignment : classification_assignment, ObjectHelper<applied_classification_assignment,1> { applied_classification_assignment() : Object("applied_classification_assignment") {}
-		ListOf< classification_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for contract_assignment
-    struct contract_assignment :  ObjectHelper<contract_assignment,1> { contract_assignment() : Object("contract_assignment") {}
-		Lazy< NotImplemented > assigned_contract;
-    };
-
-    // C++ wrapper for applied_contract_assignment
-    struct applied_contract_assignment : contract_assignment, ObjectHelper<applied_contract_assignment,1> { applied_contract_assignment() : Object("applied_contract_assignment") {}
-		ListOf< contract_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for date_and_time_assignment
-    struct date_and_time_assignment :  ObjectHelper<date_and_time_assignment,2> { date_and_time_assignment() : Object("date_and_time_assignment") {}
-		Lazy< NotImplemented > assigned_date_and_time;
-		Lazy< NotImplemented > role;
-    };
-
-    // C++ wrapper for applied_date_and_time_assignment
-    struct applied_date_and_time_assignment : date_and_time_assignment, ObjectHelper<applied_date_and_time_assignment,1> { applied_date_and_time_assignment() : Object("applied_date_and_time_assignment") {}
-		ListOf< date_and_time_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for date_assignment
-    struct date_assignment :  ObjectHelper<date_assignment,2> { date_assignment() : Object("date_assignment") {}
-		Lazy< date > assigned_date;
-		Lazy< NotImplemented > role;
-    };
-
-    // C++ wrapper for applied_date_assignment
-    struct applied_date_assignment : date_assignment, ObjectHelper<applied_date_assignment,1> { applied_date_assignment() : Object("applied_date_assignment") {}
-		ListOf< date_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for document_reference
-    struct document_reference :  ObjectHelper<document_reference,2> { document_reference() : Object("document_reference") {}
-		Lazy< NotImplemented > assigned_document;
-		label::Out source;
-    };
-
-    // C++ wrapper for applied_document_reference
-    struct applied_document_reference : document_reference, ObjectHelper<applied_document_reference,1> { applied_document_reference() : Object("applied_document_reference") {}
-		ListOf< document_reference_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for document_usage_constraint_assignment
-    struct document_usage_constraint_assignment :  ObjectHelper<document_usage_constraint_assignment,2> { document_usage_constraint_assignment() : Object("document_usage_constraint_assignment") {}
-		Lazy< NotImplemented > assigned_document_usage;
-		Lazy< NotImplemented > role;
-    };
-
-    // C++ wrapper for applied_document_usage_constraint_assignment
-    struct applied_document_usage_constraint_assignment : document_usage_constraint_assignment, ObjectHelper<applied_document_usage_constraint_assignment,1> { applied_document_usage_constraint_assignment() : Object("applied_document_usage_constraint_assignment") {}
-		ListOf< document_reference_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for effectivity_assignment
-    struct effectivity_assignment :  ObjectHelper<effectivity_assignment,1> { effectivity_assignment() : Object("effectivity_assignment") {}
-		Lazy< effectivity > assigned_effectivity;
-    };
-
-    // C++ wrapper for applied_effectivity_assignment
-    struct applied_effectivity_assignment : effectivity_assignment, ObjectHelper<applied_effectivity_assignment,1> { applied_effectivity_assignment() : Object("applied_effectivity_assignment") {}
-		ListOf< effectivity_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for event_occurrence_assignment
-    struct event_occurrence_assignment :  ObjectHelper<event_occurrence_assignment,2> { event_occurrence_assignment() : Object("event_occurrence_assignment") {}
-		Lazy< event_occurrence > assigned_event_occurrence;
-		Lazy< NotImplemented > role;
-    };
-
-    // C++ wrapper for applied_event_occurrence_assignment
-    struct applied_event_occurrence_assignment : event_occurrence_assignment, ObjectHelper<applied_event_occurrence_assignment,1> { applied_event_occurrence_assignment() : Object("applied_event_occurrence_assignment") {}
-		ListOf< event_occurrence_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for identification_assignment
-    struct identification_assignment :  ObjectHelper<identification_assignment,2> { identification_assignment() : Object("identification_assignment") {}
-		identifier::Out assigned_id;
-		Lazy< NotImplemented > role;
-    };
-
-    // C++ wrapper for external_identification_assignment
-    struct external_identification_assignment : identification_assignment, ObjectHelper<external_identification_assignment,1> { external_identification_assignment() : Object("external_identification_assignment") {}
-		Lazy< external_source > source;
-    };
-
-    // C++ wrapper for applied_external_identification_assignment
-    struct applied_external_identification_assignment : external_identification_assignment, ObjectHelper<applied_external_identification_assignment,1> { applied_external_identification_assignment() : Object("applied_external_identification_assignment") {}
-		ListOf< external_identification_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for group_assignment
-    struct group_assignment :  ObjectHelper<group_assignment,1> { group_assignment() : Object("group_assignment") {}
-		Lazy< group > assigned_group;
-    };
-
-    // C++ wrapper for applied_group_assignment
-    struct applied_group_assignment : group_assignment, ObjectHelper<applied_group_assignment,1> { applied_group_assignment() : Object("applied_group_assignment") {}
-		ListOf< groupable_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for applied_identification_assignment
-    struct applied_identification_assignment : identification_assignment, ObjectHelper<applied_identification_assignment,1> { applied_identification_assignment() : Object("applied_identification_assignment") {}
-		ListOf< identification_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for name_assignment
-    struct name_assignment :  ObjectHelper<name_assignment,1> { name_assignment() : Object("name_assignment") {}
-		label::Out assigned_name;
-    };
-
-    // C++ wrapper for applied_name_assignment
-    struct applied_name_assignment : name_assignment, ObjectHelper<applied_name_assignment,1> { applied_name_assignment() : Object("applied_name_assignment") {}
-		name_item::Out item;
-    };
-
-    // C++ wrapper for organization_assignment
-    struct organization_assignment :  ObjectHelper<organization_assignment,2> { organization_assignment() : Object("organization_assignment") {}
-		Lazy< NotImplemented > assigned_organization;
-		Lazy< NotImplemented > role;
-    };
-
-    // C++ wrapper for applied_organization_assignment
-    struct applied_organization_assignment : organization_assignment, ObjectHelper<applied_organization_assignment,1> { applied_organization_assignment() : Object("applied_organization_assignment") {}
-		ListOf< organization_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for organizational_project_assignment
-    struct organizational_project_assignment :  ObjectHelper<organizational_project_assignment,2> { organizational_project_assignment() : Object("organizational_project_assignment") {}
-		Lazy< NotImplemented > assigned_organizational_project;
-		Lazy< NotImplemented > role;
-    };
-
-    // C++ wrapper for applied_organizational_project_assignment
-    struct applied_organizational_project_assignment : organizational_project_assignment, ObjectHelper<applied_organizational_project_assignment,1> { applied_organizational_project_assignment() : Object("applied_organizational_project_assignment") {}
-		ListOf< project_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for person_and_organization_assignment
-    struct person_and_organization_assignment :  ObjectHelper<person_and_organization_assignment,2> { person_and_organization_assignment() : Object("person_and_organization_assignment") {}
-		Lazy< NotImplemented > assigned_person_and_organization;
-		Lazy< NotImplemented > role;
-    };
-
-    // C++ wrapper for applied_person_and_organization_assignment
-    struct applied_person_and_organization_assignment : person_and_organization_assignment, ObjectHelper<applied_person_and_organization_assignment,1> { applied_person_and_organization_assignment() : Object("applied_person_and_organization_assignment") {}
-		ListOf< person_and_organization_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for presented_item
-    struct presented_item :  ObjectHelper<presented_item,0> { presented_item() : Object("presented_item") {}
-
-    };
-
-    // C++ wrapper for applied_presented_item
-    struct applied_presented_item : presented_item, ObjectHelper<applied_presented_item,1> { applied_presented_item() : Object("applied_presented_item") {}
-		ListOf< presented_item_select, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for security_classification_assignment
-    struct security_classification_assignment :  ObjectHelper<security_classification_assignment,1> { security_classification_assignment() : Object("security_classification_assignment") {}
-		Lazy< NotImplemented > assigned_security_classification;
-    };
-
-    // C++ wrapper for applied_security_classification_assignment
-    struct applied_security_classification_assignment : security_classification_assignment, ObjectHelper<applied_security_classification_assignment,1> { applied_security_classification_assignment() : Object("applied_security_classification_assignment") {}
-		ListOf< security_classification_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for time_interval_assignment
-    struct time_interval_assignment :  ObjectHelper<time_interval_assignment,2> { time_interval_assignment() : Object("time_interval_assignment") {}
-		Lazy< time_interval > assigned_time_interval;
-		Lazy< NotImplemented > role;
-    };
-
-    // C++ wrapper for applied_time_interval_assignment
-    struct applied_time_interval_assignment : time_interval_assignment, ObjectHelper<applied_time_interval_assignment,1> { applied_time_interval_assignment() : Object("applied_time_interval_assignment") {}
-		ListOf< time_interval_item, 0, 0 >::Out items;
-    };
-
-    // C++ wrapper for applied_usage_right
-    struct applied_usage_right : applied_action_assignment, ObjectHelper<applied_usage_right,0> { applied_usage_right() : Object("applied_usage_right") {}
-
-    };
-
-    // C++ wrapper for area_in_set
-    struct area_in_set :  ObjectHelper<area_in_set,2> { area_in_set() : Object("area_in_set") {}
-		Lazy< presentation_area > area;
-		Lazy< presentation_set > in_set;
-    };
-
-    // C++ wrapper for area_measure_with_unit
-    struct area_measure_with_unit : measure_with_unit, ObjectHelper<area_measure_with_unit,0> { area_measure_with_unit() : Object("area_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for area_unit
-    struct area_unit : derived_unit, ObjectHelper<area_unit,0> { area_unit() : Object("area_unit") {}
-
-    };
-
-    // C++ wrapper for product_definition_relationship
-    struct product_definition_relationship :  ObjectHelper<product_definition_relationship,5> { product_definition_relationship() : Object("product_definition_relationship") {}
-		identifier::Out id;
-		label::Out name;
-		Maybe< text::Out > description;
-		Lazy< product_definition > relating_product_definition;
-		Lazy< product_definition > related_product_definition;
-    };
-
-    // C++ wrapper for product_definition_usage
-    struct product_definition_usage : product_definition_relationship, ObjectHelper<product_definition_usage,0> { product_definition_usage() : Object("product_definition_usage") {}
-
-    };
-
-    // C++ wrapper for assembly_component_usage
-    struct assembly_component_usage : product_definition_usage, ObjectHelper<assembly_component_usage,1> { assembly_component_usage() : Object("assembly_component_usage") {}
-		Maybe< identifier::Out > reference_designator;
-    };
-
-    // C++ wrapper for assigned_requirement
-    struct assigned_requirement : group_assignment, ObjectHelper<assigned_requirement,1> { assigned_requirement() : Object("assigned_requirement") {}
-		ListOf< Lazy< product_definition >, 1, 1 > items;
-    };
-
-    // C++ wrapper for compound_representation_item
-    struct compound_representation_item : representation_item, ObjectHelper<compound_representation_item,1> { compound_representation_item() : Object("compound_representation_item") {}
-		compound_item_definition::Out item_element;
-    };
-
-    // C++ wrapper for atomic_formula
-    struct atomic_formula : compound_representation_item, ObjectHelper<atomic_formula,0> { atomic_formula() : Object("atomic_formula") {}
-
-    };
-
-    // C++ wrapper for attribute_assertion
-    struct attribute_assertion :  ObjectHelper<attribute_assertion,0> { attribute_assertion() : Object("attribute_assertion") {}
-
-    };
-
-    // C++ wrapper for attribute_language_assignment
-    struct attribute_language_assignment : attribute_classification_assignment, ObjectHelper<attribute_language_assignment,1> { attribute_language_assignment() : Object("attribute_language_assignment") {}
-		ListOf< attribute_language_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for attribute_value_assignment
-    struct attribute_value_assignment :  ObjectHelper<attribute_value_assignment,3> { attribute_value_assignment() : Object("attribute_value_assignment") {}
-		label::Out attribute_name;
-		attribute_type::Out attribute_value;
-		Lazy< NotImplemented > role;
-    };
-
-    // C++ wrapper for auxiliary_geometric_representation_item
-    struct auxiliary_geometric_representation_item :  ObjectHelper<auxiliary_geometric_representation_item,0> { auxiliary_geometric_representation_item() : Object("auxiliary_geometric_representation_item") {}
-
-    };
-
-    // C++ wrapper for placement
-    struct placement : geometric_representation_item, ObjectHelper<placement,1> { placement() : Object("placement") {}
-		Lazy< cartesian_point > location;
-    };
-
-    // C++ wrapper for axis1_placement
-    struct axis1_placement : placement, ObjectHelper<axis1_placement,1> { axis1_placement() : Object("axis1_placement") {}
-		Maybe< Lazy< direction > > axis;
-    };
-
-    // C++ wrapper for axis2_placement_2d
-    struct axis2_placement_2d : placement, ObjectHelper<axis2_placement_2d,1> { axis2_placement_2d() : Object("axis2_placement_2d") {}
-		Maybe< Lazy< direction > > ref_direction;
-    };
-
-    // C++ wrapper for axis2_placement_3d
-    struct axis2_placement_3d : placement, ObjectHelper<axis2_placement_3d,2> { axis2_placement_3d() : Object("axis2_placement_3d") {}
-		Maybe< Lazy< direction > > axis;
-		Maybe< Lazy< direction > > ref_direction;
-    };
-
-    // C++ wrapper for curve
-    struct curve : geometric_representation_item, ObjectHelper<curve,0> { curve() : Object("curve") {}
-
-    };
-
-    // C++ wrapper for bounded_curve
-    struct bounded_curve : curve, ObjectHelper<bounded_curve,0> { bounded_curve() : Object("bounded_curve") {}
-
-    };
-
-    // C++ wrapper for b_spline_curve
-    struct b_spline_curve : bounded_curve, ObjectHelper<b_spline_curve,5> { b_spline_curve() : Object("b_spline_curve") {}
-		INTEGER::Out degree;
-		ListOf< Lazy< cartesian_point >, 2, 0 > control_points_list;
-		b_spline_curve_form::Out curve_form;
-		LOGICAL::Out closed_curve;
-		LOGICAL::Out self_intersect;
-    };
-
-    // C++ wrapper for b_spline_curve_with_knots
-    struct b_spline_curve_with_knots : b_spline_curve, ObjectHelper<b_spline_curve_with_knots,3> { b_spline_curve_with_knots() : Object("b_spline_curve_with_knots") {}
-		ListOf< INTEGER, 2, 0 >::Out knot_multiplicities;
-		ListOf< parameter_value, 2, 0 >::Out knots;
-		knot_type::Out knot_spec;
-    };
-
-    // C++ wrapper for surface
-    struct surface : geometric_representation_item, ObjectHelper<surface,0> { surface() : Object("surface") {}
-
-    };
-
-    // C++ wrapper for bounded_surface
-    struct bounded_surface : surface, ObjectHelper<bounded_surface,0> { bounded_surface() : Object("bounded_surface") {}
-
-    };
-
-    // C++ wrapper for b_spline_surface
-    struct b_spline_surface : bounded_surface, ObjectHelper<b_spline_surface,6> { b_spline_surface() : Object("b_spline_surface") {}
-		INTEGER::Out u_degree;
-		INTEGER::Out v_degree;
-		b_spline_surface_form::Out surface_form;
-		LOGICAL::Out u_closed;
-		LOGICAL::Out v_closed;
-		LOGICAL::Out self_intersect;
-    };
-
-    // C++ wrapper for b_spline_surface_with_knots
-    struct b_spline_surface_with_knots : b_spline_surface, ObjectHelper<b_spline_surface_with_knots,5> { b_spline_surface_with_knots() : Object("b_spline_surface_with_knots") {}
-		ListOf< INTEGER, 2, 0 >::Out u_multiplicities;
-		ListOf< INTEGER, 2, 0 >::Out v_multiplicities;
-		ListOf< parameter_value, 2, 0 >::Out u_knots;
-		ListOf< parameter_value, 2, 0 >::Out v_knots;
-		knot_type::Out knot_spec;
-    };
-
-    // C++ wrapper for product_definition
-    struct product_definition :  ObjectHelper<product_definition,4> { product_definition() : Object("product_definition") {}
-		identifier::Out id;
-		Maybe< text::Out > description;
-		Lazy< product_definition_formation > formation;
-		Lazy< product_definition_context > frame_of_reference;
-    };
-
-    // C++ wrapper for rule_software_definition
-    struct rule_software_definition : product_definition, ObjectHelper<rule_software_definition,0> { rule_software_definition() : Object("rule_software_definition") {}
-
-    };
-
-    // C++ wrapper for rule_definition
-    struct rule_definition : rule_software_definition, ObjectHelper<rule_definition,0> { rule_definition() : Object("rule_definition") {}
-
-    };
-
-    // C++ wrapper for back_chaining_rule
-    struct back_chaining_rule : rule_definition, ObjectHelper<back_chaining_rule,0> { back_chaining_rule() : Object("back_chaining_rule") {}
-
-    };
-
-    // C++ wrapper for back_chaining_rule_body
-    struct back_chaining_rule_body :  ObjectHelper<back_chaining_rule_body,0> { back_chaining_rule_body() : Object("back_chaining_rule_body") {}
-
-    };
-
-    // C++ wrapper for colour
-    struct colour :  ObjectHelper<colour,0> { colour() : Object("colour") {}
-
-    };
-
-    // C++ wrapper for background_colour
-    struct background_colour : colour, ObjectHelper<background_colour,1> { background_colour() : Object("background_colour") {}
-		area_or_view::Out presentation;
-    };
-
-    // C++ wrapper for beveled_sheet_representation
-    struct beveled_sheet_representation : shape_representation, ObjectHelper<beveled_sheet_representation,0> { beveled_sheet_representation() : Object("beveled_sheet_representation") {}
-
-    };
-
-    // C++ wrapper for bezier_curve
-    struct bezier_curve : b_spline_curve, ObjectHelper<bezier_curve,0> { bezier_curve() : Object("bezier_curve") {}
-
-    };
-
-    // C++ wrapper for bezier_surface
-    struct bezier_surface : b_spline_surface, ObjectHelper<bezier_surface,0> { bezier_surface() : Object("bezier_surface") {}
-
-    };
-
-    // C++ wrapper for generic_expression
-    struct generic_expression :  ObjectHelper<generic_expression,0> { generic_expression() : Object("generic_expression") {}
-
-    };
-
-    // C++ wrapper for binary_generic_expression
-    struct binary_generic_expression : generic_expression, ObjectHelper<binary_generic_expression,1> { binary_generic_expression() : Object("binary_generic_expression") {}
-		ListOf< Lazy< generic_expression >, 2, 2 > operands;
-    };
-
-    // C++ wrapper for binary_numeric_expression
-    struct binary_numeric_expression :  ObjectHelper<binary_numeric_expression,0> { binary_numeric_expression() : Object("binary_numeric_expression") {}
-
-    };
-
-    // C++ wrapper for binary_representation_item
-    struct binary_representation_item : representation_item, ObjectHelper<binary_representation_item,1> { binary_representation_item() : Object("binary_representation_item") {}
-		BINARY::Out binary_value;
-    };
-
-    // C++ wrapper for block
-    struct block : geometric_representation_item, ObjectHelper<block,4> { block() : Object("block") {}
-		Lazy< axis2_placement_3d > position;
-		positive_length_measure::Out x;
-		positive_length_measure::Out y;
-		positive_length_measure::Out z;
-    };
-
-    // C++ wrapper for expression
-    struct expression : generic_expression, ObjectHelper<expression,0> { expression() : Object("expression") {}
-
-    };
-
-    // C++ wrapper for boolean_expression
-    struct boolean_expression : expression, ObjectHelper<boolean_expression,0> { boolean_expression() : Object("boolean_expression") {}
-
-    };
-
-    // C++ wrapper for boolean_literal
-    struct boolean_literal :  ObjectHelper<boolean_literal,1> { boolean_literal() : Object("boolean_literal") {}
-		BOOLEAN::Out the_value;
-    };
-
-    // C++ wrapper for boolean_representation_item
-    struct boolean_representation_item :  ObjectHelper<boolean_representation_item,0> { boolean_representation_item() : Object("boolean_representation_item") {}
-
-    };
-
-    // C++ wrapper for boolean_result
-    struct boolean_result : geometric_representation_item, ObjectHelper<boolean_result,3> { boolean_result() : Object("boolean_result") {}
-		boolean_operator::Out operator_;
-		boolean_operand::Out first_operand;
-		boolean_operand::Out second_operand;
-    };
-
-    // C++ wrapper for composite_curve
-    struct composite_curve : bounded_curve, ObjectHelper<composite_curve,2> { composite_curve() : Object("composite_curve") {}
-		ListOf< Lazy< composite_curve_segment >, 1, 0 > segments;
-		LOGICAL::Out self_intersect;
-    };
-
-    // C++ wrapper for composite_curve_on_surface
-    struct composite_curve_on_surface : composite_curve, ObjectHelper<composite_curve_on_surface,0> { composite_curve_on_surface() : Object("composite_curve_on_surface") {}
-
-    };
-
-    // C++ wrapper for boundary_curve
-    struct boundary_curve : composite_curve_on_surface, ObjectHelper<boundary_curve,0> { boundary_curve() : Object("boundary_curve") {}
-
-    };
-
-    // C++ wrapper for bounded_pcurve
-    struct bounded_pcurve :  ObjectHelper<bounded_pcurve,0> { bounded_pcurve() : Object("bounded_pcurve") {}
-
-    };
-
-    // C++ wrapper for bounded_surface_curve
-    struct bounded_surface_curve :  ObjectHelper<bounded_surface_curve,0> { bounded_surface_curve() : Object("bounded_surface_curve") {}
-
-    };
-
-    // C++ wrapper for founded_item
-    struct founded_item :  ObjectHelper<founded_item,0> { founded_item() : Object("founded_item") {}
-
-    };
-
-    // C++ wrapper for box_domain
-    struct box_domain : founded_item, ObjectHelper<box_domain,4> { box_domain() : Object("box_domain") {}
-		Lazy< cartesian_point > corner;
-		positive_length_measure::Out xlength;
-		positive_length_measure::Out ylength;
-		positive_length_measure::Out zlength;
-    };
-
-    // C++ wrapper for half_space_solid
-    struct half_space_solid : geometric_representation_item, ObjectHelper<half_space_solid,2> { half_space_solid() : Object("half_space_solid") {}
-		Lazy< surface > base_surface;
-		BOOLEAN::Out agreement_flag;
-    };
-
-    // C++ wrapper for boxed_half_space
-    struct boxed_half_space : half_space_solid, ObjectHelper<boxed_half_space,1> { boxed_half_space() : Object("boxed_half_space") {}
-		Lazy< box_domain > enclosure;
-    };
-
-    // C++ wrapper for breakdown_context
-    struct breakdown_context : product_definition_relationship, ObjectHelper<breakdown_context,0> { breakdown_context() : Object("breakdown_context") {}
-
-    };
-
-    // C++ wrapper for breakdown_element_group_assignment
-    struct breakdown_element_group_assignment : group_assignment, ObjectHelper<breakdown_element_group_assignment,1> { breakdown_element_group_assignment() : Object("breakdown_element_group_assignment") {}
-		ListOf< product_definition_or_breakdown_element_usage, 1, 1 >::Out items;
-    };
-
-    // C++ wrapper for breakdown_element_realization
-    struct breakdown_element_realization :  ObjectHelper<breakdown_element_realization,0> { breakdown_element_realization() : Object("breakdown_element_realization") {}
-
-    };
-
-    // C++ wrapper for breakdown_element_usage
-    struct breakdown_element_usage : product_definition_relationship, ObjectHelper<breakdown_element_usage,0> { breakdown_element_usage() : Object("breakdown_element_usage") {}
-
-    };
-
-    // C++ wrapper for breakdown_of
-    struct breakdown_of : product_definition_relationship, ObjectHelper<breakdown_of,0> { breakdown_of() : Object("breakdown_of") {}
-
-    };
-
-    // C++ wrapper for solid_model
-    struct solid_model : geometric_representation_item, ObjectHelper<solid_model,0> { solid_model() : Object("solid_model") {}
-
-    };
-
-    // C++ wrapper for manifold_solid_brep
-    struct manifold_solid_brep : solid_model, ObjectHelper<manifold_solid_brep,1> { manifold_solid_brep() : Object("manifold_solid_brep") {}
-		Lazy< closed_shell > outer;
-    };
-
-    // C++ wrapper for brep_with_voids
-    struct brep_with_voids : manifold_solid_brep, ObjectHelper<brep_with_voids,1> { brep_with_voids() : Object("brep_with_voids") {}
-		ListOf< Lazy< oriented_closed_shell >, 1, 0 > voids;
-    };
-
-    // C++ wrapper for bytes_representation_item
-    struct bytes_representation_item : binary_representation_item, ObjectHelper<bytes_representation_item,0> { bytes_representation_item() : Object("bytes_representation_item") {}
-
-    };
-
-    // C++ wrapper for date
-    struct date :  ObjectHelper<date,1> { date() : Object("date") {}
-		year_number::Out year_component;
-    };
-
-    // C++ wrapper for calendar_date
-    struct calendar_date : date, ObjectHelper<calendar_date,2> { calendar_date() : Object("calendar_date") {}
-		day_in_month_number::Out day_component;
-		month_in_year_number::Out month_component;
-    };
-
-    // C++ wrapper for camera_image
-    struct camera_image : mapped_item, ObjectHelper<camera_image,0> { camera_image() : Object("camera_image") {}
-
-    };
-
-    // C++ wrapper for camera_image_3d_with_scale
-    struct camera_image_3d_with_scale : camera_image, ObjectHelper<camera_image_3d_with_scale,0> { camera_image_3d_with_scale() : Object("camera_image_3d_with_scale") {}
-
-    };
-
-    // C++ wrapper for camera_model
-    struct camera_model : geometric_representation_item, ObjectHelper<camera_model,0> { camera_model() : Object("camera_model") {}
-
-    };
-
-    // C++ wrapper for camera_model_d3
-    struct camera_model_d3 : camera_model, ObjectHelper<camera_model_d3,2> { camera_model_d3() : Object("camera_model_d3") {}
-		Lazy< axis2_placement_3d > view_reference_system;
-		Lazy< view_volume > perspective_of_volume;
-    };
-
-    // C++ wrapper for camera_model_d3_multi_clipping
-    struct camera_model_d3_multi_clipping : camera_model_d3, ObjectHelper<camera_model_d3_multi_clipping,1> { camera_model_d3_multi_clipping() : Object("camera_model_d3_multi_clipping") {}
-		ListOf< camera_model_d3_multi_clipping_interection_select, 1, 0 >::Out shape_clipping;
-    };
-
-    // C++ wrapper for camera_model_d3_multi_clipping_intersection
-    struct camera_model_d3_multi_clipping_intersection : geometric_representation_item, ObjectHelper<camera_model_d3_multi_clipping_intersection,1> { camera_model_d3_multi_clipping_intersection() : Object("camera_model_d3_multi_clipping_intersection") {}
-		ListOf< camera_model_d3_multi_clipping_interection_select, 2, 0 >::Out shape_clipping;
-    };
-
-    // C++ wrapper for camera_model_d3_multi_clipping_union
-    struct camera_model_d3_multi_clipping_union : geometric_representation_item, ObjectHelper<camera_model_d3_multi_clipping_union,1> { camera_model_d3_multi_clipping_union() : Object("camera_model_d3_multi_clipping_union") {}
-		ListOf< camera_model_d3_multi_clipping_union_select, 2, 0 >::Out shape_clipping;
-    };
-
-    // C++ wrapper for camera_model_d3_with_hlhsr
-    struct camera_model_d3_with_hlhsr : camera_model_d3, ObjectHelper<camera_model_d3_with_hlhsr,1> { camera_model_d3_with_hlhsr() : Object("camera_model_d3_with_hlhsr") {}
-		BOOLEAN::Out hidden_line_surface_removal;
-    };
-
-    // C++ wrapper for camera_model_with_light_sources
-    struct camera_model_with_light_sources : camera_model_d3, ObjectHelper<camera_model_with_light_sources,1> { camera_model_with_light_sources() : Object("camera_model_with_light_sources") {}
-		ListOf< Lazy< light_source >, 1, 0 > sources;
-    };
-
-    // C++ wrapper for representation_map
-    struct representation_map :  ObjectHelper<representation_map,2> { representation_map() : Object("representation_map") {}
-		Lazy< representation_item > mapping_origin;
-		Lazy< representation > mapped_representation;
-    };
-
-    // C++ wrapper for camera_usage
-    struct camera_usage : representation_map, ObjectHelper<camera_usage,0> { camera_usage() : Object("camera_usage") {}
-
-    };
-
-    // C++ wrapper for capacitance_measure_with_unit
-    struct capacitance_measure_with_unit : measure_with_unit, ObjectHelper<capacitance_measure_with_unit,0> { capacitance_measure_with_unit() : Object("capacitance_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for capacitance_unit
-    struct capacitance_unit : derived_unit, ObjectHelper<capacitance_unit,0> { capacitance_unit() : Object("capacitance_unit") {}
-
-    };
-
-    // C++ wrapper for point
-    struct point : geometric_representation_item, ObjectHelper<point,0> { point() : Object("point") {}
-
-    };
-
-    // C++ wrapper for cartesian_point
-    struct cartesian_point : point, ObjectHelper<cartesian_point,1> { cartesian_point() : Object("cartesian_point") {}
-		ListOf< length_measure, 1, 3 >::Out coordinates;
-    };
-
-    // C++ wrapper for cartesian_transformation_operator
-    struct cartesian_transformation_operator :  ObjectHelper<cartesian_transformation_operator,4> { cartesian_transformation_operator() : Object("cartesian_transformation_operator") {}
-		Maybe< Lazy< direction > > axis1;
-		Maybe< Lazy< direction > > axis2;
-		Lazy< cartesian_point > local_origin;
-		Maybe< REAL::Out > scale;
-    };
-
-    // C++ wrapper for cartesian_transformation_operator_2d
-    struct cartesian_transformation_operator_2d : cartesian_transformation_operator, ObjectHelper<cartesian_transformation_operator_2d,0> { cartesian_transformation_operator_2d() : Object("cartesian_transformation_operator_2d") {}
-
-    };
-
-    // C++ wrapper for cartesian_transformation_operator_3d
-    struct cartesian_transformation_operator_3d : cartesian_transformation_operator, ObjectHelper<cartesian_transformation_operator_3d,1> { cartesian_transformation_operator_3d() : Object("cartesian_transformation_operator_3d") {}
-		Maybe< Lazy< direction > > axis3;
-    };
-
-    // C++ wrapper for cc_design_approval
-    struct cc_design_approval : approval_assignment, ObjectHelper<cc_design_approval,1> { cc_design_approval() : Object("cc_design_approval") {}
-		ListOf< approved_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for cc_design_certification
-    struct cc_design_certification : certification_assignment, ObjectHelper<cc_design_certification,1> { cc_design_certification() : Object("cc_design_certification") {}
-		ListOf< certified_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for cc_design_contract
-    struct cc_design_contract : contract_assignment, ObjectHelper<cc_design_contract,1> { cc_design_contract() : Object("cc_design_contract") {}
-		ListOf< contracted_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for cc_design_date_and_time_assignment
-    struct cc_design_date_and_time_assignment : date_and_time_assignment, ObjectHelper<cc_design_date_and_time_assignment,1> { cc_design_date_and_time_assignment() : Object("cc_design_date_and_time_assignment") {}
-		ListOf< date_time_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for cc_design_person_and_organization_assignment
-    struct cc_design_person_and_organization_assignment : person_and_organization_assignment, ObjectHelper<cc_design_person_and_organization_assignment,1> { cc_design_person_and_organization_assignment() : Object("cc_design_person_and_organization_assignment") {}
-		ListOf< cc_person_organization_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for cc_design_security_classification
-    struct cc_design_security_classification : security_classification_assignment, ObjectHelper<cc_design_security_classification,1> { cc_design_security_classification() : Object("cc_design_security_classification") {}
-		ListOf< cc_classified_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for cc_design_specification_reference
-    struct cc_design_specification_reference : document_reference, ObjectHelper<cc_design_specification_reference,1> { cc_design_specification_reference() : Object("cc_design_specification_reference") {}
-		ListOf< cc_specified_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for celsius_temperature_measure_with_unit
-    struct celsius_temperature_measure_with_unit : measure_with_unit, ObjectHelper<celsius_temperature_measure_with_unit,0> { celsius_temperature_measure_with_unit() : Object("celsius_temperature_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for centre_of_symmetry
-    struct centre_of_symmetry : derived_shape_aspect, ObjectHelper<centre_of_symmetry,0> { centre_of_symmetry() : Object("centre_of_symmetry") {}
-
-    };
-
-    // C++ wrapper for change
-    struct change : action_assignment, ObjectHelper<change,1> { change() : Object("change") {}
-		ListOf< work_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for change_request
-    struct change_request : action_request_assignment, ObjectHelper<change_request,1> { change_request() : Object("change_request") {}
-		ListOf< change_request_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for character_glyph_style_outline
-    struct character_glyph_style_outline : founded_item, ObjectHelper<character_glyph_style_outline,1> { character_glyph_style_outline() : Object("character_glyph_style_outline") {}
-		Lazy< curve_style > outline_style;
-    };
-
-    // C++ wrapper for character_glyph_style_stroke
-    struct character_glyph_style_stroke : founded_item, ObjectHelper<character_glyph_style_stroke,1> { character_glyph_style_stroke() : Object("character_glyph_style_stroke") {}
-		Lazy< curve_style > stroke_style;
-    };
-
-    // C++ wrapper for symbol_representation
-    struct symbol_representation : representation, ObjectHelper<symbol_representation,0> { symbol_representation() : Object("symbol_representation") {}
-
-    };
-
-    // C++ wrapper for generic_character_glyph_symbol
-    struct generic_character_glyph_symbol : symbol_representation, ObjectHelper<generic_character_glyph_symbol,0> { generic_character_glyph_symbol() : Object("generic_character_glyph_symbol") {}
-
-    };
-
-    // C++ wrapper for character_glyph_symbol
-    struct character_glyph_symbol : generic_character_glyph_symbol, ObjectHelper<character_glyph_symbol,2> { character_glyph_symbol() : Object("character_glyph_symbol") {}
-		Lazy< planar_extent > character_box;
-		ratio_measure::Out baseline_ratio;
-    };
-
-    // C++ wrapper for character_glyph_symbol_outline
-    struct character_glyph_symbol_outline : character_glyph_symbol, ObjectHelper<character_glyph_symbol_outline,1> { character_glyph_symbol_outline() : Object("character_glyph_symbol_outline") {}
-		ListOf< Lazy< annotation_fill_area >, 1, 0 > outlines;
-    };
-
-    // C++ wrapper for character_glyph_symbol_stroke
-    struct character_glyph_symbol_stroke : character_glyph_symbol, ObjectHelper<character_glyph_symbol_stroke,1> { character_glyph_symbol_stroke() : Object("character_glyph_symbol_stroke") {}
-		ListOf< Lazy< curve >, 1, 0 > strokes;
-    };
-
-    // C++ wrapper for general_property
-    struct general_property :  ObjectHelper<general_property,3> { general_property() : Object("general_property") {}
-		identifier::Out id;
-		label::Out name;
-		Maybe< text::Out > description;
-    };
-
-    // C++ wrapper for characteristic_data_column_header
-    struct characteristic_data_column_header : general_property, ObjectHelper<characteristic_data_column_header,0> { characteristic_data_column_header() : Object("characteristic_data_column_header") {}
-
-    };
-
-    // C++ wrapper for general_property_relationship
-    struct general_property_relationship :  ObjectHelper<general_property_relationship,4> { general_property_relationship() : Object("general_property_relationship") {}
-		label::Out name;
-		Maybe< text::Out > description;
-		Lazy< general_property > relating_property;
-		Lazy< general_property > related_property;
-    };
-
-    // C++ wrapper for characteristic_data_column_header_link
-    struct characteristic_data_column_header_link : general_property_relationship, ObjectHelper<characteristic_data_column_header_link,0> { characteristic_data_column_header_link() : Object("characteristic_data_column_header_link") {}
-
-    };
-
-    // C++ wrapper for characteristic_data_table_header
-    struct characteristic_data_table_header : general_property, ObjectHelper<characteristic_data_table_header,0> { characteristic_data_table_header() : Object("characteristic_data_table_header") {}
-
-    };
-
-    // C++ wrapper for characteristic_data_table_header_decomposition
-    struct characteristic_data_table_header_decomposition : general_property_relationship, ObjectHelper<characteristic_data_table_header_decomposition,0> { characteristic_data_table_header_decomposition() : Object("characteristic_data_table_header_decomposition") {}
-
-    };
-
-    // C++ wrapper for group
-    struct group :  ObjectHelper<group,2> { group() : Object("group") {}
-		label::Out name;
-		Maybe< text::Out > description;
-    };
-
-    // C++ wrapper for characteristic_type
-    struct characteristic_type : group, ObjectHelper<characteristic_type,0> { characteristic_type() : Object("characteristic_type") {}
-
-    };
-
-    // C++ wrapper for characterized_class
-    struct characterized_class :  ObjectHelper<characterized_class,0> { characterized_class() : Object("characterized_class") {}
-
-    };
-
-    // C++ wrapper for characterized_object
-    struct characterized_object :  ObjectHelper<characterized_object,2> { characterized_object() : Object("characterized_object") {}
-		label::Out name;
-		Maybe< text::Out > description;
-    };
-
-    // C++ wrapper for conic
-    struct conic : curve, ObjectHelper<conic,1> { conic() : Object("conic") {}
-		axis2_placement::Out position;
-    };
-
-    // C++ wrapper for circle
-    struct circle : conic, ObjectHelper<circle,1> { circle() : Object("circle") {}
-		positive_length_measure::Out radius;
-    };
-
-    // C++ wrapper for circular_runout_tolerance
-    struct circular_runout_tolerance : geometric_tolerance_with_datum_reference, ObjectHelper<circular_runout_tolerance,0> { circular_runout_tolerance() : Object("circular_runout_tolerance") {}
-
-    };
-
-    // C++ wrapper for class_by_extension
-    struct class_by_extension : class_t, ObjectHelper<class_by_extension,0> { class_by_extension() : Object("class_by_extension") {}
-
-    };
-
-    // C++ wrapper for class_by_intension
-    struct class_by_intension : class_t, ObjectHelper<class_by_intension,0> { class_by_intension() : Object("class_by_intension") {}
-
-    };
-
-    // C++ wrapper for class_system
-    struct class_system : group, ObjectHelper<class_system,0> { class_system() : Object("class_system") {}
-
-    };
-
-    // C++ wrapper for effectivity_context_assignment
-    struct effectivity_context_assignment :  ObjectHelper<effectivity_context_assignment,2> { effectivity_context_assignment() : Object("effectivity_context_assignment") {}
-		Lazy< effectivity_assignment > assigned_effectivity_assignment;
-		Lazy< NotImplemented > role;
-    };
-
-    // C++ wrapper for class_usage_effectivity_context_assignment
-    struct class_usage_effectivity_context_assignment : effectivity_context_assignment, ObjectHelper<class_usage_effectivity_context_assignment,1> { class_usage_effectivity_context_assignment() : Object("class_usage_effectivity_context_assignment") {}
-		ListOf< class_usage_effectivity_context_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for topological_representation_item
-    struct topological_representation_item : representation_item, ObjectHelper<topological_representation_item,0> { topological_representation_item() : Object("topological_representation_item") {}
-
-    };
-
-    // C++ wrapper for connected_face_set
-    struct connected_face_set : topological_representation_item, ObjectHelper<connected_face_set,1> { connected_face_set() : Object("connected_face_set") {}
-		ListOf< Lazy< face >, 1, 0 > cfs_faces;
-    };
-
-    // C++ wrapper for closed_shell
-    struct closed_shell : connected_face_set, ObjectHelper<closed_shell,0> { closed_shell() : Object("closed_shell") {}
-
-    };
-
-    // C++ wrapper for coaxiality_tolerance
-    struct coaxiality_tolerance : geometric_tolerance_with_datum_reference, ObjectHelper<coaxiality_tolerance,0> { coaxiality_tolerance() : Object("coaxiality_tolerance") {}
-
-    };
-
-    // C++ wrapper for colour_specification
-    struct colour_specification : colour, ObjectHelper<colour_specification,1> { colour_specification() : Object("colour_specification") {}
-		label::Out name;
-    };
-
-    // C++ wrapper for colour_rgb
-    struct colour_rgb : colour_specification, ObjectHelper<colour_rgb,3> { colour_rgb() : Object("colour_rgb") {}
-		REAL::Out red;
-		REAL::Out green;
-		REAL::Out blue;
-    };
-
-    // C++ wrapper for common_datum
-    struct common_datum :  ObjectHelper<common_datum,0> { common_datum() : Object("common_datum") {}
-
-    };
-
-    // C++ wrapper for comparison_expression
-    struct comparison_expression :  ObjectHelper<comparison_expression,0> { comparison_expression() : Object("comparison_expression") {}
-
-    };
-
-    // C++ wrapper for complex_clause
-    struct complex_clause : compound_representation_item, ObjectHelper<complex_clause,0> { complex_clause() : Object("complex_clause") {}
-
-    };
-
-    // C++ wrapper for complex_conjunctive_clause
-    struct complex_conjunctive_clause : complex_clause, ObjectHelper<complex_conjunctive_clause,0> { complex_conjunctive_clause() : Object("complex_conjunctive_clause") {}
-
-    };
-
-    // C++ wrapper for complex_disjunctive_clause
-    struct complex_disjunctive_clause : complex_clause, ObjectHelper<complex_disjunctive_clause,0> { complex_disjunctive_clause() : Object("complex_disjunctive_clause") {}
-
-    };
-
-    // C++ wrapper for modified_solid
-    struct modified_solid : solid_model, ObjectHelper<modified_solid,2> { modified_solid() : Object("modified_solid") {}
-		text::Out rationale;
-		base_solid_select::Out base_solid;
-    };
-
-    // C++ wrapper for shelled_solid
-    struct shelled_solid : modified_solid, ObjectHelper<shelled_solid,2> { shelled_solid() : Object("shelled_solid") {}
-		ListOf< Lazy< face_surface >, 1, 0 > deleted_face_set;
-		length_measure::Out thickness;
-    };
-
-    // C++ wrapper for complex_shelled_solid
-    struct complex_shelled_solid : shelled_solid, ObjectHelper<complex_shelled_solid,1> { complex_shelled_solid() : Object("complex_shelled_solid") {}
-		ListOf< length_measure, 1, 0 >::Out thickness_list;
-    };
-
-    // C++ wrapper for composite_assembly_definition
-    struct composite_assembly_definition : product_definition, ObjectHelper<composite_assembly_definition,0> { composite_assembly_definition() : Object("composite_assembly_definition") {}
-
-    };
-
-    // C++ wrapper for composite_assembly_sequence_definition
-    struct composite_assembly_sequence_definition : product_definition, ObjectHelper<composite_assembly_sequence_definition,0> { composite_assembly_sequence_definition() : Object("composite_assembly_sequence_definition") {}
-
-    };
-
-    // C++ wrapper for laminate_table
-    struct laminate_table : product_definition, ObjectHelper<laminate_table,0> { laminate_table() : Object("laminate_table") {}
-
-    };
-
-    // C++ wrapper for part_laminate_table
-    struct part_laminate_table : laminate_table, ObjectHelper<part_laminate_table,0> { part_laminate_table() : Object("part_laminate_table") {}
-
-    };
-
-    // C++ wrapper for composite_assembly_table
-    struct composite_assembly_table : part_laminate_table, ObjectHelper<composite_assembly_table,0> { composite_assembly_table() : Object("composite_assembly_table") {}
-
-    };
-
-    // C++ wrapper for composite_curve_segment
-    struct composite_curve_segment : founded_item, ObjectHelper<composite_curve_segment,3> { composite_curve_segment() : Object("composite_curve_segment") {}
-		transition_code::Out transition;
-		BOOLEAN::Out same_sense;
-		Lazy< curve > parent_curve;
-    };
-
-    // C++ wrapper for material_designation
-    struct material_designation :  ObjectHelper<material_designation,2> { material_designation() : Object("material_designation") {}
-		label::Out name;
-		ListOf< characterized_definition, 1, 0 >::Out definitions;
-    };
-
-    // C++ wrapper for composite_material_designation
-    struct composite_material_designation : material_designation, ObjectHelper<composite_material_designation,0> { composite_material_designation() : Object("composite_material_designation") {}
-
-    };
-
-    // C++ wrapper for composite_shape_aspect
-    struct composite_shape_aspect : shape_aspect, ObjectHelper<composite_shape_aspect,0> { composite_shape_aspect() : Object("composite_shape_aspect") {}
-
-    };
-
-    // C++ wrapper for composite_sheet_representation
-    struct composite_sheet_representation : shape_representation, ObjectHelper<composite_sheet_representation,0> { composite_sheet_representation() : Object("composite_sheet_representation") {}
-
-    };
-
-    // C++ wrapper for composite_text
-    struct composite_text : geometric_representation_item, ObjectHelper<composite_text,1> { composite_text() : Object("composite_text") {}
-		ListOf< text_or_character, 2, 0 >::Out collected_text;
-    };
-
-    // C++ wrapper for composite_text_with_associated_curves
-    struct composite_text_with_associated_curves : composite_text, ObjectHelper<composite_text_with_associated_curves,1> { composite_text_with_associated_curves() : Object("composite_text_with_associated_curves") {}
-		ListOf< Lazy< curve >, 1, 0 > associated_curves;
-    };
-
-    // C++ wrapper for composite_text_with_blanking_box
-    struct composite_text_with_blanking_box : composite_text, ObjectHelper<composite_text_with_blanking_box,1> { composite_text_with_blanking_box() : Object("composite_text_with_blanking_box") {}
-		Lazy< planar_box > blanking;
-    };
-
-    // C++ wrapper for composite_text_with_delineation
-    struct composite_text_with_delineation : composite_text, ObjectHelper<composite_text_with_delineation,1> { composite_text_with_delineation() : Object("composite_text_with_delineation") {}
-		text_delineation::Out delineation;
-    };
-
-    // C++ wrapper for composite_text_with_extent
-    struct composite_text_with_extent : composite_text, ObjectHelper<composite_text_with_extent,1> { composite_text_with_extent() : Object("composite_text_with_extent") {}
-		Lazy< planar_extent > extent;
-    };
-
-    // C++ wrapper for compound_shape_representation
-    struct compound_shape_representation : shape_representation, ObjectHelper<compound_shape_representation,0> { compound_shape_representation() : Object("compound_shape_representation") {}
-
-    };
-
-    // C++ wrapper for concentricity_tolerance
-    struct concentricity_tolerance : geometric_tolerance_with_datum_reference, ObjectHelper<concentricity_tolerance,0> { concentricity_tolerance() : Object("concentricity_tolerance") {}
-
-    };
-
-    // C++ wrapper for concept_feature_relationship
-    struct concept_feature_relationship :  ObjectHelper<concept_feature_relationship,4> { concept_feature_relationship() : Object("concept_feature_relationship") {}
-		label::Out name;
-		Maybe< text::Out > description;
-		Lazy< product_concept_feature > relating_product_concept_feature;
-		Lazy< product_concept_feature > related_product_concept_feature;
-    };
-
-    // C++ wrapper for concept_feature_relationship_with_condition
-    struct concept_feature_relationship_with_condition : concept_feature_relationship, ObjectHelper<concept_feature_relationship_with_condition,1> { concept_feature_relationship_with_condition() : Object("concept_feature_relationship_with_condition") {}
-		Lazy< NotImplemented > conditional_operator;
-    };
-
-    // C++ wrapper for product_concept_feature
-    struct product_concept_feature :  ObjectHelper<product_concept_feature,3> { product_concept_feature() : Object("product_concept_feature") {}
-		identifier::Out id;
-		label::Out name;
-		Maybe< text::Out > description;
-    };
-
-    // C++ wrapper for conditional_concept_feature
-    struct conditional_concept_feature : product_concept_feature, ObjectHelper<conditional_concept_feature,1> { conditional_concept_feature() : Object("conditional_concept_feature") {}
-		Lazy< concept_feature_relationship_with_condition > condition;
-    };
-
-    // C++ wrapper for conductance_measure_with_unit
-    struct conductance_measure_with_unit : measure_with_unit, ObjectHelper<conductance_measure_with_unit,0> { conductance_measure_with_unit() : Object("conductance_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for conductance_unit
-    struct conductance_unit : derived_unit, ObjectHelper<conductance_unit,0> { conductance_unit() : Object("conductance_unit") {}
-
-    };
-
-    // C++ wrapper for configuration_item
-    struct configuration_item :  ObjectHelper<configuration_item,5> { configuration_item() : Object("configuration_item") {}
-		identifier::Out id;
-		label::Out name;
-		Maybe< text::Out > description;
-		Lazy< NotImplemented > item_concept;
-		Maybe< label::Out > purpose;
-    };
-
-    // C++ wrapper for configurable_item
-    struct configurable_item : configuration_item, ObjectHelper<configurable_item,1> { configurable_item() : Object("configurable_item") {}
-		ListOf< Lazy< NotImplemented >, 1, 0 > item_concept_feature;
-    };
-
-    // C++ wrapper for effectivity
-    struct effectivity :  ObjectHelper<effectivity,1> { effectivity() : Object("effectivity") {}
-		identifier::Out id;
-    };
-
-    // C++ wrapper for product_definition_effectivity
-    struct product_definition_effectivity : effectivity, ObjectHelper<product_definition_effectivity,1> { product_definition_effectivity() : Object("product_definition_effectivity") {}
-		Lazy< product_definition_relationship > usage;
-    };
-
-    // C++ wrapper for configuration_effectivity
-    struct configuration_effectivity : product_definition_effectivity, ObjectHelper<configuration_effectivity,1> { configuration_effectivity() : Object("configuration_effectivity") {}
-		Lazy< NotImplemented > configuration;
-    };
-
-    // C++ wrapper for configuration_item_relationship
-    struct configuration_item_relationship :  ObjectHelper<configuration_item_relationship,4> { configuration_item_relationship() : Object("configuration_item_relationship") {}
-		label::Out name;
-		Maybe< text::Out > description;
-		Lazy< configuration_item > relating_configuration_item;
-		Lazy< configuration_item > related_configuration_item;
-    };
-
-    // C++ wrapper for configuration_item_hierarchical_relationship
-    struct configuration_item_hierarchical_relationship : configuration_item_relationship, ObjectHelper<configuration_item_hierarchical_relationship,0> { configuration_item_hierarchical_relationship() : Object("configuration_item_hierarchical_relationship") {}
-
-    };
-
-    // C++ wrapper for configuration_item_revision_sequence
-    struct configuration_item_revision_sequence : configuration_item_relationship, ObjectHelper<configuration_item_revision_sequence,0> { configuration_item_revision_sequence() : Object("configuration_item_revision_sequence") {}
-
-    };
-
-    // C++ wrapper for configured_effectivity_assignment
-    struct configured_effectivity_assignment : effectivity_assignment, ObjectHelper<configured_effectivity_assignment,1> { configured_effectivity_assignment() : Object("configured_effectivity_assignment") {}
-		ListOf< configured_effectivity_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for configured_effectivity_context_assignment
-    struct configured_effectivity_context_assignment : effectivity_context_assignment, ObjectHelper<configured_effectivity_context_assignment,1> { configured_effectivity_context_assignment() : Object("configured_effectivity_context_assignment") {}
-		ListOf< configured_effectivity_context_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for conical_stepped_hole_transition
-    struct conical_stepped_hole_transition : geometric_representation_item, ObjectHelper<conical_stepped_hole_transition,3> { conical_stepped_hole_transition() : Object("conical_stepped_hole_transition") {}
-		positive_integer::Out transition_number;
-		plane_angle_measure::Out cone_apex_angle;
-		positive_length_measure::Out cone_base_radius;
-    };
-
-    // C++ wrapper for elementary_surface
-    struct elementary_surface : surface, ObjectHelper<elementary_surface,1> { elementary_surface() : Object("elementary_surface") {}
-		Lazy< axis2_placement_3d > position;
-    };
-
-    // C++ wrapper for conical_surface
-    struct conical_surface : elementary_surface, ObjectHelper<conical_surface,2> { conical_surface() : Object("conical_surface") {}
-		length_measure::Out radius;
-		plane_angle_measure::Out semi_angle;
-    };
-
-    // C++ wrapper for connected_edge_set
-    struct connected_edge_set : topological_representation_item, ObjectHelper<connected_edge_set,1> { connected_edge_set() : Object("connected_edge_set") {}
-		ListOf< Lazy< edge >, 1, 0 > ces_edges;
-    };
-
-    // C++ wrapper for connected_face_sub_set
-    struct connected_face_sub_set : connected_face_set, ObjectHelper<connected_face_sub_set,1> { connected_face_sub_set() : Object("connected_face_sub_set") {}
-		Lazy< connected_face_set > parent_face_set;
-    };
-
-    // C++ wrapper for constructive_geometry_representation
-    struct constructive_geometry_representation : representation, ObjectHelper<constructive_geometry_representation,0> { constructive_geometry_representation() : Object("constructive_geometry_representation") {}
-
-    };
-
-    // C++ wrapper for representation_relationship
-    struct representation_relationship :  ObjectHelper<representation_relationship,4> { representation_relationship() : Object("representation_relationship") {}
-		label::Out name;
-		Maybe< text::Out > description;
-		Lazy< representation > rep_1;
-		Lazy< representation > rep_2;
-    };
-
-    // C++ wrapper for constructive_geometry_representation_relationship
-    struct constructive_geometry_representation_relationship : representation_relationship, ObjectHelper<constructive_geometry_representation_relationship,0> { constructive_geometry_representation_relationship() : Object("constructive_geometry_representation_relationship") {}
-
-    };
-
-    // C++ wrapper for contact_ratio_representation
-    struct contact_ratio_representation : representation, ObjectHelper<contact_ratio_representation,0> { contact_ratio_representation() : Object("contact_ratio_representation") {}
-
-    };
-
-    // C++ wrapper for invisibility
-    struct invisibility :  ObjectHelper<invisibility,1> { invisibility() : Object("invisibility") {}
-		ListOf< invisible_item, 1, 0 >::Out invisible_items;
-    };
-
-    // C++ wrapper for context_dependent_invisibility
-    struct context_dependent_invisibility : invisibility, ObjectHelper<context_dependent_invisibility,1> { context_dependent_invisibility() : Object("context_dependent_invisibility") {}
-		invisibility_context::Out presentation_context;
-    };
-
-    // C++ wrapper for over_riding_styled_item
-    struct over_riding_styled_item : styled_item, ObjectHelper<over_riding_styled_item,1> { over_riding_styled_item() : Object("over_riding_styled_item") {}
-		Lazy< styled_item > over_ridden_style;
-    };
-
-    // C++ wrapper for context_dependent_over_riding_styled_item
-    struct context_dependent_over_riding_styled_item : over_riding_styled_item, ObjectHelper<context_dependent_over_riding_styled_item,1> { context_dependent_over_riding_styled_item() : Object("context_dependent_over_riding_styled_item") {}
-		ListOf< style_context_select, 1, 0 >::Out style_context;
-    };
-
-    // C++ wrapper for context_dependent_unit
-    struct context_dependent_unit : named_unit, ObjectHelper<context_dependent_unit,1> { context_dependent_unit() : Object("context_dependent_unit") {}
-		label::Out name;
-    };
-
-    // C++ wrapper for conversion_based_unit
-    struct conversion_based_unit : named_unit, ObjectHelper<conversion_based_unit,2> { conversion_based_unit() : Object("conversion_based_unit") {}
-		label::Out name;
-		Lazy< measure_with_unit > conversion_factor;
-    };
-
-    // C++ wrapper for csg_shape_representation
-    struct csg_shape_representation : shape_representation, ObjectHelper<csg_shape_representation,0> { csg_shape_representation() : Object("csg_shape_representation") {}
-
-    };
-
-    // C++ wrapper for csg_solid
-    struct csg_solid : solid_model, ObjectHelper<csg_solid,1> { csg_solid() : Object("csg_solid") {}
-		csg_select::Out tree_root_expression;
-    };
-
-    // C++ wrapper for currency
-    struct currency : context_dependent_unit, ObjectHelper<currency,0> { currency() : Object("currency") {}
-
-    };
-
-    // C++ wrapper for currency_measure_with_unit
-    struct currency_measure_with_unit : measure_with_unit, ObjectHelper<currency_measure_with_unit,0> { currency_measure_with_unit() : Object("currency_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for curve_bounded_surface
-    struct curve_bounded_surface : bounded_surface, ObjectHelper<curve_bounded_surface,3> { curve_bounded_surface() : Object("curve_bounded_surface") {}
-		Lazy< surface > basis_surface;
-		ListOf< Lazy< boundary_curve >, 1, 0 > boundaries;
-		BOOLEAN::Out implicit_outer;
-    };
-
-    // C++ wrapper for curve_dimension
-    struct curve_dimension : dimension_curve_directed_callout, ObjectHelper<curve_dimension,0> { curve_dimension() : Object("curve_dimension") {}
-
-    };
-
-    // C++ wrapper for curve_replica
-    struct curve_replica : curve, ObjectHelper<curve_replica,2> { curve_replica() : Object("curve_replica") {}
-		Lazy< curve > parent_curve;
-		Lazy< cartesian_transformation_operator > transformation;
-    };
-
-    // C++ wrapper for curve_style
-    struct curve_style : founded_item, ObjectHelper<curve_style,4> { curve_style() : Object("curve_style") {}
-		label::Out name;
-		curve_font_or_scaled_curve_font_select::Out curve_font;
-		size_select::Out curve_width;
-		Lazy< colour > curve_colour;
-    };
-
-    // C++ wrapper for curve_style_font
-    struct curve_style_font : founded_item, ObjectHelper<curve_style_font,2> { curve_style_font() : Object("curve_style_font") {}
-		label::Out name;
-		ListOf< Lazy< curve_style_font_pattern >, 1, 0 > pattern_list;
-    };
-
-    // C++ wrapper for curve_style_font_and_scaling
-    struct curve_style_font_and_scaling : founded_item, ObjectHelper<curve_style_font_and_scaling,3> { curve_style_font_and_scaling() : Object("curve_style_font_and_scaling") {}
-		label::Out name;
-		curve_style_font_select::Out curve_font;
-		REAL::Out curve_font_scaling;
-    };
-
-    // C++ wrapper for curve_style_font_pattern
-    struct curve_style_font_pattern : founded_item, ObjectHelper<curve_style_font_pattern,2> { curve_style_font_pattern() : Object("curve_style_font_pattern") {}
-		positive_length_measure::Out visible_segment_length;
-		positive_length_measure::Out invisible_segment_length;
-    };
-
-    // C++ wrapper for curve_swept_solid_shape_representation
-    struct curve_swept_solid_shape_representation : shape_representation, ObjectHelper<curve_swept_solid_shape_representation,0> { curve_swept_solid_shape_representation() : Object("curve_swept_solid_shape_representation") {}
-
-    };
-
-    // C++ wrapper for cylindrical_surface
-    struct cylindrical_surface : elementary_surface, ObjectHelper<cylindrical_surface,1> { cylindrical_surface() : Object("cylindrical_surface") {}
-		positive_length_measure::Out radius;
-    };
-
-    // C++ wrapper for cylindricity_tolerance
-    struct cylindricity_tolerance : geometric_tolerance, ObjectHelper<cylindricity_tolerance,0> { cylindricity_tolerance() : Object("cylindricity_tolerance") {}
-
-    };
-
-    // C++ wrapper for date_representation_item
-    struct date_representation_item :  ObjectHelper<date_representation_item,0> { date_representation_item() : Object("date_representation_item") {}
-
-    };
-
-    // C++ wrapper for date_time_representation_item
-    struct date_time_representation_item :  ObjectHelper<date_time_representation_item,0> { date_time_representation_item() : Object("date_time_representation_item") {}
-
-    };
-
-    // C++ wrapper for dated_effectivity
-    struct dated_effectivity : effectivity, ObjectHelper<dated_effectivity,2> { dated_effectivity() : Object("dated_effectivity") {}
-		Maybe< date_time_or_event_occurrence::Out > effectivity_end_date;
-		date_time_or_event_occurrence::Out effectivity_start_date;
-    };
-
-    // C++ wrapper for datum
-    struct datum : shape_aspect, ObjectHelper<datum,1> { datum() : Object("datum") {}
-		identifier::Out identification;
-    };
-
-    // C++ wrapper for datum_feature
-    struct datum_feature : shape_aspect, ObjectHelper<datum_feature,0> { datum_feature() : Object("datum_feature") {}
-
-    };
-
-    // C++ wrapper for datum_feature_callout
-    struct datum_feature_callout : draughting_callout, ObjectHelper<datum_feature_callout,0> { datum_feature_callout() : Object("datum_feature_callout") {}
-
-    };
-
-    // C++ wrapper for datum_reference
-    struct datum_reference :  ObjectHelper<datum_reference,2> { datum_reference() : Object("datum_reference") {}
-		INTEGER::Out precedence;
-		Lazy< datum > referenced_datum;
-    };
-
-    // C++ wrapper for datum_target
-    struct datum_target : shape_aspect, ObjectHelper<datum_target,1> { datum_target() : Object("datum_target") {}
-		identifier::Out target_id;
-    };
-
-    // C++ wrapper for datum_target_callout
-    struct datum_target_callout : draughting_callout, ObjectHelper<datum_target_callout,0> { datum_target_callout() : Object("datum_target_callout") {}
-
-    };
-
-    // C++ wrapper for default_tolerance_table
-    struct default_tolerance_table : representation, ObjectHelper<default_tolerance_table,0> { default_tolerance_table() : Object("default_tolerance_table") {}
-
-    };
-
-    // C++ wrapper for default_tolerance_table_cell
-    struct default_tolerance_table_cell : compound_representation_item, ObjectHelper<default_tolerance_table_cell,0> { default_tolerance_table_cell() : Object("default_tolerance_table_cell") {}
-
-    };
-
-    // C++ wrapper for defined_symbol
-    struct defined_symbol : geometric_representation_item, ObjectHelper<defined_symbol,2> { defined_symbol() : Object("defined_symbol") {}
-		defined_symbol_select::Out definition;
-		Lazy< symbol_target > target;
-    };
-
-    // C++ wrapper for definitional_representation
-    struct definitional_representation : representation, ObjectHelper<definitional_representation,0> { definitional_representation() : Object("definitional_representation") {}
-
-    };
-
-    // C++ wrapper for definitional_representation_relationship
-    struct definitional_representation_relationship : representation_relationship, ObjectHelper<definitional_representation_relationship,0> { definitional_representation_relationship() : Object("definitional_representation_relationship") {}
-
-    };
-
-    // C++ wrapper for definitional_representation_relationship_with_same_context
-    struct definitional_representation_relationship_with_same_context : definitional_representation_relationship, ObjectHelper<definitional_representation_relationship_with_same_context,0> { definitional_representation_relationship_with_same_context() : Object("definitional_representation_relationship_with_same_context") {}
-
-    };
-
-    // C++ wrapper for degenerate_pcurve
-    struct degenerate_pcurve : point, ObjectHelper<degenerate_pcurve,2> { degenerate_pcurve() : Object("degenerate_pcurve") {}
-		Lazy< surface > basis_surface;
-		Lazy< definitional_representation > reference_to_curve;
-    };
-
-    // C++ wrapper for toroidal_surface
-    struct toroidal_surface : elementary_surface, ObjectHelper<toroidal_surface,2> { toroidal_surface() : Object("toroidal_surface") {}
-		positive_length_measure::Out major_radius;
-		positive_length_measure::Out minor_radius;
-    };
-
-    // C++ wrapper for degenerate_toroidal_surface
-    struct degenerate_toroidal_surface : toroidal_surface, ObjectHelper<degenerate_toroidal_surface,1> { degenerate_toroidal_surface() : Object("degenerate_toroidal_surface") {}
-		BOOLEAN::Out select_outer;
-    };
-
-    // C++ wrapper for descriptive_representation_item
-    struct descriptive_representation_item : representation_item, ObjectHelper<descriptive_representation_item,1> { descriptive_representation_item() : Object("descriptive_representation_item") {}
-		text::Out description;
-    };
-
-    // C++ wrapper for product_definition_context
-    struct product_definition_context : application_context_element, ObjectHelper<product_definition_context,1> { product_definition_context() : Object("product_definition_context") {}
-		label::Out life_cycle_stage;
-    };
-
-    // C++ wrapper for design_context
-    struct design_context : product_definition_context, ObjectHelper<design_context,0> { design_context() : Object("design_context") {}
-
-    };
-
-    // C++ wrapper for design_make_from_relationship
-    struct design_make_from_relationship : product_definition_relationship, ObjectHelper<design_make_from_relationship,0> { design_make_from_relationship() : Object("design_make_from_relationship") {}
-
-    };
-
-    // C++ wrapper for diameter_dimension
-    struct diameter_dimension : dimension_curve_directed_callout, ObjectHelper<diameter_dimension,0> { diameter_dimension() : Object("diameter_dimension") {}
-
-    };
-
-    // C++ wrapper for ratio_measure_with_unit
-    struct ratio_measure_with_unit : measure_with_unit, ObjectHelper<ratio_measure_with_unit,0> { ratio_measure_with_unit() : Object("ratio_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for dielectric_constant_measure_with_unit
-    struct dielectric_constant_measure_with_unit : ratio_measure_with_unit, ObjectHelper<dielectric_constant_measure_with_unit,0> { dielectric_constant_measure_with_unit() : Object("dielectric_constant_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for dimension_callout
-    struct dimension_callout : draughting_callout, ObjectHelper<dimension_callout,0> { dimension_callout() : Object("dimension_callout") {}
-
-    };
-
-    // C++ wrapper for draughting_callout_relationship
-    struct draughting_callout_relationship :  ObjectHelper<draughting_callout_relationship,4> { draughting_callout_relationship() : Object("draughting_callout_relationship") {}
-		label::Out name;
-		text::Out description;
-		Lazy< draughting_callout > relating_draughting_callout;
-		Lazy< draughting_callout > related_draughting_callout;
-    };
-
-    // C++ wrapper for dimension_callout_component_relationship
-    struct dimension_callout_component_relationship : draughting_callout_relationship, ObjectHelper<dimension_callout_component_relationship,0> { dimension_callout_component_relationship() : Object("dimension_callout_component_relationship") {}
-
-    };
-
-    // C++ wrapper for dimension_callout_relationship
-    struct dimension_callout_relationship : draughting_callout_relationship, ObjectHelper<dimension_callout_relationship,0> { dimension_callout_relationship() : Object("dimension_callout_relationship") {}
-
-    };
-
-    // C++ wrapper for dimension_curve
-    struct dimension_curve : annotation_curve_occurrence, ObjectHelper<dimension_curve,0> { dimension_curve() : Object("dimension_curve") {}
-
-    };
-
-    // C++ wrapper for terminator_symbol
-    struct terminator_symbol : annotation_symbol_occurrence, ObjectHelper<terminator_symbol,1> { terminator_symbol() : Object("terminator_symbol") {}
-		Lazy< annotation_curve_occurrence > annotated_curve;
-    };
-
-    // C++ wrapper for dimension_curve_terminator
-    struct dimension_curve_terminator : terminator_symbol, ObjectHelper<dimension_curve_terminator,1> { dimension_curve_terminator() : Object("dimension_curve_terminator") {}
-		dimension_extent_usage::Out role;
-    };
-
-    // C++ wrapper for dimension_curve_terminator_to_projection_curve_associativity
-    struct dimension_curve_terminator_to_projection_curve_associativity : annotation_occurrence_associativity, ObjectHelper<dimension_curve_terminator_to_projection_curve_associativity,0> { dimension_curve_terminator_to_projection_curve_associativity() : Object("dimension_curve_terminator_to_projection_curve_associativity") {}
-
-    };
-
-    // C++ wrapper for dimension_pair
-    struct dimension_pair : draughting_callout_relationship, ObjectHelper<dimension_pair,0> { dimension_pair() : Object("dimension_pair") {}
-
-    };
-
-    // C++ wrapper for dimension_text_associativity
-    struct dimension_text_associativity :  ObjectHelper<dimension_text_associativity,0> { dimension_text_associativity() : Object("dimension_text_associativity") {}
-
-    };
-
-    // C++ wrapper for dimensional_location_with_path
-    struct dimensional_location_with_path : dimensional_location, ObjectHelper<dimensional_location_with_path,1> { dimensional_location_with_path() : Object("dimensional_location_with_path") {}
-		Lazy< shape_aspect > path;
-    };
-
-    // C++ wrapper for dimensional_size_with_path
-    struct dimensional_size_with_path : dimensional_size, ObjectHelper<dimensional_size_with_path,1> { dimensional_size_with_path() : Object("dimensional_size_with_path") {}
-		Lazy< shape_aspect > path;
-    };
-
-    // C++ wrapper for executed_action
-    struct executed_action : action, ObjectHelper<executed_action,0> { executed_action() : Object("executed_action") {}
-
-    };
-
-    // C++ wrapper for directed_action
-    struct directed_action : executed_action, ObjectHelper<directed_action,1> { directed_action() : Object("directed_action") {}
-		Lazy< NotImplemented > directive;
-    };
-
-    // C++ wrapper for directed_dimensional_location
-    struct directed_dimensional_location : dimensional_location, ObjectHelper<directed_dimensional_location,0> { directed_dimensional_location() : Object("directed_dimensional_location") {}
-
-    };
-
-    // C++ wrapper for direction
-    struct direction : geometric_representation_item, ObjectHelper<direction,1> { direction() : Object("direction") {}
-		ListOf< REAL, 2, 3 >::Out direction_ratios;
-    };
-
-    // C++ wrapper for document_file
-    struct document_file :  ObjectHelper<document_file,0> { document_file() : Object("document_file") {}
-
-    };
-
-    // C++ wrapper for document_identifier
-    struct document_identifier : group, ObjectHelper<document_identifier,0> { document_identifier() : Object("document_identifier") {}
-
-    };
-
-    // C++ wrapper for document_identifier_assignment
-    struct document_identifier_assignment : group_assignment, ObjectHelper<document_identifier_assignment,1> { document_identifier_assignment() : Object("document_identifier_assignment") {}
-		ListOf< document_identifier_assigned_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for document_product_association
-    struct document_product_association :  ObjectHelper<document_product_association,4> { document_product_association() : Object("document_product_association") {}
-		label::Out name;
-		Maybe< text::Out > description;
-		Lazy< NotImplemented > relating_document;
-		product_or_formation_or_definition::Out related_product;
-    };
-
-    // C++ wrapper for document_product_equivalence
-    struct document_product_equivalence : document_product_association, ObjectHelper<document_product_equivalence,0> { document_product_equivalence() : Object("document_product_equivalence") {}
-
-    };
-
-    // C++ wrapper for dose_equivalent_measure_with_unit
-    struct dose_equivalent_measure_with_unit : measure_with_unit, ObjectHelper<dose_equivalent_measure_with_unit,0> { dose_equivalent_measure_with_unit() : Object("dose_equivalent_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for dose_equivalent_unit
-    struct dose_equivalent_unit : derived_unit, ObjectHelper<dose_equivalent_unit,0> { dose_equivalent_unit() : Object("dose_equivalent_unit") {}
-
-    };
-
-    // C++ wrapper for double_offset_shelled_solid
-    struct double_offset_shelled_solid : shelled_solid, ObjectHelper<double_offset_shelled_solid,1> { double_offset_shelled_solid() : Object("double_offset_shelled_solid") {}
-		length_measure::Out thickness2;
-    };
-
-    // C++ wrapper for item_defined_transformation
-    struct item_defined_transformation :  ObjectHelper<item_defined_transformation,4> { item_defined_transformation() : Object("item_defined_transformation") {}
-		label::Out name;
-		Maybe< text::Out > description;
-		Lazy< representation_item > transform_item_1;
-		Lazy< representation_item > transform_item_2;
-    };
-
-    // C++ wrapper for transformation_with_derived_angle
-    struct transformation_with_derived_angle : item_defined_transformation, ObjectHelper<transformation_with_derived_angle,0> { transformation_with_derived_angle() : Object("transformation_with_derived_angle") {}
-
-    };
-
-    // C++ wrapper for draped_defined_transformation
-    struct draped_defined_transformation : transformation_with_derived_angle, ObjectHelper<draped_defined_transformation,0> { draped_defined_transformation() : Object("draped_defined_transformation") {}
-
-    };
-
-    // C++ wrapper for draughting_annotation_occurrence
-    struct draughting_annotation_occurrence : annotation_occurrence, ObjectHelper<draughting_annotation_occurrence,0> { draughting_annotation_occurrence() : Object("draughting_annotation_occurrence") {}
-
-    };
-
-    // C++ wrapper for draughting_elements
-    struct draughting_elements : draughting_callout, ObjectHelper<draughting_elements,0> { draughting_elements() : Object("draughting_elements") {}
-
-    };
-
-    // C++ wrapper for draughting_model
-    struct draughting_model : representation, ObjectHelper<draughting_model,0> { draughting_model() : Object("draughting_model") {}
-
-    };
-
-    // C++ wrapper for item_identified_representation_usage
-    struct item_identified_representation_usage :  ObjectHelper<item_identified_representation_usage,5> { item_identified_representation_usage() : Object("item_identified_representation_usage") {}
-		label::Out name;
-		Maybe< text::Out > description;
-		represented_definition::Out definition;
-		Lazy< representation > used_representation;
-		Lazy< representation_item > identified_item;
-    };
-
-    // C++ wrapper for draughting_model_item_association
-    struct draughting_model_item_association : item_identified_representation_usage, ObjectHelper<draughting_model_item_association,0> { draughting_model_item_association() : Object("draughting_model_item_association") {}
-
-    };
-
-    // C++ wrapper for pre_defined_colour
-    struct pre_defined_colour :  ObjectHelper<pre_defined_colour,0> { pre_defined_colour() : Object("pre_defined_colour") {}
-
-    };
-
-    // C++ wrapper for draughting_pre_defined_colour
-    struct draughting_pre_defined_colour : pre_defined_colour, ObjectHelper<draughting_pre_defined_colour,0> { draughting_pre_defined_colour() : Object("draughting_pre_defined_colour") {}
-
-    };
-
-    // C++ wrapper for pre_defined_item
-    struct pre_defined_item :  ObjectHelper<pre_defined_item,1> { pre_defined_item() : Object("pre_defined_item") {}
-		label::Out name;
-    };
-
-    // C++ wrapper for pre_defined_curve_font
-    struct pre_defined_curve_font : pre_defined_item, ObjectHelper<pre_defined_curve_font,0> { pre_defined_curve_font() : Object("pre_defined_curve_font") {}
-
-    };
-
-    // C++ wrapper for draughting_pre_defined_curve_font
-    struct draughting_pre_defined_curve_font : pre_defined_curve_font, ObjectHelper<draughting_pre_defined_curve_font,0> { draughting_pre_defined_curve_font() : Object("draughting_pre_defined_curve_font") {}
-
-    };
-
-    // C++ wrapper for pre_defined_text_font
-    struct pre_defined_text_font : pre_defined_item, ObjectHelper<pre_defined_text_font,0> { pre_defined_text_font() : Object("pre_defined_text_font") {}
-
-    };
-
-    // C++ wrapper for draughting_pre_defined_text_font
-    struct draughting_pre_defined_text_font : pre_defined_text_font, ObjectHelper<draughting_pre_defined_text_font,0> { draughting_pre_defined_text_font() : Object("draughting_pre_defined_text_font") {}
-
-    };
-
-    // C++ wrapper for draughting_subfigure_representation
-    struct draughting_subfigure_representation : symbol_representation, ObjectHelper<draughting_subfigure_representation,0> { draughting_subfigure_representation() : Object("draughting_subfigure_representation") {}
-
-    };
-
-    // C++ wrapper for draughting_symbol_representation
-    struct draughting_symbol_representation : symbol_representation, ObjectHelper<draughting_symbol_representation,0> { draughting_symbol_representation() : Object("draughting_symbol_representation") {}
-
-    };
-
-    // C++ wrapper for text_literal
-    struct text_literal : geometric_representation_item, ObjectHelper<text_literal,5> { text_literal() : Object("text_literal") {}
-		presentable_text::Out literal;
-		axis2_placement::Out placement;
-		text_alignment::Out alignment;
-		text_path::Out path;
-		font_select::Out font;
-    };
-
-    // C++ wrapper for text_literal_with_delineation
-    struct text_literal_with_delineation : text_literal, ObjectHelper<text_literal_with_delineation,1> { text_literal_with_delineation() : Object("text_literal_with_delineation") {}
-		text_delineation::Out delineation;
-    };
-
-    // C++ wrapper for draughting_text_literal_with_delineation
-    struct draughting_text_literal_with_delineation : text_literal_with_delineation, ObjectHelper<draughting_text_literal_with_delineation,0> { draughting_text_literal_with_delineation() : Object("draughting_text_literal_with_delineation") {}
-
-    };
-
-    // C++ wrapper for presentation_set
-    struct presentation_set :  ObjectHelper<presentation_set,0> { presentation_set() : Object("presentation_set") {}
-
-    };
-
-    // C++ wrapper for drawing_revision
-    struct drawing_revision : presentation_set, ObjectHelper<drawing_revision,3> { drawing_revision() : Object("drawing_revision") {}
-		identifier::Out revision_identifier;
-		Lazy< NotImplemented > drawing_identifier;
-		Maybe< text::Out > intended_scale;
-    };
-
-    // C++ wrapper for presentation_representation
-    struct presentation_representation : representation, ObjectHelper<presentation_representation,0> { presentation_representation() : Object("presentation_representation") {}
-
-    };
-
-    // C++ wrapper for presentation_area
-    struct presentation_area : presentation_representation, ObjectHelper<presentation_area,0> { presentation_area() : Object("presentation_area") {}
-
-    };
-
-    // C++ wrapper for drawing_sheet_revision
-    struct drawing_sheet_revision : presentation_area, ObjectHelper<drawing_sheet_revision,1> { drawing_sheet_revision() : Object("drawing_sheet_revision") {}
-		identifier::Out revision_identifier;
-    };
-
-    // C++ wrapper for drawing_sheet_revision_sequence
-    struct drawing_sheet_revision_sequence : representation_relationship, ObjectHelper<drawing_sheet_revision_sequence,0> { drawing_sheet_revision_sequence() : Object("drawing_sheet_revision_sequence") {}
-
-    };
-
-    // C++ wrapper for drawing_sheet_revision_usage
-    struct drawing_sheet_revision_usage : area_in_set, ObjectHelper<drawing_sheet_revision_usage,1> { drawing_sheet_revision_usage() : Object("drawing_sheet_revision_usage") {}
-		identifier::Out sheet_number;
-    };
-
-    // C++ wrapper for edge
-    struct edge : topological_representation_item, ObjectHelper<edge,2> { edge() : Object("edge") {}
-		Lazy< vertex > edge_start;
-		Lazy< vertex > edge_end;
-    };
-
-    // C++ wrapper for edge_based_wireframe_model
-    struct edge_based_wireframe_model : geometric_representation_item, ObjectHelper<edge_based_wireframe_model,1> { edge_based_wireframe_model() : Object("edge_based_wireframe_model") {}
-		ListOf< Lazy< connected_edge_set >, 1, 0 > ebwm_boundary;
-    };
-
-    // C++ wrapper for edge_based_wireframe_shape_representation
-    struct edge_based_wireframe_shape_representation : shape_representation, ObjectHelper<edge_based_wireframe_shape_representation,0> { edge_based_wireframe_shape_representation() : Object("edge_based_wireframe_shape_representation") {}
-
-    };
-
-    // C++ wrapper for edge_blended_solid
-    struct edge_blended_solid : modified_solid, ObjectHelper<edge_blended_solid,1> { edge_blended_solid() : Object("edge_blended_solid") {}
-		ListOf< Lazy< edge_curve >, 1, 0 > blended_edges;
-    };
-
-    // C++ wrapper for edge_curve
-    struct edge_curve :  ObjectHelper<edge_curve,2> { edge_curve() : Object("edge_curve") {}
-		Lazy< curve > edge_geometry;
-		BOOLEAN::Out same_sense;
-    };
-
-    // C++ wrapper for edge_loop
-    struct edge_loop :  ObjectHelper<edge_loop,0> { edge_loop() : Object("edge_loop") {}
-
-    };
-
-    // C++ wrapper for electric_charge_measure_with_unit
-    struct electric_charge_measure_with_unit : measure_with_unit, ObjectHelper<electric_charge_measure_with_unit,0> { electric_charge_measure_with_unit() : Object("electric_charge_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for electric_charge_unit
-    struct electric_charge_unit : derived_unit, ObjectHelper<electric_charge_unit,0> { electric_charge_unit() : Object("electric_charge_unit") {}
-
-    };
-
-    // C++ wrapper for electric_current_measure_with_unit
-    struct electric_current_measure_with_unit : measure_with_unit, ObjectHelper<electric_current_measure_with_unit,0> { electric_current_measure_with_unit() : Object("electric_current_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for electric_current_unit
-    struct electric_current_unit : named_unit, ObjectHelper<electric_current_unit,0> { electric_current_unit() : Object("electric_current_unit") {}
-
-    };
-
-    // C++ wrapper for electric_potential_measure_with_unit
-    struct electric_potential_measure_with_unit : measure_with_unit, ObjectHelper<electric_potential_measure_with_unit,0> { electric_potential_measure_with_unit() : Object("electric_potential_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for electric_potential_unit
-    struct electric_potential_unit : derived_unit, ObjectHelper<electric_potential_unit,0> { electric_potential_unit() : Object("electric_potential_unit") {}
-
-    };
-
-    // C++ wrapper for elementary_brep_shape_representation
-    struct elementary_brep_shape_representation : shape_representation, ObjectHelper<elementary_brep_shape_representation,0> { elementary_brep_shape_representation() : Object("elementary_brep_shape_representation") {}
-
-    };
-
-    // C++ wrapper for ellipse
-    struct ellipse : conic, ObjectHelper<ellipse,2> { ellipse() : Object("ellipse") {}
-		positive_length_measure::Out semi_axis_1;
-		positive_length_measure::Out semi_axis_2;
-    };
-
-    // C++ wrapper for energy_measure_with_unit
-    struct energy_measure_with_unit : measure_with_unit, ObjectHelper<energy_measure_with_unit,0> { energy_measure_with_unit() : Object("energy_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for energy_unit
-    struct energy_unit : derived_unit, ObjectHelper<energy_unit,0> { energy_unit() : Object("energy_unit") {}
-
-    };
-
-    // C++ wrapper for property_definition
-    struct property_definition :  ObjectHelper<property_definition,3> { property_definition() : Object("property_definition") {}
-		label::Out name;
-		Maybe< text::Out > description;
-		characterized_definition::Out definition;
-    };
-
-    // C++ wrapper for fact_type
-    struct fact_type : property_definition, ObjectHelper<fact_type,0> { fact_type() : Object("fact_type") {}
-
-    };
-
-    // C++ wrapper for entity_assertion
-    struct entity_assertion : fact_type, ObjectHelper<entity_assertion,0> { entity_assertion() : Object("entity_assertion") {}
-
-    };
-
-    // C++ wrapper for enum_reference_prefix
-    struct enum_reference_prefix : descriptive_representation_item, ObjectHelper<enum_reference_prefix,0> { enum_reference_prefix() : Object("enum_reference_prefix") {}
-
-    };
-
-    // C++ wrapper for evaluated_characteristic
-    struct evaluated_characteristic :  ObjectHelper<evaluated_characteristic,0> { evaluated_characteristic() : Object("evaluated_characteristic") {}
-
-    };
-
-    // C++ wrapper for evaluated_degenerate_pcurve
-    struct evaluated_degenerate_pcurve : degenerate_pcurve, ObjectHelper<evaluated_degenerate_pcurve,1> { evaluated_degenerate_pcurve() : Object("evaluated_degenerate_pcurve") {}
-		Lazy< cartesian_point > equivalent_point;
-    };
-
-    // C++ wrapper for evaluation_product_definition
-    struct evaluation_product_definition : product_definition, ObjectHelper<evaluation_product_definition,0> { evaluation_product_definition() : Object("evaluation_product_definition") {}
-
-    };
-
-    // C++ wrapper for event_occurrence
-    struct event_occurrence :  ObjectHelper<event_occurrence,3> { event_occurrence() : Object("event_occurrence") {}
-		identifier::Out id;
-		label::Out name;
-		Maybe< text::Out > description;
-    };
-
-    // C++ wrapper for product_concept_feature_category
-    struct product_concept_feature_category : group, ObjectHelper<product_concept_feature_category,0> { product_concept_feature_category() : Object("product_concept_feature_category") {}
-
-    };
-
-    // C++ wrapper for exclusive_product_concept_feature_category
-    struct exclusive_product_concept_feature_category : product_concept_feature_category, ObjectHelper<exclusive_product_concept_feature_category,0> { exclusive_product_concept_feature_category() : Object("exclusive_product_concept_feature_category") {}
-
-    };
-
-    // C++ wrapper for uncertainty_qualifier
-    struct uncertainty_qualifier :  ObjectHelper<uncertainty_qualifier,2> { uncertainty_qualifier() : Object("uncertainty_qualifier") {}
-		label::Out measure_name;
-		text::Out description;
-    };
-
-    // C++ wrapper for standard_uncertainty
-    struct standard_uncertainty : uncertainty_qualifier, ObjectHelper<standard_uncertainty,1> { standard_uncertainty() : Object("standard_uncertainty") {}
-		REAL::Out uncertainty_value;
-    };
-
-    // C++ wrapper for expanded_uncertainty
-    struct expanded_uncertainty : standard_uncertainty, ObjectHelper<expanded_uncertainty,1> { expanded_uncertainty() : Object("expanded_uncertainty") {}
-		REAL::Out coverage_factor;
-    };
-
-    // C++ wrapper for representation_item_relationship
-    struct representation_item_relationship :  ObjectHelper<representation_item_relationship,4> { representation_item_relationship() : Object("representation_item_relationship") {}
-		label::Out name;
-		Maybe< text::Out > description;
-		Lazy< representation_item > relating_representation_item;
-		Lazy< representation_item > related_representation_item;
-    };
-
-    // C++ wrapper for explicit_procedural_representation_item_relationship
-    struct explicit_procedural_representation_item_relationship : representation_item_relationship, ObjectHelper<explicit_procedural_representation_item_relationship,0> { explicit_procedural_representation_item_relationship() : Object("explicit_procedural_representation_item_relationship") {}
-
-    };
-
-    // C++ wrapper for explicit_procedural_geometric_representation_item_relationship
-    struct explicit_procedural_geometric_representation_item_relationship : explicit_procedural_representation_item_relationship, ObjectHelper<explicit_procedural_geometric_representation_item_relationship,0> { explicit_procedural_geometric_representation_item_relationship() : Object("explicit_procedural_geometric_representation_item_relationship") {}
-
-    };
-
-    // C++ wrapper for explicit_procedural_representation_relationship
-    struct explicit_procedural_representation_relationship : representation_relationship, ObjectHelper<explicit_procedural_representation_relationship,0> { explicit_procedural_representation_relationship() : Object("explicit_procedural_representation_relationship") {}
-
-    };
-
-    // C++ wrapper for explicit_procedural_shape_representation_relationship
-    struct explicit_procedural_shape_representation_relationship : explicit_procedural_representation_relationship, ObjectHelper<explicit_procedural_shape_representation_relationship,0> { explicit_procedural_shape_representation_relationship() : Object("explicit_procedural_shape_representation_relationship") {}
-
-    };
-
-    // C++ wrapper for expression_conversion_based_unit
-    struct expression_conversion_based_unit :  ObjectHelper<expression_conversion_based_unit,0> { expression_conversion_based_unit() : Object("expression_conversion_based_unit") {}
-
-    };
-
-    // C++ wrapper for extension
-    struct extension : derived_shape_aspect, ObjectHelper<extension,0> { extension() : Object("extension") {}
-
-    };
-
-    // C++ wrapper for extent
-    struct extent : characterized_object, ObjectHelper<extent,0> { extent() : Object("extent") {}
-
-    };
-
-    // C++ wrapper for external_source
-    struct external_source :  ObjectHelper<external_source,1> { external_source() : Object("external_source") {}
-		source_item::Out source_id;
-    };
-
-    // C++ wrapper for external_class_library
-    struct external_class_library : external_source, ObjectHelper<external_class_library,0> { external_class_library() : Object("external_class_library") {}
-
-    };
-
-    // C++ wrapper for externally_defined_class
-    struct externally_defined_class :  ObjectHelper<externally_defined_class,0> { externally_defined_class() : Object("externally_defined_class") {}
-
-    };
-
-    // C++ wrapper for externally_defined_colour
-    struct externally_defined_colour :  ObjectHelper<externally_defined_colour,0> { externally_defined_colour() : Object("externally_defined_colour") {}
-
-    };
-
-    // C++ wrapper for externally_defined_context_dependent_unit
-    struct externally_defined_context_dependent_unit :  ObjectHelper<externally_defined_context_dependent_unit,0> { externally_defined_context_dependent_unit() : Object("externally_defined_context_dependent_unit") {}
-
-    };
-
-    // C++ wrapper for externally_defined_conversion_based_unit
-    struct externally_defined_conversion_based_unit :  ObjectHelper<externally_defined_conversion_based_unit,0> { externally_defined_conversion_based_unit() : Object("externally_defined_conversion_based_unit") {}
-
-    };
-
-    // C++ wrapper for externally_defined_currency
-    struct externally_defined_currency :  ObjectHelper<externally_defined_currency,0> { externally_defined_currency() : Object("externally_defined_currency") {}
-
-    };
-
-    // C++ wrapper for externally_defined_item
-    struct externally_defined_item :  ObjectHelper<externally_defined_item,2> { externally_defined_item() : Object("externally_defined_item") {}
-		source_item::Out item_id;
-		Lazy< external_source > source;
-    };
-
-    // C++ wrapper for externally_defined_curve_font
-    struct externally_defined_curve_font : externally_defined_item, ObjectHelper<externally_defined_curve_font,0> { externally_defined_curve_font() : Object("externally_defined_curve_font") {}
-
-    };
-
-    // C++ wrapper for externally_defined_dimension_definition
-    struct externally_defined_dimension_definition :  ObjectHelper<externally_defined_dimension_definition,0> { externally_defined_dimension_definition() : Object("externally_defined_dimension_definition") {}
-
-    };
-
-    // C++ wrapper for externally_defined_general_property
-    struct externally_defined_general_property :  ObjectHelper<externally_defined_general_property,0> { externally_defined_general_property() : Object("externally_defined_general_property") {}
-
-    };
-
-    // C++ wrapper for externally_defined_hatch_style
-    struct externally_defined_hatch_style :  ObjectHelper<externally_defined_hatch_style,0> { externally_defined_hatch_style() : Object("externally_defined_hatch_style") {}
-
-    };
-
-    // C++ wrapper for externally_defined_marker
-    struct externally_defined_marker :  ObjectHelper<externally_defined_marker,0> { externally_defined_marker() : Object("externally_defined_marker") {}
-
-    };
-
-    // C++ wrapper for picture_representation_item
-    struct picture_representation_item : bytes_representation_item, ObjectHelper<picture_representation_item,0> { picture_representation_item() : Object("picture_representation_item") {}
-
-    };
-
-    // C++ wrapper for externally_defined_picture_representation_item
-    struct externally_defined_picture_representation_item : picture_representation_item, ObjectHelper<externally_defined_picture_representation_item,0> { externally_defined_picture_representation_item() : Object("externally_defined_picture_representation_item") {}
-
-    };
-
-    // C++ wrapper for externally_defined_representation_item
-    struct externally_defined_representation_item :  ObjectHelper<externally_defined_representation_item,0> { externally_defined_representation_item() : Object("externally_defined_representation_item") {}
-
-    };
-
-    // C++ wrapper for externally_defined_string
-    struct externally_defined_string : externally_defined_representation_item, ObjectHelper<externally_defined_string,0> { externally_defined_string() : Object("externally_defined_string") {}
-
-    };
-
-    // C++ wrapper for externally_defined_symbol
-    struct externally_defined_symbol : externally_defined_item, ObjectHelper<externally_defined_symbol,0> { externally_defined_symbol() : Object("externally_defined_symbol") {}
-
-    };
-
-    // C++ wrapper for externally_defined_terminator_symbol
-    struct externally_defined_terminator_symbol : externally_defined_symbol, ObjectHelper<externally_defined_terminator_symbol,0> { externally_defined_terminator_symbol() : Object("externally_defined_terminator_symbol") {}
-
-    };
-
-    // C++ wrapper for externally_defined_text_font
-    struct externally_defined_text_font : externally_defined_item, ObjectHelper<externally_defined_text_font,0> { externally_defined_text_font() : Object("externally_defined_text_font") {}
-
-    };
-
-    // C++ wrapper for externally_defined_tile
-    struct externally_defined_tile : externally_defined_item, ObjectHelper<externally_defined_tile,0> { externally_defined_tile() : Object("externally_defined_tile") {}
-
-    };
-
-    // C++ wrapper for externally_defined_tile_style
-    struct externally_defined_tile_style :  ObjectHelper<externally_defined_tile_style,0> { externally_defined_tile_style() : Object("externally_defined_tile_style") {}
-
-    };
-
-    // C++ wrapper for swept_area_solid
-    struct swept_area_solid : solid_model, ObjectHelper<swept_area_solid,1> { swept_area_solid() : Object("swept_area_solid") {}
-		Lazy< curve_bounded_surface > swept_area;
-    };
-
-    // C++ wrapper for extruded_area_solid
-    struct extruded_area_solid : swept_area_solid, ObjectHelper<extruded_area_solid,2> { extruded_area_solid() : Object("extruded_area_solid") {}
-		Lazy< direction > extruded_direction;
-		positive_length_measure::Out depth;
-    };
-
-    // C++ wrapper for swept_face_solid
-    struct swept_face_solid : solid_model, ObjectHelper<swept_face_solid,1> { swept_face_solid() : Object("swept_face_solid") {}
-		Lazy< face_surface > swept_face;
-    };
-
-    // C++ wrapper for extruded_face_solid
-    struct extruded_face_solid : swept_face_solid, ObjectHelper<extruded_face_solid,2> { extruded_face_solid() : Object("extruded_face_solid") {}
-		Lazy< direction > extruded_direction;
-		positive_length_measure::Out depth;
-    };
-
-    // C++ wrapper for extruded_face_solid_with_trim_conditions
-    struct extruded_face_solid_with_trim_conditions : extruded_face_solid, ObjectHelper<extruded_face_solid_with_trim_conditions,6> { extruded_face_solid_with_trim_conditions() : Object("extruded_face_solid_with_trim_conditions") {}
-		trim_condition_select::Out first_trim_condition;
-		trim_condition_select::Out second_trim_condition;
-		trim_intent::Out first_trim_intent;
-		trim_intent::Out second_trim_intent;
-		non_negative_length_measure::Out first_offset;
-		non_negative_length_measure::Out second_offset;
-    };
-
-    // C++ wrapper for extruded_face_solid_with_draft_angle
-    struct extruded_face_solid_with_draft_angle : extruded_face_solid_with_trim_conditions, ObjectHelper<extruded_face_solid_with_draft_angle,1> { extruded_face_solid_with_draft_angle() : Object("extruded_face_solid_with_draft_angle") {}
-		plane_angle_measure::Out draft_angle;
-    };
-
-    // C++ wrapper for extruded_face_solid_with_multiple_draft_angles
-    struct extruded_face_solid_with_multiple_draft_angles : extruded_face_solid_with_trim_conditions, ObjectHelper<extruded_face_solid_with_multiple_draft_angles,1> { extruded_face_solid_with_multiple_draft_angles() : Object("extruded_face_solid_with_multiple_draft_angles") {}
-		ListOf< plane_angle_measure, 2, 0 >::Out draft_angles;
-    };
-
-    // C++ wrapper for face
-    struct face : topological_representation_item, ObjectHelper<face,1> { face() : Object("face") {}
-		ListOf< Lazy< face_bound >, 1, 0 > bounds;
-    };
-
-    // C++ wrapper for face_based_surface_model
-    struct face_based_surface_model : geometric_representation_item, ObjectHelper<face_based_surface_model,1> { face_based_surface_model() : Object("face_based_surface_model") {}
-		ListOf< Lazy< connected_face_set >, 1, 0 > fbsm_faces;
-    };
-
-    // C++ wrapper for face_bound
-    struct face_bound : topological_representation_item, ObjectHelper<face_bound,2> { face_bound() : Object("face_bound") {}
-		Lazy< loop > bound;
-		BOOLEAN::Out orientation;
-    };
-
-    // C++ wrapper for face_outer_bound
-    struct face_outer_bound : face_bound, ObjectHelper<face_outer_bound,0> { face_outer_bound() : Object("face_outer_bound") {}
-
-    };
-
-    // C++ wrapper for faceted_brep
-    struct faceted_brep : manifold_solid_brep, ObjectHelper<faceted_brep,0> { faceted_brep() : Object("faceted_brep") {}
-
-    };
-
-    // C++ wrapper for faceted_brep_shape_representation
-    struct faceted_brep_shape_representation : shape_representation, ObjectHelper<faceted_brep_shape_representation,0> { faceted_brep_shape_representation() : Object("faceted_brep_shape_representation") {}
-
-    };
-
-    // C++ wrapper for fill_area_style
-    struct fill_area_style : founded_item, ObjectHelper<fill_area_style,2> { fill_area_style() : Object("fill_area_style") {}
-		label::Out name;
-		ListOf< fill_style_select, 1, 0 >::Out fill_styles;
-    };
-
-    // C++ wrapper for fill_area_style_hatching
-    struct fill_area_style_hatching : geometric_representation_item, ObjectHelper<fill_area_style_hatching,5> { fill_area_style_hatching() : Object("fill_area_style_hatching") {}
-		Lazy< curve_style > hatch_line_appearance;
-		Lazy< one_direction_repeat_factor > start_of_next_hatch_line;
-		Lazy< cartesian_point > point_of_reference_hatch_line;
-		Lazy< cartesian_point > pattern_start;
-		plane_angle_measure::Out hatch_line_angle;
-    };
-
-    // C++ wrapper for fill_area_style_tile_coloured_region
-    struct fill_area_style_tile_coloured_region : geometric_representation_item, ObjectHelper<fill_area_style_tile_coloured_region,2> { fill_area_style_tile_coloured_region() : Object("fill_area_style_tile_coloured_region") {}
-		curve_or_annotation_curve_occurrence::Out closed_curve;
-		Lazy< colour > region_colour;
-    };
-
-    // C++ wrapper for fill_area_style_tile_curve_with_style
-    struct fill_area_style_tile_curve_with_style : geometric_representation_item, ObjectHelper<fill_area_style_tile_curve_with_style,1> { fill_area_style_tile_curve_with_style() : Object("fill_area_style_tile_curve_with_style") {}
-		Lazy< annotation_curve_occurrence > styled_curve;
-    };
-
-    // C++ wrapper for fill_area_style_tile_symbol_with_style
-    struct fill_area_style_tile_symbol_with_style : geometric_representation_item, ObjectHelper<fill_area_style_tile_symbol_with_style,1> { fill_area_style_tile_symbol_with_style() : Object("fill_area_style_tile_symbol_with_style") {}
-		Lazy< annotation_symbol_occurrence > symbol;
-    };
-
-    // C++ wrapper for fill_area_style_tiles
-    struct fill_area_style_tiles : geometric_representation_item, ObjectHelper<fill_area_style_tiles,3> { fill_area_style_tiles() : Object("fill_area_style_tiles") {}
-		Lazy< two_direction_repeat_factor > tiling_pattern;
-		ListOf< fill_area_style_tile_shape_select, 1, 0 >::Out tiles;
-		positive_ratio_measure::Out tiling_scale;
-    };
-
-    // C++ wrapper for shape_representation_relationship
-    struct shape_representation_relationship : representation_relationship, ObjectHelper<shape_representation_relationship,0> { shape_representation_relationship() : Object("shape_representation_relationship") {}
-
-    };
-
-    // C++ wrapper for flat_pattern_ply_representation_relationship
-    struct flat_pattern_ply_representation_relationship : shape_representation_relationship, ObjectHelper<flat_pattern_ply_representation_relationship,0> { flat_pattern_ply_representation_relationship() : Object("flat_pattern_ply_representation_relationship") {}
-
-    };
-
-    // C++ wrapper for flatness_tolerance
-    struct flatness_tolerance : geometric_tolerance, ObjectHelper<flatness_tolerance,0> { flatness_tolerance() : Object("flatness_tolerance") {}
-
-    };
-
-    // C++ wrapper for force_measure_with_unit
-    struct force_measure_with_unit : measure_with_unit, ObjectHelper<force_measure_with_unit,0> { force_measure_with_unit() : Object("force_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for force_unit
-    struct force_unit : derived_unit, ObjectHelper<force_unit,0> { force_unit() : Object("force_unit") {}
-
-    };
-
-    // C++ wrapper for forward_chaining_rule
-    struct forward_chaining_rule : rule_definition, ObjectHelper<forward_chaining_rule,0> { forward_chaining_rule() : Object("forward_chaining_rule") {}
-
-    };
-
-    // C++ wrapper for forward_chaining_rule_premise
-    struct forward_chaining_rule_premise :  ObjectHelper<forward_chaining_rule_premise,0> { forward_chaining_rule_premise() : Object("forward_chaining_rule_premise") {}
-
-    };
-
-    // C++ wrapper for frequency_measure_with_unit
-    struct frequency_measure_with_unit : measure_with_unit, ObjectHelper<frequency_measure_with_unit,0> { frequency_measure_with_unit() : Object("frequency_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for frequency_unit
-    struct frequency_unit : derived_unit, ObjectHelper<frequency_unit,0> { frequency_unit() : Object("frequency_unit") {}
-
-    };
-
-    // C++ wrapper for func
-    struct func : compound_representation_item, ObjectHelper<func,0> { func() : Object("func") {}
-
-    };
-
-    // C++ wrapper for functional_breakdown_context
-    struct functional_breakdown_context : breakdown_context, ObjectHelper<functional_breakdown_context,0> { functional_breakdown_context() : Object("functional_breakdown_context") {}
-
-    };
-
-    // C++ wrapper for functional_element_usage
-    struct functional_element_usage : breakdown_element_usage, ObjectHelper<functional_element_usage,0> { functional_element_usage() : Object("functional_element_usage") {}
-
-    };
-
-    // C++ wrapper for general_material_property
-    struct general_material_property : general_property, ObjectHelper<general_material_property,0> { general_material_property() : Object("general_material_property") {}
-
-    };
-
-    // C++ wrapper for simple_generic_expression
-    struct simple_generic_expression : generic_expression, ObjectHelper<simple_generic_expression,0> { simple_generic_expression() : Object("simple_generic_expression") {}
-
-    };
-
-    // C++ wrapper for generic_literal
-    struct generic_literal : simple_generic_expression, ObjectHelper<generic_literal,0> { generic_literal() : Object("generic_literal") {}
-
-    };
-
-    // C++ wrapper for generic_variable
-    struct generic_variable : simple_generic_expression, ObjectHelper<generic_variable,0> { generic_variable() : Object("generic_variable") {}
-
-    };
-
-    // C++ wrapper for geometric_alignment
-    struct geometric_alignment : derived_shape_aspect, ObjectHelper<geometric_alignment,0> { geometric_alignment() : Object("geometric_alignment") {}
-
-    };
-
-    // C++ wrapper for geometric_set
-    struct geometric_set : geometric_representation_item, ObjectHelper<geometric_set,1> { geometric_set() : Object("geometric_set") {}
-		ListOf< geometric_set_select, 1, 0 >::Out elements;
-    };
-
-    // C++ wrapper for geometric_curve_set
-    struct geometric_curve_set : geometric_set, ObjectHelper<geometric_curve_set,0> { geometric_curve_set() : Object("geometric_curve_set") {}
-
-    };
-
-    // C++ wrapper for geometric_intersection
-    struct geometric_intersection : derived_shape_aspect, ObjectHelper<geometric_intersection,0> { geometric_intersection() : Object("geometric_intersection") {}
-
-    };
-
-    // C++ wrapper for geometric_item_specific_usage
-    struct geometric_item_specific_usage : item_identified_representation_usage, ObjectHelper<geometric_item_specific_usage,0> { geometric_item_specific_usage() : Object("geometric_item_specific_usage") {}
-
-    };
-
-    // C++ wrapper for geometric_model_element_relationship
-    struct geometric_model_element_relationship :  ObjectHelper<geometric_model_element_relationship,0> { geometric_model_element_relationship() : Object("geometric_model_element_relationship") {}
-
-    };
-
-    // C++ wrapper for representation_context
-    struct representation_context :  ObjectHelper<representation_context,2> { representation_context() : Object("representation_context") {}
-		identifier::Out context_identifier;
-		text::Out context_type;
-    };
-
-    // C++ wrapper for geometric_representation_context
-    struct geometric_representation_context : representation_context, ObjectHelper<geometric_representation_context,1> { geometric_representation_context() : Object("geometric_representation_context") {}
-		dimension_count::Out coordinate_space_dimension;
-    };
-
-    // C++ wrapper for geometric_tolerance_with_defined_unit
-    struct geometric_tolerance_with_defined_unit : geometric_tolerance, ObjectHelper<geometric_tolerance_with_defined_unit,1> { geometric_tolerance_with_defined_unit() : Object("geometric_tolerance_with_defined_unit") {}
-		Lazy< measure_with_unit > unit_size;
-    };
-
-    // C++ wrapper for geometrical_tolerance_callout
-    struct geometrical_tolerance_callout : draughting_callout, ObjectHelper<geometrical_tolerance_callout,0> { geometrical_tolerance_callout() : Object("geometrical_tolerance_callout") {}
-
-    };
-
-    // C++ wrapper for geometrically_bounded_2d_wireframe_representation
-    struct geometrically_bounded_2d_wireframe_representation : shape_representation, ObjectHelper<geometrically_bounded_2d_wireframe_representation,0> { geometrically_bounded_2d_wireframe_representation() : Object("geometrically_bounded_2d_wireframe_representation") {}
-
-    };
-
-    // C++ wrapper for geometrically_bounded_surface_shape_representation
-    struct geometrically_bounded_surface_shape_representation : shape_representation, ObjectHelper<geometrically_bounded_surface_shape_representation,0> { geometrically_bounded_surface_shape_representation() : Object("geometrically_bounded_surface_shape_representation") {}
-
-    };
-
-    // C++ wrapper for geometrically_bounded_wireframe_shape_representation
-    struct geometrically_bounded_wireframe_shape_representation : shape_representation, ObjectHelper<geometrically_bounded_wireframe_shape_representation,0> { geometrically_bounded_wireframe_shape_representation() : Object("geometrically_bounded_wireframe_shape_representation") {}
-
-    };
-
-    // C++ wrapper for global_assignment
-    struct global_assignment : representation_item_relationship, ObjectHelper<global_assignment,0> { global_assignment() : Object("global_assignment") {}
-
-    };
-
-    // C++ wrapper for global_uncertainty_assigned_context
-    struct global_uncertainty_assigned_context : representation_context, ObjectHelper<global_uncertainty_assigned_context,1> { global_uncertainty_assigned_context() : Object("global_uncertainty_assigned_context") {}
-		ListOf< Lazy< uncertainty_measure_with_unit >, 1, 0 > uncertainty;
-    };
-
-    // C++ wrapper for global_unit_assigned_context
-    struct global_unit_assigned_context : representation_context, ObjectHelper<global_unit_assigned_context,1> { global_unit_assigned_context() : Object("global_unit_assigned_context") {}
-		ListOf< unit, 1, 0 >::Out units;
-    };
-
-    // C++ wrapper for ground_fact
-    struct ground_fact : atomic_formula, ObjectHelper<ground_fact,0> { ground_fact() : Object("ground_fact") {}
-
-    };
-
-    // C++ wrapper for hardness_representation
-    struct hardness_representation : representation, ObjectHelper<hardness_representation,0> { hardness_representation() : Object("hardness_representation") {}
-
-    };
-
-    // C++ wrapper for hidden_element_over_riding_styled_item
-    struct hidden_element_over_riding_styled_item : context_dependent_over_riding_styled_item, ObjectHelper<hidden_element_over_riding_styled_item,0> { hidden_element_over_riding_styled_item() : Object("hidden_element_over_riding_styled_item") {}
-
-    };
-
-    // C++ wrapper for hyperbola
-    struct hyperbola : conic, ObjectHelper<hyperbola,2> { hyperbola() : Object("hyperbola") {}
-		positive_length_measure::Out semi_axis;
-		positive_length_measure::Out semi_imag_axis;
-    };
-
-    // C++ wrapper for illuminance_measure_with_unit
-    struct illuminance_measure_with_unit : measure_with_unit, ObjectHelper<illuminance_measure_with_unit,0> { illuminance_measure_with_unit() : Object("illuminance_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for illuminance_unit
-    struct illuminance_unit : derived_unit, ObjectHelper<illuminance_unit,0> { illuminance_unit() : Object("illuminance_unit") {}
-
-    };
-
-    // C++ wrapper for included_text_block
-    struct included_text_block : mapped_item, ObjectHelper<included_text_block,0> { included_text_block() : Object("included_text_block") {}
-
-    };
-
-    // C++ wrapper for inclusion_product_concept_feature
-    struct inclusion_product_concept_feature : conditional_concept_feature, ObjectHelper<inclusion_product_concept_feature,0> { inclusion_product_concept_feature() : Object("inclusion_product_concept_feature") {}
-
-    };
-
-    // C++ wrapper for user_selected_elements
-    struct user_selected_elements : representation_item, ObjectHelper<user_selected_elements,1> { user_selected_elements() : Object("user_selected_elements") {}
-		ListOf< Lazy< representation_item >, 1, 0 > picked_items;
-    };
-
-    // C++ wrapper for indirectly_selected_elements
-    struct indirectly_selected_elements : user_selected_elements, ObjectHelper<indirectly_selected_elements,1> { indirectly_selected_elements() : Object("indirectly_selected_elements") {}
-		ListOf< Lazy< representation_item >, 1, 0 > indirectly_picked_items;
-    };
-
-    // C++ wrapper for indirectly_selected_shape_elements
-    struct indirectly_selected_shape_elements :  ObjectHelper<indirectly_selected_shape_elements,0> { indirectly_selected_shape_elements() : Object("indirectly_selected_shape_elements") {}
-
-    };
-
-    // C++ wrapper for inductance_measure_with_unit
-    struct inductance_measure_with_unit : measure_with_unit, ObjectHelper<inductance_measure_with_unit,0> { inductance_measure_with_unit() : Object("inductance_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for inductance_unit
-    struct inductance_unit : derived_unit, ObjectHelper<inductance_unit,0> { inductance_unit() : Object("inductance_unit") {}
-
-    };
-
-    // C++ wrapper for information_right
-    struct information_right : action_method, ObjectHelper<information_right,0> { information_right() : Object("information_right") {}
-
-    };
-
-    // C++ wrapper for information_usage_right
-    struct information_usage_right : action_method, ObjectHelper<information_usage_right,0> { information_usage_right() : Object("information_usage_right") {}
-
-    };
-
-    // C++ wrapper for instance_usage_context_assignment
-    struct instance_usage_context_assignment : product_definition_context, ObjectHelper<instance_usage_context_assignment,1> { instance_usage_context_assignment() : Object("instance_usage_context_assignment") {}
-		ListOf< instance_usage_context_select, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for instanced_feature
-    struct instanced_feature :  ObjectHelper<instanced_feature,0> { instanced_feature() : Object("instanced_feature") {}
-
-    };
-
-    // C++ wrapper for literal_number
-    struct literal_number :  ObjectHelper<literal_number,1> { literal_number() : Object("literal_number") {}
-		NUMBER::Out the_value;
-    };
-
-    // C++ wrapper for int_literal
-    struct int_literal : literal_number, ObjectHelper<int_literal,0> { int_literal() : Object("int_literal") {}
-
-    };
-
-    // C++ wrapper for integer_representation_item
-    struct integer_representation_item :  ObjectHelper<integer_representation_item,0> { integer_representation_item() : Object("integer_representation_item") {}
-
-    };
-
-    // C++ wrapper for surface_curve
-    struct surface_curve : curve, ObjectHelper<surface_curve,3> { surface_curve() : Object("surface_curve") {}
-		Lazy< curve > curve_3d;
-		ListOf< pcurve_or_surface, 1, 2 >::Out associated_geometry;
-		preferred_surface_curve_representation::Out master_representation;
-    };
-
-    // C++ wrapper for intersection_curve
-    struct intersection_curve : surface_curve, ObjectHelper<intersection_curve,0> { intersection_curve() : Object("intersection_curve") {}
-
-    };
-
-    // C++ wrapper for interval_expression
-    struct interval_expression :  ObjectHelper<interval_expression,0> { interval_expression() : Object("interval_expression") {}
-
-    };
-
-    // C++ wrapper for iso4217_currency
-    struct iso4217_currency : currency, ObjectHelper<iso4217_currency,0> { iso4217_currency() : Object("iso4217_currency") {}
-
-    };
-
-    // C++ wrapper for known_source
-    struct known_source :  ObjectHelper<known_source,0> { known_source() : Object("known_source") {}
-
-    };
-
-    // C++ wrapper for laid_defined_transformation
-    struct laid_defined_transformation : transformation_with_derived_angle, ObjectHelper<laid_defined_transformation,0> { laid_defined_transformation() : Object("laid_defined_transformation") {}
-
-    };
-
-    // C++ wrapper for language
-    struct language : group, ObjectHelper<language,0> { language() : Object("language") {}
-
-    };
-
-    // C++ wrapper for leader_curve
-    struct leader_curve : annotation_curve_occurrence, ObjectHelper<leader_curve,0> { leader_curve() : Object("leader_curve") {}
-
-    };
-
-    // C++ wrapper for leader_directed_callout
-    struct leader_directed_callout : draughting_callout, ObjectHelper<leader_directed_callout,0> { leader_directed_callout() : Object("leader_directed_callout") {}
-
-    };
-
-    // C++ wrapper for leader_directed_dimension
-    struct leader_directed_dimension : leader_directed_callout, ObjectHelper<leader_directed_dimension,0> { leader_directed_dimension() : Object("leader_directed_dimension") {}
-
-    };
-
-    // C++ wrapper for leader_terminator
-    struct leader_terminator : terminator_symbol, ObjectHelper<leader_terminator,0> { leader_terminator() : Object("leader_terminator") {}
-
-    };
-
-    // C++ wrapper for length_measure_with_unit
-    struct length_measure_with_unit : measure_with_unit, ObjectHelper<length_measure_with_unit,0> { length_measure_with_unit() : Object("length_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for length_unit
-    struct length_unit : named_unit, ObjectHelper<length_unit,0> { length_unit() : Object("length_unit") {}
-
-    };
-
-    // C++ wrapper for light_source
-    struct light_source : geometric_representation_item, ObjectHelper<light_source,1> { light_source() : Object("light_source") {}
-		Lazy< colour > light_colour;
-    };
-
-    // C++ wrapper for light_source_ambient
-    struct light_source_ambient : light_source, ObjectHelper<light_source_ambient,0> { light_source_ambient() : Object("light_source_ambient") {}
-
-    };
-
-    // C++ wrapper for light_source_directional
-    struct light_source_directional : light_source, ObjectHelper<light_source_directional,1> { light_source_directional() : Object("light_source_directional") {}
-		Lazy< direction > orientation;
-    };
-
-    // C++ wrapper for light_source_positional
-    struct light_source_positional : light_source, ObjectHelper<light_source_positional,3> { light_source_positional() : Object("light_source_positional") {}
-		Lazy< cartesian_point > position;
-		REAL::Out constant_attenuation;
-		REAL::Out distance_attenuation;
-    };
-
-    // C++ wrapper for light_source_spot
-    struct light_source_spot : light_source, ObjectHelper<light_source_spot,6> { light_source_spot() : Object("light_source_spot") {}
-		Lazy< cartesian_point > position;
-		Lazy< direction > orientation;
-		REAL::Out concentration_exponent;
-		REAL::Out constant_attenuation;
-		REAL::Out distance_attenuation;
-		positive_plane_angle_measure::Out spread_angle;
-    };
-
-    // C++ wrapper for line
-    struct line : curve, ObjectHelper<line,2> { line() : Object("line") {}
-		Lazy< cartesian_point > pnt;
-		Lazy< vector > dir;
-    };
-
-    // C++ wrapper for line_profile_tolerance
-    struct line_profile_tolerance : geometric_tolerance, ObjectHelper<line_profile_tolerance,0> { line_profile_tolerance() : Object("line_profile_tolerance") {}
-
-    };
-
-    // C++ wrapper for linear_dimension
-    struct linear_dimension : dimension_curve_directed_callout, ObjectHelper<linear_dimension,0> { linear_dimension() : Object("linear_dimension") {}
-
-    };
-
-    // C++ wrapper for simple_clause
-    struct simple_clause : compound_representation_item, ObjectHelper<simple_clause,0> { simple_clause() : Object("simple_clause") {}
-
-    };
-
-    // C++ wrapper for literal_conjunction
-    struct literal_conjunction : simple_clause, ObjectHelper<literal_conjunction,0> { literal_conjunction() : Object("literal_conjunction") {}
-
-    };
-
-    // C++ wrapper for literal_disjunction
-    struct literal_disjunction : simple_clause, ObjectHelper<literal_disjunction,0> { literal_disjunction() : Object("literal_disjunction") {}
-
-    };
-
-    // C++ wrapper for logical_literal
-    struct logical_literal : generic_literal, ObjectHelper<logical_literal,1> { logical_literal() : Object("logical_literal") {}
-		LOGICAL::Out lit_value;
-    };
-
-    // C++ wrapper for logical_representation_item
-    struct logical_representation_item :  ObjectHelper<logical_representation_item,0> { logical_representation_item() : Object("logical_representation_item") {}
-
-    };
-
-    // C++ wrapper for loop
-    struct loop : topological_representation_item, ObjectHelper<loop,0> { loop() : Object("loop") {}
-
-    };
-
-    // C++ wrapper for loss_tangent_measure_with_unit
-    struct loss_tangent_measure_with_unit : ratio_measure_with_unit, ObjectHelper<loss_tangent_measure_with_unit,0> { loss_tangent_measure_with_unit() : Object("loss_tangent_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for lot_effectivity
-    struct lot_effectivity : effectivity, ObjectHelper<lot_effectivity,2> { lot_effectivity() : Object("lot_effectivity") {}
-		identifier::Out effectivity_lot_id;
-		Lazy< measure_with_unit > effectivity_lot_size;
-    };
-
-    // C++ wrapper for luminous_flux_measure_with_unit
-    struct luminous_flux_measure_with_unit : measure_with_unit, ObjectHelper<luminous_flux_measure_with_unit,0> { luminous_flux_measure_with_unit() : Object("luminous_flux_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for luminous_flux_unit
-    struct luminous_flux_unit : named_unit, ObjectHelper<luminous_flux_unit,0> { luminous_flux_unit() : Object("luminous_flux_unit") {}
-
-    };
-
-    // C++ wrapper for luminous_intensity_measure_with_unit
-    struct luminous_intensity_measure_with_unit : measure_with_unit, ObjectHelper<luminous_intensity_measure_with_unit,0> { luminous_intensity_measure_with_unit() : Object("luminous_intensity_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for luminous_intensity_unit
-    struct luminous_intensity_unit : named_unit, ObjectHelper<luminous_intensity_unit,0> { luminous_intensity_unit() : Object("luminous_intensity_unit") {}
-
-    };
-
-    // C++ wrapper for magnetic_flux_density_measure_with_unit
-    struct magnetic_flux_density_measure_with_unit : measure_with_unit, ObjectHelper<magnetic_flux_density_measure_with_unit,0> { magnetic_flux_density_measure_with_unit() : Object("magnetic_flux_density_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for magnetic_flux_density_unit
-    struct magnetic_flux_density_unit : derived_unit, ObjectHelper<magnetic_flux_density_unit,0> { magnetic_flux_density_unit() : Object("magnetic_flux_density_unit") {}
-
-    };
-
-    // C++ wrapper for magnetic_flux_measure_with_unit
-    struct magnetic_flux_measure_with_unit : measure_with_unit, ObjectHelper<magnetic_flux_measure_with_unit,0> { magnetic_flux_measure_with_unit() : Object("magnetic_flux_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for magnetic_flux_unit
-    struct magnetic_flux_unit : derived_unit, ObjectHelper<magnetic_flux_unit,0> { magnetic_flux_unit() : Object("magnetic_flux_unit") {}
-
-    };
-
-    // C++ wrapper for make_from_usage_option
-    struct make_from_usage_option : product_definition_usage, ObjectHelper<make_from_usage_option,3> { make_from_usage_option() : Object("make_from_usage_option") {}
-		INTEGER::Out ranking;
-		text::Out ranking_rationale;
-		Lazy< measure_with_unit > quantity;
-    };
-
-    // C++ wrapper for manifold_subsurface_shape_representation
-    struct manifold_subsurface_shape_representation : shape_representation, ObjectHelper<manifold_subsurface_shape_representation,0> { manifold_subsurface_shape_representation() : Object("manifold_subsurface_shape_representation") {}
-
-    };
-
-    // C++ wrapper for manifold_surface_shape_representation
-    struct manifold_surface_shape_representation : shape_representation, ObjectHelper<manifold_surface_shape_representation,0> { manifold_surface_shape_representation() : Object("manifold_surface_shape_representation") {}
-
-    };
-
-    // C++ wrapper for mass_measure_with_unit
-    struct mass_measure_with_unit : measure_with_unit, ObjectHelper<mass_measure_with_unit,0> { mass_measure_with_unit() : Object("mass_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for mass_unit
-    struct mass_unit : named_unit, ObjectHelper<mass_unit,0> { mass_unit() : Object("mass_unit") {}
-
-    };
-
-    // C++ wrapper for material_property
-    struct material_property : property_definition, ObjectHelper<material_property,0> { material_property() : Object("material_property") {}
-
-    };
-
-    // C++ wrapper for property_definition_representation
-    struct property_definition_representation :  ObjectHelper<property_definition_representation,2> { property_definition_representation() : Object("property_definition_representation") {}
-		represented_definition::Out definition;
-		Lazy< representation > used_representation;
-    };
-
-    // C++ wrapper for material_property_representation
-    struct material_property_representation : property_definition_representation, ObjectHelper<material_property_representation,1> { material_property_representation() : Object("material_property_representation") {}
-		Lazy< NotImplemented > dependent_environment;
-    };
-
-    // C++ wrapper for measure_representation_item
-    struct measure_representation_item :  ObjectHelper<measure_representation_item,0> { measure_representation_item() : Object("measure_representation_item") {}
-
-    };
-
-    // C++ wrapper for product_context
-    struct product_context : application_context_element, ObjectHelper<product_context,1> { product_context() : Object("product_context") {}
-		label::Out discipline_type;
-    };
-
-    // C++ wrapper for mechanical_context
-    struct mechanical_context : product_context, ObjectHelper<mechanical_context,0> { mechanical_context() : Object("mechanical_context") {}
-
-    };
-
-    // C++ wrapper for mechanical_design_and_draughting_relationship
-    struct mechanical_design_and_draughting_relationship : definitional_representation_relationship_with_same_context, ObjectHelper<mechanical_design_and_draughting_relationship,0> { mechanical_design_and_draughting_relationship() : Object("mechanical_design_and_draughting_relationship") {}
-
-    };
-
-    // C++ wrapper for mechanical_design_geometric_presentation_area
-    struct mechanical_design_geometric_presentation_area : presentation_area, ObjectHelper<mechanical_design_geometric_presentation_area,0> { mechanical_design_geometric_presentation_area() : Object("mechanical_design_geometric_presentation_area") {}
-
-    };
-
-    // C++ wrapper for mechanical_design_geometric_presentation_representation
-    struct mechanical_design_geometric_presentation_representation : representation, ObjectHelper<mechanical_design_geometric_presentation_representation,0> { mechanical_design_geometric_presentation_representation() : Object("mechanical_design_geometric_presentation_representation") {}
-
-    };
-
-    // C++ wrapper for mechanical_design_presentation_representation_with_draughting
-    struct mechanical_design_presentation_representation_with_draughting : representation, ObjectHelper<mechanical_design_presentation_representation_with_draughting,0> { mechanical_design_presentation_representation_with_draughting() : Object("mechanical_design_presentation_representation_with_draughting") {}
-
-    };
-
-    // C++ wrapper for mechanical_design_shaded_presentation_area
-    struct mechanical_design_shaded_presentation_area : presentation_area, ObjectHelper<mechanical_design_shaded_presentation_area,0> { mechanical_design_shaded_presentation_area() : Object("mechanical_design_shaded_presentation_area") {}
-
-    };
-
-    // C++ wrapper for mechanical_design_shaded_presentation_representation
-    struct mechanical_design_shaded_presentation_representation : representation, ObjectHelper<mechanical_design_shaded_presentation_representation,0> { mechanical_design_shaded_presentation_representation() : Object("mechanical_design_shaded_presentation_representation") {}
-
-    };
-
-    // C++ wrapper for min_and_major_ply_orientation_basis
-    struct min_and_major_ply_orientation_basis :  ObjectHelper<min_and_major_ply_orientation_basis,0> { min_and_major_ply_orientation_basis() : Object("min_and_major_ply_orientation_basis") {}
-
-    };
-
-    // C++ wrapper for modified_geometric_tolerance
-    struct modified_geometric_tolerance : geometric_tolerance, ObjectHelper<modified_geometric_tolerance,1> { modified_geometric_tolerance() : Object("modified_geometric_tolerance") {}
-		limit_condition::Out modifier;
-    };
-
-    // C++ wrapper for modified_solid_with_placed_configuration
-    struct modified_solid_with_placed_configuration : modified_solid, ObjectHelper<modified_solid_with_placed_configuration,1> { modified_solid_with_placed_configuration() : Object("modified_solid_with_placed_configuration") {}
-		Lazy< axis2_placement_3d > placing;
-    };
-
-    // C++ wrapper for moments_of_inertia_representation
-    struct moments_of_inertia_representation : representation, ObjectHelper<moments_of_inertia_representation,0> { moments_of_inertia_representation() : Object("moments_of_inertia_representation") {}
-
-    };
-
-    // C++ wrapper for multi_language_attribute_assignment
-    struct multi_language_attribute_assignment : attribute_value_assignment, ObjectHelper<multi_language_attribute_assignment,1> { multi_language_attribute_assignment() : Object("multi_language_attribute_assignment") {}
-		ListOf< multi_language_attribute_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for multiple_arity_boolean_expression
-    struct multiple_arity_boolean_expression :  ObjectHelper<multiple_arity_boolean_expression,0> { multiple_arity_boolean_expression() : Object("multiple_arity_boolean_expression") {}
-
-    };
-
-    // C++ wrapper for multiple_arity_generic_expression
-    struct multiple_arity_generic_expression : generic_expression, ObjectHelper<multiple_arity_generic_expression,1> { multiple_arity_generic_expression() : Object("multiple_arity_generic_expression") {}
-		ListOf< Lazy< generic_expression >, 2, 0 > operands;
-    };
-
-    // C++ wrapper for multiple_arity_numeric_expression
-    struct multiple_arity_numeric_expression :  ObjectHelper<multiple_arity_numeric_expression,0> { multiple_arity_numeric_expression() : Object("multiple_arity_numeric_expression") {}
-
-    };
-
-    // C++ wrapper for next_assembly_usage_occurrence
-    struct next_assembly_usage_occurrence : assembly_component_usage, ObjectHelper<next_assembly_usage_occurrence,0> { next_assembly_usage_occurrence() : Object("next_assembly_usage_occurrence") {}
-
-    };
-
-    // C++ wrapper for non_manifold_surface_shape_representation
-    struct non_manifold_surface_shape_representation : shape_representation, ObjectHelper<non_manifold_surface_shape_representation,0> { non_manifold_surface_shape_representation() : Object("non_manifold_surface_shape_representation") {}
-
-    };
-
-    // C++ wrapper for null_representation_item
-    struct null_representation_item : representation_item, ObjectHelper<null_representation_item,0> { null_representation_item() : Object("null_representation_item") {}
-
-    };
-
-    // C++ wrapper for numeric_expression
-    struct numeric_expression : expression, ObjectHelper<numeric_expression,0> { numeric_expression() : Object("numeric_expression") {}
-
-    };
-
-    // C++ wrapper for offset_curve_2d
-    struct offset_curve_2d : curve, ObjectHelper<offset_curve_2d,3> { offset_curve_2d() : Object("offset_curve_2d") {}
-		Lazy< curve > basis_curve;
-		length_measure::Out distance;
-		LOGICAL::Out self_intersect;
-    };
-
-    // C++ wrapper for offset_curve_3d
-    struct offset_curve_3d : curve, ObjectHelper<offset_curve_3d,4> { offset_curve_3d() : Object("offset_curve_3d") {}
-		Lazy< curve > basis_curve;
-		length_measure::Out distance;
-		LOGICAL::Out self_intersect;
-		Lazy< direction > ref_direction;
-    };
-
-    // C++ wrapper for offset_surface
-    struct offset_surface : surface, ObjectHelper<offset_surface,3> { offset_surface() : Object("offset_surface") {}
-		Lazy< surface > basis_surface;
-		length_measure::Out distance;
-		LOGICAL::Out self_intersect;
-    };
-
-    // C++ wrapper for one_direction_repeat_factor
-    struct one_direction_repeat_factor : geometric_representation_item, ObjectHelper<one_direction_repeat_factor,1> { one_direction_repeat_factor() : Object("one_direction_repeat_factor") {}
-		Lazy< vector > repeat_factor;
-    };
-
-    // C++ wrapper for open_shell
-    struct open_shell : connected_face_set, ObjectHelper<open_shell,0> { open_shell() : Object("open_shell") {}
-
-    };
-
-    // C++ wrapper for ordinal_date
-    struct ordinal_date : date, ObjectHelper<ordinal_date,1> { ordinal_date() : Object("ordinal_date") {}
-		day_in_year_number::Out day_component;
-    };
-
-    // C++ wrapper for projection_directed_callout
-    struct projection_directed_callout : draughting_callout, ObjectHelper<projection_directed_callout,0> { projection_directed_callout() : Object("projection_directed_callout") {}
-
-    };
-
-    // C++ wrapper for ordinate_dimension
-    struct ordinate_dimension : projection_directed_callout, ObjectHelper<ordinate_dimension,0> { ordinate_dimension() : Object("ordinate_dimension") {}
-
-    };
-
-    // C++ wrapper for organizational_address
-    struct organizational_address : address, ObjectHelper<organizational_address,2> { organizational_address() : Object("organizational_address") {}
-		ListOf< Lazy< NotImplemented >, 1, 0 > organizations;
-		Maybe< text::Out > description;
-    };
-
-    // C++ wrapper for oriented_closed_shell
-    struct oriented_closed_shell : closed_shell, ObjectHelper<oriented_closed_shell,2> { oriented_closed_shell() : Object("oriented_closed_shell") {}
-		Lazy< closed_shell > closed_shell_element;
-		BOOLEAN::Out orientation;
-    };
-
-    // C++ wrapper for oriented_edge
-    struct oriented_edge : edge, ObjectHelper<oriented_edge,2> { oriented_edge() : Object("oriented_edge") {}
-		Lazy< edge > edge_element;
-		BOOLEAN::Out orientation;
-    };
-
-    // C++ wrapper for oriented_face
-    struct oriented_face : face, ObjectHelper<oriented_face,2> { oriented_face() : Object("oriented_face") {}
-		Lazy< face > face_element;
-		BOOLEAN::Out orientation;
-    };
-
-    // C++ wrapper for oriented_open_shell
-    struct oriented_open_shell : open_shell, ObjectHelper<oriented_open_shell,2> { oriented_open_shell() : Object("oriented_open_shell") {}
-		Lazy< open_shell > open_shell_element;
-		BOOLEAN::Out orientation;
-    };
-
-    // C++ wrapper for path
-    struct path : topological_representation_item, ObjectHelper<path,1> { path() : Object("path") {}
-		ListOf< Lazy< oriented_edge >, 1, 0 > edge_list;
-    };
-
-    // C++ wrapper for oriented_path
-    struct oriented_path : path, ObjectHelper<oriented_path,2> { oriented_path() : Object("oriented_path") {}
-		Lazy< path > path_element;
-		BOOLEAN::Out orientation;
-    };
-
-    // C++ wrapper for oriented_surface
-    struct oriented_surface : surface, ObjectHelper<oriented_surface,1> { oriented_surface() : Object("oriented_surface") {}
-		BOOLEAN::Out orientation;
-    };
-
-    // C++ wrapper for outer_boundary_curve
-    struct outer_boundary_curve : boundary_curve, ObjectHelper<outer_boundary_curve,0> { outer_boundary_curve() : Object("outer_boundary_curve") {}
-
-    };
-
-    // C++ wrapper for package_product_concept_feature
-    struct package_product_concept_feature : product_concept_feature, ObjectHelper<package_product_concept_feature,0> { package_product_concept_feature() : Object("package_product_concept_feature") {}
-
-    };
-
-    // C++ wrapper for parabola
-    struct parabola : conic, ObjectHelper<parabola,1> { parabola() : Object("parabola") {}
-		length_measure::Out focal_dist;
-    };
-
-    // C++ wrapper for parallel_offset
-    struct parallel_offset : derived_shape_aspect, ObjectHelper<parallel_offset,1> { parallel_offset() : Object("parallel_offset") {}
-		Lazy< measure_with_unit > offset;
-    };
-
-    // C++ wrapper for parallelism_tolerance
-    struct parallelism_tolerance : geometric_tolerance_with_datum_reference, ObjectHelper<parallelism_tolerance,0> { parallelism_tolerance() : Object("parallelism_tolerance") {}
-
-    };
-
-    // C++ wrapper for parametric_representation_context
-    struct parametric_representation_context : representation_context, ObjectHelper<parametric_representation_context,0> { parametric_representation_context() : Object("parametric_representation_context") {}
-
-    };
-
-    // C++ wrapper for partial_document_with_structured_text_representation_assignment
-    struct partial_document_with_structured_text_representation_assignment :  ObjectHelper<partial_document_with_structured_text_representation_assignment,0> { partial_document_with_structured_text_representation_assignment() : Object("partial_document_with_structured_text_representation_assignment") {}
-
-    };
-
-    // C++ wrapper for pcurve
-    struct pcurve : curve, ObjectHelper<pcurve,2> { pcurve() : Object("pcurve") {}
-		Lazy< surface > basis_surface;
-		Lazy< definitional_representation > reference_to_curve;
-    };
-
-    // C++ wrapper for percentage_laminate_definition
-    struct percentage_laminate_definition : product_definition, ObjectHelper<percentage_laminate_definition,0> { percentage_laminate_definition() : Object("percentage_laminate_definition") {}
-
-    };
-
-    // C++ wrapper for zone_structural_makeup
-    struct zone_structural_makeup : laminate_table, ObjectHelper<zone_structural_makeup,0> { zone_structural_makeup() : Object("zone_structural_makeup") {}
-
-    };
-
-    // C++ wrapper for percentage_laminate_table
-    struct percentage_laminate_table : zone_structural_makeup, ObjectHelper<percentage_laminate_table,0> { percentage_laminate_table() : Object("percentage_laminate_table") {}
-
-    };
-
-    // C++ wrapper for percentage_ply_definition
-    struct percentage_ply_definition : product_definition, ObjectHelper<percentage_ply_definition,0> { percentage_ply_definition() : Object("percentage_ply_definition") {}
-
-    };
-
-    // C++ wrapper for perpendicular_to
-    struct perpendicular_to : derived_shape_aspect, ObjectHelper<perpendicular_to,0> { perpendicular_to() : Object("perpendicular_to") {}
-
-    };
-
-    // C++ wrapper for perpendicularity_tolerance
-    struct perpendicularity_tolerance : geometric_tolerance_with_datum_reference, ObjectHelper<perpendicularity_tolerance,0> { perpendicularity_tolerance() : Object("perpendicularity_tolerance") {}
-
-    };
-
-    // C++ wrapper for person_and_organization_address
-    struct person_and_organization_address :  ObjectHelper<person_and_organization_address,0> { person_and_organization_address() : Object("person_and_organization_address") {}
-
-    };
-
-    // C++ wrapper for personal_address
-    struct personal_address : address, ObjectHelper<personal_address,2> { personal_address() : Object("personal_address") {}
-		ListOf< Lazy< NotImplemented >, 1, 0 > people;
-		Maybe< text::Out > description;
-    };
-
-    // C++ wrapper for physical_breakdown_context
-    struct physical_breakdown_context : breakdown_context, ObjectHelper<physical_breakdown_context,0> { physical_breakdown_context() : Object("physical_breakdown_context") {}
-
-    };
-
-    // C++ wrapper for physical_element_usage
-    struct physical_element_usage : breakdown_element_usage, ObjectHelper<physical_element_usage,0> { physical_element_usage() : Object("physical_element_usage") {}
-
-    };
-
-    // C++ wrapper for presentation_view
-    struct presentation_view : presentation_representation, ObjectHelper<presentation_view,0> { presentation_view() : Object("presentation_view") {}
-
-    };
-
-    // C++ wrapper for picture_representation
-    struct picture_representation : presentation_view, ObjectHelper<picture_representation,0> { picture_representation() : Object("picture_representation") {}
-
-    };
-
-    // C++ wrapper for placed_datum_target_feature
-    struct placed_datum_target_feature : datum_target, ObjectHelper<placed_datum_target_feature,0> { placed_datum_target_feature() : Object("placed_datum_target_feature") {}
-
-    };
-
-    // C++ wrapper for placed_feature
-    struct placed_feature : shape_aspect, ObjectHelper<placed_feature,0> { placed_feature() : Object("placed_feature") {}
-
-    };
-
-    // C++ wrapper for planar_extent
-    struct planar_extent : geometric_representation_item, ObjectHelper<planar_extent,2> { planar_extent() : Object("planar_extent") {}
-		length_measure::Out size_in_x;
-		length_measure::Out size_in_y;
-    };
-
-    // C++ wrapper for planar_box
-    struct planar_box : planar_extent, ObjectHelper<planar_box,1> { planar_box() : Object("planar_box") {}
-		axis2_placement::Out placement;
-    };
-
-    // C++ wrapper for plane
-    struct plane : elementary_surface, ObjectHelper<plane,0> { plane() : Object("plane") {}
-
-    };
-
-    // C++ wrapper for plane_angle_measure_with_unit
-    struct plane_angle_measure_with_unit : measure_with_unit, ObjectHelper<plane_angle_measure_with_unit,0> { plane_angle_measure_with_unit() : Object("plane_angle_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for plane_angle_unit
-    struct plane_angle_unit : named_unit, ObjectHelper<plane_angle_unit,0> { plane_angle_unit() : Object("plane_angle_unit") {}
-
-    };
-
-    // C++ wrapper for ply_laminate_definition
-    struct ply_laminate_definition : product_definition, ObjectHelper<ply_laminate_definition,0> { ply_laminate_definition() : Object("ply_laminate_definition") {}
-
-    };
-
-    // C++ wrapper for ply_laminate_sequence_definition
-    struct ply_laminate_sequence_definition : product_definition, ObjectHelper<ply_laminate_sequence_definition,0> { ply_laminate_sequence_definition() : Object("ply_laminate_sequence_definition") {}
-
-    };
-
-    // C++ wrapper for ply_laminate_table
-    struct ply_laminate_table : part_laminate_table, ObjectHelper<ply_laminate_table,0> { ply_laminate_table() : Object("ply_laminate_table") {}
-
-    };
-
-    // C++ wrapper for point_and_vector
-    struct point_and_vector :  ObjectHelper<point_and_vector,0> { point_and_vector() : Object("point_and_vector") {}
-
-    };
-
-    // C++ wrapper for point_on_curve
-    struct point_on_curve : point, ObjectHelper<point_on_curve,2> { point_on_curve() : Object("point_on_curve") {}
-		Lazy< curve > basis_curve;
-		parameter_value::Out point_parameter;
-    };
-
-    // C++ wrapper for point_on_surface
-    struct point_on_surface : point, ObjectHelper<point_on_surface,3> { point_on_surface() : Object("point_on_surface") {}
-		Lazy< surface > basis_surface;
-		parameter_value::Out point_parameter_u;
-		parameter_value::Out point_parameter_v;
-    };
-
-    // C++ wrapper for point_path
-    struct point_path :  ObjectHelper<point_path,0> { point_path() : Object("point_path") {}
-
-    };
-
-    // C++ wrapper for point_replica
-    struct point_replica : point, ObjectHelper<point_replica,2> { point_replica() : Object("point_replica") {}
-		Lazy< point > parent_pt;
-		Lazy< cartesian_transformation_operator > transformation;
-    };
-
-    // C++ wrapper for point_style
-    struct point_style : founded_item, ObjectHelper<point_style,4> { point_style() : Object("point_style") {}
-		label::Out name;
-		marker_select::Out marker;
-		size_select::Out marker_size;
-		Lazy< colour > marker_colour;
-    };
-
-    // C++ wrapper for polar_complex_number_literal
-    struct polar_complex_number_literal : generic_literal, ObjectHelper<polar_complex_number_literal,2> { polar_complex_number_literal() : Object("polar_complex_number_literal") {}
-		REAL::Out radius;
-		REAL::Out angle;
-    };
-
-    // C++ wrapper for poly_loop
-    struct poly_loop :  ObjectHelper<poly_loop,1> { poly_loop() : Object("poly_loop") {}
-		ListOf< Lazy< cartesian_point >, 3, 0 > polygon;
-    };
-
-    // C++ wrapper for polyline
-    struct polyline : bounded_curve, ObjectHelper<polyline,1> { polyline() : Object("polyline") {}
-		ListOf< Lazy< cartesian_point >, 2, 0 > points;
-    };
-
-    // C++ wrapper for position_tolerance
-    struct position_tolerance : geometric_tolerance, ObjectHelper<position_tolerance,0> { position_tolerance() : Object("position_tolerance") {}
-
-    };
-
-    // C++ wrapper for positioned_sketch
-    struct positioned_sketch : geometric_representation_item, ObjectHelper<positioned_sketch,2> { positioned_sketch() : Object("positioned_sketch") {}
-		sketch_basis_select::Out sketch_basis;
-		ListOf< Lazy< auxiliary_geometric_representation_item >, 0, 0 > auxiliary_elements;
-    };
-
-    // C++ wrapper for power_measure_with_unit
-    struct power_measure_with_unit : measure_with_unit, ObjectHelper<power_measure_with_unit,0> { power_measure_with_unit() : Object("power_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for power_unit
-    struct power_unit : derived_unit, ObjectHelper<power_unit,0> { power_unit() : Object("power_unit") {}
-
-    };
-
-    // C++ wrapper for pre_defined_symbol
-    struct pre_defined_symbol : pre_defined_item, ObjectHelper<pre_defined_symbol,0> { pre_defined_symbol() : Object("pre_defined_symbol") {}
-
-    };
-
-    // C++ wrapper for pre_defined_dimension_symbol
-    struct pre_defined_dimension_symbol : pre_defined_symbol, ObjectHelper<pre_defined_dimension_symbol,0> { pre_defined_dimension_symbol() : Object("pre_defined_dimension_symbol") {}
-
-    };
-
-    // C++ wrapper for pre_defined_geometrical_tolerance_symbol
-    struct pre_defined_geometrical_tolerance_symbol : pre_defined_symbol, ObjectHelper<pre_defined_geometrical_tolerance_symbol,0> { pre_defined_geometrical_tolerance_symbol() : Object("pre_defined_geometrical_tolerance_symbol") {}
-
-    };
-
-    // C++ wrapper for pre_defined_marker
-    struct pre_defined_marker : pre_defined_item, ObjectHelper<pre_defined_marker,0> { pre_defined_marker() : Object("pre_defined_marker") {}
-
-    };
-
-    // C++ wrapper for pre_defined_point_marker_symbol
-    struct pre_defined_point_marker_symbol :  ObjectHelper<pre_defined_point_marker_symbol,0> { pre_defined_point_marker_symbol() : Object("pre_defined_point_marker_symbol") {}
-
-    };
-
-    // C++ wrapper for pre_defined_surface_condition_symbol
-    struct pre_defined_surface_condition_symbol : pre_defined_symbol, ObjectHelper<pre_defined_surface_condition_symbol,0> { pre_defined_surface_condition_symbol() : Object("pre_defined_surface_condition_symbol") {}
-
-    };
-
-    // C++ wrapper for pre_defined_surface_side_style
-    struct pre_defined_surface_side_style : pre_defined_item, ObjectHelper<pre_defined_surface_side_style,0> { pre_defined_surface_side_style() : Object("pre_defined_surface_side_style") {}
-
-    };
-
-    // C++ wrapper for pre_defined_terminator_symbol
-    struct pre_defined_terminator_symbol : pre_defined_symbol, ObjectHelper<pre_defined_terminator_symbol,0> { pre_defined_terminator_symbol() : Object("pre_defined_terminator_symbol") {}
-
-    };
-
-    // C++ wrapper for pre_defined_tile
-    struct pre_defined_tile : pre_defined_item, ObjectHelper<pre_defined_tile,0> { pre_defined_tile() : Object("pre_defined_tile") {}
-
-    };
-
-    // C++ wrapper for predefined_picture_representation_item
-    struct predefined_picture_representation_item : picture_representation_item, ObjectHelper<predefined_picture_representation_item,0> { predefined_picture_representation_item() : Object("predefined_picture_representation_item") {}
-
-    };
-
-    // C++ wrapper for presentation_style_assignment
-    struct presentation_style_assignment : founded_item, ObjectHelper<presentation_style_assignment,1> { presentation_style_assignment() : Object("presentation_style_assignment") {}
-		ListOf< presentation_style_select, 1, 0 >::Out styles;
-    };
-
-    // C++ wrapper for presentation_style_by_context
-    struct presentation_style_by_context : presentation_style_assignment, ObjectHelper<presentation_style_by_context,1> { presentation_style_by_context() : Object("presentation_style_by_context") {}
-		style_context_select::Out style_context;
-    };
-
-    // C++ wrapper for pressure_measure_with_unit
-    struct pressure_measure_with_unit : measure_with_unit, ObjectHelper<pressure_measure_with_unit,0> { pressure_measure_with_unit() : Object("pressure_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for pressure_unit
-    struct pressure_unit : derived_unit, ObjectHelper<pressure_unit,0> { pressure_unit() : Object("pressure_unit") {}
-
-    };
-
-    // C++ wrapper for procedural_representation
-    struct procedural_representation : representation, ObjectHelper<procedural_representation,0> { procedural_representation() : Object("procedural_representation") {}
-
-    };
-
-    // C++ wrapper for procedural_representation_sequence
-    struct procedural_representation_sequence : representation_item, ObjectHelper<procedural_representation_sequence,3> { procedural_representation_sequence() : Object("procedural_representation_sequence") {}
-		ListOf< Lazy< representation_item >, 1, 0 > elements;
-		ListOf< Lazy< representation_item >, 0, 0 > suppressed_items;
-		text::Out rationale;
-    };
-
-    // C++ wrapper for procedural_shape_representation
-    struct procedural_shape_representation :  ObjectHelper<procedural_shape_representation,0> { procedural_shape_representation() : Object("procedural_shape_representation") {}
-
-    };
-
-    // C++ wrapper for procedural_shape_representation_sequence
-    struct procedural_shape_representation_sequence :  ObjectHelper<procedural_shape_representation_sequence,0> { procedural_shape_representation_sequence() : Object("procedural_shape_representation_sequence") {}
-
-    };
-
-    // C++ wrapper for product_category
-    struct product_category :  ObjectHelper<product_category,2> { product_category() : Object("product_category") {}
-		label::Out name;
-		Maybe< text::Out > description;
-    };
-
-    // C++ wrapper for product_class
-    struct product_class :  ObjectHelper<product_class,0> { product_class() : Object("product_class") {}
-
-    };
-
-    // C++ wrapper for product_concept_context
-    struct product_concept_context : application_context_element, ObjectHelper<product_concept_context,1> { product_concept_context() : Object("product_concept_context") {}
-		label::Out market_segment_type;
-    };
-
-    // C++ wrapper for product_concept_feature_category_usage
-    struct product_concept_feature_category_usage : group_assignment, ObjectHelper<product_concept_feature_category_usage,1> { product_concept_feature_category_usage() : Object("product_concept_feature_category_usage") {}
-		ListOf< category_usage_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for product_definition_element_relationship
-    struct product_definition_element_relationship : group, ObjectHelper<product_definition_element_relationship,0> { product_definition_element_relationship() : Object("product_definition_element_relationship") {}
-
-    };
-
-    // C++ wrapper for product_definition_formation
-    struct product_definition_formation :  ObjectHelper<product_definition_formation,3> { product_definition_formation() : Object("product_definition_formation") {}
-		identifier::Out id;
-		Maybe< text::Out > description;
-		Lazy< NotImplemented > of_product;
-    };
-
-    // C++ wrapper for product_definition_formation_with_specified_source
-    struct product_definition_formation_with_specified_source : product_definition_formation, ObjectHelper<product_definition_formation_with_specified_source,1> { product_definition_formation_with_specified_source() : Object("product_definition_formation_with_specified_source") {}
-		source::Out make_or_buy;
-    };
-
-    // C++ wrapper for product_definition_group_assignment
-    struct product_definition_group_assignment : group_assignment, ObjectHelper<product_definition_group_assignment,1> { product_definition_group_assignment() : Object("product_definition_group_assignment") {}
-		ListOf< product_definition_or_product_definition_relationship, 1, 1 >::Out items;
-    };
-
-    // C++ wrapper for product_definition_shape
-    struct product_definition_shape : property_definition, ObjectHelper<product_definition_shape,0> { product_definition_shape() : Object("product_definition_shape") {}
-
-    };
-
-    // C++ wrapper for product_definition_with_associated_documents
-    struct product_definition_with_associated_documents : product_definition, ObjectHelper<product_definition_with_associated_documents,1> { product_definition_with_associated_documents() : Object("product_definition_with_associated_documents") {}
-		ListOf< Lazy< NotImplemented >, 1, 0 > documentation_ids;
-    };
-
-    // C++ wrapper for product_identification
-    struct product_identification :  ObjectHelper<product_identification,0> { product_identification() : Object("product_identification") {}
-
-    };
-
-    // C++ wrapper for product_material_composition_relationship
-    struct product_material_composition_relationship : product_definition_relationship, ObjectHelper<product_material_composition_relationship,4> { product_material_composition_relationship() : Object("product_material_composition_relationship") {}
-		label::Out class_;
-		ListOf< characterized_product_composition_value, 1, 0 >::Out constituent_amount;
-		label::Out composition_basis;
-		text::Out determination_method;
-    };
-
-    // C++ wrapper for product_related_product_category
-    struct product_related_product_category : product_category, ObjectHelper<product_related_product_category,1> { product_related_product_category() : Object("product_related_product_category") {}
-		ListOf< Lazy< NotImplemented >, 1, 0 > products;
-    };
-
-    // C++ wrapper for product_specification
-    struct product_specification :  ObjectHelper<product_specification,0> { product_specification() : Object("product_specification") {}
-
-    };
-
-    // C++ wrapper for tolerance_zone_definition
-    struct tolerance_zone_definition :  ObjectHelper<tolerance_zone_definition,2> { tolerance_zone_definition() : Object("tolerance_zone_definition") {}
-		Lazy< tolerance_zone > zone;
-		ListOf< Lazy< shape_aspect >, 1, 0 > boundaries;
-    };
-
-    // C++ wrapper for projected_zone_definition
-    struct projected_zone_definition : tolerance_zone_definition, ObjectHelper<projected_zone_definition,2> { projected_zone_definition() : Object("projected_zone_definition") {}
-		Lazy< shape_aspect > projection_end;
-		Lazy< measure_with_unit > projected_length;
-    };
-
-    // C++ wrapper for projection_curve
-    struct projection_curve : annotation_curve_occurrence, ObjectHelper<projection_curve,0> { projection_curve() : Object("projection_curve") {}
-
-    };
-
-    // C++ wrapper for promissory_usage_occurrence
-    struct promissory_usage_occurrence : assembly_component_usage, ObjectHelper<promissory_usage_occurrence,0> { promissory_usage_occurrence() : Object("promissory_usage_occurrence") {}
-
-    };
-
-    // C++ wrapper for qualified_representation_item
-    struct qualified_representation_item : representation_item, ObjectHelper<qualified_representation_item,1> { qualified_representation_item() : Object("qualified_representation_item") {}
-		ListOf< value_qualifier, 1, 0 >::Out qualifiers;
-    };
-
-    // C++ wrapper for qualitative_uncertainty
-    struct qualitative_uncertainty : uncertainty_qualifier, ObjectHelper<qualitative_uncertainty,1> { qualitative_uncertainty() : Object("qualitative_uncertainty") {}
-		text::Out uncertainty_value;
-    };
-
-    // C++ wrapper for quantified_assembly_component_usage
-    struct quantified_assembly_component_usage : assembly_component_usage, ObjectHelper<quantified_assembly_component_usage,1> { quantified_assembly_component_usage() : Object("quantified_assembly_component_usage") {}
-		Lazy< measure_with_unit > quantity;
-    };
-
-    // C++ wrapper for quasi_uniform_curve
-    struct quasi_uniform_curve : b_spline_curve, ObjectHelper<quasi_uniform_curve,0> { quasi_uniform_curve() : Object("quasi_uniform_curve") {}
-
-    };
-
-    // C++ wrapper for quasi_uniform_surface
-    struct quasi_uniform_surface : b_spline_surface, ObjectHelper<quasi_uniform_surface,0> { quasi_uniform_surface() : Object("quasi_uniform_surface") {}
-
-    };
-
-    // C++ wrapper for radioactivity_measure_with_unit
-    struct radioactivity_measure_with_unit : measure_with_unit, ObjectHelper<radioactivity_measure_with_unit,0> { radioactivity_measure_with_unit() : Object("radioactivity_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for radioactivity_unit
-    struct radioactivity_unit : derived_unit, ObjectHelper<radioactivity_unit,0> { radioactivity_unit() : Object("radioactivity_unit") {}
-
-    };
-
-    // C++ wrapper for radius_dimension
-    struct radius_dimension : dimension_curve_directed_callout, ObjectHelper<radius_dimension,0> { radius_dimension() : Object("radius_dimension") {}
-
-    };
-
-    // C++ wrapper for range_characteristic
-    struct range_characteristic :  ObjectHelper<range_characteristic,0> { range_characteristic() : Object("range_characteristic") {}
-
-    };
-
-    // C++ wrapper for ratio_unit
-    struct ratio_unit : named_unit, ObjectHelper<ratio_unit,0> { ratio_unit() : Object("ratio_unit") {}
-
-    };
-
-    // C++ wrapper for rational_b_spline_curve
-    struct rational_b_spline_curve : b_spline_curve, ObjectHelper<rational_b_spline_curve,1> { rational_b_spline_curve() : Object("rational_b_spline_curve") {}
-		ListOf< REAL, 2, 0 >::Out weights_data;
-    };
-
-    // C++ wrapper for rational_b_spline_surface
-    struct rational_b_spline_surface : b_spline_surface, ObjectHelper<rational_b_spline_surface,0> { rational_b_spline_surface() : Object("rational_b_spline_surface") {}
-
-    };
-
-    // C++ wrapper for rational_representation_item
-    struct rational_representation_item :  ObjectHelper<rational_representation_item,0> { rational_representation_item() : Object("rational_representation_item") {}
-
-    };
-
-    // C++ wrapper for real_literal
-    struct real_literal : literal_number, ObjectHelper<real_literal,0> { real_literal() : Object("real_literal") {}
-
-    };
-
-    // C++ wrapper for real_representation_item
-    struct real_representation_item :  ObjectHelper<real_representation_item,0> { real_representation_item() : Object("real_representation_item") {}
-
-    };
-
-    // C++ wrapper for rectangular_composite_surface
-    struct rectangular_composite_surface : bounded_surface, ObjectHelper<rectangular_composite_surface,0> { rectangular_composite_surface() : Object("rectangular_composite_surface") {}
-
-    };
-
-    // C++ wrapper for rectangular_trimmed_surface
-    struct rectangular_trimmed_surface : bounded_surface, ObjectHelper<rectangular_trimmed_surface,7> { rectangular_trimmed_surface() : Object("rectangular_trimmed_surface") {}
-		Lazy< surface > basis_surface;
-		parameter_value::Out u1;
-		parameter_value::Out u2;
-		parameter_value::Out v1;
-		parameter_value::Out v2;
-		BOOLEAN::Out usense;
-		BOOLEAN::Out vsense;
-    };
-
-    // C++ wrapper for referenced_modified_datum
-    struct referenced_modified_datum : datum_reference, ObjectHelper<referenced_modified_datum,1> { referenced_modified_datum() : Object("referenced_modified_datum") {}
-		limit_condition::Out modifier;
-    };
-
-    // C++ wrapper for relative_event_occurrence
-    struct relative_event_occurrence : event_occurrence, ObjectHelper<relative_event_occurrence,2> { relative_event_occurrence() : Object("relative_event_occurrence") {}
-		Lazy< event_occurrence > base_event;
-		Lazy< time_measure_with_unit > offset;
-    };
-
-    // C++ wrapper for rep_item_group
-    struct rep_item_group :  ObjectHelper<rep_item_group,0> { rep_item_group() : Object("rep_item_group") {}
-
-    };
-
-    // C++ wrapper for reparametrised_composite_curve_segment
-    struct reparametrised_composite_curve_segment : composite_curve_segment, ObjectHelper<reparametrised_composite_curve_segment,1> { reparametrised_composite_curve_segment() : Object("reparametrised_composite_curve_segment") {}
-		parameter_value::Out param_length;
-    };
-
-    // C++ wrapper for representation_relationship_with_transformation
-    struct representation_relationship_with_transformation : representation_relationship, ObjectHelper<representation_relationship_with_transformation,1> { representation_relationship_with_transformation() : Object("representation_relationship_with_transformation") {}
-		transformation::Out transformation_operator;
-    };
-
-    // C++ wrapper for requirement_assigned_object
-    struct requirement_assigned_object : group_assignment, ObjectHelper<requirement_assigned_object,1> { requirement_assigned_object() : Object("requirement_assigned_object") {}
-		ListOf< requirement_assigned_item, 1, 1 >::Out items;
-    };
-
-    // C++ wrapper for requirement_assignment
-    struct requirement_assignment :  ObjectHelper<requirement_assignment,0> { requirement_assignment() : Object("requirement_assignment") {}
-
-    };
-
-    // C++ wrapper for requirement_source
-    struct requirement_source : group, ObjectHelper<requirement_source,0> { requirement_source() : Object("requirement_source") {}
-
-    };
-
-    // C++ wrapper for requirement_view_definition_relationship
-    struct requirement_view_definition_relationship : product_definition_relationship, ObjectHelper<requirement_view_definition_relationship,0> { requirement_view_definition_relationship() : Object("requirement_view_definition_relationship") {}
-
-    };
-
-    // C++ wrapper for resistance_measure_with_unit
-    struct resistance_measure_with_unit : measure_with_unit, ObjectHelper<resistance_measure_with_unit,0> { resistance_measure_with_unit() : Object("resistance_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for resistance_unit
-    struct resistance_unit : derived_unit, ObjectHelper<resistance_unit,0> { resistance_unit() : Object("resistance_unit") {}
-
-    };
-
-    // C++ wrapper for revolved_area_solid
-    struct revolved_area_solid : swept_area_solid, ObjectHelper<revolved_area_solid,2> { revolved_area_solid() : Object("revolved_area_solid") {}
-		Lazy< axis1_placement > axis;
-		plane_angle_measure::Out angle;
-    };
-
-    // C++ wrapper for revolved_face_solid
-    struct revolved_face_solid : swept_face_solid, ObjectHelper<revolved_face_solid,2> { revolved_face_solid() : Object("revolved_face_solid") {}
-		Lazy< axis1_placement > axis;
-		plane_angle_measure::Out angle;
-    };
-
-    // C++ wrapper for revolved_face_solid_with_trim_conditions
-    struct revolved_face_solid_with_trim_conditions : revolved_face_solid, ObjectHelper<revolved_face_solid_with_trim_conditions,2> { revolved_face_solid_with_trim_conditions() : Object("revolved_face_solid_with_trim_conditions") {}
-		trim_condition_select::Out first_trim_condition;
-		trim_condition_select::Out second_trim_condition;
-    };
-
-    // C++ wrapper for right_angular_wedge
-    struct right_angular_wedge : geometric_representation_item, ObjectHelper<right_angular_wedge,5> { right_angular_wedge() : Object("right_angular_wedge") {}
-		Lazy< axis2_placement_3d > position;
-		positive_length_measure::Out x;
-		positive_length_measure::Out y;
-		positive_length_measure::Out z;
-		length_measure::Out ltx;
-    };
-
-    // C++ wrapper for right_circular_cone
-    struct right_circular_cone : geometric_representation_item, ObjectHelper<right_circular_cone,4> { right_circular_cone() : Object("right_circular_cone") {}
-		Lazy< axis1_placement > position;
-		positive_length_measure::Out height;
-		length_measure::Out radius;
-		plane_angle_measure::Out semi_angle;
-    };
-
-    // C++ wrapper for right_circular_cylinder
-    struct right_circular_cylinder : geometric_representation_item, ObjectHelper<right_circular_cylinder,3> { right_circular_cylinder() : Object("right_circular_cylinder") {}
-		Lazy< axis1_placement > position;
-		positive_length_measure::Out height;
-		positive_length_measure::Out radius;
-    };
-
-    // C++ wrapper for right_to_usage_association
-    struct right_to_usage_association : action_method_relationship, ObjectHelper<right_to_usage_association,0> { right_to_usage_association() : Object("right_to_usage_association") {}
-
-    };
-
-    // C++ wrapper for roundness_tolerance
-    struct roundness_tolerance : geometric_tolerance, ObjectHelper<roundness_tolerance,0> { roundness_tolerance() : Object("roundness_tolerance") {}
-
-    };
-
-    // C++ wrapper for row_representation_item
-    struct row_representation_item : compound_representation_item, ObjectHelper<row_representation_item,0> { row_representation_item() : Object("row_representation_item") {}
-
-    };
-
-    // C++ wrapper for row_value
-    struct row_value : compound_representation_item, ObjectHelper<row_value,0> { row_value() : Object("row_value") {}
-
-    };
-
-    // C++ wrapper for row_variable
-    struct row_variable : abstract_variable, ObjectHelper<row_variable,0> { row_variable() : Object("row_variable") {}
-
-    };
-
-    // C++ wrapper for rule_action
-    struct rule_action : action, ObjectHelper<rule_action,0> { rule_action() : Object("rule_action") {}
-
-    };
-
-    // C++ wrapper for rule_condition
-    struct rule_condition : atomic_formula, ObjectHelper<rule_condition,0> { rule_condition() : Object("rule_condition") {}
-
-    };
-
-    // C++ wrapper for rule_set
-    struct rule_set : rule_software_definition, ObjectHelper<rule_set,0> { rule_set() : Object("rule_set") {}
-
-    };
-
-    // C++ wrapper for rule_set_group
-    struct rule_set_group : rule_software_definition, ObjectHelper<rule_set_group,0> { rule_set_group() : Object("rule_set_group") {}
-
-    };
-
-    // C++ wrapper for rule_superseded_assignment
-    struct rule_superseded_assignment : action_assignment, ObjectHelper<rule_superseded_assignment,1> { rule_superseded_assignment() : Object("rule_superseded_assignment") {}
-		ListOf< rule_superseded_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for rule_supersedence
-    struct rule_supersedence : rule_action, ObjectHelper<rule_supersedence,0> { rule_supersedence() : Object("rule_supersedence") {}
-
-    };
-
-    // C++ wrapper for surface_curve_swept_area_solid
-    struct surface_curve_swept_area_solid : swept_area_solid, ObjectHelper<surface_curve_swept_area_solid,4> { surface_curve_swept_area_solid() : Object("surface_curve_swept_area_solid") {}
-		Lazy< curve > directrix;
-		REAL::Out start_param;
-		REAL::Out end_param;
-		Lazy< surface > reference_surface;
-    };
-
-    // C++ wrapper for ruled_surface_swept_area_solid
-    struct ruled_surface_swept_area_solid : surface_curve_swept_area_solid, ObjectHelper<ruled_surface_swept_area_solid,0> { ruled_surface_swept_area_solid() : Object("ruled_surface_swept_area_solid") {}
-
-    };
-
-    // C++ wrapper for runout_zone_definition
-    struct runout_zone_definition : tolerance_zone_definition, ObjectHelper<runout_zone_definition,1> { runout_zone_definition() : Object("runout_zone_definition") {}
-		Lazy< runout_zone_orientation > orientation;
-    };
-
-    // C++ wrapper for runout_zone_orientation
-    struct runout_zone_orientation :  ObjectHelper<runout_zone_orientation,1> { runout_zone_orientation() : Object("runout_zone_orientation") {}
-		Lazy< measure_with_unit > angle;
-    };
-
-    // C++ wrapper for runout_zone_orientation_reference_direction
-    struct runout_zone_orientation_reference_direction : runout_zone_orientation, ObjectHelper<runout_zone_orientation_reference_direction,1> { runout_zone_orientation_reference_direction() : Object("runout_zone_orientation_reference_direction") {}
-		Lazy< shape_aspect_relationship > orientation_defining_relationship;
-    };
-
-    // C++ wrapper for satisfied_requirement
-    struct satisfied_requirement : group_assignment, ObjectHelper<satisfied_requirement,1> { satisfied_requirement() : Object("satisfied_requirement") {}
-		ListOf< Lazy< product_definition >, 1, 1 > items;
-    };
-
-    // C++ wrapper for satisfies_requirement
-    struct satisfies_requirement : group, ObjectHelper<satisfies_requirement,0> { satisfies_requirement() : Object("satisfies_requirement") {}
-
-    };
-
-    // C++ wrapper for satisfying_item
-    struct satisfying_item : group_assignment, ObjectHelper<satisfying_item,1> { satisfying_item() : Object("satisfying_item") {}
-		ListOf< requirement_satisfaction_item, 1, 1 >::Out items;
-    };
-
-    // C++ wrapper for scalar_variable
-    struct scalar_variable : abstract_variable, ObjectHelper<scalar_variable,0> { scalar_variable() : Object("scalar_variable") {}
-
-    };
-
-    // C++ wrapper for scattering_parameter
-    struct scattering_parameter : polar_complex_number_literal, ObjectHelper<scattering_parameter,0> { scattering_parameter() : Object("scattering_parameter") {}
-
-    };
-
-    // C++ wrapper for sculptured_solid
-    struct sculptured_solid : modified_solid, ObjectHelper<sculptured_solid,2> { sculptured_solid() : Object("sculptured_solid") {}
-		generalized_surface_select::Out sculpturing_element;
-		BOOLEAN::Out positive_side;
-    };
-
-    // C++ wrapper for seam_curve
-    struct seam_curve : surface_curve, ObjectHelper<seam_curve,0> { seam_curve() : Object("seam_curve") {}
-
-    };
-
-    // C++ wrapper for serial_numbered_effectivity
-    struct serial_numbered_effectivity : effectivity, ObjectHelper<serial_numbered_effectivity,2> { serial_numbered_effectivity() : Object("serial_numbered_effectivity") {}
-		identifier::Out effectivity_start_id;
-		Maybe< identifier::Out > effectivity_end_id;
-    };
-
-    // C++ wrapper for shape_aspect_associativity
-    struct shape_aspect_associativity : shape_aspect_relationship, ObjectHelper<shape_aspect_associativity,0> { shape_aspect_associativity() : Object("shape_aspect_associativity") {}
-
-    };
-
-    // C++ wrapper for shape_aspect_deriving_relationship
-    struct shape_aspect_deriving_relationship : shape_aspect_relationship, ObjectHelper<shape_aspect_deriving_relationship,0> { shape_aspect_deriving_relationship() : Object("shape_aspect_deriving_relationship") {}
-
-    };
-
-    // C++ wrapper for shape_definition_representation
-    struct shape_definition_representation : property_definition_representation, ObjectHelper<shape_definition_representation,0> { shape_definition_representation() : Object("shape_definition_representation") {}
-
-    };
-
-    // C++ wrapper for shape_dimension_representation
-    struct shape_dimension_representation : shape_representation, ObjectHelper<shape_dimension_representation,0> { shape_dimension_representation() : Object("shape_dimension_representation") {}
-
-    };
-
-    // C++ wrapper for shape_feature_definition
-    struct shape_feature_definition : characterized_object, ObjectHelper<shape_feature_definition,0> { shape_feature_definition() : Object("shape_feature_definition") {}
-
-    };
-
-    // C++ wrapper for shape_representation_with_parameters
-    struct shape_representation_with_parameters : shape_representation, ObjectHelper<shape_representation_with_parameters,0> { shape_representation_with_parameters() : Object("shape_representation_with_parameters") {}
-
-    };
-
-    // C++ wrapper for shell_based_surface_model
-    struct shell_based_surface_model : geometric_representation_item, ObjectHelper<shell_based_surface_model,1> { shell_based_surface_model() : Object("shell_based_surface_model") {}
-		ListOf< shell, 1, 0 >::Out sbsm_boundary;
-    };
-
-    // C++ wrapper for shell_based_wireframe_model
-    struct shell_based_wireframe_model : geometric_representation_item, ObjectHelper<shell_based_wireframe_model,1> { shell_based_wireframe_model() : Object("shell_based_wireframe_model") {}
-		ListOf< shell, 1, 0 >::Out sbwm_boundary;
-    };
-
-    // C++ wrapper for shell_based_wireframe_shape_representation
-    struct shell_based_wireframe_shape_representation : shape_representation, ObjectHelper<shell_based_wireframe_shape_representation,0> { shell_based_wireframe_shape_representation() : Object("shell_based_wireframe_shape_representation") {}
-
-    };
-
-    // C++ wrapper for si_absorbed_dose_unit
-    struct si_absorbed_dose_unit :  ObjectHelper<si_absorbed_dose_unit,0> { si_absorbed_dose_unit() : Object("si_absorbed_dose_unit") {}
-
-    };
-
-    // C++ wrapper for si_capacitance_unit
-    struct si_capacitance_unit :  ObjectHelper<si_capacitance_unit,0> { si_capacitance_unit() : Object("si_capacitance_unit") {}
-
-    };
-
-    // C++ wrapper for si_conductance_unit
-    struct si_conductance_unit :  ObjectHelper<si_conductance_unit,0> { si_conductance_unit() : Object("si_conductance_unit") {}
-
-    };
-
-    // C++ wrapper for si_dose_equivalent_unit
-    struct si_dose_equivalent_unit :  ObjectHelper<si_dose_equivalent_unit,0> { si_dose_equivalent_unit() : Object("si_dose_equivalent_unit") {}
-
-    };
-
-    // C++ wrapper for si_electric_charge_unit
-    struct si_electric_charge_unit :  ObjectHelper<si_electric_charge_unit,0> { si_electric_charge_unit() : Object("si_electric_charge_unit") {}
-
-    };
-
-    // C++ wrapper for si_electric_potential_unit
-    struct si_electric_potential_unit :  ObjectHelper<si_electric_potential_unit,0> { si_electric_potential_unit() : Object("si_electric_potential_unit") {}
-
-    };
-
-    // C++ wrapper for si_energy_unit
-    struct si_energy_unit :  ObjectHelper<si_energy_unit,0> { si_energy_unit() : Object("si_energy_unit") {}
-
-    };
-
-    // C++ wrapper for si_force_unit
-    struct si_force_unit :  ObjectHelper<si_force_unit,0> { si_force_unit() : Object("si_force_unit") {}
-
-    };
-
-    // C++ wrapper for si_frequency_unit
-    struct si_frequency_unit :  ObjectHelper<si_frequency_unit,0> { si_frequency_unit() : Object("si_frequency_unit") {}
-
-    };
-
-    // C++ wrapper for si_illuminance_unit
-    struct si_illuminance_unit :  ObjectHelper<si_illuminance_unit,0> { si_illuminance_unit() : Object("si_illuminance_unit") {}
-
-    };
-
-    // C++ wrapper for si_inductance_unit
-    struct si_inductance_unit :  ObjectHelper<si_inductance_unit,0> { si_inductance_unit() : Object("si_inductance_unit") {}
-
-    };
-
-    // C++ wrapper for si_magnetic_flux_density_unit
-    struct si_magnetic_flux_density_unit :  ObjectHelper<si_magnetic_flux_density_unit,0> { si_magnetic_flux_density_unit() : Object("si_magnetic_flux_density_unit") {}
-
-    };
-
-    // C++ wrapper for si_magnetic_flux_unit
-    struct si_magnetic_flux_unit :  ObjectHelper<si_magnetic_flux_unit,0> { si_magnetic_flux_unit() : Object("si_magnetic_flux_unit") {}
-
-    };
-
-    // C++ wrapper for si_power_unit
-    struct si_power_unit :  ObjectHelper<si_power_unit,0> { si_power_unit() : Object("si_power_unit") {}
-
-    };
-
-    // C++ wrapper for si_pressure_unit
-    struct si_pressure_unit :  ObjectHelper<si_pressure_unit,0> { si_pressure_unit() : Object("si_pressure_unit") {}
-
-    };
-
-    // C++ wrapper for si_radioactivity_unit
-    struct si_radioactivity_unit :  ObjectHelper<si_radioactivity_unit,0> { si_radioactivity_unit() : Object("si_radioactivity_unit") {}
-
-    };
-
-    // C++ wrapper for si_resistance_unit
-    struct si_resistance_unit :  ObjectHelper<si_resistance_unit,0> { si_resistance_unit() : Object("si_resistance_unit") {}
-
-    };
-
-    // C++ wrapper for si_unit
-    struct si_unit : named_unit, ObjectHelper<si_unit,2> { si_unit() : Object("si_unit") {}
-		Maybe< si_prefix::Out > prefix;
-		si_unit_name::Out name;
-    };
-
-    // C++ wrapper for simple_boolean_expression
-    struct simple_boolean_expression :  ObjectHelper<simple_boolean_expression,0> { simple_boolean_expression() : Object("simple_boolean_expression") {}
-
-    };
-
-    // C++ wrapper for simple_numeric_expression
-    struct simple_numeric_expression :  ObjectHelper<simple_numeric_expression,0> { simple_numeric_expression() : Object("simple_numeric_expression") {}
-
-    };
-
-    // C++ wrapper for slash_expression
-    struct slash_expression : binary_numeric_expression, ObjectHelper<slash_expression,0> { slash_expression() : Object("slash_expression") {}
-
-    };
-
-    // C++ wrapper for smeared_material_definition
-    struct smeared_material_definition : zone_structural_makeup, ObjectHelper<smeared_material_definition,0> { smeared_material_definition() : Object("smeared_material_definition") {}
-
-    };
-
-    // C++ wrapper for solid_angle_measure_with_unit
-    struct solid_angle_measure_with_unit : measure_with_unit, ObjectHelper<solid_angle_measure_with_unit,0> { solid_angle_measure_with_unit() : Object("solid_angle_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for solid_angle_unit
-    struct solid_angle_unit : named_unit, ObjectHelper<solid_angle_unit,0> { solid_angle_unit() : Object("solid_angle_unit") {}
-
-    };
-
-    // C++ wrapper for solid_curve_font
-    struct solid_curve_font : pre_defined_curve_font, ObjectHelper<solid_curve_font,0> { solid_curve_font() : Object("solid_curve_font") {}
-
-    };
-
-    // C++ wrapper for solid_replica
-    struct solid_replica : solid_model, ObjectHelper<solid_replica,2> { solid_replica() : Object("solid_replica") {}
-		Lazy< solid_model > parent_solid;
-		Lazy< cartesian_transformation_operator_3d > transformation;
-    };
-
-    // C++ wrapper for solid_with_chamfered_edges
-    struct solid_with_chamfered_edges : edge_blended_solid, ObjectHelper<solid_with_chamfered_edges,0> { solid_with_chamfered_edges() : Object("solid_with_chamfered_edges") {}
-
-    };
-
-    // C++ wrapper for solid_with_angle_based_chamfer
-    struct solid_with_angle_based_chamfer : solid_with_chamfered_edges, ObjectHelper<solid_with_angle_based_chamfer,3> { solid_with_angle_based_chamfer() : Object("solid_with_angle_based_chamfer") {}
-		positive_length_measure::Out offset_distance;
-		BOOLEAN::Out left_offset;
-		positive_plane_angle_measure::Out offset_angle;
-    };
-
-    // C++ wrapper for solid_with_shape_element_pattern
-    struct solid_with_shape_element_pattern : modified_solid_with_placed_configuration, ObjectHelper<solid_with_shape_element_pattern,1> { solid_with_shape_element_pattern() : Object("solid_with_shape_element_pattern") {}
-		Lazy< modified_solid_with_placed_configuration > replicated_element;
-    };
-
-    // C++ wrapper for solid_with_circular_pattern
-    struct solid_with_circular_pattern : solid_with_shape_element_pattern, ObjectHelper<solid_with_circular_pattern,4> { solid_with_circular_pattern() : Object("solid_with_circular_pattern") {}
-		positive_integer::Out replicate_count;
-		plane_angle_measure::Out angular_spacing;
-		BOOLEAN::Out radial_alignment;
-		Lazy< point > reference_point;
-    };
-
-    // C++ wrapper for solid_with_depression
-    struct solid_with_depression : modified_solid_with_placed_configuration, ObjectHelper<solid_with_depression,1> { solid_with_depression() : Object("solid_with_depression") {}
-		positive_length_measure::Out depth;
-    };
-
-    // C++ wrapper for solid_with_pocket
-    struct solid_with_pocket : solid_with_depression, ObjectHelper<solid_with_pocket,2> { solid_with_pocket() : Object("solid_with_pocket") {}
-		non_negative_length_measure::Out floor_blend_radius;
-		plane_angle_measure::Out draft_angle;
-    };
-
-    // C++ wrapper for solid_with_circular_pocket
-    struct solid_with_circular_pocket : solid_with_pocket, ObjectHelper<solid_with_circular_pocket,1> { solid_with_circular_pocket() : Object("solid_with_circular_pocket") {}
-		positive_length_measure::Out pocket_radius;
-    };
-
-    // C++ wrapper for solid_with_protrusion
-    struct solid_with_protrusion : modified_solid_with_placed_configuration, ObjectHelper<solid_with_protrusion,2> { solid_with_protrusion() : Object("solid_with_protrusion") {}
-		positive_length_measure::Out protrusion_height;
-		plane_angle_measure::Out protrusion_draft_angle;
-    };
-
-    // C++ wrapper for solid_with_circular_protrusion
-    struct solid_with_circular_protrusion : solid_with_protrusion, ObjectHelper<solid_with_circular_protrusion,1> { solid_with_circular_protrusion() : Object("solid_with_circular_protrusion") {}
-		positive_length_measure::Out protrusion_radius;
-    };
-
-    // C++ wrapper for solid_with_hole
-    struct solid_with_hole : solid_with_depression, ObjectHelper<solid_with_hole,0> { solid_with_hole() : Object("solid_with_hole") {}
-
-    };
-
-    // C++ wrapper for solid_with_stepped_round_hole
-    struct solid_with_stepped_round_hole : solid_with_hole, ObjectHelper<solid_with_stepped_round_hole,1> { solid_with_stepped_round_hole() : Object("solid_with_stepped_round_hole") {}
-		positive_integer::Out segments;
-    };
-
-    // C++ wrapper for solid_with_conical_bottom_round_hole
-    struct solid_with_conical_bottom_round_hole : solid_with_stepped_round_hole, ObjectHelper<solid_with_conical_bottom_round_hole,2> { solid_with_conical_bottom_round_hole() : Object("solid_with_conical_bottom_round_hole") {}
-		positive_plane_angle_measure::Out semi_apex_angle;
-		non_negative_length_measure::Out tip_radius;
-    };
-
-    // C++ wrapper for solid_with_constant_radius_edge_blend
-    struct solid_with_constant_radius_edge_blend : edge_blended_solid, ObjectHelper<solid_with_constant_radius_edge_blend,1> { solid_with_constant_radius_edge_blend() : Object("solid_with_constant_radius_edge_blend") {}
-		positive_length_measure::Out radius;
-    };
-
-    // C++ wrapper for solid_with_slot
-    struct solid_with_slot : solid_with_depression, ObjectHelper<solid_with_slot,2> { solid_with_slot() : Object("solid_with_slot") {}
-		positive_length_measure::Out slot_width;
-		ListOf< LOGICAL, 2, 2 >::Out closed_ends;
-    };
-
-    // C++ wrapper for solid_with_curved_slot
-    struct solid_with_curved_slot : solid_with_slot, ObjectHelper<solid_with_curved_slot,1> { solid_with_curved_slot() : Object("solid_with_curved_slot") {}
-		Lazy< bounded_curve > slot_centreline;
-    };
-
-    // C++ wrapper for solid_with_double_offset_chamfer
-    struct solid_with_double_offset_chamfer : solid_with_chamfered_edges, ObjectHelper<solid_with_double_offset_chamfer,2> { solid_with_double_offset_chamfer() : Object("solid_with_double_offset_chamfer") {}
-		positive_length_measure::Out left_offset_distance;
-		positive_length_measure::Out right_offset_distance;
-    };
-
-    // C++ wrapper for solid_with_flat_bottom_round_hole
-    struct solid_with_flat_bottom_round_hole : solid_with_stepped_round_hole, ObjectHelper<solid_with_flat_bottom_round_hole,1> { solid_with_flat_bottom_round_hole() : Object("solid_with_flat_bottom_round_hole") {}
-		non_negative_length_measure::Out fillet_radius;
-    };
-
-    // C++ wrapper for solid_with_general_pocket
-    struct solid_with_general_pocket : solid_with_pocket, ObjectHelper<solid_with_general_pocket,2> { solid_with_general_pocket() : Object("solid_with_general_pocket") {}
-		Lazy< positioned_sketch > profile;
-		Lazy< point > reference_point;
-    };
-
-    // C++ wrapper for solid_with_general_protrusion
-    struct solid_with_general_protrusion : solid_with_protrusion, ObjectHelper<solid_with_general_protrusion,2> { solid_with_general_protrusion() : Object("solid_with_general_protrusion") {}
-		Lazy< positioned_sketch > profile;
-		Lazy< point > reference_point;
-    };
-
-    // C++ wrapper for solid_with_groove
-    struct solid_with_groove : solid_with_depression, ObjectHelper<solid_with_groove,5> { solid_with_groove() : Object("solid_with_groove") {}
-		positive_length_measure::Out groove_radius;
-		positive_length_measure::Out groove_width;
-		plane_angle_measure::Out draft_angle;
-		non_negative_length_measure::Out floor_fillet_radius;
-		BOOLEAN::Out external_groove;
-    };
-
-    // C++ wrapper for solid_with_incomplete_circular_pattern
-    struct solid_with_incomplete_circular_pattern : solid_with_circular_pattern, ObjectHelper<solid_with_incomplete_circular_pattern,1> { solid_with_incomplete_circular_pattern() : Object("solid_with_incomplete_circular_pattern") {}
-		ListOf< positive_integer, 1, 0 >::Out omitted_instances;
-    };
-
-    // C++ wrapper for solid_with_rectangular_pattern
-    struct solid_with_rectangular_pattern : solid_with_shape_element_pattern, ObjectHelper<solid_with_rectangular_pattern,4> { solid_with_rectangular_pattern() : Object("solid_with_rectangular_pattern") {}
-		positive_integer::Out row_count;
-		positive_integer::Out column_count;
-		length_measure::Out row_spacing;
-		length_measure::Out column_spacing;
-    };
-
-    // C++ wrapper for solid_with_incomplete_rectangular_pattern
-    struct solid_with_incomplete_rectangular_pattern : solid_with_rectangular_pattern, ObjectHelper<solid_with_incomplete_rectangular_pattern,0> { solid_with_incomplete_rectangular_pattern() : Object("solid_with_incomplete_rectangular_pattern") {}
-
-    };
-
-    // C++ wrapper for solid_with_rectangular_pocket
-    struct solid_with_rectangular_pocket : solid_with_pocket, ObjectHelper<solid_with_rectangular_pocket,3> { solid_with_rectangular_pocket() : Object("solid_with_rectangular_pocket") {}
-		positive_length_measure::Out pocket_length;
-		positive_length_measure::Out pocket_width;
-		non_negative_length_measure::Out corner_radius;
-    };
-
-    // C++ wrapper for solid_with_rectangular_protrusion
-    struct solid_with_rectangular_protrusion : solid_with_protrusion, ObjectHelper<solid_with_rectangular_protrusion,3> { solid_with_rectangular_protrusion() : Object("solid_with_rectangular_protrusion") {}
-		positive_length_measure::Out protrusion_length;
-		positive_length_measure::Out protrusion_width;
-		non_negative_length_measure::Out protrusion_corner_radius;
-    };
-
-    // C++ wrapper for solid_with_single_offset_chamfer
-    struct solid_with_single_offset_chamfer : solid_with_chamfered_edges, ObjectHelper<solid_with_single_offset_chamfer,1> { solid_with_single_offset_chamfer() : Object("solid_with_single_offset_chamfer") {}
-		positive_length_measure::Out offset_distance;
-    };
-
-    // C++ wrapper for solid_with_spherical_bottom_round_hole
-    struct solid_with_spherical_bottom_round_hole : solid_with_stepped_round_hole, ObjectHelper<solid_with_spherical_bottom_round_hole,1> { solid_with_spherical_bottom_round_hole() : Object("solid_with_spherical_bottom_round_hole") {}
-		positive_length_measure::Out sphere_radius;
-    };
-
-    // C++ wrapper for solid_with_stepped_round_hole_and_conical_transitions
-    struct solid_with_stepped_round_hole_and_conical_transitions : solid_with_stepped_round_hole, ObjectHelper<solid_with_stepped_round_hole_and_conical_transitions,1> { solid_with_stepped_round_hole_and_conical_transitions() : Object("solid_with_stepped_round_hole_and_conical_transitions") {}
-		ListOf< Lazy< conical_stepped_hole_transition >, 1, 0 > conical_transitions;
-    };
-
-    // C++ wrapper for solid_with_straight_slot
-    struct solid_with_straight_slot : solid_with_slot, ObjectHelper<solid_with_straight_slot,1> { solid_with_straight_slot() : Object("solid_with_straight_slot") {}
-		positive_length_measure::Out slot_length;
-    };
-
-    // C++ wrapper for solid_with_tee_section_slot
-    struct solid_with_tee_section_slot : solid_with_slot, ObjectHelper<solid_with_tee_section_slot,2> { solid_with_tee_section_slot() : Object("solid_with_tee_section_slot") {}
-		positive_length_measure::Out tee_section_width;
-		positive_length_measure::Out collar_depth;
-    };
-
-    // C++ wrapper for solid_with_through_depression
-    struct solid_with_through_depression : solid_with_depression, ObjectHelper<solid_with_through_depression,1> { solid_with_through_depression() : Object("solid_with_through_depression") {}
-		ListOf< Lazy< face_surface >, 1, 0 > exit_faces;
-    };
-
-    // C++ wrapper for solid_with_trapezoidal_section_slot
-    struct solid_with_trapezoidal_section_slot : solid_with_slot, ObjectHelper<solid_with_trapezoidal_section_slot,2> { solid_with_trapezoidal_section_slot() : Object("solid_with_trapezoidal_section_slot") {}
-		plane_angle_measure::Out draft_angle;
-		non_negative_length_measure::Out floor_fillet_radius;
-    };
-
-    // C++ wrapper for solid_with_variable_radius_edge_blend
-    struct solid_with_variable_radius_edge_blend :  ObjectHelper<solid_with_variable_radius_edge_blend,3> { solid_with_variable_radius_edge_blend() : Object("solid_with_variable_radius_edge_blend") {}
-		ListOf< Lazy< point >, 2, 0 > point_list;
-		ListOf< positive_length_measure, 2, 0 >::Out radius_list;
-		ListOf< blend_radius_variation_type, 1, 0 >::Out edge_function_list;
-    };
-
-    // C++ wrapper for source_for_requirement
-    struct source_for_requirement : group_assignment, ObjectHelper<source_for_requirement,1> { source_for_requirement() : Object("source_for_requirement") {}
-		ListOf< requirement_source_item, 1, 1 >::Out items;
-    };
-
-    // C++ wrapper for sourced_requirement
-    struct sourced_requirement : group_assignment, ObjectHelper<sourced_requirement,1> { sourced_requirement() : Object("sourced_requirement") {}
-		ListOf< Lazy< product_definition >, 1, 1 > items;
-    };
-
-    // C++ wrapper for specification_definition
-    struct specification_definition : product_definition, ObjectHelper<specification_definition,0> { specification_definition() : Object("specification_definition") {}
-
-    };
-
-    // C++ wrapper for specified_higher_usage_occurrence
-    struct specified_higher_usage_occurrence : assembly_component_usage, ObjectHelper<specified_higher_usage_occurrence,2> { specified_higher_usage_occurrence() : Object("specified_higher_usage_occurrence") {}
-		Lazy< assembly_component_usage > upper_usage;
-		Lazy< next_assembly_usage_occurrence > next_usage;
-    };
-
-    // C++ wrapper for sphere
-    struct sphere : geometric_representation_item, ObjectHelper<sphere,2> { sphere() : Object("sphere") {}
-		positive_length_measure::Out radius;
-		Lazy< point > centre;
-    };
-
-    // C++ wrapper for spherical_surface
-    struct spherical_surface : elementary_surface, ObjectHelper<spherical_surface,1> { spherical_surface() : Object("spherical_surface") {}
-		positive_length_measure::Out radius;
-    };
-
-    // C++ wrapper for start_request
-    struct start_request : action_request_assignment, ObjectHelper<start_request,1> { start_request() : Object("start_request") {}
-		ListOf< start_request_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for start_work
-    struct start_work : action_assignment, ObjectHelper<start_work,1> { start_work() : Object("start_work") {}
-		ListOf< work_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for straightness_tolerance
-    struct straightness_tolerance : geometric_tolerance, ObjectHelper<straightness_tolerance,0> { straightness_tolerance() : Object("straightness_tolerance") {}
-
-    };
-
-    // C++ wrapper for structured_dimension_callout
-    struct structured_dimension_callout : draughting_callout, ObjectHelper<structured_dimension_callout,0> { structured_dimension_callout() : Object("structured_dimension_callout") {}
-
-    };
-
-    // C++ wrapper for structured_text_composition
-    struct structured_text_composition : compound_representation_item, ObjectHelper<structured_text_composition,0> { structured_text_composition() : Object("structured_text_composition") {}
-
-    };
-
-    // C++ wrapper for structured_text_representation
-    struct structured_text_representation : representation, ObjectHelper<structured_text_representation,0> { structured_text_representation() : Object("structured_text_representation") {}
-
-    };
-
-    // C++ wrapper for subedge
-    struct subedge : edge, ObjectHelper<subedge,1> { subedge() : Object("subedge") {}
-		Lazy< edge > parent_edge;
-    };
-
-    // C++ wrapper for subface
-    struct subface : face, ObjectHelper<subface,1> { subface() : Object("subface") {}
-		Lazy< face > parent_face;
-    };
-
-    // C++ wrapper for supplied_part_relationship
-    struct supplied_part_relationship : product_definition_relationship, ObjectHelper<supplied_part_relationship,0> { supplied_part_relationship() : Object("supplied_part_relationship") {}
-
-    };
-
-    // C++ wrapper for surface_condition_callout
-    struct surface_condition_callout : draughting_callout, ObjectHelper<surface_condition_callout,0> { surface_condition_callout() : Object("surface_condition_callout") {}
-
-    };
-
-    // C++ wrapper for swept_surface
-    struct swept_surface : surface, ObjectHelper<swept_surface,1> { swept_surface() : Object("swept_surface") {}
-		Lazy< curve > swept_curve;
-    };
-
-    // C++ wrapper for surface_of_linear_extrusion
-    struct surface_of_linear_extrusion : swept_surface, ObjectHelper<surface_of_linear_extrusion,1> { surface_of_linear_extrusion() : Object("surface_of_linear_extrusion") {}
-		Lazy< vector > extrusion_axis;
-    };
-
-    // C++ wrapper for surface_of_revolution
-    struct surface_of_revolution : swept_surface, ObjectHelper<surface_of_revolution,1> { surface_of_revolution() : Object("surface_of_revolution") {}
-		Lazy< axis1_placement > axis_position;
-    };
-
-    // C++ wrapper for surface_patch
-    struct surface_patch : founded_item, ObjectHelper<surface_patch,5> { surface_patch() : Object("surface_patch") {}
-		Lazy< bounded_surface > parent_surface;
-		transition_code::Out u_transition;
-		transition_code::Out v_transition;
-		BOOLEAN::Out u_sense;
-		BOOLEAN::Out v_sense;
-    };
-
-    // C++ wrapper for surface_profile_tolerance
-    struct surface_profile_tolerance : geometric_tolerance, ObjectHelper<surface_profile_tolerance,0> { surface_profile_tolerance() : Object("surface_profile_tolerance") {}
-
-    };
-
-    // C++ wrapper for surface_replica
-    struct surface_replica : surface, ObjectHelper<surface_replica,2> { surface_replica() : Object("surface_replica") {}
-		Lazy< surface > parent_surface;
-		Lazy< cartesian_transformation_operator_3d > transformation;
-    };
-
-    // C++ wrapper for surface_side_style
-    struct surface_side_style : founded_item, ObjectHelper<surface_side_style,2> { surface_side_style() : Object("surface_side_style") {}
-		label::Out name;
-		ListOf< surface_style_element_select, 1, 7 >::Out styles;
-    };
-
-    // C++ wrapper for surface_style_boundary
-    struct surface_style_boundary : founded_item, ObjectHelper<surface_style_boundary,1> { surface_style_boundary() : Object("surface_style_boundary") {}
-		curve_or_render::Out style_of_boundary;
-    };
-
-    // C++ wrapper for surface_style_control_grid
-    struct surface_style_control_grid : founded_item, ObjectHelper<surface_style_control_grid,1> { surface_style_control_grid() : Object("surface_style_control_grid") {}
-		curve_or_render::Out style_of_control_grid;
-    };
-
-    // C++ wrapper for surface_style_fill_area
-    struct surface_style_fill_area : founded_item, ObjectHelper<surface_style_fill_area,1> { surface_style_fill_area() : Object("surface_style_fill_area") {}
-		Lazy< fill_area_style > fill_area;
-    };
-
-    // C++ wrapper for surface_style_parameter_line
-    struct surface_style_parameter_line : founded_item, ObjectHelper<surface_style_parameter_line,2> { surface_style_parameter_line() : Object("surface_style_parameter_line") {}
-		curve_or_render::Out style_of_parameter_lines;
-		ListOf< direction_count_select, 1, 2 >::Out direction_counts;
-    };
-
-    // C++ wrapper for surface_style_reflectance_ambient
-    struct surface_style_reflectance_ambient :  ObjectHelper<surface_style_reflectance_ambient,1> { surface_style_reflectance_ambient() : Object("surface_style_reflectance_ambient") {}
-		REAL::Out ambient_reflectance;
-    };
-
-    // C++ wrapper for surface_style_reflectance_ambient_diffuse
-    struct surface_style_reflectance_ambient_diffuse : surface_style_reflectance_ambient, ObjectHelper<surface_style_reflectance_ambient_diffuse,1> { surface_style_reflectance_ambient_diffuse() : Object("surface_style_reflectance_ambient_diffuse") {}
-		REAL::Out diffuse_reflectance;
-    };
-
-    // C++ wrapper for surface_style_reflectance_ambient_diffuse_specular
-    struct surface_style_reflectance_ambient_diffuse_specular : surface_style_reflectance_ambient_diffuse, ObjectHelper<surface_style_reflectance_ambient_diffuse_specular,3> { surface_style_reflectance_ambient_diffuse_specular() : Object("surface_style_reflectance_ambient_diffuse_specular") {}
-		REAL::Out specular_reflectance;
-		REAL::Out specular_exponent;
-		Lazy< colour > specular_colour;
-    };
-
-    // C++ wrapper for surface_style_rendering
-    struct surface_style_rendering :  ObjectHelper<surface_style_rendering,2> { surface_style_rendering() : Object("surface_style_rendering") {}
-		shading_surface_method::Out rendering_method;
-		Lazy< colour > surface_colour;
-    };
-
-    // C++ wrapper for surface_style_rendering_with_properties
-    struct surface_style_rendering_with_properties : surface_style_rendering, ObjectHelper<surface_style_rendering_with_properties,1> { surface_style_rendering_with_properties() : Object("surface_style_rendering_with_properties") {}
-		ListOf< rendering_properties_select, 1, 2 >::Out properties;
-    };
-
-    // C++ wrapper for surface_style_segmentation_curve
-    struct surface_style_segmentation_curve : founded_item, ObjectHelper<surface_style_segmentation_curve,1> { surface_style_segmentation_curve() : Object("surface_style_segmentation_curve") {}
-		curve_or_render::Out style_of_segmentation_curve;
-    };
-
-    // C++ wrapper for surface_style_silhouette
-    struct surface_style_silhouette : founded_item, ObjectHelper<surface_style_silhouette,1> { surface_style_silhouette() : Object("surface_style_silhouette") {}
-		curve_or_render::Out style_of_silhouette;
-    };
-
-    // C++ wrapper for surface_style_usage
-    struct surface_style_usage : founded_item, ObjectHelper<surface_style_usage,2> { surface_style_usage() : Object("surface_style_usage") {}
-		surface_side::Out side;
-		surface_side_style_select::Out style;
-    };
-
-    // C++ wrapper for surface_texture_representation
-    struct surface_texture_representation : representation, ObjectHelper<surface_texture_representation,0> { surface_texture_representation() : Object("surface_texture_representation") {}
-
-    };
-
-    // C++ wrapper for surfaced_open_shell
-    struct surfaced_open_shell : open_shell, ObjectHelper<surfaced_open_shell,0> { surfaced_open_shell() : Object("surfaced_open_shell") {}
-
-    };
-
-    // C++ wrapper for swept_disk_solid
-    struct swept_disk_solid : solid_model, ObjectHelper<swept_disk_solid,5> { swept_disk_solid() : Object("swept_disk_solid") {}
-		Lazy< curve > directrix;
-		positive_length_measure::Out radius;
-		Maybe< positive_length_measure::Out > inner_radius;
-		REAL::Out start_param;
-		REAL::Out end_param;
-    };
-
-    // C++ wrapper for symbol
-    struct symbol : representation_item, ObjectHelper<symbol,0> { symbol() : Object("symbol") {}
-
-    };
-
-    // C++ wrapper for symbol_representation_map
-    struct symbol_representation_map : representation_map, ObjectHelper<symbol_representation_map,0> { symbol_representation_map() : Object("symbol_representation_map") {}
-
-    };
-
-    // C++ wrapper for symbol_style
-    struct symbol_style : founded_item, ObjectHelper<symbol_style,2> { symbol_style() : Object("symbol_style") {}
-		label::Out name;
-		symbol_style_select::Out style_of_symbol;
-    };
-
-    // C++ wrapper for symbol_target
-    struct symbol_target : geometric_representation_item, ObjectHelper<symbol_target,3> { symbol_target() : Object("symbol_target") {}
-		axis2_placement::Out placement;
-		positive_ratio_measure::Out x_scale;
-		positive_ratio_measure::Out y_scale;
-    };
-
-    // C++ wrapper for symmetric_shape_aspect
-    struct symmetric_shape_aspect : shape_aspect, ObjectHelper<symmetric_shape_aspect,0> { symmetric_shape_aspect() : Object("symmetric_shape_aspect") {}
-
-    };
-
-    // C++ wrapper for symmetry_tolerance
-    struct symmetry_tolerance : geometric_tolerance_with_datum_reference, ObjectHelper<symmetry_tolerance,0> { symmetry_tolerance() : Object("symmetry_tolerance") {}
-
-    };
-
-    // C++ wrapper for table_representation_item
-    struct table_representation_item : compound_representation_item, ObjectHelper<table_representation_item,0> { table_representation_item() : Object("table_representation_item") {}
-
-    };
-
-    // C++ wrapper for tactile_appearance_representation
-    struct tactile_appearance_representation : representation, ObjectHelper<tactile_appearance_representation,0> { tactile_appearance_representation() : Object("tactile_appearance_representation") {}
-
-    };
-
-    // C++ wrapper for tagged_text_format
-    struct tagged_text_format : representation_context, ObjectHelper<tagged_text_format,0> { tagged_text_format() : Object("tagged_text_format") {}
-
-    };
-
-    // C++ wrapper for tagged_text_item
-    struct tagged_text_item : descriptive_representation_item, ObjectHelper<tagged_text_item,0> { tagged_text_item() : Object("tagged_text_item") {}
-
-    };
-
-    // C++ wrapper for tangent
-    struct tangent : derived_shape_aspect, ObjectHelper<tangent,0> { tangent() : Object("tangent") {}
-
-    };
-
-    // C++ wrapper for text_literal_with_associated_curves
-    struct text_literal_with_associated_curves : text_literal, ObjectHelper<text_literal_with_associated_curves,1> { text_literal_with_associated_curves() : Object("text_literal_with_associated_curves") {}
-		ListOf< Lazy< curve >, 1, 0 > associated_curves;
-    };
-
-    // C++ wrapper for text_literal_with_blanking_box
-    struct text_literal_with_blanking_box : text_literal, ObjectHelper<text_literal_with_blanking_box,1> { text_literal_with_blanking_box() : Object("text_literal_with_blanking_box") {}
-		Lazy< planar_box > blanking;
-    };
-
-    // C++ wrapper for text_literal_with_extent
-    struct text_literal_with_extent : text_literal, ObjectHelper<text_literal_with_extent,1> { text_literal_with_extent() : Object("text_literal_with_extent") {}
-		Lazy< planar_extent > extent;
-    };
-
-    // C++ wrapper for text_string_representation
-    struct text_string_representation : representation, ObjectHelper<text_string_representation,0> { text_string_representation() : Object("text_string_representation") {}
-
-    };
-
-    // C++ wrapper for text_style
-    struct text_style : founded_item, ObjectHelper<text_style,2> { text_style() : Object("text_style") {}
-		label::Out name;
-		character_style_select::Out character_appearance;
-    };
-
-    // C++ wrapper for text_style_with_box_characteristics
-    struct text_style_with_box_characteristics : text_style, ObjectHelper<text_style_with_box_characteristics,1> { text_style_with_box_characteristics() : Object("text_style_with_box_characteristics") {}
-		ListOf< box_characteristic_select, 1, 4 >::Out characteristics;
-    };
-
-    // C++ wrapper for text_style_with_mirror
-    struct text_style_with_mirror : text_style, ObjectHelper<text_style_with_mirror,1> { text_style_with_mirror() : Object("text_style_with_mirror") {}
-		axis2_placement::Out mirror_placement;
-    };
-
-    // C++ wrapper for text_style_with_spacing
-    struct text_style_with_spacing : text_style, ObjectHelper<text_style_with_spacing,1> { text_style_with_spacing() : Object("text_style_with_spacing") {}
-		character_spacing_select::Out character_spacing;
-    };
-
-    // C++ wrapper for thermal_resistance_measure_with_unit
-    struct thermal_resistance_measure_with_unit : measure_with_unit, ObjectHelper<thermal_resistance_measure_with_unit,0> { thermal_resistance_measure_with_unit() : Object("thermal_resistance_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for thermal_resistance_unit
-    struct thermal_resistance_unit : derived_unit, ObjectHelper<thermal_resistance_unit,0> { thermal_resistance_unit() : Object("thermal_resistance_unit") {}
-
-    };
-
-    // C++ wrapper for thermodynamic_temperature_measure_with_unit
-    struct thermodynamic_temperature_measure_with_unit : measure_with_unit, ObjectHelper<thermodynamic_temperature_measure_with_unit,0> { thermodynamic_temperature_measure_with_unit() : Object("thermodynamic_temperature_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for thermodynamic_temperature_unit
-    struct thermodynamic_temperature_unit : named_unit, ObjectHelper<thermodynamic_temperature_unit,0> { thermodynamic_temperature_unit() : Object("thermodynamic_temperature_unit") {}
-
-    };
-
-    // C++ wrapper for thickened_face_solid
-    struct thickened_face_solid : solid_model, ObjectHelper<thickened_face_solid,3> { thickened_face_solid() : Object("thickened_face_solid") {}
-		generalized_surface_select::Out base_element;
-		length_measure::Out offset1;
-		length_measure::Out offset2;
-    };
-
-    // C++ wrapper for thickness_laminate_definition
-    struct thickness_laminate_definition : product_definition, ObjectHelper<thickness_laminate_definition,0> { thickness_laminate_definition() : Object("thickness_laminate_definition") {}
-
-    };
-
-    // C++ wrapper for thickness_laminate_table
-    struct thickness_laminate_table : zone_structural_makeup, ObjectHelper<thickness_laminate_table,0> { thickness_laminate_table() : Object("thickness_laminate_table") {}
-
-    };
-
-    // C++ wrapper for time_interval
-    struct time_interval :  ObjectHelper<time_interval,3> { time_interval() : Object("time_interval") {}
-		identifier::Out id;
-		label::Out name;
-		Maybe< text::Out > description;
-    };
-
-    // C++ wrapper for time_interval_based_effectivity
-    struct time_interval_based_effectivity : effectivity, ObjectHelper<time_interval_based_effectivity,1> { time_interval_based_effectivity() : Object("time_interval_based_effectivity") {}
-		Lazy< time_interval > effectivity_period;
-    };
-
-    // C++ wrapper for time_interval_with_bounds
-    struct time_interval_with_bounds : time_interval, ObjectHelper<time_interval_with_bounds,3> { time_interval_with_bounds() : Object("time_interval_with_bounds") {}
-		Maybe< date_time_or_event_occurrence::Out > primary_bound;
-		Maybe< date_time_or_event_occurrence::Out > secondary_bound;
-		Maybe< Lazy< time_measure_with_unit > > duration;
-    };
-
-    // C++ wrapper for time_measure_with_unit
-    struct time_measure_with_unit : measure_with_unit, ObjectHelper<time_measure_with_unit,0> { time_measure_with_unit() : Object("time_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for time_unit
-    struct time_unit : named_unit, ObjectHelper<time_unit,0> { time_unit() : Object("time_unit") {}
-
-    };
-
-    // C++ wrapper for tolerance_zone
-    struct tolerance_zone : shape_aspect, ObjectHelper<tolerance_zone,2> { tolerance_zone() : Object("tolerance_zone") {}
-		ListOf< Lazy< geometric_tolerance >, 1, 0 > defining_tolerance;
-		Lazy< NotImplemented > form;
-    };
-
-    // C++ wrapper for torus
-    struct torus : geometric_representation_item, ObjectHelper<torus,3> { torus() : Object("torus") {}
-		Lazy< axis1_placement > position;
-		positive_length_measure::Out major_radius;
-		positive_length_measure::Out minor_radius;
-    };
-
-    // C++ wrapper for total_runout_tolerance
-    struct total_runout_tolerance : geometric_tolerance_with_datum_reference, ObjectHelper<total_runout_tolerance,0> { total_runout_tolerance() : Object("total_runout_tolerance") {}
-
-    };
-
-    // C++ wrapper for track_blended_solid
-    struct track_blended_solid : edge_blended_solid, ObjectHelper<track_blended_solid,0> { track_blended_solid() : Object("track_blended_solid") {}
-
-    };
-
-    // C++ wrapper for track_blended_solid_with_end_conditions
-    struct track_blended_solid_with_end_conditions : track_blended_solid, ObjectHelper<track_blended_solid_with_end_conditions,1> { track_blended_solid_with_end_conditions() : Object("track_blended_solid_with_end_conditions") {}
-		ListOf< blend_end_condition_select, 2, 2 >::Out end_conditions;
-    };
-
-    // C++ wrapper for trimmed_curve
-    struct trimmed_curve : bounded_curve, ObjectHelper<trimmed_curve,5> { trimmed_curve() : Object("trimmed_curve") {}
-		Lazy< curve > basis_curve;
-		ListOf< trimming_select, 1, 2 >::Out trim_1;
-		ListOf< trimming_select, 1, 2 >::Out trim_2;
-		BOOLEAN::Out sense_agreement;
-		trimming_preference::Out master_representation;
-    };
-
-    // C++ wrapper for two_direction_repeat_factor
-    struct two_direction_repeat_factor : one_direction_repeat_factor, ObjectHelper<two_direction_repeat_factor,1> { two_direction_repeat_factor() : Object("two_direction_repeat_factor") {}
-		Lazy< vector > second_repeat_factor;
-    };
-
-    // C++ wrapper for unary_generic_expression
-    struct unary_generic_expression : generic_expression, ObjectHelper<unary_generic_expression,1> { unary_generic_expression() : Object("unary_generic_expression") {}
-		Lazy< generic_expression > operand;
-    };
-
-    // C++ wrapper for unary_numeric_expression
-    struct unary_numeric_expression :  ObjectHelper<unary_numeric_expression,0> { unary_numeric_expression() : Object("unary_numeric_expression") {}
-
-    };
-
-    // C++ wrapper for uncertainty_assigned_representation
-    struct uncertainty_assigned_representation : representation, ObjectHelper<uncertainty_assigned_representation,1> { uncertainty_assigned_representation() : Object("uncertainty_assigned_representation") {}
-		ListOf< Lazy< uncertainty_measure_with_unit >, 1, 0 > uncertainty;
-    };
-
-    // C++ wrapper for uncertainty_measure_with_unit
-    struct uncertainty_measure_with_unit : measure_with_unit, ObjectHelper<uncertainty_measure_with_unit,2> { uncertainty_measure_with_unit() : Object("uncertainty_measure_with_unit") {}
-		label::Out name;
-		Maybe< text::Out > description;
-    };
-
-    // C++ wrapper for uniform_curve
-    struct uniform_curve : b_spline_curve, ObjectHelper<uniform_curve,0> { uniform_curve() : Object("uniform_curve") {}
-
-    };
-
-    // C++ wrapper for uniform_resource_identifier
-    struct uniform_resource_identifier : descriptive_representation_item, ObjectHelper<uniform_resource_identifier,0> { uniform_resource_identifier() : Object("uniform_resource_identifier") {}
-
-    };
-
-    // C++ wrapper for uniform_surface
-    struct uniform_surface : b_spline_surface, ObjectHelper<uniform_surface,0> { uniform_surface() : Object("uniform_surface") {}
-
-    };
-
-    // C++ wrapper for usage_association
-    struct usage_association : action_method_relationship, ObjectHelper<usage_association,0> { usage_association() : Object("usage_association") {}
-
-    };
-
-    // C++ wrapper for user_defined_curve_font
-    struct user_defined_curve_font :  ObjectHelper<user_defined_curve_font,0> { user_defined_curve_font() : Object("user_defined_curve_font") {}
-
-    };
-
-    // C++ wrapper for user_defined_marker
-    struct user_defined_marker :  ObjectHelper<user_defined_marker,0> { user_defined_marker() : Object("user_defined_marker") {}
-
-    };
-
-    // C++ wrapper for user_defined_terminator_symbol
-    struct user_defined_terminator_symbol :  ObjectHelper<user_defined_terminator_symbol,0> { user_defined_terminator_symbol() : Object("user_defined_terminator_symbol") {}
-
-    };
-
-    // C++ wrapper for user_selected_shape_elements
-    struct user_selected_shape_elements : user_selected_elements, ObjectHelper<user_selected_shape_elements,0> { user_selected_shape_elements() : Object("user_selected_shape_elements") {}
-
-    };
-
-    // C++ wrapper for value_range
-    struct value_range : compound_representation_item, ObjectHelper<value_range,0> { value_range() : Object("value_range") {}
-
-    };
-
-    // C++ wrapper for value_representation_item
-    struct value_representation_item : representation_item, ObjectHelper<value_representation_item,1> { value_representation_item() : Object("value_representation_item") {}
-		measure_value::Out value_component;
-    };
-
-    // C++ wrapper for variable_semantics
-    struct variable_semantics :  ObjectHelper<variable_semantics,0> { variable_semantics() : Object("variable_semantics") {}
-
-    };
-
-    // C++ wrapper for variational_representation_item
-    struct variational_representation_item : representation_item, ObjectHelper<variational_representation_item,0> { variational_representation_item() : Object("variational_representation_item") {}
-
-    };
-
-    // C++ wrapper for vector
-    struct vector : geometric_representation_item, ObjectHelper<vector,2> { vector() : Object("vector") {}
-		Lazy< direction > orientation;
-		length_measure::Out magnitude;
-    };
-
-    // C++ wrapper for vector_style
-    struct vector_style :  ObjectHelper<vector_style,0> { vector_style() : Object("vector_style") {}
-
-    };
-
-    // C++ wrapper for velocity_measure_with_unit
-    struct velocity_measure_with_unit : measure_with_unit, ObjectHelper<velocity_measure_with_unit,0> { velocity_measure_with_unit() : Object("velocity_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for velocity_unit
-    struct velocity_unit : derived_unit, ObjectHelper<velocity_unit,0> { velocity_unit() : Object("velocity_unit") {}
-
-    };
-
-    // C++ wrapper for vertex
-    struct vertex : topological_representation_item, ObjectHelper<vertex,0> { vertex() : Object("vertex") {}
-
-    };
-
-    // C++ wrapper for vertex_loop
-    struct vertex_loop : loop, ObjectHelper<vertex_loop,1> { vertex_loop() : Object("vertex_loop") {}
-		Lazy< vertex > loop_vertex;
-    };
-
-    // C++ wrapper for vertex_point
-    struct vertex_point :  ObjectHelper<vertex_point,1> { vertex_point() : Object("vertex_point") {}
-		Lazy< point > vertex_geometry;
-    };
-
-    // C++ wrapper for vertex_shell
-    struct vertex_shell : topological_representation_item, ObjectHelper<vertex_shell,1> { vertex_shell() : Object("vertex_shell") {}
-		Lazy< vertex_loop > vertex_shell_extent;
-    };
-
-    // C++ wrapper for view_volume
-    struct view_volume : founded_item, ObjectHelper<view_volume,9> { view_volume() : Object("view_volume") {}
-		central_or_parallel::Out projection_type;
-		Lazy< cartesian_point > projection_point;
-		length_measure::Out view_plane_distance;
-		length_measure::Out front_plane_distance;
-		BOOLEAN::Out front_plane_clipping;
-		length_measure::Out back_plane_distance;
-		BOOLEAN::Out back_plane_clipping;
-		BOOLEAN::Out view_volume_sides_clipping;
-		Lazy< planar_box > view_window;
-    };
-
-    // C++ wrapper for visual_appearance_representation
-    struct visual_appearance_representation : representation, ObjectHelper<visual_appearance_representation,0> { visual_appearance_representation() : Object("visual_appearance_representation") {}
-
-    };
-
-    // C++ wrapper for volume_measure_with_unit
-    struct volume_measure_with_unit : measure_with_unit, ObjectHelper<volume_measure_with_unit,0> { volume_measure_with_unit() : Object("volume_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for volume_unit
-    struct volume_unit : derived_unit, ObjectHelper<volume_unit,0> { volume_unit() : Object("volume_unit") {}
-
-    };
-
-    // C++ wrapper for week_of_year_and_day_date
-    struct week_of_year_and_day_date : date, ObjectHelper<week_of_year_and_day_date,2> { week_of_year_and_day_date() : Object("week_of_year_and_day_date") {}
-		week_in_year_number::Out week_component;
-		Maybe< day_in_week_number::Out > day_component;
-    };
-
-    // C++ wrapper for wire_shell
-    struct wire_shell : topological_representation_item, ObjectHelper<wire_shell,1> { wire_shell() : Object("wire_shell") {}
-		ListOf< Lazy< loop >, 1, 0 > wire_shell_extent;
-    };
-
-    // C++ wrapper for year_month
-    struct year_month : date, ObjectHelper<year_month,1> { year_month() : Object("year_month") {}
-		month_in_year_number::Out month_component;
-    };
-
-	void GetSchema(EXPRESS::ConversionSchema& out);
-
-} //! StepFile
-namespace STEP {
-
-	// ******************************************************************************
-	// Converter stubs
-	// ******************************************************************************
-	
-#define DECL_CONV_STUB(type) template <> size_t GenericFill<StepFile::type>(const STEP::DB& db, const EXPRESS::LIST& params, StepFile::type* in)
-	
-	DECL_CONV_STUB(measure_with_unit);
-	DECL_CONV_STUB(absorbed_dose_measure_with_unit);
-	DECL_CONV_STUB(derived_unit);
-	DECL_CONV_STUB(absorbed_dose_unit);
-	DECL_CONV_STUB(abstract_variable);
-	DECL_CONV_STUB(acceleration_measure_with_unit);
-	DECL_CONV_STUB(acceleration_unit);
-	DECL_CONV_STUB(action);
-	DECL_CONV_STUB(action_assignment);
-	DECL_CONV_STUB(action_method);
-	DECL_CONV_STUB(action_method_assignment);
-	DECL_CONV_STUB(action_method_relationship);
-	DECL_CONV_STUB(action_request_assignment);
-	DECL_CONV_STUB(address);
-	DECL_CONV_STUB(representation);
-	DECL_CONV_STUB(shape_representation);
-	DECL_CONV_STUB(advanced_brep_shape_representation);
-	DECL_CONV_STUB(face_surface);
-	DECL_CONV_STUB(advanced_face);
-	DECL_CONV_STUB(amount_of_substance_measure_with_unit);
-	DECL_CONV_STUB(named_unit);
-	DECL_CONV_STUB(amount_of_substance_unit);
-	DECL_CONV_STUB(angle_direction_reference);
-	DECL_CONV_STUB(representation_item);
-	DECL_CONV_STUB(geometric_representation_item);
-	DECL_CONV_STUB(draughting_callout);
-	DECL_CONV_STUB(dimension_curve_directed_callout);
-	DECL_CONV_STUB(angular_dimension);
-	DECL_CONV_STUB(shape_aspect_relationship);
-	DECL_CONV_STUB(dimensional_location);
-	DECL_CONV_STUB(angular_location);
-	DECL_CONV_STUB(dimensional_size);
-	DECL_CONV_STUB(angular_size);
-	DECL_CONV_STUB(geometric_tolerance);
-	DECL_CONV_STUB(geometric_tolerance_with_datum_reference);
-	DECL_CONV_STUB(angularity_tolerance);
-	DECL_CONV_STUB(styled_item);
-	DECL_CONV_STUB(annotation_occurrence);
-	DECL_CONV_STUB(annotation_curve_occurrence);
-	DECL_CONV_STUB(annotation_fill_area);
-	DECL_CONV_STUB(annotation_fill_area_occurrence);
-	DECL_CONV_STUB(annotation_occurrence_relationship);
-	DECL_CONV_STUB(annotation_occurrence_associativity);
-	DECL_CONV_STUB(annotation_plane);
-	DECL_CONV_STUB(annotation_symbol_occurrence);
-	DECL_CONV_STUB(annotation_subfigure_occurrence);
-	DECL_CONV_STUB(mapped_item);
-	DECL_CONV_STUB(annotation_symbol);
-	DECL_CONV_STUB(annotation_text);
-	DECL_CONV_STUB(annotation_text_character);
-	DECL_CONV_STUB(annotation_text_occurrence);
-	DECL_CONV_STUB(shape_aspect);
-	DECL_CONV_STUB(derived_shape_aspect);
-	DECL_CONV_STUB(apex);
-	DECL_CONV_STUB(application_context_element);
-	DECL_CONV_STUB(applied_action_assignment);
-	DECL_CONV_STUB(applied_action_method_assignment);
-	DECL_CONV_STUB(applied_action_request_assignment);
-	DECL_CONV_STUB(approval_assignment);
-	DECL_CONV_STUB(applied_approval_assignment);
-	DECL_CONV_STUB(attribute_classification_assignment);
-	DECL_CONV_STUB(applied_attribute_classification_assignment);
-	DECL_CONV_STUB(certification_assignment);
-	DECL_CONV_STUB(applied_certification_assignment);
-	DECL_CONV_STUB(classification_assignment);
-	DECL_CONV_STUB(applied_classification_assignment);
-	DECL_CONV_STUB(contract_assignment);
-	DECL_CONV_STUB(applied_contract_assignment);
-	DECL_CONV_STUB(date_and_time_assignment);
-	DECL_CONV_STUB(applied_date_and_time_assignment);
-	DECL_CONV_STUB(date_assignment);
-	DECL_CONV_STUB(applied_date_assignment);
-	DECL_CONV_STUB(document_reference);
-	DECL_CONV_STUB(applied_document_reference);
-	DECL_CONV_STUB(document_usage_constraint_assignment);
-	DECL_CONV_STUB(applied_document_usage_constraint_assignment);
-	DECL_CONV_STUB(effectivity_assignment);
-	DECL_CONV_STUB(applied_effectivity_assignment);
-	DECL_CONV_STUB(event_occurrence_assignment);
-	DECL_CONV_STUB(applied_event_occurrence_assignment);
-	DECL_CONV_STUB(identification_assignment);
-	DECL_CONV_STUB(external_identification_assignment);
-	DECL_CONV_STUB(applied_external_identification_assignment);
-	DECL_CONV_STUB(group_assignment);
-	DECL_CONV_STUB(applied_group_assignment);
-	DECL_CONV_STUB(applied_identification_assignment);
-	DECL_CONV_STUB(name_assignment);
-	DECL_CONV_STUB(applied_name_assignment);
-	DECL_CONV_STUB(organization_assignment);
-	DECL_CONV_STUB(applied_organization_assignment);
-	DECL_CONV_STUB(organizational_project_assignment);
-	DECL_CONV_STUB(applied_organizational_project_assignment);
-	DECL_CONV_STUB(person_and_organization_assignment);
-	DECL_CONV_STUB(applied_person_and_organization_assignment);
-	DECL_CONV_STUB(presented_item);
-	DECL_CONV_STUB(applied_presented_item);
-	DECL_CONV_STUB(security_classification_assignment);
-	DECL_CONV_STUB(applied_security_classification_assignment);
-	DECL_CONV_STUB(time_interval_assignment);
-	DECL_CONV_STUB(applied_time_interval_assignment);
-	DECL_CONV_STUB(applied_usage_right);
-	DECL_CONV_STUB(area_in_set);
-	DECL_CONV_STUB(area_measure_with_unit);
-	DECL_CONV_STUB(area_unit);
-	DECL_CONV_STUB(product_definition_relationship);
-	DECL_CONV_STUB(product_definition_usage);
-	DECL_CONV_STUB(assembly_component_usage);
-	DECL_CONV_STUB(assigned_requirement);
-	DECL_CONV_STUB(compound_representation_item);
-	DECL_CONV_STUB(atomic_formula);
-	DECL_CONV_STUB(attribute_assertion);
-	DECL_CONV_STUB(attribute_language_assignment);
-	DECL_CONV_STUB(attribute_value_assignment);
-	DECL_CONV_STUB(auxiliary_geometric_representation_item);
-	DECL_CONV_STUB(placement);
-	DECL_CONV_STUB(axis1_placement);
-	DECL_CONV_STUB(axis2_placement_2d);
-	DECL_CONV_STUB(axis2_placement_3d);
-	DECL_CONV_STUB(curve);
-	DECL_CONV_STUB(bounded_curve);
-	DECL_CONV_STUB(b_spline_curve);
-	DECL_CONV_STUB(b_spline_curve_with_knots);
-	DECL_CONV_STUB(surface);
-	DECL_CONV_STUB(bounded_surface);
-	DECL_CONV_STUB(b_spline_surface);
-	DECL_CONV_STUB(b_spline_surface_with_knots);
-	DECL_CONV_STUB(product_definition);
-	DECL_CONV_STUB(rule_software_definition);
-	DECL_CONV_STUB(rule_definition);
-	DECL_CONV_STUB(back_chaining_rule);
-	DECL_CONV_STUB(back_chaining_rule_body);
-	DECL_CONV_STUB(colour);
-	DECL_CONV_STUB(background_colour);
-	DECL_CONV_STUB(beveled_sheet_representation);
-	DECL_CONV_STUB(bezier_curve);
-	DECL_CONV_STUB(bezier_surface);
-	DECL_CONV_STUB(generic_expression);
-	DECL_CONV_STUB(binary_generic_expression);
-	DECL_CONV_STUB(binary_numeric_expression);
-	DECL_CONV_STUB(binary_representation_item);
-	DECL_CONV_STUB(block);
-	DECL_CONV_STUB(expression);
-	DECL_CONV_STUB(boolean_expression);
-	DECL_CONV_STUB(boolean_literal);
-	DECL_CONV_STUB(boolean_representation_item);
-	DECL_CONV_STUB(boolean_result);
-	DECL_CONV_STUB(composite_curve);
-	DECL_CONV_STUB(composite_curve_on_surface);
-	DECL_CONV_STUB(boundary_curve);
-	DECL_CONV_STUB(bounded_pcurve);
-	DECL_CONV_STUB(bounded_surface_curve);
-	DECL_CONV_STUB(founded_item);
-	DECL_CONV_STUB(box_domain);
-	DECL_CONV_STUB(half_space_solid);
-	DECL_CONV_STUB(boxed_half_space);
-	DECL_CONV_STUB(breakdown_context);
-	DECL_CONV_STUB(breakdown_element_group_assignment);
-	DECL_CONV_STUB(breakdown_element_realization);
-	DECL_CONV_STUB(breakdown_element_usage);
-	DECL_CONV_STUB(breakdown_of);
-	DECL_CONV_STUB(solid_model);
-	DECL_CONV_STUB(manifold_solid_brep);
-	DECL_CONV_STUB(brep_with_voids);
-	DECL_CONV_STUB(bytes_representation_item);
-	DECL_CONV_STUB(date);
-	DECL_CONV_STUB(calendar_date);
-	DECL_CONV_STUB(camera_image);
-	DECL_CONV_STUB(camera_image_3d_with_scale);
-	DECL_CONV_STUB(camera_model);
-	DECL_CONV_STUB(camera_model_d3);
-	DECL_CONV_STUB(camera_model_d3_multi_clipping);
-	DECL_CONV_STUB(camera_model_d3_multi_clipping_intersection);
-	DECL_CONV_STUB(camera_model_d3_multi_clipping_union);
-	DECL_CONV_STUB(camera_model_d3_with_hlhsr);
-	DECL_CONV_STUB(camera_model_with_light_sources);
-	DECL_CONV_STUB(representation_map);
-	DECL_CONV_STUB(camera_usage);
-	DECL_CONV_STUB(capacitance_measure_with_unit);
-	DECL_CONV_STUB(capacitance_unit);
-	DECL_CONV_STUB(point);
-	DECL_CONV_STUB(cartesian_point);
-	DECL_CONV_STUB(cartesian_transformation_operator);
-	DECL_CONV_STUB(cartesian_transformation_operator_2d);
-	DECL_CONV_STUB(cartesian_transformation_operator_3d);
-	DECL_CONV_STUB(cc_design_approval);
-	DECL_CONV_STUB(cc_design_certification);
-	DECL_CONV_STUB(cc_design_contract);
-	DECL_CONV_STUB(cc_design_date_and_time_assignment);
-	DECL_CONV_STUB(cc_design_person_and_organization_assignment);
-	DECL_CONV_STUB(cc_design_security_classification);
-	DECL_CONV_STUB(cc_design_specification_reference);
-	DECL_CONV_STUB(celsius_temperature_measure_with_unit);
-	DECL_CONV_STUB(centre_of_symmetry);
-	DECL_CONV_STUB(change);
-	DECL_CONV_STUB(change_request);
-	DECL_CONV_STUB(character_glyph_style_outline);
-	DECL_CONV_STUB(character_glyph_style_stroke);
-	DECL_CONV_STUB(symbol_representation);
-	DECL_CONV_STUB(generic_character_glyph_symbol);
-	DECL_CONV_STUB(character_glyph_symbol);
-	DECL_CONV_STUB(character_glyph_symbol_outline);
-	DECL_CONV_STUB(character_glyph_symbol_stroke);
-	DECL_CONV_STUB(general_property);
-	DECL_CONV_STUB(characteristic_data_column_header);
-	DECL_CONV_STUB(general_property_relationship);
-	DECL_CONV_STUB(characteristic_data_column_header_link);
-	DECL_CONV_STUB(characteristic_data_table_header);
-	DECL_CONV_STUB(characteristic_data_table_header_decomposition);
-	DECL_CONV_STUB(group);
-	DECL_CONV_STUB(characteristic_type);
-	DECL_CONV_STUB(characterized_class);
-	DECL_CONV_STUB(characterized_object);
-	DECL_CONV_STUB(conic);
-	DECL_CONV_STUB(circle);
-	DECL_CONV_STUB(circular_runout_tolerance);
-	DECL_CONV_STUB(class_by_extension);
-	DECL_CONV_STUB(class_by_intension);
-	DECL_CONV_STUB(class_system);
-	DECL_CONV_STUB(effectivity_context_assignment);
-	DECL_CONV_STUB(class_usage_effectivity_context_assignment);
-	DECL_CONV_STUB(topological_representation_item);
-	DECL_CONV_STUB(connected_face_set);
-	DECL_CONV_STUB(closed_shell);
-	DECL_CONV_STUB(coaxiality_tolerance);
-	DECL_CONV_STUB(colour_specification);
-	DECL_CONV_STUB(colour_rgb);
-	DECL_CONV_STUB(common_datum);
-	DECL_CONV_STUB(comparison_expression);
-	DECL_CONV_STUB(complex_clause);
-	DECL_CONV_STUB(complex_conjunctive_clause);
-	DECL_CONV_STUB(complex_disjunctive_clause);
-	DECL_CONV_STUB(modified_solid);
-	DECL_CONV_STUB(shelled_solid);
-	DECL_CONV_STUB(complex_shelled_solid);
-	DECL_CONV_STUB(composite_assembly_definition);
-	DECL_CONV_STUB(composite_assembly_sequence_definition);
-	DECL_CONV_STUB(laminate_table);
-	DECL_CONV_STUB(part_laminate_table);
-	DECL_CONV_STUB(composite_assembly_table);
-	DECL_CONV_STUB(composite_curve_segment);
-	DECL_CONV_STUB(material_designation);
-	DECL_CONV_STUB(composite_material_designation);
-	DECL_CONV_STUB(composite_shape_aspect);
-	DECL_CONV_STUB(composite_sheet_representation);
-	DECL_CONV_STUB(composite_text);
-	DECL_CONV_STUB(composite_text_with_associated_curves);
-	DECL_CONV_STUB(composite_text_with_blanking_box);
-	DECL_CONV_STUB(composite_text_with_delineation);
-	DECL_CONV_STUB(composite_text_with_extent);
-	DECL_CONV_STUB(compound_shape_representation);
-	DECL_CONV_STUB(concentricity_tolerance);
-	DECL_CONV_STUB(concept_feature_relationship);
-	DECL_CONV_STUB(concept_feature_relationship_with_condition);
-	DECL_CONV_STUB(product_concept_feature);
-	DECL_CONV_STUB(conditional_concept_feature);
-	DECL_CONV_STUB(conductance_measure_with_unit);
-	DECL_CONV_STUB(conductance_unit);
-	DECL_CONV_STUB(configuration_item);
-	DECL_CONV_STUB(configurable_item);
-	DECL_CONV_STUB(effectivity);
-	DECL_CONV_STUB(product_definition_effectivity);
-	DECL_CONV_STUB(configuration_effectivity);
-	DECL_CONV_STUB(configuration_item_relationship);
-	DECL_CONV_STUB(configuration_item_hierarchical_relationship);
-	DECL_CONV_STUB(configuration_item_revision_sequence);
-	DECL_CONV_STUB(configured_effectivity_assignment);
-	DECL_CONV_STUB(configured_effectivity_context_assignment);
-	DECL_CONV_STUB(conical_stepped_hole_transition);
-	DECL_CONV_STUB(elementary_surface);
-	DECL_CONV_STUB(conical_surface);
-	DECL_CONV_STUB(connected_edge_set);
-	DECL_CONV_STUB(connected_face_sub_set);
-	DECL_CONV_STUB(constructive_geometry_representation);
-	DECL_CONV_STUB(representation_relationship);
-	DECL_CONV_STUB(constructive_geometry_representation_relationship);
-	DECL_CONV_STUB(contact_ratio_representation);
-	DECL_CONV_STUB(invisibility);
-	DECL_CONV_STUB(context_dependent_invisibility);
-	DECL_CONV_STUB(over_riding_styled_item);
-	DECL_CONV_STUB(context_dependent_over_riding_styled_item);
-	DECL_CONV_STUB(context_dependent_unit);
-	DECL_CONV_STUB(conversion_based_unit);
-	DECL_CONV_STUB(csg_shape_representation);
-	DECL_CONV_STUB(csg_solid);
-	DECL_CONV_STUB(currency);
-	DECL_CONV_STUB(currency_measure_with_unit);
-	DECL_CONV_STUB(curve_bounded_surface);
-	DECL_CONV_STUB(curve_dimension);
-	DECL_CONV_STUB(curve_replica);
-	DECL_CONV_STUB(curve_style);
-	DECL_CONV_STUB(curve_style_font);
-	DECL_CONV_STUB(curve_style_font_and_scaling);
-	DECL_CONV_STUB(curve_style_font_pattern);
-	DECL_CONV_STUB(curve_swept_solid_shape_representation);
-	DECL_CONV_STUB(cylindrical_surface);
-	DECL_CONV_STUB(cylindricity_tolerance);
-	DECL_CONV_STUB(date_representation_item);
-	DECL_CONV_STUB(date_time_representation_item);
-	DECL_CONV_STUB(dated_effectivity);
-	DECL_CONV_STUB(datum);
-	DECL_CONV_STUB(datum_feature);
-	DECL_CONV_STUB(datum_feature_callout);
-	DECL_CONV_STUB(datum_reference);
-	DECL_CONV_STUB(datum_target);
-	DECL_CONV_STUB(datum_target_callout);
-	DECL_CONV_STUB(default_tolerance_table);
-	DECL_CONV_STUB(default_tolerance_table_cell);
-	DECL_CONV_STUB(defined_symbol);
-	DECL_CONV_STUB(definitional_representation);
-	DECL_CONV_STUB(definitional_representation_relationship);
-	DECL_CONV_STUB(definitional_representation_relationship_with_same_context);
-	DECL_CONV_STUB(degenerate_pcurve);
-	DECL_CONV_STUB(toroidal_surface);
-	DECL_CONV_STUB(degenerate_toroidal_surface);
-	DECL_CONV_STUB(descriptive_representation_item);
-	DECL_CONV_STUB(product_definition_context);
-	DECL_CONV_STUB(design_context);
-	DECL_CONV_STUB(design_make_from_relationship);
-	DECL_CONV_STUB(diameter_dimension);
-	DECL_CONV_STUB(ratio_measure_with_unit);
-	DECL_CONV_STUB(dielectric_constant_measure_with_unit);
-	DECL_CONV_STUB(dimension_callout);
-	DECL_CONV_STUB(draughting_callout_relationship);
-	DECL_CONV_STUB(dimension_callout_component_relationship);
-	DECL_CONV_STUB(dimension_callout_relationship);
-	DECL_CONV_STUB(dimension_curve);
-	DECL_CONV_STUB(terminator_symbol);
-	DECL_CONV_STUB(dimension_curve_terminator);
-	DECL_CONV_STUB(dimension_curve_terminator_to_projection_curve_associativity);
-	DECL_CONV_STUB(dimension_pair);
-	DECL_CONV_STUB(dimension_text_associativity);
-	DECL_CONV_STUB(dimensional_location_with_path);
-	DECL_CONV_STUB(dimensional_size_with_path);
-	DECL_CONV_STUB(executed_action);
-	DECL_CONV_STUB(directed_action);
-	DECL_CONV_STUB(directed_dimensional_location);
-	DECL_CONV_STUB(direction);
-	DECL_CONV_STUB(document_file);
-	DECL_CONV_STUB(document_identifier);
-	DECL_CONV_STUB(document_identifier_assignment);
-	DECL_CONV_STUB(document_product_association);
-	DECL_CONV_STUB(document_product_equivalence);
-	DECL_CONV_STUB(dose_equivalent_measure_with_unit);
-	DECL_CONV_STUB(dose_equivalent_unit);
-	DECL_CONV_STUB(double_offset_shelled_solid);
-	DECL_CONV_STUB(item_defined_transformation);
-	DECL_CONV_STUB(transformation_with_derived_angle);
-	DECL_CONV_STUB(draped_defined_transformation);
-	DECL_CONV_STUB(draughting_annotation_occurrence);
-	DECL_CONV_STUB(draughting_elements);
-	DECL_CONV_STUB(draughting_model);
-	DECL_CONV_STUB(item_identified_representation_usage);
-	DECL_CONV_STUB(draughting_model_item_association);
-	DECL_CONV_STUB(pre_defined_colour);
-	DECL_CONV_STUB(draughting_pre_defined_colour);
-	DECL_CONV_STUB(pre_defined_item);
-	DECL_CONV_STUB(pre_defined_curve_font);
-	DECL_CONV_STUB(draughting_pre_defined_curve_font);
-	DECL_CONV_STUB(pre_defined_text_font);
-	DECL_CONV_STUB(draughting_pre_defined_text_font);
-	DECL_CONV_STUB(draughting_subfigure_representation);
-	DECL_CONV_STUB(draughting_symbol_representation);
-	DECL_CONV_STUB(text_literal);
-	DECL_CONV_STUB(text_literal_with_delineation);
-	DECL_CONV_STUB(draughting_text_literal_with_delineation);
-	DECL_CONV_STUB(presentation_set);
-	DECL_CONV_STUB(drawing_revision);
-	DECL_CONV_STUB(presentation_representation);
-	DECL_CONV_STUB(presentation_area);
-	DECL_CONV_STUB(drawing_sheet_revision);
-	DECL_CONV_STUB(drawing_sheet_revision_sequence);
-	DECL_CONV_STUB(drawing_sheet_revision_usage);
-	DECL_CONV_STUB(edge);
-	DECL_CONV_STUB(edge_based_wireframe_model);
-	DECL_CONV_STUB(edge_based_wireframe_shape_representation);
-	DECL_CONV_STUB(edge_blended_solid);
-	DECL_CONV_STUB(edge_curve);
-	DECL_CONV_STUB(edge_loop);
-	DECL_CONV_STUB(electric_charge_measure_with_unit);
-	DECL_CONV_STUB(electric_charge_unit);
-	DECL_CONV_STUB(electric_current_measure_with_unit);
-	DECL_CONV_STUB(electric_current_unit);
-	DECL_CONV_STUB(electric_potential_measure_with_unit);
-	DECL_CONV_STUB(electric_potential_unit);
-	DECL_CONV_STUB(elementary_brep_shape_representation);
-	DECL_CONV_STUB(ellipse);
-	DECL_CONV_STUB(energy_measure_with_unit);
-	DECL_CONV_STUB(energy_unit);
-	DECL_CONV_STUB(property_definition);
-	DECL_CONV_STUB(fact_type);
-	DECL_CONV_STUB(entity_assertion);
-	DECL_CONV_STUB(enum_reference_prefix);
-	DECL_CONV_STUB(evaluated_characteristic);
-	DECL_CONV_STUB(evaluated_degenerate_pcurve);
-	DECL_CONV_STUB(evaluation_product_definition);
-	DECL_CONV_STUB(event_occurrence);
-	DECL_CONV_STUB(product_concept_feature_category);
-	DECL_CONV_STUB(exclusive_product_concept_feature_category);
-	DECL_CONV_STUB(uncertainty_qualifier);
-	DECL_CONV_STUB(standard_uncertainty);
-	DECL_CONV_STUB(expanded_uncertainty);
-	DECL_CONV_STUB(representation_item_relationship);
-	DECL_CONV_STUB(explicit_procedural_representation_item_relationship);
-	DECL_CONV_STUB(explicit_procedural_geometric_representation_item_relationship);
-	DECL_CONV_STUB(explicit_procedural_representation_relationship);
-	DECL_CONV_STUB(explicit_procedural_shape_representation_relationship);
-	DECL_CONV_STUB(expression_conversion_based_unit);
-	DECL_CONV_STUB(extension);
-	DECL_CONV_STUB(extent);
-	DECL_CONV_STUB(external_source);
-	DECL_CONV_STUB(external_class_library);
-	DECL_CONV_STUB(externally_defined_class);
-	DECL_CONV_STUB(externally_defined_colour);
-	DECL_CONV_STUB(externally_defined_context_dependent_unit);
-	DECL_CONV_STUB(externally_defined_conversion_based_unit);
-	DECL_CONV_STUB(externally_defined_currency);
-	DECL_CONV_STUB(externally_defined_item);
-	DECL_CONV_STUB(externally_defined_curve_font);
-	DECL_CONV_STUB(externally_defined_dimension_definition);
-	DECL_CONV_STUB(externally_defined_general_property);
-	DECL_CONV_STUB(externally_defined_hatch_style);
-	DECL_CONV_STUB(externally_defined_marker);
-	DECL_CONV_STUB(picture_representation_item);
-	DECL_CONV_STUB(externally_defined_picture_representation_item);
-	DECL_CONV_STUB(externally_defined_representation_item);
-	DECL_CONV_STUB(externally_defined_string);
-	DECL_CONV_STUB(externally_defined_symbol);
-	DECL_CONV_STUB(externally_defined_terminator_symbol);
-	DECL_CONV_STUB(externally_defined_text_font);
-	DECL_CONV_STUB(externally_defined_tile);
-	DECL_CONV_STUB(externally_defined_tile_style);
-	DECL_CONV_STUB(swept_area_solid);
-	DECL_CONV_STUB(extruded_area_solid);
-	DECL_CONV_STUB(swept_face_solid);
-	DECL_CONV_STUB(extruded_face_solid);
-	DECL_CONV_STUB(extruded_face_solid_with_trim_conditions);
-	DECL_CONV_STUB(extruded_face_solid_with_draft_angle);
-	DECL_CONV_STUB(extruded_face_solid_with_multiple_draft_angles);
-	DECL_CONV_STUB(face);
-	DECL_CONV_STUB(face_based_surface_model);
-	DECL_CONV_STUB(face_bound);
-	DECL_CONV_STUB(face_outer_bound);
-	DECL_CONV_STUB(faceted_brep);
-	DECL_CONV_STUB(faceted_brep_shape_representation);
-	DECL_CONV_STUB(fill_area_style);
-	DECL_CONV_STUB(fill_area_style_hatching);
-	DECL_CONV_STUB(fill_area_style_tile_coloured_region);
-	DECL_CONV_STUB(fill_area_style_tile_curve_with_style);
-	DECL_CONV_STUB(fill_area_style_tile_symbol_with_style);
-	DECL_CONV_STUB(fill_area_style_tiles);
-	DECL_CONV_STUB(shape_representation_relationship);
-	DECL_CONV_STUB(flat_pattern_ply_representation_relationship);
-	DECL_CONV_STUB(flatness_tolerance);
-	DECL_CONV_STUB(force_measure_with_unit);
-	DECL_CONV_STUB(force_unit);
-	DECL_CONV_STUB(forward_chaining_rule);
-	DECL_CONV_STUB(forward_chaining_rule_premise);
-	DECL_CONV_STUB(frequency_measure_with_unit);
-	DECL_CONV_STUB(frequency_unit);
-	DECL_CONV_STUB(func);
-	DECL_CONV_STUB(functional_breakdown_context);
-	DECL_CONV_STUB(functional_element_usage);
-	DECL_CONV_STUB(general_material_property);
-	DECL_CONV_STUB(simple_generic_expression);
-	DECL_CONV_STUB(generic_literal);
-	DECL_CONV_STUB(generic_variable);
-	DECL_CONV_STUB(geometric_alignment);
-	DECL_CONV_STUB(geometric_set);
-	DECL_CONV_STUB(geometric_curve_set);
-	DECL_CONV_STUB(geometric_intersection);
-	DECL_CONV_STUB(geometric_item_specific_usage);
-	DECL_CONV_STUB(geometric_model_element_relationship);
-	DECL_CONV_STUB(representation_context);
-	DECL_CONV_STUB(geometric_representation_context);
-	DECL_CONV_STUB(geometric_tolerance_with_defined_unit);
-	DECL_CONV_STUB(geometrical_tolerance_callout);
-	DECL_CONV_STUB(geometrically_bounded_2d_wireframe_representation);
-	DECL_CONV_STUB(geometrically_bounded_surface_shape_representation);
-	DECL_CONV_STUB(geometrically_bounded_wireframe_shape_representation);
-	DECL_CONV_STUB(global_assignment);
-	DECL_CONV_STUB(global_uncertainty_assigned_context);
-	DECL_CONV_STUB(global_unit_assigned_context);
-	DECL_CONV_STUB(ground_fact);
-	DECL_CONV_STUB(hardness_representation);
-	DECL_CONV_STUB(hidden_element_over_riding_styled_item);
-	DECL_CONV_STUB(hyperbola);
-	DECL_CONV_STUB(illuminance_measure_with_unit);
-	DECL_CONV_STUB(illuminance_unit);
-	DECL_CONV_STUB(included_text_block);
-	DECL_CONV_STUB(inclusion_product_concept_feature);
-	DECL_CONV_STUB(user_selected_elements);
-	DECL_CONV_STUB(indirectly_selected_elements);
-	DECL_CONV_STUB(indirectly_selected_shape_elements);
-	DECL_CONV_STUB(inductance_measure_with_unit);
-	DECL_CONV_STUB(inductance_unit);
-	DECL_CONV_STUB(information_right);
-	DECL_CONV_STUB(information_usage_right);
-	DECL_CONV_STUB(instance_usage_context_assignment);
-	DECL_CONV_STUB(instanced_feature);
-	DECL_CONV_STUB(literal_number);
-	DECL_CONV_STUB(int_literal);
-	DECL_CONV_STUB(integer_representation_item);
-	DECL_CONV_STUB(surface_curve);
-	DECL_CONV_STUB(intersection_curve);
-	DECL_CONV_STUB(interval_expression);
-	DECL_CONV_STUB(iso4217_currency);
-	DECL_CONV_STUB(known_source);
-	DECL_CONV_STUB(laid_defined_transformation);
-	DECL_CONV_STUB(language);
-	DECL_CONV_STUB(leader_curve);
-	DECL_CONV_STUB(leader_directed_callout);
-	DECL_CONV_STUB(leader_directed_dimension);
-	DECL_CONV_STUB(leader_terminator);
-	DECL_CONV_STUB(length_measure_with_unit);
-	DECL_CONV_STUB(length_unit);
-	DECL_CONV_STUB(light_source);
-	DECL_CONV_STUB(light_source_ambient);
-	DECL_CONV_STUB(light_source_directional);
-	DECL_CONV_STUB(light_source_positional);
-	DECL_CONV_STUB(light_source_spot);
-	DECL_CONV_STUB(line);
-	DECL_CONV_STUB(line_profile_tolerance);
-	DECL_CONV_STUB(linear_dimension);
-	DECL_CONV_STUB(simple_clause);
-	DECL_CONV_STUB(literal_conjunction);
-	DECL_CONV_STUB(literal_disjunction);
-	DECL_CONV_STUB(logical_literal);
-	DECL_CONV_STUB(logical_representation_item);
-	DECL_CONV_STUB(loop);
-	DECL_CONV_STUB(loss_tangent_measure_with_unit);
-	DECL_CONV_STUB(lot_effectivity);
-	DECL_CONV_STUB(luminous_flux_measure_with_unit);
-	DECL_CONV_STUB(luminous_flux_unit);
-	DECL_CONV_STUB(luminous_intensity_measure_with_unit);
-	DECL_CONV_STUB(luminous_intensity_unit);
-	DECL_CONV_STUB(magnetic_flux_density_measure_with_unit);
-	DECL_CONV_STUB(magnetic_flux_density_unit);
-	DECL_CONV_STUB(magnetic_flux_measure_with_unit);
-	DECL_CONV_STUB(magnetic_flux_unit);
-	DECL_CONV_STUB(make_from_usage_option);
-	DECL_CONV_STUB(manifold_subsurface_shape_representation);
-	DECL_CONV_STUB(manifold_surface_shape_representation);
-	DECL_CONV_STUB(mass_measure_with_unit);
-	DECL_CONV_STUB(mass_unit);
-	DECL_CONV_STUB(material_property);
-	DECL_CONV_STUB(property_definition_representation);
-	DECL_CONV_STUB(material_property_representation);
-	DECL_CONV_STUB(measure_representation_item);
-	DECL_CONV_STUB(product_context);
-	DECL_CONV_STUB(mechanical_context);
-	DECL_CONV_STUB(mechanical_design_and_draughting_relationship);
-	DECL_CONV_STUB(mechanical_design_geometric_presentation_area);
-	DECL_CONV_STUB(mechanical_design_geometric_presentation_representation);
-	DECL_CONV_STUB(mechanical_design_presentation_representation_with_draughting);
-	DECL_CONV_STUB(mechanical_design_shaded_presentation_area);
-	DECL_CONV_STUB(mechanical_design_shaded_presentation_representation);
-	DECL_CONV_STUB(min_and_major_ply_orientation_basis);
-	DECL_CONV_STUB(modified_geometric_tolerance);
-	DECL_CONV_STUB(modified_solid_with_placed_configuration);
-	DECL_CONV_STUB(moments_of_inertia_representation);
-	DECL_CONV_STUB(multi_language_attribute_assignment);
-	DECL_CONV_STUB(multiple_arity_boolean_expression);
-	DECL_CONV_STUB(multiple_arity_generic_expression);
-	DECL_CONV_STUB(multiple_arity_numeric_expression);
-	DECL_CONV_STUB(next_assembly_usage_occurrence);
-	DECL_CONV_STUB(non_manifold_surface_shape_representation);
-	DECL_CONV_STUB(null_representation_item);
-	DECL_CONV_STUB(numeric_expression);
-	DECL_CONV_STUB(offset_curve_2d);
-	DECL_CONV_STUB(offset_curve_3d);
-	DECL_CONV_STUB(offset_surface);
-	DECL_CONV_STUB(one_direction_repeat_factor);
-	DECL_CONV_STUB(open_shell);
-	DECL_CONV_STUB(ordinal_date);
-	DECL_CONV_STUB(projection_directed_callout);
-	DECL_CONV_STUB(ordinate_dimension);
-	DECL_CONV_STUB(organizational_address);
-	DECL_CONV_STUB(oriented_closed_shell);
-	DECL_CONV_STUB(oriented_edge);
-	DECL_CONV_STUB(oriented_face);
-	DECL_CONV_STUB(oriented_open_shell);
-	DECL_CONV_STUB(path);
-	DECL_CONV_STUB(oriented_path);
-	DECL_CONV_STUB(oriented_surface);
-	DECL_CONV_STUB(outer_boundary_curve);
-	DECL_CONV_STUB(package_product_concept_feature);
-	DECL_CONV_STUB(parabola);
-	DECL_CONV_STUB(parallel_offset);
-	DECL_CONV_STUB(parallelism_tolerance);
-	DECL_CONV_STUB(parametric_representation_context);
-	DECL_CONV_STUB(partial_document_with_structured_text_representation_assignment);
-	DECL_CONV_STUB(pcurve);
-	DECL_CONV_STUB(percentage_laminate_definition);
-	DECL_CONV_STUB(zone_structural_makeup);
-	DECL_CONV_STUB(percentage_laminate_table);
-	DECL_CONV_STUB(percentage_ply_definition);
-	DECL_CONV_STUB(perpendicular_to);
-	DECL_CONV_STUB(perpendicularity_tolerance);
-	DECL_CONV_STUB(person_and_organization_address);
-	DECL_CONV_STUB(personal_address);
-	DECL_CONV_STUB(physical_breakdown_context);
-	DECL_CONV_STUB(physical_element_usage);
-	DECL_CONV_STUB(presentation_view);
-	DECL_CONV_STUB(picture_representation);
-	DECL_CONV_STUB(placed_datum_target_feature);
-	DECL_CONV_STUB(placed_feature);
-	DECL_CONV_STUB(planar_extent);
-	DECL_CONV_STUB(planar_box);
-	DECL_CONV_STUB(plane);
-	DECL_CONV_STUB(plane_angle_measure_with_unit);
-	DECL_CONV_STUB(plane_angle_unit);
-	DECL_CONV_STUB(ply_laminate_definition);
-	DECL_CONV_STUB(ply_laminate_sequence_definition);
-	DECL_CONV_STUB(ply_laminate_table);
-	DECL_CONV_STUB(point_and_vector);
-	DECL_CONV_STUB(point_on_curve);
-	DECL_CONV_STUB(point_on_surface);
-	DECL_CONV_STUB(point_path);
-	DECL_CONV_STUB(point_replica);
-	DECL_CONV_STUB(point_style);
-	DECL_CONV_STUB(polar_complex_number_literal);
-	DECL_CONV_STUB(poly_loop);
-	DECL_CONV_STUB(polyline);
-	DECL_CONV_STUB(position_tolerance);
-	DECL_CONV_STUB(positioned_sketch);
-	DECL_CONV_STUB(power_measure_with_unit);
-	DECL_CONV_STUB(power_unit);
-	DECL_CONV_STUB(pre_defined_symbol);
-	DECL_CONV_STUB(pre_defined_dimension_symbol);
-	DECL_CONV_STUB(pre_defined_geometrical_tolerance_symbol);
-	DECL_CONV_STUB(pre_defined_marker);
-	DECL_CONV_STUB(pre_defined_point_marker_symbol);
-	DECL_CONV_STUB(pre_defined_surface_condition_symbol);
-	DECL_CONV_STUB(pre_defined_surface_side_style);
-	DECL_CONV_STUB(pre_defined_terminator_symbol);
-	DECL_CONV_STUB(pre_defined_tile);
-	DECL_CONV_STUB(predefined_picture_representation_item);
-	DECL_CONV_STUB(presentation_style_assignment);
-	DECL_CONV_STUB(presentation_style_by_context);
-	DECL_CONV_STUB(pressure_measure_with_unit);
-	DECL_CONV_STUB(pressure_unit);
-	DECL_CONV_STUB(procedural_representation);
-	DECL_CONV_STUB(procedural_representation_sequence);
-	DECL_CONV_STUB(procedural_shape_representation);
-	DECL_CONV_STUB(procedural_shape_representation_sequence);
-	DECL_CONV_STUB(product_category);
-	DECL_CONV_STUB(product_class);
-	DECL_CONV_STUB(product_concept_context);
-	DECL_CONV_STUB(product_concept_feature_category_usage);
-	DECL_CONV_STUB(product_definition_element_relationship);
-	DECL_CONV_STUB(product_definition_formation);
-	DECL_CONV_STUB(product_definition_formation_with_specified_source);
-	DECL_CONV_STUB(product_definition_group_assignment);
-	DECL_CONV_STUB(product_definition_shape);
-	DECL_CONV_STUB(product_definition_with_associated_documents);
-	DECL_CONV_STUB(product_identification);
-	DECL_CONV_STUB(product_material_composition_relationship);
-	DECL_CONV_STUB(product_related_product_category);
-	DECL_CONV_STUB(product_specification);
-	DECL_CONV_STUB(tolerance_zone_definition);
-	DECL_CONV_STUB(projected_zone_definition);
-	DECL_CONV_STUB(projection_curve);
-	DECL_CONV_STUB(promissory_usage_occurrence);
-	DECL_CONV_STUB(qualified_representation_item);
-	DECL_CONV_STUB(qualitative_uncertainty);
-	DECL_CONV_STUB(quantified_assembly_component_usage);
-	DECL_CONV_STUB(quasi_uniform_curve);
-	DECL_CONV_STUB(quasi_uniform_surface);
-	DECL_CONV_STUB(radioactivity_measure_with_unit);
-	DECL_CONV_STUB(radioactivity_unit);
-	DECL_CONV_STUB(radius_dimension);
-	DECL_CONV_STUB(range_characteristic);
-	DECL_CONV_STUB(ratio_unit);
-	DECL_CONV_STUB(rational_b_spline_curve);
-	DECL_CONV_STUB(rational_b_spline_surface);
-	DECL_CONV_STUB(rational_representation_item);
-	DECL_CONV_STUB(real_literal);
-	DECL_CONV_STUB(real_representation_item);
-	DECL_CONV_STUB(rectangular_composite_surface);
-	DECL_CONV_STUB(rectangular_trimmed_surface);
-	DECL_CONV_STUB(referenced_modified_datum);
-	DECL_CONV_STUB(relative_event_occurrence);
-	DECL_CONV_STUB(rep_item_group);
-	DECL_CONV_STUB(reparametrised_composite_curve_segment);
-	DECL_CONV_STUB(representation_relationship_with_transformation);
-	DECL_CONV_STUB(requirement_assigned_object);
-	DECL_CONV_STUB(requirement_assignment);
-	DECL_CONV_STUB(requirement_source);
-	DECL_CONV_STUB(requirement_view_definition_relationship);
-	DECL_CONV_STUB(resistance_measure_with_unit);
-	DECL_CONV_STUB(resistance_unit);
-	DECL_CONV_STUB(revolved_area_solid);
-	DECL_CONV_STUB(revolved_face_solid);
-	DECL_CONV_STUB(revolved_face_solid_with_trim_conditions);
-	DECL_CONV_STUB(right_angular_wedge);
-	DECL_CONV_STUB(right_circular_cone);
-	DECL_CONV_STUB(right_circular_cylinder);
-	DECL_CONV_STUB(right_to_usage_association);
-	DECL_CONV_STUB(roundness_tolerance);
-	DECL_CONV_STUB(row_representation_item);
-	DECL_CONV_STUB(row_value);
-	DECL_CONV_STUB(row_variable);
-	DECL_CONV_STUB(rule_action);
-	DECL_CONV_STUB(rule_condition);
-	DECL_CONV_STUB(rule_set);
-	DECL_CONV_STUB(rule_set_group);
-	DECL_CONV_STUB(rule_superseded_assignment);
-	DECL_CONV_STUB(rule_supersedence);
-	DECL_CONV_STUB(surface_curve_swept_area_solid);
-	DECL_CONV_STUB(ruled_surface_swept_area_solid);
-	DECL_CONV_STUB(runout_zone_definition);
-	DECL_CONV_STUB(runout_zone_orientation);
-	DECL_CONV_STUB(runout_zone_orientation_reference_direction);
-	DECL_CONV_STUB(satisfied_requirement);
-	DECL_CONV_STUB(satisfies_requirement);
-	DECL_CONV_STUB(satisfying_item);
-	DECL_CONV_STUB(scalar_variable);
-	DECL_CONV_STUB(scattering_parameter);
-	DECL_CONV_STUB(sculptured_solid);
-	DECL_CONV_STUB(seam_curve);
-	DECL_CONV_STUB(serial_numbered_effectivity);
-	DECL_CONV_STUB(shape_aspect_associativity);
-	DECL_CONV_STUB(shape_aspect_deriving_relationship);
-	DECL_CONV_STUB(shape_definition_representation);
-	DECL_CONV_STUB(shape_dimension_representation);
-	DECL_CONV_STUB(shape_feature_definition);
-	DECL_CONV_STUB(shape_representation_with_parameters);
-	DECL_CONV_STUB(shell_based_surface_model);
-	DECL_CONV_STUB(shell_based_wireframe_model);
-	DECL_CONV_STUB(shell_based_wireframe_shape_representation);
-	DECL_CONV_STUB(si_absorbed_dose_unit);
-	DECL_CONV_STUB(si_capacitance_unit);
-	DECL_CONV_STUB(si_conductance_unit);
-	DECL_CONV_STUB(si_dose_equivalent_unit);
-	DECL_CONV_STUB(si_electric_charge_unit);
-	DECL_CONV_STUB(si_electric_potential_unit);
-	DECL_CONV_STUB(si_energy_unit);
-	DECL_CONV_STUB(si_force_unit);
-	DECL_CONV_STUB(si_frequency_unit);
-	DECL_CONV_STUB(si_illuminance_unit);
-	DECL_CONV_STUB(si_inductance_unit);
-	DECL_CONV_STUB(si_magnetic_flux_density_unit);
-	DECL_CONV_STUB(si_magnetic_flux_unit);
-	DECL_CONV_STUB(si_power_unit);
-	DECL_CONV_STUB(si_pressure_unit);
-	DECL_CONV_STUB(si_radioactivity_unit);
-	DECL_CONV_STUB(si_resistance_unit);
-	DECL_CONV_STUB(si_unit);
-	DECL_CONV_STUB(simple_boolean_expression);
-	DECL_CONV_STUB(simple_numeric_expression);
-	DECL_CONV_STUB(slash_expression);
-	DECL_CONV_STUB(smeared_material_definition);
-	DECL_CONV_STUB(solid_angle_measure_with_unit);
-	DECL_CONV_STUB(solid_angle_unit);
-	DECL_CONV_STUB(solid_curve_font);
-	DECL_CONV_STUB(solid_replica);
-	DECL_CONV_STUB(solid_with_chamfered_edges);
-	DECL_CONV_STUB(solid_with_angle_based_chamfer);
-	DECL_CONV_STUB(solid_with_shape_element_pattern);
-	DECL_CONV_STUB(solid_with_circular_pattern);
-	DECL_CONV_STUB(solid_with_depression);
-	DECL_CONV_STUB(solid_with_pocket);
-	DECL_CONV_STUB(solid_with_circular_pocket);
-	DECL_CONV_STUB(solid_with_protrusion);
-	DECL_CONV_STUB(solid_with_circular_protrusion);
-	DECL_CONV_STUB(solid_with_hole);
-	DECL_CONV_STUB(solid_with_stepped_round_hole);
-	DECL_CONV_STUB(solid_with_conical_bottom_round_hole);
-	DECL_CONV_STUB(solid_with_constant_radius_edge_blend);
-	DECL_CONV_STUB(solid_with_slot);
-	DECL_CONV_STUB(solid_with_curved_slot);
-	DECL_CONV_STUB(solid_with_double_offset_chamfer);
-	DECL_CONV_STUB(solid_with_flat_bottom_round_hole);
-	DECL_CONV_STUB(solid_with_general_pocket);
-	DECL_CONV_STUB(solid_with_general_protrusion);
-	DECL_CONV_STUB(solid_with_groove);
-	DECL_CONV_STUB(solid_with_incomplete_circular_pattern);
-	DECL_CONV_STUB(solid_with_rectangular_pattern);
-	DECL_CONV_STUB(solid_with_incomplete_rectangular_pattern);
-	DECL_CONV_STUB(solid_with_rectangular_pocket);
-	DECL_CONV_STUB(solid_with_rectangular_protrusion);
-	DECL_CONV_STUB(solid_with_single_offset_chamfer);
-	DECL_CONV_STUB(solid_with_spherical_bottom_round_hole);
-	DECL_CONV_STUB(solid_with_stepped_round_hole_and_conical_transitions);
-	DECL_CONV_STUB(solid_with_straight_slot);
-	DECL_CONV_STUB(solid_with_tee_section_slot);
-	DECL_CONV_STUB(solid_with_through_depression);
-	DECL_CONV_STUB(solid_with_trapezoidal_section_slot);
-	DECL_CONV_STUB(solid_with_variable_radius_edge_blend);
-	DECL_CONV_STUB(source_for_requirement);
-	DECL_CONV_STUB(sourced_requirement);
-	DECL_CONV_STUB(specification_definition);
-	DECL_CONV_STUB(specified_higher_usage_occurrence);
-	DECL_CONV_STUB(sphere);
-	DECL_CONV_STUB(spherical_surface);
-	DECL_CONV_STUB(start_request);
-	DECL_CONV_STUB(start_work);
-	DECL_CONV_STUB(straightness_tolerance);
-	DECL_CONV_STUB(structured_dimension_callout);
-	DECL_CONV_STUB(structured_text_composition);
-	DECL_CONV_STUB(structured_text_representation);
-	DECL_CONV_STUB(subedge);
-	DECL_CONV_STUB(subface);
-	DECL_CONV_STUB(supplied_part_relationship);
-	DECL_CONV_STUB(surface_condition_callout);
-	DECL_CONV_STUB(swept_surface);
-	DECL_CONV_STUB(surface_of_linear_extrusion);
-	DECL_CONV_STUB(surface_of_revolution);
-	DECL_CONV_STUB(surface_patch);
-	DECL_CONV_STUB(surface_profile_tolerance);
-	DECL_CONV_STUB(surface_replica);
-	DECL_CONV_STUB(surface_side_style);
-	DECL_CONV_STUB(surface_style_boundary);
-	DECL_CONV_STUB(surface_style_control_grid);
-	DECL_CONV_STUB(surface_style_fill_area);
-	DECL_CONV_STUB(surface_style_parameter_line);
-	DECL_CONV_STUB(surface_style_reflectance_ambient);
-	DECL_CONV_STUB(surface_style_reflectance_ambient_diffuse);
-	DECL_CONV_STUB(surface_style_reflectance_ambient_diffuse_specular);
-	DECL_CONV_STUB(surface_style_rendering);
-	DECL_CONV_STUB(surface_style_rendering_with_properties);
-	DECL_CONV_STUB(surface_style_segmentation_curve);
-	DECL_CONV_STUB(surface_style_silhouette);
-	DECL_CONV_STUB(surface_style_usage);
-	DECL_CONV_STUB(surface_texture_representation);
-	DECL_CONV_STUB(surfaced_open_shell);
-	DECL_CONV_STUB(swept_disk_solid);
-	DECL_CONV_STUB(symbol);
-	DECL_CONV_STUB(symbol_representation_map);
-	DECL_CONV_STUB(symbol_style);
-	DECL_CONV_STUB(symbol_target);
-	DECL_CONV_STUB(symmetric_shape_aspect);
-	DECL_CONV_STUB(symmetry_tolerance);
-	DECL_CONV_STUB(table_representation_item);
-	DECL_CONV_STUB(tactile_appearance_representation);
-	DECL_CONV_STUB(tagged_text_format);
-	DECL_CONV_STUB(tagged_text_item);
-	DECL_CONV_STUB(tangent);
-	DECL_CONV_STUB(text_literal_with_associated_curves);
-	DECL_CONV_STUB(text_literal_with_blanking_box);
-	DECL_CONV_STUB(text_literal_with_extent);
-	DECL_CONV_STUB(text_string_representation);
-	DECL_CONV_STUB(text_style);
-	DECL_CONV_STUB(text_style_with_box_characteristics);
-	DECL_CONV_STUB(text_style_with_mirror);
-	DECL_CONV_STUB(text_style_with_spacing);
-	DECL_CONV_STUB(thermal_resistance_measure_with_unit);
-	DECL_CONV_STUB(thermal_resistance_unit);
-	DECL_CONV_STUB(thermodynamic_temperature_measure_with_unit);
-	DECL_CONV_STUB(thermodynamic_temperature_unit);
-	DECL_CONV_STUB(thickened_face_solid);
-	DECL_CONV_STUB(thickness_laminate_definition);
-	DECL_CONV_STUB(thickness_laminate_table);
-	DECL_CONV_STUB(time_interval);
-	DECL_CONV_STUB(time_interval_based_effectivity);
-	DECL_CONV_STUB(time_interval_with_bounds);
-	DECL_CONV_STUB(time_measure_with_unit);
-	DECL_CONV_STUB(time_unit);
-	DECL_CONV_STUB(tolerance_zone);
-	DECL_CONV_STUB(torus);
-	DECL_CONV_STUB(total_runout_tolerance);
-	DECL_CONV_STUB(track_blended_solid);
-	DECL_CONV_STUB(track_blended_solid_with_end_conditions);
-	DECL_CONV_STUB(trimmed_curve);
-	DECL_CONV_STUB(two_direction_repeat_factor);
-	DECL_CONV_STUB(unary_generic_expression);
-	DECL_CONV_STUB(unary_numeric_expression);
-	DECL_CONV_STUB(uncertainty_assigned_representation);
-	DECL_CONV_STUB(uncertainty_measure_with_unit);
-	DECL_CONV_STUB(uniform_curve);
-	DECL_CONV_STUB(uniform_resource_identifier);
-	DECL_CONV_STUB(uniform_surface);
-	DECL_CONV_STUB(usage_association);
-	DECL_CONV_STUB(user_defined_curve_font);
-	DECL_CONV_STUB(user_defined_marker);
-	DECL_CONV_STUB(user_defined_terminator_symbol);
-	DECL_CONV_STUB(user_selected_shape_elements);
-	DECL_CONV_STUB(value_range);
-	DECL_CONV_STUB(value_representation_item);
-	DECL_CONV_STUB(variable_semantics);
-	DECL_CONV_STUB(variational_representation_item);
-	DECL_CONV_STUB(vector);
-	DECL_CONV_STUB(vector_style);
-	DECL_CONV_STUB(velocity_measure_with_unit);
-	DECL_CONV_STUB(velocity_unit);
-	DECL_CONV_STUB(vertex);
-	DECL_CONV_STUB(vertex_loop);
-	DECL_CONV_STUB(vertex_point);
-	DECL_CONV_STUB(vertex_shell);
-	DECL_CONV_STUB(view_volume);
-	DECL_CONV_STUB(visual_appearance_representation);
-	DECL_CONV_STUB(volume_measure_with_unit);
-	DECL_CONV_STUB(volume_unit);
-	DECL_CONV_STUB(week_of_year_and_day_date);
-	DECL_CONV_STUB(wire_shell);
-	DECL_CONV_STUB(year_month);
-
-
-#undef DECL_CONV_STUB
-
-} //! STEP
-} //! Assimp
-
-#endif // INCLUDED_STEPFILE_READER_GEN_H
diff --git a/Engine/lib/assimp/code/Irr/IRRLoader.cpp b/Engine/lib/assimp/code/Irr/IRRLoader.cpp
deleted file mode 100644
index e94fd85a4..000000000
--- a/Engine/lib/assimp/code/Irr/IRRLoader.cpp
+++ /dev/null
@@ -1,1488 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-/** @file  IRRLoader.cpp
- *  @brief Implementation of the Irr importer class
- */
-
-
-
-#ifndef ASSIMP_BUILD_NO_IRR_IMPORTER
-
-#include "Irr/IRRLoader.h"
-#include "Common/Importer.h"
-
-#include <assimp/ParsingUtils.h>
-#include <assimp/fast_atof.h>
-#include <assimp/GenericProperty.h>
-#include <assimp/SceneCombiner.h>
-#include <assimp/StandardShapes.h>
-#include <assimp/MathFunctions.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/mesh.h>
-#include <assimp/material.h>
-#include <assimp/scene.h>
-#include <assimp/IOSystem.hpp>
-#include <assimp/postprocess.h>
-#include <assimp/importerdesc.h>
-
-#include <memory>
-
-using namespace Assimp;
-using namespace irr;
-using namespace irr::io;
-
-static const aiImporterDesc desc = {
-    "Irrlicht Scene Reader",
-    "",
-    "",
-    "http://irrlicht.sourceforge.net/",
-    aiImporterFlags_SupportTextFlavour,
-    0,
-    0,
-    0,
-    0,
-    "irr xml"
-};
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-IRRImporter::IRRImporter()
-: fps()
-, configSpeedFlag(){
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-IRRImporter::~IRRImporter() {
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the class can handle the format of the given file.
-bool IRRImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const {
-    const std::string extension = GetExtension(pFile);
-    if ( extension == "irr" ) {
-        return true;
-    } else if (extension == "xml" || checkSig) {
-        /*  If CanRead() is called in order to check whether we
-         *  support a specific file extension in general pIOHandler
-         *  might be nullptr and it's our duty to return true here.
-         */
-        if (nullptr == pIOHandler ) {
-            return true;
-        }
-        const char* tokens[] = {"irr_scene"};
-        return SearchFileHeaderForToken(pIOHandler,pFile,tokens,1);
-    }
-
-    return false;
-}
-
-// ------------------------------------------------------------------------------------------------
-const aiImporterDesc* IRRImporter::GetInfo () const
-{
-    return &desc;
-}
-
-// ------------------------------------------------------------------------------------------------
-void IRRImporter::SetupProperties(const Importer* pImp)
-{
-    // read the output frame rate of all node animation channels
-    fps = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_IRR_ANIM_FPS,100);
-    if (fps < 10.)  {
-        ASSIMP_LOG_ERROR("IRR: Invalid FPS configuration");
-        fps = 100;
-    }
-
-    // AI_CONFIG_FAVOUR_SPEED
-    configSpeedFlag = (0 != pImp->GetPropertyInteger(AI_CONFIG_FAVOUR_SPEED,0));
-}
-
-// ------------------------------------------------------------------------------------------------
-// Build a mesh tha consists of a single squad (a side of a skybox)
-aiMesh* IRRImporter::BuildSingleQuadMesh(const SkyboxVertex& v1,
-    const SkyboxVertex& v2,
-    const SkyboxVertex& v3,
-    const SkyboxVertex& v4)
-{
-    // allocate and prepare the mesh
-    aiMesh* out = new aiMesh();
-
-    out->mPrimitiveTypes = aiPrimitiveType_POLYGON;
-    out->mNumFaces = 1;
-
-    // build the face
-    out->mFaces    = new aiFace[1];
-    aiFace& face   = out->mFaces[0];
-
-    face.mNumIndices = 4;
-    face.mIndices    = new unsigned int[4];
-    for (unsigned int i = 0; i < 4;++i)
-        face.mIndices[i] = i;
-
-    out->mNumVertices = 4;
-
-    // copy vertex positions
-    aiVector3D* vec = out->mVertices = new aiVector3D[4];
-    *vec++ = v1.position;
-    *vec++ = v2.position;
-    *vec++ = v3.position;
-    *vec   = v4.position;
-
-    // copy vertex normals
-    vec = out->mNormals = new aiVector3D[4];
-    *vec++ = v1.normal;
-    *vec++ = v2.normal;
-    *vec++ = v3.normal;
-    *vec   = v4.normal;
-
-    // copy texture coordinates
-    vec = out->mTextureCoords[0] = new aiVector3D[4];
-    *vec++ = v1.uv;
-    *vec++ = v2.uv;
-    *vec++ = v3.uv;
-    *vec   = v4.uv;
-    return out;
-}
-
-// ------------------------------------------------------------------------------------------------
-void IRRImporter::BuildSkybox(std::vector<aiMesh*>& meshes, std::vector<aiMaterial*> materials)
-{
-    // Update the material of the skybox - replace the name and disable shading for skyboxes.
-    for (unsigned int i = 0; i < 6;++i) {
-        aiMaterial* out = ( aiMaterial* ) (*(materials.end()-(6-i)));
-
-        aiString s;
-        s.length = ::ai_snprintf( s.data, MAXLEN, "SkyboxSide_%u",i );
-        out->AddProperty(&s,AI_MATKEY_NAME);
-
-        int shading = aiShadingMode_NoShading;
-        out->AddProperty(&shading,1,AI_MATKEY_SHADING_MODEL);
-    }
-
-    // Skyboxes are much more difficult. They are represented
-    // by six single planes with different textures, so we'll
-    // need to build six meshes.
-
-    const ai_real l = 10.0; // the size used by Irrlicht
-
-    // FRONT SIDE
-    meshes.push_back( BuildSingleQuadMesh(
-        SkyboxVertex(-l,-l,-l,  0, 0, 1,   1.0,1.0),
-        SkyboxVertex( l,-l,-l,  0, 0, 1,   0.0,1.0),
-        SkyboxVertex( l, l,-l,  0, 0, 1,   0.0,0.0),
-        SkyboxVertex(-l, l,-l,  0, 0, 1,   1.0,0.0)) );
-    meshes.back()->mMaterialIndex = static_cast<unsigned int>(materials.size()-6u);
-
-    // LEFT SIDE
-    meshes.push_back( BuildSingleQuadMesh(
-        SkyboxVertex( l,-l,-l,  -1, 0, 0,   1.0,1.0),
-        SkyboxVertex( l,-l, l,  -1, 0, 0,   0.0,1.0),
-        SkyboxVertex( l, l, l,  -1, 0, 0,   0.0,0.0),
-        SkyboxVertex( l, l,-l,  -1, 0, 0,   1.0,0.0)) );
-    meshes.back()->mMaterialIndex = static_cast<unsigned int>(materials.size()-5u);
-
-    // BACK SIDE
-    meshes.push_back( BuildSingleQuadMesh(
-        SkyboxVertex( l,-l, l,  0, 0, -1,   1.0,1.0),
-        SkyboxVertex(-l,-l, l,  0, 0, -1,   0.0,1.0),
-        SkyboxVertex(-l, l, l,  0, 0, -1,   0.0,0.0),
-        SkyboxVertex( l, l, l,  0, 0, -1,   1.0,0.0)) );
-    meshes.back()->mMaterialIndex = static_cast<unsigned int>(materials.size()-4u);
-
-    // RIGHT SIDE
-    meshes.push_back( BuildSingleQuadMesh(
-        SkyboxVertex(-l,-l, l,  1, 0, 0,   1.0,1.0),
-        SkyboxVertex(-l,-l,-l,  1, 0, 0,   0.0,1.0),
-        SkyboxVertex(-l, l,-l,  1, 0, 0,   0.0,0.0),
-        SkyboxVertex(-l, l, l,  1, 0, 0,   1.0,0.0)) );
-    meshes.back()->mMaterialIndex = static_cast<unsigned int>(materials.size()-3u);
-
-    // TOP SIDE
-    meshes.push_back( BuildSingleQuadMesh(
-        SkyboxVertex( l, l,-l,  0, -1, 0,   1.0,1.0),
-        SkyboxVertex( l, l, l,  0, -1, 0,   0.0,1.0),
-        SkyboxVertex(-l, l, l,  0, -1, 0,   0.0,0.0),
-        SkyboxVertex(-l, l,-l,  0, -1, 0,   1.0,0.0)) );
-    meshes.back()->mMaterialIndex = static_cast<unsigned int>(materials.size()-2u);
-
-    // BOTTOM SIDE
-    meshes.push_back( BuildSingleQuadMesh(
-        SkyboxVertex( l,-l, l,  0,  1, 0,   0.0,0.0),
-        SkyboxVertex( l,-l,-l,  0,  1, 0,   1.0,0.0),
-        SkyboxVertex(-l,-l,-l,  0,  1, 0,   1.0,1.0),
-        SkyboxVertex(-l,-l, l,  0,  1, 0,   0.0,1.0)) );
-    meshes.back()->mMaterialIndex = static_cast<unsigned int>(materials.size()-1u);
-}
-
-// ------------------------------------------------------------------------------------------------
-void IRRImporter::CopyMaterial(std::vector<aiMaterial*>& materials,
-    std::vector< std::pair<aiMaterial*, unsigned int> >& inmaterials,
-    unsigned int& defMatIdx,
-    aiMesh* mesh)
-{
-    if (inmaterials.empty())    {
-        // Do we have a default material? If not we need to create one
-        if (UINT_MAX == defMatIdx)
-        {
-            defMatIdx = (unsigned int)materials.size();
-            //TODO: add this materials to someone?
-            /*aiMaterial* mat = new aiMaterial();
-
-            aiString s;
-            s.Set(AI_DEFAULT_MATERIAL_NAME);
-            mat->AddProperty(&s,AI_MATKEY_NAME);
-
-            aiColor3D c(0.6f,0.6f,0.6f);
-            mat->AddProperty(&c,1,AI_MATKEY_COLOR_DIFFUSE);*/
-        }
-        mesh->mMaterialIndex = defMatIdx;
-        return;
-    }
-    else if (inmaterials.size() > 1)    {
-        ASSIMP_LOG_INFO("IRR: Skipping additional materials");
-    }
-
-    mesh->mMaterialIndex = (unsigned int)materials.size();
-    materials.push_back(inmaterials[0].first);
-}
-
-
-// ------------------------------------------------------------------------------------------------
-inline
-int ClampSpline(int idx, int size) {
-    return ( idx<0 ? size+idx : ( idx>=size ? idx-size : idx ) );
-}
-
-// ------------------------------------------------------------------------------------------------
-inline void FindSuitableMultiple(int& angle)
-{
-    if (angle < 3) angle = 3;
-    else if (angle < 10) angle = 10;
-    else if (angle < 20) angle = 20;
-    else if (angle < 30) angle = 30;
-}
-
-// ------------------------------------------------------------------------------------------------
-void IRRImporter::ComputeAnimations(Node* root, aiNode* real, std::vector<aiNodeAnim*>& anims)
-{
-    ai_assert(nullptr != root && nullptr != real);
-
-    // XXX totally WIP - doesn't produce proper results, need to evaluate
-    // whether there's any use for Irrlicht's proprietary scene format
-    // outside Irrlicht ...
-    // This also applies to the above function of FindSuitableMultiple and ClampSpline which are
-    // solely used in this function
-
-    if (root->animators.empty()) {
-        return;
-    }
-    unsigned int total( 0 );
-    for (std::list<Animator>::iterator it = root->animators.begin();it != root->animators.end(); ++it)  {
-        if ((*it).type == Animator::UNKNOWN || (*it).type == Animator::OTHER)   {
-            ASSIMP_LOG_WARN("IRR: Skipping unknown or unsupported animator");
-            continue;
-        }
-        ++total;
-    }
-    if (!total) {
-        return;
-    } else if (1 == total)    {
-        ASSIMP_LOG_WARN("IRR: Adding dummy nodes to simulate multiple animators");
-    }
-
-    // NOTE: 1 tick == i millisecond
-
-    unsigned int cur = 0;
-    for (std::list<Animator>::iterator it = root->animators.begin();
-        it != root->animators.end(); ++it)
-    {
-        if ((*it).type == Animator::UNKNOWN || (*it).type == Animator::OTHER)continue;
-
-        Animator& in = *it ;
-        aiNodeAnim* anim = new aiNodeAnim();
-
-        if (cur != total-1) {
-            // Build a new name - a prefix instead of a suffix because it is
-            // easier to check against
-            anim->mNodeName.length = ::ai_snprintf(anim->mNodeName.data, MAXLEN,
-                "$INST_DUMMY_%i_%s",total-1,
-                (root->name.length() ? root->name.c_str() : ""));
-
-            // we'll also need to insert a dummy in the node hierarchy.
-            aiNode* dummy = new aiNode();
-
-            for (unsigned int i = 0; i < real->mParent->mNumChildren;++i)
-                if (real->mParent->mChildren[i] == real)
-                    real->mParent->mChildren[i] = dummy;
-
-            dummy->mParent = real->mParent;
-            dummy->mName = anim->mNodeName;
-
-            dummy->mNumChildren = 1;
-            dummy->mChildren = new aiNode*[dummy->mNumChildren];
-            dummy->mChildren[0] = real;
-
-            // the transformation matrix of the dummy node is the identity
-
-            real->mParent = dummy;
-        }
-        else anim->mNodeName.Set(root->name);
-        ++cur;
-
-        switch (in.type)    {
-        case Animator::ROTATION:
-            {
-                // -----------------------------------------------------
-                // find out how long a full rotation will take
-                // This is the least common multiple of 360.f and all
-                // three euler angles. Although we'll surely find a
-                // possible multiple (haha) it could be somewhat large
-                // for our purposes. So we need to modify the angles
-                // here in order to get good results.
-                // -----------------------------------------------------
-                int angles[3];
-                angles[0] = (int)(in.direction.x*100);
-                angles[1] = (int)(in.direction.y*100);
-                angles[2] = (int)(in.direction.z*100);
-
-                angles[0] %= 360;
-                angles[1] %= 360;
-                angles[2] %= 360;
-
-                if ( (angles[0]*angles[1]) != 0 && (angles[1]*angles[2]) != 0 )
-                {
-                    FindSuitableMultiple(angles[0]);
-                    FindSuitableMultiple(angles[1]);
-                    FindSuitableMultiple(angles[2]);
-                }
-
-                int lcm = 360;
-
-                if (angles[0])
-                    lcm  = Math::lcm(lcm,angles[0]);
-
-                if (angles[1])
-                    lcm  = Math::lcm(lcm,angles[1]);
-
-                if (angles[2])
-                    lcm  = Math::lcm(lcm,angles[2]);
-
-                if (360 == lcm)
-                    break;
-
-#if 0
-                // This can be a division through zero, but we don't care
-                float f1 = (float)lcm / angles[0];
-                float f2 = (float)lcm / angles[1];
-                float f3 = (float)lcm / angles[2];
-#endif
-
-                // find out how many time units we'll need for the finest
-                // track (in seconds) - this defines the number of output
-                // keys (fps * seconds)
-                float max  = 0.f;
-                if (angles[0])
-                    max = (float)lcm / angles[0];
-                if (angles[1])
-                    max = std::max(max, (float)lcm / angles[1]);
-                if (angles[2])
-                    max = std::max(max, (float)lcm / angles[2]);
-
-                anim->mNumRotationKeys = (unsigned int)(max*fps);
-                anim->mRotationKeys = new aiQuatKey[anim->mNumRotationKeys];
-
-                // begin with a zero angle
-                aiVector3D angle;
-                for (unsigned int i = 0; i < anim->mNumRotationKeys;++i)
-                {
-                    // build the quaternion for the given euler angles
-                    aiQuatKey& q = anim->mRotationKeys[i];
-
-                    q.mValue = aiQuaternion(angle.x, angle.y, angle.z);
-                    q.mTime = (double)i;
-
-                    // increase the angle
-                    angle += in.direction;
-                }
-
-                // This animation is repeated and repeated ...
-                anim->mPostState = anim->mPreState = aiAnimBehaviour_REPEAT;
-            }
-            break;
-
-        case Animator::FLY_CIRCLE:
-            {
-                // -----------------------------------------------------
-                // Find out how much time we'll need to perform a
-                // full circle.
-                // -----------------------------------------------------
-                const double seconds = (1. / in.speed) / 1000.;
-                const double tdelta = 1000. / fps;
-
-                anim->mNumPositionKeys = (unsigned int) (fps * seconds);
-                anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys];
-
-                // from Irrlicht, what else should we do than copying it?
-                aiVector3D vecU,vecV;
-                if (in.direction.y) {
-                    vecV = aiVector3D(50,0,0) ^ in.direction;
-                }
-                else vecV = aiVector3D(0,50,00) ^ in.direction;
-                vecV.Normalize();
-                vecU = (vecV ^ in.direction).Normalize();
-
-                // build the output keys
-                for (unsigned int i = 0; i < anim->mNumPositionKeys;++i)    {
-                    aiVectorKey& key = anim->mPositionKeys[i];
-                    key.mTime = i * tdelta;
-
-                    const ai_real t = (ai_real) ( in.speed * key.mTime );
-                    key.mValue = in.circleCenter  + in.circleRadius * ((vecU * std::cos(t)) + (vecV * std::sin(t)));
-                }
-
-                // This animation is repeated and repeated ...
-                anim->mPostState = anim->mPreState = aiAnimBehaviour_REPEAT;
-            }
-            break;
-
-        case Animator::FLY_STRAIGHT:
-            {
-                anim->mPostState = anim->mPreState = (in.loop ? aiAnimBehaviour_REPEAT : aiAnimBehaviour_CONSTANT);
-                const double seconds = in.timeForWay / 1000.;
-                const double tdelta = 1000. / fps;
-
-                anim->mNumPositionKeys = (unsigned int) (fps * seconds);
-                anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys];
-
-                aiVector3D diff = in.direction - in.circleCenter;
-                const ai_real lengthOfWay = diff.Length();
-                diff.Normalize();
-
-                const double timeFactor = lengthOfWay / in.timeForWay;
-
-                // build the output keys
-                for (unsigned int i = 0; i < anim->mNumPositionKeys;++i)    {
-                    aiVectorKey& key = anim->mPositionKeys[i];
-                    key.mTime = i * tdelta;
-                    key.mValue = in.circleCenter + diff * ai_real(timeFactor * key.mTime);
-                }
-            }
-            break;
-
-        case Animator::FOLLOW_SPLINE:
-            {
-                // repeat outside the defined time range
-                anim->mPostState = anim->mPreState = aiAnimBehaviour_REPEAT;
-                const int size = (int)in.splineKeys.size();
-                if (!size)  {
-                    // We have no point in the spline. That's bad. Really bad.
-                    ASSIMP_LOG_WARN("IRR: Spline animators with no points defined");
-
-                    delete anim;
-                    anim = nullptr;
-                    break;
-                }
-                else if (size == 1) {
-                    // We have just one point in the spline so we don't need the full calculation
-                    anim->mNumPositionKeys = 1;
-                    anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys];
-
-                    anim->mPositionKeys[0].mValue = in.splineKeys[0].mValue;
-                    anim->mPositionKeys[0].mTime  = 0.f;
-                    break;
-                }
-
-                unsigned int ticksPerFull = 15;
-                anim->mNumPositionKeys = (unsigned int) ( ticksPerFull * fps );
-                anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys];
-
-                for (unsigned int i = 0; i < anim->mNumPositionKeys;++i)
-                {
-                    aiVectorKey& key = anim->mPositionKeys[i];
-
-                    const ai_real dt = (i * in.speed * ai_real( 0.001 ) );
-                    const ai_real u = dt - std::floor(dt);
-                    const int idx = (int)std::floor(dt) % size;
-
-                    // get the 4 current points to evaluate the spline
-                    const aiVector3D& p0 = in.splineKeys[ ClampSpline( idx - 1, size ) ].mValue;
-                    const aiVector3D& p1 = in.splineKeys[ ClampSpline( idx + 0, size ) ].mValue;
-                    const aiVector3D& p2 = in.splineKeys[ ClampSpline( idx + 1, size ) ].mValue;
-                    const aiVector3D& p3 = in.splineKeys[ ClampSpline( idx + 2, size ) ].mValue;
-
-                    // compute polynomials
-                    const ai_real u2 = u*u;
-                    const ai_real u3 = u2*2;
-
-                    const ai_real h1 = ai_real( 2.0 ) * u3 - ai_real( 3.0 ) * u2 + ai_real( 1.0 );
-                    const ai_real h2 = ai_real( -2.0 ) * u3 + ai_real( 3.0 ) * u3;
-                    const ai_real h3 = u3 - ai_real( 2.0 ) * u3;
-                    const ai_real h4 = u3 - u2;
-
-                    // compute the spline tangents
-                    const aiVector3D t1 = ( p2 - p0 ) * in.tightness;
-                    aiVector3D t2 = ( p3 - p1 ) * in.tightness;
-
-                    // and use them to get the interpolated point
-                    t2 = (h1 * p1 + p2 * h2 + t1 * h3 + h4 * t2);
-
-                    // build a simple translation matrix from it
-                    key.mValue = t2;
-                    key.mTime  = (double) i;
-                }
-            }
-            break;
-        default:
-            // UNKNOWN , OTHER
-            break;
-        };
-        if (anim)   {
-            anims.push_back(anim);
-            ++total;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// This function is maybe more generic than we'd need it here
-void SetupMapping (aiMaterial* mat, aiTextureMapping mode, const aiVector3D& axis = aiVector3D(0.f,0.f,-1.f))
-{
-    // Check whether there are texture properties defined - setup
-    // the desired texture mapping mode for all of them and ignore
-    // all UV settings we might encounter. WE HAVE NO UVS!
-
-    std::vector<aiMaterialProperty*> p;
-    p.reserve(mat->mNumProperties+1);
-
-    for (unsigned int i = 0; i < mat->mNumProperties;++i)
-    {
-        aiMaterialProperty* prop = mat->mProperties[i];
-        if (!::strcmp( prop->mKey.data, "$tex.file"))   {
-            // Setup the mapping key
-            aiMaterialProperty* m = new aiMaterialProperty();
-            m->mKey.Set("$tex.mapping");
-            m->mIndex    = prop->mIndex;
-            m->mSemantic = prop->mSemantic;
-            m->mType     = aiPTI_Integer;
-
-            m->mDataLength = 4;
-            m->mData = new char[4];
-            *((int*)m->mData) = mode;
-
-            p.push_back(prop);
-            p.push_back(m);
-
-            // Setup the mapping axis
-            if (mode == aiTextureMapping_CYLINDER || mode == aiTextureMapping_PLANE || mode == aiTextureMapping_SPHERE) {
-                m = new aiMaterialProperty();
-                m->mKey.Set("$tex.mapaxis");
-                m->mIndex    = prop->mIndex;
-                m->mSemantic = prop->mSemantic;
-                m->mType     = aiPTI_Float;
-
-                m->mDataLength = 12;
-                m->mData = new char[12];
-                *((aiVector3D*)m->mData) = axis;
-                p.push_back(m);
-            }
-        }
-        else if (! ::strcmp( prop->mKey.data, "$tex.uvwsrc"))   {
-            delete mat->mProperties[i];
-        }
-        else p.push_back(prop);
-    }
-
-    if (p.empty())return;
-
-    // rebuild the output array
-    if (p.size() > mat->mNumAllocated)  {
-        delete[] mat->mProperties;
-        mat->mProperties = new aiMaterialProperty*[p.size()*2];
-
-        mat->mNumAllocated = static_cast<unsigned int>(p.size()*2);
-    }
-    mat->mNumProperties = (unsigned int)p.size();
-    ::memcpy(mat->mProperties,&p[0],sizeof(void*)*mat->mNumProperties);
-}
-
-// ------------------------------------------------------------------------------------------------
-void IRRImporter::GenerateGraph(Node* root,aiNode* rootOut ,aiScene* scene,
-    BatchLoader& batch,
-    std::vector<aiMesh*>&        meshes,
-    std::vector<aiNodeAnim*>&    anims,
-    std::vector<AttachmentInfo>& attach,
-    std::vector<aiMaterial*>&    materials,
-    unsigned int&                defMatIdx)
-{
-    unsigned int oldMeshSize = (unsigned int)meshes.size();
-    //unsigned int meshTrafoAssign = 0;
-
-    // Now determine the type of the node
-    switch (root->type)
-    {
-    case Node::ANIMMESH:
-    case Node::MESH:
-        {
-            if (!root->meshPath.length())
-                break;
-
-            // Get the loaded mesh from the scene and add it to
-            // the list of all scenes to be attached to the
-            // graph we're currently building
-            aiScene* localScene = batch.GetImport(root->id);
-            if (!localScene) {
-                ASSIMP_LOG_ERROR("IRR: Unable to load external file: " + root->meshPath);
-                break;
-            }
-            attach.push_back(AttachmentInfo(localScene,rootOut));
-
-            // Now combine the material we've loaded for this mesh
-            // with the real materials we got from the file. As we
-            // don't execute any pp-steps on the file, the numbers
-            // should be equal. If they are not, we can impossibly
-            // do this  ...
-            if (root->materials.size() != (unsigned int)localScene->mNumMaterials)   {
-                ASSIMP_LOG_WARN("IRR: Failed to match imported materials "
-                    "with the materials found in the IRR scene file");
-
-                break;
-            }
-            for (unsigned int i = 0; i < localScene->mNumMaterials;++i)  {
-                // Delete the old material, we don't need it anymore
-                delete localScene->mMaterials[i];
-
-                std::pair<aiMaterial*, unsigned int>& src = root->materials[i];
-                localScene->mMaterials[i] = src.first;
-            }
-
-            // NOTE: Each mesh should have exactly one material assigned,
-            // but we do it in a separate loop if this behaviour changes
-            // in future.
-            for (unsigned int i = 0; i < localScene->mNumMeshes;++i) {
-                // Process material flags
-                aiMesh* mesh = localScene->mMeshes[i];
-
-
-                // If "trans_vertex_alpha" mode is enabled, search all vertex colors
-                // and check whether they have a common alpha value. This is quite
-                // often the case so we can simply extract it to a shared oacity
-                // value.
-                std::pair<aiMaterial*, unsigned int>& src = root->materials[mesh->mMaterialIndex];
-                aiMaterial* mat = (aiMaterial*)src.first;
-
-                if (mesh->HasVertexColors(0) && src.second & AI_IRRMESH_MAT_trans_vertex_alpha)
-                {
-                    bool bdo = true;
-                    for (unsigned int a = 1; a < mesh->mNumVertices;++a)    {
-
-                        if (mesh->mColors[0][a].a != mesh->mColors[0][a-1].a)   {
-                            bdo = false;
-                            break;
-                        }
-                    }
-                    if (bdo)    {
-                        ASSIMP_LOG_INFO("IRR: Replacing mesh vertex alpha with common opacity");
-
-                        for (unsigned int a = 0; a < mesh->mNumVertices;++a)
-                            mesh->mColors[0][a].a = 1.f;
-
-                        mat->AddProperty(& mesh->mColors[0][0].a, 1, AI_MATKEY_OPACITY);
-                    }
-                }
-
-                // If we have a second texture coordinate set and a second texture
-                // (either lightmap, normalmap, 2layered material) we need to
-                // setup the correct UV index for it. The texture can either
-                // be diffuse (lightmap & 2layer) or a normal map (normal & parallax)
-                if (mesh->HasTextureCoords(1))  {
-
-                    int idx = 1;
-                    if (src.second & (AI_IRRMESH_MAT_solid_2layer | AI_IRRMESH_MAT_lightmap))   {
-                        mat->AddProperty(&idx,1,AI_MATKEY_UVWSRC_DIFFUSE(0));
-                    }
-                    else if (src.second & AI_IRRMESH_MAT_normalmap_solid)   {
-                        mat->AddProperty(&idx,1,AI_MATKEY_UVWSRC_NORMALS(0));
-                    }
-                }
-            }
-        }
-        break;
-
-    case Node::LIGHT:
-    case Node::CAMERA:
-
-        // We're already finished with lights and cameras
-        break;
-
-
-    case Node::SPHERE:
-        {
-            // Generate the sphere model. Our input parameter to
-            // the sphere generation algorithm is the number of
-            // subdivisions of each triangle - but here we have
-            // the number of poylgons on a specific axis. Just
-            // use some hardcoded limits to approximate this ...
-            unsigned int mul = root->spherePolyCountX*root->spherePolyCountY;
-            if      (mul < 100)mul = 2;
-            else if (mul < 300)mul = 3;
-            else               mul = 4;
-
-            meshes.push_back(StandardShapes::MakeMesh(mul,
-                &StandardShapes::MakeSphere));
-
-            // Adjust scaling
-            root->scaling *= root->sphereRadius/2;
-
-            // Copy one output material
-            CopyMaterial(materials, root->materials, defMatIdx, meshes.back());
-
-            // Now adjust this output material - if there is a first texture
-            // set, setup spherical UV mapping around the Y axis.
-            SetupMapping ( (aiMaterial*) materials.back(), aiTextureMapping_SPHERE);
-        }
-        break;
-
-    case Node::CUBE:
-        {
-            // Generate an unit cube first
-            meshes.push_back(StandardShapes::MakeMesh(
-                &StandardShapes::MakeHexahedron));
-
-            // Adjust scaling
-            root->scaling *= root->sphereRadius;
-
-            // Copy one output material
-            CopyMaterial(materials, root->materials, defMatIdx, meshes.back());
-
-            // Now adjust this output material - if there is a first texture
-            // set, setup cubic UV mapping
-            SetupMapping ( (aiMaterial*) materials.back(), aiTextureMapping_BOX );
-        }
-        break;
-
-
-    case Node::SKYBOX:
-        {
-            // A skybox is defined by six materials
-            if (root->materials.size() < 6) {
-                ASSIMP_LOG_ERROR("IRR: There should be six materials for a skybox");
-                break;
-            }
-
-            // copy those materials and generate 6 meshes for our new skybox
-            materials.reserve(materials.size() + 6);
-            for (unsigned int i = 0; i < 6;++i)
-                materials.insert(materials.end(),root->materials[i].first);
-
-            BuildSkybox(meshes,materials);
-
-            // *************************************************************
-            // Skyboxes will require a different code path for rendering,
-            // so there must be a way for the user to add special support
-            // for IRR skyboxes. We add a 'IRR.SkyBox_' prefix to the node.
-            // *************************************************************
-            root->name = "IRR.SkyBox_" + root->name;
-            ASSIMP_LOG_INFO("IRR: Loading skybox, this will "
-                "require special handling to be displayed correctly");
-        }
-        break;
-
-    case Node::TERRAIN:
-        {
-            // to support terrains, we'd need to have a texture decoder
-            ASSIMP_LOG_ERROR("IRR: Unsupported node - TERRAIN");
-        }
-        break;
-    default:
-        // DUMMY
-        break;
-    };
-
-    // Check whether we added a mesh (or more than one ...). In this case
-    // we'll also need to attach it to the node
-    if (oldMeshSize != (unsigned int) meshes.size())    {
-
-        rootOut->mNumMeshes = (unsigned int)meshes.size() - oldMeshSize;
-        rootOut->mMeshes    = new unsigned int[rootOut->mNumMeshes];
-
-        for (unsigned int a = 0; a  < rootOut->mNumMeshes;++a)  {
-            rootOut->mMeshes[a] = oldMeshSize+a;
-        }
-    }
-
-    // Setup the name of this node
-    rootOut->mName.Set(root->name);
-
-    // Now compute the final local transformation matrix of the
-    // node from the given translation, rotation and scaling values.
-    // (the rotation is given in Euler angles, XYZ order)
-    //std::swap((float&)root->rotation.z,(float&)root->rotation.y);
-    rootOut->mTransformation.FromEulerAnglesXYZ(AI_DEG_TO_RAD(root->rotation) );
-
-    // apply scaling
-    aiMatrix4x4& mat = rootOut->mTransformation;
-    mat.a1 *= root->scaling.x;
-    mat.b1 *= root->scaling.x;
-    mat.c1 *= root->scaling.x;
-    mat.a2 *= root->scaling.y;
-    mat.b2 *= root->scaling.y;
-    mat.c2 *= root->scaling.y;
-    mat.a3 *= root->scaling.z;
-    mat.b3 *= root->scaling.z;
-    mat.c3 *= root->scaling.z;
-
-    // apply translation
-    mat.a4 += root->position.x;
-    mat.b4 += root->position.y;
-    mat.c4 += root->position.z;
-
-    // now compute animations for the node
-    ComputeAnimations(root,rootOut, anims);
-
-    // Add all children recursively. First allocate enough storage
-    // for them, then call us again
-    rootOut->mNumChildren = (unsigned int)root->children.size();
-    if (rootOut->mNumChildren)  {
-
-        rootOut->mChildren = new aiNode*[rootOut->mNumChildren];
-        for (unsigned int i = 0; i < rootOut->mNumChildren;++i) {
-
-            aiNode* node = rootOut->mChildren[i] =  new aiNode();
-            node->mParent = rootOut;
-            GenerateGraph(root->children[i],node,scene,batch,meshes,
-                anims,attach,materials,defMatIdx);
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Imports the given file into the given scene structure.
-void IRRImporter::InternReadFile( const std::string& pFile,
-    aiScene* pScene, IOSystem* pIOHandler)
-{
-    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile));
-
-    // Check whether we can read from the file
-    if (file.get() == nullptr) {
-        throw DeadlyImportError("Failed to open IRR file " + pFile + "");
-    }
-
-    // Construct the irrXML parser
-    CIrrXML_IOStreamReader st(file.get());
-    reader = createIrrXMLReader((IFileReadCallBack*) &st);
-
-    // The root node of the scene
-    Node* root = new Node(Node::DUMMY);
-    root->parent = nullptr;
-    root->name = "<IRRSceneRoot>";
-
-    // Current node parent
-    Node* curParent = root;
-
-    // Scenegraph node we're currently working on
-    Node* curNode = nullptr;
-
-    // List of output cameras
-    std::vector<aiCamera*> cameras;
-
-    // List of output lights
-    std::vector<aiLight*> lights;
-
-    // Batch loader used to load external models
-    BatchLoader batch(pIOHandler);
-//  batch.SetBasePath(pFile);
-
-    cameras.reserve(5);
-    lights.reserve(5);
-
-    bool inMaterials = false, inAnimator = false;
-    unsigned int guessedAnimCnt = 0, guessedMeshCnt = 0, guessedMatCnt = 0;
-
-    // Parse the XML file
-    while (reader->read())  {
-        switch (reader->getNodeType())  {
-        case EXN_ELEMENT:
-
-            if (!ASSIMP_stricmp(reader->getNodeName(),"node"))  {
-                // ***********************************************************************
-                /*  What we're going to do with the node depends
-                 *  on its type:
-                 *
-                 *  "mesh" - Load a mesh from an external file
-                 *  "cube" - Generate a cube
-                 *  "skybox" - Generate a skybox
-                 *  "light" - A light source
-                 *  "sphere" - Generate a sphere mesh
-                 *  "animatedMesh" - Load an animated mesh from an external file
-                 *    and join its animation channels with ours.
-                 *  "empty" - A dummy node
-                 *  "camera" - A camera
-                 *  "terrain" - a terrain node (data comes from a heightmap)
-                 *  "billboard", ""
-                 *
-                 *  Each of these nodes can be animated and all can have multiple
-                 *  materials assigned (except lights, cameras and dummies, of course).
-                 */
-                // ***********************************************************************
-                const char* sz = reader->getAttributeValueSafe("type");
-                Node* nd;
-                if (!ASSIMP_stricmp(sz,"mesh") || !ASSIMP_stricmp(sz,"octTree"))    {
-                    // OctTree's and meshes are treated equally
-                    nd = new Node(Node::MESH);
-                }
-                else if (!ASSIMP_stricmp(sz,"cube"))    {
-                    nd = new Node(Node::CUBE);
-                    ++guessedMeshCnt;
-                    // meshes.push_back(StandardShapes::MakeMesh(&StandardShapes::MakeHexahedron));
-                }
-                else if (!ASSIMP_stricmp(sz,"skybox"))  {
-                    nd = new Node(Node::SKYBOX);
-                    guessedMeshCnt += 6;
-                }
-                else if (!ASSIMP_stricmp(sz,"camera"))  {
-                    nd = new Node(Node::CAMERA);
-
-                    // Setup a temporary name for the camera
-                    aiCamera* cam = new aiCamera();
-                    cam->mName.Set( nd->name );
-                    cameras.push_back(cam);
-                }
-                else if (!ASSIMP_stricmp(sz,"light"))   {
-                    nd = new Node(Node::LIGHT);
-
-                    // Setup a temporary name for the light
-                    aiLight* cam = new aiLight();
-                    cam->mName.Set( nd->name );
-                    lights.push_back(cam);
-                }
-                else if (!ASSIMP_stricmp(sz,"sphere"))  {
-                    nd = new Node(Node::SPHERE);
-                    ++guessedMeshCnt;
-                }
-                else if (!ASSIMP_stricmp(sz,"animatedMesh"))    {
-                    nd = new Node(Node::ANIMMESH);
-                }
-                else if (!ASSIMP_stricmp(sz,"empty"))   {
-                    nd = new Node(Node::DUMMY);
-                }
-                else if (!ASSIMP_stricmp(sz,"terrain")) {
-                    nd = new Node(Node::TERRAIN);
-                }
-                else if (!ASSIMP_stricmp(sz,"billBoard"))   {
-                    // We don't support billboards, so ignore them
-                    ASSIMP_LOG_ERROR("IRR: Billboards are not supported by Assimp");
-                    nd = new Node(Node::DUMMY);
-                }
-                else    {
-                    ASSIMP_LOG_WARN("IRR: Found unknown node: " + std::string(sz));
-
-                    /*  We skip the contents of nodes we don't know.
-                     *  We parse the transformation and all animators
-                     *  and skip the rest.
-                     */
-                    nd = new Node(Node::DUMMY);
-                }
-
-                /* Attach the newly created node to the scenegraph
-                 */
-                curNode = nd;
-                nd->parent = curParent;
-                curParent->children.push_back(nd);
-            }
-            else if (!ASSIMP_stricmp(reader->getNodeName(),"materials"))    {
-                inMaterials = true;
-            }
-            else if (!ASSIMP_stricmp(reader->getNodeName(),"animators"))    {
-                inAnimator = true;
-            }
-            else if (!ASSIMP_stricmp(reader->getNodeName(),"attributes"))   {
-                /*  We should have a valid node here
-                 *  FIX: no ... the scene root node is also contained in an attributes block
-                 */
-                if (!curNode)   {
-#if 0
-                    ASSIMP_LOG_ERROR("IRR: Encountered <attributes> element, but "
-                        "there is no node active");
-#endif
-                    continue;
-                }
-
-                Animator* curAnim = nullptr;
-
-                // Materials can occur for nearly any type of node
-                if (inMaterials && curNode->type != Node::DUMMY)    {
-                    /*  This is a material description - parse it!
-                     */
-                    curNode->materials.push_back(std::pair< aiMaterial*, unsigned int > () );
-                    std::pair< aiMaterial*, unsigned int >& p = curNode->materials.back();
-
-                    p.first = ParseMaterial(p.second);
-
-                    ++guessedMatCnt;
-                    continue;
-                }
-                else if (inAnimator)    {
-                    /*  This is an animation path - add a new animator
-                     *  to the list.
-                     */
-                    curNode->animators.push_back(Animator());
-                    curAnim = & curNode->animators.back();
-
-                    ++guessedAnimCnt;
-                }
-
-                /*  Parse all elements in the attributes block
-                 *  and process them.
-                 */
-                while (reader->read())  {
-                    if (reader->getNodeType() == EXN_ELEMENT)   {
-                        if (!ASSIMP_stricmp(reader->getNodeName(),"vector3d"))  {
-                            VectorProperty prop;
-                            ReadVectorProperty(prop);
-
-                            if (inAnimator) {
-                                if (curAnim->type == Animator::ROTATION && prop.name == "Rotation") {
-                                    // We store the rotation euler angles in 'direction'
-                                    curAnim->direction = prop.value;
-                                }
-                                else if (curAnim->type == Animator::FOLLOW_SPLINE)  {
-                                    // Check whether the vector follows the PointN naming scheme,
-                                    // here N is the ONE-based index of the point
-                                    if (prop.name.length() >= 6 && prop.name.substr(0,5) == "Point")    {
-                                        // Add a new key to the list
-                                        curAnim->splineKeys.push_back(aiVectorKey());
-                                        aiVectorKey& key = curAnim->splineKeys.back();
-
-                                        // and parse its properties
-                                        key.mValue = prop.value;
-                                        key.mTime  = strtoul10(&prop.name[5]);
-                                    }
-                                }
-                                else if (curAnim->type == Animator::FLY_CIRCLE) {
-                                    if (prop.name == "Center")  {
-                                        curAnim->circleCenter = prop.value;
-                                    }
-                                    else if (prop.name == "Direction")  {
-                                        curAnim->direction = prop.value;
-
-                                        // From Irrlicht's source - a workaround for backward compatibility with Irrlicht 1.1
-                                        if (curAnim->direction == aiVector3D()) {
-                                            curAnim->direction = aiVector3D(0.f,1.f,0.f);
-                                        }
-                                        else curAnim->direction.Normalize();
-                                    }
-                                }
-                                else if (curAnim->type == Animator::FLY_STRAIGHT)   {
-                                    if (prop.name == "Start")   {
-                                        // We reuse the field here
-                                        curAnim->circleCenter = prop.value;
-                                    }
-                                    else if (prop.name == "End")    {
-                                        // We reuse the field here
-                                        curAnim->direction = prop.value;
-                                    }
-                                }
-                            }
-                            else    {
-                                if (prop.name == "Position")    {
-                                    curNode->position = prop.value;
-                                }
-                                else if (prop.name == "Rotation")   {
-                                    curNode->rotation = prop.value;
-                                }
-                                else if (prop.name == "Scale")  {
-                                    curNode->scaling = prop.value;
-                                }
-                                else if (Node::CAMERA == curNode->type)
-                                {
-                                    aiCamera* cam = cameras.back();
-                                    if (prop.name == "Target")  {
-                                        cam->mLookAt = prop.value;
-                                    }
-                                    else if (prop.name == "UpVector")   {
-                                        cam->mUp = prop.value;
-                                    }
-                                }
-                            }
-                        }
-                        else if (!ASSIMP_stricmp(reader->getNodeName(),"bool")) {
-                            BoolProperty prop;
-                            ReadBoolProperty(prop);
-
-                            if (inAnimator && curAnim->type == Animator::FLY_CIRCLE && prop.name == "Loop") {
-                                curAnim->loop = prop.value;
-                            }
-                        }
-                        else if (!ASSIMP_stricmp(reader->getNodeName(),"float"))    {
-                            FloatProperty prop;
-                            ReadFloatProperty(prop);
-
-                            if (inAnimator) {
-                                // The speed property exists for several animators
-                                if (prop.name == "Speed")   {
-                                    curAnim->speed = prop.value;
-                                }
-                                else if (curAnim->type == Animator::FLY_CIRCLE && prop.name == "Radius")    {
-                                    curAnim->circleRadius = prop.value;
-                                }
-                                else if (curAnim->type == Animator::FOLLOW_SPLINE && prop.name == "Tightness")  {
-                                    curAnim->tightness = prop.value;
-                                }
-                            }
-                            else    {
-                                if (prop.name == "FramesPerSecond" && Node::ANIMMESH == curNode->type)  {
-                                    curNode->framesPerSecond = prop.value;
-                                }
-                                else if (Node::CAMERA == curNode->type) {
-                                    /*  This is the vertical, not the horizontal FOV.
-                                    *  We need to compute the right FOV from the
-                                    *  screen aspect which we don't know yet.
-                                    */
-                                    if (prop.name == "Fovy")    {
-                                        cameras.back()->mHorizontalFOV  = prop.value;
-                                    }
-                                    else if (prop.name == "Aspect") {
-                                        cameras.back()->mAspect = prop.value;
-                                    }
-                                    else if (prop.name == "ZNear")  {
-                                        cameras.back()->mClipPlaneNear = prop.value;
-                                    }
-                                    else if (prop.name == "ZFar")   {
-                                        cameras.back()->mClipPlaneFar = prop.value;
-                                    }
-                                }
-                                else if (Node::LIGHT == curNode->type)  {
-                                    /*  Additional light information
-                                     */
-                                    if (prop.name == "Attenuation") {
-                                        lights.back()->mAttenuationLinear  = prop.value;
-                                    }
-                                    else if (prop.name == "OuterCone")  {
-                                        lights.back()->mAngleOuterCone =  AI_DEG_TO_RAD( prop.value );
-                                    }
-                                    else if (prop.name == "InnerCone")  {
-                                        lights.back()->mAngleInnerCone =  AI_DEG_TO_RAD( prop.value );
-                                    }
-                                }
-                                // radius of the sphere to be generated -
-                                // or alternatively, size of the cube
-                                else if ((Node::SPHERE == curNode->type && prop.name == "Radius")
-                                    || (Node::CUBE == curNode->type   && prop.name == "Size" )) {
-
-                                        curNode->sphereRadius = prop.value;
-                                }
-                            }
-                        }
-                        else if (!ASSIMP_stricmp(reader->getNodeName(),"int"))  {
-                            IntProperty prop;
-                            ReadIntProperty(prop);
-
-                            if (inAnimator) {
-                                if (curAnim->type == Animator::FLY_STRAIGHT && prop.name == "TimeForWay")   {
-                                    curAnim->timeForWay = prop.value;
-                                }
-                            }
-                            else    {
-                                // sphere polgon numbers in each direction
-                                if (Node::SPHERE == curNode->type)  {
-
-                                    if (prop.name == "PolyCountX")  {
-                                        curNode->spherePolyCountX = prop.value;
-                                    }
-                                    else if (prop.name == "PolyCountY") {
-                                        curNode->spherePolyCountY = prop.value;
-                                    }
-                                }
-                            }
-                        }
-                        else if (!ASSIMP_stricmp(reader->getNodeName(),"string") ||!ASSIMP_stricmp(reader->getNodeName(),"enum"))   {
-                            StringProperty prop;
-                            ReadStringProperty(prop);
-                            if (prop.value.length())    {
-                                if (prop.name == "Name")    {
-                                    curNode->name = prop.value;
-
-                                    /*  If we're either a camera or a light source
-                                     *  we need to update the name in the aiLight/
-                                     *  aiCamera structure, too.
-                                     */
-                                    if (Node::CAMERA == curNode->type)  {
-                                        cameras.back()->mName.Set(prop.value);
-                                    }
-                                    else if (Node::LIGHT == curNode->type)  {
-                                        lights.back()->mName.Set(prop.value);
-                                    }
-                                }
-                                else if (Node::LIGHT == curNode->type && "LightType" == prop.name)
-                                {
-                                    if (prop.value == "Spot")
-                                        lights.back()->mType = aiLightSource_SPOT;
-                                    else if (prop.value == "Point")
-                                        lights.back()->mType = aiLightSource_POINT;
-                                    else if (prop.value == "Directional")
-                                        lights.back()->mType = aiLightSource_DIRECTIONAL;
-                                    else
-                                    {
-                                        // We won't pass the validation with aiLightSourceType_UNDEFINED,
-                                        // so we remove the light and replace it with a silly dummy node
-                                        delete lights.back();
-                                        lights.pop_back();
-                                        curNode->type = Node::DUMMY;
-
-                                        ASSIMP_LOG_ERROR("Ignoring light of unknown type: " + prop.value);
-                                    }
-                                }
-                                else if ((prop.name == "Mesh" && Node::MESH == curNode->type) ||
-                                    Node::ANIMMESH == curNode->type)
-                                {
-                                    /*  This is the file name of the mesh - either
-                                     *  animated or not. We need to make sure we setup
-                                     *  the correct post-processing settings here.
-                                     */
-                                    unsigned int pp = 0;
-                                    BatchLoader::PropertyMap map;
-
-                                    /* If the mesh is a static one remove all animations from the impor data
-                                     */
-                                    if (Node::ANIMMESH != curNode->type)    {
-                                        pp |= aiProcess_RemoveComponent;
-                                        SetGenericProperty<int>(map.ints,AI_CONFIG_PP_RVC_FLAGS,
-                                            aiComponent_ANIMATIONS | aiComponent_BONEWEIGHTS);
-                                    }
-
-                                    /*  TODO: maybe implement the protection against recursive
-                                    *  loading calls directly in BatchLoader? The current
-                                    *  implementation is not absolutely safe. A LWS and an IRR
-                                    *  file referencing each other *could* cause the system to
-                                    *  recurse forever.
-                                    */
-
-                                    const std::string extension = GetExtension(prop.value);
-                                    if ("irr" == extension) {
-                                        ASSIMP_LOG_ERROR("IRR: Can't load another IRR file recursively");
-                                    }
-                                    else
-                                    {
-                                        curNode->id = batch.AddLoadRequest(prop.value,pp,&map);
-                                        curNode->meshPath = prop.value;
-                                    }
-                                }
-                                else if (inAnimator && prop.name == "Type")
-                                {
-                                    // type of the animator
-                                    if (prop.value == "rotation")   {
-                                        curAnim->type = Animator::ROTATION;
-                                    }
-                                    else if (prop.value == "flyCircle") {
-                                        curAnim->type = Animator::FLY_CIRCLE;
-                                    }
-                                    else if (prop.value == "flyStraight")   {
-                                        curAnim->type = Animator::FLY_CIRCLE;
-                                    }
-                                    else if (prop.value == "followSpline")  {
-                                        curAnim->type = Animator::FOLLOW_SPLINE;
-                                    }
-                                    else    {
-                                        ASSIMP_LOG_WARN("IRR: Ignoring unknown animator: "
-                                            + prop.value);
-
-                                        curAnim->type = Animator::UNKNOWN;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    else if (reader->getNodeType() == EXN_ELEMENT_END && !ASSIMP_stricmp(reader->getNodeName(),"attributes"))   {
-                        break;
-                    }
-                }
-            }
-            break;
-
-        case EXN_ELEMENT_END:
-
-            // If we reached the end of a node, we need to continue processing its parent
-            if (!ASSIMP_stricmp(reader->getNodeName(),"node"))  {
-                if (!curNode)   {
-                    // currently is no node set. We need to go
-                    // back in the node hierarchy
-                    if (!curParent) {
-                        curParent = root;
-                        ASSIMP_LOG_ERROR("IRR: Too many closing <node> elements");
-                    }
-                    else curParent = curParent->parent;
-                }
-                else curNode = nullptr;
-            }
-            // clear all flags
-            else if (!ASSIMP_stricmp(reader->getNodeName(),"materials"))    {
-                inMaterials = false;
-            }
-            else if (!ASSIMP_stricmp(reader->getNodeName(),"animators"))    {
-                inAnimator = false;
-            }
-            break;
-
-        default:
-            // GCC complains that not all enumeration values are handled
-            break;
-        }
-    }
-
-    //  Now iterate through all cameras and compute their final (horizontal) FOV
-    for (aiCamera *cam : cameras) {
-        // screen aspect could be missing
-        if (cam->mAspect)   {
-            cam->mHorizontalFOV *= cam->mAspect;
-        } else {
-            ASSIMP_LOG_WARN("IRR: Camera aspect is not given, can't compute horizontal FOV");
-        }
-    }
-
-    batch.LoadAll();
-
-    /* Allocate a tempoary scene data structure
-     */
-    aiScene* tempScene = new aiScene();
-    tempScene->mRootNode = new aiNode();
-    tempScene->mRootNode->mName.Set("<IRRRoot>");
-
-    /* Copy the cameras to the output array
-     */
-    if (!cameras.empty())   {
-        tempScene->mNumCameras = (unsigned int)cameras.size();
-        tempScene->mCameras = new aiCamera*[tempScene->mNumCameras];
-        ::memcpy(tempScene->mCameras,&cameras[0],sizeof(void*)*tempScene->mNumCameras);
-    }
-
-    /* Copy the light sources to the output array
-     */
-    if (!lights.empty())    {
-        tempScene->mNumLights = (unsigned int)lights.size();
-        tempScene->mLights = new aiLight*[tempScene->mNumLights];
-        ::memcpy(tempScene->mLights,&lights[0],sizeof(void*)*tempScene->mNumLights);
-    }
-
-    // temporary data
-    std::vector< aiNodeAnim*>       anims;
-    std::vector< aiMaterial*>       materials;
-    std::vector< AttachmentInfo >   attach;
-    std::vector<aiMesh*>            meshes;
-
-    // try to guess how much storage we'll need
-    anims.reserve     (guessedAnimCnt + (guessedAnimCnt >> 2));
-    meshes.reserve    (guessedMeshCnt + (guessedMeshCnt >> 2));
-    materials.reserve (guessedMatCnt  + (guessedMatCnt >> 2));
-
-    /* Now process our scenegraph recursively: generate final
-     * meshes and generate animation channels for all nodes.
-     */
-    unsigned int defMatIdx = UINT_MAX;
-    GenerateGraph(root,tempScene->mRootNode, tempScene,
-        batch, meshes, anims, attach, materials, defMatIdx);
-
-    if (!anims.empty())
-    {
-        tempScene->mNumAnimations = 1;
-        tempScene->mAnimations = new aiAnimation*[tempScene->mNumAnimations];
-        aiAnimation* an = tempScene->mAnimations[0] = new aiAnimation();
-
-        // ***********************************************************
-        // This is only the global animation channel of the scene.
-        // If there are animated models, they will have separate
-        // animation channels in the scene. To display IRR scenes
-        // correctly, users will need to combine the global anim
-        // channel with all the local animations they want to play
-        // ***********************************************************
-        an->mName.Set("Irr_GlobalAnimChannel");
-
-        // copy all node animation channels to the global channel
-        an->mNumChannels = (unsigned int)anims.size();
-        an->mChannels = new aiNodeAnim*[an->mNumChannels];
-        ::memcpy(an->mChannels, & anims [0], sizeof(void*)*an->mNumChannels);
-    }
-    if (!meshes.empty())    {
-        // copy all meshes to the temporary scene
-        tempScene->mNumMeshes = (unsigned int)meshes.size();
-        tempScene->mMeshes = new aiMesh*[tempScene->mNumMeshes];
-        ::memcpy(tempScene->mMeshes,&meshes[0],tempScene->mNumMeshes*
-            sizeof(void*));
-    }
-
-    /* Copy all materials to the output array
-     */
-    if (!materials.empty()) {
-        tempScene->mNumMaterials = (unsigned int)materials.size();
-        tempScene->mMaterials = new aiMaterial*[tempScene->mNumMaterials];
-        ::memcpy(tempScene->mMaterials,&materials[0],sizeof(void*)*
-            tempScene->mNumMaterials);
-    }
-
-    /*  Now merge all sub scenes and attach them to the correct
-     *  attachment points in the scenegraph.
-     */
-    SceneCombiner::MergeScenes(&pScene,tempScene,attach,
-        AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES | (!configSpeedFlag ? (
-        AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY | AI_INT_MERGE_SCENE_GEN_UNIQUE_MATNAMES) : 0));
-
-
-    /*  If we have no meshes | no materials now set the INCOMPLETE
-     *  scene flag. This is necessary if we failed to load all
-     *  models from external files
-     */
-    if (!pScene->mNumMeshes || !pScene->mNumMaterials)  {
-        ASSIMP_LOG_WARN("IRR: No meshes loaded, setting AI_SCENE_FLAGS_INCOMPLETE");
-        pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
-    }
-
-    /* Finished ... everything destructs automatically and all
-     * temporary scenes have already been deleted by MergeScenes()
-     */
-
-    delete root;
-}
-
-#endif // !! ASSIMP_BUILD_NO_IRR_IMPORTER
diff --git a/Engine/lib/assimp/code/Irr/IRRMeshLoader.cpp b/Engine/lib/assimp/code/Irr/IRRMeshLoader.cpp
deleted file mode 100644
index f3aed5943..000000000
--- a/Engine/lib/assimp/code/Irr/IRRMeshLoader.cpp
+++ /dev/null
@@ -1,536 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-/** @file Implementation of the IrrMesh importer class */
-
-
-
-#ifndef ASSIMP_BUILD_NO_IRRMESH_IMPORTER
-
-#include "IRRMeshLoader.h"
-#include <assimp/ParsingUtils.h>
-#include <assimp/fast_atof.h>
-#include <memory>
-#include <assimp/IOSystem.hpp>
-#include <assimp/mesh.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/material.h>
-#include <assimp/scene.h>
-#include <assimp/importerdesc.h>
-#include <assimp/Macros.h>
-
-using namespace Assimp;
-using namespace irr;
-using namespace irr::io;
-
-static const aiImporterDesc desc = {
-    "Irrlicht Mesh Reader",
-    "",
-    "",
-    "http://irrlicht.sourceforge.net/",
-    aiImporterFlags_SupportTextFlavour,
-    0,
-    0,
-    0,
-    0,
-    "xml irrmesh"
-};
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-IRRMeshImporter::IRRMeshImporter()
-{}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-IRRMeshImporter::~IRRMeshImporter()
-{}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the class can handle the format of the given file.
-bool IRRMeshImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
-{
-    /* NOTE: A simple check for the file extension is not enough
-     * here. Irrmesh and irr are easy, but xml is too generic
-     * and could be collada, too. So we need to open the file and
-     * search for typical tokens.
-     */
-    const std::string extension = GetExtension(pFile);
-
-    if (extension == "irrmesh")return true;
-    else if (extension == "xml" || checkSig)
-    {
-        /*  If CanRead() is called to check whether the loader
-         *  supports a specific file extension in general we
-         *  must return true here.
-         */
-        if (!pIOHandler)return true;
-        const char* tokens[] = {"irrmesh"};
-        return SearchFileHeaderForToken(pIOHandler,pFile,tokens,1);
-    }
-    return false;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Get a list of all file extensions which are handled by this class
-const aiImporterDesc* IRRMeshImporter::GetInfo () const
-{
-    return &desc;
-}
-
-static void releaseMaterial( aiMaterial **mat ) {
-    if(*mat!= nullptr) {
-        delete *mat;
-        *mat = nullptr;
-    }
-}
-
-static void releaseMesh( aiMesh **mesh ) {
-    if (*mesh != nullptr){
-        delete *mesh;
-        *mesh = nullptr;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Imports the given file into the given scene structure.
-void IRRMeshImporter::InternReadFile( const std::string& pFile,
-    aiScene* pScene, IOSystem* pIOHandler)
-{
-    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile));
-
-    // Check whether we can read from the file
-    if( file.get() == NULL)
-        throw DeadlyImportError( "Failed to open IRRMESH file " + pFile + "");
-
-    // Construct the irrXML parser
-    CIrrXML_IOStreamReader st(file.get());
-    reader = createIrrXMLReader((IFileReadCallBack*) &st);
-
-    // final data
-    std::vector<aiMaterial*> materials;
-    std::vector<aiMesh*>     meshes;
-    materials.reserve (5);
-    meshes.reserve(5);
-
-    // temporary data - current mesh buffer
-    aiMaterial* curMat  = nullptr;
-    aiMesh* curMesh     = nullptr;
-    unsigned int curMatFlags = 0;
-
-    std::vector<aiVector3D> curVertices,curNormals,curTangents,curBitangents;
-    std::vector<aiColor4D>  curColors;
-    std::vector<aiVector3D> curUVs,curUV2s;
-
-    // some temporary variables
-    int textMeaning = 0;
-    int vertexFormat = 0; // 0 = normal; 1 = 2 tcoords, 2 = tangents
-    bool useColors = false;
-
-    // Parse the XML file
-    while (reader->read())  {
-        switch (reader->getNodeType())  {
-        case EXN_ELEMENT:
-
-            if (!ASSIMP_stricmp(reader->getNodeName(),"buffer") && (curMat || curMesh)) {
-                // end of previous buffer. A material and a mesh should be there
-                if ( !curMat || !curMesh)   {
-                    ASSIMP_LOG_ERROR("IRRMESH: A buffer must contain a mesh and a material");
-                    releaseMaterial( &curMat );
-                    releaseMesh( &curMesh );
-                } else {
-                    materials.push_back(curMat);
-                    meshes.push_back(curMesh);
-                }
-                curMat  = nullptr;
-                curMesh = nullptr;
-
-                curVertices.clear();
-                curColors.clear();
-                curNormals.clear();
-                curUV2s.clear();
-                curUVs.clear();
-                curTangents.clear();
-                curBitangents.clear();
-            }
-
-
-            if (!ASSIMP_stricmp(reader->getNodeName(),"material"))  {
-                if (curMat) {
-                    ASSIMP_LOG_WARN("IRRMESH: Only one material description per buffer, please");
-                    releaseMaterial( &curMat );
-                }
-                curMat = ParseMaterial(curMatFlags);
-            }
-            /* no else here! */ if (!ASSIMP_stricmp(reader->getNodeName(),"vertices"))
-            {
-                int num = reader->getAttributeValueAsInt("vertexCount");
-
-                if (!num)   {
-                    // This is possible ... remove the mesh from the list and skip further reading
-                    ASSIMP_LOG_WARN("IRRMESH: Found mesh with zero vertices");
-
-                    releaseMaterial( &curMat );
-                    releaseMesh( &curMesh );
-                    textMeaning = 0;
-                    continue;
-                }
-
-                curVertices.reserve(num);
-                curNormals.reserve(num);
-                curColors.reserve(num);
-                curUVs.reserve(num);
-
-                // Determine the file format
-                const char* t = reader->getAttributeValueSafe("type");
-                if (!ASSIMP_stricmp("2tcoords", t)) {
-                    curUV2s.reserve (num);
-                    vertexFormat = 1;
-
-                    if (curMatFlags & AI_IRRMESH_EXTRA_2ND_TEXTURE) {
-                        // *********************************************************
-                        // We have a second texture! So use this UV channel
-                        // for it. The 2nd texture can be either a normal
-                        // texture (solid_2layer or lightmap_xxx) or a normal
-                        // map (normal_..., parallax_...)
-                        // *********************************************************
-                        int idx = 1;
-                        aiMaterial* mat = ( aiMaterial* ) curMat;
-
-                        if (curMatFlags & AI_IRRMESH_MAT_lightmap){
-                            mat->AddProperty(&idx,1,AI_MATKEY_UVWSRC_LIGHTMAP(0));
-                        }
-                        else if (curMatFlags & AI_IRRMESH_MAT_normalmap_solid){
-                            mat->AddProperty(&idx,1,AI_MATKEY_UVWSRC_NORMALS(0));
-                        }
-                        else if (curMatFlags & AI_IRRMESH_MAT_solid_2layer) {
-                            mat->AddProperty(&idx,1,AI_MATKEY_UVWSRC_DIFFUSE(1));
-                        }
-                    }
-                }
-                else if (!ASSIMP_stricmp("tangents", t))    {
-                    curTangents.reserve (num);
-                    curBitangents.reserve (num);
-                    vertexFormat = 2;
-                }
-                else if (ASSIMP_stricmp("standard", t)) {
-                    releaseMaterial( &curMat );
-                    ASSIMP_LOG_WARN("IRRMESH: Unknown vertex format");
-                }
-                else vertexFormat = 0;
-                textMeaning = 1;
-            }
-            else if (!ASSIMP_stricmp(reader->getNodeName(),"indices"))  {
-                if (curVertices.empty() && curMat)  {
-                    releaseMaterial( &curMat );
-                    throw DeadlyImportError("IRRMESH: indices must come after vertices");
-                }
-
-                textMeaning = 2;
-
-                // start a new mesh
-                curMesh = new aiMesh();
-
-                // allocate storage for all faces
-                curMesh->mNumVertices = reader->getAttributeValueAsInt("indexCount");
-                if (!curMesh->mNumVertices) {
-                    // This is possible ... remove the mesh from the list and skip further reading
-                    ASSIMP_LOG_WARN("IRRMESH: Found mesh with zero indices");
-
-                    // mesh - away
-                    releaseMesh( &curMesh );
-
-                    // material - away
-                    releaseMaterial( &curMat );
-
-                    textMeaning = 0;
-                    continue;
-                }
-
-                if (curMesh->mNumVertices % 3)  {
-                    ASSIMP_LOG_WARN("IRRMESH: Number if indices isn't divisible by 3");
-                }
-
-                curMesh->mNumFaces = curMesh->mNumVertices / 3;
-                curMesh->mFaces = new aiFace[curMesh->mNumFaces];
-
-                // setup some members
-                curMesh->mMaterialIndex = (unsigned int)materials.size();
-                curMesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
-
-                // allocate storage for all vertices
-                curMesh->mVertices = new aiVector3D[curMesh->mNumVertices];
-
-                if (curNormals.size() == curVertices.size())    {
-                    curMesh->mNormals = new aiVector3D[curMesh->mNumVertices];
-                }
-                if (curTangents.size() == curVertices.size())   {
-                    curMesh->mTangents = new aiVector3D[curMesh->mNumVertices];
-                }
-                if (curBitangents.size() == curVertices.size()) {
-                    curMesh->mBitangents = new aiVector3D[curMesh->mNumVertices];
-                }
-                if (curColors.size() == curVertices.size() && useColors)    {
-                    curMesh->mColors[0] = new aiColor4D[curMesh->mNumVertices];
-                }
-                if (curUVs.size() == curVertices.size())    {
-                    curMesh->mTextureCoords[0] = new aiVector3D[curMesh->mNumVertices];
-                }
-                if (curUV2s.size() == curVertices.size())   {
-                    curMesh->mTextureCoords[1] = new aiVector3D[curMesh->mNumVertices];
-                }
-            }
-            break;
-
-        case EXN_TEXT:
-            {
-            const char* sz = reader->getNodeData();
-            if (textMeaning == 1)   {
-                textMeaning = 0;
-
-                // read vertices
-                do  {
-                    SkipSpacesAndLineEnd(&sz);
-                    aiVector3D temp;aiColor4D c;
-
-                    // Read the vertex position
-                    sz = fast_atoreal_move<float>(sz,(float&)temp.x);
-                    SkipSpaces(&sz);
-
-                    sz = fast_atoreal_move<float>(sz,(float&)temp.y);
-                    SkipSpaces(&sz);
-
-                    sz = fast_atoreal_move<float>(sz,(float&)temp.z);
-                    SkipSpaces(&sz);
-                    curVertices.push_back(temp);
-
-                    // Read the vertex normals
-                    sz = fast_atoreal_move<float>(sz,(float&)temp.x);
-                    SkipSpaces(&sz);
-
-                    sz = fast_atoreal_move<float>(sz,(float&)temp.y);
-                    SkipSpaces(&sz);
-
-                    sz = fast_atoreal_move<float>(sz,(float&)temp.z);
-                    SkipSpaces(&sz);
-                    curNormals.push_back(temp);
-
-                    // read the vertex colors
-                    uint32_t clr = strtoul16(sz,&sz);
-                    ColorFromARGBPacked(clr,c);
-
-                    if (!curColors.empty() && c != *(curColors.end()-1))
-                        useColors = true;
-
-                    curColors.push_back(c);
-                    SkipSpaces(&sz);
-
-
-                    // read the first UV coordinate set
-                    sz = fast_atoreal_move<float>(sz,(float&)temp.x);
-                    SkipSpaces(&sz);
-
-                    sz = fast_atoreal_move<float>(sz,(float&)temp.y);
-                    SkipSpaces(&sz);
-                    temp.z = 0.f;
-                    temp.y = 1.f - temp.y;  // DX to OGL
-                    curUVs.push_back(temp);
-
-                    // read the (optional) second UV coordinate set
-                    if (vertexFormat == 1)  {
-                        sz = fast_atoreal_move<float>(sz,(float&)temp.x);
-                        SkipSpaces(&sz);
-
-                        sz = fast_atoreal_move<float>(sz,(float&)temp.y);
-                        temp.y = 1.f - temp.y; // DX to OGL
-                        curUV2s.push_back(temp);
-                    }
-                    // read optional tangent and bitangent vectors
-                    else if (vertexFormat == 2) {
-                        // tangents
-                        sz = fast_atoreal_move<float>(sz,(float&)temp.x);
-                        SkipSpaces(&sz);
-
-                        sz = fast_atoreal_move<float>(sz,(float&)temp.z);
-                        SkipSpaces(&sz);
-
-                        sz = fast_atoreal_move<float>(sz,(float&)temp.y);
-                        SkipSpaces(&sz);
-                        temp.y *= -1.0f;
-                        curTangents.push_back(temp);
-
-                        // bitangents
-                        sz = fast_atoreal_move<float>(sz,(float&)temp.x);
-                        SkipSpaces(&sz);
-
-                        sz = fast_atoreal_move<float>(sz,(float&)temp.z);
-                        SkipSpaces(&sz);
-
-                        sz = fast_atoreal_move<float>(sz,(float&)temp.y);
-                        SkipSpaces(&sz);
-                        temp.y *= -1.0f;
-                        curBitangents.push_back(temp);
-                    }
-                }
-
-                /* IMPORTANT: We assume that each vertex is specified in one
-                   line. So we can skip the rest of the line - unknown vertex
-                   elements are ignored.
-                 */
-
-                while (SkipLine(&sz));
-            }
-            else if (textMeaning == 2)  {
-                textMeaning = 0;
-
-                // read indices
-                aiFace* curFace = curMesh->mFaces;
-                aiFace* const faceEnd = curMesh->mFaces  + curMesh->mNumFaces;
-
-                aiVector3D* pcV  = curMesh->mVertices;
-                aiVector3D* pcN  = curMesh->mNormals;
-                aiVector3D* pcT  = curMesh->mTangents;
-                aiVector3D* pcB  = curMesh->mBitangents;
-                aiColor4D* pcC0  = curMesh->mColors[0];
-                aiVector3D* pcT0 = curMesh->mTextureCoords[0];
-                aiVector3D* pcT1 = curMesh->mTextureCoords[1];
-
-                unsigned int curIdx = 0;
-                unsigned int total = 0;
-                while(SkipSpacesAndLineEnd(&sz))    {
-                    if (curFace >= faceEnd) {
-                        ASSIMP_LOG_ERROR("IRRMESH: Too many indices");
-                        break;
-                    }
-                    if (!curIdx)    {
-                        curFace->mNumIndices = 3;
-                        curFace->mIndices = new unsigned int[3];
-                    }
-
-                    unsigned int idx = strtoul10(sz,&sz);
-                    if (idx >= curVertices.size())  {
-                        ASSIMP_LOG_ERROR("IRRMESH: Index out of range");
-                        idx = 0;
-                    }
-
-                    curFace->mIndices[curIdx] = total++;
-
-                    *pcV++ = curVertices[idx];
-                    if (pcN)*pcN++ = curNormals[idx];
-                    if (pcT)*pcT++ = curTangents[idx];
-                    if (pcB)*pcB++ = curBitangents[idx];
-                    if (pcC0)*pcC0++ = curColors[idx];
-                    if (pcT0)*pcT0++ = curUVs[idx];
-                    if (pcT1)*pcT1++ = curUV2s[idx];
-
-                    if (++curIdx == 3)  {
-                        ++curFace;
-                        curIdx = 0;
-                    }
-                }
-
-                if (curFace != faceEnd)
-                    ASSIMP_LOG_ERROR("IRRMESH: Not enough indices");
-
-                // Finish processing the mesh - do some small material workarounds
-                if (curMatFlags & AI_IRRMESH_MAT_trans_vertex_alpha && !useColors)  {
-                    // Take the opacity value of the current material
-                    // from the common vertex color alpha
-                    aiMaterial* mat = (aiMaterial*)curMat;
-                    mat->AddProperty(&curColors[0].a,1,AI_MATKEY_OPACITY);
-                }
-            }}
-            break;
-
-            default:
-                // GCC complains here ...
-                break;
-
-        };
-    }
-
-    // End of the last buffer. A material and a mesh should be there
-    if (curMat || curMesh)  {
-        if ( !curMat || !curMesh)   {
-            ASSIMP_LOG_ERROR("IRRMESH: A buffer must contain a mesh and a material");
-            releaseMaterial( &curMat );
-            releaseMesh( &curMesh );
-        }
-        else    {
-            materials.push_back(curMat);
-            meshes.push_back(curMesh);
-        }
-    }
-
-    if (materials.empty())
-        throw DeadlyImportError("IRRMESH: Unable to read a mesh from this file");
-
-
-    // now generate the output scene
-    pScene->mNumMeshes = (unsigned int)meshes.size();
-    pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];
-    for (unsigned int i = 0; i < pScene->mNumMeshes;++i)    {
-        pScene->mMeshes[i] = meshes[i];
-
-        // clean this value ...
-        pScene->mMeshes[i]->mNumUVComponents[3] = 0;
-    }
-
-    pScene->mNumMaterials = (unsigned int)materials.size();
-    pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials];
-    ::memcpy(pScene->mMaterials,&materials[0],sizeof(void*)*pScene->mNumMaterials);
-
-    pScene->mRootNode = new aiNode();
-    pScene->mRootNode->mName.Set("<IRRMesh>");
-    pScene->mRootNode->mNumMeshes = pScene->mNumMeshes;
-    pScene->mRootNode->mMeshes = new unsigned int[pScene->mNumMeshes];
-
-    for (unsigned int i = 0; i < pScene->mNumMeshes;++i)
-        pScene->mRootNode->mMeshes[i] = i;
-
-    // clean up and return
-    delete reader;
-    AI_DEBUG_INVALIDATE_PTR(reader);
-}
-
-#endif // !! ASSIMP_BUILD_NO_IRRMESH_IMPORTER
diff --git a/Engine/lib/assimp/code/Irr/IRRShared.cpp b/Engine/lib/assimp/code/Irr/IRRShared.cpp
deleted file mode 100644
index ecac031ab..000000000
--- a/Engine/lib/assimp/code/Irr/IRRShared.cpp
+++ /dev/null
@@ -1,501 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-/** @file  IRRShared.cpp
- *  @brief Shared utilities for the IRR and IRRMESH loaders
- */
-
-
-
-//This section should be excluded only if both the Irrlicht AND the Irrlicht Mesh importers were omitted.
-#if !(defined(ASSIMP_BUILD_NO_IRR_IMPORTER) && defined(ASSIMP_BUILD_NO_IRRMESH_IMPORTER))
-
-#include "IRRShared.h"
-#include <assimp/ParsingUtils.h>
-#include <assimp/fast_atof.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/material.h>
-
-
-using namespace Assimp;
-using namespace irr;
-using namespace irr::io;
-
-// Transformation matrix to convert from Assimp to IRR space
-const aiMatrix4x4 Assimp::AI_TO_IRR_MATRIX = aiMatrix4x4 (
-    1.0f, 0.0f, 0.0f, 0.0f,
-    0.0f, 0.0f, 1.0f, 0.0f,
-    0.0f, 1.0f, 0.0f, 0.0f,
-    0.0f, 0.0f, 0.0f, 1.0f);
-
-// ------------------------------------------------------------------------------------------------
-// read a property in hexadecimal format (i.e. ffffffff)
-void IrrlichtBase::ReadHexProperty    (HexProperty&    out)
-{
-    for (int i = 0; i < reader->getAttributeCount();++i)
-    {
-        if (!ASSIMP_stricmp(reader->getAttributeName(i),"name"))
-        {
-            out.name = std::string( reader->getAttributeValue(i) );
-        }
-        else if (!ASSIMP_stricmp(reader->getAttributeName(i),"value"))
-        {
-            // parse the hexadecimal value
-            out.value = strtoul16(reader->getAttributeValue(i));
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// read a decimal property
-void IrrlichtBase::ReadIntProperty    (IntProperty&    out)
-{
-    for (int i = 0; i < reader->getAttributeCount();++i)
-    {
-        if (!ASSIMP_stricmp(reader->getAttributeName(i),"name"))
-        {
-            out.name = std::string( reader->getAttributeValue(i) );
-        }
-        else if (!ASSIMP_stricmp(reader->getAttributeName(i),"value"))
-        {
-            // parse the ecimal value
-            out.value = strtol10(reader->getAttributeValue(i));
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// read a string property
-void IrrlichtBase::ReadStringProperty (StringProperty& out)
-{
-    for (int i = 0; i < reader->getAttributeCount();++i)
-    {
-        if (!ASSIMP_stricmp(reader->getAttributeName(i),"name"))
-        {
-            out.name = std::string( reader->getAttributeValue(i) );
-        }
-        else if (!ASSIMP_stricmp(reader->getAttributeName(i),"value"))
-        {
-            // simple copy the string
-            out.value = std::string (reader->getAttributeValue(i));
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// read a boolean property
-void IrrlichtBase::ReadBoolProperty   (BoolProperty&   out)
-{
-    for (int i = 0; i < reader->getAttributeCount();++i)
-    {
-        if (!ASSIMP_stricmp(reader->getAttributeName(i),"name"))
-        {
-            out.name = std::string( reader->getAttributeValue(i) );
-        }
-        else if (!ASSIMP_stricmp(reader->getAttributeName(i),"value"))
-        {
-            // true or false, case insensitive
-            out.value = (ASSIMP_stricmp( reader->getAttributeValue(i),
-                "true") ? false : true);
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// read a float property
-void IrrlichtBase::ReadFloatProperty  (FloatProperty&  out)
-{
-    for (int i = 0; i < reader->getAttributeCount();++i)
-    {
-        if (!ASSIMP_stricmp(reader->getAttributeName(i),"name"))
-        {
-            out.name = std::string( reader->getAttributeValue(i) );
-        }
-        else if (!ASSIMP_stricmp(reader->getAttributeName(i),"value"))
-        {
-            // just parse the float
-            out.value = fast_atof( reader->getAttributeValue(i) );
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// read a vector property
-void IrrlichtBase::ReadVectorProperty  (VectorProperty&  out)
-{
-    for (int i = 0; i < reader->getAttributeCount();++i)
-    {
-        if (!ASSIMP_stricmp(reader->getAttributeName(i),"name"))
-        {
-            out.name = std::string( reader->getAttributeValue(i) );
-        }
-        else if (!ASSIMP_stricmp(reader->getAttributeName(i),"value"))
-        {
-            // three floats, separated with commas
-            const char* ptr = reader->getAttributeValue(i);
-
-            SkipSpaces(&ptr);
-            ptr = fast_atoreal_move<float>( ptr,(float&)out.value.x );
-            SkipSpaces(&ptr);
-            if (',' != *ptr)
-            {
-                ASSIMP_LOG_ERROR("IRR(MESH): Expected comma in vector definition");
-            }
-            else SkipSpaces(ptr+1,&ptr);
-            ptr = fast_atoreal_move<float>( ptr,(float&)out.value.y );
-            SkipSpaces(&ptr);
-            if (',' != *ptr)
-            {
-                ASSIMP_LOG_ERROR("IRR(MESH): Expected comma in vector definition");
-            }
-            else SkipSpaces(ptr+1,&ptr);
-            ptr = fast_atoreal_move<float>( ptr,(float&)out.value.z );
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Convert a string to a proper aiMappingMode
-int ConvertMappingMode(const std::string& mode)
-{
-    if (mode == "texture_clamp_repeat")
-    {
-        return aiTextureMapMode_Wrap;
-    }
-    else if (mode == "texture_clamp_mirror")
-        return aiTextureMapMode_Mirror;
-
-    return aiTextureMapMode_Clamp;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Parse a material from the XML file
-aiMaterial* IrrlichtBase::ParseMaterial(unsigned int& matFlags)
-{
-    aiMaterial* mat = new aiMaterial();
-    aiColor4D clr;
-    aiString s;
-
-    matFlags = 0; // zero output flags
-    int cnt  = 0; // number of used texture channels
-    unsigned int nd = 0;
-
-    // Continue reading from the file
-    while (reader->read())
-    {
-        switch (reader->getNodeType())
-        {
-        case EXN_ELEMENT:
-
-            // Hex properties
-            if (!ASSIMP_stricmp(reader->getNodeName(),"color"))
-            {
-                HexProperty prop;
-                ReadHexProperty(prop);
-                if (prop.name == "Diffuse")
-                {
-                    ColorFromARGBPacked(prop.value,clr);
-                    mat->AddProperty(&clr,1,AI_MATKEY_COLOR_DIFFUSE);
-                }
-                else if (prop.name == "Ambient")
-                {
-                    ColorFromARGBPacked(prop.value,clr);
-                    mat->AddProperty(&clr,1,AI_MATKEY_COLOR_AMBIENT);
-                }
-                else if (prop.name == "Specular")
-                {
-                    ColorFromARGBPacked(prop.value,clr);
-                    mat->AddProperty(&clr,1,AI_MATKEY_COLOR_SPECULAR);
-                }
-
-                // NOTE: The 'emissive' property causes problems. It is
-                // often != 0, even if there is obviously no light
-                // emitted by the described surface. In fact I think
-                // IRRLICHT ignores this property, too.
-#if 0
-                else if (prop.name == "Emissive")
-                {
-                    ColorFromARGBPacked(prop.value,clr);
-                    mat->AddProperty(&clr,1,AI_MATKEY_COLOR_EMISSIVE);
-                }
-#endif
-            }
-            // Float properties
-            else if (!ASSIMP_stricmp(reader->getNodeName(),"float"))
-            {
-                FloatProperty prop;
-                ReadFloatProperty(prop);
-                if (prop.name == "Shininess")
-                {
-                    mat->AddProperty(&prop.value,1,AI_MATKEY_SHININESS);
-                }
-            }
-            // Bool properties
-            else if (!ASSIMP_stricmp(reader->getNodeName(),"bool"))
-            {
-                BoolProperty prop;
-                ReadBoolProperty(prop);
-                if (prop.name == "Wireframe")
-                {
-                    int val = (prop.value ? true : false);
-                    mat->AddProperty(&val,1,AI_MATKEY_ENABLE_WIREFRAME);
-                }
-                else if (prop.name == "GouraudShading")
-                {
-                    int val = (prop.value ? aiShadingMode_Gouraud
-                        : aiShadingMode_NoShading);
-                    mat->AddProperty(&val,1,AI_MATKEY_SHADING_MODEL);
-                }
-                else if (prop.name == "BackfaceCulling")
-                {
-                    int val = (!prop.value);
-                    mat->AddProperty(&val,1,AI_MATKEY_TWOSIDED);
-                }
-            }
-            // String properties - textures and texture related properties
-            else if (!ASSIMP_stricmp(reader->getNodeName(),"texture") ||
-                     !ASSIMP_stricmp(reader->getNodeName(),"enum"))
-            {
-                StringProperty prop;
-                ReadStringProperty(prop);
-                if (prop.value.length())
-                {
-                    // material type (shader)
-                    if (prop.name == "Type")
-                    {
-                        if (prop.value == "solid")
-                        {
-                            // default material ...
-                        }
-                        else if (prop.value == "trans_vertex_alpha")
-                        {
-                            matFlags = AI_IRRMESH_MAT_trans_vertex_alpha;
-                        }
-                        else if (prop.value == "lightmap")
-                        {
-                            matFlags = AI_IRRMESH_MAT_lightmap;
-                        }
-                        else if (prop.value == "solid_2layer")
-                        {
-                            matFlags = AI_IRRMESH_MAT_solid_2layer;
-                        }
-                        else if (prop.value == "lightmap_m2")
-                        {
-                            matFlags = AI_IRRMESH_MAT_lightmap_m2;
-                        }
-                        else if (prop.value == "lightmap_m4")
-                        {
-                            matFlags = AI_IRRMESH_MAT_lightmap_m4;
-                        }
-                        else if (prop.value == "lightmap_light")
-                        {
-                            matFlags = AI_IRRMESH_MAT_lightmap_light;
-                        }
-                        else if (prop.value == "lightmap_light_m2")
-                        {
-                            matFlags = AI_IRRMESH_MAT_lightmap_light_m2;
-                        }
-                        else if (prop.value == "lightmap_light_m4")
-                        {
-                            matFlags = AI_IRRMESH_MAT_lightmap_light_m4;
-                        }
-                        else if (prop.value == "lightmap_add")
-                        {
-                            matFlags = AI_IRRMESH_MAT_lightmap_add;
-                        }
-                        // Normal and parallax maps are treated equally
-                        else if (prop.value == "normalmap_solid" ||
-                            prop.value == "parallaxmap_solid")
-                        {
-                            matFlags = AI_IRRMESH_MAT_normalmap_solid;
-                        }
-                        else if (prop.value == "normalmap_trans_vertex_alpha" ||
-                            prop.value == "parallaxmap_trans_vertex_alpha")
-                        {
-                            matFlags = AI_IRRMESH_MAT_normalmap_tva;
-                        }
-                        else if (prop.value == "normalmap_trans_add" ||
-                            prop.value == "parallaxmap_trans_add")
-                        {
-                            matFlags = AI_IRRMESH_MAT_normalmap_ta;
-                        }
-                        else {
-                            ASSIMP_LOG_WARN("IRRMat: Unrecognized material type: " + prop.value);
-                        }
-                    }
-
-                    // Up to 4 texture channels are supported
-                    if (prop.name == "Texture1")
-                    {
-                        // Always accept the primary texture channel
-                        ++cnt;
-                        s.Set(prop.value);
-                        mat->AddProperty(&s,AI_MATKEY_TEXTURE_DIFFUSE(0));
-                    }
-                    else if (prop.name == "Texture2" && cnt == 1)
-                    {
-                        // 2-layer material lightmapped?
-                        if (matFlags & AI_IRRMESH_MAT_lightmap) {
-                            ++cnt;
-                            s.Set(prop.value);
-                            mat->AddProperty(&s,AI_MATKEY_TEXTURE_LIGHTMAP(0));
-
-                            // set the corresponding material flag
-                            matFlags |= AI_IRRMESH_EXTRA_2ND_TEXTURE;
-                        }
-                        // alternatively: normal or parallax mapping
-                        else if (matFlags & AI_IRRMESH_MAT_normalmap_solid) {
-                            ++cnt;
-                            s.Set(prop.value);
-                            mat->AddProperty(&s,AI_MATKEY_TEXTURE_NORMALS(0));
-
-                            // set the corresponding material flag
-                            matFlags |= AI_IRRMESH_EXTRA_2ND_TEXTURE;
-                        } else if (matFlags & AI_IRRMESH_MAT_solid_2layer)    {// or just as second diffuse texture
-                            ++cnt;
-                            s.Set(prop.value);
-                            mat->AddProperty(&s,AI_MATKEY_TEXTURE_DIFFUSE(1));
-                            ++nd;
-
-                            // set the corresponding material flag
-                            matFlags |= AI_IRRMESH_EXTRA_2ND_TEXTURE;
-                        } else {
-                            ASSIMP_LOG_WARN("IRRmat: Skipping second texture");
-                        }
-                    } else if (prop.name == "Texture3" && cnt == 2) {
-                        // Irrlicht does not seem to use these channels.
-                        ++cnt;
-                        s.Set(prop.value);
-                        mat->AddProperty(&s,AI_MATKEY_TEXTURE_DIFFUSE(nd+1));
-                    } else if (prop.name == "Texture4" && cnt == 3) {
-                        // Irrlicht does not seem to use these channels.
-                        ++cnt;
-                        s.Set(prop.value);
-                        mat->AddProperty(&s,AI_MATKEY_TEXTURE_DIFFUSE(nd+2));
-                    }
-
-                    // Texture mapping options
-                    if (prop.name == "TextureWrap1" && cnt >= 1)
-                    {
-                        int map = ConvertMappingMode(prop.value);
-                        mat->AddProperty(&map,1,AI_MATKEY_MAPPINGMODE_U_DIFFUSE(0));
-                        mat->AddProperty(&map,1,AI_MATKEY_MAPPINGMODE_V_DIFFUSE(0));
-                    }
-                    else if (prop.name == "TextureWrap2" && cnt >= 2)
-                    {
-                        int map = ConvertMappingMode(prop.value);
-                        if (matFlags & AI_IRRMESH_MAT_lightmap) {
-                            mat->AddProperty(&map,1,AI_MATKEY_MAPPINGMODE_U_LIGHTMAP(0));
-                            mat->AddProperty(&map,1,AI_MATKEY_MAPPINGMODE_V_LIGHTMAP(0));
-                        }
-                        else if (matFlags & (AI_IRRMESH_MAT_normalmap_solid)) {
-                            mat->AddProperty(&map,1,AI_MATKEY_MAPPINGMODE_U_NORMALS(0));
-                            mat->AddProperty(&map,1,AI_MATKEY_MAPPINGMODE_V_NORMALS(0));
-                        }
-                        else if (matFlags & AI_IRRMESH_MAT_solid_2layer) {
-                            mat->AddProperty(&map,1,AI_MATKEY_MAPPINGMODE_U_DIFFUSE(1));
-                            mat->AddProperty(&map,1,AI_MATKEY_MAPPINGMODE_V_DIFFUSE(1));
-                        }
-                    }
-                    else if (prop.name == "TextureWrap3" && cnt >= 3)
-                    {
-                        int map = ConvertMappingMode(prop.value);
-                        mat->AddProperty(&map,1,AI_MATKEY_MAPPINGMODE_U_DIFFUSE(nd+1));
-                        mat->AddProperty(&map,1,AI_MATKEY_MAPPINGMODE_V_DIFFUSE(nd+1));
-                    }
-                    else if (prop.name == "TextureWrap4" && cnt >= 4)
-                    {
-                        int map = ConvertMappingMode(prop.value);
-                        mat->AddProperty(&map,1,AI_MATKEY_MAPPINGMODE_U_DIFFUSE(nd+2));
-                        mat->AddProperty(&map,1,AI_MATKEY_MAPPINGMODE_V_DIFFUSE(nd+2));
-                    }
-                }
-            }
-            break;
-            case EXN_ELEMENT_END:
-
-                /* Assume there are no further nested nodes in <material> elements
-                 */
-                if (/* IRRMESH */ !ASSIMP_stricmp(reader->getNodeName(),"material") ||
-                    /* IRR     */ !ASSIMP_stricmp(reader->getNodeName(),"attributes"))
-                {
-                    // Now process lightmapping flags
-                    // We should have at least one textur to do that ..
-                    if (cnt && matFlags & AI_IRRMESH_MAT_lightmap)
-                    {
-                        float f = 1.f;
-                        unsigned int unmasked = matFlags&~AI_IRRMESH_MAT_lightmap;
-
-                        // Additive lightmap?
-                        int op = (unmasked & AI_IRRMESH_MAT_lightmap_add
-                            ? aiTextureOp_Add : aiTextureOp_Multiply);
-
-                        // Handle Irrlicht's lightmapping scaling factor
-                        if (unmasked & AI_IRRMESH_MAT_lightmap_m2 ||
-                            unmasked & AI_IRRMESH_MAT_lightmap_light_m2)
-                        {
-                            f = 2.f;
-                        }
-                        else if (unmasked & AI_IRRMESH_MAT_lightmap_m4 ||
-                            unmasked & AI_IRRMESH_MAT_lightmap_light_m4)
-                        {
-                            f = 4.f;
-                        }
-                        mat->AddProperty( &f, 1, AI_MATKEY_TEXBLEND_LIGHTMAP(0));
-                        mat->AddProperty( &op,1, AI_MATKEY_TEXOP_LIGHTMAP(0));
-                    }
-
-                    return mat;
-                }
-            default:
-
-                // GCC complains here ...
-                break;
-        }
-    }
-    ASSIMP_LOG_ERROR("IRRMESH: Unexpected end of file. Material is not complete");
-
-    return mat;
-}
-
-#endif // !(defined(ASSIMP_BUILD_NO_IRR_IMPORTER) && defined(ASSIMP_BUILD_NO_IRRMESH_IMPORTER))
diff --git a/Engine/lib/assimp/code/LWO/LWOFileData.h b/Engine/lib/assimp/code/LWO/LWOFileData.h
deleted file mode 100644
index 7d1f6b1df..000000000
--- a/Engine/lib/assimp/code/LWO/LWOFileData.h
+++ /dev/null
@@ -1,703 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file LWOFileData.h
- *  @brief Defines chunk constants used by the LWO file format
-
-The chunks are taken from the official LightWave SDK headers.
-
-*/
-#ifndef AI_LWO_FILEDATA_INCLUDED
-#define AI_LWO_FILEDATA_INCLUDED
-
-// STL headers
-#include <vector>
-#include <list>
-
-// public ASSIMP headers
-#include <assimp/mesh.h>
-
-// internal headers
-#include "Common/IFF.h"
-#include "LWO/LWOAnimation.h"
-
-namespace Assimp {
-namespace LWO {
-
-#define AI_LWO_FOURCC_LWOB AI_IFF_FOURCC('L','W','O','B')
-#define AI_LWO_FOURCC_LWO2 AI_IFF_FOURCC('L','W','O','2')
-#define AI_LWO_FOURCC_LXOB AI_IFF_FOURCC('L','X','O','B')
-
-// chunks specific to the LWOB format
-#define AI_LWO_SRFS  AI_IFF_FOURCC('S','R','F','S')
-#define AI_LWO_FLAG  AI_IFF_FOURCC('F','L','A','G')
-#define AI_LWO_VLUM  AI_IFF_FOURCC('V','L','U','M')
-#define AI_LWO_VDIF  AI_IFF_FOURCC('V','D','I','F')
-#define AI_LWO_VSPC  AI_IFF_FOURCC('V','S','P','C')
-#define AI_LWO_RFLT  AI_IFF_FOURCC('R','F','L','T')
-#define AI_LWO_BTEX  AI_IFF_FOURCC('B','T','E','X')
-#define AI_LWO_CTEX  AI_IFF_FOURCC('C','T','E','X')
-#define AI_LWO_DTEX  AI_IFF_FOURCC('D','T','E','X')
-#define AI_LWO_LTEX  AI_IFF_FOURCC('L','T','E','X')
-#define AI_LWO_RTEX  AI_IFF_FOURCC('R','T','E','X')
-#define AI_LWO_STEX  AI_IFF_FOURCC('S','T','E','X')
-#define AI_LWO_TTEX  AI_IFF_FOURCC('T','T','E','X')
-#define AI_LWO_TFLG  AI_IFF_FOURCC('T','F','L','G')
-#define AI_LWO_TSIZ  AI_IFF_FOURCC('T','S','I','Z')
-#define AI_LWO_TCTR  AI_IFF_FOURCC('T','C','T','R')
-#define AI_LWO_TFAL  AI_IFF_FOURCC('T','F','A','L')
-#define AI_LWO_TVEL  AI_IFF_FOURCC('T','V','E','L')
-#define AI_LWO_TCLR  AI_IFF_FOURCC('T','C','L','R')
-#define AI_LWO_TVAL  AI_IFF_FOURCC('T','V','A','L')
-#define AI_LWO_TAMP  AI_IFF_FOURCC('T','A','M','P')
-#define AI_LWO_TIMG  AI_IFF_FOURCC('T','I','M','G')
-#define AI_LWO_TAAS  AI_IFF_FOURCC('T','A','A','S')
-#define AI_LWO_TREF  AI_IFF_FOURCC('T','R','E','F')
-#define AI_LWO_TOPC  AI_IFF_FOURCC('T','O','P','C')
-#define AI_LWO_SDAT  AI_IFF_FOURCC('S','D','A','T')
-#define AI_LWO_TFP0  AI_IFF_FOURCC('T','F','P','0')
-#define AI_LWO_TFP1  AI_IFF_FOURCC('T','F','P','1')
-
-
-/* top-level chunks */
-#define AI_LWO_LAYR  AI_IFF_FOURCC('L','A','Y','R')
-#define AI_LWO_TAGS  AI_IFF_FOURCC('T','A','G','S')
-#define AI_LWO_PNTS  AI_IFF_FOURCC('P','N','T','S')
-#define AI_LWO_BBOX  AI_IFF_FOURCC('B','B','O','X')
-#define AI_LWO_VMAP  AI_IFF_FOURCC('V','M','A','P')
-#define AI_LWO_VMAD  AI_IFF_FOURCC('V','M','A','D')
-#define AI_LWO_POLS  AI_IFF_FOURCC('P','O','L','S')
-#define AI_LWO_PTAG  AI_IFF_FOURCC('P','T','A','G')
-#define AI_LWO_ENVL  AI_IFF_FOURCC('E','N','V','L')
-#define AI_LWO_CLIP  AI_IFF_FOURCC('C','L','I','P')
-#define AI_LWO_SURF  AI_IFF_FOURCC('S','U','R','F')
-#define AI_LWO_DESC  AI_IFF_FOURCC('D','E','S','C')
-#define AI_LWO_TEXT  AI_IFF_FOURCC('T','E','X','T')
-#define AI_LWO_ICON  AI_IFF_FOURCC('I','C','O','N')
-
-/* polygon types */
-#define AI_LWO_FACE  AI_IFF_FOURCC('F','A','C','E')
-#define AI_LWO_CURV  AI_IFF_FOURCC('C','U','R','V')
-#define AI_LWO_PTCH  AI_IFF_FOURCC('P','T','C','H')
-#define AI_LWO_MBAL  AI_IFF_FOURCC('M','B','A','L')
-#define AI_LWO_BONE  AI_IFF_FOURCC('B','O','N','E')
-#define AI_LWO_SUBD  AI_IFF_FOURCC('S','U','B','D')
-
-/* polygon tags */
-#define AI_LWO_SURF  AI_IFF_FOURCC('S','U','R','F')
-#define AI_LWO_PART  AI_IFF_FOURCC('P','A','R','T')
-#define AI_LWO_SMGP  AI_IFF_FOURCC('S','M','G','P')
-
-/* envelopes */
-#define AI_LWO_PRE   AI_IFF_FOURCC('P','R','E',' ')
-#define AI_LWO_POST  AI_IFF_FOURCC('P','O','S','T')
-#define AI_LWO_KEY   AI_IFF_FOURCC('K','E','Y',' ')
-#define AI_LWO_SPAN  AI_IFF_FOURCC('S','P','A','N')
-#define AI_LWO_TCB   AI_IFF_FOURCC('T','C','B',' ')
-#define AI_LWO_HERM  AI_IFF_FOURCC('H','E','R','M')
-#define AI_LWO_BEZI  AI_IFF_FOURCC('B','E','Z','I')
-#define AI_LWO_BEZ2  AI_IFF_FOURCC('B','E','Z','2')
-#define AI_LWO_LINE  AI_IFF_FOURCC('L','I','N','E')
-#define AI_LWO_STEP  AI_IFF_FOURCC('S','T','E','P')
-
-/* clips */
-#define AI_LWO_STIL  AI_IFF_FOURCC('S','T','I','L')
-#define AI_LWO_ISEQ  AI_IFF_FOURCC('I','S','E','Q')
-#define AI_LWO_ANIM  AI_IFF_FOURCC('A','N','I','M')
-#define AI_LWO_XREF  AI_IFF_FOURCC('X','R','E','F')
-#define AI_LWO_STCC  AI_IFF_FOURCC('S','T','C','C')
-#define AI_LWO_TIME  AI_IFF_FOURCC('T','I','M','E')
-#define AI_LWO_CONT  AI_IFF_FOURCC('C','O','N','T')
-#define AI_LWO_BRIT  AI_IFF_FOURCC('B','R','I','T')
-#define AI_LWO_SATR  AI_IFF_FOURCC('S','A','T','R')
-#define AI_LWO_HUE   AI_IFF_FOURCC('H','U','E',' ')
-#define AI_LWO_GAMM  AI_IFF_FOURCC('G','A','M','M')
-#define AI_LWO_NEGA  AI_IFF_FOURCC('N','E','G','A')
-#define AI_LWO_IFLT  AI_IFF_FOURCC('I','F','L','T')
-#define AI_LWO_PFLT  AI_IFF_FOURCC('P','F','L','T')
-
-/* surfaces */
-#define AI_LWO_COLR  AI_IFF_FOURCC('C','O','L','R')
-#define AI_LWO_LUMI  AI_IFF_FOURCC('L','U','M','I')
-#define AI_LWO_DIFF  AI_IFF_FOURCC('D','I','F','F')
-#define AI_LWO_SPEC  AI_IFF_FOURCC('S','P','E','C')
-#define AI_LWO_GLOS  AI_IFF_FOURCC('G','L','O','S')
-#define AI_LWO_REFL  AI_IFF_FOURCC('R','E','F','L')
-#define AI_LWO_RFOP  AI_IFF_FOURCC('R','F','O','P')
-#define AI_LWO_RIMG  AI_IFF_FOURCC('R','I','M','G')
-#define AI_LWO_RSAN  AI_IFF_FOURCC('R','S','A','N')
-#define AI_LWO_TRAN  AI_IFF_FOURCC('T','R','A','N')
-#define AI_LWO_TROP  AI_IFF_FOURCC('T','R','O','P')
-#define AI_LWO_TIMG  AI_IFF_FOURCC('T','I','M','G')
-#define AI_LWO_RIND  AI_IFF_FOURCC('R','I','N','D')
-#define AI_LWO_TRNL  AI_IFF_FOURCC('T','R','N','L')
-#define AI_LWO_BUMP  AI_IFF_FOURCC('B','U','M','P')
-#define AI_LWO_SMAN  AI_IFF_FOURCC('S','M','A','N')
-#define AI_LWO_SIDE  AI_IFF_FOURCC('S','I','D','E')
-#define AI_LWO_CLRH  AI_IFF_FOURCC('C','L','R','H')
-#define AI_LWO_CLRF  AI_IFF_FOURCC('C','L','R','F')
-#define AI_LWO_ADTR  AI_IFF_FOURCC('A','D','T','R')
-#define AI_LWO_SHRP  AI_IFF_FOURCC('S','H','R','P')
-#define AI_LWO_LINE  AI_IFF_FOURCC('L','I','N','E')
-#define AI_LWO_LSIZ  AI_IFF_FOURCC('L','S','I','Z')
-#define AI_LWO_ALPH  AI_IFF_FOURCC('A','L','P','H')
-#define AI_LWO_AVAL  AI_IFF_FOURCC('A','V','A','L')
-#define AI_LWO_GVAL  AI_IFF_FOURCC('G','V','A','L')
-#define AI_LWO_BLOK  AI_IFF_FOURCC('B','L','O','K')
-#define AI_LWO_VCOL  AI_IFF_FOURCC('V','C','O','L')
-
-/* texture layer */
-#define AI_LWO_TYPE  AI_IFF_FOURCC('T','Y','P','E')
-#define AI_LWO_CHAN  AI_IFF_FOURCC('C','H','A','N')
-#define AI_LWO_NAME  AI_IFF_FOURCC('N','A','M','E')
-#define AI_LWO_ENAB  AI_IFF_FOURCC('E','N','A','B')
-#define AI_LWO_OPAC  AI_IFF_FOURCC('O','P','A','C')
-#define AI_LWO_FLAG  AI_IFF_FOURCC('F','L','A','G')
-#define AI_LWO_PROJ  AI_IFF_FOURCC('P','R','O','J')
-#define AI_LWO_STCK  AI_IFF_FOURCC('S','T','C','K')
-#define AI_LWO_TAMP  AI_IFF_FOURCC('T','A','M','P')
-
-/* texture coordinates */
-#define AI_LWO_TMAP  AI_IFF_FOURCC('T','M','A','P')
-#define AI_LWO_AXIS  AI_IFF_FOURCC('A','X','I','S')
-#define AI_LWO_CNTR  AI_IFF_FOURCC('C','N','T','R')
-#define AI_LWO_SIZE  AI_IFF_FOURCC('S','I','Z','E')
-#define AI_LWO_ROTA  AI_IFF_FOURCC('R','O','T','A')
-#define AI_LWO_OREF  AI_IFF_FOURCC('O','R','E','F')
-#define AI_LWO_FALL  AI_IFF_FOURCC('F','A','L','L')
-#define AI_LWO_CSYS  AI_IFF_FOURCC('C','S','Y','S')
-
-/* image map */
-#define AI_LWO_IMAP  AI_IFF_FOURCC('I','M','A','P')
-#define AI_LWO_IMAG  AI_IFF_FOURCC('I','M','A','G')
-#define AI_LWO_WRAP  AI_IFF_FOURCC('W','R','A','P')
-#define AI_LWO_WRPW  AI_IFF_FOURCC('W','R','P','W')
-#define AI_LWO_WRPH  AI_IFF_FOURCC('W','R','P','H')
-#define AI_LWO_VMAP  AI_IFF_FOURCC('V','M','A','P')
-#define AI_LWO_AAST  AI_IFF_FOURCC('A','A','S','T')
-#define AI_LWO_PIXB  AI_IFF_FOURCC('P','I','X','B')
-
-/* procedural */
-#define AI_LWO_PROC  AI_IFF_FOURCC('P','R','O','C')
-#define AI_LWO_COLR  AI_IFF_FOURCC('C','O','L','R')
-#define AI_LWO_VALU  AI_IFF_FOURCC('V','A','L','U')
-#define AI_LWO_FUNC  AI_IFF_FOURCC('F','U','N','C')
-#define AI_LWO_FTPS  AI_IFF_FOURCC('F','T','P','S')
-#define AI_LWO_ITPS  AI_IFF_FOURCC('I','T','P','S')
-#define AI_LWO_ETPS  AI_IFF_FOURCC('E','T','P','S')
-
-/* gradient */
-#define AI_LWO_GRAD  AI_IFF_FOURCC('G','R','A','D')
-#define AI_LWO_GRST  AI_IFF_FOURCC('G','R','S','T')
-#define AI_LWO_GREN  AI_IFF_FOURCC('G','R','E','N')
-#define AI_LWO_PNAM  AI_IFF_FOURCC('P','N','A','M')
-#define AI_LWO_INAM  AI_IFF_FOURCC('I','N','A','M')
-#define AI_LWO_GRPT  AI_IFF_FOURCC('G','R','P','T')
-#define AI_LWO_FKEY  AI_IFF_FOURCC('F','K','E','Y')
-#define AI_LWO_IKEY  AI_IFF_FOURCC('I','K','E','Y')
-
-/* shader */
-#define AI_LWO_SHDR  AI_IFF_FOURCC('S','H','D','R')
-#define AI_LWO_DATA  AI_IFF_FOURCC('D','A','T','A')
-
-
-/* VMAP types */
-#define AI_LWO_TXUV  AI_IFF_FOURCC('T','X','U','V')
-#define AI_LWO_RGB   AI_IFF_FOURCC('R','G','B',' ')
-#define AI_LWO_RGBA  AI_IFF_FOURCC('R','G','B','A')
-#define AI_LWO_WGHT  AI_IFF_FOURCC('W','G','H','T')
-
-#define AI_LWO_MNVW  AI_IFF_FOURCC('M','N','V','W')
-#define AI_LWO_MORF  AI_IFF_FOURCC('M','O','R','F')
-#define AI_LWO_SPOT  AI_IFF_FOURCC('S','P','O','T')
-#define AI_LWO_PICK  AI_IFF_FOURCC('P','I','C','K')
-
-// MODO extension - per-vertex normal vectors
-#define AI_LWO_MODO_NORM AI_IFF_FOURCC('N', 'O', 'R', 'M')
-
-
-// ---------------------------------------------------------------------------
-/** \brief Data structure for a face in a LWO file
- *
- * \note We can't use the code in SmoothingGroups.inl here - the mesh
- *   structures of 3DS/ASE and LWO are too different.
- */
-struct Face : public aiFace {
-    //! Default construction
-    Face() AI_NO_EXCEPT
-    : surfaceIndex( 0 )
-    , smoothGroup( 0 )
-    , type( AI_LWO_FACE ) {
-        // empty
-    }
-
-    //! Construction from given type
-    explicit Face(uint32_t _type)
-        : surfaceIndex  (0)
-        , smoothGroup   (0)
-        , type          (_type)
-    {}
-
-    //! Copy construction
-    Face(const Face& f) : aiFace() {
-        *this = f;
-    }
-
-    //! Zero-based index into tags chunk
-    unsigned int surfaceIndex;
-
-    //! Smooth group this face is assigned to
-    unsigned int smoothGroup;
-
-    //! Type of face
-    uint32_t type;
-
-
-    //! Assignment operator
-    Face& operator=(const LWO::Face& f) {
-        aiFace::operator =(f);
-        surfaceIndex    = f.surfaceIndex;
-        smoothGroup     = f.smoothGroup;
-        type            = f.type;
-        return *this;
-    }
-};
-
-// ---------------------------------------------------------------------------
-/** \brief Base structure for all vertex map representations
- */
-struct VMapEntry
-{
-    explicit VMapEntry(unsigned int _dims)
-        :  dims(_dims)
-    {}
-
-    virtual ~VMapEntry() {}
-
-    //! allocates memory for the vertex map
-    virtual void Allocate(unsigned int num)
-    {
-        if (!rawData.empty())
-            return; // return if already allocated
-
-        const unsigned int m = num*dims;
-        rawData.reserve(m + (m>>2u)); // 25% as  extra storage for VMADs
-        rawData.resize(m,0.f);
-        abAssigned.resize(num,false);
-    }
-
-    std::string name;
-    unsigned int dims;
-
-    std::vector<float> rawData;
-    std::vector<bool> abAssigned;
-};
-
-// ---------------------------------------------------------------------------
-/** \brief Represents an extra vertex color channel
- */
-struct VColorChannel : public VMapEntry
-{
-    VColorChannel()
-        : VMapEntry(4)
-    {}
-
-    //! need to overwrite this function - the alpha channel must
-    //! be initialized to 1.0 by default
-    virtual void Allocate(unsigned int num)
-    {
-        if (!rawData.empty())
-            return; // return if already allocated
-
-        unsigned int m = num*dims;
-        rawData.reserve(m + (m>>2u)); // 25% as  extra storage for VMADs
-        rawData.resize(m);
-
-        for (aiColor4D* p = (aiColor4D*)&rawData[0]; p < (aiColor4D*)&rawData[m-1]; ++p)
-            p->a = 1.f;
-
-        abAssigned.resize(num,false);
-    }
-};
-
-// ---------------------------------------------------------------------------
-/** \brief Represents an extra vertex UV channel
- */
-struct UVChannel : public VMapEntry
-{
-    UVChannel()
-        : VMapEntry(2)
-    {}
-};
-
-// ---------------------------------------------------------------------------
-/** \brief Represents a weight map
- */
-struct WeightChannel : public VMapEntry
-{
-    WeightChannel()
-        : VMapEntry(1)
-    {}
-};
-
-// ---------------------------------------------------------------------------
-/** \brief Represents a vertex-normals channel (MODO extension)
- */
-struct NormalChannel : public VMapEntry
-{
-    NormalChannel()
-        : VMapEntry(3)
-    {}
-};
-
-// ---------------------------------------------------------------------------
-/** \brief Data structure for a LWO file texture
- */
-struct Texture
-{
-    // we write the enum values out here to make debugging easier ...
-    enum BlendType
-    {
-        Normal          = 0,
-        Subtractive     = 1,
-        Difference      = 2,
-        Multiply        = 3,
-        Divide          = 4,
-        Alpha           = 5,
-        TextureDispl    = 6,
-        Additive        = 7
-    };
-
-    enum MappingMode
-    {
-        Planar          = 0,
-        Cylindrical     = 1,
-        Spherical       = 2,
-        Cubic           = 3,
-        FrontProjection = 4,
-        UV              = 5
-    };
-
-    enum Axes
-    {
-        AXIS_X          = 0,
-        AXIS_Y          = 1,
-        AXIS_Z          = 2
-    };
-
-    enum Wrap
-    {
-        RESET           = 0,
-        REPEAT          = 1,
-        MIRROR          = 2,
-        EDGE            = 3
-    };
-
-    Texture()
-        : mClipIdx(UINT_MAX)
-        , mStrength         (1.0f)
-        , type()
-        , mUVChannelIndex   ("unknown")
-        , mRealUVIndex      (UINT_MAX)
-        , enabled           (true)
-        , blendType         (Additive)
-        , bCanUse           (true)
-        , mapMode           (UV)
-        , majorAxis         (AXIS_X)
-        , wrapAmountH       (1.0f)
-        , wrapAmountW       (1.0f)
-        , wrapModeWidth     (REPEAT)
-        , wrapModeHeight    (REPEAT)
-        , ordinal           ("\x00")
-    {}
-
-    //! File name of the texture
-    std::string mFileName;
-
-    //! Clip index
-    unsigned int mClipIdx;
-
-    //! Strength of the texture - blend factor
-    float mStrength;
-
-    uint32_t type; // type of the texture
-
-    //! Name of the corresponding UV channel
-    std::string mUVChannelIndex;
-    unsigned int mRealUVIndex;
-
-    //! is the texture enabled?
-    bool enabled;
-
-    //! blend type
-    BlendType blendType;
-
-    //! are we able to use the texture?
-    bool bCanUse;
-
-    //! mapping mode
-    MappingMode mapMode;
-
-    //! major axis for planar, cylindrical, spherical projections
-    Axes majorAxis;
-
-    //! wrap amount for cylindrical and spherical projections
-    float wrapAmountH,wrapAmountW;
-
-    //! wrapping mode for the texture
-    Wrap wrapModeWidth,wrapModeHeight;
-
-    //! ordinal string of the texture
-    std::string ordinal;
-};
-
-// ---------------------------------------------------------------------------
-/** \brief Data structure for a LWO file clip
- */
-struct Clip
-{
-    enum Type
-    {
-         STILL, SEQ, REF, UNSUPPORTED
-    } type;
-
-    Clip()
-        : type   (UNSUPPORTED)
-        , clipRef()
-        , idx    (0)
-        , negate (false)
-    {}
-
-    //! path to the base texture -
-    std::string path;
-
-    //! reference to another CLIP
-    unsigned int clipRef;
-
-    //! index of the clip
-    unsigned int idx;
-
-    //! Negate the clip?
-    bool negate;
-};
-
-
-// ---------------------------------------------------------------------------
-/** \brief Data structure for a LWO file shader
- *
- *  Later
- */
-struct Shader
-{
-    Shader()
-        :   ordinal         ("\x00")
-        ,   functionName    ("unknown")
-        ,   enabled         (true)
-    {}
-
-    std::string ordinal;
-    std::string functionName;
-    bool enabled;
-};
-
-typedef std::list < Texture >       TextureList;
-typedef std::list < Shader >        ShaderList;
-
-// ---------------------------------------------------------------------------
-/** \brief Data structure for a LWO file surface (= material)
- */
-struct Surface
-{
-    Surface()
-        : mColor                (0.78431f,0.78431f,0.78431f)
-        , bDoubleSided          (false)
-        , mDiffuseValue         (1.f)
-        , mSpecularValue        (0.f)
-        , mTransparency         (0.f)
-        , mGlossiness           (0.4f)
-        , mLuminosity           (0.f)
-        , mColorHighlights      (0.f)
-        , mMaximumSmoothAngle   (0.f) // 0 == not specified, no smoothing
-        , mVCMap                ("")
-        , mVCMapType            (AI_LWO_RGBA)
-        , mIOR                  (1.f) // vakuum
-        , mBumpIntensity        (1.f)
-        , mWireframe            (false)
-        , mAdditiveTransparency (0.f)
-    {}
-
-    //! Name of the surface
-    std::string mName;
-
-    //! Color of the surface
-    aiColor3D mColor;
-
-    //! true for two-sided materials
-    bool bDoubleSided;
-
-    //! Various material parameters
-    float mDiffuseValue,mSpecularValue,mTransparency,mGlossiness,mLuminosity,mColorHighlights;
-
-    //! Maximum angle between two adjacent triangles
-    //! that they can be smoothed - in degrees
-    float mMaximumSmoothAngle;
-
-    //! Vertex color map to be used to color the surface
-    std::string mVCMap;
-    uint32_t mVCMapType;
-
-    //! Names of the special shaders to be applied to the surface
-    ShaderList mShaders;
-
-    //! Textures - the first entry in the list is evaluated first
-    TextureList mColorTextures, // color textures are added to both diffuse and specular texture stacks
-        mDiffuseTextures,
-        mSpecularTextures,
-        mOpacityTextures,
-        mBumpTextures,
-        mGlossinessTextures,
-        mReflectionTextures;
-
-    //! Index of refraction
-    float mIOR;
-
-    //! Bump intensity scaling
-    float mBumpIntensity;
-
-    //! Wireframe flag
-    bool mWireframe;
-
-    //! Intensity of additive blending
-    float mAdditiveTransparency;
-};
-
-// ---------------------------------------------------------------------------
-#define AI_LWO_VALIDATE_CHUNK_LENGTH(length,name,size) \
-    if (length < size) \
-    { \
-        throw DeadlyImportError("LWO: "#name" chunk is too small"); \
-    } \
-
-
-// some typedefs ... to make life with loader monsters like this easier
-typedef std::vector <   aiVector3D      >   PointList;
-typedef std::vector <   LWO::Face       >   FaceList;
-typedef std::vector <   LWO::Surface    >   SurfaceList;
-typedef std::vector <   std::string     >   TagList;
-typedef std::vector <   unsigned int    >   TagMappingTable;
-typedef std::vector <   unsigned int    >   ReferrerList;
-typedef std::vector <   WeightChannel   >   WeightChannelList;
-typedef std::vector <   VColorChannel   >   VColorChannelList;
-typedef std::vector <   UVChannel       >   UVChannelList;
-typedef std::vector <   Clip            >   ClipList;
-typedef std::vector <   Envelope        >   EnvelopeList;
-typedef std::vector <   unsigned int    >   SortedRep;
-
-// ---------------------------------------------------------------------------
-/** \brief Represents a layer in the file
- */
-struct Layer
-{
-    Layer()
-        : mFaceIDXOfs   (0)
-        , mPointIDXOfs  (0)
-        , mParent       (0x0)
-        , mIndex        (0xffff)
-        , skip          (false)
-    {}
-
-    /** Temporary point list from the file */
-    PointList mTempPoints;
-
-    /** Lists for every point the index of another point
-        that has been copied from *this* point or UINT_MAX if
-        no copy of the point has been made */
-    ReferrerList mPointReferrers;
-
-    /** Weight channel list from the file */
-    WeightChannelList mWeightChannels;
-
-    /** Subdivision weight channel list from the file */
-    WeightChannelList mSWeightChannels;
-
-    /** Vertex color list from the file */
-    VColorChannelList mVColorChannels;
-
-    /** UV channel list from the file */
-    UVChannelList mUVChannels;
-
-    /** Normal vector channel from the file */
-    NormalChannel mNormals;
-
-    /** Temporary face list from the file*/
-    FaceList mFaces;
-
-    /** Current face indexing offset from the beginning of the buffers*/
-    unsigned int mFaceIDXOfs;
-
-    /** Current point indexing offset from the beginning of the buffers*/
-    unsigned int mPointIDXOfs;
-
-    /** Parent index */
-    uint16_t mParent;
-
-    /** Index of the layer */
-    uint16_t mIndex;
-
-    /** Name of the layer */
-    std::string mName;
-
-    /** Pivot point of the layer */
-    aiVector3D mPivot;
-
-    /** Skip this layer? */
-    bool skip;
-};
-
-typedef std::list<LWO::Layer>       LayerList;
-
-
-}}
-
-
-#endif // !! AI_LWO_FILEDATA_INCLUDED
-
diff --git a/Engine/lib/assimp/code/LWO/LWOLoader.cpp b/Engine/lib/assimp/code/LWO/LWOLoader.cpp
deleted file mode 100644
index 1e5b92c32..000000000
--- a/Engine/lib/assimp/code/LWO/LWOLoader.cpp
+++ /dev/null
@@ -1,1490 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-/** @file  LWOLoader.cpp
- *  @brief Implementation of the LWO importer class
- */
-
-
-#ifndef ASSIMP_BUILD_NO_LWO_IMPORTER
-
-// internal headers
-#include "LWO/LWOLoader.h"
-#include "PostProcessing/ProcessHelper.h"
-#include "PostProcessing/ConvertToLHProcess.h"
-
-#include <assimp/StringComparison.h>
-#include <assimp/SGSpatialSort.h>
-#include <assimp/ByteSwapper.h>
-#include <assimp/IOSystem.hpp>
-#include <assimp/importerdesc.h>
-
-#include <memory>
-#include <sstream>
-#include <iomanip>
-#include <map>
-
-using namespace Assimp;
-
-static const aiImporterDesc desc = {
-    "LightWave/Modo Object Importer",
-    "",
-    "",
-    "https://www.lightwave3d.com/lightwave_sdk/",
-    aiImporterFlags_SupportTextFlavour,
-    0,
-    0,
-    0,
-    0,
-    "lwo lxo"
-};
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-LWOImporter::LWOImporter()
-    : mIsLWO2(),
-    mIsLXOB(),
-    mLayers(),
-    mCurLayer(),
-    mTags(),
-    mMapping(),
-    mSurfaces(),
-    mFileBuffer(),
-    fileSize(),
-    pScene(),
-    configSpeedFlag(),
-    configLayerIndex(),
-    hasNamedLayer()
-{}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-LWOImporter::~LWOImporter()
-{}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the class can handle the format of the given file.
-bool LWOImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
-{
-    const std::string extension = GetExtension(pFile);
-    if (extension == "lwo" || extension == "lxo") {
-        return true;
-    }
-
-    // if check for extension is not enough, check for the magic tokens
-    if (!extension.length() || checkSig) {
-        uint32_t tokens[3];
-        tokens[0] = AI_LWO_FOURCC_LWOB;
-        tokens[1] = AI_LWO_FOURCC_LWO2;
-        tokens[2] = AI_LWO_FOURCC_LXOB;
-        return CheckMagicToken(pIOHandler,pFile,tokens,3,8);
-    }
-    return false;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Setup configuration properties
-void LWOImporter::SetupProperties(const Importer* pImp)
-{
-    configSpeedFlag  = ( 0 != pImp->GetPropertyInteger(AI_CONFIG_FAVOUR_SPEED,0) ? true : false);
-    configLayerIndex = pImp->GetPropertyInteger (AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY,UINT_MAX);
-    configLayerName  = pImp->GetPropertyString  (AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY,"");
-}
-
-// ------------------------------------------------------------------------------------------------
-// Get list of file extensions
-const aiImporterDesc* LWOImporter::GetInfo () const
-{
-    return &desc;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Imports the given file into the given scene structure.
-void LWOImporter::InternReadFile( const std::string& pFile,
-    aiScene* pScene,
-    IOSystem* pIOHandler)
-{
-    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));
-
-    // Check whether we can read from the file
-    if( file.get() == NULL)
-        throw DeadlyImportError( "Failed to open LWO file " + pFile + ".");
-
-    if((this->fileSize = (unsigned int)file->FileSize()) < 12)
-        throw DeadlyImportError("LWO: The file is too small to contain the IFF header");
-
-    // Allocate storage and copy the contents of the file to a memory buffer
-    std::vector< uint8_t > mBuffer(fileSize);
-    file->Read( &mBuffer[0], 1, fileSize);
-    this->pScene = pScene;
-
-    // Determine the type of the file
-    uint32_t fileType;
-    const char* sz = IFF::ReadHeader(&mBuffer[0],fileType);
-    if (sz)throw DeadlyImportError(sz);
-
-    mFileBuffer = &mBuffer[0] + 12;
-    fileSize -= 12;
-
-    // Initialize some members with their default values
-    hasNamedLayer   = false;
-
-    // Create temporary storage on the stack but store pointers to it in the class
-    // instance. Therefore everything will be destructed properly if an exception
-    // is thrown and we needn't take care of that.
-    LayerList       _mLayers;
-    SurfaceList     _mSurfaces;
-    TagList         _mTags;
-    TagMappingTable _mMapping;
-
-    mLayers         = &_mLayers;
-    mTags           = &_mTags;
-    mMapping        = &_mMapping;
-    mSurfaces       = &_mSurfaces;
-
-    // Allocate a default layer (layer indices are 1-based from now)
-    mLayers->push_back(Layer());
-    mCurLayer = &mLayers->back();
-    mCurLayer->mName = "<LWODefault>";
-    mCurLayer->mIndex = -1;
-
-    // old lightwave file format (prior to v6)
-    if (AI_LWO_FOURCC_LWOB == fileType) {
-        ASSIMP_LOG_INFO("LWO file format: LWOB (<= LightWave 5.5)");
-
-        mIsLWO2 = false;
-        mIsLXOB = false;
-        LoadLWOBFile();
-    }
-    // New lightwave format
-    else if (AI_LWO_FOURCC_LWO2 == fileType)    {
-        mIsLXOB = false;
-        ASSIMP_LOG_INFO("LWO file format: LWO2 (>= LightWave 6)");
-    }
-    // MODO file format
-    else if (AI_LWO_FOURCC_LXOB == fileType)    {
-        mIsLXOB = true;
-        ASSIMP_LOG_INFO("LWO file format: LXOB (Modo)");
-    }
-    // we don't know this format
-    else
-    {
-        char szBuff[5];
-        szBuff[0] = (char)(fileType >> 24u);
-        szBuff[1] = (char)(fileType >> 16u);
-        szBuff[2] = (char)(fileType >> 8u);
-        szBuff[3] = (char)(fileType);
-        szBuff[4] = '\0';
-        throw DeadlyImportError(std::string("Unknown LWO sub format: ") + szBuff);
-    }
-
-    if (AI_LWO_FOURCC_LWOB != fileType) {
-        mIsLWO2 = true;
-        LoadLWO2File();
-
-        // The newer lightwave format allows the user to configure the
-        // loader that just one layer is used. If this is the case
-        // we need to check now whether the requested layer has been found.
-        if (UINT_MAX != configLayerIndex) {
-            unsigned int layerCount = 0;
-            for(std::list<LWO::Layer>::iterator itLayers=mLayers->begin(); itLayers!=mLayers->end(); ++itLayers)
-                if (!itLayers->skip)
-                    layerCount++;
-            if (layerCount!=2)
-                throw DeadlyImportError("LWO2: The requested layer was not found");
-        }
-
-        if (configLayerName.length() && !hasNamedLayer) {
-            throw DeadlyImportError("LWO2: Unable to find the requested layer: "
-                + configLayerName);
-        }
-    }
-
-    // now, as we have loaded all data, we can resolve cross-referenced tags and clips
-    ResolveTags();
-    ResolveClips();
-
-    // now process all layers and build meshes and nodes
-    std::vector<aiMesh*> apcMeshes;
-    std::map<uint16_t, aiNode*> apcNodes;
-
-    apcMeshes.reserve(mLayers->size()*std::min(((unsigned int)mSurfaces->size()/2u), 1u));
-
-    unsigned int iDefaultSurface = UINT_MAX; // index of the default surface
-	for (LWO::Layer &layer : *mLayers) {
-        if (layer.skip)
-            continue;
-
-        // I don't know whether there could be dummy layers, but it would be possible
-        const unsigned int meshStart = (unsigned int)apcMeshes.size();
-        if (!layer.mFaces.empty() && !layer.mTempPoints.empty())    {
-
-            // now sort all faces by the surfaces assigned to them
-            std::vector<SortedRep> pSorted(mSurfaces->size()+1);
-
-            unsigned int i = 0;
-            for (FaceList::iterator it = layer.mFaces.begin(), end = layer.mFaces.end();it != end;++it,++i) {
-                // Check whether we support this face's type
-                if ((*it).type != AI_LWO_FACE && (*it).type != AI_LWO_PTCH &&
-                    (*it).type != AI_LWO_BONE && (*it).type != AI_LWO_SUBD) {
-                    continue;
-                }
-
-                unsigned int idx = (*it).surfaceIndex;
-                if (idx >= mTags->size())
-                {
-                    ASSIMP_LOG_WARN("LWO: Invalid face surface index");
-                    idx = UINT_MAX;
-                }
-                if(UINT_MAX == idx || UINT_MAX == (idx = _mMapping[idx]))   {
-                    if (UINT_MAX == iDefaultSurface)    {
-                        iDefaultSurface = (unsigned int)mSurfaces->size();
-                        mSurfaces->push_back(LWO::Surface());
-                        LWO::Surface& surf = mSurfaces->back();
-                        surf.mColor.r = surf.mColor.g = surf.mColor.b = 0.6f;
-                        surf.mName = "LWODefaultSurface";
-                    }
-                    idx = iDefaultSurface;
-                }
-                pSorted[idx].push_back(i);
-            }
-            if (UINT_MAX == iDefaultSurface) {
-                pSorted.erase(pSorted.end()-1);
-            }
-            for (unsigned int p = 0,i = 0;i < mSurfaces->size();++i)    {
-                SortedRep& sorted = pSorted[i];
-                if (sorted.empty())
-                    continue;
-
-                // generate the mesh
-                aiMesh* mesh = new aiMesh();
-                apcMeshes.push_back(mesh);
-                mesh->mNumFaces = (unsigned int)sorted.size();
-
-                // count the number of vertices
-                SortedRep::const_iterator it = sorted.begin(), end = sorted.end();
-                for (;it != end;++it)   {
-                    mesh->mNumVertices += layer.mFaces[*it].mNumIndices;
-                }
-
-                aiVector3D *nrm = NULL, * pv = mesh->mVertices = new aiVector3D[mesh->mNumVertices];
-                aiFace* pf = mesh->mFaces = new aiFace[mesh->mNumFaces];
-                mesh->mMaterialIndex = i;
-
-                // find out which vertex color channels and which texture coordinate
-                // channels are really required by the material attached to this mesh
-                unsigned int vUVChannelIndices[AI_MAX_NUMBER_OF_TEXTURECOORDS];
-                unsigned int vVColorIndices[AI_MAX_NUMBER_OF_COLOR_SETS];
-
-#ifdef ASSIMP_BUILD_DEBUG
-                for (unsigned int mui = 0; mui < AI_MAX_NUMBER_OF_TEXTURECOORDS;++mui ) {
-                    vUVChannelIndices[mui] = UINT_MAX;
-                }
-                for (unsigned int mui = 0; mui < AI_MAX_NUMBER_OF_COLOR_SETS;++mui ) {
-                    vVColorIndices[mui] = UINT_MAX;
-                }
-#endif
-
-                FindUVChannels(_mSurfaces[i],sorted,layer,vUVChannelIndices);
-                FindVCChannels(_mSurfaces[i],sorted,layer,vVColorIndices);
-
-                // allocate storage for UV and CV channels
-                aiVector3D* pvUV[AI_MAX_NUMBER_OF_TEXTURECOORDS];
-                for (unsigned int mui = 0; mui < AI_MAX_NUMBER_OF_TEXTURECOORDS;++mui ) {
-                    if (UINT_MAX == vUVChannelIndices[mui]) {
-                        break;
-                    }
-
-                    pvUV[mui] = mesh->mTextureCoords[mui] = new aiVector3D[mesh->mNumVertices];
-
-                    // LightWave doesn't support more than 2 UV components (?)
-                    mesh->mNumUVComponents[0] = 2;
-                }
-
-                if (layer.mNormals.name.length())
-                    nrm = mesh->mNormals = new aiVector3D[mesh->mNumVertices];
-
-                aiColor4D* pvVC[AI_MAX_NUMBER_OF_COLOR_SETS];
-                for (unsigned int mui = 0; mui < AI_MAX_NUMBER_OF_COLOR_SETS;++mui) {
-                    if (UINT_MAX == vVColorIndices[mui]) {
-                        break;
-                    }
-                    pvVC[mui] = mesh->mColors[mui] = new aiColor4D[mesh->mNumVertices];
-                }
-
-                // we would not need this extra array, but the code is much cleaner if we use it
-                std::vector<unsigned int>& smoothingGroups = layer.mPointReferrers;
-                smoothingGroups.erase (smoothingGroups.begin(),smoothingGroups.end());
-                smoothingGroups.resize(mesh->mNumFaces,0);
-
-                // now convert all faces
-                unsigned int vert = 0;
-                std::vector<unsigned int>::iterator outIt = smoothingGroups.begin();
-                for (it = sorted.begin(); it != end;++it,++outIt)   {
-                    const LWO::Face& face = layer.mFaces[*it];
-                    *outIt = face.smoothGroup;
-
-                    // copy all vertices
-                    for (unsigned int q = 0; q  < face.mNumIndices;++q,++vert)  {
-                        unsigned int idx = face.mIndices[q];
-                        *pv++ = layer.mTempPoints[idx] /*- layer.mPivot*/;
-
-                        // process UV coordinates
-                        for (unsigned int w = 0; w < AI_MAX_NUMBER_OF_TEXTURECOORDS;++w)    {
-                            if (UINT_MAX == vUVChannelIndices[w]) {
-                                break;
-                            }
-                            aiVector3D*& pp = pvUV[w];
-                            const aiVector2D& src = ((aiVector2D*)&layer.mUVChannels[vUVChannelIndices[w]].rawData[0])[idx];
-                            pp->x = src.x;
-                            pp->y = src.y;
-                            pp++;
-                        }
-
-                        // process normals (MODO extension)
-                        if (nrm)    {
-                            *nrm = ((aiVector3D*)&layer.mNormals.rawData[0])[idx];
-                            nrm->z *= -1.f;
-                            ++nrm;
-                        }
-
-                        // process vertex colors
-                        for (unsigned int w = 0; w < AI_MAX_NUMBER_OF_COLOR_SETS;++w)   {
-                            if (UINT_MAX == vVColorIndices[w]) {
-                                break;
-                            }
-                            *pvVC[w] = ((aiColor4D*)&layer.mVColorChannels[vVColorIndices[w]].rawData[0])[idx];
-
-                            // If a RGB color map is explicitly requested delete the
-                            // alpha channel - it could theoretically be != 1.
-                            if(_mSurfaces[i].mVCMapType == AI_LWO_RGB)
-                                pvVC[w]->a = 1.f;
-
-                            pvVC[w]++;
-                        }
-
-#if 0
-                        // process vertex weights. We can't properly reconstruct the whole skeleton for now,
-                        // but we can create dummy bones for all weight channels which we have.
-                        for (unsigned int w = 0; w < layer.mWeightChannels.size();++w)
-                        {
-                        }
-#endif
-
-                        face.mIndices[q] = vert;
-                    }
-                    pf->mIndices = face.mIndices;
-                    pf->mNumIndices = face.mNumIndices;
-                    unsigned int** p = (unsigned int**)&face.mIndices;*p = NULL; // HACK: make sure it won't be deleted
-                    pf++;
-                }
-
-                if (!mesh->mNormals)    {
-                    // Compute normal vectors for the mesh - we can't use our GenSmoothNormal-
-                    // Step here since it wouldn't handle smoothing groups correctly for LWO.
-                    // So we use a separate implementation.
-                    ComputeNormals(mesh,smoothingGroups,_mSurfaces[i]);
-                }
-                else {
-                    ASSIMP_LOG_DEBUG("LWO2: No need to compute normals, they're already there");
-                }
-                ++p;
-            }
-        }
-
-        // Generate nodes to render the mesh. Store the source layer in the mParent member of the nodes
-        unsigned int num = static_cast<unsigned int>(apcMeshes.size() - meshStart);
-        if (layer.mName != "<LWODefault>" || num > 0) {
-            aiNode* pcNode = new aiNode();
-            pcNode->mName.Set(layer.mName);
-            pcNode->mParent = (aiNode*)&layer;
-            pcNode->mNumMeshes = num;
-
-            if (pcNode->mNumMeshes) {
-                pcNode->mMeshes = new unsigned int[pcNode->mNumMeshes];
-                for (unsigned int p = 0; p < pcNode->mNumMeshes;++p)
-                    pcNode->mMeshes[p] = p + meshStart;
-            }
-            apcNodes[layer.mIndex] = pcNode;
-        }
-    }
-
-    if (apcNodes.empty() || apcMeshes.empty())
-        throw DeadlyImportError("LWO: No meshes loaded");
-
-    // The RemoveRedundantMaterials step will clean this up later
-    pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials = (unsigned int)mSurfaces->size()];
-    for (unsigned int mat = 0; mat < pScene->mNumMaterials;++mat)   {
-        aiMaterial* pcMat = new aiMaterial();
-        pScene->mMaterials[mat] = pcMat;
-        ConvertMaterial((*mSurfaces)[mat],pcMat);
-    }
-
-    // copy the meshes to the output structure
-    pScene->mMeshes = new aiMesh*[ pScene->mNumMeshes = (unsigned int)apcMeshes.size() ];
-    ::memcpy(pScene->mMeshes,&apcMeshes[0],pScene->mNumMeshes*sizeof(void*));
-
-    // generate the final node graph
-    GenerateNodeGraph(apcNodes);
-}
-
-// ------------------------------------------------------------------------------------------------
-void LWOImporter::ComputeNormals(aiMesh* mesh, const std::vector<unsigned int>& smoothingGroups,
-    const LWO::Surface& surface)
-{
-    // Allocate output storage
-    mesh->mNormals = new aiVector3D[mesh->mNumVertices];
-
-    // First generate per-face normals
-    aiVector3D* out;
-    std::vector<aiVector3D> faceNormals;
-
-    // ... in some cases that's already enough
-    if (!surface.mMaximumSmoothAngle)
-        out = mesh->mNormals;
-    else    {
-        faceNormals.resize(mesh->mNumVertices);
-        out = &faceNormals[0];
-    }
-
-    aiFace* begin = mesh->mFaces, *const end = mesh->mFaces+mesh->mNumFaces;
-    for (; begin != end; ++begin)   {
-        aiFace& face = *begin;
-
-        if(face.mNumIndices < 3) {
-            continue;
-        }
-
-        // LWO doc: "the normal is defined as the cross product of the first and last edges"
-        aiVector3D* pV1 = mesh->mVertices + face.mIndices[0];
-        aiVector3D* pV2 = mesh->mVertices + face.mIndices[1];
-        aiVector3D* pV3 = mesh->mVertices + face.mIndices[face.mNumIndices-1];
-
-        aiVector3D vNor = ((*pV2 - *pV1) ^(*pV3 - *pV1)).Normalize();
-        for (unsigned int i = 0; i < face.mNumIndices;++i)
-            out[face.mIndices[i]] = vNor;
-    }
-    if (!surface.mMaximumSmoothAngle)return;
-    const float posEpsilon = ComputePositionEpsilon(mesh);
-
-    // Now generate the spatial sort tree
-    SGSpatialSort sSort;
-    std::vector<unsigned int>::const_iterator it = smoothingGroups.begin();
-    for( begin =  mesh->mFaces; begin != end; ++begin, ++it)
-    {
-        aiFace& face = *begin;
-        for (unsigned int i = 0; i < face.mNumIndices;++i)
-        {
-            unsigned int tt = face.mIndices[i];
-            sSort.Add(mesh->mVertices[tt],tt,*it);
-        }
-    }
-    // Sort everything - this takes O(nlogn) time
-    sSort.Prepare();
-    std::vector<unsigned int> poResult;
-    poResult.reserve(20);
-
-    // Generate vertex normals. We have O(logn) for the binary lookup, which we need
-    // for n elements, thus the EXPECTED complexity is O(nlogn)
-    if (surface.mMaximumSmoothAngle < 3.f && !configSpeedFlag)  {
-        const float fLimit = std::cos(surface.mMaximumSmoothAngle);
-
-        for( begin =  mesh->mFaces, it = smoothingGroups.begin(); begin != end; ++begin, ++it)  {
-            const aiFace& face = *begin;
-            unsigned int* beginIdx = face.mIndices, *const endIdx = face.mIndices+face.mNumIndices;
-            for (; beginIdx != endIdx; ++beginIdx)
-            {
-                unsigned int idx = *beginIdx;
-                sSort.FindPositions(mesh->mVertices[idx],*it,posEpsilon,poResult,true);
-                std::vector<unsigned int>::const_iterator a, end = poResult.end();
-
-                aiVector3D vNormals;
-                for (a =  poResult.begin();a != end;++a)    {
-                    const aiVector3D& v = faceNormals[*a];
-                    if (v * faceNormals[idx] < fLimit)
-                        continue;
-                    vNormals += v;
-                }
-                mesh->mNormals[idx] = vNormals.Normalize();
-            }
-        }
-    }
-     // faster code path in case there is no smooth angle
-    else    {
-        std::vector<bool> vertexDone(mesh->mNumVertices,false);
-        for( begin =  mesh->mFaces, it = smoothingGroups.begin(); begin != end; ++begin, ++it)  {
-            const aiFace& face = *begin;
-            unsigned int* beginIdx = face.mIndices, *const endIdx = face.mIndices+face.mNumIndices;
-            for (; beginIdx != endIdx; ++beginIdx)
-            {
-                unsigned int idx = *beginIdx;
-                if (vertexDone[idx])
-                    continue;
-                sSort.FindPositions(mesh->mVertices[idx],*it,posEpsilon,poResult,true);
-                std::vector<unsigned int>::const_iterator a, end = poResult.end();
-
-                aiVector3D vNormals;
-                for (a =  poResult.begin();a != end;++a)    {
-                    const aiVector3D& v = faceNormals[*a];
-                    vNormals += v;
-                }
-                vNormals.Normalize();
-                for (a =  poResult.begin();a != end;++a)    {
-                    mesh->mNormals[*a] = vNormals;
-                    vertexDone[*a] = true;
-                }
-            }
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void LWOImporter::GenerateNodeGraph(std::map<uint16_t,aiNode*>& apcNodes)
-{
-    // now generate the final nodegraph - generate a root node and attach children
-    aiNode* root = pScene->mRootNode = new aiNode();
-    root->mName.Set("<LWORoot>");
-
-    //Set parent of all children, inserting pivots
-    //std::cout << "Set parent of all children" << std::endl;
-    std::map<uint16_t, aiNode*> mapPivot;
-    for (auto itapcNodes = apcNodes.begin(); itapcNodes != apcNodes.end(); ++itapcNodes) {
-
-        //Get the parent index
-        LWO::Layer* nodeLayer = (LWO::Layer*)(itapcNodes->second->mParent);
-        uint16_t parentIndex = nodeLayer->mParent;
-
-        //Create pivot node, store it into the pivot map, and set the parent as the pivot
-        aiNode* pivotNode = new aiNode();
-        pivotNode->mName.Set("Pivot-"+std::string(itapcNodes->second->mName.data));
-        itapcNodes->second->mParent = pivotNode;
-
-        //Look for the parent node to attach the pivot to
-        if (apcNodes.find(parentIndex) != apcNodes.end()) {
-            pivotNode->mParent = apcNodes[parentIndex];
-        } else {
-            //If not, attach to the root node
-            pivotNode->mParent = root;
-        }
-
-        //Set the node and the pivot node transformation
-        itapcNodes->second->mTransformation.a4 = -nodeLayer->mPivot.x;
-        itapcNodes->second->mTransformation.b4 = -nodeLayer->mPivot.y;
-        itapcNodes->second->mTransformation.c4 = -nodeLayer->mPivot.z;
-        pivotNode->mTransformation.a4 = nodeLayer->mPivot.x;
-        pivotNode->mTransformation.b4 = nodeLayer->mPivot.y;
-        pivotNode->mTransformation.c4 = nodeLayer->mPivot.z;
-        mapPivot[-(itapcNodes->first+2)] = pivotNode;
-    }
-
-    //Merge pivot map into node map
-    //std::cout << "Merge pivot map into node map" << std::endl;
-    for (auto itMapPivot = mapPivot.begin(); itMapPivot != mapPivot.end(); ++itMapPivot) {
-        apcNodes[itMapPivot->first] = itMapPivot->second;
-    }
-
-    //Set children of all parents
-    apcNodes[-1] = root;
-    for (auto itMapParentNodes = apcNodes.begin(); itMapParentNodes != apcNodes.end(); ++itMapParentNodes) {
-        for (auto itMapChildNodes = apcNodes.begin(); itMapChildNodes != apcNodes.end(); ++itMapChildNodes) {
-            if ((itMapParentNodes->first != itMapChildNodes->first) && (itMapParentNodes->second == itMapChildNodes->second->mParent)) {
-                ++(itMapParentNodes->second->mNumChildren);
-            }
-        }
-        if (itMapParentNodes->second->mNumChildren) {
-            itMapParentNodes->second->mChildren = new aiNode* [ itMapParentNodes->second->mNumChildren ];
-            uint16_t p = 0;
-            for (auto itMapChildNodes = apcNodes.begin(); itMapChildNodes != apcNodes.end(); ++itMapChildNodes) {
-                if ((itMapParentNodes->first != itMapChildNodes->first) && (itMapParentNodes->second == itMapChildNodes->second->mParent)) {
-                    itMapParentNodes->second->mChildren[p++] = itMapChildNodes->second;
-                }
-            }
-        }
-    }
-
-    if (!pScene->mRootNode->mNumChildren)
-        throw DeadlyImportError("LWO: Unable to build a valid node graph");
-
-    // Remove a single root node with no meshes assigned to it ...
-    if (1 == pScene->mRootNode->mNumChildren)   {
-        aiNode* pc = pScene->mRootNode->mChildren[0];
-        pc->mParent = pScene->mRootNode->mChildren[0] = NULL;
-        delete pScene->mRootNode;
-        pScene->mRootNode = pc;
-    }
-
-    // convert the whole stuff to RH with CCW winding
-    MakeLeftHandedProcess maker;
-    maker.Execute(pScene);
-
-    FlipWindingOrderProcess flipper;
-    flipper.Execute(pScene);
-}
-
-// ------------------------------------------------------------------------------------------------
-void LWOImporter::ResolveTags()
-{
-    // --- this function is used for both LWO2 and LWOB
-    mMapping->resize(mTags->size(), UINT_MAX);
-    for (unsigned int a = 0; a  < mTags->size();++a)    {
-
-        const std::string& c = (*mTags)[a];
-        for (unsigned int i = 0; i < mSurfaces->size();++i) {
-
-            const std::string& d = (*mSurfaces)[i].mName;
-            if (!ASSIMP_stricmp(c,d))   {
-
-                (*mMapping)[a] = i;
-                break;
-            }
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void LWOImporter::ResolveClips()
-{
-    for( unsigned int i = 0; i < mClips.size();++i) {
-
-        Clip& clip = mClips[i];
-        if (Clip::REF == clip.type) {
-
-            if (clip.clipRef >= mClips.size())  {
-                ASSIMP_LOG_ERROR("LWO2: Clip referrer index is out of range");
-                clip.clipRef = 0;
-            }
-
-            Clip& dest = mClips[clip.clipRef];
-            if (Clip::REF == dest.type) {
-                ASSIMP_LOG_ERROR("LWO2: Clip references another clip reference");
-                clip.type = Clip::UNSUPPORTED;
-            }
-
-            else    {
-                clip.path = dest.path;
-                clip.type = dest.type;
-            }
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void LWOImporter::AdjustTexturePath(std::string& out)
-{
-    // --- this function is used for both LWO2 and LWOB
-    if (!mIsLWO2 && ::strstr(out.c_str(), "(sequence)"))    {
-
-        // remove the (sequence) and append 000
-        ASSIMP_LOG_INFO("LWOB: Sequence of animated texture found. It will be ignored");
-        out = out.substr(0,out.length()-10) + "000";
-    }
-
-    // format: drive:path/file - we just need to insert a slash after the drive
-    std::string::size_type n = out.find_first_of(':');
-    if (std::string::npos != n) {
-        out.insert(n+1,"/");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void LWOImporter::LoadLWOTags(unsigned int size)
-{
-    // --- this function is used for both LWO2 and LWOB
-
-    const char* szCur = (const char*)mFileBuffer, *szLast = szCur;
-    const char* const szEnd = szLast+size;
-    while (szCur < szEnd)
-    {
-        if (!(*szCur))
-        {
-            const size_t len = (size_t)(szCur-szLast);
-            // FIX: skip empty-sized tags
-            if (len)
-                mTags->push_back(std::string(szLast,len));
-            szCur += (len&0x1 ? 1 : 2);
-            szLast = szCur;
-        }
-        szCur++;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void LWOImporter::LoadLWOPoints(unsigned int length)
-{
-    // --- this function is used for both LWO2 and LWOB but for
-    // LWO2 we need to allocate 25% more storage - it could be we'll
-    // need to duplicate some points later.
-    const size_t vertexLen = 12;
-    if ((length % vertexLen) != 0)
-    {
-        throw DeadlyImportError( "LWO2: Points chunk length is not multiple of vertexLen (12)");
-    }
-    unsigned int regularSize = (unsigned int)mCurLayer->mTempPoints.size() + length / 12;
-    if (mIsLWO2)
-    {
-        mCurLayer->mTempPoints.reserve  ( regularSize + (regularSize>>2u) );
-        mCurLayer->mTempPoints.resize   ( regularSize );
-
-        // initialize all point referrers with the default values
-        mCurLayer->mPointReferrers.reserve  ( regularSize + (regularSize>>2u) );
-        mCurLayer->mPointReferrers.resize   ( regularSize, UINT_MAX );
-    }
-    else mCurLayer->mTempPoints.resize( regularSize );
-
-    // perform endianness conversions
-#ifndef AI_BUILD_BIG_ENDIAN
-    for (unsigned int i = 0; i < length>>2;++i)
-        ByteSwap::Swap4( mFileBuffer + (i << 2));
-#endif
-    ::memcpy(&mCurLayer->mTempPoints[0],mFileBuffer,length);
-}
-
-// ------------------------------------------------------------------------------------------------
-void LWOImporter::LoadLWO2Polygons(unsigned int length)
-{
-    LE_NCONST uint16_t* const end   = (LE_NCONST uint16_t*)(mFileBuffer+length);
-    const uint32_t type = GetU4();
-
-    // Determine the type of the polygons
-    switch (type)
-    {
-        // read unsupported stuff too (although we won't process it)
-    case  AI_LWO_MBAL:
-        ASSIMP_LOG_WARN("LWO2: Encountered unsupported primitive chunk (METABALL)");
-        break;
-    case  AI_LWO_CURV:
-        ASSIMP_LOG_WARN("LWO2: Encountered unsupported primitive chunk (SPLINE)");;
-        break;
-
-        // These are ok with no restrictions
-    case  AI_LWO_PTCH:
-    case  AI_LWO_FACE:
-    case  AI_LWO_BONE:
-    case  AI_LWO_SUBD:
-        break;
-    default:
-
-        // hm!? wtf is this? ok ...
-        ASSIMP_LOG_ERROR("LWO2: Ignoring unknown polygon type.");
-        break;
-    }
-
-    // first find out how many faces and vertices we'll finally need
-    uint16_t* cursor= (uint16_t*)mFileBuffer;
-
-    unsigned int iNumFaces = 0,iNumVertices = 0;
-    CountVertsAndFacesLWO2(iNumVertices,iNumFaces,cursor,end);
-
-    // allocate the output array and copy face indices
-    if (iNumFaces)
-    {
-        cursor = (uint16_t*)mFileBuffer;
-
-        mCurLayer->mFaces.resize(iNumFaces,LWO::Face(type));
-        FaceList::iterator it = mCurLayer->mFaces.begin();
-        CopyFaceIndicesLWO2(it,cursor,end);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void LWOImporter::CountVertsAndFacesLWO2(unsigned int& verts, unsigned int& faces,
-    uint16_t*& cursor, const uint16_t* const end, unsigned int max)
-{
-    while (cursor < end && max--)
-    {
-        uint16_t numIndices;
-        ::memcpy(&numIndices, cursor++, 2);
-        AI_LSWAP2(numIndices);
-        numIndices &= 0x03FF;
-
-        verts += numIndices;
-        ++faces;
-
-        for(uint16_t i = 0; i < numIndices; i++)
-        {
-            ReadVSizedIntLWO2((uint8_t*&)cursor);
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void LWOImporter::CopyFaceIndicesLWO2(FaceList::iterator& it,
-    uint16_t*& cursor,
-    const uint16_t* const end)
-{
-    while (cursor < end)
-    {
-        LWO::Face& face = *it++;
-        uint16_t numIndices;
-        ::memcpy(&numIndices, cursor++, 2);
-        AI_LSWAP2(numIndices);
-        face.mNumIndices = numIndices & 0x03FF;
-
-        if(face.mNumIndices) /* byte swapping has already been done */
-        {
-            face.mIndices = new unsigned int[face.mNumIndices];
-            for(unsigned int i = 0; i < face.mNumIndices; i++)
-            {
-                face.mIndices[i] = ReadVSizedIntLWO2((uint8_t*&)cursor) + mCurLayer->mPointIDXOfs;
-                if(face.mIndices[i] > mCurLayer->mTempPoints.size())
-                {
-                    ASSIMP_LOG_WARN("LWO2: Failure evaluating face record, index is out of range");
-                    face.mIndices[i] = (unsigned int)mCurLayer->mTempPoints.size()-1;
-                }
-            }
-        }
-        else throw DeadlyImportError("LWO2: Encountered invalid face record with zero indices");
-    }
-}
-
-
-// ------------------------------------------------------------------------------------------------
-void LWOImporter::LoadLWO2PolygonTags(unsigned int length)
-{
-    LE_NCONST uint8_t* const end = mFileBuffer+length;
-
-    AI_LWO_VALIDATE_CHUNK_LENGTH(length,PTAG,4);
-    uint32_t type = GetU4();
-
-    if (type != AI_LWO_SURF && type != AI_LWO_SMGP)
-        return;
-
-    while (mFileBuffer < end)
-    {
-        unsigned int i = ReadVSizedIntLWO2(mFileBuffer) + mCurLayer->mFaceIDXOfs;
-        unsigned int j = GetU2();
-
-        if (i >= mCurLayer->mFaces.size())  {
-            ASSIMP_LOG_WARN("LWO2: face index in PTAG is out of range");
-            continue;
-        }
-
-        switch (type)   {
-
-        case AI_LWO_SURF:
-            mCurLayer->mFaces[i].surfaceIndex = j;
-            break;
-        case AI_LWO_SMGP: /* is that really used? */
-            mCurLayer->mFaces[i].smoothGroup = j;
-            break;
-        };
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-template <class T>
-VMapEntry* FindEntry(std::vector< T >& list,const std::string& name, bool perPoly)
-{
-    for (auto & elem : list)   {
-        if (elem.name == name) {
-            if (!perPoly)   {
-                ASSIMP_LOG_WARN("LWO2: Found two VMAP sections with equal names");
-            }
-            return &elem;
-        }
-    }
-    list.push_back( T() );
-    VMapEntry* p = &list.back();
-    p->name = name;
-    return p;
-}
-
-// ------------------------------------------------------------------------------------------------
-template <class T>
-inline void CreateNewEntry(T& chan, unsigned int srcIdx)
-{
-    if (!chan.name.length())
-        return;
-
-    chan.abAssigned[srcIdx] = true;
-    chan.abAssigned.resize(chan.abAssigned.size()+1,false);
-
-    for (unsigned int a = 0; a < chan.dims;++a)
-        chan.rawData.push_back(chan.rawData[srcIdx*chan.dims+a]);
-}
-
-// ------------------------------------------------------------------------------------------------
-template <class T>
-inline void CreateNewEntry(std::vector< T >& list, unsigned int srcIdx)
-{
-    for (auto &elem : list)   {
-        CreateNewEntry( elem, srcIdx );
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-inline void LWOImporter::DoRecursiveVMAPAssignment(VMapEntry* base, unsigned int numRead,
-    unsigned int idx, float* data)
-{
-    ai_assert(NULL != data);
-    LWO::ReferrerList& refList  = mCurLayer->mPointReferrers;
-    unsigned int i;
-
-    if (idx >= base->abAssigned.size()) {
-        throw DeadlyImportError("Bad index");
-    }
-    base->abAssigned[idx] = true;
-    for (i = 0; i < numRead;++i) {
-        base->rawData[idx*base->dims+i]= data[i];
-    }
-
-    if (UINT_MAX != (i = refList[idx])) {
-        DoRecursiveVMAPAssignment(base,numRead,i,data);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-inline void AddToSingleLinkedList(ReferrerList& refList, unsigned int srcIdx, unsigned int destIdx)
-{
-    if(UINT_MAX == refList[srcIdx]) {
-        refList[srcIdx] = destIdx;
-        return;
-    }
-    AddToSingleLinkedList(refList,refList[srcIdx],destIdx);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Load LWO2 vertex map
-void LWOImporter::LoadLWO2VertexMap(unsigned int length, bool perPoly)
-{
-    LE_NCONST uint8_t* const end = mFileBuffer+length;
-
-    AI_LWO_VALIDATE_CHUNK_LENGTH(length,VMAP,6);
-    unsigned int type = GetU4();
-    unsigned int dims = GetU2();
-
-    VMapEntry* base;
-
-    // read the name of the vertex map
-    std::string name;
-    GetS0(name,length);
-
-    switch (type)
-    {
-    case AI_LWO_TXUV:
-        if (dims != 2)  {
-            ASSIMP_LOG_WARN("LWO2: Skipping UV channel \'"
-            + name + "\' with !2 components");
-            return;
-        }
-        base = FindEntry(mCurLayer->mUVChannels,name,perPoly);
-        break;
-    case AI_LWO_WGHT:
-    case AI_LWO_MNVW:
-        if (dims != 1)  {
-            ASSIMP_LOG_WARN("LWO2: Skipping Weight Channel \'"
-            + name + "\' with !1 components");
-            return;
-        }
-        base = FindEntry((type == AI_LWO_WGHT ? mCurLayer->mWeightChannels
-            : mCurLayer->mSWeightChannels),name,perPoly);
-        break;
-    case AI_LWO_RGB:
-    case AI_LWO_RGBA:
-        if (dims != 3 && dims != 4) {
-            ASSIMP_LOG_WARN("LWO2: Skipping Color Map \'"
-            + name + "\' with a dimension > 4 or < 3");
-            return;
-        }
-        base = FindEntry(mCurLayer->mVColorChannels,name,perPoly);
-        break;
-
-    case AI_LWO_MODO_NORM:
-        /*  This is a non-standard extension chunk used by Luxology's MODO.
-         *  It stores per-vertex normals. This VMAP exists just once, has
-         *  3 dimensions and is btw extremely beautiful.
-         */
-        if (name != "vert_normals" || dims != 3 || mCurLayer->mNormals.name.length())
-            return;
-
-        ASSIMP_LOG_INFO("Processing non-standard extension: MODO VMAP.NORM.vert_normals");
-
-        mCurLayer->mNormals.name = name;
-        base = & mCurLayer->mNormals;
-        break;
-
-    case AI_LWO_PICK: /* these VMAPs are just silently dropped */
-    case AI_LWO_MORF:
-    case AI_LWO_SPOT:
-        return;
-
-    default:
-        if (name == "APS.Level") {
-            // XXX handle this (seems to be subdivision-related).
-        }
-        ASSIMP_LOG_WARN_F("LWO2: Skipping unknown VMAP/VMAD channel \'", name, "\'");
-        return;
-    };
-    base->Allocate((unsigned int)mCurLayer->mTempPoints.size());
-
-    // now read all entries in the map
-    type = std::min(dims,base->dims);
-    const unsigned int diff = (dims - type)<<2u;
-
-    LWO::FaceList& list = mCurLayer->mFaces;
-    LWO::PointList& pointList = mCurLayer->mTempPoints;
-    LWO::ReferrerList& refList = mCurLayer->mPointReferrers;
-
-    const unsigned int numPoints = (unsigned int)pointList.size();
-    const unsigned int numFaces  = (unsigned int)list.size();
-
-    while (mFileBuffer < end)   {
-
-        unsigned int idx = ReadVSizedIntLWO2(mFileBuffer) + mCurLayer->mPointIDXOfs;
-        if (idx >= numPoints)   {
-            ASSIMP_LOG_WARN_F("LWO2: Failure evaluating VMAP/VMAD entry \'", name, "\', vertex index is out of range");
-            mFileBuffer += base->dims<<2u;
-            continue;
-        }
-        if (perPoly)    {
-            unsigned int polyIdx = ReadVSizedIntLWO2(mFileBuffer) + mCurLayer->mFaceIDXOfs;
-            if (base->abAssigned[idx])  {
-                // we have already a VMAP entry for this vertex - thus
-                // we need to duplicate the corresponding polygon.
-                if (polyIdx >= numFaces)    {
-                    ASSIMP_LOG_WARN_F("LWO2: Failure evaluating VMAD entry \'", name, "\', polygon index is out of range");
-                    mFileBuffer += base->dims<<2u;
-                    continue;
-                }
-
-                LWO::Face& src = list[polyIdx];
-
-                // generate a new unique vertex for the corresponding index - but only
-                // if we can find the index in the face
-                bool had = false;
-                for (unsigned int i = 0; i < src.mNumIndices;++i)   {
-
-                    unsigned int srcIdx = src.mIndices[i], tmp = idx;
-                    do {
-                        if (tmp == srcIdx)
-                            break;
-                    }
-                    while ((tmp = refList[tmp]) != UINT_MAX);
-                    if (tmp == UINT_MAX) {
-                        continue;
-                    }
-
-                    had = true;
-                    refList.resize(refList.size()+1, UINT_MAX);
-
-                    idx = (unsigned int)pointList.size();
-                    src.mIndices[i] = (unsigned int)pointList.size();
-
-                    // store the index of the new vertex in the old vertex
-                    // so we get a single linked list we can traverse in
-                    // only one direction
-                    AddToSingleLinkedList(refList,srcIdx,src.mIndices[i]);
-                    pointList.push_back(pointList[srcIdx]);
-
-                    CreateNewEntry(mCurLayer->mVColorChannels,  srcIdx );
-                    CreateNewEntry(mCurLayer->mUVChannels,      srcIdx );
-                    CreateNewEntry(mCurLayer->mWeightChannels,  srcIdx );
-                    CreateNewEntry(mCurLayer->mSWeightChannels, srcIdx );
-                    CreateNewEntry(mCurLayer->mNormals, srcIdx );
-                }
-                if (!had) {
-                    ASSIMP_LOG_WARN_F("LWO2: Failure evaluating VMAD entry \'", name, "\', vertex index wasn't found in that polygon");
-                    ai_assert(had);
-                }
-            }
-        }
-
-        std::unique_ptr<float[]> temp(new float[type]);
-        for (unsigned int l = 0; l < type;++l)
-            temp[l] = GetF4();
-
-        DoRecursiveVMAPAssignment(base,type,idx, temp.get());
-        mFileBuffer += diff;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Load LWO2 clip
-void LWOImporter::LoadLWO2Clip(unsigned int length)
-{
-    AI_LWO_VALIDATE_CHUNK_LENGTH(length,CLIP,10);
-
-    mClips.push_back(LWO::Clip());
-    LWO::Clip& clip = mClips.back();
-
-    // first - get the index of the clip
-    clip.idx = GetU4();
-
-    IFF::SubChunkHeader head = IFF::LoadSubChunk(mFileBuffer);
-    switch (head.type)
-    {
-    case AI_LWO_STIL:
-        AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,STIL,1);
-
-        // "Normal" texture
-        GetS0(clip.path,head.length);
-        clip.type = Clip::STILL;
-        break;
-
-    case AI_LWO_ISEQ:
-        AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,ISEQ,16);
-        // Image sequence. We'll later take the first.
-        {
-            uint8_t digits = GetU1();  mFileBuffer++;
-            int16_t offset = GetU2();  mFileBuffer+=4;
-            int16_t start  = GetU2();  mFileBuffer+=4;
-
-            std::string s;
-            std::ostringstream ss;
-            GetS0(s,head.length);
-
-            head.length -= (uint16_t)s.length()+1;
-            ss << s;
-            ss << std::setw(digits) << offset + start;
-            GetS0(s,head.length);
-            ss << s;
-            clip.path = ss.str();
-            clip.type = Clip::SEQ;
-        }
-        break;
-
-    case AI_LWO_STCC:
-        ASSIMP_LOG_WARN("LWO2: Color shifted images are not supported");
-        break;
-
-    case AI_LWO_ANIM:
-        ASSIMP_LOG_WARN("LWO2: Animated textures are not supported");
-        break;
-
-    case AI_LWO_XREF:
-        AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,XREF,4);
-
-        // Just a cross-reference to another CLIp
-        clip.type = Clip::REF;
-        clip.clipRef = GetU4();
-        break;
-
-    case AI_LWO_NEGA:
-        AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,NEGA,2);
-        clip.negate = (0 != GetU2());
-        break;
-
-    default:
-        ASSIMP_LOG_WARN("LWO2: Encountered unknown CLIP sub-chunk");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Load envelope description
-void LWOImporter::LoadLWO2Envelope(unsigned int length)
-{
-    LE_NCONST uint8_t* const end = mFileBuffer + length;
-    AI_LWO_VALIDATE_CHUNK_LENGTH(length,ENVL,4);
-
-    mEnvelopes.push_back(LWO::Envelope());
-    LWO::Envelope& envelope = mEnvelopes.back();
-
-    // Get the index of the envelope
-    envelope.index = ReadVSizedIntLWO2(mFileBuffer);
-
-    // It looks like there might be an extra U4 right after the index,
-    // at least in modo (LXOB) files: we'll ignore it if it's zero,
-    // otherwise it represents the start of a subchunk, so we backtrack.
-    if (mIsLXOB)
-    {
-        uint32_t extra = GetU4();
-        if (extra)
-        {
-            mFileBuffer -= 4;
-        }
-    }
-
-    // ... and read all subchunks
-    while (true)
-    {
-        if (mFileBuffer + 6 >= end)break;
-        LE_NCONST IFF::SubChunkHeader head = IFF::LoadSubChunk(mFileBuffer);
-
-        if (mFileBuffer + head.length > end)
-            throw DeadlyImportError("LWO2: Invalid envelope chunk length");
-
-        uint8_t* const next = mFileBuffer+head.length;
-        switch (head.type)
-        {
-            // Type & representation of the envelope
-        case AI_LWO_TYPE:
-            AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,TYPE,2);
-            mFileBuffer++; // skip user format
-
-            // Determine type of envelope
-            envelope.type  = (LWO::EnvelopeType)*mFileBuffer;
-            ++mFileBuffer;
-            break;
-
-            // precondition
-        case AI_LWO_PRE:
-            AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,PRE,2);
-            envelope.pre = (LWO::PrePostBehaviour)GetU2();
-            break;
-
-            // postcondition
-        case AI_LWO_POST:
-            AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,POST,2);
-            envelope.post = (LWO::PrePostBehaviour)GetU2();
-            break;
-
-            // keyframe
-        case AI_LWO_KEY:
-            {
-            AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,KEY,8);
-
-            envelope.keys.push_back(LWO::Key());
-            LWO::Key& key = envelope.keys.back();
-
-            key.time = GetF4();
-            key.value = GetF4();
-            break;
-            }
-
-            // interval interpolation
-        case AI_LWO_SPAN:
-            {
-                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,SPAN,4);
-                if (envelope.keys.size()<2)
-                    ASSIMP_LOG_WARN("LWO2: Unexpected SPAN chunk");
-                else {
-                    LWO::Key& key = envelope.keys.back();
-                    switch (GetU4())
-                    {
-                        case AI_LWO_STEP:
-                            key.inter = LWO::IT_STEP;break;
-                        case AI_LWO_LINE:
-                            key.inter = LWO::IT_LINE;break;
-                        case AI_LWO_TCB:
-                            key.inter = LWO::IT_TCB;break;
-                        case AI_LWO_HERM:
-                            key.inter = LWO::IT_HERM;break;
-                        case AI_LWO_BEZI:
-                            key.inter = LWO::IT_BEZI;break;
-                        case AI_LWO_BEZ2:
-                            key.inter = LWO::IT_BEZ2;break;
-                        default:
-                            ASSIMP_LOG_WARN("LWO2: Unknown interval interpolation mode");
-                    };
-
-                    // todo ... read params
-                }
-                break;
-            }
-
-        default:
-            ASSIMP_LOG_WARN("LWO2: Encountered unknown ENVL subchunk");
-            break;
-        }
-        // regardless how much we did actually read, go to the next chunk
-        mFileBuffer = next;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Load file - master function
-void LWOImporter::LoadLWO2File()
-{
-    bool skip = false;
-
-    LE_NCONST uint8_t* const end = mFileBuffer + fileSize;
-    unsigned int iUnnamed = 0;
-    while (true)
-    {
-        if (mFileBuffer + sizeof(IFF::ChunkHeader) > end)break;
-        const IFF::ChunkHeader head = IFF::LoadChunk(mFileBuffer);
-
-        if (mFileBuffer + head.length > end)
-        {
-            throw DeadlyImportError("LWO2: Chunk length points behind the file");
-            break;
-        }
-        uint8_t* const next = mFileBuffer+head.length;
-
-        if(!head.length) {
-            mFileBuffer = next;
-            continue;
-        }
-
-        switch (head.type)
-        {
-            // new layer
-        case AI_LWO_LAYR:
-            {
-                // add a new layer to the list ....
-                mLayers->push_back ( LWO::Layer() );
-                LWO::Layer& layer = mLayers->back();
-                mCurLayer = &layer;
-
-                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,LAYR,16);
-
-                // layer index.
-                layer.mIndex = GetU2();
-
-                // Continue loading this layer or ignore it? Check the layer index property
-                if (UINT_MAX != configLayerIndex && (configLayerIndex-1) != layer.mIndex)   {
-                    skip = true;
-                }
-                else skip = false;
-
-                // pivot point
-                mFileBuffer += 2; /* unknown */
-                mCurLayer->mPivot.x = GetF4();
-                mCurLayer->mPivot.y = GetF4();
-                mCurLayer->mPivot.z = GetF4();
-                GetS0(layer.mName,head.length-16);
-
-                // if the name is empty, generate a default name
-                if (layer.mName.empty())    {
-                    char buffer[128]; // should be sufficiently large
-                    ::ai_snprintf(buffer, 128, "Layer_%i", iUnnamed++);
-                    layer.mName = buffer;
-                }
-
-                // load this layer or ignore it? Check the layer name property
-                if (configLayerName.length() && configLayerName != layer.mName) {
-                    skip = true;
-                }
-                else hasNamedLayer = true;
-
-                // optional: parent of this layer
-                if (mFileBuffer + 2 <= next)
-                    layer.mParent = GetU2();
-                else layer.mParent = -1;
-
-                // Set layer skip parameter
-                layer.skip = skip;
-
-                break;
-            }
-
-            // vertex list
-        case AI_LWO_PNTS:
-            {
-                if (skip)
-                    break;
-
-                unsigned int old = (unsigned int)mCurLayer->mTempPoints.size();
-                LoadLWOPoints(head.length);
-                mCurLayer->mPointIDXOfs = old;
-                break;
-            }
-            // vertex tags
-        case AI_LWO_VMAD:
-            if (mCurLayer->mFaces.empty())
-            {
-                ASSIMP_LOG_WARN("LWO2: Unexpected VMAD chunk");
-                break;
-            }
-            // --- intentionally no break here
-        case AI_LWO_VMAP:
-            {
-                if (skip)
-                    break;
-
-                if (mCurLayer->mTempPoints.empty())
-                    ASSIMP_LOG_WARN("LWO2: Unexpected VMAP chunk");
-                else LoadLWO2VertexMap(head.length,head.type == AI_LWO_VMAD);
-                break;
-            }
-            // face list
-        case AI_LWO_POLS:
-            {
-                if (skip)
-                    break;
-
-                unsigned int old = (unsigned int)mCurLayer->mFaces.size();
-                LoadLWO2Polygons(head.length);
-                mCurLayer->mFaceIDXOfs = old;
-                break;
-            }
-            // polygon tags
-        case AI_LWO_PTAG:
-            {
-                if (skip)
-                    break;
-
-                if (mCurLayer->mFaces.empty()) {
-                    ASSIMP_LOG_WARN("LWO2: Unexpected PTAG");
-                } else {
-                    LoadLWO2PolygonTags(head.length);
-                }
-                break;
-            }
-            // list of tags
-        case AI_LWO_TAGS:
-            {
-                if (!mTags->empty()) {
-                    ASSIMP_LOG_WARN("LWO2: SRFS chunk encountered twice");
-                }   else {
-                    LoadLWOTags(head.length);
-                }
-                break;
-            }
-
-            // surface chunk
-        case AI_LWO_SURF:
-            {
-                LoadLWO2Surface(head.length);
-                break;
-            }
-
-            // clip chunk
-        case AI_LWO_CLIP:
-            {
-                LoadLWO2Clip(head.length);
-                break;
-            }
-
-            // envelope chunk
-        case AI_LWO_ENVL:
-            {
-                LoadLWO2Envelope(head.length);
-                break;
-            }
-        }
-        mFileBuffer = next;
-    }
-}
-
-#endif // !! ASSIMP_BUILD_NO_LWO_IMPORTER
diff --git a/Engine/lib/assimp/code/LWO/LWOMaterial.cpp b/Engine/lib/assimp/code/LWO/LWOMaterial.cpp
deleted file mode 100644
index b54c21c26..000000000
--- a/Engine/lib/assimp/code/LWO/LWOMaterial.cpp
+++ /dev/null
@@ -1,898 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-/** @file Implementation of the material oart of the LWO importer class */
-
-
-
-#ifndef ASSIMP_BUILD_NO_LWO_IMPORTER
-
-// internal headers
-#include "LWOLoader.h"
-#include <assimp/ByteSwapper.h>
-
-
-using namespace Assimp;
-
-// ------------------------------------------------------------------------------------------------
-template <class T>
-T lerp(const T& one, const T& two, float val)
-{
-    return one + (two-one)*val;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Convert a lightwave mapping mode to our's
-inline aiTextureMapMode GetMapMode(LWO::Texture::Wrap in)
-{
-    switch (in)
-    {
-        case LWO::Texture::REPEAT:
-            return aiTextureMapMode_Wrap;
-
-        case LWO::Texture::MIRROR:
-            return aiTextureMapMode_Mirror;
-
-        case LWO::Texture::RESET:
-            ASSIMP_LOG_WARN("LWO2: Unsupported texture map mode: RESET");
-
-            // fall though here
-        case LWO::Texture::EDGE:
-            return aiTextureMapMode_Clamp;
-    }
-    return (aiTextureMapMode)0;
-}
-
-// ------------------------------------------------------------------------------------------------
-bool LWOImporter::HandleTextures(aiMaterial* pcMat, const TextureList& in, aiTextureType type)
-{
-    ai_assert(NULL != pcMat);
-
-    unsigned int cur = 0, temp = 0;
-    aiString s;
-    bool ret = false;
-
-    for (const auto &texture : in)    {
-        if (!texture.enabled || !texture.bCanUse)
-            continue;
-        ret = true;
-
-        // Convert lightwave's mapping modes to ours. We let them
-        // as they are, the GenUVcoords step will compute UV
-        // channels if they're not there.
-
-        aiTextureMapping mapping;
-        switch (texture.mapMode)
-        {
-            case LWO::Texture::Planar:
-                mapping = aiTextureMapping_PLANE;
-                break;
-            case LWO::Texture::Cylindrical:
-                mapping = aiTextureMapping_CYLINDER;
-                break;
-            case LWO::Texture::Spherical:
-                mapping = aiTextureMapping_SPHERE;
-                break;
-            case LWO::Texture::Cubic:
-                mapping = aiTextureMapping_BOX;
-                break;
-            case LWO::Texture::FrontProjection:
-                ASSIMP_LOG_ERROR("LWO2: Unsupported texture mapping: FrontProjection");
-                mapping = aiTextureMapping_OTHER;
-                break;
-            case LWO::Texture::UV:
-                {
-                    if( UINT_MAX == texture.mRealUVIndex ) {
-                        // We have no UV index for this texture, so we can't display it
-                        continue;
-                    }
-
-                    // add the UV source index
-                    temp = texture.mRealUVIndex;
-                    pcMat->AddProperty<int>((int*)&temp,1,AI_MATKEY_UVWSRC(type,cur));
-
-                    mapping = aiTextureMapping_UV;
-                }
-                break;
-            default:
-                ai_assert(false);
-        };
-
-        if (mapping != aiTextureMapping_UV) {
-            // Setup the main axis
-            aiVector3D v;
-            switch (texture.majorAxis) {
-                case Texture::AXIS_X:
-                    v = aiVector3D(1.0,0.0,0.0);
-                    break;
-                case Texture::AXIS_Y:
-                    v = aiVector3D(0.0,1.0,0.0);
-                    break;
-                default: // case Texture::AXIS_Z:
-                    v = aiVector3D(0.0,0.0,1.0);
-                    break;
-            }
-
-            pcMat->AddProperty(&v,1,AI_MATKEY_TEXMAP_AXIS(type,cur));
-
-            // Setup UV scalings for cylindric and spherical projections
-            if (mapping == aiTextureMapping_CYLINDER || mapping == aiTextureMapping_SPHERE) {
-                aiUVTransform trafo;
-                trafo.mScaling.x = texture.wrapAmountW;
-                trafo.mScaling.y = texture.wrapAmountH;
-
-                static_assert(sizeof(aiUVTransform)/sizeof(ai_real) == 5, "sizeof(aiUVTransform)/sizeof(ai_real) == 5");
-                pcMat->AddProperty(&trafo,1,AI_MATKEY_UVTRANSFORM(type,cur));
-            }
-            ASSIMP_LOG_DEBUG("LWO2: Setting up non-UV mapping");
-        }
-
-        // The older LWOB format does not use indirect references to clips.
-        // The file name of a texture is directly specified in the tex chunk.
-        if (mIsLWO2)    {
-            // find the corresponding clip (take the last one if multiple
-            // share the same index)
-            ClipList::iterator end = mClips.end(), candidate = end;
-            temp = texture.mClipIdx;
-            for (ClipList::iterator clip = mClips.begin(); clip != end; ++clip) {
-                if ((*clip).idx == temp) {
-                    candidate = clip;
-                }
-
-            }
-            if (candidate == end)   {
-                ASSIMP_LOG_ERROR("LWO2: Clip index is out of bounds");
-                temp = 0;
-
-                // fixme: apparently some LWO files shipping with Doom3 don't
-                // have clips at all ... check whether that's true or whether
-                // it's a bug in the loader.
-
-                s.Set("$texture.png");
-
-                //continue;
-            }
-            else {
-                if (Clip::UNSUPPORTED == (*candidate).type) {
-                    ASSIMP_LOG_ERROR("LWO2: Clip type is not supported");
-                    continue;
-                }
-                AdjustTexturePath((*candidate).path);
-                s.Set((*candidate).path);
-
-                // Additional image settings
-                int flags = 0;
-                if ((*candidate).negate) {
-                    flags |= aiTextureFlags_Invert;
-                }
-                pcMat->AddProperty(&flags,1,AI_MATKEY_TEXFLAGS(type,cur));
-            }
-        }
-        else
-        {
-            std::string ss = texture.mFileName;
-            if (!ss.length()) {
-                ASSIMP_LOG_WARN("LWOB: Empty file name");
-                continue;
-            }
-            AdjustTexturePath(ss);
-            s.Set(ss);
-        }
-        pcMat->AddProperty(&s,AI_MATKEY_TEXTURE(type,cur));
-
-        // add the blend factor
-        pcMat->AddProperty<float>(&texture.mStrength,1,AI_MATKEY_TEXBLEND(type,cur));
-
-        // add the blend operation
-        switch (texture.blendType)
-        {
-            case LWO::Texture::Normal:
-            case LWO::Texture::Multiply:
-                temp = (unsigned int)aiTextureOp_Multiply;
-                break;
-
-            case LWO::Texture::Subtractive:
-            case LWO::Texture::Difference:
-                temp = (unsigned int)aiTextureOp_Subtract;
-                break;
-
-            case LWO::Texture::Divide:
-                temp = (unsigned int)aiTextureOp_Divide;
-                break;
-
-            case LWO::Texture::Additive:
-                temp = (unsigned int)aiTextureOp_Add;
-                break;
-
-            default:
-                temp = (unsigned int)aiTextureOp_Multiply;
-                ASSIMP_LOG_WARN("LWO2: Unsupported texture blend mode: alpha or displacement");
-
-        }
-        // Setup texture operation
-        pcMat->AddProperty<int>((int*)&temp,1,AI_MATKEY_TEXOP(type,cur));
-
-        // setup the mapping mode
-        int mapping_ = static_cast<int>(mapping);
-        pcMat->AddProperty<int>(&mapping_, 1, AI_MATKEY_MAPPING(type, cur));
-
-        // add the u-wrapping
-        temp = (unsigned int)GetMapMode(texture.wrapModeWidth);
-        pcMat->AddProperty<int>((int*)&temp,1,AI_MATKEY_MAPPINGMODE_U(type,cur));
-
-        // add the v-wrapping
-        temp = (unsigned int)GetMapMode(texture.wrapModeHeight);
-        pcMat->AddProperty<int>((int*)&temp,1,AI_MATKEY_MAPPINGMODE_V(type,cur));
-
-        ++cur;
-    }
-    return ret;
-}
-
-// ------------------------------------------------------------------------------------------------
-void LWOImporter::ConvertMaterial(const LWO::Surface& surf,aiMaterial* pcMat)
-{
-    // copy the name of the surface
-    aiString st;
-    st.Set(surf.mName);
-    pcMat->AddProperty(&st,AI_MATKEY_NAME);
-
-    const int i = surf.bDoubleSided ? 1 : 0;
-    pcMat->AddProperty(&i,1,AI_MATKEY_TWOSIDED);
-
-    // add the refraction index and the bump intensity
-    pcMat->AddProperty(&surf.mIOR,1,AI_MATKEY_REFRACTI);
-    pcMat->AddProperty(&surf.mBumpIntensity,1,AI_MATKEY_BUMPSCALING);
-
-    aiShadingMode m;
-    if (surf.mSpecularValue && surf.mGlossiness)
-    {
-        float fGloss;
-        if (mIsLWO2)    {
-            fGloss = std::pow( surf.mGlossiness*ai_real( 10.0 )+ ai_real( 2.0 ), ai_real( 2.0 ) );
-        }
-        else
-        {
-            if (16.0 >= surf.mGlossiness)
-                fGloss = 6.0;
-            else if (64.0 >= surf.mGlossiness)
-                fGloss = 20.0;
-            else if (256.0 >= surf.mGlossiness)
-                fGloss = 50.0;
-            else fGloss = 80.0;
-        }
-
-        pcMat->AddProperty(&surf.mSpecularValue,1,AI_MATKEY_SHININESS_STRENGTH);
-        pcMat->AddProperty(&fGloss,1,AI_MATKEY_SHININESS);
-        m = aiShadingMode_Phong;
-    }
-    else m = aiShadingMode_Gouraud;
-
-    // specular color
-    aiColor3D clr = lerp( aiColor3D(1.0,1.0,1.0), surf.mColor, surf.mColorHighlights );
-    pcMat->AddProperty(&clr,1,AI_MATKEY_COLOR_SPECULAR);
-    pcMat->AddProperty(&surf.mSpecularValue,1,AI_MATKEY_SHININESS_STRENGTH);
-
-    // emissive color
-    // luminosity is not really the same but it affects the surface in a similar way. Some scaling looks good.
-    clr.g = clr.b = clr.r = surf.mLuminosity*ai_real( 0.8 );
-    pcMat->AddProperty<aiColor3D>(&clr,1,AI_MATKEY_COLOR_EMISSIVE);
-
-    // opacity ... either additive or default-blended, please
-    if (0.0 != surf.mAdditiveTransparency)  {
-        const int add = aiBlendMode_Additive;
-        pcMat->AddProperty(&surf.mAdditiveTransparency,1,AI_MATKEY_OPACITY);
-        pcMat->AddProperty(&add,1,AI_MATKEY_BLEND_FUNC);
-    } else if (10e10f != surf.mTransparency)  {
-        const int def = aiBlendMode_Default;
-        const float f = 1.0f-surf.mTransparency;
-        pcMat->AddProperty(&f,1,AI_MATKEY_OPACITY);
-        pcMat->AddProperty(&def,1,AI_MATKEY_BLEND_FUNC);
-    }
-
-
-    // ADD TEXTURES to the material
-    // TODO: find out how we can handle COLOR textures correctly...
-    bool b = HandleTextures(pcMat,surf.mColorTextures,aiTextureType_DIFFUSE);
-    b = (b || HandleTextures(pcMat,surf.mDiffuseTextures,aiTextureType_DIFFUSE));
-    HandleTextures(pcMat,surf.mSpecularTextures,aiTextureType_SPECULAR);
-    HandleTextures(pcMat,surf.mGlossinessTextures,aiTextureType_SHININESS);
-    HandleTextures(pcMat,surf.mBumpTextures,aiTextureType_HEIGHT);
-    HandleTextures(pcMat,surf.mOpacityTextures,aiTextureType_OPACITY);
-    HandleTextures(pcMat,surf.mReflectionTextures,aiTextureType_REFLECTION);
-
-    // Now we need to know which shader to use .. iterate through the shader list of
-    // the surface and  search for a name which we know ...
-    for (const auto &shader : surf.mShaders)   {
-        if (shader.functionName == "LW_SuperCelShader" || shader.functionName == "AH_CelShader")  {
-            ASSIMP_LOG_INFO("LWO2: Mapping LW_SuperCelShader/AH_CelShader to aiShadingMode_Toon");
-
-            m = aiShadingMode_Toon;
-            break;
-        }
-        else if (shader.functionName == "LW_RealFresnel" || shader.functionName == "LW_FastFresnel")  {
-            ASSIMP_LOG_INFO("LWO2: Mapping LW_RealFresnel/LW_FastFresnel to aiShadingMode_Fresnel");
-
-            m = aiShadingMode_Fresnel;
-            break;
-        }
-        else
-        {
-            ASSIMP_LOG_WARN_F("LWO2: Unknown surface shader: ", shader.functionName);
-        }
-    }
-    if (surf.mMaximumSmoothAngle <= 0.0)
-        m = aiShadingMode_Flat;
-    int m_ = static_cast<int>(m);
-    pcMat->AddProperty(&m_, 1, AI_MATKEY_SHADING_MODEL);
-
-    // (the diffuse value is just a scaling factor)
-    // If a diffuse texture is set, we set this value to 1.0
-    clr = (b && false ? aiColor3D(1.0,1.0,1.0) : surf.mColor);
-    clr.r *= surf.mDiffuseValue;
-    clr.g *= surf.mDiffuseValue;
-    clr.b *= surf.mDiffuseValue;
-    pcMat->AddProperty<aiColor3D>(&clr,1,AI_MATKEY_COLOR_DIFFUSE);
-}
-
-// ------------------------------------------------------------------------------------------------
-char LWOImporter::FindUVChannels(LWO::TextureList& list,
-    LWO::Layer& /*layer*/,LWO::UVChannel& uv, unsigned int next)
-{
-    char ret = 0;
-    for (auto &texture : list)  {
-
-        // Ignore textures with non-UV mappings for the moment.
-        if (!texture.enabled || !texture.bCanUse || texture.mapMode != LWO::Texture::UV)  {
-            continue;
-        }
-
-        if (texture.mUVChannelIndex == uv.name) {
-            ret = 1;
-
-            // got it.
-            if (texture.mRealUVIndex == UINT_MAX || texture.mRealUVIndex == next)
-            {
-                texture.mRealUVIndex = next;
-            }
-            else {
-                // channel mismatch. need to duplicate the material.
-                ASSIMP_LOG_WARN("LWO: Channel mismatch, would need to duplicate surface [design bug]");
-
-                // TODO
-            }
-        }
-    }
-    return ret;
-}
-
-// ------------------------------------------------------------------------------------------------
-void LWOImporter::FindUVChannels(LWO::Surface& surf,
-    LWO::SortedRep& sorted,LWO::Layer& layer,
-    unsigned int out[AI_MAX_NUMBER_OF_TEXTURECOORDS])
-{
-    unsigned int next = 0, extra = 0, num_extra = 0;
-
-    // Check whether we have an UV entry != 0 for one of the faces in 'sorted'
-    for (unsigned int i = 0; i < layer.mUVChannels.size();++i)  {
-        LWO::UVChannel& uv = layer.mUVChannels[i];
-
-        for (LWO::SortedRep::const_iterator it = sorted.begin(); it != sorted.end(); ++it)  {
-
-            LWO::Face& face = layer.mFaces[*it];
-
-            for (unsigned int n = 0; n < face.mNumIndices; ++n) {
-                unsigned int idx = face.mIndices[n];
-
-                if (uv.abAssigned[idx] && ((aiVector2D*)&uv.rawData[0])[idx] != aiVector2D()) {
-
-                    if (extra >= AI_MAX_NUMBER_OF_TEXTURECOORDS) {
-
-                        ASSIMP_LOG_ERROR("LWO: Maximum number of UV channels for "
-                            "this mesh reached. Skipping channel \'" + uv.name + "\'");
-
-                    }
-                    else {
-                        // Search through all textures assigned to 'surf' and look for this UV channel
-                        char had = 0;
-                        had |= FindUVChannels(surf.mColorTextures,layer,uv,next);
-                        had |= FindUVChannels(surf.mDiffuseTextures,layer,uv,next);
-                        had |= FindUVChannels(surf.mSpecularTextures,layer,uv,next);
-                        had |= FindUVChannels(surf.mGlossinessTextures,layer,uv,next);
-                        had |= FindUVChannels(surf.mOpacityTextures,layer,uv,next);
-                        had |= FindUVChannels(surf.mBumpTextures,layer,uv,next);
-                        had |= FindUVChannels(surf.mReflectionTextures,layer,uv,next);
-
-                        // We have a texture referencing this UV channel so we have to take special care
-                        // and are willing to drop unreferenced channels in favour of it.
-                        if (had != 0) {
-                            if (num_extra) {
-
-                                for (unsigned int a = next; a < std::min( extra, AI_MAX_NUMBER_OF_TEXTURECOORDS-1u ); ++a) {
-                                    out[a+1] = out[a];
-                                }
-                            }
-                            ++extra;
-                            out[next++] = i;
-                        }
-                        // Bah ... seems not to be used at all. Push to end if enough space is available.
-                        else {
-                            out[extra++] = i;
-                            ++num_extra;
-                        }
-                    }
-                    it = sorted.end()-1;
-                    break;
-                }
-            }
-        }
-    }
-    if (extra < AI_MAX_NUMBER_OF_TEXTURECOORDS) {
-        out[extra] = UINT_MAX;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void LWOImporter::FindVCChannels(const LWO::Surface& surf, LWO::SortedRep& sorted, const LWO::Layer& layer,
-    unsigned int out[AI_MAX_NUMBER_OF_COLOR_SETS])
-{
-    unsigned int next = 0;
-
-    // Check whether we have an vc entry != 0 for one of the faces in 'sorted'
-    for (unsigned int i = 0; i < layer.mVColorChannels.size();++i)  {
-        const LWO::VColorChannel& vc = layer.mVColorChannels[i];
-
-        if (surf.mVCMap == vc.name) {
-            // The vertex color map is explicitly requested by the surface so we need to take special care of it
-            for (unsigned int a = 0; a < std::min(next,AI_MAX_NUMBER_OF_COLOR_SETS-1u); ++a) {
-                out[a+1] = out[a];
-            }
-            out[0] = i;
-            ++next;
-        }
-        else {
-
-            for (LWO::SortedRep::iterator it = sorted.begin(); it != sorted.end(); ++it)    {
-                const LWO::Face& face = layer.mFaces[*it];
-
-                for (unsigned int n = 0; n < face.mNumIndices; ++n) {
-                    unsigned int idx = face.mIndices[n];
-
-                    if (vc.abAssigned[idx] && ((aiColor4D*)&vc.rawData[0])[idx] != aiColor4D(0.0,0.0,0.0,1.0)) {
-                        if (next >= AI_MAX_NUMBER_OF_COLOR_SETS) {
-
-                            ASSIMP_LOG_ERROR("LWO: Maximum number of vertex color channels for "
-                                "this mesh reached. Skipping channel \'" + vc.name + "\'");
-
-                        }
-                        else {
-                            out[next++] = i;
-                        }
-                        it = sorted.end()-1;
-                        break;
-                    }
-                }
-            }
-        }
-    }
-    if (next != AI_MAX_NUMBER_OF_COLOR_SETS) {
-        out[next] = UINT_MAX;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void LWOImporter::LoadLWO2ImageMap(unsigned int size, LWO::Texture& tex )
-{
-    LE_NCONST uint8_t* const end = mFileBuffer + size;
-    while (true)
-    {
-        if (mFileBuffer + 6 >= end)break;
-        LE_NCONST IFF::SubChunkHeader head = IFF::LoadSubChunk(mFileBuffer);
-
-        if (mFileBuffer + head.length > end)
-            throw DeadlyImportError("LWO2: Invalid SURF.BLOCK chunk length");
-
-        uint8_t* const next = mFileBuffer+head.length;
-        switch (head.type)
-        {
-        case AI_LWO_PROJ:
-            tex.mapMode = (Texture::MappingMode)GetU2();
-            break;
-        case AI_LWO_WRAP:
-            tex.wrapModeWidth  = (Texture::Wrap)GetU2();
-            tex.wrapModeHeight = (Texture::Wrap)GetU2();
-            break;
-        case AI_LWO_AXIS:
-            tex.majorAxis = (Texture::Axes)GetU2();
-            break;
-        case AI_LWO_IMAG:
-            tex.mClipIdx = GetU2();
-            break;
-        case AI_LWO_VMAP:
-            GetS0(tex.mUVChannelIndex,head.length);
-            break;
-        case AI_LWO_WRPH:
-            tex.wrapAmountH = GetF4();
-            break;
-        case AI_LWO_WRPW:
-            tex.wrapAmountW = GetF4();
-            break;
-        }
-        mFileBuffer = next;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void LWOImporter::LoadLWO2Procedural(unsigned int /*size*/, LWO::Texture& tex )
-{
-    // --- not supported at the moment
-    ASSIMP_LOG_ERROR("LWO2: Found procedural texture, this is not supported");
-    tex.bCanUse = false;
-}
-
-// ------------------------------------------------------------------------------------------------
-void LWOImporter::LoadLWO2Gradient(unsigned int /*size*/, LWO::Texture& tex  )
-{
-    // --- not supported at the moment
-    ASSIMP_LOG_ERROR("LWO2: Found gradient texture, this is not supported");
-    tex.bCanUse = false;
-}
-
-// ------------------------------------------------------------------------------------------------
-void LWOImporter::LoadLWO2TextureHeader(unsigned int size, LWO::Texture& tex )
-{
-    LE_NCONST uint8_t* const end = mFileBuffer + size;
-
-    // get the ordinal string
-    GetS0( tex.ordinal, size);
-
-    // we could crash later if this is an empty string ...
-    if (!tex.ordinal.length())
-    {
-        ASSIMP_LOG_ERROR("LWO2: Ill-formed SURF.BLOK ordinal string");
-        tex.ordinal = "\x00";
-    }
-    while (true)
-    {
-        if (mFileBuffer + 6 >= end)break;
-        const IFF::SubChunkHeader head = IFF::LoadSubChunk(mFileBuffer);
-
-        if (mFileBuffer + head.length > end)
-            throw DeadlyImportError("LWO2: Invalid texture header chunk length");
-
-        uint8_t* const next = mFileBuffer+head.length;
-        switch (head.type)
-        {
-        case AI_LWO_CHAN:
-            tex.type = GetU4();
-            break;
-        case AI_LWO_ENAB:
-            tex.enabled = GetU2() ? true : false;
-            break;
-        case AI_LWO_OPAC:
-            tex.blendType = (Texture::BlendType)GetU2();
-            tex.mStrength = GetF4();
-            break;
-        }
-        mFileBuffer = next;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void LWOImporter::LoadLWO2TextureBlock(LE_NCONST IFF::SubChunkHeader* head, unsigned int size )
-{
-    ai_assert(!mSurfaces->empty());
-    LWO::Surface& surf = mSurfaces->back();
-    LWO::Texture tex;
-
-    // load the texture header
-    LoadLWO2TextureHeader(head->length,tex);
-    size -= head->length + 6;
-
-    // now get the exact type of the texture
-    switch (head->type)
-    {
-    case AI_LWO_PROC:
-        LoadLWO2Procedural(size,tex);
-        break;
-    case AI_LWO_GRAD:
-        LoadLWO2Gradient(size,tex);
-        break;
-    case AI_LWO_IMAP:
-        LoadLWO2ImageMap(size,tex);
-    }
-
-    // get the destination channel
-    TextureList* listRef = NULL;
-    switch (tex.type)
-    {
-    case AI_LWO_COLR:
-        listRef = &surf.mColorTextures;break;
-    case AI_LWO_DIFF:
-        listRef = &surf.mDiffuseTextures;break;
-    case AI_LWO_SPEC:
-        listRef = &surf.mSpecularTextures;break;
-    case AI_LWO_GLOS:
-        listRef = &surf.mGlossinessTextures;break;
-    case AI_LWO_BUMP:
-        listRef = &surf.mBumpTextures;break;
-    case AI_LWO_TRAN:
-        listRef = &surf.mOpacityTextures;break;
-    case AI_LWO_REFL:
-        listRef = &surf.mReflectionTextures;break;
-    default:
-        ASSIMP_LOG_WARN("LWO2: Encountered unknown texture type");
-        return;
-    }
-
-    // now attach the texture to the parent surface - sort by ordinal string
-    for (TextureList::iterator it = listRef->begin();it != listRef->end(); ++it)    {
-        if (::strcmp(tex.ordinal.c_str(),(*it).ordinal.c_str()) < 0)    {
-            listRef->insert(it,tex);
-            return;
-        }
-    }
-    listRef->push_back(tex);
-}
-
-// ------------------------------------------------------------------------------------------------
-void LWOImporter::LoadLWO2ShaderBlock(LE_NCONST IFF::SubChunkHeader* /*head*/, unsigned int size )
-{
-    LE_NCONST uint8_t* const end = mFileBuffer + size;
-
-    ai_assert(!mSurfaces->empty());
-    LWO::Surface& surf = mSurfaces->back();
-    LWO::Shader shader;
-
-    // get the ordinal string
-    GetS0( shader.ordinal, size);
-
-    // we could crash later if this is an empty string ...
-    if (!shader.ordinal.length())
-    {
-        ASSIMP_LOG_ERROR("LWO2: Ill-formed SURF.BLOK ordinal string");
-        shader.ordinal = "\x00";
-    }
-
-    // read the header
-    while (true)
-    {
-        if (mFileBuffer + 6 >= end)break;
-        const IFF::SubChunkHeader head = IFF::LoadSubChunk(mFileBuffer);
-
-        if (mFileBuffer + head.length > end)
-            throw DeadlyImportError("LWO2: Invalid shader header chunk length");
-
-        uint8_t* const next = mFileBuffer+head.length;
-        switch (head.type)
-        {
-        case AI_LWO_ENAB:
-            shader.enabled = GetU2() ? true : false;
-            break;
-
-        case AI_LWO_FUNC:
-            GetS0( shader.functionName, head.length );
-        }
-        mFileBuffer = next;
-    }
-
-    // now attach the shader to the parent surface - sort by ordinal string
-    for (ShaderList::iterator it = surf.mShaders.begin();it != surf.mShaders.end(); ++it)   {
-        if (::strcmp(shader.ordinal.c_str(),(*it).ordinal.c_str()) < 0) {
-            surf.mShaders.insert(it,shader);
-            return;
-        }
-    }
-    surf.mShaders.push_back(shader);
-}
-
-// ------------------------------------------------------------------------------------------------
-void LWOImporter::LoadLWO2Surface(unsigned int size)
-{
-    LE_NCONST uint8_t* const end = mFileBuffer + size;
-
-    mSurfaces->push_back( LWO::Surface () );
-    LWO::Surface& surf = mSurfaces->back();
-
-    GetS0(surf.mName,size);
-
-    // check whether this surface was derived from any other surface
-    std::string derived;
-    GetS0(derived,(unsigned int)(end - mFileBuffer));
-    if (derived.length())   {
-        // yes, find this surface
-        for (SurfaceList::iterator it = mSurfaces->begin(), end = mSurfaces->end()-1; it != end; ++it)  {
-            if ((*it).mName == derived) {
-                // we have it ...
-                surf = *it;
-                derived.clear();break;
-            }
-        }
-        if (derived.size())
-            ASSIMP_LOG_WARN("LWO2: Unable to find source surface: " + derived);
-    }
-
-    while (true)
-    {
-        if (mFileBuffer + 6 >= end)
-            break;
-        const IFF::SubChunkHeader head = IFF::LoadSubChunk(mFileBuffer);
-
-        if (mFileBuffer + head.length > end)
-            throw DeadlyImportError("LWO2: Invalid surface chunk length");
-
-        uint8_t* const next = mFileBuffer+head.length;
-        switch (head.type)
-        {
-            // diffuse color
-        case AI_LWO_COLR:
-            {
-                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,COLR,12);
-                surf.mColor.r = GetF4();
-                surf.mColor.g = GetF4();
-                surf.mColor.b = GetF4();
-                break;
-            }
-            // diffuse strength ... hopefully
-        case AI_LWO_DIFF:
-            {
-                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,DIFF,4);
-                surf.mDiffuseValue = GetF4();
-                break;
-            }
-            // specular strength ... hopefully
-        case AI_LWO_SPEC:
-            {
-                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,SPEC,4);
-                surf.mSpecularValue = GetF4();
-                break;
-            }
-            // transparency
-        case AI_LWO_TRAN:
-            {
-                // transparency explicitly disabled?
-                if (surf.mTransparency == 10e10f)
-                    break;
-
-                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,TRAN,4);
-                surf.mTransparency = GetF4();
-                break;
-            }
-            // additive transparency
-        case AI_LWO_ADTR:
-            {
-                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,ADTR,4);
-                surf.mAdditiveTransparency = GetF4();
-                break;
-            }
-            // wireframe mode
-        case AI_LWO_LINE:
-            {
-                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,LINE,2);
-                if (GetU2() & 0x1)
-                    surf.mWireframe = true;
-                break;
-            }
-            // glossiness
-        case AI_LWO_GLOS:
-            {
-                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,GLOS,4);
-                surf.mGlossiness = GetF4();
-                break;
-            }
-            // bump intensity
-        case AI_LWO_BUMP:
-            {
-                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,BUMP,4);
-                surf.mBumpIntensity = GetF4();
-                break;
-            }
-            // color highlights
-        case AI_LWO_CLRH:
-            {
-                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,CLRH,4);
-                surf.mColorHighlights = GetF4();
-                break;
-            }
-            // index of refraction
-        case AI_LWO_RIND:
-            {
-                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,RIND,4);
-                surf.mIOR = GetF4();
-                break;
-            }
-            // polygon sidedness
-        case AI_LWO_SIDE:
-            {
-                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,SIDE,2);
-                surf.bDoubleSided = (3 == GetU2());
-                break;
-            }
-            // maximum smoothing angle
-        case AI_LWO_SMAN:
-            {
-                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,SMAN,4);
-                surf.mMaximumSmoothAngle = std::fabs( GetF4() );
-                break;
-            }
-            // vertex color channel to be applied to the surface
-        case AI_LWO_VCOL:
-            {
-                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,VCOL,12);
-                surf.mDiffuseValue *= GetF4();              // strength
-                ReadVSizedIntLWO2(mFileBuffer);             // skip envelope
-                surf.mVCMapType = GetU4();                  // type of the channel
-
-                // name of the channel
-                GetS0(surf.mVCMap, (unsigned int) (next - mFileBuffer ));
-                break;
-            }
-            // surface bock entry
-        case AI_LWO_BLOK:
-            {
-                AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,BLOK,4);
-                IFF::SubChunkHeader head2 = IFF::LoadSubChunk(mFileBuffer);
-
-                switch (head2.type)
-                {
-                case AI_LWO_PROC:
-                case AI_LWO_GRAD:
-                case AI_LWO_IMAP:
-                    LoadLWO2TextureBlock(&head2, head.length);
-                    break;
-                case AI_LWO_SHDR:
-                    LoadLWO2ShaderBlock(&head2, head.length);
-                    break;
-
-                default:
-                    ASSIMP_LOG_WARN("LWO2: Found an unsupported surface BLOK");
-                };
-
-                break;
-            }
-        }
-        mFileBuffer = next;
-    }
-}
-
-#endif // !! ASSIMP_BUILD_NO_X_IMPORTER
diff --git a/Engine/lib/assimp/code/MMD/MMDImporter.cpp b/Engine/lib/assimp/code/MMD/MMDImporter.cpp
deleted file mode 100644
index e7744e4cd..000000000
--- a/Engine/lib/assimp/code/MMD/MMDImporter.cpp
+++ /dev/null
@@ -1,372 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2016, assimp team
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-#ifndef ASSIMP_BUILD_NO_MMD_IMPORTER
-
-#include "MMD/MMDImporter.h"
-#include "MMD/MMDPmdParser.h"
-#include "MMD/MMDPmxParser.h"
-#include "MMD/MMDVmdParser.h"
-#include "PostProcessing/ConvertToLHProcess.h"
-
-#include <assimp/DefaultIOSystem.h>
-#include <assimp/Importer.hpp>
-#include <assimp/ai_assert.h>
-#include <assimp/scene.h>
-
-#include <fstream>
-#include <iomanip>
-#include <memory>
-
-static const aiImporterDesc desc = {"MMD Importer",
-                                    "",
-                                    "",
-                                    "surfaces supported?",
-                                    aiImporterFlags_SupportTextFlavour,
-                                    0,
-                                    0,
-                                    0,
-                                    0,
-                                    "pmx"};
-
-namespace Assimp {
-
-using namespace std;
-
-// ------------------------------------------------------------------------------------------------
-//  Default constructor
-MMDImporter::MMDImporter()
-: m_Buffer()
-, m_strAbsPath("") {
-    DefaultIOSystem io;
-    m_strAbsPath = io.getOsSeparator();
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Destructor.
-MMDImporter::~MMDImporter() {
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Returns true, if file is an pmx file.
-bool MMDImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler,
-                          bool checkSig) const {
-  if (!checkSig) // Check File Extension
-  {
-    return SimpleExtensionCheck(pFile, "pmx");
-  } else // Check file Header
-  {
-    static const char *pTokens[] = {"PMX "};
-    return BaseImporter::SearchFileHeaderForToken(pIOHandler, pFile, pTokens, 1);
-  }
-}
-
-// ------------------------------------------------------------------------------------------------
-const aiImporterDesc *MMDImporter::GetInfo() const { return &desc; }
-
-// ------------------------------------------------------------------------------------------------
-//  MMD import implementation
-void MMDImporter::InternReadFile(const std::string &file, aiScene *pScene,
-                                 IOSystem * /*pIOHandler*/) {
-  // Read file by istream
-  std::filebuf fb;
-  if (!fb.open(file, std::ios::in | std::ios::binary)) {
-    throw DeadlyImportError("Failed to open file " + file + ".");
-  }
-
-  std::istream fileStream(&fb);
-
-  // Get the file-size and validate it, throwing an exception when fails
-  fileStream.seekg(0, fileStream.end);
-  size_t fileSize = static_cast<size_t>(fileStream.tellg());
-  fileStream.seekg(0, fileStream.beg);
-
-  if (fileSize < sizeof(pmx::PmxModel)) {
-    throw DeadlyImportError(file + " is too small.");
-  }
-
-  pmx::PmxModel model;
-  model.Read(&fileStream);
-
-  CreateDataFromImport(&model, pScene);
-}
-
-// ------------------------------------------------------------------------------------------------
-void MMDImporter::CreateDataFromImport(const pmx::PmxModel *pModel,
-                                       aiScene *pScene) {
-  if (pModel == NULL) {
-    return;
-  }
-
-  aiNode *pNode = new aiNode;
-  if (!pModel->model_name.empty()) {
-    pNode->mName.Set(pModel->model_name);
-  }
-
-  pScene->mRootNode = pNode;
-
-  pNode = new aiNode;
-  pScene->mRootNode->addChildren(1, &pNode);
-  pNode->mName.Set(string(pModel->model_name) + string("_mesh"));
-
-  // split mesh by materials
-  pNode->mNumMeshes = pModel->material_count;
-  pNode->mMeshes = new unsigned int[pNode->mNumMeshes];
-  for (unsigned int index = 0; index < pNode->mNumMeshes; index++) {
-    pNode->mMeshes[index] = index;
-  }
-
-  pScene->mNumMeshes = pModel->material_count;
-  pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
-  for (unsigned int i = 0, indexStart = 0; i < pScene->mNumMeshes; i++) {
-    const int indexCount = pModel->materials[i].index_count;
-
-    pScene->mMeshes[i] = CreateMesh(pModel, indexStart, indexCount);
-    pScene->mMeshes[i]->mName = pModel->materials[i].material_name;
-    pScene->mMeshes[i]->mMaterialIndex = i;
-    indexStart += indexCount;
-  }
-
-  // create node hierarchy for bone position
-  std::unique_ptr<aiNode *[]> ppNode(new aiNode *[pModel->bone_count]);
-  for (auto i = 0; i < pModel->bone_count; i++) {
-    ppNode[i] = new aiNode(pModel->bones[i].bone_name);
-  }
-
-  for (auto i = 0; i < pModel->bone_count; i++) {
-    const pmx::PmxBone &bone = pModel->bones[i];
-
-    if (bone.parent_index < 0) {
-      pScene->mRootNode->addChildren(1, ppNode.get() + i);
-    } else {
-      ppNode[bone.parent_index]->addChildren(1, ppNode.get() + i);
-
-      aiVector3D v3 = aiVector3D(
-          bone.position[0] - pModel->bones[bone.parent_index].position[0],
-          bone.position[1] - pModel->bones[bone.parent_index].position[1],
-          bone.position[2] - pModel->bones[bone.parent_index].position[2]);
-      aiMatrix4x4::Translation(v3, ppNode[i]->mTransformation);
-    }
-  }
-
-  // create materials
-  pScene->mNumMaterials = pModel->material_count;
-  pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials];
-  for (unsigned int i = 0; i < pScene->mNumMaterials; i++) {
-    pScene->mMaterials[i] = CreateMaterial(&pModel->materials[i], pModel);
-  }
-
-  // Convert everything to OpenGL space
-  MakeLeftHandedProcess convertProcess;
-  convertProcess.Execute(pScene);
-
-  FlipUVsProcess uvFlipper;
-  uvFlipper.Execute(pScene);
-
-  FlipWindingOrderProcess windingFlipper;
-  windingFlipper.Execute(pScene);
-}
-
-// ------------------------------------------------------------------------------------------------
-aiMesh *MMDImporter::CreateMesh(const pmx::PmxModel *pModel,
-                                const int indexStart, const int indexCount) {
-  aiMesh *pMesh = new aiMesh;
-
-  pMesh->mNumVertices = indexCount;
-
-  pMesh->mNumFaces = indexCount / 3;
-  pMesh->mFaces = new aiFace[pMesh->mNumFaces];
-
-  const int numIndices = 3; // triangular face
-  for (unsigned int index = 0; index < pMesh->mNumFaces; index++) {
-    pMesh->mFaces[index].mNumIndices = numIndices;
-    unsigned int *indices = new unsigned int[numIndices];
-    indices[0] = numIndices * index;
-    indices[1] = numIndices * index + 1;
-    indices[2] = numIndices * index + 2;
-    pMesh->mFaces[index].mIndices = indices;
-  }
-
-  pMesh->mVertices = new aiVector3D[pMesh->mNumVertices];
-  pMesh->mNormals = new aiVector3D[pMesh->mNumVertices];
-  pMesh->mTextureCoords[0] = new aiVector3D[pMesh->mNumVertices];
-  pMesh->mNumUVComponents[0] = 2;
-
-  // additional UVs
-  for (int i = 1; i <= pModel->setting.uv; i++) {
-    pMesh->mTextureCoords[i] = new aiVector3D[pMesh->mNumVertices];
-    pMesh->mNumUVComponents[i] = 4;
-  }
-
-  map<int, vector<aiVertexWeight>> bone_vertex_map;
-
-  // fill in contents and create bones
-  for (int index = 0; index < indexCount; index++) {
-    const pmx::PmxVertex *v =
-        &pModel->vertices[pModel->indices[indexStart + index]];
-    const float *position = v->position;
-    pMesh->mVertices[index].Set(position[0], position[1], position[2]);
-    const float *normal = v->normal;
-
-    pMesh->mNormals[index].Set(normal[0], normal[1], normal[2]);
-    pMesh->mTextureCoords[0][index].x = v->uv[0];
-    pMesh->mTextureCoords[0][index].y = v->uv[1];
-
-    for (int i = 1; i <= pModel->setting.uv; i++) {
-      // TODO: wrong here? use quaternion transform?
-      pMesh->mTextureCoords[i][index].x = v->uva[i][0];
-      pMesh->mTextureCoords[i][index].y = v->uva[i][1];
-    }
-
-    // handle bone map
-    const auto vsBDEF1_ptr =
-        dynamic_cast<pmx::PmxVertexSkinningBDEF1 *>(v->skinning.get());
-    const auto vsBDEF2_ptr =
-        dynamic_cast<pmx::PmxVertexSkinningBDEF2 *>(v->skinning.get());
-    const auto vsBDEF4_ptr =
-        dynamic_cast<pmx::PmxVertexSkinningBDEF4 *>(v->skinning.get());
-    const auto vsSDEF_ptr =
-        dynamic_cast<pmx::PmxVertexSkinningSDEF *>(v->skinning.get());
-    switch (v->skinning_type) {
-    case pmx::PmxVertexSkinningType::BDEF1:
-      bone_vertex_map[vsBDEF1_ptr->bone_index].push_back(
-          aiVertexWeight(index, 1.0));
-      break;
-    case pmx::PmxVertexSkinningType::BDEF2:
-      bone_vertex_map[vsBDEF2_ptr->bone_index1].push_back(
-          aiVertexWeight(index, vsBDEF2_ptr->bone_weight));
-      bone_vertex_map[vsBDEF2_ptr->bone_index2].push_back(
-          aiVertexWeight(index, 1.0f - vsBDEF2_ptr->bone_weight));
-      break;
-    case pmx::PmxVertexSkinningType::BDEF4:
-      bone_vertex_map[vsBDEF4_ptr->bone_index1].push_back(
-          aiVertexWeight(index, vsBDEF4_ptr->bone_weight1));
-      bone_vertex_map[vsBDEF4_ptr->bone_index2].push_back(
-          aiVertexWeight(index, vsBDEF4_ptr->bone_weight2));
-      bone_vertex_map[vsBDEF4_ptr->bone_index3].push_back(
-          aiVertexWeight(index, vsBDEF4_ptr->bone_weight3));
-      bone_vertex_map[vsBDEF4_ptr->bone_index4].push_back(
-          aiVertexWeight(index, vsBDEF4_ptr->bone_weight4));
-      break;
-    case pmx::PmxVertexSkinningType::SDEF: // TODO: how to use sdef_c, sdef_r0,
-                                           // sdef_r1?
-      bone_vertex_map[vsSDEF_ptr->bone_index1].push_back(
-          aiVertexWeight(index, vsSDEF_ptr->bone_weight));
-      bone_vertex_map[vsSDEF_ptr->bone_index2].push_back(
-          aiVertexWeight(index, 1.0f - vsSDEF_ptr->bone_weight));
-      break;
-    case pmx::PmxVertexSkinningType::QDEF:
-      const auto vsQDEF_ptr =
-          dynamic_cast<pmx::PmxVertexSkinningQDEF *>(v->skinning.get());
-      bone_vertex_map[vsQDEF_ptr->bone_index1].push_back(
-          aiVertexWeight(index, vsQDEF_ptr->bone_weight1));
-      bone_vertex_map[vsQDEF_ptr->bone_index2].push_back(
-          aiVertexWeight(index, vsQDEF_ptr->bone_weight2));
-      bone_vertex_map[vsQDEF_ptr->bone_index3].push_back(
-          aiVertexWeight(index, vsQDEF_ptr->bone_weight3));
-      bone_vertex_map[vsQDEF_ptr->bone_index4].push_back(
-          aiVertexWeight(index, vsQDEF_ptr->bone_weight4));
-      break;
-    }
-  }
-
-  // make all bones for each mesh
-  // assign bone weights to skinned bones (otherwise just initialize)
-  auto bone_ptr_ptr = new aiBone *[pModel->bone_count];
-  pMesh->mNumBones = pModel->bone_count;
-  pMesh->mBones = bone_ptr_ptr;
-  for (auto ii = 0; ii < pModel->bone_count; ++ii) {
-    auto pBone = new aiBone;
-    const auto &pmxBone = pModel->bones[ii];
-    pBone->mName = pmxBone.bone_name;
-    aiVector3D pos(pmxBone.position[0], pmxBone.position[1], pmxBone.position[2]);
-    aiMatrix4x4::Translation(-pos, pBone->mOffsetMatrix);
-    auto it = bone_vertex_map.find(ii);
-    if (it != bone_vertex_map.end()) {
-      pBone->mNumWeights = static_cast<unsigned int>(it->second.size());
-      pBone->mWeights = new aiVertexWeight[pBone->mNumWeights];
-      for (unsigned int j = 0; j < pBone->mNumWeights; j++) {
-          pBone->mWeights[j] = it->second[j];
-      }
-    }
-    bone_ptr_ptr[ii] = pBone;
-  }
-
-  return pMesh;
-}
-
-// ------------------------------------------------------------------------------------------------
-aiMaterial *MMDImporter::CreateMaterial(const pmx::PmxMaterial *pMat,
-                                        const pmx::PmxModel *pModel) {
-  aiMaterial *mat = new aiMaterial();
-  aiString name(pMat->material_english_name);
-  mat->AddProperty(&name, AI_MATKEY_NAME);
-
-  aiColor3D diffuse(pMat->diffuse[0], pMat->diffuse[1], pMat->diffuse[2]);
-  mat->AddProperty(&diffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
-  aiColor3D specular(pMat->specular[0], pMat->specular[1], pMat->specular[2]);
-  mat->AddProperty(&specular, 1, AI_MATKEY_COLOR_SPECULAR);
-  aiColor3D ambient(pMat->ambient[0], pMat->ambient[1], pMat->ambient[2]);
-  mat->AddProperty(&ambient, 1, AI_MATKEY_COLOR_AMBIENT);
-
-  float opacity = pMat->diffuse[3];
-  mat->AddProperty(&opacity, 1, AI_MATKEY_OPACITY);
-  float shininess = pMat->specularlity;
-  mat->AddProperty(&shininess, 1, AI_MATKEY_SHININESS_STRENGTH);
-
-  if(pMat->diffuse_texture_index >= 0) {
-      aiString texture_path(pModel->textures[pMat->diffuse_texture_index]);
-      mat->AddProperty(&texture_path, AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE, 0));
-  }
-
-  int mapping_uvwsrc = 0;
-  mat->AddProperty(&mapping_uvwsrc, 1,
-                   AI_MATKEY_UVWSRC(aiTextureType_DIFFUSE, 0));
-
-  return mat;
-}
-
-// ------------------------------------------------------------------------------------------------
-
-} // Namespace Assimp
-
-#endif // !! ASSIMP_BUILD_NO_MMD_IMPORTER
diff --git a/Engine/lib/assimp/code/Material/MaterialSystem.cpp b/Engine/lib/assimp/code/Material/MaterialSystem.cpp
index ecdf9942c..b2f738959 100644
--- a/Engine/lib/assimp/code/Material/MaterialSystem.cpp
+++ b/Engine/lib/assimp/code/Material/MaterialSystem.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -44,77 +44,73 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Implementation of the material system of the library
  */
 
-#include <assimp/Hash.h>
-#include <assimp/fast_atof.h>
-#include <assimp/ParsingUtils.h>
 #include "MaterialSystem.h"
-#include <assimp/types.h>
+#include <assimp/Hash.h>
+#include <assimp/ParsingUtils.h>
+#include <assimp/fast_atof.h>
 #include <assimp/material.h>
+#include <assimp/types.h>
 #include <assimp/DefaultLogger.hpp>
-#include <assimp/Macros.h>
 
 using namespace Assimp;
 
 // ------------------------------------------------------------------------------------------------
 // Get a specific property from a material
-aiReturn aiGetMaterialProperty(const aiMaterial* pMat,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index,
-    const aiMaterialProperty** pPropOut)
-{
-    ai_assert( pMat != NULL );
-    ai_assert( pKey != NULL );
-    ai_assert( pPropOut != NULL );
+aiReturn aiGetMaterialProperty(const aiMaterial *pMat,
+        const char *pKey,
+        unsigned int type,
+        unsigned int index,
+        const aiMaterialProperty **pPropOut) {
+    ai_assert(pMat != nullptr);
+    ai_assert(pKey != nullptr);
+    ai_assert(pPropOut != nullptr);
 
     /*  Just search for a property with exactly this name ..
      *  could be improved by hashing, but it's possibly
      *  no worth the effort (we're bound to C structures,
      *  thus std::map or derivates are not applicable. */
-    for ( unsigned int i = 0; i < pMat->mNumProperties; ++i ) {
-        aiMaterialProperty* prop = pMat->mProperties[i];
+    for (unsigned int i = 0; i < pMat->mNumProperties; ++i) {
+        aiMaterialProperty *prop = pMat->mProperties[i];
 
         if (prop /* just for safety ... */
-            && 0 == strcmp( prop->mKey.data, pKey )
-            && (UINT_MAX == type  || prop->mSemantic == type) /* UINT_MAX is a wild-card, but this is undocumented :-) */
-            && (UINT_MAX == index || prop->mIndex == index))
-        {
+                && 0 == strcmp(prop->mKey.data, pKey) && (UINT_MAX == type || prop->mSemantic == type) /* UINT_MAX is a wild-card, but this is undocumented :-) */
+                && (UINT_MAX == index || prop->mIndex == index)) {
             *pPropOut = pMat->mProperties[i];
             return AI_SUCCESS;
         }
     }
-    *pPropOut = NULL;
+    *pPropOut = nullptr;
     return AI_FAILURE;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get an array of floating-point values from the material.
-aiReturn aiGetMaterialFloatArray(const aiMaterial* pMat,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index,
-    ai_real* pOut,
-    unsigned int* pMax)
-{
-    ai_assert( pOut != nullptr );
-    ai_assert( pMat != nullptr );
+aiReturn aiGetMaterialFloatArray(const aiMaterial *pMat,
+        const char *pKey,
+        unsigned int type,
+        unsigned int index,
+        ai_real *pOut,
+        unsigned int *pMax) {
+    ai_assert(pOut != nullptr);
+    ai_assert(pMat != nullptr);
 
-    const aiMaterialProperty* prop;
-    aiGetMaterialProperty(pMat,pKey,type,index, (const aiMaterialProperty**) &prop);
-    if ( nullptr == prop) {
+    const aiMaterialProperty *prop;
+    aiGetMaterialProperty(pMat, pKey, type, index, (const aiMaterialProperty **)&prop);
+    if (nullptr == prop) {
         return AI_FAILURE;
     }
 
     // data is given in floats, convert to ai_real
     unsigned int iWrite = 0;
-    if( aiPTI_Float == prop->mType || aiPTI_Buffer == prop->mType)  {
+    if (aiPTI_Float == prop->mType || aiPTI_Buffer == prop->mType) {
         iWrite = prop->mDataLength / sizeof(float);
         if (pMax) {
-            iWrite = std::min(*pMax,iWrite); ;
+            iWrite = std::min(*pMax, iWrite);
+            ;
         }
 
         for (unsigned int a = 0; a < iWrite; ++a) {
-            pOut[ a ] = static_cast<ai_real> ( reinterpret_cast<float*>(prop->mData)[a] );
+            pOut[a] = static_cast<ai_real>(reinterpret_cast<float *>(prop->mData)[a]);
         }
 
         if (pMax) {
@@ -122,26 +118,28 @@ aiReturn aiGetMaterialFloatArray(const aiMaterial* pMat,
         }
     }
     // data is given in doubles, convert to float
-    else if( aiPTI_Double == prop->mType)  {
+    else if (aiPTI_Double == prop->mType) {
         iWrite = prop->mDataLength / sizeof(double);
         if (pMax) {
-            iWrite = std::min(*pMax,iWrite); ;
+            iWrite = std::min(*pMax, iWrite);
+            ;
         }
-        for (unsigned int a = 0; a < iWrite;++a)    {
-            pOut[a] = static_cast<ai_real> ( reinterpret_cast<double*>(prop->mData)[a] );
+        for (unsigned int a = 0; a < iWrite; ++a) {
+            pOut[a] = static_cast<ai_real>(reinterpret_cast<double *>(prop->mData)[a]);
         }
         if (pMax) {
             *pMax = iWrite;
         }
     }
     // data is given in ints, convert to float
-    else if( aiPTI_Integer == prop->mType)  {
+    else if (aiPTI_Integer == prop->mType) {
         iWrite = prop->mDataLength / sizeof(int32_t);
         if (pMax) {
-            iWrite = std::min(*pMax,iWrite); ;
+            iWrite = std::min(*pMax, iWrite);
+            ;
         }
-        for (unsigned int a = 0; a < iWrite;++a)    {
-            pOut[a] = static_cast<ai_real> ( reinterpret_cast<int32_t*>(prop->mData)[a] );
+        for (unsigned int a = 0; a < iWrite; ++a) {
+            pOut[a] = static_cast<ai_real>(reinterpret_cast<int32_t *>(prop->mData)[a]);
         }
         if (pMax) {
             *pMax = iWrite;
@@ -154,16 +152,16 @@ aiReturn aiGetMaterialFloatArray(const aiMaterial* pMat,
         }
         // strings are zero-terminated with a 32 bit length prefix, so this is safe
         const char *cur = prop->mData + 4;
-        ai_assert( prop->mDataLength >= 5 );
-        ai_assert( !prop->mData[ prop->mDataLength - 1 ] );
-        for ( unsigned int a = 0; ;++a) {
-            cur = fast_atoreal_move<ai_real>(cur,pOut[a]);
-            if ( a==iWrite-1 ) {
+        ai_assert(prop->mDataLength >= 5);
+        ai_assert(!prop->mData[prop->mDataLength - 1]);
+        for (unsigned int a = 0;; ++a) {
+            cur = fast_atoreal_move<ai_real>(cur, pOut[a]);
+            if (a == iWrite - 1) {
                 break;
             }
-            if ( !IsSpace(*cur) ) {
-                ASSIMP_LOG_ERROR("Material property" + std::string(pKey) +
-                    " is a string; failed to parse a float array out of it.");
+            if (!IsSpace(*cur)) {
+                ASSIMP_LOG_ERROR("Material property", pKey,
+                                 " is a string; failed to parse a float array out of it.");
                 return AI_FAILURE;
             }
         }
@@ -177,36 +175,34 @@ aiReturn aiGetMaterialFloatArray(const aiMaterial* pMat,
 
 // ------------------------------------------------------------------------------------------------
 // Get an array if integers from the material
-aiReturn aiGetMaterialIntegerArray(const aiMaterial* pMat,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index,
-    int* pOut,
-    unsigned int* pMax)
-{
-    ai_assert( pOut != NULL );
-    ai_assert( pMat != NULL );
+aiReturn aiGetMaterialIntegerArray(const aiMaterial *pMat,
+        const char *pKey,
+        unsigned int type,
+        unsigned int index,
+        int *pOut,
+        unsigned int *pMax) {
+    ai_assert(pOut != nullptr);
+    ai_assert(pMat != nullptr);
 
-    const aiMaterialProperty* prop;
-    aiGetMaterialProperty(pMat,pKey,type,index,(const aiMaterialProperty**) &prop);
+    const aiMaterialProperty *prop;
+    aiGetMaterialProperty(pMat, pKey, type, index, (const aiMaterialProperty **)&prop);
     if (!prop) {
         return AI_FAILURE;
     }
 
     // data is given in ints, simply copy it
     unsigned int iWrite = 0;
-    if( aiPTI_Integer == prop->mType || aiPTI_Buffer == prop->mType)    {
+    if (aiPTI_Integer == prop->mType || aiPTI_Buffer == prop->mType) {
         iWrite = std::max(static_cast<unsigned int>(prop->mDataLength / sizeof(int32_t)), 1u);
         if (pMax) {
-            iWrite = std::min(*pMax,iWrite);
+            iWrite = std::min(*pMax, iWrite);
         }
         if (1 == prop->mDataLength) {
             // bool type, 1 byte
             *pOut = static_cast<int>(*prop->mData);
-        }
-        else {
-            for (unsigned int a = 0; a < iWrite;++a) {
-                pOut[a] = static_cast<int>(reinterpret_cast<int32_t*>(prop->mData)[a]);
+        } else {
+            for (unsigned int a = 0; a < iWrite; ++a) {
+                pOut[a] = static_cast<int>(reinterpret_cast<int32_t *>(prop->mData)[a]);
             }
         }
         if (pMax) {
@@ -214,35 +210,36 @@ aiReturn aiGetMaterialIntegerArray(const aiMaterial* pMat,
         }
     }
     // data is given in floats convert to int
-    else if( aiPTI_Float == prop->mType)    {
+    else if (aiPTI_Float == prop->mType) {
         iWrite = prop->mDataLength / sizeof(float);
         if (pMax) {
-            iWrite = std::min(*pMax,iWrite); ;
+            iWrite = std::min(*pMax, iWrite);
+            ;
         }
-        for (unsigned int a = 0; a < iWrite;++a) {
-            pOut[a] = static_cast<int>(reinterpret_cast<float*>(prop->mData)[a]);
+        for (unsigned int a = 0; a < iWrite; ++a) {
+            pOut[a] = static_cast<int>(reinterpret_cast<float *>(prop->mData)[a]);
         }
         if (pMax) {
             *pMax = iWrite;
         }
     }
     // it is a string ... no way to read something out of this
-    else    {
+    else {
         if (pMax) {
             iWrite = *pMax;
         }
         // strings are zero-terminated with a 32 bit length prefix, so this is safe
-        const char *cur =  prop->mData+4;
-        ai_assert( prop->mDataLength >= 5 );
-        ai_assert( !prop->mData[ prop->mDataLength - 1 ] );
-        for (unsigned int a = 0; ;++a) {
-            pOut[a] = strtol10(cur,&cur);
-            if(a==iWrite-1) {
+        const char *cur = prop->mData + 4;
+        ai_assert(prop->mDataLength >= 5);
+        ai_assert(!prop->mData[prop->mDataLength - 1]);
+        for (unsigned int a = 0;; ++a) {
+            pOut[a] = strtol10(cur, &cur);
+            if (a == iWrite - 1) {
                 break;
             }
-            if(!IsSpace(*cur)) {
-                ASSIMP_LOG_ERROR("Material property" + std::string(pKey) +
-                    " is a string; failed to parse an integer array out of it.");
+            if (!IsSpace(*cur)) {
+                ASSIMP_LOG_ERROR("Material property", pKey,
+                                 " is a string; failed to parse an integer array out of it.");
                 return AI_FAILURE;
             }
         }
@@ -256,14 +253,13 @@ aiReturn aiGetMaterialIntegerArray(const aiMaterial* pMat,
 
 // ------------------------------------------------------------------------------------------------
 // Get a color (3 or 4 floats) from the material
-aiReturn aiGetMaterialColor(const aiMaterial* pMat,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index,
-    aiColor4D* pOut)
-{
+aiReturn aiGetMaterialColor(const aiMaterial *pMat,
+        const char *pKey,
+        unsigned int type,
+        unsigned int index,
+        aiColor4D *pOut) {
     unsigned int iMax = 4;
-    const aiReturn eRet = aiGetMaterialFloatArray(pMat,pKey,type,index,(ai_real*)pOut,&iMax);
+    const aiReturn eRet = aiGetMaterialFloatArray(pMat, pKey, type, index, (ai_real *)pOut, &iMax);
 
     // if no alpha channel is defined: set it to 1.0
     if (3 == iMax) {
@@ -274,47 +270,43 @@ aiReturn aiGetMaterialColor(const aiMaterial* pMat,
 }
 
 // ------------------------------------------------------------------------------------------------
-// Get a aiUVTransform (4 floats) from the material
-aiReturn aiGetMaterialUVTransform(const aiMaterial* pMat,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index,
-    aiUVTransform* pOut)
-{
-    unsigned int iMax = 4;
-    return aiGetMaterialFloatArray(pMat,pKey,type,index,(ai_real*)pOut,&iMax);
+// Get a aiUVTransform (5 floats) from the material
+aiReturn aiGetMaterialUVTransform(const aiMaterial *pMat,
+        const char *pKey,
+        unsigned int type,
+        unsigned int index,
+        aiUVTransform *pOut) {
+    unsigned int iMax = 5;
+    return aiGetMaterialFloatArray(pMat, pKey, type, index, (ai_real *)pOut, &iMax);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get a string from the material
-aiReturn aiGetMaterialString(const aiMaterial* pMat,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index,
-    aiString* pOut)
-{
-    ai_assert (pOut != NULL);
+aiReturn aiGetMaterialString(const aiMaterial *pMat,
+        const char *pKey,
+        unsigned int type,
+        unsigned int index,
+        aiString *pOut) {
+    ai_assert(pOut != nullptr);
 
-    const aiMaterialProperty* prop;
-    aiGetMaterialProperty(pMat,pKey,type,index,(const aiMaterialProperty**)&prop);
+    const aiMaterialProperty *prop;
+    aiGetMaterialProperty(pMat, pKey, type, index, (const aiMaterialProperty **)&prop);
     if (!prop) {
         return AI_FAILURE;
     }
 
-    if( aiPTI_String == prop->mType) {
-        ai_assert(prop->mDataLength>=5);
+    if (aiPTI_String == prop->mType) {
+        ai_assert(prop->mDataLength >= 5);
 
         // The string is stored as 32 but length prefix followed by zero-terminated UTF8 data
-        pOut->length = static_cast<unsigned int>(*reinterpret_cast<uint32_t*>(prop->mData));
+        pOut->length = static_cast<unsigned int>(*reinterpret_cast<uint32_t *>(prop->mData));
 
-        ai_assert( pOut->length+1+4==prop->mDataLength );
-        ai_assert( !prop->mData[ prop->mDataLength - 1 ] );
-        memcpy(pOut->data,prop->mData+4,pOut->length+1);
-    }
-    else {
+        ai_assert(pOut->length + 1 + 4 == prop->mDataLength);
+        ai_assert(!prop->mData[prop->mDataLength - 1]);
+        memcpy(pOut->data, prop->mData + 4, pOut->length + 1);
+    } else {
         // TODO - implement lexical cast as well
-        ASSIMP_LOG_ERROR("Material property" + std::string(pKey) +
-            " was found, but is no string" );
+        ASSIMP_LOG_ERROR("Material property", pKey, " was found, but is no string");
         return AI_FAILURE;
     }
     return AI_SUCCESS;
@@ -322,102 +314,94 @@ aiReturn aiGetMaterialString(const aiMaterial* pMat,
 
 // ------------------------------------------------------------------------------------------------
 // Get the number of textures on a particular texture stack
-unsigned int aiGetMaterialTextureCount(const C_STRUCT aiMaterial* pMat,
-    C_ENUM aiTextureType type)
-{
-    ai_assert (pMat != NULL);
+unsigned int aiGetMaterialTextureCount(const C_STRUCT aiMaterial *pMat, C_ENUM aiTextureType type) {
+    ai_assert(pMat != nullptr);
 
     // Textures are always stored with ascending indices (ValidateDS provides a check, so we don't need to do it again)
     unsigned int max = 0;
-    for (unsigned int i = 0; i < pMat->mNumProperties;++i) {
-        aiMaterialProperty* prop = pMat->mProperties[i];
+    for (unsigned int i = 0; i < pMat->mNumProperties; ++i) {
+        aiMaterialProperty *prop = pMat->mProperties[i];
 
-        if ( prop /* just a sanity check ... */
-            && 0 == strcmp( prop->mKey.data, _AI_MATKEY_TEXTURE_BASE )
-            && prop->mSemantic == type) {
+        if (prop /* just a sanity check ... */
+                && 0 == strcmp(prop->mKey.data, _AI_MATKEY_TEXTURE_BASE) && static_cast<aiTextureType>(prop->mSemantic) == type) {
 
-            max = std::max(max,prop->mIndex+1);
+            max = std::max(max, prop->mIndex + 1);
         }
     }
     return max;
 }
 
 // ------------------------------------------------------------------------------------------------
-aiReturn aiGetMaterialTexture(const C_STRUCT aiMaterial* mat,
-    aiTextureType type,
-    unsigned int  index,
-    C_STRUCT aiString* path,
-    aiTextureMapping* _mapping  /*= NULL*/,
-    unsigned int* uvindex       /*= NULL*/,
-    ai_real* blend              /*= NULL*/,
-    aiTextureOp* op             /*= NULL*/,
-    aiTextureMapMode* mapmode   /*= NULL*/,
-    unsigned int* flags         /*= NULL*/
-    )
-{
-    ai_assert( NULL != mat );
-    ai_assert( NULL != path );
+aiReturn aiGetMaterialTexture(const C_STRUCT aiMaterial *mat,
+        aiTextureType type,
+        unsigned int index,
+        C_STRUCT aiString *path,
+        aiTextureMapping *_mapping /*= nullptr*/,
+        unsigned int *uvindex /*= nullptr*/,
+        ai_real *blend /*= nullptr*/,
+        aiTextureOp *op /*= nullptr*/,
+        aiTextureMapMode *mapmode /*= nullptr*/,
+        unsigned int *flags /*= nullptr*/
+) {
+    ai_assert(nullptr != mat);
+    ai_assert(nullptr != path);
 
     // Get the path to the texture
-    if (AI_SUCCESS != aiGetMaterialString(mat,AI_MATKEY_TEXTURE(type,index),path))  {
+    if (AI_SUCCESS != aiGetMaterialString(mat, AI_MATKEY_TEXTURE(type, index), path)) {
         return AI_FAILURE;
     }
 
     // Determine mapping type
     int mapping_ = static_cast<int>(aiTextureMapping_UV);
-    aiGetMaterialInteger(mat,AI_MATKEY_MAPPING(type,index), &mapping_);
+    aiGetMaterialInteger(mat, AI_MATKEY_MAPPING(type, index), &mapping_);
     aiTextureMapping mapping = static_cast<aiTextureMapping>(mapping_);
     if (_mapping)
         *_mapping = mapping;
 
     // Get UV index
-    if (aiTextureMapping_UV == mapping && uvindex)  {
-        aiGetMaterialInteger(mat,AI_MATKEY_UVWSRC(type,index),(int*)uvindex);
+    if (aiTextureMapping_UV == mapping && uvindex) {
+        aiGetMaterialInteger(mat, AI_MATKEY_UVWSRC(type, index), (int *)uvindex);
     }
     // Get blend factor
-    if (blend)  {
-        aiGetMaterialFloat(mat,AI_MATKEY_TEXBLEND(type,index),blend);
+    if (blend) {
+        aiGetMaterialFloat(mat, AI_MATKEY_TEXBLEND(type, index), blend);
     }
     // Get texture operation
-    if (op){
-        aiGetMaterialInteger(mat,AI_MATKEY_TEXOP(type,index),(int*)op);
+    if (op) {
+        aiGetMaterialInteger(mat, AI_MATKEY_TEXOP(type, index), (int *)op);
     }
     // Get texture mapping modes
-    if (mapmode)    {
-        aiGetMaterialInteger(mat,AI_MATKEY_MAPPINGMODE_U(type,index),(int*)&mapmode[0]);
-        aiGetMaterialInteger(mat,AI_MATKEY_MAPPINGMODE_V(type,index),(int*)&mapmode[1]);
+    if (mapmode) {
+        aiGetMaterialInteger(mat, AI_MATKEY_MAPPINGMODE_U(type, index), (int *)&mapmode[0]);
+        aiGetMaterialInteger(mat, AI_MATKEY_MAPPINGMODE_V(type, index), (int *)&mapmode[1]);
     }
     // Get texture flags
-    if (flags){
-        aiGetMaterialInteger(mat,AI_MATKEY_TEXFLAGS(type,index),(int*)flags);
+    if (flags) {
+        aiGetMaterialInteger(mat, AI_MATKEY_TEXFLAGS(type, index), (int *)flags);
     }
 
     return AI_SUCCESS;
 }
 
-
 static const unsigned int DefaultNumAllocated = 5;
 
 // ------------------------------------------------------------------------------------------------
 // Construction. Actually the one and only way to get an aiMaterial instance
-aiMaterial::aiMaterial() 
-: mProperties( nullptr )
-, mNumProperties( 0 )
-, mNumAllocated( DefaultNumAllocated ) {
+aiMaterial::aiMaterial() :
+        mProperties(nullptr), mNumProperties(0), mNumAllocated(DefaultNumAllocated) {
     // Allocate 5 entries by default
-    mProperties = new aiMaterialProperty*[ DefaultNumAllocated ];
+    mProperties = new aiMaterialProperty *[DefaultNumAllocated];
 }
 
 // ------------------------------------------------------------------------------------------------
-aiMaterial::~aiMaterial()
-{
+aiMaterial::~aiMaterial() {
     Clear();
 
     delete[] mProperties;
 }
 
 // ------------------------------------------------------------------------------------------------
-aiString aiMaterial::GetName() {
+aiString aiMaterial::GetName() const {
     aiString name;
     Get(AI_MATKEY_NAME, name);
 
@@ -425,11 +409,10 @@ aiString aiMaterial::GetName() {
 }
 
 // ------------------------------------------------------------------------------------------------
-void aiMaterial::Clear()
-{
-    for ( unsigned int i = 0; i < mNumProperties; ++i )    {
+void aiMaterial::Clear() {
+    for (unsigned int i = 0; i < mNumProperties; ++i) {
         // delete this entry
-        delete mProperties[ i ];
+        delete mProperties[i];
         AI_DEBUG_INVALIDATE_PTR(mProperties[i]);
     }
     mNumProperties = 0;
@@ -438,23 +421,21 @@ void aiMaterial::Clear()
 }
 
 // ------------------------------------------------------------------------------------------------
-aiReturn aiMaterial::RemoveProperty ( const char* pKey,unsigned int type, unsigned int index )
-{
-    ai_assert( nullptr != pKey );
+aiReturn aiMaterial::RemoveProperty(const char *pKey, unsigned int type, unsigned int index) {
+    ai_assert(nullptr != pKey);
 
-    for (unsigned int i = 0; i < mNumProperties;++i) {
-        aiMaterialProperty* prop = mProperties[i];
+    for (unsigned int i = 0; i < mNumProperties; ++i) {
+        aiMaterialProperty *prop = mProperties[i];
 
-        if (prop && !strcmp( prop->mKey.data, pKey ) &&
-            prop->mSemantic == type && prop->mIndex == index)
-        {
+        if (prop && !strcmp(prop->mKey.data, pKey) &&
+                prop->mSemantic == type && prop->mIndex == index) {
             // Delete this entry
             delete mProperties[i];
 
             // collapse the array behind --.
             --mNumProperties;
-            for (unsigned int a = i; a < mNumProperties;++a)    {
-                mProperties[a] = mProperties[a+1];
+            for (unsigned int a = i; a < mNumProperties; ++a) {
+                mProperties[a] = mProperties[a + 1];
             }
             return AI_SUCCESS;
         }
@@ -464,29 +445,27 @@ aiReturn aiMaterial::RemoveProperty ( const char* pKey,unsigned int type, unsign
 }
 
 // ------------------------------------------------------------------------------------------------
-aiReturn aiMaterial::AddBinaryProperty (const void* pInput,
-    unsigned int pSizeInBytes,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index,
-    aiPropertyTypeInfo pType
-    )
-{
-    ai_assert( pInput != NULL );
-    ai_assert( pKey != NULL );
-    ai_assert( 0 != pSizeInBytes );
-
-    if ( 0 == pSizeInBytes ) {
+aiReturn aiMaterial::AddBinaryProperty(const void *pInput,
+        unsigned int pSizeInBytes,
+        const char *pKey,
+        unsigned int type,
+        unsigned int index,
+        aiPropertyTypeInfo pType) {
+    ai_assert(pInput != nullptr);
+    ai_assert(pKey != nullptr);
+    ai_assert(0 != pSizeInBytes);
 
+    if (0 == pSizeInBytes) {
+        return AI_FAILURE;
     }
 
     // first search the list whether there is already an entry with this key
-    unsigned int iOutIndex( UINT_MAX );
-    for ( unsigned int i = 0; i < mNumProperties; ++i ) {
-        aiMaterialProperty *prop( mProperties[ i ] );
+    unsigned int iOutIndex(UINT_MAX);
+    for (unsigned int i = 0; i < mNumProperties; ++i) {
+        aiMaterialProperty *prop(mProperties[i]);
 
-        if (prop /* just for safety */ && !strcmp( prop->mKey.data, pKey ) &&
-            prop->mSemantic == type && prop->mIndex == index){
+        if (prop /* just for safety */ && !strcmp(prop->mKey.data, pKey) &&
+                prop->mSemantic == type && prop->mIndex == index) {
 
             delete mProperties[i];
             iOutIndex = i;
@@ -494,7 +473,7 @@ aiReturn aiMaterial::AddBinaryProperty (const void* pInput,
     }
 
     // Allocate a new material property
-    aiMaterialProperty* pcNew = new aiMaterialProperty();
+    aiMaterialProperty *pcNew = new aiMaterialProperty();
 
     // .. and fill it
     pcNew->mType = pType;
@@ -503,32 +482,32 @@ aiReturn aiMaterial::AddBinaryProperty (const void* pInput,
 
     pcNew->mDataLength = pSizeInBytes;
     pcNew->mData = new char[pSizeInBytes];
-    memcpy (pcNew->mData,pInput,pSizeInBytes);
+    memcpy(pcNew->mData, pInput, pSizeInBytes);
 
-    pcNew->mKey.length = ::strlen(pKey);
-    ai_assert ( MAXLEN > pcNew->mKey.length);
-    strcpy( pcNew->mKey.data, pKey );
+    pcNew->mKey.length = static_cast<ai_uint32>(::strlen(pKey));
+    ai_assert(MAXLEN > pcNew->mKey.length);
+    strcpy(pcNew->mKey.data, pKey);
 
-    if (UINT_MAX != iOutIndex)  {
+    if (UINT_MAX != iOutIndex) {
         mProperties[iOutIndex] = pcNew;
         return AI_SUCCESS;
     }
 
     // resize the array ... double the storage allocated
-    if (mNumProperties == mNumAllocated)    {
+    if (mNumProperties == mNumAllocated) {
         const unsigned int iOld = mNumAllocated;
         mNumAllocated *= 2;
 
-        aiMaterialProperty** ppTemp;
+        aiMaterialProperty **ppTemp;
         try {
-            ppTemp = new aiMaterialProperty*[mNumAllocated];
-        } catch (std::bad_alloc&) {
+            ppTemp = new aiMaterialProperty *[mNumAllocated];
+        } catch (std::bad_alloc &) {
             delete pcNew;
             return AI_OUTOFMEMORY;
         }
 
         // just copy all items over; then replace the old array
-        memcpy (ppTemp,mProperties,iOld * sizeof(void*));
+        memcpy(ppTemp, mProperties, iOld * sizeof(void *));
 
         delete[] mProperties;
         mProperties = ppTemp;
@@ -540,80 +519,82 @@ aiReturn aiMaterial::AddBinaryProperty (const void* pInput,
 }
 
 // ------------------------------------------------------------------------------------------------
-aiReturn aiMaterial::AddProperty (const aiString* pInput,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index)
-{
-    ai_assert(sizeof(ai_uint32)==4);
+aiReturn aiMaterial::AddProperty(const aiString *pInput,
+        const char *pKey,
+        unsigned int type,
+        unsigned int index) {
+    ai_assert(sizeof(ai_uint32) == 4);
     return AddBinaryProperty(pInput,
-        static_cast<unsigned int>(pInput->length+1+4),
-        pKey,
-        type,
-        index,
-        aiPTI_String);
+            static_cast<unsigned int>(pInput->length + 1 + 4),
+            pKey,
+            type,
+            index,
+            aiPTI_String);
 }
 
 // ------------------------------------------------------------------------------------------------
-uint32_t Assimp::ComputeMaterialHash(const aiMaterial* mat, bool includeMatName /*= false*/)
-{
+uint32_t Assimp::ComputeMaterialHash(const aiMaterial *mat, bool includeMatName /*= false*/) {
     uint32_t hash = 1503; // magic start value, chosen to be my birthday :-)
-    for ( unsigned int i = 0; i < mat->mNumProperties; ++i ) {
-        aiMaterialProperty* prop;
+    for (unsigned int i = 0; i < mat->mNumProperties; ++i) {
+        aiMaterialProperty *prop;
 
         // Exclude all properties whose first character is '?' from the hash
         // See doc for aiMaterialProperty.
-        if ((prop = mat->mProperties[i]) && (includeMatName || prop->mKey.data[0] != '?'))  {
+        prop = mat->mProperties[i];
+        if (nullptr != prop && (includeMatName || prop->mKey.data[0] != '?')) {
 
-            hash = SuperFastHash(prop->mKey.data,(unsigned int)prop->mKey.length,hash);
-            hash = SuperFastHash(prop->mData,prop->mDataLength,hash);
+            hash = SuperFastHash(prop->mKey.data, (unsigned int)prop->mKey.length, hash);
+            hash = SuperFastHash(prop->mData, prop->mDataLength, hash);
 
             // Combine the semantic and the index with the hash
-            hash = SuperFastHash((const char*)&prop->mSemantic,sizeof(unsigned int),hash);
-            hash = SuperFastHash((const char*)&prop->mIndex,sizeof(unsigned int),hash);
+            hash = SuperFastHash((const char *)&prop->mSemantic, sizeof(unsigned int), hash);
+            hash = SuperFastHash((const char *)&prop->mIndex, sizeof(unsigned int), hash);
         }
     }
     return hash;
 }
 
 // ------------------------------------------------------------------------------------------------
-void aiMaterial::CopyPropertyList(aiMaterial* pcDest,
-    const aiMaterial* pcSrc
-    )
-{
-    ai_assert(NULL != pcDest);
-    ai_assert(NULL != pcSrc);
+void aiMaterial::CopyPropertyList(aiMaterial *const pcDest,
+        const aiMaterial *pcSrc) {
+    ai_assert(nullptr != pcDest);
+    ai_assert(nullptr != pcSrc);
+    ai_assert(pcDest->mNumProperties <= pcDest->mNumAllocated);
+    ai_assert(pcSrc->mNumProperties <= pcSrc->mNumAllocated);
 
-    unsigned int iOldNum = pcDest->mNumProperties;
+    const unsigned int iOldNum = pcDest->mNumProperties;
     pcDest->mNumAllocated += pcSrc->mNumAllocated;
     pcDest->mNumProperties += pcSrc->mNumProperties;
 
-    aiMaterialProperty** pcOld = pcDest->mProperties;
-    pcDest->mProperties = new aiMaterialProperty*[pcDest->mNumAllocated];
+    const unsigned int numAllocated = pcDest->mNumAllocated;
+    aiMaterialProperty **pcOld = pcDest->mProperties;
+    pcDest->mProperties = new aiMaterialProperty *[numAllocated];
 
-    if (iOldNum && pcOld)   {
-        for (unsigned int i = 0; i < iOldNum;++i) {
+    ai_assert(!iOldNum || pcOld);
+    ai_assert(iOldNum < numAllocated);
+
+    if (iOldNum && pcOld) {
+        for (unsigned int i = 0; i < iOldNum; ++i) {
             pcDest->mProperties[i] = pcOld[i];
         }
     }
 
-    if ( pcOld ) {
+    if (pcOld) {
         delete[] pcOld;
     }
 
-    for (unsigned int i = iOldNum; i< pcDest->mNumProperties;++i)   {
-        aiMaterialProperty* propSrc = pcSrc->mProperties[i];
+    for (unsigned int i = iOldNum; i < pcDest->mNumProperties; ++i) {
+        aiMaterialProperty *propSrc = pcSrc->mProperties[i];
 
         // search whether we have already a property with this name -> if yes, overwrite it
-        aiMaterialProperty* prop;
-        for ( unsigned int q = 0; q < iOldNum; ++q ) {
+        aiMaterialProperty *prop;
+        for (unsigned int q = 0; q < iOldNum; ++q) {
             prop = pcDest->mProperties[q];
-            if (prop /* just for safety */ && prop->mKey == propSrc->mKey && prop->mSemantic == propSrc->mSemantic
-                && prop->mIndex == propSrc->mIndex) {
+            if (prop /* just for safety */ && prop->mKey == propSrc->mKey && prop->mSemantic == propSrc->mSemantic && prop->mIndex == propSrc->mIndex) {
                 delete prop;
 
                 // collapse the whole array ...
-                memmove(&pcDest->mProperties[q],&pcDest->mProperties[q+1],i-q);
+                memmove(&pcDest->mProperties[q], &pcDest->mProperties[q + 1], i - q);
                 i--;
                 pcDest->mNumProperties--;
             }
@@ -628,6 +609,6 @@ void aiMaterial::CopyPropertyList(aiMaterial* pcDest,
         prop->mIndex = propSrc->mIndex;
 
         prop->mData = new char[propSrc->mDataLength];
-        memcpy(prop->mData,propSrc->mData,prop->mDataLength);
+        memcpy(prop->mData, propSrc->mData, prop->mDataLength);
     }
 }
diff --git a/Engine/lib/assimp/code/Material/MaterialSystem.h b/Engine/lib/assimp/code/Material/MaterialSystem.h
index 67d53578c..41891ad97 100644
--- a/Engine/lib/assimp/code/Material/MaterialSystem.h
+++ b/Engine/lib/assimp/code/Material/MaterialSystem.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Obj/ObjExporter.cpp b/Engine/lib/assimp/code/Obj/ObjExporter.cpp
deleted file mode 100644
index 0a0dbd62c..000000000
--- a/Engine/lib/assimp/code/Obj/ObjExporter.cpp
+++ /dev/null
@@ -1,414 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-#ifndef ASSIMP_BUILD_NO_EXPORT
-#ifndef ASSIMP_BUILD_NO_OBJ_EXPORTER
-
-#include "ObjExporter.h"
-#include <assimp/Exceptional.h>
-#include <assimp/StringComparison.h>
-#include <assimp/version.h>
-#include <assimp/IOSystem.hpp>
-#include <assimp/Exporter.hpp>
-#include <assimp/material.h>
-#include <assimp/scene.h>
-#include <memory>
-
-using namespace Assimp;
-
-namespace Assimp {
-
-// ------------------------------------------------------------------------------------------------
-// Worker function for exporting a scene to Wavefront OBJ. Prototyped and registered in Exporter.cpp
-void ExportSceneObj(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/) {
-    // invoke the exporter
-    ObjExporter exporter(pFile, pScene);
-
-    if (exporter.mOutput.fail() || exporter.mOutputMat.fail()) {
-        throw DeadlyExportError("output data creation failed. Most likely the file became too large: " + std::string(pFile));
-    }
-
-    // we're still here - export successfully completed. Write both the main OBJ file and the material script
-    {
-        std::unique_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wt"));
-        if(outfile == NULL) {
-            throw DeadlyExportError("could not open output .obj file: " + std::string(pFile));
-        }
-        outfile->Write( exporter.mOutput.str().c_str(), static_cast<size_t>(exporter.mOutput.tellp()),1);
-    }
-    {
-        std::unique_ptr<IOStream> outfile (pIOSystem->Open(exporter.GetMaterialLibFileName(),"wt"));
-        if(outfile == NULL) {
-            throw DeadlyExportError("could not open output .mtl file: " + std::string(exporter.GetMaterialLibFileName()));
-        }
-        outfile->Write( exporter.mOutputMat.str().c_str(), static_cast<size_t>(exporter.mOutputMat.tellp()),1);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Worker function for exporting a scene to Wavefront OBJ without the material file. Prototyped and registered in Exporter.cpp
-void ExportSceneObjNoMtl(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* pProperties) {
-    // invoke the exporter
-    ObjExporter exporter(pFile, pScene, true);
-
-    if (exporter.mOutput.fail() || exporter.mOutputMat.fail()) {
-        throw DeadlyExportError("output data creation failed. Most likely the file became too large: " + std::string(pFile));
-    }
-
-    // we're still here - export successfully completed. Write both the main OBJ file and the material script
-    {
-        std::unique_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wt"));
-        if(outfile == NULL) {
-            throw DeadlyExportError("could not open output .obj file: " + std::string(pFile));
-        }
-        outfile->Write( exporter.mOutput.str().c_str(), static_cast<size_t>(exporter.mOutput.tellp()),1);
-    }
-
-
-}
-
-} // end of namespace Assimp
-
-static const std::string MaterialExt = ".mtl";
-
-// ------------------------------------------------------------------------------------------------
-ObjExporter::ObjExporter(const char* _filename, const aiScene* pScene, bool noMtl)
-: filename(_filename)
-, pScene(pScene)
-, vn()
-, vt()
-, vp()
-, useVc(false)
-, mVnMap()
-, mVtMap()
-, mVpMap()
-, mMeshes()
-, endl("\n") {
-    // make sure that all formatting happens using the standard, C locale and not the user's current locale
-    const std::locale& l = std::locale("C");
-    mOutput.imbue(l);
-    mOutput.precision(ASSIMP_AI_REAL_TEXT_PRECISION);
-    mOutputMat.imbue(l);
-    mOutputMat.precision(ASSIMP_AI_REAL_TEXT_PRECISION);
-
-    WriteGeometryFile(noMtl);
-    if ( !noMtl ) {
-        WriteMaterialFile();
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-ObjExporter::~ObjExporter() {
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-std::string ObjExporter::GetMaterialLibName() {
-    // within the Obj file, we use just the relative file name with the path stripped
-    const std::string& s = GetMaterialLibFileName();
-    std::string::size_type il = s.find_last_of("/\\");
-    if (il != std::string::npos) {
-        return s.substr(il + 1);
-    }
-
-    return s;
-}
-
-// ------------------------------------------------------------------------------------------------
-std::string ObjExporter::GetMaterialLibFileName() {
-    // Remove existing .obj file extension so that the final material file name will be fileName.mtl and not fileName.obj.mtl
-    size_t lastdot = filename.find_last_of('.');
-    if ( lastdot != std::string::npos ) {
-        return filename.substr( 0, lastdot ) + MaterialExt;
-    }
-
-    return filename + MaterialExt;
-}
-
-// ------------------------------------------------------------------------------------------------
-void ObjExporter::WriteHeader(std::ostringstream& out) {
-    out << "# File produced by Open Asset Import Library (http://www.assimp.sf.net)" << endl;
-    out << "# (assimp v" << aiGetVersionMajor() << '.' << aiGetVersionMinor() << '.'
-        << aiGetVersionRevision() << ")" << endl  << endl;
-}
-
-// ------------------------------------------------------------------------------------------------
-std::string ObjExporter::GetMaterialName(unsigned int index) {
-    const aiMaterial* const mat = pScene->mMaterials[index];
-    if ( nullptr == mat ) {
-        static const std::string EmptyStr;
-        return EmptyStr;
-    }
-
-    aiString s;
-    if(AI_SUCCESS == mat->Get(AI_MATKEY_NAME,s)) {
-        return std::string(s.data,s.length);
-    }
-
-    char number[ sizeof(unsigned int) * 3 + 1 ];
-    ASSIMP_itoa10(number,index);
-    return "$Material_" + std::string(number);
-}
-
-// ------------------------------------------------------------------------------------------------
-void ObjExporter::WriteMaterialFile() {
-    WriteHeader(mOutputMat);
-
-    for(unsigned int i = 0; i < pScene->mNumMaterials; ++i) {
-        const aiMaterial* const mat = pScene->mMaterials[i];
-
-        int illum = 1;
-        mOutputMat << "newmtl " << GetMaterialName(i)  << endl;
-
-        aiColor4D c;
-        if(AI_SUCCESS == mat->Get(AI_MATKEY_COLOR_DIFFUSE,c)) {
-            mOutputMat << "Kd " << c.r << " " << c.g << " " << c.b << endl;
-        }
-        if(AI_SUCCESS == mat->Get(AI_MATKEY_COLOR_AMBIENT,c)) {
-            mOutputMat << "Ka " << c.r << " " << c.g << " " << c.b << endl;
-        }
-        if(AI_SUCCESS == mat->Get(AI_MATKEY_COLOR_SPECULAR,c)) {
-            mOutputMat << "Ks " << c.r << " " << c.g << " " << c.b << endl;
-        }
-        if(AI_SUCCESS == mat->Get(AI_MATKEY_COLOR_EMISSIVE,c)) {
-            mOutputMat << "Ke " << c.r << " " << c.g << " " << c.b << endl;
-        }
-        if(AI_SUCCESS == mat->Get(AI_MATKEY_COLOR_TRANSPARENT,c)) {
-            mOutputMat << "Tf " << c.r << " " << c.g << " " << c.b << endl;
-        }
-
-        ai_real o;
-        if(AI_SUCCESS == mat->Get(AI_MATKEY_OPACITY,o)) {
-            mOutputMat << "d " << o << endl;
-        }
-        if(AI_SUCCESS == mat->Get(AI_MATKEY_REFRACTI,o)) {
-            mOutputMat << "Ni " << o << endl;
-        }
-
-        if(AI_SUCCESS == mat->Get(AI_MATKEY_SHININESS,o) && o) {
-            mOutputMat << "Ns " << o << endl;
-            illum = 2;
-        }
-
-        mOutputMat << "illum " << illum << endl;
-
-        aiString s;
-        if(AI_SUCCESS == mat->Get(AI_MATKEY_TEXTURE_DIFFUSE(0),s)) {
-            mOutputMat << "map_Kd " << s.data << endl;
-        }
-        if(AI_SUCCESS == mat->Get(AI_MATKEY_TEXTURE_AMBIENT(0),s)) {
-            mOutputMat << "map_Ka " << s.data << endl;
-        }
-        if(AI_SUCCESS == mat->Get(AI_MATKEY_TEXTURE_SPECULAR(0),s)) {
-            mOutputMat << "map_Ks " << s.data << endl;
-        }
-        if(AI_SUCCESS == mat->Get(AI_MATKEY_TEXTURE_SHININESS(0),s)) {
-            mOutputMat << "map_Ns " << s.data << endl;
-        }
-        if(AI_SUCCESS == mat->Get(AI_MATKEY_TEXTURE_OPACITY(0),s)) {
-            mOutputMat << "map_d " << s.data << endl;
-        }
-        if(AI_SUCCESS == mat->Get(AI_MATKEY_TEXTURE_HEIGHT(0),s) || AI_SUCCESS == mat->Get(AI_MATKEY_TEXTURE_NORMALS(0),s)) {
-            // implementations seem to vary here, so write both variants
-            mOutputMat << "bump " << s.data << endl;
-            mOutputMat << "map_bump " << s.data << endl;
-        }
-
-        mOutputMat << endl;
-    }
-}
-
-void ObjExporter::WriteGeometryFile(bool noMtl) {
-    WriteHeader(mOutput);
-    if (!noMtl)
-        mOutput << "mtllib "  << GetMaterialLibName() << endl << endl;
-
-    // collect mesh geometry
-    aiMatrix4x4 mBase;
-    AddNode(pScene->mRootNode, mBase);
-
-    // write vertex positions with colors, if any
-    mVpMap.getKeys( vp );
-    if ( !useVc ) {
-        mOutput << "# " << vp.size() << " vertex positions" << endl;
-        for ( const vertexData& v : vp ) {
-            mOutput << "v  " << v.vp.x << " " << v.vp.y << " " << v.vp.z << endl;
-        }
-    } else {
-        mOutput << "# " << vp.size() << " vertex positions and colors" << endl;
-        for ( const vertexData& v : vp ) {
-            mOutput << "v  " << v.vp.x << " " << v.vp.y << " " << v.vp.z << " " << v.vc.r << " " << v.vc.g << " " << v.vc.b << endl;
-        }
-    }
-    mOutput << endl;
-
-    // write uv coordinates
-    mVtMap.getKeys(vt);
-    mOutput << "# " << vt.size() << " UV coordinates" << endl;
-    for(const aiVector3D& v : vt) {
-        mOutput << "vt " << v.x << " " << v.y << " " << v.z << endl;
-    }
-    mOutput << endl;
-
-    // write vertex normals
-    mVnMap.getKeys(vn);
-    mOutput << "# " << vn.size() << " vertex normals" << endl;
-    for(const aiVector3D& v : vn) {
-        mOutput << "vn " << v.x << " " << v.y << " " << v.z << endl;
-    }
-    mOutput << endl;
-
-    // now write all mesh instances
-    for(const MeshInstance& m : mMeshes) {
-        mOutput << "# Mesh \'" << m.name << "\' with " << m.faces.size() << " faces" << endl;
-        if (!m.name.empty()) {
-            mOutput << "g " << m.name << endl;
-        }
-        if ( !noMtl ) {
-            mOutput << "usemtl " << m.matname << endl;
-        }
-
-        for(const Face& f : m.faces) {
-            mOutput << f.kind << ' ';
-            for(const FaceVertex& fv : f.indices) {
-                mOutput << ' ' << fv.vp;
-
-                if (f.kind != 'p') {
-                    if (fv.vt || f.kind == 'f') {
-                        mOutput << '/';
-                    }
-                    if (fv.vt) {
-                        mOutput << fv.vt;
-                    }
-                    if (f.kind == 'f' && fv.vn) {
-                        mOutput << '/' << fv.vn;
-                    }
-                }
-            }
-
-            mOutput << endl;
-        }
-        mOutput << endl;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void ObjExporter::AddMesh(const aiString& name, const aiMesh* m, const aiMatrix4x4& mat) {
-    mMeshes.push_back(MeshInstance() );
-    MeshInstance& mesh = mMeshes.back();
-
-    if ( nullptr != m->mColors[ 0 ] ) {
-        useVc = true;
-    }
-
-    mesh.name = std::string( name.data, name.length );
-    mesh.matname = GetMaterialName(m->mMaterialIndex);
-
-    mesh.faces.resize(m->mNumFaces);
-
-    for(unsigned int i = 0; i < m->mNumFaces; ++i) {
-        const aiFace& f = m->mFaces[i];
-
-        Face& face = mesh.faces[i];
-        switch (f.mNumIndices) {
-            case 1:
-                face.kind = 'p';
-                break;
-            case 2:
-                face.kind = 'l';
-                break;
-            default:
-                face.kind = 'f';
-        }
-        face.indices.resize(f.mNumIndices);
-
-        for(unsigned int a = 0; a < f.mNumIndices; ++a) {
-            const unsigned int idx = f.mIndices[a];
-
-            aiVector3D vert = mat * m->mVertices[idx];
-
-            if ( nullptr != m->mColors[ 0 ] ) {
-                aiColor4D col4 = m->mColors[ 0 ][ idx ];
-                face.indices[a].vp = mVpMap.getIndex({vert, aiColor3D(col4.r, col4.g, col4.b)});
-            } else {
-                face.indices[a].vp = mVpMap.getIndex({vert, aiColor3D(0,0,0)});
-            }
-
-            if (m->mNormals) {
-                aiVector3D norm = aiMatrix3x3(mat) * m->mNormals[idx];
-                face.indices[a].vn = mVnMap.getIndex(norm);
-            } else {
-                face.indices[a].vn = 0;
-            }
-
-            if ( m->mTextureCoords[ 0 ] ) {
-                face.indices[a].vt = mVtMap.getIndex(m->mTextureCoords[0][idx]);
-            } else {
-                face.indices[a].vt = 0;
-            }
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void ObjExporter::AddNode(const aiNode* nd, const aiMatrix4x4& mParent) {
-    const aiMatrix4x4& mAbs = mParent * nd->mTransformation;
-
-    aiMesh *cm( nullptr );
-    for(unsigned int i = 0; i < nd->mNumMeshes; ++i) {
-        cm = pScene->mMeshes[nd->mMeshes[i]];
-        if (nullptr != cm) {
-            AddMesh(cm->mName, pScene->mMeshes[nd->mMeshes[i]], mAbs);
-        } else {
-            AddMesh(nd->mName, pScene->mMeshes[nd->mMeshes[i]], mAbs);
-        }
-    }
-
-    for(unsigned int i = 0; i < nd->mNumChildren; ++i) {
-        AddNode(nd->mChildren[i], mAbs);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-
-#endif // ASSIMP_BUILD_NO_OBJ_EXPORTER
-#endif // ASSIMP_BUILD_NO_EXPORT
diff --git a/Engine/lib/assimp/code/Obj/ObjExporter.h b/Engine/lib/assimp/code/Obj/ObjExporter.h
deleted file mode 100644
index 0d2b48d6b..000000000
--- a/Engine/lib/assimp/code/Obj/ObjExporter.h
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file ObjExporter.h
- * Declares the exporter class to write a scene to a Collada file
- */
-#ifndef AI_OBJEXPORTER_H_INC
-#define AI_OBJEXPORTER_H_INC
-
-#include <assimp/types.h>
-#include <sstream>
-#include <vector>
-#include <map>
-
-struct aiScene;
-struct aiNode;
-struct aiMesh;
-
-namespace Assimp {
-
-// ------------------------------------------------------------------------------------------------
-/** Helper class to export a given scene to an OBJ file. */
-// ------------------------------------------------------------------------------------------------
-class ObjExporter {
-public:
-    /// Constructor for a specific scene to export
-    ObjExporter(const char* filename, const aiScene* pScene, bool noMtl=false);
-    ~ObjExporter();
-    std::string GetMaterialLibName();
-    std::string GetMaterialLibFileName();
-    
-    /// public string-streams to write all output into
-    std::ostringstream mOutput, mOutputMat;
-
-private:
-    // intermediate data structures
-    struct FaceVertex {
-        FaceVertex()
-        : vp()
-        , vn()
-        , vt() {
-            // empty
-        }
-
-        // one-based, 0 means: 'does not exist'
-        unsigned int vp, vn, vt;
-    };
-
-    struct Face {
-        char kind;
-        std::vector<FaceVertex> indices;
-    };
-
-    struct MeshInstance {
-        std::string name, matname;
-        std::vector<Face> faces;
-    };
-
-    void WriteHeader(std::ostringstream& out);
-    void WriteMaterialFile();
-    void WriteGeometryFile(bool noMtl=false);
-    std::string GetMaterialName(unsigned int index);
-    void AddMesh(const aiString& name, const aiMesh* m, const aiMatrix4x4& mat);
-    void AddNode(const aiNode* nd, const aiMatrix4x4& mParent);
-
-private:
-    std::string filename;
-    const aiScene* const pScene;
-
-    struct vertexData {
-        aiVector3D vp;
-        aiColor3D vc; // OBJ does not support 4D color
-    };
-
-    std::vector<aiVector3D> vn, vt;
-    std::vector<aiColor4D> vc;
-    std::vector<vertexData> vp;
-    bool useVc;
-
-    struct vertexDataCompare {
-        bool operator() ( const vertexData& a, const vertexData& b ) const {
-            // position
-            if (a.vp.x < b.vp.x) return true;
-            if (a.vp.x > b.vp.x) return false;
-            if (a.vp.y < b.vp.y) return true;
-            if (a.vp.y > b.vp.y) return false;
-            if (a.vp.z < b.vp.z) return true;
-            if (a.vp.z > b.vp.z) return false;
-
-            // color
-            if (a.vc.r < b.vc.r) return true;
-            if (a.vc.r > b.vc.r) return false;
-            if (a.vc.g < b.vc.g) return true;
-            if (a.vc.g > b.vc.g) return false;
-            if (a.vc.b < b.vc.b) return true;
-            if (a.vc.b > b.vc.b) return false;
-            return false;
-        }
-    };
-
-    struct aiVectorCompare { 
-        bool operator() (const aiVector3D& a, const aiVector3D& b) const { 
-            if(a.x < b.x) return true; 
-            if(a.x > b.x) return false; 
-            if(a.y < b.y) return true; 
-            if(a.y > b.y) return false; 
-            if(a.z < b.z) return true; 
-            return false;
-        }
-    };
-
-    template <class T, class Compare = std::less<T>>
-    class indexMap {
-        int mNextIndex;
-        typedef std::map<T, int, Compare> dataType;
-        dataType vecMap;
-    
-    public:
-        indexMap()
-        : mNextIndex(1) {
-            // empty
-        }
-
-        int getIndex(const T& key) {
-            typename dataType::iterator vertIt = vecMap.find(key);
-            // vertex already exists, so reference it
-            if(vertIt != vecMap.end()){
-                return vertIt->second;
-            }
-            return vecMap[key] = mNextIndex++;
-        };
-
-        void getKeys( std::vector<T>& keys ) {
-            keys.resize(vecMap.size());
-            for(typename dataType::iterator it = vecMap.begin(); it != vecMap.end(); ++it){
-                keys[it->second-1] = it->first;
-            }
-        };
-    };
-
-    indexMap<aiVector3D, aiVectorCompare> mVnMap, mVtMap;
-    indexMap<vertexData, vertexDataCompare> mVpMap;
-    std::vector<MeshInstance> mMeshes;
-
-    // this endl() doesn't flush() the stream
-    const std::string endl;
-};
-
-}
-
-#endif
diff --git a/Engine/lib/assimp/code/Obj/ObjFileData.h b/Engine/lib/assimp/code/Obj/ObjFileData.h
deleted file mode 100644
index a2d9f2cc7..000000000
--- a/Engine/lib/assimp/code/Obj/ObjFileData.h
+++ /dev/null
@@ -1,339 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-#pragma once
-#ifndef OBJ_FILEDATA_H_INC
-#define OBJ_FILEDATA_H_INC
-
-#include <vector>
-#include <map>
-#include <assimp/types.h>
-#include <assimp/mesh.h>
-
-namespace Assimp {
-namespace ObjFile {
-
-struct Object;
-struct Face;
-struct Material;
-
-// ------------------------------------------------------------------------------------------------
-//! \struct Face
-//! \brief  Data structure for a simple obj-face, describes discredit,l.ation and materials
-// ------------------------------------------------------------------------------------------------
-struct Face {
-    typedef std::vector<unsigned int> IndexArray;
-
-    //! Primitive type
-    aiPrimitiveType m_PrimitiveType;
-    //! Vertex indices
-    IndexArray m_vertices;
-    //! Normal indices
-    IndexArray m_normals;
-    //! Texture coordinates indices
-    IndexArray m_texturCoords;
-    //! Pointer to assigned material
-    Material *m_pMaterial;
-
-    //! \brief  Default constructor
-    Face( aiPrimitiveType pt = aiPrimitiveType_POLYGON) 
-    : m_PrimitiveType( pt )
-    , m_vertices()
-    , m_normals()
-    , m_texturCoords()
-    , m_pMaterial( 0L ) {
-        // empty
-    }
-
-    //! \brief  Destructor
-    ~Face() {
-        // empty
-    }
-};
-
-// ------------------------------------------------------------------------------------------------
-//! \struct Object
-//! \brief  Stores all objects of an obj-file object definition
-// ------------------------------------------------------------------------------------------------
-struct Object {
-    enum ObjectType {
-        ObjType,
-        GroupType
-    };
-
-    //! Object name
-    std::string m_strObjName;
-    //! Transformation matrix, stored in OpenGL format
-    aiMatrix4x4 m_Transformation;
-    //! All sub-objects referenced by this object
-    std::vector<Object*> m_SubObjects;
-    /// Assigned meshes
-    std::vector<unsigned int> m_Meshes;
-
-    //! \brief  Default constructor
-    Object() 
-    : m_strObjName("") {
-        // empty
-    }
-
-    //! \brief  Destructor
-    ~Object() {
-        for ( std::vector<Object*>::iterator it = m_SubObjects.begin(); it != m_SubObjects.end(); ++it) {
-            delete *it;
-        }
-    }
-};
-
-// ------------------------------------------------------------------------------------------------
-//! \struct Material
-//! \brief  Data structure to store all material specific data
-// ------------------------------------------------------------------------------------------------
-struct Material {
-    //! Name of material description
-    aiString MaterialName;
-
-    //! Texture names
-    aiString texture;
-    aiString textureSpecular;
-    aiString textureAmbient;
-    aiString textureEmissive;
-    aiString textureBump;
-    aiString textureNormal;
-    aiString textureReflection[6];
-    aiString textureSpecularity;
-    aiString textureOpacity;
-    aiString textureDisp;
-
-    enum TextureType {
-        TextureDiffuseType = 0,
-        TextureSpecularType,
-        TextureAmbientType,
-        TextureEmissiveType,
-        TextureBumpType,
-        TextureNormalType,
-        TextureReflectionSphereType,
-        TextureReflectionCubeTopType,
-        TextureReflectionCubeBottomType,
-        TextureReflectionCubeFrontType,
-        TextureReflectionCubeBackType,
-        TextureReflectionCubeLeftType,
-        TextureReflectionCubeRightType,
-        TextureSpecularityType,
-        TextureOpacityType,
-        TextureDispType,
-        TextureTypeCount
-    };
-    bool clamp[TextureTypeCount];
-
-    //! Ambient color
-    aiColor3D ambient;
-    //! Diffuse color
-    aiColor3D diffuse;
-    //! Specular color
-    aiColor3D specular;
-    //! Emissive color
-    aiColor3D emissive;
-    //! Alpha value
-    ai_real alpha;
-    //! Shineness factor
-    ai_real shineness;
-    //! Illumination model
-    int illumination_model;
-    //! Index of refraction
-    ai_real ior;
-    //! Transparency color
-    aiColor3D transparent;
-
-    //! Constructor
-    Material()
-    :   diffuse ( ai_real( 0.6 ), ai_real( 0.6 ), ai_real( 0.6 ) )
-    ,   alpha   (ai_real( 1.0 ) )
-    ,   shineness ( ai_real( 0.0) )
-    ,   illumination_model (1)
-    ,   ior     ( ai_real( 1.0 ) )
-    ,   transparent( ai_real( 1.0), ai_real (1.0), ai_real(1.0)) {
-        // empty
-        for (size_t i = 0; i < TextureTypeCount; ++i) {
-            clamp[ i ] = false;
-        }
-    }
-
-    // Destructor
-    ~Material() {
-        // empty
-    }
-};
-
-// ------------------------------------------------------------------------------------------------
-//! \struct Mesh
-//! \brief  Data structure to store a mesh
-// ------------------------------------------------------------------------------------------------
-struct Mesh {
-    static const unsigned int NoMaterial = ~0u;
-    /// The name for the mesh
-    std::string m_name;
-    /// Array with pointer to all stored faces
-    std::vector<Face*> m_Faces;
-    /// Assigned material
-    Material *m_pMaterial;
-    /// Number of stored indices.
-    unsigned int m_uiNumIndices;
-    /// Number of UV
-    unsigned int m_uiUVCoordinates[ AI_MAX_NUMBER_OF_TEXTURECOORDS ];
-    /// Material index.
-    unsigned int m_uiMaterialIndex;
-    /// True, if normals are stored.
-    bool m_hasNormals;
-    /// True, if vertex colors are stored.
-    bool m_hasVertexColors;
-
-    /// Constructor
-    explicit Mesh( const std::string &name )
-    : m_name( name )
-    , m_pMaterial(NULL)
-    , m_uiNumIndices(0)
-    , m_uiMaterialIndex( NoMaterial )
-    , m_hasNormals(false) {
-        memset(m_uiUVCoordinates, 0, sizeof( unsigned int ) * AI_MAX_NUMBER_OF_TEXTURECOORDS);
-    }
-
-    /// Destructor
-    ~Mesh() {
-        for (std::vector<Face*>::iterator it = m_Faces.begin();
-            it != m_Faces.end(); ++it)
-        {
-            delete *it;
-        }
-    }
-};
-
-// ------------------------------------------------------------------------------------------------
-//! \struct Model
-//! \brief  Data structure to store all obj-specific model datas
-// ------------------------------------------------------------------------------------------------
-struct Model {
-    typedef std::map<std::string, std::vector<unsigned int>* > GroupMap;
-    typedef std::map<std::string, std::vector<unsigned int>* >::iterator GroupMapIt;
-    typedef std::map<std::string, std::vector<unsigned int>* >::const_iterator ConstGroupMapIt;
-
-    //! Model name
-    std::string m_ModelName;
-    //! List ob assigned objects
-    std::vector<Object*> m_Objects;
-    //! Pointer to current object
-    ObjFile::Object *m_pCurrent;
-    //! Pointer to current material
-    ObjFile::Material *m_pCurrentMaterial;
-    //! Pointer to default material
-    ObjFile::Material *m_pDefaultMaterial;
-    //! Vector with all generated materials
-    std::vector<std::string> m_MaterialLib;
-    //! Vector with all generated vertices
-    std::vector<aiVector3D> m_Vertices;
-    //! vector with all generated normals
-    std::vector<aiVector3D> m_Normals;
-    //! vector with all vertex colors
-    std::vector<aiVector3D> m_VertexColors;
-    //! Group map
-    GroupMap m_Groups;
-    //! Group to face id assignment
-    std::vector<unsigned int> *m_pGroupFaceIDs;
-    //! Active group
-    std::string m_strActiveGroup;
-    //! Vector with generated texture coordinates
-    std::vector<aiVector3D> m_TextureCoord;
-    //! Maximum dimension of texture coordinates
-    unsigned int m_TextureCoordDim;
-    //! Current mesh instance
-    Mesh *m_pCurrentMesh;
-    //! Vector with stored meshes
-    std::vector<Mesh*> m_Meshes;
-    //! Material map
-    std::map<std::string, Material*> m_MaterialMap;
-
-    //! \brief  The default class constructor
-    Model() :
-        m_ModelName(""),
-        m_pCurrent(NULL),
-        m_pCurrentMaterial(NULL),
-        m_pDefaultMaterial(NULL),
-        m_pGroupFaceIDs(NULL),
-        m_strActiveGroup(""),
-        m_TextureCoordDim(0),
-        m_pCurrentMesh(NULL)
-    {
-        // empty
-    }
-
-    //! \brief  The class destructor
-    ~Model() {
-        // Clear all stored object instances
-        for (std::vector<Object*>::iterator it = m_Objects.begin();
-            it != m_Objects.end(); ++it) {
-            delete *it;
-        }
-        m_Objects.clear();
-
-        // Clear all stored mesh instances
-        for (std::vector<Mesh*>::iterator it = m_Meshes.begin();
-            it != m_Meshes.end(); ++it) {
-            delete *it;
-        }
-        m_Meshes.clear();
-
-        for(GroupMapIt it = m_Groups.begin(); it != m_Groups.end(); ++it) {
-            delete it->second;
-        }
-        m_Groups.clear();
-
-        for ( std::map<std::string, Material*>::iterator it = m_MaterialMap.begin(); it != m_MaterialMap.end(); ++it ) {
-            delete it->second;
-        }
-    }
-};
-
-// ------------------------------------------------------------------------------------------------
-
-} // Namespace ObjFile
-} // Namespace Assimp
-
-#endif // OBJ_FILEDATA_H_INC
diff --git a/Engine/lib/assimp/code/Obj/ObjFileImporter.cpp b/Engine/lib/assimp/code/Obj/ObjFileImporter.cpp
deleted file mode 100644
index 26cc6d1f9..000000000
--- a/Engine/lib/assimp/code/Obj/ObjFileImporter.cpp
+++ /dev/null
@@ -1,784 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-#ifndef ASSIMP_BUILD_NO_OBJ_IMPORTER
-
-#include "ObjFileImporter.h"
-#include "ObjFileParser.h"
-#include "ObjFileData.h"
-#include <assimp/IOStreamBuffer.h>
-#include <memory>
-#include <assimp/DefaultIOSystem.h>
-#include <assimp/Importer.hpp>
-#include <assimp/scene.h>
-#include <assimp/ai_assert.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/importerdesc.h>
-
-static const aiImporterDesc desc = {
-    "Wavefront Object Importer",
-    "",
-    "",
-    "surfaces not supported",
-    aiImporterFlags_SupportTextFlavour,
-    0,
-    0,
-    0,
-    0,
-    "obj"
-};
-
-static const unsigned int ObjMinSize = 16;
-
-namespace Assimp {
-
-using namespace std;
-
-// ------------------------------------------------------------------------------------------------
-//  Default constructor
-ObjFileImporter::ObjFileImporter()
-: m_Buffer()
-, m_pRootObject( nullptr )
-, m_strAbsPath( std::string(1, DefaultIOSystem().getOsSeparator()) ) {}
-
-// ------------------------------------------------------------------------------------------------
-//  Destructor.
-ObjFileImporter::~ObjFileImporter() {
-    delete m_pRootObject;
-    m_pRootObject = nullptr;
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Returns true, if file is an obj file.
-bool ObjFileImporter::CanRead( const std::string& pFile, IOSystem*  pIOHandler , bool checkSig ) const {
-    if(!checkSig)  {
-        //Check File Extension
-        return SimpleExtensionCheck(pFile,"obj");
-    } else {
-        // Check file Header
-        static const char *pTokens[] = { "mtllib", "usemtl", "v ", "vt ", "vn ", "o ", "g ", "s ", "f " };
-        return BaseImporter::SearchFileHeaderForToken(pIOHandler, pFile, pTokens, 9, 200, false, true );
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-const aiImporterDesc* ObjFileImporter::GetInfo() const {
-    return &desc;
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Obj-file import implementation
-void ObjFileImporter::InternReadFile( const std::string &file, aiScene* pScene, IOSystem* pIOHandler) {
-    // Read file into memory
-    static const std::string mode = "rb";
-    std::unique_ptr<IOStream> fileStream( pIOHandler->Open( file, mode));
-    if( !fileStream.get() ) {
-        throw DeadlyImportError( "Failed to open file " + file + "." );
-    }
-
-    // Get the file-size and validate it, throwing an exception when fails
-    size_t fileSize = fileStream->FileSize();
-    if( fileSize < ObjMinSize ) {
-        throw DeadlyImportError( "OBJ-file is too small.");
-    }
-
-    IOStreamBuffer<char> streamedBuffer;
-    streamedBuffer.open( fileStream.get() );
-
-    // Allocate buffer and read file into it
-    //TextFileToBuffer( fileStream.get(),m_Buffer);
-
-    // Get the model name
-    std::string  modelName, folderName;
-    std::string::size_type pos = file.find_last_of( "\\/" );
-    if ( pos != std::string::npos ) {
-        modelName = file.substr(pos+1, file.size() - pos - 1);
-        folderName = file.substr( 0, pos );
-        if ( !folderName.empty() ) {
-            pIOHandler->PushDirectory( folderName );
-        }
-    } else {
-        modelName = file;
-    }
-
-    // parse the file into a temporary representation
-    ObjFileParser parser( streamedBuffer, modelName, pIOHandler, m_progress, file);
-
-    // And create the proper return structures out of it
-    CreateDataFromImport(parser.GetModel(), pScene);
-
-    streamedBuffer.close();
-
-    // Clean up allocated storage for the next import
-    m_Buffer.clear();
-
-    // Pop directory stack
-    if ( pIOHandler->StackSize() > 0 ) {
-        pIOHandler->PopDirectory();
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Create the data from parsed obj-file
-void ObjFileImporter::CreateDataFromImport(const ObjFile::Model* pModel, aiScene* pScene) {
-    if( 0L == pModel ) {
-        return;
-    }
-
-    // Create the root node of the scene
-    pScene->mRootNode = new aiNode;
-    if ( !pModel->m_ModelName.empty() ) {
-        // Set the name of the scene
-        pScene->mRootNode->mName.Set(pModel->m_ModelName);
-    } else {
-        // This is a fatal error, so break down the application
-        ai_assert(false);
-    }
-
-    if (pModel->m_Objects.size() > 0) {
-
-        unsigned int meshCount = 0;
-        unsigned int childCount = 0;
-
-        for(size_t index = 0; index < pModel->m_Objects.size(); ++index) {
-            if(pModel->m_Objects[index]) {
-                ++childCount;
-                meshCount += (unsigned int)pModel->m_Objects[index]->m_Meshes.size();
-            }
-        }
-
-        // Allocate space for the child nodes on the root node
-        pScene->mRootNode->mChildren = new aiNode*[ childCount ];
-
-        // Create nodes for the whole scene
-        std::vector<aiMesh*> MeshArray;
-        MeshArray.reserve(meshCount);
-        for (size_t index = 0; index < pModel->m_Objects.size(); ++index) {
-            createNodes(pModel, pModel->m_Objects[index], pScene->mRootNode, pScene, MeshArray);
-        }
-
-        ai_assert(pScene->mRootNode->mNumChildren == childCount);
-
-        // Create mesh pointer buffer for this scene
-        if (pScene->mNumMeshes > 0) {
-            pScene->mMeshes = new aiMesh*[MeshArray.size()];
-            for (size_t index = 0; index < MeshArray.size(); ++index) {
-                pScene->mMeshes[index] = MeshArray[index];
-            }
-        }
-
-        // Create all materials
-        createMaterials(pModel, pScene);
-    }else {
-		if (pModel->m_Vertices.empty()){
-			return;
-		}
-
-		std::unique_ptr<aiMesh> mesh( new aiMesh );
-        mesh->mPrimitiveTypes = aiPrimitiveType_POINT;
-        unsigned int n = (unsigned int)pModel->m_Vertices.size();
-        mesh->mNumVertices = n;
-
-        mesh->mVertices = new aiVector3D[n];
-        memcpy(mesh->mVertices, pModel->m_Vertices.data(), n*sizeof(aiVector3D) );
-
-        if ( !pModel->m_Normals.empty() ) {
-            mesh->mNormals = new aiVector3D[n];
-            if (pModel->m_Normals.size() < n) {
-                throw DeadlyImportError("OBJ: vertex normal index out of range");
-            }
-            memcpy(mesh->mNormals, pModel->m_Normals.data(), n*sizeof(aiVector3D));
-        }
-
-        if ( !pModel->m_VertexColors.empty() ){
-            mesh->mColors[0] = new aiColor4D[mesh->mNumVertices];
-            for (unsigned int i = 0; i < n; ++i) {
-                if (i < pModel->m_VertexColors.size() ) {
-                    const aiVector3D& color = pModel->m_VertexColors[i];
-                    mesh->mColors[0][i] = aiColor4D(color.x, color.y, color.z, 1.0);
-                }else {
-                    throw DeadlyImportError("OBJ: vertex color index out of range");
-                }
-            }
-        }
-
-        pScene->mRootNode->mNumMeshes = 1;
-        pScene->mRootNode->mMeshes = new unsigned int[1];
-        pScene->mRootNode->mMeshes[0] = 0;
-        pScene->mMeshes = new aiMesh*[1];
-        pScene->mNumMeshes = 1;
-        pScene->mMeshes[0] = mesh.release();
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Creates all nodes of the model
-aiNode *ObjFileImporter::createNodes(const ObjFile::Model* pModel, const ObjFile::Object* pObject,
-                                     aiNode *pParent, aiScene* pScene,
-                                     std::vector<aiMesh*> &MeshArray )
-{
-    ai_assert( NULL != pModel );
-    if( NULL == pObject ) {
-        return NULL;
-    }
-
-    // Store older mesh size to be able to computes mesh offsets for new mesh instances
-    const size_t oldMeshSize = MeshArray.size();
-    aiNode *pNode = new aiNode;
-
-    pNode->mName = pObject->m_strObjName;
-
-    // If we have a parent node, store it
-    ai_assert( NULL != pParent );
-    appendChildToParentNode( pParent, pNode );
-
-    for ( size_t i=0; i< pObject->m_Meshes.size(); ++i ) {
-        unsigned int meshId = pObject->m_Meshes[ i ];
-        aiMesh *pMesh = createTopology( pModel, pObject, meshId );
-        if( pMesh ) {
-            if (pMesh->mNumFaces > 0) {
-                MeshArray.push_back( pMesh );
-            } else {
-                delete pMesh;
-            }
-        }
-    }
-
-    // Create all nodes from the sub-objects stored in the current object
-    if ( !pObject->m_SubObjects.empty() ) {
-        size_t numChilds = pObject->m_SubObjects.size();
-        pNode->mNumChildren = static_cast<unsigned int>( numChilds );
-        pNode->mChildren = new aiNode*[ numChilds ];
-        pNode->mNumMeshes = 1;
-        pNode->mMeshes = new unsigned int[ 1 ];
-    }
-
-    // Set mesh instances into scene- and node-instances
-    const size_t meshSizeDiff = MeshArray.size()- oldMeshSize;
-    if ( meshSizeDiff > 0 ) {
-        pNode->mMeshes = new unsigned int[ meshSizeDiff ];
-        pNode->mNumMeshes = static_cast<unsigned int>( meshSizeDiff );
-        size_t index = 0;
-        for (size_t i = oldMeshSize; i < MeshArray.size(); ++i ) {
-            pNode->mMeshes[ index ] = pScene->mNumMeshes;
-            pScene->mNumMeshes++;
-            ++index;
-        }
-    }
-
-    return pNode;
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Create topology data
-aiMesh *ObjFileImporter::createTopology( const ObjFile::Model* pModel, const ObjFile::Object* pData, unsigned int meshIndex ) {
-    // Checking preconditions
-    ai_assert( NULL != pModel );
-
-    if( NULL == pData ) {
-        return NULL;
-    }
-
-    // Create faces
-    ObjFile::Mesh *pObjMesh = pModel->m_Meshes[ meshIndex ];
-    if( !pObjMesh ) {
-        return NULL;
-    }
-
-    if( pObjMesh->m_Faces.empty() ) {
-        return NULL;
-    }
-
-    std::unique_ptr<aiMesh> pMesh(new aiMesh);
-    if( !pObjMesh->m_name.empty() ) {
-        pMesh->mName.Set( pObjMesh->m_name );
-    }
-
-    for (size_t index = 0; index < pObjMesh->m_Faces.size(); index++)
-    {
-        ObjFile::Face *const inp = pObjMesh->m_Faces[ index ];
-        ai_assert( NULL != inp  );
-
-        if (inp->m_PrimitiveType == aiPrimitiveType_LINE) {
-            pMesh->mNumFaces += static_cast<unsigned int>(inp->m_vertices.size() - 1);
-            pMesh->mPrimitiveTypes |= aiPrimitiveType_LINE;
-        } else if (inp->m_PrimitiveType == aiPrimitiveType_POINT) {
-            pMesh->mNumFaces += static_cast<unsigned int>(inp->m_vertices.size());
-            pMesh->mPrimitiveTypes |= aiPrimitiveType_POINT;
-        } else {
-            ++pMesh->mNumFaces;
-            if (inp->m_vertices.size() > 3) {
-                pMesh->mPrimitiveTypes |= aiPrimitiveType_POLYGON;
-            } else {
-                pMesh->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
-            }
-        }
-    }
-
-    unsigned int uiIdxCount( 0u );
-    if ( pMesh->mNumFaces > 0 ) {
-        pMesh->mFaces = new aiFace[ pMesh->mNumFaces ];
-        if ( pObjMesh->m_uiMaterialIndex != ObjFile::Mesh::NoMaterial ) {
-            pMesh->mMaterialIndex = pObjMesh->m_uiMaterialIndex;
-        }
-
-        unsigned int outIndex( 0 );
-
-        // Copy all data from all stored meshes
-        for (size_t index = 0; index < pObjMesh->m_Faces.size(); index++) {
-            ObjFile::Face* const inp = pObjMesh->m_Faces[ index ];
-            if (inp->m_PrimitiveType == aiPrimitiveType_LINE) {
-                for(size_t i = 0; i < inp->m_vertices.size() - 1; ++i) {
-                    aiFace& f = pMesh->mFaces[ outIndex++ ];
-                    uiIdxCount += f.mNumIndices = 2;
-                    f.mIndices = new unsigned int[2];
-                }
-                continue;
-            }
-            else if (inp->m_PrimitiveType == aiPrimitiveType_POINT) {
-                for(size_t i = 0; i < inp->m_vertices.size(); ++i) {
-                    aiFace& f = pMesh->mFaces[ outIndex++ ];
-                    uiIdxCount += f.mNumIndices = 1;
-                    f.mIndices = new unsigned int[1];
-                }
-                continue;
-            }
-
-            aiFace *pFace = &pMesh->mFaces[ outIndex++ ];
-            const unsigned int uiNumIndices = (unsigned int) pObjMesh->m_Faces[ index ]->m_vertices.size();
-            uiIdxCount += pFace->mNumIndices = (unsigned int) uiNumIndices;
-            if (pFace->mNumIndices > 0) {
-                pFace->mIndices = new unsigned int[ uiNumIndices ];
-            }
-        }
-    }
-
-    // Create mesh vertices
-    createVertexArray(pModel, pData, meshIndex, pMesh.get(), uiIdxCount);
-
-    return pMesh.release();
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Creates a vertex array
-void ObjFileImporter::createVertexArray(const ObjFile::Model* pModel,
-                                        const ObjFile::Object* pCurrentObject,
-                                        unsigned int uiMeshIndex,
-                                        aiMesh* pMesh,
-                                        unsigned int numIndices) {
-    // Checking preconditions
-    ai_assert( NULL != pCurrentObject );
-
-    // Break, if no faces are stored in object
-    if ( pCurrentObject->m_Meshes.empty() )
-        return;
-
-    // Get current mesh
-    ObjFile::Mesh *pObjMesh = pModel->m_Meshes[ uiMeshIndex ];
-    if ( NULL == pObjMesh || pObjMesh->m_uiNumIndices < 1 ) {
-        return;
-    }
-
-    // Copy vertices of this mesh instance
-    pMesh->mNumVertices = numIndices;
-    if (pMesh->mNumVertices == 0) {
-        throw DeadlyImportError( "OBJ: no vertices" );
-    } else if (pMesh->mNumVertices > AI_MAX_VERTICES) {
-        throw DeadlyImportError( "OBJ: Too many vertices" );
-    }
-    pMesh->mVertices = new aiVector3D[ pMesh->mNumVertices ];
-
-    // Allocate buffer for normal vectors
-    if ( !pModel->m_Normals.empty() && pObjMesh->m_hasNormals )
-        pMesh->mNormals = new aiVector3D[ pMesh->mNumVertices ];
-
-    // Allocate buffer for vertex-color vectors
-    if ( !pModel->m_VertexColors.empty() )
-        pMesh->mColors[0] = new aiColor4D[ pMesh->mNumVertices ];
-
-    // Allocate buffer for texture coordinates
-    if ( !pModel->m_TextureCoord.empty() && pObjMesh->m_uiUVCoordinates[0] )
-    {
-        pMesh->mNumUVComponents[ 0 ] = pModel->m_TextureCoordDim;
-        pMesh->mTextureCoords[ 0 ] = new aiVector3D[ pMesh->mNumVertices ];
-    }
-
-    // Copy vertices, normals and textures into aiMesh instance
-    bool normalsok = true, uvok = true;
-    unsigned int newIndex = 0, outIndex = 0;
-    for ( size_t index=0; index < pObjMesh->m_Faces.size(); index++ ) {
-        // Get source face
-        ObjFile::Face *pSourceFace = pObjMesh->m_Faces[ index ];
-
-        // Copy all index arrays
-        for ( size_t vertexIndex = 0, outVertexIndex = 0; vertexIndex < pSourceFace->m_vertices.size(); vertexIndex++ ) {
-            const unsigned int vertex = pSourceFace->m_vertices.at( vertexIndex );
-            if ( vertex >= pModel->m_Vertices.size() ) {
-                throw DeadlyImportError( "OBJ: vertex index out of range" );
-            }
-
-            if ( pMesh->mNumVertices <= newIndex ) {
-                throw DeadlyImportError("OBJ: bad vertex index");
-            }
-
-            pMesh->mVertices[ newIndex ] = pModel->m_Vertices[ vertex ];
-
-            // Copy all normals
-            if ( normalsok && !pModel->m_Normals.empty() && vertexIndex < pSourceFace->m_normals.size()) {
-                const unsigned int normal = pSourceFace->m_normals.at( vertexIndex );
-                if ( normal >= pModel->m_Normals.size() )
-                {
-                    normalsok = false;
-                }
-                else
-                {
-                    pMesh->mNormals[ newIndex ] = pModel->m_Normals[ normal ];
-                }
-            }
-
-            // Copy all vertex colors
-            if ( !pModel->m_VertexColors.empty())
-            {
-                const aiVector3D& color = pModel->m_VertexColors[ vertex ];
-                pMesh->mColors[0][ newIndex ] = aiColor4D(color.x, color.y, color.z, 1.0);
-            }
-
-            // Copy all texture coordinates
-            if ( uvok && !pModel->m_TextureCoord.empty() && vertexIndex < pSourceFace->m_texturCoords.size())
-            {
-                const unsigned int tex = pSourceFace->m_texturCoords.at( vertexIndex );
-
-                if ( tex >= pModel->m_TextureCoord.size() )
-                {
-                    uvok = false;
-                }
-                else
-                {
-                    const aiVector3D &coord3d = pModel->m_TextureCoord[ tex ];
-                    pMesh->mTextureCoords[ 0 ][ newIndex ] = aiVector3D( coord3d.x, coord3d.y, coord3d.z );
-                }
-            }
-
-            // Get destination face
-            aiFace *pDestFace = &pMesh->mFaces[ outIndex ];
-
-            const bool last = ( vertexIndex == pSourceFace->m_vertices.size() - 1 );
-            if (pSourceFace->m_PrimitiveType != aiPrimitiveType_LINE || !last) {
-                pDestFace->mIndices[ outVertexIndex ] = newIndex;
-                outVertexIndex++;
-            }
-
-            if (pSourceFace->m_PrimitiveType == aiPrimitiveType_POINT) {
-                outIndex++;
-                outVertexIndex = 0;
-            } else if (pSourceFace->m_PrimitiveType == aiPrimitiveType_LINE) {
-                outVertexIndex = 0;
-
-                if(!last)
-                    outIndex++;
-
-                if (vertexIndex) {
-                    if(!last) {
-                        pMesh->mVertices[ newIndex+1 ] = pMesh->mVertices[ newIndex ];
-                        if ( !pSourceFace->m_normals.empty() && !pModel->m_Normals.empty()) {
-                            pMesh->mNormals[ newIndex+1 ] = pMesh->mNormals[newIndex ];
-                        }
-                        if ( !pModel->m_TextureCoord.empty() ) {
-                            for ( size_t i=0; i < pMesh->GetNumUVChannels(); i++ ) {
-                                pMesh->mTextureCoords[ i ][ newIndex+1 ] = pMesh->mTextureCoords[ i ][ newIndex ];
-                            }
-                        }
-                        ++newIndex;
-                    }
-
-                    pDestFace[-1].mIndices[1] = newIndex;
-                }
-            }
-            else if (last) {
-                outIndex++;
-            }
-            ++newIndex;
-        }
-    }
-
-    if (!normalsok)
-    {
-        delete [] pMesh->mNormals;
-        pMesh->mNormals = nullptr;
-    }
-
-    if (!uvok)
-    {
-        delete [] pMesh->mTextureCoords[0];
-        pMesh->mTextureCoords[0] = nullptr;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Counts all stored meshes
-void ObjFileImporter::countObjects(const std::vector<ObjFile::Object*> &rObjects, int &iNumMeshes)
-{
-    iNumMeshes = 0;
-    if ( rObjects.empty() )
-        return;
-
-    iNumMeshes += static_cast<unsigned int>( rObjects.size() );
-    for (std::vector<ObjFile::Object*>::const_iterator it = rObjects.begin();
-        it != rObjects.end();
-        ++it)
-    {
-        if (!(*it)->m_SubObjects.empty())
-        {
-            countObjects((*it)->m_SubObjects, iNumMeshes);
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-//   Add clamp mode property to material if necessary
-void ObjFileImporter::addTextureMappingModeProperty( aiMaterial* mat, aiTextureType type, int clampMode, int index) {
-    if ( nullptr == mat ) {
-        return;
-    }
-
-    mat->AddProperty<int>( &clampMode, 1, AI_MATKEY_MAPPINGMODE_U( type, index ) );
-    mat->AddProperty<int>( &clampMode, 1, AI_MATKEY_MAPPINGMODE_V( type, index ) );
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Creates the material
-void ObjFileImporter::createMaterials(const ObjFile::Model* pModel, aiScene* pScene ) {
-    if ( NULL == pScene ) {
-        return;
-    }
-
-    const unsigned int numMaterials = (unsigned int) pModel->m_MaterialLib.size();
-    pScene->mNumMaterials = 0;
-    if ( pModel->m_MaterialLib.empty() ) {
-        ASSIMP_LOG_DEBUG("OBJ: no materials specified");
-        return;
-    }
-
-    pScene->mMaterials = new aiMaterial*[ numMaterials ];
-    for ( unsigned int matIndex = 0; matIndex < numMaterials; matIndex++ )
-    {
-        // Store material name
-        std::map<std::string, ObjFile::Material*>::const_iterator it;
-        it = pModel->m_MaterialMap.find( pModel->m_MaterialLib[ matIndex ] );
-
-        // No material found, use the default material
-        if ( pModel->m_MaterialMap.end() == it )
-            continue;
-
-        aiMaterial* mat = new aiMaterial;
-        ObjFile::Material *pCurrentMaterial = (*it).second;
-        mat->AddProperty( &pCurrentMaterial->MaterialName, AI_MATKEY_NAME );
-
-        // convert illumination model
-        int sm = 0;
-        switch (pCurrentMaterial->illumination_model)
-        {
-        case 0:
-            sm = aiShadingMode_NoShading;
-            break;
-        case 1:
-            sm = aiShadingMode_Gouraud;
-            break;
-        case 2:
-            sm = aiShadingMode_Phong;
-            break;
-        default:
-            sm = aiShadingMode_Gouraud;
-            ASSIMP_LOG_ERROR("OBJ: unexpected illumination model (0-2 recognized)");
-        }
-
-        mat->AddProperty<int>( &sm, 1, AI_MATKEY_SHADING_MODEL);
-
-        // Adding material colors
-        mat->AddProperty( &pCurrentMaterial->ambient, 1, AI_MATKEY_COLOR_AMBIENT );
-        mat->AddProperty( &pCurrentMaterial->diffuse, 1, AI_MATKEY_COLOR_DIFFUSE );
-        mat->AddProperty( &pCurrentMaterial->specular, 1, AI_MATKEY_COLOR_SPECULAR );
-        mat->AddProperty( &pCurrentMaterial->emissive, 1, AI_MATKEY_COLOR_EMISSIVE );
-        mat->AddProperty( &pCurrentMaterial->shineness, 1, AI_MATKEY_SHININESS );
-        mat->AddProperty( &pCurrentMaterial->alpha, 1, AI_MATKEY_OPACITY );
-        mat->AddProperty( &pCurrentMaterial->transparent,1,AI_MATKEY_COLOR_TRANSPARENT);
-
-        // Adding refraction index
-        mat->AddProperty( &pCurrentMaterial->ior, 1, AI_MATKEY_REFRACTI );
-
-        // Adding textures
-        const int uvwIndex = 0;
-
-        if ( 0 != pCurrentMaterial->texture.length )
-        {
-            mat->AddProperty( &pCurrentMaterial->texture, AI_MATKEY_TEXTURE_DIFFUSE(0));
-            mat->AddProperty( &uvwIndex, 1, AI_MATKEY_UVWSRC_DIFFUSE(0) );
-            if (pCurrentMaterial->clamp[ObjFile::Material::TextureDiffuseType])
-            {
-                addTextureMappingModeProperty(mat, aiTextureType_DIFFUSE);
-            }
-        }
-
-        if ( 0 != pCurrentMaterial->textureAmbient.length )
-        {
-            mat->AddProperty( &pCurrentMaterial->textureAmbient, AI_MATKEY_TEXTURE_AMBIENT(0));
-            mat->AddProperty( &uvwIndex, 1, AI_MATKEY_UVWSRC_AMBIENT(0) );
-            if (pCurrentMaterial->clamp[ObjFile::Material::TextureAmbientType])
-            {
-                addTextureMappingModeProperty(mat, aiTextureType_AMBIENT);
-            }
-        }
-
-        if ( 0 != pCurrentMaterial->textureEmissive.length )
-        {
-            mat->AddProperty( &pCurrentMaterial->textureEmissive, AI_MATKEY_TEXTURE_EMISSIVE(0));
-            mat->AddProperty( &uvwIndex, 1, AI_MATKEY_UVWSRC_EMISSIVE(0) );
-        }
-
-        if ( 0 != pCurrentMaterial->textureSpecular.length )
-        {
-            mat->AddProperty( &pCurrentMaterial->textureSpecular, AI_MATKEY_TEXTURE_SPECULAR(0));
-            mat->AddProperty( &uvwIndex, 1, AI_MATKEY_UVWSRC_SPECULAR(0) );
-            if (pCurrentMaterial->clamp[ObjFile::Material::TextureSpecularType])
-            {
-                addTextureMappingModeProperty(mat, aiTextureType_SPECULAR);
-            }
-        }
-
-        if ( 0 != pCurrentMaterial->textureBump.length )
-        {
-            mat->AddProperty( &pCurrentMaterial->textureBump, AI_MATKEY_TEXTURE_HEIGHT(0));
-            mat->AddProperty( &uvwIndex, 1, AI_MATKEY_UVWSRC_HEIGHT(0) );
-            if (pCurrentMaterial->clamp[ObjFile::Material::TextureBumpType])
-            {
-                addTextureMappingModeProperty(mat, aiTextureType_HEIGHT);
-            }
-        }
-
-        if ( 0 != pCurrentMaterial->textureNormal.length )
-        {
-            mat->AddProperty( &pCurrentMaterial->textureNormal, AI_MATKEY_TEXTURE_NORMALS(0));
-            mat->AddProperty( &uvwIndex, 1, AI_MATKEY_UVWSRC_NORMALS(0) );
-            if (pCurrentMaterial->clamp[ObjFile::Material::TextureNormalType])
-            {
-                addTextureMappingModeProperty(mat, aiTextureType_NORMALS);
-            }
-        }
-
-        if( 0 != pCurrentMaterial->textureReflection[0].length )
-        {
-            ObjFile::Material::TextureType type = 0 != pCurrentMaterial->textureReflection[1].length ?
-                ObjFile::Material::TextureReflectionCubeTopType :
-                ObjFile::Material::TextureReflectionSphereType;
-
-            unsigned count = type == ObjFile::Material::TextureReflectionSphereType ? 1 : 6;
-            for( unsigned i = 0; i < count; i++ )
-            {
-                mat->AddProperty(&pCurrentMaterial->textureReflection[i], AI_MATKEY_TEXTURE_REFLECTION(i));
-                mat->AddProperty( &uvwIndex, 1, AI_MATKEY_UVWSRC_REFLECTION(i) );
-
-                if(pCurrentMaterial->clamp[type])
-                    addTextureMappingModeProperty(mat, aiTextureType_REFLECTION, 1, i);
-            }
-        }
-
-        if ( 0 != pCurrentMaterial->textureDisp.length )
-        {
-            mat->AddProperty( &pCurrentMaterial->textureDisp, AI_MATKEY_TEXTURE_DISPLACEMENT(0) );
-            mat->AddProperty( &uvwIndex, 1, AI_MATKEY_UVWSRC_DISPLACEMENT(0) );
-            if (pCurrentMaterial->clamp[ObjFile::Material::TextureDispType])
-            {
-                addTextureMappingModeProperty(mat, aiTextureType_DISPLACEMENT);
-            }
-        }
-
-        if ( 0 != pCurrentMaterial->textureOpacity.length )
-        {
-            mat->AddProperty( &pCurrentMaterial->textureOpacity, AI_MATKEY_TEXTURE_OPACITY(0));
-            mat->AddProperty( &uvwIndex, 1, AI_MATKEY_UVWSRC_OPACITY(0) );
-            if (pCurrentMaterial->clamp[ObjFile::Material::TextureOpacityType])
-            {
-                addTextureMappingModeProperty(mat, aiTextureType_OPACITY);
-            }
-        }
-
-        if ( 0 != pCurrentMaterial->textureSpecularity.length )
-        {
-            mat->AddProperty( &pCurrentMaterial->textureSpecularity, AI_MATKEY_TEXTURE_SHININESS(0));
-            mat->AddProperty( &uvwIndex, 1, AI_MATKEY_UVWSRC_SHININESS(0) );
-            if (pCurrentMaterial->clamp[ObjFile::Material::TextureSpecularityType])
-            {
-                addTextureMappingModeProperty(mat, aiTextureType_SHININESS);
-            }
-        }
-
-        // Store material property info in material array in scene
-        pScene->mMaterials[ pScene->mNumMaterials ] = mat;
-        pScene->mNumMaterials++;
-    }
-
-    // Test number of created materials.
-    ai_assert( pScene->mNumMaterials == numMaterials );
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Appends this node to the parent node
-void ObjFileImporter::appendChildToParentNode(aiNode *pParent, aiNode *pChild)
-{
-    // Checking preconditions
-    ai_assert( NULL != pParent );
-    ai_assert( NULL != pChild );
-
-    // Assign parent to child
-    pChild->mParent = pParent;
-
-    // Copy node instances into parent node
-    pParent->mNumChildren++;
-    pParent->mChildren[ pParent->mNumChildren-1 ] = pChild;
-}
-
-// ------------------------------------------------------------------------------------------------
-
-}   // Namespace Assimp
-
-#endif // !! ASSIMP_BUILD_NO_OBJ_IMPORTER
diff --git a/Engine/lib/assimp/code/Obj/ObjFileImporter.h b/Engine/lib/assimp/code/Obj/ObjFileImporter.h
deleted file mode 100644
index 0df2ef731..000000000
--- a/Engine/lib/assimp/code/Obj/ObjFileImporter.h
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-#ifndef OBJ_FILE_IMPORTER_H_INC
-#define OBJ_FILE_IMPORTER_H_INC
-
-#include <assimp/BaseImporter.h>
-#include <assimp/material.h>
-#include <vector>
-
-struct aiMesh;
-struct aiNode;
-
-namespace Assimp {
-
-namespace ObjFile {
-    struct Object;
-    struct Model;
-}
-
-// ------------------------------------------------------------------------------------------------
-/// \class  ObjFileImporter
-/// \brief  Imports a waveform obj file
-// ------------------------------------------------------------------------------------------------
-class ObjFileImporter : public BaseImporter {
-public:
-    /// \brief  Default constructor
-    ObjFileImporter();
-
-    /// \brief  Destructor
-    ~ObjFileImporter();
-
-public:
-    /// \brief  Returns whether the class can handle the format of the given file.
-    /// \remark See BaseImporter::CanRead() for details.
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const;
-
-private:
-    //! \brief  Appends the supported extension.
-    const aiImporterDesc* GetInfo () const;
-
-    //! \brief  File import implementation.
-    void InternReadFile(const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler);
-
-    //! \brief  Create the data from imported content.
-    void CreateDataFromImport(const ObjFile::Model* pModel, aiScene* pScene);
-
-    //! \brief  Creates all nodes stored in imported content.
-    aiNode *createNodes(const ObjFile::Model* pModel, const ObjFile::Object* pData,
-        aiNode *pParent, aiScene* pScene, std::vector<aiMesh*> &MeshArray);
-
-    //! \brief  Creates topology data like faces and meshes for the geometry.
-    aiMesh *createTopology( const ObjFile::Model* pModel, const ObjFile::Object* pData,
-        unsigned int uiMeshIndex );
-
-    //! \brief  Creates vertices from model.
-    void createVertexArray(const ObjFile::Model* pModel, const ObjFile::Object* pCurrentObject,
-        unsigned int uiMeshIndex, aiMesh* pMesh, unsigned int numIndices );
-
-    //! \brief  Object counter helper method.
-    void countObjects(const std::vector<ObjFile::Object*> &rObjects, int &iNumMeshes);
-
-    //! \brief  Material creation.
-    void createMaterials(const ObjFile::Model* pModel, aiScene* pScene);
-
-    /// @brief  Adds special property for the used texture mapping mode of the model.
-    void addTextureMappingModeProperty(aiMaterial* mat, aiTextureType type, int clampMode = 1, int index = 0);
-
-    //! \brief  Appends a child node to a parent node and updates the data structures.
-    void appendChildToParentNode(aiNode *pParent, aiNode *pChild);
-
-private:
-    //! Data buffer
-    std::vector<char> m_Buffer;
-    //! Pointer to root object instance
-    ObjFile::Object *m_pRootObject;
-    //! Absolute pathname of model in file system
-    std::string m_strAbsPath;
-};
-
-// ------------------------------------------------------------------------------------------------
-
-} // Namespace Assimp
-
-#endif
diff --git a/Engine/lib/assimp/code/Obj/ObjFileMtlImporter.cpp b/Engine/lib/assimp/code/Obj/ObjFileMtlImporter.cpp
deleted file mode 100644
index dd9cc3ce2..000000000
--- a/Engine/lib/assimp/code/Obj/ObjFileMtlImporter.cpp
+++ /dev/null
@@ -1,494 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-
-#ifndef ASSIMP_BUILD_NO_OBJ_IMPORTER
-
-#include <stdlib.h>
-#include "ObjFileMtlImporter.h"
-#include "ObjTools.h"
-#include "ObjFileData.h"
-#include <assimp/fast_atof.h>
-#include <assimp/ParsingUtils.h>
-#include <assimp/material.h>
-#include <assimp/DefaultLogger.hpp>
-
-namespace Assimp    {
-
-// Material specific token (case insensitive compare)
-static const std::string DiffuseTexture       = "map_Kd";
-static const std::string AmbientTexture       = "map_Ka";
-static const std::string SpecularTexture      = "map_Ks";
-static const std::string OpacityTexture       = "map_d";
-static const std::string EmissiveTexture1     = "map_emissive";
-static const std::string EmissiveTexture2     = "map_Ke";
-static const std::string BumpTexture1         = "map_bump";
-static const std::string BumpTexture2         = "bump";
-static const std::string NormalTexture        = "map_Kn";
-static const std::string ReflectionTexture    = "refl";
-static const std::string DisplacementTexture1 = "map_disp";
-static const std::string DisplacementTexture2 = "disp";
-static const std::string SpecularityTexture   = "map_ns";
-
-// texture option specific token
-static const std::string BlendUOption       = "-blendu";
-static const std::string BlendVOption       = "-blendv";
-static const std::string BoostOption        = "-boost";
-static const std::string ModifyMapOption    = "-mm";
-static const std::string OffsetOption       = "-o";
-static const std::string ScaleOption        = "-s";
-static const std::string TurbulenceOption   = "-t";
-static const std::string ResolutionOption   = "-texres";
-static const std::string ClampOption        = "-clamp";
-static const std::string BumpOption         = "-bm";
-static const std::string ChannelOption      = "-imfchan";
-static const std::string TypeOption         = "-type";
-
-// -------------------------------------------------------------------
-//  Constructor
-ObjFileMtlImporter::ObjFileMtlImporter( std::vector<char> &buffer,
-                                       const std::string &,
-                                       ObjFile::Model *pModel ) :
-    m_DataIt( buffer.begin() ),
-    m_DataItEnd( buffer.end() ),
-    m_pModel( pModel ),
-    m_uiLine( 0 )
-{
-    ai_assert( NULL != m_pModel );
-    if ( NULL == m_pModel->m_pDefaultMaterial )
-    {
-        m_pModel->m_pDefaultMaterial = new ObjFile::Material;
-        m_pModel->m_pDefaultMaterial->MaterialName.Set( "default" );
-    }
-    load();
-}
-
-// -------------------------------------------------------------------
-//  Destructor
-ObjFileMtlImporter::~ObjFileMtlImporter()
-{
-    // empty
-}
-
-// -------------------------------------------------------------------
-//  Private copy constructor
-ObjFileMtlImporter::ObjFileMtlImporter(const ObjFileMtlImporter & )
-{
-    // empty
-}
-
-// -------------------------------------------------------------------
-//  Private copy constructor
-ObjFileMtlImporter &ObjFileMtlImporter::operator = ( const ObjFileMtlImporter & )
-{
-    return *this;
-}
-
-// -------------------------------------------------------------------
-//  Loads the material description
-void ObjFileMtlImporter::load()
-{
-    if ( m_DataIt == m_DataItEnd )
-        return;
-
-    while ( m_DataIt != m_DataItEnd )
-    {
-        switch (*m_DataIt)
-        {
-        case 'k':
-        case 'K':
-            {
-                ++m_DataIt;
-                if (*m_DataIt == 'a') // Ambient color
-                {
-                    ++m_DataIt;
-                    getColorRGBA( &m_pModel->m_pCurrentMaterial->ambient );
-                }
-                else if (*m_DataIt == 'd')  // Diffuse color
-                {
-                    ++m_DataIt;
-                    getColorRGBA( &m_pModel->m_pCurrentMaterial->diffuse );
-                }
-                else if (*m_DataIt == 's')
-                {
-                    ++m_DataIt;
-                    getColorRGBA( &m_pModel->m_pCurrentMaterial->specular );
-                }
-                else if (*m_DataIt == 'e')
-                {
-                    ++m_DataIt;
-                    getColorRGBA( &m_pModel->m_pCurrentMaterial->emissive );
-                }
-                m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
-            }
-            break;
-        case 'T':
-            {
-                ++m_DataIt;
-                if (*m_DataIt == 'f') // Material transmission
-                {
-                    ++m_DataIt;
-                    getColorRGBA( &m_pModel->m_pCurrentMaterial->transparent);
-                }
-                m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
-            }
-            break;
-        case 'd':
-            {
-                if( *(m_DataIt+1) == 'i' && *( m_DataIt + 2 ) == 's' && *( m_DataIt + 3 ) == 'p' ) {
-                    // A displacement map
-                    getTexture();
-                } else {
-                    // Alpha value
-                    ++m_DataIt;
-                    getFloatValue( m_pModel->m_pCurrentMaterial->alpha );
-                    m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
-                }
-            }
-            break;
-
-        case 'N':
-        case 'n':
-            {
-                ++m_DataIt;
-                switch(*m_DataIt)
-                {
-                case 's':   // Specular exponent
-                    ++m_DataIt;
-                    getFloatValue(m_pModel->m_pCurrentMaterial->shineness);
-                    break;
-                case 'i':   // Index Of refraction
-                    ++m_DataIt;
-                    getFloatValue(m_pModel->m_pCurrentMaterial->ior);
-                    break;
-                case 'e':   // New material
-                    createMaterial();
-                    break;
-                }
-                m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
-            }
-            break;
-
-        case 'm':   // Texture
-        case 'b':   // quick'n'dirty - for 'bump' sections
-        case 'r':   // quick'n'dirty - for 'refl' sections
-            {
-                getTexture();
-                m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
-            }
-            break;
-
-        case 'i':   // Illumination model
-            {
-                m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
-                getIlluminationModel( m_pModel->m_pCurrentMaterial->illumination_model );
-                m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
-            }
-            break;
-
-        default:
-            {
-                m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
-            }
-            break;
-        }
-    }
-}
-
-// -------------------------------------------------------------------
-//  Loads a color definition
-void ObjFileMtlImporter::getColorRGBA( aiColor3D *pColor )
-{
-    ai_assert( NULL != pColor );
-
-    ai_real r( 0.0 ), g( 0.0 ), b( 0.0 );
-    m_DataIt = getFloat<DataArrayIt>( m_DataIt, m_DataItEnd, r );
-    pColor->r = r;
-
-    // we have to check if color is default 0 with only one token
-    if( !IsLineEnd( *m_DataIt ) ) {
-        m_DataIt = getFloat<DataArrayIt>( m_DataIt, m_DataItEnd, g );
-        m_DataIt = getFloat<DataArrayIt>( m_DataIt, m_DataItEnd, b );
-    }
-    pColor->g = g;
-    pColor->b = b;
-}
-
-// -------------------------------------------------------------------
-//  Loads the kind of illumination model.
-void ObjFileMtlImporter::getIlluminationModel( int &illum_model )
-{
-    m_DataIt = CopyNextWord<DataArrayIt>( m_DataIt, m_DataItEnd, m_buffer, BUFFERSIZE );
-    illum_model = atoi(m_buffer);
-}
-
-// -------------------------------------------------------------------
-//  Loads a single float value.
-void ObjFileMtlImporter::getFloatValue( ai_real &value )
-{
-    m_DataIt = CopyNextWord<DataArrayIt>( m_DataIt, m_DataItEnd, m_buffer, BUFFERSIZE );
-    value = (ai_real) fast_atof(m_buffer);
-}
-
-// -------------------------------------------------------------------
-//  Creates a material from loaded data.
-void ObjFileMtlImporter::createMaterial()
-{
-    std::string line( "" );
-    while( !IsLineEnd( *m_DataIt ) ) {
-        line += *m_DataIt;
-        ++m_DataIt;
-    }
-
-    std::vector<std::string> token;
-    const unsigned int numToken = tokenize<std::string>( line, token, " \t" );
-    std::string name( "" );
-    if ( numToken == 1 ) {
-        name = AI_DEFAULT_MATERIAL_NAME;
-    } else {
-        // skip newmtl and all following white spaces
-        std::size_t first_ws_pos = line.find_first_of(" \t");
-        std::size_t first_non_ws_pos = line.find_first_not_of(" \t", first_ws_pos);
-        if (first_non_ws_pos != std::string::npos) {
-            name = line.substr(first_non_ws_pos);
-        }
-    }
-
-    name = trim_whitespaces(name);
-
-    std::map<std::string, ObjFile::Material*>::iterator it = m_pModel->m_MaterialMap.find( name );
-    if ( m_pModel->m_MaterialMap.end() == it) {
-        // New Material created
-        m_pModel->m_pCurrentMaterial = new ObjFile::Material();
-        m_pModel->m_pCurrentMaterial->MaterialName.Set( name );
-        m_pModel->m_MaterialLib.push_back( name );
-        m_pModel->m_MaterialMap[ name ] = m_pModel->m_pCurrentMaterial;
-
-        if (m_pModel->m_pCurrentMesh) {
-            m_pModel->m_pCurrentMesh->m_uiMaterialIndex = static_cast<unsigned int>(m_pModel->m_MaterialLib.size() - 1);
-        }
-    } else {
-        // Use older material
-        m_pModel->m_pCurrentMaterial = (*it).second;
-    }
-}
-
-// -------------------------------------------------------------------
-//  Gets a texture name from data.
-void ObjFileMtlImporter::getTexture() {
-    aiString *out( NULL );
-    int clampIndex = -1;
-
-    const char *pPtr( &(*m_DataIt) );
-    if ( !ASSIMP_strincmp( pPtr, DiffuseTexture.c_str(), static_cast<unsigned int>(DiffuseTexture.size()) ) ) {
-        // Diffuse texture
-        out = & m_pModel->m_pCurrentMaterial->texture;
-        clampIndex = ObjFile::Material::TextureDiffuseType;
-    } else if ( !ASSIMP_strincmp( pPtr,AmbientTexture.c_str(), static_cast<unsigned int>(AmbientTexture.size()) ) ) {
-        // Ambient texture
-        out = & m_pModel->m_pCurrentMaterial->textureAmbient;
-        clampIndex = ObjFile::Material::TextureAmbientType;
-    } else if ( !ASSIMP_strincmp( pPtr, SpecularTexture.c_str(), static_cast<unsigned int>(SpecularTexture.size()) ) ) {
-        // Specular texture
-        out = & m_pModel->m_pCurrentMaterial->textureSpecular;
-        clampIndex = ObjFile::Material::TextureSpecularType;
-    } else if ( !ASSIMP_strincmp( pPtr, DisplacementTexture1.c_str(), static_cast<unsigned int>(DisplacementTexture1.size()) ) ||
-                !ASSIMP_strincmp( pPtr, DisplacementTexture2.c_str(), static_cast<unsigned int>(DisplacementTexture2.size()) ) ) {
-        // Displacement texture
-        out = &m_pModel->m_pCurrentMaterial->textureDisp;
-        clampIndex = ObjFile::Material::TextureDispType;
-    } else if ( !ASSIMP_strincmp( pPtr, OpacityTexture.c_str(), static_cast<unsigned int>(OpacityTexture.size()) ) ) {
-        // Opacity texture
-        out = & m_pModel->m_pCurrentMaterial->textureOpacity;
-        clampIndex = ObjFile::Material::TextureOpacityType;
-    } else if ( !ASSIMP_strincmp( pPtr, EmissiveTexture1.c_str(), static_cast<unsigned int>(EmissiveTexture1.size()) ) ||
-                !ASSIMP_strincmp( pPtr, EmissiveTexture2.c_str(), static_cast<unsigned int>(EmissiveTexture2.size()) ) ) {
-        // Emissive texture
-        out = & m_pModel->m_pCurrentMaterial->textureEmissive;
-        clampIndex = ObjFile::Material::TextureEmissiveType;
-    } else if ( !ASSIMP_strincmp( pPtr, BumpTexture1.c_str(), static_cast<unsigned int>(BumpTexture1.size()) ) ||
-                !ASSIMP_strincmp( pPtr, BumpTexture2.c_str(), static_cast<unsigned int>(BumpTexture2.size()) ) ) {
-        // Bump texture
-        out = & m_pModel->m_pCurrentMaterial->textureBump;
-        clampIndex = ObjFile::Material::TextureBumpType;
-    } else if ( !ASSIMP_strincmp( pPtr,NormalTexture.c_str(), static_cast<unsigned int>(NormalTexture.size()) ) ) {
-        // Normal map
-        out = & m_pModel->m_pCurrentMaterial->textureNormal;
-        clampIndex = ObjFile::Material::TextureNormalType;
-    } else if( !ASSIMP_strincmp( pPtr, ReflectionTexture.c_str(), static_cast<unsigned int>(ReflectionTexture.size()) ) ) {
-        // Reflection texture(s)
-        //Do nothing here
-        return;
-    } else if ( !ASSIMP_strincmp( pPtr, SpecularityTexture.c_str(), static_cast<unsigned int>(SpecularityTexture.size()) ) ) {
-        // Specularity scaling (glossiness)
-        out = & m_pModel->m_pCurrentMaterial->textureSpecularity;
-        clampIndex = ObjFile::Material::TextureSpecularityType;
-    } else {
-        ASSIMP_LOG_ERROR("OBJ/MTL: Encountered unknown texture type");
-        return;
-    }
-
-    bool clamp = false;
-    getTextureOption(clamp, clampIndex, out);
-    m_pModel->m_pCurrentMaterial->clamp[clampIndex] = clamp;
-
-    std::string texture;
-    m_DataIt = getName<DataArrayIt>( m_DataIt, m_DataItEnd, texture );
-    if ( NULL!=out ) {
-        out->Set( texture );
-    }
-}
-
-/* /////////////////////////////////////////////////////////////////////////////
- * Texture Option
- * /////////////////////////////////////////////////////////////////////////////
- * According to http://en.wikipedia.org/wiki/Wavefront_.obj_file#Texture_options
- * Texture map statement can contains various texture option, for example:
- *
- *  map_Ka -o 1 1 1 some.png
- *  map_Kd -clamp on some.png
- *
- * So we need to parse and skip these options, and leave the last part which is
- * the url of image, otherwise we will get a wrong url like "-clamp on some.png".
- *
- * Because aiMaterial supports clamp option, so we also want to return it
- * /////////////////////////////////////////////////////////////////////////////
- */
-void ObjFileMtlImporter::getTextureOption(bool &clamp, int &clampIndex, aiString *&out) {
-    m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
-
-    // If there is any more texture option
-    while (!isEndOfBuffer(m_DataIt, m_DataItEnd) && *m_DataIt == '-')
-    {
-        const char *pPtr( &(*m_DataIt) );
-        //skip option key and value
-        int skipToken = 1;
-
-        if (!ASSIMP_strincmp(pPtr, ClampOption.c_str(), static_cast<unsigned int>(ClampOption.size())))
-        {
-            DataArrayIt it = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
-            char value[3];
-            CopyNextWord(it, m_DataItEnd, value, sizeof(value) / sizeof(*value));
-            if (!ASSIMP_strincmp(value, "on", 2))
-            {
-                clamp = true;
-            }
-
-            skipToken = 2;
-        }
-        else if( !ASSIMP_strincmp( pPtr, TypeOption.c_str(), static_cast<unsigned int>(TypeOption.size()) ) )
-        {
-            DataArrayIt it = getNextToken<DataArrayIt>( m_DataIt, m_DataItEnd );
-            char value[ 12 ];
-            CopyNextWord( it, m_DataItEnd, value, sizeof( value ) / sizeof( *value ) );
-            if( !ASSIMP_strincmp( value, "cube_top", 8 ) )
-            {
-                clampIndex = ObjFile::Material::TextureReflectionCubeTopType;
-                out = &m_pModel->m_pCurrentMaterial->textureReflection[0];
-            }
-            else if( !ASSIMP_strincmp( value, "cube_bottom", 11 ) )
-            {
-                clampIndex = ObjFile::Material::TextureReflectionCubeBottomType;
-                out = &m_pModel->m_pCurrentMaterial->textureReflection[1];
-            }
-            else if( !ASSIMP_strincmp( value, "cube_front", 10 ) )
-            {
-                clampIndex = ObjFile::Material::TextureReflectionCubeFrontType;
-                out = &m_pModel->m_pCurrentMaterial->textureReflection[2];
-            }
-            else if( !ASSIMP_strincmp( value, "cube_back", 9 ) )
-            {
-                clampIndex = ObjFile::Material::TextureReflectionCubeBackType;
-                out = &m_pModel->m_pCurrentMaterial->textureReflection[3];
-            }
-            else if( !ASSIMP_strincmp( value, "cube_left", 9 ) )
-            {
-                clampIndex = ObjFile::Material::TextureReflectionCubeLeftType;
-                out = &m_pModel->m_pCurrentMaterial->textureReflection[4];
-            }
-            else if( !ASSIMP_strincmp( value, "cube_right", 10 ) )
-            {
-                clampIndex = ObjFile::Material::TextureReflectionCubeRightType;
-                out = &m_pModel->m_pCurrentMaterial->textureReflection[5];
-            }
-            else if( !ASSIMP_strincmp( value, "sphere", 6 ) )
-            {
-                clampIndex = ObjFile::Material::TextureReflectionSphereType;
-                out = &m_pModel->m_pCurrentMaterial->textureReflection[0];
-            }
-
-            skipToken = 2;
-        }
-        else if (!ASSIMP_strincmp(pPtr, BlendUOption.c_str(), static_cast<unsigned int>(BlendUOption.size()))
-                || !ASSIMP_strincmp(pPtr, BlendVOption.c_str(), static_cast<unsigned int>(BlendVOption.size()))
-                || !ASSIMP_strincmp(pPtr, BoostOption.c_str(), static_cast<unsigned int>(BoostOption.size()))
-                || !ASSIMP_strincmp(pPtr, ResolutionOption.c_str(), static_cast<unsigned int>(ResolutionOption.size()))
-                || !ASSIMP_strincmp(pPtr, BumpOption.c_str(), static_cast<unsigned int>(BumpOption.size()))
-                || !ASSIMP_strincmp(pPtr, ChannelOption.c_str(), static_cast<unsigned int>(ChannelOption.size())))
-        {
-            skipToken = 2;
-        }
-        else if (!ASSIMP_strincmp(pPtr, ModifyMapOption.c_str(), static_cast<unsigned int>(ModifyMapOption.size())))
-        {
-            skipToken = 3;
-        }
-        else if (  !ASSIMP_strincmp(pPtr, OffsetOption.c_str(), static_cast<unsigned int>(OffsetOption.size()))
-                || !ASSIMP_strincmp(pPtr, ScaleOption.c_str(), static_cast<unsigned int>(ScaleOption.size()))
-                || !ASSIMP_strincmp(pPtr, TurbulenceOption.c_str(), static_cast<unsigned int>(TurbulenceOption.size()))
-                )
-        {
-            skipToken = 4;
-        }
-
-        for (int i = 0; i < skipToken; ++i)
-        {
-            m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
-        }
-    }
-}
-
-// -------------------------------------------------------------------
-
-} // Namespace Assimp
-
-#endif // !! ASSIMP_BUILD_NO_OBJ_IMPORTER
diff --git a/Engine/lib/assimp/code/Obj/ObjFileMtlImporter.h b/Engine/lib/assimp/code/Obj/ObjFileMtlImporter.h
deleted file mode 100644
index 731952359..000000000
--- a/Engine/lib/assimp/code/Obj/ObjFileMtlImporter.h
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------*/
-#ifndef OBJFILEMTLIMPORTER_H_INC
-#define OBJFILEMTLIMPORTER_H_INC
-
-#include <vector>
-#include <string>
-#include <assimp/defs.h>
-
-struct aiColor3D;
-struct aiString;
-
-namespace Assimp {
-
-namespace ObjFile {
-    struct Model;
-    struct Material;
-}
-
-
-/**
- *  @class  ObjFileMtlImporter
- *  @brief  Loads the material description from a mtl file.
- */
-class ObjFileMtlImporter
-{
-public:
-    static const size_t BUFFERSIZE = 2048;
-    typedef std::vector<char> DataArray;
-    typedef std::vector<char>::iterator DataArrayIt;
-    typedef std::vector<char>::const_iterator ConstDataArrayIt;
-
-public:
-    //! \brief  Default constructor
-    ObjFileMtlImporter( std::vector<char> &buffer, const std::string &strAbsPath,
-        ObjFile::Model *pModel );
-
-    //! \brief  DEstructor
-    ~ObjFileMtlImporter();
-
-private:
-    /// Copy constructor, empty.
-    ObjFileMtlImporter(const ObjFileMtlImporter &rOther);
-    /// \brief  Assignment operator, returns only a reference of this instance.
-    ObjFileMtlImporter &operator = (const ObjFileMtlImporter &rOther);
-    /// Load the whole material description
-    void load();
-    /// Get color data.
-    void getColorRGBA( aiColor3D *pColor);
-    /// Get illumination model from loaded data
-    void getIlluminationModel( int &illum_model );
-    /// Gets a float value from data.
-    void getFloatValue( ai_real &value );
-    /// Creates a new material from loaded data.
-    void createMaterial();
-    /// Get texture name from loaded data.
-    void getTexture();
-    void getTextureOption(bool &clamp, int &clampIndex, aiString *&out);
-
-private:
-    //! Absolute pathname
-    std::string m_strAbsPath;
-    //! Data iterator showing to the current position in data buffer
-    DataArrayIt m_DataIt;
-    //! Data iterator to end of buffer
-    DataArrayIt m_DataItEnd;
-    //! USed model instance
-    ObjFile::Model *m_pModel;
-    //! Current line in file
-    unsigned int m_uiLine;
-    //! Helper buffer
-    char m_buffer[BUFFERSIZE];
-};
-
-// ------------------------------------------------------------------------------------------------
-
-} // Namespace Assimp
-
-#endif // OBJFILEMTLIMPORTER_H_INC
diff --git a/Engine/lib/assimp/code/Obj/ObjFileParser.cpp b/Engine/lib/assimp/code/Obj/ObjFileParser.cpp
deleted file mode 100644
index 699aafe6a..000000000
--- a/Engine/lib/assimp/code/Obj/ObjFileParser.cpp
+++ /dev/null
@@ -1,880 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-#ifndef ASSIMP_BUILD_NO_OBJ_IMPORTER
-
-#include "ObjFileParser.h"
-#include "ObjFileMtlImporter.h"
-#include "ObjTools.h"
-#include "ObjFileData.h"
-#include <assimp/ParsingUtils.h>
-#include <assimp/BaseImporter.h>
-#include <assimp/DefaultIOSystem.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/material.h>
-#include <assimp/Importer.hpp>
-#include <cstdlib>
-
-namespace Assimp {
-
-const std::string ObjFileParser::DEFAULT_MATERIAL = AI_DEFAULT_MATERIAL_NAME;
-
-ObjFileParser::ObjFileParser()
-: m_DataIt()
-, m_DataItEnd()
-, m_pModel( nullptr )
-, m_uiLine( 0 )
-, m_pIO( nullptr )
-, m_progress( nullptr )
-, m_originalObjFileName() {
-    // empty
-}
-
-ObjFileParser::ObjFileParser( IOStreamBuffer<char> &streamBuffer, const std::string &modelName,
-                              IOSystem *io, ProgressHandler* progress,
-                              const std::string &originalObjFileName) :
-    m_DataIt(),
-    m_DataItEnd(),
-    m_pModel(nullptr),
-    m_uiLine(0),
-    m_pIO( io ),
-    m_progress(progress),
-    m_originalObjFileName(originalObjFileName)
-{
-    std::fill_n(m_buffer,Buffersize,0);
-
-    // Create the model instance to store all the data
-    m_pModel.reset(new ObjFile::Model());
-    m_pModel->m_ModelName = modelName;
-
-    // create default material and store it
-    m_pModel->m_pDefaultMaterial = new ObjFile::Material;
-    m_pModel->m_pDefaultMaterial->MaterialName.Set( DEFAULT_MATERIAL );
-    m_pModel->m_MaterialLib.push_back( DEFAULT_MATERIAL );
-    m_pModel->m_MaterialMap[ DEFAULT_MATERIAL ] = m_pModel->m_pDefaultMaterial;
-
-    // Start parsing the file
-    parseFile( streamBuffer );
-}
-
-ObjFileParser::~ObjFileParser() {
-}
-
-void ObjFileParser::setBuffer( std::vector<char> &buffer ) {
-    m_DataIt = buffer.begin();
-    m_DataItEnd = buffer.end();
-}
-
-ObjFile::Model *ObjFileParser::GetModel() const {
-    return m_pModel.get();
-}
-
-void ObjFileParser::parseFile( IOStreamBuffer<char> &streamBuffer ) {
-    // only update every 100KB or it'll be too slow
-    //const unsigned int updateProgressEveryBytes = 100 * 1024;
-    unsigned int progressCounter = 0;
-    const unsigned int bytesToProcess = static_cast<unsigned int>(streamBuffer.size());
-    const unsigned int progressTotal = bytesToProcess;
-    unsigned int processed = 0;
-    size_t lastFilePos( 0 );
-
-    std::vector<char> buffer;
-    while ( streamBuffer.getNextDataLine( buffer, '\\' ) ) {
-        m_DataIt = buffer.begin();
-        m_DataItEnd = buffer.end();
-
-        // Handle progress reporting
-        const size_t filePos( streamBuffer.getFilePos() );
-        if ( lastFilePos < filePos ) {
-            processed = static_cast<unsigned int>(filePos);
-            lastFilePos = filePos;
-            progressCounter++;
-            m_progress->UpdateFileRead( processed, progressTotal );
-        }
-
-        // parse line
-        switch (*m_DataIt) {
-        case 'v': // Parse a vertex texture coordinate
-            {
-                ++m_DataIt;
-                if (*m_DataIt == ' ' || *m_DataIt == '\t') {
-                    size_t numComponents = getNumComponentsInDataDefinition();
-                    if (numComponents == 3) {
-                        // read in vertex definition
-                        getVector3(m_pModel->m_Vertices);
-                    } else if (numComponents == 4) {
-                        // read in vertex definition (homogeneous coords)
-                        getHomogeneousVector3(m_pModel->m_Vertices);
-                    } else if (numComponents == 6) {
-                        // read vertex and vertex-color
-                        getTwoVectors3(m_pModel->m_Vertices, m_pModel->m_VertexColors);
-                    }
-                } else if (*m_DataIt == 't') {
-                    // read in texture coordinate ( 2D or 3D )
-                    ++m_DataIt;
-                    size_t dim = getTexCoordVector(m_pModel->m_TextureCoord);
-                    m_pModel->m_TextureCoordDim = std::max(m_pModel->m_TextureCoordDim, (unsigned int)dim);
-                } else if (*m_DataIt == 'n') {
-                    // Read in normal vector definition
-                    ++m_DataIt;
-                    getVector3( m_pModel->m_Normals );
-                }
-            }
-            break;
-
-        case 'p': // Parse a face, line or point statement
-        case 'l':
-        case 'f':
-            {
-                getFace(*m_DataIt == 'f' ? aiPrimitiveType_POLYGON : (*m_DataIt == 'l'
-                    ? aiPrimitiveType_LINE : aiPrimitiveType_POINT));
-            }
-            break;
-
-        case '#': // Parse a comment
-            {
-                getComment();
-            }
-            break;
-
-        case 'u': // Parse a material desc. setter
-            {
-                std::string name;
-
-                getNameNoSpace(m_DataIt, m_DataItEnd, name);
-
-                size_t nextSpace = name.find(" ");
-                if (nextSpace != std::string::npos)
-                    name = name.substr(0, nextSpace);
-
-                if(name == "usemtl")
-                {
-                    getMaterialDesc();
-                }
-            }
-            break;
-
-        case 'm': // Parse a material library or merging group ('mg')
-            {
-                std::string name;
-
-                getNameNoSpace(m_DataIt, m_DataItEnd, name);
-
-                size_t nextSpace = name.find(" ");
-                if (nextSpace != std::string::npos)
-                    name = name.substr(0, nextSpace);
-
-                if (name == "mg")
-                    getGroupNumberAndResolution();
-                else if(name == "mtllib")
-                    getMaterialLib();
-				else
-					goto pf_skip_line;
-            }
-            break;
-
-        case 'g': // Parse group name
-            {
-                getGroupName();
-            }
-            break;
-
-        case 's': // Parse group number
-            {
-                getGroupNumber();
-            }
-            break;
-
-        case 'o': // Parse object name
-            {
-                getObjectName();
-            }
-            break;
-
-        default:
-            {
-pf_skip_line:
-                m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
-            }
-            break;
-        }
-    }
-}
-
-void ObjFileParser::copyNextWord(char *pBuffer, size_t length) {
-    size_t index = 0;
-    m_DataIt = getNextWord<DataArrayIt>(m_DataIt, m_DataItEnd);
-    if ( *m_DataIt == '\\' ) {
-        ++m_DataIt;
-        ++m_DataIt;
-        m_DataIt = getNextWord<DataArrayIt>( m_DataIt, m_DataItEnd );
-    }
-    while( m_DataIt != m_DataItEnd && !IsSpaceOrNewLine( *m_DataIt ) ) {
-        pBuffer[index] = *m_DataIt;
-        index++;
-        if( index == length - 1 ) {
-            break;
-        }
-        ++m_DataIt;
-    }
-
-    ai_assert(index < length);
-    pBuffer[index] = '\0';
-}
-
-static bool isDataDefinitionEnd( const char *tmp ) {
-    if ( *tmp == '\\' ) {
-        tmp++;
-        if ( IsLineEnd( *tmp ) ) {
-            tmp++;
-            return true;
-        }
-    }
-    return false;
-}
-
-static bool isNanOrInf(const char * in) {
-    // Look for "nan" or "inf", case insensitive
-    if ((in[0] == 'N' || in[0] == 'n') && ASSIMP_strincmp(in, "nan", 3) == 0) {
-        return true;
-    }
-    else if ((in[0] == 'I' || in[0] == 'i') && ASSIMP_strincmp(in, "inf", 3) == 0) {
-        return true;
-    }
-    return false;
-}
-
-size_t ObjFileParser::getNumComponentsInDataDefinition() {
-    size_t numComponents( 0 );
-    const char* tmp( &m_DataIt[0] );
-    bool end_of_definition = false;
-    while ( !end_of_definition ) {
-        if ( isDataDefinitionEnd( tmp ) ) {
-            tmp += 2;
-        } else if ( IsLineEnd( *tmp ) ) {
-            end_of_definition = true;
-        }
-        if ( !SkipSpaces( &tmp ) ) {
-            break;
-        }
-        const bool isNum( IsNumeric( *tmp ) || isNanOrInf(tmp));
-        SkipToken( tmp );
-        if ( isNum ) {
-            ++numComponents;
-        }
-        if ( !SkipSpaces( &tmp ) ) {
-            break;
-        }
-    }
-    return numComponents;
-}
-
-size_t ObjFileParser::getTexCoordVector( std::vector<aiVector3D> &point3d_array ) {
-    size_t numComponents = getNumComponentsInDataDefinition();
-    ai_real x, y, z;
-    if( 2 == numComponents ) {
-        copyNextWord( m_buffer, Buffersize );
-        x = ( ai_real ) fast_atof( m_buffer );
-
-        copyNextWord( m_buffer, Buffersize );
-        y = ( ai_real ) fast_atof( m_buffer );
-        z = 0.0;
-    } else if( 3 == numComponents ) {
-        copyNextWord( m_buffer, Buffersize );
-        x = ( ai_real ) fast_atof( m_buffer );
-
-        copyNextWord( m_buffer, Buffersize );
-        y = ( ai_real ) fast_atof( m_buffer );
-
-        copyNextWord( m_buffer, Buffersize );
-        z = ( ai_real ) fast_atof( m_buffer );
-    } else {
-        throw DeadlyImportError( "OBJ: Invalid number of components" );
-    }
-
-    // Coerce nan and inf to 0 as is the OBJ default value
-    if (!std::isfinite(x))
-        x = 0;
-
-    if (!std::isfinite(y))
-        y = 0;
-
-    if (!std::isfinite(z))
-        z = 0;
-
-    point3d_array.push_back( aiVector3D( x, y, z ) );
-    m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
-    return numComponents;
-}
-
-void ObjFileParser::getVector3( std::vector<aiVector3D> &point3d_array ) {
-    ai_real x, y, z;
-    copyNextWord(m_buffer, Buffersize);
-    x = (ai_real) fast_atof(m_buffer);
-
-    copyNextWord(m_buffer, Buffersize);
-    y = (ai_real) fast_atof(m_buffer);
-
-    copyNextWord( m_buffer, Buffersize );
-    z = ( ai_real ) fast_atof( m_buffer );
-
-    point3d_array.push_back( aiVector3D( x, y, z ) );
-    m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
-}
-
-void ObjFileParser::getHomogeneousVector3( std::vector<aiVector3D> &point3d_array ) {
-    ai_real x, y, z, w;
-    copyNextWord(m_buffer, Buffersize);
-    x = (ai_real) fast_atof(m_buffer);
-
-    copyNextWord(m_buffer, Buffersize);
-    y = (ai_real) fast_atof(m_buffer);
-
-    copyNextWord( m_buffer, Buffersize );
-    z = ( ai_real ) fast_atof( m_buffer );
-
-    copyNextWord( m_buffer, Buffersize );
-    w = ( ai_real ) fast_atof( m_buffer );
-
-    if (w == 0)
-      throw DeadlyImportError("OBJ: Invalid component in homogeneous vector (Division by zero)");
-
-    point3d_array.push_back( aiVector3D( x/w, y/w, z/w ) );
-    m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
-}
-
-void ObjFileParser::getTwoVectors3( std::vector<aiVector3D> &point3d_array_a, std::vector<aiVector3D> &point3d_array_b ) {
-    ai_real x, y, z;
-    copyNextWord(m_buffer, Buffersize);
-    x = (ai_real) fast_atof(m_buffer);
-
-    copyNextWord(m_buffer, Buffersize);
-    y = (ai_real) fast_atof(m_buffer);
-
-    copyNextWord( m_buffer, Buffersize );
-    z = ( ai_real ) fast_atof( m_buffer );
-
-    point3d_array_a.push_back( aiVector3D( x, y, z ) );
-
-    copyNextWord(m_buffer, Buffersize);
-    x = (ai_real) fast_atof(m_buffer);
-
-    copyNextWord(m_buffer, Buffersize);
-    y = (ai_real) fast_atof(m_buffer);
-
-    copyNextWord( m_buffer, Buffersize );
-    z = ( ai_real ) fast_atof( m_buffer );
-
-    point3d_array_b.push_back( aiVector3D( x, y, z ) );
-
-    m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
-}
-
-void ObjFileParser::getVector2( std::vector<aiVector2D> &point2d_array ) {
-    ai_real x, y;
-    copyNextWord(m_buffer, Buffersize);
-    x = (ai_real) fast_atof(m_buffer);
-
-    copyNextWord(m_buffer, Buffersize);
-    y = (ai_real) fast_atof(m_buffer);
-
-    point2d_array.push_back(aiVector2D(x, y));
-
-    m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
-}
-
-static const std::string DefaultObjName = "defaultobject";
-
-void ObjFileParser::getFace( aiPrimitiveType type ) {
-    m_DataIt = getNextToken<DataArrayIt>( m_DataIt, m_DataItEnd );
-    if ( m_DataIt == m_DataItEnd || *m_DataIt == '\0' ) {
-        return;
-    }
-
-    ObjFile::Face *face = new ObjFile::Face( type );
-    bool hasNormal = false;
-
-    const int vSize = static_cast<unsigned int>(m_pModel->m_Vertices.size());
-    const int vtSize = static_cast<unsigned int>(m_pModel->m_TextureCoord.size());
-    const int vnSize = static_cast<unsigned int>(m_pModel->m_Normals.size());
-
-    const bool vt = (!m_pModel->m_TextureCoord.empty());
-    const bool vn = (!m_pModel->m_Normals.empty());
-    int iStep = 0, iPos = 0;
-    while ( m_DataIt != m_DataItEnd ) {
-        iStep = 1;
-
-        if ( IsLineEnd( *m_DataIt ) ) {
-            break;
-        }
-
-        if ( *m_DataIt =='/' ) {
-            if (type == aiPrimitiveType_POINT) {
-                ASSIMP_LOG_ERROR("Obj: Separator unexpected in point statement");
-            }
-            iPos++;
-        } else if( IsSpaceOrNewLine( *m_DataIt ) ) {
-            iPos = 0;
-        } else {
-            //OBJ USES 1 Base ARRAYS!!!!
-            const int iVal( ::atoi( & ( *m_DataIt ) ) );
-
-            // increment iStep position based off of the sign and # of digits
-            int tmp = iVal;
-            if ( iVal < 0 ) {
-                ++iStep;
-            }
-            while ( ( tmp = tmp / 10 ) != 0 ) {
-                ++iStep;
-            }
-
-            if (iPos == 1 && !vt && vn)
-                iPos = 2; // skip texture coords for normals if there are no tex coords
-
-            if ( iVal > 0 ) {
-                // Store parsed index
-                if ( 0 == iPos ) {
-                    face->m_vertices.push_back( iVal - 1 );
-                } else if ( 1 == iPos ) {
-                    face->m_texturCoords.push_back( iVal - 1 );
-                } else if ( 2 == iPos ) {
-                    face->m_normals.push_back( iVal - 1 );
-                    hasNormal = true;
-                } else {
-                    reportErrorTokenInFace();
-                }
-            } else if ( iVal < 0 ) {
-                // Store relatively index
-                if ( 0 == iPos ) {
-                    face->m_vertices.push_back( vSize + iVal );
-                } else if ( 1 == iPos ) {
-                    face->m_texturCoords.push_back( vtSize + iVal );
-                } else if ( 2 == iPos ) {
-                    face->m_normals.push_back( vnSize + iVal );
-                    hasNormal = true;
-                } else {
-                    reportErrorTokenInFace();
-                }
-            } else {
-                //On error, std::atoi will return 0 which is not a valid value
-                delete face;
-                throw DeadlyImportError("OBJ: Invalid face indice");
-            }
-
-        }
-        m_DataIt += iStep;
-    }
-
-    if ( face->m_vertices.empty() ) {
-        ASSIMP_LOG_ERROR("Obj: Ignoring empty face");
-        // skip line and clean up
-        m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
-        delete face;
-        return;
-    }
-
-    // Set active material, if one set
-    if( NULL != m_pModel->m_pCurrentMaterial ) {
-        face->m_pMaterial = m_pModel->m_pCurrentMaterial;
-    } else {
-        face->m_pMaterial = m_pModel->m_pDefaultMaterial;
-    }
-
-    // Create a default object, if nothing is there
-    if( NULL == m_pModel->m_pCurrent ) {
-        createObject( DefaultObjName );
-    }
-
-    // Assign face to mesh
-    if ( NULL == m_pModel->m_pCurrentMesh ) {
-        createMesh( DefaultObjName );
-    }
-
-    // Store the face
-    m_pModel->m_pCurrentMesh->m_Faces.push_back( face );
-    m_pModel->m_pCurrentMesh->m_uiNumIndices += (unsigned int) face->m_vertices.size();
-    m_pModel->m_pCurrentMesh->m_uiUVCoordinates[ 0 ] += (unsigned int) face->m_texturCoords.size();
-    if( !m_pModel->m_pCurrentMesh->m_hasNormals && hasNormal ) {
-        m_pModel->m_pCurrentMesh->m_hasNormals = true;
-    }
-    // Skip the rest of the line
-    m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
-}
-
-void ObjFileParser::getMaterialDesc() {
-    // Get next data for material data
-    m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
-    if (m_DataIt == m_DataItEnd) {
-        return;
-    }
-
-    char *pStart = &(*m_DataIt);
-    while( m_DataIt != m_DataItEnd && !IsLineEnd( *m_DataIt ) ) {
-        ++m_DataIt;
-    }
-
-    // In some cases we should ignore this 'usemtl' command, this variable helps us to do so
-    bool skip = false;
-
-    // Get name
-    std::string strName(pStart, &(*m_DataIt));
-    strName = trim_whitespaces(strName);
-    if (strName.empty())
-        skip = true;
-
-    // If the current mesh has the same material, we simply ignore that 'usemtl' command
-    // There is no need to create another object or even mesh here
-    if ( m_pModel->m_pCurrentMaterial && m_pModel->m_pCurrentMaterial->MaterialName == aiString( strName ) ) {
-        skip = true;
-    }
-
-    if (!skip) {
-        // Search for material
-        std::map<std::string, ObjFile::Material*>::iterator it = m_pModel->m_MaterialMap.find(strName);
-        if (it == m_pModel->m_MaterialMap.end()) {
-			// Not found, so we don't know anything about the material except for its name.
-			// This may be the case if the material library is missing. We don't want to lose all
-			// materials if that happens, so create a new named material instead of discarding it
-			// completely.
-            ASSIMP_LOG_ERROR("OBJ: failed to locate material " + strName + ", creating new material");
-			m_pModel->m_pCurrentMaterial = new ObjFile::Material();
-			m_pModel->m_pCurrentMaterial->MaterialName.Set(strName);
-			m_pModel->m_MaterialLib.push_back(strName);
-			m_pModel->m_MaterialMap[strName] = m_pModel->m_pCurrentMaterial;
-        } else {
-            // Found, using detected material
-            m_pModel->m_pCurrentMaterial = (*it).second;
-        }
-
-        if ( needsNewMesh( strName ) ) {
-            createMesh( strName );
-        }
-
-        m_pModel->m_pCurrentMesh->m_uiMaterialIndex = getMaterialIndex(strName);
-    }
-
-    // Skip rest of line
-    m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
-}
-
-// -------------------------------------------------------------------
-//  Get a comment, values will be skipped
-void ObjFileParser::getComment() {
-    m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
-}
-
-// -------------------------------------------------------------------
-//  Get material library from file.
-void ObjFileParser::getMaterialLib() {
-    // Translate tuple
-    m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
-    if( m_DataIt == m_DataItEnd ) {
-        return;
-    }
-
-    char *pStart = &(*m_DataIt);
-    while( m_DataIt != m_DataItEnd && !IsLineEnd( *m_DataIt ) ) {
-        ++m_DataIt;
-    }
-
-    // Check for existence
-    const std::string strMatName(pStart, &(*m_DataIt));
-    std::string absName;
-
-	// Check if directive is valid.
-    if ( 0 == strMatName.length() ) {
-        ASSIMP_LOG_WARN( "OBJ: no name for material library specified." );
-        return;
-    }
-
-    if ( m_pIO->StackSize() > 0 ) {
-        std::string path = m_pIO->CurrentDirectory();
-        if ( '/' != *path.rbegin() ) {
-          path += '/';
-        }
-        absName += path;
-        absName += strMatName;
-    } else {
-        absName = strMatName;
-    }
-
-    IOStream *pFile = m_pIO->Open( absName );
-    if ( nullptr == pFile ) {
-        ASSIMP_LOG_ERROR("OBJ: Unable to locate material file " + strMatName);
-        std::string strMatFallbackName = m_originalObjFileName.substr(0, m_originalObjFileName.length() - 3) + "mtl";
-        ASSIMP_LOG_INFO("OBJ: Opening fallback material file " + strMatFallbackName);
-        pFile = m_pIO->Open(strMatFallbackName);
-        if (!pFile) {
-            ASSIMP_LOG_ERROR("OBJ: Unable to locate fallback material file " + strMatFallbackName);
-            m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
-            return;
-        }
-    }
-
-    // Import material library data from file.
-    // Some exporters (e.g. Silo) will happily write out empty
-    // material files if the model doesn't use any materials, so we
-    // allow that.
-    std::vector<char> buffer;
-    BaseImporter::TextFileToBuffer( pFile, buffer, BaseImporter::ALLOW_EMPTY );
-    m_pIO->Close( pFile );
-
-    // Importing the material library
-    ObjFileMtlImporter mtlImporter( buffer, strMatName, m_pModel.get() );
-}
-
-// -------------------------------------------------------------------
-//  Set a new material definition as the current material.
-void ObjFileParser::getNewMaterial() {
-    m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
-    m_DataIt = getNextWord<DataArrayIt>(m_DataIt, m_DataItEnd);
-    if( m_DataIt == m_DataItEnd ) {
-        return;
-    }
-
-    char *pStart = &(*m_DataIt);
-    std::string strMat( pStart, *m_DataIt );
-    while( m_DataIt != m_DataItEnd && IsSpaceOrNewLine( *m_DataIt ) ) {
-        ++m_DataIt;
-    }
-    std::map<std::string, ObjFile::Material*>::iterator it = m_pModel->m_MaterialMap.find( strMat );
-    if ( it == m_pModel->m_MaterialMap.end() ) {
-        // Show a warning, if material was not found
-        ASSIMP_LOG_WARN("OBJ: Unsupported material requested: " + strMat);
-        m_pModel->m_pCurrentMaterial = m_pModel->m_pDefaultMaterial;
-    } else {
-        // Set new material
-        if ( needsNewMesh( strMat ) ) {
-            createMesh( strMat );
-        }
-        m_pModel->m_pCurrentMesh->m_uiMaterialIndex = getMaterialIndex( strMat );
-    }
-
-    m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
-}
-
-// -------------------------------------------------------------------
-int ObjFileParser::getMaterialIndex( const std::string &strMaterialName )
-{
-    int mat_index = -1;
-    if( strMaterialName.empty() ) {
-        return mat_index;
-    }
-    for (size_t index = 0; index < m_pModel->m_MaterialLib.size(); ++index)
-    {
-        if ( strMaterialName == m_pModel->m_MaterialLib[ index ])
-        {
-            mat_index = (int)index;
-            break;
-        }
-    }
-    return mat_index;
-}
-
-// -------------------------------------------------------------------
-//  Getter for a group name.
-void ObjFileParser::getGroupName() {
-    std::string groupName;
-
-    // here we skip 'g ' from line
-    m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
-    m_DataIt = getName<DataArrayIt>(m_DataIt, m_DataItEnd, groupName);
-    if( isEndOfBuffer( m_DataIt, m_DataItEnd ) ) {
-        return;
-    }
-
-    // Change active group, if necessary
-    if ( m_pModel->m_strActiveGroup != groupName ) {
-        // Search for already existing entry
-        ObjFile::Model::ConstGroupMapIt it = m_pModel->m_Groups.find(groupName);
-
-        // We are mapping groups into the object structure
-        createObject( groupName );
-
-        // New group name, creating a new entry
-        if (it == m_pModel->m_Groups.end())
-        {
-            std::vector<unsigned int> *pFaceIDArray = new std::vector<unsigned int>;
-            m_pModel->m_Groups[ groupName ] = pFaceIDArray;
-            m_pModel->m_pGroupFaceIDs = (pFaceIDArray);
-        }
-        else
-        {
-            m_pModel->m_pGroupFaceIDs = (*it).second;
-        }
-        m_pModel->m_strActiveGroup = groupName;
-    }
-    m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
-}
-
-// -------------------------------------------------------------------
-//  Not supported
-void ObjFileParser::getGroupNumber()
-{
-    // Not used
-
-    m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
-}
-
-// -------------------------------------------------------------------
-//  Not supported
-void ObjFileParser::getGroupNumberAndResolution()
-{
-    // Not used
-
-    m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
-}
-
-// -------------------------------------------------------------------
-//  Stores values for a new object instance, name will be used to
-//  identify it.
-void ObjFileParser::getObjectName()
-{
-    m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
-    if( m_DataIt == m_DataItEnd ) {
-        return;
-    }
-    char *pStart = &(*m_DataIt);
-    while( m_DataIt != m_DataItEnd && !IsSpaceOrNewLine( *m_DataIt ) ) {
-        ++m_DataIt;
-    }
-
-    std::string strObjectName(pStart, &(*m_DataIt));
-    if (!strObjectName.empty())
-    {
-        // Reset current object
-        m_pModel->m_pCurrent = NULL;
-
-        // Search for actual object
-        for (std::vector<ObjFile::Object*>::const_iterator it = m_pModel->m_Objects.begin();
-            it != m_pModel->m_Objects.end();
-            ++it)
-        {
-            if ((*it)->m_strObjName == strObjectName)
-            {
-                m_pModel->m_pCurrent = *it;
-                break;
-            }
-        }
-
-        // Allocate a new object, if current one was not found before
-        if( NULL == m_pModel->m_pCurrent ) {
-            createObject( strObjectName );
-        }
-    }
-    m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
-}
-// -------------------------------------------------------------------
-//  Creates a new object instance
-void ObjFileParser::createObject(const std::string &objName)
-{
-    ai_assert( NULL != m_pModel );
-
-    m_pModel->m_pCurrent = new ObjFile::Object;
-    m_pModel->m_pCurrent->m_strObjName = objName;
-    m_pModel->m_Objects.push_back( m_pModel->m_pCurrent );
-
-    createMesh( objName  );
-
-    if( m_pModel->m_pCurrentMaterial )
-    {
-        m_pModel->m_pCurrentMesh->m_uiMaterialIndex =
-            getMaterialIndex( m_pModel->m_pCurrentMaterial->MaterialName.data );
-        m_pModel->m_pCurrentMesh->m_pMaterial = m_pModel->m_pCurrentMaterial;
-    }
-}
-// -------------------------------------------------------------------
-//  Creates a new mesh
-void ObjFileParser::createMesh( const std::string &meshName )
-{
-    ai_assert( NULL != m_pModel );
-    m_pModel->m_pCurrentMesh = new ObjFile::Mesh( meshName );
-    m_pModel->m_Meshes.push_back( m_pModel->m_pCurrentMesh );
-    unsigned int meshId = static_cast<unsigned int>(m_pModel->m_Meshes.size()-1);
-    if ( NULL != m_pModel->m_pCurrent )
-    {
-        m_pModel->m_pCurrent->m_Meshes.push_back( meshId );
-    }
-    else
-    {
-        ASSIMP_LOG_ERROR("OBJ: No object detected to attach a new mesh instance.");
-    }
-}
-
-// -------------------------------------------------------------------
-//  Returns true, if a new mesh must be created.
-bool ObjFileParser::needsNewMesh( const std::string &materialName )
-{
-    // If no mesh data yet
-    if(m_pModel->m_pCurrentMesh == 0)
-    {
-        return true;
-    }
-    bool newMat = false;
-    int matIdx = getMaterialIndex( materialName );
-    int curMatIdx = m_pModel->m_pCurrentMesh->m_uiMaterialIndex;
-    if ( curMatIdx != int(ObjFile::Mesh::NoMaterial)
-        && curMatIdx != matIdx
-        // no need create a new mesh if no faces in current
-        // lets say 'usemtl' goes straight after 'g'
-        && m_pModel->m_pCurrentMesh->m_Faces.size() > 0 )
-    {
-        // New material -> only one material per mesh, so we need to create a new
-        // material
-        newMat = true;
-    }
-    return newMat;
-}
-
-// -------------------------------------------------------------------
-//  Shows an error in parsing process.
-void ObjFileParser::reportErrorTokenInFace()
-{
-    m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
-    ASSIMP_LOG_ERROR("OBJ: Not supported token in face description detected");
-}
-
-// -------------------------------------------------------------------
-
-}   // Namespace Assimp
-
-#endif // !! ASSIMP_BUILD_NO_OBJ_IMPORTER
diff --git a/Engine/lib/assimp/code/Obj/ObjFileParser.h b/Engine/lib/assimp/code/Obj/ObjFileParser.h
deleted file mode 100644
index 7d1b806ce..000000000
--- a/Engine/lib/assimp/code/Obj/ObjFileParser.h
+++ /dev/null
@@ -1,165 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-#ifndef OBJ_FILEPARSER_H_INC
-#define OBJ_FILEPARSER_H_INC
-
-#include <vector>
-#include <string>
-#include <map>
-#include <memory>
-#include <assimp/vector2.h>
-#include <assimp/vector3.h>
-#include <assimp/mesh.h>
-#include <assimp/IOStreamBuffer.h>
-
-namespace Assimp {
-
-namespace ObjFile {
-    struct Model;
-    struct Object;
-    struct Material;
-    struct Point3;
-    struct Point2;
-}
-
-class ObjFileImporter;
-class IOSystem;
-class ProgressHandler;
-
-/// \class  ObjFileParser
-/// \brief  Parser for a obj waveform file
-class ASSIMP_API ObjFileParser {
-public:
-    static const size_t Buffersize = 4096;
-    typedef std::vector<char> DataArray;
-    typedef std::vector<char>::iterator DataArrayIt;
-    typedef std::vector<char>::const_iterator ConstDataArrayIt;
-
-public:
-    /// @brief  The default constructor.
-    ObjFileParser();
-    /// @brief  Constructor with data array.
-    ObjFileParser( IOStreamBuffer<char> &streamBuffer, const std::string &modelName, IOSystem* io, ProgressHandler* progress, const std::string &originalObjFileName);
-    /// @brief  Destructor
-    ~ObjFileParser();
-    /// @brief  If you want to load in-core data.
-    void setBuffer( std::vector<char> &buffer );
-    /// @brief  Model getter.
-    ObjFile::Model *GetModel() const;
-
-protected:
-    /// Parse the loaded file
-    void parseFile( IOStreamBuffer<char> &streamBuffer );
-    /// Method to copy the new delimited word in the current line.
-    void copyNextWord(char *pBuffer, size_t length);
-    /// Method to copy the new line.
-//    void copyNextLine(char *pBuffer, size_t length);
-    /// Get the number of components in a line.
-    size_t getNumComponentsInDataDefinition();
-    /// Stores the vector
-    size_t getTexCoordVector( std::vector<aiVector3D> &point3d_array );
-    /// Stores the following 3d vector.
-    void getVector3( std::vector<aiVector3D> &point3d_array );
-    /// Stores the following homogeneous vector as a 3D vector
-    void getHomogeneousVector3( std::vector<aiVector3D> &point3d_array );
-    /// Stores the following two 3d vectors on the line.
-    void getTwoVectors3( std::vector<aiVector3D> &point3d_array_a, std::vector<aiVector3D> &point3d_array_b );
-    /// Stores the following 3d vector.
-    void getVector2(std::vector<aiVector2D> &point2d_array);
-    /// Stores the following face.
-    void getFace(aiPrimitiveType type);
-    /// Reads the material description.
-    void getMaterialDesc();
-    /// Gets a comment.
-    void getComment();
-    /// Gets a a material library.
-    void getMaterialLib();
-    /// Creates a new material.
-    void getNewMaterial();
-    /// Gets the group name from file.
-    void getGroupName();
-    /// Gets the group number from file.
-    void getGroupNumber();
-    /// Gets the group number and resolution from file.
-    void getGroupNumberAndResolution();
-    /// Returns the index of the material. Is -1 if not material was found.
-    int getMaterialIndex( const std::string &strMaterialName );
-    /// Parse object name
-    void getObjectName();
-    /// Creates a new object.
-    void createObject( const std::string &strObjectName );
-    /// Creates a new mesh.
-    void createMesh( const std::string &meshName );
-    /// Returns true, if a new mesh instance must be created.
-    bool needsNewMesh( const std::string &rMaterialName );
-    /// Error report in token
-    void reportErrorTokenInFace();
-
-private:
-    // Copy and assignment constructor should be private
-    // because the class contains pointer to allocated memory
-    ObjFileParser(const ObjFileParser& rhs);
-    ObjFileParser& operator=(const ObjFileParser& rhs);
-
-    /// Default material name
-    static const std::string DEFAULT_MATERIAL;
-    //! Iterator to current position in buffer
-    DataArrayIt m_DataIt;
-    //! Iterator to end position of buffer
-    DataArrayIt m_DataItEnd;
-    //! Pointer to model instance
-    std::unique_ptr<ObjFile::Model> m_pModel;
-    //! Current line (for debugging)
-    unsigned int m_uiLine;
-    //! Helper buffer
-    char m_buffer[Buffersize];
-    /// Pointer to IO system instance.
-    IOSystem *m_pIO;
-    //! Pointer to progress handler
-    ProgressHandler* m_progress;
-    /// Path to the current model, name of the obj file where the buffer comes from
-    const std::string m_originalObjFileName;
-};
-
-}   // Namespace Assimp
-
-#endif
diff --git a/Engine/lib/assimp/code/Obj/ObjTools.h b/Engine/lib/assimp/code/Obj/ObjTools.h
deleted file mode 100644
index 3f4c41033..000000000
--- a/Engine/lib/assimp/code/Obj/ObjTools.h
+++ /dev/null
@@ -1,308 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file   ObjTools.h
- *  @brief  Some helpful templates for text parsing
- */
-#ifndef OBJ_TOOLS_H_INC
-#define OBJ_TOOLS_H_INC
-
-#include <assimp/fast_atof.h>
-#include <assimp/ParsingUtils.h>
-#include <vector>
-
-namespace Assimp {
-
-/** @brief  Returns true, if the last entry of the buffer is reached.
- *  @param  it  Iterator of current position.
- *  @param  end Iterator with end of buffer.
- *  @return true, if the end of the buffer is reached.
- */
-template<class char_t>
-inline bool isEndOfBuffer(  char_t it, char_t end ) {
-    if ( it == end )
-    {
-        return true;
-    }
-    else
-    {
-        --end;
-    }
-    return ( it == end );
-}
-
-/** @brief  Returns next word separated by a space
- *  @param  pBuffer Pointer to data buffer
- *  @param  pEnd    Pointer to end of buffer
- *  @return Pointer to next space
- */
-template<class Char_T>
-inline Char_T getNextWord( Char_T pBuffer, Char_T pEnd )
-{
-    while ( !isEndOfBuffer( pBuffer, pEnd ) )
-    {
-        if ( !IsSpaceOrNewLine( *pBuffer ) || IsLineEnd( *pBuffer ) ) {
-            //if ( *pBuffer != '\\' )
-                break;
-        }
-        pBuffer++;
-    }
-    return pBuffer;
-}
-
-/** @brief  Returns pointer a next token
- *  @param  pBuffer Pointer to data buffer
- *  @param  pEnd    Pointer to end of buffer
- *  @return Pointer to next token
- */
-template<class Char_T>
-inline Char_T getNextToken( Char_T pBuffer, Char_T pEnd )
-{
-    while ( !isEndOfBuffer( pBuffer, pEnd ) )
-    {
-        if( IsSpaceOrNewLine( *pBuffer ) )
-            break;
-        pBuffer++;
-    }
-    return getNextWord( pBuffer, pEnd );
-}
-
-/** @brief  Skips a line
- *  @param  it      Iterator set to current position
- *  @param  end     Iterator set to end of scratch buffer for readout
- *  @param  uiLine  Current line number in format
- *  @return Current-iterator with new position
- */
-template<class char_t>
-inline char_t skipLine( char_t it, char_t end, unsigned int &uiLine ) {
-    while( !isEndOfBuffer( it, end ) && !IsLineEnd( *it ) ) {
-        ++it;
-    }
-    
-    if ( it != end ) {
-        ++it;
-        ++uiLine;
-    }
-    // fix .. from time to time there are spaces at the beginning of a material line
-    while ( it != end && ( *it == '\t' || *it == ' ' ) ) {
-        ++it;
-    }
-
-    return it;
-}
-
-/** @brief  Get a name from the current line. Preserve space in the middle,
- *    but trim it at the end.
- *  @param  it      set to current position
- *  @param  end     set to end of scratch buffer for readout
- *  @param  name    Separated name
- *  @return Current-iterator with new position
- */
-template<class char_t>
-inline char_t getName( char_t it, char_t end, std::string &name )
-{
-    name = "";
-    if( isEndOfBuffer( it, end ) ) {
-        return end;
-    }
-
-    char *pStart = &( *it );
-    while( !isEndOfBuffer( it, end ) && !IsLineEnd( *it )) {
-        ++it;
-    }
-
-    while(IsSpace( *it ) ) {
-        --it;
-    }
-    // Get name
-    // if there is no name, and the previous char is a separator, come back to start
-    while (&(*it) < pStart) {
-        ++it;
-    }
-    std::string strName( pStart, &(*it) );
-    if ( strName.empty() )
-        return it;
-    else
-        name = strName;
-
-    return it;
-}
-
-/** @brief  Get a name from the current line. Do not preserve space
- *    in the middle, but trim it at the end.
- *  @param  it      set to current position
- *  @param  end     set to end of scratch buffer for readout
- *  @param  name    Separated name
- *  @return Current-iterator with new position
- */
-template<class char_t>
-inline char_t getNameNoSpace( char_t it, char_t end, std::string &name )
-{
-    name = "";
-    if( isEndOfBuffer( it, end ) ) {
-        return end;
-    }
-
-    char *pStart = &( *it );
-    while( !isEndOfBuffer( it, end ) && !IsLineEnd( *it )
-          && !IsSpaceOrNewLine( *it ) ) {
-        ++it;
-    }
-
-    while( isEndOfBuffer( it, end ) || IsLineEnd( *it )
-          || IsSpaceOrNewLine( *it ) ) {
-        --it;
-    }
-    ++it;
-
-    // Get name
-    // if there is no name, and the previous char is a separator, come back to start
-    while (&(*it) < pStart) {
-        ++it;
-    }
-    std::string strName( pStart, &(*it) );
-    if ( strName.empty() )
-        return it;
-    else
-        name = strName;
-
-    return it;
-}
-
-/** @brief  Get next word from given line
- *  @param  it      set to current position
- *  @param  end     set to end of scratch buffer for readout
- *  @param  pBuffer Buffer for next word
- *  @param  length  Buffer length
- *  @return Current-iterator with new position
- */
-template<class char_t>
-inline char_t CopyNextWord( char_t it, char_t end, char *pBuffer, size_t length )
-{
-    size_t index = 0;
-    it = getNextWord<char_t>( it, end );
-    while( !IsSpaceOrNewLine( *it ) && !isEndOfBuffer( it, end ) )
-    {
-        pBuffer[index] = *it ;
-        index++;
-        if (index == length-1)
-            break;
-        ++it;
-    }
-    pBuffer[ index ] = '\0';
-    return it;
-}
-
-/** @brief  Get next float from given line
- *  @param  it      set to current position
- *  @param  end     set to end of scratch buffer for readout
- *  @param  value   Separated float value.
- *  @return Current-iterator with new position
- */
-template<class char_t>
-inline char_t getFloat( char_t it, char_t end, ai_real &value )
-{
-    static const size_t BUFFERSIZE = 1024;
-    char buffer[ BUFFERSIZE ];
-    it = CopyNextWord<char_t>( it, end, buffer, BUFFERSIZE );
-    value = (ai_real) fast_atof( buffer );
-
-    return it;
-}
-
-/** @brief  Will perform a simple tokenize.
- *  @param  str         String to tokenize.
- *  @param  tokens      Array with tokens, will be empty if no token was found.
- *  @param  delimiters  Delimiter for tokenize.
- *  @return Number of found token.
- */
-template<class string_type>
-unsigned int tokenize( const string_type& str, std::vector<string_type>& tokens,
-                         const string_type& delimiters )
-{
-    // Skip delimiters at beginning.
-    typename string_type::size_type lastPos = str.find_first_not_of( delimiters, 0 );
-
-    // Find first "non-delimiter".
-    typename string_type::size_type pos = str.find_first_of( delimiters, lastPos );
-    while ( string_type::npos != pos || string_type::npos != lastPos )
-    {
-        // Found a token, add it to the vector.
-        string_type tmp = str.substr(lastPos, pos - lastPos);
-        if ( !tmp.empty() && ' ' != tmp[ 0 ] )
-            tokens.push_back( tmp );
-
-        // Skip delimiters.  Note the "not_of"
-        lastPos = str.find_first_not_of( delimiters, pos );
-
-        // Find next "non-delimiter"
-        pos = str.find_first_of( delimiters, lastPos );
-    }
-
-    return static_cast<unsigned int>( tokens.size() );
-}
-
-template <class string_type>
-string_type trim_whitespaces(string_type str)
-{
-    while (!str.empty() && IsSpace(str[0])) str.erase(0);
-    while (!str.empty() && IsSpace(str[str.length() - 1])) str.erase(str.length() - 1);
-    return str;
-}
-
-template<class T>
-bool hasLineEnd( T it, T end ) {
-    bool hasLineEnd( false );
-    while ( !isEndOfBuffer( it, end ) ) {
-        it++;
-        if ( IsLineEnd( it ) ) {
-            hasLineEnd = true;
-            break;
-        }
-    }
-
-    return hasLineEnd;
-}
-
-} // Namespace Assimp
-
-#endif // OBJ_TOOLS_H_INC
diff --git a/Engine/lib/assimp/code/Ogre/OgreBinarySerializer.h b/Engine/lib/assimp/code/Ogre/OgreBinarySerializer.h
deleted file mode 100644
index 8bab00ce9..000000000
--- a/Engine/lib/assimp/code/Ogre/OgreBinarySerializer.h
+++ /dev/null
@@ -1,423 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-#ifndef AI_OGREBINARYSERIALIZER_H_INC
-#define AI_OGREBINARYSERIALIZER_H_INC
-
-#ifndef ASSIMP_BUILD_NO_OGRE_IMPORTER
-
-#include "OgreStructs.h"
-#include <assimp/StreamReader.h>
-
-namespace Assimp
-{
-namespace Ogre
-{
-
-typedef Assimp::StreamReaderLE MemoryStreamReader;
-typedef std::shared_ptr<MemoryStreamReader> MemoryStreamReaderPtr;
-
-class OgreBinarySerializer
-{
-public:
-    /// Imports mesh and returns the result.
-    /** @note Fatal unrecoverable errors will throw a DeadlyImportError. */
-    static Mesh *ImportMesh(MemoryStreamReader *reader);
-
-    /// Imports skeleton to @c mesh into Mesh::skeleton.
-    /** If mesh does not have a skeleton reference or the skeleton file
-        cannot be found it is not a fatal DeadlyImportError.
-        @return If skeleton import was successful. */
-    static bool ImportSkeleton(Assimp::IOSystem *pIOHandler, Mesh *mesh);
-    static bool ImportSkeleton(Assimp::IOSystem *pIOHandler, MeshXml *mesh);
-
-private:
-    enum AssetMode
-    {
-        AM_Mesh,
-        AM_Skeleton
-    };
-
-    OgreBinarySerializer(MemoryStreamReader *reader, AssetMode mode) :
-        m_currentLen(0),
-        m_reader(reader),
-        assetMode(mode)
-    {
-    }
-
-    static MemoryStreamReaderPtr OpenReader(Assimp::IOSystem *pIOHandler, const std::string &filename);
-
-    // Header
-
-    uint16_t ReadHeader(bool readLen = true);
-    void RollbackHeader();
-
-    // Mesh
-
-    void ReadMesh(Mesh *mesh);
-    void ReadMeshLodInfo(Mesh *mesh);
-    void ReadMeshSkeletonLink(Mesh *mesh);
-    void ReadMeshBounds(Mesh *mesh);
-    void ReadMeshExtremes(Mesh *mesh);
-
-    void ReadSubMesh(Mesh *mesh);
-    void ReadSubMeshNames(Mesh *mesh);
-    void ReadSubMeshOperation(SubMesh *submesh);
-    void ReadSubMeshTextureAlias(SubMesh *submesh);
-
-    void ReadBoneAssignment(VertexData *dest);
-
-    void ReadGeometry(VertexData *dest);
-    void ReadGeometryVertexDeclaration(VertexData *dest);
-    void ReadGeometryVertexElement(VertexData *dest);
-    void ReadGeometryVertexBuffer(VertexData *dest);
-
-    void ReadEdgeList(Mesh *mesh);
-    void ReadPoses(Mesh *mesh);
-    void ReadPoseVertices(Pose *pose);
-
-    void ReadAnimations(Mesh *mesh);
-    void ReadAnimation(Animation *anim);
-    void ReadAnimationKeyFrames(Animation *anim, VertexAnimationTrack *track);
-
-    void NormalizeBoneWeights(VertexData *vertexData) const;
-
-    // Skeleton
-
-    void ReadSkeleton(Skeleton *skeleton);
-
-    void ReadBone(Skeleton *skeleton);
-    void ReadBoneParent(Skeleton *skeleton);
-
-    void ReadSkeletonAnimation(Skeleton *skeleton);
-    void ReadSkeletonAnimationTrack(Skeleton *skeleton, Animation *dest);
-    void ReadSkeletonAnimationKeyFrame(VertexAnimationTrack *dest);
-    void ReadSkeletonAnimationLink(Skeleton *skeleton);
-
-    // Reader utils
-    bool AtEnd() const;
-
-    template<typename T>
-    inline T Read();
-
-    void ReadBytes(char *dest, size_t numBytes);
-    void ReadBytes(uint8_t *dest, size_t numBytes);
-    void ReadBytes(void *dest, size_t numBytes);
-    uint8_t *ReadBytes(size_t numBytes);
-
-    void ReadVector(aiVector3D &vec);
-    void ReadQuaternion(aiQuaternion &quat);
-
-    std::string ReadString(size_t len);
-    std::string ReadLine();
-
-    void SkipBytes(size_t numBytes);
-
-    uint32_t m_currentLen;
-    MemoryStreamReader *m_reader;
-
-    AssetMode assetMode;
-};
-
-enum MeshChunkId
-{
-    M_HEADER = 0x1000,
-        // char*          version          : Version number check
-    M_MESH   = 0x3000,
-        // bool skeletallyAnimated   // important flag which affects h/w buffer policies
-        // Optional M_GEOMETRY chunk
-        M_SUBMESH            = 0x4000,
-            // char* materialName
-            // bool useSharedVertices
-            // unsigned int indexCount
-            // bool indexes32Bit
-            // unsigned int* faceVertexIndices (indexCount)
-            // OR
-            // unsigned short* faceVertexIndices (indexCount)
-            // M_GEOMETRY chunk (Optional: present only if useSharedVertices = false)
-            M_SUBMESH_OPERATION = 0x4010, // optional, trilist assumed if missing
-                // unsigned short operationType
-            M_SUBMESH_BONE_ASSIGNMENT = 0x4100,
-                // Optional bone weights (repeating section)
-                // unsigned int vertexIndex;
-                // unsigned short boneIndex;
-                // float weight;
-            // Optional chunk that matches a texture name to an alias
-            // a texture alias is sent to the submesh material to use this texture name
-            // instead of the one in the texture unit with a matching alias name
-            M_SUBMESH_TEXTURE_ALIAS = 0x4200, // Repeating section
-                // char* aliasName;
-                // char* textureName;
-
-        M_GEOMETRY        = 0x5000, // NB this chunk is embedded within M_MESH and M_SUBMESH
-            // unsigned int vertexCount
-            M_GEOMETRY_VERTEX_DECLARATION = 0x5100,
-                M_GEOMETRY_VERTEX_ELEMENT = 0x5110, // Repeating section
-                    // unsigned short source;   // buffer bind source
-                    // unsigned short type;     // VertexElementType
-                    // unsigned short semantic; // VertexElementSemantic
-                    // unsigned short offset;   // start offset in buffer in bytes
-                    // unsigned short index;    // index of the semantic (for colours and texture coords)
-            M_GEOMETRY_VERTEX_BUFFER = 0x5200, // Repeating section
-                // unsigned short bindIndex;    // Index to bind this buffer to
-                // unsigned short vertexSize;   // Per-vertex size, must agree with declaration at this index
-                M_GEOMETRY_VERTEX_BUFFER_DATA = 0x5210,
-                    // raw buffer data
-        M_MESH_SKELETON_LINK = 0x6000,
-            // Optional link to skeleton
-            // char* skeletonName          : name of .skeleton to use
-        M_MESH_BONE_ASSIGNMENT = 0x7000,
-            // Optional bone weights (repeating section)
-            // unsigned int vertexIndex;
-            // unsigned short boneIndex;
-            // float weight;
-        M_MESH_LOD = 0x8000,
-            // Optional LOD information
-            // string strategyName;
-            // unsigned short numLevels;
-            // bool manual;  (true for manual alternate meshes, false for generated)
-            M_MESH_LOD_USAGE = 0x8100,
-            // Repeating section, ordered in increasing depth
-            // NB LOD 0 (full detail from 0 depth) is omitted
-            // LOD value - this is a distance, a pixel count etc, based on strategy
-            // float lodValue;
-                M_MESH_LOD_MANUAL = 0x8110,
-                // Required if M_MESH_LOD section manual = true
-                // String manualMeshName;
-                M_MESH_LOD_GENERATED = 0x8120,
-                // Required if M_MESH_LOD section manual = false
-                // Repeating section (1 per submesh)
-                // unsigned int indexCount;
-                // bool indexes32Bit
-                // unsigned short* faceIndexes;  (indexCount)
-                // OR
-                // unsigned int* faceIndexes;  (indexCount)
-        M_MESH_BOUNDS = 0x9000,
-            // float minx, miny, minz
-            // float maxx, maxy, maxz
-            // float radius
-
-        // Added By DrEvil
-        // optional chunk that contains a table of submesh indexes and the names of
-        // the sub-meshes.
-        M_SUBMESH_NAME_TABLE = 0xA000,
-            // Subchunks of the name table. Each chunk contains an index & string
-            M_SUBMESH_NAME_TABLE_ELEMENT = 0xA100,
-                // short index
-                // char* name
-        // Optional chunk which stores precomputed edge data
-        M_EDGE_LISTS = 0xB000,
-            // Each LOD has a separate edge list
-            M_EDGE_LIST_LOD = 0xB100,
-                // unsigned short lodIndex
-                // bool isManual            // If manual, no edge data here, loaded from manual mesh
-                    // bool isClosed
-                    // unsigned long numTriangles
-                    // unsigned long numEdgeGroups
-                    // Triangle* triangleList
-                        // unsigned long indexSet
-                        // unsigned long vertexSet
-                        // unsigned long vertIndex[3]
-                        // unsigned long sharedVertIndex[3]
-                        // float normal[4]
-
-                    M_EDGE_GROUP = 0xB110,
-                        // unsigned long vertexSet
-                        // unsigned long triStart
-                        // unsigned long triCount
-                        // unsigned long numEdges
-                        // Edge* edgeList
-                            // unsigned long  triIndex[2]
-                            // unsigned long  vertIndex[2]
-                            // unsigned long  sharedVertIndex[2]
-                            // bool degenerate
-        // Optional poses section, referred to by pose keyframes
-        M_POSES = 0xC000,
-            M_POSE = 0xC100,
-                // char* name (may be blank)
-                // unsigned short target    // 0 for shared geometry,
-                                            // 1+ for submesh index + 1
-                // bool includesNormals [1.8+]
-                M_POSE_VERTEX = 0xC111,
-                    // unsigned long vertexIndex
-                    // float xoffset, yoffset, zoffset
-                    // float xnormal, ynormal, znormal (optional, 1.8+)
-        // Optional vertex animation chunk
-        M_ANIMATIONS = 0xD000,
-            M_ANIMATION = 0xD100,
-            // char* name
-            // float length
-            M_ANIMATION_BASEINFO = 0xD105,
-            // [Optional] base keyframe information (pose animation only)
-            // char* baseAnimationName (blank for self)
-            // float baseKeyFrameTime
-            M_ANIMATION_TRACK = 0xD110,
-                // unsigned short type          // 1 == morph, 2 == pose
-                // unsigned short target        // 0 for shared geometry,
-                                                // 1+ for submesh index + 1
-                M_ANIMATION_MORPH_KEYFRAME = 0xD111,
-                    // float time
-                    // bool includesNormals [1.8+]
-                    // float x,y,z          // repeat by number of vertices in original geometry
-                M_ANIMATION_POSE_KEYFRAME = 0xD112,
-                    // float time
-                    M_ANIMATION_POSE_REF = 0xD113, // repeat for number of referenced poses
-                        // unsigned short poseIndex
-                        // float influence
-        // Optional submesh extreme vertex list chink
-        M_TABLE_EXTREMES = 0xE000
-        // unsigned short submesh_index;
-        // float extremes [n_extremes][3];
-};
-
-/*
-static std::string MeshHeaderToString(MeshChunkId id)
-{
-    switch(id)
-    {
-        case M_HEADER:                      return "HEADER";
-        case M_MESH:                        return "MESH";
-        case M_SUBMESH:                     return "SUBMESH";
-        case M_SUBMESH_OPERATION:           return "SUBMESH_OPERATION";
-        case M_SUBMESH_BONE_ASSIGNMENT:     return "SUBMESH_BONE_ASSIGNMENT";
-        case M_SUBMESH_TEXTURE_ALIAS:       return "SUBMESH_TEXTURE_ALIAS";
-        case M_GEOMETRY:                    return "GEOMETRY";
-        case M_GEOMETRY_VERTEX_DECLARATION: return "GEOMETRY_VERTEX_DECLARATION";
-        case M_GEOMETRY_VERTEX_ELEMENT:     return "GEOMETRY_VERTEX_ELEMENT";
-        case M_GEOMETRY_VERTEX_BUFFER:      return "GEOMETRY_VERTEX_BUFFER";
-        case M_GEOMETRY_VERTEX_BUFFER_DATA: return "GEOMETRY_VERTEX_BUFFER_DATA";
-        case M_MESH_SKELETON_LINK:          return "MESH_SKELETON_LINK";
-        case M_MESH_BONE_ASSIGNMENT:        return "MESH_BONE_ASSIGNMENT";
-        case M_MESH_LOD:                    return "MESH_LOD";
-        case M_MESH_LOD_USAGE:              return "MESH_LOD_USAGE";
-        case M_MESH_LOD_MANUAL:             return "MESH_LOD_MANUAL";
-        case M_MESH_LOD_GENERATED:          return "MESH_LOD_GENERATED";
-        case M_MESH_BOUNDS:                 return "MESH_BOUNDS";
-        case M_SUBMESH_NAME_TABLE:          return "SUBMESH_NAME_TABLE";
-        case M_SUBMESH_NAME_TABLE_ELEMENT:  return "SUBMESH_NAME_TABLE_ELEMENT";
-        case M_EDGE_LISTS:                  return "EDGE_LISTS";
-        case M_EDGE_LIST_LOD:               return "EDGE_LIST_LOD";
-        case M_EDGE_GROUP:                  return "EDGE_GROUP";
-        case M_POSES:                       return "POSES";
-        case M_POSE:                        return "POSE";
-        case M_POSE_VERTEX:                 return "POSE_VERTEX";
-        case M_ANIMATIONS:                  return "ANIMATIONS";
-        case M_ANIMATION:                   return "ANIMATION";
-        case M_ANIMATION_BASEINFO:          return "ANIMATION_BASEINFO";
-        case M_ANIMATION_TRACK:             return "ANIMATION_TRACK";
-        case M_ANIMATION_MORPH_KEYFRAME:    return "ANIMATION_MORPH_KEYFRAME";
-        case M_ANIMATION_POSE_KEYFRAME:     return "ANIMATION_POSE_KEYFRAME";
-        case M_ANIMATION_POSE_REF:          return "ANIMATION_POSE_REF";
-        case M_TABLE_EXTREMES:              return "TABLE_EXTREMES";
-    }
-    return "Unknown_MeshChunkId";
-}
-*/
-
-enum SkeletonChunkId
-{
-    SKELETON_HEADER             = 0x1000,
-        // char* version           : Version number check
-        SKELETON_BLENDMODE      = 0x1010, // optional
-            // unsigned short blendmode     : SkeletonAnimationBlendMode
-    SKELETON_BONE               = 0x2000,
-    // Repeating section defining each bone in the system.
-    // Bones are assigned indexes automatically based on their order of declaration
-    // starting with 0.
-        // char* name                      : name of the bone
-        // unsigned short handle            : handle of the bone, should be contiguous & start at 0
-        // Vector3 position              : position of this bone relative to parent
-        // Quaternion orientation          : orientation of this bone relative to parent
-        // Vector3 scale                    : scale of this bone relative to parent
-    SKELETON_BONE_PARENT        = 0x3000,
-    // Record of the parent of a single bone, used to build the node tree
-    // Repeating section, listed in Bone Index order, one per Bone
-        // unsigned short handle             : child bone
-        // unsigned short parentHandle   : parent bone
-    SKELETON_ANIMATION          = 0x4000,
-    // A single animation for this skeleton
-        // char* name                      : Name of the animation
-        // float length                   : Length of the animation in seconds
-        SKELETON_ANIMATION_BASEINFO = 0x4010,
-        // [Optional] base keyframe information
-        // char* baseAnimationName (blank for self)
-        // float baseKeyFrameTime
-        SKELETON_ANIMATION_TRACK    = 0x4100,
-        // A single animation track (relates to a single bone)
-        // Repeating section (within SKELETON_ANIMATION)
-            // unsigned short boneIndex  : Index of bone to apply to
-            SKELETON_ANIMATION_TRACK_KEYFRAME = 0x4110,
-            // A single keyframe within the track
-            // Repeating section
-                // float time                   : The time position (seconds)
-                // Quaternion rotate            : Rotation to apply at this keyframe
-                // Vector3 translate            : Translation to apply at this keyframe
-                // Vector3 scale                : Scale to apply at this keyframe
-    SKELETON_ANIMATION_LINK     = 0x5000
-    // Link to another skeleton, to re-use its animations
-        // char* skeletonName                   : name of skeleton to get animations from
-        // float scale                          : scale to apply to trans/scale keys
-};
-
-/*
-static std::string SkeletonHeaderToString(SkeletonChunkId id)
-{
-    switch(id)
-    {
-        case SKELETON_HEADER:                   return "HEADER";
-        case SKELETON_BLENDMODE:                return "BLENDMODE";
-        case SKELETON_BONE:                     return "BONE";
-        case SKELETON_BONE_PARENT:              return "BONE_PARENT";
-        case SKELETON_ANIMATION:                return "ANIMATION";
-        case SKELETON_ANIMATION_BASEINFO:       return "ANIMATION_BASEINFO";
-        case SKELETON_ANIMATION_TRACK:          return "ANIMATION_TRACK";
-        case SKELETON_ANIMATION_TRACK_KEYFRAME: return "ANIMATION_TRACK_KEYFRAME";
-        case SKELETON_ANIMATION_LINK:           return "ANIMATION_LINK";
-    }
-    return "Unknown_SkeletonChunkId";
-}
-*/
-} // Ogre
-} // Assimp
-
-#endif // ASSIMP_BUILD_NO_OGRE_IMPORTER
-#endif // AI_OGREBINARYSERIALIZER_H_INC
diff --git a/Engine/lib/assimp/code/Ogre/OgreXmlSerializer.cpp b/Engine/lib/assimp/code/Ogre/OgreXmlSerializer.cpp
deleted file mode 100644
index 19fd3ad61..000000000
--- a/Engine/lib/assimp/code/Ogre/OgreXmlSerializer.cpp
+++ /dev/null
@@ -1,1002 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-#include "OgreXmlSerializer.h"
-#include "OgreBinarySerializer.h"
-#include "OgreParsingUtils.h"
-
-#include <assimp/TinyFormatter.h>
-#include <assimp/DefaultLogger.hpp>
-#include <memory>
-
-#ifndef ASSIMP_BUILD_NO_OGRE_IMPORTER
-
-// Define as 1 to get verbose logging.
-#define OGRE_XML_SERIALIZER_DEBUG 0
-
-namespace Assimp
-{
-namespace Ogre
-{
-
-AI_WONT_RETURN void ThrowAttibuteError(const XmlReader* reader, const std::string &name, const std::string &error = "") AI_WONT_RETURN_SUFFIX;
-AI_WONT_RETURN void ThrowAttibuteError(const XmlReader* reader, const std::string &name, const std::string &error)
-{
-    if (!error.empty())
-    {
-        throw DeadlyImportError(error + " in node '" + std::string(reader->getNodeName()) + "' and attribute '" + name + "'");
-    }
-    else
-    {
-        throw DeadlyImportError("Attribute '" + name + "' does not exist in node '" + std::string(reader->getNodeName()) + "'");
-    }
-}
-
-template<>
-int32_t OgreXmlSerializer::ReadAttribute<int32_t>(const char *name) const
-{
-    if (HasAttribute(name))
-    {
-        return static_cast<int32_t>(m_reader->getAttributeValueAsInt(name));
-    }
-    else
-    {
-        ThrowAttibuteError(m_reader, name);
-        return 0;
-    }
-}
-
-template<>
-uint32_t OgreXmlSerializer::ReadAttribute<uint32_t>(const char *name) const
-{
-    if (HasAttribute(name))
-    {
-        /** @note This is hackish. But we are never expecting unsigned values that go outside the
-            int32_t range. Just monitor for negative numbers and kill the import. */
-        int32_t temp = ReadAttribute<int32_t>(name);
-        if (temp >= 0)
-        {
-            return static_cast<uint32_t>(temp);
-        }
-        else
-        {
-            ThrowAttibuteError(m_reader, name, "Found a negative number value where expecting a uint32_t value");
-        }
-    }
-    else
-    {
-        ThrowAttibuteError(m_reader, name);
-    }
-    return 0;
-}
-
-template<>
-uint16_t OgreXmlSerializer::ReadAttribute<uint16_t>(const char *name) const
-{
-    if (HasAttribute(name))
-    {
-        return static_cast<uint16_t>(ReadAttribute<uint32_t>(name));
-    }
-    else
-    {
-        ThrowAttibuteError(m_reader, name);
-    }
-    return 0;
-}
-
-template<>
-float OgreXmlSerializer::ReadAttribute<float>(const char *name) const
-{
-    if (HasAttribute(name))
-    {
-        return m_reader->getAttributeValueAsFloat(name);
-    }
-    else
-    {
-        ThrowAttibuteError(m_reader, name);
-        return 0;
-    }
-}
-
-template<>
-std::string OgreXmlSerializer::ReadAttribute<std::string>(const char *name) const
-{
-    const char* value = m_reader->getAttributeValue(name);
-    if (value)
-    {
-        return std::string(value);
-    }
-    else
-    {
-        ThrowAttibuteError(m_reader, name);
-        return "";
-    }
-}
-
-template<>
-bool OgreXmlSerializer::ReadAttribute<bool>(const char *name) const
-{
-    std::string value = Ogre::ToLower(ReadAttribute<std::string>(name));
-    if (ASSIMP_stricmp(value, "true") == 0)
-    {
-        return true;
-    }
-    else if (ASSIMP_stricmp(value, "false") == 0)
-    {
-        return false;
-    }
-    else
-    {
-        ThrowAttibuteError(m_reader, name, "Boolean value is expected to be 'true' or 'false', encountered '" + value + "'");
-        return false;
-    }
-}
-
-bool OgreXmlSerializer::HasAttribute(const char *name) const
-{
-    return (m_reader->getAttributeValue(name) != 0);
-}
-
-std::string &OgreXmlSerializer::NextNode()
-{
-    do
-    {
-        if (!m_reader->read())
-        {
-            m_currentNodeName = "";
-            return m_currentNodeName;
-        }
-    }
-    while(m_reader->getNodeType() != irr::io::EXN_ELEMENT);
-
-    CurrentNodeName(true);
-#if (OGRE_XML_SERIALIZER_DEBUG == 1)
-    ASSIMP_LOG_DEBUG"<" + m_currentNodeName + ">");
-#endif
-    return m_currentNodeName;
-}
-
-bool OgreXmlSerializer::CurrentNodeNameEquals(const std::string &name) const
-{
-    return (ASSIMP_stricmp(m_currentNodeName, name) == 0);
-}
-
-std::string OgreXmlSerializer::CurrentNodeName(bool forceRead)
-{
-    if (forceRead)
-        m_currentNodeName = std::string(m_reader->getNodeName());
-    return m_currentNodeName;
-}
-
-std::string &OgreXmlSerializer::SkipCurrentNode()
-{
-#if (OGRE_XML_SERIALIZER_DEBUG == 1)
-    ASSIMP_LOG_DEBUG("Skipping node <" + m_currentNodeName + ">");
-#endif
-
-    for(;;) {
-        if (!m_reader->read()) {
-            m_currentNodeName = "";
-            return m_currentNodeName;
-        }
-        if ( m_reader->getNodeType() != irr::io::EXN_ELEMENT_END ) {
-            continue;
-        } else if ( std::string( m_reader->getNodeName() ) == m_currentNodeName ) {
-            break;
-        }
-    }
-
-    return NextNode();
-}
-
-// Mesh XML constants
-
-// <mesh>
-static const char *nnMesh                = "mesh";
-static const char *nnSharedGeometry      = "sharedgeometry";
-static const char *nnSubMeshes           = "submeshes";
-static const char *nnSubMesh             = "submesh";
-static const char *nnSubMeshNames        = "submeshnames";
-static const char *nnSkeletonLink        = "skeletonlink";
-static const char *nnLOD                 = "levelofdetail";
-static const char *nnExtremes            = "extremes";
-static const char *nnPoses               = "poses";
-static const char *nnAnimations          = "animations";
-
-// <submesh>
-static const char *nnFaces               = "faces";
-static const char *nnFace                = "face";
-static const char *nnGeometry            = "geometry";
-static const char *nnTextures            = "textures";
-
-// <mesh/submesh>
-static const char *nnBoneAssignments     = "boneassignments";
-
-// <sharedgeometry/geometry>
-static const char *nnVertexBuffer        = "vertexbuffer";
-
-// <vertexbuffer>
-static const char *nnVertex              = "vertex";
-static const char *nnPosition            = "position";
-static const char *nnNormal              = "normal";
-static const char *nnTangent             = "tangent";
-static const char *nnBinormal            = "binormal";
-static const char *nnTexCoord            = "texcoord";
-static const char *nnColorDiffuse        = "colour_diffuse";
-static const char *nnColorSpecular       = "colour_specular";
-
-// <boneassignments>
-static const char *nnVertexBoneAssignment = "vertexboneassignment";
-
-// Skeleton XML constants
-
-// <skeleton>
-static const char *nnSkeleton            = "skeleton";
-static const char *nnBones               = "bones";
-static const char *nnBoneHierarchy       = "bonehierarchy";
-static const char *nnAnimationLinks      = "animationlinks";
-
-// <bones>
-static const char *nnBone                = "bone";
-static const char *nnRotation            = "rotation";
-static const char *nnAxis                = "axis";
-static const char *nnScale               = "scale";
-
-// <bonehierarchy>
-static const char *nnBoneParent          = "boneparent";
-
-// <animations>
-static const char *nnAnimation           = "animation";
-static const char *nnTracks              = "tracks";
-
-// <tracks>
-static const char *nnTrack               = "track";
-static const char *nnKeyFrames           = "keyframes";
-static const char *nnKeyFrame            = "keyframe";
-static const char *nnTranslate           = "translate";
-static const char *nnRotate              = "rotate";
-
-// Common XML constants
-
-static const char *anX = "x";
-static const char *anY = "y";
-static const char *anZ = "z";
-
-// Mesh
-
-MeshXml *OgreXmlSerializer::ImportMesh(XmlReader *reader) {
-    OgreXmlSerializer serializer(reader);
-
-    MeshXml *mesh = new MeshXml();
-    serializer.ReadMesh(mesh);
-
-    return mesh;
-}
-
-void OgreXmlSerializer::ReadMesh(MeshXml *mesh) {
-    if (NextNode() != nnMesh) {
-        throw DeadlyImportError("Root node is <" + m_currentNodeName + "> expecting <mesh>");
-    }
-
-    ASSIMP_LOG_DEBUG("Reading Mesh");
-
-    NextNode();
-
-    // Root level nodes
-    while(m_currentNodeName == nnSharedGeometry  ||
-          m_currentNodeName == nnSubMeshes       ||
-          m_currentNodeName == nnSkeletonLink    ||
-          m_currentNodeName == nnBoneAssignments ||
-          m_currentNodeName == nnLOD             ||
-          m_currentNodeName == nnSubMeshNames    ||
-          m_currentNodeName == nnExtremes        ||
-          m_currentNodeName == nnPoses           ||
-          m_currentNodeName == nnAnimations)
-    {
-        if (m_currentNodeName == nnSharedGeometry)
-        {
-            mesh->sharedVertexData = new VertexDataXml();
-            ReadGeometry(mesh->sharedVertexData);
-        }
-        else if (m_currentNodeName == nnSubMeshes)
-        {
-            NextNode();
-            while(m_currentNodeName == nnSubMesh) {
-                ReadSubMesh(mesh);
-            }
-        }
-        else if (m_currentNodeName == nnBoneAssignments)
-        {
-            ReadBoneAssignments(mesh->sharedVertexData);
-        }
-        else if (m_currentNodeName == nnSkeletonLink)
-        {
-            mesh->skeletonRef = ReadAttribute<std::string>("name");
-            ASSIMP_LOG_DEBUG_F("Read skeleton link ", mesh->skeletonRef);
-            NextNode();
-        }
-        // Assimp incompatible/ignored nodes
-        else
-            SkipCurrentNode();
-    }
-}
-
-void OgreXmlSerializer::ReadGeometry(VertexDataXml *dest)
-{
-    dest->count = ReadAttribute<uint32_t>("vertexcount");
-    ASSIMP_LOG_DEBUG_F( "  - Reading geometry of ", dest->count, " vertices");
-
-    NextNode();
-    while(m_currentNodeName == nnVertexBuffer) {
-        ReadGeometryVertexBuffer(dest);
-    }
-}
-
-void OgreXmlSerializer::ReadGeometryVertexBuffer(VertexDataXml *dest)
-{
-    bool positions = (HasAttribute("positions") && ReadAttribute<bool>("positions"));
-    bool normals   = (HasAttribute("normals") && ReadAttribute<bool>("normals"));
-    bool tangents  = (HasAttribute("tangents") && ReadAttribute<bool>("tangents"));
-    uint32_t uvs   = (HasAttribute("texture_coords") ? ReadAttribute<uint32_t>("texture_coords") : 0);
-
-    // Not having positions is a error only if a previous vertex buffer did not have them.
-    if (!positions && !dest->HasPositions()) {
-        throw DeadlyImportError("Vertex buffer does not contain positions!");
-    }
-
-    if (positions)
-    {
-        ASSIMP_LOG_DEBUG("    - Contains positions");
-        dest->positions.reserve(dest->count);
-    }
-    if (normals)
-    {
-        ASSIMP_LOG_DEBUG("    - Contains normals");
-        dest->normals.reserve(dest->count);
-    }
-    if (tangents)
-    {
-        ASSIMP_LOG_DEBUG("    - Contains tangents");
-        dest->tangents.reserve(dest->count);
-    }
-    if (uvs > 0)
-    {
-        ASSIMP_LOG_DEBUG_F( "    - Contains ", uvs, " texture coords");
-        dest->uvs.resize(uvs);
-        for(size_t i=0, len=dest->uvs.size(); i<len; ++i) {
-            dest->uvs[i].reserve(dest->count);
-        }
-    }
-
-    bool warnBinormal = true;
-    bool warnColorDiffuse = true;
-    bool warnColorSpecular = true;
-
-    NextNode();
-
-    while(m_currentNodeName == nnVertex       ||
-          m_currentNodeName == nnPosition     ||
-          m_currentNodeName == nnNormal       ||
-          m_currentNodeName == nnTangent      ||
-          m_currentNodeName == nnBinormal     ||
-          m_currentNodeName == nnTexCoord     ||
-          m_currentNodeName == nnColorDiffuse ||
-          m_currentNodeName == nnColorSpecular)
-    {
-        if (m_currentNodeName == nnVertex) {
-            NextNode();
-        }
-
-        /// @todo Implement nnBinormal, nnColorDiffuse and nnColorSpecular
-
-        if (positions && m_currentNodeName == nnPosition)
-        {
-            aiVector3D pos;
-            pos.x = ReadAttribute<float>(anX);
-            pos.y = ReadAttribute<float>(anY);
-            pos.z = ReadAttribute<float>(anZ);
-            dest->positions.push_back(pos);
-        }
-        else if (normals && m_currentNodeName == nnNormal)
-        {
-            aiVector3D normal;
-            normal.x = ReadAttribute<float>(anX);
-            normal.y = ReadAttribute<float>(anY);
-            normal.z = ReadAttribute<float>(anZ);
-            dest->normals.push_back(normal);
-        }
-        else if (tangents && m_currentNodeName == nnTangent)
-        {
-            aiVector3D tangent;
-            tangent.x = ReadAttribute<float>(anX);
-            tangent.y = ReadAttribute<float>(anY);
-            tangent.z = ReadAttribute<float>(anZ);
-            dest->tangents.push_back(tangent);
-        }
-        else if (uvs > 0 && m_currentNodeName == nnTexCoord)
-        {
-            for(auto &uvs : dest->uvs)
-            {
-                if (m_currentNodeName != nnTexCoord) {
-                    throw DeadlyImportError("Vertex buffer declared more UVs than can be found in a vertex");
-                }
-
-                aiVector3D uv;
-                uv.x = ReadAttribute<float>("u");
-                uv.y = (ReadAttribute<float>("v") * -1) + 1; // Flip UV from Ogre to Assimp form
-                uvs.push_back(uv);
-
-                NextNode();
-            }
-            // Continue main loop as above already read next node
-            continue;
-        }
-        else
-        {
-            /// @todo Remove this stuff once implemented. We only want to log warnings once per element.
-            bool warn = true;
-            if (m_currentNodeName == nnBinormal)
-            {
-                if (warnBinormal)
-                {
-                    warnBinormal = false;
-                }
-                else
-                {
-                    warn = false;
-                }
-            }
-            else if (m_currentNodeName == nnColorDiffuse)
-            {
-                if (warnColorDiffuse)
-                {
-                    warnColorDiffuse = false;
-                }
-                else
-                {
-                    warn = false;
-                }
-            }
-            else if (m_currentNodeName == nnColorSpecular)
-            {
-                if (warnColorSpecular)
-                {
-                    warnColorSpecular = false;
-                }
-                else
-                {
-                    warn = false;
-                }
-            }
-            if (warn) {
-                ASSIMP_LOG_WARN_F("Vertex buffer attribute read not implemented for element: ", m_currentNodeName);
-            }
-        }
-
-        // Advance
-        NextNode();
-    }
-
-    // Sanity checks
-    if (dest->positions.size() != dest->count) {
-      throw DeadlyImportError(Formatter::format() << "Read only " << dest->positions.size() << " positions when should have read " << dest->count);
-    }
-    if (normals && dest->normals.size() != dest->count) {
-        throw DeadlyImportError(Formatter::format() << "Read only " << dest->normals.size() << " normals when should have read " << dest->count);
-    }
-    if (tangents && dest->tangents.size() != dest->count) {
-        throw DeadlyImportError(Formatter::format() << "Read only " << dest->tangents.size() << " tangents when should have read " << dest->count);
-    }
-    for(unsigned int i=0; i<dest->uvs.size(); ++i)
-    {
-        if (dest->uvs[i].size() != dest->count) {
-            throw DeadlyImportError(Formatter::format() << "Read only " << dest->uvs[i].size()
-                << " uvs for uv index " << i << " when should have read " << dest->count);
-        }
-    }
-}
-
-void OgreXmlSerializer::ReadSubMesh(MeshXml *mesh)
-{
-    static const char *anMaterial          = "material";
-    static const char *anUseSharedVertices = "usesharedvertices";
-    static const char *anCount             = "count";
-    static const char *anV1                = "v1";
-    static const char *anV2                = "v2";
-    static const char *anV3                = "v3";
-    static const char *anV4                = "v4";
-
-    SubMeshXml* submesh = new SubMeshXml();
-
-    if (HasAttribute(anMaterial)) {
-        submesh->materialRef = ReadAttribute<std::string>(anMaterial);
-    }
-    if (HasAttribute(anUseSharedVertices)) {
-        submesh->usesSharedVertexData = ReadAttribute<bool>(anUseSharedVertices);
-    }
-
-    ASSIMP_LOG_DEBUG_F( "Reading SubMesh ", mesh->subMeshes.size());
-    ASSIMP_LOG_DEBUG_F( "  - Material: '", submesh->materialRef, "'");
-    ASSIMP_LOG_DEBUG_F( "  - Uses shared geometry: ", (submesh->usesSharedVertexData ? "true" : "false"));
-
-    // TODO: maybe we have always just 1 faces and 1 geometry and always in this order. this loop will only work correct, when the order
-    // of faces and geometry changed, and not if we have more than one of one
-    /// @todo Fix above comment with better read logic below
-
-    bool quadWarned = false;
-
-    NextNode();
-    while(m_currentNodeName == nnFaces     ||
-          m_currentNodeName == nnGeometry  ||
-          m_currentNodeName == nnTextures  ||
-          m_currentNodeName == nnBoneAssignments)
-    {
-        if (m_currentNodeName == nnFaces)
-        {
-            submesh->indexData->faceCount = ReadAttribute<uint32_t>(anCount);
-            submesh->indexData->faces.reserve(submesh->indexData->faceCount);
-
-            NextNode();
-            while(m_currentNodeName == nnFace)
-            {
-                aiFace face;
-                face.mNumIndices = 3;
-                face.mIndices = new unsigned int[3];
-                face.mIndices[0] = ReadAttribute<uint32_t>(anV1);
-                face.mIndices[1] = ReadAttribute<uint32_t>(anV2);
-                face.mIndices[2] = ReadAttribute<uint32_t>(anV3);
-
-                /// @todo Support quads if Ogre even supports them in XML (I'm not sure but I doubt it)
-                if (!quadWarned && HasAttribute(anV4)) {
-                    ASSIMP_LOG_WARN("Submesh <face> has quads with <v4>, only triangles are supported at the moment!");
-                    quadWarned = true;
-                }
-
-                submesh->indexData->faces.push_back(face);
-
-                // Advance
-                NextNode();
-            }
-
-            if (submesh->indexData->faces.size() == submesh->indexData->faceCount) {
-                ASSIMP_LOG_DEBUG_F( "  - Faces ", submesh->indexData->faceCount);
-            } else {
-                throw DeadlyImportError(Formatter::format() << "Read only " << submesh->indexData->faces.size() << " faces when should have read " << submesh->indexData->faceCount);
-            }
-        } else if (m_currentNodeName == nnGeometry) {
-            if (submesh->usesSharedVertexData) {
-                throw DeadlyImportError("Found <geometry> in <submesh> when use shared geometry is true. Invalid mesh file.");
-            }
-
-            submesh->vertexData = new VertexDataXml();
-            ReadGeometry(submesh->vertexData);
-        } else if (m_currentNodeName == nnBoneAssignments) {
-            ReadBoneAssignments(submesh->vertexData);
-        }
-        // Assimp incompatible/ignored nodes
-        else {
-            SkipCurrentNode();
-        }
-    }
-
-    submesh->index = static_cast<unsigned int>(mesh->subMeshes.size());
-    mesh->subMeshes.push_back(submesh);
-}
-
-void OgreXmlSerializer::ReadBoneAssignments(VertexDataXml *dest)
-{
-    if (!dest) {
-        throw DeadlyImportError("Cannot read bone assignments, vertex data is null.");
-    }
-
-    static const char *anVertexIndex = "vertexindex";
-    static const char *anBoneIndex   = "boneindex";
-    static const char *anWeight      = "weight";
-
-    std::set<uint32_t> influencedVertices;
-
-    NextNode();
-    while(m_currentNodeName == nnVertexBoneAssignment)
-    {
-        VertexBoneAssignment ba;
-        ba.vertexIndex = ReadAttribute<uint32_t>(anVertexIndex);
-        ba.boneIndex = ReadAttribute<uint16_t>(anBoneIndex);
-        ba.weight = ReadAttribute<float>(anWeight);
-
-        dest->boneAssignments.push_back(ba);
-        influencedVertices.insert(ba.vertexIndex);
-
-        NextNode();
-    }
-
-    /** Normalize bone weights.
-        Some exporters won't care if the sum of all bone weights
-        for a single vertex equals 1 or not, so validate here. */
-    const float epsilon = 0.05f;
-    for (const uint32_t vertexIndex : influencedVertices)
-    {
-        float sum = 0.0f;
-        for (VertexBoneAssignmentList::const_iterator baIter=dest->boneAssignments.begin(), baEnd=dest->boneAssignments.end(); baIter != baEnd; ++baIter)
-        {
-            if (baIter->vertexIndex == vertexIndex)
-                sum += baIter->weight;
-        }
-        if ((sum < (1.0f - epsilon)) || (sum > (1.0f + epsilon)))
-        {
-            for (auto &boneAssign : dest->boneAssignments)
-            {
-                if (boneAssign.vertexIndex == vertexIndex)
-                    boneAssign.weight /= sum;
-            }
-        }
-    }
-
-    ASSIMP_LOG_DEBUG_F( "  - ", dest->boneAssignments.size(), " bone assignments");
-}
-
-// Skeleton
-
-bool OgreXmlSerializer::ImportSkeleton(Assimp::IOSystem *pIOHandler, MeshXml *mesh)
-{
-    if (!mesh || mesh->skeletonRef.empty())
-        return false;
-
-    // Highly unusual to see in read world cases but support
-    // XML mesh referencing a binary skeleton file.
-    if (EndsWith(mesh->skeletonRef, ".skeleton", false))
-    {
-        if (OgreBinarySerializer::ImportSkeleton(pIOHandler, mesh))
-            return true;
-
-        /** Last fallback if .skeleton failed to be read. Try reading from
-            .skeleton.xml even if the XML file referenced a binary skeleton.
-            @note This logic was in the previous version and I don't want to break
-            old code that might depends on it. */
-        mesh->skeletonRef = mesh->skeletonRef + ".xml";
-    }
-
-    XmlReaderPtr reader = OpenReader(pIOHandler, mesh->skeletonRef);
-    if (!reader.get())
-        return false;
-
-    Skeleton *skeleton = new Skeleton();
-    OgreXmlSerializer serializer(reader.get());
-    serializer.ReadSkeleton(skeleton);
-    mesh->skeleton = skeleton;
-    return true;
-}
-
-bool OgreXmlSerializer::ImportSkeleton(Assimp::IOSystem *pIOHandler, Mesh *mesh)
-{
-    if (!mesh || mesh->skeletonRef.empty())
-        return false;
-
-    XmlReaderPtr reader = OpenReader(pIOHandler, mesh->skeletonRef);
-    if (!reader.get())
-        return false;
-
-    Skeleton *skeleton = new Skeleton();
-    OgreXmlSerializer serializer(reader.get());
-    serializer.ReadSkeleton(skeleton);
-    mesh->skeleton = skeleton;
-    return true;
-}
-
-XmlReaderPtr OgreXmlSerializer::OpenReader(Assimp::IOSystem *pIOHandler, const std::string &filename)
-{
-    if (!EndsWith(filename, ".skeleton.xml", false))
-    {
-        ASSIMP_LOG_ERROR_F("Imported Mesh is referencing to unsupported '", filename, "' skeleton file.");
-        return XmlReaderPtr();
-    }
-
-    if (!pIOHandler->Exists(filename))
-    {
-        ASSIMP_LOG_ERROR_F("Failed to find skeleton file '", filename, "' that is referenced by imported Mesh.");
-        return XmlReaderPtr();
-    }
-
-    std::unique_ptr<IOStream> file(pIOHandler->Open(filename));
-    if (!file.get()) {
-        throw DeadlyImportError("Failed to open skeleton file " + filename);
-    }
-
-    std::unique_ptr<CIrrXML_IOStreamReader> stream(new CIrrXML_IOStreamReader(file.get()));
-    XmlReaderPtr reader = XmlReaderPtr(irr::io::createIrrXMLReader(stream.get()));
-    if (!reader.get()) {
-        throw DeadlyImportError("Failed to create XML reader for skeleton file " + filename);
-    }
-    return reader;
-}
-
-void OgreXmlSerializer::ReadSkeleton(Skeleton *skeleton)
-{
-    if (NextNode() != nnSkeleton) {
-        throw DeadlyImportError("Root node is <" + m_currentNodeName + "> expecting <skeleton>");
-    }
-
-    ASSIMP_LOG_DEBUG("Reading Skeleton");
-
-    // Optional blend mode from root node
-    if (HasAttribute("blendmode")) {
-        skeleton->blendMode = (ToLower(ReadAttribute<std::string>("blendmode")) == "cumulative"
-            ? Skeleton::ANIMBLEND_CUMULATIVE : Skeleton::ANIMBLEND_AVERAGE);
-    }
-
-    NextNode();
-
-    // Root level nodes
-    while(m_currentNodeName == nnBones         ||
-          m_currentNodeName == nnBoneHierarchy ||
-          m_currentNodeName == nnAnimations    ||
-          m_currentNodeName == nnAnimationLinks)
-    {
-        if (m_currentNodeName == nnBones)
-            ReadBones(skeleton);
-        else if (m_currentNodeName == nnBoneHierarchy)
-            ReadBoneHierarchy(skeleton);
-        else if (m_currentNodeName == nnAnimations)
-            ReadAnimations(skeleton);
-        else
-            SkipCurrentNode();
-    }
-}
-
-void OgreXmlSerializer::ReadAnimations(Skeleton *skeleton)
-{
-    if (skeleton->bones.empty()) {
-        throw DeadlyImportError("Cannot read <animations> for a Skeleton without bones");
-    }
-
-    ASSIMP_LOG_DEBUG("  - Animations");
-
-    NextNode();
-    while(m_currentNodeName == nnAnimation)
-    {
-        Animation *anim = new Animation(skeleton);
-        anim->name = ReadAttribute<std::string>("name");
-        anim->length = ReadAttribute<float>("length");
-
-        if (NextNode() != nnTracks) {
-            throw DeadlyImportError(Formatter::format() << "No <tracks> found in <animation> " << anim->name);
-        }
-
-        ReadAnimationTracks(anim);
-        skeleton->animations.push_back(anim);
-
-        ASSIMP_LOG_DEBUG_F( "    ", anim->name, " (", anim->length, " sec, ", anim->tracks.size(), " tracks)");
-    }
-}
-
-void OgreXmlSerializer::ReadAnimationTracks(Animation *dest)
-{
-    NextNode();
-    while(m_currentNodeName == nnTrack)
-    {
-        VertexAnimationTrack track;
-        track.type = VertexAnimationTrack::VAT_TRANSFORM;
-        track.boneName = ReadAttribute<std::string>("bone");
-
-        if (NextNode() != nnKeyFrames) {
-            throw DeadlyImportError(Formatter::format() << "No <keyframes> found in <track> " << dest->name);
-        }
-
-        ReadAnimationKeyFrames(dest, &track);
-
-        dest->tracks.push_back(track);
-    }
-}
-
-void OgreXmlSerializer::ReadAnimationKeyFrames(Animation *anim, VertexAnimationTrack *dest)
-{
-    const aiVector3D zeroVec(0.f, 0.f, 0.f);
-
-    NextNode();
-    while(m_currentNodeName == nnKeyFrame)
-    {
-        TransformKeyFrame keyframe;
-        keyframe.timePos = ReadAttribute<float>("time");
-
-        NextNode();
-        while(m_currentNodeName == nnTranslate || m_currentNodeName == nnRotate || m_currentNodeName == nnScale)
-        {
-            if (m_currentNodeName == nnTranslate)
-            {
-                keyframe.position.x = ReadAttribute<float>(anX);
-                keyframe.position.y = ReadAttribute<float>(anY);
-                keyframe.position.z = ReadAttribute<float>(anZ);
-            }
-            else if (m_currentNodeName == nnRotate)
-            {
-                float angle = ReadAttribute<float>("angle");
-
-                if (NextNode() != nnAxis) {
-                    throw DeadlyImportError("No axis specified for keyframe rotation in animation " + anim->name);
-                }
-
-                aiVector3D axis;
-                axis.x = ReadAttribute<float>(anX);
-                axis.y = ReadAttribute<float>(anY);
-                axis.z = ReadAttribute<float>(anZ);
-                if (axis.Equal(zeroVec))
-                {
-                    axis.x = 1.0f;
-                    if (angle != 0) {
-                        ASSIMP_LOG_WARN_F("Found invalid a key frame with a zero rotation axis in animation: ", anim->name);
-                    }
-                }
-                keyframe.rotation = aiQuaternion(axis, angle);
-            }
-            else if (m_currentNodeName == nnScale)
-            {
-                keyframe.scale.x = ReadAttribute<float>(anX);
-                keyframe.scale.y = ReadAttribute<float>(anY);
-                keyframe.scale.z = ReadAttribute<float>(anZ);
-            }
-
-            NextNode();
-        }
-
-        dest->transformKeyFrames.push_back(keyframe);
-    }
-}
-
-void OgreXmlSerializer::ReadBoneHierarchy(Skeleton *skeleton)
-{
-    if (skeleton->bones.empty()) {
-        throw DeadlyImportError("Cannot read <bonehierarchy> for a Skeleton without bones");
-    }
-
-    while(NextNode() == nnBoneParent)
-    {
-        const std::string name = ReadAttribute<std::string>("bone");
-        const std::string parentName = ReadAttribute<std::string>("parent");
-
-        Bone *bone = skeleton->BoneByName(name);
-        Bone *parent = skeleton->BoneByName(parentName);
-
-        if (bone && parent)
-            parent->AddChild(bone);
-        else
-            throw DeadlyImportError("Failed to find bones for parenting: Child " + name + " for parent " + parentName);
-    }
-
-    // Calculate bone matrices for root bones. Recursively calculates their children.
-    for (size_t i=0, len=skeleton->bones.size(); i<len; ++i)
-    {
-        Bone *bone = skeleton->bones[i];
-        if (!bone->IsParented())
-            bone->CalculateWorldMatrixAndDefaultPose(skeleton);
-    }
-}
-
-static bool BoneCompare(Bone *a, Bone *b)
-{
-    ai_assert( nullptr != a );
-    ai_assert( nullptr != b );
-    
-    return (a->id < b->id);
-}
-
-void OgreXmlSerializer::ReadBones(Skeleton *skeleton)
-{
-    ASSIMP_LOG_DEBUG("  - Bones");
-
-    NextNode();
-    while(m_currentNodeName == nnBone)
-    {
-        Bone *bone = new Bone();
-        bone->id = ReadAttribute<uint16_t>("id");
-        bone->name = ReadAttribute<std::string>("name");
-
-        NextNode();
-        while(m_currentNodeName == nnPosition ||
-              m_currentNodeName == nnRotation ||
-              m_currentNodeName == nnScale)
-        {
-            if (m_currentNodeName == nnPosition)
-            {
-                bone->position.x = ReadAttribute<float>(anX);
-                bone->position.y = ReadAttribute<float>(anY);
-                bone->position.z = ReadAttribute<float>(anZ);
-            }
-            else if (m_currentNodeName == nnRotation)
-            {
-                float angle = ReadAttribute<float>("angle");
-
-                if (NextNode() != nnAxis) {
-                    throw DeadlyImportError(Formatter::format() << "No axis specified for bone rotation in bone " << bone->id);
-                }
-
-                aiVector3D axis;
-                axis.x = ReadAttribute<float>(anX);
-                axis.y = ReadAttribute<float>(anY);
-                axis.z = ReadAttribute<float>(anZ);
-
-                bone->rotation = aiQuaternion(axis, angle);
-            }
-            else if (m_currentNodeName == nnScale)
-            {
-                /// @todo Implement taking scale into account in matrix/pose calculations!
-                if (HasAttribute("factor"))
-                {
-                    float factor = ReadAttribute<float>("factor");
-                    bone->scale.Set(factor, factor, factor);
-                }
-                else
-                {
-                    if (HasAttribute(anX))
-                        bone->scale.x = ReadAttribute<float>(anX);
-                    if (HasAttribute(anY))
-                        bone->scale.y = ReadAttribute<float>(anY);
-                    if (HasAttribute(anZ))
-                        bone->scale.z = ReadAttribute<float>(anZ);
-                }
-            }
-
-            NextNode();
-        }
-
-        skeleton->bones.push_back(bone);
-    }
-
-    // Order bones by Id
-    std::sort(skeleton->bones.begin(), skeleton->bones.end(), BoneCompare);
-
-    // Validate that bone indexes are not skipped.
-    /** @note Left this from original authors code, but not sure if this is strictly necessary
-        as per the Ogre skeleton spec. It might be more that other (later) code in this imported does not break. */
-    for (size_t i=0, len=skeleton->bones.size(); i<len; ++i)
-    {
-        Bone *b = skeleton->bones[i];
-        ASSIMP_LOG_DEBUG_F( "    ", b->id, " ", b->name);
-
-        if (b->id != static_cast<uint16_t>(i)) {
-            throw DeadlyImportError(Formatter::format() << "Bone ids are not in sequence starting from 0. Missing index " << i);
-        }
-    }
-}
-
-} // Ogre
-} // Assimp
-
-#endif // ASSIMP_BUILD_NO_OGRE_IMPORTER
diff --git a/Engine/lib/assimp/code/OpenGEX/OpenGEXImporter.cpp b/Engine/lib/assimp/code/OpenGEX/OpenGEXImporter.cpp
deleted file mode 100644
index 07d3efd5e..000000000
--- a/Engine/lib/assimp/code/OpenGEX/OpenGEXImporter.cpp
+++ /dev/null
@@ -1,1326 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-#ifndef ASSIMP_BUILD_NO_OPENGEX_IMPORTER
-
-#include "OpenGEX/OpenGEXImporter.h"
-#include "PostProcessing/MakeVerboseFormat.h"
-
-#include <assimp/DefaultIOSystem.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/StringComparison.h>
-
-#include <openddlparser/OpenDDLParser.h>
-#include <assimp/scene.h>
-#include <assimp/ai_assert.h>
-#include <assimp/importerdesc.h>
-
-#include <vector>
-
-static const aiImporterDesc desc = {
-    "Open Game Engine Exchange",
-    "",
-    "",
-    "",
-    aiImporterFlags_SupportTextFlavour,
-    0,
-    0,
-    0,
-    0,
-    "ogex"
-};
-
-namespace Grammar {
-    static const std::string MetricType          = "Metric";
-    static const std::string Metric_DistanceType = "distance";
-    static const std::string Metric_AngleType    = "angle";
-    static const std::string Metric_TimeType     = "time";
-    static const std::string Metric_UpType       = "up";
-    static const std::string NameType            = "Name";
-    static const std::string ObjectRefType       = "ObjectRef";
-    static const std::string MaterialRefType     = "MaterialRef";
-    static const std::string MetricKeyType       = "key";
-    static const std::string GeometryNodeType    = "GeometryNode";
-    static const std::string CameraNodeType      = "CameraNode";
-    static const std::string LightNodeType       = "LightNode";
-    static const std::string GeometryObjectType  = "GeometryObject";
-    static const std::string CameraObjectType    = "CameraObject";
-    static const std::string LightObjectType     = "LightObject";
-    static const std::string TransformType       = "Transform";
-    static const std::string MeshType            = "Mesh";
-    static const std::string VertexArrayType     = "VertexArray";
-    static const std::string IndexArrayType      = "IndexArray";
-    static const std::string MaterialType        = "Material";
-    static const std::string ColorType           = "Color";
-    static const std::string ParamType           = "Param";
-    static const std::string TextureType         = "Texture";
-    static const std::string AttenType           = "Atten";
-
-    static const std::string DiffuseColorToken  = "diffuse";
-    static const std::string SpecularColorToken = "specular";
-    static const std::string EmissionColorToken = "emission";
-
-    static const std::string DiffuseTextureToken         = "diffuse";
-    static const std::string DiffuseSpecularTextureToken = "specular";
-    static const std::string SpecularPowerTextureToken   = "specular_power";
-    static const std::string EmissionTextureToken        = "emission";
-    static const std::string OpacyTextureToken           = "opacity";
-    static const std::string TransparencyTextureToken    = "transparency";
-    static const std::string NormalTextureToken          = "normal";
-
-    enum TokenType {
-        NoneType = -1,
-        MetricToken,
-        NameToken,
-        ObjectRefToken,
-        MaterialRefToken,
-        MetricKeyToken,
-        GeometryNodeToken,
-        CameraNodeToken,
-        LightNodeToken,
-        GeometryObjectToken,
-        CameraObjectToken,
-        LightObjectToken,
-        TransformToken,
-        MeshToken,
-        VertexArrayToken,
-        IndexArrayToken,
-        MaterialToken,
-        ColorToken,
-        ParamToken,
-        TextureToken,
-        AttenToken
-    };
-
-    static const std::string ValidMetricToken[ 4 ] = {
-        Metric_DistanceType,
-        Metric_AngleType,
-        Metric_TimeType,
-        Metric_UpType
-    };
-
-    static int isValidMetricType( const char *token ) {
-        if( nullptr == token ) {
-            return false;
-        }
-
-        int idx( -1 );
-        for( size_t i = 0; i < 4; i++ ) {
-            if( ValidMetricToken[ i ] == token ) {
-                idx = (int) i;
-                break;
-            }
-        }
-
-        return idx;
-    }
-
-    static TokenType matchTokenType( const char *tokenType ) {
-        if( MetricType == tokenType ) {
-            return MetricToken;
-        } else if(  NameType == tokenType ) {
-            return NameToken;
-        } else if( ObjectRefType == tokenType ) {
-            return ObjectRefToken;
-        } else if( MaterialRefType == tokenType ) {
-            return MaterialRefToken;
-        } else if( MetricKeyType == tokenType ) {
-            return MetricKeyToken;
-        } else if ( GeometryNodeType == tokenType ) {
-            return GeometryNodeToken;
-        } else if ( CameraNodeType == tokenType ) {
-            return CameraNodeToken;
-        } else if ( LightNodeType == tokenType ) {
-            return LightNodeToken;
-        } else if ( GeometryObjectType == tokenType ) {
-            return GeometryObjectToken;
-        } else if ( CameraObjectType == tokenType ) {
-            return CameraObjectToken;
-        } else if ( LightObjectType == tokenType ) {
-            return LightObjectToken;
-        } else if( TransformType == tokenType ) {
-            return TransformToken;
-        } else if( MeshType == tokenType ) {
-            return MeshToken;
-        } else if( VertexArrayType == tokenType ) {
-            return VertexArrayToken;
-        } else if( IndexArrayType == tokenType ) {
-            return IndexArrayToken;
-        } else if(  MaterialType == tokenType ) {
-            return MaterialToken;
-        } else if ( ColorType == tokenType ) {
-            return ColorToken;
-        } else if ( ParamType == tokenType ) {
-            return ParamToken;
-        } else if(  TextureType == tokenType ) {
-            return TextureToken;
-        } else if ( AttenType == tokenType ) {
-            return AttenToken;
-        }
-
-        return NoneType;
-    }
-} // Namespace Grammar
-
-namespace Assimp {
-namespace OpenGEX {
-
-USE_ODDLPARSER_NS
-
-//------------------------------------------------------------------------------------------------
-static void propId2StdString( Property *prop, std::string &name, std::string &key ) {
-    name = key = "";
-    if ( nullptr == prop ) {
-        return;
-    }
-
-    if ( nullptr != prop->m_key ) {
-#ifdef ASSIMP_USE_HUNTER
-        name = prop->m_key->m_text.m_buffer;
-#else
-        name = prop->m_key->m_buffer;
-#endif
-        if ( Value::ddl_string == prop->m_value->m_type ) {
-            key = prop->m_value->getString();
-        }
-    }
-}
-
-//------------------------------------------------------------------------------------------------
-OpenGEXImporter::VertexContainer::VertexContainer()
-: m_numColors( 0 )
-, m_colors( nullptr )
-, m_numUVComps()
-, m_textureCoords() {
-    // empty
-}
-
-//------------------------------------------------------------------------------------------------
-OpenGEXImporter::VertexContainer::~VertexContainer() {
-    delete[] m_colors;
-
-    for(auto &texcoords : m_textureCoords) {
-        delete [] texcoords;
-    }
-}
-
-//------------------------------------------------------------------------------------------------
-OpenGEXImporter::RefInfo::RefInfo( aiNode *node, Type type, std::vector<std::string> &names )
-: m_node( node )
-, m_type( type )
-, m_Names( names ) {
-    // empty
-}
-
-//------------------------------------------------------------------------------------------------
-OpenGEXImporter::RefInfo::~RefInfo() {
-    // empty
-}
-
-//------------------------------------------------------------------------------------------------
-OpenGEXImporter::OpenGEXImporter()
-: m_root( nullptr )
-, m_nodeChildMap()
-, m_meshCache()
-, m_mesh2refMap()
-, m_material2refMap()
-, m_ctx( nullptr )
-, m_metrics()
-, m_currentNode( nullptr )
-, m_currentVertices()
-, m_currentMesh( nullptr )
-, m_currentMaterial( nullptr )
-, m_currentLight( nullptr )
-, m_currentCamera( nullptr )
-, m_tokenType( Grammar::NoneType )
-, m_materialCache()
-, m_cameraCache()
-, m_lightCache()
-, m_nodeStack()
-, m_unresolvedRefStack() {
-    // empty
-}
-
-//------------------------------------------------------------------------------------------------
-OpenGEXImporter::~OpenGEXImporter() {
-    m_ctx = nullptr;
-}
-
-//------------------------------------------------------------------------------------------------
-bool OpenGEXImporter::CanRead( const std::string &file, IOSystem *pIOHandler, bool checkSig ) const {
-    bool canRead( false );
-    if( !checkSig ) {
-        canRead = SimpleExtensionCheck( file, "ogex" );
-    } else {
-        static const char *token[] = { "Metric", "GeometryNode", "VertexArray (attrib", "IndexArray" };
-        canRead = BaseImporter::SearchFileHeaderForToken( pIOHandler, file, token, 4 );
-    }
-
-    return canRead;
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::InternReadFile( const std::string &filename, aiScene *pScene, IOSystem *pIOHandler ) {
-    // open source file
-    IOStream *file = pIOHandler->Open( filename, "rb" );
-    if( !file ) {
-        throw DeadlyImportError( "Failed to open file " + filename );
-    }
-
-    std::vector<char> buffer;
-    TextFileToBuffer( file, buffer );
-    pIOHandler->Close( file );
-
-    OpenDDLParser myParser;
-    myParser.setBuffer( &buffer[ 0 ], buffer.size() );
-    bool success( myParser.parse() );
-    if( success ) {
-        m_ctx = myParser.getContext();
-        pScene->mRootNode = new aiNode;
-        pScene->mRootNode->mName.Set( filename );
-        handleNodes( m_ctx->m_root, pScene );
-    }
-
-    copyMeshes( pScene );
-    copyCameras( pScene );
-    copyLights( pScene );
-    copyMaterials( pScene );
-    resolveReferences();
-    createNodeTree( pScene );
-}
-
-//------------------------------------------------------------------------------------------------
-const aiImporterDesc *OpenGEXImporter::GetInfo() const {
-    return &desc;
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::SetupProperties( const Importer *pImp ) {
-    if( nullptr == pImp ) {
-        return;
-    }
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::handleNodes( DDLNode *node, aiScene *pScene ) {
-    if( nullptr == node ) {
-        return;
-    }
-
-    DDLNode::DllNodeList childs = node->getChildNodeList();
-    for( DDLNode::DllNodeList::iterator it = childs.begin(); it != childs.end(); ++it ) {
-        Grammar::TokenType tokenType( Grammar::matchTokenType( ( *it )->getType().c_str() ) );
-        switch( tokenType ) {
-            case Grammar::MetricToken:
-                handleMetricNode( *it, pScene );
-                break;
-
-            case Grammar::NameToken:
-                handleNameNode( *it, pScene );
-                break;
-
-            case Grammar::ObjectRefToken:
-                handleObjectRefNode( *it, pScene );
-                break;
-
-            case Grammar::MaterialRefToken:
-                handleMaterialRefNode( *it, pScene );
-                break;
-
-            case Grammar::MetricKeyToken:
-                break;
-
-            case Grammar::GeometryNodeToken:
-                handleGeometryNode( *it, pScene );
-                break;
-
-            case Grammar::CameraNodeToken:
-                handleCameraNode( *it, pScene );
-                break;
-
-            case Grammar::LightNodeToken:
-                handleLightNode( *it, pScene );
-                break;
-
-            case Grammar::GeometryObjectToken:
-                handleGeometryObject( *it, pScene );
-                break;
-
-            case Grammar::CameraObjectToken:
-                handleCameraObject( *it, pScene );
-                break;
-
-            case Grammar::LightObjectToken:
-                handleLightObject( *it, pScene );
-                break;
-
-            case Grammar::TransformToken:
-                handleTransformNode( *it, pScene );
-                break;
-
-            case Grammar::MeshToken:
-                handleMeshNode( *it, pScene );
-                break;
-
-            case Grammar::VertexArrayToken:
-                handleVertexArrayNode( *it, pScene );
-                break;
-
-            case Grammar::IndexArrayToken:
-                handleIndexArrayNode( *it, pScene );
-                break;
-
-            case Grammar::MaterialToken:
-                handleMaterialNode( *it, pScene );
-                break;
-
-            case Grammar::ColorToken:
-                handleColorNode( *it, pScene );
-                break;
-
-            case Grammar::ParamToken:
-                handleParamNode( *it, pScene );
-                break;
-
-            case Grammar::TextureToken:
-                handleTextureNode( *it, pScene );
-                break;
-
-            default:
-                break;
-        }
-    }
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::handleMetricNode( DDLNode *node, aiScene * /*pScene*/ ) {
-    if( nullptr == node || nullptr == m_ctx ) {
-        return;
-    }
-
-    if( m_ctx->m_root != node->getParent() ) {
-        return;
-    }
-
-    Property *prop( node->getProperties() );
-    while( nullptr != prop ) {
-        if( nullptr != prop->m_key ) {
-            if( Value::ddl_string == prop->m_value->m_type ) {
-                std::string valName( ( char* ) prop->m_value->m_data );
-                int type( Grammar::isValidMetricType( valName.c_str() ) );
-                if( Grammar::NoneType != type ) {
-                    Value *val( node->getValue() );
-                    if( nullptr != val ) {
-                        if( Value::ddl_float == val->m_type ) {
-                            m_metrics[ type ].m_floatValue = val->getFloat();
-                        } else if( Value::ddl_int32 == val->m_type ) {
-                            m_metrics[ type ].m_intValue = val->getInt32();
-                        } else if( Value::ddl_string == val->m_type ) {
-                            m_metrics[type].m_stringValue = std::string( val->getString() );
-                        } else {
-                            throw DeadlyImportError( "OpenGEX: invalid data type for Metric node." );
-                        }
-                    }
-                }
-            }
-        }
-        prop = prop->m_next;
-    }
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::handleNameNode( DDLNode *node, aiScene * /*pScene*/ ) {
-    if( nullptr == m_currentNode ) {
-        throw DeadlyImportError( "No current node for name." );
-        return;
-    }
-
-    Value *val( node->getValue() );
-    if( nullptr != val ) {
-        if( Value::ddl_string != val->m_type ) {
-            throw DeadlyImportError( "OpenGEX: invalid data type for value in node name." );
-            return;
-        }
-
-        const std::string name( val->getString() );
-        if( m_tokenType == Grammar::GeometryNodeToken || m_tokenType == Grammar::LightNodeToken
-                || m_tokenType == Grammar::CameraNodeToken ) {
-            m_currentNode->mName.Set( name.c_str() );
-        } else if( m_tokenType == Grammar::MaterialToken ) {
-            aiString aiName;
-            aiName.Set( name );
-            m_currentMaterial->AddProperty( &aiName, AI_MATKEY_NAME );
-            m_material2refMap[ name ] = m_materialCache.size() - 1;
-        }
-    }
-}
-
-//------------------------------------------------------------------------------------------------
-static void getRefNames( DDLNode *node, std::vector<std::string> &names ) {
-    ai_assert( nullptr != node );
-
-    Reference *ref = node->getReferences();
-    if( nullptr != ref ) {
-        for( size_t i = 0; i < ref->m_numRefs; i++ )  {
-            Name *currentName( ref->m_referencedName[ i ] );
-            if( nullptr != currentName && nullptr != currentName->m_id ) {
-#ifdef ASSIMP_USE_HUNTER
-                const std::string name( currentName->m_id->m_text.m_buffer );
-#else
-                const std::string name( currentName->m_id->m_buffer );
-#endif
-                if( !name.empty() ) {
-                    names.push_back( name );
-                }
-            }
-        }
-    }
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::handleObjectRefNode( DDLNode *node, aiScene * /*pScene*/ ) {
-    if( nullptr == m_currentNode ) {
-        throw DeadlyImportError( "No parent node for name." );
-        return;
-    }
-
-    std::vector<std::string> objRefNames;
-    getRefNames( node, objRefNames );
-
-    // when we are dealing with a geometry node prepare the mesh cache
-    if ( m_tokenType == Grammar::GeometryNodeToken ) {
-        m_currentNode->mNumMeshes = static_cast<unsigned int>(objRefNames.size());
-        m_currentNode->mMeshes = new unsigned int[ objRefNames.size() ];
-        if ( !objRefNames.empty() ) {
-            m_unresolvedRefStack.push_back( std::unique_ptr<RefInfo>( new RefInfo( m_currentNode, RefInfo::MeshRef, objRefNames ) ) );
-        }
-    } else if ( m_tokenType == Grammar::LightNodeToken ) {
-        // TODO!
-    } else if ( m_tokenType == Grammar::CameraNodeToken ) {
-        // TODO!
-    }
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::handleMaterialRefNode( ODDLParser::DDLNode *node, aiScene * /*pScene*/ ) {
-    if( nullptr == m_currentNode ) {
-        throw DeadlyImportError( "No parent node for name." );
-        return;
-    }
-
-    std::vector<std::string> matRefNames;
-    getRefNames( node, matRefNames );
-    if( !matRefNames.empty() ) {
-        m_unresolvedRefStack.push_back( std::unique_ptr<RefInfo>( new RefInfo( m_currentNode, RefInfo::MaterialRef, matRefNames ) ) );
-    }
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::handleGeometryNode( DDLNode *node, aiScene *pScene ) {
-    aiNode *newNode = new aiNode;
-    pushNode( newNode, pScene );
-    m_tokenType = Grammar::GeometryNodeToken;
-    m_currentNode = newNode;
-    handleNodes( node, pScene );
-
-    popNode();
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::handleCameraNode( DDLNode *node, aiScene *pScene ) {
-    aiCamera *camera( new aiCamera );
-    m_cameraCache.push_back( camera );
-    m_currentCamera = camera;
-
-    aiNode *newNode = new aiNode;
-    pushNode( newNode, pScene );
-    m_tokenType = Grammar::CameraNodeToken;
-    m_currentNode = newNode;
-
-    handleNodes( node, pScene );
-
-    popNode();
-
-    m_currentCamera->mName.Set( newNode->mName.C_Str() );
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::handleLightNode( ODDLParser::DDLNode *node, aiScene *pScene ) {
-    aiLight *light( new aiLight );
-    m_lightCache.push_back( light );
-    m_currentLight = light;
-
-    aiNode *newNode = new aiNode;
-    m_tokenType = Grammar::LightNodeToken;
-    m_currentNode = newNode;
-    pushNode( newNode, pScene );
-
-    handleNodes( node, pScene );
-
-    popNode();
-
-    m_currentLight->mName.Set( newNode->mName.C_Str() );
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::handleGeometryObject( DDLNode *node, aiScene *pScene ) {
-    // parameters will be parsed normally in the tree, so just go for it
-    handleNodes( node, pScene );
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::handleCameraObject( ODDLParser::DDLNode *node, aiScene *pScene ) {
-    // parameters will be parsed normally in the tree, so just go for it
-
-    handleNodes( node, pScene );
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::handleLightObject( ODDLParser::DDLNode *node, aiScene *pScene ) {
-    aiLight *light( new aiLight );
-    m_lightCache.push_back( light );
-    std::string objName = node->getName();
-    if ( !objName.empty() ) {
-        light->mName.Set( objName );
-    }
-    m_currentLight = light;
-
-    Property *prop( node->findPropertyByName( "type" ) );
-    if ( nullptr != prop ) {
-        if ( nullptr != prop->m_value ) {
-            std::string typeStr( prop->m_value->getString() );
-            if ( "point" == typeStr ) {
-                m_currentLight->mType = aiLightSource_POINT;
-            } else if ( "spot" == typeStr ) {
-                m_currentLight->mType = aiLightSource_SPOT;
-            } else if ( "infinite" == typeStr ) {
-                m_currentLight->mType = aiLightSource_DIRECTIONAL;
-            }
-        }
-    }
-
-    // parameters will be parsed normally in the tree, so just go for it
-    handleNodes( node, pScene );
-}
-
-//------------------------------------------------------------------------------------------------
-static void setMatrix( aiNode *node, DataArrayList *transformData ) {
-    ai_assert( nullptr != node );
-    ai_assert( nullptr != transformData );
-
-    float m[ 16 ];
-    size_t i( 1 );
-    Value *next( transformData->m_dataList->m_next );
-    m[ 0 ] = transformData->m_dataList->getFloat();
-    while(  next != nullptr ) {
-        m[ i ] = next->getFloat();
-        next = next->m_next;
-        i++;
-    }
-
-    ai_assert(i == 16);
-
-    node->mTransformation.a1 = m[ 0 ];
-    node->mTransformation.a2 = m[ 4 ];
-    node->mTransformation.a3 = m[ 8 ];
-    node->mTransformation.a4 = m[ 12 ];
-
-    node->mTransformation.b1 = m[ 1 ];
-    node->mTransformation.b2 = m[ 5 ];
-    node->mTransformation.b3 = m[ 9 ];
-    node->mTransformation.b4 = m[ 13 ];
-
-    node->mTransformation.c1 = m[ 2 ];
-    node->mTransformation.c2 = m[ 6 ];
-    node->mTransformation.c3 = m[ 10 ];
-    node->mTransformation.c4 = m[ 14 ];
-
-    node->mTransformation.d1 = m[ 3 ];
-    node->mTransformation.d2 = m[ 7 ];
-    node->mTransformation.d3 = m[ 11 ];
-    node->mTransformation.d4 = m[ 15 ];
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::handleTransformNode( ODDLParser::DDLNode *node, aiScene * /*pScene*/ ) {
-    if( nullptr == m_currentNode ) {
-        throw DeadlyImportError( "No parent node for name." );
-        return;
-    }
-
-    DataArrayList *transformData( node->getDataArrayList() );
-    if( nullptr != transformData ) {
-        if( transformData->m_numItems != 16 ) {
-            throw DeadlyImportError( "Invalid number of data for transform matrix." );
-            return;
-        }
-        setMatrix( m_currentNode, transformData );
-    }
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::handleMeshNode( ODDLParser::DDLNode *node, aiScene *pScene ) {
-    m_currentMesh = new aiMesh;
-    const size_t meshidx( m_meshCache.size() );
-    // ownership is transferred but a reference remains in m_currentMesh
-    m_meshCache.emplace_back( m_currentMesh );
-
-    Property *prop = node->getProperties();
-    if( nullptr != prop ) {
-        std::string propName, propKey;
-        propId2StdString( prop, propName, propKey );
-        if( "primitive" == propName ) {
-            if ( "points" == propKey ) {
-                m_currentMesh->mPrimitiveTypes |= aiPrimitiveType_POINT;
-            } else if ( "lines" == propKey ) {
-                m_currentMesh->mPrimitiveTypes |= aiPrimitiveType_LINE;
-            } else if( "triangles" == propKey ) {
-                m_currentMesh->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
-            } else if ( "quads" == propKey ) {
-                m_currentMesh->mPrimitiveTypes |= aiPrimitiveType_POLYGON;
-            } else {
-                ASSIMP_LOG_WARN_F( propKey, " is not supported primitive type." );
-            }
-        }
-    }
-
-    handleNodes( node, pScene );
-
-    DDLNode *parent( node->getParent() );
-    if( nullptr != parent ) {
-        const std::string &name = parent->getName();
-        m_mesh2refMap[ name ] = meshidx;
-    }
-}
-
-//------------------------------------------------------------------------------------------------
-enum MeshAttribute {
-    None,
-    Position,
-    Color,
-    Normal,
-    TexCoord
-};
-
-static const std::string PosToken = "position";
-static const std::string ColToken = "color";
-static const std::string NormalToken = "normal";
-static const std::string TexCoordToken = "texcoord";
-
-//------------------------------------------------------------------------------------------------
-static MeshAttribute getAttributeByName( const char *attribName ) {
-    ai_assert( nullptr != attribName  );
-
-    if ( 0 == strncmp( PosToken.c_str(), attribName, PosToken.size() ) ) {
-        return Position;
-    } else if ( 0 == strncmp( ColToken.c_str(), attribName, ColToken.size() ) ) {
-        return Color;
-    } else if( 0 == strncmp( NormalToken.c_str(), attribName, NormalToken.size() ) ) {
-        return Normal;
-    } else if( 0 == strncmp( TexCoordToken.c_str(), attribName, TexCoordToken.size() ) ) {
-        return TexCoord;
-    }
-
-    return None;
-}
-
-//------------------------------------------------------------------------------------------------
-static void fillVector3( aiVector3D *vec3, Value *vals ) {
-    ai_assert( nullptr != vec3 );
-    ai_assert( nullptr != vals );
-
-    float x( 0.0f ), y( 0.0f ), z( 0.0f );
-    Value *next( vals );
-    x = next->getFloat();
-    next = next->m_next;
-    y = next->getFloat();
-    next = next->m_next;
-    if( nullptr != next ) {
-        z = next->getFloat();
-    }
-
-    vec3->Set( x, y, z );
-}
-
-//------------------------------------------------------------------------------------------------
-static void fillColor4( aiColor4D *col4, Value *vals ) {
-    ai_assert( nullptr != col4 );
-    ai_assert( nullptr != vals );
-
-    Value *next( vals );
-    col4->r = next->getFloat();
-    next = next->m_next;
-    if (!next) {
-        throw DeadlyImportError( "OpenGEX: Not enough values to fill 4-element color, only 1" );
-    }
-
-    col4->g = next->getFloat();
-    next = next->m_next;
-    if (!next) {
-        throw DeadlyImportError( "OpenGEX: Not enough values to fill 4-element color, only 2" );
-    }
-
-    col4->b = next->getFloat();
-    next = next->m_next;
-    if (!next) {
-        throw DeadlyImportError( "OpenGEX: Not enough values to fill 4-element color, only 3" );
-    }
-
-    col4->a = next->getFloat();
-}
-
-//------------------------------------------------------------------------------------------------
-static size_t countDataArrayListItems( DataArrayList *vaList ) {
-    size_t numItems( 0 );
-    if( nullptr == vaList ) {
-        return numItems;
-    }
-
-    DataArrayList *next( vaList );
-    while( nullptr != next ) {
-        if( nullptr != vaList->m_dataList ) {
-            numItems++;
-        }
-        next = next->m_next;
-    }
-
-    return numItems;
-}
-
-//------------------------------------------------------------------------------------------------
-static void copyVectorArray( size_t numItems, DataArrayList *vaList, aiVector3D *vectorArray ) {
-    for( size_t i = 0; i < numItems; i++ ) {
-        Value *next( vaList->m_dataList );
-        fillVector3( &vectorArray[ i ], next );
-        vaList = vaList->m_next;
-    }
-}
-
-//------------------------------------------------------------------------------------------------
-static void copyColor4DArray( size_t numItems, DataArrayList *vaList, aiColor4D *colArray ) {
-    for ( size_t i = 0; i < numItems; i++ ) {
-        Value *next( vaList->m_dataList );
-        fillColor4( &colArray[ i ], next );
-    }
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::handleVertexArrayNode( ODDLParser::DDLNode *node, aiScene * /*pScene*/ ) {
-    if( nullptr == node ) {
-        throw DeadlyImportError( "No parent node for name." );
-        return;
-    }
-
-    Property *prop( node->getProperties() );
-    if( nullptr != prop ) {
-        std::string propName, propKey;
-        propId2StdString( prop, propName, propKey );
-        MeshAttribute attribType( getAttributeByName( propKey.c_str() ) );
-        if( None == attribType ) {
-            return;
-        }
-
-        DataArrayList *vaList = node->getDataArrayList();
-        if( nullptr == vaList ) {
-            return;
-        }
-
-        const size_t numItems( countDataArrayListItems( vaList ) );
-
-        if( Position == attribType ) {
-            m_currentVertices.m_vertices.resize( numItems );
-            copyVectorArray( numItems, vaList, m_currentVertices.m_vertices.data() );
-        } else if ( Color == attribType ) {
-            m_currentVertices.m_numColors = numItems;
-            m_currentVertices.m_colors = new aiColor4D[ numItems ];
-            copyColor4DArray( numItems, vaList, m_currentVertices.m_colors );
-        } else if( Normal == attribType ) {
-            m_currentVertices.m_normals.resize( numItems );
-            copyVectorArray( numItems, vaList, m_currentVertices.m_normals.data() );
-        } else if( TexCoord == attribType ) {
-            m_currentVertices.m_numUVComps[ 0 ] = numItems;
-            m_currentVertices.m_textureCoords[ 0 ] = new aiVector3D[ numItems ];
-            copyVectorArray( numItems, vaList, m_currentVertices.m_textureCoords[ 0 ] );
-        }
-    }
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::handleIndexArrayNode( ODDLParser::DDLNode *node, aiScene * /*pScene*/ ) {
-    if( nullptr == node ) {
-        throw DeadlyImportError( "No parent node for name." );
-        return;
-    }
-
-    if( nullptr == m_currentMesh ) {
-        throw DeadlyImportError( "No current mesh for index data found." );
-        return;
-    }
-
-    DataArrayList *vaList = node->getDataArrayList();
-    if( nullptr == vaList ) {
-        return;
-    }
-
-    const size_t numItems( countDataArrayListItems( vaList ) );
-    m_currentMesh->mNumFaces = static_cast<unsigned int>(numItems);
-    m_currentMesh->mFaces = new aiFace[ numItems ];
-    m_currentMesh->mNumVertices = static_cast<unsigned int>(numItems * 3);
-    m_currentMesh->mVertices = new aiVector3D[ m_currentMesh->mNumVertices ];
-    bool hasColors( false );
-    if ( m_currentVertices.m_numColors > 0 ) {
-        m_currentMesh->mColors[0] = new aiColor4D[ m_currentVertices.m_numColors ];
-        hasColors = true;
-    }
-    bool hasNormalCoords( false );
-    if ( !m_currentVertices.m_normals.empty() ) {
-        m_currentMesh->mNormals = new aiVector3D[ m_currentMesh->mNumVertices ];
-        hasNormalCoords = true;
-    }
-    bool hasTexCoords( false );
-    if ( m_currentVertices.m_numUVComps[ 0 ] > 0 ) {
-        m_currentMesh->mTextureCoords[ 0 ] = new aiVector3D[ m_currentMesh->mNumVertices ];
-        hasTexCoords = true;
-    }
-
-    unsigned int index( 0 );
-    for( size_t i = 0; i < m_currentMesh->mNumFaces; i++ ) {
-        aiFace &current(  m_currentMesh->mFaces[ i ] );
-        current.mNumIndices = 3;
-        current.mIndices = new unsigned int[ current.mNumIndices ];
-        Value *next( vaList->m_dataList );
-        for( size_t indices = 0; indices < current.mNumIndices; indices++ ) {
-            const int idx( next->getUnsignedInt32() );
-            ai_assert( static_cast<size_t>( idx ) <= m_currentVertices.m_vertices.size() );
-            ai_assert( index < m_currentMesh->mNumVertices );
-            aiVector3D &pos = ( m_currentVertices.m_vertices[ idx ] );
-            m_currentMesh->mVertices[ index ].Set( pos.x, pos.y, pos.z );
-            if ( hasColors ) {
-                aiColor4D &col = m_currentVertices.m_colors[ idx ];
-                m_currentMesh->mColors[ 0 ][ index ] = col;
-            }
-            if ( hasNormalCoords ) {
-                aiVector3D &normal = ( m_currentVertices.m_normals[ idx ] );
-                m_currentMesh->mNormals[ index ].Set( normal.x, normal.y, normal.z );
-            }
-            if ( hasTexCoords ) {
-                aiVector3D &tex = ( m_currentVertices.m_textureCoords[ 0 ][ idx ] );
-                m_currentMesh->mTextureCoords[ 0 ][ index ].Set( tex.x, tex.y, tex.z );
-            }
-            current.mIndices[ indices ] = index;
-            index++;
-
-            next = next->m_next;
-        }
-        vaList = vaList->m_next;
-    }
-}
-
-//------------------------------------------------------------------------------------------------
-static void getColorRGB3( aiColor3D *pColor, DataArrayList *colList ) {
-    if( nullptr == pColor || nullptr == colList ) {
-        return;
-    }
-
-    ai_assert( 3 == colList->m_numItems );
-    Value *val( colList->m_dataList );
-    pColor->r = val->getFloat();
-    val = val->getNext();
-    pColor->g = val->getFloat();
-    val = val->getNext();
-    pColor->b = val->getFloat();
-}
-
-//------------------------------------------------------------------------------------------------
-static void getColorRGB4( aiColor4D *pColor, DataArrayList *colList ) {
-    if ( nullptr == pColor || nullptr == colList ) {
-        return;
-    }
-
-    ai_assert( 4 == colList->m_numItems );
-    Value *val( colList->m_dataList );
-    pColor->r = val->getFloat();
-    val = val->getNext();
-    pColor->g = val->getFloat();
-    val = val->getNext();
-    pColor->b = val->getFloat();
-    val = val->getNext();
-    pColor->a = val->getFloat();
-}
-
-//------------------------------------------------------------------------------------------------
-enum ColorType {
-    NoneColor = 0,
-    DiffuseColor,
-    SpecularColor,
-    EmissionColor,
-    LightColor
-};
-
-//------------------------------------------------------------------------------------------------
-static ColorType getColorType( Text *id ) {
-    if ( nullptr == id ) {
-        return NoneColor;
-    }
-
-    if( *id == Grammar::DiffuseColorToken ) {
-        return DiffuseColor;
-    } else if( *id == Grammar::SpecularColorToken ) {
-        return SpecularColor;
-    } else if( *id == Grammar::EmissionColorToken ) {
-        return EmissionColor;
-    } else if ( *id == "light" ) {
-        return LightColor;
-    }
-
-    return NoneColor;
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::handleMaterialNode( ODDLParser::DDLNode *node, aiScene *pScene ) {
-    m_currentMaterial = new aiMaterial;
-    m_materialCache.push_back( m_currentMaterial );
-    m_tokenType = Grammar::MaterialToken;
-    handleNodes( node, pScene );
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::handleColorNode( ODDLParser::DDLNode *node, aiScene * /*pScene*/ ) {
-    if( nullptr == node ) {
-        return;
-    }
-
-    Property *prop = node->findPropertyByName( "attrib" );
-    if( nullptr != prop ) {
-        if( nullptr != prop->m_value ) {
-            DataArrayList *colList( node->getDataArrayList() );
-            if( nullptr == colList ) {
-                return;
-            }
-            aiColor3D col;
-            if ( 3 == colList->m_numItems ) {
-                aiColor3D col3;
-                getColorRGB3( &col3, colList );
-                col = col3;
-            } else {
-                aiColor4D col4;
-                getColorRGB4( &col4, colList );
-                col.r = col4.r;
-                col.g = col4.g;
-                col.b = col4.b;
-            }
-#ifdef ASSIMP_USE_HUNTER
-            const ColorType colType( getColorType( &prop->m_key->m_text ) );
-#else
-            const ColorType colType( getColorType( prop->m_key ) );
-#endif
-            if( DiffuseColor == colType ) {
-                m_currentMaterial->AddProperty( &col, 1, AI_MATKEY_COLOR_DIFFUSE );
-            } else if( SpecularColor == colType ) {
-                m_currentMaterial->AddProperty( &col, 1, AI_MATKEY_COLOR_SPECULAR );
-            } else if( EmissionColor == colType ) {
-                m_currentMaterial->AddProperty( &col, 1, AI_MATKEY_COLOR_EMISSIVE );
-            } else if ( LightColor == colType ) {
-                m_currentLight->mColorDiffuse = col;
-            }
-        }
-    }
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::handleTextureNode( ODDLParser::DDLNode *node, aiScene * /*pScene*/ ) {
-    if( nullptr == node ) {
-        return;
-    }
-
-    Property *prop = node->findPropertyByName( "attrib" );
-    if( nullptr != prop ) {
-        if( nullptr != prop->m_value ) {
-            Value *val( node->getValue() );
-            if( nullptr != val ) {
-                aiString tex;
-                tex.Set( val->getString() );
-                if( prop->m_value->getString() == Grammar::DiffuseTextureToken ) {
-                    m_currentMaterial->AddProperty( &tex, AI_MATKEY_TEXTURE_DIFFUSE( 0 ) );
-                } else if( prop->m_value->getString() == Grammar::SpecularPowerTextureToken ) {
-                    m_currentMaterial->AddProperty( &tex, AI_MATKEY_TEXTURE_SPECULAR( 0 ) );
-                } else if( prop->m_value->getString() == Grammar::EmissionTextureToken ) {
-                    m_currentMaterial->AddProperty( &tex, AI_MATKEY_TEXTURE_EMISSIVE( 0 ) );
-                } else if( prop->m_value->getString() == Grammar::OpacyTextureToken ) {
-                    m_currentMaterial->AddProperty( &tex, AI_MATKEY_TEXTURE_OPACITY( 0 ) );
-                } else if( prop->m_value->getString() == Grammar::TransparencyTextureToken ) {
-                    // ToDo!
-                    // m_currentMaterial->AddProperty( &tex, AI_MATKEY_TEXTURE_DIFFUSE( 0 ) );
-                } else if( prop->m_value->getString() == Grammar::NormalTextureToken ) {
-                    m_currentMaterial->AddProperty( &tex, AI_MATKEY_TEXTURE_NORMALS( 0 ) );
-                } else {
-                    ai_assert( false );
-                }
-            }
-        }
-    }
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::handleParamNode( ODDLParser::DDLNode *node, aiScene * /*pScene*/ ) {
-    if ( nullptr == node ) {
-        return;
-    }
-
-    Property *prop = node->findPropertyByName( "attrib" );
-    if ( nullptr == prop ) {
-        return;
-    }
-
-    if ( nullptr != prop->m_value ) {
-        Value *val( node->getValue() );
-        if ( nullptr == val ) {
-            return;
-        }
-        const float floatVal( val->getFloat() );
-        if ( 0 == ASSIMP_strincmp( "fov", prop->m_value->getString(), 3 ) ) {
-            m_currentCamera->mHorizontalFOV = floatVal;
-        } else if ( 0 == ASSIMP_strincmp( "near", prop->m_value->getString(), 4 ) ) {
-            m_currentCamera->mClipPlaneNear = floatVal;
-        } else if ( 0 == ASSIMP_strincmp( "far", prop->m_value->getString(), 3 ) ) {
-            m_currentCamera->mClipPlaneFar = floatVal;
-        }
-    }
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::handleAttenNode( ODDLParser::DDLNode *node, aiScene * /*pScene*/ ) {
-    if ( nullptr == node ) {
-        return;
-    }
-
-    Property *prop = node->findPropertyByName( "curve" );
-    if ( nullptr != prop ) {
-        if ( nullptr != prop->m_value ) {
-            Value *val( node->getValue() );
-            const float floatVal( val->getFloat() );
-            if ( 0 == strncmp( "scale", prop->m_value->getString(), strlen( "scale" ) ) ) {
-                m_currentLight->mAttenuationQuadratic = floatVal;
-            }
-        }
-    }
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::copyMeshes( aiScene *pScene ) {
-    ai_assert( nullptr != pScene );
-
-    if( m_meshCache.empty() ) {
-        return;
-    }
-
-    pScene->mNumMeshes = static_cast<unsigned int>(m_meshCache.size());
-    pScene->mMeshes = new aiMesh*[ pScene->mNumMeshes ];
-    for (unsigned int i = 0; i < pScene->mNumMeshes; i++) {
-        pScene->mMeshes[i] = m_meshCache[i].release();
-    }
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::copyCameras( aiScene *pScene ) {
-    ai_assert( nullptr != pScene );
-
-    if ( m_cameraCache.empty() ) {
-        return;
-    }
-
-    pScene->mNumCameras = static_cast<unsigned int>(m_cameraCache.size());
-    pScene->mCameras = new aiCamera*[ pScene->mNumCameras ];
-    std::copy( m_cameraCache.begin(), m_cameraCache.end(), pScene->mCameras );
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::copyLights( aiScene *pScene ) {
-    ai_assert( nullptr != pScene );
-
-    if ( m_lightCache.empty() ) {
-        return;
-    }
-
-    pScene->mNumLights = static_cast<unsigned int>(m_lightCache.size());
-    pScene->mLights = new aiLight*[ pScene->mNumLights ];
-    std::copy( m_lightCache.begin(), m_lightCache.end(), pScene->mLights );
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::copyMaterials( aiScene *pScene ) {
-    ai_assert( nullptr != pScene );
-
-    if ( m_materialCache.empty() ) {
-        return;
-    }
-
-    pScene->mNumMaterials = static_cast<unsigned int>(m_materialCache.size());
-    pScene->mMaterials = new aiMaterial*[ pScene->mNumMaterials ];
-    std::copy( m_materialCache.begin(), m_materialCache.end(), pScene->mMaterials );
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::resolveReferences() {
-    if( m_unresolvedRefStack.empty() ) {
-        return;
-    }
-
-    RefInfo *currentRefInfo( nullptr );
-    for( auto it = m_unresolvedRefStack.begin(); it != m_unresolvedRefStack.end(); ++it ) {
-        currentRefInfo = it->get();
-        if( nullptr != currentRefInfo ) {
-            aiNode *node( currentRefInfo->m_node );
-            if( RefInfo::MeshRef == currentRefInfo->m_type ) {
-                for( size_t i = 0; i < currentRefInfo->m_Names.size(); ++i ) {
-                    const std::string &name( currentRefInfo->m_Names[ i ] );
-                    ReferenceMap::const_iterator it( m_mesh2refMap.find( name ) );
-                    if( m_mesh2refMap.end() != it ) {
-                        unsigned int meshIdx = static_cast<unsigned int>(m_mesh2refMap[ name ]);
-                        node->mMeshes[ i ] = meshIdx;
-                    }
-                }
-            } else if( RefInfo::MaterialRef == currentRefInfo->m_type ) {
-                for ( size_t i = 0; i < currentRefInfo->m_Names.size(); ++i ) {
-                    const std::string name( currentRefInfo->m_Names[ i ] );
-                    ReferenceMap::const_iterator it( m_material2refMap.find( name ) );
-                    if ( m_material2refMap.end() != it ) {
-                        if ( nullptr != m_currentMesh ) {
-                            unsigned int matIdx = static_cast< unsigned int >( m_material2refMap[ name ] );
-                            if ( m_currentMesh->mMaterialIndex != 0 ) {
-                                ASSIMP_LOG_WARN( "Override of material reference in current mesh by material reference." );
-                            }
-                            m_currentMesh->mMaterialIndex = matIdx;
-                        }  else {
-                            ASSIMP_LOG_WARN( "Cannot resolve material reference, because no current mesh is there." );
-                        }
-                    }
-                }
-            } else {
-                throw DeadlyImportError( "Unknown reference info to resolve." );
-            }
-        }
-    }
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::createNodeTree( aiScene *pScene ) {
-    if( nullptr == m_root ) {
-        return;
-    }
-
-    if( m_root->m_children.empty() ) {
-        return;
-    }
-
-    pScene->mRootNode->mNumChildren = static_cast<unsigned int>(m_root->m_children.size());
-    pScene->mRootNode->mChildren = new aiNode*[ pScene->mRootNode->mNumChildren ];
-    std::copy( m_root->m_children.begin(), m_root->m_children.end(), pScene->mRootNode->mChildren );
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::pushNode( aiNode *node, aiScene *pScene ) {
-    ai_assert( nullptr != pScene );
-
-    if ( nullptr == node ) {
-        return;
-    }
-
-    ChildInfo *info( nullptr );
-    if( m_nodeStack.empty() ) {
-        node->mParent = pScene->mRootNode;
-        NodeChildMap::iterator it( m_nodeChildMap.find( node->mParent ) );
-        if( m_nodeChildMap.end() == it ) {
-            info = new ChildInfo;
-            m_root = info;
-            m_nodeChildMap[ node->mParent ] = std::unique_ptr<ChildInfo>(info);
-        } else {
-            info = it->second.get();
-        }
-        info->m_children.push_back( node );
-    } else {
-        aiNode *parent( m_nodeStack.back() );
-        ai_assert( nullptr != parent );
-        node->mParent = parent;
-        NodeChildMap::iterator it( m_nodeChildMap.find( node->mParent ) );
-        if( m_nodeChildMap.end() == it ) {
-            info = new ChildInfo;
-            m_nodeChildMap[ node->mParent ] = std::unique_ptr<ChildInfo>(info);
-        } else {
-            info = it->second.get();
-        }
-        info->m_children.push_back( node );
-    }
-    m_nodeStack.push_back( node );
-}
-
-//------------------------------------------------------------------------------------------------
-aiNode *OpenGEXImporter::popNode() {
-    if( m_nodeStack.empty() ) {
-        return nullptr;
-    }
-
-    aiNode *node( top() );
-    m_nodeStack.pop_back();
-
-    return node;
-}
-
-//------------------------------------------------------------------------------------------------
-aiNode *OpenGEXImporter::top() const {
-    if( m_nodeStack.empty() ) {
-        return nullptr;
-    }
-
-    return m_nodeStack.back();
-}
-
-//------------------------------------------------------------------------------------------------
-void OpenGEXImporter::clearNodeStack() {
-    m_nodeStack.clear();
-}
-
-//------------------------------------------------------------------------------------------------
-
-} // Namespace OpenGEX
-} // Namespace Assimp
-
-#endif // ASSIMP_BUILD_NO_OPENGEX_IMPORTER
diff --git a/Engine/lib/assimp/code/Pbrt/PbrtExporter.cpp b/Engine/lib/assimp/code/Pbrt/PbrtExporter.cpp
new file mode 100644
index 000000000..25061f517
--- /dev/null
+++ b/Engine/lib/assimp/code/Pbrt/PbrtExporter.cpp
@@ -0,0 +1,947 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/* TODO:
+
+Material improvements:
+- don't export embedded textures that we're not going to use
+- diffuse roughness
+- what is with the uv mapping, uv transform not coming through??
+- metal? glass? mirror?  detect these better?
+  - eta/k from RGB?
+- emissive textures: warn at least
+
+Other:
+- use aiProcess_GenUVCoords if needed to handle spherical/planar uv mapping?
+- don't build up a big string in memory but write directly to a file
+- aiProcess_Triangulate meshes to get triangles only?
+- animation (allow specifying a time)
+
+ */
+
+#ifndef ASSIMP_BUILD_NO_EXPORT
+#ifndef ASSIMP_BUILD_NO_PBRT_EXPORTER
+
+#include "PbrtExporter.h"
+
+#include <assimp/version.h>
+#include <assimp/DefaultIOSystem.h>
+#include <assimp/IOSystem.hpp>
+#include <assimp/Exporter.hpp>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/StreamWriter.h>
+#include <assimp/Exceptional.h>
+#include <assimp/material.h>
+#include <assimp/scene.h>
+#include <assimp/mesh.h>
+
+#include <algorithm>
+#include <cctype>
+#include <cmath>
+#include <fstream>
+#include <functional>
+#include <iostream>
+#include <memory>
+#include <sstream>
+#include <string>
+
+#include "stb/stb_image.h"
+
+using namespace Assimp;
+
+namespace Assimp {
+
+void ExportScenePbrt (
+    const char* pFile,
+    IOSystem* pIOSystem,
+    const aiScene* pScene,
+    const ExportProperties* /*pProperties*/
+){
+    std::string path = DefaultIOSystem::absolutePath(std::string(pFile));
+    std::string file = DefaultIOSystem::completeBaseName(std::string(pFile));
+
+    // initialize the exporter
+    PbrtExporter exporter(pScene, pIOSystem, path, file);
+}
+
+} // end of namespace Assimp
+
+// Constructor
+PbrtExporter::PbrtExporter(
+        const aiScene *pScene, IOSystem *pIOSystem,
+        const std::string &path, const std::string &file) :
+        mScene(pScene),
+        mIOSystem(pIOSystem),
+        mPath(path),
+        mFile(file) {
+    // Export embedded textures.
+    if (mScene->mNumTextures > 0)
+        if (!mIOSystem->CreateDirectory("textures"))
+            throw DeadlyExportError("Could not create textures/ directory.");
+    for (unsigned int i = 0; i < mScene->mNumTextures; ++i) {
+        aiTexture* tex = mScene->mTextures[i];
+        std::string fn = CleanTextureFilename(tex->mFilename, false);
+        std::cerr << "Writing embedded texture: " << tex->mFilename.C_Str() << " -> "
+                  << fn << "\n";
+
+        std::unique_ptr<IOStream> outfile(mIOSystem->Open(fn, "wb"));
+        if (!outfile) {
+            throw DeadlyExportError("could not open output texture file: " + fn);
+        }
+        if (tex->mHeight == 0) {
+            // It's binary data
+            outfile->Write(tex->pcData, tex->mWidth, 1);
+        } else {
+            std::cerr << fn << ": TODO handle uncompressed embedded textures.\n";
+        }
+    }
+
+#if 0
+    // Debugging: print the full node hierarchy
+    std::function<void(aiNode*, int)> visitNode;
+    visitNode = [&](aiNode* node, int depth) {
+        for (int i = 0; i < depth; ++i) std::cerr << "    ";
+        std::cerr << node->mName.C_Str() << "\n";
+        for (int i = 0; i < node->mNumChildren; ++i)
+            visitNode(node->mChildren[i], depth + 1);
+    };
+    visitNode(mScene->mRootNode, 0);
+#endif
+
+    mOutput.precision(ASSIMP_AI_REAL_TEXT_PRECISION);
+
+    // Write everything out
+    WriteMetaData();
+    WriteCameras();
+    WriteWorldDefinition();
+
+    // And write the file to disk...
+    std::unique_ptr<IOStream> outfile(mIOSystem->Open(mPath,"wt"));
+    if (!outfile) {
+        throw DeadlyExportError("could not open output .pbrt file: " + std::string(mFile));
+    }
+    outfile->Write(mOutput.str().c_str(), mOutput.str().length(), 1);
+}
+
+// Destructor
+PbrtExporter::~PbrtExporter() {
+    // Empty
+}
+
+void PbrtExporter::WriteMetaData() {
+    mOutput << "#############################\n";
+    mOutput << "# Scene metadata:\n";
+
+    aiMetadata* pMetaData = mScene->mMetaData;
+    for (unsigned int i = 0; i < pMetaData->mNumProperties; i++) {
+        mOutput << "# - ";
+        mOutput << pMetaData->mKeys[i].C_Str() << " :";
+        switch(pMetaData->mValues[i].mType) {
+            case AI_BOOL : {
+                mOutput << " ";
+                if (*static_cast<bool*>(pMetaData->mValues[i].mData))
+                    mOutput << "TRUE\n";
+                else
+                    mOutput << "FALSE\n";
+                break;
+            }
+            case AI_INT32 : {
+                mOutput << " " <<
+                    *static_cast<int32_t*>(pMetaData->mValues[i].mData) <<
+                    std::endl;
+                break;
+            }
+            case AI_UINT64 :
+                mOutput << " " <<
+                    *static_cast<uint64_t*>(pMetaData->mValues[i].mData) <<
+                    std::endl;
+                break;
+            case AI_FLOAT :
+                mOutput << " " <<
+                    *static_cast<float*>(pMetaData->mValues[i].mData) <<
+                    std::endl;
+                break;
+            case AI_DOUBLE :
+                mOutput << " " <<
+                    *static_cast<double*>(pMetaData->mValues[i].mData) <<
+                    std::endl;
+                break;
+            case AI_AISTRING : {
+                aiString* value =
+                    static_cast<aiString*>(pMetaData->mValues[i].mData);
+                std::string svalue = value->C_Str();
+                std::size_t found = svalue.find_first_of('\n');
+                mOutput << "\n";
+                while (found != std::string::npos) {
+                    mOutput << "#     " << svalue.substr(0, found) << "\n";
+                    svalue = svalue.substr(found + 1);
+                    found = svalue.find_first_of('\n');
+                }
+                mOutput << "#     " << svalue << "\n";
+                break;
+            }
+            case AI_AIVECTOR3D :
+                // TODO
+                mOutput << " Vector3D (unable to print)\n";
+                break;
+            default:
+                // AI_META_MAX and FORCE_32BIT
+                mOutput << " META_MAX or FORCE_32Bit (unable to print)\n";
+                break;
+        }
+    }
+}
+
+void PbrtExporter::WriteCameras() {
+    mOutput << "\n";
+    mOutput << "###############################\n";
+    mOutput << "# Cameras (" << mScene->mNumCameras << ") total\n\n";
+
+    if (mScene->mNumCameras == 0) {
+        std::cerr << "Warning: No cameras found in scene file.\n";
+        return;
+    }
+
+    if (mScene->mNumCameras > 1) {
+        std::cerr << "Multiple cameras found in scene file; defaulting to first one specified.\n";
+    }
+
+    for (unsigned int i = 0; i < mScene->mNumCameras; i++) {
+        WriteCamera(i);
+    }
+}
+
+aiMatrix4x4 PbrtExporter::GetNodeTransform(const aiString &name) const {
+    aiMatrix4x4 m;
+    auto node = mScene->mRootNode->FindNode(name);
+    if (!node) {
+        std::cerr << '"' << name.C_Str() << "\": node not found in scene tree.\n";
+        throw DeadlyExportError("Could not find node");
+    }
+    else {
+        while (node) {
+            m = node->mTransformation * m;
+            node = node->mParent;
+        }
+    }
+    return m;
+}
+
+std::string PbrtExporter::TransformAsString(const aiMatrix4x4 &m) {
+    // Transpose on the way out to match pbrt's expected layout (sanity
+    // check: the translation component should be the last 3 entries
+    // before a '1' as the final entry in the matrix, assuming it's
+    // non-projective.)
+    std::stringstream s;
+    s << m.a1 << " " << m.b1 << " " << m.c1 << " " << m.d1 << " "
+      << m.a2 << " " << m.b2 << " " << m.c2 << " " << m.d2 << " "
+      << m.a3 << " " << m.b3 << " " << m.c3 << " " << m.d3 << " "
+      << m.a4 << " " << m.b4 << " " << m.c4 << " " << m.d4;
+    return s.str();
+}
+
+void PbrtExporter::WriteCamera(int i) {
+    auto camera = mScene->mCameras[i];
+    bool cameraActive = i == 0;
+
+    mOutput << "# - Camera " << i+1 <<  ": "
+        << camera->mName.C_Str() << "\n";
+
+    // Get camera aspect ratio
+    float aspect = camera->mAspect;
+    if (aspect == 0) {
+        aspect = 4.f/3.f;
+        mOutput << "#   - Aspect ratio : 1.33333 (no aspect found, defaulting to 4/3)\n";
+    } else {
+        mOutput << "#   - Aspect ratio : " << aspect << "\n";
+    }
+
+    // Get Film xres and yres
+    int xres = 1920;
+    int yres = (int)round(xres/aspect);
+
+    // Print Film for this camera
+    if (!cameraActive)
+        mOutput << "# ";
+    mOutput << "Film \"rgb\" \"string filename\" \"" << mFile << ".exr\"\n";
+    if (!cameraActive)
+        mOutput << "# ";
+    mOutput << "    \"integer xresolution\" [" << xres << "]\n";
+    if (!cameraActive)
+        mOutput << "# ";
+    mOutput << "    \"integer yresolution\" [" << yres << "]\n";
+
+    // Get camera fov
+    float hfov = AI_RAD_TO_DEG(camera->mHorizontalFOV);
+    float fov = (aspect >= 1.0) ? hfov : (hfov * aspect);
+    if (fov < 5) {
+        std::cerr << fov << ": suspiciously low field of view specified by camera. Setting to 45 degrees.\n";
+        fov = 45;
+    }
+
+    // Get camera transform
+    aiMatrix4x4 worldFromCamera = GetNodeTransform(camera->mName);
+
+    // Print Camera LookAt
+    auto position = worldFromCamera * camera->mPosition;
+    auto lookAt = worldFromCamera * (camera->mPosition + camera->mLookAt);
+    aiMatrix3x3 worldFromCamera3(worldFromCamera);
+    auto up = worldFromCamera3 * camera->mUp;
+    up.Normalize();
+
+    if (!cameraActive)
+        mOutput << "# ";
+    mOutput << "Scale -1 1 1\n";  // right handed -> left handed
+    if (!cameraActive)
+        mOutput << "# ";
+    mOutput << "LookAt "
+        << position.x << " " << position.y << " " << position.z << "\n";
+    if (!cameraActive)
+        mOutput << "# ";
+    mOutput << "       "
+        << lookAt.x << " " << lookAt.y << " " << lookAt.z << "\n";
+    if (!cameraActive)
+        mOutput << "# ";
+    mOutput << "       "
+        << up.x << " " << up.y << " " << up.z << "\n";
+
+    // Print camera descriptor
+    if (!cameraActive)
+        mOutput << "# ";
+    mOutput << "Camera \"perspective\" \"float fov\" " << "[" << fov << "]\n\n";
+}
+
+void PbrtExporter::WriteWorldDefinition() {
+    // Figure out which meshes are referenced multiple times; those will be
+    // emitted as object instances and the rest will be emitted directly.
+    std::map<int, int> meshUses;
+    std::function<void(aiNode*)> visitNode;
+    visitNode = [&](aiNode* node) {
+        for (unsigned int i = 0; i < node->mNumMeshes; ++i)
+            ++meshUses[node->mMeshes[i]];
+        for (unsigned int i = 0; i < node->mNumChildren; ++i)
+            visitNode(node->mChildren[i]);
+    };
+    visitNode(mScene->mRootNode);
+    int nInstanced = 0, nUnused = 0;
+    for (const auto &u : meshUses) {
+        if (u.second == 0) ++nUnused;
+        else if (u.second > 1) ++nInstanced;
+    }
+    std::cerr << nInstanced << " / " << mScene->mNumMeshes << " meshes instanced.\n";
+    if (nUnused)
+        std::cerr << nUnused << " meshes defined but not used in scene.\n";
+
+    mOutput << "WorldBegin\n";
+
+    WriteLights();
+    WriteTextures();
+    WriteMaterials();
+
+    // Object instance definitions
+    mOutput << "# Object instance definitions\n\n";
+    for (const auto &mu : meshUses) {
+        if (mu.second > 1) {
+            WriteInstanceDefinition(mu.first);
+        }
+    }
+
+    mOutput << "# Geometry\n\n";
+    aiMatrix4x4 worldFromObject;
+    WriteGeometricObjects(mScene->mRootNode, worldFromObject, meshUses);
+}
+
+void PbrtExporter::WriteTextures() {
+    mOutput << "###################\n";
+    mOutput << "# Textures\n\n";
+
+    C_STRUCT aiString path;
+    aiTextureMapping mapping;
+    unsigned int uvIndex;
+    ai_real blend;
+    aiTextureOp op;
+    aiTextureMapMode mapMode[3];
+
+    // For every material in the scene,
+    for (unsigned int m = 0 ; m < mScene->mNumMaterials; m++) {
+        auto material = mScene->mMaterials[m];
+        // Parse through all texture types,
+        for (int tt = 1; tt <= aiTextureType_UNKNOWN; tt++) {
+            int ttCount = material->GetTextureCount(aiTextureType(tt));
+            // ... and get every texture
+            for (int t = 0; t < ttCount; t++) {
+                // TODO write out texture specifics
+                // TODO UV transforms may be material specific
+                //        so those may need to be baked into unique tex name
+                if (material->GetTexture(aiTextureType(tt), t, &path, &mapping,
+                                         &uvIndex, &blend, &op, mapMode) != AI_SUCCESS) {
+                    std::cerr << "Error getting texture! " << m << " " << tt << " " << t << "\n";
+                    continue;
+                }
+
+                std::string filename = CleanTextureFilename(path);
+
+                if (uvIndex != 0)
+                    std::cerr << "Warning: texture \"" << filename << "\" uses uv set #" <<
+                        uvIndex << " but the pbrt converter only exports uv set 0.\n";
+#if 0
+                if (op != aiTextureOp_Multiply)
+                    std::cerr << "Warning: unexpected texture op " << (int)op <<
+                        " encountered for texture \"" <<
+                        filename << "\". The resulting scene may have issues...\n";
+                if (blend != 1)
+                    std::cerr << "Blend value of " << blend << " found for texture \"" << filename
+                              << "\" but not handled in converter.\n";
+#endif
+
+                std::string mappingString;
+#if 0
+                if (mapMode[0] != mapMode[1])
+                    std::cerr << "Different texture boundary mode for u and v for texture \"" <<
+                        filename << "\". Using u for both.\n";
+                switch (mapMode[0]) {
+                case aiTextureMapMode_Wrap:
+                    // pbrt's default
+                    break;
+                case aiTextureMapMode_Clamp:
+                    mappingString = "\"string wrap\" \"clamp\"";
+                    break;
+                case aiTextureMapMode_Decal:
+                    std::cerr << "Decal texture boundary mode not supported by pbrt for texture \"" <<
+                        filename << "\"\n";
+                    break;
+                case aiTextureMapMode_Mirror:
+                    std::cerr << "Mirror texture boundary mode not supported by pbrt for texture \"" <<
+                        filename << "\"\n";
+                    break;
+                default:
+                    std::cerr << "Unexpected map mode " << (int)mapMode[0] << " for texture \"" <<
+                        filename << "\"\n";
+                    //throw DeadlyExportError("Unexpected aiTextureMapMode");
+                }
+#endif
+
+#if 0
+                aiUVTransform uvTransform;
+                if (material->Get(AI_MATKEY_TEXTURE(tt, t), uvTransform) == AI_SUCCESS) {
+                    mOutput << "# UV transform " << uvTransform.mTranslation.x << " "
+                            << uvTransform.mTranslation.y << " " << uvTransform.mScaling.x << " "
+                            << uvTransform.mScaling.y << " " << uvTransform.mRotation << "\n";
+                }
+#endif
+
+                std::string texName, texType, texOptions;
+                if (aiTextureType(tt) == aiTextureType_SHININESS ||
+                    aiTextureType(tt) == aiTextureType_OPACITY ||
+                    aiTextureType(tt) == aiTextureType_HEIGHT ||
+                    aiTextureType(tt) == aiTextureType_DISPLACEMENT ||
+                    aiTextureType(tt) == aiTextureType_METALNESS ||
+                    aiTextureType(tt) == aiTextureType_DIFFUSE_ROUGHNESS) {
+                    texType = "float";
+                    texName = std::string("float:") + RemoveSuffix(filename);
+
+                    if (aiTextureType(tt) == aiTextureType_SHININESS) {
+                        texOptions = "    \"bool invert\" true\n";
+                        texName += "_Roughness";
+                    }
+                } else if (aiTextureType(tt) == aiTextureType_DIFFUSE ||
+                           aiTextureType(tt) == aiTextureType_BASE_COLOR) {
+                    texType = "spectrum";
+                    texName = std::string("rgb:") + RemoveSuffix(filename);
+                }
+
+                // Don't export textures we're not actually going to use...
+                if (texName.empty())
+                    continue;
+
+                if (mTextureSet.find(texName) == mTextureSet.end()) {
+                    mOutput << "Texture \"" << texName << "\" \"" << texType << "\" \"imagemap\"\n"
+                            << texOptions
+                            << "    \"string filename\" \"" << filename << "\" " << mappingString << '\n';
+                    mTextureSet.insert(texName);
+                }
+
+                // Also emit a float version for use with alpha testing...
+                if ((aiTextureType(tt) == aiTextureType_DIFFUSE ||
+                     aiTextureType(tt) == aiTextureType_BASE_COLOR) &&
+                    TextureHasAlphaMask(filename)) {
+                    texType = "float";
+                    texName = std::string("alpha:") + filename;
+                    if (mTextureSet.find(texName) == mTextureSet.end()) {
+                        mOutput << "Texture \"" << texName << "\" \"" << texType << "\" \"imagemap\"\n"
+                                << "    \"string filename\" \"" << filename << "\" " << mappingString << '\n';
+                        mTextureSet.insert(texName);
+                    }
+                }
+            }
+        }
+    }
+}
+
+bool PbrtExporter::TextureHasAlphaMask(const std::string &filename) {
+    // TODO: STBIDEF int      stbi_info               (char const *filename,     int *x, int *y, int *comp);
+    // quick return if it's 3
+
+    int xSize, ySize, nComponents;
+    unsigned char *data = stbi_load(filename.c_str(), &xSize, &ySize, &nComponents, 0);
+    if (!data) {
+        std::cerr << filename << ": unable to load texture and check for alpha mask in texture. "
+        "Geometry will not be alpha masked with this texture.\n";
+        return false;
+    }
+
+    bool hasMask = false;
+    switch (nComponents) {
+    case 1:
+        for (int i = 0; i < xSize * ySize; ++i)
+            if (data[i] != 255) {
+                hasMask = true;
+                break;
+            }
+        break;
+    case 2:
+          for (int y = 0; y < ySize; ++y)
+              for (int x = 0; x < xSize; ++x)
+                  if (data[2 * (x + y * xSize) + 1] != 255) {
+                      hasMask = true;
+                      break;
+                  }
+        break;
+    case 3:
+        break;
+    case 4:
+          for (int y = 0; y < ySize; ++y)
+              for (int x = 0; x < xSize; ++x)
+                  if (data[4 * (x + y * xSize) + 3] != 255) {
+                      hasMask = true;
+                      break;
+                  }
+          break;
+    default:
+        std::cerr << filename << ": unexpected number of image channels, " <<
+            nComponents << ".\n";
+    }
+
+    stbi_image_free(data);
+    return hasMask;
+}
+
+void PbrtExporter::WriteMaterials() {
+    mOutput << "\n";
+    mOutput << "####################\n";
+    mOutput << "# Materials (" << mScene->mNumMaterials << ") total\n\n";
+
+    for (unsigned int i = 0; i < mScene->mNumMaterials; i++) {
+        WriteMaterial(i);
+    }
+    mOutput << "\n\n";
+}
+
+void PbrtExporter::WriteMaterial(int m) {
+    aiMaterial* material = mScene->mMaterials[m];
+
+    // get material name
+    auto materialName = material->GetName();
+    mOutput << std::endl << "# - Material " << m+1 <<  ": " << materialName.C_Str() << "\n";
+
+    // Print out number of properties
+    mOutput << "#   - Number of Material Properties: " << material->mNumProperties << "\n";
+
+    // Print out texture type counts
+    mOutput << "#   - Non-Zero Texture Type Counts: ";
+    for (int i = 1; i <= aiTextureType_UNKNOWN; i++) {
+        int count = material->GetTextureCount(aiTextureType(i));
+        if (count > 0)
+            mOutput << TextureTypeToString(aiTextureType(i)) << ": " <<  count << " ";
+    }
+    mOutput << "\n";
+
+    auto White = [](const aiColor3D &c) { return c.r == 1 && c.g == 1 && c.b == 1; };
+    auto Black = [](const aiColor3D &c) { return c.r == 0 && c.g == 0 && c.b == 0; };
+
+    aiColor3D diffuse, specular, transparency;
+    bool constantDiffuse = (material->Get(AI_MATKEY_COLOR_DIFFUSE, diffuse) == AI_SUCCESS &&
+                            !White(diffuse));
+    bool constantSpecular = (material->Get(AI_MATKEY_COLOR_SPECULAR, specular) == AI_SUCCESS &&
+                             !White(specular));
+    bool constantTransparency = (material->Get(AI_MATKEY_COLOR_TRANSPARENT, transparency) == AI_SUCCESS &&
+                                 !Black(transparency));
+
+    float opacity, shininess, shininessStrength, eta;
+    bool constantOpacity = (material->Get(AI_MATKEY_OPACITY, opacity) == AI_SUCCESS &&
+                            opacity != 0);
+    bool constantShininess = material->Get(AI_MATKEY_SHININESS, shininess) == AI_SUCCESS;
+    bool constantShininessStrength = material->Get(AI_MATKEY_SHININESS_STRENGTH, shininessStrength) == AI_SUCCESS;
+    bool constantEta = (material->Get(AI_MATKEY_REFRACTI, eta) == AI_SUCCESS &&
+                        eta != 1);
+
+    mOutput << "#    - Constants: diffuse " << constantDiffuse << " specular " << constantSpecular <<
+        " transparency " << constantTransparency << " opacity " << constantOpacity <<
+        " shininess " << constantShininess << " shininess strength " << constantShininessStrength <<
+        " eta " << constantEta << "\n";
+
+    aiString roughnessMap;
+    if (material->Get(AI_MATKEY_TEXTURE_SHININESS(0), roughnessMap) == AI_SUCCESS) {
+        std::string roughnessTexture = std::string("float:") +
+            RemoveSuffix(CleanTextureFilename(roughnessMap)) + "_Roughness";
+        mOutput << "MakeNamedMaterial \"" << materialName.C_Str() << "\""
+                << " \"string type\" \"coateddiffuse\"\n"
+                << "    \"texture roughness\" \"" << roughnessTexture << "\"\n";
+    } else if (constantShininess) {
+        // Assume plastic for now at least
+        float roughness = std::max(0.f, 1.f - shininess);
+        mOutput << "MakeNamedMaterial \"" << materialName.C_Str() << "\""
+                << " \"string type\" \"coateddiffuse\"\n"
+                << "    \"float roughness\" " << roughness << "\n";
+    } else
+        // Diffuse
+        mOutput << "MakeNamedMaterial \"" << materialName.C_Str() << "\""
+                << " \"string type\" \"diffuse\"\n";
+
+    aiString diffuseTexture;
+    if (material->Get(AI_MATKEY_TEXTURE_DIFFUSE(0), diffuseTexture) == AI_SUCCESS)
+        mOutput << "    \"texture reflectance\" \"rgb:" << RemoveSuffix(CleanTextureFilename(diffuseTexture)) << "\"\n";
+    else
+        mOutput << "    \"rgb reflectance\" [ " << diffuse.r << " " << diffuse.g <<
+            " " << diffuse.b << " ]\n";
+
+    aiString displacementTexture, normalMap;
+    if (material->Get(AI_MATKEY_TEXTURE_NORMALS(0), displacementTexture) == AI_SUCCESS)
+        mOutput << "    \"string normalmap\" \"" << CleanTextureFilename(displacementTexture) << "\"\n";
+    else if (material->Get(AI_MATKEY_TEXTURE_HEIGHT(0), displacementTexture) == AI_SUCCESS)
+        mOutput << "    \"texture displacement\" \"float:" <<
+            RemoveSuffix(CleanTextureFilename(displacementTexture)) << "\"\n";
+    else if (material->Get(AI_MATKEY_TEXTURE_DISPLACEMENT(0), displacementTexture) == AI_SUCCESS)
+        mOutput << "    \"texture displacement\" \"float:" <<
+            RemoveSuffix(CleanTextureFilename(displacementTexture)) << "\"\n";
+}
+
+std::string PbrtExporter::CleanTextureFilename(const aiString &f, bool rewriteExtension) const {
+    std::string fn = f.C_Str();
+    // Remove directory name
+    size_t offset = fn.find_last_of("/\\");
+    if (offset != std::string::npos) {
+        fn.erase(0, offset + 1);
+    }
+
+    // Expect all textures in textures
+    fn = std::string("textures") + mIOSystem->getOsSeparator() + fn;
+
+    // Rewrite extension for unsupported file formats.
+    if (rewriteExtension) {
+        offset = fn.rfind('.');
+        if (offset != std::string::npos) {
+            std::string extension = fn;
+            extension.erase(0, offset + 1);
+            std::transform(extension.begin(), extension.end(), extension.begin(),
+                           [](unsigned char c) { return (char)std::tolower(c); });
+
+            if (extension != "tga" && extension != "exr" && extension != "png" &&
+                extension != "pfm" && extension != "hdr") {
+                std::string orig = fn;
+                fn.erase(offset + 1);
+                fn += "png";
+
+                // Does it already exist? Warn if not.
+                std::ifstream filestream(fn);
+                if (!filestream.good())
+                    std::cerr << orig << ": must convert this texture to PNG.\n";
+            }
+        }
+    }
+
+    return fn;
+}
+
+std::string PbrtExporter::RemoveSuffix(std::string filename) {
+    size_t offset = filename.rfind('.');
+    if (offset != std::string::npos)
+        filename.erase(offset);
+    return filename;
+}
+
+void PbrtExporter::WriteLights() {
+    mOutput << "\n";
+    mOutput << "#################\n";
+    mOutput << "# Lights\n\n";
+    if (mScene->mNumLights == 0) {
+        // Skip the default light if no cameras and this is flat up geometry
+        if (mScene->mNumCameras > 0) {
+            std::cerr << "No lights specified. Using default infinite light.\n";
+
+            mOutput << "AttributeBegin\n";
+            mOutput << "    # default light\n";
+            mOutput << "    LightSource \"infinite\" \"blackbody L\" [6000 1]\n";
+
+            mOutput << "AttributeEnd\n\n";
+        }
+    } else {
+        for (unsigned int i = 0; i < mScene->mNumLights; ++i) {
+            const aiLight *light = mScene->mLights[i];
+
+            mOutput << "# Light " << light->mName.C_Str() << "\n";
+            mOutput << "AttributeBegin\n";
+
+            aiMatrix4x4 worldFromLight = GetNodeTransform(light->mName);
+            mOutput << "    Transform [ " << TransformAsString(worldFromLight) << " ]\n";
+
+            aiColor3D color = light->mColorDiffuse + light->mColorSpecular;
+            if (light->mAttenuationConstant != 0)
+                color = color * (ai_real)(1. / light->mAttenuationConstant);
+
+            switch (light->mType) {
+            case aiLightSource_DIRECTIONAL: {
+                mOutput << "    LightSource \"distant\"\n";
+                mOutput << "        \"point3 from\" [ " << light->mPosition.x << " " <<
+                    light->mPosition.y << " " << light->mPosition.z << " ]\n";
+                aiVector3D to = light->mPosition + light->mDirection;
+                mOutput << "        \"point3 to\" [ " << to.x << " " << to.y << " " << to.z << " ]\n";
+                mOutput << "        \"rgb L\" [ " << color.r << " " << color.g << " " << color.b << " ]\n";
+                break;
+            } case aiLightSource_POINT:
+                mOutput << "    LightSource \"distant\"\n";
+                mOutput << "        \"point3 from\" [ " << light->mPosition.x << " " <<
+                    light->mPosition.y << " " << light->mPosition.z << " ]\n";
+                mOutput << "        \"rgb L\" [ " << color.r << " " << color.g << " " << color.b << " ]\n";
+                break;
+            case aiLightSource_SPOT: {
+                mOutput << "    LightSource \"spot\"\n";
+                mOutput << "        \"point3 from\" [ " << light->mPosition.x << " " <<
+                    light->mPosition.y << " " << light->mPosition.z << " ]\n";
+                aiVector3D to = light->mPosition + light->mDirection;
+                mOutput << "        \"point3 to\" [ " << to.x << " " << to.y << " " << to.z << " ]\n";
+                mOutput << "        \"rgb L\" [ " << color.r << " " << color.g << " " << color.b << " ]\n";
+                mOutput << "        \"float coneangle\" [ " << AI_RAD_TO_DEG(light->mAngleOuterCone) << " ]\n";
+                mOutput << "        \"float conedeltaangle\" [ " << AI_RAD_TO_DEG(light->mAngleOuterCone -
+                                                                                  light->mAngleInnerCone) << " ]\n";
+                break;
+            } case aiLightSource_AMBIENT:
+                mOutput << "# ignored ambient light source\n";
+                break;
+            case aiLightSource_AREA: {
+                aiVector3D left = light->mDirection ^ light->mUp;
+                // rectangle. center at position, direction is normal vector
+                ai_real dLeft = light->mSize.x / 2, dUp = light->mSize.y / 2;
+                aiVector3D vertices[4] = {
+                     light->mPosition - dLeft * left - dUp * light->mUp,
+                     light->mPosition + dLeft * left - dUp * light->mUp,
+                     light->mPosition - dLeft * left + dUp * light->mUp,
+                     light->mPosition + dLeft * left + dUp * light->mUp };
+                mOutput << "    AreaLightSource \"diffuse\"\n";
+                mOutput << "        \"rgb L\" [ " << color.r << " " << color.g << " " << color.b << " ]\n";
+                mOutput << "    Shape \"bilinearmesh\"\n";
+                mOutput << "        \"point3 p\" [ ";
+                for (int j = 0; j < 4; ++j)
+                    mOutput << vertices[j].x << " " << vertices[j].y << " " << vertices[j].z;
+                mOutput << " ]\n";
+                mOutput << "        \"integer indices\" [ 0 1 2 3 ]\n";
+                break;
+            } default:
+                mOutput << "# ignored undefined light source type\n";
+                break;
+            }
+            mOutput << "AttributeEnd\n\n";
+        }
+    }
+}
+
+void PbrtExporter::WriteMesh(aiMesh* mesh) {
+    mOutput << "# - Mesh: ";
+    if (mesh->mName == aiString(""))
+        mOutput << "<No Name>\n";
+    else
+        mOutput << mesh->mName.C_Str() << "\n";
+
+    mOutput << "AttributeBegin\n";
+    aiMaterial* material = mScene->mMaterials[mesh->mMaterialIndex];
+    mOutput << "    NamedMaterial \"" << material->GetName().C_Str() << "\"\n";
+
+    // Handle area lights
+    aiColor3D emission;
+    if (material->Get(AI_MATKEY_COLOR_EMISSIVE, emission) == AI_SUCCESS &&
+        (emission.r > 0 || emission.g > 0 || emission.b > 0))
+        mOutput << "    AreaLightSource \"diffuse\" \"rgb L\" [ " << emission.r <<
+            " " << emission.g << " " << emission.b << " ]\n";
+
+    // Check if any types other than tri
+    if (   (mesh->mPrimitiveTypes & aiPrimitiveType_POINT)
+        || (mesh->mPrimitiveTypes & aiPrimitiveType_LINE)
+        || (mesh->mPrimitiveTypes & aiPrimitiveType_POLYGON)) {
+        std::cerr << "Error: ignoring point / line / polygon mesh " << mesh->mName.C_Str() << ".\n";
+        return;
+    }
+
+    // Alpha mask
+    std::string alpha;
+    aiString opacityTexture;
+    if (material->Get(AI_MATKEY_TEXTURE_OPACITY(0), opacityTexture) == AI_SUCCESS ||
+        material->Get(AI_MATKEY_TEXTURE_DIFFUSE(0), opacityTexture) == AI_SUCCESS) {
+        // material->Get(AI_MATKEY_TEXTURE_BASE_COLOR(0), opacityTexture) == AI_SUCCESS)
+        std::string texName = std::string("alpha:") + CleanTextureFilename(opacityTexture);
+        if (mTextureSet.find(texName) != mTextureSet.end())
+            alpha = std::string("    \"texture alpha\" \"") + texName + "\"\n";
+    } else {
+        float opacity = 1;
+        if (material->Get(AI_MATKEY_OPACITY, opacity) == AI_SUCCESS && opacity < 1)
+            alpha = std::string("    \"float alpha\" [ ") + std::to_string(opacity) + " ]\n";
+    }
+
+    // Output the shape specification
+    mOutput << "Shape \"trianglemesh\"\n" <<
+        alpha <<
+        "    \"integer indices\" [";
+
+    // Start with faces (which hold indices)
+    for (unsigned int i = 0; i < mesh->mNumFaces; i++) {
+        auto face = mesh->mFaces[i];
+        if (face.mNumIndices != 3) throw DeadlyExportError("oh no not a tri!");
+
+        for (unsigned int j = 0; j < face.mNumIndices; j++) {
+            mOutput << face.mIndices[j] << " ";
+        }
+        if ((i % 7) == 6) mOutput << "\n    ";
+    }
+    mOutput << "]\n";
+
+    // Then go to vertices
+    mOutput << "    \"point3 P\" [";
+    for (unsigned int i = 0; i < mesh->mNumVertices; i++) {
+        auto vector = mesh->mVertices[i];
+        mOutput << vector.x << " " << vector.y << " " << vector.z << "  ";
+        if ((i % 4) == 3) mOutput << "\n    ";
+    }
+    mOutput << "]\n";
+
+    // Normals (if present)
+    if (mesh->mNormals) {
+        mOutput << "    \"normal N\" [";
+        for (unsigned int i = 0; i < mesh->mNumVertices; i++) {
+            auto normal = mesh->mNormals[i];
+            mOutput << normal.x << " " << normal.y << " " << normal.z << "  ";
+            if ((i % 4) == 3) mOutput << "\n    ";
+        }
+        mOutput << "]\n";
+    }
+
+    // Tangents (if present)
+    if (mesh->mTangents) {
+        mOutput << "    \"vector3 S\" [";
+        for (unsigned int i = 0; i < mesh->mNumVertices; i++) {
+            auto tangent = mesh->mTangents[i];
+            mOutput << tangent.x << " " << tangent.y << " " << tangent.z << "  ";
+            if ((i % 4) == 3) mOutput << "\n    ";
+        }
+        mOutput << "]\n";
+    }
+
+    // Texture Coords (if present)
+    // Find the first set of 2D texture coordinates..
+    for (int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
+        if (mesh->mNumUVComponents[i] == 2) {
+            // assert(mesh->mTextureCoords[i] != nullptr);
+            aiVector3D* uv = mesh->mTextureCoords[i];
+            mOutput << "    \"point2 uv\" [";
+            for (unsigned int j = 0; j < mesh->mNumVertices; ++j) {
+                mOutput << uv[j].x << " " << uv[j].y << " ";
+                if ((j % 6) == 5) mOutput << "\n    ";
+            }
+            mOutput << "]\n";
+            break;
+        }
+    }
+    // TODO: issue warning if there are additional UV sets?
+
+    mOutput << "AttributeEnd\n";
+}
+
+void PbrtExporter::WriteInstanceDefinition(int i) {
+    aiMesh* mesh = mScene->mMeshes[i];
+
+    mOutput << "ObjectBegin \"";
+    if (mesh->mName == aiString(""))
+        mOutput << "mesh_" << i+1 << "\"\n";
+    else
+        mOutput << mesh->mName.C_Str() << "_" << i+1 << "\"\n";
+
+    WriteMesh(mesh);
+
+    mOutput << "ObjectEnd\n";
+}
+
+void PbrtExporter::WriteGeometricObjects(aiNode* node, aiMatrix4x4 worldFromObject,
+                                         std::map<int, int> &meshUses) {
+    // Sometimes interior nodes have degenerate matrices??
+    if (node->mTransformation.Determinant() != 0)
+        worldFromObject = worldFromObject * node->mTransformation;
+
+    if (node->mNumMeshes > 0) {
+        mOutput << "AttributeBegin\n";
+
+        mOutput << "  Transform [ " << TransformAsString(worldFromObject) << "]\n";
+
+        for (unsigned int i = 0; i < node->mNumMeshes; i++) {
+            aiMesh* mesh = mScene->mMeshes[node->mMeshes[i]];
+            if (meshUses[node->mMeshes[i]] == 1) {
+                // If it's only used once in the scene, emit it directly as
+                // a triangle mesh.
+                mOutput << "  # " << mesh->mName.C_Str();
+                WriteMesh(mesh);
+            } else {
+                // If it's used multiple times, there will be an object
+                // instance for it, so emit a reference to that.
+                mOutput << "  ObjectInstance \"";
+                if (mesh->mName == aiString(""))
+                    mOutput << "mesh_" << node->mMeshes[i] + 1 << "\"\n";
+                else
+                    mOutput << mesh->mName.C_Str() << "_" << node->mMeshes[i] + 1 << "\"\n";
+            }
+        }
+        mOutput << "AttributeEnd\n\n";
+    }
+
+    // Recurse through children
+    for (unsigned int i = 0; i < node->mNumChildren; i++) {
+        WriteGeometricObjects(node->mChildren[i], worldFromObject, meshUses);
+    }
+}
+
+#endif // ASSIMP_BUILD_NO_PBRT_EXPORTER
+#endif // ASSIMP_BUILD_NO_EXPORT
diff --git a/Engine/lib/assimp/code/Pbrt/PbrtExporter.h b/Engine/lib/assimp/code/Pbrt/PbrtExporter.h
new file mode 100644
index 000000000..4f4e1625d
--- /dev/null
+++ b/Engine/lib/assimp/code/Pbrt/PbrtExporter.h
@@ -0,0 +1,135 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file PbrtExporter.h
+* Declares the exporter class to write a scene to a pbrt file
+*/
+#ifndef AI_PBRTEXPORTER_H_INC
+#define AI_PBRTEXPORTER_H_INC
+
+#ifndef ASSIMP_BUILD_NO_PBRT_EXPORTER
+
+#include <assimp/types.h>
+#include <assimp/StreamWriter.h>
+#include <assimp/Exceptional.h>
+
+#include <map>
+#include <set>
+#include <string>
+#include <sstream>
+
+struct aiScene;
+struct aiNode;
+struct aiMaterial;
+struct aiMesh;
+
+namespace Assimp {
+
+class IOSystem;
+class IOStream;
+class ExportProperties;
+
+// ---------------------------------------------------------------------
+/** Helper class to export a given scene to a Pbrt file. */
+// ---------------------------------------------------------------------
+class PbrtExporter
+{
+public:
+    /// Constructor for a specific scene to export
+    PbrtExporter(const aiScene *pScene, IOSystem *pIOSystem,
+            const std::string &path, const std::string &file);
+
+    /// Destructor
+    virtual ~PbrtExporter();
+
+private:
+    // the scene to export
+    const aiScene* mScene;
+
+    /// Stringstream to write all output into
+    std::stringstream mOutput;
+
+    /// The IOSystem for output
+    IOSystem* mIOSystem;
+
+    /// Path of the directory where the scene will be exported
+    const std::string mPath;
+
+    /// Name of the file (without extension) where the scene will be exported
+    const std::string mFile;
+
+private:
+    //  A private set to keep track of which textures have been declared
+    std::set<std::string> mTextureSet;
+
+    aiMatrix4x4 GetNodeTransform(const aiString& name) const;
+    static std::string TransformAsString(const aiMatrix4x4& m);
+
+    static std::string RemoveSuffix(std::string filename);
+    std::string CleanTextureFilename(const aiString &f, bool rewriteExtension = true) const;
+
+    void WriteMetaData();
+
+    void WriteWorldDefinition();
+
+    void WriteCameras();
+    void WriteCamera(int i);
+
+    void WriteLights();
+
+    void WriteTextures();
+    static bool TextureHasAlphaMask(const std::string &filename);
+
+    void WriteMaterials();
+    void WriteMaterial(int i);
+
+    void WriteMesh(aiMesh* mesh);
+
+    void WriteInstanceDefinition(int i);
+    void WriteGeometricObjects(aiNode* node, aiMatrix4x4 parentTransform,
+                               std::map<int, int> &meshUses);
+};
+
+} // namespace Assimp
+
+#endif // ASSIMP_BUILD_NO_PBRT_EXPORTER
+
+#endif // AI_PBRTEXPORTER_H_INC
diff --git a/Engine/lib/assimp/code/Ply/PlyParser.cpp b/Engine/lib/assimp/code/Ply/PlyParser.cpp
deleted file mode 100644
index 2a6f00ad6..000000000
--- a/Engine/lib/assimp/code/Ply/PlyParser.cpp
+++ /dev/null
@@ -1,1142 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-/** @file Implementation of the PLY parser class */
-
-
-#ifndef ASSIMP_BUILD_NO_PLY_IMPORTER
-
-#include <assimp/fast_atof.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/ByteSwapper.h>
-#include "PlyLoader.h"
-
-using namespace Assimp;
-
-// ------------------------------------------------------------------------------------------------
-PLY::EDataType PLY::Property::ParseDataType(std::vector<char> &buffer) {
-  ai_assert(!buffer.empty());
-
-  PLY::EDataType eOut = PLY::EDT_INVALID;
-
-  if (PLY::DOM::TokenMatch(buffer, "char", 4) ||
-    PLY::DOM::TokenMatch(buffer, "int8", 4))
-  {
-    eOut = PLY::EDT_Char;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "uchar", 5) ||
-    PLY::DOM::TokenMatch(buffer, "uint8", 5))
-  {
-    eOut = PLY::EDT_UChar;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "short", 5) ||
-    PLY::DOM::TokenMatch(buffer, "int16", 5))
-  {
-    eOut = PLY::EDT_Short;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "ushort", 6) ||
-    PLY::DOM::TokenMatch(buffer, "uint16", 6))
-  {
-    eOut = PLY::EDT_UShort;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "int32", 5) || PLY::DOM::TokenMatch(buffer, "int", 3))
-  {
-    eOut = PLY::EDT_Int;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "uint32", 6) || PLY::DOM::TokenMatch(buffer, "uint", 4))
-  {
-    eOut = PLY::EDT_UInt;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "float", 5) || PLY::DOM::TokenMatch(buffer, "float32", 7))
-  {
-    eOut = PLY::EDT_Float;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "double64", 8) || PLY::DOM::TokenMatch(buffer, "double", 6) ||
-    PLY::DOM::TokenMatch(buffer, "float64", 7))
-  {
-    eOut = PLY::EDT_Double;
-  }
-  if (PLY::EDT_INVALID == eOut)
-  {
-      ASSIMP_LOG_INFO("Found unknown data type in PLY file. This is OK");
-  }
-
-  return eOut;
-}
-
-// ------------------------------------------------------------------------------------------------
-PLY::ESemantic PLY::Property::ParseSemantic(std::vector<char> &buffer) {
-  ai_assert(!buffer.empty());
-
-  PLY::ESemantic eOut = PLY::EST_INVALID;
-  if (PLY::DOM::TokenMatch(buffer, "red", 3)) {
-    eOut = PLY::EST_Red;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "green", 5)) {
-    eOut = PLY::EST_Green;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "blue", 4)) {
-    eOut = PLY::EST_Blue;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "alpha", 5)) {
-    eOut = PLY::EST_Alpha;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "vertex_index", 12) || PLY::DOM::TokenMatch(buffer, "vertex_indices", 14)) {
-    eOut = PLY::EST_VertexIndex;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "texcoord", 8)) // Manage uv coords on faces
-  {
-    eOut = PLY::EST_TextureCoordinates;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "material_index", 14))
-  {
-    eOut = PLY::EST_MaterialIndex;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "ambient_red", 11))
-  {
-    eOut = PLY::EST_AmbientRed;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "ambient_green", 13))
-  {
-    eOut = PLY::EST_AmbientGreen;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "ambient_blue", 12))
-  {
-    eOut = PLY::EST_AmbientBlue;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "ambient_alpha", 13))
-  {
-    eOut = PLY::EST_AmbientAlpha;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "diffuse_red", 11))
-  {
-    eOut = PLY::EST_DiffuseRed;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "diffuse_green", 13))
-  {
-    eOut = PLY::EST_DiffuseGreen;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "diffuse_blue", 12))
-  {
-    eOut = PLY::EST_DiffuseBlue;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "diffuse_alpha", 13))
-  {
-    eOut = PLY::EST_DiffuseAlpha;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "specular_red", 12))
-  {
-    eOut = PLY::EST_SpecularRed;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "specular_green", 14))
-  {
-    eOut = PLY::EST_SpecularGreen;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "specular_blue", 13))
-  {
-    eOut = PLY::EST_SpecularBlue;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "specular_alpha", 14))
-  {
-    eOut = PLY::EST_SpecularAlpha;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "opacity", 7))
-  {
-    eOut = PLY::EST_Opacity;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "specular_power", 14))
-  {
-    eOut = PLY::EST_PhongPower;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "r", 1))
-  {
-    eOut = PLY::EST_Red;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "g", 1))
-  {
-    eOut = PLY::EST_Green;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "b", 1))
-  {
-    eOut = PLY::EST_Blue;
-  }
-
-  // NOTE: Blender3D exports texture coordinates as s,t tuples
-  else if (PLY::DOM::TokenMatch(buffer, "u", 1) || PLY::DOM::TokenMatch(buffer, "s", 1) || PLY::DOM::TokenMatch(buffer, "tx", 2) || PLY::DOM::TokenMatch(buffer, "texture_u", 9))
-  {
-    eOut = PLY::EST_UTextureCoord;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "v", 1) || PLY::DOM::TokenMatch(buffer, "t", 1) || PLY::DOM::TokenMatch(buffer, "ty", 2) || PLY::DOM::TokenMatch(buffer, "texture_v", 9))
-  {
-    eOut = PLY::EST_VTextureCoord;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "x", 1))
-  {
-    eOut = PLY::EST_XCoord;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "y", 1)) {
-    eOut = PLY::EST_YCoord;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "z", 1)) {
-    eOut = PLY::EST_ZCoord;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "nx", 2)) {
-    eOut = PLY::EST_XNormal;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "ny", 2)) {
-    eOut = PLY::EST_YNormal;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "nz", 2)) {
-    eOut = PLY::EST_ZNormal;
-  }
-  else {
-      ASSIMP_LOG_INFO("Found unknown property semantic in file. This is ok");
-    PLY::DOM::SkipLine(buffer);
-  }
-  return eOut;
-}
-
-// ------------------------------------------------------------------------------------------------
-bool PLY::Property::ParseProperty(std::vector<char> &buffer, PLY::Property* pOut)
-{
-  ai_assert(!buffer.empty());
-
-  // Forms supported:
-  // "property float x"
-  // "property list uchar int vertex_index"
-
-  // skip leading spaces
-  if (!PLY::DOM::SkipSpaces(buffer)) {
-    return false;
-  }
-
-  // skip the "property" string at the beginning
-  if (!PLY::DOM::TokenMatch(buffer, "property", 8))
-  {
-    // seems not to be a valid property entry
-    return false;
-  }
-  // get next word
-  if (!PLY::DOM::SkipSpaces(buffer)) {
-    return false;
-  }
-  if (PLY::DOM::TokenMatch(buffer, "list", 4))
-  {
-    pOut->bIsList = true;
-
-    // seems to be a list.
-    if (EDT_INVALID == (pOut->eFirstType = PLY::Property::ParseDataType(buffer)))
-    {
-      // unable to parse list size data type
-      PLY::DOM::SkipLine(buffer);
-      return false;
-    }
-    if (!PLY::DOM::SkipSpaces(buffer))return false;
-    if (EDT_INVALID == (pOut->eType = PLY::Property::ParseDataType(buffer)))
-    {
-      // unable to parse list data type
-      PLY::DOM::SkipLine(buffer);
-      return false;
-    }
-  }
-  else
-  {
-    if (EDT_INVALID == (pOut->eType = PLY::Property::ParseDataType(buffer)))
-    {
-      // unable to parse data type. Skip the property
-      PLY::DOM::SkipLine(buffer);
-      return false;
-    }
-  }
-
-  if (!PLY::DOM::SkipSpaces(buffer))
-    return false;
-
-  pOut->Semantic = PLY::Property::ParseSemantic(buffer);
-
-  if (PLY::EST_INVALID == pOut->Semantic)
-  {
-    ASSIMP_LOG_INFO("Found unknown semantic in PLY file. This is OK");
-    std::string(&buffer[0], &buffer[0] + strlen(&buffer[0]));
-  }
-
-  PLY::DOM::SkipSpacesAndLineEnd(buffer);
-  return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-PLY::EElementSemantic PLY::Element::ParseSemantic(std::vector<char> &buffer)
-{
-  ai_assert(!buffer.empty());
-
-  PLY::EElementSemantic eOut = PLY::EEST_INVALID;
-  if (PLY::DOM::TokenMatch(buffer, "vertex", 6))
-  {
-    eOut = PLY::EEST_Vertex;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "face", 4))
-  {
-    eOut = PLY::EEST_Face;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "tristrips", 9))
-  {
-    eOut = PLY::EEST_TriStrip;
-  }
-#if 0
-  // TODO: maybe implement this?
-  else if (PLY::DOM::TokenMatch(buffer,"range_grid",10))
-  {
-    eOut = PLY::EEST_Face;
-  }
-#endif
-  else if (PLY::DOM::TokenMatch(buffer, "edge", 4))
-  {
-    eOut = PLY::EEST_Edge;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "material", 8))
-  {
-    eOut = PLY::EEST_Material;
-  }
-  else if (PLY::DOM::TokenMatch(buffer, "TextureFile", 11))
-  {
-    eOut = PLY::EEST_TextureFile;
-  }
-
-  return eOut;
-}
-
-// ------------------------------------------------------------------------------------------------
-bool PLY::Element::ParseElement(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer, PLY::Element* pOut)
-{
-  ai_assert(NULL != pOut);
-  // Example format: "element vertex 8"
-
-  // skip leading spaces
-  if (!PLY::DOM::SkipSpaces(buffer))
-  {
-    return false;
-  }
-
-  // skip the "element" string at the beginning
-  if (!PLY::DOM::TokenMatch(buffer, "element", 7) && !PLY::DOM::TokenMatch(buffer, "comment", 7))
-  {
-    // seems not to be a valid property entry
-    return false;
-  }
-  // get next word
-  if (!PLY::DOM::SkipSpaces(buffer))
-    return false;
-
-  // parse the semantic of the element
-  pOut->eSemantic = PLY::Element::ParseSemantic(buffer);
-  if (PLY::EEST_INVALID == pOut->eSemantic)
-  {
-    // if the exact semantic can't be determined, just store
-    // the original string identifier
-    pOut->szName = std::string(&buffer[0], &buffer[0] + strlen(&buffer[0]));
-  }
-
-  if (!PLY::DOM::SkipSpaces(buffer))
-    return false;
-
-  if (PLY::EEST_TextureFile == pOut->eSemantic)
-  {
-    char* endPos = &buffer[0] + (strlen(&buffer[0]) - 1);
-    pOut->szName = std::string(&buffer[0], endPos);
-
-    // go to the next line
-    PLY::DOM::SkipSpacesAndLineEnd(buffer);
-
-    return true;
-  }
-
-  //parse the number of occurrences of this element
-  const char* pCur = (char*)&buffer[0];
-  pOut->NumOccur = strtoul10(pCur, &pCur);
-
-  // go to the next line
-  PLY::DOM::SkipSpacesAndLineEnd(buffer);
-
-  // now parse all properties of the element
-  while (true)
-  {
-    streamBuffer.getNextLine(buffer);
-    pCur = (char*)&buffer[0];
-
-    // skip all comments
-    PLY::DOM::SkipComments(buffer);
-
-    PLY::Property prop;
-    if (!PLY::Property::ParseProperty(buffer, &prop))
-      break;
-
-    pOut->alProperties.push_back(prop);
-  }
-
-  return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-bool PLY::DOM::SkipSpaces(std::vector<char> &buffer)
-{
-  const char* pCur = buffer.empty() ? NULL : (char*)&buffer[0];
-  bool ret = false;
-  if (pCur)
-  {
-    const char* szCur = pCur;
-    ret = Assimp::SkipSpaces(pCur, &pCur);
-
-    uintptr_t iDiff = (uintptr_t)pCur - (uintptr_t)szCur;
-    buffer.erase(buffer.begin(), buffer.begin() + iDiff);
-    return ret;
-  }
-
-  return ret;
-}
-
-bool PLY::DOM::SkipLine(std::vector<char> &buffer)
-{
-  const char* pCur = buffer.empty() ? NULL : (char*)&buffer[0];
-  bool ret = false;
-  if (pCur)
-  {
-    const char* szCur = pCur;
-    ret = Assimp::SkipLine(pCur, &pCur);
-
-    uintptr_t iDiff = (uintptr_t)pCur - (uintptr_t)szCur;
-    buffer.erase(buffer.begin(), buffer.begin() + iDiff);
-    return ret;
-  }
-
-  return ret;
-}
-
-bool PLY::DOM::TokenMatch(std::vector<char> &buffer, const char* token, unsigned int len)
-{
-  const char* pCur = buffer.empty() ? NULL : (char*)&buffer[0];
-  bool ret = false;
-  if (pCur)
-  {
-    const char* szCur = pCur;
-    ret = Assimp::TokenMatch(pCur, token, len);
-
-    uintptr_t iDiff = (uintptr_t)pCur - (uintptr_t)szCur;
-    buffer.erase(buffer.begin(), buffer.begin() + iDiff);
-    return ret;
-  }
-
-  return ret;
-}
-
-bool PLY::DOM::SkipSpacesAndLineEnd(std::vector<char> &buffer)
-{
-  const char* pCur = buffer.empty() ? NULL : (char*)&buffer[0];
-  bool ret = false;
-  if (pCur)
-  {
-    const char* szCur = pCur;
-    ret = Assimp::SkipSpacesAndLineEnd(pCur, &pCur);
-
-    uintptr_t iDiff = (uintptr_t)pCur - (uintptr_t)szCur;
-    buffer.erase(buffer.begin(), buffer.begin() + iDiff);
-    return ret;
-  }
-
-  return ret;
-}
-
-bool PLY::DOM::SkipComments(std::vector<char> &buffer)
-{
-  ai_assert(!buffer.empty());
-
-  std::vector<char> nbuffer = buffer;
-  // skip spaces
-  if (!SkipSpaces(nbuffer)) {
-    return false;
-  }
-
-  if (TokenMatch(nbuffer, "comment", 7))
-  {
-    if (!SkipSpaces(nbuffer))
-      SkipLine(nbuffer);
-
-    if (!TokenMatch(nbuffer, "TextureFile", 11))
-    {
-      SkipLine(nbuffer);
-      buffer = nbuffer;
-      return true;
-    }
-
-    return true;
-  }
-
-  return false;
-}
-
-// ------------------------------------------------------------------------------------------------
-bool PLY::DOM::ParseHeader(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer, bool isBinary) {
-    ASSIMP_LOG_DEBUG("PLY::DOM::ParseHeader() begin");
-
-  // parse all elements
-  while (!buffer.empty())
-  {
-    // skip all comments
-    PLY::DOM::SkipComments(buffer);
-
-    PLY::Element out;
-    if (PLY::Element::ParseElement(streamBuffer, buffer, &out))
-    {
-      // add the element to the list of elements
-      alElements.push_back(out);
-    }
-    else if (TokenMatch(buffer, "end_header", 10))
-    {
-      // we have reached the end of the header
-      break;
-    }
-    else
-    {
-      // ignore unknown header elements
-      streamBuffer.getNextLine(buffer);
-    }
-  }
-
-  if (!isBinary) // it would occur an error, if binary data start with values as space or line end.
-    SkipSpacesAndLineEnd(buffer);
-
-  ASSIMP_LOG_DEBUG("PLY::DOM::ParseHeader() succeeded");
-  return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-bool PLY::DOM::ParseElementInstanceLists(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer, PLYImporter* loader)
-{
-    ASSIMP_LOG_DEBUG("PLY::DOM::ParseElementInstanceLists() begin");
-  alElementData.resize(alElements.size());
-
-  std::vector<PLY::Element>::const_iterator i = alElements.begin();
-  std::vector<PLY::ElementInstanceList>::iterator a = alElementData.begin();
-
-  // parse all element instances
-  //construct vertices and faces
-  for (; i != alElements.end(); ++i, ++a)
-  {
-    if ((*i).eSemantic == EEST_Vertex || (*i).eSemantic == EEST_Face || (*i).eSemantic == EEST_TriStrip)
-    {
-      PLY::ElementInstanceList::ParseInstanceList(streamBuffer, buffer, &(*i), NULL, loader);
-    }
-    else
-    {
-      (*a).alInstances.resize((*i).NumOccur);
-      PLY::ElementInstanceList::ParseInstanceList(streamBuffer, buffer, &(*i), &(*a), NULL);
-    }
-  }
-
-  ASSIMP_LOG_DEBUG("PLY::DOM::ParseElementInstanceLists() succeeded");
-  return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-bool PLY::DOM::ParseElementInstanceListsBinary(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer,
-    const char* &pCur,
-    unsigned int &bufferSize,
-    PLYImporter* loader,
-    bool p_bBE)
-{
-    ASSIMP_LOG_DEBUG("PLY::DOM::ParseElementInstanceListsBinary() begin");
-  alElementData.resize(alElements.size());
-
-  std::vector<PLY::Element>::const_iterator i = alElements.begin();
-  std::vector<PLY::ElementInstanceList>::iterator a = alElementData.begin();
-
-  // parse all element instances
-  for (; i != alElements.end(); ++i, ++a)
-  {
-    if ((*i).eSemantic == EEST_Vertex || (*i).eSemantic == EEST_Face || (*i).eSemantic == EEST_TriStrip)
-    {
-      PLY::ElementInstanceList::ParseInstanceListBinary(streamBuffer, buffer, pCur, bufferSize, &(*i), NULL, loader, p_bBE);
-    }
-    else
-    {
-      (*a).alInstances.resize((*i).NumOccur);
-      PLY::ElementInstanceList::ParseInstanceListBinary(streamBuffer, buffer, pCur, bufferSize, &(*i), &(*a), NULL, p_bBE);
-    }
-  }
-
-  ASSIMP_LOG_DEBUG("PLY::DOM::ParseElementInstanceListsBinary() succeeded");
-  return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-bool PLY::DOM::ParseInstanceBinary(IOStreamBuffer<char> &streamBuffer, DOM* p_pcOut, PLYImporter* loader, bool p_bBE)
-{
-  ai_assert(NULL != p_pcOut);
-  ai_assert(NULL != loader);
-
-  std::vector<char> buffer;
-  streamBuffer.getNextLine(buffer);
-
-  ASSIMP_LOG_DEBUG("PLY::DOM::ParseInstanceBinary() begin");
-
-  if (!p_pcOut->ParseHeader(streamBuffer, buffer, true))
-  {
-      ASSIMP_LOG_DEBUG("PLY::DOM::ParseInstanceBinary() failure");
-    return false;
-  }
-
-  streamBuffer.getNextBlock(buffer);
-  unsigned int bufferSize = static_cast<unsigned int>(buffer.size());
-  const char* pCur = (char*)&buffer[0];
-  if (!p_pcOut->ParseElementInstanceListsBinary(streamBuffer, buffer, pCur, bufferSize, loader, p_bBE))
-  {
-      ASSIMP_LOG_DEBUG("PLY::DOM::ParseInstanceBinary() failure");
-    return false;
-  }
-  ASSIMP_LOG_DEBUG("PLY::DOM::ParseInstanceBinary() succeeded");
-  return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-bool PLY::DOM::ParseInstance(IOStreamBuffer<char> &streamBuffer, DOM* p_pcOut, PLYImporter* loader)
-{
-  ai_assert(NULL != p_pcOut);
-  ai_assert(NULL != loader);
-
-  std::vector<char> buffer;
-  streamBuffer.getNextLine(buffer);
-
-  ASSIMP_LOG_DEBUG("PLY::DOM::ParseInstance() begin");
-
-  if (!p_pcOut->ParseHeader(streamBuffer, buffer, false))
-  {
-      ASSIMP_LOG_DEBUG("PLY::DOM::ParseInstance() failure");
-    return false;
-  }
-
-  //get next line after header
-  streamBuffer.getNextLine(buffer);
-  if (!p_pcOut->ParseElementInstanceLists(streamBuffer, buffer, loader))
-  {
-      ASSIMP_LOG_DEBUG("PLY::DOM::ParseInstance() failure");
-    return false;
-  }
-  ASSIMP_LOG_DEBUG("PLY::DOM::ParseInstance() succeeded");
-  return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-bool PLY::ElementInstanceList::ParseInstanceList(
-  IOStreamBuffer<char> &streamBuffer,
-  std::vector<char> &buffer,
-  const PLY::Element* pcElement,
-  PLY::ElementInstanceList* p_pcOut,
-  PLYImporter* loader)
-{
-  ai_assert(NULL != pcElement);
-
-  // parse all elements
-  if (EEST_INVALID == pcElement->eSemantic || pcElement->alProperties.empty())
-  {
-    // if the element has an unknown semantic we can skip all lines
-    // However, there could be comments
-    for (unsigned int i = 0; i < pcElement->NumOccur; ++i)
-    {
-      PLY::DOM::SkipComments(buffer);
-      PLY::DOM::SkipLine(buffer);
-      streamBuffer.getNextLine(buffer);
-    }
-  }
-  else
-  {
-    const char* pCur = (const char*)&buffer[0];
-    // be sure to have enough storage
-    for (unsigned int i = 0; i < pcElement->NumOccur; ++i)
-    {
-      if (p_pcOut)
-        PLY::ElementInstance::ParseInstance(pCur, pcElement, &p_pcOut->alInstances[i]);
-      else
-      {
-        ElementInstance elt;
-        PLY::ElementInstance::ParseInstance(pCur, pcElement, &elt);
-
-        // Create vertex or face
-        if (pcElement->eSemantic == EEST_Vertex)
-        {
-          //call loader instance from here
-          loader->LoadVertex(pcElement, &elt, i);
-        }
-        else if (pcElement->eSemantic == EEST_Face)
-        {
-          //call loader instance from here
-          loader->LoadFace(pcElement, &elt, i);
-        }
-        else if (pcElement->eSemantic == EEST_TriStrip)
-        {
-          //call loader instance from here
-          loader->LoadFace(pcElement, &elt, i);
-        }
-      }
-
-      streamBuffer.getNextLine(buffer);
-      pCur = (buffer.empty()) ? NULL : (const char*)&buffer[0];
-    }
-  }
-  return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-bool PLY::ElementInstanceList::ParseInstanceListBinary(
-  IOStreamBuffer<char> &streamBuffer,
-  std::vector<char> &buffer,
-  const char* &pCur,
-  unsigned int &bufferSize,
-  const PLY::Element* pcElement,
-  PLY::ElementInstanceList* p_pcOut,
-  PLYImporter* loader,
-  bool p_bBE /* = false */)
-{
-  ai_assert(NULL != pcElement);
-
-  // we can add special handling code for unknown element semantics since
-  // we can't skip it as a whole block (we don't know its exact size
-  // due to the fact that lists could be contained in the property list
-  // of the unknown element)
-  for (unsigned int i = 0; i < pcElement->NumOccur; ++i)
-  {
-    if (p_pcOut)
-      PLY::ElementInstance::ParseInstanceBinary(streamBuffer, buffer, pCur, bufferSize, pcElement, &p_pcOut->alInstances[i], p_bBE);
-    else
-    {
-      ElementInstance elt;
-      PLY::ElementInstance::ParseInstanceBinary(streamBuffer, buffer, pCur, bufferSize, pcElement, &elt, p_bBE);
-
-      // Create vertex or face
-      if (pcElement->eSemantic == EEST_Vertex)
-      {
-        //call loader instance from here
-        loader->LoadVertex(pcElement, &elt, i);
-      }
-      else if (pcElement->eSemantic == EEST_Face)
-      {
-        //call loader instance from here
-        loader->LoadFace(pcElement, &elt, i);
-      }
-      else if (pcElement->eSemantic == EEST_TriStrip)
-      {
-        //call loader instance from here
-        loader->LoadFace(pcElement, &elt, i);
-      }
-    }
-  }
-  return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-bool PLY::ElementInstance::ParseInstance(const char* &pCur,
-  const PLY::Element* pcElement,
-  PLY::ElementInstance* p_pcOut)
-{
-  ai_assert(NULL != pcElement);
-  ai_assert(NULL != p_pcOut);
-
-  // allocate enough storage
-  p_pcOut->alProperties.resize(pcElement->alProperties.size());
-
-  std::vector<PLY::PropertyInstance>::iterator i = p_pcOut->alProperties.begin();
-  std::vector<PLY::Property>::const_iterator  a = pcElement->alProperties.begin();
-  for (; i != p_pcOut->alProperties.end(); ++i, ++a)
-  {
-    if (!(PLY::PropertyInstance::ParseInstance(pCur, &(*a), &(*i))))
-    {
-        ASSIMP_LOG_WARN("Unable to parse property instance. "
-        "Skipping this element instance");
-
-      PLY::PropertyInstance::ValueUnion v = PLY::PropertyInstance::DefaultValue((*a).eType);
-      (*i).avList.push_back(v);
-    }
-  }
-  return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-bool PLY::ElementInstance::ParseInstanceBinary(
-  IOStreamBuffer<char> &streamBuffer,
-  std::vector<char> &buffer,
-  const char* &pCur,
-  unsigned int &bufferSize,
-  const PLY::Element* pcElement,
-  PLY::ElementInstance* p_pcOut,
-  bool p_bBE /* = false */)
-{
-  ai_assert(NULL != pcElement);
-  ai_assert(NULL != p_pcOut);
-
-  // allocate enough storage
-  p_pcOut->alProperties.resize(pcElement->alProperties.size());
-
-  std::vector<PLY::PropertyInstance>::iterator i = p_pcOut->alProperties.begin();
-  std::vector<PLY::Property>::const_iterator   a = pcElement->alProperties.begin();
-  for (; i != p_pcOut->alProperties.end(); ++i, ++a)
-  {
-    if (!(PLY::PropertyInstance::ParseInstanceBinary(streamBuffer, buffer, pCur, bufferSize, &(*a), &(*i), p_bBE)))
-    {
-        ASSIMP_LOG_WARN("Unable to parse binary property instance. "
-        "Skipping this element instance");
-
-      (*i).avList.push_back(PLY::PropertyInstance::DefaultValue((*a).eType));
-    }
-  }
-  return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-bool PLY::PropertyInstance::ParseInstance(const char* &pCur,
-  const PLY::Property* prop, PLY::PropertyInstance* p_pcOut)
-{
-  ai_assert(NULL != prop);
-  ai_assert(NULL != p_pcOut);
-
-  // skip spaces at the beginning
-  if (!SkipSpaces(&pCur))
-  {
-    return false;
-  }
-
-  if (prop->bIsList)
-  {
-    // parse the number of elements in the list
-    PLY::PropertyInstance::ValueUnion v;
-    PLY::PropertyInstance::ParseValue(pCur, prop->eFirstType, &v);
-
-    // convert to unsigned int
-    unsigned int iNum = PLY::PropertyInstance::ConvertTo<unsigned int>(v, prop->eFirstType);
-
-    // parse all list elements
-    p_pcOut->avList.resize(iNum);
-    for (unsigned int i = 0; i < iNum; ++i)
-    {
-      if (!SkipSpaces(&pCur))
-        return false;
-
-      PLY::PropertyInstance::ParseValue(pCur, prop->eType, &p_pcOut->avList[i]);
-    }
-  }
-  else
-  {
-    // parse the property
-    PLY::PropertyInstance::ValueUnion v;
-
-    PLY::PropertyInstance::ParseValue(pCur, prop->eType, &v);
-    p_pcOut->avList.push_back(v);
-  }
-  SkipSpacesAndLineEnd(&pCur);
-  return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-bool PLY::PropertyInstance::ParseInstanceBinary(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer,
-  const char* &pCur,
-  unsigned int &bufferSize,
-  const PLY::Property* prop,
-  PLY::PropertyInstance* p_pcOut,
-  bool p_bBE)
-{
-  ai_assert(NULL != prop);
-  ai_assert(NULL != p_pcOut);
-
-  // parse all elements
-  if (prop->bIsList)
-  {
-    // parse the number of elements in the list
-    PLY::PropertyInstance::ValueUnion v;
-    PLY::PropertyInstance::ParseValueBinary(streamBuffer, buffer, pCur, bufferSize, prop->eFirstType, &v, p_bBE);
-
-    // convert to unsigned int
-    unsigned int iNum = PLY::PropertyInstance::ConvertTo<unsigned int>(v, prop->eFirstType);
-
-    // parse all list elements
-    p_pcOut->avList.resize(iNum);
-    for (unsigned int i = 0; i < iNum; ++i)
-    {
-      PLY::PropertyInstance::ParseValueBinary(streamBuffer, buffer, pCur, bufferSize, prop->eType, &p_pcOut->avList[i], p_bBE);
-    }
-  }
-  else
-  {
-    // parse the property
-    PLY::PropertyInstance::ValueUnion v;
-    PLY::PropertyInstance::ParseValueBinary(streamBuffer, buffer, pCur, bufferSize, prop->eType, &v, p_bBE);
-    p_pcOut->avList.push_back(v);
-  }
-  return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-PLY::PropertyInstance::ValueUnion PLY::PropertyInstance::DefaultValue(PLY::EDataType eType)
-{
-  PLY::PropertyInstance::ValueUnion out;
-
-  switch (eType)
-  {
-  case EDT_Float:
-    out.fFloat = 0.f;
-    return out;
-
-  case EDT_Double:
-    out.fDouble = 0.;
-    return out;
-
-  default:;
-  };
-  out.iUInt = 0;
-  return out;
-}
-
-// ------------------------------------------------------------------------------------------------
-bool PLY::PropertyInstance::ParseValue(const char* &pCur,
-  PLY::EDataType eType,
-  PLY::PropertyInstance::ValueUnion* out)
-{
-  ai_assert(NULL != pCur);
-  ai_assert(NULL != out);
-
-  //calc element size
-  bool ret = true;
-  switch (eType)
-  {
-  case EDT_UInt:
-  case EDT_UShort:
-  case EDT_UChar:
-
-    out->iUInt = (uint32_t)strtoul10(pCur, &pCur);
-    break;
-
-  case EDT_Int:
-  case EDT_Short:
-  case EDT_Char:
-
-    out->iInt = (int32_t)strtol10(pCur, &pCur);
-    break;
-
-  case EDT_Float:
-    // technically this should cast to float, but people tend to use float descriptors for double data
-    // this is the best way to not risk losing precision on import and it doesn't hurt to do this
-    ai_real f;
-    pCur = fast_atoreal_move<ai_real>(pCur, f);
-    out->fFloat = (ai_real)f;
-    break;
-
-  case EDT_Double:
-    double d;
-    pCur = fast_atoreal_move<double>(pCur, d);
-    out->fDouble = (double)d;
-    break;
-
-  case EDT_INVALID:
-  default:
-    ret = false;
-    break;
-  }
-
-  return ret;
-}
-
-// ------------------------------------------------------------------------------------------------
-bool PLY::PropertyInstance::ParseValueBinary(IOStreamBuffer<char> &streamBuffer,
-  std::vector<char> &buffer,
-  const char* &pCur,
-  unsigned int &bufferSize,
-  PLY::EDataType eType,
-  PLY::PropertyInstance::ValueUnion* out,
-  bool p_bBE)
-{
-  ai_assert(NULL != out);
-
-  //calc element size
-  unsigned int lsize = 0;
-  switch (eType)
-  {
-  case EDT_Char:
-  case EDT_UChar:
-    lsize = 1;
-    break;
-
-  case EDT_UShort:
-  case EDT_Short:
-    lsize = 2;
-    break;
-
-  case EDT_UInt:
-  case EDT_Int:
-  case EDT_Float:
-    lsize = 4;
-    break;
-
-  case EDT_Double:
-    lsize = 8;
-    break;
-
-  case EDT_INVALID:
-  default:
-      break;
-  }
-
-  //read the next file block if needed
-  if (bufferSize < lsize)
-  {
-    std::vector<char> nbuffer;
-    if (streamBuffer.getNextBlock(nbuffer))
-    {
-      //concat buffer contents
-      buffer = std::vector<char>(buffer.end() - bufferSize, buffer.end());
-      buffer.insert(buffer.end(), nbuffer.begin(), nbuffer.end());
-      nbuffer.clear();
-      bufferSize = static_cast<unsigned int>(buffer.size());
-      pCur = (char*)&buffer[0];
-    }
-    else
-    {
-      throw DeadlyImportError("Invalid .ply file: File corrupted");
-    }
-  }
-
-  bool ret = true;
-  switch (eType)
-  {
-  case EDT_UInt:
-  {
-    uint32_t t;
-    memcpy(&t, pCur, sizeof(uint32_t));
-    pCur += sizeof(uint32_t);
-
-    // Swap endianness
-    if (p_bBE)ByteSwap::Swap(&t);
-    out->iUInt = t;
-    break;
-  }
-
-  case EDT_UShort:
-  {
-    uint16_t t;
-    memcpy(&t, pCur, sizeof(uint16_t));
-    pCur += sizeof(uint16_t);
-
-    // Swap endianness
-    if (p_bBE)ByteSwap::Swap(&t);
-    out->iUInt = t;
-    break;
-  }
-
-  case EDT_UChar:
-  {
-    uint8_t t;
-    memcpy(&t, pCur, sizeof(uint8_t));
-    pCur += sizeof(uint8_t);
-    out->iUInt = t;
-    break;
-  }
-
-  case EDT_Int:
-  {
-    int32_t t;
-    memcpy(&t, pCur, sizeof(int32_t));
-    pCur += sizeof(int32_t);
-
-    // Swap endianness
-    if (p_bBE)ByteSwap::Swap(&t);
-    out->iInt = t;
-    break;
-  }
-
-  case EDT_Short:
-  {
-    int16_t t;
-    memcpy(&t, pCur, sizeof(int16_t));
-    pCur += sizeof(int16_t);
-
-    // Swap endianness
-    if (p_bBE)ByteSwap::Swap(&t);
-    out->iInt = t;
-    break;
-  }
-
-  case EDT_Char:
-  {
-    int8_t t;
-    memcpy(&t, pCur, sizeof(int8_t));
-    pCur += sizeof(int8_t);
-    out->iInt = t;
-    break;
-  }
-
-  case EDT_Float:
-  {
-    float t;
-    memcpy(&t, pCur, sizeof(float));
-    pCur += sizeof(float);
-
-    // Swap endianness
-    if (p_bBE)ByteSwap::Swap(&t);
-    out->fFloat = t;
-    break;
-  }
-  case EDT_Double:
-  {
-    double t;
-    memcpy(&t, pCur, sizeof(double));
-    pCur += sizeof(double);
-
-    // Swap endianness
-    if (p_bBE)ByteSwap::Swap(&t);
-    out->fDouble = t;
-    break;
-  }
-  default:
-    ret = false;
-  }
-
-  bufferSize -= lsize;
-
-  return ret;
-}
-
-#endif // !! ASSIMP_BUILD_NO_PLY_IMPORTER
diff --git a/Engine/lib/assimp/code/PostProcessing/ArmaturePopulate.cpp b/Engine/lib/assimp/code/PostProcessing/ArmaturePopulate.cpp
new file mode 100644
index 000000000..44f1e2e14
--- /dev/null
+++ b/Engine/lib/assimp/code/PostProcessing/ArmaturePopulate.cpp
@@ -0,0 +1,265 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+----------------------------------------------------------------------
+*/
+#include "ArmaturePopulate.h"
+
+#include <assimp/BaseImporter.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/postprocess.h>
+#include <assimp/scene.h>
+#include <iostream>
+
+namespace Assimp {
+
+/// The default class constructor.
+ArmaturePopulate::ArmaturePopulate() :
+        BaseProcess() {
+    // do nothing
+}
+
+/// The class destructor.
+ArmaturePopulate::~ArmaturePopulate() {
+    // do nothing
+}
+
+bool ArmaturePopulate::IsActive(unsigned int pFlags) const {
+    return (pFlags & aiProcess_PopulateArmatureData) != 0;
+}
+
+void ArmaturePopulate::SetupProperties(const Importer *) {
+    // do nothing
+}
+
+void ArmaturePopulate::Execute(aiScene *out) {
+
+    // Now convert all bone positions to the correct mOffsetMatrix
+    std::vector<aiBone *> bones;
+    std::vector<aiNode *> nodes;
+    std::map<aiBone *, aiNode *> bone_stack;
+    BuildBoneList(out->mRootNode, out->mRootNode, out, bones);
+    BuildNodeList(out->mRootNode, nodes);
+
+    BuildBoneStack(out->mRootNode, out->mRootNode, out, bones, bone_stack, nodes);
+
+    ASSIMP_LOG_DEBUG("Bone stack size: ", bone_stack.size());
+
+    for (std::pair<aiBone *, aiNode *> kvp : bone_stack) {
+        aiBone *bone = kvp.first;
+        aiNode *bone_node = kvp.second;
+        ASSIMP_LOG_VERBOSE_DEBUG("active node lookup: ", bone->mName.C_Str());
+        // lcl transform grab - done in generate_nodes :)
+
+        // bone->mOffsetMatrix = bone_node->mTransformation;
+        aiNode *armature = GetArmatureRoot(bone_node, bones);
+
+        ai_assert(armature);
+
+#ifndef ASSIMP_BUILD_NO_ARMATUREPOPULATE_PROCESS
+        // set up bone armature id
+        bone->mArmature = armature;
+
+        // set this bone node to be referenced properly
+        ai_assert(bone_node);
+        bone->mNode = bone_node;
+#endif
+    }
+}
+
+
+// Reprocess all nodes to calculate bone transforms properly based on the REAL
+// mOffsetMatrix not the local.
+// Before this would use mesh transforms which is wrong for bone transforms
+// Before this would work for simple character skeletons but not complex meshes
+// with multiple origins
+// Source: sketch fab log cutter fbx
+void ArmaturePopulate::BuildBoneList(aiNode *current_node,
+                                     const aiNode *root_node,
+                                     const aiScene *scene,
+                                     std::vector<aiBone *> &bones) {
+    ai_assert(scene);
+    for (unsigned int nodeId = 0; nodeId < current_node->mNumChildren; ++nodeId) {
+        aiNode *child = current_node->mChildren[nodeId];
+        ai_assert(child);
+
+        // check for bones
+        for (unsigned int meshId = 0; meshId < child->mNumMeshes; ++meshId) {
+            ai_assert(child->mMeshes);
+            unsigned int mesh_index = child->mMeshes[meshId];
+            aiMesh *mesh = scene->mMeshes[mesh_index];
+            ai_assert(mesh);
+
+            for (unsigned int boneId = 0; boneId < mesh->mNumBones; ++boneId) {
+                aiBone *bone = mesh->mBones[boneId];
+                ai_assert(nullptr != bone);
+
+                // duplicate mehes exist with the same bones sometimes :)
+                // so this must be detected
+                if (std::find(bones.begin(), bones.end(), bone) == bones.end()) {
+                    // add the element once
+                    bones.emplace_back(bone);
+                }
+            }
+
+            // find mesh and get bones
+            // then do recursive lookup for bones in root node hierarchy
+        }
+
+        BuildBoneList(child, root_node, scene, bones);
+    }
+}
+
+// Prepare flat node list which can be used for non recursive lookups later
+void ArmaturePopulate::BuildNodeList(const aiNode *current_node,
+                                     std::vector<aiNode *> &nodes) {
+    ai_assert(nullptr != current_node);
+
+    for (unsigned int nodeId = 0; nodeId < current_node->mNumChildren; ++nodeId) {
+        aiNode *child = current_node->mChildren[nodeId];
+        ai_assert(child);
+
+        if (child->mNumMeshes == 0) {
+            nodes.emplace_back(child);
+        }
+
+        BuildNodeList(child, nodes);
+  }
+}
+
+// A bone stack allows us to have multiple armatures, with the same bone names
+// A bone stack allows us also to retrieve bones true transform even with
+// duplicate names :)
+void ArmaturePopulate::BuildBoneStack(aiNode *,
+                                      const aiNode *root_node,
+                                      const aiScene*,
+                                      const std::vector<aiBone *> &bones,
+                                      std::map<aiBone *, aiNode *> &bone_stack,
+                                  std::vector<aiNode *> &node_stack) {
+    if (node_stack.empty()) {
+        return;
+    }
+    ai_assert(nullptr != root_node);
+
+    for (aiBone *bone : bones) {
+        ai_assert(bone);
+        aiNode *node = GetNodeFromStack(bone->mName, node_stack);
+        if (node == nullptr) {
+            node_stack.clear();
+            BuildNodeList(root_node, node_stack);
+            ASSIMP_LOG_VERBOSE_DEBUG("Resetting bone stack: nullptr element ", bone->mName.C_Str());
+
+            node = GetNodeFromStack(bone->mName, node_stack);
+
+            if (nullptr == node) {
+                ASSIMP_LOG_ERROR("serious import issue node for bone was not detected");
+                continue;
+            }
+        }
+
+        ASSIMP_LOG_VERBOSE_DEBUG("Successfully added bone[", bone->mName.C_Str(), "] to stack and bone node is: ", node->mName.C_Str());
+
+        bone_stack.insert(std::pair<aiBone *, aiNode *>(bone, node));
+    }
+}
+
+// Returns the armature root node
+// This is required to be detected for a bone initially, it will recurse up
+// until it cannot find another bone and return the node No known failure
+// points. (yet)
+aiNode *ArmaturePopulate::GetArmatureRoot(aiNode *bone_node,
+                                          std::vector<aiBone *> &bone_list) {
+    while (nullptr != bone_node) {
+        if (!IsBoneNode(bone_node->mName, bone_list)) {
+            ASSIMP_LOG_VERBOSE_DEBUG("GetArmatureRoot() Found valid armature: ", bone_node->mName.C_Str());
+            return bone_node;
+        }
+
+        bone_node = bone_node->mParent;
+    }
+
+    ASSIMP_LOG_ERROR("GetArmatureRoot() can't find armature!");
+
+    return nullptr;
+}
+
+// Simple IsBoneNode check if this could be a bone
+bool ArmaturePopulate::IsBoneNode(const aiString &bone_name,
+                                  std::vector<aiBone *> &bones) {
+    for (aiBone *bone : bones) {
+        if (bone->mName == bone_name) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+// Pop this node by name from the stack if found
+// Used in multiple armature situations with duplicate node / bone names
+// Known flaw: cannot have nodes with bone names, will be fixed in later release
+// (serious to be fixed) Known flaw: nodes which have more than one bone could
+// be prematurely dropped from stack
+aiNode *ArmaturePopulate::GetNodeFromStack(const aiString &node_name,
+                                           std::vector<aiNode *> &nodes) {
+    std::vector<aiNode *>::iterator iter;
+    aiNode *found = nullptr;
+    for (iter = nodes.begin(); iter < nodes.end(); ++iter) {
+        aiNode *element = *iter;
+        ai_assert(nullptr != element);
+        // node valid and node name matches
+        if (element->mName == node_name) {
+            found = element;
+            break;
+        }
+    }
+
+    if (found != nullptr) {
+        ASSIMP_LOG_INFO("Removed node from stack: ", found->mName.C_Str());
+        // now pop the element from the node list
+        nodes.erase(iter);
+
+        return found;
+    }
+
+    // unique names can cause this problem
+    ASSIMP_LOG_ERROR("[Serious] GetNodeFromStack() can't find node from stack!");
+
+    return nullptr;
+}
+
+} // Namespace Assimp
diff --git a/Engine/lib/assimp/code/PostProcessing/ArmaturePopulate.h b/Engine/lib/assimp/code/PostProcessing/ArmaturePopulate.h
new file mode 100644
index 000000000..530932f48
--- /dev/null
+++ b/Engine/lib/assimp/code/PostProcessing/ArmaturePopulate.h
@@ -0,0 +1,112 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+#ifndef ARMATURE_POPULATE_H_
+#define ARMATURE_POPULATE_H_
+
+#include "Common/BaseProcess.h"
+#include <assimp/BaseImporter.h>
+#include <vector>
+#include <map>
+
+
+struct aiNode;
+struct aiBone;
+
+namespace Assimp {
+
+// ---------------------------------------------------------------------------
+/** Armature Populate: This is a post process designed
+ * To save you time when importing models into your game engines
+ * This was originally designed only for fbx but will work with other formats
+ * it is intended to auto populate aiBone data with armature and the aiNode
+ * This is very useful when dealing with skinned meshes
+ * or when dealing with many different skeletons
+ * It's off by default but recommend that you try it and use it
+ * It should reduce down any glue code you have in your
+ * importers
+ * You can contact RevoluPowered <gordon@gordonite.tech>
+ * For more info about this
+*/
+class ASSIMP_API ArmaturePopulate : public BaseProcess {
+public:
+    /// The default class constructor.
+    ArmaturePopulate();
+
+    /// The class destructor.
+    virtual ~ArmaturePopulate();
+
+    /// Overwritten, @see BaseProcess
+    virtual bool IsActive( unsigned int pFlags ) const;
+
+    /// Overwritten, @see BaseProcess
+    virtual void SetupProperties( const Importer* pImp );
+
+    /// Overwritten, @see BaseProcess
+    virtual void Execute( aiScene* pScene );
+
+    static aiNode *GetArmatureRoot(aiNode *bone_node,
+                                      std::vector<aiBone *> &bone_list);
+
+    static bool IsBoneNode(const aiString &bone_name,
+                              std::vector<aiBone *> &bones);
+
+    static aiNode *GetNodeFromStack(const aiString &node_name,
+                                       std::vector<aiNode *> &nodes);
+
+    static void BuildNodeList(const aiNode *current_node,
+                                 std::vector<aiNode *> &nodes);
+
+    static void BuildBoneList(aiNode *current_node, const aiNode *root_node,
+                                 const aiScene *scene,
+                                 std::vector<aiBone *> &bones);
+
+    static void BuildBoneStack(aiNode *current_node, const aiNode *root_node,
+                                  const aiScene *scene,
+                                  const std::vector<aiBone *> &bones,
+                                  std::map<aiBone *, aiNode *> &bone_stack,
+                                  std::vector<aiNode *> &node_stack);
+};
+
+} // Namespace Assimp
+
+
+#endif // SCALE_PROCESS_H_
diff --git a/Engine/lib/assimp/code/PostProcessing/CalcTangentsProcess.cpp b/Engine/lib/assimp/code/PostProcessing/CalcTangentsProcess.cpp
index a3f7dd255..b8847e473 100644
--- a/Engine/lib/assimp/code/PostProcessing/CalcTangentsProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/CalcTangentsProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -55,54 +55,49 @@ using namespace Assimp;
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-CalcTangentsProcess::CalcTangentsProcess()
-: configMaxAngle( AI_DEG_TO_RAD(45.f) )
-, configSourceUV( 0 ) {
+CalcTangentsProcess::CalcTangentsProcess() :
+        configMaxAngle(float(AI_DEG_TO_RAD(45.f))), configSourceUV(0) {
     // nothing to do here
 }
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-CalcTangentsProcess::~CalcTangentsProcess()
-{
+CalcTangentsProcess::~CalcTangentsProcess() {
     // nothing to do here
 }
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the processing step is present in the given flag field.
-bool CalcTangentsProcess::IsActive( unsigned int pFlags) const
-{
+bool CalcTangentsProcess::IsActive(unsigned int pFlags) const {
     return (pFlags & aiProcess_CalcTangentSpace) != 0;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Executes the post processing step on the given imported data.
-void CalcTangentsProcess::SetupProperties(const Importer* pImp)
-{
-    ai_assert( NULL != pImp );
+void CalcTangentsProcess::SetupProperties(const Importer *pImp) {
+    ai_assert(nullptr != pImp);
 
     // get the current value of the property
-    configMaxAngle = pImp->GetPropertyFloat(AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE,45.f);
-    configMaxAngle = std::max(std::min(configMaxAngle,45.0f),0.0f);
+    configMaxAngle = pImp->GetPropertyFloat(AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE, 45.f);
+    configMaxAngle = std::max(std::min(configMaxAngle, 45.0f), 0.0f);
     configMaxAngle = AI_DEG_TO_RAD(configMaxAngle);
 
-    configSourceUV = pImp->GetPropertyInteger(AI_CONFIG_PP_CT_TEXTURE_CHANNEL_INDEX,0);
+    configSourceUV = pImp->GetPropertyInteger(AI_CONFIG_PP_CT_TEXTURE_CHANNEL_INDEX, 0);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Executes the post processing step on the given imported data.
-void CalcTangentsProcess::Execute( aiScene* pScene)
-{
-    ai_assert( NULL != pScene );
+void CalcTangentsProcess::Execute(aiScene *pScene) {
+    ai_assert(nullptr != pScene);
 
     ASSIMP_LOG_DEBUG("CalcTangentsProcess begin");
 
     bool bHas = false;
-    for ( unsigned int a = 0; a < pScene->mNumMeshes; a++ ) {
-        if(ProcessMesh( pScene->mMeshes[a],a))bHas = true;
+    for (unsigned int a = 0; a < pScene->mNumMeshes; a++) {
+        if (ProcessMesh(pScene->mMeshes[a], a)) bHas = true;
     }
 
-    if ( bHas ) {
+    if (bHas) {
         ASSIMP_LOG_INFO("CalcTangentsProcess finished. Tangents have been calculated");
     } else {
         ASSIMP_LOG_DEBUG("CalcTangentsProcess finished");
@@ -111,8 +106,7 @@ void CalcTangentsProcess::Execute( aiScene* pScene)
 
 // ------------------------------------------------------------------------------------------------
 // Calculates tangents and bi-tangents for the given mesh
-bool CalcTangentsProcess::ProcessMesh( aiMesh* pMesh, unsigned int meshIndex)
-{
+bool CalcTangentsProcess::ProcessMesh(aiMesh *pMesh, unsigned int meshIndex) {
     // we assume that the mesh is still in the verbose vertex format where each face has its own set
     // of vertices and no vertices are shared between faces. Sadly I don't know any quick test to
     // assert() it here.
@@ -124,54 +118,48 @@ bool CalcTangentsProcess::ProcessMesh( aiMesh* pMesh, unsigned int meshIndex)
     // If the mesh consists of lines and/or points but not of
     // triangles or higher-order polygons the normal vectors
     // are undefined.
-    if (!(pMesh->mPrimitiveTypes & (aiPrimitiveType_TRIANGLE | aiPrimitiveType_POLYGON)))
-    {
+    if (!(pMesh->mPrimitiveTypes & (aiPrimitiveType_TRIANGLE | aiPrimitiveType_POLYGON))) {
         ASSIMP_LOG_INFO("Tangents are undefined for line and point meshes");
         return false;
     }
 
     // what we can check, though, is if the mesh has normals and texture coordinates. That's a requirement
-    if( pMesh->mNormals == NULL)
-    {
+    if (pMesh->mNormals == nullptr) {
         ASSIMP_LOG_ERROR("Failed to compute tangents; need normals");
         return false;
     }
-    if( configSourceUV >= AI_MAX_NUMBER_OF_TEXTURECOORDS || !pMesh->mTextureCoords[configSourceUV] )
-    {
-        ASSIMP_LOG_ERROR((Formatter::format("Failed to compute tangents; need UV data in channel"),configSourceUV));
+    if (configSourceUV >= AI_MAX_NUMBER_OF_TEXTURECOORDS || !pMesh->mTextureCoords[configSourceUV]) {
+        ASSIMP_LOG_ERROR("Failed to compute tangents; need UV data in channel", configSourceUV);
         return false;
     }
 
     const float angleEpsilon = 0.9999f;
 
-    std::vector<bool> vertexDone( pMesh->mNumVertices, false);
+    std::vector<bool> vertexDone(pMesh->mNumVertices, false);
     const float qnan = get_qnan();
 
     // create space for the tangents and bitangents
     pMesh->mTangents = new aiVector3D[pMesh->mNumVertices];
     pMesh->mBitangents = new aiVector3D[pMesh->mNumVertices];
 
-    const aiVector3D* meshPos = pMesh->mVertices;
-    const aiVector3D* meshNorm = pMesh->mNormals;
-    const aiVector3D* meshTex = pMesh->mTextureCoords[configSourceUV];
-    aiVector3D* meshTang = pMesh->mTangents;
-    aiVector3D* meshBitang = pMesh->mBitangents;
+    const aiVector3D *meshPos = pMesh->mVertices;
+    const aiVector3D *meshNorm = pMesh->mNormals;
+    const aiVector3D *meshTex = pMesh->mTextureCoords[configSourceUV];
+    aiVector3D *meshTang = pMesh->mTangents;
+    aiVector3D *meshBitang = pMesh->mBitangents;
 
     // calculate the tangent and bitangent for every face
-    for( unsigned int a = 0; a < pMesh->mNumFaces; a++)
-    {
-        const aiFace& face = pMesh->mFaces[a];
-        if (face.mNumIndices < 3)
-        {
+    for (unsigned int a = 0; a < pMesh->mNumFaces; a++) {
+        const aiFace &face = pMesh->mFaces[a];
+        if (face.mNumIndices < 3) {
             // There are less than three indices, thus the tangent vector
             // is not defined. We are finished with these vertices now,
             // their tangent vectors are set to qnan.
-            for (unsigned int i = 0; i < face.mNumIndices;++i)
-            {
+            for (unsigned int i = 0; i < face.mNumIndices; ++i) {
                 unsigned int idx = face.mIndices[i];
-                vertexDone  [idx] = true;
-                meshTang    [idx] = aiVector3D(qnan);
-                meshBitang  [idx] = aiVector3D(qnan);
+                vertexDone[idx] = true;
+                meshTang[idx] = aiVector3D(qnan);
+                meshBitang[idx] = aiVector3D(qnan);
             }
 
             continue;
@@ -190,9 +178,11 @@ bool CalcTangentsProcess::ProcessMesh( aiMesh* pMesh, unsigned int meshIndex)
         float tx = meshTex[p2].x - meshTex[p0].x, ty = meshTex[p2].y - meshTex[p0].y;
         float dirCorrection = (tx * sy - ty * sx) < 0.0f ? -1.0f : 1.0f;
         // when t1, t2, t3 in same position in UV space, just use default UV direction.
-        if (  sx * ty == sy * tx ) {
-            sx = 0.0; sy = 1.0;
-            tx = 1.0; ty = 0.0;
+        if (sx * ty == sy * tx) {
+            sx = 0.0;
+            sy = 1.0;
+            tx = 1.0;
+            ty = 0.0;
         }
 
         // tangent points in the direction where to positive X axis of the texture coord's would point in model space
@@ -201,18 +191,19 @@ bool CalcTangentsProcess::ProcessMesh( aiMesh* pMesh, unsigned int meshIndex)
         tangent.x = (w.x * sy - v.x * ty) * dirCorrection;
         tangent.y = (w.y * sy - v.y * ty) * dirCorrection;
         tangent.z = (w.z * sy - v.z * ty) * dirCorrection;
-        bitangent.x = (w.x * sx - v.x * tx) * dirCorrection;
-        bitangent.y = (w.y * sx - v.y * tx) * dirCorrection;
-        bitangent.z = (w.z * sx - v.z * tx) * dirCorrection;
+        bitangent.x = (- w.x * sx + v.x * tx) * dirCorrection;
+        bitangent.y = (- w.y * sx + v.y * tx) * dirCorrection;
+        bitangent.z = (- w.z * sx + v.z * tx) * dirCorrection;
 
         // store for every vertex of that face
-        for( unsigned int b = 0; b < face.mNumIndices; ++b ) {
+        for (unsigned int b = 0; b < face.mNumIndices; ++b) {
             unsigned int p = face.mIndices[b];
 
             // project tangent and bitangent into the plane formed by the vertex' normal
             aiVector3D localTangent = tangent - meshNorm[p] * (tangent * meshNorm[p]);
-            aiVector3D localBitangent = bitangent - meshNorm[p] * (bitangent * meshNorm[p]);
-            localTangent.NormalizeSafe(); localBitangent.NormalizeSafe();
+            aiVector3D localBitangent = bitangent - meshNorm[p] * (bitangent * meshNorm[p]) - localTangent * (bitangent * localTangent);
+            localTangent.NormalizeSafe();
+            localBitangent.NormalizeSafe();
 
             // reconstruct tangent/bitangent according to normal and bitangent/tangent when it's infinite or NaN.
             bool invalid_tangent = is_special_float(localTangent.x) || is_special_float(localTangent.y) || is_special_float(localTangent.z);
@@ -228,31 +219,28 @@ bool CalcTangentsProcess::ProcessMesh( aiMesh* pMesh, unsigned int meshIndex)
             }
 
             // and write it into the mesh.
-            meshTang[ p ]   = localTangent;
-            meshBitang[ p ] = localBitangent;
+            meshTang[p] = localTangent;
+            meshBitang[p] = localBitangent;
         }
     }
 
-
     // create a helper to quickly find locally close vertices among the vertex array
     // FIX: check whether we can reuse the SpatialSort of a previous step
-    SpatialSort* vertexFinder = NULL;
-    SpatialSort  _vertexFinder;
-    float posEpsilon;
-    if (shared)
-    {
-        std::vector<std::pair<SpatialSort,float> >* avf;
-        shared->GetProperty(AI_SPP_SPATIAL_SORT,avf);
-        if (avf)
-        {
-            std::pair<SpatialSort,float>& blubb = avf->operator [] (meshIndex);
+    SpatialSort *vertexFinder = nullptr;
+    SpatialSort _vertexFinder;
+    float posEpsilon = 10e-6f;
+    if (shared) {
+        std::vector<std::pair<SpatialSort, float>> *avf;
+        shared->GetProperty(AI_SPP_SPATIAL_SORT, avf);
+        if (avf) {
+            std::pair<SpatialSort, float> &blubb = avf->operator[](meshIndex);
             vertexFinder = &blubb.first;
-            posEpsilon = blubb.second;;
+            posEpsilon = blubb.second;
+            ;
         }
     }
-    if (!vertexFinder)
-    {
-        _vertexFinder.Fill(pMesh->mVertices, pMesh->mNumVertices, sizeof( aiVector3D));
+    if (!vertexFinder) {
+        _vertexFinder.Fill(pMesh->mVertices, pMesh->mNumVertices, sizeof(aiVector3D));
         vertexFinder = &_vertexFinder;
         posEpsilon = ComputePositionEpsilon(pMesh);
     }
@@ -263,56 +251,52 @@ bool CalcTangentsProcess::ProcessMesh( aiMesh* pMesh, unsigned int meshIndex)
 
     // in the second pass we now smooth out all tangents and bitangents at the same local position
     // if they are not too far off.
-    for( unsigned int a = 0; a < pMesh->mNumVertices; a++)
-    {
-        if( vertexDone[a])
+    for (unsigned int a = 0; a < pMesh->mNumVertices; a++) {
+        if (vertexDone[a])
             continue;
 
-        const aiVector3D& origPos = pMesh->mVertices[a];
-        const aiVector3D& origNorm = pMesh->mNormals[a];
-        const aiVector3D& origTang = pMesh->mTangents[a];
-        const aiVector3D& origBitang = pMesh->mBitangents[a];
-        closeVertices.resize( 0 );
+        const aiVector3D &origPos = pMesh->mVertices[a];
+        const aiVector3D &origNorm = pMesh->mNormals[a];
+        const aiVector3D &origTang = pMesh->mTangents[a];
+        const aiVector3D &origBitang = pMesh->mBitangents[a];
+        closeVertices.resize(0);
 
         // find all vertices close to that position
-        vertexFinder->FindPositions( origPos, posEpsilon, verticesFound);
+        vertexFinder->FindPositions(origPos, posEpsilon, verticesFound);
 
-        closeVertices.reserve (verticesFound.size()+5);
-        closeVertices.push_back( a);
+        closeVertices.reserve(verticesFound.size() + 5);
+        closeVertices.push_back(a);
 
         // look among them for other vertices sharing the same normal and a close-enough tangent/bitangent
-        for( unsigned int b = 0; b < verticesFound.size(); b++)
-        {
+        for (unsigned int b = 0; b < verticesFound.size(); b++) {
             unsigned int idx = verticesFound[b];
-            if( vertexDone[idx])
+            if (vertexDone[idx])
                 continue;
-            if( meshNorm[idx] * origNorm < angleEpsilon)
+            if (meshNorm[idx] * origNorm < angleEpsilon)
                 continue;
-            if(  meshTang[idx] * origTang < fLimit)
+            if (meshTang[idx] * origTang < fLimit)
                 continue;
-            if( meshBitang[idx] * origBitang < fLimit)
+            if (meshBitang[idx] * origBitang < fLimit)
                 continue;
 
             // it's similar enough -> add it to the smoothing group
-            closeVertices.push_back( idx);
+            closeVertices.push_back(idx);
             vertexDone[idx] = true;
         }
 
         // smooth the tangents and bitangents of all vertices that were found to be close enough
-        aiVector3D smoothTangent( 0, 0, 0), smoothBitangent( 0, 0, 0);
-        for( unsigned int b = 0; b < closeVertices.size(); ++b)
-        {
-            smoothTangent += meshTang[ closeVertices[b] ];
-            smoothBitangent += meshBitang[ closeVertices[b] ];
+        aiVector3D smoothTangent(0, 0, 0), smoothBitangent(0, 0, 0);
+        for (unsigned int b = 0; b < closeVertices.size(); ++b) {
+            smoothTangent += meshTang[closeVertices[b]];
+            smoothBitangent += meshBitang[closeVertices[b]];
         }
         smoothTangent.Normalize();
         smoothBitangent.Normalize();
 
         // and write it back into all affected tangents
-        for( unsigned int b = 0; b < closeVertices.size(); ++b)
-        {
-            meshTang[ closeVertices[b] ] = smoothTangent;
-            meshBitang[ closeVertices[b] ] = smoothBitangent;
+        for (unsigned int b = 0; b < closeVertices.size(); ++b) {
+            meshTang[closeVertices[b]] = smoothTangent;
+            meshBitang[closeVertices[b]] = smoothBitangent;
         }
     }
     return true;
diff --git a/Engine/lib/assimp/code/PostProcessing/CalcTangentsProcess.h b/Engine/lib/assimp/code/PostProcessing/CalcTangentsProcess.h
index 3568a624f..018789bae 100644
--- a/Engine/lib/assimp/code/PostProcessing/CalcTangentsProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/CalcTangentsProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/ComputeUVMappingProcess.cpp b/Engine/lib/assimp/code/PostProcessing/ComputeUVMappingProcess.cpp
index df4d44337..c7456cc9d 100644
--- a/Engine/lib/assimp/code/PostProcessing/ComputeUVMappingProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/ComputeUVMappingProcess.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -122,7 +122,7 @@ void RemoveUVSeams (aiMesh* mesh, aiVector3D* out)
         const aiFace& face = mesh->mFaces[fidx];
         if (face.mNumIndices < 3) continue; // triangles and polygons only, please
 
-        unsigned int small = face.mNumIndices, large = small;
+        unsigned int smallV = face.mNumIndices, large = smallV;
         bool zero = false, one = false, round_to_zero = false;
 
         // Check whether this face lies on a UV seam. We can just guess,
@@ -133,7 +133,7 @@ void RemoveUVSeams (aiMesh* mesh, aiVector3D* out)
         {
             if (out[face.mIndices[n]].x < LOWER_LIMIT)
             {
-                small = n;
+                smallV = n;
 
                 // If we have a U value very close to 0 we can't
                 // round the others to 0, too.
@@ -151,7 +151,7 @@ void RemoveUVSeams (aiMesh* mesh, aiVector3D* out)
                     one = true;
             }
         }
-        if (small != face.mNumIndices && large != face.mNumIndices)
+        if (smallV != face.mNumIndices && large != face.mNumIndices)
         {
             for (unsigned int n = 0; n < face.mNumIndices;++n)
             {
diff --git a/Engine/lib/assimp/code/PostProcessing/ComputeUVMappingProcess.h b/Engine/lib/assimp/code/PostProcessing/ComputeUVMappingProcess.h
index a6d36e06e..74744be7f 100644
--- a/Engine/lib/assimp/code/PostProcessing/ComputeUVMappingProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/ComputeUVMappingProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/ConvertToLHProcess.cpp b/Engine/lib/assimp/code/PostProcessing/ConvertToLHProcess.cpp
index b7cd4f0bc..4ded0fc15 100644
--- a/Engine/lib/assimp/code/PostProcessing/ConvertToLHProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/ConvertToLHProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -49,10 +49,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  better location.
  */
 
-
 #include "ConvertToLHProcess.h"
-#include <assimp/scene.h>
 #include <assimp/postprocess.h>
+#include <assimp/scene.h>
 #include <assimp/DefaultLogger.hpp>
 
 using namespace Assimp;
@@ -62,8 +61,10 @@ using namespace Assimp;
 namespace {
 
 template <typename aiMeshType>
-void flipUVs(aiMeshType* pMesh) {
-    if (pMesh == nullptr) { return; }
+void flipUVs(aiMeshType *pMesh) {
+    if (pMesh == nullptr) {
+        return;
+    }
     // mirror texture y coordinate
     for (unsigned int tcIdx = 0; tcIdx < AI_MAX_NUMBER_OF_TEXTURECOORDS; tcIdx++) {
         if (!pMesh->HasTextureCoords(tcIdx)) {
@@ -80,8 +81,8 @@ void flipUVs(aiMeshType* pMesh) {
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-MakeLeftHandedProcess::MakeLeftHandedProcess()
-: BaseProcess() {
+MakeLeftHandedProcess::MakeLeftHandedProcess() :
+        BaseProcess() {
     // empty
 }
 
@@ -93,40 +94,36 @@ MakeLeftHandedProcess::~MakeLeftHandedProcess() {
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the processing step is present in the given flag field.
-bool MakeLeftHandedProcess::IsActive( unsigned int pFlags) const
-{
+bool MakeLeftHandedProcess::IsActive(unsigned int pFlags) const {
     return 0 != (pFlags & aiProcess_MakeLeftHanded);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Executes the post processing step on the given imported data.
-void MakeLeftHandedProcess::Execute( aiScene* pScene)
-{
+void MakeLeftHandedProcess::Execute(aiScene *pScene) {
     // Check for an existent root node to proceed
-    ai_assert(pScene->mRootNode != NULL);
+    ai_assert(pScene->mRootNode != nullptr);
     ASSIMP_LOG_DEBUG("MakeLeftHandedProcess begin");
 
     // recursively convert all the nodes
-    ProcessNode( pScene->mRootNode, aiMatrix4x4());
+    ProcessNode(pScene->mRootNode, aiMatrix4x4());
 
     // process the meshes accordingly
-    for ( unsigned int a = 0; a < pScene->mNumMeshes; ++a ) {
-        ProcessMesh( pScene->mMeshes[ a ] );
+    for (unsigned int a = 0; a < pScene->mNumMeshes; ++a) {
+        ProcessMesh(pScene->mMeshes[a]);
     }
 
     // process the materials accordingly
-    for ( unsigned int a = 0; a < pScene->mNumMaterials; ++a ) {
-        ProcessMaterial( pScene->mMaterials[ a ] );
+    for (unsigned int a = 0; a < pScene->mNumMaterials; ++a) {
+        ProcessMaterial(pScene->mMaterials[a]);
     }
 
     // transform all animation channels as well
-    for( unsigned int a = 0; a < pScene->mNumAnimations; a++)
-    {
-        aiAnimation* anim = pScene->mAnimations[a];
-        for( unsigned int b = 0; b < anim->mNumChannels; b++)
-        {
-            aiNodeAnim* nodeAnim = anim->mChannels[b];
-            ProcessAnimation( nodeAnim);
+    for (unsigned int a = 0; a < pScene->mNumAnimations; a++) {
+        aiAnimation *anim = pScene->mAnimations[a];
+        for (unsigned int b = 0; b < anim->mNumChannels; b++) {
+            aiNodeAnim *nodeAnim = anim->mChannels[b];
+            ProcessAnimation(nodeAnim);
         }
     }
     ASSIMP_LOG_DEBUG("MakeLeftHandedProcess finished");
@@ -134,8 +131,7 @@ void MakeLeftHandedProcess::Execute( aiScene* pScene)
 
 // ------------------------------------------------------------------------------------------------
 // Recursively converts a node, all of its children and all of its meshes
-void MakeLeftHandedProcess::ProcessNode( aiNode* pNode, const aiMatrix4x4& pParentGlobalRotation)
-{
+void MakeLeftHandedProcess::ProcessNode(aiNode *pNode, const aiMatrix4x4 &pParentGlobalRotation) {
     // mirror all base vectors at the local Z axis
     pNode->mTransformation.c1 = -pNode->mTransformation.c1;
     pNode->mTransformation.c2 = -pNode->mTransformation.c2;
@@ -150,43 +146,38 @@ void MakeLeftHandedProcess::ProcessNode( aiNode* pNode, const aiMatrix4x4& pPare
     pNode->mTransformation.d3 = -pNode->mTransformation.d3; // useless, but anyways...
 
     // continue for all children
-    for( size_t a = 0; a < pNode->mNumChildren; ++a ) {
-        ProcessNode( pNode->mChildren[ a ], pParentGlobalRotation * pNode->mTransformation );
+    for (size_t a = 0; a < pNode->mNumChildren; ++a) {
+        ProcessNode(pNode->mChildren[a], pParentGlobalRotation * pNode->mTransformation);
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Converts a single mesh to left handed coordinates.
-void MakeLeftHandedProcess::ProcessMesh( aiMesh* pMesh) {
-    if ( nullptr == pMesh ) {
-        ASSIMP_LOG_ERROR( "Nullptr to mesh found." );
+void MakeLeftHandedProcess::ProcessMesh(aiMesh *pMesh) {
+    if (nullptr == pMesh) {
+        ASSIMP_LOG_ERROR("Nullptr to mesh found.");
         return;
     }
     // mirror positions, normals and stuff along the Z axis
-    for( size_t a = 0; a < pMesh->mNumVertices; ++a)
-    {
+    for (size_t a = 0; a < pMesh->mNumVertices; ++a) {
         pMesh->mVertices[a].z *= -1.0f;
         if (pMesh->HasNormals()) {
             pMesh->mNormals[a].z *= -1.0f;
         }
-        if( pMesh->HasTangentsAndBitangents())
-        {
+        if (pMesh->HasTangentsAndBitangents()) {
             pMesh->mTangents[a].z *= -1.0f;
             pMesh->mBitangents[a].z *= -1.0f;
         }
     }
 
     // mirror anim meshes positions, normals and stuff along the Z axis
-    for (size_t m = 0; m < pMesh->mNumAnimMeshes; ++m)
-    {
-        for (size_t a = 0; a < pMesh->mAnimMeshes[m]->mNumVertices; ++a)
-        {
+    for (size_t m = 0; m < pMesh->mNumAnimMeshes; ++m) {
+        for (size_t a = 0; a < pMesh->mAnimMeshes[m]->mNumVertices; ++a) {
             pMesh->mAnimMeshes[m]->mVertices[a].z *= -1.0f;
             if (pMesh->mAnimMeshes[m]->HasNormals()) {
                 pMesh->mAnimMeshes[m]->mNormals[a].z *= -1.0f;
             }
-            if (pMesh->mAnimMeshes[m]->HasTangentsAndBitangents())
-            {
+            if (pMesh->mAnimMeshes[m]->HasTangentsAndBitangents()) {
                 pMesh->mAnimMeshes[m]->mTangents[a].z *= -1.0f;
                 pMesh->mAnimMeshes[m]->mBitangents[a].z *= -1.0f;
             }
@@ -194,9 +185,8 @@ void MakeLeftHandedProcess::ProcessMesh( aiMesh* pMesh) {
     }
 
     // mirror offset matrices of all bones
-    for( size_t a = 0; a < pMesh->mNumBones; ++a)
-    {
-        aiBone* bone = pMesh->mBones[a];
+    for (size_t a = 0; a < pMesh->mNumBones; ++a) {
+        aiBone *bone = pMesh->mBones[a];
         bone->mOffsetMatrix.a3 = -bone->mOffsetMatrix.a3;
         bone->mOffsetMatrix.b3 = -bone->mOffsetMatrix.b3;
         bone->mOffsetMatrix.d3 = -bone->mOffsetMatrix.d3;
@@ -206,29 +196,28 @@ void MakeLeftHandedProcess::ProcessMesh( aiMesh* pMesh) {
     }
 
     // mirror bitangents as well as they're derived from the texture coords
-    if( pMesh->HasTangentsAndBitangents())
-    {
-        for( unsigned int a = 0; a < pMesh->mNumVertices; a++)
+    if (pMesh->HasTangentsAndBitangents()) {
+        for (unsigned int a = 0; a < pMesh->mNumVertices; a++)
             pMesh->mBitangents[a] *= -1.0f;
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Converts a single material to left handed coordinates.
-void MakeLeftHandedProcess::ProcessMaterial( aiMaterial* _mat) {
-    if ( nullptr == _mat ) {
-        ASSIMP_LOG_ERROR( "Nullptr to aiMaterial found." );
+void MakeLeftHandedProcess::ProcessMaterial(aiMaterial *_mat) {
+    if (nullptr == _mat) {
+        ASSIMP_LOG_ERROR("Nullptr to aiMaterial found.");
         return;
     }
 
-    aiMaterial* mat = (aiMaterial*)_mat;
-    for (unsigned int a = 0; a < mat->mNumProperties;++a)   {
-        aiMaterialProperty* prop = mat->mProperties[a];
+    aiMaterial *mat = (aiMaterial *)_mat;
+    for (unsigned int a = 0; a < mat->mNumProperties; ++a) {
+        aiMaterialProperty *prop = mat->mProperties[a];
 
         // Mapping axis for UV mappings?
-        if (!::strcmp( prop->mKey.data, "$tex.mapaxis"))    {
-            ai_assert( prop->mDataLength >= sizeof(aiVector3D)); /* something is wrong with the validation if we end up here */
-            aiVector3D* pff = (aiVector3D*)prop->mData;
+        if (!::strcmp(prop->mKey.data, "$tex.mapaxis")) {
+            ai_assert(prop->mDataLength >= sizeof(aiVector3D)); // something is wrong with the validation if we end up here
+            aiVector3D *pff = (aiVector3D *)prop->mData;
             pff->z *= -1.f;
         }
     }
@@ -236,15 +225,13 @@ void MakeLeftHandedProcess::ProcessMaterial( aiMaterial* _mat) {
 
 // ------------------------------------------------------------------------------------------------
 // Converts the given animation to LH coordinates.
-void MakeLeftHandedProcess::ProcessAnimation( aiNodeAnim* pAnim)
-{
+void MakeLeftHandedProcess::ProcessAnimation(aiNodeAnim *pAnim) {
     // position keys
-    for( unsigned int a = 0; a < pAnim->mNumPositionKeys; a++)
+    for (unsigned int a = 0; a < pAnim->mNumPositionKeys; a++)
         pAnim->mPositionKeys[a].mValue.z *= -1.0f;
 
     // rotation keys
-    for( unsigned int a = 0; a < pAnim->mNumRotationKeys; a++)
-    {
+    for (unsigned int a = 0; a < pAnim->mNumRotationKeys; a++) {
         /* That's the safe version, but the float errors add up. So we try the short version instead
         aiMatrix3x3 rotmat = pAnim->mRotationKeys[a].mValue.GetMatrix();
         rotmat.a3 = -rotmat.a3; rotmat.b3 = -rotmat.b3;
@@ -258,55 +245,50 @@ void MakeLeftHandedProcess::ProcessAnimation( aiNodeAnim* pAnim)
 }
 
 #endif // !!  ASSIMP_BUILD_NO_MAKELEFTHANDED_PROCESS
-#ifndef  ASSIMP_BUILD_NO_FLIPUVS_PROCESS
+#ifndef ASSIMP_BUILD_NO_FLIPUVS_PROCESS
 // # FlipUVsProcess
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-FlipUVsProcess::FlipUVsProcess()
-{}
+FlipUVsProcess::FlipUVsProcess() {}
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-FlipUVsProcess::~FlipUVsProcess()
-{}
+FlipUVsProcess::~FlipUVsProcess() {}
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the processing step is present in the given flag field.
-bool FlipUVsProcess::IsActive( unsigned int pFlags) const
-{
+bool FlipUVsProcess::IsActive(unsigned int pFlags) const {
     return 0 != (pFlags & aiProcess_FlipUVs);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Executes the post processing step on the given imported data.
-void FlipUVsProcess::Execute( aiScene* pScene)
-{
+void FlipUVsProcess::Execute(aiScene *pScene) {
     ASSIMP_LOG_DEBUG("FlipUVsProcess begin");
-    for (unsigned int i = 0; i < pScene->mNumMeshes;++i)
+    for (unsigned int i = 0; i < pScene->mNumMeshes; ++i)
         ProcessMesh(pScene->mMeshes[i]);
 
-    for (unsigned int i = 0; i < pScene->mNumMaterials;++i)
+    for (unsigned int i = 0; i < pScene->mNumMaterials; ++i)
         ProcessMaterial(pScene->mMaterials[i]);
     ASSIMP_LOG_DEBUG("FlipUVsProcess finished");
 }
 
 // ------------------------------------------------------------------------------------------------
 // Converts a single material
-void FlipUVsProcess::ProcessMaterial (aiMaterial* _mat)
-{
-    aiMaterial* mat = (aiMaterial*)_mat;
-    for (unsigned int a = 0; a < mat->mNumProperties;++a)   {
-        aiMaterialProperty* prop = mat->mProperties[a];
-        if( !prop ) {
-            ASSIMP_LOG_DEBUG( "Property is null" );
+void FlipUVsProcess::ProcessMaterial(aiMaterial *_mat) {
+    aiMaterial *mat = (aiMaterial *)_mat;
+    for (unsigned int a = 0; a < mat->mNumProperties; ++a) {
+        aiMaterialProperty *prop = mat->mProperties[a];
+        if (!prop) {
+            ASSIMP_LOG_VERBOSE_DEBUG("Property is null");
             continue;
         }
 
         // UV transformation key?
-        if (!::strcmp( prop->mKey.data, "$tex.uvtrafo"))    {
-            ai_assert( prop->mDataLength >= sizeof(aiUVTransform));  /* something is wrong with the validation if we end up here */
-            aiUVTransform* uv = (aiUVTransform*)prop->mData;
+        if (!::strcmp(prop->mKey.data, "$tex.uvtrafo")) {
+            ai_assert(prop->mDataLength >= sizeof(aiUVTransform)); // something is wrong with the validation if we end up here
+            aiUVTransform *uv = (aiUVTransform *)prop->mData;
 
             // just flip it, that's everything
             uv->mTranslation.y *= -1.f;
@@ -317,8 +299,7 @@ void FlipUVsProcess::ProcessMaterial (aiMaterial* _mat)
 
 // ------------------------------------------------------------------------------------------------
 // Converts a single mesh
-void FlipUVsProcess::ProcessMesh( aiMesh* pMesh)
-{
+void FlipUVsProcess::ProcessMesh(aiMesh *pMesh) {
     flipUVs(pMesh);
     for (unsigned int idx = 0; idx < pMesh->mNumAnimMeshes; idx++) {
         flipUVs(pMesh->mAnimMeshes[idx]);
@@ -326,44 +307,38 @@ void FlipUVsProcess::ProcessMesh( aiMesh* pMesh)
 }
 
 #endif // !ASSIMP_BUILD_NO_FLIPUVS_PROCESS
-#ifndef  ASSIMP_BUILD_NO_FLIPWINDING_PROCESS
+#ifndef ASSIMP_BUILD_NO_FLIPWINDING_PROCESS
 // # FlipWindingOrderProcess
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-FlipWindingOrderProcess::FlipWindingOrderProcess()
-{}
+FlipWindingOrderProcess::FlipWindingOrderProcess() {}
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-FlipWindingOrderProcess::~FlipWindingOrderProcess()
-{}
+FlipWindingOrderProcess::~FlipWindingOrderProcess() {}
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the processing step is present in the given flag field.
-bool FlipWindingOrderProcess::IsActive( unsigned int pFlags) const
-{
+bool FlipWindingOrderProcess::IsActive(unsigned int pFlags) const {
     return 0 != (pFlags & aiProcess_FlipWindingOrder);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Executes the post processing step on the given imported data.
-void FlipWindingOrderProcess::Execute( aiScene* pScene)
-{
+void FlipWindingOrderProcess::Execute(aiScene *pScene) {
     ASSIMP_LOG_DEBUG("FlipWindingOrderProcess begin");
-    for (unsigned int i = 0; i < pScene->mNumMeshes;++i)
+    for (unsigned int i = 0; i < pScene->mNumMeshes; ++i)
         ProcessMesh(pScene->mMeshes[i]);
     ASSIMP_LOG_DEBUG("FlipWindingOrderProcess finished");
 }
 
 // ------------------------------------------------------------------------------------------------
 // Converts a single mesh
-void FlipWindingOrderProcess::ProcessMesh( aiMesh* pMesh)
-{
+void FlipWindingOrderProcess::ProcessMesh(aiMesh *pMesh) {
     // invert the order of all faces in this mesh
-    for( unsigned int a = 0; a < pMesh->mNumFaces; a++)
-    {
-        aiFace& face = pMesh->mFaces[a];
+    for (unsigned int a = 0; a < pMesh->mNumFaces; a++) {
+        aiFace &face = pMesh->mFaces[a];
         for (unsigned int b = 0; b < face.mNumIndices / 2; b++) {
             std::swap(face.mIndices[b], face.mIndices[face.mNumIndices - 1 - b]);
         }
@@ -371,39 +346,34 @@ void FlipWindingOrderProcess::ProcessMesh( aiMesh* pMesh)
 
     // invert the order of all components in this mesh anim meshes
     for (unsigned int m = 0; m < pMesh->mNumAnimMeshes; m++) {
-        aiAnimMesh* animMesh = pMesh->mAnimMeshes[m];
+        aiAnimMesh *animMesh = pMesh->mAnimMeshes[m];
         unsigned int numVertices = animMesh->mNumVertices;
         if (animMesh->HasPositions()) {
-            for (unsigned int a = 0; a < numVertices; a++)
-            {
+            for (unsigned int a = 0; a < numVertices; a++) {
                 std::swap(animMesh->mVertices[a], animMesh->mVertices[numVertices - 1 - a]);
             }
         }
         if (animMesh->HasNormals()) {
-            for (unsigned int a = 0; a < numVertices; a++)
-            {
+            for (unsigned int a = 0; a < numVertices; a++) {
                 std::swap(animMesh->mNormals[a], animMesh->mNormals[numVertices - 1 - a]);
             }
         }
         for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; i++) {
             if (animMesh->HasTextureCoords(i)) {
-                for (unsigned int a = 0; a < numVertices; a++)
-                {
+                for (unsigned int a = 0; a < numVertices; a++) {
                     std::swap(animMesh->mTextureCoords[i][a], animMesh->mTextureCoords[i][numVertices - 1 - a]);
                 }
             }
         }
         if (animMesh->HasTangentsAndBitangents()) {
-            for (unsigned int a = 0; a < numVertices; a++)
-            {
+            for (unsigned int a = 0; a < numVertices; a++) {
                 std::swap(animMesh->mTangents[a], animMesh->mTangents[numVertices - 1 - a]);
                 std::swap(animMesh->mBitangents[a], animMesh->mBitangents[numVertices - 1 - a]);
             }
         }
         for (unsigned int v = 0; v < AI_MAX_NUMBER_OF_COLOR_SETS; v++) {
             if (animMesh->HasVertexColors(v)) {
-                for (unsigned int a = 0; a < numVertices; a++)
-                {
+                for (unsigned int a = 0; a < numVertices; a++) {
                     std::swap(animMesh->mColors[v][a], animMesh->mColors[v][numVertices - 1 - a]);
                 }
             }
diff --git a/Engine/lib/assimp/code/PostProcessing/ConvertToLHProcess.h b/Engine/lib/assimp/code/PostProcessing/ConvertToLHProcess.h
index f32b91fc3..474056c3a 100644
--- a/Engine/lib/assimp/code/PostProcessing/ConvertToLHProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/ConvertToLHProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -137,8 +137,9 @@ public:
     // -------------------------------------------------------------------
     void Execute( aiScene* pScene);
 
-protected:
-    void ProcessMesh( aiMesh* pMesh);
+public:
+    /** Some other types of post-processing require winding order flips */
+    static void ProcessMesh( aiMesh* pMesh);
 };
 
 // ---------------------------------------------------------------------------
diff --git a/Engine/lib/assimp/code/PostProcessing/DeboneProcess.cpp b/Engine/lib/assimp/code/PostProcessing/DeboneProcess.cpp
index 83b8336bc..e8cfb16b0 100644
--- a/Engine/lib/assimp/code/PostProcessing/DeboneProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/DeboneProcess.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -148,7 +148,7 @@ void DeboneProcess::Execute( aiScene* pScene)
                 }
 
                 if(!DefaultLogger::isNullLogger()) {
-                    ASSIMP_LOG_INFO_F("Removed %u bones. Input bones:", in - out, ". Output bones: ", out);
+                    ASSIMP_LOG_INFO("Removed %u bones. Input bones:", in - out, ". Output bones: ", out);
                 }
 
                 // and destroy the source mesh. It should be completely contained inside the new submeshes
@@ -414,7 +414,8 @@ void DeboneProcess::UpdateNode(aiNode* pNode) const
     }
 
     if( pNode->mNumMeshes > 0 ) {
-        delete [] pNode->mMeshes; pNode->mMeshes = NULL;
+        delete[] pNode->mMeshes;
+        pNode->mMeshes = nullptr;
     }
 
     pNode->mNumMeshes = static_cast<unsigned int>(newMeshList.size());
diff --git a/Engine/lib/assimp/code/PostProcessing/DeboneProcess.h b/Engine/lib/assimp/code/PostProcessing/DeboneProcess.h
index 8b64c2acc..cb072b7eb 100644
--- a/Engine/lib/assimp/code/PostProcessing/DeboneProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/DeboneProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/DropFaceNormalsProcess.cpp b/Engine/lib/assimp/code/PostProcessing/DropFaceNormalsProcess.cpp
index b11615bb8..0cf17f909 100644
--- a/Engine/lib/assimp/code/PostProcessing/DropFaceNormalsProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/DropFaceNormalsProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -98,12 +98,14 @@ void DropFaceNormalsProcess::Execute( aiScene* pScene) {
 
 // ------------------------------------------------------------------------------------------------
 // Executes the post processing step on the given imported data.
-bool DropFaceNormalsProcess::DropMeshFaceNormals (aiMesh* pMesh) {
-    if (NULL == pMesh->mNormals) {
+bool DropFaceNormalsProcess::DropMeshFaceNormals (aiMesh* mesh) {
+    ai_assert(nullptr != mesh);
+
+    if (nullptr == mesh->mNormals) {
         return false;
     }
-    
-    delete[] pMesh->mNormals;
-    pMesh->mNormals = nullptr;
+
+    delete[] mesh->mNormals;
+    mesh->mNormals = nullptr;
     return true;
 }
diff --git a/Engine/lib/assimp/code/PostProcessing/DropFaceNormalsProcess.h b/Engine/lib/assimp/code/PostProcessing/DropFaceNormalsProcess.h
index c710c5a5e..50abdc727 100644
--- a/Engine/lib/assimp/code/PostProcessing/DropFaceNormalsProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/DropFaceNormalsProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/EmbedTexturesProcess.cpp b/Engine/lib/assimp/code/PostProcessing/EmbedTexturesProcess.cpp
index 739382a05..2f80c908e 100644
--- a/Engine/lib/assimp/code/PostProcessing/EmbedTexturesProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/EmbedTexturesProcess.cpp
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -41,6 +40,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "EmbedTexturesProcess.h"
+#include <assimp/IOStream.hpp>
+#include <assimp/IOSystem.hpp>
 #include <assimp/ParsingUtils.h>
 #include "ProcessHelper.h"
 
@@ -48,11 +49,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 using namespace Assimp;
 
-EmbedTexturesProcess::EmbedTexturesProcess()
-: BaseProcess() {
+EmbedTexturesProcess::EmbedTexturesProcess() :
+        BaseProcess() {
+    // empty
 }
 
 EmbedTexturesProcess::~EmbedTexturesProcess() {
+    // empty
 }
 
 bool EmbedTexturesProcess::IsActive(unsigned int pFlags) const {
@@ -62,15 +65,16 @@ bool EmbedTexturesProcess::IsActive(unsigned int pFlags) const {
 void EmbedTexturesProcess::SetupProperties(const Importer* pImp) {
     mRootPath = pImp->GetPropertyString("sourceFilePath");
     mRootPath = mRootPath.substr(0, mRootPath.find_last_of("\\/") + 1u);
+    mIOHandler = pImp->GetIOHandler();
 }
 
 void EmbedTexturesProcess::Execute(aiScene* pScene) {
-    if (pScene == nullptr || pScene->mRootNode == nullptr) return;
+    if (pScene == nullptr || pScene->mRootNode == nullptr || mIOHandler == nullptr){
+        return;
+    }
 
     aiString path;
-
     uint32_t embeddedTexturesCount = 0u;
-
     for (auto matId = 0u; matId < pScene->mNumMaterials; ++matId) {
         auto material = pScene->mMaterials[matId];
 
@@ -85,7 +89,7 @@ void EmbedTexturesProcess::Execute(aiScene* pScene) {
                 // Indeed embed
                 if (addTexture(pScene, path.data)) {
                     auto embeddedTextureId = pScene->mNumTextures - 1u;
-                    ::ai_snprintf(path.data, 1024, "*%u", embeddedTextureId);
+                    path.length = ::ai_snprintf(path.data, 1024, "*%u", embeddedTextureId);
                     material->AddProperty(&path, AI_MATKEY_TEXTURE(tt, texId));
                     embeddedTexturesCount++;
                 }
@@ -93,41 +97,46 @@ void EmbedTexturesProcess::Execute(aiScene* pScene) {
         }
     }
 
-    ASSIMP_LOG_INFO_F("EmbedTexturesProcess finished. Embedded ", embeddedTexturesCount, " textures." );
+    ASSIMP_LOG_INFO("EmbedTexturesProcess finished. Embedded ", embeddedTexturesCount, " textures." );
 }
 
-bool EmbedTexturesProcess::addTexture(aiScene* pScene, std::string path) const {
+bool EmbedTexturesProcess::addTexture(aiScene *pScene, const std::string &path) const {
     std::streampos imageSize = 0;
     std::string    imagePath = path;
 
     // Test path directly
-    std::ifstream file(imagePath, std::ios::binary | std::ios::ate);
-    if ((imageSize = file.tellg()) == std::streampos(-1)) {
-        ASSIMP_LOG_WARN_F("EmbedTexturesProcess: Cannot find image: ", imagePath, ". Will try to find it in root folder.");
+    if (!mIOHandler->Exists(imagePath)) {
+        ASSIMP_LOG_WARN("EmbedTexturesProcess: Cannot find image: ", imagePath, ". Will try to find it in root folder.");
 
         // Test path in root path
         imagePath = mRootPath + path;
-        file.open(imagePath, std::ios::binary | std::ios::ate);
-        if ((imageSize = file.tellg()) == std::streampos(-1)) {
+        if (!mIOHandler->Exists(imagePath)) {
             // Test path basename in root path
             imagePath = mRootPath + path.substr(path.find_last_of("\\/") + 1u);
-            file.open(imagePath, std::ios::binary | std::ios::ate);
-            if ((imageSize = file.tellg()) == std::streampos(-1)) {
-                ASSIMP_LOG_ERROR_F("EmbedTexturesProcess: Unable to embed texture: ", path, ".");
+            if (!mIOHandler->Exists(imagePath)) {
+                ASSIMP_LOG_ERROR("EmbedTexturesProcess: Unable to embed texture: ", path, ".");
                 return false;
             }
         }
     }
+    IOStream* pFile = mIOHandler->Open(imagePath);
+    if (pFile == nullptr) {
+        ASSIMP_LOG_ERROR("EmbedTexturesProcess: Unable to embed texture: ", path, ".");
+        return false;
+    }
+    imageSize = pFile->FileSize();
 
     aiTexel* imageContent = new aiTexel[ 1ul + static_cast<unsigned long>( imageSize ) / sizeof(aiTexel)];
-    file.seekg(0, std::ios::beg);
-    file.read(reinterpret_cast<char*>(imageContent), imageSize);
+    pFile->Seek(0, aiOrigin_SET);
+    pFile->Read(reinterpret_cast<char*>(imageContent), imageSize, 1);
+    mIOHandler->Close(pFile);
 
     // Enlarging the textures table
     unsigned int textureId = pScene->mNumTextures++;
     auto oldTextures = pScene->mTextures;
     pScene->mTextures = new aiTexture*[pScene->mNumTextures];
     ::memmove(pScene->mTextures, oldTextures, sizeof(aiTexture*) * (pScene->mNumTextures - 1u));
+    delete [] oldTextures;
 
     // Add the new texture
     auto pTexture = new aiTexture;
@@ -136,7 +145,7 @@ bool EmbedTexturesProcess::addTexture(aiScene* pScene, std::string path) const {
     pTexture->pcData = imageContent;
 
     auto extension = path.substr(path.find_last_of('.') + 1u);
-    std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
+    extension = ai_tolower(extension);
     if (extension == "jpeg") {
         extension = "jpg";
     }
diff --git a/Engine/lib/assimp/code/PostProcessing/EmbedTexturesProcess.h b/Engine/lib/assimp/code/PostProcessing/EmbedTexturesProcess.h
index 3c4b2eab4..c3e63612c 100644
--- a/Engine/lib/assimp/code/PostProcessing/EmbedTexturesProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/EmbedTexturesProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -48,6 +48,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 struct aiNode;
 
+class IOSystem;
+
 namespace Assimp {
 
 /**
@@ -76,10 +78,11 @@ public:
 
 private:
     // Resolve the path and add the file content to the scene as a texture.
-    bool addTexture(aiScene* pScene, std::string path) const;
+    bool addTexture(aiScene *pScene, const std::string &path) const;
 
 private:
     std::string mRootPath;
+    IOSystem* mIOHandler = nullptr;
 };
 
 } // namespace Assimp
diff --git a/Engine/lib/assimp/code/PostProcessing/FindDegenerates.cpp b/Engine/lib/assimp/code/PostProcessing/FindDegenerates.cpp
index 50fac46db..0bbf421d2 100644
--- a/Engine/lib/assimp/code/PostProcessing/FindDegenerates.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/FindDegenerates.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -45,25 +43,23 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Implementation of the FindDegenerates post-process step.
 */
 
-
-
-// internal headers
 #include "ProcessHelper.h"
 #include "FindDegenerates.h"
+
 #include <assimp/Exceptional.h>
 
+#include <unordered_map>
+
 using namespace Assimp;
 
-//remove mesh at position 'index' from the scene
-static void removeMesh(aiScene* pScene, unsigned const index);
-//correct node indices to meshes and remove references to deleted mesh
-static void updateSceneGraph(aiNode* pNode, unsigned const index);
+// Correct node indices to meshes and remove references to deleted mesh
+static void updateSceneGraph(aiNode* pNode, const std::unordered_map<unsigned int, unsigned int>& meshMap);
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-FindDegeneratesProcess::FindDegeneratesProcess()
-: mConfigRemoveDegenerates( false )
-, mConfigCheckAreaOfTriangle( false ){
+FindDegeneratesProcess::FindDegeneratesProcess() :
+        mConfigRemoveDegenerates( false ),
+        mConfigCheckAreaOfTriangle( false ){
     // empty
 }
 
@@ -91,50 +87,50 @@ void FindDegeneratesProcess::SetupProperties(const Importer* pImp) {
 // Executes the post processing step on the given imported data.
 void FindDegeneratesProcess::Execute( aiScene* pScene) {
     ASSIMP_LOG_DEBUG("FindDegeneratesProcess begin");
-    for (unsigned int i = 0; i < pScene->mNumMeshes;++i)
-    {
-        //Do not process point cloud, ExecuteOnMesh works only with faces data
+    if ( nullptr == pScene) {
+        return;
+    }
+
+    std::unordered_map<unsigned int, unsigned int> meshMap;
+    meshMap.reserve(pScene->mNumMeshes);
+
+    const unsigned int originalNumMeshes = pScene->mNumMeshes;
+    unsigned int targetIndex = 0;
+    for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
+        // Do not process point cloud, ExecuteOnMesh works only with faces data
         if ((pScene->mMeshes[i]->mPrimitiveTypes != aiPrimitiveType::aiPrimitiveType_POINT) && ExecuteOnMesh(pScene->mMeshes[i])) {
-            removeMesh(pScene, i);
-            --i; //the current i is removed, do not skip the next one
+            delete pScene->mMeshes[i];
+            // Not strictly required, but clean:
+            pScene->mMeshes[i] = nullptr;
+        } else {
+            meshMap[i] = targetIndex;
+            pScene->mMeshes[targetIndex] = pScene->mMeshes[i];
+            ++targetIndex;
         }
     }
+    pScene->mNumMeshes = targetIndex;
+
+    if (meshMap.size() < originalNumMeshes) {
+        updateSceneGraph(pScene->mRootNode, meshMap);
+    }
+
     ASSIMP_LOG_DEBUG("FindDegeneratesProcess finished");
 }
 
-static void removeMesh(aiScene* pScene, unsigned const index) {
-    //we start at index and copy the pointers one position forward
-    //save the mesh pointer to delete it later
-    auto delete_me = pScene->mMeshes[index];
-    for (unsigned i = index; i < pScene->mNumMeshes - 1; ++i) {
-        pScene->mMeshes[i] = pScene->mMeshes[i+1];
-    }
-    pScene->mMeshes[pScene->mNumMeshes - 1] = nullptr;
-    --(pScene->mNumMeshes);
-    delete delete_me;
-
-    //removing a mesh also requires updating all references to it in the scene graph
-    updateSceneGraph(pScene->mRootNode, index);
-}
-
-static void updateSceneGraph(aiNode* pNode, unsigned const index) {
+static void updateSceneGraph(aiNode* pNode, const std::unordered_map<unsigned int, unsigned int>& meshMap) {
+    unsigned int targetIndex = 0;
     for (unsigned i = 0; i < pNode->mNumMeshes; ++i) {
-        if (pNode->mMeshes[i] > index) {
-            --(pNode->mMeshes[i]);
-            continue;
-        }
-        if (pNode->mMeshes[i] == index) {
-            for (unsigned j = i; j < pNode->mNumMeshes -1; ++j) {
-                pNode->mMeshes[j] = pNode->mMeshes[j+1];
-            }
-            --(pNode->mNumMeshes);
-            --i;
-            continue;
+        const unsigned int sourceMeshIndex = pNode->mMeshes[i];
+        auto it = meshMap.find(sourceMeshIndex);
+        if (it != meshMap.end()) {
+            pNode->mMeshes[targetIndex] = it->second;
+            ++targetIndex;
         }
     }
+    pNode->mNumMeshes = targetIndex;
     //recurse to all children
     for (unsigned i = 0; i < pNode->mNumChildren; ++i) {
-        updateSceneGraph(pNode->mChildren[i], index);
+        updateSceneGraph(pNode->mChildren[i], meshMap);
     }
 }
 
@@ -225,7 +221,7 @@ bool FindDegeneratesProcess::ExecuteOnMesh( aiMesh* mesh) {
             if ( mConfigCheckAreaOfTriangle ) {
                 if ( face.mNumIndices == 3 ) {
                     ai_real area = calculateAreaOfTriangle( face, mesh );
-                    if ( area < 1e-6 ) {
+                    if (area < ai_epsilon) {
                         if ( mConfigRemoveDegenerates ) {
                             remove_me[ a ] = true;
                             ++deg;
@@ -289,13 +285,13 @@ evil_jump_outside:
         if (!mesh->mNumFaces) {
             //The whole mesh consists of degenerated faces
             //signal upward, that this mesh should be deleted.
-            ASSIMP_LOG_DEBUG("FindDegeneratesProcess removed a mesh full of degenerated primitives");
+            ASSIMP_LOG_VERBOSE_DEBUG("FindDegeneratesProcess removed a mesh full of degenerated primitives");
             return true;
         }
     }
 
     if (deg && !DefaultLogger::isNullLogger()) {
-        ASSIMP_LOG_WARN_F( "Found ", deg, " degenerated primitives");
+        ASSIMP_LOG_WARN( "Found ", deg, " degenerated primitives");
     }
     return false;
 }
diff --git a/Engine/lib/assimp/code/PostProcessing/FindDegenerates.h b/Engine/lib/assimp/code/PostProcessing/FindDegenerates.h
index 7a15e77cf..6fe1e929b 100644
--- a/Engine/lib/assimp/code/PostProcessing/FindDegenerates.h
+++ b/Engine/lib/assimp/code/PostProcessing/FindDegenerates.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/FindInstancesProcess.cpp b/Engine/lib/assimp/code/PostProcessing/FindInstancesProcess.cpp
index 64907458a..7f8c93f77 100644
--- a/Engine/lib/assimp/code/PostProcessing/FindInstancesProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/FindInstancesProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -137,7 +137,7 @@ void FindInstancesProcess::Execute( aiScene* pScene)
             aiMesh* inst = pScene->mMeshes[i];
             hashes[i] = GetMeshHash(inst);
 
-            // Find an appropriate epsilon 
+            // Find an appropriate epsilon
             // to compare position differences against
             float epsilon = ComputePositionEpsilon(inst);
             epsilon *= epsilon;
@@ -243,7 +243,7 @@ void FindInstancesProcess::Execute( aiScene* pScene)
 
                     // Delete the instanced mesh, we don't need it anymore
                     delete inst;
-                    pScene->mMeshes[i] = NULL;
+                    pScene->mMeshes[i] = nullptr;
                     break;
                 }
             }
@@ -256,7 +256,7 @@ void FindInstancesProcess::Execute( aiScene* pScene)
         ai_assert(0 != numMeshesOut);
         if (numMeshesOut != pScene->mNumMeshes) {
 
-            // Collapse the meshes array by removing all NULL entries
+            // Collapse the meshes array by removing all nullptr entries
             for (unsigned int real = 0, i = 0; real < numMeshesOut; ++i) {
                 if (pScene->mMeshes[i])
                     pScene->mMeshes[real++] = pScene->mMeshes[i];
@@ -267,7 +267,7 @@ void FindInstancesProcess::Execute( aiScene* pScene)
 
             // write to log
             if (!DefaultLogger::isNullLogger()) {
-                ASSIMP_LOG_INFO_F( "FindInstancesProcess finished. Found ", (pScene->mNumMeshes - numMeshesOut), " instances" );
+                ASSIMP_LOG_INFO( "FindInstancesProcess finished. Found ", (pScene->mNumMeshes - numMeshesOut), " instances" );
             }
             pScene->mNumMeshes = numMeshesOut;
         } else {
diff --git a/Engine/lib/assimp/code/PostProcessing/FindInstancesProcess.h b/Engine/lib/assimp/code/PostProcessing/FindInstancesProcess.h
index 64b838d7c..b501d88d5 100644
--- a/Engine/lib/assimp/code/PostProcessing/FindInstancesProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/FindInstancesProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/FindInvalidDataProcess.cpp b/Engine/lib/assimp/code/PostProcessing/FindInvalidDataProcess.cpp
index 433f04244..b42cbe9a0 100644
--- a/Engine/lib/assimp/code/PostProcessing/FindInvalidDataProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/FindInvalidDataProcess.cpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -44,15 +42,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Defines a post processing step to search an importer's output
     for data that is obviously invalid  */
 
-
-
 #ifndef ASSIMP_BUILD_NO_FINDINVALIDDATA_PROCESS
 
 // internal headers
 #include "FindInvalidDataProcess.h"
 #include "ProcessHelper.h"
 
-#include <assimp/Macros.h>
 #include <assimp/Exceptional.h>
 #include <assimp/qnan.h>
 
@@ -60,9 +55,8 @@ using namespace Assimp;
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-FindInvalidDataProcess::FindInvalidDataProcess()
-: configEpsilon(0.0)
-, mIgnoreTexCoods( false ){
+FindInvalidDataProcess::FindInvalidDataProcess() :
+        configEpsilon(0.0), mIgnoreTexCoods(false) {
     // nothing to do here
 }
 
@@ -74,47 +68,47 @@ FindInvalidDataProcess::~FindInvalidDataProcess() {
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the processing step is present in the given flag field.
-bool FindInvalidDataProcess::IsActive( unsigned int pFlags) const {
+bool FindInvalidDataProcess::IsActive(unsigned int pFlags) const {
     return 0 != (pFlags & aiProcess_FindInvalidData);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup import configuration
-void FindInvalidDataProcess::SetupProperties(const Importer* pImp) {
+void FindInvalidDataProcess::SetupProperties(const Importer *pImp) {
     // Get the current value of AI_CONFIG_PP_FID_ANIM_ACCURACY
-    configEpsilon = (0 != pImp->GetPropertyFloat(AI_CONFIG_PP_FID_ANIM_ACCURACY,0.f));
+    configEpsilon = (0 != pImp->GetPropertyFloat(AI_CONFIG_PP_FID_ANIM_ACCURACY, 0.f));
     mIgnoreTexCoods = pImp->GetPropertyBool(AI_CONFIG_PP_FID_IGNORE_TEXTURECOORDS, false);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Update mesh references in the node graph
-void UpdateMeshReferences(aiNode* node, const std::vector<unsigned int>& meshMapping) {
-    if (node->mNumMeshes)   {
+void UpdateMeshReferences(aiNode *node, const std::vector<unsigned int> &meshMapping) {
+    if (node->mNumMeshes) {
         unsigned int out = 0;
-        for (unsigned int a = 0; a < node->mNumMeshes;++a)  {
+        for (unsigned int a = 0; a < node->mNumMeshes; ++a) {
 
             unsigned int ref = node->mMeshes[a];
-            if (UINT_MAX != (ref = meshMapping[ref]))   {
+            if (UINT_MAX != (ref = meshMapping[ref])) {
                 node->mMeshes[out++] = ref;
             }
         }
         // just let the members that are unused, that's much cheaper
         // than a full array realloc'n'copy party ...
-        if(!(node->mNumMeshes = out))   {
-
+        node->mNumMeshes = out;
+        if (0 == out) {
             delete[] node->mMeshes;
-            node->mMeshes = NULL;
+            node->mMeshes = nullptr;
         }
     }
     // recursively update all children
-    for (unsigned int i = 0; i < node->mNumChildren;++i) {
-        UpdateMeshReferences(node->mChildren[i],meshMapping);
+    for (unsigned int i = 0; i < node->mNumChildren; ++i) {
+        UpdateMeshReferences(node->mChildren[i], meshMapping);
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Executes the post processing step on the given imported data.
-void FindInvalidDataProcess::Execute( aiScene* pScene) {
+void FindInvalidDataProcess::Execute(aiScene *pScene) {
     ASSIMP_LOG_DEBUG("FindInvalidDataProcess begin");
 
     bool out = false;
@@ -122,33 +116,32 @@ void FindInvalidDataProcess::Execute( aiScene* pScene) {
     unsigned int real = 0;
 
     // Process meshes
-    for( unsigned int a = 0; a < pScene->mNumMeshes; a++)   {
-
-        int result;
-        if ((result = ProcessMesh( pScene->mMeshes[a])))    {
+    for (unsigned int a = 0; a < pScene->mNumMeshes; a++) {
+        int result = ProcessMesh(pScene->mMeshes[a]);
+        if (0 == result) {
             out = true;
-
-            if (2 == result)    {
-                // remove this mesh
-                delete pScene->mMeshes[a];
-                AI_DEBUG_INVALIDATE_PTR(pScene->mMeshes[a]);
-
-                meshMapping[a] = UINT_MAX;
-                continue;
-            }
         }
+        if (2 == result) {
+            // remove this mesh
+            delete pScene->mMeshes[a];
+            pScene->mMeshes[a] = nullptr;
+
+            meshMapping[a] = UINT_MAX;
+            out = true;
+            continue;
+        }
+
         pScene->mMeshes[real] = pScene->mMeshes[a];
         meshMapping[a] = real++;
     }
 
     // Process animations
-    for (unsigned int a = 0; a < pScene->mNumAnimations;++a) {
-        ProcessAnimation( pScene->mAnimations[a]);
+    for (unsigned int animIdx = 0; animIdx < pScene->mNumAnimations; ++animIdx) {
+        ProcessAnimation(pScene->mAnimations[animIdx]);
     }
 
-
-    if (out)    {
-        if ( real != pScene->mNumMeshes)    {
+    if (out) {
+        if (real != pScene->mNumMeshes) {
             if (!real) {
                 throw DeadlyImportError("No meshes remaining");
             }
@@ -156,7 +149,7 @@ void FindInvalidDataProcess::Execute( aiScene* pScene) {
             // we need to remove some meshes.
             // therefore we'll also need to remove all references
             // to them from the scenegraph
-            UpdateMeshReferences(pScene->mRootNode,meshMapping);
+            UpdateMeshReferences(pScene->mRootNode, meshMapping);
             pScene->mNumMeshes = real;
         }
 
@@ -168,35 +161,32 @@ void FindInvalidDataProcess::Execute( aiScene* pScene) {
 
 // ------------------------------------------------------------------------------------------------
 template <typename T>
-inline
-const char* ValidateArrayContents(const T* /*arr*/, unsigned int /*size*/,
-        const std::vector<bool>& /*dirtyMask*/, bool /*mayBeIdentical = false*/, bool /*mayBeZero = true*/)
-{
+inline const char *ValidateArrayContents(const T * /*arr*/, unsigned int /*size*/,
+        const std::vector<bool> & /*dirtyMask*/, bool /*mayBeIdentical = false*/, bool /*mayBeZero = true*/) {
     return nullptr;
 }
 
 // ------------------------------------------------------------------------------------------------
 template <>
-inline
-const char* ValidateArrayContents<aiVector3D>(const aiVector3D* arr, unsigned int size,
-        const std::vector<bool>& dirtyMask, bool mayBeIdentical , bool mayBeZero ) {
+inline const char *ValidateArrayContents<aiVector3D>(const aiVector3D *arr, unsigned int size,
+        const std::vector<bool> &dirtyMask, bool mayBeIdentical, bool mayBeZero) {
     bool b = false;
     unsigned int cnt = 0;
-    for (unsigned int i = 0; i < size;++i)  {
+    for (unsigned int i = 0; i < size; ++i) {
 
         if (dirtyMask.size() && dirtyMask[i]) {
             continue;
         }
         ++cnt;
 
-        const aiVector3D& v = arr[i];
-        if (is_special_float(v.x) || is_special_float(v.y) || is_special_float(v.z))    {
+        const aiVector3D &v = arr[i];
+        if (is_special_float(v.x) || is_special_float(v.y) || is_special_float(v.z)) {
             return "INF/NAN was found in a vector component";
         }
-        if (!mayBeZero && !v.x && !v.y && !v.z )    {
+        if (!mayBeZero && !v.x && !v.y && !v.z) {
             return "Found zero-length vector";
         }
-        if (i && v != arr[i-1])b = true;
+        if (i && v != arr[i - 1]) b = true;
     }
     if (cnt > 1 && !b && !mayBeIdentical) {
         return "All vectors are identical";
@@ -206,14 +196,13 @@ const char* ValidateArrayContents<aiVector3D>(const aiVector3D* arr, unsigned in
 
 // ------------------------------------------------------------------------------------------------
 template <typename T>
-inline 
-bool ProcessArray(T*& in, unsigned int num,const char* name,
-        const std::vector<bool>& dirtyMask, bool mayBeIdentical = false, bool mayBeZero = true) {
-    const char* err = ValidateArrayContents(in,num,dirtyMask,mayBeIdentical,mayBeZero);
-    if (err)    {
-        ASSIMP_LOG_ERROR_F( "FindInvalidDataProcess fails on mesh ", name, ": ", err);
+inline bool ProcessArray(T *&in, unsigned int num, const char *name,
+        const std::vector<bool> &dirtyMask, bool mayBeIdentical = false, bool mayBeZero = true) {
+    const char *err = ValidateArrayContents(in, num, dirtyMask, mayBeIdentical, mayBeZero);
+    if (err) {
+        ASSIMP_LOG_ERROR("FindInvalidDataProcess fails on mesh ", name, ": ", err);
         delete[] in;
-        in = NULL;
+        in = nullptr;
         return true;
     }
     return false;
@@ -221,49 +210,46 @@ bool ProcessArray(T*& in, unsigned int num,const char* name,
 
 // ------------------------------------------------------------------------------------------------
 template <typename T>
-AI_FORCE_INLINE bool EpsilonCompare(const T& n, const T& s, ai_real epsilon);
+AI_FORCE_INLINE bool EpsilonCompare(const T &n, const T &s, ai_real epsilon);
 
 // ------------------------------------------------------------------------------------------------
 AI_FORCE_INLINE bool EpsilonCompare(ai_real n, ai_real s, ai_real epsilon) {
-    return std::fabs(n-s)>epsilon;
+    return std::fabs(n - s) > epsilon;
 }
 
 // ------------------------------------------------------------------------------------------------
 template <>
-bool EpsilonCompare<aiVectorKey>(const aiVectorKey& n, const aiVectorKey& s, ai_real epsilon) {
-    return
-        EpsilonCompare(n.mValue.x,s.mValue.x,epsilon) &&
-        EpsilonCompare(n.mValue.y,s.mValue.y,epsilon) &&
-        EpsilonCompare(n.mValue.z,s.mValue.z,epsilon);
+bool EpsilonCompare<aiVectorKey>(const aiVectorKey &n, const aiVectorKey &s, ai_real epsilon) {
+    return EpsilonCompare(n.mValue.x, s.mValue.x, epsilon) &&
+           EpsilonCompare(n.mValue.y, s.mValue.y, epsilon) &&
+           EpsilonCompare(n.mValue.z, s.mValue.z, epsilon);
 }
 
 // ------------------------------------------------------------------------------------------------
 template <>
-bool EpsilonCompare<aiQuatKey>(const aiQuatKey& n, const aiQuatKey& s, ai_real epsilon)   {
-    return
-        EpsilonCompare(n.mValue.x,s.mValue.x,epsilon) &&
-        EpsilonCompare(n.mValue.y,s.mValue.y,epsilon) &&
-        EpsilonCompare(n.mValue.z,s.mValue.z,epsilon) &&
-        EpsilonCompare(n.mValue.w,s.mValue.w,epsilon);
+bool EpsilonCompare<aiQuatKey>(const aiQuatKey &n, const aiQuatKey &s, ai_real epsilon) {
+    return EpsilonCompare(n.mValue.x, s.mValue.x, epsilon) &&
+           EpsilonCompare(n.mValue.y, s.mValue.y, epsilon) &&
+           EpsilonCompare(n.mValue.z, s.mValue.z, epsilon) &&
+           EpsilonCompare(n.mValue.w, s.mValue.w, epsilon);
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename T>
-inline
-bool AllIdentical(T* in, unsigned int num, ai_real epsilon) {
+inline bool AllIdentical(T *in, unsigned int num, ai_real epsilon) {
     if (num <= 1) {
         return true;
     }
 
     if (fabs(epsilon) > 0.f) {
-        for (unsigned int i = 0; i < num-1;++i) {
-            if (!EpsilonCompare(in[i],in[i+1],epsilon)) {
+        for (unsigned int i = 0; i < num - 1; ++i) {
+            if (!EpsilonCompare(in[i], in[i + 1], epsilon)) {
                 return false;
             }
         }
     } else {
-        for (unsigned int i = 0; i < num-1;++i) {
-            if (in[i] != in[i+1]) {
+        for (unsigned int i = 0; i < num - 1; ++i) {
+            if (in[i] != in[i + 1]) {
                 return false;
             }
         }
@@ -273,16 +259,16 @@ bool AllIdentical(T* in, unsigned int num, ai_real epsilon) {
 
 // ------------------------------------------------------------------------------------------------
 // Search an animation for invalid content
-void FindInvalidDataProcess::ProcessAnimation (aiAnimation* anim) {
+void FindInvalidDataProcess::ProcessAnimation(aiAnimation *anim) {
     // Process all animation channels
-    for ( unsigned int a = 0; a < anim->mNumChannels; ++a ) {
-        ProcessAnimationChannel( anim->mChannels[a]);
+    for (unsigned int a = 0; a < anim->mNumChannels; ++a) {
+        ProcessAnimationChannel(anim->mChannels[a]);
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void FindInvalidDataProcess::ProcessAnimationChannel (aiNodeAnim* anim) {
-    ai_assert( nullptr != anim );
+void FindInvalidDataProcess::ProcessAnimationChannel(aiNodeAnim *anim) {
+    ai_assert(nullptr != anim);
     if (anim->mNumPositionKeys == 0 && anim->mNumRotationKeys == 0 && anim->mNumScalingKeys == 0) {
         ai_assert_entry();
         return;
@@ -292,7 +278,7 @@ void FindInvalidDataProcess::ProcessAnimationChannel (aiNodeAnim* anim) {
     // we can remove al keys except one.
     // POSITIONS
     int i = 0;
-    if (anim->mNumPositionKeys > 1 && AllIdentical(anim->mPositionKeys,anim->mNumPositionKeys,configEpsilon)) {
+    if (anim->mNumPositionKeys > 1 && AllIdentical(anim->mPositionKeys, anim->mNumPositionKeys, configEpsilon)) {
         aiVectorKey v = anim->mPositionKeys[0];
 
         // Reallocate ... we need just ONE element, it makes no sense to reuse the array
@@ -303,7 +289,7 @@ void FindInvalidDataProcess::ProcessAnimationChannel (aiNodeAnim* anim) {
     }
 
     // ROTATIONS
-    if (anim->mNumRotationKeys > 1 && AllIdentical(anim->mRotationKeys,anim->mNumRotationKeys,configEpsilon)) {
+    if (anim->mNumRotationKeys > 1 && AllIdentical(anim->mRotationKeys, anim->mNumRotationKeys, configEpsilon)) {
         aiQuatKey v = anim->mRotationKeys[0];
 
         // Reallocate ... we need just ONE element, it makes no sense to reuse the array
@@ -314,7 +300,7 @@ void FindInvalidDataProcess::ProcessAnimationChannel (aiNodeAnim* anim) {
     }
 
     // SCALINGS
-    if (anim->mNumScalingKeys > 1 && AllIdentical(anim->mScalingKeys,anim->mNumScalingKeys,configEpsilon)) {
+    if (anim->mNumScalingKeys > 1 && AllIdentical(anim->mScalingKeys, anim->mNumScalingKeys, configEpsilon)) {
         aiVectorKey v = anim->mScalingKeys[0];
 
         // Reallocate ... we need just ONE element, it makes no sense to reuse the array
@@ -323,22 +309,21 @@ void FindInvalidDataProcess::ProcessAnimationChannel (aiNodeAnim* anim) {
         anim->mScalingKeys[0] = v;
         i = 1;
     }
-    if ( 1 == i ) {
+    if (1 == i) {
         ASSIMP_LOG_WARN("Simplified dummy tracks with just one key");
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Search a mesh for invalid contents
-int FindInvalidDataProcess::ProcessMesh(aiMesh* pMesh)
-{
+int FindInvalidDataProcess::ProcessMesh(aiMesh *pMesh) {
     bool ret = false;
     std::vector<bool> dirtyMask(pMesh->mNumVertices, pMesh->mNumFaces != 0);
 
     // Ignore elements that are not referenced by vertices.
     // (they are, for example, caused by the FindDegenerates step)
     for (unsigned int m = 0; m < pMesh->mNumFaces; ++m) {
-        const aiFace& f = pMesh->mFaces[m];
+        const aiFace &f = pMesh->mFaces[m];
 
         for (unsigned int i = 0; i < f.mNumIndices; ++i) {
             dirtyMask[f.mIndices[i]] = false;
@@ -361,7 +346,7 @@ int FindInvalidDataProcess::ProcessMesh(aiMesh* pMesh)
                 // delete all subsequent texture coordinate sets.
                 for (unsigned int a = i + 1; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
                     delete[] pMesh->mTextureCoords[a];
-                    pMesh->mTextureCoords[a] = NULL;
+                    pMesh->mTextureCoords[a] = nullptr;
                     pMesh->mNumUVComponents[a] = 0;
                 }
 
@@ -374,19 +359,17 @@ int FindInvalidDataProcess::ProcessMesh(aiMesh* pMesh)
     // they are invalid or not.
 
     // Normals and tangents are undefined for point and line faces.
-    if (pMesh->mNormals || pMesh->mTangents)    {
+    if (pMesh->mNormals || pMesh->mTangents) {
 
         if (aiPrimitiveType_POINT & pMesh->mPrimitiveTypes ||
-            aiPrimitiveType_LINE  & pMesh->mPrimitiveTypes)
-        {
+                aiPrimitiveType_LINE & pMesh->mPrimitiveTypes) {
             if (aiPrimitiveType_TRIANGLE & pMesh->mPrimitiveTypes ||
-                aiPrimitiveType_POLYGON  & pMesh->mPrimitiveTypes)
-            {
+                    aiPrimitiveType_POLYGON & pMesh->mPrimitiveTypes) {
                 // We need to update the lookup-table
-                for (unsigned int m = 0; m < pMesh->mNumFaces;++m) {
-                    const aiFace& f = pMesh->mFaces[ m ];
+                for (unsigned int m = 0; m < pMesh->mNumFaces; ++m) {
+                    const aiFace &f = pMesh->mFaces[m];
 
-                    if (f.mNumIndices < 3)  {
+                    if (f.mNumIndices < 3) {
                         dirtyMask[f.mIndices[0]] = true;
                         if (f.mNumIndices == 2) {
                             dirtyMask[f.mIndices[1]] = true;
@@ -402,19 +385,21 @@ int FindInvalidDataProcess::ProcessMesh(aiMesh* pMesh)
         }
 
         // Process mesh normals
-        if (pMesh->mNormals && ProcessArray(pMesh->mNormals,pMesh->mNumVertices,
-            "normals",dirtyMask,true,false))
+        if (pMesh->mNormals && ProcessArray(pMesh->mNormals, pMesh->mNumVertices,
+                                       "normals", dirtyMask, true, false))
             ret = true;
 
         // Process mesh tangents
-        if (pMesh->mTangents && ProcessArray(pMesh->mTangents,pMesh->mNumVertices,"tangents",dirtyMask))    {
-            delete[] pMesh->mBitangents; pMesh->mBitangents = NULL;
+        if (pMesh->mTangents && ProcessArray(pMesh->mTangents, pMesh->mNumVertices, "tangents", dirtyMask)) {
+            delete[] pMesh->mBitangents;
+            pMesh->mBitangents = nullptr;
             ret = true;
         }
 
         // Process mesh bitangents
-        if (pMesh->mBitangents && ProcessArray(pMesh->mBitangents,pMesh->mNumVertices,"bitangents",dirtyMask))  {
-            delete[] pMesh->mTangents; pMesh->mTangents = NULL;
+        if (pMesh->mBitangents && ProcessArray(pMesh->mBitangents, pMesh->mNumVertices, "bitangents", dirtyMask)) {
+            delete[] pMesh->mTangents;
+            pMesh->mTangents = nullptr;
             ret = true;
         }
     }
diff --git a/Engine/lib/assimp/code/PostProcessing/FindInvalidDataProcess.h b/Engine/lib/assimp/code/PostProcessing/FindInvalidDataProcess.h
index ce7375f34..5ea895c59 100644
--- a/Engine/lib/assimp/code/PostProcessing/FindInvalidDataProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/FindInvalidDataProcess.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -48,14 +47,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "Common/BaseProcess.h"
 
-#include <assimp/types.h>
 #include <assimp/anim.h>
+#include <assimp/types.h>
 
 struct aiMesh;
 
 class FindInvalidDataProcessTest;
 
-namespace Assimp    {
+namespace Assimp {
 
 // ---------------------------------------------------------------------------
 /** The FindInvalidData post-processing step. It searches the mesh data
@@ -70,31 +69,31 @@ public:
 
     // -------------------------------------------------------------------
     //
-    bool IsActive( unsigned int pFlags) const;
+    bool IsActive(unsigned int pFlags) const;
 
     // -------------------------------------------------------------------
     // Setup import settings
-    void SetupProperties(const Importer* pImp);
+    void SetupProperties(const Importer *pImp);
 
     // -------------------------------------------------------------------
     // Run the step
-    void Execute( aiScene* pScene);
+    void Execute(aiScene *pScene);
 
     // -------------------------------------------------------------------
     /** Executes the post-processing step on the given mesh
      * @param pMesh The mesh to process.
      * @return 0 - nothing, 1 - removed sth, 2 - please delete me  */
-    int ProcessMesh( aiMesh* pMesh);
+    int ProcessMesh(aiMesh *pMesh);
 
     // -------------------------------------------------------------------
     /** Executes the post-processing step on the given animation
      * @param anim The animation to process.  */
-    void ProcessAnimation (aiAnimation* anim);
+    void ProcessAnimation(aiAnimation *anim);
 
     // -------------------------------------------------------------------
     /** Executes the post-processing step on the given anim channel
      * @param anim The animation channel to process.*/
-    void ProcessAnimationChannel (aiNodeAnim* anim);
+    void ProcessAnimationChannel(aiNodeAnim *anim);
 
 private:
     ai_real configEpsilon;
diff --git a/Engine/lib/assimp/code/PostProcessing/FixNormalsStep.cpp b/Engine/lib/assimp/code/PostProcessing/FixNormalsStep.cpp
index bbbe6899b..be0104214 100644
--- a/Engine/lib/assimp/code/PostProcessing/FixNormalsStep.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/FixNormalsStep.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -164,7 +164,7 @@ bool FixInfacingNormalsProcess::ProcessMesh( aiMesh* pcMesh, unsigned int index)
     // now compare the volumes of the bounding boxes
     if (std::fabs(fDelta0_x * fDelta0_y * fDelta0_z) < std::fabs(fDelta1_x * fDelta1_yz)) {
         if (!DefaultLogger::isNullLogger()) {
-            ASSIMP_LOG_INFO_F("Mesh ", index, ": Normals are facing inwards (or the mesh is planar)", index);
+            ASSIMP_LOG_INFO("Mesh ", index, ": Normals are facing inwards (or the mesh is planar)", index);
         }
 
         // Invert normals
diff --git a/Engine/lib/assimp/code/PostProcessing/FixNormalsStep.h b/Engine/lib/assimp/code/PostProcessing/FixNormalsStep.h
index f60ce596a..b7d3ba386 100644
--- a/Engine/lib/assimp/code/PostProcessing/FixNormalsStep.h
+++ b/Engine/lib/assimp/code/PostProcessing/FixNormalsStep.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/GenBoundingBoxesProcess.cpp b/Engine/lib/assimp/code/PostProcessing/GenBoundingBoxesProcess.cpp
index c013454fc..1c20b6f94 100644
--- a/Engine/lib/assimp/code/PostProcessing/GenBoundingBoxesProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/GenBoundingBoxesProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/Engine/lib/assimp/code/PostProcessing/GenBoundingBoxesProcess.h b/Engine/lib/assimp/code/PostProcessing/GenBoundingBoxesProcess.h
index 4b43c82a4..0b7591b6d 100644
--- a/Engine/lib/assimp/code/PostProcessing/GenBoundingBoxesProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/GenBoundingBoxesProcess.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/Engine/lib/assimp/code/PostProcessing/GenFaceNormalsProcess.cpp b/Engine/lib/assimp/code/PostProcessing/GenFaceNormalsProcess.cpp
index 028334dec..517dd3b63 100644
--- a/Engine/lib/assimp/code/PostProcessing/GenFaceNormalsProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/GenFaceNormalsProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -45,41 +45,38 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * normals for all imported faces.
 */
 
-
 #include "GenFaceNormalsProcess.h"
+#include <assimp/Exceptional.h>
 #include <assimp/postprocess.h>
+#include <assimp/qnan.h>
 #include <assimp/scene.h>
 #include <assimp/DefaultLogger.hpp>
-#include <assimp/Exceptional.h>
-#include <assimp/qnan.h>
-
 
 using namespace Assimp;
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-GenFaceNormalsProcess::GenFaceNormalsProcess()
-{
+GenFaceNormalsProcess::GenFaceNormalsProcess() {
     // nothing to do here
 }
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-GenFaceNormalsProcess::~GenFaceNormalsProcess()
-{
+GenFaceNormalsProcess::~GenFaceNormalsProcess() {
     // nothing to do here
 }
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the processing step is present in the given flag field.
-bool GenFaceNormalsProcess::IsActive( unsigned int pFlags) const {
+bool GenFaceNormalsProcess::IsActive(unsigned int pFlags) const {
     force_ = (pFlags & aiProcess_ForceGenNormals) != 0;
-    return  (pFlags & aiProcess_GenNormals) != 0;
+    flippedWindingOrder_ = (pFlags & aiProcess_FlipWindingOrder) != 0;
+    return (pFlags & aiProcess_GenNormals) != 0;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Executes the post processing step on the given imported data.
-void GenFaceNormalsProcess::Execute( aiScene* pScene) {
+void GenFaceNormalsProcess::Execute(aiScene *pScene) {
     ASSIMP_LOG_DEBUG("GenFaceNormalsProcess begin");
 
     if (pScene->mFlags & AI_SCENE_FLAGS_NON_VERBOSE_FORMAT) {
@@ -87,33 +84,35 @@ void GenFaceNormalsProcess::Execute( aiScene* pScene) {
     }
 
     bool bHas = false;
-    for( unsigned int a = 0; a < pScene->mNumMeshes; a++)   {
-        if(this->GenMeshFaceNormals( pScene->mMeshes[a])) {
+    for (unsigned int a = 0; a < pScene->mNumMeshes; a++) {
+        if (this->GenMeshFaceNormals(pScene->mMeshes[a])) {
             bHas = true;
         }
     }
-    if (bHas)   {
+    if (bHas) {
         ASSIMP_LOG_INFO("GenFaceNormalsProcess finished. "
-            "Face normals have been calculated");
+                        "Face normals have been calculated");
     } else {
         ASSIMP_LOG_DEBUG("GenFaceNormalsProcess finished. "
-            "Normals are already there");
+                         "Normals are already there");
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Executes the post processing step on the given imported data.
-bool GenFaceNormalsProcess::GenMeshFaceNormals (aiMesh* pMesh)
-{
-    if (NULL != pMesh->mNormals) {
-        if (force_) delete[] pMesh->mNormals;
-        else return false;
+bool GenFaceNormalsProcess::GenMeshFaceNormals(aiMesh *pMesh) {
+    if (nullptr != pMesh->mNormals) {
+        if (force_) {
+            delete[] pMesh->mNormals;
+        } else {
+            return false;
+        }
     }
 
     // If the mesh consists of lines and/or points but not of
     // triangles or higher-order polygons the normal vectors
     // are undefined.
-    if (!(pMesh->mPrimitiveTypes & (aiPrimitiveType_TRIANGLE | aiPrimitiveType_POLYGON)))   {
+    if (!(pMesh->mPrimitiveTypes & (aiPrimitiveType_TRIANGLE | aiPrimitiveType_POLYGON))) {
         ASSIMP_LOG_INFO("Normal vectors are undefined for line and point meshes");
         return false;
     }
@@ -123,22 +122,24 @@ bool GenFaceNormalsProcess::GenMeshFaceNormals (aiMesh* pMesh)
     const float qnan = get_qnan();
 
     // iterate through all faces and compute per-face normals but store them per-vertex.
-    for( unsigned int a = 0; a < pMesh->mNumFaces; a++) {
-        const aiFace& face = pMesh->mFaces[a];
-        if (face.mNumIndices < 3)   {
+    for (unsigned int a = 0; a < pMesh->mNumFaces; a++) {
+        const aiFace &face = pMesh->mFaces[a];
+        if (face.mNumIndices < 3) {
             // either a point or a line -> no well-defined normal vector
-            for (unsigned int i = 0;i < face.mNumIndices;++i) {
+            for (unsigned int i = 0; i < face.mNumIndices; ++i) {
                 pMesh->mNormals[face.mIndices[i]] = aiVector3D(qnan);
             }
             continue;
         }
 
-        const aiVector3D* pV1 = &pMesh->mVertices[face.mIndices[0]];
-        const aiVector3D* pV2 = &pMesh->mVertices[face.mIndices[1]];
-        const aiVector3D* pV3 = &pMesh->mVertices[face.mIndices[face.mNumIndices-1]];
+        const aiVector3D *pV1 = &pMesh->mVertices[face.mIndices[0]];
+        const aiVector3D *pV2 = &pMesh->mVertices[face.mIndices[1]];
+        const aiVector3D *pV3 = &pMesh->mVertices[face.mIndices[face.mNumIndices - 1]];
+        if (flippedWindingOrder_)
+            std::swap( pV2, pV3 );
         const aiVector3D vNor = ((*pV2 - *pV1) ^ (*pV3 - *pV1)).NormalizeSafe();
 
-        for (unsigned int i = 0;i < face.mNumIndices;++i) {
+        for (unsigned int i = 0; i < face.mNumIndices; ++i) {
             pMesh->mNormals[face.mIndices[i]] = vNor;
         }
     }
diff --git a/Engine/lib/assimp/code/PostProcessing/GenFaceNormalsProcess.h b/Engine/lib/assimp/code/PostProcessing/GenFaceNormalsProcess.h
index c641fd635..586c4902e 100644
--- a/Engine/lib/assimp/code/PostProcessing/GenFaceNormalsProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/GenFaceNormalsProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -80,6 +80,7 @@ public:
 private:
     bool GenMeshFaceNormals(aiMesh* pcMesh);
     mutable bool force_ = false;
+    mutable bool flippedWindingOrder_ = false;
 };
 
 } // end of namespace Assimp
diff --git a/Engine/lib/assimp/code/PostProcessing/GenVertexNormalsProcess.cpp b/Engine/lib/assimp/code/PostProcessing/GenVertexNormalsProcess.cpp
index 3f6c2f86b..1a8afc597 100644
--- a/Engine/lib/assimp/code/PostProcessing/GenVertexNormalsProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/GenVertexNormalsProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -45,8 +45,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * normals for all imported faces.
 */
 
-
-
 // internal headers
 #include "GenVertexNormalsProcess.h"
 #include "ProcessHelper.h"
@@ -57,8 +55,8 @@ using namespace Assimp;
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-GenVertexNormalsProcess::GenVertexNormalsProcess()
-: configMaxAngle( AI_DEG_TO_RAD( 175.f ) ) {
+GenVertexNormalsProcess::GenVertexNormalsProcess() :
+        configMaxAngle(AI_DEG_TO_RAD(175.f)) {
     // empty
 }
 
@@ -70,25 +68,23 @@ GenVertexNormalsProcess::~GenVertexNormalsProcess() {
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the processing step is present in the given flag field.
-bool GenVertexNormalsProcess::IsActive( unsigned int pFlags) const
-{
+bool GenVertexNormalsProcess::IsActive(unsigned int pFlags) const {
     force_ = (pFlags & aiProcess_ForceGenNormals) != 0;
+    flippedWindingOrder_ = (pFlags & aiProcess_FlipWindingOrder) != 0;
     return (pFlags & aiProcess_GenSmoothNormals) != 0;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Executes the post processing step on the given imported data.
-void GenVertexNormalsProcess::SetupProperties(const Importer* pImp)
-{
+void GenVertexNormalsProcess::SetupProperties(const Importer *pImp) {
     // Get the current value of the AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE property
-    configMaxAngle = pImp->GetPropertyFloat(AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE,(ai_real)175.0);
-    configMaxAngle = AI_DEG_TO_RAD(std::max(std::min(configMaxAngle,(ai_real)175.0),(ai_real)0.0));
+    configMaxAngle = pImp->GetPropertyFloat(AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE, (ai_real)175.0);
+    configMaxAngle = AI_DEG_TO_RAD(std::max(std::min(configMaxAngle, (ai_real)175.0), (ai_real)0.0));
 }
 
 // ------------------------------------------------------------------------------------------------
 // Executes the post processing step on the given imported data.
-void GenVertexNormalsProcess::Execute( aiScene* pScene)
-{
+void GenVertexNormalsProcess::Execute(aiScene *pScene) {
     ASSIMP_LOG_DEBUG("GenVertexNormalsProcess begin");
 
     if (pScene->mFlags & AI_SCENE_FLAGS_NON_VERBOSE_FORMAT) {
@@ -96,34 +92,34 @@ void GenVertexNormalsProcess::Execute( aiScene* pScene)
     }
 
     bool bHas = false;
-    for( unsigned int a = 0; a < pScene->mNumMeshes; ++a) {
-        if(GenMeshVertexNormals( pScene->mMeshes[a],a))
+    for (unsigned int a = 0; a < pScene->mNumMeshes; ++a) {
+        if (GenMeshVertexNormals(pScene->mMeshes[a], a))
             bHas = true;
     }
 
-    if (bHas)   {
+    if (bHas) {
         ASSIMP_LOG_INFO("GenVertexNormalsProcess finished. "
-            "Vertex normals have been calculated");
+                        "Vertex normals have been calculated");
     } else {
         ASSIMP_LOG_DEBUG("GenVertexNormalsProcess finished. "
-            "Normals are already there");
+                         "Normals are already there");
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Executes the post processing step on the given imported data.
-bool GenVertexNormalsProcess::GenMeshVertexNormals (aiMesh* pMesh, unsigned int meshIndex)
-{
-    if (NULL != pMesh->mNormals) {
-        if (force_) delete[] pMesh->mNormals;
-        else return false;
+bool GenVertexNormalsProcess::GenMeshVertexNormals(aiMesh *pMesh, unsigned int meshIndex) {
+    if (nullptr != pMesh->mNormals) {
+        if (force_)
+            delete[] pMesh->mNormals;
+        else
+            return false;
     }
 
     // If the mesh consists of lines and/or points but not of
     // triangles or higher-order polygons the normal vectors
     // are undefined.
-    if (!(pMesh->mPrimitiveTypes & (aiPrimitiveType_TRIANGLE | aiPrimitiveType_POLYGON)))
-    {
+    if (!(pMesh->mPrimitiveTypes & (aiPrimitiveType_TRIANGLE | aiPrimitiveType_POLYGON))) {
         ASSIMP_LOG_INFO("Normal vectors are undefined for line and point meshes");
         return false;
     }
@@ -133,75 +129,73 @@ bool GenVertexNormalsProcess::GenMeshVertexNormals (aiMesh* pMesh, unsigned int
     pMesh->mNormals = new aiVector3D[pMesh->mNumVertices];
 
     // Compute per-face normals but store them per-vertex
-    for( unsigned int a = 0; a < pMesh->mNumFaces; a++)
-    {
-        const aiFace& face = pMesh->mFaces[a];
-        if (face.mNumIndices < 3)
-        {
+    for (unsigned int a = 0; a < pMesh->mNumFaces; a++) {
+        const aiFace &face = pMesh->mFaces[a];
+        if (face.mNumIndices < 3) {
             // either a point or a line -> no normal vector
-            for (unsigned int i = 0;i < face.mNumIndices;++i) {
+            for (unsigned int i = 0; i < face.mNumIndices; ++i) {
                 pMesh->mNormals[face.mIndices[i]] = aiVector3D(qnan);
             }
 
             continue;
         }
 
-        const aiVector3D* pV1 = &pMesh->mVertices[face.mIndices[0]];
-        const aiVector3D* pV2 = &pMesh->mVertices[face.mIndices[1]];
-        const aiVector3D* pV3 = &pMesh->mVertices[face.mIndices[face.mNumIndices-1]];
+        const aiVector3D *pV1 = &pMesh->mVertices[face.mIndices[0]];
+        const aiVector3D *pV2 = &pMesh->mVertices[face.mIndices[1]];
+        const aiVector3D *pV3 = &pMesh->mVertices[face.mIndices[face.mNumIndices - 1]];
+        if (flippedWindingOrder_)
+            std::swap( pV2, pV3 );
         const aiVector3D vNor = ((*pV2 - *pV1) ^ (*pV3 - *pV1)).NormalizeSafe();
 
-        for (unsigned int i = 0;i < face.mNumIndices;++i) {
+        for (unsigned int i = 0; i < face.mNumIndices; ++i) {
             pMesh->mNormals[face.mIndices[i]] = vNor;
         }
     }
 
     // Set up a SpatialSort to quickly find all vertices close to a given position
     // check whether we can reuse the SpatialSort of a previous step.
-    SpatialSort* vertexFinder = NULL;
-    SpatialSort  _vertexFinder;
-    ai_real posEpsilon = ai_real( 1e-5 );
+    SpatialSort *vertexFinder = nullptr;
+    SpatialSort _vertexFinder;
+    ai_real posEpsilon = ai_real(1e-5);
     if (shared) {
-        std::vector<std::pair<SpatialSort,ai_real> >* avf;
-        shared->GetProperty(AI_SPP_SPATIAL_SORT,avf);
-        if (avf)
-        {
-            std::pair<SpatialSort,ai_real>& blubb = avf->operator [] (meshIndex);
+        std::vector<std::pair<SpatialSort, ai_real>> *avf;
+        shared->GetProperty(AI_SPP_SPATIAL_SORT, avf);
+        if (avf) {
+            std::pair<SpatialSort, ai_real> &blubb = avf->operator[](meshIndex);
             vertexFinder = &blubb.first;
             posEpsilon = blubb.second;
         }
     }
-    if (!vertexFinder)  {
-        _vertexFinder.Fill(pMesh->mVertices, pMesh->mNumVertices, sizeof( aiVector3D));
+    if (!vertexFinder) {
+        _vertexFinder.Fill(pMesh->mVertices, pMesh->mNumVertices, sizeof(aiVector3D));
         vertexFinder = &_vertexFinder;
         posEpsilon = ComputePositionEpsilon(pMesh);
     }
     std::vector<unsigned int> verticesFound;
-    aiVector3D* pcNew = new aiVector3D[pMesh->mNumVertices];
+    aiVector3D *pcNew = new aiVector3D[pMesh->mNumVertices];
 
-    if (configMaxAngle >= AI_DEG_TO_RAD( 175.f ))   {
+    if (configMaxAngle >= AI_DEG_TO_RAD(175.f)) {
         // There is no angle limit. Thus all vertices with positions close
         // to each other will receive the same vertex normal. This allows us
         // to optimize the whole algorithm a little bit ...
-        std::vector<bool> abHad(pMesh->mNumVertices,false);
-        for (unsigned int i = 0; i < pMesh->mNumVertices;++i)   {
+        std::vector<bool> abHad(pMesh->mNumVertices, false);
+        for (unsigned int i = 0; i < pMesh->mNumVertices; ++i) {
             if (abHad[i]) {
                 continue;
             }
 
             // Get all vertices that share this one ...
-            vertexFinder->FindPositions( pMesh->mVertices[i], posEpsilon, verticesFound);
+            vertexFinder->FindPositions(pMesh->mVertices[i], posEpsilon, verticesFound);
 
             aiVector3D pcNor;
             for (unsigned int a = 0; a < verticesFound.size(); ++a) {
-                const aiVector3D& v = pMesh->mNormals[verticesFound[a]];
-                if (is_not_qnan(v.x))pcNor += v;
+                const aiVector3D &v = pMesh->mNormals[verticesFound[a]];
+                if (is_not_qnan(v.x)) pcNor += v;
             }
             pcNor.NormalizeSafe();
 
             // Write the smoothed normal back to all affected normals
-            for (unsigned int a = 0; a < verticesFound.size(); ++a)
-            {
+            for (unsigned int a = 0; a < verticesFound.size(); ++a) {
                 unsigned int vidx = verticesFound[a];
                 pcNew[vidx] = pcNor;
                 abHad[vidx] = true;
@@ -210,11 +204,11 @@ bool GenVertexNormalsProcess::GenMeshVertexNormals (aiMesh* pMesh, unsigned int
     }
     // Slower code path if a smooth angle is set. There are many ways to achieve
     // the effect, this one is the most straightforward one.
-    else    {
+    else {
         const ai_real fLimit = std::cos(configMaxAngle);
-        for (unsigned int i = 0; i < pMesh->mNumVertices;++i)   {
+        for (unsigned int i = 0; i < pMesh->mNumVertices; ++i) {
             // Get all vertices that share this one ...
-            vertexFinder->FindPositions( pMesh->mVertices[i] , posEpsilon, verticesFound);
+            vertexFinder->FindPositions(pMesh->mVertices[i], posEpsilon, verticesFound);
 
             aiVector3D vr = pMesh->mNormals[i];
 
diff --git a/Engine/lib/assimp/code/PostProcessing/GenVertexNormalsProcess.h b/Engine/lib/assimp/code/PostProcessing/GenVertexNormalsProcess.h
index 2ceee17e8..0dcae793a 100644
--- a/Engine/lib/assimp/code/PostProcessing/GenVertexNormalsProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/GenVertexNormalsProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -104,6 +104,7 @@ private:
     /** Configuration option: maximum smoothing angle, in radians*/
     ai_real configMaxAngle;
     mutable bool force_ = false;
+    mutable bool flippedWindingOrder_ = false;
 };
 
 } // end of namespace Assimp
diff --git a/Engine/lib/assimp/code/PostProcessing/ImproveCacheLocality.cpp b/Engine/lib/assimp/code/PostProcessing/ImproveCacheLocality.cpp
index d0a016fa4..56bdfc447 100644
--- a/Engine/lib/assimp/code/PostProcessing/ImproveCacheLocality.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/ImproveCacheLocality.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -109,7 +109,7 @@ void ImproveCacheLocalityProcess::Execute( aiScene* pScene) {
     }
     if (!DefaultLogger::isNullLogger()) {
         if (numf > 0) {
-            ASSIMP_LOG_INFO_F("Cache relevant are ", numm, " meshes (", numf, " faces). Average output ACMR is ", out / numf);
+            ASSIMP_LOG_INFO("Cache relevant are ", numm, " meshes (", numf, " faces). Average output ACMR is ", out / numf);
         }
         ASSIMP_LOG_DEBUG("ImproveCacheLocalityProcess finished. ");
     }
@@ -355,7 +355,7 @@ ai_real ImproveCacheLocalityProcess::ProcessMesh( aiMesh* pMesh, unsigned int me
 
         // very intense verbose logging ... prepare for much text if there are many meshes
         if ( DefaultLogger::get()->getLogSeverity() == Logger::VERBOSE) {
-            ASSIMP_LOG_DEBUG_F("Mesh %u | ACMR in: ", meshNum, " out: ", fACMR, " | ~", fACMR2, ((fACMR - fACMR2) / fACMR) * 100.f);
+            ASSIMP_LOG_VERBOSE_DEBUG("Mesh %u | ACMR in: ", meshNum, " out: ", fACMR, " | ~", fACMR2, ((fACMR - fACMR2) / fACMR) * 100.f);
         }
 
         fACMR2 *= pMesh->mNumFaces;
diff --git a/Engine/lib/assimp/code/PostProcessing/ImproveCacheLocality.h b/Engine/lib/assimp/code/PostProcessing/ImproveCacheLocality.h
index de25ecd9f..b2074a17c 100644
--- a/Engine/lib/assimp/code/PostProcessing/ImproveCacheLocality.h
+++ b/Engine/lib/assimp/code/PostProcessing/ImproveCacheLocality.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/JoinVerticesProcess.cpp b/Engine/lib/assimp/code/PostProcessing/JoinVerticesProcess.cpp
index f121fc60d..184e8d745 100644
--- a/Engine/lib/assimp/code/PostProcessing/JoinVerticesProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/JoinVerticesProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -100,7 +100,7 @@ void JoinVerticesProcess::Execute( aiScene* pScene)
         if (iNumOldVertices == iNumVertices) {
             ASSIMP_LOG_DEBUG("JoinVerticesProcess finished ");
         } else {
-            ASSIMP_LOG_INFO_F("JoinVerticesProcess finished | Verts in: ", iNumOldVertices,
+            ASSIMP_LOG_INFO("JoinVerticesProcess finished | Verts in: ", iNumOldVertices,
                 " out: ", iNumVertices, " | ~",
                 ((iNumOldVertices - iNumVertices) / (float)iNumOldVertices) * 100.f );
         }
@@ -266,7 +266,7 @@ int JoinVerticesProcess::ProcessMesh( aiMesh* pMesh, unsigned int meshIndex)
     std::vector<unsigned int> replaceIndex( pMesh->mNumVertices, 0xffffffff);
 
     // float posEpsilonSqr;
-    SpatialSort* vertexFinder = NULL;
+    SpatialSort *vertexFinder = nullptr;
     SpatialSort _vertexFinder;
 
     typedef std::pair<SpatialSort,float> SpatPair;
@@ -373,7 +373,7 @@ int JoinVerticesProcess::ProcessMesh( aiMesh* pMesh, unsigned int meshIndex)
     }
 
     if (!DefaultLogger::isNullLogger() && DefaultLogger::get()->getLogSeverity() == Logger::VERBOSE)    {
-        ASSIMP_LOG_DEBUG_F(
+        ASSIMP_LOG_VERBOSE_DEBUG(
             "Mesh ",meshIndex,
             " (",
             (pMesh->mName.length ? pMesh->mName.data : "unnamed"),
@@ -408,7 +408,7 @@ int JoinVerticesProcess::ProcessMesh( aiMesh* pMesh, unsigned int meshIndex)
         std::vector<aiVertexWeight> newWeights;
         newWeights.reserve( bone->mNumWeights);
 
-        if ( NULL != bone->mWeights ) {
+        if (nullptr != bone->mWeights) {
             for ( unsigned int b = 0; b < bone->mNumWeights; b++ ) {
                 const aiVertexWeight& ow = bone->mWeights[ b ];
                 // if the vertex is a unique one, translate it
@@ -420,7 +420,7 @@ int JoinVerticesProcess::ProcessMesh( aiMesh* pMesh, unsigned int meshIndex)
                 }
             }
         } else {
-            ASSIMP_LOG_ERROR( "X-Export: aiBone shall contain weights, but pointer to them is NULL." );
+            ASSIMP_LOG_ERROR( "X-Export: aiBone shall contain weights, but pointer to them is nullptr." );
         }
 
         if (newWeights.size() > 0) {
diff --git a/Engine/lib/assimp/code/PostProcessing/JoinVerticesProcess.h b/Engine/lib/assimp/code/PostProcessing/JoinVerticesProcess.h
index e017ae62d..f95236e31 100644
--- a/Engine/lib/assimp/code/PostProcessing/JoinVerticesProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/JoinVerticesProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/LimitBoneWeightsProcess.cpp b/Engine/lib/assimp/code/PostProcessing/LimitBoneWeightsProcess.cpp
index d560f1928..63f6bf9f3 100644
--- a/Engine/lib/assimp/code/PostProcessing/LimitBoneWeightsProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/LimitBoneWeightsProcess.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -44,6 +44,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
 #include "LimitBoneWeightsProcess.h"
+#include <assimp/SmallVector.h>
 #include <assimp/StringUtils.h>
 #include <assimp/postprocess.h>
 #include <assimp/DefaultLogger.hpp>
@@ -52,7 +53,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 using namespace Assimp;
 
-
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 LimitBoneWeightsProcess::LimitBoneWeightsProcess()
@@ -76,10 +76,12 @@ bool LimitBoneWeightsProcess::IsActive( unsigned int pFlags) const
 
 // ------------------------------------------------------------------------------------------------
 // Executes the post processing step on the given imported data.
-void LimitBoneWeightsProcess::Execute( aiScene* pScene) {
+void LimitBoneWeightsProcess::Execute( aiScene* pScene)
+{
     ASSIMP_LOG_DEBUG("LimitBoneWeightsProcess begin");
-    for (unsigned int a = 0; a < pScene->mNumMeshes; ++a ) {
-        ProcessMesh(pScene->mMeshes[a]);
+
+    for (unsigned int m = 0; m < pScene->mNumMeshes; ++m) {
+        ProcessMesh(pScene->mMeshes[m]);
     }
 
     ASSIMP_LOG_DEBUG("LimitBoneWeightsProcess end");
@@ -95,107 +97,100 @@ void LimitBoneWeightsProcess::SetupProperties(const Importer* pImp)
 
 // ------------------------------------------------------------------------------------------------
 // Unites identical vertices in the given mesh
-void LimitBoneWeightsProcess::ProcessMesh( aiMesh* pMesh)
+void LimitBoneWeightsProcess::ProcessMesh(aiMesh* pMesh)
 {
-    if( !pMesh->HasBones())
+    if (!pMesh->HasBones())
         return;
 
     // collect all bone weights per vertex
-    typedef std::vector< std::vector< Weight > > WeightsPerVertex;
-    WeightsPerVertex vertexWeights( pMesh->mNumVertices);
+    typedef SmallVector<Weight,8> VertexWeightArray;
+    typedef std::vector<VertexWeightArray> WeightsPerVertex;
+    WeightsPerVertex vertexWeights(pMesh->mNumVertices);
+    size_t maxVertexWeights = 0;
 
-    // collect all weights per vertex
-    for( unsigned int a = 0; a < pMesh->mNumBones; a++)
+    for (unsigned int b = 0; b < pMesh->mNumBones; ++b)
     {
-        const aiBone* bone = pMesh->mBones[a];
-        for( unsigned int b = 0; b < bone->mNumWeights; b++)
+        const aiBone* bone = pMesh->mBones[b];
+        for (unsigned int w = 0; w < bone->mNumWeights; ++w)
         {
-            const aiVertexWeight& w = bone->mWeights[b];
-            vertexWeights[w.mVertexId].push_back( Weight( a, w.mWeight));
+            const aiVertexWeight& vw = bone->mWeights[w];
+
+            if (vertexWeights.size() <= vw.mVertexId)
+                continue;
+
+            vertexWeights[vw.mVertexId].push_back(Weight(b, vw.mWeight));
+            maxVertexWeights = std::max(maxVertexWeights, vertexWeights[vw.mVertexId].size());
         }
     }
 
+    if (maxVertexWeights <= mMaxWeights)
+        return;
+
     unsigned int removed = 0, old_bones = pMesh->mNumBones;
 
     // now cut the weight count if it exceeds the maximum
-    bool bChanged = false;
-    for( WeightsPerVertex::iterator vit = vertexWeights.begin(); vit != vertexWeights.end(); ++vit)
+    for (WeightsPerVertex::iterator vit = vertexWeights.begin(); vit != vertexWeights.end(); ++vit)
     {
-        if( vit->size() <= mMaxWeights)
+        if (vit->size() <= mMaxWeights)
             continue;
 
-        bChanged = true;
-
         // more than the defined maximum -> first sort by weight in descending order. That's
         // why we defined the < operator in such a weird way.
-        std::sort( vit->begin(), vit->end());
+        std::sort(vit->begin(), vit->end());
 
         // now kill everything beyond the maximum count
         unsigned int m = static_cast<unsigned int>(vit->size());
-        vit->erase( vit->begin() + mMaxWeights, vit->end());
-        removed += static_cast<unsigned int>(m-vit->size());
+        vit->resize(mMaxWeights);
+        removed += static_cast<unsigned int>(m - vit->size());
 
         // and renormalize the weights
         float sum = 0.0f;
-        for( std::vector<Weight>::const_iterator it = vit->begin(); it != vit->end(); ++it ) {
+        for(const Weight* it = vit->begin(); it != vit->end(); ++it) {
             sum += it->mWeight;
         }
-        if( 0.0f != sum ) {
+        if (0.0f != sum) {
             const float invSum = 1.0f / sum;
-            for( std::vector<Weight>::iterator it = vit->begin(); it != vit->end(); ++it ) {
+            for(Weight* it = vit->begin(); it != vit->end(); ++it) {
                 it->mWeight *= invSum;
             }
         }
     }
 
-    if (bChanged)   {
-        // rebuild the vertex weight array for all bones
-        typedef std::vector< std::vector< aiVertexWeight > > WeightsPerBone;
-        WeightsPerBone boneWeights( pMesh->mNumBones);
-        for( unsigned int a = 0; a < vertexWeights.size(); a++)
+    // clear weight count for all bone
+    for (unsigned int a = 0; a < pMesh->mNumBones; ++a)
+    {
+        pMesh->mBones[a]->mNumWeights = 0;
+    }
+
+    // rebuild the vertex weight array for all bones
+    for (unsigned int a = 0; a < vertexWeights.size(); ++a)
+    {
+        const VertexWeightArray& vw = vertexWeights[a];
+        for (const Weight* it = vw.begin(); it != vw.end(); ++it)
         {
-            const std::vector<Weight>& vw = vertexWeights[a];
-            for( std::vector<Weight>::const_iterator it = vw.begin(); it != vw.end(); ++it)
-                boneWeights[it->mBone].push_back( aiVertexWeight( a, it->mWeight));
-        }
-
-        // and finally copy the vertex weight list over to the mesh's bones
-        std::vector<bool> abNoNeed(pMesh->mNumBones,false);
-        bChanged = false;
-
-        for( unsigned int a = 0; a < pMesh->mNumBones; a++)
-        {
-            const std::vector<aiVertexWeight>& bw = boneWeights[a];
-            aiBone* bone = pMesh->mBones[a];
-
-            if ( bw.empty() )
-            {
-                abNoNeed[a] = bChanged = true;
-                continue;
-            }
-
-            // copy the weight list. should always be less weights than before, so we don't need a new allocation
-            ai_assert( bw.size() <= bone->mNumWeights);
-            bone->mNumWeights = static_cast<unsigned int>( bw.size() );
-            ::memcpy( bone->mWeights, &bw[0], bw.size() * sizeof( aiVertexWeight));
-        }
-
-        if (bChanged)   {
-            // the number of new bones is smaller than before, so we can reuse the old array
-            aiBone** ppcCur = pMesh->mBones;aiBone** ppcSrc = ppcCur;
-
-            for (std::vector<bool>::const_iterator iter  = abNoNeed.begin();iter != abNoNeed.end()  ;++iter)    {
-                if (*iter)  {
-                    delete *ppcSrc;
-                    --pMesh->mNumBones;
-                }
-                else *ppcCur++ = *ppcSrc;
-                ++ppcSrc;
-            }
-        }
-
-        if (!DefaultLogger::isNullLogger()) {
-            ASSIMP_LOG_INFO_F("Removed ", removed, " weights. Input bones: ", old_bones, ". Output bones: ", pMesh->mNumBones );
+            aiBone* bone = pMesh->mBones[it->mBone];
+            bone->mWeights[bone->mNumWeights++] = aiVertexWeight(a, it->mWeight);
         }
     }
+
+    // remove empty bones
+    unsigned int writeBone = 0;
+
+    for (unsigned int readBone = 0; readBone< pMesh->mNumBones; ++readBone)
+    {
+        aiBone* bone = pMesh->mBones[readBone];
+        if (bone->mNumWeights > 0)
+        {
+            pMesh->mBones[writeBone++] = bone;
+        }
+        else
+        {
+            delete bone;
+        }
+    }
+    pMesh->mNumBones = writeBone;
+
+    if (!DefaultLogger::isNullLogger()) {
+        ASSIMP_LOG_INFO("Removed ", removed, " weights. Input bones: ", old_bones, ". Output bones: ", pMesh->mNumBones);
+    }
 }
diff --git a/Engine/lib/assimp/code/PostProcessing/LimitBoneWeightsProcess.h b/Engine/lib/assimp/code/PostProcessing/LimitBoneWeightsProcess.h
index 73c2a68d5..22d286b68 100644
--- a/Engine/lib/assimp/code/PostProcessing/LimitBoneWeightsProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/LimitBoneWeightsProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/MakeVerboseFormat.cpp b/Engine/lib/assimp/code/PostProcessing/MakeVerboseFormat.cpp
index 41f50a5ba..75e2a0f06 100644
--- a/Engine/lib/assimp/code/PostProcessing/MakeVerboseFormat.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/MakeVerboseFormat.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -43,7 +43,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Implementation of the post processing step "MakeVerboseFormat"
 */
 
-
 #include "MakeVerboseFormat.h"
 #include <assimp/scene.h>
 #include <assimp/DefaultLogger.hpp>
@@ -51,26 +50,22 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 using namespace Assimp;
 
 // ------------------------------------------------------------------------------------------------
-MakeVerboseFormatProcess::MakeVerboseFormatProcess()
-{
+MakeVerboseFormatProcess::MakeVerboseFormatProcess() {
     // nothing to do here
 }
 // ------------------------------------------------------------------------------------------------
-MakeVerboseFormatProcess::~MakeVerboseFormatProcess()
-{
+MakeVerboseFormatProcess::~MakeVerboseFormatProcess() {
     // nothing to do here
 }
 // ------------------------------------------------------------------------------------------------
 // Executes the post processing step on the given imported data.
-void MakeVerboseFormatProcess::Execute( aiScene* pScene)
-{
-    ai_assert(NULL != pScene);
+void MakeVerboseFormatProcess::Execute(aiScene *pScene) {
+    ai_assert(nullptr != pScene);
     ASSIMP_LOG_DEBUG("MakeVerboseFormatProcess begin");
 
     bool bHas = false;
-    for( unsigned int a = 0; a < pScene->mNumMeshes; a++)
-    {
-        if( MakeVerboseFormat( pScene->mMeshes[a]))
+    for (unsigned int a = 0; a < pScene->mNumMeshes; a++) {
+        if (MakeVerboseFormat(pScene->mMeshes[a]))
             bHas = true;
     }
     if (bHas) {
@@ -84,29 +79,26 @@ void MakeVerboseFormatProcess::Execute( aiScene* pScene)
 
 // ------------------------------------------------------------------------------------------------
 // Executes the post processing step on the given imported data.
-bool MakeVerboseFormatProcess::MakeVerboseFormat(aiMesh* pcMesh)
-{
-    ai_assert(NULL != pcMesh);
+bool MakeVerboseFormatProcess::MakeVerboseFormat(aiMesh *pcMesh) {
+    ai_assert(nullptr != pcMesh);
 
     unsigned int iOldNumVertices = pcMesh->mNumVertices;
-    const unsigned int iNumVerts = pcMesh->mNumFaces*3;
+    const unsigned int iNumVerts = pcMesh->mNumFaces * 3;
 
-    aiVector3D* pvPositions = new aiVector3D[ iNumVerts ];
+    aiVector3D *pvPositions = new aiVector3D[iNumVerts];
 
-    aiVector3D* pvNormals = NULL;
-    if (pcMesh->HasNormals())
-    {
+    aiVector3D *pvNormals = nullptr;
+    if (pcMesh->HasNormals()) {
         pvNormals = new aiVector3D[iNumVerts];
     }
-    aiVector3D* pvTangents = NULL, *pvBitangents = NULL;
-    if (pcMesh->HasTangentsAndBitangents())
-    {
+    aiVector3D *pvTangents = nullptr, *pvBitangents = nullptr;
+    if (pcMesh->HasTangentsAndBitangents()) {
         pvTangents = new aiVector3D[iNumVerts];
         pvBitangents = new aiVector3D[iNumVerts];
     }
 
-    aiVector3D* apvTextureCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS] = {0};
-    aiColor4D* apvColorSets[AI_MAX_NUMBER_OF_COLOR_SETS] = {0};
+    aiVector3D *apvTextureCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS] = { 0 };
+    aiColor4D *apvColorSets[AI_MAX_NUMBER_OF_COLOR_SETS] = { 0 };
 
     unsigned int p = 0;
     while (pcMesh->HasTextureCoords(p))
@@ -117,26 +109,21 @@ bool MakeVerboseFormatProcess::MakeVerboseFormat(aiMesh* pcMesh)
         apvColorSets[p++] = new aiColor4D[iNumVerts];
 
     // allocate enough memory to hold output bones and vertex weights ...
-    std::vector<aiVertexWeight>* newWeights = new std::vector<aiVertexWeight>[pcMesh->mNumBones];
-    for (unsigned int i = 0;i < pcMesh->mNumBones;++i) {
-        newWeights[i].reserve(pcMesh->mBones[i]->mNumWeights*3);
+    std::vector<aiVertexWeight> *newWeights = new std::vector<aiVertexWeight>[pcMesh->mNumBones];
+    for (unsigned int i = 0; i < pcMesh->mNumBones; ++i) {
+        newWeights[i].reserve(pcMesh->mBones[i]->mNumWeights * 3);
     }
 
     // iterate through all faces and build a clean list
     unsigned int iIndex = 0;
-    for (unsigned int a = 0; a< pcMesh->mNumFaces;++a)
-    {
-        aiFace* pcFace = &pcMesh->mFaces[a];
-        for (unsigned int q = 0; q < pcFace->mNumIndices;++q,++iIndex)
-        {
+    for (unsigned int a = 0; a < pcMesh->mNumFaces; ++a) {
+        aiFace *pcFace = &pcMesh->mFaces[a];
+        for (unsigned int q = 0; q < pcFace->mNumIndices; ++q, ++iIndex) {
             // need to build a clean list of bones, too
-            for (unsigned int i = 0;i < pcMesh->mNumBones;++i)
-            {
-                for (unsigned int a = 0;  a < pcMesh->mBones[i]->mNumWeights;a++)
-                {
-                    const aiVertexWeight& w = pcMesh->mBones[i]->mWeights[a];
-                    if(pcFace->mIndices[q] == w.mVertexId)
-                    {
+            for (unsigned int i = 0; i < pcMesh->mNumBones; ++i) {
+                for (unsigned int boneIdx = 0; boneIdx < pcMesh->mBones[i]->mNumWeights; ++boneIdx) {
+                    const aiVertexWeight &w = pcMesh->mBones[i]->mWeights[boneIdx];
+                    if (pcFace->mIndices[q] == w.mVertexId) {
                         aiVertexWeight wNew;
                         wNew.mVertexId = iIndex;
                         wNew.mWeight = w.mWeight;
@@ -147,45 +134,39 @@ bool MakeVerboseFormatProcess::MakeVerboseFormat(aiMesh* pcMesh)
 
             pvPositions[iIndex] = pcMesh->mVertices[pcFace->mIndices[q]];
 
-            if (pcMesh->HasNormals())
-            {
+            if (pcMesh->HasNormals()) {
                 pvNormals[iIndex] = pcMesh->mNormals[pcFace->mIndices[q]];
             }
-            if (pcMesh->HasTangentsAndBitangents())
-            {
+            if (pcMesh->HasTangentsAndBitangents()) {
                 pvTangents[iIndex] = pcMesh->mTangents[pcFace->mIndices[q]];
                 pvBitangents[iIndex] = pcMesh->mBitangents[pcFace->mIndices[q]];
             }
 
-            unsigned int p = 0;
-            while (pcMesh->HasTextureCoords(p))
-            {
-                apvTextureCoords[p][iIndex] = pcMesh->mTextureCoords[p][pcFace->mIndices[q]];
-                ++p;
+            unsigned int pp = 0;
+            while (pcMesh->HasTextureCoords(pp)) {
+                apvTextureCoords[pp][iIndex] = pcMesh->mTextureCoords[pp][pcFace->mIndices[q]];
+                ++pp;
             }
-            p = 0;
-            while (pcMesh->HasVertexColors(p))
-            {
-                apvColorSets[p][iIndex] = pcMesh->mColors[p][pcFace->mIndices[q]];
-                ++p;
+            pp = 0;
+            while (pcMesh->HasVertexColors(pp)) {
+                apvColorSets[pp][iIndex] = pcMesh->mColors[pp][pcFace->mIndices[q]];
+                ++pp;
             }
             pcFace->mIndices[q] = iIndex;
         }
     }
 
-
-
     // build output vertex weights
-    for (unsigned int i = 0;i < pcMesh->mNumBones;++i)
-    {
-        delete [] pcMesh->mBones[i]->mWeights;
+    for (unsigned int i = 0; i < pcMesh->mNumBones; ++i) {
+        delete[] pcMesh->mBones[i]->mWeights;
         if (!newWeights[i].empty()) {
             pcMesh->mBones[i]->mWeights = new aiVertexWeight[newWeights[i].size()];
-            aiVertexWeight *weightToCopy = &( newWeights[i][0] );
+            pcMesh->mBones[i]->mNumWeights = static_cast<unsigned int>(newWeights[i].size());
+            aiVertexWeight *weightToCopy = &(newWeights[i][0]);
             memcpy(pcMesh->mBones[i]->mWeights, weightToCopy,
-                sizeof(aiVertexWeight) * newWeights[i].size());
+                    sizeof(aiVertexWeight) * newWeights[i].size());
         } else {
-            pcMesh->mBones[i]->mWeights = NULL;
+            pcMesh->mBones[i]->mWeights = nullptr;
         }
     }
     delete[] newWeights;
@@ -195,28 +176,24 @@ bool MakeVerboseFormatProcess::MakeVerboseFormat(aiMesh* pcMesh)
     pcMesh->mVertices = pvPositions;
 
     p = 0;
-    while (pcMesh->HasTextureCoords(p))
-    {
+    while (pcMesh->HasTextureCoords(p)) {
         delete[] pcMesh->mTextureCoords[p];
         pcMesh->mTextureCoords[p] = apvTextureCoords[p];
         ++p;
     }
     p = 0;
-    while (pcMesh->HasVertexColors(p))
-    {
+    while (pcMesh->HasVertexColors(p)) {
         delete[] pcMesh->mColors[p];
         pcMesh->mColors[p] = apvColorSets[p];
         ++p;
     }
     pcMesh->mNumVertices = iNumVerts;
 
-    if (pcMesh->HasNormals())
-    {
+    if (pcMesh->HasNormals()) {
         delete[] pcMesh->mNormals;
         pcMesh->mNormals = pvNormals;
     }
-    if (pcMesh->HasTangentsAndBitangents())
-    {
+    if (pcMesh->HasTangentsAndBitangents()) {
         delete[] pcMesh->mTangents;
         pcMesh->mTangents = pvTangents;
         delete[] pcMesh->mBitangents;
@@ -225,15 +202,14 @@ bool MakeVerboseFormatProcess::MakeVerboseFormat(aiMesh* pcMesh)
     return (pcMesh->mNumVertices != iOldNumVertices);
 }
 
-
 // ------------------------------------------------------------------------------------------------
-bool IsMeshInVerboseFormat(const aiMesh* mesh) {
+bool IsMeshInVerboseFormat(const aiMesh *mesh) {
     // avoid slow vector<bool> specialization
-    std::vector<unsigned int> seen(mesh->mNumVertices,0);
-    for(unsigned int i = 0; i < mesh->mNumFaces; ++i) {
-        const aiFace& f = mesh->mFaces[i];
-        for(unsigned int j = 0; j < f.mNumIndices; ++j) {
-            if(++seen[f.mIndices[j]] == 2) {
+    std::vector<unsigned int> seen(mesh->mNumVertices, 0);
+    for (unsigned int i = 0; i < mesh->mNumFaces; ++i) {
+        const aiFace &f = mesh->mFaces[i];
+        for (unsigned int j = 0; j < f.mNumIndices; ++j) {
+            if (++seen[f.mIndices[j]] == 2) {
                 // found a duplicate index
                 return false;
             }
@@ -244,9 +220,9 @@ bool IsMeshInVerboseFormat(const aiMesh* mesh) {
 }
 
 // ------------------------------------------------------------------------------------------------
-bool MakeVerboseFormatProcess::IsVerboseFormat(const aiScene* pScene) {
-    for(unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
-        if(!IsMeshInVerboseFormat(pScene->mMeshes[i])) {
+bool MakeVerboseFormatProcess::IsVerboseFormat(const aiScene *pScene) {
+    for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
+        if (!IsMeshInVerboseFormat(pScene->mMeshes[i])) {
             return false;
         }
     }
diff --git a/Engine/lib/assimp/code/PostProcessing/MakeVerboseFormat.h b/Engine/lib/assimp/code/PostProcessing/MakeVerboseFormat.h
index 8565d5933..6b81da622 100644
--- a/Engine/lib/assimp/code/PostProcessing/MakeVerboseFormat.h
+++ b/Engine/lib/assimp/code/PostProcessing/MakeVerboseFormat.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -98,7 +98,7 @@ public:
 
     // -------------------------------------------------------------------
     /** Checks whether the scene is already in verbose format.
-    * @param pScene The data to check. 
+    * @param pScene The data to check.
     * @return true if the scene is already in verbose format. */
     static bool IsVerboseFormat(const aiScene* pScene);
 
diff --git a/Engine/lib/assimp/code/PostProcessing/OptimizeGraph.cpp b/Engine/lib/assimp/code/PostProcessing/OptimizeGraph.cpp
index 5db51f58b..ea44eb3c1 100644
--- a/Engine/lib/assimp/code/PostProcessing/OptimizeGraph.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/OptimizeGraph.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,13 +43,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Implementation of the aiProcess_OptimizGraph step
  */
 
-
 #ifndef ASSIMP_BUILD_NO_OPTIMIZEGRAPH_PROCESS
 
 #include "OptimizeGraph.h"
 #include "ProcessHelper.h"
-#include <assimp/SceneCombiner.h>
+#include "ConvertToLHProcess.h"
 #include <assimp/Exceptional.h>
+#include <assimp/SceneCombiner.h>
 #include <stdio.h>
 
 using namespace Assimp;
@@ -60,292 +60,299 @@ using namespace Assimp;
  * The unhashed variant should be faster, except for *very* large data sets
  */
 #ifdef AI_OG_USE_HASHING
-    // Use our standard hashing function to compute the hash
-#   define AI_OG_GETKEY(str) SuperFastHash(str.data,str.length)
+// Use our standard hashing function to compute the hash
+#define AI_OG_GETKEY(str) SuperFastHash(str.data, str.length)
 #else
-    // Otherwise hope that std::string will utilize a static buffer
-    // for shorter node names. This would avoid endless heap copying.
-#   define AI_OG_GETKEY(str) std::string(str.data)
+// Otherwise hope that std::string will utilize a static buffer
+// for shorter node names. This would avoid endless heap copying.
+#define AI_OG_GETKEY(str) std::string(str.data)
 #endif
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-OptimizeGraphProcess::OptimizeGraphProcess()
-: mScene()
-, nodes_in()
-, nodes_out()
-, count_merged() {
-    // empty
+OptimizeGraphProcess::OptimizeGraphProcess() :
+		mScene(),
+		nodes_in(),
+		nodes_out(),
+		count_merged() {
+	// empty
 }
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
 OptimizeGraphProcess::~OptimizeGraphProcess() {
-    // empty
+	// empty
 }
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the processing step is present in the given flag field.
-bool OptimizeGraphProcess::IsActive( unsigned int pFlags) const {
-    return (0 != (pFlags & aiProcess_OptimizeGraph));
+bool OptimizeGraphProcess::IsActive(unsigned int pFlags) const {
+	return (0 != (pFlags & aiProcess_OptimizeGraph));
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup properties for the post-processing step
-void OptimizeGraphProcess::SetupProperties(const Importer* pImp) {
-    // Get value of AI_CONFIG_PP_OG_EXCLUDE_LIST
-    std::string tmp = pImp->GetPropertyString(AI_CONFIG_PP_OG_EXCLUDE_LIST,"");
-    AddLockedNodeList(tmp);
+void OptimizeGraphProcess::SetupProperties(const Importer *pImp) {
+	// Get value of AI_CONFIG_PP_OG_EXCLUDE_LIST
+	std::string tmp = pImp->GetPropertyString(AI_CONFIG_PP_OG_EXCLUDE_LIST, "");
+	AddLockedNodeList(tmp);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Collect new children
-void OptimizeGraphProcess::CollectNewChildren(aiNode* nd, std::list<aiNode*>& nodes) {
-    nodes_in += nd->mNumChildren;
+void OptimizeGraphProcess::CollectNewChildren(aiNode *nd, std::list<aiNode *> &nodes) {
+	nodes_in += nd->mNumChildren;
 
-    // Process children
-    std::list<aiNode*> child_nodes;
-    for (unsigned int i = 0; i < nd->mNumChildren; ++i) {
-        CollectNewChildren(nd->mChildren[i],child_nodes);
-        nd->mChildren[i] = nullptr;
-    }
+	// Process children
+	std::list<aiNode *> child_nodes;
+	for (unsigned int i = 0; i < nd->mNumChildren; ++i) {
+		CollectNewChildren(nd->mChildren[i], child_nodes);
+		nd->mChildren[i] = nullptr;
+	}
 
-    // Check whether we need this node; if not we can replace it by our own children (warn, danger of incest).
-    if (locked.find(AI_OG_GETKEY(nd->mName)) == locked.end() ) {
-        for (std::list<aiNode*>::iterator it = child_nodes.begin(); it != child_nodes.end();) {
+	// Check whether we need this node; if not we can replace it by our own children (warn, danger of incest).
+	if (locked.find(AI_OG_GETKEY(nd->mName)) == locked.end()) {
+		for (std::list<aiNode *>::iterator it = child_nodes.begin(); it != child_nodes.end();) {
 
-            if (locked.find(AI_OG_GETKEY((*it)->mName)) == locked.end()) {
-                (*it)->mTransformation = nd->mTransformation * (*it)->mTransformation;
-                nodes.push_back(*it);
+			if (locked.find(AI_OG_GETKEY((*it)->mName)) == locked.end()) {
+				(*it)->mTransformation = nd->mTransformation * (*it)->mTransformation;
+				nodes.push_back(*it);
 
-                it = child_nodes.erase(it);
-                continue;
-            }
-            ++it;
-        }
+				it = child_nodes.erase(it);
+				continue;
+			}
+			++it;
+		}
 
-        if (nd->mNumMeshes || !child_nodes.empty()) {
-            nodes.push_back(nd);
-        } else {
-            delete nd; /* bye, node */
-            return;
-        }
-    } else {
+		if (nd->mNumMeshes || !child_nodes.empty()) {
+			nodes.push_back(nd);
+		} else {
+			delete nd; /* bye, node */
+			return;
+		}
+	} else {
 
-        // Retain our current position in the hierarchy
-        nodes.push_back(nd);
+		// Retain our current position in the hierarchy
+		nodes.push_back(nd);
 
-        // Now check for possible optimizations in our list of child nodes. join as many as possible
-        aiNode* join_master = NULL;
-        aiMatrix4x4 inv;
+		// Now check for possible optimizations in our list of child nodes. join as many as possible
+		aiNode *join_master = nullptr;
+		aiMatrix4x4 inv;
 
-        const LockedSetType::const_iterator end = locked.end();
+		const LockedSetType::const_iterator end = locked.end();
 
-        std::list<aiNode*> join;
-        for (std::list<aiNode*>::iterator it = child_nodes.begin(); it != child_nodes.end();)   {
-            aiNode* child = *it;
-            if (child->mNumChildren == 0 && locked.find(AI_OG_GETKEY(child->mName)) == end) {
+		std::list<aiNode *> join;
+		for (std::list<aiNode *>::iterator it = child_nodes.begin(); it != child_nodes.end();) {
+			aiNode *child = *it;
+			if (child->mNumChildren == 0 && locked.find(AI_OG_GETKEY(child->mName)) == end) {
 
-                // There may be no instanced meshes
-                unsigned int n = 0;
-                for (; n < child->mNumMeshes;++n) {
-                    if (meshes[child->mMeshes[n]] > 1) {
-                        break;
-                    }
-                }
-                if (n == child->mNumMeshes) {
-                    if (!join_master) {
-                        join_master = child;
-                        inv = join_master->mTransformation;
-                        inv.Inverse();
-                    } else {
-                        child->mTransformation = inv * child->mTransformation ;
+				// There may be no instanced meshes
+				unsigned int n = 0;
+				for (; n < child->mNumMeshes; ++n) {
+					if (meshes[child->mMeshes[n]] > 1) {
+						break;
+					}
+				}
+				if (n == child->mNumMeshes) {
+					if (!join_master) {
+						join_master = child;
+						inv = join_master->mTransformation;
+						inv.Inverse();
+					} else {
+						child->mTransformation = inv * child->mTransformation;
 
-                        join.push_back(child);
-                        it = child_nodes.erase(it);
-                        continue;
-                    }
-                }
-            }
-            ++it;
-        }
-        if (join_master && !join.empty()) {
-            join_master->mName.length = ::ai_snprintf(join_master->mName.data, MAXLEN, "$MergedNode_%i",count_merged++);
+						join.push_back(child);
+						it = child_nodes.erase(it);
+						continue;
+					}
+				}
+			}
+			++it;
+		}
+		if (join_master && !join.empty()) {
+			join_master->mName.length = ::ai_snprintf(join_master->mName.data, MAXLEN, "$MergedNode_%u", count_merged++);
 
-            unsigned int out_meshes = 0;
-            for (std::list<aiNode*>::iterator it = join.begin(); it != join.end(); ++it) {
-                out_meshes += (*it)->mNumMeshes;
-            }
+			unsigned int out_meshes = 0;
+			for (std::list<aiNode *>::const_iterator it = join.cbegin(); it != join.cend(); ++it) {
+				out_meshes += (*it)->mNumMeshes;
+			}
 
-            // copy all mesh references in one array
-            if (out_meshes) {
-                unsigned int* meshes = new unsigned int[out_meshes+join_master->mNumMeshes], *tmp = meshes;
-                for (unsigned int n = 0; n < join_master->mNumMeshes;++n) {
-                    *tmp++ = join_master->mMeshes[n];
-                }
+			// copy all mesh references in one array
+			if (out_meshes) {
+				unsigned int *meshIdxs = new unsigned int[out_meshes + join_master->mNumMeshes], *tmp = meshIdxs;
+				for (unsigned int n = 0; n < join_master->mNumMeshes; ++n) {
+					*tmp++ = join_master->mMeshes[n];
+				}
 
-                for (std::list<aiNode*>::iterator it = join.begin(); it != join.end(); ++it) {
-                    for (unsigned int n = 0; n < (*it)->mNumMeshes; ++n) {
+				for (const aiNode *join_node : join) {
+					for (unsigned int n = 0; n < join_node->mNumMeshes; ++n) {
 
-                        *tmp = (*it)->mMeshes[n];
-                        aiMesh* mesh = mScene->mMeshes[*tmp++];
+						*tmp = join_node->mMeshes[n];
+						aiMesh *mesh = mScene->mMeshes[*tmp++];
 
-                        // manually move the mesh into the right coordinate system
-                        const aiMatrix3x3 IT = aiMatrix3x3( (*it)->mTransformation ).Inverse().Transpose();
-                        for (unsigned int a = 0; a < mesh->mNumVertices; ++a) {
+						// Assume the transformation is affine
+						// manually move the mesh into the right coordinate system
 
-                            mesh->mVertices[a] *= (*it)->mTransformation;
+						// Check for odd negative scale (mirror)
+						if (join_node->mTransformation.Determinant() < 0) {
+							// Reverse the mesh face winding order
+                            FlipWindingOrderProcess::ProcessMesh(mesh);
+						}
 
-                            if (mesh->HasNormals())
-                                mesh->mNormals[a] *= IT;
+                        // Update positions, normals and tangents
+						const aiMatrix3x3 IT = aiMatrix3x3(join_node->mTransformation).Inverse().Transpose();
+						for (unsigned int a = 0; a < mesh->mNumVertices; ++a) {
 
-                            if (mesh->HasTangentsAndBitangents()) {
-                                mesh->mTangents[a] *= IT;
-                                mesh->mBitangents[a] *= IT;
-                            }
-                        }
-                    }
-                    delete *it; // bye, node
-                }
-                delete[] join_master->mMeshes;
-                join_master->mMeshes = meshes;
-                join_master->mNumMeshes += out_meshes;
-            }
-        }
-    }
-    // reassign children if something changed
-    if (child_nodes.empty() || child_nodes.size() > nd->mNumChildren) {
+							mesh->mVertices[a] *= join_node->mTransformation;
 
-        delete[] nd->mChildren;
+							if (mesh->HasNormals())
+								mesh->mNormals[a] *= IT;
 
-        if (!child_nodes.empty()) {
-            nd->mChildren = new aiNode*[child_nodes.size()];
-        }
-        else nd->mChildren = nullptr;
-    }
+							if (mesh->HasTangentsAndBitangents()) {
+								mesh->mTangents[a] *= IT;
+								mesh->mBitangents[a] *= IT;
+							}
+						}
+					}
+					delete join_node; // bye, node
+				}
+				delete[] join_master->mMeshes;
+				join_master->mMeshes = meshIdxs;
+				join_master->mNumMeshes += out_meshes;
+			}
+		}
+	}
+	// reassign children if something changed
+	if (child_nodes.empty() || child_nodes.size() > nd->mNumChildren) {
 
-    nd->mNumChildren = static_cast<unsigned int>(child_nodes.size());
+		delete[] nd->mChildren;
 
-    if (nd->mChildren) {
-        aiNode** tmp = nd->mChildren;
-        for (std::list<aiNode*>::iterator it = child_nodes.begin(); it != child_nodes.end(); ++it) {
-            aiNode* node = *tmp++ = *it;
-            node->mParent = nd;
-        }
-    }
+		if (!child_nodes.empty()) {
+			nd->mChildren = new aiNode *[child_nodes.size()];
+		} else
+			nd->mChildren = nullptr;
+	}
 
-    nodes_out += static_cast<unsigned int>(child_nodes.size());
+	nd->mNumChildren = static_cast<unsigned int>(child_nodes.size());
+
+	if (nd->mChildren) {
+		aiNode **tmp = nd->mChildren;
+		for (std::list<aiNode *>::iterator it = child_nodes.begin(); it != child_nodes.end(); ++it) {
+			aiNode *node = *tmp++ = *it;
+			node->mParent = nd;
+		}
+	}
+
+	nodes_out += static_cast<unsigned int>(child_nodes.size());
 }
 
 // ------------------------------------------------------------------------------------------------
 // Execute the post-processing step on the given scene
-void OptimizeGraphProcess::Execute( aiScene* pScene) {
-    ASSIMP_LOG_DEBUG("OptimizeGraphProcess begin");
-    nodes_in = nodes_out = count_merged = 0;
-    mScene = pScene;
+void OptimizeGraphProcess::Execute(aiScene *pScene) {
+	ASSIMP_LOG_DEBUG("OptimizeGraphProcess begin");
+	nodes_in = nodes_out = count_merged = 0;
+	mScene = pScene;
 
-    meshes.resize(pScene->mNumMeshes,0);
-    FindInstancedMeshes(pScene->mRootNode);
+	meshes.resize(pScene->mNumMeshes, 0);
+	FindInstancedMeshes(pScene->mRootNode);
 
-    // build a blacklist of identifiers. If the name of a node matches one of these, we won't touch it
-    locked.clear();
-    for (std::list<std::string>::const_iterator it = locked_nodes.begin(); it != locked_nodes.end(); ++it) {
+	// build a blacklist of identifiers. If the name of a node matches one of these, we won't touch it
+	locked.clear();
+	for (std::list<std::string>::const_iterator it = locked_nodes.begin(); it != locked_nodes.end(); ++it) {
 #ifdef AI_OG_USE_HASHING
-        locked.insert(SuperFastHash((*it).c_str()));
+		locked.insert(SuperFastHash((*it).c_str()));
 #else
-        locked.insert(*it);
+		locked.insert(*it);
 #endif
-    }
+	}
 
-    for (unsigned int i = 0; i < pScene->mNumAnimations; ++i) {
-        for (unsigned int a = 0; a < pScene->mAnimations[i]->mNumChannels; ++a) {
-            aiNodeAnim* anim = pScene->mAnimations[i]->mChannels[a];
-            locked.insert(AI_OG_GETKEY(anim->mNodeName));
-        }
-    }
+	for (unsigned int i = 0; i < pScene->mNumAnimations; ++i) {
+		for (unsigned int a = 0; a < pScene->mAnimations[i]->mNumChannels; ++a) {
+			aiNodeAnim *anim = pScene->mAnimations[i]->mChannels[a];
+			locked.insert(AI_OG_GETKEY(anim->mNodeName));
+		}
+	}
 
-    for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
-        for (unsigned int a = 0; a < pScene->mMeshes[i]->mNumBones; ++a) {
+	for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
+		for (unsigned int a = 0; a < pScene->mMeshes[i]->mNumBones; ++a) {
 
-            aiBone* bone = pScene->mMeshes[i]->mBones[a];
-            locked.insert(AI_OG_GETKEY(bone->mName));
+			aiBone *bone = pScene->mMeshes[i]->mBones[a];
+			locked.insert(AI_OG_GETKEY(bone->mName));
 
-            // HACK: Meshes referencing bones may not be transformed; we need to look them.
-            // The easiest way to do this is to increase their reference counters ...
-            meshes[i] += 2;
-        }
-    }
+			// HACK: Meshes referencing bones may not be transformed; we need to look them.
+			// The easiest way to do this is to increase their reference counters ...
+			meshes[i] += 2;
+		}
+	}
 
-    for (unsigned int i = 0; i < pScene->mNumCameras; ++i) {
-        aiCamera* cam = pScene->mCameras[i];
-        locked.insert(AI_OG_GETKEY(cam->mName));
-    }
+	for (unsigned int i = 0; i < pScene->mNumCameras; ++i) {
+		aiCamera *cam = pScene->mCameras[i];
+		locked.insert(AI_OG_GETKEY(cam->mName));
+	}
 
-    for (unsigned int i = 0; i < pScene->mNumLights; ++i) {
-        aiLight* lgh = pScene->mLights[i];
-        locked.insert(AI_OG_GETKEY(lgh->mName));
-    }
+	for (unsigned int i = 0; i < pScene->mNumLights; ++i) {
+		aiLight *lgh = pScene->mLights[i];
+		locked.insert(AI_OG_GETKEY(lgh->mName));
+	}
 
-    // Insert a dummy master node and make it read-only
-    aiNode* dummy_root = new aiNode(AI_RESERVED_NODE_NAME);
-    locked.insert(AI_OG_GETKEY(dummy_root->mName));
+	// Insert a dummy master node and make it read-only
+	aiNode *dummy_root = new aiNode(AI_RESERVED_NODE_NAME);
+	locked.insert(AI_OG_GETKEY(dummy_root->mName));
 
-    const aiString prev = pScene->mRootNode->mName;
-    pScene->mRootNode->mParent = dummy_root;
+	const aiString prev = pScene->mRootNode->mName;
+	pScene->mRootNode->mParent = dummy_root;
 
-    dummy_root->mChildren = new aiNode*[dummy_root->mNumChildren = 1];
-    dummy_root->mChildren[0] = pScene->mRootNode;
+	dummy_root->mChildren = new aiNode *[dummy_root->mNumChildren = 1];
+	dummy_root->mChildren[0] = pScene->mRootNode;
 
-    // Do our recursive processing of scenegraph nodes. For each node collect
-    // a fully new list of children and allow their children to place themselves
-    // on the same hierarchy layer as their parents.
-    std::list<aiNode*> nodes;
-    CollectNewChildren (dummy_root,nodes);
+	// Do our recursive processing of scenegraph nodes. For each node collect
+	// a fully new list of children and allow their children to place themselves
+	// on the same hierarchy layer as their parents.
+	std::list<aiNode *> nodes;
+	CollectNewChildren(dummy_root, nodes);
 
-    ai_assert(nodes.size() == 1);
+	ai_assert(nodes.size() == 1);
 
-    if (dummy_root->mNumChildren == 0) {
-        pScene->mRootNode = NULL;
-        throw DeadlyImportError("After optimizing the scene graph, no data remains");
-    }
+	if (dummy_root->mNumChildren == 0) {
+		pScene->mRootNode = nullptr;
+		throw DeadlyImportError("After optimizing the scene graph, no data remains");
+	}
 
-    if (dummy_root->mNumChildren > 1) {
-        pScene->mRootNode = dummy_root;
+	if (dummy_root->mNumChildren > 1) {
+		pScene->mRootNode = dummy_root;
 
-        // Keep the dummy node but assign the name of the old root node to it
-        pScene->mRootNode->mName = prev;
-    }
-    else {
+		// Keep the dummy node but assign the name of the old root node to it
+		pScene->mRootNode->mName = prev;
+	} else {
 
-        // Remove the dummy root node again.
-        pScene->mRootNode = dummy_root->mChildren[0];
+		// Remove the dummy root node again.
+		pScene->mRootNode = dummy_root->mChildren[0];
 
-        dummy_root->mChildren[0] = NULL;
-        delete dummy_root;
-    }
+		dummy_root->mChildren[0] = nullptr;
+		delete dummy_root;
+	}
 
-    pScene->mRootNode->mParent = NULL;
-    if (!DefaultLogger::isNullLogger()) {
-        if ( nodes_in != nodes_out) {
-            ASSIMP_LOG_INFO_F("OptimizeGraphProcess finished; Input nodes: ", nodes_in, ", Output nodes: ", nodes_out);
-        } else {
-            ASSIMP_LOG_DEBUG("OptimizeGraphProcess finished");
-        }
-    }
-    meshes.clear();
-    locked.clear();
+	pScene->mRootNode->mParent = nullptr;
+	if (!DefaultLogger::isNullLogger()) {
+		if (nodes_in != nodes_out) {
+			ASSIMP_LOG_INFO("OptimizeGraphProcess finished; Input nodes: ", nodes_in, ", Output nodes: ", nodes_out);
+		} else {
+			ASSIMP_LOG_DEBUG("OptimizeGraphProcess finished");
+		}
+	}
+	meshes.clear();
+	locked.clear();
 }
 
 // ------------------------------------------------------------------------------------------------
 // Build a LUT of all instanced meshes
-void OptimizeGraphProcess::FindInstancedMeshes (aiNode* pNode)
-{
-    for (unsigned int i = 0; i < pNode->mNumMeshes;++i) {
-        ++meshes[pNode->mMeshes[i]];
-    }
+void OptimizeGraphProcess::FindInstancedMeshes(aiNode *pNode) {
+	for (unsigned int i = 0; i < pNode->mNumMeshes; ++i) {
+		++meshes[pNode->mMeshes[i]];
+	}
 
-    for (unsigned int i = 0; i < pNode->mNumChildren; ++i)
-        FindInstancedMeshes(pNode->mChildren[i]);
+	for (unsigned int i = 0; i < pNode->mNumChildren; ++i)
+		FindInstancedMeshes(pNode->mChildren[i]);
 }
 
 #endif // !! ASSIMP_BUILD_NO_OPTIMIZEGRAPH_PROCESS
diff --git a/Engine/lib/assimp/code/PostProcessing/OptimizeGraph.h b/Engine/lib/assimp/code/PostProcessing/OptimizeGraph.h
index 82cc5db3f..f5caa139c 100644
--- a/Engine/lib/assimp/code/PostProcessing/OptimizeGraph.h
+++ b/Engine/lib/assimp/code/PostProcessing/OptimizeGraph.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -75,13 +75,13 @@ public:
     ~OptimizeGraphProcess();
 
     // -------------------------------------------------------------------
-    bool IsActive( unsigned int pFlags) const;
+    bool IsActive( unsigned int pFlags) const override;
 
     // -------------------------------------------------------------------
-    void Execute( aiScene* pScene);
+    void Execute( aiScene* pScene) override;
 
     // -------------------------------------------------------------------
-    void SetupProperties(const Importer* pImp);
+    void SetupProperties(const Importer* pImp) override;
 
     // -------------------------------------------------------------------
     /** @brief Add a list of node names to be locked and not modified.
diff --git a/Engine/lib/assimp/code/PostProcessing/OptimizeMeshes.cpp b/Engine/lib/assimp/code/PostProcessing/OptimizeMeshes.cpp
index 3f6765f6c..e624bb1cf 100644
--- a/Engine/lib/assimp/code/PostProcessing/OptimizeMeshes.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/OptimizeMeshes.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -151,7 +151,7 @@ void OptimizeMeshesProcess::Execute( aiScene* pScene)
     std::copy(output.begin(),output.end(),mScene->mMeshes);
 
     if (output.size() != num_old) {
-        ASSIMP_LOG_DEBUG_F("OptimizeMeshesProcess finished. Input meshes: ", num_old, ", Output meshes: ", pScene->mNumMeshes);
+        ASSIMP_LOG_DEBUG("OptimizeMeshesProcess finished. Input meshes: ", num_old, ", Output meshes: ", pScene->mNumMeshes);
     } else {
         ASSIMP_LOG_DEBUG( "OptimizeMeshesProcess finished" );
     }
diff --git a/Engine/lib/assimp/code/PostProcessing/OptimizeMeshes.h b/Engine/lib/assimp/code/PostProcessing/OptimizeMeshes.h
index dec4ab52d..b80f98d5d 100644
--- a/Engine/lib/assimp/code/PostProcessing/OptimizeMeshes.h
+++ b/Engine/lib/assimp/code/PostProcessing/OptimizeMeshes.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/PretransformVertices.cpp b/Engine/lib/assimp/code/PostProcessing/PretransformVertices.cpp
index 52001a057..ec7b8783e 100644
--- a/Engine/lib/assimp/code/PostProcessing/PretransformVertices.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/PretransformVertices.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -45,11 +45,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Implementation of the "PretransformVertices" post processing step
 */
 
-
 #include "PretransformVertices.h"
+#include "ConvertToLHProcess.h"
 #include "ProcessHelper.h"
-#include <assimp/SceneCombiner.h>
 #include <assimp/Exceptional.h>
+#include <assimp/SceneCombiner.h>
 
 using namespace Assimp;
 
@@ -59,670 +59,630 @@ using namespace Assimp;
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-PretransformVertices::PretransformVertices()
-: configKeepHierarchy (false)
-, configNormalize(false)
-, configTransform(false)
-, configTransformation()
-, mConfigPointCloud( false ) {
-    // empty
+PretransformVertices::PretransformVertices() :
+		configKeepHierarchy(false),
+		configNormalize(false),
+		configTransform(false),
+		configTransformation(),
+		mConfigPointCloud(false) {
+	// empty
 }
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
 PretransformVertices::~PretransformVertices() {
-    // nothing to do here
+	// nothing to do here
 }
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the processing step is present in the given flag field.
-bool PretransformVertices::IsActive( unsigned int pFlags) const
-{
-    return  (pFlags & aiProcess_PreTransformVertices) != 0;
+bool PretransformVertices::IsActive(unsigned int pFlags) const {
+	return (pFlags & aiProcess_PreTransformVertices) != 0;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup import configuration
-void PretransformVertices::SetupProperties(const Importer* pImp)
-{
-    // Get the current value of AI_CONFIG_PP_PTV_KEEP_HIERARCHY, AI_CONFIG_PP_PTV_NORMALIZE,
-    // AI_CONFIG_PP_PTV_ADD_ROOT_TRANSFORMATION and AI_CONFIG_PP_PTV_ROOT_TRANSFORMATION
-    configKeepHierarchy = (0 != pImp->GetPropertyInteger(AI_CONFIG_PP_PTV_KEEP_HIERARCHY,0));
-    configNormalize = (0 != pImp->GetPropertyInteger(AI_CONFIG_PP_PTV_NORMALIZE,0));
-    configTransform = (0 != pImp->GetPropertyInteger(AI_CONFIG_PP_PTV_ADD_ROOT_TRANSFORMATION,0));
+void PretransformVertices::SetupProperties(const Importer *pImp) {
+	// Get the current value of AI_CONFIG_PP_PTV_KEEP_HIERARCHY, AI_CONFIG_PP_PTV_NORMALIZE,
+	// AI_CONFIG_PP_PTV_ADD_ROOT_TRANSFORMATION and AI_CONFIG_PP_PTV_ROOT_TRANSFORMATION
+	configKeepHierarchy = (0 != pImp->GetPropertyInteger(AI_CONFIG_PP_PTV_KEEP_HIERARCHY, 0));
+	configNormalize = (0 != pImp->GetPropertyInteger(AI_CONFIG_PP_PTV_NORMALIZE, 0));
+	configTransform = (0 != pImp->GetPropertyInteger(AI_CONFIG_PP_PTV_ADD_ROOT_TRANSFORMATION, 0));
 
-    configTransformation = pImp->GetPropertyMatrix(AI_CONFIG_PP_PTV_ROOT_TRANSFORMATION, aiMatrix4x4());
+	configTransformation = pImp->GetPropertyMatrix(AI_CONFIG_PP_PTV_ROOT_TRANSFORMATION, aiMatrix4x4());
 
-    mConfigPointCloud = pImp->GetPropertyBool(AI_CONFIG_EXPORT_POINT_CLOUDS);
+	mConfigPointCloud = pImp->GetPropertyBool(AI_CONFIG_EXPORT_POINT_CLOUDS);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Count the number of nodes
-unsigned int PretransformVertices::CountNodes( aiNode* pcNode )
-{
-    unsigned int iRet = 1;
-    for (unsigned int i = 0;i < pcNode->mNumChildren;++i)
-    {
-        iRet += CountNodes(pcNode->mChildren[i]);
-    }
-    return iRet;
+unsigned int PretransformVertices::CountNodes(const aiNode *pcNode) const {
+	unsigned int iRet = 1;
+	for (unsigned int i = 0; i < pcNode->mNumChildren; ++i) {
+		iRet += CountNodes(pcNode->mChildren[i]);
+	}
+	return iRet;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get a bitwise combination identifying the vertex format of a mesh
-unsigned int PretransformVertices::GetMeshVFormat( aiMesh* pcMesh )
-{
-    // the vertex format is stored in aiMesh::mBones for later retrieval.
-    // there isn't a good reason to compute it a few hundred times
-    // from scratch. The pointer is unused as animations are lost
-    // during PretransformVertices.
-    if (pcMesh->mBones)
-        return (unsigned int)(uint64_t)pcMesh->mBones;
+unsigned int PretransformVertices::GetMeshVFormat(aiMesh *pcMesh) const {
+	// the vertex format is stored in aiMesh::mBones for later retrieval.
+	// there isn't a good reason to compute it a few hundred times
+	// from scratch. The pointer is unused as animations are lost
+	// during PretransformVertices.
+	if (pcMesh->mBones)
+		return (unsigned int)(uint64_t)pcMesh->mBones;
 
+	const unsigned int iRet = GetMeshVFormatUnique(pcMesh);
 
-    const unsigned int iRet = GetMeshVFormatUnique(pcMesh);
-
-    // store the value for later use
-    pcMesh->mBones = (aiBone**)(uint64_t)iRet;
-    return iRet;
+	// store the value for later use
+	pcMesh->mBones = (aiBone **)(uint64_t)iRet;
+	return iRet;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Count the number of vertices in the whole scene and a given
 // material index
-void PretransformVertices::CountVerticesAndFaces( aiScene* pcScene, aiNode* pcNode, unsigned int iMat,
-    unsigned int iVFormat, unsigned int* piFaces, unsigned int* piVertices)
-{
-    for (unsigned int i = 0; i < pcNode->mNumMeshes;++i)
-    {
-        aiMesh* pcMesh = pcScene->mMeshes[ pcNode->mMeshes[i] ];
-        if (iMat == pcMesh->mMaterialIndex && iVFormat == GetMeshVFormat(pcMesh))
-        {
-            *piVertices += pcMesh->mNumVertices;
-            *piFaces += pcMesh->mNumFaces;
-        }
-    }
-    for (unsigned int i = 0;i < pcNode->mNumChildren;++i)
-    {
-        CountVerticesAndFaces(pcScene,pcNode->mChildren[i],iMat,
-            iVFormat,piFaces,piVertices);
-    }
+void PretransformVertices::CountVerticesAndFaces(const aiScene *pcScene, const aiNode *pcNode, unsigned int iMat,
+		unsigned int iVFormat, unsigned int *piFaces, unsigned int *piVertices) const {
+	for (unsigned int i = 0; i < pcNode->mNumMeshes; ++i) {
+		aiMesh *pcMesh = pcScene->mMeshes[pcNode->mMeshes[i]];
+		if (iMat == pcMesh->mMaterialIndex && iVFormat == GetMeshVFormat(pcMesh)) {
+			*piVertices += pcMesh->mNumVertices;
+			*piFaces += pcMesh->mNumFaces;
+		}
+	}
+	for (unsigned int i = 0; i < pcNode->mNumChildren; ++i) {
+		CountVerticesAndFaces(pcScene, pcNode->mChildren[i], iMat,
+				iVFormat, piFaces, piVertices);
+	}
 }
 
 // ------------------------------------------------------------------------------------------------
 // Collect vertex/face data
-void PretransformVertices::CollectData( aiScene* pcScene, aiNode* pcNode, unsigned int iMat,
-    unsigned int iVFormat, aiMesh* pcMeshOut,
-    unsigned int aiCurrent[2], unsigned int* num_refs)
-{
-    // No need to multiply if there's no transformation
-    const bool identity = pcNode->mTransformation.IsIdentity();
-    for (unsigned int i = 0; i < pcNode->mNumMeshes;++i)
-    {
-        aiMesh* pcMesh = pcScene->mMeshes[ pcNode->mMeshes[i] ];
-        if (iMat == pcMesh->mMaterialIndex && iVFormat == GetMeshVFormat(pcMesh))
-        {
-            // Decrement mesh reference counter
-            unsigned int& num_ref = num_refs[pcNode->mMeshes[i]];
-            ai_assert(0 != num_ref);
-            --num_ref;
-            // Save the name of the last mesh
-            if (num_ref==0)
-            {
-                pcMeshOut->mName = pcMesh->mName;
-            }
+void PretransformVertices::CollectData(const aiScene *pcScene, const aiNode *pcNode, unsigned int iMat,
+		unsigned int iVFormat, aiMesh *pcMeshOut,
+		unsigned int aiCurrent[2], unsigned int *num_refs) const {
+	// No need to multiply if there's no transformation
+	const bool identity = pcNode->mTransformation.IsIdentity();
+	for (unsigned int i = 0; i < pcNode->mNumMeshes; ++i) {
+		aiMesh *pcMesh = pcScene->mMeshes[pcNode->mMeshes[i]];
+		if (iMat == pcMesh->mMaterialIndex && iVFormat == GetMeshVFormat(pcMesh)) {
+			// Decrement mesh reference counter
+			unsigned int &num_ref = num_refs[pcNode->mMeshes[i]];
+			ai_assert(0 != num_ref);
+			--num_ref;
+			// Save the name of the last mesh
+			if (num_ref == 0) {
+				pcMeshOut->mName = pcMesh->mName;
+			}
 
-            if (identity)   {
-                // copy positions without modifying them
-                ::memcpy(pcMeshOut->mVertices + aiCurrent[AI_PTVS_VERTEX],
-                    pcMesh->mVertices,
-                    pcMesh->mNumVertices * sizeof(aiVector3D));
+			if (identity) {
+				// copy positions without modifying them
+				::memcpy(pcMeshOut->mVertices + aiCurrent[AI_PTVS_VERTEX],
+						pcMesh->mVertices,
+						pcMesh->mNumVertices * sizeof(aiVector3D));
 
-                if (iVFormat & 0x2) {
-                    // copy normals without modifying them
-                    ::memcpy(pcMeshOut->mNormals + aiCurrent[AI_PTVS_VERTEX],
-                        pcMesh->mNormals,
-                        pcMesh->mNumVertices * sizeof(aiVector3D));
-                }
-                if (iVFormat & 0x4)
-                {
-                    // copy tangents without modifying them
-                    ::memcpy(pcMeshOut->mTangents + aiCurrent[AI_PTVS_VERTEX],
-                        pcMesh->mTangents,
-                        pcMesh->mNumVertices * sizeof(aiVector3D));
-                    // copy bitangents without modifying them
-                    ::memcpy(pcMeshOut->mBitangents + aiCurrent[AI_PTVS_VERTEX],
-                        pcMesh->mBitangents,
-                        pcMesh->mNumVertices * sizeof(aiVector3D));
-                }
-            }
-            else
-            {
-                // copy positions, transform them to worldspace
-                for (unsigned int n = 0; n < pcMesh->mNumVertices;++n)  {
-                    pcMeshOut->mVertices[aiCurrent[AI_PTVS_VERTEX]+n] = pcNode->mTransformation * pcMesh->mVertices[n];
-                }
-                aiMatrix4x4 mWorldIT = pcNode->mTransformation;
-                mWorldIT.Inverse().Transpose();
+				if (iVFormat & 0x2) {
+					// copy normals without modifying them
+					::memcpy(pcMeshOut->mNormals + aiCurrent[AI_PTVS_VERTEX],
+							pcMesh->mNormals,
+							pcMesh->mNumVertices * sizeof(aiVector3D));
+				}
+				if (iVFormat & 0x4) {
+					// copy tangents without modifying them
+					::memcpy(pcMeshOut->mTangents + aiCurrent[AI_PTVS_VERTEX],
+							pcMesh->mTangents,
+							pcMesh->mNumVertices * sizeof(aiVector3D));
+					// copy bitangents without modifying them
+					::memcpy(pcMeshOut->mBitangents + aiCurrent[AI_PTVS_VERTEX],
+							pcMesh->mBitangents,
+							pcMesh->mNumVertices * sizeof(aiVector3D));
+				}
+			} else {
+				// copy positions, transform them to worldspace
+				for (unsigned int n = 0; n < pcMesh->mNumVertices; ++n) {
+					pcMeshOut->mVertices[aiCurrent[AI_PTVS_VERTEX] + n] = pcNode->mTransformation * pcMesh->mVertices[n];
+				}
+				aiMatrix4x4 mWorldIT = pcNode->mTransformation;
+				mWorldIT.Inverse().Transpose();
 
-                // TODO: implement Inverse() for aiMatrix3x3
-                aiMatrix3x3 m = aiMatrix3x3(mWorldIT);
+				// TODO: implement Inverse() for aiMatrix3x3
+				aiMatrix3x3 m = aiMatrix3x3(mWorldIT);
 
-                if (iVFormat & 0x2)
-                {
-                    // copy normals, transform them to worldspace
-                    for (unsigned int n = 0; n < pcMesh->mNumVertices;++n)  {
-                        pcMeshOut->mNormals[aiCurrent[AI_PTVS_VERTEX]+n] =
-                            (m * pcMesh->mNormals[n]).Normalize();
-                    }
-                }
-                if (iVFormat & 0x4)
-                {
-                    // copy tangents and bitangents, transform them to worldspace
-                    for (unsigned int n = 0; n < pcMesh->mNumVertices;++n)  {
-                        pcMeshOut->mTangents  [aiCurrent[AI_PTVS_VERTEX]+n] = (m * pcMesh->mTangents[n]).Normalize();
-                        pcMeshOut->mBitangents[aiCurrent[AI_PTVS_VERTEX]+n] = (m * pcMesh->mBitangents[n]).Normalize();
-                    }
-                }
-            }
-            unsigned int p = 0;
-            while (iVFormat & (0x100 << p))
-            {
-                // copy texture coordinates
-                memcpy(pcMeshOut->mTextureCoords[p] + aiCurrent[AI_PTVS_VERTEX],
-                    pcMesh->mTextureCoords[p],
-                    pcMesh->mNumVertices * sizeof(aiVector3D));
-                ++p;
-            }
-            p = 0;
-            while (iVFormat & (0x1000000 << p))
-            {
-                // copy vertex colors
-                memcpy(pcMeshOut->mColors[p] + aiCurrent[AI_PTVS_VERTEX],
-                    pcMesh->mColors[p],
-                    pcMesh->mNumVertices * sizeof(aiColor4D));
-                ++p;
-            }
-            // now we need to copy all faces. since we will delete the source mesh afterwards,
-            // we don't need to reallocate the array of indices except if this mesh is
-            // referenced multiple times.
-            for (unsigned int planck = 0;planck < pcMesh->mNumFaces;++planck)
-            {
-                aiFace& f_src = pcMesh->mFaces[planck];
-                aiFace& f_dst = pcMeshOut->mFaces[aiCurrent[AI_PTVS_FACE]+planck];
+				if (iVFormat & 0x2) {
+					// copy normals, transform them to worldspace
+					for (unsigned int n = 0; n < pcMesh->mNumVertices; ++n) {
+						pcMeshOut->mNormals[aiCurrent[AI_PTVS_VERTEX] + n] =
+								(m * pcMesh->mNormals[n]).Normalize();
+					}
+				}
+				if (iVFormat & 0x4) {
+					// copy tangents and bitangents, transform them to worldspace
+					for (unsigned int n = 0; n < pcMesh->mNumVertices; ++n) {
+						pcMeshOut->mTangents[aiCurrent[AI_PTVS_VERTEX] + n] = (m * pcMesh->mTangents[n]).Normalize();
+						pcMeshOut->mBitangents[aiCurrent[AI_PTVS_VERTEX] + n] = (m * pcMesh->mBitangents[n]).Normalize();
+					}
+				}
+			}
+			unsigned int p = 0;
+			while (iVFormat & (0x100 << p)) {
+				// copy texture coordinates
+				memcpy(pcMeshOut->mTextureCoords[p] + aiCurrent[AI_PTVS_VERTEX],
+						pcMesh->mTextureCoords[p],
+						pcMesh->mNumVertices * sizeof(aiVector3D));
+				++p;
+			}
+			p = 0;
+			while (iVFormat & (0x1000000 << p)) {
+				// copy vertex colors
+				memcpy(pcMeshOut->mColors[p] + aiCurrent[AI_PTVS_VERTEX],
+						pcMesh->mColors[p],
+						pcMesh->mNumVertices * sizeof(aiColor4D));
+				++p;
+			}
+			// now we need to copy all faces. since we will delete the source mesh afterwards,
+			// we don't need to reallocate the array of indices except if this mesh is
+			// referenced multiple times.
+			for (unsigned int planck = 0; planck < pcMesh->mNumFaces; ++planck) {
+				aiFace &f_src = pcMesh->mFaces[planck];
+				aiFace &f_dst = pcMeshOut->mFaces[aiCurrent[AI_PTVS_FACE] + planck];
 
-                const unsigned int num_idx = f_src.mNumIndices;
+				const unsigned int num_idx = f_src.mNumIndices;
 
-                f_dst.mNumIndices = num_idx;
+				f_dst.mNumIndices = num_idx;
 
-                unsigned int* pi;
-                if (!num_ref) { /* if last time the mesh is referenced -> no reallocation */
-                    pi = f_dst.mIndices = f_src.mIndices;
+				unsigned int *pi;
+				if (!num_ref) { /* if last time the mesh is referenced -> no reallocation */
+					pi = f_dst.mIndices = f_src.mIndices;
 
-                    // offset all vertex indices
-                    for (unsigned int hahn = 0; hahn < num_idx;++hahn){
-                        pi[hahn] += aiCurrent[AI_PTVS_VERTEX];
-                    }
-                }
-                else {
-                    pi = f_dst.mIndices = new unsigned int[num_idx];
+					// offset all vertex indices
+					for (unsigned int hahn = 0; hahn < num_idx; ++hahn) {
+						pi[hahn] += aiCurrent[AI_PTVS_VERTEX];
+					}
+				} else {
+					pi = f_dst.mIndices = new unsigned int[num_idx];
 
-                    // copy and offset all vertex indices
-                    for (unsigned int hahn = 0; hahn < num_idx;++hahn){
-                        pi[hahn] = f_src.mIndices[hahn] + aiCurrent[AI_PTVS_VERTEX];
-                    }
-                }
+					// copy and offset all vertex indices
+					for (unsigned int hahn = 0; hahn < num_idx; ++hahn) {
+						pi[hahn] = f_src.mIndices[hahn] + aiCurrent[AI_PTVS_VERTEX];
+					}
+				}
 
-                // Update the mPrimitiveTypes member of the mesh
-                switch (pcMesh->mFaces[planck].mNumIndices)
-                {
-                case 0x1:
-                    pcMeshOut->mPrimitiveTypes |= aiPrimitiveType_POINT;
-                    break;
-                case 0x2:
-                    pcMeshOut->mPrimitiveTypes |= aiPrimitiveType_LINE;
-                    break;
-                case 0x3:
-                    pcMeshOut->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
-                    break;
-                default:
-                    pcMeshOut->mPrimitiveTypes |= aiPrimitiveType_POLYGON;
-                    break;
-                };
-            }
-            aiCurrent[AI_PTVS_VERTEX] += pcMesh->mNumVertices;
-            aiCurrent[AI_PTVS_FACE]   += pcMesh->mNumFaces;
-        }
-    }
+				// Update the mPrimitiveTypes member of the mesh
+				switch (pcMesh->mFaces[planck].mNumIndices) {
+					case 0x1:
+						pcMeshOut->mPrimitiveTypes |= aiPrimitiveType_POINT;
+						break;
+					case 0x2:
+						pcMeshOut->mPrimitiveTypes |= aiPrimitiveType_LINE;
+						break;
+					case 0x3:
+						pcMeshOut->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
+						break;
+					default:
+						pcMeshOut->mPrimitiveTypes |= aiPrimitiveType_POLYGON;
+						break;
+				};
+			}
+			aiCurrent[AI_PTVS_VERTEX] += pcMesh->mNumVertices;
+			aiCurrent[AI_PTVS_FACE] += pcMesh->mNumFaces;
+		}
+	}
 
-    // append all children of us
-    for (unsigned int i = 0;i < pcNode->mNumChildren;++i) {
-        CollectData(pcScene,pcNode->mChildren[i],iMat,
-            iVFormat,pcMeshOut,aiCurrent,num_refs);
-    }
+	// append all children of us
+	for (unsigned int i = 0; i < pcNode->mNumChildren; ++i) {
+		CollectData(pcScene, pcNode->mChildren[i], iMat,
+				iVFormat, pcMeshOut, aiCurrent, num_refs);
+	}
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get a list of all vertex formats that occur for a given material index
 // The output list contains duplicate elements
-void PretransformVertices::GetVFormatList( aiScene* pcScene, unsigned int iMat,
-    std::list<unsigned int>& aiOut)
-{
-    for (unsigned int i = 0; i < pcScene->mNumMeshes;++i)
-    {
-        aiMesh* pcMesh = pcScene->mMeshes[ i ];
-        if (iMat == pcMesh->mMaterialIndex) {
-            aiOut.push_back(GetMeshVFormat(pcMesh));
-        }
-    }
+void PretransformVertices::GetVFormatList(const aiScene *pcScene, unsigned int iMat,
+		std::list<unsigned int> &aiOut) const {
+	for (unsigned int i = 0; i < pcScene->mNumMeshes; ++i) {
+		aiMesh *pcMesh = pcScene->mMeshes[i];
+		if (iMat == pcMesh->mMaterialIndex) {
+			aiOut.push_back(GetMeshVFormat(pcMesh));
+		}
+	}
 }
 
 // ------------------------------------------------------------------------------------------------
 // Compute the absolute transformation matrices of each node
-void PretransformVertices::ComputeAbsoluteTransform( aiNode* pcNode )
-{
-    if (pcNode->mParent)    {
-        pcNode->mTransformation = pcNode->mParent->mTransformation*pcNode->mTransformation;
-    }
+void PretransformVertices::ComputeAbsoluteTransform(aiNode *pcNode) {
+	if (pcNode->mParent) {
+		pcNode->mTransformation = pcNode->mParent->mTransformation * pcNode->mTransformation;
+	}
 
-    for (unsigned int i = 0;i < pcNode->mNumChildren;++i)   {
-        ComputeAbsoluteTransform(pcNode->mChildren[i]);
-    }
+	for (unsigned int i = 0; i < pcNode->mNumChildren; ++i) {
+		ComputeAbsoluteTransform(pcNode->mChildren[i]);
+	}
 }
 
 // ------------------------------------------------------------------------------------------------
 // Apply the node transformation to a mesh
-void PretransformVertices::ApplyTransform(aiMesh* mesh, const aiMatrix4x4& mat)
-{
-    // Check whether we need to transform the coordinates at all
-    if (!mat.IsIdentity()) {
+void PretransformVertices::ApplyTransform(aiMesh *mesh, const aiMatrix4x4 &mat) const {
+	// Check whether we need to transform the coordinates at all
+	if (!mat.IsIdentity()) {
 
-        if (mesh->HasPositions()) {
-            for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
-                mesh->mVertices[i] = mat * mesh->mVertices[i];
-            }
-        }
-        if (mesh->HasNormals() || mesh->HasTangentsAndBitangents()) {
-            aiMatrix4x4 mWorldIT = mat;
-            mWorldIT.Inverse().Transpose();
+		// Check for odd negative scale (mirror)
+		if (mesh->HasFaces() && mat.Determinant() < 0) {
+			// Reverse the mesh face winding order
+			FlipWindingOrderProcess::ProcessMesh(mesh);
+		}
 
-            // TODO: implement Inverse() for aiMatrix3x3
-            aiMatrix3x3 m = aiMatrix3x3(mWorldIT);
+		// Update positions
+		if (mesh->HasPositions()) {
+			for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
+				mesh->mVertices[i] = mat * mesh->mVertices[i];
+			}
+		}
 
-            if (mesh->HasNormals()) {
-                for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
-                    mesh->mNormals[i] = (m * mesh->mNormals[i]).Normalize();
-                }
-            }
-            if (mesh->HasTangentsAndBitangents()) {
-                for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
-                    mesh->mTangents[i]   = (m * mesh->mTangents[i]).Normalize();
-                    mesh->mBitangents[i] = (m * mesh->mBitangents[i]).Normalize();
-                }
-            }
-        }
-    }
+		// Update normals and tangents
+		if (mesh->HasNormals() || mesh->HasTangentsAndBitangents()) {
+			const aiMatrix3x3 m = aiMatrix3x3(mat).Inverse().Transpose();
+
+			if (mesh->HasNormals()) {
+				for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
+					mesh->mNormals[i] = (m * mesh->mNormals[i]).Normalize();
+				}
+			}
+			if (mesh->HasTangentsAndBitangents()) {
+				for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
+					mesh->mTangents[i] = (m * mesh->mTangents[i]).Normalize();
+					mesh->mBitangents[i] = (m * mesh->mBitangents[i]).Normalize();
+				}
+			}
+		}
+	}
 }
 
 // ------------------------------------------------------------------------------------------------
 // Simple routine to build meshes in worldspace, no further optimization
-void PretransformVertices::BuildWCSMeshes(std::vector<aiMesh*>& out, aiMesh** in,
-    unsigned int numIn, aiNode* node)
-{
-    // NOTE:
-    //  aiMesh::mNumBones store original source mesh, or UINT_MAX if not a copy
-    //  aiMesh::mBones store reference to abs. transform we multiplied with
+void PretransformVertices::BuildWCSMeshes(std::vector<aiMesh *> &out, aiMesh **in,
+		unsigned int numIn, aiNode *node) const {
+	// NOTE:
+	//  aiMesh::mNumBones store original source mesh, or UINT_MAX if not a copy
+	//  aiMesh::mBones store reference to abs. transform we multiplied with
 
-    // process meshes
-    for (unsigned int i = 0; i < node->mNumMeshes;++i) {
-        aiMesh* mesh = in[node->mMeshes[i]];
+	// process meshes
+	for (unsigned int i = 0; i < node->mNumMeshes; ++i) {
+		aiMesh *mesh = in[node->mMeshes[i]];
 
-        // check whether we can operate on this mesh
-        if (!mesh->mBones || *reinterpret_cast<aiMatrix4x4*>(mesh->mBones) == node->mTransformation) {
-            // yes, we can.
-            mesh->mBones = reinterpret_cast<aiBone**> (&node->mTransformation);
-            mesh->mNumBones = UINT_MAX;
-        }
-        else {
+		// check whether we can operate on this mesh
+		if (!mesh->mBones || *reinterpret_cast<aiMatrix4x4 *>(mesh->mBones) == node->mTransformation) {
+			// yes, we can.
+			mesh->mBones = reinterpret_cast<aiBone **>(&node->mTransformation);
+			mesh->mNumBones = UINT_MAX;
+		} else {
 
-            // try to find us in the list of newly created meshes
-            for (unsigned int n = 0; n < out.size(); ++n) {
-                aiMesh* ctz = out[n];
-                if (ctz->mNumBones == node->mMeshes[i] && *reinterpret_cast<aiMatrix4x4*>(ctz->mBones) ==  node->mTransformation) {
+			// try to find us in the list of newly created meshes
+			for (unsigned int n = 0; n < out.size(); ++n) {
+				aiMesh *ctz = out[n];
+				if (ctz->mNumBones == node->mMeshes[i] && *reinterpret_cast<aiMatrix4x4 *>(ctz->mBones) == node->mTransformation) {
 
-                    // ok, use this one. Update node mesh index
-                    node->mMeshes[i] = numIn + n;
-                }
-            }
-            if (node->mMeshes[i] < numIn) {
-                // Worst case. Need to operate on a full copy of the mesh
-                ASSIMP_LOG_INFO("PretransformVertices: Copying mesh due to mismatching transforms");
-                aiMesh* ntz;
+					// ok, use this one. Update node mesh index
+					node->mMeshes[i] = numIn + n;
+				}
+			}
+			if (node->mMeshes[i] < numIn) {
+				// Worst case. Need to operate on a full copy of the mesh
+				ASSIMP_LOG_INFO("PretransformVertices: Copying mesh due to mismatching transforms");
+				aiMesh *ntz;
 
-                const unsigned int tmp = mesh->mNumBones; //
-                mesh->mNumBones = 0;
-                SceneCombiner::Copy(&ntz,mesh);
-                mesh->mNumBones = tmp;
+				const unsigned int tmp = mesh->mNumBones; //
+				mesh->mNumBones = 0;
+				SceneCombiner::Copy(&ntz, mesh);
+				mesh->mNumBones = tmp;
 
-                ntz->mNumBones = node->mMeshes[i];
-                ntz->mBones = reinterpret_cast<aiBone**> (&node->mTransformation);
+				ntz->mNumBones = node->mMeshes[i];
+				ntz->mBones = reinterpret_cast<aiBone **>(&node->mTransformation);
 
-                out.push_back(ntz);
+				out.push_back(ntz);
 
-                node->mMeshes[i] = static_cast<unsigned int>(numIn + out.size() - 1);
-            }
-        }
-    }
+				node->mMeshes[i] = static_cast<unsigned int>(numIn + out.size() - 1);
+			}
+		}
+	}
 
-    // call children
-    for (unsigned int i = 0; i < node->mNumChildren;++i)
-        BuildWCSMeshes(out,in,numIn,node->mChildren[i]);
+	// call children
+	for (unsigned int i = 0; i < node->mNumChildren; ++i)
+		BuildWCSMeshes(out, in, numIn, node->mChildren[i]);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Reset transformation matrices to identity
-void PretransformVertices::MakeIdentityTransform(aiNode* nd)
-{
-    nd->mTransformation = aiMatrix4x4();
+void PretransformVertices::MakeIdentityTransform(aiNode *nd) const {
+	nd->mTransformation = aiMatrix4x4();
 
-    // call children
-    for (unsigned int i = 0; i < nd->mNumChildren;++i)
-        MakeIdentityTransform(nd->mChildren[i]);
+	// call children
+	for (unsigned int i = 0; i < nd->mNumChildren; ++i)
+		MakeIdentityTransform(nd->mChildren[i]);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Build reference counters for all meshes
-void PretransformVertices::BuildMeshRefCountArray(aiNode* nd, unsigned int * refs)
-{
-    for (unsigned int i = 0; i< nd->mNumMeshes;++i)
-        refs[nd->mMeshes[i]]++;
+void PretransformVertices::BuildMeshRefCountArray(const aiNode *nd, unsigned int *refs) const {
+	for (unsigned int i = 0; i < nd->mNumMeshes; ++i)
+		refs[nd->mMeshes[i]]++;
 
-    // call children
-    for (unsigned int i = 0; i < nd->mNumChildren;++i)
-        BuildMeshRefCountArray(nd->mChildren[i],refs);
+	// call children
+	for (unsigned int i = 0; i < nd->mNumChildren; ++i)
+		BuildMeshRefCountArray(nd->mChildren[i], refs);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Executes the post processing step on the given imported data.
-void PretransformVertices::Execute( aiScene* pScene)
-{
-    ASSIMP_LOG_DEBUG("PretransformVerticesProcess begin");
+void PretransformVertices::Execute(aiScene *pScene) {
+	ASSIMP_LOG_DEBUG("PretransformVerticesProcess begin");
 
-    // Return immediately if we have no meshes
-    if (!pScene->mNumMeshes)
-        return;
+	// Return immediately if we have no meshes
+	if (!pScene->mNumMeshes)
+		return;
 
-    const unsigned int iOldMeshes = pScene->mNumMeshes;
-    const unsigned int iOldAnimationChannels = pScene->mNumAnimations;
-    const unsigned int iOldNodes = CountNodes(pScene->mRootNode);
+	const unsigned int iOldMeshes = pScene->mNumMeshes;
+	const unsigned int iOldAnimationChannels = pScene->mNumAnimations;
+	const unsigned int iOldNodes = CountNodes(pScene->mRootNode);
 
-    if(configTransform) {
-        pScene->mRootNode->mTransformation = configTransformation;
-    }
+	if (configTransform) {
+		pScene->mRootNode->mTransformation = configTransformation * pScene->mRootNode->mTransformation;
+	}
 
-    // first compute absolute transformation matrices for all nodes
-    ComputeAbsoluteTransform(pScene->mRootNode);
+	// first compute absolute transformation matrices for all nodes
+	ComputeAbsoluteTransform(pScene->mRootNode);
 
-    // Delete aiMesh::mBones for all meshes. The bones are
-    // removed during this step and we need the pointer as
-    // temporary storage
-    for (unsigned int i = 0; i < pScene->mNumMeshes;++i)    {
-        aiMesh* mesh = pScene->mMeshes[i];
+	// Delete aiMesh::mBones for all meshes. The bones are
+	// removed during this step and we need the pointer as
+	// temporary storage
+	for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
+		aiMesh *mesh = pScene->mMeshes[i];
 
-        for (unsigned int a = 0; a < mesh->mNumBones;++a)
-            delete mesh->mBones[a];
+		for (unsigned int a = 0; a < mesh->mNumBones; ++a)
+			delete mesh->mBones[a];
 
-        delete[] mesh->mBones;
-        mesh->mBones = NULL;
-    }
+		delete[] mesh->mBones;
+        mesh->mBones = nullptr;
+	}
 
-    // now build a list of output meshes
-    std::vector<aiMesh*> apcOutMeshes;
+	// now build a list of output meshes
+	std::vector<aiMesh *> apcOutMeshes;
 
-    // Keep scene hierarchy? It's an easy job in this case ...
-    // we go on and transform all meshes, if one is referenced by nodes
-    // with different absolute transformations a depth copy of the mesh
-    // is required.
-    if( configKeepHierarchy ) {
+	// Keep scene hierarchy? It's an easy job in this case ...
+	// we go on and transform all meshes, if one is referenced by nodes
+	// with different absolute transformations a depth copy of the mesh
+	// is required.
+	if (configKeepHierarchy) {
 
-        // Hack: store the matrix we're transforming a mesh with in aiMesh::mBones
-        BuildWCSMeshes(apcOutMeshes,pScene->mMeshes,pScene->mNumMeshes, pScene->mRootNode);
+		// Hack: store the matrix we're transforming a mesh with in aiMesh::mBones
+		BuildWCSMeshes(apcOutMeshes, pScene->mMeshes, pScene->mNumMeshes, pScene->mRootNode);
 
-        // ... if new meshes have been generated, append them to the end of the scene
-        if (apcOutMeshes.size() > 0) {
-            aiMesh** npp = new aiMesh*[pScene->mNumMeshes + apcOutMeshes.size()];
+		// ... if new meshes have been generated, append them to the end of the scene
+		if (apcOutMeshes.size() > 0) {
+			aiMesh **npp = new aiMesh *[pScene->mNumMeshes + apcOutMeshes.size()];
 
-            memcpy(npp,pScene->mMeshes,sizeof(aiMesh*)*pScene->mNumMeshes);
-            memcpy(npp+pScene->mNumMeshes,&apcOutMeshes[0],sizeof(aiMesh*)*apcOutMeshes.size());
+			memcpy(npp, pScene->mMeshes, sizeof(aiMesh *) * pScene->mNumMeshes);
+			memcpy(npp + pScene->mNumMeshes, &apcOutMeshes[0], sizeof(aiMesh *) * apcOutMeshes.size());
 
-            pScene->mNumMeshes  += static_cast<unsigned int>(apcOutMeshes.size());
-            delete[] pScene->mMeshes; pScene->mMeshes = npp;
-        }
+			pScene->mNumMeshes += static_cast<unsigned int>(apcOutMeshes.size());
+			delete[] pScene->mMeshes;
+			pScene->mMeshes = npp;
+		}
 
-        // now iterate through all meshes and transform them to worldspace
-        for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
-            ApplyTransform(pScene->mMeshes[i],*reinterpret_cast<aiMatrix4x4*>( pScene->mMeshes[i]->mBones ));
+		// now iterate through all meshes and transform them to world-space
+		for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
+			ApplyTransform(pScene->mMeshes[i], *reinterpret_cast<aiMatrix4x4 *>(pScene->mMeshes[i]->mBones));
 
-            // prevent improper destruction
-            pScene->mMeshes[i]->mBones    = NULL;
-            pScene->mMeshes[i]->mNumBones = 0;
-        }
-    } else {
-        apcOutMeshes.reserve(pScene->mNumMaterials<<1u);
-        std::list<unsigned int> aiVFormats;
+			// prevent improper destruction
+            pScene->mMeshes[i]->mBones = nullptr;
+			pScene->mMeshes[i]->mNumBones = 0;
+		}
+	} else {
+		apcOutMeshes.reserve(static_cast<size_t>(pScene->mNumMaterials) << 1u);
+		std::list<unsigned int> aiVFormats;
 
-        std::vector<unsigned int> s(pScene->mNumMeshes,0);
-        BuildMeshRefCountArray(pScene->mRootNode,&s[0]);
+		std::vector<unsigned int> s(pScene->mNumMeshes, 0);
+		BuildMeshRefCountArray(pScene->mRootNode, &s[0]);
 
-        for (unsigned int i = 0; i < pScene->mNumMaterials;++i)     {
-            // get the list of all vertex formats for this material
-            aiVFormats.clear();
-            GetVFormatList(pScene,i,aiVFormats);
-            aiVFormats.sort();
-            aiVFormats.unique();
-            for (std::list<unsigned int>::const_iterator j =  aiVFormats.begin();j != aiVFormats.end();++j) {
-                unsigned int iVertices = 0;
-                unsigned int iFaces = 0;
-                CountVerticesAndFaces(pScene,pScene->mRootNode,i,*j,&iFaces,&iVertices);
-                if (0 != iFaces && 0 != iVertices)
-                {
-                    apcOutMeshes.push_back(new aiMesh());
-                    aiMesh* pcMesh = apcOutMeshes.back();
-                    pcMesh->mNumFaces = iFaces;
-                    pcMesh->mNumVertices = iVertices;
-                    pcMesh->mFaces = new aiFace[iFaces];
-                    pcMesh->mVertices = new aiVector3D[iVertices];
-                    pcMesh->mMaterialIndex = i;
-                    if ((*j) & 0x2)pcMesh->mNormals = new aiVector3D[iVertices];
-                    if ((*j) & 0x4)
-                    {
-                        pcMesh->mTangents    = new aiVector3D[iVertices];
-                        pcMesh->mBitangents  = new aiVector3D[iVertices];
-                    }
-                    iFaces = 0;
-                    while ((*j) & (0x100 << iFaces))
-                    {
-                        pcMesh->mTextureCoords[iFaces] = new aiVector3D[iVertices];
-                        if ((*j) & (0x10000 << iFaces))pcMesh->mNumUVComponents[iFaces] = 3;
-                        else pcMesh->mNumUVComponents[iFaces] = 2;
-                        iFaces++;
-                    }
-                    iFaces = 0;
-                    while ((*j) & (0x1000000 << iFaces))
-                        pcMesh->mColors[iFaces++] = new aiColor4D[iVertices];
+		for (unsigned int i = 0; i < pScene->mNumMaterials; ++i) {
+			// get the list of all vertex formats for this material
+			aiVFormats.clear();
+			GetVFormatList(pScene, i, aiVFormats);
+			aiVFormats.sort();
+			aiVFormats.unique();
+			for (std::list<unsigned int>::const_iterator j = aiVFormats.begin(); j != aiVFormats.end(); ++j) {
+				unsigned int iVertices = 0;
+				unsigned int iFaces = 0;
+				CountVerticesAndFaces(pScene, pScene->mRootNode, i, *j, &iFaces, &iVertices);
+				if (0 != iFaces && 0 != iVertices) {
+					apcOutMeshes.push_back(new aiMesh());
+					aiMesh *pcMesh = apcOutMeshes.back();
+					pcMesh->mNumFaces = iFaces;
+					pcMesh->mNumVertices = iVertices;
+					pcMesh->mFaces = new aiFace[iFaces];
+					pcMesh->mVertices = new aiVector3D[iVertices];
+					pcMesh->mMaterialIndex = i;
+					if ((*j) & 0x2) pcMesh->mNormals = new aiVector3D[iVertices];
+					if ((*j) & 0x4) {
+						pcMesh->mTangents = new aiVector3D[iVertices];
+						pcMesh->mBitangents = new aiVector3D[iVertices];
+					}
+					iFaces = 0;
+					while ((*j) & (0x100 << iFaces)) {
+						pcMesh->mTextureCoords[iFaces] = new aiVector3D[iVertices];
+						if ((*j) & (0x10000 << iFaces))
+							pcMesh->mNumUVComponents[iFaces] = 3;
+						else
+							pcMesh->mNumUVComponents[iFaces] = 2;
+						iFaces++;
+					}
+					iFaces = 0;
+					while ((*j) & (0x1000000 << iFaces))
+						pcMesh->mColors[iFaces++] = new aiColor4D[iVertices];
 
-                    // fill the mesh ...
-                    unsigned int aiTemp[2] = {0,0};
-                    CollectData(pScene,pScene->mRootNode,i,*j,pcMesh,aiTemp,&s[0]);
-                }
-            }
-        }
+					// fill the mesh ...
+					unsigned int aiTemp[2] = { 0, 0 };
+					CollectData(pScene, pScene->mRootNode, i, *j, pcMesh, aiTemp, &s[0]);
+				}
+			}
+		}
 
-        // If no meshes are referenced in the node graph it is possible that we get no output meshes.
-        if (apcOutMeshes.empty()) {
-            
-            throw DeadlyImportError("No output meshes: all meshes are orphaned and are not referenced by any nodes");
-        }
-        else
-        {
-            // now delete all meshes in the scene and build a new mesh list
-            for (unsigned int i = 0; i < pScene->mNumMeshes;++i)
-            {
-                aiMesh* mesh = pScene->mMeshes[i];
-                mesh->mNumBones = 0;
-                mesh->mBones    = NULL;
+		// If no meshes are referenced in the node graph it is possible that we get no output meshes.
+		if (apcOutMeshes.empty()) {
 
-                // we're reusing the face index arrays. avoid destruction
-                for (unsigned int a = 0; a < mesh->mNumFaces; ++a) {
-                    mesh->mFaces[a].mNumIndices = 0;
-                    mesh->mFaces[a].mIndices = NULL;
-                }
+			throw DeadlyImportError("No output meshes: all meshes are orphaned and are not referenced by any nodes");
+		} else {
+			// now delete all meshes in the scene and build a new mesh list
+			for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
+				aiMesh *mesh = pScene->mMeshes[i];
+				mesh->mNumBones = 0;
+                mesh->mBones = nullptr;
 
-                delete mesh;
+				// we're reusing the face index arrays. avoid destruction
+				for (unsigned int a = 0; a < mesh->mNumFaces; ++a) {
+					mesh->mFaces[a].mNumIndices = 0;
+                    mesh->mFaces[a].mIndices = nullptr;
+				}
 
-                // Invalidate the contents of the old mesh array. We will most
-                // likely have less output meshes now, so the last entries of
-                // the mesh array are not overridden. We set them to NULL to
-                // make sure the developer gets notified when his application
-                // attempts to access these fields ...
-                mesh = NULL;
-            }
+				delete mesh;
 
-            // It is impossible that we have more output meshes than
-            // input meshes, so we can easily reuse the old mesh array
-            pScene->mNumMeshes = (unsigned int)apcOutMeshes.size();
-            for (unsigned int i = 0; i < pScene->mNumMeshes;++i) {
-                pScene->mMeshes[i] = apcOutMeshes[i];
-            }
-        }
-    }
+				// Invalidate the contents of the old mesh array. We will most
+				// likely have less output meshes now, so the last entries of
+				// the mesh array are not overridden. We set them to nullptr to
+				// make sure the developer gets notified when his application
+				// attempts to access these fields ...
+                mesh = nullptr;
+			}
 
-    // remove all animations from the scene
-    for (unsigned int i = 0; i < pScene->mNumAnimations;++i)
-        delete pScene->mAnimations[i];
-    delete[] pScene->mAnimations;
+			// It is impossible that we have more output meshes than
+			// input meshes, so we can easily reuse the old mesh array
+			pScene->mNumMeshes = (unsigned int)apcOutMeshes.size();
+			for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
+				pScene->mMeshes[i] = apcOutMeshes[i];
+			}
+		}
+	}
 
-    pScene->mAnimations    = NULL;
-    pScene->mNumAnimations = 0;
+	// remove all animations from the scene
+	for (unsigned int i = 0; i < pScene->mNumAnimations; ++i)
+		delete pScene->mAnimations[i];
+	delete[] pScene->mAnimations;
 
-    // --- we need to keep all cameras and lights
-    for (unsigned int i = 0; i < pScene->mNumCameras;++i)
-    {
-        aiCamera* cam = pScene->mCameras[i];
-        const aiNode* nd = pScene->mRootNode->FindNode(cam->mName);
-        ai_assert(NULL != nd);
+	pScene->mAnimations = nullptr;
+	pScene->mNumAnimations = 0;
 
-        // multiply all properties of the camera with the absolute
-        // transformation of the corresponding node
-        cam->mPosition = nd->mTransformation * cam->mPosition;
-        cam->mLookAt   = aiMatrix3x3( nd->mTransformation ) * cam->mLookAt;
-        cam->mUp       = aiMatrix3x3( nd->mTransformation ) * cam->mUp;
-    }
+	// --- we need to keep all cameras and lights
+	for (unsigned int i = 0; i < pScene->mNumCameras; ++i) {
+		aiCamera *cam = pScene->mCameras[i];
+		const aiNode *nd = pScene->mRootNode->FindNode(cam->mName);
+        ai_assert(nullptr != nd);
 
-    for (unsigned int i = 0; i < pScene->mNumLights;++i)
-    {
-        aiLight* l = pScene->mLights[i];
-        const aiNode* nd = pScene->mRootNode->FindNode(l->mName);
-        ai_assert(NULL != nd);
+		// multiply all properties of the camera with the absolute
+		// transformation of the corresponding node
+		cam->mPosition = nd->mTransformation * cam->mPosition;
+		cam->mLookAt = aiMatrix3x3(nd->mTransformation) * cam->mLookAt;
+		cam->mUp = aiMatrix3x3(nd->mTransformation) * cam->mUp;
+	}
 
-        // multiply all properties of the camera with the absolute
-        // transformation of the corresponding node
-        l->mPosition   = nd->mTransformation * l->mPosition;
-        l->mDirection  = aiMatrix3x3( nd->mTransformation ) * l->mDirection;
-        l->mUp         = aiMatrix3x3( nd->mTransformation ) * l->mUp;
-    }
+	for (unsigned int i = 0; i < pScene->mNumLights; ++i) {
+		aiLight *l = pScene->mLights[i];
+		const aiNode *nd = pScene->mRootNode->FindNode(l->mName);
+        ai_assert(nullptr != nd);
 
-    if( !configKeepHierarchy ) {
+		// multiply all properties of the camera with the absolute
+		// transformation of the corresponding node
+		l->mPosition = nd->mTransformation * l->mPosition;
+		l->mDirection = aiMatrix3x3(nd->mTransformation) * l->mDirection;
+		l->mUp = aiMatrix3x3(nd->mTransformation) * l->mUp;
+	}
 
-        // now delete all nodes in the scene and build a new
-        // flat node graph with a root node and some level 1 children
-        aiNode* newRoot = new aiNode();
-        newRoot->mName = pScene->mRootNode->mName;
-        delete pScene->mRootNode;
-        pScene->mRootNode = newRoot;
+	if (!configKeepHierarchy) {
 
-        if (1 == pScene->mNumMeshes && !pScene->mNumLights && !pScene->mNumCameras)
-        {
-            pScene->mRootNode->mNumMeshes = 1;
-            pScene->mRootNode->mMeshes = new unsigned int[1];
-            pScene->mRootNode->mMeshes[0] = 0;
-        }
-        else
-        {
-            pScene->mRootNode->mNumChildren = pScene->mNumMeshes+pScene->mNumLights+pScene->mNumCameras;
-            aiNode** nodes = pScene->mRootNode->mChildren = new aiNode*[pScene->mRootNode->mNumChildren];
+		// now delete all nodes in the scene and build a new
+		// flat node graph with a root node and some level 1 children
+		aiNode *newRoot = new aiNode();
+		newRoot->mName = pScene->mRootNode->mName;
+		delete pScene->mRootNode;
+		pScene->mRootNode = newRoot;
 
-            // generate mesh nodes
-            for (unsigned int i = 0; i < pScene->mNumMeshes;++i,++nodes)
-            {
-                aiNode* pcNode = new aiNode();
-                *nodes = pcNode;
-                pcNode->mParent = pScene->mRootNode;
-                pcNode->mName = pScene->mMeshes[i]->mName;
+		if (1 == pScene->mNumMeshes && !pScene->mNumLights && !pScene->mNumCameras) {
+			pScene->mRootNode->mNumMeshes = 1;
+			pScene->mRootNode->mMeshes = new unsigned int[1];
+			pScene->mRootNode->mMeshes[0] = 0;
+		} else {
+			pScene->mRootNode->mNumChildren = pScene->mNumMeshes + pScene->mNumLights + pScene->mNumCameras;
+			aiNode **nodes = pScene->mRootNode->mChildren = new aiNode *[pScene->mRootNode->mNumChildren];
 
-                // setup mesh indices
-                pcNode->mNumMeshes = 1;
-                pcNode->mMeshes = new unsigned int[1];
-                pcNode->mMeshes[0] = i;
-            }
-            // generate light nodes
-            for (unsigned int i = 0; i < pScene->mNumLights;++i,++nodes)
-            {
-                aiNode* pcNode = new aiNode();
-                *nodes = pcNode;
-                pcNode->mParent = pScene->mRootNode;
-                pcNode->mName.length = ai_snprintf(pcNode->mName.data, MAXLEN, "light_%u",i);
-                pScene->mLights[i]->mName = pcNode->mName;
-            }
-            // generate camera nodes
-            for (unsigned int i = 0; i < pScene->mNumCameras;++i,++nodes)
-            {
-                aiNode* pcNode = new aiNode();
-                *nodes = pcNode;
-                pcNode->mParent = pScene->mRootNode;
-                pcNode->mName.length = ::ai_snprintf(pcNode->mName.data,MAXLEN,"cam_%u",i);
-                pScene->mCameras[i]->mName = pcNode->mName;
-            }
-        }
-    }
-    else {
-        // ... and finally set the transformation matrix of all nodes to identity
-        MakeIdentityTransform(pScene->mRootNode);
-    }
+			// generate mesh nodes
+			for (unsigned int i = 0; i < pScene->mNumMeshes; ++i, ++nodes) {
+				aiNode *pcNode = new aiNode();
+				*nodes = pcNode;
+				pcNode->mParent = pScene->mRootNode;
+				pcNode->mName = pScene->mMeshes[i]->mName;
 
-    if (configNormalize) {
-        // compute the boundary of all meshes
-        aiVector3D min,max;
-        MinMaxChooser<aiVector3D> ()(min,max);
+				// setup mesh indices
+				pcNode->mNumMeshes = 1;
+				pcNode->mMeshes = new unsigned int[1];
+				pcNode->mMeshes[0] = i;
+			}
+			// generate light nodes
+			for (unsigned int i = 0; i < pScene->mNumLights; ++i, ++nodes) {
+				aiNode *pcNode = new aiNode();
+				*nodes = pcNode;
+				pcNode->mParent = pScene->mRootNode;
+				pcNode->mName.length = ai_snprintf(pcNode->mName.data, MAXLEN, "light_%u", i);
+				pScene->mLights[i]->mName = pcNode->mName;
+			}
+			// generate camera nodes
+			for (unsigned int i = 0; i < pScene->mNumCameras; ++i, ++nodes) {
+				aiNode *pcNode = new aiNode();
+				*nodes = pcNode;
+				pcNode->mParent = pScene->mRootNode;
+				pcNode->mName.length = ::ai_snprintf(pcNode->mName.data, MAXLEN, "cam_%u", i);
+				pScene->mCameras[i]->mName = pcNode->mName;
+			}
+		}
+	} else {
+		// ... and finally set the transformation matrix of all nodes to identity
+		MakeIdentityTransform(pScene->mRootNode);
+	}
 
-        for (unsigned int a = 0; a <  pScene->mNumMeshes; ++a) {
-            aiMesh* m = pScene->mMeshes[a];
-            for (unsigned int i = 0; i < m->mNumVertices;++i) {
-                min = std::min(m->mVertices[i],min);
-                max = std::max(m->mVertices[i],max);
-            }
-        }
+	if (configNormalize) {
+		// compute the boundary of all meshes
+		aiVector3D min, max;
+		MinMaxChooser<aiVector3D>()(min, max);
 
-        // find the dominant axis
-        aiVector3D d = max-min;
-        const ai_real div = std::max(d.x,std::max(d.y,d.z))*ai_real( 0.5);
+		for (unsigned int a = 0; a < pScene->mNumMeshes; ++a) {
+			aiMesh *m = pScene->mMeshes[a];
+			for (unsigned int i = 0; i < m->mNumVertices; ++i) {
+				min = std::min(m->mVertices[i], min);
+				max = std::max(m->mVertices[i], max);
+			}
+		}
 
-        d = min + d * (ai_real)0.5;
-        for (unsigned int a = 0; a <  pScene->mNumMeshes; ++a) {
-            aiMesh* m = pScene->mMeshes[a];
-            for (unsigned int i = 0; i < m->mNumVertices;++i) {
-                m->mVertices[i] = (m->mVertices[i]-d)/div;
-            }
-        }
-    }
+		// find the dominant axis
+		aiVector3D d = max - min;
+		const ai_real div = std::max(d.x, std::max(d.y, d.z)) * ai_real(0.5);
 
-    // print statistics
-    if (!DefaultLogger::isNullLogger()) {
-        ASSIMP_LOG_DEBUG("PretransformVerticesProcess finished");
+		d = min + d * (ai_real)0.5;
+		for (unsigned int a = 0; a < pScene->mNumMeshes; ++a) {
+			aiMesh *m = pScene->mMeshes[a];
+			for (unsigned int i = 0; i < m->mNumVertices; ++i) {
+				m->mVertices[i] = (m->mVertices[i] - d) / div;
+			}
+		}
+	}
 
-        ASSIMP_LOG_INFO_F("Removed ", iOldNodes, " nodes and ", iOldAnimationChannels, " animation channels (", 
-            CountNodes(pScene->mRootNode) ," output nodes)" );
-        ASSIMP_LOG_INFO_F("Kept ", pScene->mNumLights, " lights and ", pScene->mNumCameras, " cameras." );
-        ASSIMP_LOG_INFO_F("Moved ", iOldMeshes, " meshes to WCS (number of output meshes: ", pScene->mNumMeshes, ")");
-    }
+	// print statistics
+	if (!DefaultLogger::isNullLogger()) {
+		ASSIMP_LOG_DEBUG("PretransformVerticesProcess finished");
+
+		ASSIMP_LOG_INFO("Removed ", iOldNodes, " nodes and ", iOldAnimationChannels, " animation channels (",
+				CountNodes(pScene->mRootNode), " output nodes)");
+		ASSIMP_LOG_INFO("Kept ", pScene->mNumLights, " lights and ", pScene->mNumCameras, " cameras.");
+		ASSIMP_LOG_INFO("Moved ", iOldMeshes, " meshes to WCS (number of output meshes: ", pScene->mNumMeshes, ")");
+	}
 }
diff --git a/Engine/lib/assimp/code/PostProcessing/PretransformVertices.h b/Engine/lib/assimp/code/PostProcessing/PretransformVertices.h
index b2982951e..14e5139ec 100644
--- a/Engine/lib/assimp/code/PostProcessing/PretransformVertices.h
+++ b/Engine/lib/assimp/code/PostProcessing/PretransformVertices.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -59,7 +59,7 @@ struct aiNode;
 
 class PretransformVerticesTest;
 
-namespace Assimp    {
+namespace Assimp {
 
 // ---------------------------------------------------------------------------
 /** The PretransformVertices pre-transforms all vertices in the node tree
@@ -68,97 +68,97 @@ namespace Assimp    {
 */
 class ASSIMP_API PretransformVertices : public BaseProcess {
 public:
-    PretransformVertices ();
-    ~PretransformVertices ();
+	PretransformVertices();
+	~PretransformVertices();
 
-    // -------------------------------------------------------------------
-    // Check whether step is active
-    bool IsActive( unsigned int pFlags) const;
+	// -------------------------------------------------------------------
+	// Check whether step is active
+	bool IsActive(unsigned int pFlags) const override;
 
-    // -------------------------------------------------------------------
-    // Execute step on a given scene
-    void Execute( aiScene* pScene);
+	// -------------------------------------------------------------------
+	// Execute step on a given scene
+	void Execute(aiScene *pScene) override;
 
-    // -------------------------------------------------------------------
-    // Setup import settings
-    void SetupProperties(const Importer* pImp);
+	// -------------------------------------------------------------------
+	// Setup import settings
+	void SetupProperties(const Importer *pImp) override;
 
-    // -------------------------------------------------------------------
-    /** @brief Toggle the 'keep hierarchy' option
+	// -------------------------------------------------------------------
+	/** @brief Toggle the 'keep hierarchy' option
      *  @param keep    true for keep configuration.
      */
-    void KeepHierarchy(bool keep) {
-        configKeepHierarchy = keep;
-    }
+	void KeepHierarchy(bool keep) {
+		configKeepHierarchy = keep;
+	}
 
-    // -------------------------------------------------------------------
-    /** @brief Check whether 'keep hierarchy' is currently enabled.
+	// -------------------------------------------------------------------
+	/** @brief Check whether 'keep hierarchy' is currently enabled.
      *  @return ...
      */
-    bool IsHierarchyKept() const {
-        return configKeepHierarchy;
-    }
+	bool IsHierarchyKept() const {
+		return configKeepHierarchy;
+	}
 
 private:
-    // -------------------------------------------------------------------
-    // Count the number of nodes
-    unsigned int CountNodes( aiNode* pcNode );
+	// -------------------------------------------------------------------
+	// Count the number of nodes
+	unsigned int CountNodes(const aiNode *pcNode) const;
 
-    // -------------------------------------------------------------------
-    // Get a bitwise combination identifying the vertex format of a mesh
-    unsigned int GetMeshVFormat(aiMesh* pcMesh);
+	// -------------------------------------------------------------------
+	// Get a bitwise combination identifying the vertex format of a mesh
+	unsigned int GetMeshVFormat(aiMesh *pcMesh) const;
 
-    // -------------------------------------------------------------------
-    // Count the number of vertices in the whole scene and a given
-    // material index
-    void CountVerticesAndFaces( aiScene* pcScene, aiNode* pcNode,
-        unsigned int iMat,
-        unsigned int iVFormat,
-        unsigned int* piFaces,
-        unsigned int* piVertices);
+	// -------------------------------------------------------------------
+	// Count the number of vertices in the whole scene and a given
+	// material index
+	void CountVerticesAndFaces(const aiScene *pcScene, const aiNode *pcNode,
+			unsigned int iMat,
+			unsigned int iVFormat,
+			unsigned int *piFaces,
+			unsigned int *piVertices) const;
 
-    // -------------------------------------------------------------------
-    // Collect vertex/face data
-    void CollectData( aiScene* pcScene, aiNode* pcNode,
-        unsigned int iMat,
-        unsigned int iVFormat,
-        aiMesh* pcMeshOut,
-        unsigned int aiCurrent[2],
-        unsigned int* num_refs);
+	// -------------------------------------------------------------------
+	// Collect vertex/face data
+	void CollectData(const aiScene *pcScene, const aiNode *pcNode,
+			unsigned int iMat,
+			unsigned int iVFormat,
+			aiMesh *pcMeshOut,
+			unsigned int aiCurrent[2],
+			unsigned int *num_refs) const;
 
-    // -------------------------------------------------------------------
-    // Get a list of all vertex formats that occur for a given material
-    // The output list contains duplicate elements
-    void GetVFormatList( aiScene* pcScene, unsigned int iMat,
-        std::list<unsigned int>& aiOut);
+	// -------------------------------------------------------------------
+	// Get a list of all vertex formats that occur for a given material
+	// The output list contains duplicate elements
+	void GetVFormatList(const aiScene *pcScene, unsigned int iMat,
+			std::list<unsigned int> &aiOut) const;
 
-    // -------------------------------------------------------------------
-    // Compute the absolute transformation matrices of each node
-    void ComputeAbsoluteTransform( aiNode* pcNode );
+	// -------------------------------------------------------------------
+	// Compute the absolute transformation matrices of each node
+	void ComputeAbsoluteTransform(aiNode *pcNode);
 
-    // -------------------------------------------------------------------
-    // Simple routine to build meshes in worldspace, no further optimization
-    void BuildWCSMeshes(std::vector<aiMesh*>& out, aiMesh** in,
-        unsigned int numIn, aiNode* node);
+	// -------------------------------------------------------------------
+	// Simple routine to build meshes in worldspace, no further optimization
+	void BuildWCSMeshes(std::vector<aiMesh *> &out, aiMesh **in,
+			unsigned int numIn, aiNode *node) const;
 
-    // -------------------------------------------------------------------
-    // Apply the node transformation to a mesh
-    void ApplyTransform(aiMesh* mesh, const aiMatrix4x4& mat);
+	// -------------------------------------------------------------------
+	// Apply the node transformation to a mesh
+	void ApplyTransform(aiMesh *mesh, const aiMatrix4x4 &mat) const;
 
-    // -------------------------------------------------------------------
-    // Reset transformation matrices to identity
-    void MakeIdentityTransform(aiNode* nd);
+	// -------------------------------------------------------------------
+	// Reset transformation matrices to identity
+	void MakeIdentityTransform(aiNode *nd) const;
 
-    // -------------------------------------------------------------------
-    // Build reference counters for all meshes
-    void BuildMeshRefCountArray(aiNode* nd, unsigned int * refs);
+	// -------------------------------------------------------------------
+	// Build reference counters for all meshes
+	void BuildMeshRefCountArray(const aiNode *nd, unsigned int *refs) const;
 
-    //! Configuration option: keep scene hierarchy as long as possible
-    bool configKeepHierarchy;
-    bool configNormalize;
-    bool configTransform;
-    aiMatrix4x4 configTransformation;
-    bool mConfigPointCloud;
+	//! Configuration option: keep scene hierarchy as long as possible
+	bool configKeepHierarchy;
+	bool configNormalize;
+	bool configTransform;
+	aiMatrix4x4 configTransformation;
+	bool mConfigPointCloud;
 };
 
 } // end of namespace Assimp
diff --git a/Engine/lib/assimp/code/PostProcessing/ProcessHelper.cpp b/Engine/lib/assimp/code/PostProcessing/ProcessHelper.cpp
index 59869fdff..6f0a79825 100644
--- a/Engine/lib/assimp/code/PostProcessing/ProcessHelper.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/ProcessHelper.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -43,22 +43,19 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /// @file ProcessHelper.cpp
 /** Implement shared utility functions for postprocessing steps */
 
-
 #include "ProcessHelper.h"
 
-
 #include <limits>
 
 namespace Assimp {
 
 // -------------------------------------------------------------------------------
-void ConvertListToStrings(const std::string& in, std::list<std::string>& out)
-{
-    const char* s = in.c_str();
+void ConvertListToStrings(const std::string &in, std::list<std::string> &out) {
+    const char *s = in.c_str();
     while (*s) {
         SkipSpacesAndLineEnd(&s);
         if (*s == '\'') {
-            const char* base = ++s;
+            const char *base = ++s;
             while (*s != '\'') {
                 ++s;
                 if (*s == '\0') {
@@ -66,43 +63,39 @@ void ConvertListToStrings(const std::string& in, std::list<std::string>& out)
                     return;
                 }
             }
-            out.push_back(std::string(base,(size_t)(s-base)));
+            out.push_back(std::string(base, (size_t)(s - base)));
             ++s;
-        }
-        else {
+        } else {
             out.push_back(GetNextToken(s));
         }
     }
 }
 
 // -------------------------------------------------------------------------------
-void FindAABBTransformed (const aiMesh* mesh, aiVector3D& min, aiVector3D& max,
-    const aiMatrix4x4& m)
-{
-    min = aiVector3D ( ai_real( 10e10 ), ai_real( 10e10 ), ai_real( 10e10 ) );
-    max = aiVector3D ( ai_real( -10e10 ), ai_real( -10e10 ), ai_real( -10e10 ) );
-    for (unsigned int i = 0;i < mesh->mNumVertices;++i)
-    {
+void FindAABBTransformed(const aiMesh *mesh, aiVector3D &min, aiVector3D &max,
+        const aiMatrix4x4 &m) {
+    min = aiVector3D(ai_real(10e10), ai_real(10e10), ai_real(10e10));
+    max = aiVector3D(ai_real(-10e10), ai_real(-10e10), ai_real(-10e10));
+    for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
         const aiVector3D v = m * mesh->mVertices[i];
-        min = std::min(v,min);
-        max = std::max(v,max);
+        min = std::min(v, min);
+        max = std::max(v, max);
     }
 }
 
 // -------------------------------------------------------------------------------
-void FindMeshCenter (aiMesh* mesh, aiVector3D& out, aiVector3D& min, aiVector3D& max)
-{
-    ArrayBounds(mesh->mVertices,mesh->mNumVertices, min,max);
-    out = min + (max-min)*(ai_real)0.5;
+void FindMeshCenter(aiMesh *mesh, aiVector3D &out, aiVector3D &min, aiVector3D &max) {
+    ArrayBounds(mesh->mVertices, mesh->mNumVertices, min, max);
+    out = min + (max - min) * (ai_real)0.5;
 }
 
 // -------------------------------------------------------------------------------
-void FindSceneCenter (aiScene* scene, aiVector3D& out, aiVector3D& min, aiVector3D& max) {
-    if ( NULL == scene ) {
+void FindSceneCenter(aiScene *scene, aiVector3D &out, aiVector3D &min, aiVector3D &max) {
+    if (nullptr == scene) {
         return;
     }
 
-    if ( 0 == scene->mNumMeshes ) {
+    if (0 == scene->mNumMeshes) {
         return;
     }
     FindMeshCenter(scene->mMeshes[0], out, min, max);
@@ -116,79 +109,71 @@ void FindSceneCenter (aiScene* scene, aiVector3D& out, aiVector3D& min, aiVector
         if (max[1] < tmax[1]) max[1] = tmax[1];
         if (max[2] < tmax[2]) max[2] = tmax[2];
     }
-    out = min + (max-min)*(ai_real)0.5;
-}
-
-
-// -------------------------------------------------------------------------------
-void FindMeshCenterTransformed (aiMesh* mesh, aiVector3D& out, aiVector3D& min,
-    aiVector3D& max, const aiMatrix4x4& m)
-{
-    FindAABBTransformed(mesh,min,max,m);
-    out = min + (max-min)*(ai_real)0.5;
+    out = min + (max - min) * (ai_real)0.5;
 }
 
 // -------------------------------------------------------------------------------
-void FindMeshCenter (aiMesh* mesh, aiVector3D& out)
-{
-    aiVector3D min,max;
-    FindMeshCenter(mesh,out,min,max);
+void FindMeshCenterTransformed(aiMesh *mesh, aiVector3D &out, aiVector3D &min,
+        aiVector3D &max, const aiMatrix4x4 &m) {
+    FindAABBTransformed(mesh, min, max, m);
+    out = min + (max - min) * (ai_real)0.5;
 }
 
 // -------------------------------------------------------------------------------
-void FindMeshCenterTransformed (aiMesh* mesh, aiVector3D& out,
-    const aiMatrix4x4& m)
-{
-    aiVector3D min,max;
-    FindMeshCenterTransformed(mesh,out,min,max,m);
+void FindMeshCenter(aiMesh *mesh, aiVector3D &out) {
+    aiVector3D min, max;
+    FindMeshCenter(mesh, out, min, max);
 }
 
 // -------------------------------------------------------------------------------
-ai_real ComputePositionEpsilon(const aiMesh* pMesh)
-{
-    const ai_real epsilon = ai_real( 1e-4 );
+void FindMeshCenterTransformed(aiMesh *mesh, aiVector3D &out,
+        const aiMatrix4x4 &m) {
+    aiVector3D min, max;
+    FindMeshCenterTransformed(mesh, out, min, max, m);
+}
+
+// -------------------------------------------------------------------------------
+ai_real ComputePositionEpsilon(const aiMesh *pMesh) {
+    const ai_real epsilon = ai_real(1e-4);
 
     // calculate the position bounds so we have a reliable epsilon to check position differences against
     aiVector3D minVec, maxVec;
-    ArrayBounds(pMesh->mVertices,pMesh->mNumVertices,minVec,maxVec);
+    ArrayBounds(pMesh->mVertices, pMesh->mNumVertices, minVec, maxVec);
     return (maxVec - minVec).Length() * epsilon;
 }
 
 // -------------------------------------------------------------------------------
-ai_real ComputePositionEpsilon(const aiMesh* const* pMeshes, size_t num)
-{
-    ai_assert( NULL != pMeshes );
+ai_real ComputePositionEpsilon(const aiMesh *const *pMeshes, size_t num) {
+    ai_assert(nullptr != pMeshes);
 
-    const ai_real epsilon = ai_real( 1e-4 );
+    const ai_real epsilon = ai_real(1e-4);
 
     // calculate the position bounds so we have a reliable epsilon to check position differences against
     aiVector3D minVec, maxVec, mi, ma;
-    MinMaxChooser<aiVector3D>()(minVec,maxVec);
+    MinMaxChooser<aiVector3D>()(minVec, maxVec);
 
     for (size_t a = 0; a < num; ++a) {
-        const aiMesh* pMesh = pMeshes[a];
-        ArrayBounds(pMesh->mVertices,pMesh->mNumVertices,mi,ma);
+        const aiMesh *pMesh = pMeshes[a];
+        ArrayBounds(pMesh->mVertices, pMesh->mNumVertices, mi, ma);
 
-        minVec = std::min(minVec,mi);
-        maxVec = std::max(maxVec,ma);
+        minVec = std::min(minVec, mi);
+        maxVec = std::max(maxVec, ma);
     }
     return (maxVec - minVec).Length() * epsilon;
 }
 
-
 // -------------------------------------------------------------------------------
-unsigned int GetMeshVFormatUnique(const aiMesh* pcMesh)
-{
-    ai_assert(NULL != pcMesh);
+unsigned int GetMeshVFormatUnique(const aiMesh *pcMesh) {
+    ai_assert(nullptr != pcMesh);
 
     // FIX: the hash may never be 0. Otherwise a comparison against
     // nullptr could be successful
     unsigned int iRet = 1;
 
     // normals
-    if (pcMesh->HasNormals())iRet |= 0x2;
+    if (pcMesh->HasNormals()) iRet |= 0x2;
     // tangents and bitangents
-    if (pcMesh->HasTangentsAndBitangents())iRet |= 0x4;
+    if (pcMesh->HasTangentsAndBitangents()) iRet |= 0x4;
 
 #ifdef BOOST_STATIC_ASSERT
     BOOST_STATIC_ASSERT(8 >= AI_MAX_NUMBER_OF_COLOR_SETS);
@@ -197,8 +182,7 @@ unsigned int GetMeshVFormatUnique(const aiMesh* pcMesh)
 
     // texture coordinates
     unsigned int p = 0;
-    while (pcMesh->HasTextureCoords(p))
-    {
+    while (pcMesh->HasTextureCoords(p)) {
         iRet |= (0x100 << p);
         if (3 == pcMesh->mNumUVComponents[p])
             iRet |= (0x10000 << p);
@@ -207,74 +191,32 @@ unsigned int GetMeshVFormatUnique(const aiMesh* pcMesh)
     }
     // vertex colors
     p = 0;
-    while (pcMesh->HasVertexColors(p))iRet |= (0x1000000 << p++);
+    while (pcMesh->HasVertexColors(p))
+        iRet |= (0x1000000 << p++);
     return iRet;
 }
 
 // -------------------------------------------------------------------------------
-VertexWeightTable* ComputeVertexBoneWeightTable(const aiMesh* pMesh)
-{
+VertexWeightTable *ComputeVertexBoneWeightTable(const aiMesh *pMesh) {
     if (!pMesh || !pMesh->mNumVertices || !pMesh->mNumBones) {
-        return NULL;
+        return nullptr;
     }
 
-    VertexWeightTable* avPerVertexWeights = new VertexWeightTable[pMesh->mNumVertices];
-    for (unsigned int i = 0; i < pMesh->mNumBones;++i)  {
+    VertexWeightTable *avPerVertexWeights = new VertexWeightTable[pMesh->mNumVertices];
+    for (unsigned int i = 0; i < pMesh->mNumBones; ++i) {
 
-        aiBone* bone = pMesh->mBones[i];
-        for (unsigned int a = 0; a < bone->mNumWeights;++a) {
-            const aiVertexWeight& weight = bone->mWeights[a];
-            avPerVertexWeights[weight.mVertexId].push_back( std::pair<unsigned int,float>(i,weight.mWeight) );
+        aiBone *bone = pMesh->mBones[i];
+        for (unsigned int a = 0; a < bone->mNumWeights; ++a) {
+            const aiVertexWeight &weight = bone->mWeights[a];
+            avPerVertexWeights[weight.mVertexId].push_back(std::pair<unsigned int, float>(i, weight.mWeight));
         }
     }
     return avPerVertexWeights;
 }
 
-
 // -------------------------------------------------------------------------------
-const char* TextureTypeToString(aiTextureType in)
-{
-    switch (in)
-    {
-    case aiTextureType_NONE:
-        return "n/a";
-    case aiTextureType_DIFFUSE:
-        return "Diffuse";
-    case aiTextureType_SPECULAR:
-        return "Specular";
-    case aiTextureType_AMBIENT:
-        return "Ambient";
-    case aiTextureType_EMISSIVE:
-        return "Emissive";
-    case aiTextureType_OPACITY:
-        return "Opacity";
-    case aiTextureType_NORMALS:
-        return "Normals";
-    case aiTextureType_HEIGHT:
-        return "Height";
-    case aiTextureType_SHININESS:
-        return "Shininess";
-    case aiTextureType_DISPLACEMENT:
-        return "Displacement";
-    case aiTextureType_LIGHTMAP:
-        return "Lightmap";
-    case aiTextureType_REFLECTION:
-        return "Reflection";
-    case aiTextureType_UNKNOWN:
-        return "Unknown";
-    default:
-        break;
-    }
-
-    ai_assert(false);
-    return  "BUG";
-}
-
-// -------------------------------------------------------------------------------
-const char* MappingTypeToString(aiTextureMapping in)
-{
-    switch (in)
-    {
+const char *MappingTypeToString(aiTextureMapping in) {
+    switch (in) {
     case aiTextureMapping_UV:
         return "UV";
     case aiTextureMapping_BOX:
@@ -292,24 +234,22 @@ const char* MappingTypeToString(aiTextureMapping in)
     }
 
     ai_assert(false);
-    return  "BUG";
+    return "BUG";
 }
 
-
 // -------------------------------------------------------------------------------
-aiMesh* MakeSubmesh(const aiMesh *pMesh, const std::vector<unsigned int> &subMeshFaces, unsigned int subFlags)
-{
+aiMesh *MakeSubmesh(const aiMesh *pMesh, const std::vector<unsigned int> &subMeshFaces, unsigned int subFlags) {
     aiMesh *oMesh = new aiMesh();
-    std::vector<unsigned int> vMap(pMesh->mNumVertices,UINT_MAX);
+    std::vector<unsigned int> vMap(pMesh->mNumVertices, UINT_MAX);
 
     size_t numSubVerts = 0;
     size_t numSubFaces = subMeshFaces.size();
 
-    for(unsigned int i=0;i<numSubFaces;i++) {
+    for (unsigned int i = 0; i < numSubFaces; i++) {
         const aiFace &f = pMesh->mFaces[subMeshFaces[i]];
 
-        for(unsigned int j=0;j<f.mNumIndices;j++)   {
-            if(vMap[f.mIndices[j]]==UINT_MAX)   {
+        for (unsigned int j = 0; j < f.mNumIndices; j++) {
+            if (vMap[f.mIndices[j]] == UINT_MAX) {
                 vMap[f.mIndices[j]] = static_cast<unsigned int>(numSubVerts++);
             }
         }
@@ -325,114 +265,114 @@ aiMesh* MakeSubmesh(const aiMesh *pMesh, const std::vector<unsigned int> &subMes
     oMesh->mNumFaces = static_cast<unsigned int>(subMeshFaces.size());
     oMesh->mNumVertices = static_cast<unsigned int>(numSubVerts);
     oMesh->mVertices = new aiVector3D[numSubVerts];
-    if( pMesh->HasNormals() ) {
+    if (pMesh->HasNormals()) {
         oMesh->mNormals = new aiVector3D[numSubVerts];
     }
 
-    if( pMesh->HasTangentsAndBitangents() ) {
+    if (pMesh->HasTangentsAndBitangents()) {
         oMesh->mTangents = new aiVector3D[numSubVerts];
         oMesh->mBitangents = new aiVector3D[numSubVerts];
     }
 
-    for( size_t a = 0;  pMesh->HasTextureCoords(static_cast<unsigned int>(a)) ; ++a ) {
+    for (size_t a = 0; pMesh->HasTextureCoords(static_cast<unsigned int>(a)); ++a) {
         oMesh->mTextureCoords[a] = new aiVector3D[numSubVerts];
         oMesh->mNumUVComponents[a] = pMesh->mNumUVComponents[a];
     }
 
-    for( size_t a = 0; pMesh->HasVertexColors( static_cast<unsigned int>(a)); ++a )    {
+    for (size_t a = 0; pMesh->HasVertexColors(static_cast<unsigned int>(a)); ++a) {
         oMesh->mColors[a] = new aiColor4D[numSubVerts];
     }
 
     // and copy over the data, generating faces with linear indices along the way
     oMesh->mFaces = new aiFace[numSubFaces];
 
-    for(unsigned int a = 0; a < numSubFaces; ++a )  {
+    for (unsigned int a = 0; a < numSubFaces; ++a) {
 
-        const aiFace& srcFace = pMesh->mFaces[subMeshFaces[a]];
-        aiFace& dstFace = oMesh->mFaces[a];
+        const aiFace &srcFace = pMesh->mFaces[subMeshFaces[a]];
+        aiFace &dstFace = oMesh->mFaces[a];
         dstFace.mNumIndices = srcFace.mNumIndices;
         dstFace.mIndices = new unsigned int[dstFace.mNumIndices];
 
         // accumulate linearly all the vertices of the source face
-        for( size_t b = 0; b < dstFace.mNumIndices; ++b )   {
+        for (size_t b = 0; b < dstFace.mNumIndices; ++b) {
             dstFace.mIndices[b] = vMap[srcFace.mIndices[b]];
         }
     }
 
-    for(unsigned int srcIndex = 0; srcIndex < pMesh->mNumVertices; ++srcIndex ) {
+    for (unsigned int srcIndex = 0; srcIndex < pMesh->mNumVertices; ++srcIndex) {
         unsigned int nvi = vMap[srcIndex];
-        if(nvi==UINT_MAX) {
+        if (nvi == UINT_MAX) {
             continue;
         }
 
         oMesh->mVertices[nvi] = pMesh->mVertices[srcIndex];
-        if( pMesh->HasNormals() ) {
+        if (pMesh->HasNormals()) {
             oMesh->mNormals[nvi] = pMesh->mNormals[srcIndex];
         }
 
-        if( pMesh->HasTangentsAndBitangents() ) {
+        if (pMesh->HasTangentsAndBitangents()) {
             oMesh->mTangents[nvi] = pMesh->mTangents[srcIndex];
             oMesh->mBitangents[nvi] = pMesh->mBitangents[srcIndex];
         }
-        for( size_t c = 0, cc = pMesh->GetNumUVChannels(); c < cc; ++c )    {
-                oMesh->mTextureCoords[c][nvi] = pMesh->mTextureCoords[c][srcIndex];
+        for (size_t c = 0, cc = pMesh->GetNumUVChannels(); c < cc; ++c) {
+            oMesh->mTextureCoords[c][nvi] = pMesh->mTextureCoords[c][srcIndex];
         }
-        for( size_t c = 0, cc = pMesh->GetNumColorChannels(); c < cc; ++c ) {
+        for (size_t c = 0, cc = pMesh->GetNumColorChannels(); c < cc; ++c) {
             oMesh->mColors[c][nvi] = pMesh->mColors[c][srcIndex];
         }
     }
 
-    if(~subFlags&AI_SUBMESH_FLAGS_SANS_BONES)   {
-        std::vector<unsigned int> subBones(pMesh->mNumBones,0);
+    if (~subFlags & AI_SUBMESH_FLAGS_SANS_BONES) {
+        std::vector<unsigned int> subBones(pMesh->mNumBones, 0);
 
-        for(unsigned int a=0;a<pMesh->mNumBones;++a)    {
-            const aiBone* bone = pMesh->mBones[a];
+        for (unsigned int a = 0; a < pMesh->mNumBones; ++a) {
+            const aiBone *bone = pMesh->mBones[a];
 
-            for(unsigned int b=0;b<bone->mNumWeights;b++)   {
+            for (unsigned int b = 0; b < bone->mNumWeights; b++) {
                 unsigned int v = vMap[bone->mWeights[b].mVertexId];
 
-                if(v!=UINT_MAX) {
+                if (v != UINT_MAX) {
                     subBones[a]++;
                 }
             }
         }
 
-        for(unsigned int a=0;a<pMesh->mNumBones;++a)    {
-            if(subBones[a]>0) {
+        for (unsigned int a = 0; a < pMesh->mNumBones; ++a) {
+            if (subBones[a] > 0) {
                 oMesh->mNumBones++;
             }
         }
 
-        if(oMesh->mNumBones) {
-            oMesh->mBones = new aiBone*[oMesh->mNumBones]();
+        if (oMesh->mNumBones) {
+            oMesh->mBones = new aiBone *[oMesh->mNumBones]();
             unsigned int nbParanoia = oMesh->mNumBones;
 
             oMesh->mNumBones = 0; //rewind
 
-            for(unsigned int a=0;a<pMesh->mNumBones;++a)    {
-                if(subBones[a]==0) {
+            for (unsigned int a = 0; a < pMesh->mNumBones; ++a) {
+                if (subBones[a] == 0) {
                     continue;
                 }
                 aiBone *newBone = new aiBone;
                 oMesh->mBones[oMesh->mNumBones++] = newBone;
 
-                const aiBone* bone = pMesh->mBones[a];
+                const aiBone *bone = pMesh->mBones[a];
 
                 newBone->mName = bone->mName;
                 newBone->mOffsetMatrix = bone->mOffsetMatrix;
                 newBone->mWeights = new aiVertexWeight[subBones[a]];
 
-                for(unsigned int b=0;b<bone->mNumWeights;b++)   {
+                for (unsigned int b = 0; b < bone->mNumWeights; b++) {
                     const unsigned int v = vMap[bone->mWeights[b].mVertexId];
 
-                    if(v!=UINT_MAX) {
-                        aiVertexWeight w(v,bone->mWeights[b].mWeight);
+                    if (v != UINT_MAX) {
+                        aiVertexWeight w(v, bone->mWeights[b].mWeight);
                         newBone->mWeights[newBone->mNumWeights++] = w;
                     }
                 }
             }
 
-            ai_assert(nbParanoia==oMesh->mNumBones);
+            ai_assert(nbParanoia == oMesh->mNumBones);
             (void)nbParanoia; // remove compiler warning on release build
         }
     }
diff --git a/Engine/lib/assimp/code/PostProcessing/ProcessHelper.h b/Engine/lib/assimp/code/PostProcessing/ProcessHelper.h
index 0afcc4142..78df94ca1 100644
--- a/Engine/lib/assimp/code/PostProcessing/ProcessHelper.h
+++ b/Engine/lib/assimp/code/PostProcessing/ProcessHelper.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -43,16 +43,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_PROCESS_HELPER_H_INCLUDED
 #define AI_PROCESS_HELPER_H_INCLUDED
 
-#include <assimp/postprocess.h>
 #include <assimp/anim.h>
-#include <assimp/mesh.h>
 #include <assimp/material.h>
-#include <assimp/DefaultLogger.hpp>
+#include <assimp/mesh.h>
+#include <assimp/postprocess.h>
 #include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
 
-#include <assimp/SpatialSort.h>
 #include "Common/BaseProcess.h"
 #include <assimp/ParsingUtils.h>
+#include <assimp/SpatialSort.h>
 
 #include <list>
 
@@ -63,86 +63,83 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifdef __cplusplus
 namespace std {
 
-    // std::min for aiVector3D
-    template <typename TReal>
-    inline ::aiVector3t<TReal> min (const ::aiVector3t<TReal>& a, const ::aiVector3t<TReal>& b) {
-        return ::aiVector3t<TReal> (min(a.x,b.x),min(a.y,b.y),min(a.z,b.z));
-    }
+// std::min for aiVector3D
+template <typename TReal>
+inline ::aiVector3t<TReal> min(const ::aiVector3t<TReal> &a, const ::aiVector3t<TReal> &b) {
+    return ::aiVector3t<TReal>(min(a.x, b.x), min(a.y, b.y), min(a.z, b.z));
+}
 
-    // std::max for aiVector3t<TReal>
-    template <typename TReal>
-    inline ::aiVector3t<TReal> max (const ::aiVector3t<TReal>& a, const ::aiVector3t<TReal>& b) {
-        return ::aiVector3t<TReal> (max(a.x,b.x),max(a.y,b.y),max(a.z,b.z));
-    }
+// std::max for aiVector3t<TReal>
+template <typename TReal>
+inline ::aiVector3t<TReal> max(const ::aiVector3t<TReal> &a, const ::aiVector3t<TReal> &b) {
+    return ::aiVector3t<TReal>(max(a.x, b.x), max(a.y, b.y), max(a.z, b.z));
+}
 
-    // std::min for aiVector2t<TReal>
-    template <typename TReal>
-    inline ::aiVector2t<TReal> min (const ::aiVector2t<TReal>& a, const ::aiVector2t<TReal>& b) {
-        return ::aiVector2t<TReal> (min(a.x,b.x),min(a.y,b.y));
-    }
+// std::min for aiVector2t<TReal>
+template <typename TReal>
+inline ::aiVector2t<TReal> min(const ::aiVector2t<TReal> &a, const ::aiVector2t<TReal> &b) {
+    return ::aiVector2t<TReal>(min(a.x, b.x), min(a.y, b.y));
+}
 
-    // std::max for aiVector2t<TReal>
-    template <typename TReal>
-    inline ::aiVector2t<TReal> max (const ::aiVector2t<TReal>& a, const ::aiVector2t<TReal>& b) {
-        return ::aiVector2t<TReal> (max(a.x,b.x),max(a.y,b.y));
-    }
+// std::max for aiVector2t<TReal>
+template <typename TReal>
+inline ::aiVector2t<TReal> max(const ::aiVector2t<TReal> &a, const ::aiVector2t<TReal> &b) {
+    return ::aiVector2t<TReal>(max(a.x, b.x), max(a.y, b.y));
+}
 
-    // std::min for aiColor4D
-    template <typename TReal>
-    inline ::aiColor4t<TReal> min (const ::aiColor4t<TReal>& a, const ::aiColor4t<TReal>& b)    {
-        return ::aiColor4t<TReal> (min(a.r,b.r),min(a.g,b.g),min(a.b,b.b),min(a.a,b.a));
-    }
+// std::min for aiColor4D
+template <typename TReal>
+inline ::aiColor4t<TReal> min(const ::aiColor4t<TReal> &a, const ::aiColor4t<TReal> &b) {
+    return ::aiColor4t<TReal>(min(a.r, b.r), min(a.g, b.g), min(a.b, b.b), min(a.a, b.a));
+}
 
-    // std::max for aiColor4D
-    template <typename TReal>
-    inline ::aiColor4t<TReal> max (const ::aiColor4t<TReal>& a, const ::aiColor4t<TReal>& b)    {
-        return ::aiColor4t<TReal> (max(a.r,b.r),max(a.g,b.g),max(a.b,b.b),max(a.a,b.a));
-    }
+// std::max for aiColor4D
+template <typename TReal>
+inline ::aiColor4t<TReal> max(const ::aiColor4t<TReal> &a, const ::aiColor4t<TReal> &b) {
+    return ::aiColor4t<TReal>(max(a.r, b.r), max(a.g, b.g), max(a.b, b.b), max(a.a, b.a));
+}
 
+// std::min for aiQuaterniont<TReal>
+template <typename TReal>
+inline ::aiQuaterniont<TReal> min(const ::aiQuaterniont<TReal> &a, const ::aiQuaterniont<TReal> &b) {
+    return ::aiQuaterniont<TReal>(min(a.w, b.w), min(a.x, b.x), min(a.y, b.y), min(a.z, b.z));
+}
 
-    // std::min for aiQuaterniont<TReal>
-    template <typename TReal>
-    inline ::aiQuaterniont<TReal> min (const ::aiQuaterniont<TReal>& a, const ::aiQuaterniont<TReal>& b)    {
-        return ::aiQuaterniont<TReal> (min(a.w,b.w),min(a.x,b.x),min(a.y,b.y),min(a.z,b.z));
-    }
+// std::max for aiQuaterniont<TReal>
+template <typename TReal>
+inline ::aiQuaterniont<TReal> max(const ::aiQuaterniont<TReal> &a, const ::aiQuaterniont<TReal> &b) {
+    return ::aiQuaterniont<TReal>(max(a.w, b.w), max(a.x, b.x), max(a.y, b.y), max(a.z, b.z));
+}
 
-    // std::max for aiQuaterniont<TReal>
-    template <typename TReal>
-    inline ::aiQuaterniont<TReal> max (const ::aiQuaterniont<TReal>& a, const ::aiQuaterniont<TReal>& b)    {
-        return ::aiQuaterniont<TReal> (max(a.w,b.w),max(a.x,b.x),max(a.y,b.y),max(a.z,b.z));
-    }
+// std::min for aiVectorKey
+inline ::aiVectorKey min(const ::aiVectorKey &a, const ::aiVectorKey &b) {
+    return ::aiVectorKey(min(a.mTime, b.mTime), min(a.mValue, b.mValue));
+}
 
+// std::max for aiVectorKey
+inline ::aiVectorKey max(const ::aiVectorKey &a, const ::aiVectorKey &b) {
+    return ::aiVectorKey(max(a.mTime, b.mTime), max(a.mValue, b.mValue));
+}
 
+// std::min for aiQuatKey
+inline ::aiQuatKey min(const ::aiQuatKey &a, const ::aiQuatKey &b) {
+    return ::aiQuatKey(min(a.mTime, b.mTime), min(a.mValue, b.mValue));
+}
 
-    // std::min for aiVectorKey
-    inline ::aiVectorKey min (const ::aiVectorKey& a, const ::aiVectorKey& b)   {
-        return ::aiVectorKey (min(a.mTime,b.mTime),min(a.mValue,b.mValue));
-    }
+// std::max for aiQuatKey
+inline ::aiQuatKey max(const ::aiQuatKey &a, const ::aiQuatKey &b) {
+    return ::aiQuatKey(max(a.mTime, b.mTime), max(a.mValue, b.mValue));
+}
 
-    // std::max for aiVectorKey
-    inline ::aiVectorKey max (const ::aiVectorKey& a, const ::aiVectorKey& b)   {
-        return ::aiVectorKey (max(a.mTime,b.mTime),max(a.mValue,b.mValue));
-    }
+// std::min for aiVertexWeight
+inline ::aiVertexWeight min(const ::aiVertexWeight &a, const ::aiVertexWeight &b) {
+    return ::aiVertexWeight(min(a.mVertexId, b.mVertexId),static_cast<ai_real>(min(a.mWeight, b.mWeight)));
+}
 
-    // std::min for aiQuatKey
-    inline ::aiQuatKey min (const ::aiQuatKey& a, const ::aiQuatKey& b) {
-        return ::aiQuatKey (min(a.mTime,b.mTime),min(a.mValue,b.mValue));
-    }
-
-    // std::max for aiQuatKey
-    inline ::aiQuatKey max (const ::aiQuatKey& a, const ::aiQuatKey& b) {
-        return ::aiQuatKey (max(a.mTime,b.mTime),max(a.mValue,b.mValue));
-    }
-
-    // std::min for aiVertexWeight
-    inline ::aiVertexWeight min (const ::aiVertexWeight& a, const ::aiVertexWeight& b)  {
-        return ::aiVertexWeight (min(a.mVertexId,b.mVertexId),min(a.mWeight,b.mWeight));
-    }
-
-    // std::max for aiVertexWeight
-    inline ::aiVertexWeight max (const ::aiVertexWeight& a, const ::aiVertexWeight& b)  {
-        return ::aiVertexWeight (max(a.mVertexId,b.mVertexId),max(a.mWeight,b.mWeight));
-    }
+// std::max for aiVertexWeight
+inline ::aiVertexWeight max(const ::aiVertexWeight &a, const ::aiVertexWeight &b) {
+    return ::aiVertexWeight(max(a.mVertexId, b.mVertexId), static_cast<ai_real>(max(a.mWeight, b.mWeight)));
+}
 
 } // end namespace std
 #endif // !! C++
@@ -154,60 +151,80 @@ namespace Assimp {
 template <typename T>
 struct MinMaxChooser;
 
-template <> struct MinMaxChooser<float> {
-    void operator ()(float& min,float& max) {
+template <>
+struct MinMaxChooser<float> {
+    void operator()(float &min, float &max) {
         max = -1e10f;
-        min =  1e10f;
-}};
-template <> struct MinMaxChooser<double> {
-    void operator ()(double& min,double& max) {
+        min = 1e10f;
+    }
+};
+template <>
+struct MinMaxChooser<double> {
+    void operator()(double &min, double &max) {
         max = -1e10;
-        min =  1e10;
-}};
-template <> struct MinMaxChooser<unsigned int> {
-    void operator ()(unsigned int& min,unsigned int& max) {
+        min = 1e10;
+    }
+};
+template <>
+struct MinMaxChooser<unsigned int> {
+    void operator()(unsigned int &min, unsigned int &max) {
         max = 0;
-        min = (1u<<(sizeof(unsigned int)*8-1));
-}};
+        min = (1u << (sizeof(unsigned int) * 8 - 1));
+    }
+};
 
-template <typename T> struct MinMaxChooser< aiVector3t<T> > {
-    void operator ()(aiVector3t<T>& min,aiVector3t<T>& max) {
-        max = aiVector3t<T>(-1e10f,-1e10f,-1e10f);
-        min = aiVector3t<T>( 1e10f, 1e10f, 1e10f);
-}};
-template <typename T> struct MinMaxChooser< aiVector2t<T> > {
-    void operator ()(aiVector2t<T>& min,aiVector2t<T>& max) {
-        max = aiVector2t<T>(-1e10f,-1e10f);
-        min = aiVector2t<T>( 1e10f, 1e10f);
-    }};
-template <typename T> struct MinMaxChooser< aiColor4t<T> > {
-    void operator ()(aiColor4t<T>& min,aiColor4t<T>& max) {
-        max = aiColor4t<T>(-1e10f,-1e10f,-1e10f,-1e10f);
-        min = aiColor4t<T>( 1e10f, 1e10f, 1e10f, 1e10f);
-}};
+template <typename T>
+struct MinMaxChooser<aiVector3t<T>> {
+    void operator()(aiVector3t<T> &min, aiVector3t<T> &max) {
+        max = aiVector3t<T>(-1e10f, -1e10f, -1e10f);
+        min = aiVector3t<T>(1e10f, 1e10f, 1e10f);
+    }
+};
+template <typename T>
+struct MinMaxChooser<aiVector2t<T>> {
+    void operator()(aiVector2t<T> &min, aiVector2t<T> &max) {
+        max = aiVector2t<T>(-1e10f, -1e10f);
+        min = aiVector2t<T>(1e10f, 1e10f);
+    }
+};
+template <typename T>
+struct MinMaxChooser<aiColor4t<T>> {
+    void operator()(aiColor4t<T> &min, aiColor4t<T> &max) {
+        max = aiColor4t<T>(-1e10f, -1e10f, -1e10f, -1e10f);
+        min = aiColor4t<T>(1e10f, 1e10f, 1e10f, 1e10f);
+    }
+};
 
-template <typename T> struct MinMaxChooser< aiQuaterniont<T> > {
-    void operator ()(aiQuaterniont<T>& min,aiQuaterniont<T>& max) {
-        max = aiQuaterniont<T>(-1e10f,-1e10f,-1e10f,-1e10f);
-        min = aiQuaterniont<T>( 1e10f, 1e10f, 1e10f, 1e10f);
-}};
+template <typename T>
+struct MinMaxChooser<aiQuaterniont<T>> {
+    void operator()(aiQuaterniont<T> &min, aiQuaterniont<T> &max) {
+        max = aiQuaterniont<T>(-1e10f, -1e10f, -1e10f, -1e10f);
+        min = aiQuaterniont<T>(1e10f, 1e10f, 1e10f, 1e10f);
+    }
+};
 
-template <> struct MinMaxChooser<aiVectorKey> {
-    void operator ()(aiVectorKey& min,aiVectorKey& max) {
-        MinMaxChooser<double>()(min.mTime,max.mTime);
-        MinMaxChooser<aiVector3D>()(min.mValue,max.mValue);
-}};
-template <> struct MinMaxChooser<aiQuatKey> {
-    void operator ()(aiQuatKey& min,aiQuatKey& max) {
-        MinMaxChooser<double>()(min.mTime,max.mTime);
-        MinMaxChooser<aiQuaternion>()(min.mValue,max.mValue);
-}};
+template <>
+struct MinMaxChooser<aiVectorKey> {
+    void operator()(aiVectorKey &min, aiVectorKey &max) {
+        MinMaxChooser<double>()(min.mTime, max.mTime);
+        MinMaxChooser<aiVector3D>()(min.mValue, max.mValue);
+    }
+};
+template <>
+struct MinMaxChooser<aiQuatKey> {
+    void operator()(aiQuatKey &min, aiQuatKey &max) {
+        MinMaxChooser<double>()(min.mTime, max.mTime);
+        MinMaxChooser<aiQuaternion>()(min.mValue, max.mValue);
+    }
+};
 
-template <> struct MinMaxChooser<aiVertexWeight> {
-    void operator ()(aiVertexWeight& min,aiVertexWeight& max) {
-        MinMaxChooser<unsigned int>()(min.mVertexId,max.mVertexId);
-        MinMaxChooser<float>()(min.mWeight,max.mWeight);
-}};
+template <>
+struct MinMaxChooser<aiVertexWeight> {
+    void operator()(aiVertexWeight &min, aiVertexWeight &max) {
+        MinMaxChooser<unsigned int>()(min.mVertexId, max.mVertexId);
+        MinMaxChooser<ai_real>()(min.mWeight, max.mWeight);
+    }
+};
 
 // -------------------------------------------------------------------------------
 /** @brief Find the min/max values of an array of Ts
@@ -217,36 +234,31 @@ template <> struct MinMaxChooser<aiVertexWeight> {
  *  @param[out] max maximum value
  */
 template <typename T>
-inline void ArrayBounds(const T* in, unsigned int size, T& min, T& max)
-{
-    MinMaxChooser<T> ()(min,max);
-    for (unsigned int i = 0; i < size;++i) {
-        min = std::min(in[i],min);
-        max = std::max(in[i],max);
+inline void ArrayBounds(const T *in, unsigned int size, T &min, T &max) {
+    MinMaxChooser<T>()(min, max);
+    for (unsigned int i = 0; i < size; ++i) {
+        min = std::min(in[i], min);
+        max = std::max(in[i], max);
     }
 }
 
-
 // -------------------------------------------------------------------------------
 /** Little helper function to calculate the quadratic difference
- * of two colours.
+ * of two colors.
  * @param pColor1 First color
  * @param pColor2 second color
  * @return Quadratic color difference */
-inline ai_real GetColorDifference( const aiColor4D& pColor1, const aiColor4D& pColor2)
-{
-    const aiColor4D c (pColor1.r - pColor2.r, pColor1.g - pColor2.g, pColor1.b - pColor2.b, pColor1.a - pColor2.a);
-    return c.r*c.r + c.g*c.g + c.b*c.b + c.a*c.a;
+inline ai_real GetColorDifference(const aiColor4D &pColor1, const aiColor4D &pColor2) {
+    const aiColor4D c(pColor1.r - pColor2.r, pColor1.g - pColor2.g, pColor1.b - pColor2.b, pColor1.a - pColor2.a);
+    return c.r * c.r + c.g * c.g + c.b * c.b + c.a * c.a;
 }
 
-
 // -------------------------------------------------------------------------------
 /** @brief Extract single strings from a list of identifiers
  *  @param in Input string list.
  *  @param out Receives a list of clean output strings
  *  @sdee #AI_CONFIG_PP_OG_EXCLUDE_LIST */
-void ConvertListToStrings(const std::string& in, std::list<std::string>& out);
-
+void ConvertListToStrings(const std::string &in, std::list<std::string> &out);
 
 // -------------------------------------------------------------------------------
 /** @brief Compute the AABB of a mesh after applying a given transform
@@ -254,8 +266,7 @@ void ConvertListToStrings(const std::string& in, std::list<std::string>& out);
  *  @param[out] min Receives minimum transformed vertex
  *  @param[out] max Receives maximum transformed vertex
  *  @param m Transformation matrix to be applied */
-void FindAABBTransformed (const aiMesh* mesh, aiVector3D& min, aiVector3D& max, const aiMatrix4x4& m);
-
+void FindAABBTransformed(const aiMesh *mesh, aiVector3D &min, aiVector3D &max, const aiMatrix4x4 &m);
 
 // -------------------------------------------------------------------------------
 /** @brief Helper function to determine the 'real' center of a mesh
@@ -265,7 +276,7 @@ void FindAABBTransformed (const aiMesh* mesh, aiVector3D& min, aiVector3D& max,
  *  @param[out] min Minimum vertex of the mesh
  *  @param[out] max maximum vertex of the mesh
  *  @param[out] out Center point */
-void FindMeshCenter (aiMesh* mesh, aiVector3D& out, aiVector3D& min, aiVector3D& max);
+void FindMeshCenter(aiMesh *mesh, aiVector3D &out, aiVector3D &min, aiVector3D &max);
 
 // -------------------------------------------------------------------------------
 /** @brief Helper function to determine the 'real' center of a scene
@@ -275,112 +286,91 @@ void FindMeshCenter (aiMesh* mesh, aiVector3D& out, aiVector3D& min, aiVector3D&
  *  @param[out] min Minimum vertex of the scene
  *  @param[out] max maximum vertex of the scene
  *  @param[out] out Center point */
-void FindSceneCenter (aiScene* scene, aiVector3D& out, aiVector3D& min, aiVector3D& max);
-
+void FindSceneCenter(aiScene *scene, aiVector3D &out, aiVector3D &min, aiVector3D &max);
 
 // -------------------------------------------------------------------------------
 // Helper function to determine the 'real' center of a mesh after applying a given transform
-void FindMeshCenterTransformed (aiMesh* mesh, aiVector3D& out, aiVector3D& min,aiVector3D& max, const aiMatrix4x4& m);
-
+void FindMeshCenterTransformed(aiMesh *mesh, aiVector3D &out, aiVector3D &min, aiVector3D &max, const aiMatrix4x4 &m);
 
 // -------------------------------------------------------------------------------
 // Helper function to determine the 'real' center of a mesh
-void FindMeshCenter (aiMesh* mesh, aiVector3D& out);
-
+void FindMeshCenter(aiMesh *mesh, aiVector3D &out);
 
 // -------------------------------------------------------------------------------
 // Helper function to determine the 'real' center of a mesh after applying a given transform
-void FindMeshCenterTransformed (aiMesh* mesh, aiVector3D& out,const aiMatrix4x4& m);
-
+void FindMeshCenterTransformed(aiMesh *mesh, aiVector3D &out, const aiMatrix4x4 &m);
 
 // -------------------------------------------------------------------------------
 // Compute a good epsilon value for position comparisons on a mesh
-ai_real ComputePositionEpsilon(const aiMesh* pMesh);
-
+ai_real ComputePositionEpsilon(const aiMesh *pMesh);
 
 // -------------------------------------------------------------------------------
 // Compute a good epsilon value for position comparisons on a array of meshes
-ai_real ComputePositionEpsilon(const aiMesh* const* pMeshes, size_t num);
-
+ai_real ComputePositionEpsilon(const aiMesh *const *pMeshes, size_t num);
 
 // -------------------------------------------------------------------------------
 // Compute an unique value for the vertex format of a mesh
-unsigned int GetMeshVFormatUnique(const aiMesh* pcMesh);
-
+unsigned int GetMeshVFormatUnique(const aiMesh *pcMesh);
 
 // defs for ComputeVertexBoneWeightTable()
-typedef std::pair <unsigned int,float> PerVertexWeight;
-typedef std::vector <PerVertexWeight> VertexWeightTable;
+using PerVertexWeight = std::pair<unsigned int, float>;
+using VertexWeightTable = std::vector<PerVertexWeight>;
 
 // -------------------------------------------------------------------------------
 // Compute a per-vertex bone weight table
-VertexWeightTable* ComputeVertexBoneWeightTable(const aiMesh* pMesh);
-
-
-// -------------------------------------------------------------------------------
-// Get a string for a given aiTextureType
-const char* TextureTypeToString(aiTextureType in);
-
+VertexWeightTable *ComputeVertexBoneWeightTable(const aiMesh *pMesh);
 
 // -------------------------------------------------------------------------------
 // Get a string for a given aiTextureMapping
-const char* MappingTypeToString(aiTextureMapping in);
-
+const char *MappingTypeToString(aiTextureMapping in);
 
 // flags for MakeSubmesh()
 #define AI_SUBMESH_FLAGS_SANS_BONES 0x1
 
 // -------------------------------------------------------------------------------
 // Split a mesh given a list of faces to be contained in the sub mesh
-aiMesh* MakeSubmesh(const aiMesh *superMesh, const std::vector<unsigned int> &subMeshFaces, unsigned int subFlags);
+aiMesh *MakeSubmesh(const aiMesh *superMesh, const std::vector<unsigned int> &subMeshFaces, unsigned int subFlags);
 
 // -------------------------------------------------------------------------------
-// Utility postprocess step to share the spatial sort tree between
+// Utility post-process step to share the spatial sort tree between
 // all steps which use it to speedup its computations.
-class ComputeSpatialSortProcess : public BaseProcess
-{
-    bool IsActive( unsigned int pFlags) const
-    {
-        return NULL != shared && 0 != (pFlags & (aiProcess_CalcTangentSpace |
-            aiProcess_GenNormals | aiProcess_JoinIdenticalVertices));
+class ComputeSpatialSortProcess : public BaseProcess {
+    bool IsActive(unsigned int pFlags) const {
+        return nullptr != shared && 0 != (pFlags & (aiProcess_CalcTangentSpace |
+                                                           aiProcess_GenNormals | aiProcess_JoinIdenticalVertices));
     }
 
-    void Execute( aiScene* pScene)
-    {
+    void Execute(aiScene *pScene) {
         typedef std::pair<SpatialSort, ai_real> _Type;
         ASSIMP_LOG_DEBUG("Generate spatially-sorted vertex cache");
 
-        std::vector<_Type>* p = new std::vector<_Type>(pScene->mNumMeshes);
+        std::vector<_Type> *p = new std::vector<_Type>(pScene->mNumMeshes);
         std::vector<_Type>::iterator it = p->begin();
 
         for (unsigned int i = 0; i < pScene->mNumMeshes; ++i, ++it) {
-            aiMesh* mesh = pScene->mMeshes[i];
-            _Type& blubb = *it;
-            blubb.first.Fill(mesh->mVertices,mesh->mNumVertices,sizeof(aiVector3D));
+            aiMesh *mesh = pScene->mMeshes[i];
+            _Type &blubb = *it;
+            blubb.first.Fill(mesh->mVertices, mesh->mNumVertices, sizeof(aiVector3D));
             blubb.second = ComputePositionEpsilon(mesh);
         }
 
-        shared->AddProperty(AI_SPP_SPATIAL_SORT,p);
+        shared->AddProperty(AI_SPP_SPATIAL_SORT, p);
     }
 };
 
 // -------------------------------------------------------------------------------
 // ... and the same again to cleanup the whole stuff
-class DestroySpatialSortProcess : public BaseProcess
-{
-    bool IsActive( unsigned int pFlags) const
-    {
-        return NULL != shared && 0 != (pFlags & (aiProcess_CalcTangentSpace |
-            aiProcess_GenNormals | aiProcess_JoinIdenticalVertices));
+class DestroySpatialSortProcess : public BaseProcess {
+    bool IsActive(unsigned int pFlags) const {
+        return nullptr != shared && 0 != (pFlags & (aiProcess_CalcTangentSpace |
+                                                        aiProcess_GenNormals | aiProcess_JoinIdenticalVertices));
     }
 
-    void Execute( aiScene* /*pScene*/)
-    {
+    void Execute(aiScene * /*pScene*/) {
         shared->RemoveProperty(AI_SPP_SPATIAL_SORT);
     }
 };
 
+} // namespace Assimp
 
-
-} // ! namespace Assimp
 #endif // !! AI_PROCESS_HELPER_H_INCLUDED
diff --git a/Engine/lib/assimp/code/PostProcessing/RemoveRedundantMaterials.cpp b/Engine/lib/assimp/code/PostProcessing/RemoveRedundantMaterials.cpp
index 49ec8f5c4..ac2fa9790 100644
--- a/Engine/lib/assimp/code/PostProcessing/RemoveRedundantMaterials.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/RemoveRedundantMaterials.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -50,6 +50,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/ParsingUtils.h>
 #include "ProcessHelper.h"
 #include "Material/MaterialSystem.h"
+#include <assimp/Exceptional.h>
 #include <stdio.h>
 
 using namespace Assimp;
@@ -122,7 +123,7 @@ void RemoveRedundantMatsProcess::Execute( aiScene* pScene)
 
                         // Keep this material even if no mesh references it
                         abReferenced[i] = true;
-                        ASSIMP_LOG_DEBUG_F( "Found positive match in exclusion list: \'", name.data, "\'");
+                        ASSIMP_LOG_VERBOSE_DEBUG( "Found positive match in exclusion list: \'", name.data, "\'");
                     }
                 }
             }
@@ -171,6 +172,8 @@ void RemoveRedundantMatsProcess::Execute( aiScene* pScene)
         }
         // If the new material count differs from the original,
         // we need to rebuild the material list and remap mesh material indexes.
+        if(iNewNum < 1)
+          throw DeadlyImportError("No materials remaining");
         if (iNewNum != pScene->mNumMaterials) {
             ai_assert(iNewNum > 0);
             aiMaterial** ppcMaterials = new aiMaterial*[iNewNum];
@@ -197,7 +200,7 @@ void RemoveRedundantMatsProcess::Execute( aiScene* pScene)
             // update all material indices
             for (unsigned int p = 0; p < pScene->mNumMeshes;++p) {
                 aiMesh* mesh = pScene->mMeshes[p];
-                ai_assert( NULL!=mesh );
+                ai_assert(nullptr != mesh);
                 mesh->mMaterialIndex = aiMappingTable[mesh->mMaterialIndex];
             }
             // delete the old material list
@@ -215,7 +218,7 @@ void RemoveRedundantMatsProcess::Execute( aiScene* pScene)
     }
     else
     {
-        ASSIMP_LOG_INFO_F("RemoveRedundantMatsProcess finished. Removed ", redundantRemoved, " redundant and ", 
+        ASSIMP_LOG_INFO("RemoveRedundantMatsProcess finished. Removed ", redundantRemoved, " redundant and ",
             unreferencedRemoved, " unused materials.");
     }
 }
diff --git a/Engine/lib/assimp/code/PostProcessing/RemoveRedundantMaterials.h b/Engine/lib/assimp/code/PostProcessing/RemoveRedundantMaterials.h
index 1f32a0abf..e8c1478fd 100644
--- a/Engine/lib/assimp/code/PostProcessing/RemoveRedundantMaterials.h
+++ b/Engine/lib/assimp/code/PostProcessing/RemoveRedundantMaterials.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -81,7 +81,7 @@ public:
     /** @brief Set list of fixed (inmutable) materials
      *  @param fixed See #AI_CONFIG_PP_RRM_EXCLUDE_LIST
      */
-    void SetFixedMaterialsString(const std::string& fixed = "") {
+    void SetFixedMaterialsString(const std::string& fixed = std::string()) {
         mConfigFixedMaterials = fixed;
     }
 
diff --git a/Engine/lib/assimp/code/PostProcessing/RemoveVCProcess.cpp b/Engine/lib/assimp/code/PostProcessing/RemoveVCProcess.cpp
index 99fd47a3a..1107736e9 100644
--- a/Engine/lib/assimp/code/PostProcessing/RemoveVCProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/RemoveVCProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -44,43 +44,37 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *        any parts of the mesh structure from the imported data.
 */
 
-
 #include "RemoveVCProcess.h"
 #include <assimp/postprocess.h>
-#include <assimp/DefaultLogger.hpp>
 #include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
 
 using namespace Assimp;
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 RemoveVCProcess::RemoveVCProcess() :
-    configDeleteFlags()
-  , mScene()
-{}
+        configDeleteFlags(), mScene() {}
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-RemoveVCProcess::~RemoveVCProcess()
-{}
+RemoveVCProcess::~RemoveVCProcess() {}
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the processing step is present in the given flag field.
-bool RemoveVCProcess::IsActive( unsigned int pFlags) const
-{
+bool RemoveVCProcess::IsActive(unsigned int pFlags) const {
     return (pFlags & aiProcess_RemoveComponent) != 0;
 }
 
 // ------------------------------------------------------------------------------------------------
-// Small helper function to delete all elements in a T** aray using delete
+// Small helper function to delete all elements in a T** array using delete
 template <typename T>
-inline void ArrayDelete(T**& in, unsigned int& num)
-{
+inline void ArrayDelete(T **&in, unsigned int &num) {
     for (unsigned int i = 0; i < num; ++i)
         delete in[i];
 
     delete[] in;
-    in = NULL;
+    in = nullptr;
     num = 0;
 }
 
@@ -108,9 +102,9 @@ bool UpdateNodeGraph(aiNode* node,std::list<aiNode*>& childsOfParent,bool root)
         {
             childsOfParent.insert(childsOfParent.end(),mine.begin(),mine.end());
 
-            // set all children to NULL to make sure they are not deleted when we delete ourself
+            // set all children to nullptr to make sure they are not deleted when we delete ourself
             for (unsigned int i = 0; i < node->mNumChildren;++i)
-                node->mChildren[i] = NULL;
+                node->mChildren[i] = nullptr;
         }
         b = true;
         delete node;
@@ -143,86 +137,74 @@ bool UpdateNodeGraph(aiNode* node,std::list<aiNode*>& childsOfParent,bool root)
 
 // ------------------------------------------------------------------------------------------------
 // Executes the post processing step on the given imported data.
-void RemoveVCProcess::Execute( aiScene* pScene)
-{
+void RemoveVCProcess::Execute(aiScene *pScene) {
     ASSIMP_LOG_DEBUG("RemoveVCProcess begin");
     bool bHas = false; //,bMasked = false;
 
     mScene = pScene;
 
     // handle animations
-    if ( configDeleteFlags & aiComponent_ANIMATIONS)
-    {
+    if (configDeleteFlags & aiComponent_ANIMATIONS) {
 
         bHas = true;
-        ArrayDelete(pScene->mAnimations,pScene->mNumAnimations);
+        ArrayDelete(pScene->mAnimations, pScene->mNumAnimations);
     }
 
     // handle textures
-    if ( configDeleteFlags & aiComponent_TEXTURES)
-    {
+    if (configDeleteFlags & aiComponent_TEXTURES) {
         bHas = true;
-        ArrayDelete(pScene->mTextures,pScene->mNumTextures);
+        ArrayDelete(pScene->mTextures, pScene->mNumTextures);
     }
 
     // handle materials
-    if ( configDeleteFlags & aiComponent_MATERIALS && pScene->mNumMaterials)
-    {
+    if (configDeleteFlags & aiComponent_MATERIALS && pScene->mNumMaterials) {
         bHas = true;
-        for (unsigned int i = 1;i < pScene->mNumMaterials;++i)
+        for (unsigned int i = 1; i < pScene->mNumMaterials; ++i)
             delete pScene->mMaterials[i];
 
         pScene->mNumMaterials = 1;
-        aiMaterial* helper = (aiMaterial*) pScene->mMaterials[0];
-        ai_assert(NULL != helper);
+        aiMaterial *helper = (aiMaterial *)pScene->mMaterials[0];
+        ai_assert(nullptr != helper);
         helper->Clear();
 
         // gray
-        aiColor3D clr(0.6f,0.6f,0.6f);
-        helper->AddProperty(&clr,1,AI_MATKEY_COLOR_DIFFUSE);
+        aiColor3D clr(0.6f, 0.6f, 0.6f);
+        helper->AddProperty(&clr, 1, AI_MATKEY_COLOR_DIFFUSE);
 
         // add a small ambient color value
-        clr = aiColor3D(0.05f,0.05f,0.05f);
-        helper->AddProperty(&clr,1,AI_MATKEY_COLOR_AMBIENT);
+        clr = aiColor3D(0.05f, 0.05f, 0.05f);
+        helper->AddProperty(&clr, 1, AI_MATKEY_COLOR_AMBIENT);
 
         aiString s;
         s.Set("Dummy_MaterialsRemoved");
-        helper->AddProperty(&s,AI_MATKEY_NAME);
+        helper->AddProperty(&s, AI_MATKEY_NAME);
     }
 
     // handle light sources
-    if ( configDeleteFlags & aiComponent_LIGHTS)
-    {
-        bHas =  true;
-        ArrayDelete(pScene->mLights,pScene->mNumLights);
+    if (configDeleteFlags & aiComponent_LIGHTS) {
+        bHas = true;
+        ArrayDelete(pScene->mLights, pScene->mNumLights);
     }
 
     // handle camneras
-    if ( configDeleteFlags & aiComponent_CAMERAS)
-    {
+    if (configDeleteFlags & aiComponent_CAMERAS) {
         bHas = true;
-        ArrayDelete(pScene->mCameras,pScene->mNumCameras);
+        ArrayDelete(pScene->mCameras, pScene->mNumCameras);
     }
 
     // handle meshes
-    if (configDeleteFlags & aiComponent_MESHES)
-    {
+    if (configDeleteFlags & aiComponent_MESHES) {
         bHas = true;
-        ArrayDelete(pScene->mMeshes,pScene->mNumMeshes);
-    }
-    else
-    {
-        for( unsigned int a = 0; a < pScene->mNumMeshes; a++)
-        {
-            if( ProcessMesh( pScene->mMeshes[a]))
+        ArrayDelete(pScene->mMeshes, pScene->mNumMeshes);
+    } else {
+        for (unsigned int a = 0; a < pScene->mNumMeshes; a++) {
+            if (ProcessMesh(pScene->mMeshes[a]))
                 bHas = true;
         }
     }
 
-
     // now check whether the result is still a full scene
-    if (!pScene->mNumMeshes || !pScene->mNumMaterials)
-    {
+    if (!pScene->mNumMeshes || !pScene->mNumMaterials) {
         pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
         ASSIMP_LOG_DEBUG("Setting AI_SCENE_FLAGS_INCOMPLETE flag");
 
@@ -240,63 +222,55 @@ void RemoveVCProcess::Execute( aiScene* pScene)
 
 // ------------------------------------------------------------------------------------------------
 // Setup configuration properties for the step
-void RemoveVCProcess::SetupProperties(const Importer* pImp)
-{
-    configDeleteFlags = pImp->GetPropertyInteger(AI_CONFIG_PP_RVC_FLAGS,0x0);
-    if (!configDeleteFlags)
-    {
+void RemoveVCProcess::SetupProperties(const Importer *pImp) {
+    configDeleteFlags = pImp->GetPropertyInteger(AI_CONFIG_PP_RVC_FLAGS, 0x0);
+    if (!configDeleteFlags) {
         ASSIMP_LOG_WARN("RemoveVCProcess: AI_CONFIG_PP_RVC_FLAGS is zero.");
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Executes the post processing step on the given imported data.
-bool RemoveVCProcess::ProcessMesh(aiMesh* pMesh)
-{
+bool RemoveVCProcess::ProcessMesh(aiMesh *pMesh) {
     bool ret = false;
 
     // if all materials have been deleted let the material
     // index of the mesh point to the created default material
-    if ( configDeleteFlags & aiComponent_MATERIALS)
+    if (configDeleteFlags & aiComponent_MATERIALS)
         pMesh->mMaterialIndex = 0;
 
     // handle normals
-    if (configDeleteFlags & aiComponent_NORMALS && pMesh->mNormals)
-    {
+    if (configDeleteFlags & aiComponent_NORMALS && pMesh->mNormals) {
         delete[] pMesh->mNormals;
-        pMesh->mNormals = NULL;
+        pMesh->mNormals = nullptr;
         ret = true;
     }
 
     // handle tangents and bitangents
-    if (configDeleteFlags & aiComponent_TANGENTS_AND_BITANGENTS && pMesh->mTangents)
-    {
+    if (configDeleteFlags & aiComponent_TANGENTS_AND_BITANGENTS && pMesh->mTangents) {
         delete[] pMesh->mTangents;
-        pMesh->mTangents = NULL;
+        pMesh->mTangents = nullptr;
 
         delete[] pMesh->mBitangents;
-        pMesh->mBitangents = NULL;
+        pMesh->mBitangents = nullptr;
         ret = true;
     }
 
     // handle texture coordinates
     bool b = (0 != (configDeleteFlags & aiComponent_TEXCOORDS));
-    for (unsigned int i = 0, real = 0; real < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++real)
-    {
-        if (!pMesh->mTextureCoords[i])break;
-        if (configDeleteFlags & aiComponent_TEXCOORDSn(real) || b)
-        {
-            delete [] pMesh->mTextureCoords[i];
-            pMesh->mTextureCoords[i] = NULL;
+    for (unsigned int i = 0, real = 0; real < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++real) {
+        if (!pMesh->mTextureCoords[i]) break;
+        if (configDeleteFlags & aiComponent_TEXCOORDSn(real) || b) {
+            delete[] pMesh->mTextureCoords[i];
+            pMesh->mTextureCoords[i] = nullptr;
             ret = true;
 
-            if (!b)
-            {
+            if (!b) {
                 // collapse the rest of the array
-                for (unsigned int a = i+1; a < AI_MAX_NUMBER_OF_TEXTURECOORDS;++a)
-                    pMesh->mTextureCoords[a-1] = pMesh->mTextureCoords[a];
+                for (unsigned int a = i + 1; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a)
+                    pMesh->mTextureCoords[a - 1] = pMesh->mTextureCoords[a];
 
-                pMesh->mTextureCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS-1] = NULL;
+                pMesh->mTextureCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS - 1] = nullptr;
                 continue;
             }
         }
@@ -305,22 +279,19 @@ bool RemoveVCProcess::ProcessMesh(aiMesh* pMesh)
 
     // handle vertex colors
     b = (0 != (configDeleteFlags & aiComponent_COLORS));
-    for (unsigned int i = 0, real = 0; real < AI_MAX_NUMBER_OF_COLOR_SETS; ++real)
-    {
-        if (!pMesh->mColors[i])break;
-        if (configDeleteFlags & aiComponent_COLORSn(i) || b)
-        {
-            delete [] pMesh->mColors[i];
-            pMesh->mColors[i] = NULL;
+    for (unsigned int i = 0, real = 0; real < AI_MAX_NUMBER_OF_COLOR_SETS; ++real) {
+        if (!pMesh->mColors[i]) break;
+        if (configDeleteFlags & aiComponent_COLORSn(i) || b) {
+            delete[] pMesh->mColors[i];
+            pMesh->mColors[i] = nullptr;
             ret = true;
 
-            if (!b)
-            {
+            if (!b) {
                 // collapse the rest of the array
-                for (unsigned int a = i+1; a < AI_MAX_NUMBER_OF_COLOR_SETS;++a)
-                    pMesh->mColors[a-1] = pMesh->mColors[a];
+                for (unsigned int a = i + 1; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a)
+                    pMesh->mColors[a - 1] = pMesh->mColors[a];
 
-                pMesh->mColors[AI_MAX_NUMBER_OF_COLOR_SETS-1] = NULL;
+                pMesh->mColors[AI_MAX_NUMBER_OF_COLOR_SETS - 1] = nullptr;
                 continue;
             }
         }
@@ -328,9 +299,8 @@ bool RemoveVCProcess::ProcessMesh(aiMesh* pMesh)
     }
 
     // handle bones
-    if (configDeleteFlags & aiComponent_BONEWEIGHTS && pMesh->mBones)
-    {
-        ArrayDelete(pMesh->mBones,pMesh->mNumBones);
+    if (configDeleteFlags & aiComponent_BONEWEIGHTS && pMesh->mBones) {
+        ArrayDelete(pMesh->mBones, pMesh->mNumBones);
         ret = true;
     }
     return ret;
diff --git a/Engine/lib/assimp/code/PostProcessing/RemoveVCProcess.h b/Engine/lib/assimp/code/PostProcessing/RemoveVCProcess.h
index 7bb21a833..cf1086882 100644
--- a/Engine/lib/assimp/code/PostProcessing/RemoveVCProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/RemoveVCProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/ScaleProcess.cpp b/Engine/lib/assimp/code/PostProcessing/ScaleProcess.cpp
index ac770c41f..0090f8dd7 100644
--- a/Engine/lib/assimp/code/PostProcessing/ScaleProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/ScaleProcess.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -75,7 +75,7 @@ void ScaleProcess::SetupProperties( const Importer* pImp ) {
     // File scaling * Application Scaling
     float importerScale = pImp->GetPropertyFloat( AI_CONFIG_APP_SCALE_KEY, 1.0f );
 
-    // apply scale to the scale 
+    // apply scale to the scale
     // helps prevent bugs with backward compatibility for anyone using normal scaling.
     mScale *= importerScale;
 }
@@ -84,7 +84,7 @@ void ScaleProcess::Execute( aiScene* pScene ) {
     if(mScale == 1.0f)  {
         return; // nothing to scale
     }
-    
+
     ai_assert( mScale != 0 );
     ai_assert( nullptr != pScene );
     ai_assert( nullptr != pScene->mRootNode );
@@ -96,7 +96,7 @@ void ScaleProcess::Execute( aiScene* pScene ) {
     if ( nullptr == pScene->mRootNode ) {
         return;
     }
-    
+
     // Process animations and update position transform to new unit system
     for( unsigned int animationID = 0; animationID < pScene->mNumAnimations; animationID++ )
     {
@@ -105,7 +105,7 @@ void ScaleProcess::Execute( aiScene* pScene ) {
         for( unsigned int animationChannel = 0; animationChannel < animation->mNumChannels; animationChannel++)
         {
             aiNodeAnim* anim = animation->mChannels[animationChannel];
-            
+
             for( unsigned int posKey = 0; posKey < anim->mNumPositionKeys; posKey++)
             {
                 aiVectorKey& vectorKey = anim->mPositionKeys[posKey];
@@ -116,9 +116,9 @@ void ScaleProcess::Execute( aiScene* pScene ) {
 
     for( unsigned int meshID = 0; meshID < pScene->mNumMeshes; meshID++)
     {
-        aiMesh *mesh = pScene->mMeshes[meshID]; 
-        
-        // Reconstruct mesh vertexes to the new unit system
+        aiMesh *mesh = pScene->mMeshes[meshID];
+
+        // Reconstruct mesh vertices to the new unit system
         for( unsigned int vertexID = 0; vertexID < mesh->mNumVertices; vertexID++)
         {
             aiVector3D& vertex = mesh->mVertices[vertexID];
@@ -129,9 +129,9 @@ void ScaleProcess::Execute( aiScene* pScene ) {
         // bone placement / scaling
         for( unsigned int boneID = 0; boneID < mesh->mNumBones; boneID++)
         {
-            // Reconstruct matrix by transform rather than by scale 
+            // Reconstruct matrix by transform rather than by scale
             // This prevent scale values being changed which can
-            // be meaningful in some cases 
+            // be meaningful in some cases
             // like when you want the modeller to see 1:1 compatibility.
             aiBone* bone = mesh->mBones[boneID];
 
@@ -139,10 +139,10 @@ void ScaleProcess::Execute( aiScene* pScene ) {
             aiQuaternion rotation;
 
             bone->mOffsetMatrix.Decompose( scale, rotation, pos);
-            
+
             aiMatrix4x4 translation;
             aiMatrix4x4::Translation( pos * mScale, translation );
-            
+
             aiMatrix4x4 scaling;
             aiMatrix4x4::Scaling( aiVector3D(scale), scaling );
 
@@ -157,7 +157,7 @@ void ScaleProcess::Execute( aiScene* pScene ) {
         for( unsigned int animMeshID = 0; animMeshID < mesh->mNumAnimMeshes; animMeshID++)
         {
             aiAnimMesh * animMesh = mesh->mAnimMeshes[animMeshID];
-            
+
             for( unsigned int vertexID = 0; vertexID < animMesh->mNumVertices; vertexID++)
             {
                 aiVector3D& vertex = animMesh->mVertices[vertexID];
@@ -169,31 +169,31 @@ void ScaleProcess::Execute( aiScene* pScene ) {
     traverseNodes( pScene->mRootNode );
 }
 
-void ScaleProcess::traverseNodes( aiNode *node, unsigned int nested_node_id ) {    
+void ScaleProcess::traverseNodes( aiNode *node, unsigned int nested_node_id ) {
     applyScaling( node );
 
     for( size_t i = 0; i < node->mNumChildren; i++)
     {
         // recurse into the tree until we are done!
-        traverseNodes( node->mChildren[i], nested_node_id+1 ); 
+        traverseNodes( node->mChildren[i], nested_node_id+1 );
     }
 }
 
 void ScaleProcess::applyScaling( aiNode *currentNode ) {
     if ( nullptr != currentNode ) {
-        // Reconstruct matrix by transform rather than by scale 
+        // Reconstruct matrix by transform rather than by scale
         // This prevent scale values being changed which can
-        // be meaningful in some cases 
-        // like when you want the modeller to 
+        // be meaningful in some cases
+        // like when you want the modeller to
         // see 1:1 compatibility.
-        
+
         aiVector3D pos, scale;
         aiQuaternion rotation;
         currentNode->mTransformation.Decompose( scale, rotation, pos);
-        
+
         aiMatrix4x4 translation;
         aiMatrix4x4::Translation( pos * mScale, translation );
-        
+
         aiMatrix4x4 scaling;
 
         // note: we do not use mScale here, this is on purpose.
diff --git a/Engine/lib/assimp/code/PostProcessing/ScaleProcess.h b/Engine/lib/assimp/code/PostProcessing/ScaleProcess.h
index 468a21673..b6eb75de7 100644
--- a/Engine/lib/assimp/code/PostProcessing/ScaleProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/ScaleProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -55,8 +55,8 @@ namespace Assimp {
 // ---------------------------------------------------------------------------
 /** ScaleProcess: Class to rescale the whole model.
  * Now rescales animations, bones, and blend shapes properly.
- * Please note this will not write to 'scale' transform it will rewrite mesh 
- * and matrixes so that your scale values 
+ * Please note this will not write to 'scale' transform it will rewrite mesh
+ * and matrixes so that your scale values
  * from your model package are preserved, so this is completely intentional
  * bugs should be reported as soon as they are found.
 */
@@ -94,4 +94,4 @@ private:
 } // Namespace Assimp
 
 
-#endif // SCALE_PROCESS_H_
\ No newline at end of file
+#endif // SCALE_PROCESS_H_
diff --git a/Engine/lib/assimp/code/PostProcessing/SortByPTypeProcess.cpp b/Engine/lib/assimp/code/PostProcessing/SortByPTypeProcess.cpp
index be8405a17..c9268093e 100644
--- a/Engine/lib/assimp/code/PostProcessing/SortByPTypeProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/SortByPTypeProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -45,112 +45,99 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  SortByPTypeProcess post-process steps.
 */
 
-
-
 // internal headers
-#include "ProcessHelper.h"
 #include "SortByPTypeProcess.h"
+#include "ProcessHelper.h"
 #include <assimp/Exceptional.h>
 
 using namespace Assimp;
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-SortByPTypeProcess::SortByPTypeProcess()
-: mConfigRemoveMeshes( 0 ) {
+SortByPTypeProcess::SortByPTypeProcess() :
+        mConfigRemoveMeshes(0) {
     // empty
 }
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-SortByPTypeProcess::~SortByPTypeProcess()
-{
+SortByPTypeProcess::~SortByPTypeProcess() {
     // nothing to do here
 }
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the processing step is present in the given flag field.
-bool SortByPTypeProcess::IsActive( unsigned int pFlags) const
-{
-    return  (pFlags & aiProcess_SortByPType) != 0;
+bool SortByPTypeProcess::IsActive(unsigned int pFlags) const {
+    return (pFlags & aiProcess_SortByPType) != 0;
 }
 
 // ------------------------------------------------------------------------------------------------
-void SortByPTypeProcess::SetupProperties(const Importer* pImp)
-{
-    mConfigRemoveMeshes = pImp->GetPropertyInteger(AI_CONFIG_PP_SBP_REMOVE,0);
+void SortByPTypeProcess::SetupProperties(const Importer *pImp) {
+    mConfigRemoveMeshes = pImp->GetPropertyInteger(AI_CONFIG_PP_SBP_REMOVE, 0);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Update changed meshes in all nodes
-void UpdateNodes(const std::vector<unsigned int>& replaceMeshIndex, aiNode* node)
-{
-    if (node->mNumMeshes)
-    {
+void UpdateNodes(const std::vector<unsigned int> &replaceMeshIndex, aiNode *node) {
+    if (node->mNumMeshes) {
         unsigned int newSize = 0;
-        for (unsigned int m = 0; m< node->mNumMeshes; ++m)
-        {
-            unsigned int add = node->mMeshes[m]<<2;
-            for (unsigned int i = 0; i < 4;++i)
-            {
-                if (UINT_MAX != replaceMeshIndex[add+i])++newSize;
+        for (unsigned int m = 0; m < node->mNumMeshes; ++m) {
+            unsigned int add = node->mMeshes[m] << 2;
+            for (unsigned int i = 0; i < 4; ++i) {
+                if (UINT_MAX != replaceMeshIndex[add + i]) ++newSize;
             }
         }
-        if (!newSize)
-        {
+        if (!newSize) {
             delete[] node->mMeshes;
             node->mNumMeshes = 0;
-            node->mMeshes    = NULL;
-        }
-        else
-        {
+            node->mMeshes = nullptr;
+        } else {
             // Try to reuse the old array if possible
-            unsigned int* newMeshes = (newSize > node->mNumMeshes
-                ? new unsigned int[newSize] : node->mMeshes);
+            unsigned int *newMeshes = (newSize > node->mNumMeshes ? new unsigned int[newSize] : node->mMeshes);
 
-            for (unsigned int m = 0; m< node->mNumMeshes; ++m)
-            {
-                unsigned int add = node->mMeshes[m]<<2;
-                for (unsigned int i = 0; i < 4;++i)
-                {
-                    if (UINT_MAX != replaceMeshIndex[add+i])
-                        *newMeshes++ = replaceMeshIndex[add+i];
+            for (unsigned int m = 0; m < node->mNumMeshes; ++m) {
+                unsigned int add = node->mMeshes[m] << 2;
+                for (unsigned int i = 0; i < 4; ++i) {
+                    if (UINT_MAX != replaceMeshIndex[add + i])
+                        *newMeshes++ = replaceMeshIndex[add + i];
                 }
             }
             if (newSize > node->mNumMeshes)
                 delete[] node->mMeshes;
 
-            node->mMeshes = newMeshes-(node->mNumMeshes = newSize);
+            node->mMeshes = newMeshes - (node->mNumMeshes = newSize);
         }
     }
 
     // call all subnodes recursively
     for (unsigned int m = 0; m < node->mNumChildren; ++m)
-        UpdateNodes(replaceMeshIndex,node->mChildren[m]);
+        UpdateNodes(replaceMeshIndex, node->mChildren[m]);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Executes the post processing step on the given imported data.
-void SortByPTypeProcess::Execute( aiScene* pScene) {
-    if ( 0 == pScene->mNumMeshes) {
+void SortByPTypeProcess::Execute(aiScene *pScene) {
+    if (0 == pScene->mNumMeshes) {
         ASSIMP_LOG_DEBUG("SortByPTypeProcess skipped, there are no meshes");
         return;
     }
 
     ASSIMP_LOG_DEBUG("SortByPTypeProcess begin");
 
-    unsigned int aiNumMeshesPerPType[4] = {0,0,0,0};
+    unsigned int aiNumMeshesPerPType[4] = { 0, 0, 0, 0 };
 
-    std::vector<aiMesh*> outMeshes;
-    outMeshes.reserve(pScene->mNumMeshes<<1u);
+    std::vector<aiMesh *> outMeshes;
+    outMeshes.reserve(static_cast<size_t>(pScene->mNumMeshes) << 1u);
 
     bool bAnyChanges = false;
 
-    std::vector<unsigned int> replaceMeshIndex(pScene->mNumMeshes*4,UINT_MAX);
+    std::vector<unsigned int> replaceMeshIndex(pScene->mNumMeshes * 4, UINT_MAX);
     std::vector<unsigned int>::iterator meshIdx = replaceMeshIndex.begin();
     for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
-        aiMesh* const mesh = pScene->mMeshes[i];
-        ai_assert(0 != mesh->mPrimitiveTypes);
+        aiMesh *const mesh = pScene->mMeshes[i];
+        if (mesh->mPrimitiveTypes == 0) {
+            throw DeadlyImportError("Mesh with invalid primitive type: ", mesh->mName.C_Str());
+        }
 
         // if there's just one primitive type in the mesh there's nothing to do for us
         unsigned int num = 0;
@@ -173,11 +160,11 @@ void SortByPTypeProcess::Execute( aiScene* pScene) {
 
         if (1 == num) {
             if (!(mConfigRemoveMeshes & mesh->mPrimitiveTypes)) {
-                *meshIdx = static_cast<unsigned int>( outMeshes.size() );
+                *meshIdx = static_cast<unsigned int>(outMeshes.size());
                 outMeshes.push_back(mesh);
             } else {
                 delete mesh;
-                pScene->mMeshes[ i ] = nullptr;
+                pScene->mMeshes[i] = nullptr;
                 bAnyChanges = true;
             }
 
@@ -188,32 +175,29 @@ void SortByPTypeProcess::Execute( aiScene* pScene) {
 
         // reuse our current mesh arrays for the submesh
         // with the largest number of primitives
-        unsigned int aiNumPerPType[4] = {0,0,0,0};
-        aiFace* pFirstFace = mesh->mFaces;
-        aiFace* const pLastFace = pFirstFace + mesh->mNumFaces;
+        unsigned int aiNumPerPType[4] = { 0, 0, 0, 0 };
+        aiFace *pFirstFace = mesh->mFaces;
+        aiFace *const pLastFace = pFirstFace + mesh->mNumFaces;
 
         unsigned int numPolyVerts = 0;
-        for (;pFirstFace != pLastFace; ++pFirstFace) {
+        for (; pFirstFace != pLastFace; ++pFirstFace) {
             if (pFirstFace->mNumIndices <= 3)
-                ++aiNumPerPType[pFirstFace->mNumIndices-1];
-            else
-            {
+                ++aiNumPerPType[pFirstFace->mNumIndices - 1];
+            else {
                 ++aiNumPerPType[3];
-                numPolyVerts += pFirstFace-> mNumIndices;
+                numPolyVerts += pFirstFace->mNumIndices;
             }
         }
 
-        VertexWeightTable* avw = ComputeVertexBoneWeightTable(mesh);
-        for (unsigned int real = 0; real < 4; ++real,++meshIdx)
-        {
-            if ( !aiNumPerPType[real] || mConfigRemoveMeshes & (1u << real))
-            {
+        VertexWeightTable *avw = ComputeVertexBoneWeightTable(mesh);
+        for (unsigned int real = 0; real < 4; ++real, ++meshIdx) {
+            if (!aiNumPerPType[real] || mConfigRemoveMeshes & (1u << real)) {
                 continue;
             }
 
-            *meshIdx = (unsigned int) outMeshes.size();
+            *meshIdx = (unsigned int)outMeshes.size();
             outMeshes.push_back(new aiMesh());
-            aiMesh* out = outMeshes.back();
+            aiMesh *out = outMeshes.back();
 
             // the name carries the adjacency information between the meshes
             out->mName = mesh->mName;
@@ -224,13 +208,13 @@ void SortByPTypeProcess::Execute( aiScene* pScene) {
 
             // allocate output storage
             out->mNumFaces = aiNumPerPType[real];
-            aiFace* outFaces = out->mFaces = new aiFace[out->mNumFaces];
+            aiFace *outFaces = out->mFaces = new aiFace[out->mNumFaces];
 
-            out->mNumVertices = (3 == real ? numPolyVerts : out->mNumFaces * (real+1));
+            out->mNumVertices = (3 == real ? numPolyVerts : out->mNumFaces * (real + 1));
 
             aiVector3D *vert(nullptr), *nor(nullptr), *tan(nullptr), *bit(nullptr);
-            aiVector3D *uv   [AI_MAX_NUMBER_OF_TEXTURECOORDS];
-            aiColor4D  *cols [AI_MAX_NUMBER_OF_COLOR_SETS];
+            aiVector3D *uv[AI_MAX_NUMBER_OF_TEXTURECOORDS];
+            aiColor4D *cols[AI_MAX_NUMBER_OF_COLOR_SETS];
 
             if (mesh->mVertices) {
                 vert = out->mVertices = new aiVector3D[out->mNumVertices];
@@ -241,11 +225,11 @@ void SortByPTypeProcess::Execute( aiScene* pScene) {
             }
 
             if (mesh->mTangents) {
-                tan = out->mTangents   = new aiVector3D[out->mNumVertices];
+                tan = out->mTangents = new aiVector3D[out->mNumVertices];
                 bit = out->mBitangents = new aiVector3D[out->mNumVertices];
             }
 
-            for (unsigned int j = 0; j < AI_MAX_NUMBER_OF_TEXTURECOORDS;++j) {
+            for (unsigned int j = 0; j < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++j) {
                 uv[j] = nullptr;
                 if (mesh->mTextureCoords[j]) {
                     uv[j] = out->mTextureCoords[j] = new aiVector3D[out->mNumVertices];
@@ -254,73 +238,127 @@ void SortByPTypeProcess::Execute( aiScene* pScene) {
                 out->mNumUVComponents[j] = mesh->mNumUVComponents[j];
             }
 
-            for (unsigned int j = 0; j < AI_MAX_NUMBER_OF_COLOR_SETS;++j) {
+            for (unsigned int j = 0; j < AI_MAX_NUMBER_OF_COLOR_SETS; ++j) {
                 cols[j] = nullptr;
                 if (mesh->mColors[j]) {
                     cols[j] = out->mColors[j] = new aiColor4D[out->mNumVertices];
                 }
             }
 
-            typedef std::vector< aiVertexWeight > TempBoneInfo;
-            std::vector< TempBoneInfo > tempBones(mesh->mNumBones);
+            if (mesh->mNumAnimMeshes > 0 && mesh->mAnimMeshes) {
+                out->mNumAnimMeshes = mesh->mNumAnimMeshes;
+                out->mAnimMeshes = new aiAnimMesh *[out->mNumAnimMeshes];
+            }
+
+            for (unsigned int j = 0; j < mesh->mNumAnimMeshes; ++j) {
+                aiAnimMesh *animMesh = mesh->mAnimMeshes[j];
+                aiAnimMesh *outAnimMesh = out->mAnimMeshes[j] = new aiAnimMesh;
+                outAnimMesh->mNumVertices = out->mNumVertices;
+                if (animMesh->mVertices)
+                    outAnimMesh->mVertices = new aiVector3D[out->mNumVertices];
+                else
+                    outAnimMesh->mVertices = nullptr;
+                if (animMesh->mNormals)
+                    outAnimMesh->mNormals = new aiVector3D[out->mNumVertices];
+                else
+                    outAnimMesh->mNormals = nullptr;
+                if (animMesh->mTangents)
+                    outAnimMesh->mTangents = new aiVector3D[out->mNumVertices];
+                else
+                    outAnimMesh->mTangents = nullptr;
+                if (animMesh->mBitangents)
+                    outAnimMesh->mBitangents = new aiVector3D[out->mNumVertices];
+                else
+                    outAnimMesh->mBitangents = nullptr;
+                for (int jj = 0; jj < AI_MAX_NUMBER_OF_COLOR_SETS; ++jj) {
+                    if (animMesh->mColors[jj])
+                        outAnimMesh->mColors[jj] = new aiColor4D[out->mNumVertices];
+                    else
+                        outAnimMesh->mColors[jj] = nullptr;
+                }
+                for (int jj = 0; jj < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++jj) {
+                    if (animMesh->mTextureCoords[jj])
+                        outAnimMesh->mTextureCoords[jj] = new aiVector3D[out->mNumVertices];
+                    else
+                        outAnimMesh->mTextureCoords[jj] = nullptr;
+                }
+            }
+
+            typedef std::vector<aiVertexWeight> TempBoneInfo;
+            std::vector<TempBoneInfo> tempBones(mesh->mNumBones);
 
             // try to guess how much storage we'll need
-            for (unsigned int q = 0; q < mesh->mNumBones;++q)
-            {
-                tempBones[q].reserve(mesh->mBones[q]->mNumWeights / (num-1));
+            for (unsigned int q = 0; q < mesh->mNumBones; ++q) {
+                tempBones[q].reserve(mesh->mBones[q]->mNumWeights / (num - 1));
             }
 
             unsigned int outIdx = 0;
-            for (unsigned int m = 0; m < mesh->mNumFaces; ++m)
-            {
-                aiFace& in = mesh->mFaces[m];
-                if ((real == 3  && in.mNumIndices <= 3) || (real != 3 && in.mNumIndices != real+1))
-                {
+            unsigned int amIdx = 0; // AnimMesh index
+            for (unsigned int m = 0; m < mesh->mNumFaces; ++m) {
+                aiFace &in = mesh->mFaces[m];
+                if ((real == 3 && in.mNumIndices <= 3) || (real != 3 && in.mNumIndices != real + 1)) {
                     continue;
                 }
 
                 outFaces->mNumIndices = in.mNumIndices;
-                outFaces->mIndices    = in.mIndices;
+                outFaces->mIndices = in.mIndices;
 
-                for (unsigned int q = 0; q < in.mNumIndices; ++q)
-                {
+                for (unsigned int q = 0; q < in.mNumIndices; ++q) {
                     unsigned int idx = in.mIndices[q];
 
                     // process all bones of this index
-                    if (avw)
-                    {
-                        VertexWeightTable& tbl = avw[idx];
+                    if (avw) {
+                        VertexWeightTable &tbl = avw[idx];
                         for (VertexWeightTable::const_iterator it = tbl.begin(), end = tbl.end();
-                             it != end; ++it)
-                        {
-                            tempBones[ (*it).first ].push_back( aiVertexWeight(outIdx, (*it).second) );
+                                it != end; ++it) {
+                            tempBones[(*it).first].push_back(aiVertexWeight(outIdx, (*it).second));
                         }
                     }
 
-                    if (vert)
-                    {
+                    if (vert) {
                         *vert++ = mesh->mVertices[idx];
                         //mesh->mVertices[idx].x = get_qnan();
                     }
-                    if (nor )*nor++  = mesh->mNormals[idx];
-                    if (tan )
-                    {
-                        *tan++  = mesh->mTangents[idx];
-                        *bit++  = mesh->mBitangents[idx];
+                    if (nor) *nor++ = mesh->mNormals[idx];
+                    if (tan) {
+                        *tan++ = mesh->mTangents[idx];
+                        *bit++ = mesh->mBitangents[idx];
                     }
 
-                    for (unsigned int pp = 0; pp < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++pp)
-                    {
-                        if (!uv[pp])break;
+                    for (unsigned int pp = 0; pp < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++pp) {
+                        if (!uv[pp]) break;
                         *uv[pp]++ = mesh->mTextureCoords[pp][idx];
                     }
 
-                    for (unsigned int pp = 0; pp < AI_MAX_NUMBER_OF_COLOR_SETS; ++pp)
-                    {
-                        if (!cols[pp])break;
+                    for (unsigned int pp = 0; pp < AI_MAX_NUMBER_OF_COLOR_SETS; ++pp) {
+                        if (!cols[pp]) break;
                         *cols[pp]++ = mesh->mColors[pp][idx];
                     }
 
+                    unsigned int pp = 0;
+                    for (; pp < mesh->mNumAnimMeshes; ++pp) {
+                        aiAnimMesh *animMesh = mesh->mAnimMeshes[pp];
+                        aiAnimMesh *outAnimMesh = out->mAnimMeshes[pp];
+                        if (animMesh->mVertices)
+                            outAnimMesh->mVertices[amIdx] = animMesh->mVertices[idx];
+                        if (animMesh->mNormals)
+                            outAnimMesh->mNormals[amIdx] = animMesh->mNormals[idx];
+                        if (animMesh->mTangents)
+                            outAnimMesh->mTangents[amIdx] = animMesh->mTangents[idx];
+                        if (animMesh->mBitangents)
+                            outAnimMesh->mBitangents[amIdx] = animMesh->mBitangents[idx];
+                        for (int jj = 0; jj < AI_MAX_NUMBER_OF_COLOR_SETS; ++jj) {
+                            if (animMesh->mColors[jj])
+                                outAnimMesh->mColors[jj][amIdx] = animMesh->mColors[jj][idx];
+                        }
+                        for (int jj = 0; jj < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++jj) {
+                            if (animMesh->mTextureCoords[jj])
+                                outAnimMesh->mTextureCoords[jj][amIdx] = animMesh->mTextureCoords[jj][idx];
+                        }
+                    }
+                    if (pp == mesh->mNumAnimMeshes)
+                        amIdx++;
+
                     in.mIndices[q] = outIdx++;
                 }
 
@@ -330,19 +368,22 @@ void SortByPTypeProcess::Execute( aiScene* pScene) {
             ai_assert(outFaces == out->mFaces + out->mNumFaces);
 
             // now generate output bones
-            for (unsigned int q = 0; q < mesh->mNumBones;++q)
-                if (!tempBones[q].empty())++out->mNumBones;
+            for (unsigned int q = 0; q < mesh->mNumBones; ++q) {
+                if (!tempBones[q].empty()) {
+                    ++out->mNumBones;
+                }
+            }
 
-            if (out->mNumBones)
-            {
-                out->mBones = new aiBone*[out->mNumBones];
-                for (unsigned int q = 0, real = 0; q < mesh->mNumBones;++q)
-                {
-                    TempBoneInfo& in = tempBones[q];
-                    if (in.empty())continue;
+            if (out->mNumBones) {
+                out->mBones = new aiBone *[out->mNumBones];
+                for (unsigned int q = 0, boneIdx = 0; q < mesh->mNumBones; ++q) {
+                    TempBoneInfo &in = tempBones[q];
+                    if (in.empty()) {
+                        continue;
+                    }
 
-                    aiBone* srcBone = mesh->mBones[q];
-                    aiBone* bone = out->mBones[real] = new aiBone();
+                    aiBone *srcBone = mesh->mBones[q];
+                    aiBone *bone = out->mBones[boneIdx] = new aiBone();
 
                     bone->mName = srcBone->mName;
                     bone->mOffsetMatrix = srcBone->mOffsetMatrix;
@@ -350,9 +391,9 @@ void SortByPTypeProcess::Execute( aiScene* pScene) {
                     bone->mNumWeights = (unsigned int)in.size();
                     bone->mWeights = new aiVertexWeight[bone->mNumWeights];
 
-                    ::memcpy(bone->mWeights,&in[0],bone->mNumWeights*sizeof(aiVertexWeight));
+                    ::memcpy(bone->mWeights, &in[0], bone->mNumWeights * sizeof(aiVertexWeight));
 
-                    ++real;
+                    ++boneIdx;
                 }
             }
         }
@@ -364,40 +405,35 @@ void SortByPTypeProcess::Execute( aiScene* pScene) {
         delete mesh;
 
         // avoid invalid pointer
-        pScene->mMeshes[i] = NULL;
+        pScene->mMeshes[i] = nullptr;
     }
 
-    if (outMeshes.empty())
-    {
+    if (outMeshes.empty()) {
         // This should not occur
         throw DeadlyImportError("No meshes remaining");
     }
 
     // If we added at least one mesh process all nodes in the node
     // graph and update their respective mesh indices.
-    if (bAnyChanges)
-    {
-        UpdateNodes(replaceMeshIndex,pScene->mRootNode);
+    if (bAnyChanges) {
+        UpdateNodes(replaceMeshIndex, pScene->mRootNode);
     }
 
-    if (outMeshes.size() != pScene->mNumMeshes)
-    {
+    if (outMeshes.size() != pScene->mNumMeshes) {
         delete[] pScene->mMeshes;
         pScene->mNumMeshes = (unsigned int)outMeshes.size();
-        pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];
+        pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
     }
-    ::memcpy(pScene->mMeshes,&outMeshes[0],pScene->mNumMeshes*sizeof(void*));
+    ::memcpy(pScene->mMeshes, &outMeshes[0], pScene->mNumMeshes * sizeof(void *));
 
-    if (!DefaultLogger::isNullLogger())
-    {
+    if (!DefaultLogger::isNullLogger()) {
         char buffer[1024];
-        ::ai_snprintf(buffer,1024,"Points: %u%s, Lines: %u%s, Triangles: %u%s, Polygons: %u%s (Meshes, X = removed)",
-            aiNumMeshesPerPType[0], ((mConfigRemoveMeshes & aiPrimitiveType_POINT)     ? "X" : ""),
-            aiNumMeshesPerPType[1], ((mConfigRemoveMeshes & aiPrimitiveType_LINE)      ? "X" : ""),
-            aiNumMeshesPerPType[2], ((mConfigRemoveMeshes & aiPrimitiveType_TRIANGLE)  ? "X" : ""),
-            aiNumMeshesPerPType[3], ((mConfigRemoveMeshes & aiPrimitiveType_POLYGON)   ? "X" : ""));
+        ::ai_snprintf(buffer, 1024, "Points: %u%s, Lines: %u%s, Triangles: %u%s, Polygons: %u%s (Meshes, X = removed)",
+                aiNumMeshesPerPType[0], ((mConfigRemoveMeshes & aiPrimitiveType_POINT) ? "X" : ""),
+                aiNumMeshesPerPType[1], ((mConfigRemoveMeshes & aiPrimitiveType_LINE) ? "X" : ""),
+                aiNumMeshesPerPType[2], ((mConfigRemoveMeshes & aiPrimitiveType_TRIANGLE) ? "X" : ""),
+                aiNumMeshesPerPType[3], ((mConfigRemoveMeshes & aiPrimitiveType_POLYGON) ? "X" : ""));
         ASSIMP_LOG_INFO(buffer);
         ASSIMP_LOG_DEBUG("SortByPTypeProcess finished");
     }
 }
-
diff --git a/Engine/lib/assimp/code/PostProcessing/SortByPTypeProcess.h b/Engine/lib/assimp/code/PostProcessing/SortByPTypeProcess.h
index 1d7ccfc15..e30342a86 100644
--- a/Engine/lib/assimp/code/PostProcessing/SortByPTypeProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/SortByPTypeProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/Common/SplitByBoneCountProcess.cpp b/Engine/lib/assimp/code/PostProcessing/SplitByBoneCountProcess.cpp
similarity index 79%
rename from Engine/lib/assimp/code/Common/SplitByBoneCountProcess.cpp
rename to Engine/lib/assimp/code/PostProcessing/SplitByBoneCountProcess.cpp
index 2ef66a9af..ace62ae90 100644
--- a/Engine/lib/assimp/code/Common/SplitByBoneCountProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/SplitByBoneCountProcess.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -51,6 +51,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <limits>
 #include <assimp/TinyFormatter.h>
+#include <assimp/Exceptional.h>
+#include <set>
 
 using namespace Assimp;
 using namespace Assimp::Formatter;
@@ -94,11 +96,14 @@ void SplitByBoneCountProcess::Execute( aiScene* pScene)
     bool isNecessary = false;
     for( unsigned int a = 0; a < pScene->mNumMeshes; ++a)
         if( pScene->mMeshes[a]->mNumBones > mMaxBoneCount )
+        {
             isNecessary = true;
+            break;
+        }
 
     if( !isNecessary )
     {
-        ASSIMP_LOG_DEBUG( format() << "SplitByBoneCountProcess early-out: no meshes with more than " << mMaxBoneCount << " bones." );
+        ASSIMP_LOG_DEBUG("SplitByBoneCountProcess early-out: no meshes with more than ", mMaxBoneCount, " bones." );
         return;
     }
 
@@ -146,7 +151,7 @@ void SplitByBoneCountProcess::Execute( aiScene* pScene)
     // recurse through all nodes and translate the node's mesh indices to fit the new mesh array
     UpdateNode( pScene->mRootNode);
 
-    ASSIMP_LOG_DEBUG( format() << "SplitByBoneCountProcess end: split " << mSubMeshIndices.size() << " meshes into " << meshes.size() << " submeshes." );
+    ASSIMP_LOG_DEBUG( "SplitByBoneCountProcess end: split ", mSubMeshIndices.size(), " meshes into ", meshes.size(), " submeshes." );
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -155,7 +160,9 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
 {
     // skip if not necessary
     if( pMesh->mNumBones <= mMaxBoneCount )
+    {
         return;
+    }
 
     // necessary optimisation: build a list of all affecting bones for each vertex
     // TODO: (thom) maybe add a custom allocator here to avoid allocating tens of thousands of small arrays
@@ -165,7 +172,17 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
     {
         const aiBone* bone = pMesh->mBones[a];
         for( unsigned int b = 0; b < bone->mNumWeights; ++b)
-            vertexBones[ bone->mWeights[b].mVertexId ].push_back( BoneWeight( a, bone->mWeights[b].mWeight));
+        {
+          if (bone->mWeights[b].mWeight > 0.0f)
+          {
+            int vertexId = bone->mWeights[b].mVertexId;
+            vertexBones[vertexId].push_back( BoneWeight( a, bone->mWeights[b].mWeight));
+            if (vertexBones[vertexId].size() > mMaxBoneCount)
+            {
+              throw DeadlyImportError("SplitByBoneCountProcess: Single face requires more bones than specified max bone count!");
+            }
+          }
+        }
     }
 
     unsigned int numFacesHandled = 0;
@@ -180,49 +197,48 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
         subMeshFaces.reserve( pMesh->mNumFaces);
         // accumulated vertex count of all the faces in this submesh
         unsigned int numSubMeshVertices = 0;
-        // a small local array of new bones for the current face. State of all used bones for that face
-        // can only be updated AFTER the face is completely analysed. Thanks to imre for the fix.
-        std::vector<unsigned int> newBonesAtCurrentFace;
 
         // add faces to the new submesh as long as all bones affecting the faces' vertices fit in the limit
         for( unsigned int a = 0; a < pMesh->mNumFaces; ++a)
         {
             // skip if the face is already stored in a submesh
             if( isFaceHandled[a] )
+            {
                 continue;
+            }
+            // a small local set of new bones for the current face. State of all used bones for that face
+            // can only be updated AFTER the face is completely analysed. Thanks to imre for the fix.
+            std::set<unsigned int> newBonesAtCurrentFace;
 
             const aiFace& face = pMesh->mFaces[a];
             // check every vertex if its bones would still fit into the current submesh
             for( unsigned int b = 0; b < face.mNumIndices; ++b )
             {
-                const std::vector<BoneWeight>& vb = vertexBones[face.mIndices[b]];
-                for( unsigned int c = 0; c < vb.size(); ++c)
+              const std::vector<BoneWeight>& vb = vertexBones[face.mIndices[b]];
+              for( unsigned int c = 0; c < vb.size(); ++c)
+              {
+                unsigned int boneIndex = vb[c].first;
+                if( !isBoneUsed[boneIndex] )
                 {
-                    unsigned int boneIndex = vb[c].first;
-                    // if the bone is already used in this submesh, it's ok
-                    if( isBoneUsed[boneIndex] )
-                        continue;
-
-                    // if it's not used, yet, we would need to add it. Store its bone index
-                    if( std::find( newBonesAtCurrentFace.begin(), newBonesAtCurrentFace.end(), boneIndex) == newBonesAtCurrentFace.end() )
-                        newBonesAtCurrentFace.push_back( boneIndex);
+                  newBonesAtCurrentFace.insert(boneIndex);
                 }
+              }
             }
 
             // leave out the face if the new bones required for this face don't fit the bone count limit anymore
             if( numBones + newBonesAtCurrentFace.size() > mMaxBoneCount )
+            {
                 continue;
+            }
 
             // mark all new bones as necessary
-            while( !newBonesAtCurrentFace.empty() )
+            for (std::set<unsigned int>::iterator it = newBonesAtCurrentFace.begin(); it != newBonesAtCurrentFace.end(); ++it)
             {
-                unsigned int newIndex = newBonesAtCurrentFace.back();
-                newBonesAtCurrentFace.pop_back(); // this also avoids the deallocation which comes with a clear()
-                if( isBoneUsed[newIndex] )
-                    continue;
-
-                isBoneUsed[newIndex] = true;
+              if (!isBoneUsed[*it])
+              {
+                isBoneUsed[*it] = true;
                 numBones++;
+              }
             }
 
             // store the face index and the vertex count
@@ -237,7 +253,9 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
         // create a new mesh to hold this subset of the source mesh
         aiMesh* newMesh = new aiMesh;
         if( pMesh->mName.length > 0 )
+        {
             newMesh->mName.Set( format() << pMesh->mName.data << "_sub" << poNewMeshes.size());
+        }
         newMesh->mMaterialIndex = pMesh->mMaterialIndex;
         newMesh->mPrimitiveTypes = pMesh->mPrimitiveTypes;
         poNewMeshes.push_back( newMesh);
@@ -247,7 +265,9 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
         newMesh->mNumFaces = static_cast<unsigned int>(subMeshFaces.size());
         newMesh->mVertices = new aiVector3D[newMesh->mNumVertices];
         if( pMesh->HasNormals() )
+        {
             newMesh->mNormals = new aiVector3D[newMesh->mNumVertices];
+        }
         if( pMesh->HasTangentsAndBitangents() )
         {
             newMesh->mTangents = new aiVector3D[newMesh->mNumVertices];
@@ -256,13 +276,17 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
         for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a )
         {
             if( pMesh->HasTextureCoords( a) )
+            {
                 newMesh->mTextureCoords[a] = new aiVector3D[newMesh->mNumVertices];
+            }
             newMesh->mNumUVComponents[a] = pMesh->mNumUVComponents[a];
         }
         for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a )
         {
             if( pMesh->HasVertexColors( a) )
+            {
                 newMesh->mColors[a] = new aiColor4D[newMesh->mNumVertices];
+            }
         }
 
         // and copy over the data, generating faces with linear indices along the way
@@ -285,7 +309,9 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
 
                 newMesh->mVertices[nvi] = pMesh->mVertices[srcIndex];
                 if( pMesh->HasNormals() )
+                {
                     newMesh->mNormals[nvi] = pMesh->mNormals[srcIndex];
+                }
                 if( pMesh->HasTangentsAndBitangents() )
                 {
                     newMesh->mTangents[nvi] = pMesh->mTangents[srcIndex];
@@ -294,12 +320,16 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
                 for( unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++c )
                 {
                     if( pMesh->HasTextureCoords( c) )
+                    {
                         newMesh->mTextureCoords[c][nvi] = pMesh->mTextureCoords[c][srcIndex];
+                    }
                 }
                 for( unsigned int c = 0; c < AI_MAX_NUMBER_OF_COLOR_SETS; ++c )
                 {
                     if( pMesh->HasVertexColors( c) )
+                    {
                         newMesh->mColors[c][nvi] = pMesh->mColors[c][srcIndex];
+                    }
                 }
 
                 nvi++;
@@ -316,7 +346,9 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
         for( unsigned int a = 0; a < pMesh->mNumBones; ++a )
         {
             if( !isBoneUsed[a] )
+            {
                 continue;
+            }
 
             // create the new bone
             const aiBone* srcBone = pMesh->mBones[a];
@@ -340,7 +372,9 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
             {
                 unsigned int newBoneIndex = mappedBoneIndex[ bonesOnThisVertex[b].first ];
                 if( newBoneIndex != std::numeric_limits<unsigned int>::max() )
+                {
                     newMesh->mBones[newBoneIndex]->mNumWeights++;
+                }
             }
         }
 
@@ -374,6 +408,45 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
             }
         }
 
+        // ... and copy all the morph targets for all the vertices which made it into the new submesh
+        if (pMesh->mNumAnimMeshes > 0) {
+            newMesh->mNumAnimMeshes = pMesh->mNumAnimMeshes;
+            newMesh->mAnimMeshes = new aiAnimMesh*[newMesh->mNumAnimMeshes];
+
+            for (unsigned int morphIdx = 0; morphIdx < newMesh->mNumAnimMeshes; ++morphIdx) {
+                aiAnimMesh* origTarget = pMesh->mAnimMeshes[morphIdx];
+                aiAnimMesh* newTarget = new aiAnimMesh;
+                newTarget->mName = origTarget->mName;
+                newTarget->mWeight = origTarget->mWeight;
+                newTarget->mNumVertices = numSubMeshVertices;
+                newTarget->mVertices = new aiVector3D[numSubMeshVertices];
+                newMesh->mAnimMeshes[morphIdx] = newTarget;
+
+                if (origTarget->HasNormals()) {
+                    newTarget->mNormals = new aiVector3D[numSubMeshVertices];
+                }
+
+                if (origTarget->HasTangentsAndBitangents()) {
+                    newTarget->mTangents = new aiVector3D[numSubMeshVertices];
+                    newTarget->mBitangents = new aiVector3D[numSubMeshVertices];
+                }
+
+                for( unsigned int vi = 0; vi < numSubMeshVertices; ++vi) {
+                    // find the source vertex for it in the source mesh
+                    unsigned int previousIndex = previousVertexIndices[vi];
+                    newTarget->mVertices[vi] = origTarget->mVertices[previousIndex];
+
+                    if (newTarget->HasNormals()) {
+                        newTarget->mNormals[vi] = origTarget->mNormals[previousIndex];
+                    }
+                    if (newTarget->HasTangentsAndBitangents()) {
+                        newTarget->mTangents[vi] = origTarget->mTangents[previousIndex];
+                        newTarget->mBitangents[vi] = origTarget->mBitangents[previousIndex];
+                    }
+                }
+            }
+        }
+
         // I have the strange feeling that this will break apart at some point in time...
     }
 }
diff --git a/Engine/lib/assimp/code/Common/SplitByBoneCountProcess.h b/Engine/lib/assimp/code/PostProcessing/SplitByBoneCountProcess.h
similarity index 98%
rename from Engine/lib/assimp/code/Common/SplitByBoneCountProcess.h
rename to Engine/lib/assimp/code/PostProcessing/SplitByBoneCountProcess.h
index 6c904a9df..938b00c7f 100644
--- a/Engine/lib/assimp/code/Common/SplitByBoneCountProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/SplitByBoneCountProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -46,7 +46,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define AI_SPLITBYBONECOUNTPROCESS_H_INC
 
 #include <vector>
-#include "BaseProcess.h"
+#include "Common/BaseProcess.h"
 
 #include <assimp/mesh.h>
 #include <assimp/scene.h>
diff --git a/Engine/lib/assimp/code/PostProcessing/SplitLargeMeshes.cpp b/Engine/lib/assimp/code/PostProcessing/SplitLargeMeshes.cpp
index 1797b28d5..508a82669 100644
--- a/Engine/lib/assimp/code/PostProcessing/SplitLargeMeshes.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/SplitLargeMeshes.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -40,7 +40,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
-/** 
+/**
  *  @file Implementation of the SplitLargeMeshes postprocessing step
  */
 
@@ -129,7 +129,7 @@ void SplitLargeMeshesProcess_Triangle::UpdateNode(aiNode* pcNode,
         pcNode->mMeshes[b] = aiEntries[b];
     }
 
-    // recusively update all other nodes
+    // recursively update all other nodes
     for (unsigned int i = 0; i < pcNode->mNumChildren;++i) {
         UpdateNode ( pcNode->mChildren[i], avList );
     }
@@ -353,7 +353,7 @@ void SplitLargeMeshesProcess_Vertex::Execute( aiScene* pScene) {
 
     std::vector<std::pair<aiMesh*, unsigned int> > avList;
 
-    //Check for point cloud first, 
+    //Check for point cloud first,
     //Do not process point cloud, splitMesh works only with faces data
     for (unsigned int a = 0; a < pScene->mNumMeshes; a++) {
         if ( pScene->mMeshes[a]->mPrimitiveTypes == aiPrimitiveType_POINT ) {
@@ -575,8 +575,9 @@ void SplitLargeMeshesProcess_Vertex::SplitMesh(
                 for (unsigned int k = 0; k < pMesh->mNumBones;++k) {
                     // check whether the bone is existing
                     BoneWeightList* pcWeightList;
-                    if ((pcWeightList = (BoneWeightList*)pcMesh->mBones[k])) {
-                        aiBone* pcOldBone = pMesh->mBones[k];
+                    pcWeightList = (BoneWeightList *)pcMesh->mBones[k];
+                    if (nullptr != pcWeightList) {
+                        aiBone *pcOldBone = pMesh->mBones[k];
                         aiBone* pcOut( nullptr );
                         *ppCurrent++ = pcOut = new aiBone();
                         pcOut->mName = aiString(pcOldBone->mName);
diff --git a/Engine/lib/assimp/code/PostProcessing/SplitLargeMeshes.h b/Engine/lib/assimp/code/PostProcessing/SplitLargeMeshes.h
index 3f90576ea..e5a8d4c1b 100644
--- a/Engine/lib/assimp/code/PostProcessing/SplitLargeMeshes.h
+++ b/Engine/lib/assimp/code/PostProcessing/SplitLargeMeshes.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
diff --git a/Engine/lib/assimp/code/PostProcessing/TextureTransform.cpp b/Engine/lib/assimp/code/PostProcessing/TextureTransform.cpp
index 8ae2ba721..653506ec6 100644
--- a/Engine/lib/assimp/code/PostProcessing/TextureTransform.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/TextureTransform.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -92,9 +92,8 @@ void TextureTransformStep::PreProcessUVTransform(STransformVecInfo& info)
      *  are applied is - as always - scaling, rotation, translation.
      */
 
-    char szTemp[512];
-    int rounded = 0;
-
+	int rounded;
+	char szTemp[512];
 
     /* Optimize the rotation angle. That's slightly difficult as
      * we have an inprecise floating-point number (when comparing
@@ -105,10 +104,11 @@ void TextureTransformStep::PreProcessUVTransform(STransformVecInfo& info)
     if (info.mRotation)
     {
         float out = info.mRotation;
-        if ((rounded = static_cast<int>((info.mRotation / static_cast<float>(AI_MATH_TWO_PI)))))
+        rounded = static_cast<int>((info.mRotation / static_cast<float>(AI_MATH_TWO_PI)));
+        if (rounded)
         {
             out -= rounded * static_cast<float>(AI_MATH_PI);
-            ASSIMP_LOG_INFO_F("Texture coordinate rotation ", info.mRotation, " can be simplified to ", out);
+            ASSIMP_LOG_INFO("Texture coordinate rotation ", info.mRotation, " can be simplified to ", out);
         }
 
         // Next step - convert negative rotation angles to positives
@@ -125,7 +125,8 @@ void TextureTransformStep::PreProcessUVTransform(STransformVecInfo& info)
      * type (e.g. if mirroring is active there IS a difference between
      * offset 2 and 3)
      */
-    if ((rounded  = (int)info.mTranslation.x))  {
+    rounded = (int)info.mTranslation.x;
+    if (rounded) {
         float out = 0.0f;
         szTemp[0] = 0;
         if (aiTextureMapMode_Wrap == info.mapU) {
@@ -158,7 +159,8 @@ void TextureTransformStep::PreProcessUVTransform(STransformVecInfo& info)
      * type (e.g. if mirroring is active there IS a difference between
      * offset 2 and 3)
      */
-    if ((rounded  = (int)info.mTranslation.y))  {
+    rounded = (int)info.mTranslation.y;
+    if (rounded) {
         float out = 0.0f;
         szTemp[0] = 0;
         if (aiTextureMapMode_Wrap == info.mapV) {
@@ -176,7 +178,7 @@ void TextureTransformStep::PreProcessUVTransform(STransformVecInfo& info)
         }
         else if (aiTextureMapMode_Clamp == info.mapV || aiTextureMapMode_Decal == info.mapV)    {
             // Clamp - translations beyond 1,1 are senseless
-            ::ai_snprintf(szTemp,512,"[c] UV V offset %f canbe clamped to 1.0f",info.mTranslation.y);
+            ::ai_snprintf(szTemp,512,"[c] UV V offset %f can be clamped to 1.0f",info.mTranslation.y);
 
             out = 1.f;
         }
@@ -185,7 +187,6 @@ void TextureTransformStep::PreProcessUVTransform(STransformVecInfo& info)
             info.mTranslation.y = out;
         }
     }
-    return;
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -428,7 +429,7 @@ void TextureTransformStep::Execute( aiScene* pScene)
         // at the end of the list
         bool ref[AI_MAX_NUMBER_OF_TEXTURECOORDS];
         for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n)
-            ref[n] = (!mesh->mTextureCoords[n] ? true : false);
+            ref[n] = !mesh->mTextureCoords[n];
 
         for (it = trafo.begin();it != trafo.end(); ++it)
             ref[(*it).uvIndex] = true;
@@ -447,7 +448,7 @@ void TextureTransformStep::Execute( aiScene* pScene)
         if (size > AI_MAX_NUMBER_OF_TEXTURECOORDS) {
 
             if (!DefaultLogger::isNullLogger()) {
-                ASSIMP_LOG_ERROR_F(static_cast<unsigned int>(trafo.size()), " UV channels required but just ", 
+                ASSIMP_LOG_ERROR(static_cast<unsigned int>(trafo.size()), " UV channels required but just ",
                     AI_MAX_NUMBER_OF_TEXTURECOORDS, " available");
             }
             size = AI_MAX_NUMBER_OF_TEXTURECOORDS;
@@ -507,7 +508,7 @@ void TextureTransformStep::Execute( aiScene* pScene)
             aiVector3D* dest, *end;
             dest = mesh->mTextureCoords[n];
 
-            ai_assert(NULL != src);
+            ai_assert(nullptr != src);
 
             // Copy the data to the destination array
             if (dest != src)
@@ -538,7 +539,7 @@ void TextureTransformStep::Execute( aiScene* pScene)
                 m5.a3 += trl.x; m5.b3 += trl.y;
                 matrix = m2 * m4 * matrix * m3 * m5;
 
-                for (src = dest; src != end; ++src) { /* manual homogenious divide */
+                for (src = dest; src != end; ++src) { /* manual homogeneous divide */
                     src->z = 1.f;
                     *src = matrix * *src;
                     src->x /= src->z;
@@ -556,7 +557,7 @@ void TextureTransformStep::Execute( aiScene* pScene)
     if (!DefaultLogger::isNullLogger()) {
 
         if (transformedChannels)    {
-            ASSIMP_LOG_INFO_F("TransformUVCoordsProcess end: ", outChannels, " output channels (in: ", inChannels, ", modified: ", transformedChannels,")");
+            ASSIMP_LOG_INFO("TransformUVCoordsProcess end: ", outChannels, " output channels (in: ", inChannels, ", modified: ", transformedChannels,")");
         } else {
             ASSIMP_LOG_DEBUG("TransformUVCoordsProcess finished");
         }
diff --git a/Engine/lib/assimp/code/PostProcessing/TextureTransform.h b/Engine/lib/assimp/code/PostProcessing/TextureTransform.h
index 2a5d623d7..c1cccf8ef 100644
--- a/Engine/lib/assimp/code/PostProcessing/TextureTransform.h
+++ b/Engine/lib/assimp/code/PostProcessing/TextureTransform.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/TriangulateProcess.cpp b/Engine/lib/assimp/code/PostProcessing/TriangulateProcess.cpp
index 1040836bb..a18bf1c24 100644
--- a/Engine/lib/assimp/code/PostProcessing/TriangulateProcess.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/TriangulateProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -64,6 +64,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "Common/PolyTools.h"
 
 #include <memory>
+#include <cstdint>
 
 //#define AI_BUILD_TRIANGULATE_COLOR_FACE_WINDING
 //#define AI_BUILD_TRIANGULATE_DEBUG_POLYS
@@ -75,6 +76,87 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 using namespace Assimp;
 
+namespace {
+
+    /**
+     * @brief Helper struct used to simplify NGON encoding functions.
+     */
+    struct NGONEncoder {
+        NGONEncoder() : mLastNGONFirstIndex((unsigned int)-1) {}
+
+        /**
+         * @brief Encode the current triangle, and make sure it is recognized as a triangle.
+         *
+         * This method will rotate indices in tri if needed in order to avoid tri to be considered
+         * part of the previous ngon. This method is to be used whenever you want to emit a real triangle,
+         * and make sure it is seen as a triangle.
+         *
+         * @param tri Triangle to encode.
+         */
+        void ngonEncodeTriangle(aiFace * tri) {
+            ai_assert(tri->mNumIndices == 3);
+
+            // Rotate indices in new triangle to avoid ngon encoding false ngons
+            // Otherwise, the new triangle would be considered part of the previous NGON.
+            if (isConsideredSameAsLastNgon(tri)) {
+                std::swap(tri->mIndices[0], tri->mIndices[2]);
+                std::swap(tri->mIndices[1], tri->mIndices[2]);
+            }
+
+            mLastNGONFirstIndex = tri->mIndices[0];
+        }
+
+        /**
+         * @brief Encode a quad (2 triangles) in ngon encoding, and make sure they are seen as a single ngon.
+         *
+         * @param tri1 First quad triangle
+         * @param tri2 Second quad triangle
+         *
+         * @pre Triangles must be properly fanned from the most appropriate vertex.
+         */
+        void ngonEncodeQuad(aiFace *tri1, aiFace *tri2) {
+            ai_assert(tri1->mNumIndices == 3);
+            ai_assert(tri2->mNumIndices == 3);
+            ai_assert(tri1->mIndices[0] == tri2->mIndices[0]);
+
+            // If the selected fanning vertex is the same as the previously
+            // emitted ngon, we use the opposite vertex which also happens to work
+            // for tri-fanning a concave quad.
+            // ref: https://github.com/assimp/assimp/pull/3695#issuecomment-805999760
+            if (isConsideredSameAsLastNgon(tri1)) {
+                // Right-rotate indices for tri1 (index 2 becomes the new fanning vertex)
+                std::swap(tri1->mIndices[0], tri1->mIndices[2]);
+                std::swap(tri1->mIndices[1], tri1->mIndices[2]);
+
+                // Left-rotate indices for tri2 (index 2 becomes the new fanning vertex)
+                std::swap(tri2->mIndices[1], tri2->mIndices[2]);
+                std::swap(tri2->mIndices[0], tri2->mIndices[2]);
+
+                ai_assert(tri1->mIndices[0] == tri2->mIndices[0]);
+            }
+
+            mLastNGONFirstIndex = tri1->mIndices[0];
+        }
+
+        /**
+         * @brief Check whether this triangle would be considered part of the lastly emitted ngon or not.
+         *
+         * @param tri Current triangle.
+         * @return true If used as is, this triangle will be part of last ngon.
+         * @return false If used as is, this triangle is not considered part of the last ngon.
+         */
+        bool isConsideredSameAsLastNgon(const aiFace * tri) const {
+            ai_assert(tri->mNumIndices == 3);
+            return tri->mIndices[0] == mLastNGONFirstIndex;
+        }
+
+    private:
+        unsigned int mLastNGONFirstIndex;
+    };
+
+}
+
+
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 TriangulateProcess::TriangulateProcess()
@@ -141,7 +223,7 @@ bool TriangulateProcess::TriangulateMesh( aiMesh* pMesh)
     }
 
     // Find out how many output faces we'll get
-    unsigned int numOut = 0, max_out = 0;
+    uint32_t numOut = 0, max_out = 0;
     bool get_normals = true;
     for( unsigned int a = 0; a < pMesh->mNumFaces; a++) {
         aiFace& face = pMesh->mFaces[a];
@@ -161,7 +243,7 @@ bool TriangulateProcess::TriangulateMesh( aiMesh* pMesh)
     // Just another check whether aiMesh::mPrimitiveTypes is correct
     ai_assert(numOut != pMesh->mNumFaces);
 
-    aiVector3D* nor_out = NULL;
+    aiVector3D *nor_out = nullptr;
 
     // if we don't have normals yet, but expect them to be a cheap side
     // product of triangulation anyway, allocate storage for them.
@@ -174,10 +256,15 @@ bool TriangulateProcess::TriangulateMesh( aiMesh* pMesh)
     pMesh->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
     pMesh->mPrimitiveTypes &= ~aiPrimitiveType_POLYGON;
 
+    // The mesh becomes NGON encoded now, during the triangulation process.
+    pMesh->mPrimitiveTypes |= aiPrimitiveType_NGONEncodingFlag;
+
     aiFace* out = new aiFace[numOut](), *curOut = out;
     std::vector<aiVector3D> temp_verts3d(max_out+2); /* temporary storage for vertices */
     std::vector<aiVector2D> temp_verts(max_out+2);
 
+    NGONEncoder ngonEncoder;
+
     // Apply vertex colors to represent the face winding?
 #ifdef AI_BUILD_TRIANGULATE_COLOR_FACE_WINDING
     if (!pMesh->mColors[0])
@@ -219,8 +306,11 @@ bool TriangulateProcess::TriangulateMesh( aiMesh* pMesh)
             aiFace& nface = *curOut++;
             nface.mNumIndices = face.mNumIndices;
             nface.mIndices    = face.mIndices;
+            face.mIndices = nullptr;
+
+            // points and lines don't require ngon encoding (and are not supported either!)
+            if (nface.mNumIndices == 3) ngonEncoder.ngonEncodeTriangle(&nface);
 
-            face.mIndices = NULL;
             continue;
         }
         // optimized code for quadrilaterals
@@ -272,7 +362,10 @@ bool TriangulateProcess::TriangulateMesh( aiMesh* pMesh)
             sface.mIndices[2] = temp[(start_vertex + 3) % 4];
 
             // prevent double deletion of the indices field
-            face.mIndices = NULL;
+            face.mIndices = nullptr;
+
+            ngonEncoder.ngonEncodeQuad(&nface, &sface);
+
             continue;
         }
         else
@@ -283,11 +376,11 @@ bool TriangulateProcess::TriangulateMesh( aiMesh* pMesh)
             // modeling suite to make extensive use of highly concave, monster polygons ...
             // so we need to apply the full 'ear cutting' algorithm to get it right.
 
-            // RERQUIREMENT: polygon is expected to be simple and *nearly* planar.
+            // REQUIREMENT: polygon is expected to be simple and *nearly* planar.
             // We project it onto a plane to get a 2d triangle.
 
             // Collect all vertices of of the polygon.
-           for (tmp = 0; tmp < max; ++tmp) {
+            for (tmp = 0; tmp < max; ++tmp) {
                 temp_verts3d[tmp] = verts[idx[tmp]];
             }
 
@@ -419,7 +512,7 @@ bool TriangulateProcess::TriangulateMesh( aiMesh* pMesh)
                     num = 0;
                     break;
 
-                    curOut -= (max-num); /* undo all previous work */
+                    /*curOut -= (max-num); // undo all previous work
                     for (tmp = 0; tmp < max-2; ++tmp) {
                         aiFace& nface = *curOut++;
 
@@ -433,7 +526,7 @@ bool TriangulateProcess::TriangulateMesh( aiMesh* pMesh)
 
                     }
                     num = 0;
-                    break;
+                    break;*/
                 }
 
                 aiFace& nface = *curOut++;
@@ -490,7 +583,7 @@ bool TriangulateProcess::TriangulateMesh( aiMesh* pMesh)
             //  drop dumb 0-area triangles - deactivated for now:
             //FindDegenerates post processing step can do the same thing
             //if (std::fabs(GetArea2D(temp_verts[i[0]],temp_verts[i[1]],temp_verts[i[2]])) < 1e-5f) {
-            //    ASSIMP_LOG_DEBUG("Dropping triangle with area 0");
+            //    ASSIMP_LOG_VERBOSE_DEBUG("Dropping triangle with area 0");
             //    --curOut;
 
             //    delete[] f->mIndices;
@@ -507,11 +600,16 @@ bool TriangulateProcess::TriangulateMesh( aiMesh* pMesh)
             i[0] = idx[i[0]];
             i[1] = idx[i[1]];
             i[2] = idx[i[2]];
+
+            // IMPROVEMENT: Polygons are not supported yet by this ngon encoding + triangulation step.
+            //              So we encode polygons as regular triangles. No way to reconstruct the original
+            //              polygon in this case.
+            ngonEncoder.ngonEncodeTriangle(f);
             ++f;
         }
 
         delete[] face.mIndices;
-        face.mIndices = NULL;
+        face.mIndices = nullptr;
     }
 
 #ifdef AI_BUILD_TRIANGULATE_DEBUG_POLYS
diff --git a/Engine/lib/assimp/code/PostProcessing/TriangulateProcess.h b/Engine/lib/assimp/code/PostProcessing/TriangulateProcess.h
index 916b5103d..ed5f4a587 100644
--- a/Engine/lib/assimp/code/PostProcessing/TriangulateProcess.h
+++ b/Engine/lib/assimp/code/PostProcessing/TriangulateProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
diff --git a/Engine/lib/assimp/code/PostProcessing/ValidateDataStructure.cpp b/Engine/lib/assimp/code/PostProcessing/ValidateDataStructure.cpp
index 501f7a9b2..e99f6a6e3 100644
--- a/Engine/lib/assimp/code/PostProcessing/ValidateDataStructure.cpp
+++ b/Engine/lib/assimp/code/PostProcessing/ValidateDataStructure.cpp
@@ -1,9 +1,9 @@
-/*
+/*
 ---------------------------------------------------------------------------
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -48,9 +48,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // internal headers
 #include "ValidateDataStructure.h"
+#include "ProcessHelper.h"
 #include <assimp/BaseImporter.h>
 #include <assimp/fast_atof.h>
-#include "ProcessHelper.h"
 #include <memory>
 
 // CRT headers
@@ -61,80 +61,69 @@ using namespace Assimp;
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 ValidateDSProcess::ValidateDSProcess() :
-    mScene()
-{}
+        mScene() {}
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-ValidateDSProcess::~ValidateDSProcess()
-{}
+ValidateDSProcess::~ValidateDSProcess() {}
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the processing step is present in the given flag field.
-bool ValidateDSProcess::IsActive( unsigned int pFlags) const
-{
+bool ValidateDSProcess::IsActive(unsigned int pFlags) const {
     return (pFlags & aiProcess_ValidateDataStructure) != 0;
 }
 // ------------------------------------------------------------------------------------------------
-AI_WONT_RETURN void ValidateDSProcess::ReportError(const char* msg,...)
-{
-    ai_assert(NULL != msg);
+AI_WONT_RETURN void ValidateDSProcess::ReportError(const char *msg, ...) {
+    ai_assert(nullptr != msg);
 
     va_list args;
-    va_start(args,msg);
+    va_start(args, msg);
 
     char szBuffer[3000];
-    const int iLen = vsprintf(szBuffer,msg,args);
+    const int iLen = vsprintf(szBuffer, msg, args);
     ai_assert(iLen > 0);
 
     va_end(args);
 
-    throw DeadlyImportError("Validation failed: " + std::string(szBuffer,iLen));
+    throw DeadlyImportError("Validation failed: ", std::string(szBuffer, iLen));
 }
 // ------------------------------------------------------------------------------------------------
-void ValidateDSProcess::ReportWarning(const char* msg,...)
-{
-    ai_assert(NULL != msg);
+void ValidateDSProcess::ReportWarning(const char *msg, ...) {
+    ai_assert(nullptr != msg);
 
     va_list args;
-    va_start(args,msg);
+    va_start(args, msg);
 
     char szBuffer[3000];
-    const int iLen = vsprintf(szBuffer,msg,args);
+    const int iLen = vsprintf(szBuffer, msg, args);
     ai_assert(iLen > 0);
 
     va_end(args);
-    ASSIMP_LOG_WARN("Validation warning: " + std::string(szBuffer,iLen));
+    ASSIMP_LOG_WARN("Validation warning: ", std::string(szBuffer, iLen));
 }
 
 // ------------------------------------------------------------------------------------------------
-inline
-int HasNameMatch(const aiString& in, aiNode* node) {
-    int result = (node->mName == in ? 1 : 0 );
-    for (unsigned int i = 0; i < node->mNumChildren;++i)    {
-        result += HasNameMatch(in,node->mChildren[i]);
+inline int HasNameMatch(const aiString &in, aiNode *node) {
+    int result = (node->mName == in ? 1 : 0);
+    for (unsigned int i = 0; i < node->mNumChildren; ++i) {
+        result += HasNameMatch(in, node->mChildren[i]);
     }
     return result;
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename T>
-inline
-void ValidateDSProcess::DoValidation(T** parray, unsigned int size, const char* firstName, const char* secondName) {
+inline void ValidateDSProcess::DoValidation(T **parray, unsigned int size, const char *firstName, const char *secondName) {
     // validate all entries
-    if (size)
-    {
-        if (!parray)
-        {
-            ReportError("aiScene::%s is NULL (aiScene::%s is %i)",
-                firstName, secondName, size);
+    if (size) {
+        if (!parray) {
+            ReportError("aiScene::%s is nullptr (aiScene::%s is %i)",
+                    firstName, secondName, size);
         }
-        for (unsigned int i = 0; i < size;++i)
-        {
-            if (!parray[i])
-            {
-                ReportError("aiScene::%s[%i] is NULL (aiScene::%s is %i)",
-                    firstName,i,secondName,size);
+        for (unsigned int i = 0; i < size; ++i) {
+            if (!parray[i]) {
+                ReportError("aiScene::%s[%i] is nullptr (aiScene::%s is %i)",
+                        firstName, i, secondName, size);
             }
             Validate(parray[i]);
         }
@@ -143,32 +132,27 @@ void ValidateDSProcess::DoValidation(T** parray, unsigned int size, const char*
 
 // ------------------------------------------------------------------------------------------------
 template <typename T>
-inline void ValidateDSProcess::DoValidationEx(T** parray, unsigned int size,
-    const char* firstName, const char* secondName)
-{
+inline void ValidateDSProcess::DoValidationEx(T **parray, unsigned int size,
+        const char *firstName, const char *secondName) {
     // validate all entries
-    if (size)
-    {
-        if (!parray)    {
-            ReportError("aiScene::%s is NULL (aiScene::%s is %i)",
-                firstName, secondName, size);
+    if (size) {
+        if (!parray) {
+            ReportError("aiScene::%s is nullptr (aiScene::%s is %i)",
+                    firstName, secondName, size);
         }
-        for (unsigned int i = 0; i < size;++i)
-        {
-            if (!parray[i])
-            {
-                ReportError("aiScene::%s[%u] is NULL (aiScene::%s is %u)",
-                    firstName,i,secondName,size);
+        for (unsigned int i = 0; i < size; ++i) {
+            if (!parray[i]) {
+                ReportError("aiScene::%s[%u] is nullptr (aiScene::%s is %u)",
+                        firstName, i, secondName, size);
             }
             Validate(parray[i]);
 
             // check whether there are duplicate names
-            for (unsigned int a = i+1; a < size;++a)
-            {
-                if (parray[i]->mName == parray[a]->mName)
-                {
-                	ReportError("aiScene::%s[%u] has the same name as "
-                        "aiScene::%s[%u]",firstName, i,secondName, a);
+            for (unsigned int a = i + 1; a < size; ++a) {
+                if (parray[i]->mName == parray[a]->mName) {
+                    ReportError("aiScene::%s[%u] has the same name as "
+                                "aiScene::%s[%u]",
+                            firstName, i, secondName, a);
                 }
             }
         }
@@ -177,29 +161,28 @@ inline void ValidateDSProcess::DoValidationEx(T** parray, unsigned int size,
 
 // ------------------------------------------------------------------------------------------------
 template <typename T>
-inline
-void ValidateDSProcess::DoValidationWithNameCheck(T** array, unsigned int size, const char* firstName,
-        const char* secondName) {
+inline void ValidateDSProcess::DoValidationWithNameCheck(T **array, unsigned int size, const char *firstName,
+        const char *secondName) {
     // validate all entries
-    DoValidationEx(array,size,firstName,secondName);
+    DoValidationEx(array, size, firstName, secondName);
 
-    for (unsigned int i = 0; i < size;++i) {
-        int res = HasNameMatch(array[i]->mName,mScene->mRootNode);
-        if (0 == res)   {
-            const std::string name = static_cast<char*>(array[i]->mName.data);
+    for (unsigned int i = 0; i < size; ++i) {
+        int res = HasNameMatch(array[i]->mName, mScene->mRootNode);
+        if (0 == res) {
+            const std::string name = static_cast<char *>(array[i]->mName.data);
             ReportError("aiScene::%s[%i] has no corresponding node in the scene graph (%s)",
-                firstName,i, name.c_str());
-        } else if (1 != res)  {
-            const std::string name = static_cast<char*>(array[i]->mName.data);
+                    firstName, i, name.c_str());
+        } else if (1 != res) {
+            const std::string name = static_cast<char *>(array[i]->mName.data);
             ReportError("aiScene::%s[%i]: there are more than one nodes with %s as name",
-                firstName,i, name.c_str());
+                    firstName, i, name.c_str());
         }
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Executes the post processing step on the given imported data.
-void ValidateDSProcess::Execute( aiScene* pScene) {
+void ValidateDSProcess::Execute(aiScene *pScene) {
     mScene = pScene;
     ASSIMP_LOG_DEBUG("ValidateDataStructureProcess begin");
 
@@ -208,54 +191,48 @@ void ValidateDSProcess::Execute( aiScene* pScene) {
 
     // validate all meshes
     if (pScene->mNumMeshes) {
-        DoValidation(pScene->mMeshes,pScene->mNumMeshes,"mMeshes","mNumMeshes");
-    }
-    else if (!(mScene->mFlags & AI_SCENE_FLAGS_INCOMPLETE)) {
+        DoValidation(pScene->mMeshes, pScene->mNumMeshes, "mMeshes", "mNumMeshes");
+    } else if (!(mScene->mFlags & AI_SCENE_FLAGS_INCOMPLETE)) {
         ReportError("aiScene::mNumMeshes is 0. At least one mesh must be there");
-    }
-    else if (pScene->mMeshes)   {
+    } else if (pScene->mMeshes) {
         ReportError("aiScene::mMeshes is non-null although there are no meshes");
     }
 
     // validate all animations
     if (pScene->mNumAnimations) {
-        DoValidation(pScene->mAnimations,pScene->mNumAnimations,
-            "mAnimations","mNumAnimations");
-    }
-    else if (pScene->mAnimations)   {
+        DoValidation(pScene->mAnimations, pScene->mNumAnimations,
+                "mAnimations", "mNumAnimations");
+    } else if (pScene->mAnimations) {
         ReportError("aiScene::mAnimations is non-null although there are no animations");
     }
 
     // validate all cameras
     if (pScene->mNumCameras) {
-        DoValidationWithNameCheck(pScene->mCameras,pScene->mNumCameras,
-            "mCameras","mNumCameras");
-    }
-    else if (pScene->mCameras)  {
+        DoValidationWithNameCheck(pScene->mCameras, pScene->mNumCameras,
+                "mCameras", "mNumCameras");
+    } else if (pScene->mCameras) {
         ReportError("aiScene::mCameras is non-null although there are no cameras");
     }
 
     // validate all lights
     if (pScene->mNumLights) {
-        DoValidationWithNameCheck(pScene->mLights,pScene->mNumLights,
-            "mLights","mNumLights");
-    }
-    else if (pScene->mLights)   {
+        DoValidationWithNameCheck(pScene->mLights, pScene->mNumLights,
+                "mLights", "mNumLights");
+    } else if (pScene->mLights) {
         ReportError("aiScene::mLights is non-null although there are no lights");
     }
 
     // validate all textures
     if (pScene->mNumTextures) {
-        DoValidation(pScene->mTextures,pScene->mNumTextures,
-            "mTextures","mNumTextures");
-    }
-    else if (pScene->mTextures) {
+        DoValidation(pScene->mTextures, pScene->mNumTextures,
+                "mTextures", "mNumTextures");
+    } else if (pScene->mTextures) {
         ReportError("aiScene::mTextures is non-null although there are no textures");
     }
 
     // validate all materials
     if (pScene->mNumMaterials) {
-        DoValidation(pScene->mMaterials,pScene->mNumMaterials,"mMaterials","mNumMaterials");
+        DoValidation(pScene->mMaterials, pScene->mNumMaterials, "mMaterials", "mNumMaterials");
     }
 #if 0
     // NOTE: ScenePreprocessor generates a default material if none is there
@@ -263,104 +240,95 @@ void ValidateDSProcess::Execute( aiScene* pScene) {
         ReportError("aiScene::mNumMaterials is 0. At least one material must be there");
     }
 #endif
-    else if (pScene->mMaterials)    {
+    else if (pScene->mMaterials) {
         ReportError("aiScene::mMaterials is non-null although there are no materials");
     }
 
-//  if (!has)ReportError("The aiScene data structure is empty");
+    //  if (!has)ReportError("The aiScene data structure is empty");
     ASSIMP_LOG_DEBUG("ValidateDataStructureProcess end");
 }
 
 // ------------------------------------------------------------------------------------------------
-void ValidateDSProcess::Validate( const aiLight* pLight)
-{
+void ValidateDSProcess::Validate(const aiLight *pLight) {
     if (pLight->mType == aiLightSource_UNDEFINED)
         ReportWarning("aiLight::mType is aiLightSource_UNDEFINED");
 
     if (!pLight->mAttenuationConstant &&
-        !pLight->mAttenuationLinear   &&
-        !pLight->mAttenuationQuadratic) {
+            !pLight->mAttenuationLinear &&
+            !pLight->mAttenuationQuadratic) {
         ReportWarning("aiLight::mAttenuationXXX - all are zero");
     }
 
     if (pLight->mAngleInnerCone > pLight->mAngleOuterCone)
         ReportError("aiLight::mAngleInnerCone is larger than aiLight::mAngleOuterCone");
 
-    if (pLight->mColorDiffuse.IsBlack() && pLight->mColorAmbient.IsBlack()
-        && pLight->mColorSpecular.IsBlack())
-    {
+    if (pLight->mColorDiffuse.IsBlack() && pLight->mColorAmbient.IsBlack() && pLight->mColorSpecular.IsBlack()) {
         ReportWarning("aiLight::mColorXXX - all are black and won't have any influence");
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void ValidateDSProcess::Validate( const aiCamera* pCamera)
-{
+void ValidateDSProcess::Validate(const aiCamera *pCamera) {
     if (pCamera->mClipPlaneFar <= pCamera->mClipPlaneNear)
         ReportError("aiCamera::mClipPlaneFar must be >= aiCamera::mClipPlaneNear");
 
     // FIX: there are many 3ds files with invalid FOVs. No reason to
     // reject them at all ... a warning is appropriate.
     if (!pCamera->mHorizontalFOV || pCamera->mHorizontalFOV >= (float)AI_MATH_PI)
-        ReportWarning("%f is not a valid value for aiCamera::mHorizontalFOV",pCamera->mHorizontalFOV);
+        ReportWarning("%f is not a valid value for aiCamera::mHorizontalFOV", pCamera->mHorizontalFOV);
 }
 
 // ------------------------------------------------------------------------------------------------
-void ValidateDSProcess::Validate( const aiMesh* pMesh)
-{
+void ValidateDSProcess::Validate(const aiMesh *pMesh) {
     // validate the material index of the mesh
-    if (mScene->mNumMaterials && pMesh->mMaterialIndex >= mScene->mNumMaterials)
-    {
+    if (mScene->mNumMaterials && pMesh->mMaterialIndex >= mScene->mNumMaterials) {
         ReportError("aiMesh::mMaterialIndex is invalid (value: %i maximum: %i)",
-            pMesh->mMaterialIndex,mScene->mNumMaterials-1);
+                pMesh->mMaterialIndex, mScene->mNumMaterials - 1);
     }
 
     Validate(&pMesh->mName);
 
-    for (unsigned int i = 0; i < pMesh->mNumFaces; ++i)
-    {
-        aiFace& face = pMesh->mFaces[i];
+    for (unsigned int i = 0; i < pMesh->mNumFaces; ++i) {
+        aiFace &face = pMesh->mFaces[i];
 
-        if (pMesh->mPrimitiveTypes)
-        {
-            switch (face.mNumIndices)
-            {
+        if (pMesh->mPrimitiveTypes) {
+            switch (face.mNumIndices) {
             case 0:
-                ReportError("aiMesh::mFaces[%i].mNumIndices is 0",i);
+                ReportError("aiMesh::mFaces[%i].mNumIndices is 0", i);
                 break;
             case 1:
-                if (0 == (pMesh->mPrimitiveTypes & aiPrimitiveType_POINT))
-                {
+                if (0 == (pMesh->mPrimitiveTypes & aiPrimitiveType_POINT)) {
                     ReportError("aiMesh::mFaces[%i] is a POINT but aiMesh::mPrimitiveTypes "
-                        "does not report the POINT flag",i);
+                                "does not report the POINT flag",
+                            i);
                 }
                 break;
             case 2:
-                if (0 == (pMesh->mPrimitiveTypes & aiPrimitiveType_LINE))
-                {
+                if (0 == (pMesh->mPrimitiveTypes & aiPrimitiveType_LINE)) {
                     ReportError("aiMesh::mFaces[%i] is a LINE but aiMesh::mPrimitiveTypes "
-                        "does not report the LINE flag",i);
+                                "does not report the LINE flag",
+                            i);
                 }
                 break;
             case 3:
-                if (0 == (pMesh->mPrimitiveTypes & aiPrimitiveType_TRIANGLE))
-                {
+                if (0 == (pMesh->mPrimitiveTypes & aiPrimitiveType_TRIANGLE)) {
                     ReportError("aiMesh::mFaces[%i] is a TRIANGLE but aiMesh::mPrimitiveTypes "
-                        "does not report the TRIANGLE flag",i);
+                                "does not report the TRIANGLE flag",
+                            i);
                 }
                 break;
             default:
-                if (0 == (pMesh->mPrimitiveTypes & aiPrimitiveType_POLYGON))
-                {
+                if (0 == (pMesh->mPrimitiveTypes & aiPrimitiveType_POLYGON)) {
                     this->ReportError("aiMesh::mFaces[%i] is a POLYGON but aiMesh::mPrimitiveTypes "
-                        "does not report the POLYGON flag",i);
+                                      "does not report the POLYGON flag",
+                            i);
                 }
                 break;
             };
         }
 
         if (!face.mIndices)
-            ReportError("aiMesh::mFaces[%i].mIndices is NULL",i);
+            ReportError("aiMesh::mFaces[%i].mIndices is nullptr", i);
     }
 
     // positions must always be there ...
@@ -369,42 +337,40 @@ void ValidateDSProcess::Validate( const aiMesh* pMesh)
     }
 
     if (pMesh->mNumVertices > AI_MAX_VERTICES) {
-        ReportError("Mesh has too many vertices: %u, but the limit is %u",pMesh->mNumVertices,AI_MAX_VERTICES);
+        ReportError("Mesh has too many vertices: %u, but the limit is %u", pMesh->mNumVertices, AI_MAX_VERTICES);
     }
     if (pMesh->mNumFaces > AI_MAX_FACES) {
-        ReportError("Mesh has too many faces: %u, but the limit is %u",pMesh->mNumFaces,AI_MAX_FACES);
+        ReportError("Mesh has too many faces: %u, but the limit is %u", pMesh->mNumFaces, AI_MAX_FACES);
     }
 
     // if tangents are there there must also be bitangent vectors ...
-    if ((pMesh->mTangents != NULL) != (pMesh->mBitangents != NULL)) {
+    if ((pMesh->mTangents != nullptr) != (pMesh->mBitangents != nullptr)) {
         ReportError("If there are tangents, bitangent vectors must be present as well");
     }
 
     // faces, too
-    if (!pMesh->mNumFaces || (!pMesh->mFaces && !mScene->mFlags))   {
+    if (!pMesh->mNumFaces || (!pMesh->mFaces && !mScene->mFlags)) {
         ReportError("Mesh %s contains no faces", pMesh->mName.C_Str());
     }
 
     // now check whether the face indexing layout is correct:
     // unique vertices, pseudo-indexed.
     std::vector<bool> abRefList;
-    abRefList.resize(pMesh->mNumVertices,false);
-    for (unsigned int i = 0; i < pMesh->mNumFaces;++i)
-    {
-        aiFace& face = pMesh->mFaces[i];
+    abRefList.resize(pMesh->mNumVertices, false);
+    for (unsigned int i = 0; i < pMesh->mNumFaces; ++i) {
+        aiFace &face = pMesh->mFaces[i];
         if (face.mNumIndices > AI_MAX_FACE_INDICES) {
-            ReportError("Face %u has too many faces: %u, but the limit is %u",i,face.mNumIndices,AI_MAX_FACE_INDICES);
+            ReportError("Face %u has too many faces: %u, but the limit is %u", i, face.mNumIndices, AI_MAX_FACE_INDICES);
         }
 
-        for (unsigned int a = 0; a < face.mNumIndices;++a)
-        {
-            if (face.mIndices[a] >= pMesh->mNumVertices)    {
-                ReportError("aiMesh::mFaces[%i]::mIndices[%i] is out of range",i,a);
+        for (unsigned int a = 0; a < face.mNumIndices; ++a) {
+            if (face.mIndices[a] >= pMesh->mNumVertices) {
+                ReportError("aiMesh::mFaces[%i]::mIndices[%i] is out of range", i, a);
             }
             // the MSB flag is temporarily used by the extra verbose
             // mode to tell us that the JoinVerticesProcess might have
             // been executed already.
-			/*if ( !(this->mScene->mFlags & AI_SCENE_FLAGS_NON_VERBOSE_FORMAT ) && !(this->mScene->mFlags & AI_SCENE_FLAGS_ALLOW_SHARED) &&
+            /*if ( !(this->mScene->mFlags & AI_SCENE_FLAGS_NON_VERBOSE_FORMAT ) && !(this->mScene->mFlags & AI_SCENE_FLAGS_ALLOW_SHARED) &&
 				abRefList[face.mIndices[a]])
             {
                 ReportError("aiMesh::mVertices[%i] is referenced twice - second "
@@ -416,155 +382,146 @@ void ValidateDSProcess::Validate( const aiMesh* pMesh)
 
     // check whether there are vertices that aren't referenced by a face
     bool b = false;
-    for (unsigned int i = 0; i < pMesh->mNumVertices;++i)   {
-        if (!abRefList[i])b = true;
+    for (unsigned int i = 0; i < pMesh->mNumVertices; ++i) {
+        if (!abRefList[i]) b = true;
     }
     abRefList.clear();
     if (b) {
-    	ReportWarning("There are unreferenced vertices");
+        ReportWarning("There are unreferenced vertices");
     }
 
     // texture channel 2 may not be set if channel 1 is zero ...
     {
         unsigned int i = 0;
-        for (;i < AI_MAX_NUMBER_OF_TEXTURECOORDS;++i)
-        {
-            if (!pMesh->HasTextureCoords(i))break;
+        for (; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
+            if (!pMesh->HasTextureCoords(i)) break;
         }
-        for (;i < AI_MAX_NUMBER_OF_TEXTURECOORDS;++i)
-            if (pMesh->HasTextureCoords(i))
-            {
+        for (; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i)
+            if (pMesh->HasTextureCoords(i)) {
                 ReportError("Texture coordinate channel %i exists "
-                    "although the previous channel was NULL.",i);
+                            "although the previous channel was nullptr.",
+                        i);
             }
     }
     // the same for the vertex colors
     {
         unsigned int i = 0;
-        for (;i < AI_MAX_NUMBER_OF_COLOR_SETS;++i)
-        {
-            if (!pMesh->HasVertexColors(i))break;
+        for (; i < AI_MAX_NUMBER_OF_COLOR_SETS; ++i) {
+            if (!pMesh->HasVertexColors(i)) break;
         }
-        for (;i < AI_MAX_NUMBER_OF_COLOR_SETS;++i)
-            if (pMesh->HasVertexColors(i))
-            {
+        for (; i < AI_MAX_NUMBER_OF_COLOR_SETS; ++i)
+            if (pMesh->HasVertexColors(i)) {
                 ReportError("Vertex color channel %i is exists "
-                    "although the previous channel was NULL.",i);
+                            "although the previous channel was nullptr.",
+                        i);
             }
     }
 
-
     // now validate all bones
-    if (pMesh->mNumBones)
-    {
-        if (!pMesh->mBones)
-        {
-            ReportError("aiMesh::mBones is NULL (aiMesh::mNumBones is %i)",
-                pMesh->mNumBones);
+    if (pMesh->mNumBones) {
+        if (!pMesh->mBones) {
+            ReportError("aiMesh::mBones is nullptr (aiMesh::mNumBones is %i)",
+                    pMesh->mNumBones);
         }
         std::unique_ptr<float[]> afSum(nullptr);
-        if (pMesh->mNumVertices)
-        {
+        if (pMesh->mNumVertices) {
             afSum.reset(new float[pMesh->mNumVertices]);
-            for (unsigned int i = 0; i < pMesh->mNumVertices;++i)
+            for (unsigned int i = 0; i < pMesh->mNumVertices; ++i)
                 afSum[i] = 0.0f;
         }
 
         // check whether there are duplicate bone names
-        for (unsigned int i = 0; i < pMesh->mNumBones;++i)
-        {
-            const aiBone* bone = pMesh->mBones[i];
+        for (unsigned int i = 0; i < pMesh->mNumBones; ++i) {
+            const aiBone *bone = pMesh->mBones[i];
             if (bone->mNumWeights > AI_MAX_BONE_WEIGHTS) {
-                ReportError("Bone %u has too many weights: %u, but the limit is %u",i,bone->mNumWeights,AI_MAX_BONE_WEIGHTS);
+                ReportError("Bone %u has too many weights: %u, but the limit is %u", i, bone->mNumWeights, AI_MAX_BONE_WEIGHTS);
             }
 
-            if (!pMesh->mBones[i])
-            {
-                ReportError("aiMesh::mBones[%i] is NULL (aiMesh::mNumBones is %i)",
-                    i,pMesh->mNumBones);
+            if (!pMesh->mBones[i]) {
+                ReportError("aiMesh::mBones[%i] is nullptr (aiMesh::mNumBones is %i)",
+                        i, pMesh->mNumBones);
             }
-            Validate(pMesh,pMesh->mBones[i],afSum.get());
+            Validate(pMesh, pMesh->mBones[i], afSum.get());
 
-            for (unsigned int a = i+1; a < pMesh->mNumBones;++a)
-            {
-                if (pMesh->mBones[i]->mName == pMesh->mBones[a]->mName)
-                {
+            for (unsigned int a = i + 1; a < pMesh->mNumBones; ++a) {
+                if (pMesh->mBones[i]->mName == pMesh->mBones[a]->mName) {
                     const char *name = "unknown";
-                    if (nullptr != pMesh->mBones[ i ]->mName.C_Str()) {
-                        name = pMesh->mBones[ i ]->mName.C_Str();
+                    if (nullptr != pMesh->mBones[i]->mName.C_Str()) {
+                        name = pMesh->mBones[i]->mName.C_Str();
                     }
                     ReportError("aiMesh::mBones[%i], name = \"%s\" has the same name as "
-                        "aiMesh::mBones[%i]", i, name, a );
+                                "aiMesh::mBones[%i]",
+                            i, name, a);
                 }
             }
         }
         // check whether all bone weights for a vertex sum to 1.0 ...
-        for (unsigned int i = 0; i < pMesh->mNumVertices;++i)
-        {
+        for (unsigned int i = 0; i < pMesh->mNumVertices; ++i) {
             if (afSum[i] && (afSum[i] <= 0.94 || afSum[i] >= 1.05)) {
-                ReportWarning("aiMesh::mVertices[%i]: bone weight sum != 1.0 (sum is %f)",i,afSum[i]);
+                ReportWarning("aiMesh::mVertices[%i]: bone weight sum != 1.0 (sum is %f)", i, afSum[i]);
             }
         }
-    }
-    else if (pMesh->mBones)
-    {
+    } else if (pMesh->mBones) {
         ReportError("aiMesh::mBones is non-null although there are no bones");
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void ValidateDSProcess::Validate( const aiMesh* pMesh, const aiBone* pBone,float* afSum) {
+void ValidateDSProcess::Validate(const aiMesh *pMesh, const aiBone *pBone, float *afSum) {
     this->Validate(&pBone->mName);
 
-    if (!pBone->mNumWeights)    {
+    if (!pBone->mNumWeights) {
         //ReportError("aiBone::mNumWeights is zero");
     }
 
     // check whether all vertices affected by this bone are valid
-    for (unsigned int i = 0; i < pBone->mNumWeights;++i)
-    {
-        if (pBone->mWeights[i].mVertexId >= pMesh->mNumVertices)    {
-            ReportError("aiBone::mWeights[%i].mVertexId is out of range",i);
-        }
-        else if (!pBone->mWeights[i].mWeight || pBone->mWeights[i].mWeight > 1.0f)  {
-            ReportWarning("aiBone::mWeights[%i].mWeight has an invalid value",i);
+    for (unsigned int i = 0; i < pBone->mNumWeights; ++i) {
+        if (pBone->mWeights[i].mVertexId >= pMesh->mNumVertices) {
+            ReportError("aiBone::mWeights[%i].mVertexId is out of range", i);
+        } else if (!pBone->mWeights[i].mWeight || pBone->mWeights[i].mWeight > 1.0f) {
+            ReportWarning("aiBone::mWeights[%i].mWeight has an invalid value", i);
         }
         afSum[pBone->mWeights[i].mVertexId] += pBone->mWeights[i].mWeight;
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void ValidateDSProcess::Validate( const aiAnimation* pAnimation)
-{
+void ValidateDSProcess::Validate(const aiAnimation *pAnimation) {
     Validate(&pAnimation->mName);
 
-    // validate all materials
-    if (pAnimation->mNumChannels)
-    {
-        if (!pAnimation->mChannels) {
-            ReportError("aiAnimation::mChannels is NULL (aiAnimation::mNumChannels is %i)",
-                pAnimation->mNumChannels);
+    // validate all animations
+    if (pAnimation->mNumChannels || pAnimation->mNumMorphMeshChannels) {
+        if (!pAnimation->mChannels && pAnimation->mNumChannels) {
+            ReportError("aiAnimation::mChannels is nullptr (aiAnimation::mNumChannels is %i)",
+                    pAnimation->mNumChannels);
         }
-        for (unsigned int i = 0; i < pAnimation->mNumChannels;++i)
-        {
-            if (!pAnimation->mChannels[i])
-            {
-                ReportError("aiAnimation::mChannels[%i] is NULL (aiAnimation::mNumChannels is %i)",
-                    i, pAnimation->mNumChannels);
+        if (!pAnimation->mMorphMeshChannels && pAnimation->mNumMorphMeshChannels) {
+            ReportError("aiAnimation::mMorphMeshChannels is nullptr (aiAnimation::mNumMorphMeshChannels is %i)",
+                    pAnimation->mNumMorphMeshChannels);
+        }
+        for (unsigned int i = 0; i < pAnimation->mNumChannels; ++i) {
+            if (!pAnimation->mChannels[i]) {
+                ReportError("aiAnimation::mChannels[%i] is nullptr (aiAnimation::mNumChannels is %i)",
+                        i, pAnimation->mNumChannels);
             }
             Validate(pAnimation, pAnimation->mChannels[i]);
         }
-    }
-    else {
-    	ReportError("aiAnimation::mNumChannels is 0. At least one node animation channel must be there.");
+        for (unsigned int i = 0; i < pAnimation->mNumMorphMeshChannels; ++i) {
+            if (!pAnimation->mMorphMeshChannels[i]) {
+                ReportError("aiAnimation::mMorphMeshChannels[%i] is nullptr (aiAnimation::mNumMorphMeshChannels is %i)",
+                        i, pAnimation->mNumMorphMeshChannels);
+            }
+            Validate(pAnimation, pAnimation->mMorphMeshChannels[i]);
+        }
+    } else {
+        ReportError("aiAnimation::mNumChannels is 0. At least one node animation channel must be there.");
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void ValidateDSProcess::SearchForInvalidTextures(const aiMaterial* pMaterial,
-    aiTextureType type)
-{
-    const char* szType = TextureTypeToString(type);
+void ValidateDSProcess::SearchForInvalidTextures(const aiMaterial *pMaterial,
+        aiTextureType type) {
+    const char *szType = TextureTypeToString(type);
 
     // ****************************************************************************
     // Search all keys of the material ...
@@ -574,11 +531,11 @@ void ValidateDSProcess::SearchForInvalidTextures(const aiMaterial* pMaterial,
 
     int iNumIndices = 0;
     int iIndex = -1;
-    for (unsigned int i = 0; i < pMaterial->mNumProperties;++i) {
-        aiMaterialProperty* prop = pMaterial->mProperties[ i ];
+    for (unsigned int i = 0; i < pMaterial->mNumProperties; ++i) {
+        aiMaterialProperty *prop = pMaterial->mProperties[i];
         ai_assert(nullptr != prop);
-        if ( !::strcmp(prop->mKey.data,"$tex.file") && prop->mSemantic == static_cast<unsigned int>(type))  {
-            iIndex = std::max(iIndex, (int) prop->mIndex);
+        if (!::strcmp(prop->mKey.data, "$tex.file") && prop->mSemantic == static_cast<unsigned int>(type)) {
+            iIndex = std::max(iIndex, (int)prop->mIndex);
             ++iNumIndices;
 
             if (aiPTI_String != prop->mType) {
@@ -586,84 +543,75 @@ void ValidateDSProcess::SearchForInvalidTextures(const aiMaterial* pMaterial,
             }
         }
     }
-    if (iIndex +1 != iNumIndices)   {
+    if (iIndex + 1 != iNumIndices) {
         ReportError("%s #%i is set, but there are only %i %s textures",
-            szType,iIndex,iNumIndices,szType);
+                szType, iIndex, iNumIndices, szType);
+    }
+    if (!iNumIndices) {
+        return;
     }
-    if (!iNumIndices)return;
     std::vector<aiTextureMapping> mappings(iNumIndices);
 
     // Now check whether all UV indices are valid ...
     bool bNoSpecified = true;
-    for (unsigned int i = 0; i < pMaterial->mNumProperties;++i)
-    {
-        aiMaterialProperty* prop = pMaterial->mProperties[i];
-        if (prop->mSemantic != type)continue;
+    for (unsigned int i = 0; i < pMaterial->mNumProperties; ++i) {
+        aiMaterialProperty *prop = pMaterial->mProperties[i];
+        if (static_cast<aiTextureType>(prop->mSemantic) != type) {
+            continue;
+        }
 
-        if ((int)prop->mIndex >= iNumIndices)
-        {
+        if ((int)prop->mIndex >= iNumIndices) {
             ReportError("Found texture property with index %i, although there "
-                "are only %i textures of type %s",
-                prop->mIndex, iNumIndices, szType);
+                        "are only %i textures of type %s",
+                    prop->mIndex, iNumIndices, szType);
         }
 
-        if (!::strcmp(prop->mKey.data,"$tex.mapping"))  {
-            if (aiPTI_Integer != prop->mType || prop->mDataLength < sizeof(aiTextureMapping))
-            {
+        if (!::strcmp(prop->mKey.data, "$tex.mapping")) {
+            if (aiPTI_Integer != prop->mType || prop->mDataLength < sizeof(aiTextureMapping)) {
                 ReportError("Material property %s%i is expected to be an integer (size is %i)",
-                    prop->mKey.data,prop->mIndex,prop->mDataLength);
+                        prop->mKey.data, prop->mIndex, prop->mDataLength);
             }
-            mappings[prop->mIndex] = *((aiTextureMapping*)prop->mData);
-        }
-        else if (!::strcmp(prop->mKey.data,"$tex.uvtrafo")) {
-            if (aiPTI_Float != prop->mType || prop->mDataLength < sizeof(aiUVTransform))
-            {
+            mappings[prop->mIndex] = *((aiTextureMapping *)prop->mData);
+        } else if (!::strcmp(prop->mKey.data, "$tex.uvtrafo")) {
+            if (aiPTI_Float != prop->mType || prop->mDataLength < sizeof(aiUVTransform)) {
                 ReportError("Material property %s%i is expected to be 5 floats large (size is %i)",
-                    prop->mKey.data,prop->mIndex, prop->mDataLength);
+                        prop->mKey.data, prop->mIndex, prop->mDataLength);
             }
-            mappings[prop->mIndex] = *((aiTextureMapping*)prop->mData);
-        }
-        else if (!::strcmp(prop->mKey.data,"$tex.uvwsrc")) {
-            if (aiPTI_Integer != prop->mType || sizeof(int) > prop->mDataLength)
-            {
+            //mappings[prop->mIndex] = ((aiUVTransform*)prop->mData);
+        } else if (!::strcmp(prop->mKey.data, "$tex.uvwsrc")) {
+            if (aiPTI_Integer != prop->mType || sizeof(int) > prop->mDataLength) {
                 ReportError("Material property %s%i is expected to be an integer (size is %i)",
-                    prop->mKey.data,prop->mIndex,prop->mDataLength);
+                        prop->mKey.data, prop->mIndex, prop->mDataLength);
             }
             bNoSpecified = false;
 
             // Ignore UV indices for texture channels that are not there ...
 
             // Get the value
-            iIndex = *((unsigned int*)prop->mData);
+            iIndex = *((unsigned int *)prop->mData);
 
             // Check whether there is a mesh using this material
             // which has not enough UV channels ...
-            for (unsigned int a = 0; a < mScene->mNumMeshes;++a)
-            {
-                aiMesh* mesh = this->mScene->mMeshes[a];
-                if(mesh->mMaterialIndex == (unsigned int)i)
-                {
+            for (unsigned int a = 0; a < mScene->mNumMeshes; ++a) {
+                aiMesh *mesh = this->mScene->mMeshes[a];
+                if (mesh->mMaterialIndex == (unsigned int)i) {
                     int iChannels = 0;
-                    while (mesh->HasTextureCoords(iChannels))++iChannels;
-                    if (iIndex >= iChannels)
-                    {
+                    while (mesh->HasTextureCoords(iChannels))
+                        ++iChannels;
+                    if (iIndex >= iChannels) {
                         ReportWarning("Invalid UV index: %i (key %s). Mesh %i has only %i UV channels",
-                            iIndex,prop->mKey.data,a,iChannels);
+                                iIndex, prop->mKey.data, a, iChannels);
                     }
                 }
             }
         }
     }
-    if (bNoSpecified)
-    {
+    if (bNoSpecified) {
         // Assume that all textures are using the first UV channel
-        for (unsigned int a = 0; a < mScene->mNumMeshes;++a)
-        {
-            aiMesh* mesh = mScene->mMeshes[a];
-            if(mesh->mMaterialIndex == (unsigned int)iIndex && mappings[0] == aiTextureMapping_UV)
-            {
-                if (!mesh->mTextureCoords[0])
-                {
+        for (unsigned int a = 0; a < mScene->mNumMeshes; ++a) {
+            aiMesh *mesh = mScene->mMeshes[a];
+            if (mesh->mMaterialIndex == (unsigned int)iIndex && mappings[0] == aiTextureMapping_UV) {
+                if (!mesh->mTextureCoords[0]) {
                     // This is a special case ... it could be that the
                     // original mesh format intended the use of a special
                     // mapping here.
@@ -674,46 +622,43 @@ void ValidateDSProcess::SearchForInvalidTextures(const aiMaterial* pMaterial,
     }
 }
 // ------------------------------------------------------------------------------------------------
-void ValidateDSProcess::Validate( const aiMaterial* pMaterial)
-{
+void ValidateDSProcess::Validate(const aiMaterial *pMaterial) {
     // check whether there are material keys that are obviously not legal
-    for (unsigned int i = 0; i < pMaterial->mNumProperties;++i)
-    {
-        const aiMaterialProperty* prop = pMaterial->mProperties[i];
-        if (!prop)  {
-            ReportError("aiMaterial::mProperties[%i] is NULL (aiMaterial::mNumProperties is %i)",
-                i,pMaterial->mNumProperties);
+    for (unsigned int i = 0; i < pMaterial->mNumProperties; ++i) {
+        const aiMaterialProperty *prop = pMaterial->mProperties[i];
+        if (!prop) {
+            ReportError("aiMaterial::mProperties[%i] is nullptr (aiMaterial::mNumProperties is %i)",
+                    i, pMaterial->mNumProperties);
         }
         if (!prop->mDataLength || !prop->mData) {
             ReportError("aiMaterial::mProperties[%i].mDataLength or "
-                "aiMaterial::mProperties[%i].mData is 0",i,i);
+                        "aiMaterial::mProperties[%i].mData is 0",
+                    i, i);
         }
         // check all predefined types
-        if (aiPTI_String == prop->mType)    {
+        if (aiPTI_String == prop->mType) {
             // FIX: strings are now stored in a less expensive way, but we can't use the
             // validation routine for 'normal' aiStrings
-            if (prop->mDataLength < 5 || prop->mDataLength < 4 + (*reinterpret_cast<uint32_t*>(prop->mData)) + 1)   {
+            if (prop->mDataLength < 5 || prop->mDataLength < 4 + (*reinterpret_cast<uint32_t *>(prop->mData)) + 1) {
                 ReportError("aiMaterial::mProperties[%i].mDataLength is "
-                    "too small to contain a string (%i, needed: %i)",
-                    i,prop->mDataLength,static_cast<int>(sizeof(aiString)));
+                            "too small to contain a string (%i, needed: %i)",
+                        i, prop->mDataLength, static_cast<int>(sizeof(aiString)));
             }
-            if(prop->mData[prop->mDataLength-1]) {
+            if (prop->mData[prop->mDataLength - 1]) {
                 ReportError("Missing null-terminator in string material property");
             }
-        //  Validate((const aiString*)prop->mData);
-        }
-        else if (aiPTI_Float == prop->mType)    {
-            if (prop->mDataLength < sizeof(float))  {
+            //  Validate((const aiString*)prop->mData);
+        } else if (aiPTI_Float == prop->mType) {
+            if (prop->mDataLength < sizeof(float)) {
                 ReportError("aiMaterial::mProperties[%i].mDataLength is "
-                    "too small to contain a float (%i, needed: %i)",
-                    i,prop->mDataLength, static_cast<int>(sizeof(float)));
+                            "too small to contain a float (%i, needed: %i)",
+                        i, prop->mDataLength, static_cast<int>(sizeof(float)));
             }
-        }
-        else if (aiPTI_Integer == prop->mType)  {
-            if (prop->mDataLength < sizeof(int))    {
+        } else if (aiPTI_Integer == prop->mType) {
+            if (prop->mDataLength < sizeof(int)) {
                 ReportError("aiMaterial::mProperties[%i].mDataLength is "
-                    "too small to contain an integer (%i, needed: %i)",
-                    i,prop->mDataLength, static_cast<int>(sizeof(int)));
+                            "too small to contain an integer (%i, needed: %i)",
+                        i, prop->mDataLength, static_cast<int>(sizeof(int)));
             }
         }
         // TODO: check whether there is a key with an unknown name ...
@@ -722,20 +667,19 @@ void ValidateDSProcess::Validate( const aiMaterial* pMaterial)
     // make some more specific tests
     ai_real fTemp;
     int iShading;
-    if (AI_SUCCESS == aiGetMaterialInteger( pMaterial,AI_MATKEY_SHADING_MODEL,&iShading))   {
-        switch ((aiShadingMode)iShading)
-        {
+    if (AI_SUCCESS == aiGetMaterialInteger(pMaterial, AI_MATKEY_SHADING_MODEL, &iShading)) {
+        switch ((aiShadingMode)iShading) {
         case aiShadingMode_Blinn:
         case aiShadingMode_CookTorrance:
         case aiShadingMode_Phong:
 
-            if (AI_SUCCESS != aiGetMaterialFloat(pMaterial,AI_MATKEY_SHININESS,&fTemp)) {
+            if (AI_SUCCESS != aiGetMaterialFloat(pMaterial, AI_MATKEY_SHININESS, &fTemp)) {
                 ReportWarning("A specular shading model is specified but there is no "
-                    "AI_MATKEY_SHININESS key");
+                              "AI_MATKEY_SHININESS key");
             }
-            if (AI_SUCCESS == aiGetMaterialFloat(pMaterial,AI_MATKEY_SHININESS_STRENGTH,&fTemp) && !fTemp)  {
+            if (AI_SUCCESS == aiGetMaterialFloat(pMaterial, AI_MATKEY_SHININESS_STRENGTH, &fTemp) && !fTemp) {
                 ReportWarning("A specular shading model is specified but the value of the "
-                    "AI_MATKEY_SHININESS_STRENGTH key is 0.0");
+                              "AI_MATKEY_SHININESS_STRENGTH key is 0.0");
             }
             break;
         default:
@@ -743,235 +687,254 @@ void ValidateDSProcess::Validate( const aiMaterial* pMaterial)
         }
     }
 
-    if (AI_SUCCESS == aiGetMaterialFloat( pMaterial,AI_MATKEY_OPACITY,&fTemp) && (!fTemp || fTemp > 1.01)) {
+    if (AI_SUCCESS == aiGetMaterialFloat(pMaterial, AI_MATKEY_OPACITY, &fTemp) && (!fTemp || fTemp > 1.01)) {
         ReportWarning("Invalid opacity value (must be 0 < opacity < 1.0)");
     }
 
     // Check whether there are invalid texture keys
     // TODO: that's a relict of the past, where texture type and index were baked
     // into the material string ... we could do that in one single pass.
-    SearchForInvalidTextures(pMaterial,aiTextureType_DIFFUSE);
-    SearchForInvalidTextures(pMaterial,aiTextureType_SPECULAR);
-    SearchForInvalidTextures(pMaterial,aiTextureType_AMBIENT);
-    SearchForInvalidTextures(pMaterial,aiTextureType_EMISSIVE);
-    SearchForInvalidTextures(pMaterial,aiTextureType_OPACITY);
-    SearchForInvalidTextures(pMaterial,aiTextureType_SHININESS);
-    SearchForInvalidTextures(pMaterial,aiTextureType_HEIGHT);
-    SearchForInvalidTextures(pMaterial,aiTextureType_NORMALS);
-    SearchForInvalidTextures(pMaterial,aiTextureType_DISPLACEMENT);
-    SearchForInvalidTextures(pMaterial,aiTextureType_LIGHTMAP);
-    SearchForInvalidTextures(pMaterial,aiTextureType_REFLECTION);
+    SearchForInvalidTextures(pMaterial, aiTextureType_DIFFUSE);
+    SearchForInvalidTextures(pMaterial, aiTextureType_SPECULAR);
+    SearchForInvalidTextures(pMaterial, aiTextureType_AMBIENT);
+    SearchForInvalidTextures(pMaterial, aiTextureType_EMISSIVE);
+    SearchForInvalidTextures(pMaterial, aiTextureType_OPACITY);
+    SearchForInvalidTextures(pMaterial, aiTextureType_SHININESS);
+    SearchForInvalidTextures(pMaterial, aiTextureType_HEIGHT);
+    SearchForInvalidTextures(pMaterial, aiTextureType_NORMALS);
+    SearchForInvalidTextures(pMaterial, aiTextureType_DISPLACEMENT);
+    SearchForInvalidTextures(pMaterial, aiTextureType_LIGHTMAP);
+    SearchForInvalidTextures(pMaterial, aiTextureType_REFLECTION);
+    SearchForInvalidTextures(pMaterial, aiTextureType_BASE_COLOR);
+    SearchForInvalidTextures(pMaterial, aiTextureType_NORMAL_CAMERA);
+    SearchForInvalidTextures(pMaterial, aiTextureType_EMISSION_COLOR);
+    SearchForInvalidTextures(pMaterial, aiTextureType_METALNESS);
+    SearchForInvalidTextures(pMaterial, aiTextureType_DIFFUSE_ROUGHNESS);
+    SearchForInvalidTextures(pMaterial, aiTextureType_AMBIENT_OCCLUSION);
 }
 
 // ------------------------------------------------------------------------------------------------
-void ValidateDSProcess::Validate( const aiTexture* pTexture)
-{
-    // the data section may NEVER be NULL
-    if (!pTexture->pcData)  {
-        ReportError("aiTexture::pcData is NULL");
+void ValidateDSProcess::Validate(const aiTexture *pTexture) {
+    // the data section may NEVER be nullptr
+    if (nullptr == pTexture->pcData) {
+        ReportError("aiTexture::pcData is nullptr");
     }
-    if (pTexture->mHeight)
-    {
-        if (!pTexture->mWidth){
-        	ReportError("aiTexture::mWidth is zero (aiTexture::mHeight is %i, uncompressed texture)",
-        			pTexture->mHeight);
+    if (pTexture->mHeight) {
+        if (!pTexture->mWidth) {
+            ReportError("aiTexture::mWidth is zero (aiTexture::mHeight is %i, uncompressed texture)",
+                    pTexture->mHeight);
         }
-    }
-    else
-    {
+    } else {
         if (!pTexture->mWidth) {
             ReportError("aiTexture::mWidth is zero (compressed texture)");
         }
-        if ('\0' != pTexture->achFormatHint[3]) {
+        if ('\0' != pTexture->achFormatHint[HINTMAXTEXTURELEN - 1]) {
             ReportWarning("aiTexture::achFormatHint must be zero-terminated");
-        }
-        else if ('.'  == pTexture->achFormatHint[0])    {
+        } else if ('.' == pTexture->achFormatHint[0]) {
             ReportWarning("aiTexture::achFormatHint should contain a file extension "
-                "without a leading dot (format hint: %s).",pTexture->achFormatHint);
+                          "without a leading dot (format hint: %s).",
+                    pTexture->achFormatHint);
         }
     }
 
-    const char* sz = pTexture->achFormatHint;
+    const char *sz = pTexture->achFormatHint;
     if ((sz[0] >= 'A' && sz[0] <= 'Z') ||
-        (sz[1] >= 'A' && sz[1] <= 'Z') ||
-        (sz[2] >= 'A' && sz[2] <= 'Z') ||
-        (sz[3] >= 'A' && sz[3] <= 'Z')) {
+            (sz[1] >= 'A' && sz[1] <= 'Z') ||
+            (sz[2] >= 'A' && sz[2] <= 'Z') ||
+            (sz[3] >= 'A' && sz[3] <= 'Z')) {
         ReportError("aiTexture::achFormatHint contains non-lowercase letters");
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void ValidateDSProcess::Validate( const aiAnimation* pAnimation,
-     const aiNodeAnim* pNodeAnim)
-{
+void ValidateDSProcess::Validate(const aiAnimation *pAnimation,
+        const aiNodeAnim *pNodeAnim) {
     Validate(&pNodeAnim->mNodeName);
 
     if (!pNodeAnim->mNumPositionKeys && !pNodeAnim->mScalingKeys && !pNodeAnim->mNumRotationKeys) {
         ReportError("Empty node animation channel");
     }
     // otherwise check whether one of the keys exceeds the total duration of the animation
-    if (pNodeAnim->mNumPositionKeys)
-    {
-        if (!pNodeAnim->mPositionKeys)
-        {
-        	ReportError("aiNodeAnim::mPositionKeys is NULL (aiNodeAnim::mNumPositionKeys is %i)",
-                pNodeAnim->mNumPositionKeys);
+    if (pNodeAnim->mNumPositionKeys) {
+        if (!pNodeAnim->mPositionKeys) {
+            ReportError("aiNodeAnim::mPositionKeys is nullptr (aiNodeAnim::mNumPositionKeys is %i)",
+                    pNodeAnim->mNumPositionKeys);
         }
         double dLast = -10e10;
-        for (unsigned int i = 0; i < pNodeAnim->mNumPositionKeys;++i)
-        {
+        for (unsigned int i = 0; i < pNodeAnim->mNumPositionKeys; ++i) {
             // ScenePreprocessor will compute the duration if still the default value
             // (Aramis) Add small epsilon, comparison tended to fail if max_time == duration,
             //  seems to be due the compilers register usage/width.
-            if (pAnimation->mDuration > 0. && pNodeAnim->mPositionKeys[i].mTime > pAnimation->mDuration+0.001)
-            {
+            if (pAnimation->mDuration > 0. && pNodeAnim->mPositionKeys[i].mTime > pAnimation->mDuration + 0.001) {
                 ReportError("aiNodeAnim::mPositionKeys[%i].mTime (%.5f) is larger "
-                    "than aiAnimation::mDuration (which is %.5f)",i,
-                    (float)pNodeAnim->mPositionKeys[i].mTime,
-                    (float)pAnimation->mDuration);
+                            "than aiAnimation::mDuration (which is %.5f)",
+                        i,
+                        (float)pNodeAnim->mPositionKeys[i].mTime,
+                        (float)pAnimation->mDuration);
             }
-            if (i && pNodeAnim->mPositionKeys[i].mTime <= dLast)
-            {
+            if (i && pNodeAnim->mPositionKeys[i].mTime <= dLast) {
                 ReportWarning("aiNodeAnim::mPositionKeys[%i].mTime (%.5f) is smaller "
-                    "than aiAnimation::mPositionKeys[%i] (which is %.5f)",i,
-                    (float)pNodeAnim->mPositionKeys[i].mTime,
-                    i-1, (float)dLast);
+                              "than aiAnimation::mPositionKeys[%i] (which is %.5f)",
+                        i,
+                        (float)pNodeAnim->mPositionKeys[i].mTime,
+                        i - 1, (float)dLast);
             }
             dLast = pNodeAnim->mPositionKeys[i].mTime;
         }
     }
     // rotation keys
-    if (pNodeAnim->mNumRotationKeys)
-    {
-        if (!pNodeAnim->mRotationKeys)
-        {
-            ReportError("aiNodeAnim::mRotationKeys is NULL (aiNodeAnim::mNumRotationKeys is %i)",
-                pNodeAnim->mNumRotationKeys);
+    if (pNodeAnim->mNumRotationKeys) {
+        if (!pNodeAnim->mRotationKeys) {
+            ReportError("aiNodeAnim::mRotationKeys is nullptr (aiNodeAnim::mNumRotationKeys is %i)",
+                    pNodeAnim->mNumRotationKeys);
         }
         double dLast = -10e10;
-        for (unsigned int i = 0; i < pNodeAnim->mNumRotationKeys;++i)
-        {
-            if (pAnimation->mDuration > 0. && pNodeAnim->mRotationKeys[i].mTime > pAnimation->mDuration+0.001)
-            {
+        for (unsigned int i = 0; i < pNodeAnim->mNumRotationKeys; ++i) {
+            if (pAnimation->mDuration > 0. && pNodeAnim->mRotationKeys[i].mTime > pAnimation->mDuration + 0.001) {
                 ReportError("aiNodeAnim::mRotationKeys[%i].mTime (%.5f) is larger "
-                    "than aiAnimation::mDuration (which is %.5f)",i,
-                    (float)pNodeAnim->mRotationKeys[i].mTime,
-                    (float)pAnimation->mDuration);
+                            "than aiAnimation::mDuration (which is %.5f)",
+                        i,
+                        (float)pNodeAnim->mRotationKeys[i].mTime,
+                        (float)pAnimation->mDuration);
             }
-            if (i && pNodeAnim->mRotationKeys[i].mTime <= dLast)
-            {
+            if (i && pNodeAnim->mRotationKeys[i].mTime <= dLast) {
                 ReportWarning("aiNodeAnim::mRotationKeys[%i].mTime (%.5f) is smaller "
-                    "than aiAnimation::mRotationKeys[%i] (which is %.5f)",i,
-                    (float)pNodeAnim->mRotationKeys[i].mTime,
-                    i-1, (float)dLast);
+                              "than aiAnimation::mRotationKeys[%i] (which is %.5f)",
+                        i,
+                        (float)pNodeAnim->mRotationKeys[i].mTime,
+                        i - 1, (float)dLast);
             }
             dLast = pNodeAnim->mRotationKeys[i].mTime;
         }
     }
     // scaling keys
-    if (pNodeAnim->mNumScalingKeys)
-    {
-        if (!pNodeAnim->mScalingKeys)   {
-            ReportError("aiNodeAnim::mScalingKeys is NULL (aiNodeAnim::mNumScalingKeys is %i)",
-                pNodeAnim->mNumScalingKeys);
+    if (pNodeAnim->mNumScalingKeys) {
+        if (!pNodeAnim->mScalingKeys) {
+            ReportError("aiNodeAnim::mScalingKeys is nullptr (aiNodeAnim::mNumScalingKeys is %i)",
+                    pNodeAnim->mNumScalingKeys);
         }
         double dLast = -10e10;
-        for (unsigned int i = 0; i < pNodeAnim->mNumScalingKeys;++i)
-        {
-            if (pAnimation->mDuration > 0. && pNodeAnim->mScalingKeys[i].mTime > pAnimation->mDuration+0.001)
-            {
+        for (unsigned int i = 0; i < pNodeAnim->mNumScalingKeys; ++i) {
+            if (pAnimation->mDuration > 0. && pNodeAnim->mScalingKeys[i].mTime > pAnimation->mDuration + 0.001) {
                 ReportError("aiNodeAnim::mScalingKeys[%i].mTime (%.5f) is larger "
-                    "than aiAnimation::mDuration (which is %.5f)",i,
-                    (float)pNodeAnim->mScalingKeys[i].mTime,
-                    (float)pAnimation->mDuration);
+                            "than aiAnimation::mDuration (which is %.5f)",
+                        i,
+                        (float)pNodeAnim->mScalingKeys[i].mTime,
+                        (float)pAnimation->mDuration);
             }
-            if (i && pNodeAnim->mScalingKeys[i].mTime <= dLast)
-            {
+            if (i && pNodeAnim->mScalingKeys[i].mTime <= dLast) {
                 ReportWarning("aiNodeAnim::mScalingKeys[%i].mTime (%.5f) is smaller "
-                    "than aiAnimation::mScalingKeys[%i] (which is %.5f)",i,
-                    (float)pNodeAnim->mScalingKeys[i].mTime,
-                    i-1, (float)dLast);
+                              "than aiAnimation::mScalingKeys[%i] (which is %.5f)",
+                        i,
+                        (float)pNodeAnim->mScalingKeys[i].mTime,
+                        i - 1, (float)dLast);
             }
             dLast = pNodeAnim->mScalingKeys[i].mTime;
         }
     }
 
     if (!pNodeAnim->mNumScalingKeys && !pNodeAnim->mNumRotationKeys &&
-        !pNodeAnim->mNumPositionKeys)
-    {
+            !pNodeAnim->mNumPositionKeys) {
         ReportError("A node animation channel must have at least one subtrack");
     }
 }
 
+void ValidateDSProcess::Validate(const aiAnimation *pAnimation,
+        const aiMeshMorphAnim *pMeshMorphAnim) {
+    Validate(&pMeshMorphAnim->mName);
+
+    if (!pMeshMorphAnim->mNumKeys) {
+        ReportWarning("Empty mesh morph animation channel");
+        return;
+    }
+
+    // otherwise check whether one of the keys exceeds the total duration of the animation
+    if (pMeshMorphAnim->mNumKeys) {
+        if (!pMeshMorphAnim->mKeys) {
+            ReportError("aiMeshMorphAnim::mKeys is nullptr (aiMeshMorphAnim::mNumKeys is %i)",
+                    pMeshMorphAnim->mNumKeys);
+        }
+        double dLast = -10e10;
+        for (unsigned int i = 0; i < pMeshMorphAnim->mNumKeys; ++i) {
+            // ScenePreprocessor will compute the duration if still the default value
+            // (Aramis) Add small epsilon, comparison tended to fail if max_time == duration,
+            //  seems to be due the compilers register usage/width.
+            if (pAnimation->mDuration > 0. && pMeshMorphAnim->mKeys[i].mTime > pAnimation->mDuration + 0.001) {
+                ReportError("aiMeshMorphAnim::mKeys[%i].mTime (%.5f) is larger "
+                            "than aiAnimation::mDuration (which is %.5f)",
+                        i,
+                        (float)pMeshMorphAnim->mKeys[i].mTime,
+                        (float)pAnimation->mDuration);
+            }
+            if (i && pMeshMorphAnim->mKeys[i].mTime <= dLast) {
+                ReportWarning("aiMeshMorphAnim::mKeys[%i].mTime (%.5f) is smaller "
+                              "than aiMeshMorphAnim::mKeys[%i] (which is %.5f)",
+                        i,
+                        (float)pMeshMorphAnim->mKeys[i].mTime,
+                        i - 1, (float)dLast);
+            }
+            dLast = pMeshMorphAnim->mKeys[i].mTime;
+        }
+    }
+}
+
 // ------------------------------------------------------------------------------------------------
-void ValidateDSProcess::Validate( const aiNode* pNode)
-{
+void ValidateDSProcess::Validate(const aiNode *pNode) {
     if (!pNode) {
-    	ReportError("A node of the scenegraph is NULL");
+        ReportError("A node of the scene-graph is nullptr");
     }
     // Validate node name string first so that it's safe to use in below expressions
     this->Validate(&pNode->mName);
-    const char* nodeName = (&pNode->mName)->C_Str();
-    if (pNode != mScene->mRootNode && !pNode->mParent){
-        ReportError("Non-root node %s lacks a valid parent (aiNode::mParent is NULL) ", nodeName);
+    const char *nodeName = (&pNode->mName)->C_Str();
+    if (pNode != mScene->mRootNode && !pNode->mParent) {
+        ReportError("Non-root node %s lacks a valid parent (aiNode::mParent is nullptr) ", nodeName);
     }
 
     // validate all meshes
-    if (pNode->mNumMeshes)
-    {
-        if (!pNode->mMeshes)
-        {
-            ReportError("aiNode::mMeshes is NULL for node %s (aiNode::mNumMeshes is %i)",
-            		  nodeName, pNode->mNumMeshes);
+    if (pNode->mNumMeshes) {
+        if (!pNode->mMeshes) {
+            ReportError("aiNode::mMeshes is nullptr for node %s (aiNode::mNumMeshes is %i)",
+                    nodeName, pNode->mNumMeshes);
         }
         std::vector<bool> abHadMesh;
-        abHadMesh.resize(mScene->mNumMeshes,false);
-        for (unsigned int i = 0; i < pNode->mNumMeshes;++i)
-        {
-            if (pNode->mMeshes[i] >= mScene->mNumMeshes)
-            {
+        abHadMesh.resize(mScene->mNumMeshes, false);
+        for (unsigned int i = 0; i < pNode->mNumMeshes; ++i) {
+            if (pNode->mMeshes[i] >= mScene->mNumMeshes) {
                 ReportError("aiNode::mMeshes[%i] is out of range for node %s (maximum is %i)",
-                    pNode->mMeshes[i], nodeName, mScene->mNumMeshes-1);
+                        pNode->mMeshes[i], nodeName, mScene->mNumMeshes - 1);
             }
-            if (abHadMesh[pNode->mMeshes[i]])
-            {
+            if (abHadMesh[pNode->mMeshes[i]]) {
                 ReportError("aiNode::mMeshes[%i] is already referenced by this node %s (value: %i)",
-                    i, nodeName, pNode->mMeshes[i]);
+                        i, nodeName, pNode->mMeshes[i]);
             }
             abHadMesh[pNode->mMeshes[i]] = true;
         }
     }
-    if (pNode->mNumChildren)
-    {
-        if (!pNode->mChildren)  {
-            ReportError("aiNode::mChildren is NULL for node %s (aiNode::mNumChildren is %i)",
-            		nodeName, pNode->mNumChildren);
+    if (pNode->mNumChildren) {
+        if (!pNode->mChildren) {
+            ReportError("aiNode::mChildren is nullptr for node %s (aiNode::mNumChildren is %i)",
+                    nodeName, pNode->mNumChildren);
         }
-        for (unsigned int i = 0; i < pNode->mNumChildren;++i)   {
+        for (unsigned int i = 0; i < pNode->mNumChildren; ++i) {
             Validate(pNode->mChildren[i]);
         }
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void ValidateDSProcess::Validate( const aiString* pString)
-{
-    if (pString->length > MAXLEN)
-    {
+void ValidateDSProcess::Validate(const aiString *pString) {
+    if (pString->length > MAXLEN) {
         ReportError("aiString::length is too large (%u, maximum is %lu)",
-            pString->length,MAXLEN);
+                pString->length, MAXLEN);
     }
-    const char* sz = pString->data;
-    while (true)
-    {
-        if ('\0' == *sz)
-        {
-            if (pString->length != (unsigned int)(sz-pString->data)) {
+    const char *sz = pString->data;
+    while (true) {
+        if ('\0' == *sz) {
+            if (pString->length != (unsigned int)(sz - pString->data)) {
                 ReportError("aiString::data is invalid: the terminal zero is at a wrong offset");
             }
             break;
-        }
-        else if (sz >= &pString->data[MAXLEN]) {
+        } else if (sz >= &pString->data[MAXLEN]) {
             ReportError("aiString::data is invalid. There is no terminal character");
         }
         ++sz;
diff --git a/Engine/lib/assimp/code/PostProcessing/ValidateDataStructure.h b/Engine/lib/assimp/code/PostProcessing/ValidateDataStructure.h
index 0b891ef41..077a47b70 100644
--- a/Engine/lib/assimp/code/PostProcessing/ValidateDataStructure.h
+++ b/Engine/lib/assimp/code/PostProcessing/ValidateDataStructure.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -55,6 +55,7 @@ struct aiBone;
 struct aiMesh;
 struct aiAnimation;
 struct aiNodeAnim;
+struct aiMeshMorphAnim;
 struct aiTexture;
 struct aiMaterial;
 struct aiNode;
@@ -150,6 +151,13 @@ protected:
     void Validate( const aiAnimation* pAnimation,
         const aiNodeAnim* pBoneAnim);
 
+    /** Validates a mesh morph animation channel.
+     * @param pAnimation Input animation.
+     * @param pMeshMorphAnim Mesh morph animation channel.
+     * */
+    void Validate( const aiAnimation* pAnimation,
+        const aiMeshMorphAnim* pMeshMorphAnim);
+
     // -------------------------------------------------------------------
     /** Validates a node and all of its subnodes
      * @param Node Input node*/
diff --git a/Engine/lib/assimp/code/Q3BSP/Q3BSPFileImporter.cpp b/Engine/lib/assimp/code/Q3BSP/Q3BSPFileImporter.cpp
deleted file mode 100644
index 4add00a07..000000000
--- a/Engine/lib/assimp/code/Q3BSP/Q3BSPFileImporter.cpp
+++ /dev/null
@@ -1,706 +0,0 @@
-/*
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
----------------------------------------------------------------------------------------------------
-*/
-
-#ifndef ASSIMP_BUILD_NO_Q3BSP_IMPORTER
-
-#include "Q3BSPFileImporter.h"
-#include "Q3BSPFileParser.h"
-#include "Q3BSPFileData.h"
-
-#include <assimp/DefaultLogger.hpp>
-
-#ifdef ASSIMP_BUILD_NO_OWN_ZLIB
-#   include <zlib.h>
-#else
-#   include "../contrib/zlib/zlib.h"
-#endif
-
-#include <assimp/types.h>
-#include <assimp/mesh.h>
-#include <assimp/scene.h>
-#include <assimp/ai_assert.h>
-#include <assimp/DefaultIOSystem.h>
-#include <assimp/ZipArchiveIOSystem.h>
-#include <assimp/importerdesc.h>
-#include <vector>
-#include <sstream>
-#include <assimp/StringComparison.h>
-
-static const aiImporterDesc desc = {
-    "Quake III BSP Importer",
-    "",
-    "",
-    "",
-    aiImporterFlags_SupportBinaryFlavour,
-    0,
-    0,
-    0,
-    0,
-    "pk3"
-};
-
-namespace Assimp {
-
-using namespace Q3BSP;
-
-// ------------------------------------------------------------------------------------------------
-//  Local function to create a material key name.
-static void createKey( int id1, int id2, std::string &key ) {
-    std::ostringstream str;
-    str << id1 << "." << id2;
-    key = str.str();
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Local function to extract the texture ids from a material key-name.
-static void extractIds( const std::string &key, int &id1, int &id2 ) {
-    id1 = -1;
-    id2 = -1;
-    if (key.empty()) {
-        return;
-    }
-
-    const std::string::size_type pos = key.find( "." );
-    if (std::string::npos == pos) {
-        return;
-    }
-
-    std::string tmp1 = key.substr( 0, pos );
-    std::string tmp2 = key.substr( pos + 1, key.size() - pos - 1 );
-    id1 = atoi( tmp1.c_str() );
-    id2 = atoi( tmp2.c_str() );
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Local helper function to normalize filenames.
-static void normalizePathName( const std::string &rPath, std::string &normalizedPath ) {
-    normalizedPath = "";
-    if (rPath.empty()) {
-        return;
-    }
-
-#ifdef _WIN32
-    std::string sep = "\\";
-#else
-    std::string sep = "/";
-#endif
-
-    static const unsigned int numDelimiters = 2;
-    const char delimiters[ numDelimiters ] = { '/', '\\' };
-    normalizedPath = rPath;
-    for (const char delimiter : delimiters) {
-        for ( size_t j=0; j<normalizedPath.size(); ++j ) {
-            if ( normalizedPath[j] == delimiter ) {
-                normalizedPath[ j ] = sep[ 0 ];
-            }
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Constructor.
-Q3BSPFileImporter::Q3BSPFileImporter()
-: m_pCurrentMesh( nullptr )
-, m_pCurrentFace(nullptr)
-, m_MaterialLookupMap()
-, mTextures() {
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Destructor.
-Q3BSPFileImporter::~Q3BSPFileImporter() {
-    m_pCurrentMesh = nullptr;
-    m_pCurrentFace = nullptr;
-
-    // Clear face-to-material map
-    for ( FaceMap::iterator it = m_MaterialLookupMap.begin(); it != m_MaterialLookupMap.end(); ++it ) {
-        const std::string &matName = it->first;
-        if ( !matName.empty() ) {
-            delete it->second;
-        }
-    }
-    m_MaterialLookupMap.clear();
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Returns true, if the loader can read this.
-bool Q3BSPFileImporter::CanRead( const std::string& rFile, IOSystem* /*pIOHandler*/, bool checkSig ) const {
-    if(!checkSig) {
-        return SimpleExtensionCheck( rFile, "pk3", "bsp" );
-    }
-
-    return false;
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Adds extensions.
-const aiImporterDesc* Q3BSPFileImporter::GetInfo () const {
-    return &desc;
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Import method.
-void Q3BSPFileImporter::InternReadFile(const std::string &rFile, aiScene* scene, IOSystem* ioHandler) {
-    ZipArchiveIOSystem Archive( ioHandler, rFile );
-    if ( !Archive.isOpen() ) {
-        throw DeadlyImportError( "Failed to open file " + rFile + "." );
-    }
-
-    std::string archiveName( "" ), mapName( "" );
-    separateMapName( rFile, archiveName, mapName );
-
-    if ( mapName.empty() ) {
-        if ( !findFirstMapInArchive( Archive, mapName ) ) {
-            return;
-        }
-    }
-
-    Q3BSPFileParser fileParser( mapName, &Archive );
-    Q3BSPModel *pBSPModel = fileParser.getModel();
-    if ( nullptr != pBSPModel ) {
-        CreateDataFromImport( pBSPModel, scene, &Archive );
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Separates the map name from the import name.
-void Q3BSPFileImporter::separateMapName( const std::string &importName, std::string &archiveName, std::string &mapName ) {
-    archiveName = "";
-    mapName = "";
-    if (importName.empty()) {
-        return;
-    }
-
-    const std::string::size_type pos = importName.rfind( "," );
-    if ( std::string::npos == pos ) {
-        archiveName = importName;
-        return;
-    }
-
-    archiveName = importName.substr( 0, pos );
-    mapName = importName.substr( pos, importName.size() - pos - 1 );
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Returns the first map in the map archive.
-bool Q3BSPFileImporter::findFirstMapInArchive(ZipArchiveIOSystem &bspArchive, std::string &mapName ) {
-    mapName = "";
-    std::vector<std::string> fileList;
-    bspArchive.getFileListExtension( fileList, "bsp" );
-    if (fileList.empty()) {
-        return false;
-    }
-
-    std::vector<std::string>::iterator it( fileList.begin() );
-    for ( ; it != fileList.end(); ++it ) {
-        const std::string::size_type pos = (*it).find( "maps/" );
-        if ( std::string::npos != pos ) {
-            std::string::size_type extPos = (*it).find( ".bsp" );
-            if ( std::string::npos != extPos ) {
-                mapName = *it;
-                return true;
-            }
-        }
-    }
-
-    return false;
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Creates the assimp specific data.
-void Q3BSPFileImporter::CreateDataFromImport( const Q3BSP::Q3BSPModel *pModel, aiScene* pScene,
-    ZipArchiveIOSystem *pArchive ) {
-    if (nullptr == pModel || nullptr == pScene) {
-        return;
-    }
-
-    pScene->mRootNode = new aiNode;
-    if ( !pModel->m_ModelName.empty() ) {
-        pScene->mRootNode->mName.Set( pModel->m_ModelName );
-    }
-
-    // Create the face to material relation map
-    createMaterialMap( pModel );
-
-    // Create all nodes
-    CreateNodes( pModel, pScene, pScene->mRootNode );
-
-    // Create the assigned materials
-    createMaterials( pModel, pScene, pArchive );
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Creates all assimp nodes.
-void Q3BSPFileImporter::CreateNodes( const Q3BSP::Q3BSPModel *pModel, aiScene* pScene,
-        aiNode *pParent ) {
-    if ( nullptr == pModel ) {
-        return;
-    }
-
-    unsigned int matIdx( 0 );
-    std::vector<aiMesh*> MeshArray;
-    std::vector<aiNode*> NodeArray;
-    for ( FaceMapIt it = m_MaterialLookupMap.begin(); it != m_MaterialLookupMap.end(); ++it ) {
-        std::vector<Q3BSP::sQ3BSPFace*> *pArray = (*it).second;
-        size_t numVerts = countData( *pArray );
-        if ( 0 != numVerts ) {
-            aiMesh *pMesh( nullptr );
-            aiNode *pNode = CreateTopology( pModel, matIdx, *pArray, &pMesh );
-            if ( nullptr != pNode ) {
-                NodeArray.push_back( pNode );
-                MeshArray.push_back( pMesh );
-            }
-        }
-        matIdx++;
-    }
-
-    pScene->mNumMeshes = static_cast<unsigned int>( MeshArray.size() );
-    if ( pScene->mNumMeshes > 0 ) {
-        pScene->mMeshes = new aiMesh*[ pScene->mNumMeshes ];
-        for ( size_t i = 0; i < MeshArray.size(); i++ ) {
-            aiMesh *pMesh = MeshArray[ i ];
-            if ( nullptr != pMesh ) {
-                pScene->mMeshes[ i ] = pMesh;
-            }
-        }
-    }
-
-    pParent->mNumChildren = static_cast<unsigned int>(MeshArray.size());
-    pParent->mChildren = new aiNode*[ pScene->mRootNode->mNumChildren ];
-    for ( size_t i=0; i<NodeArray.size(); i++ ) {
-        aiNode *pNode = NodeArray[ i ];
-        pNode->mParent = pParent;
-        pParent->mChildren[ i ] = pNode;
-        pParent->mChildren[ i ]->mMeshes[ 0 ] = static_cast<unsigned int>(i);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Creates the topology.
-aiNode *Q3BSPFileImporter::CreateTopology( const Q3BSP::Q3BSPModel *pModel, unsigned int materialIdx,
-        std::vector<sQ3BSPFace*> &rArray, aiMesh **pMesh ) {
-    size_t numVerts = countData( rArray );
-    if ( 0 == numVerts ) {
-        return nullptr;
-    }
-
-    size_t numFaces = countFaces( rArray );
-    if ( 0 == numFaces ) {
-        return nullptr;
-    }
-
-    aiMesh *mesh = new aiMesh;
-    size_t numTriangles = countTriangles( rArray );
-    mesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
-
-    mesh->mFaces = new aiFace[ numTriangles ];
-    mesh->mNumFaces = static_cast<unsigned int>(numTriangles);
-
-    mesh->mNumVertices = static_cast<unsigned int>(numVerts);
-    mesh->mVertices = new aiVector3D[ numVerts ];
-    mesh->mNormals =  new aiVector3D[ numVerts ];
-    mesh->mTextureCoords[ 0 ] = new aiVector3D[ numVerts ];
-    mesh->mTextureCoords[ 1 ] = new aiVector3D[ numVerts ];
-    mesh->mMaterialIndex = materialIdx;
-
-    unsigned int faceIdx = 0;
-    unsigned int vertIdx = 0;
-    mesh->mNumUVComponents[ 0 ] = 2;
-    mesh->mNumUVComponents[ 1 ] = 2;
-    for ( std::vector<sQ3BSPFace*>::const_iterator it = rArray.begin(); it != rArray.end(); ++it ) {
-        Q3BSP::sQ3BSPFace *pQ3BSPFace = *it;
-        ai_assert( NULL != pQ3BSPFace );
-        if ( nullptr == pQ3BSPFace ) {
-            continue;
-        }
-
-        if ( pQ3BSPFace->iNumOfFaceVerts > 0 ) {
-            if ( pQ3BSPFace->iType == Polygon || pQ3BSPFace->iType == TriangleMesh ) {
-                createTriangleTopology( pModel, pQ3BSPFace, mesh, faceIdx, vertIdx );
-            }
-        }
-    }
-
-    aiNode *pNode = new aiNode;
-    pNode->mNumMeshes = 1;
-    pNode->mMeshes = new unsigned int[ 1 ];
-    *pMesh = mesh;
-
-    return pNode;
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Creates the triangle topology from a face array.
-void Q3BSPFileImporter::createTriangleTopology( const Q3BSP::Q3BSPModel *pModel, sQ3BSPFace *pQ3BSPFace,
-        aiMesh* pMesh, unsigned int &faceIdx, unsigned int &vertIdx ) {
-    ai_assert( faceIdx < pMesh->mNumFaces );
-
-    m_pCurrentFace = getNextFace( pMesh, faceIdx );
-    if ( nullptr == m_pCurrentFace ) {
-        return;
-    }
-
-    m_pCurrentFace->mNumIndices = 3;
-    m_pCurrentFace->mIndices = new unsigned int[ m_pCurrentFace->mNumIndices ];
-
-    size_t idx( 0 );
-    for ( size_t i = 0; i < (size_t) pQ3BSPFace->iNumOfFaceVerts; ++i ) {
-        const size_t index = pQ3BSPFace->iVertexIndex + pModel->m_Indices[ pQ3BSPFace->iFaceVertexIndex + i ];
-        if ( index >= pModel->m_Vertices.size() ) {
-            continue;
-        }
-
-        sQ3BSPVertex *pVertex = pModel->m_Vertices[ index ];
-        if ( nullptr == pVertex ) {
-            continue;
-        }
-        if (idx > 2) {
-            idx = 0;
-            m_pCurrentFace = getNextFace(pMesh, faceIdx);
-            if (nullptr != m_pCurrentFace) {
-                m_pCurrentFace->mNumIndices = 3;
-                m_pCurrentFace->mIndices = new unsigned int[3];
-                m_pCurrentFace->mIndices[ idx ] = vertIdx;
-            }
-        }
-
-        pMesh->mVertices[ vertIdx ].Set( pVertex->vPosition.x, pVertex->vPosition.y, pVertex->vPosition.z );
-        pMesh->mNormals[ vertIdx ].Set( pVertex->vNormal.x, pVertex->vNormal.y, pVertex->vNormal.z );
-
-        pMesh->mTextureCoords[ 0 ][ vertIdx ].Set( pVertex->vTexCoord.x, pVertex->vTexCoord.y, 0.0f );
-        pMesh->mTextureCoords[ 1 ][ vertIdx ].Set( pVertex->vLightmap.x, pVertex->vLightmap.y, 0.0f );
-
-        vertIdx++;
-        idx++;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Creates all referenced materials.
-void Q3BSPFileImporter::createMaterials( const Q3BSP::Q3BSPModel *pModel, aiScene* pScene,
-    ZipArchiveIOSystem *pArchive ) {
-    if ( m_MaterialLookupMap.empty() ) {
-        return;
-    }
-
-    pScene->mMaterials = new aiMaterial*[ m_MaterialLookupMap.size() ];
-    aiString aiMatName;
-    int textureId( -1 ), lightmapId( -1 );
-    for ( FaceMapIt it = m_MaterialLookupMap.begin(); it != m_MaterialLookupMap.end();
-        ++it ) {
-        const std::string matName( it->first );
-        if ( matName.empty() ) {
-            continue;
-        }
-
-        aiMatName.Set( matName );
-        aiMaterial *pMatHelper = new aiMaterial;
-        pMatHelper->AddProperty( &aiMatName, AI_MATKEY_NAME );
-
-        extractIds( matName, textureId, lightmapId );
-
-        // Adding the texture
-        if ( -1 != textureId ) {
-            sQ3BSPTexture *pTexture = pModel->m_Textures[ textureId ];
-            if ( nullptr != pTexture ) {
-                std::string tmp( "*" ), texName( "" );
-                tmp += pTexture->strName;
-                tmp += ".jpg";
-                normalizePathName( tmp, texName );
-
-                if ( !importTextureFromArchive( pModel, pArchive, pScene, pMatHelper, textureId ) ) {
-                    ASSIMP_LOG_ERROR("Cannot import texture from archive " + texName);
-                }
-            }
-
-        }
-        if ( -1 != lightmapId )
-        {
-            importLightmap( pModel, pScene, pMatHelper, lightmapId );
-        }
-        pScene->mMaterials[ pScene->mNumMaterials ] = pMatHelper;
-        pScene->mNumMaterials++;
-    }
-    pScene->mNumTextures = static_cast<unsigned int>(mTextures.size());
-    pScene->mTextures = new aiTexture*[ pScene->mNumTextures ];
-    std::copy( mTextures.begin(), mTextures.end(), pScene->mTextures );
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Counts the number of referenced vertices.
-size_t Q3BSPFileImporter::countData( const std::vector<sQ3BSPFace*> &faceArray ) const {
-    size_t numVerts( 0 );
-    for ( std::vector<sQ3BSPFace*>::const_iterator it = faceArray.begin(); it != faceArray.end();
-        ++it )
-    {
-        sQ3BSPFace *pQ3BSPFace = *it;
-        if ( pQ3BSPFace->iType == Polygon || pQ3BSPFace->iType == TriangleMesh )
-        {
-            Q3BSP::sQ3BSPFace *pQ3BSPFace = *it;
-            ai_assert( nullptr != pQ3BSPFace );
-            numVerts += pQ3BSPFace->iNumOfFaceVerts;
-        }
-    }
-
-    return numVerts;
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Counts the faces with vertices.
-size_t Q3BSPFileImporter::countFaces( const std::vector<Q3BSP::sQ3BSPFace*> &rArray ) const
-{
-    size_t numFaces = 0;
-    for ( std::vector<sQ3BSPFace*>::const_iterator it = rArray.begin(); it != rArray.end();
-        ++it )
-    {
-        Q3BSP::sQ3BSPFace *pQ3BSPFace = *it;
-        if ( pQ3BSPFace->iNumOfFaceVerts > 0 )
-        {
-            numFaces++;
-        }
-    }
-
-    return numFaces;
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Counts the number of triangles in a Q3-face-array.
-size_t Q3BSPFileImporter::countTriangles( const std::vector<Q3BSP::sQ3BSPFace*> &rArray ) const
-{
-    size_t numTriangles = 0;
-    for ( std::vector<Q3BSP::sQ3BSPFace*>::const_iterator it = rArray.begin(); it != rArray.end();
-        ++it )
-    {
-        const Q3BSP::sQ3BSPFace *pQ3BSPFace = *it;
-        if ( NULL != pQ3BSPFace )
-        {
-            numTriangles += pQ3BSPFace->iNumOfFaceVerts / 3;
-        }
-    }
-
-    return numTriangles;
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Creates the faces-to-material map.
-void Q3BSPFileImporter::createMaterialMap( const Q3BSP::Q3BSPModel *pModel ) {
-    std::string key( "" );
-    std::vector<sQ3BSPFace*> *pCurFaceArray = NULL;
-    for ( size_t idx = 0; idx < pModel->m_Faces.size(); idx++ )
-    {
-        Q3BSP::sQ3BSPFace *pQ3BSPFace = pModel->m_Faces[ idx ];
-        const int texId = pQ3BSPFace->iTextureID;
-        const int lightMapId = pQ3BSPFace->iLightmapID;
-        createKey( texId, lightMapId, key );
-        FaceMapIt it = m_MaterialLookupMap.find( key );
-        if ( m_MaterialLookupMap.end() == it ) {
-            pCurFaceArray = new std::vector<Q3BSP::sQ3BSPFace*>;
-            m_MaterialLookupMap[ key ] = pCurFaceArray;
-        }
-        else
-        {
-            pCurFaceArray = (*it).second;
-        }
-        ai_assert( nullptr != pCurFaceArray );
-        if (nullptr != pCurFaceArray )
-        {
-            pCurFaceArray->push_back( pQ3BSPFace );
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Returns the next face.
-aiFace *Q3BSPFileImporter::getNextFace( aiMesh *mesh, unsigned int &faceIdx ) {
-    aiFace *face( nullptr );
-    if ( faceIdx < mesh->mNumFaces ) {
-        face = &mesh->mFaces[ faceIdx ];
-        ++faceIdx;
-    }
-
-    return face;
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Imports a texture file.
-bool Q3BSPFileImporter::importTextureFromArchive( const Q3BSP::Q3BSPModel *model,
-                                                 ZipArchiveIOSystem *archive, aiScene*,
-                                                 aiMaterial *pMatHelper, int textureId ) {
-    if (nullptr == archive || nullptr == pMatHelper ) {
-        return false;
-    }
-
-    if ( textureId < 0 || textureId >= static_cast<int>( model->m_Textures.size() ) ) {
-        return false;
-    }
-
-    bool res = true;
-    sQ3BSPTexture *pTexture = model->m_Textures[ textureId ];
-    if ( !pTexture ) {
-        return false;
-    }
-
-    std::vector<std::string> supportedExtensions;
-    supportedExtensions.push_back( ".jpg" );
-    supportedExtensions.push_back( ".png" );
-    supportedExtensions.push_back( ".tga" );
-    std::string textureName, ext;
-    if ( expandFile( archive, pTexture->strName, supportedExtensions, textureName, ext ) ) {
-        IOStream *pTextureStream = archive->Open( textureName.c_str() );
-        if ( pTextureStream ) {
-            size_t texSize = pTextureStream->FileSize();
-            aiTexture *pTexture = new aiTexture;
-            pTexture->mHeight = 0;
-            pTexture->mWidth = static_cast<unsigned int>(texSize);
-            unsigned char *pData = new unsigned char[ pTexture->mWidth ];
-            size_t readSize = pTextureStream->Read( pData, sizeof( unsigned char ), pTexture->mWidth );
-            (void)readSize;
-            ai_assert( readSize == pTexture->mWidth );
-            pTexture->pcData = reinterpret_cast<aiTexel*>( pData );
-            pTexture->achFormatHint[ 0 ] = ext[ 1 ];
-            pTexture->achFormatHint[ 1 ] = ext[ 2 ];
-            pTexture->achFormatHint[ 2 ] = ext[ 3 ];
-            pTexture->achFormatHint[ 3 ] = '\0';
-            res = true;
-
-            aiString name;
-            name.data[ 0 ] = '*';
-            name.length = 1 + ASSIMP_itoa10( name.data + 1, static_cast<unsigned int>(MAXLEN-1), static_cast<int32_t>(mTextures.size()) );
-
-            archive->Close( pTextureStream );
-
-            pMatHelper->AddProperty( &name, AI_MATKEY_TEXTURE_DIFFUSE( 0 ) );
-            mTextures.push_back( pTexture );
-        } else {
-            // If it doesn't exist in the archive, it is probably just a reference to an external file.
-            // We'll leave it up to the user to figure out which extension the file has.
-            aiString name;
-            strncpy( name.data, pTexture->strName, sizeof name.data );
-            name.length = strlen( name.data );
-            pMatHelper->AddProperty( &name, AI_MATKEY_TEXTURE_DIFFUSE( 0 ) );
-        }
-    }
-
-    return res;
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Imports a light map file.
-bool Q3BSPFileImporter::importLightmap( const Q3BSP::Q3BSPModel *pModel, aiScene* pScene,
-                                       aiMaterial *pMatHelper, int lightmapId )
-{
-    if (nullptr == pModel || nullptr == pScene || nullptr == pMatHelper ) {
-        return false;
-    }
-
-    if ( lightmapId < 0 || lightmapId >= static_cast<int>( pModel->m_Lightmaps.size() ) ) {
-        return false;
-    }
-
-    sQ3BSPLightmap *pLightMap = pModel->m_Lightmaps[ lightmapId ];
-    if (nullptr == pLightMap ) {
-        return false;
-    }
-
-    aiTexture *pTexture = new aiTexture;
-
-    pTexture->mWidth = CE_BSP_LIGHTMAPWIDTH;
-    pTexture->mHeight = CE_BSP_LIGHTMAPHEIGHT;
-    pTexture->pcData = new aiTexel[CE_BSP_LIGHTMAPWIDTH * CE_BSP_LIGHTMAPHEIGHT];
-
-    ::memcpy( pTexture->pcData, pLightMap->bLMapData, pTexture->mWidth );
-    size_t p = 0;
-    for ( size_t i = 0; i < CE_BSP_LIGHTMAPWIDTH * CE_BSP_LIGHTMAPHEIGHT; ++i ) {
-        pTexture->pcData[ i ].r = pLightMap->bLMapData[ p++ ];
-        pTexture->pcData[ i ].g = pLightMap->bLMapData[ p++ ];
-        pTexture->pcData[ i ].b = pLightMap->bLMapData[ p++ ];
-        pTexture->pcData[ i ].a = 0xFF;
-    }
-
-    aiString name;
-    name.data[ 0 ] = '*';
-    name.length = 1 + ASSIMP_itoa10( name.data + 1, static_cast<unsigned int>(MAXLEN-1), static_cast<int32_t>(mTextures.size()) );
-
-    pMatHelper->AddProperty( &name,AI_MATKEY_TEXTURE_LIGHTMAP( 1 ) );
-    mTextures.push_back( pTexture );
-
-    return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Will search for a supported extension.
-bool Q3BSPFileImporter::expandFile(ZipArchiveIOSystem *pArchive, const std::string &rFilename,
-                                   const std::vector<std::string> &rExtList, std::string &rFile,
-                                   std::string &rExt )
-{
-    ai_assert( NULL != pArchive );
-    ai_assert( !rFilename.empty() );
-
-    if ( rExtList.empty() )
-    {
-        rFile =  rFilename;
-        rExt = "";
-        return true;
-    }
-
-    bool found = false;
-    for ( std::vector<std::string>::const_iterator it = rExtList.begin(); it != rExtList.end(); ++it )
-    {
-        const std::string textureName = rFilename + *it;
-        if ( pArchive->Exists( textureName.c_str() ) )
-        {
-            rExt = *it;
-            rFile = textureName;
-            found = true;
-            break;
-        }
-    }
-
-    return found;
-}
-
-// ------------------------------------------------------------------------------------------------
-
-} // Namespace Assimp
-
-#endif // ASSIMP_BUILD_NO_Q3BSP_IMPORTER
diff --git a/Engine/lib/assimp/code/Q3D/Q3DLoader.cpp b/Engine/lib/assimp/code/Q3D/Q3DLoader.cpp
deleted file mode 100644
index b8c8de716..000000000
--- a/Engine/lib/assimp/code/Q3D/Q3DLoader.cpp
+++ /dev/null
@@ -1,619 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-/** @file  Q3DLoader.cpp
- *  @brief Implementation of the Q3D importer class
- */
-
-
-#ifndef ASSIMP_BUILD_NO_Q3D_IMPORTER
-
-// internal headers
-#include "Q3DLoader.h"
-#include <assimp/StreamReader.h>
-#include <assimp/fast_atof.h>
-#include <assimp/IOSystem.hpp>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/scene.h>
-#include <assimp/importerdesc.h>
-
-using namespace Assimp;
-
-static const aiImporterDesc desc = {
-    "Quick3D Importer",
-    "",
-    "",
-    "http://www.quick3d.com/",
-    aiImporterFlags_SupportBinaryFlavour,
-    0,
-    0,
-    0,
-    0,
-    "q3o q3s"
-};
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-Q3DImporter::Q3DImporter()
-{}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-Q3DImporter::~Q3DImporter()
-{}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the class can handle the format of the given file.
-bool Q3DImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
-{
-    const std::string extension = GetExtension(pFile);
-
-    if (extension == "q3s" || extension == "q3o")
-        return true;
-    else if (!extension.length() || checkSig)   {
-        if (!pIOHandler)
-            return true;
-        const char* tokens[] = {"quick3Do","quick3Ds"};
-        return SearchFileHeaderForToken(pIOHandler,pFile,tokens,2);
-    }
-    return false;
-}
-
-// ------------------------------------------------------------------------------------------------
-const aiImporterDesc* Q3DImporter::GetInfo () const
-{
-    return &desc;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Imports the given file into the given scene structure.
-void Q3DImporter::InternReadFile( const std::string& pFile,
-    aiScene* pScene, IOSystem* pIOHandler)
-{
-    StreamReaderLE stream(pIOHandler->Open(pFile,"rb"));
-
-    // The header is 22 bytes large
-    if (stream.GetRemainingSize() < 22)
-        throw DeadlyImportError("File is either empty or corrupt: " + pFile);
-
-    // Check the file's signature
-    if (ASSIMP_strincmp( (const char*)stream.GetPtr(), "quick3Do", 8 ) &&
-        ASSIMP_strincmp( (const char*)stream.GetPtr(), "quick3Ds", 8 ))
-    {
-        throw DeadlyImportError("Not a Quick3D file. Signature string is: " +
-            std::string((const char*)stream.GetPtr(),8));
-    }
-
-    // Print the file format version
-    ASSIMP_LOG_INFO_F("Quick3D File format version: ",
-        std::string(&((const char*)stream.GetPtr())[8],2));
-
-    // ... an store it
-    char major = ((const char*)stream.GetPtr())[8];
-    char minor = ((const char*)stream.GetPtr())[9];
-
-    stream.IncPtr(10);
-    unsigned int numMeshes    = (unsigned int)stream.GetI4();
-    unsigned int numMats      = (unsigned int)stream.GetI4();
-    unsigned int numTextures  = (unsigned int)stream.GetI4();
-
-    std::vector<Material> materials;
-    materials.reserve(numMats);
-
-    std::vector<Mesh> meshes;
-    meshes.reserve(numMeshes);
-
-    // Allocate the scene root node
-    pScene->mRootNode = new aiNode();
-
-    aiColor3D fgColor (0.6f,0.6f,0.6f);
-
-    // Now read all file chunks
-    while (true)
-    {
-        if (stream.GetRemainingSize() < 1)break;
-        char c = stream.GetI1();
-        switch (c)
-        {
-            // Meshes chunk
-        case 'm':
-            {
-                for (unsigned int quak = 0; quak < numMeshes; ++quak)
-                {
-                    meshes.push_back(Mesh());
-                    Mesh& mesh = meshes.back();
-
-                    // read all vertices
-                    unsigned int numVerts = (unsigned int)stream.GetI4();
-                    if (!numVerts)
-                        throw DeadlyImportError("Quick3D: Found mesh with zero vertices");
-
-                    std::vector<aiVector3D>& verts = mesh.verts;
-                    verts.resize(numVerts);
-
-                    for (unsigned int i = 0; i < numVerts;++i)
-                    {
-                        verts[i].x = stream.GetF4();
-                        verts[i].y = stream.GetF4();
-                        verts[i].z = stream.GetF4();
-                    }
-
-                    // read all faces
-                    numVerts = (unsigned int)stream.GetI4();
-                    if (!numVerts)
-                        throw DeadlyImportError("Quick3D: Found mesh with zero faces");
-
-                    std::vector<Face >& faces = mesh.faces;
-                    faces.reserve(numVerts);
-
-                    // number of indices
-                    for (unsigned int i = 0; i < numVerts;++i)
-                    {
-                        faces.push_back(Face(stream.GetI2()) );
-                        if (faces.back().indices.empty())
-                            throw DeadlyImportError("Quick3D: Found face with zero indices");
-                    }
-
-                    // indices
-                    for (unsigned int i = 0; i < numVerts;++i)
-                    {
-                        Face& vec = faces[i];
-                        for (unsigned int a = 0; a < (unsigned int)vec.indices.size();++a)
-                            vec.indices[a] = stream.GetI4();
-                    }
-
-                    // material indices
-                    for (unsigned int i = 0; i < numVerts;++i)
-                    {
-                        faces[i].mat = (unsigned int)stream.GetI4();
-                    }
-
-                    // read all normals
-                    numVerts = (unsigned int)stream.GetI4();
-                    std::vector<aiVector3D>& normals = mesh.normals;
-                    normals.resize(numVerts);
-
-                    for (unsigned int i = 0; i < numVerts;++i)
-                    {
-                        normals[i].x = stream.GetF4();
-                        normals[i].y = stream.GetF4();
-                        normals[i].z = stream.GetF4();
-                    }
-
-                    numVerts = (unsigned int)stream.GetI4();
-                    if (numTextures && numVerts)
-                    {
-                        // read all texture coordinates
-                        std::vector<aiVector3D>& uv = mesh.uv;
-                        uv.resize(numVerts);
-
-                        for (unsigned int i = 0; i < numVerts;++i)
-                        {
-                            uv[i].x = stream.GetF4();
-                            uv[i].y = stream.GetF4();
-                        }
-
-                        // UV indices
-                        for (unsigned int i = 0; i < (unsigned int)faces.size();++i)
-                        {
-                            Face& vec = faces[i];
-                            for (unsigned int a = 0; a < (unsigned int)vec.indices.size();++a)
-                            {
-                                vec.uvindices[a] = stream.GetI4();
-                                if (!i && !a)
-                                    mesh.prevUVIdx = vec.uvindices[a];
-                                else if (vec.uvindices[a] != mesh.prevUVIdx)
-                                    mesh.prevUVIdx = UINT_MAX;
-                            }
-                        }
-                    }
-
-                    // we don't need the rest, but we need to get to the next chunk
-                    stream.IncPtr(36);
-                    if (minor > '0' && major == '3')
-                        stream.IncPtr(mesh.faces.size());
-                }
-                // stream.IncPtr(4); // unknown value here
-            }
-            break;
-
-            // materials chunk
-        case 'c':
-
-            for (unsigned int i = 0; i < numMats; ++i)
-            {
-                materials.push_back(Material());
-                Material& mat = materials.back();
-
-                // read the material name
-                while (( c = stream.GetI1()))
-                    mat.name.data[mat.name.length++] = c;
-
-                // add the terminal character
-                mat.name.data[mat.name.length] = '\0';
-
-                // read the ambient color
-                mat.ambient.r = stream.GetF4();
-                mat.ambient.g = stream.GetF4();
-                mat.ambient.b = stream.GetF4();
-
-                // read the diffuse color
-                mat.diffuse.r = stream.GetF4();
-                mat.diffuse.g = stream.GetF4();
-                mat.diffuse.b = stream.GetF4();
-
-                // read the ambient color
-                mat.specular.r = stream.GetF4();
-                mat.specular.g = stream.GetF4();
-                mat.specular.b = stream.GetF4();
-
-                // read the transparency
-                mat.transparency = stream.GetF4();
-
-                // unknown value here
-                // stream.IncPtr(4);
-                // FIX: it could be the texture index ...
-                mat.texIdx = (unsigned int)stream.GetI4();
-            }
-
-            break;
-
-            // texture chunk
-        case 't':
-
-            pScene->mNumTextures = numTextures;
-            if (!numTextures) {
-                break;
-            }
-            pScene->mTextures = new aiTexture*[pScene->mNumTextures];
-            // to make sure we won't crash if we leave through an exception
-            ::memset(pScene->mTextures,0,sizeof(void*)*pScene->mNumTextures);
-            for (unsigned int i = 0; i < pScene->mNumTextures; ++i) {
-                aiTexture* tex = pScene->mTextures[i] = new aiTexture;
-
-                // skip the texture name
-                while (stream.GetI1());
-
-                // read texture width and height
-                tex->mWidth  = (unsigned int)stream.GetI4();
-                tex->mHeight = (unsigned int)stream.GetI4();
-
-                if (!tex->mWidth || !tex->mHeight) {
-                    throw DeadlyImportError("Quick3D: Invalid texture. Width or height is zero");
-                }
-
-                unsigned int mul = tex->mWidth * tex->mHeight;
-                aiTexel* begin = tex->pcData = new aiTexel[mul];
-                aiTexel* const end = & begin[mul-1] +1;
-
-
-                for (;begin != end; ++begin) {
-                    begin->r = stream.GetI1();
-                    begin->g = stream.GetI1();
-                    begin->b = stream.GetI1();
-                    begin->a = 0xff;
-                }
-            }
-
-            break;
-
-            // scene chunk
-        case 's':
-            {
-                // skip position and rotation
-                stream.IncPtr(12);
-
-                for (unsigned int i = 0; i < 4;++i)
-                    for (unsigned int a = 0; a < 4;++a)
-                        pScene->mRootNode->mTransformation[i][a] = stream.GetF4();
-
-                stream.IncPtr(16);
-
-                // now setup a single camera
-                pScene->mNumCameras = 1;
-                pScene->mCameras = new aiCamera*[1];
-                aiCamera* cam = pScene->mCameras[0] = new aiCamera();
-                cam->mPosition.x = stream.GetF4();
-                cam->mPosition.y = stream.GetF4();
-                cam->mPosition.z = stream.GetF4();
-                cam->mName.Set("Q3DCamera");
-
-                // skip eye rotation for the moment
-                stream.IncPtr(12);
-
-                // read the default material color
-                fgColor .r = stream.GetF4();
-                fgColor .g = stream.GetF4();
-                fgColor .b = stream.GetF4();
-
-                // skip some unimportant properties
-                stream.IncPtr(29);
-
-                // setup a single point light with no attenuation
-                pScene->mNumLights = 1;
-                pScene->mLights = new aiLight*[1];
-                aiLight* light = pScene->mLights[0] = new aiLight();
-                light->mName.Set("Q3DLight");
-                light->mType = aiLightSource_POINT;
-
-                light->mAttenuationConstant  = 1;
-                light->mAttenuationLinear    = 0;
-                light->mAttenuationQuadratic = 0;
-
-                light->mColorDiffuse.r = stream.GetF4();
-                light->mColorDiffuse.g = stream.GetF4();
-                light->mColorDiffuse.b = stream.GetF4();
-
-                light->mColorSpecular = light->mColorDiffuse;
-
-
-                // We don't need the rest, but we need to know where this chunk ends.
-                unsigned int temp = (unsigned int)(stream.GetI4() * stream.GetI4());
-
-                // skip the background file name
-                while (stream.GetI1());
-
-                // skip background texture data + the remaining fields
-                stream.IncPtr(temp*3 + 20); // 4 bytes of unknown data here
-
-                // TODO
-                goto outer;
-            }
-            break;
-
-        default:
-            throw DeadlyImportError("Quick3D: Unknown chunk");
-            break;
-        };
-    }
-outer:
-
-    // If we have no mesh loaded - break here
-    if (meshes.empty())
-        throw DeadlyImportError("Quick3D: No meshes loaded");
-
-    // If we have no materials loaded - generate a default mat
-    if (materials.empty())
-    {
-        ASSIMP_LOG_INFO("Quick3D: No material found, generating one");
-        materials.push_back(Material());
-        materials.back().diffuse  = fgColor ;
-    }
-
-    // find out which materials we'll need
-    typedef std::pair<unsigned int, unsigned int> FaceIdx;
-    typedef std::vector< FaceIdx > FaceIdxArray;
-    FaceIdxArray* fidx = new FaceIdxArray[materials.size()];
-
-    unsigned int p = 0;
-    for (std::vector<Mesh>::iterator it = meshes.begin(), end = meshes.end();
-         it != end; ++it,++p)
-    {
-        unsigned int q = 0;
-        for (std::vector<Face>::iterator fit = (*it).faces.begin(), fend = (*it).faces.end();
-             fit != fend; ++fit,++q)
-        {
-            if ((*fit).mat >= materials.size())
-            {
-                ASSIMP_LOG_WARN("Quick3D: Material index overflow");
-                (*fit).mat = 0;
-            }
-            if (fidx[(*fit).mat].empty())++pScene->mNumMeshes;
-            fidx[(*fit).mat].push_back( FaceIdx(p,q) );
-        }
-    }
-    pScene->mNumMaterials = pScene->mNumMeshes;
-    pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials];
-    pScene->mMeshes = new aiMesh*[pScene->mNumMaterials];
-
-    for (unsigned int i = 0, real = 0; i < (unsigned int)materials.size(); ++i)
-    {
-        if (fidx[i].empty())continue;
-
-        // Allocate a mesh and a material
-        aiMesh* mesh = pScene->mMeshes[real] = new aiMesh();
-        aiMaterial* mat = new aiMaterial();
-        pScene->mMaterials[real] = mat;
-
-        mesh->mMaterialIndex = real;
-
-        // Build the output material
-        Material& srcMat = materials[i];
-        mat->AddProperty(&srcMat.diffuse,  1,AI_MATKEY_COLOR_DIFFUSE);
-        mat->AddProperty(&srcMat.specular, 1,AI_MATKEY_COLOR_SPECULAR);
-        mat->AddProperty(&srcMat.ambient,  1,AI_MATKEY_COLOR_AMBIENT);
-
-        // NOTE: Ignore transparency for the moment - it seems
-        // unclear how to interpret the data
-#if 0
-        if (!(minor > '0' && major == '3'))
-            srcMat.transparency = 1.0f - srcMat.transparency;
-        mat->AddProperty(&srcMat.transparency, 1, AI_MATKEY_OPACITY);
-#endif
-
-        // add shininess - Quick3D seems to use it ins its viewer
-        srcMat.transparency = 16.f;
-        mat->AddProperty(&srcMat.transparency, 1, AI_MATKEY_SHININESS);
-
-        int m = (int)aiShadingMode_Phong;
-        mat->AddProperty(&m, 1, AI_MATKEY_SHADING_MODEL);
-
-        if (srcMat.name.length)
-            mat->AddProperty(&srcMat.name,AI_MATKEY_NAME);
-
-        // Add a texture
-        if (srcMat.texIdx < pScene->mNumTextures || real < pScene->mNumTextures)
-        {
-            srcMat.name.data[0] = '*';
-            srcMat.name.length  = ASSIMP_itoa10(&srcMat.name.data[1],1000,
-                (srcMat.texIdx < pScene->mNumTextures ? srcMat.texIdx : real));
-            mat->AddProperty(&srcMat.name,AI_MATKEY_TEXTURE_DIFFUSE(0));
-        }
-
-        mesh->mNumFaces = (unsigned int)fidx[i].size();
-        aiFace* faces = mesh->mFaces = new aiFace[mesh->mNumFaces];
-
-        // Now build the output mesh. First find out how many
-        // vertices we'll need
-        for (FaceIdxArray::const_iterator it = fidx[i].begin(),end = fidx[i].end();
-             it != end; ++it)
-        {
-            mesh->mNumVertices += (unsigned int)meshes[(*it).first].faces[
-                (*it).second].indices.size();
-        }
-
-        aiVector3D* verts = mesh->mVertices = new aiVector3D[mesh->mNumVertices];
-        aiVector3D* norms = mesh->mNormals  = new aiVector3D[mesh->mNumVertices];
-        aiVector3D* uv;
-        if (real < pScene->mNumTextures)
-        {
-            uv = mesh->mTextureCoords[0] =  new aiVector3D[mesh->mNumVertices];
-            mesh->mNumUVComponents[0]    =  2;
-        }
-        else uv = NULL;
-
-        // Build the final array
-        unsigned int cnt = 0;
-        for (FaceIdxArray::const_iterator it = fidx[i].begin(),end = fidx[i].end();
-             it != end; ++it, ++faces)
-        {
-            Mesh& m    = meshes[(*it).first];
-            Face& face = m.faces[(*it).second];
-            faces->mNumIndices = (unsigned int)face.indices.size();
-            faces->mIndices = new unsigned int [faces->mNumIndices];
-
-
-            aiVector3D faceNormal;
-            bool fnOK = false;
-
-            for (unsigned int n = 0; n < faces->mNumIndices;++n, ++cnt, ++norms, ++verts)
-            {
-                if (face.indices[n] >= m.verts.size())
-                {
-                    ASSIMP_LOG_WARN("Quick3D: Vertex index overflow");
-                    face.indices[n] = 0;
-                }
-
-                // copy vertices
-                *verts =  m.verts[ face.indices[n] ];
-
-                if (face.indices[n] >= m.normals.size() && faces->mNumIndices >= 3)
-                {
-                    // we have no normal here - assign the face normal
-                    if (!fnOK)
-                    {
-                        const aiVector3D& pV1 =  m.verts[ face.indices[0] ];
-                        const aiVector3D& pV2 =  m.verts[ face.indices[1] ];
-                        const aiVector3D& pV3 =  m.verts[ face.indices.size() - 1 ];
-                        faceNormal = (pV2 - pV1) ^ (pV3 - pV1).Normalize();
-                        fnOK = true;
-                    }
-                    *norms = faceNormal;
-                }
-                else *norms =  m.normals[ face.indices[n] ];
-
-                // copy texture coordinates
-                if (uv && m.uv.size())
-                {
-                    if (m.prevUVIdx != 0xffffffff && m.uv.size() >= m.verts.size()) // workaround
-                    {
-                        *uv = m.uv[face.indices[n]];
-                    }
-                    else
-                    {
-                        if (face.uvindices[n] >= m.uv.size())
-                        {
-                            ASSIMP_LOG_WARN("Quick3D: Texture coordinate index overflow");
-                            face.uvindices[n] = 0;
-                        }
-                        *uv = m.uv[face.uvindices[n]];
-                    }
-                    uv->y = 1.f - uv->y;
-                    ++uv;
-                }
-
-                // setup the new vertex index
-                faces->mIndices[n] = cnt;
-            }
-
-        }
-        ++real;
-    }
-
-    // Delete our nice helper array
-    delete[] fidx;
-
-    // Now we need to attach the meshes to the root node of the scene
-    pScene->mRootNode->mNumMeshes = pScene->mNumMeshes;
-    pScene->mRootNode->mMeshes = new unsigned int [pScene->mNumMeshes];
-    for (unsigned int i = 0; i < pScene->mNumMeshes;++i)
-        pScene->mRootNode->mMeshes[i] = i;
-
-    /*pScene->mRootNode->mTransformation *= aiMatrix4x4(
-        1.f, 0.f, 0.f, 0.f,
-        0.f, -1.f,0.f, 0.f,
-        0.f, 0.f, 1.f, 0.f,
-        0.f, 0.f, 0.f, 1.f);*/
-
-    // Add cameras and light sources to the scene root node
-    pScene->mRootNode->mNumChildren = pScene->mNumLights+pScene->mNumCameras;
-    if (pScene->mRootNode->mNumChildren)
-    {
-        pScene->mRootNode->mChildren = new aiNode* [ pScene->mRootNode->mNumChildren ];
-
-        // the light source
-        aiNode* nd = pScene->mRootNode->mChildren[0] = new aiNode();
-        nd->mParent = pScene->mRootNode;
-        nd->mName.Set("Q3DLight");
-        nd->mTransformation = pScene->mRootNode->mTransformation;
-        nd->mTransformation.Inverse();
-
-        // camera
-        nd = pScene->mRootNode->mChildren[1] = new aiNode();
-        nd->mParent = pScene->mRootNode;
-        nd->mName.Set("Q3DCamera");
-        nd->mTransformation = pScene->mRootNode->mChildren[0]->mTransformation;
-    }
-}
-
-#endif // !! ASSIMP_BUILD_NO_Q3D_IMPORTER
diff --git a/Engine/lib/assimp/code/Step/STEPFile.h b/Engine/lib/assimp/code/Step/STEPFile.h
deleted file mode 100644
index d99b34b3c..000000000
--- a/Engine/lib/assimp/code/Step/STEPFile.h
+++ /dev/null
@@ -1,1016 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-#ifndef INCLUDED_AI_STEPFILE_H
-#define INCLUDED_AI_STEPFILE_H
-
-#include <bitset>
-#include <memory>
-#include <typeinfo>
-#include <vector>
-#include <map>
-#include <set>
-
-#include "FBX/FBXDocument.h" //ObjectMap::value_type
-
-#include <assimp/DefaultLogger.hpp>
-
-//
-#if _MSC_VER > 1500 || (defined __GNUC___)
-#   define ASSIMP_STEP_USE_UNORDERED_MULTIMAP
-#else
-#   define step_unordered_map map
-#   define step_unordered_multimap multimap
-#endif
-
-#ifdef ASSIMP_STEP_USE_UNORDERED_MULTIMAP
-#   include <unordered_map>
-#   if _MSC_VER > 1600
-#       define step_unordered_map unordered_map
-#       define step_unordered_multimap unordered_multimap
-#   else
-#       define step_unordered_map tr1::unordered_map
-#       define step_unordered_multimap tr1::unordered_multimap
-#   endif
-#endif
-
-#include <assimp/LineSplitter.h>
-
-// uncomment this to have the loader evaluate all entities upon loading.
-// this is intended as stress test - by default, entities are evaluated
-// lazily and therefore not unless needed.
-
-//#define ASSIMP_IFC_TEST
-
-namespace Assimp {
-
-// ********************************************************************************
-// before things get complicated, this is the basic outline:
-
-
-namespace STEP {
-
-    namespace EXPRESS {
-
-        // base data types known by EXPRESS schemata - any custom data types will derive one of those
-        class DataType;
-            class UNSET;        /*: public DataType */
-            class ISDERIVED;    /*: public DataType */
-        //  class REAL;         /*: public DataType */
-            class ENUM;         /*: public DataType */
-        //  class STRING;       /*: public DataType */
-        //  class INTEGER;      /*: public DataType */
-            class ENTITY;       /*: public DataType */
-            class LIST;         /*: public DataType */
-        //  class SELECT;       /*: public DataType */
-
-        // a conversion schema is not exactly an EXPRESS schema, rather it
-        // is a list of pointers to conversion functions to build up the
-        // object tree from an input file.
-        class ConversionSchema;
-    }
-
-    struct HeaderInfo;
-    class Object;
-    class LazyObject;
-    class DB;
-
-
-    typedef Object* (*ConvertObjectProc)(const DB& db, const EXPRESS::LIST& params);
-}
-
-// ********************************************************************************
-
-namespace STEP {
-
-    // -------------------------------------------------------------------------------
-    /** Exception class used by the STEP loading & parsing code. It is typically
-     *  coupled with a line number. */
-    // -------------------------------------------------------------------------------
-    struct SyntaxError : DeadlyImportError {
-        enum {
-            LINE_NOT_SPECIFIED = 0xffffffffffffffffLL
-        };
-
-        SyntaxError (const std::string& s,uint64_t line = LINE_NOT_SPECIFIED);
-    };
-
-
-    // -------------------------------------------------------------------------------
-    /** Exception class used by the STEP loading & parsing code when a type
-     *  error (i.e. an entity expects a string but receives a bool) occurs.
-     *  It is typically coupled with both an entity id and a line number.*/
-    // -------------------------------------------------------------------------------
-    struct TypeError : DeadlyImportError {
-        enum {
-            ENTITY_NOT_SPECIFIED = 0xffffffffffffffffLL,
-            ENTITY_NOT_SPECIFIED_32 = 0x00000000ffffffff
-        };
-
-        TypeError (const std::string& s,uint64_t entity = ENTITY_NOT_SPECIFIED, uint64_t line = SyntaxError::LINE_NOT_SPECIFIED);
-    };
-
-
-    // hack to make a given member template-dependent
-    template <typename T, typename T2>
-    T2& Couple(T2& in) {
-        return in;
-    }
-
-
-    namespace EXPRESS {
-
-        // -------------------------------------------------------------------------------
-        //** Base class for all STEP data types */
-        // -------------------------------------------------------------------------------
-        class DataType
-        {
-        public:
-            typedef std::shared_ptr<const DataType> Out;
-
-        public:
-
-            virtual ~DataType() {
-            }
-
-        public:
-
-            template <typename T>
-            const T& To() const {
-                return dynamic_cast<const T&>(*this);
-            }
-
-            template <typename T>
-            T& To() {
-                return dynamic_cast<T&>(*this);
-            }
-
-
-            template <typename T>
-            const T* ToPtr() const {
-                return dynamic_cast<const T*>(this);
-            }
-
-            template <typename T>
-            T* ToPtr() {
-                return dynamic_cast<T*>(this);
-            }
-
-            // utilities to deal with SELECT entities, which currently lack automatic
-            // conversion support.
-            template <typename T>
-            const T& ResolveSelect(const DB& db) const {
-                return Couple<T>(db).MustGetObject(To<EXPRESS::ENTITY>())->template To<T>();
-            }
-
-            template <typename T>
-            const T* ResolveSelectPtr(const DB& db) const {
-                const EXPRESS::ENTITY* e = ToPtr<EXPRESS::ENTITY>();
-                return e?Couple<T>(db).MustGetObject(*e)->template ToPtr<T>():(const T*)0;
-            }
-
-        public:
-
-            /** parse a variable from a string and set 'inout' to the character
-             *  behind the last consumed character. An optional schema enables,
-             *  if specified, automatic conversion of custom data types.
-             *
-             *  @throw SyntaxError
-             */
-            static std::shared_ptr<const EXPRESS::DataType> Parse(const char*& inout,
-                uint64_t line                           = SyntaxError::LINE_NOT_SPECIFIED,
-                const EXPRESS::ConversionSchema* schema = NULL);
-
-        public:
-        };
-
-        typedef DataType SELECT;
-        typedef DataType LOGICAL;
-
-        // -------------------------------------------------------------------------------
-        /** Sentinel class to represent explicitly unset (optional) fields ($) */
-        // -------------------------------------------------------------------------------
-        class UNSET : public DataType
-        {
-        public:
-        private:
-        };
-
-        // -------------------------------------------------------------------------------
-        /** Sentinel class to represent explicitly derived fields (*) */
-        // -------------------------------------------------------------------------------
-        class ISDERIVED : public DataType
-        {
-        public:
-        private:
-        };
-
-        // -------------------------------------------------------------------------------
-        /** Shared implementation for some of the primitive data type, i.e. int, float */
-        // -------------------------------------------------------------------------------
-        template <typename T>
-        class PrimitiveDataType : public DataType
-        {
-        public:
-
-            // This is the type that will cd ultimatively be used to
-            // expose this data type to the user.
-            typedef T Out;
-
-        public:
-
-            PrimitiveDataType() {}
-            PrimitiveDataType(const T& val)
-                : val(val)
-            {}
-
-            PrimitiveDataType(const PrimitiveDataType& o) {
-                (*this) = o;
-            }
-
-
-        public:
-
-            operator const T& () const {
-                return val;
-            }
-
-            PrimitiveDataType& operator=(const PrimitiveDataType& o) {
-                val = o.val;
-                return *this;
-            }
-
-        protected:
-            T val;
-
-        };
-
-        typedef PrimitiveDataType<int64_t>          INTEGER;
-        typedef PrimitiveDataType<double>           REAL;
-        typedef PrimitiveDataType<double>           NUMBER;
-        typedef PrimitiveDataType<std::string>      STRING;
-
-
-
-        // -------------------------------------------------------------------------------
-        /** Generic base class for all enumerated types */
-        // -------------------------------------------------------------------------------
-        class ENUMERATION : public STRING
-        {
-        public:
-
-            ENUMERATION (const std::string& val)
-                : STRING(val)
-            {}
-
-        private:
-        };
-
-        typedef ENUMERATION BOOLEAN;
-
-        // -------------------------------------------------------------------------------
-        /** This is just a reference to an entity/object somewhere else */
-        // -------------------------------------------------------------------------------
-        class ENTITY : public PrimitiveDataType<uint64_t>
-        {
-        public:
-
-            ENTITY(uint64_t val)
-                : PrimitiveDataType<uint64_t>(val)
-            {
-                ai_assert(val!=0);
-            }
-
-            ENTITY()
-                : PrimitiveDataType<uint64_t>(TypeError::ENTITY_NOT_SPECIFIED)
-            {
-            }
-
-        private:
-        };
-
-        // -------------------------------------------------------------------------------
-        /** Wrap any STEP aggregate: LIST, SET, ... */
-        // -------------------------------------------------------------------------------
-        class LIST : public DataType
-        {
-        public:
-
-            // access a particular list index, throw std::range_error for wrong indices
-            std::shared_ptr<const DataType> operator[] (size_t index) const {
-                return members[index];
-            }
-
-            size_t GetSize() const {
-                return members.size();
-            }
-
-        public:
-
-            /** @see DaraType::Parse */
-            static std::shared_ptr<const EXPRESS::LIST> Parse(const char*& inout,
-                uint64_t line                           = SyntaxError::LINE_NOT_SPECIFIED,
-                const EXPRESS::ConversionSchema* schema = NULL);
-
-
-        private:
-            typedef std::vector< std::shared_ptr<const DataType> > MemberList;
-            MemberList members;
-        };
-
-        class BINARY : public PrimitiveDataType<uint32_t> {
-        public:
-            BINARY(uint32_t val)
-            : PrimitiveDataType<uint32_t>(val) {
-                // empty
-            }
-
-            BINARY()
-            : PrimitiveDataType<uint32_t>(TypeError::ENTITY_NOT_SPECIFIED_32) {
-                // empty
-            }
-        };
-
-        // -------------------------------------------------------------------------------
-        /* Not exactly a full EXPRESS schema but rather a list of conversion functions
-         * to extract valid C++ objects out of a STEP file. Those conversion functions
-         * may, however, perform further schema validations. */
-        // -------------------------------------------------------------------------------
-        class ConversionSchema {
-        public:
-            struct SchemaEntry {
-                SchemaEntry( const char *name, ConvertObjectProc func )
-                : mName( name )
-                , mFunc(func) {
-                    // empty
-                }
-
-                const char* mName;
-                ConvertObjectProc mFunc;
-            };
-
-            typedef std::map<std::string,ConvertObjectProc> ConverterMap;
-
-            template <size_t N>
-            explicit ConversionSchema( const SchemaEntry (& schemas)[N]) {
-                *this = schemas;
-            }
-
-            ConversionSchema() {
-
-            }
-
-            ConvertObjectProc GetConverterProc(const std::string& name) const {
-                ConverterMap::const_iterator it = converters.find(name);
-                return it == converters.end() ? nullptr : (*it).second;
-            }
-
-            bool IsKnownToken(const std::string& name) const {
-                return converters.find(name) != converters.end();
-            }
-
-            const char* GetStaticStringForToken(const std::string& token) const {
-                ConverterMap::const_iterator it = converters.find(token);
-                return it == converters.end() ? nullptr : (*it).first.c_str();
-            }
-
-
-            template <size_t N>
-            const ConversionSchema& operator=( const SchemaEntry (& schemas)[N]) {
-                for(size_t i = 0; i < N; ++i ) {
-                    const SchemaEntry& schema = schemas[i];
-                    converters[schema.mName] = schema.mFunc;
-                }
-                return *this;
-            }
-
-        private:
-            ConverterMap converters;
-        };
-    }
-
-
-
-    // ------------------------------------------------------------------------------
-    /** Bundle all the relevant info from a STEP header, parts of which may later
-     *  be plainly dumped to the logfile, whereas others may help the caller pick an
-     *  appropriate loading strategy.*/
-    // ------------------------------------------------------------------------------
-    struct HeaderInfo
-    {
-        std::string timestamp;
-        std::string app;
-        std::string fileSchema;
-    };
-
-
-    // ------------------------------------------------------------------------------
-    /** Base class for all concrete object instances */
-    // ------------------------------------------------------------------------------
-    class Object {
-    public:
-        Object(const char* classname = "unknown")
-        : id( 0 )
-        , classname(classname) {
-            // empty
-        }
-
-        virtual ~Object() {
-            // empty
-        }
-
-        // utilities to simplify casting to concrete types
-        template <typename T>
-        const T& To() const {
-            return dynamic_cast<const T&>(*this);
-        }
-
-        template <typename T>
-        T& To() {
-            return dynamic_cast<T&>(*this);
-        }
-
-        template <typename T>
-        const T* ToPtr() const {
-            return dynamic_cast<const T*>(this);
-        }
-
-        template <typename T>
-        T* ToPtr() {
-            return dynamic_cast<T*>(this);
-        }
-
-        uint64_t GetID() const {
-            return id;
-        }
-
-        std::string GetClassName() const {
-            return classname;
-        }
-
-        void SetID(uint64_t newval) {
-            id = newval;
-        }
-
-    private:
-        uint64_t id;
-        const char* const classname;
-    };
-
-    template <typename T>
-    size_t GenericFill(const STEP::DB& db, const EXPRESS::LIST& params, T* in);
-    // (intentionally undefined)
-
-
-    // ------------------------------------------------------------------------------
-    /** CRTP shared base class for use by concrete entity implementation classes */
-    // ------------------------------------------------------------------------------
-    template <typename TDerived, size_t arg_count>
-    struct ObjectHelper : virtual Object {
-        ObjectHelper()
-        : aux_is_derived(0) {
-            // empty
-        }
-
-        static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) {
-            // make sure we don't leak if Fill() throws an exception
-            std::unique_ptr<TDerived> impl(new TDerived());
-
-            // GenericFill<T> is undefined so we need to have a specialization
-            const size_t num_args = GenericFill<TDerived>(db,params,&*impl);
-            (void)num_args;
-
-            // the following check is commented because it will always trigger if
-            // parts of the entities are generated with dummy wrapper code.
-            // This is currently done to reduce the size of the loader
-            // code.
-            //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") {
-            //  DefaultLogger::get()->debug("STEP: not all parameters consumed");
-            //}
-            return impl.release();
-        }
-
-        // note that this member always exists multiple times within the hierarchy
-        // of an individual object, so any access to it must be disambiguated.
-        std::bitset<arg_count> aux_is_derived;
-    };
-
-    // ------------------------------------------------------------------------------
-    /** Class template used to represent OPTIONAL data members in the converted schema */
-    // ------------------------------------------------------------------------------
-    template <typename T>
-    struct Maybe {
-        Maybe()
-        : have() {
-            // empty
-        }
-
-        explicit Maybe(const T& ptr)
-        : ptr(ptr)
-        , have(true) {
-            // empty
-        }
-
-
-        void flag_invalid() {
-            have = false;
-        }
-
-        void flag_valid() {
-            have = true;
-        }
-
-
-        bool operator! () const {
-            return !have;
-        }
-
-        operator bool() const {
-            return have;
-        }
-
-        operator const T&() const {
-            return Get();
-        }
-
-        const T& Get() const {
-            ai_assert(have);
-            return ptr;
-        }
-
-        Maybe& operator=(const T& _ptr) {
-            ptr = _ptr;
-            have = true;
-            return *this;
-        }
-
-    private:
-        template <typename T2> friend struct InternGenericConvert;
-
-        operator T&() {
-            return ptr;
-        }
-
-        T ptr;
-        bool have;
-    };
-
-    // ------------------------------------------------------------------------------
-    /** A LazyObject is created when needed. Before this happens, we just keep
-       the text line that contains the object definition. */
-    // -------------------------------------------------------------------------------
-    class LazyObject {
-        friend class DB;
-
-    public:
-        LazyObject(DB& db, uint64_t id, uint64_t line, const char* type,const char* args);
-        ~LazyObject();
-
-        Object& operator * () {
-            if (!obj) {
-                LazyInit();
-                ai_assert(obj);
-            }
-            return *obj;
-        }
-
-        const Object& operator * () const {
-            if (!obj) {
-                LazyInit();
-                ai_assert(obj);
-            }
-            return *obj;
-        }
-
-        template <typename T>
-        const T& To() const {
-            return dynamic_cast<const T&>( **this );
-        }
-
-        template <typename T>
-        T& To()  {
-            return dynamic_cast<T&>( **this );
-        }
-
-        template <typename T>
-        const T* ToPtr() const {
-            return dynamic_cast<const T*>( &**this );
-        }
-
-        template <typename T>
-        T* ToPtr()  {
-            return dynamic_cast<T*>( &**this );
-        }
-
-        Object* operator -> () {
-            return &**this;
-        }
-
-        const Object* operator -> () const {
-            return &**this;
-        }
-
-        bool operator== (const std::string& atype) const {
-            return type == atype;
-        }
-
-        bool operator!= (const std::string& atype) const {
-            return type != atype;
-        }
-
-        uint64_t GetID() const {
-            return id;
-        }
-
-    private:
-        void LazyInit() const;
-
-    private:
-        mutable uint64_t id;
-        const char* const type;
-        DB& db;
-        mutable const char* args;
-        mutable Object* obj;
-    };
-
-    template <typename T>
-    inline
-    bool operator==( std::shared_ptr<LazyObject> lo, T whatever ) {
-        return *lo == whatever; // XXX use std::forward if we have 0x
-    }
-
-    template <typename T>
-    inline
-    bool operator==( const std::pair<uint64_t, std::shared_ptr<LazyObject> >& lo, T whatever ) {
-        return *(lo.second) == whatever; // XXX use std::forward if we have 0x
-    }
-
-    // ------------------------------------------------------------------------------
-    /** Class template used to represent lazily evaluated object references in the converted schema */
-    // ------------------------------------------------------------------------------
-    template <typename T>
-    struct Lazy {
-        typedef Lazy Out;
-        Lazy(const LazyObject* obj = nullptr)
-        : obj(obj) {
-            // empty
-        }
-
-        operator const T*() const {
-            return obj->ToPtr<T>();
-        }
-
-        operator const T&() const {
-            return obj->To<T>();
-        }
-
-        const T& operator * () const {
-            return obj->To<T>();
-        }
-
-        const T* operator -> () const {
-            return &obj->To<T>();
-        }
-
-        const LazyObject* obj;
-    };
-
-    // ------------------------------------------------------------------------------
-    /** Class template used to represent LIST and SET data members in the converted schema */
-    // ------------------------------------------------------------------------------
-    template <typename T, uint64_t min_cnt, uint64_t max_cnt=0uL>
-    struct ListOf : public std::vector<typename T::Out> {
-        typedef typename T::Out OutScalar;
-        typedef ListOf Out;
-
-        ListOf() {
-            static_assert(min_cnt <= max_cnt || !max_cnt, "min_cnt <= max_cnt || !max_cnt");
-        }
-    };
-
-    // ------------------------------------------------------------------------------
-    template <typename TOut>
-    struct PickBaseType {
-        typedef EXPRESS::PrimitiveDataType<TOut> Type;
-    };
-
-    template <typename TOut>
-    struct PickBaseType< Lazy<TOut> > {
-        typedef EXPRESS::ENTITY Type;
-    };
-
-    template<>
-    struct PickBaseType< std::shared_ptr< const EXPRESS::DataType > >;
-
-    // ------------------------------------------------------------------------------
-    template <typename T>
-    struct InternGenericConvert {
-        void operator()(T& out, const std::shared_ptr< const EXPRESS::DataType >& in, const STEP::DB& /*db*/) {
-            try{
-                out = dynamic_cast< const typename PickBaseType<T>::Type& > ( *in );
-            } catch(std::bad_cast&) {
-                throw TypeError("type error reading literal field");
-            }
-        }
-    };
-
-    template <>
-    struct InternGenericConvert< std::shared_ptr< const EXPRESS::DataType > > {
-        void operator()(std::shared_ptr< const EXPRESS::DataType >& out, const std::shared_ptr< const EXPRESS::DataType >& in, const STEP::DB& /*db*/) {
-            out = in;
-        }
-    };
-
-    template <typename T>
-    struct InternGenericConvert< Maybe<T> > {
-        void operator()(Maybe<T>& out, const std::shared_ptr< const EXPRESS::DataType >& in, const STEP::DB& db) {
-            GenericConvert((T&)out,in,db);
-            out.flag_valid();
-        }
-    };
-
-    template <typename T,uint64_t min_cnt, uint64_t max_cnt>
-    struct InternGenericConvertList {
-        void operator()(ListOf<T, min_cnt, max_cnt>& out, const std::shared_ptr< const EXPRESS::DataType >& inp_base, const STEP::DB& db) {
-
-            const EXPRESS::LIST* inp = dynamic_cast<const EXPRESS::LIST*>(inp_base.get());
-            if (!inp) {
-                throw TypeError("type error reading aggregate");
-            }
-
-            // XXX is this really how the EXPRESS notation ([?:3],[1:3]) is intended?
-            if (max_cnt && inp->GetSize() > max_cnt) {
-                ASSIMP_LOG_WARN("too many aggregate elements");
-            }
-            else if (inp->GetSize() < min_cnt) {
-                ASSIMP_LOG_WARN("too few aggregate elements");
-            }
-
-            out.reserve(inp->GetSize());
-            for(size_t i = 0; i < inp->GetSize(); ++i) {
-
-                out.push_back( typename ListOf<T, min_cnt, max_cnt>::OutScalar() );
-                try{
-                    GenericConvert(out.back(),(*inp)[i], db);
-                }
-                catch(const TypeError& t) {
-                    throw TypeError(t.what() +std::string(" of aggregate"));
-                }
-            }
-        }
-    };
-
-    template <typename T>
-    struct InternGenericConvert< Lazy<T> > {
-        void operator()(Lazy<T>& out, const std::shared_ptr< const EXPRESS::DataType >& in_base, const STEP::DB& db) {
-            const EXPRESS::ENTITY* in = dynamic_cast<const EXPRESS::ENTITY*>(in_base.get());
-            if (!in) {
-                throw TypeError("type error reading entity");
-            }
-            out = Couple<T>(db).GetObject(*in);
-        }
-    };
-
-    template <typename T1>
-    inline void GenericConvert(T1& a, const std::shared_ptr< const EXPRESS::DataType >& b, const STEP::DB& db) {
-        return InternGenericConvert<T1>()(a,b,db);
-    }
-
-    template <typename T1,uint64_t N1, uint64_t N2>
-    inline void GenericConvert(ListOf<T1,N1,N2>& a, const std::shared_ptr< const EXPRESS::DataType >& b, const STEP::DB& db) {
-        return InternGenericConvertList<T1,N1,N2>()(a,b,db);
-    }
-
-    // ------------------------------------------------------------------------------
-    /** Lightweight manager class that holds the map of all objects in a
-     *  STEP file. DB's are exclusively maintained by the functions in
-     *  STEPFileReader.h*/
-    // -------------------------------------------------------------------------------
-    class DB
-    {
-        friend DB* ReadFileHeader(std::shared_ptr<IOStream> stream);
-        friend void ReadFile(DB& db,const EXPRESS::ConversionSchema& scheme,
-            const char* const* types_to_track, size_t len,
-            const char* const* inverse_indices_to_track, size_t len2
-        );
-
-        friend class LazyObject;
-
-    public:
-        // objects indexed by ID - this can grow pretty large (i.e some hundred million
-        // entries), so use raw pointers to avoid *any* overhead.
-        typedef std::map<uint64_t,const LazyObject* > ObjectMap;
-
-        // objects indexed by their declarative type, but only for those that we truly want
-        typedef std::set< const LazyObject*> ObjectSet;
-        typedef std::map<std::string, ObjectSet > ObjectMapByType;
-
-        // list of types for which to keep inverse indices for all references
-        // that the respective objects keep.
-        // the list keeps pointers to strings in static storage
-        typedef std::set<const char*> InverseWhitelist;
-
-        // references - for each object id the ids of all objects which reference it
-        // this is used to simulate STEP inverse indices for selected types.
-        typedef std::step_unordered_multimap<uint64_t, uint64_t > RefMap;
-        typedef std::pair<RefMap::const_iterator,RefMap::const_iterator> RefMapRange;
-
-    private:
-
-        DB(std::shared_ptr<StreamReaderLE> reader)
-            : reader(reader)
-            , splitter(*reader,true,true)
-            , evaluated_count()
-            , schema( nullptr )
-        {}
-
-    public:
-        ~DB() {
-            for(ObjectMap::value_type& o : objects) {
-                delete o.second;
-            }
-        }
-
-        uint64_t GetObjectCount() const {
-            return objects.size();
-        }
-
-        uint64_t GetEvaluatedObjectCount() const {
-            return evaluated_count;
-        }
-
-        const HeaderInfo& GetHeader() const {
-            return header;
-        }
-
-        const EXPRESS::ConversionSchema& GetSchema() const {
-            return *schema;
-        }
-
-        const ObjectMap& GetObjects() const {
-            return objects;
-        }
-
-        const ObjectMapByType& GetObjectsByType() const {
-            return objects_bytype;
-        }
-
-        const RefMap& GetRefs() const {
-            return refs;
-        }
-
-        bool KeepInverseIndicesForType(const char* const type) const {
-            return inv_whitelist.find(type) != inv_whitelist.end();
-        }
-
-
-        // get the yet unevaluated object record with a given id
-        const LazyObject* GetObject(uint64_t id) const {
-            const ObjectMap::const_iterator it = objects.find(id);
-            if (it != objects.end()) {
-                return (*it).second;
-            }
-            return nullptr;
-        }
-
-
-        // get an arbitrary object out of the soup with the only restriction being its type.
-        const LazyObject* GetObject(const std::string& type) const {
-            const ObjectMapByType::const_iterator it = objects_bytype.find(type);
-            if (it != objects_bytype.end() && (*it).second.size()) {
-                return *(*it).second.begin();
-            }
-            return NULL;
-        }
-
-        // same, but raise an exception if the object doesn't exist and return a reference
-        const LazyObject& MustGetObject(uint64_t id) const {
-            const LazyObject* o = GetObject(id);
-            if (!o) {
-                throw TypeError("requested entity is not present",id);
-            }
-            return *o;
-        }
-
-        const LazyObject& MustGetObject(const std::string& type) const {
-            const LazyObject* o = GetObject(type);
-            if (!o) {
-                throw TypeError("requested entity of type "+type+"is not present");
-            }
-            return *o;
-        }
-
-
-#ifdef ASSIMP_IFC_TEST
-
-        // evaluate *all* entities in the file. this is a power test for the loader
-        void EvaluateAll() {
-            for(ObjectMap::value_type& e :objects) {
-                **e.second;
-            }
-            ai_assert(evaluated_count == objects.size());
-        }
-
-#endif
-
-    private:
-
-        // full access only offered to close friends - they should
-        // use the provided getters rather than messing around with
-        // the members directly.
-        LineSplitter& GetSplitter() {
-            return splitter;
-        }
-
-        void InternInsert(const LazyObject* lz) {
-            objects[lz->GetID()] = lz;
-
-            const ObjectMapByType::iterator it = objects_bytype.find( lz->type );
-            if (it != objects_bytype.end()) {
-                (*it).second.insert(lz);
-            }
-        }
-
-        void SetSchema(const EXPRESS::ConversionSchema& _schema) {
-            schema = &_schema;
-        }
-
-
-        void SetTypesToTrack(const char* const* types, size_t N) {
-            for(size_t i = 0; i < N;++i) {
-                objects_bytype[types[i]] = ObjectSet();
-            }
-        }
-
-        void SetInverseIndicesToTrack( const char* const* types, size_t N ) {
-            for(size_t i = 0; i < N;++i) {
-                const char* const sz = schema->GetStaticStringForToken(types[i]);
-                ai_assert(sz);
-                inv_whitelist.insert(sz);
-            }
-        }
-
-        HeaderInfo& GetHeader() {
-            return header;
-        }
-
-        void MarkRef(uint64_t who, uint64_t by_whom) {
-            refs.insert(std::make_pair(who,by_whom));
-        }
-
-    private:
-        HeaderInfo header;
-        ObjectMap objects;
-        ObjectMapByType objects_bytype;
-        RefMap refs;
-        InverseWhitelist inv_whitelist;
-        std::shared_ptr<StreamReaderLE> reader;
-        LineSplitter splitter;
-        uint64_t evaluated_count;
-        const EXPRESS::ConversionSchema* schema;
-    };
-
-}
-
-} // end Assimp
-
-#endif // INCLUDED_AI_STEPFILE_H
diff --git a/Engine/lib/assimp/code/X3D/FIReader.cpp b/Engine/lib/assimp/code/X3D/FIReader.cpp
deleted file mode 100644
index 9bb2c69f6..000000000
--- a/Engine/lib/assimp/code/X3D/FIReader.cpp
+++ /dev/null
@@ -1,1838 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-/// \file   FIReader.cpp
-/// \brief  Reader for Fast Infoset encoded binary XML files.
-/// \date   2017
-/// \author Patrick Daehne
-
-#ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
-
-#include "FIReader.hpp"
-#include <assimp/StringUtils.h>
-
-// Workaround for issue #1361
-// https://github.com/assimp/assimp/issues/1361
-#ifdef __ANDROID__
-#  define _GLIBCXX_USE_C99 1
-#endif
-
-#include <assimp/Exceptional.h>
-#include <assimp/IOStream.hpp>
-#include <assimp/types.h>
-#include <assimp/MemoryIOWrapper.h>
-#include <assimp/irrXMLWrapper.h>
-#ifdef ASSIMP_USE_HUNTER
-#  include <utf8/utf8.h>
-#else
-#  include "../contrib/utf8cpp/source/utf8.h"
-#endif
-#include <assimp/fast_atof.h>
-#include <stack>
-#include <map>
-#include <iostream>
-#include <sstream>
-#include <iomanip>
-
-namespace Assimp {
-
-static const std::string parseErrorMessage = "Fast Infoset parse error";
-
-static const char *xmlDeclarations[] = {
-    "<?xml encoding='finf'?>",
-    "<?xml encoding='finf' standalone='yes'?>",
-    "<?xml encoding='finf' standalone='no'?>",
-    "<?xml version='1.0' encoding='finf'?>",
-    "<?xml version='1.0' encoding='finf' standalone='yes'?>",
-    "<?xml version='1.0' encoding='finf' standalone='no'?>",
-    "<?xml version='1.1' encoding='finf'?>",
-    "<?xml version='1.1' encoding='finf' standalone='yes'?>",
-    "<?xml version='1.1' encoding='finf' standalone='no'?>"
-};
-
-static size_t parseMagic(const uint8_t *data, const uint8_t *dataEnd) {
-    if (dataEnd - data < 4) {
-        return 0;
-    }
-    uint32_t magic = (data[0] << 24) | (data[1] << 16) | (data[2] << 8) | data[3];
-    switch (magic) {
-    case 0xe0000001:
-        return 4;
-    case 0x3c3f786d: // "<?xm"
-        {
-            size_t xmlDeclarationsLength = sizeof(xmlDeclarations) / sizeof(xmlDeclarations[0]);
-            for (size_t i = 0; i < xmlDeclarationsLength; ++i) {
-                auto xmlDeclaration = xmlDeclarations[i];
-                ptrdiff_t xmlDeclarationLength = strlen(xmlDeclaration);
-                if ((dataEnd - data >= xmlDeclarationLength) && (memcmp(xmlDeclaration, data, xmlDeclarationLength) == 0)) {
-                    data += xmlDeclarationLength;
-                    if (dataEnd - data < 4) {
-                        return 0;
-                    }
-                    magic = (data[0] << 24) | (data[1] << 16) | (data[2] << 8) | data[3];
-                    return magic == 0xe0000001 ? xmlDeclarationLength + 4 : 0;
-                }
-            }
-            return 0;
-        }
-    default:
-        return 0;
-    }
-}
-
-static std::string parseUTF8String(const uint8_t *data, size_t len) {
-    return std::string((char*)data, len);
-}
-
-static std::string parseUTF16String(const uint8_t *data, size_t len) {
-    if (len & 1) {
-        throw DeadlyImportError(parseErrorMessage);
-    }
-    size_t numShorts = len / 2;
-    std::vector<short> utf16;
-    utf16.reserve(numShorts);
-    for (size_t i = 0; i < numShorts; ++i) {
-        short v = (data[0] << 8) | data[1];
-        utf16.push_back(v);
-        data += 2;
-    }
-    std::string result;
-    utf8::utf16to8(utf16.begin(), utf16.end(), back_inserter(result));
-    return result;
-}
-
-struct FIStringValueImpl: public FIStringValue {
-    inline FIStringValueImpl(std::string &&value_) { value = std::move(value_); }
-    virtual const std::string &toString() const /*override*/ { return value; }
-};
-
-std::shared_ptr<FIStringValue> FIStringValue::create(std::string &&value) {
-    return std::make_shared<FIStringValueImpl>(std::move(value));
-}
-
-struct FIHexValueImpl: public FIHexValue {
-    mutable std::string strValue;
-    mutable bool strValueValid;
-    inline FIHexValueImpl(std::vector<uint8_t> &&value_):  strValueValid(false) { value = std::move(value_); }
-    virtual const std::string &toString() const /*override*/ {
-        if (!strValueValid) {
-            strValueValid = true;
-            std::ostringstream os;
-            os << std::hex << std::uppercase << std::setfill('0');
-            std::for_each(value.begin(), value.end(), [&](uint8_t c) { os << std::setw(2) << static_cast<int>(c); });
-            strValue = os.str();
-        }
-        return strValue;
-    };
-};
-
-std::shared_ptr<FIHexValue> FIHexValue::create(std::vector<uint8_t> &&value) {
-    return std::make_shared<FIHexValueImpl>(std::move(value));
-}
-
-struct FIBase64ValueImpl: public FIBase64Value {
-    mutable std::string strValue;
-    mutable bool strValueValid;
-    inline FIBase64ValueImpl(std::vector<uint8_t> &&value_): strValueValid(false) { value = std::move(value_); }
-    virtual const std::string &toString() const /*override*/ {
-        if (!strValueValid) {
-            strValueValid = true;
-            std::ostringstream os;
-            uint8_t c1 = 0, c2;
-            int imod3 = 0;
-            std::vector<uint8_t>::size_type valueSize = value.size();
-            for (std::vector<uint8_t>::size_type i = 0; i < valueSize; ++i) {
-                c2 = value[i];
-                switch (imod3) {
-                case 0:
-                    os << basis_64[c2 >> 2];
-                    imod3 = 1;
-                    break;
-                case 1:
-                    os << basis_64[((c1 & 0x03) << 4) | ((c2 & 0xf0) >> 4)];
-                    imod3 = 2;
-                    break;
-                case 2:
-                    os << basis_64[((c1 & 0x0f) << 2) | ((c2 & 0xc0) >> 6)] << basis_64[c2 & 0x3f];
-                    imod3 = 0;
-                    break;
-                }
-                c1 = c2;
-            }
-            switch (imod3) {
-            case 1:
-                os << basis_64[(c1 & 0x03) << 4] << "==";
-                break;
-            case 2:
-                os << basis_64[(c1 & 0x0f) << 2] << '=';
-                break;
-            }
-            strValue = os.str();
-        }
-        return strValue;
-    };
-    static const char basis_64[];
-};
-
-const char FIBase64ValueImpl::basis_64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
-std::shared_ptr<FIBase64Value> FIBase64Value::create(std::vector<uint8_t> &&value) {
-    return std::make_shared<FIBase64ValueImpl>(std::move(value));
-}
-
-struct FIShortValueImpl: public FIShortValue {
-    mutable std::string strValue;
-    mutable bool strValueValid;
-    inline FIShortValueImpl(std::vector<int16_t> &&value_): strValueValid(false) { value = std::move(value_); }
-    virtual const std::string &toString() const /*override*/ {
-        if (!strValueValid) {
-            strValueValid = true;
-            std::ostringstream os;
-            int n = 0;
-            std::for_each(value.begin(), value.end(), [&](int16_t s) { if (++n > 1) os << ' '; os << s; });
-            strValue = os.str();
-        }
-        return strValue;
-    }
-};
-
-std::shared_ptr<FIShortValue> FIShortValue::create(std::vector<int16_t> &&value) {
-    return std::make_shared<FIShortValueImpl>(std::move(value));
-}
-
-struct FIIntValueImpl: public FIIntValue {
-    mutable std::string strValue;
-    mutable bool strValueValid;
-    inline FIIntValueImpl(std::vector<int32_t> &&value_): strValueValid(false) { value = std::move(value_); }
-    virtual const std::string &toString() const /*override*/ {
-        if (!strValueValid) {
-            strValueValid = true;
-            std::ostringstream os;
-            int n = 0;
-            std::for_each(value.begin(), value.end(), [&](int32_t i) { if (++n > 1) os << ' '; os << i; });
-            strValue = os.str();
-        }
-        return strValue;
-    };
-};
-
-std::shared_ptr<FIIntValue> FIIntValue::create(std::vector<int32_t> &&value) {
-    return std::make_shared<FIIntValueImpl>(std::move(value));
-}
-
-struct FILongValueImpl: public FILongValue {
-    mutable std::string strValue;
-    mutable bool strValueValid;
-    inline FILongValueImpl(std::vector<int64_t> &&value_): strValueValid(false) { value = std::move(value_); }
-    virtual const std::string &toString() const /*override*/ {
-        if (!strValueValid) {
-            strValueValid = true;
-            std::ostringstream os;
-            int n = 0;
-            std::for_each(value.begin(), value.end(), [&](int64_t l) { if (++n > 1) os << ' '; os << l; });
-            strValue = os.str();
-        }
-        return strValue;
-    };
-};
-
-std::shared_ptr<FILongValue> FILongValue::create(std::vector<int64_t> &&value) {
-    return std::make_shared<FILongValueImpl>(std::move(value));
-}
-
-struct FIBoolValueImpl: public FIBoolValue {
-    mutable std::string strValue;
-    mutable bool strValueValid;
-    inline FIBoolValueImpl(std::vector<bool> &&value_): strValueValid(false) { value = std::move(value_); }
-    virtual const std::string &toString() const /*override*/ {
-        if (!strValueValid) {
-            strValueValid = true;
-            std::ostringstream os;
-            os << std::boolalpha;
-            int n = 0;
-            std::for_each(value.begin(), value.end(), [&](bool b) { if (++n > 1) os << ' '; os << b; });
-            strValue = os.str();
-        }
-        return strValue;
-    };
-};
-
-std::shared_ptr<FIBoolValue> FIBoolValue::create(std::vector<bool> &&value) {
-    return std::make_shared<FIBoolValueImpl>(std::move(value));
-}
-
-struct FIFloatValueImpl: public FIFloatValue {
-    mutable std::string strValue;
-    mutable bool strValueValid;
-    inline FIFloatValueImpl(std::vector<float> &&value_): strValueValid(false) { value = std::move(value_); }
-    virtual const std::string &toString() const /*override*/ {
-        if (!strValueValid) {
-            strValueValid = true;
-            std::ostringstream os;
-            int n = 0;
-            std::for_each(value.begin(), value.end(), [&](float f) { if (++n > 1) os << ' '; os << f; });
-            strValue = os.str();
-        }
-        return strValue;
-    }
-};
-
-std::shared_ptr<FIFloatValue> FIFloatValue::create(std::vector<float> &&value) {
-    return std::make_shared<FIFloatValueImpl>(std::move(value));
-}
-
-struct FIDoubleValueImpl: public FIDoubleValue {
-    mutable std::string strValue;
-    mutable bool strValueValid;
-    inline FIDoubleValueImpl(std::vector<double> &&value_): strValueValid(false) { value = std::move(value_); }
-    virtual const std::string &toString() const /*override*/ {
-        if (!strValueValid) {
-            strValueValid = true;
-            std::ostringstream os;
-            int n = 0;
-            std::for_each(value.begin(), value.end(), [&](double d) { if (++n > 1) os << ' '; os << d; });
-            strValue = os.str();
-        }
-        return strValue;
-    }
-};
-
-std::shared_ptr<FIDoubleValue> FIDoubleValue::create(std::vector<double> &&value) {
-    return std::make_shared<FIDoubleValueImpl>(std::move(value));
-}
-
-struct FIUUIDValueImpl: public FIUUIDValue {
-    mutable std::string strValue;
-    mutable bool strValueValid;
-    inline FIUUIDValueImpl(std::vector<uint8_t> &&value_): strValueValid(false) { value = std::move(value_); }
-    virtual const std::string &toString() const /*override*/ {
-        if (!strValueValid) {
-            strValueValid = true;
-            std::ostringstream os;
-            os << std::hex << std::uppercase << std::setfill('0');
-            std::vector<uint8_t>::size_type valueSize = value.size();
-            for (std::vector<uint8_t>::size_type i = 0; i < valueSize; ++i) {
-                switch (i & 15) {
-                case 0:
-                    if (i > 0) {
-                        os << ' ';
-                    }
-                    os << std::setw(2) << static_cast<int>(value[i]);
-                    break;
-                case 4:
-                case 6:
-                case 8:
-                case 10:
-                    os << '-';
-                    // intentionally fall through!
-                case 1:
-                case 2:
-                case 3:
-                case 5:
-                case 7:
-                case 9:
-                case 11:
-                case 12:
-                case 13:
-                case 14:
-                case 15:
-                    os << std::setw(2) << static_cast<int>(value[i]);
-                    break;
-                }
-            }
-            strValue = os.str();
-        }
-        return strValue;
-    };
-};
-
-std::shared_ptr<FIUUIDValue> FIUUIDValue::create(std::vector<uint8_t> &&value) {
-    return std::make_shared<FIUUIDValueImpl>(std::move(value));
-}
-
-struct FICDATAValueImpl: public FICDATAValue {
-    inline FICDATAValueImpl(std::string &&value_) { value = std::move(value_); }
-    virtual const std::string &toString() const /*override*/ { return value; }
-};
-
-std::shared_ptr<FICDATAValue> FICDATAValue::create(std::string &&value) {
-    return std::make_shared<FICDATAValueImpl>(std::move(value));
-}
-
-struct FIHexDecoder: public FIDecoder {
-    virtual std::shared_ptr<const FIValue> decode(const uint8_t *data, size_t len) /*override*/ {
-        return FIHexValue::create(std::vector<uint8_t>(data, data + len));
-    }
-};
-
-struct FIBase64Decoder: public FIDecoder {
-    virtual std::shared_ptr<const FIValue> decode(const uint8_t *data, size_t len) /*override*/ {
-        return FIBase64Value::create(std::vector<uint8_t>(data, data + len));
-    }
-};
-
-struct FIShortDecoder: public FIDecoder {
-    virtual std::shared_ptr<const FIValue> decode(const uint8_t *data, size_t len) /*override*/ {
-        if (len & 1) {
-            throw DeadlyImportError(parseErrorMessage);
-        }
-        std::vector<int16_t> value;
-        size_t numShorts = len / 2;
-        value.reserve(numShorts);
-        for (size_t i = 0; i < numShorts; ++i) {
-            int16_t v = (data[0] << 8) | data[1];
-            value.push_back(v);
-            data += 2;
-        }
-        return FIShortValue::create(std::move(value));
-    }
-};
-
-struct FIIntDecoder: public FIDecoder {
-    virtual std::shared_ptr<const FIValue> decode(const uint8_t *data, size_t len) /*override*/ {
-        if (len & 3) {
-            throw DeadlyImportError(parseErrorMessage);
-        }
-        std::vector<int32_t> value;
-        size_t numInts = len / 4;
-        value.reserve(numInts);
-        for (size_t i = 0; i < numInts; ++i) {
-            int32_t v = (data[0] << 24) | (data[1] << 16) | (data[2] << 8) | data[3];
-            value.push_back(v);
-            data += 4;
-        }
-        return FIIntValue::create(std::move(value));
-    }
-};
-
-struct FILongDecoder: public FIDecoder {
-    virtual std::shared_ptr<const FIValue> decode(const uint8_t *data, size_t len) /*override*/ {
-        if (len & 7) {
-            throw DeadlyImportError(parseErrorMessage);
-        }
-        std::vector<int64_t> value;
-        size_t numLongs = len / 8;
-        value.reserve(numLongs);
-        for (size_t i = 0; i < numLongs; ++i) {
-            int64_t b0 = data[0], b1 = data[1], b2 = data[2], b3 = data[3], b4 = data[4], b5 = data[5], b6 = data[6], b7 = data[7];
-            int64_t v = (b0 << 56) | (b1 << 48) | (b2 << 40) | (b3 << 32) | (b4 << 24) | (b5 << 16) | (b6 << 8) | b7;
-            value.push_back(v);
-            data += 8;
-        }
-        return FILongValue::create(std::move(value));
-    }
-};
-
-struct FIBoolDecoder: public FIDecoder {
-    virtual std::shared_ptr<const FIValue> decode(const uint8_t *data, size_t len) /*override*/ {
-        if (len < 1) {
-            throw DeadlyImportError(parseErrorMessage);
-        }
-        std::vector<bool> value;
-        uint8_t b = *data++;
-        size_t unusedBits = b >> 4;
-        size_t numBools = (len * 8) - 4 - unusedBits;
-        value.reserve(numBools);
-        uint8_t mask = 1 << 3;
-        for (size_t i = 0; i < numBools; ++i) {
-            if (!mask) {
-                mask = 1 << 7;
-                b = *data++;
-            }
-            value.push_back((b & mask) != 0);
-        }
-        return FIBoolValue::create(std::move(value));
-    }
-};
-
-struct FIFloatDecoder: public FIDecoder {
-    virtual std::shared_ptr<const FIValue> decode(const uint8_t *data, size_t len) /*override*/ {
-        if (len & 3) {
-            throw DeadlyImportError(parseErrorMessage);
-        }
-        std::vector<float> value;
-        size_t numFloats = len / 4;
-        value.reserve(numFloats);
-        for (size_t i = 0; i < numFloats; ++i) {
-            int v = (data[0] << 24) | (data[1] << 16) | (data[2] << 8) | data[3];
-            float f;
-            memcpy(&f, &v, 4);
-            value.push_back(f);
-            data += 4;
-        }
-        return FIFloatValue::create(std::move(value));
-    }
-};
-
-struct FIDoubleDecoder: public FIDecoder {
-    virtual std::shared_ptr<const FIValue> decode(const uint8_t *data, size_t len) /*override*/ {
-        if (len & 7) {
-            throw DeadlyImportError(parseErrorMessage);
-        }
-        std::vector<double> value;
-        size_t numDoubles = len / 8;
-        value.reserve(numDoubles);
-        for (size_t i = 0; i < numDoubles; ++i) {
-            long long b0 = data[0], b1 = data[1], b2 = data[2], b3 = data[3], b4 = data[4], b5 = data[5], b6 = data[6], b7 = data[7];
-            long long v = (b0 << 56) | (b1 << 48) | (b2 << 40) | (b3 << 32) | (b4 << 24) | (b5 << 16) | (b6 << 8) | b7;
-            double f;
-            memcpy(&f, &v, 8);
-            value.push_back(f);
-            data += 8;
-        }
-        return FIDoubleValue::create(std::move(value));
-    }
-};
-
-struct FIUUIDDecoder: public FIDecoder {
-    virtual std::shared_ptr<const FIValue> decode(const uint8_t *data, size_t len) /*override*/ {
-        if (len & 15) {
-            throw DeadlyImportError(parseErrorMessage);
-        }
-        return FIUUIDValue::create(std::vector<uint8_t>(data, data + len));
-    }
-};
-
-struct FICDATADecoder: public FIDecoder {
-    virtual std::shared_ptr<const FIValue> decode(const uint8_t *data, size_t len) /*override*/ {
-        return FICDATAValue::create(parseUTF8String(data, len));
-    }
-};
-
-class CFIReaderImpl: public FIReader {
-public:
-
-    CFIReaderImpl(std::unique_ptr<uint8_t[]> data_, size_t size):
-    data(std::move(data_)), dataP(data.get()), dataEnd(data.get() + size), currentNodeType(irr::io::EXN_NONE),
-    emptyElement(false), headerPending(true), terminatorPending(false)
-    {}
-
-    virtual ~CFIReaderImpl() {}
-
-    virtual bool read() /*override*/ {
-        if (headerPending) {
-            headerPending = false;
-            parseHeader();
-        }
-        if (terminatorPending) {
-            terminatorPending = false;
-            if (elementStack.empty()) {
-                return false;
-            }
-            else {
-                nodeName = elementStack.top();
-                elementStack.pop();
-                currentNodeType = nodeName.empty() ? irr::io::EXN_UNKNOWN : irr::io::EXN_ELEMENT_END;
-                return true;
-            }
-        }
-        if (dataP >= dataEnd) {
-            return false;
-        }
-        uint8_t b = *dataP;
-        if (b < 0x80) { // Element (C.2.11.2, C.3.7.2)
-            // C.3
-            parseElement();
-            return true;
-        }
-        else if (b < 0xc0) { // Characters (C.3.7.5)
-            // C.7
-            auto chars = parseNonIdentifyingStringOrIndex3(vocabulary.charactersTable);
-            nodeName = chars->toString();
-            currentNodeType = irr::io::EXN_TEXT;
-            return true;
-        }
-        else if (b < 0xe0) {
-            if ((b & 0xfc) == 0xc4) { // DTD (C.2.11.5)
-                // C.9
-                ++dataP;
-                if (b & 0x02) {
-                    /*const std::string &systemID =*/ parseIdentifyingStringOrIndex(vocabulary.otherURITable);
-                }
-                if (b & 0x01) {
-                    /*const std::string &publicID =*/ parseIdentifyingStringOrIndex(vocabulary.otherURITable);
-                }
-                elementStack.push(EmptyString);
-                currentNodeType = irr::io::EXN_UNKNOWN;
-                return true;
-            }
-            else if ((b & 0xfc) == 0xc8) { // Unexpanded entity reference (C.3.7.4)
-                // C.6
-                ++dataP;
-                /*const std::string &name =*/ parseIdentifyingStringOrIndex(vocabulary.otherNCNameTable);
-                if (b & 0x02) {
-                    /*const std::string &systemID =*/ parseIdentifyingStringOrIndex(vocabulary.otherURITable);
-                }
-                if (b & 0x01) {
-                    /*const std::string &publicID =*/ parseIdentifyingStringOrIndex(vocabulary.otherURITable);
-                }
-                currentNodeType = irr::io::EXN_UNKNOWN;
-                return true;
-            }
-        }
-        else if (b < 0xf0) {
-            if (b == 0xe1) { // Processing instruction (C.2.11.3, C.3.7.3)
-                // C.5
-                ++dataP;
-                /*const std::string &target =*/ parseIdentifyingStringOrIndex(vocabulary.otherNCNameTable);
-                if (dataEnd - dataP < 1) {
-                    throw DeadlyImportError(parseErrorMessage);
-                }
-                /*std::shared_ptr<const FIValue> data =*/ parseNonIdentifyingStringOrIndex1(vocabulary.otherStringTable);
-                currentNodeType = irr::io::EXN_UNKNOWN;
-                return true;
-            }
-            else if (b == 0xe2) { // Comment (C.2.11.4, C.3.7.6)
-                // C.8
-                ++dataP;
-                if (dataEnd - dataP < 1) {
-                    throw DeadlyImportError(parseErrorMessage);
-                }
-                std::shared_ptr<const FIValue> comment = parseNonIdentifyingStringOrIndex1(vocabulary.otherStringTable);
-                nodeName = comment->toString();
-                currentNodeType = irr::io::EXN_COMMENT;
-                return true;
-            }
-        }
-        else { // Terminator (C.2.12, C.3.8)
-            ++dataP;
-            if (b == 0xff) {
-                terminatorPending = true;
-            }
-            if (elementStack.empty()) {
-                return false;
-            }
-            else {
-                nodeName = elementStack.top();
-                elementStack.pop();
-                currentNodeType = nodeName.empty() ? irr::io::EXN_UNKNOWN : irr::io::EXN_ELEMENT_END;
-                return true;
-            }
-        }
-        throw DeadlyImportError(parseErrorMessage);
-    }
-
-    virtual irr::io::EXML_NODE getNodeType() const /*override*/ {
-        return currentNodeType;
-    }
-
-    virtual int getAttributeCount() const /*override*/ {
-        return static_cast<int>(attributes.size());
-    }
-
-    virtual const char* getAttributeName(int idx) const /*override*/ {
-        if (idx < 0 || idx >= (int)attributes.size()) {
-            return nullptr;
-        }
-        return attributes[idx].name.c_str();
-    }
-
-    virtual const char* getAttributeValue(int idx) const /*override*/ {
-        if (idx < 0 || idx >= (int)attributes.size()) {
-            return nullptr;
-        }
-        return attributes[idx].value->toString().c_str();
-    }
-
-    virtual const char* getAttributeValue(const char* name) const /*override*/ {
-        const Attribute* attr = getAttributeByName(name);
-        if (!attr) {
-            return nullptr;
-        }
-        return attr->value->toString().c_str();
-    }
-
-    virtual const char* getAttributeValueSafe(const char* name) const /*override*/ {
-        const Attribute* attr = getAttributeByName(name);
-        if (!attr) {
-            return EmptyString.c_str();
-        }
-        return attr->value->toString().c_str();
-    }
-
-    virtual int getAttributeValueAsInt(const char* name) const /*override*/ {
-        const Attribute* attr = getAttributeByName(name);
-        if (!attr) {
-            return 0;
-        }
-        std::shared_ptr<const FIIntValue> intValue = std::dynamic_pointer_cast<const FIIntValue>(attr->value);
-        if (intValue) {
-            return intValue->value.size() == 1 ? intValue->value.front() : 0;
-        }
-        return atoi(attr->value->toString().c_str());
-    }
-
-    virtual int getAttributeValueAsInt(int idx) const /*override*/ {
-        if (idx < 0 || idx >= (int)attributes.size()) {
-            return 0;
-        }
-        std::shared_ptr<const FIIntValue> intValue = std::dynamic_pointer_cast<const FIIntValue>(attributes[idx].value);
-        if (intValue) {
-            return intValue->value.size() == 1 ? intValue->value.front() : 0;
-        }
-        return atoi(attributes[idx].value->toString().c_str());
-    }
-
-    virtual float getAttributeValueAsFloat(const char* name) const /*override*/ {
-        const Attribute* attr = getAttributeByName(name);
-        if (!attr) {
-            return 0;
-        }
-        std::shared_ptr<const FIFloatValue> floatValue = std::dynamic_pointer_cast<const FIFloatValue>(attr->value);
-        if (floatValue) {
-            return floatValue->value.size() == 1 ? floatValue->value.front() : 0;
-        }
-
-        return fast_atof(attr->value->toString().c_str());
-    }
-
-    virtual float getAttributeValueAsFloat(int idx) const /*override*/ {
-        if (idx < 0 || idx >= (int)attributes.size()) {
-            return 0;
-        }
-        std::shared_ptr<const FIFloatValue> floatValue = std::dynamic_pointer_cast<const FIFloatValue>(attributes[idx].value);
-        if (floatValue) {
-            return floatValue->value.size() == 1 ? floatValue->value.front() : 0;
-        }
-        return fast_atof(attributes[idx].value->toString().c_str());
-    }
-
-    virtual const char* getNodeName() const /*override*/ {
-        return nodeName.c_str();
-    }
-
-    virtual const char* getNodeData() const /*override*/ {
-        return nodeName.c_str();
-    }
-
-    virtual bool isEmptyElement() const /*override*/ {
-        return emptyElement;
-    }
-
-    virtual irr::io::ETEXT_FORMAT getSourceFormat() const /*override*/ {
-        return irr::io::ETF_UTF8;
-    }
-
-    virtual irr::io::ETEXT_FORMAT getParserFormat() const /*override*/ {
-        return irr::io::ETF_UTF8;
-    }
-
-    virtual std::shared_ptr<const FIValue> getAttributeEncodedValue(int idx) const /*override*/ {
-        if (idx < 0 || idx >= (int)attributes.size()) {
-            return nullptr;
-        }
-        return attributes[idx].value;
-    }
-
-    virtual std::shared_ptr<const FIValue> getAttributeEncodedValue(const char* name) const /*override*/ {
-        const Attribute* attr = getAttributeByName(name);
-        if (!attr) {
-            return nullptr;
-        }
-        return attr->value;
-    }
-
-    virtual void registerDecoder(const std::string &algorithmUri, std::unique_ptr<FIDecoder> decoder) /*override*/ {
-        decoderMap[algorithmUri] = std::move(decoder);
-    }
-
-    virtual void registerVocabulary(const std::string &vocabularyUri, const FIVocabulary *vocabulary) /*override*/ {
-        vocabularyMap[vocabularyUri] = vocabulary;
-    }
-
-private:
-
-    struct QName {
-        std::string prefix;
-        std::string uri;
-        std::string name;
-        inline QName() {}
-        inline QName(const FIQName &qname): prefix(qname.prefix ? qname.prefix : ""), uri(qname.uri ? qname.uri : ""), name(qname.name) {}
-    };
-
-    struct Attribute {
-        QName qname;
-        std::string name;
-        std::shared_ptr<const FIValue> value;
-    };
-
-    struct Vocabulary {
-        std::vector<std::string> restrictedAlphabetTable;
-        std::vector<std::string> encodingAlgorithmTable;
-        std::vector<std::string> prefixTable;
-        std::vector<std::string> namespaceNameTable;
-        std::vector<std::string> localNameTable;
-        std::vector<std::string> otherNCNameTable;
-        std::vector<std::string> otherURITable;
-        std::vector<std::shared_ptr<const FIValue>> attributeValueTable;
-        std::vector<std::shared_ptr<const FIValue>> charactersTable;
-        std::vector<std::shared_ptr<const FIValue>> otherStringTable;
-        std::vector<QName> elementNameTable;
-        std::vector<QName> attributeNameTable;
-        Vocabulary() {
-            prefixTable.push_back("xml");
-            namespaceNameTable.push_back("http://www.w3.org/XML/1998/namespace");
-        }
-    };
-
-    const Attribute* getAttributeByName(const char* name) const {
-        if (!name) {
-            return 0;
-        }
-        std::string n = name;
-        for (int i=0; i<(int)attributes.size(); ++i) {
-            if (attributes[i].name == n) {
-                return &attributes[i];
-            }
-        }
-        return 0;
-    }
-
-    size_t parseInt2() { // C.25
-        uint8_t b = *dataP++;
-        if (!(b & 0x40)) { // x0...... (C.25.2)
-            return b & 0x3f;
-        }
-        else if ((b & 0x60) == 0x40) { // x10..... ........ (C.25.3)
-            if (dataEnd - dataP > 0) {
-                return (((b & 0x1f) << 8) | *dataP++) + 0x40;
-            }
-        }
-        else if ((b & 0x70) == 0x60) { // x110.... ........ ........ (C.25.4)
-            if (dataEnd - dataP > 1) {
-                size_t result = (((b & 0x0f) << 16) | (dataP[0] << 8) | dataP[1]) + 0x2040;
-                dataP += 2;
-                return result;
-            }
-        }
-        throw DeadlyImportError(parseErrorMessage);
-    }
-
-    size_t parseInt3() { // C.27
-        uint8_t b = *dataP++;
-        if (!(b & 0x20)) { // xx0..... (C.27.2)
-            return b & 0x1f;
-        }
-        else if ((b & 0x38) == 0x20) { // xx100... ........ (C.27.3)
-            if (dataEnd - dataP > 0) {
-                return (((b & 0x07) << 8) | *dataP++) + 0x20;
-            }
-        }
-        else if ((b & 0x38) == 0x28) { // xx101... ........ ........ (C.27.4)
-            if (dataEnd - dataP > 1) {
-                size_t result = (((b & 0x07) << 16) | (dataP[0] << 8) | dataP[1]) + 0x820;
-                dataP += 2;
-                return result;
-            }
-        }
-        else if ((b & 0x3f) == 0x30) { // xx110000 0000.... ........ ........ (C.27.5)
-            if ((dataEnd - dataP > 2) && !(dataP[0] & 0xf0)) {
-                size_t result = (((dataP[0] & 0x0f) << 16) | (dataP[1] << 8) | dataP[2]) + 0x80820;
-                dataP += 3;
-                return result;
-            }
-        }
-        throw DeadlyImportError(parseErrorMessage);
-    }
-
-    size_t parseInt4() { // C.28
-        uint8_t b = *dataP++;
-        if (!(b & 0x10)) { // xxx0.... (C.28.2)
-            return b & 0x0f;
-        }
-        else if ((b & 0x1c) == 0x10) { // xxx100.. ........ (C.28.3)
-            if (dataEnd - dataP > 0) {
-                return (((b & 0x03) << 8) | *dataP++) + 0x10;
-            }
-        }
-        else if ((b & 0x1c) == 0x14) { // xxx101.. ........ ........ (C.28.4)
-            if (dataEnd - dataP > 1) {
-                size_t result = (((b & 0x03) << 16) | (dataP[0] << 8) | dataP[1]) + 0x410;
-                dataP += 2;
-                return result;
-            }
-        }
-        else if ((b & 0x1f) == 0x18) { // xxx11000 0000.... ........ ........ (C.28.5)
-            if ((dataEnd - dataP > 2) && !(dataP[0] & 0xf0)) {
-                size_t result = (((dataP[0] & 0x0f) << 16) | (dataP[1] << 8) | dataP[2]) + 0x40410;
-                dataP += 3;
-                return result;
-            }
-        }
-        throw DeadlyImportError(parseErrorMessage);
-    }
-
-    size_t parseSequenceLen() { // C.21
-        if (dataEnd - dataP > 0) {
-            uint8_t b = *dataP++;
-            if (b < 0x80) { // 0....... (C.21.2)
-                return b;
-            }
-            else if ((b & 0xf0) == 0x80) { // 1000.... ........ ........ (C.21.3)
-                if (dataEnd - dataP > 1) {
-                    size_t result = (((b & 0x0f) << 16) | (dataP[0] << 8) | dataP[1]) + 0x80;
-                    dataP += 2;
-                    return result;
-                }
-            }
-        }
-        throw DeadlyImportError(parseErrorMessage);
-    }
-
-    std::string parseNonEmptyOctetString2() { // C.22
-        // Parse the length of the string
-        uint8_t b = *dataP++ & 0x7f;
-        size_t len;
-        if (!(b & 0x40)) { // x0...... (C.22.3.1)
-            len = b + 1;
-        }
-        else if (b == 0x40) { // x1000000 ........ (C.22.3.2)
-            if (dataEnd - dataP < 1) {
-                throw DeadlyImportError(parseErrorMessage);
-            }
-            len = *dataP++ + 0x41;
-        }
-        else if (b == 0x60) { // x1100000 ........ ........ ........ ........ (C.22.3.3)
-            if (dataEnd - dataP < 4) {
-                throw DeadlyImportError(parseErrorMessage);
-            }
-            len = ((dataP[0] << 24) | (dataP[1] << 16) | (dataP[2] << 8) | dataP[3]) + 0x141;
-            dataP += 4;
-        }
-        else {
-            throw DeadlyImportError(parseErrorMessage);
-        }
-
-        // Parse the string (C.22.4)
-        if (dataEnd - dataP < static_cast<ptrdiff_t>(len)) {
-            throw DeadlyImportError(parseErrorMessage);
-        }
-        std::string s = parseUTF8String(dataP, len);
-        dataP += len;
-
-        return s;
-    }
-
-    size_t parseNonEmptyOctetString5Length() { // C.23
-        // Parse the length of the string
-        size_t b = *dataP++ & 0x0f;
-        if (!(b & 0x08)) { // xxxx0... (C.23.3.1)
-            return b + 1;
-        }
-        else if (b == 0x08) { // xxxx1000 ........ (C.23.3.2)
-            if (dataEnd - dataP > 0) {
-                return *dataP++ + 0x09;
-            }
-        }
-        else if (b == 0x0c) { // xxxx1100 ........ ........ ........ ........ (C.23.3.3)
-            if (dataEnd - dataP > 3) {
-                size_t result = ((dataP[0] << 24) | (dataP[1] << 16) | (dataP[2] << 8) | dataP[3]) + 0x109;
-                dataP += 4;
-                return result;
-            }
-        }
-        throw DeadlyImportError(parseErrorMessage);
-    }
-
-    size_t parseNonEmptyOctetString7Length() { // C.24
-        // Parse the length of the string
-        size_t b = *dataP++ & 0x03;
-        if (!(b & 0x02)) { // xxxxxx0. (C.24.3.1)
-            return b + 1;
-        }
-        else if (b == 0x02) { // xxxxxx10 ........ (C.24.3.2)
-            if (dataEnd - dataP > 0) {
-                return *dataP++ + 0x3;
-            }
-        }
-        else if (b == 0x03) { // xxxxxx11 ........ ........ ........ ........ (C.24.3.3)
-            if (dataEnd - dataP > 3) {
-                size_t result = ((dataP[0] << 24) | (dataP[1] << 16) | (dataP[2] << 8) | dataP[3]) + 0x103;
-                dataP += 4;
-                return result;
-            }
-        }
-        throw DeadlyImportError(parseErrorMessage);
-    }
-
-    std::shared_ptr<const FIValue> parseEncodedData(size_t index, size_t len) {
-        if (index < 32) {
-            FIDecoder *decoder = defaultDecoder[index];
-            if (!decoder) {
-                throw DeadlyImportError("Invalid encoding algorithm index " + to_string(index));
-            }
-            return decoder->decode(dataP, len);
-        }
-        else {
-            if (index - 32 >= vocabulary.encodingAlgorithmTable.size()) {
-                throw DeadlyImportError("Invalid encoding algorithm index " + to_string(index));
-            }
-            std::string uri = vocabulary.encodingAlgorithmTable[index - 32];
-            auto it = decoderMap.find(uri);
-            if (it == decoderMap.end()) {
-                throw DeadlyImportError("Unsupported encoding algorithm " + uri);
-            }
-            else {
-                return it->second->decode(dataP, len);
-            }
-        }
-    }
-
-    std::shared_ptr<const FIValue> parseRestrictedAlphabet(size_t index, size_t len) {
-        std::string alphabet;
-        if (index < 16) {
-            switch (index) {
-            case 0: // numeric
-                alphabet = "0123456789-+.e ";
-                break;
-            case 1: // date and time
-                alphabet = "0123456789-:TZ ";
-                break;
-            default:
-                throw DeadlyImportError("Invalid restricted alphabet index " + to_string(index));
-            }
-        }
-        else {
-            if (index - 16 >= vocabulary.restrictedAlphabetTable.size()) {
-                throw DeadlyImportError("Invalid restricted alphabet index " + to_string(index));
-            }
-            alphabet = vocabulary.restrictedAlphabetTable[index - 16];
-        }
-        std::vector<uint32_t> alphabetUTF32;
-        utf8::utf8to32(alphabet.begin(), alphabet.end(), back_inserter(alphabetUTF32));
-        std::string::size_type alphabetLength = alphabetUTF32.size();
-        if (alphabetLength < 2) {
-            throw DeadlyImportError("Invalid restricted alphabet length " + to_string(alphabetLength));
-        }
-        std::string::size_type bitsPerCharacter = 1;
-        while ((1ull << bitsPerCharacter) <= alphabetLength) {
-            ++bitsPerCharacter;
-        }
-        size_t bitsAvail = 0;
-        uint8_t mask = (1 << bitsPerCharacter) - 1;
-        uint32_t bits = 0;
-        std::string s;
-        for (size_t i = 0; i < len; ++i) {
-            bits = (bits << 8) | dataP[i];
-            bitsAvail += 8;
-            while (bitsAvail >= bitsPerCharacter) {
-                bitsAvail -= bitsPerCharacter;
-                size_t charIndex = (bits >> bitsAvail) & mask;
-                if (charIndex < alphabetLength) {
-                    s.push_back(alphabetUTF32[charIndex]);
-                }
-                else if (charIndex != mask) {
-                    throw DeadlyImportError(parseErrorMessage);
-                }
-            }
-        }
-        return FIStringValue::create(std::move(s));
-    }
-
-    std::shared_ptr<const FIValue> parseEncodedCharacterString3() { // C.19
-        std::shared_ptr<const FIValue> result;
-        size_t len;
-        uint8_t b = *dataP;
-        if (b & 0x20) {
-            ++dataP;
-            if (dataEnd - dataP < 1) {
-                throw DeadlyImportError(parseErrorMessage);
-            }
-            size_t index = ((b & 0x0f) << 4) | ((*dataP & 0xf0) >> 4); // C.29
-            len = parseNonEmptyOctetString5Length();
-            if (dataEnd - dataP < static_cast<ptrdiff_t>(len)) {
-                throw DeadlyImportError(parseErrorMessage);
-            }
-            if (b & 0x10) {
-                // encoding algorithm (C.19.3.4)
-                result = parseEncodedData(index, len);
-            }
-            else {
-                // Restricted alphabet (C.19.3.3)
-                result = parseRestrictedAlphabet(index, len);
-            }
-        }
-        else {
-            len = parseNonEmptyOctetString5Length();
-            if (dataEnd - dataP < static_cast<ptrdiff_t>(len)) {
-                throw DeadlyImportError(parseErrorMessage);
-            }
-            if (b & 0x10) {
-                // UTF-16 (C.19.3.2)
-                if (len & 1) {
-                    throw DeadlyImportError(parseErrorMessage);
-                }
-                result = FIStringValue::create(parseUTF16String(dataP, len));
-            }
-            else {
-                // UTF-8 (C.19.3.1)
-                result = FIStringValue::create(parseUTF8String(dataP, len));
-            }
-        }
-        dataP += len;
-        return result;
-    }
-
-    std::shared_ptr<const FIValue> parseEncodedCharacterString5() { // C.20
-        std::shared_ptr<const FIValue> result;
-        size_t len;
-        uint8_t b = *dataP;
-        if (b & 0x08) {
-            ++dataP;
-            if (dataEnd - dataP < 1) {
-                throw DeadlyImportError(parseErrorMessage);
-            }
-            size_t index = ((b & 0x03) << 6) | ((*dataP & 0xfc) >> 2); /* C.29 */
-            len = parseNonEmptyOctetString7Length();
-            if (dataEnd - dataP < static_cast<ptrdiff_t>(len)) {
-                throw DeadlyImportError(parseErrorMessage);
-            }
-            if (b & 0x04) {
-                // encoding algorithm (C.20.3.4)
-                result = parseEncodedData(index, len);
-            }
-            else {
-                // Restricted alphabet (C.20.3.3)
-                result = parseRestrictedAlphabet(index, len);
-            }
-        }
-        else {
-            len = parseNonEmptyOctetString7Length();
-            if (dataEnd - dataP < static_cast<ptrdiff_t>(len)) {
-                throw DeadlyImportError(parseErrorMessage);
-            }
-            if (b & 0x04) {
-                // UTF-16 (C.20.3.2)
-                if (len & 1) {
-                    throw DeadlyImportError(parseErrorMessage);
-                }
-                result = FIStringValue::create(parseUTF16String(dataP, len));
-            }
-            else {
-                // UTF-8 (C.20.3.1)
-                result = FIStringValue::create(parseUTF8String(dataP, len));
-            }
-        }
-        dataP += len;
-        return result;
-    }
-
-    const std::string &parseIdentifyingStringOrIndex(std::vector<std::string> &stringTable) { // C.13
-        if (dataEnd - dataP < 1) {
-            throw DeadlyImportError(parseErrorMessage);
-        }
-        uint8_t b = *dataP;
-        if (b & 0x80) {
-            // We have an index (C.13.4)
-            size_t index = parseInt2();
-            if (index >= stringTable.size()) {
-                throw DeadlyImportError(parseErrorMessage);
-            }
-            return stringTable[index];
-        }
-        else {
-            // We have a string (C.13.3)
-            stringTable.push_back(parseNonEmptyOctetString2());
-            return stringTable.back();
-        }
-    }
-
-    QName parseNameSurrogate() { // C.16
-        if (dataEnd - dataP < 1) {
-            throw DeadlyImportError(parseErrorMessage);
-        }
-        uint8_t b = *dataP++;
-        if (b & 0xfc) { // Padding '000000' C.2.5.5
-            throw DeadlyImportError(parseErrorMessage);
-        }
-        QName result;
-        size_t index;
-        if (b & 0x02) { // prefix (C.16.3)
-            if ((dataEnd - dataP < 1) || (*dataP & 0x80)) {
-                throw DeadlyImportError(parseErrorMessage);
-            }
-            index = parseInt2();
-            if (index >= vocabulary.prefixTable.size()) {
-                throw DeadlyImportError(parseErrorMessage);
-            }
-            result.prefix = vocabulary.prefixTable[index];
-        }
-        if (b & 0x01) { // namespace-name (C.16.4)
-            if ((dataEnd - dataP < 1) || (*dataP & 0x80)) {
-                throw DeadlyImportError(parseErrorMessage);
-            }
-            index = parseInt2();
-            if (index >= vocabulary.namespaceNameTable.size()) {
-                throw DeadlyImportError(parseErrorMessage);
-            }
-            result.uri = vocabulary.namespaceNameTable[index];
-        }
-        // local-name
-        if ((dataEnd - dataP < 1) || (*dataP & 0x80)) {
-            throw DeadlyImportError(parseErrorMessage);
-        }
-        index = parseInt2();
-        if (index >= vocabulary.localNameTable.size()) {
-            throw DeadlyImportError(parseErrorMessage);
-        }
-        result.name = vocabulary.localNameTable[index];
-        return result;
-    }
-
-    const QName &parseQualifiedNameOrIndex2(std::vector<QName> &qNameTable) { // C.17
-        uint8_t b = *dataP;
-        if ((b & 0x7c) == 0x78) { // x11110..
-            // We have a literal (C.17.3)
-            ++dataP;
-            QName result;
-            // prefix (C.17.3.1)
-            result.prefix = b & 0x02 ? parseIdentifyingStringOrIndex(vocabulary.prefixTable) : std::string();
-            // namespace-name (C.17.3.1)
-            result.uri = b & 0x01 ? parseIdentifyingStringOrIndex(vocabulary.namespaceNameTable) : std::string();
-            // local-name
-            result.name = parseIdentifyingStringOrIndex(vocabulary.localNameTable);
-            qNameTable.push_back(result);
-            return qNameTable.back();
-        }
-        else {
-            // We have an index (C.17.4)
-            size_t index = parseInt2();
-            if (index >= qNameTable.size()) {
-                throw DeadlyImportError(parseErrorMessage);
-            }
-            return qNameTable[index];
-        }
-    }
-
-    const QName &parseQualifiedNameOrIndex3(std::vector<QName> &qNameTable) { // C.18
-        uint8_t b = *dataP;
-        if ((b & 0x3c) == 0x3c) { // xx1111..
-            // We have a literal (C.18.3)
-            ++dataP;
-            QName result;
-            // prefix (C.18.3.1)
-            result.prefix = b & 0x02 ? parseIdentifyingStringOrIndex(vocabulary.prefixTable) : std::string();
-            // namespace-name (C.18.3.1)
-            result.uri = b & 0x01 ? parseIdentifyingStringOrIndex(vocabulary.namespaceNameTable) : std::string();
-            // local-name
-            result.name = parseIdentifyingStringOrIndex(vocabulary.localNameTable);
-            qNameTable.push_back(result);
-            return qNameTable.back();
-        }
-        else {
-            // We have an index (C.18.4)
-            size_t index = parseInt3();
-            if (index >= qNameTable.size()) {
-                throw DeadlyImportError(parseErrorMessage);
-            }
-            return qNameTable[index];
-        }
-    }
-
-    std::shared_ptr<const FIValue> parseNonIdentifyingStringOrIndex1(std::vector<std::shared_ptr<const FIValue>> &valueTable) { // C.14
-        uint8_t b = *dataP;
-        if (b == 0xff) { // C.26.2
-            // empty string
-            ++dataP;
-            return EmptyFIString;
-        }
-        else if (b & 0x80) { // C.14.4
-            // We have an index
-            size_t index = parseInt2();
-            if (index >= valueTable.size()) {
-                throw DeadlyImportError(parseErrorMessage);
-            }
-            return valueTable[index];
-        }
-        else { // C.14.3
-            // We have a literal
-            std::shared_ptr<const FIValue> result = parseEncodedCharacterString3();
-            if (b & 0x40) { // C.14.3.1
-                valueTable.push_back(result);
-            }
-            return result;
-        }
-    }
-
-    std::shared_ptr<const FIValue> parseNonIdentifyingStringOrIndex3(std::vector<std::shared_ptr<const FIValue>> &valueTable) { // C.15
-        uint8_t b = *dataP;
-        if (b & 0x20) { // C.15.4
-            // We have an index
-            size_t index = parseInt4();
-            if (index >= valueTable.size()) {
-                throw DeadlyImportError(parseErrorMessage);
-            }
-            return valueTable[index];
-        }
-        else { // C.15.3
-            // We have a literal
-            std::shared_ptr<const FIValue> result = parseEncodedCharacterString5();
-            if (b & 0x10) { // C.15.3.1
-                valueTable.push_back(result);
-            }
-            return result;
-        }
-    }
-
-    void parseElement() {
-        // C.3
-
-        attributes.clear();
-
-        uint8_t b = *dataP;
-        bool hasAttributes = (b & 0x40) != 0; // C.3.3
-        if ((b & 0x3f) == 0x38) { // C.3.4.1
-            // Parse namespaces
-            ++dataP;
-            for (;;) {
-                if (dataEnd - dataP < 1) {
-                    throw DeadlyImportError(parseErrorMessage);
-                }
-                b = *dataP++;
-                if (b == 0xf0) { // C.3.4.3
-                    break;
-                }
-                if ((b & 0xfc) != 0xcc) { // C.3.4.2
-                    throw DeadlyImportError(parseErrorMessage);
-                }
-                // C.12
-                Attribute attr;
-                attr.qname.prefix = "xmlns";
-                attr.qname.name = b & 0x02 ? parseIdentifyingStringOrIndex(vocabulary.prefixTable) : std::string();
-                attr.qname.uri = b & 0x01 ? parseIdentifyingStringOrIndex(vocabulary.namespaceNameTable) : std::string();
-                attr.name = attr.qname.name.empty() ? "xmlns" : "xmlns:" + attr.qname.name;
-                attr.value = FIStringValue::create(std::string(attr.qname.uri));
-                attributes.push_back(attr);
-            }
-            if ((dataEnd - dataP < 1) || (*dataP & 0xc0)) {
-                throw DeadlyImportError(parseErrorMessage);
-            }
-        }
-
-        // Parse Element name (C.3.5)
-        const QName &elemName = parseQualifiedNameOrIndex3(vocabulary.elementNameTable);
-        nodeName = elemName.prefix.empty() ? elemName.name : elemName.prefix + ':' + elemName.name;
-
-        if (hasAttributes) {
-            for (;;) {
-                if (dataEnd - dataP < 1) {
-                    throw DeadlyImportError(parseErrorMessage);
-                }
-                b = *dataP;
-                if (b < 0x80) { // C.3.6.1
-                    // C.4
-                    Attribute attr;
-                    attr.qname = parseQualifiedNameOrIndex2(vocabulary.attributeNameTable);
-                    attr.name = attr.qname.prefix.empty() ? attr.qname.name : attr.qname.prefix + ':' + attr.qname.name;
-                    if (dataEnd - dataP < 1) {
-                        throw DeadlyImportError(parseErrorMessage);
-                    }
-                    attr.value = parseNonIdentifyingStringOrIndex1(vocabulary.attributeValueTable);
-                    attributes.push_back(attr);
-                }
-                else {
-                    if ((b & 0xf0) != 0xf0) { // C.3.6.2
-                        throw DeadlyImportError(parseErrorMessage);
-                    }
-                    emptyElement = b == 0xff; // C.3.6.2, C.3.8
-                    ++dataP;
-                    break;
-                }
-            }
-        }
-        else {
-            if (dataEnd - dataP < 1) {
-                throw DeadlyImportError(parseErrorMessage);
-            }
-            b = *dataP;
-            switch (b) {
-            case 0xff:
-                terminatorPending = true;
-                // Intentionally fall through
-            case 0xf0:
-                emptyElement = true;
-                ++dataP;
-                break;
-            default:
-                emptyElement = false;
-            }
-        }
-        if (!emptyElement) {
-            elementStack.push(nodeName);
-        }
-
-        currentNodeType = irr::io::EXN_ELEMENT;
-    }
-
-    void parseHeader() {
-        // Parse header (C.1.3)
-        size_t magicSize = parseMagic(dataP, dataEnd);
-        if (!magicSize) {
-            throw DeadlyImportError(parseErrorMessage);
-        }
-        dataP += magicSize;
-        // C.2.3
-        if (dataEnd - dataP < 1) {
-            throw DeadlyImportError(parseErrorMessage);
-        }
-        uint8_t b = *dataP++;
-        if (b & 0x40) {
-            // Parse additional data (C.2.4)
-            size_t len = parseSequenceLen();
-            for (size_t i = 0; i < len; ++i) {
-                if (dataEnd - dataP < 1) {
-                    throw DeadlyImportError(parseErrorMessage);
-                }
-                /*std::string id =*/ parseNonEmptyOctetString2();
-                if (dataEnd - dataP < 1) {
-                    throw DeadlyImportError(parseErrorMessage);
-                }
-                /*std::string data =*/ parseNonEmptyOctetString2();
-            }
-        }
-        if (b & 0x20) {
-            // Parse initial vocabulary (C.2.5)
-            if (dataEnd - dataP < 2) {
-                throw DeadlyImportError(parseErrorMessage);
-            }
-            uint16_t b1 = (dataP[0] << 8) | dataP[1];
-            dataP += 2;
-            if (b1 & 0x1000) {
-                // External vocabulary (C.2.5.2)
-                if (dataEnd - dataP < 1) {
-                    throw DeadlyImportError(parseErrorMessage);
-                }
-                std::string uri = parseNonEmptyOctetString2();
-                auto it = vocabularyMap.find(uri);
-                if (it == vocabularyMap.end()) {
-                    throw DeadlyImportError("Unknown vocabulary " + uri);
-                }
-                const FIVocabulary *externalVocabulary = it->second;
-                if (externalVocabulary->restrictedAlphabetTable) {
-                    std::copy(externalVocabulary->restrictedAlphabetTable, externalVocabulary->restrictedAlphabetTable + externalVocabulary->restrictedAlphabetTableSize, std::back_inserter(vocabulary.restrictedAlphabetTable));
-                }
-                if (externalVocabulary->encodingAlgorithmTable) {
-                    std::copy(externalVocabulary->encodingAlgorithmTable, externalVocabulary->encodingAlgorithmTable + externalVocabulary->encodingAlgorithmTableSize, std::back_inserter(vocabulary.encodingAlgorithmTable));
-                }
-                if (externalVocabulary->prefixTable) {
-                    std::copy(externalVocabulary->prefixTable, externalVocabulary->prefixTable + externalVocabulary->prefixTableSize, std::back_inserter(vocabulary.prefixTable));
-                }
-                if (externalVocabulary->namespaceNameTable) {
-                    std::copy(externalVocabulary->namespaceNameTable, externalVocabulary->namespaceNameTable + externalVocabulary->namespaceNameTableSize, std::back_inserter(vocabulary.namespaceNameTable));
-                }
-                if (externalVocabulary->localNameTable) {
-                    std::copy(externalVocabulary->localNameTable, externalVocabulary->localNameTable + externalVocabulary->localNameTableSize, std::back_inserter(vocabulary.localNameTable));
-                }
-                if (externalVocabulary->otherNCNameTable) {
-                    std::copy(externalVocabulary->otherNCNameTable, externalVocabulary->otherNCNameTable + externalVocabulary->otherNCNameTableSize, std::back_inserter(vocabulary.otherNCNameTable));
-                }
-                if (externalVocabulary->otherURITable) {
-                    std::copy(externalVocabulary->otherURITable, externalVocabulary->otherURITable + externalVocabulary->otherURITableSize, std::back_inserter(vocabulary.otherURITable));
-                }
-                if (externalVocabulary->attributeValueTable) {
-                    std::copy(externalVocabulary->attributeValueTable, externalVocabulary->attributeValueTable + externalVocabulary->attributeValueTableSize, std::back_inserter(vocabulary.attributeValueTable));
-                }
-                if (externalVocabulary->charactersTable) {
-                    std::copy(externalVocabulary->charactersTable, externalVocabulary->charactersTable + externalVocabulary->charactersTableSize, std::back_inserter(vocabulary.charactersTable));
-                }
-                if (externalVocabulary->otherStringTable) {
-                    std::copy(externalVocabulary->otherStringTable, externalVocabulary->otherStringTable + externalVocabulary->otherStringTableSize, std::back_inserter(vocabulary.otherStringTable));
-                }
-                if (externalVocabulary->elementNameTable) {
-                    std::copy(externalVocabulary->elementNameTable, externalVocabulary->elementNameTable + externalVocabulary->elementNameTableSize, std::back_inserter(vocabulary.elementNameTable));
-                }
-                if (externalVocabulary->attributeNameTable) {
-                    std::copy(externalVocabulary->attributeNameTable, externalVocabulary->attributeNameTable + externalVocabulary->attributeNameTableSize, std::back_inserter(vocabulary.attributeNameTable));
-                }
-            }
-            if (b1 & 0x0800) {
-                // Parse restricted alphabets (C.2.5.3)
-                for (size_t len = parseSequenceLen(); len > 0; --len) {
-                    if (dataEnd - dataP < 1) {
-                        throw DeadlyImportError(parseErrorMessage);
-                    }
-                    vocabulary.restrictedAlphabetTable.push_back(parseNonEmptyOctetString2());
-                }
-            }
-            if (b1 & 0x0400) {
-                // Parse encoding algorithms (C.2.5.3)
-                for (size_t len = parseSequenceLen(); len > 0; --len) {
-                    if (dataEnd - dataP < 1) {
-                        throw DeadlyImportError(parseErrorMessage);
-                    }
-                    vocabulary.encodingAlgorithmTable.push_back(parseNonEmptyOctetString2());
-                }
-            }
-            if (b1 & 0x0200) {
-                // Parse prefixes (C.2.5.3)
-                for (size_t len = parseSequenceLen(); len > 0; --len) {
-                    if (dataEnd - dataP < 1) {
-                        throw DeadlyImportError(parseErrorMessage);
-                    }
-                    vocabulary.prefixTable.push_back(parseNonEmptyOctetString2());
-                }
-            }
-            if (b1 & 0x0100) {
-                // Parse namespace names (C.2.5.3)
-                for (size_t len = parseSequenceLen(); len > 0; --len) {
-                    if (dataEnd - dataP < 1) {
-                        throw DeadlyImportError(parseErrorMessage);
-                    }
-                    vocabulary.namespaceNameTable.push_back(parseNonEmptyOctetString2());
-                }
-            }
-            if (b1 & 0x0080) {
-                // Parse local names (C.2.5.3)
-                for (size_t len = parseSequenceLen(); len > 0; --len) {
-                    if (dataEnd - dataP < 1) {
-                        throw DeadlyImportError(parseErrorMessage);
-                    }
-                    vocabulary.localNameTable.push_back(parseNonEmptyOctetString2());
-                }
-            }
-            if (b1 & 0x0040) {
-                // Parse other ncnames (C.2.5.3)
-                for (size_t len = parseSequenceLen(); len > 0; --len) {
-                    if (dataEnd - dataP < 1) {
-                        throw DeadlyImportError(parseErrorMessage);
-                    }
-                    vocabulary.otherNCNameTable.push_back(parseNonEmptyOctetString2());
-                }
-            }
-            if (b1 & 0x0020) {
-                // Parse other uris (C.2.5.3)
-                for (size_t len = parseSequenceLen(); len > 0; --len) {
-                    if (dataEnd - dataP < 1) {
-                        throw DeadlyImportError(parseErrorMessage);
-                    }
-                    vocabulary.otherURITable.push_back(parseNonEmptyOctetString2());
-                }
-            }
-            if (b1 & 0x0010) {
-                // Parse attribute values (C.2.5.4)
-                for (size_t len = parseSequenceLen(); len > 0; --len) {
-                    if (dataEnd - dataP < 1) {
-                        throw DeadlyImportError(parseErrorMessage);
-                    }
-                    vocabulary.attributeValueTable.push_back(parseEncodedCharacterString3());
-                }
-            }
-            if (b1 & 0x0008) {
-                // Parse content character chunks (C.2.5.4)
-                for (size_t len = parseSequenceLen(); len > 0; --len) {
-                    if (dataEnd - dataP < 1) {
-                        throw DeadlyImportError(parseErrorMessage);
-                    }
-                    vocabulary.charactersTable.push_back(parseEncodedCharacterString3());
-                }
-            }
-            if (b1 & 0x0004) {
-                // Parse other strings (C.2.5.4)
-                for (size_t len = parseSequenceLen(); len > 0; --len) {
-                    if (dataEnd - dataP < 1) {
-                        throw DeadlyImportError(parseErrorMessage);
-                    }
-                    vocabulary.otherStringTable.push_back(parseEncodedCharacterString3());
-                }
-            }
-            if (b1 & 0x0002) {
-                // Parse element name surrogates (C.2.5.5)
-                for (size_t len = parseSequenceLen(); len > 0; --len) {
-                    vocabulary.elementNameTable.push_back(parseNameSurrogate());
-                }
-            }
-            if (b1 & 0x0001) {
-                // Parse attribute name surrogates (C.2.5.5)
-                for (size_t len = parseSequenceLen(); len > 0; --len) {
-                    vocabulary.attributeNameTable.push_back(parseNameSurrogate());
-                }
-            }
-        }
-        if (b & 0x10) {
-            // Parse notations (C.2.6)
-            for (;;) {
-                if (dataEnd - dataP < 1) {
-                    throw DeadlyImportError(parseErrorMessage);
-                }
-                uint8_t b1 = *dataP++;
-                if (b1 == 0xf0) {
-                    break;
-                }
-                if ((b1 & 0xfc) != 0xc0) {
-                    throw DeadlyImportError(parseErrorMessage);
-                }
-                /* C.11 */
-                /*const std::string &name =*/ parseIdentifyingStringOrIndex(vocabulary.otherNCNameTable);
-                if (b1 & 0x02) {
-                    /*const std::string &systemId =*/ parseIdentifyingStringOrIndex(vocabulary.otherURITable);
-                }
-                if (b1 & 0x01) {
-                    /*const std::string &publicId =*/ parseIdentifyingStringOrIndex(vocabulary.otherURITable);
-                }
-            }
-        }
-        if (b & 0x08) {
-            // Parse unparsed entities (C.2.7)
-            for (;;) {
-                if (dataEnd - dataP < 1) {
-                    throw DeadlyImportError(parseErrorMessage);
-                }
-                uint8_t b1 = *dataP++;
-                if (b1 == 0xf0) {
-                    break;
-                }
-                if ((b1 & 0xfe) != 0xd0) {
-                    throw DeadlyImportError(parseErrorMessage);
-                }
-                /* C.10 */
-                /*const std::string &name =*/ parseIdentifyingStringOrIndex(vocabulary.otherNCNameTable);
-                /*const std::string &systemId =*/ parseIdentifyingStringOrIndex(vocabulary.otherURITable);
-                if (b1 & 0x01) {
-                    /*const std::string &publicId =*/ parseIdentifyingStringOrIndex(vocabulary.otherURITable);
-                }
-                /*const std::string &notationName =*/ parseIdentifyingStringOrIndex(vocabulary.otherNCNameTable);
-            }
-        }
-        if (b & 0x04) {
-            // Parse character encoding scheme (C.2.8)
-            if (dataEnd - dataP < 1) {
-                throw DeadlyImportError(parseErrorMessage);
-            }
-            /*std::string characterEncodingScheme =*/ parseNonEmptyOctetString2();
-        }
-        if (b & 0x02) {
-            // Parse standalone flag (C.2.9)
-            if (dataEnd - dataP < 1) {
-                throw DeadlyImportError(parseErrorMessage);
-            }
-            uint8_t b1 = *dataP++;
-            if (b1 & 0xfe) {
-                throw DeadlyImportError(parseErrorMessage);
-            }
-            //bool standalone = b1 & 0x01;
-        }
-        if (b & 0x01) {
-            // Parse version (C.2.10)
-            if (dataEnd - dataP < 1) {
-                throw DeadlyImportError(parseErrorMessage);
-            }
-            /*std::shared_ptr<const FIValue> version =*/ parseNonIdentifyingStringOrIndex1(vocabulary.otherStringTable);
-        }
-    }
-
-    std::unique_ptr<uint8_t[]> data;
-    uint8_t *dataP, *dataEnd;
-    irr::io::EXML_NODE currentNodeType;
-    bool emptyElement;
-    bool headerPending;
-    bool terminatorPending;
-    Vocabulary vocabulary;
-    std::vector<Attribute> attributes;
-    std::stack<std::string> elementStack;
-    std::string nodeName;
-    std::map<std::string, std::unique_ptr<FIDecoder>> decoderMap;
-    std::map<std::string, const FIVocabulary*> vocabularyMap;
-
-    static const std::string EmptyString;
-    static std::shared_ptr<const FIValue> EmptyFIString;
-
-    static FIHexDecoder hexDecoder;
-    static FIBase64Decoder base64Decoder;
-    static FIShortDecoder shortDecoder;
-    static FIIntDecoder intDecoder;
-    static FILongDecoder longDecoder;
-    static FIBoolDecoder boolDecoder;
-    static FIFloatDecoder floatDecoder;
-    static FIDoubleDecoder doubleDecoder;
-    static FIUUIDDecoder uuidDecoder;
-    static FICDATADecoder cdataDecoder;
-    static FIDecoder *defaultDecoder[32];
-};
-
-const std::string CFIReaderImpl::EmptyString;
-std::shared_ptr<const FIValue> CFIReaderImpl::EmptyFIString = FIStringValue::create(std::string());
-
-FIHexDecoder CFIReaderImpl::hexDecoder;
-FIBase64Decoder CFIReaderImpl::base64Decoder;
-FIShortDecoder CFIReaderImpl::shortDecoder;
-FIIntDecoder CFIReaderImpl::intDecoder;
-FILongDecoder CFIReaderImpl::longDecoder;
-FIBoolDecoder CFIReaderImpl::boolDecoder;
-FIFloatDecoder CFIReaderImpl::floatDecoder;
-FIDoubleDecoder CFIReaderImpl::doubleDecoder;
-FIUUIDDecoder CFIReaderImpl::uuidDecoder;
-FICDATADecoder CFIReaderImpl::cdataDecoder;
-
-FIDecoder *CFIReaderImpl::defaultDecoder[32] = {
-    &hexDecoder,
-    &base64Decoder,
-    &shortDecoder,
-    &intDecoder,
-    &longDecoder,
-    &boolDecoder,
-    &floatDecoder,
-    &doubleDecoder,
-    &uuidDecoder,
-    &cdataDecoder
-};
-
-class CXMLReaderImpl : public FIReader
-{
-public:
-
-    //! Constructor
-    CXMLReaderImpl(std::unique_ptr<irr::io::IIrrXMLReader<char, irr::io::IXMLBase>> reader_)
-    : reader(std::move(reader_))
-    {}
-
-    virtual ~CXMLReaderImpl() {}
-
-    virtual bool read() /*override*/ {
-        return reader->read();
-    }
-
-    virtual irr::io::EXML_NODE getNodeType() const /*override*/ {
-        return reader->getNodeType();
-    }
-
-    virtual int getAttributeCount() const /*override*/ {
-        return reader->getAttributeCount();
-    }
-
-    virtual const char* getAttributeName(int idx) const /*override*/ {
-        return reader->getAttributeName(idx);
-    }
-
-    virtual const char* getAttributeValue(int idx) const /*override*/ {
-        return reader->getAttributeValue(idx);
-    }
-
-    virtual const char* getAttributeValue(const char* name) const /*override*/ {
-        return reader->getAttributeValue(name);
-    }
-
-    virtual const char* getAttributeValueSafe(const char* name) const /*override*/ {
-        return reader->getAttributeValueSafe(name);
-    }
-
-    virtual int getAttributeValueAsInt(const char* name) const /*override*/ {
-        return reader->getAttributeValueAsInt(name);
-    }
-
-    virtual int getAttributeValueAsInt(int idx) const /*override*/ {
-        return reader->getAttributeValueAsInt(idx);
-    }
-
-    virtual float getAttributeValueAsFloat(const char* name) const /*override*/ {
-        return reader->getAttributeValueAsFloat(name);
-    }
-
-    virtual float getAttributeValueAsFloat(int idx) const /*override*/ {
-        return reader->getAttributeValueAsFloat(idx);
-    }
-
-    virtual const char* getNodeName() const /*override*/ {
-        return reader->getNodeName();
-    }
-
-    virtual const char* getNodeData() const /*override*/ {
-        return reader->getNodeData();
-    }
-
-    virtual bool isEmptyElement() const /*override*/ {
-        return reader->isEmptyElement();
-    }
-
-    virtual irr::io::ETEXT_FORMAT getSourceFormat() const /*override*/ {
-        return reader->getSourceFormat();
-    }
-
-    virtual irr::io::ETEXT_FORMAT getParserFormat() const /*override*/ {
-        return reader->getParserFormat();
-    }
-
-    virtual std::shared_ptr<const FIValue> getAttributeEncodedValue(int /*idx*/) const /*override*/ {
-        return nullptr;
-    }
-
-    virtual std::shared_ptr<const FIValue> getAttributeEncodedValue(const char* /*name*/) const /*override*/ {
-        return nullptr;
-    }
-
-    virtual void registerDecoder(const std::string & /*algorithmUri*/, std::unique_ptr<FIDecoder> /*decoder*/) /*override*/ {}
-
-
-    virtual void registerVocabulary(const std::string &/*vocabularyUri*/, const FIVocabulary * /*vocabulary*/) /*override*/ {}
-
-private:
-
-    std::unique_ptr<irr::io::IIrrXMLReader<char, irr::io::IXMLBase>> reader;
-};
-
-static std::unique_ptr<uint8_t[]> readFile(IOStream *stream, size_t &size, bool &isFI) {
-    size = stream->FileSize();
-    std::unique_ptr<uint8_t[]> data = std::unique_ptr<uint8_t[]>(new uint8_t[size]);
-    if (stream->Read(data.get(), size, 1) != 1) {
-        size = 0;
-        data.reset();
-    }
-    isFI = parseMagic(data.get(), data.get() + size) > 0;
-    return data;
-}
-
-std::unique_ptr<FIReader> FIReader::create(IOStream *stream)
-{
-    size_t size;
-    bool isFI;
-    auto data = readFile(stream, size, isFI);
-    if (isFI) {
-        return std::unique_ptr<FIReader>(new CFIReaderImpl(std::move(data), size));
-    }
-    else {
-        auto memios = std::unique_ptr<MemoryIOStream>(new MemoryIOStream(data.release(), size, true));
-        auto callback = std::unique_ptr<CIrrXML_IOStreamReader>(new CIrrXML_IOStreamReader(memios.get()));
-        return std::unique_ptr<FIReader>(new CXMLReaderImpl(std::unique_ptr<irr::io::IIrrXMLReader<char, irr::io::IXMLBase>>(createIrrXMLReader(callback.get()))));
-    }
-}
-
-}// namespace Assimp
-
-#endif // !ASSIMP_BUILD_NO_X3D_IMPORTER
diff --git a/Engine/lib/assimp/code/X3D/FIReader.hpp b/Engine/lib/assimp/code/X3D/FIReader.hpp
deleted file mode 100644
index 2c92239ac..000000000
--- a/Engine/lib/assimp/code/X3D/FIReader.hpp
+++ /dev/null
@@ -1,192 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-/// \file   FIReader.hpp
-/// \brief  Reader for Fast Infoset encoded binary XML files.
-/// \date   2017
-/// \author Patrick Daehne
-
-#ifndef INCLUDED_AI_FI_READER_H
-#define INCLUDED_AI_FI_READER_H
-
-#ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
-
-//#include <wchar.h>
-#include <string>
-#include <memory>
-#include <cerrno>
-#include <cwchar>
-#include <vector>
-//#include <stdio.h>
-//#include <cstdint>
-#ifdef ASSIMP_USE_HUNTER
-#  include <irrXML/irrXML.h>
-#else
-#  include <irrXML.h>
-#endif
-
-namespace Assimp {
-
-struct FIValue {
-    virtual const std::string &toString() const = 0;
-    virtual ~FIValue() {}
-};
-
-struct FIStringValue: public FIValue {
-    std::string value;
-    static std::shared_ptr<FIStringValue> create(std::string &&value);
-};
-
-struct FIByteValue: public FIValue {
-    std::vector<uint8_t> value;
-};
-
-struct FIHexValue: public FIByteValue {
-    static std::shared_ptr<FIHexValue> create(std::vector<uint8_t> &&value);
-};
-
-struct FIBase64Value: public FIByteValue {
-    static std::shared_ptr<FIBase64Value> create(std::vector<uint8_t> &&value);
-};
-
-struct FIShortValue: public FIValue {
-    std::vector<int16_t> value;
-    static std::shared_ptr<FIShortValue> create(std::vector<int16_t> &&value);
-};
-
-struct FIIntValue: public FIValue {
-    std::vector<int32_t> value;
-    static std::shared_ptr<FIIntValue> create(std::vector<int32_t> &&value);
-};
-
-struct FILongValue: public FIValue {
-    std::vector<int64_t> value;
-    static std::shared_ptr<FILongValue> create(std::vector<int64_t> &&value);
-};
-
-struct FIBoolValue: public FIValue {
-    std::vector<bool> value;
-    static std::shared_ptr<FIBoolValue> create(std::vector<bool> &&value);
-};
-
-struct FIFloatValue: public FIValue {
-    std::vector<float> value;
-    static std::shared_ptr<FIFloatValue> create(std::vector<float> &&value);
-};
-
-struct FIDoubleValue: public FIValue {
-    std::vector<double> value;
-    static std::shared_ptr<FIDoubleValue> create(std::vector<double> &&value);
-};
-
-struct FIUUIDValue: public FIByteValue {
-    static std::shared_ptr<FIUUIDValue> create(std::vector<uint8_t> &&value);
-};
-
-struct FICDATAValue: public FIStringValue {
-    static std::shared_ptr<FICDATAValue> create(std::string &&value);
-};
-
-struct FIDecoder {
-    virtual std::shared_ptr<const FIValue> decode(const uint8_t *data, size_t len) = 0;
-    virtual ~FIDecoder() {}
-};
-
-struct FIQName {
-    const char *name;
-    const char *prefix;
-    const char *uri;
-};
-
-struct FIVocabulary {
-    const char **restrictedAlphabetTable;
-    size_t restrictedAlphabetTableSize;
-    const char **encodingAlgorithmTable;
-    size_t encodingAlgorithmTableSize;
-    const char **prefixTable;
-    size_t prefixTableSize;
-    const char **namespaceNameTable;
-    size_t namespaceNameTableSize;
-    const char **localNameTable;
-    size_t localNameTableSize;
-    const char **otherNCNameTable;
-    size_t otherNCNameTableSize;
-    const char **otherURITable;
-    size_t otherURITableSize;
-    const std::shared_ptr<const FIValue> *attributeValueTable;
-    size_t attributeValueTableSize;
-    const std::shared_ptr<const FIValue> *charactersTable;
-    size_t charactersTableSize;
-    const std::shared_ptr<const FIValue> *otherStringTable;
-    size_t otherStringTableSize;
-    const FIQName *elementNameTable;
-    size_t elementNameTableSize;
-    const FIQName *attributeNameTable;
-    size_t attributeNameTableSize;
-};
-
-class IOStream;
-
-class FIReader: public irr::io::IIrrXMLReader<char, irr::io::IXMLBase> {
-public:
-	virtual ~FIReader();
-    virtual std::shared_ptr<const FIValue> getAttributeEncodedValue(int idx) const = 0;
-
-    virtual std::shared_ptr<const FIValue> getAttributeEncodedValue(const char *name) const = 0;
-
-    virtual void registerDecoder(const std::string &algorithmUri, std::unique_ptr<FIDecoder> decoder) = 0;
-
-    virtual void registerVocabulary(const std::string &vocabularyUri, const FIVocabulary *vocabulary) = 0;
-
-    static std::unique_ptr<FIReader> create(IOStream *stream);
-
-};// class IFIReader
-
-inline
-FIReader::~FIReader() {
-	// empty
-}
-
-}// namespace Assimp
-
-#endif // #ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
-
-#endif // INCLUDED_AI_FI_READER_H
diff --git a/Engine/lib/assimp/code/X3D/X3DExporter.cpp b/Engine/lib/assimp/code/X3D/X3DExporter.cpp
deleted file mode 100644
index e5eeb0886..000000000
--- a/Engine/lib/assimp/code/X3D/X3DExporter.cpp
+++ /dev/null
@@ -1,735 +0,0 @@
-/// \file   X3DExporter.cpp
-/// \brief  X3D-format files exporter for Assimp. Implementation.
-/// \date   2016
-/// \author smal.root@gmail.com
-
-#ifndef ASSIMP_BUILD_NO_EXPORT
-#ifndef ASSIMP_BUILD_NO_X3D_EXPORTER
-
-#include "X3DExporter.hpp"
-
-// Header files, Assimp.
-#include <assimp/Exceptional.h>
-#include <assimp/StringUtils.h>
-#include <assimp/Exporter.hpp>
-#include <assimp/IOSystem.hpp>
-
-using namespace std;
-
-namespace Assimp
-{
-
-void ExportSceneX3D(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* pProperties)
-{
-	X3DExporter exporter(pFile, pIOSystem, pScene, pProperties);
-}
-
-}// namespace Assimp
-
-namespace Assimp
-{
-
-void X3DExporter::IndentationStringSet(const size_t pNewLevel)
-{
-	if(pNewLevel > mIndentationString.size())
-	{
-		if(pNewLevel > mIndentationString.capacity()) mIndentationString.reserve(pNewLevel + 1);
-
-		for(size_t i = 0, i_e = pNewLevel - mIndentationString.size(); i < i_e; i++) mIndentationString.push_back('\t');
-	}
-	else if(pNewLevel < mIndentationString.size())
-	{
-		mIndentationString.resize(pNewLevel);
-	}
-}
-
-void X3DExporter::XML_Write(const string& pData)
-{
-	if(pData.size() == 0) return;
-	if(mOutFile->Write((void*)pData.data(), pData.length(), 1) != 1) throw DeadlyExportError("Failed to write scene data!");
-}
-
-aiMatrix4x4 X3DExporter::Matrix_GlobalToCurrent(const aiNode& pNode) const
-{
-aiNode* cur_node;
-std::list<aiMatrix4x4> matr;
-aiMatrix4x4 out_matr;
-
-	// starting walk from current element to root
-	matr.push_back(pNode.mTransformation);
-	cur_node = pNode.mParent;
-	if(cur_node != nullptr)
-	{
-		do
-		{
-			matr.push_back(cur_node->mTransformation);
-			cur_node = cur_node->mParent;
-		} while(cur_node != nullptr);
-	}
-
-	// multiplicate all matrices in reverse order
-	for(std::list<aiMatrix4x4>::reverse_iterator rit = matr.rbegin(); rit != matr.rend(); ++rit) out_matr = out_matr * (*rit);
-
-	return out_matr;
-}
-
-void X3DExporter::AttrHelper_FloatToString(const float pValue, std::string& pTargetString)
-{
-	pTargetString = to_string(pValue);
-	AttrHelper_CommaToPoint(pTargetString);
-}
-
-void X3DExporter::AttrHelper_Vec3DArrToString(const aiVector3D* pArray, const size_t pArray_Size, string& pTargetString)
-{
-	pTargetString.clear();
-	pTargetString.reserve(pArray_Size * 6);// (Number + space) * 3.
-	for(size_t idx = 0; idx < pArray_Size; idx++)
-		pTargetString.append(to_string(pArray[idx].x) + " " + to_string(pArray[idx].y) + " " + to_string(pArray[idx].z) + " ");
-
-	// remove last space symbol.
-	pTargetString.resize(pTargetString.length() - 1);
-	AttrHelper_CommaToPoint(pTargetString);
-}
-
-void X3DExporter::AttrHelper_Vec2DArrToString(const aiVector2D* pArray, const size_t pArray_Size, std::string& pTargetString)
-{
-	pTargetString.clear();
-	pTargetString.reserve(pArray_Size * 4);// (Number + space) * 2.
-	for(size_t idx = 0; idx < pArray_Size; idx++)
-		pTargetString.append(to_string(pArray[idx].x) + " " + to_string(pArray[idx].y) + " ");
-
-	// remove last space symbol.
-	pTargetString.resize(pTargetString.length() - 1);
-	AttrHelper_CommaToPoint(pTargetString);
-}
-
-void X3DExporter::AttrHelper_Vec3DAsVec2fArrToString(const aiVector3D* pArray, const size_t pArray_Size, string& pTargetString)
-{
-	pTargetString.clear();
-	pTargetString.reserve(pArray_Size * 4);// (Number + space) * 2.
-	for(size_t idx = 0; idx < pArray_Size; idx++)
-		pTargetString.append(to_string(pArray[idx].x) + " " + to_string(pArray[idx].y) + " ");
-
-	// remove last space symbol.
-	pTargetString.resize(pTargetString.length() - 1);
-	AttrHelper_CommaToPoint(pTargetString);
-}
-
-void X3DExporter::AttrHelper_Col4DArrToString(const aiColor4D* pArray, const size_t pArray_Size, string& pTargetString)
-{
-	pTargetString.clear();
-	pTargetString.reserve(pArray_Size * 8);// (Number + space) * 4.
-	for(size_t idx = 0; idx < pArray_Size; idx++)
-		pTargetString.append(to_string(pArray[idx].r) + " " + to_string(pArray[idx].g) + " " + to_string(pArray[idx].b) + " " +
-								to_string(pArray[idx].a) + " ");
-
-	// remove last space symbol.
-	pTargetString.resize(pTargetString.length() - 1);
-	AttrHelper_CommaToPoint(pTargetString);
-}
-
-void X3DExporter::AttrHelper_Col3DArrToString(const aiColor3D* pArray, const size_t pArray_Size, std::string& pTargetString)
-{
-	pTargetString.clear();
-	pTargetString.reserve(pArray_Size * 6);// (Number + space) * 3.
-	for(size_t idx = 0; idx < pArray_Size; idx++)
-		pTargetString.append(to_string(pArray[idx].r) + " " + to_string(pArray[idx].g) + " " + to_string(pArray[idx].b) + " ");
-
-	// remove last space symbol.
-	pTargetString.resize(pTargetString.length() - 1);
-	AttrHelper_CommaToPoint(pTargetString);
-}
-
-void X3DExporter::AttrHelper_Color3ToAttrList(std::list<SAttribute>& pList, const std::string& pName, const aiColor3D& pValue, const aiColor3D& pDefaultValue)
-{
-string tstr;
-
-	if(pValue == pDefaultValue) return;
-
-	AttrHelper_Col3DArrToString(&pValue, 1, tstr);
-	pList.push_back({pName, tstr});
-}
-
-void X3DExporter::AttrHelper_FloatToAttrList(std::list<SAttribute>& pList, const string& pName, const float pValue, const float pDefaultValue)
-{
-string tstr;
-
-	if(pValue == pDefaultValue) return;
-
-	AttrHelper_FloatToString(pValue, tstr);
-	pList.push_back({pName, tstr});
-}
-
-void X3DExporter::NodeHelper_OpenNode(const string& pNodeName, const size_t pTabLevel, const bool pEmptyElement, const list<SAttribute>& pAttrList)
-{
-	// Write indentation.
-	IndentationStringSet(pTabLevel);
-	XML_Write(mIndentationString);
-	// Begin of the element
-	XML_Write("<" + pNodeName);
-	// Write attributes
-	for(const SAttribute& attr: pAttrList) { XML_Write(" " + attr.Name + "='" + attr.Value + "'"); }
-
-	// End of the element
-	if(pEmptyElement)
-	{
-		XML_Write("/>\n");
-	}
-	else
-	{
-		XML_Write(">\n");
-	}
-}
-
-void X3DExporter::NodeHelper_OpenNode(const string& pNodeName, const size_t pTabLevel, const bool pEmptyElement)
-{
-const list<SAttribute> attr_list;
-
-	NodeHelper_OpenNode(pNodeName, pTabLevel, pEmptyElement, attr_list);
-}
-
-void X3DExporter::NodeHelper_CloseNode(const string& pNodeName, const size_t pTabLevel)
-{
-	// Write indentation.
-	IndentationStringSet(pTabLevel);
-	XML_Write(mIndentationString);
-	// Write element
-	XML_Write("</" + pNodeName + ">\n");
-}
-
-void X3DExporter::Export_Node(const aiNode *pNode, const size_t pTabLevel)
-{
-bool transform = false;
-list<SAttribute> attr_list;
-
-	// In Assimp lights is stored in next way: light source store in mScene->mLights and in node tree must present aiNode with name same as
-	// light source has. Considering it we must compare every aiNode name with light sources names. Why not to look where ligths is present
-	// and save them to fili? Because corresponding aiNode can be already written to file and we can only add information to file not to edit.
-	if(CheckAndExport_Light(*pNode, pTabLevel)) return;
-
-	// Check if need DEF.
-	if(pNode->mName.length) attr_list.push_back({"DEF", pNode->mName.C_Str()});
-
-	// Check if need <Transformation> node against <Group>.
-	if(!pNode->mTransformation.IsIdentity())
-	{
-		auto Vector2String = [this](const aiVector3D pVector) -> string
-		{
-			string tstr = to_string(pVector.x) + " " + to_string(pVector.y) + " " + to_string(pVector.z);
-
-			AttrHelper_CommaToPoint(tstr);
-
-			return tstr;
-		};
-
-		auto Rotation2String = [this](const aiVector3D pAxis, const ai_real pAngle) -> string
-		{
-			string tstr = to_string(pAxis.x) + " " + to_string(pAxis.y) + " " + to_string(pAxis.z) + " " + to_string(pAngle);
-
-			AttrHelper_CommaToPoint(tstr);
-
-			return tstr;
-		};
-
-		aiVector3D scale, translate, rotate_axis;
-		ai_real rotate_angle;
-
-		transform = true;
-		pNode->mTransformation.Decompose(scale, rotate_axis, rotate_angle, translate);
-		// Check if values different from default
-		if((rotate_angle != 0) && (rotate_axis.Length() > 0))
-			attr_list.push_back({"rotation", Rotation2String(rotate_axis, rotate_angle)});
-
-        if(!scale.Equal({1.0,1.0,1.0})) {
-            attr_list.push_back({"scale", Vector2String(scale)});
-        }
-        if(translate.Length() > 0) {
-            attr_list.push_back({"translation", Vector2String(translate)});
-        }
-	}
-
-	// Begin node if need.
-	if(transform)
-		NodeHelper_OpenNode("Transform", pTabLevel, false, attr_list);
-	else
-		NodeHelper_OpenNode("Group", pTabLevel);
-
-	// Export metadata
-	if(pNode->mMetaData != nullptr)
-	{
-		for(size_t idx_prop = 0; idx_prop < pNode->mMetaData->mNumProperties; idx_prop++)
-		{
-			const aiString* key;
-			const aiMetadataEntry* entry;
-
-			if(pNode->mMetaData->Get(idx_prop, key, entry))
-			{
-				switch(entry->mType)
-				{
-					case AI_BOOL:
-						Export_MetadataBoolean(*key, *static_cast<bool*>(entry->mData), pTabLevel + 1);
-						break;
-					case AI_DOUBLE:
-						Export_MetadataDouble(*key, *static_cast<double*>(entry->mData), pTabLevel + 1);
-						break;
-					case AI_FLOAT:
-						Export_MetadataFloat(*key, *static_cast<float*>(entry->mData), pTabLevel + 1);
-						break;
-					case AI_INT32:
-						Export_MetadataInteger(*key, *static_cast<int32_t*>(entry->mData), pTabLevel + 1);
-						break;
-					case AI_AISTRING:
-						Export_MetadataString(*key, *static_cast<aiString*>(entry->mData), pTabLevel + 1);
-						break;
-					default:
-						LogError("Unsupported metadata type: " + to_string(entry->mType));
-						break;
-				}// switch(entry->mType)
-			}
-		}
-	}// if(pNode->mMetaData != nullptr)
-
-	// Export meshes.
-	for(size_t idx_mesh = 0; idx_mesh < pNode->mNumMeshes; idx_mesh++) Export_Mesh(pNode->mMeshes[idx_mesh], pTabLevel + 1);
-	// Export children.
-	for(size_t idx_node = 0; idx_node < pNode->mNumChildren; idx_node++) Export_Node(pNode->mChildren[idx_node], pTabLevel + 1);
-
-	// End node if need.
-	if(transform)
-		NodeHelper_CloseNode("Transform", pTabLevel);
-	else
-		NodeHelper_CloseNode("Group", pTabLevel);
-}
-
-void X3DExporter::Export_Mesh(const size_t pIdxMesh, const size_t pTabLevel)
-{
-const char* NodeName_IFS = "IndexedFaceSet";
-const char* NodeName_Shape = "Shape";
-
-list<SAttribute> attr_list;
-aiMesh& mesh = *mScene->mMeshes[pIdxMesh];// create alias for conveniance.
-
-	// Check if mesh already defined early.
-	if(mDEF_Map_Mesh.find(pIdxMesh) != mDEF_Map_Mesh.end())
-	{
-		// Mesh already defined, just refer to it
-		attr_list.push_back({"USE", mDEF_Map_Mesh.at(pIdxMesh)});
-		NodeHelper_OpenNode(NodeName_Shape, pTabLevel, true, attr_list);
-
-		return;
-	}
-
-	string mesh_name(mesh.mName.C_Str() + string("_IDX_") + to_string(pIdxMesh));// Create mesh name
-
-	// Define mesh name.
-	attr_list.push_back({"DEF", mesh_name});
-	mDEF_Map_Mesh[pIdxMesh] = mesh_name;
-
-	//
-	// "Shape" node.
-	//
-	NodeHelper_OpenNode(NodeName_Shape, pTabLevel, false, attr_list);
-	attr_list.clear();
-
-	//
-	// "Appearance" node.
-	//
-	Export_Material(mesh.mMaterialIndex, pTabLevel + 1);
-
-	//
-	// "IndexedFaceSet" node.
-	//
-	// Fill attributes which differ from default. In Assimp for colors, vertices and normals used one indices set. So, only "coordIndex" must be set.
-	string coordIndex;
-
-	// fill coordinates index.
-	coordIndex.reserve(mesh.mNumVertices * 4);// Index + space + Face delimiter
-	for(size_t idx_face = 0; idx_face < mesh.mNumFaces; idx_face++)
-	{
-		const aiFace& face_cur = mesh.mFaces[idx_face];
-
-		for(size_t idx_vert = 0; idx_vert < face_cur.mNumIndices; idx_vert++)
-		{
-			coordIndex.append(to_string(face_cur.mIndices[idx_vert]) + " ");
-		}
-
-		coordIndex.append("-1 ");// face delimiter.
-	}
-
-	// remove last space symbol.
-	coordIndex.resize(coordIndex.length() - 1);
-	attr_list.push_back({"coordIndex", coordIndex});
-	// create node
-	NodeHelper_OpenNode(NodeName_IFS, pTabLevel + 1, false, attr_list);
-	attr_list.clear();
-	// Child nodes for "IndexedFaceSet" needed when used colors, textures or normals.
-	string attr_value;
-
-	// Export <Coordinate>
-	AttrHelper_Vec3DArrToString(mesh.mVertices, mesh.mNumVertices, attr_value);
-	attr_list.push_back({"point", attr_value});
-	NodeHelper_OpenNode("Coordinate", pTabLevel + 2, true, attr_list);
-	attr_list.clear();
-
-	// Export <ColorRGBA>
-	if(mesh.HasVertexColors(0))
-	{
-		AttrHelper_Col4DArrToString(mesh.mColors[0], mesh.mNumVertices, attr_value);
-		attr_list.push_back({"color", attr_value});
-		NodeHelper_OpenNode("ColorRGBA", pTabLevel + 2, true, attr_list);
-		attr_list.clear();
-	}
-
-	// Export <TextureCoordinate>
-	if(mesh.HasTextureCoords(0))
-	{
-		AttrHelper_Vec3DAsVec2fArrToString(mesh.mTextureCoords[0], mesh.mNumVertices, attr_value);
-		attr_list.push_back({"point", attr_value});
-		NodeHelper_OpenNode("TextureCoordinate", pTabLevel + 2, true, attr_list);
-		attr_list.clear();
-	}
-
-	// Export <Normal>
-	if(mesh.HasNormals())
-	{
-		AttrHelper_Vec3DArrToString(mesh.mNormals, mesh.mNumVertices, attr_value);
-		attr_list.push_back({"vector", attr_value});
-		NodeHelper_OpenNode("Normal", pTabLevel + 2, true, attr_list);
-		attr_list.clear();
-	}
-
-	//
-	// Close opened nodes.
-	//
-	NodeHelper_CloseNode(NodeName_IFS, pTabLevel + 1);
-	NodeHelper_CloseNode(NodeName_Shape, pTabLevel);
-}
-
-void X3DExporter::Export_Material(const size_t pIdxMaterial, const size_t pTabLevel)
-{
-const char* NodeName_A = "Appearance";
-
-list<SAttribute> attr_list;
-aiMaterial& material = *mScene->mMaterials[pIdxMaterial];// create alias for conveniance.
-
-	// Check if material already defined early.
-	if(mDEF_Map_Material.find(pIdxMaterial) != mDEF_Map_Material.end())
-	{
-		// Material already defined, just refer to it
-		attr_list.push_back({"USE", mDEF_Map_Material.at(pIdxMaterial)});
-		NodeHelper_OpenNode(NodeName_A, pTabLevel, true, attr_list);
-
-		return;
-	}
-
-	string material_name(string("_IDX_") + to_string(pIdxMaterial));// Create material name
-	aiString ai_mat_name;
-
-	if(material.Get(AI_MATKEY_NAME, ai_mat_name) == AI_SUCCESS) material_name.insert(0, ai_mat_name.C_Str());
-
-	// Define material name.
-	attr_list.push_back({"DEF", material_name});
-	mDEF_Map_Material[pIdxMaterial] = material_name;
-
-	//
-	// "Appearance" node.
-	//
-	NodeHelper_OpenNode(NodeName_A, pTabLevel, false, attr_list);
-	attr_list.clear();
-
-	//
-	// "Material" node.
-	//
-	{
-		auto Color4ToAttrList = [&](const string& pAttrName, const aiColor4D& pAttrValue, const aiColor3D& pAttrDefaultValue)
-		{
-			string tstr;
-
-			if(aiColor3D(pAttrValue.r, pAttrValue.g, pAttrValue.b) != pAttrDefaultValue)
-			{
-				AttrHelper_Col4DArrToString(&pAttrValue, 1, tstr);
-				attr_list.push_back({pAttrName, tstr});
-			}
-		};
-
-		float tvalf;
-		aiColor3D color3;
-		aiColor4D color4;
-
-		// ambientIntensity="0.2"     SFFloat [inputOutput]
-		if(material.Get(AI_MATKEY_COLOR_AMBIENT, color3) == AI_SUCCESS)
-			AttrHelper_FloatToAttrList(attr_list, "ambientIntensity", (color3.r + color3.g + color3.b) / 3.0f, 0.2f);
-		else if(material.Get(AI_MATKEY_COLOR_AMBIENT, color4) == AI_SUCCESS)
-			AttrHelper_FloatToAttrList(attr_list, "ambientIntensity", (color4.r + color4.g + color4.b) / 3.0f, 0.2f);
-
-		// diffuseColor="0.8 0.8 0.8" SFColor [inputOutput]
-		if(material.Get(AI_MATKEY_COLOR_DIFFUSE, color3) == AI_SUCCESS)
-			AttrHelper_Color3ToAttrList(attr_list, "diffuseColor", color3, aiColor3D(0.8f, 0.8f, 0.8f));
-		else if(material.Get(AI_MATKEY_COLOR_DIFFUSE, color4) == AI_SUCCESS)
-			Color4ToAttrList("diffuseColor", color4, aiColor3D(0.8f, 0.8f, 0.8f));
-
-		// emissiveColor="0 0 0"      SFColor [inputOutput]
-		if(material.Get(AI_MATKEY_COLOR_EMISSIVE, color3) == AI_SUCCESS)
-			AttrHelper_Color3ToAttrList(attr_list, "emissiveColor", color3, aiColor3D(0, 0, 0));
-		else if(material.Get(AI_MATKEY_COLOR_EMISSIVE, color4) == AI_SUCCESS)
-			Color4ToAttrList("emissiveColor", color4, aiColor3D(0, 0, 0));
-
-		// shininess="0.2"            SFFloat [inputOutput]
-		if(material.Get(AI_MATKEY_SHININESS, tvalf) == AI_SUCCESS) AttrHelper_FloatToAttrList(attr_list, "shininess", tvalf, 0.2f);
-
-		// specularColor="0 0 0"      SFColor [inputOutput]
-		if(material.Get(AI_MATKEY_COLOR_SPECULAR, color3) == AI_SUCCESS)
-			AttrHelper_Color3ToAttrList(attr_list, "specularColor", color3, aiColor3D(0, 0, 0));
-		else if(material.Get(AI_MATKEY_COLOR_SPECULAR, color4) == AI_SUCCESS)
-			Color4ToAttrList("specularColor", color4, aiColor3D(0, 0, 0));
-
-		// transparency="0"           SFFloat [inputOutput]
-		if(material.Get(AI_MATKEY_OPACITY, tvalf) == AI_SUCCESS)
-		{
-			if(tvalf > 1) tvalf = 1;
-
-			tvalf = 1.0f - tvalf;
-			AttrHelper_FloatToAttrList(attr_list, "transparency", tvalf, 0);
-		}
-
-		NodeHelper_OpenNode("Material", pTabLevel + 1, true, attr_list);
-		attr_list.clear();
-	}// "Material" node. END.
-
-	//
-	// "ImageTexture" node.
-	//
-	{
-		auto RepeatToAttrList = [&](const string& pAttrName, const bool pAttrValue)
-		{
-			if(!pAttrValue) attr_list.push_back({pAttrName, "false"});
-		};
-
-		bool tvalb;
-		aiString tstring;
-
-		// url=""         MFString
-		if(material.Get(AI_MATKEY_TEXTURE_DIFFUSE(0), tstring) == AI_SUCCESS)
-		{
-			if(strncmp(tstring.C_Str(), AI_EMBEDDED_TEXNAME_PREFIX, strlen(AI_EMBEDDED_TEXNAME_PREFIX)) == 0)
-				LogError("Embedded texture is not supported");
-			else
-				attr_list.push_back({"url", string("\"") + tstring.C_Str() + "\""});
-		}
-
-		// repeatS="true" SFBool
-		if(material.Get(AI_MATKEY_MAPPINGMODE_U_DIFFUSE(0), tvalb) == AI_SUCCESS) RepeatToAttrList("repeatS", tvalb);
-
-		// repeatT="true" SFBool
-		if(material.Get(AI_MATKEY_MAPPINGMODE_V_DIFFUSE(0), tvalb) == AI_SUCCESS) RepeatToAttrList("repeatT", tvalb);
-
-		NodeHelper_OpenNode("ImageTexture", pTabLevel + 1, true, attr_list);
-		attr_list.clear();
-	}// "ImageTexture" node. END.
-
-	//
-	// "TextureTransform" node.
-	//
-	{
-		auto Vec2ToAttrList = [&](const string& pAttrName, const aiVector2D& pAttrValue, const aiVector2D& pAttrDefaultValue)
-		{
-			string tstr;
-
-			if(pAttrValue != pAttrDefaultValue)
-			{
-				AttrHelper_Vec2DArrToString(&pAttrValue, 1, tstr);
-				attr_list.push_back({pAttrName, tstr});
-			}
-		};
-
-		aiUVTransform transform;
-
-		if(material.Get(AI_MATKEY_UVTRANSFORM_DIFFUSE(0), transform) == AI_SUCCESS)
-		{
-			Vec2ToAttrList("translation", transform.mTranslation, aiVector2D(0, 0));
-			AttrHelper_FloatToAttrList(attr_list, "rotation", transform.mRotation, 0);
-			Vec2ToAttrList("scale", transform.mScaling, aiVector2D(1, 1));
-
-			NodeHelper_OpenNode("TextureTransform", pTabLevel + 1, true, attr_list);
-			attr_list.clear();
-		}
-	}// "TextureTransform" node. END.
-
-	//
-	// Close opened nodes.
-	//
-	NodeHelper_CloseNode(NodeName_A, pTabLevel);
-
-}
-
-void X3DExporter::Export_MetadataBoolean(const aiString& pKey, const bool pValue, const size_t pTabLevel)
-{
-list<SAttribute> attr_list;
-
-	attr_list.push_back({"name", pKey.C_Str()});
-	attr_list.push_back({"value", pValue ? "true" : "false"});
-	NodeHelper_OpenNode("MetadataBoolean", pTabLevel, true, attr_list);
-}
-
-void X3DExporter::Export_MetadataDouble(const aiString& pKey, const double pValue, const size_t pTabLevel)
-{
-list<SAttribute> attr_list;
-
-	attr_list.push_back({"name", pKey.C_Str()});
-	attr_list.push_back({"value", to_string(pValue)});
-	NodeHelper_OpenNode("MetadataDouble", pTabLevel, true, attr_list);
-}
-
-void X3DExporter::Export_MetadataFloat(const aiString& pKey, const float pValue, const size_t pTabLevel)
-{
-list<SAttribute> attr_list;
-
-	attr_list.push_back({"name", pKey.C_Str()});
-	attr_list.push_back({"value", to_string(pValue)});
-	NodeHelper_OpenNode("MetadataFloat", pTabLevel, true, attr_list);
-}
-
-void X3DExporter::Export_MetadataInteger(const aiString& pKey, const int32_t pValue, const size_t pTabLevel)
-{
-list<SAttribute> attr_list;
-
-	attr_list.push_back({"name", pKey.C_Str()});
-	attr_list.push_back({"value", to_string(pValue)});
-	NodeHelper_OpenNode("MetadataInteger", pTabLevel, true, attr_list);
-}
-
-void X3DExporter::Export_MetadataString(const aiString& pKey, const aiString& pValue, const size_t pTabLevel)
-{
-list<SAttribute> attr_list;
-
-	attr_list.push_back({"name", pKey.C_Str()});
-	attr_list.push_back({"value", pValue.C_Str()});
-	NodeHelper_OpenNode("MetadataString", pTabLevel, true, attr_list);
-}
-
-bool X3DExporter::CheckAndExport_Light(const aiNode& pNode, const size_t pTabLevel)
-{
-list<SAttribute> attr_list;
-
-auto Vec3ToAttrList = [&](const string& pAttrName, const aiVector3D& pAttrValue, const aiVector3D& pAttrDefaultValue)
-{
-	string tstr;
-
-	if(pAttrValue != pAttrDefaultValue)
-	{
-		AttrHelper_Vec3DArrToString(&pAttrValue, 1, tstr);
-		attr_list.push_back({pAttrName, tstr});
-	}
-};
-
-size_t idx_light;
-bool found = false;
-
-	// Name of the light source can not be empty.
-	if(pNode.mName.length == 0) return false;
-
-	// search for light with name like node has.
-	for(idx_light = 0; mScene->mNumLights; idx_light++)
-	{
-		if(pNode.mName == mScene->mLights[idx_light]->mName)
-		{
-			found = true;
-			break;
-		}
-	}
-
-	if(!found) return false;
-
-	// Light source is found.
-	const aiLight& light = *mScene->mLights[idx_light];// Alias for conveniance.
-
-	aiMatrix4x4 trafo_mat = Matrix_GlobalToCurrent(pNode).Inverse();
-
-	attr_list.push_back({"DEF", light.mName.C_Str()});
-	attr_list.push_back({"global", "true"});// "false" is not supported.
-	// ambientIntensity="0" SFFloat [inputOutput]
-	AttrHelper_FloatToAttrList(attr_list, "ambientIntensity", aiVector3D(light.mColorAmbient.r, light.mColorAmbient.g, light.mColorAmbient.b).Length(), 0);
-	// color="1 1 1"        SFColor [inputOutput]
-	AttrHelper_Color3ToAttrList(attr_list, "color", light.mColorDiffuse, aiColor3D(1, 1, 1));
-
-	switch(light.mType)
-	{
-		case aiLightSource_DIRECTIONAL:
-			{
-				aiVector3D direction = trafo_mat * light.mDirection;
-
-				Vec3ToAttrList("direction", direction, aiVector3D(0, 0, -1));
-				NodeHelper_OpenNode("DirectionalLight", pTabLevel, true, attr_list);
-			}
-
-			break;
-		case aiLightSource_POINT:
-			{
-				aiVector3D attenuation(light.mAttenuationConstant, light.mAttenuationLinear, light.mAttenuationQuadratic);
-				aiVector3D location = trafo_mat * light.mPosition;
-
-				Vec3ToAttrList("attenuation", attenuation, aiVector3D(1, 0, 0));
-				Vec3ToAttrList("location", location, aiVector3D(0, 0, 0));
-				NodeHelper_OpenNode("PointLight", pTabLevel, true, attr_list);
-			}
-
-			break;
-		case aiLightSource_SPOT:
-			{
-				aiVector3D attenuation(light.mAttenuationConstant, light.mAttenuationLinear, light.mAttenuationQuadratic);
-				aiVector3D location = trafo_mat * light.mPosition;
-				aiVector3D direction = trafo_mat * light.mDirection;
-
-				Vec3ToAttrList("attenuation", attenuation, aiVector3D(1, 0, 0));
-				Vec3ToAttrList("location", location, aiVector3D(0, 0, 0));
-				Vec3ToAttrList("direction", direction, aiVector3D(0, 0, -1));
-				AttrHelper_FloatToAttrList(attr_list, "beamWidth", light.mAngleInnerCone, 0.7854f);
-				AttrHelper_FloatToAttrList(attr_list, "cutOffAngle", light.mAngleOuterCone, 1.570796f);
-				NodeHelper_OpenNode("SpotLight", pTabLevel, true, attr_list);
-			}
-
-			break;
-		default:
-			throw DeadlyExportError("Unknown light type: " + to_string(light.mType));
-	}// switch(light.mType)
-
-	return true;
-}
-
-X3DExporter::X3DExporter(const char* pFileName, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/)
-	: mScene(pScene)
-{
-list<SAttribute> attr_list;
-
-	mOutFile = pIOSystem->Open(pFileName, "wt");
-	if(mOutFile == nullptr) throw DeadlyExportError("Could not open output .x3d file: " + string(pFileName));
-
-	// Begin document
-	XML_Write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
-	XML_Write("<!DOCTYPE X3D PUBLIC \"ISO//Web3D//DTD X3D 3.3//EN\" \"http://www.web3d.org/specifications/x3d-3.3.dtd\">\n");
-	// Root node
-	attr_list.push_back({"profile", "Interchange"});
-	attr_list.push_back({"version", "3.3"});
-	attr_list.push_back({"xmlns:xsd", "http://www.w3.org/2001/XMLSchema-instance"});
-	attr_list.push_back({"xsd:noNamespaceSchemaLocation", "http://www.web3d.org/specifications/x3d-3.3.xsd"});
-	NodeHelper_OpenNode("X3D", 0, false, attr_list);
-	attr_list.clear();
-	// <head>: meta data.
-	NodeHelper_OpenNode("head", 1);
-	XML_Write(mIndentationString + "<!-- All \"meta\" from this section tou will found in <Scene> node as MetadataString nodes. -->\n");
-	NodeHelper_CloseNode("head", 1);
-	// Scene node.
-	NodeHelper_OpenNode("Scene", 1);
-	Export_Node(mScene->mRootNode, 2);
-	NodeHelper_CloseNode("Scene", 1);
-	// Close Root node.
-	NodeHelper_CloseNode("X3D", 0);
-	// Cleanup
-	pIOSystem->Close(mOutFile);
-	mOutFile = nullptr;
-}
-
-}// namespace Assimp
-
-#endif // ASSIMP_BUILD_NO_X3D_EXPORTER
-#endif // ASSIMP_BUILD_NO_EXPORT
diff --git a/Engine/lib/assimp/code/X3D/X3DExporter.hpp b/Engine/lib/assimp/code/X3D/X3DExporter.hpp
deleted file mode 100644
index dc1650b5a..000000000
--- a/Engine/lib/assimp/code/X3D/X3DExporter.hpp
+++ /dev/null
@@ -1,235 +0,0 @@
-/// \file   X3DExporter.hpp
-/// \brief  X3D-format files exporter for Assimp.
-/// \date   2016
-/// \author smal.root@gmail.com
-// Thanks to acorn89 for support.
-
-#ifndef INCLUDED_AI_X3D_EXPORTER_H
-#define INCLUDED_AI_X3D_EXPORTER_H
-
-// Header files, Assimp.
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/Exporter.hpp>
-#include <assimp/material.h>
-#include <assimp/scene.h>
-
-// Header files, stdlib.
-#include <list>
-#include <string>
-
-namespace Assimp
-{
-
-/// \class X3DExporter
-/// Class which export aiScene to X3D file.
-///
-/// Limitations.
-///
-/// Pay attention that X3D is format for interactive graphic and simulations for web browsers. aiScene can not contain all features of the X3D format.
-/// Also, aiScene contain rasterized-like data. For example, X3D can describe circle all cylinder with one tag, but aiScene contain result of tessellation:
-/// vertices, faces etc. Yes, you can use algorithm for detecting figures or shapes, but that's not a good idea at all.
-///
-/// Supported nodes:
-///		Core component:
-///			"MetadataBoolean", "MetadataDouble", "MetadataFloat", "MetadataInteger", "MetadataSet", "MetadataString"
-///		Geometry3D component:
-///			"IndexedFaceSet"
-///		Grouping component:
-///			"Group", "Transform"
-///		Lighting component:
-///			"DirectionalLight", "PointLight", "SpotLight"
-///		Rendering component:
-///			"ColorRGBA", "Coordinate", "Normal"
-///		Shape component:
-///			"Shape", "Appearance", "Material"
-///		Texturing component:
-///			"ImageTexture", "TextureCoordinate", "TextureTransform"
-///
-class X3DExporter
-{
-	/***********************************************/
-	/******************** Types ********************/
-	/***********************************************/
-
-	struct SAttribute
-	{
-		const std::string Name;
-		const std::string Value;
-	};
-
-	/***********************************************/
-	/****************** Constants ******************/
-	/***********************************************/
-
-	const aiScene* const mScene;
-
-	/***********************************************/
-	/****************** Variables ******************/
-	/***********************************************/
-
-	IOStream* mOutFile;
-	std::map<size_t, std::string> mDEF_Map_Mesh;
-	std::map<size_t, std::string> mDEF_Map_Material;
-
-private:
-
-	std::string mIndentationString;
-
-	/***********************************************/
-	/****************** Functions ******************/
-	/***********************************************/
-
-	/// \fn void IndentationStringSet(const size_t pNewLevel)
-	/// Set value of the indentation string.
-	/// \param [in] pNewLevel - new level of the indentation.
-	void IndentationStringSet(const size_t pNewLevel);
-
-	/// \fn void XML_Write(const std::string& pData)
-	/// Write data to XML-file.
-	/// \param [in] pData - reference to string which must be written.
-	void XML_Write(const std::string& pData);
-
-	/// \fn aiMatrix4x4 Matrix_GlobalToCurrent(const aiNode& pNode) const
-	/// Calculate transformation matrix for transformation from global coordinate system to pointed aiNode.
-	/// \param [in] pNode - reference to local node.
-	/// \return calculated matrix.
-	aiMatrix4x4 Matrix_GlobalToCurrent(const aiNode& pNode) const;
-
-	/// \fn void AttrHelper_CommaToPoint(std::string& pStringWithComma)
-	/// Convert commas in string to points. That's needed because "std::to_string" result depends on locale (regional settings).
-	/// \param [in, out] pStringWithComma - reference to string, which must be modified.
-	void AttrHelper_CommaToPoint(std::string& pStringWithComma) { for(char& c: pStringWithComma) { if(c == ',') c = '.'; } }
-
-	/// \fn void AttrHelper_FloatToString(const float pValue, std::string& pTargetString)
-	/// Converts float to string.
-	/// \param [in] pValue - value for converting.
-	/// \param [out] pTargetString - reference to string where result will be placed. Will be cleared before using.
-	void AttrHelper_FloatToString(const float pValue, std::string& pTargetString);
-
-	/// \fn void AttrHelper_Vec3DArrToString(const aiVector3D* pArray, const size_t pArray_Size, std::string& pTargetString)
-	/// Converts array of vectors to string.
-	/// \param [in] pArray - pointer to array of vectors.
-	/// \param [in] pArray_Size - count of elements in array.
-	/// \param [out] pTargetString - reference to string where result will be placed. Will be cleared before using.
-	void AttrHelper_Vec3DArrToString(const aiVector3D* pArray, const size_t pArray_Size, std::string& pTargetString);
-
-	/// \fn void AttrHelper_Vec2DArrToString(const aiVector2D* pArray, const size_t pArray_Size, std::string& pTargetString)
-	/// \overload void AttrHelper_Vec3DArrToString(const aiVector3D* pArray, const size_t pArray_Size, std::string& pTargetString)
-	void AttrHelper_Vec2DArrToString(const aiVector2D* pArray, const size_t pArray_Size, std::string& pTargetString);
-
-	/// \fn void AttrHelper_Vec3DAsVec2fArrToString(const aiVector3D* pArray, const size_t pArray_Size, std::string& pTargetString)
-	/// \overload void AttrHelper_Vec3DArrToString(const aiVector3D* pArray, const size_t pArray_Size, std::string& pTargetString)
-	/// Only x, y is used from aiVector3D.
-	void AttrHelper_Vec3DAsVec2fArrToString(const aiVector3D* pArray, const size_t pArray_Size, std::string& pTargetString);
-
-	/// \fn void AttrHelper_Col4DArrToString(const aiColor4D* pArray, const size_t pArray_Size, std::string& pTargetString)
-	/// \overload void AttrHelper_Vec3DArrToString(const aiVector3D* pArray, const size_t pArray_Size, std::string& pTargetString)
-	/// Converts array of colors to string.
-	void AttrHelper_Col4DArrToString(const aiColor4D* pArray, const size_t pArray_Size, std::string& pTargetString);
-
-	/// \fn void AttrHelper_Col3DArrToString(const aiColor3D* pArray, const size_t pArray_Size, std::string& pTargetString)
-	/// \overload void AttrHelper_Col4DArrToString(const aiColor4D* pArray, const size_t pArray_Size, std::string& pTargetString)
-	/// Converts array of colors to string.
-	void AttrHelper_Col3DArrToString(const aiColor3D* pArray, const size_t pArray_Size, std::string& pTargetString);
-
-	/// \fn void AttrHelper_FloatToAttrList(std::list<SAttribute> pList, const std::string& pName, const float pValue, const float pDefaultValue)
-	/// \overload void AttrHelper_Col3DArrToString(const aiColor3D* pArray, const size_t pArray_Size, std::string& pTargetString)
-	void AttrHelper_FloatToAttrList(std::list<SAttribute> &pList, const std::string& pName, const float pValue, const float pDefaultValue);
-
-	/// \fn void AttrHelper_Color3ToAttrList(std::list<SAttribute> pList, const std::string& pName, const aiColor3D& pValue, const aiColor3D& pDefaultValue)
-	/// Add attribute to list if value not equal to default.
-	/// \param [in] pList - target list of the attributes.
-	/// \param [in] pName - name of new attribute.
-	/// \param [in] pValue - value of the new attribute.
-	/// \param [in] pDefaultValue - default value for checking: if pValue is equal to pDefaultValue then attribute will not be added.
-	void AttrHelper_Color3ToAttrList(std::list<SAttribute> &pList, const std::string& pName, const aiColor3D& pValue, const aiColor3D& pDefaultValue);
-
-	/// \fn void NodeHelper_OpenNode(const std::string& pNodeName, const size_t pTabLevel, const bool pEmptyElement, const std::list<SAttribute>& pAttrList)
-	/// Begin new XML-node element.
-	/// \param [in] pNodeName - name of the element.
-	/// \param [in] pTabLevel - indentation level.
-	/// \param [in] pEmtyElement - if true then empty element will be created.
-	/// \param [in] pAttrList - list of the attributes for element.
-	void NodeHelper_OpenNode(const std::string& pNodeName, const size_t pTabLevel, const bool pEmptyElement, const std::list<SAttribute>& pAttrList);
-
-	/// \fn void NodeHelper_OpenNode(const std::string& pNodeName, const size_t pTabLevel, const bool pEmptyElement = false)
-	/// \overload void NodeHelper_OpenNode(const std::string& pNodeName, const size_t pTabLevel, const bool pEmptyElement, const std::list<SAttribute>& pAttrList)
-	void NodeHelper_OpenNode(const std::string& pNodeName, const size_t pTabLevel, const bool pEmptyElement = false);
-
-	/// \fn void NodeHelper_CloseNode(const std::string& pNodeName, const size_t pTabLevel)
-	/// End XML-node element.
-	/// \param [in] pNodeName - name of the element.
-	/// \param [in] pTabLevel - indentation level.
-	void NodeHelper_CloseNode(const std::string& pNodeName, const size_t pTabLevel);
-
-	/// \fn void Export_Node(const aiNode* pNode, const size_t pTabLevel)
-	/// Export data from scene to XML-file: aiNode.
-	/// \param [in] pNode - source aiNode.
-	/// \param [in] pTabLevel - indentation level.
-	void Export_Node(const aiNode* pNode, const size_t pTabLevel);
-
-	/// \fn void Export_Mesh(const size_t pIdxMesh, const size_t pTabLevel)
-	/// Export data from scene to XML-file: aiMesh.
-	/// \param [in] pMesh - index of the source aiMesh.
-	/// \param [in] pTabLevel - indentation level.
-	void Export_Mesh(const size_t pIdxMesh, const size_t pTabLevel);
-
-	/// \fn void Export_Material(const size_t pIdxMaterial, const size_t pTabLevel)
-	/// Export data from scene to XML-file: aiMaterial.
-	/// \param [in] pIdxMaterial - index of the source aiMaterial.
-	/// \param [in] pTabLevel - indentation level.
-	void Export_Material(const size_t pIdxMaterial, const size_t pTabLevel);
-
-	/// \fn void Export_MetadataBoolean(const aiString& pKey, const bool pValue, const size_t pTabLevel)
-	/// Export data from scene to XML-file: aiMetadata.
-	/// \param [in] pKey - source data: value of the metadata key.
-	/// \param [in] pValue - source data: value of the metadata value.
-	/// \param [in] pTabLevel - indentation level.
-	void Export_MetadataBoolean(const aiString& pKey, const bool pValue, const size_t pTabLevel);
-
-	/// \fn void Export_MetadataDouble(const aiString& pKey, const double pValue, const size_t pTabLevel)
-	/// \overload void Export_MetadataBoolean(const aiString& pKey, const bool pValue, const size_t pTabLevel)
-	void Export_MetadataDouble(const aiString& pKey, const double pValue, const size_t pTabLevel);
-
-	/// \fn void Export_MetadataFloat(const aiString& pKey, const float pValue, const size_t pTabLevel)
-	/// \overload void Export_MetadataBoolean(const aiString& pKey, const bool pValue, const size_t pTabLevel)
-	void Export_MetadataFloat(const aiString& pKey, const float pValue, const size_t pTabLevel);
-
-	/// \fn void Export_MetadataInteger(const aiString& pKey, const int32_t pValue, const size_t pTabLevel)
-	/// \overload void Export_MetadataBoolean(const aiString& pKey, const bool pValue, const size_t pTabLevel)
-	void Export_MetadataInteger(const aiString& pKey, const int32_t pValue, const size_t pTabLevel);
-
-	/// \fn void Export_MetadataString(const aiString& pKey, const aiString& pValue, const size_t pTabLevel)
-	/// \overload void Export_MetadataBoolean(const aiString& pKey, const bool pValue, const size_t pTabLevel)
-	void Export_MetadataString(const aiString& pKey, const aiString& pValue, const size_t pTabLevel);
-
-	/// \fn bool CheckAndExport_Light(const aiNode& pNode, const size_t pTabLevel)
-	/// Check if node point to light source. If yes then export light source.
-	/// \param [in] pNode - reference to node for checking.
-	/// \param [in] pTabLevel - indentation level.
-	/// \return true - if node assigned with light and it was exported, else - return false.
-	bool CheckAndExport_Light(const aiNode& pNode, const size_t pTabLevel);
-
-	/***********************************************/
-	/************** Functions: LOG set *************/
-	/***********************************************/
-
-	/// \fn void LogError(const std::string& pMessage)
-	/// Short variant for calling \ref DefaultLogger::get()->error()
-	void LogError(const std::string& pMessage) { DefaultLogger::get()->error(pMessage); }
-
-public:
-
-	/// \fn X3DExporter()
-	/// Default constructor.
-	X3DExporter(const char* pFileName, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* pProperties);
-
-	/// \fn ~X3DExporter()
-	/// Default destructor.
-	~X3DExporter() {}
-
-};// class X3DExporter
-
-}// namespace Assimp
-
-#endif // INCLUDED_AI_X3D_EXPORTER_H
diff --git a/Engine/lib/assimp/code/X3D/X3DImporter.cpp b/Engine/lib/assimp/code/X3D/X3DImporter.cpp
deleted file mode 100644
index 367d84fcf..000000000
--- a/Engine/lib/assimp/code/X3D/X3DImporter.cpp
+++ /dev/null
@@ -1,1735 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-/// \file   X3DImporter.cpp
-/// \brief  X3D-format files importer for Assimp: main algorithm implementation.
-/// \date   2015-2016
-/// \author smal.root@gmail.com
-
-#ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
-
-#include "X3DImporter.hpp"
-#include "X3DImporter_Macro.hpp"
-#include <assimp/StringUtils.h>
-
-// Header files, Assimp.
-#include <assimp/DefaultIOSystem.h>
-#include <assimp/fast_atof.h>
-#include "FIReader.hpp"
-
-// Header files, stdlib.
-#include <memory>
-#include <string>
-#include <iterator>
-
-namespace Assimp {
-
-/// \var aiImporterDesc X3DImporter::Description
-/// Constant which holds the importer description
-const aiImporterDesc X3DImporter::Description = {
-	"Extensible 3D(X3D) Importer",
-	"smalcom",
-	"",
-	"See documentation in source code. Chapter: Limitations.",
-	aiImporterFlags_SupportTextFlavour | aiImporterFlags_SupportBinaryFlavour | aiImporterFlags_LimitedSupport | aiImporterFlags_Experimental,
-	0,
-	0,
-	0,
-	0,
-	"x3d x3db"
-};
-
-//const std::regex X3DImporter::pattern_nws(R"([^, \t\r\n]+)");
-//const std::regex X3DImporter::pattern_true(R"(^\s*(?:true|1)\s*$)", std::regex::icase);
-
-struct WordIterator {
-    using iterator_category = std::input_iterator_tag;
-    using value_type = const char*;
-    using difference_type = ptrdiff_t;
-    using pointer = value_type*;
-    using reference = value_type&;
-
-    static const char *whitespace;
-    const char *start_, *end_;
-    WordIterator(const char *start, const char *end): start_(start), end_(end) {
-        start_ = start + strspn(start, whitespace);
-        if (start_ >= end_) {
-            start_ = 0;
-        }
-    }
-    WordIterator(): start_(0), end_(0) {}
-    WordIterator(const WordIterator &other): start_(other.start_), end_(other.end_) {}
-    WordIterator &operator=(const WordIterator &other) {
-        start_ = other.start_;
-        end_ = other.end_;
-        return *this;
-    }
-    bool operator==(const WordIterator &other) const { return start_ == other.start_; }
-    bool operator!=(const WordIterator &other) const { return start_ != other.start_; }
-    WordIterator &operator++() {
-        start_ += strcspn(start_, whitespace);
-        start_ += strspn(start_, whitespace);
-        if (start_ >= end_) {
-            start_ = 0;
-        }
-        return *this;
-    }
-    WordIterator operator++(int) {
-        WordIterator result(*this);
-        ++(*this);
-        return result;
-    }
-    const char *operator*() const { return start_; }
-};
-
-const char *WordIterator::whitespace = ", \t\r\n";
-
-X3DImporter::X3DImporter()
-: NodeElement_Cur( nullptr )
-, mReader( nullptr ) {
-    // empty
-}
-
-X3DImporter::~X3DImporter() {
-    // Clear() is accounting if data already is deleted. So, just check again if all data is deleted.
-    Clear();
-}
-
-void X3DImporter::Clear() {
-	NodeElement_Cur = nullptr;
-	// Delete all elements
-	if(!NodeElement_List.empty()) {
-        for ( std::list<CX3DImporter_NodeElement*>::iterator it = NodeElement_List.begin(); it != NodeElement_List.end(); ++it ) {
-            delete *it;
-        }
-		NodeElement_List.clear();
-	}
-}
-
-
-/*********************************************************************************************************************************************/
-/************************************************************ Functions: find set ************************************************************/
-/*********************************************************************************************************************************************/
-
-bool X3DImporter::FindNodeElement_FromRoot(const std::string& pID, const CX3DImporter_NodeElement::EType pType, CX3DImporter_NodeElement** pElement)
-{
-	for(std::list<CX3DImporter_NodeElement*>::iterator it = NodeElement_List.begin(); it != NodeElement_List.end(); ++it)
-	{
-		if(((*it)->Type == pType) && ((*it)->ID == pID))
-		{
-			if(pElement != nullptr) *pElement = *it;
-
-			return true;
-		}
-	}// for(std::list<CX3DImporter_NodeElement*>::iterator it = NodeElement_List.begin(); it != NodeElement_List.end(); it++)
-
-	return false;
-}
-
-bool X3DImporter::FindNodeElement_FromNode(CX3DImporter_NodeElement* pStartNode, const std::string& pID,
-													const CX3DImporter_NodeElement::EType pType, CX3DImporter_NodeElement** pElement)
-{
-    bool found = false;// flag: true - if requested element is found.
-
-	// Check if pStartNode - this is the element, we are looking for.
-	if((pStartNode->Type == pType) && (pStartNode->ID == pID))
-	{
-		found = true;
-        if ( pElement != nullptr )
-        {
-            *pElement = pStartNode;
-        }
-
-		goto fne_fn_end;
-	}// if((pStartNode->Type() == pType) && (pStartNode->ID() == pID))
-
-	// Check childs of pStartNode.
-	for(std::list<CX3DImporter_NodeElement*>::iterator ch_it = pStartNode->Child.begin(); ch_it != pStartNode->Child.end(); ++ch_it)
-	{
-		found = FindNodeElement_FromNode(*ch_it, pID, pType, pElement);
-        if ( found )
-        {
-            break;
-        }
-	}// for(std::list<CX3DImporter_NodeElement*>::iterator ch_it = it->Child.begin(); ch_it != it->Child.end(); ch_it++)
-
-fne_fn_end:
-
-	return found;
-}
-
-bool X3DImporter::FindNodeElement(const std::string& pID, const CX3DImporter_NodeElement::EType pType, CX3DImporter_NodeElement** pElement)
-{
-    CX3DImporter_NodeElement* tnd = NodeElement_Cur;// temporary pointer to node.
-    bool static_search = false;// flag: true if searching in static node.
-
-    // At first check if we have deal with static node. Go up through parent nodes and check flag.
-    while(tnd != nullptr)
-    {
-		if(tnd->Type == CX3DImporter_NodeElement::ENET_Group)
-		{
-			if(((CX3DImporter_NodeElement_Group*)tnd)->Static)
-			{
-				static_search = true;// Flag found, stop walking up. Node with static flag will holded in tnd variable.
-				break;
-			}
-		}
-
-		tnd = tnd->Parent;// go up in graph.
-    }// while(tnd != nullptr)
-
-    // at now call appropriate search function.
-    if ( static_search )
-    {
-        return FindNodeElement_FromNode( tnd, pID, pType, pElement );
-    }
-    else
-    {
-        return FindNodeElement_FromRoot( pID, pType, pElement );
-    }
-}
-
-/*********************************************************************************************************************************************/
-/************************************************************ Functions: throw set ***********************************************************/
-/*********************************************************************************************************************************************/
-
-void X3DImporter::Throw_ArgOutOfRange(const std::string& pArgument)
-{
-	throw DeadlyImportError("Argument value is out of range for: \"" + pArgument + "\".");
-}
-
-void X3DImporter::Throw_CloseNotFound(const std::string& pNode)
-{
-	throw DeadlyImportError("Close tag for node <" + pNode + "> not found. Seems file is corrupt.");
-}
-
-void X3DImporter::Throw_ConvertFail_Str2ArrF(const std::string& pAttrValue)
-{
-	throw DeadlyImportError("In <" + std::string(mReader->getNodeName()) + "> failed to convert attribute value \"" + pAttrValue +
-							"\" from string to array of floats.");
-}
-
-void X3DImporter::Throw_DEF_And_USE()
-{
-	throw DeadlyImportError("\"DEF\" and \"USE\" can not be defined both in <" + std::string(mReader->getNodeName()) + ">.");
-}
-
-void X3DImporter::Throw_IncorrectAttr(const std::string& pAttrName)
-{
-	throw DeadlyImportError("Node <" + std::string(mReader->getNodeName()) + "> has incorrect attribute \"" + pAttrName + "\".");
-}
-
-void X3DImporter::Throw_IncorrectAttrValue(const std::string& pAttrName)
-{
-	throw DeadlyImportError("Attribute \"" + pAttrName + "\" in node <" + std::string(mReader->getNodeName()) + "> has incorrect value.");
-}
-
-void X3DImporter::Throw_MoreThanOnceDefined(const std::string& pNodeType, const std::string& pDescription)
-{
-	throw DeadlyImportError("\"" + pNodeType + "\" node can be used only once in " + mReader->getNodeName() + ". Description: " + pDescription);
-}
-
-void X3DImporter::Throw_TagCountIncorrect(const std::string& pNode)
-{
-	throw DeadlyImportError("Count of open and close tags for node <" + pNode + "> are not equivalent. Seems file is corrupt.");
-}
-
-void X3DImporter::Throw_USE_NotFound(const std::string& pAttrValue)
-{
-	throw DeadlyImportError("Not found node with name \"" + pAttrValue + "\" in <" + std::string(mReader->getNodeName()) + ">.");
-}
-
-/*********************************************************************************************************************************************/
-/************************************************************* Functions: XML set ************************************************************/
-/*********************************************************************************************************************************************/
-
-void X3DImporter::XML_CheckNode_MustBeEmpty()
-{
-	if(!mReader->isEmptyElement()) throw DeadlyImportError(std::string("Node <") + mReader->getNodeName() + "> must be empty.");
-}
-
-void X3DImporter::XML_CheckNode_SkipUnsupported(const std::string& pParentNodeName)
-{
-    static const size_t Uns_Skip_Len = 192;
-    const char* Uns_Skip[ Uns_Skip_Len ] = {
-	    // CAD geometry component
-	    "CADAssembly", "CADFace", "CADLayer", "CADPart", "IndexedQuadSet", "QuadSet",
-	    // Core
-	    "ROUTE", "ExternProtoDeclare", "ProtoDeclare", "ProtoInstance", "ProtoInterface", "WorldInfo",
-	    // Distributed interactive simulation (DIS) component
-	    "DISEntityManager", "DISEntityTypeMapping", "EspduTransform", "ReceiverPdu", "SignalPdu", "TransmitterPdu",
-	    // Cube map environmental texturing component
-	    "ComposedCubeMapTexture", "GeneratedCubeMapTexture", "ImageCubeMapTexture",
-	    // Environmental effects component
-	    "Background", "Fog", "FogCoordinate", "LocalFog", "TextureBackground",
-	    // Environmental sensor component
-	    "ProximitySensor", "TransformSensor", "VisibilitySensor",
-	    // Followers component
-	    "ColorChaser", "ColorDamper", "CoordinateChaser", "CoordinateDamper", "OrientationChaser", "OrientationDamper", "PositionChaser", "PositionChaser2D",
-	    "PositionDamper", "PositionDamper2D", "ScalarChaser", "ScalarDamper", "TexCoordChaser2D", "TexCoordDamper2D",
-	    // Geospatial component
-	    "GeoCoordinate", "GeoElevationGrid", "GeoLocation", "GeoLOD", "GeoMetadata", "GeoOrigin", "GeoPositionInterpolator", "GeoProximitySensor",
-	    "GeoTouchSensor", "GeoTransform", "GeoViewpoint",
-	    // Humanoid Animation (H-Anim) component
-	    "HAnimDisplacer", "HAnimHumanoid", "HAnimJoint", "HAnimSegment", "HAnimSite",
-	    // Interpolation component
-	    "ColorInterpolator", "CoordinateInterpolator", "CoordinateInterpolator2D", "EaseInEaseOut", "NormalInterpolator", "OrientationInterpolator",
-	    "PositionInterpolator", "PositionInterpolator2D", "ScalarInterpolator", "SplinePositionInterpolator", "SplinePositionInterpolator2D",
-	    "SplineScalarInterpolator", "SquadOrientationInterpolator",
-	    // Key device sensor component
-	    "KeySensor", "StringSensor",
-	    // Layering component
-	    "Layer", "LayerSet", "Viewport",
-	    // Layout component
-	    "Layout", "LayoutGroup", "LayoutLayer", "ScreenFontStyle", "ScreenGroup",
-	    // Navigation component
-	    "Billboard", "Collision", "LOD", "NavigationInfo", "OrthoViewpoint", "Viewpoint", "ViewpointGroup",
-	    // Networking component
-	    "EXPORT", "IMPORT", "Anchor", "LoadSensor",
-	    // NURBS component
-	    "Contour2D", "ContourPolyline2D", "CoordinateDouble", "NurbsCurve", "NurbsCurve2D", "NurbsOrientationInterpolator", "NurbsPatchSurface",
-	    "NurbsPositionInterpolator", "NurbsSet", "NurbsSurfaceInterpolator", "NurbsSweptSurface", "NurbsSwungSurface", "NurbsTextureCoordinate",
-	    "NurbsTrimmedSurface",
-	    // Particle systems component
-	    "BoundedPhysicsModel", "ConeEmitter", "ExplosionEmitter", "ForcePhysicsModel", "ParticleSystem", "PointEmitter", "PolylineEmitter", "SurfaceEmitter",
-	    "VolumeEmitter", "WindPhysicsModel",
-	    // Picking component
-	    "LinePickSensor", "PickableGroup", "PointPickSensor", "PrimitivePickSensor", "VolumePickSensor",
-	    // Pointing device sensor component
-	    "CylinderSensor", "PlaneSensor", "SphereSensor", "TouchSensor",
-	    // Rendering component
-	    "ClipPlane",
-	    // Rigid body physics
-	    "BallJoint", "CollidableOffset", "CollidableShape", "CollisionCollection", "CollisionSensor", "CollisionSpace", "Contact", "DoubleAxisHingeJoint",
-	    "MotorJoint", "RigidBody", "RigidBodyCollection", "SingleAxisHingeJoint", "SliderJoint", "UniversalJoint",
-	    // Scripting component
-	    "Script",
-	    // Programmable shaders component
-	    "ComposedShader", "FloatVertexAttribute", "Matrix3VertexAttribute", "Matrix4VertexAttribute", "PackagedShader", "ProgramShader", "ShaderPart",
-	    "ShaderProgram",
-	    // Shape component
-	    "FillProperties", "LineProperties", "TwoSidedMaterial",
-	    // Sound component
-	    "AudioClip", "Sound",
-	    // Text component
-	    "FontStyle", "Text",
-	    // Texturing3D Component
-	    "ComposedTexture3D", "ImageTexture3D", "PixelTexture3D", "TextureCoordinate3D", "TextureCoordinate4D", "TextureTransformMatrix3D", "TextureTransform3D",
-	    // Texturing component
-	    "MovieTexture", "MultiTexture", "MultiTextureCoordinate", "MultiTextureTransform", "PixelTexture", "TextureCoordinateGenerator", "TextureProperties",
-	    // Time component
-	    "TimeSensor",
-	    // Event Utilities component
-	    "BooleanFilter", "BooleanSequencer", "BooleanToggle", "BooleanTrigger", "IntegerSequencer", "IntegerTrigger", "TimeTrigger",
-	    // Volume rendering component
-	    "BlendedVolumeStyle", "BoundaryEnhancementVolumeStyle", "CartoonVolumeStyle", "ComposedVolumeStyle", "EdgeEnhancementVolumeStyle", "IsoSurfaceVolumeData",
-	    "OpacityMapVolumeStyle", "ProjectionVolumeStyle", "SegmentedVolumeData", "ShadedVolumeStyle", "SilhouetteEnhancementVolumeStyle", "ToneMappedVolumeStyle",
-	    "VolumeData"
-    };
-
-    const std::string nn( mReader->getNodeName() );
-    bool found = false;
-    bool close_found = false;
-
-	for(size_t i = 0; i < Uns_Skip_Len; i++)
-	{
-		if(nn == Uns_Skip[i])
-		{
-			found = true;
-			if(mReader->isEmptyElement())
-			{
-				close_found = true;
-
-				goto casu_cres;
-			}
-
-			while(mReader->read())
-			{
-				if((mReader->getNodeType() == irr::io::EXN_ELEMENT_END) && (nn == mReader->getNodeName()))
-				{
-					close_found = true;
-
-					goto casu_cres;
-				}
-			}
-		}
-	}
-
-casu_cres:
-
-	if(!found) throw DeadlyImportError("Unknown node \"" + nn + "\" in " + pParentNodeName + ".");
-
-	if(close_found)
-		LogInfo("Skipping node \"" + nn + "\" in " + pParentNodeName + ".");
-	else
-		Throw_CloseNotFound(nn);
-}
-
-bool X3DImporter::XML_SearchNode(const std::string& pNodeName)
-{
-	while(mReader->read())
-	{
-		if((mReader->getNodeType() == irr::io::EXN_ELEMENT) && XML_CheckNode_NameEqual(pNodeName)) return true;
-	}
-
-	return false;
-}
-
-bool X3DImporter::XML_ReadNode_GetAttrVal_AsBool(const int pAttrIdx)
-{
-    auto boolValue = std::dynamic_pointer_cast<const FIBoolValue>(mReader->getAttributeEncodedValue(pAttrIdx));
-    if (boolValue) {
-        if (boolValue->value.size() == 1) {
-            return boolValue->value.front();
-        }
-        throw DeadlyImportError("Invalid bool value");
-    }
-    else {
-        std::string val(mReader->getAttributeValue(pAttrIdx));
-
-        if(val == "false")
-            return false;
-        else if(val == "true")
-            return true;
-        else
-            throw DeadlyImportError("Bool attribute value can contain \"false\" or \"true\" not the \"" + val + "\"");
-    }
-}
-
-float X3DImporter::XML_ReadNode_GetAttrVal_AsFloat(const int pAttrIdx)
-{
-    auto floatValue = std::dynamic_pointer_cast<const FIFloatValue>(mReader->getAttributeEncodedValue(pAttrIdx));
-    if (floatValue) {
-        if (floatValue->value.size() == 1) {
-            return floatValue->value.front();
-        }
-        throw DeadlyImportError("Invalid float value");
-    }
-    else {
-        std::string val;
-        float tvalf;
-
-        ParseHelper_FixTruncatedFloatString(mReader->getAttributeValue(pAttrIdx), val);
-        fast_atoreal_move(val.c_str(), tvalf, false);
-
-        return tvalf;
-    }
-}
-
-int32_t X3DImporter::XML_ReadNode_GetAttrVal_AsI32(const int pAttrIdx)
-{
-    auto intValue = std::dynamic_pointer_cast<const FIIntValue>(mReader->getAttributeEncodedValue(pAttrIdx));
-    if (intValue) {
-        if (intValue->value.size() == 1) {
-            return intValue->value.front();
-        }
-        throw DeadlyImportError("Invalid int value");
-    }
-    else {
-        return strtol10(mReader->getAttributeValue(pAttrIdx));
-    }
-}
-
-void X3DImporter::XML_ReadNode_GetAttrVal_AsCol3f(const int pAttrIdx, aiColor3D& pValue)
-{
-    std::vector<float> tlist;
-    std::vector<float>::iterator it;
-
-	XML_ReadNode_GetAttrVal_AsArrF(pAttrIdx, tlist);
-	if(tlist.size() != 3) Throw_ConvertFail_Str2ArrF(mReader->getAttributeValue(pAttrIdx));
-
-	it = tlist.begin();
-	pValue.r = *it++;
-	pValue.g = *it++;
-	pValue.b = *it;
-}
-
-void X3DImporter::XML_ReadNode_GetAttrVal_AsVec2f(const int pAttrIdx, aiVector2D& pValue)
-{
-    std::vector<float> tlist;
-    std::vector<float>::iterator it;
-
-	XML_ReadNode_GetAttrVal_AsArrF(pAttrIdx, tlist);
-	if(tlist.size() != 2) Throw_ConvertFail_Str2ArrF(mReader->getAttributeValue(pAttrIdx));
-
-	it = tlist.begin();
-	pValue.x = *it++;
-	pValue.y = *it;
-}
-
-void X3DImporter::XML_ReadNode_GetAttrVal_AsVec3f(const int pAttrIdx, aiVector3D& pValue)
-{
-    std::vector<float> tlist;
-    std::vector<float>::iterator it;
-
-	XML_ReadNode_GetAttrVal_AsArrF(pAttrIdx, tlist);
-	if(tlist.size() != 3) Throw_ConvertFail_Str2ArrF(mReader->getAttributeValue(pAttrIdx));
-
-	it = tlist.begin();
-	pValue.x = *it++;
-	pValue.y = *it++;
-	pValue.z = *it;
-}
-
-void X3DImporter::XML_ReadNode_GetAttrVal_AsArrB(const int pAttrIdx, std::vector<bool>& pValue)
-{
-    auto boolValue = std::dynamic_pointer_cast<const FIBoolValue>(mReader->getAttributeEncodedValue(pAttrIdx));
-    if (boolValue) {
-        pValue = boolValue->value;
-    }
-    else {
-        const char *val = mReader->getAttributeValue(pAttrIdx);
-        pValue.clear();
-
-        //std::cregex_iterator wordItBegin(val, val + strlen(val), pattern_nws);
-        //const std::cregex_iterator wordItEnd;
-        //std::transform(wordItBegin, wordItEnd, std::back_inserter(pValue), [](const std::cmatch &match) { return std::regex_match(match.str(), pattern_true); });
-
-        WordIterator wordItBegin(val, val + strlen(val));
-        WordIterator wordItEnd;
-        std::transform(wordItBegin, wordItEnd, std::back_inserter(pValue), [](const char *match) { return (::tolower(match[0]) == 't') || (match[0] == '1'); });
-    }
-}
-
-void X3DImporter::XML_ReadNode_GetAttrVal_AsArrI32(const int pAttrIdx, std::vector<int32_t>& pValue)
-{
-    auto intValue = std::dynamic_pointer_cast<const FIIntValue>(mReader->getAttributeEncodedValue(pAttrIdx));
-    if (intValue) {
-        pValue = intValue->value;
-    }
-    else {
-        const char *val = mReader->getAttributeValue(pAttrIdx);
-        pValue.clear();
-
-        //std::cregex_iterator wordItBegin(val, val + strlen(val), pattern_nws);
-        //const std::cregex_iterator wordItEnd;
-        //std::transform(wordItBegin, wordItEnd, std::back_inserter(pValue), [](const std::cmatch &match) { return std::stoi(match.str()); });
-
-        WordIterator wordItBegin(val, val + strlen(val));
-        WordIterator wordItEnd;
-        std::transform(wordItBegin, wordItEnd, std::back_inserter(pValue), [](const char *match) { return atoi(match); });
-    }
-}
-
-void X3DImporter::XML_ReadNode_GetAttrVal_AsArrF(const int pAttrIdx, std::vector<float>& pValue)
-{
-    auto floatValue = std::dynamic_pointer_cast<const FIFloatValue>(mReader->getAttributeEncodedValue(pAttrIdx));
-    if (floatValue) {
-        pValue = floatValue->value;
-    }
-    else {
-        const char *val = mReader->getAttributeValue(pAttrIdx);
-        pValue.clear();
-
-        //std::cregex_iterator wordItBegin(val, val + strlen(val), pattern_nws);
-        //const std::cregex_iterator wordItEnd;
-        //std::transform(wordItBegin, wordItEnd, std::back_inserter(pValue), [](const std::cmatch &match) { return std::stof(match.str()); });
-
-        WordIterator wordItBegin(val, val + strlen(val));
-        WordIterator wordItEnd;
-        std::transform(wordItBegin, wordItEnd, std::back_inserter(pValue), [](const char *match) { return static_cast<float>(atof(match)); });
-    }
-}
-
-void X3DImporter::XML_ReadNode_GetAttrVal_AsArrD(const int pAttrIdx, std::vector<double>& pValue)
-{
-    auto doubleValue = std::dynamic_pointer_cast<const FIDoubleValue>(mReader->getAttributeEncodedValue(pAttrIdx));
-    if (doubleValue) {
-        pValue = doubleValue->value;
-    }
-    else {
-        const char *val = mReader->getAttributeValue(pAttrIdx);
-        pValue.clear();
-
-        //std::cregex_iterator wordItBegin(val, val + strlen(val), pattern_nws);
-        //const std::cregex_iterator wordItEnd;
-        //std::transform(wordItBegin, wordItEnd, std::back_inserter(pValue), [](const std::cmatch &match) { return std::stod(match.str()); });
-
-        WordIterator wordItBegin(val, val + strlen(val));
-        WordIterator wordItEnd;
-        std::transform(wordItBegin, wordItEnd, std::back_inserter(pValue), [](const char *match) { return atof(match); });
-    }
-}
-
-void X3DImporter::XML_ReadNode_GetAttrVal_AsListCol3f(const int pAttrIdx, std::list<aiColor3D>& pValue)
-{
-    std::vector<float> tlist;
-
-	XML_ReadNode_GetAttrVal_AsArrF(pAttrIdx, tlist);// read as list
-	if(tlist.size() % 3) Throw_ConvertFail_Str2ArrF(mReader->getAttributeValue(pAttrIdx));
-
-	// copy data to array
-	for(std::vector<float>::iterator it = tlist.begin(); it != tlist.end();)
-	{
-		aiColor3D tcol;
-
-		tcol.r = *it++;
-		tcol.g = *it++;
-		tcol.b = *it++;
-		pValue.push_back(tcol);
-	}
-}
-
-void X3DImporter::XML_ReadNode_GetAttrVal_AsArrCol3f(const int pAttrIdx, std::vector<aiColor3D>& pValue)
-{
-    std::list<aiColor3D> tlist;
-
-	XML_ReadNode_GetAttrVal_AsListCol3f(pAttrIdx, tlist);// read as list
-	// and copy to array
-	if(!tlist.empty())
-	{
-		pValue.reserve(tlist.size());
-		for(std::list<aiColor3D>::iterator it = tlist.begin(); it != tlist.end(); ++it) pValue.push_back(*it);
-	}
-}
-
-void X3DImporter::XML_ReadNode_GetAttrVal_AsListCol4f(const int pAttrIdx, std::list<aiColor4D>& pValue)
-{
-    std::vector<float> tlist;
-
-	XML_ReadNode_GetAttrVal_AsArrF(pAttrIdx, tlist);// read as list
-	if(tlist.size() % 4) Throw_ConvertFail_Str2ArrF(mReader->getAttributeValue(pAttrIdx));
-
-	// copy data to array
-	for(std::vector<float>::iterator it = tlist.begin(); it != tlist.end();)
-	{
-		aiColor4D tcol;
-
-		tcol.r = *it++;
-		tcol.g = *it++;
-		tcol.b = *it++;
-		tcol.a = *it++;
-		pValue.push_back(tcol);
-	}
-}
-
-void X3DImporter::XML_ReadNode_GetAttrVal_AsArrCol4f(const int pAttrIdx, std::vector<aiColor4D>& pValue)
-{
-    std::list<aiColor4D> tlist;
-
-	XML_ReadNode_GetAttrVal_AsListCol4f(pAttrIdx, tlist);// read as list
-	// and copy to array
-	if(!tlist.empty())
-	{
-		pValue.reserve(tlist.size());
-        for ( std::list<aiColor4D>::iterator it = tlist.begin(); it != tlist.end(); ++it )
-        {
-            pValue.push_back( *it );
-        }
-	}
-}
-
-void X3DImporter::XML_ReadNode_GetAttrVal_AsListVec2f(const int pAttrIdx, std::list<aiVector2D>& pValue)
-{
-    std::vector<float> tlist;
-
-	XML_ReadNode_GetAttrVal_AsArrF(pAttrIdx, tlist);// read as list
-    if ( tlist.size() % 2 )
-    {
-        Throw_ConvertFail_Str2ArrF( mReader->getAttributeValue( pAttrIdx ) );
-    }
-
-	// copy data to array
-	for(std::vector<float>::iterator it = tlist.begin(); it != tlist.end();)
-	{
-		aiVector2D tvec;
-
-		tvec.x = *it++;
-		tvec.y = *it++;
-		pValue.push_back(tvec);
-	}
-}
-
-void X3DImporter::XML_ReadNode_GetAttrVal_AsArrVec2f(const int pAttrIdx, std::vector<aiVector2D>& pValue)
-{
-    std::list<aiVector2D> tlist;
-
-	XML_ReadNode_GetAttrVal_AsListVec2f(pAttrIdx, tlist);// read as list
-	// and copy to array
-	if(!tlist.empty())
-	{
-		pValue.reserve(tlist.size());
-        for ( std::list<aiVector2D>::iterator it = tlist.begin(); it != tlist.end(); ++it )
-        {
-            pValue.push_back( *it );
-        }
-	}
-}
-
-void X3DImporter::XML_ReadNode_GetAttrVal_AsListVec3f(const int pAttrIdx, std::list<aiVector3D>& pValue)
-{
-    std::vector<float> tlist;
-
-	XML_ReadNode_GetAttrVal_AsArrF(pAttrIdx, tlist);// read as list
-    if ( tlist.size() % 3 )
-    {
-        Throw_ConvertFail_Str2ArrF( mReader->getAttributeValue( pAttrIdx ) );
-    }
-
-	// copy data to array
-	for(std::vector<float>::iterator it = tlist.begin(); it != tlist.end();)
-	{
-		aiVector3D tvec;
-
-		tvec.x = *it++;
-		tvec.y = *it++;
-		tvec.z = *it++;
-		pValue.push_back(tvec);
-	}
-}
-
-void X3DImporter::XML_ReadNode_GetAttrVal_AsArrVec3f(const int pAttrIdx, std::vector<aiVector3D>& pValue)
-{
-    std::list<aiVector3D> tlist;
-
-	XML_ReadNode_GetAttrVal_AsListVec3f(pAttrIdx, tlist);// read as list
-	// and copy to array
-	if(!tlist.empty())
-	{
-		pValue.reserve(tlist.size());
-        for ( std::list<aiVector3D>::iterator it = tlist.begin(); it != tlist.end(); ++it )
-        {
-            pValue.push_back( *it );
-        }
-	}
-}
-
-void X3DImporter::XML_ReadNode_GetAttrVal_AsListS(const int pAttrIdx, std::list<std::string>& pValue)
-{
-	// make copy of attribute value - strings list.
-	const size_t tok_str_len = strlen(mReader->getAttributeValue(pAttrIdx));
-    if ( 0 == tok_str_len )
-    {
-        Throw_IncorrectAttrValue( mReader->getAttributeName( pAttrIdx ) );
-    }
-
-	// get pointer to begin of value.
-    char *tok_str = const_cast<char*>(mReader->getAttributeValue(pAttrIdx));
-    char *tok_str_end = tok_str + tok_str_len;
-	// string list has following format: attr_name='"s1" "s2" "sn"'.
-	do
-	{
-		char* tbeg;
-		char* tend;
-		size_t tlen;
-		std::string tstr;
-
-		// find begin of string(element of string list): "sn".
-		tbeg = strstr(tok_str, "\"");
-		if(tbeg == nullptr) Throw_IncorrectAttrValue(mReader->getAttributeName(pAttrIdx));
-
-		tbeg++;// forward pointer from '\"' symbol to next after it.
-		tok_str = tbeg;
-		// find end of string(element of string list): "sn".
-		tend = strstr(tok_str, "\"");
-		if(tend == nullptr) Throw_IncorrectAttrValue(mReader->getAttributeName(pAttrIdx));
-
-		tok_str = tend + 1;
-		// create storage for new string
-		tlen = tend - tbeg;
-		tstr.resize(tlen);// reserve enough space and copy data
-		memcpy((void*)tstr.data(), tbeg, tlen);// not strcpy because end of copied string from tok_str has no terminator.
-		// and store string in output list.
-		pValue.push_back(tstr);
-	} while(tok_str < tok_str_end);
-}
-
-/*********************************************************************************************************************************************/
-/****************************************************** Functions: geometry helper set  ******************************************************/
-/*********************************************************************************************************************************************/
-
-aiVector3D X3DImporter::GeometryHelper_Make_Point2D(const float pAngle, const float pRadius)
-{
-	return aiVector3D(pRadius * std::cos(pAngle), pRadius * std::sin(pAngle), 0);
-}
-
-void X3DImporter::GeometryHelper_Make_Arc2D(const float pStartAngle, const float pEndAngle, const float pRadius, size_t pNumSegments,
-												std::list<aiVector3D>& pVertices)
-{
-	// check argument values ranges.
-    if ( ( pStartAngle < -AI_MATH_TWO_PI_F ) || ( pStartAngle > AI_MATH_TWO_PI_F ) )
-    {
-        Throw_ArgOutOfRange( "GeometryHelper_Make_Arc2D.pStartAngle" );
-    }
-    if ( ( pEndAngle < -AI_MATH_TWO_PI_F ) || ( pEndAngle > AI_MATH_TWO_PI_F ) )
-    {
-        Throw_ArgOutOfRange( "GeometryHelper_Make_Arc2D.pEndAngle" );
-    }
-    if ( pRadius <= 0 )
-    {
-        Throw_ArgOutOfRange( "GeometryHelper_Make_Arc2D.pRadius" );
-    }
-
-	// calculate arc angle and check type of arc
-	float angle_full = std::fabs(pEndAngle - pStartAngle);
-    if ( ( angle_full > AI_MATH_TWO_PI_F ) || ( angle_full == 0.0f ) )
-    {
-        angle_full = AI_MATH_TWO_PI_F;
-    }
-
-	// calculate angle for one step - angle to next point of line.
-	float angle_step = angle_full / (float)pNumSegments;
-	// make points
-	for(size_t pi = 0; pi <= pNumSegments; pi++)
-	{
-		float tangle = pStartAngle + pi * angle_step;
-		pVertices.push_back(GeometryHelper_Make_Point2D(tangle, pRadius));
-	}// for(size_t pi = 0; pi <= pNumSegments; pi++)
-
-	// if we making full circle then add last vertex equal to first vertex
-	if(angle_full == AI_MATH_TWO_PI_F) pVertices.push_back(*pVertices.begin());
-}
-
-void X3DImporter::GeometryHelper_Extend_PointToLine(const std::list<aiVector3D>& pPoint, std::list<aiVector3D>& pLine)
-{
-    std::list<aiVector3D>::const_iterator pit = pPoint.begin();
-    std::list<aiVector3D>::const_iterator pit_last = pPoint.end();
-
-	--pit_last;
-
-    if ( pPoint.size() < 2 )
-    {
-        Throw_ArgOutOfRange( "GeometryHelper_Extend_PointToLine.pPoint.size() can not be less than 2." );
-    }
-
-	// add first point of first line.
-	pLine.push_back(*pit++);
-	// add internal points
-	while(pit != pit_last)
-	{
-		pLine.push_back(*pit);// second point of previous line
-		pLine.push_back(*pit);// first point of next line
-		++pit;
-	}
-	// add last point of last line
-	pLine.push_back(*pit);
-}
-
-void X3DImporter::GeometryHelper_Extend_PolylineIdxToLineIdx(const std::list<int32_t>& pPolylineCoordIdx, std::list<int32_t>& pLineCoordIdx)
-{
-    std::list<int32_t>::const_iterator plit = pPolylineCoordIdx.begin();
-
-	while(plit != pPolylineCoordIdx.end())
-	{
-		// add first point of polyline
-		pLineCoordIdx.push_back(*plit++);
-		while((*plit != (-1)) && (plit != pPolylineCoordIdx.end()))
-		{
-			std::list<int32_t>::const_iterator plit_next;
-
-			plit_next = plit, ++plit_next;
-			pLineCoordIdx.push_back(*plit);// second point of previous line.
-			pLineCoordIdx.push_back(-1);// delimiter
-			if((*plit_next == (-1)) || (plit_next == pPolylineCoordIdx.end())) break;// current polyline is finished
-
-			pLineCoordIdx.push_back(*plit);// first point of next line.
-			plit = plit_next;
-		}// while((*plit != (-1)) && (plit != pPolylineCoordIdx.end()))
-	}// while(plit != pPolylineCoordIdx.end())
-}
-
-#define MESH_RectParallelepiped_CREATE_VERT \
-aiVector3D vert_set[8]; \
-float x1, x2, y1, y2, z1, z2, hs; \
- \
-	hs = pSize.x / 2, x1 = -hs, x2 = hs; \
-	hs = pSize.y / 2, y1 = -hs, y2 = hs; \
-	hs = pSize.z / 2, z1 = -hs, z2 = hs; \
-	vert_set[0].Set(x2, y1, z2); \
-	vert_set[1].Set(x2, y2, z2); \
-	vert_set[2].Set(x2, y2, z1); \
-	vert_set[3].Set(x2, y1, z1); \
-	vert_set[4].Set(x1, y1, z2); \
-	vert_set[5].Set(x1, y2, z2); \
-	vert_set[6].Set(x1, y2, z1); \
-	vert_set[7].Set(x1, y1, z1)
-
-void X3DImporter::GeometryHelper_MakeQL_RectParallelepiped(const aiVector3D& pSize, std::list<aiVector3D>& pVertices)
-{
-	MESH_RectParallelepiped_CREATE_VERT;
-	MACRO_FACE_ADD_QUAD_FA(true, pVertices, vert_set, 3, 2, 1, 0);// front
-	MACRO_FACE_ADD_QUAD_FA(true, pVertices, vert_set, 6, 7, 4, 5);// back
-	MACRO_FACE_ADD_QUAD_FA(true, pVertices, vert_set, 7, 3, 0, 4);// left
-	MACRO_FACE_ADD_QUAD_FA(true, pVertices, vert_set, 2, 6, 5, 1);// right
-	MACRO_FACE_ADD_QUAD_FA(true, pVertices, vert_set, 0, 1, 5, 4);// top
-	MACRO_FACE_ADD_QUAD_FA(true, pVertices, vert_set, 7, 6, 2, 3);// bottom
-}
-
-#undef MESH_RectParallelepiped_CREATE_VERT
-
-void X3DImporter::GeometryHelper_CoordIdxStr2FacesArr(const std::vector<int32_t>& pCoordIdx, std::vector<aiFace>& pFaces, unsigned int& pPrimitiveTypes) const
-{
-    std::vector<int32_t> f_data(pCoordIdx);
-    std::vector<unsigned int> inds;
-    unsigned int prim_type = 0;
-
-    if ( f_data.back() != ( -1 ) )
-    {
-        f_data.push_back( -1 );
-    }
-
-	// reserve average size.
-	pFaces.reserve(f_data.size() / 3);
-	inds.reserve(4);
-    //PrintVectorSet("build. ci", pCoordIdx);
-	for(std::vector<int32_t>::iterator it = f_data.begin(); it != f_data.end(); ++it)
-	{
-		// when face is got count how many indices in it.
-		if(*it == (-1))
-		{
-			aiFace tface;
-			size_t ts;
-
-			ts = inds.size();
-			switch(ts)
-			{
-				case 0: goto mg_m_err;
-				case 1: prim_type |= aiPrimitiveType_POINT; break;
-				case 2: prim_type |= aiPrimitiveType_LINE; break;
-				case 3: prim_type |= aiPrimitiveType_TRIANGLE; break;
-				default: prim_type |= aiPrimitiveType_POLYGON; break;
-			}
-
-			tface.mNumIndices = static_cast<unsigned int>(ts);
-			tface.mIndices = new unsigned int[ts];
-			memcpy(tface.mIndices, inds.data(), ts * sizeof(unsigned int));
-			pFaces.push_back(tface);
-			inds.clear();
-		}// if(*it == (-1))
-		else
-		{
-			inds.push_back(*it);
-		}// if(*it == (-1)) else
-	}// for(std::list<int32_t>::iterator it = f_data.begin(); it != f_data.end(); it++)
-//PrintVectorSet("build. faces", pCoordIdx);
-
-	pPrimitiveTypes = prim_type;
-
-	return;
-
-mg_m_err:
-
-	for(size_t i = 0, i_e = pFaces.size(); i < i_e; i++) delete [] pFaces.at(i).mIndices;
-
-	pFaces.clear();
-}
-
-void X3DImporter::MeshGeometry_AddColor(aiMesh& pMesh, const std::list<aiColor3D>& pColors, const bool pColorPerVertex) const
-{
-std::list<aiColor4D> tcol;
-
-	// create RGBA array from RGB.
-	for(std::list<aiColor3D>::const_iterator it = pColors.begin(); it != pColors.end(); ++it) tcol.push_back(aiColor4D((*it).r, (*it).g, (*it).b, 1));
-
-	// call existing function for adding RGBA colors
-	MeshGeometry_AddColor(pMesh, tcol, pColorPerVertex);
-}
-
-void X3DImporter::MeshGeometry_AddColor(aiMesh& pMesh, const std::list<aiColor4D>& pColors, const bool pColorPerVertex) const
-{
-    std::list<aiColor4D>::const_iterator col_it = pColors.begin();
-
-	if(pColorPerVertex)
-	{
-		if(pColors.size() < pMesh.mNumVertices)
-		{
-			throw DeadlyImportError("MeshGeometry_AddColor1. Colors count(" + to_string(pColors.size()) + ") can not be less than Vertices count(" +
-									to_string(pMesh.mNumVertices) +  ").");
-		}
-
-		// copy colors to mesh
-		pMesh.mColors[0] = new aiColor4D[pMesh.mNumVertices];
-		for(size_t i = 0; i < pMesh.mNumVertices; i++) pMesh.mColors[0][i] = *col_it++;
-	}// if(pColorPerVertex)
-	else
-	{
-		if(pColors.size() < pMesh.mNumFaces)
-		{
-			throw DeadlyImportError("MeshGeometry_AddColor1. Colors count(" + to_string(pColors.size()) + ") can not be less than Faces count(" +
-									to_string(pMesh.mNumFaces) +  ").");
-		}
-
-		// copy colors to mesh
-		pMesh.mColors[0] = new aiColor4D[pMesh.mNumVertices];
-		for(size_t fi = 0; fi < pMesh.mNumFaces; fi++)
-		{
-			// apply color to all vertices of face
-            for ( size_t vi = 0, vi_e = pMesh.mFaces[ fi ].mNumIndices; vi < vi_e; vi++ )
-            {
-                pMesh.mColors[ 0 ][ pMesh.mFaces[ fi ].mIndices[ vi ] ] = *col_it;
-            }
-
-			++col_it;
-		}
-	}// if(pColorPerVertex) else
-}
-
-void X3DImporter::MeshGeometry_AddColor(aiMesh& pMesh, const std::vector<int32_t>& pCoordIdx, const std::vector<int32_t>& pColorIdx,
-										const std::list<aiColor3D>& pColors, const bool pColorPerVertex) const
-{
-    std::list<aiColor4D> tcol;
-
-	// create RGBA array from RGB.
-    for ( std::list<aiColor3D>::const_iterator it = pColors.begin(); it != pColors.end(); ++it )
-    {
-        tcol.push_back( aiColor4D( ( *it ).r, ( *it ).g, ( *it ).b, 1 ) );
-    }
-
-	// call existing function for adding RGBA colors
-	MeshGeometry_AddColor(pMesh, pCoordIdx, pColorIdx, tcol, pColorPerVertex);
-}
-
-void X3DImporter::MeshGeometry_AddColor(aiMesh& pMesh, const std::vector<int32_t>& pCoordIdx, const std::vector<int32_t>& pColorIdx,
-										const std::list<aiColor4D>& pColors, const bool pColorPerVertex) const
-{
-    std::vector<aiColor4D> col_tgt_arr;
-    std::list<aiColor4D> col_tgt_list;
-    std::vector<aiColor4D> col_arr_copy;
-
-    if ( pCoordIdx.size() == 0 )
-    {
-        throw DeadlyImportError( "MeshGeometry_AddColor2. pCoordIdx can not be empty." );
-    }
-
-	// copy list to array because we are need indexed access to colors.
-	col_arr_copy.reserve(pColors.size());
-    for ( std::list<aiColor4D>::const_iterator it = pColors.begin(); it != pColors.end(); ++it )
-    {
-        col_arr_copy.push_back( *it );
-    }
-
-	if(pColorPerVertex)
-	{
-		if(pColorIdx.size() > 0)
-		{
-			// check indices array count.
-			if(pColorIdx.size() < pCoordIdx.size())
-			{
-				throw DeadlyImportError("MeshGeometry_AddColor2. Colors indices count(" + to_string(pColorIdx.size()) +
-										") can not be less than Coords inidces count(" + to_string(pCoordIdx.size()) +  ").");
-			}
-			// create list with colors for every vertex.
-			col_tgt_arr.resize(pMesh.mNumVertices);
-			for(std::vector<int32_t>::const_iterator colidx_it = pColorIdx.begin(), coordidx_it = pCoordIdx.begin(); colidx_it != pColorIdx.end(); ++colidx_it, ++coordidx_it)
-			{
-                if ( *colidx_it == ( -1 ) )
-                {
-                    continue;// skip faces delimiter
-                }
-                if ( ( unsigned int ) ( *coordidx_it ) > pMesh.mNumVertices )
-                {
-                    throw DeadlyImportError( "MeshGeometry_AddColor2. Coordinate idx is out of range." );
-                }
-                if ( ( unsigned int ) *colidx_it > pMesh.mNumVertices )
-                {
-                    throw DeadlyImportError( "MeshGeometry_AddColor2. Color idx is out of range." );
-                }
-
-				col_tgt_arr[*coordidx_it] = col_arr_copy[*colidx_it];
-			}
-		}// if(pColorIdx.size() > 0)
-		else
-		{
-			// when color indices list is absent use CoordIdx.
-			// check indices array count.
-			if(pColors.size() < pMesh.mNumVertices)
-			{
-				throw DeadlyImportError("MeshGeometry_AddColor2. Colors count(" + to_string(pColors.size()) + ") can not be less than Vertices count(" +
-										to_string(pMesh.mNumVertices) +  ").");
-			}
-			// create list with colors for every vertex.
-			col_tgt_arr.resize(pMesh.mNumVertices);
-            for ( size_t i = 0; i < pMesh.mNumVertices; i++ )
-            {
-                col_tgt_arr[ i ] = col_arr_copy[ i ];
-            }
-		}// if(pColorIdx.size() > 0) else
-	}// if(pColorPerVertex)
-	else
-	{
-		if(pColorIdx.size() > 0)
-		{
-			// check indices array count.
-			if(pColorIdx.size() < pMesh.mNumFaces)
-			{
-				throw DeadlyImportError("MeshGeometry_AddColor2. Colors indices count(" + to_string(pColorIdx.size()) +
-										") can not be less than Faces count(" + to_string(pMesh.mNumFaces) +  ").");
-			}
-			// create list with colors for every vertex using faces indices.
-			col_tgt_arr.resize(pMesh.mNumFaces);
-
-			std::vector<int32_t>::const_iterator colidx_it = pColorIdx.begin();
-			for(size_t fi = 0; fi < pMesh.mNumFaces; fi++)
-			{
-				if((unsigned int)*colidx_it > pMesh.mNumFaces) throw DeadlyImportError("MeshGeometry_AddColor2. Face idx is out of range.");
-
-				col_tgt_arr[fi] = col_arr_copy[*colidx_it++];
-			}
-		}// if(pColorIdx.size() > 0)
-		else
-		{
-			// when color indices list is absent use CoordIdx.
-			// check indices array count.
-			if(pColors.size() < pMesh.mNumFaces)
-			{
-				throw DeadlyImportError("MeshGeometry_AddColor2. Colors count(" + to_string(pColors.size()) + ") can not be less than Faces count(" +
-										to_string(pMesh.mNumFaces) +  ").");
-			}
-			// create list with colors for every vertex using faces indices.
-			col_tgt_arr.resize(pMesh.mNumFaces);
-			for(size_t fi = 0; fi < pMesh.mNumFaces; fi++) col_tgt_arr[fi] = col_arr_copy[fi];
-
-		}// if(pColorIdx.size() > 0) else
-	}// if(pColorPerVertex) else
-
-	// copy array to list for calling function that add colors.
-	for(std::vector<aiColor4D>::const_iterator it = col_tgt_arr.begin(); it != col_tgt_arr.end(); ++it) col_tgt_list.push_back(*it);
-	// add prepared colors list to mesh.
-	MeshGeometry_AddColor(pMesh, col_tgt_list, pColorPerVertex);
-}
-
-void X3DImporter::MeshGeometry_AddNormal(aiMesh& pMesh, const std::vector<int32_t>& pCoordIdx, const std::vector<int32_t>& pNormalIdx,
-								const std::list<aiVector3D>& pNormals, const bool pNormalPerVertex) const
-{
-    std::vector<size_t> tind;
-    std::vector<aiVector3D> norm_arr_copy;
-
-	// copy list to array because we are need indexed access to normals.
-	norm_arr_copy.reserve(pNormals.size());
-    for ( std::list<aiVector3D>::const_iterator it = pNormals.begin(); it != pNormals.end(); ++it )
-    {
-        norm_arr_copy.push_back( *it );
-    }
-
-	if(pNormalPerVertex)
-	{
-		if(pNormalIdx.size() > 0)
-		{
-			// check indices array count.
-			if(pNormalIdx.size() != pCoordIdx.size()) throw DeadlyImportError("Normals and Coords inidces count must be equal.");
-
-			tind.reserve(pNormalIdx.size());
-			for(std::vector<int32_t>::const_iterator it = pNormalIdx.begin(); it != pNormalIdx.end(); ++it)
-			{
-				if(*it != (-1)) tind.push_back(*it);
-			}
-
-			// copy normals to mesh
-			pMesh.mNormals = new aiVector3D[pMesh.mNumVertices];
-			for(size_t i = 0; (i < pMesh.mNumVertices) && (i < tind.size()); i++)
-			{
-				if(tind[i] >= norm_arr_copy.size())
-					throw DeadlyImportError("MeshGeometry_AddNormal. Normal index(" + to_string(tind[i]) +
-											") is out of range. Normals count: " + to_string(norm_arr_copy.size()) + ".");
-
-				pMesh.mNormals[i] = norm_arr_copy[tind[i]];
-			}
-		}
-		else
-		{
-			if(pNormals.size() != pMesh.mNumVertices) throw DeadlyImportError("MeshGeometry_AddNormal. Normals and vertices count must be equal.");
-
-			// copy normals to mesh
-			pMesh.mNormals = new aiVector3D[pMesh.mNumVertices];
-			std::list<aiVector3D>::const_iterator norm_it = pNormals.begin();
-			for(size_t i = 0; i < pMesh.mNumVertices; i++) pMesh.mNormals[i] = *norm_it++;
-		}
-	}// if(pNormalPerVertex)
-	else
-	{
-		if(pNormalIdx.size() > 0)
-		{
-			if(pMesh.mNumFaces != pNormalIdx.size()) throw DeadlyImportError("Normals faces count must be equal to mesh faces count.");
-
-			std::vector<int32_t>::const_iterator normidx_it = pNormalIdx.begin();
-
-			tind.reserve(pNormalIdx.size());
-			for(size_t i = 0, i_e = pNormalIdx.size(); i < i_e; i++) tind.push_back(*normidx_it++);
-
-		}
-		else
-		{
-			tind.reserve(pMesh.mNumFaces);
-			for(size_t i = 0; i < pMesh.mNumFaces; i++) tind.push_back(i);
-
-		}
-
-		// copy normals to mesh
-		pMesh.mNormals = new aiVector3D[pMesh.mNumVertices];
-		for(size_t fi = 0; fi < pMesh.mNumFaces; fi++)
-		{
-			aiVector3D tnorm;
-
-			tnorm = norm_arr_copy[tind[fi]];
-			for(size_t vi = 0, vi_e = pMesh.mFaces[fi].mNumIndices; vi < vi_e; vi++) pMesh.mNormals[pMesh.mFaces[fi].mIndices[vi]] = tnorm;
-		}
-	}// if(pNormalPerVertex) else
-}
-
-void X3DImporter::MeshGeometry_AddNormal(aiMesh& pMesh, const std::list<aiVector3D>& pNormals, const bool pNormalPerVertex) const
-{
-    std::list<aiVector3D>::const_iterator norm_it = pNormals.begin();
-
-	if(pNormalPerVertex)
-	{
-		if(pNormals.size() != pMesh.mNumVertices) throw DeadlyImportError("MeshGeometry_AddNormal. Normals and vertices count must be equal.");
-
-		// copy normals to mesh
-		pMesh.mNormals = new aiVector3D[pMesh.mNumVertices];
-		for(size_t i = 0; i < pMesh.mNumVertices; i++) pMesh.mNormals[i] = *norm_it++;
-	}// if(pNormalPerVertex)
-	else
-	{
-		if(pNormals.size() != pMesh.mNumFaces) throw DeadlyImportError("MeshGeometry_AddNormal. Normals and faces count must be equal.");
-
-		// copy normals to mesh
-		pMesh.mNormals = new aiVector3D[pMesh.mNumVertices];
-		for(size_t fi = 0; fi < pMesh.mNumFaces; fi++)
-		{
-			// apply color to all vertices of face
-			for(size_t vi = 0, vi_e = pMesh.mFaces[fi].mNumIndices; vi < vi_e; vi++) pMesh.mNormals[pMesh.mFaces[fi].mIndices[vi]] = *norm_it;
-
-			++norm_it;
-		}
-	}// if(pNormalPerVertex) else
-}
-
-void X3DImporter::MeshGeometry_AddTexCoord(aiMesh& pMesh, const std::vector<int32_t>& pCoordIdx, const std::vector<int32_t>& pTexCoordIdx,
-								const std::list<aiVector2D>& pTexCoords) const
-{
-    std::vector<aiVector3D> texcoord_arr_copy;
-    std::vector<aiFace> faces;
-    unsigned int prim_type;
-
-	// copy list to array because we are need indexed access to normals.
-	texcoord_arr_copy.reserve(pTexCoords.size());
-	for(std::list<aiVector2D>::const_iterator it = pTexCoords.begin(); it != pTexCoords.end(); ++it)
-	{
-		texcoord_arr_copy.push_back(aiVector3D((*it).x, (*it).y, 0));
-	}
-
-	if(pTexCoordIdx.size() > 0)
-	{
-		GeometryHelper_CoordIdxStr2FacesArr(pTexCoordIdx, faces, prim_type);
-        if ( faces.empty() )
-        {
-            throw DeadlyImportError( "Failed to add texture coordinates to mesh, faces list is empty." );
-        }
-        if ( faces.size() != pMesh.mNumFaces )
-        {
-            throw DeadlyImportError( "Texture coordinates faces count must be equal to mesh faces count." );
-        }
-	}
-	else
-	{
-		GeometryHelper_CoordIdxStr2FacesArr(pCoordIdx, faces, prim_type);
-	}
-
-	pMesh.mTextureCoords[0] = new aiVector3D[pMesh.mNumVertices];
-	pMesh.mNumUVComponents[0] = 2;
-	for(size_t fi = 0, fi_e = faces.size(); fi < fi_e; fi++)
-	{
-		if(pMesh.mFaces[fi].mNumIndices != faces.at(fi).mNumIndices)
-			throw DeadlyImportError("Number of indices in texture face and mesh face must be equal. Invalid face index: " + to_string(fi) + ".");
-
-		for(size_t ii = 0; ii < pMesh.mFaces[fi].mNumIndices; ii++)
-		{
-			size_t vert_idx = pMesh.mFaces[fi].mIndices[ii];
-			size_t tc_idx = faces.at(fi).mIndices[ii];
-
-			pMesh.mTextureCoords[0][vert_idx] = texcoord_arr_copy.at(tc_idx);
-		}
-	}// for(size_t fi = 0, fi_e = faces.size(); fi < fi_e; fi++)
-}
-
-void X3DImporter::MeshGeometry_AddTexCoord(aiMesh& pMesh, const std::list<aiVector2D>& pTexCoords) const
-{
-    std::vector<aiVector3D> tc_arr_copy;
-
-    if ( pTexCoords.size() != pMesh.mNumVertices )
-    {
-        throw DeadlyImportError( "MeshGeometry_AddTexCoord. Texture coordinates and vertices count must be equal." );
-    }
-
-	// copy list to array because we are need convert aiVector2D to aiVector3D and also get indexed access as a bonus.
-	tc_arr_copy.reserve(pTexCoords.size());
-    for ( std::list<aiVector2D>::const_iterator it = pTexCoords.begin(); it != pTexCoords.end(); ++it )
-    {
-        tc_arr_copy.push_back( aiVector3D( ( *it ).x, ( *it ).y, 0 ) );
-    }
-
-	// copy texture coordinates to mesh
-	pMesh.mTextureCoords[0] = new aiVector3D[pMesh.mNumVertices];
-	pMesh.mNumUVComponents[0] = 2;
-    for ( size_t i = 0; i < pMesh.mNumVertices; i++ )
-    {
-        pMesh.mTextureCoords[ 0 ][ i ] = tc_arr_copy[ i ];
-    }
-}
-
-aiMesh* X3DImporter::GeometryHelper_MakeMesh(const std::vector<int32_t>& pCoordIdx, const std::list<aiVector3D>& pVertices) const
-{
-    std::vector<aiFace> faces;
-    unsigned int prim_type = 0;
-
-	// create faces array from input string with vertices indices.
-	GeometryHelper_CoordIdxStr2FacesArr(pCoordIdx, faces, prim_type);
-    if ( !faces.size() )
-    {
-        throw DeadlyImportError( "Failed to create mesh, faces list is empty." );
-    }
-
-	//
-	// Create new mesh and copy geometry data.
-	//
-    aiMesh *tmesh = new aiMesh;
-    size_t ts = faces.size();
-	// faces
-	tmesh->mFaces = new aiFace[ts];
-	tmesh->mNumFaces = static_cast<unsigned int>(ts);
-	for(size_t i = 0; i < ts; i++) tmesh->mFaces[i] = faces.at(i);
-
-	// vertices
-	std::list<aiVector3D>::const_iterator vit = pVertices.begin();
-
-	ts = pVertices.size();
-	tmesh->mVertices = new aiVector3D[ts];
-	tmesh->mNumVertices = static_cast<unsigned int>(ts);
-    for ( size_t i = 0; i < ts; i++ )
-    {
-        tmesh->mVertices[ i ] = *vit++;
-    }
-
-	// set primitives type and return result.
-	tmesh->mPrimitiveTypes = prim_type;
-
-	return tmesh;
-}
-
-/*********************************************************************************************************************************************/
-/************************************************************ Functions: parse set ***********************************************************/
-/*********************************************************************************************************************************************/
-
-void X3DImporter::ParseHelper_Group_Begin(const bool pStatic)
-{
-    CX3DImporter_NodeElement_Group* new_group = new CX3DImporter_NodeElement_Group(NodeElement_Cur, pStatic);// create new node with current node as parent.
-
-	// if we are adding not the root element then add new element to current element child list.
-    if ( NodeElement_Cur != nullptr )
-    {
-        NodeElement_Cur->Child.push_back( new_group );
-    }
-
-	NodeElement_List.push_back(new_group);// it's a new element - add it to list.
-	NodeElement_Cur = new_group;// switch current element to new one.
-}
-
-void X3DImporter::ParseHelper_Node_Enter(CX3DImporter_NodeElement* pNode)
-{
-	NodeElement_Cur->Child.push_back(pNode);// add new element to current element child list.
-	NodeElement_Cur = pNode;// switch current element to new one.
-}
-
-void X3DImporter::ParseHelper_Node_Exit()
-{
-	// check if we can walk up.
-    if ( NodeElement_Cur != nullptr )
-    {
-        NodeElement_Cur = NodeElement_Cur->Parent;
-    }
-}
-
-void X3DImporter::ParseHelper_FixTruncatedFloatString(const char* pInStr, std::string& pOutString)
-{
-	pOutString.clear();
-    const size_t instr_len = strlen(pInStr);
-    if ( 0 == instr_len )
-    {
-        return;
-    }
-
-	pOutString.reserve(instr_len * 3 / 2);
-	// check and correct floats in format ".x". Must be "x.y".
-    if ( pInStr[ 0 ] == '.' )
-    {
-        pOutString.push_back( '0' );
-    }
-
-	pOutString.push_back(pInStr[0]);
-	for(size_t ci = 1; ci < instr_len; ci++)
-	{
-		if((pInStr[ci] == '.') && ((pInStr[ci - 1] == ' ') || (pInStr[ci - 1] == '-') || (pInStr[ci - 1] == '+') || (pInStr[ci - 1] == '\t')))
-		{
-			pOutString.push_back('0');
-			pOutString.push_back('.');
-		}
-		else
-		{
-			pOutString.push_back(pInStr[ci]);
-		}
-	}
-}
-
-extern FIVocabulary X3D_vocabulary_3_2;
-extern FIVocabulary X3D_vocabulary_3_3;
-
-void X3DImporter::ParseFile(const std::string& pFile, IOSystem* pIOHandler)
-{
-    std::unique_ptr<FIReader> OldReader = std::move(mReader);// store current XMLreader.
-    std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));
-
-	// Check whether we can read from the file
-    if ( file.get() == nullptr )
-    {
-        throw DeadlyImportError( "Failed to open X3D file " + pFile + "." );
-    }
-	mReader = FIReader::create(file.get());
-    if ( !mReader )
-    {
-        throw DeadlyImportError( "Failed to create XML reader for file" + pFile + "." );
-    }
-    mReader->registerVocabulary("urn:web3d:x3d:fi-vocabulary-3.2", &X3D_vocabulary_3_2);
-    mReader->registerVocabulary("urn:web3d:x3d:fi-vocabulary-3.3", &X3D_vocabulary_3_3);
-	// start reading
-	ParseNode_Root();
-
-	// restore old XMLreader
-	mReader = std::move(OldReader);
-}
-
-void X3DImporter::ParseNode_Root()
-{
-	// search for root tag <X3D>
-    if ( !XML_SearchNode( "X3D" ) )
-    {
-        throw DeadlyImportError( "Root node \"X3D\" not found." );
-    }
-
-	ParseHelper_Group_Begin();// create root node element.
-	// parse other contents
-	while(mReader->read())
-	{
-        if ( mReader->getNodeType() != irr::io::EXN_ELEMENT )
-        {
-            continue;
-        }
-
-		if(XML_CheckNode_NameEqual("head"))
-			ParseNode_Head();
-		else if(XML_CheckNode_NameEqual("Scene"))
-			ParseNode_Scene();
-		else
-			XML_CheckNode_SkipUnsupported("Root");
-	}
-
-	// exit from root node element.
-	ParseHelper_Node_Exit();
-}
-
-void X3DImporter::ParseNode_Head()
-{
-    bool close_found = false;// flag: true if close tag of node are found.
-
-	while(mReader->read())
-	{
-		if(mReader->getNodeType() == irr::io::EXN_ELEMENT)
-		{
-			if(XML_CheckNode_NameEqual("meta"))
-			{
-				XML_CheckNode_MustBeEmpty();
-
-				// adding metadata from <head> as MetaString from <Scene>
-                bool added( false );
-                CX3DImporter_NodeElement_MetaString* ms = new CX3DImporter_NodeElement_MetaString(NodeElement_Cur);
-
-				ms->Name = mReader->getAttributeValueSafe("name");
-				// name must not be empty
-				if(!ms->Name.empty())
-				{
-					ms->Value.push_back(mReader->getAttributeValueSafe("content"));
-					NodeElement_List.push_back(ms);
-                    if ( NodeElement_Cur != nullptr )
-                    {
-                        NodeElement_Cur->Child.push_back( ms );
-                        added = true;
-                    }
-				}
-                // if an error has occurred, release instance
-                if ( !added ) {
-                    delete ms;
-                }
-			}// if(XML_CheckNode_NameEqual("meta"))
-		}// if(mReader->getNodeType() == irr::io::EXN_ELEMENT)
-		else if(mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
-		{
-			if(XML_CheckNode_NameEqual("head"))
-			{
-				close_found = true;
-				break;
-			}
-		}// if(mReader->getNodeType() == irr::io::EXN_ELEMENT) else
-	}// while(mReader->read())
-
-    if ( !close_found )
-    {
-        Throw_CloseNotFound( "head" );
-    }
-}
-
-void X3DImporter::ParseNode_Scene()
-{
-    auto GroupCounter_Increase = [](size_t& pCounter, const char* pGroupName) -> void
-    {
-	    pCounter++;
-	    if(pCounter == 0) throw DeadlyImportError("Group counter overflow. Too much groups with type: " + std::string(pGroupName) + ".");
-};
-
-auto GroupCounter_Decrease = [&](size_t& pCounter, const char* pGroupName) -> void
-{
-	if(pCounter == 0) Throw_TagCountIncorrect(pGroupName);
-
-	pCounter--;
-};
-
-static const char* GroupName_Group = "Group";
-static const char* GroupName_StaticGroup = "StaticGroup";
-static const char* GroupName_Transform = "Transform";
-static const char* GroupName_Switch = "Switch";
-
-bool close_found = false;
-size_t counter_group = 0;
-size_t counter_transform = 0;
-size_t counter_switch = 0;
-
-	// while create static node? Because objects name used deeper in "USE" attribute can be equal to some meta in <head> node.
-	ParseHelper_Group_Begin(true);
-	while(mReader->read())
-	{
-		if(mReader->getNodeType() == irr::io::EXN_ELEMENT)
-		{
-			if(XML_CheckNode_NameEqual("Shape"))
-			{
-				ParseNode_Shape_Shape();
-			}
-			else if(XML_CheckNode_NameEqual(GroupName_Group))
-			{
-				GroupCounter_Increase(counter_group, GroupName_Group);
-				ParseNode_Grouping_Group();
-				// if node is empty then decrease group counter at this place.
-				if(mReader->isEmptyElement()) GroupCounter_Decrease(counter_group, GroupName_Group);
-			}
-			else if(XML_CheckNode_NameEqual(GroupName_StaticGroup))
-			{
-				GroupCounter_Increase(counter_group, GroupName_StaticGroup);
-				ParseNode_Grouping_StaticGroup();
-				// if node is empty then decrease group counter at this place.
-				if(mReader->isEmptyElement()) GroupCounter_Decrease(counter_group, GroupName_StaticGroup);
-			}
-			else if(XML_CheckNode_NameEqual(GroupName_Transform))
-			{
-				GroupCounter_Increase(counter_transform, GroupName_Transform);
-				ParseNode_Grouping_Transform();
-				// if node is empty then decrease group counter at this place.
-				if(mReader->isEmptyElement()) GroupCounter_Decrease(counter_transform, GroupName_Transform);
-			}
-			else if(XML_CheckNode_NameEqual(GroupName_Switch))
-			{
-				GroupCounter_Increase(counter_switch, GroupName_Switch);
-				ParseNode_Grouping_Switch();
-				// if node is empty then decrease group counter at this place.
-				if(mReader->isEmptyElement()) GroupCounter_Decrease(counter_switch, GroupName_Switch);
-			}
-			else if(XML_CheckNode_NameEqual("DirectionalLight"))
-		{
-				ParseNode_Lighting_DirectionalLight();
-			}
-			else if(XML_CheckNode_NameEqual("PointLight"))
-			{
-				ParseNode_Lighting_PointLight();
-			}
-			else if(XML_CheckNode_NameEqual("SpotLight"))
-			{
-				ParseNode_Lighting_SpotLight();
-			}
-			else if(XML_CheckNode_NameEqual("Inline"))
-			{
-				ParseNode_Networking_Inline();
-			}
-			else if(!ParseHelper_CheckRead_X3DMetadataObject())
-			{
-				XML_CheckNode_SkipUnsupported("Scene");
-			}
-		}// if(mReader->getNodeType() == irr::io::EXN_ELEMENT)
-		else if(mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
-		{
-			if(XML_CheckNode_NameEqual("Scene"))
-			{
-				close_found = true;
-
-				break;
-			}
-			else if(XML_CheckNode_NameEqual(GroupName_Group))
-			{
-				GroupCounter_Decrease(counter_group, GroupName_Group);
-				ParseNode_Grouping_GroupEnd();
-			}
-			else if(XML_CheckNode_NameEqual(GroupName_StaticGroup))
-			{
-				GroupCounter_Decrease(counter_group, GroupName_StaticGroup);
-				ParseNode_Grouping_StaticGroupEnd();
-			}
-			else if(XML_CheckNode_NameEqual(GroupName_Transform))
-			{
-				GroupCounter_Decrease(counter_transform, GroupName_Transform);
-				ParseNode_Grouping_TransformEnd();
-			}
-			else if(XML_CheckNode_NameEqual(GroupName_Switch))
-			{
-				GroupCounter_Decrease(counter_switch, GroupName_Switch);
-				ParseNode_Grouping_SwitchEnd();
-			}
-		}// if(mReader->getNodeType() == irr::io::EXN_ELEMENT) else
-	}// while(mReader->read())
-
-	ParseHelper_Node_Exit();
-
-	if(counter_group) Throw_TagCountIncorrect("Group");
-	if(counter_transform) Throw_TagCountIncorrect("Transform");
-	if(counter_switch) Throw_TagCountIncorrect("Switch");
-	if(!close_found) Throw_CloseNotFound("Scene");
-
-}
-
-/*********************************************************************************************************************************************/
-/******************************************************** Functions: BaseImporter set ********************************************************/
-/*********************************************************************************************************************************************/
-
-bool X3DImporter::CanRead(const std::string& pFile, IOSystem* pIOHandler, bool pCheckSig) const
-{
-    const std::string extension = GetExtension(pFile);
-
-	if((extension == "x3d") || (extension == "x3db")) return true;
-
-	if(!extension.length() || pCheckSig)
-	{
-		const char* tokens[] = { "DOCTYPE X3D PUBLIC", "http://www.web3d.org/specifications/x3d" };
-
-		return SearchFileHeaderForToken(pIOHandler, pFile, tokens, 2);
-	}
-
-	return false;
-}
-
-void X3DImporter::GetExtensionList(std::set<std::string>& pExtensionList)
-{
-	pExtensionList.insert("x3d");
-	pExtensionList.insert("x3db");
-}
-
-const aiImporterDesc* X3DImporter::GetInfo () const
-{
-	return &Description;
-}
-
-void X3DImporter::InternReadFile(const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler)
-{
-	mpIOHandler = pIOHandler;
-
-	Clear();// delete old graph.
-	std::string::size_type slashPos = pFile.find_last_of("\\/");
-	pIOHandler->PushDirectory(slashPos == std::string::npos ? std::string() : pFile.substr(0, slashPos + 1));
-	ParseFile(pFile, pIOHandler);
-	pIOHandler->PopDirectory();
-	//
-	// Assimp use static arrays of objects for fast speed of rendering. That's good, but need some additional operations/
-	// We know that geometry objects(meshes) are stored in <Shape>, also in <Shape>-><Appearance> materials(in Assimp logical view)
-	// are stored. So at first we need to count how meshes and materials are stored in scene graph.
-	//
-	// at first creating root node for aiScene.
-	pScene->mRootNode = new aiNode;
-	pScene->mRootNode->mParent = nullptr;
-	pScene->mFlags |= AI_SCENE_FLAGS_ALLOW_SHARED;
-	//search for root node element
-	NodeElement_Cur = NodeElement_List.front();
-	while(NodeElement_Cur->Parent != nullptr) NodeElement_Cur = NodeElement_Cur->Parent;
-
-	{// fill aiScene with objects.
-		std::list<aiMesh*> mesh_list;
-		std::list<aiMaterial*> mat_list;
-		std::list<aiLight*> light_list;
-
-		// create nodes tree
-		Postprocess_BuildNode(*NodeElement_Cur, *pScene->mRootNode, mesh_list, mat_list, light_list);
-		// copy needed data to scene
-		if(!mesh_list.empty())
-		{
-			std::list<aiMesh*>::const_iterator it = mesh_list.begin();
-
-			pScene->mNumMeshes = static_cast<unsigned int>(mesh_list.size());
-			pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];
-			for(size_t i = 0; i < pScene->mNumMeshes; i++) pScene->mMeshes[i] = *it++;
-		}
-
-		if(!mat_list.empty())
-		{
-			std::list<aiMaterial*>::const_iterator it = mat_list.begin();
-
-			pScene->mNumMaterials = static_cast<unsigned int>(mat_list.size());
-			pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials];
-			for(size_t i = 0; i < pScene->mNumMaterials; i++) pScene->mMaterials[i] = *it++;
-		}
-
-		if(!light_list.empty())
-		{
-			std::list<aiLight*>::const_iterator it = light_list.begin();
-
-			pScene->mNumLights = static_cast<unsigned int>(light_list.size());
-			pScene->mLights = new aiLight*[pScene->mNumLights];
-			for(size_t i = 0; i < pScene->mNumLights; i++) pScene->mLights[i] = *it++;
-		}
-	}// END: fill aiScene with objects.
-
-	///TODO: IME optimize tree
-}
-
-}// namespace Assimp
-
-#endif // !ASSIMP_BUILD_NO_X3D_IMPORTER
diff --git a/Engine/lib/assimp/code/X3D/X3DImporter.hpp b/Engine/lib/assimp/code/X3D/X3DImporter.hpp
deleted file mode 100644
index a4afc1463..000000000
--- a/Engine/lib/assimp/code/X3D/X3DImporter.hpp
+++ /dev/null
@@ -1,834 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-/// \file   X3DImporter.hpp
-/// \brief  X3D-format files importer for Assimp.
-/// \date   2015-2016
-/// \author smal.root@gmail.com
-// Thanks to acorn89 for support.
-
-#ifndef INCLUDED_AI_X3D_IMPORTER_H
-#define INCLUDED_AI_X3D_IMPORTER_H
-
-#include "X3DImporter_Node.hpp"
-
-// Header files, Assimp.
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/importerdesc.h>
-#include <assimp/ProgressHandler.hpp>
-#include <assimp/types.h>
-#include <assimp/BaseImporter.h>
-#include <assimp/irrXMLWrapper.h>
-#include "FIReader.hpp"
-//#include <regex>
-
-namespace Assimp {
-
-/// \class X3DImporter
-/// Class that holding scene graph which include: groups, geometry, metadata etc.
-///
-/// Limitations.
-///
-/// Pay attention that X3D is format for interactive graphic and simulations for web browsers.
-/// So not all features can be imported using Assimp.
-///
-/// Unsupported nodes:
-/// 	CAD geometry component:
-///			"CADAssembly", "CADFace", "CADLayer", "CADPart", "IndexedQuadSet", "QuadSet"
-///		Core component:
-///			"ROUTE", "ExternProtoDeclare", "ProtoDeclare", "ProtoInstance", "ProtoInterface", "WorldInfo"
-///		Distributed interactive simulation (DIS) component:
-///			"DISEntityManager", "DISEntityTypeMapping", "EspduTransform", "ReceiverPdu", "SignalPdu", "TransmitterPdu"
-///		Cube map environmental texturing component:
-///			"ComposedCubeMapTexture", "GeneratedCubeMapTexture", "ImageCubeMapTexture"
-///		Environmental effects component:
-///			"Background", "Fog", "FogCoordinate", "LocalFog", "TextureBackground"
-///		Environmental sensor component:
-///			"ProximitySensor", "TransformSensor", "VisibilitySensor"
-///		Followers component:
-///			"ColorChaser", "ColorDamper", "CoordinateChaser", "CoordinateDamper", "OrientationChaser", "OrientationDamper", "PositionChaser",
-///			"PositionChaser2D", "PositionDamper", "PositionDamper2D", "ScalarChaser", "ScalarDamper", "TexCoordChaser2D", "TexCoordDamper2D"
-///		Geospatial component:
-///			"GeoCoordinate", "GeoElevationGrid", "GeoLocation", "GeoLOD", "GeoMetadata", "GeoOrigin", "GeoPositionInterpolator", "GeoProximitySensor",
-///			"GeoTouchSensor", "GeoTransform", "GeoViewpoint"
-///		Humanoid Animation (H-Anim) component:
-///			"HAnimDisplacer", "HAnimHumanoid", "HAnimJoint", "HAnimSegment", "HAnimSite"
-///		Interpolation component:
-///			"ColorInterpolator", "CoordinateInterpolator", "CoordinateInterpolator2D", "EaseInEaseOut", "NormalInterpolator", "OrientationInterpolator",
-///			"PositionInterpolator", "PositionInterpolator2D", "ScalarInterpolator", "SplinePositionInterpolator", "SplinePositionInterpolator2D",
-///			"SplineScalarInterpolator", "SquadOrientationInterpolator",
-///		Key device sensor component:
-///			"KeySensor", "StringSensor"
-///		Layering component:
-///			"Layer", "LayerSet", "Viewport"
-///		Layout component:
-///			"Layout", "LayoutGroup", "LayoutLayer", "ScreenFontStyle", "ScreenGroup"
-///		Navigation component:
-///			"Billboard", "Collision", "LOD", "NavigationInfo", "OrthoViewpoint", "Viewpoint", "ViewpointGroup"
-///		Networking component:
-///			"EXPORT", "IMPORT", "Anchor", "LoadSensor"
-///		NURBS component:
-///			"Contour2D", "ContourPolyline2D", "CoordinateDouble", "NurbsCurve", "NurbsCurve2D", "NurbsOrientationInterpolator", "NurbsPatchSurface",
-///			"NurbsPositionInterpolator", "NurbsSet", "NurbsSurfaceInterpolator", "NurbsSweptSurface", "NurbsSwungSurface", "NurbsTextureCoordinate",
-///			"NurbsTrimmedSurface"
-///		Particle systems component:
-///			"BoundedPhysicsModel", "ConeEmitter", "ExplosionEmitter", "ForcePhysicsModel", "ParticleSystem", "PointEmitter", "PolylineEmitter",
-///			"SurfaceEmitter", "VolumeEmitter", "WindPhysicsModel"
-///		Picking component:
-///			"LinePickSensor", "PickableGroup", "PointPickSensor", "PrimitivePickSensor", "VolumePickSensor"
-///		Pointing device sensor component:
-///			"CylinderSensor", "PlaneSensor", "SphereSensor", "TouchSensor"
-///		Rendering component:
-///			"ClipPlane"
-///		Rigid body physics:
-///			"BallJoint", "CollidableOffset", "CollidableShape", "CollisionCollection", "CollisionSensor", "CollisionSpace", "Contact", "DoubleAxisHingeJoint",
-///			"MotorJoint", "RigidBody", "RigidBodyCollection", "SingleAxisHingeJoint", "SliderJoint", "UniversalJoint"
-///		Scripting component:
-///			"Script"
-///		Programmable shaders component:
-///			"ComposedShader", "FloatVertexAttribute", "Matrix3VertexAttribute", "Matrix4VertexAttribute", "PackagedShader", "ProgramShader", "ShaderPart",
-///			"ShaderProgram",
-///		Shape component:
-///			"FillProperties", "LineProperties", "TwoSidedMaterial"
-///		Sound component:
-///			"AudioClip", "Sound"
-///		Text component:
-///			"FontStyle", "Text"
-///		Texturing3D Component:
-///			"ComposedTexture3D", "ImageTexture3D", "PixelTexture3D", "TextureCoordinate3D", "TextureCoordinate4D", "TextureTransformMatrix3D",
-///			"TextureTransform3D"
-///		Texturing component:
-///			"MovieTexture", "MultiTexture", "MultiTextureCoordinate", "MultiTextureTransform", "PixelTexture", "TextureCoordinateGenerator",
-///			"TextureProperties",
-///		Time component:
-///			"TimeSensor"
-///		Event Utilities component:
-///			"BooleanFilter", "BooleanSequencer", "BooleanToggle", "BooleanTrigger", "IntegerSequencer", "IntegerTrigger", "TimeTrigger",
-///		Volume rendering component:
-///			"BlendedVolumeStyle", "BoundaryEnhancementVolumeStyle", "CartoonVolumeStyle", "ComposedVolumeStyle", "EdgeEnhancementVolumeStyle",
-///			"IsoSurfaceVolumeData", "OpacityMapVolumeStyle", "ProjectionVolumeStyle", "SegmentedVolumeData", "ShadedVolumeStyle",
-///			"SilhouetteEnhancementVolumeStyle", "ToneMappedVolumeStyle", "VolumeData"
-///
-/// Supported nodes:
-///		Core component:
-///			"MetadataBoolean", "MetadataDouble", "MetadataFloat", "MetadataInteger", "MetadataSet", "MetadataString"
-///		Geometry2D component:
-///			"Arc2D", "ArcClose2D", "Circle2D", "Disk2D", "Polyline2D", "Polypoint2D", "Rectangle2D", "TriangleSet2D"
-///		Geometry3D component:
-///			"Box", "Cone", "Cylinder", "ElevationGrid", "Extrusion", "IndexedFaceSet", "Sphere"
-///		Grouping component:
-///			"Group", "StaticGroup", "Switch", "Transform"
-///		Lighting component:
-///			"DirectionalLight", "PointLight", "SpotLight"
-///		Networking component:
-///			"Inline"
-///		Rendering component:
-///			"Color", "ColorRGBA", "Coordinate", "IndexedLineSet", "IndexedTriangleFanSet", "IndexedTriangleSet", "IndexedTriangleStripSet", "LineSet",
-///			"PointSet", "TriangleFanSet", "TriangleSet", "TriangleStripSet", "Normal"
-///		Shape component:
-///			"Shape", "Appearance", "Material"
-///		Texturing component:
-///			"ImageTexture", "TextureCoordinate", "TextureTransform"
-///
-/// Limitations of attribute "USE".
-/// If "USE" is set then node must be empty, like that:
-///		<Node USE='name'/>
-/// not the
-///		<Node USE='name'><!-- something --> </Node>
-///
-/// Ignored attributes: "creaseAngle", "convex", "solid".
-///
-/// Texture coordinates generating: only for Sphere, Cone, Cylinder. In all other case used PLANE mapping.
-///		It's better that Assimp main code has powerful texture coordinates generator. Then is not needed to
-///		duplicate this code in every importer.
-///
-/// Lighting limitations.
-///		If light source placed in some group with "DEF" set. And after that some node is use it group with "USE" attribute then
-///		you will get error about duplicate light sources. That's happening because Assimp require names for lights but do not like
-///		duplicates of it )).
-///
-///	Color for faces.
-/// That's happening when attribute "colorPerVertex" is set to "false". But Assimp do not hold how many colors has mesh and require
-/// equal length for mVertices and mColors. You will see the colors but vertices will use call which last used in "colorIdx".
-///
-///	That's all for now. Enjoy
-///
-class X3DImporter : public BaseImporter
-{
-public:
-    std::list<CX3DImporter_NodeElement*> NodeElement_List;///< All elements of scene graph.
-
-public:
-    /***********************************************/
-    /****************** Functions ******************/
-    /***********************************************/
-
-    /// Default constructor.
-    X3DImporter();
-
-    /// Default destructor.
-    ~X3DImporter();
-
-    /***********************************************/
-    /******** Functions: parse set, public *********/
-    /***********************************************/
-
-    /// Parse X3D file and fill scene graph. The function has no return value. Result can be found by analyzing the generated graph.
-    /// Also exception can be thrown if trouble will found.
-    /// \param [in] pFile - name of file to be parsed.
-    /// \param [in] pIOHandler - pointer to IO helper object.
-    void ParseFile( const std::string& pFile, IOSystem* pIOHandler );
-
-    /***********************************************/
-    /********* Functions: BaseImporter set *********/
-    /***********************************************/
-
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler, bool pCheckSig ) const;
-    void GetExtensionList( std::set<std::string>& pExtensionList );
-    void InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler );
-    const aiImporterDesc* GetInfo()const;
-
-
-private:
-	/// Disabled copy constructor.
-	X3DImporter(const X3DImporter& pScene);
-
-	/// Disabled assign operator.
-	X3DImporter& operator=(const X3DImporter& pScene);
-
-	/// Clear all temporary data.
-	void Clear();
-
-	/***********************************************/
-	/************* Functions: find set *************/
-	/***********************************************/
-
-	/// Find requested node element. Search will be made in all existing nodes.
-	/// \param [in] pID - ID of requested element.
-	/// \param [in] pType - type of requested element.
-	/// \param [out] pElement - pointer to pointer to item found.
-	/// \return true - if the element is found, else - false.
-	bool FindNodeElement_FromRoot(const std::string& pID, const CX3DImporter_NodeElement::EType pType, CX3DImporter_NodeElement** pElement);
-
-	/// Find requested node element. Search will be made from pointed node down to childs.
-	/// \param [in] pStartNode - pointer to start node.
-	/// \param [in] pID - ID of requested element.
-	/// \param [in] pType - type of requested element.
-	/// \param [out] pElement - pointer to pointer to item found.
-	/// \return true - if the element is found, else - false.
-	bool FindNodeElement_FromNode(CX3DImporter_NodeElement* pStartNode, const std::string& pID, const CX3DImporter_NodeElement::EType pType,
-									CX3DImporter_NodeElement** pElement);
-
-	/// Find requested node element. For "Node"'s accounting flag "Static".
-	/// \param [in] pName - name of requested element.
-	/// \param [in] pType - type of requested element.
-	/// \param [out] pElement - pointer to pointer to item found.
-	/// \return true - if the element is found, else - false.
-	bool FindNodeElement(const std::string& pName, const CX3DImporter_NodeElement::EType pType, CX3DImporter_NodeElement** pElement);
-
-	/***********************************************/
-	/********* Functions: postprocess set **********/
-	/***********************************************/
-
-	/// \return transformation matrix from global coordinate system to local.
-	aiMatrix4x4 PostprocessHelper_Matrix_GlobalToCurrent() const;
-
-	/// Check if child elements of node element is metadata and add it to temporary list.
-	/// \param [in] pNodeElement - node element where metadata is searching.
-	/// \param [out] pList - temporary list for collected metadata.
-	void PostprocessHelper_CollectMetadata(const CX3DImporter_NodeElement& pNodeElement, std::list<CX3DImporter_NodeElement*>& pList) const;
-
-	/// Check if type of node element is metadata. E.g. <MetadataSet>, <MetadataString>.
-	/// \param [in] pType - checked type.
-	/// \return true - if the type corresponds to the metadata.
-	bool PostprocessHelper_ElementIsMetadata(const CX3DImporter_NodeElement::EType pType) const;
-
-	/// Check if type of node element is geometry object and can be used to build mesh. E.g. <Box>, <Arc2D>.
-	/// \param [in] pType - checked type.
-	/// \return true - if the type corresponds to the mesh.
-	bool PostprocessHelper_ElementIsMesh(const CX3DImporter_NodeElement::EType pType) const;
-
-	/// Read CX3DImporter_NodeElement_Light, create aiLight and add it to list of the lights.
-	/// \param [in] pNodeElement - reference to lisght element(<DirectionalLight>, <PointLight>, <SpotLight>).
-	/// \param [out] pSceneLightList - reference to list of the lights.
-	void Postprocess_BuildLight(const CX3DImporter_NodeElement& pNodeElement, std::list<aiLight*>& pSceneLightList) const;
-
-	/// Create filled structure with type \ref aiMaterial from \ref CX3DImporter_NodeElement. This function itseld extract
-	/// all needed data from scene graph.
-	/// \param [in] pNodeElement - reference to material element(<Appearance>).
-	/// \param [out] pMaterial - pointer to pointer to created material. *pMaterial must be nullptr.
-	void Postprocess_BuildMaterial(const CX3DImporter_NodeElement& pNodeElement, aiMaterial** pMaterial) const;
-
-	/// Create filled structure with type \ref aiMaterial from \ref CX3DImporter_NodeElement. This function itseld extract
-	/// all needed data from scene graph.
-	/// \param [in] pNodeElement - reference to geometry object.
-	/// \param [out] pMesh - pointer to pointer to created mesh. *pMesh must be nullptr.
-	void Postprocess_BuildMesh(const CX3DImporter_NodeElement& pNodeElement, aiMesh** pMesh) const;
-
-	/// Create aiNode from CX3DImporter_NodeElement. Also function check children and make recursive call.
-	/// \param [out] pNode - pointer to pointer to created node. *pNode must be nullptr.
-	/// \param [in] pNodeElement - CX3DImporter_NodeElement which read.
-	/// \param [out] pSceneNode - aiNode for filling.
-	/// \param [out] pSceneMeshList - list with aiMesh which belong to scene.
-	/// \param [out] pSceneMaterialList - list with aiMaterial which belong to scene.
-	/// \param [out] pSceneLightList - list with aiLight which belong to scene.
-	void Postprocess_BuildNode(const CX3DImporter_NodeElement& pNodeElement, aiNode& pSceneNode, std::list<aiMesh*>& pSceneMeshList,
-								std::list<aiMaterial*>& pSceneMaterialList, std::list<aiLight*>& pSceneLightList) const;
-
-	/// To create mesh and material kept in <Schape>.
-	/// \param pShapeNodeElement - reference to node element which kept <Shape> data.
-	/// \param pNodeMeshInd - reference to list with mesh indices. When pShapeNodeElement will read new mesh index will be added to this list.
-	/// \param pSceneMeshList - reference to list with meshes. When pShapeNodeElement will read new mesh will be added to this list.
-	/// \param pSceneMaterialList - reference to list with materials. When pShapeNodeElement will read new material will be added to this list.
-	void Postprocess_BuildShape(const CX3DImporter_NodeElement_Shape& pShapeNodeElement, std::list<unsigned int>& pNodeMeshInd,
-								std::list<aiMesh*>& pSceneMeshList, std::list<aiMaterial*>& pSceneMaterialList) const;
-
-	/// Check if child elements of node element is metadata and add it to scene node.
-	/// \param [in] pNodeElement - node element where metadata is searching.
-	/// \param [out] pSceneNode - scene node in which metadata will be added.
-	void Postprocess_CollectMetadata(const CX3DImporter_NodeElement& pNodeElement, aiNode& pSceneNode) const;
-
-	/***********************************************/
-	/************* Functions: throw set ************/
-	/***********************************************/
-
-	/// Call that function when argument is out of range and exception must be raised.
-	/// \throw DeadlyImportError.
-	/// \param [in] pArgument - argument name.
-	void Throw_ArgOutOfRange(const std::string& pArgument);
-
-	/// Call that function when close tag of node not found and exception must be raised.
-	/// E.g.:
-	/// <Scene>
-	///     <Shape>
-	/// </Scene> <!--- shape not closed --->
-	/// \throw DeadlyImportError.
-	/// \param [in] pNode - node name in which exception happened.
-	void Throw_CloseNotFound(const std::string& pNode);
-
-	/// Call that function when string value can not be converted to floating point value and exception must be raised.
-	/// \param [in] pAttrValue - attribute value.
-	/// \throw DeadlyImportError.
-	void Throw_ConvertFail_Str2ArrF(const std::string& pAttrValue);
-
-	/// Call that function when in node defined attributes "DEF" and "USE" and exception must be raised.
-	/// E.g.: <Box DEF="BigBox" USE="MegaBox">
-	/// \throw DeadlyImportError.
-	void Throw_DEF_And_USE();
-
-	/// Call that function when attribute name is incorrect and exception must be raised.
-	/// \param [in] pAttrName - attribute name.
-	/// \throw DeadlyImportError.
-	void Throw_IncorrectAttr(const std::string& pAttrName);
-
-	/// Call that function when attribute value is incorrect and exception must be raised.
-	/// \param [in] pAttrName - attribute name.
-	/// \throw DeadlyImportError.
-	void Throw_IncorrectAttrValue(const std::string& pAttrName);
-
-	/// Call that function when some type of nodes are defined twice or more when must be used only once and exception must be raised.
-	/// E.g.:
-	/// <Shape>
-	///     <Box/>    <!--- first geometry node --->
-	///     <Sphere/> <!--- second geometry node. raise exception --->
-	/// </Shape>
-	/// \throw DeadlyImportError.
-	/// \param [in] pNodeType - type of node which defined one more time.
-	/// \param [in] pDescription - message about error. E.g. what the node defined while exception raised.
-	void Throw_MoreThanOnceDefined(const std::string& pNodeType, const std::string& pDescription);
-
-	/// Call that function when count of opening and closing tags which create group(e.g. <Group>) are not equal and exception must be raised.
-	/// E.g.:
-	/// <Scene>
-	///     <Transform>  <!--- first grouping node begin --->
-	///         <Group>  <!--- second grouping node begin --->
-	///     </Transform> <!--- first grouping node end --->
-	/// </Scene> <!--- one grouping node still not closed --->
-	/// \throw DeadlyImportError.
-	/// \param [in] pNode - node name in which exception happened.
-	void Throw_TagCountIncorrect(const std::string& pNode);
-
-	/// Call that function when defined in "USE" element are not found in graph and exception must be raised.
-	/// \param [in] pAttrValue - "USE" attribute value.
-	/// \throw DeadlyImportError.
-	void Throw_USE_NotFound(const std::string& pAttrValue);
-
-	/***********************************************/
-	/************** Functions: LOG set *************/
-	/***********************************************/
-
-	/// Short variant for calling \ref DefaultLogger::get()->info()
-	void LogInfo(const std::string& pMessage) { DefaultLogger::get()->info(pMessage); }
-
-	/***********************************************/
-	/************** Functions: XML set *************/
-	/***********************************************/
-
-	/// Check if current node is empty: <node />. If not then exception will throwed.
-	void XML_CheckNode_MustBeEmpty();
-
-	/// Check if current node name is equal to pNodeName.
-	/// \param [in] pNodeName - name for checking.
-	/// return true if current node name is equal to pNodeName, else - false.
-	bool XML_CheckNode_NameEqual(const std::string& pNodeName) { return mReader->getNodeName() == pNodeName; }
-
-	/// Skip unsupported node and report about that. Depend on node name can be skipped begin tag of node all whole node.
-	/// \param [in] pParentNodeName - parent node name. Used for reporting.
-	void XML_CheckNode_SkipUnsupported(const std::string& pParentNodeName);
-
-	/// Search for specified node in file. XML file read pointer(mReader) will point to found node or file end after search is end.
-	/// \param [in] pNodeName - requested node name.
-	/// return true - if node is found, else - false.
-	bool XML_SearchNode(const std::string& pNodeName);
-
-	/// Read attribute value.
-	/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
-	/// \return read data.
-	bool XML_ReadNode_GetAttrVal_AsBool(const int pAttrIdx);
-
-	/// Read attribute value.
-	/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
-	/// \return read data.
-	float XML_ReadNode_GetAttrVal_AsFloat(const int pAttrIdx);
-
-	/// Read attribute value.
-	/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
-	/// \return read data.
-	int32_t XML_ReadNode_GetAttrVal_AsI32(const int pAttrIdx);
-
-	/// Read attribute value.
-	/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
-	/// \param [out] pValue - read data.
-	void XML_ReadNode_GetAttrVal_AsCol3f(const int pAttrIdx, aiColor3D& pValue);
-
-	/// Read attribute value.
-	/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
-	/// \param [out] pValue - read data.
-	void XML_ReadNode_GetAttrVal_AsVec2f(const int pAttrIdx, aiVector2D& pValue);
-
-	/// Read attribute value.
-	/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
-	/// \param [out] pValue - read data.
-	void XML_ReadNode_GetAttrVal_AsVec3f(const int pAttrIdx, aiVector3D& pValue);
-
-	/// Read attribute value.
-	/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
-	/// \param [out] pValue - read data.
-	void XML_ReadNode_GetAttrVal_AsArrB(const int pAttrIdx, std::vector<bool>& pValue);
-
-	/// Read attribute value.
-	/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
-	/// \param [out] pValue - read data.
-	void XML_ReadNode_GetAttrVal_AsArrI32(const int pAttrIdx, std::vector<int32_t>& pValue);
-
-	/// Read attribute value.
-	/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
-	/// \param [out] pValue - read data.
-	void XML_ReadNode_GetAttrVal_AsArrF(const int pAttrIdx, std::vector<float>& pValue);
-
-    /// Read attribute value.
-	/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
-	/// \param [out] pValue - read data.
-	void XML_ReadNode_GetAttrVal_AsArrD(const int pAttrIdx, std::vector<double>& pValue);
-
-	/// Read attribute value.
-	/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
-	/// \param [out] pValue - read data.
-	void XML_ReadNode_GetAttrVal_AsListCol3f(const int pAttrIdx, std::list<aiColor3D>& pValue);
-
-	/// \overload void XML_ReadNode_GetAttrVal_AsListCol3f(const int pAttrIdx, std::vector<aiColor3D>& pValue)
-	void XML_ReadNode_GetAttrVal_AsArrCol3f(const int pAttrIdx, std::vector<aiColor3D>& pValue);
-
-	/// Read attribute value.
-	/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
-	/// \param [out] pValue - read data.
-	void XML_ReadNode_GetAttrVal_AsListCol4f(const int pAttrIdx, std::list<aiColor4D>& pValue);
-
-	/// \overload void XML_ReadNode_GetAttrVal_AsListCol4f(const int pAttrIdx, std::list<aiColor4D>& pValue)
-	void XML_ReadNode_GetAttrVal_AsArrCol4f(const int pAttrIdx, std::vector<aiColor4D>& pValue);
-
-	/// Read attribute value.
-	/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
-	/// \param [out] pValue - read data.
-	void XML_ReadNode_GetAttrVal_AsListVec2f(const int pAttrIdx, std::list<aiVector2D>& pValue);
-
-	/// \overload void XML_ReadNode_GetAttrVal_AsListVec2f(const int pAttrIdx, std::list<aiVector2D>& pValue)
-	void XML_ReadNode_GetAttrVal_AsArrVec2f(const int pAttrIdx, std::vector<aiVector2D>& pValue);
-
-	/// Read attribute value.
-	/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
-	/// \param [out] pValue - read data.
-	void XML_ReadNode_GetAttrVal_AsListVec3f(const int pAttrIdx, std::list<aiVector3D>& pValue);
-
-	/// \overload void XML_ReadNode_GetAttrVal_AsListVec3f(const int pAttrIdx, std::list<aiVector3D>& pValue)
-	void XML_ReadNode_GetAttrVal_AsArrVec3f(const int pAttrIdx, std::vector<aiVector3D>& pValue);
-
-	/// Read attribute value.
-	/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
-	/// \param [out] pValue - read data.
-	void XML_ReadNode_GetAttrVal_AsListS(const int pAttrIdx, std::list<std::string>& pValue);
-
-	/***********************************************/
-	/******* Functions: geometry helper set  *******/
-	/***********************************************/
-
-	/// Make point on surface oXY.
-	/// \param [in] pAngle - angle in radians between radius-vector of point and oX axis. Angle extends from the oX axis counterclockwise to the radius-vector.
-	/// \param [in] pRadius - length of radius-vector.
-	/// \return made point coordinates.
-	aiVector3D GeometryHelper_Make_Point2D(const float pAngle, const float pRadius);
-
-	/// Make 2D figure - linear circular arc with center in (0, 0). The z-coordinate is 0. The arc extends from the pStartAngle counterclockwise
-	/// to the pEndAngle. If pStartAngle and pEndAngle have the same value, a circle is specified. If the absolute difference between pStartAngle
-	/// and pEndAngle is greater than or equal to 2pi, a circle is specified.
-	/// \param [in] pStartAngle - angle in radians of start of the arc.
-	/// \param [in] pEndAngle - angle in radians of end of the arc.
-	/// \param [in] pRadius - radius of the arc.
-	/// \param [out] pNumSegments - number of segments in arc. In other words - tessellation factor.
-	/// \param [out] pVertices - generated vertices.
-	void GeometryHelper_Make_Arc2D(const float pStartAngle, const float pEndAngle, const float pRadius, size_t pNumSegments, std::list<aiVector3D>& pVertices);
-
-	/// Create line set from point set.
-	/// \param [in] pPoint - input points list.
-	/// \param [out] pLine - made lines list.
-	void GeometryHelper_Extend_PointToLine(const std::list<aiVector3D>& pPoint, std::list<aiVector3D>& pLine);
-
-	/// Create CoordIdx of line set from CoordIdx of polyline set.
-	/// \param [in] pPolylineCoordIdx - vertices indices divided by delimiter "-1". Must contain faces with two or more indices.
-	/// \param [out] pLineCoordIdx - made CoordIdx of line set.
-	void GeometryHelper_Extend_PolylineIdxToLineIdx(const std::list<int32_t>& pPolylineCoordIdx, std::list<int32_t>& pLineCoordIdx);
-
-	/// Make 3D body - rectangular parallelepiped with center in (0, 0). QL mean quadlist (\sa pVertices).
-	/// \param [in] pSize - scale factor for body for every axis. E.g. (1, 2, 1) mean: X-size and Z-size - 1, Y-size - 2.
-	/// \param [out] pVertices - generated vertices. The list of vertices is grouped in quads.
-	void GeometryHelper_MakeQL_RectParallelepiped(const aiVector3D& pSize, std::list<aiVector3D>& pVertices);
-
-	/// Create faces array from vertices indices array.
-	/// \param [in] pCoordIdx - vertices indices divided by delimiter "-1".
-	/// \param [in] pFaces - created faces array.
-	/// \param [in] pPrimitiveTypes - type of primitives in faces.
-	void GeometryHelper_CoordIdxStr2FacesArr(const std::vector<int32_t>& pCoordIdx, std::vector<aiFace>& pFaces, unsigned int& pPrimitiveTypes) const;
-
-	/// Add colors to mesh.
-	/// a. If colorPerVertex is FALSE, colours are applied to each face, as follows:
-	///		If the colorIndex field is not empty, one colour is used for each face of the mesh. There shall be at least as many indices in the
-	///			colorIndex field as there are faces in the mesh. The colorIndex field shall not contain any negative entries.
-	///		If the colorIndex field is empty, the colours in the X3DColorNode node are applied to each face of the mesh in order.
-	///			There shall be at least as many colours in the X3DColorNode node as there are faces.
-	/// b. If colorPerVertex is TRUE, colours are applied to each vertex, as follows:
-	///		If the colorIndex field is not empty, colours are applied to each vertex of the mesh in exactly the same manner that the coordIndex
-	///			field is used to choose coordinates for each vertex from the <Coordinate> node. The colorIndex field shall contain end-of-face markers (-1)
-	///			in exactly the same places as the coordIndex field.
-	///		If the colorIndex field is empty, the coordIndex field is used to choose colours from the X3DColorNode node.
-	/// \param [in] pMesh - mesh for adding data.
-	/// \param [in] pCoordIdx - vertices indices divided by delimiter "-1".
-	/// \param [in] pColorIdx - color indices for every vertex divided by delimiter "-1" if \ref pColorPerVertex is true. if \ref pColorPerVertex is false
-	/// then pColorIdx contain color indices for every faces and must not contain delimiter "-1".
-	/// \param [in] pColors - defined colors.
-	/// \param [in] pColorPerVertex - if \ref pColorPerVertex is true then color in \ref pColors defined for every vertex, if false - for every face.
-	void MeshGeometry_AddColor(aiMesh& pMesh, const std::vector<int32_t>& pCoordIdx, const std::vector<int32_t>& pColorIdx,
-								const std::list<aiColor4D>& pColors, const bool pColorPerVertex) const;
-
-	/// \overload void MeshGeometry_AddColor(aiMesh& pMesh, const std::list<int32_t>& pCoordIdx, const std::list<int32_t>& pColorIdx, const std::list<aiColor4D>& pColors, const bool pColorPerVertex) const;
-	void MeshGeometry_AddColor(aiMesh& pMesh, const std::vector<int32_t>& pCoordIdx, const std::vector<int32_t>& pColorIdx,
-								const std::list<aiColor3D>& pColors, const bool pColorPerVertex) const;
-
-	/// Add colors to mesh.
-	/// \param [in] pMesh - mesh for adding data.
-	/// \param [in] pColors - defined colors.
-	/// \param [in] pColorPerVertex - if \ref pColorPerVertex is true then color in \ref pColors defined for every vertex, if false - for every face.
-	void MeshGeometry_AddColor(aiMesh& pMesh, const std::list<aiColor4D>& pColors, const bool pColorPerVertex) const;
-
-	/// \overload void MeshGeometry_AddColor(aiMesh& pMesh, const std::list<aiColor4D>& pColors, const bool pColorPerVertex) const
-	void MeshGeometry_AddColor(aiMesh& pMesh, const std::list<aiColor3D>& pColors, const bool pColorPerVertex) const;
-
-	/// Add normals to mesh. Function work similar to \ref MeshGeometry_AddColor;
-	void MeshGeometry_AddNormal(aiMesh& pMesh, const std::vector<int32_t>& pCoordIdx, const std::vector<int32_t>& pNormalIdx,
-								const std::list<aiVector3D>& pNormals, const bool pNormalPerVertex) const;
-
-	/// Add normals to mesh. Function work similar to \ref MeshGeometry_AddColor;
-	void MeshGeometry_AddNormal(aiMesh& pMesh, const std::list<aiVector3D>& pNormals, const bool pNormalPerVertex) const;
-
-    /// Add texture coordinates to mesh. Function work similar to \ref MeshGeometry_AddColor;
-	void MeshGeometry_AddTexCoord(aiMesh& pMesh, const std::vector<int32_t>& pCoordIdx, const std::vector<int32_t>& pTexCoordIdx,
-								const std::list<aiVector2D>& pTexCoords) const;
-
-    /// Add texture coordinates to mesh. Function work similar to \ref MeshGeometry_AddColor;
-	void MeshGeometry_AddTexCoord(aiMesh& pMesh, const std::list<aiVector2D>& pTexCoords) const;
-
-	/// Create mesh.
-	/// \param [in] pCoordIdx - vertices indices divided by delimiter "-1".
-	/// \param [in] pVertices - vertices of mesh.
-	/// \return created mesh.
-	aiMesh* GeometryHelper_MakeMesh(const std::vector<int32_t>& pCoordIdx, const std::list<aiVector3D>& pVertices) const;
-
-	/***********************************************/
-	/******** Functions: parse set private *********/
-	/***********************************************/
-
-	/// Create node element with type "Node" in scene graph. That operation is needed when you enter to X3D group node
-	/// like <Group>, <Transform> etc. When exiting from X3D group node(e.g. </Group>) \ref ParseHelper_Node_Exit must
-	/// be called.
-	/// \param [in] pStatic - flag: if true then static node is created(e.g. <StaticGroup>).
-	void ParseHelper_Group_Begin(const bool pStatic = false);
-
-	/// Make pNode as current and enter deeper for parsing child nodes. At end \ref ParseHelper_Node_Exit must be called.
-	/// \param [in] pNode - new current node.
-	void ParseHelper_Node_Enter(CX3DImporter_NodeElement* pNode);
-
-	/// This function must be called when exiting from X3D group node(e.g. </Group>). \ref ParseHelper_Group_Begin.
-	void ParseHelper_Node_Exit();
-
-	/// Attribute values of floating point types can take form ".x"(without leading zero). irrXMLReader can not read this form of values and it
-	/// must be converted to right form - "0.xxx".
-	/// \param [in] pInStr - pointer to input string which can contain incorrect form of values.
-	/// \param [out[ pOutString - output string with right form of values.
-	void ParseHelper_FixTruncatedFloatString(const char* pInStr, std::string& pOutString);
-
-	/// Check if current node has nodes of type X3DMetadataObject. Why we must do it? Because X3DMetadataObject can be in any non-empty X3DNode.
-	/// Meaning that X3DMetadataObject can be in any non-empty node in <Scene>.
-	/// \return true - if metadata node are found and parsed, false - metadata not found.
-	bool ParseHelper_CheckRead_X3DMetadataObject();
-
-	/// Check if current node has nodes of type X3DGeometricPropertyNode. X3DGeometricPropertyNode
-	/// X3DGeometricPropertyNode inheritors:
-	/// <FogCoordinate>, <HAnimDisplacer>, <Color>, <ColorRGBA>, <Coordinate>, <CoordinateDouble>, <GeoCoordinate>, <Normal>,
-	/// <MultiTextureCoordinate>, <TextureCoordinate>, <TextureCoordinate3D>, <TextureCoordinate4D>, <TextureCoordinateGenerator>,
-	/// <FloatVertexAttribute>, <Matrix3VertexAttribute>, <Matrix4VertexAttribute>.
-	/// \return true - if nodes are found and parsed, false - nodes not found.
-	bool ParseHelper_CheckRead_X3DGeometricPropertyNode();
-
-	/// Parse <X3D> node of the file.
-	void ParseNode_Root();
-
-	/// Parse <head> node of the file.
-	void ParseNode_Head();
-
-	/// Parse <Scene> node of the file.
-	void ParseNode_Scene();
-
-	/// Parse child nodes of <Metadata*> node.
-	/// \param [in] pNodeName - parsed node name. Must be set because that function is general and name needed for checking the end
-	/// and error reporing.
-	/// \param [in] pParentElement - parent metadata element.
-	void ParseNode_Metadata(CX3DImporter_NodeElement* pParentElement, const std::string& pNodeName);
-
-	/// Parse <MetadataBoolean> node of the file.
-	void ParseNode_MetadataBoolean();
-
-	/// Parse <MetadataDouble> node of the file.
-	void ParseNode_MetadataDouble();
-
-	/// Parse <MetadataFloat> node of the file.
-	void ParseNode_MetadataFloat();
-
-	/// Parse <MetadataInteger> node of the file.
-	void ParseNode_MetadataInteger();
-
-	/// Parse <MetadataSet> node of the file.
-	void ParseNode_MetadataSet();
-
-	/// \fn void ParseNode_MetadataString()
-	/// Parse <MetadataString> node of the file.
-	void ParseNode_MetadataString();
-
-	/// Parse <Arc2D> node of the file.
-	void ParseNode_Geometry2D_Arc2D();
-
-	/// Parse <ArcClose2D> node of the file.
-	void ParseNode_Geometry2D_ArcClose2D();
-
-	/// Parse <Circle2D> node of the file.
-	void ParseNode_Geometry2D_Circle2D();
-
-	/// Parse <Disk2D> node of the file.
-	void ParseNode_Geometry2D_Disk2D();
-
-	/// Parse <Polyline2D> node of the file.
-	void ParseNode_Geometry2D_Polyline2D();
-
-	/// Parse <Polypoint2D> node of the file.
-	void ParseNode_Geometry2D_Polypoint2D();
-
-	/// Parse <Rectangle2D> node of the file.
-	void ParseNode_Geometry2D_Rectangle2D();
-
-	/// Parse <TriangleSet2D> node of the file.
-	void ParseNode_Geometry2D_TriangleSet2D();
-
-	/// Parse <Box> node of the file.
-	void ParseNode_Geometry3D_Box();
-
-	/// Parse <Cone> node of the file.
-	void ParseNode_Geometry3D_Cone();
-
-	/// Parse <Cylinder> node of the file.
-	void ParseNode_Geometry3D_Cylinder();
-
-	/// Parse <ElevationGrid> node of the file.
-	void ParseNode_Geometry3D_ElevationGrid();
-
-	/// Parse <Extrusion> node of the file.
-	void ParseNode_Geometry3D_Extrusion();
-
-	/// Parse <IndexedFaceSet> node of the file.
-	void ParseNode_Geometry3D_IndexedFaceSet();
-
-	/// Parse <Sphere> node of the file.
-	void ParseNode_Geometry3D_Sphere();
-
-	/// Parse <Group> node of the file. And create new node in scene graph.
-	void ParseNode_Grouping_Group();
-
-	/// Doing actions at an exit from <Group>. Walk up in scene graph.
-	void ParseNode_Grouping_GroupEnd();
-
-	/// Parse <StaticGroup> node of the file. And create new node in scene graph.
-	void ParseNode_Grouping_StaticGroup();
-
-	/// Doing actions at an exit from <StaticGroup>. Walk up in scene graph.
-	void ParseNode_Grouping_StaticGroupEnd();
-
-	/// Parse <Switch> node of the file. And create new node in scene graph.
-	void ParseNode_Grouping_Switch();
-
-	/// Doing actions at an exit from <Switch>. Walk up in scene graph.
-	void ParseNode_Grouping_SwitchEnd();
-
-	/// Parse <Transform> node of the file. And create new node in scene graph.
-	void ParseNode_Grouping_Transform();
-
-	/// Doing actions at an exit from <Transform>. Walk up in scene graph.
-	void ParseNode_Grouping_TransformEnd();
-
-	/// Parse <Color> node of the file.
-	void ParseNode_Rendering_Color();
-
-	/// Parse <ColorRGBA> node of the file.
-	void ParseNode_Rendering_ColorRGBA();
-
-	/// Parse <Coordinate> node of the file.
-	void ParseNode_Rendering_Coordinate();
-
-	/// Parse <Normal> node of the file.
-	void ParseNode_Rendering_Normal();
-
-	/// Parse <IndexedLineSet> node of the file.
-	void ParseNode_Rendering_IndexedLineSet();
-
-	/// Parse <IndexedTriangleFanSet> node of the file.
-	void ParseNode_Rendering_IndexedTriangleFanSet();
-
-	/// Parse <IndexedTriangleSet> node of the file.
-	void ParseNode_Rendering_IndexedTriangleSet();
-
-	/// Parse <IndexedTriangleStripSet> node of the file.
-	void ParseNode_Rendering_IndexedTriangleStripSet();
-
-	/// Parse <LineSet> node of the file.
-	void ParseNode_Rendering_LineSet();
-
-	/// Parse <PointSet> node of the file.
-	void ParseNode_Rendering_PointSet();
-
-	/// Parse <TriangleFanSet> node of the file.
-	void ParseNode_Rendering_TriangleFanSet();
-
-	/// Parse <TriangleSet> node of the file.
-	void ParseNode_Rendering_TriangleSet();
-
-	/// Parse <TriangleStripSet> node of the file.
-	void ParseNode_Rendering_TriangleStripSet();
-
-	/// Parse <ImageTexture> node of the file.
-	void ParseNode_Texturing_ImageTexture();
-
-	/// Parse <TextureCoordinate> node of the file.
-	void ParseNode_Texturing_TextureCoordinate();
-
-	/// Parse <TextureTransform> node of the file.
-	void ParseNode_Texturing_TextureTransform();
-
-	/// Parse <Shape> node of the file.
-	void ParseNode_Shape_Shape();
-
-	/// Parse <Appearance> node of the file.
-	void ParseNode_Shape_Appearance();
-
-	/// Parse <Material> node of the file.
-	void ParseNode_Shape_Material();
-
-	/// Parse <Inline> node of the file.
-	void ParseNode_Networking_Inline();
-
-	/// Parse <DirectionalLight> node of the file.
-	void ParseNode_Lighting_DirectionalLight();
-
-	/// Parse <PointLight> node of the file.
-	void ParseNode_Lighting_PointLight();
-
-	/// Parse <SpotLight> node of the file.
-	void ParseNode_Lighting_SpotLight();
-
-private:
-    /***********************************************/
-    /******************** Types ********************/
-    /***********************************************/
-
-    /***********************************************/
-    /****************** Constants ******************/
-    /***********************************************/
-    static const aiImporterDesc Description;
-    //static const std::regex pattern_nws;
-    //static const std::regex pattern_true;
-
-
-    /***********************************************/
-    /****************** Variables ******************/
-    /***********************************************/
-    CX3DImporter_NodeElement* NodeElement_Cur;///< Current element.
-    std::unique_ptr<FIReader> mReader;///< Pointer to XML-reader object
-    IOSystem *mpIOHandler;
-};// class X3DImporter
-
-}// namespace Assimp
-
-#endif // INCLUDED_AI_X3D_IMPORTER_H
diff --git a/Engine/lib/assimp/code/X3D/X3DImporter_Geometry2D.cpp b/Engine/lib/assimp/code/X3D/X3DImporter_Geometry2D.cpp
deleted file mode 100644
index 350fd6c40..000000000
--- a/Engine/lib/assimp/code/X3D/X3DImporter_Geometry2D.cpp
+++ /dev/null
@@ -1,522 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-/// \file   X3DImporter_Geometry2D.cpp
-/// \brief  Parsing data from nodes of "Geometry2D" set of X3D.
-/// \date   2015-2016
-/// \author smal.root@gmail.com
-
-#ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
-
-#include "X3DImporter.hpp"
-#include "X3DImporter_Node.hpp"
-#include "X3DImporter_Macro.hpp"
-
-namespace Assimp
-{
-
-// <Arc2D
-// DEF=""              ID
-// USE=""              IDREF
-// endAngle="1.570796" SFFloat [initializeOnly]
-// radius="1"          SFFloat [initializeOnly]
-// startAngle="0"      SFFloat [initializeOnly]
-// />
-// The Arc2D node specifies a linear circular arc whose center is at (0,0) and whose angles are measured starting at the positive x-axis and sweeping
-// towards the positive y-axis. The radius field specifies the radius of the circle of which the arc is a portion. The arc extends from the startAngle
-// counterclockwise to the endAngle. The values of startAngle and endAngle shall be in the range [-2pi, 2pi] radians (or the equivalent if a different
-// angle base unit has been specified). If startAngle and endAngle have the same value, a circle is specified.
-void X3DImporter::ParseNode_Geometry2D_Arc2D()
-{
-    std::string def, use;
-    float endAngle = AI_MATH_HALF_PI_F;
-    float radius = 1;
-    float startAngle = 0;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_RET("endAngle", endAngle, XML_ReadNode_GetAttrVal_AsFloat);
-		MACRO_ATTRREAD_CHECK_RET("radius", radius, XML_ReadNode_GetAttrVal_AsFloat);
-		MACRO_ATTRREAD_CHECK_RET("startAngle", startAngle, XML_ReadNode_GetAttrVal_AsFloat);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_Arc2D, ne);
-	}
-	else
-	{
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_Geometry2D(CX3DImporter_NodeElement::ENET_Arc2D, NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		// create point list of geometry object and convert it to line set.
-		std::list<aiVector3D> tlist;
-
-		GeometryHelper_Make_Arc2D(startAngle, endAngle, radius, 10, tlist);///TODO: IME - AI_CONFIG for NumSeg
-		GeometryHelper_Extend_PointToLine(tlist, ((CX3DImporter_NodeElement_Geometry2D*)ne)->Vertices);
-		((CX3DImporter_NodeElement_Geometry2D*)ne)->NumIndices = 2;
-		// check for X3DMetadataObject childs.
-		if(!mReader->isEmptyElement())
-			ParseNode_Metadata(ne, "Arc2D");
-		else
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-// <ArcClose2D
-// DEF=""              ID
-// USE=""              IDREF
-// closureType="PIE"   SFString [initializeOnly], {"PIE", "CHORD"}
-// endAngle="1.570796" SFFloat  [initializeOnly]
-// radius="1"          SFFloat  [initializeOnly]
-// solid="false"       SFBool   [initializeOnly]
-// startAngle="0"      SFFloat  [initializeOnly]
-// />
-// The ArcClose node specifies a portion of a circle whose center is at (0,0) and whose angles are measured starting at the positive x-axis and sweeping
-// towards the positive y-axis. The end points of the arc specified are connected as defined by the closureType field. The radius field specifies the radius
-// of the circle of which the arc is a portion. The arc extends from the startAngle counterclockwise to the endAngle. The value of radius shall be greater
-// than zero. The values of startAngle and endAngle shall be in the range [-2pi, 2pi] radians (or the equivalent if a different default angle base unit has
-// been specified). If startAngle and endAngle have the same value, a circle is specified and closureType is ignored. If the absolute difference between
-// startAngle and endAngle is greater than or equal to 2pi, a complete circle is produced with no chord or radial line(s) drawn from the center.
-// A closureType of "PIE" connects the end point to the start point by defining two straight line segments first from the end point to the center and then
-// the center to the start point. A closureType of "CHORD" connects the end point to the start point by defining a straight line segment from the end point
-// to the start point. Textures are applied individually to each face of the ArcClose2D. On the front (+Z) and back (-Z) faces of the ArcClose2D, when
-// viewed from the +Z-axis, the texture is mapped onto each face with the same orientation as if the image were displayed normally in 2D.
-void X3DImporter::ParseNode_Geometry2D_ArcClose2D()
-{
-    std::string def, use;
-    std::string closureType("PIE");
-    float endAngle = AI_MATH_HALF_PI_F;
-    float radius = 1;
-    bool solid = false;
-    float startAngle = 0;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_RET("closureType", closureType, mReader->getAttributeValue);
-		MACRO_ATTRREAD_CHECK_RET("endAngle", endAngle, XML_ReadNode_GetAttrVal_AsFloat);
-		MACRO_ATTRREAD_CHECK_RET("radius", radius, XML_ReadNode_GetAttrVal_AsFloat);
-		MACRO_ATTRREAD_CHECK_RET("solid", solid, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("startAngle", startAngle, XML_ReadNode_GetAttrVal_AsFloat);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_ArcClose2D, ne);
-	}
-	else
-	{
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_Geometry2D(CX3DImporter_NodeElement::ENET_ArcClose2D, NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		((CX3DImporter_NodeElement_Geometry2D*)ne)->Solid = solid;
-		// create point list of geometry object.
-		GeometryHelper_Make_Arc2D(startAngle, endAngle, radius, 10, ((CX3DImporter_NodeElement_Geometry2D*)ne)->Vertices);///TODO: IME - AI_CONFIG for NumSeg
-		// add chord or two radiuses only if not a circle was defined
-		if(!((std::fabs(endAngle - startAngle) >= AI_MATH_TWO_PI_F) || (endAngle == startAngle)))
-		{
-			std::list<aiVector3D>& vlist = ((CX3DImporter_NodeElement_Geometry2D*)ne)->Vertices;// just short alias.
-
-			if((closureType == "PIE") || (closureType == "\"PIE\""))
-				vlist.push_back(aiVector3D(0, 0, 0));// center point - first radial line
-			else if((closureType != "CHORD") && (closureType != "\"CHORD\""))
-				Throw_IncorrectAttrValue("closureType");
-
-			vlist.push_back(*vlist.begin());// arc first point - chord from first to last point of arc(if CHORD) or second radial line(if PIE).
-		}
-
-		((CX3DImporter_NodeElement_Geometry2D*)ne)->NumIndices = ((CX3DImporter_NodeElement_Geometry2D*)ne)->Vertices.size();
-		// check for X3DMetadataObject childs.
-		if(!mReader->isEmptyElement())
-			ParseNode_Metadata(ne, "ArcClose2D");
-		else
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-// <Circle2D
-// DEF=""     ID
-// USE=""     IDREF
-// radius="1" SFFloat  [initializeOnly]
-// />
-void X3DImporter::ParseNode_Geometry2D_Circle2D()
-{
-    std::string def, use;
-    float radius = 1;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_RET("radius", radius, XML_ReadNode_GetAttrVal_AsFloat);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_Circle2D, ne);
-	}
-	else
-	{
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_Geometry2D(CX3DImporter_NodeElement::ENET_Circle2D, NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		// create point list of geometry object and convert it to line set.
-		std::list<aiVector3D> tlist;
-
-		GeometryHelper_Make_Arc2D(0, 0, radius, 10, tlist);///TODO: IME - AI_CONFIG for NumSeg
-		GeometryHelper_Extend_PointToLine(tlist, ((CX3DImporter_NodeElement_Geometry2D*)ne)->Vertices);
-		((CX3DImporter_NodeElement_Geometry2D*)ne)->NumIndices = 2;
-		// check for X3DMetadataObject childs.
-		if(!mReader->isEmptyElement())
-			ParseNode_Metadata(ne, "Circle2D");
-		else
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-// <Disk2D
-// DEF=""          ID
-// USE=""          IDREF
-// innerRadius="0" SFFloat  [initializeOnly]
-// outerRadius="1" SFFloat  [initializeOnly]
-// solid="false"   SFBool   [initializeOnly]
-// />
-// The Disk2D node specifies a circular disk which is centred at (0, 0) in the local coordinate system. The outerRadius field specifies the radius of the
-// outer dimension of the Disk2D. The innerRadius field specifies the inner dimension of the Disk2D. The value of outerRadius shall be greater than zero.
-// The value of innerRadius shall be greater than or equal to zero and less than or equal to outerRadius. If innerRadius is zero, the Disk2D is completely
-// filled. Otherwise, the area within the innerRadius forms a hole in the Disk2D. If innerRadius is equal to outerRadius, a solid circular line shall
-// be drawn using the current line properties. Textures are applied individually to each face of the Disk2D. On the front (+Z) and back (-Z) faces of
-// the Disk2D, when viewed from the +Z-axis, the texture is mapped onto each face with the same orientation as if the image were displayed normally in 2D.
-void X3DImporter::ParseNode_Geometry2D_Disk2D()
-{
-    std::string def, use;
-    float innerRadius = 0;
-    float outerRadius = 1;
-    bool solid = false;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_RET("innerRadius", innerRadius, XML_ReadNode_GetAttrVal_AsFloat);
-		MACRO_ATTRREAD_CHECK_RET("outerRadius", outerRadius, XML_ReadNode_GetAttrVal_AsFloat);
-		MACRO_ATTRREAD_CHECK_RET("solid", solid, XML_ReadNode_GetAttrVal_AsBool);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_Disk2D, ne);
-	}
-	else
-	{
-		std::list<aiVector3D> tlist_o, tlist_i;
-
-		if(innerRadius > outerRadius) Throw_IncorrectAttrValue("innerRadius");
-
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_Geometry2D(CX3DImporter_NodeElement::ENET_Disk2D, NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		// create point list of geometry object.
-		///TODO: IME - AI_CONFIG for NumSeg
-		GeometryHelper_Make_Arc2D(0, 0, outerRadius, 10, tlist_o);// outer circle
-		if(innerRadius == 0.0f)
-		{// make filled disk
-			// in tlist_o we already have points of circle. just copy it and sign as polygon.
-			((CX3DImporter_NodeElement_Geometry2D*)ne)->Vertices = tlist_o;
-			((CX3DImporter_NodeElement_Geometry2D*)ne)->NumIndices = tlist_o.size();
-		}
-		else if(innerRadius == outerRadius)
-		{// make circle
-			// in tlist_o we already have points of circle. convert it to line set.
-			GeometryHelper_Extend_PointToLine(tlist_o, ((CX3DImporter_NodeElement_Geometry2D*)ne)->Vertices);
-			((CX3DImporter_NodeElement_Geometry2D*)ne)->NumIndices = 2;
-		}
-		else
-		{// make disk
-			std::list<aiVector3D>& vlist = ((CX3DImporter_NodeElement_Geometry2D*)ne)->Vertices;// just short alias.
-
-			GeometryHelper_Make_Arc2D(0, 0, innerRadius, 10, tlist_i);// inner circle
-			//
-			// create quad list from two point lists
-			//
-			if(tlist_i.size() < 2) throw DeadlyImportError("Disk2D. Not enough points for creating quad list.");// tlist_i and tlist_o has equal size.
-
-			// add all quads except last
-			for(std::list<aiVector3D>::iterator it_i = tlist_i.begin(), it_o = tlist_o.begin(); it_i != tlist_i.end();)
-			{
-				// do not forget - CCW direction
-				vlist.push_back(*it_i++);// 1st point
-				vlist.push_back(*it_o++);// 2nd point
-				vlist.push_back(*it_o);// 3rd point
-				vlist.push_back(*it_i);// 4th point
-			}
-
-			// add last quad
-			vlist.push_back(*tlist_i.end());// 1st point
-			vlist.push_back(*tlist_o.end());// 2nd point
-			vlist.push_back(*tlist_o.begin());// 3rd point
-			vlist.push_back(*tlist_o.begin());// 4th point
-
-			((CX3DImporter_NodeElement_Geometry2D*)ne)->NumIndices = 4;
-		}
-
-		((CX3DImporter_NodeElement_Geometry2D*)ne)->Solid = solid;
-		// check for X3DMetadataObject childs.
-		if(!mReader->isEmptyElement())
-			ParseNode_Metadata(ne, "Disk2D");
-		else
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-// <Polyline2D
-// DEF=""          ID
-// USE=""          IDREF
-// lineSegments="" MFVec2F [intializeOnly]
-// />
-void X3DImporter::ParseNode_Geometry2D_Polyline2D()
-{
-    std::string def, use;
-    std::list<aiVector2D> lineSegments;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_REF("lineSegments", lineSegments, XML_ReadNode_GetAttrVal_AsListVec2f);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_Polyline2D, ne);
-	}
-	else
-	{
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_Geometry2D(CX3DImporter_NodeElement::ENET_Polyline2D, NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		//
-		// convert read point list of geometry object to line set.
-		//
-		std::list<aiVector3D> tlist;
-
-		// convert vec2 to vec3
-		for(std::list<aiVector2D>::iterator it2 = lineSegments.begin(); it2 != lineSegments.end(); ++it2) tlist.push_back(aiVector3D(it2->x, it2->y, 0));
-
-		// convert point set to line set
-		GeometryHelper_Extend_PointToLine(tlist, ((CX3DImporter_NodeElement_Geometry2D*)ne)->Vertices);
-		((CX3DImporter_NodeElement_Geometry2D*)ne)->NumIndices = 2;
-		// check for X3DMetadataObject childs.
-		if(!mReader->isEmptyElement())
-			ParseNode_Metadata(ne, "Polyline2D");
-		else
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-// <Polypoint2D
-// DEF=""   ID
-// USE=""   IDREF
-// point="" MFVec2F [inputOutput]
-// />
-void X3DImporter::ParseNode_Geometry2D_Polypoint2D()
-{
-    std::string def, use;
-    std::list<aiVector2D> point;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_REF("point", point, XML_ReadNode_GetAttrVal_AsListVec2f);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_Polypoint2D, ne);
-	}
-	else
-	{
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_Geometry2D(CX3DImporter_NodeElement::ENET_Polypoint2D, NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		// convert vec2 to vec3
-		for(std::list<aiVector2D>::iterator it2 = point.begin(); it2 != point.end(); ++it2)
-		{
-			((CX3DImporter_NodeElement_Geometry2D*)ne)->Vertices.push_back(aiVector3D(it2->x, it2->y, 0));
-		}
-
-		((CX3DImporter_NodeElement_Geometry2D*)ne)->NumIndices = 1;
-		// check for X3DMetadataObject childs.
-		if(!mReader->isEmptyElement())
-			ParseNode_Metadata(ne, "Polypoint2D");
-		else
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-// <Rectangle2D
-// DEF=""        ID
-// USE=""        IDREF
-// size="2 2"    SFVec2f [initializeOnly]
-// solid="false" SFBool  [initializeOnly]
-// />
-void X3DImporter::ParseNode_Geometry2D_Rectangle2D()
-{
-    std::string def, use;
-    aiVector2D size(2, 2);
-    bool solid = false;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_REF("size", size, XML_ReadNode_GetAttrVal_AsVec2f);
-		MACRO_ATTRREAD_CHECK_RET("solid", solid, XML_ReadNode_GetAttrVal_AsBool);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_Rectangle2D, ne);
-	}
-	else
-	{
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_Geometry2D(CX3DImporter_NodeElement::ENET_Rectangle2D, NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		float x1 = -size.x / 2.0f;
-		float x2 = size.x / 2.0f;
-		float y1 = -size.y / 2.0f;
-		float y2 = size.y / 2.0f;
-		std::list<aiVector3D>& vlist = ((CX3DImporter_NodeElement_Geometry2D*)ne)->Vertices;// just short alias.
-
-		vlist.push_back(aiVector3D(x2, y1, 0));// 1st point
-		vlist.push_back(aiVector3D(x2, y2, 0));// 2nd point
-		vlist.push_back(aiVector3D(x1, y2, 0));// 3rd point
-		vlist.push_back(aiVector3D(x1, y1, 0));// 4th point
-		((CX3DImporter_NodeElement_Geometry2D*)ne)->Solid = solid;
-		((CX3DImporter_NodeElement_Geometry2D*)ne)->NumIndices = 4;
-		// check for X3DMetadataObject childs.
-		if(!mReader->isEmptyElement())
-			ParseNode_Metadata(ne, "Rectangle2D");
-		else
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-// <TriangleSet2D
-// DEF=""        ID
-// USE=""        IDREF
-// solid="false" SFBool  [initializeOnly]
-// vertices=""   MFVec2F [inputOutput]
-// />
-void X3DImporter::ParseNode_Geometry2D_TriangleSet2D()
-{
-    std::string def, use;
-    bool solid = false;
-    std::list<aiVector2D> vertices;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_REF("vertices", vertices, XML_ReadNode_GetAttrVal_AsListVec2f);
-		MACRO_ATTRREAD_CHECK_RET("solid", solid, XML_ReadNode_GetAttrVal_AsBool);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_TriangleSet2D, ne);
-	}
-	else
-	{
-		if(vertices.size() % 3) throw DeadlyImportError("TriangleSet2D. Not enough points for defining triangle.");
-
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_Geometry2D(CX3DImporter_NodeElement::ENET_TriangleSet2D, NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		// convert vec2 to vec3
-		for(std::list<aiVector2D>::iterator it2 = vertices.begin(); it2 != vertices.end(); ++it2)
-		{
-			((CX3DImporter_NodeElement_Geometry2D*)ne)->Vertices.push_back(aiVector3D(it2->x, it2->y, 0));
-		}
-
-		((CX3DImporter_NodeElement_Geometry2D*)ne)->Solid = solid;
-		((CX3DImporter_NodeElement_Geometry2D*)ne)->NumIndices = 3;
-		// check for X3DMetadataObject childs.
-		if(!mReader->isEmptyElement())
-			ParseNode_Metadata(ne, "TriangleSet2D");
-		else
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-}// namespace Assimp
-
-#endif // !ASSIMP_BUILD_NO_X3D_IMPORTER
diff --git a/Engine/lib/assimp/code/X3D/X3DImporter_Geometry3D.cpp b/Engine/lib/assimp/code/X3D/X3DImporter_Geometry3D.cpp
deleted file mode 100644
index e12cbd3ab..000000000
--- a/Engine/lib/assimp/code/X3D/X3DImporter_Geometry3D.cpp
+++ /dev/null
@@ -1,999 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-/// \file   X3DImporter_Geometry3D.cpp
-/// \brief  Parsing data from nodes of "Geometry3D" set of X3D.
-/// \date   2015-2016
-/// \author smal.root@gmail.com
-
-#ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
-
-#include "X3DImporter.hpp"
-#include "X3DImporter_Macro.hpp"
-
-// Header files, Assimp.
-#include <assimp/StandardShapes.h>
-
-namespace Assimp
-{
-
-// <Box
-// DEF=""       ID
-// USE=""       IDREF
-// size="2 2 2" SFVec3f [initializeOnly]
-// solid="true" SFBool  [initializeOnly]
-// />
-// The Box node specifies a rectangular parallelepiped box centred at (0, 0, 0) in the local coordinate system and aligned with the local coordinate axes.
-// By default, the box measures 2 units in each dimension, from -1 to +1. The size field specifies the extents of the box along the X-, Y-, and Z-axes
-// respectively and each component value shall be greater than zero.
-void X3DImporter::ParseNode_Geometry3D_Box()
-{
-    std::string def, use;
-    bool solid = true;
-    aiVector3D size(2, 2, 2);
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_REF("size", size, XML_ReadNode_GetAttrVal_AsVec3f);
-		MACRO_ATTRREAD_CHECK_RET("solid", solid, XML_ReadNode_GetAttrVal_AsBool);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_Box, ne);
-	}
-	else
-	{
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_Geometry3D(CX3DImporter_NodeElement::ENET_Box, NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		GeometryHelper_MakeQL_RectParallelepiped(size, ((CX3DImporter_NodeElement_Geometry3D*)ne)->Vertices);// get quad list
-		((CX3DImporter_NodeElement_Geometry3D*)ne)->Solid = solid;
-		((CX3DImporter_NodeElement_Geometry3D*)ne)->NumIndices = 4;
-		// check for X3DMetadataObject childs.
-		if(!mReader->isEmptyElement())
-			ParseNode_Metadata(ne, "Box");
-		else
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-// <Cone
-// DEF=""           ID
-// USE=""           IDREF
-// bottom="true"    SFBool [initializeOnly]
-// bottomRadius="1" SFloat [initializeOnly]
-// height="2"       SFloat [initializeOnly]
-// side="true"      SFBool [initializeOnly]
-// solid="true"     SFBool [initializeOnly]
-// />
-void X3DImporter::ParseNode_Geometry3D_Cone()
-{
-    std::string use, def;
-    bool bottom = true;
-    float bottomRadius = 1;
-    float height = 2;
-    bool side = true;
-    bool solid = true;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_RET("solid", solid, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("side", side, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("bottom", bottom, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("height", height, XML_ReadNode_GetAttrVal_AsFloat);
-		MACRO_ATTRREAD_CHECK_RET("bottomRadius", bottomRadius, XML_ReadNode_GetAttrVal_AsFloat);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_Cone, ne);
-	}
-	else
-	{
-		const unsigned int tess = 30;///TODO: IME tessellation factor through ai_property
-
-		std::vector<aiVector3D> tvec;// temp array for vertices.
-
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_Geometry3D(CX3DImporter_NodeElement::ENET_Cone, NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		// make cone or parts according to flags.
-		if(side)
-		{
-			StandardShapes::MakeCone(height, 0, bottomRadius, tess, tvec, !bottom);
-		}
-		else if(bottom)
-		{
-			StandardShapes::MakeCircle(bottomRadius, tess, tvec);
-			height = -(height / 2);
-			for(std::vector<aiVector3D>::iterator it = tvec.begin(); it != tvec.end(); ++it) it->y = height;// y - because circle made in oXZ.
-		}
-
-		// copy data from temp array
-		for(std::vector<aiVector3D>::iterator it = tvec.begin(); it != tvec.end(); ++it) ((CX3DImporter_NodeElement_Geometry3D*)ne)->Vertices.push_back(*it);
-
-		((CX3DImporter_NodeElement_Geometry3D*)ne)->Solid = solid;
-		((CX3DImporter_NodeElement_Geometry3D*)ne)->NumIndices = 3;
-		// check for X3DMetadataObject childs.
-		if(!mReader->isEmptyElement())
-			ParseNode_Metadata(ne, "Cone");
-		else
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-// <Cylinder
-// DEF=""        ID
-// USE=""        IDREF
-// bottom="true" SFBool [initializeOnly]
-// height="2"    SFloat [initializeOnly]
-// radius="1"    SFloat [initializeOnly]
-// side="true"   SFBool [initializeOnly]
-// solid="true"  SFBool [initializeOnly]
-// top="true"    SFBool [initializeOnly]
-// />
-void X3DImporter::ParseNode_Geometry3D_Cylinder()
-{
-    std::string use, def;
-    bool bottom = true;
-    float height = 2;
-    float radius = 1;
-    bool side = true;
-    bool solid = true;
-    bool top = true;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_RET("radius", radius, XML_ReadNode_GetAttrVal_AsFloat);
-		MACRO_ATTRREAD_CHECK_RET("solid", solid, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("bottom", bottom, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("top", top, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("side", side, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("height", height, XML_ReadNode_GetAttrVal_AsFloat);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_Cylinder, ne);
-	}
-	else
-	{
-		const unsigned int tess = 30;///TODO: IME tessellation factor through ai_property
-
-		std::vector<aiVector3D> tside;// temp array for vertices of side.
-		std::vector<aiVector3D> tcir;// temp array for vertices of circle.
-
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_Geometry3D(CX3DImporter_NodeElement::ENET_Cylinder, NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		// make cilynder or parts according to flags.
-		if(side) StandardShapes::MakeCone(height, radius, radius, tess, tside, true);
-
-		height /= 2;// height defined for whole cylinder, when creating top and bottom circle we are using just half of height.
-		if(top || bottom) StandardShapes::MakeCircle(radius, tess, tcir);
-		// copy data from temp arrays
-		std::list<aiVector3D>& vlist = ((CX3DImporter_NodeElement_Geometry3D*)ne)->Vertices;// just short alias.
-
-		for(std::vector<aiVector3D>::iterator it = tside.begin(); it != tside.end(); ++it) vlist.push_back(*it);
-
-		if(top)
-		{
-			for(std::vector<aiVector3D>::iterator it = tcir.begin(); it != tcir.end(); ++it)
-			{
-				(*it).y = height;// y - because circle made in oXZ.
-				vlist.push_back(*it);
-			}
-		}// if(top)
-
-		if(bottom)
-		{
-			for(std::vector<aiVector3D>::iterator it = tcir.begin(); it != tcir.end(); ++it)
-			{
-				(*it).y = -height;// y - because circle made in oXZ.
-				vlist.push_back(*it);
-			}
-		}// if(top)
-
-		((CX3DImporter_NodeElement_Geometry3D*)ne)->Solid = solid;
-		((CX3DImporter_NodeElement_Geometry3D*)ne)->NumIndices = 3;
-		// check for X3DMetadataObject childs.
-		if(!mReader->isEmptyElement())
-			ParseNode_Metadata(ne, "Cylinder");
-		else
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-// <ElevationGrid
-// DEF=""                 ID
-// USE=""                 IDREF
-// ccw="true"             SFBool  [initializeOnly]
-// colorPerVertex="true"  SFBool  [initializeOnly]
-// creaseAngle="0"        SFloat  [initializeOnly]
-// height=""              MFloat  [initializeOnly]
-// normalPerVertex="true" SFBool  [initializeOnly]
-// solid="true"           SFBool  [initializeOnly]
-// xDimension="0"         SFInt32 [initializeOnly]
-// xSpacing="1.0"         SFloat  [initializeOnly]
-// zDimension="0"         SFInt32 [initializeOnly]
-// zSpacing="1.0"         SFloat  [initializeOnly]
-// >
-//   <!-- ColorNormalTexCoordContentModel -->
-// ColorNormalTexCoordContentModel can contain Color (or ColorRGBA), Normal and TextureCoordinate, in any order. No more than one instance of any single
-// node type is allowed. A ProtoInstance node (with the proper node type) can be substituted for any node in this content model.
-// </ElevationGrid>
-// The ElevationGrid node specifies a uniform rectangular grid of varying height in the Y=0 plane of the local coordinate system. The geometry is described
-// by a scalar array of height values that specify the height of a surface above each point of the grid. The xDimension and zDimension fields indicate
-// the number of elements of the grid height array in the X and Z directions. Both xDimension and zDimension shall be greater than or equal to zero.
-// If either the xDimension or the zDimension is less than two, the ElevationGrid contains no quadrilaterals.
-void X3DImporter::ParseNode_Geometry3D_ElevationGrid()
-{
-    std::string use, def;
-    bool ccw = true;
-    bool colorPerVertex = true;
-    float creaseAngle = 0;
-    std::vector<float> height;
-    bool normalPerVertex = true;
-    bool solid = true;
-    int32_t xDimension = 0;
-    float xSpacing = 1;
-    int32_t zDimension = 0;
-    float zSpacing = 1;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_RET("solid", solid, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("ccw", ccw, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("colorPerVertex", colorPerVertex, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("normalPerVertex", normalPerVertex, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("creaseAngle", creaseAngle, XML_ReadNode_GetAttrVal_AsFloat);
-		MACRO_ATTRREAD_CHECK_REF("height", height, XML_ReadNode_GetAttrVal_AsArrF);
-		MACRO_ATTRREAD_CHECK_RET("xDimension", xDimension, XML_ReadNode_GetAttrVal_AsI32);
-		MACRO_ATTRREAD_CHECK_RET("xSpacing", xSpacing, XML_ReadNode_GetAttrVal_AsFloat);
-		MACRO_ATTRREAD_CHECK_RET("zDimension", zDimension, XML_ReadNode_GetAttrVal_AsI32);
-		MACRO_ATTRREAD_CHECK_RET("zSpacing", zSpacing, XML_ReadNode_GetAttrVal_AsFloat);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_ElevationGrid, ne);
-	}
-	else
-	{
-		if((xSpacing == 0.0f) || (zSpacing == 0.0f)) throw DeadlyImportError("Spacing in <ElevationGrid> must be grater than zero.");
-		if((xDimension <= 0) || (zDimension <= 0)) throw DeadlyImportError("Dimension in <ElevationGrid> must be grater than zero.");
-		if((size_t)(xDimension * zDimension) != height.size()) Throw_IncorrectAttrValue("Heights count must be equal to \"xDimension * zDimension\"");
-
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_ElevationGrid(CX3DImporter_NodeElement::ENET_ElevationGrid, NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		CX3DImporter_NodeElement_ElevationGrid& grid_alias = *((CX3DImporter_NodeElement_ElevationGrid*)ne);// create alias for conveience
-
-		{// create grid vertices list
-			std::vector<float>::const_iterator he_it = height.begin();
-
-			for(int32_t zi = 0; zi < zDimension; zi++)// rows
-			{
-				for(int32_t xi = 0; xi < xDimension; xi++)// columns
-				{
-					aiVector3D tvec(xSpacing * xi, *he_it, zSpacing * zi);
-
-					grid_alias.Vertices.push_back(tvec);
-					++he_it;
-				}
-			}
-		}// END: create grid vertices list
-		//
-		// create faces list. In "coordIdx" format
-		//
-		// check if we have quads
-		if((xDimension < 2) || (zDimension < 2))// only one element in dimension is set, create line set.
-		{
-			((CX3DImporter_NodeElement_ElevationGrid*)ne)->NumIndices = 2;// will be holded as line set.
-			for(size_t i = 0, i_e = (grid_alias.Vertices.size() - 1); i < i_e; i++)
-			{
-				grid_alias.CoordIdx.push_back(static_cast<int32_t>(i));
-				grid_alias.CoordIdx.push_back(static_cast<int32_t>(i + 1));
-				grid_alias.CoordIdx.push_back(-1);
-			}
-		}
-		else// two or more elements in every dimension is set. create quad set.
-		{
-			((CX3DImporter_NodeElement_ElevationGrid*)ne)->NumIndices = 4;
-			for(int32_t fzi = 0, fzi_e = (zDimension - 1); fzi < fzi_e; fzi++)// rows
-			{
-				for(int32_t fxi = 0, fxi_e = (xDimension - 1); fxi < fxi_e; fxi++)// columns
-				{
-					// points direction in face.
-					if(ccw)
-					{
-						// CCW:
-						//	3 2
-						//	0 1
-						grid_alias.CoordIdx.push_back((fzi + 1) * xDimension + fxi);
-						grid_alias.CoordIdx.push_back((fzi + 1) * xDimension + (fxi + 1));
-						grid_alias.CoordIdx.push_back(fzi * xDimension + (fxi + 1));
-						grid_alias.CoordIdx.push_back(fzi * xDimension + fxi);
-					}
-					else
-					{
-						// CW:
-						//	0 1
-						//	3 2
-						grid_alias.CoordIdx.push_back(fzi * xDimension + fxi);
-						grid_alias.CoordIdx.push_back(fzi * xDimension + (fxi + 1));
-						grid_alias.CoordIdx.push_back((fzi + 1) * xDimension + (fxi + 1));
-						grid_alias.CoordIdx.push_back((fzi + 1) * xDimension + fxi);
-					}// if(ccw) else
-
-					grid_alias.CoordIdx.push_back(-1);
-				}// for(int32_t fxi = 0, fxi_e = (xDimension - 1); fxi < fxi_e; fxi++)
-			}// for(int32_t fzi = 0, fzi_e = (zDimension - 1); fzi < fzi_e; fzi++)
-		}// if((xDimension < 2) || (zDimension < 2)) else
-
-		grid_alias.ColorPerVertex = colorPerVertex;
-		grid_alias.NormalPerVertex = normalPerVertex;
-		grid_alias.CreaseAngle = creaseAngle;
-		grid_alias.Solid = solid;
-        // check for child nodes
-        if(!mReader->isEmptyElement())
-        {
-			ParseHelper_Node_Enter(ne);
-			MACRO_NODECHECK_LOOPBEGIN("ElevationGrid");
-				// check for X3DComposedGeometryNodes
-				if(XML_CheckNode_NameEqual("Color")) { ParseNode_Rendering_Color(); continue; }
-				if(XML_CheckNode_NameEqual("ColorRGBA")) { ParseNode_Rendering_ColorRGBA(); continue; }
-				if(XML_CheckNode_NameEqual("Normal")) { ParseNode_Rendering_Normal(); continue; }
-				if(XML_CheckNode_NameEqual("TextureCoordinate")) { ParseNode_Texturing_TextureCoordinate(); continue; }
-				// check for X3DMetadataObject
-				if(!ParseHelper_CheckRead_X3DMetadataObject()) XML_CheckNode_SkipUnsupported("ElevationGrid");
-
-			MACRO_NODECHECK_LOOPEND("ElevationGrid");
-			ParseHelper_Node_Exit();
-		}// if(!mReader->isEmptyElement())
-		else
-		{
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-		}// if(!mReader->isEmptyElement()) else
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-template<typename TVector>
-static void GeometryHelper_Extrusion_CurveIsClosed(std::vector<TVector>& pCurve, const bool pDropTail, const bool pRemoveLastPoint, bool& pCurveIsClosed)
-{
-    size_t cur_sz = pCurve.size();
-
-	pCurveIsClosed = false;
-	// for curve with less than four points checking is have no sense,
-	if(cur_sz < 4) return;
-
-	for(size_t s = 3, s_e = cur_sz; s < s_e; s++)
-	{
-		// search for first point of duplicated part.
-		if(pCurve[0] == pCurve[s])
-		{
-			bool found = true;
-
-			// check if tail(indexed by b2) is duplicate of head(indexed by b1).
-			for(size_t b1 = 1, b2 = (s + 1); b2 < cur_sz; b1++, b2++)
-			{
-				if(pCurve[b1] != pCurve[b2])
-				{// points not match: clear flag and break loop.
-					found = false;
-
-					break;
-				}
-			}// for(size_t b1 = 1, b2 = (s + 1); b2 < cur_sz; b1++, b2++)
-
-			// if duplicate tail is found then drop or not it depending on flags.
-			if(found)
-			{
-				pCurveIsClosed = true;
-				if(pDropTail)
-				{
-					if(!pRemoveLastPoint) s++;// prepare value for iterator's arithmetics.
-
-					pCurve.erase(pCurve.begin() + s, pCurve.end());// remove tail
-				}
-
-				break;
-			}// if(found)
-		}// if(pCurve[0] == pCurve[s])
-	}// for(size_t s = 3, s_e = (cur_sz - 1); s < s_e; s++)
-}
-
-static aiVector3D GeometryHelper_Extrusion_GetNextY(const size_t pSpine_PointIdx, const std::vector<aiVector3D>& pSpine, const bool pSpine_Closed)
-{
-    const size_t spine_idx_last = pSpine.size() - 1;
-    aiVector3D tvec;
-
-	if((pSpine_PointIdx == 0) || (pSpine_PointIdx == spine_idx_last))// at first special cases
-	{
-		if(pSpine_Closed)
-		{// If the spine curve is closed: The SCP for the first and last points is the same and is found using (spine[1] - spine[n - 2]) to compute the Y-axis.
-			// As we even for closed spine curve last and first point in pSpine are not the same: duplicates(spine[n - 1] which are equivalent to spine[0])
-			// in tail are removed.
-			// So, last point in pSpine is a spine[n - 2]
-			tvec = pSpine[1] - pSpine[spine_idx_last];
-		}
-		else if(pSpine_PointIdx == 0)
-		{// The Y-axis used for the first point is the vector from spine[0] to spine[1]
-			tvec = pSpine[1] - pSpine[0];
-		}
-		else
-		{// The Y-axis used for the last point it is the vector from spine[n-2] to spine[n-1]. In our case(see above about dropping tail) spine[n - 1] is
-			// the spine[0].
-			tvec = pSpine[spine_idx_last] - pSpine[spine_idx_last - 1];
-		}
-	}// if((pSpine_PointIdx == 0) || (pSpine_PointIdx == spine_idx_last))
-	else
-	{// For all points other than the first or last: The Y-axis for spine[i] is found by normalizing the vector defined by (spine[i+1] - spine[i-1]).
-		tvec = pSpine[pSpine_PointIdx + 1] - pSpine[pSpine_PointIdx - 1];
-	}// if((pSpine_PointIdx == 0) || (pSpine_PointIdx == spine_idx_last)) else
-
-	return tvec.Normalize();
-}
-
-static aiVector3D GeometryHelper_Extrusion_GetNextZ(const size_t pSpine_PointIdx, const std::vector<aiVector3D>& pSpine, const bool pSpine_Closed,
-													const aiVector3D pVecZ_Prev)
-{
-    const aiVector3D zero_vec(0);
-    const size_t spine_idx_last = pSpine.size() - 1;
-
-    aiVector3D tvec;
-
-	// at first special cases
-	if(pSpine.size() < 3)// spine have not enough points for vector calculations.
-	{
-		tvec.Set(0, 0, 1);
-	}
-	else if(pSpine_PointIdx == 0)// special case: first point
-	{
-		if(pSpine_Closed)// for calculating use previous point in curve s[n - 2]. In list it's a last point, because point s[n - 1] was removed as duplicate.
-		{
-			tvec = (pSpine[1] - pSpine[0]) ^ (pSpine[spine_idx_last] - pSpine[0]);
-		}
-		else // for not closed curve first and next point(s[0] and s[1]) has the same vector Z.
-		{
-			bool found = false;
-
-			// As said: "If the Z-axis of the first point is undefined (because the spine is not closed and the first two spine segments are collinear)
-			// then the Z-axis for the first spine point with a defined Z-axis is used."
-			// Walk through spine and find Z.
-			for(size_t next_point = 2; (next_point <= spine_idx_last) && !found; next_point++)
-			{
-				// (pSpine[2] - pSpine[1]) ^ (pSpine[0] - pSpine[1])
-				tvec = (pSpine[next_point] - pSpine[next_point - 1]) ^ (pSpine[next_point - 2] - pSpine[next_point - 1]);
-				found = !tvec.Equal(zero_vec);
-			}
-
-			// if entire spine are collinear then use OZ axis.
-			if(!found) tvec.Set(0, 0, 1);
-		}// if(pSpine_Closed) else
-	}// else if(pSpine_PointIdx == 0)
-	else if(pSpine_PointIdx == spine_idx_last)// special case: last point
-	{
-		if(pSpine_Closed)
-		{// do not forget that real last point s[n - 1] is removed as duplicated. And in this case we are calculating vector Z for point s[n - 2].
-			tvec = (pSpine[0] - pSpine[pSpine_PointIdx]) ^ (pSpine[pSpine_PointIdx - 1] - pSpine[pSpine_PointIdx]);
-			// if taken spine vectors are collinear then use previous vector Z.
-			if(tvec.Equal(zero_vec)) tvec = pVecZ_Prev;
-		}
-		else
-		{// vector Z for last point of not closed curve is previous vector Z.
-			tvec = pVecZ_Prev;
-		}
-	}
-	else// regular point
-	{
-		tvec = (pSpine[pSpine_PointIdx + 1] - pSpine[pSpine_PointIdx]) ^ (pSpine[pSpine_PointIdx - 1] - pSpine[pSpine_PointIdx]);
-		// if taken spine vectors are collinear then use previous vector Z.
-		if(tvec.Equal(zero_vec)) tvec = pVecZ_Prev;
-	}
-
-	// After determining the Z-axis, its dot product with the Z-axis of the previous spine point is computed. If this value is negative, the Z-axis
-	// is flipped (multiplied by -1).
-	if((tvec * pVecZ_Prev) < 0) tvec = -tvec;
-
-	return tvec.Normalize();
-}
-
-// <Extrusion
-// DEF=""                                 ID
-// USE=""                                 IDREF
-// beginCap="true"                        SFBool     [initializeOnly]
-// ccw="true"                             SFBool     [initializeOnly]
-// convex="true"                          SFBool     [initializeOnly]
-// creaseAngle="0.0"                      SFloat     [initializeOnly]
-// crossSection="1 1 1 -1 -1 -1 -1 1 1 1" MFVec2f    [initializeOnly]
-// endCap="true"                          SFBool     [initializeOnly]
-// orientation="0 0 1 0"                  MFRotation [initializeOnly]
-// scale="1 1"                            MFVec2f    [initializeOnly]
-// solid="true"                           SFBool     [initializeOnly]
-// spine="0 0 0 0 1 0"                    MFVec3f    [initializeOnly]
-// />
-void X3DImporter::ParseNode_Geometry3D_Extrusion()
-{
-    std::string use, def;
-    bool beginCap = true;
-    bool ccw = true;
-    bool convex = true;
-    float creaseAngle = 0;
-    std::vector<aiVector2D> crossSection;
-    bool endCap = true;
-    std::vector<float> orientation;
-    std::vector<aiVector2D> scale;
-    bool solid = true;
-    std::vector<aiVector3D> spine;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_RET("beginCap", beginCap, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("ccw", ccw, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("convex", convex, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("creaseAngle", creaseAngle, XML_ReadNode_GetAttrVal_AsFloat);
-		MACRO_ATTRREAD_CHECK_REF("crossSection", crossSection, XML_ReadNode_GetAttrVal_AsArrVec2f);
-		MACRO_ATTRREAD_CHECK_RET("endCap", endCap, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_REF("orientation", orientation, XML_ReadNode_GetAttrVal_AsArrF);
-		MACRO_ATTRREAD_CHECK_REF("scale", scale, XML_ReadNode_GetAttrVal_AsArrVec2f);
-		MACRO_ATTRREAD_CHECK_RET("solid", solid, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_REF("spine", spine, XML_ReadNode_GetAttrVal_AsArrVec3f);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_Extrusion, ne);
-	}
-	else
-	{
-		//
-		// check if default values must be assigned
-		//
-		if(spine.size() == 0)
-		{
-			spine.resize(2);
-			spine[0].Set(0, 0, 0), spine[1].Set(0, 1, 0);
-		}
-		else if(spine.size() == 1)
-		{
-			throw DeadlyImportError("ParseNode_Geometry3D_Extrusion. Spine must have at least two points.");
-		}
-
-		if(crossSection.size() == 0)
-		{
-			crossSection.resize(5);
-			crossSection[0].Set(1, 1), crossSection[1].Set(1, -1), crossSection[2].Set(-1, -1), crossSection[3].Set(-1, 1), crossSection[4].Set(1, 1);
-		}
-
-		{// orientation
-			size_t ori_size = orientation.size() / 4;
-
-			if(ori_size < spine.size())
-			{
-				float add_ori[4];// values that will be added
-
-				if(ori_size == 1)// if "orientation" has one element(means one MFRotation with four components) then use it value for all spine points.
-				{
-					add_ori[0] = orientation[0], add_ori[1] = orientation[1], add_ori[2] = orientation[2], add_ori[3] = orientation[3];
-				}
-				else// else - use default values
-				{
-					add_ori[0] = 0, add_ori[1] = 0, add_ori[2] = 1, add_ori[3] = 0;
-				}
-
-				orientation.reserve(spine.size() * 4);
-				for(size_t i = 0, i_e = (spine.size() - ori_size); i < i_e; i++)
-					orientation.push_back(add_ori[0]), orientation.push_back(add_ori[1]), orientation.push_back(add_ori[2]), orientation.push_back(add_ori[3]);
-			}
-
-			if(orientation.size() % 4) throw DeadlyImportError("Attribute \"orientation\" in <Extrusion> must has multiple four quantity of numbers.");
-		}// END: orientation
-
-		{// scale
-			if(scale.size() < spine.size())
-			{
-				aiVector2D add_sc;
-
-				if(scale.size() == 1)// if "scale" has one element then use it value for all spine points.
-					add_sc = scale[0];
-				else// else - use default values
-					add_sc.Set(1, 1);
-
-				scale.reserve(spine.size());
-				for(size_t i = 0, i_e = (spine.size() - scale.size()); i < i_e; i++) scale.push_back(add_sc);
-			}
-		}// END: scale
-		//
-		// create and if needed - define new geometry object.
-		//
-		ne = new CX3DImporter_NodeElement_IndexedSet(CX3DImporter_NodeElement::ENET_Extrusion, NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		CX3DImporter_NodeElement_IndexedSet& ext_alias = *((CX3DImporter_NodeElement_IndexedSet*)ne);// create alias for conveience
-		// assign part of input data
-		ext_alias.CCW = ccw;
-		ext_alias.Convex = convex;
-		ext_alias.CreaseAngle = creaseAngle;
-		ext_alias.Solid = solid;
-
-		//
-		// How we done it at all?
-		// 1. At first we will calculate array of basises for every point in spine(look SCP in ISO-dic). Also "orientation" vector
-		// are applied vor every basis.
-		// 2. After that we can create array of point sets: which are scaled, transferred to basis of relative basis and at final translated to real position
-		// using relative spine point.
-		// 3. Next step is creating CoordIdx array(do not forget "-1" delimiter). While creating CoordIdx also created faces for begin and end caps, if
-		// needed. While createing CootdIdx is taking in account CCW flag.
-		// 4. The last step: create Vertices list.
-		//
-        bool spine_closed;// flag: true if spine curve is closed.
-        bool cross_closed;// flag: true if cross curve is closed.
-        std::vector<aiMatrix3x3> basis_arr;// array of basises. ROW_a - X, ROW_b - Y, ROW_c - Z.
-        std::vector<std::vector<aiVector3D> > pointset_arr;// array of point sets: cross curves.
-
-        // detect closed curves
-        GeometryHelper_Extrusion_CurveIsClosed(crossSection, true, true, cross_closed);// true - drop tail, true - remove duplicate end.
-        GeometryHelper_Extrusion_CurveIsClosed(spine, true, true, spine_closed);// true - drop tail, true - remove duplicate end.
-        // If both cap are requested and spine curve is closed then we can make only one cap. Because second cap will be the same surface.
-        if(spine_closed)
-        {
-			beginCap |= endCap;
-			endCap = false;
-		}
-
-        {// 1. Calculate array of basises.
-			aiMatrix4x4 rotmat;
-			aiVector3D vecX(0), vecY(0), vecZ(0);
-
-			basis_arr.resize(spine.size());
-			for(size_t i = 0, i_e = spine.size(); i < i_e; i++)
-			{
-				aiVector3D tvec;
-
-				// get axises of basis.
-				vecY = GeometryHelper_Extrusion_GetNextY(i, spine, spine_closed);
-				vecZ = GeometryHelper_Extrusion_GetNextZ(i, spine, spine_closed, vecZ);
-				vecX = (vecY ^ vecZ).Normalize();
-				// get rotation matrix and apply "orientation" to basis
-				aiMatrix4x4::Rotation(orientation[i * 4 + 3], aiVector3D(orientation[i * 4], orientation[i * 4 + 1], orientation[i * 4 + 2]), rotmat);
-				tvec = vecX, tvec *= rotmat, basis_arr[i].a1 = tvec.x, basis_arr[i].a2 = tvec.y, basis_arr[i].a3 = tvec.z;
-				tvec = vecY, tvec *= rotmat, basis_arr[i].b1 = tvec.x, basis_arr[i].b2 = tvec.y, basis_arr[i].b3 = tvec.z;
-				tvec = vecZ, tvec *= rotmat, basis_arr[i].c1 = tvec.x, basis_arr[i].c2 = tvec.y, basis_arr[i].c3 = tvec.z;
-			}// for(size_t i = 0, i_e = spine.size(); i < i_e; i++)
-		}// END: 1. Calculate array of basises
-
-		{// 2. Create array of point sets.
-			aiMatrix4x4 scmat;
-			std::vector<aiVector3D> tcross(crossSection.size());
-
-			pointset_arr.resize(spine.size());
-			for(size_t spi = 0, spi_e = spine.size(); spi < spi_e; spi++)
-			{
-				aiVector3D tc23vec;
-
-				tc23vec.Set(scale[spi].x, 0, scale[spi].y);
-				aiMatrix4x4::Scaling(tc23vec, scmat);
-				for(size_t cri = 0, cri_e = crossSection.size(); cri < cri_e; cri++)
-				{
-					aiVector3D tvecX, tvecY, tvecZ;
-
-					tc23vec.Set(crossSection[cri].x, 0, crossSection[cri].y);
-					// apply scaling to point
-					tcross[cri] = scmat * tc23vec;
-					//
-					// transfer point to new basis
-					// calculate coordinate in new basis
-					tvecX.Set(basis_arr[spi].a1, basis_arr[spi].a2, basis_arr[spi].a3), tvecX *= tcross[cri].x;
-					tvecY.Set(basis_arr[spi].b1, basis_arr[spi].b2, basis_arr[spi].b3), tvecY *= tcross[cri].y;
-					tvecZ.Set(basis_arr[spi].c1, basis_arr[spi].c2, basis_arr[spi].c3), tvecZ *= tcross[cri].z;
-					// apply new coordinates and translate it to spine point.
-					tcross[cri] = tvecX + tvecY + tvecZ + spine[spi];
-				}// for(size_t cri = 0, cri_e = crossSection.size(); cri < cri_e; i++)
-
-				pointset_arr[spi] = tcross;// store transferred point set
-			}// for(size_t spi = 0, spi_e = spine.size(); spi < spi_e; i++)
-		}// END: 2. Create array of point sets.
-
-		{// 3. Create CoordIdx.
-			// add caps if needed
-			if(beginCap)
-			{
-				// add cap as polygon. vertices of cap are places at begin, so just add numbers from zero.
-				for(size_t i = 0, i_e = crossSection.size(); i < i_e; i++) ext_alias.CoordIndex.push_back(static_cast<int32_t>(i));
-
-				// add delimiter
-				ext_alias.CoordIndex.push_back(-1);
-			}// if(beginCap)
-
-			if(endCap)
-			{
-				// add cap as polygon. vertices of cap are places at end, as for beginCap use just sequence of numbers but with offset.
-				size_t beg = (pointset_arr.size() - 1) * crossSection.size();
-
-				for(size_t i = beg, i_e = (beg + crossSection.size()); i < i_e; i++) ext_alias.CoordIndex.push_back(static_cast<int32_t>(i));
-
-				// add delimiter
-				ext_alias.CoordIndex.push_back(-1);
-			}// if(beginCap)
-
-			// add quads
-			for(size_t spi = 0, spi_e = (spine.size() - 1); spi <= spi_e; spi++)
-			{
-				const size_t cr_sz = crossSection.size();
-				const size_t cr_last = crossSection.size() - 1;
-
-				size_t right_col;// hold index basis for points of quad placed in right column;
-
-				if(spi != spi_e)
-					right_col = spi + 1;
-				else if(spine_closed)// if spine curve is closed then one more quad is needed: between first and last points of curve.
-					right_col = 0;
-				else
-					break;// if spine curve is not closed then break the loop, because spi is out of range for that type of spine.
-
-				for(size_t cri = 0; cri < cr_sz; cri++)
-				{
-					if(cri != cr_last)
-					{
-						MACRO_FACE_ADD_QUAD(ccw, ext_alias.CoordIndex,
-											static_cast<int32_t>(spi * cr_sz + cri), 
-                                            static_cast<int32_t>(right_col * cr_sz + cri), 
-                                            static_cast<int32_t>(right_col * cr_sz + cri + 1), 
-                                            static_cast<int32_t>(spi * cr_sz + cri + 1));
-						// add delimiter
-						ext_alias.CoordIndex.push_back(-1);
-					}
-					else if(cross_closed)// if cross curve is closed then one more quad is needed: between first and last points of curve.
-					{
-						MACRO_FACE_ADD_QUAD(ccw, ext_alias.CoordIndex,
-                                            static_cast<int32_t>(spi * cr_sz + cri), 
-                                            static_cast<int32_t>(right_col * cr_sz + cri), 
-                                            static_cast<int32_t>(right_col * cr_sz + 0), 
-                                            static_cast<int32_t>(spi * cr_sz + 0));
-						// add delimiter
-						ext_alias.CoordIndex.push_back(-1);
-					}
-				}// for(size_t cri = 0; cri < cr_sz; cri++)
-			}// for(size_t spi = 0, spi_e = (spine.size() - 2); spi < spi_e; spi++)
-		}// END: 3. Create CoordIdx.
-
-		{// 4. Create vertices list.
-			// just copy all vertices
-			for(size_t spi = 0, spi_e = spine.size(); spi < spi_e; spi++)
-			{
-				for(size_t cri = 0, cri_e = crossSection.size(); cri < cri_e; cri++)
-				{
-					ext_alias.Vertices.push_back(pointset_arr[spi][cri]);
-				}
-			}
-		}// END: 4. Create vertices list.
-//PrintVectorSet("Ext. CoordIdx", ext_alias.CoordIndex);
-//PrintVectorSet("Ext. Vertices", ext_alias.Vertices);
-		// check for child nodes
-		if(!mReader->isEmptyElement())
-			ParseNode_Metadata(ne, "Extrusion");
-		else
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-// <IndexedFaceSet
-// DEF=""                         ID
-// USE=""                         IDREF
-// ccw="true"             SFBool  [initializeOnly]
-// colorIndex=""          MFInt32 [initializeOnly]
-// colorPerVertex="true"  SFBool  [initializeOnly]
-// convex="true"          SFBool  [initializeOnly]
-// coordIndex=""          MFInt32 [initializeOnly]
-// creaseAngle="0"        SFFloat [initializeOnly]
-// normalIndex=""         MFInt32 [initializeOnly]
-// normalPerVertex="true" SFBool  [initializeOnly]
-// solid="true"           SFBool  [initializeOnly]
-// texCoordIndex=""       MFInt32 [initializeOnly]
-// >
-//    <!-- ComposedGeometryContentModel -->
-// ComposedGeometryContentModel is the child-node content model corresponding to X3DComposedGeometryNodes. It can contain Color (or ColorRGBA), Coordinate,
-// Normal and TextureCoordinate, in any order. No more than one instance of these nodes is allowed. Multiple VertexAttribute (FloatVertexAttribute,
-// Matrix3VertexAttribute, Matrix4VertexAttribute) nodes can also be contained.
-// A ProtoInstance node (with the proper node type) can be substituted for any node in this content model.
-// </IndexedFaceSet>
-void X3DImporter::ParseNode_Geometry3D_IndexedFaceSet()
-{
-    std::string use, def;
-    bool ccw = true;
-    std::vector<int32_t> colorIndex;
-    bool colorPerVertex = true;
-    bool convex = true;
-    std::vector<int32_t> coordIndex;
-    float creaseAngle = 0;
-    std::vector<int32_t> normalIndex;
-    bool normalPerVertex = true;
-    bool solid = true;
-    std::vector<int32_t> texCoordIndex;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_RET("ccw", ccw, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_REF("colorIndex", colorIndex, XML_ReadNode_GetAttrVal_AsArrI32);
-		MACRO_ATTRREAD_CHECK_RET("colorPerVertex", colorPerVertex, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("convex", convex, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_REF("coordIndex", coordIndex, XML_ReadNode_GetAttrVal_AsArrI32);
-		MACRO_ATTRREAD_CHECK_RET("creaseAngle", creaseAngle, XML_ReadNode_GetAttrVal_AsFloat);
-		MACRO_ATTRREAD_CHECK_REF("normalIndex", normalIndex, XML_ReadNode_GetAttrVal_AsArrI32);
-		MACRO_ATTRREAD_CHECK_RET("normalPerVertex", normalPerVertex, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("solid", solid, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_REF("texCoordIndex", texCoordIndex, XML_ReadNode_GetAttrVal_AsArrI32);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_IndexedFaceSet, ne);
-	}
-	else
-	{
-		// check data
-		if(coordIndex.size() == 0) throw DeadlyImportError("IndexedFaceSet must contain not empty \"coordIndex\" attribute.");
-
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_IndexedSet(CX3DImporter_NodeElement::ENET_IndexedFaceSet, NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		CX3DImporter_NodeElement_IndexedSet& ne_alias = *((CX3DImporter_NodeElement_IndexedSet*)ne);
-
-		ne_alias.CCW = ccw;
-		ne_alias.ColorIndex = colorIndex;
-		ne_alias.ColorPerVertex = colorPerVertex;
-		ne_alias.Convex = convex;
-		ne_alias.CoordIndex = coordIndex;
-		ne_alias.CreaseAngle = creaseAngle;
-		ne_alias.NormalIndex = normalIndex;
-		ne_alias.NormalPerVertex = normalPerVertex;
-		ne_alias.Solid = solid;
-		ne_alias.TexCoordIndex = texCoordIndex;
-        // check for child nodes
-        if(!mReader->isEmptyElement())
-        {
-			ParseHelper_Node_Enter(ne);
-			MACRO_NODECHECK_LOOPBEGIN("IndexedFaceSet");
-				// check for X3DComposedGeometryNodes
-				if(XML_CheckNode_NameEqual("Color")) { ParseNode_Rendering_Color(); continue; }
-				if(XML_CheckNode_NameEqual("ColorRGBA")) { ParseNode_Rendering_ColorRGBA(); continue; }
-				if(XML_CheckNode_NameEqual("Coordinate")) { ParseNode_Rendering_Coordinate(); continue; }
-				if(XML_CheckNode_NameEqual("Normal")) { ParseNode_Rendering_Normal(); continue; }
-				if(XML_CheckNode_NameEqual("TextureCoordinate")) { ParseNode_Texturing_TextureCoordinate(); continue; }
-				// check for X3DMetadataObject
-				if(!ParseHelper_CheckRead_X3DMetadataObject()) XML_CheckNode_SkipUnsupported("IndexedFaceSet");
-
-			MACRO_NODECHECK_LOOPEND("IndexedFaceSet");
-			ParseHelper_Node_Exit();
-		}// if(!mReader->isEmptyElement())
-		else
-		{
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-		}
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-// <Sphere
-// DEF=""       ID
-// USE=""       IDREF
-// radius="1"   SFloat [initializeOnly]
-// solid="true" SFBool [initializeOnly]
-// />
-void X3DImporter::ParseNode_Geometry3D_Sphere()
-{
-    std::string use, def;
-    ai_real radius = 1;
-    bool solid = true;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_RET("radius", radius, XML_ReadNode_GetAttrVal_AsFloat);
-		MACRO_ATTRREAD_CHECK_RET("solid", solid, XML_ReadNode_GetAttrVal_AsBool);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_Sphere, ne);
-	}
-	else
-	{
-		const unsigned int tess = 3;///TODO: IME tessellation factor through ai_property
-
-		std::vector<aiVector3D> tlist;
-
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_Geometry3D(CX3DImporter_NodeElement::ENET_Sphere, NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		StandardShapes::MakeSphere(tess, tlist);
-		// copy data from temp array and apply scale
-		for(std::vector<aiVector3D>::iterator it = tlist.begin(); it != tlist.end(); ++it)
-		{
-			((CX3DImporter_NodeElement_Geometry3D*)ne)->Vertices.push_back(*it * radius);
-		}
-
-		((CX3DImporter_NodeElement_Geometry3D*)ne)->Solid = solid;
-		((CX3DImporter_NodeElement_Geometry3D*)ne)->NumIndices = 3;
-		// check for X3DMetadataObject childs.
-		if(!mReader->isEmptyElement())
-			ParseNode_Metadata(ne, "Sphere");
-		else
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-}// namespace Assimp
-
-#endif // !ASSIMP_BUILD_NO_X3D_IMPORTER
diff --git a/Engine/lib/assimp/code/X3D/X3DImporter_Light.cpp b/Engine/lib/assimp/code/X3D/X3DImporter_Light.cpp
deleted file mode 100644
index 842fffc04..000000000
--- a/Engine/lib/assimp/code/X3D/X3DImporter_Light.cpp
+++ /dev/null
@@ -1,290 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-/// \file   X3DImporter_Light.cpp
-/// \brief  Parsing data from nodes of "Lighting" set of X3D.
-/// \date   2015-2016
-/// \author smal.root@gmail.com
-
-#ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
-
-#include "X3DImporter.hpp"
-#include "X3DImporter_Macro.hpp"
-#include <assimp/StringUtils.h>
-
-namespace Assimp {
-
-// <DirectionalLight
-// DEF=""               ID
-// USE=""               IDREF
-// ambientIntensity="0" SFFloat [inputOutput]
-// color="1 1 1"        SFColor [inputOutput]
-// direction="0 0 -1"   SFVec3f [inputOutput]
-// global="false"       SFBool  [inputOutput]
-// intensity="1"        SFFloat [inputOutput]
-// on="true"            SFBool  [inputOutput]
-// />
-void X3DImporter::ParseNode_Lighting_DirectionalLight()
-{
-    std::string def, use;
-    float ambientIntensity = 0;
-    aiColor3D color(1, 1, 1);
-    aiVector3D direction(0, 0, -1);
-    bool global = false;
-    float intensity = 1;
-    bool on = true;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_RET("ambientIntensity", ambientIntensity, XML_ReadNode_GetAttrVal_AsFloat);
-		MACRO_ATTRREAD_CHECK_REF("color", color, XML_ReadNode_GetAttrVal_AsCol3f);
-		MACRO_ATTRREAD_CHECK_REF("direction", direction, XML_ReadNode_GetAttrVal_AsVec3f);
-		MACRO_ATTRREAD_CHECK_RET("global", global, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("intensity", intensity, XML_ReadNode_GetAttrVal_AsFloat);
-		MACRO_ATTRREAD_CHECK_RET("on", on, XML_ReadNode_GetAttrVal_AsBool);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_DirectionalLight, ne);
-	}
-	else
-	{
-		if(on)
-		{
-			// create and if needed - define new geometry object.
-			ne = new CX3DImporter_NodeElement_Light(CX3DImporter_NodeElement::ENET_DirectionalLight, NodeElement_Cur);
-			if(!def.empty())
-				ne->ID = def;
-			else
-				ne->ID = "DirectionalLight_" + to_string((size_t)ne);// make random name
-
-			((CX3DImporter_NodeElement_Light*)ne)->AmbientIntensity = ambientIntensity;
-			((CX3DImporter_NodeElement_Light*)ne)->Color = color;
-			((CX3DImporter_NodeElement_Light*)ne)->Direction = direction;
-			((CX3DImporter_NodeElement_Light*)ne)->Global = global;
-			((CX3DImporter_NodeElement_Light*)ne)->Intensity = intensity;
-			// Assimp want a node with name similar to a light. "Why? I don't no." )
-			ParseHelper_Group_Begin(false);
-
-			NodeElement_Cur->ID = ne->ID;// assign name to node and return to light element.
-			ParseHelper_Node_Exit();
-			// check for child nodes
-			if(!mReader->isEmptyElement())
-				ParseNode_Metadata(ne, "DirectionalLight");
-			else
-				NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-
-			NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-		}// if(on)
-	}// if(!use.empty()) else
-}
-
-// <PointLight
-// DEF=""               ID
-// USE=""               IDREF
-// ambientIntensity="0" SFFloat [inputOutput]
-// attenuation="1 0 0"  SFVec3f [inputOutput]
-// color="1 1 1"        SFColor [inputOutput]
-// global="true"        SFBool  [inputOutput]
-// intensity="1"        SFFloat [inputOutput]
-// location="0 0 0"     SFVec3f [inputOutput]
-// on="true"            SFBool  [inputOutput]
-// radius="100"         SFFloat [inputOutput]
-// />
-void X3DImporter::ParseNode_Lighting_PointLight()
-{
-    std::string def, use;
-    float ambientIntensity = 0;
-    aiVector3D attenuation( 1, 0, 0 );
-    aiColor3D color( 1, 1, 1 );
-    bool global = true;
-    float intensity = 1;
-    aiVector3D location( 0, 0, 0 );
-    bool on = true;
-    float radius = 100;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_RET("ambientIntensity", ambientIntensity, XML_ReadNode_GetAttrVal_AsFloat);
-		MACRO_ATTRREAD_CHECK_REF("attenuation", attenuation, XML_ReadNode_GetAttrVal_AsVec3f);
-		MACRO_ATTRREAD_CHECK_REF("color", color, XML_ReadNode_GetAttrVal_AsCol3f);
-		MACRO_ATTRREAD_CHECK_RET("global", global, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("intensity", intensity, XML_ReadNode_GetAttrVal_AsFloat);
-		MACRO_ATTRREAD_CHECK_REF("location", location, XML_ReadNode_GetAttrVal_AsVec3f);
-		MACRO_ATTRREAD_CHECK_RET("on", on, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("radius", radius, XML_ReadNode_GetAttrVal_AsFloat);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_PointLight, ne);
-	}
-	else
-	{
-		if(on)
-		{
-			// create and if needed - define new geometry object.
-			ne = new CX3DImporter_NodeElement_Light(CX3DImporter_NodeElement::ENET_PointLight, NodeElement_Cur);
-			if(!def.empty()) ne->ID = def;
-
-			((CX3DImporter_NodeElement_Light*)ne)->AmbientIntensity = ambientIntensity;
-			((CX3DImporter_NodeElement_Light*)ne)->Attenuation = attenuation;
-			((CX3DImporter_NodeElement_Light*)ne)->Color = color;
-			((CX3DImporter_NodeElement_Light*)ne)->Global = global;
-			((CX3DImporter_NodeElement_Light*)ne)->Intensity = intensity;
-			((CX3DImporter_NodeElement_Light*)ne)->Location = location;
-			((CX3DImporter_NodeElement_Light*)ne)->Radius = radius;
-			// Assimp want a node with name similar to a light. "Why? I don't no." )
-			ParseHelper_Group_Begin(false);
-			// make random name
-			if(ne->ID.empty()) ne->ID = "PointLight_" + to_string((size_t)ne);
-
-			NodeElement_Cur->ID = ne->ID;// assign name to node and return to light element.
-			ParseHelper_Node_Exit();
-			// check for child nodes
-			if(!mReader->isEmptyElement())
-				ParseNode_Metadata(ne, "PointLight");
-			else
-				NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-
-			NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-		}// if(on)
-	}// if(!use.empty()) else
-}
-
-// <SpotLight
-// DEF=""                 ID
-// USE=""                 IDREF
-// ambientIntensity="0"   SFFloat [inputOutput]
-// attenuation="1 0 0"    SFVec3f [inputOutput]
-// beamWidth="0.7854"     SFFloat [inputOutput]
-// color="1 1 1"          SFColor [inputOutput]
-// cutOffAngle="1.570796" SFFloat [inputOutput]
-// direction="0 0 -1"     SFVec3f [inputOutput]
-// global="true"          SFBool  [inputOutput]
-// intensity="1"          SFFloat [inputOutput]
-// location="0 0 0"       SFVec3f [inputOutput]
-// on="true"              SFBool  [inputOutput]
-// radius="100"           SFFloat [inputOutput]
-// />
-void X3DImporter::ParseNode_Lighting_SpotLight()
-{
-    std::string def, use;
-    float ambientIntensity = 0;
-    aiVector3D attenuation( 1, 0, 0 );
-    float beamWidth = 0.7854f;
-    aiColor3D color( 1, 1, 1 );
-    float cutOffAngle = 1.570796f;
-    aiVector3D direction( 0, 0, -1 );
-    bool global = true;
-    float intensity = 1;
-    aiVector3D location( 0, 0, 0 );
-    bool on = true;
-    float radius = 100;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_RET("ambientIntensity", ambientIntensity, XML_ReadNode_GetAttrVal_AsFloat);
-		MACRO_ATTRREAD_CHECK_REF("attenuation", attenuation, XML_ReadNode_GetAttrVal_AsVec3f);
-		MACRO_ATTRREAD_CHECK_RET("beamWidth", beamWidth, XML_ReadNode_GetAttrVal_AsFloat);
-		MACRO_ATTRREAD_CHECK_REF("color", color, XML_ReadNode_GetAttrVal_AsCol3f);
-		MACRO_ATTRREAD_CHECK_RET("cutOffAngle", cutOffAngle, XML_ReadNode_GetAttrVal_AsFloat);
-		MACRO_ATTRREAD_CHECK_REF("direction", direction, XML_ReadNode_GetAttrVal_AsVec3f);
-		MACRO_ATTRREAD_CHECK_RET("global", global, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("intensity", intensity, XML_ReadNode_GetAttrVal_AsFloat);
-		MACRO_ATTRREAD_CHECK_REF("location", location, XML_ReadNode_GetAttrVal_AsVec3f);
-		MACRO_ATTRREAD_CHECK_RET("on", on, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("radius", radius, XML_ReadNode_GetAttrVal_AsFloat);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_SpotLight, ne);
-	}
-	else
-	{
-		if(on)
-		{
-			// create and if needed - define new geometry object.
-			ne = new CX3DImporter_NodeElement_Light(CX3DImporter_NodeElement::ENET_SpotLight, NodeElement_Cur);
-			if(!def.empty()) ne->ID = def;
-
-			if(beamWidth > cutOffAngle) beamWidth = cutOffAngle;
-
-			((CX3DImporter_NodeElement_Light*)ne)->AmbientIntensity = ambientIntensity;
-			((CX3DImporter_NodeElement_Light*)ne)->Attenuation = attenuation;
-			((CX3DImporter_NodeElement_Light*)ne)->BeamWidth = beamWidth;
-			((CX3DImporter_NodeElement_Light*)ne)->Color = color;
-			((CX3DImporter_NodeElement_Light*)ne)->CutOffAngle = cutOffAngle;
-			((CX3DImporter_NodeElement_Light*)ne)->Direction = direction;
-			((CX3DImporter_NodeElement_Light*)ne)->Global = global;
-			((CX3DImporter_NodeElement_Light*)ne)->Intensity = intensity;
-			((CX3DImporter_NodeElement_Light*)ne)->Location = location;
-			((CX3DImporter_NodeElement_Light*)ne)->Radius = radius;
-
-			// Assimp want a node with name similar to a light. "Why? I don't no." )
-			ParseHelper_Group_Begin(false);
-			// make random name
-			if(ne->ID.empty()) ne->ID = "SpotLight_" + to_string((size_t)ne);
-
-			NodeElement_Cur->ID = ne->ID;// assign name to node and return to light element.
-			ParseHelper_Node_Exit();
-			// check for child nodes
-			if(!mReader->isEmptyElement())
-				ParseNode_Metadata(ne, "SpotLight");
-			else
-				NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-
-			NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-		}// if(on)
-	}// if(!use.empty()) else
-}
-
-}// namespace Assimp
-
-#endif // !ASSIMP_BUILD_NO_X3D_IMPORTER
diff --git a/Engine/lib/assimp/code/X3D/X3DImporter_Macro.hpp b/Engine/lib/assimp/code/X3D/X3DImporter_Macro.hpp
deleted file mode 100644
index a6aca33fb..000000000
--- a/Engine/lib/assimp/code/X3D/X3DImporter_Macro.hpp
+++ /dev/null
@@ -1,195 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-/// \file X3DImporter_Macro.hpp
-/// \brief Useful macrodefines.
-/// \date 2015-2016
-/// \author smal.root@gmail.com
-
-#ifndef X3DIMPORTER_MACRO_HPP_INCLUDED
-#define X3DIMPORTER_MACRO_HPP_INCLUDED
-
-/// \def MACRO_USE_CHECKANDAPPLY(pDEF, pUSE, pNE)
-/// Used for regular checking while attribute "USE" is defined.
-/// \param [in] pDEF - string holding "DEF" value.
-/// \param [in] pUSE - string holding "USE" value.
-/// \param [in] pType - type of element to find.
-/// \param [out] pNE - pointer to found node element.
-#define MACRO_USE_CHECKANDAPPLY(pDEF, pUSE, pType, pNE) \
-	do { \
-	XML_CheckNode_MustBeEmpty(); \
-	if(!pDEF.empty()) Throw_DEF_And_USE(); \
-	if(!FindNodeElement(pUSE, CX3DImporter_NodeElement::pType, &pNE)) Throw_USE_NotFound(pUSE); \
-	 \
-	NodeElement_Cur->Child.push_back(pNE);/* add found object as child to current element */ \
-	} while(false)
-
-/// \def MACRO_ATTRREAD_LOOPBEG
-/// Begin of loop that read attributes values.
-#define MACRO_ATTRREAD_LOOPBEG \
-	for(int idx = 0, idx_end = mReader->getAttributeCount(); idx < idx_end; idx++) \
-	{ \
-		std::string an(mReader->getAttributeName(idx));
-
-/// \def MACRO_ATTRREAD_LOOPEND
-/// End of loop that read attributes values.
-#define MACRO_ATTRREAD_LOOPEND \
-		Throw_IncorrectAttr(an); \
-	}
-
-/// \def MACRO_ATTRREAD_CHECK_REF
-/// Check current attribute name and if it equal to requested then read value. Result write to output variable by reference. If result was read then
-/// "continue" will called.
-/// \param [in] pAttrName - attribute name.
-/// \param [out] pVarName - output variable name.
-/// \param [in] pFunction - function which read attribute value and write it to pVarName.
-#define MACRO_ATTRREAD_CHECK_REF(pAttrName, pVarName, pFunction) \
-	if(an == pAttrName) \
-	{ \
-		pFunction(idx, pVarName); \
-		continue; \
-	}
-
-/// \def MACRO_ATTRREAD_CHECK_RET
-/// Check current attribute name and if it equal to requested then read value. Result write to output variable using return value of \ref pFunction.
-/// If result was read then  "continue" will called.
-/// \param [in] pAttrName - attribute name.
-/// \param [out] pVarName - output variable name.
-/// \param [in] pFunction - function which read attribute value and write it to pVarName.
-#define MACRO_ATTRREAD_CHECK_RET(pAttrName, pVarName, pFunction) \
-	if(an == pAttrName) \
-	{ \
-		pVarName = pFunction(idx); \
-		continue; \
-	}
-
-/// \def MACRO_ATTRREAD_CHECKUSEDEF_RET
-/// Compact variant for checking "USE" and "DEF". Also skip bbox attributes: "bboxCenter", "bboxSize".
-/// If result was read then  "continue" will called.
-/// \param [out] pDEF_Var - output variable name for "DEF" value.
-/// \param [out] pUSE_Var - output variable name for "USE" value.
-#define MACRO_ATTRREAD_CHECKUSEDEF_RET(pDEF_Var, pUSE_Var) \
-	MACRO_ATTRREAD_CHECK_RET("DEF", pDEF_Var, mReader->getAttributeValue); \
-	MACRO_ATTRREAD_CHECK_RET("USE", pUSE_Var, mReader->getAttributeValue); \
-	if(an == "bboxCenter") continue; \
-	if(an == "bboxSize") continue; \
-	if(an == "containerField") continue; \
-	do {} while(false)
-
-/// \def MACRO_NODECHECK_LOOPBEGIN(pNodeName)
-/// Begin of loop of parsing child nodes. Do not add ';' at end.
-/// \param [in] pNodeName - current node name.
-#define MACRO_NODECHECK_LOOPBEGIN(pNodeName) \
-	do { \
-	bool close_found = false; \
-	 \
-	while(mReader->read()) \
-	{ \
-		if(mReader->getNodeType() == irr::io::EXN_ELEMENT) \
-		{
-
-/// \def MACRO_NODECHECK_LOOPEND(pNodeName)
-/// End of loop of parsing child nodes.
-/// \param [in] pNodeName - current node name.
-#define MACRO_NODECHECK_LOOPEND(pNodeName) \
-		}/* if(mReader->getNodeType() == irr::io::EXN_ELEMENT) */ \
-		else if(mReader->getNodeType() == irr::io::EXN_ELEMENT_END) \
-		{ \
-			if(XML_CheckNode_NameEqual(pNodeName)) \
-			{ \
-				close_found = true; \
-	 \
-				break; \
-			} \
-		}/* else if(mReader->getNodeType() == irr::io::EXN_ELEMENT_END) */ \
-	}/* while(mReader->read()) */ \
-	 \
-	if(!close_found) Throw_CloseNotFound(pNodeName); \
-	 \
-	} while(false)
-
-#define MACRO_NODECHECK_METADATA(pNodeName) \
-	MACRO_NODECHECK_LOOPBEGIN(pNodeName) \
-			/* and childs must be metadata nodes */ \
-			if(!ParseHelper_CheckRead_X3DMetadataObject()) XML_CheckNode_SkipUnsupported(pNodeName); \
-	 MACRO_NODECHECK_LOOPEND(pNodeName)
-
-/// \def MACRO_FACE_ADD_QUAD_FA(pCCW, pOut, pIn, pP1, pP2, pP3, pP4)
-/// Add points as quad. Means that pP1..pP4 set in CCW order.
-#define MACRO_FACE_ADD_QUAD_FA(pCCW, pOut, pIn, pP1, pP2, pP3, pP4) \
-	do { \
-	if(pCCW) \
-	{ \
-		pOut.push_back(pIn[pP1]); \
-		pOut.push_back(pIn[pP2]); \
-		pOut.push_back(pIn[pP3]); \
-		pOut.push_back(pIn[pP4]); \
-	} \
-	else \
-	{ \
-		pOut.push_back(pIn[pP4]); \
-		pOut.push_back(pIn[pP3]); \
-		pOut.push_back(pIn[pP2]); \
-		pOut.push_back(pIn[pP1]); \
-	} \
-	} while(false)
-
-/// \def MACRO_FACE_ADD_QUAD(pCCW, pOut, pP1, pP2, pP3, pP4)
-/// Add points as quad. Means that pP1..pP4 set in CCW order.
-#define MACRO_FACE_ADD_QUAD(pCCW, pOut, pP1, pP2, pP3, pP4) \
-	do { \
-	if(pCCW) \
-	{ \
-		pOut.push_back(pP1); \
-		pOut.push_back(pP2); \
-		pOut.push_back(pP3); \
-		pOut.push_back(pP4); \
-	} \
-	else \
-	{ \
-		pOut.push_back(pP4); \
-		pOut.push_back(pP3); \
-		pOut.push_back(pP2); \
-		pOut.push_back(pP1); \
-	} \
-	} while(false)
-
-#endif // X3DIMPORTER_MACRO_HPP_INCLUDED
diff --git a/Engine/lib/assimp/code/X3D/X3DImporter_Metadata.cpp b/Engine/lib/assimp/code/X3D/X3DImporter_Metadata.cpp
deleted file mode 100644
index f888ac2b9..000000000
--- a/Engine/lib/assimp/code/X3D/X3DImporter_Metadata.cpp
+++ /dev/null
@@ -1,277 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-/// \file   X3DImporter_Metadata.cpp
-/// \brief  Parsing data from nodes of "Metadata" set of X3D.
-/// \date   2015-2016
-/// \author smal.root@gmail.com
-
-#ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
-
-#include "X3DImporter.hpp"
-#include "X3DImporter_Macro.hpp"
-
-namespace Assimp
-{
-
-/// \def MACRO_METADATA_FINDCREATE(pDEF_Var, pUSE_Var, pReference, pValue, pNE, pMetaName)
-/// Find element by "USE" or create new one.
-/// \param [in] pDEF_Var - variable name with "DEF" value.
-/// \param [in] pUSE_Var - variable name with "USE" value.
-/// \param [in] pReference - variable name with "reference" value.
-/// \param [in] pValue - variable name with "value" value.
-/// \param [in, out] pNE - pointer to node element.
-/// \param [in] pMetaClass - Class of node.
-/// \param [in] pMetaName - Name of node.
-/// \param [in] pType - type of element to find.
-#define MACRO_METADATA_FINDCREATE(pDEF_Var, pUSE_Var, pReference, pValue, pNE, pMetaClass, pMetaName, pType) \
-	/* if "USE" defined then find already defined element. */ \
-	if(!pUSE_Var.empty()) \
-	{ \
-		MACRO_USE_CHECKANDAPPLY(pDEF_Var, pUSE_Var, pType, pNE); \
-	} \
-	else \
-	{ \
-		pNE = new pMetaClass(NodeElement_Cur); \
-		if(!pDEF_Var.empty()) pNE->ID = pDEF_Var; \
-	 \
-		((pMetaClass*)pNE)->Reference = pReference; \
-		((pMetaClass*)pNE)->Value = pValue; \
-		/* also metadata node can contain childs */ \
-		if(!mReader->isEmptyElement()) \
-			ParseNode_Metadata(pNE, pMetaName);/* in that case node element will be added to child elements list of current node. */ \
-		else \
-			NodeElement_Cur->Child.push_back(pNE);/* else - add element to child list manually */ \
-	 \
-		NodeElement_List.push_back(pNE);/* add new element to elements list. */ \
-	}/* if(!pUSE_Var.empty()) else */ \
-	 \
-	do {} while(false)
-
-bool X3DImporter::ParseHelper_CheckRead_X3DMetadataObject()
-{
-	if(XML_CheckNode_NameEqual("MetadataBoolean"))
-		ParseNode_MetadataBoolean();
-	else if(XML_CheckNode_NameEqual("MetadataDouble"))
-		ParseNode_MetadataDouble();
-	else if(XML_CheckNode_NameEqual("MetadataFloat"))
-		ParseNode_MetadataFloat();
-	else if(XML_CheckNode_NameEqual("MetadataInteger"))
-		ParseNode_MetadataInteger();
-	else if(XML_CheckNode_NameEqual("MetadataSet"))
-		ParseNode_MetadataSet();
-	else if(XML_CheckNode_NameEqual("MetadataString"))
-		ParseNode_MetadataString();
-	else
-		return false;
-
-	return true;
-}
-
-void X3DImporter::ParseNode_Metadata(CX3DImporter_NodeElement* pParentElement, const std::string& /*pNodeName*/)
-{
-	ParseHelper_Node_Enter(pParentElement);
-	MACRO_NODECHECK_METADATA(mReader->getNodeName());
-	ParseHelper_Node_Exit();
-}
-
-// <MetadataBoolean
-// DEF=""       ID
-// USE=""       IDREF
-// name=""      SFString [inputOutput]
-// reference="" SFString [inputOutput]
-// value=""     MFBool   [inputOutput]
-// />
-void X3DImporter::ParseNode_MetadataBoolean()
-{
-    std::string def, use;
-    std::string name, reference;
-    std::vector<bool> value;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_RET("name", name, mReader->getAttributeValue);
-		MACRO_ATTRREAD_CHECK_RET("reference", reference, mReader->getAttributeValue);
-		MACRO_ATTRREAD_CHECK_REF("value", value, XML_ReadNode_GetAttrVal_AsArrB);
-	MACRO_ATTRREAD_LOOPEND;
-
-	MACRO_METADATA_FINDCREATE(def, use, reference, value, ne, CX3DImporter_NodeElement_MetaBoolean, "MetadataBoolean", ENET_MetaBoolean);
-}
-
-// <MetadataDouble
-// DEF=""       ID
-// USE=""       IDREF
-// name=""      SFString [inputOutput]
-// reference="" SFString [inputOutput]
-// value=""     MFDouble [inputOutput]
-// />
-void X3DImporter::ParseNode_MetadataDouble()
-{
-    std::string def, use;
-    std::string name, reference;
-    std::vector<double> value;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_RET("name", name, mReader->getAttributeValue);
-		MACRO_ATTRREAD_CHECK_RET("reference", reference, mReader->getAttributeValue);
-		MACRO_ATTRREAD_CHECK_REF("value", value, XML_ReadNode_GetAttrVal_AsArrD);
-	MACRO_ATTRREAD_LOOPEND;
-
-	MACRO_METADATA_FINDCREATE(def, use, reference, value, ne, CX3DImporter_NodeElement_MetaDouble, "MetadataDouble", ENET_MetaDouble);
-}
-
-// <MetadataFloat
-// DEF=""       ID
-// USE=""       IDREF
-// name=""      SFString [inputOutput]
-// reference="" SFString [inputOutput]
-// value=""     MFFloat  [inputOutput]
-// />
-void X3DImporter::ParseNode_MetadataFloat()
-{
-    std::string def, use;
-    std::string name, reference;
-    std::vector<float> value;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_RET("name", name, mReader->getAttributeValue);
-		MACRO_ATTRREAD_CHECK_RET("reference", reference, mReader->getAttributeValue);
-		MACRO_ATTRREAD_CHECK_REF("value", value, XML_ReadNode_GetAttrVal_AsArrF);
-	MACRO_ATTRREAD_LOOPEND;
-
-	MACRO_METADATA_FINDCREATE(def, use, reference, value, ne, CX3DImporter_NodeElement_MetaFloat, "MetadataFloat", ENET_MetaFloat);
-}
-
-// <MetadataInteger
-// DEF=""       ID
-// USE=""       IDREF
-// name=""      SFString  [inputOutput]
-// reference="" SFString  [inputOutput]
-// value=""     MFInteger [inputOutput]
-// />
-void X3DImporter::ParseNode_MetadataInteger()
-{
-    std::string def, use;
-    std::string name, reference;
-    std::vector<int32_t> value;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_RET("name", name, mReader->getAttributeValue);
-		MACRO_ATTRREAD_CHECK_RET("reference", reference, mReader->getAttributeValue);
-		MACRO_ATTRREAD_CHECK_REF("value", value, XML_ReadNode_GetAttrVal_AsArrI32);
-	MACRO_ATTRREAD_LOOPEND;
-
-	MACRO_METADATA_FINDCREATE(def, use, reference, value, ne, CX3DImporter_NodeElement_MetaInteger, "MetadataInteger", ENET_MetaInteger);
-}
-
-// <MetadataSet
-// DEF=""       ID
-// USE=""       IDREF
-// name=""      SFString [inputOutput]
-// reference="" SFString [inputOutput]
-// />
-void X3DImporter::ParseNode_MetadataSet()
-{
-    std::string def, use;
-    std::string name, reference;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_RET("name", name, mReader->getAttributeValue);
-		MACRO_ATTRREAD_CHECK_RET("reference", reference, mReader->getAttributeValue);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_MetaSet, ne);
-	}
-	else
-	{
-		ne = new CX3DImporter_NodeElement_MetaSet(NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		((CX3DImporter_NodeElement_MetaSet*)ne)->Reference = reference;
-		// also metadata node can contain childs
-		if(!mReader->isEmptyElement())
-			ParseNode_Metadata(ne, "MetadataSet");
-		else
-			NodeElement_Cur->Child.push_back(ne);// made object as child to current element
-
-		NodeElement_List.push_back(ne);// add new element to elements list.
-	}// if(!use.empty()) else
-}
-
-// <MetadataString
-// DEF=""       ID
-// USE=""       IDREF
-// name=""      SFString [inputOutput]
-// reference="" SFString [inputOutput]
-// value=""     MFString [inputOutput]
-// />
-void X3DImporter::ParseNode_MetadataString()
-{
-    std::string def, use;
-    std::string name, reference;
-    std::list<std::string> value;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_RET("name", name, mReader->getAttributeValue);
-		MACRO_ATTRREAD_CHECK_RET("reference", reference, mReader->getAttributeValue);
-		MACRO_ATTRREAD_CHECK_REF("value", value, XML_ReadNode_GetAttrVal_AsListS);
-	MACRO_ATTRREAD_LOOPEND;
-
-	MACRO_METADATA_FINDCREATE(def, use, reference, value, ne, CX3DImporter_NodeElement_MetaString, "MetadataString", ENET_MetaString);
-}
-
-}// namespace Assimp
-
-#endif // !ASSIMP_BUILD_NO_X3D_IMPORTER
diff --git a/Engine/lib/assimp/code/X3D/X3DImporter_Node.hpp b/Engine/lib/assimp/code/X3D/X3DImporter_Node.hpp
deleted file mode 100644
index 85208223d..000000000
--- a/Engine/lib/assimp/code/X3D/X3DImporter_Node.hpp
+++ /dev/null
@@ -1,780 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-/// \file   X3DImporter_Node.hpp
-/// \brief  Elements of scene graph.
-/// \date   2015-2016
-/// \author smal.root@gmail.com
-
-#ifndef INCLUDED_AI_X3D_IMPORTER_NODE_H
-#define INCLUDED_AI_X3D_IMPORTER_NODE_H
-
-// Header files, Assimp.
-#include <assimp/scene.h>
-#include <assimp/types.h>
-
-// Header files, stdlib.
-#include <list>
-#include <vector>
-#include <string>
-
-/// \class CX3DImporter_NodeElement
-/// Base class for elements of nodes.
-class CX3DImporter_NodeElement
-{
-	/***********************************************/
-	/******************** Types ********************/
-	/***********************************************/
-
-public:
-
-	/// \enum EType
-	/// Define what data type contain node element.
-	enum EType
-	{
-		ENET_Group,                  ///< Element has type "Group".
-		ENET_MetaBoolean,            ///< Element has type "Metadata boolean".
-		ENET_MetaDouble,             ///< Element has type "Metadata double".
-		ENET_MetaFloat,              ///< Element has type "Metadata float".
-		ENET_MetaInteger,            ///< Element has type "Metadata integer".
-		ENET_MetaSet,                ///< Element has type "Metadata set".
-		ENET_MetaString,             ///< Element has type "Metadata string".
-		ENET_Arc2D,                  ///< Element has type "Arc2D".
-		ENET_ArcClose2D,             ///< Element has type "ArcClose2D".
-		ENET_Circle2D,               ///< Element has type "Circle2D".
-		ENET_Disk2D,                 ///< Element has type "Disk2D".
-		ENET_Polyline2D,             ///< Element has type "Polyline2D".
-		ENET_Polypoint2D,            ///< Element has type "Polypoint2D".
-		ENET_Rectangle2D,            ///< Element has type "Rectangle2D".
-		ENET_TriangleSet2D,          ///< Element has type "TriangleSet2D".
-		ENET_Box,                    ///< Element has type "Box".
-		ENET_Cone,                   ///< Element has type "Cone".
-		ENET_Cylinder,               ///< Element has type "Cylinder".
-		ENET_Sphere,                 ///< Element has type "Sphere".
-		ENET_ElevationGrid,          ///< Element has type "ElevationGrid".
-		ENET_Extrusion,              ///< Element has type "Extrusion".
-		ENET_Coordinate,             ///< Element has type "Coordinate".
-		ENET_Normal,                 ///< Element has type "Normal".
-		ENET_TextureCoordinate,      ///< Element has type "TextureCoordinate".
-		ENET_IndexedFaceSet,         ///< Element has type "IndexedFaceSet".
-		ENET_IndexedLineSet,         ///< Element has type "IndexedLineSet".
-		ENET_IndexedTriangleSet,     ///< Element has type "IndexedTriangleSet".
-		ENET_IndexedTriangleFanSet,  ///< Element has type "IndexedTriangleFanSet".
-		ENET_IndexedTriangleStripSet,///< Element has type "IndexedTriangleStripSet".
-		ENET_LineSet,                ///< Element has type "LineSet".
-		ENET_PointSet,               ///< Element has type "PointSet".
-		ENET_TriangleSet,            ///< Element has type "TriangleSet".
-		ENET_TriangleFanSet,         ///< Element has type "TriangleFanSet".
-		ENET_TriangleStripSet,       ///< Element has type "TriangleStripSet".
-		ENET_Color,                  ///< Element has type "Color".
-		ENET_ColorRGBA,              ///< Element has type "ColorRGBA".
-		ENET_Shape,                  ///< Element has type "Shape".
-		ENET_Appearance,             ///< Element has type "Appearance".
-		ENET_Material,               ///< Element has type "Material".
-		ENET_ImageTexture,           ///< Element has type "ImageTexture".
-		ENET_TextureTransform,       ///< Element has type "TextureTransform".
-		ENET_DirectionalLight,       ///< Element has type "DirectionalLight".
-		ENET_PointLight,             ///< Element has type "PointLight".
-		ENET_SpotLight,              ///< Element has type "SpotLight".
-
-		ENET_Invalid                 ///< Element has invalid type and possible contain invalid data.
-	};
-
-	/***********************************************/
-	/****************** Constants ******************/
-	/***********************************************/
-
-public:
-
-	const EType Type;
-
-	/***********************************************/
-	/****************** Variables ******************/
-	/***********************************************/
-
-public:
-
-	std::string ID;///< ID of the element. Can be empty. In X3D synonym for "ID" attribute.
-	CX3DImporter_NodeElement* Parent;///< Parent element. If nullptr then this node is root.
-	std::list<CX3DImporter_NodeElement*> Child;///< Child elements.
-
-	/***********************************************/
-	/****************** Functions ******************/
-	/***********************************************/
-
-    /// @brief  The destructor, virtual.
-    virtual ~CX3DImporter_NodeElement() {
-        // empty
-    }
-
-private:
-	/// Disabled copy constructor.
-	CX3DImporter_NodeElement(const CX3DImporter_NodeElement& pNodeElement);
-
-	/// Disabled assign operator.
-	CX3DImporter_NodeElement& operator=(const CX3DImporter_NodeElement& pNodeElement);
-
-	/// Disabled default constructor.
-	CX3DImporter_NodeElement();
-
-protected:
-	/// In constructor inheritor must set element type.
-	/// \param [in] pType - element type.
-	/// \param [in] pParent - parent element.
-	CX3DImporter_NodeElement(const EType pType, CX3DImporter_NodeElement* pParent)
-		: Type(pType), Parent(pParent)
-	{}
-};// class IX3DImporter_NodeElement
-
-/// \class CX3DImporter_NodeElement_Group
-/// Class that define grouping node. Define transformation matrix for children.
-/// Also can select which child will be kept and others are removed.
-class CX3DImporter_NodeElement_Group : public CX3DImporter_NodeElement
-{
-	/***********************************************/
-	/****************** Variables ******************/
-	/***********************************************/
-
-public:
-
-	aiMatrix4x4 Transformation;///< Transformation matrix.
-
-	/// \var bool Static
-	/// As you know node elements can use already defined node elements when attribute "USE" is defined.
-	/// Standard search when looking for an element in the whole scene graph, existing at this moment.
-	/// If a node is marked as static, the children(or lower) can not search for elements in the nodes upper then static.
-	bool Static;
-
-	bool UseChoice;///< Flag: if true then use number from \ref Choice to choose what the child will be kept.
-	int32_t Choice;///< Number of the child which will be kept.
-
-	/***********************************************/
-	/****************** Functions ******************/
-	/***********************************************/
-
-private:
-
-	/// \fn CX3DImporter_NodeElement_Group(const CX3DImporter_NodeElement_Group& pNode)
-	/// Disabled copy constructor.
-	CX3DImporter_NodeElement_Group(const CX3DImporter_NodeElement_Group& pNode);
-
-	/// \fn CX3DImporter_NodeElement_Group& operator=(const CX3DImporter_NodeElement_Group& pNode)
-	/// Disabled assign operator.
-	CX3DImporter_NodeElement_Group& operator=(const CX3DImporter_NodeElement_Group& pNode);
-
-	/// \fn CX3DImporter_NodeElement_Group()
-	/// Disabled default constructor.
-	CX3DImporter_NodeElement_Group();
-
-public:
-
-	/// \fn CX3DImporter_NodeElement_Group(CX3DImporter_NodeElement_Group* pParent, const bool pStatic = false)
-	/// Constructor.
-	/// \param [in] pParent - pointer to parent node.
-	/// \param [in] pStatic - static node flag.
-	CX3DImporter_NodeElement_Group(CX3DImporter_NodeElement* pParent, const bool pStatic = false)
-		: CX3DImporter_NodeElement(ENET_Group, pParent), Static(pStatic), UseChoice(false)
-	{}
-
-};// class CX3DImporter_NodeElement_Group
-
-/// \class CX3DImporter_NodeElement_Meta
-/// This struct describe metavalue.
-class CX3DImporter_NodeElement_Meta : public CX3DImporter_NodeElement
-{
-	/***********************************************/
-	/****************** Variables ******************/
-	/***********************************************/
-
-public:
-
-	std::string Name;///< Name of metadata object.
-	/// \var std::string Reference
-	/// If provided, it identifies the metadata standard or other specification that defines the name field. If the reference field is not provided or is
-	/// empty, the meaning of the name field is considered implicit to the characters in the string.
-	std::string Reference;
-
-	/***********************************************/
-	/****************** Functions ******************/
-	/***********************************************/
-
-private:
-
-	/// \fn CX3DImporter_NodeElement_Meta(const CX3DImporter_NodeElement_Meta& pNode)
-	/// Disabled copy constructor.
-	CX3DImporter_NodeElement_Meta(const CX3DImporter_NodeElement_Meta& pNode);
-
-	/// \fn CX3DImporter_NodeElement_Meta& operator=(const CX3DImporter_NodeElement_Meta& pNode)
-	/// Disabled assign operator.
-	CX3DImporter_NodeElement_Meta& operator=(const CX3DImporter_NodeElement_Meta& pNode);
-
-	/// \fn CX3DImporter_NodeElement_Meta()
-	/// Disabled default constructor.
-	CX3DImporter_NodeElement_Meta();
-
-public:
-
-	/// \fn CX3DImporter_NodeElement_Meta(const EType pType, CX3DImporter_NodeElement* pParent)
-	/// In constructor inheritor must set element type.
-	/// \param [in] pType - element type.
-	/// \param [in] pParent - pointer to parent node.
-	CX3DImporter_NodeElement_Meta(const EType pType, CX3DImporter_NodeElement* pParent)
-		: CX3DImporter_NodeElement(pType, pParent)
-	{}
-
-};// class CX3DImporter_NodeElement_Meta
-
-/// \struct CX3DImporter_NodeElement_MetaBoolean
-/// This struct describe metavalue of type boolean.
-struct CX3DImporter_NodeElement_MetaBoolean : public CX3DImporter_NodeElement_Meta
-{
-	std::vector<bool> Value;///< Stored value.
-
-	/// \fn CX3DImporter_NodeElement_MetaBoolean(CX3DImporter_NodeElement* pParent)
-	/// Constructor
-	/// \param [in] pParent - pointer to parent node.
-	CX3DImporter_NodeElement_MetaBoolean(CX3DImporter_NodeElement* pParent)
-		: CX3DImporter_NodeElement_Meta(ENET_MetaBoolean, pParent)
-	{}
-
-};// struct CX3DImporter_NodeElement_MetaBoolean
-
-/// \struct CX3DImporter_NodeElement_MetaDouble
-/// This struct describe metavalue of type double.
-struct CX3DImporter_NodeElement_MetaDouble : public CX3DImporter_NodeElement_Meta
-{
-	std::vector<double> Value;///< Stored value.
-
-	/// \fn CX3DImporter_NodeElement_MetaDouble(CX3DImporter_NodeElement* pParent)
-	/// Constructor
-	/// \param [in] pParent - pointer to parent node.
-	CX3DImporter_NodeElement_MetaDouble(CX3DImporter_NodeElement* pParent)
-		: CX3DImporter_NodeElement_Meta(ENET_MetaDouble, pParent)
-	{}
-
-};// struct CX3DImporter_NodeElement_MetaDouble
-
-/// \struct CX3DImporter_NodeElement_MetaFloat
-/// This struct describe metavalue of type float.
-struct CX3DImporter_NodeElement_MetaFloat : public CX3DImporter_NodeElement_Meta
-{
-	std::vector<float> Value;///< Stored value.
-
-	/// \fn CX3DImporter_NodeElement_MetaFloat(CX3DImporter_NodeElement* pParent)
-	/// Constructor
-	/// \param [in] pParent - pointer to parent node.
-	CX3DImporter_NodeElement_MetaFloat(CX3DImporter_NodeElement* pParent)
-		: CX3DImporter_NodeElement_Meta(ENET_MetaFloat, pParent)
-	{}
-
-};// struct CX3DImporter_NodeElement_MetaFloat
-
-/// \struct CX3DImporter_NodeElement_MetaInteger
-/// This struct describe metavalue of type integer.
-struct CX3DImporter_NodeElement_MetaInteger : public CX3DImporter_NodeElement_Meta
-{
-	std::vector<int32_t> Value;///< Stored value.
-
-	/// \fn CX3DImporter_NodeElement_MetaInteger(CX3DImporter_NodeElement* pParent)
-	/// Constructor
-	/// \param [in] pParent - pointer to parent node.
-	CX3DImporter_NodeElement_MetaInteger(CX3DImporter_NodeElement* pParent)
-		: CX3DImporter_NodeElement_Meta(ENET_MetaInteger, pParent)
-	{}
-
-};// struct CX3DImporter_NodeElement_MetaInteger
-
-/// \struct CX3DImporter_NodeElement_MetaSet
-/// This struct describe container for metaobjects.
-struct CX3DImporter_NodeElement_MetaSet : public CX3DImporter_NodeElement_Meta
-{
-	std::list<CX3DImporter_NodeElement_Meta> Value;///< Stored value.
-
-	/// \fn CX3DImporter_NodeElement_MetaSet(CX3DImporter_NodeElement* pParent)
-	/// Constructor
-	/// \param [in] pParent - pointer to parent node.
-	CX3DImporter_NodeElement_MetaSet(CX3DImporter_NodeElement* pParent)
-		: CX3DImporter_NodeElement_Meta(ENET_MetaSet, pParent)
-	{}
-
-};// struct CX3DImporter_NodeElement_MetaSet
-
-/// \struct CX3DImporter_NodeElement_MetaString
-/// This struct describe metavalue of type string.
-struct CX3DImporter_NodeElement_MetaString : public CX3DImporter_NodeElement_Meta
-{
-	std::list<std::string> Value;///< Stored value.
-
-	/// \fn CX3DImporter_NodeElement_MetaString(CX3DImporter_NodeElement* pParent)
-	/// Constructor
-	/// \param [in] pParent - pointer to parent node.
-	CX3DImporter_NodeElement_MetaString(CX3DImporter_NodeElement* pParent)
-		: CX3DImporter_NodeElement_Meta(ENET_MetaString, pParent)
-	{}
-
-};// struct CX3DImporter_NodeElement_MetaString
-
-/// \struct CX3DImporter_NodeElement_Color
-/// This struct hold <Color> value.
-struct CX3DImporter_NodeElement_Color : public CX3DImporter_NodeElement
-{
-	std::list<aiColor3D> Value;///< Stored value.
-
-	/// \fn CX3DImporter_NodeElement_Color(CX3DImporter_NodeElement* pParent)
-	/// Constructor
-	/// \param [in] pParent - pointer to parent node.
-	CX3DImporter_NodeElement_Color(CX3DImporter_NodeElement* pParent)
-		: CX3DImporter_NodeElement(ENET_Color, pParent)
-	{}
-
-};// struct CX3DImporter_NodeElement_Color
-
-/// \struct CX3DImporter_NodeElement_ColorRGBA
-/// This struct hold <ColorRGBA> value.
-struct CX3DImporter_NodeElement_ColorRGBA : public CX3DImporter_NodeElement
-{
-	std::list<aiColor4D> Value;///< Stored value.
-
-	/// \fn CX3DImporter_NodeElement_ColorRGBA(CX3DImporter_NodeElement* pParent)
-	/// Constructor
-	/// \param [in] pParent - pointer to parent node.
-	CX3DImporter_NodeElement_ColorRGBA(CX3DImporter_NodeElement* pParent)
-		: CX3DImporter_NodeElement(ENET_ColorRGBA, pParent)
-	{}
-
-};// struct CX3DImporter_NodeElement_ColorRGBA
-
-/// \struct CX3DImporter_NodeElement_Coordinate
-/// This struct hold <Coordinate> value.
-struct CX3DImporter_NodeElement_Coordinate : public CX3DImporter_NodeElement
-{
-	std::list<aiVector3D> Value;///< Stored value.
-
-	/// \fn CX3DImporter_NodeElement_Coordinate(CX3DImporter_NodeElement* pParent)
-	/// Constructor
-	/// \param [in] pParent - pointer to parent node.
-	CX3DImporter_NodeElement_Coordinate(CX3DImporter_NodeElement* pParent)
-		: CX3DImporter_NodeElement(ENET_Coordinate, pParent)
-	{}
-
-};// struct CX3DImporter_NodeElement_Coordinate
-
-/// \struct CX3DImporter_NodeElement_Normal
-/// This struct hold <Normal> value.
-struct CX3DImporter_NodeElement_Normal : public CX3DImporter_NodeElement
-{
-	std::list<aiVector3D> Value;///< Stored value.
-
-	/// \fn CX3DImporter_NodeElement_Normal(CX3DImporter_NodeElement* pParent)
-	/// Constructor
-	/// \param [in] pParent - pointer to parent node.
-	CX3DImporter_NodeElement_Normal(CX3DImporter_NodeElement* pParent)
-		: CX3DImporter_NodeElement(ENET_Normal, pParent)
-	{}
-
-};// struct CX3DImporter_NodeElement_Normal
-
-/// \struct CX3DImporter_NodeElement_TextureCoordinate
-/// This struct hold <TextureCoordinate> value.
-struct CX3DImporter_NodeElement_TextureCoordinate : public CX3DImporter_NodeElement
-{
-	std::list<aiVector2D> Value;///< Stored value.
-
-	/// \fn CX3DImporter_NodeElement_TextureCoordinate(CX3DImporter_NodeElement* pParent)
-	/// Constructor
-	/// \param [in] pParent - pointer to parent node.
-	CX3DImporter_NodeElement_TextureCoordinate(CX3DImporter_NodeElement* pParent)
-		: CX3DImporter_NodeElement(ENET_TextureCoordinate, pParent)
-	{}
-
-};// struct CX3DImporter_NodeElement_TextureCoordinate
-
-/// \class CX3DImporter_NodeElement_Geometry2D
-/// Two-dimensional figure.
-class CX3DImporter_NodeElement_Geometry2D : public CX3DImporter_NodeElement
-{
-	/***********************************************/
-	/****************** Variables ******************/
-	/***********************************************/
-
-public:
-
-	std::list<aiVector3D> Vertices;///< Vertices list.
-	size_t NumIndices;///< Number of indices in one face.
-	bool Solid;///< Flag: if true then render must use back-face culling, else render must draw both sides of object.
-
-	/***********************************************/
-	/****************** Functions ******************/
-	/***********************************************/
-
-private:
-
-	/// \fn CX3DImporter_NodeElement_Geometry2D(const CX3DImporter_NodeElement_Geometry2D& pNode)
-	/// Disabled copy constructor.
-	CX3DImporter_NodeElement_Geometry2D(const CX3DImporter_NodeElement_Geometry2D& pNode);
-
-	/// \fn CX3DImporter_NodeElement_Geometry2D& operator=(const CX3DImporter_NodeElement_Geometry2D& pNode)
-	/// Disabled assign operator.
-	CX3DImporter_NodeElement_Geometry2D& operator=(const CX3DImporter_NodeElement_Geometry2D& pNode);
-
-public:
-
-	/// \fn CX3DImporter_NodeElement_Geometry2D(const EType pType, CX3DImporter_NodeElement* pParent)
-	/// Constructor.
-	/// \param [in] pParent - pointer to parent node.
-	/// \param [in] pType - type of geometry object.
-	CX3DImporter_NodeElement_Geometry2D(const EType pType, CX3DImporter_NodeElement* pParent)
-		: CX3DImporter_NodeElement(pType, pParent), Solid(true)
-	{}
-
-};// class CX3DImporter_NodeElement_Geometry2D
-
-/// \class CX3DImporter_NodeElement_Geometry3D
-/// Three-dimensional body.
-class CX3DImporter_NodeElement_Geometry3D : public CX3DImporter_NodeElement {
-public:
-	std::list<aiVector3D> Vertices;  ///< Vertices list.
-	size_t                NumIndices;///< Number of indices in one face.
-	bool                  Solid;     ///< Flag: if true then render must use back-face culling, else render must draw both sides of object.
-
-	/// Constructor.
-	/// \param [in] pParent - pointer to parent node.
-	/// \param [in] pType - type of geometry object.
-	CX3DImporter_NodeElement_Geometry3D(const EType pType, CX3DImporter_NodeElement* pParent)
-	: CX3DImporter_NodeElement(pType, pParent)
-	, Vertices()
-	, NumIndices( 0 )
-	, Solid(true) {
-        // empty		
-	}
-
-private:
-	/// Disabled copy constructor.
-	CX3DImporter_NodeElement_Geometry3D(const CX3DImporter_NodeElement_Geometry3D& pNode);
-
-	/// Disabled assign operator.
-	CX3DImporter_NodeElement_Geometry3D& operator=(const CX3DImporter_NodeElement_Geometry3D& pNode);
-};// class CX3DImporter_NodeElement_Geometry3D
-
-/// \class CX3DImporter_NodeElement_ElevationGrid
-/// Uniform rectangular grid of varying height.
-class CX3DImporter_NodeElement_ElevationGrid : public CX3DImporter_NodeElement_Geometry3D
-{
-	/***********************************************/
-	/****************** Variables ******************/
-	/***********************************************/
-
-public:
-
-	bool NormalPerVertex;///< If true then normals are defined for every vertex, else for every face(line).
-	bool ColorPerVertex;///< If true then colors are defined for every vertex, else for every face(line).
-	/// \var CreaseAngle
-	/// If the angle between the geometric normals of two adjacent faces is less than the crease angle, normals shall be calculated so that the faces are
-	/// shaded smoothly across the edge; otherwise, normals shall be calculated so that a lighting discontinuity across the edge is produced.
-	float CreaseAngle;
-	std::vector<int32_t> CoordIdx;///< Coordinates list by faces. In X3D format: "-1" - delimiter for faces.
-
-	/***********************************************/
-	/****************** Functions ******************/
-	/***********************************************/
-
-private:
-
-	/// \fn CX3DImporter_NodeElement_ElevationGrid(const CX3DImporter_NodeElement_ElevationGrid& pNode)
-	/// Disabled copy constructor.
-	CX3DImporter_NodeElement_ElevationGrid(const CX3DImporter_NodeElement_ElevationGrid& pNode);
-
-	/// \fn CX3DImporter_NodeElement_ElevationGrid& operator=(const CX3DImporter_NodeElement_ElevationGrid& pNode)
-	/// Disabled assign operator.
-	CX3DImporter_NodeElement_ElevationGrid& operator=(const CX3DImporter_NodeElement_ElevationGrid& pNode);
-
-public:
-
-	/// \fn CX3DImporter_NodeElement_ElevationGrid(const EType pType, CX3DImporter_NodeElement* pParent)
-	/// Constructor.
-	/// \param [in] pParent - pointer to parent node.
-	/// \param [in] pType - type of geometry object.
-	CX3DImporter_NodeElement_ElevationGrid(const EType pType, CX3DImporter_NodeElement* pParent)
-		: CX3DImporter_NodeElement_Geometry3D(pType, pParent)
-	{}
-
-};// class CX3DImporter_NodeElement_IndexedSet
-
-/// \class CX3DImporter_NodeElement_IndexedSet
-/// Shape with indexed vertices.
-class CX3DImporter_NodeElement_IndexedSet : public CX3DImporter_NodeElement_Geometry3D
-{
-	/***********************************************/
-	/****************** Variables ******************/
-	/***********************************************/
-
-public:
-
-	/// \var CCW
-	/// The ccw field defines the ordering of the vertex coordinates of the geometry with respect to user-given or automatically generated normal vectors
-	/// used in the lighting model equations. If ccw is TRUE, the normals shall follow the right hand rule; the orientation of each normal with respect to
-	/// the vertices (taken in order) shall be such that the vertices appear to be oriented in a counterclockwise order when the vertices are viewed (in the
-	/// local coordinate system of the Shape) from the opposite direction as the normal. If ccw is FALSE, the normals shall be oriented in the opposite
-	/// direction. If normals are not generated but are supplied using a Normal node, and the orientation of the normals does not match the setting of the
-	/// ccw field, results are undefined.
-	bool CCW;
-	std::vector<int32_t> ColorIndex;///< Field to specify the polygonal faces by indexing into the <Color> or <ColorRGBA>.
-	bool ColorPerVertex;///< If true then colors are defined for every vertex, else for every face(line).
-	/// \var Convex
-	/// The convex field indicates whether all polygons in the shape are convex (TRUE). A polygon is convex if it is planar, does not intersect itself,
-	/// and all of the interior angles at its vertices are less than 180 degrees. Non planar and self intersecting polygons may produce undefined results
-	/// even if the convex field is FALSE.
-	bool Convex;
-	std::vector<int32_t> CoordIndex;///< Field to specify the polygonal faces by indexing into the <Coordinate>.
-	/// \var CreaseAngle
-	/// If the angle between the geometric normals of two adjacent faces is less than the crease angle, normals shall be calculated so that the faces are
-	/// shaded smoothly across the edge; otherwise, normals shall be calculated so that a lighting discontinuity across the edge is produced.
-	float CreaseAngle;
-	std::vector<int32_t> NormalIndex;///< Field to specify the polygonal faces by indexing into the <Normal>.
-	bool NormalPerVertex;///< If true then normals are defined for every vertex, else for every face(line).
-	std::vector<int32_t> TexCoordIndex;///< Field to specify the polygonal faces by indexing into the <TextureCoordinate>.
-
-	/***********************************************/
-	/****************** Functions ******************/
-	/***********************************************/
-
-private:
-
-	/// \fn CX3DImporter_NodeElement_IndexedSet(const CX3DImporter_NodeElement_IndexedSet& pNode)
-	/// Disabled copy constructor.
-	CX3DImporter_NodeElement_IndexedSet(const CX3DImporter_NodeElement_IndexedSet& pNode);
-
-	/// \fn CX3DImporter_NodeElement_IndexedSet& operator=(const CX3DImporter_NodeElement_IndexedSet& pNode)
-	/// Disabled assign operator.
-	CX3DImporter_NodeElement_IndexedSet& operator=(const CX3DImporter_NodeElement_IndexedSet& pNode);
-
-public:
-
-	/// \fn CX3DImporter_NodeElement_IndexedSet(const EType pType, CX3DImporter_NodeElement* pParent)
-	/// Constructor.
-	/// \param [in] pParent - pointer to parent node.
-	/// \param [in] pType - type of geometry object.
-	CX3DImporter_NodeElement_IndexedSet(const EType pType, CX3DImporter_NodeElement* pParent)
-		: CX3DImporter_NodeElement_Geometry3D(pType, pParent)
-	{}
-
-};// class CX3DImporter_NodeElement_IndexedSet
-
-/// \class CX3DImporter_NodeElement_Set
-/// Shape with set of vertices.
-class CX3DImporter_NodeElement_Set : public CX3DImporter_NodeElement_Geometry3D
-{
-	/***********************************************/
-	/****************** Variables ******************/
-	/***********************************************/
-
-public:
-
-	/// \var CCW
-	/// The ccw field defines the ordering of the vertex coordinates of the geometry with respect to user-given or automatically generated normal vectors
-	/// used in the lighting model equations. If ccw is TRUE, the normals shall follow the right hand rule; the orientation of each normal with respect to
-	/// the vertices (taken in order) shall be such that the vertices appear to be oriented in a counterclockwise order when the vertices are viewed (in the
-	/// local coordinate system of the Shape) from the opposite direction as the normal. If ccw is FALSE, the normals shall be oriented in the opposite
-	/// direction. If normals are not generated but are supplied using a Normal node, and the orientation of the normals does not match the setting of the
-	/// ccw field, results are undefined.
-	bool CCW;
-	bool ColorPerVertex;///< If true then colors are defined for every vertex, else for every face(line).
-	bool NormalPerVertex;///< If true then normals are defined for every vertex, else for every face(line).
-	std::vector<int32_t> CoordIndex;///< Field to specify the polygonal faces by indexing into the <Coordinate>.
-	std::vector<int32_t> NormalIndex;///< Field to specify the polygonal faces by indexing into the <Normal>.
-	std::vector<int32_t> TexCoordIndex;///< Field to specify the polygonal faces by indexing into the <TextureCoordinate>.
-	std::vector<int32_t> VertexCount;///< Field describes how many vertices are to be used in each polyline(polygon) from the <Coordinate> field.
-
-	/***********************************************/
-	/****************** Functions ******************/
-	/***********************************************/
-
-private:
-
-	/// \fn CX3DImporter_NodeElement_Set(const CX3DImporter_NodeElement_Set& pNode)
-	/// Disabled copy constructor.
-	CX3DImporter_NodeElement_Set(const CX3DImporter_NodeElement_Set& pNode);
-
-	/// \fn CX3DImporter_NodeElement_Set& operator=(const CX3DImporter_NodeElement_Set& pNode)
-	/// Disabled assign operator.
-	CX3DImporter_NodeElement_Set& operator=(const CX3DImporter_NodeElement_Set& pNode);
-
-public:
-
-	/// \fn CX3DImporter_NodeElement_Set(const EType pType, CX3DImporter_NodeElement* pParent)
-	/// Constructor.
-	/// \param [in] pParent - pointer to parent node.
-	/// \param [in] pType - type of geometry object.
-	CX3DImporter_NodeElement_Set(const EType pType, CX3DImporter_NodeElement* pParent)
-		: CX3DImporter_NodeElement_Geometry3D(pType, pParent)
-	{}
-
-};// class CX3DImporter_NodeElement_Set
-
-/// \struct CX3DImporter_NodeElement_Shape
-/// This struct hold <Shape> value.
-struct CX3DImporter_NodeElement_Shape : public CX3DImporter_NodeElement
-{
-	/// \fn CX3DImporter_NodeElement_Shape(CX3DImporter_NodeElement_Shape* pParent)
-	/// Constructor
-	/// \param [in] pParent - pointer to parent node.
-	CX3DImporter_NodeElement_Shape(CX3DImporter_NodeElement* pParent)
-		: CX3DImporter_NodeElement(ENET_Shape, pParent)
-	{}
-
-};// struct CX3DImporter_NodeElement_Shape
-
-/// \struct CX3DImporter_NodeElement_Appearance
-/// This struct hold <Appearance> value.
-struct CX3DImporter_NodeElement_Appearance : public CX3DImporter_NodeElement
-{
-	/// \fn CX3DImporter_NodeElement_Appearance(CX3DImporter_NodeElement_Appearance* pParent)
-	/// Constructor
-	/// \param [in] pParent - pointer to parent node.
-	CX3DImporter_NodeElement_Appearance(CX3DImporter_NodeElement* pParent)
-		: CX3DImporter_NodeElement(ENET_Appearance, pParent)
-	{}
-
-};// struct CX3DImporter_NodeElement_Appearance
-
-/// \class CX3DImporter_NodeElement_Material
-/// Material.
-class CX3DImporter_NodeElement_Material : public CX3DImporter_NodeElement {
-public:
-	float     AmbientIntensity;///< Specifies how much ambient light from light sources this surface shall reflect.
-	aiColor3D DiffuseColor;    ///< Reflects all X3D light sources depending on the angle of the surface with respect to the light source.
-	aiColor3D EmissiveColor;   ///< Models "glowing" objects. This can be useful for displaying pre-lit models.
-	float     Shininess;       ///< Lower shininess values produce soft glows, while higher values result in sharper, smaller highlights.
-	aiColor3D SpecularColor;   ///< The specularColor and shininess fields determine the specular highlights.
-	float     Transparency;    ///< Specifies how "clear" an object is, with 1.0 being completely transparent, and 0.0 completely opaque.
-
-	/// Constructor.
-	/// \param [in] pParent - pointer to parent node.
-	/// \param [in] pType - type of geometry object.
-	CX3DImporter_NodeElement_Material(CX3DImporter_NodeElement* pParent)
-	: CX3DImporter_NodeElement(ENET_Material, pParent)
-	, AmbientIntensity( 0.0f )
-	, DiffuseColor()
-	, EmissiveColor()
-	, Shininess( 0.0f )
-	, SpecularColor()
-	, Transparency( 1.0f ) {
-		// empty
-	}
-
-private:
-	/// Disabled copy constructor.
-	CX3DImporter_NodeElement_Material(const CX3DImporter_NodeElement_Material& pNode);
-
-	/// Disabled assign operator.
-	CX3DImporter_NodeElement_Material& operator=(const CX3DImporter_NodeElement_Material& pNode);
-};// class CX3DImporter_NodeElement_Material
-
-/// \struct CX3DImporter_NodeElement_ImageTexture
-/// This struct hold <ImageTexture> value.
-struct CX3DImporter_NodeElement_ImageTexture : public CX3DImporter_NodeElement
-{
-	/// \var RepeatS
-	/// RepeatS and RepeatT, that specify how the texture wraps in the S and T directions. If repeatS is TRUE (the default), the texture map is repeated
-	/// outside the [0.0, 1.0] texture coordinate range in the S direction so that it fills the shape. If repeatS is FALSE, the texture coordinates are
-	/// clamped in the S direction to lie within the [0.0, 1.0] range. The repeatT field is analogous to the repeatS field.
-	bool RepeatS;
-	bool RepeatT;///< See \ref RepeatS.
-	std::string URL;///< URL of the texture.
-	/// \fn CX3DImporter_NodeElement_ImageTexture(CX3DImporter_NodeElement_ImageTexture* pParent)
-	/// Constructor
-	/// \param [in] pParent - pointer to parent node.
-	CX3DImporter_NodeElement_ImageTexture(CX3DImporter_NodeElement* pParent)
-		: CX3DImporter_NodeElement(ENET_ImageTexture, pParent)
-	{}
-
-};// struct CX3DImporter_NodeElement_ImageTexture
-
-/// \struct CX3DImporter_NodeElement_TextureTransform
-/// This struct hold <TextureTransform> value.
-struct CX3DImporter_NodeElement_TextureTransform : public CX3DImporter_NodeElement
-{
-	aiVector2D Center;///< Specifies a translation offset in texture coordinate space about which the rotation and scale fields are applied.
-	float Rotation;///< Specifies a rotation in angle base units of the texture coordinates about the center point after the scale has been applied.
-	aiVector2D Scale;///< Specifies a scaling factor in S and T of the texture coordinates about the center point.
-	aiVector2D Translation;///<  Specifies a translation of the texture coordinates.
-
-	/// \fn CX3DImporter_NodeElement_TextureTransform(CX3DImporter_NodeElement_TextureTransform* pParent)
-	/// Constructor
-	/// \param [in] pParent - pointer to parent node.
-	CX3DImporter_NodeElement_TextureTransform(CX3DImporter_NodeElement* pParent)
-		: CX3DImporter_NodeElement(ENET_TextureTransform, pParent)
-	{}
-
-};// struct CX3DImporter_NodeElement_TextureTransform
-
-/// \struct CX3DImporter_NodeElement_Light
-/// This struct hold <TextureTransform> value.
-struct CX3DImporter_NodeElement_Light : public CX3DImporter_NodeElement
-{
-	float AmbientIntensity;///< Specifies the intensity of the ambient emission from the light.
-	aiColor3D Color;///< specifies the spectral colour properties of both the direct and ambient light emission as an RGB value.
-	aiVector3D Direction;///< Specifies the direction vector of the illumination emanating from the light source in the local coordinate system.
-	/// \var Global
-	/// Field that determines whether the light is global or scoped. Global lights illuminate all objects that fall within their volume of lighting influence.
-	/// Scoped lights only illuminate objects that are in the same transformation hierarchy as the light.
-	bool Global;
-	float Intensity;///< Specifies the brightness of the direct emission from the light.
-	/// \var Attenuation
-	/// PointLight node's illumination falls off with distance as specified by three attenuation coefficients. The attenuation factor
-	/// is: "1 / max(attenuation[0] + attenuation[1] * r + attenuation[2] * r2, 1)", where r is the distance from the light to the surface being illuminated.
-	aiVector3D Attenuation;
-	aiVector3D Location;///< Specifies a translation offset of the centre point of the light source from the light's local coordinate system origin.
-	float Radius;///< Specifies the radial extent of the solid angle and the maximum distance from location that may be illuminated by the light source.
-	float BeamWidth;///< Specifies an inner solid angle in which the light source emits light at uniform full intensity.
-	float CutOffAngle;///< The light source's emission intensity drops off from the inner solid angle (beamWidth) to the outer solid angle (cutOffAngle).
-
-	/// \fn CX3DImporter_NodeElement_Light(EType pLightType, CX3DImporter_NodeElement* pParent)
-	/// Constructor
-	/// \param [in] pParent - pointer to parent node.
-	/// \param [in] pLightType - type of the light source.
-	CX3DImporter_NodeElement_Light(EType pLightType, CX3DImporter_NodeElement* pParent)
-		: CX3DImporter_NodeElement(pLightType, pParent)
-	{}
-
-};// struct CX3DImporter_NodeElement_Light
-
-#endif // INCLUDED_AI_X3D_IMPORTER_NODE_H
diff --git a/Engine/lib/assimp/code/X3D/X3DImporter_Postprocess.cpp b/Engine/lib/assimp/code/X3D/X3DImporter_Postprocess.cpp
deleted file mode 100644
index 539563fcf..000000000
--- a/Engine/lib/assimp/code/X3D/X3DImporter_Postprocess.cpp
+++ /dev/null
@@ -1,827 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-/// \file   X3DImporter_Postprocess.cpp
-/// \brief  Convert built scenegraph and objects to Assimp scenegraph.
-/// \date   2015-2016
-/// \author smal.root@gmail.com
-
-#ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
-
-#include "X3DImporter.hpp"
-
-// Header files, Assimp.
-#include <assimp/ai_assert.h>
-#include <assimp/StandardShapes.h>
-#include <assimp/StringUtils.h>
-
-// Header files, stdlib.
-#include <algorithm>
-#include <iterator>
-#include <string>
-
-namespace Assimp
-{
-
-aiMatrix4x4 X3DImporter::PostprocessHelper_Matrix_GlobalToCurrent() const
-{
-    CX3DImporter_NodeElement* cur_node;
-    std::list<aiMatrix4x4> matr;
-    aiMatrix4x4 out_matr;
-
-	// starting walk from current element to root
-	cur_node = NodeElement_Cur;
-	if(cur_node != nullptr)
-	{
-		do
-		{
-			// if cur_node is group then store group transformation matrix in list.
-			if(cur_node->Type == CX3DImporter_NodeElement::ENET_Group) matr.push_back(((CX3DImporter_NodeElement_Group*)cur_node)->Transformation);
-
-			cur_node = cur_node->Parent;
-		} while(cur_node != nullptr);
-	}
-
-	// multiplicate all matrices in reverse order
-	for(std::list<aiMatrix4x4>::reverse_iterator rit = matr.rbegin(); rit != matr.rend(); ++rit) out_matr = out_matr * (*rit);
-
-	return out_matr;
-}
-
-void X3DImporter::PostprocessHelper_CollectMetadata(const CX3DImporter_NodeElement& pNodeElement, std::list<CX3DImporter_NodeElement*>& pList) const
-{
-	// walk through childs and find for metadata.
-	for(std::list<CX3DImporter_NodeElement*>::const_iterator el_it = pNodeElement.Child.begin(); el_it != pNodeElement.Child.end(); ++el_it)
-	{
-		if(((*el_it)->Type == CX3DImporter_NodeElement::ENET_MetaBoolean) || ((*el_it)->Type == CX3DImporter_NodeElement::ENET_MetaDouble) ||
-			((*el_it)->Type == CX3DImporter_NodeElement::ENET_MetaFloat) || ((*el_it)->Type == CX3DImporter_NodeElement::ENET_MetaInteger) ||
-			((*el_it)->Type == CX3DImporter_NodeElement::ENET_MetaString))
-		{
-			pList.push_back(*el_it);
-		}
-		else if((*el_it)->Type == CX3DImporter_NodeElement::ENET_MetaSet)
-		{
-			PostprocessHelper_CollectMetadata(**el_it, pList);
-		}
-	}// for(std::list<CX3DImporter_NodeElement*>::const_iterator el_it = pNodeElement.Child.begin(); el_it != pNodeElement.Child.end(); el_it++)
-}
-
-bool X3DImporter::PostprocessHelper_ElementIsMetadata(const CX3DImporter_NodeElement::EType pType) const
-{
-	if((pType == CX3DImporter_NodeElement::ENET_MetaBoolean) || (pType == CX3DImporter_NodeElement::ENET_MetaDouble) ||
-		(pType == CX3DImporter_NodeElement::ENET_MetaFloat) || (pType == CX3DImporter_NodeElement::ENET_MetaInteger) ||
-		(pType == CX3DImporter_NodeElement::ENET_MetaString) || (pType == CX3DImporter_NodeElement::ENET_MetaSet))
-	{
-		return true;
-	}
-	else
-	{
-		return false;
-	}
-}
-
-bool X3DImporter::PostprocessHelper_ElementIsMesh(const CX3DImporter_NodeElement::EType pType) const
-{
-	if((pType == CX3DImporter_NodeElement::ENET_Arc2D) || (pType == CX3DImporter_NodeElement::ENET_ArcClose2D) ||
-		(pType == CX3DImporter_NodeElement::ENET_Box) || (pType == CX3DImporter_NodeElement::ENET_Circle2D) ||
-		(pType == CX3DImporter_NodeElement::ENET_Cone) || (pType == CX3DImporter_NodeElement::ENET_Cylinder) ||
-		(pType == CX3DImporter_NodeElement::ENET_Disk2D) || (pType == CX3DImporter_NodeElement::ENET_ElevationGrid) ||
-		(pType == CX3DImporter_NodeElement::ENET_Extrusion) || (pType == CX3DImporter_NodeElement::ENET_IndexedFaceSet) ||
-		(pType == CX3DImporter_NodeElement::ENET_IndexedLineSet) || (pType == CX3DImporter_NodeElement::ENET_IndexedTriangleFanSet) ||
-		(pType == CX3DImporter_NodeElement::ENET_IndexedTriangleSet) || (pType == CX3DImporter_NodeElement::ENET_IndexedTriangleStripSet) ||
-		(pType == CX3DImporter_NodeElement::ENET_PointSet) || (pType == CX3DImporter_NodeElement::ENET_LineSet) ||
-		(pType == CX3DImporter_NodeElement::ENET_Polyline2D) || (pType == CX3DImporter_NodeElement::ENET_Polypoint2D) ||
-		(pType == CX3DImporter_NodeElement::ENET_Rectangle2D) || (pType == CX3DImporter_NodeElement::ENET_Sphere) ||
-		(pType == CX3DImporter_NodeElement::ENET_TriangleFanSet) || (pType == CX3DImporter_NodeElement::ENET_TriangleSet) ||
-		(pType == CX3DImporter_NodeElement::ENET_TriangleSet2D) || (pType == CX3DImporter_NodeElement::ENET_TriangleStripSet))
-	{
-		return true;
-	}
-	else
-	{
-		return false;
-	}
-}
-
-void X3DImporter::Postprocess_BuildLight(const CX3DImporter_NodeElement& pNodeElement, std::list<aiLight*>& pSceneLightList) const
-{
-    const CX3DImporter_NodeElement_Light& ne = *( ( CX3DImporter_NodeElement_Light* ) &pNodeElement );
-    aiMatrix4x4 transform_matr = PostprocessHelper_Matrix_GlobalToCurrent();
-    aiLight* new_light = new aiLight;
-
-	new_light->mName = ne.ID;
-	new_light->mColorAmbient = ne.Color * ne.AmbientIntensity;
-	new_light->mColorDiffuse = ne.Color * ne.Intensity;
-	new_light->mColorSpecular = ne.Color * ne.Intensity;
-	switch(pNodeElement.Type)
-	{
-		case CX3DImporter_NodeElement::ENET_DirectionalLight:
-			new_light->mType = aiLightSource_DIRECTIONAL;
-			new_light->mDirection = ne.Direction, new_light->mDirection *= transform_matr;
-
-			break;
-		case CX3DImporter_NodeElement::ENET_PointLight:
-			new_light->mType = aiLightSource_POINT;
-			new_light->mPosition = ne.Location, new_light->mPosition *= transform_matr;
-			new_light->mAttenuationConstant = ne.Attenuation.x;
-			new_light->mAttenuationLinear = ne.Attenuation.y;
-			new_light->mAttenuationQuadratic = ne.Attenuation.z;
-
-			break;
-		case CX3DImporter_NodeElement::ENET_SpotLight:
-			new_light->mType = aiLightSource_SPOT;
-			new_light->mPosition = ne.Location, new_light->mPosition *= transform_matr;
-			new_light->mDirection = ne.Direction, new_light->mDirection *= transform_matr;
-			new_light->mAttenuationConstant = ne.Attenuation.x;
-			new_light->mAttenuationLinear = ne.Attenuation.y;
-			new_light->mAttenuationQuadratic = ne.Attenuation.z;
-			new_light->mAngleInnerCone = ne.BeamWidth;
-			new_light->mAngleOuterCone = ne.CutOffAngle;
-
-			break;
-		default:
-			throw DeadlyImportError("Postprocess_BuildLight. Unknown type of light: " + to_string(pNodeElement.Type) + ".");
-	}
-
-	pSceneLightList.push_back(new_light);
-}
-
-void X3DImporter::Postprocess_BuildMaterial(const CX3DImporter_NodeElement& pNodeElement, aiMaterial** pMaterial) const
-{
-	// check argument
-	if(pMaterial == nullptr) throw DeadlyImportError("Postprocess_BuildMaterial. pMaterial is nullptr.");
-	if(*pMaterial != nullptr) throw DeadlyImportError("Postprocess_BuildMaterial. *pMaterial must be nullptr.");
-
-	*pMaterial = new aiMaterial;
-	aiMaterial& taimat = **pMaterial;// creating alias for convenience.
-
-	// at this point pNodeElement point to <Appearance> node. Walk through childs and add all stored data.
-	for(std::list<CX3DImporter_NodeElement*>::const_iterator el_it = pNodeElement.Child.begin(); el_it != pNodeElement.Child.end(); ++el_it)
-	{
-		if((*el_it)->Type == CX3DImporter_NodeElement::ENET_Material)
-		{
-			aiColor3D tcol3;
-			float tvalf;
-			CX3DImporter_NodeElement_Material& tnemat = *((CX3DImporter_NodeElement_Material*)*el_it);
-
-			tcol3.r = tnemat.AmbientIntensity, tcol3.g = tnemat.AmbientIntensity, tcol3.b = tnemat.AmbientIntensity;
-			taimat.AddProperty(&tcol3, 1, AI_MATKEY_COLOR_AMBIENT);
-			taimat.AddProperty(&tnemat.DiffuseColor, 1, AI_MATKEY_COLOR_DIFFUSE);
-			taimat.AddProperty(&tnemat.EmissiveColor, 1, AI_MATKEY_COLOR_EMISSIVE);
-			taimat.AddProperty(&tnemat.SpecularColor, 1, AI_MATKEY_COLOR_SPECULAR);
-			tvalf = 1;
-			taimat.AddProperty(&tvalf, 1, AI_MATKEY_SHININESS_STRENGTH);
-			taimat.AddProperty(&tnemat.Shininess, 1, AI_MATKEY_SHININESS);
-			tvalf = 1.0f - tnemat.Transparency;
-			taimat.AddProperty(&tvalf, 1, AI_MATKEY_OPACITY);
-		}// if((*el_it)->Type == CX3DImporter_NodeElement::ENET_Material)
-		else if((*el_it)->Type == CX3DImporter_NodeElement::ENET_ImageTexture)
-		{
-			CX3DImporter_NodeElement_ImageTexture& tnetex = *((CX3DImporter_NodeElement_ImageTexture*)*el_it);
-			aiString url_str(tnetex.URL.c_str());
-			int mode = aiTextureOp_Multiply;
-
-			taimat.AddProperty(&url_str, AI_MATKEY_TEXTURE_DIFFUSE(0));
-			taimat.AddProperty(&tnetex.RepeatS, 1, AI_MATKEY_MAPPINGMODE_U_DIFFUSE(0));
-			taimat.AddProperty(&tnetex.RepeatT, 1, AI_MATKEY_MAPPINGMODE_V_DIFFUSE(0));
-			taimat.AddProperty(&mode, 1, AI_MATKEY_TEXOP_DIFFUSE(0));
-		}// else if((*el_it)->Type == CX3DImporter_NodeElement::ENET_ImageTexture)
-		else if((*el_it)->Type == CX3DImporter_NodeElement::ENET_TextureTransform)
-		{
-			aiUVTransform trans;
-			CX3DImporter_NodeElement_TextureTransform& tnetextr = *((CX3DImporter_NodeElement_TextureTransform*)*el_it);
-
-			trans.mTranslation = tnetextr.Translation - tnetextr.Center;
-			trans.mScaling = tnetextr.Scale;
-			trans.mRotation = tnetextr.Rotation;
-			taimat.AddProperty(&trans, 1, AI_MATKEY_UVTRANSFORM_DIFFUSE(0));
-		}// else if((*el_it)->Type == CX3DImporter_NodeElement::ENET_TextureTransform)
-	}// for(std::list<CX3DImporter_NodeElement*>::const_iterator el_it = pNodeElement.Child.begin(); el_it != pNodeElement.Child.end(); el_it++)
-}
-
-void X3DImporter::Postprocess_BuildMesh(const CX3DImporter_NodeElement& pNodeElement, aiMesh** pMesh) const
-{
-	// check argument
-	if(pMesh == nullptr) throw DeadlyImportError("Postprocess_BuildMesh. pMesh is nullptr.");
-	if(*pMesh != nullptr) throw DeadlyImportError("Postprocess_BuildMesh. *pMesh must be nullptr.");
-
-	/************************************************************************************************************************************/
-	/************************************************************ Geometry2D ************************************************************/
-	/************************************************************************************************************************************/
-	if((pNodeElement.Type == CX3DImporter_NodeElement::ENET_Arc2D) || (pNodeElement.Type == CX3DImporter_NodeElement::ENET_ArcClose2D) ||
-		(pNodeElement.Type == CX3DImporter_NodeElement::ENET_Circle2D) || (pNodeElement.Type == CX3DImporter_NodeElement::ENET_Disk2D) ||
-		(pNodeElement.Type == CX3DImporter_NodeElement::ENET_Polyline2D) || (pNodeElement.Type == CX3DImporter_NodeElement::ENET_Polypoint2D) ||
-		(pNodeElement.Type == CX3DImporter_NodeElement::ENET_Rectangle2D) || (pNodeElement.Type == CX3DImporter_NodeElement::ENET_TriangleSet2D))
-	{
-		CX3DImporter_NodeElement_Geometry2D& tnemesh = *((CX3DImporter_NodeElement_Geometry2D*)&pNodeElement);// create alias for convenience
-		std::vector<aiVector3D> tarr;
-
-		tarr.reserve(tnemesh.Vertices.size());
-		for(std::list<aiVector3D>::iterator it = tnemesh.Vertices.begin(); it != tnemesh.Vertices.end(); ++it) tarr.push_back(*it);
-		*pMesh = StandardShapes::MakeMesh(tarr, static_cast<unsigned int>(tnemesh.NumIndices));// create mesh from vertices using Assimp help.
-
-		return;// mesh is build, nothing to do anymore.
-	}
-	/************************************************************************************************************************************/
-	/************************************************************ Geometry3D ************************************************************/
-	/************************************************************************************************************************************/
-	//
-	// Predefined figures
-	//
-	if((pNodeElement.Type == CX3DImporter_NodeElement::ENET_Box) || (pNodeElement.Type == CX3DImporter_NodeElement::ENET_Cone) ||
-		(pNodeElement.Type == CX3DImporter_NodeElement::ENET_Cylinder) || (pNodeElement.Type == CX3DImporter_NodeElement::ENET_Sphere))
-	{
-		CX3DImporter_NodeElement_Geometry3D& tnemesh = *((CX3DImporter_NodeElement_Geometry3D*)&pNodeElement);// create alias for convenience
-		std::vector<aiVector3D> tarr;
-
-		tarr.reserve(tnemesh.Vertices.size());
-		for(std::list<aiVector3D>::iterator it = tnemesh.Vertices.begin(); it != tnemesh.Vertices.end(); ++it) tarr.push_back(*it);
-
-		*pMesh = StandardShapes::MakeMesh(tarr, static_cast<unsigned int>(tnemesh.NumIndices));// create mesh from vertices using Assimp help.
-
-		return;// mesh is build, nothing to do anymore.
-	}
-	//
-	// Parametric figures
-	//
-	if(pNodeElement.Type == CX3DImporter_NodeElement::ENET_ElevationGrid)
-	{
-		CX3DImporter_NodeElement_ElevationGrid& tnemesh = *((CX3DImporter_NodeElement_ElevationGrid*)&pNodeElement);// create alias for convenience
-
-		// at first create mesh from existing vertices.
-		*pMesh = GeometryHelper_MakeMesh(tnemesh.CoordIdx, tnemesh.Vertices);
-		// copy additional information from children
-		for(std::list<CX3DImporter_NodeElement*>::iterator ch_it = tnemesh.Child.begin(); ch_it != tnemesh.Child.end(); ++ch_it)
-		{
-			if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Color)
-				MeshGeometry_AddColor(**pMesh, ((CX3DImporter_NodeElement_Color*)*ch_it)->Value, tnemesh.ColorPerVertex);
-			else if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_ColorRGBA)
-				MeshGeometry_AddColor(**pMesh, ((CX3DImporter_NodeElement_ColorRGBA*)*ch_it)->Value, tnemesh.ColorPerVertex);
-			else if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Normal)
-				MeshGeometry_AddNormal(**pMesh,  ((CX3DImporter_NodeElement_Normal*)*ch_it)->Value, tnemesh.NormalPerVertex);
-			else if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_TextureCoordinate)
-				MeshGeometry_AddTexCoord(**pMesh, ((CX3DImporter_NodeElement_TextureCoordinate*)*ch_it)->Value);
-			else
-				throw DeadlyImportError("Postprocess_BuildMesh. Unknown child of ElevationGrid: " + to_string((*ch_it)->Type) + ".");
-		}// for(std::list<CX3DImporter_NodeElement*>::iterator ch_it = tnemesh.Child.begin(); ch_it != tnemesh.Child.end(); ++ch_it)
-
-		return;// mesh is build, nothing to do anymore.
-	}// if(pNodeElement.Type == CX3DImporter_NodeElement::ENET_ElevationGrid)
-	//
-	// Indexed primitives sets
-	//
-	if(pNodeElement.Type == CX3DImporter_NodeElement::ENET_IndexedFaceSet)
-	{
-		CX3DImporter_NodeElement_IndexedSet& tnemesh = *((CX3DImporter_NodeElement_IndexedSet*)&pNodeElement);// create alias for convenience
-
-		// at first search for <Coordinate> node and create mesh.
-		for(std::list<CX3DImporter_NodeElement*>::iterator ch_it = tnemesh.Child.begin(); ch_it != tnemesh.Child.end(); ++ch_it)
-		{
-			if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Coordinate)
-			{
-				*pMesh = GeometryHelper_MakeMesh(tnemesh.CoordIndex, ((CX3DImporter_NodeElement_Coordinate*)*ch_it)->Value);
-			}
-		}
-
-		// copy additional information from children
-		for(std::list<CX3DImporter_NodeElement*>::iterator ch_it = tnemesh.Child.begin(); ch_it != tnemesh.Child.end(); ++ch_it)
-		{
-			if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Color)
-				MeshGeometry_AddColor(**pMesh, tnemesh.CoordIndex, tnemesh.ColorIndex, ((CX3DImporter_NodeElement_Color*)*ch_it)->Value, tnemesh.ColorPerVertex);
-			else if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_ColorRGBA)
-				MeshGeometry_AddColor(**pMesh, tnemesh.CoordIndex, tnemesh.ColorIndex, ((CX3DImporter_NodeElement_ColorRGBA*)*ch_it)->Value,
-										tnemesh.ColorPerVertex);
-			else if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Coordinate)
-				{} // skip because already read when mesh created.
-			else if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Normal)
-				MeshGeometry_AddNormal(**pMesh, tnemesh.CoordIndex, tnemesh.NormalIndex, ((CX3DImporter_NodeElement_Normal*)*ch_it)->Value,
-										tnemesh.NormalPerVertex);
-			else if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_TextureCoordinate)
-				MeshGeometry_AddTexCoord(**pMesh, tnemesh.CoordIndex, tnemesh.TexCoordIndex, ((CX3DImporter_NodeElement_TextureCoordinate*)*ch_it)->Value);
-			else
-				throw DeadlyImportError("Postprocess_BuildMesh. Unknown child of IndexedFaceSet: " + to_string((*ch_it)->Type) + ".");
-		}// for(std::list<CX3DImporter_NodeElement*>::iterator ch_it = tnemesh.Child.begin(); ch_it != tnemesh.Child.end(); ++ch_it)
-
-		return;// mesh is build, nothing to do anymore.
-	}// if(pNodeElement.Type == CX3DImporter_NodeElement::ENET_IndexedFaceSet)
-
-	if(pNodeElement.Type == CX3DImporter_NodeElement::ENET_IndexedLineSet)
-	{
-		CX3DImporter_NodeElement_IndexedSet& tnemesh = *((CX3DImporter_NodeElement_IndexedSet*)&pNodeElement);// create alias for convenience
-
-		// at first search for <Coordinate> node and create mesh.
-		for(std::list<CX3DImporter_NodeElement*>::iterator ch_it = tnemesh.Child.begin(); ch_it != tnemesh.Child.end(); ++ch_it)
-		{
-			if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Coordinate)
-			{
-				*pMesh = GeometryHelper_MakeMesh(tnemesh.CoordIndex, ((CX3DImporter_NodeElement_Coordinate*)*ch_it)->Value);
-			}
-		}
-
-		// copy additional information from children
-		for(std::list<CX3DImporter_NodeElement*>::iterator ch_it = tnemesh.Child.begin(); ch_it != tnemesh.Child.end(); ++ch_it)
-		{
-			ai_assert(*pMesh);
-			if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Color)
-				MeshGeometry_AddColor(**pMesh, tnemesh.CoordIndex, tnemesh.ColorIndex, ((CX3DImporter_NodeElement_Color*)*ch_it)->Value, tnemesh.ColorPerVertex);
-			else if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_ColorRGBA)
-				MeshGeometry_AddColor(**pMesh, tnemesh.CoordIndex, tnemesh.ColorIndex, ((CX3DImporter_NodeElement_ColorRGBA*)*ch_it)->Value,
-										tnemesh.ColorPerVertex);
-			else if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Coordinate)
-				{} // skip because already read when mesh created.
-			else
-				throw DeadlyImportError("Postprocess_BuildMesh. Unknown child of IndexedLineSet: " + to_string((*ch_it)->Type) + ".");
-		}// for(std::list<CX3DImporter_NodeElement*>::iterator ch_it = tnemesh.Child.begin(); ch_it != tnemesh.Child.end(); ++ch_it)
-
-		return;// mesh is build, nothing to do anymore.
-	}// if(pNodeElement.Type == CX3DImporter_NodeElement::ENET_IndexedLineSet)
-
-	if((pNodeElement.Type == CX3DImporter_NodeElement::ENET_IndexedTriangleSet) ||
-		(pNodeElement.Type == CX3DImporter_NodeElement::ENET_IndexedTriangleFanSet) ||
-		(pNodeElement.Type == CX3DImporter_NodeElement::ENET_IndexedTriangleStripSet))
-	{
-		CX3DImporter_NodeElement_IndexedSet& tnemesh = *((CX3DImporter_NodeElement_IndexedSet*)&pNodeElement);// create alias for convenience
-
-		// at first search for <Coordinate> node and create mesh.
-		for(std::list<CX3DImporter_NodeElement*>::iterator ch_it = tnemesh.Child.begin(); ch_it != tnemesh.Child.end(); ++ch_it)
-		{
-			if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Coordinate)
-			{
-				*pMesh = GeometryHelper_MakeMesh(tnemesh.CoordIndex, ((CX3DImporter_NodeElement_Coordinate*)*ch_it)->Value);
-			}
-		}
-
-		// copy additional information from children
-		for(std::list<CX3DImporter_NodeElement*>::iterator ch_it = tnemesh.Child.begin(); ch_it != tnemesh.Child.end(); ++ch_it)
-		{
-			ai_assert(*pMesh);
-			if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Color)
-				MeshGeometry_AddColor(**pMesh, tnemesh.CoordIndex, tnemesh.ColorIndex, ((CX3DImporter_NodeElement_Color*)*ch_it)->Value, tnemesh.ColorPerVertex);
-			else if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_ColorRGBA)
-				MeshGeometry_AddColor(**pMesh, tnemesh.CoordIndex, tnemesh.ColorIndex, ((CX3DImporter_NodeElement_ColorRGBA*)*ch_it)->Value,
-										tnemesh.ColorPerVertex);
-			else if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Coordinate)
-				{} // skip because already read when mesh created.
-			else if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Normal)
-				MeshGeometry_AddNormal(**pMesh, tnemesh.CoordIndex, tnemesh.NormalIndex, ((CX3DImporter_NodeElement_Normal*)*ch_it)->Value,
-										tnemesh.NormalPerVertex);
-			else if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_TextureCoordinate)
-				MeshGeometry_AddTexCoord(**pMesh, tnemesh.CoordIndex, tnemesh.TexCoordIndex, ((CX3DImporter_NodeElement_TextureCoordinate*)*ch_it)->Value);
-			else
-				throw DeadlyImportError("Postprocess_BuildMesh. Unknown child of IndexedTriangleSet or IndexedTriangleFanSet, or \
-																	IndexedTriangleStripSet: " + to_string((*ch_it)->Type) + ".");
-		}// for(std::list<CX3DImporter_NodeElement*>::iterator ch_it = tnemesh.Child.begin(); ch_it != tnemesh.Child.end(); ++ch_it)
-
-		return;// mesh is build, nothing to do anymore.
-	}// if((pNodeElement.Type == CX3DImporter_NodeElement::ENET_IndexedTriangleFanSet) || (pNodeElement.Type == CX3DImporter_NodeElement::ENET_IndexedTriangleStripSet))
-
-	if(pNodeElement.Type == CX3DImporter_NodeElement::ENET_Extrusion)
-	{
-		CX3DImporter_NodeElement_IndexedSet& tnemesh = *((CX3DImporter_NodeElement_IndexedSet*)&pNodeElement);// create alias for convenience
-
-		*pMesh = GeometryHelper_MakeMesh(tnemesh.CoordIndex, tnemesh.Vertices);
-
-		return;// mesh is build, nothing to do anymore.
-	}// if(pNodeElement.Type == CX3DImporter_NodeElement::ENET_Extrusion)
-
-	//
-	// Primitives sets
-	//
-	if(pNodeElement.Type == CX3DImporter_NodeElement::ENET_PointSet)
-	{
-		CX3DImporter_NodeElement_Set& tnemesh = *((CX3DImporter_NodeElement_Set*)&pNodeElement);// create alias for convenience
-
-		// at first search for <Coordinate> node and create mesh.
-		for(std::list<CX3DImporter_NodeElement*>::iterator ch_it = tnemesh.Child.begin(); ch_it != tnemesh.Child.end(); ++ch_it)
-		{
-			if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Coordinate)
-			{
-				std::vector<aiVector3D> vec_copy;
-
-				vec_copy.reserve(((CX3DImporter_NodeElement_Coordinate*)*ch_it)->Value.size());
-				for(std::list<aiVector3D>::const_iterator it = ((CX3DImporter_NodeElement_Coordinate*)*ch_it)->Value.begin();
-					it != ((CX3DImporter_NodeElement_Coordinate*)*ch_it)->Value.end(); ++it)
-				{
-					vec_copy.push_back(*it);
-				}
-
-				*pMesh = StandardShapes::MakeMesh(vec_copy, 1);
-			}
-		}
-
-		// copy additional information from children
-		for(std::list<CX3DImporter_NodeElement*>::iterator ch_it = tnemesh.Child.begin(); ch_it != tnemesh.Child.end(); ++ch_it)
-		{
-			ai_assert(*pMesh);
-			if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Color)
-				MeshGeometry_AddColor(**pMesh, ((CX3DImporter_NodeElement_Color*)*ch_it)->Value, true);
-			else if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_ColorRGBA)
-				MeshGeometry_AddColor(**pMesh, ((CX3DImporter_NodeElement_ColorRGBA*)*ch_it)->Value, true);
-			else if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Coordinate)
-				{} // skip because already read when mesh created.
-			else
-				throw DeadlyImportError("Postprocess_BuildMesh. Unknown child of PointSet: " + to_string((*ch_it)->Type) + ".");
-		}// for(std::list<CX3DImporter_NodeElement*>::iterator ch_it = tnemesh.Child.begin(); ch_it != tnemesh.Child.end(); ++ch_it)
-
-		return;// mesh is build, nothing to do anymore.
-	}// if(pNodeElement.Type == CX3DImporter_NodeElement::ENET_PointSet)
-
-	if(pNodeElement.Type == CX3DImporter_NodeElement::ENET_LineSet)
-	{
-		CX3DImporter_NodeElement_Set& tnemesh = *((CX3DImporter_NodeElement_Set*)&pNodeElement);// create alias for convenience
-
-		// at first search for <Coordinate> node and create mesh.
-		for(std::list<CX3DImporter_NodeElement*>::iterator ch_it = tnemesh.Child.begin(); ch_it != tnemesh.Child.end(); ++ch_it)
-		{
-			if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Coordinate)
-			{
-				*pMesh = GeometryHelper_MakeMesh(tnemesh.CoordIndex, ((CX3DImporter_NodeElement_Coordinate*)*ch_it)->Value);
-			}
-		}
-
-		// copy additional information from children
-		for(std::list<CX3DImporter_NodeElement*>::iterator ch_it = tnemesh.Child.begin(); ch_it != tnemesh.Child.end(); ++ch_it)
-		{
-			ai_assert(*pMesh);
-			if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Color)
-				MeshGeometry_AddColor(**pMesh, ((CX3DImporter_NodeElement_Color*)*ch_it)->Value, true);
-			else if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_ColorRGBA)
-				MeshGeometry_AddColor(**pMesh, ((CX3DImporter_NodeElement_ColorRGBA*)*ch_it)->Value, true);
-			else if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Coordinate)
-				{} // skip because already read when mesh created.
-			else
-				throw DeadlyImportError("Postprocess_BuildMesh. Unknown child of LineSet: " + to_string((*ch_it)->Type) + ".");
-		}// for(std::list<CX3DImporter_NodeElement*>::iterator ch_it = tnemesh.Child.begin(); ch_it != tnemesh.Child.end(); ++ch_it)
-
-		return;// mesh is build, nothing to do anymore.
-	}// if(pNodeElement.Type == CX3DImporter_NodeElement::ENET_LineSet)
-
-	if(pNodeElement.Type == CX3DImporter_NodeElement::ENET_TriangleFanSet)
-	{
-		CX3DImporter_NodeElement_Set& tnemesh = *((CX3DImporter_NodeElement_Set*)&pNodeElement);// create alias for convenience
-
-		// at first search for <Coordinate> node and create mesh.
-		for(std::list<CX3DImporter_NodeElement*>::iterator ch_it = tnemesh.Child.begin(); ch_it != tnemesh.Child.end(); ++ch_it)
-		{
-			if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Coordinate)
-			{
-				*pMesh = GeometryHelper_MakeMesh(tnemesh.CoordIndex, ((CX3DImporter_NodeElement_Coordinate*)*ch_it)->Value);
-			}
-		}
-
-		// copy additional information from children
-		for(std::list<CX3DImporter_NodeElement*>::iterator ch_it = tnemesh.Child.begin(); ch_it != tnemesh.Child.end(); ++ch_it)
-		{
-			if ( nullptr == *pMesh ) {
-				break;
-			}
-			if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Color)
-				MeshGeometry_AddColor(**pMesh, ((CX3DImporter_NodeElement_Color*)*ch_it)->Value,tnemesh.ColorPerVertex);
-			else if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_ColorRGBA)
-				MeshGeometry_AddColor(**pMesh, ((CX3DImporter_NodeElement_ColorRGBA*)*ch_it)->Value, tnemesh.ColorPerVertex);
-			else if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Coordinate)
-				{} // skip because already read when mesh created.
-			else if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Normal)
-				MeshGeometry_AddNormal(**pMesh, tnemesh.CoordIndex, tnemesh.NormalIndex, ((CX3DImporter_NodeElement_Normal*)*ch_it)->Value,
-										tnemesh.NormalPerVertex);
-			else if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_TextureCoordinate)
-				MeshGeometry_AddTexCoord(**pMesh, tnemesh.CoordIndex, tnemesh.TexCoordIndex, ((CX3DImporter_NodeElement_TextureCoordinate*)*ch_it)->Value);
-			else
-				throw DeadlyImportError("Postprocess_BuildMesh. Unknown child of TrianlgeFanSet: " + to_string((*ch_it)->Type) + ".");
-		}// for(std::list<CX3DImporter_NodeElement*>::iterator ch_it = tnemesh.Child.begin(); ch_it != tnemesh.Child.end(); ++ch_it)
-
-		return;// mesh is build, nothing to do anymore.
-	}// if(pNodeElement.Type == CX3DImporter_NodeElement::ENET_TriangleFanSet)
-
-	if(pNodeElement.Type == CX3DImporter_NodeElement::ENET_TriangleSet)
-	{
-		CX3DImporter_NodeElement_Set& tnemesh = *((CX3DImporter_NodeElement_Set*)&pNodeElement);// create alias for convenience
-
-		// at first search for <Coordinate> node and create mesh.
-		for(std::list<CX3DImporter_NodeElement*>::iterator ch_it = tnemesh.Child.begin(); ch_it != tnemesh.Child.end(); ++ch_it)
-		{
-			if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Coordinate)
-			{
-				std::vector<aiVector3D> vec_copy;
-
-				vec_copy.reserve(((CX3DImporter_NodeElement_Coordinate*)*ch_it)->Value.size());
-				for(std::list<aiVector3D>::const_iterator it = ((CX3DImporter_NodeElement_Coordinate*)*ch_it)->Value.begin();
-					it != ((CX3DImporter_NodeElement_Coordinate*)*ch_it)->Value.end(); ++it)
-				{
-					vec_copy.push_back(*it);
-				}
-
-				*pMesh = StandardShapes::MakeMesh(vec_copy, 3);
-			}
-		}
-
-		// copy additional information from children
-		for(std::list<CX3DImporter_NodeElement*>::iterator ch_it = tnemesh.Child.begin(); ch_it != tnemesh.Child.end(); ++ch_it)
-		{
-			ai_assert(*pMesh);
-			if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Color)
-				MeshGeometry_AddColor(**pMesh, ((CX3DImporter_NodeElement_Color*)*ch_it)->Value, tnemesh.ColorPerVertex);
-			else if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_ColorRGBA)
-				MeshGeometry_AddColor(**pMesh, ((CX3DImporter_NodeElement_ColorRGBA*)*ch_it)->Value, tnemesh.ColorPerVertex);
-			else if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Coordinate)
-				{} // skip because already read when mesh created.
-			else if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Normal)
-				MeshGeometry_AddNormal(**pMesh, tnemesh.CoordIndex, tnemesh.NormalIndex, ((CX3DImporter_NodeElement_Normal*)*ch_it)->Value,
-										tnemesh.NormalPerVertex);
-			else if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_TextureCoordinate)
-				MeshGeometry_AddTexCoord(**pMesh, tnemesh.CoordIndex, tnemesh.TexCoordIndex, ((CX3DImporter_NodeElement_TextureCoordinate*)*ch_it)->Value);
-			else
-				throw DeadlyImportError("Postprocess_BuildMesh. Unknown child of TrianlgeSet: " + to_string((*ch_it)->Type) + ".");
-		}// for(std::list<CX3DImporter_NodeElement*>::iterator ch_it = tnemesh.Child.begin(); ch_it != tnemesh.Child.end(); ++ch_it)
-
-		return;// mesh is build, nothing to do anymore.
-	}// if(pNodeElement.Type == CX3DImporter_NodeElement::ENET_TriangleSet)
-
-	if(pNodeElement.Type == CX3DImporter_NodeElement::ENET_TriangleStripSet)
-	{
-		CX3DImporter_NodeElement_Set& tnemesh = *((CX3DImporter_NodeElement_Set*)&pNodeElement);// create alias for convenience
-
-		// at first search for <Coordinate> node and create mesh.
-		for(std::list<CX3DImporter_NodeElement*>::iterator ch_it = tnemesh.Child.begin(); ch_it != tnemesh.Child.end(); ++ch_it)
-		{
-			if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Coordinate)
-			{
-				*pMesh = GeometryHelper_MakeMesh(tnemesh.CoordIndex, ((CX3DImporter_NodeElement_Coordinate*)*ch_it)->Value);
-			}
-		}
-
-		// copy additional information from children
-		for(std::list<CX3DImporter_NodeElement*>::iterator ch_it = tnemesh.Child.begin(); ch_it != tnemesh.Child.end(); ++ch_it)
-		{
-			ai_assert(*pMesh);
-			if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Color)
-				MeshGeometry_AddColor(**pMesh, ((CX3DImporter_NodeElement_Color*)*ch_it)->Value, tnemesh.ColorPerVertex);
-			else if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_ColorRGBA)
-				MeshGeometry_AddColor(**pMesh, ((CX3DImporter_NodeElement_ColorRGBA*)*ch_it)->Value, tnemesh.ColorPerVertex);
-			else if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Coordinate)
-				{} // skip because already read when mesh created.
-			else if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_Normal)
-				MeshGeometry_AddNormal(**pMesh, tnemesh.CoordIndex, tnemesh.NormalIndex, ((CX3DImporter_NodeElement_Normal*)*ch_it)->Value,
-										tnemesh.NormalPerVertex);
-			else if((*ch_it)->Type == CX3DImporter_NodeElement::ENET_TextureCoordinate)
-				MeshGeometry_AddTexCoord(**pMesh, tnemesh.CoordIndex, tnemesh.TexCoordIndex, ((CX3DImporter_NodeElement_TextureCoordinate*)*ch_it)->Value);
-			else
-				throw DeadlyImportError("Postprocess_BuildMesh. Unknown child of TriangleStripSet: " + to_string((*ch_it)->Type) + ".");
-		}// for(std::list<CX3DImporter_NodeElement*>::iterator ch_it = tnemesh.Child.begin(); ch_it != tnemesh.Child.end(); ++ch_it)
-
-		return;// mesh is build, nothing to do anymore.
-	}// if(pNodeElement.Type == CX3DImporter_NodeElement::ENET_TriangleStripSet)
-
-	throw DeadlyImportError("Postprocess_BuildMesh. Unknown mesh type: " + to_string(pNodeElement.Type) + ".");
-}
-
-void X3DImporter::Postprocess_BuildNode(const CX3DImporter_NodeElement& pNodeElement, aiNode& pSceneNode, std::list<aiMesh*>& pSceneMeshList,
-										std::list<aiMaterial*>& pSceneMaterialList, std::list<aiLight*>& pSceneLightList) const
-{
-    std::list<CX3DImporter_NodeElement*>::const_iterator chit_begin = pNodeElement.Child.begin();
-    std::list<CX3DImporter_NodeElement*>::const_iterator chit_end = pNodeElement.Child.end();
-    std::list<aiNode*> SceneNode_Child;
-    std::list<unsigned int> SceneNode_Mesh;
-
-	// At first read all metadata
-	Postprocess_CollectMetadata(pNodeElement, pSceneNode);
-	// check if we have deal with grouping node. Which can contain transformation or switch
-	if(pNodeElement.Type == CX3DImporter_NodeElement::ENET_Group)
-	{
-		const CX3DImporter_NodeElement_Group& tne_group = *((CX3DImporter_NodeElement_Group*)&pNodeElement);// create alias for convenience
-
-		pSceneNode.mTransformation = tne_group.Transformation;
-		if(tne_group.UseChoice)
-		{
-			// If Choice is less than zero or greater than the number of nodes in the children field, nothing is chosen.
-			if((tne_group.Choice < 0) || ((size_t)tne_group.Choice >= pNodeElement.Child.size()))
-			{
-				chit_begin = pNodeElement.Child.end();
-				chit_end = pNodeElement.Child.end();
-			}
-			else
-			{
-				for(size_t i = 0; i < (size_t)tne_group.Choice; i++) ++chit_begin;// forward iterator to chosen node.
-
-				chit_end = chit_begin;
-				++chit_end;// point end iterator to next element after chosen node.
-			}
-		}// if(tne_group.UseChoice)
-	}// if(pNodeElement.Type == CX3DImporter_NodeElement::ENET_Group)
-
-	// Reserve memory for fast access and check children.
-	for(std::list<CX3DImporter_NodeElement*>::const_iterator it = chit_begin; it != chit_end; ++it)
-	{// in this loop we do not read metadata because it's already read at begin.
-		if((*it)->Type == CX3DImporter_NodeElement::ENET_Group)
-		{
-			// if child is group then create new node and do recursive call.
-			aiNode* new_node = new aiNode;
-
-			new_node->mName = (*it)->ID;
-			new_node->mParent = &pSceneNode;
-			SceneNode_Child.push_back(new_node);
-			Postprocess_BuildNode(**it, *new_node, pSceneMeshList, pSceneMaterialList, pSceneLightList);
-		}
-		else if((*it)->Type == CX3DImporter_NodeElement::ENET_Shape)
-		{
-			// shape can contain only one geometry and one appearance nodes.
-			Postprocess_BuildShape(*((CX3DImporter_NodeElement_Shape*)*it), SceneNode_Mesh, pSceneMeshList, pSceneMaterialList);
-		}
-		else if(((*it)->Type == CX3DImporter_NodeElement::ENET_DirectionalLight) || ((*it)->Type == CX3DImporter_NodeElement::ENET_PointLight) ||
-				((*it)->Type == CX3DImporter_NodeElement::ENET_SpotLight))
-		{
-			Postprocess_BuildLight(*((CX3DImporter_NodeElement_Light*)*it), pSceneLightList);
-		}
-		else if(!PostprocessHelper_ElementIsMetadata((*it)->Type))// skip metadata
-		{
-			throw DeadlyImportError("Postprocess_BuildNode. Unknown type: " + to_string((*it)->Type) + ".");
-		}
-	}// for(std::list<CX3DImporter_NodeElement*>::const_iterator it = chit_begin; it != chit_end; it++)
-
-	// copy data about children and meshes to aiNode.
-	if(!SceneNode_Child.empty())
-	{
-		std::list<aiNode*>::const_iterator it = SceneNode_Child.begin();
-
-		pSceneNode.mNumChildren = static_cast<unsigned int>(SceneNode_Child.size());
-		pSceneNode.mChildren = new aiNode*[pSceneNode.mNumChildren];
-		for(size_t i = 0; i < pSceneNode.mNumChildren; i++) pSceneNode.mChildren[i] = *it++;
-	}
-
-	if(!SceneNode_Mesh.empty())
-	{
-		std::list<unsigned int>::const_iterator it = SceneNode_Mesh.begin();
-
-		pSceneNode.mNumMeshes = static_cast<unsigned int>(SceneNode_Mesh.size());
-		pSceneNode.mMeshes = new unsigned int[pSceneNode.mNumMeshes];
-		for(size_t i = 0; i < pSceneNode.mNumMeshes; i++) pSceneNode.mMeshes[i] = *it++;
-	}
-
-	// that's all. return to previous deals
-}
-
-void X3DImporter::Postprocess_BuildShape(const CX3DImporter_NodeElement_Shape& pShapeNodeElement, std::list<unsigned int>& pNodeMeshInd,
-							std::list<aiMesh*>& pSceneMeshList, std::list<aiMaterial*>& pSceneMaterialList) const
-{
-    aiMaterial* tmat = nullptr;
-    aiMesh* tmesh = nullptr;
-    CX3DImporter_NodeElement::EType mesh_type = CX3DImporter_NodeElement::ENET_Invalid;
-    unsigned int mat_ind = 0;
-
-	for(std::list<CX3DImporter_NodeElement*>::const_iterator it = pShapeNodeElement.Child.begin(); it != pShapeNodeElement.Child.end(); ++it)
-	{
-		if(PostprocessHelper_ElementIsMesh((*it)->Type))
-		{
-			Postprocess_BuildMesh(**it, &tmesh);
-			if(tmesh != nullptr)
-			{
-				// if mesh successfully built then add data about it to arrays
-				pNodeMeshInd.push_back(static_cast<unsigned int>(pSceneMeshList.size()));
-				pSceneMeshList.push_back(tmesh);
-				// keep mesh type. Need above for texture coordinate generation.
-				mesh_type = (*it)->Type;
-			}
-		}
-		else if((*it)->Type == CX3DImporter_NodeElement::ENET_Appearance)
-		{
-			Postprocess_BuildMaterial(**it, &tmat);
-			if(tmat != nullptr)
-			{
-				// if material successfully built then add data about it to array
-				mat_ind = static_cast<unsigned int>(pSceneMaterialList.size());
-				pSceneMaterialList.push_back(tmat);
-			}
-		}
-	}// for(std::list<CX3DImporter_NodeElement*>::const_iterator it = pShapeNodeElement.Child.begin(); it != pShapeNodeElement.Child.end(); it++)
-
-	// associate read material with read mesh.
-	if((tmesh != nullptr) && (tmat != nullptr))
-	{
-		tmesh->mMaterialIndex = mat_ind;
-		// Check texture mapping. If material has texture but mesh has no texture coordinate then try to ask Assimp to generate texture coordinates.
-		if((tmat->GetTextureCount(aiTextureType_DIFFUSE) != 0) && !tmesh->HasTextureCoords(0))
-		{
-			int32_t tm;
-			aiVector3D tvec3;
-
-			switch(mesh_type)
-			{
-				case CX3DImporter_NodeElement::ENET_Box:
-					tm = aiTextureMapping_BOX;
-					break;
-				case CX3DImporter_NodeElement::ENET_Cone:
-				case CX3DImporter_NodeElement::ENET_Cylinder:
-					tm = aiTextureMapping_CYLINDER;
-					break;
-				case CX3DImporter_NodeElement::ENET_Sphere:
-					tm = aiTextureMapping_SPHERE;
-					break;
-				default:
-					tm = aiTextureMapping_PLANE;
-					break;
-			}// switch(mesh_type)
-
-			tmat->AddProperty(&tm, 1, AI_MATKEY_MAPPING_DIFFUSE(0));
-		}// if((tmat->GetTextureCount(aiTextureType_DIFFUSE) != 0) && !tmesh->HasTextureCoords(0))
-	}// if((tmesh != nullptr) && (tmat != nullptr))
-}
-
-void X3DImporter::Postprocess_CollectMetadata(const CX3DImporter_NodeElement& pNodeElement, aiNode& pSceneNode) const
-{
-    std::list<CX3DImporter_NodeElement*> meta_list;
-    size_t meta_idx;
-
-	PostprocessHelper_CollectMetadata(pNodeElement, meta_list);// find metadata in current node element.
-	if ( !meta_list.empty() )
-	{
-        if ( pSceneNode.mMetaData != nullptr ) {
-            throw DeadlyImportError( "Postprocess. MetaData member in node are not nullptr. Something went wrong." );
-        }
-
-		// copy collected metadata to output node.
-        pSceneNode.mMetaData = aiMetadata::Alloc( static_cast<unsigned int>(meta_list.size()) );
-		meta_idx = 0;
-		for(std::list<CX3DImporter_NodeElement*>::const_iterator it = meta_list.begin(); it != meta_list.end(); ++it, ++meta_idx)
-		{
-			CX3DImporter_NodeElement_Meta* cur_meta = (CX3DImporter_NodeElement_Meta*)*it;
-
-			// due to limitations we can add only first element of value list.
-			// Add an element according to its type.
-			if((*it)->Type == CX3DImporter_NodeElement::ENET_MetaBoolean)
-			{
-				if(((CX3DImporter_NodeElement_MetaBoolean*)cur_meta)->Value.size() > 0)
-					pSceneNode.mMetaData->Set(static_cast<unsigned int>(meta_idx), cur_meta->Name, *(((CX3DImporter_NodeElement_MetaBoolean*)cur_meta)->Value.begin()));
-			}
-			else if((*it)->Type == CX3DImporter_NodeElement::ENET_MetaDouble)
-			{
-				if(((CX3DImporter_NodeElement_MetaDouble*)cur_meta)->Value.size() > 0)
-					pSceneNode.mMetaData->Set(static_cast<unsigned int>(meta_idx), cur_meta->Name, (float)*(((CX3DImporter_NodeElement_MetaDouble*)cur_meta)->Value.begin()));
-			}
-			else if((*it)->Type == CX3DImporter_NodeElement::ENET_MetaFloat)
-			{
-				if(((CX3DImporter_NodeElement_MetaFloat*)cur_meta)->Value.size() > 0)
-					pSceneNode.mMetaData->Set(static_cast<unsigned int>(meta_idx), cur_meta->Name, *(((CX3DImporter_NodeElement_MetaFloat*)cur_meta)->Value.begin()));
-			}
-			else if((*it)->Type == CX3DImporter_NodeElement::ENET_MetaInteger)
-			{
-				if(((CX3DImporter_NodeElement_MetaInteger*)cur_meta)->Value.size() > 0)
-					pSceneNode.mMetaData->Set(static_cast<unsigned int>(meta_idx), cur_meta->Name, *(((CX3DImporter_NodeElement_MetaInteger*)cur_meta)->Value.begin()));
-			}
-			else if((*it)->Type == CX3DImporter_NodeElement::ENET_MetaString)
-			{
-				if(((CX3DImporter_NodeElement_MetaString*)cur_meta)->Value.size() > 0)
-				{
-					aiString tstr(((CX3DImporter_NodeElement_MetaString*)cur_meta)->Value.begin()->data());
-
-					pSceneNode.mMetaData->Set(static_cast<unsigned int>(meta_idx), cur_meta->Name, tstr);
-				}
-			}
-			else
-			{
-				throw DeadlyImportError("Postprocess. Unknown metadata type.");
-			}// if((*it)->Type == CX3DImporter_NodeElement::ENET_Meta*) else
-		}// for(std::list<CX3DImporter_NodeElement*>::const_iterator it = meta_list.begin(); it != meta_list.end(); it++)
-	}// if( !meta_list.empty() )
-}
-
-}// namespace Assimp
-
-#endif // !ASSIMP_BUILD_NO_X3D_IMPORTER
diff --git a/Engine/lib/assimp/code/X3D/X3DImporter_Rendering.cpp b/Engine/lib/assimp/code/X3D/X3DImporter_Rendering.cpp
deleted file mode 100644
index 6e95c9441..000000000
--- a/Engine/lib/assimp/code/X3D/X3DImporter_Rendering.cpp
+++ /dev/null
@@ -1,1071 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-/// \file   X3DImporter_Rendering.cpp
-/// \brief  Parsing data from nodes of "Rendering" set of X3D.
-/// \date   2015-2016
-/// \author smal.root@gmail.com
-
-#ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
-
-#include "X3DImporter.hpp"
-#include "X3DImporter_Macro.hpp"
-
-namespace Assimp
-{
-
-// <Color
-// DEF=""           ID
-// USE=""           IDREF
-// color="" MFColor [inputOutput]
-// />
-void X3DImporter::ParseNode_Rendering_Color()
-{
-    std::string use, def;
-    std::list<aiColor3D> color;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_REF("color", color, XML_ReadNode_GetAttrVal_AsListCol3f);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_Color, ne);
-	}
-	else
-	{
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_Color(NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		((CX3DImporter_NodeElement_Color*)ne)->Value = color;
-		// check for X3DMetadataObject childs.
-		if(!mReader->isEmptyElement())
-			ParseNode_Metadata(ne, "Color");
-		else
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-// <ColorRGBA
-// DEF=""               ID
-// USE=""               IDREF
-// color="" MFColorRGBA [inputOutput]
-// />
-void X3DImporter::ParseNode_Rendering_ColorRGBA()
-{
-    std::string use, def;
-    std::list<aiColor4D> color;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_REF("color", color, XML_ReadNode_GetAttrVal_AsListCol4f);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_ColorRGBA, ne);
-	}
-	else
-	{
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_ColorRGBA(NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		((CX3DImporter_NodeElement_ColorRGBA*)ne)->Value = color;
-		// check for X3DMetadataObject childs.
-		if(!mReader->isEmptyElement())
-			ParseNode_Metadata(ne, "ColorRGBA");
-		else
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-// <Coordinate
-// DEF=""      ID
-// USE=""      IDREF
-// point=""    MFVec3f [inputOutput]
-// />
-void X3DImporter::ParseNode_Rendering_Coordinate()
-{
-    std::string use, def;
-    std::list<aiVector3D> point;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_REF("point", point, XML_ReadNode_GetAttrVal_AsListVec3f);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_Coordinate, ne);
-	}
-	else
-	{
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_Coordinate(NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		((CX3DImporter_NodeElement_Coordinate*)ne)->Value = point;
-		// check for X3DMetadataObject childs.
-		if(!mReader->isEmptyElement())
-			ParseNode_Metadata(ne, "Coordinate");
-		else
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-// <IndexedLineSet
-// DEF=""                ID
-// USE=""                IDREF
-// colorIndex=""         MFInt32 [initializeOnly]
-// colorPerVertex="true" SFBool  [initializeOnly]
-// coordIndex=""         MFInt32 [initializeOnly]
-// >
-//    <!-- ColorCoordinateContentModel -->
-// ColorCoordinateContentModel is the child-node content model corresponding to IndexedLineSet, LineSet and PointSet. ColorCoordinateContentModel can
-// contain any-order Coordinate node with Color (or ColorRGBA) node. No more than one instance of any single node type is allowed.
-// A ProtoInstance node (with the proper node type) can be substituted for any node in this content model.
-// </IndexedLineSet>
-void X3DImporter::ParseNode_Rendering_IndexedLineSet()
-{
-    std::string use, def;
-    std::vector<int32_t> colorIndex;
-    bool colorPerVertex = true;
-    std::vector<int32_t> coordIndex;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_REF("colorIndex", colorIndex, XML_ReadNode_GetAttrVal_AsArrI32);
-		MACRO_ATTRREAD_CHECK_RET("colorPerVertex", colorPerVertex, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_REF("coordIndex", coordIndex, XML_ReadNode_GetAttrVal_AsArrI32);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_IndexedLineSet, ne);
-	}
-	else
-	{
-		// check data
-		if((coordIndex.size() < 2) || ((coordIndex.back() == (-1)) && (coordIndex.size() < 3)))
-			throw DeadlyImportError("IndexedLineSet must contain not empty \"coordIndex\" attribute.");
-
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_IndexedSet(CX3DImporter_NodeElement::ENET_IndexedLineSet, NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		CX3DImporter_NodeElement_IndexedSet& ne_alias = *((CX3DImporter_NodeElement_IndexedSet*)ne);
-
-		ne_alias.ColorIndex = colorIndex;
-		ne_alias.ColorPerVertex = colorPerVertex;
-		ne_alias.CoordIndex = coordIndex;
-        // check for child nodes
-        if(!mReader->isEmptyElement())
-        {
-			ParseHelper_Node_Enter(ne);
-			MACRO_NODECHECK_LOOPBEGIN("IndexedLineSet");
-				// check for Color and Coordinate nodes
-				if(XML_CheckNode_NameEqual("Color")) { ParseNode_Rendering_Color(); continue; }
-				if(XML_CheckNode_NameEqual("ColorRGBA")) { ParseNode_Rendering_ColorRGBA(); continue; }
-				if(XML_CheckNode_NameEqual("Coordinate")) { ParseNode_Rendering_Coordinate(); continue; }
-				// check for X3DMetadataObject
-				if(!ParseHelper_CheckRead_X3DMetadataObject()) XML_CheckNode_SkipUnsupported("IndexedLineSet");
-
-			MACRO_NODECHECK_LOOPEND("IndexedLineSet");
-			ParseHelper_Node_Exit();
-		}// if(!mReader->isEmptyElement())
-		else
-		{
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-		}
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-// <IndexedTriangleFanSet
-// DEF=""                 ID
-// USE=""                 IDREF
-// ccw="true"             SFBool  [initializeOnly]
-// colorPerVertex="true"  SFBool  [initializeOnly]
-// index=""               MFInt32 [initializeOnly]
-// normalPerVertex="true" SFBool  [initializeOnly]
-// solid="true"           SFBool  [initializeOnly]
-// >
-//    <!-- ComposedGeometryContentModel -->
-// ComposedGeometryContentModel is the child-node content model corresponding to X3DComposedGeometryNodes. It can contain Color (or ColorRGBA), Coordinate,
-// Normal and TextureCoordinate, in any order. No more than one instance of these nodes is allowed. Multiple VertexAttribute (FloatVertexAttribute,
-// Matrix3VertexAttribute, Matrix4VertexAttribute) nodes can also be contained.
-// A ProtoInstance node (with the proper node type) can be substituted for any node in this content model.
-// </IndexedTriangleFanSet>
-void X3DImporter::ParseNode_Rendering_IndexedTriangleFanSet()
-{
-    std::string use, def;
-    bool ccw = true;
-    bool colorPerVertex = true;
-    std::vector<int32_t> index;
-    bool normalPerVertex = true;
-    bool solid = true;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_RET("ccw", ccw, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("colorPerVertex", colorPerVertex, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_REF("index", index, XML_ReadNode_GetAttrVal_AsArrI32);
-		MACRO_ATTRREAD_CHECK_RET("normalPerVertex", normalPerVertex, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("solid", solid, XML_ReadNode_GetAttrVal_AsBool);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_IndexedTriangleFanSet, ne);
-	}
-	else
-	{
-		// check data
-		if(index.size() == 0) throw DeadlyImportError("IndexedTriangleFanSet must contain not empty \"index\" attribute.");
-
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_IndexedSet(CX3DImporter_NodeElement::ENET_IndexedTriangleFanSet, NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		CX3DImporter_NodeElement_IndexedSet& ne_alias = *((CX3DImporter_NodeElement_IndexedSet*)ne);
-
-		ne_alias.CCW = ccw;
-		ne_alias.ColorPerVertex = colorPerVertex;
-		ne_alias.NormalPerVertex = normalPerVertex;
-		ne_alias.Solid = solid;
-
-		ne_alias.CoordIndex.clear();
-		int counter = 0;
-		int32_t idx[3];
-		for(std::vector<int32_t>::const_iterator idx_it = index.begin(); idx_it != index.end(); ++idx_it)
-		{
-			idx[2] = *idx_it;
-			if (idx[2] < 0)
-			{
-				counter = 0;
-			}
-			else
-			{
-				if (counter >= 2)
-				{
-					if(ccw)
-					{
-						ne_alias.CoordIndex.push_back(idx[0]);
-						ne_alias.CoordIndex.push_back(idx[1]);
-						ne_alias.CoordIndex.push_back(idx[2]);
-					}
-					else
-					{
-						ne_alias.CoordIndex.push_back(idx[0]);
-						ne_alias.CoordIndex.push_back(idx[2]);
-						ne_alias.CoordIndex.push_back(idx[1]);
-					}
-					ne_alias.CoordIndex.push_back(-1);
-					idx[1] = idx[2];
-				}
-				else
-				{
-					idx[counter] = idx[2];
-				}
-				++counter;
-			}
-		}// for(std::list<int32_t>::const_iterator idx_it = index.begin(); idx_it != ne_alias.index.end(); idx_it++)
-
-        // check for child nodes
-        if(!mReader->isEmptyElement())
-        {
-			ParseHelper_Node_Enter(ne);
-			MACRO_NODECHECK_LOOPBEGIN("IndexedTriangleFanSet");
-				// check for X3DComposedGeometryNodes
-				if(XML_CheckNode_NameEqual("Color")) { ParseNode_Rendering_Color(); continue; }
-				if(XML_CheckNode_NameEqual("ColorRGBA")) { ParseNode_Rendering_ColorRGBA(); continue; }
-				if(XML_CheckNode_NameEqual("Coordinate")) { ParseNode_Rendering_Coordinate(); continue; }
-				if(XML_CheckNode_NameEqual("Normal")) { ParseNode_Rendering_Normal(); continue; }
-				if(XML_CheckNode_NameEqual("TextureCoordinate")) { ParseNode_Texturing_TextureCoordinate(); continue; }
-				// check for X3DMetadataObject
-				if(!ParseHelper_CheckRead_X3DMetadataObject()) XML_CheckNode_SkipUnsupported("IndexedTriangleFanSet");
-
-			MACRO_NODECHECK_LOOPEND("IndexedTriangleFanSet");
-			ParseHelper_Node_Exit();
-		}// if(!mReader->isEmptyElement())
-		else
-		{
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-		}
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-// <IndexedTriangleSet
-// DEF=""                 ID
-// USE=""                 IDREF
-// ccw="true"             SFBool  [initializeOnly]
-// colorPerVertex="true"  SFBool  [initializeOnly]
-// index=""               MFInt32 [initializeOnly]
-// normalPerVertex="true" SFBool  [initializeOnly]
-// solid="true"           SFBool  [initializeOnly]
-// >
-//    <!-- ComposedGeometryContentModel -->
-// ComposedGeometryContentModel is the child-node content model corresponding to X3DComposedGeometryNodes. It can contain Color (or ColorRGBA), Coordinate,
-// Normal and TextureCoordinate, in any order. No more than one instance of these nodes is allowed. Multiple VertexAttribute (FloatVertexAttribute,
-// Matrix3VertexAttribute, Matrix4VertexAttribute) nodes can also be contained.
-// A ProtoInstance node (with the proper node type) can be substituted for any node in this content model.
-// </IndexedTriangleSet>
-void X3DImporter::ParseNode_Rendering_IndexedTriangleSet()
-{
-    std::string use, def;
-    bool ccw = true;
-    bool colorPerVertex = true;
-    std::vector<int32_t> index;
-    bool normalPerVertex = true;
-    bool solid = true;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_RET("ccw", ccw, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("colorPerVertex", colorPerVertex, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_REF("index", index, XML_ReadNode_GetAttrVal_AsArrI32);
-		MACRO_ATTRREAD_CHECK_RET("normalPerVertex", normalPerVertex, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("solid", solid, XML_ReadNode_GetAttrVal_AsBool);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_IndexedTriangleSet, ne);
-	}
-	else
-	{
-		// check data
-		if(index.size() == 0) throw DeadlyImportError("IndexedTriangleSet must contain not empty \"index\" attribute.");
-
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_IndexedSet(CX3DImporter_NodeElement::ENET_IndexedTriangleSet, NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		CX3DImporter_NodeElement_IndexedSet& ne_alias = *((CX3DImporter_NodeElement_IndexedSet*)ne);
-
-		ne_alias.CCW = ccw;
-		ne_alias.ColorPerVertex = colorPerVertex;
-		ne_alias.NormalPerVertex = normalPerVertex;
-		ne_alias.Solid = solid;
-
-		ne_alias.CoordIndex.clear();
-		int counter = 0;
-		int32_t idx[3];
-		for(std::vector<int32_t>::const_iterator idx_it = index.begin(); idx_it != index.end(); ++idx_it)
-		{
-			idx[counter++] = *idx_it;
-			if (counter > 2)
-			{
-				counter = 0;
-				if(ccw)
-				{
-					ne_alias.CoordIndex.push_back(idx[0]);
-					ne_alias.CoordIndex.push_back(idx[1]);
-					ne_alias.CoordIndex.push_back(idx[2]);
-				}
-				else
-				{
-					ne_alias.CoordIndex.push_back(idx[0]);
-					ne_alias.CoordIndex.push_back(idx[2]);
-					ne_alias.CoordIndex.push_back(idx[1]);
-				}
-				ne_alias.CoordIndex.push_back(-1);
-			}
-		}// for(std::list<int32_t>::const_iterator idx_it = index.begin(); idx_it != ne_alias.index.end(); idx_it++)
-
-        // check for child nodes
-        if(!mReader->isEmptyElement())
-        {
-			ParseHelper_Node_Enter(ne);
-			MACRO_NODECHECK_LOOPBEGIN("IndexedTriangleSet");
-				// check for X3DComposedGeometryNodes
-				if(XML_CheckNode_NameEqual("Color")) { ParseNode_Rendering_Color(); continue; }
-				if(XML_CheckNode_NameEqual("ColorRGBA")) { ParseNode_Rendering_ColorRGBA(); continue; }
-				if(XML_CheckNode_NameEqual("Coordinate")) { ParseNode_Rendering_Coordinate(); continue; }
-				if(XML_CheckNode_NameEqual("Normal")) { ParseNode_Rendering_Normal(); continue; }
-				if(XML_CheckNode_NameEqual("TextureCoordinate")) { ParseNode_Texturing_TextureCoordinate(); continue; }
-				// check for X3DMetadataObject
-				if(!ParseHelper_CheckRead_X3DMetadataObject()) XML_CheckNode_SkipUnsupported("IndexedTriangleSet");
-
-			MACRO_NODECHECK_LOOPEND("IndexedTriangleSet");
-			ParseHelper_Node_Exit();
-		}// if(!mReader->isEmptyElement())
-		else
-		{
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-		}
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-// <IndexedTriangleStripSet
-// DEF=""                 ID
-// USE=""                 IDREF
-// ccw="true"             SFBool  [initializeOnly]
-// colorPerVertex="true"  SFBool  [initializeOnly]
-// index=""               MFInt32 [initializeOnly]
-// normalPerVertex="true" SFBool  [initializeOnly]
-// solid="true"           SFBool  [initializeOnly]
-// >
-//    <!-- ComposedGeometryContentModel -->
-// ComposedGeometryContentModel is the child-node content model corresponding to X3DComposedGeometryNodes. It can contain Color (or ColorRGBA), Coordinate,
-// Normal and TextureCoordinate, in any order. No more than one instance of these nodes is allowed. Multiple VertexAttribute (FloatVertexAttribute,
-// Matrix3VertexAttribute, Matrix4VertexAttribute) nodes can also be contained.
-// A ProtoInstance node (with the proper node type) can be substituted for any node in this content model.
-// </IndexedTriangleStripSet>
-void X3DImporter::ParseNode_Rendering_IndexedTriangleStripSet()
-{
-    std::string use, def;
-    bool ccw = true;
-    bool colorPerVertex = true;
-    std::vector<int32_t> index;
-    bool normalPerVertex = true;
-    bool solid = true;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_RET("ccw", ccw, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("colorPerVertex", colorPerVertex, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_REF("index", index, XML_ReadNode_GetAttrVal_AsArrI32);
-		MACRO_ATTRREAD_CHECK_RET("normalPerVertex", normalPerVertex, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("solid", solid, XML_ReadNode_GetAttrVal_AsBool);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_IndexedTriangleStripSet, ne);
-	}
-	else
-	{
-		// check data
-		if(index.size() == 0) throw DeadlyImportError("IndexedTriangleStripSet must contain not empty \"index\" attribute.");
-
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_IndexedSet(CX3DImporter_NodeElement::ENET_IndexedTriangleStripSet, NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		CX3DImporter_NodeElement_IndexedSet& ne_alias = *((CX3DImporter_NodeElement_IndexedSet*)ne);
-
-		ne_alias.CCW = ccw;
-		ne_alias.ColorPerVertex = colorPerVertex;
-		ne_alias.NormalPerVertex = normalPerVertex;
-		ne_alias.Solid = solid;
-
-		ne_alias.CoordIndex.clear();
-		int counter = 0;
-		int32_t idx[3];
-		for(std::vector<int32_t>::const_iterator idx_it = index.begin(); idx_it != index.end(); ++idx_it)
-		{
-			idx[2] = *idx_it;
-			if (idx[2] < 0)
-			{
-				counter = 0;
-			}
-			else
-			{
-				if (counter >= 2)
-				{
-					if(ccw)
-					{
-						ne_alias.CoordIndex.push_back(idx[0]);
-						ne_alias.CoordIndex.push_back(idx[1]);
-						ne_alias.CoordIndex.push_back(idx[2]);
-					}
-					else
-					{
-						ne_alias.CoordIndex.push_back(idx[0]);
-						ne_alias.CoordIndex.push_back(idx[2]);
-						ne_alias.CoordIndex.push_back(idx[1]);
-					}
-					ne_alias.CoordIndex.push_back(-1);
-				}
-				idx[counter & 1] = idx[2];
-				++counter;
-			}
-		}// for(std::list<int32_t>::const_iterator idx_it = index.begin(); idx_it != ne_alias.index.end(); idx_it++)
-
-        // check for child nodes
-        if(!mReader->isEmptyElement())
-        {
-			ParseHelper_Node_Enter(ne);
-			MACRO_NODECHECK_LOOPBEGIN("IndexedTriangleStripSet");
-				// check for X3DComposedGeometryNodes
-				if(XML_CheckNode_NameEqual("Color")) { ParseNode_Rendering_Color(); continue; }
-				if(XML_CheckNode_NameEqual("ColorRGBA")) { ParseNode_Rendering_ColorRGBA(); continue; }
-				if(XML_CheckNode_NameEqual("Coordinate")) { ParseNode_Rendering_Coordinate(); continue; }
-				if(XML_CheckNode_NameEqual("Normal")) { ParseNode_Rendering_Normal(); continue; }
-				if(XML_CheckNode_NameEqual("TextureCoordinate")) { ParseNode_Texturing_TextureCoordinate(); continue; }
-				// check for X3DMetadataObject
-				if(!ParseHelper_CheckRead_X3DMetadataObject()) XML_CheckNode_SkipUnsupported("IndexedTriangleStripSet");
-
-			MACRO_NODECHECK_LOOPEND("IndexedTriangleStripSet");
-			ParseHelper_Node_Exit();
-		}// if(!mReader->isEmptyElement())
-		else
-		{
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-		}
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-// <LineSet
-// DEF=""         ID
-// USE=""         IDREF
-// vertexCount="" MFInt32 [initializeOnly]
-// >
-//    <!-- ColorCoordinateContentModel -->
-// ColorCoordinateContentModel is the child-node content model corresponding to IndexedLineSet, LineSet and PointSet. ColorCoordinateContentModel can
-// contain any-order Coordinate node with Color (or ColorRGBA) node. No more than one instance of any single node type is allowed.
-// A ProtoInstance node (with the proper node type) can be substituted for any node in this content model.
-// </LineSet>
-void X3DImporter::ParseNode_Rendering_LineSet()
-{
-    std::string use, def;
-    std::vector<int32_t> vertexCount;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_REF("vertexCount", vertexCount, XML_ReadNode_GetAttrVal_AsArrI32);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_LineSet, ne);
-	}
-	else
-	{
-		// check data
-		if(vertexCount.size() == 0) throw DeadlyImportError("LineSet must contain not empty \"vertexCount\" attribute.");
-
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_Set(CX3DImporter_NodeElement::ENET_LineSet, NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		CX3DImporter_NodeElement_Set& ne_alias = *((CX3DImporter_NodeElement_Set*)ne);
-
-		ne_alias.VertexCount = vertexCount;
-		// create CoordIdx
-		size_t coord_num = 0;
-
-		ne_alias.CoordIndex.clear();
-		for(std::vector<int32_t>::const_iterator vc_it = ne_alias.VertexCount.begin(); vc_it != ne_alias.VertexCount.end(); ++vc_it)
-		{
-			if(*vc_it < 2) throw DeadlyImportError("LineSet. vertexCount shall be greater than or equal to two.");
-
-			for(int32_t i = 0; i < *vc_it; i++) ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num++));// add vertices indices
-
-			 ne_alias.CoordIndex.push_back(-1);// add face delimiter.
-		}
-
-        // check for child nodes
-        if(!mReader->isEmptyElement())
-        {
-			ParseHelper_Node_Enter(ne);
-			MACRO_NODECHECK_LOOPBEGIN("LineSet");
-				// check for X3DComposedGeometryNodes
-				if(XML_CheckNode_NameEqual("Color")) { ParseNode_Rendering_Color(); continue; }
-				if(XML_CheckNode_NameEqual("ColorRGBA")) { ParseNode_Rendering_ColorRGBA(); continue; }
-				if(XML_CheckNode_NameEqual("Coordinate")) { ParseNode_Rendering_Coordinate(); continue; }
-				// check for X3DMetadataObject
-				if(!ParseHelper_CheckRead_X3DMetadataObject()) XML_CheckNode_SkipUnsupported("LineSet");
-
-			MACRO_NODECHECK_LOOPEND("LineSet");
-			ParseHelper_Node_Exit();
-		}// if(!mReader->isEmptyElement())
-		else
-		{
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-		}
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-// <PointSet
-// DEF="" ID
-// USE="" IDREF
-// >
-//    <!-- ColorCoordinateContentModel -->
-// ColorCoordinateContentModel is the child-node content model corresponding to IndexedLineSet, LineSet and PointSet. ColorCoordinateContentModel can
-// contain any-order Coordinate node with Color (or ColorRGBA) node. No more than one instance of any single node type is allowed.
-// A ProtoInstance node (with the proper node type) can be substituted for any node in this content model.
-// </PointSet>
-void X3DImporter::ParseNode_Rendering_PointSet()
-{
-    std::string use, def;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_PointSet, ne);
-	}
-	else
-	{
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_IndexedSet(CX3DImporter_NodeElement::ENET_PointSet, NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-        // check for child nodes
-        if(!mReader->isEmptyElement())
-        {
-			ParseHelper_Node_Enter(ne);
-			MACRO_NODECHECK_LOOPBEGIN("PointSet");
-				// check for X3DComposedGeometryNodes
-				if(XML_CheckNode_NameEqual("Color")) { ParseNode_Rendering_Color(); continue; }
-				if(XML_CheckNode_NameEqual("ColorRGBA")) { ParseNode_Rendering_ColorRGBA(); continue; }
-				if(XML_CheckNode_NameEqual("Coordinate")) { ParseNode_Rendering_Coordinate(); continue; }
-				// check for X3DMetadataObject
-				if(!ParseHelper_CheckRead_X3DMetadataObject()) XML_CheckNode_SkipUnsupported("PointSet");
-
-			MACRO_NODECHECK_LOOPEND("PointSet");
-			ParseHelper_Node_Exit();
-		}// if(!mReader->isEmptyElement())
-		else
-		{
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-		}
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-// <TriangleFanSet
-// DEF=""                 ID
-// USE=""                 IDREF
-// ccw="true"             SFBool  [initializeOnly]
-// colorPerVertex="true"  SFBool  [initializeOnly]
-// fanCount=""            MFInt32 [inputOutput]
-// normalPerVertex="true" SFBool  [initializeOnly]
-// solid="true"           SFBool  [initializeOnly]
-// >
-//    <!-- ComposedGeometryContentModel -->
-// ComposedGeometryContentModel is the child-node content model corresponding to X3DComposedGeometryNodes. It can contain Color (or ColorRGBA), Coordinate,
-// Normal and TextureCoordinate, in any order. No more than one instance of these nodes is allowed. Multiple VertexAttribute (FloatVertexAttribute,
-// Matrix3VertexAttribute, Matrix4VertexAttribute) nodes can also be contained.
-// A ProtoInstance node (with the proper node type) can be substituted for any node in this content model.
-// </TriangleFanSet>
-void X3DImporter::ParseNode_Rendering_TriangleFanSet()
-{
-    std::string use, def;
-    bool ccw = true;
-    bool colorPerVertex = true;
-    std::vector<int32_t> fanCount;
-    bool normalPerVertex = true;
-    bool solid = true;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_RET("ccw", ccw, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("colorPerVertex", colorPerVertex, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_REF("fanCount", fanCount, XML_ReadNode_GetAttrVal_AsArrI32);
-		MACRO_ATTRREAD_CHECK_RET("normalPerVertex", normalPerVertex, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("solid", solid, XML_ReadNode_GetAttrVal_AsBool);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_TriangleFanSet, ne);
-	}
-	else
-	{
-		// check data
-		if(fanCount.size() == 0) throw DeadlyImportError("TriangleFanSet must contain not empty \"fanCount\" attribute.");
-
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_Set(CX3DImporter_NodeElement::ENET_TriangleFanSet, NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		CX3DImporter_NodeElement_Set& ne_alias = *((CX3DImporter_NodeElement_Set*)ne);
-
-		ne_alias.CCW = ccw;
-		ne_alias.ColorPerVertex = colorPerVertex;
-		ne_alias.VertexCount = fanCount;
-		ne_alias.NormalPerVertex = normalPerVertex;
-		ne_alias.Solid = solid;
-		// create CoordIdx
-		size_t coord_num_first, coord_num_prev;
-
-		ne_alias.CoordIndex.clear();
-		// assign indices for first triangle
-		coord_num_first = 0;
-		coord_num_prev = 1;
-		for(std::vector<int32_t>::const_iterator vc_it = ne_alias.VertexCount.begin(); vc_it != ne_alias.VertexCount.end(); ++vc_it)
-		{
-			if(*vc_it < 3) throw DeadlyImportError("TriangleFanSet. fanCount shall be greater than or equal to three.");
-
-			for(int32_t vc = 2; vc < *vc_it; vc++)
-			{
-				if(ccw)
-				{
-					// 2 1
-					//  0
-					ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num_first));// first vertex is a center and always is [0].
-					ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num_prev++));
-					ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num_prev));
-				}
-				else
-				{
-					// 1 2
-					//  0
-					ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num_first));// first vertex is a center and always is [0].
-					ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num_prev + 1));
-					ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num_prev++));
-				}// if(ccw) else
-
-				ne_alias.CoordIndex.push_back(-1);// add face delimiter.
-			}// for(int32_t vc = 2; vc < *vc_it; vc++)
-
-			coord_num_prev++;// that index will be center of next fan
-			coord_num_first = coord_num_prev++;// forward to next point - second point of fan
-		}// for(std::list<int32_t>::const_iterator vc_it = ne_alias.VertexCount.begin(); vc_it != ne_alias.VertexCount.end(); vc_it++)
-        // check for child nodes
-        if(!mReader->isEmptyElement())
-        {
-			ParseHelper_Node_Enter(ne);
-			MACRO_NODECHECK_LOOPBEGIN("TriangleFanSet");
-				// check for X3DComposedGeometryNodes
-				if(XML_CheckNode_NameEqual("Color")) { ParseNode_Rendering_Color(); continue; }
-				if(XML_CheckNode_NameEqual("ColorRGBA")) { ParseNode_Rendering_ColorRGBA(); continue; }
-				if(XML_CheckNode_NameEqual("Coordinate")) { ParseNode_Rendering_Coordinate(); continue; }
-				if(XML_CheckNode_NameEqual("Normal")) { ParseNode_Rendering_Normal(); continue; }
-				if(XML_CheckNode_NameEqual("TextureCoordinate")) { ParseNode_Texturing_TextureCoordinate(); continue; }
-				// check for X3DMetadataObject
-				if(!ParseHelper_CheckRead_X3DMetadataObject()) XML_CheckNode_SkipUnsupported("TriangleFanSet");
-
-			MACRO_NODECHECK_LOOPEND("TriangleFanSet");
-			ParseHelper_Node_Exit();
-		}// if(!mReader->isEmptyElement())
-		else
-		{
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-		}
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-// <TriangleSet
-// DEF=""                 ID
-// USE=""                 IDREF
-// ccw="true"             SFBool  [initializeOnly]
-// colorPerVertex="true"  SFBool  [initializeOnly]
-// normalPerVertex="true" SFBool  [initializeOnly]
-// solid="true"           SFBool  [initializeOnly]
-// >
-//    <!-- ComposedGeometryContentModel -->
-// ComposedGeometryContentModel is the child-node content model corresponding to X3DComposedGeometryNodes. It can contain Color (or ColorRGBA), Coordinate,
-// Normal and TextureCoordinate, in any order. No more than one instance of these nodes is allowed. Multiple VertexAttribute (FloatVertexAttribute,
-// Matrix3VertexAttribute, Matrix4VertexAttribute) nodes can also be contained.
-// A ProtoInstance node (with the proper node type) can be substituted for any node in this content model.
-// </TriangleSet>
-void X3DImporter::ParseNode_Rendering_TriangleSet()
-{
-    std::string use, def;
-    bool ccw = true;
-    bool colorPerVertex = true;
-    bool normalPerVertex = true;
-    bool solid = true;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_RET("ccw", ccw, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("colorPerVertex", colorPerVertex, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("normalPerVertex", normalPerVertex, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("solid", solid, XML_ReadNode_GetAttrVal_AsBool);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_TriangleSet, ne);
-	}
-	else
-	{
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_IndexedSet(CX3DImporter_NodeElement::ENET_TriangleSet, NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		CX3DImporter_NodeElement_Set& ne_alias = *((CX3DImporter_NodeElement_Set*)ne);
-
-		ne_alias.CCW = ccw;
-		ne_alias.ColorPerVertex = colorPerVertex;
-		ne_alias.NormalPerVertex = normalPerVertex;
-		ne_alias.Solid = solid;
-        // check for child nodes
-        if(!mReader->isEmptyElement())
-        {
-			ParseHelper_Node_Enter(ne);
-			MACRO_NODECHECK_LOOPBEGIN("TriangleSet");
-				// check for X3DComposedGeometryNodes
-				if(XML_CheckNode_NameEqual("Color")) { ParseNode_Rendering_Color(); continue; }
-				if(XML_CheckNode_NameEqual("ColorRGBA")) { ParseNode_Rendering_ColorRGBA(); continue; }
-				if(XML_CheckNode_NameEqual("Coordinate")) { ParseNode_Rendering_Coordinate(); continue; }
-				if(XML_CheckNode_NameEqual("Normal")) { ParseNode_Rendering_Normal(); continue; }
-				if(XML_CheckNode_NameEqual("TextureCoordinate")) { ParseNode_Texturing_TextureCoordinate(); continue; }
-				// check for X3DMetadataObject
-				if(!ParseHelper_CheckRead_X3DMetadataObject()) XML_CheckNode_SkipUnsupported("TriangleSet");
-
-			MACRO_NODECHECK_LOOPEND("TriangleSet");
-			ParseHelper_Node_Exit();
-		}// if(!mReader->isEmptyElement())
-		else
-		{
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-		}
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-// <TriangleStripSet
-// DEF=""                 ID
-// USE=""                 IDREF
-// ccw="true"             SFBool  [initializeOnly]
-// colorPerVertex="true"  SFBool  [initializeOnly]
-// normalPerVertex="true" SFBool  [initializeOnly]
-// solid="true"           SFBool  [initializeOnly]
-// stripCount=""          MFInt32 [inputOutput]
-// >
-//    <!-- ComposedGeometryContentModel -->
-// ComposedGeometryContentModel is the child-node content model corresponding to X3DComposedGeometryNodes. It can contain Color (or ColorRGBA), Coordinate,
-// Normal and TextureCoordinate, in any order. No more than one instance of these nodes is allowed. Multiple VertexAttribute (FloatVertexAttribute,
-// Matrix3VertexAttribute, Matrix4VertexAttribute) nodes can also be contained.
-// A ProtoInstance node (with the proper node type) can be substituted for any node in this content model.
-// </TriangleStripSet>
-void X3DImporter::ParseNode_Rendering_TriangleStripSet()
-{
-    std::string use, def;
-    bool ccw = true;
-    bool colorPerVertex = true;
-    std::vector<int32_t> stripCount;
-    bool normalPerVertex = true;
-    bool solid = true;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_RET("ccw", ccw, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("colorPerVertex", colorPerVertex, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_REF("stripCount", stripCount, XML_ReadNode_GetAttrVal_AsArrI32);
-		MACRO_ATTRREAD_CHECK_RET("normalPerVertex", normalPerVertex, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("solid", solid, XML_ReadNode_GetAttrVal_AsBool);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_TriangleStripSet, ne);
-	}
-	else
-	{
-		// check data
-		if(stripCount.size() == 0) throw DeadlyImportError("TriangleStripSet must contain not empty \"stripCount\" attribute.");
-
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_Set(CX3DImporter_NodeElement::ENET_TriangleStripSet, NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		CX3DImporter_NodeElement_Set& ne_alias = *((CX3DImporter_NodeElement_Set*)ne);
-
-		ne_alias.CCW = ccw;
-		ne_alias.ColorPerVertex = colorPerVertex;
-		ne_alias.VertexCount = stripCount;
-		ne_alias.NormalPerVertex = normalPerVertex;
-		ne_alias.Solid = solid;
-		// create CoordIdx
-		size_t coord_num0, coord_num1, coord_num2;// indices of current triangle
-		bool odd_tri;// sequence of current triangle
-		size_t coord_num_sb;// index of first point of strip
-
-		ne_alias.CoordIndex.clear();
-		coord_num_sb = 0;
-		for(std::vector<int32_t>::const_iterator vc_it = ne_alias.VertexCount.begin(); vc_it != ne_alias.VertexCount.end(); ++vc_it)
-		{
-			if(*vc_it < 3) throw DeadlyImportError("TriangleStripSet. stripCount shall be greater than or equal to three.");
-
-			// set initial values for first triangle
-			coord_num0 = coord_num_sb;
-			coord_num1 = coord_num_sb + 1;
-			coord_num2 = coord_num_sb + 2;
-			odd_tri = true;
-
-			for(int32_t vc = 2; vc < *vc_it; vc++)
-			{
-				if(ccw)
-				{
-					// 0 2
-					//  1
-					ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num0));
-					ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num1));
-					ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num2));
-				}
-				else
-				{
-					// 0 1
-					//  2
-					ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num0));
-					ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num2));
-					ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num1));
-				}// if(ccw) else
-
-				ne_alias.CoordIndex.push_back(-1);// add face delimiter.
-				// prepare values for next triangle
-				if(odd_tri)
-				{
-					coord_num0 = coord_num2;
-					coord_num2++;
-				}
-				else
-				{
-					coord_num1 = coord_num2;
-					coord_num2 = coord_num1 + 1;
-				}
-
-				odd_tri = !odd_tri;
-				coord_num_sb = coord_num2;// that index will be start of next strip
-			}// for(int32_t vc = 2; vc < *vc_it; vc++)
-		}// for(std::list<int32_t>::const_iterator vc_it = ne_alias.VertexCount.begin(); vc_it != ne_alias.VertexCount.end(); vc_it++)
-        // check for child nodes
-        if(!mReader->isEmptyElement())
-        {
-			ParseHelper_Node_Enter(ne);
-			MACRO_NODECHECK_LOOPBEGIN("TriangleStripSet");
-				// check for X3DComposedGeometryNodes
-				if(XML_CheckNode_NameEqual("Color")) { ParseNode_Rendering_Color(); continue; }
-				if(XML_CheckNode_NameEqual("ColorRGBA")) { ParseNode_Rendering_ColorRGBA(); continue; }
-				if(XML_CheckNode_NameEqual("Coordinate")) { ParseNode_Rendering_Coordinate(); continue; }
-				if(XML_CheckNode_NameEqual("Normal")) { ParseNode_Rendering_Normal(); continue; }
-				if(XML_CheckNode_NameEqual("TextureCoordinate")) { ParseNode_Texturing_TextureCoordinate(); continue; }
-				// check for X3DMetadataObject
-				if(!ParseHelper_CheckRead_X3DMetadataObject()) XML_CheckNode_SkipUnsupported("TriangleStripSet");
-
-			MACRO_NODECHECK_LOOPEND("TriangleStripSet");
-			ParseHelper_Node_Exit();
-		}// if(!mReader->isEmptyElement())
-		else
-		{
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-		}
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-// <Normal
-// DEF=""      ID
-// USE=""      IDREF
-// vector=""   MFVec3f [inputOutput]
-// />
-void X3DImporter::ParseNode_Rendering_Normal()
-{
-std::string use, def;
-std::list<aiVector3D> vector;
-CX3DImporter_NodeElement* ne;
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_REF("vector", vector, XML_ReadNode_GetAttrVal_AsListVec3f);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_Normal, ne);
-	}
-	else
-	{
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_Normal(NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		((CX3DImporter_NodeElement_Normal*)ne)->Value = vector;
-		// check for X3DMetadataObject childs.
-		if(!mReader->isEmptyElement())
-			ParseNode_Metadata(ne, "Normal");
-		else
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-}// namespace Assimp
-
-#endif // !ASSIMP_BUILD_NO_X3D_IMPORTER
diff --git a/Engine/lib/assimp/code/X3D/X3DImporter_Shape.cpp b/Engine/lib/assimp/code/X3D/X3DImporter_Shape.cpp
deleted file mode 100644
index 126d5905a..000000000
--- a/Engine/lib/assimp/code/X3D/X3DImporter_Shape.cpp
+++ /dev/null
@@ -1,250 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-/// \file   X3DImporter_Shape.cpp
-/// \brief  Parsing data from nodes of "Shape" set of X3D.
-/// \date   2015-2016
-/// \author smal.root@gmail.com
-
-#ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
-
-#include "X3DImporter.hpp"
-#include "X3DImporter_Macro.hpp"
-
-namespace Assimp
-{
-
-// <Shape
-// DEF=""              ID
-// USE=""              IDREF
-// bboxCenter="0 0 0"  SFVec3f [initializeOnly]
-// bboxSize="-1 -1 -1" SFVec3f [initializeOnly]
-// >
-//    <!-- ShapeChildContentModel -->
-// "ShapeChildContentModel is the child-node content model corresponding to X3DShapeNode. ShapeChildContentModel can contain a single Appearance node and a
-// single geometry node, in any order.
-// A ProtoInstance node (with the proper node type) can be substituted for any node in this content model."
-// </Shape>
-// A Shape node is unlit if either of the following is true:
-//     The shape's appearance field is NULL (default).
-//     The material field in the Appearance node is NULL (default).
-// NOTE Geometry nodes that represent lines or points do not support lighting.
-void X3DImporter::ParseNode_Shape_Shape()
-{
-    std::string use, def;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_Shape, ne);
-	}
-	else
-	{
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_Shape(NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-        // check for child nodes
-        if(!mReader->isEmptyElement())
-        {
-			ParseHelper_Node_Enter(ne);
-			MACRO_NODECHECK_LOOPBEGIN("Shape");
-				// check for appearance node
-				if(XML_CheckNode_NameEqual("Appearance")) { ParseNode_Shape_Appearance(); continue; }
-				// check for X3DGeometryNodes
-				if(XML_CheckNode_NameEqual("Arc2D")) { ParseNode_Geometry2D_Arc2D(); continue; }
-				if(XML_CheckNode_NameEqual("ArcClose2D")) { ParseNode_Geometry2D_ArcClose2D(); continue; }
-				if(XML_CheckNode_NameEqual("Circle2D")) { ParseNode_Geometry2D_Circle2D(); continue; }
-				if(XML_CheckNode_NameEqual("Disk2D")) { ParseNode_Geometry2D_Disk2D(); continue; }
-				if(XML_CheckNode_NameEqual("Polyline2D")) { ParseNode_Geometry2D_Polyline2D(); continue; }
-				if(XML_CheckNode_NameEqual("Polypoint2D")) { ParseNode_Geometry2D_Polypoint2D(); continue; }
-				if(XML_CheckNode_NameEqual("Rectangle2D")) { ParseNode_Geometry2D_Rectangle2D(); continue; }
-				if(XML_CheckNode_NameEqual("TriangleSet2D")) { ParseNode_Geometry2D_TriangleSet2D(); continue; }
-				if(XML_CheckNode_NameEqual("Box")) { ParseNode_Geometry3D_Box(); continue; }
-				if(XML_CheckNode_NameEqual("Cone")) { ParseNode_Geometry3D_Cone(); continue; }
-				if(XML_CheckNode_NameEqual("Cylinder")) { ParseNode_Geometry3D_Cylinder(); continue; }
-				if(XML_CheckNode_NameEqual("ElevationGrid")) { ParseNode_Geometry3D_ElevationGrid(); continue; }
-				if(XML_CheckNode_NameEqual("Extrusion")) { ParseNode_Geometry3D_Extrusion(); continue; }
-				if(XML_CheckNode_NameEqual("IndexedFaceSet")) { ParseNode_Geometry3D_IndexedFaceSet(); continue; }
-				if(XML_CheckNode_NameEqual("Sphere")) { ParseNode_Geometry3D_Sphere(); continue; }
-				if(XML_CheckNode_NameEqual("IndexedLineSet")) { ParseNode_Rendering_IndexedLineSet(); continue; }
-				if(XML_CheckNode_NameEqual("LineSet")) { ParseNode_Rendering_LineSet(); continue; }
-				if(XML_CheckNode_NameEqual("PointSet")) { ParseNode_Rendering_PointSet(); continue; }
-				if(XML_CheckNode_NameEqual("IndexedTriangleFanSet")) { ParseNode_Rendering_IndexedTriangleFanSet(); continue; }
-				if(XML_CheckNode_NameEqual("IndexedTriangleSet")) { ParseNode_Rendering_IndexedTriangleSet(); continue; }
-				if(XML_CheckNode_NameEqual("IndexedTriangleStripSet")) { ParseNode_Rendering_IndexedTriangleStripSet(); continue; }
-				if(XML_CheckNode_NameEqual("TriangleFanSet")) { ParseNode_Rendering_TriangleFanSet(); continue; }
-				if(XML_CheckNode_NameEqual("TriangleSet")) { ParseNode_Rendering_TriangleSet(); continue; }
-				if(XML_CheckNode_NameEqual("TriangleStripSet")) { ParseNode_Rendering_TriangleStripSet(); continue; }
-				// check for X3DMetadataObject
-				if(!ParseHelper_CheckRead_X3DMetadataObject()) XML_CheckNode_SkipUnsupported("Shape");
-
-			MACRO_NODECHECK_LOOPEND("Shape");
-			ParseHelper_Node_Exit();
-		}// if(!mReader->isEmptyElement())
-		else
-		{
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-		}
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-// <Appearance
-// DEF="" ID
-// USE="" IDREF
-// >
-// <!-- AppearanceChildContentModel -->
-// "Child-node content model corresponding to X3DAppearanceChildNode. Appearance can contain FillProperties, LineProperties, Material, any Texture node and
-// any TextureTransform node, in any order. No more than one instance of these nodes is allowed. Appearance may also contain multiple shaders (ComposedShader,
-// PackagedShader, ProgramShader).
-// A ProtoInstance node (with the proper node type) can be substituted for any node in this content model."
-// </Appearance>
-void X3DImporter::ParseNode_Shape_Appearance()
-{
-    std::string use, def;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_Appearance, ne);
-	}
-	else
-	{
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_Appearance(NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-        // check for child nodes
-        if(!mReader->isEmptyElement())
-        {
-			ParseHelper_Node_Enter(ne);
-			MACRO_NODECHECK_LOOPBEGIN("Appearance");
-				if(XML_CheckNode_NameEqual("Material")) { ParseNode_Shape_Material(); continue; }
-				if(XML_CheckNode_NameEqual("ImageTexture")) { ParseNode_Texturing_ImageTexture(); continue; }
-				if(XML_CheckNode_NameEqual("TextureTransform")) { ParseNode_Texturing_TextureTransform(); continue; }
-				// check for X3DMetadataObject
-				if(!ParseHelper_CheckRead_X3DMetadataObject()) XML_CheckNode_SkipUnsupported("Appearance");
-
-			MACRO_NODECHECK_LOOPEND("Appearance");
-			ParseHelper_Node_Exit();
-		}// if(!mReader->isEmptyElement())
-		else
-		{
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-		}
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-// <Material
-// DEF=""                     ID
-// USE=""                     IDREF
-// ambientIntensity="0.2"     SFFloat [inputOutput]
-// diffuseColor="0.8 0.8 0.8" SFColor [inputOutput]
-// emissiveColor="0 0 0"      SFColor [inputOutput]
-// shininess="0.2"            SFFloat [inputOutput]
-// specularColor="0 0 0"      SFColor [inputOutput]
-// transparency="0"           SFFloat [inputOutput]
-// />
-void X3DImporter::ParseNode_Shape_Material()
-{
-    std::string use, def;
-    float ambientIntensity = 0.2f;
-    float shininess = 0.2f;
-    float transparency = 0;
-    aiColor3D diffuseColor(0.8f, 0.8f, 0.8f);
-    aiColor3D emissiveColor(0, 0, 0);
-    aiColor3D specularColor(0, 0, 0);
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_RET("ambientIntensity", ambientIntensity, XML_ReadNode_GetAttrVal_AsFloat);
-		MACRO_ATTRREAD_CHECK_RET("shininess", shininess, XML_ReadNode_GetAttrVal_AsFloat);
-		MACRO_ATTRREAD_CHECK_RET("transparency", transparency, XML_ReadNode_GetAttrVal_AsFloat);
-		MACRO_ATTRREAD_CHECK_REF("diffuseColor", diffuseColor, XML_ReadNode_GetAttrVal_AsCol3f);
-		MACRO_ATTRREAD_CHECK_REF("emissiveColor", emissiveColor, XML_ReadNode_GetAttrVal_AsCol3f);
-		MACRO_ATTRREAD_CHECK_REF("specularColor", specularColor, XML_ReadNode_GetAttrVal_AsCol3f);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_Material, ne);
-	}
-	else
-	{
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_Material(NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		((CX3DImporter_NodeElement_Material*)ne)->AmbientIntensity = ambientIntensity;
-		((CX3DImporter_NodeElement_Material*)ne)->Shininess = shininess;
-		((CX3DImporter_NodeElement_Material*)ne)->Transparency = transparency;
-		((CX3DImporter_NodeElement_Material*)ne)->DiffuseColor = diffuseColor;
-		((CX3DImporter_NodeElement_Material*)ne)->EmissiveColor = emissiveColor;
-		((CX3DImporter_NodeElement_Material*)ne)->SpecularColor = specularColor;
-        // check for child nodes
-		if(!mReader->isEmptyElement())
-			ParseNode_Metadata(ne, "Material");
-		else
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-}// namespace Assimp
-
-#endif // !ASSIMP_BUILD_NO_X3D_IMPORTER
diff --git a/Engine/lib/assimp/code/X3D/X3DImporter_Texturing.cpp b/Engine/lib/assimp/code/X3D/X3DImporter_Texturing.cpp
deleted file mode 100644
index 2eaf3e6bc..000000000
--- a/Engine/lib/assimp/code/X3D/X3DImporter_Texturing.cpp
+++ /dev/null
@@ -1,197 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-/// \file   X3DImporter_Texturing.cpp
-/// \brief  Parsing data from nodes of "Texturing" set of X3D.
-/// \date   2015-2016
-/// \author smal.root@gmail.com
-
-#ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
-
-#include "X3DImporter.hpp"
-#include "X3DImporter_Macro.hpp"
-
-namespace Assimp
-{
-
-// <ImageTexture
-// DEF=""         ID
-// USE=""         IDREF
-// repeatS="true" SFBool
-// repeatT="true" SFBool
-// url=""         MFString
-// />
-// When the url field contains no values ([]), texturing is disabled.
-void X3DImporter::ParseNode_Texturing_ImageTexture()
-{
-    std::string use, def;
-    bool repeatS = true;
-    bool repeatT = true;
-    std::list<std::string> url;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_RET("repeatS", repeatS, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_RET("repeatT", repeatT, XML_ReadNode_GetAttrVal_AsBool);
-		MACRO_ATTRREAD_CHECK_REF("url", url, XML_ReadNode_GetAttrVal_AsListS);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_ImageTexture, ne);
-	}
-	else
-	{
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_ImageTexture(NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		((CX3DImporter_NodeElement_ImageTexture*)ne)->RepeatS = repeatS;
-		((CX3DImporter_NodeElement_ImageTexture*)ne)->RepeatT = repeatT;
-		// Attribute "url" can contain list of strings. But we need only one - first.
-		if(!url.empty())
-			((CX3DImporter_NodeElement_ImageTexture*)ne)->URL = url.front();
-		else
-			((CX3DImporter_NodeElement_ImageTexture*)ne)->URL = "";
-
-		// check for X3DMetadataObject childs.
-		if(!mReader->isEmptyElement())
-			ParseNode_Metadata(ne, "ImageTexture");
-		else
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-// <TextureCoordinate
-// DEF=""      ID
-// USE=""      IDREF
-// point=""    MFVec3f [inputOutput]
-// />
-void X3DImporter::ParseNode_Texturing_TextureCoordinate()
-{
-    std::string use, def;
-    std::list<aiVector2D> point;
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_REF("point", point, XML_ReadNode_GetAttrVal_AsListVec2f);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_TextureCoordinate, ne);
-	}
-	else
-	{
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_TextureCoordinate(NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		((CX3DImporter_NodeElement_TextureCoordinate*)ne)->Value = point;
-		// check for X3DMetadataObject childs.
-		if(!mReader->isEmptyElement())
-			ParseNode_Metadata(ne, "TextureCoordinate");
-		else
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-// <TextureTransform
-// DEF=""            ID
-// USE=""            IDREF
-// center="0 0"      SFVec2f [inputOutput]
-// rotation="0"      SFFloat [inputOutput]
-// scale="1 1"       SFVec2f [inputOutput]
-// translation="0 0" SFVec2f [inputOutput]
-// />
-void X3DImporter::ParseNode_Texturing_TextureTransform()
-{
-    std::string use, def;
-    aiVector2D center(0, 0);
-    float rotation = 0;
-    aiVector2D scale(1, 1);
-    aiVector2D translation(0, 0);
-    CX3DImporter_NodeElement* ne( nullptr );
-
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
-		MACRO_ATTRREAD_CHECK_REF("center", center, XML_ReadNode_GetAttrVal_AsVec2f);
-		MACRO_ATTRREAD_CHECK_RET("rotation", rotation, XML_ReadNode_GetAttrVal_AsFloat);
-		MACRO_ATTRREAD_CHECK_REF("scale", scale, XML_ReadNode_GetAttrVal_AsVec2f);
-		MACRO_ATTRREAD_CHECK_REF("translation", translation, XML_ReadNode_GetAttrVal_AsVec2f);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// if "USE" defined then find already defined element.
-	if(!use.empty())
-	{
-		MACRO_USE_CHECKANDAPPLY(def, use, ENET_TextureTransform, ne);
-	}
-	else
-	{
-		// create and if needed - define new geometry object.
-		ne = new CX3DImporter_NodeElement_TextureTransform(NodeElement_Cur);
-		if(!def.empty()) ne->ID = def;
-
-		((CX3DImporter_NodeElement_TextureTransform*)ne)->Center = center;
-		((CX3DImporter_NodeElement_TextureTransform*)ne)->Rotation = rotation;
-		((CX3DImporter_NodeElement_TextureTransform*)ne)->Scale = scale;
-		((CX3DImporter_NodeElement_TextureTransform*)ne)->Translation = translation;
-		// check for X3DMetadataObject childs.
-		if(!mReader->isEmptyElement())
-			ParseNode_Metadata(ne, "TextureTransform");
-		else
-			NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
-
-		NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
-	}// if(!use.empty()) else
-}
-
-}// namespace Assimp
-
-#endif // !ASSIMP_BUILD_NO_X3D_IMPORTER
diff --git a/Engine/lib/assimp/code/X3D/X3DVocabulary.cpp b/Engine/lib/assimp/code/X3D/X3DVocabulary.cpp
deleted file mode 100644
index c6ee113b3..000000000
--- a/Engine/lib/assimp/code/X3D/X3DVocabulary.cpp
+++ /dev/null
@@ -1,1676 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-/// \file   X3DVocabulary.cpp
-/// \brief  Vocabulary for Fast Infoset encoded binary X3D files.
-/// \date   2017
-/// \author Patrick Daehne
-
-#ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
-
-#include "FIReader.hpp"
-
-namespace Assimp {
-
-static const char *encodingAlgorithmTable_3_2[] = {
-    "encoder://web3d.org/QuantizedFloatArrayEncoder",
-    "encoder://web3d.org/DeltazlibIntArrayEncoder",
-    "encoder://web3d.org/QuantizedzlibFloatArrayEncoder",
-    "encoder://web3d.org/zlibFloatArrayEncoder",
-    "encoder://web3d.org/QuantizedDoubleArrayEncoder",
-    "encoder://web3d.org/zlibDoubleArrayEncoder",
-    "encoder://web3d.org/QuantizedzlibDoubleArrayEncoder",
-    "encoder://web3d.org/RangeIntArrayEncoder"
-};
-
-static const std::shared_ptr<const FIValue> attributeValueTable_3_2[] = {
-    FIStringValue::create("false"),
-    FIStringValue::create("true")
-};
-
-static const FIQName elementNameTable_3_2[] = {
-    { "Shape", nullptr, nullptr },
-    { "Appearance", nullptr, nullptr },
-    { "Material", nullptr, nullptr },
-    { "IndexedFaceSet", nullptr, nullptr },
-    { "ProtoInstance", nullptr, nullptr },
-    { "Transform", nullptr, nullptr },
-    { "ImageTexture", nullptr, nullptr },
-    { "TextureTransform", nullptr, nullptr },
-    { "Coordinate", nullptr, nullptr },
-    { "Normal", nullptr, nullptr },
-    { "Color", nullptr, nullptr },
-    { "ColorRGBA", nullptr, nullptr },
-    { "TextureCoordinate", nullptr, nullptr },
-    { "ROUTE", nullptr, nullptr },
-    { "fieldValue", nullptr, nullptr },
-    { "Group", nullptr, nullptr },
-    { "LOD", nullptr, nullptr },
-    { "Switch", nullptr, nullptr },
-    { "Script", nullptr, nullptr },
-    { "IndexedTriangleFanSet", nullptr, nullptr },
-    { "IndexedTriangleSet", nullptr, nullptr },
-    { "IndexedTriangleStripSet", nullptr, nullptr },
-    { "MultiTexture", nullptr, nullptr },
-    { "MultiTextureCoordinate", nullptr, nullptr },
-    { "MultiTextureTransform", nullptr, nullptr },
-    { "IndexedLineSet", nullptr, nullptr },
-    { "PointSet", nullptr, nullptr },
-    { "StaticGroup", nullptr, nullptr },
-    { "Sphere", nullptr, nullptr },
-    { "Box", nullptr, nullptr },
-    { "Cone", nullptr, nullptr },
-    { "Anchor", nullptr, nullptr },
-    { "Arc2D", nullptr, nullptr },
-    { "ArcClose2D", nullptr, nullptr },
-    { "AudioClip", nullptr, nullptr },
-    { "Background", nullptr, nullptr },
-    { "Billboard", nullptr, nullptr },
-    { "BooleanFilter", nullptr, nullptr },
-    { "BooleanSequencer", nullptr, nullptr },
-    { "BooleanToggle", nullptr, nullptr },
-    { "BooleanTrigger", nullptr, nullptr },
-    { "Circle2D", nullptr, nullptr },
-    { "Collision", nullptr, nullptr },
-    { "ColorInterpolator", nullptr, nullptr },
-    { "Contour2D", nullptr, nullptr },
-    { "ContourPolyline2D", nullptr, nullptr },
-    { "CoordinateDouble", nullptr, nullptr },
-    { "CoordinateInterpolator", nullptr, nullptr },
-    { "CoordinateInterpolator2D", nullptr, nullptr },
-    { "Cylinder", nullptr, nullptr },
-    { "CylinderSensor", nullptr, nullptr },
-    { "DirectionalLight", nullptr, nullptr },
-    { "Disk2D", nullptr, nullptr },
-    { "EXPORT", nullptr, nullptr },
-    { "ElevationGrid", nullptr, nullptr },
-    { "EspduTransform", nullptr, nullptr },
-    { "ExternProtoDeclare", nullptr, nullptr },
-    { "Extrusion", nullptr, nullptr },
-    { "FillProperties", nullptr, nullptr },
-    { "Fog", nullptr, nullptr },
-    { "FontStyle", nullptr, nullptr },
-    { "GeoCoordinate", nullptr, nullptr },
-    { "GeoElevationGrid", nullptr, nullptr },
-    { "GeoLOD", nullptr, nullptr },
-    { "GeoLocation", nullptr, nullptr },
-    { "GeoMetadata", nullptr, nullptr },
-    { "GeoOrigin", nullptr, nullptr },
-    { "GeoPositionInterpolator", nullptr, nullptr },
-    { "GeoTouchSensor", nullptr, nullptr },
-    { "GeoViewpoint", nullptr, nullptr },
-    { "HAnimDisplacer", nullptr, nullptr },
-    { "HAnimHumanoid", nullptr, nullptr },
-    { "HAnimJoint", nullptr, nullptr },
-    { "HAnimSegment", nullptr, nullptr },
-    { "HAnimSite", nullptr, nullptr },
-    { "IMPORT", nullptr, nullptr },
-    { "IS", nullptr, nullptr },
-    { "Inline", nullptr, nullptr },
-    { "IntegerSequencer", nullptr, nullptr },
-    { "IntegerTrigger", nullptr, nullptr },
-    { "KeySensor", nullptr, nullptr },
-    { "LineProperties", nullptr, nullptr },
-    { "LineSet", nullptr, nullptr },
-    { "LoadSensor", nullptr, nullptr },
-    { "MetadataDouble", nullptr, nullptr },
-    { "MetadataFloat", nullptr, nullptr },
-    { "MetadataInteger", nullptr, nullptr },
-    { "MetadataSet", nullptr, nullptr },
-    { "MetadataString", nullptr, nullptr },
-    { "MovieTexture", nullptr, nullptr },
-    { "NavigationInfo", nullptr, nullptr },
-    { "NormalInterpolator", nullptr, nullptr },
-    { "NurbsCurve", nullptr, nullptr },
-    { "NurbsCurve2D", nullptr, nullptr },
-    { "NurbsOrientationInterpolator", nullptr, nullptr },
-    { "NurbsPatchSurface", nullptr, nullptr },
-    { "NurbsPositionInterpolator", nullptr, nullptr },
-    { "NurbsSet", nullptr, nullptr },
-    { "NurbsSurfaceInterpolator", nullptr, nullptr },
-    { "NurbsSweptSurface", nullptr, nullptr },
-    { "NurbsSwungSurface", nullptr, nullptr },
-    { "NurbsTextureCoordinate", nullptr, nullptr },
-    { "NurbsTrimmedSurface", nullptr, nullptr },
-    { "OrientationInterpolator", nullptr, nullptr },
-    { "PixelTexture", nullptr, nullptr },
-    { "PlaneSensor", nullptr, nullptr },
-    { "PointLight", nullptr, nullptr },
-    { "Polyline2D", nullptr, nullptr },
-    { "Polypoint2D", nullptr, nullptr },
-    { "PositionInterpolator", nullptr, nullptr },
-    { "PositionInterpolator2D", nullptr, nullptr },
-    { "ProtoBody", nullptr, nullptr },
-    { "ProtoDeclare", nullptr, nullptr },
-    { "ProtoInterface", nullptr, nullptr },
-    { "ProximitySensor", nullptr, nullptr },
-    { "ReceiverPdu", nullptr, nullptr },
-    { "Rectangle2D", nullptr, nullptr },
-    { "ScalarInterpolator", nullptr, nullptr },
-    { "Scene", nullptr, nullptr },
-    { "SignalPdu", nullptr, nullptr },
-    { "Sound", nullptr, nullptr },
-    { "SphereSensor", nullptr, nullptr },
-    { "SpotLight", nullptr, nullptr },
-    { "StringSensor", nullptr, nullptr },
-    { "Text", nullptr, nullptr },
-    { "TextureBackground", nullptr, nullptr },
-    { "TextureCoordinateGenerator", nullptr, nullptr },
-    { "TimeSensor", nullptr, nullptr },
-    { "TimeTrigger", nullptr, nullptr },
-    { "TouchSensor", nullptr, nullptr },
-    { "TransmitterPdu", nullptr, nullptr },
-    { "TriangleFanSet", nullptr, nullptr },
-    { "TriangleSet", nullptr, nullptr },
-    { "TriangleSet2D", nullptr, nullptr },
-    { "TriangleStripSet", nullptr, nullptr },
-    { "Viewpoint", nullptr, nullptr },
-    { "VisibilitySensor", nullptr, nullptr },
-    { "WorldInfo", nullptr, nullptr },
-    { "X3D", nullptr, nullptr },
-    { "component", nullptr, nullptr },
-    { "connect", nullptr, nullptr },
-    { "field", nullptr, nullptr },
-    { "head", nullptr, nullptr },
-    { "humanoidBodyType", nullptr, nullptr },
-    { "meta", nullptr, nullptr },
-    { "CADAssembly", nullptr, nullptr },
-    { "CADFace", nullptr, nullptr },
-    { "CADLayer", nullptr, nullptr },
-    { "CADPart", nullptr, nullptr },
-    { "ComposedCubeMapTexture", nullptr, nullptr },
-    { "ComposedShader", nullptr, nullptr },
-    { "ComposedTexture3D", nullptr, nullptr },
-    { "FloatVertexAttribute", nullptr, nullptr },
-    { "FogCoordinate", nullptr, nullptr },
-    { "GeneratedCubeMapTexture", nullptr, nullptr },
-    { "ImageCubeMapTexture", nullptr, nullptr },
-    { "ImageTexture3D", nullptr, nullptr },
-    { "IndexedQuadSet", nullptr, nullptr },
-    { "LocalFog", nullptr, nullptr },
-    { "Matrix3VertexAttribute", nullptr, nullptr },
-    { "Matrix4VertexAttribute", nullptr, nullptr },
-    { "PackagedShader", nullptr, nullptr },
-    { "PixelTexture3D", nullptr, nullptr },
-    { "ProgramShader", nullptr, nullptr },
-    { "QuadSet", nullptr, nullptr },
-    { "ShaderPart", nullptr, nullptr },
-    { "ShaderProgram", nullptr, nullptr },
-    { "TextureCoordinate3D", nullptr, nullptr },
-    { "TextureCoordinate4D", nullptr, nullptr },
-    { "TextureTransform3D", nullptr, nullptr },
-    { "TextureTransformMatrix3D", nullptr, nullptr },
-    { "BallJoint", nullptr, nullptr },
-    { "BoundedPhysicsModel", nullptr, nullptr },
-    { "ClipPlane", nullptr, nullptr },
-    { "CollidableOffset", nullptr, nullptr },
-    { "CollidableShape", nullptr, nullptr },
-    { "CollisionCollection", nullptr, nullptr },
-    { "CollisionSensor", nullptr, nullptr },
-    { "CollisionSpace", nullptr, nullptr },
-    { "ColorDamper", nullptr, nullptr },
-    { "ConeEmitter", nullptr, nullptr },
-    { "Contact", nullptr, nullptr },
-    { "CoordinateDamper", nullptr, nullptr },
-    { "DISEntityManager", nullptr, nullptr },
-    { "DISEntityTypeMapping", nullptr, nullptr },
-    { "DoubleAxisHingeJoint", nullptr, nullptr },
-    { "EaseInEaseOut", nullptr, nullptr },
-    { "ExplosionEmitter", nullptr, nullptr },
-    { "ForcePhysicsModel", nullptr, nullptr },
-    { "GeoProximitySensor", nullptr, nullptr },
-    { "GeoTransform", nullptr, nullptr },
-    { "Layer", nullptr, nullptr },
-    { "LayerSet", nullptr, nullptr },
-    { "Layout", nullptr, nullptr },
-    { "LayoutGroup", nullptr, nullptr },
-    { "LayoutLayer", nullptr, nullptr },
-    { "LinePickSensor", nullptr, nullptr },
-    { "MotorJoint", nullptr, nullptr },
-    { "OrientationChaser", nullptr, nullptr },
-    { "OrientationDamper", nullptr, nullptr },
-    { "OrthoViewpoint", nullptr, nullptr },
-    { "ParticleSystem", nullptr, nullptr },
-    { "PickableGroup", nullptr, nullptr },
-    { "PointEmitter", nullptr, nullptr },
-    { "PointPickSensor", nullptr, nullptr },
-    { "PolylineEmitter", nullptr, nullptr },
-    { "PositionChaser", nullptr, nullptr },
-    { "PositionChaser2D", nullptr, nullptr },
-    { "PositionDamper", nullptr, nullptr },
-    { "PositionDamper2D", nullptr, nullptr },
-    { "PrimitivePickSensor", nullptr, nullptr },
-    { "RigidBody", nullptr, nullptr },
-    { "RigidBodyCollection", nullptr, nullptr },
-    { "ScalarChaser", nullptr, nullptr },
-    { "ScreenFontStyle", nullptr, nullptr },
-    { "ScreenGroup", nullptr, nullptr },
-    { "SingleAxisHingeJoint", nullptr, nullptr },
-    { "SliderJoint", nullptr, nullptr },
-    { "SplinePositionInterpolator", nullptr, nullptr },
-    { "SplinePositionInterpolator2D", nullptr, nullptr },
-    { "SplineScalarInterpolator", nullptr, nullptr },
-    { "SquadOrientationInterpolator", nullptr, nullptr },
-    { "SurfaceEmitter", nullptr, nullptr },
-    { "TexCoordDamper", nullptr, nullptr },
-    { "TextureProperties", nullptr, nullptr },
-    { "TransformSensor", nullptr, nullptr },
-    { "TwoSidedMaterial", nullptr, nullptr },
-    { "UniversalJoint", nullptr, nullptr },
-    { "ViewpointGroup", nullptr, nullptr },
-    { "Viewport", nullptr, nullptr },
-    { "VolumeEmitter", nullptr, nullptr },
-    { "VolumePickSensor", nullptr, nullptr },
-    { "WindPhysicsModel", nullptr, nullptr }
-};
-
-static const FIQName attributeNameTable_3_2[] = {
-    { "DEF", nullptr, nullptr },
-    { "USE", nullptr, nullptr },
-    { "containerField", nullptr, nullptr },
-    { "fromNode", nullptr, nullptr },
-    { "fromField", nullptr, nullptr },
-    { "toNode", nullptr, nullptr },
-    { "toField", nullptr, nullptr },
-    { "name", nullptr, nullptr },
-    { "value", nullptr, nullptr },
-    { "color", nullptr, nullptr },
-    { "colorIndex", nullptr, nullptr },
-    { "coordIndex", nullptr, nullptr },
-    { "texCoordIndex", nullptr, nullptr },
-    { "normalIndex", nullptr, nullptr },
-    { "colorPerVertex", nullptr, nullptr },
-    { "normalPerVertex", nullptr, nullptr },
-    { "rotation", nullptr, nullptr },
-    { "scale", nullptr, nullptr },
-    { "center", nullptr, nullptr },
-    { "scaleOrientation", nullptr, nullptr },
-    { "translation", nullptr, nullptr },
-    { "url", nullptr, nullptr },
-    { "repeatS", nullptr, nullptr },
-    { "repeatT", nullptr, nullptr },
-    { "point", nullptr, nullptr },
-    { "vector", nullptr, nullptr },
-    { "range", nullptr, nullptr },
-    { "ambientIntensity", nullptr, nullptr },
-    { "diffuseColor", nullptr, nullptr },
-    { "emissiveColor", nullptr, nullptr },
-    { "shininess", nullptr, nullptr },
-    { "specularColor", nullptr, nullptr },
-    { "transparency", nullptr, nullptr },
-    { "whichChoice", nullptr, nullptr },
-    { "index", nullptr, nullptr },
-    { "mode", nullptr, nullptr },
-    { "source", nullptr, nullptr },
-    { "function", nullptr, nullptr },
-    { "alpha", nullptr, nullptr },
-    { "vertexCount", nullptr, nullptr },
-    { "radius", nullptr, nullptr },
-    { "size", nullptr, nullptr },
-    { "height", nullptr, nullptr },
-    { "solid", nullptr, nullptr },
-    { "ccw", nullptr, nullptr },
-    { "key", nullptr, nullptr },
-    { "keyValue", nullptr, nullptr },
-    { "enabled", nullptr, nullptr },
-    { "direction", nullptr, nullptr },
-    { "position", nullptr, nullptr },
-    { "orientation", nullptr, nullptr },
-    { "bboxCenter", nullptr, nullptr },
-    { "bboxSize", nullptr, nullptr },
-    { "AS", nullptr, nullptr },
-    { "InlineDEF", nullptr, nullptr },
-    { "accessType", nullptr, nullptr },
-    { "actionKeyPress", nullptr, nullptr },
-    { "actionKeyRelease", nullptr, nullptr },
-    { "address", nullptr, nullptr },
-    { "altKey", nullptr, nullptr },
-    { "antennaLocation", nullptr, nullptr },
-    { "antennaPatternLength", nullptr, nullptr },
-    { "antennaPatternType", nullptr, nullptr },
-    { "applicationID", nullptr, nullptr },
-    { "articulationParameterArray", nullptr, nullptr },
-    { "articulationParameterChangeIndicatorArray", nullptr, nullptr },
-    { "articulationParameterCount", nullptr, nullptr },
-    { "articulationParameterDesignatorArray", nullptr, nullptr },
-    { "articulationParameterIdPartAttachedArray", nullptr, nullptr },
-    { "articulationParameterTypeArray", nullptr, nullptr },
-    { "attenuation", nullptr, nullptr },
-    { "autoOffset", nullptr, nullptr },
-    { "avatarSize", nullptr, nullptr },
-    { "axisOfRotation", nullptr, nullptr },
-    { "backUrl", nullptr, nullptr },
-    { "beamWidth", nullptr, nullptr },
-    { "beginCap", nullptr, nullptr },
-    { "bindTime", nullptr, nullptr },
-    { "bottom", nullptr, nullptr },
-    { "bottomRadius", nullptr, nullptr },
-    { "bottomUrl", nullptr, nullptr },
-    { "centerOfMass", nullptr, nullptr },
-    { "centerOfRotation", nullptr, nullptr },
-    { "child1Url", nullptr, nullptr },
-    { "child2Url", nullptr, nullptr },
-    { "child3Url", nullptr, nullptr },
-    { "child4Url", nullptr, nullptr },
-    { "class", nullptr, nullptr },
-    { "closureType", nullptr, nullptr },
-    { "collideTime", nullptr, nullptr },
-    { "content", nullptr, nullptr },
-    { "controlKey", nullptr, nullptr },
-    { "controlPoint", nullptr, nullptr },
-    { "convex", nullptr, nullptr },
-    { "coordinateSystem", nullptr, nullptr },
-    { "copyright", nullptr, nullptr },
-    { "creaseAngle", nullptr, nullptr },
-    { "crossSection", nullptr, nullptr },
-    { "cryptoKeyID", nullptr, nullptr },
-    { "cryptoSystem", nullptr, nullptr },
-    { "cutOffAngle", nullptr, nullptr },
-    { "cycleInterval", nullptr, nullptr },
-    { "cycleTime", nullptr, nullptr },
-    { "data", nullptr, nullptr },
-    { "dataFormat", nullptr, nullptr },
-    { "dataLength", nullptr, nullptr },
-    { "dataUrl", nullptr, nullptr },
-    { "date", nullptr, nullptr },
-    { "deadReckoning", nullptr, nullptr },
-    { "deletionAllowed", nullptr, nullptr },
-    { "description", nullptr, nullptr },
-    { "detonateTime", nullptr, nullptr },
-    { "dir", nullptr, nullptr },
-    { "directOutput", nullptr, nullptr },
-    { "diskAngle", nullptr, nullptr },
-    { "displacements", nullptr, nullptr },
-    { "documentation", nullptr, nullptr },
-    { "elapsedTime", nullptr, nullptr },
-    { "ellipsoid", nullptr, nullptr },
-    { "encodingScheme", nullptr, nullptr },
-    { "endAngle", nullptr, nullptr },
-    { "endCap", nullptr, nullptr },
-    { "enterTime", nullptr, nullptr },
-    { "enteredText", nullptr, nullptr },
-    { "entityCategory", nullptr, nullptr },
-    { "entityCountry", nullptr, nullptr },
-    { "entityDomain", nullptr, nullptr },
-    { "entityExtra", nullptr, nullptr },
-    { "entityID", nullptr, nullptr },
-    { "entityKind", nullptr, nullptr },
-    { "entitySpecific", nullptr, nullptr },
-    { "entitySubCategory", nullptr, nullptr },
-    { "exitTime", nullptr, nullptr },
-    { "extent", nullptr, nullptr },
-    { "family", nullptr, nullptr },
-    { "fanCount", nullptr, nullptr },
-    { "fieldOfView", nullptr, nullptr },
-    { "filled", nullptr, nullptr },
-    { "finalText", nullptr, nullptr },
-    { "fireMissionIndex", nullptr, nullptr },
-    { "fired1", nullptr, nullptr },
-    { "fired2", nullptr, nullptr },
-    { "firedTime", nullptr, nullptr },
-    { "firingRange", nullptr, nullptr },
-    { "firingRate", nullptr, nullptr },
-    { "fogType", nullptr, nullptr },
-    { "forceID", nullptr, nullptr },
-    { "frequency", nullptr, nullptr },
-    { "frontUrl", nullptr, nullptr },
-    { "fuse", nullptr, nullptr },
-    { "geoCoords", nullptr, nullptr },
-    { "geoGridOrigin", nullptr, nullptr },
-    { "geoSystem", nullptr, nullptr },
-    { "groundAngle", nullptr, nullptr },
-    { "groundColor", nullptr, nullptr },
-    { "hatchColor", nullptr, nullptr },
-    { "hatchStyle", nullptr, nullptr },
-    { "hatched", nullptr, nullptr },
-    { "headlight", nullptr, nullptr },
-    { "horizontal", nullptr, nullptr },
-    { "horizontalDatum", nullptr, nullptr },
-    { "http-equiv", nullptr, nullptr },
-    { "image", nullptr, nullptr },
-    { "importedDEF", nullptr, nullptr },
-    { "info", nullptr, nullptr },
-    { "innerRadius", nullptr, nullptr },
-    { "inputFalse", nullptr, nullptr },
-    { "inputNegate", nullptr, nullptr },
-    { "inputSource", nullptr, nullptr },
-    { "inputTrue", nullptr, nullptr },
-    { "integerKey", nullptr, nullptr },
-    { "intensity", nullptr, nullptr },
-    { "jump", nullptr, nullptr },
-    { "justify", nullptr, nullptr },
-    { "keyPress", nullptr, nullptr },
-    { "keyRelease", nullptr, nullptr },
-    { "knot", nullptr, nullptr },
-    { "lang", nullptr, nullptr },
-    { "language", nullptr, nullptr },
-    { "leftToRight", nullptr, nullptr },
-    { "leftUrl", nullptr, nullptr },
-    { "length", nullptr, nullptr },
-    { "lengthOfModulationParameters", nullptr, nullptr },
-    { "level", nullptr, nullptr },
-    { "limitOrientation", nullptr, nullptr },
-    { "lineSegments", nullptr, nullptr },
-    { "linearAcceleration", nullptr, nullptr },
-    { "linearVelocity", nullptr, nullptr },
-    { "linetype", nullptr, nullptr },
-    { "linewidthScaleFactor", nullptr, nullptr },
-    { "llimit", nullptr, nullptr },
-    { "load", nullptr, nullptr },
-    { "loadTime", nullptr, nullptr },
-    { "localDEF", nullptr, nullptr },
-    { "location", nullptr, nullptr },
-    { "loop", nullptr, nullptr },
-    { "marking", nullptr, nullptr },
-    { "mass", nullptr, nullptr },
-    { "maxAngle", nullptr, nullptr },
-    { "maxBack", nullptr, nullptr },
-    { "maxExtent", nullptr, nullptr },
-    { "maxFront", nullptr, nullptr },
-    { "maxPosition", nullptr, nullptr },
-    { "metadataFormat", nullptr, nullptr },
-    { "minAngle", nullptr, nullptr },
-    { "minBack", nullptr, nullptr },
-    { "minFront", nullptr, nullptr },
-    { "minPosition", nullptr, nullptr },
-    { "modulationTypeDetail", nullptr, nullptr },
-    { "modulationTypeMajor", nullptr, nullptr },
-    { "modulationTypeSpreadSpectrum", nullptr, nullptr },
-    { "modulationTypeSystem", nullptr, nullptr },
-    { "momentsOfInertia", nullptr, nullptr },
-    { "multicastRelayHost", nullptr, nullptr },
-    { "multicastRelayPort", nullptr, nullptr },
-    { "munitionApplicationID", nullptr, nullptr },
-    { "munitionEndPoint", nullptr, nullptr },
-    { "munitionEntityID", nullptr, nullptr },
-    { "munitionQuantity", nullptr, nullptr },
-    { "munitionSiteID", nullptr, nullptr },
-    { "munitionStartPoint", nullptr, nullptr },
-    { "mustEvaluate", nullptr, nullptr },
-    { "navType", nullptr, nullptr },
-    { "networkMode", nullptr, nullptr },
-    { "next", nullptr, nullptr },
-    { "nodeField", nullptr, nullptr },
-    { "offset", nullptr, nullptr },
-    { "on", nullptr, nullptr },
-    { "order", nullptr, nullptr },
-    { "originator", nullptr, nullptr },
-    { "outerRadius", nullptr, nullptr },
-    { "parameter", nullptr, nullptr },
-    { "pauseTime", nullptr, nullptr },
-    { "pitch", nullptr, nullptr },
-    { "points", nullptr, nullptr },
-    { "port", nullptr, nullptr },
-    { "power", nullptr, nullptr },
-    { "previous", nullptr, nullptr },
-    { "priority", nullptr, nullptr },
-    { "profile", nullptr, nullptr },
-    { "progress", nullptr, nullptr },
-    { "protoField", nullptr, nullptr },
-    { "radioEntityTypeCategory", nullptr, nullptr },
-    { "radioEntityTypeCountry", nullptr, nullptr },
-    { "radioEntityTypeDomain", nullptr, nullptr },
-    { "radioEntityTypeKind", nullptr, nullptr },
-    { "radioEntityTypeNomenclature", nullptr, nullptr },
-    { "radioEntityTypeNomenclatureVersion", nullptr, nullptr },
-    { "radioID", nullptr, nullptr },
-    { "readInterval", nullptr, nullptr },
-    { "receivedPower", nullptr, nullptr },
-    { "receiverState", nullptr, nullptr },
-    { "reference", nullptr, nullptr },
-    { "relativeAntennaLocation", nullptr, nullptr },
-    { "resolution", nullptr, nullptr },
-    { "resumeTime", nullptr, nullptr },
-    { "rightUrl", nullptr, nullptr },
-    { "rootUrl", nullptr, nullptr },
-    { "rotateYUp", nullptr, nullptr },
-    { "rtpHeaderExpected", nullptr, nullptr },
-    { "sampleRate", nullptr, nullptr },
-    { "samples", nullptr, nullptr },
-    { "shiftKey", nullptr, nullptr },
-    { "side", nullptr, nullptr },
-    { "siteID", nullptr, nullptr },
-    { "skinCoordIndex", nullptr, nullptr },
-    { "skinCoordWeight", nullptr, nullptr },
-    { "skyAngle", nullptr, nullptr },
-    { "skyColor", nullptr, nullptr },
-    { "spacing", nullptr, nullptr },
-    { "spatialize", nullptr, nullptr },
-    { "speed", nullptr, nullptr },
-    { "speedFactor", nullptr, nullptr },
-    { "spine", nullptr, nullptr },
-    { "startAngle", nullptr, nullptr },
-    { "startTime", nullptr, nullptr },
-    { "stiffness", nullptr, nullptr },
-    { "stopTime", nullptr, nullptr },
-    { "string", nullptr, nullptr },
-    { "stripCount", nullptr, nullptr },
-    { "style", nullptr, nullptr },
-    { "summary", nullptr, nullptr },
-    { "tdlType", nullptr, nullptr },
-    { "tessellation", nullptr, nullptr },
-    { "tessellationScale", nullptr, nullptr },
-    { "time", nullptr, nullptr },
-    { "timeOut", nullptr, nullptr },
-    { "timestamp", nullptr, nullptr },
-    { "title", nullptr, nullptr },
-    { "toggle", nullptr, nullptr },
-    { "top", nullptr, nullptr },
-    { "topToBottom", nullptr, nullptr },
-    { "topUrl", nullptr, nullptr },
-    { "touchTime", nullptr, nullptr },
-    { "transmitFrequencyBandwidth", nullptr, nullptr },
-    { "transmitState", nullptr, nullptr },
-    { "transmitterApplicationID", nullptr, nullptr },
-    { "transmitterEntityID", nullptr, nullptr },
-    { "transmitterRadioID", nullptr, nullptr },
-    { "transmitterSiteID", nullptr, nullptr },
-    { "transparent", nullptr, nullptr },
-    { "triggerTime", nullptr, nullptr },
-    { "triggerTrue", nullptr, nullptr },
-    { "triggerValue", nullptr, nullptr },
-    { "type", nullptr, nullptr },
-    { "uDimension", nullptr, nullptr },
-    { "uKnot", nullptr, nullptr },
-    { "uOrder", nullptr, nullptr },
-    { "uTessellation", nullptr, nullptr },
-    { "ulimit", nullptr, nullptr },
-    { "vDimension", nullptr, nullptr },
-    { "vKnot", nullptr, nullptr },
-    { "vOrder", nullptr, nullptr },
-    { "vTessellation", nullptr, nullptr },
-    { "version", nullptr, nullptr },
-    { "verticalDatum", nullptr, nullptr },
-    { "vertices", nullptr, nullptr },
-    { "visibilityLimit", nullptr, nullptr },
-    { "visibilityRange", nullptr, nullptr },
-    { "warhead", nullptr, nullptr },
-    { "weight", nullptr, nullptr },
-    { "whichGeometry", nullptr, nullptr },
-    { "writeInterval", nullptr, nullptr },
-    { "xDimension", nullptr, nullptr },
-    { "xSpacing", nullptr, nullptr },
-    { "yScale", nullptr, nullptr },
-    { "zDimension", nullptr, nullptr },
-    { "zSpacing", nullptr, nullptr },
-    { "visible", nullptr, nullptr },
-    { "repeatR", nullptr, nullptr },
-    { "texture", nullptr, nullptr },
-    { "back", nullptr, nullptr },
-    { "front", nullptr, nullptr },
-    { "left", nullptr, nullptr },
-    { "right", nullptr, nullptr },
-    { "parts", nullptr, nullptr },
-    { "isSelected", nullptr, nullptr },
-    { "isValid", nullptr, nullptr },
-    { "numComponents", nullptr, nullptr },
-    { "depth", nullptr, nullptr },
-    { "update", nullptr, nullptr },
-    { "fogCoord", nullptr, nullptr },
-    { "texCoord", nullptr, nullptr },
-    { "activate", nullptr, nullptr },
-    { "programs", nullptr, nullptr },
-    { "matrix", nullptr, nullptr },
-    { "anchorPoint", nullptr, nullptr },
-    { "body1", nullptr, nullptr },
-    { "body2", nullptr, nullptr },
-    { "mustOutput", nullptr, nullptr },
-    { "body1AnchorPoint", nullptr, nullptr },
-    { "body2AnchorPoint", nullptr, nullptr },
-    { "plane", nullptr, nullptr },
-    { "appliedParameters", nullptr, nullptr },
-    { "bounce", nullptr, nullptr },
-    { "frictionCoefficients", nullptr, nullptr },
-    { "minBounceSpeed", nullptr, nullptr },
-    { "slipFactors", nullptr, nullptr },
-    { "softnessConstantForceMix", nullptr, nullptr },
-    { "softnessErrorCorrection", nullptr, nullptr },
-    { "surfaceSpeed", nullptr, nullptr },
-    { "isActive", nullptr, nullptr },
-    { "useGeometry", nullptr, nullptr },
-    { "set_destination", nullptr, nullptr },
-    { "set_value", nullptr, nullptr },
-    { "tau", nullptr, nullptr },
-    { "tolerance", nullptr, nullptr },
-    { "value_changed", nullptr, nullptr },
-    { "initialDestination", nullptr, nullptr },
-    { "initialValue", nullptr, nullptr },
-    { "angle", nullptr, nullptr },
-    { "variation", nullptr, nullptr },
-    { "surfaceArea", nullptr, nullptr },
-    { "frictionDirection", nullptr, nullptr },
-    { "slipCoefficients", nullptr, nullptr },
-    { "category", nullptr, nullptr },
-    { "country", nullptr, nullptr },
-    { "domain", nullptr, nullptr },
-    { "extra", nullptr, nullptr },
-    { "kind", nullptr, nullptr },
-    { "specific", nullptr, nullptr },
-    { "subcategory", nullptr, nullptr },
-    { "axis1", nullptr, nullptr },
-    { "axis2", nullptr, nullptr },
-    { "desiredAngularVelocity1", nullptr, nullptr },
-    { "desiredAngularVelocity2", nullptr, nullptr },
-    { "maxAngle1", nullptr, nullptr },
-    { "maxTorque1", nullptr, nullptr },
-    { "maxTorque2", nullptr, nullptr },
-    { "minAngle1", nullptr, nullptr },
-    { "stopBounce1", nullptr, nullptr },
-    { "stopConstantForceMix1", nullptr, nullptr },
-    { "stopErrorCorrection1", nullptr, nullptr },
-    { "suspensionErrorCorrection", nullptr, nullptr },
-    { "suspensionForce", nullptr, nullptr },
-    { "body1Axis", nullptr, nullptr },
-    { "body2Axis", nullptr, nullptr },
-    { "hinge1Angle", nullptr, nullptr },
-    { "hinge1AngleRate", nullptr, nullptr },
-    { "hinge2Angle", nullptr, nullptr },
-    { "hinge2AngleRate", nullptr, nullptr },
-    { "set_fraction", nullptr, nullptr },
-    { "easeInEaseOut", nullptr, nullptr },
-    { "modifiedFraction_changed", nullptr, nullptr },
-    { "force", nullptr, nullptr },
-    { "geoCenter", nullptr, nullptr },
-    { "centerOfRotation_changed", nullptr, nullptr },
-    { "geoCoord_changed", nullptr, nullptr },
-    { "orientation_changed", nullptr, nullptr },
-    { "position_changed", nullptr, nullptr },
-    { "isPickable", nullptr, nullptr },
-    { "viewport", nullptr, nullptr },
-    { "activeLayer", nullptr, nullptr },
-    { "align", nullptr, nullptr },
-    { "offsetUnits", nullptr, nullptr },
-    { "scaleMode", nullptr, nullptr },
-    { "sizeUnits", nullptr, nullptr },
-    { "layout", nullptr, nullptr },
-    { "objectType", nullptr, nullptr },
-    { "pickedNormal", nullptr, nullptr },
-    { "pickedPoint", nullptr, nullptr },
-    { "pickedTextureCoordinate", nullptr, nullptr },
-    { "intersectionType", nullptr, nullptr },
-    { "sortOrder", nullptr, nullptr },
-    { "axis1Angle", nullptr, nullptr },
-    { "axis1Torque", nullptr, nullptr },
-    { "axis2Angle", nullptr, nullptr },
-    { "axis2Torque", nullptr, nullptr },
-    { "axis3Angle", nullptr, nullptr },
-    { "axis3Torque", nullptr, nullptr },
-    { "enabledAxies", nullptr, nullptr },
-    { "motor1Axis", nullptr, nullptr },
-    { "motor2Axis", nullptr, nullptr },
-    { "motor3Axis", nullptr, nullptr },
-    { "stop1Bounce", nullptr, nullptr },
-    { "stop1ErrorCorrection", nullptr, nullptr },
-    { "stop2Bounce", nullptr, nullptr },
-    { "stop2ErrorCorrection", nullptr, nullptr },
-    { "stop3Bounce", nullptr, nullptr },
-    { "stop3ErrorCorrection", nullptr, nullptr },
-    { "motor1Angle", nullptr, nullptr },
-    { "motor1AngleRate", nullptr, nullptr },
-    { "motor2Angle", nullptr, nullptr },
-    { "motor2AngleRate", nullptr, nullptr },
-    { "motor3Angle", nullptr, nullptr },
-    { "motor3AngleRate", nullptr, nullptr },
-    { "autoCalc", nullptr, nullptr },
-    { "duration", nullptr, nullptr },
-    { "retainUserOffsets", nullptr, nullptr },
-    { "isBound", nullptr, nullptr },
-    { "appearance", nullptr, nullptr },
-    { "createParticles", nullptr, nullptr },
-    { "lifetimeVariation", nullptr, nullptr },
-    { "maxParticles", nullptr, nullptr },
-    { "particleLifetime", nullptr, nullptr },
-    { "particleSize", nullptr, nullptr },
-    { "colorKey", nullptr, nullptr },
-    { "geometryType", nullptr, nullptr },
-    { "texCoordKey", nullptr, nullptr },
-    { "pickable", nullptr, nullptr },
-    { "angularDampingFactor", nullptr, nullptr },
-    { "angularVelocity", nullptr, nullptr },
-    { "autoDamp", nullptr, nullptr },
-    { "autoDisable", nullptr, nullptr },
-    { "disableAngularSpeed", nullptr, nullptr },
-    { "disableLinearSpeed", nullptr, nullptr },
-    { "disableTime", nullptr, nullptr },
-    { "finiteRotationAxis", nullptr, nullptr },
-    { "fixed", nullptr, nullptr },
-    { "forces", nullptr, nullptr },
-    { "inertia", nullptr, nullptr },
-    { "linearDampingFactor", nullptr, nullptr },
-    { "torques", nullptr, nullptr },
-    { "useFiniteRotation", nullptr, nullptr },
-    { "useGlobalForce", nullptr, nullptr },
-    { "constantForceMix", nullptr, nullptr },
-    { "constantSurfaceThickness", nullptr, nullptr },
-    { "errorCorrection", nullptr, nullptr },
-    { "iterations", nullptr, nullptr },
-    { "maxCorrectionSpeed", nullptr, nullptr },
-    { "preferAccuracy", nullptr, nullptr },
-    { "pointSize", nullptr, nullptr },
-    { "stopBounce", nullptr, nullptr },
-    { "stopErrorCorrection", nullptr, nullptr },
-    { "angleRate", nullptr, nullptr },
-    { "maxSeparation", nullptr, nullptr },
-    { "minSeparation", nullptr, nullptr },
-    { "separation", nullptr, nullptr },
-    { "separationRate", nullptr, nullptr },
-    { "closed", nullptr, nullptr },
-    { "keyVelocity", nullptr, nullptr },
-    { "normalizeVelocity", nullptr, nullptr },
-    { "surface", nullptr, nullptr },
-    { "anisotropicDegree", nullptr, nullptr },
-    { "borderColor", nullptr, nullptr },
-    { "borderWidth", nullptr, nullptr },
-    { "boundaryModeS", nullptr, nullptr },
-    { "boundaryModeT", nullptr, nullptr },
-    { "boundaryModeR", nullptr, nullptr },
-    { "magnificationFilter", nullptr, nullptr },
-    { "minificationFilter", nullptr, nullptr },
-    { "textureCompression", nullptr, nullptr },
-    { "texturePriority", nullptr, nullptr },
-    { "generateMipMaps", nullptr, nullptr },
-    { "targetObject", nullptr, nullptr },
-    { "backAmbientIntensity", nullptr, nullptr },
-    { "backDiffuseColor", nullptr, nullptr },
-    { "backEmissiveColor", nullptr, nullptr },
-    { "backShininess", nullptr, nullptr },
-    { "backSpecularColor", nullptr, nullptr },
-    { "separateBackColor", nullptr, nullptr },
-    { "displayed", nullptr, nullptr },
-    { "clipBoundary", nullptr, nullptr },
-    { "internal", nullptr, nullptr },
-    { "gustiness", nullptr, nullptr },
-    { "turbulence", nullptr, nullptr }
-};
-
-FIVocabulary X3D_vocabulary_3_2 = {
-    nullptr, 0,
-    encodingAlgorithmTable_3_2, 8,
-    nullptr, 0,
-    nullptr, 0,
-    nullptr, 0,
-    nullptr, 0,
-    nullptr, 0,
-    attributeValueTable_3_2, 2,
-    nullptr, 0,
-    nullptr, 0,
-    elementNameTable_3_2, 233,
-    attributeNameTable_3_2, 516
-};
-
-static const char *encodingAlgorithmTable_3_3[] = {
-    "encoder://web3d.org/QuantizedFloatArrayEncoder",
-    "encoder://web3d.org/DeltazlibIntArrayEncoder",
-    "encoder://web3d.org/QuantizedzlibFloatArrayEncoder",
-    "encoder://web3d.org/zlibFloatArrayEncoder",
-    "encoder://web3d.org/QuantizedDoubleArrayEncoder",
-    "encoder://web3d.org/zlibDoubleArrayEncoder",
-    "encoder://web3d.org/QuantizedzlibDoubleArrayEncoder",
-    "encoder://web3d.org/RangeIntArrayEncoder"
-};
-
-static const std::shared_ptr<const FIValue> attributeValueTable_3_3[] = {
-    FIStringValue::create("false"),
-    FIStringValue::create("true")
-};
-
-static const FIQName elementNameTable_3_3[] = {
-    { "Shape", nullptr, nullptr },
-    { "Appearance", nullptr, nullptr },
-    { "Material", nullptr, nullptr },
-    { "IndexedFaceSet", nullptr, nullptr },
-    { "ProtoInstance", nullptr, nullptr },
-    { "Transform", nullptr, nullptr },
-    { "ImageTexture", nullptr, nullptr },
-    { "TextureTransform", nullptr, nullptr },
-    { "Coordinate", nullptr, nullptr },
-    { "Normal", nullptr, nullptr },
-    { "Color", nullptr, nullptr },
-    { "ColorRGBA", nullptr, nullptr },
-    { "TextureCoordinate", nullptr, nullptr },
-    { "ROUTE", nullptr, nullptr },
-    { "fieldValue", nullptr, nullptr },
-    { "Group", nullptr, nullptr },
-    { "LOD", nullptr, nullptr },
-    { "Switch", nullptr, nullptr },
-    { "Script", nullptr, nullptr },
-    { "IndexedTriangleFanSet", nullptr, nullptr },
-    { "IndexedTriangleSet", nullptr, nullptr },
-    { "IndexedTriangleStripSet", nullptr, nullptr },
-    { "MultiTexture", nullptr, nullptr },
-    { "MultiTextureCoordinate", nullptr, nullptr },
-    { "MultiTextureTransform", nullptr, nullptr },
-    { "IndexedLineSet", nullptr, nullptr },
-    { "PointSet", nullptr, nullptr },
-    { "StaticGroup", nullptr, nullptr },
-    { "Sphere", nullptr, nullptr },
-    { "Box", nullptr, nullptr },
-    { "Cone", nullptr, nullptr },
-    { "Anchor", nullptr, nullptr },
-    { "Arc2D", nullptr, nullptr },
-    { "ArcClose2D", nullptr, nullptr },
-    { "AudioClip", nullptr, nullptr },
-    { "Background", nullptr, nullptr },
-    { "Billboard", nullptr, nullptr },
-    { "BooleanFilter", nullptr, nullptr },
-    { "BooleanSequencer", nullptr, nullptr },
-    { "BooleanToggle", nullptr, nullptr },
-    { "BooleanTrigger", nullptr, nullptr },
-    { "Circle2D", nullptr, nullptr },
-    { "Collision", nullptr, nullptr },
-    { "ColorInterpolator", nullptr, nullptr },
-    { "Contour2D", nullptr, nullptr },
-    { "ContourPolyline2D", nullptr, nullptr },
-    { "CoordinateDouble", nullptr, nullptr },
-    { "CoordinateInterpolator", nullptr, nullptr },
-    { "CoordinateInterpolator2D", nullptr, nullptr },
-    { "Cylinder", nullptr, nullptr },
-    { "CylinderSensor", nullptr, nullptr },
-    { "DirectionalLight", nullptr, nullptr },
-    { "Disk2D", nullptr, nullptr },
-    { "EXPORT", nullptr, nullptr },
-    { "ElevationGrid", nullptr, nullptr },
-    { "EspduTransform", nullptr, nullptr },
-    { "ExternProtoDeclare", nullptr, nullptr },
-    { "Extrusion", nullptr, nullptr },
-    { "FillProperties", nullptr, nullptr },
-    { "Fog", nullptr, nullptr },
-    { "FontStyle", nullptr, nullptr },
-    { "GeoCoordinate", nullptr, nullptr },
-    { "GeoElevationGrid", nullptr, nullptr },
-    { "GeoLOD", nullptr, nullptr },
-    { "GeoLocation", nullptr, nullptr },
-    { "GeoMetadata", nullptr, nullptr },
-    { "GeoOrigin", nullptr, nullptr },
-    { "GeoPositionInterpolator", nullptr, nullptr },
-    { "GeoTouchSensor", nullptr, nullptr },
-    { "GeoViewpoint", nullptr, nullptr },
-    { "HAnimDisplacer", nullptr, nullptr },
-    { "HAnimHumanoid", nullptr, nullptr },
-    { "HAnimJoint", nullptr, nullptr },
-    { "HAnimSegment", nullptr, nullptr },
-    { "HAnimSite", nullptr, nullptr },
-    { "IMPORT", nullptr, nullptr },
-    { "IS", nullptr, nullptr },
-    { "Inline", nullptr, nullptr },
-    { "IntegerSequencer", nullptr, nullptr },
-    { "IntegerTrigger", nullptr, nullptr },
-    { "KeySensor", nullptr, nullptr },
-    { "LineProperties", nullptr, nullptr },
-    { "LineSet", nullptr, nullptr },
-    { "LoadSensor", nullptr, nullptr },
-    { "MetadataDouble", nullptr, nullptr },
-    { "MetadataFloat", nullptr, nullptr },
-    { "MetadataInteger", nullptr, nullptr },
-    { "MetadataSet", nullptr, nullptr },
-    { "MetadataString", nullptr, nullptr },
-    { "MovieTexture", nullptr, nullptr },
-    { "NavigationInfo", nullptr, nullptr },
-    { "NormalInterpolator", nullptr, nullptr },
-    { "NurbsCurve", nullptr, nullptr },
-    { "NurbsCurve2D", nullptr, nullptr },
-    { "NurbsOrientationInterpolator", nullptr, nullptr },
-    { "NurbsPatchSurface", nullptr, nullptr },
-    { "NurbsPositionInterpolator", nullptr, nullptr },
-    { "NurbsSet", nullptr, nullptr },
-    { "NurbsSurfaceInterpolator", nullptr, nullptr },
-    { "NurbsSweptSurface", nullptr, nullptr },
-    { "NurbsSwungSurface", nullptr, nullptr },
-    { "NurbsTextureCoordinate", nullptr, nullptr },
-    { "NurbsTrimmedSurface", nullptr, nullptr },
-    { "OrientationInterpolator", nullptr, nullptr },
-    { "PixelTexture", nullptr, nullptr },
-    { "PlaneSensor", nullptr, nullptr },
-    { "PointLight", nullptr, nullptr },
-    { "Polyline2D", nullptr, nullptr },
-    { "Polypoint2D", nullptr, nullptr },
-    { "PositionInterpolator", nullptr, nullptr },
-    { "PositionInterpolator2D", nullptr, nullptr },
-    { "ProtoBody", nullptr, nullptr },
-    { "ProtoDeclare", nullptr, nullptr },
-    { "ProtoInterface", nullptr, nullptr },
-    { "ProximitySensor", nullptr, nullptr },
-    { "ReceiverPdu", nullptr, nullptr },
-    { "Rectangle2D", nullptr, nullptr },
-    { "ScalarInterpolator", nullptr, nullptr },
-    { "Scene", nullptr, nullptr },
-    { "SignalPdu", nullptr, nullptr },
-    { "Sound", nullptr, nullptr },
-    { "SphereSensor", nullptr, nullptr },
-    { "SpotLight", nullptr, nullptr },
-    { "StringSensor", nullptr, nullptr },
-    { "Text", nullptr, nullptr },
-    { "TextureBackground", nullptr, nullptr },
-    { "TextureCoordinateGenerator", nullptr, nullptr },
-    { "TimeSensor", nullptr, nullptr },
-    { "TimeTrigger", nullptr, nullptr },
-    { "TouchSensor", nullptr, nullptr },
-    { "TransmitterPdu", nullptr, nullptr },
-    { "TriangleFanSet", nullptr, nullptr },
-    { "TriangleSet", nullptr, nullptr },
-    { "TriangleSet2D", nullptr, nullptr },
-    { "TriangleStripSet", nullptr, nullptr },
-    { "Viewpoint", nullptr, nullptr },
-    { "VisibilitySensor", nullptr, nullptr },
-    { "WorldInfo", nullptr, nullptr },
-    { "X3D", nullptr, nullptr },
-    { "component", nullptr, nullptr },
-    { "connect", nullptr, nullptr },
-    { "field", nullptr, nullptr },
-    { "head", nullptr, nullptr },
-    { "humanoidBodyType", nullptr, nullptr },
-    { "meta", nullptr, nullptr },
-    { "CADAssembly", nullptr, nullptr },
-    { "CADFace", nullptr, nullptr },
-    { "CADLayer", nullptr, nullptr },
-    { "CADPart", nullptr, nullptr },
-    { "ComposedCubeMapTexture", nullptr, nullptr },
-    { "ComposedShader", nullptr, nullptr },
-    { "ComposedTexture3D", nullptr, nullptr },
-    { "FloatVertexAttribute", nullptr, nullptr },
-    { "FogCoordinate", nullptr, nullptr },
-    { "GeneratedCubeMapTexture", nullptr, nullptr },
-    { "ImageCubeMapTexture", nullptr, nullptr },
-    { "ImageTexture3D", nullptr, nullptr },
-    { "IndexedQuadSet", nullptr, nullptr },
-    { "LocalFog", nullptr, nullptr },
-    { "Matrix3VertexAttribute", nullptr, nullptr },
-    { "Matrix4VertexAttribute", nullptr, nullptr },
-    { "PackagedShader", nullptr, nullptr },
-    { "PixelTexture3D", nullptr, nullptr },
-    { "ProgramShader", nullptr, nullptr },
-    { "QuadSet", nullptr, nullptr },
-    { "ShaderPart", nullptr, nullptr },
-    { "ShaderProgram", nullptr, nullptr },
-    { "TextureCoordinate3D", nullptr, nullptr },
-    { "TextureCoordinate4D", nullptr, nullptr },
-    { "TextureTransform3D", nullptr, nullptr },
-    { "TextureTransformMatrix3D", nullptr, nullptr },
-    { "BallJoint", nullptr, nullptr },
-    { "BoundedPhysicsModel", nullptr, nullptr },
-    { "ClipPlane", nullptr, nullptr },
-    { "CollidableOffset", nullptr, nullptr },
-    { "CollidableShape", nullptr, nullptr },
-    { "CollisionCollection", nullptr, nullptr },
-    { "CollisionSensor", nullptr, nullptr },
-    { "CollisionSpace", nullptr, nullptr },
-    { "ColorDamper", nullptr, nullptr },
-    { "ConeEmitter", nullptr, nullptr },
-    { "Contact", nullptr, nullptr },
-    { "CoordinateDamper", nullptr, nullptr },
-    { "DISEntityManager", nullptr, nullptr },
-    { "DISEntityTypeMapping", nullptr, nullptr },
-    { "DoubleAxisHingeJoint", nullptr, nullptr },
-    { "EaseInEaseOut", nullptr, nullptr },
-    { "ExplosionEmitter", nullptr, nullptr },
-    { "ForcePhysicsModel", nullptr, nullptr },
-    { "GeoProximitySensor", nullptr, nullptr },
-    { "GeoTransform", nullptr, nullptr },
-    { "Layer", nullptr, nullptr },
-    { "LayerSet", nullptr, nullptr },
-    { "Layout", nullptr, nullptr },
-    { "LayoutGroup", nullptr, nullptr },
-    { "LayoutLayer", nullptr, nullptr },
-    { "LinePickSensor", nullptr, nullptr },
-    { "MotorJoint", nullptr, nullptr },
-    { "OrientationChaser", nullptr, nullptr },
-    { "OrientationDamper", nullptr, nullptr },
-    { "OrthoViewpoint", nullptr, nullptr },
-    { "ParticleSystem", nullptr, nullptr },
-    { "PickableGroup", nullptr, nullptr },
-    { "PointEmitter", nullptr, nullptr },
-    { "PointPickSensor", nullptr, nullptr },
-    { "PolylineEmitter", nullptr, nullptr },
-    { "PositionChaser", nullptr, nullptr },
-    { "PositionChaser2D", nullptr, nullptr },
-    { "PositionDamper", nullptr, nullptr },
-    { "PositionDamper2D", nullptr, nullptr },
-    { "PrimitivePickSensor", nullptr, nullptr },
-    { "RigidBody", nullptr, nullptr },
-    { "RigidBodyCollection", nullptr, nullptr },
-    { "ScalarChaser", nullptr, nullptr },
-    { "ScreenFontStyle", nullptr, nullptr },
-    { "ScreenGroup", nullptr, nullptr },
-    { "SingleAxisHingeJoint", nullptr, nullptr },
-    { "SliderJoint", nullptr, nullptr },
-    { "SplinePositionInterpolator", nullptr, nullptr },
-    { "SplinePositionInterpolator2D", nullptr, nullptr },
-    { "SplineScalarInterpolator", nullptr, nullptr },
-    { "SquadOrientationInterpolator", nullptr, nullptr },
-    { "SurfaceEmitter", nullptr, nullptr },
-    { "TexCoordDamper2D", nullptr, nullptr },
-    { "TextureProperties", nullptr, nullptr },
-    { "TransformSensor", nullptr, nullptr },
-    { "TwoSidedMaterial", nullptr, nullptr },
-    { "UniversalJoint", nullptr, nullptr },
-    { "ViewpointGroup", nullptr, nullptr },
-    { "Viewport", nullptr, nullptr },
-    { "VolumeEmitter", nullptr, nullptr },
-    { "VolumePickSensor", nullptr, nullptr },
-    { "WindPhysicsModel", nullptr, nullptr },
-    { "BlendedVolumeStyle", nullptr, nullptr },
-    { "BoundaryEnhancementVolumeStyle", nullptr, nullptr },
-    { "CartoonVolumeStyle", nullptr, nullptr },
-    { "ComposedVolumeStyle", nullptr, nullptr },
-    { "EdgeEnhancementVolumeStyle", nullptr, nullptr },
-    { "IsoSurfaceVolumeData", nullptr, nullptr },
-    { "MetadataBoolean", nullptr, nullptr },
-    { "OpacityMapVolumeStyle", nullptr, nullptr },
-    { "ProjectionVolumeStyle", nullptr, nullptr },
-    { "SegmentedVolumeData", nullptr, nullptr },
-    { "ShadedVolumeStyle", nullptr, nullptr },
-    { "SilhouetteEnhancementVolumeStyle", nullptr, nullptr },
-    { "ToneMappedVolumeStyle", nullptr, nullptr },
-    { "VolumeData", nullptr, nullptr },
-    { "ColorChaser", nullptr, nullptr },
-    { "CoordinateChaser", nullptr, nullptr },
-    { "ScalarDamper", nullptr, nullptr },
-    { "TexCoordChaser2D", nullptr, nullptr },
-    { "unit", nullptr, nullptr }
-};
-
-static const FIQName attributeNameTable_3_3[] = {
-    { "DEF", nullptr, nullptr },
-    { "USE", nullptr, nullptr },
-    { "containerField", nullptr, nullptr },
-    { "fromNode", nullptr, nullptr },
-    { "fromField", nullptr, nullptr },
-    { "toNode", nullptr, nullptr },
-    { "toField", nullptr, nullptr },
-    { "name", nullptr, nullptr },
-    { "value", nullptr, nullptr },
-    { "color", nullptr, nullptr },
-    { "colorIndex", nullptr, nullptr },
-    { "coordIndex", nullptr, nullptr },
-    { "texCoordIndex", nullptr, nullptr },
-    { "normalIndex", nullptr, nullptr },
-    { "colorPerVertex", nullptr, nullptr },
-    { "normalPerVertex", nullptr, nullptr },
-    { "rotation", nullptr, nullptr },
-    { "scale", nullptr, nullptr },
-    { "center", nullptr, nullptr },
-    { "scaleOrientation", nullptr, nullptr },
-    { "translation", nullptr, nullptr },
-    { "url", nullptr, nullptr },
-    { "repeatS", nullptr, nullptr },
-    { "repeatT", nullptr, nullptr },
-    { "point", nullptr, nullptr },
-    { "vector", nullptr, nullptr },
-    { "range", nullptr, nullptr },
-    { "ambientIntensity", nullptr, nullptr },
-    { "diffuseColor", nullptr, nullptr },
-    { "emissiveColor", nullptr, nullptr },
-    { "shininess", nullptr, nullptr },
-    { "specularColor", nullptr, nullptr },
-    { "transparency", nullptr, nullptr },
-    { "whichChoice", nullptr, nullptr },
-    { "index", nullptr, nullptr },
-    { "mode", nullptr, nullptr },
-    { "source", nullptr, nullptr },
-    { "function", nullptr, nullptr },
-    { "alpha", nullptr, nullptr },
-    { "vertexCount", nullptr, nullptr },
-    { "radius", nullptr, nullptr },
-    { "size", nullptr, nullptr },
-    { "height", nullptr, nullptr },
-    { "solid", nullptr, nullptr },
-    { "ccw", nullptr, nullptr },
-    { "key", nullptr, nullptr },
-    { "keyValue", nullptr, nullptr },
-    { "enabled", nullptr, nullptr },
-    { "direction", nullptr, nullptr },
-    { "position", nullptr, nullptr },
-    { "orientation", nullptr, nullptr },
-    { "bboxCenter", nullptr, nullptr },
-    { "bboxSize", nullptr, nullptr },
-    { "AS", nullptr, nullptr },
-    { "InlineDEF", nullptr, nullptr },
-    { "accessType", nullptr, nullptr },
-    { "actionKeyPress", nullptr, nullptr },
-    { "actionKeyRelease", nullptr, nullptr },
-    { "address", nullptr, nullptr },
-    { "altKey", nullptr, nullptr },
-    { "antennaLocation", nullptr, nullptr },
-    { "antennaPatternLength", nullptr, nullptr },
-    { "antennaPatternType", nullptr, nullptr },
-    { "applicationID", nullptr, nullptr },
-    { "articulationParameterArray", nullptr, nullptr },
-    { "articulationParameterChangeIndicatorArray", nullptr, nullptr },
-    { "articulationParameterCount", nullptr, nullptr },
-    { "articulationParameterDesignatorArray", nullptr, nullptr },
-    { "articulationParameterIdPartAttachedArray", nullptr, nullptr },
-    { "articulationParameterTypeArray", nullptr, nullptr },
-    { "attenuation", nullptr, nullptr },
-    { "autoOffset", nullptr, nullptr },
-    { "avatarSize", nullptr, nullptr },
-    { "axisOfRotation", nullptr, nullptr },
-    { "backUrl", nullptr, nullptr },
-    { "beamWidth", nullptr, nullptr },
-    { "beginCap", nullptr, nullptr },
-    { "bindTime", nullptr, nullptr },
-    { "bottom", nullptr, nullptr },
-    { "bottomRadius", nullptr, nullptr },
-    { "bottomUrl", nullptr, nullptr },
-    { "centerOfMass", nullptr, nullptr },
-    { "centerOfRotation", nullptr, nullptr },
-    { "child1Url", nullptr, nullptr },
-    { "child2Url", nullptr, nullptr },
-    { "child3Url", nullptr, nullptr },
-    { "child4Url", nullptr, nullptr },
-    { "class", nullptr, nullptr },
-    { "closureType", nullptr, nullptr },
-    { "collideTime", nullptr, nullptr },
-    { "content", nullptr, nullptr },
-    { "controlKey", nullptr, nullptr },
-    { "controlPoint", nullptr, nullptr },
-    { "convex", nullptr, nullptr },
-    { "coordinateSystem", nullptr, nullptr },
-    { "copyright", nullptr, nullptr },
-    { "creaseAngle", nullptr, nullptr },
-    { "crossSection", nullptr, nullptr },
-    { "cryptoKeyID", nullptr, nullptr },
-    { "cryptoSystem", nullptr, nullptr },
-    { "cutOffAngle", nullptr, nullptr },
-    { "cycleInterval", nullptr, nullptr },
-    { "cycleTime", nullptr, nullptr },
-    { "data", nullptr, nullptr },
-    { "dataFormat", nullptr, nullptr },
-    { "dataLength", nullptr, nullptr },
-    { "dataUrl", nullptr, nullptr },
-    { "date", nullptr, nullptr },
-    { "deadReckoning", nullptr, nullptr },
-    { "deletionAllowed", nullptr, nullptr },
-    { "description", nullptr, nullptr },
-    { "detonateTime", nullptr, nullptr },
-    { "dir", nullptr, nullptr },
-    { "directOutput", nullptr, nullptr },
-    { "diskAngle", nullptr, nullptr },
-    { "displacements", nullptr, nullptr },
-    { "documentation", nullptr, nullptr },
-    { "elapsedTime", nullptr, nullptr },
-    { "ellipsoid", nullptr, nullptr },
-    { "encodingScheme", nullptr, nullptr },
-    { "endAngle", nullptr, nullptr },
-    { "endCap", nullptr, nullptr },
-    { "enterTime", nullptr, nullptr },
-    { "enteredText", nullptr, nullptr },
-    { "entityCategory", nullptr, nullptr },
-    { "entityCountry", nullptr, nullptr },
-    { "entityDomain", nullptr, nullptr },
-    { "entityExtra", nullptr, nullptr },
-    { "entityID", nullptr, nullptr },
-    { "entityKind", nullptr, nullptr },
-    { "entitySpecific", nullptr, nullptr },
-    { "entitySubCategory", nullptr, nullptr },
-    { "exitTime", nullptr, nullptr },
-    { "extent", nullptr, nullptr },
-    { "family", nullptr, nullptr },
-    { "fanCount", nullptr, nullptr },
-    { "fieldOfView", nullptr, nullptr },
-    { "filled", nullptr, nullptr },
-    { "finalText", nullptr, nullptr },
-    { "fireMissionIndex", nullptr, nullptr },
-    { "fired1", nullptr, nullptr },
-    { "fired2", nullptr, nullptr },
-    { "firedTime", nullptr, nullptr },
-    { "firingRange", nullptr, nullptr },
-    { "firingRate", nullptr, nullptr },
-    { "fogType", nullptr, nullptr },
-    { "forceID", nullptr, nullptr },
-    { "frequency", nullptr, nullptr },
-    { "frontUrl", nullptr, nullptr },
-    { "fuse", nullptr, nullptr },
-    { "geoCoords", nullptr, nullptr },
-    { "geoGridOrigin", nullptr, nullptr },
-    { "geoSystem", nullptr, nullptr },
-    { "groundAngle", nullptr, nullptr },
-    { "groundColor", nullptr, nullptr },
-    { "hatchColor", nullptr, nullptr },
-    { "hatchStyle", nullptr, nullptr },
-    { "hatched", nullptr, nullptr },
-    { "headlight", nullptr, nullptr },
-    { "horizontal", nullptr, nullptr },
-    { "horizontalDatum", nullptr, nullptr },
-    { "http-equiv", nullptr, nullptr },
-    { "image", nullptr, nullptr },
-    { "importedDEF", nullptr, nullptr },
-    { "info", nullptr, nullptr },
-    { "innerRadius", nullptr, nullptr },
-    { "inputFalse", nullptr, nullptr },
-    { "inputNegate", nullptr, nullptr },
-    { "inputSource", nullptr, nullptr },
-    { "inputTrue", nullptr, nullptr },
-    { "integerKey", nullptr, nullptr },
-    { "intensity", nullptr, nullptr },
-    { "jump", nullptr, nullptr },
-    { "justify", nullptr, nullptr },
-    { "keyPress", nullptr, nullptr },
-    { "keyRelease", nullptr, nullptr },
-    { "knot", nullptr, nullptr },
-    { "lang", nullptr, nullptr },
-    { "language", nullptr, nullptr },
-    { "leftToRight", nullptr, nullptr },
-    { "leftUrl", nullptr, nullptr },
-    { "length", nullptr, nullptr },
-    { "lengthOfModulationParameters", nullptr, nullptr },
-    { "level", nullptr, nullptr },
-    { "limitOrientation", nullptr, nullptr },
-    { "lineSegments", nullptr, nullptr },
-    { "linearAcceleration", nullptr, nullptr },
-    { "linearVelocity", nullptr, nullptr },
-    { "linetype", nullptr, nullptr },
-    { "linewidthScaleFactor", nullptr, nullptr },
-    { "llimit", nullptr, nullptr },
-    { "load", nullptr, nullptr },
-    { "loadTime", nullptr, nullptr },
-    { "localDEF", nullptr, nullptr },
-    { "location", nullptr, nullptr },
-    { "loop", nullptr, nullptr },
-    { "marking", nullptr, nullptr },
-    { "mass", nullptr, nullptr },
-    { "maxAngle", nullptr, nullptr },
-    { "maxBack", nullptr, nullptr },
-    { "maxExtent", nullptr, nullptr },
-    { "maxFront", nullptr, nullptr },
-    { "maxPosition", nullptr, nullptr },
-    { "metadataFormat", nullptr, nullptr },
-    { "minAngle", nullptr, nullptr },
-    { "minBack", nullptr, nullptr },
-    { "minFront", nullptr, nullptr },
-    { "minPosition", nullptr, nullptr },
-    { "modulationTypeDetail", nullptr, nullptr },
-    { "modulationTypeMajor", nullptr, nullptr },
-    { "modulationTypeSpreadSpectrum", nullptr, nullptr },
-    { "modulationTypeSystem", nullptr, nullptr },
-    { "momentsOfInertia", nullptr, nullptr },
-    { "multicastRelayHost", nullptr, nullptr },
-    { "multicastRelayPort", nullptr, nullptr },
-    { "munitionApplicationID", nullptr, nullptr },
-    { "munitionEndPoint", nullptr, nullptr },
-    { "munitionEntityID", nullptr, nullptr },
-    { "munitionQuantity", nullptr, nullptr },
-    { "munitionSiteID", nullptr, nullptr },
-    { "munitionStartPoint", nullptr, nullptr },
-    { "mustEvaluate", nullptr, nullptr },
-    { "navType", nullptr, nullptr },
-    { "networkMode", nullptr, nullptr },
-    { "next", nullptr, nullptr },
-    { "nodeField", nullptr, nullptr },
-    { "offset", nullptr, nullptr },
-    { "on", nullptr, nullptr },
-    { "order", nullptr, nullptr },
-    { "originator", nullptr, nullptr },
-    { "outerRadius", nullptr, nullptr },
-    { "parameter", nullptr, nullptr },
-    { "pauseTime", nullptr, nullptr },
-    { "pitch", nullptr, nullptr },
-    { "points", nullptr, nullptr },
-    { "port", nullptr, nullptr },
-    { "power", nullptr, nullptr },
-    { "previous", nullptr, nullptr },
-    { "priority", nullptr, nullptr },
-    { "profile", nullptr, nullptr },
-    { "progress", nullptr, nullptr },
-    { "protoField", nullptr, nullptr },
-    { "radioEntityTypeCategory", nullptr, nullptr },
-    { "radioEntityTypeCountry", nullptr, nullptr },
-    { "radioEntityTypeDomain", nullptr, nullptr },
-    { "radioEntityTypeKind", nullptr, nullptr },
-    { "radioEntityTypeNomenclature", nullptr, nullptr },
-    { "radioEntityTypeNomenclatureVersion", nullptr, nullptr },
-    { "radioID", nullptr, nullptr },
-    { "readInterval", nullptr, nullptr },
-    { "receivedPower", nullptr, nullptr },
-    { "receiverState", nullptr, nullptr },
-    { "reference", nullptr, nullptr },
-    { "relativeAntennaLocation", nullptr, nullptr },
-    { "resolution", nullptr, nullptr },
-    { "resumeTime", nullptr, nullptr },
-    { "rightUrl", nullptr, nullptr },
-    { "rootUrl", nullptr, nullptr },
-    { "rotateYUp", nullptr, nullptr },
-    { "rtpHeaderExpected", nullptr, nullptr },
-    { "sampleRate", nullptr, nullptr },
-    { "samples", nullptr, nullptr },
-    { "shiftKey", nullptr, nullptr },
-    { "side", nullptr, nullptr },
-    { "siteID", nullptr, nullptr },
-    { "skinCoordIndex", nullptr, nullptr },
-    { "skinCoordWeight", nullptr, nullptr },
-    { "skyAngle", nullptr, nullptr },
-    { "skyColor", nullptr, nullptr },
-    { "spacing", nullptr, nullptr },
-    { "spatialize", nullptr, nullptr },
-    { "speed", nullptr, nullptr },
-    { "speedFactor", nullptr, nullptr },
-    { "spine", nullptr, nullptr },
-    { "startAngle", nullptr, nullptr },
-    { "startTime", nullptr, nullptr },
-    { "stiffness", nullptr, nullptr },
-    { "stopTime", nullptr, nullptr },
-    { "string", nullptr, nullptr },
-    { "stripCount", nullptr, nullptr },
-    { "style", nullptr, nullptr },
-    { "summary", nullptr, nullptr },
-    { "tdlType", nullptr, nullptr },
-    { "tessellation", nullptr, nullptr },
-    { "tessellationScale", nullptr, nullptr },
-    { "time", nullptr, nullptr },
-    { "timeOut", nullptr, nullptr },
-    { "timestamp", nullptr, nullptr },
-    { "title", nullptr, nullptr },
-    { "toggle", nullptr, nullptr },
-    { "top", nullptr, nullptr },
-    { "topToBottom", nullptr, nullptr },
-    { "topUrl", nullptr, nullptr },
-    { "touchTime", nullptr, nullptr },
-    { "transmitFrequencyBandwidth", nullptr, nullptr },
-    { "transmitState", nullptr, nullptr },
-    { "transmitterApplicationID", nullptr, nullptr },
-    { "transmitterEntityID", nullptr, nullptr },
-    { "transmitterRadioID", nullptr, nullptr },
-    { "transmitterSiteID", nullptr, nullptr },
-    { "transparent", nullptr, nullptr },
-    { "triggerTime", nullptr, nullptr },
-    { "triggerTrue", nullptr, nullptr },
-    { "triggerValue", nullptr, nullptr },
-    { "type", nullptr, nullptr },
-    { "uDimension", nullptr, nullptr },
-    { "uKnot", nullptr, nullptr },
-    { "uOrder", nullptr, nullptr },
-    { "uTessellation", nullptr, nullptr },
-    { "ulimit", nullptr, nullptr },
-    { "vDimension", nullptr, nullptr },
-    { "vKnot", nullptr, nullptr },
-    { "vOrder", nullptr, nullptr },
-    { "vTessellation", nullptr, nullptr },
-    { "version", nullptr, nullptr },
-    { "verticalDatum", nullptr, nullptr },
-    { "vertices", nullptr, nullptr },
-    { "visibilityLimit", nullptr, nullptr },
-    { "visibilityRange", nullptr, nullptr },
-    { "warhead", nullptr, nullptr },
-    { "weight", nullptr, nullptr },
-    { "whichGeometry", nullptr, nullptr },
-    { "writeInterval", nullptr, nullptr },
-    { "xDimension", nullptr, nullptr },
-    { "xSpacing", nullptr, nullptr },
-    { "yScale", nullptr, nullptr },
-    { "zDimension", nullptr, nullptr },
-    { "zSpacing", nullptr, nullptr },
-    { "visible", nullptr, nullptr },
-    { "repeatR", nullptr, nullptr },
-    { "texture", nullptr, nullptr },
-    { "back", nullptr, nullptr },
-    { "front", nullptr, nullptr },
-    { "left", nullptr, nullptr },
-    { "right", nullptr, nullptr },
-    { "parts", nullptr, nullptr },
-    { "isSelected", nullptr, nullptr },
-    { "isValid", nullptr, nullptr },
-    { "numComponents", nullptr, nullptr },
-    { "depth", nullptr, nullptr },
-    { "update", nullptr, nullptr },
-    { "fogCoord", nullptr, nullptr },
-    { "texCoord", nullptr, nullptr },
-    { "activate", nullptr, nullptr },
-    { "programs", nullptr, nullptr },
-    { "matrix", nullptr, nullptr },
-    { "anchorPoint", nullptr, nullptr },
-    { "body1", nullptr, nullptr },
-    { "body2", nullptr, nullptr },
-    { "forceOutput", nullptr, nullptr },
-    { "body1AnchorPoint", nullptr, nullptr },
-    { "body2AnchorPoint", nullptr, nullptr },
-    { "plane", nullptr, nullptr },
-    { "appliedParameters", nullptr, nullptr },
-    { "bounce", nullptr, nullptr },
-    { "frictionCoefficients", nullptr, nullptr },
-    { "minBounceSpeed", nullptr, nullptr },
-    { "slipFactors", nullptr, nullptr },
-    { "softnessConstantForceMix", nullptr, nullptr },
-    { "softnessErrorCorrection", nullptr, nullptr },
-    { "surfaceSpeed", nullptr, nullptr },
-    { "isActive", nullptr, nullptr },
-    { "useGeometry", nullptr, nullptr },
-    { "set_destination", nullptr, nullptr },
-    { "set_value", nullptr, nullptr },
-    { "tau", nullptr, nullptr },
-    { "tolerance", nullptr, nullptr },
-    { "value_changed", nullptr, nullptr },
-    { "initialDestination", nullptr, nullptr },
-    { "initialValue", nullptr, nullptr },
-    { "angle", nullptr, nullptr },
-    { "variation", nullptr, nullptr },
-    { "surfaceArea", nullptr, nullptr },
-    { "frictionDirection", nullptr, nullptr },
-    { "slipCoefficients", nullptr, nullptr },
-    { "category", nullptr, nullptr },
-    { "country", nullptr, nullptr },
-    { "domain", nullptr, nullptr },
-    { "extra", nullptr, nullptr },
-    { "kind", nullptr, nullptr },
-    { "specific", nullptr, nullptr },
-    { "subcategory", nullptr, nullptr },
-    { "axis1", nullptr, nullptr },
-    { "axis2", nullptr, nullptr },
-    { "desiredAngularVelocity1", nullptr, nullptr },
-    { "desiredAngularVelocity2", nullptr, nullptr },
-    { "maxAngle1", nullptr, nullptr },
-    { "maxTorque1", nullptr, nullptr },
-    { "maxTorque2", nullptr, nullptr },
-    { "minAngle1", nullptr, nullptr },
-    { "stopBounce1", nullptr, nullptr },
-    { "stopConstantForceMix1", nullptr, nullptr },
-    { "stopErrorCorrection1", nullptr, nullptr },
-    { "suspensionErrorCorrection", nullptr, nullptr },
-    { "suspensionForce", nullptr, nullptr },
-    { "body1Axis", nullptr, nullptr },
-    { "body2Axis", nullptr, nullptr },
-    { "hinge1Angle", nullptr, nullptr },
-    { "hinge1AngleRate", nullptr, nullptr },
-    { "hinge2Angle", nullptr, nullptr },
-    { "hinge2AngleRate", nullptr, nullptr },
-    { "set_fraction", nullptr, nullptr },
-    { "easeInEaseOut", nullptr, nullptr },
-    { "modifiedFraction_changed", nullptr, nullptr },
-    { "force", nullptr, nullptr },
-    { "geoCenter", nullptr, nullptr },
-    { "centerOfRotation_changed", nullptr, nullptr },
-    { "geoCoord_changed", nullptr, nullptr },
-    { "orientation_changed", nullptr, nullptr },
-    { "position_changed", nullptr, nullptr },
-    { "isPickable", nullptr, nullptr },
-    { "viewport", nullptr, nullptr },
-    { "activeLayer", nullptr, nullptr },
-    { "align", nullptr, nullptr },
-    { "offsetUnits", nullptr, nullptr },
-    { "scaleMode", nullptr, nullptr },
-    { "sizeUnits", nullptr, nullptr },
-    { "layout", nullptr, nullptr },
-    { "objectType", nullptr, nullptr },
-    { "pickedNormal", nullptr, nullptr },
-    { "pickedPoint", nullptr, nullptr },
-    { "pickedTextureCoordinate", nullptr, nullptr },
-    { "intersectionType", nullptr, nullptr },
-    { "sortOrder", nullptr, nullptr },
-    { "axis1Angle", nullptr, nullptr },
-    { "axis1Torque", nullptr, nullptr },
-    { "axis2Angle", nullptr, nullptr },
-    { "axis2Torque", nullptr, nullptr },
-    { "axis3Angle", nullptr, nullptr },
-    { "axis3Torque", nullptr, nullptr },
-    { "enabledAxies", nullptr, nullptr },
-    { "motor1Axis", nullptr, nullptr },
-    { "motor2Axis", nullptr, nullptr },
-    { "motor3Axis", nullptr, nullptr },
-    { "stop1Bounce", nullptr, nullptr },
-    { "stop1ErrorCorrection", nullptr, nullptr },
-    { "stop2Bounce", nullptr, nullptr },
-    { "stop2ErrorCorrection", nullptr, nullptr },
-    { "stop3Bounce", nullptr, nullptr },
-    { "stop3ErrorCorrection", nullptr, nullptr },
-    { "motor1Angle", nullptr, nullptr },
-    { "motor1AngleRate", nullptr, nullptr },
-    { "motor2Angle", nullptr, nullptr },
-    { "motor2AngleRate", nullptr, nullptr },
-    { "motor3Angle", nullptr, nullptr },
-    { "motor3AngleRate", nullptr, nullptr },
-    { "autoCalc", nullptr, nullptr },
-    { "duration", nullptr, nullptr },
-    { "retainUserOffsets", nullptr, nullptr },
-    { "isBound", nullptr, nullptr },
-    { "appearance", nullptr, nullptr },
-    { "createParticles", nullptr, nullptr },
-    { "lifetimeVariation", nullptr, nullptr },
-    { "maxParticles", nullptr, nullptr },
-    { "particleLifetime", nullptr, nullptr },
-    { "particleSize", nullptr, nullptr },
-    { "colorKey", nullptr, nullptr },
-    { "geometryType", nullptr, nullptr },
-    { "texCoordKey", nullptr, nullptr },
-    { "pickable", nullptr, nullptr },
-    { "angularDampingFactor", nullptr, nullptr },
-    { "angularVelocity", nullptr, nullptr },
-    { "autoDamp", nullptr, nullptr },
-    { "autoDisable", nullptr, nullptr },
-    { "disableAngularSpeed", nullptr, nullptr },
-    { "disableLinearSpeed", nullptr, nullptr },
-    { "disableTime", nullptr, nullptr },
-    { "finiteRotationAxis", nullptr, nullptr },
-    { "fixed", nullptr, nullptr },
-    { "forces", nullptr, nullptr },
-    { "inertia", nullptr, nullptr },
-    { "linearDampingFactor", nullptr, nullptr },
-    { "torques", nullptr, nullptr },
-    { "useFiniteRotation", nullptr, nullptr },
-    { "useGlobalForce", nullptr, nullptr },
-    { "constantForceMix", nullptr, nullptr },
-    { "constantSurfaceThickness", nullptr, nullptr },
-    { "errorCorrection", nullptr, nullptr },
-    { "iterations", nullptr, nullptr },
-    { "maxCorrectionSpeed", nullptr, nullptr },
-    { "preferAccuracy", nullptr, nullptr },
-    { "pointSize", nullptr, nullptr },
-    { "stopBounce", nullptr, nullptr },
-    { "stopErrorCorrection", nullptr, nullptr },
-    { "angleRate", nullptr, nullptr },
-    { "maxSeparation", nullptr, nullptr },
-    { "minSeparation", nullptr, nullptr },
-    { "separation", nullptr, nullptr },
-    { "separationRate", nullptr, nullptr },
-    { "closed", nullptr, nullptr },
-    { "keyVelocity", nullptr, nullptr },
-    { "normalizeVelocity", nullptr, nullptr },
-    { "surface", nullptr, nullptr },
-    { "anisotropicDegree", nullptr, nullptr },
-    { "borderColor", nullptr, nullptr },
-    { "borderWidth", nullptr, nullptr },
-    { "boundaryModeS", nullptr, nullptr },
-    { "boundaryModeT", nullptr, nullptr },
-    { "boundaryModeR", nullptr, nullptr },
-    { "magnificationFilter", nullptr, nullptr },
-    { "minificationFilter", nullptr, nullptr },
-    { "textureCompression", nullptr, nullptr },
-    { "texturePriority", nullptr, nullptr },
-    { "generateMipMaps", nullptr, nullptr },
-    { "targetObject", nullptr, nullptr },
-    { "backAmbientIntensity", nullptr, nullptr },
-    { "backDiffuseColor", nullptr, nullptr },
-    { "backEmissiveColor", nullptr, nullptr },
-    { "backShininess", nullptr, nullptr },
-    { "backSpecularColor", nullptr, nullptr },
-    { "separateBackColor", nullptr, nullptr },
-    { "displayed", nullptr, nullptr },
-    { "clipBoundary", nullptr, nullptr },
-    { "internal", nullptr, nullptr },
-    { "gustiness", nullptr, nullptr },
-    { "turbulence", nullptr, nullptr },
-    { "unitCategory", nullptr, nullptr },
-    { "unitName", nullptr, nullptr },
-    { "unitConversionFactor", nullptr, nullptr },
-    { "weightConstant1", nullptr, nullptr },
-    { "weightConstant2", nullptr, nullptr },
-    { "weightFunction1", nullptr, nullptr },
-    { "weightFunction2", nullptr, nullptr },
-    { "boundaryOpacity", nullptr, nullptr },
-    { "opacityFactor", nullptr, nullptr },
-    { "retainedOpacity", nullptr, nullptr },
-    { "colorSteps", nullptr, nullptr },
-    { "orthogonalColor", nullptr, nullptr },
-    { "parallelColor", nullptr, nullptr },
-    { "ordered", nullptr, nullptr },
-    { "edgeColor", nullptr, nullptr },
-    { "gradientThreshold", nullptr, nullptr },
-    { "contourStepSize", nullptr, nullptr },
-    { "dimensions", nullptr, nullptr },
-    { "surfaceTolerance", nullptr, nullptr },
-    { "surfaceValues", nullptr, nullptr },
-    { "intensityThreshold", nullptr, nullptr },
-    { "segmentEnabled", nullptr, nullptr },
-    { "lighting", nullptr, nullptr },
-    { "shadows", nullptr, nullptr },
-    { "phaseFunction", nullptr, nullptr },
-    { "silhouetteBoundaryOpacity", nullptr, nullptr },
-    { "silhouetteRetainedOpacity", nullptr, nullptr },
-    { "silhouetteSharpness", nullptr, nullptr },
-    { "coolColor", nullptr, nullptr },
-    { "warmColor", nullptr, nullptr }
-};
-
-FIVocabulary X3D_vocabulary_3_3 = {
-    nullptr, 0,
-    encodingAlgorithmTable_3_3, 8,
-    nullptr, 0,
-    nullptr, 0,
-    nullptr, 0,
-    nullptr, 0,
-    nullptr, 0,
-    attributeValueTable_3_3, 2,
-    nullptr, 0,
-    nullptr, 0,
-    elementNameTable_3_3, 252,
-    attributeNameTable_3_3, 546
-};
-
-}// namespace Assimp
-
-#endif // !ASSIMP_BUILD_NO_X3D_IMPORTER
diff --git a/Engine/lib/assimp/code/XGL/XGLLoader.cpp b/Engine/lib/assimp/code/XGL/XGLLoader.cpp
deleted file mode 100644
index 32cfd72ca..000000000
--- a/Engine/lib/assimp/code/XGL/XGLLoader.cpp
+++ /dev/null
@@ -1,956 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-/** @file Implementation of the XGL/ZGL importer class */
-
-
-#ifndef ASSIMP_BUILD_NO_XGL_IMPORTER
-
-#include "XGLLoader.h"
-#include <assimp/ParsingUtils.h>
-#include <assimp/fast_atof.h>
-
-#include <assimp/StreamReader.h>
-#include <assimp/MemoryIOWrapper.h>
-#include <assimp/mesh.h>
-#include <assimp/scene.h>
-#include <assimp/importerdesc.h>
-#include <cctype>
-#include <memory>
-
-using namespace Assimp;
-using namespace irr;
-using namespace irr::io;
-
-// zlib is needed for compressed XGL files
-#ifndef ASSIMP_BUILD_NO_COMPRESSED_XGL
-#   ifdef ASSIMP_BUILD_NO_OWN_ZLIB
-#       include <zlib.h>
-#   else
-#       include <contrib/zlib/zlib.h>
-#   endif
-#endif
-
-
-namespace Assimp { // this has to be in here because LogFunctions is in ::Assimp
-    template<> const char* LogFunctions<XGLImporter>::Prefix()
-    {
-        static auto prefix = "XGL: ";
-        return prefix;
-    }
-}
-
-static const aiImporterDesc desc = {
-    "XGL Importer",
-    "",
-    "",
-    "",
-    aiImporterFlags_SupportTextFlavour | aiImporterFlags_SupportCompressedFlavour,
-    0,
-    0,
-    0,
-    0,
-    "xgl zgl"
-};
-
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-XGLImporter::XGLImporter()
-: m_reader( nullptr )
-, m_scene( nullptr ) {
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-XGLImporter::~XGLImporter() {
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the class can handle the format of the given file.
-bool XGLImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
-{
-    /* NOTE: A simple check for the file extension is not enough
-     * here. XGL and ZGL are ok, but xml is too generic
-     * and might be collada as well. So open the file and
-     * look for typical signal tokens.
-     */
-    const std::string extension = GetExtension(pFile);
-
-    if (extension == "xgl" || extension == "zgl") {
-        return true;
-    }
-    else if (extension == "xml" || checkSig) {
-        ai_assert(pIOHandler != NULL);
-
-        const char* tokens[] = {"<world>","<World>","<WORLD>"};
-        return SearchFileHeaderForToken(pIOHandler,pFile,tokens,3);
-    }
-    return false;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Get a list of all file extensions which are handled by this class
-const aiImporterDesc* XGLImporter::GetInfo () const
-{
-    return &desc;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Imports the given file into the given scene structure.
-void XGLImporter::InternReadFile( const std::string& pFile,
-    aiScene* pScene, IOSystem* pIOHandler)
-{
-#ifndef ASSIMP_BUILD_NO_COMPRESSED_XGL
-    std::vector<Bytef> uncompressed;
-#endif
-
-    m_scene = pScene;
-    std::shared_ptr<IOStream> stream( pIOHandler->Open( pFile, "rb"));
-
-    // check whether we can read from the file
-    if( stream.get() == NULL) {
-        throw DeadlyImportError( "Failed to open XGL/ZGL file " + pFile + "");
-    }
-
-    // see if its compressed, if so uncompress it
-    if (GetExtension(pFile) == "zgl") {
-#ifdef ASSIMP_BUILD_NO_COMPRESSED_XGL
-        ThrowException("Cannot read ZGL file since Assimp was built without compression support");
-#else
-        std::unique_ptr<StreamReaderLE> raw_reader(new StreamReaderLE(stream));
-
-        // build a zlib stream
-        z_stream zstream;
-        zstream.opaque = Z_NULL;
-        zstream.zalloc = Z_NULL;
-        zstream.zfree  = Z_NULL;
-        zstream.data_type = Z_BINARY;
-
-        // raw decompression without a zlib or gzip header
-        inflateInit2(&zstream, -MAX_WBITS);
-
-        // skip two extra bytes, zgl files do carry a crc16 upfront (I think)
-        raw_reader->IncPtr(2);
-
-        zstream.next_in   = reinterpret_cast<Bytef*>( raw_reader->GetPtr() );
-        zstream.avail_in  = raw_reader->GetRemainingSize();
-
-        size_t total = 0l;
-
-        // TODO: be smarter about this, decompress directly into heap buffer
-        // and decompress the data .... do 1k chunks in the hope that we won't kill the stack
-    #define MYBLOCK 1024
-        Bytef block[MYBLOCK];
-        int ret;
-        do {
-            zstream.avail_out = MYBLOCK;
-            zstream.next_out = block;
-            ret = inflate(&zstream, Z_NO_FLUSH);
-
-            if (ret != Z_STREAM_END && ret != Z_OK) {
-                ThrowException("Failure decompressing this file using gzip, seemingly it is NOT a compressed .XGL file");
-            }
-            const size_t have = MYBLOCK - zstream.avail_out;
-            total += have;
-            uncompressed.resize(total);
-            memcpy(uncompressed.data() + total - have,block,have);
-        }
-        while (ret != Z_STREAM_END);
-
-        // terminate zlib
-        inflateEnd(&zstream);
-
-        // replace the input stream with a memory stream
-        stream.reset(new MemoryIOStream(reinterpret_cast<uint8_t*>(uncompressed.data()),total));
-#endif
-    }
-
-    // construct the irrXML parser
-    CIrrXML_IOStreamReader st(stream.get());
-    m_reader.reset( createIrrXMLReader( ( IFileReadCallBack* ) &st ) );
-
-    // parse the XML file
-    TempScope scope;
-
-    while (ReadElement())   {
-        if (!ASSIMP_stricmp(m_reader->getNodeName(),"world")) {
-            ReadWorld(scope);
-        }
-    }
-
-
-    std::vector<aiMesh*>& meshes = scope.meshes_linear;
-    std::vector<aiMaterial*>& materials = scope.materials_linear;
-    if(!meshes.size() || !materials.size()) {
-        ThrowException("failed to extract data from XGL file, no meshes loaded");
-    }
-
-    // copy meshes
-    m_scene->mNumMeshes = static_cast<unsigned int>(meshes.size());
-    m_scene->mMeshes = new aiMesh*[m_scene->mNumMeshes]();
-    std::copy(meshes.begin(),meshes.end(),m_scene->mMeshes);
-
-    // copy materials
-    m_scene->mNumMaterials = static_cast<unsigned int>(materials.size());
-    m_scene->mMaterials = new aiMaterial*[m_scene->mNumMaterials]();
-    std::copy(materials.begin(),materials.end(),m_scene->mMaterials);
-
-    if (scope.light) {
-        m_scene->mNumLights = 1;
-        m_scene->mLights = new aiLight*[1];
-        m_scene->mLights[0] = scope.light;
-
-        scope.light->mName = m_scene->mRootNode->mName;
-    }
-
-    scope.dismiss();
-}
-
-// ------------------------------------------------------------------------------------------------
-bool XGLImporter::ReadElement()
-{
-    while(m_reader->read()) {
-        if (m_reader->getNodeType() == EXN_ELEMENT) {
-            return true;
-        }
-    }
-    return false;
-}
-
-// ------------------------------------------------------------------------------------------------
-bool XGLImporter::ReadElementUpToClosing(const char* closetag)
-{
-    while(m_reader->read()) {
-        if (m_reader->getNodeType() == EXN_ELEMENT) {
-            return true;
-        }
-        else if (m_reader->getNodeType() == EXN_ELEMENT_END && !ASSIMP_stricmp(m_reader->getNodeName(),closetag)) {
-            return false;
-        }
-    }
-    LogError("unexpected EOF, expected closing <" + std::string(closetag) + "> tag");
-    return false;
-}
-
-// ------------------------------------------------------------------------------------------------
-bool XGLImporter::SkipToText()
-{
-    while(m_reader->read()) {
-        if (m_reader->getNodeType() == EXN_TEXT) {
-            return true;
-        }
-        else if (m_reader->getNodeType() == EXN_ELEMENT || m_reader->getNodeType() == EXN_ELEMENT_END) {
-            ThrowException("expected text contents but found another element (or element end)");
-        }
-    }
-    return false;
-}
-
-// ------------------------------------------------------------------------------------------------
-std::string XGLImporter::GetElementName()
-{
-    const char* s  = m_reader->getNodeName();
-    size_t len = strlen(s);
-
-    std::string ret;
-    ret.resize(len);
-
-    std::transform(s,s+len,ret.begin(),::tolower);
-    return ret;
-}
-
-// ------------------------------------------------------------------------------------------------
-void XGLImporter::ReadWorld(TempScope& scope)
-{
-    while (ReadElementUpToClosing("world")) {
-        const std::string& s = GetElementName();
-        // XXX right now we'd skip <lighting> if it comes after
-        // <object> or <mesh>
-        if (s == "lighting") {
-            ReadLighting(scope);
-        }
-        else if (s == "object" || s == "mesh" || s == "mat") {
-            break;
-        }
-    }
-
-
-    aiNode* const nd = ReadObject(scope,true,"world");
-    if(!nd) {
-        ThrowException("failure reading <world>");
-    }
-    if(!nd->mName.length) {
-        nd->mName.Set("WORLD");
-    }
-
-    m_scene->mRootNode = nd;
-}
-
-// ------------------------------------------------------------------------------------------------
-void XGLImporter::ReadLighting(TempScope& scope)
-{
-    while (ReadElementUpToClosing("lighting"))  {
-        const std::string& s = GetElementName();
-        if (s == "directionallight") {
-            scope.light = ReadDirectionalLight();
-        }
-        else if (s == "ambient") {
-            LogWarn("ignoring <ambient> tag");
-        }
-        else if (s == "spheremap") {
-            LogWarn("ignoring <spheremap> tag");
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-aiLight* XGLImporter::ReadDirectionalLight()
-{
-    std::unique_ptr<aiLight> l(new aiLight());
-    l->mType = aiLightSource_DIRECTIONAL;
-
-    while (ReadElementUpToClosing("directionallight"))  {
-        const std::string& s = GetElementName();
-        if (s == "direction") {
-            l->mDirection = ReadVec3();
-        }
-        else if (s == "diffuse") {
-            l->mColorDiffuse = ReadCol3();
-        }
-        else if (s == "specular") {
-            l->mColorSpecular = ReadCol3();
-        }
-    }
-    return l.release();
-}
-
-// ------------------------------------------------------------------------------------------------
-aiNode* XGLImporter::ReadObject(TempScope& scope, bool skipFirst, const char* closetag)
-{
-    aiNode *nd = new aiNode;
-    std::vector<aiNode*> children;
-    std::vector<unsigned int> meshes;
-
-    try {
-        while (skipFirst || ReadElementUpToClosing(closetag))   {
-            skipFirst = false;
-
-            const std::string& s = GetElementName();
-            if (s == "mesh") {
-                const size_t prev = scope.meshes_linear.size();
-                if(ReadMesh(scope)) {
-                    const size_t newc = scope.meshes_linear.size();
-                    for(size_t i = 0; i < newc-prev; ++i) {
-                        meshes.push_back(static_cast<unsigned int>(i+prev));
-                    }
-                }
-            }
-            else if (s == "mat") {
-                ReadMaterial(scope);
-            }
-            else if (s == "object") {
-                children.push_back(ReadObject(scope));
-            }
-            else if (s == "objectref") {
-                // XXX
-            }
-            else if (s == "meshref") {
-                const unsigned int id = static_cast<unsigned int>( ReadIndexFromText() );
-
-                std::multimap<unsigned int, aiMesh*>::iterator it = scope.meshes.find(id), end = scope.meshes.end();
-                if (it == end) {
-                    ThrowException("<meshref> index out of range");
-                }
-
-                for(; it != end && (*it).first == id; ++it) {
-                    // ok, this is n^2 and should get optimized one day
-                    aiMesh* const m = (*it).second;
-
-                    unsigned int i = 0, mcount = static_cast<unsigned int>(scope.meshes_linear.size());
-                    for(; i < mcount; ++i) {
-                        if (scope.meshes_linear[i] == m) {
-                            meshes.push_back(i);
-                            break;
-                        }
-                    }
-
-                    ai_assert(i < mcount);
-                }
-            }
-            else if (s == "transform") {
-                nd->mTransformation = ReadTrafo();
-            }
-        }
-
-    } catch(...) {
-        for(aiNode* ch : children) {
-            delete ch;
-        }
-        throw;
-    }
-
-    // FIX: since we used std::multimap<> to keep meshes by id, mesh order now depends on the behaviour
-    // of the multimap implementation with respect to the ordering of entries with same values.
-    // C++11 gives the guarantee that it uses insertion order, before it is implementation-specific.
-    // Sort by material id to always guarantee a deterministic result.
-    std::sort(meshes.begin(), meshes.end(), SortMeshByMaterialId(scope));
-
-    // link meshes to node
-    nd->mNumMeshes = static_cast<unsigned int>(meshes.size());
-    if (nd->mNumMeshes) {
-        nd->mMeshes = new unsigned int[nd->mNumMeshes]();
-        for(unsigned int i = 0; i < nd->mNumMeshes; ++i) {
-            nd->mMeshes[i] = meshes[i];
-        }
-    }
-
-    // link children to parent
-    nd->mNumChildren = static_cast<unsigned int>(children.size());
-    if (nd->mNumChildren) {
-        nd->mChildren = new aiNode*[nd->mNumChildren]();
-        for(unsigned int i = 0; i < nd->mNumChildren; ++i) {
-            nd->mChildren[i] = children[i];
-            children[i]->mParent = nd;
-        }
-    }
-
-    return nd;
-}
-
-// ------------------------------------------------------------------------------------------------
-aiMatrix4x4 XGLImporter::ReadTrafo()
-{
-    aiVector3D forward, up, right, position;
-    float scale = 1.0f;
-
-    while (ReadElementUpToClosing("transform")) {
-        const std::string& s = GetElementName();
-        if (s == "forward") {
-            forward = ReadVec3();
-        }
-        else if (s == "up") {
-            up = ReadVec3();
-        }
-        else if (s == "position") {
-            position = ReadVec3();
-        }
-        if (s == "scale") {
-            scale = ReadFloat();
-            if(scale < 0.f) {
-                // this is wrong, but we can leave the value and pass it to the caller
-                LogError("found negative scaling in <transform>, ignoring");
-            }
-        }
-    }
-
-    aiMatrix4x4 m;
-    if(forward.SquareLength() < 1e-4 || up.SquareLength() < 1e-4) {
-        LogError("A direction vector in <transform> is zero, ignoring trafo");
-        return m;
-    }
-
-    forward.Normalize();
-    up.Normalize();
-
-    right = forward ^ up;
-    if (std::fabs(up * forward) > 1e-4) {
-        // this is definitely wrong - a degenerate coordinate space ruins everything
-        // so substitute identity transform.
-        LogError("<forward> and <up> vectors in <transform> are skewing, ignoring trafo");
-        return m;
-    }
-
-    right *= scale;
-    up *= scale;
-    forward *= scale;
-
-    m.a1 = right.x;
-    m.b1 = right.y;
-    m.c1 = right.z;
-
-    m.a2 = up.x;
-    m.b2 = up.y;
-    m.c2 = up.z;
-
-    m.a3 = forward.x;
-    m.b3 = forward.y;
-    m.c3 = forward.z;
-
-    m.a4 = position.x;
-    m.b4 = position.y;
-    m.c4 = position.z;
-
-    return m;
-}
-
-// ------------------------------------------------------------------------------------------------
-aiMesh* XGLImporter::ToOutputMesh(const TempMaterialMesh& m)
-{
-    std::unique_ptr<aiMesh> mesh(new aiMesh());
-
-    mesh->mNumVertices = static_cast<unsigned int>(m.positions.size());
-    mesh->mVertices = new aiVector3D[mesh->mNumVertices];
-    std::copy(m.positions.begin(),m.positions.end(),mesh->mVertices);
-
-    if(m.normals.size()) {
-        mesh->mNormals = new aiVector3D[mesh->mNumVertices];
-        std::copy(m.normals.begin(),m.normals.end(),mesh->mNormals);
-    }
-
-    if(m.uvs.size()) {
-        mesh->mNumUVComponents[0] = 2;
-        mesh->mTextureCoords[0] = new aiVector3D[mesh->mNumVertices];
-
-        for(unsigned int i = 0; i < mesh->mNumVertices; ++i) {
-            mesh->mTextureCoords[0][i] = aiVector3D(m.uvs[i].x,m.uvs[i].y,0.f);
-        }
-    }
-
-    mesh->mNumFaces =  static_cast<unsigned int>(m.vcounts.size());
-    mesh->mFaces = new aiFace[m.vcounts.size()];
-
-    unsigned int idx = 0;
-    for(unsigned int i = 0; i < mesh->mNumFaces; ++i) {
-        aiFace& f = mesh->mFaces[i];
-        f.mNumIndices = m.vcounts[i];
-        f.mIndices = new unsigned int[f.mNumIndices];
-        for(unsigned int c = 0; c < f.mNumIndices; ++c) {
-            f.mIndices[c] = idx++;
-        }
-    }
-
-    ai_assert(idx == mesh->mNumVertices);
-
-    mesh->mPrimitiveTypes = m.pflags;
-    mesh->mMaterialIndex = m.matid;
-    return mesh.release();
-}
-
-// ------------------------------------------------------------------------------------------------
-bool XGLImporter::ReadMesh(TempScope& scope)
-{
-    TempMesh t;
-
-    std::map<unsigned int, TempMaterialMesh> bymat;
-    const unsigned int mesh_id = ReadIDAttr();
-
-    while (ReadElementUpToClosing("mesh"))  {
-        const std::string& s = GetElementName();
-
-        if (s == "mat") {
-            ReadMaterial(scope);
-        }
-        else if (s == "p") {
-            if (!m_reader->getAttributeValue("ID")) {
-                LogWarn("no ID attribute on <p>, ignoring");
-            }
-            else {
-                int id = m_reader->getAttributeValueAsInt("ID");
-                t.points[id] = ReadVec3();
-            }
-        }
-        else if (s == "n") {
-            if (!m_reader->getAttributeValue("ID")) {
-                LogWarn("no ID attribute on <n>, ignoring");
-            }
-            else {
-                int id = m_reader->getAttributeValueAsInt("ID");
-                t.normals[id] = ReadVec3();
-            }
-        }
-        else if (s == "tc") {
-            if (!m_reader->getAttributeValue("ID")) {
-                LogWarn("no ID attribute on <tc>, ignoring");
-            }
-            else {
-                int id = m_reader->getAttributeValueAsInt("ID");
-                t.uvs[id] = ReadVec2();
-            }
-        }
-        else if (s == "f" || s == "l" || s == "p") {
-            const unsigned int vcount = s == "f" ? 3 : (s == "l" ? 2 : 1);
-
-            unsigned int mid = ~0u;
-            TempFace tf[3];
-            bool has[3] = {0};
-
-            while (ReadElementUpToClosing(s.c_str()))   {
-                const std::string& s = GetElementName();
-                if (s == "fv1" || s == "lv1" || s == "pv1") {
-                    ReadFaceVertex(t,tf[0]);
-                    has[0] = true;
-                }
-                else if (s == "fv2" || s == "lv2") {
-                    ReadFaceVertex(t,tf[1]);
-                    has[1] = true;
-                }
-                else if (s == "fv3") {
-                    ReadFaceVertex(t,tf[2]);
-                    has[2] = true;
-                }
-                else if (s == "mat") {
-                    if (mid != ~0u) {
-                        LogWarn("only one material tag allowed per <f>");
-                    }
-                    mid = ResolveMaterialRef(scope);
-                }
-                else if (s == "matref") {
-                    if (mid != ~0u) {
-                        LogWarn("only one material tag allowed per <f>");
-                    }
-                    mid = ResolveMaterialRef(scope);
-                }
-            }
-
-            if (mid == ~0u) {
-                ThrowException("missing material index");
-            }
-
-            bool nor = false;
-            bool uv = false;
-            for(unsigned int i = 0; i < vcount; ++i) {
-                if (!has[i]) {
-                    ThrowException("missing face vertex data");
-                }
-
-                nor = nor || tf[i].has_normal;
-                uv = uv || tf[i].has_uv;
-            }
-
-            if (mid >= (1<<30)) {
-                LogWarn("material indices exhausted, this may cause errors in the output");
-            }
-            unsigned int meshId = mid | ((nor?1:0)<<31) | ((uv?1:0)<<30);
-
-            TempMaterialMesh& mesh = bymat[meshId];
-            mesh.matid = mid;
-
-            for(unsigned int i = 0; i < vcount; ++i) {
-                mesh.positions.push_back(tf[i].pos);
-                if(nor) {
-                    mesh.normals.push_back(tf[i].normal);
-                }
-                if(uv) {
-                    mesh.uvs.push_back(tf[i].uv);
-                }
-
-                mesh.pflags |= 1 << (vcount-1);
-            }
-
-            mesh.vcounts.push_back(vcount);
-        }
-    }
-
-    // finally extract output meshes and add them to the scope
-    typedef std::pair<unsigned int, TempMaterialMesh> pairt;
-    for(const pairt& p : bymat) {
-        aiMesh* const m  = ToOutputMesh(p.second);
-        scope.meshes_linear.push_back(m);
-
-        // if this is a definition, keep it on the stack
-        if(mesh_id != ~0u) {
-            scope.meshes.insert(std::pair<unsigned int, aiMesh*>(mesh_id,m));
-        }
-    }
-
-    // no id == not a reference, insert this mesh right *here*
-    return mesh_id == ~0u;
-}
-
-// ----------------------------------------------------------------------------------------------
-unsigned int XGLImporter::ResolveMaterialRef(TempScope& scope)
-{
-    const std::string& s = GetElementName();
-    if (s == "mat") {
-        ReadMaterial(scope);
-        return static_cast<unsigned int>(scope.materials_linear.size()-1);
-    }
-
-    const int id = ReadIndexFromText();
-
-    std::map<unsigned int, aiMaterial*>::iterator it = scope.materials.find(id), end = scope.materials.end();
-    if (it == end) {
-        ThrowException("<matref> index out of range");
-    }
-
-    // ok, this is n^2 and should get optimized one day
-    aiMaterial* const m = (*it).second;
-
-    unsigned int i = 0, mcount = static_cast<unsigned int>(scope.materials_linear.size());
-    for(; i < mcount; ++i) {
-        if (scope.materials_linear[i] == m) {
-            return i;
-        }
-    }
-
-    ai_assert(false);
-    return 0;
-}
-
-// ------------------------------------------------------------------------------------------------
-void XGLImporter::ReadMaterial(TempScope& scope) {
-    const unsigned int mat_id = ReadIDAttr();
-
-    aiMaterial *mat(new aiMaterial );
-    while (ReadElementUpToClosing("mat"))  {
-        const std::string& s = GetElementName();
-        if (s == "amb") {
-            const aiColor3D c = ReadCol3();
-            mat->AddProperty(&c,1,AI_MATKEY_COLOR_AMBIENT);
-        }
-        else if (s == "diff") {
-            const aiColor3D c = ReadCol3();
-            mat->AddProperty(&c,1,AI_MATKEY_COLOR_DIFFUSE);
-        }
-        else if (s == "spec") {
-            const aiColor3D c = ReadCol3();
-            mat->AddProperty(&c,1,AI_MATKEY_COLOR_SPECULAR);
-        }
-        else if (s == "emiss") {
-            const aiColor3D c = ReadCol3();
-            mat->AddProperty(&c,1,AI_MATKEY_COLOR_EMISSIVE);
-        }
-        else if (s == "alpha") {
-            const float f = ReadFloat();
-            mat->AddProperty(&f,1,AI_MATKEY_OPACITY);
-        }
-        else if (s == "shine") {
-            const float f = ReadFloat();
-            mat->AddProperty(&f,1,AI_MATKEY_SHININESS);
-        }
-    }
-
-    scope.materials[mat_id] = mat;
-    scope.materials_linear.push_back(mat);
-}
-
-// ----------------------------------------------------------------------------------------------
-void XGLImporter::ReadFaceVertex(const TempMesh& t, TempFace& out)
-{
-    const std::string& end = GetElementName();
-
-    bool havep = false;
-    while (ReadElementUpToClosing(end.c_str()))  {
-        const std::string& s = GetElementName();
-        if (s == "pref") {
-            const unsigned int id = ReadIndexFromText();
-            std::map<unsigned int, aiVector3D>::const_iterator it = t.points.find(id);
-            if (it == t.points.end()) {
-                ThrowException("point index out of range");
-            }
-
-            out.pos = (*it).second;
-            havep = true;
-        }
-        else if (s == "nref") {
-            const unsigned int id = ReadIndexFromText();
-            std::map<unsigned int, aiVector3D>::const_iterator it = t.normals.find(id);
-            if (it == t.normals.end()) {
-                ThrowException("normal index out of range");
-            }
-
-            out.normal = (*it).second;
-            out.has_normal = true;
-        }
-        else if (s == "tcref") {
-            const unsigned int id = ReadIndexFromText();
-            std::map<unsigned int, aiVector2D>::const_iterator it = t.uvs.find(id);
-            if (it == t.uvs.end()) {
-                ThrowException("uv index out of range");
-            }
-
-            out.uv = (*it).second;
-            out.has_uv = true;
-        }
-        else if (s == "p") {
-            out.pos = ReadVec3();
-        }
-        else if (s == "n") {
-            out.normal = ReadVec3();
-        }
-        else if (s == "tc") {
-            out.uv = ReadVec2();
-        }
-    }
-
-    if (!havep) {
-        ThrowException("missing <pref> in <fvN> element");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-unsigned int XGLImporter::ReadIDAttr()
-{
-    for(int i = 0, e = m_reader->getAttributeCount(); i < e; ++i) {
-
-        if(!ASSIMP_stricmp(m_reader->getAttributeName(i),"id")) {
-            return m_reader->getAttributeValueAsInt(i);
-        }
-    }
-    return ~0u;
-}
-
-// ------------------------------------------------------------------------------------------------
-float XGLImporter::ReadFloat()
-{
-    if(!SkipToText()) {
-        LogError("unexpected EOF reading float element contents");
-        return 0.f;
-    }
-    const char* s = m_reader->getNodeData(), *se;
-
-    if(!SkipSpaces(&s)) {
-        LogError("unexpected EOL, failed to parse float");
-        return 0.f;
-    }
-
-    float t;
-    se = fast_atoreal_move(s,t);
-
-    if (se == s) {
-        LogError("failed to read float text");
-        return 0.f;
-    }
-
-    return t;
-}
-
-// ------------------------------------------------------------------------------------------------
-unsigned int XGLImporter::ReadIndexFromText()
-{
-    if(!SkipToText()) {
-        LogError("unexpected EOF reading index element contents");
-        return ~0u;
-    }
-    const char* s = m_reader->getNodeData(), *se;
-    if(!SkipSpaces(&s)) {
-        LogError("unexpected EOL, failed to parse index element");
-        return ~0u;
-    }
-
-    const unsigned int t = strtoul10(s,&se);
-
-    if (se == s) {
-        LogError("failed to read index");
-        return ~0u;
-    }
-
-    return t;
-}
-
-// ------------------------------------------------------------------------------------------------
-aiVector2D XGLImporter::ReadVec2()
-{
-    aiVector2D vec;
-
-    if(!SkipToText()) {
-        LogError("unexpected EOF reading vec2 contents");
-        return vec;
-    }
-    const char* s = m_reader->getNodeData();
-
-    ai_real v[2];
-	for(int i = 0; i < 2; ++i) {
-        if(!SkipSpaces(&s)) {
-            LogError("unexpected EOL, failed to parse vec2");
-            return vec;
-        }
-		
-        v[i] = fast_atof(&s);
-
-        SkipSpaces(&s);
-        if (i != 1 && *s != ',') {
-            LogError("expected comma, failed to parse vec2");
-            return vec;
-        }
-        ++s;
-    }
-	vec.x = v[0];
-	vec.y = v[1];
-
-    return vec;
-}
-
-// ------------------------------------------------------------------------------------------------
-aiVector3D XGLImporter::ReadVec3()
-{
-    aiVector3D vec;
-
-    if(!SkipToText()) {
-        LogError("unexpected EOF reading vec3 contents");
-        return vec;
-    }
-    const char* s = m_reader->getNodeData();
-
-    for(int i = 0; i < 3; ++i) {
-        if(!SkipSpaces(&s)) {
-            LogError("unexpected EOL, failed to parse vec3");
-            return vec;
-        }
-        vec[i] = fast_atof(&s);
-
-        SkipSpaces(&s);
-        if (i != 2 && *s != ',') {
-            LogError("expected comma, failed to parse vec3");
-            return vec;
-        }
-        ++s;
-    }
-
-    return vec;
-}
-
-// ------------------------------------------------------------------------------------------------
-aiColor3D XGLImporter::ReadCol3()
-{
-    const aiVector3D& v = ReadVec3();
-    if (v.x < 0.f || v.x > 1.0f || v.y < 0.f || v.y > 1.0f || v.z < 0.f || v.z > 1.0f) {
-        LogWarn("color values out of range, ignoring");
-    }
-    return aiColor3D(v.x,v.y,v.z);
-}
-
-#endif
diff --git a/Engine/lib/assimp/code/glTF/glTFAsset.h b/Engine/lib/assimp/code/glTF/glTFAsset.h
deleted file mode 100644
index ddc7f086e..000000000
--- a/Engine/lib/assimp/code/glTF/glTFAsset.h
+++ /dev/null
@@ -1,1146 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file glTFAsset.h
- * Declares a glTF class to handle gltf/glb files
- *
- * glTF Extensions Support:
- *   KHR_binary_glTF: full
- *   KHR_materials_common: full
- */
-#ifndef GLTFASSET_H_INC
-#define GLTFASSET_H_INC
-
-#ifndef ASSIMP_BUILD_NO_GLTF_IMPORTER
-
-#include <assimp/Exceptional.h>
-
-#include <map>
-#include <string>
-#include <list>
-#include <vector>
-#include <algorithm>
-#include <stdexcept>
-
-#define RAPIDJSON_HAS_STDSTRING 1
-#include <rapidjson/rapidjson.h>
-#include <rapidjson/document.h>
-#include <rapidjson/error/en.h>
-
-#ifdef ASSIMP_API
-#   include <memory>
-#   include <assimp/DefaultIOSystem.h>
-#   include <assimp/ByteSwapper.h>
-#else
-#   include <memory>
-#   define AI_SWAP4(p)
-#   define ai_assert
-#endif
-
-
-#if _MSC_VER > 1500 || (defined __GNUC___)
-#       define ASSIMP_GLTF_USE_UNORDERED_MULTIMAP
-#   else
-#       define gltf_unordered_map map
-#endif
-
-#ifdef ASSIMP_GLTF_USE_UNORDERED_MULTIMAP
-#   include <unordered_map>
-#   if _MSC_VER > 1600
-#       define gltf_unordered_map unordered_map
-#   else
-#       define gltf_unordered_map tr1::unordered_map
-#   endif
-#endif
-
-#include "glTF/glTFCommon.h"
-
-namespace glTF
-{
-    using glTFCommon::shared_ptr;
-    using glTFCommon::IOSystem;
-    using glTFCommon::IOStream;
-
-    using rapidjson::Value;
-    using rapidjson::Document;
-
-    class Asset;
-    class AssetWriter;
-
-    struct BufferView; // here due to cross-reference
-    struct Texture;
-    struct Light;
-    struct Skin;
-
-    using glTFCommon::vec3;
-    using glTFCommon::vec4;
-    using glTFCommon::mat4;
-
-    //! Magic number for GLB files
-    #define AI_GLB_MAGIC_NUMBER "glTF"
-
-    #ifdef ASSIMP_API
-        #include <assimp/Compiler/pushpack1.h>
-    #endif
-
-    //! For the KHR_binary_glTF extension (binary .glb file)
-    //! 20-byte header (+ the JSON + a "body" data section)
-    struct GLB_Header
-    {
-        uint8_t magic[4];     //!< Magic number: "glTF"
-        uint32_t version;     //!< Version number (always 1 as of the last update)
-        uint32_t length;      //!< Total length of the Binary glTF, including header, scene, and body, in bytes
-        uint32_t sceneLength; //!< Length, in bytes, of the glTF scene
-        uint32_t sceneFormat; //!< Specifies the format of the glTF scene (see the SceneFormat enum)
-    } PACK_STRUCT;
-
-    #ifdef ASSIMP_API
-        #include <assimp/Compiler/poppack1.h>
-    #endif
-
-
-    //! Values for the GLB_Header::sceneFormat field
-    enum SceneFormat
-    {
-        SceneFormat_JSON = 0
-    };
-
-    //! Values for the mesh primitive modes
-    enum PrimitiveMode
-    {
-        PrimitiveMode_POINTS = 0,
-        PrimitiveMode_LINES = 1,
-        PrimitiveMode_LINE_LOOP = 2,
-        PrimitiveMode_LINE_STRIP = 3,
-        PrimitiveMode_TRIANGLES = 4,
-        PrimitiveMode_TRIANGLE_STRIP = 5,
-        PrimitiveMode_TRIANGLE_FAN = 6
-    };
-
-    //! Values for the Accessor::componentType field
-    enum ComponentType
-    {
-        ComponentType_BYTE = 5120,
-        ComponentType_UNSIGNED_BYTE = 5121,
-        ComponentType_SHORT = 5122,
-        ComponentType_UNSIGNED_SHORT = 5123,
-        ComponentType_UNSIGNED_INT = 5125,
-        ComponentType_FLOAT = 5126
-    };
-
-    inline unsigned int ComponentTypeSize(ComponentType t)
-    {
-        switch (t) {
-            case ComponentType_SHORT:
-            case ComponentType_UNSIGNED_SHORT:
-                return 2;
-
-            case ComponentType_UNSIGNED_INT:
-            case ComponentType_FLOAT:
-                return 4;
-
-            case ComponentType_BYTE:
-            case ComponentType_UNSIGNED_BYTE:
-                return 1;
-            default:
-                std::string err = "GLTF: Unsupported Component Type ";
-                err += t;
-                throw DeadlyImportError(err);
-        }
-    }
-
-    //! Values for the BufferView::target field
-    enum BufferViewTarget
-    {
-        BufferViewTarget_ARRAY_BUFFER = 34962,
-        BufferViewTarget_ELEMENT_ARRAY_BUFFER = 34963
-    };
-
-    //! Values for the Sampler::magFilter field
-    enum SamplerMagFilter
-    {
-        SamplerMagFilter_Nearest = 9728,
-        SamplerMagFilter_Linear = 9729
-    };
-
-    //! Values for the Sampler::minFilter field
-    enum SamplerMinFilter
-    {
-        SamplerMinFilter_Nearest = 9728,
-        SamplerMinFilter_Linear = 9729,
-        SamplerMinFilter_Nearest_Mipmap_Nearest = 9984,
-        SamplerMinFilter_Linear_Mipmap_Nearest = 9985,
-        SamplerMinFilter_Nearest_Mipmap_Linear = 9986,
-        SamplerMinFilter_Linear_Mipmap_Linear = 9987
-    };
-
-    //! Values for the Sampler::wrapS and Sampler::wrapT field
-    enum SamplerWrap
-    {
-        SamplerWrap_Clamp_To_Edge = 33071,
-        SamplerWrap_Mirrored_Repeat = 33648,
-        SamplerWrap_Repeat = 10497
-    };
-
-    //! Values for the Texture::format and Texture::internalFormat fields
-    enum TextureFormat
-    {
-        TextureFormat_ALPHA = 6406,
-        TextureFormat_RGB = 6407,
-        TextureFormat_RGBA = 6408,
-        TextureFormat_LUMINANCE = 6409,
-        TextureFormat_LUMINANCE_ALPHA = 6410
-    };
-
-    //! Values for the Texture::target field
-    enum TextureTarget
-    {
-        TextureTarget_TEXTURE_2D = 3553
-    };
-
-    //! Values for the Texture::type field
-    enum TextureType
-    {
-        TextureType_UNSIGNED_BYTE = 5121,
-        TextureType_UNSIGNED_SHORT_5_6_5 = 33635,
-        TextureType_UNSIGNED_SHORT_4_4_4_4 = 32819,
-        TextureType_UNSIGNED_SHORT_5_5_5_1 = 32820
-    };
-
-
-    //! Values for the Accessor::type field (helper class)
-    class AttribType
-    {
-    public:
-        enum Value
-            { SCALAR, VEC2, VEC3, VEC4, MAT2, MAT3, MAT4 };
-
-    private:
-        static const size_t NUM_VALUES = static_cast<size_t>(MAT4)+1;
-
-        struct Info
-            { const char* name; unsigned int numComponents; };
-
-        template<int N> struct data
-            { static const Info infos[NUM_VALUES]; };
-
-    public:
-        inline static Value FromString(const char* str)
-        {
-            for (size_t i = 0; i < NUM_VALUES; ++i) {
-                if (strcmp(data<0>::infos[i].name, str) == 0) {
-                    return static_cast<Value>(i);
-                }
-            }
-            return SCALAR;
-        }
-
-        inline static const char* ToString(Value type)
-        {
-            return data<0>::infos[static_cast<size_t>(type)].name;
-        }
-
-        inline static unsigned int GetNumComponents(Value type)
-        {
-            return data<0>::infos[static_cast<size_t>(type)].numComponents;
-        }
-    };
-
-    // must match the order of the AttribTypeTraits::Value enum!
-    template<int N> const AttribType::Info
-    AttribType::data<N>::infos[AttribType::NUM_VALUES] = {
-        { "SCALAR", 1 }, { "VEC2", 2 }, { "VEC3", 3 }, { "VEC4", 4 }, { "MAT2", 4 }, { "MAT3", 9 }, { "MAT4", 16 }
-    };
-
-
-
-    //! A reference to one top-level object, which is valid
-    //! until the Asset instance is destroyed
-    template<class T>
-    class Ref
-    {
-        std::vector<T*>* vector;
-        unsigned int index;
-
-    public:
-        Ref() : vector(0), index(0) {}
-        Ref(std::vector<T*>& vec, unsigned int idx) : vector(&vec), index(idx) {}
-
-        inline unsigned int GetIndex() const
-            { return index; }
-
-        operator bool() const
-            { return vector != 0; }
-
-        T* operator->()
-            { return (*vector)[index]; }
-
-        T& operator*()
-            { return *((*vector)[index]); }
-    };
-
-    //! Helper struct to represent values that might not be present
-    template<class T>
-    struct Nullable
-    {
-        T value;
-        bool isPresent;
-
-        Nullable() : isPresent(false) {}
-        Nullable(T& val) : value(val), isPresent(true) {}
-    };
-
-
-    //! Base class for all glTF top-level objects
-    struct Object
-    {
-        std::string id;   //!< The globally unique ID used to reference this object
-        std::string name; //!< The user-defined name of this object
-
-        //! Objects marked as special are not exported (used to emulate the binary body buffer)
-        virtual bool IsSpecial() const
-            { return false; }
-
-        virtual ~Object() {}
-
-        //! Maps special IDs to another ID, where needed. Subclasses may override it (statically)
-        static const char* TranslateId(Asset& /*r*/, const char* id)
-            { return id; }
-    };
-
-    //
-    // Classes for each glTF top-level object type
-    //
-
-    //! A typed view into a BufferView. A BufferView contains raw binary data.
-    //! An accessor provides a typed view into a BufferView or a subset of a BufferView
-    //! similar to how WebGL's vertexAttribPointer() defines an attribute in a buffer.
-    struct Accessor : public Object
-    {
-        Ref<BufferView> bufferView;  //!< The ID of the bufferView. (required)
-        unsigned int byteOffset;     //!< The offset relative to the start of the bufferView in bytes. (required)
-        unsigned int byteStride;     //!< The stride, in bytes, between attributes referenced by this accessor. (default: 0)
-        ComponentType componentType; //!< The datatype of components in the attribute. (required)
-        unsigned int count;          //!< The number of attributes referenced by this accessor. (required)
-        AttribType::Value type;      //!< Specifies if the attribute is a scalar, vector, or matrix. (required)
-        std::vector<float> max;      //!< Maximum value of each component in this attribute.
-        std::vector<float> min;      //!< Minimum value of each component in this attribute.
-
-        unsigned int GetNumComponents();
-        unsigned int GetBytesPerComponent();
-        unsigned int GetElementSize();
-
-        inline uint8_t* GetPointer();
-
-        template<class T>
-        bool ExtractData(T*& outData);
-
-        void WriteData(size_t count, const void* src_buffer, size_t src_stride);
-
-        //! Helper class to iterate the data
-        class Indexer
-        {
-            friend struct Accessor;
-
-            Accessor& accessor;
-            uint8_t* data;
-            size_t elemSize, stride;
-
-            Indexer(Accessor& acc);
-
-        public:
-
-            //! Accesses the i-th value as defined by the accessor
-            template<class T>
-            T GetValue(int i);
-
-            //! Accesses the i-th value as defined by the accessor
-            inline unsigned int GetUInt(int i)
-            {
-                return GetValue<unsigned int>(i);
-            }
-
-            inline bool IsValid() const
-            {
-                return data != 0;
-            }
-        };
-
-        inline Indexer GetIndexer()
-        {
-            return Indexer(*this);
-        }
-
-        Accessor() {}
-        void Read(Value& obj, Asset& r);
-    };
-
-    //! A buffer points to binary geometry, animation, or skins.
-    struct Buffer : public Object
-	{
-		/********************* Types *********************/
-	public:
-
-		enum Type
-		{
-			Type_arraybuffer,
-			Type_text
-		};
-
-		/// \struct SEncodedRegion
-		/// Descriptor of encoded region in "bufferView".
-		struct SEncodedRegion
-		{
-			const size_t Offset;///< Offset from begin of "bufferView" to encoded region, in bytes.
-			const size_t EncodedData_Length;///< Size of encoded region, in bytes.
-			uint8_t* const DecodedData;///< Cached encoded data.
-			const size_t DecodedData_Length;///< Size of decoded region, in bytes.
-			const std::string ID;///< ID of the region.
-
-			/// \fn SEncodedRegion(const size_t pOffset, const size_t pEncodedData_Length, uint8_t* pDecodedData, const size_t pDecodedData_Length, const std::string pID)
-			/// Constructor.
-			/// \param [in] pOffset - offset from begin of "bufferView" to encoded region, in bytes.
-			/// \param [in] pEncodedData_Length - size of encoded region, in bytes.
-			/// \param [in] pDecodedData - pointer to decoded data array.
-			/// \param [in] pDecodedData_Length - size of encoded region, in bytes.
-			/// \param [in] pID - ID of the region.
-			SEncodedRegion(const size_t pOffset, const size_t pEncodedData_Length, uint8_t* pDecodedData, const size_t pDecodedData_Length, const std::string pID)
-				: Offset(pOffset), EncodedData_Length(pEncodedData_Length), DecodedData(pDecodedData), DecodedData_Length(pDecodedData_Length), ID(pID)
-			{}
-
-			/// \fn ~SEncodedRegion()
-			/// Destructor.
-			~SEncodedRegion() { delete [] DecodedData; }
-		};
-
-		/******************* Variables *******************/
-
-		//std::string uri; //!< The uri of the buffer. Can be a filepath, a data uri, etc. (required)
-		size_t byteLength; //!< The length of the buffer in bytes. (default: 0)
-		//std::string type; //!< XMLHttpRequest responseType (default: "arraybuffer")
-
-		Type type;
-
-		/// \var EncodedRegion_Current
-		/// Pointer to currently active encoded region.
-		/// Why not decoding all regions at once and not to set one buffer with decoded data?
-		/// Yes, why not? Even "accessor" point to decoded data. I mean that fields "byteOffset", "byteStride" and "count" has values which describes decoded
-		/// data array. But only in range of mesh while is active parameters from "compressedData". For another mesh accessors point to decoded data too. But
-		/// offset is counted for another regions is encoded.
-		/// Example. You have two meshes. For every of it you have 4 bytes of data. That data compressed to 2 bytes. So, you have buffer with encoded data:
-		/// M1_E0, M1_E1, M2_E0, M2_E1.
-		/// After decoding you'll get:
-		/// M1_D0, M1_D1, M1_D2, M1_D3, M2_D0, M2_D1, M2_D2, M2_D3.
-		/// "accessors" must to use values that point to decoded data - obviously. So, you'll expect "accessors" like
-		/// "accessor_0" : { byteOffset: 0, byteLength: 4}, "accessor_1" : { byteOffset: 4, byteLength: 4}
-		/// but in real life you'll get:
-		/// "accessor_0" : { byteOffset: 0, byteLength: 4}, "accessor_1" : { byteOffset: 2, byteLength: 4}
-		/// Yes, accessor of next mesh has offset and length which mean: current mesh data is decoded, all other data is encoded.
-		/// And when before you start to read data of current mesh (with encoded data ofcourse) you must decode region of "bufferView", after read finished
-		/// delete encoding mark. And after that you can repeat process: decode data of mesh, read, delete decoded data.
-		///
-		/// Remark. Encoding all data at once is good in world with computers which do not has RAM limitation. So, you must use step by step encoding in
-		/// exporter and importer. And, thanks to such way, there is no need to load whole file into memory.
-		SEncodedRegion* EncodedRegion_Current;
-
-	private:
-
-		shared_ptr<uint8_t> mData; //!< Pointer to the data
-		bool mIsSpecial; //!< Set to true for special cases (e.g. the body buffer)
-        size_t capacity = 0; //!< The capacity of the buffer in bytes. (default: 0)
-		/// \var EncodedRegion_List
-		/// List of encoded regions.
-		std::list<SEncodedRegion*> EncodedRegion_List;
-
-		/******************* Functions *******************/
-
-	public:
-
-		Buffer();
-		~Buffer();
-
-		void Read(Value& obj, Asset& r);
-
-        bool LoadFromStream(IOStream& stream, size_t length = 0, size_t baseOffset = 0);
-
-		/// \fn void EncodedRegion_Mark(const size_t pOffset, const size_t pEncodedData_Length, uint8_t* pDecodedData, const size_t pDecodedData_Length, const std::string& pID)
-		/// Mark region of "bufferView" as encoded. When data is request from such region then "bufferView" use decoded data.
-		/// \param [in] pOffset - offset from begin of "bufferView" to encoded region, in bytes.
-		/// \param [in] pEncodedData_Length - size of encoded region, in bytes.
-		/// \param [in] pDecodedData - pointer to decoded data array.
-		/// \param [in] pDecodedData_Length - size of encoded region, in bytes.
-		/// \param [in] pID - ID of the region.
-		void EncodedRegion_Mark(const size_t pOffset, const size_t pEncodedData_Length, uint8_t* pDecodedData, const size_t pDecodedData_Length, const std::string& pID);
-
-		/// \fn void EncodedRegion_SetCurrent(const std::string& pID)
-		/// Select current encoded region by ID. \sa EncodedRegion_Current.
-		/// \param [in] pID - ID of the region.
-		void EncodedRegion_SetCurrent(const std::string& pID);
-
-		/// \fn bool ReplaceData(const size_t pBufferData_Offset, const size_t pBufferData_Count, const uint8_t* pReplace_Data, const size_t pReplace_Count)
-		/// Replace part of buffer data. Pay attention that function work with original array of data (\ref mData) not with encoded regions.
-		/// \param [in] pBufferData_Offset - index of first element in buffer from which new data will be placed.
-		/// \param [in] pBufferData_Count - count of bytes in buffer which will be replaced.
-		/// \param [in] pReplace_Data - pointer to array with new data for buffer.
-		/// \param [in] pReplace_Count - count of bytes in new data.
-		/// \return true - if successfully replaced, false if input arguments is out of range.
-		bool ReplaceData(const size_t pBufferData_Offset, const size_t pBufferData_Count, const uint8_t* pReplace_Data, const size_t pReplace_Count);
-
-        size_t AppendData(uint8_t* data, size_t length);
-        void Grow(size_t amount);
-
-        uint8_t* GetPointer()
-            { return mData.get(); }
-
-        void MarkAsSpecial()
-            { mIsSpecial = true; }
-
-        bool IsSpecial() const
-            { return mIsSpecial; }
-
-        std::string GetURI()
-            { return std::string(this->id) + ".bin"; }
-
-        static const char* TranslateId(Asset& r, const char* id);
-    };
-
-    //! A view into a buffer generally representing a subset of the buffer.
-    struct BufferView : public Object
-    {
-        Ref<Buffer> buffer; //! The ID of the buffer. (required)
-        size_t byteOffset; //! The offset into the buffer in bytes. (required)
-        size_t byteLength; //! The length of the bufferView in bytes. (default: 0)
-
-        BufferViewTarget target; //! The target that the WebGL buffer should be bound to.
-
-        void Read(Value& obj, Asset& r);
-    };
-
-    struct Camera : public Object
-    {
-        enum Type
-        {
-            Perspective,
-            Orthographic
-        };
-
-        Type type;
-
-        union
-        {
-            struct {
-                float aspectRatio; //!<The floating - point aspect ratio of the field of view. (0 = undefined = use the canvas one)
-                float yfov;  //!<The floating - point vertical field of view in radians. (required)
-                float zfar;  //!<The floating - point distance to the far clipping plane. (required)
-                float znear; //!< The floating - point distance to the near clipping plane. (required)
-            } perspective;
-
-            struct {
-                float xmag;  //! The floating-point horizontal magnification of the view. (required)
-                float ymag;  //! The floating-point vertical magnification of the view. (required)
-                float zfar;  //! The floating-point distance to the far clipping plane. (required)
-                float znear; //! The floating-point distance to the near clipping plane. (required)
-            } ortographic;
-        };
-
-        Camera() {}
-        void Read(Value& obj, Asset& r);
-    };
-
-
-    //! Image data used to create a texture.
-    struct Image : public Object
-    {
-        std::string uri; //! The uri of the image, that can be a file path, a data URI, etc.. (required)
-
-        Ref<BufferView> bufferView;
-
-        std::string mimeType;
-
-        int width, height;
-
-    private:
-        std::unique_ptr<uint8_t[]> mData;
-        size_t mDataLength;
-
-    public:
-
-        Image();
-        void Read(Value& obj, Asset& r);
-
-        inline bool HasData() const
-            { return mDataLength > 0; }
-
-        inline size_t GetDataLength() const
-            { return mDataLength; }
-
-        inline const uint8_t* GetData() const
-            { return mData.get(); }
-
-        inline uint8_t* StealData();
-
-        inline void SetData(uint8_t* data, size_t length, Asset& r);
-    };
-
-    //! Holds a material property that can be a texture or a color
-    struct TexProperty
-    {
-        Ref<Texture> texture;
-        vec4 color;
-    };
-
-    //! The material appearance of a primitive.
-    struct Material : public Object
-    {
-        //Ref<Sampler> source; //!< The ID of the technique.
-        //std::gltf_unordered_map<std::string, std::string> values; //!< A dictionary object of parameter values.
-
-        //! Techniques defined by KHR_materials_common
-        enum Technique
-        {
-            Technique_undefined = 0,
-            Technique_BLINN,
-            Technique_PHONG,
-            Technique_LAMBERT,
-            Technique_CONSTANT
-        };
-
-        TexProperty ambient;
-        TexProperty diffuse;
-        TexProperty specular;
-        TexProperty emission;
-
-        bool doubleSided;
-        bool transparent;
-        float transparency;
-        float shininess;
-
-        Technique technique;
-
-        Material() { SetDefaults(); }
-        void Read(Value& obj, Asset& r);
-        void SetDefaults();
-    };
-
-    //! A set of primitives to be rendered. A node can contain one or more meshes. A node's transform places the mesh in the scene.
-    struct Mesh : public Object
-    {
-        typedef std::vector< Ref<Accessor> > AccessorList;
-
-        struct Primitive
-        {
-            PrimitiveMode mode;
-
-            struct Attributes {
-                AccessorList position, normal, texcoord, color, joint, jointmatrix, weight;
-            } attributes;
-
-            Ref<Accessor> indices;
-
-            Ref<Material> material;
-        };
-
-		/// \struct SExtension
-		/// Extension used for mesh.
-		struct SExtension
-		{
-			/// \enum EType
-			/// Type of extension.
-			enum EType
-			{
-				#ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC
-					Compression_Open3DGC,///< Compression of mesh data using Open3DGC algorithm.
-				#endif
-
-				Unknown
-			};
-
-			EType Type;///< Type of extension.
-
-			/// \fn SExtension
-			/// Constructor.
-			/// \param [in] pType - type of extension.
-			SExtension(const EType pType)
-				: Type(pType)
-			{}
-
-            virtual ~SExtension() {
-                // empty
-            }
-		};
-
-		#ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC
-			/// \struct SCompression_Open3DGC
-			/// Compression of mesh data using Open3DGC algorithm.
-			struct SCompression_Open3DGC : public SExtension
-			{
-				using SExtension::Type;
-
-				std::string Buffer;///< ID of "buffer" used for storing compressed data.
-				size_t Offset;///< Offset in "bufferView" where compressed data are stored.
-				size_t Count;///< Count of elements in compressed data. Is always equivalent to size in bytes: look comments for "Type" and "Component_Type".
-				bool Binary;///< If true then "binary" mode is used for coding, if false - "ascii" mode.
-				size_t IndicesCount;///< Count of indices in mesh.
-				size_t VerticesCount;///< Count of vertices in mesh.
-				// AttribType::Value Type;///< Is always "SCALAR".
-				// ComponentType Component_Type;///< Is always "ComponentType_UNSIGNED_BYTE" (5121).
-
-				/// \fn SCompression_Open3DGC
-				/// Constructor.
-				SCompression_Open3DGC()
-				: SExtension(Compression_Open3DGC) {
-                    // empty
-                }
-
-                virtual ~SCompression_Open3DGC() {
-                    // empty
-                }
-			};
-		#endif
-
-        std::vector<Primitive> primitives;
-		std::list<SExtension*> Extension;///< List of extensions used in mesh.
-
-        Mesh() {}
-
-		/// \fn ~Mesh()
-		/// Destructor.
-		~Mesh() { for(std::list<SExtension*>::iterator it = Extension.begin(), it_end = Extension.end(); it != it_end; it++) { delete *it; }; }
-
-		/// \fn void Read(Value& pJSON_Object, Asset& pAsset_Root)
-		/// Get mesh data from JSON-object and place them to root asset.
-		/// \param [in] pJSON_Object - reference to pJSON-object from which data are read.
-		/// \param [out] pAsset_Root - reference to root assed where data will be stored.
-		void Read(Value& pJSON_Object, Asset& pAsset_Root);
-
-		#ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC
-			/// \fn void Decode_O3DGC(const SCompression_Open3DGC& pCompression_Open3DGC, Asset& pAsset_Root)
-			/// Decode part of "buffer" which encoded with Open3DGC algorithm.
-			/// \param [in] pCompression_Open3DGC - reference to structure which describe encoded region.
-			/// \param [out] pAsset_Root - reference to root assed where data will be stored.
-			void Decode_O3DGC(const SCompression_Open3DGC& pCompression_Open3DGC, Asset& pAsset_Root);
-		#endif
-    };
-
-    struct Node : public Object
-    {
-        std::vector< Ref<Node> > children;
-        std::vector< Ref<Mesh> > meshes;
-
-        Nullable<mat4> matrix;
-        Nullable<vec3> translation;
-        Nullable<vec4> rotation;
-        Nullable<vec3> scale;
-
-        Ref<Camera> camera;
-        Ref<Light>  light;
-
-        std::vector< Ref<Node> > skeletons;       //!< The ID of skeleton nodes. Each of which is the root of a node hierarchy.
-        Ref<Skin>  skin;                          //!< The ID of the skin referenced by this node.
-        std::string jointName;                    //!< Name used when this node is a joint in a skin.
-
-        Ref<Node> parent;                         //!< This is not part of the glTF specification. Used as a helper.
-
-        Node() {}
-        void Read(Value& obj, Asset& r);
-    };
-
-    struct Program : public Object
-    {
-        Program() {}
-        void Read(Value& obj, Asset& r);
-    };
-
-
-    struct Sampler : public Object
-    {
-        SamplerMagFilter magFilter; //!< The texture magnification filter. (required)
-        SamplerMinFilter minFilter; //!< The texture minification filter. (required)
-        SamplerWrap wrapS;          //!< The texture wrapping in the S direction. (required)
-        SamplerWrap wrapT;          //!< The texture wrapping in the T direction. (required)
-
-        Sampler() {}
-        void Read(Value& obj, Asset& r);
-        void SetDefaults();
-    };
-
-    struct Scene : public Object
-    {
-        std::vector< Ref<Node> > nodes;
-
-        Scene() {}
-        void Read(Value& obj, Asset& r);
-    };
-
-    struct Shader : public Object
-    {
-        Shader() {}
-        void Read(Value& obj, Asset& r);
-    };
-
-    struct Skin : public Object
-    {
-        Nullable<mat4> bindShapeMatrix;       //!< Floating-point 4x4 transformation matrix stored in column-major order.
-        Ref<Accessor> inverseBindMatrices;    //!< The ID of the accessor containing the floating-point 4x4 inverse-bind matrices.
-        std::vector<Ref<Node>> jointNames;    //!< Joint names of the joints (nodes with a jointName property) in this skin.
-        std::string name;                     //!< The user-defined name of this object.
-
-        Skin() {}
-        void Read(Value& obj, Asset& r);
-    };
-
-    struct Technique : public Object
-    {
-        struct Parameters
-        {
-
-        };
-
-        struct States
-        {
-
-        };
-
-        struct Functions
-        {
-
-        };
-
-        Technique() {}
-        void Read(Value& obj, Asset& r);
-    };
-
-    //! A texture and its sampler.
-    struct Texture : public Object
-    {
-        Ref<Sampler> sampler; //!< The ID of the sampler used by this texture. (required)
-        Ref<Image> source;    //!< The ID of the image used by this texture. (required)
-
-        //TextureFormat format; //!< The texture's format. (default: TextureFormat_RGBA)
-        //TextureFormat internalFormat; //!< The texture's internal format. (default: TextureFormat_RGBA)
-
-        //TextureTarget target; //!< The target that the WebGL texture should be bound to. (default: TextureTarget_TEXTURE_2D)
-        //TextureType type; //!< Texel datatype. (default: TextureType_UNSIGNED_BYTE)
-
-        Texture() {}
-        void Read(Value& obj, Asset& r);
-    };
-
-
-    //! A light (from KHR_materials_common extension)
-    struct Light : public Object
-    {
-        enum Type
-        {
-            Type_undefined,
-            Type_ambient,
-            Type_directional,
-            Type_point,
-            Type_spot
-        };
-
-        Type type;
-
-        vec4 color;
-        float distance;
-        float constantAttenuation;
-        float linearAttenuation;
-        float quadraticAttenuation;
-        float falloffAngle;
-        float falloffExponent;
-
-        Light() {}
-        void Read(Value& obj, Asset& r);
-
-        void SetDefaults();
-    };
-
-    struct Animation : public Object
-    {
-        struct AnimSampler {
-            std::string id;               //!< The ID of this sampler.
-            std::string input;            //!< The ID of a parameter in this animation to use as key-frame input.
-            std::string interpolation;    //!< Type of interpolation algorithm to use between key-frames.
-            std::string output;           //!< The ID of a parameter in this animation to use as key-frame output.
-        };
-
-        struct AnimChannel {
-            std::string sampler;         //!< The ID of one sampler present in the containing animation's samplers property.
-
-            struct AnimTarget {
-                Ref<Node> id;            //!< The ID of the node to animate.
-                std::string path;        //!< The name of property of the node to animate ("translation", "rotation", or "scale").
-            } target;
-        };
-
-        struct AnimParameters {
-            Ref<Accessor> TIME;           //!< Accessor reference to a buffer storing a array of floating point scalar values.
-            Ref<Accessor> rotation;       //!< Accessor reference to a buffer storing a array of four-component floating-point vectors.
-            Ref<Accessor> scale;          //!< Accessor reference to a buffer storing a array of three-component floating-point vectors.
-            Ref<Accessor> translation;    //!< Accessor reference to a buffer storing a array of three-component floating-point vectors.
-        };
-
-        // AnimChannel Channels[3];            //!< Connect the output values of the key-frame animation to a specific node in the hierarchy.
-        // AnimParameters Parameters;          //!< The samplers that interpolate between the key-frames.
-        // AnimSampler Samplers[3];            //!< The parameterized inputs representing the key-frame data.
-
-        std::vector<AnimChannel> Channels;            //!< Connect the output values of the key-frame animation to a specific node in the hierarchy.
-        AnimParameters Parameters;                    //!< The samplers that interpolate between the key-frames.
-        std::vector<AnimSampler> Samplers;         //!< The parameterized inputs representing the key-frame data.
-
-        Animation() {}
-        void Read(Value& obj, Asset& r);
-    };
-
-
-    //! Base class for LazyDict that acts as an interface
-    class LazyDictBase
-    {
-    public:
-        virtual ~LazyDictBase() {}
-
-        virtual void AttachToDocument(Document& doc) = 0;
-        virtual void DetachFromDocument() = 0;
-
-        virtual void WriteObjects(AssetWriter& writer) = 0;
-    };
-
-
-    template<class T>
-    class LazyDict;
-
-    //! (Implemented in glTFAssetWriter.h)
-    template<class T>
-    void WriteLazyDict(LazyDict<T>& d, AssetWriter& w);
-
-
-    //! Manages lazy loading of the glTF top-level objects, and keeps a reference to them by ID
-    //! It is the owner the loaded objects, so when it is destroyed it also deletes them
-    template<class T>
-    class LazyDict : public LazyDictBase
-    {
-        friend class Asset;
-        friend class AssetWriter;
-
-        typedef typename std::gltf_unordered_map< std::string, unsigned int > Dict;
-
-        std::vector<T*>  mObjs;      //! The read objects
-        Dict             mObjsById;  //! The read objects accessible by id
-        const char*      mDictId;    //! ID of the dictionary object
-        const char*      mExtId;     //! ID of the extension defining the dictionary
-        Value*           mDict;      //! JSON dictionary object
-        Asset&           mAsset;     //! The asset instance
-
-        void AttachToDocument(Document& doc);
-        void DetachFromDocument();
-
-        void WriteObjects(AssetWriter& writer)
-            { WriteLazyDict<T>(*this, writer); }
-
-        Ref<T> Add(T* obj);
-
-    public:
-        LazyDict(Asset& asset, const char* dictId, const char* extId = 0);
-        ~LazyDict();
-
-        Ref<T> Get(const char* id);
-        Ref<T> Get(unsigned int i);
-        Ref<T> Get(const std::string& pID) { return Get(pID.c_str()); }
-
-        Ref<T> Create(const char* id);
-        Ref<T> Create(const std::string& id)
-            { return Create(id.c_str()); }
-
-        inline unsigned int Size() const
-            { return unsigned(mObjs.size()); }
-
-        inline T& operator[](size_t i)
-            { return *mObjs[i]; }
-
-    };
-
-
-    struct AssetMetadata
-    {
-        std::string copyright; //!< A copyright message suitable for display to credit the content creator.
-        std::string generator; //!< Tool that generated this glTF model.Useful for debugging.
-        bool premultipliedAlpha; //!< Specifies if the shaders were generated with premultiplied alpha. (default: false)
-
-        struct {
-            std::string api;     //!< Specifies the target rendering API (default: "WebGL")
-            std::string version; //!< Specifies the target rendering API (default: "1.0.3")
-        } profile; //!< Specifies the target rendering API and version, e.g., WebGL 1.0.3. (default: {})
-
-        std::string version; //!< The glTF format version (should be 1.0)
-
-        void Read(Document& doc);
-
-        AssetMetadata()
-            : premultipliedAlpha(false)
-            , version("")
-        {
-        }
-    };
-
-    //
-    // glTF Asset class
-    //
-
-    //! Root object for a glTF asset
-    class Asset
-    {
-        typedef std::gltf_unordered_map<std::string, int> IdMap;
-
-        template<class T>
-        friend class LazyDict;
-
-        friend struct Buffer; // To access OpenFile
-
-        friend class AssetWriter;
-
-    private:
-        IOSystem* mIOSystem;
-
-        std::string mCurrentAssetDir;
-
-        size_t mSceneLength;
-        size_t mBodyOffset, mBodyLength;
-
-        std::vector<LazyDictBase*> mDicts;
-
-        IdMap mUsedIds;
-
-        Ref<Buffer> mBodyBuffer;
-
-        Asset(Asset&);
-        Asset& operator=(const Asset&);
-
-    public:
-
-        //! Keeps info about the enabled extensions
-        struct Extensions
-        {
-            bool KHR_binary_glTF;
-            bool KHR_materials_common;
-
-        } extensionsUsed;
-
-        AssetMetadata asset;
-
-
-        // Dictionaries for each type of object
-
-        LazyDict<Accessor>    accessors;
-        LazyDict<Animation>   animations;
-        LazyDict<Buffer>      buffers;
-        LazyDict<BufferView>  bufferViews;
-        LazyDict<Camera>      cameras;
-        LazyDict<Image>       images;
-        LazyDict<Material>    materials;
-        LazyDict<Mesh>        meshes;
-        LazyDict<Node>        nodes;
-        //LazyDict<Program>   programs;
-        LazyDict<Sampler>     samplers;
-        LazyDict<Scene>       scenes;
-        //LazyDict<Shader>    shaders;
-        LazyDict<Skin>      skins;
-        //LazyDict<Technique> techniques;
-        LazyDict<Texture>     textures;
-
-        LazyDict<Light>       lights; // KHR_materials_common ext
-
-        Ref<Scene> scene;
-
-    public:
-        Asset(IOSystem* io = 0)
-            : mIOSystem(io)
-            , asset()
-            , accessors     (*this, "accessors")
-            , animations    (*this, "animations")
-            , buffers       (*this, "buffers")
-            , bufferViews   (*this, "bufferViews")
-            , cameras       (*this, "cameras")
-            , images        (*this, "images")
-            , materials     (*this, "materials")
-            , meshes        (*this, "meshes")
-            , nodes         (*this, "nodes")
-            //, programs    (*this, "programs")
-            , samplers      (*this, "samplers")
-            , scenes        (*this, "scenes")
-            //, shaders     (*this, "shaders")
-            , skins       (*this, "skins")
-            //, techniques  (*this, "techniques")
-            , textures      (*this, "textures")
-            , lights        (*this, "lights", "KHR_materials_common")
-        {
-            memset(&extensionsUsed, 0, sizeof(extensionsUsed));
-        }
-
-        //! Main function
-        void Load(const std::string& file, bool isBinary = false);
-
-        //! Enables the "KHR_binary_glTF" extension on the asset
-        void SetAsBinary();
-
-        //! Search for an available name, starting from the given strings
-        std::string FindUniqueID(const std::string& str, const char* suffix);
-
-        Ref<Buffer> GetBodyBuffer()
-            { return mBodyBuffer; }
-
-    private:
-        void ReadBinaryHeader(IOStream& stream);
-
-        void ReadExtensionsUsed(Document& doc);
-
-
-        IOStream* OpenFile(std::string path, const char* mode, bool absolute = false);
-    };
-
-}
-
-// Include the implementation of the methods
-#include "glTFAsset.inl"
-
-#endif // ASSIMP_BUILD_NO_GLTF_IMPORTER
-
-#endif // GLTFASSET_H_INC
diff --git a/Engine/lib/assimp/code/glTF/glTFAsset.inl b/Engine/lib/assimp/code/glTF/glTFAsset.inl
deleted file mode 100644
index f31781a3f..000000000
--- a/Engine/lib/assimp/code/glTF/glTFAsset.inl
+++ /dev/null
@@ -1,1481 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-#include <assimp/StringUtils.h>
-#include <iomanip>
-
-// Header files, Assimp
-#include <assimp/DefaultLogger.hpp>
-
-#ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC
-	// Header files, Open3DGC.
-#	include <Open3DGC/o3dgcSC3DMCDecoder.h>
-#endif
-
-using namespace Assimp;
-using namespace glTFCommon;
-
-namespace glTF {
-
-namespace {
-
-    //
-    // JSON Value reading helpers
-    //
-
-    template<class T>
-    struct ReadHelper { static bool Read(Value& val, T& out) {
-        return val.IsInt() ? out = static_cast<T>(val.GetInt()), true : false;
-    }};
-
-    template<> struct ReadHelper<bool> { static bool Read(Value& val, bool& out) {
-        return val.IsBool() ? out = val.GetBool(), true : false;
-    }};
-
-    template<> struct ReadHelper<float> { static bool Read(Value& val, float& out) {
-        return val.IsNumber() ? out = static_cast<float>(val.GetDouble()), true : false;
-    }};
-
-    template<unsigned int N> struct ReadHelper<float[N]> { static bool Read(Value& val, float (&out)[N]) {
-        if (!val.IsArray() || val.Size() != N) return false;
-        for (unsigned int i = 0; i < N; ++i) {
-            if (val[i].IsNumber())
-                out[i] = static_cast<float>(val[i].GetDouble());
-        }
-        return true;
-    }};
-
-    template<> struct ReadHelper<const char*> { static bool Read(Value& val, const char*& out) {
-        return val.IsString() ? (out = val.GetString(), true) : false;
-    }};
-
-    template<> struct ReadHelper<std::string> { static bool Read(Value& val, std::string& out) {
-        return val.IsString() ? (out = std::string(val.GetString(), val.GetStringLength()), true) : false;
-    }};
-
-    template<class T> struct ReadHelper< Nullable<T> > { static bool Read(Value& val, Nullable<T>& out) {
-        return out.isPresent = ReadHelper<T>::Read(val, out.value);
-    }};
-
-    template<> struct ReadHelper<uint64_t> { static bool Read(Value& val, uint64_t& out) {
-        return val.IsUint64() ? out = val.GetUint64(), true : false;
-    }};
-
-    template<> struct ReadHelper<int64_t> { static bool Read(Value& val, int64_t& out) {
-        return val.IsInt64() ? out = val.GetInt64(), true : false;
-    }};
-
-    template<class T>
-    inline static bool ReadValue(Value& val, T& out)
-    {
-        return ReadHelper<T>::Read(val, out);
-    }
-
-    template<class T>
-    inline static bool ReadMember(Value& obj, const char* id, T& out)
-    {
-        Value::MemberIterator it = obj.FindMember(id);
-        if (it != obj.MemberEnd()) {
-            return ReadHelper<T>::Read(it->value, out);
-        }
-        return false;
-    }
-
-    template<class T>
-    inline static T MemberOrDefault(Value& obj, const char* id, T defaultValue)
-    {
-        T out;
-        return ReadMember(obj, id, out) ? out : defaultValue;
-    }
-
-    inline Value* FindMember(Value& val, const char* id)
-    {
-        Value::MemberIterator it = val.FindMember(id);
-        return (it != val.MemberEnd()) ? &it->value : 0;
-    }
-
-    inline Value* FindString(Value& val, const char* id)
-    {
-        Value::MemberIterator it = val.FindMember(id);
-        return (it != val.MemberEnd() && it->value.IsString()) ? &it->value : 0;
-    }
-
-    inline Value* FindNumber(Value& val, const char* id)
-    {
-        Value::MemberIterator it = val.FindMember(id);
-        return (it != val.MemberEnd() && it->value.IsNumber()) ? &it->value : 0;
-    }
-
-    inline Value* FindArray(Value& val, const char* id)
-    {
-        Value::MemberIterator it = val.FindMember(id);
-        return (it != val.MemberEnd() && it->value.IsArray()) ? &it->value : 0;
-    }
-
-    inline Value* FindObject(Value& val, const char* id)
-    {
-        Value::MemberIterator it = val.FindMember(id);
-        return (it != val.MemberEnd() && it->value.IsObject()) ? &it->value : 0;
-    }
-}
-
-//
-// LazyDict methods
-//
-
-template<class T>
-inline LazyDict<T>::LazyDict(Asset& asset, const char* dictId, const char* extId)
-    : mDictId(dictId), mExtId(extId), mDict(0), mAsset(asset)
-{
-    asset.mDicts.push_back(this); // register to the list of dictionaries
-}
-
-template<class T>
-inline LazyDict<T>::~LazyDict()
-{
-    for (size_t i = 0; i < mObjs.size(); ++i) {
-        delete mObjs[i];
-    }
-}
-
-
-template<class T>
-inline void LazyDict<T>::AttachToDocument(Document& doc)
-{
-    Value* container = 0;
-
-    if (mExtId) {
-        if (Value* exts = FindObject(doc, "extensions")) {
-            container = FindObject(*exts, mExtId);
-        }
-    }
-    else {
-        container = &doc;
-    }
-
-    if (container) {
-        mDict = FindObject(*container, mDictId);
-    }
-}
-
-template<class T>
-inline void LazyDict<T>::DetachFromDocument()
-{
-    mDict = 0;
-}
-
-template<class T>
-Ref<T> LazyDict<T>::Get(unsigned int i)
-{
-    return Ref<T>(mObjs, i);
-}
-
-template<class T>
-Ref<T> LazyDict<T>::Get(const char* id)
-{
-    id = T::TranslateId(mAsset, id);
-
-    typename Dict::iterator it = mObjsById.find(id);
-    if (it != mObjsById.end()) { // already created?
-        return Ref<T>(mObjs, it->second);
-    }
-
-    // read it from the JSON object
-    if (!mDict) {
-        throw DeadlyImportError("GLTF: Missing section \"" + std::string(mDictId) + "\"");
-    }
-
-    Value::MemberIterator obj = mDict->FindMember(id);
-    if (obj == mDict->MemberEnd()) {
-        throw DeadlyImportError("GLTF: Missing object with id \"" + std::string(id) + "\" in \"" + mDictId + "\"");
-    }
-    if (!obj->value.IsObject()) {
-        throw DeadlyImportError("GLTF: Object with id \"" + std::string(id) + "\" is not a JSON object");
-    }
-
-    // create an instance of the given type
-    T* inst = new T();
-    inst->id = id;
-    ReadMember(obj->value, "name", inst->name);
-    inst->Read(obj->value, mAsset);
-    return Add(inst);
-}
-
-template<class T>
-Ref<T> LazyDict<T>::Add(T* obj)
-{
-    unsigned int idx = unsigned(mObjs.size());
-    mObjs.push_back(obj);
-    mObjsById[obj->id] = idx;
-    mAsset.mUsedIds[obj->id] = true;
-    return Ref<T>(mObjs, idx);
-}
-
-template<class T>
-Ref<T> LazyDict<T>::Create(const char* id)
-{
-    Asset::IdMap::iterator it = mAsset.mUsedIds.find(id);
-    if (it != mAsset.mUsedIds.end()) {
-        throw DeadlyImportError("GLTF: two objects with the same ID exist");
-    }
-    T* inst = new T();
-    inst->id = id;
-    return Add(inst);
-}
-
-
-//
-// glTF dictionary objects methods
-//
-
-
-inline Buffer::Buffer()
-	: byteLength(0), type(Type_arraybuffer), EncodedRegion_Current(nullptr), mIsSpecial(false)
-{ }
-
-inline Buffer::~Buffer()
-{
-	for(SEncodedRegion* reg : EncodedRegion_List) delete reg;
-}
-
-inline const char* Buffer::TranslateId(Asset& r, const char* id)
-{
-    // Compatibility with old spec
-    if (r.extensionsUsed.KHR_binary_glTF && strcmp(id, "KHR_binary_glTF") == 0) {
-        return "binary_glTF";
-    }
-
-    return id;
-}
-
-inline void Buffer::Read(Value& obj, Asset& r)
-{
-    size_t statedLength = MemberOrDefault<size_t>(obj, "byteLength", 0);
-    byteLength = statedLength;
-
-    Value* it = FindString(obj, "uri");
-    if (!it) {
-        if (statedLength > 0) {
-            throw DeadlyImportError("GLTF: buffer with non-zero length missing the \"uri\" attribute");
-        }
-        return;
-    }
-
-    const char* uri = it->GetString();
-
-    glTFCommon::Util::DataURI dataURI;
-    if (ParseDataURI(uri, it->GetStringLength(), dataURI)) {
-        if (dataURI.base64) {
-            uint8_t* data = 0;
-            this->byteLength = Util::DecodeBase64(dataURI.data, dataURI.dataLength, data);
-            this->mData.reset(data, std::default_delete<uint8_t[]>());
-
-            if (statedLength > 0 && this->byteLength != statedLength) {
-                throw DeadlyImportError("GLTF: buffer \"" + id + "\", expected " + to_string(statedLength) +
-                    " bytes, but found " + to_string(dataURI.dataLength));
-            }
-        }
-        else { // assume raw data
-            if (statedLength != dataURI.dataLength) {
-                throw DeadlyImportError("GLTF: buffer \"" + id + "\", expected " + to_string(statedLength) +
-                                        " bytes, but found " + to_string(dataURI.dataLength));
-            }
-
-            this->mData.reset(new uint8_t[dataURI.dataLength], std::default_delete<uint8_t[]>());
-            memcpy( this->mData.get(), dataURI.data, dataURI.dataLength );
-        }
-    }
-    else { // Local file
-        if (byteLength > 0) {
-            std::string dir = !r.mCurrentAssetDir.empty() ? (r.mCurrentAssetDir + "/") : "";
-
-            IOStream* file = r.OpenFile(dir + uri, "rb");
-            if (file) {
-                bool ok = LoadFromStream(*file, byteLength);
-                delete file;
-
-                if (!ok)
-                    throw DeadlyImportError("GLTF: error while reading referenced file \"" + std::string(uri) + "\"" );
-            }
-            else {
-                throw DeadlyImportError("GLTF: could not open referenced file \"" + std::string(uri) + "\"");
-            }
-        }
-    }
-}
-
-inline bool Buffer::LoadFromStream(IOStream& stream, size_t length, size_t baseOffset)
-{
-    byteLength = length ? length : stream.FileSize();
-
-    if (baseOffset) {
-        stream.Seek(baseOffset, aiOrigin_SET);
-    }
-
-    mData.reset(new uint8_t[byteLength], std::default_delete<uint8_t[]>());
-
-    if (stream.Read(mData.get(), byteLength, 1) != 1) {
-        return false;
-    }
-    return true;
-}
-
-inline void Buffer::EncodedRegion_Mark(const size_t pOffset, const size_t pEncodedData_Length, uint8_t* pDecodedData, const size_t pDecodedData_Length, const std::string& pID)
-{
-	// Check pointer to data
-	if(pDecodedData == nullptr) throw DeadlyImportError("GLTF: for marking encoded region pointer to decoded data must be provided.");
-
-	// Check offset
-	if(pOffset > byteLength)
-	{
-		const uint8_t val_size = 32;
-
-		char val[val_size];
-
-		ai_snprintf(val, val_size, "%llu", (long long)pOffset);
-		throw DeadlyImportError(std::string("GLTF: incorrect offset value (") + val + ") for marking encoded region.");
-	}
-
-	// Check length
-	if((pOffset + pEncodedData_Length) > byteLength)
-	{
-		const uint8_t val_size = 64;
-
-		char val[val_size];
-
-		ai_snprintf(val, val_size, "%llu, %llu", (long long)pOffset, (long long)pEncodedData_Length);
-		throw DeadlyImportError(std::string("GLTF: encoded region with offset/length (") + val + ") is out of range.");
-	}
-
-	// Add new region
-	EncodedRegion_List.push_back(new SEncodedRegion(pOffset, pEncodedData_Length, pDecodedData, pDecodedData_Length, pID));
-	// And set new value for "byteLength"
-	byteLength += (pDecodedData_Length - pEncodedData_Length);
-}
-
-inline void Buffer::EncodedRegion_SetCurrent(const std::string& pID)
-{
-	if((EncodedRegion_Current != nullptr) && (EncodedRegion_Current->ID == pID)) return;
-
-	for(SEncodedRegion* reg : EncodedRegion_List)
-	{
-		if(reg->ID == pID)
-		{
-			EncodedRegion_Current = reg;
-
-			return;
-		}
-
-	}
-
-	throw DeadlyImportError("GLTF: EncodedRegion with ID: \"" + pID + "\" not found.");
-}
-
-inline bool Buffer::ReplaceData(const size_t pBufferData_Offset, const size_t pBufferData_Count, const uint8_t* pReplace_Data, const size_t pReplace_Count)
-{
-const size_t new_data_size = byteLength + pReplace_Count - pBufferData_Count;
-
-uint8_t* new_data;
-
-	if((pBufferData_Count == 0) || (pReplace_Count == 0) || (pReplace_Data == nullptr)) return false;
-
-	new_data = new uint8_t[new_data_size];
-	// Copy data which place before replacing part.
-	memcpy(new_data, mData.get(), pBufferData_Offset);
-	// Copy new data.
-	memcpy(&new_data[pBufferData_Offset], pReplace_Data, pReplace_Count);
-	// Copy data which place after replacing part.
-	memcpy(&new_data[pBufferData_Offset + pReplace_Count], &mData.get()[pBufferData_Offset + pBufferData_Count], pBufferData_Offset);
-	// Apply new data
-	mData.reset(new_data, std::default_delete<uint8_t[]>());
-	byteLength = new_data_size;
-
-	return true;
-}
-
-inline size_t Buffer::AppendData(uint8_t* data, size_t length)
-{
-    size_t offset = this->byteLength;
-    Grow(length);
-    memcpy(mData.get() + offset, data, length);
-    return offset;
-}
-
-inline void Buffer::Grow(size_t amount)
-{
-    if (amount <= 0) return;
-    if (capacity >= byteLength + amount)
-    {
-        byteLength += amount;
-        return;
-    }
-
-    // Shift operation is standard way to divide integer by 2, it doesn't cast it to float back and forth, also works for odd numbers,
-    // originally it would look like: static_cast<size_t>(capacity * 1.5f)
-    capacity = std::max(capacity + (capacity >> 1), byteLength + amount);
-
-    uint8_t* b = new uint8_t[capacity];
-    if (mData) memcpy(b, mData.get(), byteLength);
-    mData.reset(b, std::default_delete<uint8_t[]>());
-    byteLength += amount;
-}
-
-//
-// struct BufferView
-//
-
-inline void BufferView::Read(Value& obj, Asset& r)
-{
-    const char* bufferId = MemberOrDefault<const char*>(obj, "buffer", 0);
-    if (bufferId) {
-        buffer = r.buffers.Get(bufferId);
-    }
-
-    byteOffset = MemberOrDefault(obj, "byteOffset", 0u);
-    byteLength = MemberOrDefault(obj, "byteLength", 0u);
-}
-
-//
-// struct Accessor
-//
-
-inline void Accessor::Read(Value& obj, Asset& r)
-{
-    const char* bufferViewId = MemberOrDefault<const char*>(obj, "bufferView", 0);
-    if (bufferViewId) {
-        bufferView = r.bufferViews.Get(bufferViewId);
-    }
-
-    byteOffset = MemberOrDefault(obj, "byteOffset", 0u);
-    byteStride = MemberOrDefault(obj, "byteStride", 0u);
-    componentType = MemberOrDefault(obj, "componentType", ComponentType_BYTE);
-    count = MemberOrDefault(obj, "count", 0u);
-
-    const char* typestr;
-    type = ReadMember(obj, "type", typestr) ? AttribType::FromString(typestr) : AttribType::SCALAR;
-}
-
-inline unsigned int Accessor::GetNumComponents()
-{
-    return AttribType::GetNumComponents(type);
-}
-
-inline unsigned int Accessor::GetBytesPerComponent()
-{
-    return int(ComponentTypeSize(componentType));
-}
-
-inline unsigned int Accessor::GetElementSize()
-{
-    return GetNumComponents() * GetBytesPerComponent();
-}
-
-inline uint8_t* Accessor::GetPointer()
-{
-    if (!bufferView || !bufferView->buffer) return 0;
-    uint8_t* basePtr = bufferView->buffer->GetPointer();
-    if (!basePtr) return 0;
-
-    size_t offset = byteOffset + bufferView->byteOffset;
-
-	// Check if region is encoded.
-	if(bufferView->buffer->EncodedRegion_Current != nullptr)
-	{
-		const size_t begin = bufferView->buffer->EncodedRegion_Current->Offset;
-		const size_t end = begin + bufferView->buffer->EncodedRegion_Current->DecodedData_Length;
-
-		if((offset >= begin) && (offset < end))
-			return &bufferView->buffer->EncodedRegion_Current->DecodedData[offset - begin];
-	}
-
-	return basePtr + offset;
-}
-
-namespace {
-    inline void CopyData(size_t count,
-            const uint8_t* src, size_t src_stride,
-                  uint8_t* dst, size_t dst_stride)
-    {
-        if (src_stride == dst_stride) {
-            memcpy(dst, src, count * src_stride);
-        }
-        else {
-            size_t sz = std::min(src_stride, dst_stride);
-            for (size_t i = 0; i < count; ++i) {
-                memcpy(dst, src, sz);
-                if (sz < dst_stride) {
-                    memset(dst + sz, 0, dst_stride - sz);
-                }
-                src += src_stride;
-                dst += dst_stride;
-            }
-        }
-    }
-}
-
-template<class T>
-bool Accessor::ExtractData(T*& outData)
-{
-    uint8_t* data = GetPointer();
-    if (!data) return false;
-
-    const size_t elemSize = GetElementSize();
-    const size_t totalSize = elemSize * count;
-
-    const size_t stride = byteStride ? byteStride : elemSize;
-
-    const size_t targetElemSize = sizeof(T);
-    ai_assert(elemSize <= targetElemSize);
-
-    ai_assert(count*stride <= bufferView->byteLength);
-
-    outData = new T[count];
-    if (stride == elemSize && targetElemSize == elemSize) {
-        memcpy(outData, data, totalSize);
-    }
-    else {
-        for (size_t i = 0; i < count; ++i) {
-            memcpy(outData + i, data + i*stride, elemSize);
-        }
-    }
-
-    return true;
-}
-
-inline void Accessor::WriteData(size_t count, const void* src_buffer, size_t src_stride)
-{
-    uint8_t* buffer_ptr = bufferView->buffer->GetPointer();
-    size_t offset = byteOffset + bufferView->byteOffset;
-
-    size_t dst_stride = GetNumComponents() * GetBytesPerComponent();
-
-    const uint8_t* src = reinterpret_cast<const uint8_t*>(src_buffer);
-    uint8_t*       dst = reinterpret_cast<      uint8_t*>(buffer_ptr + offset);
-
-    ai_assert(dst + count*dst_stride <= buffer_ptr + bufferView->buffer->byteLength);
-    CopyData(count, src, src_stride, dst, dst_stride);
-}
-
-
-
-inline Accessor::Indexer::Indexer(Accessor& acc)
-    : accessor(acc)
-    , data(acc.GetPointer())
-    , elemSize(acc.GetElementSize())
-    , stride(acc.byteStride ? acc.byteStride : elemSize)
-{
-
-}
-
-//! Accesses the i-th value as defined by the accessor
-template<class T>
-T Accessor::Indexer::GetValue(int i)
-{
-    ai_assert(data);
-    ai_assert(i*stride < accessor.bufferView->byteLength);
-    T value = T();
-    memcpy(&value, data + i*stride, elemSize);
-    //value >>= 8 * (sizeof(T) - elemSize);
-    return value;
-}
-
-inline Image::Image()
-    : width(0)
-    , height(0)
-    , mDataLength(0)
-{
-
-}
-
-inline void Image::Read(Value& obj, Asset& r)
-{
-    // Check for extensions first (to detect binary embedded data)
-    if (Value* extensions = FindObject(obj, "extensions")) {
-        if (r.extensionsUsed.KHR_binary_glTF) {
-            if (Value* ext = FindObject(*extensions, "KHR_binary_glTF")) {
-
-                width  = MemberOrDefault(*ext, "width", 0);
-                height = MemberOrDefault(*ext, "height", 0);
-
-                ReadMember(*ext, "mimeType", mimeType);
-
-                const char* bufferViewId;
-                if (ReadMember(*ext, "bufferView", bufferViewId)) {
-                    Ref<BufferView> bv = r.bufferViews.Get(bufferViewId);
-                    if (bv) {
-                        mDataLength = bv->byteLength;
-                        mData.reset(new uint8_t[mDataLength]);
-                        memcpy(mData.get(), bv->buffer->GetPointer() + bv->byteOffset, mDataLength);
-                    }
-                }
-            }
-        }
-    }
-
-    if (!mDataLength) {
-        if (Value* uri = FindString(obj, "uri")) {
-            const char* uristr = uri->GetString();
-
-            glTFCommon::Util::DataURI dataURI;
-            if (ParseDataURI(uristr, uri->GetStringLength(), dataURI)) {
-                mimeType = dataURI.mediaType;
-                if (dataURI.base64) {
-                    uint8_t *ptr = nullptr;
-                    mDataLength = glTFCommon::Util::DecodeBase64(dataURI.data, dataURI.dataLength, ptr);
-                    mData.reset(ptr);
-                }
-            }
-            else {
-                this->uri = uristr;
-            }
-        }
-    }
-}
-
-inline uint8_t* Image::StealData()
-{
-    mDataLength = 0;
-    return mData.release();
-}
-
-inline void Image::SetData(uint8_t* data, size_t length, Asset& r)
-{
-    Ref<Buffer> b = r.GetBodyBuffer();
-    if (b) { // binary file: append to body
-        std::string bvId = r.FindUniqueID(this->id, "imgdata");
-        bufferView = r.bufferViews.Create(bvId);
-
-        bufferView->buffer = b;
-        bufferView->byteLength = length;
-        bufferView->byteOffset = b->AppendData(data, length);
-    }
-    else { // text file: will be stored as a data uri
-        this->mData.reset(data);
-        this->mDataLength = length;
-    }
-}
-
-inline void Sampler::Read(Value& obj, Asset& /*r*/)
-{
-    SetDefaults();
-
-    ReadMember(obj, "magFilter", magFilter);
-    ReadMember(obj, "minFilter", minFilter);
-    ReadMember(obj, "wrapS", wrapS);
-    ReadMember(obj, "wrapT", wrapT);
-}
-
-inline void Sampler::SetDefaults()
-{
-    magFilter = SamplerMagFilter_Linear;
-    minFilter = SamplerMinFilter_Linear;
-    wrapS = SamplerWrap_Repeat;
-    wrapT = SamplerWrap_Repeat;
-}
-
-inline void Texture::Read(Value& obj, Asset& r)
-{
-    const char* sourcestr;
-    if (ReadMember(obj, "source", sourcestr)) {
-        source = r.images.Get(sourcestr);
-    }
-
-    const char* samplerstr;
-    if (ReadMember(obj, "sampler", samplerstr)) {
-        sampler = r.samplers.Get(samplerstr);
-    }
-}
-
-namespace {
-    inline void ReadMaterialProperty(Asset& r, Value& vals, const char* propName, TexProperty& out)
-    {
-        if (Value* prop = FindMember(vals, propName)) {
-            if (prop->IsString()) {
-                out.texture = r.textures.Get(prop->GetString());
-            }
-            else {
-                ReadValue(*prop, out.color);
-            }
-        }
-    }
-}
-
-inline void Material::Read(Value& material, Asset& r)
-{
-    SetDefaults();
-
-    if (Value* values = FindObject(material, "values")) {
-        ReadMaterialProperty(r, *values, "ambient", this->ambient);
-        ReadMaterialProperty(r, *values, "diffuse", this->diffuse);
-        ReadMaterialProperty(r, *values, "specular", this->specular);
-
-        ReadMember(*values, "transparency", transparency);
-        ReadMember(*values, "shininess", shininess);
-    }
-
-    if (Value* extensions = FindObject(material, "extensions")) {
-        if (r.extensionsUsed.KHR_materials_common) {
-            if (Value* ext = FindObject(*extensions, "KHR_materials_common")) {
-                if (Value* tnq = FindString(*ext, "technique")) {
-                    const char* t = tnq->GetString();
-                    if      (strcmp(t, "BLINN") == 0)    technique = Technique_BLINN;
-                    else if (strcmp(t, "PHONG") == 0)    technique = Technique_PHONG;
-                    else if (strcmp(t, "LAMBERT") == 0)  technique = Technique_LAMBERT;
-                    else if (strcmp(t, "CONSTANT") == 0) technique = Technique_CONSTANT;
-                }
-
-                if (Value* values = FindObject(*ext, "values")) {
-                    ReadMaterialProperty(r, *values, "ambient", this->ambient);
-                    ReadMaterialProperty(r, *values, "diffuse", this->diffuse);
-                    ReadMaterialProperty(r, *values, "specular", this->specular);
-
-                    ReadMember(*values, "doubleSided", doubleSided);
-                    ReadMember(*values, "transparent", transparent);
-                    ReadMember(*values, "transparency", transparency);
-                    ReadMember(*values, "shininess", shininess);
-                }
-            }
-        }
-    }
-}
-
-namespace {
-    void SetVector(vec4& v, float x, float y, float z, float w)
-        { v[0] = x; v[1] = y; v[2] = z; v[3] = w; }
-}
-
-inline void Material::SetDefaults()
-{
-    SetVector(ambient.color, 0, 0, 0, 1);
-    SetVector(diffuse.color, 0, 0, 0, 1);
-    SetVector(specular.color, 0, 0, 0, 1);
-    SetVector(emission.color, 0, 0, 0, 1);
-
-    doubleSided = false;
-    transparent = false;
-    transparency = 1.0;
-    shininess = 0.0;
-
-    technique = Technique_undefined;
-}
-
-namespace {
-
-    template<int N>
-    inline int Compare(const char* attr, const char (&str)[N]) {
-        return (strncmp(attr, str, N - 1) == 0) ? N - 1 : 0;
-    }
-
-    inline bool GetAttribVector(Mesh::Primitive& p, const char* attr, Mesh::AccessorList*& v, int& pos)
-    {
-        if ((pos = Compare(attr, "POSITION"))) {
-            v = &(p.attributes.position);
-        }
-        else if ((pos = Compare(attr, "NORMAL"))) {
-            v = &(p.attributes.normal);
-        }
-        else if ((pos = Compare(attr, "TEXCOORD"))) {
-            v = &(p.attributes.texcoord);
-        }
-        else if ((pos = Compare(attr, "COLOR"))) {
-            v = &(p.attributes.color);
-        }
-        else if ((pos = Compare(attr, "JOINT"))) {
-            v = &(p.attributes.joint);
-        }
-        else if ((pos = Compare(attr, "JOINTMATRIX"))) {
-            v = &(p.attributes.jointmatrix);
-        }
-        else if ((pos = Compare(attr, "WEIGHT"))) {
-            v = &(p.attributes.weight);
-        }
-        else return false;
-        return true;
-    }
-}
-
-inline void Mesh::Read(Value& pJSON_Object, Asset& pAsset_Root)
-{
-	/****************** Mesh primitives ******************/
-	if (Value* primitives = FindArray(pJSON_Object, "primitives")) {
-        this->primitives.resize(primitives->Size());
-        for (unsigned int i = 0; i < primitives->Size(); ++i) {
-            Value& primitive = (*primitives)[i];
-
-            Primitive& prim = this->primitives[i];
-            prim.mode = MemberOrDefault(primitive, "mode", PrimitiveMode_TRIANGLES);
-
-            if (Value* attrs = FindObject(primitive, "attributes")) {
-                for (Value::MemberIterator it = attrs->MemberBegin(); it != attrs->MemberEnd(); ++it) {
-                    if (!it->value.IsString()) continue;
-                    const char* attr = it->name.GetString();
-                    // Valid attribute semantics include POSITION, NORMAL, TEXCOORD, COLOR, JOINT, JOINTMATRIX,
-                    // and WEIGHT.Attribute semantics can be of the form[semantic]_[set_index], e.g., TEXCOORD_0, TEXCOORD_1, etc.
-
-                    int undPos = 0;
-                    Mesh::AccessorList* vec = 0;
-                    if (GetAttribVector(prim, attr, vec, undPos)) {
-                        size_t idx = (attr[undPos] == '_') ? atoi(attr + undPos + 1) : 0;
-                        if ((*vec).size() <= idx) (*vec).resize(idx + 1);
-						(*vec)[idx] = pAsset_Root.accessors.Get(it->value.GetString());
-                    }
-                }
-            }
-
-            if (Value* indices = FindString(primitive, "indices")) {
-				prim.indices = pAsset_Root.accessors.Get(indices->GetString());
-            }
-
-            if (Value* material = FindString(primitive, "material")) {
-				prim.material = pAsset_Root.materials.Get(material->GetString());
-            }
-        }
-    }
-
-	/****************** Mesh extensions ******************/
-	Value* json_extensions = FindObject(pJSON_Object, "extensions");
-
-	if(json_extensions == nullptr) goto mr_skip_extensions;
-
-	for(Value::MemberIterator it_memb = json_extensions->MemberBegin(); it_memb != json_extensions->MemberEnd(); it_memb++)
-	{
-#ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC
-        if(it_memb->name.GetString() == std::string("Open3DGC-compression"))
-		{
-			// Search for compressed data.
-			// Compressed data contain description of part of "buffer" which is encoded. This part must be decoded and
-			// new data will replace old encoded part by request. In fact \"compressedData\" is kind of "accessor" structure.
-			Value* comp_data = FindObject(it_memb->value, "compressedData");
-
-			if(comp_data == nullptr) throw DeadlyImportError("GLTF: \"Open3DGC-compression\" must has \"compressedData\".");
-
-            ASSIMP_LOG_INFO("GLTF: Decompressing Open3DGC data.");
-
-			/************** Read data from JSON-document **************/
-			#define MESH_READ_COMPRESSEDDATA_MEMBER(pFieldName, pOut) \
-				if(!ReadMember(*comp_data, pFieldName, pOut)) \
-				{ \
-					throw DeadlyImportError(std::string("GLTF: \"compressedData\" must has \"") + pFieldName + "\"."); \
-				}
-
-			const char* mode_str;
-			const char* type_str;
-			ComponentType component_type;
-			SCompression_Open3DGC* ext_o3dgc = new SCompression_Open3DGC;
-
-			MESH_READ_COMPRESSEDDATA_MEMBER("buffer", ext_o3dgc->Buffer);
-			MESH_READ_COMPRESSEDDATA_MEMBER("byteOffset", ext_o3dgc->Offset);
-			MESH_READ_COMPRESSEDDATA_MEMBER("componentType", component_type);
-			MESH_READ_COMPRESSEDDATA_MEMBER("type", type_str);
-			MESH_READ_COMPRESSEDDATA_MEMBER("count", ext_o3dgc->Count);
-			MESH_READ_COMPRESSEDDATA_MEMBER("mode", mode_str);
-			MESH_READ_COMPRESSEDDATA_MEMBER("indicesCount", ext_o3dgc->IndicesCount);
-			MESH_READ_COMPRESSEDDATA_MEMBER("verticesCount", ext_o3dgc->VerticesCount);
-
-			#undef MESH_READ_COMPRESSEDDATA_MEMBER
-
-			// Check some values
-			if(strcmp(type_str, "SCALAR")) throw DeadlyImportError("GLTF: only \"SCALAR\" type is supported for compressed data.");
-			if(component_type != ComponentType_UNSIGNED_BYTE) throw DeadlyImportError("GLTF: only \"UNSIGNED_BYTE\" component type is supported for compressed data.");
-
-			// Set read/write data mode.
-			if(strcmp(mode_str, "binary") == 0)
-				ext_o3dgc->Binary = true;
-			else if(strcmp(mode_str, "ascii") == 0)
-				ext_o3dgc->Binary = false;
-			else
-				throw DeadlyImportError(std::string("GLTF: for compressed data supported modes is: \"ascii\", \"binary\". Not the: \"") + mode_str + "\".");
-
-			/************************ Decoding ************************/
-			Decode_O3DGC(*ext_o3dgc, pAsset_Root);
-			Extension.push_back(ext_o3dgc);// store info in mesh extensions list.
-		}// if(it_memb->name.GetString() == "Open3DGC-compression")
-		else
-#endif
-		{
-			throw DeadlyImportError(std::string("GLTF: Unknown mesh extension: \"") + it_memb->name.GetString() + "\".");
-		}
-	}// for(Value::MemberIterator it_memb = json_extensions->MemberBegin(); it_memb != json_extensions->MemberEnd(); json_extensions++)
-
-mr_skip_extensions:
-
-	return;// After label some operators must be present.
-}
-
-#ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC
-inline void Mesh::Decode_O3DGC(const SCompression_Open3DGC& pCompression_Open3DGC, Asset& pAsset_Root)
-{
-typedef unsigned short IndicesType;///< \sa glTFExporter::ExportMeshes.
-
-o3dgc::SC3DMCDecoder<IndicesType> decoder;
-o3dgc::IndexedFaceSet<IndicesType> ifs;
-o3dgc::BinaryStream bstream;
-uint8_t* decoded_data;
-size_t decoded_data_size = 0;
-Ref<Buffer> buf = pAsset_Root.buffers.Get(pCompression_Open3DGC.Buffer);
-
-	// Read data from buffer and place it in BinaryStream for decoder.
-	// Just "Count" because always is used type equivalent to uint8_t.
-	bstream.LoadFromBuffer(&buf->GetPointer()[pCompression_Open3DGC.Offset], static_cast<unsigned long>(pCompression_Open3DGC.Count));
-
-	// After decoding header we can get size of primitives.
-	if(decoder.DecodeHeader(ifs, bstream) != o3dgc::O3DGC_OK) throw DeadlyImportError("GLTF: can not decode Open3DGC header.");
-
-	/****************** Get sizes of arrays and check sizes ******************/
-	// Note. See "Limitations for meshes when using Open3DGC-compression".
-
-	// Indices
-	size_t size_coordindex = ifs.GetNCoordIndex() * 3;// See float attributes note.
-
-	if(primitives[0].indices->count != size_coordindex)
-		throw DeadlyImportError("GLTF: Open3DGC. Compressed indices count (" + to_string(size_coordindex) +
-								") not equal to uncompressed (" + to_string(primitives[0].indices->count) + ").");
-
-	size_coordindex *= sizeof(IndicesType);
-	// Coordinates
-	size_t size_coord = ifs.GetNCoord();// See float attributes note.
-
-	if(primitives[0].attributes.position[0]->count != size_coord)
-		throw DeadlyImportError("GLTF: Open3DGC. Compressed positions count (" + to_string(size_coord) +
-								") not equal to uncompressed (" + to_string(primitives[0].attributes.position[0]->count) + ").");
-
-	size_coord *= 3 * sizeof(float);
-	// Normals
-	size_t size_normal = ifs.GetNNormal();// See float attributes note.
-
-	if(primitives[0].attributes.normal[0]->count != size_normal)
-		throw DeadlyImportError("GLTF: Open3DGC. Compressed normals count (" + to_string(size_normal) +
-								") not equal to uncompressed (" + to_string(primitives[0].attributes.normal[0]->count) + ").");
-
-	size_normal *= 3 * sizeof(float);
-	// Additional attributes.
-	std::vector<size_t> size_floatattr;
-	std::vector<size_t> size_intattr;
-
-	size_floatattr.resize(ifs.GetNumFloatAttributes());
-	size_intattr.resize(ifs.GetNumIntAttributes());
-
-	decoded_data_size = size_coordindex + size_coord + size_normal;
-	for(size_t idx = 0, idx_end = size_floatattr.size(), idx_texcoord = 0; idx < idx_end; idx++)
-	{
-		// size = number_of_elements * components_per_element * size_of_component.
-		// Note. But as you can see above, at first we are use this variable in meaning "count". After checking count of objects...
-		size_t tval = ifs.GetNFloatAttribute(static_cast<unsigned long>(idx));
-
-		switch(ifs.GetFloatAttributeType(static_cast<unsigned long>(idx)))
-		{
-			case o3dgc::O3DGC_IFS_FLOAT_ATTRIBUTE_TYPE_TEXCOORD:
-				// Check situation when encoded data contain texture coordinates but primitive not.
-				if(idx_texcoord < primitives[0].attributes.texcoord.size())
-				{
-					if(primitives[0].attributes.texcoord[idx]->count != tval)
-						throw DeadlyImportError("GLTF: Open3DGC. Compressed texture coordinates count (" + to_string(tval) +
-												") not equal to uncompressed (" + to_string(primitives[0].attributes.texcoord[idx]->count) + ").");
-
-					idx_texcoord++;
-				}
-				else
-				{
-					ifs.SetNFloatAttribute(static_cast<unsigned long>(idx), 0ul);// Disable decoding this attribute.
-				}
-
-				break;
-			default:
-				throw DeadlyImportError("GLTF: Open3DGC. Unsupported type of float attribute: " + to_string(ifs.GetFloatAttributeType(static_cast<unsigned long>(idx))));
-		}
-
-		tval *=  ifs.GetFloatAttributeDim(static_cast<unsigned long>(idx)) * sizeof(o3dgc::Real);// After checking count of objects we can get size of array.
-		size_floatattr[idx] = tval;
-		decoded_data_size += tval;
-	}
-
-	for(size_t idx = 0, idx_end = size_intattr.size(); idx < idx_end; idx++)
-	{
-		// size = number_of_elements * components_per_element * size_of_component. See float attributes note.
-		size_t tval = ifs.GetNIntAttribute(static_cast<unsigned long>(idx));
-		switch( ifs.GetIntAttributeType(static_cast<unsigned long>(idx) ) )
-		{
-            case o3dgc::O3DGC_IFS_INT_ATTRIBUTE_TYPE_UNKOWN:
-            case o3dgc::O3DGC_IFS_INT_ATTRIBUTE_TYPE_INDEX:
-            case o3dgc::O3DGC_IFS_INT_ATTRIBUTE_TYPE_JOINT_ID:
-            case o3dgc::O3DGC_IFS_INT_ATTRIBUTE_TYPE_INDEX_BUFFER_ID:
-                break;
-
-			default:
-				throw DeadlyImportError("GLTF: Open3DGC. Unsupported type of int attribute: " + to_string(ifs.GetIntAttributeType(static_cast<unsigned long>(idx))));
-		}
-
-		tval *= ifs.GetIntAttributeDim(static_cast<unsigned long>(idx)) * sizeof(long);// See float attributes note.
-		size_intattr[idx] = tval;
-		decoded_data_size += tval;
-	}
-
-	// Create array for decoded data.
-	decoded_data = new uint8_t[decoded_data_size];
-
-	/****************** Set right array regions for decoder ******************/
-
-	auto get_buf_offset = [](Ref<Accessor>& pAccessor) -> size_t { return pAccessor->byteOffset + pAccessor->bufferView->byteOffset; };
-
-	// Indices
-	ifs.SetCoordIndex((IndicesType* const)(decoded_data + get_buf_offset(primitives[0].indices)));
-	// Coordinates
-	ifs.SetCoord((o3dgc::Real* const)(decoded_data + get_buf_offset(primitives[0].attributes.position[0])));
-	// Normals
-	if(size_normal)
-	{
-		ifs.SetNormal((o3dgc::Real* const)(decoded_data + get_buf_offset(primitives[0].attributes.normal[0])));
-	}
-
-	for(size_t idx = 0, idx_end = size_floatattr.size(), idx_texcoord = 0; idx < idx_end; idx++)
-	{
-		switch(ifs.GetFloatAttributeType(static_cast<unsigned long>(idx)))
-		{
-			case o3dgc::O3DGC_IFS_FLOAT_ATTRIBUTE_TYPE_TEXCOORD:
-				if(idx_texcoord < primitives[0].attributes.texcoord.size())
-				{
-					// See above about absent attributes.
-					ifs.SetFloatAttribute(static_cast<unsigned long>(idx), (o3dgc::Real* const)(decoded_data + get_buf_offset(primitives[0].attributes.texcoord[idx])));
-					idx_texcoord++;
-				}
-
-				break;
-			default:
-				throw DeadlyImportError("GLTF: Open3DGC. Unsupported type of float attribute: " + to_string(ifs.GetFloatAttributeType(static_cast<unsigned long>(idx))));
-		}
-	}
-
-	for(size_t idx = 0, idx_end = size_intattr.size(); idx < idx_end; idx++) {
-		switch(ifs.GetIntAttributeType(static_cast<unsigned int>(idx))) {
-            case o3dgc::O3DGC_IFS_INT_ATTRIBUTE_TYPE_UNKOWN:
-            case o3dgc::O3DGC_IFS_INT_ATTRIBUTE_TYPE_INDEX:
-            case o3dgc::O3DGC_IFS_INT_ATTRIBUTE_TYPE_JOINT_ID:
-            case o3dgc::O3DGC_IFS_INT_ATTRIBUTE_TYPE_INDEX_BUFFER_ID:
-                break;
-
-			// ifs.SetIntAttribute(idx, (long* const)(decoded_data + get_buf_offset(primitives[0].attributes.joint)));
-			default:
-				throw DeadlyImportError("GLTF: Open3DGC. Unsupported type of int attribute: " + to_string(ifs.GetIntAttributeType(static_cast<unsigned long>(idx))));
-		}
-	}
-
-	//
-	// Decode data
-	//
-    if ( decoder.DecodePayload( ifs, bstream ) != o3dgc::O3DGC_OK ) {
-        throw DeadlyImportError( "GLTF: can not decode Open3DGC data." );
-    }
-
-	// Set encoded region for "buffer".
-	buf->EncodedRegion_Mark(pCompression_Open3DGC.Offset, pCompression_Open3DGC.Count, decoded_data, decoded_data_size, id);
-	// No. Do not delete "output_data". After calling "EncodedRegion_Mark" bufferView is owner of "output_data".
-	// "delete [] output_data;"
-}
-#endif
-
-inline void Camera::Read(Value& obj, Asset& /*r*/)
-{
-    type = MemberOrDefault(obj, "type", Camera::Perspective);
-
-    const char* subobjId = (type == Camera::Orthographic) ? "ortographic" : "perspective";
-
-    Value* it = FindObject(obj, subobjId);
-    if (!it) throw DeadlyImportError("GLTF: Camera missing its parameters");
-
-    if (type == Camera::Perspective) {
-        perspective.aspectRatio = MemberOrDefault(*it, "aspectRatio", 0.f);
-        perspective.yfov        = MemberOrDefault(*it, "yfov", 3.1415f/2.f);
-        perspective.zfar        = MemberOrDefault(*it, "zfar", 100.f);
-        perspective.znear       = MemberOrDefault(*it, "znear", 0.01f);
-    }
-    else {
-        ortographic.xmag  = MemberOrDefault(obj, "xmag", 1.f);
-        ortographic.ymag  = MemberOrDefault(obj, "ymag", 1.f);
-        ortographic.zfar  = MemberOrDefault(obj, "zfar", 100.f);
-        ortographic.znear = MemberOrDefault(obj, "znear", 0.01f);
-    }
-}
-
-inline void Light::Read(Value& obj, Asset& /*r*/)
-{
-    SetDefaults();
-
-    if (Value* type = FindString(obj, "type")) {
-        const char* t = type->GetString();
-        if      (strcmp(t, "ambient") == 0)     this->type = Type_ambient;
-        else if (strcmp(t, "directional") == 0) this->type = Type_directional;
-        else if (strcmp(t, "point") == 0)       this->type = Type_point;
-        else if (strcmp(t, "spot") == 0)        this->type = Type_spot;
-
-        if (this->type != Type_undefined) {
-            if (Value* vals = FindString(obj, t)) {
-                ReadMember(*vals, "color", color);
-
-                ReadMember(*vals, "constantAttenuation", constantAttenuation);
-                ReadMember(*vals, "linearAttenuation", linearAttenuation);
-                ReadMember(*vals, "quadraticAttenuation", quadraticAttenuation);
-                ReadMember(*vals, "distance", distance);
-
-                ReadMember(*vals, "falloffAngle", falloffAngle);
-                ReadMember(*vals, "falloffExponent", falloffExponent);
-            }
-        }
-    }
-}
-
-inline void Light::SetDefaults()
-{
-    #ifndef M_PI
-        const float M_PI = 3.14159265358979323846f;
-    #endif
-
-    type = Type_undefined;
-
-    SetVector(color, 0.f, 0.f, 0.f, 1.f);
-
-    constantAttenuation = 0.f;
-    linearAttenuation = 1.f;
-    quadraticAttenuation = 1.f;
-    distance = 0.f;
-
-    falloffAngle = static_cast<float>(M_PI / 2.f);
-    falloffExponent = 0.f;
-}
-
-inline 
-void Node::Read(Value& obj, Asset& r) {
-    if (name.empty()) {
-        name = id;
-    }
-
-    if (Value* children = FindArray(obj, "children")) {
-        this->children.reserve(children->Size());
-        for (unsigned int i = 0; i < children->Size(); ++i) {
-            Value& child = (*children)[i];
-            if (child.IsString()) {
-                // get/create the child node
-                Ref<Node> chn = r.nodes.Get(child.GetString());
-                if (chn) this->children.push_back(chn);
-            }
-        }
-    }
-
-
-    if (Value* matrix = FindArray(obj, "matrix")) {
-        ReadValue(*matrix, this->matrix);
-    }
-    else {
-        ReadMember(obj, "translation", translation);
-        ReadMember(obj, "scale", scale);
-        ReadMember(obj, "rotation", rotation);
-    }
-
-    if (Value* meshes = FindArray(obj, "meshes")) {
-        unsigned numMeshes = (unsigned)meshes->Size();
-
-        std::vector<unsigned int> meshList;
-
-        this->meshes.reserve(numMeshes);
-        for (unsigned i = 0; i < numMeshes; ++i) {
-            if ((*meshes)[i].IsString()) {
-                Ref<Mesh> mesh = r.meshes.Get((*meshes)[i].GetString());
-                if (mesh) this->meshes.push_back(mesh);
-            }
-        }
-    }
-
-    if (Value* camera = FindString(obj, "camera")) {
-        this->camera = r.cameras.Get(camera->GetString());
-        if (this->camera)
-            this->camera->id = this->id;
-    }
-
-    // TODO load "skeletons", "skin", "jointName"
-
-    if (Value* extensions = FindObject(obj, "extensions")) {
-        if (r.extensionsUsed.KHR_materials_common) {
-
-            if (Value* ext = FindObject(*extensions, "KHR_materials_common")) {
-                if (Value* light = FindString(*ext, "light")) {
-                    this->light = r.lights.Get(light->GetString());
-                }
-            }
-
-        }
-    }
-}
-
-inline void Scene::Read(Value& obj, Asset& r)
-{
-    if (Value* array = FindArray(obj, "nodes")) {
-        for (unsigned int i = 0; i < array->Size(); ++i) {
-            if (!(*array)[i].IsString()) continue;
-            Ref<Node> node = r.nodes.Get((*array)[i].GetString());
-            if (node)
-                this->nodes.push_back(node);
-        }
-    }
-}
-
-
-inline void AssetMetadata::Read(Document& doc)
-{
-    // read the version, etc.
-    if (Value* obj = FindObject(doc, "asset")) {
-        ReadMember(*obj, "copyright", copyright);
-        ReadMember(*obj, "generator", generator);
-
-        premultipliedAlpha = MemberOrDefault(*obj, "premultipliedAlpha", false);
-
-        if (Value* versionString = FindString(*obj, "version")) {
-            version = versionString->GetString();
-        } else if (Value* versionNumber = FindNumber (*obj, "version")) {
-            char buf[4];
-
-            ai_snprintf(buf, 4, "%.1f", versionNumber->GetDouble());
-
-            version = buf;
-        }
-
-        if (Value* profile = FindObject(*obj, "profile")) {
-            ReadMember(*profile, "api",     this->profile.api);
-            ReadMember(*profile, "version", this->profile.version);
-        }
-    }
-
-    if (version.empty() || version[0] != '1') {
-        throw DeadlyImportError("GLTF: Unsupported glTF version: " + version);
-    }
-}
-
-
-
-//
-// Asset methods implementation
-//
-
-inline void Asset::ReadBinaryHeader(IOStream& stream)
-{
-    GLB_Header header;
-    if (stream.Read(&header, sizeof(header), 1) != 1) {
-        throw DeadlyImportError("GLTF: Unable to read the file header");
-    }
-
-    if (strncmp((char*)header.magic, AI_GLB_MAGIC_NUMBER, sizeof(header.magic)) != 0) {
-        throw DeadlyImportError("GLTF: Invalid binary glTF file");
-    }
-
-    AI_SWAP4(header.version);
-    asset.version = to_string(header.version);
-    if (header.version != 1) {
-        throw DeadlyImportError("GLTF: Unsupported binary glTF version");
-    }
-
-    AI_SWAP4(header.sceneFormat);
-    if (header.sceneFormat != SceneFormat_JSON) {
-        throw DeadlyImportError("GLTF: Unsupported binary glTF scene format");
-    }
-
-    AI_SWAP4(header.length);
-    AI_SWAP4(header.sceneLength);
-
-    mSceneLength = static_cast<size_t>(header.sceneLength);
-
-    mBodyOffset = sizeof(header)+mSceneLength;
-    mBodyOffset = (mBodyOffset + 3) & ~3; // Round up to next multiple of 4
-
-    mBodyLength = header.length - mBodyOffset;
-}
-
-inline void Asset::Load(const std::string& pFile, bool isBinary)
-{
-    mCurrentAssetDir.clear();
-    int pos = std::max(int(pFile.rfind('/')), int(pFile.rfind('\\')));
-    if (pos != int(std::string::npos)) mCurrentAssetDir = pFile.substr(0, pos + 1);
-
-    shared_ptr<IOStream> stream(OpenFile(pFile.c_str(), "rb", true));
-    if (!stream) {
-        throw DeadlyImportError("GLTF: Could not open file for reading");
-    }
-
-    // is binary? then read the header
-    if (isBinary) {
-        SetAsBinary(); // also creates the body buffer
-        ReadBinaryHeader(*stream);
-    }
-    else {
-        mSceneLength = stream->FileSize();
-        mBodyLength = 0;
-    }
-
-
-    // read the scene data
-
-    std::vector<char> sceneData(mSceneLength + 1);
-    sceneData[mSceneLength] = '\0';
-
-    if (stream->Read(&sceneData[0], 1, mSceneLength) != mSceneLength) {
-        throw DeadlyImportError("GLTF: Could not read the file contents");
-    }
-
-
-    // parse the JSON document
-
-    Document doc;
-    doc.ParseInsitu(&sceneData[0]);
-
-    if (doc.HasParseError()) {
-        char buffer[32];
-        ai_snprintf(buffer, 32, "%d", static_cast<int>(doc.GetErrorOffset()));
-        throw DeadlyImportError(std::string("GLTF: JSON parse error, offset ") + buffer + ": "
-            + GetParseError_En(doc.GetParseError()));
-    }
-
-    if (!doc.IsObject()) {
-        throw DeadlyImportError("GLTF: JSON document root must be a JSON object");
-    }
-
-    // Fill the buffer instance for the current file embedded contents
-    if (mBodyLength > 0) {
-        if (!mBodyBuffer->LoadFromStream(*stream, mBodyLength, mBodyOffset)) {
-            throw DeadlyImportError("GLTF: Unable to read gltf file");
-        }
-    }
-
-
-    // Load the metadata
-    asset.Read(doc);
-    ReadExtensionsUsed(doc);
-
-    // Prepare the dictionaries
-    for (size_t i = 0; i < mDicts.size(); ++i) {
-        mDicts[i]->AttachToDocument(doc);
-    }
-
-
-
-    // Read the "scene" property, which specifies which scene to load
-    // and recursively load everything referenced by it
-    if (Value* scene = FindString(doc, "scene")) {
-        this->scene = scenes.Get(scene->GetString());
-    }
-
-    // Clean up
-    for (size_t i = 0; i < mDicts.size(); ++i) {
-        mDicts[i]->DetachFromDocument();
-    }
-}
-
-inline void Asset::SetAsBinary()
-{
-    if (!extensionsUsed.KHR_binary_glTF) {
-        extensionsUsed.KHR_binary_glTF = true;
-        mBodyBuffer = buffers.Create("binary_glTF");
-        mBodyBuffer->MarkAsSpecial();
-    }
-}
-
-
-inline void Asset::ReadExtensionsUsed(Document& doc)
-{
-    Value* extsUsed = FindArray(doc, "extensionsUsed");
-    if (!extsUsed) return;
-
-    std::gltf_unordered_map<std::string, bool> exts;
-
-    for (unsigned int i = 0; i < extsUsed->Size(); ++i) {
-        if ((*extsUsed)[i].IsString()) {
-            exts[(*extsUsed)[i].GetString()] = true;
-        }
-    }
-
-    #define CHECK_EXT(EXT) \
-        if (exts.find(#EXT) != exts.end()) extensionsUsed.EXT = true;
-
-    CHECK_EXT(KHR_binary_glTF);
-    CHECK_EXT(KHR_materials_common);
-
-    #undef CHECK_EXT
-}
-
-inline IOStream* Asset::OpenFile(std::string path, const char* mode, bool /*absolute*/)
-{
-    #ifdef ASSIMP_API
-        return mIOSystem->Open(path, mode);
-    #else
-        if (path.size() < 2) return 0;
-        if (!absolute && path[1] != ':' && path[0] != '/') { // relative?
-            path = mCurrentAssetDir + path;
-        }
-        FILE* f = fopen(path.c_str(), mode);
-        return f ? new IOStream(f) : 0;
-    #endif
-}
-
-inline std::string Asset::FindUniqueID(const std::string& str, const char* suffix)
-{
-    std::string id = str;
-
-    if (!id.empty()) {
-        if (mUsedIds.find(id) == mUsedIds.end())
-            return id;
-
-        id += "_";
-    }
-
-    id += suffix;
-
-    Asset::IdMap::iterator it = mUsedIds.find(id);
-    if (it == mUsedIds.end())
-        return id;
-
-    char buffer[1024];
-    int offset = ai_snprintf(buffer, sizeof(buffer), "%s_", id.c_str());
-    for (int i = 0; it != mUsedIds.end(); ++i) {
-        ai_snprintf(buffer + offset, sizeof(buffer) - offset, "%d", i);
-        id = buffer;
-        it = mUsedIds.find(id);
-    }
-
-    return id;
-}
-
-} // ns glTF
diff --git a/Engine/lib/assimp/code/glTF/glTFCommon.h b/Engine/lib/assimp/code/glTF/glTFCommon.h
deleted file mode 100644
index d9edee75e..000000000
--- a/Engine/lib/assimp/code/glTF/glTFCommon.h
+++ /dev/null
@@ -1,248 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-#ifndef AI_GLFTCOMMON_H_INC
-#define AI_GLFTCOMMON_H_INC
-
-#ifndef ASSIMP_BUILD_NO_GLTF_IMPORTER
-
-#include <assimp/Exceptional.h>
-
-#include <map>
-#include <string>
-#include <list>
-#include <vector>
-#include <algorithm>
-#include <stdexcept>
-
-#define RAPIDJSON_HAS_STDSTRING 1
-#include <rapidjson/rapidjson.h>
-#include <rapidjson/document.h>
-#include <rapidjson/error/en.h>
-
-#ifdef ASSIMP_API
-#   include <memory>
-#   include <assimp/DefaultIOSystem.h>
-#   include <assimp/ByteSwapper.h>
-#else
-#   include <memory>
-#   define AI_SWAP4(p)
-#   define ai_assert
-#endif
-
-
-#if _MSC_VER > 1500 || (defined __GNUC___)
-#       define ASSIMP_GLTF_USE_UNORDERED_MULTIMAP
-#   else
-#       define gltf_unordered_map map
-#endif
-
-#ifdef ASSIMP_GLTF_USE_UNORDERED_MULTIMAP
-#   include <unordered_map>
-#   if _MSC_VER > 1600
-#       define gltf_unordered_map unordered_map
-#   else
-#       define gltf_unordered_map tr1::unordered_map
-#   endif
-#endif
-
-namespace glTFCommon {
-
-#ifdef ASSIMP_API
-    using Assimp::IOStream;
-    using Assimp::IOSystem;
-    using std::shared_ptr;
-#else
-    using std::shared_ptr;
-
-    typedef std::runtime_error DeadlyImportError;
-    typedef std::runtime_error DeadlyExportError;
-
-    enum aiOrigin {
-        aiOrigin_SET = 0,
-        aiOrigin_CUR = 1,
-        aiOrigin_END = 2
-    };
-
-    class IOSystem;
-
-    class IOStream {
-    public:
-        IOStream(FILE* file) : f(file) {}
-        ~IOStream() { fclose(f); f = 0; }
-
-        size_t Read(void* b, size_t sz, size_t n) { return fread(b, sz, n, f); }
-        size_t Write(const void* b, size_t sz, size_t n) { return fwrite(b, sz, n, f); }
-        int    Seek(size_t off, aiOrigin orig) { return fseek(f, off, int(orig)); }
-        size_t Tell() const { return ftell(f); }
-
-        size_t FileSize() {
-            long p = Tell(), len = (Seek(0, aiOrigin_END), Tell());
-            return size_t((Seek(p, aiOrigin_SET), len));
-        }
-
-    private:
-        FILE* f;
-    };
-#endif
-
-    // Vec/matrix types, as raw float arrays
-    typedef float(vec3)[3];
-    typedef float(vec4)[4];
-    typedef float(mat4)[16];
-
-    inline
-    void CopyValue(const glTFCommon::vec3& v, aiColor4D& out) {
-        out.r = v[0];
-        out.g = v[1];
-        out.b = v[2];
-        out.a = 1.0;
-    }
-
-    inline
-    void CopyValue(const glTFCommon::vec4& v, aiColor4D& out) {
-        out.r = v[0];
-        out.g = v[1];
-        out.b = v[2];
-        out.a = v[3];
-    }
-
-    inline
-    void CopyValue(const glTFCommon::vec4& v, aiColor3D& out) {
-        out.r = v[0];
-        out.g = v[1];
-        out.b = v[2];
-    }
-
-    inline
-    void CopyValue(const glTFCommon::vec3& v, aiColor3D& out) {
-        out.r = v[0];
-        out.g = v[1];
-        out.b = v[2];
-    }
-
-    inline
-    void CopyValue(const glTFCommon::vec3& v, aiVector3D& out) {
-        out.x = v[0];
-        out.y = v[1];
-        out.z = v[2];
-    }
-
-    inline
-    void CopyValue(const glTFCommon::vec4& v, aiQuaternion& out) {
-        out.x = v[0];
-        out.y = v[1];
-        out.z = v[2];
-        out.w = v[3];
-    }
-
-    inline
-    void CopyValue(const glTFCommon::mat4& v, aiMatrix4x4& o) {
-        o.a1 = v[0]; o.b1 = v[1]; o.c1 = v[2]; o.d1 = v[3];
-        o.a2 = v[4]; o.b2 = v[5]; o.c2 = v[6]; o.d2 = v[7];
-        o.a3 = v[8]; o.b3 = v[9]; o.c3 = v[10]; o.d3 = v[11];
-        o.a4 = v[12]; o.b4 = v[13]; o.c4 = v[14]; o.d4 = v[15];
-    }
-
-    namespace Util {
-
-        void EncodeBase64(const uint8_t* in, size_t inLength, std::string& out);
-
-        size_t DecodeBase64(const char* in, size_t inLength, uint8_t*& out);
-
-        inline
-            size_t DecodeBase64(const char* in, uint8_t*& out) {
-            return DecodeBase64(in, strlen(in), out);
-        }
-
-        struct DataURI {
-            const char* mediaType;
-            const char* charset;
-            bool base64;
-            const char* data;
-            size_t dataLength;
-        };
-
-        //! Check if a uri is a data URI
-        bool ParseDataURI(const char* const_uri, size_t uriLen, DataURI& out);
-
-        template<bool B>
-        struct DATA {
-            static const uint8_t tableDecodeBase64[128];
-        };
-
-        template<bool B>
-        const uint8_t DATA<B>::tableDecodeBase64[128] = {
-                0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-                0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-                0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 62,  0,  0,  0, 63,
-            52, 53, 54, 55, 56, 57, 58, 59, 60, 61,  0,  0,  0, 64,  0,  0,
-                0,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
-            15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,  0,  0,  0,  0,  0,
-                0, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
-            41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,  0,  0,  0,  0,  0
-        };
-
-        inline
-            char EncodeCharBase64(uint8_t b) {
-            return "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="[size_t(b)];
-        }
-
-        inline
-            uint8_t DecodeCharBase64(char c) {
-            return DATA<true>::tableDecodeBase64[size_t(c)]; // TODO faster with lookup table or ifs?
-            /*if (c >= 'A' && c <= 'Z') return c - 'A';
-            if (c >= 'a' && c <= 'z') return c - 'a' + 26;
-            if (c >= '0' && c <= '9') return c - '0' + 52;
-            if (c == '+') return 62;
-            if (c == '/') return 63;
-            return 64; // '-' */
-        }
-
-        size_t DecodeBase64(const char* in, size_t inLength, uint8_t*& out);
-
-        void EncodeBase64(const uint8_t* in, size_t inLength, std::string& out);
-    }
-
-}
-
-#endif  // ASSIMP_BUILD_NO_GLTF_IMPORTER
-
-#endif // AI_GLFTCOMMON_H_INC
diff --git a/Engine/lib/assimp/code/glTF2/glTF2Asset.h b/Engine/lib/assimp/code/glTF2/glTF2Asset.h
deleted file mode 100644
index 15c4c44fa..000000000
--- a/Engine/lib/assimp/code/glTF2/glTF2Asset.h
+++ /dev/null
@@ -1,1101 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file glTFAsset.h
- * Declares a glTF class to handle gltf/glb files
- *
- * glTF Extensions Support:
- *   KHR_materials_pbrSpecularGlossiness full
- *   KHR_materials_unlit full
- *   KHR_lights_punctual full
- */
-#ifndef GLTF2ASSET_H_INC
-#define GLTF2ASSET_H_INC
-
-#ifndef ASSIMP_BUILD_NO_GLTF_IMPORTER
-
-#include <assimp/Exceptional.h>
-
-#include <map>
-#include <string>
-#include <list>
-#include <vector>
-#include <algorithm>
-#include <stdexcept>
-
-#define RAPIDJSON_HAS_STDSTRING 1
-#include <rapidjson/rapidjson.h>
-#include <rapidjson/document.h>
-#include <rapidjson/error/en.h>
-
-#ifdef ASSIMP_API
-#   include <memory>
-#   include <assimp/DefaultIOSystem.h>
-#   include <assimp/ByteSwapper.h>
-#else
-#   include <memory>
-#   define AI_SWAP4(p)
-#   define ai_assert
-#endif
-
-
-#if _MSC_VER > 1500 || (defined __GNUC___)
-#       define ASSIMP_GLTF_USE_UNORDERED_MULTIMAP
-#   else
-#       define gltf_unordered_map map
-#endif
-
-#ifdef ASSIMP_GLTF_USE_UNORDERED_MULTIMAP
-#   include <unordered_map>
-#   if _MSC_VER > 1600
-#       define gltf_unordered_map unordered_map
-#   else
-#       define gltf_unordered_map tr1::unordered_map
-#   endif
-#endif
-
-#include <assimp/StringUtils.h>
-
-#include "glTF/glTFCommon.h"
-
-namespace glTF2
-{
-    using glTFCommon::shared_ptr;
-    using glTFCommon::IOSystem;
-    using glTFCommon::IOStream;
-
-    using rapidjson::Value;
-    using rapidjson::Document;
-
-    class Asset;
-    class AssetWriter;
-
-    struct BufferView; // here due to cross-reference
-    struct Texture;
-    struct Skin;
-
-    using glTFCommon::vec3;
-    using glTFCommon::vec4;
-    using glTFCommon::mat4;
-
-    //! Magic number for GLB files
-	#define AI_GLB_MAGIC_NUMBER "glTF"
-	#include <assimp/pbrmaterial.h>
-
-    #ifdef ASSIMP_API
-        #include <assimp/Compiler/pushpack1.h>
-    #endif
-
-    //! For binary .glb files
-    //! 12-byte header (+ the JSON + a "body" data section)
-    struct GLB_Header
-    {
-        uint8_t magic[4];     //!< Magic number: "glTF"
-        uint32_t version;     //!< Version number (always 2 as of the last update)
-        uint32_t length;      //!< Total length of the Binary glTF, including header, scene, and body, in bytes
-    } PACK_STRUCT;
-
-    struct GLB_Chunk
-    {
-        uint32_t chunkLength;
-        uint32_t chunkType;
-    } PACK_STRUCT;
-
-    #ifdef ASSIMP_API
-        #include <assimp/Compiler/poppack1.h>
-    #endif
-
-
-    //! Values for the GLB_Chunk::chunkType field
-    enum ChunkType
-    {
-        ChunkType_JSON = 0x4E4F534A,
-        ChunkType_BIN  = 0x004E4942
-    };
-
-    //! Values for the mesh primitive modes
-    enum PrimitiveMode
-    {
-        PrimitiveMode_POINTS = 0,
-        PrimitiveMode_LINES = 1,
-        PrimitiveMode_LINE_LOOP = 2,
-        PrimitiveMode_LINE_STRIP = 3,
-        PrimitiveMode_TRIANGLES = 4,
-        PrimitiveMode_TRIANGLE_STRIP = 5,
-        PrimitiveMode_TRIANGLE_FAN = 6
-    };
-
-    //! Values for the Accessor::componentType field
-    enum ComponentType
-    {
-        ComponentType_BYTE = 5120,
-        ComponentType_UNSIGNED_BYTE = 5121,
-        ComponentType_SHORT = 5122,
-        ComponentType_UNSIGNED_SHORT = 5123,
-        ComponentType_UNSIGNED_INT = 5125,
-        ComponentType_FLOAT = 5126
-    };
-
-    inline
-    unsigned int ComponentTypeSize(ComponentType t)
-    {
-        switch (t) {
-            case ComponentType_SHORT:
-            case ComponentType_UNSIGNED_SHORT:
-                return 2;
-
-            case ComponentType_UNSIGNED_INT:
-            case ComponentType_FLOAT:
-                return 4;
-
-            case ComponentType_BYTE:
-            case ComponentType_UNSIGNED_BYTE:
-                return 1;
-            default:
-                throw DeadlyImportError("GLTF: Unsupported Component Type " + to_string(t));
-        }
-    }
-
-    //! Values for the BufferView::target field
-    enum BufferViewTarget
-    {
-        BufferViewTarget_ARRAY_BUFFER = 34962,
-        BufferViewTarget_ELEMENT_ARRAY_BUFFER = 34963
-    };
-
-    //! Values for the Sampler::magFilter field
-    enum class SamplerMagFilter : unsigned int
-    {
-        UNSET = 0,
-        SamplerMagFilter_Nearest = 9728,
-        SamplerMagFilter_Linear = 9729
-    };
-
-    //! Values for the Sampler::minFilter field
-    enum class SamplerMinFilter : unsigned int
-    {
-        UNSET = 0,
-        SamplerMinFilter_Nearest = 9728,
-        SamplerMinFilter_Linear = 9729,
-        SamplerMinFilter_Nearest_Mipmap_Nearest = 9984,
-        SamplerMinFilter_Linear_Mipmap_Nearest = 9985,
-        SamplerMinFilter_Nearest_Mipmap_Linear = 9986,
-        SamplerMinFilter_Linear_Mipmap_Linear = 9987
-    };
-
-    //! Values for the Sampler::wrapS and Sampler::wrapT field
-    enum class SamplerWrap: unsigned int
-    {
-        UNSET = 0,
-        Clamp_To_Edge = 33071,
-        Mirrored_Repeat = 33648,
-        Repeat = 10497
-    };
-
-    //! Values for the Texture::format and Texture::internalFormat fields
-    enum TextureFormat
-    {
-        TextureFormat_ALPHA = 6406,
-        TextureFormat_RGB = 6407,
-        TextureFormat_RGBA = 6408,
-        TextureFormat_LUMINANCE = 6409,
-        TextureFormat_LUMINANCE_ALPHA = 6410
-    };
-
-    //! Values for the Texture::target field
-    enum TextureTarget
-    {
-        TextureTarget_TEXTURE_2D = 3553
-    };
-
-    //! Values for the Texture::type field
-    enum TextureType
-    {
-        TextureType_UNSIGNED_BYTE = 5121,
-        TextureType_UNSIGNED_SHORT_5_6_5 = 33635,
-        TextureType_UNSIGNED_SHORT_4_4_4_4 = 32819,
-        TextureType_UNSIGNED_SHORT_5_5_5_1 = 32820
-    };
-
-    //! Values for the Animation::Target::path field
-    enum AnimationPath {
-        AnimationPath_TRANSLATION,
-        AnimationPath_ROTATION,
-        AnimationPath_SCALE,
-        AnimationPath_WEIGHTS,
-    };
-
-    //! Values for the Animation::Sampler::interpolation field
-    enum Interpolation {
-        Interpolation_LINEAR,
-        Interpolation_STEP,
-        Interpolation_CUBICSPLINE,
-    };
-
-    //! Values for the Accessor::type field (helper class)
-    class AttribType
-    {
-    public:
-        enum Value
-            { SCALAR, VEC2, VEC3, VEC4, MAT2, MAT3, MAT4 };
-
-    private:
-        static const size_t NUM_VALUES = static_cast<size_t>(MAT4)+1;
-
-        struct Info
-            { const char* name; unsigned int numComponents; };
-
-        template<int N> struct data
-            { static const Info infos[NUM_VALUES]; };
-
-    public:
-        inline static Value FromString(const char* str)
-        {
-            for (size_t i = 0; i < NUM_VALUES; ++i) {
-                if (strcmp(data<0>::infos[i].name, str) == 0) {
-                    return static_cast<Value>(i);
-                }
-            }
-            return SCALAR;
-        }
-
-        inline static const char* ToString(Value type)
-        {
-            return data<0>::infos[static_cast<size_t>(type)].name;
-        }
-
-        inline static unsigned int GetNumComponents(Value type)
-        {
-            return data<0>::infos[static_cast<size_t>(type)].numComponents;
-        }
-    };
-
-    // must match the order of the AttribTypeTraits::Value enum!
-    template<int N> const AttribType::Info
-    AttribType::data<N>::infos[AttribType::NUM_VALUES] = {
-        { "SCALAR", 1 }, { "VEC2", 2 }, { "VEC3", 3 }, { "VEC4", 4 }, { "MAT2", 4 }, { "MAT3", 9 }, { "MAT4", 16 }
-    };
-
-
-
-    //! A reference to one top-level object, which is valid
-    //! until the Asset instance is destroyed
-    template<class T>
-    class Ref
-    {
-        std::vector<T*>* vector;
-        unsigned int index;
-
-    public:
-        Ref() : vector(0), index(0) {}
-        Ref(std::vector<T*>& vec, unsigned int idx) : vector(&vec), index(idx) {}
-
-        inline unsigned int GetIndex() const
-            { return index; }
-
-        operator bool() const
-            { return vector != 0; }
-
-        T* operator->()
-            { return (*vector)[index]; }
-
-        T& operator*()
-            { return *((*vector)[index]); }
-    };
-
-    //! Helper struct to represent values that might not be present
-    template<class T>
-    struct Nullable
-    {
-        T value;
-        bool isPresent;
-
-        Nullable() : isPresent(false) {}
-        Nullable(T& val) : value(val), isPresent(true) {}
-    };
-
-
-    //! Base class for all glTF top-level objects
-    struct Object
-    {
-        int index;        //!< The index of this object within its property container
-        int oIndex;       //!< The original index of this object defined in the JSON
-        std::string id;   //!< The globally unique ID used to reference this object
-        std::string name; //!< The user-defined name of this object
-
-        //! Objects marked as special are not exported (used to emulate the binary body buffer)
-        virtual bool IsSpecial() const
-            { return false; }
-
-        virtual ~Object() {}
-
-        //! Maps special IDs to another ID, where needed. Subclasses may override it (statically)
-        static const char* TranslateId(Asset& /*r*/, const char* id)
-            { return id; }
-    };
-
-    //
-    // Classes for each glTF top-level object type
-    //
-
-    //! A typed view into a BufferView. A BufferView contains raw binary data.
-    //! An accessor provides a typed view into a BufferView or a subset of a BufferView
-    //! similar to how WebGL's vertexAttribPointer() defines an attribute in a buffer.
-    struct Accessor : public Object
-    {
-        Ref<BufferView> bufferView;  //!< The ID of the bufferView. (required)
-        size_t byteOffset;           //!< The offset relative to the start of the bufferView in bytes. (required)
-        ComponentType componentType; //!< The datatype of components in the attribute. (required)
-        size_t count;                //!< The number of attributes referenced by this accessor. (required)
-        AttribType::Value type;      //!< Specifies if the attribute is a scalar, vector, or matrix. (required)
-        std::vector<float> max;      //!< Maximum value of each component in this attribute.
-        std::vector<float> min;      //!< Minimum value of each component in this attribute.
-
-        unsigned int GetNumComponents();
-        unsigned int GetBytesPerComponent();
-        unsigned int GetElementSize();
-
-        inline uint8_t* GetPointer();
-
-        template<class T>
-        bool ExtractData(T*& outData);
-
-        void WriteData(size_t count, const void* src_buffer, size_t src_stride);
-
-        //! Helper class to iterate the data
-        class Indexer
-        {
-            friend struct Accessor;
-
-            Accessor& accessor;
-            uint8_t* data;
-            size_t elemSize, stride;
-
-            Indexer(Accessor& acc);
-
-        public:
-
-            //! Accesses the i-th value as defined by the accessor
-            template<class T>
-            T GetValue(int i);
-
-            //! Accesses the i-th value as defined by the accessor
-            inline unsigned int GetUInt(int i)
-            {
-                return GetValue<unsigned int>(i);
-            }
-
-            inline bool IsValid() const
-            {
-                return data != 0;
-            }
-        };
-
-        inline Indexer GetIndexer()
-        {
-            return Indexer(*this);
-        }
-
-        Accessor() {}
-        void Read(Value& obj, Asset& r);
-    };
-
-    //! A buffer points to binary geometry, animation, or skins.
-    struct Buffer : public Object
-	{
-		/********************* Types *********************/
-	public:
-
-		enum Type
-		{
-			Type_arraybuffer,
-			Type_text
-		};
-
-		/// \struct SEncodedRegion
-		/// Descriptor of encoded region in "bufferView".
-		struct SEncodedRegion
-		{
-			const size_t Offset;///< Offset from begin of "bufferView" to encoded region, in bytes.
-			const size_t EncodedData_Length;///< Size of encoded region, in bytes.
-			uint8_t* const DecodedData;///< Cached encoded data.
-			const size_t DecodedData_Length;///< Size of decoded region, in bytes.
-			const std::string ID;///< ID of the region.
-
-			/// \fn SEncodedRegion(const size_t pOffset, const size_t pEncodedData_Length, uint8_t* pDecodedData, const size_t pDecodedData_Length, const std::string pID)
-			/// Constructor.
-			/// \param [in] pOffset - offset from begin of "bufferView" to encoded region, in bytes.
-			/// \param [in] pEncodedData_Length - size of encoded region, in bytes.
-			/// \param [in] pDecodedData - pointer to decoded data array.
-			/// \param [in] pDecodedData_Length - size of encoded region, in bytes.
-			/// \param [in] pID - ID of the region.
-			SEncodedRegion(const size_t pOffset, const size_t pEncodedData_Length, uint8_t* pDecodedData, const size_t pDecodedData_Length, const std::string pID)
-				: Offset(pOffset), EncodedData_Length(pEncodedData_Length), DecodedData(pDecodedData), DecodedData_Length(pDecodedData_Length), ID(pID)
-			{}
-
-			/// \fn ~SEncodedRegion()
-			/// Destructor.
-			~SEncodedRegion() { delete[] DecodedData; }
-		};
-
-		/******************* Variables *******************/
-
-		//std::string uri; //!< The uri of the buffer. Can be a filepath, a data uri, etc. (required)
-		size_t byteLength; //!< The length of the buffer in bytes. (default: 0)
-		//std::string type; //!< XMLHttpRequest responseType (default: "arraybuffer")
-        size_t capacity = 0; //!< The capacity of the buffer in bytes. (default: 0)
-
-		Type type;
-
-		/// \var EncodedRegion_Current
-		/// Pointer to currently active encoded region.
-		/// Why not decoding all regions at once and not to set one buffer with decoded data?
-		/// Yes, why not? Even "accessor" point to decoded data. I mean that fields "byteOffset", "byteStride" and "count" has values which describes decoded
-		/// data array. But only in range of mesh while is active parameters from "compressedData". For another mesh accessors point to decoded data too. But
-		/// offset is counted for another regions is encoded.
-		/// Example. You have two meshes. For every of it you have 4 bytes of data. That data compressed to 2 bytes. So, you have buffer with encoded data:
-		/// M1_E0, M1_E1, M2_E0, M2_E1.
-		/// After decoding you'll get:
-		/// M1_D0, M1_D1, M1_D2, M1_D3, M2_D0, M2_D1, M2_D2, M2_D3.
-		/// "accessors" must to use values that point to decoded data - obviously. So, you'll expect "accessors" like
-		/// "accessor_0" : { byteOffset: 0, byteLength: 4}, "accessor_1" : { byteOffset: 4, byteLength: 4}
-		/// but in real life you'll get:
-		/// "accessor_0" : { byteOffset: 0, byteLength: 4}, "accessor_1" : { byteOffset: 2, byteLength: 4}
-		/// Yes, accessor of next mesh has offset and length which mean: current mesh data is decoded, all other data is encoded.
-		/// And when before you start to read data of current mesh (with encoded data of course) you must decode region of "bufferView", after read finished
-		/// delete encoding mark. And after that you can repeat process: decode data of mesh, read, delete decoded data.
-		///
-		/// Remark. Encoding all data at once is good in world with computers which do not has RAM limitation. So, you must use step by step encoding in
-		/// exporter and importer. And, thanks to such way, there is no need to load whole file into memory.
-		SEncodedRegion* EncodedRegion_Current;
-
-	private:
-
-		shared_ptr<uint8_t> mData; //!< Pointer to the data
-		bool mIsSpecial; //!< Set to true for special cases (e.g. the body buffer)
-
-		/// \var EncodedRegion_List
-		/// List of encoded regions.
-		std::list<SEncodedRegion*> EncodedRegion_List;
-
-		/******************* Functions *******************/
-
-	public:
-
-		Buffer();
-		~Buffer();
-
-		void Read(Value& obj, Asset& r);
-
-        bool LoadFromStream(IOStream& stream, size_t length = 0, size_t baseOffset = 0);
-
-		/// \fn void EncodedRegion_Mark(const size_t pOffset, const size_t pEncodedData_Length, uint8_t* pDecodedData, const size_t pDecodedData_Length, const std::string& pID)
-		/// Mark region of "bufferView" as encoded. When data is request from such region then "bufferView" use decoded data.
-		/// \param [in] pOffset - offset from begin of "bufferView" to encoded region, in bytes.
-		/// \param [in] pEncodedData_Length - size of encoded region, in bytes.
-		/// \param [in] pDecodedData - pointer to decoded data array.
-		/// \param [in] pDecodedData_Length - size of encoded region, in bytes.
-		/// \param [in] pID - ID of the region.
-		void EncodedRegion_Mark(const size_t pOffset, const size_t pEncodedData_Length, uint8_t* pDecodedData, const size_t pDecodedData_Length, const std::string& pID);
-
-		/// \fn void EncodedRegion_SetCurrent(const std::string& pID)
-		/// Select current encoded region by ID. \sa EncodedRegion_Current.
-		/// \param [in] pID - ID of the region.
-		void EncodedRegion_SetCurrent(const std::string& pID);
-
-		/// \fn bool ReplaceData(const size_t pBufferData_Offset, const size_t pBufferData_Count, const uint8_t* pReplace_Data, const size_t pReplace_Count)
-		/// Replace part of buffer data. Pay attention that function work with original array of data (\ref mData) not with encoded regions.
-		/// \param [in] pBufferData_Offset - index of first element in buffer from which new data will be placed.
-		/// \param [in] pBufferData_Count - count of bytes in buffer which will be replaced.
-		/// \param [in] pReplace_Data - pointer to array with new data for buffer.
-		/// \param [in] pReplace_Count - count of bytes in new data.
-		/// \return true - if successfully replaced, false if input arguments is out of range.
-		bool ReplaceData(const size_t pBufferData_Offset, const size_t pBufferData_Count, const uint8_t* pReplace_Data, const size_t pReplace_Count);
-		bool ReplaceData_joint(const size_t pBufferData_Offset, const size_t pBufferData_Count, const uint8_t* pReplace_Data, const size_t pReplace_Count);
-
-        size_t AppendData(uint8_t* data, size_t length);
-        void Grow(size_t amount);
-
-        uint8_t* GetPointer()
-            { return mData.get(); }
-
-        void MarkAsSpecial()
-            { mIsSpecial = true; }
-
-        bool IsSpecial() const
-            { return mIsSpecial; }
-
-        std::string GetURI()
-            { return std::string(this->id) + ".bin"; }
-
-        static const char* TranslateId(Asset& r, const char* id);
-    };
-
-    //! A view into a buffer generally representing a subset of the buffer.
-    struct BufferView : public Object
-    {
-        Ref<Buffer> buffer; //! The ID of the buffer. (required)
-        size_t byteOffset; //! The offset into the buffer in bytes. (required)
-        size_t byteLength; //! The length of the bufferView in bytes. (default: 0)
-        unsigned int byteStride; //!< The stride, in bytes, between attributes referenced by this accessor. (default: 0)
-
-        BufferViewTarget target; //! The target that the WebGL buffer should be bound to.
-
-        void Read(Value& obj, Asset& r);
-    };
-
-    struct Camera : public Object
-    {
-        enum Type
-        {
-            Perspective,
-            Orthographic
-        };
-
-        Type type;
-
-        union
-        {
-            struct {
-                float aspectRatio; //!<The floating - point aspect ratio of the field of view. (0 = undefined = use the canvas one)
-                float yfov;  //!<The floating - point vertical field of view in radians. (required)
-                float zfar;  //!<The floating - point distance to the far clipping plane. (required)
-                float znear; //!< The floating - point distance to the near clipping plane. (required)
-            } perspective;
-
-            struct {
-                float xmag;  //! The floating-point horizontal magnification of the view. (required)
-                float ymag;  //! The floating-point vertical magnification of the view. (required)
-                float zfar;  //! The floating-point distance to the far clipping plane. (required)
-                float znear; //! The floating-point distance to the near clipping plane. (required)
-            } ortographic;
-        } cameraProperties;
-
-        Camera()
-        : type(Perspective)
-        , cameraProperties() {
-            // empty
-        }
-        void Read(Value& obj, Asset& r);
-    };
-
-    //! A light (from KHR_lights_punctual extension)
-    struct Light : public Object
-    {
-        enum Type
-        {
-            Directional,
-            Point,
-            Spot
-        };
-
-        Type type;
-
-        vec3 color;
-        float intensity;
-        Nullable<float> range;
-
-        float innerConeAngle;
-        float outerConeAngle;
-
-        Light() {}
-        void Read(Value& obj, Asset& r);
-    };
-
-    //! Image data used to create a texture.
-    struct Image : public Object
-    {
-        std::string uri; //! The uri of the image, that can be a file path, a data URI, etc.. (required)
-
-        Ref<BufferView> bufferView;
-
-        std::string mimeType;
-
-        int width, height;
-
-    private:
-        std::unique_ptr<uint8_t[]> mData;
-        size_t mDataLength;
-
-    public:
-
-        Image();
-        void Read(Value& obj, Asset& r);
-
-        inline bool HasData() const
-            { return mDataLength > 0; }
-
-        inline size_t GetDataLength() const
-            { return mDataLength; }
-
-        inline const uint8_t* GetData() const
-            { return mData.get(); }
-
-        inline uint8_t* StealData();
-
-        inline void SetData(uint8_t* data, size_t length, Asset& r);
-	};
-
-	const vec4 defaultBaseColor = {1, 1, 1, 1};
-	const vec3 defaultEmissiveFactor = {0, 0, 0};
-	const vec4 defaultDiffuseFactor = {1, 1, 1, 1};
-	const vec3 defaultSpecularFactor = {1, 1, 1};
-
-    struct TextureInfo
-    {
-        Ref<Texture> texture;
-        unsigned int index;
-        unsigned int texCoord = 0;
-    };
-
-    struct NormalTextureInfo : TextureInfo
-    {
-        float scale = 1;
-    };
-
-    struct OcclusionTextureInfo : TextureInfo
-    {
-        float strength = 1;
-    };
-
-    struct PbrMetallicRoughness
-    {
-        vec4 baseColorFactor;
-        TextureInfo baseColorTexture;
-        TextureInfo metallicRoughnessTexture;
-        float metallicFactor;
-        float roughnessFactor;
-    };
-
-    struct PbrSpecularGlossiness
-    {
-        vec4 diffuseFactor;
-        vec3 specularFactor;
-        float glossinessFactor;
-        TextureInfo diffuseTexture;
-		TextureInfo specularGlossinessTexture;
-
-		PbrSpecularGlossiness() { SetDefaults(); }
-		void SetDefaults();
-    };
-
-    //! The material appearance of a primitive.
-    struct Material : public Object
-    {
-        //PBR metallic roughness properties
-        PbrMetallicRoughness pbrMetallicRoughness;
-
-        //other basic material properties
-        NormalTextureInfo normalTexture;
-        OcclusionTextureInfo occlusionTexture;
-        TextureInfo emissiveTexture;
-        vec3 emissiveFactor;
-        std::string alphaMode;
-        float alphaCutoff;
-        bool doubleSided;
-
-        //extension: KHR_materials_pbrSpecularGlossiness
-        Nullable<PbrSpecularGlossiness> pbrSpecularGlossiness;
-
-        //extension: KHR_materials_unlit
-        bool unlit;
-
-        Material() { SetDefaults(); }
-        void Read(Value& obj, Asset& r);
-        void SetDefaults();
-    };
-
-    //! A set of primitives to be rendered. A node can contain one or more meshes. A node's transform places the mesh in the scene.
-    struct Mesh : public Object
-    {
-        typedef std::vector< Ref<Accessor> > AccessorList;
-
-        struct Primitive
-        {
-            PrimitiveMode mode;
-
-            struct Attributes {
-                AccessorList position, normal, tangent, texcoord, color, joint, jointmatrix, weight;
-            } attributes;
-
-            Ref<Accessor> indices;
-
-            Ref<Material> material;
-
-            struct Target {
-                AccessorList position, normal, tangent;
-            };
-            std::vector<Target> targets;
-        };
-
-        std::vector<Primitive> primitives;
-
-        std::vector<float> weights;
-
-        Mesh() {}
-
-		/// \fn void Read(Value& pJSON_Object, Asset& pAsset_Root)
-		/// Get mesh data from JSON-object and place them to root asset.
-		/// \param [in] pJSON_Object - reference to pJSON-object from which data are read.
-		/// \param [out] pAsset_Root - reference to root assed where data will be stored.
-		void Read(Value& pJSON_Object, Asset& pAsset_Root);
-    };
-
-    struct Node : public Object
-    {
-        std::vector< Ref<Node> > children;
-        std::vector< Ref<Mesh> > meshes;
-
-        Nullable<mat4> matrix;
-        Nullable<vec3> translation;
-        Nullable<vec4> rotation;
-        Nullable<vec3> scale;
-
-        Ref<Camera> camera;
-        Ref<Light>  light;
-
-        std::vector< Ref<Node> > skeletons;       //!< The ID of skeleton nodes. Each of which is the root of a node hierarchy.
-        Ref<Skin> skin;                           //!< The ID of the skin referenced by this node.
-        std::string jointName;                    //!< Name used when this node is a joint in a skin.
-
-        Ref<Node> parent;                         //!< This is not part of the glTF specification. Used as a helper.
-
-        Node() {}
-        void Read(Value& obj, Asset& r);
-    };
-
-    struct Program : public Object
-    {
-        Program() {}
-        void Read(Value& obj, Asset& r);
-    };
-
-
-    struct Sampler : public Object
-    {
-        SamplerMagFilter magFilter; //!< The texture magnification filter.
-        SamplerMinFilter minFilter; //!< The texture minification filter.
-        SamplerWrap wrapS;          //!< The texture wrapping in the S direction.
-        SamplerWrap wrapT;          //!< The texture wrapping in the T direction.
-
-        Sampler() { SetDefaults(); }
-        void Read(Value& obj, Asset& r);
-        void SetDefaults();
-    };
-
-    struct Scene : public Object
-    {
-        std::vector< Ref<Node> > nodes;
-
-        Scene() {}
-        void Read(Value& obj, Asset& r);
-    };
-
-    struct Shader : public Object
-    {
-        Shader() {}
-        void Read(Value& obj, Asset& r);
-    };
-
-    struct Skin : public Object
-    {
-        Nullable<mat4> bindShapeMatrix;       //!< Floating-point 4x4 transformation matrix stored in column-major order.
-        Ref<Accessor> inverseBindMatrices;    //!< The ID of the accessor containing the floating-point 4x4 inverse-bind matrices.
-        std::vector<Ref<Node>> jointNames;    //!< Joint names of the joints (nodes with a jointName property) in this skin.
-        std::string name;                     //!< The user-defined name of this object.
-
-        Skin() {}
-        void Read(Value& obj, Asset& r);
-    };
-
-    //! A texture and its sampler.
-    struct Texture : public Object
-    {
-        Ref<Sampler> sampler; //!< The ID of the sampler used by this texture. (required)
-        Ref<Image> source;    //!< The ID of the image used by this texture. (required)
-
-        //TextureFormat format; //!< The texture's format. (default: TextureFormat_RGBA)
-        //TextureFormat internalFormat; //!< The texture's internal format. (default: TextureFormat_RGBA)
-
-        //TextureTarget target; //!< The target that the WebGL texture should be bound to. (default: TextureTarget_TEXTURE_2D)
-        //TextureType type; //!< Texel datatype. (default: TextureType_UNSIGNED_BYTE)
-
-        Texture() {}
-        void Read(Value& obj, Asset& r);
-    };
-
-    struct Animation : public Object
-    {
-        struct Sampler {
-            Sampler() : interpolation(Interpolation_LINEAR) {}
-
-            Ref<Accessor> input;          //!< Accessor reference to the buffer storing the key-frame times.
-            Ref<Accessor> output;         //!< Accessor reference to the buffer storing the key-frame values.
-            Interpolation interpolation;  //!< Type of interpolation algorithm to use between key-frames.
-        };
-
-        struct Target {
-            Target() : path(AnimationPath_TRANSLATION) {}
-
-            Ref<Node> node;                //!< The node to animate.
-            AnimationPath path;            //!< The property of the node to animate.
-        };
-
-        struct Channel {
-            Channel() : sampler(-1) {}
-
-            int sampler;                   //!< The sampler index containing the animation data.
-            Target target;                 //!< The node and property to animate.
-        };
-
-        std::vector<Sampler> samplers;     //!< All the key-frame data for this animation.
-        std::vector<Channel> channels;     //!< Data to connect nodes to key-frames.
-
-        Animation() {}
-        void Read(Value& obj, Asset& r);
-    };
-
-    //! Base class for LazyDict that acts as an interface
-    class LazyDictBase
-    {
-    public:
-        virtual ~LazyDictBase() {}
-
-        virtual void AttachToDocument(Document& doc) = 0;
-        virtual void DetachFromDocument() = 0;
-
-        virtual void WriteObjects(AssetWriter& writer) = 0;
-    };
-
-
-    template<class T>
-    class LazyDict;
-
-    //! (Implemented in glTFAssetWriter.h)
-    template<class T>
-    void WriteLazyDict(LazyDict<T>& d, AssetWriter& w);
-
-
-    //! Manages lazy loading of the glTF top-level objects, and keeps a reference to them by ID
-    //! It is the owner the loaded objects, so when it is destroyed it also deletes them
-    template<class T>
-    class LazyDict : public LazyDictBase
-    {
-        friend class Asset;
-        friend class AssetWriter;
-
-        typedef typename std::gltf_unordered_map< unsigned int, unsigned int > Dict;
-        typedef typename std::gltf_unordered_map< std::string, unsigned int > IdDict;
-
-        std::vector<T*>     mObjs;         //! The read objects
-        Dict                mObjsByOIndex; //! The read objects accessible by original index
-        IdDict              mObjsById;     //! The read objects accessible by id
-        const char*         mDictId;       //! ID of the dictionary object
-        const char*         mExtId;        //! ID of the extension defining the dictionary
-        Value*              mDict;         //! JSON dictionary object
-        Asset&              mAsset;        //! The asset instance
-
-        void AttachToDocument(Document& doc);
-        void DetachFromDocument();
-
-        void WriteObjects(AssetWriter& writer)
-            { WriteLazyDict<T>(*this, writer); }
-
-        Ref<T> Add(T* obj);
-
-    public:
-        LazyDict(Asset& asset, const char* dictId, const char* extId = 0);
-        ~LazyDict();
-
-        Ref<T> Retrieve(unsigned int i);
-
-        Ref<T> Get(unsigned int i);
-        Ref<T> Get(const char* id);
-
-        Ref<T> Create(const char* id);
-        Ref<T> Create(const std::string& id)
-            { return Create(id.c_str()); }
-
-        unsigned int Remove(const char* id);
-
-        inline unsigned int Size() const
-            { return unsigned(mObjs.size()); }
-
-        inline T& operator[](size_t i)
-            { return *mObjs[i]; }
-
-    };
-
-
-    struct AssetMetadata
-    {
-        std::string copyright; //!< A copyright message suitable for display to credit the content creator.
-        std::string generator; //!< Tool that generated this glTF model.Useful for debugging.
-
-        struct {
-            std::string api;     //!< Specifies the target rendering API (default: "WebGL")
-            std::string version; //!< Specifies the target rendering API (default: "1.0.3")
-        } profile; //!< Specifies the target rendering API and version, e.g., WebGL 1.0.3. (default: {})
-
-        std::string version; //!< The glTF format version
-
-        void Read(Document& doc);
-
-        AssetMetadata() : version("") {}
-    };
-
-    //
-    // glTF Asset class
-    //
-
-    //! Root object for a glTF asset
-    class Asset
-    {
-        typedef std::gltf_unordered_map<std::string, int> IdMap;
-
-        template<class T>
-        friend class LazyDict;
-
-        friend struct Buffer; // To access OpenFile
-
-        friend class AssetWriter;
-
-    private:
-        IOSystem* mIOSystem;
-
-        std::string mCurrentAssetDir;
-
-        size_t mSceneLength;
-        size_t mBodyOffset, mBodyLength;
-
-        std::vector<LazyDictBase*> mDicts;
-
-        IdMap mUsedIds;
-
-        Ref<Buffer> mBodyBuffer;
-
-        Asset(Asset&);
-        Asset& operator=(const Asset&);
-
-    public:
-
-        //! Keeps info about the enabled extensions
-        struct Extensions
-        {
-            bool KHR_materials_pbrSpecularGlossiness;
-            bool KHR_materials_unlit;
-            bool KHR_lights_punctual;
-
-        } extensionsUsed;
-
-        AssetMetadata asset;
-
-
-        // Dictionaries for each type of object
-
-        LazyDict<Accessor>    accessors;
-        LazyDict<Animation>   animations;
-        LazyDict<Buffer>      buffers;
-        LazyDict<BufferView>  bufferViews;
-        LazyDict<Camera>      cameras;
-        LazyDict<Light>       lights;
-        LazyDict<Image>       images;
-        LazyDict<Material>    materials;
-        LazyDict<Mesh>        meshes;
-        LazyDict<Node>        nodes;
-        LazyDict<Sampler>     samplers;
-        LazyDict<Scene>       scenes;
-        LazyDict<Skin>        skins;
-        LazyDict<Texture>     textures;
-
-        Ref<Scene> scene;
-
-    public:
-        Asset(IOSystem* io = 0)
-            : mIOSystem(io)
-            , asset()
-            , accessors     (*this, "accessors")
-            , animations    (*this, "animations")
-            , buffers       (*this, "buffers")
-            , bufferViews   (*this, "bufferViews")
-            , cameras       (*this, "cameras")
-            , lights        (*this, "lights", "KHR_lights_punctual")
-            , images        (*this, "images")
-            , materials     (*this, "materials")
-            , meshes        (*this, "meshes")
-            , nodes         (*this, "nodes")
-            , samplers      (*this, "samplers")
-            , scenes        (*this, "scenes")
-            , skins         (*this, "skins")
-            , textures      (*this, "textures")
-        {
-            memset(&extensionsUsed, 0, sizeof(extensionsUsed));
-        }
-
-        //! Main function
-        void Load(const std::string& file, bool isBinary = false);
-
-        //! Enables binary encoding on the asset
-        void SetAsBinary();
-
-        //! Search for an available name, starting from the given strings
-        std::string FindUniqueID(const std::string& str, const char* suffix);
-
-        Ref<Buffer> GetBodyBuffer()
-            { return mBodyBuffer; }
-
-    private:
-        void ReadBinaryHeader(IOStream& stream, std::vector<char>& sceneData);
-
-        void ReadExtensionsUsed(Document& doc);
-
-        IOStream* OpenFile(std::string path, const char* mode, bool absolute = false);
-    };
-
-}
-
-// Include the implementation of the methods
-#include "glTF2Asset.inl"
-
-#endif // ASSIMP_BUILD_NO_GLTF_IMPORTER
-
-#endif // GLTF2ASSET_H_INC
diff --git a/Engine/lib/assimp/code/glTF2/glTF2Asset.inl b/Engine/lib/assimp/code/glTF2/glTF2Asset.inl
deleted file mode 100644
index 6b47b1607..000000000
--- a/Engine/lib/assimp/code/glTF2/glTF2Asset.inl
+++ /dev/null
@@ -1,1519 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-#include <assimp/StringUtils.h>
-
-// Header files, Assimp
-#include <assimp/DefaultLogger.hpp>
-
-using namespace Assimp;
-
-namespace glTF2 {
-
-namespace {
-
-    //
-    // JSON Value reading helpers
-    //
-
-    template<class T>
-    struct ReadHelper { static bool Read(Value& val, T& out) {
-        return val.IsInt() ? out = static_cast<T>(val.GetInt()), true : false;
-    }};
-
-    template<> struct ReadHelper<bool> { static bool Read(Value& val, bool& out) {
-        return val.IsBool() ? out = val.GetBool(), true : false;
-    }};
-
-    template<> struct ReadHelper<float> { static bool Read(Value& val, float& out) {
-        return val.IsNumber() ? out = static_cast<float>(val.GetDouble()), true : false;
-    }};
-
-    template<unsigned int N> struct ReadHelper<float[N]> { static bool Read(Value& val, float (&out)[N]) {
-        if (!val.IsArray() || val.Size() != N) return false;
-        for (unsigned int i = 0; i < N; ++i) {
-            if (val[i].IsNumber())
-                out[i] = static_cast<float>(val[i].GetDouble());
-        }
-        return true;
-    }};
-
-    template<> struct ReadHelper<const char*> { static bool Read(Value& val, const char*& out) {
-        return val.IsString() ? (out = val.GetString(), true) : false;
-    }};
-
-    template<> struct ReadHelper<std::string> { static bool Read(Value& val, std::string& out) {
-        return val.IsString() ? (out = std::string(val.GetString(), val.GetStringLength()), true) : false;
-    }};
-
-    template<> struct ReadHelper<uint64_t> { static bool Read(Value& val, uint64_t& out) {
-        return val.IsUint64() ? out = val.GetUint64(), true : false;
-    }};
-
-    template<> struct ReadHelper<int64_t> { static bool Read(Value& val, int64_t& out) {
-        return val.IsInt64() ? out = val.GetInt64(), true : false;
-    }};
-
-    template<class T> struct ReadHelper< Nullable<T> > { static bool Read(Value& val, Nullable<T>& out) {
-        return out.isPresent = ReadHelper<T>::Read(val, out.value);
-    }};
-
-    template<class T>
-    inline static bool ReadValue(Value& val, T& out)
-    {
-        return ReadHelper<T>::Read(val, out);
-    }
-
-    template<class T>
-    inline static bool ReadMember(Value& obj, const char* id, T& out)
-    {
-        Value::MemberIterator it = obj.FindMember(id);
-        if (it != obj.MemberEnd()) {
-            return ReadHelper<T>::Read(it->value, out);
-        }
-        return false;
-    }
-
-    template<class T>
-    inline static T MemberOrDefault(Value& obj, const char* id, T defaultValue)
-    {
-        T out;
-        return ReadMember(obj, id, out) ? out : defaultValue;
-    }
-
-    inline Value* FindMember(Value& val, const char* id)
-    {
-        Value::MemberIterator it = val.FindMember(id);
-        return (it != val.MemberEnd()) ? &it->value : 0;
-    }
-
-    inline Value* FindString(Value& val, const char* id)
-    {
-        Value::MemberIterator it = val.FindMember(id);
-        return (it != val.MemberEnd() && it->value.IsString()) ? &it->value : 0;
-    }
-
-    inline Value* FindNumber(Value& val, const char* id)
-    {
-        Value::MemberIterator it = val.FindMember(id);
-        return (it != val.MemberEnd() && it->value.IsNumber()) ? &it->value : 0;
-    }
-
-    inline Value* FindUInt(Value& val, const char* id)
-    {
-        Value::MemberIterator it = val.FindMember(id);
-        return (it != val.MemberEnd() && it->value.IsUint()) ? &it->value : 0;
-    }
-
-    inline Value* FindArray(Value& val, const char* id)
-    {
-        Value::MemberIterator it = val.FindMember(id);
-        return (it != val.MemberEnd() && it->value.IsArray()) ? &it->value : 0;
-    }
-
-    inline Value* FindObject(Value& val, const char* id)
-    {
-        Value::MemberIterator it = val.FindMember(id);
-        return (it != val.MemberEnd() && it->value.IsObject()) ? &it->value : 0;
-    }
-}
-
-//
-// LazyDict methods
-//
-
-template<class T>
-inline LazyDict<T>::LazyDict(Asset& asset, const char* dictId, const char* extId)
-    : mDictId(dictId), mExtId(extId), mDict(0), mAsset(asset)
-{
-    asset.mDicts.push_back(this); // register to the list of dictionaries
-}
-
-template<class T>
-inline LazyDict<T>::~LazyDict()
-{
-    for (size_t i = 0; i < mObjs.size(); ++i) {
-        delete mObjs[i];
-    }
-}
-
-
-template<class T>
-inline void LazyDict<T>::AttachToDocument(Document& doc)
-{
-    Value* container = 0;
-
-    if (mExtId) {
-        if (Value* exts = FindObject(doc, "extensions")) {
-            container = FindObject(*exts, mExtId);
-        }
-    }
-    else {
-        container = &doc;
-    }
-
-    if (container) {
-        mDict = FindArray(*container, mDictId);
-    }
-}
-
-template<class T>
-inline void LazyDict<T>::DetachFromDocument()
-{
-    mDict = 0;
-}
-
-template<class T>
-unsigned int LazyDict<T>::Remove(const char* id)
-{
-    id = T::TranslateId(mAsset, id);
-
-    typename IdDict::iterator it = mObjsById.find(id);
-
-    if (it == mObjsById.end()) {
-        throw DeadlyExportError("GLTF: Object with id \"" + std::string(id) + "\" is not found");
-    }
-
-    const unsigned int index = it->second;
-
-    mAsset.mUsedIds[id] = false;
-    mObjsById.erase(id);
-    mObjsByOIndex.erase(index);
-    mObjs.erase(mObjs.begin() + index);
-
-    //update index of object in mObjs;
-    for (unsigned int i = index; i < mObjs.size(); ++i) {
-        T *obj = mObjs[i];
-
-        obj->index = i;
-    }
-
-    for (IdDict::iterator it = mObjsById.begin(); it != mObjsById.end(); ++it) {
-        if (it->second <= index) {
-            continue;
-        }
-
-        mObjsById[it->first] = it->second - 1;
-    }
-
-    for (Dict::iterator it = mObjsByOIndex.begin(); it != mObjsByOIndex.end(); ++it) {
-        if (it->second <= index) {
-            continue;
-        }
-
-        mObjsByOIndex[it->first] = it->second - 1;
-    }
-
-    return index;
-}
-
-template<class T>
-Ref<T> LazyDict<T>::Retrieve(unsigned int i)
-{
-
-    typename Dict::iterator it = mObjsByOIndex.find(i);
-    if (it != mObjsByOIndex.end()) {// already created?
-        return Ref<T>(mObjs, it->second);
-    }
-
-    // read it from the JSON object
-    if (!mDict) {
-        throw DeadlyImportError("GLTF: Missing section \"" + std::string(mDictId) + "\"");
-    }
-
-    if (!mDict->IsArray()) {
-        throw DeadlyImportError("GLTF: Field is not an array \"" + std::string(mDictId) + "\"");
-    }
-
-    Value &obj = (*mDict)[i];
-
-    if (!obj.IsObject()) {
-        throw DeadlyImportError("GLTF: Object at index \"" + to_string(i) + "\" is not a JSON object");
-    }
-
-    T* inst = new T();
-    inst->id = std::string(mDictId) + "_" + to_string(i);
-    inst->oIndex = i;
-    ReadMember(obj, "name", inst->name);
-    inst->Read(obj, mAsset);
-
-    return Add(inst);
-}
-
-template<class T>
-Ref<T> LazyDict<T>::Get(unsigned int i)
-{
-    return Ref<T>(mObjs, i);
-}
-
-template<class T>
-Ref<T> LazyDict<T>::Get(const char* id)
-{
-    id = T::TranslateId(mAsset, id);
-
-    typename IdDict::iterator it = mObjsById.find(id);
-    if (it != mObjsById.end()) { // already created?
-        return Ref<T>(mObjs, it->second);
-    }
-
-    return Ref<T>();
-}
-
-template<class T>
-Ref<T> LazyDict<T>::Add(T* obj)
-{
-    unsigned int idx = unsigned(mObjs.size());
-    mObjs.push_back(obj);
-    mObjsByOIndex[obj->oIndex] = idx;
-    mObjsById[obj->id] = idx;
-    mAsset.mUsedIds[obj->id] = true;
-    return Ref<T>(mObjs, idx);
-}
-
-template<class T>
-Ref<T> LazyDict<T>::Create(const char* id)
-{
-    Asset::IdMap::iterator it = mAsset.mUsedIds.find(id);
-    if (it != mAsset.mUsedIds.end()) {
-        throw DeadlyImportError("GLTF: two objects with the same ID exist");
-    }
-    T* inst = new T();
-    unsigned int idx = unsigned(mObjs.size());
-    inst->id = id;
-    inst->index = idx;
-    inst->oIndex = idx;
-    return Add(inst);
-}
-
-
-//
-// glTF dictionary objects methods
-//
-
-
-inline Buffer::Buffer()
-	: byteLength(0), type(Type_arraybuffer), EncodedRegion_Current(nullptr), mIsSpecial(false)
-{ }
-
-inline Buffer::~Buffer()
-{
-	for(SEncodedRegion* reg : EncodedRegion_List) delete reg;
-}
-
-inline const char* Buffer::TranslateId(Asset& /*r*/, const char* id)
-{
-    return id;
-}
-
-inline void Buffer::Read(Value& obj, Asset& r)
-{
-    size_t statedLength = MemberOrDefault<size_t>(obj, "byteLength", 0);
-    byteLength = statedLength;
-
-    Value* it = FindString(obj, "uri");
-    if (!it) {
-        if (statedLength > 0) {
-            throw DeadlyImportError("GLTF: buffer with non-zero length missing the \"uri\" attribute");
-        }
-        return;
-    }
-
-    const char* uri = it->GetString();
-
-    glTFCommon::Util::DataURI dataURI;
-    if (ParseDataURI(uri, it->GetStringLength(), dataURI)) {
-        if (dataURI.base64) {
-            uint8_t* data = 0;
-            this->byteLength = glTFCommon::Util::DecodeBase64(dataURI.data, dataURI.dataLength, data);
-            this->mData.reset(data, std::default_delete<uint8_t[]>());
-
-            if (statedLength > 0 && this->byteLength != statedLength) {
-                throw DeadlyImportError("GLTF: buffer \"" + id + "\", expected " + to_string(statedLength) +
-                    " bytes, but found " + to_string(dataURI.dataLength));
-            }
-        }
-        else { // assume raw data
-            if (statedLength != dataURI.dataLength) {
-                throw DeadlyImportError("GLTF: buffer \"" + id + "\", expected " + to_string(statedLength) +
-                                        " bytes, but found " + to_string(dataURI.dataLength));
-            }
-
-            this->mData.reset(new uint8_t[dataURI.dataLength], std::default_delete<uint8_t[]>());
-            memcpy( this->mData.get(), dataURI.data, dataURI.dataLength );
-        }
-    }
-    else { // Local file
-        if (byteLength > 0) {
-            std::string dir = !r.mCurrentAssetDir.empty() ? (r.mCurrentAssetDir + "/") : "";
-
-            IOStream* file = r.OpenFile(dir + uri, "rb");
-            if (file) {
-                bool ok = LoadFromStream(*file, byteLength);
-                delete file;
-
-                if (!ok)
-                    throw DeadlyImportError("GLTF: error while reading referenced file \"" + std::string(uri) + "\"" );
-            }
-            else {
-                throw DeadlyImportError("GLTF: could not open referenced file \"" + std::string(uri) + "\"");
-            }
-        }
-    }
-}
-
-inline bool Buffer::LoadFromStream(IOStream& stream, size_t length, size_t baseOffset)
-{
-    byteLength = length ? length : stream.FileSize();
-
-    if (baseOffset) {
-        stream.Seek(baseOffset, aiOrigin_SET);
-    }
-
-    mData.reset(new uint8_t[byteLength], std::default_delete<uint8_t[]>());
-
-    if (stream.Read(mData.get(), byteLength, 1) != 1) {
-        return false;
-    }
-    return true;
-}
-
-inline void Buffer::EncodedRegion_Mark(const size_t pOffset, const size_t pEncodedData_Length, uint8_t* pDecodedData, const size_t pDecodedData_Length, const std::string& pID)
-{
-	// Check pointer to data
-	if(pDecodedData == nullptr) throw DeadlyImportError("GLTF: for marking encoded region pointer to decoded data must be provided.");
-
-	// Check offset
-	if(pOffset > byteLength)
-	{
-		const uint8_t val_size = 32;
-
-		char val[val_size];
-
-		ai_snprintf(val, val_size, "%llu", (long long)pOffset);
-		throw DeadlyImportError(std::string("GLTF: incorrect offset value (") + val + ") for marking encoded region.");
-	}
-
-	// Check length
-	if((pOffset + pEncodedData_Length) > byteLength)
-	{
-		const uint8_t val_size = 64;
-
-		char val[val_size];
-
-		ai_snprintf(val, val_size, "%llu, %llu", (long long)pOffset, (long long)pEncodedData_Length);
-		throw DeadlyImportError(std::string("GLTF: encoded region with offset/length (") + val + ") is out of range.");
-	}
-
-	// Add new region
-	EncodedRegion_List.push_back(new SEncodedRegion(pOffset, pEncodedData_Length, pDecodedData, pDecodedData_Length, pID));
-	// And set new value for "byteLength"
-	byteLength += (pDecodedData_Length - pEncodedData_Length);
-}
-
-inline void Buffer::EncodedRegion_SetCurrent(const std::string& pID)
-{
-	if((EncodedRegion_Current != nullptr) && (EncodedRegion_Current->ID == pID)) return;
-
-	for(SEncodedRegion* reg : EncodedRegion_List)
-	{
-		if(reg->ID == pID)
-		{
-			EncodedRegion_Current = reg;
-
-			return;
-		}
-
-	}
-
-	throw DeadlyImportError("GLTF: EncodedRegion with ID: \"" + pID + "\" not found.");
-}
-
-inline
-bool Buffer::ReplaceData(const size_t pBufferData_Offset, const size_t pBufferData_Count, const uint8_t* pReplace_Data, const size_t pReplace_Count)
-{
-
-	if((pBufferData_Count == 0) || (pReplace_Count == 0) || (pReplace_Data == nullptr)) {
-		return false;
-	}
-
-        const size_t new_data_size = byteLength + pReplace_Count - pBufferData_Count;
-	uint8_t *new_data = new uint8_t[new_data_size];
-	// Copy data which place before replacing part.
-	::memcpy(new_data, mData.get(), pBufferData_Offset);
-	// Copy new data.
-	::memcpy(&new_data[pBufferData_Offset], pReplace_Data, pReplace_Count);
-	// Copy data which place after replacing part.
-	::memcpy(&new_data[pBufferData_Offset + pReplace_Count], &mData.get()[pBufferData_Offset + pBufferData_Count], pBufferData_Offset);
-	// Apply new data
-	mData.reset(new_data, std::default_delete<uint8_t[]>());
-	byteLength = new_data_size;
-
-	return true;
-}
-
-inline
-bool Buffer::ReplaceData_joint(const size_t pBufferData_Offset, const size_t pBufferData_Count, const uint8_t* pReplace_Data, const size_t pReplace_Count)
-{
-	if((pBufferData_Count == 0) || (pReplace_Count == 0) || (pReplace_Data == nullptr)) {
-		return false;
-	}
-
-	const size_t new_data_size = byteLength + pReplace_Count - pBufferData_Count;
-	uint8_t* new_data = new uint8_t[new_data_size];
-	// Copy data which place before replacing part.
-	memcpy(new_data, mData.get(), pBufferData_Offset);
-	// Copy new data.
-	memcpy(&new_data[pBufferData_Offset], pReplace_Data, pReplace_Count);
-	// Copy data which place after replacing part.
-    memcpy(&new_data[pBufferData_Offset + pReplace_Count], &mData.get()[pBufferData_Offset + pBufferData_Count]
-            , new_data_size - (pBufferData_Offset + pReplace_Count)
-          );
-	// Apply new data
-	mData.reset(new_data, std::default_delete<uint8_t[]>());
-	byteLength = new_data_size;
-
-	return true;
-}
-
-inline size_t Buffer::AppendData(uint8_t* data, size_t length)
-{
-    size_t offset = this->byteLength;
-    // Force alignment to 4 bits
-    Grow((length + 3) & ~3);
-    memcpy(mData.get() + offset, data, length);
-    return offset;
-}
-
-inline void Buffer::Grow(size_t amount)
-{
-    if (amount <= 0) return;
-    if (capacity >= byteLength + amount)
-    {
-        byteLength += amount;
-        return;
-    }
-
-    // Shift operation is standard way to divide integer by 2, it doesn't cast it to float back and forth, also works for odd numbers,
-    // originally it would look like: static_cast<size_t>(capacity * 1.5f)
-    capacity = std::max(capacity + (capacity >> 1), byteLength + amount);
-
-    uint8_t* b = new uint8_t[capacity];
-    if (mData) memcpy(b, mData.get(), byteLength);
-    mData.reset(b, std::default_delete<uint8_t[]>());
-    byteLength += amount;
-}
-
-//
-// struct BufferView
-//
-
-inline void BufferView::Read(Value& obj, Asset& r)
-{
-
-    if (Value* bufferVal = FindUInt(obj, "buffer")) {
-        buffer = r.buffers.Retrieve(bufferVal->GetUint());
-    }
-
-    byteOffset = MemberOrDefault(obj, "byteOffset", size_t(0));
-    byteLength = MemberOrDefault(obj, "byteLength", size_t(0));
-    byteStride = MemberOrDefault(obj, "byteStride", 0u);
-}
-
-//
-// struct Accessor
-//
-
-inline void Accessor::Read(Value& obj, Asset& r)
-{
-
-    if (Value* bufferViewVal = FindUInt(obj, "bufferView")) {
-        bufferView = r.bufferViews.Retrieve(bufferViewVal->GetUint());
-    }
-
-    byteOffset = MemberOrDefault(obj, "byteOffset", size_t(0));
-    componentType = MemberOrDefault(obj, "componentType", ComponentType_BYTE);
-    count = MemberOrDefault(obj, "count", size_t(0));
-
-    const char* typestr;
-    type = ReadMember(obj, "type", typestr) ? AttribType::FromString(typestr) : AttribType::SCALAR;
-}
-
-inline unsigned int Accessor::GetNumComponents()
-{
-    return AttribType::GetNumComponents(type);
-}
-
-inline unsigned int Accessor::GetBytesPerComponent()
-{
-    return int(ComponentTypeSize(componentType));
-}
-
-inline unsigned int Accessor::GetElementSize()
-{
-    return GetNumComponents() * GetBytesPerComponent();
-}
-
-inline uint8_t* Accessor::GetPointer()
-{
-    if (!bufferView || !bufferView->buffer) return 0;
-    uint8_t* basePtr = bufferView->buffer->GetPointer();
-    if (!basePtr) return 0;
-
-    size_t offset = byteOffset + bufferView->byteOffset;
-
-	// Check if region is encoded.
-	if(bufferView->buffer->EncodedRegion_Current != nullptr)
-	{
-		const size_t begin = bufferView->buffer->EncodedRegion_Current->Offset;
-		const size_t end = begin + bufferView->buffer->EncodedRegion_Current->DecodedData_Length;
-
-		if((offset >= begin) && (offset < end))
-			return &bufferView->buffer->EncodedRegion_Current->DecodedData[offset - begin];
-	}
-
-	return basePtr + offset;
-}
-
-namespace {
-    inline void CopyData(size_t count,
-            const uint8_t* src, size_t src_stride,
-                  uint8_t* dst, size_t dst_stride)
-    {
-        if (src_stride == dst_stride) {
-            memcpy(dst, src, count * src_stride);
-        }
-        else {
-            size_t sz = std::min(src_stride, dst_stride);
-            for (size_t i = 0; i < count; ++i) {
-                memcpy(dst, src, sz);
-                if (sz < dst_stride) {
-                    memset(dst + sz, 0, dst_stride - sz);
-                }
-                src += src_stride;
-                dst += dst_stride;
-            }
-        }
-    }
-}
-
-template<class T>
-bool Accessor::ExtractData(T*& outData)
-{
-    uint8_t* data = GetPointer();
-    if (!data) return false;
-
-    const size_t elemSize = GetElementSize();
-    const size_t totalSize = elemSize * count;
-
-    const size_t stride = bufferView && bufferView->byteStride ? bufferView->byteStride : elemSize;
-
-    const size_t targetElemSize = sizeof(T);
-    ai_assert(elemSize <= targetElemSize);
-
-    ai_assert(count*stride <= bufferView->byteLength);
-
-    outData = new T[count];
-    if (stride == elemSize && targetElemSize == elemSize) {
-        memcpy(outData, data, totalSize);
-    }
-    else {
-        for (size_t i = 0; i < count; ++i) {
-            memcpy(outData + i, data + i*stride, elemSize);
-        }
-    }
-
-    return true;
-}
-
-inline void Accessor::WriteData(size_t count, const void* src_buffer, size_t src_stride)
-{
-    uint8_t* buffer_ptr = bufferView->buffer->GetPointer();
-    size_t offset = byteOffset + bufferView->byteOffset;
-
-    size_t dst_stride = GetNumComponents() * GetBytesPerComponent();
-
-    const uint8_t* src = reinterpret_cast<const uint8_t*>(src_buffer);
-    uint8_t*       dst = reinterpret_cast<      uint8_t*>(buffer_ptr + offset);
-
-    ai_assert(dst + count*dst_stride <= buffer_ptr + bufferView->buffer->byteLength);
-    CopyData(count, src, src_stride, dst, dst_stride);
-}
-
-
-
-inline Accessor::Indexer::Indexer(Accessor& acc)
-    : accessor(acc)
-    , data(acc.GetPointer())
-    , elemSize(acc.GetElementSize())
-    , stride(acc.bufferView && acc.bufferView->byteStride ? acc.bufferView->byteStride : elemSize)
-{
-
-}
-
-//! Accesses the i-th value as defined by the accessor
-template<class T>
-T Accessor::Indexer::GetValue(int i)
-{
-    ai_assert(data);
-    ai_assert(i*stride < accessor.bufferView->byteLength);
-    T value = T();
-    memcpy(&value, data + i*stride, elemSize);
-    //value >>= 8 * (sizeof(T) - elemSize);
-    return value;
-}
-
-inline Image::Image()
-    : width(0)
-    , height(0)
-    , mDataLength(0)
-{
-
-}
-
-inline void Image::Read(Value& obj, Asset& r)
-{
-    if (!mDataLength) {
-        if (Value* uri = FindString(obj, "uri")) {
-            const char* uristr = uri->GetString();
-
-            glTFCommon::Util::DataURI dataURI;
-            if (ParseDataURI(uristr, uri->GetStringLength(), dataURI)) {
-                mimeType = dataURI.mediaType;
-                if (dataURI.base64) {
-                    uint8_t *ptr = nullptr;
-                    mDataLength = glTFCommon::Util::DecodeBase64(dataURI.data, dataURI.dataLength, ptr);
-                    mData.reset(ptr);
-                }
-            }
-            else {
-                this->uri = uristr;
-            }
-        }
-        else if (Value* bufferViewVal = FindUInt(obj, "bufferView")) {
-            this->bufferView = r.bufferViews.Retrieve(bufferViewVal->GetUint());
-            Ref<Buffer> buffer = this->bufferView->buffer;
-
-            this->mDataLength = this->bufferView->byteLength;
-            // maybe this memcpy could be avoided if aiTexture does not delete[] pcData at destruction.
-
-			this->mData.reset(new uint8_t[this->mDataLength]);
-			memcpy(this->mData.get(), buffer->GetPointer() + this->bufferView->byteOffset, this->mDataLength);
-
-            if (Value* mtype = FindString(obj, "mimeType")) {
-                this->mimeType = mtype->GetString();
-            }
-        }
-    }
-}
-
-inline uint8_t* Image::StealData()
-{
-	mDataLength = 0;
-	return mData.release();
-}
-
-inline void Image::SetData(uint8_t* data, size_t length, Asset& r)
-{
-    Ref<Buffer> b = r.GetBodyBuffer();
-    if (b) { // binary file: append to body
-        std::string bvId = r.FindUniqueID(this->id, "imgdata");
-        bufferView = r.bufferViews.Create(bvId);
-
-        bufferView->buffer = b;
-        bufferView->byteLength = length;
-        bufferView->byteOffset = b->AppendData(data, length);
-    }
-    else { // text file: will be stored as a data uri
-		this->mData.reset(data);
-		this->mDataLength = length;
-    }
-}
-
-inline void Sampler::Read(Value& obj, Asset& /*r*/)
-{
-    SetDefaults();
-
-    ReadMember(obj, "name", name);
-    ReadMember(obj, "magFilter", magFilter);
-    ReadMember(obj, "minFilter", minFilter);
-    ReadMember(obj, "wrapS", wrapS);
-    ReadMember(obj, "wrapT", wrapT);
-}
-
-inline void Sampler::SetDefaults()
-{
-    //only wrapping modes have defaults
-    wrapS = SamplerWrap::Repeat;
-    wrapT = SamplerWrap::Repeat;
-    magFilter = SamplerMagFilter::UNSET;
-    minFilter = SamplerMinFilter::UNSET;
-}
-
-inline void Texture::Read(Value& obj, Asset& r)
-{
-    if (Value* sourceVal = FindUInt(obj, "source")) {
-        source = r.images.Retrieve(sourceVal->GetUint());
-    }
-
-    if (Value* samplerVal = FindUInt(obj, "sampler")) {
-        sampler = r.samplers.Retrieve(samplerVal->GetUint());
-    }
-}
-
-namespace {
-    inline void SetTextureProperties(Asset& r, Value* prop, TextureInfo& out)
-    {
-        if (Value* index = FindUInt(*prop, "index")) {
-            out.texture = r.textures.Retrieve(index->GetUint());
-        }
-
-        if (Value* texcoord = FindUInt(*prop, "texCoord")) {
-            out.texCoord = texcoord->GetUint();
-        }
-    }
-
-    inline void ReadTextureProperty(Asset& r, Value& vals, const char* propName, TextureInfo& out)
-    {
-        if (Value* prop = FindMember(vals, propName)) {
-            SetTextureProperties(r, prop, out);
-        }
-    }
-
-    inline void ReadTextureProperty(Asset& r, Value& vals, const char* propName, NormalTextureInfo& out)
-    {
-        if (Value* prop = FindMember(vals, propName)) {
-            SetTextureProperties(r, prop, out);
-
-            if (Value* scale = FindNumber(*prop, "scale")) {
-                out.scale = static_cast<float>(scale->GetDouble());
-            }
-        }
-    }
-
-    inline void ReadTextureProperty(Asset& r, Value& vals, const char* propName, OcclusionTextureInfo& out)
-    {
-        if (Value* prop = FindMember(vals, propName)) {
-            SetTextureProperties(r, prop, out);
-
-            if (Value* strength = FindNumber(*prop, "strength")) {
-                out.strength = static_cast<float>(strength->GetDouble());
-            }
-        }
-    }
-}
-
-inline void Material::Read(Value& material, Asset& r)
-{
-    SetDefaults();
-
-    if (Value* pbrMetallicRoughness = FindObject(material, "pbrMetallicRoughness")) {
-        ReadMember(*pbrMetallicRoughness, "baseColorFactor", this->pbrMetallicRoughness.baseColorFactor);
-        ReadTextureProperty(r, *pbrMetallicRoughness, "baseColorTexture", this->pbrMetallicRoughness.baseColorTexture);
-        ReadTextureProperty(r, *pbrMetallicRoughness, "metallicRoughnessTexture", this->pbrMetallicRoughness.metallicRoughnessTexture);
-        ReadMember(*pbrMetallicRoughness, "metallicFactor", this->pbrMetallicRoughness.metallicFactor);
-        ReadMember(*pbrMetallicRoughness, "roughnessFactor", this->pbrMetallicRoughness.roughnessFactor);
-    }
-
-    ReadTextureProperty(r, material, "normalTexture", this->normalTexture);
-    ReadTextureProperty(r, material, "occlusionTexture", this->occlusionTexture);
-    ReadTextureProperty(r, material, "emissiveTexture", this->emissiveTexture);
-    ReadMember(material, "emissiveFactor", this->emissiveFactor);
-
-    ReadMember(material, "doubleSided", this->doubleSided);
-    ReadMember(material, "alphaMode", this->alphaMode);
-    ReadMember(material, "alphaCutoff", this->alphaCutoff);
-
-    if (Value* extensions = FindObject(material, "extensions")) {
-        if (r.extensionsUsed.KHR_materials_pbrSpecularGlossiness) {
-            if (Value* pbrSpecularGlossiness = FindObject(*extensions, "KHR_materials_pbrSpecularGlossiness")) {
-                PbrSpecularGlossiness pbrSG;
-
-                ReadMember(*pbrSpecularGlossiness, "diffuseFactor", pbrSG.diffuseFactor);
-                ReadTextureProperty(r, *pbrSpecularGlossiness, "diffuseTexture", pbrSG.diffuseTexture);
-                ReadTextureProperty(r, *pbrSpecularGlossiness, "specularGlossinessTexture", pbrSG.specularGlossinessTexture);
-                ReadMember(*pbrSpecularGlossiness, "specularFactor", pbrSG.specularFactor);
-                ReadMember(*pbrSpecularGlossiness, "glossinessFactor", pbrSG.glossinessFactor);
-
-                this->pbrSpecularGlossiness = Nullable<PbrSpecularGlossiness>(pbrSG);
-            }
-        }
-
-        unlit = nullptr != FindObject(*extensions, "KHR_materials_unlit");
-    }
-}
-
-namespace {
-    void SetVector(vec4& v, const float(&in)[4])
-        { v[0] = in[0]; v[1] = in[1]; v[2] = in[2]; v[3] = in[3]; }
-
-    void SetVector(vec3& v, const float(&in)[3])
-        { v[0] = in[0]; v[1] = in[1]; v[2] = in[2]; }
-}
-
-inline void Material::SetDefaults()
-{
-    //pbr materials
-    SetVector(pbrMetallicRoughness.baseColorFactor, defaultBaseColor);
-    pbrMetallicRoughness.metallicFactor = 1.0;
-    pbrMetallicRoughness.roughnessFactor = 1.0;
-
-    SetVector(emissiveFactor, defaultEmissiveFactor);
-    alphaMode = "OPAQUE";
-    alphaCutoff = 0.5;
-    doubleSided = false;
-    unlit = false;
-}
-
-inline void PbrSpecularGlossiness::SetDefaults()
-{
-    //pbrSpecularGlossiness properties
-    SetVector(diffuseFactor, defaultDiffuseFactor);
-    SetVector(specularFactor, defaultSpecularFactor);
-    glossinessFactor = 1.0;
-}
-
-namespace {
-
-    template<int N>
-    inline int Compare(const char* attr, const char (&str)[N]) {
-        return (strncmp(attr, str, N - 1) == 0) ? N - 1 : 0;
-    }
-
-    inline bool GetAttribVector(Mesh::Primitive& p, const char* attr, Mesh::AccessorList*& v, int& pos)
-    {
-        if ((pos = Compare(attr, "POSITION"))) {
-            v = &(p.attributes.position);
-        }
-        else if ((pos = Compare(attr, "NORMAL"))) {
-            v = &(p.attributes.normal);
-        }
-        else if ((pos = Compare(attr, "TANGENT"))) {
-            v = &(p.attributes.tangent);
-        }
-        else if ((pos = Compare(attr, "TEXCOORD"))) {
-            v = &(p.attributes.texcoord);
-        }
-        else if ((pos = Compare(attr, "COLOR"))) {
-            v = &(p.attributes.color);
-        }
-        else if ((pos = Compare(attr, "JOINT"))) {
-            v = &(p.attributes.joint);
-        }
-        else if ((pos = Compare(attr, "JOINTMATRIX"))) {
-            v = &(p.attributes.jointmatrix);
-        }
-        else if ((pos = Compare(attr, "WEIGHT"))) {
-            v = &(p.attributes.weight);
-        }
-        else return false;
-        return true;
-    }
-
-    inline bool GetAttribTargetVector(Mesh::Primitive& p, const int targetIndex, const char* attr, Mesh::AccessorList*& v, int& pos)
-    {
-        if ((pos = Compare(attr, "POSITION"))) {
-            v = &(p.targets[targetIndex].position);
-        }
-        else if ((pos = Compare(attr, "NORMAL"))) {
-            v = &(p.targets[targetIndex].normal);
-        }
-        else if ((pos = Compare(attr, "TANGENT"))) {
-            v = &(p.targets[targetIndex].tangent);
-        }
-        else return false;
-        return true;
-    }
-}
-
-inline void Mesh::Read(Value& pJSON_Object, Asset& pAsset_Root)
-{
-    if (Value* name = FindMember(pJSON_Object, "name")) {
-        this->name = name->GetString();
-    }
-
-	/****************** Mesh primitives ******************/
-	if (Value* primitives = FindArray(pJSON_Object, "primitives")) {
-        this->primitives.resize(primitives->Size());
-        for (unsigned int i = 0; i < primitives->Size(); ++i) {
-            Value& primitive = (*primitives)[i];
-
-            Primitive& prim = this->primitives[i];
-            prim.mode = MemberOrDefault(primitive, "mode", PrimitiveMode_TRIANGLES);
-
-            if (Value* attrs = FindObject(primitive, "attributes")) {
-                for (Value::MemberIterator it = attrs->MemberBegin(); it != attrs->MemberEnd(); ++it) {
-                    if (!it->value.IsUint()) continue;
-                    const char* attr = it->name.GetString();
-                    // Valid attribute semantics include POSITION, NORMAL, TANGENT, TEXCOORD, COLOR, JOINT, JOINTMATRIX,
-                    // and WEIGHT.Attribute semantics can be of the form[semantic]_[set_index], e.g., TEXCOORD_0, TEXCOORD_1, etc.
-
-                    int undPos = 0;
-                    Mesh::AccessorList* vec = 0;
-                    if (GetAttribVector(prim, attr, vec, undPos)) {
-                        size_t idx = (attr[undPos] == '_') ? atoi(attr + undPos + 1) : 0;
-                        if ((*vec).size() <= idx) (*vec).resize(idx + 1);
-						(*vec)[idx] = pAsset_Root.accessors.Retrieve(it->value.GetUint());
-                    }
-                }
-            }
-
-            if (Value* targetsArray = FindArray(primitive, "targets")) {
-                prim.targets.resize(targetsArray->Size());
-                for (unsigned int i = 0; i < targetsArray->Size(); ++i) {
-                    Value& target = (*targetsArray)[i];
-                    if (!target.IsObject()) continue;
-                    for (Value::MemberIterator it = target.MemberBegin(); it != target.MemberEnd(); ++it) {
-                        if (!it->value.IsUint()) continue;
-                        const char* attr = it->name.GetString();
-                        // Valid attribute semantics include POSITION, NORMAL, TANGENT
-                        int undPos = 0;
-                        Mesh::AccessorList* vec = 0;
-                        if (GetAttribTargetVector(prim, i, attr, vec, undPos)) {
-                            size_t idx = (attr[undPos] == '_') ? atoi(attr + undPos + 1) : 0;
-                            if ((*vec).size() <= idx) (*vec).resize(idx + 1);
-                            (*vec)[idx] = pAsset_Root.accessors.Retrieve(it->value.GetUint());
-                        }
-                    }
-                }
-            }
-
-            if (Value* indices = FindUInt(primitive, "indices")) {
-				prim.indices = pAsset_Root.accessors.Retrieve(indices->GetUint());
-            }
-
-            if (Value* material = FindUInt(primitive, "material")) {
-				prim.material = pAsset_Root.materials.Retrieve(material->GetUint());
-            }
-        }
-    }
-
-    if (Value* weights = FindArray(pJSON_Object, "weights")) {
-        this->weights.resize(weights->Size());
-        for (unsigned int i = 0; i < weights->Size(); ++i) {
-          Value& weightValue = (*weights)[i];
-          if (weightValue.IsNumber()) {
-            this->weights[i] = weightValue.GetFloat();
-          }
-        }
-    }
-}
-
-inline void Camera::Read(Value& obj, Asset& /*r*/)
-{
-    std::string type_string = std::string(MemberOrDefault(obj, "type", "perspective"));
-    if (type_string == "orthographic") {
-        type = Camera::Orthographic;
-    } else {
-        type = Camera::Perspective;
-    }
-
-    const char* subobjId = (type == Camera::Orthographic) ? "orthographic" : "perspective";
-
-    Value* it = FindObject(obj, subobjId);
-    if (!it) throw DeadlyImportError("GLTF: Camera missing its parameters");
-
-    if (type == Camera::Perspective) {
-        cameraProperties.perspective.aspectRatio = MemberOrDefault(*it, "aspectRatio", 0.f);
-        cameraProperties.perspective.yfov        = MemberOrDefault(*it, "yfov", 3.1415f/2.f);
-        cameraProperties.perspective.zfar        = MemberOrDefault(*it, "zfar", 100.f);
-        cameraProperties.perspective.znear       = MemberOrDefault(*it, "znear", 0.01f);
-    }
-    else {
-        cameraProperties.ortographic.xmag  = MemberOrDefault(obj, "xmag", 1.f);
-        cameraProperties.ortographic.ymag  = MemberOrDefault(obj, "ymag", 1.f);
-        cameraProperties.ortographic.zfar  = MemberOrDefault(obj, "zfar", 100.f);
-        cameraProperties.ortographic.znear = MemberOrDefault(obj, "znear", 0.01f);
-    }
-}
-
-inline void Light::Read(Value& obj, Asset& /*r*/)
-{
-#ifndef M_PI
-    const float M_PI = 3.14159265358979323846f;
-#endif
-
-    std::string type_string;
-    ReadMember(obj, "type", type_string);
-    if (type_string == "directional")
-        type = Light::Directional;
-    else if (type_string == "point")
-        type = Light::Point;
-    else
-        type = Light::Spot;
-
-    name = MemberOrDefault(obj, "name", "");
-
-    SetVector(color, vec3{ 1.0f, 1.0f, 1.0f });
-    ReadMember(obj, "color", color);
-
-    intensity = MemberOrDefault(obj, "intensity", 1.0f);
-
-    ReadMember(obj, "range", range);
-
-    if (type == Light::Spot)
-    {
-        Value* spot = FindObject(obj, "spot");
-        if (!spot) throw DeadlyImportError("GLTF: Light missing its spot parameters");
-        innerConeAngle = MemberOrDefault(*spot, "innerConeAngle", 0.0f);
-        outerConeAngle = MemberOrDefault(*spot, "outerConeAngle", M_PI / 4.0f);
-    }
-}
-
-inline 
-void Node::Read(Value& obj, Asset& r) {
-    if (name.empty()) {
-        name = id;
-    }
-
-    if (Value* children = FindArray(obj, "children")) {
-        this->children.reserve(children->Size());
-        for (unsigned int i = 0; i < children->Size(); ++i) {
-            Value& child = (*children)[i];
-            if (child.IsUint()) {
-                // get/create the child node
-                Ref<Node> chn = r.nodes.Retrieve(child.GetUint());
-                if (chn) this->children.push_back(chn);
-            }
-        }
-    }
-
-    if (Value* matrix = FindArray(obj, "matrix")) {
-        ReadValue(*matrix, this->matrix);
-    }
-    else {
-        ReadMember(obj, "translation", translation);
-        ReadMember(obj, "scale", scale);
-        ReadMember(obj, "rotation", rotation);
-    }
-
-    if (Value* mesh = FindUInt(obj, "mesh")) {
-        unsigned numMeshes = 1;
-
-        this->meshes.reserve(numMeshes);
-
-        Ref<Mesh> meshRef = r.meshes.Retrieve((*mesh).GetUint());
-
-        if (meshRef) this->meshes.push_back(meshRef);
-    }
-
-    if (Value* skin = FindUInt(obj, "skin")) {
-        this->skin = r.skins.Retrieve(skin->GetUint());
-    }
-
-    if (Value* camera = FindUInt(obj, "camera")) {
-        this->camera = r.cameras.Retrieve(camera->GetUint());
-        if (this->camera)
-            this->camera->id = this->id;
-    }
-
-    if (Value* extensions = FindObject(obj, "extensions")) {
-        if (r.extensionsUsed.KHR_lights_punctual) {
-
-            if (Value* ext = FindObject(*extensions, "KHR_lights_punctual")) {
-                if (Value* light = FindUInt(*ext, "light")) {
-                    this->light = r.lights.Retrieve(light->GetUint());
-                    if (this->light)
-                        this->light->id = this->id;
-                }
-            }
-        }
-    }
-}
-
-inline void Scene::Read(Value& obj, Asset& r)
-{
-    if (Value* array = FindArray(obj, "nodes")) {
-        for (unsigned int i = 0; i < array->Size(); ++i) {
-            if (!(*array)[i].IsUint()) continue;
-            Ref<Node> node = r.nodes.Retrieve((*array)[i].GetUint());
-            if (node)
-                this->nodes.push_back(node);
-        }
-    }
-}
-
-inline void Skin::Read(Value& obj, Asset& r)
-{
-    if (Value* matrices = FindUInt(obj, "inverseBindMatrices")) {
-        inverseBindMatrices = r.accessors.Retrieve(matrices->GetUint());
-    }
-
-    if (Value* joints = FindArray(obj, "joints")) {
-        for (unsigned i = 0; i < joints->Size(); ++i) {
-            if (!(*joints)[i].IsUint()) continue;
-            Ref<Node> node = r.nodes.Retrieve((*joints)[i].GetUint());
-            if (node) {
-                this->jointNames.push_back(node);
-            }
-        }
-    }
-}
-
-inline void Animation::Read(Value& obj, Asset& r)
-{
-    if (Value* samplers = FindArray(obj, "samplers")) {
-        for (unsigned i = 0; i < samplers->Size(); ++i) {
-            Value& sampler = (*samplers)[i];
-
-            Sampler s;
-            if (Value* input = FindUInt(sampler, "input")) {
-                s.input = r.accessors.Retrieve(input->GetUint());
-            }
-            if (Value* output = FindUInt(sampler, "output")) {
-                s.output = r.accessors.Retrieve(output->GetUint());
-            }
-            s.interpolation = Interpolation_LINEAR;
-            if (Value* interpolation = FindString(sampler, "interpolation")) {
-                const std::string interp = interpolation->GetString();
-                if (interp == "LINEAR") {
-                  s.interpolation = Interpolation_LINEAR;
-                } else if (interp == "STEP") {
-                  s.interpolation = Interpolation_STEP;
-                } else if (interp == "CUBICSPLINE") {
-                  s.interpolation = Interpolation_CUBICSPLINE;
-                }
-            }
-            this->samplers.push_back(s);
-        }
-    }
-
-    if (Value* channels = FindArray(obj, "channels")) {
-        for (unsigned i = 0; i < channels->Size(); ++i) {
-            Value& channel = (*channels)[i];
-
-            Channel c;
-            if (Value* sampler = FindUInt(channel, "sampler")) {
-                c.sampler = sampler->GetUint();
-            }
-
-            if (Value* target = FindObject(channel, "target")) {
-                if (Value* node = FindUInt(*target, "node")) {
-                    c.target.node = r.nodes.Retrieve(node->GetUint());
-                }
-                if (Value* path = FindString(*target, "path")) {
-                    const std::string p = path->GetString();
-                    if (p == "translation") {
-                        c.target.path = AnimationPath_TRANSLATION;
-                    } else if (p == "rotation") {
-                        c.target.path = AnimationPath_ROTATION;
-                    } else if (p == "scale") {
-                        c.target.path = AnimationPath_SCALE;
-                    } else if (p == "weights") {
-                        c.target.path = AnimationPath_WEIGHTS;
-                    }
-                }
-            }
-            this->channels.push_back(c);
-        }
-    }
-}
-
-inline void AssetMetadata::Read(Document& doc)
-{
-    if (Value* obj = FindObject(doc, "asset")) {
-        ReadMember(*obj, "copyright", copyright);
-        ReadMember(*obj, "generator", generator);
-
-        if (Value* versionString = FindString(*obj, "version")) {
-            version = versionString->GetString();
-        } else if (Value* versionNumber = FindNumber (*obj, "version")) {
-            char buf[4];
-
-            ai_snprintf(buf, 4, "%.1f", versionNumber->GetDouble());
-
-            version = buf;
-        }
-
-        if (Value* profile = FindObject(*obj, "profile")) {
-            ReadMember(*profile, "api",     this->profile.api);
-            ReadMember(*profile, "version", this->profile.version);
-        }
-    }
-
-    if (version.empty() || version[0] != '2') {
-        throw DeadlyImportError("GLTF: Unsupported glTF version: " + version);
-    }
-}
-
-//
-// Asset methods implementation
-//
-
-inline void Asset::ReadBinaryHeader(IOStream& stream, std::vector<char>& sceneData)
-{
-    GLB_Header header;
-    if (stream.Read(&header, sizeof(header), 1) != 1) {
-        throw DeadlyImportError("GLTF: Unable to read the file header");
-    }
-
-    if (strncmp((char*)header.magic, AI_GLB_MAGIC_NUMBER, sizeof(header.magic)) != 0) {
-        throw DeadlyImportError("GLTF: Invalid binary glTF file");
-    }
-
-    AI_SWAP4(header.version);
-    asset.version = to_string(header.version);
-    if (header.version != 2) {
-        throw DeadlyImportError("GLTF: Unsupported binary glTF version");
-    }
-
-    GLB_Chunk chunk;
-    if (stream.Read(&chunk, sizeof(chunk), 1) != 1) {
-        throw DeadlyImportError("GLTF: Unable to read JSON chunk");
-    }
-
-    AI_SWAP4(chunk.chunkLength);
-    AI_SWAP4(chunk.chunkType);
-
-    if (chunk.chunkType != ChunkType_JSON) {
-        throw DeadlyImportError("GLTF: JSON chunk missing");
-    }
-
-    // read the scene data
-
-    mSceneLength = chunk.chunkLength;
-    sceneData.resize(mSceneLength + 1);
-    sceneData[mSceneLength] = '\0';
-
-    if (stream.Read(&sceneData[0], 1, mSceneLength) != mSceneLength) {
-        throw DeadlyImportError("GLTF: Could not read the file contents");
-    }
-
-    uint32_t padding = ((chunk.chunkLength + 3) & ~3) - chunk.chunkLength;
-    if (padding > 0) {
-        stream.Seek(padding, aiOrigin_CUR);
-    }
-
-    AI_SWAP4(header.length);
-    mBodyOffset = 12 + 8 + chunk.chunkLength + padding + 8;
-    if (header.length >= mBodyOffset) {
-        if (stream.Read(&chunk, sizeof(chunk), 1) != 1) {
-            throw DeadlyImportError("GLTF: Unable to read BIN chunk");
-        }
-
-        AI_SWAP4(chunk.chunkLength);
-        AI_SWAP4(chunk.chunkType);
-
-        if (chunk.chunkType != ChunkType_BIN) {
-            throw DeadlyImportError("GLTF: BIN chunk missing");
-        }
-
-        mBodyLength = chunk.chunkLength;
-    }
-    else {
-        mBodyOffset = mBodyLength = 0;
-    }
-}
-
-inline void Asset::Load(const std::string& pFile, bool isBinary)
-{
-    mCurrentAssetDir.clear();
-    int pos = std::max(int(pFile.rfind('/')), int(pFile.rfind('\\')));
-    if (pos != int(std::string::npos)) mCurrentAssetDir = pFile.substr(0, pos + 1);
-
-    shared_ptr<IOStream> stream(OpenFile(pFile.c_str(), "rb", true));
-    if (!stream) {
-        throw DeadlyImportError("GLTF: Could not open file for reading");
-    }
-
-    // is binary? then read the header
-    std::vector<char> sceneData;
-    if (isBinary) {
-        SetAsBinary(); // also creates the body buffer
-        ReadBinaryHeader(*stream, sceneData);
-    }
-    else {
-        mSceneLength = stream->FileSize();
-        mBodyLength = 0;
-
-
-        // read the scene data
-
-        sceneData.resize(mSceneLength + 1);
-        sceneData[mSceneLength] = '\0';
-
-        if (stream->Read(&sceneData[0], 1, mSceneLength) != mSceneLength) {
-            throw DeadlyImportError("GLTF: Could not read the file contents");
-        }
-    }
-
-
-    // parse the JSON document
-
-    Document doc;
-    doc.ParseInsitu(&sceneData[0]);
-
-    if (doc.HasParseError()) {
-        char buffer[32];
-        ai_snprintf(buffer, 32, "%d", static_cast<int>(doc.GetErrorOffset()));
-        throw DeadlyImportError(std::string("GLTF: JSON parse error, offset ") + buffer + ": "
-            + GetParseError_En(doc.GetParseError()));
-    }
-
-    if (!doc.IsObject()) {
-        throw DeadlyImportError("GLTF: JSON document root must be a JSON object");
-    }
-
-    // Fill the buffer instance for the current file embedded contents
-    if (mBodyLength > 0) {
-        if (!mBodyBuffer->LoadFromStream(*stream, mBodyLength, mBodyOffset)) {
-            throw DeadlyImportError("GLTF: Unable to read gltf file");
-        }
-    }
-
-
-    // Load the metadata
-    asset.Read(doc);
-    ReadExtensionsUsed(doc);
-
-    // Prepare the dictionaries
-    for (size_t i = 0; i < mDicts.size(); ++i) {
-        mDicts[i]->AttachToDocument(doc);
-    }
-
-    // Read the "scene" property, which specifies which scene to load
-    // and recursively load everything referenced by it
-    unsigned int sceneIndex = 0;
-    if (Value* scene = FindUInt(doc, "scene")) {
-        sceneIndex = scene->GetUint();
-    }
-
-    if (Value* scenesArray = FindArray(doc, "scenes")) {
-        if (sceneIndex < scenesArray->Size()) {
-            this->scene = scenes.Retrieve(sceneIndex);
-        }
-    }
-
-    // Force reading of skins since they're not always directly referenced
-    if (Value* skinsArray = FindArray(doc, "skins")) {
-        for (unsigned int i = 0; i < skinsArray->Size(); ++i) {
-            skins.Retrieve(i);
-        }
-    }
-
-    if (Value* animsArray = FindArray(doc, "animations")) {
-        for (unsigned int i = 0; i < animsArray->Size(); ++i) {
-            animations.Retrieve(i);
-        }
-    }
-
-    // Clean up
-    for (size_t i = 0; i < mDicts.size(); ++i) {
-        mDicts[i]->DetachFromDocument();
-    }
-}
-
-inline void Asset::SetAsBinary()
-{
-    if (!mBodyBuffer) {
-        mBodyBuffer = buffers.Create("binary_glTF");
-        mBodyBuffer->MarkAsSpecial();
-    }
-}
-
-
-inline void Asset::ReadExtensionsUsed(Document& doc)
-{
-    Value* extsUsed = FindArray(doc, "extensionsUsed");
-    if (!extsUsed) return;
-
-    std::gltf_unordered_map<std::string, bool> exts;
-
-    for (unsigned int i = 0; i < extsUsed->Size(); ++i) {
-        if ((*extsUsed)[i].IsString()) {
-            exts[(*extsUsed)[i].GetString()] = true;
-        }
-    }
-
-    #define CHECK_EXT(EXT) \
-        if (exts.find(#EXT) != exts.end()) extensionsUsed.EXT = true;
-
-    CHECK_EXT(KHR_materials_pbrSpecularGlossiness);
-    CHECK_EXT(KHR_materials_unlit);
-    CHECK_EXT(KHR_lights_punctual);
-
-    #undef CHECK_EXT
-}
-
-inline IOStream* Asset::OpenFile(std::string path, const char* mode, bool /*absolute*/)
-{
-    #ifdef ASSIMP_API
-        return mIOSystem->Open(path, mode);
-    #else
-        if (path.size() < 2) return 0;
-        if (!absolute && path[1] != ':' && path[0] != '/') { // relative?
-            path = mCurrentAssetDir + path;
-        }
-        FILE* f = fopen(path.c_str(), mode);
-        return f ? new IOStream(f) : 0;
-    #endif
-}
-
-inline std::string Asset::FindUniqueID(const std::string& str, const char* suffix)
-{
-    std::string id = str;
-
-    if (!id.empty()) {
-        if (mUsedIds.find(id) == mUsedIds.end())
-            return id;
-
-        id += "_";
-    }
-
-    id += suffix;
-
-    Asset::IdMap::iterator it = mUsedIds.find(id);
-    if (it == mUsedIds.end())
-        return id;
-
-    std::vector<char> buffer;
-    buffer.resize(id.size() + 16);
-    int offset = ai_snprintf(buffer.data(), buffer.size(), "%s_", id.c_str());
-    for (int i = 0; it != mUsedIds.end(); ++i) {
-        ai_snprintf(buffer.data() + offset, buffer.size() - offset, "%d", i);
-        id = buffer.data();
-        it = mUsedIds.find(id);
-    }
-
-    return id;
-}
-
-} // ns glTF
diff --git a/Engine/lib/assimp/code/glTF2/glTF2Exporter.cpp b/Engine/lib/assimp/code/glTF2/glTF2Exporter.cpp
deleted file mode 100644
index 4724c2ef4..000000000
--- a/Engine/lib/assimp/code/glTF2/glTF2Exporter.cpp
+++ /dev/null
@@ -1,1100 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-#ifndef ASSIMP_BUILD_NO_EXPORT
-#ifndef ASSIMP_BUILD_NO_GLTF_EXPORTER
-
-#include "glTF2/glTF2Exporter.h"
-#include "glTF2/glTF2AssetWriter.h"
-#include "PostProcessing/SplitLargeMeshes.h"
-
-#include <assimp/Exceptional.h>
-#include <assimp/StringComparison.h>
-#include <assimp/ByteSwapper.h>
-#include <assimp/SceneCombiner.h>
-#include <assimp/version.h>
-#include <assimp/IOSystem.hpp>
-#include <assimp/Exporter.hpp>
-#include <assimp/material.h>
-#include <assimp/scene.h>
-
-// Header files, standard library.
-#include <memory>
-#include <inttypes.h>
-
-using namespace rapidjson;
-
-using namespace Assimp;
-using namespace glTF2;
-
-namespace Assimp {
-
-    // ------------------------------------------------------------------------------------------------
-    // Worker function for exporting a scene to GLTF. Prototyped and registered in Exporter.cpp
-    void ExportSceneGLTF2(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* pProperties)
-    {
-        // invoke the exporter
-        glTF2Exporter exporter(pFile, pIOSystem, pScene, pProperties, false);
-    }
-
-    // ------------------------------------------------------------------------------------------------
-    // Worker function for exporting a scene to GLB. Prototyped and registered in Exporter.cpp
-    void ExportSceneGLB2(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* pProperties)
-    {
-        // invoke the exporter
-        glTF2Exporter exporter(pFile, pIOSystem, pScene, pProperties, true);
-    }
-
-} // end of namespace Assimp
-
-glTF2Exporter::glTF2Exporter(const char* filename, IOSystem* pIOSystem, const aiScene* pScene,
-                           const ExportProperties* pProperties, bool isBinary)
-    : mFilename(filename)
-    , mIOSystem(pIOSystem)
-    , mProperties(pProperties)
-{
-    mScene = pScene;
-
-    mAsset.reset( new Asset( pIOSystem ) );
-
-    if (isBinary) {
-        mAsset->SetAsBinary();
-    }
-
-    ExportMetadata();
-
-    ExportMaterials();
-
-    if (mScene->mRootNode) {
-        ExportNodeHierarchy(mScene->mRootNode);
-    }
-
-    ExportMeshes();
-    MergeMeshes();
-
-    ExportScene();
-
-    ExportAnimations();
-
-    AssetWriter writer(*mAsset);
-
-    if (isBinary) {
-        writer.WriteGLBFile(filename);
-    } else {
-        writer.WriteFile(filename);
-    }
-}
-
-glTF2Exporter::~glTF2Exporter() {
-    // empty
-}
-
-/*
- * Copy a 4x4 matrix from struct aiMatrix to typedef mat4.
- * Also converts from row-major to column-major storage.
- */
-static void CopyValue(const aiMatrix4x4& v, mat4& o) {
-    o[ 0] = v.a1; o[ 1] = v.b1; o[ 2] = v.c1; o[ 3] = v.d1;
-    o[ 4] = v.a2; o[ 5] = v.b2; o[ 6] = v.c2; o[ 7] = v.d2;
-    o[ 8] = v.a3; o[ 9] = v.b3; o[10] = v.c3; o[11] = v.d3;
-    o[12] = v.a4; o[13] = v.b4; o[14] = v.c4; o[15] = v.d4;
-}
-
-static void CopyValue(const aiMatrix4x4& v, aiMatrix4x4& o) {
-    o.a1 = v.a1; o.a2 = v.a2; o.a3 = v.a3; o.a4 = v.a4;
-    o.b1 = v.b1; o.b2 = v.b2; o.b3 = v.b3; o.b4 = v.b4;
-    o.c1 = v.c1; o.c2 = v.c2; o.c3 = v.c3; o.c4 = v.c4;
-    o.d1 = v.d1; o.d2 = v.d2; o.d3 = v.d3; o.d4 = v.d4;
-}
-
-static void IdentityMatrix4(mat4& o) {
-    o[ 0] = 1; o[ 1] = 0; o[ 2] = 0; o[ 3] = 0;
-    o[ 4] = 0; o[ 5] = 1; o[ 6] = 0; o[ 7] = 0;
-    o[ 8] = 0; o[ 9] = 0; o[10] = 1; o[11] = 0;
-    o[12] = 0; o[13] = 0; o[14] = 0; o[15] = 1;
-}
-
-inline Ref<Accessor> ExportData(Asset& a, std::string& meshName, Ref<Buffer>& buffer,
-    size_t count, void* data, AttribType::Value typeIn, AttribType::Value typeOut, ComponentType compType, bool isIndices = false)
-{
-    if (!count || !data) {
-        return Ref<Accessor>();
-    }
-
-    unsigned int numCompsIn = AttribType::GetNumComponents(typeIn);
-    unsigned int numCompsOut = AttribType::GetNumComponents(typeOut);
-    unsigned int bytesPerComp = ComponentTypeSize(compType);
-
-    size_t offset = buffer->byteLength;
-    // make sure offset is correctly byte-aligned, as required by spec
-    size_t padding = offset % bytesPerComp;
-    offset += padding;
-    size_t length = count * numCompsOut * bytesPerComp;
-    buffer->Grow(length + padding);
-
-    // bufferView
-    Ref<BufferView> bv = a.bufferViews.Create(a.FindUniqueID(meshName, "view"));
-    bv->buffer = buffer;
-    bv->byteOffset = offset;
-    bv->byteLength = length; //! The target that the WebGL buffer should be bound to.
-    bv->byteStride = 0;
-    bv->target = isIndices ? BufferViewTarget_ELEMENT_ARRAY_BUFFER : BufferViewTarget_ARRAY_BUFFER;
-
-    // accessor
-    Ref<Accessor> acc = a.accessors.Create(a.FindUniqueID(meshName, "accessor"));
-    acc->bufferView = bv;
-    acc->byteOffset = 0;
-    acc->componentType = compType;
-    acc->count = count;
-    acc->type = typeOut;
-
-    // calculate min and max values
-    {
-        // Allocate and initialize with large values.
-        float float_MAX = 10000000000000.0f;
-        for (unsigned int i = 0 ; i < numCompsOut ; i++) {
-            acc->min.push_back( float_MAX);
-            acc->max.push_back(-float_MAX);
-        }
-
-        // Search and set extreme values.
-        float valueTmp;
-        for (unsigned int i = 0 ; i < count       ; i++) {
-            for (unsigned int j = 0 ; j < numCompsOut ; j++) {
-                if (numCompsOut == 1) {
-                  valueTmp = static_cast<unsigned short*>(data)[i];
-                } else {
-                  valueTmp = static_cast<aiVector3D*>(data)[i][j];
-                }
-
-                if (valueTmp < acc->min[j]) {
-                    acc->min[j] = valueTmp;
-                }
-                if (valueTmp > acc->max[j]) {
-                    acc->max[j] = valueTmp;
-                }
-            }
-        }
-    }
-
-    // copy the data
-    acc->WriteData(count, data, numCompsIn*bytesPerComp);
-
-    return acc;
-}
-
-inline void SetSamplerWrap(SamplerWrap& wrap, aiTextureMapMode map)
-{
-    switch (map) {
-        case aiTextureMapMode_Clamp:
-            wrap = SamplerWrap::Clamp_To_Edge;
-            break;
-        case aiTextureMapMode_Mirror:
-            wrap = SamplerWrap::Mirrored_Repeat;
-            break;
-        case aiTextureMapMode_Wrap:
-        case aiTextureMapMode_Decal:
-        default:
-            wrap = SamplerWrap::Repeat;
-            break;
-    };
-}
-
-void glTF2Exporter::GetTexSampler(const aiMaterial* mat, Ref<Texture> texture, aiTextureType tt, unsigned int slot)
-{
-    aiString aId;
-    std::string id;
-    if (aiGetMaterialString(mat, AI_MATKEY_GLTF_MAPPINGID(tt, slot), &aId) == AI_SUCCESS) {
-        id = aId.C_Str();
-    }
-
-    if (Ref<Sampler> ref = mAsset->samplers.Get(id.c_str())) {
-        texture->sampler = ref;
-    } else {
-        id = mAsset->FindUniqueID(id, "sampler");
-
-        texture->sampler = mAsset->samplers.Create(id.c_str());
-
-        aiTextureMapMode mapU, mapV;
-        SamplerMagFilter filterMag;
-        SamplerMinFilter filterMin;
-
-        if (aiGetMaterialInteger(mat, AI_MATKEY_MAPPINGMODE_U(tt, slot), (int*)&mapU) == AI_SUCCESS) {
-            SetSamplerWrap(texture->sampler->wrapS, mapU);
-        }
-
-        if (aiGetMaterialInteger(mat, AI_MATKEY_MAPPINGMODE_V(tt, slot), (int*)&mapV) == AI_SUCCESS) {
-            SetSamplerWrap(texture->sampler->wrapT, mapV);
-        }
-
-        if (aiGetMaterialInteger(mat, AI_MATKEY_GLTF_MAPPINGFILTER_MAG(tt, slot), (int*)&filterMag) == AI_SUCCESS) {
-            texture->sampler->magFilter = filterMag;
-        }
-
-        if (aiGetMaterialInteger(mat, AI_MATKEY_GLTF_MAPPINGFILTER_MIN(tt, slot), (int*)&filterMin) == AI_SUCCESS) {
-            texture->sampler->minFilter = filterMin;
-        }
-
-        aiString name;
-        if (aiGetMaterialString(mat, AI_MATKEY_GLTF_MAPPINGNAME(tt, slot), &name) == AI_SUCCESS) {
-            texture->sampler->name = name.C_Str();
-        }
-    }
-}
-
-void glTF2Exporter::GetMatTexProp(const aiMaterial* mat, unsigned int& prop, const char* propName, aiTextureType tt, unsigned int slot)
-{
-    std::string textureKey = std::string(_AI_MATKEY_TEXTURE_BASE) + "." + propName;
-
-    mat->Get(textureKey.c_str(), tt, slot, prop);
-}
-
-void glTF2Exporter::GetMatTexProp(const aiMaterial* mat, float& prop, const char* propName, aiTextureType tt, unsigned int slot)
-{
-    std::string textureKey = std::string(_AI_MATKEY_TEXTURE_BASE) + "." + propName;
-
-    mat->Get(textureKey.c_str(), tt, slot, prop);
-}
-
-void glTF2Exporter::GetMatTex(const aiMaterial* mat, Ref<Texture>& texture, aiTextureType tt, unsigned int slot = 0)
-{
-
-    if (mat->GetTextureCount(tt) > 0) {
-        aiString tex;
-
-        if (mat->Get(AI_MATKEY_TEXTURE(tt, slot), tex) == AI_SUCCESS) {
-            std::string path = tex.C_Str();
-
-            if (path.size() > 0) {
-                std::map<std::string, unsigned int>::iterator it = mTexturesByPath.find(path);
-                if (it != mTexturesByPath.end()) {
-                    texture = mAsset->textures.Get(it->second);
-                }
-
-                if (!texture) {
-                    std::string texId = mAsset->FindUniqueID("", "texture");
-                    texture = mAsset->textures.Create(texId);
-                    mTexturesByPath[path] = texture.GetIndex();
-
-                    std::string imgId = mAsset->FindUniqueID("", "image");
-                    texture->source = mAsset->images.Create(imgId);
-
-                    if (path[0] == '*') { // embedded
-                        aiTexture* tex = mScene->mTextures[atoi(&path[1])];
-
-                        uint8_t* data = reinterpret_cast<uint8_t*>(tex->pcData);
-                        texture->source->SetData(data, tex->mWidth, *mAsset);
-
-                        if (tex->achFormatHint[0]) {
-                            std::string mimeType = "image/";
-                            mimeType += (memcmp(tex->achFormatHint, "jpg", 3) == 0) ? "jpeg" : tex->achFormatHint;
-                            texture->source->mimeType = mimeType;
-                        }
-                    }
-                    else {
-                        texture->source->uri = path;
-                    }
-
-                    GetTexSampler(mat, texture, tt, slot);
-                }
-            }
-        }
-    }
-}
-
-void glTF2Exporter::GetMatTex(const aiMaterial* mat, TextureInfo& prop, aiTextureType tt, unsigned int slot = 0)
-{
-    Ref<Texture>& texture = prop.texture;
-
-    GetMatTex(mat, texture, tt, slot);
-
-    if (texture) {
-        GetMatTexProp(mat, prop.texCoord, "texCoord", tt, slot);
-    }
-}
-
-void glTF2Exporter::GetMatTex(const aiMaterial* mat, NormalTextureInfo& prop, aiTextureType tt, unsigned int slot = 0)
-{
-    Ref<Texture>& texture = prop.texture;
-
-    GetMatTex(mat, texture, tt, slot);
-
-    if (texture) {
-        GetMatTexProp(mat, prop.texCoord, "texCoord", tt, slot);
-        GetMatTexProp(mat, prop.scale, "scale", tt, slot);
-    }
-}
-
-void glTF2Exporter::GetMatTex(const aiMaterial* mat, OcclusionTextureInfo& prop, aiTextureType tt, unsigned int slot = 0)
-{
-    Ref<Texture>& texture = prop.texture;
-
-    GetMatTex(mat, texture, tt, slot);
-
-    if (texture) {
-        GetMatTexProp(mat, prop.texCoord, "texCoord", tt, slot);
-        GetMatTexProp(mat, prop.strength, "strength", tt, slot);
-    }
-}
-
-aiReturn glTF2Exporter::GetMatColor(const aiMaterial* mat, vec4& prop, const char* propName, int type, int idx)
-{
-    aiColor4D col;
-    aiReturn result = mat->Get(propName, type, idx, col);
-
-    if (result == AI_SUCCESS) {
-        prop[0] = col.r; prop[1] = col.g; prop[2] = col.b; prop[3] = col.a;
-    }
-
-    return result;
-}
-
-aiReturn glTF2Exporter::GetMatColor(const aiMaterial* mat, vec3& prop, const char* propName, int type, int idx)
-{
-    aiColor3D col;
-    aiReturn result = mat->Get(propName, type, idx, col);
-
-    if (result == AI_SUCCESS) {
-        prop[0] = col.r; prop[1] = col.g; prop[2] = col.b;
-    }
-
-    return result;
-}
-
-void glTF2Exporter::ExportMaterials()
-{
-    aiString aiName;
-    for (unsigned int i = 0; i < mScene->mNumMaterials; ++i) {
-        const aiMaterial* mat = mScene->mMaterials[i];
-
-        std::string id = "material_" + to_string(i);
-
-        Ref<Material> m = mAsset->materials.Create(id);
-
-        std::string name;
-        if (mat->Get(AI_MATKEY_NAME, aiName) == AI_SUCCESS) {
-            name = aiName.C_Str();
-        }
-        name = mAsset->FindUniqueID(name, "material");
-
-        m->name = name;
-
-        GetMatTex(mat, m->pbrMetallicRoughness.baseColorTexture, AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_BASE_COLOR_TEXTURE);
-
-        if (!m->pbrMetallicRoughness.baseColorTexture.texture) {
-            //if there wasn't a baseColorTexture defined in the source, fallback to any diffuse texture
-            GetMatTex(mat, m->pbrMetallicRoughness.baseColorTexture, aiTextureType_DIFFUSE);
-        }
-
-        GetMatTex(mat, m->pbrMetallicRoughness.metallicRoughnessTexture, AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_METALLICROUGHNESS_TEXTURE);
-
-        if (GetMatColor(mat, m->pbrMetallicRoughness.baseColorFactor, AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_BASE_COLOR_FACTOR) != AI_SUCCESS) {
-            // if baseColorFactor wasn't defined, then the source is likely not a metallic roughness material.
-            //a fallback to any diffuse color should be used instead
-            GetMatColor(mat, m->pbrMetallicRoughness.baseColorFactor, AI_MATKEY_COLOR_DIFFUSE);
-        }
-
-        if (mat->Get(AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_METALLIC_FACTOR, m->pbrMetallicRoughness.metallicFactor) != AI_SUCCESS) {
-            //if metallicFactor wasn't defined, then the source is likely not a PBR file, and the metallicFactor should be 0
-            m->pbrMetallicRoughness.metallicFactor = 0;
-        }
-
-        // get roughness if source is gltf2 file
-        if (mat->Get(AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_ROUGHNESS_FACTOR, m->pbrMetallicRoughness.roughnessFactor) != AI_SUCCESS) {
-            // otherwise, try to derive and convert from specular + shininess values
-            aiColor4D specularColor;
-            ai_real shininess;
-
-            if (
-                mat->Get(AI_MATKEY_COLOR_SPECULAR, specularColor) == AI_SUCCESS &&
-                mat->Get(AI_MATKEY_SHININESS, shininess) == AI_SUCCESS
-            ) {
-                // convert specular color to luminance
-                float specularIntensity = specularColor[0] * 0.2125f + specularColor[1] * 0.7154f + specularColor[2] * 0.0721f;
-                //normalize shininess (assuming max is 1000) with an inverse exponentional curve
-                float normalizedShininess = std::sqrt(shininess / 1000);
-
-                //clamp the shininess value between 0 and 1
-                normalizedShininess = std::min(std::max(normalizedShininess, 0.0f), 1.0f);
-                // low specular intensity values should produce a rough material even if shininess is high.
-                normalizedShininess = normalizedShininess * specularIntensity;
-
-                m->pbrMetallicRoughness.roughnessFactor = 1 - normalizedShininess;
-            }
-        }
-
-        GetMatTex(mat, m->normalTexture, aiTextureType_NORMALS);
-        GetMatTex(mat, m->occlusionTexture, aiTextureType_LIGHTMAP);
-        GetMatTex(mat, m->emissiveTexture, aiTextureType_EMISSIVE);
-        GetMatColor(mat, m->emissiveFactor, AI_MATKEY_COLOR_EMISSIVE);
-
-        mat->Get(AI_MATKEY_TWOSIDED, m->doubleSided);
-        mat->Get(AI_MATKEY_GLTF_ALPHACUTOFF, m->alphaCutoff);
-
-        aiString alphaMode;
-
-        if (mat->Get(AI_MATKEY_GLTF_ALPHAMODE, alphaMode) == AI_SUCCESS) {
-            m->alphaMode = alphaMode.C_Str();
-        } else {
-            float opacity;
-
-            if (mat->Get(AI_MATKEY_OPACITY, opacity) == AI_SUCCESS) {
-                if (opacity < 1) {
-                    m->alphaMode = "BLEND";
-                    m->pbrMetallicRoughness.baseColorFactor[3] *= opacity;
-                }
-            }
-        }
-
-        bool hasPbrSpecularGlossiness = false;
-        mat->Get(AI_MATKEY_GLTF_PBRSPECULARGLOSSINESS, hasPbrSpecularGlossiness);
-
-        if (hasPbrSpecularGlossiness) {
-
-            if (!mAsset->extensionsUsed.KHR_materials_pbrSpecularGlossiness) {
-                mAsset->extensionsUsed.KHR_materials_pbrSpecularGlossiness = true;
-            }
-
-            PbrSpecularGlossiness pbrSG;
-
-            GetMatColor(mat, pbrSG.diffuseFactor, AI_MATKEY_COLOR_DIFFUSE);
-            GetMatColor(mat, pbrSG.specularFactor, AI_MATKEY_COLOR_SPECULAR);
-
-            if (mat->Get(AI_MATKEY_GLTF_PBRSPECULARGLOSSINESS_GLOSSINESS_FACTOR, pbrSG.glossinessFactor) != AI_SUCCESS) {
-				float shininess;
-
-				if (mat->Get(AI_MATKEY_SHININESS, shininess) == AI_SUCCESS) {
-                    pbrSG.glossinessFactor = shininess / 1000;
-                }
-            }
-
-            GetMatTex(mat, pbrSG.diffuseTexture, aiTextureType_DIFFUSE);
-            GetMatTex(mat, pbrSG.specularGlossinessTexture, aiTextureType_SPECULAR);
-
-            m->pbrSpecularGlossiness = Nullable<PbrSpecularGlossiness>(pbrSG);
-        }
-
-        bool unlit;
-        if (mat->Get(AI_MATKEY_GLTF_UNLIT, unlit) == AI_SUCCESS && unlit) {
-            mAsset->extensionsUsed.KHR_materials_unlit = true;
-            m->unlit = true;
-        }
-    }
-}
-
-/*
- * Search through node hierarchy and find the node containing the given meshID.
- * Returns true on success, and false otherwise.
- */
-bool FindMeshNode(Ref<Node>& nodeIn, Ref<Node>& meshNode, std::string meshID)
-{
-    for (unsigned int i = 0; i < nodeIn->meshes.size(); ++i) {
-        if (meshID.compare(nodeIn->meshes[i]->id) == 0) {
-            meshNode = nodeIn;
-            return true;
-        }
-    }
-
-    for (unsigned int i = 0; i < nodeIn->children.size(); ++i) {
-        if(FindMeshNode(nodeIn->children[i], meshNode, meshID)) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-/*
- * Find the root joint of the skeleton.
- * Starts will any joint node and traces up the tree,
- * until a parent is found that does not have a jointName.
- * Returns the first parent Ref<Node> found that does not have a jointName.
- */
-Ref<Node> FindSkeletonRootJoint(Ref<Skin>& skinRef)
-{
-    Ref<Node> startNodeRef;
-    Ref<Node> parentNodeRef;
-
-    // Arbitrarily use the first joint to start the search.
-    startNodeRef = skinRef->jointNames[0];
-    parentNodeRef = skinRef->jointNames[0];
-
-    do {
-        startNodeRef = parentNodeRef;
-        parentNodeRef = startNodeRef->parent;
-    } while (!parentNodeRef->jointName.empty());
-
-    return parentNodeRef;
-}
-
-void ExportSkin(Asset& mAsset, const aiMesh* aimesh, Ref<Mesh>& meshRef, Ref<Buffer>& bufferRef, Ref<Skin>& skinRef, std::vector<aiMatrix4x4>& inverseBindMatricesData)
-{
-    if (aimesh->mNumBones < 1) {
-        return;
-    }
-
-    // Store the vertex joint and weight data.
-    const size_t NumVerts( aimesh->mNumVertices );
-    vec4* vertexJointData = new vec4[ NumVerts ];
-    vec4* vertexWeightData = new vec4[ NumVerts ];
-    int* jointsPerVertex = new int[ NumVerts ];
-    for (size_t i = 0; i < NumVerts; ++i) {
-        jointsPerVertex[i] = 0;
-        for (size_t j = 0; j < 4; ++j) {
-            vertexJointData[i][j] = 0;
-            vertexWeightData[i][j] = 0;
-        }
-    }
-
-    for (unsigned int idx_bone = 0; idx_bone < aimesh->mNumBones; ++idx_bone) {
-        const aiBone* aib = aimesh->mBones[idx_bone];
-
-        // aib->mName   =====>  skinRef->jointNames
-        // Find the node with id = mName.
-        Ref<Node> nodeRef = mAsset.nodes.Get(aib->mName.C_Str());
-        nodeRef->jointName = nodeRef->name;
-
-        unsigned int jointNamesIndex = 0;
-        bool addJointToJointNames = true;
-        for ( unsigned int idx_joint = 0; idx_joint < skinRef->jointNames.size(); ++idx_joint) {
-            if (skinRef->jointNames[idx_joint]->jointName.compare(nodeRef->jointName) == 0) {
-                addJointToJointNames = false;
-                jointNamesIndex = idx_joint;
-            }
-        }
-
-        if (addJointToJointNames) {
-            skinRef->jointNames.push_back(nodeRef);
-
-            // aib->mOffsetMatrix   =====>  skinRef->inverseBindMatrices
-            aiMatrix4x4 tmpMatrix4;
-            CopyValue(aib->mOffsetMatrix, tmpMatrix4);
-            inverseBindMatricesData.push_back(tmpMatrix4);
-            jointNamesIndex = static_cast<unsigned int>(inverseBindMatricesData.size() - 1);
-        }
-
-        // aib->mWeights   =====>  vertexWeightData
-        for (unsigned int idx_weights = 0; idx_weights < aib->mNumWeights; ++idx_weights) {
-            unsigned int vertexId = aib->mWeights[idx_weights].mVertexId;
-            float vertWeight      = aib->mWeights[idx_weights].mWeight;
-
-            // A vertex can only have at most four joint weights. Ignore all others.
-            if (jointsPerVertex[vertexId] > 3) {
-                continue;
-            }
-
-            vertexJointData[vertexId][jointsPerVertex[vertexId]] = static_cast<float>(jointNamesIndex);
-            vertexWeightData[vertexId][jointsPerVertex[vertexId]] = vertWeight;
-
-            jointsPerVertex[vertexId] += 1;
-        }
-
-    } // End: for-loop mNumMeshes
-
-    Mesh::Primitive& p = meshRef->primitives.back();
-    Ref<Accessor> vertexJointAccessor = ExportData(mAsset, skinRef->id, bufferRef, aimesh->mNumVertices, vertexJointData, AttribType::VEC4, AttribType::VEC4, ComponentType_FLOAT);
-    if ( vertexJointAccessor ) {
-        size_t offset = vertexJointAccessor->bufferView->byteOffset;
-        size_t bytesLen = vertexJointAccessor->bufferView->byteLength;
-        unsigned int s_bytesPerComp= ComponentTypeSize(ComponentType_UNSIGNED_SHORT);
-        unsigned int bytesPerComp = ComponentTypeSize(vertexJointAccessor->componentType);
-        size_t s_bytesLen = bytesLen * s_bytesPerComp / bytesPerComp;
-        Ref<Buffer> buf = vertexJointAccessor->bufferView->buffer;
-        uint8_t* arrys = new uint8_t[bytesLen];
-        unsigned int i = 0;
-        for ( unsigned int j = 0; j <= bytesLen; j += bytesPerComp ){
-            size_t len_p = offset + j;
-            float f_value = *(float *)&buf->GetPointer()[len_p];
-            unsigned short c = static_cast<unsigned short>(f_value);
-            memcpy(&arrys[i*s_bytesPerComp], &c, s_bytesPerComp);
-            ++i;
-        }
-        buf->ReplaceData_joint(offset, bytesLen, arrys, bytesLen);
-        vertexJointAccessor->componentType = ComponentType_UNSIGNED_SHORT;
-        vertexJointAccessor->bufferView->byteLength = s_bytesLen;
-
-        p.attributes.joint.push_back( vertexJointAccessor );
-        delete[] arrys;
-    }
-
-    Ref<Accessor> vertexWeightAccessor = ExportData(mAsset, skinRef->id, bufferRef, aimesh->mNumVertices,
-            vertexWeightData, AttribType::VEC4, AttribType::VEC4, ComponentType_FLOAT);
-    if ( vertexWeightAccessor ) {
-        p.attributes.weight.push_back( vertexWeightAccessor );
-    }
-    delete[] jointsPerVertex;
-    delete[] vertexWeightData;
-    delete[] vertexJointData;
-}
-
-void glTF2Exporter::ExportMeshes()
-{
-    typedef decltype(aiFace::mNumIndices) IndicesType;
-
-    std::string fname = std::string(mFilename);
-    std::string bufferIdPrefix = fname.substr(0, fname.rfind(".gltf"));
-    std::string bufferId = mAsset->FindUniqueID("", bufferIdPrefix.c_str());
-
-    Ref<Buffer> b = mAsset->GetBodyBuffer();
-    if (!b) {
-       b = mAsset->buffers.Create(bufferId);
-    }
-
-    //----------------------------------------
-    // Initialize variables for the skin
-    bool createSkin = false;
-    for (unsigned int idx_mesh = 0; idx_mesh < mScene->mNumMeshes; ++idx_mesh) {
-        const aiMesh* aim = mScene->mMeshes[idx_mesh];
-        if(aim->HasBones()) {
-            createSkin = true;
-            break;
-        }
-    }
-
-    Ref<Skin> skinRef;
-    std::string skinName = mAsset->FindUniqueID("skin", "skin");
-    std::vector<aiMatrix4x4> inverseBindMatricesData;
-    if(createSkin) {
-        skinRef = mAsset->skins.Create(skinName);
-        skinRef->name = skinName;
-    }
-    //----------------------------------------
-
-	for (unsigned int idx_mesh = 0; idx_mesh < mScene->mNumMeshes; ++idx_mesh) {
-		const aiMesh* aim = mScene->mMeshes[idx_mesh];
-
-        std::string name = aim->mName.C_Str();
-
-        std::string meshId = mAsset->FindUniqueID(name, "mesh");
-        Ref<Mesh> m = mAsset->meshes.Create(meshId);
-        m->primitives.resize(1);
-        Mesh::Primitive& p = m->primitives.back();
-
-        m->name = name;
-
-        p.material = mAsset->materials.Get(aim->mMaterialIndex);
-
-		/******************* Vertices ********************/
-        Ref<Accessor> v = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mVertices, AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT);
-		if (v) p.attributes.position.push_back(v);
-
-		/******************** Normals ********************/
-        // Normalize all normals as the validator can emit a warning otherwise
-        if ( nullptr != aim->mNormals) {
-            for ( auto i = 0u; i < aim->mNumVertices; ++i ) {
-                aim->mNormals[ i ].Normalize();
-            }
-        }
-
-		Ref<Accessor> n = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mNormals, AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT);
-        if (n) p.attributes.normal.push_back(n);
-
-		/************** Texture coordinates **************/
-        for (int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
-			if (!aim->HasTextureCoords(i))
-				continue;
-			
-            // Flip UV y coords
-            if (aim -> mNumUVComponents[i] > 1) {
-                for (unsigned int j = 0; j < aim->mNumVertices; ++j) {
-                    aim->mTextureCoords[i][j].y = 1 - aim->mTextureCoords[i][j].y;
-                }
-            }
-
-            if (aim->mNumUVComponents[i] > 0) {
-                AttribType::Value type = (aim->mNumUVComponents[i] == 2) ? AttribType::VEC2 : AttribType::VEC3;
-
-				Ref<Accessor> tc = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mTextureCoords[i], AttribType::VEC3, type, ComponentType_FLOAT, false);
-				if (tc) p.attributes.texcoord.push_back(tc);
-			}
-		}
-
-		/*************** Vertex colors ****************/
-		for (unsigned int indexColorChannel = 0; indexColorChannel < aim->GetNumColorChannels(); ++indexColorChannel) {
-			Ref<Accessor> c = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mColors[indexColorChannel], AttribType::VEC4, AttribType::VEC4, ComponentType_FLOAT, false);
-			if (c)
-				p.attributes.color.push_back(c);
-		}
-
-		/*************** Vertices indices ****************/
-		if (aim->mNumFaces > 0) {
-			std::vector<IndicesType> indices;
-			unsigned int nIndicesPerFace = aim->mFaces[0].mNumIndices;
-            indices.resize(aim->mNumFaces * nIndicesPerFace);
-            for (size_t i = 0; i < aim->mNumFaces; ++i) {
-                for (size_t j = 0; j < nIndicesPerFace; ++j) {
-                    indices[i*nIndicesPerFace + j] = IndicesType(aim->mFaces[i].mIndices[j]);
-                }
-            }
-
-			p.indices = ExportData(*mAsset, meshId, b, indices.size(), &indices[0], AttribType::SCALAR, AttribType::SCALAR, ComponentType_UNSIGNED_INT, true);
-		}
-
-        switch (aim->mPrimitiveTypes) {
-            case aiPrimitiveType_POLYGON:
-                p.mode = PrimitiveMode_TRIANGLES; break; // TODO implement this
-            case aiPrimitiveType_LINE:
-                p.mode = PrimitiveMode_LINES; break;
-            case aiPrimitiveType_POINT:
-                p.mode = PrimitiveMode_POINTS; break;
-            default: // aiPrimitiveType_TRIANGLE
-                p.mode = PrimitiveMode_TRIANGLES;
-        }
-
-        /*************** Skins ****************/
-        if(aim->HasBones()) {
-            ExportSkin(*mAsset, aim, m, b, skinRef, inverseBindMatricesData);
-        }
-    }
-
-    //----------------------------------------
-    // Finish the skin
-    // Create the Accessor for skinRef->inverseBindMatrices
-    if (createSkin) {
-        mat4* invBindMatrixData = new mat4[inverseBindMatricesData.size()];
-        for ( unsigned int idx_joint = 0; idx_joint < inverseBindMatricesData.size(); ++idx_joint) {
-            CopyValue(inverseBindMatricesData[idx_joint], invBindMatrixData[idx_joint]);
-        }
-
-        Ref<Accessor> invBindMatrixAccessor = ExportData(*mAsset, skinName, b,
-                static_cast<unsigned int>(inverseBindMatricesData.size()),
-            invBindMatrixData, AttribType::MAT4, AttribType::MAT4, ComponentType_FLOAT);
-        if (invBindMatrixAccessor) {
-            skinRef->inverseBindMatrices = invBindMatrixAccessor;
-        }
-
-        // Identity Matrix   =====>  skinRef->bindShapeMatrix
-        // Temporary. Hard-coded identity matrix here
-        skinRef->bindShapeMatrix.isPresent = true;
-        IdentityMatrix4(skinRef->bindShapeMatrix.value);
-
-        // Find nodes that contain a mesh with bones and add "skeletons" and "skin" attributes to those nodes.
-        Ref<Node> rootNode = mAsset->nodes.Get(unsigned(0));
-        Ref<Node> meshNode;
-        for (unsigned int meshIndex = 0; meshIndex < mAsset->meshes.Size(); ++meshIndex) {
-            Ref<Mesh> mesh = mAsset->meshes.Get(meshIndex);
-            bool hasBones = false;
-            for (unsigned int i = 0; i < mesh->primitives.size(); ++i) {
-                if (!mesh->primitives[i].attributes.weight.empty()) {
-                    hasBones = true;
-                    break;
-                }
-            }
-            if (!hasBones) {
-                continue;
-            }
-            std::string meshID = mesh->id;
-            FindMeshNode(rootNode, meshNode, meshID);
-            Ref<Node> rootJoint = FindSkeletonRootJoint(skinRef);
-            meshNode->skeletons.push_back(rootJoint);
-            meshNode->skin = skinRef;
-        }
-        delete[] invBindMatrixData;
-    }
-}
-
-// Merges a node's multiple meshes (with one primitive each) into one mesh with multiple primitives
-void glTF2Exporter::MergeMeshes()
-{
-    for (unsigned int n = 0; n < mAsset->nodes.Size(); ++n) {
-        Ref<Node> node = mAsset->nodes.Get(n);
-
-        unsigned int nMeshes = static_cast<unsigned int>(node->meshes.size());
-
-        //skip if it's 1 or less meshes per node
-        if (nMeshes > 1) {
-            Ref<Mesh> firstMesh = node->meshes.at(0);
-
-            //loop backwards to allow easy removal of a mesh from a node once it's merged
-            for (unsigned int m = nMeshes - 1; m >= 1; --m) {
-                Ref<Mesh> mesh = node->meshes.at(m);
-
-                //append this mesh's primitives to the first mesh's primitives
-                firstMesh->primitives.insert(
-                    firstMesh->primitives.end(),
-                    mesh->primitives.begin(),
-                    mesh->primitives.end()
-                );
-
-                //remove the mesh from the list of meshes
-                unsigned int removedIndex = mAsset->meshes.Remove(mesh->id.c_str());
-
-                //find the presence of the removed mesh in other nodes
-                for (unsigned int nn = 0; nn < mAsset->nodes.Size(); ++nn) {
-                    Ref<Node> node = mAsset->nodes.Get(nn);
-
-                    for (unsigned int mm = 0; mm < node->meshes.size(); ++mm) {
-                        Ref<Mesh>& meshRef = node->meshes.at(mm);
-                        unsigned int meshIndex = meshRef.GetIndex();
-
-                        if (meshIndex == removedIndex) {
-                            node->meshes.erase(node->meshes.begin() + mm);
-                        } else if (meshIndex > removedIndex) {
-                            Ref<Mesh> newMeshRef = mAsset->meshes.Get(meshIndex - 1);
-
-                            meshRef = newMeshRef;
-                        }
-                    }
-                }
-            }
-
-            //since we were looping backwards, reverse the order of merged primitives to their original order
-            std::reverse(firstMesh->primitives.begin() + 1, firstMesh->primitives.end());
-        }
-    }
-}
-
-/*
- * Export the root node of the node hierarchy.
- * Calls ExportNode for all children.
- */
-unsigned int glTF2Exporter::ExportNodeHierarchy(const aiNode* n)
-{
-    Ref<Node> node = mAsset->nodes.Create(mAsset->FindUniqueID(n->mName.C_Str(), "node"));
-
-    node->name = n->mName.C_Str();
-
-    if (!n->mTransformation.IsIdentity()) {
-        node->matrix.isPresent = true;
-        CopyValue(n->mTransformation, node->matrix.value);
-    }
-
-    for (unsigned int i = 0; i < n->mNumMeshes; ++i) {
-        node->meshes.push_back(mAsset->meshes.Get(n->mMeshes[i]));
-    }
-
-    for (unsigned int i = 0; i < n->mNumChildren; ++i) {
-        unsigned int idx = ExportNode(n->mChildren[i], node);
-        node->children.push_back(mAsset->nodes.Get(idx));
-    }
-
-    return node.GetIndex();
-}
-
-/*
- * Export node and recursively calls ExportNode for all children.
- * Since these nodes are not the root node, we also export the parent Ref<Node>
- */
-unsigned int glTF2Exporter::ExportNode(const aiNode* n, Ref<Node>& parent)
-{
-    std::string name = mAsset->FindUniqueID(n->mName.C_Str(), "node");
-    Ref<Node> node = mAsset->nodes.Create(name);
-
-    node->parent = parent;
-    node->name = name;
-
-    if (!n->mTransformation.IsIdentity()) {
-        node->matrix.isPresent = true;
-        CopyValue(n->mTransformation, node->matrix.value);
-    }
-
-    for (unsigned int i = 0; i < n->mNumMeshes; ++i) {
-        node->meshes.push_back(mAsset->meshes.Get(n->mMeshes[i]));
-    }
-
-    for (unsigned int i = 0; i < n->mNumChildren; ++i) {
-        unsigned int idx = ExportNode(n->mChildren[i], node);
-        node->children.push_back(mAsset->nodes.Get(idx));
-    }
-
-    return node.GetIndex();
-}
-
-
-void glTF2Exporter::ExportScene()
-{
-    const char* sceneName = "defaultScene";
-    Ref<Scene> scene = mAsset->scenes.Create(sceneName);
-
-    // root node will be the first one exported (idx 0)
-    if (mAsset->nodes.Size() > 0) {
-        scene->nodes.push_back(mAsset->nodes.Get(0u));
-    }
-
-    // set as the default scene
-    mAsset->scene = scene;
-}
-
-void glTF2Exporter::ExportMetadata()
-{
-    AssetMetadata& asset = mAsset->asset;
-    asset.version = "2.0";
-
-    char buffer[256];
-    ai_snprintf(buffer, 256, "Open Asset Import Library (assimp v%d.%d.%d)",
-        aiGetVersionMajor(), aiGetVersionMinor(), aiGetVersionRevision());
-
-    asset.generator = buffer;
-}
-
-inline Ref<Accessor> GetSamplerInputRef(Asset& asset, std::string& animId, Ref<Buffer>& buffer, std::vector<float>& times)
-{
-    return ExportData(asset, animId, buffer, (unsigned int)times.size(), &times[0], AttribType::SCALAR, AttribType::SCALAR, ComponentType_FLOAT);
-}
-
-inline void ExtractTranslationSampler(Asset& asset, std::string& animId, Ref<Buffer>& buffer, const aiNodeAnim* nodeChannel, float ticksPerSecond, Animation::Sampler& sampler)
-{
-    const unsigned int numKeyframes = nodeChannel->mNumPositionKeys;
-    if (numKeyframes == 0) {
-        return;
-    }
-
-    std::vector<float> times(numKeyframes);
-    std::vector<float> values(numKeyframes * 3);
-    for (unsigned int i = 0; i < numKeyframes; ++i) {
-        const aiVectorKey& key = nodeChannel->mPositionKeys[i];
-        // mTime is measured in ticks, but GLTF time is measured in seconds, so convert.
-        times[i] = static_cast<float>(key.mTime / ticksPerSecond);
-        values[(i * 3) + 0] = key.mValue.x;
-        values[(i * 3) + 1] = key.mValue.y;
-        values[(i * 3) + 2] = key.mValue.z;
-    }
-
-    sampler.input = GetSamplerInputRef(asset, animId, buffer, times);
-    sampler.output = ExportData(asset, animId, buffer, numKeyframes, &values[0], AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT);
-    sampler.interpolation = Interpolation_LINEAR;
-}
-
-inline void ExtractScaleSampler(Asset& asset, std::string& animId, Ref<Buffer>& buffer, const aiNodeAnim* nodeChannel, float ticksPerSecond, Animation::Sampler& sampler)
-{
-    const unsigned int numKeyframes = nodeChannel->mNumScalingKeys;
-    if (numKeyframes == 0) {
-        return;
-    }
-
-    std::vector<float> times(numKeyframes);
-    std::vector<float> values(numKeyframes * 3);
-    for (unsigned int i = 0; i < numKeyframes; ++i) {
-        const aiVectorKey& key = nodeChannel->mScalingKeys[i];
-        // mTime is measured in ticks, but GLTF time is measured in seconds, so convert.
-        times[i] = static_cast<float>(key.mTime / ticksPerSecond);
-        values[(i * 3) + 0] = key.mValue.x;
-        values[(i * 3) + 1] = key.mValue.y;
-        values[(i * 3) + 2] = key.mValue.z;
-    }
-
-    sampler.input = GetSamplerInputRef(asset, animId, buffer, times);
-    sampler.output = ExportData(asset, animId, buffer, numKeyframes, &values[0], AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT);
-    sampler.interpolation = Interpolation_LINEAR;
-}
-
-inline void ExtractRotationSampler(Asset& asset, std::string& animId, Ref<Buffer>& buffer, const aiNodeAnim* nodeChannel, float ticksPerSecond, Animation::Sampler& sampler)
-{
-    const unsigned int numKeyframes = nodeChannel->mNumRotationKeys;
-    if (numKeyframes == 0) {
-        return;
-    }
-
-    std::vector<float> times(numKeyframes);
-    std::vector<float> values(numKeyframes * 4);
-    for (unsigned int i = 0; i < numKeyframes; ++i) {
-        const aiQuatKey& key = nodeChannel->mRotationKeys[i];
-        // mTime is measured in ticks, but GLTF time is measured in seconds, so convert.
-        times[i] = static_cast<float>(key.mTime / ticksPerSecond);
-        values[(i * 4) + 0] = key.mValue.x;
-        values[(i * 4) + 1] = key.mValue.y;
-        values[(i * 4) + 2] = key.mValue.z;
-        values[(i * 4) + 3] = key.mValue.w;
-    }
-
-    sampler.input = GetSamplerInputRef(asset, animId, buffer, times);
-    sampler.output = ExportData(asset, animId, buffer, numKeyframes, &values[0], AttribType::VEC4, AttribType::VEC4, ComponentType_FLOAT);
-    sampler.interpolation = Interpolation_LINEAR;
-}
-
-static void AddSampler(Ref<Animation>& animRef, Ref<Node>& nodeRef, Animation::Sampler& sampler, AnimationPath path)
-{
-      Animation::Channel channel;
-      channel.sampler = static_cast<int>(animRef->samplers.size());
-      channel.target.path = path;
-      channel.target.node = nodeRef;
-      animRef->channels.push_back(channel);
-      animRef->samplers.push_back(sampler);
-}
-
-void glTF2Exporter::ExportAnimations()
-{
-    Ref<Buffer> bufferRef = mAsset->buffers.Get(unsigned (0));
-
-    for (unsigned int i = 0; i < mScene->mNumAnimations; ++i) {
-        const aiAnimation* anim = mScene->mAnimations[i];
-        const float ticksPerSecond = static_cast<float>(anim->mTicksPerSecond);
-
-        std::string nameAnim = "anim";
-        if (anim->mName.length > 0) {
-            nameAnim = anim->mName.C_Str();
-        }
-
-        for (unsigned int channelIndex = 0; channelIndex < anim->mNumChannels; ++channelIndex) {
-            const aiNodeAnim* nodeChannel = anim->mChannels[channelIndex];
-
-            // It appears that assimp stores this type of animation as multiple animations.
-            // where each aiNodeAnim in mChannels animates a specific node.
-            std::string name = nameAnim + "_" + to_string(channelIndex);
-            name = mAsset->FindUniqueID(name, "animation");
-            Ref<Animation> animRef = mAsset->animations.Create(name);
-
-            Ref<Node> animNode = mAsset->nodes.Get(nodeChannel->mNodeName.C_Str());
-
-            Animation::Sampler translationSampler;
-            ExtractTranslationSampler(*mAsset, name, bufferRef, nodeChannel, ticksPerSecond, translationSampler);
-            AddSampler(animRef, animNode, translationSampler, AnimationPath_TRANSLATION);
-
-            Animation::Sampler rotationSampler;
-            ExtractRotationSampler(*mAsset, name, bufferRef, nodeChannel, ticksPerSecond, rotationSampler);
-            AddSampler(animRef, animNode, rotationSampler, AnimationPath_ROTATION);
-
-            Animation::Sampler scaleSampler;
-            ExtractScaleSampler(*mAsset, name, bufferRef, nodeChannel, ticksPerSecond, scaleSampler);
-            AddSampler(animRef, animNode, scaleSampler, AnimationPath_SCALE);
-        }
-
-        // Assimp documentation staes this is not used (not implemented)
-        // for (unsigned int channelIndex = 0; channelIndex < anim->mNumMeshChannels; ++channelIndex) {
-        //     const aiMeshAnim* meshChannel = anim->mMeshChannels[channelIndex];
-        // }
-
-    } // End: for-loop mNumAnimations
-}
-
-
-#endif // ASSIMP_BUILD_NO_GLTF_EXPORTER
-#endif // ASSIMP_BUILD_NO_EXPORT
diff --git a/Engine/lib/assimp/code/glTF2/glTF2Exporter.h b/Engine/lib/assimp/code/glTF2/glTF2Exporter.h
deleted file mode 100644
index 2dc083709..000000000
--- a/Engine/lib/assimp/code/glTF2/glTF2Exporter.h
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file GltfExporter.h
-* Declares the exporter class to write a scene to a gltf/glb file
-*/
-#ifndef AI_GLTF2EXPORTER_H_INC
-#define AI_GLTF2EXPORTER_H_INC
-
-#ifndef ASSIMP_BUILD_NO_GLTF_IMPORTER
-
-#include <assimp/types.h>
-#include <assimp/material.h>
-
-#include <sstream>
-#include <vector>
-#include <map>
-#include <memory>
-
-struct aiScene;
-struct aiNode;
-struct aiMaterial;
-
-namespace glTF2
-{
-    template<class T>
-    class Ref;
-
-    class Asset;
-    struct TexProperty;
-    struct TextureInfo;
-    struct NormalTextureInfo;
-    struct OcclusionTextureInfo;
-    struct Node;
-    struct Texture;
-
-    // Vec/matrix types, as raw float arrays
-    typedef float (vec3)[3];
-    typedef float (vec4)[4];
-}
-
-namespace Assimp
-{
-    class IOSystem;
-    class IOStream;
-    class ExportProperties;
-
-    // ------------------------------------------------------------------------------------------------
-    /** Helper class to export a given scene to an glTF file. */
-    // ------------------------------------------------------------------------------------------------
-    class glTF2Exporter {
-    public:
-        /// Constructor for a specific scene to export
-        glTF2Exporter(const char* filename, IOSystem* pIOSystem, const aiScene* pScene,
-            const ExportProperties* pProperties, bool binary);
-        ~glTF2Exporter();
-
-    protected:
-        void WriteBinaryData(IOStream* outfile, std::size_t sceneLength);
-        void GetTexSampler(const aiMaterial* mat, glTF2::Ref<glTF2::Texture> texture, aiTextureType tt, unsigned int slot);
-        void GetMatTexProp(const aiMaterial* mat, unsigned int& prop, const char* propName, aiTextureType tt, unsigned int idx);
-        void GetMatTexProp(const aiMaterial* mat, float& prop, const char* propName, aiTextureType tt, unsigned int idx);
-        void GetMatTex(const aiMaterial* mat, glTF2::Ref<glTF2::Texture>& texture, aiTextureType tt, unsigned int slot);
-        void GetMatTex(const aiMaterial* mat, glTF2::TextureInfo& prop, aiTextureType tt, unsigned int slot);
-        void GetMatTex(const aiMaterial* mat, glTF2::NormalTextureInfo& prop, aiTextureType tt, unsigned int slot);
-        void GetMatTex(const aiMaterial* mat, glTF2::OcclusionTextureInfo& prop, aiTextureType tt, unsigned int slot);
-        aiReturn GetMatColor(const aiMaterial* mat, glTF2::vec4& prop, const char* propName, int type, int idx);
-        aiReturn GetMatColor(const aiMaterial* mat, glTF2::vec3& prop, const char* propName, int type, int idx);
-        void ExportMetadata();
-        void ExportMaterials();
-        void ExportMeshes();
-        void MergeMeshes();
-        unsigned int ExportNodeHierarchy(const aiNode* n);
-        unsigned int ExportNode(const aiNode* node, glTF2::Ref<glTF2::Node>& parent);
-        void ExportScene();
-        void ExportAnimations();
-
-    private:
-        const char* mFilename;
-        IOSystem* mIOSystem;
-        const aiScene* mScene;
-        const ExportProperties* mProperties;
-        std::map<std::string, unsigned int> mTexturesByPath;
-        std::shared_ptr<glTF2::Asset> mAsset;
-        std::vector<unsigned char> mBodyData;
-    };
-
-}
-
-#endif // ASSIMP_BUILD_NO_GLTF_IMPORTER
-
-#endif // AI_GLTF2EXPORTER_H_INC
diff --git a/Engine/lib/assimp/code/glTF2/glTF2Importer.cpp b/Engine/lib/assimp/code/glTF2/glTF2Importer.cpp
deleted file mode 100644
index 82c6cbfa8..000000000
--- a/Engine/lib/assimp/code/glTF2/glTF2Importer.cpp
+++ /dev/null
@@ -1,1265 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-#ifndef ASSIMP_BUILD_NO_GLTF_IMPORTER
-
-#include "glTF2/glTF2Importer.h"
-#include "glTF2/glTF2Asset.h"
-#include "glTF2/glTF2AssetWriter.h"
-#include "PostProcessing/MakeVerboseFormat.h"
-
-#include <assimp/StringComparison.h>
-#include <assimp/StringUtils.h>
-#include <assimp/Importer.hpp>
-#include <assimp/scene.h>
-#include <assimp/ai_assert.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/importerdesc.h>
-#include <assimp/CreateAnimMesh.h>
-
-#include <memory>
-#include <unordered_map>
-
-#include <rapidjson/document.h>
-#include <rapidjson/rapidjson.h>
-
-using namespace Assimp;
-using namespace glTF2;
-using namespace glTFCommon;
-
-namespace {
-    // generate bi-tangents from normals and tangents according to spec
-    struct Tangent {
-        aiVector3D xyz;
-        ai_real w;
-    };
-} // namespace
-
-//
-// glTF2Importer
-//
-
-static const aiImporterDesc desc = {
-    "glTF2 Importer",
-    "",
-    "",
-    "",
-    aiImporterFlags_SupportTextFlavour | aiImporterFlags_SupportBinaryFlavour | aiImporterFlags_LimitedSupport | aiImporterFlags_Experimental,
-    0,
-    0,
-    0,
-    0,
-    "gltf glb"
-};
-
-glTF2Importer::glTF2Importer()
-: BaseImporter()
-, meshOffsets()
-, embeddedTexIdxs()
-, mScene( NULL ) {
-    // empty
-}
-
-glTF2Importer::~glTF2Importer() {
-    // empty
-}
-
-const aiImporterDesc* glTF2Importer::GetInfo() const
-{
-    return &desc;
-}
-
-bool glTF2Importer::CanRead(const std::string& pFile, IOSystem* pIOHandler, bool /* checkSig */) const
-{
-    const std::string &extension = GetExtension(pFile);
-
-    if (extension != "gltf" && extension != "glb")
-        return false;
-
-    if (pIOHandler) {
-        glTF2::Asset asset(pIOHandler);
-        asset.Load(pFile, extension == "glb");
-        std::string version = asset.asset.version;
-        return !version.empty() && version[0] == '2';
-    }
-
-    return false;
-}
-
-static aiTextureMapMode ConvertWrappingMode(SamplerWrap gltfWrapMode)
-{
-    switch (gltfWrapMode) {
-        case SamplerWrap::Mirrored_Repeat:
-            return aiTextureMapMode_Mirror;
-
-        case SamplerWrap::Clamp_To_Edge:
-            return aiTextureMapMode_Clamp;
-
-        case SamplerWrap::UNSET:
-        case SamplerWrap::Repeat:
-        default:
-            return aiTextureMapMode_Wrap;
-    }
-}
-
-/*static void CopyValue(const glTF2::vec3& v, aiColor3D& out)
-{
-    out.r = v[0]; out.g = v[1]; out.b = v[2];
-}
-
-
-static void CopyValue(const glTF2::vec4& v, aiColor4D& out)
-{
-    out.r = v[0]; out.g = v[1]; out.b = v[2]; out.a = v[3];
-}*/
-
-/*static void CopyValue(const glTF2::vec4& v, aiColor3D& out)
-{
-    out.r = v[0]; out.g = v[1]; out.b = v[2];
-}*/
-
-/*static void CopyValue(const glTF2::vec3& v, aiColor4D& out)
-{
-    out.r = v[0]; out.g = v[1]; out.b = v[2]; out.a = 1.0;
-}
-
-static void CopyValue(const glTF2::vec3& v, aiVector3D& out)
-{
-    out.x = v[0]; out.y = v[1]; out.z = v[2];
-}
-
-static void CopyValue(const glTF2::vec4& v, aiQuaternion& out)
-{
-    out.x = v[0]; out.y = v[1]; out.z = v[2]; out.w = v[3];
-}*/
-
-/*static void CopyValue(const glTF2::mat4& v, aiMatrix4x4& o)
-{
-    o.a1 = v[ 0]; o.b1 = v[ 1]; o.c1 = v[ 2]; o.d1 = v[ 3];
-    o.a2 = v[ 4]; o.b2 = v[ 5]; o.c2 = v[ 6]; o.d2 = v[ 7];
-    o.a3 = v[ 8]; o.b3 = v[ 9]; o.c3 = v[10]; o.d3 = v[11];
-    o.a4 = v[12]; o.b4 = v[13]; o.c4 = v[14]; o.d4 = v[15];
-}*/
-
-inline void SetMaterialColorProperty(Asset& /*r*/, vec4& prop, aiMaterial* mat, const char* pKey, unsigned int type, unsigned int idx)
-{
-    aiColor4D col;
-    CopyValue(prop, col);
-    mat->AddProperty(&col, 1, pKey, type, idx);
-}
-
-inline void SetMaterialColorProperty(Asset& /*r*/, vec3& prop, aiMaterial* mat, const char* pKey, unsigned int type, unsigned int idx)
-{
-    aiColor4D col;
-    glTFCommon::CopyValue(prop, col);
-    mat->AddProperty(&col, 1, pKey, type, idx);
-}
-
-inline void SetMaterialTextureProperty(std::vector<int>& embeddedTexIdxs, Asset& /*r*/, glTF2::TextureInfo prop, aiMaterial* mat, aiTextureType texType, unsigned int texSlot = 0)
-{
-    if (prop.texture && prop.texture->source) {
-        aiString uri(prop.texture->source->uri);
-
-        int texIdx = embeddedTexIdxs[prop.texture->source.GetIndex()];
-        if (texIdx != -1) { // embedded
-            // setup texture reference string (copied from ColladaLoader::FindFilenameForEffectTexture)
-            uri.data[0] = '*';
-            uri.length = 1 + ASSIMP_itoa10(uri.data + 1, MAXLEN - 1, texIdx);
-        }
-
-        mat->AddProperty(&uri, AI_MATKEY_TEXTURE(texType, texSlot));
-        mat->AddProperty(&prop.texCoord, 1, _AI_MATKEY_GLTF_TEXTURE_TEXCOORD_BASE, texType, texSlot);
-
-        if (prop.texture->sampler) {
-            Ref<Sampler> sampler = prop.texture->sampler;
-
-            aiString name(sampler->name);
-            aiString id(sampler->id);
-
-            mat->AddProperty(&name, AI_MATKEY_GLTF_MAPPINGNAME(texType, texSlot));
-            mat->AddProperty(&id, AI_MATKEY_GLTF_MAPPINGID(texType, texSlot));
-
-            aiTextureMapMode wrapS = ConvertWrappingMode(sampler->wrapS);
-            aiTextureMapMode wrapT = ConvertWrappingMode(sampler->wrapT);
-            mat->AddProperty(&wrapS, 1, AI_MATKEY_MAPPINGMODE_U(texType, texSlot));
-            mat->AddProperty(&wrapT, 1, AI_MATKEY_MAPPINGMODE_V(texType, texSlot));
-
-            if (sampler->magFilter != SamplerMagFilter::UNSET) {
-                mat->AddProperty(&sampler->magFilter, 1, AI_MATKEY_GLTF_MAPPINGFILTER_MAG(texType, texSlot));
-            }
-
-            if (sampler->minFilter != SamplerMinFilter::UNSET) {
-                mat->AddProperty(&sampler->minFilter, 1, AI_MATKEY_GLTF_MAPPINGFILTER_MIN(texType, texSlot));
-            }
-        }
-    }
-}
-
-inline void SetMaterialTextureProperty(std::vector<int>& embeddedTexIdxs, Asset& r, glTF2::NormalTextureInfo& prop, aiMaterial* mat, aiTextureType texType, unsigned int texSlot = 0)
-{
-    SetMaterialTextureProperty( embeddedTexIdxs, r, (glTF2::TextureInfo) prop, mat, texType, texSlot );
-
-    if (prop.texture && prop.texture->source) {
-         mat->AddProperty(&prop.scale, 1, AI_MATKEY_GLTF_TEXTURE_SCALE(texType, texSlot));
-    }
-}
-
-inline void SetMaterialTextureProperty(std::vector<int>& embeddedTexIdxs, Asset& r, glTF2::OcclusionTextureInfo& prop, aiMaterial* mat, aiTextureType texType, unsigned int texSlot = 0)
-{
-    SetMaterialTextureProperty( embeddedTexIdxs, r, (glTF2::TextureInfo) prop, mat, texType, texSlot );
-
-    if (prop.texture && prop.texture->source) {
-        mat->AddProperty(&prop.strength, 1, AI_MATKEY_GLTF_TEXTURE_STRENGTH(texType, texSlot));
-    }
-}
-
-static aiMaterial* ImportMaterial(std::vector<int>& embeddedTexIdxs, Asset& r, Material& mat)
-{
-    aiMaterial* aimat = new aiMaterial();
-
-   if (!mat.name.empty()) {
-        aiString str(mat.name);
-
-        aimat->AddProperty(&str, AI_MATKEY_NAME);
-    }
-
-    SetMaterialColorProperty(r, mat.pbrMetallicRoughness.baseColorFactor, aimat, AI_MATKEY_COLOR_DIFFUSE);
-    SetMaterialColorProperty(r, mat.pbrMetallicRoughness.baseColorFactor, aimat, AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_BASE_COLOR_FACTOR);
-
-    SetMaterialTextureProperty(embeddedTexIdxs, r, mat.pbrMetallicRoughness.baseColorTexture, aimat, aiTextureType_DIFFUSE);
-    SetMaterialTextureProperty(embeddedTexIdxs, r, mat.pbrMetallicRoughness.baseColorTexture, aimat, AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_BASE_COLOR_TEXTURE);
-
-    SetMaterialTextureProperty(embeddedTexIdxs, r, mat.pbrMetallicRoughness.metallicRoughnessTexture, aimat, AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_METALLICROUGHNESS_TEXTURE);
-
-    aimat->AddProperty(&mat.pbrMetallicRoughness.metallicFactor, 1, AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_METALLIC_FACTOR);
-    aimat->AddProperty(&mat.pbrMetallicRoughness.roughnessFactor, 1, AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_ROUGHNESS_FACTOR);
-
-    float roughnessAsShininess = 1 - mat.pbrMetallicRoughness.roughnessFactor;
-    roughnessAsShininess *= roughnessAsShininess * 1000;
-    aimat->AddProperty(&roughnessAsShininess, 1, AI_MATKEY_SHININESS);
-
-    SetMaterialTextureProperty(embeddedTexIdxs, r, mat.normalTexture, aimat, aiTextureType_NORMALS);
-    SetMaterialTextureProperty(embeddedTexIdxs, r, mat.occlusionTexture, aimat, aiTextureType_LIGHTMAP);
-    SetMaterialTextureProperty(embeddedTexIdxs, r, mat.emissiveTexture, aimat, aiTextureType_EMISSIVE);
-    SetMaterialColorProperty(r, mat.emissiveFactor, aimat, AI_MATKEY_COLOR_EMISSIVE);
-
-    aimat->AddProperty(&mat.doubleSided, 1, AI_MATKEY_TWOSIDED);
-
-    aiString alphaMode(mat.alphaMode);
-    aimat->AddProperty(&alphaMode, AI_MATKEY_GLTF_ALPHAMODE);
-    aimat->AddProperty(&mat.alphaCutoff, 1, AI_MATKEY_GLTF_ALPHACUTOFF);
-
-    //pbrSpecularGlossiness
-    if (mat.pbrSpecularGlossiness.isPresent) {
-        PbrSpecularGlossiness &pbrSG = mat.pbrSpecularGlossiness.value;
-
-        aimat->AddProperty(&mat.pbrSpecularGlossiness.isPresent, 1, AI_MATKEY_GLTF_PBRSPECULARGLOSSINESS);
-        SetMaterialColorProperty(r, pbrSG.diffuseFactor, aimat, AI_MATKEY_COLOR_DIFFUSE);
-        SetMaterialColorProperty(r, pbrSG.specularFactor, aimat, AI_MATKEY_COLOR_SPECULAR);
-
-        float glossinessAsShininess = pbrSG.glossinessFactor * 1000.0f;
-        aimat->AddProperty(&glossinessAsShininess, 1, AI_MATKEY_SHININESS);
-        aimat->AddProperty(&pbrSG.glossinessFactor, 1, AI_MATKEY_GLTF_PBRSPECULARGLOSSINESS_GLOSSINESS_FACTOR);
-
-        SetMaterialTextureProperty(embeddedTexIdxs, r, pbrSG.diffuseTexture, aimat, aiTextureType_DIFFUSE);
-
-        SetMaterialTextureProperty(embeddedTexIdxs, r, pbrSG.specularGlossinessTexture, aimat, aiTextureType_SPECULAR);
-    }
-    if (mat.unlit) {
-        aimat->AddProperty(&mat.unlit, 1, AI_MATKEY_GLTF_UNLIT);
-    }
-
-    return aimat;
-}
-
-void glTF2Importer::ImportMaterials(glTF2::Asset& r)
-{
-    const unsigned int numImportedMaterials = unsigned(r.materials.Size());
-    Material defaultMaterial;
-
-    mScene->mNumMaterials = numImportedMaterials + 1;
-    mScene->mMaterials = new aiMaterial*[mScene->mNumMaterials];
-    mScene->mMaterials[numImportedMaterials] = ImportMaterial(embeddedTexIdxs, r, defaultMaterial);
-
-    for (unsigned int i = 0; i < numImportedMaterials; ++i) {
-       mScene->mMaterials[i] = ImportMaterial(embeddedTexIdxs, r, r.materials[i]);
-    }
-}
-
-
-static inline void SetFace(aiFace& face, int a)
-{
-    face.mNumIndices = 1;
-    face.mIndices = new unsigned int[1];
-    face.mIndices[0] = a;
-}
-
-static inline void SetFace(aiFace& face, int a, int b)
-{
-    face.mNumIndices = 2;
-    face.mIndices = new unsigned int[2];
-    face.mIndices[0] = a;
-    face.mIndices[1] = b;
-}
-
-static inline void SetFace(aiFace& face, int a, int b, int c)
-{
-    face.mNumIndices = 3;
-    face.mIndices = new unsigned int[3];
-    face.mIndices[0] = a;
-    face.mIndices[1] = b;
-    face.mIndices[2] = c;
-}
-
-#ifdef ASSIMP_BUILD_DEBUG
-static inline bool CheckValidFacesIndices(aiFace* faces, unsigned nFaces, unsigned nVerts)
-{
-    for (unsigned i = 0; i < nFaces; ++i) {
-        for (unsigned j = 0; j < faces[i].mNumIndices; ++j) {
-            unsigned idx = faces[i].mIndices[j];
-            if (idx >= nVerts)
-                return false;
-        }
-    }
-    return true;
-}
-#endif // ASSIMP_BUILD_DEBUG
-
-void glTF2Importer::ImportMeshes(glTF2::Asset& r)
-{
-    std::vector<aiMesh*> meshes;
-
-    unsigned int k = 0;
-
-    for (unsigned int m = 0; m < r.meshes.Size(); ++m) {
-        Mesh& mesh = r.meshes[m];
-
-        meshOffsets.push_back(k);
-        k += unsigned(mesh.primitives.size());
-
-        for (unsigned int p = 0; p < mesh.primitives.size(); ++p) {
-            Mesh::Primitive& prim = mesh.primitives[p];
-
-            aiMesh* aim = new aiMesh();
-            meshes.push_back(aim);
-
-            aim->mName = mesh.name.empty() ? mesh.id : mesh.name;
-
-            if (mesh.primitives.size() > 1) {
-                ai_uint32& len = aim->mName.length;
-                aim->mName.data[len] = '-';
-                len += 1 + ASSIMP_itoa10(aim->mName.data + len + 1, unsigned(MAXLEN - len - 1), p);
-            }
-
-            switch (prim.mode) {
-                case PrimitiveMode_POINTS:
-                    aim->mPrimitiveTypes |= aiPrimitiveType_POINT;
-                    break;
-
-                case PrimitiveMode_LINES:
-                case PrimitiveMode_LINE_LOOP:
-                case PrimitiveMode_LINE_STRIP:
-                    aim->mPrimitiveTypes |= aiPrimitiveType_LINE;
-                    break;
-
-                case PrimitiveMode_TRIANGLES:
-                case PrimitiveMode_TRIANGLE_STRIP:
-                case PrimitiveMode_TRIANGLE_FAN:
-                    aim->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
-                    break;
-
-            }
-
-            Mesh::Primitive::Attributes& attr = prim.attributes;
-
-            if (attr.position.size() > 0 && attr.position[0]) {
-                aim->mNumVertices = static_cast<unsigned int>(attr.position[0]->count);
-                attr.position[0]->ExtractData(aim->mVertices);
-            }
-
-            if (attr.normal.size() > 0 && attr.normal[0]) {
-                attr.normal[0]->ExtractData(aim->mNormals);
-
-                // only extract tangents if normals are present
-                if (attr.tangent.size() > 0 && attr.tangent[0]) {
-                    // generate bitangents from normals and tangents according to spec
-                    Tangent *tangents = nullptr;
-
-                    attr.tangent[0]->ExtractData(tangents);
-
-                    aim->mTangents = new aiVector3D[aim->mNumVertices];
-                    aim->mBitangents = new aiVector3D[aim->mNumVertices];
-
-                    for (unsigned int i = 0; i < aim->mNumVertices; ++i) {
-                        aim->mTangents[i] = tangents[i].xyz;
-                        aim->mBitangents[i] = (aim->mNormals[i] ^ tangents[i].xyz) * tangents[i].w;
-                    }
-
-                    delete [] tangents;
-                }
-            }
-
-            for (size_t c = 0; c < attr.color.size() && c < AI_MAX_NUMBER_OF_COLOR_SETS; ++c) {
-                if (attr.color[c]->count != aim->mNumVertices) {
-                    DefaultLogger::get()->warn("Color stream size in mesh \"" + mesh.name +
-                        "\" does not match the vertex count");
-                    continue;
-                }
-                attr.color[c]->ExtractData(aim->mColors[c]);
-            }
-            for (size_t tc = 0; tc < attr.texcoord.size() && tc < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++tc) {
-                if (attr.texcoord[tc]->count != aim->mNumVertices) {
-                    DefaultLogger::get()->warn("Texcoord stream size in mesh \"" + mesh.name +
-                                               "\" does not match the vertex count");
-                    continue;
-                }
-
-                attr.texcoord[tc]->ExtractData(aim->mTextureCoords[tc]);
-                aim->mNumUVComponents[tc] = attr.texcoord[tc]->GetNumComponents();
-
-                aiVector3D* values = aim->mTextureCoords[tc];
-                for (unsigned int i = 0; i < aim->mNumVertices; ++i) {
-                    values[i].y = 1 - values[i].y; // Flip Y coords
-                }
-            }
-
-            std::vector<Mesh::Primitive::Target>& targets = prim.targets;
-            if (targets.size() > 0) {
-                aim->mNumAnimMeshes = (unsigned int)targets.size();
-                aim->mAnimMeshes = new aiAnimMesh*[aim->mNumAnimMeshes];
-                for (size_t i = 0; i < targets.size(); i++) {
-                    aim->mAnimMeshes[i] = aiCreateAnimMesh(aim);
-                    aiAnimMesh& aiAnimMesh = *(aim->mAnimMeshes[i]);
-                    Mesh::Primitive::Target& target = targets[i];
-
-                    if (target.position.size() > 0) {
-                        aiVector3D *positionDiff = nullptr;
-                        target.position[0]->ExtractData(positionDiff);
-                        for(unsigned int vertexId = 0; vertexId < aim->mNumVertices; vertexId++) {
-                            aiAnimMesh.mVertices[vertexId] += positionDiff[vertexId];
-                        }
-                        delete [] positionDiff;
-                    }
-                    if (target.normal.size() > 0) {
-                        aiVector3D *normalDiff = nullptr;
-                        target.normal[0]->ExtractData(normalDiff);
-                        for(unsigned int vertexId = 0; vertexId < aim->mNumVertices; vertexId++) {
-                            aiAnimMesh.mNormals[vertexId] += normalDiff[vertexId];
-                        }
-                        delete [] normalDiff;
-                    }
-                    if (target.tangent.size() > 0) {
-                        Tangent *tangent = nullptr;
-                        attr.tangent[0]->ExtractData(tangent);
-
-                        aiVector3D *tangentDiff = nullptr;
-                        target.tangent[0]->ExtractData(tangentDiff);
-
-                        for (unsigned int vertexId = 0; vertexId < aim->mNumVertices; ++vertexId) {
-                            tangent[vertexId].xyz += tangentDiff[vertexId];
-                            aiAnimMesh.mTangents[vertexId] = tangent[vertexId].xyz;
-                            aiAnimMesh.mBitangents[vertexId] = (aiAnimMesh.mNormals[vertexId] ^ tangent[vertexId].xyz) * tangent[vertexId].w;
-                        }
-                        delete [] tangent;
-                        delete [] tangentDiff;
-                    }
-                    if (mesh.weights.size() > i) {
-                        aiAnimMesh.mWeight = mesh.weights[i];
-                    }
-                }
-            }
-
-
-            aiFace* faces = 0;
-            size_t nFaces = 0;
-
-            if (prim.indices) {
-                size_t count = prim.indices->count;
-
-                Accessor::Indexer data = prim.indices->GetIndexer();
-                ai_assert(data.IsValid());
-
-                switch (prim.mode) {
-                    case PrimitiveMode_POINTS: {
-                        nFaces = count;
-                        faces = new aiFace[nFaces];
-                        for (unsigned int i = 0; i < count; ++i) {
-                            SetFace(faces[i], data.GetUInt(i));
-                        }
-                        break;
-                    }
-
-                    case PrimitiveMode_LINES: {
-                        nFaces = count / 2;
-                        faces = new aiFace[nFaces];
-                        for (unsigned int i = 0; i < count; i += 2) {
-                            SetFace(faces[i / 2], data.GetUInt(i), data.GetUInt(i + 1));
-                        }
-                        break;
-                    }
-
-                    case PrimitiveMode_LINE_LOOP:
-                    case PrimitiveMode_LINE_STRIP: {
-                        nFaces = count - ((prim.mode == PrimitiveMode_LINE_STRIP) ? 1 : 0);
-                        faces = new aiFace[nFaces];
-                        SetFace(faces[0], data.GetUInt(0), data.GetUInt(1));
-                        for (unsigned int i = 2; i < count; ++i) {
-                            SetFace(faces[i - 1], faces[i - 2].mIndices[1], data.GetUInt(i));
-                        }
-                        if (prim.mode == PrimitiveMode_LINE_LOOP) { // close the loop
-                            SetFace(faces[count - 1], faces[count - 2].mIndices[1], faces[0].mIndices[0]);
-                        }
-                        break;
-                    }
-
-                    case PrimitiveMode_TRIANGLES: {
-                        nFaces = count / 3;
-                        faces = new aiFace[nFaces];
-                        for (unsigned int i = 0; i < count; i += 3) {
-                            SetFace(faces[i / 3], data.GetUInt(i), data.GetUInt(i + 1), data.GetUInt(i + 2));
-                        }
-                        break;
-                    }
-                    case PrimitiveMode_TRIANGLE_STRIP: {
-                        nFaces = count - 2;
-                        faces = new aiFace[nFaces];
-                        for (unsigned int i = 0; i < nFaces; ++i) {
-                            //The ordering is to ensure that the triangles are all drawn with the same orientation
-                            if ((i + 1) % 2 == 0)
-                            {
-                                //For even n, vertices n + 1, n, and n + 2 define triangle n
-                                SetFace(faces[i], data.GetUInt(i + 1), data.GetUInt(i), data.GetUInt(i + 2));
-                            }
-                            else
-                            {
-                                //For odd n, vertices n, n+1, and n+2 define triangle n
-                                SetFace(faces[i], data.GetUInt(i), data.GetUInt(i + 1), data.GetUInt(i + 2));
-                            }
-                        }
-                        break;
-                    }
-                    case PrimitiveMode_TRIANGLE_FAN:
-                        nFaces = count - 2;
-                        faces = new aiFace[nFaces];
-                        SetFace(faces[0], data.GetUInt(0), data.GetUInt(1), data.GetUInt(2));
-                        for (unsigned int i = 1; i < nFaces; ++i) {
-                            SetFace(faces[i], faces[0].mIndices[0], faces[i - 1].mIndices[2], data.GetUInt(i + 2));
-                        }
-                        break;
-                }
-            }
-            else { // no indices provided so directly generate from counts
-
-                // use the already determined count as it includes checks
-                unsigned int count = aim->mNumVertices;
-
-                switch (prim.mode) {
-                case PrimitiveMode_POINTS: {
-                    nFaces = count;
-                    faces = new aiFace[nFaces];
-                    for (unsigned int i = 0; i < count; ++i) {
-                        SetFace(faces[i], i);
-                    }
-                    break;
-                }
-
-                case PrimitiveMode_LINES: {
-                    nFaces = count / 2;
-                    faces = new aiFace[nFaces];
-                    for (unsigned int i = 0; i < count; i += 2) {
-                        SetFace(faces[i / 2], i, i + 1);
-                    }
-                    break;
-                }
-
-                case PrimitiveMode_LINE_LOOP:
-                case PrimitiveMode_LINE_STRIP: {
-                    nFaces = count - ((prim.mode == PrimitiveMode_LINE_STRIP) ? 1 : 0);
-                    faces = new aiFace[nFaces];
-                    SetFace(faces[0], 0, 1);
-                    for (unsigned int i = 2; i < count; ++i) {
-                        SetFace(faces[i - 1], faces[i - 2].mIndices[1], i);
-                    }
-                    if (prim.mode == PrimitiveMode_LINE_LOOP) { // close the loop
-                        SetFace(faces[count - 1], faces[count - 2].mIndices[1], faces[0].mIndices[0]);
-                    }
-                    break;
-                }
-
-                case PrimitiveMode_TRIANGLES: {
-                    nFaces = count / 3;
-                    faces = new aiFace[nFaces];
-                    for (unsigned int i = 0; i < count; i += 3) {
-                        SetFace(faces[i / 3], i, i + 1, i + 2);
-                    }
-                    break;
-                }
-                case PrimitiveMode_TRIANGLE_STRIP: {
-                    nFaces = count - 2;
-                    faces = new aiFace[nFaces];
-                    for (unsigned int i = 0; i < nFaces; ++i) {
-                        //The ordering is to ensure that the triangles are all drawn with the same orientation
-                        if ((i+1) % 2 == 0)
-                        {
-                            //For even n, vertices n + 1, n, and n + 2 define triangle n
-                            SetFace(faces[i], i+1, i, i+2);
-                        }
-                        else
-                        {
-                            //For odd n, vertices n, n+1, and n+2 define triangle n
-                            SetFace(faces[i], i, i+1, i+2);
-                        }
-                    }
-                    break;
-                }
-                case PrimitiveMode_TRIANGLE_FAN:
-                    nFaces = count - 2;
-                    faces = new aiFace[nFaces];
-                    SetFace(faces[0], 0, 1, 2);
-                    for (unsigned int i = 1; i < nFaces; ++i) {
-                        SetFace(faces[i], faces[0].mIndices[0], faces[i - 1].mIndices[2], i + 2);
-                    }
-                    break;
-                }
-            }
-
-            if (faces) {
-                aim->mFaces = faces;
-                aim->mNumFaces = static_cast<unsigned int>(nFaces);
-                ai_assert(CheckValidFacesIndices(faces, static_cast<unsigned>(nFaces), aim->mNumVertices));
-            }
-
-            if (prim.material) {
-                aim->mMaterialIndex = prim.material.GetIndex();
-            }
-            else {
-                aim->mMaterialIndex = mScene->mNumMaterials - 1;
-            }
-
-        }
-    }
-
-    meshOffsets.push_back(k);
-
-    CopyVector(meshes, mScene->mMeshes, mScene->mNumMeshes);
-}
-
-void glTF2Importer::ImportCameras(glTF2::Asset& r)
-{
-    if (!r.cameras.Size()) return;
-
-    mScene->mNumCameras = r.cameras.Size();
-    mScene->mCameras = new aiCamera*[r.cameras.Size()];
-
-    for (size_t i = 0; i < r.cameras.Size(); ++i) {
-        Camera& cam = r.cameras[i];
-
-        aiCamera* aicam = mScene->mCameras[i] = new aiCamera();
-
-        // cameras point in -Z by default, rest is specified in node transform
-        aicam->mLookAt = aiVector3D(0.f,0.f,-1.f);
-
-        if (cam.type == Camera::Perspective) {
-
-            aicam->mAspect        = cam.cameraProperties.perspective.aspectRatio;
-            aicam->mHorizontalFOV = cam.cameraProperties.perspective.yfov * ((aicam->mAspect == 0.f) ? 1.f : aicam->mAspect);
-            aicam->mClipPlaneFar  = cam.cameraProperties.perspective.zfar;
-            aicam->mClipPlaneNear = cam.cameraProperties.perspective.znear;
-        } else {
-            aicam->mClipPlaneFar = cam.cameraProperties.ortographic.zfar;
-            aicam->mClipPlaneNear = cam.cameraProperties.ortographic.znear;
-            aicam->mHorizontalFOV = 0.0;
-            aicam->mAspect = 1.0f;
-            if (0.f != cam.cameraProperties.ortographic.ymag ) {
-                aicam->mAspect = cam.cameraProperties.ortographic.xmag / cam.cameraProperties.ortographic.ymag;
-            }
-        }
-    }
-}
-
-void glTF2Importer::ImportLights(glTF2::Asset& r)
-{
-    if (!r.lights.Size())
-        return;
-
-    mScene->mNumLights = r.lights.Size();
-    mScene->mLights = new aiLight*[r.lights.Size()];
-
-    for (size_t i = 0; i < r.lights.Size(); ++i) {
-        Light& light = r.lights[i];
-
-        aiLight* ail = mScene->mLights[i] = new aiLight();
-
-        switch (light.type)
-        {
-        case Light::Directional:
-            ail->mType = aiLightSource_DIRECTIONAL; break;
-        case Light::Point:
-            ail->mType = aiLightSource_POINT; break;
-        case Light::Spot:
-            ail->mType = aiLightSource_SPOT; break;
-        }
-
-        if (ail->mType != aiLightSource_POINT)
-        {
-            ail->mDirection = aiVector3D(0.0f, 0.0f, -1.0f);
-            ail->mUp = aiVector3D(0.0f, 1.0f, 0.0f);
-        }
-
-        vec3 colorWithIntensity = { light.color[0] * light.intensity, light.color[1] * light.intensity, light.color[2] * light.intensity };
-        CopyValue(colorWithIntensity, ail->mColorAmbient);
-        CopyValue(colorWithIntensity, ail->mColorDiffuse);
-        CopyValue(colorWithIntensity, ail->mColorSpecular);
-
-        if (ail->mType == aiLightSource_DIRECTIONAL)
-        {
-            ail->mAttenuationConstant = 1.0;
-            ail->mAttenuationLinear = 0.0;
-            ail->mAttenuationQuadratic = 0.0;
-        }
-        else
-        {
-            //in PBR attenuation is calculated using inverse square law which can be expressed
-            //using assimps equation: 1/(att0 + att1 * d + att2 * d*d) with the following parameters
-            //this is correct equation for the case when range (see
-            //https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_lights_punctual)
-            //is not present. When range is not present it is assumed that it is infinite and so numerator is 1.
-            //When range is present then numerator might be any value in range [0,1] and then assimps equation
-            //will not suffice. In this case range is added into metadata in ImportNode function
-            //and its up to implementation to read it when it wants to
-            ail->mAttenuationConstant = 0.0;
-            ail->mAttenuationLinear = 0.0;
-            ail->mAttenuationQuadratic = 1.0;
-        }
-
-        if (ail->mType == aiLightSource_SPOT)
-        {
-            ail->mAngleInnerCone = light.innerConeAngle;
-            ail->mAngleOuterCone = light.outerConeAngle;
-        }
-    }
-}
-
-static void GetNodeTransform(aiMatrix4x4& matrix, const glTF2::Node& node) {
-    if (node.matrix.isPresent) {
-        CopyValue(node.matrix.value, matrix);
-    }
-    else {
-        if (node.translation.isPresent) {
-            aiVector3D trans;
-            CopyValue(node.translation.value, trans);
-            aiMatrix4x4 t;
-            aiMatrix4x4::Translation(trans, t);
-            matrix = matrix * t;
-        }
-
-        if (node.rotation.isPresent) {
-            aiQuaternion rot;
-            CopyValue(node.rotation.value, rot);
-            matrix = matrix * aiMatrix4x4(rot.GetMatrix());
-        }
-
-        if (node.scale.isPresent) {
-            aiVector3D scal(1.f);
-            CopyValue(node.scale.value, scal);
-            aiMatrix4x4 s;
-            aiMatrix4x4::Scaling(scal, s);
-            matrix = matrix * s;
-        }
-    }
-}
-
-static void BuildVertexWeightMapping(Mesh::Primitive& primitive, std::vector<std::vector<aiVertexWeight>>& map)
-{
-    Mesh::Primitive::Attributes& attr = primitive.attributes;
-    if (attr.weight.empty() || attr.joint.empty()) {
-        return;
-    }
-    if (attr.weight[0]->count != attr.joint[0]->count) {
-        return;
-    }
-
-    size_t num_vertices = attr.weight[0]->count;
-
-    struct Weights { float values[4]; };
-    Weights* weights = nullptr;
-    attr.weight[0]->ExtractData(weights);
-
-    struct Indices8 { uint8_t values[4]; };
-    struct Indices16 { uint16_t values[4]; };
-    Indices8* indices8 = nullptr;
-    Indices16* indices16 = nullptr;
-    if (attr.joint[0]->GetElementSize() == 4) {
-        attr.joint[0]->ExtractData(indices8);
-    }else {
-        attr.joint[0]->ExtractData(indices16);
-    }
-    // 
-    if (nullptr == indices8 && nullptr == indices16) {
-        // Something went completely wrong!
-        ai_assert(false);
-        return;
-    }
-
-    for (size_t i = 0; i < num_vertices; ++i) {
-        for (int j = 0; j < 4; ++j) {
-            const unsigned int bone = (indices8!=nullptr) ? indices8[i].values[j] : indices16[i].values[j];
-            const float weight = weights[i].values[j];
-            if (weight > 0 && bone < map.size()) {
-                map[bone].reserve(8);
-                map[bone].emplace_back(static_cast<unsigned int>(i), weight);
-            }
-        }
-    }
-
-    delete[] weights;
-    delete[] indices8;
-    delete[] indices16;
-}
-
-static std::string GetNodeName(const Node& node)
-{
-    return node.name.empty() ? node.id : node.name;
-}
-
-aiNode* ImportNode(aiScene* pScene, glTF2::Asset& r, std::vector<unsigned int>& meshOffsets, glTF2::Ref<glTF2::Node>& ptr)
-{
-    Node& node = *ptr;
-
-    aiNode* ainode = new aiNode(GetNodeName(node));
-
-    if (!node.children.empty()) {
-        ainode->mNumChildren = unsigned(node.children.size());
-        ainode->mChildren = new aiNode*[ainode->mNumChildren];
-
-        for (unsigned int i = 0; i < ainode->mNumChildren; ++i) {
-            aiNode* child = ImportNode(pScene, r, meshOffsets, node.children[i]);
-            child->mParent = ainode;
-            ainode->mChildren[i] = child;
-        }
-    }
-
-    GetNodeTransform(ainode->mTransformation, node);
-
-    if (!node.meshes.empty()) {
-        // GLTF files contain at most 1 mesh per node.
-        assert(node.meshes.size() == 1);
-        int mesh_idx = node.meshes[0].GetIndex();
-        int count = meshOffsets[mesh_idx + 1] - meshOffsets[mesh_idx];
-
-        ainode->mNumMeshes = count;
-        ainode->mMeshes = new unsigned int[count];
-
-        if (node.skin) {
-            for (int primitiveNo = 0; primitiveNo < count; ++primitiveNo) {
-                aiMesh* mesh = pScene->mMeshes[meshOffsets[mesh_idx]+primitiveNo];
-                mesh->mNumBones = static_cast<unsigned int>(node.skin->jointNames.size());
-                mesh->mBones = new aiBone*[mesh->mNumBones];
-
-                // GLTF and Assimp choose to store bone weights differently.
-                // GLTF has each vertex specify which bones influence the vertex.
-                // Assimp has each bone specify which vertices it has influence over.
-                // To convert this data, we first read over the vertex data and pull
-                // out the bone-to-vertex mapping.  Then, when creating the aiBones,
-                // we copy the bone-to-vertex mapping into the bone.  This is unfortunate
-                // both because it's somewhat slow and because, for many applications,
-                // we then need to reconvert the data back into the vertex-to-bone
-                // mapping which makes things doubly-slow.
-                std::vector<std::vector<aiVertexWeight>> weighting(mesh->mNumBones);
-                BuildVertexWeightMapping(node.meshes[0]->primitives[primitiveNo], weighting);
-
-                mat4* pbindMatrices = nullptr;
-                node.skin->inverseBindMatrices->ExtractData(pbindMatrices);
-
-                for (uint32_t i = 0; i < mesh->mNumBones; ++i) {
-                    aiBone* bone = new aiBone();
-
-                    Ref<Node> joint = node.skin->jointNames[i];
-                    if (!joint->name.empty()) {
-                      bone->mName = joint->name;
-                    } else {
-                      // Assimp expects each bone to have a unique name.
-                      static const std::string kDefaultName = "bone_";
-                      char postfix[10] = {0};
-                      ASSIMP_itoa10(postfix, i);
-                      bone->mName = (kDefaultName + postfix);
-                    }
-                    GetNodeTransform(bone->mOffsetMatrix, *joint);
-
-                    CopyValue(pbindMatrices[i], bone->mOffsetMatrix);
-
-                    std::vector<aiVertexWeight>& weights = weighting[i];
-
-                    bone->mNumWeights = static_cast<uint32_t>(weights.size());
-                    if (bone->mNumWeights > 0) {
-                      bone->mWeights = new aiVertexWeight[bone->mNumWeights];
-                      memcpy(bone->mWeights, weights.data(), bone->mNumWeights * sizeof(aiVertexWeight));
-                    } else {
-                      // Assimp expects all bones to have at least 1 weight.
-                      bone->mWeights = new aiVertexWeight[1];
-                      bone->mNumWeights = 1;
-                      bone->mWeights->mVertexId = 0;
-                      bone->mWeights->mWeight = 0.f;
-                    }
-                    mesh->mBones[i] = bone;
-                }
-
-                if (pbindMatrices) {
-                    delete[] pbindMatrices;
-                }
-            }
-        }
-
-        int k = 0;
-        for (unsigned int j = meshOffsets[mesh_idx]; j < meshOffsets[mesh_idx + 1]; ++j, ++k) {
-            ainode->mMeshes[k] = j;
-        }
-    }
-
-    if (node.camera) {
-        pScene->mCameras[node.camera.GetIndex()]->mName = ainode->mName;
-    }
-
-    if (node.light) {
-        pScene->mLights[node.light.GetIndex()]->mName = ainode->mName;
-
-        //range is optional - see https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_lights_punctual
-        //it is added to meta data of parent node, because there is no other place to put it
-        if (node.light->range.isPresent)
-        {
-            ainode->mMetaData = aiMetadata::Alloc(1);
-            ainode->mMetaData->Set(0, "PBR_LightRange", node.light->range.value);
-        }
-    }
-
-    return ainode;
-}
-
-void glTF2Importer::ImportNodes(glTF2::Asset& r)
-{
-    if (!r.scene) return;
-
-    std::vector< Ref<Node> > rootNodes = r.scene->nodes;
-
-    // The root nodes
-    unsigned int numRootNodes = unsigned(rootNodes.size());
-    if (numRootNodes == 1) { // a single root node: use it
-        mScene->mRootNode = ImportNode(mScene, r, meshOffsets, rootNodes[0]);
-    }
-    else if (numRootNodes > 1) { // more than one root node: create a fake root
-        aiNode* root = new aiNode("ROOT");
-        root->mChildren = new aiNode*[numRootNodes];
-        for (unsigned int i = 0; i < numRootNodes; ++i) {
-            aiNode* node = ImportNode(mScene, r, meshOffsets, rootNodes[i]);
-            node->mParent = root;
-            root->mChildren[root->mNumChildren++] = node;
-        }
-        mScene->mRootNode = root;
-    }
-
-    //if (!mScene->mRootNode) {
-    //  mScene->mRootNode = new aiNode("EMPTY");
-    //}
-}
-
-struct AnimationSamplers {
-    AnimationSamplers()
-    : translation(nullptr)
-    , rotation(nullptr)
-    , scale(nullptr) {
-        // empty
-    }
-
-    Animation::Sampler* translation;
-    Animation::Sampler* rotation;
-    Animation::Sampler* scale;
-};
-
-aiNodeAnim* CreateNodeAnim(glTF2::Asset& r, Node& node, AnimationSamplers& samplers)
-{
-    aiNodeAnim* anim = new aiNodeAnim();
-    anim->mNodeName = GetNodeName(node);
-
-    static const float kMillisecondsFromSeconds = 1000.f;
-
-    if (samplers.translation) {
-        float* times = nullptr;
-        samplers.translation->input->ExtractData(times);
-        aiVector3D* values = nullptr;
-        samplers.translation->output->ExtractData(values);
-        anim->mNumPositionKeys = static_cast<uint32_t>(samplers.translation->input->count);
-        anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys];
-        for (unsigned int i = 0; i < anim->mNumPositionKeys; ++i) {
-            anim->mPositionKeys[i].mTime = times[i] * kMillisecondsFromSeconds;
-            anim->mPositionKeys[i].mValue = values[i];
-        }
-        delete[] times;
-        delete[] values;
-    } else if (node.translation.isPresent) {
-        anim->mNumPositionKeys = 1;
-        anim->mPositionKeys = new aiVectorKey();
-        anim->mPositionKeys->mTime = 0.f;
-        anim->mPositionKeys->mValue.x = node.translation.value[0];
-        anim->mPositionKeys->mValue.y = node.translation.value[1];
-        anim->mPositionKeys->mValue.z = node.translation.value[2];
-    }
-
-    if (samplers.rotation) {
-        float* times = nullptr;
-        samplers.rotation->input->ExtractData(times);
-        aiQuaternion* values = nullptr;
-        samplers.rotation->output->ExtractData(values);
-        anim->mNumRotationKeys = static_cast<uint32_t>(samplers.rotation->input->count);
-        anim->mRotationKeys = new aiQuatKey[anim->mNumRotationKeys];
-        for (unsigned int i = 0; i < anim->mNumRotationKeys; ++i) {
-            anim->mRotationKeys[i].mTime = times[i] * kMillisecondsFromSeconds;
-            anim->mRotationKeys[i].mValue.x = values[i].w;
-            anim->mRotationKeys[i].mValue.y = values[i].x;
-            anim->mRotationKeys[i].mValue.z = values[i].y;
-            anim->mRotationKeys[i].mValue.w = values[i].z;
-        }
-        delete[] times;
-        delete[] values;
-    } else if (node.rotation.isPresent) {
-        anim->mNumRotationKeys = 1;
-        anim->mRotationKeys = new aiQuatKey[anim->mNumRotationKeys];
-        anim->mRotationKeys->mTime = 0.f;
-        anim->mRotationKeys->mValue.x = node.rotation.value[0];
-        anim->mRotationKeys->mValue.y = node.rotation.value[1];
-        anim->mRotationKeys->mValue.z = node.rotation.value[2];
-        anim->mRotationKeys->mValue.w = node.rotation.value[3];
-    }
-
-    if (samplers.scale) {
-        float* times = nullptr;
-        samplers.scale->input->ExtractData(times);
-        aiVector3D* values = nullptr;
-        samplers.scale->output->ExtractData(values);
-        anim->mNumScalingKeys = static_cast<uint32_t>(samplers.scale->input->count);
-        anim->mScalingKeys = new aiVectorKey[anim->mNumScalingKeys];
-        for (unsigned int i = 0; i < anim->mNumScalingKeys; ++i) {
-            anim->mScalingKeys[i].mTime = times[i] * kMillisecondsFromSeconds;
-            anim->mScalingKeys[i].mValue = values[i];
-        }
-        delete[] times;
-        delete[] values;
-    } else if (node.scale.isPresent) {
-        anim->mNumScalingKeys = 1;
-        anim->mScalingKeys = new aiVectorKey[anim->mNumScalingKeys];
-        anim->mScalingKeys->mTime = 0.f;
-        anim->mScalingKeys->mValue.x = node.scale.value[0];
-        anim->mScalingKeys->mValue.y = node.scale.value[1];
-        anim->mScalingKeys->mValue.z = node.scale.value[2];
-    }
-
-    return anim;
-}
-
-std::unordered_map<unsigned int, AnimationSamplers> GatherSamplers(Animation& anim)
-{
-    std::unordered_map<unsigned int, AnimationSamplers> samplers;
-    for (unsigned int c = 0; c < anim.channels.size(); ++c) {
-        Animation::Channel& channel = anim.channels[c];
-        if (channel.sampler >= static_cast<int>(anim.samplers.size())) {
-            continue;
-        }
-
-        const unsigned int node_index = channel.target.node.GetIndex();
-
-        AnimationSamplers& sampler = samplers[node_index];
-        if (channel.target.path == AnimationPath_TRANSLATION) {
-            sampler.translation = &anim.samplers[channel.sampler];
-        } else if (channel.target.path == AnimationPath_ROTATION) {
-            sampler.rotation = &anim.samplers[channel.sampler];
-        } else if (channel.target.path == AnimationPath_SCALE) {
-            sampler.scale = &anim.samplers[channel.sampler];
-        }
-    }
-
-    return samplers;
-}
-
-void glTF2Importer::ImportAnimations(glTF2::Asset& r)
-{
-    if (!r.scene) return;
-
-    mScene->mNumAnimations = r.animations.Size();
-    if (mScene->mNumAnimations == 0) {
-        return;
-    }
-
-    mScene->mAnimations = new aiAnimation*[mScene->mNumAnimations];
-    for (unsigned int i = 0; i < r.animations.Size(); ++i) {
-        Animation& anim = r.animations[i];
-
-        aiAnimation* ai_anim = new aiAnimation();
-        ai_anim->mName = anim.name;
-        ai_anim->mDuration = 0;
-        ai_anim->mTicksPerSecond = 0;
-
-        std::unordered_map<unsigned int, AnimationSamplers> samplers = GatherSamplers(anim);
-
-        ai_anim->mNumChannels = static_cast<uint32_t>(samplers.size());
-        if (ai_anim->mNumChannels > 0) {
-            ai_anim->mChannels = new aiNodeAnim*[ai_anim->mNumChannels];
-            int j = 0;
-            for (auto& iter : samplers) {
-                ai_anim->mChannels[j] = CreateNodeAnim(r, r.nodes[iter.first], iter.second);
-                ++j;
-            }
-        }
-
-        // Use the latest keyframe for the duration of the animation
-        double maxDuration = 0;
-        unsigned int maxNumberOfKeys = 0;
-        for (unsigned int j = 0; j < ai_anim->mNumChannels; ++j) {
-            auto chan = ai_anim->mChannels[j];
-            if (chan->mNumPositionKeys) {
-                auto lastPosKey = chan->mPositionKeys[chan->mNumPositionKeys - 1];
-                if (lastPosKey.mTime > maxDuration) {
-                    maxDuration = lastPosKey.mTime;
-                }
-                maxNumberOfKeys = std::max(maxNumberOfKeys, chan->mNumPositionKeys);
-            }
-            if (chan->mNumRotationKeys) {
-                auto lastRotKey = chan->mRotationKeys[chan->mNumRotationKeys - 1];
-                if (lastRotKey.mTime > maxDuration) {
-                    maxDuration = lastRotKey.mTime;
-                }
-                maxNumberOfKeys = std::max(maxNumberOfKeys, chan->mNumRotationKeys);
-            }
-            if (chan->mNumScalingKeys) {
-                auto lastScaleKey = chan->mScalingKeys[chan->mNumScalingKeys - 1];
-                if (lastScaleKey.mTime > maxDuration) {
-                    maxDuration = lastScaleKey.mTime;
-                }
-                maxNumberOfKeys = std::max(maxNumberOfKeys, chan->mNumScalingKeys);
-            }
-        }
-        ai_anim->mDuration = maxDuration;
-        ai_anim->mTicksPerSecond = (maxNumberOfKeys > 0 && maxDuration > 0) ? (maxNumberOfKeys / (maxDuration/1000)) : 30;
-
-        mScene->mAnimations[i] = ai_anim;
-    }
-}
-
-void glTF2Importer::ImportEmbeddedTextures(glTF2::Asset& r)
-{
-    embeddedTexIdxs.resize(r.images.Size(), -1);
-
-    int numEmbeddedTexs = 0;
-    for (size_t i = 0; i < r.images.Size(); ++i) {
-        if (r.images[i].HasData())
-            numEmbeddedTexs += 1;
-    }
-
-    if (numEmbeddedTexs == 0)
-        return;
-
-    mScene->mTextures = new aiTexture*[numEmbeddedTexs];
-
-    // Add the embedded textures
-    for (size_t i = 0; i < r.images.Size(); ++i) {
-        Image &img = r.images[i];
-        if (!img.HasData()) continue;
-
-        int idx = mScene->mNumTextures++;
-        embeddedTexIdxs[i] = idx;
-
-        aiTexture* tex = mScene->mTextures[idx] = new aiTexture();
-
-        size_t length = img.GetDataLength();
-        void* data = img.StealData();
-
-        tex->mWidth = static_cast<unsigned int>(length);
-        tex->mHeight = 0;
-        tex->pcData = reinterpret_cast<aiTexel*>(data);
-
-        if (!img.mimeType.empty()) {
-            const char* ext = strchr(img.mimeType.c_str(), '/') + 1;
-            if (ext) {
-                if (strcmp(ext, "jpeg") == 0) ext = "jpg";
-
-                size_t len = strlen(ext);
-                if (len <= 3) {
-                    strcpy(tex->achFormatHint, ext);
-                }
-            }
-        }
-    }
-}
-
-void glTF2Importer::InternReadFile(const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler)
-{
-    // clean all member arrays
-    meshOffsets.clear();
-    embeddedTexIdxs.clear();
-
-    this->mScene = pScene;
-
-    // read the asset file
-    glTF2::Asset asset(pIOHandler);
-    asset.Load(pFile, GetExtension(pFile) == "glb");
-
-    //
-    // Copy the data out
-    //
-
-    ImportEmbeddedTextures(asset);
-    ImportMaterials(asset);
-
-    ImportMeshes(asset);
-
-    ImportCameras(asset);
-    ImportLights(asset);
-
-    ImportNodes(asset);
-
-    ImportAnimations(asset);
-
-    if (pScene->mNumMeshes == 0) {
-        pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
-    }
-}
-
-#endif // ASSIMP_BUILD_NO_GLTF_IMPORTER
-
diff --git a/Engine/lib/assimp/code/res/assimp.rc b/Engine/lib/assimp/code/res/assimp.rc
index daecf9cf5..9ae821b4b 100644
--- a/Engine/lib/assimp/code/res/assimp.rc
+++ b/Engine/lib/assimp/code/res/assimp.rc
@@ -52,7 +52,7 @@ BEGIN
             VALUE "FileDescription", "Open Asset Import Library"
             VALUE "FileVersion", VER_FILEVERSION
             VALUE "InternalName", "assimp "
-            VALUE "LegalCopyright", "Copyright (C) 2006-2019"
+            VALUE "LegalCopyright", "Copyright (C) 2006-2020"
             VALUE "OriginalFilename", VER_ORIGINAL_FILENAME_STR
             VALUE "ProductName", "Open Asset Import Library"
             VALUE "ProductVersion", VER_FILEVERSION_STR
diff --git a/Engine/lib/assimp/contrib/CMakeLists.txt b/Engine/lib/assimp/contrib/CMakeLists.txt
deleted file mode 100644
index 362f1653d..000000000
--- a/Engine/lib/assimp/contrib/CMakeLists.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-# Compile internal irrXML only if system is not requested
-if( NOT SYSTEM_IRRXML )
-    add_subdirectory(irrXML)
-endif( NOT SYSTEM_IRRXML )
diff --git a/Engine/lib/assimp/contrib/Open3DGC/o3dgcArithmeticCodec.cpp b/Engine/lib/assimp/contrib/Open3DGC/o3dgcArithmeticCodec.cpp
index 3597ec39a..2ae70fa2e 100644
--- a/Engine/lib/assimp/contrib/Open3DGC/o3dgcArithmeticCodec.cpp
+++ b/Engine/lib/assimp/contrib/Open3DGC/o3dgcArithmeticCodec.cpp
@@ -522,8 +522,7 @@ namespace o3dgc
 
       buffer_size = max_code_bytes;                           // assign new memory
       delete [] new_buffer;                   // free anything previously assigned
-      if ((new_buffer = new unsigned char[buffer_size+16]) == 0) // 16 extra bytes
-        AC_Error("cannot assign memory for compressed data buffer");
+      new_buffer = new unsigned char[buffer_size+16];        // 16 extra bytes
       code_buffer = new_buffer;                  // set buffer for compressed data
     }
 
@@ -732,7 +731,6 @@ namespace o3dgc
           table_size = table_shift = 0;
           distribution = new unsigned[data_symbols];
         }
-        if (distribution == 0) AC_Error("cannot assign model memory");
       }
                                  // compute cumulative distribution, decoder table
       unsigned s = 0;
@@ -803,7 +801,6 @@ namespace o3dgc
           distribution = new unsigned[2*data_symbols];
         }
         symbol_count = distribution + data_symbols;
-        if (distribution == 0) AC_Error("cannot assign model memory");
       }
 
       reset();                                                 // initialize model
diff --git a/Engine/lib/assimp/contrib/Open3DGC/o3dgcArithmeticCodec.h b/Engine/lib/assimp/contrib/Open3DGC/o3dgcArithmeticCodec.h
index d3cf6d14a..6c1fb0645 100644
--- a/Engine/lib/assimp/contrib/Open3DGC/o3dgcArithmeticCodec.h
+++ b/Engine/lib/assimp/contrib/Open3DGC/o3dgcArithmeticCodec.h
@@ -75,6 +75,7 @@ OF SUCH DAMAGE.
 
 #include <stdio.h>
 #include "o3dgcCommon.h"
+#include <assimp/defs.h>
 
 namespace o3dgc
 {
diff --git a/Engine/lib/assimp/contrib/Open3DGC/o3dgcSC3DMCDecoder.h b/Engine/lib/assimp/contrib/Open3DGC/o3dgcSC3DMCDecoder.h
index f3f1617c4..e6f803b94 100644
--- a/Engine/lib/assimp/contrib/Open3DGC/o3dgcSC3DMCDecoder.h
+++ b/Engine/lib/assimp/contrib/Open3DGC/o3dgcSC3DMCDecoder.h
@@ -1,4 +1,4 @@
-/*
+/*
 Copyright (c) 2013 Khaled Mammou - Advanced Micro Devices, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
diff --git a/Engine/lib/assimp/contrib/Open3DGC/o3dgcSC3DMCDecoder.inl b/Engine/lib/assimp/contrib/Open3DGC/o3dgcSC3DMCDecoder.inl
index aa6f24b73..8bd85f27b 100644
--- a/Engine/lib/assimp/contrib/Open3DGC/o3dgcSC3DMCDecoder.inl
+++ b/Engine/lib/assimp/contrib/Open3DGC/o3dgcSC3DMCDecoder.inl
@@ -27,6 +27,11 @@ THE SOFTWARE.
 #include "o3dgcArithmeticCodec.h"
 #include "o3dgcTimer.h"
 
+#ifdef _MSC_VER
+#    pragma warning(push)
+#    pragma warning( disable : 4456)
+#endif // _MSC_VER
+
 //#define DEBUG_VERBOSE
 
 namespace o3dgc
@@ -67,9 +72,12 @@ namespace o3dgc
         unsigned char mask = bstream.ReadUChar(m_iterator, m_streamType);
 
         ifs.SetCCW             ((mask & 1) == 1);
-        ifs.SetSolid           ((mask & 2) == 1);
-        ifs.SetConvex          ((mask & 4) == 1);
-        ifs.SetIsTriangularMesh((mask & 8) == 1);
+        // (mask & 2) == 1
+        ifs.SetSolid           (false);
+        // (mask & 4) == 1
+        ifs.SetConvex          (false);
+        // (mask & 8) == 1
+        ifs.SetIsTriangularMesh(false);
         //bool markerBit0 = (mask & 16 ) == 1;
         //bool markerBit1 = (mask & 32 ) == 1;
         //bool markerBit2 = (mask & 64 ) == 1;
@@ -836,15 +844,18 @@ namespace o3dgc
         }        
         for(unsigned long v = 0; v < numFloatArray; ++v)
         {
-            for(unsigned long d = 0; d < dimFloatArray; ++d)
-            {
-//                floatArray[v * stride + d] = m_quantFloatArray[v * stride + d];
-                floatArray[v * stride + d] = m_quantFloatArray[v * stride + d] * idelta[d] + minFloatArray[d];
+            for(unsigned long d = 0; d < dimFloatArray; ++d) {
+                 floatArray[v * stride + d] = m_quantFloatArray[v * stride + d] * idelta[d] + minFloatArray[d];
             }
         }
         return O3DGC_OK;
     }
-}
+} // namespace o3dgc
+
+#ifdef _MSC_VER
+#    pragma warning( pop )
+#endif // _MSC_VER
+
 #endif // O3DGC_SC3DMC_DECODER_INL
 
 
diff --git a/Engine/lib/assimp/contrib/Open3DGC/o3dgcSC3DMCEncoder.inl b/Engine/lib/assimp/contrib/Open3DGC/o3dgcSC3DMCEncoder.inl
index 2d30b05a2..ca1e0ea76 100644
--- a/Engine/lib/assimp/contrib/Open3DGC/o3dgcSC3DMCEncoder.inl
+++ b/Engine/lib/assimp/contrib/Open3DGC/o3dgcSC3DMCEncoder.inl
@@ -24,7 +24,6 @@ THE SOFTWARE.
 #ifndef O3DGC_SC3DMC_ENCODER_INL
 #define O3DGC_SC3DMC_ENCODER_INL
 
-
 #include "o3dgcArithmeticCodec.h"
 #include "o3dgcTimer.h"
 #include "o3dgcVector.h"
@@ -33,6 +32,11 @@ THE SOFTWARE.
 
 //#define DEBUG_VERBOSE
 
+#ifdef _MSC_VER
+#    pragma warning(push)
+#    pragma warning(disable : 4456)
+#endif // _MSC_VER
+
 namespace o3dgc
 {
 #ifdef DEBUG_VERBOSE
@@ -247,8 +251,8 @@ namespace o3dgc
 
         if (predMode == O3DGC_SC3DMC_SURF_NORMALS_PREDICTION)
         {
-            const Real minFloatArray[2] = {(Real)(-2.0),(Real)(-2.0)};
-            const Real maxFloatArray[2] = {(Real)(2.0),(Real)(2.0)};
+            const Real curMinFloatArray[2] = {(Real)(-2.0),(Real)(-2.0)};
+            const Real curMaxFloatArray[2] = {(Real)(2.0),(Real)(2.0)};
             if (m_streamType == O3DGC_STREAM_TYPE_ASCII)
             {
                 for(unsigned long i = 0; i < numFloatArray; ++i)
@@ -264,7 +268,7 @@ namespace o3dgc
                     ace.encode(IntToUInt(m_predictors[i]), dModel);
                 }
             }
-            QuantizeFloatArray(floatArray, numFloatArray, dimFloatArray, stride, minFloatArray, maxFloatArray, nQBits+1);
+            QuantizeFloatArray(floatArray, numFloatArray, dimFloatArray, stride, curMinFloatArray, curMaxFloatArray, nQBits + 1);
         }
         else
         {
@@ -921,7 +925,12 @@ namespace o3dgc
 #endif //DEBUG_VERBOSE
         return O3DGC_OK;
     }
-}
+} // namespace o3dgc
+
+#ifdef _MSC_VER
+#    pragma warning(pop)
+#endif // _MSC_VER
+
 #endif // O3DGC_SC3DMC_ENCODER_INL
 
 
diff --git a/Engine/lib/assimp/contrib/Open3DGC/o3dgcTimer.h b/Engine/lib/assimp/contrib/Open3DGC/o3dgcTimer.h
index d9a285968..f5ed0c83f 100644
--- a/Engine/lib/assimp/contrib/Open3DGC/o3dgcTimer.h
+++ b/Engine/lib/assimp/contrib/Open3DGC/o3dgcTimer.h
@@ -28,7 +28,9 @@ THE SOFTWARE.
 
 #ifdef _WIN32
 /* Thank you, Microsoft, for file WinDef.h with min/max redefinition. */
+#ifndef NOMINMAX
 #define NOMINMAX
+#endif
 #include <windows.h>
 #elif __APPLE__
 #include <mach/clock.h>
diff --git a/Engine/lib/assimp/contrib/Open3DGC/o3dgcTriangleListEncoder.inl b/Engine/lib/assimp/contrib/Open3DGC/o3dgcTriangleListEncoder.inl
index 017dd86bf..9ae65c81f 100644
--- a/Engine/lib/assimp/contrib/Open3DGC/o3dgcTriangleListEncoder.inl
+++ b/Engine/lib/assimp/contrib/Open3DGC/o3dgcTriangleListEncoder.inl
@@ -353,9 +353,9 @@ namespace o3dgc
                 m_ctfans.PushTriangleIndex(pred);
                 prev = m_tmap[t] + 1;
             }
-            for (long t = 0; t < numTriangles; ++t)
+            for (long tt = 0; tt < numTriangles; ++tt)
             {
-                m_invTMap[m_tmap[t]] = t;
+                m_invTMap[m_tmap[tt]] = tt;
             }
         }
         m_ctfans.Save(bstream, encodeTrianglesOrder, m_streamType);
diff --git a/Engine/lib/assimp/contrib/Open3DGC/o3dgcVector.inl b/Engine/lib/assimp/contrib/Open3DGC/o3dgcVector.inl
index 5549b00ce..de8dfd5f1 100644
--- a/Engine/lib/assimp/contrib/Open3DGC/o3dgcVector.inl
+++ b/Engine/lib/assimp/contrib/Open3DGC/o3dgcVector.inl
@@ -175,7 +175,7 @@ namespace o3dgc
         m_data[2] = rhs.m_data[2];
     }
     template <typename T>
-    inline Vec3<T>::~Vec3(void){};
+    inline Vec3<T>::~Vec3(void){}
 
     template <typename T>
     inline Vec3<T>::Vec3() {}
@@ -308,7 +308,7 @@ namespace o3dgc
         m_data[1] = rhs.m_data[1];
     }
     template <typename T>
-    inline Vec2<T>::~Vec2(void){};
+    inline Vec2<T>::~Vec2(void){}
 
     template <typename T>
     inline Vec2<T>::Vec2() {}
diff --git a/Engine/lib/assimp/contrib/android-cmake/README.md b/Engine/lib/assimp/contrib/android-cmake/README.md
index ee6302128..395131daf 100644
--- a/Engine/lib/assimp/contrib/android-cmake/README.md
+++ b/Engine/lib/assimp/contrib/android-cmake/README.md
@@ -237,4 +237,4 @@ The _android-cmake_ should correctly handle projects with assembler sources (`*.
 
 ## Copying
 
-_android-cmake_ is distributed under the terms of [BSD 3-Clause License](http://opensource.org/licenses/BSD-3-Clause)
\ No newline at end of file
+_android-cmake_ is distributed under the terms of [BSD 3-Clause License](http://opensource.org/licenses/BSD-3-Clause)
diff --git a/Engine/lib/assimp/contrib/android-cmake/android.toolchain.cmake b/Engine/lib/assimp/contrib/android-cmake/android.toolchain.cmake
index ffa26126a..c2b8a0730 100644
--- a/Engine/lib/assimp/contrib/android-cmake/android.toolchain.cmake
+++ b/Engine/lib/assimp/contrib/android-cmake/android.toolchain.cmake
@@ -1616,6 +1616,7 @@ endif()
 if( CMAKE_GENERATOR MATCHES "Ninja" AND CMAKE_HOST_WIN32 )
  # it is a bad hack after all
  # CMake generates Ninja makefiles with UNIX paths only if it thinks that we are going to build with MinGW
+ set( MINGW TRUE ) # tell CMake that we are MinGW
  set( CMAKE_COMPILER_IS_MINGW TRUE ) # tell CMake that we are MinGW
  set( CMAKE_CROSSCOMPILING TRUE )    # stop recursion
  enable_language( C )
diff --git a/Engine/lib/assimp/contrib/draco/.clang-format b/Engine/lib/assimp/contrib/draco/.clang-format
new file mode 100644
index 000000000..533d35e6d
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/.clang-format
@@ -0,0 +1,5 @@
+---
+Language:        Cpp
+BasedOnStyle: Google
+PointerAlignment: Right
+...
diff --git a/Engine/lib/assimp/contrib/draco/.cmake-format.py b/Engine/lib/assimp/contrib/draco/.cmake-format.py
new file mode 100644
index 000000000..64f2495b4
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/.cmake-format.py
@@ -0,0 +1,102 @@
+# Generated with cmake-format 0.5.1
+# How wide to allow formatted cmake files
+line_width = 80
+
+# How many spaces to tab for indent
+tab_size = 2
+
+# If arglists are longer than this, break them always
+max_subargs_per_line = 10
+
+# If true, separate flow control names from their parentheses with a space
+separate_ctrl_name_with_space = False
+
+# If true, separate function names from parentheses with a space
+separate_fn_name_with_space = False
+
+# If a statement is wrapped to more than one line, than dangle the closing
+# parenthesis on its own line
+dangle_parens = False
+
+# What character to use for bulleted lists
+bullet_char = '*'
+
+# What character to use as punctuation after numerals in an enumerated list
+enum_char = '.'
+
+# What style line endings to use in the output.
+line_ending = u'unix'
+
+# Format command names consistently as 'lower' or 'upper' case
+command_case = u'lower'
+
+# Format keywords consistently as 'lower' or 'upper' case
+keyword_case = u'unchanged'
+
+# Specify structure for custom cmake functions
+additional_commands = {
+  "foo": {
+    "flags": [
+      "BAR",
+      "BAZ"
+    ],
+    "kwargs": {
+      "HEADERS": "*",
+      "DEPENDS": "*",
+      "SOURCES": "*"
+    }
+  }
+}
+
+# A list of command names which should always be wrapped
+always_wrap = []
+
+# Specify the order of wrapping algorithms during successive reflow attempts
+algorithm_order = [0, 1, 2, 3, 4]
+
+# If true, the argument lists which are known to be sortable will be sorted
+# lexicographicall
+autosort = False
+
+# enable comment markup parsing and reflow
+enable_markup = True
+
+# If comment markup is enabled, don't reflow the first comment block in
+# eachlistfile. Use this to preserve formatting of your
+# copyright/licensestatements.
+first_comment_is_literal = False
+
+# If comment markup is enabled, don't reflow any comment block which matchesthis
+# (regex) pattern. Default is `None` (disabled).
+literal_comment_pattern = None
+
+# Regular expression to match preformat fences in comments
+# default=r'^\s*([`~]{3}[`~]*)(.*)$'
+fence_pattern = u'^\\s*([`~]{3}[`~]*)(.*)$'
+
+# Regular expression to match rulers in comments
+# default=r'^\s*[^\w\s]{3}.*[^\w\s]{3}$'
+ruler_pattern = u'^\\s*[^\\w\\s]{3}.*[^\\w\\s]{3}$'
+
+# If true, emit the unicode byte-order mark (BOM) at the start of the file
+emit_byteorder_mark = False
+
+# If a comment line starts with at least this many consecutive hash characters,
+# then don't lstrip() them off. This allows for lazy hash rulers where the first
+# hash char is not separated by space
+hashruler_min_length = 10
+
+# If true, then insert a space between the first hash char and remaining hash
+# chars in a hash ruler, and normalize its length to fill the column
+canonicalize_hashrulers = True
+
+# Specify the encoding of the input file. Defaults to utf-8.
+input_encoding = u'utf-8'
+
+# Specify the encoding of the output file. Defaults to utf-8. Note that cmake
+# only claims to support utf-8 so be careful when using anything else
+output_encoding = u'utf-8'
+
+# A dictionary containing any per-command configuration overrides. Currently
+# only `command_case` is supported.
+per_command = {}
diff --git a/Engine/lib/assimp/contrib/draco/AUTHORS b/Engine/lib/assimp/contrib/draco/AUTHORS
new file mode 100644
index 000000000..67f63a671
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/AUTHORS
@@ -0,0 +1,7 @@
+# This is the list of Draco authors for copyright purposes.
+#
+# This does not necessarily list everyone who has contributed code, since in
+# some cases, their employer may be the copyright holder.  To see the full list
+# of contributors, see the revision history in source control.
+Google Inc.
+and other contributors
diff --git a/Engine/lib/assimp/contrib/draco/BUILDING.md b/Engine/lib/assimp/contrib/draco/BUILDING.md
new file mode 100644
index 000000000..d33917b88
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/BUILDING.md
@@ -0,0 +1,301 @@
+_**Contents**_
+
+  * [CMake Basics](#cmake-basics)
+  * [Mac OS X](#mac-os-x)
+  * [Windows](#windows)
+  * [CMake Build Configuration](#cmake-build-configuration)
+    * [Debugging and Optimization](#debugging-and-optimization)
+    * [Googletest Integration](#googletest-integration)
+    * [Javascript Encoder/Decoder](#javascript-encoderdecoder)
+    * [WebAssembly Decoder](#webassembly-decoder)
+    * [WebAssembly Mesh Only Decoder](#webassembly-mesh-only-decoder)
+    * [WebAssembly Point Cloud Only Decoder](#webassembly-point-cloud-only-decoder)
+    * [iOS Builds](#ios-builds)
+  * [Android Studio Project Integration](#android-studio-project-integration)
+  * [Native Android Builds](#native-android-builds)
+  * [vcpkg](#vcpkg)
+
+Building
+========
+For all platforms, you must first generate the project/make files and then
+compile the examples.
+
+CMake Basics
+------------
+
+To generate project/make files for the default toolchain on your system, run
+`cmake` from a directory where you would like to generate build files, and pass
+it the path to your Draco repository.
+
+E.g. Starting from Draco root.
+
+~~~~~ bash
+$ mkdir build_dir && cd build_dir
+$ cmake ../
+~~~~~
+
+On Windows, the above command will produce Visual Studio project files for the
+newest Visual Studio detected on the system. On Mac OS X and Linux systems,
+the above command will produce a `makefile`.
+
+To control what types of projects are generated, add the `-G` parameter to the
+`cmake` command. This argument must be followed by the name of a generator.
+Running `cmake` with the `--help` argument will list the available
+generators for your system.
+
+Mac OS X
+---------
+
+On Mac OS X, run the following command to generate Xcode projects:
+
+~~~~~ bash
+$ cmake ../ -G Xcode
+~~~~~
+
+Windows
+-------
+
+On a Windows box you would run the following command to generate Visual Studio
+2019 projects:
+
+~~~~~ bash
+C:\Users\nobody> cmake ../ -G "Visual Studio 16 2019" -A Win32
+~~~~~
+
+To generate 64-bit Windows Visual Studio 2019 projects:
+
+~~~~~ bash
+C:\Users\nobody> cmake ../ -G "Visual Studio 16 2019" -A x64
+~~~~~
+
+
+CMake Build Configuration
+-------------------------
+
+Debugging and Optimization
+--------------------------
+
+Unlike Visual Studio and Xcode projects, the build configuration for make
+builds is controlled when you run `cmake`. The following examples demonstrate
+various build configurations.
+
+Omitting the build type produces makefiles that use release build flags
+by default:
+
+~~~~~ bash
+$ cmake ../
+~~~~~
+
+A makefile using release (optimized) flags is produced like this:
+
+~~~~~ bash
+$ cmake ../ -DCMAKE_BUILD_TYPE=Release
+~~~~~
+
+A release build with debug info can be produced as well:
+
+~~~~~ bash
+$ cmake ../ -DCMAKE_BUILD_TYPE=RelWithDebInfo
+~~~~~
+
+And your standard debug build will be produced using:
+
+~~~~~ bash
+$ cmake ../ -DCMAKE_BUILD_TYPE=Debug
+~~~~~
+
+To enable the use of sanitizers when the compiler in use supports them, set the
+sanitizer type when running CMake:
+
+~~~~~ bash
+$ cmake ../ -DDRACO_SANITIZE=address
+~~~~~
+
+Googletest Integration
+----------------------
+
+Draco includes testing support built using Googletest. To enable Googletest unit
+test support the DRACO_TESTS cmake variable must be turned on at cmake
+generation time:
+
+~~~~~ bash
+$ cmake ../ -DDRACO_TESTS=ON
+~~~~~
+
+When cmake is used as shown in the above example the googletest directory must
+be a sibling of the Draco repository root directory. To run the tests execute
+`draco_tests` from your build output directory.
+
+WebAssembly Decoder
+-------------------
+
+The WebAssembly decoder can be built using the existing cmake build file by
+passing the path the Emscripten's cmake toolchain file at cmake generation time
+in the CMAKE_TOOLCHAIN_FILE variable and enabling the WASM build option.
+In addition, the EMSCRIPTEN environment variable must be set to the local path
+of the parent directory of the Emscripten tools directory.
+
+~~~~~ bash
+# Make the path to emscripten available to cmake.
+$ export EMSCRIPTEN=/path/to/emscripten/tools/parent
+
+# Emscripten.cmake can be found within your Emscripten installation directory,
+# it should be the subdir: cmake/Modules/Platform/Emscripten.cmake
+$ cmake ../ -DCMAKE_TOOLCHAIN_FILE=/path/to/Emscripten.cmake -DDRACO_WASM=ON
+
+# Build the WebAssembly decoder.
+$ make
+
+# Run the Javascript wrapper through Closure.
+$ java -jar closure.jar --compilation_level SIMPLE --js draco_decoder.js --js_output_file draco_wasm_wrapper.js
+
+~~~~~
+
+WebAssembly Mesh Only Decoder
+-----------------------------
+
+~~~~~ bash
+
+# cmake command line for mesh only WebAssembly decoder.
+$ cmake ../ -DCMAKE_TOOLCHAIN_FILE=/path/to/Emscripten.cmake -DDRACO_WASM=ON -DDRACO_POINT_CLOUD_COMPRESSION=OFF
+
+~~~~~
+
+WebAssembly Point Cloud Only Decoder
+-----------------------------
+
+~~~~~ bash
+
+# cmake command line for point cloud only WebAssembly decoder.
+$ cmake ../ -DCMAKE_TOOLCHAIN_FILE=/path/to/Emscripten.cmake -DDRACO_WASM=ON -DDRACO_MESH_COMPRESSION=OFF
+
+~~~~~
+
+Javascript Encoder/Decoder
+------------------
+
+The javascript encoder and decoder can be built using the existing cmake build
+file by passing the path the Emscripten's cmake toolchain file at cmake
+generation time in the CMAKE_TOOLCHAIN_FILE variable.
+In addition, the EMSCRIPTEN environment variable must be set to the local path
+of the parent directory of the Emscripten tools directory.
+
+*Note* The WebAssembly decoder should be favored over the JavaScript decoder.
+
+~~~~~ bash
+# Make the path to emscripten available to cmake.
+$ export EMSCRIPTEN=/path/to/emscripten/tools/parent
+
+# Emscripten.cmake can be found within your Emscripten installation directory,
+# it should be the subdir: cmake/Modules/Platform/Emscripten.cmake
+$ cmake ../ -DCMAKE_TOOLCHAIN_FILE=/path/to/Emscripten.cmake
+
+# Build the Javascript encoder and decoder.
+$ make
+~~~~~
+
+iOS Builds
+---------------------
+These are the basic commands needed to build Draco for iOS targets.
+~~~~~ bash
+
+#arm64
+$ cmake ../ -DCMAKE_TOOLCHAIN_FILE=../cmake/toolchains/arm64-ios.cmake
+$ make
+
+#x86_64
+$ cmake ../ -DCMAKE_TOOLCHAIN_FILE=../cmake/toolchains/x86_64-ios.cmake
+$ make
+
+#armv7
+$ cmake ../ -DCMAKE_TOOLCHAIN_FILE=../cmake/toolchains/armv7-ios.cmake
+$ make
+
+#i386
+$ cmake ../ -DCMAKE_TOOLCHAIN_FILE=../cmake/toolchains/i386-ios.cmake
+$ make
+~~~~~~
+
+After building for each target the libraries can be merged into a single
+universal/fat library using lipo, and then used in iOS applications.
+
+
+Native Android Builds
+---------------------
+
+It's sometimes useful to build Draco command line tools and run them directly on
+Android devices via adb.
+
+~~~~~ bash
+# This example is for armeabi-v7a.
+$ cmake ../ -DCMAKE_TOOLCHAIN_FILE=../cmake/toolchains/android.cmake \
+  -DDRACO_ANDROID_NDK_PATH=path/to/ndk -DANDROID_ABI=armeabi-v7a
+$ make
+
+# See the android.cmake toolchain file for additional ANDROID_ABI options and
+# other configurable Android variables.
+~~~~~
+
+After building the tools they can be moved to an android device via the use of
+`adb push`, and then run within an `adb shell` instance.
+
+
+Android Studio Project Integration
+----------------------------------
+
+Tested on Android Studio 3.5.3.
+
+
+Draco - Static Library
+----------------------
+
+To include Draco in an existing or new Android Studio project, reference it
+from the `cmake` file of an existing native project that has a minimum SDK
+version of 18 or higher. The project must support C++11.
+To add Draco to your project:
+
+  1. Create a new "Native C++" project.
+
+  2. Add the following somewhere within the `CMakeLists.txt` for your project
+     before the `add_library()` for your project's native-lib:
+
+     ~~~~~ cmake
+     # Note "/path/to/draco" must be changed to the path where you have cloned
+     # the Draco sources.
+
+     add_subdirectory(/path/to/draco
+                      ${CMAKE_BINARY_DIR}/draco_build)
+     include_directories("${CMAKE_BINARY_DIR}" /path/to/draco)
+     ~~~~~
+
+  3. Add the library target "draco" to the `target_link_libraries()` call for
+     your project's native-lib. The `target_link_libraries()` call for an
+     empty activity native project looks like this after the addition of
+     Draco:
+
+     ~~~~~ cmake
+     target_link_libraries( # Specifies the target library.
+                            native-lib
+
+                            # Tells cmake this build depends on libdraco.
+                            draco
+
+                            # Links the target library to the log library
+                            # included in the NDK.
+                            ${log-lib} )
+
+vcpkg
+---------------------
+You can download and install Draco using the
+[vcpkg](https://github.com/Microsoft/vcpkg/) dependency manager:
+
+    git clone https://github.com/Microsoft/vcpkg.git
+    cd vcpkg
+    ./bootstrap-vcpkg.sh
+    ./vcpkg integrate install
+    vcpkg install draco
+
+The Draco port in vcpkg is kept up to date by Microsoft team members and
+community contributors. If the version is out of date, please
+[create an issue or pull request](https://github.com/Microsoft/vcpkg) on the
+vcpkg repository.
diff --git a/Engine/lib/assimp/contrib/draco/CMAKE.md b/Engine/lib/assimp/contrib/draco/CMAKE.md
new file mode 100644
index 000000000..392c6ce40
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/CMAKE.md
@@ -0,0 +1,106 @@
+# CMake Build System Overview
+
+[TOC]
+
+This document provides a general layout of the Draco CMake build system.
+
+## Core Build System Files
+
+These files are listed in order of interest to maintainers of the build system.
+
+-   `CMakeLists.txt` is the main driver of the build system. It's responsible
+    for defining targets and source lists, surfacing build system options, and
+    tying the components of the build system together.
+
+-   `cmake/draco_build_definitions.cmake` defines the macro
+    `draco_set_build_definitions()`, which is called from `CMakeLists.txt` to
+    configure include paths, compiler and linker flags, library settings,
+    platform speficic configuration, and other build system settings that
+    depend on optional build configurations.
+
+-   `cmake/draco_targets.cmake` defines the macros `draco_add_library()` and
+    `draco_add_executable()` which are used to create all targets in the CMake
+    build. These macros attempt to behave in a manner that loosely mirrors the
+    blaze `cc_library()` and `cc_binary()` commands. Note that
+    `draco_add_executable()` is also used for tests.
+
+-   `cmake/draco_emscripten.cmake` handles Emscripten SDK integration. It
+    defines several Emscripten specific macros that are required to build the
+    Emscripten specific targets defined in `CMakeLists.txt`.
+
+-   `cmake/draco_flags.cmake` defines macros related to compiler and linker
+    flags. Testing macros, macros for isolating flags to specific source files,
+    and the main flag configuration function for the library are defined here.
+
+-   `cmake/draco_options.cmake` defines macros that control optional features
+    of draco, and help track draco library and build system options.
+
+-   `cmake/draco_install.cmake` defines the draco install target.
+
+-   `cmake/draco_cpu_detection.cmake` determines the optimization types to
+    enable based on target system processor as reported by CMake.
+
+-   `cmake/draco_intrinsics.cmake` manages flags for source files that use
+    intrinsics. It handles detection of whether flags are necessary, and the
+    application of the flags to the sources that need them when they are
+    required.
+
+## Helper and Utility Files
+
+-   `.cmake-format.py` Defines coding style for cmake-format.
+
+-   `cmake/draco_helpers.cmake` defines utility macros.
+
+-   `cmake/draco_sanitizer.cmake` defines the `draco_configure_sanitizer()`
+    macro, which implements support for `DRACO_SANITIZE`. It handles the
+    compiler and linker flags necessary for using sanitizers like asan and msan.
+
+-   `cmake/draco_variables.cmake` defines macros for tracking and control of
+    draco build system variables.
+
+## Toolchain Files
+
+These files help facilitate cross compiling of draco for various targets.
+
+-   `cmake/toolchains/aarch64-linux-gnu.cmake` provides cross compilation
+    support for arm64 targets.
+
+-   `cmake/toolchains/android.cmake` provides cross compilation support for
+    Android targets.
+
+-   `cmake/toolchains/arm-linux-gnueabihf.cmake` provides cross compilation
+    support for armv7 targets.
+
+-   `cmake/toolchains/arm64-ios.cmake`, `cmake/toolchains/armv7-ios.cmake`,
+    and `cmake/toolchains/armv7s-ios.cmake` provide support for iOS.
+
+-   `cmake/toolchains/arm64-linux-gcc.cmake` and
+    `cmake/toolchains/armv7-linux-gcc.cmake` are deprecated, but remain for
+    compatibility. `cmake/toolchains/android.cmake` should be used instead.
+
+-   `cmake/toolchains/arm64-android-ndk-libcpp.cmake`,
+    `cmake/toolchains/armv7-android-ndk-libcpp.cmake`,
+    `cmake/toolchains/x86-android-ndk-libcpp.cmake`, and
+    `cmake/toolchains/x86_64-android-ndk-libcpp.cmake` are deprecated, but
+    remain for compatibility. `cmake/toolchains/android.cmake` should be used
+    instead.
+
+-   `cmake/toolchains/i386-ios.cmake` and `cmake/toolchains/x86_64-ios.cmake`
+    provide support for the iOS simulator.
+
+-   `cmake/toolchains/android-ndk-common.cmake` and
+    `cmake/toolchains/arm-ios-common.cmake` are support files used by other
+    toolchain files.
+
+## Template Files
+
+These files are inputs to the CMake build and are used to generate inputs to the
+build system output by CMake.
+
+-   `cmake/draco-config.cmake.template` is used to produce
+    draco-config.cmake. draco-config.cmake can be used by CMake to find draco
+    when another CMake project depends on draco.
+
+-   `cmake/draco.pc.template` is used to produce draco's pkg-config file.
+    Some build systems use pkg-config to configure include and library paths
+    when they depend upon third party libraries like draco.
diff --git a/Engine/lib/assimp/contrib/draco/CMakeLists.txt b/Engine/lib/assimp/contrib/draco/CMakeLists.txt
new file mode 100644
index 000000000..5526e7f60
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/CMakeLists.txt
@@ -0,0 +1,952 @@
+cmake_minimum_required(VERSION 3.12 FATAL_ERROR)
+
+# Draco requires C++11.
+set(CMAKE_CXX_STANDARD 11)
+project(draco C CXX)
+
+if(NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE Release)
+endif()
+
+set(draco_root "${CMAKE_CURRENT_SOURCE_DIR}")
+set(draco_src_root "${draco_root}/src/draco")
+set(draco_build "${CMAKE_BINARY_DIR}")
+
+if("${draco_root}" STREQUAL "${draco_build}")
+  message(
+    FATAL_ERROR "Building from within the Draco source tree is not supported.\n"
+                "Hint: Run these commands\n"
+                "$ rm -rf CMakeCache.txt CMakeFiles\n"
+                "$ mkdir -p ../draco_build\n" "$ cd ../draco_build\n"
+                "And re-run CMake from the draco_build directory.")
+endif()
+
+include(CMakePackageConfigHelpers)
+include(FindPythonInterp)
+include("${draco_root}/cmake/draco_build_definitions.cmake")
+include("${draco_root}/cmake/draco_cpu_detection.cmake")
+include("${draco_root}/cmake/draco_emscripten.cmake")
+include("${draco_root}/cmake/draco_flags.cmake")
+include("${draco_root}/cmake/draco_helpers.cmake")
+include("${draco_root}/cmake/draco_install.cmake")
+include("${draco_root}/cmake/draco_intrinsics.cmake")
+include("${draco_root}/cmake/draco_options.cmake")
+include("${draco_root}/cmake/draco_sanitizer.cmake")
+include("${draco_root}/cmake/draco_targets.cmake")
+include("${draco_root}/cmake/draco_tests.cmake")
+include("${draco_root}/cmake/draco_variables.cmake")
+
+# C++ and linker flags.
+draco_track_configuration_variable(DRACO_CXX_FLAGS)
+draco_track_configuration_variable(DRACO_EXE_LINKER_FLAGS)
+
+# Sanitizer integration.
+draco_track_configuration_variable(DRACO_SANITIZE)
+
+# Generated source file directory.
+draco_track_configuration_variable(DRACO_GENERATED_SOURCES_DIRECTORY)
+
+# Controls use of std::mutex and absl::Mutex in ThreadPool.
+draco_track_configuration_variable(DRACO_THREADPOOL_USE_STD_MUTEX)
+
+if(DRACO_VERBOSE)
+  draco_dump_cmake_flag_variables()
+  draco_dump_tracked_configuration_variables()
+  draco_dump_options()
+endif()
+
+# Compiler/linker flags must be lists, but come in from the environment as
+# strings. Break them up:
+if(NOT "${DRACO_CXX_FLAGS}" STREQUAL "")
+  separate_arguments(DRACO_CXX_FLAGS)
+endif()
+if(NOT "${DRACO_EXE_LINKER_FLAGS}" STREQUAL "")
+  separate_arguments(DRACO_EXE_LINKER_FLAGS)
+endif()
+
+draco_reset_target_lists()
+draco_setup_options()
+draco_set_build_definitions()
+draco_set_cxx_flags()
+draco_generate_features_h()
+
+# Draco source file listing variables.
+list(APPEND draco_attributes_sources
+            "${draco_src_root}/attributes/attribute_octahedron_transform.cc"
+            "${draco_src_root}/attributes/attribute_octahedron_transform.h"
+            "${draco_src_root}/attributes/attribute_quantization_transform.cc"
+            "${draco_src_root}/attributes/attribute_quantization_transform.h"
+            "${draco_src_root}/attributes/attribute_transform.cc"
+            "${draco_src_root}/attributes/attribute_transform.h"
+            "${draco_src_root}/attributes/attribute_transform_data.h"
+            "${draco_src_root}/attributes/attribute_transform_type.h"
+            "${draco_src_root}/attributes/geometry_attribute.cc"
+            "${draco_src_root}/attributes/geometry_attribute.h"
+            "${draco_src_root}/attributes/geometry_indices.h"
+            "${draco_src_root}/attributes/point_attribute.cc"
+            "${draco_src_root}/attributes/point_attribute.h")
+
+list(
+  APPEND
+    draco_compression_attributes_dec_sources
+    "${draco_src_root}/compression/attributes/attributes_decoder.cc"
+    "${draco_src_root}/compression/attributes/attributes_decoder.h"
+    "${draco_src_root}/compression/attributes/kd_tree_attributes_decoder.cc"
+    "${draco_src_root}/compression/attributes/kd_tree_attributes_decoder.h"
+    "${draco_src_root}/compression/attributes/kd_tree_attributes_shared.h"
+    "${draco_src_root}/compression/attributes/mesh_attribute_indices_encoding_data.h"
+    "${draco_src_root}/compression/attributes/normal_compression_utils.h"
+    "${draco_src_root}/compression/attributes/point_d_vector.h"
+    "${draco_src_root}/compression/attributes/sequential_attribute_decoder.cc"
+    "${draco_src_root}/compression/attributes/sequential_attribute_decoder.h"
+    "${draco_src_root}/compression/attributes/sequential_attribute_decoders_controller.cc"
+    "${draco_src_root}/compression/attributes/sequential_attribute_decoders_controller.h"
+    "${draco_src_root}/compression/attributes/sequential_integer_attribute_decoder.cc"
+    "${draco_src_root}/compression/attributes/sequential_integer_attribute_decoder.h"
+    "${draco_src_root}/compression/attributes/sequential_normal_attribute_decoder.cc"
+    "${draco_src_root}/compression/attributes/sequential_normal_attribute_decoder.h"
+    "${draco_src_root}/compression/attributes/sequential_quantization_attribute_decoder.cc"
+    "${draco_src_root}/compression/attributes/sequential_quantization_attribute_decoder.h"
+  )
+
+list(
+  APPEND
+    draco_compression_attributes_enc_sources
+    "${draco_src_root}/compression/attributes/attributes_encoder.cc"
+    "${draco_src_root}/compression/attributes/attributes_encoder.h"
+    "${draco_src_root}/compression/attributes/kd_tree_attributes_encoder.cc"
+    "${draco_src_root}/compression/attributes/kd_tree_attributes_encoder.h"
+    "${draco_src_root}/compression/attributes/linear_sequencer.h"
+    "${draco_src_root}/compression/attributes/points_sequencer.h"
+    "${draco_src_root}/compression/attributes/sequential_attribute_encoder.cc"
+    "${draco_src_root}/compression/attributes/sequential_attribute_encoder.h"
+    "${draco_src_root}/compression/attributes/sequential_attribute_encoders_controller.cc"
+    "${draco_src_root}/compression/attributes/sequential_attribute_encoders_controller.h"
+    "${draco_src_root}/compression/attributes/sequential_integer_attribute_encoder.cc"
+    "${draco_src_root}/compression/attributes/sequential_integer_attribute_encoder.h"
+    "${draco_src_root}/compression/attributes/sequential_normal_attribute_encoder.cc"
+    "${draco_src_root}/compression/attributes/sequential_normal_attribute_encoder.h"
+    "${draco_src_root}/compression/attributes/sequential_quantization_attribute_encoder.cc"
+    "${draco_src_root}/compression/attributes/sequential_quantization_attribute_encoder.h"
+  )
+
+
+list(
+  APPEND
+    draco_compression_attributes_pred_schemes_dec_sources
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_decoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_shared.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_data.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_decoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_area.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_base.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_decoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_encoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_decoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_decoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_predictor.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_decoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_decoder_factory.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_decoder_interface.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_decoding_transform.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_delta_decoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_factory.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_interface.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_decoding_transform.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_base.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_decoding_transform.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_base.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_wrap_decoding_transform.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_wrap_transform_base.h"
+  )
+
+list(
+  APPEND
+    draco_compression_attributes_pred_schemes_enc_sources
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_encoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_shared.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_data.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_encoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_area.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_base.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_encoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_encoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_encoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_encoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_predictor.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_delta_encoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_encoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.cc"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_encoder_interface.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_encoding_transform.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_factory.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_interface.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_encoding_transform.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_base.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_encoding_transform.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_base.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_wrap_encoding_transform.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_wrap_transform_base.h"
+  )
+
+list(
+  APPEND
+    draco_compression_bit_coders_sources
+    "${draco_src_root}/compression/bit_coders/adaptive_rans_bit_coding_shared.h"
+    "${draco_src_root}/compression/bit_coders/adaptive_rans_bit_decoder.cc"
+    "${draco_src_root}/compression/bit_coders/adaptive_rans_bit_decoder.h"
+    "${draco_src_root}/compression/bit_coders/adaptive_rans_bit_encoder.cc"
+    "${draco_src_root}/compression/bit_coders/adaptive_rans_bit_encoder.h"
+    "${draco_src_root}/compression/bit_coders/direct_bit_decoder.cc"
+    "${draco_src_root}/compression/bit_coders/direct_bit_decoder.h"
+    "${draco_src_root}/compression/bit_coders/direct_bit_encoder.cc"
+    "${draco_src_root}/compression/bit_coders/direct_bit_encoder.h"
+    "${draco_src_root}/compression/bit_coders/folded_integer_bit_decoder.h"
+    "${draco_src_root}/compression/bit_coders/folded_integer_bit_encoder.h"
+    "${draco_src_root}/compression/bit_coders/rans_bit_decoder.cc"
+    "${draco_src_root}/compression/bit_coders/rans_bit_decoder.h"
+    "${draco_src_root}/compression/bit_coders/rans_bit_encoder.cc"
+    "${draco_src_root}/compression/bit_coders/rans_bit_encoder.h"
+    "${draco_src_root}/compression/bit_coders/symbol_bit_decoder.cc"
+    "${draco_src_root}/compression/bit_coders/symbol_bit_decoder.h"
+    "${draco_src_root}/compression/bit_coders/symbol_bit_encoder.cc"
+    "${draco_src_root}/compression/bit_coders/symbol_bit_encoder.h")
+
+list(APPEND draco_enc_config_sources
+            "${draco_src_root}/compression/config/compression_shared.h"
+            "${draco_src_root}/compression/config/draco_options.h"
+            "${draco_src_root}/compression/config/encoder_options.h"
+            "${draco_src_root}/compression/config/encoding_features.h")
+
+list(APPEND draco_dec_config_sources
+            "${draco_src_root}/compression/config/compression_shared.h"
+            "${draco_src_root}/compression/config/decoder_options.h"
+            "${draco_src_root}/compression/config/draco_options.h")
+
+list(APPEND draco_compression_decode_sources
+            "${draco_src_root}/compression/decode.cc"
+            "${draco_src_root}/compression/decode.h")
+
+list(APPEND draco_compression_encode_sources
+            "${draco_src_root}/compression/encode.cc"
+            "${draco_src_root}/compression/encode.h"
+            "${draco_src_root}/compression/encode_base.h"
+            "${draco_src_root}/compression/expert_encode.cc"
+            "${draco_src_root}/compression/expert_encode.h")
+
+list(
+  APPEND
+    draco_compression_mesh_traverser_sources
+    "${draco_src_root}/compression/mesh/traverser/depth_first_traverser.h"
+    "${draco_src_root}/compression/mesh/traverser/max_prediction_degree_traverser.h"
+    "${draco_src_root}/compression/mesh/traverser/mesh_attribute_indices_encoding_observer.h"
+    "${draco_src_root}/compression/mesh/traverser/mesh_traversal_sequencer.h"
+    "${draco_src_root}/compression/mesh/traverser/traverser_base.h")
+
+list(
+  APPEND
+    draco_compression_mesh_dec_sources
+    "${draco_src_root}/compression/mesh/mesh_decoder.cc"
+    "${draco_src_root}/compression/mesh/mesh_decoder.h"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_decoder.cc"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_decoder.h"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_decoder_impl.cc"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_decoder_impl.h"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_decoder_impl_interface.h"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_shared.h"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_traversal_decoder.h"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_traversal_predictive_decoder.h"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_traversal_valence_decoder.h"
+    "${draco_src_root}/compression/mesh/mesh_sequential_decoder.cc"
+    "${draco_src_root}/compression/mesh/mesh_sequential_decoder.h")
+
+list(
+  APPEND
+    draco_compression_mesh_enc_sources
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_encoder.cc"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_encoder.h"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_encoder_impl.cc"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_encoder_impl.h"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_encoder_impl_interface.h"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_shared.h"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_traversal_encoder.h"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_traversal_predictive_encoder.h"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_traversal_valence_encoder.h"
+    "${draco_src_root}/compression/mesh/mesh_encoder.cc"
+    "${draco_src_root}/compression/mesh/mesh_encoder.h"
+    "${draco_src_root}/compression/mesh/mesh_sequential_encoder.cc"
+    "${draco_src_root}/compression/mesh/mesh_sequential_encoder.h")
+
+list(
+  APPEND
+    draco_compression_point_cloud_dec_sources
+    "${draco_src_root}/compression/point_cloud/point_cloud_decoder.cc"
+    "${draco_src_root}/compression/point_cloud/point_cloud_decoder.h"
+    "${draco_src_root}/compression/point_cloud/point_cloud_kd_tree_decoder.cc"
+    "${draco_src_root}/compression/point_cloud/point_cloud_kd_tree_decoder.h"
+    "${draco_src_root}/compression/point_cloud/point_cloud_sequential_decoder.cc"
+    "${draco_src_root}/compression/point_cloud/point_cloud_sequential_decoder.h"
+  )
+
+list(
+  APPEND
+    draco_compression_point_cloud_enc_sources
+    "${draco_src_root}/compression/point_cloud/point_cloud_encoder.cc"
+    "${draco_src_root}/compression/point_cloud/point_cloud_encoder.h"
+    "${draco_src_root}/compression/point_cloud/point_cloud_kd_tree_encoder.cc"
+    "${draco_src_root}/compression/point_cloud/point_cloud_kd_tree_encoder.h"
+    "${draco_src_root}/compression/point_cloud/point_cloud_sequential_encoder.cc"
+    "${draco_src_root}/compression/point_cloud/point_cloud_sequential_encoder.h"
+  )
+
+list(APPEND draco_compression_entropy_sources
+            "${draco_src_root}/compression/entropy/ans.h"
+            "${draco_src_root}/compression/entropy/rans_symbol_coding.h"
+            "${draco_src_root}/compression/entropy/rans_symbol_decoder.h"
+            "${draco_src_root}/compression/entropy/rans_symbol_encoder.h"
+            "${draco_src_root}/compression/entropy/shannon_entropy.cc"
+            "${draco_src_root}/compression/entropy/shannon_entropy.h"
+            "${draco_src_root}/compression/entropy/symbol_decoding.cc"
+            "${draco_src_root}/compression/entropy/symbol_decoding.h"
+            "${draco_src_root}/compression/entropy/symbol_encoding.cc"
+            "${draco_src_root}/compression/entropy/symbol_encoding.h")
+
+list(APPEND draco_core_sources
+            "${draco_src_root}/core/bit_utils.cc"
+            "${draco_src_root}/core/bit_utils.h"
+            "${draco_src_root}/core/bounding_box.cc"
+            "${draco_src_root}/core/bounding_box.h"
+            "${draco_src_root}/core/cycle_timer.cc"
+            "${draco_src_root}/core/cycle_timer.h"
+            "${draco_src_root}/core/data_buffer.cc"
+            "${draco_src_root}/core/data_buffer.h"
+            "${draco_src_root}/core/decoder_buffer.cc"
+            "${draco_src_root}/core/decoder_buffer.h"
+            "${draco_src_root}/core/divide.cc"
+            "${draco_src_root}/core/divide.h"
+            "${draco_src_root}/core/draco_index_type.h"
+            "${draco_src_root}/core/draco_index_type_vector.h"
+            "${draco_src_root}/core/draco_types.cc"
+            "${draco_src_root}/core/draco_types.h"
+            "${draco_src_root}/core/encoder_buffer.cc"
+            "${draco_src_root}/core/encoder_buffer.h"
+            "${draco_src_root}/core/hash_utils.cc"
+            "${draco_src_root}/core/hash_utils.h"
+            "${draco_src_root}/core/macros.h"
+            "${draco_src_root}/core/math_utils.h"
+            "${draco_src_root}/core/options.cc"
+            "${draco_src_root}/core/options.h"
+            "${draco_src_root}/core/quantization_utils.cc"
+            "${draco_src_root}/core/quantization_utils.h"
+            "${draco_src_root}/core/status.h"
+            "${draco_src_root}/core/status_or.h"
+            "${draco_src_root}/core/varint_decoding.h"
+            "${draco_src_root}/core/varint_encoding.h"
+            "${draco_src_root}/core/vector_d.h")
+
+list(APPEND draco_io_sources
+            "${draco_src_root}/io/file_reader_factory.cc"
+            "${draco_src_root}/io/file_reader_factory.h"
+            "${draco_src_root}/io/file_reader_interface.h"
+            "${draco_src_root}/io/file_utils.cc"
+            "${draco_src_root}/io/file_utils.h"
+            "${draco_src_root}/io/file_writer_factory.cc"
+            "${draco_src_root}/io/file_writer_factory.h"
+            "${draco_src_root}/io/file_writer_interface.h"
+            "${draco_src_root}/io/file_writer_utils.h"
+            "${draco_src_root}/io/file_writer_utils.cc"
+            "${draco_src_root}/io/mesh_io.cc"
+            "${draco_src_root}/io/mesh_io.h"
+            "${draco_src_root}/io/obj_decoder.cc"
+            "${draco_src_root}/io/obj_decoder.h"
+            "${draco_src_root}/io/obj_encoder.cc"
+            "${draco_src_root}/io/obj_encoder.h"
+            "${draco_src_root}/io/parser_utils.cc"
+            "${draco_src_root}/io/parser_utils.h"
+            "${draco_src_root}/io/ply_decoder.cc"
+            "${draco_src_root}/io/ply_decoder.h"
+            "${draco_src_root}/io/ply_encoder.cc"
+            "${draco_src_root}/io/ply_encoder.h"
+            "${draco_src_root}/io/ply_property_reader.h"
+            "${draco_src_root}/io/ply_property_writer.h"
+            "${draco_src_root}/io/ply_reader.cc"
+            "${draco_src_root}/io/ply_reader.h"
+            "${draco_src_root}/io/point_cloud_io.cc"
+            "${draco_src_root}/io/point_cloud_io.h"
+            "${draco_src_root}/io/stdio_file_reader.cc"
+            "${draco_src_root}/io/stdio_file_reader.h"
+            "${draco_src_root}/io/stdio_file_writer.cc"
+            "${draco_src_root}/io/stdio_file_writer.h")
+
+list(APPEND draco_mesh_sources
+            "${draco_src_root}/mesh/corner_table.cc"
+            "${draco_src_root}/mesh/corner_table.h"
+            "${draco_src_root}/mesh/corner_table_iterators.h"
+            "${draco_src_root}/mesh/mesh.cc"
+            "${draco_src_root}/mesh/mesh.h"
+            "${draco_src_root}/mesh/mesh_are_equivalent.cc"
+            "${draco_src_root}/mesh/mesh_are_equivalent.h"
+            "${draco_src_root}/mesh/mesh_attribute_corner_table.cc"
+            "${draco_src_root}/mesh/mesh_attribute_corner_table.h"
+            "${draco_src_root}/mesh/mesh_cleanup.cc"
+            "${draco_src_root}/mesh/mesh_cleanup.h"
+            "${draco_src_root}/mesh/mesh_misc_functions.cc"
+            "${draco_src_root}/mesh/mesh_misc_functions.h"
+            "${draco_src_root}/mesh/mesh_stripifier.cc"
+            "${draco_src_root}/mesh/mesh_stripifier.h"
+            "${draco_src_root}/mesh/triangle_soup_mesh_builder.cc"
+            "${draco_src_root}/mesh/triangle_soup_mesh_builder.h"
+            "${draco_src_root}/mesh/valence_cache.h")
+
+list(APPEND draco_point_cloud_sources
+            "${draco_src_root}/point_cloud/point_cloud.cc"
+            "${draco_src_root}/point_cloud/point_cloud.h"
+            "${draco_src_root}/point_cloud/point_cloud_builder.cc"
+            "${draco_src_root}/point_cloud/point_cloud_builder.h")
+
+list(
+  APPEND
+    draco_points_common_sources
+    "${draco_src_root}/compression/point_cloud/algorithms/point_cloud_compression_method.h"
+    "${draco_src_root}/compression/point_cloud/algorithms/point_cloud_types.h"
+    "${draco_src_root}/compression/point_cloud/algorithms/quantize_points_3.h"
+    "${draco_src_root}/compression/point_cloud/algorithms/queuing_policy.h")
+
+list(
+  APPEND
+    draco_points_dec_sources
+    "${draco_src_root}/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_decoder.cc"
+    "${draco_src_root}/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_decoder.h"
+    "${draco_src_root}/compression/point_cloud/algorithms/float_points_tree_decoder.cc"
+    "${draco_src_root}/compression/point_cloud/algorithms/float_points_tree_decoder.h"
+  )
+
+list(
+  APPEND
+    draco_points_enc_sources
+    "${draco_src_root}/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_encoder.cc"
+    "${draco_src_root}/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_encoder.h"
+    "${draco_src_root}/compression/point_cloud/algorithms/float_points_tree_encoder.cc"
+    "${draco_src_root}/compression/point_cloud/algorithms/float_points_tree_encoder.h"
+  )
+
+list(APPEND draco_metadata_sources
+            "${draco_src_root}/metadata/geometry_metadata.cc"
+            "${draco_src_root}/metadata/geometry_metadata.h"
+            "${draco_src_root}/metadata/metadata.cc"
+            "${draco_src_root}/metadata/metadata.h")
+
+list(APPEND draco_metadata_enc_sources
+            "${draco_src_root}/metadata/metadata_encoder.cc"
+            "${draco_src_root}/metadata/metadata_encoder.h")
+
+list(APPEND draco_metadata_dec_sources
+            "${draco_src_root}/metadata/metadata_decoder.cc"
+            "${draco_src_root}/metadata/metadata_decoder.h")
+
+list(APPEND draco_animation_sources
+            "${draco_src_root}/animation/keyframe_animation.cc"
+            "${draco_src_root}/animation/keyframe_animation.h")
+
+list(APPEND draco_animation_enc_sources
+            "${draco_src_root}/animation/keyframe_animation_encoder.cc"
+            "${draco_src_root}/animation/keyframe_animation_encoder.h")
+
+list(APPEND draco_animation_dec_sources
+            "${draco_src_root}/animation/keyframe_animation_decoder.cc"
+            "${draco_src_root}/animation/keyframe_animation_decoder.h")
+
+list(
+  APPEND draco_js_dec_sources
+         "${draco_src_root}/javascript/emscripten/decoder_webidl_wrapper.cc"
+         "${draco_src_root}/javascript/emscripten/draco_decoder_glue_wrapper.cc"
+  )
+
+list(
+  APPEND draco_js_enc_sources
+         "${draco_src_root}/javascript/emscripten/draco_encoder_glue_wrapper.cc"
+         "${draco_src_root}/javascript/emscripten/encoder_webidl_wrapper.cc")
+
+list(
+  APPEND
+    draco_animation_js_dec_sources
+    "${draco_src_root}/javascript/emscripten/animation_decoder_webidl_wrapper.cc"
+    "${draco_src_root}/javascript/emscripten/draco_animation_decoder_glue_wrapper.cc"
+  )
+
+list(
+  APPEND
+    draco_animation_js_enc_sources
+    "${draco_src_root}/javascript/emscripten/animation_encoder_webidl_wrapper.cc"
+    "${draco_src_root}/javascript/emscripten/draco_animation_encoder_glue_wrapper.cc"
+  )
+
+list(APPEND draco_unity_plug_sources
+            "${draco_src_root}/unity/draco_unity_plugin.cc"
+            "${draco_src_root}/unity/draco_unity_plugin.h")
+
+list(APPEND draco_maya_plug_sources
+            "${draco_src_root}/maya/draco_maya_plugin.cc"
+            "${draco_src_root}/maya/draco_maya_plugin.h")
+
+#
+# Draco targets.
+#
+if(EMSCRIPTEN AND DRACO_JS_GLUE)
+  # Draco decoder and encoder "executable" targets in various flavors for
+  # Emsscripten.
+  list(APPEND draco_decoder_src
+              ${draco_attributes_sources}
+              ${draco_compression_attributes_dec_sources}
+              ${draco_compression_attributes_pred_schemes_dec_sources}
+              ${draco_compression_bit_coders_sources}
+              ${draco_compression_decode_sources}
+              ${draco_compression_entropy_sources}
+              ${draco_compression_mesh_traverser_sources}
+              ${draco_compression_mesh_dec_sources}
+              ${draco_compression_point_cloud_dec_sources}
+              ${draco_core_sources}
+              ${draco_dec_config_sources}
+              ${draco_js_dec_sources}
+              ${draco_mesh_sources}
+              ${draco_metadata_dec_sources}
+              ${draco_metadata_sources}
+              ${draco_point_cloud_sources}
+              ${draco_points_dec_sources})
+
+  list(APPEND draco_encoder_src
+              ${draco_attributes_sources}
+              ${draco_compression_attributes_enc_sources}
+              ${draco_compression_attributes_pred_schemes_enc_sources}
+              ${draco_compression_bit_coders_sources}
+              ${draco_compression_encode_sources}
+              ${draco_compression_entropy_sources}
+              ${draco_compression_mesh_traverser_sources}
+              ${draco_compression_mesh_enc_sources}
+              ${draco_compression_point_cloud_enc_sources}
+              ${draco_core_sources}
+              ${draco_enc_config_sources}
+              ${draco_js_enc_sources}
+              ${draco_mesh_sources}
+              ${draco_metadata_enc_sources}
+              ${draco_metadata_sources}
+              ${draco_point_cloud_sources}
+              ${draco_points_enc_sources})
+
+  list(APPEND draco_js_dec_idl
+              "${draco_src_root}/javascript/emscripten/draco_web_decoder.idl")
+  list(APPEND draco_js_enc_idl
+              "${draco_src_root}/javascript/emscripten/draco_web_encoder.idl")
+  list(
+    APPEND
+      draco_animation_js_dec_idl
+      "${draco_src_root}/javascript/emscripten/draco_animation_web_decoder.idl")
+  list(
+    APPEND
+      draco_animation_js_enc_idl
+      "${draco_src_root}/javascript/emscripten/draco_animation_web_encoder.idl")
+  list(APPEND draco_pre_link_js_sources
+              "${draco_src_root}/javascript/emscripten/prepareCallbacks.js"
+              "${draco_src_root}/javascript/emscripten/version.js")
+  list(APPEND draco_post_link_js_sources
+              "${draco_src_root}/javascript/emscripten/finalize.js")
+  list(APPEND draco_post_link_js_decoder_sources ${draco_post_link_js_sources}
+              "${draco_src_root}/javascript/emscripten/decoder_functions.js")
+
+  set(draco_decoder_glue_path "${draco_build}/glue_decoder")
+  set(draco_encoder_glue_path "${draco_build}/glue_encoder")
+
+  draco_generate_emscripten_glue(INPUT_IDL ${draco_js_dec_idl} OUTPUT_PATH
+                                 ${draco_decoder_glue_path})
+  draco_generate_emscripten_glue(INPUT_IDL ${draco_js_enc_idl} OUTPUT_PATH
+                                 ${draco_encoder_glue_path})
+
+  if(DRACO_DECODER_ATTRIBUTE_DEDUPLICATION)
+    list(APPEND draco_decoder_features
+                "DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED"
+                "DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED")
+  endif()
+
+  draco_add_emscripten_executable(NAME
+                                  draco_decoder
+                                  SOURCES
+                                  ${draco_decoder_src}
+                                  DEFINES
+                                  ${draco_defines}
+                                  FEATURES
+                                  ${draco_decoder_features}
+                                  INCLUDES
+                                  ${draco_include_paths}
+                                  LINK_FLAGS
+                                  "-sEXPORT_NAME=\"DracoDecoderModule\""
+                                  GLUE_PATH
+                                  ${draco_decoder_glue_path}
+                                  PRE_LINK_JS_SOURCES
+                                  ${draco_pre_link_js_sources}
+                                  POST_LINK_JS_SOURCES
+                                  ${draco_post_link_js_decoder_sources})
+
+  draco_add_emscripten_executable(
+    NAME
+    draco_encoder
+    SOURCES
+    ${draco_encoder_src}
+    DEFINES
+    ${draco_defines}
+    FEATURES
+    DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+    DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED
+    INCLUDES
+    ${draco_include_paths}
+    LINK_FLAGS
+    "-sEXPORT_NAME=\"DracoEncoderModule\""
+    GLUE_PATH
+    ${draco_encoder_glue_path}
+    PRE_LINK_JS_SOURCES
+    ${draco_pre_link_js_sources}
+    POST_LINK_JS_SOURCES
+    ${draco_post_link_js_sources})
+
+  if(DRACO_ANIMATION_ENCODING)
+    set(draco_anim_decoder_glue_path "${draco_build}/glue_animation_decoder")
+    set(draco_anim_encoder_glue_path "${draco_build}/glue_animation_encoder")
+
+    draco_generate_emscripten_glue(INPUT_IDL ${draco_animation_js_dec_idl}
+                                   OUTPUT_PATH ${draco_anim_decoder_glue_path})
+    draco_generate_emscripten_glue(INPUT_IDL ${draco_animation_js_enc_idl}
+                                   OUTPUT_PATH ${draco_anim_encoder_glue_path})
+
+    draco_add_emscripten_executable(
+      NAME
+      draco_animation_decoder
+      SOURCES
+      ${draco_animation_dec_sources}
+      ${draco_animation_js_dec_sources}
+      ${draco_animation_sources}
+      ${draco_decoder_src}
+      DEFINES
+      ${draco_defines}
+      INCLUDES
+      ${draco_include_paths}
+      LINK_FLAGS
+      "-sEXPORT_NAME=\"DracoAnimationDecoderModule\""
+      GLUE_PATH
+      ${draco_anim_decoder_glue_path}
+      PRE_LINK_JS_SOURCES
+      ${draco_pre_link_js_sources}
+      POST_LINK_JS_SOURCES
+      ${draco_post_link_js_decoder_sources})
+
+    draco_add_emscripten_executable(
+      NAME
+      draco_animation_encoder
+      SOURCES
+      ${draco_animation_enc_sources}
+      ${draco_animation_js_enc_sources}
+      ${draco_animation_sources}
+      ${draco_encoder_src}
+      DEFINES
+      ${draco_defines}
+      INCLUDES
+      ${draco_include_paths}
+      LINK_FLAGS
+      "-sEXPORT_NAME=\"DracoAnimationEncoderModule\""
+      GLUE_PATH
+      ${draco_anim_encoder_glue_path}
+      PRE_LINK_JS_SOURCES
+      ${draco_pre_link_js_sources}
+      POST_LINK_JS_SOURCES
+      ${draco_post_link_js_sources})
+  endif()
+else()
+  # Standard Draco libs, encoder and decoder. Object collections that mirror the
+  # Draco directory structure.
+  draco_add_library(NAME draco_attributes TYPE OBJECT SOURCES
+                    ${draco_attributes_sources} DEFINES ${draco_defines}
+                    INCLUDES ${draco_include_paths})
+  draco_add_library(NAME
+                    draco_compression_attributes_dec
+                    OBJECT
+                    ${draco_compression_attributes_dec_sources}
+                    TYPE
+                    OBJECT
+                    SOURCES
+                    ${draco_compression_attributes_dec_sources}
+                    DEFINES
+                    ${draco_defines}
+                    INCLUDES
+                    ${draco_include_paths})
+  draco_add_library(NAME draco_compression_attributes_enc TYPE OBJECT SOURCES
+                    ${draco_compression_attributes_enc_sources} DEFINES
+                    ${draco_defines} INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_compression_attributes_pred_schemes_dec TYPE
+                    OBJECT SOURCES
+                    ${draco_compression_attributes_pred_schemes_dec_sources})
+  draco_add_library(NAME draco_compression_attributes_pred_schemes_enc TYPE
+                    OBJECT SOURCES
+                    ${draco_compression_attributes_pred_schemes_enc_sources}
+                    DEFINES ${draco_defines} INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_compression_bit_coders TYPE OBJECT SOURCES
+                    ${draco_compression_bit_coders_sources} DEFINES
+                    ${draco_defines} INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_enc_config TYPE OBJECT SOURCES
+                    ${draco_enc_config_sources} DEFINES ${draco_defines}
+                    INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_dec_config TYPE OBJECT SOURCES
+                    ${draco_dec_config_sources} DEFINES ${draco_defines}
+                    INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_compression_decode TYPE OBJECT SOURCES
+                    ${draco_compression_decode_sources} DEFINES ${draco_defines}
+                    INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_compression_encode TYPE OBJECT SOURCES
+                    ${draco_compression_encode_sources} DEFINES ${draco_defines}
+                    INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_compression_entropy TYPE OBJECT SOURCES
+                    ${draco_compression_entropy_sources} DEFINES
+                    ${draco_defines} INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_compression_mesh_traverser TYPE OBJECT SOURCES
+                    ${draco_compression_mesh_traverser_sources} DEFINES
+                    ${draco_defines} INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_compression_mesh_dec TYPE OBJECT SOURCES
+                    ${draco_compression_mesh_dec_sources} DEFINES
+                    ${draco_defines} INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_compression_mesh_enc TYPE OBJECT SOURCES
+                    ${draco_compression_mesh_enc_sources} DEFINES
+                    ${draco_defines} INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_compression_point_cloud_dec TYPE OBJECT SOURCES
+                    ${draco_compression_point_cloud_dec_sources} DEFINES
+                    ${draco_defines} INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_compression_point_cloud_enc TYPE OBJECT SOURCES
+                    ${draco_compression_point_cloud_enc_sources} DEFINES
+                    ${draco_defines} INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_core TYPE OBJECT SOURCES ${draco_core_sources}
+                    DEFINES ${draco_defines} INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_io TYPE OBJECT SOURCES ${draco_io_sources}
+                    DEFINES ${draco_defines} INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_mesh TYPE OBJECT SOURCES ${draco_mesh_sources}
+                    DEFINES ${draco_defines} INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_metadata_dec TYPE OBJECT SOURCES
+                    ${draco_metadata_dec_sources} DEFINES ${draco_defines}
+                    INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_metadata_enc TYPE OBJECT SOURCES
+                    ${draco_metadata_enc_sources} DEFINES ${draco_defines}
+                    INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_metadata TYPE OBJECT SOURCES
+                    ${draco_metadata_sources} DEFINES ${draco_defines} INCLUDES
+                    ${draco_include_paths})
+  draco_add_library(NAME draco_animation_dec TYPE OBJECT SOURCES
+                    ${draco_animation_dec_sources} DEFINES ${draco_defines}
+                    INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_animation_enc TYPE OBJECT SOURCES
+                    ${draco_animation_enc_sources} DEFINES ${draco_defines}
+                    INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_animation TYPE OBJECT SOURCES
+                    ${draco_animation_sources} DEFINES ${draco_defines} INCLUDES
+                    ${draco_include_paths})
+  draco_add_library(NAME draco_point_cloud TYPE OBJECT SOURCES
+                    ${draco_point_cloud_sources} DEFINES ${draco_defines}
+                    INCLUDES ${draco_include_paths})
+  draco_add_library(NAME
+                    draco_points_dec
+                    TYPE
+                    OBJECT
+                    SOURCES
+                    ${draco_points_common_sources}
+                    ${draco_points_dec_sources}
+                    DEFINES
+                    ${draco_defines}
+                    INCLUDES
+                    ${draco_include_paths})
+  draco_add_library(NAME
+                    draco_points_enc
+                    TYPE
+                    OBJECT
+                    SOURCES
+                    ${draco_points_common_sources}
+                    ${draco_points_enc_sources}
+                    DEFINES
+                    ${draco_defines}
+                    INCLUDES
+                    ${draco_include_paths})
+
+  set(draco_object_library_deps
+      draco_attributes
+      draco_compression_attributes_dec
+      draco_compression_attributes_enc
+      draco_compression_attributes_pred_schemes_dec
+      draco_compression_attributes_pred_schemes_enc
+      draco_compression_bit_coders
+      draco_compression_decode
+      draco_compression_encode
+      draco_compression_entropy
+      draco_compression_mesh_dec
+      draco_compression_mesh_enc
+      draco_compression_point_cloud_dec
+      draco_compression_point_cloud_enc
+      draco_core
+      draco_dec_config
+      draco_enc_config
+      draco_io
+      draco_mesh
+      draco_metadata
+      draco_metadata_dec
+      draco_metadata_enc
+      draco_animation
+      draco_animation_dec
+      draco_animation_enc
+      draco_point_cloud
+      draco_points_dec
+      draco_points_enc)
+
+  # Library targets that consume the object collections.
+  if(MSVC)
+    # In order to produce a DLL and import library the Windows tools require
+    # that the exported symbols are part of the DLL target. The unfortunate side
+    # effect of this is that a single configuration cannot output both the
+    # static library and the DLL: This results in an either/or situation.
+    # Windows users of the draco build can have a DLL and an import library,
+    # or they can have a static library; they cannot have both from a single
+    # configuration of the build.
+    if(BUILD_SHARED_LIBS)
+      set(draco_lib_type SHARED)
+    else()
+      set(draco_lib_type STATIC)
+    endif()
+    draco_add_library(NAME
+                      draco
+                      OUTPUT_NAME
+                      draco
+                      TYPE
+                      ${draco_lib_type}
+                      DEFINES
+                      ${draco_defines}
+                      INCLUDES
+                      ${draco_include_paths}
+                      OBJLIB_DEPS
+                      ${draco_object_library_deps})
+
+  else()
+    draco_add_library(NAME
+                      draco_static
+                      OUTPUT_NAME
+                      draco
+                      TYPE
+                      STATIC
+                      DEFINES
+                      ${draco_defines}
+                      INCLUDES
+                      ${draco_include_paths}
+                      OBJLIB_DEPS
+                      ${draco_object_library_deps})
+
+    if(BUILD_SHARED_LIBS)
+      draco_add_library(NAME
+                        draco_shared
+                        SOURCES
+                        "${draco_src_root}/core/draco_version.h"
+                        OUTPUT_NAME
+                        draco
+                        TYPE
+                        SHARED
+                        DEFINES
+                        ${draco_defines}
+                        INCLUDES
+                        ${draco_include_paths}
+                        LIB_DEPS
+                        draco_static)
+    endif()
+  endif()
+
+  if(DRACO_UNITY_PLUGIN)
+    if(IOS)
+      set(unity_decoder_lib_type STATIC)
+    else()
+      set(unity_decoder_lib_type MODULE)
+    endif()
+
+    draco_add_library(NAME draco_unity_plugin TYPE OBJECT SOURCES
+                      ${draco_unity_plug_sources} DEFINES ${draco_defines}
+                      INCLUDES ${draco_include_paths})
+
+    draco_add_library(NAME
+                      dracodec_unity
+                      TYPE
+                      ${unity_decoder_lib_type}
+                      DEFINES
+                      ${draco_defines}
+                      INCLUDES
+                      ${draco_include_paths}
+                      OBJLIB_DEPS
+                      draco_unity_plugin
+                      LIB_DEPS
+                      ${draco_plugin_dependency})
+
+    # For Mac, we need to build a .bundle for the unity plugin.
+    if(APPLE)
+      set_target_properties(dracodec_unity PROPERTIES BUNDLE true)
+    endif()
+  endif()
+
+  if(DRACO_MAYA_PLUGIN)
+    draco_add_library(NAME draco_maya_plugin TYPE OBJECT SOURCES
+                      ${draco_maya_plug_sources} DEFINES ${draco_defines}
+                      INCLUDES ${draco_include_paths})
+
+    draco_add_library(NAME
+                      draco_maya_wrapper
+                      TYPE
+                      MODULE
+                      DEFINES
+                      ${draco_defines}
+                      INCLUDES
+                      ${draco_include_paths}
+                      OBJLIB_DEPS
+                      draco_maya_plugin
+                      LIB_DEPS
+                      ${draco_plugin_dependency})
+
+    # For Mac, we need to build a .bundle for the plugin.
+    if(APPLE)
+      set_target_properties(draco_maya_wrapper PROPERTIES BUNDLE true)
+    endif()
+  endif()
+
+  # Draco app targets.
+  draco_add_executable(NAME
+                       draco_decoder
+                       SOURCES
+                       "${draco_src_root}/tools/draco_decoder.cc"
+                       ${draco_io_sources}
+                       DEFINES
+                       ${draco_defines}
+                       INCLUDES
+                       ${draco_include_paths}
+                       LIB_DEPS
+                       ${draco_dependency})
+
+  draco_add_executable(NAME
+                       draco_encoder
+                       SOURCES
+                       "${draco_src_root}/tools/draco_encoder.cc"
+                       ${draco_io_sources}
+                       DEFINES
+                       ${draco_defines}
+                       INCLUDES
+                       ${draco_include_paths}
+                       LIB_DEPS
+                       ${draco_dependency})
+
+  draco_setup_install_target()
+  draco_setup_test_targets()
+endif()
+
+if(DRACO_VERBOSE)
+  draco_dump_cmake_flag_variables()
+  draco_dump_tracked_configuration_variables()
+  draco_dump_options()
+endif()
diff --git a/Engine/lib/assimp/contrib/draco/CONTRIBUTING.md b/Engine/lib/assimp/contrib/draco/CONTRIBUTING.md
new file mode 100644
index 000000000..b7bab3447
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/CONTRIBUTING.md
@@ -0,0 +1,27 @@
+Want to contribute? Great! First, read this page (including the small print at the end).
+
+### Before you contribute
+Before we can use your code, you must sign the
+[Google Individual Contributor License Agreement](https://cla.developers.google.com/about/google-individual)
+(CLA), which you can do online. The CLA is necessary mainly because you own the
+copyright to your changes, even after your contribution becomes part of our
+codebase, so we need your permission to use and distribute your code. We also
+need to be sure of various other things—for instance that you'll tell us if you
+know that your code infringes on other people's patents. You don't have to sign
+the CLA until after you've submitted your code for review and a member has
+approved it, but you must do it before we can put your code into our codebase.
+Before you start working on a larger contribution, you should get in touch with
+us first through the issue tracker with your idea so that we can help out and
+possibly guide you. Coordinating up front makes it much easier to avoid
+frustration later on.
+
+### Code reviews
+All submissions, including submissions by project members, require review. We
+use GitHub pull requests for this purpose.
+Please make sure that your code conforms with our
+[coding style guidelines](https://google.github.io/styleguide/cppguide.html).
+
+### The small print
+Contributions made by corporations are covered by a different agreement than
+the one above, the
+[Software Grant and Corporate Contributor License Agreement](https://cla.developers.google.com/about/google-corporate).
diff --git a/Engine/lib/assimp/contrib/draco/LICENSE b/Engine/lib/assimp/contrib/draco/LICENSE
new file mode 100644
index 000000000..301095454
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/LICENSE
@@ -0,0 +1,252 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+--------------------------------------------------------------------------------
+Files: docs/assets/js/ASCIIMathML.js
+
+Copyright (c) 2014 Peter Jipsen and other ASCIIMathML.js contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+--------------------------------------------------------------------------------
+Files: docs/assets/css/pygments/*
+
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org>
diff --git a/Engine/lib/assimp/contrib/draco/README.md b/Engine/lib/assimp/contrib/draco/README.md
new file mode 100644
index 000000000..0d980b387
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/README.md
@@ -0,0 +1,478 @@
+<p align="center">
+<img width="350px" src="docs/artwork/draco3d-vert.svg" />
+</p>
+
+[![Build Status](https://github.com/google/draco/workflows/Build/badge.svg)](https://github.com/google/draco/actions?query=workflow%3ABuild)
+
+News
+=======
+### Version 1.4.1 release
+* Using the versioned www.gstatic.com WASM and Javascript decoders is now
+  recommended. To use v1.4.1, use this URL:
+  * https://www.gstatic.com/draco/versioned/decoders/1.4.1/*
+    * Replace the * with the files to load. E.g.
+    * https://www.gstatic.com/draco/versioned/decoders/1.4.1/draco_decoder.js
+  * This works with the v1.3.6 and v1.4.0 releases, and will work with future
+    Draco releases.
+* Bug fixes
+
+### Version 1.4.0 release
+* WASM and JavaScript decoders are hosted from a static URL.
+  * It is recommended to always pull your Draco WASM and JavaScript decoders from this URL:
+  * https://www.gstatic.com/draco/v1/decoders/*
+    * Replace * with the files to load. E.g.
+    * https://www.gstatic.com/draco/v1/decoders/draco_decoder_gltf.wasm
+  * Users will benefit from having the Draco decoder in cache as more sites start using the static URL
+* Changed npm modules to use WASM, which increased performance by ~200%.
+* Updated Emscripten to 2.0.
+  * This causes the Draco codec modules to return a promise instead of the module directly.
+  * Please see the example code on how to handle the promise.
+* Changed NORMAL quantization default to 8.
+* Added new array API to decoder and deprecated DecoderBuffer.
+  * See PR https://github.com/google/draco/issues/513 for more information.
+* Changed WASM/JavaScript behavior of catching exceptions.
+  * See issue https://github.com/google/draco/issues/629 for more information.
+* Code cleanup.
+* Emscripten builds now disable NODEJS_CATCH_EXIT and NODEJS_CATCH_REJECTION.
+  * Authors of a CLI tool might want to add their own error handlers.
+* Added Maya plugin builds.
+* Unity plugin builds updated.
+  * Builds are now stored as archives.
+  * Added iOS build.
+  * Unity users may want to look into https://github.com/atteneder/DracoUnity.
+* Bug fixes.
+
+### Version 1.3.6 release
+* WASM and JavaScript decoders are now hosted from a static URL
+  * It is recommended to always pull your Draco WASM and JavaScript decoders from this URL:
+  * https://www.gstatic.com/draco/v1/decoders/*
+    * Replace * with the files to load. E.g.
+    * https://www.gstatic.com/draco/v1/decoders/draco_decoder_gltf.wasm
+  * Users will benefit from having the Draco decoder in cache as more sites start using the static URL
+* Changed web examples to pull Draco decoders from static URL
+* Added new API to Draco WASM decoder, which increased performance by ~15%
+* Decreased Draco WASM decoder size by ~20%
+* Added support for generic and multiple attributes to Draco Unity plug-ins
+* Added new API to Draco Unity, which increased decoder performance by ~15%
+* Changed quantization defaults:
+  * POSITION: 11
+  * NORMAL: 7
+  * TEX_COORD: 10
+  * COLOR: 8
+  * GENERIC: 8
+* Code cleanup
+* Bug fixes
+
+### Version 1.3.5 release
+* Added option to build Draco for Universal Scene Description
+* Code cleanup
+* Bug fixes
+
+### Version 1.3.4 release
+* Released Draco Animation code
+* Fixes for Unity
+* Various file location and name changes
+
+### Version 1.3.3 release
+* Added ExpertEncoder to the Javascript API
+  * Allows developers to set quantization options per attribute id
+* Bug fixes
+
+### Version 1.3.2 release
+* Bug fixes
+
+### Version 1.3.1 release
+* Fix issue with multiple attributes when skipping an attribute transform
+
+### Version 1.3.0 release
+* Improved kD-tree based point cloud encoding
+  * Now applicable to point clouds with any number of attributes
+  * Support for all integer attribute types and quantized floating point types
+* Improved mesh compression up to 10% (on average ~2%)
+  * For meshes, the 1.3.0 bitstream is fully compatible with 1.2.x decoders
+* Improved Javascript API
+  * Added support for all signed and unsigned integer types
+  * Added support for point clouds to our Javascript encoder API
+* Added support for integer properties to the PLY decoder
+* Bug fixes
+
+### Previous releases
+https://github.com/google/draco/releases
+
+Description
+===========
+
+Draco is a library for compressing and decompressing 3D geometric [meshes] and
+[point clouds]. It is intended to improve the storage and transmission of 3D
+graphics.
+
+Draco was designed and built for compression efficiency and speed. The code
+supports compressing points, connectivity information, texture coordinates,
+color information, normals, and any other generic attributes associated with
+geometry. With Draco, applications using 3D graphics can be significantly
+smaller without compromising visual fidelity. For users, this means apps can
+now be downloaded faster, 3D graphics in the browser can load quicker, and VR
+and AR scenes can now be transmitted with a fraction of the bandwidth and
+rendered quickly.
+
+Draco is released as C++ source code that can be used to compress 3D graphics
+as well as C++ and Javascript decoders for the encoded data.
+
+
+_**Contents**_
+
+  * [Building](#building)
+  * [Usage](#usage)
+    * [Unity](#unity)
+    * [WASM and JavaScript Decoders](#WASM-and-JavaScript-Decoders)
+    * [Command Line Applications](#command-line-applications)
+    * [Encoding Tool](#encoding-tool)
+    * [Encoding Point Clouds](#encoding-point-clouds)
+    * [Decoding Tool](#decoding-tool)
+    * [C++ Decoder API](#c-decoder-api)
+    * [Javascript Encoder API](#javascript-encoder-api)
+    * [Javascript Decoder API](#javascript-decoder-api)
+    * [Javascript Decoder Performance](#javascript-decoder-performance)
+    * [Metadata API](#metadata-api)
+    * [NPM Package](#npm-package)
+    * [three.js Renderer Example](#threejs-renderer-example)
+  * [Support](#support)
+  * [License](#license)
+  * [References](#references)
+
+
+Building
+========
+See [BUILDING](BUILDING.md) for building instructions.
+
+
+Usage
+======
+
+Unity
+-----
+For the best information about using Unity with Draco please visit https://github.com/atteneder/DracoUnity
+
+For a simple example of using Unity with Draco see [README](unity/README.md) in the unity folder.
+
+WASM and JavaScript Decoders
+----------------------------
+
+It is recommended to always pull your Draco WASM and JavaScript decoders from:
+
+~~~~~ bash
+https://www.gstatic.com/draco/v1/decoders/
+~~~~~
+
+Users will benefit from having the Draco decoder in cache as more sites start using the static URL.
+
+Command Line Applications
+------------------------
+
+The default target created from the build files will be the `draco_encoder`
+and `draco_decoder` command line applications. For both applications, if you
+run them without any arguments or `-h`, the applications will output usage and
+options.
+
+Encoding Tool
+-------------
+
+`draco_encoder` will read OBJ or PLY files as input, and output Draco-encoded
+files. We have included Stanford's [Bunny] mesh for testing. The basic command
+line looks like this:
+
+~~~~~ bash
+./draco_encoder -i testdata/bun_zipper.ply -o out.drc
+~~~~~
+
+A value of `0` for the quantization parameter will not perform any quantization
+on the specified attribute. Any value other than `0` will quantize the input
+values for the specified attribute to that number of bits. For example:
+
+~~~~~ bash
+./draco_encoder -i testdata/bun_zipper.ply -o out.drc -qp 14
+~~~~~
+
+will quantize the positions to 14 bits (default is 11 for the position
+coordinates).
+
+In general, the more you quantize your attributes the better compression rate
+you will get. It is up to your project to decide how much deviation it will
+tolerate. In general, most projects can set quantization values of about `11`
+without any noticeable difference in quality.
+
+The compression level (`-cl`) parameter turns on/off different compression
+features.
+
+~~~~~ bash
+./draco_encoder -i testdata/bun_zipper.ply -o out.drc -cl 8
+~~~~~
+
+In general, the highest setting, `10`, will have the most compression but
+worst decompression speed. `0` will have the least compression, but best
+decompression speed. The default setting is `7`.
+
+Encoding Point Clouds
+---------------------
+
+You can encode point cloud data with `draco_encoder` by specifying the
+`-point_cloud` parameter. If you specify the `-point_cloud` parameter with a
+mesh input file, `draco_encoder` will ignore the connectivity data and encode
+the positions from the mesh file.
+
+~~~~~ bash
+./draco_encoder -point_cloud -i testdata/bun_zipper.ply -o out.drc
+~~~~~
+
+This command line will encode the mesh input as a point cloud, even though the
+input might not produce compression that is representative of other point
+clouds. Specifically, one can expect much better compression rates for larger
+and denser point clouds.
+
+Decoding Tool
+-------------
+
+`draco_decoder` will read Draco files as input, and output OBJ or PLY files.
+The basic command line looks like this:
+
+~~~~~ bash
+./draco_decoder -i in.drc -o out.obj
+~~~~~
+
+C++ Decoder API
+-------------
+
+If you'd like to add decoding to your applications you will need to include
+the `draco_dec` library. In order to use the Draco decoder you need to
+initialize a `DecoderBuffer` with the compressed data. Then call
+`DecodeMeshFromBuffer()` to return a decoded mesh object or call
+`DecodePointCloudFromBuffer()` to return a decoded `PointCloud` object. For
+example:
+
+~~~~~ cpp
+draco::DecoderBuffer buffer;
+buffer.Init(data.data(), data.size());
+
+const draco::EncodedGeometryType geom_type =
+    draco::GetEncodedGeometryType(&buffer);
+if (geom_type == draco::TRIANGULAR_MESH) {
+  unique_ptr<draco::Mesh> mesh = draco::DecodeMeshFromBuffer(&buffer);
+} else if (geom_type == draco::POINT_CLOUD) {
+  unique_ptr<draco::PointCloud> pc = draco::DecodePointCloudFromBuffer(&buffer);
+}
+~~~~~
+
+Please see [src/draco/mesh/mesh.h](src/draco/mesh/mesh.h) for the full `Mesh` class interface and
+[src/draco/point_cloud/point_cloud.h](src/draco/point_cloud/point_cloud.h) for the full `PointCloud` class interface.
+
+
+Javascript Encoder API
+----------------------
+The Javascript encoder is located in `javascript/draco_encoder.js`. The encoder
+API can be used to compress mesh and point cloud. In order to use the encoder,
+you need to first create an instance of `DracoEncoderModule`. Then use this
+instance to create `MeshBuilder` and `Encoder` objects. `MeshBuilder` is used
+to construct a mesh from geometry data that could be later compressed by
+`Encoder`. First create a mesh object using `new encoderModule.Mesh()` . Then,
+use `AddFacesToMesh()` to add indices to the mesh and use
+`AddFloatAttributeToMesh()` to add attribute data to the mesh, e.g. position,
+normal, color and texture coordinates. After a mesh is constructed, you could
+then use `EncodeMeshToDracoBuffer()` to compress the mesh. For example:
+
+~~~~~ js
+const mesh = {
+  indices : new Uint32Array(indices),
+  vertices : new Float32Array(vertices),
+  normals : new Float32Array(normals)
+};
+
+const encoderModule = DracoEncoderModule();
+const encoder = new encoderModule.Encoder();
+const meshBuilder = new encoderModule.MeshBuilder();
+const dracoMesh = new encoderModule.Mesh();
+
+const numFaces = mesh.indices.length / 3;
+const numPoints = mesh.vertices.length;
+meshBuilder.AddFacesToMesh(dracoMesh, numFaces, mesh.indices);
+
+meshBuilder.AddFloatAttributeToMesh(dracoMesh, encoderModule.POSITION,
+  numPoints, 3, mesh.vertices);
+if (mesh.hasOwnProperty('normals')) {
+  meshBuilder.AddFloatAttributeToMesh(
+    dracoMesh, encoderModule.NORMAL, numPoints, 3, mesh.normals);
+}
+if (mesh.hasOwnProperty('colors')) {
+  meshBuilder.AddFloatAttributeToMesh(
+    dracoMesh, encoderModule.COLOR, numPoints, 3, mesh.colors);
+}
+if (mesh.hasOwnProperty('texcoords')) {
+  meshBuilder.AddFloatAttributeToMesh(
+    dracoMesh, encoderModule.TEX_COORD, numPoints, 3, mesh.texcoords);
+}
+
+if (method === "edgebreaker") {
+  encoder.SetEncodingMethod(encoderModule.MESH_EDGEBREAKER_ENCODING);
+} else if (method === "sequential") {
+  encoder.SetEncodingMethod(encoderModule.MESH_SEQUENTIAL_ENCODING);
+}
+
+const encodedData = new encoderModule.DracoInt8Array();
+// Use default encoding setting.
+const encodedLen = encoder.EncodeMeshToDracoBuffer(dracoMesh,
+                                                   encodedData);
+encoderModule.destroy(dracoMesh);
+encoderModule.destroy(encoder);
+encoderModule.destroy(meshBuilder);
+
+~~~~~
+Please see [src/draco/javascript/emscripten/draco_web_encoder.idl](src/draco/javascript/emscripten/draco_web_encoder.idl) for the full API.
+
+Javascript Decoder API
+----------------------
+
+The Javascript decoder is located in [javascript/draco_decoder.js](javascript/draco_decoder.js). The
+Javascript decoder can decode mesh and point cloud. In order to use the
+decoder, you must first create an instance of `DracoDecoderModule`. The
+instance is then used to create `DecoderBuffer` and `Decoder` objects. Set
+the encoded data in the `DecoderBuffer`. Then call `GetEncodedGeometryType()`
+to identify the type of geometry, e.g. mesh or point cloud. Then call either
+`DecodeBufferToMesh()` or `DecodeBufferToPointCloud()`, which will return
+a Mesh object or a point cloud. For example:
+
+~~~~~ js
+// Create the Draco decoder.
+const decoderModule = DracoDecoderModule();
+const buffer = new decoderModule.DecoderBuffer();
+buffer.Init(byteArray, byteArray.length);
+
+// Create a buffer to hold the encoded data.
+const decoder = new decoderModule.Decoder();
+const geometryType = decoder.GetEncodedGeometryType(buffer);
+
+// Decode the encoded geometry.
+let outputGeometry;
+let status;
+if (geometryType == decoderModule.TRIANGULAR_MESH) {
+  outputGeometry = new decoderModule.Mesh();
+  status = decoder.DecodeBufferToMesh(buffer, outputGeometry);
+} else {
+  outputGeometry = new decoderModule.PointCloud();
+  status = decoder.DecodeBufferToPointCloud(buffer, outputGeometry);
+}
+
+// You must explicitly delete objects created from the DracoDecoderModule
+// or Decoder.
+decoderModule.destroy(outputGeometry);
+decoderModule.destroy(decoder);
+decoderModule.destroy(buffer);
+~~~~~
+
+Please see [src/draco/javascript/emscripten/draco_web_decoder.idl](src/draco/javascript/emscripten/draco_web_decoder.idl) for the full API.
+
+Javascript Decoder Performance
+------------------------------
+
+The Javascript decoder is built with dynamic memory. This will let the decoder
+work with all of the compressed data. But this option is not the fastest.
+Pre-allocating the memory sees about a 2x decoder speed improvement. If you
+know all of your project's memory requirements, you can turn on static memory
+by changing `CMakeLists.txt` accordingly.
+
+Metadata API
+------------
+Starting from v1.0, Draco provides metadata functionality for encoding data
+other than geometry. It could be used to encode any custom data along with the
+geometry. For example, we can enable metadata functionality to encode the name
+of attributes, name of sub-objects and customized information.
+For one mesh and point cloud, it can have one top-level geometry metadata class.
+The top-level metadata then can have hierarchical metadata. Other than that,
+the top-level metadata can have metadata for each attribute which is called
+attribute metadata. The attribute metadata should be initialized with the
+correspondent attribute id within the mesh. The metadata API is provided both
+in C++ and Javascript.
+For example, to add metadata in C++:
+
+~~~~~ cpp
+draco::PointCloud pc;
+// Add metadata for the geometry.
+std::unique_ptr<draco::GeometryMetadata> metadata =
+  std::unique_ptr<draco::GeometryMetadata>(new draco::GeometryMetadata());
+metadata->AddEntryString("description", "This is an example.");
+pc.AddMetadata(std::move(metadata));
+
+// Add metadata for attributes.
+draco::GeometryAttribute pos_att;
+pos_att.Init(draco::GeometryAttribute::POSITION, nullptr, 3,
+             draco::DT_FLOAT32, false, 12, 0);
+const uint32_t pos_att_id = pc.AddAttribute(pos_att, false, 0);
+
+std::unique_ptr<draco::AttributeMetadata> pos_metadata =
+    std::unique_ptr<draco::AttributeMetadata>(
+        new draco::AttributeMetadata(pos_att_id));
+pos_metadata->AddEntryString("name", "position");
+
+// Directly add attribute metadata to geometry.
+// You can do this without explicitly add |GeometryMetadata| to mesh.
+pc.AddAttributeMetadata(pos_att_id, std::move(pos_metadata));
+~~~~~
+
+To read metadata from a geometry in C++:
+
+~~~~~ cpp
+// Get metadata for the geometry.
+const draco::GeometryMetadata *pc_metadata = pc.GetMetadata();
+
+// Request metadata for a specific attribute.
+const draco::AttributeMetadata *requested_pos_metadata =
+  pc.GetAttributeMetadataByStringEntry("name", "position");
+~~~~~
+
+Please see [src/draco/metadata](src/draco/metadata) and [src/draco/point_cloud](src/draco/point_cloud) for the full API.
+
+NPM Package
+-----------
+Draco NPM NodeJS package is located in [javascript/npm/draco3d](javascript/npm/draco3d). Please see the
+doc in the folder for detailed usage.
+
+three.js Renderer Example
+-------------------------
+
+Here's an [example] of a geometric compressed with Draco loaded via a
+Javascript decoder using the `three.js` renderer.
+
+Please see the [javascript/example/README.md](javascript/example/README.md) file for more information.
+
+Support
+=======
+
+For questions/comments please email <draco-3d-discuss@googlegroups.com>
+
+If you have found an error in this library, please file an issue at
+<https://github.com/google/draco/issues>
+
+Patches are encouraged, and may be submitted by forking this project and
+submitting a pull request through GitHub. See [CONTRIBUTING] for more detail.
+
+License
+=======
+Licensed under the Apache License, Version 2.0 (the "License"); you may not
+use this file except in compliance with the License. You may obtain a copy of
+the License at
+
+<http://www.apache.org/licenses/LICENSE-2.0>
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+License for the specific language governing permissions and limitations under
+the License.
+
+References
+==========
+[example]:https://storage.googleapis.com/demos.webmproject.org/draco/draco_loader_throw.html
+[meshes]: https://en.wikipedia.org/wiki/Polygon_mesh
+[point clouds]: https://en.wikipedia.org/wiki/Point_cloud
+[Bunny]: https://graphics.stanford.edu/data/3Dscanrep/
+[CONTRIBUTING]: https://raw.githubusercontent.com/google/draco/master/CONTRIBUTING.md
+
+Bunny model from Stanford's graphic department <https://graphics.stanford.edu/data/3Dscanrep/>
diff --git a/Engine/lib/assimp/contrib/draco/cmake/DracoConfig.cmake b/Engine/lib/assimp/contrib/draco/cmake/DracoConfig.cmake
new file mode 100644
index 000000000..be5e1faef
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/DracoConfig.cmake
@@ -0,0 +1,3 @@
+@PACKAGE_INIT@
+set_and_check(draco_INCLUDE_DIR "@PACKAGE_draco_include_install_dir@")
+set_and_check(draco_LIBRARY_DIR "@PACKAGE_draco_lib_install_dir@")
diff --git a/Engine/lib/assimp/contrib/draco/cmake/FindDraco.cmake b/Engine/lib/assimp/contrib/draco/cmake/FindDraco.cmake
new file mode 100644
index 000000000..0a9193065
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/FindDraco.cmake
@@ -0,0 +1,56 @@
+# Finddraco
+#
+# Locates draco and sets the following variables:
+#
+# draco_FOUND draco_INCLUDE_DIRS draco_LIBARY_DIRS draco_LIBRARIES
+# draco_VERSION_STRING
+#
+# draco_FOUND is set to YES only when all other variables are successfully
+# configured.
+
+unset(draco_FOUND)
+unset(draco_INCLUDE_DIRS)
+unset(draco_LIBRARY_DIRS)
+unset(draco_LIBRARIES)
+unset(draco_VERSION_STRING)
+
+mark_as_advanced(draco_FOUND)
+mark_as_advanced(draco_INCLUDE_DIRS)
+mark_as_advanced(draco_LIBRARY_DIRS)
+mark_as_advanced(draco_LIBRARIES)
+mark_as_advanced(draco_VERSION_STRING)
+
+set(draco_version_file_no_prefix "draco/src/draco/core/draco_version.h")
+
+# Set draco_INCLUDE_DIRS
+find_path(draco_INCLUDE_DIRS NAMES "${draco_version_file_no_prefix}")
+
+# Extract the version string from draco_version.h.
+if(draco_INCLUDE_DIRS)
+  set(draco_version_file
+      "${draco_INCLUDE_DIRS}/draco/src/draco/core/draco_version.h")
+  file(STRINGS "${draco_version_file}" draco_version REGEX "kdracoVersion")
+  list(GET draco_version 0 draco_version)
+  string(REPLACE "static const char kdracoVersion[] = " "" draco_version
+                 "${draco_version}")
+  string(REPLACE ";" "" draco_version "${draco_version}")
+  string(REPLACE "\"" "" draco_version "${draco_version}")
+  set(draco_VERSION_STRING ${draco_version})
+endif()
+
+# Find the library.
+if(BUILD_SHARED_LIBS)
+  find_library(draco_LIBRARIES NAMES draco.dll libdraco.dylib libdraco.so)
+else()
+  find_library(draco_LIBRARIES NAMES draco.lib libdraco.a)
+endif()
+
+# Store path to library.
+get_filename_component(draco_LIBRARY_DIRS ${draco_LIBRARIES} DIRECTORY)
+
+if(draco_INCLUDE_DIRS
+   AND draco_LIBRARY_DIRS
+   AND draco_LIBRARIES
+   AND draco_VERSION_STRING)
+  set(draco_FOUND YES)
+endif()
diff --git a/Engine/lib/assimp/contrib/draco/cmake/compiler_flags.cmake b/Engine/lib/assimp/contrib/draco/cmake/compiler_flags.cmake
new file mode 100644
index 000000000..8750e6f7d
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/compiler_flags.cmake
@@ -0,0 +1,220 @@
+if(DRACO_CMAKE_COMPILER_FLAGS_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_COMPILER_FLAGS_CMAKE_ 1)
+
+include(CheckCCompilerFlag)
+include(CheckCXXCompilerFlag)
+include("${draco_root}/cmake/compiler_tests.cmake")
+
+# Strings used to cache failed C/CXX flags.
+set(DRACO_FAILED_C_FLAGS)
+set(DRACO_FAILED_CXX_FLAGS)
+
+# Checks C compiler for support of $c_flag. Adds $c_flag to $CMAKE_C_FLAGS when
+# the compile test passes. Caches $c_flag in $DRACO_FAILED_C_FLAGS when the test
+# fails.
+macro(add_c_flag_if_supported c_flag)
+  unset(C_FLAG_FOUND CACHE)
+  string(FIND "${CMAKE_C_FLAGS}" "${c_flag}" C_FLAG_FOUND)
+  unset(C_FLAG_FAILED CACHE)
+  string(FIND "${DRACO_FAILED_C_FLAGS}" "${c_flag}" C_FLAG_FAILED)
+
+  if(${C_FLAG_FOUND} EQUAL -1 AND ${C_FLAG_FAILED} EQUAL -1)
+    unset(C_FLAG_SUPPORTED CACHE)
+    message("Checking C compiler flag support for: " ${c_flag})
+    check_c_compiler_flag("${c_flag}" C_FLAG_SUPPORTED)
+    if(${C_FLAG_SUPPORTED})
+      set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${c_flag}" CACHE STRING "")
+    else()
+      set(DRACO_FAILED_C_FLAGS
+          "${DRACO_FAILED_C_FLAGS} ${c_flag}"
+          CACHE STRING "" FORCE)
+    endif()
+  endif()
+endmacro()
+
+# Checks C++ compiler for support of $cxx_flag. Adds $cxx_flag to
+# $CMAKE_CXX_FLAGS when the compile test passes. Caches $c_flag in
+# $DRACO_FAILED_CXX_FLAGS when the test fails.
+macro(add_cxx_flag_if_supported cxx_flag)
+  unset(CXX_FLAG_FOUND CACHE)
+  string(FIND "${CMAKE_CXX_FLAGS}" "${cxx_flag}" CXX_FLAG_FOUND)
+  unset(CXX_FLAG_FAILED CACHE)
+  string(FIND "${DRACO_FAILED_CXX_FLAGS}" "${cxx_flag}" CXX_FLAG_FAILED)
+
+  if(${CXX_FLAG_FOUND} EQUAL -1 AND ${CXX_FLAG_FAILED} EQUAL -1)
+    unset(CXX_FLAG_SUPPORTED CACHE)
+    message("Checking CXX compiler flag support for: " ${cxx_flag})
+    check_cxx_compiler_flag("${cxx_flag}" CXX_FLAG_SUPPORTED)
+    if(${CXX_FLAG_SUPPORTED})
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${cxx_flag}" CACHE STRING "")
+    else()
+      set(DRACO_FAILED_CXX_FLAGS
+          "${DRACO_FAILED_CXX_FLAGS} ${cxx_flag}"
+          CACHE STRING "" FORCE)
+    endif()
+  endif()
+endmacro()
+
+# Convenience method for adding a flag to both the C and C++ compiler command
+# lines.
+macro(add_compiler_flag_if_supported flag)
+  add_c_flag_if_supported(${flag})
+  add_cxx_flag_if_supported(${flag})
+endmacro()
+
+# Checks C compiler for support of $c_flag and terminates generation when
+# support is not present.
+macro(require_c_flag c_flag update_c_flags)
+  unset(C_FLAG_FOUND CACHE)
+  string(FIND "${CMAKE_C_FLAGS}" "${c_flag}" C_FLAG_FOUND)
+
+  if(${C_FLAG_FOUND} EQUAL -1)
+    unset(HAVE_C_FLAG CACHE)
+    message("Checking C compiler flag support for: " ${c_flag})
+    check_c_compiler_flag("${c_flag}" HAVE_C_FLAG)
+    if(NOT ${HAVE_C_FLAG})
+      message(
+        FATAL_ERROR "${PROJECT_NAME} requires support for C flag: ${c_flag}.")
+    endif()
+    if(${update_c_flags})
+      set(CMAKE_C_FLAGS "${c_flag} ${CMAKE_C_FLAGS}" CACHE STRING "" FORCE)
+    endif()
+  endif()
+endmacro()
+
+# Checks CXX compiler for support of $cxx_flag and terminates generation when
+# support is not present.
+macro(require_cxx_flag cxx_flag update_cxx_flags)
+  unset(CXX_FLAG_FOUND CACHE)
+  string(FIND "${CMAKE_CXX_FLAGS}" "${cxx_flag}" CXX_FLAG_FOUND)
+
+  if(${CXX_FLAG_FOUND} EQUAL -1)
+    unset(HAVE_CXX_FLAG CACHE)
+    message("Checking CXX compiler flag support for: " ${cxx_flag})
+    check_cxx_compiler_flag("${cxx_flag}" HAVE_CXX_FLAG)
+    if(NOT ${HAVE_CXX_FLAG})
+      message(
+        FATAL_ERROR
+          "${PROJECT_NAME} requires support for CXX flag: ${cxx_flag}.")
+    endif()
+    if(${update_cxx_flags})
+      set(CMAKE_CXX_FLAGS
+          "${cxx_flag} ${CMAKE_CXX_FLAGS}"
+          CACHE STRING "" FORCE)
+    endif()
+  endif()
+endmacro()
+
+# Checks for support of $flag by both the C and CXX compilers. Terminates
+# generation when support is not present in both compilers.
+macro(require_compiler_flag flag update_cmake_flags)
+  require_c_flag(${flag} ${update_cmake_flags})
+  require_cxx_flag(${flag} ${update_cmake_flags})
+endmacro()
+
+# Checks only non-MSVC targets for support of $c_flag and terminates generation
+# when support is not present.
+macro(require_c_flag_nomsvc c_flag update_c_flags)
+  if(NOT MSVC)
+    require_c_flag(${c_flag} ${update_c_flags})
+  endif()
+endmacro()
+
+# Checks only non-MSVC targets for support of $cxx_flag and terminates
+# generation when support is not present.
+macro(require_cxx_flag_nomsvc cxx_flag update_cxx_flags)
+  if(NOT MSVC)
+    require_cxx_flag(${cxx_flag} ${update_cxx_flags})
+  endif()
+endmacro()
+
+# Checks only non-MSVC targets for support of $flag by both the C and CXX
+# compilers. Terminates generation when support is not present in both
+# compilers.
+macro(require_compiler_flag_nomsvc flag update_cmake_flags)
+  require_c_flag_nomsvc(${flag} ${update_cmake_flags})
+  require_cxx_flag_nomsvc(${flag} ${update_cmake_flags})
+endmacro()
+
+# Adds $flag to assembler command line.
+macro(append_as_flag flag)
+  unset(AS_FLAG_FOUND CACHE)
+  string(FIND "${DRACO_AS_FLAGS}" "${flag}" AS_FLAG_FOUND)
+
+  if(${AS_FLAG_FOUND} EQUAL -1)
+    set(DRACO_AS_FLAGS "${DRACO_AS_FLAGS} ${flag}")
+  endif()
+endmacro()
+
+# Adds $flag to the C compiler command line.
+macro(append_c_flag flag)
+  unset(C_FLAG_FOUND CACHE)
+  string(FIND "${CMAKE_C_FLAGS}" "${flag}" C_FLAG_FOUND)
+
+  if(${C_FLAG_FOUND} EQUAL -1)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${flag}")
+  endif()
+endmacro()
+
+# Adds $flag to the CXX compiler command line.
+macro(append_cxx_flag flag)
+  unset(CXX_FLAG_FOUND CACHE)
+  string(FIND "${CMAKE_CXX_FLAGS}" "${flag}" CXX_FLAG_FOUND)
+
+  if(${CXX_FLAG_FOUND} EQUAL -1)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}")
+  endif()
+endmacro()
+
+# Adds $flag to the C and CXX compiler command lines.
+macro(append_compiler_flag flag)
+  append_c_flag(${flag})
+  append_cxx_flag(${flag})
+endmacro()
+
+# Adds $flag to the executable linker command line.
+macro(append_exe_linker_flag flag)
+  unset(LINKER_FLAG_FOUND CACHE)
+  string(FIND "${CMAKE_EXE_LINKER_FLAGS}" "${flag}" LINKER_FLAG_FOUND)
+
+  if(${LINKER_FLAG_FOUND} EQUAL -1)
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${flag}")
+  endif()
+endmacro()
+
+# Adds $flag to the link flags for $target.
+function(append_link_flag_to_target target flags)
+  unset(target_link_flags)
+  get_target_property(target_link_flags ${target} LINK_FLAGS)
+
+  if(target_link_flags)
+    unset(link_flag_found)
+    string(FIND "${target_link_flags}" "${flags}" link_flag_found)
+
+    if(NOT ${link_flag_found} EQUAL -1)
+      return()
+    endif()
+
+    set(target_link_flags "${target_link_flags} ${flags}")
+  else()
+    set(target_link_flags "${flags}")
+  endif()
+
+  set_target_properties(${target} PROPERTIES LINK_FLAGS ${target_link_flags})
+endfunction()
+
+# Adds $flag to executable linker flags, and makes sure C/CXX builds still work.
+macro(require_linker_flag flag)
+  append_exe_linker_flag(${flag})
+
+  unset(c_passed)
+  draco_check_c_compiles("LINKER_FLAG_C_TEST(${flag})" "" c_passed)
+  unset(cxx_passed)
+  draco_check_cxx_compiles("LINKER_FLAG_CXX_TEST(${flag})" "" cxx_passed)
+
+  if(NOT c_passed OR NOT cxx_passed)
+    message(FATAL_ERROR "Linker flag test for ${flag} failed.")
+  endif()
+endmacro()
diff --git a/Engine/lib/assimp/contrib/draco/cmake/compiler_tests.cmake b/Engine/lib/assimp/contrib/draco/cmake/compiler_tests.cmake
new file mode 100644
index 000000000..e781a6537
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/compiler_tests.cmake
@@ -0,0 +1,103 @@
+if(DRACO_CMAKE_COMPILER_TESTS_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_COMPILER_TESTS_CMAKE_ 1)
+
+include(CheckCSourceCompiles)
+include(CheckCXXSourceCompiles)
+
+# The basic main() macro used in all compile tests.
+set(DRACO_C_MAIN "\nint main(void) { return 0; }")
+set(DRACO_CXX_MAIN "\nint main() { return 0; }")
+
+# Strings containing the names of passed and failed tests.
+set(DRACO_C_PASSED_TESTS)
+set(DRACO_C_FAILED_TESTS)
+set(DRACO_CXX_PASSED_TESTS)
+set(DRACO_CXX_FAILED_TESTS)
+
+macro(draco_push_var var new_value)
+  set(SAVED_${var} ${var})
+  set(${var} ${new_value})
+endmacro()
+
+macro(draco_pop_var var)
+  set(var ${SAVED_${var}})
+  unset(SAVED_${var})
+endmacro()
+
+# Confirms $test_source compiles and stores $test_name in one of
+# $DRACO_C_PASSED_TESTS or $DRACO_C_FAILED_TESTS depending on out come. When the
+# test passes $result_var is set to 1. When it fails $result_var is unset. The
+# test is not run if the test name is found in either of the passed or failed
+# test variables.
+macro(draco_check_c_compiles test_name test_source result_var)
+  unset(C_TEST_PASSED CACHE)
+  unset(C_TEST_FAILED CACHE)
+  string(FIND "${DRACO_C_PASSED_TESTS}" "${test_name}" C_TEST_PASSED)
+  string(FIND "${DRACO_C_FAILED_TESTS}" "${test_name}" C_TEST_FAILED)
+  if(${C_TEST_PASSED} EQUAL -1 AND ${C_TEST_FAILED} EQUAL -1)
+    unset(C_TEST_COMPILED CACHE)
+    message("Running C compiler test: ${test_name}")
+    check_c_source_compiles("${test_source} ${DRACO_C_MAIN}" C_TEST_COMPILED)
+    set(${result_var} ${C_TEST_COMPILED})
+
+    if(${C_TEST_COMPILED})
+      set(DRACO_C_PASSED_TESTS "${DRACO_C_PASSED_TESTS} ${test_name}")
+    else()
+      set(DRACO_C_FAILED_TESTS "${DRACO_C_FAILED_TESTS} ${test_name}")
+      message("C Compiler test ${test_name} failed.")
+    endif()
+  elseif(NOT ${C_TEST_PASSED} EQUAL -1)
+    set(${result_var} 1)
+  else() # ${C_TEST_FAILED} NOT EQUAL -1
+    unset(${result_var})
+  endif()
+endmacro()
+
+# Confirms $test_source compiles and stores $test_name in one of
+# $DRACO_CXX_PASSED_TESTS or $DRACO_CXX_FAILED_TESTS depending on out come. When
+# the test passes $result_var is set to 1. When it fails $result_var is unset.
+# The test is not run if the test name is found in either of the passed or
+# failed test variables.
+macro(draco_check_cxx_compiles test_name test_source result_var)
+  unset(CXX_TEST_PASSED CACHE)
+  unset(CXX_TEST_FAILED CACHE)
+  string(FIND "${DRACO_CXX_PASSED_TESTS}" "${test_name}" CXX_TEST_PASSED)
+  string(FIND "${DRACO_CXX_FAILED_TESTS}" "${test_name}" CXX_TEST_FAILED)
+  if(${CXX_TEST_PASSED} EQUAL -1 AND ${CXX_TEST_FAILED} EQUAL -1)
+    unset(CXX_TEST_COMPILED CACHE)
+    message("Running CXX compiler test: ${test_name}")
+    check_cxx_source_compiles("${test_source} ${DRACO_CXX_MAIN}"
+                              CXX_TEST_COMPILED)
+    set(${result_var} ${CXX_TEST_COMPILED})
+
+    if(${CXX_TEST_COMPILED})
+      set(DRACO_CXX_PASSED_TESTS "${DRACO_CXX_PASSED_TESTS} ${test_name}")
+    else()
+      set(DRACO_CXX_FAILED_TESTS "${DRACO_CXX_FAILED_TESTS} ${test_name}")
+      message("CXX Compiler test ${test_name} failed.")
+    endif()
+  elseif(NOT ${CXX_TEST_PASSED} EQUAL -1)
+    set(${result_var} 1)
+  else() # ${CXX_TEST_FAILED} NOT EQUAL -1
+    unset(${result_var})
+  endif()
+endmacro()
+
+# Convenience macro that confirms $test_source compiles as C and C++.
+# $result_var is set to 1 when both tests are successful, and 0 when one or both
+# tests fail. Note: This macro is intended to be used to write to result
+# variables that are expanded via configure_file(). $result_var is set to 1 or 0
+# to allow direct usage of the value in generated source files.
+macro(draco_check_source_compiles test_name test_source result_var)
+  unset(C_PASSED)
+  unset(CXX_PASSED)
+  draco_check_c_compiles(${test_name} ${test_source} C_PASSED)
+  draco_check_cxx_compiles(${test_name} ${test_source} CXX_PASSED)
+  if(${C_PASSED} AND ${CXX_PASSED})
+    set(${result_var} 1)
+  else()
+    set(${result_var} 0)
+  endif()
+endmacro()
diff --git a/Engine/lib/assimp/contrib/draco/cmake/draco-config.cmake.template b/Engine/lib/assimp/contrib/draco/cmake/draco-config.cmake.template
new file mode 100644
index 000000000..ca4a456bf
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/draco-config.cmake.template
@@ -0,0 +1,2 @@
+set(DRACO_INCLUDE_DIRS "@DRACO_INCLUDE_DIRS@")
+set(DRACO_LIBRARIES "draco")
diff --git a/Engine/lib/assimp/contrib/draco/cmake/draco.pc.template b/Engine/lib/assimp/contrib/draco/cmake/draco.pc.template
new file mode 100644
index 000000000..b8ae48212
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/draco.pc.template
@@ -0,0 +1,11 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: @PROJECT_NAME@
+Description: Draco geometry de(com)pression library.
+Version: @DRACO_VERSION@
+Cflags: -I${includedir}
+Libs: -L${libdir} -ldraco
+Libs.private: @CMAKE_THREAD_LIBS_INIT@
diff --git a/Engine/lib/assimp/contrib/draco/cmake/draco_build_definitions.cmake b/Engine/lib/assimp/contrib/draco/cmake/draco_build_definitions.cmake
new file mode 100644
index 000000000..f7354c15f
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/draco_build_definitions.cmake
@@ -0,0 +1,124 @@
+if(DRACO_CMAKE_DRACO_BUILD_DEFINITIONS_CMAKE_)
+  return()
+endif() # DRACO_CMAKE_DRACO_BUILD_DEFINITIONS_CMAKE_
+set(DRACO_CMAKE_DRACO_BUILD_DEFINITIONS_CMAKE_ 1)
+
+# Utility for controlling the main draco library dependency. This changes in
+# shared builds, and when an optional target requires a shared library build.
+macro(set_draco_target)
+  if(MSVC)
+    set(draco_dependency draco)
+    set(draco_plugin_dependency ${draco_dependency})
+  else()
+    if(BUILD_SHARED_LIBS)
+      set(draco_dependency draco_shared)
+    else()
+      set(draco_dependency draco_static)
+    endif()
+    set(draco_plugin_dependency draco_static)
+  endif()
+
+  if(BUILD_SHARED_LIBS)
+    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+  endif()
+endmacro()
+
+# Configures flags and sets build system globals.
+macro(draco_set_build_definitions)
+  string(TOLOWER "${CMAKE_BUILD_TYPE}" build_type_lowercase)
+
+  if(build_type_lowercase MATCHES "rel" AND DRACO_FAST)
+    if(MSVC)
+      list(APPEND draco_msvc_cxx_flags "/Ox")
+    else()
+      list(APPEND draco_base_cxx_flags "-O3")
+    endif()
+  endif()
+
+  draco_load_version_info()
+  set(DRACO_SOVERSION 1)
+
+  list(APPEND draco_include_paths "${draco_root}" "${draco_root}/src"
+              "${draco_build}")
+
+  if(DRACO_ABSL)
+    list(APPEND draco_include_path "${draco_root}/third_party/abseil-cpp")
+  endif()
+
+
+  list(APPEND draco_gtest_include_paths
+              "${draco_root}/../googletest/googlemock/include"
+              "${draco_root}/../googletest/googlemock"
+              "${draco_root}/../googletest/googletest/include"
+              "${draco_root}/../googletest/googletest")
+  list(APPEND draco_test_include_paths ${draco_include_paths}
+              ${draco_gtest_include_paths})
+  list(APPEND draco_defines "DRACO_CMAKE=1"
+              "DRACO_FLAGS_SRCDIR=\"${draco_root}\""
+              "DRACO_FLAGS_TMPDIR=\"/tmp\"")
+
+  if(MSVC OR WIN32)
+    list(APPEND draco_defines "_CRT_SECURE_NO_DEPRECATE=1" "NOMINMAX=1")
+
+    if(BUILD_SHARED_LIBS)
+      set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS TRUE)
+    endif()
+  else()
+    if(${CMAKE_SIZEOF_VOID_P} EQUAL 8)
+      # Ensure 64-bit platforms can support large files.
+      list(APPEND draco_defines "_LARGEFILE_SOURCE" "_FILE_OFFSET_BITS=64")
+    endif()
+  endif()
+
+  if(ANDROID)
+    if(CMAKE_ANDROID_ARCH_ABI STREQUAL "armeabi-v7a")
+      set(CMAKE_ANDROID_ARM_MODE ON)
+    endif()
+  endif()
+
+  set_draco_target()
+
+  if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+    if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6")
+      # Quiet warnings in copy-list-initialization where {} elision has always
+      # been allowed.
+      list(APPEND draco_clang_cxx_flags "-Wno-missing-braces")
+    endif()
+  endif()
+
+  if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "7")
+      if(CMAKE_SYSTEM_PROCESSOR STREQUAL "armv7")
+        # Quiet gcc 6 vs 7 abi warnings:
+        # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=77728
+        list(APPEND draco_base_cxx_flags "-Wno-psabi")
+        list(APPEND ABSL_GCC_FLAGS "-Wno-psabi")
+      endif()
+    endif()
+  endif()
+
+  # Source file names ending in these suffixes will have the appropriate
+  # compiler flags added to their compile commands to enable intrinsics.
+  set(draco_neon_source_file_suffix "neon.cc")
+  set(draco_sse4_source_file_suffix "sse4.cc")
+
+  if((${CMAKE_CXX_COMPILER_ID}
+      STREQUAL
+      "GNU"
+      AND ${CMAKE_CXX_COMPILER_VERSION} VERSION_LESS 5)
+     OR (${CMAKE_CXX_COMPILER_ID}
+         STREQUAL
+         "Clang"
+         AND ${CMAKE_CXX_COMPILER_VERSION} VERSION_LESS 4))
+    message(
+      WARNING "GNU/GCC < v5 or Clang/LLVM < v4, ENABLING COMPATIBILITY MODE.")
+    draco_enable_feature(FEATURE "DRACO_OLD_GCC")
+  endif()
+
+  if(EMSCRIPTEN)
+    draco_check_emscripten_environment()
+    draco_get_required_emscripten_flags(FLAG_LIST_VAR draco_base_cxx_flags)
+  endif()
+
+  draco_configure_sanitizer()
+endmacro()
diff --git a/Engine/lib/assimp/contrib/draco/cmake/draco_cpu_detection.cmake b/Engine/lib/assimp/contrib/draco/cmake/draco_cpu_detection.cmake
new file mode 100644
index 000000000..96e4a289b
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/draco_cpu_detection.cmake
@@ -0,0 +1,28 @@
+if(DRACO_CMAKE_DRACO_CPU_DETECTION_CMAKE_)
+  return()
+endif() # DRACO_CMAKE_DRACO_CPU_DETECTION_CMAKE_
+set(DRACO_CMAKE_DRACO_CPU_DETECTION_CMAKE_ 1)
+
+# Detect optimizations available for the current target CPU.
+macro(draco_optimization_detect)
+  if(DRACO_ENABLE_OPTIMIZATIONS)
+    string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" cpu_lowercase)
+    if(cpu_lowercase MATCHES "^arm|^aarch64")
+      set(draco_have_neon ON)
+    elseif(cpu_lowercase MATCHES "^x86|amd64")
+      set(draco_have_sse4 ON)
+    endif()
+  endif()
+
+  if(draco_have_neon AND DRACO_ENABLE_NEON)
+    list(APPEND draco_defines "DRACO_ENABLE_NEON=1")
+  else()
+    list(APPEND draco_defines "DRACO_ENABLE_NEON=0")
+  endif()
+
+  if(draco_have_sse4 AND DRACO_ENABLE_SSE4_1)
+    list(APPEND draco_defines "DRACO_ENABLE_SSE4_1=1")
+  else()
+    list(APPEND draco_defines "DRACO_ENABLE_SSE4_1=0")
+  endif()
+endmacro()
diff --git a/Engine/lib/assimp/contrib/draco/cmake/draco_emscripten.cmake b/Engine/lib/assimp/contrib/draco/cmake/draco_emscripten.cmake
new file mode 100644
index 000000000..10c935043
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/draco_emscripten.cmake
@@ -0,0 +1,185 @@
+if(DRACO_CMAKE_DRACO_EMSCRIPTEN_CMAKE_)
+  return()
+endif() # DRACO_CMAKE_DRACO_EMSCRIPTEN_CMAKE_
+
+# Checks environment for Emscripten prerequisites.
+macro(draco_check_emscripten_environment)
+  if(NOT PYTHONINTERP_FOUND)
+    message(
+      FATAL_ERROR
+        "Python required for Emscripten builds, but cmake cannot find it.")
+  endif()
+  if(NOT EXISTS "$ENV{EMSCRIPTEN}")
+    message(
+      FATAL_ERROR
+        "The EMSCRIPTEN environment variable must be set. See README.md.")
+  endif()
+endmacro()
+
+# Obtains the required Emscripten flags for Draco targets.
+macro(draco_get_required_emscripten_flags)
+  set(em_FLAG_LIST_VAR)
+  set(em_flags)
+  set(em_single_arg_opts FLAG_LIST_VAR)
+  set(em_multi_arg_opts)
+  cmake_parse_arguments(em "${em_flags}" "${em_single_arg_opts}"
+                        "${em_multi_arg_opts}" ${ARGN})
+  if(NOT em_FLAG_LIST_VAR)
+    message(FATAL "draco_get_required_emscripten_flags: FLAG_LIST_VAR required")
+  endif()
+
+  if(DRACO_JS_GLUE)
+    unset(required_flags)
+    list(APPEND ${em_FLAG_LIST_VAR} "-sALLOW_MEMORY_GROWTH=1")
+    list(APPEND ${em_FLAG_LIST_VAR} "-Wno-almost-asm")
+    list(APPEND ${em_FLAG_LIST_VAR} "--memory-init-file" "0")
+    list(APPEND ${em_FLAG_LIST_VAR} "-fno-omit-frame-pointer")
+    list(APPEND ${em_FLAG_LIST_VAR} "-sMODULARIZE=1")
+    list(APPEND ${em_FLAG_LIST_VAR} "-sNO_FILESYSTEM=1")
+    list(APPEND ${em_FLAG_LIST_VAR} "-sEXPORTED_RUNTIME_METHODS=[]")
+    list(APPEND ${em_FLAG_LIST_VAR} "-sPRECISE_F32=1")
+    list(APPEND ${em_FLAG_LIST_VAR} "-sNODEJS_CATCH_EXIT=0")
+    list(APPEND ${em_FLAG_LIST_VAR} "-sNODEJS_CATCH_REJECTION=0")
+
+    if(DRACO_FAST)
+      list(APPEND ${em_FLAG_LIST_VAR} "--llvm-lto" "1")
+    endif()
+    if(DRACO_WASM)
+      list(APPEND ${em_FLAG_LIST_VAR} "-sWASM=1")
+    else()
+      list(APPEND ${em_FLAG_LIST_VAR} "-sWASM=0")
+    endif()
+    if(DRACO_IE_COMPATIBLE)
+      list(APPEND ${em_FLAG_LIST_VAR} "-sLEGACY_VM_SUPPORT=1")
+    endif()
+  endif()
+endmacro()
+
+# Macro for generating C++ glue code from IDL for Emscripten targets. Executes
+# python to generate the C++ binding, and establishes dendency: $OUTPUT_PATH.cpp
+# on $INPUT_IDL.
+macro(draco_generate_emscripten_glue)
+  set(glue_flags)
+  set(glue_single_arg_opts INPUT_IDL OUTPUT_PATH)
+  set(glue_multi_arg_opts)
+  cmake_parse_arguments(glue "${glue_flags}" "${glue_single_arg_opts}"
+                        "${glue_multi_arg_opts}" ${ARGN})
+
+  if(DRACO_VERBOSE GREATER 1)
+    message("--------- draco_generate_emscripten_glue -----------\n"
+            "glue_INPUT_IDL=${glue_INPUT_IDL}\n"
+            "glue_OUTPUT_PATH=${glue_OUTPUT_PATH}\n" ]
+            "----------------------------------------------------\n")
+  endif()
+
+  if(NOT glue_INPUT_IDL OR NOT glue_OUTPUT_PATH)
+    message(
+      FATAL_ERROR
+        "draco_generate_emscripten_glue: INPUT_IDL and OUTPUT_PATH required.")
+  endif()
+
+  # Generate the glue source.
+  execute_process(COMMAND ${PYTHON_EXECUTABLE}
+                          $ENV{EMSCRIPTEN}/tools/webidl_binder.py
+                          ${glue_INPUT_IDL} ${glue_OUTPUT_PATH})
+  if(NOT EXISTS "${glue_OUTPUT_PATH}.cpp")
+    message(FATAL_ERROR "JS glue generation failed for ${glue_INPUT_IDL}.")
+  endif()
+
+  # Create a dependency so that it regenerated on edits.
+  add_custom_command(OUTPUT "${glue_OUTPUT_PATH}.cpp"
+                     COMMAND ${PYTHON_EXECUTABLE}
+                             $ENV{EMSCRIPTEN}/tools/webidl_binder.py
+                             ${glue_INPUT_IDL} ${glue_OUTPUT_PATH}
+                     DEPENDS ${draco_js_dec_idl}
+                     COMMENT "Generating ${glue_OUTPUT_PATH}.cpp."
+                     WORKING_DIRECTORY ${draco_build}
+                     VERBATIM)
+endmacro()
+
+# Wrapper for draco_add_executable() that handles the extra work necessary for
+# emscripten targets when generating JS glue:
+#
+# ~~~
+# - Set source level dependency on the C++ binding.
+# - Pre/Post link emscripten magic.
+#
+# Required args:
+#   - GLUE_PATH: Base path for glue file. Used to generate .cpp and .js files.
+#   - PRE_LINK_JS_SOURCES: em_link_pre_js() source files.
+#   - POST_LINK_JS_SOURCES: em_link_post_js() source files.
+# Optional args:
+#   - FEATURES:
+# ~~~
+macro(draco_add_emscripten_executable)
+  unset(emexe_NAME)
+  unset(emexe_FEATURES)
+  unset(emexe_SOURCES)
+  unset(emexe_DEFINES)
+  unset(emexe_INCLUDES)
+  unset(emexe_LINK_FLAGS)
+  set(optional_args)
+  set(single_value_args NAME GLUE_PATH)
+  set(multi_value_args SOURCES DEFINES FEATURES INCLUDES LINK_FLAGS
+                       PRE_LINK_JS_SOURCES POST_LINK_JS_SOURCES)
+
+  cmake_parse_arguments(emexe "${optional_args}" "${single_value_args}"
+                        "${multi_value_args}" ${ARGN})
+
+  if(NOT
+     (emexe_GLUE_PATH
+      AND emexe_POST_LINK_JS_SOURCES
+      AND emexe_PRE_LINK_JS_SOURCES))
+    message(FATAL
+            "draco_add_emscripten_executable: GLUE_PATH PRE_LINK_JS_SOURCES "
+            "POST_LINK_JS_SOURCES args required.")
+  endif()
+
+  if(DRACO_VERBOSE GREATER 1)
+    message("--------- draco_add_emscripten_executable ---------\n"
+            "emexe_NAME=${emexe_NAME}\n"
+            "emexe_SOURCES=${emexe_SOURCES}\n"
+            "emexe_DEFINES=${emexe_DEFINES}\n"
+            "emexe_INCLUDES=${emexe_INCLUDES}\n"
+            "emexe_LINK_FLAGS=${emexe_LINK_FLAGS}\n"
+            "emexe_GLUE_PATH=${emexe_GLUE_PATH}\n"
+            "emexe_FEATURES=${emexe_FEATURES}\n"
+            "emexe_PRE_LINK_JS_SOURCES=${emexe_PRE_LINK_JS_SOURCES}\n"
+            "emexe_POST_LINK_JS_SOURCES=${emexe_POST_LINK_JS_SOURCES}\n"
+            "----------------------------------------------------\n")
+  endif()
+
+  # The Emscripten linker needs the C++ flags in addition to whatever has been
+  # passed in with the target.
+  list(APPEND emexe_LINK_FLAGS ${DRACO_CXX_FLAGS})
+
+  if(DRACO_GLTF)
+    draco_add_executable(NAME
+                         ${emexe_NAME}
+                         OUTPUT_NAME
+                         ${emexe_NAME}_gltf
+                         SOURCES
+                         ${emexe_SOURCES}
+                         DEFINES
+                         ${emexe_DEFINES}
+                         INCLUDES
+                         ${emexe_INCLUDES}
+                         LINK_FLAGS
+                         ${emexe_LINK_FLAGS})
+  else()
+    draco_add_executable(NAME ${emexe_NAME} SOURCES ${emexe_SOURCES} DEFINES
+                         ${emexe_DEFINES} INCLUDES ${emexe_INCLUDES} LINK_FLAGS
+                         ${emexe_LINK_FLAGS})
+  endif()
+
+  foreach(feature ${emexe_FEATURES})
+    draco_enable_feature(FEATURE ${feature} TARGETS ${emexe_NAME})
+  endforeach()
+
+  set_property(SOURCE ${emexe_SOURCES}
+               APPEND
+               PROPERTY OBJECT_DEPENDS "${emexe_GLUE_PATH}.cpp")
+  em_link_pre_js(${emexe_NAME} ${emexe_PRE_LINK_JS_SOURCES})
+  em_link_post_js(${emexe_NAME} "${emexe_GLUE_PATH}.js"
+                  ${emexe_POST_LINK_JS_SOURCES})
+endmacro()
diff --git a/Engine/lib/assimp/contrib/draco/cmake/draco_flags.cmake b/Engine/lib/assimp/contrib/draco/cmake/draco_flags.cmake
new file mode 100644
index 000000000..0397859a4
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/draco_flags.cmake
@@ -0,0 +1,247 @@
+if(DRACO_CMAKE_DRACO_FLAGS_CMAKE_)
+  return()
+endif() # DRACO_CMAKE_DRACO_FLAGS_CMAKE_
+set(DRACO_CMAKE_DRACO_FLAGS_CMAKE_ 1)
+
+include(CheckCXXCompilerFlag)
+include(CheckCXXSourceCompiles)
+
+# Adds compiler flags specified by FLAGS to the sources specified by SOURCES:
+#
+# draco_set_compiler_flags_for_sources(SOURCES <sources> FLAGS <flags>)
+macro(draco_set_compiler_flags_for_sources)
+  unset(compiler_SOURCES)
+  unset(compiler_FLAGS)
+  unset(optional_args)
+  unset(single_value_args)
+  set(multi_value_args SOURCES FLAGS)
+  cmake_parse_arguments(compiler "${optional_args}" "${single_value_args}"
+                        "${multi_value_args}" ${ARGN})
+
+  if(NOT (compiler_SOURCES AND compiler_FLAGS))
+    draco_die("draco_set_compiler_flags_for_sources: SOURCES and "
+              "FLAGS required.")
+  endif()
+
+  set_source_files_properties(${compiler_SOURCES} PROPERTIES COMPILE_FLAGS
+                              ${compiler_FLAGS})
+
+  if(DRACO_VERBOSE GREATER 1)
+    foreach(source ${compiler_SOURCES})
+      foreach(flag ${compiler_FLAGS})
+        message("draco_set_compiler_flags_for_sources: source:${source} "
+                "flag:${flag}")
+      endforeach()
+    endforeach()
+  endif()
+endmacro()
+
+# Tests compiler flags stored in list(s) specified by FLAG_LIST_VAR_NAMES, adds
+# flags to $DRACO_CXX_FLAGS when tests pass. Terminates configuration if
+# FLAG_REQUIRED is specified and any flag check fails.
+#
+# ~~~
+# draco_test_cxx_flag(<FLAG_LIST_VAR_NAMES <flag list variable(s)>>
+#                       [FLAG_REQUIRED])
+# ~~~
+macro(draco_test_cxx_flag)
+  unset(cxx_test_FLAG_LIST_VAR_NAMES)
+  unset(cxx_test_FLAG_REQUIRED)
+  unset(single_value_args)
+  set(optional_args FLAG_REQUIRED)
+  set(multi_value_args FLAG_LIST_VAR_NAMES)
+  cmake_parse_arguments(cxx_test "${optional_args}" "${single_value_args}"
+                        "${multi_value_args}" ${ARGN})
+
+  if(NOT cxx_test_FLAG_LIST_VAR_NAMES)
+    draco_die("draco_test_cxx_flag: FLAG_LIST_VAR_NAMES required")
+  endif()
+
+  unset(cxx_flags)
+  foreach(list_var ${cxx_test_FLAG_LIST_VAR_NAMES})
+    if(DRACO_VERBOSE)
+      message("draco_test_cxx_flag: adding ${list_var} to cxx_flags")
+    endif()
+    list(APPEND cxx_flags ${${list_var}})
+  endforeach()
+
+  if(DRACO_VERBOSE)
+    message("CXX test: all flags: ${cxx_flags}")
+  endif()
+
+  unset(all_cxx_flags)
+  list(APPEND all_cxx_flags ${DRACO_CXX_FLAGS} ${cxx_flags})
+
+  # Turn off output from check_cxx_source_compiles. Print status directly
+  # instead since the logging messages from check_cxx_source_compiles can be
+  # quite confusing.
+  set(CMAKE_REQUIRED_QUIET TRUE)
+
+  # Run the actual compile test.
+  unset(draco_all_cxx_flags_pass CACHE)
+  message("--- Running combined CXX flags test, flags: ${all_cxx_flags}")
+
+  # check_cxx_compiler_flag() requires that the flags are a string. When flags
+  # are passed as a list it will remove the list separators, and attempt to run
+  # a compile command using list entries concatenated together as a single
+  # argument. Avoid the problem by forcing the argument to be a string.
+  draco_set_and_stringify(SOURCE_VARS all_cxx_flags DEST all_cxx_flags)
+  check_cxx_compiler_flag("${all_cxx_flags}" draco_all_cxx_flags_pass)
+
+  if(cxx_test_FLAG_REQUIRED AND NOT draco_all_cxx_flags_pass)
+    draco_die("Flag test failed for required flag(s): "
+              "${all_cxx_flags} and FLAG_REQUIRED specified.")
+  endif()
+
+  if(draco_all_cxx_flags_pass)
+    # Test passed: update the global flag list used by the draco target creation
+    # wrappers.
+    set(DRACO_CXX_FLAGS ${cxx_flags})
+    list(REMOVE_DUPLICATES DRACO_CXX_FLAGS)
+
+    if(DRACO_VERBOSE)
+      message("DRACO_CXX_FLAGS=${DRACO_CXX_FLAGS}")
+    endif()
+
+    message("--- Passed combined CXX flags test")
+  else()
+    message("--- Failed combined CXX flags test, testing flags individually.")
+
+    if(cxx_flags)
+      message("--- Testing flags from $cxx_flags: " "${cxx_flags}")
+      foreach(cxx_flag ${cxx_flags})
+        # Since 3.17.0 check_cxx_compiler_flag() sets a normal variable at
+        # parent scope while check_cxx_source_compiles() continues to set an
+        # internal cache variable, so we unset both to avoid the failure /
+        # success state persisting between checks. This has been fixed in newer
+        # CMake releases, but 3.17 is pretty common: we will need this to avoid
+        # weird build breakages while the fix propagates.
+        unset(cxx_flag_test_passed)
+        unset(cxx_flag_test_passed CACHE)
+        message("--- Testing flag: ${cxx_flag}")
+        check_cxx_compiler_flag("${cxx_flag}" cxx_flag_test_passed)
+
+        if(cxx_flag_test_passed)
+          message("--- Passed test for ${cxx_flag}")
+        else()
+          list(REMOVE_ITEM cxx_flags ${cxx_flag})
+          message("--- Failed test for ${cxx_flag}, flag removed.")
+        endif()
+      endforeach()
+
+      set(DRACO_CXX_FLAGS ${cxx_flags})
+    endif()
+  endif()
+
+  if(DRACO_CXX_FLAGS)
+    list(REMOVE_DUPLICATES DRACO_CXX_FLAGS)
+  endif()
+endmacro()
+
+# Tests executable linker flags stored in list specified by FLAG_LIST_VAR_NAME,
+# adds flags to $DRACO_EXE_LINKER_FLAGS when test passes. Terminates
+# configuration when flag check fails. draco_set_cxx_flags() must be called
+# before calling this macro because it assumes $DRACO_CXX_FLAGS contains only
+# valid CXX flags.
+#
+# draco_test_exe_linker_flag(<FLAG_LIST_VAR_NAME <flag list variable)>)
+macro(draco_test_exe_linker_flag)
+  unset(link_FLAG_LIST_VAR_NAME)
+  unset(optional_args)
+  unset(multi_value_args)
+  set(single_value_args FLAG_LIST_VAR_NAME)
+  cmake_parse_arguments(link "${optional_args}" "${single_value_args}"
+                        "${multi_value_args}" ${ARGN})
+
+  if(NOT link_FLAG_LIST_VAR_NAME)
+    draco_die("draco_test_link_flag: FLAG_LIST_VAR_NAME required")
+  endif()
+
+  draco_set_and_stringify(DEST linker_flags SOURCE_VARS
+                          ${link_FLAG_LIST_VAR_NAME})
+
+  if(DRACO_VERBOSE)
+    message("EXE LINKER test: all flags: ${linker_flags}")
+  endif()
+
+  # Tests of $DRACO_CXX_FLAGS have already passed. Include them with the linker
+  # test.
+  draco_set_and_stringify(DEST CMAKE_REQUIRED_FLAGS SOURCE_VARS DRACO_CXX_FLAGS)
+
+  # Cache the global exe linker flags.
+  if(CMAKE_EXE_LINKER_FLAGS)
+    set(cached_CMAKE_EXE_LINKER_FLAGS ${CMAKE_EXE_LINKER_FLAGS})
+    draco_set_and_stringify(DEST CMAKE_EXE_LINKER_FLAGS SOURCE ${linker_flags})
+  endif()
+
+  draco_set_and_stringify(DEST CMAKE_EXE_LINKER_FLAGS SOURCE ${linker_flags}
+                          ${CMAKE_EXE_LINKER_FLAGS})
+
+  # Turn off output from check_cxx_source_compiles. Print status directly
+  # instead since the logging messages from check_cxx_source_compiles can be
+  # quite confusing.
+  set(CMAKE_REQUIRED_QUIET TRUE)
+
+  message("--- Running EXE LINKER test for flags: ${linker_flags}")
+
+  unset(linker_flag_test_passed CACHE)
+  set(draco_cxx_main "\nint main() { return 0; }")
+  check_cxx_source_compiles("${draco_cxx_main}" linker_flag_test_passed)
+
+  if(NOT linker_flag_test_passed)
+    draco_die("EXE LINKER test failed.")
+  endif()
+
+  message("--- Passed EXE LINKER flag test.")
+
+  # Restore cached global exe linker flags.
+  if(cached_CMAKE_EXE_LINKER_FLAGS)
+    set(CMAKE_EXE_LINKER_FLAGS ${cached_CMAKE_EXE_LINKER_FLAGS})
+  else()
+    unset(CMAKE_EXE_LINKER_FLAGS)
+  endif()
+
+  list(APPEND DRACO_EXE_LINKER_FLAGS ${${link_FLAG_LIST_VAR_NAME}})
+  list(REMOVE_DUPLICATES DRACO_EXE_LINKER_FLAGS)
+endmacro()
+
+# Runs the draco compiler tests. This macro builds up the list of list var(s)
+# that is passed to draco_test_cxx_flag().
+#
+# Note: draco_set_build_definitions() must be called before this macro.
+macro(draco_set_cxx_flags)
+  unset(cxx_flag_lists)
+
+  if(CMAKE_CXX_COMPILER_ID MATCHES "Clang|GNU")
+    list(APPEND cxx_flag_lists draco_base_cxx_flags)
+  endif()
+
+  # Append clang flags after the base set to allow -Wno* overrides to take
+  # effect. Some of the base flags may enable a large set of warnings, e.g.,
+  # -Wall.
+  if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    list(APPEND cxx_flag_lists draco_clang_cxx_flags)
+  endif()
+
+  if(MSVC)
+    list(APPEND cxx_flag_lists draco_msvc_cxx_flags)
+  endif()
+
+  draco_set_and_stringify(DEST cxx_flags SOURCE_VARS ${cxx_flag_lists})
+  if(DRACO_VERBOSE)
+    message("draco_set_cxx_flags: internal CXX flags: ${cxx_flags}")
+  endif()
+
+  if(DRACO_CXX_FLAGS)
+    list(APPEND cxx_flag_lists DRACO_CXX_FLAGS)
+    if(DRACO_VERBOSE)
+      message("draco_set_cxx_flags: user CXX flags: ${DRACO_CXX_FLAGS}")
+    endif()
+  endif()
+
+  draco_set_and_stringify(DEST cxx_flags SOURCE_VARS ${cxx_flag_lists})
+
+  if(cxx_flags)
+    draco_test_cxx_flag(FLAG_LIST_VAR_NAMES ${cxx_flag_lists})
+  endif()
+endmacro()
diff --git a/Engine/lib/assimp/contrib/draco/cmake/draco_helpers.cmake b/Engine/lib/assimp/contrib/draco/cmake/draco_helpers.cmake
new file mode 100644
index 000000000..0b3b804cf
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/draco_helpers.cmake
@@ -0,0 +1,110 @@
+if(DRACO_CMAKE_DRACO_HELPERS_CMAKE_)
+  return()
+endif() # DRACO_CMAKE_DRACO_HELPERS_CMAKE_
+set(DRACO_CMAKE_DRACO_HELPERS_CMAKE_ 1)
+
+# Kills build generation using message(FATAL_ERROR) and outputs all data passed
+# to the console via use of $ARGN.
+macro(draco_die)
+  message(FATAL_ERROR ${ARGN})
+endmacro()
+
+# Converts semi-colon delimited list variable(s) to string. Output is written to
+# variable supplied via the DEST parameter. Input is from an expanded variable
+# referenced by SOURCE and/or variable(s) referenced by SOURCE_VARS.
+macro(draco_set_and_stringify)
+  set(optional_args)
+  set(single_value_args DEST SOURCE_VAR)
+  set(multi_value_args SOURCE SOURCE_VARS)
+  cmake_parse_arguments(sas "${optional_args}" "${single_value_args}"
+                        "${multi_value_args}" ${ARGN})
+
+  if(NOT sas_DEST OR NOT (sas_SOURCE OR sas_SOURCE_VARS))
+    draco_die("draco_set_and_stringify: DEST and at least one of SOURCE "
+              "SOURCE_VARS required.")
+  endif()
+
+  unset(${sas_DEST})
+
+  if(sas_SOURCE)
+    # $sas_SOURCE is one or more expanded variables, just copy the values to
+    # $sas_DEST.
+    set(${sas_DEST} "${sas_SOURCE}")
+  endif()
+
+  if(sas_SOURCE_VARS)
+    # $sas_SOURCE_VARS is one or more variable names. Each iteration expands a
+    # variable and appends it to $sas_DEST.
+    foreach(source_var ${sas_SOURCE_VARS})
+      set(${sas_DEST} "${${sas_DEST}} ${${source_var}}")
+    endforeach()
+
+    # Because $sas_DEST can be empty when entering this scope leading whitespace
+    # can be introduced to $sas_DEST on the first iteration of the above loop.
+    # Remove it:
+    string(STRIP "${${sas_DEST}}" ${sas_DEST})
+  endif()
+
+  # Lists in CMake are simply semicolon delimited strings, so stringification is
+  # just a find and replace of the semicolon.
+  string(REPLACE ";" " " ${sas_DEST} "${${sas_DEST}}")
+
+  if(DRACO_VERBOSE GREATER 1)
+    message("draco_set_and_stringify: ${sas_DEST}=${${sas_DEST}}")
+  endif()
+endmacro()
+
+# Creates a dummy source file in $DRACO_GENERATED_SOURCES_DIRECTORY and adds it
+# to the specified target. Optionally adds its path to a list variable.
+#
+# draco_create_dummy_source_file(<TARGET <target> BASENAME <basename of file>>
+# [LISTVAR <list variable>])
+macro(draco_create_dummy_source_file)
+  set(optional_args)
+  set(single_value_args TARGET BASENAME LISTVAR)
+  set(multi_value_args)
+  cmake_parse_arguments(cdsf "${optional_args}" "${single_value_args}"
+                        "${multi_value_args}" ${ARGN})
+
+  if(NOT cdsf_TARGET OR NOT cdsf_BASENAME)
+    draco_die("draco_create_dummy_source_file: TARGET and BASENAME required.")
+  endif()
+
+  if(NOT DRACO_GENERATED_SOURCES_DIRECTORY)
+    set(DRACO_GENERATED_SOURCES_DIRECTORY "${draco_build}/gen_src")
+  endif()
+
+  set(dummy_source_dir "${DRACO_GENERATED_SOURCES_DIRECTORY}")
+  set(dummy_source_file
+      "${dummy_source_dir}/draco_${cdsf_TARGET}_${cdsf_BASENAME}.cc")
+  set(dummy_source_code
+      "// Generated file. DO NOT EDIT!\n"
+      "// C++ source file created for target ${cdsf_TARGET}.\n"
+      "void draco_${cdsf_TARGET}_${cdsf_BASENAME}_dummy_function(void)\;\n"
+      "void draco_${cdsf_TARGET}_${cdsf_BASENAME}_dummy_function(void) {}\n")
+  file(WRITE "${dummy_source_file}" ${dummy_source_code})
+
+  target_sources(${cdsf_TARGET} PRIVATE ${dummy_source_file})
+
+  if(cdsf_LISTVAR)
+    list(APPEND ${cdsf_LISTVAR} "${dummy_source_file}")
+  endif()
+endmacro()
+
+# Loads the version string from $draco_source/draco/version.h and sets
+# $DRACO_VERSION.
+macro(draco_load_version_info)
+  file(STRINGS "${draco_src_root}/core/draco_version.h" version_file_strings)
+  foreach(str ${version_file_strings})
+    if(str MATCHES "char kDracoVersion")
+      string(FIND "${str}" "\"" open_quote_pos)
+      string(FIND "${str}" ";" semicolon_pos)
+      math(EXPR open_quote_pos "${open_quote_pos} + 1")
+      math(EXPR close_quote_pos "${semicolon_pos} - 1")
+      math(EXPR version_string_length "${close_quote_pos} - ${open_quote_pos}")
+      string(SUBSTRING "${str}" ${open_quote_pos} ${version_string_length}
+                       DRACO_VERSION)
+      break()
+    endif()
+  endforeach()
+endmacro()
diff --git a/Engine/lib/assimp/contrib/draco/cmake/draco_install.cmake b/Engine/lib/assimp/contrib/draco/cmake/draco_install.cmake
new file mode 100644
index 000000000..09bfb591d
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/draco_install.cmake
@@ -0,0 +1,79 @@
+if(DRACO_CMAKE_DRACO_INSTALL_CMAKE_)
+  return()
+endif() # DRACO_CMAKE_DRACO_INSTALL_CMAKE_
+set(DRACO_CMAKE_DRACO_INSTALL_CMAKE_ 1)
+
+# Sets up the draco install targets. Must be called after the static library
+# target is created.
+macro(draco_setup_install_target)
+  include(GNUInstallDirs)
+
+  # pkg-config: draco.pc
+  set(prefix "${CMAKE_INSTALL_PREFIX}")
+  set(exec_prefix "\${prefix}")
+  set(libdir "\${prefix}/${CMAKE_INSTALL_LIBDIR}")
+  set(includedir "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
+  set(draco_lib_name "draco")
+
+  configure_file("${draco_root}/cmake/draco.pc.template"
+                 "${draco_build}/draco.pc" @ONLY NEWLINE_STYLE UNIX)
+  install(FILES "${draco_build}/draco.pc"
+          DESTINATION "${prefix}/${CMAKE_INSTALL_LIBDIR}/pkgconfig")
+
+  # CMake config: draco-config.cmake
+  set(DRACO_INCLUDE_DIRS "${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
+  configure_file("${draco_root}/cmake/draco-config.cmake.template"
+                 "${draco_build}/draco-config.cmake" @ONLY NEWLINE_STYLE UNIX)
+  install(
+    FILES "${draco_build}/draco-config.cmake"
+    DESTINATION "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_DATAROOTDIR}/cmake")
+
+  foreach(file ${draco_sources})
+    if(file MATCHES "h$")
+      list(APPEND draco_api_includes ${file})
+    endif()
+  endforeach()
+
+  # Strip $draco_src_root from the file paths: we need to install relative to
+  # $include_directory.
+  list(TRANSFORM draco_api_includes REPLACE "${draco_src_root}/" "")
+  set(include_directory "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}")
+
+  foreach(draco_api_include ${draco_api_includes})
+    get_filename_component(file_directory ${draco_api_include} DIRECTORY)
+    set(target_directory "${include_directory}/draco/${file_directory}")
+    install(FILES ${draco_src_root}/${draco_api_include}
+            DESTINATION "${target_directory}")
+  endforeach()
+
+  install(
+    FILES "${draco_build}/draco/draco_features.h"
+    DESTINATION "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}/draco/")
+
+  install(TARGETS draco_decoder DESTINATION
+                  "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_BINDIR}")
+  install(TARGETS draco_encoder DESTINATION
+                  "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_BINDIR}")
+
+  if(MSVC)
+    install(TARGETS draco DESTINATION
+                    "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
+  else()
+    install(TARGETS draco_static DESTINATION
+                    "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
+    if(BUILD_SHARED_LIBS)
+      install(TARGETS draco_shared DESTINATION
+                      "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
+    endif()
+  endif()
+
+  if(DRACO_UNITY_PLUGIN)
+    install(TARGETS dracodec_unity DESTINATION
+                    "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
+  endif()
+  if(DRACO_MAYA_PLUGIN)
+    install(TARGETS draco_maya_wrapper DESTINATION
+                    "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
+  endif()
+
+endmacro()
diff --git a/Engine/lib/assimp/contrib/draco/cmake/draco_intrinsics.cmake b/Engine/lib/assimp/contrib/draco/cmake/draco_intrinsics.cmake
new file mode 100644
index 000000000..9011c0de5
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/draco_intrinsics.cmake
@@ -0,0 +1,96 @@
+if(DRACO_CMAKE_DRACO_INTRINSICS_CMAKE_)
+  return()
+endif() # DRACO_CMAKE_DRACO_INTRINSICS_CMAKE_
+set(DRACO_CMAKE_DRACO_INTRINSICS_CMAKE_ 1)
+
+# Returns the compiler flag for the SIMD intrinsics suffix specified by the
+# SUFFIX argument via the variable specified by the VARIABLE argument:
+# draco_get_intrinsics_flag_for_suffix(SUFFIX <suffix> VARIABLE <var name>)
+macro(draco_get_intrinsics_flag_for_suffix)
+  unset(intrinsics_SUFFIX)
+  unset(intrinsics_VARIABLE)
+  unset(optional_args)
+  unset(multi_value_args)
+  set(single_value_args SUFFIX VARIABLE)
+  cmake_parse_arguments(intrinsics "${optional_args}" "${single_value_args}"
+                        "${multi_value_args}" ${ARGN})
+
+  if(NOT (intrinsics_SUFFIX AND intrinsics_VARIABLE))
+    message(FATAL_ERROR "draco_get_intrinsics_flag_for_suffix: SUFFIX and "
+                        "VARIABLE required.")
+  endif()
+
+  if(intrinsics_SUFFIX MATCHES "neon")
+    if(NOT MSVC)
+      set(${intrinsics_VARIABLE} "${DRACO_NEON_INTRINSICS_FLAG}")
+    endif()
+  elseif(intrinsics_SUFFIX MATCHES "sse4")
+    if(NOT MSVC)
+      set(${intrinsics_VARIABLE} "-msse4.1")
+    endif()
+  else()
+    message(FATAL_ERROR "draco_get_intrinsics_flag_for_suffix: Unknown "
+                        "instrinics suffix: ${intrinsics_SUFFIX}")
+  endif()
+
+  if(DRACO_VERBOSE GREATER 1)
+    message("draco_get_intrinsics_flag_for_suffix: "
+            "suffix:${intrinsics_SUFFIX} flag:${${intrinsics_VARIABLE}}")
+  endif()
+endmacro()
+
+# Processes source files specified by SOURCES and adds intrinsics flags as
+# necessary: draco_process_intrinsics_sources(SOURCES <sources>)
+#
+# Detects requirement for intrinsics flags using source file name suffix.
+# Currently supports only SSE4.1.
+macro(draco_process_intrinsics_sources)
+  unset(arg_TARGET)
+  unset(arg_SOURCES)
+  unset(optional_args)
+  set(single_value_args TARGET)
+  set(multi_value_args SOURCES)
+  cmake_parse_arguments(arg "${optional_args}" "${single_value_args}"
+                        "${multi_value_args}" ${ARGN})
+  if(NOT (arg_TARGET AND arg_SOURCES))
+    message(FATAL_ERROR "draco_process_intrinsics_sources: TARGET and "
+                        "SOURCES required.")
+  endif()
+
+  if(DRACO_ENABLE_SSE4_1 AND draco_have_sse4)
+    unset(sse4_sources)
+    list(APPEND sse4_sources ${arg_SOURCES})
+
+    list(FILTER sse4_sources INCLUDE REGEX
+         "${draco_sse4_source_file_suffix}$")
+
+    if(sse4_sources)
+      unset(sse4_flags)
+      draco_get_intrinsics_flag_for_suffix(SUFFIX
+                                             ${draco_sse4_source_file_suffix}
+                                             VARIABLE sse4_flags)
+      if(sse4_flags)
+        draco_set_compiler_flags_for_sources(SOURCES ${sse4_sources} FLAGS
+                                               ${sse4_flags})
+      endif()
+    endif()
+  endif()
+
+  if(DRACO_ENABLE_NEON AND draco_have_neon)
+    unset(neon_sources)
+    list(APPEND neon_sources ${arg_SOURCES})
+    list(FILTER neon_sources INCLUDE REGEX
+         "${draco_neon_source_file_suffix}$")
+
+    if(neon_sources AND DRACO_NEON_INTRINSICS_FLAG)
+      unset(neon_flags)
+      draco_get_intrinsics_flag_for_suffix(SUFFIX
+                                             ${draco_neon_source_file_suffix}
+                                             VARIABLE neon_flags)
+      if(neon_flags)
+        draco_set_compiler_flags_for_sources(SOURCES ${neon_sources} FLAGS
+                                               ${neon_flags})
+      endif()
+    endif()
+  endif()
+endmacro()
diff --git a/Engine/lib/assimp/contrib/draco/cmake/draco_options.cmake b/Engine/lib/assimp/contrib/draco/cmake/draco_options.cmake
new file mode 100644
index 000000000..832bfb69f
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/draco_options.cmake
@@ -0,0 +1,239 @@
+if(DRACO_CMAKE_DRACO_OPTIONS_CMAKE_)
+  return()
+endif() # DRACO_CMAKE_DRACO_OPTIONS_CMAKE_
+set(DRACO_CMAKE_DRACO_OPTIONS_CMAKE_)
+
+set(draco_features_file_name "${draco_build}/draco/draco_features.h")
+set(draco_features_list)
+
+# Simple wrapper for CMake's builtin option command that tracks draco's build
+# options in the list variable $draco_options.
+macro(draco_option)
+  unset(option_NAME)
+  unset(option_HELPSTRING)
+  unset(option_VALUE)
+  unset(optional_args)
+  unset(multi_value_args)
+  set(single_value_args NAME HELPSTRING VALUE)
+  cmake_parse_arguments(option "${optional_args}" "${single_value_args}"
+                        "${multi_value_args}" ${ARGN})
+
+  if(NOT (option_NAME AND option_HELPSTRING AND DEFINED option_VALUE))
+    message(FATAL_ERROR "draco_option: NAME HELPSTRING and VALUE required.")
+  endif()
+
+  option(${option_NAME} ${option_HELPSTRING} ${option_VALUE})
+
+  if(DRACO_VERBOSE GREATER 2)
+    message("--------- draco_option ---------\n" "option_NAME=${option_NAME}\n"
+            "option_HELPSTRING=${option_HELPSTRING}\n"
+            "option_VALUE=${option_VALUE}\n"
+            "------------------------------------------\n")
+  endif()
+
+  list(APPEND draco_options ${option_NAME})
+  list(REMOVE_DUPLICATES draco_options)
+endmacro()
+
+# Dumps the $draco_options list via CMake message command.
+macro(draco_dump_options)
+  foreach(option_name ${draco_options})
+    message("${option_name}: ${${option_name}}")
+  endforeach()
+endmacro()
+
+# Set default options.
+macro(draco_set_default_options)
+  draco_option(NAME DRACO_FAST HELPSTRING "Try to build faster libs." VALUE OFF)
+  draco_option(NAME DRACO_JS_GLUE HELPSTRING
+               "Enable JS Glue and JS targets when using Emscripten." VALUE ON)
+  draco_option(NAME DRACO_IE_COMPATIBLE HELPSTRING
+               "Enable support for older IE builds when using Emscripten." VALUE
+               OFF)
+  draco_option(NAME DRACO_MESH_COMPRESSION HELPSTRING "Enable mesh compression."
+               VALUE ON)
+  draco_option(NAME DRACO_POINT_CLOUD_COMPRESSION HELPSTRING
+               "Enable point cloud compression." VALUE ON)
+  draco_option(NAME DRACO_PREDICTIVE_EDGEBREAKER HELPSTRING
+               "Enable predictive edgebreaker." VALUE ON)
+  draco_option(NAME DRACO_STANDARD_EDGEBREAKER HELPSTRING
+               "Enable stand edgebreaker." VALUE ON)
+  draco_option(NAME DRACO_BACKWARDS_COMPATIBILITY HELPSTRING
+               "Enable backwards compatibility." VALUE ON)
+  draco_option(NAME DRACO_DECODER_ATTRIBUTE_DEDUPLICATION HELPSTRING
+               "Enable attribute deduping." VALUE OFF)
+  draco_option(NAME DRACO_TESTS HELPSTRING "Enables tests." VALUE OFF)
+  draco_option(NAME DRACO_WASM HELPSTRING "Enables WASM support." VALUE OFF)
+  draco_option(NAME DRACO_UNITY_PLUGIN HELPSTRING
+               "Build plugin library for Unity." VALUE OFF)
+  draco_option(NAME DRACO_ANIMATION_ENCODING HELPSTRING "Enable animation."
+               VALUE OFF)
+  draco_option(NAME DRACO_GLTF HELPSTRING "Support GLTF." VALUE OFF)
+  draco_option(NAME DRACO_MAYA_PLUGIN HELPSTRING
+               "Build plugin library for Maya." VALUE OFF)
+  draco_check_deprecated_options()
+endmacro()
+
+# Warns when a deprecated option is used and sets the option that replaced it.
+macro(draco_handle_deprecated_option)
+  unset(option_OLDNAME)
+  unset(option_NEWNAME)
+  unset(optional_args)
+  unset(multi_value_args)
+  set(single_value_args OLDNAME NEWNAME)
+  cmake_parse_arguments(option "${optional_args}" "${single_value_args}"
+                        "${multi_value_args}" ${ARGN})
+
+  if("${${option_OLDNAME}}")
+    message(WARNING "${option_OLDNAME} is deprecated. Use ${option_NEWNAME}.")
+    set(${option_NEWNAME} ${${option_OLDNAME}})
+  endif()
+endmacro()
+
+# Checks for use of deprecated options.
+macro(draco_check_deprecated_options)
+  draco_handle_deprecated_option(OLDNAME ENABLE_EXTRA_SPEED NEWNAME DRACO_FAST)
+  draco_handle_deprecated_option(OLDNAME ENABLE_JS_GLUE NEWNAME DRACO_JS_GLUE)
+  draco_handle_deprecated_option(OLDNAME ENABLE_MESH_COMPRESSION NEWNAME
+                                 DRACO_MESH_COMPRESSION)
+  draco_handle_deprecated_option(OLDNAME ENABLE_POINT_CLOUD_COMPRESSION NEWNAME
+                                 DRACO_POINT_CLOUD_COMPRESSION)
+  draco_handle_deprecated_option(OLDNAME ENABLE_PREDICTIVE_EDGEBREAKER NEWNAME
+                                 DRACO_PREDICTIVE_EDGEBREAKER)
+  draco_handle_deprecated_option(OLDNAME ENABLE_STANDARD_EDGEBREAKER NEWNAME
+                                 DRACO_STANDARD_EDGEBREAKER)
+  draco_handle_deprecated_option(OLDNAME ENABLE_BACKWARDS_COMPATIBILITY NEWNAME
+                                 DRACO_BACKWARDS_COMPATIBILITY)
+  draco_handle_deprecated_option(OLDNAME ENABLE_DECODER_ATTRIBUTE_DEDUPLICATION
+                                 NEWNAME DRACO_DECODER_ATTRIBUTE_DEDUPLICATION)
+  draco_handle_deprecated_option(OLDNAME ENABLE_TESTS NEWNAME DRACO_TESTS)
+  draco_handle_deprecated_option(OLDNAME ENABLE_WASM NEWNAME DRACO_WASM)
+  draco_handle_deprecated_option(OLDNAME BUILD_UNITY_PLUGIN NEWNAME
+                                 DRACO_UNITY_PLUGIN)
+  draco_handle_deprecated_option(OLDNAME BUILD_ANIMATION_ENCODING NEWNAME
+                                 DRACO_ANIMATION_ENCODING)
+  draco_handle_deprecated_option(OLDNAME BUILD_FOR_GLTF NEWNAME DRACO_GLTF)
+  draco_handle_deprecated_option(OLDNAME BUILD_MAYA_PLUGIN NEWNAME
+                                 DRACO_MAYA_PLUGIN)
+  draco_handle_deprecated_option(OLDNAME BUILD_USD_PLUGIN NEWNAME
+                                 BUILD_SHARED_LIBS)
+
+endmacro()
+
+# Macro for setting Draco features based on user configuration. Features enabled
+# by this macro are Draco global.
+macro(draco_set_optional_features)
+  if(DRACO_GLTF)
+    # Override settings when building for GLTF.
+    draco_enable_feature(FEATURE "DRACO_MESH_COMPRESSION_SUPPORTED")
+    draco_enable_feature(FEATURE "DRACO_NORMAL_ENCODING_SUPPORTED")
+    draco_enable_feature(FEATURE "DRACO_STANDARD_EDGEBREAKER_SUPPORTED")
+  else()
+    if(DRACO_POINT_CLOUD_COMPRESSION)
+      draco_enable_feature(FEATURE "DRACO_POINT_CLOUD_COMPRESSION_SUPPORTED")
+    endif()
+    if(DRACO_MESH_COMPRESSION)
+      draco_enable_feature(FEATURE "DRACO_MESH_COMPRESSION_SUPPORTED")
+      draco_enable_feature(FEATURE "DRACO_NORMAL_ENCODING_SUPPORTED")
+
+      if(DRACO_STANDARD_EDGEBREAKER)
+        draco_enable_feature(FEATURE "DRACO_STANDARD_EDGEBREAKER_SUPPORTED")
+      endif()
+      if(DRACO_PREDICTIVE_EDGEBREAKER)
+        draco_enable_feature(FEATURE "DRACO_PREDICTIVE_EDGEBREAKER_SUPPORTED")
+      endif()
+    endif()
+
+    if(DRACO_BACKWARDS_COMPATIBILITY)
+      draco_enable_feature(FEATURE "DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED")
+    endif()
+
+
+    if(NOT EMSCRIPTEN)
+      # For now, enable deduplication for both encoder and decoder.
+      # TODO(ostava): Support for disabling attribute deduplication for the C++
+      # decoder is planned in future releases.
+      draco_enable_feature(FEATURE
+                           DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED)
+      draco_enable_feature(FEATURE
+                           DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED)
+    endif()
+  endif()
+
+  if(DRACO_UNITY_PLUGIN)
+    draco_enable_feature(FEATURE "DRACO_UNITY_PLUGIN")
+    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+  endif()
+
+  if(DRACO_MAYA_PLUGIN)
+    draco_enable_feature(FEATURE "DRACO_MAYA_PLUGIN")
+    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+  endif()
+
+endmacro()
+
+# Macro that handles tracking of Draco preprocessor symbols for the purpose of
+# producing draco_features.h.
+#
+# ~~~
+# draco_enable_feature(FEATURE <feature_name> [TARGETS <target_name>])
+# ~~~
+#
+# FEATURE  is required. It should be a Draco preprocessor symbol. TARGETS is
+# optional. It can be one or more draco targets.
+#
+# When the TARGETS argument is not present the preproc symbol is added to
+# draco_features.h. When it is draco_features.h is unchanged, and
+# target_compile_options() is called for each target specified.
+macro(draco_enable_feature)
+  set(def_flags)
+  set(def_single_arg_opts FEATURE)
+  set(def_multi_arg_opts TARGETS)
+  cmake_parse_arguments(DEF "${def_flags}" "${def_single_arg_opts}"
+                        "${def_multi_arg_opts}" ${ARGN})
+  if("${DEF_FEATURE}" STREQUAL "")
+    message(FATAL_ERROR "Empty FEATURE passed to draco_enable_feature().")
+  endif()
+
+  # Do nothing/return early if $DEF_FEATURE is already in the list.
+  list(FIND draco_features_list ${DEF_FEATURE} df_index)
+  if(NOT df_index EQUAL -1)
+    return()
+  endif()
+
+  list(LENGTH DEF_TARGETS df_targets_list_length)
+  if(${df_targets_list_length} EQUAL 0)
+    list(APPEND draco_features_list ${DEF_FEATURE})
+  else()
+    foreach(target ${DEF_TARGETS})
+      target_compile_definitions(${target} PRIVATE ${DEF_FEATURE})
+    endforeach()
+  endif()
+endmacro()
+
+# Function for generating draco_features.h.
+function(draco_generate_features_h)
+  file(WRITE "${draco_features_file_name}.new"
+       "// GENERATED FILE -- DO NOT EDIT\n\n" "#ifndef DRACO_FEATURES_H_\n"
+       "#define DRACO_FEATURES_H_\n\n")
+
+  foreach(feature ${draco_features_list})
+    file(APPEND "${draco_features_file_name}.new" "#define ${feature}\n")
+  endforeach()
+
+  file(APPEND "${draco_features_file_name}.new"
+       "\n#endif  // DRACO_FEATURES_H_")
+
+  # Will replace ${draco_features_file_name} only if the file content has
+  # changed. This prevents forced Draco rebuilds after CMake runs.
+  configure_file("${draco_features_file_name}.new"
+                 "${draco_features_file_name}")
+  file(REMOVE "${draco_features_file_name}.new")
+endfunction()
+
+# Sets default options for the build and processes user controlled options to
+# compute enabled features.
+macro(draco_setup_options)
+  draco_set_default_options()
+  draco_set_optional_features()
+endmacro()
diff --git a/Engine/lib/assimp/contrib/draco/cmake/draco_sanitizer.cmake b/Engine/lib/assimp/contrib/draco/cmake/draco_sanitizer.cmake
new file mode 100644
index 000000000..d2e41a6cb
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/draco_sanitizer.cmake
@@ -0,0 +1,32 @@
+if(DRACO_CMAKE_DRACO_SANITIZER_CMAKE_)
+  return()
+endif() # DRACO_CMAKE_DRACO_SANITIZER_CMAKE_
+set(DRACO_CMAKE_DRACO_SANITIZER_CMAKE_ 1)
+
+# Handles the details of enabling sanitizers.
+macro(draco_configure_sanitizer)
+  if(DRACO_SANITIZE AND NOT EMSCRIPTEN AND NOT MSVC)
+    if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+      if(DRACO_SANITIZE MATCHES "cfi")
+        list(APPEND SAN_CXX_FLAGS "-flto" "-fno-sanitize-trap=cfi")
+        list(APPEND SAN_LINKER_FLAGS "-flto" "-fno-sanitize-trap=cfi"
+                    "-fuse-ld=gold")
+      endif()
+
+      if(${CMAKE_SIZEOF_VOID_P} EQUAL 4
+         AND DRACO_SANITIZE MATCHES "integer|undefined")
+        list(APPEND SAN_LINKER_FLAGS "--rtlib=compiler-rt" "-lgcc_s")
+      endif()
+    endif()
+
+    list(APPEND SAN_CXX_FLAGS "-fsanitize=${DRACO_SANITIZE}")
+    list(APPEND SAN_LINKER_FLAGS "-fsanitize=${DRACO_SANITIZE}")
+
+    # Make sanitizer callstacks accurate.
+    list(APPEND SAN_CXX_FLAGS "-fno-omit-frame-pointer")
+    list(APPEND SAN_CXX_FLAGS "-fno-optimize-sibling-calls")
+
+    draco_test_cxx_flag(FLAG_LIST_VAR_NAMES SAN_CXX_FLAGS FLAG_REQUIRED)
+    draco_test_exe_linker_flag(FLAG_LIST_VAR_NAME SAN_LINKER_FLAGS)
+  endif()
+endmacro()
diff --git a/Engine/lib/assimp/contrib/draco/cmake/draco_targets.cmake b/Engine/lib/assimp/contrib/draco/cmake/draco_targets.cmake
new file mode 100644
index 000000000..0456c4d7b
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/draco_targets.cmake
@@ -0,0 +1,355 @@
+if(DRACO_CMAKE_DRACO_TARGETS_CMAKE_)
+  return()
+endif() # DRACO_CMAKE_DRACO_TARGETS_CMAKE_
+set(DRACO_CMAKE_DRACO_TARGETS_CMAKE_ 1)
+
+# Resets list variables used to track draco targets.
+macro(draco_reset_target_lists)
+  unset(draco_targets)
+  unset(draco_exe_targets)
+  unset(draco_lib_targets)
+  unset(draco_objlib_targets)
+  unset(draco_module_targets)
+  unset(draco_sources)
+  unset(draco_test_targets)
+endmacro()
+
+# Creates an executable target. The target name is passed as a parameter to the
+# NAME argument, and the sources passed as a parameter to the SOURCES argument:
+# draco_add_executable(NAME <name> SOURCES <sources> [optional args])
+#
+# Optional args:
+# cmake-format: off
+#   - OUTPUT_NAME: Override output file basename. Target basename defaults to
+#     NAME.
+#   - TEST: Flag. Presence means treat executable as a test.
+#   - DEFINES: List of preprocessor macro definitions.
+#   - INCLUDES: list of include directories for the target.
+#   - COMPILE_FLAGS: list of compiler flags for the target.
+#   - LINK_FLAGS: List of linker flags for the target.
+#   - OBJLIB_DEPS: List of CMake object library target dependencies.
+#   - LIB_DEPS: List of CMake library dependencies.
+# cmake-format: on
+#
+# Sources passed to this macro are added to $draco_test_sources when TEST is
+# specified. Otherwise sources are added to $draco_sources.
+#
+# Targets passed to this macro are always added to the $draco_targets list. When
+# TEST is specified targets are also added to the $draco_test_targets list.
+# Otherwise targets are added to $draco_exe_targets.
+macro(draco_add_executable)
+  unset(exe_TEST)
+  unset(exe_TEST_DEFINES_MAIN)
+  unset(exe_NAME)
+  unset(exe_OUTPUT_NAME)
+  unset(exe_SOURCES)
+  unset(exe_DEFINES)
+  unset(exe_INCLUDES)
+  unset(exe_COMPILE_FLAGS)
+  unset(exe_LINK_FLAGS)
+  unset(exe_OBJLIB_DEPS)
+  unset(exe_LIB_DEPS)
+  set(optional_args TEST)
+  set(single_value_args NAME OUTPUT_NAME)
+  set(multi_value_args SOURCES DEFINES INCLUDES COMPILE_FLAGS LINK_FLAGS
+                       OBJLIB_DEPS LIB_DEPS)
+
+  cmake_parse_arguments(exe "${optional_args}" "${single_value_args}"
+                        "${multi_value_args}" ${ARGN})
+
+  if(DRACO_VERBOSE GREATER 1)
+    message("--------- draco_add_executable ---------\n"
+            "exe_TEST=${exe_TEST}\n"
+            "exe_TEST_DEFINES_MAIN=${exe_TEST_DEFINES_MAIN}\n"
+            "exe_NAME=${exe_NAME}\n"
+            "exe_OUTPUT_NAME=${exe_OUTPUT_NAME}\n"
+            "exe_SOURCES=${exe_SOURCES}\n"
+            "exe_DEFINES=${exe_DEFINES}\n"
+            "exe_INCLUDES=${exe_INCLUDES}\n"
+            "exe_COMPILE_FLAGS=${exe_COMPILE_FLAGS}\n"
+            "exe_LINK_FLAGS=${exe_LINK_FLAGS}\n"
+            "exe_OBJLIB_DEPS=${exe_OBJLIB_DEPS}\n"
+            "exe_LIB_DEPS=${exe_LIB_DEPS}\n"
+            "------------------------------------------\n")
+  endif()
+
+  if(NOT (exe_NAME AND exe_SOURCES))
+    message(FATAL_ERROR "draco_add_executable: NAME and SOURCES required.")
+  endif()
+
+  list(APPEND draco_targets ${exe_NAME})
+  if(exe_TEST)
+    list(APPEND draco_test_targets ${exe_NAME})
+    list(APPEND draco_test_sources ${exe_SOURCES})
+  else()
+    list(APPEND draco_exe_targets ${exe_NAME})
+    list(APPEND draco_sources ${exe_SOURCES})
+  endif()
+
+  add_executable(${exe_NAME} ${exe_SOURCES})
+  set_target_properties(${exe_NAME} PROPERTIES VERSION ${DRACO_VERSION})
+
+  if(exe_OUTPUT_NAME)
+    set_target_properties(${exe_NAME} PROPERTIES OUTPUT_NAME ${exe_OUTPUT_NAME})
+  endif()
+
+  draco_process_intrinsics_sources(TARGET ${exe_NAME} SOURCES ${exe_SOURCES})
+
+  if(exe_DEFINES)
+    target_compile_definitions(${exe_NAME} PRIVATE ${exe_DEFINES})
+  endif()
+
+  if(exe_INCLUDES)
+    target_include_directories(${exe_NAME} PRIVATE ${exe_INCLUDES})
+  endif()
+
+  if(exe_COMPILE_FLAGS OR DRACO_CXX_FLAGS)
+    target_compile_options(${exe_NAME}
+                           PRIVATE ${exe_COMPILE_FLAGS} ${DRACO_CXX_FLAGS})
+  endif()
+
+  if(exe_LINK_FLAGS OR DRACO_EXE_LINKER_FLAGS)
+    if(${CMAKE_VERSION} VERSION_LESS "3.13")
+      list(APPEND exe_LINK_FLAGS "${DRACO_EXE_LINKER_FLAGS}")
+      # LINK_FLAGS is managed as a string.
+      draco_set_and_stringify(SOURCE "${exe_LINK_FLAGS}" DEST exe_LINK_FLAGS)
+      set_target_properties(${exe_NAME}
+                            PROPERTIES LINK_FLAGS "${exe_LINK_FLAGS}")
+    else()
+      target_link_options(${exe_NAME} PRIVATE ${exe_LINK_FLAGS}
+                          ${DRACO_EXE_LINKER_FLAGS})
+    endif()
+  endif()
+
+  if(exe_OBJLIB_DEPS)
+    foreach(objlib_dep ${exe_OBJLIB_DEPS})
+      target_sources(${exe_NAME} PRIVATE $<TARGET_OBJECTS:${objlib_dep}>)
+    endforeach()
+  endif()
+
+  if(CMAKE_THREAD_LIBS_INIT)
+    list(APPEND exe_LIB_DEPS ${CMAKE_THREAD_LIBS_INIT})
+  endif()
+
+  if(BUILD_SHARED_LIBS AND (MSVC OR WIN32))
+    target_compile_definitions(${exe_NAME} PRIVATE "DRACO_BUILDING_DLL=0")
+  endif()
+
+  if(exe_LIB_DEPS)
+    unset(exe_static)
+    if("${CMAKE_EXE_LINKER_FLAGS} ${DRACO_EXE_LINKER_FLAGS}" MATCHES "static")
+      set(exe_static ON)
+    endif()
+
+    if(exe_static AND CMAKE_CXX_COMPILER_ID MATCHES "Clang|GNU")
+      # Third party dependencies can introduce dependencies on system and test
+      # libraries. Since the target created here is an executable, and CMake
+      # does not provide a method of controlling order of link dependencies,
+      # wrap all of the dependencies of this target in start/end group flags to
+      # ensure that dependencies of third party targets can be resolved when
+      # those dependencies happen to be resolved by dependencies of the current
+      # target.
+      list(INSERT exe_LIB_DEPS 0 -Wl,--start-group)
+      list(APPEND exe_LIB_DEPS -Wl,--end-group)
+    endif()
+    target_link_libraries(${exe_NAME} PRIVATE ${exe_LIB_DEPS})
+  endif()
+endmacro()
+
+# Creates a library target of the specified type. The target name is passed as a
+# parameter to the NAME argument, the type as a parameter to the TYPE argument,
+# and the sources passed as a parameter to the SOURCES argument:
+# draco_add_library(NAME <name> TYPE <type> SOURCES <sources> [optional args])
+#
+# Optional args:
+# cmake-format: off
+#   - OUTPUT_NAME: Override output file basename. Target basename defaults to
+#     NAME. OUTPUT_NAME is ignored when BUILD_SHARED_LIBS is enabled and CMake
+#     is generating a build for which MSVC is true. This is to avoid output
+#     basename collisions with DLL import libraries.
+#   - TEST: Flag. Presence means treat library as a test.
+#   - DEFINES: List of preprocessor macro definitions.
+#   - INCLUDES: list of include directories for the target.
+#   - COMPILE_FLAGS: list of compiler flags for the target.
+#   - LINK_FLAGS: List of linker flags for the target.
+#   - OBJLIB_DEPS: List of CMake object library target dependencies.
+#   - LIB_DEPS: List of CMake library dependencies.
+#   - PUBLIC_INCLUDES: List of include paths to export to dependents.
+# cmake-format: on
+#
+# Sources passed to the macro are added to the lists tracking draco sources:
+# cmake-format: off
+#   - When TEST is specified sources are added to $draco_test_sources.
+#   - Otherwise sources are added to $draco_sources.
+# cmake-format: on
+#
+# Targets passed to this macro are added to the lists tracking draco targets:
+# cmake-format: off
+#   - Targets are always added to $draco_targets.
+#   - When the TEST flag is specified, targets are added to
+#     $draco_test_targets.
+#   - When TEST is not specified:
+#     - Libraries of type SHARED are added to $draco_dylib_targets.
+#     - Libraries of type OBJECT are added to $draco_objlib_targets.
+#     - Libraries of type STATIC are added to $draco_lib_targets.
+# cmake-format: on
+macro(draco_add_library)
+  unset(lib_TEST)
+  unset(lib_NAME)
+  unset(lib_OUTPUT_NAME)
+  unset(lib_TYPE)
+  unset(lib_SOURCES)
+  unset(lib_DEFINES)
+  unset(lib_INCLUDES)
+  unset(lib_COMPILE_FLAGS)
+  unset(lib_LINK_FLAGS)
+  unset(lib_OBJLIB_DEPS)
+  unset(lib_LIB_DEPS)
+  unset(lib_PUBLIC_INCLUDES)
+  unset(lib_TARGET_PROPERTIES)
+  set(optional_args TEST)
+  set(single_value_args NAME OUTPUT_NAME TYPE)
+  set(multi_value_args SOURCES DEFINES INCLUDES COMPILE_FLAGS LINK_FLAGS
+                       OBJLIB_DEPS LIB_DEPS PUBLIC_INCLUDES TARGET_PROPERTIES)
+
+  cmake_parse_arguments(lib "${optional_args}" "${single_value_args}"
+                        "${multi_value_args}" ${ARGN})
+
+  if(DRACO_VERBOSE GREATER 1)
+    message("--------- draco_add_library ---------\n"
+            "lib_TEST=${lib_TEST}\n"
+            "lib_NAME=${lib_NAME}\n"
+            "lib_OUTPUT_NAME=${lib_OUTPUT_NAME}\n"
+            "lib_TYPE=${lib_TYPE}\n"
+            "lib_SOURCES=${lib_SOURCES}\n"
+            "lib_DEFINES=${lib_DEFINES}\n"
+            "lib_INCLUDES=${lib_INCLUDES}\n"
+            "lib_COMPILE_FLAGS=${lib_COMPILE_FLAGS}\n"
+            "lib_LINK_FLAGS=${lib_LINK_FLAGS}\n"
+            "lib_OBJLIB_DEPS=${lib_OBJLIB_DEPS}\n"
+            "lib_LIB_DEPS=${lib_LIB_DEPS}\n"
+            "lib_PUBLIC_INCLUDES=${lib_PUBLIC_INCLUDES}\n"
+            "---------------------------------------\n")
+  endif()
+
+  if(NOT (lib_NAME AND lib_TYPE))
+    message(FATAL_ERROR "draco_add_library: NAME and TYPE required.")
+  endif()
+
+  list(APPEND draco_targets ${lib_NAME})
+  if(lib_TEST)
+    list(APPEND draco_test_targets ${lib_NAME})
+    list(APPEND draco_test_sources ${lib_SOURCES})
+  else()
+    list(APPEND draco_sources ${lib_SOURCES})
+    if(lib_TYPE STREQUAL MODULE)
+      list(APPEND draco_module_targets ${lib_NAME})
+    elseif(lib_TYPE STREQUAL OBJECT)
+      list(APPEND draco_objlib_targets ${lib_NAME})
+    elseif(lib_TYPE STREQUAL SHARED)
+      list(APPEND draco_dylib_targets ${lib_NAME})
+    elseif(lib_TYPE STREQUAL STATIC)
+      list(APPEND draco_lib_targets ${lib_NAME})
+    else()
+      message(WARNING "draco_add_library: Unhandled type: ${lib_TYPE}")
+    endif()
+  endif()
+
+  add_library(${lib_NAME} ${lib_TYPE} ${lib_SOURCES})
+  if(lib_SOURCES)
+    draco_process_intrinsics_sources(TARGET ${lib_NAME} SOURCES ${lib_SOURCES})
+  endif()
+
+  if(lib_OUTPUT_NAME)
+    if(NOT (BUILD_SHARED_LIBS AND MSVC))
+      set_target_properties(${lib_NAME}
+                            PROPERTIES OUTPUT_NAME ${lib_OUTPUT_NAME})
+    endif()
+  endif()
+
+  if(lib_DEFINES)
+    target_compile_definitions(${lib_NAME} PRIVATE ${lib_DEFINES})
+  endif()
+
+  if(lib_INCLUDES)
+    target_include_directories(${lib_NAME} PRIVATE ${lib_INCLUDES})
+  endif()
+
+  if(lib_PUBLIC_INCLUDES)
+    target_include_directories(${lib_NAME} PUBLIC ${lib_PUBLIC_INCLUDES})
+  endif()
+
+  if(lib_COMPILE_FLAGS OR DRACO_CXX_FLAGS)
+    target_compile_options(${lib_NAME}
+                           PRIVATE ${lib_COMPILE_FLAGS} ${DRACO_CXX_FLAGS})
+  endif()
+
+  if(lib_LINK_FLAGS)
+    set_target_properties(${lib_NAME} PROPERTIES LINK_FLAGS ${lib_LINK_FLAGS})
+  endif()
+
+  if(lib_OBJLIB_DEPS)
+    foreach(objlib_dep ${lib_OBJLIB_DEPS})
+      target_sources(${lib_NAME} PRIVATE $<TARGET_OBJECTS:${objlib_dep}>)
+    endforeach()
+  endif()
+
+  if(lib_LIB_DEPS)
+    if(lib_TYPE STREQUAL STATIC)
+      set(link_type PUBLIC)
+    else()
+      set(link_type PRIVATE)
+      if(lib_TYPE STREQUAL SHARED AND CMAKE_CXX_COMPILER_ID MATCHES "Clang|GNU")
+        # The draco shared object uses the static draco as input to turn it into
+        # a shared object. Include everything from the static library in the
+        # shared object.
+        if(APPLE)
+          list(INSERT lib_LIB_DEPS 0 -Wl,-force_load)
+        else()
+          list(INSERT lib_LIB_DEPS 0 -Wl,--whole-archive)
+          list(APPEND lib_LIB_DEPS -Wl,--no-whole-archive)
+        endif()
+      endif()
+    endif()
+    target_link_libraries(${lib_NAME} ${link_type} ${lib_LIB_DEPS})
+  endif()
+
+  if(NOT MSVC AND lib_NAME MATCHES "^lib")
+    # Non-MSVC generators prepend lib to static lib target file names. Libdraco
+    # already includes lib in its name. Avoid naming output files liblib*.
+    set_target_properties(${lib_NAME} PROPERTIES PREFIX "")
+  endif()
+
+  # VERSION and SOVERSION as necessary
+  if(NOT lib_TYPE STREQUAL STATIC AND NOT lib_TYPE STREQUAL MODULE)
+    set_target_properties(${lib_NAME} PROPERTIES VERSION ${DRACO_VERSION})
+    if(NOT MSVC)
+      set_target_properties(${lib_NAME} PROPERTIES SOVERSION ${DRACO_SOVERSION})
+    endif()
+  endif()
+
+  if(BUILD_SHARED_LIBS AND (MSVC OR WIN32))
+    if(lib_TYPE STREQUAL SHARED)
+      target_compile_definitions(${lib_NAME} PRIVATE "DRACO_BUILDING_DLL=1")
+    else()
+      target_compile_definitions(${lib_NAME} PRIVATE "DRACO_BUILDING_DLL=0")
+    endif()
+  endif()
+
+  # Determine if $lib_NAME is a header only target.
+  unset(sources_list)
+  if(lib_SOURCES)
+    set(sources_list ${lib_SOURCES})
+    list(FILTER sources_list INCLUDE REGEX cc$)
+  endif()
+
+  if(NOT sources_list)
+    if(NOT XCODE)
+      # This is a header only target. Tell CMake the link language.
+      set_target_properties(${lib_NAME} PROPERTIES LINKER_LANGUAGE CXX)
+    else()
+      # The Xcode generator ignores LINKER_LANGUAGE. Add a dummy cc file.
+      draco_create_dummy_source_file(TARGET ${lib_NAME} BASENAME ${lib_NAME})
+    endif()
+  endif()
+endmacro()
diff --git a/Engine/lib/assimp/contrib/draco/cmake/draco_test_config.h.cmake b/Engine/lib/assimp/contrib/draco/cmake/draco_test_config.h.cmake
new file mode 100644
index 000000000..77a574123
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/draco_test_config.h.cmake
@@ -0,0 +1,13 @@
+#ifndef DRACO_TESTING_DRACO_TEST_CONFIG_H_
+#define DRACO_TESTING_DRACO_TEST_CONFIG_H_
+
+// If this file is named draco_test_config.h.cmake:
+// This file is used as input at cmake generation time.
+
+// If this file is named draco_test_config.h:
+// GENERATED FILE, DO NOT EDIT. SEE ABOVE.
+
+#define DRACO_TEST_DATA_DIR "${DRACO_TEST_DATA_DIR}"
+#define DRACO_TEST_TEMP_DIR "${DRACO_TEST_TEMP_DIR}"
+
+#endif  // DRACO_TESTING_DRACO_TEST_CONFIG_H_
diff --git a/Engine/lib/assimp/contrib/draco/cmake/draco_tests.cmake b/Engine/lib/assimp/contrib/draco/cmake/draco_tests.cmake
new file mode 100644
index 000000000..a6dfc5b57
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/draco_tests.cmake
@@ -0,0 +1,133 @@
+if(DRACO_CMAKE_DRACO_TESTS_CMAKE)
+  return()
+endif()
+set(DRACO_CMAKE_DRACO_TESTS_CMAKE 1)
+
+# The factory tests are in a separate target to avoid breaking tests that rely
+# on file I/O via the factories. The fake reader and writer implementations
+# interfere with normal file I/O function.
+set(draco_factory_test_sources
+    "${draco_src_root}/io/file_reader_factory_test.cc"
+    "${draco_src_root}/io/file_writer_factory_test.cc")
+
+list(
+  APPEND
+    draco_test_sources
+    "${draco_src_root}/animation/keyframe_animation_encoding_test.cc"
+    "${draco_src_root}/animation/keyframe_animation_test.cc"
+    "${draco_src_root}/attributes/point_attribute_test.cc"
+    "${draco_src_root}/compression/attributes/point_d_vector_test.cc"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_test.cc"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_test.cc"
+    "${draco_src_root}/compression/attributes/sequential_integer_attribute_encoding_test.cc"
+    "${draco_src_root}/compression/bit_coders/rans_coding_test.cc"
+    "${draco_src_root}/compression/decode_test.cc"
+    "${draco_src_root}/compression/encode_test.cc"
+    "${draco_src_root}/compression/entropy/shannon_entropy_test.cc"
+    "${draco_src_root}/compression/entropy/symbol_coding_test.cc"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_encoding_test.cc"
+    "${draco_src_root}/compression/mesh/mesh_encoder_test.cc"
+    "${draco_src_root}/compression/point_cloud/point_cloud_kd_tree_encoding_test.cc"
+    "${draco_src_root}/compression/point_cloud/point_cloud_sequential_encoding_test.cc"
+    "${draco_src_root}/core/buffer_bit_coding_test.cc"
+    "${draco_src_root}/core/draco_test_base.h"
+    "${draco_src_root}/core/draco_test_utils.cc"
+    "${draco_src_root}/core/draco_test_utils.h"
+    "${draco_src_root}/core/math_utils_test.cc"
+    "${draco_src_root}/core/quantization_utils_test.cc"
+    "${draco_src_root}/core/status_test.cc"
+    "${draco_src_root}/core/vector_d_test.cc"
+    "${draco_src_root}/io/file_reader_test_common.h"
+    "${draco_src_root}/io/file_utils_test.cc"
+    "${draco_src_root}/io/stdio_file_reader_test.cc"
+    "${draco_src_root}/io/stdio_file_writer_test.cc"
+    "${draco_src_root}/io/obj_decoder_test.cc"
+    "${draco_src_root}/io/obj_encoder_test.cc"
+    "${draco_src_root}/io/ply_decoder_test.cc"
+    "${draco_src_root}/io/ply_reader_test.cc"
+    "${draco_src_root}/io/point_cloud_io_test.cc"
+    "${draco_src_root}/mesh/mesh_are_equivalent_test.cc"
+    "${draco_src_root}/mesh/mesh_cleanup_test.cc"
+    "${draco_src_root}/mesh/triangle_soup_mesh_builder_test.cc"
+    "${draco_src_root}/metadata/metadata_encoder_test.cc"
+    "${draco_src_root}/metadata/metadata_test.cc"
+    "${draco_src_root}/point_cloud/point_cloud_builder_test.cc"
+    "${draco_src_root}/point_cloud/point_cloud_test.cc")
+
+list(APPEND draco_gtest_all
+            "${draco_root}/../googletest/googletest/src/gtest-all.cc")
+list(APPEND draco_gtest_main
+            "${draco_root}/../googletest/googletest/src/gtest_main.cc")
+
+macro(draco_setup_test_targets)
+  if(DRACO_TESTS)
+    if(NOT (EXISTS ${draco_gtest_all} AND EXISTS ${draco_gtest_main}))
+      message(FATAL "googletest must be a sibling directory of ${draco_root}.")
+    endif()
+
+    list(APPEND draco_test_defines GTEST_HAS_PTHREAD=0)
+
+    draco_add_library(TEST
+                      NAME
+                      draco_gtest
+                      TYPE
+                      STATIC
+                      SOURCES
+                      ${draco_gtest_all}
+                      DEFINES
+                      ${draco_defines}
+                      ${draco_test_defines}
+                      INCLUDES
+                      ${draco_test_include_paths})
+
+    draco_add_library(TEST
+                      NAME
+                      draco_gtest_main
+                      TYPE
+                      STATIC
+                      SOURCES
+                      ${draco_gtest_main}
+                      DEFINES
+                      ${draco_defines}
+                      ${draco_test_defines}
+                      INCLUDES
+                      ${draco_test_include_paths})
+
+    set(DRACO_TEST_DATA_DIR "${draco_root}/testdata")
+    set(DRACO_TEST_TEMP_DIR "${draco_build}/draco_test_temp")
+    file(MAKE_DIRECTORY "${DRACO_TEST_TEMP_DIR}")
+
+    # Sets DRACO_TEST_DATA_DIR and DRACO_TEST_TEMP_DIR.
+    configure_file("${draco_root}/cmake/draco_test_config.h.cmake"
+                   "${draco_build}/testing/draco_test_config.h")
+
+    # Create the test targets.
+    draco_add_executable(NAME
+                         draco_tests
+                         SOURCES
+                         ${draco_test_sources}
+                         DEFINES
+                         ${draco_defines}
+                         ${draco_test_defines}
+                         INCLUDES
+                         ${draco_test_include_paths}
+                         LIB_DEPS
+                         draco_static
+                         draco_gtest
+                         draco_gtest_main)
+
+    draco_add_executable(NAME
+                         draco_factory_tests
+                         SOURCES
+                         ${draco_factory_test_sources}
+                         DEFINES
+                         ${draco_defines}
+                         ${draco_test_defines}
+                         INCLUDES
+                         ${draco_test_include_paths}
+                         LIB_DEPS
+                         draco_static
+                         draco_gtest
+                         draco_gtest_main)
+  endif()
+endmacro()
diff --git a/Engine/lib/assimp/contrib/draco/cmake/draco_variables.cmake b/Engine/lib/assimp/contrib/draco/cmake/draco_variables.cmake
new file mode 100644
index 000000000..8dbc77a53
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/draco_variables.cmake
@@ -0,0 +1,64 @@
+if(DRACO_CMAKE_DRACO_VARIABLES_CMAKE_)
+  return()
+endif() # DRACO_CMAKE_DRACO_VARIABLES_CMAKE_
+set(DRACO_CMAKE_DRACO_VARIABLES_CMAKE_ 1)
+
+# Halts generation when $variable_name does not refer to a directory that
+# exists.
+macro(draco_variable_must_be_directory variable_name)
+  if("${variable_name}" STREQUAL "")
+    message(
+      FATAL_ERROR
+        "Empty variable_name passed to draco_variable_must_be_directory.")
+  endif()
+
+  if("${${variable_name}}" STREQUAL "")
+    message(
+      FATAL_ERROR
+        "Empty variable ${variable_name} is required to build draco.")
+  endif()
+
+  if(NOT IS_DIRECTORY "${${variable_name}}")
+    message(
+      FATAL_ERROR
+        "${variable_name}, which is ${${variable_name}}, does not refer to a\n"
+        "directory.")
+  endif()
+endmacro()
+
+# Adds $var_name to the tracked variables list.
+macro(draco_track_configuration_variable var_name)
+  if(DRACO_VERBOSE GREATER 2)
+    message("---- draco_track_configuration_variable ----\n"
+            "var_name=${var_name}\n"
+            "----------------------------------------------\n")
+  endif()
+
+  list(APPEND draco_configuration_variables ${var_name})
+  list(REMOVE_DUPLICATES draco_configuration_variables)
+endmacro()
+
+# Logs current C++ and executable linker flags via the CMake message command.
+macro(draco_dump_cmake_flag_variables)
+  unset(flag_variables)
+  list(APPEND flag_variables "CMAKE_CXX_FLAGS_INIT" "CMAKE_CXX_FLAGS"
+              "CMAKE_EXE_LINKER_FLAGS_INIT" "CMAKE_EXE_LINKER_FLAGS")
+  if(CMAKE_BUILD_TYPE)
+    list(APPEND flag_variables "CMAKE_BUILD_TYPE"
+                "CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE}_INIT"
+                "CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE}"
+                "CMAKE_EXE_LINKER_FLAGS_${CMAKE_BUILD_TYPE}_INIT"
+                "CMAKE_EXE_LINKER_FLAGS_${CMAKE_BUILD_TYPE}")
+  endif()
+  foreach(flag_variable ${flag_variables})
+    message("${flag_variable}:${${flag_variable}}")
+  endforeach()
+endmacro()
+
+# Dumps the variables tracked in $draco_configuration_variables via the CMake
+# message command.
+macro(draco_dump_tracked_configuration_variables)
+  foreach(config_variable ${draco_configuration_variables})
+    message("${config_variable}:${${config_variable}}")
+  endforeach()
+endmacro()
diff --git a/Engine/lib/assimp/contrib/draco/cmake/sanitizers.cmake b/Engine/lib/assimp/contrib/draco/cmake/sanitizers.cmake
new file mode 100644
index 000000000..e720bc045
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/sanitizers.cmake
@@ -0,0 +1,19 @@
+if(DRACO_CMAKE_SANITIZERS_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_SANITIZERS_CMAKE_ 1)
+
+if(MSVC OR NOT SANITIZE)
+  return()
+endif()
+
+include("${draco_root}/cmake/compiler_flags.cmake")
+
+string(TOLOWER ${SANITIZE} SANITIZE)
+
+# Require the sanitizer requested.
+require_linker_flag("-fsanitize=${SANITIZE}")
+require_compiler_flag("-fsanitize=${SANITIZE}" YES)
+
+# Make callstacks accurate.
+require_compiler_flag("-fno-omit-frame-pointer -fno-optimize-sibling-calls" YES)
diff --git a/Engine/lib/assimp/contrib/draco/cmake/toolchains/aarch64-linux-gnu.cmake b/Engine/lib/assimp/contrib/draco/cmake/toolchains/aarch64-linux-gnu.cmake
new file mode 100644
index 000000000..87e0b4a45
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/toolchains/aarch64-linux-gnu.cmake
@@ -0,0 +1,14 @@
+if(DRACO_CMAKE_TOOLCHAINS_AARCH64_LINUX_GNU_CMAKE_)
+  return()
+endif() # DRACO_CMAKE_TOOLCHAINS_AARCH64_LINUX_GNU_CMAKE_
+set(DRACO_CMAKE_TOOLCHAINS_AARCH64_LINUX_GNU_CMAKE_ 1)
+
+set(CMAKE_SYSTEM_NAME "Linux")
+
+if("${CROSS}" STREQUAL "")
+  set(CROSS aarch64-linux-gnu-)
+endif()
+
+set(CMAKE_CXX_COMPILER ${CROSS}g++)
+set(CMAKE_CXX_FLAGS_INIT "-march=armv8-a")
+set(CMAKE_SYSTEM_PROCESSOR "aarch64")
diff --git a/Engine/lib/assimp/contrib/draco/cmake/toolchains/android-ndk-common.cmake b/Engine/lib/assimp/contrib/draco/cmake/toolchains/android-ndk-common.cmake
new file mode 100644
index 000000000..5126d6e29
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/toolchains/android-ndk-common.cmake
@@ -0,0 +1,23 @@
+if(DRACO_CMAKE_TOOLCHAINS_ANDROID_NDK_COMMON_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_ANDROID_NDK_COMMON_CMAKE_ 1)
+
+# Toolchain files do not have access to cached variables:
+# https://gitlab.kitware.com/cmake/cmake/issues/16170. Set an intermediate
+# environment variable when loaded the first time.
+if(DRACO_ANDROID_NDK_PATH)
+  set(ENV{DRACO_ANDROID_NDK_PATH} "${DRACO_ANDROID_NDK_PATH}")
+else()
+  set(DRACO_ANDROID_NDK_PATH "$ENV{DRACO_ANDROID_NDK_PATH}")
+endif()
+
+set(CMAKE_SYSTEM_NAME Android)
+
+if(NOT CMAKE_ANDROID_STL_TYPE)
+  set(CMAKE_ANDROID_STL_TYPE c++_static)
+endif()
+
+if(NOT CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION)
+  set(CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION clang)
+endif()
diff --git a/Engine/lib/assimp/contrib/draco/cmake/toolchains/android.cmake b/Engine/lib/assimp/contrib/draco/cmake/toolchains/android.cmake
new file mode 100644
index 000000000..b8f576d5e
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/toolchains/android.cmake
@@ -0,0 +1,39 @@
+if(DRACO_CMAKE_TOOLCHAINS_ANDROID_CMAKE_)
+  return()
+endif() # DRACO_CMAKE_TOOLCHAINS_ANDROID_CMAKE_
+
+# Additional ANDROID_* settings are available, see:
+# https://developer.android.com/ndk/guides/cmake#variables
+
+if(NOT ANDROID_PLATFORM)
+  set(ANDROID_PLATFORM android-21)
+endif()
+
+# Choose target architecture with:
+#
+# -DANDROID_ABI={armeabi-v7a,armeabi-v7a with NEON,arm64-v8a,x86,x86_64}
+if(NOT ANDROID_ABI)
+  set(ANDROID_ABI arm64-v8a)
+endif()
+
+# Force arm mode for 32-bit targets (instead of the default thumb) to improve
+# performance.
+if(NOT ANDROID_ARM_MODE)
+  set(ANDROID_ARM_MODE arm)
+endif()
+
+# Toolchain files do not have access to cached variables:
+# https://gitlab.kitware.com/cmake/cmake/issues/16170. Set an intermediate
+# environment variable when loaded the first time.
+if(DRACO_ANDROID_NDK_PATH)
+  set(ENV{DRACO_ANDROID_NDK_PATH} "${DRACO_ANDROID_NDK_PATH}")
+else()
+  set(DRACO_ANDROID_NDK_PATH "$ENV{DRACO_ANDROID_NDK_PATH}")
+endif()
+
+if(NOT DRACO_ANDROID_NDK_PATH)
+  message(FATAL_ERROR "DRACO_ANDROID_NDK_PATH not set.")
+  return()
+endif()
+
+include("${DRACO_ANDROID_NDK_PATH}/build/cmake/android.toolchain.cmake")
diff --git a/Engine/lib/assimp/contrib/draco/cmake/toolchains/arm-ios-common.cmake b/Engine/lib/assimp/contrib/draco/cmake/toolchains/arm-ios-common.cmake
new file mode 100644
index 000000000..65326d1c2
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/toolchains/arm-ios-common.cmake
@@ -0,0 +1,17 @@
+if(DRACO_CMAKE_TOOLCHAINS_ARM_IOS_COMMON_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_ARM_IOS_COMMON_CMAKE_ 1)
+
+set(CMAKE_SYSTEM_NAME "Darwin")
+if(CMAKE_OSX_SDK)
+  set(CMAKE_OSX_SYSROOT ${CMAKE_OSX_SDK})
+else()
+  set(CMAKE_OSX_SYSROOT iphoneos)
+endif()
+set(CMAKE_C_COMPILER clang)
+set(CMAKE_C_COMPILER_ARG1 "-arch ${CMAKE_SYSTEM_PROCESSOR}")
+set(CMAKE_CXX_COMPILER clang++)
+set(CMAKE_CXX_COMPILER_ARG1 "-arch ${CMAKE_SYSTEM_PROCESSOR}")
+
+# TODO(tomfinegan): Handle bit code embedding.
diff --git a/Engine/lib/assimp/contrib/draco/cmake/toolchains/arm-linux-gnueabihf.cmake b/Engine/lib/assimp/contrib/draco/cmake/toolchains/arm-linux-gnueabihf.cmake
new file mode 100644
index 000000000..6e45969e9
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/toolchains/arm-linux-gnueabihf.cmake
@@ -0,0 +1,15 @@
+if(DRACO_CMAKE_TOOLCHAINS_ARM_LINUX_GNUEABIHF_CMAKE_)
+  return()
+endif() # DRACO_CMAKE_TOOLCHAINS_ARM_LINUX_GNUEABIHF_CMAKE_
+set(DRACO_CMAKE_TOOLCHAINS_ARM_LINUX_GNUEABIHF_CMAKE_ 1)
+
+set(CMAKE_SYSTEM_NAME "Linux")
+
+if("${CROSS}" STREQUAL "")
+  set(CROSS arm-linux-gnueabihf-)
+endif()
+
+set(CMAKE_CXX_COMPILER ${CROSS}g++)
+set(CMAKE_CXX_FLAGS_INIT "-march=armv7-a -marm")
+set(CMAKE_SYSTEM_PROCESSOR "armv7")
+set(DRACO_NEON_INTRINSICS_FLAG "-mfpu=neon")
diff --git a/Engine/lib/assimp/contrib/draco/cmake/toolchains/arm64-android-ndk-libcpp.cmake b/Engine/lib/assimp/contrib/draco/cmake/toolchains/arm64-android-ndk-libcpp.cmake
new file mode 100644
index 000000000..4b6d366f0
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/toolchains/arm64-android-ndk-libcpp.cmake
@@ -0,0 +1,16 @@
+if(DRACO_CMAKE_TOOLCHAINS_ARM64_ANDROID_NDK_LIBCPP_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_ARM64_ANDROID_NDK_LIBCPP_CMAKE_ 1)
+
+include("${CMAKE_CURRENT_LIST_DIR}/android-ndk-common.cmake")
+
+if(NOT ANDROID_PLATFORM)
+  set(ANROID_PLATFORM android-21)
+endif()
+
+if(NOT ANDROID_ABI)
+  set(ANDROID_ABI arm64-v8a)
+endif()
+
+include("${DRACO_ANDROID_NDK_PATH}/build/cmake/android.toolchain.cmake")
diff --git a/Engine/lib/assimp/contrib/draco/cmake/toolchains/arm64-ios.cmake b/Engine/lib/assimp/contrib/draco/cmake/toolchains/arm64-ios.cmake
new file mode 100644
index 000000000..c4ec7e3fa
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/toolchains/arm64-ios.cmake
@@ -0,0 +1,14 @@
+if(DRACO_CMAKE_TOOLCHAINS_ARM64_IOS_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_ARM64_IOS_CMAKE_ 1)
+
+if(XCODE)
+  # TODO(tomfinegan): Handle arm builds in Xcode.
+  message(FATAL_ERROR "This toolchain does not support Xcode.")
+endif()
+
+set(CMAKE_SYSTEM_PROCESSOR "arm64")
+set(CMAKE_OSX_ARCHITECTURES "arm64")
+
+include("${CMAKE_CURRENT_LIST_DIR}/arm-ios-common.cmake")
diff --git a/Engine/lib/assimp/contrib/draco/cmake/toolchains/arm64-linux-gcc.cmake b/Engine/lib/assimp/contrib/draco/cmake/toolchains/arm64-linux-gcc.cmake
new file mode 100644
index 000000000..046ff0139
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/toolchains/arm64-linux-gcc.cmake
@@ -0,0 +1,18 @@
+if(DRACO_CMAKE_TOOLCHAINS_ARM64_LINUX_GCC_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_ARM64_LINUX_GCC_CMAKE_ 1)
+
+set(CMAKE_SYSTEM_NAME "Linux")
+
+if("${CROSS}" STREQUAL "")
+  # Default the cross compiler prefix to something known to work.
+  set(CROSS aarch64-linux-gnu-)
+endif()
+
+set(CMAKE_C_COMPILER ${CROSS}gcc)
+set(CMAKE_CXX_COMPILER ${CROSS}g++)
+set(AS_EXECUTABLE ${CROSS}as)
+set(CMAKE_C_COMPILER_ARG1 "-march=armv8-a")
+set(CMAKE_CXX_COMPILER_ARG1 "-march=armv8-a")
+set(CMAKE_SYSTEM_PROCESSOR "arm64")
diff --git a/Engine/lib/assimp/contrib/draco/cmake/toolchains/armv7-android-ndk-libcpp.cmake b/Engine/lib/assimp/contrib/draco/cmake/toolchains/armv7-android-ndk-libcpp.cmake
new file mode 100644
index 000000000..80ee98b18
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/toolchains/armv7-android-ndk-libcpp.cmake
@@ -0,0 +1,16 @@
+if(DRACO_CMAKE_TOOLCHAINS_ARMV7_ANDROID_NDK_LIBCPP_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_ARMV7_ANDROID_NDK_LIBCPP_CMAKE_ 1)
+
+include("${CMAKE_CURRENT_LIST_DIR}/android-ndk-common.cmake")
+
+if(NOT ANDROID_PLATFORM)
+  set(ANDROID_PLATFORM android-18)
+endif()
+
+if(NOT ANDROID_ABI)
+  set(ANDROID_ABI armeabi-v7a)
+endif()
+
+include("${DRACO_ANDROID_NDK_PATH}/build/cmake/android.toolchain.cmake")
diff --git a/Engine/lib/assimp/contrib/draco/cmake/toolchains/armv7-ios.cmake b/Engine/lib/assimp/contrib/draco/cmake/toolchains/armv7-ios.cmake
new file mode 100644
index 000000000..8ddd6997b
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/toolchains/armv7-ios.cmake
@@ -0,0 +1,14 @@
+if(DRACO_CMAKE_TOOLCHAINS_ARMV7_IOS_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_ARMV7_IOS_CMAKE_ 1)
+
+if(XCODE)
+  # TODO(tomfinegan): Handle arm builds in Xcode.
+  message(FATAL_ERROR "This toolchain does not support Xcode.")
+endif()
+
+set(CMAKE_SYSTEM_PROCESSOR "armv7")
+set(CMAKE_OSX_ARCHITECTURES "armv7")
+
+include("${CMAKE_CURRENT_LIST_DIR}/arm-ios-common.cmake")
diff --git a/Engine/lib/assimp/contrib/draco/cmake/toolchains/armv7-linux-gcc.cmake b/Engine/lib/assimp/contrib/draco/cmake/toolchains/armv7-linux-gcc.cmake
new file mode 100644
index 000000000..9c9472319
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/toolchains/armv7-linux-gcc.cmake
@@ -0,0 +1,24 @@
+if(DRACO_CMAKE_TOOLCHAINS_ARMV7_LINUX_GCC_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_ARMV7_LINUX_GCC_CMAKE_ 1)
+
+set(CMAKE_SYSTEM_NAME "Linux")
+
+if("${CROSS}" STREQUAL "")
+  # Default the cross compiler prefix to something known to work.
+  set(CROSS arm-linux-gnueabihf-)
+endif()
+
+if(NOT ${CROSS} MATCHES hf-$)
+  set(DRACO_EXTRA_TOOLCHAIN_FLAGS "-mfloat-abi=softfp")
+endif()
+
+set(CMAKE_C_COMPILER ${CROSS}gcc)
+set(CMAKE_CXX_COMPILER ${CROSS}g++)
+set(AS_EXECUTABLE ${CROSS}as)
+set(CMAKE_C_COMPILER_ARG1
+    "-march=armv7-a -mfpu=neon ${DRACO_EXTRA_TOOLCHAIN_FLAGS}")
+set(CMAKE_CXX_COMPILER_ARG1
+    "-march=armv7-a -mfpu=neon ${DRACO_EXTRA_TOOLCHAIN_FLAGS}")
+set(CMAKE_SYSTEM_PROCESSOR "armv7")
diff --git a/Engine/lib/assimp/contrib/draco/cmake/toolchains/armv7s-ios.cmake b/Engine/lib/assimp/contrib/draco/cmake/toolchains/armv7s-ios.cmake
new file mode 100644
index 000000000..b433025ba
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/toolchains/armv7s-ios.cmake
@@ -0,0 +1,14 @@
+if(DRACO_CMAKE_TOOLCHAINS_ARMV7S_IOS_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_ARMV7S_IOS_CMAKE_ 1)
+
+if(XCODE)
+  # TODO(tomfinegan): Handle arm builds in Xcode.
+  message(FATAL_ERROR "This toolchain does not support Xcode.")
+endif()
+
+set(CMAKE_SYSTEM_PROCESSOR "armv7s")
+set(CMAKE_OSX_ARCHITECTURES "armv7s")
+
+include("${CMAKE_CURRENT_LIST_DIR}/arm-ios-common.cmake")
diff --git a/Engine/lib/assimp/contrib/draco/cmake/toolchains/i386-ios.cmake b/Engine/lib/assimp/contrib/draco/cmake/toolchains/i386-ios.cmake
new file mode 100644
index 000000000..e9a105591
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/toolchains/i386-ios.cmake
@@ -0,0 +1,15 @@
+if(DRACO_CMAKE_TOOLCHAINS_i386_IOS_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_i386_IOS_CMAKE_ 1)
+
+if(XCODE)
+  # TODO(tomfinegan): Handle arm builds in Xcode.
+  message(FATAL_ERROR "This toolchain does not support Xcode.")
+endif()
+
+set(CMAKE_SYSTEM_PROCESSOR "i386")
+set(CMAKE_OSX_ARCHITECTURES "i386")
+set(CMAKE_OSX_SDK "iphonesimulator")
+
+include("${CMAKE_CURRENT_LIST_DIR}/arm-ios-common.cmake")
diff --git a/Engine/lib/assimp/contrib/draco/cmake/toolchains/x86-android-ndk-libcpp.cmake b/Engine/lib/assimp/contrib/draco/cmake/toolchains/x86-android-ndk-libcpp.cmake
new file mode 100644
index 000000000..d43383640
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/toolchains/x86-android-ndk-libcpp.cmake
@@ -0,0 +1,16 @@
+if(DRACO_CMAKE_TOOLCHAINS_X86_ANDROID_NDK_LIBCPP_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_X86_ANDROID_NDK_LIBCPP_CMAKE_ 1)
+
+include("${CMAKE_CURRENT_LIST_DIR}/android-ndk-common.cmake")
+
+if(NOT ANDROID_PLATFORM)
+  set(ANDROID_PLATFORM android-18)
+endif()
+
+if(NOT ANDROID_ABI)
+  set(ANDROID_ABI x86)
+endif()
+
+include("${DRACO_ANDROID_NDK_PATH}/build/cmake/android.toolchain.cmake")
diff --git a/Engine/lib/assimp/contrib/draco/cmake/toolchains/x86_64-android-ndk-libcpp.cmake b/Engine/lib/assimp/contrib/draco/cmake/toolchains/x86_64-android-ndk-libcpp.cmake
new file mode 100644
index 000000000..d6fabeacc
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/toolchains/x86_64-android-ndk-libcpp.cmake
@@ -0,0 +1,16 @@
+if(DRACO_CMAKE_TOOLCHAINS_X86_64_ANDROID_NDK_LIBCPP_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_X86_64_ANDROID_NDK_LIBCPP_CMAKE_ 1)
+
+include("${CMAKE_CURRENT_LIST_DIR}/android-ndk-common.cmake")
+
+if(NOT ANDROID_PLATFORM)
+  set(ANDROID_PLATFORM android-21)
+endif()
+
+if(NOT ANDROID_ABI)
+  set(ANDROID_ABI x86_64)
+endif()
+
+include("${DRACO_ANDROID_NDK_PATH}/build/cmake/android.toolchain.cmake")
diff --git a/Engine/lib/assimp/contrib/draco/cmake/toolchains/x86_64-ios.cmake b/Engine/lib/assimp/contrib/draco/cmake/toolchains/x86_64-ios.cmake
new file mode 100644
index 000000000..4c50a72a2
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/toolchains/x86_64-ios.cmake
@@ -0,0 +1,15 @@
+if(DRACO_CMAKE_TOOLCHAINS_X86_64_IOS_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_X86_64_IOS_CMAKE_ 1)
+
+if(XCODE)
+  # TODO(tomfinegan): Handle arm builds in Xcode.
+  message(FATAL_ERROR "This toolchain does not support Xcode.")
+endif()
+
+set(CMAKE_SYSTEM_PROCESSOR "x86_64")
+set(CMAKE_OSX_ARCHITECTURES "x86_64")
+set(CMAKE_OSX_SDK "iphonesimulator")
+
+include("${CMAKE_CURRENT_LIST_DIR}/arm-ios-common.cmake")
diff --git a/Engine/lib/assimp/contrib/draco/cmake/util.cmake b/Engine/lib/assimp/contrib/draco/cmake/util.cmake
new file mode 100644
index 000000000..813146a62
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/cmake/util.cmake
@@ -0,0 +1,79 @@
+if(DRACO_CMAKE_UTIL_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_UTIL_CMAKE_ 1)
+
+# Creates dummy source file in $draco_build_dir named $basename.$extension and
+# returns the full path to the dummy source file via the $out_file_path
+# parameter.
+function(create_dummy_source_file basename extension out_file_path)
+  set(dummy_source_file "${draco_build_dir}/${basename}.${extension}")
+  file(WRITE "${dummy_source_file}.new"
+       "// Generated file. DO NOT EDIT!\n"
+       "// ${target_name} needs a ${extension} file to force link language, \n"
+       "// or to silence a harmless CMake warning: Ignore me.\n"
+       "void ${target_name}_dummy_function(void) {}\n")
+
+  # Will replace ${dummy_source_file} only if the file content has changed.
+  # This prevents forced Draco rebuilds after CMake runs.
+  configure_file("${dummy_source_file}.new" "${dummy_source_file}")
+  file(REMOVE "${dummy_source_file}.new")
+
+  set(${out_file_path} ${dummy_source_file} PARENT_SCOPE)
+endfunction()
+
+# Convenience function for adding a dummy source file to $target_name using
+# $extension as the file extension. Wraps create_dummy_source_file().
+function(add_dummy_source_file_to_target target_name extension)
+  create_dummy_source_file("${target_name}" "${extension}" "dummy_source_file")
+  target_sources(${target_name} PRIVATE ${dummy_source_file})
+endfunction()
+
+# Extracts the version number from $version_file and returns it to the user via
+# $version_string_out_var. This is achieved by finding the first instance of the
+# kDracoVersion variable and then removing everything but the string literal
+# assigned to the variable. Quotes and semicolon are stripped from the returned
+# string.
+function(extract_version_string version_file version_string_out_var)
+  file(STRINGS "${version_file}" draco_version REGEX "kDracoVersion")
+  list(GET draco_version 0 draco_version)
+  string(REPLACE "static const char kDracoVersion[] = " "" draco_version
+                 "${draco_version}")
+  string(REPLACE ";" "" draco_version "${draco_version}")
+  string(REPLACE "\"" "" draco_version "${draco_version}")
+  set("${version_string_out_var}" "${draco_version}" PARENT_SCOPE)
+endfunction()
+
+# Sets CMake compiler launcher to $launcher_name when $launcher_name is found in
+# $PATH. Warns user about ignoring build flag $launcher_flag when $launcher_name
+# is not found in $PATH.
+function(set_compiler_launcher launcher_flag launcher_name)
+  find_program(launcher_path "${launcher_name}")
+  if(launcher_path)
+    set(CMAKE_C_COMPILER_LAUNCHER "${launcher_path}" PARENT_SCOPE)
+    set(CMAKE_CXX_COMPILER_LAUNCHER "${launcher_path}" PARENT_SCOPE)
+    message("--- Using ${launcher_name} as compiler launcher.")
+  else()
+    message(
+      WARNING "--- Cannot find ${launcher_name}, ${launcher_flag} ignored.")
+  endif()
+endfunction()
+
+# Terminates CMake execution when $var_name is unset in the environment. Sets
+# CMake variable to the value of the environment variable when the variable is
+# present in the environment.
+macro(require_variable var_name)
+  if("$ENV{${var_name}}" STREQUAL "")
+    message(FATAL_ERROR "${var_name} must be set in environment.")
+  endif()
+  set_variable_if_unset(${var_name} "")
+endmacro()
+
+# Sets $var_name to $default_value if not already set.
+macro(set_variable_if_unset var_name default_value)
+  if(NOT "$ENV{${var_name}}" STREQUAL "")
+    set(${var_name} $ENV{${var_name}})
+  elseif(NOT ${var_name})
+    set(${var_name} ${default_value})
+  endif()
+endmacro()
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation.cc b/Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation.cc
new file mode 100644
index 000000000..eaf94a330
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation.cc
@@ -0,0 +1,54 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/animation/keyframe_animation.h"
+
+namespace draco {
+
+KeyframeAnimation::KeyframeAnimation() {}
+
+bool KeyframeAnimation::SetTimestamps(
+    const std::vector<TimestampType> &timestamp) {
+  // Already added attributes.
+  const int32_t num_frames = timestamp.size();
+  if (num_attributes() > 0) {
+    // Timestamp attribute could be added only once.
+    if (timestamps()->size()) {
+      return false;
+    } else {
+      // Check if the number of frames is consistent with
+      // the existing keyframes.
+      if (num_frames != num_points()) {
+        return false;
+      }
+    }
+  } else {
+    // This is the first attribute.
+    set_num_frames(num_frames);
+  }
+
+  // Add attribute for time stamp data.
+  std::unique_ptr<PointAttribute> timestamp_att =
+      std::unique_ptr<PointAttribute>(new PointAttribute());
+  timestamp_att->Init(GeometryAttribute::GENERIC, 1, DT_FLOAT32, false,
+                      num_frames);
+  for (PointIndex i(0); i < num_frames; ++i) {
+    timestamp_att->SetAttributeValue(timestamp_att->mapped_index(i),
+                                     &timestamp[i.value()]);
+  }
+  this->SetAttribute(kTimestampId, std::move(timestamp_att));
+  return true;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation.h b/Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation.h
new file mode 100644
index 000000000..a7afb2b81
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation.h
@@ -0,0 +1,107 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ANIMATION_KEYFRAME_ANIMATION_H_
+#define DRACO_ANIMATION_KEYFRAME_ANIMATION_H_
+
+#include <vector>
+
+#include "draco/point_cloud/point_cloud.h"
+
+namespace draco {
+
+// Class for holding keyframe animation data. It will have two or more
+// attributes as a point cloud. The first attribute is always the timestamp
+// of the animation. Each KeyframeAnimation could have multiple animations with
+// the same number of frames. Each animation will be treated as a point
+// attribute.
+class KeyframeAnimation : public PointCloud {
+ public:
+  // Force time stamp to be float type.
+  using TimestampType = float;
+
+  KeyframeAnimation();
+
+  // Animation must have only one timestamp attribute.
+  // This function must be called before adding any animation data.
+  // Returns false if timestamp already exists.
+  bool SetTimestamps(const std::vector<TimestampType> &timestamp);
+
+  // Returns an id for the added animation data. This id will be used to
+  // identify this animation.
+  // Returns -1 if error, e.g. number of frames is not consistent.
+  // Type |T| should be consistent with |DataType|, e.g:
+  //    float - DT_FLOAT32,
+  //    int32_t - DT_INT32, ...
+  template <typename T>
+  int32_t AddKeyframes(DataType data_type, uint32_t num_components,
+                       const std::vector<T> &data);
+
+  const PointAttribute *timestamps() const {
+    return GetAttributeByUniqueId(kTimestampId);
+  }
+  const PointAttribute *keyframes(int32_t animation_id) const {
+    return GetAttributeByUniqueId(animation_id);
+  }
+
+  // Number of frames should be equal to number points in the point cloud.
+  void set_num_frames(int32_t num_frames) { set_num_points(num_frames); }
+  int32_t num_frames() const { return static_cast<int32_t>(num_points()); }
+
+  int32_t num_animations() const { return num_attributes() - 1; }
+
+ private:
+  // Attribute id of timestamp is fixed to 0.
+  static constexpr int32_t kTimestampId = 0;
+};
+
+template <typename T>
+int32_t KeyframeAnimation::AddKeyframes(DataType data_type,
+                                        uint32_t num_components,
+                                        const std::vector<T> &data) {
+  // TODO(draco-eng): Verify T is consistent with |data_type|.
+  if (num_components == 0) {
+    return -1;
+  }
+  // If timestamps is not added yet, then reserve attribute 0 for timestamps.
+  if (!num_attributes()) {
+    // Add a temporary attribute with 0 points to fill attribute id 0.
+    std::unique_ptr<PointAttribute> temp_att =
+        std::unique_ptr<PointAttribute>(new PointAttribute());
+    temp_att->Init(GeometryAttribute::GENERIC, num_components, data_type, false,
+                   0);
+    this->AddAttribute(std::move(temp_att));
+
+    set_num_frames(data.size() / num_components);
+  }
+
+  if (data.size() != num_components * num_frames()) {
+    return -1;
+  }
+
+  std::unique_ptr<PointAttribute> keyframe_att =
+      std::unique_ptr<PointAttribute>(new PointAttribute());
+  keyframe_att->Init(GeometryAttribute::GENERIC, num_components, data_type,
+                     false, num_frames());
+  const size_t stride = num_components;
+  for (PointIndex i(0); i < num_frames(); ++i) {
+    keyframe_att->SetAttributeValue(keyframe_att->mapped_index(i),
+                                    &data[i.value() * stride]);
+  }
+  return this->AddAttribute(std::move(keyframe_att));
+}
+
+}  // namespace draco
+
+#endif  // DRACO_ANIMATION_KEYFRAME_ANIMATION_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation_decoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation_decoder.cc
new file mode 100644
index 000000000..20659468d
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation_decoder.cc
@@ -0,0 +1,30 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/animation/keyframe_animation_decoder.h"
+
+namespace draco {
+
+Status KeyframeAnimationDecoder::Decode(const DecoderOptions &options,
+                                        DecoderBuffer *in_buffer,
+                                        KeyframeAnimation *animation) {
+  const auto status = PointCloudSequentialDecoder::Decode(
+      options, in_buffer, static_cast<PointCloud *>(animation));
+  if (!status.ok()) {
+    return status;
+  }
+  return OkStatus();
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation_decoder.h
new file mode 100644
index 000000000..fdf086b3a
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation_decoder.h
@@ -0,0 +1,34 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ANIMATION_KEYFRAME_ANIMATION_DECODER_H_
+#define DRACO_ANIMATION_KEYFRAME_ANIMATION_DECODER_H_
+
+#include "draco/animation/keyframe_animation.h"
+#include "draco/compression/point_cloud/point_cloud_sequential_decoder.h"
+
+namespace draco {
+
+// Class for decoding keyframe animation.
+class KeyframeAnimationDecoder : private PointCloudSequentialDecoder {
+ public:
+  KeyframeAnimationDecoder(){};
+
+  Status Decode(const DecoderOptions &options, DecoderBuffer *in_buffer,
+                KeyframeAnimation *animation);
+};
+
+}  // namespace draco
+
+#endif  // DRACO_ANIMATION_KEYFRAME_ANIMATION_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation_encoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation_encoder.cc
new file mode 100644
index 000000000..f7d84f310
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation_encoder.cc
@@ -0,0 +1,28 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/animation/keyframe_animation_encoder.h"
+
+namespace draco {
+
+KeyframeAnimationEncoder::KeyframeAnimationEncoder() {}
+
+Status KeyframeAnimationEncoder::EncodeKeyframeAnimation(
+    const KeyframeAnimation &animation, const EncoderOptions &options,
+    EncoderBuffer *out_buffer) {
+  SetPointCloud(animation);
+  return Encode(options, out_buffer);
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation_encoder.h
new file mode 100644
index 000000000..6096c79fa
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation_encoder.h
@@ -0,0 +1,39 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ANIMATION_KEYFRAME_ANIMATION_ENCODER_H_
+#define DRACO_ANIMATION_KEYFRAME_ANIMATION_ENCODER_H_
+
+#include "draco/animation/keyframe_animation.h"
+#include "draco/compression/point_cloud/point_cloud_sequential_encoder.h"
+
+namespace draco {
+
+// Class for encoding keyframe animation. It takes KeyframeAnimation as a
+// PointCloud and compress it. It's mostly a wrapper around PointCloudEncoder so
+// that the animation module could be separated from geometry compression when
+// exposed to developers.
+class KeyframeAnimationEncoder : private PointCloudSequentialEncoder {
+ public:
+  KeyframeAnimationEncoder();
+
+  // Encode an animation to a buffer.
+  Status EncodeKeyframeAnimation(const KeyframeAnimation &animation,
+                                 const EncoderOptions &options,
+                                 EncoderBuffer *out_buffer);
+};
+
+}  // namespace draco
+
+#endif  // DRACO_ANIMATION_KEYFRAME_ANIMATION_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation_encoding_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation_encoding_test.cc
new file mode 100644
index 000000000..4a6491f9d
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation_encoding_test.cc
@@ -0,0 +1,168 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/animation/keyframe_animation.h"
+#include "draco/animation/keyframe_animation_decoder.h"
+#include "draco/animation/keyframe_animation_encoder.h"
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+
+namespace draco {
+
+class KeyframeAnimationEncodingTest : public ::testing::Test {
+ protected:
+  KeyframeAnimationEncodingTest() {}
+
+  bool CreateAndAddTimestamps(int32_t num_frames) {
+    timestamps_.resize(num_frames);
+    for (int i = 0; i < timestamps_.size(); ++i)
+      timestamps_[i] = static_cast<draco::KeyframeAnimation::TimestampType>(i);
+    return keyframe_animation_.SetTimestamps(timestamps_);
+  }
+
+  int32_t CreateAndAddAnimationData(int32_t num_frames,
+                                    uint32_t num_components) {
+    // Create and add animation data with.
+    animation_data_.resize(num_frames * num_components);
+    for (int i = 0; i < animation_data_.size(); ++i)
+      animation_data_[i] = static_cast<float>(i);
+    return keyframe_animation_.AddKeyframes(draco::DT_FLOAT32, num_components,
+                                            animation_data_);
+  }
+
+  template <int num_components_t>
+  void CompareAnimationData(const KeyframeAnimation &animation0,
+                            const KeyframeAnimation &animation1,
+                            bool quantized) {
+    ASSERT_EQ(animation0.num_frames(), animation1.num_frames());
+    ASSERT_EQ(animation0.num_animations(), animation1.num_animations());
+
+    if (quantized) {
+      // TODO(hemmer) : Add test for stable quantization.
+      // Quantization will result in slightly different values.
+      // Skip comparing values.
+      return;
+    }
+
+    // Compare time stamp.
+    const auto timestamp_att0 = animation0.timestamps();
+    const auto timestamp_att1 = animation0.timestamps();
+    for (int i = 0; i < animation0.num_frames(); ++i) {
+      std::array<float, 1> att_value0;
+      std::array<float, 1> att_value1;
+      ASSERT_TRUE((timestamp_att0->GetValue<float, 1>(
+          draco::AttributeValueIndex(i), &att_value0)));
+      ASSERT_TRUE((timestamp_att1->GetValue<float, 1>(
+          draco::AttributeValueIndex(i), &att_value1)));
+      ASSERT_FLOAT_EQ(att_value0[0], att_value1[0]);
+    }
+
+    for (int animation_id = 1; animation_id < animation0.num_animations();
+         ++animation_id) {
+      // Compare keyframe data.
+      const auto keyframe_att0 = animation0.keyframes(animation_id);
+      const auto keyframe_att1 = animation1.keyframes(animation_id);
+      ASSERT_EQ(keyframe_att0->num_components(),
+                keyframe_att1->num_components());
+      for (int i = 0; i < animation0.num_frames(); ++i) {
+        std::array<float, num_components_t> att_value0;
+        std::array<float, num_components_t> att_value1;
+        ASSERT_TRUE((keyframe_att0->GetValue<float, num_components_t>(
+            draco::AttributeValueIndex(i), &att_value0)));
+        ASSERT_TRUE((keyframe_att1->GetValue<float, num_components_t>(
+            draco::AttributeValueIndex(i), &att_value1)));
+        for (int j = 0; j < att_value0.size(); ++j) {
+          ASSERT_FLOAT_EQ(att_value0[j], att_value1[j]);
+        }
+      }
+    }
+  }
+
+  template <int num_components_t>
+  void TestKeyframeAnimationEncoding() {
+    TestKeyframeAnimationEncoding<num_components_t>(false);
+  }
+
+  template <int num_components_t>
+  void TestKeyframeAnimationEncoding(bool quantized) {
+    // Encode animation class.
+    draco::EncoderBuffer buffer;
+    draco::KeyframeAnimationEncoder encoder;
+    EncoderOptions options = EncoderOptions::CreateDefaultOptions();
+    if (quantized) {
+      // Set quantization for timestamps.
+      options.SetAttributeInt(0, "quantization_bits", 20);
+      // Set quantization for keyframes.
+      for (int i = 1; i <= keyframe_animation_.num_animations(); ++i) {
+        options.SetAttributeInt(i, "quantization_bits", 20);
+      }
+    }
+
+    ASSERT_TRUE(
+        encoder.EncodeKeyframeAnimation(keyframe_animation_, options, &buffer)
+            .ok());
+
+    draco::DecoderBuffer dec_decoder;
+    draco::KeyframeAnimationDecoder decoder;
+    DecoderBuffer dec_buffer;
+    dec_buffer.Init(buffer.data(), buffer.size());
+
+    // Decode animation class.
+    std::unique_ptr<KeyframeAnimation> decoded_animation(
+        new KeyframeAnimation());
+    DecoderOptions dec_options;
+    ASSERT_TRUE(
+        decoder.Decode(dec_options, &dec_buffer, decoded_animation.get()).ok());
+
+    // Verify if animation before and after compression is identical.
+    CompareAnimationData<num_components_t>(keyframe_animation_,
+                                           *decoded_animation, quantized);
+  }
+
+  draco::KeyframeAnimation keyframe_animation_;
+  std::vector<draco::KeyframeAnimation::TimestampType> timestamps_;
+  std::vector<float> animation_data_;
+};
+
+TEST_F(KeyframeAnimationEncodingTest, OneComponent) {
+  const int num_frames = 1;
+  ASSERT_TRUE(CreateAndAddTimestamps(num_frames));
+  ASSERT_EQ(CreateAndAddAnimationData(num_frames, 1), 1);
+  TestKeyframeAnimationEncoding<1>();
+}
+
+TEST_F(KeyframeAnimationEncodingTest, ManyComponents) {
+  const int num_frames = 100;
+  ASSERT_TRUE(CreateAndAddTimestamps(num_frames));
+  ASSERT_EQ(CreateAndAddAnimationData(num_frames, 100), 1);
+  TestKeyframeAnimationEncoding<100>();
+}
+
+TEST_F(KeyframeAnimationEncodingTest, ManyComponentsWithQuantization) {
+  const int num_frames = 100;
+  ASSERT_TRUE(CreateAndAddTimestamps(num_frames));
+  ASSERT_EQ(CreateAndAddAnimationData(num_frames, 4), 1);
+  // Test compression with quantization.
+  TestKeyframeAnimationEncoding<4>(true);
+}
+
+TEST_F(KeyframeAnimationEncodingTest, MultipleAnimations) {
+  const int num_frames = 5;
+  ASSERT_TRUE(CreateAndAddTimestamps(num_frames));
+  ASSERT_EQ(CreateAndAddAnimationData(num_frames, 3), 1);
+  ASSERT_EQ(CreateAndAddAnimationData(num_frames, 3), 2);
+  TestKeyframeAnimationEncoding<3>();
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation_test.cc
new file mode 100644
index 000000000..bc92b25ff
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/animation/keyframe_animation_test.cc
@@ -0,0 +1,102 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/animation/keyframe_animation.h"
+
+#include "draco/core/draco_test_base.h"
+
+namespace {
+
+class KeyframeAnimationTest : public ::testing::Test {
+ protected:
+  KeyframeAnimationTest() {}
+
+  bool CreateAndAddTimestamps(int32_t num_frames) {
+    timestamps_.resize(num_frames);
+    for (int i = 0; i < timestamps_.size(); ++i)
+      timestamps_[i] = static_cast<draco::KeyframeAnimation::TimestampType>(i);
+    return keyframe_animation_.SetTimestamps(timestamps_);
+  }
+
+  int32_t CreateAndAddAnimationData(int32_t num_frames,
+                                    uint32_t num_components) {
+    // Create and add animation data with.
+    animation_data_.resize(num_frames * num_components);
+    for (int i = 0; i < animation_data_.size(); ++i)
+      animation_data_[i] = static_cast<float>(i);
+    return keyframe_animation_.AddKeyframes(draco::DT_FLOAT32, num_components,
+                                            animation_data_);
+  }
+
+  template <int num_components_t>
+  void CompareAnimationData() {
+    // Compare time stamp.
+    const auto timestamp_att = keyframe_animation_.timestamps();
+    for (int i = 0; i < timestamps_.size(); ++i) {
+      std::array<float, 1> att_value;
+      ASSERT_TRUE((timestamp_att->GetValue<float, 1>(
+          draco::AttributeValueIndex(i), &att_value)));
+      ASSERT_FLOAT_EQ(att_value[0], i);
+    }
+
+    // Compare keyframe data.
+    const auto keyframe_att = keyframe_animation_.keyframes(1);
+    for (int i = 0; i < animation_data_.size() / num_components_t; ++i) {
+      std::array<float, num_components_t> att_value;
+      ASSERT_TRUE((keyframe_att->GetValue<float, num_components_t>(
+          draco::AttributeValueIndex(i), &att_value)));
+      for (int j = 0; j < num_components_t; ++j) {
+        ASSERT_FLOAT_EQ(att_value[j], i * num_components_t + j);
+      }
+    }
+  }
+
+  template <int num_components_t>
+  void TestKeyframeAnimation(int32_t num_frames) {
+    ASSERT_TRUE(CreateAndAddTimestamps(num_frames));
+    ASSERT_EQ(CreateAndAddAnimationData(num_frames, num_components_t), 1);
+    CompareAnimationData<num_components_t>();
+  }
+
+  draco::KeyframeAnimation keyframe_animation_;
+  std::vector<draco::KeyframeAnimation::TimestampType> timestamps_;
+  std::vector<float> animation_data_;
+};
+
+// Test animation with 1 component and 10 frames.
+TEST_F(KeyframeAnimationTest, OneComponent) { TestKeyframeAnimation<1>(10); }
+
+// Test animation with 4 component and 10 frames.
+TEST_F(KeyframeAnimationTest, FourComponent) { TestKeyframeAnimation<4>(10); }
+
+// Test adding animation data before timestamp.
+TEST_F(KeyframeAnimationTest, AddingAnimationFirst) {
+  ASSERT_EQ(CreateAndAddAnimationData(5, 1), 1);
+  ASSERT_TRUE(CreateAndAddTimestamps(5));
+}
+
+// Test adding timestamp more than once.
+TEST_F(KeyframeAnimationTest, ErrorAddingTimestampsTwice) {
+  ASSERT_TRUE(CreateAndAddTimestamps(5));
+  ASSERT_FALSE(CreateAndAddTimestamps(5));
+}
+// Test animation with multiple animation data.
+TEST_F(KeyframeAnimationTest, MultipleAnimationData) {
+  const int num_frames = 5;
+  ASSERT_TRUE(CreateAndAddTimestamps(num_frames));
+  ASSERT_EQ(CreateAndAddAnimationData(num_frames, 1), 1);
+  ASSERT_EQ(CreateAndAddAnimationData(num_frames, 2), 2);
+}
+
+}  // namespace
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_octahedron_transform.cc b/Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_octahedron_transform.cc
new file mode 100644
index 000000000..51c3bb6c8
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_octahedron_transform.cc
@@ -0,0 +1,145 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include "draco/attributes/attribute_octahedron_transform.h"
+
+#include "draco/attributes/attribute_transform_type.h"
+#include "draco/compression/attributes/normal_compression_utils.h"
+
+namespace draco {
+
+bool AttributeOctahedronTransform::InitFromAttribute(
+    const PointAttribute &attribute) {
+  const AttributeTransformData *const transform_data =
+      attribute.GetAttributeTransformData();
+  if (!transform_data ||
+      transform_data->transform_type() != ATTRIBUTE_OCTAHEDRON_TRANSFORM) {
+    return false;  // Wrong transform type.
+  }
+  quantization_bits_ = transform_data->GetParameterValue<int32_t>(0);
+  return true;
+}
+
+void AttributeOctahedronTransform::CopyToAttributeTransformData(
+    AttributeTransformData *out_data) const {
+  out_data->set_transform_type(ATTRIBUTE_OCTAHEDRON_TRANSFORM);
+  out_data->AppendParameterValue(quantization_bits_);
+}
+
+bool AttributeOctahedronTransform::TransformAttribute(
+    const PointAttribute &attribute, const std::vector<PointIndex> &point_ids,
+    PointAttribute *target_attribute) {
+  return GeneratePortableAttribute(attribute, point_ids,
+                                   target_attribute->size(), target_attribute);
+}
+
+bool AttributeOctahedronTransform::InverseTransformAttribute(
+    const PointAttribute &attribute, PointAttribute *target_attribute) {
+  if (target_attribute->data_type() != DT_FLOAT32) {
+    return false;
+  }
+
+  const int num_points = target_attribute->size();
+  const int num_components = target_attribute->num_components();
+  if (num_components != 3) {
+    return false;
+  }
+  constexpr int kEntrySize = sizeof(float) * 3;
+  float att_val[3];
+  const int32_t *source_attribute_data = reinterpret_cast<const int32_t *>(
+      attribute.GetAddress(AttributeValueIndex(0)));
+  uint8_t *target_address =
+      target_attribute->GetAddress(AttributeValueIndex(0));
+  OctahedronToolBox octahedron_tool_box;
+  if (!octahedron_tool_box.SetQuantizationBits(quantization_bits_)) {
+    return false;
+  }
+  for (uint32_t i = 0; i < num_points; ++i) {
+    const int32_t s = *source_attribute_data++;
+    const int32_t t = *source_attribute_data++;
+    octahedron_tool_box.QuantizedOctahedralCoordsToUnitVector(s, t, att_val);
+
+    // Store the decoded floating point values into the attribute buffer.
+    std::memcpy(target_address, att_val, kEntrySize);
+    target_address += kEntrySize;
+  }
+  return true;
+}
+
+void AttributeOctahedronTransform::SetParameters(int quantization_bits) {
+  quantization_bits_ = quantization_bits;
+}
+
+bool AttributeOctahedronTransform::EncodeParameters(
+    EncoderBuffer *encoder_buffer) const {
+  if (is_initialized()) {
+    encoder_buffer->Encode(static_cast<uint8_t>(quantization_bits_));
+    return true;
+  }
+  return false;
+}
+
+bool AttributeOctahedronTransform::DecodeParameters(
+    const PointAttribute &attribute, DecoderBuffer *decoder_buffer) {
+  uint8_t quantization_bits;
+  if (!decoder_buffer->Decode(&quantization_bits)) {
+    return false;
+  }
+  quantization_bits_ = quantization_bits;
+  return true;
+}
+
+bool AttributeOctahedronTransform::GeneratePortableAttribute(
+    const PointAttribute &attribute, const std::vector<PointIndex> &point_ids,
+    int num_points, PointAttribute *target_attribute) const {
+  DRACO_DCHECK(is_initialized());
+
+  // Quantize all values in the order given by point_ids into portable
+  // attribute.
+  int32_t *const portable_attribute_data = reinterpret_cast<int32_t *>(
+      target_attribute->GetAddress(AttributeValueIndex(0)));
+  float att_val[3];
+  int32_t dst_index = 0;
+  OctahedronToolBox converter;
+  if (!converter.SetQuantizationBits(quantization_bits_)) {
+    return false;
+  }
+  if (!point_ids.empty()) {
+    for (uint32_t i = 0; i < point_ids.size(); ++i) {
+      const AttributeValueIndex att_val_id =
+          attribute.mapped_index(point_ids[i]);
+      attribute.GetValue(att_val_id, att_val);
+      // Encode the vector into a s and t octahedral coordinates.
+      int32_t s, t;
+      converter.FloatVectorToQuantizedOctahedralCoords(att_val, &s, &t);
+      portable_attribute_data[dst_index++] = s;
+      portable_attribute_data[dst_index++] = t;
+    }
+  } else {
+    for (PointIndex i(0); i < num_points; ++i) {
+      const AttributeValueIndex att_val_id = attribute.mapped_index(i);
+      attribute.GetValue(att_val_id, att_val);
+      // Encode the vector into a s and t octahedral coordinates.
+      int32_t s, t;
+      converter.FloatVectorToQuantizedOctahedralCoords(att_val, &s, &t);
+      portable_attribute_data[dst_index++] = s;
+      portable_attribute_data[dst_index++] = t;
+    }
+  }
+
+  return true;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_octahedron_transform.h b/Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_octahedron_transform.h
new file mode 100644
index 000000000..21a1725bb
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_octahedron_transform.h
@@ -0,0 +1,81 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef DRACO_ATTRIBUTES_ATTRIBUTE_OCTAHEDRON_TRANSFORM_H_
+#define DRACO_ATTRIBUTES_ATTRIBUTE_OCTAHEDRON_TRANSFORM_H_
+
+#include "draco/attributes/attribute_transform.h"
+#include "draco/attributes/point_attribute.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// Attribute transform for attributes transformed to octahedral coordinates.
+class AttributeOctahedronTransform : public AttributeTransform {
+ public:
+  AttributeOctahedronTransform() : quantization_bits_(-1) {}
+
+  // Return attribute transform type.
+  AttributeTransformType Type() const override {
+    return ATTRIBUTE_OCTAHEDRON_TRANSFORM;
+  }
+  // Try to init transform from attribute.
+  bool InitFromAttribute(const PointAttribute &attribute) override;
+  // Copy parameter values into the provided AttributeTransformData instance.
+  void CopyToAttributeTransformData(
+      AttributeTransformData *out_data) const override;
+
+  bool TransformAttribute(const PointAttribute &attribute,
+                          const std::vector<PointIndex> &point_ids,
+                          PointAttribute *target_attribute) override;
+
+  bool InverseTransformAttribute(const PointAttribute &attribute,
+                                 PointAttribute *target_attribute) override;
+
+  // Set number of quantization bits.
+  void SetParameters(int quantization_bits);
+
+  // Encode relevant parameters into buffer.
+  bool EncodeParameters(EncoderBuffer *encoder_buffer) const override;
+
+  bool DecodeParameters(const PointAttribute &attribute,
+                        DecoderBuffer *decoder_buffer) override;
+
+  bool is_initialized() const { return quantization_bits_ != -1; }
+  int32_t quantization_bits() const { return quantization_bits_; }
+
+ protected:
+  DataType GetTransformedDataType(
+      const PointAttribute &attribute) const override {
+    return DT_UINT32;
+  }
+  int GetTransformedNumComponents(
+      const PointAttribute &attribute) const override {
+    return 2;
+  }
+
+  // Perform the actual transformation.
+  bool GeneratePortableAttribute(const PointAttribute &attribute,
+                                 const std::vector<PointIndex> &point_ids,
+                                 int num_points,
+                                 PointAttribute *target_attribute) const;
+
+ private:
+  int32_t quantization_bits_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_ATTRIBUTES_ATTRIBUTE_OCTAHEDRON_TRANSFORM_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_quantization_transform.cc b/Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_quantization_transform.cc
new file mode 100644
index 000000000..a7f93a488
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_quantization_transform.cc
@@ -0,0 +1,260 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/attributes/attribute_quantization_transform.h"
+
+#include "draco/attributes/attribute_transform_type.h"
+#include "draco/core/quantization_utils.h"
+
+namespace draco {
+
+bool AttributeQuantizationTransform::InitFromAttribute(
+    const PointAttribute &attribute) {
+  const AttributeTransformData *const transform_data =
+      attribute.GetAttributeTransformData();
+  if (!transform_data ||
+      transform_data->transform_type() != ATTRIBUTE_QUANTIZATION_TRANSFORM) {
+    return false;  // Wrong transform type.
+  }
+  int32_t byte_offset = 0;
+  quantization_bits_ = transform_data->GetParameterValue<int32_t>(byte_offset);
+  byte_offset += 4;
+  min_values_.resize(attribute.num_components());
+  for (int i = 0; i < attribute.num_components(); ++i) {
+    min_values_[i] = transform_data->GetParameterValue<float>(byte_offset);
+    byte_offset += 4;
+  }
+  range_ = transform_data->GetParameterValue<float>(byte_offset);
+  return true;
+}
+
+// Copy parameter values into the provided AttributeTransformData instance.
+void AttributeQuantizationTransform::CopyToAttributeTransformData(
+    AttributeTransformData *out_data) const {
+  out_data->set_transform_type(ATTRIBUTE_QUANTIZATION_TRANSFORM);
+  out_data->AppendParameterValue(quantization_bits_);
+  for (int i = 0; i < min_values_.size(); ++i) {
+    out_data->AppendParameterValue(min_values_[i]);
+  }
+  out_data->AppendParameterValue(range_);
+}
+
+bool AttributeQuantizationTransform::TransformAttribute(
+    const PointAttribute &attribute, const std::vector<PointIndex> &point_ids,
+    PointAttribute *target_attribute) {
+  if (point_ids.empty()) {
+    GeneratePortableAttribute(attribute, target_attribute->size(),
+                              target_attribute);
+  } else {
+    GeneratePortableAttribute(attribute, point_ids, target_attribute->size(),
+                              target_attribute);
+  }
+  return true;
+}
+
+bool AttributeQuantizationTransform::InverseTransformAttribute(
+    const PointAttribute &attribute, PointAttribute *target_attribute) {
+  if (target_attribute->data_type() != DT_FLOAT32) {
+    return false;
+  }
+
+  // Convert all quantized values back to floats.
+  const int32_t max_quantized_value =
+      (1u << static_cast<uint32_t>(quantization_bits_)) - 1;
+  const int num_components = target_attribute->num_components();
+  const int entry_size = sizeof(float) * num_components;
+  const std::unique_ptr<float[]> att_val(new float[num_components]);
+  int quant_val_id = 0;
+  int out_byte_pos = 0;
+  Dequantizer dequantizer;
+  if (!dequantizer.Init(range_, max_quantized_value)) {
+    return false;
+  }
+  const int32_t *const source_attribute_data =
+      reinterpret_cast<const int32_t *>(
+          attribute.GetAddress(AttributeValueIndex(0)));
+
+  const int num_values = target_attribute->size();
+
+  for (uint32_t i = 0; i < num_values; ++i) {
+    for (int c = 0; c < num_components; ++c) {
+      float value =
+          dequantizer.DequantizeFloat(source_attribute_data[quant_val_id++]);
+      value = value + min_values_[c];
+      att_val[c] = value;
+    }
+    // Store the floating point value into the attribute buffer.
+    target_attribute->buffer()->Write(out_byte_pos, att_val.get(), entry_size);
+    out_byte_pos += entry_size;
+  }
+  return true;
+}
+
+bool AttributeQuantizationTransform::IsQuantizationValid(
+    int quantization_bits) {
+  // Currently we allow only up to 30 bit quantization.
+  return quantization_bits >= 1 && quantization_bits <= 30;
+}
+
+bool AttributeQuantizationTransform::SetParameters(int quantization_bits,
+                                                   const float *min_values,
+                                                   int num_components,
+                                                   float range) {
+  if (!IsQuantizationValid(quantization_bits)) {
+    return false;
+  }
+  quantization_bits_ = quantization_bits;
+  min_values_.assign(min_values, min_values + num_components);
+  range_ = range;
+  return true;
+}
+
+bool AttributeQuantizationTransform::ComputeParameters(
+    const PointAttribute &attribute, const int quantization_bits) {
+  if (quantization_bits_ != -1) {
+    return false;  // already initialized.
+  }
+  if (!IsQuantizationValid(quantization_bits)) {
+    return false;
+  }
+  quantization_bits_ = quantization_bits;
+
+  const int num_components = attribute.num_components();
+  range_ = 0.f;
+  min_values_ = std::vector<float>(num_components, 0.f);
+  const std::unique_ptr<float[]> max_values(new float[num_components]);
+  const std::unique_ptr<float[]> att_val(new float[num_components]);
+  // Compute minimum values and max value difference.
+  attribute.GetValue(AttributeValueIndex(0), att_val.get());
+  attribute.GetValue(AttributeValueIndex(0), min_values_.data());
+  attribute.GetValue(AttributeValueIndex(0), max_values.get());
+
+  for (AttributeValueIndex i(1); i < static_cast<uint32_t>(attribute.size());
+       ++i) {
+    attribute.GetValue(i, att_val.get());
+    for (int c = 0; c < num_components; ++c) {
+      if (min_values_[c] > att_val[c]) {
+        min_values_[c] = att_val[c];
+      }
+      if (max_values[c] < att_val[c]) {
+        max_values[c] = att_val[c];
+      }
+    }
+  }
+  for (int c = 0; c < num_components; ++c) {
+    if (std::isnan(min_values_[c]) || std::isinf(min_values_[c]) ||
+        std::isnan(max_values[c]) || std::isinf(max_values[c])) {
+      return false;
+    }
+    const float dif = max_values[c] - min_values_[c];
+    if (dif > range_) {
+      range_ = dif;
+    }
+  }
+
+  // In case all values are the same, initialize the range to unit length. This
+  // will ensure that all values are quantized properly to the same value.
+  if (range_ == 0.f) {
+    range_ = 1.f;
+  }
+
+  return true;
+}
+
+bool AttributeQuantizationTransform::EncodeParameters(
+    EncoderBuffer *encoder_buffer) const {
+  if (is_initialized()) {
+    encoder_buffer->Encode(min_values_.data(),
+                           sizeof(float) * min_values_.size());
+    encoder_buffer->Encode(range_);
+    encoder_buffer->Encode(static_cast<uint8_t>(quantization_bits_));
+    return true;
+  }
+  return false;
+}
+
+bool AttributeQuantizationTransform::DecodeParameters(
+    const PointAttribute &attribute, DecoderBuffer *decoder_buffer) {
+  min_values_.resize(attribute.num_components());
+  if (!decoder_buffer->Decode(&min_values_[0],
+                              sizeof(float) * min_values_.size())) {
+    return false;
+  }
+  if (!decoder_buffer->Decode(&range_)) {
+    return false;
+  }
+  uint8_t quantization_bits;
+  if (!decoder_buffer->Decode(&quantization_bits)) {
+    return false;
+  }
+  if (!IsQuantizationValid(quantization_bits)) {
+    return false;
+  }
+  quantization_bits_ = quantization_bits;
+  return true;
+}
+
+void AttributeQuantizationTransform::GeneratePortableAttribute(
+    const PointAttribute &attribute, int num_points,
+    PointAttribute *target_attribute) const {
+  DRACO_DCHECK(is_initialized());
+
+  const int num_components = attribute.num_components();
+
+  // Quantize all values using the order given by point_ids.
+  int32_t *const portable_attribute_data = reinterpret_cast<int32_t *>(
+      target_attribute->GetAddress(AttributeValueIndex(0)));
+  const uint32_t max_quantized_value = (1 << (quantization_bits_)) - 1;
+  Quantizer quantizer;
+  quantizer.Init(range(), max_quantized_value);
+  int32_t dst_index = 0;
+  const std::unique_ptr<float[]> att_val(new float[num_components]);
+  for (PointIndex i(0); i < num_points; ++i) {
+    const AttributeValueIndex att_val_id = attribute.mapped_index(i);
+    attribute.GetValue(att_val_id, att_val.get());
+    for (int c = 0; c < num_components; ++c) {
+      const float value = (att_val[c] - min_values()[c]);
+      const int32_t q_val = quantizer.QuantizeFloat(value);
+      portable_attribute_data[dst_index++] = q_val;
+    }
+  }
+}
+
+void AttributeQuantizationTransform::GeneratePortableAttribute(
+    const PointAttribute &attribute, const std::vector<PointIndex> &point_ids,
+    int num_points, PointAttribute *target_attribute) const {
+  DRACO_DCHECK(is_initialized());
+
+  const int num_components = attribute.num_components();
+
+  // Quantize all values using the order given by point_ids.
+  int32_t *const portable_attribute_data = reinterpret_cast<int32_t *>(
+      target_attribute->GetAddress(AttributeValueIndex(0)));
+  const uint32_t max_quantized_value = (1 << (quantization_bits_)) - 1;
+  Quantizer quantizer;
+  quantizer.Init(range(), max_quantized_value);
+  int32_t dst_index = 0;
+  const std::unique_ptr<float[]> att_val(new float[num_components]);
+  for (uint32_t i = 0; i < point_ids.size(); ++i) {
+    const AttributeValueIndex att_val_id = attribute.mapped_index(point_ids[i]);
+    attribute.GetValue(att_val_id, att_val.get());
+    for (int c = 0; c < num_components; ++c) {
+      const float value = (att_val[c] - min_values()[c]);
+      const int32_t q_val = quantizer.QuantizeFloat(value);
+      portable_attribute_data[dst_index++] = q_val;
+    }
+  }
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_quantization_transform.h b/Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_quantization_transform.h
new file mode 100644
index 000000000..f1122b680
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_quantization_transform.h
@@ -0,0 +1,102 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ATTRIBUTES_ATTRIBUTE_QUANTIZATION_TRANSFORM_H_
+#define DRACO_ATTRIBUTES_ATTRIBUTE_QUANTIZATION_TRANSFORM_H_
+
+#include <vector>
+
+#include "draco/attributes/attribute_transform.h"
+#include "draco/attributes/point_attribute.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// Attribute transform for quantized attributes.
+class AttributeQuantizationTransform : public AttributeTransform {
+ public:
+  AttributeQuantizationTransform() : quantization_bits_(-1), range_(0.f) {}
+  // Return attribute transform type.
+  AttributeTransformType Type() const override {
+    return ATTRIBUTE_QUANTIZATION_TRANSFORM;
+  }
+  // Try to init transform from attribute.
+  bool InitFromAttribute(const PointAttribute &attribute) override;
+  // Copy parameter values into the provided AttributeTransformData instance.
+  void CopyToAttributeTransformData(
+      AttributeTransformData *out_data) const override;
+
+  bool TransformAttribute(const PointAttribute &attribute,
+                          const std::vector<PointIndex> &point_ids,
+                          PointAttribute *target_attribute) override;
+
+  bool InverseTransformAttribute(const PointAttribute &attribute,
+                                 PointAttribute *target_attribute) override;
+
+  bool SetParameters(int quantization_bits, const float *min_values,
+                     int num_components, float range);
+
+  bool ComputeParameters(const PointAttribute &attribute,
+                         const int quantization_bits);
+
+  // Encode relevant parameters into buffer.
+  bool EncodeParameters(EncoderBuffer *encoder_buffer) const override;
+
+  bool DecodeParameters(const PointAttribute &attribute,
+                        DecoderBuffer *decoder_buffer) override;
+
+  int32_t quantization_bits() const { return quantization_bits_; }
+  float min_value(int axis) const { return min_values_[axis]; }
+  const std::vector<float> &min_values() const { return min_values_; }
+  float range() const { return range_; }
+  bool is_initialized() const { return quantization_bits_ != -1; }
+
+ protected:
+  // Create portable attribute using 1:1 mapping between points in the input and
+  // output attribute.
+  void GeneratePortableAttribute(const PointAttribute &attribute,
+                                 int num_points,
+                                 PointAttribute *target_attribute) const;
+
+  // Create portable attribute using custom mapping between input and output
+  // points.
+  void GeneratePortableAttribute(const PointAttribute &attribute,
+                                 const std::vector<PointIndex> &point_ids,
+                                 int num_points,
+                                 PointAttribute *target_attribute) const;
+
+  DataType GetTransformedDataType(
+      const PointAttribute &attribute) const override {
+    return DT_UINT32;
+  }
+  int GetTransformedNumComponents(
+      const PointAttribute &attribute) const override {
+    return attribute.num_components();
+  }
+
+  static bool IsQuantizationValid(int quantization_bits);
+
+ private:
+  int32_t quantization_bits_;
+
+  // Minimal dequantized value for each component of the attribute.
+  std::vector<float> min_values_;
+
+  // Bounds of the dequantized attribute (max delta over all components).
+  float range_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTE_DEQUANTIZATION_TRANSFORM_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_transform.cc b/Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_transform.cc
new file mode 100644
index 000000000..174e6b822
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_transform.cc
@@ -0,0 +1,40 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/attributes/attribute_transform.h"
+
+namespace draco {
+
+bool AttributeTransform::TransferToAttribute(PointAttribute *attribute) const {
+  std::unique_ptr<AttributeTransformData> transform_data(
+      new AttributeTransformData());
+  this->CopyToAttributeTransformData(transform_data.get());
+  attribute->SetAttributeTransformData(std::move(transform_data));
+  return true;
+}
+
+std::unique_ptr<PointAttribute> AttributeTransform::InitTransformedAttribute(
+    const PointAttribute &src_attribute, int num_entries) {
+  const int num_components = GetTransformedNumComponents(src_attribute);
+  const DataType dt = GetTransformedDataType(src_attribute);
+  GeometryAttribute va;
+  va.Init(src_attribute.attribute_type(), nullptr, num_components, dt, false,
+          num_components * DataTypeLength(dt), 0);
+  std::unique_ptr<PointAttribute> transformed_attribute(new PointAttribute(va));
+  transformed_attribute->Reset(num_entries);
+  transformed_attribute->SetIdentityMapping();
+  return transformed_attribute;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_transform.h b/Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_transform.h
new file mode 100644
index 000000000..62aad60db
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_transform.h
@@ -0,0 +1,76 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ATTRIBUTES_ATTRIBUTE_TRANSFORM_H_
+#define DRACO_ATTRIBUTES_ATTRIBUTE_TRANSFORM_H_
+
+#include "draco/attributes/attribute_transform_data.h"
+#include "draco/attributes/point_attribute.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// Virtual base class for various attribute transforms, enforcing common
+// interface where possible.
+class AttributeTransform {
+ public:
+  virtual ~AttributeTransform() = default;
+
+  // Return attribute transform type.
+  virtual AttributeTransformType Type() const = 0;
+  // Try to init transform from attribute.
+  virtual bool InitFromAttribute(const PointAttribute &attribute) = 0;
+  // Copy parameter values into the provided AttributeTransformData instance.
+  virtual void CopyToAttributeTransformData(
+      AttributeTransformData *out_data) const = 0;
+  bool TransferToAttribute(PointAttribute *attribute) const;
+
+  // Applies the transform to |attribute| and stores the result in
+  // |target_attribute|. |point_ids| is an optional vector that can be used to
+  // remap values during the transform.
+  virtual bool TransformAttribute(const PointAttribute &attribute,
+                                  const std::vector<PointIndex> &point_ids,
+                                  PointAttribute *target_attribute) = 0;
+
+  // Applies an inverse transform to |attribute| and stores the result in
+  // |target_attribute|. In this case, |attribute| is an attribute that was
+  // already transformed (e.g. quantized) and |target_attribute| is the
+  // attribute before the transformation.
+  virtual bool InverseTransformAttribute(const PointAttribute &attribute,
+                                         PointAttribute *target_attribute) = 0;
+
+  // Encodes all data needed by the transformation into the |encoder_buffer|.
+  virtual bool EncodeParameters(EncoderBuffer *encoder_buffer) const = 0;
+
+  // Decodes all data needed to transform |attribute| back to the original
+  // format.
+  virtual bool DecodeParameters(const PointAttribute &attribute,
+                                DecoderBuffer *decoder_buffer) = 0;
+
+  // Initializes a transformed attribute that can be used as target in the
+  // TransformAttribute() function call.
+  virtual std::unique_ptr<PointAttribute> InitTransformedAttribute(
+      const PointAttribute &src_attribute, int num_entries);
+
+ protected:
+  virtual DataType GetTransformedDataType(
+      const PointAttribute &attribute) const = 0;
+  virtual int GetTransformedNumComponents(
+      const PointAttribute &attribute) const = 0;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_ATTRIBUTES_ATTRIBUTE_OCTAHEDRON_TRANSFORM_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_transform_data.h b/Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_transform_data.h
new file mode 100644
index 000000000..96ed07320
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_transform_data.h
@@ -0,0 +1,71 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ATTRIBUTES_ATTRIBUTE_TRANSFORM_DATA_H_
+#define DRACO_ATTRIBUTES_ATTRIBUTE_TRANSFORM_DATA_H_
+
+#include <memory>
+
+#include "draco/attributes/attribute_transform_type.h"
+#include "draco/core/data_buffer.h"
+
+namespace draco {
+
+// Class for holding parameter values for an attribute transform of a
+// PointAttribute. This can be for example quantization data for an attribute
+// that holds quantized values. This class provides only a basic storage for
+// attribute transform parameters and it should be accessed only through wrapper
+// classes for a specific transform (e.g. AttributeQuantizationTransform).
+class AttributeTransformData {
+ public:
+  AttributeTransformData() : transform_type_(ATTRIBUTE_INVALID_TRANSFORM) {}
+  AttributeTransformData(const AttributeTransformData &data) = default;
+
+  // Returns the type of the attribute transform that is described by the class.
+  AttributeTransformType transform_type() const { return transform_type_; }
+  void set_transform_type(AttributeTransformType type) {
+    transform_type_ = type;
+  }
+
+  // Returns a parameter value on a given |byte_offset|.
+  template <typename DataTypeT>
+  DataTypeT GetParameterValue(int byte_offset) const {
+    DataTypeT out_data;
+    buffer_.Read(byte_offset, &out_data, sizeof(DataTypeT));
+    return out_data;
+  }
+
+  // Sets a parameter value on a given |byte_offset|.
+  template <typename DataTypeT>
+  void SetParameterValue(int byte_offset, const DataTypeT &in_data) {
+    if (byte_offset + sizeof(DataTypeT) > buffer_.data_size()) {
+      buffer_.Resize(byte_offset + sizeof(DataTypeT));
+    }
+    buffer_.Write(byte_offset, &in_data, sizeof(DataTypeT));
+  }
+
+  // Sets a parameter value at the end of the |buffer_|.
+  template <typename DataTypeT>
+  void AppendParameterValue(const DataTypeT &in_data) {
+    SetParameterValue(static_cast<int>(buffer_.data_size()), in_data);
+  }
+
+ private:
+  AttributeTransformType transform_type_;
+  DataBuffer buffer_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_ATTRIBUTES_ATTRIBUTE_TRANSFORM_DATA_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_transform_type.h b/Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_transform_type.h
new file mode 100644
index 000000000..51ce6f333
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/attributes/attribute_transform_type.h
@@ -0,0 +1,30 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ATTRIBUTES_ATTRIBUTE_TRANSFORM_TYPE_H_
+#define DRACO_ATTRIBUTES_ATTRIBUTE_TRANSFORM_TYPE_H_
+
+namespace draco {
+
+// List of all currently supported attribute transforms.
+enum AttributeTransformType {
+  ATTRIBUTE_INVALID_TRANSFORM = -1,
+  ATTRIBUTE_NO_TRANSFORM = 0,
+  ATTRIBUTE_QUANTIZATION_TRANSFORM = 1,
+  ATTRIBUTE_OCTAHEDRON_TRANSFORM = 2,
+};
+
+}  // namespace draco
+
+#endif  // DRACO_ATTRIBUTES_ATTRIBUTE_TRANSFORM_TYPE_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/attributes/geometry_attribute.cc b/Engine/lib/assimp/contrib/draco/src/draco/attributes/geometry_attribute.cc
new file mode 100644
index 000000000..b62478426
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/attributes/geometry_attribute.cc
@@ -0,0 +1,102 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/attributes/geometry_attribute.h"
+
+namespace draco {
+
+GeometryAttribute::GeometryAttribute()
+    : buffer_(nullptr),
+      num_components_(1),
+      data_type_(DT_FLOAT32),
+      byte_stride_(0),
+      byte_offset_(0),
+      attribute_type_(INVALID),
+      unique_id_(0) {}
+
+void GeometryAttribute::Init(GeometryAttribute::Type attribute_type,
+                             DataBuffer *buffer, int8_t num_components,
+                             DataType data_type, bool normalized,
+                             int64_t byte_stride, int64_t byte_offset) {
+  buffer_ = buffer;
+  if (buffer) {
+    buffer_descriptor_.buffer_id = buffer->buffer_id();
+    buffer_descriptor_.buffer_update_count = buffer->update_count();
+  }
+  num_components_ = num_components;
+  data_type_ = data_type;
+  normalized_ = normalized;
+  byte_stride_ = byte_stride;
+  byte_offset_ = byte_offset;
+  attribute_type_ = attribute_type;
+}
+
+bool GeometryAttribute::CopyFrom(const GeometryAttribute &src_att) {
+  num_components_ = src_att.num_components_;
+  data_type_ = src_att.data_type_;
+  normalized_ = src_att.normalized_;
+  byte_stride_ = src_att.byte_stride_;
+  byte_offset_ = src_att.byte_offset_;
+  attribute_type_ = src_att.attribute_type_;
+  buffer_descriptor_ = src_att.buffer_descriptor_;
+  unique_id_ = src_att.unique_id_;
+  if (src_att.buffer_ == nullptr) {
+    buffer_ = nullptr;
+  } else {
+    if (buffer_ == nullptr) {
+      return false;
+    }
+    buffer_->Update(src_att.buffer_->data(), src_att.buffer_->data_size());
+  }
+  return true;
+}
+
+bool GeometryAttribute::operator==(const GeometryAttribute &va) const {
+  if (attribute_type_ != va.attribute_type_) {
+    return false;
+  }
+  // It's OK to compare just the buffer descriptors here. We don't need to
+  // compare the buffers themselves.
+  if (buffer_descriptor_.buffer_id != va.buffer_descriptor_.buffer_id) {
+    return false;
+  }
+  if (buffer_descriptor_.buffer_update_count !=
+      va.buffer_descriptor_.buffer_update_count) {
+    return false;
+  }
+  if (num_components_ != va.num_components_) {
+    return false;
+  }
+  if (data_type_ != va.data_type_) {
+    return false;
+  }
+  if (byte_stride_ != va.byte_stride_) {
+    return false;
+  }
+  if (byte_offset_ != va.byte_offset_) {
+    return false;
+  }
+  return true;
+}
+
+void GeometryAttribute::ResetBuffer(DataBuffer *buffer, int64_t byte_stride,
+                                    int64_t byte_offset) {
+  buffer_ = buffer;
+  buffer_descriptor_.buffer_id = buffer->buffer_id();
+  buffer_descriptor_.buffer_update_count = buffer->update_count();
+  byte_stride_ = byte_stride;
+  byte_offset_ = byte_offset;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/attributes/geometry_attribute.h b/Engine/lib/assimp/contrib/draco/src/draco/attributes/geometry_attribute.h
new file mode 100644
index 000000000..f4d099b1b
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/attributes/geometry_attribute.h
@@ -0,0 +1,350 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ATTRIBUTES_GEOMETRY_ATTRIBUTE_H_
+#define DRACO_ATTRIBUTES_GEOMETRY_ATTRIBUTE_H_
+
+#include <array>
+#include <limits>
+
+#include "draco/attributes/geometry_indices.h"
+#include "draco/core/data_buffer.h"
+#include "draco/core/hash_utils.h"
+
+namespace draco {
+
+// The class provides access to a specific attribute which is stored in a
+// DataBuffer, such as normals or coordinates. However, the GeometryAttribute
+// class does not own the buffer and the buffer itself may store other data
+// unrelated to this attribute (such as data for other attributes in which case
+// we can have multiple GeometryAttributes accessing one buffer). Typically,
+// all attributes for a point (or corner, face) are stored in one block, which
+// is advantageous in terms of memory access. The length of the entire block is
+// given by the byte_stride, the position where the attribute starts is given by
+// the byte_offset, the actual number of bytes that the attribute occupies is
+// given by the data_type and the number of components.
+class GeometryAttribute {
+ public:
+  // Supported attribute types.
+  enum Type {
+    INVALID = -1,
+    // Named attributes start here. The difference between named and generic
+    // attributes is that for named attributes we know their purpose and we
+    // can apply some special methods when dealing with them (e.g. during
+    // encoding).
+    POSITION = 0,
+    NORMAL,
+    COLOR,
+    TEX_COORD,
+    // A special id used to mark attributes that are not assigned to any known
+    // predefined use case. Such attributes are often used for a shader specific
+    // data.
+    GENERIC,
+    // Total number of different attribute types.
+    // Always keep behind all named attributes.
+    NAMED_ATTRIBUTES_COUNT,
+  };
+
+  GeometryAttribute();
+  // Initializes and enables the attribute.
+  void Init(Type attribute_type, DataBuffer *buffer, int8_t num_components,
+            DataType data_type, bool normalized, int64_t byte_stride,
+            int64_t byte_offset);
+  bool IsValid() const { return buffer_ != nullptr; }
+
+  // Copies data from the source attribute to the this attribute.
+  // This attribute must have a valid buffer allocated otherwise the operation
+  // is going to fail and return false.
+  bool CopyFrom(const GeometryAttribute &src_att);
+
+  // Function for getting a attribute value with a specific format.
+  // Unsafe. Caller must ensure the accessed memory is valid.
+  // T is the attribute data type.
+  // att_components_t is the number of attribute components.
+  template <typename T, int att_components_t>
+  std::array<T, att_components_t> GetValue(
+      AttributeValueIndex att_index) const {
+    // Byte address of the attribute index.
+    const int64_t byte_pos = byte_offset_ + byte_stride_ * att_index.value();
+    std::array<T, att_components_t> out;
+    buffer_->Read(byte_pos, &(out[0]), sizeof(out));
+    return out;
+  }
+
+  // Function for getting a attribute value with a specific format.
+  // T is the attribute data type.
+  // att_components_t is the number of attribute components.
+  template <typename T, int att_components_t>
+  bool GetValue(AttributeValueIndex att_index,
+                std::array<T, att_components_t> *out) const {
+    // Byte address of the attribute index.
+    const int64_t byte_pos = byte_offset_ + byte_stride_ * att_index.value();
+    // Check we are not reading past end of data.
+    if (byte_pos + sizeof(*out) > buffer_->data_size()) {
+      return false;
+    }
+    buffer_->Read(byte_pos, &((*out)[0]), sizeof(*out));
+    return true;
+  }
+
+  // Returns the byte position of the attribute entry in the data buffer.
+  inline int64_t GetBytePos(AttributeValueIndex att_index) const {
+    return byte_offset_ + byte_stride_ * att_index.value();
+  }
+
+  inline const uint8_t *GetAddress(AttributeValueIndex att_index) const {
+    const int64_t byte_pos = GetBytePos(att_index);
+    return buffer_->data() + byte_pos;
+  }
+  inline uint8_t *GetAddress(AttributeValueIndex att_index) {
+    const int64_t byte_pos = GetBytePos(att_index);
+    return buffer_->data() + byte_pos;
+  }
+  inline bool IsAddressValid(const uint8_t *address) const {
+    return ((buffer_->data() + buffer_->data_size()) > address);
+  }
+
+  // Fills out_data with the raw value of the requested attribute entry.
+  // out_data must be at least byte_stride_ long.
+  void GetValue(AttributeValueIndex att_index, void *out_data) const {
+    const int64_t byte_pos = byte_offset_ + byte_stride_ * att_index.value();
+    buffer_->Read(byte_pos, out_data, byte_stride_);
+  }
+
+  // Sets a value of an attribute entry. The input value must be allocated to
+  // cover all components of a single attribute entry.
+  void SetAttributeValue(AttributeValueIndex entry_index, const void *value) {
+    const int64_t byte_pos = entry_index.value() * byte_stride();
+    buffer_->Write(byte_pos, value, byte_stride());
+  }
+
+  // DEPRECATED: Use
+  //   ConvertValue(AttributeValueIndex att_id,
+  //               int out_num_components,
+  //               OutT *out_val);
+  //
+  // Function for conversion of a attribute to a specific output format.
+  // OutT is the desired data type of the attribute.
+  // out_att_components_t is the number of components of the output format.
+  // Returns false when the conversion failed.
+  template <typename OutT, int out_att_components_t>
+  bool ConvertValue(AttributeValueIndex att_id, OutT *out_val) const {
+    return ConvertValue(att_id, out_att_components_t, out_val);
+  }
+
+  // Function for conversion of a attribute to a specific output format.
+  // |out_val| needs to be able to store |out_num_components| values.
+  // OutT is the desired data type of the attribute.
+  // Returns false when the conversion failed.
+  template <typename OutT>
+  bool ConvertValue(AttributeValueIndex att_id, int8_t out_num_components,
+                    OutT *out_val) const {
+    if (out_val == nullptr) {
+      return false;
+    }
+    switch (data_type_) {
+      case DT_INT8:
+        return ConvertTypedValue<int8_t, OutT>(att_id, out_num_components,
+                                               out_val);
+      case DT_UINT8:
+        return ConvertTypedValue<uint8_t, OutT>(att_id, out_num_components,
+                                                out_val);
+      case DT_INT16:
+        return ConvertTypedValue<int16_t, OutT>(att_id, out_num_components,
+                                                out_val);
+      case DT_UINT16:
+        return ConvertTypedValue<uint16_t, OutT>(att_id, out_num_components,
+                                                 out_val);
+      case DT_INT32:
+        return ConvertTypedValue<int32_t, OutT>(att_id, out_num_components,
+                                                out_val);
+      case DT_UINT32:
+        return ConvertTypedValue<uint32_t, OutT>(att_id, out_num_components,
+                                                 out_val);
+      case DT_INT64:
+        return ConvertTypedValue<int64_t, OutT>(att_id, out_num_components,
+                                                out_val);
+      case DT_UINT64:
+        return ConvertTypedValue<uint64_t, OutT>(att_id, out_num_components,
+                                                 out_val);
+      case DT_FLOAT32:
+        return ConvertTypedValue<float, OutT>(att_id, out_num_components,
+                                              out_val);
+      case DT_FLOAT64:
+        return ConvertTypedValue<double, OutT>(att_id, out_num_components,
+                                               out_val);
+      case DT_BOOL:
+        return ConvertTypedValue<bool, OutT>(att_id, out_num_components,
+                                             out_val);
+      default:
+        // Wrong attribute type.
+        return false;
+    }
+  }
+
+  // Function for conversion of a attribute to a specific output format.
+  // The |out_value| must be able to store all components of a single attribute
+  // entry.
+  // OutT is the desired data type of the attribute.
+  // Returns false when the conversion failed.
+  template <typename OutT>
+  bool ConvertValue(AttributeValueIndex att_index, OutT *out_value) const {
+    return ConvertValue<OutT>(att_index, num_components_, out_value);
+  }
+
+  // Utility function. Returns |attribute_type| as std::string.
+  static std::string TypeToString(Type attribute_type) {
+    switch (attribute_type) {
+      case INVALID:
+        return "INVALID";
+      case POSITION:
+        return "POSITION";
+      case NORMAL:
+        return "NORMAL";
+      case COLOR:
+        return "COLOR";
+      case TEX_COORD:
+        return "TEX_COORD";
+      case GENERIC:
+        return "GENERIC";
+      default:
+        return "UNKNOWN";
+    }
+  }
+
+  bool operator==(const GeometryAttribute &va) const;
+
+  // Returns the type of the attribute indicating the nature of the attribute.
+  Type attribute_type() const { return attribute_type_; }
+  void set_attribute_type(Type type) { attribute_type_ = type; }
+  // Returns the data type that is stored in the attribute.
+  DataType data_type() const { return data_type_; }
+  // Returns the number of components that are stored for each entry.
+  // For position attribute this is usually three (x,y,z),
+  // while texture coordinates have two components (u,v).
+  int8_t num_components() const { return num_components_; }
+  // Indicates whether the data type should be normalized before interpretation,
+  // that is, it should be divided by the max value of the data type.
+  bool normalized() const { return normalized_; }
+  // The buffer storing the entire data of the attribute.
+  const DataBuffer *buffer() const { return buffer_; }
+  // Returns the number of bytes between two attribute entries, this is, at
+  // least size of the data types times number of components.
+  int64_t byte_stride() const { return byte_stride_; }
+  // The offset where the attribute starts within the block of size byte_stride.
+  int64_t byte_offset() const { return byte_offset_; }
+  void set_byte_offset(int64_t byte_offset) { byte_offset_ = byte_offset; }
+  DataBufferDescriptor buffer_descriptor() const { return buffer_descriptor_; }
+  uint32_t unique_id() const { return unique_id_; }
+  void set_unique_id(uint32_t id) { unique_id_ = id; }
+
+ protected:
+  // Sets a new internal storage for the attribute.
+  void ResetBuffer(DataBuffer *buffer, int64_t byte_stride,
+                   int64_t byte_offset);
+
+ private:
+  // Function for conversion of an attribute to a specific output format given a
+  // format of the stored attribute.
+  // T is the stored attribute data type.
+  // OutT is the desired data type of the attribute.
+  template <typename T, typename OutT>
+  bool ConvertTypedValue(AttributeValueIndex att_id, int8_t out_num_components,
+                         OutT *out_value) const {
+    const uint8_t *src_address = GetAddress(att_id);
+
+    // Convert all components available in both the original and output formats.
+    for (int i = 0; i < std::min(num_components_, out_num_components); ++i) {
+      if (!IsAddressValid(src_address)) {
+        return false;
+      }
+      const T in_value = *reinterpret_cast<const T *>(src_address);
+
+      // Make sure the in_value fits within the range of values that OutT
+      // is able to represent. Perform the check only for integral types.
+      if (std::is_integral<T>::value && std::is_integral<OutT>::value) {
+        static constexpr OutT kOutMin =
+            std::is_signed<T>::value ? std::numeric_limits<OutT>::lowest() : 0;
+        if (in_value < kOutMin || in_value > std::numeric_limits<OutT>::max()) {
+          return false;
+        }
+      }
+
+      out_value[i] = static_cast<OutT>(in_value);
+      // When converting integer to floating point, normalize the value if
+      // necessary.
+      if (std::is_integral<T>::value && std::is_floating_point<OutT>::value &&
+          normalized_) {
+        out_value[i] /= static_cast<OutT>(std::numeric_limits<T>::max());
+      }
+      // TODO(ostava): Add handling of normalized attributes when converting
+      // between different integer representations. If the attribute is
+      // normalized, integer values should be converted as if they represent 0-1
+      // range. E.g. when we convert uint16 to uint8, the range <0, 2^16 - 1>
+      // should be converted to range <0, 2^8 - 1>.
+      src_address += sizeof(T);
+    }
+    // Fill empty data for unused output components if needed.
+    for (int i = num_components_; i < out_num_components; ++i) {
+      out_value[i] = static_cast<OutT>(0);
+    }
+    return true;
+  }
+
+  DataBuffer *buffer_;
+  // The buffer descriptor is stored at the time the buffer is attached to this
+  // attribute. The purpose is to detect if any changes happened to the buffer
+  // since the time it was attached.
+  DataBufferDescriptor buffer_descriptor_;
+  int8_t num_components_;
+  DataType data_type_;
+  bool normalized_;
+  int64_t byte_stride_;
+  int64_t byte_offset_;
+
+  Type attribute_type_;
+
+  // Unique id of this attribute. No two attributes could have the same unique
+  // id. It is used to identify each attribute, especially when there are
+  // multiple attribute of the same type in a point cloud.
+  uint32_t unique_id_;
+
+  friend struct GeometryAttributeHasher;
+};
+
+// Hashing support
+
+// Function object for using Attribute as a hash key.
+struct GeometryAttributeHasher {
+  size_t operator()(const GeometryAttribute &va) const {
+    size_t hash = HashCombine(va.buffer_descriptor_.buffer_id,
+                              va.buffer_descriptor_.buffer_update_count);
+    hash = HashCombine(va.num_components_, hash);
+    hash = HashCombine(static_cast<int8_t>(va.data_type_), hash);
+    hash = HashCombine(static_cast<int8_t>(va.attribute_type_), hash);
+    hash = HashCombine(va.byte_stride_, hash);
+    return HashCombine(va.byte_offset_, hash);
+  }
+};
+
+// Function object for using GeometryAttribute::Type as a hash key.
+struct GeometryAttributeTypeHasher {
+  size_t operator()(const GeometryAttribute::Type &at) const {
+    return static_cast<size_t>(at);
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_ATTRIBUTES_GEOMETRY_ATTRIBUTE_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/attributes/geometry_indices.h b/Engine/lib/assimp/contrib/draco/src/draco/attributes/geometry_indices.h
new file mode 100644
index 000000000..80e43e30a
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/attributes/geometry_indices.h
@@ -0,0 +1,54 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ATTRIBUTES_GEOMETRY_INDICES_H_
+#define DRACO_ATTRIBUTES_GEOMETRY_INDICES_H_
+
+#include <inttypes.h>
+
+#include <limits>
+
+#include "draco/core/draco_index_type.h"
+
+namespace draco {
+
+// Index of an attribute value entry stored in a GeometryAttribute.
+DEFINE_NEW_DRACO_INDEX_TYPE(uint32_t, AttributeValueIndex)
+// Index of a point in a PointCloud.
+DEFINE_NEW_DRACO_INDEX_TYPE(uint32_t, PointIndex)
+// Vertex index in a Mesh or CornerTable.
+DEFINE_NEW_DRACO_INDEX_TYPE(uint32_t, VertexIndex)
+// Corner index that identifies a corner in a Mesh or CornerTable.
+DEFINE_NEW_DRACO_INDEX_TYPE(uint32_t, CornerIndex)
+// Face index for Mesh and CornerTable.
+DEFINE_NEW_DRACO_INDEX_TYPE(uint32_t, FaceIndex)
+
+// Constants denoting invalid indices.
+static constexpr AttributeValueIndex kInvalidAttributeValueIndex(
+    std::numeric_limits<uint32_t>::max());
+static constexpr PointIndex kInvalidPointIndex(
+    std::numeric_limits<uint32_t>::max());
+static constexpr VertexIndex kInvalidVertexIndex(
+    std::numeric_limits<uint32_t>::max());
+static constexpr CornerIndex kInvalidCornerIndex(
+    std::numeric_limits<uint32_t>::max());
+static constexpr FaceIndex kInvalidFaceIndex(
+    std::numeric_limits<uint32_t>::max());
+
+// TODO(ostava): Add strongly typed indices for attribute id and unique
+// attribute id.
+
+}  // namespace draco
+
+#endif  // DRACO_ATTRIBUTES_GEOMETRY_INDICES_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/attributes/point_attribute.cc b/Engine/lib/assimp/contrib/draco/src/draco/attributes/point_attribute.cc
new file mode 100644
index 000000000..b28f860c1
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/attributes/point_attribute.cc
@@ -0,0 +1,225 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/attributes/point_attribute.h"
+
+#include <unordered_map>
+
+using std::unordered_map;
+
+// Shortcut for typed conditionals.
+template <bool B, class T, class F>
+using conditional_t = typename std::conditional<B, T, F>::type;
+
+namespace draco {
+
+PointAttribute::PointAttribute()
+    : num_unique_entries_(0), identity_mapping_(false) {}
+
+PointAttribute::PointAttribute(const GeometryAttribute &att)
+    : GeometryAttribute(att),
+      num_unique_entries_(0),
+      identity_mapping_(false) {}
+
+void PointAttribute::Init(Type attribute_type, int8_t num_components,
+                          DataType data_type, bool normalized,
+                          size_t num_attribute_values) {
+  attribute_buffer_ = std::unique_ptr<DataBuffer>(new DataBuffer());
+  GeometryAttribute::Init(attribute_type, attribute_buffer_.get(),
+                          num_components, data_type, normalized,
+                          DataTypeLength(data_type) * num_components, 0);
+  Reset(num_attribute_values);
+  SetIdentityMapping();
+}
+
+void PointAttribute::CopyFrom(const PointAttribute &src_att) {
+  if (buffer() == nullptr) {
+    // If the destination attribute doesn't have a valid buffer, create it.
+    attribute_buffer_ = std::unique_ptr<DataBuffer>(new DataBuffer());
+    ResetBuffer(attribute_buffer_.get(), 0, 0);
+  }
+  if (!GeometryAttribute::CopyFrom(src_att)) {
+    return;
+  }
+  identity_mapping_ = src_att.identity_mapping_;
+  num_unique_entries_ = src_att.num_unique_entries_;
+  indices_map_ = src_att.indices_map_;
+  if (src_att.attribute_transform_data_) {
+    attribute_transform_data_ = std::unique_ptr<AttributeTransformData>(
+        new AttributeTransformData(*src_att.attribute_transform_data_));
+  } else {
+    attribute_transform_data_ = nullptr;
+  }
+}
+
+bool PointAttribute::Reset(size_t num_attribute_values) {
+  if (attribute_buffer_ == nullptr) {
+    attribute_buffer_ = std::unique_ptr<DataBuffer>(new DataBuffer());
+  }
+  const int64_t entry_size = DataTypeLength(data_type()) * num_components();
+  if (!attribute_buffer_->Update(nullptr, num_attribute_values * entry_size)) {
+    return false;
+  }
+  // Assign the new buffer to the parent attribute.
+  ResetBuffer(attribute_buffer_.get(), entry_size, 0);
+  num_unique_entries_ = static_cast<uint32_t>(num_attribute_values);
+  return true;
+}
+
+void PointAttribute::Resize(size_t new_num_unique_entries) {
+  num_unique_entries_ = static_cast<uint32_t>(new_num_unique_entries);
+  attribute_buffer_->Resize(new_num_unique_entries * byte_stride());
+}
+
+#ifdef DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED
+AttributeValueIndex::ValueType PointAttribute::DeduplicateValues(
+    const GeometryAttribute &in_att) {
+  return DeduplicateValues(in_att, AttributeValueIndex(0));
+}
+
+AttributeValueIndex::ValueType PointAttribute::DeduplicateValues(
+    const GeometryAttribute &in_att, AttributeValueIndex in_att_offset) {
+  AttributeValueIndex::ValueType unique_vals = 0;
+  switch (in_att.data_type()) {
+    // Currently we support only float, uint8, and uint16 arguments.
+    case DT_FLOAT32:
+      unique_vals = DeduplicateTypedValues<float>(in_att, in_att_offset);
+      break;
+    case DT_INT8:
+      unique_vals = DeduplicateTypedValues<int8_t>(in_att, in_att_offset);
+      break;
+    case DT_UINT8:
+    case DT_BOOL:
+      unique_vals = DeduplicateTypedValues<uint8_t>(in_att, in_att_offset);
+      break;
+    case DT_UINT16:
+      unique_vals = DeduplicateTypedValues<uint16_t>(in_att, in_att_offset);
+      break;
+    case DT_INT16:
+      unique_vals = DeduplicateTypedValues<int16_t>(in_att, in_att_offset);
+      break;
+    case DT_UINT32:
+      unique_vals = DeduplicateTypedValues<uint32_t>(in_att, in_att_offset);
+      break;
+    case DT_INT32:
+      unique_vals = DeduplicateTypedValues<int32_t>(in_att, in_att_offset);
+      break;
+    default:
+      return -1;  // Unsupported data type.
+  }
+  if (unique_vals == 0) {
+    return -1;  // Unexpected error.
+  }
+  return unique_vals;
+}
+
+// Helper function for calling UnifyDuplicateAttributes<T,num_components_t>
+// with the correct template arguments.
+// Returns the number of unique attribute values.
+template <typename T>
+AttributeValueIndex::ValueType PointAttribute::DeduplicateTypedValues(
+    const GeometryAttribute &in_att, AttributeValueIndex in_att_offset) {
+  // Select the correct method to call based on the number of attribute
+  // components.
+  switch (in_att.num_components()) {
+    case 1:
+      return DeduplicateFormattedValues<T, 1>(in_att, in_att_offset);
+    case 2:
+      return DeduplicateFormattedValues<T, 2>(in_att, in_att_offset);
+    case 3:
+      return DeduplicateFormattedValues<T, 3>(in_att, in_att_offset);
+    case 4:
+      return DeduplicateFormattedValues<T, 4>(in_att, in_att_offset);
+    default:
+      return 0;
+  }
+}
+
+template <typename T, int num_components_t>
+AttributeValueIndex::ValueType PointAttribute::DeduplicateFormattedValues(
+    const GeometryAttribute &in_att, AttributeValueIndex in_att_offset) {
+  // We want to detect duplicates using a hash map but we cannot hash floating
+  // point numbers directly so bit-copy floats to the same sized integers and
+  // hash them.
+
+  // First we need to determine which int type to use (1, 2, 4 or 8 bytes).
+  // Note, this is done at compile time using std::conditional struct.
+  // Conditional is in form <bool-expression, true, false>. If bool-expression
+  // is true the "true" branch is used and vice versa. All at compile time.
+  typedef conditional_t<sizeof(T) == 1, uint8_t,
+                        conditional_t<sizeof(T) == 2, uint16_t,
+                                      conditional_t<sizeof(T) == 4, uint32_t,
+                                                    /*else*/ uint64_t>>>
+      HashType;
+
+  AttributeValueIndex unique_vals(0);
+  typedef std::array<T, num_components_t> AttributeValue;
+  typedef std::array<HashType, num_components_t> AttributeHashableValue;
+  // Hash map storing index of the first attribute with a given value.
+  unordered_map<AttributeHashableValue, AttributeValueIndex,
+                HashArray<AttributeHashableValue>>
+      value_to_index_map;
+  AttributeValue att_value;
+  AttributeHashableValue hashable_value;
+  IndexTypeVector<AttributeValueIndex, AttributeValueIndex> value_map(
+      num_unique_entries_);
+  for (AttributeValueIndex i(0); i < num_unique_entries_; ++i) {
+    const AttributeValueIndex att_pos = i + in_att_offset;
+    att_value = in_att.GetValue<T, num_components_t>(att_pos);
+    // Convert the value to hashable type. Bit-copy real attributes to integers.
+    memcpy(&(hashable_value[0]), &(att_value[0]), sizeof(att_value));
+
+    // Check if the given attribute value has been used before already.
+    auto it = value_to_index_map.find(hashable_value);
+    if (it != value_to_index_map.end()) {
+      // Duplicated value found. Update index mapping.
+      value_map[i] = it->second;
+    } else {
+      // New unique value.
+      // Update the hash map with a new entry pointing to the latest unique
+      // vertex index.
+      value_to_index_map.insert(
+          std::pair<AttributeHashableValue, AttributeValueIndex>(hashable_value,
+                                                                 unique_vals));
+      // Add the unique value to the mesh builder.
+      SetAttributeValue(unique_vals, &att_value);
+      // Update index mapping.
+      value_map[i] = unique_vals;
+
+      ++unique_vals;
+    }
+  }
+  if (unique_vals == num_unique_entries_) {
+    return unique_vals.value();  // Nothing has changed.
+  }
+  if (is_mapping_identity()) {
+    // Change identity mapping to the explicit one.
+    // The number of points is equal to the number of old unique values.
+    SetExplicitMapping(num_unique_entries_);
+    // Update the explicit map.
+    for (uint32_t i = 0; i < num_unique_entries_; ++i) {
+      SetPointMapEntry(PointIndex(i), value_map[AttributeValueIndex(i)]);
+    }
+  } else {
+    // Update point to value map using the mapping between old and new values.
+    for (PointIndex i(0); i < static_cast<uint32_t>(indices_map_.size()); ++i) {
+      SetPointMapEntry(i, value_map[indices_map_[i]]);
+    }
+  }
+  num_unique_entries_ = unique_vals.value();
+  return num_unique_entries_;
+}
+#endif
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/attributes/point_attribute.h b/Engine/lib/assimp/contrib/draco/src/draco/attributes/point_attribute.h
new file mode 100644
index 000000000..ee3662031
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/attributes/point_attribute.h
@@ -0,0 +1,190 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ATTRIBUTES_POINT_ATTRIBUTE_H_
+#define DRACO_ATTRIBUTES_POINT_ATTRIBUTE_H_
+
+#include <memory>
+
+#include "draco/attributes/attribute_transform_data.h"
+#include "draco/attributes/geometry_attribute.h"
+#include "draco/core/draco_index_type_vector.h"
+#include "draco/core/hash_utils.h"
+#include "draco/core/macros.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Class for storing point specific data about each attribute. In general,
+// multiple points stored in a point cloud can share the same attribute value
+// and this class provides the necessary mapping between point ids and attribute
+// value ids.
+class PointAttribute : public GeometryAttribute {
+ public:
+  PointAttribute();
+  explicit PointAttribute(const GeometryAttribute &att);
+
+  // Make sure the move constructor is defined (needed for better performance
+  // when new attributes are added to PointCloud).
+  PointAttribute(PointAttribute &&attribute) = default;
+  PointAttribute &operator=(PointAttribute &&attribute) = default;
+
+  // Initializes a point attribute. By default the attribute will be set to
+  // identity mapping between point indices and attribute values. To set custom
+  // mapping use SetExplicitMapping() function.
+  void Init(Type attribute_type, int8_t num_components, DataType data_type,
+            bool normalized, size_t num_attribute_values);
+
+  // Copies attribute data from the provided |src_att| attribute.
+  void CopyFrom(const PointAttribute &src_att);
+
+  // Prepares the attribute storage for the specified number of entries.
+  bool Reset(size_t num_attribute_values);
+
+  size_t size() const { return num_unique_entries_; }
+  AttributeValueIndex mapped_index(PointIndex point_index) const {
+    if (identity_mapping_) {
+      return AttributeValueIndex(point_index.value());
+    }
+    return indices_map_[point_index];
+  }
+  DataBuffer *buffer() const { return attribute_buffer_.get(); }
+  bool is_mapping_identity() const { return identity_mapping_; }
+  size_t indices_map_size() const {
+    if (is_mapping_identity()) {
+      return 0;
+    }
+    return indices_map_.size();
+  }
+
+  const uint8_t *GetAddressOfMappedIndex(PointIndex point_index) const {
+    return GetAddress(mapped_index(point_index));
+  }
+
+  // Sets the new number of unique attribute entries for the attribute. The
+  // function resizes the attribute storage to hold |num_attribute_values|
+  // entries.
+  // All previous entries with AttributeValueIndex < |num_attribute_values|
+  // are preserved. Caller needs to ensure that the PointAttribute is still
+  // valid after the resizing operation (that is, each point is mapped to a
+  // valid attribute value).
+  void Resize(size_t new_num_unique_entries);
+
+  // Functions for setting the type of mapping between point indices and
+  // attribute entry ids.
+  // This function sets the mapping to implicit, where point indices are equal
+  // to attribute entry indices.
+  void SetIdentityMapping() {
+    identity_mapping_ = true;
+    indices_map_.clear();
+  }
+  // This function sets the mapping to be explicitly using the indices_map_
+  // array that needs to be initialized by the caller.
+  void SetExplicitMapping(size_t num_points) {
+    identity_mapping_ = false;
+    indices_map_.resize(num_points, kInvalidAttributeValueIndex);
+  }
+
+  // Set an explicit map entry for a specific point index.
+  void SetPointMapEntry(PointIndex point_index,
+                        AttributeValueIndex entry_index) {
+    DRACO_DCHECK(!identity_mapping_);
+    indices_map_[point_index] = entry_index;
+  }
+
+  // Same as GeometryAttribute::GetValue(), but using point id as the input.
+  // Mapping to attribute value index is performed automatically.
+  void GetMappedValue(PointIndex point_index, void *out_data) const {
+    return GetValue(mapped_index(point_index), out_data);
+  }
+
+#ifdef DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED
+  // Deduplicate |in_att| values into |this| attribute. |in_att| can be equal
+  // to |this|.
+  // Returns -1 if the deduplication failed.
+  AttributeValueIndex::ValueType DeduplicateValues(
+      const GeometryAttribute &in_att);
+
+  // Same as above but the values read from |in_att| are sampled with the
+  // provided offset |in_att_offset|.
+  AttributeValueIndex::ValueType DeduplicateValues(
+      const GeometryAttribute &in_att, AttributeValueIndex in_att_offset);
+#endif
+
+  // Set attribute transform data for the attribute. The data is used to store
+  // the type and parameters of the transform that is applied on the attribute
+  // data (optional).
+  void SetAttributeTransformData(
+      std::unique_ptr<AttributeTransformData> transform_data) {
+    attribute_transform_data_ = std::move(transform_data);
+  }
+  const AttributeTransformData *GetAttributeTransformData() const {
+    return attribute_transform_data_.get();
+  }
+
+ private:
+#ifdef DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED
+  template <typename T>
+  AttributeValueIndex::ValueType DeduplicateTypedValues(
+      const GeometryAttribute &in_att, AttributeValueIndex in_att_offset);
+  template <typename T, int COMPONENTS_COUNT>
+  AttributeValueIndex::ValueType DeduplicateFormattedValues(
+      const GeometryAttribute &in_att, AttributeValueIndex in_att_offset);
+#endif
+
+  // Data storage for attribute values. GeometryAttribute itself doesn't own its
+  // buffer so we need to allocate it here.
+  std::unique_ptr<DataBuffer> attribute_buffer_;
+
+  // Mapping between point ids and attribute value ids.
+  IndexTypeVector<PointIndex, AttributeValueIndex> indices_map_;
+  AttributeValueIndex::ValueType num_unique_entries_;
+  // Flag when the mapping between point ids and attribute values is identity.
+  bool identity_mapping_;
+
+  // If an attribute contains transformed data (e.g. quantized), we can specify
+  // the attribute transform here and use it to transform the attribute back to
+  // its original format.
+  std::unique_ptr<AttributeTransformData> attribute_transform_data_;
+
+  friend struct PointAttributeHasher;
+};
+
+// Hash functor for the PointAttribute class.
+struct PointAttributeHasher {
+  size_t operator()(const PointAttribute &attribute) const {
+    GeometryAttributeHasher base_hasher;
+    size_t hash = base_hasher(attribute);
+    hash = HashCombine(attribute.identity_mapping_, hash);
+    hash = HashCombine(attribute.num_unique_entries_, hash);
+    hash = HashCombine(attribute.indices_map_.size(), hash);
+    if (!attribute.indices_map_.empty()) {
+      const uint64_t indices_hash = FingerprintString(
+          reinterpret_cast<const char *>(attribute.indices_map_.data()),
+          attribute.indices_map_.size());
+      hash = HashCombine(indices_hash, hash);
+    }
+    if (attribute.attribute_buffer_ != nullptr) {
+      const uint64_t buffer_hash = FingerprintString(
+          reinterpret_cast<const char *>(attribute.attribute_buffer_->data()),
+          attribute.attribute_buffer_->data_size());
+      hash = HashCombine(buffer_hash, hash);
+    }
+    return hash;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_ATTRIBUTES_POINT_ATTRIBUTE_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/attributes/point_attribute_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/attributes/point_attribute_test.cc
new file mode 100644
index 000000000..4ae23fb3c
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/attributes/point_attribute_test.cc
@@ -0,0 +1,128 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/attributes/point_attribute.h"
+
+#include "draco/core/draco_test_base.h"
+
+namespace {
+
+class PointAttributeTest : public ::testing::Test {
+ protected:
+  PointAttributeTest() {}
+};
+
+TEST_F(PointAttributeTest, TestCopy) {
+  // This test verifies that PointAttribute can copy data from another point
+  // attribute.
+  draco::PointAttribute pa;
+  pa.Init(draco::GeometryAttribute::POSITION, 1, draco::DT_INT32, false, 10);
+
+  for (int32_t i = 0; i < 10; ++i) {
+    pa.SetAttributeValue(draco::AttributeValueIndex(i), &i);
+  }
+
+  pa.set_unique_id(12);
+
+  draco::PointAttribute other_pa;
+  other_pa.CopyFrom(pa);
+
+  draco::PointAttributeHasher hasher;
+  ASSERT_EQ(hasher(pa), hasher(other_pa));
+  ASSERT_EQ(pa.unique_id(), other_pa.unique_id());
+
+  // The hash function does not actually compute the hash from attribute values,
+  // so ensure the data got copied correctly as well.
+  for (int32_t i = 0; i < 10; ++i) {
+    int32_t data;
+    other_pa.GetValue(draco::AttributeValueIndex(i), &data);
+    ASSERT_EQ(data, i);
+  }
+}
+
+TEST_F(PointAttributeTest, TestGetValueFloat) {
+  draco::PointAttribute pa;
+  pa.Init(draco::GeometryAttribute::POSITION, 3, draco::DT_FLOAT32, false, 5);
+  float points[3];
+  for (int32_t i = 0; i < 5; ++i) {
+    points[0] = i * 3.0;
+    points[1] = (i * 3.0) + 1.0;
+    points[2] = (i * 3.0) + 2.0;
+    pa.SetAttributeValue(draco::AttributeValueIndex(i), &points);
+  }
+
+  for (int32_t i = 0; i < 5; ++i) {
+    pa.GetValue(draco::AttributeValueIndex(i), &points);
+    ASSERT_FLOAT_EQ(points[0], i * 3.0);
+    ASSERT_FLOAT_EQ(points[1], (i * 3.0) + 1.0);
+    ASSERT_FLOAT_EQ(points[2], (i * 3.0) + 2.0);
+  }
+}
+
+TEST_F(PointAttributeTest, TestGetArray) {
+  draco::PointAttribute pa;
+  pa.Init(draco::GeometryAttribute::POSITION, 3, draco::DT_FLOAT32, false, 5);
+  float points[3];
+  for (int32_t i = 0; i < 5; ++i) {
+    points[0] = i * 3.0;
+    points[1] = (i * 3.0) + 1.0;
+    points[2] = (i * 3.0) + 2.0;
+    pa.SetAttributeValue(draco::AttributeValueIndex(i), &points);
+  }
+
+  for (int32_t i = 0; i < 5; ++i) {
+    std::array<float, 3> att_value;
+    att_value = pa.GetValue<float, 3>(draco::AttributeValueIndex(i));
+    ASSERT_FLOAT_EQ(att_value[0], i * 3.0);
+    ASSERT_FLOAT_EQ(att_value[1], (i * 3.0) + 1.0);
+    ASSERT_FLOAT_EQ(att_value[2], (i * 3.0) + 2.0);
+  }
+  for (int32_t i = 0; i < 5; ++i) {
+    std::array<float, 3> att_value;
+    EXPECT_TRUE(
+        (pa.GetValue<float, 3>(draco::AttributeValueIndex(i), &att_value)));
+    ASSERT_FLOAT_EQ(att_value[0], i * 3.0);
+    ASSERT_FLOAT_EQ(att_value[1], (i * 3.0) + 1.0);
+    ASSERT_FLOAT_EQ(att_value[2], (i * 3.0) + 2.0);
+  }
+}
+
+TEST_F(PointAttributeTest, TestArrayReadError) {
+  draco::PointAttribute pa;
+  pa.Init(draco::GeometryAttribute::POSITION, 3, draco::DT_FLOAT32, false, 5);
+  float points[3];
+  for (int32_t i = 0; i < 5; ++i) {
+    points[0] = i * 3.0;
+    points[1] = (i * 3.0) + 1.0;
+    points[2] = (i * 3.0) + 2.0;
+    pa.SetAttributeValue(draco::AttributeValueIndex(i), &points);
+  }
+
+  std::array<float, 3> att_value;
+  EXPECT_FALSE(
+      (pa.GetValue<float, 3>(draco::AttributeValueIndex(5), &att_value)));
+}
+
+TEST_F(PointAttributeTest, TestResize) {
+  draco::PointAttribute pa;
+  pa.Init(draco::GeometryAttribute::POSITION, 3, draco::DT_FLOAT32, false, 5);
+  ASSERT_EQ(pa.size(), 5);
+  ASSERT_EQ(pa.buffer()->data_size(), 4 * 3 * 5);
+
+  pa.Resize(10);
+  ASSERT_EQ(pa.size(), 10);
+  ASSERT_EQ(pa.buffer()->data_size(), 4 * 3 * 10);
+}
+
+}  // namespace
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/attributes_decoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/attributes_decoder.cc
new file mode 100644
index 000000000..007dd2f43
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/attributes_decoder.cc
@@ -0,0 +1,127 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/attributes_decoder.h"
+
+#include "draco/core/varint_decoding.h"
+
+namespace draco {
+
+AttributesDecoder::AttributesDecoder()
+    : point_cloud_decoder_(nullptr), point_cloud_(nullptr) {}
+
+bool AttributesDecoder::Init(PointCloudDecoder *decoder, PointCloud *pc) {
+  point_cloud_decoder_ = decoder;
+  point_cloud_ = pc;
+  return true;
+}
+
+bool AttributesDecoder::DecodeAttributesDecoderData(DecoderBuffer *in_buffer) {
+  // Decode and create attributes.
+  uint32_t num_attributes;
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (point_cloud_decoder_->bitstream_version() <
+      DRACO_BITSTREAM_VERSION(2, 0)) {
+    if (!in_buffer->Decode(&num_attributes)) {
+      return false;
+    }
+  } else
+#endif
+  {
+    if (!DecodeVarint(&num_attributes, in_buffer)) {
+      return false;
+    }
+  }
+
+  // Check that decoded number of attributes is valid.
+  if (num_attributes == 0) {
+    return false;
+  }
+  if (num_attributes > 5 * in_buffer->remaining_size()) {
+    // The decoded number of attributes is unreasonably high, because at least
+    // five bytes of attribute descriptor data per attribute are expected.
+    return false;
+  }
+
+  // Decode attribute descriptor data.
+  point_attribute_ids_.resize(num_attributes);
+  PointCloud *pc = point_cloud_;
+  for (uint32_t i = 0; i < num_attributes; ++i) {
+    // Decode attribute descriptor data.
+    uint8_t att_type, data_type, num_components, normalized;
+    if (!in_buffer->Decode(&att_type)) {
+      return false;
+    }
+    if (!in_buffer->Decode(&data_type)) {
+      return false;
+    }
+    if (!in_buffer->Decode(&num_components)) {
+      return false;
+    }
+    if (!in_buffer->Decode(&normalized)) {
+      return false;
+    }
+    if (att_type >= GeometryAttribute::NAMED_ATTRIBUTES_COUNT) {
+      return false;
+    }
+    if (data_type == DT_INVALID || data_type >= DT_TYPES_COUNT) {
+      return false;
+    }
+
+    // Check decoded attribute descriptor data.
+    if (num_components == 0) {
+      return false;
+    }
+
+    // Add the attribute to the point cloud.
+    const DataType draco_dt = static_cast<DataType>(data_type);
+    GeometryAttribute ga;
+    ga.Init(static_cast<GeometryAttribute::Type>(att_type), nullptr,
+            num_components, draco_dt, normalized > 0,
+            DataTypeLength(draco_dt) * num_components, 0);
+    uint32_t unique_id;
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+    if (point_cloud_decoder_->bitstream_version() <
+        DRACO_BITSTREAM_VERSION(1, 3)) {
+      uint16_t custom_id;
+      if (!in_buffer->Decode(&custom_id)) {
+        return false;
+      }
+      // TODO(draco-eng): Add "custom_id" to attribute metadata.
+      unique_id = static_cast<uint32_t>(custom_id);
+      ga.set_unique_id(unique_id);
+    } else
+#endif
+    {
+      if (!DecodeVarint(&unique_id, in_buffer)) {
+        return false;
+      }
+      ga.set_unique_id(unique_id);
+    }
+    const int att_id = pc->AddAttribute(
+        std::unique_ptr<PointAttribute>(new PointAttribute(ga)));
+    pc->attribute(att_id)->set_unique_id(unique_id);
+    point_attribute_ids_[i] = att_id;
+
+    // Update the inverse map.
+    if (att_id >=
+        static_cast<int32_t>(point_attribute_to_local_id_map_.size())) {
+      point_attribute_to_local_id_map_.resize(att_id + 1, -1);
+    }
+    point_attribute_to_local_id_map_[att_id] = i;
+  }
+  return true;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/attributes_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/attributes_decoder.h
new file mode 100644
index 000000000..5b2bb2cfe
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/attributes_decoder.h
@@ -0,0 +1,97 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTES_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTES_DECODER_H_
+
+#include <vector>
+
+#include "draco/compression/attributes/attributes_decoder_interface.h"
+#include "draco/compression/point_cloud/point_cloud_decoder.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/draco_features.h"
+#include "draco/point_cloud/point_cloud.h"
+
+namespace draco {
+
+// Base class for decoding one or more attributes that were encoded with a
+// matching AttributesEncoder. It is a basic implementation of
+// AttributesDecoderInterface that provides functionality that is shared between
+// all AttributesDecoders.
+class AttributesDecoder : public AttributesDecoderInterface {
+ public:
+  AttributesDecoder();
+  virtual ~AttributesDecoder() = default;
+
+  // Called after all attribute decoders are created. It can be used to perform
+  // any custom initialization.
+  bool Init(PointCloudDecoder *decoder, PointCloud *pc) override;
+
+  // Decodes any attribute decoder specific data from the |in_buffer|.
+  bool DecodeAttributesDecoderData(DecoderBuffer *in_buffer) override;
+
+  int32_t GetAttributeId(int i) const override {
+    return point_attribute_ids_[i];
+  }
+  int32_t GetNumAttributes() const override {
+    return static_cast<int32_t>(point_attribute_ids_.size());
+  }
+  PointCloudDecoder *GetDecoder() const override {
+    return point_cloud_decoder_;
+  }
+
+  // Decodes attribute data from the source buffer.
+  bool DecodeAttributes(DecoderBuffer *in_buffer) override {
+    if (!DecodePortableAttributes(in_buffer)) {
+      return false;
+    }
+    if (!DecodeDataNeededByPortableTransforms(in_buffer)) {
+      return false;
+    }
+    if (!TransformAttributesToOriginalFormat()) {
+      return false;
+    }
+    return true;
+  }
+
+ protected:
+  int32_t GetLocalIdForPointAttribute(int32_t point_attribute_id) const {
+    const int id_map_size =
+        static_cast<int>(point_attribute_to_local_id_map_.size());
+    if (point_attribute_id >= id_map_size) {
+      return -1;
+    }
+    return point_attribute_to_local_id_map_[point_attribute_id];
+  }
+  virtual bool DecodePortableAttributes(DecoderBuffer *in_buffer) = 0;
+  virtual bool DecodeDataNeededByPortableTransforms(DecoderBuffer *in_buffer) {
+    return true;
+  }
+  virtual bool TransformAttributesToOriginalFormat() { return true; }
+
+ private:
+  // List of attribute ids that need to be decoded with this decoder.
+  std::vector<int32_t> point_attribute_ids_;
+
+  // Map between point attribute id and the local id (i.e., the inverse of the
+  // |point_attribute_ids_|.
+  std::vector<int32_t> point_attribute_to_local_id_map_;
+
+  PointCloudDecoder *point_cloud_decoder_;
+  PointCloud *point_cloud_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTES_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/attributes_decoder_interface.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/attributes_decoder_interface.h
new file mode 100644
index 000000000..8e5cf52ac
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/attributes_decoder_interface.h
@@ -0,0 +1,62 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTES_DECODER_INTERFACE_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTES_DECODER_INTERFACE_H_
+
+#include <vector>
+
+#include "draco/core/decoder_buffer.h"
+#include "draco/point_cloud/point_cloud.h"
+
+namespace draco {
+
+class PointCloudDecoder;
+
+// Interface class for decoding one or more attributes that were encoded with a
+// matching AttributesEncoder. It provides only the basic interface
+// that is used by the PointCloudDecoder. The actual decoding must be
+// implemented in derived classes using the DecodeAttributes() method.
+class AttributesDecoderInterface {
+ public:
+  AttributesDecoderInterface() = default;
+  virtual ~AttributesDecoderInterface() = default;
+
+  // Called after all attribute decoders are created. It can be used to perform
+  // any custom initialization.
+  virtual bool Init(PointCloudDecoder *decoder, PointCloud *pc) = 0;
+
+  // Decodes any attribute decoder specific data from the |in_buffer|.
+  virtual bool DecodeAttributesDecoderData(DecoderBuffer *in_buffer) = 0;
+
+  // Decode attribute data from the source buffer. Needs to be implemented by
+  // the derived classes.
+  virtual bool DecodeAttributes(DecoderBuffer *in_buffer) = 0;
+
+  virtual int32_t GetAttributeId(int i) const = 0;
+  virtual int32_t GetNumAttributes() const = 0;
+  virtual PointCloudDecoder *GetDecoder() const = 0;
+
+  // Returns an attribute containing data processed by the attribute transform.
+  // (see TransformToPortableFormat() method). This data is guaranteed to be
+  // same for encoder and decoder and it can be used by predictors.
+  virtual const PointAttribute *GetPortableAttribute(
+      int32_t /* point_attribute_id */) {
+    return nullptr;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTES_DECODER_INTERFACE_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/attributes_encoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/attributes_encoder.cc
new file mode 100644
index 000000000..797c62f30
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/attributes_encoder.cc
@@ -0,0 +1,49 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/attributes_encoder.h"
+
+#include "draco/core/varint_encoding.h"
+
+namespace draco {
+
+AttributesEncoder::AttributesEncoder()
+    : point_cloud_encoder_(nullptr), point_cloud_(nullptr) {}
+
+AttributesEncoder::AttributesEncoder(int att_id) : AttributesEncoder() {
+  AddAttributeId(att_id);
+}
+
+bool AttributesEncoder::Init(PointCloudEncoder *encoder, const PointCloud *pc) {
+  point_cloud_encoder_ = encoder;
+  point_cloud_ = pc;
+  return true;
+}
+
+bool AttributesEncoder::EncodeAttributesEncoderData(EncoderBuffer *out_buffer) {
+  // Encode data about all attributes.
+  EncodeVarint(num_attributes(), out_buffer);
+  for (uint32_t i = 0; i < num_attributes(); ++i) {
+    const int32_t att_id = point_attribute_ids_[i];
+    const PointAttribute *const pa = point_cloud_->attribute(att_id);
+    out_buffer->Encode(static_cast<uint8_t>(pa->attribute_type()));
+    out_buffer->Encode(static_cast<uint8_t>(pa->data_type()));
+    out_buffer->Encode(static_cast<uint8_t>(pa->num_components()));
+    out_buffer->Encode(static_cast<uint8_t>(pa->normalized()));
+    EncodeVarint(pa->unique_id(), out_buffer);
+  }
+  return true;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/attributes_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/attributes_encoder.h
new file mode 100644
index 000000000..9de846ae6
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/attributes_encoder.h
@@ -0,0 +1,154 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTES_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTES_ENCODER_H_
+
+#include "draco/attributes/point_attribute.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/point_cloud/point_cloud.h"
+
+namespace draco {
+
+class PointCloudEncoder;
+
+// Base class for encoding one or more attributes of a PointCloud (or other
+// geometry). This base class provides only the basic interface that is used
+// by the PointCloudEncoder.
+class AttributesEncoder {
+ public:
+  AttributesEncoder();
+  // Constructs an attribute encoder associated with a given point attribute.
+  explicit AttributesEncoder(int point_attrib_id);
+  virtual ~AttributesEncoder() = default;
+
+  // Called after all attribute encoders are created. It can be used to perform
+  // any custom initialization, including setting up attribute dependencies.
+  // Note: no data should be encoded in this function, because the decoder may
+  // process encoders in a different order from the decoder.
+  virtual bool Init(PointCloudEncoder *encoder, const PointCloud *pc);
+
+  // Encodes data needed by the target attribute decoder.
+  virtual bool EncodeAttributesEncoderData(EncoderBuffer *out_buffer);
+
+  // Returns a unique identifier of the given encoder type, that is used during
+  // decoding to construct the corresponding attribute decoder.
+  virtual uint8_t GetUniqueId() const = 0;
+
+  // Encode attribute data to the target buffer.
+  virtual bool EncodeAttributes(EncoderBuffer *out_buffer) {
+    if (!TransformAttributesToPortableFormat()) {
+      return false;
+    }
+    if (!EncodePortableAttributes(out_buffer)) {
+      return false;
+    }
+    // Encode data needed by portable transforms after the attribute is encoded.
+    // This corresponds to the order in which the data is going to be decoded by
+    // the decoder.
+    if (!EncodeDataNeededByPortableTransforms(out_buffer)) {
+      return false;
+    }
+    return true;
+  }
+
+  // Returns the number of attributes that need to be encoded before the
+  // specified attribute is encoded.
+  // Note that the attribute is specified by its point attribute id.
+  virtual int NumParentAttributes(int32_t /* point_attribute_id */) const {
+    return 0;
+  }
+
+  virtual int GetParentAttributeId(int32_t /* point_attribute_id */,
+                                   int32_t /* parent_i */) const {
+    return -1;
+  }
+
+  // Marks a given attribute as a parent of another attribute.
+  virtual bool MarkParentAttribute(int32_t /* point_attribute_id */) {
+    return false;
+  }
+
+  // Returns an attribute containing data processed by the attribute transform.
+  // (see TransformToPortableFormat() method). This data is guaranteed to be
+  // encoded losslessly and it can be safely used for predictors.
+  virtual const PointAttribute *GetPortableAttribute(
+      int32_t /* point_attribute_id */) {
+    return nullptr;
+  }
+
+  void AddAttributeId(int32_t id) {
+    point_attribute_ids_.push_back(id);
+    if (id >= static_cast<int32_t>(point_attribute_to_local_id_map_.size())) {
+      point_attribute_to_local_id_map_.resize(id + 1, -1);
+    }
+    point_attribute_to_local_id_map_[id] =
+        static_cast<int32_t>(point_attribute_ids_.size()) - 1;
+  }
+
+  // Sets new attribute point ids (replacing the existing ones).
+  void SetAttributeIds(const std::vector<int32_t> &point_attribute_ids) {
+    point_attribute_ids_.clear();
+    point_attribute_to_local_id_map_.clear();
+    for (int32_t att_id : point_attribute_ids) {
+      AddAttributeId(att_id);
+    }
+  }
+
+  int32_t GetAttributeId(int i) const { return point_attribute_ids_[i]; }
+  uint32_t num_attributes() const {
+    return static_cast<uint32_t>(point_attribute_ids_.size());
+  }
+  PointCloudEncoder *encoder() const { return point_cloud_encoder_; }
+
+ protected:
+  // Transforms the input attribute data into a form that should be losslessly
+  // encoded (transform itself can be lossy).
+  virtual bool TransformAttributesToPortableFormat() { return true; }
+
+  // Losslessly encodes data of all portable attributes.
+  // Precondition: All attributes must have been transformed into portable
+  // format at this point (see TransformAttributesToPortableFormat() method).
+  virtual bool EncodePortableAttributes(EncoderBuffer *out_buffer) = 0;
+
+  // Encodes any data needed to revert the transform to portable format for each
+  // attribute (e.g. data needed for dequantization of quantized values).
+  virtual bool EncodeDataNeededByPortableTransforms(EncoderBuffer *out_buffer) {
+    return true;
+  }
+
+  int32_t GetLocalIdForPointAttribute(int32_t point_attribute_id) const {
+    const int id_map_size =
+        static_cast<int>(point_attribute_to_local_id_map_.size());
+    if (point_attribute_id >= id_map_size) {
+      return -1;
+    }
+    return point_attribute_to_local_id_map_[point_attribute_id];
+  }
+
+ private:
+  // List of attribute ids that need to be encoded with this encoder.
+  std::vector<int32_t> point_attribute_ids_;
+
+  // Map between point attribute id and the local id (i.e., the inverse of the
+  // |point_attribute_ids_|.
+  std::vector<int32_t> point_attribute_to_local_id_map_;
+
+  PointCloudEncoder *point_cloud_encoder_;
+  const PointCloud *point_cloud_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTES_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_decoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_decoder.cc
new file mode 100644
index 000000000..e4d53485d
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_decoder.cc
@@ -0,0 +1,556 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/kd_tree_attributes_decoder.h"
+
+#include "draco/compression/attributes/kd_tree_attributes_shared.h"
+#include "draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_decoder.h"
+#include "draco/compression/point_cloud/algorithms/float_points_tree_decoder.h"
+#include "draco/compression/point_cloud/point_cloud_decoder.h"
+#include "draco/core/draco_types.h"
+#include "draco/core/varint_decoding.h"
+
+namespace draco {
+
+// attribute, offset_dimensionality, data_type, data_size, num_components
+using AttributeTuple =
+    std::tuple<PointAttribute *, uint32_t, DataType, uint32_t, uint32_t>;
+
+// Output iterator that is used to decode values directly into the data buffer
+// of the modified PointAttribute.
+// The extension of this iterator beyond the DT_UINT32 concerns itself only with
+// the size of the data for efficiency, not the type.  DataType is conveyed in
+// but is an unused field populated for any future logic/special casing.
+// DT_UINT32 and all other 4-byte types are naturally supported from the size of
+// data in the kd tree encoder.  DT_UINT16 and DT_UINT8 are supported by way
+// of byte copies into a temporary memory buffer.
+template <class CoeffT>
+class PointAttributeVectorOutputIterator {
+  typedef PointAttributeVectorOutputIterator<CoeffT> Self;
+
+ public:
+  PointAttributeVectorOutputIterator(
+      PointAttributeVectorOutputIterator &&that) = default;
+
+  explicit PointAttributeVectorOutputIterator(
+      const std::vector<AttributeTuple> &atts)
+      : attributes_(atts), point_id_(0) {
+    DRACO_DCHECK_GE(atts.size(), 1);
+    uint32_t required_decode_bytes = 0;
+    for (auto index = 0; index < attributes_.size(); index++) {
+      const AttributeTuple &att = attributes_[index];
+      required_decode_bytes = (std::max)(required_decode_bytes,
+                                         std::get<3>(att) * std::get<4>(att));
+    }
+    memory_.resize(required_decode_bytes);
+    data_ = memory_.data();
+  }
+
+  const Self &operator++() {
+    ++point_id_;
+    return *this;
+  }
+
+  // We do not want to do ANY copying of this constructor so this particular
+  // operator is disabled for performance reasons.
+  // Self operator++(int) {
+  //   Self copy = *this;
+  //   ++point_id_;
+  //   return copy;
+  // }
+
+  Self &operator*() { return *this; }
+  // Still needed in some cases.
+  // TODO(hemmer): remove.
+  // hardcoded to 3 based on legacy usage.
+  const Self &operator=(const VectorD<CoeffT, 3> &val) {
+    DRACO_DCHECK_EQ(attributes_.size(), 1);  // Expect only ONE attribute.
+    AttributeTuple &att = attributes_[0];
+    PointAttribute *attribute = std::get<0>(att);
+    const uint32_t &offset = std::get<1>(att);
+    DRACO_DCHECK_EQ(offset, 0);  // expected to be zero
+    attribute->SetAttributeValue(attribute->mapped_index(point_id_),
+                                 &val[0] + offset);
+    return *this;
+  }
+  // Additional operator taking std::vector as argument.
+  const Self &operator=(const std::vector<CoeffT> &val) {
+    for (auto index = 0; index < attributes_.size(); index++) {
+      AttributeTuple &att = attributes_[index];
+      PointAttribute *attribute = std::get<0>(att);
+      const uint32_t &offset = std::get<1>(att);
+      const uint32_t &data_size = std::get<3>(att);
+      const uint32_t &num_components = std::get<4>(att);
+      const uint32_t *data_source = val.data() + offset;
+      if (data_size < 4) {  // handle uint16_t, uint8_t
+        // selectively copy data bytes
+        uint8_t *data_counter = data_;
+        for (uint32_t index = 0; index < num_components;
+             index += 1, data_counter += data_size) {
+          std::memcpy(data_counter, data_source + index, data_size);
+        }
+        // redirect to copied data
+        data_source = reinterpret_cast<uint32_t *>(data_);
+      }
+      const AttributeValueIndex avi = attribute->mapped_index(point_id_);
+      if (avi >= static_cast<uint32_t>(attribute->size())) {
+        return *this;
+      }
+      attribute->SetAttributeValue(avi, data_source);
+    }
+    return *this;
+  }
+
+ private:
+  // preallocated memory for buffering different data sizes.  Never reallocated.
+  std::vector<uint8_t> memory_;
+  uint8_t *data_;
+  std::vector<AttributeTuple> attributes_;
+  PointIndex point_id_;
+
+  // NO COPY
+  PointAttributeVectorOutputIterator(
+      const PointAttributeVectorOutputIterator &that) = delete;
+  PointAttributeVectorOutputIterator &operator=(
+      PointAttributeVectorOutputIterator const &) = delete;
+};
+
+KdTreeAttributesDecoder::KdTreeAttributesDecoder() {}
+
+bool KdTreeAttributesDecoder::DecodePortableAttributes(
+    DecoderBuffer *in_buffer) {
+  if (in_buffer->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 3)) {
+    // Old bitstream does everything in the
+    // DecodeDataNeededByPortableTransforms() method.
+    return true;
+  }
+  uint8_t compression_level = 0;
+  if (!in_buffer->Decode(&compression_level)) {
+    return false;
+  }
+  const int32_t num_points = GetDecoder()->point_cloud()->num_points();
+
+  // Decode data using the kd tree decoding into integer (portable) attributes.
+  // We first need to go over all attributes and create a new portable storage
+  // for those attributes that need it (floating point attributes that have to
+  // be dequantized after decoding).
+
+  const int num_attributes = GetNumAttributes();
+  uint32_t total_dimensionality = 0;  // position is a required dimension
+  std::vector<AttributeTuple> atts(num_attributes);
+
+  for (int i = 0; i < GetNumAttributes(); ++i) {
+    const int att_id = GetAttributeId(i);
+    PointAttribute *const att = GetDecoder()->point_cloud()->attribute(att_id);
+    // All attributes have the same number of values and identity mapping
+    // between PointIndex and AttributeValueIndex.
+    att->Reset(num_points);
+    att->SetIdentityMapping();
+
+    PointAttribute *target_att = nullptr;
+    if (att->data_type() == DT_UINT32 || att->data_type() == DT_UINT16 ||
+        att->data_type() == DT_UINT8) {
+      // We can decode to these attributes directly.
+      target_att = att;
+    } else if (att->data_type() == DT_INT32 || att->data_type() == DT_INT16 ||
+               att->data_type() == DT_INT8) {
+      // Prepare storage for data that is used to convert unsigned values back
+      // to the signed ones.
+      for (int c = 0; c < att->num_components(); ++c) {
+        min_signed_values_.push_back(0);
+      }
+      target_att = att;
+    } else if (att->data_type() == DT_FLOAT32) {
+      // Create a portable attribute that will hold the decoded data. We will
+      // dequantize the decoded data to the final attribute later on.
+      const int num_components = att->num_components();
+      GeometryAttribute va;
+      va.Init(att->attribute_type(), nullptr, num_components, DT_UINT32, false,
+              num_components * DataTypeLength(DT_UINT32), 0);
+      std::unique_ptr<PointAttribute> port_att(new PointAttribute(va));
+      port_att->SetIdentityMapping();
+      port_att->Reset(num_points);
+      quantized_portable_attributes_.push_back(std::move(port_att));
+      target_att = quantized_portable_attributes_.back().get();
+    } else {
+      // Unsupported type.
+      return false;
+    }
+    // Add attribute to the output iterator used by the core algorithm.
+    const DataType data_type = target_att->data_type();
+    const uint32_t data_size = (std::max)(0, DataTypeLength(data_type));
+    const uint32_t num_components = target_att->num_components();
+    atts[i] = std::make_tuple(target_att, total_dimensionality, data_type,
+                              data_size, num_components);
+    total_dimensionality += num_components;
+  }
+  PointAttributeVectorOutputIterator<uint32_t> out_it(atts);
+
+  switch (compression_level) {
+    case 0: {
+      DynamicIntegerPointsKdTreeDecoder<0> decoder(total_dimensionality);
+      if (!decoder.DecodePoints(in_buffer, out_it)) {
+        return false;
+      }
+      break;
+    }
+    case 1: {
+      DynamicIntegerPointsKdTreeDecoder<1> decoder(total_dimensionality);
+      if (!decoder.DecodePoints(in_buffer, out_it)) {
+        return false;
+      }
+      break;
+    }
+    case 2: {
+      DynamicIntegerPointsKdTreeDecoder<2> decoder(total_dimensionality);
+      if (!decoder.DecodePoints(in_buffer, out_it)) {
+        return false;
+      }
+      break;
+    }
+    case 3: {
+      DynamicIntegerPointsKdTreeDecoder<3> decoder(total_dimensionality);
+      if (!decoder.DecodePoints(in_buffer, out_it)) {
+        return false;
+      }
+      break;
+    }
+    case 4: {
+      DynamicIntegerPointsKdTreeDecoder<4> decoder(total_dimensionality);
+      if (!decoder.DecodePoints(in_buffer, out_it)) {
+        return false;
+      }
+      break;
+    }
+    case 5: {
+      DynamicIntegerPointsKdTreeDecoder<5> decoder(total_dimensionality);
+      if (!decoder.DecodePoints(in_buffer, out_it)) {
+        return false;
+      }
+      break;
+    }
+    case 6: {
+      DynamicIntegerPointsKdTreeDecoder<6> decoder(total_dimensionality);
+      if (!decoder.DecodePoints(in_buffer, out_it)) {
+        return false;
+      }
+      break;
+    }
+    default:
+      return false;
+  }
+  return true;
+}
+
+bool KdTreeAttributesDecoder::DecodeDataNeededByPortableTransforms(
+    DecoderBuffer *in_buffer) {
+  if (in_buffer->bitstream_version() >= DRACO_BITSTREAM_VERSION(2, 3)) {
+    // Decode quantization data for each attribute that need it.
+    // TODO(ostava): This should be moved to AttributeQuantizationTransform.
+    std::vector<float> min_value;
+    for (int i = 0; i < GetNumAttributes(); ++i) {
+      const int att_id = GetAttributeId(i);
+      const PointAttribute *const att =
+          GetDecoder()->point_cloud()->attribute(att_id);
+      if (att->data_type() == DT_FLOAT32) {
+        const int num_components = att->num_components();
+        min_value.resize(num_components);
+        if (!in_buffer->Decode(&min_value[0], sizeof(float) * num_components)) {
+          return false;
+        }
+        float max_value_dif;
+        if (!in_buffer->Decode(&max_value_dif)) {
+          return false;
+        }
+        uint8_t quantization_bits;
+        if (!in_buffer->Decode(&quantization_bits) || quantization_bits > 31) {
+          return false;
+        }
+        AttributeQuantizationTransform transform;
+        if (!transform.SetParameters(quantization_bits, min_value.data(),
+                                     num_components, max_value_dif)) {
+          return false;
+        }
+        const int num_transforms =
+            static_cast<int>(attribute_quantization_transforms_.size());
+        if (!transform.TransferToAttribute(
+                quantized_portable_attributes_[num_transforms].get())) {
+          return false;
+        }
+        attribute_quantization_transforms_.push_back(transform);
+      }
+    }
+
+    // Decode transform data for signed integer attributes.
+    for (int i = 0; i < min_signed_values_.size(); ++i) {
+      int32_t val;
+      if (!DecodeVarint(&val, in_buffer)) {
+        return false;
+      }
+      min_signed_values_[i] = val;
+    }
+    return true;
+  }
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  // Handle old bitstream
+  // Figure out the total dimensionality of the point cloud
+  const uint32_t attribute_count = GetNumAttributes();
+  uint32_t total_dimensionality = 0;  // position is a required dimension
+  std::vector<AttributeTuple> atts(attribute_count);
+  for (auto attribute_index = 0;
+       static_cast<uint32_t>(attribute_index) < attribute_count;
+       attribute_index += 1)  // increment the dimensionality as needed...
+  {
+    const int att_id = GetAttributeId(attribute_index);
+    PointAttribute *const att = GetDecoder()->point_cloud()->attribute(att_id);
+    const DataType data_type = att->data_type();
+    const uint32_t data_size = (std::max)(0, DataTypeLength(data_type));
+    const uint32_t num_components = att->num_components();
+    if (data_size > 4) {
+      return false;
+    }
+
+    atts[attribute_index] = std::make_tuple(
+        att, total_dimensionality, data_type, data_size, num_components);
+    // everything is treated as 32bit in the encoder.
+    total_dimensionality += num_components;
+  }
+
+  const int att_id = GetAttributeId(0);
+  PointAttribute *const att = GetDecoder()->point_cloud()->attribute(att_id);
+  att->SetIdentityMapping();
+  // Decode method
+  uint8_t method;
+  if (!in_buffer->Decode(&method)) {
+    return false;
+  }
+  if (method == KdTreeAttributesEncodingMethod::kKdTreeQuantizationEncoding) {
+    uint8_t compression_level = 0;
+    if (!in_buffer->Decode(&compression_level)) {
+      return false;
+    }
+    uint32_t num_points = 0;
+    if (!in_buffer->Decode(&num_points)) {
+      return false;
+    }
+    att->Reset(num_points);
+    FloatPointsTreeDecoder decoder;
+    decoder.set_num_points_from_header(num_points);
+    PointAttributeVectorOutputIterator<float> out_it(atts);
+    if (!decoder.DecodePointCloud(in_buffer, out_it)) {
+      return false;
+    }
+  } else if (method == KdTreeAttributesEncodingMethod::kKdTreeIntegerEncoding) {
+    uint8_t compression_level = 0;
+    if (!in_buffer->Decode(&compression_level)) {
+      return false;
+    }
+    if (6 < compression_level) {
+      DRACO_LOGE(
+          "KdTreeAttributesDecoder: compression level %i not supported.\n",
+          compression_level);
+      return false;
+    }
+
+    uint32_t num_points;
+    if (!in_buffer->Decode(&num_points)) {
+      return false;
+    }
+
+    for (auto attribute_index = 0;
+         static_cast<uint32_t>(attribute_index) < attribute_count;
+         attribute_index += 1) {
+      const int att_id = GetAttributeId(attribute_index);
+      PointAttribute *const attr =
+          GetDecoder()->point_cloud()->attribute(att_id);
+      attr->Reset(num_points);
+      attr->SetIdentityMapping();
+    };
+
+    PointAttributeVectorOutputIterator<uint32_t> out_it(atts);
+
+    switch (compression_level) {
+      case 0: {
+        DynamicIntegerPointsKdTreeDecoder<0> decoder(total_dimensionality);
+        if (!decoder.DecodePoints(in_buffer, out_it)) {
+          return false;
+        }
+        break;
+      }
+      case 1: {
+        DynamicIntegerPointsKdTreeDecoder<1> decoder(total_dimensionality);
+        if (!decoder.DecodePoints(in_buffer, out_it)) {
+          return false;
+        }
+        break;
+      }
+      case 2: {
+        DynamicIntegerPointsKdTreeDecoder<2> decoder(total_dimensionality);
+        if (!decoder.DecodePoints(in_buffer, out_it)) {
+          return false;
+        }
+        break;
+      }
+      case 3: {
+        DynamicIntegerPointsKdTreeDecoder<3> decoder(total_dimensionality);
+        if (!decoder.DecodePoints(in_buffer, out_it)) {
+          return false;
+        }
+        break;
+      }
+      case 4: {
+        DynamicIntegerPointsKdTreeDecoder<4> decoder(total_dimensionality);
+        if (!decoder.DecodePoints(in_buffer, out_it)) {
+          return false;
+        }
+        break;
+      }
+      case 5: {
+        DynamicIntegerPointsKdTreeDecoder<5> decoder(total_dimensionality);
+        if (!decoder.DecodePoints(in_buffer, out_it)) {
+          return false;
+        }
+        break;
+      }
+      case 6: {
+        DynamicIntegerPointsKdTreeDecoder<6> decoder(total_dimensionality);
+        if (!decoder.DecodePoints(in_buffer, out_it)) {
+          return false;
+        }
+        break;
+      }
+      default:
+        return false;
+    }
+  } else {
+    // Invalid method.
+    return false;
+  }
+  return true;
+#else
+  return false;
+#endif
+}
+
+template <typename SignedDataTypeT>
+bool KdTreeAttributesDecoder::TransformAttributeBackToSignedType(
+    PointAttribute *att, int num_processed_signed_components) {
+  typedef typename std::make_unsigned<SignedDataTypeT>::type UnsignedType;
+  std::vector<UnsignedType> unsigned_val(att->num_components());
+  std::vector<SignedDataTypeT> signed_val(att->num_components());
+
+  for (AttributeValueIndex avi(0); avi < static_cast<uint32_t>(att->size());
+       ++avi) {
+    att->GetValue(avi, &unsigned_val[0]);
+    for (int c = 0; c < att->num_components(); ++c) {
+      // Up-cast |unsigned_val| to int32_t to ensure we don't overflow it for
+      // smaller data types.
+      signed_val[c] = static_cast<SignedDataTypeT>(
+          static_cast<int32_t>(unsigned_val[c]) +
+          min_signed_values_[num_processed_signed_components + c]);
+    }
+    att->SetAttributeValue(avi, &signed_val[0]);
+  }
+  return true;
+}
+
+bool KdTreeAttributesDecoder::TransformAttributesToOriginalFormat() {
+  if (quantized_portable_attributes_.empty() && min_signed_values_.empty()) {
+    return true;
+  }
+  int num_processed_quantized_attributes = 0;
+  int num_processed_signed_components = 0;
+  // Dequantize attributes that needed it.
+  for (int i = 0; i < GetNumAttributes(); ++i) {
+    const int att_id = GetAttributeId(i);
+    PointAttribute *const att = GetDecoder()->point_cloud()->attribute(att_id);
+    if (att->data_type() == DT_INT32 || att->data_type() == DT_INT16 ||
+        att->data_type() == DT_INT8) {
+      std::vector<uint32_t> unsigned_val(att->num_components());
+      std::vector<int32_t> signed_val(att->num_components());
+      // Values are stored as unsigned in the attribute, make them signed again.
+      if (att->data_type() == DT_INT32) {
+        if (!TransformAttributeBackToSignedType<int32_t>(
+                att, num_processed_signed_components)) {
+          return false;
+        }
+      } else if (att->data_type() == DT_INT16) {
+        if (!TransformAttributeBackToSignedType<int16_t>(
+                att, num_processed_signed_components)) {
+          return false;
+        }
+      } else if (att->data_type() == DT_INT8) {
+        if (!TransformAttributeBackToSignedType<int8_t>(
+                att, num_processed_signed_components)) {
+          return false;
+        }
+      }
+      num_processed_signed_components += att->num_components();
+    } else if (att->data_type() == DT_FLOAT32) {
+      // TODO(ostava): This code should be probably moved out to attribute
+      // transform and shared with the SequentialQuantizationAttributeDecoder.
+
+      const PointAttribute *const src_att =
+          quantized_portable_attributes_[num_processed_quantized_attributes]
+              .get();
+
+      const AttributeQuantizationTransform &transform =
+          attribute_quantization_transforms_
+              [num_processed_quantized_attributes];
+
+      num_processed_quantized_attributes++;
+
+      if (GetDecoder()->options()->GetAttributeBool(
+              att->attribute_type(), "skip_attribute_transform", false)) {
+        // Attribute transform should not be performed. In this case, we replace
+        // the output geometry attribute with the portable attribute.
+        // TODO(ostava): We can potentially avoid this copy by introducing a new
+        // mechanism that would allow to use the final attributes as portable
+        // attributes for predictors that may need them.
+        att->CopyFrom(*src_att);
+        continue;
+      }
+
+      // Convert all quantized values back to floats.
+      const int32_t max_quantized_value =
+          (1u << static_cast<uint32_t>(transform.quantization_bits())) - 1;
+      const int num_components = att->num_components();
+      const int entry_size = sizeof(float) * num_components;
+      const std::unique_ptr<float[]> att_val(new float[num_components]);
+      int quant_val_id = 0;
+      int out_byte_pos = 0;
+      Dequantizer dequantizer;
+      if (!dequantizer.Init(transform.range(), max_quantized_value)) {
+        return false;
+      }
+      const uint32_t *const portable_attribute_data =
+          reinterpret_cast<const uint32_t *>(
+              src_att->GetAddress(AttributeValueIndex(0)));
+      for (uint32_t i = 0; i < src_att->size(); ++i) {
+        for (int c = 0; c < num_components; ++c) {
+          float value = dequantizer.DequantizeFloat(
+              portable_attribute_data[quant_val_id++]);
+          value = value + transform.min_value(c);
+          att_val[c] = value;
+        }
+        // Store the floating point value into the attribute buffer.
+        att->buffer()->Write(out_byte_pos, att_val.get(), entry_size);
+        out_byte_pos += entry_size;
+      }
+    }
+  }
+  return true;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_decoder.h
new file mode 100644
index 000000000..87338d6b0
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_decoder.h
@@ -0,0 +1,46 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_KD_TREE_ATTRIBUTES_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_KD_TREE_ATTRIBUTES_DECODER_H_
+
+#include "draco/attributes/attribute_quantization_transform.h"
+#include "draco/compression/attributes/attributes_decoder.h"
+
+namespace draco {
+
+// Decodes attributes encoded with the KdTreeAttributesEncoder.
+class KdTreeAttributesDecoder : public AttributesDecoder {
+ public:
+  KdTreeAttributesDecoder();
+
+ protected:
+  bool DecodePortableAttributes(DecoderBuffer *in_buffer) override;
+  bool DecodeDataNeededByPortableTransforms(DecoderBuffer *in_buffer) override;
+  bool TransformAttributesToOriginalFormat() override;
+
+ private:
+  template <typename SignedDataTypeT>
+  bool TransformAttributeBackToSignedType(PointAttribute *att,
+                                          int num_processed_signed_components);
+
+  std::vector<AttributeQuantizationTransform>
+      attribute_quantization_transforms_;
+  std::vector<int32_t> min_signed_values_;
+  std::vector<std::unique_ptr<PointAttribute>> quantized_portable_attributes_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_KD_TREE_ATTRIBUTES_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_encoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_encoder.cc
new file mode 100644
index 000000000..b70deb9e0
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_encoder.cc
@@ -0,0 +1,305 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/kd_tree_attributes_encoder.h"
+
+#include "draco/compression/attributes/kd_tree_attributes_shared.h"
+#include "draco/compression/attributes/point_d_vector.h"
+#include "draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_encoder.h"
+#include "draco/compression/point_cloud/algorithms/float_points_tree_encoder.h"
+#include "draco/compression/point_cloud/point_cloud_encoder.h"
+#include "draco/core/varint_encoding.h"
+
+namespace draco {
+
+KdTreeAttributesEncoder::KdTreeAttributesEncoder() : num_components_(0) {}
+
+KdTreeAttributesEncoder::KdTreeAttributesEncoder(int att_id)
+    : AttributesEncoder(att_id), num_components_(0) {}
+
+bool KdTreeAttributesEncoder::TransformAttributesToPortableFormat() {
+  // Convert any of the input attributes into a format that can be processed by
+  // the kd tree encoder (quantization of floating attributes for now).
+  const size_t num_points = encoder()->point_cloud()->num_points();
+  int num_components = 0;
+  for (uint32_t i = 0; i < num_attributes(); ++i) {
+    const int att_id = GetAttributeId(i);
+    const PointAttribute *const att =
+        encoder()->point_cloud()->attribute(att_id);
+    num_components += att->num_components();
+  }
+  num_components_ = num_components;
+
+  // Go over all attributes and quantize them if needed.
+  for (uint32_t i = 0; i < num_attributes(); ++i) {
+    const int att_id = GetAttributeId(i);
+    const PointAttribute *const att =
+        encoder()->point_cloud()->attribute(att_id);
+    if (att->data_type() == DT_FLOAT32) {
+      // Quantization path.
+      AttributeQuantizationTransform attribute_quantization_transform;
+      const int quantization_bits = encoder()->options()->GetAttributeInt(
+          att_id, "quantization_bits", -1);
+      if (quantization_bits < 1) {
+        return false;
+      }
+      if (encoder()->options()->IsAttributeOptionSet(att_id,
+                                                     "quantization_origin") &&
+          encoder()->options()->IsAttributeOptionSet(att_id,
+                                                     "quantization_range")) {
+        // Quantization settings are explicitly specified in the provided
+        // options.
+        std::vector<float> quantization_origin(att->num_components());
+        encoder()->options()->GetAttributeVector(att_id, "quantization_origin",
+                                                 att->num_components(),
+                                                 &quantization_origin[0]);
+        const float range = encoder()->options()->GetAttributeFloat(
+            att_id, "quantization_range", 1.f);
+        attribute_quantization_transform.SetParameters(
+            quantization_bits, quantization_origin.data(),
+            att->num_components(), range);
+      } else {
+        // Compute quantization settings from the attribute values.
+        if (!attribute_quantization_transform.ComputeParameters(
+                *att, quantization_bits)) {
+          return false;
+        }
+      }
+      attribute_quantization_transforms_.push_back(
+          attribute_quantization_transform);
+      // Store the quantized attribute in an array that will be used when we do
+      // the actual encoding of the data.
+      auto portable_att =
+          attribute_quantization_transform.InitTransformedAttribute(*att,
+                                                                    num_points);
+      attribute_quantization_transform.TransformAttribute(*att, {},
+                                                          portable_att.get());
+      quantized_portable_attributes_.push_back(std::move(portable_att));
+    } else if (att->data_type() == DT_INT32 || att->data_type() == DT_INT16 ||
+               att->data_type() == DT_INT8) {
+      // For signed types, find the minimum value for each component. These
+      // values are going to be used to transform the attribute values to
+      // unsigned integers that can be processed by the core kd tree algorithm.
+      std::vector<int32_t> min_value(att->num_components(),
+                                     std::numeric_limits<int32_t>::max());
+      std::vector<int32_t> act_value(att->num_components());
+      for (AttributeValueIndex avi(0); avi < static_cast<uint32_t>(att->size());
+           ++avi) {
+        att->ConvertValue<int32_t>(avi, &act_value[0]);
+        for (int c = 0; c < att->num_components(); ++c) {
+          if (min_value[c] > act_value[c]) {
+            min_value[c] = act_value[c];
+          }
+        }
+      }
+      for (int c = 0; c < att->num_components(); ++c) {
+        min_signed_values_.push_back(min_value[c]);
+      }
+    }
+  }
+  return true;
+}
+
+bool KdTreeAttributesEncoder::EncodeDataNeededByPortableTransforms(
+    EncoderBuffer *out_buffer) {
+  // Store quantization settings for all attributes that need it.
+  for (int i = 0; i < attribute_quantization_transforms_.size(); ++i) {
+    attribute_quantization_transforms_[i].EncodeParameters(out_buffer);
+  }
+
+  // Encode data needed for transforming signed integers to unsigned ones.
+  for (int i = 0; i < min_signed_values_.size(); ++i) {
+    EncodeVarint<int32_t>(min_signed_values_[i], out_buffer);
+  }
+  return true;
+}
+
+bool KdTreeAttributesEncoder::EncodePortableAttributes(
+    EncoderBuffer *out_buffer) {
+  // Encode the data using the kd tree encoder algorithm. The data is first
+  // copied to a PointDVector that provides all the API expected by the core
+  // encoding algorithm.
+
+  // We limit the maximum value of compression_level to 6 as we don't currently
+  // have viable algorithms for higher compression levels.
+  uint8_t compression_level =
+      std::min(10 - encoder()->options()->GetSpeed(), 6);
+  DRACO_DCHECK_LE(compression_level, 6);
+
+  if (compression_level == 6 && num_components_ > 15) {
+    // Don't use compression level for CL >= 6. Axis selection is currently
+    // encoded using 4 bits.
+    compression_level = 5;
+  }
+
+  out_buffer->Encode(compression_level);
+
+  // Init PointDVector. The number of dimensions is equal to the total number
+  // of dimensions across all attributes.
+  const int num_points = encoder()->point_cloud()->num_points();
+  PointDVector<uint32_t> point_vector(num_points, num_components_);
+
+  int num_processed_components = 0;
+  int num_processed_quantized_attributes = 0;
+  int num_processed_signed_components = 0;
+  // Copy data to the point vector.
+  for (uint32_t i = 0; i < num_attributes(); ++i) {
+    const int att_id = GetAttributeId(i);
+    const PointAttribute *const att =
+        encoder()->point_cloud()->attribute(att_id);
+    const PointAttribute *source_att = nullptr;
+    if (att->data_type() == DT_UINT32 || att->data_type() == DT_UINT16 ||
+        att->data_type() == DT_UINT8 || att->data_type() == DT_INT32 ||
+        att->data_type() == DT_INT16 || att->data_type() == DT_INT8) {
+      // Use the original attribute.
+      source_att = att;
+    } else if (att->data_type() == DT_FLOAT32) {
+      // Use the portable (quantized) attribute instead.
+      source_att =
+          quantized_portable_attributes_[num_processed_quantized_attributes]
+              .get();
+      num_processed_quantized_attributes++;
+    } else {
+      // Unsupported data type.
+      return false;
+    }
+
+    if (source_att == nullptr) {
+      return false;
+    }
+
+    // Copy source_att to the vector.
+    if (source_att->data_type() == DT_UINT32) {
+      // If the data type is the same as the one used by the point vector, we
+      // can directly copy individual elements.
+      for (PointIndex pi(0); pi < num_points; ++pi) {
+        const AttributeValueIndex avi = source_att->mapped_index(pi);
+        const uint8_t *const att_value_address = source_att->GetAddress(avi);
+        point_vector.CopyAttribute(source_att->num_components(),
+                                   num_processed_components, pi.value(),
+                                   att_value_address);
+      }
+    } else if (source_att->data_type() == DT_INT32 ||
+               source_att->data_type() == DT_INT16 ||
+               source_att->data_type() == DT_INT8) {
+      // Signed values need to be converted to unsigned before they are stored
+      // in the point vector.
+      std::vector<int32_t> signed_point(source_att->num_components());
+      std::vector<uint32_t> unsigned_point(source_att->num_components());
+      for (PointIndex pi(0); pi < num_points; ++pi) {
+        const AttributeValueIndex avi = source_att->mapped_index(pi);
+        source_att->ConvertValue<int32_t>(avi, &signed_point[0]);
+        for (int c = 0; c < source_att->num_components(); ++c) {
+          unsigned_point[c] =
+              signed_point[c] -
+              min_signed_values_[num_processed_signed_components + c];
+        }
+
+        point_vector.CopyAttribute(source_att->num_components(),
+                                   num_processed_components, pi.value(),
+                                   &unsigned_point[0]);
+      }
+      num_processed_signed_components += source_att->num_components();
+    } else {
+      // If the data type of the attribute is different, we have to convert the
+      // value before we put it to the point vector.
+      std::vector<uint32_t> point(source_att->num_components());
+      for (PointIndex pi(0); pi < num_points; ++pi) {
+        const AttributeValueIndex avi = source_att->mapped_index(pi);
+        source_att->ConvertValue<uint32_t>(avi, &point[0]);
+        point_vector.CopyAttribute(source_att->num_components(),
+                                   num_processed_components, pi.value(),
+                                   point.data());
+      }
+    }
+    num_processed_components += source_att->num_components();
+  }
+
+  // Compute the maximum bit length needed for the kd tree encoding.
+  int num_bits = 0;
+  const uint32_t *data = point_vector[0];
+  for (int i = 0; i < num_points * num_components_; ++i) {
+    if (data[i] > 0) {
+      const int msb = MostSignificantBit(data[i]) + 1;
+      if (msb > num_bits) {
+        num_bits = msb;
+      }
+    }
+  }
+
+  switch (compression_level) {
+    case 6: {
+      DynamicIntegerPointsKdTreeEncoder<6> points_encoder(num_components_);
+      if (!points_encoder.EncodePoints(point_vector.begin(), point_vector.end(),
+                                       num_bits, out_buffer)) {
+        return false;
+      }
+      break;
+    }
+    case 5: {
+      DynamicIntegerPointsKdTreeEncoder<5> points_encoder(num_components_);
+      if (!points_encoder.EncodePoints(point_vector.begin(), point_vector.end(),
+                                       num_bits, out_buffer)) {
+        return false;
+      }
+      break;
+    }
+    case 4: {
+      DynamicIntegerPointsKdTreeEncoder<4> points_encoder(num_components_);
+      if (!points_encoder.EncodePoints(point_vector.begin(), point_vector.end(),
+                                       num_bits, out_buffer)) {
+        return false;
+      }
+      break;
+    }
+    case 3: {
+      DynamicIntegerPointsKdTreeEncoder<3> points_encoder(num_components_);
+      if (!points_encoder.EncodePoints(point_vector.begin(), point_vector.end(),
+                                       num_bits, out_buffer)) {
+        return false;
+      }
+      break;
+    }
+    case 2: {
+      DynamicIntegerPointsKdTreeEncoder<2> points_encoder(num_components_);
+      if (!points_encoder.EncodePoints(point_vector.begin(), point_vector.end(),
+                                       num_bits, out_buffer)) {
+        return false;
+      }
+      break;
+    }
+    case 1: {
+      DynamicIntegerPointsKdTreeEncoder<1> points_encoder(num_components_);
+      if (!points_encoder.EncodePoints(point_vector.begin(), point_vector.end(),
+                                       num_bits, out_buffer)) {
+        return false;
+      }
+      break;
+    }
+    case 0: {
+      DynamicIntegerPointsKdTreeEncoder<0> points_encoder(num_components_);
+      if (!points_encoder.EncodePoints(point_vector.begin(), point_vector.end(),
+                                       num_bits, out_buffer)) {
+        return false;
+      }
+      break;
+    }
+    // Compression level and/or encoding speed seem wrong.
+    default:
+      return false;
+  }
+  return true;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_encoder.h
new file mode 100644
index 000000000..80748e0bf
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_encoder.h
@@ -0,0 +1,51 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_KD_TREE_ATTRIBUTES_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_KD_TREE_ATTRIBUTES_ENCODER_H_
+
+#include "draco/attributes/attribute_quantization_transform.h"
+#include "draco/compression/attributes/attributes_encoder.h"
+#include "draco/compression/config/compression_shared.h"
+
+namespace draco {
+
+// Encodes all attributes of a given PointCloud using one of the available
+// Kd-tree compression methods.
+// See compression/point_cloud/point_cloud_kd_tree_encoder.h for more details.
+class KdTreeAttributesEncoder : public AttributesEncoder {
+ public:
+  KdTreeAttributesEncoder();
+  explicit KdTreeAttributesEncoder(int att_id);
+
+  uint8_t GetUniqueId() const override { return KD_TREE_ATTRIBUTE_ENCODER; }
+
+ protected:
+  bool TransformAttributesToPortableFormat() override;
+  bool EncodePortableAttributes(EncoderBuffer *out_buffer) override;
+  bool EncodeDataNeededByPortableTransforms(EncoderBuffer *out_buffer) override;
+
+ private:
+  std::vector<AttributeQuantizationTransform>
+      attribute_quantization_transforms_;
+  // Min signed values are used to transform signed integers into unsigned ones
+  // (by subtracting the min signed value for each component).
+  std::vector<int32_t> min_signed_values_;
+  std::vector<std::unique_ptr<PointAttribute>> quantized_portable_attributes_;
+  int num_components_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_KD_TREE_ATTRIBUTES_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_shared.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_shared.h
new file mode 100644
index 000000000..94841a91d
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_shared.h
@@ -0,0 +1,28 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_KD_TREE_ATTRIBUTES_SHARED_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_KD_TREE_ATTRIBUTES_SHARED_H_
+
+namespace draco {
+
+// Defines types of kD-tree compression
+enum KdTreeAttributesEncodingMethod {
+  kKdTreeQuantizationEncoding = 0,
+  kKdTreeIntegerEncoding
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_KD_TREE_ATTRIBUTES_SHARED_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/linear_sequencer.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/linear_sequencer.h
new file mode 100644
index 000000000..7d9b52641
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/linear_sequencer.h
@@ -0,0 +1,51 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_LINEAR_SEQUENCER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_LINEAR_SEQUENCER_H_
+
+#include "draco/compression/attributes/points_sequencer.h"
+
+namespace draco {
+
+// A simple sequencer that generates a linear sequence [0, num_points - 1].
+// I.e., the order of the points is preserved for the input data.
+class LinearSequencer : public PointsSequencer {
+ public:
+  explicit LinearSequencer(int32_t num_points) : num_points_(num_points) {}
+
+  bool UpdatePointToAttributeIndexMapping(PointAttribute *attribute) override {
+    attribute->SetIdentityMapping();
+    return true;
+  }
+
+ protected:
+  bool GenerateSequenceInternal() override {
+    if (num_points_ < 0) {
+      return false;
+    }
+    out_point_ids()->resize(num_points_);
+    for (int i = 0; i < num_points_; ++i) {
+      out_point_ids()->at(i) = PointIndex(i);
+    }
+    return true;
+  }
+
+ private:
+  int32_t num_points_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_LINEAR_SEQUENCER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/mesh_attribute_indices_encoding_data.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/mesh_attribute_indices_encoding_data.h
new file mode 100644
index 000000000..9a358e447
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/mesh_attribute_indices_encoding_data.h
@@ -0,0 +1,58 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_MESH_ATTRIBUTE_INDICES_ENCODING_DATA_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_MESH_ATTRIBUTE_INDICES_ENCODING_DATA_H_
+
+#include <inttypes.h>
+
+#include <vector>
+
+#include "draco/attributes/geometry_indices.h"
+
+namespace draco {
+
+// Data used for encoding and decoding of mesh attributes.
+struct MeshAttributeIndicesEncodingData {
+  MeshAttributeIndicesEncodingData() : num_values(0) {}
+
+  void Init(int num_vertices) {
+    vertex_to_encoded_attribute_value_index_map.resize(num_vertices);
+
+    // We expect to store one value for each vertex.
+    encoded_attribute_value_index_to_corner_map.reserve(num_vertices);
+  }
+
+  // Array for storing the corner ids in the order their associated attribute
+  // entries were encoded/decoded. For every encoded attribute value entry we
+  // store exactly one corner. I.e., this is the mapping between an encoded
+  // attribute entry ids and corner ids. This map is needed for example by
+  // prediction schemes. Note that not all corners are included in this map,
+  // e.g., if multiple corners share the same attribute value, only one of these
+  // corners will be usually included.
+  std::vector<CornerIndex> encoded_attribute_value_index_to_corner_map;
+
+  // Map for storing encoding order of attribute entries for each vertex.
+  // i.e. Mapping between vertices and their corresponding attribute entry ids
+  // that are going to be used by the decoder.
+  // -1 if an attribute entry hasn't been encoded/decoded yet.
+  std::vector<int32_t> vertex_to_encoded_attribute_value_index_map;
+
+  // Total number of encoded/decoded attribute entries.
+  int num_values;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_MESH_ATTRIBUTE_INDICES_ENCODING_DATA_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/normal_compression_utils.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/normal_compression_utils.h
new file mode 100644
index 000000000..8a6f25b66
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/normal_compression_utils.h
@@ -0,0 +1,360 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Utilities for converting unit vectors to octahedral coordinates and back.
+// For more details about octahedral coordinates, see for example Cigolle
+// et al.'14 “A Survey of Efficient Representations for Independent Unit
+// Vectors�.
+//
+// In short this is motivated by an octahedron inscribed into a sphere. The
+// direction of the normal vector can be defined by a point on the octahedron.
+// On the right hemisphere (x > 0) this point is projected onto the x = 0 plane,
+// that is, the right side of the octahedron forms a diamond like shape. The
+// left side of the octahedron is also projected onto the x = 0 plane, however,
+// in this case we flap the triangles of the diamond outward. Afterwards we
+// shift the resulting square such that all values are positive.
+//
+// Important values in this file:
+// * q: number of quantization bits
+// * max_quantized_value: the max value representable with q bits (odd)
+// * max_value: max value of the diamond = max_quantized_value - 1  (even)
+// * center_value: center of the diamond after shift
+//
+// Note that the parameter space is somewhat periodic, e.g. (0, 0) ==
+// (max_value, max_value), which is also why the diamond is one smaller than the
+// maximal representable value in order to have an odd range of values.
+
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_NORMAL_COMPRESSION_UTILS_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_NORMAL_COMPRESSION_UTILS_H_
+
+#include <inttypes.h>
+
+#include <algorithm>
+#include <cmath>
+
+#include "draco/core/macros.h"
+
+namespace draco {
+
+class OctahedronToolBox {
+ public:
+  OctahedronToolBox()
+      : quantization_bits_(-1),
+        max_quantized_value_(-1),
+        max_value_(-1),
+        dequantization_scale_(1.f),
+        center_value_(-1) {}
+
+  bool SetQuantizationBits(int32_t q) {
+    if (q < 2 || q > 30) {
+      return false;
+    }
+    quantization_bits_ = q;
+    max_quantized_value_ = (1 << quantization_bits_) - 1;
+    max_value_ = max_quantized_value_ - 1;
+    dequantization_scale_ = 2.f / max_value_;
+    center_value_ = max_value_ / 2;
+    return true;
+  }
+  bool IsInitialized() const { return quantization_bits_ != -1; }
+
+  // Convert all edge points in the top left and bottom right quadrants to
+  // their corresponding position in the bottom left and top right quadrants.
+  // Convert all corner edge points to the top right corner.
+  inline void CanonicalizeOctahedralCoords(int32_t s, int32_t t, int32_t *out_s,
+                                           int32_t *out_t) const {
+    if ((s == 0 && t == 0) || (s == 0 && t == max_value_) ||
+        (s == max_value_ && t == 0)) {
+      s = max_value_;
+      t = max_value_;
+    } else if (s == 0 && t > center_value_) {
+      t = center_value_ - (t - center_value_);
+    } else if (s == max_value_ && t < center_value_) {
+      t = center_value_ + (center_value_ - t);
+    } else if (t == max_value_ && s < center_value_) {
+      s = center_value_ + (center_value_ - s);
+    } else if (t == 0 && s > center_value_) {
+      s = center_value_ - (s - center_value_);
+    }
+
+    *out_s = s;
+    *out_t = t;
+  }
+
+  // Converts an integer vector to octahedral coordinates.
+  // Precondition: |int_vec| abs sum must equal center value.
+  inline void IntegerVectorToQuantizedOctahedralCoords(const int32_t *int_vec,
+                                                       int32_t *out_s,
+                                                       int32_t *out_t) const {
+    DRACO_DCHECK_EQ(
+        std::abs(int_vec[0]) + std::abs(int_vec[1]) + std::abs(int_vec[2]),
+        center_value_);
+    int32_t s, t;
+    if (int_vec[0] >= 0) {
+      // Right hemisphere.
+      s = (int_vec[1] + center_value_);
+      t = (int_vec[2] + center_value_);
+    } else {
+      // Left hemisphere.
+      if (int_vec[1] < 0) {
+        s = std::abs(int_vec[2]);
+      } else {
+        s = (max_value_ - std::abs(int_vec[2]));
+      }
+      if (int_vec[2] < 0) {
+        t = std::abs(int_vec[1]);
+      } else {
+        t = (max_value_ - std::abs(int_vec[1]));
+      }
+    }
+    CanonicalizeOctahedralCoords(s, t, out_s, out_t);
+  }
+
+  template <class T>
+  void FloatVectorToQuantizedOctahedralCoords(const T *vector, int32_t *out_s,
+                                              int32_t *out_t) const {
+    const double abs_sum = std::abs(static_cast<double>(vector[0])) +
+                           std::abs(static_cast<double>(vector[1])) +
+                           std::abs(static_cast<double>(vector[2]));
+
+    // Adjust values such that abs sum equals 1.
+    double scaled_vector[3];
+    if (abs_sum > 1e-6) {
+      // Scale needed to project the vector to the surface of an octahedron.
+      const double scale = 1.0 / abs_sum;
+      scaled_vector[0] = vector[0] * scale;
+      scaled_vector[1] = vector[1] * scale;
+      scaled_vector[2] = vector[2] * scale;
+    } else {
+      scaled_vector[0] = 1.0;
+      scaled_vector[1] = 0;
+      scaled_vector[2] = 0;
+    }
+
+    // Scale vector such that the sum equals the center value.
+    int32_t int_vec[3];
+    int_vec[0] =
+        static_cast<int32_t>(floor(scaled_vector[0] * center_value_ + 0.5));
+    int_vec[1] =
+        static_cast<int32_t>(floor(scaled_vector[1] * center_value_ + 0.5));
+    // Make sure the sum is exactly the center value.
+    int_vec[2] = center_value_ - std::abs(int_vec[0]) - std::abs(int_vec[1]);
+    if (int_vec[2] < 0) {
+      // If the sum of first two coordinates is too large, we need to decrease
+      // the length of one of the coordinates.
+      if (int_vec[1] > 0) {
+        int_vec[1] += int_vec[2];
+      } else {
+        int_vec[1] -= int_vec[2];
+      }
+      int_vec[2] = 0;
+    }
+    // Take care of the sign.
+    if (scaled_vector[2] < 0) {
+      int_vec[2] *= -1;
+    }
+
+    IntegerVectorToQuantizedOctahedralCoords(int_vec, out_s, out_t);
+  }
+
+  // Normalize |vec| such that its abs sum is equal to the center value;
+  template <class T>
+  void CanonicalizeIntegerVector(T *vec) const {
+    static_assert(std::is_integral<T>::value, "T must be an integral type.");
+    static_assert(std::is_signed<T>::value, "T must be a signed type.");
+    const int64_t abs_sum = static_cast<int64_t>(std::abs(vec[0])) +
+                            static_cast<int64_t>(std::abs(vec[1])) +
+                            static_cast<int64_t>(std::abs(vec[2]));
+
+    if (abs_sum == 0) {
+      vec[0] = center_value_;  // vec[1] == v[2] == 0
+    } else {
+      vec[0] =
+          (static_cast<int64_t>(vec[0]) * static_cast<int64_t>(center_value_)) /
+          abs_sum;
+      vec[1] =
+          (static_cast<int64_t>(vec[1]) * static_cast<int64_t>(center_value_)) /
+          abs_sum;
+      if (vec[2] >= 0) {
+        vec[2] = center_value_ - std::abs(vec[0]) - std::abs(vec[1]);
+      } else {
+        vec[2] = -(center_value_ - std::abs(vec[0]) - std::abs(vec[1]));
+      }
+    }
+  }
+
+  inline void QuantizedOctahedralCoordsToUnitVector(int32_t in_s, int32_t in_t,
+                                                    float *out_vector) const {
+    OctahedralCoordsToUnitVector(in_s * dequantization_scale_ - 1.f,
+                                 in_t * dequantization_scale_ - 1.f,
+                                 out_vector);
+  }
+
+  // |s| and |t| are expected to be signed values.
+  inline bool IsInDiamond(const int32_t &s, const int32_t &t) const {
+    // Expect center already at origin.
+    DRACO_DCHECK_LE(s, center_value_);
+    DRACO_DCHECK_LE(t, center_value_);
+    DRACO_DCHECK_GE(s, -center_value_);
+    DRACO_DCHECK_GE(t, -center_value_);
+    return std::abs(s) + std::abs(t) <= center_value_;
+  }
+
+  void InvertDiamond(int32_t *s, int32_t *t) const {
+    // Expect center already at origin.
+    DRACO_DCHECK_LE(*s, center_value_);
+    DRACO_DCHECK_LE(*t, center_value_);
+    DRACO_DCHECK_GE(*s, -center_value_);
+    DRACO_DCHECK_GE(*t, -center_value_);
+    int32_t sign_s = 0;
+    int32_t sign_t = 0;
+    if (*s >= 0 && *t >= 0) {
+      sign_s = 1;
+      sign_t = 1;
+    } else if (*s <= 0 && *t <= 0) {
+      sign_s = -1;
+      sign_t = -1;
+    } else {
+      sign_s = (*s > 0) ? 1 : -1;
+      sign_t = (*t > 0) ? 1 : -1;
+    }
+
+    const int32_t corner_point_s = sign_s * center_value_;
+    const int32_t corner_point_t = sign_t * center_value_;
+    *s = 2 * *s - corner_point_s;
+    *t = 2 * *t - corner_point_t;
+    if (sign_s * sign_t >= 0) {
+      int32_t temp = *s;
+      *s = -*t;
+      *t = -temp;
+    } else {
+      std::swap(*s, *t);
+    }
+    *s = (*s + corner_point_s) / 2;
+    *t = (*t + corner_point_t) / 2;
+  }
+
+  void InvertDirection(int32_t *s, int32_t *t) const {
+    // Expect center already at origin.
+    DRACO_DCHECK_LE(*s, center_value_);
+    DRACO_DCHECK_LE(*t, center_value_);
+    DRACO_DCHECK_GE(*s, -center_value_);
+    DRACO_DCHECK_GE(*t, -center_value_);
+    *s *= -1;
+    *t *= -1;
+    this->InvertDiamond(s, t);
+  }
+
+  // For correction values.
+  int32_t ModMax(int32_t x) const {
+    if (x > this->center_value()) {
+      return x - this->max_quantized_value();
+    }
+    if (x < -this->center_value()) {
+      return x + this->max_quantized_value();
+    }
+    return x;
+  }
+
+  // For correction values.
+  int32_t MakePositive(int32_t x) const {
+    DRACO_DCHECK_LE(x, this->center_value() * 2);
+    if (x < 0) {
+      return x + this->max_quantized_value();
+    }
+    return x;
+  }
+
+  int32_t quantization_bits() const { return quantization_bits_; }
+  int32_t max_quantized_value() const { return max_quantized_value_; }
+  int32_t max_value() const { return max_value_; }
+  int32_t center_value() const { return center_value_; }
+
+ private:
+  inline void OctahedralCoordsToUnitVector(float in_s_scaled, float in_t_scaled,
+                                           float *out_vector) const {
+    // Background about the encoding:
+    //   A normal is encoded in a normalized space <s, t> depicted below. The
+    //   encoding correponds to an octahedron that is unwrapped to a 2D plane.
+    //   During encoding, a normal is projected to the surface of the octahedron
+    //   and the projection is then unwrapped to the 2D plane. Decoding is the
+    //   reverse of this process.
+    //   All points in the central diamond are located on triangles on the
+    //   right "hemisphere" of the octahedron while all points outside of the
+    //   diamond are on the left hemisphere (basically, they would have to be
+    //   wrapped along the diagonal edges to form the octahedron). The central
+    //   point corresponds to the right most vertex of the octahedron and all
+    //   corners of the plane correspond to the left most vertex of the
+    //   octahedron.
+    //
+    // t
+    // ^ *-----*-----*
+    // | |    /|\    |
+    //   |   / | \   |
+    //   |  /  |  \  |
+    //   | /   |   \ |
+    //   *-----*---- *
+    //   | \   |   / |
+    //   |  \  |  /  |
+    //   |   \ | /   |
+    //   |    \|/    |
+    //   *-----*-----*  --> s
+
+    // Note that the input |in_s_scaled| and |in_t_scaled| are already scaled to
+    // <-1, 1> range. This way, the central point is at coordinate (0, 0).
+    float y = in_s_scaled;
+    float z = in_t_scaled;
+
+    // Remaining coordinate can be computed by projecting the (y, z) values onto
+    // the surface of the octahedron.
+    const float x = 1.f - abs(y) - abs(z);
+
+    // |x| is essentially a signed distance from the diagonal edges of the
+    // diamond shown on the figure above. It is positive for all points in the
+    // diamond (right hemisphere) and negative for all points outside the
+    // diamond (left hemisphere). For all points on the left hemisphere we need
+    // to update their (y, z) coordinates to account for the wrapping along
+    // the edges of the diamond.
+    float x_offset = -x;
+    x_offset = x_offset < 0 ? 0 : x_offset;
+
+    // This will do nothing for the points on the right hemisphere but it will
+    // mirror the (y, z) location along the nearest diagonal edge of the
+    // diamond.
+    y += y < 0 ? x_offset : -x_offset;
+    z += z < 0 ? x_offset : -x_offset;
+
+    // Normalize the computed vector.
+    const float norm_squared = x * x + y * y + z * z;
+    if (norm_squared < 1e-6) {
+      out_vector[0] = 0;
+      out_vector[1] = 0;
+      out_vector[2] = 0;
+    } else {
+      const float d = 1.0f / std::sqrt(norm_squared);
+      out_vector[0] = x * d;
+      out_vector[1] = y * d;
+      out_vector[2] = z * d;
+    }
+  }
+
+  int32_t quantization_bits_;
+  int32_t max_quantized_value_;
+  int32_t max_value_;
+  float dequantization_scale_;
+  int32_t center_value_;
+};
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_NORMAL_COMPRESSION_UTILS_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/point_d_vector.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/point_d_vector.h
new file mode 100644
index 000000000..3b115d500
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/point_d_vector.h
@@ -0,0 +1,279 @@
+// Copyright 2018 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_POINT_D_VECTOR_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_POINT_D_VECTOR_H_
+
+#include <cstring>
+#include <memory>
+#include <vector>
+
+#include "draco/core/macros.h"
+
+namespace draco {
+
+// The main class of this file is PointDVector providing an interface similar to
+// std::vector<PointD> for arbitrary number of dimensions (without a template
+// argument). PointDVectorIterator is a random access iterator, which allows for
+// compatibility with existing algorithms. PseudoPointD provides for a view on
+// the individual items in a contiguous block of memory, which is compatible
+// with the swap function and is returned by a dereference of
+// PointDVectorIterator. Swap functions provide for compatibility/specialization
+// that allows these classes to work with currently utilized STL functions.
+
+// This class allows for swap functionality from the RandomIterator
+// It seems problematic to bring this inside PointDVector due to templating.
+template <typename internal_t>
+class PseudoPointD {
+ public:
+  PseudoPointD(internal_t *mem, internal_t dimension)
+      : mem_(mem), dimension_(dimension) {}
+
+  // Specifically copies referenced memory
+  void swap(PseudoPointD &other) noexcept {
+    for (internal_t dim = 0; dim < dimension_; dim += 1) {
+      std::swap(mem_[dim], other.mem_[dim]);
+    }
+  }
+
+  PseudoPointD(const PseudoPointD &other)
+      : mem_(other.mem_), dimension_(other.dimension_) {}
+
+  const internal_t &operator[](const size_t &n) const {
+    DRACO_DCHECK_LT(n, dimension_);
+    return mem_[n];
+  }
+  internal_t &operator[](const size_t &n) {
+    DRACO_DCHECK_LT(n, dimension_);
+    return mem_[n];
+  }
+
+  bool operator==(const PseudoPointD &other) const {
+    for (auto dim = 0; dim < dimension_; dim += 1) {
+      if (mem_[dim] != other.mem_[dim]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  bool operator!=(const PseudoPointD &other) const {
+    return !this->operator==(other);
+  }
+
+ private:
+  internal_t *const mem_;
+  const internal_t dimension_;
+};
+
+// It seems problematic to bring this inside PointDVector due to templating.
+template <typename internal_t>
+void swap(draco::PseudoPointD<internal_t> &&a,
+          draco::PseudoPointD<internal_t> &&b) noexcept {
+  a.swap(b);
+};
+template <typename internal_t>
+void swap(draco::PseudoPointD<internal_t> &a,
+          draco::PseudoPointD<internal_t> &b) noexcept {
+  a.swap(b);
+};
+
+template <typename internal_t>
+class PointDVector {
+ public:
+  PointDVector(const uint32_t n_items, const uint32_t dimensionality)
+      : n_items_(n_items),
+        dimensionality_(dimensionality),
+        item_size_bytes_(dimensionality * sizeof(internal_t)),
+        data_(n_items * dimensionality),
+        data0_(data_.data()) {}
+  // random access iterator
+  class PointDVectorIterator
+      : public std::iterator<std::random_access_iterator_tag, size_t, size_t> {
+    friend class PointDVector;
+
+   public:
+    // std::iter_swap is called inside of std::partition and needs this
+    // specialized support
+    PseudoPointD<internal_t> operator*() const {
+      return PseudoPointD<internal_t>(vec_->data0_ + item_ * dimensionality_,
+                                      dimensionality_);
+    }
+    const PointDVectorIterator &operator++() {
+      item_ += 1;
+      return *this;
+    }
+    const PointDVectorIterator &operator--() {
+      item_ -= 1;
+      return *this;
+    }
+    PointDVectorIterator operator++(int32_t) {
+      PointDVectorIterator copy(*this);
+      item_ += 1;
+      return copy;
+    }
+    PointDVectorIterator operator--(int32_t) {
+      PointDVectorIterator copy(*this);
+      item_ -= 1;
+      return copy;
+    }
+    PointDVectorIterator &operator=(const PointDVectorIterator &other) {
+      this->item_ = other.item_;
+      return *this;
+    }
+
+    bool operator==(const PointDVectorIterator &ref) const {
+      return item_ == ref.item_;
+    }
+    bool operator!=(const PointDVectorIterator &ref) const {
+      return item_ != ref.item_;
+    }
+    bool operator<(const PointDVectorIterator &ref) const {
+      return item_ < ref.item_;
+    }
+    bool operator>(const PointDVectorIterator &ref) const {
+      return item_ > ref.item_;
+    }
+    bool operator<=(const PointDVectorIterator &ref) const {
+      return item_ <= ref.item_;
+    }
+    bool operator>=(const PointDVectorIterator &ref) const {
+      return item_ >= ref.item_;
+    }
+
+    PointDVectorIterator operator+(const int32_t &add) const {
+      PointDVectorIterator copy(vec_, item_ + add);
+      return copy;
+    }
+    PointDVectorIterator &operator+=(const int32_t &add) {
+      item_ += add;
+      return *this;
+    }
+    PointDVectorIterator operator-(const int32_t &sub) const {
+      PointDVectorIterator copy(vec_, item_ - sub);
+      return copy;
+    }
+    size_t operator-(const PointDVectorIterator &sub) const {
+      return (item_ - sub.item_);
+    }
+
+    PointDVectorIterator &operator-=(const int32_t &sub) {
+      item_ -= sub;
+      return *this;
+    }
+
+    internal_t *operator[](const size_t &n) const {
+      return vec_->data0_ + (item_ + n) * dimensionality_;
+    }
+
+   protected:
+    explicit PointDVectorIterator(PointDVector *vec, size_t start_item)
+        : item_(start_item), vec_(vec), dimensionality_(vec->dimensionality_) {}
+
+   private:
+    size_t item_;  // this counts the item that should be referenced.
+    PointDVector *const vec_;        // the thing that we're iterating on
+    const uint32_t dimensionality_;  // local copy from vec_
+  };
+
+  PointDVectorIterator begin() { return PointDVectorIterator(this, 0); }
+  PointDVectorIterator end() { return PointDVectorIterator(this, n_items_); }
+
+  // operator[] allows for unprotected user-side usage of operator[] on the
+  // return value AS IF it were a natively indexable type like Point3*
+  internal_t *operator[](const uint32_t index) {
+    DRACO_DCHECK_LT(index, n_items_);
+    return data0_ + index * dimensionality_;
+  }
+  const internal_t *operator[](const uint32_t index) const {
+    DRACO_DCHECK_LT(index, n_items_);
+    return data0_ + index * dimensionality_;
+  }
+
+  uint32_t size() const { return n_items_; }
+  size_t GetBufferSize() const { return data_.size(); }
+
+  // copy a single contiguous 'item' from one PointDVector into this one.
+  void CopyItem(const PointDVector &source, const internal_t source_index,
+                const internal_t destination_index) {
+    DRACO_DCHECK(&source != this ||
+                 (&source == this && source_index != destination_index));
+    DRACO_DCHECK_LT(destination_index, n_items_);
+    DRACO_DCHECK_LT(source_index, source.n_items_);
+
+    // DRACO_DCHECK_EQ(source.n_items_, n_items_); // not technically necessary
+    DRACO_DCHECK_EQ(source.dimensionality_, dimensionality_);
+
+    const internal_t *ref = source[source_index];
+    internal_t *const dest = this->operator[](destination_index);
+    std::memcpy(dest, ref, item_size_bytes_);
+  }
+
+  // Copy data directly off of an attribute buffer interleaved into internal
+  // memory.
+  void CopyAttribute(
+      // The dimensionality of the attribute being integrated
+      const internal_t attribute_dimensionality,
+      // The offset in dimensions to insert this attribute.
+      const internal_t offset_dimensionality, const internal_t index,
+      // The direct pointer to the data
+      const void *const attribute_item_data) {
+    // chunk copy
+    const size_t copy_size = sizeof(internal_t) * attribute_dimensionality;
+
+    // a multiply and add can be optimized away with an iterator
+    std::memcpy(data0_ + index * dimensionality_ + offset_dimensionality,
+                attribute_item_data, copy_size);
+  }
+  // Copy data off of a contiguous buffer interleaved into internal memory
+  void CopyAttribute(
+      // The dimensionality of the attribute being integrated
+      const internal_t attribute_dimensionality,
+      // The offset in dimensions to insert this attribute.
+      const internal_t offset_dimensionality,
+      const internal_t *const attribute_mem) {
+    DRACO_DCHECK_LT(offset_dimensionality,
+                    dimensionality_ - attribute_dimensionality);
+    // degenerate case block copy the whole buffer.
+    if (dimensionality_ == attribute_dimensionality) {
+      DRACO_DCHECK_EQ(offset_dimensionality, 0);
+      const size_t copy_size =
+          sizeof(internal_t) * attribute_dimensionality * n_items_;
+      std::memcpy(data0_, attribute_mem, copy_size);
+    } else {  // chunk copy
+      const size_t copy_size = sizeof(internal_t) * attribute_dimensionality;
+      internal_t *internal_data;
+      const internal_t *attribute_data;
+      internal_t item;
+      for (internal_data = data0_ + offset_dimensionality,
+          attribute_data = attribute_mem, item = 0;
+           item < n_items_; internal_data += dimensionality_,
+          attribute_data += attribute_dimensionality, item += 1) {
+        std::memcpy(internal_data, attribute_data, copy_size);
+      }
+    }
+  }
+
+ private:
+  // internal parameters.
+  const uint32_t n_items_;
+  const uint32_t dimensionality_;  // The dimension of the points in the buffer
+  const uint32_t item_size_bytes_;
+  std::vector<internal_t> data_;  // contiguously stored data.  Never resized.
+  internal_t *const data0_;       // raw pointer to base data.
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_POINT_D_VECTOR_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/point_d_vector_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/point_d_vector_test.cc
new file mode 100644
index 000000000..59f28f80b
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/point_d_vector_test.cc
@@ -0,0 +1,360 @@
+// Copyright 2018 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/point_d_vector.h"
+
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+#include "draco/core/draco_test_base.h"
+
+namespace draco {
+
+class PointDVectorTest : public ::testing::Test {
+ protected:
+  template <typename PT>
+  void TestIntegrity() {}
+  template <typename PT>
+  void TestSize() {
+    for (uint32_t n_items = 0; n_items <= 10; ++n_items) {
+      for (uint32_t dimensionality = 1; dimensionality <= 10;
+           ++dimensionality) {
+        draco::PointDVector<PT> var(n_items, dimensionality);
+        ASSERT_EQ(n_items, var.size());
+        ASSERT_EQ(n_items * dimensionality, var.GetBufferSize());
+      }
+    }
+  }
+  template <typename PT>
+  void TestContentsContiguous() {
+    for (uint32_t n_items = 1; n_items <= 1000; n_items *= 10) {
+      for (uint32_t dimensionality = 1; dimensionality < 10;
+           dimensionality += 2) {
+        for (uint32_t att_dimensionality = 1;
+             att_dimensionality <= dimensionality; att_dimensionality += 2) {
+          for (uint32_t offset_dimensionality = 0;
+               offset_dimensionality < dimensionality - att_dimensionality;
+               ++offset_dimensionality) {
+            PointDVector<PT> var(n_items, dimensionality);
+
+            std::vector<PT> att(n_items * att_dimensionality);
+            for (PT val = 0; val < n_items; val += 1) {
+              for (PT att_dim = 0; att_dim < att_dimensionality; att_dim += 1) {
+                att[val * att_dimensionality + att_dim] = val;
+              }
+            }
+            const PT *const attribute_data = att.data();
+
+            var.CopyAttribute(att_dimensionality, offset_dimensionality,
+                              attribute_data);
+
+            for (PT val = 0; val < n_items; val += 1) {
+              for (PT att_dim = 0; att_dim < att_dimensionality; att_dim += 1) {
+                ASSERT_EQ(var[val][offset_dimensionality + att_dim], val);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  template <typename PT>
+  void TestContentsDiscrete() {
+    for (uint32_t n_items = 1; n_items <= 1000; n_items *= 10) {
+      for (uint32_t dimensionality = 1; dimensionality < 10;
+           dimensionality += 2) {
+        for (uint32_t att_dimensionality = 1;
+             att_dimensionality <= dimensionality; att_dimensionality += 2) {
+          for (uint32_t offset_dimensionality = 0;
+               offset_dimensionality < dimensionality - att_dimensionality;
+               ++offset_dimensionality) {
+            PointDVector<PT> var(n_items, dimensionality);
+
+            std::vector<PT> att(n_items * att_dimensionality);
+            for (PT val = 0; val < n_items; val += 1) {
+              for (PT att_dim = 0; att_dim < att_dimensionality; att_dim += 1) {
+                att[val * att_dimensionality + att_dim] = val;
+              }
+            }
+            const PT *const attribute_data = att.data();
+
+            for (PT item = 0; item < n_items; item += 1) {
+              var.CopyAttribute(att_dimensionality, offset_dimensionality, item,
+                                attribute_data + item * att_dimensionality);
+            }
+
+            for (PT val = 0; val < n_items; val += 1) {
+              for (PT att_dim = 0; att_dim < att_dimensionality; att_dim += 1) {
+                ASSERT_EQ(var[val][offset_dimensionality + att_dim], val);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  template <typename PT>
+  void TestContentsCopy() {
+    for (uint32_t n_items = 1; n_items <= 1000; n_items *= 10) {
+      for (uint32_t dimensionality = 1; dimensionality < 10;
+           dimensionality += 2) {
+        for (uint32_t att_dimensionality = 1;
+             att_dimensionality <= dimensionality; att_dimensionality += 2) {
+          for (uint32_t offset_dimensionality = 0;
+               offset_dimensionality < dimensionality - att_dimensionality;
+               ++offset_dimensionality) {
+            PointDVector<PT> var(n_items, dimensionality);
+            PointDVector<PT> dest(n_items, dimensionality);
+
+            std::vector<PT> att(n_items * att_dimensionality);
+            for (PT val = 0; val < n_items; val += 1) {
+              for (PT att_dim = 0; att_dim < att_dimensionality; att_dim += 1) {
+                att[val * att_dimensionality + att_dim] = val;
+              }
+            }
+            const PT *const attribute_data = att.data();
+
+            var.CopyAttribute(att_dimensionality, offset_dimensionality,
+                              attribute_data);
+
+            for (PT item = 0; item < n_items; item += 1) {
+              dest.CopyItem(var, item, item);
+            }
+
+            for (PT val = 0; val < n_items; val += 1) {
+              for (PT att_dim = 0; att_dim < att_dimensionality; att_dim += 1) {
+                ASSERT_EQ(var[val][offset_dimensionality + att_dim], val);
+                ASSERT_EQ(dest[val][offset_dimensionality + att_dim], val);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  template <typename PT>
+  void TestIterator() {
+    for (uint32_t n_items = 1; n_items <= 1000; n_items *= 10) {
+      for (uint32_t dimensionality = 1; dimensionality < 10;
+           dimensionality += 2) {
+        for (uint32_t att_dimensionality = 1;
+             att_dimensionality <= dimensionality; att_dimensionality += 2) {
+          for (uint32_t offset_dimensionality = 0;
+               offset_dimensionality < dimensionality - att_dimensionality;
+               ++offset_dimensionality) {
+            PointDVector<PT> var(n_items, dimensionality);
+            PointDVector<PT> dest(n_items, dimensionality);
+
+            std::vector<PT> att(n_items * att_dimensionality);
+            for (PT val = 0; val < n_items; val += 1) {
+              for (PT att_dim = 0; att_dim < att_dimensionality; att_dim += 1) {
+                att[val * att_dimensionality + att_dim] = val;
+              }
+            }
+            const PT *const attribute_data = att.data();
+
+            var.CopyAttribute(att_dimensionality, offset_dimensionality,
+                              attribute_data);
+
+            for (PT item = 0; item < n_items; item += 1) {
+              dest.CopyItem(var, item, item);
+            }
+
+            auto V0 = var.begin();
+            auto VE = var.end();
+            auto D0 = dest.begin();
+            auto DE = dest.end();
+
+            while (V0 != VE && D0 != DE) {
+              ASSERT_EQ(*D0, *V0);  // compare PseudoPointD
+              // verify elemental values
+              for (auto index = 0; index < dimensionality; index += 1) {
+                ASSERT_EQ((*D0)[index], (*V0)[index]);
+              }
+              ++V0;
+              ++D0;
+            }
+
+            for (PT val = 0; val < n_items; val += 1) {
+              for (PT att_dim = 0; att_dim < att_dimensionality; att_dim += 1) {
+                ASSERT_EQ(var[val][offset_dimensionality + att_dim], val);
+                ASSERT_EQ(dest[val][offset_dimensionality + att_dim], val);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  template <typename PT>
+  void TestPoint3Iterator() {
+    for (uint32_t n_items = 1; n_items <= 1000; n_items *= 10) {
+      const uint32_t dimensionality = 3;
+      // for (uint32_t dimensionality = 1; dimensionality < 10;
+      //      dimensionality += 2) {
+      const uint32_t att_dimensionality = 3;
+      // for (uint32_t att_dimensionality = 1;
+      //      att_dimensionality <= dimensionality; att_dimensionality += 2) {
+      for (uint32_t offset_dimensionality = 0;
+           offset_dimensionality < dimensionality - att_dimensionality;
+           ++offset_dimensionality) {
+        PointDVector<PT> var(n_items, dimensionality);
+        PointDVector<PT> dest(n_items, dimensionality);
+
+        std::vector<PT> att(n_items * att_dimensionality);
+        std::vector<draco::Point3ui> att3(n_items);
+        for (PT val = 0; val < n_items; val += 1) {
+          att3[val][0] = val;
+          att3[val][1] = val;
+          att3[val][2] = val;
+          for (PT att_dim = 0; att_dim < att_dimensionality; att_dim += 1) {
+            att[val * att_dimensionality + att_dim] = val;
+          }
+        }
+        const PT *const attribute_data = att.data();
+
+        var.CopyAttribute(att_dimensionality, offset_dimensionality,
+                          attribute_data);
+
+        for (PT item = 0; item < n_items; item += 1) {
+          dest.CopyItem(var, item, item);
+        }
+
+        auto aV0 = att3.begin();
+        auto aVE = att3.end();
+        auto V0 = var.begin();
+        auto VE = var.end();
+        auto D0 = dest.begin();
+        auto DE = dest.end();
+
+        while (aV0 != aVE && V0 != VE && D0 != DE) {
+          ASSERT_EQ(*D0, *V0);  // compare PseudoPointD
+          // verify elemental values
+          for (auto index = 0; index < dimensionality; index += 1) {
+            ASSERT_EQ((*D0)[index], (*V0)[index]);
+            ASSERT_EQ((*D0)[index], (*aV0)[index]);
+            ASSERT_EQ((*aV0)[index], (*V0)[index]);
+          }
+          ++aV0;
+          ++V0;
+          ++D0;
+        }
+
+        for (PT val = 0; val < n_items; val += 1) {
+          for (PT att_dim = 0; att_dim < att_dimensionality; att_dim += 1) {
+            ASSERT_EQ(var[val][offset_dimensionality + att_dim], val);
+            ASSERT_EQ(dest[val][offset_dimensionality + att_dim], val);
+          }
+        }
+      }
+    }
+  }
+
+  void TestPseudoPointDSwap() {
+    draco::Point3ui val = {0, 1, 2};
+    draco::Point3ui dest = {10, 11, 12};
+    draco::PseudoPointD<uint32_t> val_src1(&val[0], 3);
+    draco::PseudoPointD<uint32_t> dest_src1(&dest[0], 3);
+
+    ASSERT_EQ(val_src1[0], 0);
+    ASSERT_EQ(val_src1[1], 1);
+    ASSERT_EQ(val_src1[2], 2);
+    ASSERT_EQ(dest_src1[0], 10);
+    ASSERT_EQ(dest_src1[1], 11);
+    ASSERT_EQ(dest_src1[2], 12);
+
+    ASSERT_NE(val_src1, dest_src1);
+
+    swap(val_src1, dest_src1);
+
+    ASSERT_EQ(dest_src1[0], 0);
+    ASSERT_EQ(dest_src1[1], 1);
+    ASSERT_EQ(dest_src1[2], 2);
+    ASSERT_EQ(val_src1[0], 10);
+    ASSERT_EQ(val_src1[1], 11);
+    ASSERT_EQ(val_src1[2], 12);
+
+    ASSERT_NE(val_src1, dest_src1);
+  }
+  void TestPseudoPointDEquality() {
+    draco::Point3ui val = {0, 1, 2};
+    draco::Point3ui dest = {0, 1, 2};
+    draco::PseudoPointD<uint32_t> val_src1(&val[0], 3);
+    draco::PseudoPointD<uint32_t> val_src2(&val[0], 3);
+    draco::PseudoPointD<uint32_t> dest_src1(&dest[0], 3);
+    draco::PseudoPointD<uint32_t> dest_src2(&dest[0], 3);
+
+    ASSERT_EQ(val_src1, val_src1);
+    ASSERT_EQ(val_src1, val_src2);
+    ASSERT_EQ(dest_src1, val_src1);
+    ASSERT_EQ(dest_src1, val_src2);
+    ASSERT_EQ(val_src2, val_src1);
+    ASSERT_EQ(val_src2, val_src2);
+    ASSERT_EQ(dest_src2, val_src1);
+    ASSERT_EQ(dest_src2, val_src2);
+
+    for (auto i = 0; i < 3; i++) {
+      ASSERT_EQ(val_src1[i], val_src1[i]);
+      ASSERT_EQ(val_src1[i], val_src2[i]);
+      ASSERT_EQ(dest_src1[i], val_src1[i]);
+      ASSERT_EQ(dest_src1[i], val_src2[i]);
+      ASSERT_EQ(val_src2[i], val_src1[i]);
+      ASSERT_EQ(val_src2[i], val_src2[i]);
+      ASSERT_EQ(dest_src2[i], val_src1[i]);
+      ASSERT_EQ(dest_src2[i], val_src2[i]);
+    }
+  }
+  void TestPseudoPointDInequality() {
+    draco::Point3ui val = {0, 1, 2};
+    draco::Point3ui dest = {1, 2, 3};
+    draco::PseudoPointD<uint32_t> val_src1(&val[0], 3);
+    draco::PseudoPointD<uint32_t> val_src2(&val[0], 3);
+    draco::PseudoPointD<uint32_t> dest_src1(&dest[0], 3);
+    draco::PseudoPointD<uint32_t> dest_src2(&dest[0], 3);
+
+    ASSERT_EQ(val_src1, val_src1);
+    ASSERT_EQ(val_src1, val_src2);
+    ASSERT_NE(dest_src1, val_src1);
+    ASSERT_NE(dest_src1, val_src2);
+    ASSERT_EQ(val_src2, val_src1);
+    ASSERT_EQ(val_src2, val_src2);
+    ASSERT_NE(dest_src2, val_src1);
+    ASSERT_NE(dest_src2, val_src2);
+
+    for (auto i = 0; i < 3; i++) {
+      ASSERT_EQ(val_src1[i], val_src1[i]);
+      ASSERT_EQ(val_src1[i], val_src2[i]);
+      ASSERT_NE(dest_src1[i], val_src1[i]);
+      ASSERT_NE(dest_src1[i], val_src2[i]);
+      ASSERT_EQ(val_src2[i], val_src1[i]);
+      ASSERT_EQ(val_src2[i], val_src2[i]);
+      ASSERT_NE(dest_src2[i], val_src1[i]);
+      ASSERT_NE(dest_src2[i], val_src2[i]);
+    }
+  }
+};
+
+TEST_F(PointDVectorTest, VectorTest) {
+  TestSize<uint32_t>();
+  TestContentsDiscrete<uint32_t>();
+  TestContentsContiguous<uint32_t>();
+  TestContentsCopy<uint32_t>();
+  TestIterator<uint32_t>();
+  TestPoint3Iterator<uint32_t>();
+}
+TEST_F(PointDVectorTest, PseudoPointDTest) {
+  TestPseudoPointDSwap();
+  TestPseudoPointDEquality();
+  TestPseudoPointDInequality();
+}
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/points_sequencer.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/points_sequencer.h
new file mode 100644
index 000000000..2f4f7e16d
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/points_sequencer.h
@@ -0,0 +1,63 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_POINTS_SEQUENCER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_POINTS_SEQUENCER_H_
+
+#include <vector>
+
+#include "draco/attributes/point_attribute.h"
+
+namespace draco {
+
+// Class for generating a sequence of point ids that can be used to encode
+// or decode attribute values in a specific order.
+// See sequential_attribute_encoders/decoders_controller.h for more details.
+class PointsSequencer {
+ public:
+  PointsSequencer() : out_point_ids_(nullptr) {}
+  virtual ~PointsSequencer() = default;
+
+  // Fills the |out_point_ids| with the generated sequence of point ids.
+  bool GenerateSequence(std::vector<PointIndex> *out_point_ids) {
+    out_point_ids_ = out_point_ids;
+    return GenerateSequenceInternal();
+  }
+
+  // Appends a point to the sequence.
+  void AddPointId(PointIndex point_id) { out_point_ids_->push_back(point_id); }
+
+  // Sets the correct mapping between point ids and value ids. I.e., the inverse
+  // of the |out_point_ids|. In general, |out_point_ids_| does not contain
+  // sufficient information to compute the inverse map, because not all point
+  // ids are necessarily contained within the map.
+  // Must be implemented for sequencers that are used by attribute decoders.
+  virtual bool UpdatePointToAttributeIndexMapping(PointAttribute * /* attr */) {
+    return false;
+  }
+
+ protected:
+  // Method that needs to be implemented by the derived classes. The
+  // implementation is responsible for filling |out_point_ids_| with the valid
+  // sequence of point ids.
+  virtual bool GenerateSequenceInternal() = 0;
+  std::vector<PointIndex> *out_point_ids() const { return out_point_ids_; }
+
+ private:
+  std::vector<PointIndex> *out_point_ids_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_POINTS_SEQUENCER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_decoder.h
new file mode 100644
index 000000000..36c124baa
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_decoder.h
@@ -0,0 +1,231 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_DECODER_H_
+
+#include <algorithm>
+#include <cmath>
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_shared.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h"
+#include "draco/compression/bit_coders/rans_bit_decoder.h"
+#include "draco/core/varint_decoding.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Decoder for predictions encoded with the constrained multi-parallelogram
+// encoder. See the corresponding encoder for more details about the prediction
+// method.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeConstrainedMultiParallelogramDecoder
+    : public MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType =
+      typename PredictionSchemeDecoder<DataTypeT, TransformT>::CorrType;
+  using CornerTable = typename MeshDataT::CornerTable;
+
+  explicit MeshPredictionSchemeConstrainedMultiParallelogramDecoder(
+      const PointAttribute *attribute)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute),
+        selected_mode_(Mode::OPTIMAL_MULTI_PARALLELOGRAM) {}
+  MeshPredictionSchemeConstrainedMultiParallelogramDecoder(
+      const PointAttribute *attribute, const TransformT &transform,
+      const MeshDataT &mesh_data)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data),
+        selected_mode_(Mode::OPTIMAL_MULTI_PARALLELOGRAM) {}
+
+  bool ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                             int size, int num_components,
+                             const PointIndex *entry_to_point_id_map) override;
+
+  bool DecodePredictionData(DecoderBuffer *buffer) override;
+
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM;
+  }
+
+  bool IsInitialized() const override {
+    return this->mesh_data().IsInitialized();
+  }
+
+ private:
+  typedef constrained_multi_parallelogram::Mode Mode;
+  static constexpr int kMaxNumParallelograms =
+      constrained_multi_parallelogram::kMaxNumParallelograms;
+  // Crease edges are used to store whether any given edge should be used for
+  // parallelogram prediction or not. New values are added in the order in which
+  // the edges are processed. For better compression, the flags are stored in
+  // in separate contexts based on the number of available parallelograms at a
+  // given vertex.
+  std::vector<bool> is_crease_edge_[kMaxNumParallelograms];
+  Mode selected_mode_;
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeConstrainedMultiParallelogramDecoder<
+    DataTypeT, TransformT, MeshDataT>::
+    ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                          int /* size */, int num_components,
+                          const PointIndex * /* entry_to_point_id_map */) {
+  this->transform().Init(num_components);
+
+  // Predicted values for all simple parallelograms encountered at any given
+  // vertex.
+  std::vector<DataTypeT> pred_vals[kMaxNumParallelograms];
+  for (int i = 0; i < kMaxNumParallelograms; ++i) {
+    pred_vals[i].resize(num_components, 0);
+  }
+  this->transform().ComputeOriginalValue(pred_vals[0].data(), in_corr,
+                                         out_data);
+
+  const CornerTable *const table = this->mesh_data().corner_table();
+  const std::vector<int32_t> *const vertex_to_data_map =
+      this->mesh_data().vertex_to_data_map();
+
+  // Current position in the |is_crease_edge_| array for each context.
+  std::vector<int> is_crease_edge_pos(kMaxNumParallelograms, 0);
+
+  // Used to store predicted value for multi-parallelogram prediction.
+  std::vector<DataTypeT> multi_pred_vals(num_components);
+
+  const int corner_map_size =
+      static_cast<int>(this->mesh_data().data_to_corner_map()->size());
+  for (int p = 1; p < corner_map_size; ++p) {
+    const CornerIndex start_corner_id =
+        this->mesh_data().data_to_corner_map()->at(p);
+
+    CornerIndex corner_id(start_corner_id);
+    int num_parallelograms = 0;
+    bool first_pass = true;
+    while (corner_id != kInvalidCornerIndex) {
+      if (ComputeParallelogramPrediction(
+              p, corner_id, table, *vertex_to_data_map, out_data,
+              num_components, &(pred_vals[num_parallelograms][0]))) {
+        // Parallelogram prediction applied and stored in
+        // |pred_vals[num_parallelograms]|
+        ++num_parallelograms;
+        // Stop processing when we reach the maximum number of allowed
+        // parallelograms.
+        if (num_parallelograms == kMaxNumParallelograms) {
+          break;
+        }
+      }
+
+      // Proceed to the next corner attached to the vertex. First swing left
+      // and if we reach a boundary, swing right from the start corner.
+      if (first_pass) {
+        corner_id = table->SwingLeft(corner_id);
+      } else {
+        corner_id = table->SwingRight(corner_id);
+      }
+      if (corner_id == start_corner_id) {
+        break;
+      }
+      if (corner_id == kInvalidCornerIndex && first_pass) {
+        first_pass = false;
+        corner_id = table->SwingRight(start_corner_id);
+      }
+    }
+
+    // Check which of the available parallelograms are actually used and compute
+    // the final predicted value.
+    int num_used_parallelograms = 0;
+    if (num_parallelograms > 0) {
+      for (int i = 0; i < num_components; ++i) {
+        multi_pred_vals[i] = 0;
+      }
+      // Check which parallelograms are actually used.
+      for (int i = 0; i < num_parallelograms; ++i) {
+        const int context = num_parallelograms - 1;
+        const int pos = is_crease_edge_pos[context]++;
+        if (is_crease_edge_[context].size() <= pos) {
+          return false;
+        }
+        const bool is_crease = is_crease_edge_[context][pos];
+        if (!is_crease) {
+          ++num_used_parallelograms;
+          for (int j = 0; j < num_components; ++j) {
+            multi_pred_vals[j] += pred_vals[i][j];
+          }
+        }
+      }
+    }
+    const int dst_offset = p * num_components;
+    if (num_used_parallelograms == 0) {
+      // No parallelogram was valid.
+      // We use the last decoded point as a reference.
+      const int src_offset = (p - 1) * num_components;
+      this->transform().ComputeOriginalValue(
+          out_data + src_offset, in_corr + dst_offset, out_data + dst_offset);
+    } else {
+      // Compute the correction from the predicted value.
+      for (int c = 0; c < num_components; ++c) {
+        multi_pred_vals[c] /= num_used_parallelograms;
+      }
+      this->transform().ComputeOriginalValue(
+          multi_pred_vals.data(), in_corr + dst_offset, out_data + dst_offset);
+    }
+  }
+  return true;
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeConstrainedMultiParallelogramDecoder<
+    DataTypeT, TransformT, MeshDataT>::DecodePredictionData(DecoderBuffer
+                                                                *buffer) {
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (buffer->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+    // Decode prediction mode.
+    uint8_t mode;
+    if (!buffer->Decode(&mode)) {
+      return false;
+    }
+
+    if (mode != Mode::OPTIMAL_MULTI_PARALLELOGRAM) {
+      // Unsupported mode.
+      return false;
+    }
+  }
+#endif
+
+  // Encode selected edges using separate rans bit coder for each context.
+  for (int i = 0; i < kMaxNumParallelograms; ++i) {
+    uint32_t num_flags;
+    if (!DecodeVarint<uint32_t>(&num_flags, buffer)) {
+      return false;
+    }
+    if (num_flags > 0) {
+      is_crease_edge_[i].resize(num_flags);
+      RAnsBitDecoder decoder;
+      if (!decoder.StartDecoding(buffer)) {
+        return false;
+      }
+      for (uint32_t j = 0; j < num_flags; ++j) {
+        is_crease_edge_[i][j] = decoder.DecodeNextBit();
+      }
+      decoder.EndDecoding();
+    }
+  }
+  return MeshPredictionSchemeDecoder<DataTypeT, TransformT,
+                                     MeshDataT>::DecodePredictionData(buffer);
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_encoder.h
new file mode 100644
index 000000000..77df8ee24
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_encoder.h
@@ -0,0 +1,414 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_ENCODER_H_
+
+#include <algorithm>
+#include <cmath>
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_shared.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h"
+#include "draco/compression/bit_coders/rans_bit_encoder.h"
+#include "draco/compression/entropy/shannon_entropy.h"
+#include "draco/core/varint_encoding.h"
+
+namespace draco {
+
+// Compared to standard multi-parallelogram, constrained multi-parallelogram can
+// explicitly select which of the available parallelograms are going to be used
+// for the prediction by marking crease edges between two triangles. This
+// requires storing extra data, but it allows the predictor to avoid using
+// parallelograms that would lead to poor predictions. For improved efficiency,
+// our current implementation limits the maximum number of used parallelograms
+// to four, which covers >95% of the cases (on average, there are only two
+// parallelograms available for any given vertex).
+// All bits of the explicitly chosen configuration are stored together in a
+// single context chosen by the total number of parallelograms available to
+// choose from.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeConstrainedMultiParallelogramEncoder
+    : public MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType =
+      typename PredictionSchemeEncoder<DataTypeT, TransformT>::CorrType;
+  using CornerTable = typename MeshDataT::CornerTable;
+
+  explicit MeshPredictionSchemeConstrainedMultiParallelogramEncoder(
+      const PointAttribute *attribute)
+      : MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT>(
+            attribute),
+        selected_mode_(Mode::OPTIMAL_MULTI_PARALLELOGRAM) {}
+  MeshPredictionSchemeConstrainedMultiParallelogramEncoder(
+      const PointAttribute *attribute, const TransformT &transform,
+      const MeshDataT &mesh_data)
+      : MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data),
+        selected_mode_(Mode::OPTIMAL_MULTI_PARALLELOGRAM) {}
+
+  bool ComputeCorrectionValues(
+      const DataTypeT *in_data, CorrType *out_corr, int size,
+      int num_components, const PointIndex *entry_to_point_id_map) override;
+
+  bool EncodePredictionData(EncoderBuffer *buffer) override;
+
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM;
+  }
+
+  bool IsInitialized() const override {
+    return this->mesh_data().IsInitialized();
+  }
+
+ private:
+  // Function used to compute number of bits needed to store overhead of the
+  // predictor. In this case, we consider overhead to be all bits that mark
+  // whether a parallelogram should be used for prediction or not. The input
+  // to this method is the total number of parallelograms that were evaluated so
+  // far(total_parallelogram), and the number of parallelograms we decided to
+  // use for prediction (total_used_parallelograms).
+  // Returns number of bits required to store the overhead.
+  int64_t ComputeOverheadBits(int64_t total_used_parallelograms,
+                              int64_t total_parallelogram) const {
+    // For now we assume RAns coding for the bits where the total required size
+    // is directly correlated to the binary entropy of the input stream.
+    // TODO(ostava): This should be generalized in case we use other binary
+    // coding scheme.
+    const double entropy = ComputeBinaryShannonEntropy(
+        static_cast<uint32_t>(total_parallelogram),
+        static_cast<uint32_t>(total_used_parallelograms));
+
+    // Round up to the nearest full bit.
+    return static_cast<int64_t>(
+        ceil(static_cast<double>(total_parallelogram) * entropy));
+  }
+
+  // Struct that contains data used for measuring the error of each available
+  // parallelogram configuration.
+  struct Error {
+    Error() : num_bits(0), residual_error(0) {}
+
+    // Primary metric: number of bits required to store the data as a result of
+    // the selected prediction configuration.
+    int num_bits;
+    // Secondary metric: absolute difference of residuals for the given
+    // configuration.
+    int residual_error;
+
+    bool operator<(const Error &e) const {
+      if (num_bits < e.num_bits) {
+        return true;
+      }
+      if (num_bits > e.num_bits) {
+        return false;
+      }
+      return residual_error < e.residual_error;
+    }
+  };
+
+  // Computes error for predicting |predicted_val| instead of |actual_val|.
+  // Error is computed as the number of bits needed to encode the difference
+  // between the values.
+  Error ComputeError(const DataTypeT *predicted_val,
+                     const DataTypeT *actual_val, int *out_residuals,
+                     int num_components) {
+    Error error;
+
+    for (int i = 0; i < num_components; ++i) {
+      const int dif = (predicted_val[i] - actual_val[i]);
+      error.residual_error += std::abs(dif);
+      out_residuals[i] = dif;
+      // Entropy needs unsigned symbols, so convert the signed difference to an
+      // unsigned symbol.
+      entropy_symbols_[i] = ConvertSignedIntToSymbol(dif);
+    }
+
+    // Generate entropy data for case that this configuration was used.
+    // Note that the entropy stream is NOT updated in this case.
+    const auto entropy_data =
+        entropy_tracker_.Peek(entropy_symbols_.data(), num_components);
+
+    error.num_bits = entropy_tracker_.GetNumberOfDataBits(entropy_data) +
+                     entropy_tracker_.GetNumberOfRAnsTableBits(entropy_data);
+    return error;
+  }
+
+  typedef constrained_multi_parallelogram::Mode Mode;
+  static constexpr int kMaxNumParallelograms =
+      constrained_multi_parallelogram::kMaxNumParallelograms;
+  // Crease edges are used to store whether any given edge should be used for
+  // parallelogram prediction or not. New values are added in the order in which
+  // the edges are processed. For better compression, the flags are stored in
+  // in separate contexts based on the number of available parallelograms at a
+  // given vertex.
+  // TODO(draco-eng) reconsider std::vector<bool> (performance/space).
+  std::vector<bool> is_crease_edge_[kMaxNumParallelograms];
+  Mode selected_mode_;
+
+  ShannonEntropyTracker entropy_tracker_;
+
+  // Temporary storage for symbols that are fed into the |entropy_stream|.
+  // Always contains only |num_components| entries.
+  std::vector<uint32_t> entropy_symbols_;
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeConstrainedMultiParallelogramEncoder<
+    DataTypeT, TransformT, MeshDataT>::
+    ComputeCorrectionValues(const DataTypeT *in_data, CorrType *out_corr,
+                            int size, int num_components,
+                            const PointIndex * /* entry_to_point_id_map */) {
+  this->transform().Init(in_data, size, num_components);
+  const CornerTable *const table = this->mesh_data().corner_table();
+  const std::vector<int32_t> *const vertex_to_data_map =
+      this->mesh_data().vertex_to_data_map();
+
+  // Predicted values for all simple parallelograms encountered at any given
+  // vertex.
+  std::vector<DataTypeT> pred_vals[kMaxNumParallelograms];
+  for (int i = 0; i < kMaxNumParallelograms; ++i) {
+    pred_vals[i].resize(num_components);
+  }
+  // Used to store predicted value for various multi-parallelogram predictions
+  // (combinations of simple parallelogram predictions).
+  std::vector<DataTypeT> multi_pred_vals(num_components);
+  entropy_symbols_.resize(num_components);
+
+  // Struct for holding data about prediction configuration for different sets
+  // of used parallelograms.
+  struct PredictionConfiguration {
+    PredictionConfiguration()
+        : error(), configuration(0), num_used_parallelograms(0) {}
+    Error error;
+    uint8_t configuration;  // Bitfield, 1 use parallelogram, 0 don't use it.
+    int num_used_parallelograms;
+    std::vector<DataTypeT> predicted_value;
+    std::vector<int32_t> residuals;
+  };
+
+  // Bit-field used for computing permutations of excluded edges
+  // (parallelograms).
+  bool exluded_parallelograms[kMaxNumParallelograms];
+
+  // Data about the number of used parallelogram and total number of available
+  // parallelogram for each context. Used to compute overhead needed for storing
+  // the parallelogram choices made by the encoder.
+  int64_t total_used_parallelograms[kMaxNumParallelograms] = {0};
+  int64_t total_parallelograms[kMaxNumParallelograms] = {0};
+
+  std::vector<int> current_residuals(num_components);
+
+  // We start processing the vertices from the end because this prediction uses
+  // data from previous entries that could be overwritten when an entry is
+  // processed.
+  for (int p =
+           static_cast<int>(this->mesh_data().data_to_corner_map()->size()) - 1;
+       p > 0; --p) {
+    const CornerIndex start_corner_id =
+        this->mesh_data().data_to_corner_map()->at(p);
+
+    // Go over all corners attached to the vertex and compute the predicted
+    // value from the parallelograms defined by their opposite faces.
+    CornerIndex corner_id(start_corner_id);
+    int num_parallelograms = 0;
+    bool first_pass = true;
+    while (corner_id != kInvalidCornerIndex) {
+      if (ComputeParallelogramPrediction(
+              p, corner_id, table, *vertex_to_data_map, in_data, num_components,
+              &(pred_vals[num_parallelograms][0]))) {
+        // Parallelogram prediction applied and stored in
+        // |pred_vals[num_parallelograms]|
+        ++num_parallelograms;
+        // Stop processing when we reach the maximum number of allowed
+        // parallelograms.
+        if (num_parallelograms == kMaxNumParallelograms) {
+          break;
+        }
+      }
+
+      // Proceed to the next corner attached to the vertex. First swing left
+      // and if we reach a boundary, swing right from the start corner.
+      if (first_pass) {
+        corner_id = table->SwingLeft(corner_id);
+      } else {
+        corner_id = table->SwingRight(corner_id);
+      }
+      if (corner_id == start_corner_id) {
+        break;
+      }
+      if (corner_id == kInvalidCornerIndex && first_pass) {
+        first_pass = false;
+        corner_id = table->SwingRight(start_corner_id);
+      }
+    }
+
+    // Offset to the target (destination) vertex.
+    const int dst_offset = p * num_components;
+    Error error;
+
+    // Compute all prediction errors for all possible configurations of
+    // available parallelograms.
+
+    // Variable for holding the best configuration that has been found so far.
+    PredictionConfiguration best_prediction;
+
+    // Compute delta coding error (configuration when no parallelogram is
+    // selected).
+    const int src_offset = (p - 1) * num_components;
+    error = ComputeError(in_data + src_offset, in_data + dst_offset,
+                         &current_residuals[0], num_components);
+
+    if (num_parallelograms > 0) {
+      total_parallelograms[num_parallelograms - 1] += num_parallelograms;
+      const int64_t new_overhead_bits =
+          ComputeOverheadBits(total_used_parallelograms[num_parallelograms - 1],
+                              total_parallelograms[num_parallelograms - 1]);
+      error.num_bits += new_overhead_bits;
+    }
+
+    best_prediction.error = error;
+    best_prediction.configuration = 0;
+    best_prediction.num_used_parallelograms = 0;
+    best_prediction.predicted_value.assign(
+        in_data + src_offset, in_data + src_offset + num_components);
+    best_prediction.residuals.assign(current_residuals.begin(),
+                                     current_residuals.end());
+
+    // Compute prediction error for different cases of used parallelograms.
+    for (int num_used_parallelograms = 1;
+         num_used_parallelograms <= num_parallelograms;
+         ++num_used_parallelograms) {
+      // Mark all parallelograms as excluded.
+      std::fill(exluded_parallelograms,
+                exluded_parallelograms + num_parallelograms, true);
+      // TODO(draco-eng) maybe this should be another std::fill.
+      // Mark the first |num_used_parallelograms| as not excluded.
+      for (int j = 0; j < num_used_parallelograms; ++j) {
+        exluded_parallelograms[j] = false;
+      }
+      // Permute over the excluded edges and compute error for each
+      // configuration (permutation of excluded parallelograms).
+      do {
+        // Reset the multi-parallelogram predicted values.
+        for (int j = 0; j < num_components; ++j) {
+          multi_pred_vals[j] = 0;
+        }
+        uint8_t configuration = 0;
+        for (int j = 0; j < num_parallelograms; ++j) {
+          if (exluded_parallelograms[j]) {
+            continue;
+          }
+          for (int c = 0; c < num_components; ++c) {
+            multi_pred_vals[c] += pred_vals[j][c];
+          }
+          // Set jth bit of the configuration.
+          configuration |= (1 << j);
+        }
+
+        for (int j = 0; j < num_components; ++j) {
+          multi_pred_vals[j] /= num_used_parallelograms;
+        }
+        error = ComputeError(multi_pred_vals.data(), in_data + dst_offset,
+                             &current_residuals[0], num_components);
+        if (num_parallelograms > 0) {
+          const int64_t new_overhead_bits = ComputeOverheadBits(
+              total_used_parallelograms[num_parallelograms - 1] +
+                  num_used_parallelograms,
+              total_parallelograms[num_parallelograms - 1]);
+
+          // Add overhead bits to the total error.
+          error.num_bits += new_overhead_bits;
+        }
+        if (error < best_prediction.error) {
+          best_prediction.error = error;
+          best_prediction.configuration = configuration;
+          best_prediction.num_used_parallelograms = num_used_parallelograms;
+          best_prediction.predicted_value.assign(multi_pred_vals.begin(),
+                                                 multi_pred_vals.end());
+          best_prediction.residuals.assign(current_residuals.begin(),
+                                           current_residuals.end());
+        }
+      } while (std::next_permutation(
+          exluded_parallelograms, exluded_parallelograms + num_parallelograms));
+    }
+    if (num_parallelograms > 0) {
+      total_used_parallelograms[num_parallelograms - 1] +=
+          best_prediction.num_used_parallelograms;
+    }
+
+    // Update the entropy stream by adding selected residuals as symbols to the
+    // stream.
+    for (int i = 0; i < num_components; ++i) {
+      entropy_symbols_[i] =
+          ConvertSignedIntToSymbol(best_prediction.residuals[i]);
+    }
+    entropy_tracker_.Push(entropy_symbols_.data(), num_components);
+
+    for (int i = 0; i < num_parallelograms; ++i) {
+      if ((best_prediction.configuration & (1 << i)) == 0) {
+        // Parallelogram not used, mark the edge as crease.
+        is_crease_edge_[num_parallelograms - 1].push_back(true);
+      } else {
+        // Parallelogram used. Add it to the predicted value and mark the
+        // edge as not a crease.
+        is_crease_edge_[num_parallelograms - 1].push_back(false);
+      }
+    }
+    this->transform().ComputeCorrection(in_data + dst_offset,
+                                        best_prediction.predicted_value.data(),
+                                        out_corr + dst_offset);
+  }
+  // First element is always fixed because it cannot be predicted.
+  for (int i = 0; i < num_components; ++i) {
+    pred_vals[0][i] = static_cast<DataTypeT>(0);
+  }
+  this->transform().ComputeCorrection(in_data, pred_vals[0].data(), out_corr);
+  return true;
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeConstrainedMultiParallelogramEncoder<
+    DataTypeT, TransformT, MeshDataT>::EncodePredictionData(EncoderBuffer
+                                                                *buffer) {
+  // Encode selected edges using separate rans bit coder for each context.
+  for (int i = 0; i < kMaxNumParallelograms; ++i) {
+    // |i| is the context based on the number of available parallelograms, which
+    // is always equal to |i + 1|.
+    const int num_used_parallelograms = i + 1;
+    EncodeVarint<uint32_t>(is_crease_edge_[i].size(), buffer);
+    if (is_crease_edge_[i].size()) {
+      RAnsBitEncoder encoder;
+      encoder.StartEncoding();
+      // Encode the crease edge flags in the reverse vertex order that is needed
+      // be the decoder. Note that for the currently supported mode, each vertex
+      // has exactly |num_used_parallelograms| edges that need to be encoded.
+      for (int j = static_cast<int>(is_crease_edge_[i].size()) -
+                   num_used_parallelograms;
+           j >= 0; j -= num_used_parallelograms) {
+        // Go over all edges of the current vertex.
+        for (int k = 0; k < num_used_parallelograms; ++k) {
+          encoder.EncodeBit(is_crease_edge_[i][j + k]);
+        }
+      }
+      encoder.EndEncoding(buffer);
+    }
+  }
+  return MeshPredictionSchemeEncoder<DataTypeT, TransformT,
+                                     MeshDataT>::EncodePredictionData(buffer);
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_shared.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_shared.h
new file mode 100644
index 000000000..c7a4e351a
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_shared.h
@@ -0,0 +1,34 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_SHARED_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_SHARED_H_
+
+namespace draco {
+
+// Data shared between constrained multi-parallelogram encoder and decoder.
+namespace constrained_multi_parallelogram {
+
+enum Mode {
+  // Selects the optimal multi-parallelogram from up to 4 available
+  // parallelograms.
+  OPTIMAL_MULTI_PARALLELOGRAM = 0,
+};
+
+static constexpr int kMaxNumParallelograms = 4;
+
+}  // namespace constrained_multi_parallelogram
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_SHARED_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_data.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_data.h
new file mode 100644
index 000000000..2960a5e71
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_data.h
@@ -0,0 +1,72 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_DATA_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_DATA_H_
+
+#include "draco/mesh/corner_table.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Class stores data about the connectivity data of the mesh and information
+// about how the connectivity was encoded/decoded.
+template <class CornerTableT>
+class MeshPredictionSchemeData {
+ public:
+  typedef CornerTableT CornerTable;
+  MeshPredictionSchemeData()
+      : mesh_(nullptr),
+        corner_table_(nullptr),
+        vertex_to_data_map_(nullptr),
+        data_to_corner_map_(nullptr) {}
+
+  void Set(const Mesh *mesh, const CornerTable *table,
+           const std::vector<CornerIndex> *data_to_corner_map,
+           const std::vector<int32_t> *vertex_to_data_map) {
+    mesh_ = mesh;
+    corner_table_ = table;
+    data_to_corner_map_ = data_to_corner_map;
+    vertex_to_data_map_ = vertex_to_data_map;
+  }
+
+  const Mesh *mesh() const { return mesh_; }
+  const CornerTable *corner_table() const { return corner_table_; }
+  const std::vector<int32_t> *vertex_to_data_map() const {
+    return vertex_to_data_map_;
+  }
+  const std::vector<CornerIndex> *data_to_corner_map() const {
+    return data_to_corner_map_;
+  }
+  bool IsInitialized() const {
+    return mesh_ != nullptr && corner_table_ != nullptr &&
+           vertex_to_data_map_ != nullptr && data_to_corner_map_ != nullptr;
+  }
+
+ private:
+  const Mesh *mesh_;
+  const CornerTable *corner_table_;
+
+  // Mapping between vertices and their encoding order. I.e. when an attribute
+  // entry on a given vertex was encoded.
+  const std::vector<int32_t> *vertex_to_data_map_;
+
+  // Array that stores which corner was processed when a given attribute entry
+  // was encoded or decoded.
+  const std::vector<CornerIndex> *data_to_corner_map_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_DATA_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h
new file mode 100644
index 000000000..6694a981c
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h
@@ -0,0 +1,46 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_DECODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_data.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_decoder.h"
+
+namespace draco {
+
+// Base class for all mesh prediction scheme decoders that use the mesh
+// connectivity data. |MeshDataT| can be any class that provides the same
+// interface as the PredictionSchemeMeshData class.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeDecoder
+    : public PredictionSchemeDecoder<DataTypeT, TransformT> {
+ public:
+  typedef MeshDataT MeshData;
+  MeshPredictionSchemeDecoder(const PointAttribute *attribute,
+                              const TransformT &transform,
+                              const MeshDataT &mesh_data)
+      : PredictionSchemeDecoder<DataTypeT, TransformT>(attribute, transform),
+        mesh_data_(mesh_data) {}
+
+ protected:
+  const MeshData &mesh_data() const { return mesh_data_; }
+
+ private:
+  MeshData mesh_data_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h
new file mode 100644
index 000000000..ab3c81a39
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h
@@ -0,0 +1,46 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_ENCODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_data.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_encoder.h"
+
+namespace draco {
+
+// Base class for all mesh prediction scheme encoders that use the mesh
+// connectivity data. |MeshDataT| can be any class that provides the same
+// interface as the PredictionSchemeMeshData class.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeEncoder
+    : public PredictionSchemeEncoder<DataTypeT, TransformT> {
+ public:
+  typedef MeshDataT MeshData;
+  MeshPredictionSchemeEncoder(const PointAttribute *attribute,
+                              const TransformT &transform,
+                              const MeshDataT &mesh_data)
+      : PredictionSchemeEncoder<DataTypeT, TransformT>(attribute, transform),
+        mesh_data_(mesh_data) {}
+
+ protected:
+  const MeshData &mesh_data() const { return mesh_data_; }
+
+ private:
+  MeshData mesh_data_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_decoder.h
new file mode 100644
index 000000000..da1387a30
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_decoder.h
@@ -0,0 +1,172 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_DECODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_area.h"
+#include "draco/compression/bit_coders/rans_bit_decoder.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// See MeshPredictionSchemeGeometricNormalEncoder for documentation.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeGeometricNormalDecoder
+    : public MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType = typename MeshPredictionSchemeDecoder<DataTypeT, TransformT,
+                                                        MeshDataT>::CorrType;
+  MeshPredictionSchemeGeometricNormalDecoder(const PointAttribute *attribute,
+                                             const TransformT &transform,
+                                             const MeshDataT &mesh_data)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data),
+        predictor_(mesh_data) {}
+
+ private:
+  MeshPredictionSchemeGeometricNormalDecoder() {}
+
+ public:
+  bool ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                             int size, int num_components,
+                             const PointIndex *entry_to_point_id_map) override;
+
+  bool DecodePredictionData(DecoderBuffer *buffer) override;
+
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_GEOMETRIC_NORMAL;
+  }
+
+  bool IsInitialized() const override {
+    if (!predictor_.IsInitialized()) {
+      return false;
+    }
+    if (!this->mesh_data().IsInitialized()) {
+      return false;
+    }
+    if (!octahedron_tool_box_.IsInitialized()) {
+      return false;
+    }
+    return true;
+  }
+
+  int GetNumParentAttributes() const override { return 1; }
+
+  GeometryAttribute::Type GetParentAttributeType(int i) const override {
+    DRACO_DCHECK_EQ(i, 0);
+    (void)i;
+    return GeometryAttribute::POSITION;
+  }
+
+  bool SetParentAttribute(const PointAttribute *att) override {
+    if (att->attribute_type() != GeometryAttribute::POSITION) {
+      return false;  // Invalid attribute type.
+    }
+    if (att->num_components() != 3) {
+      return false;  // Currently works only for 3 component positions.
+    }
+    predictor_.SetPositionAttribute(*att);
+    return true;
+  }
+  void SetQuantizationBits(int q) {
+    octahedron_tool_box_.SetQuantizationBits(q);
+  }
+
+ private:
+  MeshPredictionSchemeGeometricNormalPredictorArea<DataTypeT, TransformT,
+                                                   MeshDataT>
+      predictor_;
+  OctahedronToolBox octahedron_tool_box_;
+  RAnsBitDecoder flip_normal_bit_decoder_;
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeGeometricNormalDecoder<
+    DataTypeT, TransformT,
+    MeshDataT>::ComputeOriginalValues(const CorrType *in_corr,
+                                      DataTypeT *out_data, int /* size */,
+                                      int num_components,
+                                      const PointIndex *entry_to_point_id_map) {
+  this->SetQuantizationBits(this->transform().quantization_bits());
+  predictor_.SetEntryToPointIdMap(entry_to_point_id_map);
+  DRACO_DCHECK(this->IsInitialized());
+
+  // Expecting in_data in octahedral coordinates, i.e., portable attribute.
+  DRACO_DCHECK_EQ(num_components, 2);
+
+  const int corner_map_size =
+      static_cast<int>(this->mesh_data().data_to_corner_map()->size());
+
+  VectorD<int32_t, 3> pred_normal_3d;
+  int32_t pred_normal_oct[2];
+
+  for (int data_id = 0; data_id < corner_map_size; ++data_id) {
+    const CornerIndex corner_id =
+        this->mesh_data().data_to_corner_map()->at(data_id);
+    predictor_.ComputePredictedValue(corner_id, pred_normal_3d.data());
+
+    // Compute predicted octahedral coordinates.
+    octahedron_tool_box_.CanonicalizeIntegerVector(pred_normal_3d.data());
+    DRACO_DCHECK_EQ(pred_normal_3d.AbsSum(),
+                    octahedron_tool_box_.center_value());
+    if (flip_normal_bit_decoder_.DecodeNextBit()) {
+      pred_normal_3d = -pred_normal_3d;
+    }
+    octahedron_tool_box_.IntegerVectorToQuantizedOctahedralCoords(
+        pred_normal_3d.data(), pred_normal_oct, pred_normal_oct + 1);
+
+    const int data_offset = data_id * 2;
+    this->transform().ComputeOriginalValue(
+        pred_normal_oct, in_corr + data_offset, out_data + data_offset);
+  }
+  flip_normal_bit_decoder_.EndDecoding();
+  return true;
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeGeometricNormalDecoder<
+    DataTypeT, TransformT, MeshDataT>::DecodePredictionData(DecoderBuffer
+                                                                *buffer) {
+  // Get data needed for transform
+  if (!this->transform().DecodeTransformData(buffer)) {
+    return false;
+  }
+
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (buffer->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+    uint8_t prediction_mode;
+    if (!buffer->Decode(&prediction_mode)) {
+      return false;
+    }
+
+    if (!predictor_.SetNormalPredictionMode(
+            NormalPredictionMode(prediction_mode))) {
+      return false;
+    }
+  }
+#endif
+
+  // Init normal flips.
+  if (!flip_normal_bit_decoder_.StartDecoding(buffer)) {
+    return false;
+  }
+
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_encoder.h
new file mode 100644
index 000000000..cf146f83a
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_encoder.h
@@ -0,0 +1,180 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_ENCODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_area.h"
+#include "draco/compression/bit_coders/rans_bit_encoder.h"
+#include "draco/compression/config/compression_shared.h"
+
+namespace draco {
+
+// Prediction scheme for normals based on the underlying geometry.
+// At a smooth vertices normals are computed by weighting the normals of
+// adjacent faces with the area of these faces. At seams, the same approach
+// applies for seam corners.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeGeometricNormalEncoder
+    : public MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType = typename MeshPredictionSchemeEncoder<DataTypeT, TransformT,
+                                                        MeshDataT>::CorrType;
+  MeshPredictionSchemeGeometricNormalEncoder(const PointAttribute *attribute,
+                                             const TransformT &transform,
+                                             const MeshDataT &mesh_data)
+      : MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data),
+        predictor_(mesh_data) {}
+
+  bool ComputeCorrectionValues(
+      const DataTypeT *in_data, CorrType *out_corr, int size,
+      int num_components, const PointIndex *entry_to_point_id_map) override;
+
+  bool EncodePredictionData(EncoderBuffer *buffer) override;
+
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_GEOMETRIC_NORMAL;
+  }
+
+  bool IsInitialized() const override {
+    if (!predictor_.IsInitialized()) {
+      return false;
+    }
+    if (!this->mesh_data().IsInitialized()) {
+      return false;
+    }
+    return true;
+  }
+
+  int GetNumParentAttributes() const override { return 1; }
+
+  GeometryAttribute::Type GetParentAttributeType(int i) const override {
+    DRACO_DCHECK_EQ(i, 0);
+    (void)i;
+    return GeometryAttribute::POSITION;
+  }
+
+  bool SetParentAttribute(const PointAttribute *att) override {
+    if (att->attribute_type() != GeometryAttribute::POSITION) {
+      return false;  // Invalid attribute type.
+    }
+    if (att->num_components() != 3) {
+      return false;  // Currently works only for 3 component positions.
+    }
+    predictor_.SetPositionAttribute(*att);
+    return true;
+  }
+
+ private:
+  void SetQuantizationBits(int q) {
+    DRACO_DCHECK_GE(q, 2);
+    DRACO_DCHECK_LE(q, 30);
+    octahedron_tool_box_.SetQuantizationBits(q);
+  }
+  MeshPredictionSchemeGeometricNormalPredictorArea<DataTypeT, TransformT,
+                                                   MeshDataT>
+      predictor_;
+
+  OctahedronToolBox octahedron_tool_box_;
+  RAnsBitEncoder flip_normal_bit_encoder_;
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeGeometricNormalEncoder<DataTypeT, TransformT,
+                                                MeshDataT>::
+    ComputeCorrectionValues(const DataTypeT *in_data, CorrType *out_corr,
+                            int size, int num_components,
+                            const PointIndex *entry_to_point_id_map) {
+  this->SetQuantizationBits(this->transform().quantization_bits());
+  predictor_.SetEntryToPointIdMap(entry_to_point_id_map);
+  DRACO_DCHECK(this->IsInitialized());
+  // Expecting in_data in octahedral coordinates, i.e., portable attribute.
+  DRACO_DCHECK_EQ(num_components, 2);
+
+  flip_normal_bit_encoder_.StartEncoding();
+
+  const int corner_map_size =
+      static_cast<int>(this->mesh_data().data_to_corner_map()->size());
+
+  VectorD<int32_t, 3> pred_normal_3d;
+  VectorD<int32_t, 2> pos_pred_normal_oct;
+  VectorD<int32_t, 2> neg_pred_normal_oct;
+  VectorD<int32_t, 2> pos_correction;
+  VectorD<int32_t, 2> neg_correction;
+  for (int data_id = 0; data_id < corner_map_size; ++data_id) {
+    const CornerIndex corner_id =
+        this->mesh_data().data_to_corner_map()->at(data_id);
+    predictor_.ComputePredictedValue(corner_id, pred_normal_3d.data());
+
+    // Compute predicted octahedral coordinates.
+    octahedron_tool_box_.CanonicalizeIntegerVector(pred_normal_3d.data());
+    DRACO_DCHECK_EQ(pred_normal_3d.AbsSum(),
+                    octahedron_tool_box_.center_value());
+
+    // Compute octahedral coordinates for both possible directions.
+    octahedron_tool_box_.IntegerVectorToQuantizedOctahedralCoords(
+        pred_normal_3d.data(), pos_pred_normal_oct.data(),
+        pos_pred_normal_oct.data() + 1);
+    pred_normal_3d = -pred_normal_3d;
+    octahedron_tool_box_.IntegerVectorToQuantizedOctahedralCoords(
+        pred_normal_3d.data(), neg_pred_normal_oct.data(),
+        neg_pred_normal_oct.data() + 1);
+
+    // Choose the one with the best correction value.
+    const int data_offset = data_id * 2;
+    this->transform().ComputeCorrection(in_data + data_offset,
+                                        pos_pred_normal_oct.data(),
+                                        pos_correction.data());
+    this->transform().ComputeCorrection(in_data + data_offset,
+                                        neg_pred_normal_oct.data(),
+                                        neg_correction.data());
+    pos_correction[0] = octahedron_tool_box_.ModMax(pos_correction[0]);
+    pos_correction[1] = octahedron_tool_box_.ModMax(pos_correction[1]);
+    neg_correction[0] = octahedron_tool_box_.ModMax(neg_correction[0]);
+    neg_correction[1] = octahedron_tool_box_.ModMax(neg_correction[1]);
+    if (pos_correction.AbsSum() < neg_correction.AbsSum()) {
+      flip_normal_bit_encoder_.EncodeBit(false);
+      (out_corr + data_offset)[0] =
+          octahedron_tool_box_.MakePositive(pos_correction[0]);
+      (out_corr + data_offset)[1] =
+          octahedron_tool_box_.MakePositive(pos_correction[1]);
+    } else {
+      flip_normal_bit_encoder_.EncodeBit(true);
+      (out_corr + data_offset)[0] =
+          octahedron_tool_box_.MakePositive(neg_correction[0]);
+      (out_corr + data_offset)[1] =
+          octahedron_tool_box_.MakePositive(neg_correction[1]);
+    }
+  }
+  return true;
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeGeometricNormalEncoder<
+    DataTypeT, TransformT, MeshDataT>::EncodePredictionData(EncoderBuffer
+                                                                *buffer) {
+  if (!this->transform().EncodeTransformData(buffer)) {
+    return false;
+  }
+
+  // Encode normal flips.
+  flip_normal_bit_encoder_.EndEncoding(buffer);
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_area.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_area.h
new file mode 100644
index 000000000..775eded6b
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_area.h
@@ -0,0 +1,117 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_PREDICTOR_AREA_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_PREDICTOR_AREA_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_base.h"
+
+namespace draco {
+
+// This predictor estimates the normal via the surrounding triangles of the
+// given corner. Triangles are weighted according to their area.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeGeometricNormalPredictorArea
+    : public MeshPredictionSchemeGeometricNormalPredictorBase<
+          DataTypeT, TransformT, MeshDataT> {
+  typedef MeshPredictionSchemeGeometricNormalPredictorBase<
+      DataTypeT, TransformT, MeshDataT>
+      Base;
+
+ public:
+  explicit MeshPredictionSchemeGeometricNormalPredictorArea(const MeshDataT &md)
+      : Base(md) {
+    this->SetNormalPredictionMode(TRIANGLE_AREA);
+  };
+  virtual ~MeshPredictionSchemeGeometricNormalPredictorArea() {}
+
+  // Computes predicted octahedral coordinates on a given corner.
+  void ComputePredictedValue(CornerIndex corner_id,
+                             DataTypeT *prediction) override {
+    DRACO_DCHECK(this->IsInitialized());
+    typedef typename MeshDataT::CornerTable CornerTable;
+    const CornerTable *const corner_table = this->mesh_data_.corner_table();
+    // Going to compute the predicted normal from the surrounding triangles
+    // according to the connectivity of the given corner table.
+    VertexCornersIterator<CornerTable> cit(corner_table, corner_id);
+    // Position of central vertex does not change in loop.
+    const VectorD<int64_t, 3> pos_cent = this->GetPositionForCorner(corner_id);
+    // Computing normals for triangles and adding them up.
+
+    VectorD<int64_t, 3> normal;
+    CornerIndex c_next, c_prev;
+    while (!cit.End()) {
+      // Getting corners.
+      if (this->normal_prediction_mode_ == ONE_TRIANGLE) {
+        c_next = corner_table->Next(corner_id);
+        c_prev = corner_table->Previous(corner_id);
+      } else {
+        c_next = corner_table->Next(cit.Corner());
+        c_prev = corner_table->Previous(cit.Corner());
+      }
+      const VectorD<int64_t, 3> pos_next = this->GetPositionForCorner(c_next);
+      const VectorD<int64_t, 3> pos_prev = this->GetPositionForCorner(c_prev);
+
+      // Computing delta vectors to next and prev.
+      const VectorD<int64_t, 3> delta_next = pos_next - pos_cent;
+      const VectorD<int64_t, 3> delta_prev = pos_prev - pos_cent;
+
+      // Computing cross product.
+      const VectorD<int64_t, 3> cross = CrossProduct(delta_next, delta_prev);
+
+      // Prevent signed integer overflows by doing math as unsigned.
+      auto normal_data = reinterpret_cast<uint64_t *>(normal.data());
+      auto cross_data = reinterpret_cast<const uint64_t *>(cross.data());
+      normal_data[0] = normal_data[0] + cross_data[0];
+      normal_data[1] = normal_data[1] + cross_data[1];
+      normal_data[2] = normal_data[2] + cross_data[2];
+
+      cit.Next();
+    }
+
+    // Convert to int32_t, make sure entries are not too large.
+    constexpr int64_t upper_bound = 1 << 29;
+    if (this->normal_prediction_mode_ == ONE_TRIANGLE) {
+      const int32_t abs_sum = static_cast<int32_t>(normal.AbsSum());
+      if (abs_sum > upper_bound) {
+        const int64_t quotient = abs_sum / upper_bound;
+        normal = normal / quotient;
+      }
+    } else {
+      const int64_t abs_sum = normal.AbsSum();
+      if (abs_sum > upper_bound) {
+        const int64_t quotient = abs_sum / upper_bound;
+        normal = normal / quotient;
+      }
+    }
+    DRACO_DCHECK_LE(normal.AbsSum(), upper_bound);
+    prediction[0] = static_cast<int32_t>(normal[0]);
+    prediction[1] = static_cast<int32_t>(normal[1]);
+    prediction[2] = static_cast<int32_t>(normal[2]);
+  }
+  bool SetNormalPredictionMode(NormalPredictionMode mode) override {
+    if (mode == ONE_TRIANGLE) {
+      this->normal_prediction_mode_ = mode;
+      return true;
+    } else if (mode == TRIANGLE_AREA) {
+      this->normal_prediction_mode_ = mode;
+      return true;
+    }
+    return false;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_PREDICTOR_AREA_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_base.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_base.h
new file mode 100644
index 000000000..a554dda96
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_base.h
@@ -0,0 +1,96 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_PREDICTOR_BASE_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_PREDICTOR_BASE_H_
+
+#include <math.h>
+
+#include "draco/attributes/point_attribute.h"
+#include "draco/compression/attributes/normal_compression_utils.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/math_utils.h"
+#include "draco/core/vector_d.h"
+#include "draco/mesh/corner_table.h"
+#include "draco/mesh/corner_table_iterators.h"
+
+namespace draco {
+
+// Base class for geometric normal predictors using position attribute.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeGeometricNormalPredictorBase {
+ protected:
+  explicit MeshPredictionSchemeGeometricNormalPredictorBase(const MeshDataT &md)
+      : pos_attribute_(nullptr),
+        entry_to_point_id_map_(nullptr),
+        mesh_data_(md) {}
+  virtual ~MeshPredictionSchemeGeometricNormalPredictorBase() {}
+
+ public:
+  void SetPositionAttribute(const PointAttribute &position_attribute) {
+    pos_attribute_ = &position_attribute;
+  }
+  void SetEntryToPointIdMap(const PointIndex *map) {
+    entry_to_point_id_map_ = map;
+  }
+  bool IsInitialized() const {
+    if (pos_attribute_ == nullptr) {
+      return false;
+    }
+    if (entry_to_point_id_map_ == nullptr) {
+      return false;
+    }
+    return true;
+  }
+
+  virtual bool SetNormalPredictionMode(NormalPredictionMode mode) = 0;
+  virtual NormalPredictionMode GetNormalPredictionMode() const {
+    return normal_prediction_mode_;
+  }
+
+ protected:
+  VectorD<int64_t, 3> GetPositionForDataId(int data_id) const {
+    DRACO_DCHECK(this->IsInitialized());
+    const auto point_id = entry_to_point_id_map_[data_id];
+    const auto pos_val_id = pos_attribute_->mapped_index(point_id);
+    VectorD<int64_t, 3> pos;
+    pos_attribute_->ConvertValue(pos_val_id, &pos[0]);
+    return pos;
+  }
+  VectorD<int64_t, 3> GetPositionForCorner(CornerIndex ci) const {
+    DRACO_DCHECK(this->IsInitialized());
+    const auto corner_table = mesh_data_.corner_table();
+    const auto vert_id = corner_table->Vertex(ci).value();
+    const auto data_id = mesh_data_.vertex_to_data_map()->at(vert_id);
+    return GetPositionForDataId(data_id);
+  }
+  VectorD<int32_t, 2> GetOctahedralCoordForDataId(int data_id,
+                                                  const DataTypeT *data) const {
+    DRACO_DCHECK(this->IsInitialized());
+    const int data_offset = data_id * 2;
+    return VectorD<int32_t, 2>(data[data_offset], data[data_offset + 1]);
+  }
+  // Computes predicted octahedral coordinates on a given corner.
+  virtual void ComputePredictedValue(CornerIndex corner_id,
+                                     DataTypeT *prediction) = 0;
+
+  const PointAttribute *pos_attribute_;
+  const PointIndex *entry_to_point_id_map_;
+  MeshDataT mesh_data_;
+  NormalPredictionMode normal_prediction_mode_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_PREDICTOR_BASE_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_decoder.h
new file mode 100644
index 000000000..fc82e0a8f
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_decoder.h
@@ -0,0 +1,126 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_MULTI_PARALLELOGRAM_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_MULTI_PARALLELOGRAM_DECODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Decoder for predictions encoded by multi-parallelogram encoding scheme.
+// See the corresponding encoder for method description.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeMultiParallelogramDecoder
+    : public MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType =
+      typename PredictionSchemeDecoder<DataTypeT, TransformT>::CorrType;
+  using CornerTable = typename MeshDataT::CornerTable;
+
+  explicit MeshPredictionSchemeMultiParallelogramDecoder(
+      const PointAttribute *attribute)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute) {}
+  MeshPredictionSchemeMultiParallelogramDecoder(const PointAttribute *attribute,
+                                                const TransformT &transform,
+                                                const MeshDataT &mesh_data)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data) {}
+
+  bool ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                             int size, int num_components,
+                             const PointIndex *entry_to_point_id_map) override;
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_MULTI_PARALLELOGRAM;
+  }
+
+  bool IsInitialized() const override {
+    return this->mesh_data().IsInitialized();
+  }
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeMultiParallelogramDecoder<DataTypeT, TransformT,
+                                                   MeshDataT>::
+    ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                          int /* size */, int num_components,
+                          const PointIndex * /* entry_to_point_id_map */) {
+  this->transform().Init(num_components);
+
+  // For storage of prediction values (already initialized to zero).
+  std::unique_ptr<DataTypeT[]> pred_vals(new DataTypeT[num_components]());
+  std::unique_ptr<DataTypeT[]> parallelogram_pred_vals(
+      new DataTypeT[num_components]());
+
+  this->transform().ComputeOriginalValue(pred_vals.get(), in_corr, out_data);
+
+  const CornerTable *const table = this->mesh_data().corner_table();
+  const std::vector<int32_t> *const vertex_to_data_map =
+      this->mesh_data().vertex_to_data_map();
+
+  const int corner_map_size =
+      static_cast<int>(this->mesh_data().data_to_corner_map()->size());
+  for (int p = 1; p < corner_map_size; ++p) {
+    const CornerIndex start_corner_id =
+        this->mesh_data().data_to_corner_map()->at(p);
+
+    CornerIndex corner_id(start_corner_id);
+    int num_parallelograms = 0;
+    for (int i = 0; i < num_components; ++i) {
+      pred_vals[i] = static_cast<DataTypeT>(0);
+    }
+    while (corner_id != kInvalidCornerIndex) {
+      if (ComputeParallelogramPrediction(
+              p, corner_id, table, *vertex_to_data_map, out_data,
+              num_components, parallelogram_pred_vals.get())) {
+        for (int c = 0; c < num_components; ++c) {
+          pred_vals[c] += parallelogram_pred_vals[c];
+        }
+        ++num_parallelograms;
+      }
+
+      // Proceed to the next corner attached to the vertex.
+      corner_id = table->SwingRight(corner_id);
+      if (corner_id == start_corner_id) {
+        corner_id = kInvalidCornerIndex;
+      }
+    }
+
+    const int dst_offset = p * num_components;
+    if (num_parallelograms == 0) {
+      // No parallelogram was valid.
+      // We use the last decoded point as a reference.
+      const int src_offset = (p - 1) * num_components;
+      this->transform().ComputeOriginalValue(
+          out_data + src_offset, in_corr + dst_offset, out_data + dst_offset);
+    } else {
+      // Compute the correction from the predicted value.
+      for (int c = 0; c < num_components; ++c) {
+        pred_vals[c] /= num_parallelograms;
+      }
+      this->transform().ComputeOriginalValue(
+          pred_vals.get(), in_corr + dst_offset, out_data + dst_offset);
+    }
+  }
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_MULTI_PARALLELOGRAM_DECODER_H_
+#endif
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_encoder.h
new file mode 100644
index 000000000..301b357d4
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_encoder.h
@@ -0,0 +1,133 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_MULTI_PARALLELOGRAM_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_MULTI_PARALLELOGRAM_ENCODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h"
+
+namespace draco {
+
+// Multi parallelogram prediction predicts attribute values using information
+// from all opposite faces to the predicted vertex, compared to the standard
+// prediction scheme, where only one opposite face is used (see
+// prediction_scheme_parallelogram.h). This approach is generally slower than
+// the standard parallelogram prediction, but it usually results in better
+// prediction (5 - 20% based on the quantization level. Better gains can be
+// achieved when more aggressive quantization is used).
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeMultiParallelogramEncoder
+    : public MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType =
+      typename PredictionSchemeEncoder<DataTypeT, TransformT>::CorrType;
+  using CornerTable = typename MeshDataT::CornerTable;
+
+  explicit MeshPredictionSchemeMultiParallelogramEncoder(
+      const PointAttribute *attribute)
+      : MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT>(
+            attribute) {}
+  MeshPredictionSchemeMultiParallelogramEncoder(const PointAttribute *attribute,
+                                                const TransformT &transform,
+                                                const MeshDataT &mesh_data)
+      : MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data) {}
+
+  bool ComputeCorrectionValues(
+      const DataTypeT *in_data, CorrType *out_corr, int size,
+      int num_components, const PointIndex *entry_to_point_id_map) override;
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_MULTI_PARALLELOGRAM;
+  }
+
+  bool IsInitialized() const override {
+    return this->mesh_data().IsInitialized();
+  }
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeMultiParallelogramEncoder<DataTypeT, TransformT,
+                                                   MeshDataT>::
+    ComputeCorrectionValues(const DataTypeT *in_data, CorrType *out_corr,
+                            int size, int num_components,
+                            const PointIndex * /* entry_to_point_id_map */) {
+  this->transform().Init(in_data, size, num_components);
+  const CornerTable *const table = this->mesh_data().corner_table();
+  const std::vector<int32_t> *const vertex_to_data_map =
+      this->mesh_data().vertex_to_data_map();
+
+  // For storage of prediction values (already initialized to zero).
+  std::unique_ptr<DataTypeT[]> pred_vals(new DataTypeT[num_components]());
+  std::unique_ptr<DataTypeT[]> parallelogram_pred_vals(
+      new DataTypeT[num_components]());
+
+  // We start processing from the end because this prediction uses data from
+  // previous entries that could be overwritten when an entry is processed.
+  for (int p =
+           static_cast<int>(this->mesh_data().data_to_corner_map()->size() - 1);
+       p > 0; --p) {
+    const CornerIndex start_corner_id =
+        this->mesh_data().data_to_corner_map()->at(p);
+
+    // Go over all corners attached to the vertex and compute the predicted
+    // value from the parallelograms defined by their opposite faces.
+    CornerIndex corner_id(start_corner_id);
+    int num_parallelograms = 0;
+    for (int i = 0; i < num_components; ++i) {
+      pred_vals[i] = static_cast<DataTypeT>(0);
+    }
+    while (corner_id != kInvalidCornerIndex) {
+      if (ComputeParallelogramPrediction(
+              p, corner_id, table, *vertex_to_data_map, in_data, num_components,
+              parallelogram_pred_vals.get())) {
+        for (int c = 0; c < num_components; ++c) {
+          pred_vals[c] += parallelogram_pred_vals[c];
+        }
+        ++num_parallelograms;
+      }
+
+      // Proceed to the next corner attached to the vertex.
+      corner_id = table->SwingRight(corner_id);
+      if (corner_id == start_corner_id) {
+        corner_id = kInvalidCornerIndex;
+      }
+    }
+    const int dst_offset = p * num_components;
+    if (num_parallelograms == 0) {
+      // No parallelogram was valid.
+      // We use the last encoded point as a reference.
+      const int src_offset = (p - 1) * num_components;
+      this->transform().ComputeCorrection(
+          in_data + dst_offset, in_data + src_offset, out_corr + dst_offset);
+    } else {
+      // Compute the correction from the predicted value.
+      for (int c = 0; c < num_components; ++c) {
+        pred_vals[c] /= num_parallelograms;
+      }
+      this->transform().ComputeCorrection(in_data + dst_offset, pred_vals.get(),
+                                          out_corr + dst_offset);
+    }
+  }
+  // First element is always fixed because it cannot be predicted.
+  for (int i = 0; i < num_components; ++i) {
+    pred_vals[i] = static_cast<DataTypeT>(0);
+  }
+  this->transform().ComputeCorrection(in_data, pred_vals.get(), out_corr);
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_MULTI_PARALLELOGRAM_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_decoder.h
new file mode 100644
index 000000000..4d47ddf30
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_decoder.h
@@ -0,0 +1,98 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_PARALLELOGRAM_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_PARALLELOGRAM_DECODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h"
+
+namespace draco {
+
+// Decoder for attribute values encoded with the standard parallelogram
+// prediction. See the description of the corresponding encoder for more
+// details.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeParallelogramDecoder
+    : public MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType =
+      typename PredictionSchemeDecoder<DataTypeT, TransformT>::CorrType;
+  using CornerTable = typename MeshDataT::CornerTable;
+  explicit MeshPredictionSchemeParallelogramDecoder(
+      const PointAttribute *attribute)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute) {}
+  MeshPredictionSchemeParallelogramDecoder(const PointAttribute *attribute,
+                                           const TransformT &transform,
+                                           const MeshDataT &mesh_data)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data) {}
+
+  bool ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                             int size, int num_components,
+                             const PointIndex *entry_to_point_id_map) override;
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_PARALLELOGRAM;
+  }
+
+  bool IsInitialized() const override {
+    return this->mesh_data().IsInitialized();
+  }
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeParallelogramDecoder<DataTypeT, TransformT,
+                                              MeshDataT>::
+    ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                          int /* size */, int num_components,
+                          const PointIndex * /* entry_to_point_id_map */) {
+  this->transform().Init(num_components);
+
+  const CornerTable *const table = this->mesh_data().corner_table();
+  const std::vector<int32_t> *const vertex_to_data_map =
+      this->mesh_data().vertex_to_data_map();
+
+  // For storage of prediction values (already initialized to zero).
+  std::unique_ptr<DataTypeT[]> pred_vals(new DataTypeT[num_components]());
+
+  // Restore the first value.
+  this->transform().ComputeOriginalValue(pred_vals.get(), in_corr, out_data);
+
+  const int corner_map_size =
+      static_cast<int>(this->mesh_data().data_to_corner_map()->size());
+  for (int p = 1; p < corner_map_size; ++p) {
+    const CornerIndex corner_id = this->mesh_data().data_to_corner_map()->at(p);
+    const int dst_offset = p * num_components;
+    if (!ComputeParallelogramPrediction(p, corner_id, table,
+                                        *vertex_to_data_map, out_data,
+                                        num_components, pred_vals.get())) {
+      // Parallelogram could not be computed, Possible because some of the
+      // vertices are not valid (not encoded yet).
+      // We use the last encoded point as a reference (delta coding).
+      const int src_offset = (p - 1) * num_components;
+      this->transform().ComputeOriginalValue(
+          out_data + src_offset, in_corr + dst_offset, out_data + dst_offset);
+    } else {
+      // Apply the parallelogram prediction.
+      this->transform().ComputeOriginalValue(
+          pred_vals.get(), in_corr + dst_offset, out_data + dst_offset);
+    }
+  }
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_PARALLELOGRAM_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_encoder.h
new file mode 100644
index 000000000..f00801932
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_encoder.h
@@ -0,0 +1,111 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_PARALLELOGRAM_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_PARALLELOGRAM_ENCODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h"
+
+namespace draco {
+
+// Parallelogram prediction predicts an attribute value V from three vertices
+// on the opposite face to the predicted vertex. The values on the three
+// vertices are used to construct a parallelogram V' = O - A - B, where O is the
+// value on the opposite vertex, and A, B are values on the shared vertices:
+//     V
+//    / \
+//   /   \
+//  /     \
+// A-------B
+//  \     /
+//   \   /
+//    \ /
+//     O
+//
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeParallelogramEncoder
+    : public MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType =
+      typename PredictionSchemeEncoder<DataTypeT, TransformT>::CorrType;
+  using CornerTable = typename MeshDataT::CornerTable;
+  explicit MeshPredictionSchemeParallelogramEncoder(
+      const PointAttribute *attribute)
+      : MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT>(
+            attribute) {}
+  MeshPredictionSchemeParallelogramEncoder(const PointAttribute *attribute,
+                                           const TransformT &transform,
+                                           const MeshDataT &mesh_data)
+      : MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data) {}
+
+  bool ComputeCorrectionValues(
+      const DataTypeT *in_data, CorrType *out_corr, int size,
+      int num_components, const PointIndex *entry_to_point_id_map) override;
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_PARALLELOGRAM;
+  }
+
+  bool IsInitialized() const override {
+    return this->mesh_data().IsInitialized();
+  }
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeParallelogramEncoder<DataTypeT, TransformT,
+                                              MeshDataT>::
+    ComputeCorrectionValues(const DataTypeT *in_data, CorrType *out_corr,
+                            int size, int num_components,
+                            const PointIndex * /* entry_to_point_id_map */) {
+  this->transform().Init(in_data, size, num_components);
+  // For storage of prediction values (already initialized to zero).
+  std::unique_ptr<DataTypeT[]> pred_vals(new DataTypeT[num_components]());
+
+  // We start processing from the end because this prediction uses data from
+  // previous entries that could be overwritten when an entry is processed.
+  const CornerTable *const table = this->mesh_data().corner_table();
+  const std::vector<int32_t> *const vertex_to_data_map =
+      this->mesh_data().vertex_to_data_map();
+  for (int p =
+           static_cast<int>(this->mesh_data().data_to_corner_map()->size() - 1);
+       p > 0; --p) {
+    const CornerIndex corner_id = this->mesh_data().data_to_corner_map()->at(p);
+    const int dst_offset = p * num_components;
+    if (!ComputeParallelogramPrediction(p, corner_id, table,
+                                        *vertex_to_data_map, in_data,
+                                        num_components, pred_vals.get())) {
+      // Parallelogram could not be computed, Possible because some of the
+      // vertices are not valid (not encoded yet).
+      // We use the last encoded point as a reference (delta coding).
+      const int src_offset = (p - 1) * num_components;
+      this->transform().ComputeCorrection(
+          in_data + dst_offset, in_data + src_offset, out_corr + dst_offset);
+    } else {
+      // Apply the parallelogram prediction.
+      this->transform().ComputeCorrection(in_data + dst_offset, pred_vals.get(),
+                                          out_corr + dst_offset);
+    }
+  }
+  // First element is always fixed because it cannot be predicted.
+  for (int i = 0; i < num_components; ++i) {
+    pred_vals[i] = static_cast<DataTypeT>(0);
+  }
+  this->transform().ComputeCorrection(in_data, pred_vals.get(), out_corr);
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_PARALLELOGRAM_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h
new file mode 100644
index 000000000..fd10fb524
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h
@@ -0,0 +1,78 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Shared functionality for different parallelogram prediction schemes.
+
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_PARALLELOGRAM_SHARED_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_PARALLELOGRAM_SHARED_H_
+
+#include "draco/mesh/corner_table.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// TODO(draco-eng) consolidate Vertex/next/previous queries to one call
+// (performance).
+template <class CornerTableT>
+inline void GetParallelogramEntries(
+    const CornerIndex ci, const CornerTableT *table,
+    const std::vector<int32_t> &vertex_to_data_map, int *opp_entry,
+    int *next_entry, int *prev_entry) {
+  // One vertex of the input |table| correspond to exactly one attribute value
+  // entry. The |table| can be either CornerTable for per-vertex attributes,
+  // or MeshAttributeCornerTable for attributes with interior seams.
+  *opp_entry = vertex_to_data_map[table->Vertex(ci).value()];
+  *next_entry = vertex_to_data_map[table->Vertex(table->Next(ci)).value()];
+  *prev_entry = vertex_to_data_map[table->Vertex(table->Previous(ci)).value()];
+}
+
+// Computes parallelogram prediction for a given corner and data entry id.
+// The prediction is stored in |out_prediction|.
+// Function returns false when the prediction couldn't be computed, e.g. because
+// not all entry points were available.
+template <class CornerTableT, typename DataTypeT>
+inline bool ComputeParallelogramPrediction(
+    int data_entry_id, const CornerIndex ci, const CornerTableT *table,
+    const std::vector<int32_t> &vertex_to_data_map, const DataTypeT *in_data,
+    int num_components, DataTypeT *out_prediction) {
+  const CornerIndex oci = table->Opposite(ci);
+  if (oci == kInvalidCornerIndex) {
+    return false;
+  }
+  int vert_opp, vert_next, vert_prev;
+  GetParallelogramEntries<CornerTableT>(oci, table, vertex_to_data_map,
+                                        &vert_opp, &vert_next, &vert_prev);
+  if (vert_opp < data_entry_id && vert_next < data_entry_id &&
+      vert_prev < data_entry_id) {
+    // Apply the parallelogram prediction.
+    const int v_opp_off = vert_opp * num_components;
+    const int v_next_off = vert_next * num_components;
+    const int v_prev_off = vert_prev * num_components;
+    for (int c = 0; c < num_components; ++c) {
+      const int64_t in_data_next_off = in_data[v_next_off + c];
+      const int64_t in_data_prev_off = in_data[v_prev_off + c];
+      const int64_t in_data_opp_off = in_data[v_opp_off + c];
+      const int64_t result =
+          (in_data_next_off + in_data_prev_off) - in_data_opp_off;
+
+      out_prediction[c] = static_cast<DataTypeT>(result);
+    }
+    return true;
+  }
+  return false;  // Not all data is available for prediction
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_PARALLELOGRAM_SHARED_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_decoder.h
new file mode 100644
index 000000000..02cf7e60f
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_decoder.h
@@ -0,0 +1,344 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_DECODER_H_
+
+#include <math.h>
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h"
+#include "draco/compression/bit_coders/rans_bit_decoder.h"
+#include "draco/core/varint_decoding.h"
+#include "draco/core/vector_d.h"
+#include "draco/draco_features.h"
+#include "draco/mesh/corner_table.h"
+
+namespace draco {
+
+// Decoder for predictions of UV coordinates encoded by our specialized texture
+// coordinate predictor. See the corresponding encoder for more details. Note
+// that this predictor is not portable and should not be used anymore. See
+// MeshPredictionSchemeTexCoordsPortableEncoder/Decoder for a portable version
+// of this prediction scheme.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeTexCoordsDecoder
+    : public MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType = typename MeshPredictionSchemeDecoder<DataTypeT, TransformT,
+                                                        MeshDataT>::CorrType;
+  MeshPredictionSchemeTexCoordsDecoder(const PointAttribute *attribute,
+                                       const TransformT &transform,
+                                       const MeshDataT &mesh_data, int version)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data),
+        pos_attribute_(nullptr),
+        entry_to_point_id_map_(nullptr),
+        num_components_(0),
+        version_(version) {}
+
+  bool ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                             int size, int num_components,
+                             const PointIndex *entry_to_point_id_map) override;
+
+  bool DecodePredictionData(DecoderBuffer *buffer) override;
+
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_TEX_COORDS_DEPRECATED;
+  }
+
+  bool IsInitialized() const override {
+    if (pos_attribute_ == nullptr) {
+      return false;
+    }
+    if (!this->mesh_data().IsInitialized()) {
+      return false;
+    }
+    return true;
+  }
+
+  int GetNumParentAttributes() const override { return 1; }
+
+  GeometryAttribute::Type GetParentAttributeType(int i) const override {
+    DRACO_DCHECK_EQ(i, 0);
+    (void)i;
+    return GeometryAttribute::POSITION;
+  }
+
+  bool SetParentAttribute(const PointAttribute *att) override {
+    if (att == nullptr) {
+      return false;
+    }
+    if (att->attribute_type() != GeometryAttribute::POSITION) {
+      return false;  // Invalid attribute type.
+    }
+    if (att->num_components() != 3) {
+      return false;  // Currently works only for 3 component positions.
+    }
+    pos_attribute_ = att;
+    return true;
+  }
+
+ protected:
+  Vector3f GetPositionForEntryId(int entry_id) const {
+    const PointIndex point_id = entry_to_point_id_map_[entry_id];
+    Vector3f pos;
+    pos_attribute_->ConvertValue(pos_attribute_->mapped_index(point_id),
+                                 &pos[0]);
+    return pos;
+  }
+
+  Vector2f GetTexCoordForEntryId(int entry_id, const DataTypeT *data) const {
+    const int data_offset = entry_id * num_components_;
+    return Vector2f(static_cast<float>(data[data_offset]),
+                    static_cast<float>(data[data_offset + 1]));
+  }
+
+  void ComputePredictedValue(CornerIndex corner_id, const DataTypeT *data,
+                             int data_id);
+
+ private:
+  const PointAttribute *pos_attribute_;
+  const PointIndex *entry_to_point_id_map_;
+  std::unique_ptr<DataTypeT[]> predicted_value_;
+  int num_components_;
+  // Encoded / decoded array of UV flips.
+  std::vector<bool> orientations_;
+  int version_;
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeTexCoordsDecoder<DataTypeT, TransformT, MeshDataT>::
+    ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                          int /* size */, int num_components,
+                          const PointIndex *entry_to_point_id_map) {
+  num_components_ = num_components;
+  entry_to_point_id_map_ = entry_to_point_id_map;
+  predicted_value_ =
+      std::unique_ptr<DataTypeT[]>(new DataTypeT[num_components]);
+  this->transform().Init(num_components);
+
+  const int corner_map_size =
+      static_cast<int>(this->mesh_data().data_to_corner_map()->size());
+  for (int p = 0; p < corner_map_size; ++p) {
+    const CornerIndex corner_id = this->mesh_data().data_to_corner_map()->at(p);
+    ComputePredictedValue(corner_id, out_data, p);
+
+    const int dst_offset = p * num_components;
+    this->transform().ComputeOriginalValue(
+        predicted_value_.get(), in_corr + dst_offset, out_data + dst_offset);
+  }
+  return true;
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeTexCoordsDecoder<DataTypeT, TransformT, MeshDataT>::
+    DecodePredictionData(DecoderBuffer *buffer) {
+  // Decode the delta coded orientations.
+  uint32_t num_orientations = 0;
+  if (buffer->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+    if (!buffer->Decode(&num_orientations)) {
+      return false;
+    }
+  } else {
+    if (!DecodeVarint(&num_orientations, buffer)) {
+      return false;
+    }
+  }
+  if (num_orientations == 0) {
+    return false;
+  }
+  orientations_.resize(num_orientations);
+  bool last_orientation = true;
+  RAnsBitDecoder decoder;
+  if (!decoder.StartDecoding(buffer)) {
+    return false;
+  }
+  for (uint32_t i = 0; i < num_orientations; ++i) {
+    if (!decoder.DecodeNextBit()) {
+      last_orientation = !last_orientation;
+    }
+    orientations_[i] = last_orientation;
+  }
+  decoder.EndDecoding();
+  return MeshPredictionSchemeDecoder<DataTypeT, TransformT,
+                                     MeshDataT>::DecodePredictionData(buffer);
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+void MeshPredictionSchemeTexCoordsDecoder<DataTypeT, TransformT, MeshDataT>::
+    ComputePredictedValue(CornerIndex corner_id, const DataTypeT *data,
+                          int data_id) {
+  // Compute the predicted UV coordinate from the positions on all corners
+  // of the processed triangle. For the best prediction, the UV coordinates
+  // on the next/previous corners need to be already encoded/decoded.
+  const CornerIndex next_corner_id =
+      this->mesh_data().corner_table()->Next(corner_id);
+  const CornerIndex prev_corner_id =
+      this->mesh_data().corner_table()->Previous(corner_id);
+  // Get the encoded data ids from the next and previous corners.
+  // The data id is the encoding order of the UV coordinates.
+  int next_data_id, prev_data_id;
+
+  int next_vert_id, prev_vert_id;
+  next_vert_id =
+      this->mesh_data().corner_table()->Vertex(next_corner_id).value();
+  prev_vert_id =
+      this->mesh_data().corner_table()->Vertex(prev_corner_id).value();
+
+  next_data_id = this->mesh_data().vertex_to_data_map()->at(next_vert_id);
+  prev_data_id = this->mesh_data().vertex_to_data_map()->at(prev_vert_id);
+
+  if (prev_data_id < data_id && next_data_id < data_id) {
+    // Both other corners have available UV coordinates for prediction.
+    const Vector2f n_uv = GetTexCoordForEntryId(next_data_id, data);
+    const Vector2f p_uv = GetTexCoordForEntryId(prev_data_id, data);
+    if (p_uv == n_uv) {
+      // We cannot do a reliable prediction on degenerated UV triangles.
+      predicted_value_[0] = static_cast<int>(p_uv[0]);
+      predicted_value_[1] = static_cast<int>(p_uv[1]);
+      return;
+    }
+
+    // Get positions at all corners.
+    const Vector3f tip_pos = GetPositionForEntryId(data_id);
+    const Vector3f next_pos = GetPositionForEntryId(next_data_id);
+    const Vector3f prev_pos = GetPositionForEntryId(prev_data_id);
+    // Use the positions of the above triangle to predict the texture coordinate
+    // on the tip corner C.
+    // Convert the triangle into a new coordinate system defined by orthogonal
+    // bases vectors S, T, where S is vector prev_pos - next_pos and T is an
+    // perpendicular vector to S in the same plane as vector the
+    // tip_pos - next_pos.
+    // The transformed triangle in the new coordinate system is then going to
+    // be represented as:
+    //
+    //        1 ^
+    //          |
+    //          |
+    //          |   C
+    //          |  /  \
+    //          | /      \
+    //          |/          \
+    //          N--------------P
+    //          0              1
+    //
+    // Where next_pos point (N) is at position (0, 0), prev_pos point (P) is
+    // at (1, 0). Our goal is to compute the position of the tip_pos point (C)
+    // in this new coordinate space (s, t).
+    //
+    const Vector3f pn = prev_pos - next_pos;
+    const Vector3f cn = tip_pos - next_pos;
+    const float pn_norm2_squared = pn.SquaredNorm();
+    // Coordinate s of the tip corner C is simply the dot product of the
+    // normalized vectors |pn| and |cn| (normalized by the length of |pn|).
+    // Since both of these vectors are normalized, we don't need to perform the
+    // normalization explicitly and instead we can just use the squared norm
+    // of |pn| as a denominator of the resulting dot product of non normalized
+    // vectors.
+    float s, t;
+    // |pn_norm2_squared| can be exactly 0 when the next_pos and prev_pos are
+    // the same positions (e.g. because they were quantized to the same
+    // location).
+    if (version_ < DRACO_BITSTREAM_VERSION(1, 2) || pn_norm2_squared > 0) {
+      s = pn.Dot(cn) / pn_norm2_squared;
+      // To get the coordinate t, we can use formula:
+      //      t = |C-N - (P-N) * s| / |P-N|
+      // Do not use std::sqrt to avoid changes in the bitstream.
+      t = sqrt((cn - pn * s).SquaredNorm() / pn_norm2_squared);
+    } else {
+      s = 0;
+      t = 0;
+    }
+
+    // Now we need to transform the point (s, t) to the texture coordinate space
+    // UV. We know the UV coordinates on points N and P (N_UV and P_UV). Lets
+    // denote P_UV - N_UV = PN_UV. PN_UV is then 2 dimensional vector that can
+    // be used to define transformation from the normalized coordinate system
+    // to the texture coordinate system using a 3x3 affine matrix M:
+    //
+    //  M = | PN_UV[0]  -PN_UV[1]  N_UV[0] |
+    //      | PN_UV[1]   PN_UV[0]  N_UV[1] |
+    //      | 0          0         1       |
+    //
+    // The predicted point C_UV in the texture space is then equal to
+    // C_UV = M * (s, t, 1). Because the triangle in UV space may be flipped
+    // around the PN_UV axis, we also need to consider point C_UV' = M * (s, -t)
+    // as the prediction.
+    const Vector2f pn_uv = p_uv - n_uv;
+    const float pnus = pn_uv[0] * s + n_uv[0];
+    const float pnut = pn_uv[0] * t;
+    const float pnvs = pn_uv[1] * s + n_uv[1];
+    const float pnvt = pn_uv[1] * t;
+    Vector2f predicted_uv;
+
+    // When decoding the data, we already know which orientation to use.
+    const bool orientation = orientations_.back();
+    orientations_.pop_back();
+    if (orientation)
+      predicted_uv = Vector2f(pnus - pnvt, pnvs + pnut);
+    else
+      predicted_uv = Vector2f(pnus + pnvt, pnvs - pnut);
+
+    if (std::is_integral<DataTypeT>::value) {
+      // Round the predicted value for integer types.
+      if (std::isnan(predicted_uv[0])) {
+        predicted_value_[0] = INT_MIN;
+      } else {
+        predicted_value_[0] = static_cast<int>(floor(predicted_uv[0] + 0.5));
+      }
+      if (std::isnan(predicted_uv[1])) {
+        predicted_value_[1] = INT_MIN;
+      } else {
+        predicted_value_[1] = static_cast<int>(floor(predicted_uv[1] + 0.5));
+      }
+    } else {
+      predicted_value_[0] = static_cast<int>(predicted_uv[0]);
+      predicted_value_[1] = static_cast<int>(predicted_uv[1]);
+    }
+    return;
+  }
+  // Else we don't have available textures on both corners. For such case we
+  // can't use positions for predicting the uv value and we resort to delta
+  // coding.
+  int data_offset = 0;
+  if (prev_data_id < data_id) {
+    // Use the value on the previous corner as the prediction.
+    data_offset = prev_data_id * num_components_;
+  }
+  if (next_data_id < data_id) {
+    // Use the value on the next corner as the prediction.
+    data_offset = next_data_id * num_components_;
+  } else {
+    // None of the other corners have a valid value. Use the last encoded value
+    // as the prediction if possible.
+    if (data_id > 0) {
+      data_offset = (data_id - 1) * num_components_;
+    } else {
+      // We are encoding the first value. Predict 0.
+      for (int i = 0; i < num_components_; ++i) {
+        predicted_value_[i] = 0;
+      }
+      return;
+    }
+  }
+  for (int i = 0; i < num_components_; ++i) {
+    predicted_value_[i] = data[data_offset + i];
+  }
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_DECODER_H_
+#endif
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_encoder.h
new file mode 100644
index 000000000..813b72ae3
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_encoder.h
@@ -0,0 +1,318 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_ENCODER_H_
+
+#include <math.h>
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h"
+#include "draco/compression/bit_coders/rans_bit_encoder.h"
+#include "draco/core/varint_encoding.h"
+#include "draco/core/vector_d.h"
+#include "draco/mesh/corner_table.h"
+
+namespace draco {
+
+// Prediction scheme designed for predicting texture coordinates from known
+// spatial position of vertices. For good parametrization, the ratios between
+// triangle edge lengths should be about the same in both the spatial and UV
+// coordinate spaces, which makes the positions a good predictor for the UV
+// coordinates.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeTexCoordsEncoder
+    : public MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType = typename MeshPredictionSchemeEncoder<DataTypeT, TransformT,
+                                                        MeshDataT>::CorrType;
+  MeshPredictionSchemeTexCoordsEncoder(const PointAttribute *attribute,
+                                       const TransformT &transform,
+                                       const MeshDataT &mesh_data)
+      : MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data),
+        pos_attribute_(nullptr),
+        entry_to_point_id_map_(nullptr),
+        num_components_(0) {}
+
+  bool ComputeCorrectionValues(
+      const DataTypeT *in_data, CorrType *out_corr, int size,
+      int num_components, const PointIndex *entry_to_point_id_map) override;
+
+  bool EncodePredictionData(EncoderBuffer *buffer) override;
+
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_TEX_COORDS_DEPRECATED;
+  }
+
+  bool IsInitialized() const override {
+    if (pos_attribute_ == nullptr) {
+      return false;
+    }
+    if (!this->mesh_data().IsInitialized()) {
+      return false;
+    }
+    return true;
+  }
+
+  int GetNumParentAttributes() const override { return 1; }
+
+  GeometryAttribute::Type GetParentAttributeType(int i) const override {
+    DRACO_DCHECK_EQ(i, 0);
+    (void)i;
+    return GeometryAttribute::POSITION;
+  }
+
+  bool SetParentAttribute(const PointAttribute *att) override {
+    if (att->attribute_type() != GeometryAttribute::POSITION) {
+      return false;  // Invalid attribute type.
+    }
+    if (att->num_components() != 3) {
+      return false;  // Currently works only for 3 component positions.
+    }
+    pos_attribute_ = att;
+    return true;
+  }
+
+ protected:
+  Vector3f GetPositionForEntryId(int entry_id) const {
+    const PointIndex point_id = entry_to_point_id_map_[entry_id];
+    Vector3f pos;
+    pos_attribute_->ConvertValue(pos_attribute_->mapped_index(point_id),
+                                 &pos[0]);
+    return pos;
+  }
+
+  Vector2f GetTexCoordForEntryId(int entry_id, const DataTypeT *data) const {
+    const int data_offset = entry_id * num_components_;
+    return Vector2f(static_cast<float>(data[data_offset]),
+                    static_cast<float>(data[data_offset + 1]));
+  }
+
+  void ComputePredictedValue(CornerIndex corner_id, const DataTypeT *data,
+                             int data_id);
+
+ private:
+  const PointAttribute *pos_attribute_;
+  const PointIndex *entry_to_point_id_map_;
+  std::unique_ptr<DataTypeT[]> predicted_value_;
+  int num_components_;
+  // Encoded / decoded array of UV flips.
+  std::vector<bool> orientations_;
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeTexCoordsEncoder<DataTypeT, TransformT, MeshDataT>::
+    ComputeCorrectionValues(const DataTypeT *in_data, CorrType *out_corr,
+                            int size, int num_components,
+                            const PointIndex *entry_to_point_id_map) {
+  num_components_ = num_components;
+  entry_to_point_id_map_ = entry_to_point_id_map;
+  predicted_value_ =
+      std::unique_ptr<DataTypeT[]>(new DataTypeT[num_components]);
+  this->transform().Init(in_data, size, num_components);
+  // We start processing from the end because this prediction uses data from
+  // previous entries that could be overwritten when an entry is processed.
+  for (int p =
+           static_cast<int>(this->mesh_data().data_to_corner_map()->size()) - 1;
+       p >= 0; --p) {
+    const CornerIndex corner_id = this->mesh_data().data_to_corner_map()->at(p);
+    ComputePredictedValue(corner_id, in_data, p);
+
+    const int dst_offset = p * num_components;
+    this->transform().ComputeCorrection(
+        in_data + dst_offset, predicted_value_.get(), out_corr + dst_offset);
+  }
+  return true;
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeTexCoordsEncoder<DataTypeT, TransformT, MeshDataT>::
+    EncodePredictionData(EncoderBuffer *buffer) {
+  // Encode the delta-coded orientations using arithmetic coding.
+  const uint32_t num_orientations = static_cast<uint32_t>(orientations_.size());
+  EncodeVarint(num_orientations, buffer);
+  bool last_orientation = true;
+  RAnsBitEncoder encoder;
+  encoder.StartEncoding();
+  for (bool orientation : orientations_) {
+    encoder.EncodeBit(orientation == last_orientation);
+    last_orientation = orientation;
+  }
+  encoder.EndEncoding(buffer);
+  return MeshPredictionSchemeEncoder<DataTypeT, TransformT,
+                                     MeshDataT>::EncodePredictionData(buffer);
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+void MeshPredictionSchemeTexCoordsEncoder<DataTypeT, TransformT, MeshDataT>::
+    ComputePredictedValue(CornerIndex corner_id, const DataTypeT *data,
+                          int data_id) {
+  // Compute the predicted UV coordinate from the positions on all corners
+  // of the processed triangle. For the best prediction, the UV coordinates
+  // on the next/previous corners need to be already encoded/decoded.
+  const CornerIndex next_corner_id =
+      this->mesh_data().corner_table()->Next(corner_id);
+  const CornerIndex prev_corner_id =
+      this->mesh_data().corner_table()->Previous(corner_id);
+  // Get the encoded data ids from the next and previous corners.
+  // The data id is the encoding order of the UV coordinates.
+  int next_data_id, prev_data_id;
+
+  int next_vert_id, prev_vert_id;
+  next_vert_id =
+      this->mesh_data().corner_table()->Vertex(next_corner_id).value();
+  prev_vert_id =
+      this->mesh_data().corner_table()->Vertex(prev_corner_id).value();
+
+  next_data_id = this->mesh_data().vertex_to_data_map()->at(next_vert_id);
+  prev_data_id = this->mesh_data().vertex_to_data_map()->at(prev_vert_id);
+
+  if (prev_data_id < data_id && next_data_id < data_id) {
+    // Both other corners have available UV coordinates for prediction.
+    const Vector2f n_uv = GetTexCoordForEntryId(next_data_id, data);
+    const Vector2f p_uv = GetTexCoordForEntryId(prev_data_id, data);
+    if (p_uv == n_uv) {
+      // We cannot do a reliable prediction on degenerated UV triangles.
+      predicted_value_[0] = static_cast<int>(p_uv[0]);
+      predicted_value_[1] = static_cast<int>(p_uv[1]);
+      return;
+    }
+
+    // Get positions at all corners.
+    const Vector3f tip_pos = GetPositionForEntryId(data_id);
+    const Vector3f next_pos = GetPositionForEntryId(next_data_id);
+    const Vector3f prev_pos = GetPositionForEntryId(prev_data_id);
+    // Use the positions of the above triangle to predict the texture coordinate
+    // on the tip corner C.
+    // Convert the triangle into a new coordinate system defined by orthogonal
+    // bases vectors S, T, where S is vector prev_pos - next_pos and T is an
+    // perpendicular vector to S in the same plane as vector the
+    // tip_pos - next_pos.
+    // The transformed triangle in the new coordinate system is then going to
+    // be represented as:
+    //
+    //        1 ^
+    //          |
+    //          |
+    //          |   C
+    //          |  /  \
+    //          | /      \
+    //          |/          \
+    //          N--------------P
+    //          0              1
+    //
+    // Where next_pos point (N) is at position (0, 0), prev_pos point (P) is
+    // at (1, 0). Our goal is to compute the position of the tip_pos point (C)
+    // in this new coordinate space (s, t).
+    //
+    const Vector3f pn = prev_pos - next_pos;
+    const Vector3f cn = tip_pos - next_pos;
+    const float pn_norm2_squared = pn.SquaredNorm();
+    // Coordinate s of the tip corner C is simply the dot product of the
+    // normalized vectors |pn| and |cn| (normalized by the length of |pn|).
+    // Since both of these vectors are normalized, we don't need to perform the
+    // normalization explicitly and instead we can just use the squared norm
+    // of |pn| as a denominator of the resulting dot product of non normalized
+    // vectors.
+    float s, t;
+    // |pn_norm2_squared| can be exactly 0 when the next_pos and prev_pos are
+    // the same positions (e.g. because they were quantized to the same
+    // location).
+    if (pn_norm2_squared > 0) {
+      s = pn.Dot(cn) / pn_norm2_squared;
+      // To get the coordinate t, we can use formula:
+      //      t = |C-N - (P-N) * s| / |P-N|
+      // Do not use std::sqrt to avoid changes in the bitstream.
+      t = sqrt((cn - pn * s).SquaredNorm() / pn_norm2_squared);
+    } else {
+      s = 0;
+      t = 0;
+    }
+
+    // Now we need to transform the point (s, t) to the texture coordinate space
+    // UV. We know the UV coordinates on points N and P (N_UV and P_UV). Lets
+    // denote P_UV - N_UV = PN_UV. PN_UV is then 2 dimensional vector that can
+    // be used to define transformation from the normalized coordinate system
+    // to the texture coordinate system using a 3x3 affine matrix M:
+    //
+    //  M = | PN_UV[0]  -PN_UV[1]  N_UV[0] |
+    //      | PN_UV[1]   PN_UV[0]  N_UV[1] |
+    //      | 0          0         1       |
+    //
+    // The predicted point C_UV in the texture space is then equal to
+    // C_UV = M * (s, t, 1). Because the triangle in UV space may be flipped
+    // around the PN_UV axis, we also need to consider point C_UV' = M * (s, -t)
+    // as the prediction.
+    const Vector2f pn_uv = p_uv - n_uv;
+    const float pnus = pn_uv[0] * s + n_uv[0];
+    const float pnut = pn_uv[0] * t;
+    const float pnvs = pn_uv[1] * s + n_uv[1];
+    const float pnvt = pn_uv[1] * t;
+    Vector2f predicted_uv;
+
+    // When encoding compute both possible vectors and determine which one
+    // results in a better prediction.
+    const Vector2f predicted_uv_0(pnus - pnvt, pnvs + pnut);
+    const Vector2f predicted_uv_1(pnus + pnvt, pnvs - pnut);
+    const Vector2f c_uv = GetTexCoordForEntryId(data_id, data);
+    if ((c_uv - predicted_uv_0).SquaredNorm() <
+        (c_uv - predicted_uv_1).SquaredNorm()) {
+      predicted_uv = predicted_uv_0;
+      orientations_.push_back(true);
+    } else {
+      predicted_uv = predicted_uv_1;
+      orientations_.push_back(false);
+    }
+    if (std::is_integral<DataTypeT>::value) {
+      // Round the predicted value for integer types.
+      predicted_value_[0] = static_cast<int>(floor(predicted_uv[0] + 0.5));
+      predicted_value_[1] = static_cast<int>(floor(predicted_uv[1] + 0.5));
+    } else {
+      predicted_value_[0] = static_cast<int>(predicted_uv[0]);
+      predicted_value_[1] = static_cast<int>(predicted_uv[1]);
+    }
+    return;
+  }
+  // Else we don't have available textures on both corners. For such case we
+  // can't use positions for predicting the uv value and we resort to delta
+  // coding.
+  int data_offset = 0;
+  if (prev_data_id < data_id) {
+    // Use the value on the previous corner as the prediction.
+    data_offset = prev_data_id * num_components_;
+  }
+  if (next_data_id < data_id) {
+    // Use the value on the next corner as the prediction.
+    data_offset = next_data_id * num_components_;
+  } else {
+    // None of the other corners have a valid value. Use the last encoded value
+    // as the prediction if possible.
+    if (data_id > 0) {
+      data_offset = (data_id - 1) * num_components_;
+    } else {
+      // We are encoding the first value. Predict 0.
+      for (int i = 0; i < num_components_; ++i) {
+        predicted_value_[i] = 0;
+      }
+      return;
+    }
+  }
+  for (int i = 0; i < num_components_; ++i) {
+    predicted_value_[i] = data[data_offset + i];
+  }
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_decoder.h
new file mode 100644
index 000000000..83d496639
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_decoder.h
@@ -0,0 +1,143 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_PORTABLE_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_PORTABLE_DECODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_predictor.h"
+#include "draco/compression/bit_coders/rans_bit_decoder.h"
+
+namespace draco {
+
+// Decoder for predictions of UV coordinates encoded by our specialized and
+// portable texture coordinate predictor. See the corresponding encoder for more
+// details.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeTexCoordsPortableDecoder
+    : public MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType = typename MeshPredictionSchemeDecoder<DataTypeT, TransformT,
+                                                        MeshDataT>::CorrType;
+  MeshPredictionSchemeTexCoordsPortableDecoder(const PointAttribute *attribute,
+                                               const TransformT &transform,
+                                               const MeshDataT &mesh_data)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data),
+        predictor_(mesh_data) {}
+
+  bool ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                             int size, int num_components,
+                             const PointIndex *entry_to_point_id_map) override;
+
+  bool DecodePredictionData(DecoderBuffer *buffer) override;
+
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_TEX_COORDS_PORTABLE;
+  }
+
+  bool IsInitialized() const override {
+    if (!predictor_.IsInitialized()) {
+      return false;
+    }
+    if (!this->mesh_data().IsInitialized()) {
+      return false;
+    }
+    return true;
+  }
+
+  int GetNumParentAttributes() const override { return 1; }
+
+  GeometryAttribute::Type GetParentAttributeType(int i) const override {
+    DRACO_DCHECK_EQ(i, 0);
+    (void)i;
+    return GeometryAttribute::POSITION;
+  }
+
+  bool SetParentAttribute(const PointAttribute *att) override {
+    if (!att || att->attribute_type() != GeometryAttribute::POSITION) {
+      return false;  // Invalid attribute type.
+    }
+    if (att->num_components() != 3) {
+      return false;  // Currently works only for 3 component positions.
+    }
+    predictor_.SetPositionAttribute(*att);
+    return true;
+  }
+
+ private:
+  MeshPredictionSchemeTexCoordsPortablePredictor<DataTypeT, MeshDataT>
+      predictor_;
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeTexCoordsPortableDecoder<
+    DataTypeT, TransformT,
+    MeshDataT>::ComputeOriginalValues(const CorrType *in_corr,
+                                      DataTypeT *out_data, int /* size */,
+                                      int num_components,
+                                      const PointIndex *entry_to_point_id_map) {
+  if (num_components != MeshPredictionSchemeTexCoordsPortablePredictor<
+                            DataTypeT, MeshDataT>::kNumComponents) {
+    return false;
+  }
+  predictor_.SetEntryToPointIdMap(entry_to_point_id_map);
+  this->transform().Init(num_components);
+
+  const int corner_map_size =
+      static_cast<int>(this->mesh_data().data_to_corner_map()->size());
+  for (int p = 0; p < corner_map_size; ++p) {
+    const CornerIndex corner_id = this->mesh_data().data_to_corner_map()->at(p);
+    if (!predictor_.template ComputePredictedValue<false>(corner_id, out_data,
+                                                          p)) {
+      return false;
+    }
+
+    const int dst_offset = p * num_components;
+    this->transform().ComputeOriginalValue(predictor_.predicted_value(),
+                                           in_corr + dst_offset,
+                                           out_data + dst_offset);
+  }
+  return true;
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeTexCoordsPortableDecoder<
+    DataTypeT, TransformT, MeshDataT>::DecodePredictionData(DecoderBuffer
+                                                                *buffer) {
+  // Decode the delta coded orientations.
+  int32_t num_orientations = 0;
+  if (!buffer->Decode(&num_orientations) || num_orientations < 0) {
+    return false;
+  }
+  predictor_.ResizeOrientations(num_orientations);
+  bool last_orientation = true;
+  RAnsBitDecoder decoder;
+  if (!decoder.StartDecoding(buffer)) {
+    return false;
+  }
+  for (int i = 0; i < num_orientations; ++i) {
+    if (!decoder.DecodeNextBit()) {
+      last_orientation = !last_orientation;
+    }
+    predictor_.set_orientation(i, last_orientation);
+  }
+  decoder.EndDecoding();
+  return MeshPredictionSchemeDecoder<DataTypeT, TransformT,
+                                     MeshDataT>::DecodePredictionData(buffer);
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_PORTABLE_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_encoder.h
new file mode 100644
index 000000000..741ec66dc
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_encoder.h
@@ -0,0 +1,133 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_PORTABLE_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_PORTABLE_ENCODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_predictor.h"
+#include "draco/compression/bit_coders/rans_bit_encoder.h"
+
+namespace draco {
+
+// Prediction scheme designed for predicting texture coordinates from known
+// spatial position of vertices. For isometric parametrizations, the ratios
+// between triangle edge lengths should be about the same in both the spatial
+// and UV coordinate spaces, which makes the positions a good predictor for the
+// UV coordinates. Note that this may not be the optimal approach for other
+// parametrizations such as projective ones.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeTexCoordsPortableEncoder
+    : public MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType = typename MeshPredictionSchemeEncoder<DataTypeT, TransformT,
+                                                        MeshDataT>::CorrType;
+  MeshPredictionSchemeTexCoordsPortableEncoder(const PointAttribute *attribute,
+                                               const TransformT &transform,
+                                               const MeshDataT &mesh_data)
+      : MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data),
+        predictor_(mesh_data) {}
+
+  bool ComputeCorrectionValues(
+      const DataTypeT *in_data, CorrType *out_corr, int size,
+      int num_components, const PointIndex *entry_to_point_id_map) override;
+
+  bool EncodePredictionData(EncoderBuffer *buffer) override;
+
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_TEX_COORDS_PORTABLE;
+  }
+
+  bool IsInitialized() const override {
+    if (!predictor_.IsInitialized()) {
+      return false;
+    }
+    if (!this->mesh_data().IsInitialized()) {
+      return false;
+    }
+    return true;
+  }
+
+  int GetNumParentAttributes() const override { return 1; }
+
+  GeometryAttribute::Type GetParentAttributeType(int i) const override {
+    DRACO_DCHECK_EQ(i, 0);
+    (void)i;
+    return GeometryAttribute::POSITION;
+  }
+
+  bool SetParentAttribute(const PointAttribute *att) override {
+    if (att->attribute_type() != GeometryAttribute::POSITION) {
+      return false;  // Invalid attribute type.
+    }
+    if (att->num_components() != 3) {
+      return false;  // Currently works only for 3 component positions.
+    }
+    predictor_.SetPositionAttribute(*att);
+    return true;
+  }
+
+ private:
+  MeshPredictionSchemeTexCoordsPortablePredictor<DataTypeT, MeshDataT>
+      predictor_;
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeTexCoordsPortableEncoder<DataTypeT, TransformT,
+                                                  MeshDataT>::
+    ComputeCorrectionValues(const DataTypeT *in_data, CorrType *out_corr,
+                            int size, int num_components,
+                            const PointIndex *entry_to_point_id_map) {
+  predictor_.SetEntryToPointIdMap(entry_to_point_id_map);
+  this->transform().Init(in_data, size, num_components);
+  // We start processing from the end because this prediction uses data from
+  // previous entries that could be overwritten when an entry is processed.
+  for (int p =
+           static_cast<int>(this->mesh_data().data_to_corner_map()->size() - 1);
+       p >= 0; --p) {
+    const CornerIndex corner_id = this->mesh_data().data_to_corner_map()->at(p);
+    predictor_.template ComputePredictedValue<true>(corner_id, in_data, p);
+
+    const int dst_offset = p * num_components;
+    this->transform().ComputeCorrection(in_data + dst_offset,
+                                        predictor_.predicted_value(),
+                                        out_corr + dst_offset);
+  }
+  return true;
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeTexCoordsPortableEncoder<
+    DataTypeT, TransformT, MeshDataT>::EncodePredictionData(EncoderBuffer
+                                                                *buffer) {
+  // Encode the delta-coded orientations using arithmetic coding.
+  const int32_t num_orientations = predictor_.num_orientations();
+  buffer->Encode(num_orientations);
+  bool last_orientation = true;
+  RAnsBitEncoder encoder;
+  encoder.StartEncoding();
+  for (int i = 0; i < num_orientations; ++i) {
+    const bool orientation = predictor_.orientation(i);
+    encoder.EncodeBit(orientation == last_orientation);
+    last_orientation = orientation;
+  }
+  encoder.EndEncoding(buffer);
+  return MeshPredictionSchemeEncoder<DataTypeT, TransformT,
+                                     MeshDataT>::EncodePredictionData(buffer);
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_PORTABLE_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_predictor.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_predictor.h
new file mode 100644
index 000000000..f05e5ddd7
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_predictor.h
@@ -0,0 +1,263 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_PORTABLE_PREDICTOR_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_PORTABLE_PREDICTOR_H_
+
+#include <math.h>
+
+#include "draco/attributes/point_attribute.h"
+#include "draco/core/math_utils.h"
+#include "draco/core/vector_d.h"
+#include "draco/mesh/corner_table.h"
+
+namespace draco {
+
+// Predictor functionality used for portable UV prediction by both encoder and
+// decoder.
+template <typename DataTypeT, class MeshDataT>
+class MeshPredictionSchemeTexCoordsPortablePredictor {
+ public:
+  static constexpr int kNumComponents = 2;
+
+  explicit MeshPredictionSchemeTexCoordsPortablePredictor(const MeshDataT &md)
+      : pos_attribute_(nullptr),
+        entry_to_point_id_map_(nullptr),
+        mesh_data_(md) {}
+  void SetPositionAttribute(const PointAttribute &position_attribute) {
+    pos_attribute_ = &position_attribute;
+  }
+  void SetEntryToPointIdMap(const PointIndex *map) {
+    entry_to_point_id_map_ = map;
+  }
+  bool IsInitialized() const { return pos_attribute_ != nullptr; }
+
+  VectorD<int64_t, 3> GetPositionForEntryId(int entry_id) const {
+    const PointIndex point_id = entry_to_point_id_map_[entry_id];
+    VectorD<int64_t, 3> pos;
+    pos_attribute_->ConvertValue(pos_attribute_->mapped_index(point_id),
+                                 &pos[0]);
+    return pos;
+  }
+
+  VectorD<int64_t, 2> GetTexCoordForEntryId(int entry_id,
+                                            const DataTypeT *data) const {
+    const int data_offset = entry_id * kNumComponents;
+    return VectorD<int64_t, 2>(data[data_offset], data[data_offset + 1]);
+  }
+
+  // Computes predicted UV coordinates on a given corner. The coordinates are
+  // stored in |predicted_value_| member.
+  template <bool is_encoder_t>
+  bool ComputePredictedValue(CornerIndex corner_id, const DataTypeT *data,
+                             int data_id);
+
+  const DataTypeT *predicted_value() const { return predicted_value_; }
+  bool orientation(int i) const { return orientations_[i]; }
+  void set_orientation(int i, bool v) { orientations_[i] = v; }
+  size_t num_orientations() const { return orientations_.size(); }
+  void ResizeOrientations(int num_orientations) {
+    orientations_.resize(num_orientations);
+  }
+
+ private:
+  const PointAttribute *pos_attribute_;
+  const PointIndex *entry_to_point_id_map_;
+  DataTypeT predicted_value_[kNumComponents];
+  // Encoded / decoded array of UV flips.
+  // TODO(ostava): We should remove this and replace this with in-place encoding
+  // and decoding to avoid unnecessary copy.
+  std::vector<bool> orientations_;
+  MeshDataT mesh_data_;
+};
+
+template <typename DataTypeT, class MeshDataT>
+template <bool is_encoder_t>
+bool MeshPredictionSchemeTexCoordsPortablePredictor<
+    DataTypeT, MeshDataT>::ComputePredictedValue(CornerIndex corner_id,
+                                                 const DataTypeT *data,
+                                                 int data_id) {
+  // Compute the predicted UV coordinate from the positions on all corners
+  // of the processed triangle. For the best prediction, the UV coordinates
+  // on the next/previous corners need to be already encoded/decoded.
+  const CornerIndex next_corner_id = mesh_data_.corner_table()->Next(corner_id);
+  const CornerIndex prev_corner_id =
+      mesh_data_.corner_table()->Previous(corner_id);
+  // Get the encoded data ids from the next and previous corners.
+  // The data id is the encoding order of the UV coordinates.
+  int next_data_id, prev_data_id;
+
+  int next_vert_id, prev_vert_id;
+  next_vert_id = mesh_data_.corner_table()->Vertex(next_corner_id).value();
+  prev_vert_id = mesh_data_.corner_table()->Vertex(prev_corner_id).value();
+
+  next_data_id = mesh_data_.vertex_to_data_map()->at(next_vert_id);
+  prev_data_id = mesh_data_.vertex_to_data_map()->at(prev_vert_id);
+
+  if (prev_data_id < data_id && next_data_id < data_id) {
+    // Both other corners have available UV coordinates for prediction.
+    const VectorD<int64_t, 2> n_uv = GetTexCoordForEntryId(next_data_id, data);
+    const VectorD<int64_t, 2> p_uv = GetTexCoordForEntryId(prev_data_id, data);
+    if (p_uv == n_uv) {
+      // We cannot do a reliable prediction on degenerated UV triangles.
+      predicted_value_[0] = p_uv[0];
+      predicted_value_[1] = p_uv[1];
+      return true;
+    }
+
+    // Get positions at all corners.
+    const VectorD<int64_t, 3> tip_pos = GetPositionForEntryId(data_id);
+    const VectorD<int64_t, 3> next_pos = GetPositionForEntryId(next_data_id);
+    const VectorD<int64_t, 3> prev_pos = GetPositionForEntryId(prev_data_id);
+    // We use the positions of the above triangle to predict the texture
+    // coordinate on the tip corner C.
+    // To convert the triangle into the UV coordinate system we first compute
+    // position X on the vector |prev_pos - next_pos| that is the projection of
+    // point C onto vector |prev_pos - next_pos|:
+    //
+    //              C
+    //             /.  \
+    //            / .     \
+    //           /  .        \
+    //          N---X----------P
+    //
+    // Where next_pos is point (N), prev_pos is point (P) and tip_pos is the
+    // position of predicted coordinate (C).
+    //
+    const VectorD<int64_t, 3> pn = prev_pos - next_pos;
+    const uint64_t pn_norm2_squared = pn.SquaredNorm();
+    if (pn_norm2_squared != 0) {
+      // Compute the projection of C onto PN by computing dot product of CN with
+      // PN and normalizing it by length of PN. This gives us a factor |s| where
+      // |s = PN.Dot(CN) / PN.SquaredNorm2()|. This factor can be used to
+      // compute X in UV space |X_UV| as |X_UV = N_UV + s * PN_UV|.
+      const VectorD<int64_t, 3> cn = tip_pos - next_pos;
+      const int64_t cn_dot_pn = pn.Dot(cn);
+
+      const VectorD<int64_t, 2> pn_uv = p_uv - n_uv;
+      // Because we perform all computations with integers, we don't explicitly
+      // compute the normalized factor |s|, but rather we perform all operations
+      // over UV vectors in a non-normalized coordinate system scaled with a
+      // scaling factor |pn_norm2_squared|:
+      //
+      //      x_uv = X_UV * PN.Norm2Squared()
+      //
+      const VectorD<int64_t, 2> x_uv =
+          n_uv * pn_norm2_squared + (cn_dot_pn * pn_uv);
+
+      const int64_t pn_absmax_element =
+          std::max(std::max(std::abs(pn[0]), std::abs(pn[1])), std::abs(pn[2]));
+      if (cn_dot_pn > std::numeric_limits<int64_t>::max() / pn_absmax_element) {
+        // return false if squared length calculation would overflow.
+        return false;
+      }
+
+      // Compute squared length of vector CX in position coordinate system:
+      const VectorD<int64_t, 3> x_pos =
+          next_pos + (cn_dot_pn * pn) / pn_norm2_squared;
+      const uint64_t cx_norm2_squared = (tip_pos - x_pos).SquaredNorm();
+
+      // Compute vector CX_UV in the uv space by rotating vector PN_UV by 90
+      // degrees and scaling it with factor CX.Norm2() / PN.Norm2():
+      //
+      //     CX_UV = (CX.Norm2() / PN.Norm2()) * Rot(PN_UV)
+      //
+      // To preserve precision, we perform all operations in scaled space as
+      // explained above, so we want the final vector to be:
+      //
+      //     cx_uv = CX_UV * PN.Norm2Squared()
+      //
+      // We can then rewrite the formula as:
+      //
+      //     cx_uv = CX.Norm2() * PN.Norm2() * Rot(PN_UV)
+      //
+      VectorD<int64_t, 2> cx_uv(pn_uv[1], -pn_uv[0]);  // Rotated PN_UV.
+      // Compute CX.Norm2() * PN.Norm2()
+      const uint64_t norm_squared =
+          IntSqrt(cx_norm2_squared * pn_norm2_squared);
+      // Final cx_uv in the scaled coordinate space.
+      cx_uv = cx_uv * norm_squared;
+
+      // Predicted uv coordinate is then computed by either adding or
+      // subtracting CX_UV to/from X_UV.
+      VectorD<int64_t, 2> predicted_uv;
+      if (is_encoder_t) {
+        // When encoding, compute both possible vectors and determine which one
+        // results in a better prediction.
+        // Both vectors need to be transformed back from the scaled space to
+        // the real UV coordinate space.
+        const VectorD<int64_t, 2> predicted_uv_0((x_uv + cx_uv) /
+                                                 pn_norm2_squared);
+        const VectorD<int64_t, 2> predicted_uv_1((x_uv - cx_uv) /
+                                                 pn_norm2_squared);
+        const VectorD<int64_t, 2> c_uv = GetTexCoordForEntryId(data_id, data);
+        if ((c_uv - predicted_uv_0).SquaredNorm() <
+            (c_uv - predicted_uv_1).SquaredNorm()) {
+          predicted_uv = predicted_uv_0;
+          orientations_.push_back(true);
+        } else {
+          predicted_uv = predicted_uv_1;
+          orientations_.push_back(false);
+        }
+      } else {
+        // When decoding the data, we already know which orientation to use.
+        if (orientations_.empty()) {
+          return false;
+        }
+        const bool orientation = orientations_.back();
+        orientations_.pop_back();
+        if (orientation) {
+          predicted_uv = (x_uv + cx_uv) / pn_norm2_squared;
+        } else {
+          predicted_uv = (x_uv - cx_uv) / pn_norm2_squared;
+        }
+      }
+      predicted_value_[0] = static_cast<int>(predicted_uv[0]);
+      predicted_value_[1] = static_cast<int>(predicted_uv[1]);
+      return true;
+    }
+  }
+  // Else we don't have available textures on both corners or the position data
+  // is invalid. For such cases we can't use positions for predicting the uv
+  // value and we resort to delta coding.
+  int data_offset = 0;
+  if (prev_data_id < data_id) {
+    // Use the value on the previous corner as the prediction.
+    data_offset = prev_data_id * kNumComponents;
+  }
+  if (next_data_id < data_id) {
+    // Use the value on the next corner as the prediction.
+    data_offset = next_data_id * kNumComponents;
+  } else {
+    // None of the other corners have a valid value. Use the last encoded value
+    // as the prediction if possible.
+    if (data_id > 0) {
+      data_offset = (data_id - 1) * kNumComponents;
+    } else {
+      // We are encoding the first value. Predict 0.
+      for (int i = 0; i < kNumComponents; ++i) {
+        predicted_value_[i] = 0;
+      }
+      return true;
+    }
+  }
+  for (int i = 0; i < kNumComponents; ++i) {
+    predicted_value_[i] = data[data_offset + i];
+  }
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_PORTABLE_PREDICTOR_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder.h
new file mode 100644
index 000000000..064e1b44f
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder.h
@@ -0,0 +1,90 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODER_H_
+
+#include <type_traits>
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_interface.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_decoding_transform.h"
+
+// Prediction schemes can be used during encoding and decoding of vertex
+// attributes to predict attribute values based on the previously
+// encoded/decoded data. The differences between the original and predicted
+// attribute values are used to compute correction values that can be usually
+// encoded with fewer bits compared to the original data.
+namespace draco {
+
+// Abstract base class for typed prediction schemes. It provides basic access
+// to the encoded attribute and to the supplied prediction transform.
+template <typename DataTypeT,
+          class TransformT =
+              PredictionSchemeDecodingTransform<DataTypeT, DataTypeT>>
+class PredictionSchemeDecoder : public PredictionSchemeTypedDecoderInterface<
+                                    DataTypeT, typename TransformT::CorrType> {
+ public:
+  typedef DataTypeT DataType;
+  typedef TransformT Transform;
+  // Correction type needs to be defined in the prediction transform class.
+  typedef typename Transform::CorrType CorrType;
+  explicit PredictionSchemeDecoder(const PointAttribute *attribute)
+      : PredictionSchemeDecoder(attribute, Transform()) {}
+  PredictionSchemeDecoder(const PointAttribute *attribute,
+                          const Transform &transform)
+      : attribute_(attribute), transform_(transform) {}
+
+  bool DecodePredictionData(DecoderBuffer *buffer) override {
+    if (!transform_.DecodeTransformData(buffer)) {
+      return false;
+    }
+    return true;
+  }
+
+  const PointAttribute *GetAttribute() const override { return attribute(); }
+
+  // Returns the number of parent attributes that are needed for the prediction.
+  int GetNumParentAttributes() const override { return 0; }
+
+  // Returns the type of each of the parent attribute.
+  GeometryAttribute::Type GetParentAttributeType(int /* i */) const override {
+    return GeometryAttribute::INVALID;
+  }
+
+  // Sets the required parent attribute.
+  bool SetParentAttribute(const PointAttribute * /* att */) override {
+    return false;
+  }
+
+  bool AreCorrectionsPositive() override {
+    return transform_.AreCorrectionsPositive();
+  }
+
+  PredictionSchemeTransformType GetTransformType() const override {
+    return transform_.GetType();
+  }
+
+ protected:
+  inline const PointAttribute *attribute() const { return attribute_; }
+  inline const Transform &transform() const { return transform_; }
+  inline Transform &transform() { return transform_; }
+
+ private:
+  const PointAttribute *attribute_;
+  Transform transform_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_factory.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_factory.h
new file mode 100644
index 000000000..cf2a6ba6b
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_factory.h
@@ -0,0 +1,194 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Functions for creating prediction schemes for decoders using the provided
+// prediction method id.
+
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODER_FACTORY_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODER_FACTORY_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_decoder.h"
+#include "draco/draco_features.h"
+#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_decoder.h"
+#endif
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_delta_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_factory.h"
+#include "draco/compression/mesh/mesh_decoder.h"
+
+namespace draco {
+
+// Factory class for creating mesh prediction schemes. The factory implements
+// operator() that is used to create an appropriate mesh prediction scheme in
+// CreateMeshPredictionScheme() function in prediction_scheme_factory.h
+template <typename DataTypeT>
+struct MeshPredictionSchemeDecoderFactory {
+  // Operator () specialized for the wrap transform. Wrap transform can be used
+  // for all mesh prediction schemes. The specialization is done in compile time
+  // to prevent instantiations of unneeded combinations of prediction schemes +
+  // prediction transforms.
+  template <class TransformT, class MeshDataT,
+            PredictionSchemeTransformType Method>
+  struct DispatchFunctor {
+    std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>> operator()(
+        PredictionSchemeMethod method, const PointAttribute *attribute,
+        const TransformT &transform, const MeshDataT &mesh_data,
+        uint16_t bitstream_version) {
+      if (method == MESH_PREDICTION_PARALLELOGRAM) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeParallelogramDecoder<DataTypeT, TransformT,
+                                                         MeshDataT>(
+                attribute, transform, mesh_data));
+      }
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+      else if (method == MESH_PREDICTION_MULTI_PARALLELOGRAM) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeMultiParallelogramDecoder<
+                DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                  mesh_data));
+      }
+#endif
+      else if (method == MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeConstrainedMultiParallelogramDecoder<
+                DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                  mesh_data));
+      }
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+      else if (method == MESH_PREDICTION_TEX_COORDS_DEPRECATED) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeTexCoordsDecoder<DataTypeT, TransformT,
+                                                     MeshDataT>(
+                attribute, transform, mesh_data, bitstream_version));
+      }
+#endif
+      else if (method == MESH_PREDICTION_TEX_COORDS_PORTABLE) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeTexCoordsPortableDecoder<
+                DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                  mesh_data));
+      }
+#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
+      else if (method == MESH_PREDICTION_GEOMETRIC_NORMAL) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeGeometricNormalDecoder<
+                DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                  mesh_data));
+      }
+#endif
+      return nullptr;
+    }
+  };
+
+#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
+  // Operator () specialized for normal octahedron transforms. These transforms
+  // are currently used only by the geometric normal prediction scheme (the
+  // transform is also used by delta coding, but delta predictor is not
+  // constructed in this function).
+  template <class TransformT, class MeshDataT>
+  struct DispatchFunctor<TransformT, MeshDataT,
+                         PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON_CANONICALIZED> {
+    std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>> operator()(
+        PredictionSchemeMethod method, const PointAttribute *attribute,
+        const TransformT &transform, const MeshDataT &mesh_data,
+        uint16_t bitstream_version) {
+      if (method == MESH_PREDICTION_GEOMETRIC_NORMAL) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeGeometricNormalDecoder<
+                DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                  mesh_data));
+      }
+      return nullptr;
+    }
+  };
+  template <class TransformT, class MeshDataT>
+  struct DispatchFunctor<TransformT, MeshDataT,
+                         PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON> {
+    std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>> operator()(
+        PredictionSchemeMethod method, const PointAttribute *attribute,
+        const TransformT &transform, const MeshDataT &mesh_data,
+        uint16_t bitstream_version) {
+      if (method == MESH_PREDICTION_GEOMETRIC_NORMAL) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeGeometricNormalDecoder<
+                DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                  mesh_data));
+      }
+      return nullptr;
+    }
+  };
+#endif
+
+  template <class TransformT, class MeshDataT>
+  std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>> operator()(
+      PredictionSchemeMethod method, const PointAttribute *attribute,
+      const TransformT &transform, const MeshDataT &mesh_data,
+      uint16_t bitstream_version) {
+    return DispatchFunctor<TransformT, MeshDataT, TransformT::GetType()>()(
+        method, attribute, transform, mesh_data, bitstream_version);
+  }
+};
+
+// Creates a prediction scheme for a given decoder and given prediction method.
+// The prediction schemes are automatically initialized with decoder specific
+// data if needed.
+template <typename DataTypeT, class TransformT>
+std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>
+CreatePredictionSchemeForDecoder(PredictionSchemeMethod method, int att_id,
+                                 const PointCloudDecoder *decoder,
+                                 const TransformT &transform) {
+  if (method == PREDICTION_NONE) {
+    return nullptr;
+  }
+  const PointAttribute *const att = decoder->point_cloud()->attribute(att_id);
+  if (decoder->GetGeometryType() == TRIANGULAR_MESH) {
+    // Cast the decoder to mesh decoder. This is not necessarily safe if there
+    // is some other decoder decides to use TRIANGULAR_MESH as the return type,
+    // but unfortunately there is not nice work around for this without using
+    // RTTI (double dispatch and similar concepts will not work because of the
+    // template nature of the prediction schemes).
+    const MeshDecoder *const mesh_decoder =
+        static_cast<const MeshDecoder *>(decoder);
+
+    auto ret = CreateMeshPredictionScheme<
+        MeshDecoder, PredictionSchemeDecoder<DataTypeT, TransformT>,
+        MeshPredictionSchemeDecoderFactory<DataTypeT>>(
+        mesh_decoder, method, att_id, transform, decoder->bitstream_version());
+    if (ret) {
+      return ret;
+    }
+    // Otherwise try to create another prediction scheme.
+  }
+  // Create delta decoder.
+  return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+      new PredictionSchemeDeltaDecoder<DataTypeT, TransformT>(att, transform));
+}
+
+// Create a prediction scheme using a default transform constructor.
+template <typename DataTypeT, class TransformT>
+std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>
+CreatePredictionSchemeForDecoder(PredictionSchemeMethod method, int att_id,
+                                 const PointCloudDecoder *decoder) {
+  return CreatePredictionSchemeForDecoder<DataTypeT, TransformT>(
+      method, att_id, decoder, TransformT());
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODER_FACTORY_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_interface.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_interface.h
new file mode 100644
index 000000000..6f19f7fdb
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_interface.h
@@ -0,0 +1,53 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODER_INTERFACE_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODER_INTERFACE_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_interface.h"
+#include "draco/core/decoder_buffer.h"
+
+// Prediction schemes can be used during encoding and decoding of attributes
+// to predict attribute values based on the previously encoded/decoded data.
+// See prediction_scheme.h for more details.
+namespace draco {
+
+// Abstract interface for all prediction schemes used during attribute encoding.
+class PredictionSchemeDecoderInterface : public PredictionSchemeInterface {
+ public:
+  // Method that can be used to decode any prediction scheme specific data
+  // from the input buffer.
+  virtual bool DecodePredictionData(DecoderBuffer *buffer) = 0;
+};
+
+// A specialized version of the prediction scheme interface for specific
+// input and output data types.
+// |entry_to_point_id_map| is the mapping between value entries to point ids
+// of the associated point cloud, where one entry is defined as |num_components|
+// values of the |in_data|.
+// DataTypeT is the data type of input and predicted values.
+// CorrTypeT is the data type used for storing corrected values.
+template <typename DataTypeT, typename CorrTypeT = DataTypeT>
+class PredictionSchemeTypedDecoderInterface
+    : public PredictionSchemeDecoderInterface {
+ public:
+  // Reverts changes made by the prediction scheme during encoding.
+  virtual bool ComputeOriginalValues(
+      const CorrTypeT *in_corr, DataTypeT *out_data, int size,
+      int num_components, const PointIndex *entry_to_point_id_map) = 0;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODER_INTERFACE_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoding_transform.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoding_transform.h
new file mode 100644
index 000000000..47c1532ad
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoding_transform.h
@@ -0,0 +1,65 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODING_TRANSFORM_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODING_TRANSFORM_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+
+// PredictionSchemeDecodingTransform is used to transform predicted values and
+// correction values into the final original attribute values.
+// DataTypeT is the data type of predicted values.
+// CorrTypeT is the data type used for storing corrected values. It allows
+// transforms to store corrections into a different type or format compared to
+// the predicted data.
+template <typename DataTypeT, typename CorrTypeT>
+class PredictionSchemeDecodingTransform {
+ public:
+  typedef CorrTypeT CorrType;
+  PredictionSchemeDecodingTransform() : num_components_(0) {}
+
+  void Init(int num_components) { num_components_ = num_components; }
+
+  // Computes the original value from the input predicted value and the decoded
+  // corrections. The default implementation is equal to std:plus.
+  inline void ComputeOriginalValue(const DataTypeT *predicted_vals,
+                                   const CorrTypeT *corr_vals,
+                                   DataTypeT *out_original_vals) const {
+    static_assert(std::is_same<DataTypeT, CorrTypeT>::value,
+                  "For the default prediction transform, correction and input "
+                  "data must be of the same type.");
+    for (int i = 0; i < num_components_; ++i) {
+      out_original_vals[i] = predicted_vals[i] + corr_vals[i];
+    }
+  }
+
+  // Decodes any transform specific data. Called before Init() method.
+  bool DecodeTransformData(DecoderBuffer * /* buffer */) { return true; }
+
+  // Should return true if all corrected values are guaranteed to be positive.
+  bool AreCorrectionsPositive() const { return false; }
+
+ protected:
+  int num_components() const { return num_components_; }
+
+ private:
+  int num_components_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODING_TRANSFORM_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_delta_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_delta_decoder.h
new file mode 100644
index 000000000..ae72c7120
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_delta_decoder.h
@@ -0,0 +1,65 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DELTA_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DELTA_DECODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_decoder.h"
+
+namespace draco {
+
+// Decoder for values encoded with delta coding. See the corresponding encoder
+// for more details.
+template <typename DataTypeT, class TransformT>
+class PredictionSchemeDeltaDecoder
+    : public PredictionSchemeDecoder<DataTypeT, TransformT> {
+ public:
+  using CorrType =
+      typename PredictionSchemeDecoder<DataTypeT, TransformT>::CorrType;
+  // Initialized the prediction scheme.
+  explicit PredictionSchemeDeltaDecoder(const PointAttribute *attribute)
+      : PredictionSchemeDecoder<DataTypeT, TransformT>(attribute) {}
+  PredictionSchemeDeltaDecoder(const PointAttribute *attribute,
+                               const TransformT &transform)
+      : PredictionSchemeDecoder<DataTypeT, TransformT>(attribute, transform) {}
+
+  bool ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                             int size, int num_components,
+                             const PointIndex *entry_to_point_id_map) override;
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return PREDICTION_DIFFERENCE;
+  }
+  bool IsInitialized() const override { return true; }
+};
+
+template <typename DataTypeT, class TransformT>
+bool PredictionSchemeDeltaDecoder<DataTypeT, TransformT>::ComputeOriginalValues(
+    const CorrType *in_corr, DataTypeT *out_data, int size, int num_components,
+    const PointIndex *) {
+  this->transform().Init(num_components);
+  // Decode the original value for the first element.
+  std::unique_ptr<DataTypeT[]> zero_vals(new DataTypeT[num_components]());
+  this->transform().ComputeOriginalValue(zero_vals.get(), in_corr, out_data);
+
+  // Decode data from the front using D(i) = D(i) + D(i - 1).
+  for (int i = num_components; i < size; i += num_components) {
+    this->transform().ComputeOriginalValue(out_data + i - num_components,
+                                           in_corr + i, out_data + i);
+  }
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DELTA_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_delta_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_delta_encoder.h
new file mode 100644
index 000000000..324afafa6
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_delta_encoder.h
@@ -0,0 +1,69 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DELTA_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DELTA_ENCODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_encoder.h"
+
+namespace draco {
+
+// Basic prediction scheme based on computing backward differences between
+// stored attribute values (also known as delta-coding). Usually works better
+// than the reference point prediction scheme, because nearby values are often
+// encoded next to each other.
+template <typename DataTypeT, class TransformT>
+class PredictionSchemeDeltaEncoder
+    : public PredictionSchemeEncoder<DataTypeT, TransformT> {
+ public:
+  using CorrType =
+      typename PredictionSchemeEncoder<DataTypeT, TransformT>::CorrType;
+  // Initialized the prediction scheme.
+  explicit PredictionSchemeDeltaEncoder(const PointAttribute *attribute)
+      : PredictionSchemeEncoder<DataTypeT, TransformT>(attribute) {}
+  PredictionSchemeDeltaEncoder(const PointAttribute *attribute,
+                               const TransformT &transform)
+      : PredictionSchemeEncoder<DataTypeT, TransformT>(attribute, transform) {}
+
+  bool ComputeCorrectionValues(
+      const DataTypeT *in_data, CorrType *out_corr, int size,
+      int num_components, const PointIndex *entry_to_point_id_map) override;
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return PREDICTION_DIFFERENCE;
+  }
+  bool IsInitialized() const override { return true; }
+};
+
+template <typename DataTypeT, class TransformT>
+bool PredictionSchemeDeltaEncoder<
+    DataTypeT, TransformT>::ComputeCorrectionValues(const DataTypeT *in_data,
+                                                    CorrType *out_corr,
+                                                    int size,
+                                                    int num_components,
+                                                    const PointIndex *) {
+  this->transform().Init(in_data, size, num_components);
+  // Encode data from the back using D(i) = D(i) - D(i - 1).
+  for (int i = size - num_components; i > 0; i -= num_components) {
+    this->transform().ComputeCorrection(
+        in_data + i, in_data + i - num_components, out_corr + i);
+  }
+  // Encode correction for the first element.
+  std::unique_ptr<DataTypeT[]> zero_vals(new DataTypeT[num_components]());
+  this->transform().ComputeCorrection(in_data, zero_vals.get(), out_corr);
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DELTA_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder.h
new file mode 100644
index 000000000..2a211a9fc
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder.h
@@ -0,0 +1,90 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_H_
+
+#include <type_traits>
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_interface.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_encoding_transform.h"
+
+// Prediction schemes can be used during encoding and decoding of vertex
+// attributes to predict attribute values based on the previously
+// encoded/decoded data. The differences between the original and predicted
+// attribute values are used to compute correction values that can be usually
+// encoded with fewer bits compared to the original data.
+namespace draco {
+
+// Abstract base class for typed prediction schemes. It provides basic access
+// to the encoded attribute and to the supplied prediction transform.
+template <typename DataTypeT,
+          class TransformT =
+              PredictionSchemeEncodingTransform<DataTypeT, DataTypeT>>
+class PredictionSchemeEncoder : public PredictionSchemeTypedEncoderInterface<
+                                    DataTypeT, typename TransformT::CorrType> {
+ public:
+  typedef DataTypeT DataType;
+  typedef TransformT Transform;
+  // Correction type needs to be defined in the prediction transform class.
+  typedef typename Transform::CorrType CorrType;
+  explicit PredictionSchemeEncoder(const PointAttribute *attribute)
+      : PredictionSchemeEncoder(attribute, Transform()) {}
+  PredictionSchemeEncoder(const PointAttribute *attribute,
+                          const Transform &transform)
+      : attribute_(attribute), transform_(transform) {}
+
+  bool EncodePredictionData(EncoderBuffer *buffer) override {
+    if (!transform_.EncodeTransformData(buffer)) {
+      return false;
+    }
+    return true;
+  }
+
+  const PointAttribute *GetAttribute() const override { return attribute(); }
+
+  // Returns the number of parent attributes that are needed for the prediction.
+  int GetNumParentAttributes() const override { return 0; }
+
+  // Returns the type of each of the parent attribute.
+  GeometryAttribute::Type GetParentAttributeType(int /* i */) const override {
+    return GeometryAttribute::INVALID;
+  }
+
+  // Sets the required parent attribute.
+  bool SetParentAttribute(const PointAttribute * /* att */) override {
+    return false;
+  }
+
+  bool AreCorrectionsPositive() override {
+    return transform_.AreCorrectionsPositive();
+  }
+
+  PredictionSchemeTransformType GetTransformType() const override {
+    return transform_.GetType();
+  }
+
+ protected:
+  inline const PointAttribute *attribute() const { return attribute_; }
+  inline const Transform &transform() const { return transform_; }
+  inline Transform &transform() { return transform_; }
+
+ private:
+  const PointAttribute *attribute_;
+  Transform transform_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.cc
new file mode 100644
index 000000000..f410a6cd2
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.cc
@@ -0,0 +1,85 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.h"
+
+namespace draco {
+
+PredictionSchemeMethod SelectPredictionMethod(
+    int att_id, const PointCloudEncoder *encoder) {
+  if (encoder->options()->GetSpeed() >= 10) {
+    // Selected fastest, though still doing some compression.
+    return PREDICTION_DIFFERENCE;
+  }
+  if (encoder->GetGeometryType() == TRIANGULAR_MESH) {
+    // Use speed setting to select the best encoding method.
+    const PointAttribute *const att = encoder->point_cloud()->attribute(att_id);
+    if (att->attribute_type() == GeometryAttribute::TEX_COORD) {
+      if (encoder->options()->GetSpeed() < 4) {
+        // Use texture coordinate prediction for speeds 0, 1, 2, 3.
+        return MESH_PREDICTION_TEX_COORDS_PORTABLE;
+      }
+    }
+    if (att->attribute_type() == GeometryAttribute::NORMAL) {
+#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
+      if (encoder->options()->GetSpeed() < 4) {
+        // Use geometric normal prediction for speeds 0, 1, 2, 3.
+        // For this prediction, the position attribute needs to be either
+        // integer or quantized as well.
+        const int pos_att_id = encoder->point_cloud()->GetNamedAttributeId(
+            GeometryAttribute::POSITION);
+        const PointAttribute *const pos_att =
+            encoder->point_cloud()->GetNamedAttribute(
+                GeometryAttribute::POSITION);
+        if (pos_att && (IsDataTypeIntegral(pos_att->data_type()) ||
+                        encoder->options()->GetAttributeInt(
+                            pos_att_id, "quantization_bits", -1) > 0)) {
+          return MESH_PREDICTION_GEOMETRIC_NORMAL;
+        }
+      }
+#endif
+      return PREDICTION_DIFFERENCE;  // default
+    }
+    // Handle other attribute types.
+    if (encoder->options()->GetSpeed() >= 8) {
+      return PREDICTION_DIFFERENCE;
+    }
+    if (encoder->options()->GetSpeed() >= 2 ||
+        encoder->point_cloud()->num_points() < 40) {
+      // Parallelogram prediction is used for speeds 2 - 7 or when the overhead
+      // of using constrained multi-parallelogram would be too high.
+      return MESH_PREDICTION_PARALLELOGRAM;
+    }
+    // Multi-parallelogram is used for speeds 0, 1.
+    return MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM;
+  }
+  // Default option is delta coding.
+  return PREDICTION_DIFFERENCE;
+}
+
+// Returns the preferred prediction scheme based on the encoder options.
+PredictionSchemeMethod GetPredictionMethodFromOptions(
+    int att_id, const EncoderOptions &options) {
+  const int pred_type =
+      options.GetAttributeInt(att_id, "prediction_scheme", -1);
+  if (pred_type == -1) {
+    return PREDICTION_UNDEFINED;
+  }
+  if (pred_type < 0 || pred_type >= NUM_PREDICTION_SCHEMES) {
+    return PREDICTION_NONE;
+  }
+  return static_cast<PredictionSchemeMethod>(pred_type);
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.h
new file mode 100644
index 000000000..40a7683aa
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.h
@@ -0,0 +1,129 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Functions for creating prediction schemes for encoders using the provided
+// prediction method id.
+
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_FACTORY_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_FACTORY_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_encoder.h"
+#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_encoder.h"
+#endif
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_delta_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_factory.h"
+#include "draco/compression/mesh/mesh_encoder.h"
+
+namespace draco {
+
+// Selects a prediction method based on the input geometry type and based on the
+// encoder options.
+PredictionSchemeMethod SelectPredictionMethod(int att_id,
+                                              const PointCloudEncoder *encoder);
+
+// Factory class for creating mesh prediction schemes.
+template <typename DataTypeT>
+struct MeshPredictionSchemeEncoderFactory {
+  template <class TransformT, class MeshDataT>
+  std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>> operator()(
+      PredictionSchemeMethod method, const PointAttribute *attribute,
+      const TransformT &transform, const MeshDataT &mesh_data,
+      uint16_t bitstream_version) {
+    if (method == MESH_PREDICTION_PARALLELOGRAM) {
+      return std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>>(
+          new MeshPredictionSchemeParallelogramEncoder<DataTypeT, TransformT,
+                                                       MeshDataT>(
+              attribute, transform, mesh_data));
+    } else if (method == MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM) {
+      return std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>>(
+          new MeshPredictionSchemeConstrainedMultiParallelogramEncoder<
+              DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                mesh_data));
+    } else if (method == MESH_PREDICTION_TEX_COORDS_PORTABLE) {
+      return std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>>(
+          new MeshPredictionSchemeTexCoordsPortableEncoder<
+              DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                mesh_data));
+    }
+#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
+    else if (method == MESH_PREDICTION_GEOMETRIC_NORMAL) {
+      return std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>>(
+          new MeshPredictionSchemeGeometricNormalEncoder<DataTypeT, TransformT,
+                                                         MeshDataT>(
+              attribute, transform, mesh_data));
+    }
+#endif
+    return nullptr;
+  }
+};
+
+// Creates a prediction scheme for a given encoder and given prediction method.
+// The prediction schemes are automatically initialized with encoder specific
+// data if needed.
+template <typename DataTypeT, class TransformT>
+std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>>
+CreatePredictionSchemeForEncoder(PredictionSchemeMethod method, int att_id,
+                                 const PointCloudEncoder *encoder,
+                                 const TransformT &transform) {
+  const PointAttribute *const att = encoder->point_cloud()->attribute(att_id);
+  if (method == PREDICTION_UNDEFINED) {
+    method = SelectPredictionMethod(att_id, encoder);
+  }
+  if (method == PREDICTION_NONE) {
+    return nullptr;  // No prediction is used.
+  }
+  if (encoder->GetGeometryType() == TRIANGULAR_MESH) {
+    // Cast the encoder to mesh encoder. This is not necessarily safe if there
+    // is some other encoder decides to use TRIANGULAR_MESH as the return type,
+    // but unfortunately there is not nice work around for this without using
+    // RTTI (double dispatch and similar concepts will not work because of the
+    // template nature of the prediction schemes).
+    const MeshEncoder *const mesh_encoder =
+        static_cast<const MeshEncoder *>(encoder);
+    auto ret = CreateMeshPredictionScheme<
+        MeshEncoder, PredictionSchemeEncoder<DataTypeT, TransformT>,
+        MeshPredictionSchemeEncoderFactory<DataTypeT>>(
+        mesh_encoder, method, att_id, transform, kDracoMeshBitstreamVersion);
+    if (ret) {
+      return ret;
+    }
+    // Otherwise try to create another prediction scheme.
+  }
+  // Create delta encoder.
+  return std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>>(
+      new PredictionSchemeDeltaEncoder<DataTypeT, TransformT>(att, transform));
+}
+
+// Create a prediction scheme using a default transform constructor.
+template <typename DataTypeT, class TransformT>
+std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>>
+CreatePredictionSchemeForEncoder(PredictionSchemeMethod method, int att_id,
+                                 const PointCloudEncoder *encoder) {
+  return CreatePredictionSchemeForEncoder<DataTypeT, TransformT>(
+      method, att_id, encoder, TransformT());
+}
+
+// Returns the preferred prediction scheme based on the encoder options.
+PredictionSchemeMethod GetPredictionMethodFromOptions(
+    int att_id, const EncoderOptions &options);
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_FACTORY_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_interface.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_interface.h
new file mode 100644
index 000000000..37aa9f76a
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_interface.h
@@ -0,0 +1,55 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_INTERFACE_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_INTERFACE_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_interface.h"
+#include "draco/core/encoder_buffer.h"
+
+// Prediction schemes can be used during encoding and decoding of attributes
+// to predict attribute values based on the previously encoded/decoded data.
+// See prediction_scheme.h for more details.
+namespace draco {
+
+// Abstract interface for all prediction schemes used during attribute encoding.
+class PredictionSchemeEncoderInterface : public PredictionSchemeInterface {
+ public:
+  // Method that can be used to encode any prediction scheme specific data
+  // into the output buffer.
+  virtual bool EncodePredictionData(EncoderBuffer *buffer) = 0;
+};
+
+// A specialized version of the prediction scheme interface for specific
+// input and output data types.
+// |entry_to_point_id_map| is the mapping between value entries to point ids
+// of the associated point cloud, where one entry is defined as |num_components|
+// values of the |in_data|.
+// DataTypeT is the data type of input and predicted values.
+// CorrTypeT is the data type used for storing corrected values.
+template <typename DataTypeT, typename CorrTypeT = DataTypeT>
+class PredictionSchemeTypedEncoderInterface
+    : public PredictionSchemeEncoderInterface {
+ public:
+  // Applies the prediction scheme when encoding the attribute.
+  // |in_data| contains value entries to be encoded.
+  // |out_corr| is an output array containing the to be encoded corrections.
+  virtual bool ComputeCorrectionValues(
+      const DataTypeT *in_data, CorrTypeT *out_corr, int size,
+      int num_components, const PointIndex *entry_to_point_id_map) = 0;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_INTERFACE_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoding_transform.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoding_transform.h
new file mode 100644
index 000000000..0929492aa
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoding_transform.h
@@ -0,0 +1,77 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODING_TRANSFORM_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODING_TRANSFORM_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// PredictionSchemeEncodingTransform is used to transform predicted values into
+// correction values.
+// CorrTypeT is the data type used for storing corrected values. It allows
+// transforms to store corrections into a different type or format compared to
+// the predicted data.
+template <typename DataTypeT, typename CorrTypeT>
+class PredictionSchemeEncodingTransform {
+ public:
+  typedef CorrTypeT CorrType;
+  PredictionSchemeEncodingTransform() : num_components_(0) {}
+
+  PredictionSchemeTransformType GetType() const {
+    return PREDICTION_TRANSFORM_DELTA;
+  }
+
+  // Performs any custom initialization of the transform for the encoder.
+  // |size| = total number of values in |orig_data| (i.e., number of entries *
+  // number of components).
+  void Init(const DataTypeT * /* orig_data */, int /* size */,
+            int num_components) {
+    num_components_ = num_components;
+  }
+
+  // Computes the corrections based on the input original values and the
+  // predicted values. The correction is always computed for all components
+  // of the input element. |val_id| is the id of the input value
+  // (i.e., element_id * num_components). The default implementation is equal to
+  // std::minus.
+  inline void ComputeCorrection(const DataTypeT *original_vals,
+                                const DataTypeT *predicted_vals,
+                                CorrTypeT *out_corr_vals) {
+    static_assert(std::is_same<DataTypeT, CorrTypeT>::value,
+                  "For the default prediction transform, correction and input "
+                  "data must be of the same type.");
+    for (int i = 0; i < num_components_; ++i) {
+      out_corr_vals[i] = original_vals[i] - predicted_vals[i];
+    }
+  }
+
+  // Encode any transform specific data.
+  bool EncodeTransformData(EncoderBuffer * /* buffer */) { return true; }
+
+  // Should return true if all corrected values are guaranteed to be positive.
+  bool AreCorrectionsPositive() const { return false; }
+
+ protected:
+  int num_components() const { return num_components_; }
+
+ private:
+  int num_components_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODING_TRANSFORM_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_factory.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_factory.h
new file mode 100644
index 000000000..b36c4c8a2
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_factory.h
@@ -0,0 +1,85 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Functions for creating prediction schemes from a provided prediction method
+// name. The functions in this file can create only basic prediction schemes
+// that don't require any encoder or decoder specific data. To create more
+// sophisticated prediction schemes, use functions from either
+// prediction_scheme_encoder_factory.h  or,
+// prediction_scheme_decoder_factory.h.
+
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_FACTORY_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_FACTORY_H_
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_data.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/mesh/mesh_attribute_corner_table.h"
+
+namespace draco {
+
+template <class EncodingDataSourceT, class PredictionSchemeT,
+          class MeshPredictionSchemeFactoryT>
+std::unique_ptr<PredictionSchemeT> CreateMeshPredictionScheme(
+    const EncodingDataSourceT *source, PredictionSchemeMethod method,
+    int att_id, const typename PredictionSchemeT::Transform &transform,
+    uint16_t bitstream_version) {
+  const PointAttribute *const att = source->point_cloud()->attribute(att_id);
+  if (source->GetGeometryType() == TRIANGULAR_MESH &&
+      (method == MESH_PREDICTION_PARALLELOGRAM ||
+       method == MESH_PREDICTION_MULTI_PARALLELOGRAM ||
+       method == MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM ||
+       method == MESH_PREDICTION_TEX_COORDS_PORTABLE ||
+       method == MESH_PREDICTION_GEOMETRIC_NORMAL ||
+       method == MESH_PREDICTION_TEX_COORDS_DEPRECATED)) {
+    const CornerTable *const ct = source->GetCornerTable();
+    const MeshAttributeIndicesEncodingData *const encoding_data =
+        source->GetAttributeEncodingData(att_id);
+    if (ct == nullptr || encoding_data == nullptr) {
+      // No connectivity data found.
+      return nullptr;
+    }
+    // Connectivity data exists.
+    const MeshAttributeCornerTable *const att_ct =
+        source->GetAttributeCornerTable(att_id);
+    if (att_ct != nullptr) {
+      typedef MeshPredictionSchemeData<MeshAttributeCornerTable> MeshData;
+      MeshData md;
+      md.Set(source->mesh(), att_ct,
+             &encoding_data->encoded_attribute_value_index_to_corner_map,
+             &encoding_data->vertex_to_encoded_attribute_value_index_map);
+      MeshPredictionSchemeFactoryT factory;
+      auto ret = factory(method, att, transform, md, bitstream_version);
+      if (ret) {
+        return ret;
+      }
+    } else {
+      typedef MeshPredictionSchemeData<CornerTable> MeshData;
+      MeshData md;
+      md.Set(source->mesh(), ct,
+             &encoding_data->encoded_attribute_value_index_to_corner_map,
+             &encoding_data->vertex_to_encoded_attribute_value_index_map);
+      MeshPredictionSchemeFactoryT factory;
+      auto ret = factory(method, att, transform, md, bitstream_version);
+      if (ret) {
+        return ret;
+      }
+    }
+  }
+  return nullptr;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_FACTORY_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_interface.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_interface.h
new file mode 100644
index 000000000..c9b370693
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_interface.h
@@ -0,0 +1,60 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_INTERFACE_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_INTERFACE_H_
+
+#include "draco/attributes/point_attribute.h"
+#include "draco/compression/config/compression_shared.h"
+
+// Prediction schemes can be used during encoding and decoding of attributes
+// to predict attribute values based on the previously encoded/decoded data.
+// See prediction_scheme.h for more details.
+namespace draco {
+
+// Abstract interface for all prediction schemes used during attribute encoding.
+class PredictionSchemeInterface {
+ public:
+  virtual ~PredictionSchemeInterface() = default;
+  virtual PredictionSchemeMethod GetPredictionMethod() const = 0;
+
+  // Returns the encoded attribute.
+  virtual const PointAttribute *GetAttribute() const = 0;
+
+  // Returns true when the prediction scheme is initialized with all data it
+  // needs.
+  virtual bool IsInitialized() const = 0;
+
+  // Returns the number of parent attributes that are needed for the prediction.
+  virtual int GetNumParentAttributes() const = 0;
+
+  // Returns the type of each of the parent attribute.
+  virtual GeometryAttribute::Type GetParentAttributeType(int i) const = 0;
+
+  // Sets the required parent attribute.
+  // Returns false if the attribute doesn't meet the requirements of the
+  // prediction scheme.
+  virtual bool SetParentAttribute(const PointAttribute *att) = 0;
+
+  // Method should return true if the prediction scheme guarantees that all
+  // correction values are always positive (or at least non-negative).
+  virtual bool AreCorrectionsPositive() = 0;
+
+  // Returns the transform type used by the prediction scheme.
+  virtual PredictionSchemeTransformType GetTransformType() const = 0;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_INTERFACE_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_decoding_transform.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_decoding_transform.h
new file mode 100644
index 000000000..5a6c7c2dd
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_decoding_transform.h
@@ -0,0 +1,118 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_DECODING_TRANSFORM_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_DECODING_TRANSFORM_H_
+
+#include <cmath>
+
+#include "draco/compression/attributes/normal_compression_utils.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_base.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/macros.h"
+#include "draco/core/vector_d.h"
+
+namespace draco {
+
+// Class for converting correction values transformed by the canonicalized
+// normal octahedron transform back to the original values. See the
+// corresponding encoder for more details.
+template <typename DataTypeT>
+class PredictionSchemeNormalOctahedronCanonicalizedDecodingTransform
+    : public PredictionSchemeNormalOctahedronCanonicalizedTransformBase<
+          DataTypeT> {
+ public:
+  typedef VectorD<DataTypeT, 2> Point2;
+  typedef DataTypeT CorrType;
+  typedef DataTypeT DataType;
+
+  PredictionSchemeNormalOctahedronCanonicalizedDecodingTransform() {}
+
+  // Dummy to fulfill concept.
+  void Init(int num_components) {}
+
+  bool DecodeTransformData(DecoderBuffer *buffer) {
+    DataTypeT max_quantized_value, center_value;
+    if (!buffer->Decode(&max_quantized_value)) {
+      return false;
+    }
+    if (!buffer->Decode(&center_value)) {
+      return false;
+    }
+    (void)center_value;
+    if (!this->set_max_quantized_value(max_quantized_value)) {
+      return false;
+    }
+    // Account for reading wrong values, e.g., due to fuzzing.
+    if (this->quantization_bits() < 2) {
+      return false;
+    }
+    if (this->quantization_bits() > 30) {
+      return false;
+    }
+    return true;
+  }
+
+  inline void ComputeOriginalValue(const DataType *pred_vals,
+                                   const CorrType *corr_vals,
+                                   DataType *out_orig_vals) const {
+    DRACO_DCHECK_LE(pred_vals[0], 2 * this->center_value());
+    DRACO_DCHECK_LE(pred_vals[1], 2 * this->center_value());
+    DRACO_DCHECK_LE(corr_vals[0], 2 * this->center_value());
+    DRACO_DCHECK_LE(corr_vals[1], 2 * this->center_value());
+
+    DRACO_DCHECK_LE(0, pred_vals[0]);
+    DRACO_DCHECK_LE(0, pred_vals[1]);
+    DRACO_DCHECK_LE(0, corr_vals[0]);
+    DRACO_DCHECK_LE(0, corr_vals[1]);
+
+    const Point2 pred = Point2(pred_vals[0], pred_vals[1]);
+    const Point2 corr = Point2(corr_vals[0], corr_vals[1]);
+    const Point2 orig = ComputeOriginalValue(pred, corr);
+
+    out_orig_vals[0] = orig[0];
+    out_orig_vals[1] = orig[1];
+  }
+
+ private:
+  Point2 ComputeOriginalValue(Point2 pred, Point2 corr) const {
+    const Point2 t(this->center_value(), this->center_value());
+    pred = pred - t;
+    const bool pred_is_in_diamond = this->IsInDiamond(pred[0], pred[1]);
+    if (!pred_is_in_diamond) {
+      this->InvertDiamond(&pred[0], &pred[1]);
+    }
+    const bool pred_is_in_bottom_left = this->IsInBottomLeft(pred);
+    const int32_t rotation_count = this->GetRotationCount(pred);
+    if (!pred_is_in_bottom_left) {
+      pred = this->RotatePoint(pred, rotation_count);
+    }
+    Point2 orig = pred + corr;
+    orig[0] = this->ModMax(orig[0]);
+    orig[1] = this->ModMax(orig[1]);
+    if (!pred_is_in_bottom_left) {
+      const int32_t reverse_rotation_count = (4 - rotation_count) % 4;
+      orig = this->RotatePoint(orig, reverse_rotation_count);
+    }
+    if (!pred_is_in_diamond) {
+      this->InvertDiamond(&orig[0], &orig[1]);
+    }
+    orig = orig + t;
+    return orig;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_DECODING_TRANSFORM_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_encoding_transform.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_encoding_transform.h
new file mode 100644
index 000000000..0dc96967b
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_encoding_transform.h
@@ -0,0 +1,116 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_ENCODING_TRANSFORM_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_ENCODING_TRANSFORM_H_
+
+#include <cmath>
+
+#include "draco/compression/attributes/normal_compression_utils.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_base.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/macros.h"
+#include "draco/core/vector_d.h"
+
+namespace draco {
+
+// The transform works on octahedral coordinates for normals. The square is
+// subdivided into four inner triangles (diamond) and four outer triangles. The
+// inner triangles are associated with the upper part of the octahedron and the
+// outer triangles are associated with the lower part.
+// Given a prediction value P and the actual value Q that should be encoded,
+// this transform first checks if P is outside the diamond. If so, the outer
+// triangles are flipped towards the inside and vice versa. Then it checks if p
+// is in the bottom left quadrant. If it is not, it rotates p and q accordingly.
+// The actual correction value is then based on the mapped and rotated P and Q
+// values. The inversion tends to result in shorter correction vectors and the
+// rotation makes it so that all long correction values are positive, reducing
+// the possible value range of the correction values and increasing the
+// occurrences of positive large correction values, which helps the entropy
+// encoder. This is possible since P is also known by the decoder, see also
+// ComputeCorrection and ComputeOriginalValue functions.
+// Note that the tile is not periodic, which implies that the outer edges can
+// not be identified, which requires us to use an odd number of values on each
+// axis.
+// DataTypeT is expected to be some integral type.
+//
+template <typename DataTypeT>
+class PredictionSchemeNormalOctahedronCanonicalizedEncodingTransform
+    : public PredictionSchemeNormalOctahedronCanonicalizedTransformBase<
+          DataTypeT> {
+ public:
+  typedef PredictionSchemeNormalOctahedronCanonicalizedTransformBase<DataTypeT>
+      Base;
+  typedef VectorD<DataTypeT, 2> Point2;
+  typedef DataTypeT CorrType;
+  typedef DataTypeT DataType;
+
+  // We expect the mod value to be of the form 2^b-1.
+  explicit PredictionSchemeNormalOctahedronCanonicalizedEncodingTransform(
+      DataType max_quantized_value)
+      : Base(max_quantized_value) {}
+
+  // Dummy function to fulfill concept.
+  void Init(const DataTypeT *orig_data, int size, int num_components) {}
+
+  bool EncodeTransformData(EncoderBuffer *buffer) {
+    buffer->Encode(this->max_quantized_value());
+    buffer->Encode(this->center_value());
+    return true;
+  }
+
+  inline void ComputeCorrection(const DataType *orig_vals,
+                                const DataType *pred_vals,
+                                CorrType *out_corr_vals) const {
+    DRACO_DCHECK_LE(pred_vals[0], this->center_value() * 2);
+    DRACO_DCHECK_LE(pred_vals[1], this->center_value() * 2);
+    DRACO_DCHECK_LE(orig_vals[0], this->center_value() * 2);
+    DRACO_DCHECK_LE(orig_vals[1], this->center_value() * 2);
+    DRACO_DCHECK_LE(0, pred_vals[0]);
+    DRACO_DCHECK_LE(0, pred_vals[1]);
+    DRACO_DCHECK_LE(0, orig_vals[0]);
+    DRACO_DCHECK_LE(0, orig_vals[1]);
+
+    const Point2 orig = Point2(orig_vals[0], orig_vals[1]);
+    const Point2 pred = Point2(pred_vals[0], pred_vals[1]);
+    const Point2 corr = ComputeCorrection(orig, pred);
+
+    out_corr_vals[0] = corr[0];
+    out_corr_vals[1] = corr[1];
+  }
+
+ private:
+  Point2 ComputeCorrection(Point2 orig, Point2 pred) const {
+    const Point2 t(this->center_value(), this->center_value());
+    orig = orig - t;
+    pred = pred - t;
+    if (!this->IsInDiamond(pred[0], pred[1])) {
+      this->InvertDiamond(&orig[0], &orig[1]);
+      this->InvertDiamond(&pred[0], &pred[1]);
+    }
+    if (!this->IsInBottomLeft(pred)) {
+      const int32_t rotation_count = this->GetRotationCount(pred);
+      orig = this->RotatePoint(orig, rotation_count);
+      pred = this->RotatePoint(pred, rotation_count);
+    }
+    Point2 corr = orig - pred;
+    corr[0] = this->MakePositive(corr[0]);
+    corr[1] = this->MakePositive(corr[1]);
+    return corr;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_ENCODING_TRANSFORM_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_base.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_base.h
new file mode 100644
index 000000000..4a1e3a67b
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_base.h
@@ -0,0 +1,102 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_TRANSFORM_BASE_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_TRANSFORM_BASE_H_
+
+#include <cmath>
+
+#include "draco/compression/attributes/normal_compression_utils.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_base.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/bit_utils.h"
+#include "draco/core/macros.h"
+#include "draco/core/vector_d.h"
+
+namespace draco {
+
+// Base class containing shared functionality used by both encoding and decoding
+// canonicalized normal octahedron prediction scheme transforms. See the
+// encoding transform for more details about the method.
+template <typename DataTypeT>
+class PredictionSchemeNormalOctahedronCanonicalizedTransformBase
+    : public PredictionSchemeNormalOctahedronTransformBase<DataTypeT> {
+ public:
+  typedef PredictionSchemeNormalOctahedronTransformBase<DataTypeT> Base;
+  typedef VectorD<DataTypeT, 2> Point2;
+  typedef DataTypeT DataType;
+
+  PredictionSchemeNormalOctahedronCanonicalizedTransformBase() : Base() {}
+  // We expect the mod value to be of the form 2^b-1.
+  explicit PredictionSchemeNormalOctahedronCanonicalizedTransformBase(
+      DataType mod_value)
+      : Base(mod_value) {}
+
+  static constexpr PredictionSchemeTransformType GetType() {
+    return PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON_CANONICALIZED;
+  }
+
+  int32_t GetRotationCount(Point2 pred) const {
+    const DataType sign_x = pred[0];
+    const DataType sign_y = pred[1];
+
+    int32_t rotation_count = 0;
+    if (sign_x == 0) {
+      if (sign_y == 0) {
+        rotation_count = 0;
+      } else if (sign_y > 0) {
+        rotation_count = 3;
+      } else {
+        rotation_count = 1;
+      }
+    } else if (sign_x > 0) {
+      if (sign_y >= 0) {
+        rotation_count = 2;
+      } else {
+        rotation_count = 1;
+      }
+    } else {
+      if (sign_y <= 0) {
+        rotation_count = 0;
+      } else {
+        rotation_count = 3;
+      }
+    }
+    return rotation_count;
+  }
+
+  Point2 RotatePoint(Point2 p, int32_t rotation_count) const {
+    switch (rotation_count) {
+      case 1:
+        return Point2(p[1], -p[0]);
+      case 2:
+        return Point2(-p[0], -p[1]);
+      case 3:
+        return Point2(-p[1], p[0]);
+      default:
+        return p;
+    }
+  }
+
+  bool IsInBottomLeft(const Point2 &p) const {
+    if (p[0] == 0 && p[1] == 0) {
+      return true;
+    }
+    return (p[0] < 0 && p[1] <= 0);
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_TRANSFORM_BASE_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_test.cc
new file mode 100644
index 000000000..8c8932f77
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_test.cc
@@ -0,0 +1,192 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_encoding_transform.h"
+#include "draco/core/draco_test_base.h"
+
+namespace {
+
+class PredictionSchemeNormalOctahedronCanonicalizedTransformTest
+    : public ::testing::Test {
+ protected:
+  typedef draco::PredictionSchemeNormalOctahedronCanonicalizedEncodingTransform<
+      int32_t>
+      Transform;
+  typedef Transform::Point2 Point2;
+
+  void TestComputeCorrection(const Transform &transform, const int32_t &ox,
+                             const int32_t &oy, const int32_t &px,
+                             const int32_t &py, const int32_t &cx,
+                             const int32_t &cy) {
+    const int32_t o[2] = {ox + 7, oy + 7};
+    const int32_t p[2] = {px + 7, py + 7};
+    int32_t corr[2] = {500, 500};
+    transform.ComputeCorrection(o, p, corr);
+    ASSERT_EQ(corr[0], (cx + 15) % 15);
+    ASSERT_EQ(corr[1], (cy + 15) % 15);
+  }
+
+  void TestGetRotationCount(const Transform &transform, const Point2 &pred,
+                            const int32_t &rot_dir) {
+    const int32_t rotation_count = transform.GetRotationCount(pred);
+    ASSERT_EQ(rot_dir, rotation_count);
+  }
+
+  void TestRotateRepresentation(const Transform &transform, const Point2 &org,
+                                const Point2 &pred, const Point2 &rot_org,
+                                const Point2 &rot_pred) {
+    const int32_t rotation_count = transform.GetRotationCount(pred);
+    const Point2 res_org = transform.RotatePoint(org, rotation_count);
+    const Point2 res_pred = transform.RotatePoint(pred, rotation_count);
+    ASSERT_EQ(rot_org[0], res_org[0]);
+    ASSERT_EQ(rot_org[1], res_org[1]);
+    ASSERT_EQ(rot_pred[0], res_pred[0]);
+    ASSERT_EQ(rot_pred[1], res_pred[1]);
+  }
+};
+
+TEST_F(PredictionSchemeNormalOctahedronCanonicalizedTransformTest, Init) {
+  const Transform transform(15);
+  ASSERT_TRUE(transform.AreCorrectionsPositive());
+}
+
+TEST_F(PredictionSchemeNormalOctahedronCanonicalizedTransformTest,
+       IsInBottomLeft) {
+  const Transform transform(15);
+  ASSERT_TRUE(transform.IsInBottomLeft(Point2(0, 0)));
+  ASSERT_TRUE(transform.IsInBottomLeft(Point2(-1, -1)));
+  ASSERT_TRUE(transform.IsInBottomLeft(Point2(-7, -7)));
+
+  ASSERT_FALSE(transform.IsInBottomLeft(Point2(1, 1)));
+  ASSERT_FALSE(transform.IsInBottomLeft(Point2(7, 7)));
+  ASSERT_FALSE(transform.IsInBottomLeft(Point2(-1, 1)));
+  ASSERT_FALSE(transform.IsInBottomLeft(Point2(-7, 7)));
+  ASSERT_FALSE(transform.IsInBottomLeft(Point2(1, -1)));
+  ASSERT_FALSE(transform.IsInBottomLeft(Point2(7, -7)));
+}
+
+TEST_F(PredictionSchemeNormalOctahedronCanonicalizedTransformTest,
+       GetRotationCount) {
+  const Transform transform(15);
+  TestGetRotationCount(transform, Point2(1, 2), 2);    // top right
+  TestGetRotationCount(transform, Point2(-1, 2), 3);   // top left
+  TestGetRotationCount(transform, Point2(1, -2), 1);   // bottom right
+  TestGetRotationCount(transform, Point2(-1, -2), 0);  // bottom left
+  TestGetRotationCount(transform, Point2(0, 2), 3);    // top left
+  TestGetRotationCount(transform, Point2(0, -2), 1);   // bottom right
+  TestGetRotationCount(transform, Point2(2, 0), 2);    // top right
+  TestGetRotationCount(transform, Point2(-2, 0), 0);   // bottom left
+  TestGetRotationCount(transform, Point2(0, 0), 0);    // bottom left
+}
+
+TEST_F(PredictionSchemeNormalOctahedronCanonicalizedTransformTest,
+       RotateRepresentation) {
+  const Transform transform(15);
+  // p top left; shift clockwise by 3
+  TestRotateRepresentation(transform, Point2(1, 2), Point2(-3, 1),
+                           Point2(-2, 1), Point2(-1, -3));  // q top right
+  TestRotateRepresentation(transform, Point2(-1, -2), Point2(-3, 1),
+                           Point2(2, -1), Point2(-1, -3));  // q bottom left
+  TestRotateRepresentation(transform, Point2(1, -2), Point2(-3, 1),
+                           Point2(2, 1), Point2(-1, -3));  // q bottom right
+  TestRotateRepresentation(transform, Point2(-1, 2), Point2(-3, 1),
+                           Point2(-2, -1), Point2(-1, -3));  // q top left
+  // p top right; shift clockwise by 2 (flip)
+  TestRotateRepresentation(transform, Point2(1, 1), Point2(1, 3),
+                           Point2(-1, -1), Point2(-1, -3));  // q top right
+  TestRotateRepresentation(transform, Point2(-1, -2), Point2(1, 3),
+                           Point2(1, 2), Point2(-1, -3));  // q bottom left
+  TestRotateRepresentation(transform, Point2(-1, 2), Point2(1, 3),
+                           Point2(1, -2), Point2(-1, -3));  // q top left
+  TestRotateRepresentation(transform, Point2(1, -2), Point2(1, 3),
+                           Point2(-1, 2), Point2(-1, -3));  // q bottom right
+  // p bottom right; shift clockwise by 1
+  TestRotateRepresentation(transform, Point2(1, 2), Point2(3, -1),
+                           Point2(2, -1), Point2(-1, -3));  // q top right
+  TestRotateRepresentation(transform, Point2(1, -2), Point2(3, -1),
+                           Point2(-2, -1), Point2(-1, -3));  // q bottom right
+  TestRotateRepresentation(transform, Point2(-1, -2), Point2(3, -1),
+                           Point2(-2, 1), Point2(-1, -3));  // q bottom left
+  TestRotateRepresentation(transform, Point2(-1, 2), Point2(3, -1),
+                           Point2(2, 1), Point2(-1, -3));  // q top left
+  // p bottom left; no change
+  TestRotateRepresentation(transform, Point2(1, 2), Point2(-1, -3),
+                           Point2(1, 2), Point2(-1, -3));  // q top right
+  TestRotateRepresentation(transform, Point2(-1, 2), Point2(-1, -3),
+                           Point2(-1, 2), Point2(-1, -3));  // q top left
+  TestRotateRepresentation(transform, Point2(1, -2), Point2(-1, -3),
+                           Point2(1, -2), Point2(-1, -3));  // q bottom right
+  TestRotateRepresentation(transform, Point2(-1, -2), Point2(-1, -3),
+                           Point2(-1, -2), Point2(-1, -3));  // q bottom left
+}
+
+TEST_F(PredictionSchemeNormalOctahedronCanonicalizedTransformTest,
+       ComputeCorrection) {
+  const Transform transform(15);
+  TestComputeCorrection(transform, 0, 0, 0, 0, 0, 0);
+  TestComputeCorrection(transform, 1, 1, 1, 1, 0, 0);
+  // inside diamond; p top right
+  TestComputeCorrection(transform, 3, 4, 1, 2, -2, -2);  // q top right
+  TestComputeCorrection(transform, -3, 4, 1, 2, 4, -2);  // q top left
+  TestComputeCorrection(transform, 3, -4, 1, 2, -2, 6);  // q bottom right
+  TestComputeCorrection(transform, -3, -4, 1, 2, 4, 6);  // q bottom left
+  // inside diamond; p top left
+  TestComputeCorrection(transform, 3, 4, -1, 2, -2, 4);    // q top right
+  TestComputeCorrection(transform, -3, 4, -1, 2, -2, -2);  // q top left
+  TestComputeCorrection(transform, 3, -4, -1, 2, 6, 4);    // q bottom right
+  TestComputeCorrection(transform, -3, -4, -1, 2, 6, -2);  // q bottom left
+  // inside diamond; p bottom right
+  TestComputeCorrection(transform, 3, 4, 1, -2, 6, -2);    // q top right
+  TestComputeCorrection(transform, -3, 4, 1, -2, 6, 4);    // q top left
+  TestComputeCorrection(transform, 3, -4, 1, -2, -2, -2);  // q bottom right
+  TestComputeCorrection(transform, -3, -4, 1, -2, -2, 4);  // q bottom left
+  // inside diamond; p bottom left
+  TestComputeCorrection(transform, 3, 4, -1, -2, 4, 6);      // q top right
+  TestComputeCorrection(transform, -3, 4, -1, -2, -2, 6);    // q top left
+  TestComputeCorrection(transform, 3, -4, -1, -2, 4, -2);    // q bottom right
+  TestComputeCorrection(transform, -3, -4, -1, -2, -2, -2);  // q bottom left
+  // outside diamond; p top right
+  TestComputeCorrection(transform, 1, 2, 5, 4, -2, -4);    // q top right
+  TestComputeCorrection(transform, -1, 2, 5, 4, -7, -4);   // q top left
+  TestComputeCorrection(transform, 1, -2, 5, 4, -2, -7);   // q bottom right
+  TestComputeCorrection(transform, -1, -2, 5, 4, -7, -7);  // q bottom left
+  // outside diamond; p top left
+  TestComputeCorrection(transform, 1, 2, -5, 4, -4, -7);    // q top right
+  TestComputeCorrection(transform, -1, 2, -5, 4, -4, -2);   // q top left
+  TestComputeCorrection(transform, 1, -2, -5, 4, -7, -7);   // q bottom right
+  TestComputeCorrection(transform, -1, -2, -5, 4, -7, -2);  // q bottom left
+  // outside diamond; p bottom right
+  TestComputeCorrection(transform, 1, 2, 5, -4, -7, -2);    // q top right
+  TestComputeCorrection(transform, -1, 2, 5, -4, -7, -7);   // q top left
+  TestComputeCorrection(transform, 1, -2, 5, -4, -4, -2);   // q bottom right
+  TestComputeCorrection(transform, -1, -2, 5, -4, -4, -7);  // q bottom left
+  // outside diamond; p bottom left
+  TestComputeCorrection(transform, 1, 2, -5, -4, -7, -7);    // q top right
+  TestComputeCorrection(transform, -1, 2, -5, -4, -2, -7);   // q top left
+  TestComputeCorrection(transform, 1, -2, -5, -4, -7, -4);   // q bottom right
+  TestComputeCorrection(transform, -1, -2, -5, -4, -2, -4);  // q bottom left
+
+  TestComputeCorrection(transform, -1, -2, 7, 7, -5, -6);
+  TestComputeCorrection(transform, 0, 0, 7, 7, 7, 7);
+  TestComputeCorrection(transform, -1, -2, 0, -2, 0, 1);
+}
+
+TEST_F(PredictionSchemeNormalOctahedronCanonicalizedTransformTest, Interface) {
+  const Transform transform(15);
+  ASSERT_EQ(transform.max_quantized_value(), 15);
+  ASSERT_EQ(transform.center_value(), 7);
+  ASSERT_EQ(transform.quantization_bits(), 4);
+}
+
+}  // namespace
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_decoding_transform.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_decoding_transform.h
new file mode 100644
index 000000000..a1bc4a327
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_decoding_transform.h
@@ -0,0 +1,103 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_DECODING_TRANSFORM_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_DECODING_TRANSFORM_H_
+
+#include <cmath>
+
+#include "draco/compression/attributes/normal_compression_utils.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_base.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/macros.h"
+#include "draco/core/vector_d.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Class for converting correction values transformed by the octahedral normal
+// transform back to the original values. See the corresponding encoder for more
+// details.
+template <typename DataTypeT>
+class PredictionSchemeNormalOctahedronDecodingTransform
+    : public PredictionSchemeNormalOctahedronTransformBase<DataTypeT> {
+ public:
+  typedef VectorD<DataTypeT, 2> Point2;
+  typedef DataTypeT CorrType;
+  typedef DataTypeT DataType;
+
+  PredictionSchemeNormalOctahedronDecodingTransform() {}
+
+  // Dummy function to fulfill concept.
+  void Init(int num_components) {}
+  bool DecodeTransformData(DecoderBuffer *buffer) {
+    DataTypeT max_quantized_value, center_value;
+    if (!buffer->Decode(&max_quantized_value)) {
+      return false;
+    }
+    if (buffer->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+      if (!buffer->Decode(&center_value)) {
+        return false;
+      }
+    }
+    (void)center_value;
+    return this->set_max_quantized_value(max_quantized_value);
+  }
+
+  inline void ComputeOriginalValue(const DataType *pred_vals,
+                                   const CorrType *corr_vals,
+                                   DataType *out_orig_vals) const {
+    DRACO_DCHECK_LE(pred_vals[0], 2 * this->center_value());
+    DRACO_DCHECK_LE(pred_vals[1], 2 * this->center_value());
+    DRACO_DCHECK_LE(corr_vals[0], 2 * this->center_value());
+    DRACO_DCHECK_LE(corr_vals[1], 2 * this->center_value());
+
+    DRACO_DCHECK_LE(0, pred_vals[0]);
+    DRACO_DCHECK_LE(0, pred_vals[1]);
+    DRACO_DCHECK_LE(0, corr_vals[0]);
+    DRACO_DCHECK_LE(0, corr_vals[1]);
+
+    const Point2 pred = Point2(pred_vals[0], pred_vals[1]);
+    const Point2 corr = Point2(corr_vals[0], corr_vals[1]);
+    const Point2 orig = ComputeOriginalValue(pred, corr);
+
+    out_orig_vals[0] = orig[0];
+    out_orig_vals[1] = orig[1];
+  }
+
+ private:
+  Point2 ComputeOriginalValue(Point2 pred, const Point2 &corr) const {
+    const Point2 t(this->center_value(), this->center_value());
+    pred = pred - t;
+
+    const bool pred_is_in_diamond = this->IsInDiamond(pred[0], pred[1]);
+    if (!pred_is_in_diamond) {
+      this->InvertDiamond(&pred[0], &pred[1]);
+    }
+    Point2 orig = pred + corr;
+    orig[0] = this->ModMax(orig[0]);
+    orig[1] = this->ModMax(orig[1]);
+    if (!pred_is_in_diamond) {
+      this->InvertDiamond(&orig[0], &orig[1]);
+    }
+    orig = orig + t;
+    return orig;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_DECODING_TRANSFORM_H_
+#endif
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_encoding_transform.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_encoding_transform.h
new file mode 100644
index 000000000..4abfef669
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_encoding_transform.h
@@ -0,0 +1,105 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_ENCODING_TRANSFORM_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_ENCODING_TRANSFORM_H_
+
+#include <cmath>
+
+#include "draco/compression/attributes/normal_compression_utils.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_base.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/macros.h"
+#include "draco/core/vector_d.h"
+
+namespace draco {
+
+// The transform works on octahedral coordinates for normals. The square is
+// subdivided into four inner triangles (diamond) and four outer triangles. The
+// inner triangles are associated with the upper part of the octahedron and the
+// outer triangles are associated with the lower part.
+// Given a prediction value P and the actual value Q that should be encoded,
+// this transform first checks if P is outside the diamond. If so, the outer
+// triangles are flipped towards the inside and vice versa. The actual
+// correction value is then based on the mapped P and Q values. This tends to
+// result in shorter correction vectors.
+// This is possible since the P value is also known by the decoder, see also
+// ComputeCorrection and ComputeOriginalValue functions.
+// Note that the tile is not periodic, which implies that the outer edges can
+// not be identified, which requires us to use an odd number of values on each
+// axis.
+// DataTypeT is expected to be some integral type.
+//
+template <typename DataTypeT>
+class PredictionSchemeNormalOctahedronEncodingTransform
+    : public PredictionSchemeNormalOctahedronTransformBase<DataTypeT> {
+ public:
+  typedef PredictionSchemeNormalOctahedronTransformBase<DataTypeT> Base;
+  typedef VectorD<DataTypeT, 2> Point2;
+  typedef DataTypeT CorrType;
+  typedef DataTypeT DataType;
+
+  // We expect the mod value to be of the form 2^b-1.
+  explicit PredictionSchemeNormalOctahedronEncodingTransform(
+      DataType max_quantized_value)
+      : Base(max_quantized_value) {}
+
+  void Init(const DataTypeT *orig_data, int size, int num_components) {}
+
+  bool EncodeTransformData(EncoderBuffer *buffer) {
+    buffer->Encode(this->max_quantized_value());
+    return true;
+  }
+
+  inline void ComputeCorrection(const DataType *orig_vals,
+                                const DataType *pred_vals,
+                                CorrType *out_corr_vals) const {
+    DRACO_DCHECK_LE(pred_vals[0], this->center_value() * 2);
+    DRACO_DCHECK_LE(pred_vals[1], this->center_value() * 2);
+    DRACO_DCHECK_LE(orig_vals[0], this->center_value() * 2);
+    DRACO_DCHECK_LE(orig_vals[1], this->center_value() * 2);
+    DRACO_DCHECK_LE(0, pred_vals[0]);
+    DRACO_DCHECK_LE(0, pred_vals[1]);
+    DRACO_DCHECK_LE(0, orig_vals[0]);
+    DRACO_DCHECK_LE(0, orig_vals[1]);
+
+    const Point2 orig = Point2(orig_vals[0], orig_vals[1]);
+    const Point2 pred = Point2(pred_vals[0], pred_vals[1]);
+    const Point2 corr = ComputeCorrection(orig, pred);
+
+    out_corr_vals[0] = corr[0];
+    out_corr_vals[1] = corr[1];
+  }
+
+ private:
+  Point2 ComputeCorrection(Point2 orig, Point2 pred) const {
+    const Point2 t(this->center_value(), this->center_value());
+    orig = orig - t;
+    pred = pred - t;
+
+    if (!this->IsInDiamond(pred[0], pred[1])) {
+      this->InvertDiamond(&orig[0], &orig[1]);
+      this->InvertDiamond(&pred[0], &pred[1]);
+    }
+
+    Point2 corr = orig - pred;
+    corr[0] = this->MakePositive(corr[0]);
+    corr[1] = this->MakePositive(corr[1]);
+    return corr;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_ENCODING_TRANSFORM_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_base.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_base.h
new file mode 100644
index 000000000..c9dd7d67b
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_base.h
@@ -0,0 +1,90 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_TRANSFORM_BASE_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_TRANSFORM_BASE_H_
+
+#include <cmath>
+
+#include "draco/compression/attributes/normal_compression_utils.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/bit_utils.h"
+#include "draco/core/macros.h"
+#include "draco/core/vector_d.h"
+
+namespace draco {
+
+// Base class containing shared functionality used by both encoding and decoding
+// octahedral normal prediction scheme transforms. See the encoding transform
+// for more details about the method.
+template <typename DataTypeT>
+class PredictionSchemeNormalOctahedronTransformBase {
+ public:
+  typedef VectorD<DataTypeT, 2> Point2;
+  typedef DataTypeT DataType;
+
+  PredictionSchemeNormalOctahedronTransformBase() {}
+  // We expect the mod value to be of the form 2^b-1.
+  explicit PredictionSchemeNormalOctahedronTransformBase(
+      DataType max_quantized_value) {
+    this->set_max_quantized_value(max_quantized_value);
+  }
+
+  static constexpr PredictionSchemeTransformType GetType() {
+    return PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON;
+  }
+
+  // We can return true as we keep correction values positive.
+  bool AreCorrectionsPositive() const { return true; }
+
+  inline DataTypeT max_quantized_value() const {
+    return octahedron_tool_box_.max_quantized_value();
+  }
+  inline DataTypeT center_value() const {
+    return octahedron_tool_box_.center_value();
+  }
+  inline int32_t quantization_bits() const {
+    return octahedron_tool_box_.quantization_bits();
+  }
+
+ protected:
+  inline bool set_max_quantized_value(DataTypeT max_quantized_value) {
+    if (max_quantized_value % 2 == 0) {
+      return false;
+    }
+    int q = MostSignificantBit(max_quantized_value) + 1;
+    return octahedron_tool_box_.SetQuantizationBits(q);
+  }
+
+  bool IsInDiamond(DataTypeT s, DataTypeT t) const {
+    return octahedron_tool_box_.IsInDiamond(s, t);
+  }
+  void InvertDiamond(DataTypeT *s, DataTypeT *t) const {
+    return octahedron_tool_box_.InvertDiamond(s, t);
+  }
+
+  int32_t ModMax(int32_t x) const { return octahedron_tool_box_.ModMax(x); }
+
+  // For correction values.
+  int32_t MakePositive(int32_t x) const {
+    return octahedron_tool_box_.MakePositive(x);
+  }
+
+ private:
+  OctahedronToolBox octahedron_tool_box_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_TRANSFORM_BASE_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_test.cc
new file mode 100644
index 000000000..1001b19fa
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_test.cc
@@ -0,0 +1,71 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_encoding_transform.h"
+#include "draco/core/draco_test_base.h"
+
+namespace {
+
+class PredictionSchemeNormalOctahedronTransformTest : public ::testing::Test {
+ protected:
+  typedef draco::PredictionSchemeNormalOctahedronEncodingTransform<int32_t>
+      Transform;
+  typedef Transform::Point2 Point2;
+
+  void TestComputeCorrection(const Transform &transform, const int32_t &ox,
+                             const int32_t &oy, const int32_t &px,
+                             const int32_t &py, const int32_t &cx,
+                             const int32_t &cy) {
+    const int32_t o[2] = {ox + 7, oy + 7};
+    const int32_t p[2] = {px + 7, py + 7};
+    int32_t corr[2] = {500, 500};
+    transform.ComputeCorrection(o, p, corr);
+    ASSERT_EQ(corr[0], (cx + 15) % 15);
+    ASSERT_EQ(corr[1], (cy + 15) % 15);
+  }
+};
+
+TEST_F(PredictionSchemeNormalOctahedronTransformTest, Init) {
+  const Transform transform(15);
+  ASSERT_TRUE(transform.AreCorrectionsPositive());
+}
+
+TEST_F(PredictionSchemeNormalOctahedronTransformTest, ComputeCorrections) {
+  const Transform transform(15);
+  // checks inside diamond
+  TestComputeCorrection(transform, 0, 0, 0, 0, 0, 0);
+  TestComputeCorrection(transform, 1, 1, 1, 1, 0, 0);
+  TestComputeCorrection(transform, 3, 4, 1, 1, 2, 3);
+  TestComputeCorrection(transform, -1, -1, -1, -1, 0, 0);
+  TestComputeCorrection(transform, -3, -4, -1, -1, -2, -3);
+  // checks outside diamond
+  TestComputeCorrection(transform, 4, 4, 4, 4, 0, 0);
+  TestComputeCorrection(transform, 5, 6, 4, 4, -2, -1);
+  TestComputeCorrection(transform, 3, 2, 4, 4, 2, 1);
+  // checks on outer edges
+  TestComputeCorrection(transform, 7, 7, 4, 4, -3, -3);
+  TestComputeCorrection(transform, 6, 7, 4, 4, -3, -2);
+  TestComputeCorrection(transform, -6, 7, 4, 4, -3, -2);
+  TestComputeCorrection(transform, 7, 6, 4, 4, -2, -3);
+  TestComputeCorrection(transform, 7, -6, 4, 4, -2, -3);
+}
+
+TEST_F(PredictionSchemeNormalOctahedronTransformTest, Interface) {
+  const Transform transform(15);
+  ASSERT_EQ(transform.max_quantized_value(), 15);
+  ASSERT_EQ(transform.center_value(), 7);
+  ASSERT_EQ(transform.quantization_bits(), 4);
+}
+
+}  // namespace
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_decoding_transform.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_decoding_transform.h
new file mode 100644
index 000000000..e100c738a
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_decoding_transform.h
@@ -0,0 +1,88 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_WRAP_DECODING_TRANSFORM_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_WRAP_DECODING_TRANSFORM_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_transform_base.h"
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+
+// PredictionSchemeWrapDecodingTransform unwraps values encoded with the
+// PredictionSchemeWrapEncodingTransform.
+// See prediction_scheme_wrap_transform_base.h for more details about the
+// method.
+template <typename DataTypeT, typename CorrTypeT = DataTypeT>
+class PredictionSchemeWrapDecodingTransform
+    : public PredictionSchemeWrapTransformBase<DataTypeT> {
+ public:
+  typedef CorrTypeT CorrType;
+  PredictionSchemeWrapDecodingTransform() {}
+
+  // Computes the original value from the input predicted value and the decoded
+  // corrections. Values out of the bounds of the input values are unwrapped.
+  inline void ComputeOriginalValue(const DataTypeT *predicted_vals,
+                                   const CorrTypeT *corr_vals,
+                                   DataTypeT *out_original_vals) const {
+    // For now we assume both |DataTypeT| and |CorrTypeT| are equal.
+    static_assert(std::is_same<DataTypeT, CorrTypeT>::value,
+                  "Predictions and corrections must have the same type.");
+
+    // The only valid implementation right now is for int32_t.
+    static_assert(std::is_same<DataTypeT, int32_t>::value,
+                  "Only int32_t is supported for predicted values.");
+
+    predicted_vals = this->ClampPredictedValue(predicted_vals);
+
+    // Perform the wrapping using unsigned coordinates to avoid potential signed
+    // integer overflows caused by malformed input.
+    const uint32_t *const uint_predicted_vals =
+        reinterpret_cast<const uint32_t *>(predicted_vals);
+    const uint32_t *const uint_corr_vals =
+        reinterpret_cast<const uint32_t *>(corr_vals);
+    for (int i = 0; i < this->num_components(); ++i) {
+      out_original_vals[i] =
+          static_cast<DataTypeT>(uint_predicted_vals[i] + uint_corr_vals[i]);
+      if (out_original_vals[i] > this->max_value()) {
+        out_original_vals[i] -= this->max_dif();
+      } else if (out_original_vals[i] < this->min_value()) {
+        out_original_vals[i] += this->max_dif();
+      }
+    }
+  }
+
+  bool DecodeTransformData(DecoderBuffer *buffer) {
+    DataTypeT min_value, max_value;
+    if (!buffer->Decode(&min_value)) {
+      return false;
+    }
+    if (!buffer->Decode(&max_value)) {
+      return false;
+    }
+    if (min_value > max_value) {
+      return false;
+    }
+    this->set_min_value(min_value);
+    this->set_max_value(max_value);
+    if (!this->InitCorrectionBounds()) {
+      return false;
+    }
+    return true;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_WRAP_DECODING_TRANSFORM_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_encoding_transform.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_encoding_transform.h
new file mode 100644
index 000000000..1f5e8b135
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_encoding_transform.h
@@ -0,0 +1,81 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_WRAP_ENCODING_TRANSFORM_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_WRAP_ENCODING_TRANSFORM_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_transform_base.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// PredictionSchemeWrapEncodingTransform wraps input values using the wrapping
+// scheme described in: prediction_scheme_wrap_transform_base.h .
+template <typename DataTypeT, typename CorrTypeT = DataTypeT>
+class PredictionSchemeWrapEncodingTransform
+    : public PredictionSchemeWrapTransformBase<DataTypeT> {
+ public:
+  typedef CorrTypeT CorrType;
+  PredictionSchemeWrapEncodingTransform() {}
+
+  void Init(const DataTypeT *orig_data, int size, int num_components) {
+    PredictionSchemeWrapTransformBase<DataTypeT>::Init(num_components);
+    // Go over the original values and compute the bounds.
+    if (size == 0) {
+      return;
+    }
+    DataTypeT min_value = orig_data[0];
+    DataTypeT max_value = min_value;
+    for (int i = 1; i < size; ++i) {
+      if (orig_data[i] < min_value) {
+        min_value = orig_data[i];
+      } else if (orig_data[i] > max_value) {
+        max_value = orig_data[i];
+      }
+    }
+    this->set_min_value(min_value);
+    this->set_max_value(max_value);
+    this->InitCorrectionBounds();
+  }
+
+  // Computes the corrections based on the input original value and the
+  // predicted value. Out of bound correction values are wrapped around the max
+  // range of input values.
+  inline void ComputeCorrection(const DataTypeT *original_vals,
+                                const DataTypeT *predicted_vals,
+                                CorrTypeT *out_corr_vals) const {
+    for (int i = 0; i < this->num_components(); ++i) {
+      predicted_vals = this->ClampPredictedValue(predicted_vals);
+      out_corr_vals[i] = original_vals[i] - predicted_vals[i];
+      // Wrap around if needed.
+      DataTypeT &corr_val = out_corr_vals[i];
+      if (corr_val < this->min_correction()) {
+        corr_val += this->max_dif();
+      } else if (corr_val > this->max_correction()) {
+        corr_val -= this->max_dif();
+      }
+    }
+  }
+
+  bool EncodeTransformData(EncoderBuffer *buffer) {
+    // Store the input value range as it is needed by the decoder.
+    buffer->Encode(this->min_value());
+    buffer->Encode(this->max_value());
+    return true;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_WRAP_ENCODING_TRANSFORM_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_transform_base.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_transform_base.h
new file mode 100644
index 000000000..26f61fbaf
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_transform_base.h
@@ -0,0 +1,120 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_WRAP_TRANSFORM_BASE_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_WRAP_TRANSFORM_BASE_H_
+
+#include <limits>
+#include <vector>
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/macros.h"
+
+namespace draco {
+
+// PredictionSchemeWrapTransform uses the min and max bounds of the original
+// data to wrap stored correction values around these bounds centered at 0,
+// i.e., when the range of the original values O is between <MIN, MAX> and
+// N = MAX-MIN, we can then store any correction X = O - P, as:
+//        X + N,   if X < -N / 2
+//        X - N,   if X > N / 2
+//        X        otherwise
+// To unwrap this value, the decoder then simply checks whether the final
+// corrected value F = P + X is out of the bounds of the input values.
+// All out of bounds values are unwrapped using
+//        F + N,   if F < MIN
+//        F - N,   if F > MAX
+// This wrapping can reduce the number of unique values, which translates to a
+// better entropy of the stored values and better compression rates.
+template <typename DataTypeT>
+class PredictionSchemeWrapTransformBase {
+ public:
+  PredictionSchemeWrapTransformBase()
+      : num_components_(0),
+        min_value_(0),
+        max_value_(0),
+        max_dif_(0),
+        max_correction_(0),
+        min_correction_(0) {}
+
+  static constexpr PredictionSchemeTransformType GetType() {
+    return PREDICTION_TRANSFORM_WRAP;
+  }
+
+  void Init(int num_components) {
+    num_components_ = num_components;
+    clamped_value_.resize(num_components);
+  }
+
+  bool AreCorrectionsPositive() const { return false; }
+
+  inline const DataTypeT *ClampPredictedValue(
+      const DataTypeT *predicted_val) const {
+    for (int i = 0; i < this->num_components(); ++i) {
+      if (predicted_val[i] > max_value_) {
+        clamped_value_[i] = max_value_;
+      } else if (predicted_val[i] < min_value_) {
+        clamped_value_[i] = min_value_;
+      } else {
+        clamped_value_[i] = predicted_val[i];
+      }
+    }
+    return &clamped_value_[0];
+  }
+
+  // TODO(hemmer): Consider refactoring to avoid this dummy.
+  int quantization_bits() const {
+    DRACO_DCHECK(false);
+    return -1;
+  }
+
+ protected:
+  bool InitCorrectionBounds() {
+    const int64_t dif =
+        static_cast<int64_t>(max_value_) - static_cast<int64_t>(min_value_);
+    if (dif < 0 || dif >= std::numeric_limits<DataTypeT>::max()) {
+      return false;
+    }
+    max_dif_ = 1 + static_cast<DataTypeT>(dif);
+    max_correction_ = max_dif_ / 2;
+    min_correction_ = -max_correction_;
+    if ((max_dif_ & 1) == 0) {
+      max_correction_ -= 1;
+    }
+    return true;
+  }
+
+  inline int num_components() const { return num_components_; }
+  inline DataTypeT min_value() const { return min_value_; }
+  inline void set_min_value(const DataTypeT &v) { min_value_ = v; }
+  inline DataTypeT max_value() const { return max_value_; }
+  inline void set_max_value(const DataTypeT &v) { max_value_ = v; }
+  inline DataTypeT max_dif() const { return max_dif_; }
+  inline DataTypeT min_correction() const { return min_correction_; }
+  inline DataTypeT max_correction() const { return max_correction_; }
+
+ private:
+  int num_components_;
+  DataTypeT min_value_;
+  DataTypeT max_value_;
+  DataTypeT max_dif_;
+  DataTypeT max_correction_;
+  DataTypeT min_correction_;
+  // This is in fact just a tmp variable to avoid reallocation.
+  mutable std::vector<DataTypeT> clamped_value_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_WRAP_TRANSFORM_BASE_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_decoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_decoder.cc
new file mode 100644
index 000000000..b4ba24f2d
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_decoder.cc
@@ -0,0 +1,118 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/sequential_attribute_decoder.h"
+
+namespace draco {
+
+SequentialAttributeDecoder::SequentialAttributeDecoder()
+    : decoder_(nullptr), attribute_(nullptr), attribute_id_(-1) {}
+
+bool SequentialAttributeDecoder::Init(PointCloudDecoder *decoder,
+                                      int attribute_id) {
+  decoder_ = decoder;
+  attribute_ = decoder->point_cloud()->attribute(attribute_id);
+  attribute_id_ = attribute_id;
+  return true;
+}
+
+bool SequentialAttributeDecoder::InitializeStandalone(
+    PointAttribute *attribute) {
+  attribute_ = attribute;
+  attribute_id_ = -1;
+  return true;
+}
+
+bool SequentialAttributeDecoder::DecodePortableAttribute(
+    const std::vector<PointIndex> &point_ids, DecoderBuffer *in_buffer) {
+  if (attribute_->num_components() <= 0 ||
+      !attribute_->Reset(point_ids.size())) {
+    return false;
+  }
+  if (!DecodeValues(point_ids, in_buffer)) {
+    return false;
+  }
+  return true;
+}
+
+bool SequentialAttributeDecoder::DecodeDataNeededByPortableTransform(
+    const std::vector<PointIndex> &point_ids, DecoderBuffer *in_buffer) {
+  // Default implementation does not apply any transform.
+  return true;
+}
+
+bool SequentialAttributeDecoder::TransformAttributeToOriginalFormat(
+    const std::vector<PointIndex> &point_ids) {
+  // Default implementation does not apply any transform.
+  return true;
+}
+
+const PointAttribute *SequentialAttributeDecoder::GetPortableAttribute() {
+  // If needed, copy point to attribute value index mapping from the final
+  // attribute to the portable attribute.
+  if (!attribute_->is_mapping_identity() && portable_attribute_ &&
+      portable_attribute_->is_mapping_identity()) {
+    portable_attribute_->SetExplicitMapping(attribute_->indices_map_size());
+    for (PointIndex i(0);
+         i < static_cast<uint32_t>(attribute_->indices_map_size()); ++i) {
+      portable_attribute_->SetPointMapEntry(i, attribute_->mapped_index(i));
+    }
+  }
+  return portable_attribute_.get();
+}
+
+bool SequentialAttributeDecoder::InitPredictionScheme(
+    PredictionSchemeInterface *ps) {
+  for (int i = 0; i < ps->GetNumParentAttributes(); ++i) {
+    const int att_id = decoder_->point_cloud()->GetNamedAttributeId(
+        ps->GetParentAttributeType(i));
+    if (att_id == -1) {
+      return false;  // Requested attribute does not exist.
+    }
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+    if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+      if (!ps->SetParentAttribute(decoder_->point_cloud()->attribute(att_id))) {
+        return false;
+      }
+    } else
+#endif
+    {
+      const PointAttribute *const pa = decoder_->GetPortableAttribute(att_id);
+      if (pa == nullptr || !ps->SetParentAttribute(pa)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+bool SequentialAttributeDecoder::DecodeValues(
+    const std::vector<PointIndex> &point_ids, DecoderBuffer *in_buffer) {
+  const int32_t num_values = static_cast<uint32_t>(point_ids.size());
+  const int entry_size = static_cast<int>(attribute_->byte_stride());
+  std::unique_ptr<uint8_t[]> value_data_ptr(new uint8_t[entry_size]);
+  uint8_t *const value_data = value_data_ptr.get();
+  int out_byte_pos = 0;
+  // Decode raw attribute values in their original format.
+  for (int i = 0; i < num_values; ++i) {
+    if (!in_buffer->Decode(value_data, entry_size)) {
+      return false;
+    }
+    attribute_->buffer()->Write(out_byte_pos, value_data, entry_size);
+    out_byte_pos += entry_size;
+  }
+  return true;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_decoder.h
new file mode 100644
index 000000000..d48119465
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_decoder.h
@@ -0,0 +1,86 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_DECODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_interface.h"
+#include "draco/compression/point_cloud/point_cloud_decoder.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// A base class for decoding attribute values encoded by the
+// SequentialAttributeEncoder.
+class SequentialAttributeDecoder {
+ public:
+  SequentialAttributeDecoder();
+  virtual ~SequentialAttributeDecoder() = default;
+
+  virtual bool Init(PointCloudDecoder *decoder, int attribute_id);
+
+  // Initialization for a specific attribute. This can be used mostly for
+  // standalone decoding of an attribute without an PointCloudDecoder.
+  virtual bool InitializeStandalone(PointAttribute *attribute);
+
+  // Performs lossless decoding of the portable attribute data.
+  virtual bool DecodePortableAttribute(const std::vector<PointIndex> &point_ids,
+                                       DecoderBuffer *in_buffer);
+
+  // Decodes any data needed to revert portable transform of the decoded
+  // attribute.
+  virtual bool DecodeDataNeededByPortableTransform(
+      const std::vector<PointIndex> &point_ids, DecoderBuffer *in_buffer);
+
+  // Reverts transformation performed by encoder in
+  // SequentialAttributeEncoder::TransformAttributeToPortableFormat() method.
+  virtual bool TransformAttributeToOriginalFormat(
+      const std::vector<PointIndex> &point_ids);
+
+  const PointAttribute *GetPortableAttribute();
+
+  const PointAttribute *attribute() const { return attribute_; }
+  PointAttribute *attribute() { return attribute_; }
+  int attribute_id() const { return attribute_id_; }
+  PointCloudDecoder *decoder() const { return decoder_; }
+
+ protected:
+  // Should be used to initialize newly created prediction scheme.
+  // Returns false when the initialization failed (in which case the scheme
+  // cannot be used).
+  virtual bool InitPredictionScheme(PredictionSchemeInterface *ps);
+
+  // The actual implementation of the attribute decoding. Should be overridden
+  // for specialized decoders.
+  virtual bool DecodeValues(const std::vector<PointIndex> &point_ids,
+                            DecoderBuffer *in_buffer);
+
+  void SetPortableAttribute(std::unique_ptr<PointAttribute> att) {
+    portable_attribute_ = std::move(att);
+  }
+
+  PointAttribute *portable_attribute() { return portable_attribute_.get(); }
+
+ private:
+  PointCloudDecoder *decoder_;
+  PointAttribute *attribute_;
+  int attribute_id_;
+
+  // Storage for decoded portable attribute (after lossless decoding).
+  std::unique_ptr<PointAttribute> portable_attribute_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_decoders_controller.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_decoders_controller.cc
new file mode 100644
index 000000000..0e5e26bca
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_decoders_controller.cc
@@ -0,0 +1,149 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/sequential_attribute_decoders_controller.h"
+#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
+#include "draco/compression/attributes/sequential_normal_attribute_decoder.h"
+#endif
+#include "draco/compression/attributes/sequential_quantization_attribute_decoder.h"
+#include "draco/compression/config/compression_shared.h"
+
+namespace draco {
+
+SequentialAttributeDecodersController::SequentialAttributeDecodersController(
+    std::unique_ptr<PointsSequencer> sequencer)
+    : sequencer_(std::move(sequencer)) {}
+
+bool SequentialAttributeDecodersController::DecodeAttributesDecoderData(
+    DecoderBuffer *buffer) {
+  if (!AttributesDecoder::DecodeAttributesDecoderData(buffer)) {
+    return false;
+  }
+  // Decode unique ids of all sequential encoders and create them.
+  const int32_t num_attributes = GetNumAttributes();
+  sequential_decoders_.resize(num_attributes);
+  for (int i = 0; i < num_attributes; ++i) {
+    uint8_t decoder_type;
+    if (!buffer->Decode(&decoder_type)) {
+      return false;
+    }
+    // Create the decoder from the id.
+    sequential_decoders_[i] = CreateSequentialDecoder(decoder_type);
+    if (!sequential_decoders_[i]) {
+      return false;
+    }
+    if (!sequential_decoders_[i]->Init(GetDecoder(), GetAttributeId(i))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool SequentialAttributeDecodersController::DecodeAttributes(
+    DecoderBuffer *buffer) {
+  if (!sequencer_ || !sequencer_->GenerateSequence(&point_ids_)) {
+    return false;
+  }
+  // Initialize point to attribute value mapping for all decoded attributes.
+  const int32_t num_attributes = GetNumAttributes();
+  for (int i = 0; i < num_attributes; ++i) {
+    PointAttribute *const pa =
+        GetDecoder()->point_cloud()->attribute(GetAttributeId(i));
+    if (!sequencer_->UpdatePointToAttributeIndexMapping(pa)) {
+      return false;
+    }
+  }
+  return AttributesDecoder::DecodeAttributes(buffer);
+}
+
+bool SequentialAttributeDecodersController::DecodePortableAttributes(
+    DecoderBuffer *in_buffer) {
+  const int32_t num_attributes = GetNumAttributes();
+  for (int i = 0; i < num_attributes; ++i) {
+    if (!sequential_decoders_[i]->DecodePortableAttribute(point_ids_,
+                                                          in_buffer)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool SequentialAttributeDecodersController::
+    DecodeDataNeededByPortableTransforms(DecoderBuffer *in_buffer) {
+  const int32_t num_attributes = GetNumAttributes();
+  for (int i = 0; i < num_attributes; ++i) {
+    if (!sequential_decoders_[i]->DecodeDataNeededByPortableTransform(
+            point_ids_, in_buffer)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool SequentialAttributeDecodersController::
+    TransformAttributesToOriginalFormat() {
+  const int32_t num_attributes = GetNumAttributes();
+  for (int i = 0; i < num_attributes; ++i) {
+    // Check whether the attribute transform should be skipped.
+    if (GetDecoder()->options()) {
+      const PointAttribute *const attribute =
+          sequential_decoders_[i]->attribute();
+      const PointAttribute *const portable_attribute =
+          sequential_decoders_[i]->GetPortableAttribute();
+      if (portable_attribute &&
+          GetDecoder()->options()->GetAttributeBool(
+              attribute->attribute_type(), "skip_attribute_transform", false)) {
+        // Attribute transform should not be performed. In this case, we replace
+        // the output geometry attribute with the portable attribute.
+        // TODO(ostava): We can potentially avoid this copy by introducing a new
+        // mechanism that would allow to use the final attributes as portable
+        // attributes for predictors that may need them.
+        sequential_decoders_[i]->attribute()->CopyFrom(*portable_attribute);
+        continue;
+      }
+    }
+    if (!sequential_decoders_[i]->TransformAttributeToOriginalFormat(
+            point_ids_)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+std::unique_ptr<SequentialAttributeDecoder>
+SequentialAttributeDecodersController::CreateSequentialDecoder(
+    uint8_t decoder_type) {
+  switch (decoder_type) {
+    case SEQUENTIAL_ATTRIBUTE_ENCODER_GENERIC:
+      return std::unique_ptr<SequentialAttributeDecoder>(
+          new SequentialAttributeDecoder());
+    case SEQUENTIAL_ATTRIBUTE_ENCODER_INTEGER:
+      return std::unique_ptr<SequentialAttributeDecoder>(
+          new SequentialIntegerAttributeDecoder());
+    case SEQUENTIAL_ATTRIBUTE_ENCODER_QUANTIZATION:
+      return std::unique_ptr<SequentialAttributeDecoder>(
+          new SequentialQuantizationAttributeDecoder());
+#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
+    case SEQUENTIAL_ATTRIBUTE_ENCODER_NORMALS:
+      return std::unique_ptr<SequentialNormalAttributeDecoder>(
+          new SequentialNormalAttributeDecoder());
+#endif
+    default:
+      break;
+  }
+  // Unknown or unsupported decoder type.
+  return nullptr;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_decoders_controller.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_decoders_controller.h
new file mode 100644
index 000000000..abc1f3685
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_decoders_controller.h
@@ -0,0 +1,61 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_DECODERS_CONTROLLER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_DECODERS_CONTROLLER_H_
+
+#include "draco/compression/attributes/attributes_decoder.h"
+#include "draco/compression/attributes/points_sequencer.h"
+#include "draco/compression/attributes/sequential_attribute_decoder.h"
+
+namespace draco {
+
+// A basic implementation of an attribute decoder that decodes data encoded by
+// the SequentialAttributeEncodersController class. The
+// SequentialAttributeDecodersController creates a single
+// AttributeIndexedValuesDecoder for each of the decoded attribute, where the
+// type of the values decoder is determined by the unique identifier that was
+// encoded by the encoder.
+class SequentialAttributeDecodersController : public AttributesDecoder {
+ public:
+  explicit SequentialAttributeDecodersController(
+      std::unique_ptr<PointsSequencer> sequencer);
+
+  bool DecodeAttributesDecoderData(DecoderBuffer *buffer) override;
+  bool DecodeAttributes(DecoderBuffer *buffer) override;
+  const PointAttribute *GetPortableAttribute(
+      int32_t point_attribute_id) override {
+    const int32_t loc_id = GetLocalIdForPointAttribute(point_attribute_id);
+    if (loc_id < 0) {
+      return nullptr;
+    }
+    return sequential_decoders_[loc_id]->GetPortableAttribute();
+  }
+
+ protected:
+  bool DecodePortableAttributes(DecoderBuffer *in_buffer) override;
+  bool DecodeDataNeededByPortableTransforms(DecoderBuffer *in_buffer) override;
+  bool TransformAttributesToOriginalFormat() override;
+  virtual std::unique_ptr<SequentialAttributeDecoder> CreateSequentialDecoder(
+      uint8_t decoder_type);
+
+ private:
+  std::vector<std::unique_ptr<SequentialAttributeDecoder>> sequential_decoders_;
+  std::vector<PointIndex> point_ids_;
+  std::unique_ptr<PointsSequencer> sequencer_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_DECODERS_CONTROLLER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_encoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_encoder.cc
new file mode 100644
index 000000000..6bde3eeb3
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_encoder.cc
@@ -0,0 +1,108 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/sequential_attribute_encoder.h"
+
+namespace draco {
+
+SequentialAttributeEncoder::SequentialAttributeEncoder()
+    : encoder_(nullptr),
+      attribute_(nullptr),
+      attribute_id_(-1),
+      is_parent_encoder_(false) {}
+
+bool SequentialAttributeEncoder::Init(PointCloudEncoder *encoder,
+                                      int attribute_id) {
+  encoder_ = encoder;
+  attribute_ = encoder_->point_cloud()->attribute(attribute_id);
+  attribute_id_ = attribute_id;
+  return true;
+}
+
+bool SequentialAttributeEncoder::InitializeStandalone(
+    PointAttribute *attribute) {
+  attribute_ = attribute;
+  attribute_id_ = -1;
+  return true;
+}
+
+bool SequentialAttributeEncoder::TransformAttributeToPortableFormat(
+    const std::vector<PointIndex> &point_ids) {
+  // Default implementation doesn't transform the input data.
+  return true;
+}
+
+bool SequentialAttributeEncoder::EncodePortableAttribute(
+    const std::vector<PointIndex> &point_ids, EncoderBuffer *out_buffer) {
+  // Lossless encoding of the input values.
+  if (!EncodeValues(point_ids, out_buffer)) {
+    return false;
+  }
+  return true;
+}
+
+bool SequentialAttributeEncoder::EncodeDataNeededByPortableTransform(
+    EncoderBuffer *out_buffer) {
+  // Default implementation doesn't transform the input data.
+  return true;
+}
+
+bool SequentialAttributeEncoder::EncodeValues(
+    const std::vector<PointIndex> &point_ids, EncoderBuffer *out_buffer) {
+  const int entry_size = static_cast<int>(attribute_->byte_stride());
+  const std::unique_ptr<uint8_t[]> value_data_ptr(new uint8_t[entry_size]);
+  uint8_t *const value_data = value_data_ptr.get();
+  // Encode all attribute values in their native raw format.
+  for (uint32_t i = 0; i < point_ids.size(); ++i) {
+    const AttributeValueIndex entry_id = attribute_->mapped_index(point_ids[i]);
+    attribute_->GetValue(entry_id, value_data);
+    out_buffer->Encode(value_data, entry_size);
+  }
+  return true;
+}
+
+void SequentialAttributeEncoder::MarkParentAttribute() {
+  is_parent_encoder_ = true;
+}
+
+bool SequentialAttributeEncoder::InitPredictionScheme(
+    PredictionSchemeInterface *ps) {
+  for (int i = 0; i < ps->GetNumParentAttributes(); ++i) {
+    const int att_id = encoder_->point_cloud()->GetNamedAttributeId(
+        ps->GetParentAttributeType(i));
+    if (att_id == -1) {
+      return false;  // Requested attribute does not exist.
+    }
+    parent_attributes_.push_back(att_id);
+    encoder_->MarkParentAttribute(att_id);
+  }
+  return true;
+}
+
+bool SequentialAttributeEncoder::SetPredictionSchemeParentAttributes(
+    PredictionSchemeInterface *ps) {
+  for (int i = 0; i < ps->GetNumParentAttributes(); ++i) {
+    const int att_id = encoder_->point_cloud()->GetNamedAttributeId(
+        ps->GetParentAttributeType(i));
+    if (att_id == -1) {
+      return false;  // Requested attribute does not exist.
+    }
+    if (!ps->SetParentAttribute(encoder_->GetPortableAttribute(att_id))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_encoder.h
new file mode 100644
index 000000000..00f62db89
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_encoder.h
@@ -0,0 +1,134 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_ENCODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_interface.h"
+#include "draco/compression/point_cloud/point_cloud_encoder.h"
+
+namespace draco {
+
+// A base class for encoding attribute values of a single attribute using a
+// given sequence of point ids. The default implementation encodes all attribute
+// values directly to the buffer but derived classes can perform any custom
+// encoding (such as quantization) by overriding the EncodeValues() method.
+class SequentialAttributeEncoder {
+ public:
+  SequentialAttributeEncoder();
+  virtual ~SequentialAttributeEncoder() = default;
+
+  // Method that can be used for custom initialization of an attribute encoder,
+  // such as creation of prediction schemes and initialization of attribute
+  // encoder dependencies.
+  // |encoder| is the parent PointCloudEncoder,
+  // |attribute_id| is the id of the attribute that is being encoded by this
+  // encoder.
+  // This method is automatically called by the PointCloudEncoder after all
+  // attribute encoders are created and it should not be called explicitly from
+  // other places.
+  virtual bool Init(PointCloudEncoder *encoder, int attribute_id);
+
+  // Initialization for a specific attribute. This can be used mostly for
+  // standalone encoding of an attribute without an PointCloudEncoder.
+  virtual bool InitializeStandalone(PointAttribute *attribute);
+
+  // Transforms attribute data into format that is going to be encoded
+  // losslessly. The transform itself can be lossy.
+  virtual bool TransformAttributeToPortableFormat(
+      const std::vector<PointIndex> &point_ids);
+
+  // Performs lossless encoding of the transformed attribute data.
+  virtual bool EncodePortableAttribute(const std::vector<PointIndex> &point_ids,
+                                       EncoderBuffer *out_buffer);
+
+  // Encodes any data related to the portable attribute transform.
+  virtual bool EncodeDataNeededByPortableTransform(EncoderBuffer *out_buffer);
+
+  virtual bool IsLossyEncoder() const { return false; }
+
+  int NumParentAttributes() const {
+    return static_cast<int>(parent_attributes_.size());
+  }
+  int GetParentAttributeId(int i) const { return parent_attributes_[i]; }
+
+  const PointAttribute *GetPortableAttribute() const {
+    if (portable_attribute_ != nullptr) {
+      return portable_attribute_.get();
+    }
+    return attribute();
+  }
+
+  // Called when this attribute encoder becomes a parent encoder of another
+  // encoder.
+  void MarkParentAttribute();
+
+  virtual uint8_t GetUniqueId() const {
+    return SEQUENTIAL_ATTRIBUTE_ENCODER_GENERIC;
+  }
+
+  const PointAttribute *attribute() const { return attribute_; }
+  int attribute_id() const { return attribute_id_; }
+  PointCloudEncoder *encoder() const { return encoder_; }
+
+ protected:
+  // Should be used to initialize newly created prediction scheme.
+  // Returns false when the initialization failed (in which case the scheme
+  // cannot be used).
+  virtual bool InitPredictionScheme(PredictionSchemeInterface *ps);
+
+  // Sets parent attributes for a given prediction scheme. Must be called
+  // after all prediction schemes are initialized, but before the prediction
+  // scheme is used.
+  virtual bool SetPredictionSchemeParentAttributes(
+      PredictionSchemeInterface *ps);
+
+  // Encodes all attribute values in the specified order. Should be overridden
+  // for specialized  encoders.
+  virtual bool EncodeValues(const std::vector<PointIndex> &point_ids,
+                            EncoderBuffer *out_buffer);
+
+  bool is_parent_encoder() const { return is_parent_encoder_; }
+
+  void SetPortableAttribute(std::unique_ptr<PointAttribute> att) {
+    portable_attribute_ = std::move(att);
+  }
+
+  // Returns a mutable attribute that should be filled by derived encoders with
+  // the transformed version of the attribute data. To get a public const
+  // version, use the GetPortableAttribute() method.
+  PointAttribute *portable_attribute() { return portable_attribute_.get(); }
+
+ private:
+  PointCloudEncoder *encoder_;
+  const PointAttribute *attribute_;
+  int attribute_id_;
+
+  // List of attribute encoders that need to be encoded before this attribute.
+  // E.g. The parent attributes may be used to predict values used by this
+  // attribute encoder.
+  std::vector<int32_t> parent_attributes_;
+
+  bool is_parent_encoder_;
+
+  // Attribute that stores transformed data from the source attribute after it
+  // is processed through the ApplyTransform() method. Attribute data stored
+  // within this attribute is guaranteed to be encoded losslessly and it can be
+  // safely used for prediction of other attributes.
+  std::unique_ptr<PointAttribute> portable_attribute_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_encoders_controller.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_encoders_controller.cc
new file mode 100644
index 000000000..7d5d1eeff
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_encoders_controller.cc
@@ -0,0 +1,159 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/sequential_attribute_encoders_controller.h"
+#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
+#include "draco/compression/attributes/sequential_normal_attribute_encoder.h"
+#endif
+#include "draco/compression/attributes/sequential_quantization_attribute_encoder.h"
+#include "draco/compression/point_cloud/point_cloud_encoder.h"
+
+namespace draco {
+
+SequentialAttributeEncodersController::SequentialAttributeEncodersController(
+    std::unique_ptr<PointsSequencer> sequencer)
+    : sequencer_(std::move(sequencer)) {}
+
+SequentialAttributeEncodersController::SequentialAttributeEncodersController(
+    std::unique_ptr<PointsSequencer> sequencer, int point_attrib_id)
+    : AttributesEncoder(point_attrib_id), sequencer_(std::move(sequencer)) {}
+
+bool SequentialAttributeEncodersController::Init(PointCloudEncoder *encoder,
+                                                 const PointCloud *pc) {
+  if (!AttributesEncoder::Init(encoder, pc)) {
+    return false;
+  }
+  if (!CreateSequentialEncoders()) {
+    return false;
+  }
+  // Initialize all value encoders.
+  for (uint32_t i = 0; i < num_attributes(); ++i) {
+    const int32_t att_id = GetAttributeId(i);
+    if (!sequential_encoders_[i]->Init(encoder, att_id)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool SequentialAttributeEncodersController::EncodeAttributesEncoderData(
+    EncoderBuffer *out_buffer) {
+  if (!AttributesEncoder::EncodeAttributesEncoderData(out_buffer)) {
+    return false;
+  }
+  // Encode a unique id of every sequential encoder.
+  for (uint32_t i = 0; i < sequential_encoders_.size(); ++i) {
+    out_buffer->Encode(sequential_encoders_[i]->GetUniqueId());
+  }
+  return true;
+}
+
+bool SequentialAttributeEncodersController::EncodeAttributes(
+    EncoderBuffer *buffer) {
+  if (!sequencer_ || !sequencer_->GenerateSequence(&point_ids_)) {
+    return false;
+  }
+  return AttributesEncoder::EncodeAttributes(buffer);
+}
+
+bool SequentialAttributeEncodersController::
+    TransformAttributesToPortableFormat() {
+  for (uint32_t i = 0; i < sequential_encoders_.size(); ++i) {
+    if (!sequential_encoders_[i]->TransformAttributeToPortableFormat(
+            point_ids_)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool SequentialAttributeEncodersController::EncodePortableAttributes(
+    EncoderBuffer *out_buffer) {
+  for (uint32_t i = 0; i < sequential_encoders_.size(); ++i) {
+    if (!sequential_encoders_[i]->EncodePortableAttribute(point_ids_,
+                                                          out_buffer)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool SequentialAttributeEncodersController::
+    EncodeDataNeededByPortableTransforms(EncoderBuffer *out_buffer) {
+  for (uint32_t i = 0; i < sequential_encoders_.size(); ++i) {
+    if (!sequential_encoders_[i]->EncodeDataNeededByPortableTransform(
+            out_buffer)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool SequentialAttributeEncodersController::CreateSequentialEncoders() {
+  sequential_encoders_.resize(num_attributes());
+  for (uint32_t i = 0; i < num_attributes(); ++i) {
+    sequential_encoders_[i] = CreateSequentialEncoder(i);
+    if (sequential_encoders_[i] == nullptr) {
+      return false;
+    }
+    if (i < sequential_encoder_marked_as_parent_.size()) {
+      if (sequential_encoder_marked_as_parent_[i]) {
+        sequential_encoders_[i]->MarkParentAttribute();
+      }
+    }
+  }
+  return true;
+}
+
+std::unique_ptr<SequentialAttributeEncoder>
+SequentialAttributeEncodersController::CreateSequentialEncoder(int i) {
+  const int32_t att_id = GetAttributeId(i);
+  const PointAttribute *const att = encoder()->point_cloud()->attribute(att_id);
+
+  switch (att->data_type()) {
+    case DT_UINT8:
+    case DT_INT8:
+    case DT_UINT16:
+    case DT_INT16:
+    case DT_UINT32:
+    case DT_INT32:
+      return std::unique_ptr<SequentialAttributeEncoder>(
+          new SequentialIntegerAttributeEncoder());
+    case DT_FLOAT32:
+      if (encoder()->options()->GetAttributeInt(att_id, "quantization_bits",
+                                                -1) > 0) {
+#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
+        if (att->attribute_type() == GeometryAttribute::NORMAL) {
+          // We currently only support normals with float coordinates
+          // and must be quantized.
+          return std::unique_ptr<SequentialAttributeEncoder>(
+              new SequentialNormalAttributeEncoder());
+        } else {
+#endif
+          return std::unique_ptr<SequentialAttributeEncoder>(
+              new SequentialQuantizationAttributeEncoder());
+#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
+        }
+#endif
+      }
+      break;
+    default:
+      break;
+  }
+  // Return the default attribute encoder.
+  return std::unique_ptr<SequentialAttributeEncoder>(
+      new SequentialAttributeEncoder());
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_encoders_controller.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_encoders_controller.h
new file mode 100644
index 000000000..13c2704ec
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_attribute_encoders_controller.h
@@ -0,0 +1,115 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_ENCODERS_CONTROLLER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_ENCODERS_CONTROLLER_H_
+
+#include "draco/compression/attributes/attributes_encoder.h"
+#include "draco/compression/attributes/points_sequencer.h"
+#include "draco/compression/attributes/sequential_attribute_encoder.h"
+
+namespace draco {
+
+// A basic implementation of an attribute encoder that can be used to encode
+// an arbitrary set of attributes. The encoder creates a sequential attribute
+// encoder for each encoded attribute (see sequential_attribute_encoder.h) and
+// then it encodes all attribute values in an order defined by a point sequence
+// generated in the GeneratePointSequence() method. The default implementation
+// generates a linear sequence of all points, but derived classes can generate
+// any custom sequence.
+class SequentialAttributeEncodersController : public AttributesEncoder {
+ public:
+  explicit SequentialAttributeEncodersController(
+      std::unique_ptr<PointsSequencer> sequencer);
+  SequentialAttributeEncodersController(
+      std::unique_ptr<PointsSequencer> sequencer, int point_attrib_id);
+
+  bool Init(PointCloudEncoder *encoder, const PointCloud *pc) override;
+  bool EncodeAttributesEncoderData(EncoderBuffer *out_buffer) override;
+  bool EncodeAttributes(EncoderBuffer *buffer) override;
+  uint8_t GetUniqueId() const override { return BASIC_ATTRIBUTE_ENCODER; }
+
+  int NumParentAttributes(int32_t point_attribute_id) const override {
+    const int32_t loc_id = GetLocalIdForPointAttribute(point_attribute_id);
+    if (loc_id < 0) {
+      return 0;
+    }
+    return sequential_encoders_[loc_id]->NumParentAttributes();
+  }
+
+  int GetParentAttributeId(int32_t point_attribute_id,
+                           int32_t parent_i) const override {
+    const int32_t loc_id = GetLocalIdForPointAttribute(point_attribute_id);
+    if (loc_id < 0) {
+      return -1;
+    }
+    return sequential_encoders_[loc_id]->GetParentAttributeId(parent_i);
+  }
+
+  bool MarkParentAttribute(int32_t point_attribute_id) override {
+    const int32_t loc_id = GetLocalIdForPointAttribute(point_attribute_id);
+    if (loc_id < 0) {
+      return false;
+    }
+    // Mark the attribute encoder as parent (even when if it is not created
+    // yet).
+    if (sequential_encoder_marked_as_parent_.size() <= loc_id) {
+      sequential_encoder_marked_as_parent_.resize(loc_id + 1, false);
+    }
+    sequential_encoder_marked_as_parent_[loc_id] = true;
+
+    if (sequential_encoders_.size() <= loc_id) {
+      return true;  // Sequential encoders not generated yet.
+    }
+    sequential_encoders_[loc_id]->MarkParentAttribute();
+    return true;
+  }
+
+  const PointAttribute *GetPortableAttribute(
+      int32_t point_attribute_id) override {
+    const int32_t loc_id = GetLocalIdForPointAttribute(point_attribute_id);
+    if (loc_id < 0) {
+      return nullptr;
+    }
+    return sequential_encoders_[loc_id]->GetPortableAttribute();
+  }
+
+ protected:
+  bool TransformAttributesToPortableFormat() override;
+  bool EncodePortableAttributes(EncoderBuffer *out_buffer) override;
+  bool EncodeDataNeededByPortableTransforms(EncoderBuffer *out_buffer) override;
+
+  // Creates all sequential encoders (one for each attribute associated with the
+  // encoder).
+  virtual bool CreateSequentialEncoders();
+
+  // Create a sequential encoder for a given attribute based on the attribute
+  // type
+  // and the provided encoder options.
+  virtual std::unique_ptr<SequentialAttributeEncoder> CreateSequentialEncoder(
+      int i);
+
+ private:
+  std::vector<std::unique_ptr<SequentialAttributeEncoder>> sequential_encoders_;
+
+  // Flag for each sequential attribute encoder indicating whether it was marked
+  // as parent attribute or not.
+  std::vector<bool> sequential_encoder_marked_as_parent_;
+  std::vector<PointIndex> point_ids_;
+  std::unique_ptr<PointsSequencer> sequencer_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_ENCODERS_CONTROLLER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_decoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_decoder.cc
new file mode 100644
index 000000000..83f42125a
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_decoder.cc
@@ -0,0 +1,240 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/sequential_integer_attribute_decoder.h"
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_factory.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_decoding_transform.h"
+#include "draco/compression/entropy/symbol_decoding.h"
+
+namespace draco {
+
+SequentialIntegerAttributeDecoder::SequentialIntegerAttributeDecoder() {}
+
+bool SequentialIntegerAttributeDecoder::Init(PointCloudDecoder *decoder,
+                                             int attribute_id) {
+  if (!SequentialAttributeDecoder::Init(decoder, attribute_id)) {
+    return false;
+  }
+  return true;
+}
+
+bool SequentialIntegerAttributeDecoder::TransformAttributeToOriginalFormat(
+    const std::vector<PointIndex> &point_ids) {
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (decoder() &&
+      decoder()->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+    return true;  // Don't revert the transform here for older files.
+  }
+#endif
+  return StoreValues(static_cast<uint32_t>(point_ids.size()));
+}
+
+bool SequentialIntegerAttributeDecoder::DecodeValues(
+    const std::vector<PointIndex> &point_ids, DecoderBuffer *in_buffer) {
+  // Decode prediction scheme.
+  int8_t prediction_scheme_method;
+  if (!in_buffer->Decode(&prediction_scheme_method)) {
+    return false;
+  }
+  if (prediction_scheme_method != PREDICTION_NONE) {
+    int8_t prediction_transform_type;
+    if (!in_buffer->Decode(&prediction_transform_type)) {
+      return false;
+    }
+    // Check that decoded prediction scheme transform type is valid.
+    if (prediction_transform_type < PREDICTION_TRANSFORM_NONE ||
+        prediction_transform_type >= NUM_PREDICTION_SCHEME_TRANSFORM_TYPES) {
+      return false;
+    }
+    prediction_scheme_ = CreateIntPredictionScheme(
+        static_cast<PredictionSchemeMethod>(prediction_scheme_method),
+        static_cast<PredictionSchemeTransformType>(prediction_transform_type));
+  }
+
+  if (prediction_scheme_) {
+    if (!InitPredictionScheme(prediction_scheme_.get())) {
+      return false;
+    }
+  }
+
+  if (!DecodeIntegerValues(point_ids, in_buffer)) {
+    return false;
+  }
+
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  const int32_t num_values = static_cast<uint32_t>(point_ids.size());
+  if (decoder() &&
+      decoder()->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+    // For older files, revert the transform right after we decode the data.
+    if (!StoreValues(num_values)) {
+      return false;
+    }
+  }
+#endif
+  return true;
+}
+
+std::unique_ptr<PredictionSchemeTypedDecoderInterface<int32_t>>
+SequentialIntegerAttributeDecoder::CreateIntPredictionScheme(
+    PredictionSchemeMethod method,
+    PredictionSchemeTransformType transform_type) {
+  if (transform_type != PREDICTION_TRANSFORM_WRAP) {
+    return nullptr;  // For now we support only wrap transform.
+  }
+  return CreatePredictionSchemeForDecoder<
+      int32_t, PredictionSchemeWrapDecodingTransform<int32_t>>(
+      method, attribute_id(), decoder());
+}
+
+bool SequentialIntegerAttributeDecoder::DecodeIntegerValues(
+    const std::vector<PointIndex> &point_ids, DecoderBuffer *in_buffer) {
+  const int num_components = GetNumValueComponents();
+  if (num_components <= 0) {
+    return false;
+  }
+  const size_t num_entries = point_ids.size();
+  const size_t num_values = num_entries * num_components;
+  PreparePortableAttribute(static_cast<int>(num_entries), num_components);
+  int32_t *const portable_attribute_data = GetPortableAttributeData();
+  if (portable_attribute_data == nullptr) {
+    return false;
+  }
+  uint8_t compressed;
+  if (!in_buffer->Decode(&compressed)) {
+    return false;
+  }
+  if (compressed > 0) {
+    // Decode compressed values.
+    if (!DecodeSymbols(static_cast<uint32_t>(num_values), num_components,
+                       in_buffer,
+                       reinterpret_cast<uint32_t *>(portable_attribute_data))) {
+      return false;
+    }
+  } else {
+    // Decode the integer data directly.
+    // Get the number of bytes for a given entry.
+    uint8_t num_bytes;
+    if (!in_buffer->Decode(&num_bytes)) {
+      return false;
+    }
+    if (num_bytes == DataTypeLength(DT_INT32)) {
+      if (portable_attribute()->buffer()->data_size() <
+          sizeof(int32_t) * num_values) {
+        return false;
+      }
+      if (!in_buffer->Decode(portable_attribute_data,
+                             sizeof(int32_t) * num_values)) {
+        return false;
+      }
+    } else {
+      if (portable_attribute()->buffer()->data_size() <
+          num_bytes * num_values) {
+        return false;
+      }
+      if (in_buffer->remaining_size() <
+          static_cast<int64_t>(num_bytes) * static_cast<int64_t>(num_values)) {
+        return false;
+      }
+      for (size_t i = 0; i < num_values; ++i) {
+        if (!in_buffer->Decode(portable_attribute_data + i, num_bytes))
+          return false;
+      }
+    }
+  }
+
+  if (num_values > 0 && (prediction_scheme_ == nullptr ||
+                         !prediction_scheme_->AreCorrectionsPositive())) {
+    // Convert the values back to the original signed format.
+    ConvertSymbolsToSignedInts(
+        reinterpret_cast<const uint32_t *>(portable_attribute_data),
+        static_cast<int>(num_values), portable_attribute_data);
+  }
+
+  // If the data was encoded with a prediction scheme, we must revert it.
+  if (prediction_scheme_) {
+    if (!prediction_scheme_->DecodePredictionData(in_buffer)) {
+      return false;
+    }
+
+    if (num_values > 0) {
+      if (!prediction_scheme_->ComputeOriginalValues(
+              portable_attribute_data, portable_attribute_data,
+              static_cast<int>(num_values), num_components, point_ids.data())) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+bool SequentialIntegerAttributeDecoder::StoreValues(uint32_t num_values) {
+  switch (attribute()->data_type()) {
+    case DT_UINT8:
+      StoreTypedValues<uint8_t>(num_values);
+      break;
+    case DT_INT8:
+      StoreTypedValues<int8_t>(num_values);
+      break;
+    case DT_UINT16:
+      StoreTypedValues<uint16_t>(num_values);
+      break;
+    case DT_INT16:
+      StoreTypedValues<int16_t>(num_values);
+      break;
+    case DT_UINT32:
+      StoreTypedValues<uint32_t>(num_values);
+      break;
+    case DT_INT32:
+      StoreTypedValues<int32_t>(num_values);
+      break;
+    default:
+      return false;
+  }
+  return true;
+}
+
+template <typename AttributeTypeT>
+void SequentialIntegerAttributeDecoder::StoreTypedValues(uint32_t num_values) {
+  const int num_components = attribute()->num_components();
+  const int entry_size = sizeof(AttributeTypeT) * num_components;
+  const std::unique_ptr<AttributeTypeT[]> att_val(
+      new AttributeTypeT[num_components]);
+  const int32_t *const portable_attribute_data = GetPortableAttributeData();
+  int val_id = 0;
+  int out_byte_pos = 0;
+  for (uint32_t i = 0; i < num_values; ++i) {
+    for (int c = 0; c < num_components; ++c) {
+      const AttributeTypeT value =
+          static_cast<AttributeTypeT>(portable_attribute_data[val_id++]);
+      att_val[c] = value;
+    }
+    // Store the integer value into the attribute buffer.
+    attribute()->buffer()->Write(out_byte_pos, att_val.get(), entry_size);
+    out_byte_pos += entry_size;
+  }
+}
+
+void SequentialIntegerAttributeDecoder::PreparePortableAttribute(
+    int num_entries, int num_components) {
+  GeometryAttribute va;
+  va.Init(attribute()->attribute_type(), nullptr, num_components, DT_INT32,
+          false, num_components * DataTypeLength(DT_INT32), 0);
+  std::unique_ptr<PointAttribute> port_att(new PointAttribute(va));
+  port_att->SetIdentityMapping();
+  port_att->Reset(num_entries);
+  SetPortableAttribute(std::move(port_att));
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_decoder.h
new file mode 100644
index 000000000..ef48ed817
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_decoder.h
@@ -0,0 +1,76 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_INTEGER_ATTRIBUTE_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_INTEGER_ATTRIBUTE_DECODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_decoder.h"
+#include "draco/compression/attributes/sequential_attribute_decoder.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Decoder for attributes encoded with the SequentialIntegerAttributeEncoder.
+class SequentialIntegerAttributeDecoder : public SequentialAttributeDecoder {
+ public:
+  SequentialIntegerAttributeDecoder();
+  bool Init(PointCloudDecoder *decoder, int attribute_id) override;
+
+  bool TransformAttributeToOriginalFormat(
+      const std::vector<PointIndex> &point_ids) override;
+
+ protected:
+  bool DecodeValues(const std::vector<PointIndex> &point_ids,
+                    DecoderBuffer *in_buffer) override;
+  virtual bool DecodeIntegerValues(const std::vector<PointIndex> &point_ids,
+                                   DecoderBuffer *in_buffer);
+
+  // Returns a prediction scheme that should be used for decoding of the
+  // integer values.
+  virtual std::unique_ptr<PredictionSchemeTypedDecoderInterface<int32_t>>
+  CreateIntPredictionScheme(PredictionSchemeMethod method,
+                            PredictionSchemeTransformType transform_type);
+
+  // Returns the number of integer attribute components. In general, this
+  // can be different from the number of components of the input attribute.
+  virtual int32_t GetNumValueComponents() const {
+    return attribute()->num_components();
+  }
+
+  // Called after all integer values are decoded. The implementation should
+  // use this method to store the values into the attribute.
+  virtual bool StoreValues(uint32_t num_values);
+
+  void PreparePortableAttribute(int num_entries, int num_components);
+
+  int32_t *GetPortableAttributeData() {
+    if (portable_attribute()->size() == 0) {
+      return nullptr;
+    }
+    return reinterpret_cast<int32_t *>(
+        portable_attribute()->GetAddress(AttributeValueIndex(0)));
+  }
+
+ private:
+  // Stores decoded values into the attribute with a data type AttributeTypeT.
+  template <typename AttributeTypeT>
+  void StoreTypedValues(uint32_t num_values);
+
+  std::unique_ptr<PredictionSchemeTypedDecoderInterface<int32_t>>
+      prediction_scheme_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_INTEGER_ATTRIBUTE_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_encoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_encoder.cc
new file mode 100644
index 000000000..e66a0a8a4
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_encoder.cc
@@ -0,0 +1,233 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/sequential_integer_attribute_encoder.h"
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_encoding_transform.h"
+#include "draco/compression/entropy/symbol_encoding.h"
+#include "draco/core/bit_utils.h"
+
+namespace draco {
+
+SequentialIntegerAttributeEncoder::SequentialIntegerAttributeEncoder() {}
+
+bool SequentialIntegerAttributeEncoder::Init(PointCloudEncoder *encoder,
+                                             int attribute_id) {
+  if (!SequentialAttributeEncoder::Init(encoder, attribute_id)) {
+    return false;
+  }
+  if (GetUniqueId() == SEQUENTIAL_ATTRIBUTE_ENCODER_INTEGER) {
+    // When encoding integers, this encoder currently works only for integer
+    // attributes up to 32 bits.
+    switch (attribute()->data_type()) {
+      case DT_INT8:
+      case DT_UINT8:
+      case DT_INT16:
+      case DT_UINT16:
+      case DT_INT32:
+      case DT_UINT32:
+        break;
+      default:
+        return false;
+    }
+  }
+  // Init prediction scheme.
+  const PredictionSchemeMethod prediction_scheme_method =
+      GetPredictionMethodFromOptions(attribute_id, *encoder->options());
+
+  prediction_scheme_ = CreateIntPredictionScheme(prediction_scheme_method);
+
+  if (prediction_scheme_ && !InitPredictionScheme(prediction_scheme_.get())) {
+    prediction_scheme_ = nullptr;
+  }
+
+  return true;
+}
+
+bool SequentialIntegerAttributeEncoder::TransformAttributeToPortableFormat(
+    const std::vector<PointIndex> &point_ids) {
+  if (encoder()) {
+    if (!PrepareValues(point_ids, encoder()->point_cloud()->num_points())) {
+      return false;
+    }
+  } else {
+    if (!PrepareValues(point_ids, 0)) {
+      return false;
+    }
+  }
+
+  // Update point to attribute mapping with the portable attribute if the
+  // attribute is a parent attribute (for now, we can skip it otherwise).
+  if (is_parent_encoder()) {
+    // First create map between original attribute value indices and new ones
+    // (determined by the encoding order).
+    const PointAttribute *const orig_att = attribute();
+    PointAttribute *const portable_att = portable_attribute();
+    IndexTypeVector<AttributeValueIndex, AttributeValueIndex>
+        value_to_value_map(orig_att->size());
+    for (int i = 0; i < point_ids.size(); ++i) {
+      value_to_value_map[orig_att->mapped_index(point_ids[i])] =
+          AttributeValueIndex(i);
+    }
+    if (portable_att->is_mapping_identity()) {
+      portable_att->SetExplicitMapping(encoder()->point_cloud()->num_points());
+    }
+    // Go over all points of the original attribute and update the mapping in
+    // the portable attribute.
+    for (PointIndex i(0); i < encoder()->point_cloud()->num_points(); ++i) {
+      portable_att->SetPointMapEntry(
+          i, value_to_value_map[orig_att->mapped_index(i)]);
+    }
+  }
+  return true;
+}
+
+std::unique_ptr<PredictionSchemeTypedEncoderInterface<int32_t>>
+SequentialIntegerAttributeEncoder::CreateIntPredictionScheme(
+    PredictionSchemeMethod method) {
+  return CreatePredictionSchemeForEncoder<
+      int32_t, PredictionSchemeWrapEncodingTransform<int32_t>>(
+      method, attribute_id(), encoder());
+}
+
+bool SequentialIntegerAttributeEncoder::EncodeValues(
+    const std::vector<PointIndex> &point_ids, EncoderBuffer *out_buffer) {
+  // Initialize general quantization data.
+  const PointAttribute *const attrib = attribute();
+  if (attrib->size() == 0) {
+    return true;
+  }
+
+  int8_t prediction_scheme_method = PREDICTION_NONE;
+  if (prediction_scheme_) {
+    if (!SetPredictionSchemeParentAttributes(prediction_scheme_.get())) {
+      return false;
+    }
+    prediction_scheme_method =
+        static_cast<int8_t>(prediction_scheme_->GetPredictionMethod());
+  }
+  out_buffer->Encode(prediction_scheme_method);
+  if (prediction_scheme_) {
+    out_buffer->Encode(
+        static_cast<int8_t>(prediction_scheme_->GetTransformType()));
+  }
+
+  const int num_components = portable_attribute()->num_components();
+  const int num_values =
+      static_cast<int>(num_components * portable_attribute()->size());
+  const int32_t *const portable_attribute_data = GetPortableAttributeData();
+
+  // We need to keep the portable data intact, but several encoding steps can
+  // result in changes of this data, e.g., by applying prediction schemes that
+  // change the data in place. To preserve the portable data we store and
+  // process all encoded data in a separate array.
+  std::vector<int32_t> encoded_data(num_values);
+
+  // All integer values are initialized. Process them using the prediction
+  // scheme if we have one.
+  if (prediction_scheme_) {
+    prediction_scheme_->ComputeCorrectionValues(
+        portable_attribute_data, &encoded_data[0], num_values, num_components,
+        point_ids.data());
+  }
+
+  if (prediction_scheme_ == nullptr ||
+      !prediction_scheme_->AreCorrectionsPositive()) {
+    const int32_t *const input =
+        prediction_scheme_ ? encoded_data.data() : portable_attribute_data;
+    ConvertSignedIntsToSymbols(input, num_values,
+                               reinterpret_cast<uint32_t *>(&encoded_data[0]));
+  }
+
+  if (encoder() == nullptr || encoder()->options()->GetGlobalBool(
+                                  "use_built_in_attribute_compression", true)) {
+    out_buffer->Encode(static_cast<uint8_t>(1));
+    Options symbol_encoding_options;
+    if (encoder() != nullptr) {
+      SetSymbolEncodingCompressionLevel(&symbol_encoding_options,
+                                        10 - encoder()->options()->GetSpeed());
+    }
+    if (!EncodeSymbols(reinterpret_cast<uint32_t *>(encoded_data.data()),
+                       static_cast<int>(point_ids.size()) * num_components,
+                       num_components, &symbol_encoding_options, out_buffer)) {
+      return false;
+    }
+  } else {
+    // No compression. Just store the raw integer values, using the number of
+    // bytes as needed.
+
+    // To compute the maximum bit-length, first OR all values.
+    uint32_t masked_value = 0;
+    for (uint32_t i = 0; i < static_cast<uint32_t>(num_values); ++i) {
+      masked_value |= encoded_data[i];
+    }
+    // Compute the msb of the ORed value.
+    int value_msb_pos = 0;
+    if (masked_value != 0) {
+      value_msb_pos = MostSignificantBit(masked_value);
+    }
+    const int num_bytes = 1 + value_msb_pos / 8;
+
+    out_buffer->Encode(static_cast<uint8_t>(0));
+    out_buffer->Encode(static_cast<uint8_t>(num_bytes));
+
+    if (num_bytes == DataTypeLength(DT_INT32)) {
+      out_buffer->Encode(encoded_data.data(), sizeof(int32_t) * num_values);
+    } else {
+      for (uint32_t i = 0; i < static_cast<uint32_t>(num_values); ++i) {
+        out_buffer->Encode(encoded_data.data() + i, num_bytes);
+      }
+    }
+  }
+  if (prediction_scheme_) {
+    prediction_scheme_->EncodePredictionData(out_buffer);
+  }
+  return true;
+}
+
+bool SequentialIntegerAttributeEncoder::PrepareValues(
+    const std::vector<PointIndex> &point_ids, int num_points) {
+  // Convert all values to int32_t format.
+  const PointAttribute *const attrib = attribute();
+  const int num_components = attrib->num_components();
+  const int num_entries = static_cast<int>(point_ids.size());
+  PreparePortableAttribute(num_entries, num_components, num_points);
+  int32_t dst_index = 0;
+  int32_t *const portable_attribute_data = GetPortableAttributeData();
+  for (PointIndex pi : point_ids) {
+    const AttributeValueIndex att_id = attrib->mapped_index(pi);
+    if (!attrib->ConvertValue<int32_t>(att_id,
+                                       portable_attribute_data + dst_index)) {
+      return false;
+    }
+    dst_index += num_components;
+  }
+  return true;
+}
+
+void SequentialIntegerAttributeEncoder::PreparePortableAttribute(
+    int num_entries, int num_components, int num_points) {
+  GeometryAttribute va;
+  va.Init(attribute()->attribute_type(), nullptr, num_components, DT_INT32,
+          false, num_components * DataTypeLength(DT_INT32), 0);
+  std::unique_ptr<PointAttribute> port_att(new PointAttribute(va));
+  port_att->Reset(num_entries);
+  SetPortableAttribute(std::move(port_att));
+  if (num_points) {
+    portable_attribute()->SetExplicitMapping(num_points);
+  }
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_encoder.h
new file mode 100644
index 000000000..c1d6222ef
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_encoder.h
@@ -0,0 +1,67 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_INTEGER_ATTRIBUTE_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_INTEGER_ATTRIBUTE_ENCODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_encoder.h"
+#include "draco/compression/attributes/sequential_attribute_encoder.h"
+
+namespace draco {
+
+// Attribute encoder designed for lossless encoding of integer attributes. The
+// attribute values can be pre-processed by a prediction scheme and compressed
+// with a built-in entropy coder.
+class SequentialIntegerAttributeEncoder : public SequentialAttributeEncoder {
+ public:
+  SequentialIntegerAttributeEncoder();
+  uint8_t GetUniqueId() const override {
+    return SEQUENTIAL_ATTRIBUTE_ENCODER_INTEGER;
+  }
+
+  bool Init(PointCloudEncoder *encoder, int attribute_id) override;
+  bool TransformAttributeToPortableFormat(
+      const std::vector<PointIndex> &point_ids) override;
+
+ protected:
+  bool EncodeValues(const std::vector<PointIndex> &point_ids,
+                    EncoderBuffer *out_buffer) override;
+
+  // Returns a prediction scheme that should be used for encoding of the
+  // integer values.
+  virtual std::unique_ptr<PredictionSchemeTypedEncoderInterface<int32_t>>
+  CreateIntPredictionScheme(PredictionSchemeMethod method);
+
+  // Prepares the integer values that are going to be encoded.
+  virtual bool PrepareValues(const std::vector<PointIndex> &point_ids,
+                             int num_points);
+
+  void PreparePortableAttribute(int num_entries, int num_components,
+                                int num_points);
+
+  int32_t *GetPortableAttributeData() {
+    return reinterpret_cast<int32_t *>(
+        portable_attribute()->GetAddress(AttributeValueIndex(0)));
+  }
+
+ private:
+  // Optional prediction scheme can be used to modify the integer values in
+  // order to make them easier to compress.
+  std::unique_ptr<PredictionSchemeTypedEncoderInterface<int32_t>>
+      prediction_scheme_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_INTEGER_ATTRIBUTE_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_encoding_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_encoding_test.cc
new file mode 100644
index 000000000..44485e679
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_encoding_test.cc
@@ -0,0 +1,64 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include <numeric>
+
+#include "draco/compression/attributes/sequential_integer_attribute_decoder.h"
+#include "draco/compression/attributes/sequential_integer_attribute_encoder.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/draco_test_base.h"
+
+namespace draco {
+
+class SequentialIntegerAttributeEncodingTest : public ::testing::Test {
+ protected:
+};
+
+TEST_F(SequentialIntegerAttributeEncodingTest, DoesCompress) {
+  // This test verifies that IntegerEncoding encodes and decodes the given data.
+  const std::vector<int32_t> values{1,   8,  7,  5, 5,   5, 9,
+                                    155, -6, -9, 9, 125, 1, 0};
+  PointAttribute pa;
+  pa.Init(GeometryAttribute::GENERIC, 1, DT_INT32, false, values.size());
+  for (uint32_t i = 0; i < values.size(); ++i) {
+    pa.SetAttributeValue(AttributeValueIndex(i), &values[i]);
+  }
+  // List of point ids from 0 to point_ids.size() - 1.
+  std::vector<PointIndex> point_ids(values.size());
+  std::iota(point_ids.begin(), point_ids.end(), 0);
+
+  EncoderBuffer out_buf;
+  SequentialIntegerAttributeEncoder ie;
+  ASSERT_TRUE(ie.InitializeStandalone(&pa));
+  ASSERT_TRUE(ie.TransformAttributeToPortableFormat(point_ids));
+  ASSERT_TRUE(ie.EncodePortableAttribute(point_ids, &out_buf));
+  ASSERT_TRUE(ie.EncodeDataNeededByPortableTransform(&out_buf));
+
+  DecoderBuffer in_buf;
+  in_buf.Init(out_buf.data(), out_buf.size());
+  in_buf.set_bitstream_version(kDracoMeshBitstreamVersion);
+  SequentialIntegerAttributeDecoder id;
+  ASSERT_TRUE(id.InitializeStandalone(&pa));
+  ASSERT_TRUE(id.DecodePortableAttribute(point_ids, &in_buf));
+  ASSERT_TRUE(id.DecodeDataNeededByPortableTransform(point_ids, &in_buf));
+  ASSERT_TRUE(id.TransformAttributeToOriginalFormat(point_ids));
+
+  for (uint32_t i = 0; i < values.size(); ++i) {
+    int32_t entry_val;
+    pa.GetValue(AttributeValueIndex(i), &entry_val);
+    ASSERT_EQ(entry_val, values[i]);
+  }
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_decoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_decoder.cc
new file mode 100644
index 000000000..de36c1c36
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_decoder.cc
@@ -0,0 +1,76 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/sequential_normal_attribute_decoder.h"
+
+#include "draco/compression/attributes/normal_compression_utils.h"
+
+namespace draco {
+
+SequentialNormalAttributeDecoder::SequentialNormalAttributeDecoder() {}
+
+bool SequentialNormalAttributeDecoder::Init(PointCloudDecoder *decoder,
+                                            int attribute_id) {
+  if (!SequentialIntegerAttributeDecoder::Init(decoder, attribute_id)) {
+    return false;
+  }
+  // Currently, this encoder works only for 3-component normal vectors.
+  if (attribute()->num_components() != 3) {
+    return false;
+  }
+  // Also the data type must be DT_FLOAT32.
+  if (attribute()->data_type() != DT_FLOAT32) {
+    return false;
+  }
+  return true;
+}
+
+bool SequentialNormalAttributeDecoder::DecodeIntegerValues(
+    const std::vector<PointIndex> &point_ids, DecoderBuffer *in_buffer) {
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (decoder()->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+    // Note: in older bitstreams, we do not have a PortableAttribute() decoded
+    // at this stage so we cannot pass it down to the DecodeParameters() call.
+    // It still works fine for octahedral transform because it does not need to
+    // use any data from the attribute.
+    if (!octahedral_transform_.DecodeParameters(*attribute(), in_buffer)) {
+      return false;
+    }
+  }
+#endif
+  return SequentialIntegerAttributeDecoder::DecodeIntegerValues(point_ids,
+                                                                in_buffer);
+}
+
+bool SequentialNormalAttributeDecoder::DecodeDataNeededByPortableTransform(
+    const std::vector<PointIndex> &point_ids, DecoderBuffer *in_buffer) {
+  if (decoder()->bitstream_version() >= DRACO_BITSTREAM_VERSION(2, 0)) {
+    // For newer file version, decode attribute transform data here.
+    if (!octahedral_transform_.DecodeParameters(*GetPortableAttribute(),
+                                                in_buffer)) {
+      return false;
+    }
+  }
+
+  // Store the decoded transform data in portable attribute.
+  return octahedral_transform_.TransferToAttribute(portable_attribute());
+}
+
+bool SequentialNormalAttributeDecoder::StoreValues(uint32_t num_points) {
+  // Convert all quantized values back to floats.
+  return octahedral_transform_.InverseTransformAttribute(
+      *GetPortableAttribute(), attribute());
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_decoder.h
new file mode 100644
index 000000000..8c2d801b7
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_decoder.h
@@ -0,0 +1,83 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_NORMAL_ATTRIBUTE_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_NORMAL_ATTRIBUTE_DECODER_H_
+
+#include "draco/attributes/attribute_octahedron_transform.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_factory.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_decoding_transform.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_decoding_transform.h"
+#include "draco/compression/attributes/sequential_integer_attribute_decoder.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Decoder for attributes encoded with SequentialNormalAttributeEncoder.
+class SequentialNormalAttributeDecoder
+    : public SequentialIntegerAttributeDecoder {
+ public:
+  SequentialNormalAttributeDecoder();
+  bool Init(PointCloudDecoder *decoder, int attribute_id) override;
+
+ protected:
+  int32_t GetNumValueComponents() const override {
+    return 2;  // We quantize everything into two components.
+  }
+  bool DecodeIntegerValues(const std::vector<PointIndex> &point_ids,
+                           DecoderBuffer *in_buffer) override;
+  bool DecodeDataNeededByPortableTransform(
+      const std::vector<PointIndex> &point_ids,
+      DecoderBuffer *in_buffer) override;
+  bool StoreValues(uint32_t num_points) override;
+
+ private:
+  AttributeOctahedronTransform octahedral_transform_;
+
+  std::unique_ptr<PredictionSchemeTypedDecoderInterface<int32_t>>
+  CreateIntPredictionScheme(
+      PredictionSchemeMethod method,
+      PredictionSchemeTransformType transform_type) override {
+    switch (transform_type) {
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+      case PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON: {
+        typedef PredictionSchemeNormalOctahedronDecodingTransform<int32_t>
+            Transform;
+        // At this point the decoder has not read the quantization bits,
+        // which is why we must construct the transform by default.
+        // See Transform.DecodeTransformData for more details.
+        return CreatePredictionSchemeForDecoder<int32_t, Transform>(
+            method, attribute_id(), decoder());
+      }
+#endif
+      case PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON_CANONICALIZED: {
+        typedef PredictionSchemeNormalOctahedronCanonicalizedDecodingTransform<
+            int32_t>
+            Transform;
+        // At this point the decoder has not read the quantization bits,
+        // which is why we must construct the transform by default.
+        // See Transform.DecodeTransformData for more details.
+        return CreatePredictionSchemeForDecoder<int32_t, Transform>(
+            method, attribute_id(), decoder());
+      }
+      default:
+        return nullptr;  // Currently, we support only octahedron transform and
+                         // octahedron transform canonicalized.
+    }
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_NORMAL_ATTRIBUTE_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_encoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_encoder.cc
new file mode 100644
index 000000000..2e20e89e6
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_encoder.cc
@@ -0,0 +1,57 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/sequential_normal_attribute_encoder.h"
+
+#include "draco/compression/attributes/normal_compression_utils.h"
+
+namespace draco {
+
+bool SequentialNormalAttributeEncoder::Init(PointCloudEncoder *encoder,
+                                            int attribute_id) {
+  if (!SequentialIntegerAttributeEncoder::Init(encoder, attribute_id))
+    return false;
+  // Currently this encoder works only for 3-component normal vectors.
+  if (attribute()->num_components() != 3) {
+    return false;
+  }
+
+  // Initialize AttributeOctahedronTransform.
+  const int quantization_bits = encoder->options()->GetAttributeInt(
+      attribute_id, "quantization_bits", -1);
+  if (quantization_bits < 1) {
+    return false;
+  }
+  attribute_octahedron_transform_.SetParameters(quantization_bits);
+  return true;
+}
+
+bool SequentialNormalAttributeEncoder::EncodeDataNeededByPortableTransform(
+    EncoderBuffer *out_buffer) {
+  return attribute_octahedron_transform_.EncodeParameters(out_buffer);
+}
+
+bool SequentialNormalAttributeEncoder::PrepareValues(
+    const std::vector<PointIndex> &point_ids, int num_points) {
+  auto portable_att = attribute_octahedron_transform_.InitTransformedAttribute(
+      *(attribute()), point_ids.size());
+  if (!attribute_octahedron_transform_.TransformAttribute(
+          *(attribute()), point_ids, portable_att.get())) {
+    return false;
+  }
+  SetPortableAttribute(std::move(portable_att));
+  return true;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_encoder.h
new file mode 100644
index 000000000..53705c598
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_encoder.h
@@ -0,0 +1,82 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_NORMAL_ATTRIBUTE_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_NORMAL_ATTRIBUTE_ENCODER_H_
+
+#include "draco/attributes/attribute_octahedron_transform.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_encoding_transform.h"
+#include "draco/compression/attributes/sequential_integer_attribute_encoder.h"
+#include "draco/compression/config/compression_shared.h"
+
+namespace draco {
+
+// Class for encoding normal vectors using an octahedral encoding, see Cigolle
+// et al.'14 “A Survey of Efficient Representations for Independent Unit
+// Vectors�. Compared to the basic quantization encoder, this encoder results
+// in a better compression rate under the same accuracy settings. Note that this
+// encoder doesn't preserve the lengths of input vectors, therefore it will not
+// work correctly when the input values are not normalized.
+class SequentialNormalAttributeEncoder
+    : public SequentialIntegerAttributeEncoder {
+ public:
+  uint8_t GetUniqueId() const override {
+    return SEQUENTIAL_ATTRIBUTE_ENCODER_NORMALS;
+  }
+  bool IsLossyEncoder() const override { return true; }
+
+  bool EncodeDataNeededByPortableTransform(EncoderBuffer *out_buffer) override;
+
+ protected:
+  bool Init(PointCloudEncoder *encoder, int attribute_id) override;
+
+  // Put quantized values in portable attribute for sequential encoding.
+  bool PrepareValues(const std::vector<PointIndex> &point_ids,
+                     int num_points) override;
+
+  std::unique_ptr<PredictionSchemeTypedEncoderInterface<int32_t>>
+  CreateIntPredictionScheme(PredictionSchemeMethod /* method */) override {
+    typedef PredictionSchemeNormalOctahedronCanonicalizedEncodingTransform<
+        int32_t>
+        Transform;
+    const int32_t quantization_bits = encoder()->options()->GetAttributeInt(
+        attribute_id(), "quantization_bits", -1);
+    const int32_t max_value = (1 << quantization_bits) - 1;
+    const Transform transform(max_value);
+    const PredictionSchemeMethod default_prediction_method =
+        SelectPredictionMethod(attribute_id(), encoder());
+    const int32_t prediction_method = encoder()->options()->GetAttributeInt(
+        attribute_id(), "prediction_scheme", default_prediction_method);
+
+    if (prediction_method == MESH_PREDICTION_GEOMETRIC_NORMAL) {
+      return CreatePredictionSchemeForEncoder<int32_t, Transform>(
+          MESH_PREDICTION_GEOMETRIC_NORMAL, attribute_id(), encoder(),
+          transform);
+    }
+    if (prediction_method == PREDICTION_DIFFERENCE) {
+      return CreatePredictionSchemeForEncoder<int32_t, Transform>(
+          PREDICTION_DIFFERENCE, attribute_id(), encoder(), transform);
+    }
+    DRACO_DCHECK(false);  // Should never be reached.
+    return nullptr;
+  }
+
+  // Used for the conversion to quantized normals in octahedral format.
+  AttributeOctahedronTransform attribute_octahedron_transform_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_NORMAL_ATTRIBUTE_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_decoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_decoder.cc
new file mode 100644
index 000000000..3d306e7da
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_decoder.cc
@@ -0,0 +1,88 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/sequential_quantization_attribute_decoder.h"
+
+#include "draco/core/quantization_utils.h"
+
+namespace draco {
+
+SequentialQuantizationAttributeDecoder::
+    SequentialQuantizationAttributeDecoder() {}
+
+bool SequentialQuantizationAttributeDecoder::Init(PointCloudDecoder *decoder,
+                                                  int attribute_id) {
+  if (!SequentialIntegerAttributeDecoder::Init(decoder, attribute_id)) {
+    return false;
+  }
+  const PointAttribute *const attribute =
+      decoder->point_cloud()->attribute(attribute_id);
+  // Currently we can quantize only floating point arguments.
+  if (attribute->data_type() != DT_FLOAT32) {
+    return false;
+  }
+  return true;
+}
+
+bool SequentialQuantizationAttributeDecoder::DecodeIntegerValues(
+    const std::vector<PointIndex> &point_ids, DecoderBuffer *in_buffer) {
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (decoder()->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0) &&
+      !DecodeQuantizedDataInfo()) {
+    return false;
+  }
+#endif
+  return SequentialIntegerAttributeDecoder::DecodeIntegerValues(point_ids,
+                                                                in_buffer);
+}
+
+bool SequentialQuantizationAttributeDecoder::
+    DecodeDataNeededByPortableTransform(
+        const std::vector<PointIndex> &point_ids, DecoderBuffer *in_buffer) {
+  if (decoder()->bitstream_version() >= DRACO_BITSTREAM_VERSION(2, 0)) {
+    // Decode quantization data here only for files with bitstream version 2.0+
+    if (!DecodeQuantizedDataInfo()) {
+      return false;
+    }
+  }
+
+  // Store the decoded transform data in portable attribute;
+  return quantization_transform_.TransferToAttribute(portable_attribute());
+}
+
+bool SequentialQuantizationAttributeDecoder::StoreValues(uint32_t num_points) {
+  return DequantizeValues(num_points);
+}
+
+bool SequentialQuantizationAttributeDecoder::DecodeQuantizedDataInfo() {
+  // Get attribute used as source for decoding.
+  auto att = GetPortableAttribute();
+  if (att == nullptr) {
+    // This should happen only in the backward compatibility mode. It will still
+    // work fine for this case because the only thing the quantization transform
+    // cares about is the number of components that is the same for both source
+    // and target attributes.
+    att = attribute();
+  }
+  return quantization_transform_.DecodeParameters(*att, decoder()->buffer());
+}
+
+bool SequentialQuantizationAttributeDecoder::DequantizeValues(
+    uint32_t num_values) {
+  // Convert all quantized values back to floats.
+  return quantization_transform_.InverseTransformAttribute(
+      *GetPortableAttribute(), attribute());
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_decoder.h
new file mode 100644
index 000000000..ad372dcd8
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_decoder.h
@@ -0,0 +1,52 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_QUANTIZATION_ATTRIBUTE_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_QUANTIZATION_ATTRIBUTE_DECODER_H_
+
+#include "draco/attributes/attribute_quantization_transform.h"
+#include "draco/compression/attributes/sequential_integer_attribute_decoder.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Decoder for attribute values encoded with the
+// SequentialQuantizationAttributeEncoder.
+class SequentialQuantizationAttributeDecoder
+    : public SequentialIntegerAttributeDecoder {
+ public:
+  SequentialQuantizationAttributeDecoder();
+  bool Init(PointCloudDecoder *decoder, int attribute_id) override;
+
+ protected:
+  bool DecodeIntegerValues(const std::vector<PointIndex> &point_ids,
+                           DecoderBuffer *in_buffer) override;
+  bool DecodeDataNeededByPortableTransform(
+      const std::vector<PointIndex> &point_ids,
+      DecoderBuffer *in_buffer) override;
+  bool StoreValues(uint32_t num_points) override;
+
+  // Decodes data necessary for dequantizing the encoded values.
+  virtual bool DecodeQuantizedDataInfo();
+
+  // Dequantizes all values and stores them into the output attribute.
+  virtual bool DequantizeValues(uint32_t num_values);
+
+ private:
+  AttributeQuantizationTransform quantization_transform_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_QUANTIZATION_ATTRIBUTE_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_encoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_encoder.cc
new file mode 100644
index 000000000..d3666f7a4
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_encoder.cc
@@ -0,0 +1,86 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/sequential_quantization_attribute_encoder.h"
+
+#include "draco/core/quantization_utils.h"
+
+namespace draco {
+
+SequentialQuantizationAttributeEncoder::
+    SequentialQuantizationAttributeEncoder() {}
+
+bool SequentialQuantizationAttributeEncoder::Init(PointCloudEncoder *encoder,
+                                                  int attribute_id) {
+  if (!SequentialIntegerAttributeEncoder::Init(encoder, attribute_id)) {
+    return false;
+  }
+  // This encoder currently works only for floating point attributes.
+  const PointAttribute *const attribute =
+      encoder->point_cloud()->attribute(attribute_id);
+  if (attribute->data_type() != DT_FLOAT32) {
+    return false;
+  }
+
+  // Initialize AttributeQuantizationTransform.
+  const int quantization_bits = encoder->options()->GetAttributeInt(
+      attribute_id, "quantization_bits", -1);
+  if (quantization_bits < 1) {
+    return false;
+  }
+  if (encoder->options()->IsAttributeOptionSet(attribute_id,
+                                               "quantization_origin") &&
+      encoder->options()->IsAttributeOptionSet(attribute_id,
+                                               "quantization_range")) {
+    // Quantization settings are explicitly specified in the provided options.
+    std::vector<float> quantization_origin(attribute->num_components());
+    encoder->options()->GetAttributeVector(attribute_id, "quantization_origin",
+                                           attribute->num_components(),
+                                           &quantization_origin[0]);
+    const float range = encoder->options()->GetAttributeFloat(
+        attribute_id, "quantization_range", 1.f);
+    if (!attribute_quantization_transform_.SetParameters(
+            quantization_bits, quantization_origin.data(),
+            attribute->num_components(), range)) {
+      return false;
+    }
+  } else {
+    // Compute quantization settings from the attribute values.
+    if (!attribute_quantization_transform_.ComputeParameters(
+            *attribute, quantization_bits)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool SequentialQuantizationAttributeEncoder::
+    EncodeDataNeededByPortableTransform(EncoderBuffer *out_buffer) {
+  return attribute_quantization_transform_.EncodeParameters(out_buffer);
+}
+
+bool SequentialQuantizationAttributeEncoder::PrepareValues(
+    const std::vector<PointIndex> &point_ids, int num_points) {
+  auto portable_attribute =
+      attribute_quantization_transform_.InitTransformedAttribute(
+          *attribute(), point_ids.size());
+  if (!attribute_quantization_transform_.TransformAttribute(
+          *(attribute()), point_ids, portable_attribute.get())) {
+    return false;
+  }
+  SetPortableAttribute(std::move(portable_attribute));
+  return true;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_encoder.h
new file mode 100644
index 000000000..e9762bdd6
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_encoder.h
@@ -0,0 +1,52 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_QUANTIZATION_ATTRIBUTE_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_QUANTIZATION_ATTRIBUTE_ENCODER_H_
+
+#include "draco/attributes/attribute_quantization_transform.h"
+#include "draco/compression/attributes/sequential_integer_attribute_encoder.h"
+
+namespace draco {
+
+class MeshEncoder;
+
+// Attribute encoder that quantizes floating point attribute values. The
+// quantized values can be optionally compressed using an entropy coding.
+class SequentialQuantizationAttributeEncoder
+    : public SequentialIntegerAttributeEncoder {
+ public:
+  SequentialQuantizationAttributeEncoder();
+  uint8_t GetUniqueId() const override {
+    return SEQUENTIAL_ATTRIBUTE_ENCODER_QUANTIZATION;
+  }
+  bool Init(PointCloudEncoder *encoder, int attribute_id) override;
+
+  bool IsLossyEncoder() const override { return true; }
+
+  bool EncodeDataNeededByPortableTransform(EncoderBuffer *out_buffer) override;
+
+ protected:
+  // Put quantized values in portable attribute for sequential encoding.
+  bool PrepareValues(const std::vector<PointIndex> &point_ids,
+                     int num_points) override;
+
+ private:
+  // Used for the quantization.
+  AttributeQuantizationTransform attribute_quantization_transform_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_QUANTIZATION_ATTRIBUTE_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_coding_shared.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_coding_shared.h
new file mode 100644
index 000000000..faacbd5b9
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_coding_shared.h
@@ -0,0 +1,43 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides shared functions for adaptive rANS bit coding.
+#ifndef DRACO_COMPRESSION_BIT_CODERS_ADAPTIVE_RANS_BIT_CODING_SHARED_H_
+#define DRACO_COMPRESSION_BIT_CODERS_ADAPTIVE_RANS_BIT_CODING_SHARED_H_
+
+#include "draco/core/macros.h"
+
+namespace draco {
+
+// Clamp the probability p to a uint8_t in the range [1,255].
+inline uint8_t clamp_probability(double p) {
+  DRACO_DCHECK_LE(p, 1.0);
+  DRACO_DCHECK_LE(0.0, p);
+  uint32_t p_int = static_cast<uint32_t>((p * 256) + 0.5);
+  p_int -= (p_int == 256);
+  p_int += (p_int == 0);
+  return static_cast<uint8_t>(p_int);
+}
+
+// Update the probability according to new incoming bit.
+inline double update_probability(double old_p, bool bit) {
+  static constexpr double w = 128.0;
+  static constexpr double w0 = (w - 1.0) / w;
+  static constexpr double w1 = 1.0 / w;
+  return old_p * w0 + (!bit) * w1;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_ADAPTIVE_RANS_BIT_CODING_SHARED_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_decoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_decoder.cc
new file mode 100644
index 000000000..056842c4a
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_decoder.cc
@@ -0,0 +1,70 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/bit_coders/adaptive_rans_bit_decoder.h"
+
+#include "draco/compression/bit_coders/adaptive_rans_bit_coding_shared.h"
+
+namespace draco {
+
+AdaptiveRAnsBitDecoder::AdaptiveRAnsBitDecoder() : p0_f_(0.5) {}
+
+AdaptiveRAnsBitDecoder::~AdaptiveRAnsBitDecoder() { Clear(); }
+
+bool AdaptiveRAnsBitDecoder::StartDecoding(DecoderBuffer *source_buffer) {
+  Clear();
+
+  uint32_t size_in_bytes;
+  if (!source_buffer->Decode(&size_in_bytes)) {
+    return false;
+  }
+  if (size_in_bytes > source_buffer->remaining_size()) {
+    return false;
+  }
+  if (ans_read_init(&ans_decoder_,
+                    reinterpret_cast<uint8_t *>(
+                        const_cast<char *>(source_buffer->data_head())),
+                    size_in_bytes) != 0) {
+    return false;
+  }
+  source_buffer->Advance(size_in_bytes);
+  return true;
+}
+
+bool AdaptiveRAnsBitDecoder::DecodeNextBit() {
+  const uint8_t p0 = clamp_probability(p0_f_);
+  const bool bit = static_cast<bool>(rabs_read(&ans_decoder_, p0));
+  p0_f_ = update_probability(p0_f_, bit);
+  return bit;
+}
+
+void AdaptiveRAnsBitDecoder::DecodeLeastSignificantBits32(int nbits,
+                                                          uint32_t *value) {
+  DRACO_DCHECK_EQ(true, nbits <= 32);
+  DRACO_DCHECK_EQ(true, nbits > 0);
+
+  uint32_t result = 0;
+  while (nbits) {
+    result = (result << 1) + DecodeNextBit();
+    --nbits;
+  }
+  *value = result;
+}
+
+void AdaptiveRAnsBitDecoder::Clear() {
+  ans_read_end(&ans_decoder_);
+  p0_f_ = 0.5;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_decoder.h
new file mode 100644
index 000000000..a1ea011dd
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_decoder.h
@@ -0,0 +1,54 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides basic classes and functions for rANS bit decoding.
+#ifndef DRACO_COMPRESSION_BIT_CODERS_ADAPTIVE_RANS_BIT_DECODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_ADAPTIVE_RANS_BIT_DECODER_H_
+
+#include <vector>
+
+#include "draco/compression/entropy/ans.h"
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+
+// Class for decoding a sequence of bits that were encoded with
+// AdaptiveRAnsBitEncoder.
+class AdaptiveRAnsBitDecoder {
+ public:
+  AdaptiveRAnsBitDecoder();
+  ~AdaptiveRAnsBitDecoder();
+
+  // Sets |source_buffer| as the buffer to decode bits from.
+  bool StartDecoding(DecoderBuffer *source_buffer);
+
+  // Decode one bit. Returns true if the bit is a 1, otherwise false.
+  bool DecodeNextBit();
+
+  // Decode the next |nbits| and return the sequence in |value|. |nbits| must be
+  // > 0 and <= 32.
+  void DecodeLeastSignificantBits32(int nbits, uint32_t *value);
+
+  void EndDecoding() {}
+
+ private:
+  void Clear();
+
+  AnsDecoder ans_decoder_;
+  double p0_f_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_ADAPTIVE_RANS_BIT_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_encoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_encoder.cc
new file mode 100644
index 000000000..5ce9dc388
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_encoder.cc
@@ -0,0 +1,59 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/bit_coders/adaptive_rans_bit_encoder.h"
+
+#include "draco/compression/bit_coders/adaptive_rans_bit_coding_shared.h"
+
+namespace draco {
+
+AdaptiveRAnsBitEncoder::AdaptiveRAnsBitEncoder() {}
+
+AdaptiveRAnsBitEncoder::~AdaptiveRAnsBitEncoder() { Clear(); }
+
+void AdaptiveRAnsBitEncoder::StartEncoding() { Clear(); }
+
+void AdaptiveRAnsBitEncoder::EndEncoding(EncoderBuffer *target_buffer) {
+  // Buffer for ans to write.
+  std::vector<uint8_t> buffer(bits_.size() + 16);
+  AnsCoder ans_coder;
+  ans_write_init(&ans_coder, buffer.data());
+
+  // Unfortunately we have to encode the bits in reversed order, while the
+  // probabilities that should be given are those of the forward sequence.
+  double p0_f = 0.5;
+  std::vector<uint8_t> p0s;
+  p0s.reserve(bits_.size());
+  for (bool b : bits_) {
+    p0s.push_back(clamp_probability(p0_f));
+    p0_f = update_probability(p0_f, b);
+  }
+  auto bit = bits_.rbegin();
+  auto pit = p0s.rbegin();
+  while (bit != bits_.rend()) {
+    rabs_write(&ans_coder, *bit, *pit);
+    ++bit;
+    ++pit;
+  }
+
+  const uint32_t size_in_bytes = ans_write_end(&ans_coder);
+  target_buffer->Encode(size_in_bytes);
+  target_buffer->Encode(buffer.data(), size_in_bytes);
+
+  Clear();
+}
+
+void AdaptiveRAnsBitEncoder::Clear() { bits_.clear(); }
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_encoder.h
new file mode 100644
index 000000000..9b1832844
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_encoder.h
@@ -0,0 +1,61 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides basic classes and functions for rANS bit encoding.
+#ifndef DRACO_COMPRESSION_BIT_CODERS_ADAPTIVE_RANS_BIT_ENCODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_ADAPTIVE_RANS_BIT_ENCODER_H_
+
+#include <vector>
+
+#include "draco/compression/entropy/ans.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// Class for adaptive encoding a sequence of bits using rANS.
+class AdaptiveRAnsBitEncoder {
+ public:
+  AdaptiveRAnsBitEncoder();
+  ~AdaptiveRAnsBitEncoder();
+
+  // Must be called before any Encode* function is called.
+  void StartEncoding();
+
+  // Encode one bit. If |bit| is true encode a 1, otherwise encode a 0.
+  void EncodeBit(bool bit) { bits_.push_back(bit); }
+
+  // Encode |nbits| of |value|, starting from the least significant bit.
+  // |nbits| must be > 0 and <= 32.
+  void EncodeLeastSignificantBits32(int nbits, uint32_t value) {
+    DRACO_DCHECK_EQ(true, nbits <= 32);
+    DRACO_DCHECK_EQ(true, nbits > 0);
+    uint32_t selector = (1 << (nbits - 1));
+    while (selector) {
+      EncodeBit(value & selector);
+      selector = selector >> 1;
+    }
+  }
+
+  // Ends the bit encoding and stores the result into the target_buffer.
+  void EndEncoding(EncoderBuffer *target_buffer);
+
+ private:
+  void Clear();
+
+  std::vector<bool> bits_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_ADAPTIVE_RANS_BIT_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/direct_bit_decoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/direct_bit_decoder.cc
new file mode 100644
index 000000000..2abe3382a
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/direct_bit_decoder.cc
@@ -0,0 +1,54 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/bit_coders/direct_bit_decoder.h"
+
+namespace draco {
+
+DirectBitDecoder::DirectBitDecoder() : pos_(bits_.end()), num_used_bits_(0) {}
+
+DirectBitDecoder::~DirectBitDecoder() { Clear(); }
+
+bool DirectBitDecoder::StartDecoding(DecoderBuffer *source_buffer) {
+  Clear();
+  uint32_t size_in_bytes;
+  if (!source_buffer->Decode(&size_in_bytes)) {
+    return false;
+  }
+
+  // Check that size_in_bytes is > 0 and a multiple of 4 as the encoder always
+  // encodes 32 bit elements.
+  if (size_in_bytes == 0 || size_in_bytes & 0x3) {
+    return false;
+  }
+  if (size_in_bytes > source_buffer->remaining_size()) {
+    return false;
+  }
+  const uint32_t num_32bit_elements = size_in_bytes / 4;
+  bits_.resize(num_32bit_elements);
+  if (!source_buffer->Decode(bits_.data(), size_in_bytes)) {
+    return false;
+  }
+  pos_ = bits_.begin();
+  num_used_bits_ = 0;
+  return true;
+}
+
+void DirectBitDecoder::Clear() {
+  bits_.clear();
+  num_used_bits_ = 0;
+  pos_ = bits_.end();
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/direct_bit_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/direct_bit_decoder.h
new file mode 100644
index 000000000..b9fbc2d6f
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/direct_bit_decoder.h
@@ -0,0 +1,90 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides direct encoding of bits with arithmetic encoder interface.
+#ifndef DRACO_COMPRESSION_BIT_CODERS_DIRECT_BIT_DECODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_DIRECT_BIT_DECODER_H_
+
+#include <vector>
+
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+
+class DirectBitDecoder {
+ public:
+  DirectBitDecoder();
+  ~DirectBitDecoder();
+
+  // Sets |source_buffer| as the buffer to decode bits from.
+  bool StartDecoding(DecoderBuffer *source_buffer);
+
+  // Decode one bit. Returns true if the bit is a 1, otherwise false.
+  bool DecodeNextBit() {
+    const uint32_t selector = 1 << (31 - num_used_bits_);
+    if (pos_ == bits_.end()) {
+      return false;
+    }
+    const bool bit = *pos_ & selector;
+    ++num_used_bits_;
+    if (num_used_bits_ == 32) {
+      ++pos_;
+      num_used_bits_ = 0;
+    }
+    return bit;
+  }
+
+  // Decode the next |nbits| and return the sequence in |value|. |nbits| must be
+  // > 0 and <= 32.
+  void DecodeLeastSignificantBits32(int nbits, uint32_t *value) {
+    DRACO_DCHECK_EQ(true, nbits <= 32);
+    DRACO_DCHECK_EQ(true, nbits > 0);
+    const int remaining = 32 - num_used_bits_;
+    if (nbits <= remaining) {
+      if (pos_ == bits_.end()) {
+        *value = 0;
+        return;
+      }
+      *value = (*pos_ << num_used_bits_) >> (32 - nbits);
+      num_used_bits_ += nbits;
+      if (num_used_bits_ == 32) {
+        ++pos_;
+        num_used_bits_ = 0;
+      }
+    } else {
+      if (pos_ + 1 == bits_.end()) {
+        *value = 0;
+        return;
+      }
+      const uint32_t value_l = ((*pos_) << num_used_bits_);
+      num_used_bits_ = nbits - remaining;
+      ++pos_;
+      const uint32_t value_r = (*pos_) >> (32 - num_used_bits_);
+      *value = (value_l >> (32 - num_used_bits_ - remaining)) | value_r;
+    }
+  }
+
+  void EndDecoding() {}
+
+ private:
+  void Clear();
+
+  std::vector<uint32_t> bits_;
+  std::vector<uint32_t>::const_iterator pos_;
+  uint32_t num_used_bits_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_DIRECT_BIT_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/direct_bit_encoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/direct_bit_encoder.cc
new file mode 100644
index 000000000..d39143cf5
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/direct_bit_encoder.cc
@@ -0,0 +1,39 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/bit_coders/direct_bit_encoder.h"
+
+namespace draco {
+
+DirectBitEncoder::DirectBitEncoder() : local_bits_(0), num_local_bits_(0) {}
+
+DirectBitEncoder::~DirectBitEncoder() { Clear(); }
+
+void DirectBitEncoder::StartEncoding() { Clear(); }
+
+void DirectBitEncoder::EndEncoding(EncoderBuffer *target_buffer) {
+  bits_.push_back(local_bits_);
+  const uint32_t size_in_byte = static_cast<uint32_t>(bits_.size()) * 4;
+  target_buffer->Encode(size_in_byte);
+  target_buffer->Encode(bits_.data(), size_in_byte);
+  Clear();
+}
+
+void DirectBitEncoder::Clear() {
+  bits_.clear();
+  local_bits_ = 0;
+  num_local_bits_ = 0;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/direct_bit_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/direct_bit_encoder.h
new file mode 100644
index 000000000..705b2ca93
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/direct_bit_encoder.h
@@ -0,0 +1,89 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides direct encoding of bits with arithmetic encoder interface.
+#ifndef DRACO_COMPRESSION_BIT_CODERS_DIRECT_BIT_ENCODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_DIRECT_BIT_ENCODER_H_
+
+#include <vector>
+
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+class DirectBitEncoder {
+ public:
+  DirectBitEncoder();
+  ~DirectBitEncoder();
+
+  // Must be called before any Encode* function is called.
+  void StartEncoding();
+
+  // Encode one bit. If |bit| is true encode a 1, otherwise encode a 0.
+  void EncodeBit(bool bit) {
+    if (bit) {
+      local_bits_ |= 1 << (31 - num_local_bits_);
+    }
+    num_local_bits_++;
+    if (num_local_bits_ == 32) {
+      bits_.push_back(local_bits_);
+      num_local_bits_ = 0;
+      local_bits_ = 0;
+    }
+  }
+
+  // Encode |nbits| of |value|, starting from the least significant bit.
+  // |nbits| must be > 0 and <= 32.
+  void EncodeLeastSignificantBits32(int nbits, uint32_t value) {
+    DRACO_DCHECK_EQ(true, nbits <= 32);
+    DRACO_DCHECK_EQ(true, nbits > 0);
+
+    const int remaining = 32 - num_local_bits_;
+
+    // Make sure there are no leading bits that should not be encoded and
+    // start from here.
+    value = value << (32 - nbits);
+    if (nbits <= remaining) {
+      value = value >> num_local_bits_;
+      local_bits_ = local_bits_ | value;
+      num_local_bits_ += nbits;
+      if (num_local_bits_ == 32) {
+        bits_.push_back(local_bits_);
+        local_bits_ = 0;
+        num_local_bits_ = 0;
+      }
+    } else {
+      value = value >> (32 - nbits);
+      num_local_bits_ = nbits - remaining;
+      const uint32_t value_l = value >> num_local_bits_;
+      local_bits_ = local_bits_ | value_l;
+      bits_.push_back(local_bits_);
+      local_bits_ = value << (32 - num_local_bits_);
+    }
+  }
+
+  // Ends the bit encoding and stores the result into the target_buffer.
+  void EndEncoding(EncoderBuffer *target_buffer);
+
+ private:
+  void Clear();
+
+  std::vector<uint32_t> bits_;
+  uint32_t local_bits_;
+  uint32_t num_local_bits_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_DIRECT_BIT_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/folded_integer_bit_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/folded_integer_bit_decoder.h
new file mode 100644
index 000000000..c14058b65
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/folded_integer_bit_decoder.h
@@ -0,0 +1,77 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides direct encoding of bits with arithmetic encoder interface.
+#ifndef DRACO_COMPRESSION_BIT_CODERS_FOLDED_INTEGER_BIT_DECODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_FOLDED_INTEGER_BIT_DECODER_H_
+
+#include <vector>
+
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+
+// See FoldedBit32Encoder for more details.
+template <class BitDecoderT>
+class FoldedBit32Decoder {
+ public:
+  FoldedBit32Decoder() {}
+  ~FoldedBit32Decoder() {}
+
+  // Sets |source_buffer| as the buffer to decode bits from.
+  bool StartDecoding(DecoderBuffer *source_buffer) {
+    for (int i = 0; i < 32; i++) {
+      if (!folded_number_decoders_[i].StartDecoding(source_buffer)) {
+        return false;
+      }
+    }
+    return bit_decoder_.StartDecoding(source_buffer);
+  }
+
+  // Decode one bit. Returns true if the bit is a 1, otherwise false.
+  bool DecodeNextBit() { return bit_decoder_.DecodeNextBit(); }
+
+  // Decode the next |nbits| and return the sequence in |value|. |nbits| must be
+  // > 0 and <= 32.
+  void DecodeLeastSignificantBits32(int nbits, uint32_t *value) {
+    uint32_t result = 0;
+    for (int i = 0; i < nbits; ++i) {
+      const bool bit = folded_number_decoders_[i].DecodeNextBit();
+      result = (result << 1) + bit;
+    }
+    *value = result;
+  }
+
+  void EndDecoding() {
+    for (int i = 0; i < 32; i++) {
+      folded_number_decoders_[i].EndDecoding();
+    }
+    bit_decoder_.EndDecoding();
+  }
+
+ private:
+  void Clear() {
+    for (int i = 0; i < 32; i++) {
+      folded_number_decoders_[i].Clear();
+    }
+    bit_decoder_.Clear();
+  }
+
+  std::array<BitDecoderT, 32> folded_number_decoders_;
+  BitDecoderT bit_decoder_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_FOLDED_INTEGER_BIT_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/folded_integer_bit_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/folded_integer_bit_encoder.h
new file mode 100644
index 000000000..375b38a61
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/folded_integer_bit_encoder.h
@@ -0,0 +1,82 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides direct encoding of bits with arithmetic encoder interface.
+#ifndef DRACO_COMPRESSION_BIT_CODERS_FOLDED_INTEGER_BIT_ENCODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_FOLDED_INTEGER_BIT_ENCODER_H_
+
+#include <vector>
+
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// This coding scheme considers every bit of an (up to) 32bit integer as a
+// separate context. This can be a significant advantage when encoding numbers
+// where it is more likely that the front bits are zero.
+// The behavior is essentially the same as other arithmetic encoding schemes,
+// the only difference is that encoding and decoding of bits must be absolutely
+// symmetric, bits handed in by EncodeBit32 must be also decoded in this way.
+// This is the FoldedBit32Encoder, see also FoldedBit32Decoder.
+template <class BitEncoderT>
+class FoldedBit32Encoder {
+ public:
+  FoldedBit32Encoder() {}
+  ~FoldedBit32Encoder() {}
+
+  // Must be called before any Encode* function is called.
+  void StartEncoding() {
+    for (int i = 0; i < 32; i++) {
+      folded_number_encoders_[i].StartEncoding();
+    }
+    bit_encoder_.StartEncoding();
+  }
+
+  // Encode one bit. If |bit| is true encode a 1, otherwise encode a 0.
+  void EncodeBit(bool bit) { bit_encoder_.EncodeBit(bit); }
+
+  // Encode |nbits| of |value|, starting from the least significant bit.
+  // |nbits| must be > 0 and <= 32.
+  void EncodeLeastSignificantBits32(int nbits, uint32_t value) {
+    uint32_t selector = 1 << (nbits - 1);
+    for (int i = 0; i < nbits; i++) {
+      const bool bit = (value & selector);
+      folded_number_encoders_[i].EncodeBit(bit);
+      selector = selector >> 1;
+    }
+  }
+
+  // Ends the bit encoding and stores the result into the target_buffer.
+  void EndEncoding(EncoderBuffer *target_buffer) {
+    for (int i = 0; i < 32; i++) {
+      folded_number_encoders_[i].EndEncoding(target_buffer);
+    }
+    bit_encoder_.EndEncoding(target_buffer);
+  }
+
+ private:
+  void Clear() {
+    for (int i = 0; i < 32; i++) {
+      folded_number_encoders_[i].Clear();
+    }
+    bit_encoder_.Clear();
+  }
+
+  std::array<BitEncoderT, 32> folded_number_encoders_;
+  BitEncoderT bit_encoder_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_FOLDED_INTEGER_BIT_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/rans_bit_decoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/rans_bit_decoder.cc
new file mode 100644
index 000000000..a9b8fb9e9
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/rans_bit_decoder.cc
@@ -0,0 +1,82 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/bit_coders/rans_bit_decoder.h"
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/bit_utils.h"
+#include "draco/core/varint_decoding.h"
+
+namespace draco {
+
+RAnsBitDecoder::RAnsBitDecoder() : prob_zero_(0) {}
+
+RAnsBitDecoder::~RAnsBitDecoder() { Clear(); }
+
+bool RAnsBitDecoder::StartDecoding(DecoderBuffer *source_buffer) {
+  Clear();
+
+  if (!source_buffer->Decode(&prob_zero_)) {
+    return false;
+  }
+
+  uint32_t size_in_bytes;
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (source_buffer->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+    if (!source_buffer->Decode(&size_in_bytes)) {
+      return false;
+    }
+
+  } else
+#endif
+  {
+    if (!DecodeVarint(&size_in_bytes, source_buffer)) {
+      return false;
+    }
+  }
+
+  if (size_in_bytes > source_buffer->remaining_size()) {
+    return false;
+  }
+
+  if (ans_read_init(&ans_decoder_,
+                    reinterpret_cast<uint8_t *>(
+                        const_cast<char *>(source_buffer->data_head())),
+                    size_in_bytes) != 0) {
+    return false;
+  }
+  source_buffer->Advance(size_in_bytes);
+  return true;
+}
+
+bool RAnsBitDecoder::DecodeNextBit() {
+  const uint8_t bit = rabs_read(&ans_decoder_, prob_zero_);
+  return bit > 0;
+}
+
+void RAnsBitDecoder::DecodeLeastSignificantBits32(int nbits, uint32_t *value) {
+  DRACO_DCHECK_EQ(true, nbits <= 32);
+  DRACO_DCHECK_EQ(true, nbits > 0);
+
+  uint32_t result = 0;
+  while (nbits) {
+    result = (result << 1) + DecodeNextBit();
+    --nbits;
+  }
+  *value = result;
+}
+
+void RAnsBitDecoder::Clear() { ans_read_end(&ans_decoder_); }
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/rans_bit_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/rans_bit_decoder.h
new file mode 100644
index 000000000..25d243eac
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/rans_bit_decoder.h
@@ -0,0 +1,55 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides basic classes and functions for rANS coding.
+#ifndef DRACO_COMPRESSION_BIT_CODERS_RANS_BIT_DECODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_RANS_BIT_DECODER_H_
+
+#include <vector>
+
+#include "draco/compression/entropy/ans.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Class for decoding a sequence of bits that were encoded with RAnsBitEncoder.
+class RAnsBitDecoder {
+ public:
+  RAnsBitDecoder();
+  ~RAnsBitDecoder();
+
+  // Sets |source_buffer| as the buffer to decode bits from.
+  // Returns false when the data is invalid.
+  bool StartDecoding(DecoderBuffer *source_buffer);
+
+  // Decode one bit. Returns true if the bit is a 1, otherwise false.
+  bool DecodeNextBit();
+
+  // Decode the next |nbits| and return the sequence in |value|. |nbits| must be
+  // > 0 and <= 32.
+  void DecodeLeastSignificantBits32(int nbits, uint32_t *value);
+
+  void EndDecoding() {}
+
+ private:
+  void Clear();
+
+  AnsDecoder ans_decoder_;
+  uint8_t prob_zero_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_RANS_BIT_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/rans_bit_encoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/rans_bit_encoder.cc
new file mode 100644
index 000000000..8d00ea352
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/rans_bit_encoder.cc
@@ -0,0 +1,125 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/bit_coders/rans_bit_encoder.h"
+
+#include "draco/compression/entropy/ans.h"
+#include "draco/core/bit_utils.h"
+#include "draco/core/varint_encoding.h"
+
+namespace draco {
+
+RAnsBitEncoder::RAnsBitEncoder() : local_bits_(0), num_local_bits_(0) {}
+
+RAnsBitEncoder::~RAnsBitEncoder() { Clear(); }
+
+void RAnsBitEncoder::StartEncoding() { Clear(); }
+
+void RAnsBitEncoder::EncodeBit(bool bit) {
+  if (bit) {
+    bit_counts_[1]++;
+    local_bits_ |= 1 << num_local_bits_;
+  } else {
+    bit_counts_[0]++;
+  }
+  num_local_bits_++;
+
+  if (num_local_bits_ == 32) {
+    bits_.push_back(local_bits_);
+    num_local_bits_ = 0;
+    local_bits_ = 0;
+  }
+}
+
+void RAnsBitEncoder::EncodeLeastSignificantBits32(int nbits, uint32_t value) {
+  DRACO_DCHECK_EQ(true, nbits <= 32);
+  DRACO_DCHECK_EQ(true, nbits > 0);
+
+  const uint32_t reversed = ReverseBits32(value) >> (32 - nbits);
+  const int ones = CountOneBits32(reversed);
+  bit_counts_[0] += (nbits - ones);
+  bit_counts_[1] += ones;
+
+  const int remaining = 32 - num_local_bits_;
+
+  if (nbits <= remaining) {
+    CopyBits32(&local_bits_, num_local_bits_, reversed, 0, nbits);
+    num_local_bits_ += nbits;
+    if (num_local_bits_ == 32) {
+      bits_.push_back(local_bits_);
+      local_bits_ = 0;
+      num_local_bits_ = 0;
+    }
+  } else {
+    CopyBits32(&local_bits_, num_local_bits_, reversed, 0, remaining);
+    bits_.push_back(local_bits_);
+    local_bits_ = 0;
+    CopyBits32(&local_bits_, 0, reversed, remaining, nbits - remaining);
+    num_local_bits_ = nbits - remaining;
+  }
+}
+
+void RAnsBitEncoder::EndEncoding(EncoderBuffer *target_buffer) {
+  uint64_t total = bit_counts_[1] + bit_counts_[0];
+  if (total == 0) {
+    total++;
+  }
+
+  // The probability interval [0,1] is mapped to values of [0, 256]. However,
+  // the coding scheme can not deal with probabilities of 0 or 1, which is why
+  // we must clamp the values to interval [1, 255]. Specifically 128
+  // corresponds to 0.5 exactly. And the value can be given as uint8_t.
+  const uint32_t zero_prob_raw = static_cast<uint32_t>(
+      ((bit_counts_[0] / static_cast<double>(total)) * 256.0) + 0.5);
+
+  uint8_t zero_prob = 255;
+  if (zero_prob_raw < 255) {
+    zero_prob = static_cast<uint8_t>(zero_prob_raw);
+  }
+
+  zero_prob += (zero_prob == 0);
+
+  // Space for 32 bit integer and some extra space.
+  std::vector<uint8_t> buffer((bits_.size() + 8) * 8);
+  AnsCoder ans_coder;
+  ans_write_init(&ans_coder, buffer.data());
+
+  for (int i = num_local_bits_ - 1; i >= 0; --i) {
+    const uint8_t bit = (local_bits_ >> i) & 1;
+    rabs_write(&ans_coder, bit, zero_prob);
+  }
+  for (auto it = bits_.rbegin(); it != bits_.rend(); ++it) {
+    const uint32_t bits = *it;
+    for (int i = 31; i >= 0; --i) {
+      const uint8_t bit = (bits >> i) & 1;
+      rabs_write(&ans_coder, bit, zero_prob);
+    }
+  }
+
+  const int size_in_bytes = ans_write_end(&ans_coder);
+  target_buffer->Encode(zero_prob);
+  EncodeVarint(static_cast<uint32_t>(size_in_bytes), target_buffer);
+  target_buffer->Encode(buffer.data(), size_in_bytes);
+
+  Clear();
+}
+
+void RAnsBitEncoder::Clear() {
+  bit_counts_.assign(2, 0);
+  bits_.clear();
+  local_bits_ = 0;
+  num_local_bits_ = 0;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/rans_bit_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/rans_bit_encoder.h
new file mode 100644
index 000000000..1993dd3d3
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/rans_bit_encoder.h
@@ -0,0 +1,57 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides basic classes and functions for rANS coding.
+#ifndef DRACO_COMPRESSION_BIT_CODERS_RANS_BIT_ENCODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_RANS_BIT_ENCODER_H_
+
+#include <vector>
+
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// Class for encoding a sequence of bits using rANS. The probability table used
+// to encode the bits is based off the total counts of bits.
+// TODO(fgalligan): Investigate using an adaptive table for more compression.
+class RAnsBitEncoder {
+ public:
+  RAnsBitEncoder();
+  ~RAnsBitEncoder();
+
+  // Must be called before any Encode* function is called.
+  void StartEncoding();
+
+  // Encode one bit. If |bit| is true encode a 1, otherwise encode a 0.
+  void EncodeBit(bool bit);
+
+  // Encode |nbits| of |value|, starting from the least significant bit.
+  // |nbits| must be > 0 and <= 32.
+  void EncodeLeastSignificantBits32(int nbits, uint32_t value);
+
+  // Ends the bit encoding and stores the result into the target_buffer.
+  void EndEncoding(EncoderBuffer *target_buffer);
+
+ private:
+  void Clear();
+
+  std::vector<uint64_t> bit_counts_;
+  std::vector<uint32_t> bits_;
+  uint32_t local_bits_;
+  uint32_t num_local_bits_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_RANS_BIT_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/rans_coding_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/rans_coding_test.cc
new file mode 100644
index 000000000..9509ad9f3
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/rans_coding_test.cc
@@ -0,0 +1,9 @@
+#include "draco/compression/bit_coders/adaptive_rans_bit_decoder.h"
+#include "draco/compression/bit_coders/adaptive_rans_bit_encoder.h"
+#include "draco/compression/bit_coders/rans_bit_decoder.h"
+#include "draco/compression/bit_coders/rans_bit_encoder.h"
+#include "draco/core/draco_test_base.h"
+
+// Just including rans_coding.h and adaptive_rans_coding.h gets an asan error
+// when compiling (blaze test :rans_coding_test --config=asan)
+TEST(RansCodingTest, LinkerTest) {}
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/symbol_bit_decoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/symbol_bit_decoder.cc
new file mode 100644
index 000000000..8ed50ef92
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/symbol_bit_decoder.cc
@@ -0,0 +1,49 @@
+#include "draco/compression/bit_coders/symbol_bit_decoder.h"
+
+#include "draco/compression/entropy/symbol_decoding.h"
+
+namespace draco {
+
+bool SymbolBitDecoder::StartDecoding(DecoderBuffer *source_buffer) {
+  uint32_t size;
+  if (!source_buffer->Decode(&size)) {
+    return false;
+  }
+
+  symbols_.resize(size);
+  if (!DecodeSymbols(size, 1, source_buffer, symbols_.data())) {
+    return false;
+  }
+  std::reverse(symbols_.begin(), symbols_.end());
+  return true;
+}
+
+bool SymbolBitDecoder::DecodeNextBit() {
+  uint32_t symbol;
+  DecodeLeastSignificantBits32(1, &symbol);
+  DRACO_DCHECK(symbol == 0 || symbol == 1);
+  return symbol == 1;
+}
+
+void SymbolBitDecoder::DecodeLeastSignificantBits32(int nbits,
+                                                    uint32_t *value) {
+  DRACO_DCHECK_LE(1, nbits);
+  DRACO_DCHECK_LE(nbits, 32);
+  DRACO_DCHECK_NE(value, nullptr);
+  // Testing: check to make sure there is something to decode.
+  DRACO_DCHECK_GT(symbols_.size(), 0);
+
+  (*value) = symbols_.back();
+  symbols_.pop_back();
+
+  const int discarded_bits = 32 - nbits;
+  (*value) <<= discarded_bits;
+  (*value) >>= discarded_bits;
+}
+
+void SymbolBitDecoder::Clear() {
+  symbols_.clear();
+  symbols_.shrink_to_fit();
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/symbol_bit_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/symbol_bit_decoder.h
new file mode 100644
index 000000000..909d7174f
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/symbol_bit_decoder.h
@@ -0,0 +1,36 @@
+#ifndef DRACO_COMPRESSION_BIT_CODERS_SYMBOL_BIT_DECODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_SYMBOL_BIT_DECODER_H_
+
+#include <algorithm>
+#include <vector>
+
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+
+// Class for decoding bits using the symbol entropy encoding. Wraps
+// |DecodeSymbols|. Note that this uses a symbol-based encoding scheme for
+// encoding bits.
+class SymbolBitDecoder {
+ public:
+  // Sets |source_buffer| as the buffer to decode bits from.
+  bool StartDecoding(DecoderBuffer *source_buffer);
+
+  // Decode one bit. Returns true if the bit is a 1, otherwise false.
+  bool DecodeNextBit();
+
+  // Decode the next |nbits| and return the sequence in |value|. |nbits| must be
+  // > 0 and <= 32.
+  void DecodeLeastSignificantBits32(int nbits, uint32_t *value);
+
+  void EndDecoding() { Clear(); }
+
+ private:
+  void Clear();
+
+  std::vector<uint32_t> symbols_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_SYMBOL_BIT_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/symbol_bit_encoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/symbol_bit_encoder.cc
new file mode 100644
index 000000000..83834236f
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/symbol_bit_encoder.cc
@@ -0,0 +1,30 @@
+#include "draco/compression/bit_coders/symbol_bit_encoder.h"
+
+#include "draco/compression/entropy/symbol_encoding.h"
+
+namespace draco {
+
+void SymbolBitEncoder::EncodeLeastSignificantBits32(int nbits, uint32_t value) {
+  DRACO_DCHECK_LE(1, nbits);
+  DRACO_DCHECK_LE(nbits, 32);
+
+  const int discarded_bits = 32 - nbits;
+  value <<= discarded_bits;
+  value >>= discarded_bits;
+
+  symbols_.push_back(value);
+}
+
+void SymbolBitEncoder::EndEncoding(EncoderBuffer *target_buffer) {
+  target_buffer->Encode(static_cast<uint32_t>(symbols_.size()));
+  EncodeSymbols(symbols_.data(), static_cast<int>(symbols_.size()), 1, nullptr,
+                target_buffer);
+  Clear();
+}
+
+void SymbolBitEncoder::Clear() {
+  symbols_.clear();
+  symbols_.shrink_to_fit();
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/symbol_bit_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/symbol_bit_encoder.h
new file mode 100644
index 000000000..7f1570c1a
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/bit_coders/symbol_bit_encoder.h
@@ -0,0 +1,36 @@
+#ifndef DRACO_COMPRESSION_BIT_CODERS_SYMBOL_BIT_ENCODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_SYMBOL_BIT_ENCODER_H_
+
+#include <algorithm>
+#include <vector>
+
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// Class for encoding bits using the symbol entropy encoding. Wraps
+// |EncodeSymbols|. Note that this uses a symbol-based encoding scheme for
+// encoding bits.
+class SymbolBitEncoder {
+ public:
+  // Must be called before any Encode* function is called.
+  void StartEncoding() { Clear(); }
+
+  // Encode one bit. If |bit| is true encode a 1, otherwise encode a 0.
+  void EncodeBit(bool bit) { EncodeLeastSignificantBits32(1, bit ? 1 : 0); }
+
+  // Encode |nbits| LSBs of |value| as a symbol. |nbits| must be > 0 and <= 32.
+  void EncodeLeastSignificantBits32(int nbits, uint32_t value);
+
+  // Ends the bit encoding and stores the result into the target_buffer.
+  void EndEncoding(EncoderBuffer *target_buffer);
+
+ private:
+  void Clear();
+
+  std::vector<uint32_t> symbols_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_SYMBOL_BIT_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/config/compression_shared.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/config/compression_shared.h
new file mode 100644
index 000000000..c43f303bd
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/config/compression_shared.h
@@ -0,0 +1,155 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_CONFIG_COMPRESSION_SHARED_H_
+#define DRACO_COMPRESSION_CONFIG_COMPRESSION_SHARED_H_
+
+#include <stdint.h>
+
+#include "draco/core/macros.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Latest Draco bit-stream version.
+static constexpr uint8_t kDracoPointCloudBitstreamVersionMajor = 2;
+static constexpr uint8_t kDracoPointCloudBitstreamVersionMinor = 3;
+static constexpr uint8_t kDracoMeshBitstreamVersionMajor = 2;
+static constexpr uint8_t kDracoMeshBitstreamVersionMinor = 2;
+
+// Concatenated latest bit-stream version.
+static constexpr uint16_t kDracoPointCloudBitstreamVersion =
+    DRACO_BITSTREAM_VERSION(kDracoPointCloudBitstreamVersionMajor,
+                            kDracoPointCloudBitstreamVersionMinor);
+
+static constexpr uint16_t kDracoMeshBitstreamVersion = DRACO_BITSTREAM_VERSION(
+    kDracoMeshBitstreamVersionMajor, kDracoMeshBitstreamVersionMinor);
+
+// Currently, we support point cloud and triangular mesh encoding.
+// TODO(draco-eng) Convert enum to enum class (safety, not performance).
+enum EncodedGeometryType {
+  INVALID_GEOMETRY_TYPE = -1,
+  POINT_CLOUD = 0,
+  TRIANGULAR_MESH,
+  NUM_ENCODED_GEOMETRY_TYPES
+};
+
+// List of encoding methods for point clouds.
+enum PointCloudEncodingMethod {
+  POINT_CLOUD_SEQUENTIAL_ENCODING = 0,
+  POINT_CLOUD_KD_TREE_ENCODING
+};
+
+// List of encoding methods for meshes.
+enum MeshEncoderMethod {
+  MESH_SEQUENTIAL_ENCODING = 0,
+  MESH_EDGEBREAKER_ENCODING,
+};
+
+// List of various attribute encoders supported by our framework. The entries
+// are used as unique identifiers of the encoders and their values should not
+// be changed!
+enum AttributeEncoderType {
+  BASIC_ATTRIBUTE_ENCODER = 0,
+  MESH_TRAVERSAL_ATTRIBUTE_ENCODER,
+  KD_TREE_ATTRIBUTE_ENCODER,
+};
+
+// List of various sequential attribute encoder/decoders that can be used in our
+// pipeline. The values represent unique identifiers used by the decoder and
+// they should not be changed.
+enum SequentialAttributeEncoderType {
+  SEQUENTIAL_ATTRIBUTE_ENCODER_GENERIC = 0,
+  SEQUENTIAL_ATTRIBUTE_ENCODER_INTEGER,
+  SEQUENTIAL_ATTRIBUTE_ENCODER_QUANTIZATION,
+  SEQUENTIAL_ATTRIBUTE_ENCODER_NORMALS,
+};
+
+// List of all prediction methods currently supported by our framework.
+enum PredictionSchemeMethod {
+  // Special value indicating that no prediction scheme was used.
+  PREDICTION_NONE = -2,
+  // Used when no specific prediction scheme is required.
+  PREDICTION_UNDEFINED = -1,
+  PREDICTION_DIFFERENCE = 0,
+  MESH_PREDICTION_PARALLELOGRAM = 1,
+  MESH_PREDICTION_MULTI_PARALLELOGRAM = 2,
+  MESH_PREDICTION_TEX_COORDS_DEPRECATED = 3,
+  MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM = 4,
+  MESH_PREDICTION_TEX_COORDS_PORTABLE = 5,
+  MESH_PREDICTION_GEOMETRIC_NORMAL = 6,
+  NUM_PREDICTION_SCHEMES
+};
+
+// List of all prediction scheme transforms used by our framework.
+enum PredictionSchemeTransformType {
+  PREDICTION_TRANSFORM_NONE = -1,
+  // Basic delta transform where the prediction is computed as difference the
+  // predicted and original value.
+  PREDICTION_TRANSFORM_DELTA = 0,
+  // An improved delta transform where all computed delta values are wrapped
+  // around a fixed interval which lowers the entropy.
+  PREDICTION_TRANSFORM_WRAP = 1,
+  // Specialized transform for normal coordinates using inverted tiles.
+  PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON = 2,
+  // Specialized transform for normal coordinates using canonicalized inverted
+  // tiles.
+  PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON_CANONICALIZED = 3,
+  // The number of valid (non-negative) prediction scheme transform types.
+  NUM_PREDICTION_SCHEME_TRANSFORM_TYPES
+};
+
+// List of all mesh traversal methods supported by Draco framework.
+enum MeshTraversalMethod {
+  MESH_TRAVERSAL_DEPTH_FIRST = 0,
+  MESH_TRAVERSAL_PREDICTION_DEGREE = 1,
+  NUM_TRAVERSAL_METHODS
+};
+
+// List of all variant of the edgebreaker method that is used for compression
+// of mesh connectivity.
+enum MeshEdgebreakerConnectivityEncodingMethod {
+  MESH_EDGEBREAKER_STANDARD_ENCODING = 0,
+  MESH_EDGEBREAKER_PREDICTIVE_ENCODING = 1,  // Deprecated.
+  MESH_EDGEBREAKER_VALENCE_ENCODING = 2,
+};
+
+// Draco header V1
+struct DracoHeader {
+  int8_t draco_string[5];
+  uint8_t version_major;
+  uint8_t version_minor;
+  uint8_t encoder_type;
+  uint8_t encoder_method;
+  uint16_t flags;
+};
+
+enum NormalPredictionMode {
+  ONE_TRIANGLE = 0,  // To be deprecated.
+  TRIANGLE_AREA = 1,
+};
+
+// Different methods used for symbol entropy encoding.
+enum SymbolCodingMethod {
+  SYMBOL_CODING_TAGGED = 0,
+  SYMBOL_CODING_RAW = 1,
+  NUM_SYMBOL_CODING_METHODS,
+};
+
+// Mask for setting and getting the bit for metadata in |flags| of header.
+#define METADATA_FLAG_MASK 0x8000
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_CONFIG_COMPRESSION_SHARED_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/config/decoder_options.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/config/decoder_options.h
new file mode 100644
index 000000000..3b3889993
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/config/decoder_options.h
@@ -0,0 +1,34 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_CONFIG_DECODER_OPTIONS_H_
+#define DRACO_COMPRESSION_CONFIG_DECODER_OPTIONS_H_
+
+#include <map>
+#include <memory>
+
+#include "draco/attributes/geometry_attribute.h"
+#include "draco/compression/config/draco_options.h"
+
+namespace draco {
+
+// Class containing options that can be passed to PointCloudDecoder to control
+// decoding of the input geometry. The options can be specified either for the
+// whole geometry or for a specific attribute type. Each option is identified
+// by a unique name stored as an std::string.
+typedef DracoOptions<GeometryAttribute::Type> DecoderOptions;
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_CONFIG_DECODER_OPTIONS_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/config/decoder_options_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/config/decoder_options_test.cc
new file mode 100644
index 000000000..a5cd7f106
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/config/decoder_options_test.cc
@@ -0,0 +1,67 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/config/decoder_options.h"
+
+#include "draco/core/draco_test_base.h"
+
+namespace {
+
+class DecoderOptionsTest : public ::testing::Test {
+ protected:
+  DecoderOptionsTest() {}
+};
+
+TEST_F(DecoderOptionsTest, TestOptions) {
+  // This test verifies that we can update global and attribute options of the
+  // DecoderOptions class instance.
+  draco::DecoderOptions options;
+  options.SetGlobalInt("test", 3);
+  ASSERT_EQ(options.GetGlobalInt("test", -1), 3);
+
+  options.SetAttributeInt(draco::GeometryAttribute::POSITION, "test", 1);
+  options.SetAttributeInt(draco::GeometryAttribute::GENERIC, "test", 2);
+  ASSERT_EQ(
+      options.GetAttributeInt(draco::GeometryAttribute::TEX_COORD, "test", -1),
+      3);
+  ASSERT_EQ(
+      options.GetAttributeInt(draco::GeometryAttribute::POSITION, "test", -1),
+      1);
+  ASSERT_EQ(
+      options.GetAttributeInt(draco::GeometryAttribute::GENERIC, "test", -1),
+      2);
+}
+
+TEST_F(DecoderOptionsTest, TestAttributeOptionsAccessors) {
+  // This test verifies that we can query options stored in DecoderOptions
+  // class instance.
+  draco::DecoderOptions options;
+  options.SetGlobalInt("test", 1);
+  options.SetAttributeInt(draco::GeometryAttribute::POSITION, "test", 2);
+  options.SetAttributeInt(draco::GeometryAttribute::TEX_COORD, "test", 3);
+
+  ASSERT_EQ(
+      options.GetAttributeInt(draco::GeometryAttribute::POSITION, "test", -1),
+      2);
+  ASSERT_EQ(
+      options.GetAttributeInt(draco::GeometryAttribute::POSITION, "test2", -1),
+      -1);
+  ASSERT_EQ(
+      options.GetAttributeInt(draco::GeometryAttribute::TEX_COORD, "test", -1),
+      3);
+  ASSERT_EQ(
+      options.GetAttributeInt(draco::GeometryAttribute::NORMAL, "test", -1), 1);
+}
+
+}  // namespace
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/config/draco_options.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/config/draco_options.h
new file mode 100644
index 000000000..2bd4a3b67
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/config/draco_options.h
@@ -0,0 +1,249 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_CONFIG_DRACO_OPTIONS_H_
+#define DRACO_COMPRESSION_CONFIG_DRACO_OPTIONS_H_
+
+#include <map>
+#include <memory>
+
+#include "draco/core/options.h"
+
+namespace draco {
+
+// Base option class used to control encoding and decoding. The geometry coding
+// can be controlled through the following options:
+//   1. Global options - Options specific to overall geometry or options common
+//                       for all attributes
+//   2. Per attribute options - Options specific to a given attribute.
+//                              Each attribute is identified by the template
+//                              argument AttributeKeyT that can be for example
+//                              the attribute type or the attribute id.
+//
+// Example:
+//
+//   DracoOptions<AttributeKey> options;
+//
+//   // Set an option common for all attributes.
+//   options.SetGlobalInt("some_option_name", 2);
+//
+//   // Geometry with two attributes.
+//   AttributeKey att_key0 = in_key0;
+//   AttributeKey att_key1 = in_key1;
+//
+//   options.SetAttributeInt(att_key0, "some_option_name", 3);
+//
+//   options.GetAttributeInt(att_key0, "some_option_name");  // Returns 3
+//   options.GetAttributeInt(att_key1, "some_option_name");  // Returns 2
+//   options.GetGlobalInt("some_option_name");               // Returns 2
+//
+template <typename AttributeKeyT>
+class DracoOptions {
+ public:
+  typedef AttributeKeyT AttributeKey;
+
+  // Get an option for a specific attribute key. If the option is not found in
+  // an attribute specific storage, the implementation will return a global
+  // option of the given name (if available). If the option is not found, the
+  // provided default value |default_val| is returned instead.
+  int GetAttributeInt(const AttributeKey &att_key, const std::string &name,
+                      int default_val) const;
+
+  // Sets an option for a specific attribute key.
+  void SetAttributeInt(const AttributeKey &att_key, const std::string &name,
+                       int val);
+
+  float GetAttributeFloat(const AttributeKey &att_key, const std::string &name,
+                          float default_val) const;
+  void SetAttributeFloat(const AttributeKey &att_key, const std::string &name,
+                         float val);
+  bool GetAttributeBool(const AttributeKey &att_key, const std::string &name,
+                        bool default_val) const;
+  void SetAttributeBool(const AttributeKey &att_key, const std::string &name,
+                        bool val);
+  template <typename DataTypeT>
+  bool GetAttributeVector(const AttributeKey &att_key, const std::string &name,
+                          int num_dims, DataTypeT *val) const;
+  template <typename DataTypeT>
+  void SetAttributeVector(const AttributeKey &att_key, const std::string &name,
+                          int num_dims, const DataTypeT *val);
+
+  bool IsAttributeOptionSet(const AttributeKey &att_key,
+                            const std::string &name) const;
+
+  // Gets/sets a global option that is not specific to any attribute.
+  int GetGlobalInt(const std::string &name, int default_val) const {
+    return global_options_.GetInt(name, default_val);
+  }
+  void SetGlobalInt(const std::string &name, int val) {
+    global_options_.SetInt(name, val);
+  }
+  float GetGlobalFloat(const std::string &name, float default_val) const {
+    return global_options_.GetFloat(name, default_val);
+  }
+  void SetGlobalFloat(const std::string &name, float val) {
+    global_options_.SetFloat(name, val);
+  }
+  bool GetGlobalBool(const std::string &name, bool default_val) const {
+    return global_options_.GetBool(name, default_val);
+  }
+  void SetGlobalBool(const std::string &name, bool val) {
+    global_options_.SetBool(name, val);
+  }
+  template <typename DataTypeT>
+  bool GetGlobalVector(const std::string &name, int num_dims,
+                       DataTypeT *val) const {
+    return global_options_.GetVector(name, num_dims, val);
+  }
+  template <typename DataTypeT>
+  void SetGlobalVector(const std::string &name, int num_dims,
+                       const DataTypeT *val) {
+    global_options_.SetVector(name, val, num_dims);
+  }
+  bool IsGlobalOptionSet(const std::string &name) const {
+    return global_options_.IsOptionSet(name);
+  }
+
+  // Sets or replaces attribute options with the provided |options|.
+  void SetAttributeOptions(const AttributeKey &att_key, const Options &options);
+  void SetGlobalOptions(const Options &options) { global_options_ = options; }
+
+  // Returns |Options| instance for the specified options class if it exists.
+  const Options *FindAttributeOptions(const AttributeKeyT &att_key) const;
+  const Options &GetGlobalOptions() const { return global_options_; }
+
+ private:
+  Options *GetAttributeOptions(const AttributeKeyT &att_key);
+
+  Options global_options_;
+
+  // Storage for options related to geometry attributes.
+  std::map<AttributeKey, Options> attribute_options_;
+};
+
+template <typename AttributeKeyT>
+const Options *DracoOptions<AttributeKeyT>::FindAttributeOptions(
+    const AttributeKeyT &att_key) const {
+  auto it = attribute_options_.find(att_key);
+  if (it == attribute_options_.end()) {
+    return nullptr;
+  }
+  return &it->second;
+}
+
+template <typename AttributeKeyT>
+Options *DracoOptions<AttributeKeyT>::GetAttributeOptions(
+    const AttributeKeyT &att_key) {
+  auto it = attribute_options_.find(att_key);
+  if (it != attribute_options_.end()) {
+    return &it->second;
+  }
+  Options new_options;
+  it = attribute_options_.insert(std::make_pair(att_key, new_options)).first;
+  return &it->second;
+}
+
+template <typename AttributeKeyT>
+int DracoOptions<AttributeKeyT>::GetAttributeInt(const AttributeKeyT &att_key,
+                                                 const std::string &name,
+                                                 int default_val) const {
+  const Options *const att_options = FindAttributeOptions(att_key);
+  if (att_options && att_options->IsOptionSet(name)) {
+    return att_options->GetInt(name, default_val);
+  }
+  return global_options_.GetInt(name, default_val);
+}
+
+template <typename AttributeKeyT>
+void DracoOptions<AttributeKeyT>::SetAttributeInt(const AttributeKeyT &att_key,
+                                                  const std::string &name,
+                                                  int val) {
+  GetAttributeOptions(att_key)->SetInt(name, val);
+}
+
+template <typename AttributeKeyT>
+float DracoOptions<AttributeKeyT>::GetAttributeFloat(
+    const AttributeKeyT &att_key, const std::string &name,
+    float default_val) const {
+  const Options *const att_options = FindAttributeOptions(att_key);
+  if (att_options && att_options->IsOptionSet(name)) {
+    return att_options->GetFloat(name, default_val);
+  }
+  return global_options_.GetFloat(name, default_val);
+}
+
+template <typename AttributeKeyT>
+void DracoOptions<AttributeKeyT>::SetAttributeFloat(
+    const AttributeKeyT &att_key, const std::string &name, float val) {
+  GetAttributeOptions(att_key)->SetFloat(name, val);
+}
+
+template <typename AttributeKeyT>
+bool DracoOptions<AttributeKeyT>::GetAttributeBool(const AttributeKeyT &att_key,
+                                                   const std::string &name,
+                                                   bool default_val) const {
+  const Options *const att_options = FindAttributeOptions(att_key);
+  if (att_options && att_options->IsOptionSet(name)) {
+    return att_options->GetBool(name, default_val);
+  }
+  return global_options_.GetBool(name, default_val);
+}
+
+template <typename AttributeKeyT>
+void DracoOptions<AttributeKeyT>::SetAttributeBool(const AttributeKeyT &att_key,
+                                                   const std::string &name,
+                                                   bool val) {
+  GetAttributeOptions(att_key)->SetBool(name, val);
+}
+
+template <typename AttributeKeyT>
+template <typename DataTypeT>
+bool DracoOptions<AttributeKeyT>::GetAttributeVector(
+    const AttributeKey &att_key, const std::string &name, int num_dims,
+    DataTypeT *val) const {
+  const Options *const att_options = FindAttributeOptions(att_key);
+  if (att_options && att_options->IsOptionSet(name)) {
+    return att_options->GetVector(name, num_dims, val);
+  }
+  return global_options_.GetVector(name, num_dims, val);
+}
+
+template <typename AttributeKeyT>
+template <typename DataTypeT>
+void DracoOptions<AttributeKeyT>::SetAttributeVector(
+    const AttributeKey &att_key, const std::string &name, int num_dims,
+    const DataTypeT *val) {
+  GetAttributeOptions(att_key)->SetVector(name, val, num_dims);
+}
+
+template <typename AttributeKeyT>
+bool DracoOptions<AttributeKeyT>::IsAttributeOptionSet(
+    const AttributeKey &att_key, const std::string &name) const {
+  const Options *const att_options = FindAttributeOptions(att_key);
+  if (att_options) {
+    return att_options->IsOptionSet(name);
+  }
+  return global_options_.IsOptionSet(name);
+}
+
+template <typename AttributeKeyT>
+void DracoOptions<AttributeKeyT>::SetAttributeOptions(
+    const AttributeKey &att_key, const Options &options) {
+  Options *att_options = GetAttributeOptions(att_key);
+  *att_options = options;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_CONFIG_DRACO_OPTIONS_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/config/encoder_options.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/config/encoder_options.h
new file mode 100644
index 000000000..ed1b02068
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/config/encoder_options.h
@@ -0,0 +1,97 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_CONFIG_ENCODER_OPTIONS_H_
+#define DRACO_COMPRESSION_CONFIG_ENCODER_OPTIONS_H_
+
+#include "draco/attributes/geometry_attribute.h"
+#include "draco/compression/config/draco_options.h"
+#include "draco/compression/config/encoding_features.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// EncoderOptions allow users to specify so called feature options that are used
+// to inform the encoder which encoding features can be used (i.e. which
+// features are going to be available to the decoder).
+template <typename AttributeKeyT>
+class EncoderOptionsBase : public DracoOptions<AttributeKeyT> {
+ public:
+  static EncoderOptionsBase CreateDefaultOptions() {
+    EncoderOptionsBase options;
+#ifdef DRACO_STANDARD_EDGEBREAKER_SUPPORTED
+    options.SetSupportedFeature(features::kEdgebreaker, true);
+#endif
+#ifdef DRACO_PREDICTIVE_EDGEBREAKER_SUPPORTED
+    options.SetSupportedFeature(features::kPredictiveEdgebreaker, true);
+#endif
+    return options;
+  }
+  static EncoderOptionsBase CreateEmptyOptions() {
+    return EncoderOptionsBase();
+  }
+
+  // Returns speed options with default value of 5.
+  int GetEncodingSpeed() const {
+    return this->GetGlobalInt("encoding_speed", 5);
+  }
+  int GetDecodingSpeed() const {
+    return this->GetGlobalInt("decoding_speed", 5);
+  }
+
+  // Returns the maximum speed for both encoding/decoding.
+  int GetSpeed() const {
+    const int encoding_speed = this->GetGlobalInt("encoding_speed", -1);
+    const int decoding_speed = this->GetGlobalInt("decoding_speed", -1);
+    const int max_speed = std::max(encoding_speed, decoding_speed);
+    if (max_speed == -1) {
+      return 5;  // Default value.
+    }
+    return max_speed;
+  }
+
+  void SetSpeed(int encoding_speed, int decoding_speed) {
+    this->SetGlobalInt("encoding_speed", encoding_speed);
+    this->SetGlobalInt("decoding_speed", decoding_speed);
+  }
+
+  // Sets a given feature as supported or unsupported by the target decoder.
+  // Encoder will always use only supported features when encoding the input
+  // geometry.
+  void SetSupportedFeature(const std::string &name, bool supported) {
+    feature_options_.SetBool(name, supported);
+  }
+  bool IsFeatureSupported(const std::string &name) const {
+    return feature_options_.GetBool(name);
+  }
+
+  void SetFeatureOptions(const Options &options) { feature_options_ = options; }
+  const Options &GetFeaturelOptions() const { return feature_options_; }
+
+ private:
+  // Use helper methods to construct the encoder options.
+  // See CreateDefaultOptions();
+  EncoderOptionsBase() {}
+
+  // List of supported/unsupported features that can be used by the encoder.
+  Options feature_options_;
+};
+
+// Encoder options where attributes are identified by their attribute id.
+// Used to set options that are specific to a given geometry.
+typedef EncoderOptionsBase<int32_t> EncoderOptions;
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_CONFIG_ENCODER_OPTIONS_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/config/encoding_features.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/config/encoding_features.h
new file mode 100644
index 000000000..d6a8b7128
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/config/encoding_features.h
@@ -0,0 +1,39 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides helpful macros that define features available for encoding
+// the input of the input geometry. These macros can be used as an input in
+// the EncoderOptions::SetSupportedFeature() method instead of the text.
+// The most recent set of features supported
+// by the default implementation is:
+//
+// kEdgebreaker
+//     - edgebreaker method for encoding meshes.
+// kPredictiveEdgebreaker
+//     - advanced version of the edgebreaker method (slower but better
+//       compression).
+//
+#ifndef DRACO_COMPRESSION_CONFIG_ENCODING_FEATURES_H_
+#define DRACO_COMPRESSION_CONFIG_ENCODING_FEATURES_H_
+
+namespace draco {
+namespace features {
+
+constexpr const char *kEdgebreaker = "standard_edgebreaker";
+constexpr const char *kPredictiveEdgebreaker = "predictive_edgebreaker";
+
+}  // namespace features
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_CONFIG_ENCODING_FEATURES_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/decode.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/decode.cc
new file mode 100644
index 000000000..92ae4ff66
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/decode.cc
@@ -0,0 +1,135 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/decode.h"
+
+#include "draco/compression/config/compression_shared.h"
+
+#ifdef DRACO_MESH_COMPRESSION_SUPPORTED
+#include "draco/compression/mesh/mesh_edgebreaker_decoder.h"
+#include "draco/compression/mesh/mesh_sequential_decoder.h"
+#endif
+
+#ifdef DRACO_POINT_CLOUD_COMPRESSION_SUPPORTED
+#include "draco/compression/point_cloud/point_cloud_kd_tree_decoder.h"
+#include "draco/compression/point_cloud/point_cloud_sequential_decoder.h"
+#endif
+
+namespace draco {
+
+#ifdef DRACO_POINT_CLOUD_COMPRESSION_SUPPORTED
+StatusOr<std::unique_ptr<PointCloudDecoder>> CreatePointCloudDecoder(
+    int8_t method) {
+  if (method == POINT_CLOUD_SEQUENTIAL_ENCODING) {
+    return std::unique_ptr<PointCloudDecoder>(
+        new PointCloudSequentialDecoder());
+  } else if (method == POINT_CLOUD_KD_TREE_ENCODING) {
+    return std::unique_ptr<PointCloudDecoder>(new PointCloudKdTreeDecoder());
+  }
+  return Status(Status::DRACO_ERROR, "Unsupported encoding method.");
+}
+#endif
+
+#ifdef DRACO_MESH_COMPRESSION_SUPPORTED
+StatusOr<std::unique_ptr<MeshDecoder>> CreateMeshDecoder(uint8_t method) {
+  if (method == MESH_SEQUENTIAL_ENCODING) {
+    return std::unique_ptr<MeshDecoder>(new MeshSequentialDecoder());
+  } else if (method == MESH_EDGEBREAKER_ENCODING) {
+    return std::unique_ptr<MeshDecoder>(new MeshEdgebreakerDecoder());
+  }
+  return Status(Status::DRACO_ERROR, "Unsupported encoding method.");
+}
+#endif
+
+StatusOr<EncodedGeometryType> Decoder::GetEncodedGeometryType(
+    DecoderBuffer *in_buffer) {
+  DecoderBuffer temp_buffer(*in_buffer);
+  DracoHeader header;
+  DRACO_RETURN_IF_ERROR(PointCloudDecoder::DecodeHeader(&temp_buffer, &header));
+  if (header.encoder_type >= NUM_ENCODED_GEOMETRY_TYPES) {
+    return Status(Status::DRACO_ERROR, "Unsupported geometry type.");
+  }
+  return static_cast<EncodedGeometryType>(header.encoder_type);
+}
+
+StatusOr<std::unique_ptr<PointCloud>> Decoder::DecodePointCloudFromBuffer(
+    DecoderBuffer *in_buffer) {
+  DRACO_ASSIGN_OR_RETURN(EncodedGeometryType type,
+                         GetEncodedGeometryType(in_buffer))
+  if (type == POINT_CLOUD) {
+#ifdef DRACO_POINT_CLOUD_COMPRESSION_SUPPORTED
+    std::unique_ptr<PointCloud> point_cloud(new PointCloud());
+    DRACO_RETURN_IF_ERROR(DecodeBufferToGeometry(in_buffer, point_cloud.get()))
+    return std::move(point_cloud);
+#endif
+  } else if (type == TRIANGULAR_MESH) {
+#ifdef DRACO_MESH_COMPRESSION_SUPPORTED
+    std::unique_ptr<Mesh> mesh(new Mesh());
+    DRACO_RETURN_IF_ERROR(DecodeBufferToGeometry(in_buffer, mesh.get()))
+    return static_cast<std::unique_ptr<PointCloud>>(std::move(mesh));
+#endif
+  }
+  return Status(Status::DRACO_ERROR, "Unsupported geometry type.");
+}
+
+StatusOr<std::unique_ptr<Mesh>> Decoder::DecodeMeshFromBuffer(
+    DecoderBuffer *in_buffer) {
+  std::unique_ptr<Mesh> mesh(new Mesh());
+  DRACO_RETURN_IF_ERROR(DecodeBufferToGeometry(in_buffer, mesh.get()))
+  return std::move(mesh);
+}
+
+Status Decoder::DecodeBufferToGeometry(DecoderBuffer *in_buffer,
+                                       PointCloud *out_geometry) {
+#ifdef DRACO_POINT_CLOUD_COMPRESSION_SUPPORTED
+  DecoderBuffer temp_buffer(*in_buffer);
+  DracoHeader header;
+  DRACO_RETURN_IF_ERROR(PointCloudDecoder::DecodeHeader(&temp_buffer, &header))
+  if (header.encoder_type != POINT_CLOUD) {
+    return Status(Status::DRACO_ERROR, "Input is not a point cloud.");
+  }
+  DRACO_ASSIGN_OR_RETURN(std::unique_ptr<PointCloudDecoder> decoder,
+                         CreatePointCloudDecoder(header.encoder_method))
+
+  DRACO_RETURN_IF_ERROR(decoder->Decode(options_, in_buffer, out_geometry))
+  return OkStatus();
+#else
+  return Status(Status::DRACO_ERROR, "Unsupported geometry type.");
+#endif
+}
+
+Status Decoder::DecodeBufferToGeometry(DecoderBuffer *in_buffer,
+                                       Mesh *out_geometry) {
+#ifdef DRACO_MESH_COMPRESSION_SUPPORTED
+  DecoderBuffer temp_buffer(*in_buffer);
+  DracoHeader header;
+  DRACO_RETURN_IF_ERROR(PointCloudDecoder::DecodeHeader(&temp_buffer, &header))
+  if (header.encoder_type != TRIANGULAR_MESH) {
+    return Status(Status::DRACO_ERROR, "Input is not a mesh.");
+  }
+  DRACO_ASSIGN_OR_RETURN(std::unique_ptr<MeshDecoder> decoder,
+                         CreateMeshDecoder(header.encoder_method))
+
+  DRACO_RETURN_IF_ERROR(decoder->Decode(options_, in_buffer, out_geometry))
+  return OkStatus();
+#else
+  return Status(Status::DRACO_ERROR, "Unsupported geometry type.");
+#endif
+}
+
+void Decoder::SetSkipAttributeTransform(GeometryAttribute::Type att_type) {
+  options_.SetAttributeBool(att_type, "skip_attribute_transform", true);
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/decode.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/decode.h
new file mode 100644
index 000000000..5f3fad26b
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/decode.h
@@ -0,0 +1,80 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_DECODE_H_
+#define DRACO_COMPRESSION_DECODE_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/config/decoder_options.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/status_or.h"
+#include "draco/draco_features.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Class responsible for decoding of meshes and point clouds that were
+// compressed by a Draco encoder.
+class Decoder {
+ public:
+  // Returns the geometry type encoded in the input |in_buffer|.
+  // The return value is one of POINT_CLOUD, MESH or INVALID_GEOMETRY in case
+  // the input data is invalid.
+  // The decoded geometry type can be used to choose an appropriate decoding
+  // function for a given geometry type (see below).
+  static StatusOr<EncodedGeometryType> GetEncodedGeometryType(
+      DecoderBuffer *in_buffer);
+
+  // Decodes point cloud from the provided buffer. The buffer must be filled
+  // with data that was encoded with either the EncodePointCloudToBuffer or
+  // EncodeMeshToBuffer methods in encode.h. In case the input buffer contains
+  // mesh, the returned instance can be down-casted to Mesh.
+  StatusOr<std::unique_ptr<PointCloud>> DecodePointCloudFromBuffer(
+      DecoderBuffer *in_buffer);
+
+  // Decodes a triangular mesh from the provided buffer. The mesh must be filled
+  // with data that was encoded using the EncodeMeshToBuffer method in encode.h.
+  // The function will return nullptr in case the input is invalid or if it was
+  // encoded with the EncodePointCloudToBuffer method.
+  StatusOr<std::unique_ptr<Mesh>> DecodeMeshFromBuffer(
+      DecoderBuffer *in_buffer);
+
+  // Decodes the buffer into a provided geometry. If the geometry is
+  // incompatible with the encoded data. For example, when |out_geometry| is
+  // draco::Mesh while the data contains a point cloud, the function will return
+  // an error status.
+  Status DecodeBufferToGeometry(DecoderBuffer *in_buffer,
+                                PointCloud *out_geometry);
+  Status DecodeBufferToGeometry(DecoderBuffer *in_buffer, Mesh *out_geometry);
+
+  // When set, the decoder is going to skip attribute transform for a given
+  // attribute type. For example for quantized attributes, the decoder would
+  // skip the dequantization step and the returned geometry would contain an
+  // attribute with quantized values. The attribute would also contain an
+  // instance of AttributeTransform class that is used to describe the skipped
+  // transform, including all parameters that are needed to perform the
+  // transform manually.
+  void SetSkipAttributeTransform(GeometryAttribute::Type att_type);
+
+  // Returns the options instance used by the decoder that can be used by users
+  // to control the decoding process.
+  DecoderOptions *options() { return &options_; }
+
+ private:
+  DecoderOptions options_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_DECODE_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/decode_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/decode_test.cc
new file mode 100644
index 000000000..198714690
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/decode_test.cc
@@ -0,0 +1,169 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/decode.h"
+
+#include <cinttypes>
+#include <sstream>
+
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+#include "draco/io/file_utils.h"
+
+namespace {
+
+class DecodeTest : public ::testing::Test {
+ protected:
+  DecodeTest() {}
+};
+
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+TEST_F(DecodeTest, TestSkipAttributeTransform) {
+  const std::string file_name = "test_nm_quant.0.9.0.drc";
+  // Tests that decoders can successfully skip attribute transform.
+  std::vector<char> data;
+  ASSERT_TRUE(
+      draco::ReadFileToBuffer(draco::GetTestFileFullPath(file_name), &data));
+  ASSERT_FALSE(data.empty());
+
+  // Create a draco decoding buffer. Note that no data is copied in this step.
+  draco::DecoderBuffer buffer;
+  buffer.Init(data.data(), data.size());
+
+  draco::Decoder decoder;
+  // Make sure we skip dequantization for the position attribute.
+  decoder.SetSkipAttributeTransform(draco::GeometryAttribute::POSITION);
+
+  // Decode the input data into a geometry.
+  std::unique_ptr<draco::PointCloud> pc =
+      decoder.DecodePointCloudFromBuffer(&buffer).value();
+  ASSERT_NE(pc, nullptr);
+
+  const draco::PointAttribute *const pos_att =
+      pc->GetNamedAttribute(draco::GeometryAttribute::POSITION);
+  ASSERT_NE(pos_att, nullptr);
+
+  // Ensure the position attribute is of type int32_t and that it has a valid
+  // attribute transform.
+  ASSERT_EQ(pos_att->data_type(), draco::DT_INT32);
+  ASSERT_NE(pos_att->GetAttributeTransformData(), nullptr);
+
+  // Normal attribute should be left transformed.
+  const draco::PointAttribute *const norm_att =
+      pc->GetNamedAttribute(draco::GeometryAttribute::NORMAL);
+  ASSERT_EQ(norm_att->data_type(), draco::DT_FLOAT32);
+  ASSERT_EQ(norm_att->GetAttributeTransformData(), nullptr);
+}
+#endif
+
+void TestSkipAttributeTransformOnPointCloudWithColor(const std::string &file) {
+  std::vector<char> data;
+  ASSERT_TRUE(draco::ReadFileToBuffer(draco::GetTestFileFullPath(file), &data));
+  ASSERT_FALSE(data.empty());
+
+  // Create a draco decoding buffer. Note that no data is copied in this step.
+  draco::DecoderBuffer buffer;
+  buffer.Init(data.data(), data.size());
+
+  draco::Decoder decoder;
+  // Make sure we skip dequantization for the position attribute.
+  decoder.SetSkipAttributeTransform(draco::GeometryAttribute::POSITION);
+
+  // Decode the input data into a geometry.
+  std::unique_ptr<draco::PointCloud> pc =
+      decoder.DecodePointCloudFromBuffer(&buffer).value();
+  ASSERT_NE(pc, nullptr);
+
+  const draco::PointAttribute *const pos_att =
+      pc->GetNamedAttribute(draco::GeometryAttribute::POSITION);
+  ASSERT_NE(pos_att, nullptr);
+
+  // Ensure the position attribute is of type int32_t or uint32_t and that it
+  // has a valid attribute transform.
+  ASSERT_TRUE(pos_att->data_type() == draco::DT_INT32 ||
+              pos_att->data_type() == draco::DT_UINT32);
+  ASSERT_NE(pos_att->GetAttributeTransformData(), nullptr);
+
+  const draco::PointAttribute *const clr_att =
+      pc->GetNamedAttribute(draco::GeometryAttribute::COLOR);
+  ASSERT_EQ(clr_att->data_type(), draco::DT_UINT8);
+
+  // Ensure the color attribute was decoded correctly. Perform the decoding
+  // again without skipping the position dequantization and compare the
+  // attribute values.
+
+  draco::DecoderBuffer buffer_2;
+  buffer_2.Init(data.data(), data.size());
+
+  draco::Decoder decoder_2;
+
+  // Decode the input data into a geometry.
+  std::unique_ptr<draco::PointCloud> pc_2 =
+      decoder_2.DecodePointCloudFromBuffer(&buffer_2).value();
+  ASSERT_NE(pc_2, nullptr);
+
+  const draco::PointAttribute *const clr_att_2 =
+      pc_2->GetNamedAttribute(draco::GeometryAttribute::COLOR);
+  ASSERT_NE(clr_att_2, nullptr);
+  for (draco::PointIndex pi(0); pi < pc_2->num_points(); ++pi) {
+    // Colors should be exactly the same for both cases.
+    ASSERT_EQ(std::memcmp(clr_att->GetAddress(clr_att->mapped_index(pi)),
+                          clr_att_2->GetAddress(clr_att_2->mapped_index(pi)),
+                          clr_att->byte_stride()),
+              0);
+  }
+}
+
+TEST_F(DecodeTest, TestSkipAttributeTransformOnPointCloud) {
+  // Tests that decoders can successfully skip attribute transform on a point
+  // cloud with multiple attributes encoded with one attributes encoder.
+  TestSkipAttributeTransformOnPointCloudWithColor("pc_color.drc");
+  TestSkipAttributeTransformOnPointCloudWithColor("pc_kd_color.drc");
+}
+
+TEST_F(DecodeTest, TestSkipAttributeTransformWithNoQuantization) {
+  // Tests that decoders can successfully skip attribute transform even though
+  // the input model was not quantized (it has no attribute transform).
+  const std::string file_name = "point_cloud_no_qp.drc";
+  std::vector<char> data;
+  ASSERT_TRUE(
+      draco::ReadFileToBuffer(draco::GetTestFileFullPath(file_name), &data));
+  ASSERT_FALSE(data.empty());
+
+  // Create a draco decoding buffer. Note that no data is copied in this step.
+  draco::DecoderBuffer buffer;
+  buffer.Init(data.data(), data.size());
+
+  draco::Decoder decoder;
+  // Make sure we skip dequantization for the position attribute.
+  decoder.SetSkipAttributeTransform(draco::GeometryAttribute::POSITION);
+
+  // Decode the input data into a geometry.
+  std::unique_ptr<draco::PointCloud> pc =
+      decoder.DecodePointCloudFromBuffer(&buffer).value();
+  ASSERT_NE(pc, nullptr);
+
+  const draco::PointAttribute *const pos_att =
+      pc->GetNamedAttribute(draco::GeometryAttribute::POSITION);
+  ASSERT_NE(pos_att, nullptr);
+
+  // Ensure the position attribute is of type float32 since the attribute was
+  // not quantized.
+  ASSERT_EQ(pos_att->data_type(), draco::DT_FLOAT32);
+
+  // Make sure there is no attribute transform available for the attribute.
+  ASSERT_EQ(pos_att->GetAttributeTransformData(), nullptr);
+}
+
+}  // namespace
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/encode.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/encode.cc
new file mode 100644
index 000000000..f380aec15
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/encode.cc
@@ -0,0 +1,96 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/encode.h"
+
+#include "draco/compression/expert_encode.h"
+
+namespace draco {
+
+Encoder::Encoder() {}
+
+Status Encoder::EncodePointCloudToBuffer(const PointCloud &pc,
+                                         EncoderBuffer *out_buffer) {
+  ExpertEncoder encoder(pc);
+  encoder.Reset(CreateExpertEncoderOptions(pc));
+  return encoder.EncodeToBuffer(out_buffer);
+}
+
+Status Encoder::EncodeMeshToBuffer(const Mesh &m, EncoderBuffer *out_buffer) {
+  ExpertEncoder encoder(m);
+  encoder.Reset(CreateExpertEncoderOptions(m));
+  DRACO_RETURN_IF_ERROR(encoder.EncodeToBuffer(out_buffer));
+  set_num_encoded_points(encoder.num_encoded_points());
+  set_num_encoded_faces(encoder.num_encoded_faces());
+  return OkStatus();
+}
+
+EncoderOptions Encoder::CreateExpertEncoderOptions(const PointCloud &pc) const {
+  EncoderOptions ret_options = EncoderOptions::CreateEmptyOptions();
+  ret_options.SetGlobalOptions(options().GetGlobalOptions());
+  ret_options.SetFeatureOptions(options().GetFeaturelOptions());
+  // Convert type-based attribute options to specific attributes in the provided
+  // point cloud.
+  for (int i = 0; i < pc.num_attributes(); ++i) {
+    const Options *att_options =
+        options().FindAttributeOptions(pc.attribute(i)->attribute_type());
+    if (att_options) {
+      ret_options.SetAttributeOptions(i, *att_options);
+    }
+  }
+  return ret_options;
+}
+
+void Encoder::Reset(
+    const EncoderOptionsBase<GeometryAttribute::Type> &options) {
+  Base::Reset(options);
+}
+
+void Encoder::Reset() { Base::Reset(); }
+
+void Encoder::SetSpeedOptions(int encoding_speed, int decoding_speed) {
+  Base::SetSpeedOptions(encoding_speed, decoding_speed);
+}
+
+void Encoder::SetAttributeQuantization(GeometryAttribute::Type type,
+                                       int quantization_bits) {
+  options().SetAttributeInt(type, "quantization_bits", quantization_bits);
+}
+
+void Encoder::SetAttributeExplicitQuantization(GeometryAttribute::Type type,
+                                               int quantization_bits,
+                                               int num_dims,
+                                               const float *origin,
+                                               float range) {
+  options().SetAttributeInt(type, "quantization_bits", quantization_bits);
+  options().SetAttributeVector(type, "quantization_origin", num_dims, origin);
+  options().SetAttributeFloat(type, "quantization_range", range);
+}
+
+void Encoder::SetEncodingMethod(int encoding_method) {
+  Base::SetEncodingMethod(encoding_method);
+}
+
+Status Encoder::SetAttributePredictionScheme(GeometryAttribute::Type type,
+                                             int prediction_scheme_method) {
+  Status status = CheckPredictionScheme(type, prediction_scheme_method);
+  if (!status.ok()) {
+    return status;
+  }
+  options().SetAttributeInt(type, "prediction_scheme",
+                            prediction_scheme_method);
+  return status;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/encode.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/encode.h
new file mode 100644
index 000000000..bce8b34c2
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/encode.h
@@ -0,0 +1,140 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ENCODE_H_
+#define DRACO_COMPRESSION_ENCODE_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/config/encoder_options.h"
+#include "draco/compression/encode_base.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/status.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Basic helper class for encoding geometry using the Draco compression library.
+// The class provides various methods that can be used to control several common
+// options used during the encoding, such as the number of quantization bits for
+// a given attribute. All these options are defined per attribute type, i.e.,
+// if there are more attributes of the same type (such as multiple texture
+// coordinate attributes), the same options are going to be used for all of the
+// attributes of this type. If different attributes of the same type need to
+// use different options, use ExpertEncoder in expert_encode.h.
+class Encoder
+    : public EncoderBase<EncoderOptionsBase<GeometryAttribute::Type>> {
+ public:
+  typedef EncoderBase<EncoderOptionsBase<GeometryAttribute::Type>> Base;
+
+  Encoder();
+  virtual ~Encoder() {}
+
+  // Encodes a point cloud to the provided buffer.
+  virtual Status EncodePointCloudToBuffer(const PointCloud &pc,
+                                          EncoderBuffer *out_buffer);
+
+  // Encodes a mesh to the provided buffer.
+  virtual Status EncodeMeshToBuffer(const Mesh &m, EncoderBuffer *out_buffer);
+
+  // Set encoder options used during the geometry encoding. Note that this call
+  // overwrites any modifications to the options done with the functions below,
+  // i.e., it resets the encoder.
+  void Reset(const EncoderOptionsBase<GeometryAttribute::Type> &options);
+  void Reset();
+
+  // Sets the desired encoding and decoding speed for the given options.
+  //
+  //  0 = slowest speed, but the best compression.
+  // 10 = fastest, but the worst compression.
+  // -1 = undefined.
+  //
+  // Note that both speed options affect the encoder choice of used methods and
+  // algorithms. For example, a requirement for fast decoding may prevent the
+  // encoder from using the best compression methods even if the encoding speed
+  // is set to 0. In general, the faster of the two options limits the choice of
+  // features that can be used by the encoder. Additionally, setting
+  // |decoding_speed| to be faster than the |encoding_speed| may allow the
+  // encoder to choose the optimal method out of the available features for the
+  // given |decoding_speed|.
+  void SetSpeedOptions(int encoding_speed, int decoding_speed);
+
+  // Sets the quantization compression options for a named attribute. The
+  // attribute values will be quantized in a box defined by the maximum extent
+  // of the attribute values. I.e., the actual precision of this option depends
+  // on the scale of the attribute values.
+  void SetAttributeQuantization(GeometryAttribute::Type type,
+                                int quantization_bits);
+
+  // Sets the explicit quantization compression for a named attribute. The
+  // attribute values will be quantized in a coordinate system defined by the
+  // provided origin and range (the input values should be within interval:
+  // <origin, origin + range>).
+  void SetAttributeExplicitQuantization(GeometryAttribute::Type type,
+                                        int quantization_bits, int num_dims,
+                                        const float *origin, float range);
+
+  // Sets the desired prediction method for a given attribute. By default,
+  // prediction scheme is selected automatically by the encoder using other
+  // provided options (such as speed) and input geometry type (mesh, point
+  // cloud). This function should be called only when a specific prediction is
+  // preferred (e.g., when it is known that the encoder would select a less
+  // optimal prediction for the given input data).
+  //
+  // |prediction_scheme_method| should be one of the entries defined in
+  // compression/config/compression_shared.h :
+  //
+  //   PREDICTION_NONE - use no prediction.
+  //   PREDICTION_DIFFERENCE - delta coding
+  //   MESH_PREDICTION_PARALLELOGRAM - parallelogram prediction for meshes.
+  //   MESH_PREDICTION_CONSTRAINED_PARALLELOGRAM
+  //      - better and more costly version of the parallelogram prediction.
+  //   MESH_PREDICTION_TEX_COORDS_PORTABLE
+  //      - specialized predictor for tex coordinates.
+  //   MESH_PREDICTION_GEOMETRIC_NORMAL
+  //      - specialized predictor for normal coordinates.
+  //
+  // Note that in case the desired prediction cannot be used, the default
+  // prediction will be automatically used instead.
+  Status SetAttributePredictionScheme(GeometryAttribute::Type type,
+                                      int prediction_scheme_method);
+
+  // Sets the desired encoding method for a given geometry. By default, encoding
+  // method is selected based on the properties of the input geometry and based
+  // on the other options selected in the used EncoderOptions (such as desired
+  // encoding and decoding speed). This function should be called only when a
+  // specific method is required.
+  //
+  // |encoding_method| can be one of the values defined in
+  // compression/config/compression_shared.h based on the type of the input
+  // geometry that is going to be encoded. For point clouds, allowed entries are
+  //   POINT_CLOUD_SEQUENTIAL_ENCODING
+  //   POINT_CLOUD_KD_TREE_ENCODING
+  //
+  // For meshes the input can be
+  //   MESH_SEQUENTIAL_ENCODING
+  //   MESH_EDGEBREAKER_ENCODING
+  //
+  // If the selected method cannot be used for the given input, the subsequent
+  // call of EncodePointCloudToBuffer or EncodeMeshToBuffer is going to fail.
+  void SetEncodingMethod(int encoding_method);
+
+ protected:
+  // Creates encoder options for the expert encoder used during the actual
+  // encoding.
+  EncoderOptions CreateExpertEncoderOptions(const PointCloud &pc) const;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ENCODE_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/encode_base.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/encode_base.h
new file mode 100644
index 000000000..c501bc4fa
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/encode_base.h
@@ -0,0 +1,131 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ENCODE_BASE_H_
+#define DRACO_COMPRESSION_ENCODE_BASE_H_
+
+#include "draco/attributes/geometry_attribute.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/status.h"
+
+namespace draco {
+
+// Base class for our geometry encoder classes. |EncoderOptionsT| specifies
+// options class used by the encoder. Please, see encode.h and expert_encode.h
+// for more details and method descriptions.
+template <class EncoderOptionsT>
+class EncoderBase {
+ public:
+  typedef EncoderOptionsT OptionsType;
+
+  EncoderBase()
+      : options_(EncoderOptionsT::CreateDefaultOptions()),
+        num_encoded_points_(0),
+        num_encoded_faces_(0) {}
+  virtual ~EncoderBase() {}
+
+  const EncoderOptionsT &options() const { return options_; }
+  EncoderOptionsT &options() { return options_; }
+
+  // If enabled, it tells the encoder to keep track of the number of encoded
+  // points and faces (default = false).
+  // Note that this can slow down encoding for certain encoders.
+  void SetTrackEncodedProperties(bool flag);
+
+  // Returns the number of encoded points and faces during the last encoding
+  // operation. Returns 0 if SetTrackEncodedProperties() was not set.
+  size_t num_encoded_points() const { return num_encoded_points_; }
+  size_t num_encoded_faces() const { return num_encoded_faces_; }
+
+ protected:
+  void Reset(const EncoderOptionsT &options) { options_ = options; }
+
+  void Reset() { options_ = EncoderOptionsT::CreateDefaultOptions(); }
+
+  void SetSpeedOptions(int encoding_speed, int decoding_speed) {
+    options_.SetSpeed(encoding_speed, decoding_speed);
+  }
+
+  void SetEncodingMethod(int encoding_method) {
+    options_.SetGlobalInt("encoding_method", encoding_method);
+  }
+
+  void SetEncodingSubmethod(int encoding_submethod) {
+    options_.SetGlobalInt("encoding_submethod", encoding_submethod);
+  }
+
+  Status CheckPredictionScheme(GeometryAttribute::Type att_type,
+                               int prediction_scheme) const {
+    // Out of bound checks:
+    if (prediction_scheme < PREDICTION_NONE) {
+      return Status(Status::DRACO_ERROR,
+                    "Invalid prediction scheme requested.");
+    }
+    if (prediction_scheme >= NUM_PREDICTION_SCHEMES) {
+      return Status(Status::DRACO_ERROR,
+                    "Invalid prediction scheme requested.");
+    }
+    // Deprecated prediction schemes:
+    if (prediction_scheme == MESH_PREDICTION_TEX_COORDS_DEPRECATED) {
+      return Status(Status::DRACO_ERROR,
+                    "MESH_PREDICTION_TEX_COORDS_DEPRECATED is deprecated.");
+    }
+    if (prediction_scheme == MESH_PREDICTION_MULTI_PARALLELOGRAM) {
+      return Status(Status::DRACO_ERROR,
+                    "MESH_PREDICTION_MULTI_PARALLELOGRAM is deprecated.");
+    }
+    // Attribute specific checks:
+    if (prediction_scheme == MESH_PREDICTION_TEX_COORDS_PORTABLE) {
+      if (att_type != GeometryAttribute::TEX_COORD) {
+        return Status(Status::DRACO_ERROR,
+                      "Invalid prediction scheme for attribute type.");
+      }
+    }
+    if (prediction_scheme == MESH_PREDICTION_GEOMETRIC_NORMAL) {
+      if (att_type != GeometryAttribute::NORMAL) {
+        return Status(Status::DRACO_ERROR,
+                      "Invalid prediction scheme for attribute type.");
+      }
+    }
+    // TODO(hemmer): Try to enable more prediction schemes for normals.
+    if (att_type == GeometryAttribute::NORMAL) {
+      if (!(prediction_scheme == PREDICTION_DIFFERENCE ||
+            prediction_scheme == MESH_PREDICTION_GEOMETRIC_NORMAL)) {
+        return Status(Status::DRACO_ERROR,
+                      "Invalid prediction scheme for attribute type.");
+      }
+    }
+    return OkStatus();
+  }
+
+ protected:
+  void set_num_encoded_points(size_t num) { num_encoded_points_ = num; }
+  void set_num_encoded_faces(size_t num) { num_encoded_faces_ = num; }
+
+ private:
+  EncoderOptionsT options_;
+
+  size_t num_encoded_points_;
+  size_t num_encoded_faces_;
+};
+
+template <class EncoderOptionsT>
+void EncoderBase<EncoderOptionsT>::SetTrackEncodedProperties(bool flag) {
+  options_.SetGlobalBool("store_number_of_encoded_points", flag);
+  options_.SetGlobalBool("store_number_of_encoded_faces", flag);
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ENCODE_BASE_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/encode_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/encode_test.cc
new file mode 100644
index 000000000..fde4f6f5b
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/encode_test.cc
@@ -0,0 +1,407 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include "draco/compression/encode.h"
+
+#include <cinttypes>
+#include <fstream>
+#include <sstream>
+
+#include "draco/attributes/attribute_quantization_transform.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/decode.h"
+#include "draco/compression/expert_encode.h"
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+#include "draco/core/vector_d.h"
+#include "draco/io/obj_decoder.h"
+#include "draco/mesh/triangle_soup_mesh_builder.h"
+#include "draco/point_cloud/point_cloud_builder.h"
+
+namespace {
+
+class EncodeTest : public ::testing::Test {
+ protected:
+  EncodeTest() {}
+  std::unique_ptr<draco::Mesh> CreateTestMesh() const {
+    draco::TriangleSoupMeshBuilder mesh_builder;
+
+    // Create a simple mesh with one face.
+    mesh_builder.Start(1);
+
+    // Add one position attribute and two texture coordinate attributes.
+    const int32_t pos_att_id = mesh_builder.AddAttribute(
+        draco::GeometryAttribute::POSITION, 3, draco::DT_FLOAT32);
+    const int32_t tex_att_id_0 = mesh_builder.AddAttribute(
+        draco::GeometryAttribute::TEX_COORD, 2, draco::DT_FLOAT32);
+    const int32_t tex_att_id_1 = mesh_builder.AddAttribute(
+        draco::GeometryAttribute::TEX_COORD, 2, draco::DT_FLOAT32);
+
+    // Initialize the attribute values.
+    mesh_builder.SetAttributeValuesForFace(
+        pos_att_id, draco::FaceIndex(0), draco::Vector3f(0.f, 0.f, 0.f).data(),
+        draco::Vector3f(1.f, 0.f, 0.f).data(),
+        draco::Vector3f(1.f, 1.f, 0.f).data());
+    mesh_builder.SetAttributeValuesForFace(
+        tex_att_id_0, draco::FaceIndex(0), draco::Vector2f(0.f, 0.f).data(),
+        draco::Vector2f(1.f, 0.f).data(), draco::Vector2f(1.f, 1.f).data());
+    mesh_builder.SetAttributeValuesForFace(
+        tex_att_id_1, draco::FaceIndex(0), draco::Vector2f(0.f, 0.f).data(),
+        draco::Vector2f(1.f, 0.f).data(), draco::Vector2f(1.f, 1.f).data());
+
+    return mesh_builder.Finalize();
+  }
+
+  std::unique_ptr<draco::PointCloud> CreateTestPointCloud() const {
+    draco::PointCloudBuilder pc_builder;
+
+    constexpr int kNumPoints = 100;
+    constexpr int kNumGenAttCoords0 = 4;
+    constexpr int kNumGenAttCoords1 = 6;
+    pc_builder.Start(kNumPoints);
+
+    // Add one position attribute and two generic attributes.
+    const int32_t pos_att_id = pc_builder.AddAttribute(
+        draco::GeometryAttribute::POSITION, 3, draco::DT_FLOAT32);
+    const int32_t gen_att_id_0 = pc_builder.AddAttribute(
+        draco::GeometryAttribute::GENERIC, kNumGenAttCoords0, draco::DT_UINT32);
+    const int32_t gen_att_id_1 = pc_builder.AddAttribute(
+        draco::GeometryAttribute::GENERIC, kNumGenAttCoords1, draco::DT_UINT8);
+
+    std::vector<uint32_t> gen_att_data_0(kNumGenAttCoords0);
+    std::vector<uint32_t> gen_att_data_1(kNumGenAttCoords1);
+
+    // Initialize the attribute values.
+    for (draco::PointIndex i(0); i < kNumPoints; ++i) {
+      const float pos_coord = static_cast<float>(i.value());
+      pc_builder.SetAttributeValueForPoint(
+          pos_att_id, i,
+          draco::Vector3f(pos_coord, -pos_coord, pos_coord).data());
+
+      for (int j = 0; j < kNumGenAttCoords0; ++j) {
+        gen_att_data_0[j] = i.value();
+      }
+      pc_builder.SetAttributeValueForPoint(gen_att_id_0, i,
+                                           gen_att_data_0.data());
+
+      for (int j = 0; j < kNumGenAttCoords1; ++j) {
+        gen_att_data_1[j] = -i.value();
+      }
+      pc_builder.SetAttributeValueForPoint(gen_att_id_1, i,
+                                           gen_att_data_1.data());
+    }
+    return pc_builder.Finalize(false);
+  }
+
+  std::unique_ptr<draco::PointCloud> CreateTestPointCloudPosNorm() const {
+    draco::PointCloudBuilder pc_builder;
+
+    constexpr int kNumPoints = 20;
+    pc_builder.Start(kNumPoints);
+
+    // Add one position attribute and a normal attribute.
+    const int32_t pos_att_id = pc_builder.AddAttribute(
+        draco::GeometryAttribute::POSITION, 3, draco::DT_FLOAT32);
+    const int32_t norm_att_id = pc_builder.AddAttribute(
+        draco::GeometryAttribute::NORMAL, 3, draco::DT_FLOAT32);
+
+    // Initialize the attribute values.
+    for (draco::PointIndex i(0); i < kNumPoints; ++i) {
+      const float pos_coord = static_cast<float>(i.value());
+      pc_builder.SetAttributeValueForPoint(
+          pos_att_id, i,
+          draco::Vector3f(pos_coord, -pos_coord, pos_coord).data());
+
+      // Pseudo-random normal.
+      draco::Vector3f norm(pos_coord * 2.f, pos_coord - 2.f, pos_coord * 3.f);
+      norm.Normalize();
+      pc_builder.SetAttributeValueForPoint(norm_att_id, i, norm.data());
+    }
+
+    return pc_builder.Finalize(false);
+  }
+
+  int GetQuantizationBitsFromAttribute(const draco::PointAttribute *att) const {
+    if (att == nullptr) {
+      return -1;
+    }
+    draco::AttributeQuantizationTransform transform;
+    if (!transform.InitFromAttribute(*att)) {
+      return -1;
+    }
+    return transform.quantization_bits();
+  }
+
+  void VerifyNumQuantizationBits(const draco::EncoderBuffer &buffer,
+                                 int pos_quantization,
+                                 int tex_coord_0_quantization,
+                                 int tex_coord_1_quantization) const {
+    draco::Decoder decoder;
+
+    // Skip the dequantization for the attributes which will allow us to get
+    // the number of quantization bits used during encoding.
+    decoder.SetSkipAttributeTransform(draco::GeometryAttribute::POSITION);
+    decoder.SetSkipAttributeTransform(draco::GeometryAttribute::TEX_COORD);
+
+    draco::DecoderBuffer in_buffer;
+    in_buffer.Init(buffer.data(), buffer.size());
+    auto mesh = decoder.DecodeMeshFromBuffer(&in_buffer).value();
+    ASSERT_NE(mesh, nullptr);
+    ASSERT_EQ(GetQuantizationBitsFromAttribute(mesh->attribute(0)),
+              pos_quantization);
+    ASSERT_EQ(GetQuantizationBitsFromAttribute(mesh->attribute(1)),
+              tex_coord_0_quantization);
+    ASSERT_EQ(GetQuantizationBitsFromAttribute(mesh->attribute(2)),
+              tex_coord_1_quantization);
+  }
+
+  // Tests that the encoder returns the correct number of encoded points and
+  // faces for a given mesh or point cloud.
+  void TestNumberOfEncodedEntries(const std::string &file_name,
+                                  int32_t encoding_method) {
+    std::unique_ptr<draco::PointCloud> geometry;
+    draco::Mesh *mesh = nullptr;
+
+    if (encoding_method == draco::MESH_EDGEBREAKER_ENCODING ||
+        encoding_method == draco::MESH_SEQUENTIAL_ENCODING) {
+      std::unique_ptr<draco::Mesh> mesh_tmp =
+          draco::ReadMeshFromTestFile(file_name);
+      mesh = mesh_tmp.get();
+      if (!mesh->DeduplicateAttributeValues()) {
+        return;
+      }
+      mesh->DeduplicatePointIds();
+      geometry = std::move(mesh_tmp);
+    } else {
+      geometry = draco::ReadPointCloudFromTestFile(file_name);
+    }
+    ASSERT_NE(mesh, nullptr);
+
+    draco::Encoder encoder;
+    encoder.SetAttributeQuantization(draco::GeometryAttribute::POSITION, 14);
+    encoder.SetAttributeQuantization(draco::GeometryAttribute::TEX_COORD, 12);
+    encoder.SetAttributeQuantization(draco::GeometryAttribute::NORMAL, 10);
+
+    encoder.SetEncodingMethod(encoding_method);
+
+    encoder.SetTrackEncodedProperties(true);
+
+    draco::EncoderBuffer buffer;
+    if (mesh) {
+      encoder.EncodeMeshToBuffer(*mesh, &buffer);
+    } else {
+      encoder.EncodePointCloudToBuffer(*geometry, &buffer);
+    }
+
+    // Ensure the logged number of encoded points and faces matches the number
+    // we get from the decoder.
+
+    draco::DecoderBuffer decoder_buffer;
+    decoder_buffer.Init(buffer.data(), buffer.size());
+    draco::Decoder decoder;
+
+    if (mesh) {
+      auto maybe_mesh = decoder.DecodeMeshFromBuffer(&decoder_buffer);
+      ASSERT_TRUE(maybe_mesh.ok());
+      auto decoded_mesh = std::move(maybe_mesh).value();
+      ASSERT_NE(decoded_mesh, nullptr);
+      ASSERT_EQ(decoded_mesh->num_points(), encoder.num_encoded_points());
+      ASSERT_EQ(decoded_mesh->num_faces(), encoder.num_encoded_faces());
+    } else {
+      auto maybe_pc = decoder.DecodePointCloudFromBuffer(&decoder_buffer);
+      ASSERT_TRUE(maybe_pc.ok());
+      auto decoded_pc = std::move(maybe_pc).value();
+      ASSERT_EQ(decoded_pc->num_points(), encoder.num_encoded_points());
+    }
+  }
+};
+
+TEST_F(EncodeTest, TestExpertEncoderQuantization) {
+  // This test verifies that the expert encoder can quantize individual
+  // attributes even if they have the same type.
+  auto mesh = CreateTestMesh();
+  ASSERT_NE(mesh, nullptr);
+
+  draco::ExpertEncoder encoder(*mesh);
+  encoder.SetAttributeQuantization(0, 16);  // Position quantization.
+  encoder.SetAttributeQuantization(1, 15);  // Tex-coord 0 quantization.
+  encoder.SetAttributeQuantization(2, 14);  // Tex-coord 1 quantization.
+
+  draco::EncoderBuffer buffer;
+  encoder.EncodeToBuffer(&buffer);
+  VerifyNumQuantizationBits(buffer, 16, 15, 14);
+}
+
+TEST_F(EncodeTest, TestEncoderQuantization) {
+  // This test verifies that Encoder applies the same quantization to all
+  // attributes of the same type.
+  auto mesh = CreateTestMesh();
+  ASSERT_NE(mesh, nullptr);
+
+  draco::Encoder encoder;
+  encoder.SetAttributeQuantization(draco::GeometryAttribute::POSITION, 16);
+  encoder.SetAttributeQuantization(draco::GeometryAttribute::TEX_COORD, 15);
+
+  draco::EncoderBuffer buffer;
+  encoder.EncodeMeshToBuffer(*mesh, &buffer);
+  VerifyNumQuantizationBits(buffer, 16, 15, 15);
+}
+
+TEST_F(EncodeTest, TestLinesObj) {
+  // This test verifies that Encoder can encode file that contains only line
+  // segments (that are ignored).
+  std::unique_ptr<draco::Mesh> mesh(
+      draco::ReadMeshFromTestFile("test_lines.obj"));
+  ASSERT_NE(mesh, nullptr);
+  ASSERT_EQ(mesh->num_faces(), 0);
+  std::unique_ptr<draco::PointCloud> pc(
+      draco::ReadPointCloudFromTestFile("test_lines.obj"));
+  ASSERT_NE(pc, nullptr);
+
+  draco::Encoder encoder;
+  encoder.SetAttributeQuantization(draco::GeometryAttribute::POSITION, 16);
+
+  draco::EncoderBuffer buffer;
+  ASSERT_TRUE(encoder.EncodePointCloudToBuffer(*pc, &buffer).ok());
+}
+
+TEST_F(EncodeTest, TestQuantizedInfinity) {
+  // This test verifies that Encoder fails to encode point cloud when requesting
+  // quantization of attribute that contains infinity values.
+  std::unique_ptr<draco::PointCloud> pc(
+      draco::ReadPointCloudFromTestFile("float_inf_point_cloud.ply"));
+  ASSERT_NE(pc, nullptr);
+
+  {
+    draco::Encoder encoder;
+    encoder.SetEncodingMethod(draco::POINT_CLOUD_SEQUENTIAL_ENCODING);
+    encoder.SetAttributeQuantization(draco::GeometryAttribute::POSITION, 11);
+
+    draco::EncoderBuffer buffer;
+    ASSERT_FALSE(encoder.EncodePointCloudToBuffer(*pc, &buffer).ok());
+  }
+
+  {
+    draco::Encoder encoder;
+    encoder.SetEncodingMethod(draco::POINT_CLOUD_KD_TREE_ENCODING);
+    encoder.SetAttributeQuantization(draco::GeometryAttribute::POSITION, 11);
+
+    draco::EncoderBuffer buffer;
+    ASSERT_FALSE(encoder.EncodePointCloudToBuffer(*pc, &buffer).ok());
+  }
+}
+
+TEST_F(EncodeTest, TestUnquantizedInfinity) {
+  // This test verifies that Encoder can successfully encode point cloud when
+  // not requesting quantization of attribute that contains infinity values.
+  std::unique_ptr<draco::PointCloud> pc(
+      draco::ReadPointCloudFromTestFile("float_inf_point_cloud.ply"));
+  ASSERT_NE(pc, nullptr);
+
+  // Note that the KD tree encoding method is not applicable to float values.
+  draco::Encoder encoder;
+  encoder.SetEncodingMethod(draco::POINT_CLOUD_SEQUENTIAL_ENCODING);
+
+  draco::EncoderBuffer buffer;
+  ASSERT_TRUE(encoder.EncodePointCloudToBuffer(*pc, &buffer).ok());
+}
+
+TEST_F(EncodeTest, TestQuantizedAndUnquantizedAttributes) {
+  // This test verifies that Encoder can successfully encode point cloud with
+  // two float attribiutes - one quantized and another unquantized. The encoder
+  // defaults to sequential encoding in this case.
+  std::unique_ptr<draco::PointCloud> pc(
+      draco::ReadPointCloudFromTestFile("float_two_att_point_cloud.ply"));
+  ASSERT_NE(pc, nullptr);
+
+  draco::Encoder encoder;
+  encoder.SetAttributeQuantization(draco::GeometryAttribute::POSITION, 11);
+  encoder.SetAttributeQuantization(draco::GeometryAttribute::NORMAL, 0);
+  draco::EncoderBuffer buffer;
+  ASSERT_TRUE(encoder.EncodePointCloudToBuffer(*pc, &buffer).ok());
+}
+
+TEST_F(EncodeTest, TestKdTreeEncoding) {
+  // This test verifies that the API can successfully encode a point cloud
+  // defined by several attributes using the kd tree method.
+  std::unique_ptr<draco::PointCloud> pc = CreateTestPointCloud();
+  ASSERT_NE(pc, nullptr);
+
+  draco::EncoderBuffer buffer;
+  draco::Encoder encoder;
+  encoder.SetEncodingMethod(draco::POINT_CLOUD_KD_TREE_ENCODING);
+  // First try it without quantizing positions which should fail.
+  ASSERT_FALSE(encoder.EncodePointCloudToBuffer(*pc, &buffer).ok());
+
+  // Now set quantization for the position attribute which should make
+  // the encoder happy.
+  encoder.SetAttributeQuantization(draco::GeometryAttribute::POSITION, 16);
+  ASSERT_TRUE(encoder.EncodePointCloudToBuffer(*pc, &buffer).ok());
+}
+
+TEST_F(EncodeTest, TestTrackingOfNumberOfEncodedEntries) {
+  TestNumberOfEncodedEntries("deg_faces.obj", draco::MESH_EDGEBREAKER_ENCODING);
+  TestNumberOfEncodedEntries("deg_faces.obj", draco::MESH_SEQUENTIAL_ENCODING);
+  TestNumberOfEncodedEntries("cube_att.obj", draco::MESH_EDGEBREAKER_ENCODING);
+  TestNumberOfEncodedEntries("test_nm.obj", draco::MESH_EDGEBREAKER_ENCODING);
+  TestNumberOfEncodedEntries("test_nm.obj", draco::MESH_SEQUENTIAL_ENCODING);
+  TestNumberOfEncodedEntries("cube_subd.obj",
+                             draco::POINT_CLOUD_KD_TREE_ENCODING);
+  TestNumberOfEncodedEntries("cube_subd.obj",
+                             draco::POINT_CLOUD_SEQUENTIAL_ENCODING);
+}
+
+TEST_F(EncodeTest, TestTrackingOfNumberOfEncodedEntriesNotSet) {
+  // Tests that when tracing of encoded properties is disabled, the returned
+  // number of encoded faces and points is 0.
+  std::unique_ptr<draco::Mesh> mesh(
+      draco::ReadMeshFromTestFile("cube_att.obj"));
+  ASSERT_NE(mesh, nullptr);
+
+  draco::EncoderBuffer buffer;
+  draco::Encoder encoder;
+
+  ASSERT_TRUE(encoder.EncodeMeshToBuffer(*mesh, &buffer).ok());
+  ASSERT_EQ(encoder.num_encoded_points(), 0);
+  ASSERT_EQ(encoder.num_encoded_faces(), 0);
+}
+
+TEST_F(EncodeTest, TestNoPosQuantizationNormalCoding) {
+  // Tests that we can encode and decode a file with quantized normals but
+  // non-quantized positions.
+  const auto mesh = draco::ReadMeshFromTestFile("test_nm.obj");
+  ASSERT_NE(mesh, nullptr);
+
+  // The mesh should have positions and normals.
+  ASSERT_NE(mesh->GetNamedAttribute(draco::GeometryAttribute::POSITION),
+            nullptr);
+  ASSERT_NE(mesh->GetNamedAttribute(draco::GeometryAttribute::NORMAL), nullptr);
+
+  draco::EncoderBuffer buffer;
+  draco::Encoder encoder;
+  // No quantization for positions.
+  encoder.SetAttributeQuantization(draco::GeometryAttribute::NORMAL, 8);
+
+  DRACO_ASSERT_OK(encoder.EncodeMeshToBuffer(*mesh, &buffer));
+
+  draco::Decoder decoder;
+
+  draco::DecoderBuffer in_buffer;
+  in_buffer.Init(buffer.data(), buffer.size());
+  const auto decoded_mesh = decoder.DecodeMeshFromBuffer(&in_buffer).value();
+  ASSERT_NE(decoded_mesh, nullptr);
+}
+
+}  // namespace
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/ans.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/ans.h
new file mode 100644
index 000000000..c71d58975
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/ans.h
@@ -0,0 +1,527 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ENTROPY_ANS_H_
+#define DRACO_COMPRESSION_ENTROPY_ANS_H_
+// An implementation of Asymmetric Numeral Systems (rANS).
+// See http://arxiv.org/abs/1311.2540v2 for more information on rANS.
+// This file is based off libvpx's ans.h.
+
+#include <vector>
+
+#define DRACO_ANS_DIVIDE_BY_MULTIPLY 1
+#if DRACO_ANS_DIVIDE_BY_MULTIPLY
+#include "draco/core/divide.h"
+#endif
+#include "draco/core/macros.h"
+
+namespace draco {
+
+#if DRACO_ANS_DIVIDE_BY_MULTIPLY
+
+#define DRACO_ANS_DIVREM(quotient, remainder, dividend, divisor) \
+  do {                                                           \
+    quotient = fastdiv(dividend, divisor);                       \
+    remainder = dividend - quotient * divisor;                   \
+  } while (0)
+#define DRACO_ANS_DIV(dividend, divisor) fastdiv(dividend, divisor)
+#else
+#define DRACO_ANS_DIVREM(quotient, remainder, dividend, divisor) \
+  do {                                                           \
+    quotient = dividend / divisor;                               \
+    remainder = dividend % divisor;                              \
+  } while (0)
+#define DRACO_ANS_DIV(dividend, divisor) ((dividend) / (divisor))
+#endif
+
+struct AnsCoder {
+  AnsCoder() : buf(nullptr), buf_offset(0), state(0) {}
+  uint8_t *buf;
+  int buf_offset;
+  uint32_t state;
+};
+
+struct AnsDecoder {
+  AnsDecoder() : buf(nullptr), buf_offset(0), state(0) {}
+  const uint8_t *buf;
+  int buf_offset;
+  uint32_t state;
+};
+
+typedef uint8_t AnsP8;
+#define DRACO_ANS_P8_PRECISION 256u
+#define DRACO_ANS_L_BASE (4096u)
+#define DRACO_ANS_IO_BASE 256
+
+static uint32_t mem_get_le16(const void *vmem) {
+  uint32_t val;
+  const uint8_t *mem = (const uint8_t *)vmem;
+
+  val = mem[1] << 8;
+  val |= mem[0];
+  return val;
+}
+
+static uint32_t mem_get_le24(const void *vmem) {
+  uint32_t val;
+  const uint8_t *mem = (const uint8_t *)vmem;
+
+  val = mem[2] << 16;
+  val |= mem[1] << 8;
+  val |= mem[0];
+  return val;
+}
+
+static inline uint32_t mem_get_le32(const void *vmem) {
+  uint32_t val;
+  const uint8_t *mem = (const uint8_t *)vmem;
+
+  val = mem[3] << 24;
+  val |= mem[2] << 16;
+  val |= mem[1] << 8;
+  val |= mem[0];
+  return val;
+}
+
+static inline void mem_put_le16(void *vmem, uint32_t val) {
+  uint8_t *mem = reinterpret_cast<uint8_t *>(vmem);
+
+  mem[0] = (val >> 0) & 0xff;
+  mem[1] = (val >> 8) & 0xff;
+}
+
+static inline void mem_put_le24(void *vmem, uint32_t val) {
+  uint8_t *mem = reinterpret_cast<uint8_t *>(vmem);
+
+  mem[0] = (val >> 0) & 0xff;
+  mem[1] = (val >> 8) & 0xff;
+  mem[2] = (val >> 16) & 0xff;
+}
+
+static inline void mem_put_le32(void *vmem, uint32_t val) {
+  uint8_t *mem = reinterpret_cast<uint8_t *>(vmem);
+
+  mem[0] = (val >> 0) & 0xff;
+  mem[1] = (val >> 8) & 0xff;
+  mem[2] = (val >> 16) & 0xff;
+  mem[3] = (val >> 24) & 0xff;
+}
+
+static inline void ans_write_init(struct AnsCoder *const ans,
+                                  uint8_t *const buf) {
+  ans->buf = buf;
+  ans->buf_offset = 0;
+  ans->state = DRACO_ANS_L_BASE;
+}
+
+static inline int ans_write_end(struct AnsCoder *const ans) {
+  uint32_t state;
+  DRACO_DCHECK_GE(ans->state, DRACO_ANS_L_BASE);
+  DRACO_DCHECK_LT(ans->state, DRACO_ANS_L_BASE * DRACO_ANS_IO_BASE);
+  state = ans->state - DRACO_ANS_L_BASE;
+  if (state < (1 << 6)) {
+    ans->buf[ans->buf_offset] = (0x00 << 6) + state;
+    return ans->buf_offset + 1;
+  } else if (state < (1 << 14)) {
+    mem_put_le16(ans->buf + ans->buf_offset, (0x01 << 14) + state);
+    return ans->buf_offset + 2;
+  } else if (state < (1 << 22)) {
+    mem_put_le24(ans->buf + ans->buf_offset, (0x02 << 22) + state);
+    return ans->buf_offset + 3;
+  } else {
+    DRACO_DCHECK(0 && "State is too large to be serialized");
+    return ans->buf_offset;
+  }
+}
+
+// rABS with descending spread.
+// p or p0 takes the place of l_s from the paper.
+// DRACO_ANS_P8_PRECISION is m.
+static inline void rabs_desc_write(struct AnsCoder *ans, int val, AnsP8 p0) {
+  const AnsP8 p = DRACO_ANS_P8_PRECISION - p0;
+  const unsigned l_s = val ? p : p0;
+  unsigned quot, rem;
+  if (ans->state >=
+      DRACO_ANS_L_BASE / DRACO_ANS_P8_PRECISION * DRACO_ANS_IO_BASE * l_s) {
+    ans->buf[ans->buf_offset++] = ans->state % DRACO_ANS_IO_BASE;
+    ans->state /= DRACO_ANS_IO_BASE;
+  }
+  DRACO_ANS_DIVREM(quot, rem, ans->state, l_s);
+  ans->state = quot * DRACO_ANS_P8_PRECISION + rem + (val ? 0 : p);
+}
+
+#define DRACO_ANS_IMPL1 0
+#define UNPREDICTABLE(x) x
+static inline int rabs_desc_read(struct AnsDecoder *ans, AnsP8 p0) {
+  int val;
+#if DRACO_ANS_IMPL1
+  unsigned l_s;
+#else
+  unsigned quot, rem, x, xn;
+#endif
+  const AnsP8 p = DRACO_ANS_P8_PRECISION - p0;
+  if (ans->state < DRACO_ANS_L_BASE && ans->buf_offset > 0) {
+    ans->state = ans->state * DRACO_ANS_IO_BASE + ans->buf[--ans->buf_offset];
+  }
+#if DRACO_ANS_IMPL1
+  val = ans->state % DRACO_ANS_P8_PRECISION < p;
+  l_s = val ? p : p0;
+  ans->state = (ans->state / DRACO_ANS_P8_PRECISION) * l_s +
+               ans->state % DRACO_ANS_P8_PRECISION - (!val * p);
+#else
+  x = ans->state;
+  quot = x / DRACO_ANS_P8_PRECISION;
+  rem = x % DRACO_ANS_P8_PRECISION;
+  xn = quot * p;
+  val = rem < p;
+  if (UNPREDICTABLE(val)) {
+    ans->state = xn + rem;
+  } else {
+    // ans->state = quot * p0 + rem - p;
+    ans->state = x - xn - p;
+  }
+#endif
+  return val;
+}
+
+// rABS with ascending spread.
+// p or p0 takes the place of l_s from the paper.
+// DRACO_ANS_P8_PRECISION is m.
+static inline void rabs_asc_write(struct AnsCoder *ans, int val, AnsP8 p0) {
+  const AnsP8 p = DRACO_ANS_P8_PRECISION - p0;
+  const unsigned l_s = val ? p : p0;
+  unsigned quot, rem;
+  if (ans->state >=
+      DRACO_ANS_L_BASE / DRACO_ANS_P8_PRECISION * DRACO_ANS_IO_BASE * l_s) {
+    ans->buf[ans->buf_offset++] = ans->state % DRACO_ANS_IO_BASE;
+    ans->state /= DRACO_ANS_IO_BASE;
+  }
+  DRACO_ANS_DIVREM(quot, rem, ans->state, l_s);
+  ans->state = quot * DRACO_ANS_P8_PRECISION + rem + (val ? p0 : 0);
+}
+
+static inline int rabs_asc_read(struct AnsDecoder *ans, AnsP8 p0) {
+  int val;
+#if DRACO_ANS_IMPL1
+  unsigned l_s;
+#else
+  unsigned quot, rem, x, xn;
+#endif
+  const AnsP8 p = DRACO_ANS_P8_PRECISION - p0;
+  if (ans->state < DRACO_ANS_L_BASE) {
+    ans->state = ans->state * DRACO_ANS_IO_BASE + ans->buf[--ans->buf_offset];
+  }
+#if DRACO_ANS_IMPL1
+  val = ans->state % DRACO_ANS_P8_PRECISION < p;
+  l_s = val ? p : p0;
+  ans->state = (ans->state / DRACO_ANS_P8_PRECISION) * l_s +
+               ans->state % DRACO_ANS_P8_PRECISION - (!val * p);
+#else
+  x = ans->state;
+  quot = x / DRACO_ANS_P8_PRECISION;
+  rem = x % DRACO_ANS_P8_PRECISION;
+  xn = quot * p;
+  val = rem >= p0;
+  if (UNPREDICTABLE(val)) {
+    ans->state = xn + rem - p0;
+  } else {
+    // ans->state = quot * p0 + rem - p0;
+    ans->state = x - xn;
+  }
+#endif
+  return val;
+}
+
+#define rabs_read rabs_desc_read
+#define rabs_write rabs_desc_write
+
+// uABS with normalization.
+static inline void uabs_write(struct AnsCoder *ans, int val, AnsP8 p0) {
+  AnsP8 p = DRACO_ANS_P8_PRECISION - p0;
+  const unsigned l_s = val ? p : p0;
+  while (ans->state >=
+         DRACO_ANS_L_BASE / DRACO_ANS_P8_PRECISION * DRACO_ANS_IO_BASE * l_s) {
+    ans->buf[ans->buf_offset++] = ans->state % DRACO_ANS_IO_BASE;
+    ans->state /= DRACO_ANS_IO_BASE;
+  }
+  if (!val) {
+    ans->state = DRACO_ANS_DIV(ans->state * DRACO_ANS_P8_PRECISION, p0);
+  } else {
+    ans->state =
+        DRACO_ANS_DIV((ans->state + 1) * DRACO_ANS_P8_PRECISION + p - 1, p) - 1;
+  }
+}
+
+static inline int uabs_read(struct AnsDecoder *ans, AnsP8 p0) {
+  AnsP8 p = DRACO_ANS_P8_PRECISION - p0;
+  int s;
+  // unsigned int xp1;
+  unsigned xp, sp;
+  unsigned state = ans->state;
+  while (state < DRACO_ANS_L_BASE && ans->buf_offset > 0) {
+    state = state * DRACO_ANS_IO_BASE + ans->buf[--ans->buf_offset];
+  }
+  sp = state * p;
+  // xp1 = (sp + p) / DRACO_ANS_P8_PRECISION;
+  xp = sp / DRACO_ANS_P8_PRECISION;
+  // s = xp1 - xp;
+  s = (sp & 0xFF) >= p0;
+  if (UNPREDICTABLE(s)) {
+    ans->state = xp;
+  } else {
+    ans->state = state - xp;
+  }
+  return s;
+}
+
+static inline int uabs_read_bit(struct AnsDecoder *ans) {
+  int s;
+  unsigned state = ans->state;
+  while (state < DRACO_ANS_L_BASE && ans->buf_offset > 0) {
+    state = state * DRACO_ANS_IO_BASE + ans->buf[--ans->buf_offset];
+  }
+  s = static_cast<int>(state & 1);
+  ans->state = state >> 1;
+  return s;
+}
+
+static inline int ans_read_init(struct AnsDecoder *const ans,
+                                const uint8_t *const buf, int offset) {
+  unsigned x;
+  if (offset < 1) {
+    return 1;
+  }
+  ans->buf = buf;
+  x = buf[offset - 1] >> 6;
+  if (x == 0) {
+    ans->buf_offset = offset - 1;
+    ans->state = buf[offset - 1] & 0x3F;
+  } else if (x == 1) {
+    if (offset < 2) {
+      return 1;
+    }
+    ans->buf_offset = offset - 2;
+    ans->state = mem_get_le16(buf + offset - 2) & 0x3FFF;
+  } else if (x == 2) {
+    if (offset < 3) {
+      return 1;
+    }
+    ans->buf_offset = offset - 3;
+    ans->state = mem_get_le24(buf + offset - 3) & 0x3FFFFF;
+  } else {
+    return 1;
+  }
+  ans->state += DRACO_ANS_L_BASE;
+  if (ans->state >= DRACO_ANS_L_BASE * DRACO_ANS_IO_BASE) {
+    return 1;
+  }
+  return 0;
+}
+
+static inline int ans_read_end(struct AnsDecoder *const ans) {
+  return ans->state == DRACO_ANS_L_BASE;
+}
+
+static inline int ans_reader_has_error(const struct AnsDecoder *const ans) {
+  return ans->state < DRACO_ANS_L_BASE && ans->buf_offset == 0;
+}
+
+struct rans_sym {
+  uint32_t prob;
+  uint32_t cum_prob;  // not-inclusive.
+};
+
+// Class for performing rANS encoding using a desired number of precision bits.
+// The max number of precision bits is currently 19. The actual number of
+// symbols in the input alphabet should be (much) smaller than that, otherwise
+// the compression rate may suffer.
+template <int rans_precision_bits_t>
+class RAnsEncoder {
+ public:
+  RAnsEncoder() {}
+
+  // Provides the input buffer where the data is going to be stored.
+  inline void write_init(uint8_t *const buf) {
+    ans_.buf = buf;
+    ans_.buf_offset = 0;
+    ans_.state = l_rans_base;
+  }
+
+  // Needs to be called after all symbols are encoded.
+  inline int write_end() {
+    uint32_t state;
+    DRACO_DCHECK_GE(ans_.state, l_rans_base);
+    DRACO_DCHECK_LT(ans_.state, l_rans_base * DRACO_ANS_IO_BASE);
+    state = ans_.state - l_rans_base;
+    if (state < (1 << 6)) {
+      ans_.buf[ans_.buf_offset] = (0x00 << 6) + state;
+      return ans_.buf_offset + 1;
+    } else if (state < (1 << 14)) {
+      mem_put_le16(ans_.buf + ans_.buf_offset, (0x01 << 14) + state);
+      return ans_.buf_offset + 2;
+    } else if (state < (1 << 22)) {
+      mem_put_le24(ans_.buf + ans_.buf_offset, (0x02 << 22) + state);
+      return ans_.buf_offset + 3;
+    } else if (state < (1 << 30)) {
+      mem_put_le32(ans_.buf + ans_.buf_offset, (0x03u << 30u) + state);
+      return ans_.buf_offset + 4;
+    } else {
+      DRACO_DCHECK(0 && "State is too large to be serialized");
+      return ans_.buf_offset;
+    }
+  }
+
+  // rANS with normalization.
+  // sym->prob takes the place of l_s from the paper.
+  // rans_precision is m.
+  inline void rans_write(const struct rans_sym *const sym) {
+    const uint32_t p = sym->prob;
+    while (ans_.state >= l_rans_base / rans_precision * DRACO_ANS_IO_BASE * p) {
+      ans_.buf[ans_.buf_offset++] = ans_.state % DRACO_ANS_IO_BASE;
+      ans_.state /= DRACO_ANS_IO_BASE;
+    }
+    // TODO(ostava): The division and multiplication should be optimized.
+    ans_.state =
+        (ans_.state / p) * rans_precision + ans_.state % p + sym->cum_prob;
+  }
+
+ private:
+  static constexpr int rans_precision = 1 << rans_precision_bits_t;
+  static constexpr int l_rans_base = rans_precision * 4;
+  AnsCoder ans_;
+};
+
+struct rans_dec_sym {
+  uint32_t val;
+  uint32_t prob;
+  uint32_t cum_prob;  // not-inclusive.
+};
+
+// Class for performing rANS decoding using a desired number of precision bits.
+// The number of precision bits needs to be the same as with the RAnsEncoder
+// that was used to encode the input data.
+template <int rans_precision_bits_t>
+class RAnsDecoder {
+ public:
+  RAnsDecoder() {}
+
+  // Initializes the decoder from the input buffer. The |offset| specifies the
+  // number of bytes encoded by the encoder. A non zero return value is an
+  // error.
+  inline int read_init(const uint8_t *const buf, int offset) {
+    unsigned x;
+    if (offset < 1) {
+      return 1;
+    }
+    ans_.buf = buf;
+    x = buf[offset - 1] >> 6;
+    if (x == 0) {
+      ans_.buf_offset = offset - 1;
+      ans_.state = buf[offset - 1] & 0x3F;
+    } else if (x == 1) {
+      if (offset < 2) {
+        return 1;
+      }
+      ans_.buf_offset = offset - 2;
+      ans_.state = mem_get_le16(buf + offset - 2) & 0x3FFF;
+    } else if (x == 2) {
+      if (offset < 3) {
+        return 1;
+      }
+      ans_.buf_offset = offset - 3;
+      ans_.state = mem_get_le24(buf + offset - 3) & 0x3FFFFF;
+    } else if (x == 3) {
+      ans_.buf_offset = offset - 4;
+      ans_.state = mem_get_le32(buf + offset - 4) & 0x3FFFFFFF;
+    } else {
+      return 1;
+    }
+    ans_.state += l_rans_base;
+    if (ans_.state >= l_rans_base * DRACO_ANS_IO_BASE) {
+      return 1;
+    }
+    return 0;
+  }
+
+  inline int read_end() { return ans_.state == l_rans_base; }
+
+  inline int reader_has_error() {
+    return ans_.state < l_rans_base && ans_.buf_offset == 0;
+  }
+
+  inline int rans_read() {
+    unsigned rem;
+    unsigned quo;
+    struct rans_dec_sym sym;
+    while (ans_.state < l_rans_base && ans_.buf_offset > 0) {
+      ans_.state = ans_.state * DRACO_ANS_IO_BASE + ans_.buf[--ans_.buf_offset];
+    }
+    // |rans_precision| is a power of two compile time constant, and the below
+    // division and modulo are going to be optimized by the compiler.
+    quo = ans_.state / rans_precision;
+    rem = ans_.state % rans_precision;
+    fetch_sym(&sym, rem);
+    ans_.state = quo * sym.prob + rem - sym.cum_prob;
+    return sym.val;
+  }
+
+  // Construct a lookup table with |rans_precision| number of entries.
+  // Returns false if the table couldn't be built (because of wrong input data).
+  inline bool rans_build_look_up_table(const uint32_t token_probs[],
+                                       uint32_t num_symbols) {
+    lut_table_.resize(rans_precision);
+    probability_table_.resize(num_symbols);
+    uint32_t cum_prob = 0;
+    uint32_t act_prob = 0;
+    for (uint32_t i = 0; i < num_symbols; ++i) {
+      probability_table_[i].prob = token_probs[i];
+      probability_table_[i].cum_prob = cum_prob;
+      cum_prob += token_probs[i];
+      if (cum_prob > rans_precision) {
+        return false;
+      }
+      for (uint32_t j = act_prob; j < cum_prob; ++j) {
+        lut_table_[j] = i;
+      }
+      act_prob = cum_prob;
+    }
+    if (cum_prob != rans_precision) {
+      return false;
+    }
+    return true;
+  }
+
+ private:
+  inline void fetch_sym(struct rans_dec_sym *out, uint32_t rem) {
+    uint32_t symbol = lut_table_[rem];
+    out->val = symbol;
+    out->prob = probability_table_[symbol].prob;
+    out->cum_prob = probability_table_[symbol].cum_prob;
+  }
+
+  static constexpr int rans_precision = 1 << rans_precision_bits_t;
+  static constexpr int l_rans_base = rans_precision * 4;
+  std::vector<uint32_t> lut_table_;
+  std::vector<rans_sym> probability_table_;
+  AnsDecoder ans_;
+};
+
+#undef DRACO_ANS_DIVREM
+#undef DRACO_ANS_P8_PRECISION
+#undef DRACO_ANS_L_BASE
+#undef DRACO_ANS_IO_BASE
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ENTROPY_ANS_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/rans_symbol_coding.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/rans_symbol_coding.h
new file mode 100644
index 000000000..cd4271193
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/rans_symbol_coding.h
@@ -0,0 +1,53 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File providing shared functionality for RAnsSymbolEncoder and
+// RAnsSymbolDecoder (see rans_symbol_encoder.h / rans_symbol_decoder.h).
+#ifndef DRACO_COMPRESSION_ENTROPY_RANS_SYMBOL_CODING_H_
+#define DRACO_COMPRESSION_ENTROPY_RANS_SYMBOL_CODING_H_
+
+#include "draco/compression/entropy/ans.h"
+
+namespace draco {
+
+// Computes the desired precision of the rANS method for the specified number of
+// unique symbols the input data (defined by their bit_length).
+constexpr int ComputeRAnsUnclampedPrecision(int symbols_bit_length) {
+  return (3 * symbols_bit_length) / 2;
+}
+
+// Computes the desired precision clamped to guarantee a valid functionality of
+// our rANS library (which is between 12 to 20 bits).
+constexpr int ComputeRAnsPrecisionFromUniqueSymbolsBitLength(
+    int symbols_bit_length) {
+  return ComputeRAnsUnclampedPrecision(symbols_bit_length) < 12 ? 12
+         : ComputeRAnsUnclampedPrecision(symbols_bit_length) > 20
+             ? 20
+             : ComputeRAnsUnclampedPrecision(symbols_bit_length);
+}
+
+// Compute approximate frequency table size needed for storing the provided
+// symbols.
+static inline int64_t ApproximateRAnsFrequencyTableBits(
+    int32_t max_value, int num_unique_symbols) {
+  // Approximate number of bits for storing zero frequency entries using the
+  // run length encoding (with max length of 64).
+  const int64_t table_zero_frequency_bits =
+      8 * (num_unique_symbols + (max_value - num_unique_symbols) / 64);
+  return 8 * num_unique_symbols + table_zero_frequency_bits;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ENTROPY_RANS_SYMBOL_CODING_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/rans_symbol_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/rans_symbol_decoder.h
new file mode 100644
index 000000000..10cdc6781
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/rans_symbol_decoder.h
@@ -0,0 +1,164 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ENTROPY_RANS_SYMBOL_DECODER_H_
+#define DRACO_COMPRESSION_ENTROPY_RANS_SYMBOL_DECODER_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/entropy/rans_symbol_coding.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/varint_decoding.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// A helper class for decoding symbols using the rANS algorithm (see ans.h).
+// The class can be used to decode the probability table and the data encoded
+// by the RAnsSymbolEncoder. |unique_symbols_bit_length_t| must be the same as
+// the one used for the corresponding RAnsSymbolEncoder.
+template <int unique_symbols_bit_length_t>
+class RAnsSymbolDecoder {
+ public:
+  RAnsSymbolDecoder() : num_symbols_(0) {}
+
+  // Initialize the decoder and decode the probability table.
+  bool Create(DecoderBuffer *buffer);
+
+  uint32_t num_symbols() const { return num_symbols_; }
+
+  // Starts decoding from the buffer. The buffer will be advanced past the
+  // encoded data after this call.
+  bool StartDecoding(DecoderBuffer *buffer);
+  uint32_t DecodeSymbol() { return ans_.rans_read(); }
+  void EndDecoding();
+
+ private:
+  static constexpr int rans_precision_bits_ =
+      ComputeRAnsPrecisionFromUniqueSymbolsBitLength(
+          unique_symbols_bit_length_t);
+  static constexpr int rans_precision_ = 1 << rans_precision_bits_;
+
+  std::vector<uint32_t> probability_table_;
+  uint32_t num_symbols_;
+  RAnsDecoder<rans_precision_bits_> ans_;
+};
+
+template <int unique_symbols_bit_length_t>
+bool RAnsSymbolDecoder<unique_symbols_bit_length_t>::Create(
+    DecoderBuffer *buffer) {
+  // Check that the DecoderBuffer version is set.
+  if (buffer->bitstream_version() == 0) {
+    return false;
+  }
+  // Decode the number of alphabet symbols.
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (buffer->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+    if (!buffer->Decode(&num_symbols_)) {
+      return false;
+    }
+
+  } else
+#endif
+  {
+    if (!DecodeVarint(&num_symbols_, buffer)) {
+      return false;
+    }
+  }
+  probability_table_.resize(num_symbols_);
+  if (num_symbols_ == 0) {
+    return true;
+  }
+  // Decode the table.
+  for (uint32_t i = 0; i < num_symbols_; ++i) {
+    uint8_t prob_data = 0;
+    // Decode the first byte and extract the number of extra bytes we need to
+    // get, or the offset to the next symbol with non-zero probability.
+    if (!buffer->Decode(&prob_data)) {
+      return false;
+    }
+    // Token is stored in the first two bits of the first byte. Values 0-2 are
+    // used to indicate the number of extra bytes, and value 3 is a special
+    // symbol used to denote run-length coding of zero probability entries.
+    // See rans_symbol_encoder.h for more details.
+    const int token = prob_data & 3;
+    if (token == 3) {
+      const uint32_t offset = prob_data >> 2;
+      if (i + offset >= num_symbols_) {
+        return false;
+      }
+      // Set zero probability for all symbols in the specified range.
+      for (uint32_t j = 0; j < offset + 1; ++j) {
+        probability_table_[i + j] = 0;
+      }
+      i += offset;
+    } else {
+      const int extra_bytes = token;
+      uint32_t prob = prob_data >> 2;
+      for (int b = 0; b < extra_bytes; ++b) {
+        uint8_t eb;
+        if (!buffer->Decode(&eb)) {
+          return false;
+        }
+        // Shift 8 bits for each extra byte and subtract 2 for the two first
+        // bits.
+        prob |= static_cast<uint32_t>(eb) << (8 * (b + 1) - 2);
+      }
+      probability_table_[i] = prob;
+    }
+  }
+  if (!ans_.rans_build_look_up_table(&probability_table_[0], num_symbols_)) {
+    return false;
+  }
+  return true;
+}
+
+template <int unique_symbols_bit_length_t>
+bool RAnsSymbolDecoder<unique_symbols_bit_length_t>::StartDecoding(
+    DecoderBuffer *buffer) {
+  uint64_t bytes_encoded;
+  // Decode the number of bytes encoded by the encoder.
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (buffer->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+    if (!buffer->Decode(&bytes_encoded)) {
+      return false;
+    }
+
+  } else
+#endif
+  {
+    if (!DecodeVarint<uint64_t>(&bytes_encoded, buffer)) {
+      return false;
+    }
+  }
+  if (bytes_encoded > static_cast<uint64_t>(buffer->remaining_size())) {
+    return false;
+  }
+  const uint8_t *const data_head =
+      reinterpret_cast<const uint8_t *>(buffer->data_head());
+  // Advance the buffer past the rANS data.
+  buffer->Advance(bytes_encoded);
+  if (ans_.read_init(data_head, static_cast<int>(bytes_encoded)) != 0) {
+    return false;
+  }
+  return true;
+}
+
+template <int unique_symbols_bit_length_t>
+void RAnsSymbolDecoder<unique_symbols_bit_length_t>::EndDecoding() {
+  ans_.read_end();
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ENTROPY_RANS_SYMBOL_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/rans_symbol_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/rans_symbol_encoder.h
new file mode 100644
index 000000000..4e07ec871
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/rans_symbol_encoder.h
@@ -0,0 +1,290 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ENTROPY_RANS_SYMBOL_ENCODER_H_
+#define DRACO_COMPRESSION_ENTROPY_RANS_SYMBOL_ENCODER_H_
+
+#include <algorithm>
+#include <cmath>
+#include <cstring>
+
+#include "draco/compression/entropy/ans.h"
+#include "draco/compression/entropy/rans_symbol_coding.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/varint_encoding.h"
+
+namespace draco {
+
+// A helper class for encoding symbols using the rANS algorithm (see ans.h).
+// The class can be used to initialize and encode probability table needed by
+// rANS, and to perform encoding of symbols into the provided EncoderBuffer.
+template <int unique_symbols_bit_length_t>
+class RAnsSymbolEncoder {
+ public:
+  RAnsSymbolEncoder()
+      : num_symbols_(0), num_expected_bits_(0), buffer_offset_(0) {}
+
+  // Creates a probability table needed by the rANS library and encode it into
+  // the provided buffer.
+  bool Create(const uint64_t *frequencies, int num_symbols,
+              EncoderBuffer *buffer);
+
+  void StartEncoding(EncoderBuffer *buffer);
+  void EncodeSymbol(uint32_t symbol) {
+    ans_.rans_write(&probability_table_[symbol]);
+  }
+  void EndEncoding(EncoderBuffer *buffer);
+
+  // rANS requires to encode the input symbols in the reverse order.
+  static constexpr bool needs_reverse_encoding() { return true; }
+
+ private:
+  // Functor used for sorting symbol ids according to their probabilities.
+  // The functor sorts symbol indices that index an underlying map between
+  // symbol ids and their probabilities. We don't sort the probability table
+  // directly, because that would require an additional indirection during the
+  // EncodeSymbol() function.
+  struct ProbabilityLess {
+    explicit ProbabilityLess(const std::vector<rans_sym> *probs)
+        : probabilities(probs) {}
+    bool operator()(int i, int j) const {
+      return probabilities->at(i).prob < probabilities->at(j).prob;
+    }
+    const std::vector<rans_sym> *probabilities;
+  };
+
+  // Encodes the probability table into the output buffer.
+  bool EncodeTable(EncoderBuffer *buffer);
+
+  static constexpr int rans_precision_bits_ =
+      ComputeRAnsPrecisionFromUniqueSymbolsBitLength(
+          unique_symbols_bit_length_t);
+  static constexpr int rans_precision_ = 1 << rans_precision_bits_;
+
+  std::vector<rans_sym> probability_table_;
+  // The number of symbols in the input alphabet.
+  uint32_t num_symbols_;
+  // Expected number of bits that is needed to encode the input.
+  uint64_t num_expected_bits_;
+
+  RAnsEncoder<rans_precision_bits_> ans_;
+  // Initial offset of the encoder buffer before any ans data was encoded.
+  uint64_t buffer_offset_;
+};
+
+template <int unique_symbols_bit_length_t>
+bool RAnsSymbolEncoder<unique_symbols_bit_length_t>::Create(
+    const uint64_t *frequencies, int num_symbols, EncoderBuffer *buffer) {
+  // Compute the total of the input frequencies.
+  uint64_t total_freq = 0;
+  int max_valid_symbol = 0;
+  for (int i = 0; i < num_symbols; ++i) {
+    total_freq += frequencies[i];
+    if (frequencies[i] > 0) {
+      max_valid_symbol = i;
+    }
+  }
+  num_symbols = max_valid_symbol + 1;
+  num_symbols_ = num_symbols;
+  probability_table_.resize(num_symbols);
+  const double total_freq_d = static_cast<double>(total_freq);
+  const double rans_precision_d = static_cast<double>(rans_precision_);
+  // Compute probabilities by rescaling the normalized frequencies into interval
+  // [1, rans_precision - 1]. The total probability needs to be equal to
+  // rans_precision.
+  int total_rans_prob = 0;
+  for (int i = 0; i < num_symbols; ++i) {
+    const uint64_t freq = frequencies[i];
+
+    // Normalized probability.
+    const double prob = static_cast<double>(freq) / total_freq_d;
+
+    // RAns probability in range of [1, rans_precision - 1].
+    uint32_t rans_prob = static_cast<uint32_t>(prob * rans_precision_d + 0.5f);
+    if (rans_prob == 0 && freq > 0) {
+      rans_prob = 1;
+    }
+    probability_table_[i].prob = rans_prob;
+    total_rans_prob += rans_prob;
+  }
+  // Because of rounding errors, the total precision may not be exactly accurate
+  // and we may need to adjust the entries a little bit.
+  if (total_rans_prob != rans_precision_) {
+    std::vector<int> sorted_probabilities(num_symbols);
+    for (int i = 0; i < num_symbols; ++i) {
+      sorted_probabilities[i] = i;
+    }
+    std::sort(sorted_probabilities.begin(), sorted_probabilities.end(),
+              ProbabilityLess(&probability_table_));
+    if (total_rans_prob < rans_precision_) {
+      // This happens rather infrequently, just add the extra needed precision
+      // to the most frequent symbol.
+      probability_table_[sorted_probabilities.back()].prob +=
+          rans_precision_ - total_rans_prob;
+    } else {
+      // We have over-allocated the precision, which is quite common.
+      // Rescale the probabilities of all symbols.
+      int32_t error = total_rans_prob - rans_precision_;
+      while (error > 0) {
+        const double act_total_prob_d = static_cast<double>(total_rans_prob);
+        const double act_rel_error_d = rans_precision_d / act_total_prob_d;
+        for (int j = num_symbols - 1; j > 0; --j) {
+          int symbol_id = sorted_probabilities[j];
+          if (probability_table_[symbol_id].prob <= 1) {
+            if (j == num_symbols - 1) {
+              return false;  // Most frequent symbol would be empty.
+            }
+            break;
+          }
+          const int32_t new_prob = static_cast<int32_t>(
+              floor(act_rel_error_d *
+                    static_cast<double>(probability_table_[symbol_id].prob)));
+          int32_t fix = probability_table_[symbol_id].prob - new_prob;
+          if (fix == 0u) {
+            fix = 1;
+          }
+          if (fix >= static_cast<int32_t>(probability_table_[symbol_id].prob)) {
+            fix = probability_table_[symbol_id].prob - 1;
+          }
+          if (fix > error) {
+            fix = error;
+          }
+          probability_table_[symbol_id].prob -= fix;
+          total_rans_prob -= fix;
+          error -= fix;
+          if (total_rans_prob == rans_precision_) {
+            break;
+          }
+        }
+      }
+    }
+  }
+
+  // Compute the cumulative probability (cdf).
+  uint32_t total_prob = 0;
+  for (int i = 0; i < num_symbols; ++i) {
+    probability_table_[i].cum_prob = total_prob;
+    total_prob += probability_table_[i].prob;
+  }
+  if (total_prob != rans_precision_) {
+    return false;
+  }
+
+  // Estimate the number of bits needed to encode the input.
+  // From Shannon entropy the total number of bits N is:
+  //   N = -sum{i : all_symbols}(F(i) * log2(P(i)))
+  // where P(i) is the normalized probability of symbol i and F(i) is the
+  // symbol's frequency in the input data.
+  double num_bits = 0;
+  for (int i = 0; i < num_symbols; ++i) {
+    if (probability_table_[i].prob == 0) {
+      continue;
+    }
+    const double norm_prob =
+        static_cast<double>(probability_table_[i].prob) / rans_precision_d;
+    num_bits += static_cast<double>(frequencies[i]) * log2(norm_prob);
+  }
+  num_expected_bits_ = static_cast<uint64_t>(ceil(-num_bits));
+  if (!EncodeTable(buffer)) {
+    return false;
+  }
+  return true;
+}
+
+template <int unique_symbols_bit_length_t>
+bool RAnsSymbolEncoder<unique_symbols_bit_length_t>::EncodeTable(
+    EncoderBuffer *buffer) {
+  EncodeVarint(num_symbols_, buffer);
+  // Use varint encoding for the probabilities (first two bits represent the
+  // number of bytes used - 1).
+  for (uint32_t i = 0; i < num_symbols_; ++i) {
+    const uint32_t prob = probability_table_[i].prob;
+    int num_extra_bytes = 0;
+    if (prob >= (1 << 6)) {
+      num_extra_bytes++;
+      if (prob >= (1 << 14)) {
+        num_extra_bytes++;
+        if (prob >= (1 << 22)) {
+          // The maximum number of precision bits is 20 so we should not really
+          // get to this point.
+          return false;
+        }
+      }
+    }
+    if (prob == 0) {
+      // When the probability of the symbol is 0, set the first two bits to 1
+      // (unique identifier) and use the remaining 6 bits to store the offset
+      // to the next symbol with non-zero probability.
+      uint32_t offset = 0;
+      for (; offset < (1 << 6) - 1; ++offset) {
+        // Note: we don't have to check whether the next symbol id is larger
+        // than num_symbols_ because we know that the last symbol always has
+        // non-zero probability.
+        const uint32_t next_prob = probability_table_[i + offset + 1].prob;
+        if (next_prob > 0) {
+          break;
+        }
+      }
+      buffer->Encode(static_cast<uint8_t>((offset << 2) | 3));
+      i += offset;
+    } else {
+      // Encode the first byte (including the number of extra bytes).
+      buffer->Encode(static_cast<uint8_t>((prob << 2) | (num_extra_bytes & 3)));
+      // Encode the extra bytes.
+      for (int b = 0; b < num_extra_bytes; ++b) {
+        buffer->Encode(static_cast<uint8_t>(prob >> (8 * (b + 1) - 2)));
+      }
+    }
+  }
+  return true;
+}
+
+template <int unique_symbols_bit_length_t>
+void RAnsSymbolEncoder<unique_symbols_bit_length_t>::StartEncoding(
+    EncoderBuffer *buffer) {
+  // Allocate extra storage just in case.
+  const uint64_t required_bits = 2 * num_expected_bits_ + 32;
+
+  buffer_offset_ = buffer->size();
+  const int64_t required_bytes = (required_bits + 7) / 8;
+  buffer->Resize(buffer_offset_ + required_bytes + sizeof(buffer_offset_));
+  uint8_t *const data =
+      reinterpret_cast<uint8_t *>(const_cast<char *>(buffer->data()));
+  ans_.write_init(data + buffer_offset_);
+}
+
+template <int unique_symbols_bit_length_t>
+void RAnsSymbolEncoder<unique_symbols_bit_length_t>::EndEncoding(
+    EncoderBuffer *buffer) {
+  char *const src = const_cast<char *>(buffer->data()) + buffer_offset_;
+
+  // TODO(fgalligan): Look into changing this to uint32_t as write_end()
+  // returns an int.
+  const uint64_t bytes_written = static_cast<uint64_t>(ans_.write_end());
+  EncoderBuffer var_size_buffer;
+  EncodeVarint(bytes_written, &var_size_buffer);
+  const uint32_t size_len = static_cast<uint32_t>(var_size_buffer.size());
+  char *const dst = src + size_len;
+  memmove(dst, src, bytes_written);
+
+  // Store the size of the encoded data.
+  memcpy(src, var_size_buffer.data(), size_len);
+
+  // Resize the buffer to match the number of encoded bytes.
+  buffer->Resize(buffer_offset_ + bytes_written + size_len);
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ENTROPY_RANS_SYMBOL_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/shannon_entropy.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/shannon_entropy.cc
new file mode 100644
index 000000000..137eafe5f
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/shannon_entropy.cc
@@ -0,0 +1,147 @@
+#include "draco/compression/entropy/shannon_entropy.h"
+
+#include <cmath>
+#include <vector>
+
+#include "draco/compression/entropy/rans_symbol_coding.h"
+
+namespace draco {
+
+int64_t ComputeShannonEntropy(const uint32_t *symbols, int num_symbols,
+                              int max_value, int *out_num_unique_symbols) {
+  // First find frequency of all unique symbols in the input array.
+  int num_unique_symbols = 0;
+  std::vector<int> symbol_frequencies(max_value + 1, 0);
+  for (int i = 0; i < num_symbols; ++i) {
+    ++symbol_frequencies[symbols[i]];
+  }
+  double total_bits = 0;
+  double num_symbols_d = num_symbols;
+  for (int i = 0; i < max_value + 1; ++i) {
+    if (symbol_frequencies[i] > 0) {
+      ++num_unique_symbols;
+      // Compute Shannon entropy for the symbol.
+      // We don't want to use std::log2 here for Android build.
+      total_bits +=
+          symbol_frequencies[i] *
+          log2(static_cast<double>(symbol_frequencies[i]) / num_symbols_d);
+    }
+  }
+  if (out_num_unique_symbols) {
+    *out_num_unique_symbols = num_unique_symbols;
+  }
+  // Entropy is always negative.
+  return static_cast<int64_t>(-total_bits);
+}
+
+double ComputeBinaryShannonEntropy(uint32_t num_values,
+                                   uint32_t num_true_values) {
+  if (num_values == 0) {
+    return 0;
+  }
+
+  // We can exit early if the data set has 0 entropy.
+  if (num_true_values == 0 || num_values == num_true_values) {
+    return 0;
+  }
+  const double true_freq =
+      static_cast<double>(num_true_values) / static_cast<double>(num_values);
+  const double false_freq = 1.0 - true_freq;
+  return -(true_freq * std::log2(true_freq) +
+           false_freq * std::log2(false_freq));
+}
+
+ShannonEntropyTracker::ShannonEntropyTracker() {}
+
+ShannonEntropyTracker::EntropyData ShannonEntropyTracker::Peek(
+    const uint32_t *symbols, int num_symbols) {
+  return UpdateSymbols(symbols, num_symbols, false);
+}
+
+ShannonEntropyTracker::EntropyData ShannonEntropyTracker::Push(
+    const uint32_t *symbols, int num_symbols) {
+  return UpdateSymbols(symbols, num_symbols, true);
+}
+
+ShannonEntropyTracker::EntropyData ShannonEntropyTracker::UpdateSymbols(
+    const uint32_t *symbols, int num_symbols, bool push_changes) {
+  EntropyData ret_data = entropy_data_;
+  ret_data.num_values += num_symbols;
+  for (int i = 0; i < num_symbols; ++i) {
+    const uint32_t symbol = symbols[i];
+    if (frequencies_.size() <= symbol) {
+      frequencies_.resize(symbol + 1, 0);
+    }
+
+    // Update the entropy of the stream. Note that entropy of |N| values
+    // represented by |S| unique symbols is defined as:
+    //
+    //  entropy = -sum_over_S(symbol_frequency / N * log2(symbol_frequency / N))
+    //
+    // To avoid the need to recompute the entire sum when new values are added,
+    // we can instead update a so called entropy norm that is defined as:
+    //
+    //  entropy_norm = sum_over_S(symbol_frequency * log2(symbol_frequency))
+    //
+    // In this case, all we need to do is update entries on the symbols where
+    // the frequency actually changed.
+    //
+    // Note that entropy_norm and entropy can be easily transformed to the
+    // actual entropy as:
+    //
+    //  entropy = log2(N) - entropy_norm / N
+    //
+    double old_symbol_entropy_norm = 0;
+    int &frequency = frequencies_[symbol];
+    if (frequency > 1) {
+      old_symbol_entropy_norm = frequency * std::log2(frequency);
+    } else if (frequency == 0) {
+      ret_data.num_unique_symbols++;
+      if (symbol > static_cast<uint32_t>(ret_data.max_symbol)) {
+        ret_data.max_symbol = symbol;
+      }
+    }
+    frequency++;
+    const double new_symbol_entropy_norm = frequency * std::log2(frequency);
+
+    // Update the final entropy.
+    ret_data.entropy_norm += new_symbol_entropy_norm - old_symbol_entropy_norm;
+  }
+  if (push_changes) {
+    // Update entropy data of the stream.
+    entropy_data_ = ret_data;
+  } else {
+    // We are only peeking so do not update the stream.
+    // Revert changes in the frequency table.
+    for (int i = 0; i < num_symbols; ++i) {
+      const uint32_t symbol = symbols[i];
+      frequencies_[symbol]--;
+    }
+  }
+  return ret_data;
+}
+
+int64_t ShannonEntropyTracker::GetNumberOfDataBits(
+    const EntropyData &entropy_data) {
+  if (entropy_data.num_values < 2) {
+    return 0;
+  }
+  // We need to compute the number of bits required to represent the stream
+  // using the entropy norm. Note that:
+  //
+  //   entropy = log2(num_values) - entropy_norm / num_values
+  //
+  // and number of bits required for the entropy is: num_values * entropy
+  //
+  return static_cast<int64_t>(
+      ceil(entropy_data.num_values * std::log2(entropy_data.num_values) -
+           entropy_data.entropy_norm));
+}
+
+int64_t ShannonEntropyTracker::GetNumberOfRAnsTableBits(
+    const EntropyData &entropy_data) {
+  return ApproximateRAnsFrequencyTableBits(entropy_data.max_symbol + 1,
+                                           entropy_data.num_unique_symbols);
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/shannon_entropy.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/shannon_entropy.h
new file mode 100644
index 000000000..85165f4cb
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/shannon_entropy.h
@@ -0,0 +1,110 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ENTROPY_SHANNON_ENTROPY_H_
+#define DRACO_COMPRESSION_ENTROPY_SHANNON_ENTROPY_H_
+
+#include <stdint.h>
+
+#include <vector>
+
+namespace draco {
+
+// Computes an approximate Shannon entropy of symbols stored in the provided
+// input array |symbols|. The entropy corresponds to the number of bits that is
+// required to represent/store all the symbols using an optimal entropy coding
+// algorithm. See for example "A mathematical theory of communication" by
+// Shannon'48 (http://ieeexplore.ieee.org/document/6773024/).
+//
+// |max_value| is a required input that define the maximum value in the input
+// |symbols| array.
+//
+// |out_num_unique_symbols| is an optional output argument that stores the
+// number of unique symbols contained within the |symbols| array.
+// TODO(ostava): This should be renamed or the return value should be changed to
+// return the actual entropy and not the number of bits needed to represent the
+// input symbols.
+int64_t ComputeShannonEntropy(const uint32_t *symbols, int num_symbols,
+                              int max_value, int *out_num_unique_symbols);
+
+// Computes the Shannon entropy of |num_values| Boolean entries, where
+// |num_true_values| are set to true.
+// Returns entropy between 0-1.
+double ComputeBinaryShannonEntropy(uint32_t num_values,
+                                   uint32_t num_true_values);
+
+// Class that can be used to keep track of the Shannon entropy on streamed data.
+// As new symbols are pushed to the tracker, the entropy is automatically
+// recomputed. The class also support recomputing the entropy without actually
+// pushing the symbols to the tracker through the Peek() method.
+class ShannonEntropyTracker {
+ public:
+  ShannonEntropyTracker();
+
+  // Struct for holding entropy data about the symbols added to the tracker.
+  // It can be used to compute the number of bits needed to store the data using
+  // the method:
+  //   ShannonEntropyTracker::GetNumberOfDataBits(entropy_data);
+  // or to compute the approximate size of the frequency table needed by the
+  // rans coding using method:
+  //   ShannonEntropyTracker::GetNumberOfRAnsTableBits(entropy_data);
+  struct EntropyData {
+    double entropy_norm;
+    int num_values;
+    int max_symbol;
+    int num_unique_symbols;
+    EntropyData()
+        : entropy_norm(0.0),
+          num_values(0),
+          max_symbol(0),
+          num_unique_symbols(0) {}
+  };
+
+  // Adds new symbols to the tracker and recomputes the entropy accordingly.
+  EntropyData Push(const uint32_t *symbols, int num_symbols);
+
+  // Returns new entropy data for the tracker as if |symbols| were added to the
+  // tracker without actually changing the status of the tracker.
+  EntropyData Peek(const uint32_t *symbols, int num_symbols);
+
+  // Gets the number of bits needed for encoding symbols added to the tracker.
+  int64_t GetNumberOfDataBits() const {
+    return GetNumberOfDataBits(entropy_data_);
+  }
+
+  // Gets the number of bits needed for encoding frequency table using the rans
+  // encoder.
+  int64_t GetNumberOfRAnsTableBits() const {
+    return GetNumberOfRAnsTableBits(entropy_data_);
+  }
+
+  // Gets the number of bits needed for encoding given |entropy_data|.
+  static int64_t GetNumberOfDataBits(const EntropyData &entropy_data);
+
+  // Gets the number of bits needed for encoding frequency table using the rans
+  // encoder for the given |entropy_data|.
+  static int64_t GetNumberOfRAnsTableBits(const EntropyData &entropy_data);
+
+ private:
+  EntropyData UpdateSymbols(const uint32_t *symbols, int num_symbols,
+                            bool push_changes);
+
+  std::vector<int32_t> frequencies_;
+
+  EntropyData entropy_data_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ENTROPY_SHANNON_ENTROPY_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/shannon_entropy_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/shannon_entropy_test.cc
new file mode 100644
index 000000000..732c7d2fb
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/shannon_entropy_test.cc
@@ -0,0 +1,58 @@
+#include "draco/compression/entropy/shannon_entropy.h"
+
+#include "draco/core/draco_test_base.h"
+
+namespace {
+
+TEST(ShannonEntropyTest, TestBinaryEntropy) {
+  // Test verifies that computing binary entropy works as expected.
+  ASSERT_EQ(draco::ComputeBinaryShannonEntropy(0, 0), 0);
+  ASSERT_EQ(draco::ComputeBinaryShannonEntropy(10, 0), 0);
+  ASSERT_EQ(draco::ComputeBinaryShannonEntropy(10, 10), 0);
+  ASSERT_NEAR(draco::ComputeBinaryShannonEntropy(10, 5), 1.0, 1e-4);
+}
+
+TEST(ShannonEntropyTest, TestStreamEntropy) {
+  // Test verifies that the entropy of streamed data is computed correctly.
+  const std::vector<uint32_t> symbols = {1, 5, 1, 100, 2, 1};
+
+  draco::ShannonEntropyTracker entropy_tracker;
+
+  // Nothing added, 0 entropy.
+  ASSERT_EQ(entropy_tracker.GetNumberOfDataBits(), 0);
+
+  // Try to push symbols one by one.
+  uint32_t max_symbol = 0;
+  for (int i = 0; i < symbols.size(); ++i) {
+    if (symbols[i] > max_symbol) {
+      max_symbol = symbols[i];
+    }
+    const auto entropy_data = entropy_tracker.Push(&symbols[i], 1);
+
+    const int64_t stream_entropy_bits = entropy_tracker.GetNumberOfDataBits();
+    // Ensure the returned entropy_data is in sync with the stream.
+    ASSERT_EQ(draco::ShannonEntropyTracker::GetNumberOfDataBits(entropy_data),
+              stream_entropy_bits);
+
+    // Make sure the entropy is approximately the same as the one we compute
+    // directly from all symbols.
+    const int64_t expected_entropy_bits = draco::ComputeShannonEntropy(
+        symbols.data(), i + 1, max_symbol, nullptr);
+
+    // For now hardcoded tolerance of 2 bits.
+    ASSERT_NEAR(expected_entropy_bits, stream_entropy_bits, 2);
+  }
+
+  // Compare it also to the case when we add all symbols in one call.
+  draco::ShannonEntropyTracker entropy_tracker_2;
+  entropy_tracker_2.Push(symbols.data(), symbols.size());
+  const int64_t stream_2_entropy_bits = entropy_tracker_2.GetNumberOfDataBits();
+  ASSERT_EQ(entropy_tracker.GetNumberOfDataBits(), stream_2_entropy_bits);
+
+  // Ensure that peeking does not change the entropy.
+  entropy_tracker_2.Peek(symbols.data(), 1);
+
+  ASSERT_EQ(stream_2_entropy_bits, entropy_tracker_2.GetNumberOfDataBits());
+}
+
+}  // namespace
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/symbol_coding_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/symbol_coding_test.cc
new file mode 100644
index 000000000..ba7166bbe
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/symbol_coding_test.cc
@@ -0,0 +1,170 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/entropy/symbol_decoding.h"
+#include "draco/compression/entropy/symbol_encoding.h"
+#include "draco/core/bit_utils.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/draco_test_base.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+class SymbolCodingTest : public ::testing::Test {
+ protected:
+  SymbolCodingTest() : bitstream_version_(kDracoMeshBitstreamVersion) {}
+
+  template <class SignedIntTypeT>
+  void TestConvertToSymbolAndBack(SignedIntTypeT x) {
+    typedef typename std::make_unsigned<SignedIntTypeT>::type Symbol;
+    Symbol symbol = ConvertSignedIntToSymbol(x);
+    SignedIntTypeT y = ConvertSymbolToSignedInt(symbol);
+    ASSERT_EQ(x, y);
+  }
+
+  uint16_t bitstream_version_;
+};
+
+TEST_F(SymbolCodingTest, TestLargeNumbers) {
+  // This test verifies that SymbolCoding successfully encodes an array of large
+  // numbers.
+  const uint32_t in[] = {12345678, 1223333, 111, 5};
+  const int num_values = sizeof(in) / sizeof(uint32_t);
+  EncoderBuffer eb;
+  ASSERT_TRUE(EncodeSymbols(in, num_values, 1, nullptr, &eb));
+
+  std::vector<uint32_t> out;
+  out.resize(num_values);
+  DecoderBuffer db;
+  db.Init(eb.data(), eb.size());
+  db.set_bitstream_version(bitstream_version_);
+  ASSERT_TRUE(DecodeSymbols(num_values, 1, &db, &out[0]));
+  for (int i = 0; i < num_values; ++i) {
+    EXPECT_EQ(in[i], out[i]);
+  }
+}
+
+TEST_F(SymbolCodingTest, TestManyNumbers) {
+  // This test verifies that SymbolCoding successfully encodes an array of
+  // several numbers that repeat many times.
+
+  // Value/frequency pairs.
+  const std::pair<uint32_t, uint32_t> in[] = {
+      {12, 1500}, {1025, 31000}, {7, 1}, {9, 5}, {0, 6432}};
+
+  const int num_pairs = sizeof(in) / sizeof(std::pair<uint32_t, uint32_t>);
+
+  std::vector<uint32_t> in_values;
+  for (int i = 0; i < num_pairs; ++i) {
+    in_values.insert(in_values.end(), in[i].second, in[i].first);
+  }
+  for (int method = 0; method < NUM_SYMBOL_CODING_METHODS; ++method) {
+    // Test the encoding using all available symbol coding methods.
+    Options options;
+    SetSymbolEncodingMethod(&options, static_cast<SymbolCodingMethod>(method));
+
+    EncoderBuffer eb;
+    ASSERT_TRUE(
+        EncodeSymbols(in_values.data(), in_values.size(), 1, &options, &eb));
+    std::vector<uint32_t> out_values;
+    out_values.resize(in_values.size());
+    DecoderBuffer db;
+    db.Init(eb.data(), eb.size());
+    db.set_bitstream_version(bitstream_version_);
+    ASSERT_TRUE(DecodeSymbols(in_values.size(), 1, &db, &out_values[0]));
+    for (uint32_t i = 0; i < in_values.size(); ++i) {
+      ASSERT_EQ(in_values[i], out_values[i]);
+    }
+  }
+}
+
+TEST_F(SymbolCodingTest, TestEmpty) {
+  // This test verifies that SymbolCoding successfully encodes an empty array.
+  EncoderBuffer eb;
+  ASSERT_TRUE(EncodeSymbols(nullptr, 0, 1, nullptr, &eb));
+  DecoderBuffer db;
+  db.Init(eb.data(), eb.size());
+  db.set_bitstream_version(bitstream_version_);
+  ASSERT_TRUE(DecodeSymbols(0, 1, &db, nullptr));
+}
+
+TEST_F(SymbolCodingTest, TestOneSymbol) {
+  // This test verifies that SymbolCoding successfully encodes an a single
+  // symbol.
+  EncoderBuffer eb;
+  const std::vector<uint32_t> in(1200, 0);
+  ASSERT_TRUE(EncodeSymbols(in.data(), in.size(), 1, nullptr, &eb));
+
+  std::vector<uint32_t> out(in.size());
+  DecoderBuffer db;
+  db.Init(eb.data(), eb.size());
+  db.set_bitstream_version(bitstream_version_);
+  ASSERT_TRUE(DecodeSymbols(in.size(), 1, &db, &out[0]));
+  for (uint32_t i = 0; i < in.size(); ++i) {
+    ASSERT_EQ(in[i], out[i]);
+  }
+}
+
+TEST_F(SymbolCodingTest, TestBitLengths) {
+  // This test verifies that SymbolCoding successfully encodes symbols of
+  // various bit lengths
+  EncoderBuffer eb;
+  std::vector<uint32_t> in;
+  constexpr int bit_lengths = 18;
+  for (int i = 0; i < bit_lengths; ++i) {
+    in.push_back(1 << i);
+  }
+  std::vector<uint32_t> out(in.size());
+  for (int i = 0; i < bit_lengths; ++i) {
+    eb.Clear();
+    ASSERT_TRUE(EncodeSymbols(in.data(), i + 1, 1, nullptr, &eb));
+    DecoderBuffer db;
+    db.Init(eb.data(), eb.size());
+    db.set_bitstream_version(bitstream_version_);
+    ASSERT_TRUE(DecodeSymbols(i + 1, 1, &db, &out[0]));
+    for (int j = 0; j < i + 1; ++j) {
+      ASSERT_EQ(in[j], out[j]);
+    }
+  }
+}
+
+TEST_F(SymbolCodingTest, TestLargeNumberCondition) {
+  // This test verifies that SymbolCoding successfully encodes large symbols
+  // that are on the boundary between raw scheme and tagged scheme (18 bits).
+  EncoderBuffer eb;
+  constexpr int num_symbols = 1000000;
+  const std::vector<uint32_t> in(num_symbols, 1 << 18);
+  ASSERT_TRUE(EncodeSymbols(in.data(), in.size(), 1, nullptr, &eb));
+
+  std::vector<uint32_t> out(in.size());
+  DecoderBuffer db;
+  db.Init(eb.data(), eb.size());
+  db.set_bitstream_version(bitstream_version_);
+  ASSERT_TRUE(DecodeSymbols(in.size(), 1, &db, &out[0]));
+  for (uint32_t i = 0; i < in.size(); ++i) {
+    ASSERT_EQ(in[i], out[i]);
+  }
+}
+
+TEST_F(SymbolCodingTest, TestConversionFullRange) {
+  TestConvertToSymbolAndBack(static_cast<int8_t>(-128));
+  TestConvertToSymbolAndBack(static_cast<int8_t>(-127));
+  TestConvertToSymbolAndBack(static_cast<int8_t>(-1));
+  TestConvertToSymbolAndBack(static_cast<int8_t>(0));
+  TestConvertToSymbolAndBack(static_cast<int8_t>(1));
+  TestConvertToSymbolAndBack(static_cast<int8_t>(127));
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/symbol_decoding.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/symbol_decoding.cc
new file mode 100644
index 000000000..93d29971c
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/symbol_decoding.cc
@@ -0,0 +1,181 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/entropy/symbol_decoding.h"
+
+#include <algorithm>
+#include <cmath>
+
+#include "draco/compression/entropy/rans_symbol_decoder.h"
+
+namespace draco {
+
+template <template <int> class SymbolDecoderT>
+bool DecodeTaggedSymbols(uint32_t num_values, int num_components,
+                         DecoderBuffer *src_buffer, uint32_t *out_values);
+
+template <template <int> class SymbolDecoderT>
+bool DecodeRawSymbols(uint32_t num_values, DecoderBuffer *src_buffer,
+                      uint32_t *out_values);
+
+bool DecodeSymbols(uint32_t num_values, int num_components,
+                   DecoderBuffer *src_buffer, uint32_t *out_values) {
+  if (num_values == 0) {
+    return true;
+  }
+  // Decode which scheme to use.
+  uint8_t scheme;
+  if (!src_buffer->Decode(&scheme)) {
+    return false;
+  }
+  if (scheme == SYMBOL_CODING_TAGGED) {
+    return DecodeTaggedSymbols<RAnsSymbolDecoder>(num_values, num_components,
+                                                  src_buffer, out_values);
+  } else if (scheme == SYMBOL_CODING_RAW) {
+    return DecodeRawSymbols<RAnsSymbolDecoder>(num_values, src_buffer,
+                                               out_values);
+  }
+  return false;
+}
+
+template <template <int> class SymbolDecoderT>
+bool DecodeTaggedSymbols(uint32_t num_values, int num_components,
+                         DecoderBuffer *src_buffer, uint32_t *out_values) {
+  // Decode the encoded data.
+  SymbolDecoderT<5> tag_decoder;
+  if (!tag_decoder.Create(src_buffer)) {
+    return false;
+  }
+
+  if (!tag_decoder.StartDecoding(src_buffer)) {
+    return false;
+  }
+
+  if (num_values > 0 && tag_decoder.num_symbols() == 0) {
+    return false;  // Wrong number of symbols.
+  }
+
+  // src_buffer now points behind the encoded tag data (to the place where the
+  // values are encoded).
+  src_buffer->StartBitDecoding(false, nullptr);
+  int value_id = 0;
+  for (uint32_t i = 0; i < num_values; i += num_components) {
+    // Decode the tag.
+    const int bit_length = tag_decoder.DecodeSymbol();
+    // Decode the actual value.
+    for (int j = 0; j < num_components; ++j) {
+      uint32_t val;
+      if (!src_buffer->DecodeLeastSignificantBits32(bit_length, &val)) {
+        return false;
+      }
+      out_values[value_id++] = val;
+    }
+  }
+  tag_decoder.EndDecoding();
+  src_buffer->EndBitDecoding();
+  return true;
+}
+
+template <class SymbolDecoderT>
+bool DecodeRawSymbolsInternal(uint32_t num_values, DecoderBuffer *src_buffer,
+                              uint32_t *out_values) {
+  SymbolDecoderT decoder;
+  if (!decoder.Create(src_buffer)) {
+    return false;
+  }
+
+  if (num_values > 0 && decoder.num_symbols() == 0) {
+    return false;  // Wrong number of symbols.
+  }
+
+  if (!decoder.StartDecoding(src_buffer)) {
+    return false;
+  }
+  for (uint32_t i = 0; i < num_values; ++i) {
+    // Decode a symbol into the value.
+    const uint32_t value = decoder.DecodeSymbol();
+    out_values[i] = value;
+  }
+  decoder.EndDecoding();
+  return true;
+}
+
+template <template <int> class SymbolDecoderT>
+bool DecodeRawSymbols(uint32_t num_values, DecoderBuffer *src_buffer,
+                      uint32_t *out_values) {
+  uint8_t max_bit_length;
+  if (!src_buffer->Decode(&max_bit_length)) {
+    return false;
+  }
+  switch (max_bit_length) {
+    case 1:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<1>>(num_values, src_buffer,
+                                                         out_values);
+    case 2:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<2>>(num_values, src_buffer,
+                                                         out_values);
+    case 3:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<3>>(num_values, src_buffer,
+                                                         out_values);
+    case 4:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<4>>(num_values, src_buffer,
+                                                         out_values);
+    case 5:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<5>>(num_values, src_buffer,
+                                                         out_values);
+    case 6:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<6>>(num_values, src_buffer,
+                                                         out_values);
+    case 7:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<7>>(num_values, src_buffer,
+                                                         out_values);
+    case 8:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<8>>(num_values, src_buffer,
+                                                         out_values);
+    case 9:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<9>>(num_values, src_buffer,
+                                                         out_values);
+    case 10:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<10>>(
+          num_values, src_buffer, out_values);
+    case 11:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<11>>(
+          num_values, src_buffer, out_values);
+    case 12:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<12>>(
+          num_values, src_buffer, out_values);
+    case 13:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<13>>(
+          num_values, src_buffer, out_values);
+    case 14:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<14>>(
+          num_values, src_buffer, out_values);
+    case 15:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<15>>(
+          num_values, src_buffer, out_values);
+    case 16:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<16>>(
+          num_values, src_buffer, out_values);
+    case 17:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<17>>(
+          num_values, src_buffer, out_values);
+    case 18:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<18>>(
+          num_values, src_buffer, out_values);
+    default:
+      return false;
+  }
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/symbol_decoding.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/symbol_decoding.h
new file mode 100644
index 000000000..ea11165c3
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/symbol_decoding.h
@@ -0,0 +1,29 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ENTROPY_SYMBOL_DECODING_H_
+#define DRACO_COMPRESSION_ENTROPY_SYMBOL_DECODING_H_
+
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+
+// Decodes an array of symbols that was previously encoded with an entropy code.
+// Returns false on error.
+bool DecodeSymbols(uint32_t num_values, int num_components,
+                   DecoderBuffer *src_buffer, uint32_t *out_values);
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ENTROPY_SYMBOL_DECODING_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/symbol_encoding.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/symbol_encoding.cc
new file mode 100644
index 000000000..710c96284
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/symbol_encoding.cc
@@ -0,0 +1,376 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/entropy/symbol_encoding.h"
+
+#include <algorithm>
+#include <cmath>
+
+#include "draco/compression/entropy/rans_symbol_encoder.h"
+#include "draco/compression/entropy/shannon_entropy.h"
+#include "draco/core/bit_utils.h"
+#include "draco/core/macros.h"
+
+namespace draco {
+
+constexpr int32_t kMaxTagSymbolBitLength = 32;
+constexpr int kMaxRawEncodingBitLength = 18;
+constexpr int kDefaultSymbolCodingCompressionLevel = 7;
+
+typedef uint64_t TaggedBitLengthFrequencies[kMaxTagSymbolBitLength];
+
+void SetSymbolEncodingMethod(Options *options, SymbolCodingMethod method) {
+  options->SetInt("symbol_encoding_method", method);
+}
+
+bool SetSymbolEncodingCompressionLevel(Options *options,
+                                       int compression_level) {
+  if (compression_level < 0 || compression_level > 10) {
+    return false;
+  }
+  options->SetInt("symbol_encoding_compression_level", compression_level);
+  return true;
+}
+
+// Computes bit lengths of the input values. If num_components > 1, the values
+// are processed in "num_components" sized chunks and the bit length is always
+// computed for the largest value from the chunk.
+static void ComputeBitLengths(const uint32_t *symbols, int num_values,
+                              int num_components,
+                              std::vector<uint32_t> *out_bit_lengths,
+                              uint32_t *out_max_value) {
+  out_bit_lengths->reserve(num_values);
+  *out_max_value = 0;
+  // Maximum integer value across all components.
+  for (int i = 0; i < num_values; i += num_components) {
+    // Get the maximum value for a given entry across all attribute components.
+    uint32_t max_component_value = symbols[i];
+    for (int j = 1; j < num_components; ++j) {
+      if (max_component_value < symbols[i + j]) {
+        max_component_value = symbols[i + j];
+      }
+    }
+    int value_msb_pos = 0;
+    if (max_component_value > 0) {
+      value_msb_pos = MostSignificantBit(max_component_value);
+    }
+    if (max_component_value > *out_max_value) {
+      *out_max_value = max_component_value;
+    }
+    out_bit_lengths->push_back(value_msb_pos + 1);
+  }
+}
+
+static int64_t ApproximateTaggedSchemeBits(
+    const std::vector<uint32_t> bit_lengths, int num_components) {
+  // Compute the total bit length used by all values (the length of data encode
+  // after tags).
+  uint64_t total_bit_length = 0;
+  for (size_t i = 0; i < bit_lengths.size(); ++i) {
+    total_bit_length += bit_lengths[i];
+  }
+  // Compute the number of entropy bits for tags.
+  int num_unique_symbols;
+  const int64_t tag_bits = ComputeShannonEntropy(
+      bit_lengths.data(), static_cast<int>(bit_lengths.size()), 32,
+      &num_unique_symbols);
+  const int64_t tag_table_bits =
+      ApproximateRAnsFrequencyTableBits(num_unique_symbols, num_unique_symbols);
+  return tag_bits + tag_table_bits + total_bit_length * num_components;
+}
+
+static int64_t ApproximateRawSchemeBits(const uint32_t *symbols,
+                                        int num_symbols, uint32_t max_value,
+                                        int *out_num_unique_symbols) {
+  int num_unique_symbols;
+  const int64_t data_bits = ComputeShannonEntropy(
+      symbols, num_symbols, max_value, &num_unique_symbols);
+  const int64_t table_bits =
+      ApproximateRAnsFrequencyTableBits(max_value, num_unique_symbols);
+  *out_num_unique_symbols = num_unique_symbols;
+  return table_bits + data_bits;
+}
+
+template <template <int> class SymbolEncoderT>
+bool EncodeTaggedSymbols(const uint32_t *symbols, int num_values,
+                         int num_components,
+                         const std::vector<uint32_t> &bit_lengths,
+                         EncoderBuffer *target_buffer);
+
+template <template <int> class SymbolEncoderT>
+bool EncodeRawSymbols(const uint32_t *symbols, int num_values,
+                      uint32_t max_entry_value, int32_t num_unique_symbols,
+                      const Options *options, EncoderBuffer *target_buffer);
+
+bool EncodeSymbols(const uint32_t *symbols, int num_values, int num_components,
+                   const Options *options, EncoderBuffer *target_buffer) {
+  if (num_values < 0) {
+    return false;
+  }
+  if (num_values == 0) {
+    return true;
+  }
+  if (num_components <= 0) {
+    num_components = 1;
+  }
+  std::vector<uint32_t> bit_lengths;
+  uint32_t max_value;
+  ComputeBitLengths(symbols, num_values, num_components, &bit_lengths,
+                    &max_value);
+
+  // Approximate number of bits needed for storing the symbols using the tagged
+  // scheme.
+  const int64_t tagged_scheme_total_bits =
+      ApproximateTaggedSchemeBits(bit_lengths, num_components);
+
+  // Approximate number of bits needed for storing the symbols using the raw
+  // scheme.
+  int num_unique_symbols = 0;
+  const int64_t raw_scheme_total_bits = ApproximateRawSchemeBits(
+      symbols, num_values, max_value, &num_unique_symbols);
+
+  // The maximum bit length of a single entry value that we can encode using
+  // the raw scheme.
+  const int max_value_bit_length =
+      MostSignificantBit(std::max(1u, max_value)) + 1;
+
+  int method = -1;
+  if (options != nullptr && options->IsOptionSet("symbol_encoding_method")) {
+    method = options->GetInt("symbol_encoding_method");
+  } else {
+    if (tagged_scheme_total_bits < raw_scheme_total_bits ||
+        max_value_bit_length > kMaxRawEncodingBitLength) {
+      method = SYMBOL_CODING_TAGGED;
+    } else {
+      method = SYMBOL_CODING_RAW;
+    }
+  }
+  // Use the tagged scheme.
+  target_buffer->Encode(static_cast<uint8_t>(method));
+  if (method == SYMBOL_CODING_TAGGED) {
+    return EncodeTaggedSymbols<RAnsSymbolEncoder>(
+        symbols, num_values, num_components, bit_lengths, target_buffer);
+  }
+  if (method == SYMBOL_CODING_RAW) {
+    return EncodeRawSymbols<RAnsSymbolEncoder>(symbols, num_values, max_value,
+                                               num_unique_symbols, options,
+                                               target_buffer);
+  }
+  // Unknown method selected.
+  return false;
+}
+
+template <template <int> class SymbolEncoderT>
+bool EncodeTaggedSymbols(const uint32_t *symbols, int num_values,
+                         int num_components,
+                         const std::vector<uint32_t> &bit_lengths,
+                         EncoderBuffer *target_buffer) {
+  // Create entries for entropy coding. Each entry corresponds to a different
+  // number of bits that are necessary to encode a given value. Every value
+  // has at most 32 bits. Therefore, we need 32 different entries (for
+  // bit_length [1-32]). For each entry we compute the frequency of a given
+  // bit-length in our data set.
+  TaggedBitLengthFrequencies frequencies;
+  // Set frequency for each entry to zero.
+  memset(frequencies, 0, sizeof(frequencies));
+
+  // Compute the frequencies from input data.
+  // Maximum integer value for the values across all components.
+  for (size_t i = 0; i < bit_lengths.size(); ++i) {
+    // Update the frequency of the associated entry id.
+    ++frequencies[bit_lengths[i]];
+  }
+
+  // Create one extra buffer to store raw value.
+  EncoderBuffer value_buffer;
+  // Number of expected bits we need to store the values (can be optimized if
+  // needed).
+  const uint64_t value_bits =
+      kMaxTagSymbolBitLength * static_cast<uint64_t>(num_values);
+
+  // Create encoder for encoding the bit tags.
+  SymbolEncoderT<5> tag_encoder;
+  tag_encoder.Create(frequencies, kMaxTagSymbolBitLength, target_buffer);
+
+  // Start encoding bit tags.
+  tag_encoder.StartEncoding(target_buffer);
+
+  // Also start encoding the values.
+  value_buffer.StartBitEncoding(value_bits, false);
+
+  if (tag_encoder.needs_reverse_encoding()) {
+    // Encoder needs the values to be encoded in the reverse order.
+    for (int i = num_values - num_components; i >= 0; i -= num_components) {
+      const int bit_length = bit_lengths[i / num_components];
+      tag_encoder.EncodeSymbol(bit_length);
+
+      // Values are always encoded in the normal order
+      const int j = num_values - num_components - i;
+      const int value_bit_length = bit_lengths[j / num_components];
+      for (int c = 0; c < num_components; ++c) {
+        value_buffer.EncodeLeastSignificantBits32(value_bit_length,
+                                                  symbols[j + c]);
+      }
+    }
+  } else {
+    for (int i = 0; i < num_values; i += num_components) {
+      const int bit_length = bit_lengths[i / num_components];
+      // First encode the tag.
+      tag_encoder.EncodeSymbol(bit_length);
+      // Now encode all values using the stored bit_length.
+      for (int j = 0; j < num_components; ++j) {
+        value_buffer.EncodeLeastSignificantBits32(bit_length, symbols[i + j]);
+      }
+    }
+  }
+  tag_encoder.EndEncoding(target_buffer);
+  value_buffer.EndBitEncoding();
+
+  // Append the values to the end of the target buffer.
+  target_buffer->Encode(value_buffer.data(), value_buffer.size());
+  return true;
+}
+
+template <class SymbolEncoderT>
+bool EncodeRawSymbolsInternal(const uint32_t *symbols, int num_values,
+                              uint32_t max_entry_value,
+                              EncoderBuffer *target_buffer) {
+  // Count the frequency of each entry value.
+  std::vector<uint64_t> frequencies(max_entry_value + 1, 0);
+  for (int i = 0; i < num_values; ++i) {
+    ++frequencies[symbols[i]];
+  }
+
+  SymbolEncoderT encoder;
+  encoder.Create(frequencies.data(), static_cast<int>(frequencies.size()),
+                 target_buffer);
+  encoder.StartEncoding(target_buffer);
+  // Encode all values.
+  if (SymbolEncoderT::needs_reverse_encoding()) {
+    for (int i = num_values - 1; i >= 0; --i) {
+      encoder.EncodeSymbol(symbols[i]);
+    }
+  } else {
+    for (int i = 0; i < num_values; ++i) {
+      encoder.EncodeSymbol(symbols[i]);
+    }
+  }
+  encoder.EndEncoding(target_buffer);
+  return true;
+}
+
+template <template <int> class SymbolEncoderT>
+bool EncodeRawSymbols(const uint32_t *symbols, int num_values,
+                      uint32_t max_entry_value, int32_t num_unique_symbols,
+                      const Options *options, EncoderBuffer *target_buffer) {
+  int symbol_bits = 0;
+  if (num_unique_symbols > 0) {
+    symbol_bits = MostSignificantBit(num_unique_symbols);
+  }
+  int unique_symbols_bit_length = symbol_bits + 1;
+  // Currently, we don't support encoding of more than 2^18 unique symbols.
+  if (unique_symbols_bit_length > kMaxRawEncodingBitLength) {
+    return false;
+  }
+  int compression_level = kDefaultSymbolCodingCompressionLevel;
+  if (options != nullptr &&
+      options->IsOptionSet("symbol_encoding_compression_level")) {
+    compression_level = options->GetInt("symbol_encoding_compression_level");
+  }
+
+  // Adjust the bit_length based on compression level. Lower compression levels
+  // will use fewer bits while higher compression levels use more bits. Note
+  // that this is going to work for all valid bit_lengths because the actual
+  // number of bits allocated for rANS encoding is hard coded as:
+  // std::max(12, 3 * bit_length / 2) , therefore there will be always a
+  // sufficient number of bits available for all symbols.
+  // See ComputeRAnsPrecisionFromUniqueSymbolsBitLength() for the formula.
+  // This hardcoded equation cannot be changed without changing the bitstream.
+  if (compression_level < 4) {
+    unique_symbols_bit_length -= 2;
+  } else if (compression_level < 6) {
+    unique_symbols_bit_length -= 1;
+  } else if (compression_level > 9) {
+    unique_symbols_bit_length += 2;
+  } else if (compression_level > 7) {
+    unique_symbols_bit_length += 1;
+  }
+  // Clamp the bit_length to a valid range.
+  unique_symbols_bit_length = std::min(std::max(1, unique_symbols_bit_length),
+                                       kMaxRawEncodingBitLength);
+  target_buffer->Encode(static_cast<uint8_t>(unique_symbols_bit_length));
+  // Use appropriate symbol encoder based on the maximum symbol bit length.
+  switch (unique_symbols_bit_length) {
+    case 0:
+      FALLTHROUGH_INTENDED;
+    case 1:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<1>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 2:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<2>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 3:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<3>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 4:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<4>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 5:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<5>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 6:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<6>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 7:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<7>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 8:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<8>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 9:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<9>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 10:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<10>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 11:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<11>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 12:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<12>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 13:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<13>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 14:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<14>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 15:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<15>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 16:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<16>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 17:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<17>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 18:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<18>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    default:
+      return false;
+  }
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/symbol_encoding.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/symbol_encoding.h
new file mode 100644
index 000000000..839b28b17
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/entropy/symbol_encoding.h
@@ -0,0 +1,47 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ENTROPY_SYMBOL_ENCODING_H_
+#define DRACO_COMPRESSION_ENTROPY_SYMBOL_ENCODING_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/options.h"
+
+namespace draco {
+
+// Encodes an array of symbols using an entropy coding. This function
+// automatically decides whether to encode the symbol values using bit
+// length tags (see EncodeTaggedSymbols), or whether to encode them directly
+// (see EncodeRawSymbols). The symbols can be grouped into separate components
+// that can be used for better compression. |options| is an optional parameter
+// that allows more direct control over various stages of the symbol encoding
+// (see below for functions that are used to set valid options).
+// Returns false on error.
+bool EncodeSymbols(const uint32_t *symbols, int num_values, int num_components,
+                   const Options *options, EncoderBuffer *target_buffer);
+
+// Sets an option that forces symbol encoder to use the specified encoding
+// method.
+void SetSymbolEncodingMethod(Options *options, SymbolCodingMethod method);
+
+// Sets the desired compression level for symbol encoding in range <0, 10> where
+// 0 is the worst but fastest compression and 10 is the best but slowest
+// compression. If the option is not set, default value of 7 is used.
+// Returns false if an invalid level has been set.
+bool SetSymbolEncodingCompressionLevel(Options *options, int compression_level);
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ENTROPY_SYMBOL_ENCODING_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/expert_encode.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/expert_encode.cc
new file mode 100644
index 000000000..f9aec15eb
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/expert_encode.cc
@@ -0,0 +1,182 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/expert_encode.h"
+
+#include "draco/compression/mesh/mesh_edgebreaker_encoder.h"
+#include "draco/compression/mesh/mesh_sequential_encoder.h"
+#ifdef DRACO_POINT_CLOUD_COMPRESSION_SUPPORTED
+#include "draco/compression/point_cloud/point_cloud_kd_tree_encoder.h"
+#include "draco/compression/point_cloud/point_cloud_sequential_encoder.h"
+#endif
+
+namespace draco {
+
+ExpertEncoder::ExpertEncoder(const PointCloud &point_cloud)
+    : point_cloud_(&point_cloud), mesh_(nullptr) {}
+
+ExpertEncoder::ExpertEncoder(const Mesh &mesh)
+    : point_cloud_(&mesh), mesh_(&mesh) {}
+
+Status ExpertEncoder::EncodeToBuffer(EncoderBuffer *out_buffer) {
+  if (point_cloud_ == nullptr) {
+    return Status(Status::DRACO_ERROR, "Invalid input geometry.");
+  }
+  if (mesh_ == nullptr) {
+    return EncodePointCloudToBuffer(*point_cloud_, out_buffer);
+  }
+  return EncodeMeshToBuffer(*mesh_, out_buffer);
+}
+
+Status ExpertEncoder::EncodePointCloudToBuffer(const PointCloud &pc,
+                                               EncoderBuffer *out_buffer) {
+#ifdef DRACO_POINT_CLOUD_COMPRESSION_SUPPORTED
+  std::unique_ptr<PointCloudEncoder> encoder;
+  const int encoding_method = options().GetGlobalInt("encoding_method", -1);
+
+  if (encoding_method == POINT_CLOUD_SEQUENTIAL_ENCODING) {
+    // Use sequential encoding if requested.
+    encoder.reset(new PointCloudSequentialEncoder());
+  } else if (encoding_method == -1 && options().GetSpeed() == 10) {
+    // Use sequential encoding if speed is at max.
+    encoder.reset(new PointCloudSequentialEncoder());
+  } else {
+    // Speed < 10, use POINT_CLOUD_KD_TREE_ENCODING if possible.
+    bool kd_tree_possible = true;
+    // Kd-Tree encoder can be currently used only when the following conditions
+    // are satisfied for all attributes:
+    //     -data type is float32 and quantization is enabled, OR
+    //     -data type is uint32, uint16, uint8 or int32, int16, int8
+    for (int i = 0; i < pc.num_attributes(); ++i) {
+      const PointAttribute *const att = pc.attribute(i);
+      if (kd_tree_possible && att->data_type() != DT_FLOAT32 &&
+          att->data_type() != DT_UINT32 && att->data_type() != DT_UINT16 &&
+          att->data_type() != DT_UINT8 && att->data_type() != DT_INT32 &&
+          att->data_type() != DT_INT16 && att->data_type() != DT_INT8) {
+        kd_tree_possible = false;
+      }
+      if (kd_tree_possible && att->data_type() == DT_FLOAT32 &&
+          options().GetAttributeInt(i, "quantization_bits", -1) <= 0) {
+        kd_tree_possible = false;  // Quantization not enabled.
+      }
+      if (!kd_tree_possible) {
+        break;
+      }
+    }
+
+    if (kd_tree_possible) {
+      // Create kD-tree encoder (all checks passed).
+      encoder.reset(new PointCloudKdTreeEncoder());
+    } else if (encoding_method == POINT_CLOUD_KD_TREE_ENCODING) {
+      // Encoding method was explicitly specified but we cannot use it for
+      // the given input (some of the checks above failed).
+      return Status(Status::DRACO_ERROR, "Invalid encoding method.");
+    }
+  }
+  if (!encoder) {
+    // Default choice.
+    encoder.reset(new PointCloudSequentialEncoder());
+  }
+  encoder->SetPointCloud(pc);
+  DRACO_RETURN_IF_ERROR(encoder->Encode(options(), out_buffer));
+
+  set_num_encoded_points(encoder->num_encoded_points());
+  set_num_encoded_faces(0);
+  return OkStatus();
+#else
+  return Status(Status::DRACO_ERROR, "Point cloud encoding is not enabled.");
+#endif
+}
+
+Status ExpertEncoder::EncodeMeshToBuffer(const Mesh &m,
+                                         EncoderBuffer *out_buffer) {
+  std::unique_ptr<MeshEncoder> encoder;
+  // Select the encoding method only based on the provided options.
+  int encoding_method = options().GetGlobalInt("encoding_method", -1);
+  if (encoding_method == -1) {
+    // For now select the edgebreaker for all options expect of speed 10
+    if (options().GetSpeed() == 10) {
+      encoding_method = MESH_SEQUENTIAL_ENCODING;
+    } else {
+      encoding_method = MESH_EDGEBREAKER_ENCODING;
+    }
+  }
+  if (encoding_method == MESH_EDGEBREAKER_ENCODING) {
+    encoder = std::unique_ptr<MeshEncoder>(new MeshEdgebreakerEncoder());
+  } else {
+    encoder = std::unique_ptr<MeshEncoder>(new MeshSequentialEncoder());
+  }
+  encoder->SetMesh(m);
+  DRACO_RETURN_IF_ERROR(encoder->Encode(options(), out_buffer));
+
+  set_num_encoded_points(encoder->num_encoded_points());
+  set_num_encoded_faces(encoder->num_encoded_faces());
+  return OkStatus();
+}
+
+void ExpertEncoder::Reset(const EncoderOptions &options) {
+  Base::Reset(options);
+}
+
+void ExpertEncoder::Reset() { Base::Reset(); }
+
+void ExpertEncoder::SetSpeedOptions(int encoding_speed, int decoding_speed) {
+  Base::SetSpeedOptions(encoding_speed, decoding_speed);
+}
+
+void ExpertEncoder::SetAttributeQuantization(int32_t attribute_id,
+                                             int quantization_bits) {
+  options().SetAttributeInt(attribute_id, "quantization_bits",
+                            quantization_bits);
+}
+
+void ExpertEncoder::SetAttributeExplicitQuantization(int32_t attribute_id,
+                                                     int quantization_bits,
+                                                     int num_dims,
+                                                     const float *origin,
+                                                     float range) {
+  options().SetAttributeInt(attribute_id, "quantization_bits",
+                            quantization_bits);
+  options().SetAttributeVector(attribute_id, "quantization_origin", num_dims,
+                               origin);
+  options().SetAttributeFloat(attribute_id, "quantization_range", range);
+}
+
+void ExpertEncoder::SetUseBuiltInAttributeCompression(bool enabled) {
+  options().SetGlobalBool("use_built_in_attribute_compression", enabled);
+}
+
+void ExpertEncoder::SetEncodingMethod(int encoding_method) {
+  Base::SetEncodingMethod(encoding_method);
+}
+
+void ExpertEncoder::SetEncodingSubmethod(int encoding_submethod) {
+  Base::SetEncodingSubmethod(encoding_submethod);
+}
+
+Status ExpertEncoder::SetAttributePredictionScheme(
+    int32_t attribute_id, int prediction_scheme_method) {
+  auto att = point_cloud_->attribute(attribute_id);
+  auto att_type = att->attribute_type();
+  const Status status =
+      CheckPredictionScheme(att_type, prediction_scheme_method);
+  if (!status.ok()) {
+    return status;
+  }
+  options().SetAttributeInt(attribute_id, "prediction_scheme",
+                            prediction_scheme_method);
+  return status;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/expert_encode.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/expert_encode.h
new file mode 100644
index 000000000..ea59393d3
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/expert_encode.h
@@ -0,0 +1,147 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_EXPERT_ENCODE_H_
+#define DRACO_COMPRESSION_EXPERT_ENCODE_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/config/encoder_options.h"
+#include "draco/compression/encode_base.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/status.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Advanced helper class for encoding geometry using the Draco compression
+// library. Unlike the basic Encoder (encode.h), this class allows users to
+// specify options for each attribute individually using provided attribute ids.
+// The drawback of this encoder is that it can be used to encode only one model
+// at a time, and for each new model the options need to be set again,
+class ExpertEncoder : public EncoderBase<EncoderOptions> {
+ public:
+  typedef EncoderBase<EncoderOptions> Base;
+  typedef EncoderOptions OptionsType;
+
+  explicit ExpertEncoder(const PointCloud &point_cloud);
+  explicit ExpertEncoder(const Mesh &mesh);
+
+  // Encodes the geometry provided in the constructor to the target buffer.
+  Status EncodeToBuffer(EncoderBuffer *out_buffer);
+
+  // Set encoder options used during the geometry encoding. Note that this call
+  // overwrites any modifications to the options done with the functions below.
+  void Reset(const EncoderOptions &options);
+  void Reset();
+
+  // Sets the desired encoding and decoding speed for the given options.
+  //
+  //  0 = slowest speed, but the best compression.
+  // 10 = fastest, but the worst compression.
+  // -1 = undefined.
+  //
+  // Note that both speed options affect the encoder choice of used methods and
+  // algorithms. For example, a requirement for fast decoding may prevent the
+  // encoder from using the best compression methods even if the encoding speed
+  // is set to 0. In general, the faster of the two options limits the choice of
+  // features that can be used by the encoder. Additionally, setting
+  // |decoding_speed| to be faster than the |encoding_speed| may allow the
+  // encoder to choose the optimal method out of the available features for the
+  // given |decoding_speed|.
+  void SetSpeedOptions(int encoding_speed, int decoding_speed);
+
+  // Sets the quantization compression options for a specific attribute. The
+  // attribute values will be quantized in a box defined by the maximum extent
+  // of the attribute values. I.e., the actual precision of this option depends
+  // on the scale of the attribute values.
+  void SetAttributeQuantization(int32_t attribute_id, int quantization_bits);
+
+  // Sets the explicit quantization compression for a named attribute. The
+  // attribute values will be quantized in a coordinate system defined by the
+  // provided origin and range (the input values should be within interval:
+  // <origin, origin + range>).
+  void SetAttributeExplicitQuantization(int32_t attribute_id,
+                                        int quantization_bits, int num_dims,
+                                        const float *origin, float range);
+
+  // Enables/disables built in entropy coding of attribute values. Disabling
+  // this option may be useful to improve the performance when third party
+  // compression is used on top of the Draco compression. Default: [true].
+  void SetUseBuiltInAttributeCompression(bool enabled);
+
+  // Sets the desired encoding method for a given geometry. By default, encoding
+  // method is selected based on the properties of the input geometry and based
+  // on the other options selected in the used EncoderOptions (such as desired
+  // encoding and decoding speed). This function should be called only when a
+  // specific method is required.
+  //
+  // |encoding_method| can be one of the values defined in
+  // compression/config/compression_shared.h based on the type of the input
+  // geometry that is going to be encoded. For point clouds, allowed entries are
+  //   POINT_CLOUD_SEQUENTIAL_ENCODING
+  //   POINT_CLOUD_KD_TREE_ENCODING
+  //
+  // For meshes the input can be
+  //   MESH_SEQUENTIAL_ENCODING
+  //   MESH_EDGEBREAKER_ENCODING
+  //
+  // If the selected method cannot be used for the given input, the subsequent
+  // call of EncodePointCloudToBuffer or EncodeMeshToBuffer is going to fail.
+  void SetEncodingMethod(int encoding_method);
+
+  // Sets the desired encoding submethod, only for MESH_EDGEBREAKER_ENCODING.
+  // Valid values for |encoding_submethod| are:
+  //   MESH_EDGEBREAKER_STANDARD_ENCODING
+  //   MESH_EDGEBREAKER_VALENCE_ENCODING
+  // see also compression/config/compression_shared.h.
+  void SetEncodingSubmethod(int encoding_submethod);
+
+  // Sets the desired prediction method for a given attribute. By default,
+  // prediction scheme is selected automatically by the encoder using other
+  // provided options (such as speed) and input geometry type (mesh, point
+  // cloud). This function should be called only when a specific prediction is
+  // preferred (e.g., when it is known that the encoder would select a less
+  // optimal prediction for the given input data).
+  //
+  // |prediction_scheme_method| should be one of the entries defined in
+  // compression/config/compression_shared.h :
+  //
+  //   PREDICTION_NONE - use no prediction.
+  //   PREDICTION_DIFFERENCE - delta coding
+  //   MESH_PREDICTION_PARALLELOGRAM - parallelogram prediction for meshes.
+  //   MESH_PREDICTION_CONSTRAINED_PARALLELOGRAM
+  //      - better and more costly version of the parallelogram prediction.
+  //   MESH_PREDICTION_TEX_COORDS_PORTABLE
+  //      - specialized predictor for tex coordinates.
+  //   MESH_PREDICTION_GEOMETRIC_NORMAL
+  //      - specialized predictor for normal coordinates.
+  //
+  // Note that in case the desired prediction cannot be used, the default
+  // prediction will be automatically used instead.
+  Status SetAttributePredictionScheme(int32_t attribute_id,
+                                      int prediction_scheme_method);
+
+ private:
+  Status EncodePointCloudToBuffer(const PointCloud &pc,
+                                  EncoderBuffer *out_buffer);
+
+  Status EncodeMeshToBuffer(const Mesh &m, EncoderBuffer *out_buffer);
+
+  const PointCloud *point_cloud_;
+  const Mesh *mesh_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_EXPERT_ENCODE_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_decoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_decoder.cc
new file mode 100644
index 000000000..6e48e56fb
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_decoder.cc
@@ -0,0 +1,37 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/mesh/mesh_decoder.h"
+
+namespace draco {
+
+MeshDecoder::MeshDecoder() : mesh_(nullptr) {}
+
+Status MeshDecoder::Decode(const DecoderOptions &options,
+                           DecoderBuffer *in_buffer, Mesh *out_mesh) {
+  mesh_ = out_mesh;
+  return PointCloudDecoder::Decode(options, in_buffer, out_mesh);
+}
+
+bool MeshDecoder::DecodeGeometryData() {
+  if (mesh_ == nullptr) {
+    return false;
+  }
+  if (!DecodeConnectivity()) {
+    return false;
+  }
+  return PointCloudDecoder::DecodeGeometryData();
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_decoder.h
new file mode 100644
index 000000000..397a679d4
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_decoder.h
@@ -0,0 +1,68 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_DECODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_DECODER_H_
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/compression/point_cloud/point_cloud_decoder.h"
+#include "draco/mesh/mesh.h"
+#include "draco/mesh/mesh_attribute_corner_table.h"
+
+namespace draco {
+
+// Class that reconstructs a 3D mesh from input data that was encoded by
+// MeshEncoder.
+class MeshDecoder : public PointCloudDecoder {
+ public:
+  MeshDecoder();
+
+  EncodedGeometryType GetGeometryType() const override {
+    return TRIANGULAR_MESH;
+  }
+
+  // The main entry point for mesh decoding.
+  Status Decode(const DecoderOptions &options, DecoderBuffer *in_buffer,
+                Mesh *out_mesh);
+
+  // Returns the base connectivity of the decoded mesh (or nullptr if it is not
+  // initialized).
+  virtual const CornerTable *GetCornerTable() const { return nullptr; }
+
+  // Returns the attribute connectivity data or nullptr if it does not exist.
+  virtual const MeshAttributeCornerTable *GetAttributeCornerTable(
+      int /* att_id */) const {
+    return nullptr;
+  }
+
+  // Returns the decoding data for a given attribute or nullptr when the data
+  // does not exist.
+  virtual const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int /* att_id */) const {
+    return nullptr;
+  }
+
+  Mesh *mesh() const { return mesh_; }
+
+ protected:
+  bool DecodeGeometryData() override;
+  virtual bool DecodeConnectivity() = 0;
+
+ private:
+  Mesh *mesh_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder.cc
new file mode 100644
index 000000000..427dd59f5
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder.cc
@@ -0,0 +1,70 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/mesh/mesh_edgebreaker_decoder.h"
+
+#include "draco/compression/mesh/mesh_edgebreaker_decoder_impl.h"
+#include "draco/compression/mesh/mesh_edgebreaker_traversal_predictive_decoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_traversal_valence_decoder.h"
+
+namespace draco {
+
+MeshEdgebreakerDecoder::MeshEdgebreakerDecoder() {}
+
+bool MeshEdgebreakerDecoder::CreateAttributesDecoder(int32_t att_decoder_id) {
+  return impl_->CreateAttributesDecoder(att_decoder_id);
+}
+
+bool MeshEdgebreakerDecoder::InitializeDecoder() {
+  uint8_t traversal_decoder_type;
+  if (!buffer()->Decode(&traversal_decoder_type)) {
+    return false;
+  }
+  impl_ = nullptr;
+  if (traversal_decoder_type == MESH_EDGEBREAKER_STANDARD_ENCODING) {
+#ifdef DRACO_STANDARD_EDGEBREAKER_SUPPORTED
+    impl_ = std::unique_ptr<MeshEdgebreakerDecoderImplInterface>(
+        new MeshEdgebreakerDecoderImpl<MeshEdgebreakerTraversalDecoder>());
+#endif
+  } else if (traversal_decoder_type == MESH_EDGEBREAKER_PREDICTIVE_ENCODING) {
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+#ifdef DRACO_PREDICTIVE_EDGEBREAKER_SUPPORTED
+    impl_ = std::unique_ptr<MeshEdgebreakerDecoderImplInterface>(
+        new MeshEdgebreakerDecoderImpl<
+            MeshEdgebreakerTraversalPredictiveDecoder>());
+#endif
+#endif
+  } else if (traversal_decoder_type == MESH_EDGEBREAKER_VALENCE_ENCODING) {
+    impl_ = std::unique_ptr<MeshEdgebreakerDecoderImplInterface>(
+        new MeshEdgebreakerDecoderImpl<
+            MeshEdgebreakerTraversalValenceDecoder>());
+  }
+  if (!impl_) {
+    return false;
+  }
+  if (!impl_->Init(this)) {
+    return false;
+  }
+  return true;
+}
+
+bool MeshEdgebreakerDecoder::DecodeConnectivity() {
+  return impl_->DecodeConnectivity();
+}
+
+bool MeshEdgebreakerDecoder::OnAttributesDecoded() {
+  return impl_->OnAttributesDecoded();
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder.h
new file mode 100644
index 000000000..5c1617942
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder.h
@@ -0,0 +1,54 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_H_
+
+#include "draco/compression/mesh/mesh_decoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_decoder_impl_interface.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Class for decoding data encoded by MeshEdgebreakerEncoder.
+class MeshEdgebreakerDecoder : public MeshDecoder {
+ public:
+  MeshEdgebreakerDecoder();
+
+  const CornerTable *GetCornerTable() const override {
+    return impl_->GetCornerTable();
+  }
+
+  const MeshAttributeCornerTable *GetAttributeCornerTable(
+      int att_id) const override {
+    return impl_->GetAttributeCornerTable(att_id);
+  }
+
+  const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int att_id) const override {
+    return impl_->GetAttributeEncodingData(att_id);
+  }
+
+ protected:
+  bool InitializeDecoder() override;
+  bool CreateAttributesDecoder(int32_t att_decoder_id) override;
+  bool DecodeConnectivity() override;
+  bool OnAttributesDecoded() override;
+
+  std::unique_ptr<MeshEdgebreakerDecoderImplInterface> impl_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder_impl.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder_impl.cc
new file mode 100644
index 000000000..0bbbea4af
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder_impl.cc
@@ -0,0 +1,1231 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/mesh/mesh_edgebreaker_decoder_impl.h"
+
+#include <algorithm>
+
+#include "draco/compression/attributes/sequential_attribute_decoders_controller.h"
+#include "draco/compression/mesh/mesh_edgebreaker_decoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_traversal_predictive_decoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_traversal_valence_decoder.h"
+#include "draco/compression/mesh/traverser/depth_first_traverser.h"
+#include "draco/compression/mesh/traverser/max_prediction_degree_traverser.h"
+#include "draco/compression/mesh/traverser/mesh_attribute_indices_encoding_observer.h"
+#include "draco/compression/mesh/traverser/mesh_traversal_sequencer.h"
+#include "draco/compression/mesh/traverser/traverser_base.h"
+#include "draco/mesh/corner_table_iterators.h"
+
+namespace draco {
+
+// Types of "free" edges that are used during topology decoding.
+// A free edge is an edge that is connected to one face only.
+// All edge types are stored in the opposite_corner_id_ array, where each
+// edge "e" is uniquely identified by the opposite corner "C" in its parent
+// triangle:
+//          *
+//         /C\
+//        /   \
+//       /  e  \
+//      *-------*
+// For more description about how the edges are used, see comment inside
+// ZipConnectivity() method.
+
+template <class TraversalDecoder>
+MeshEdgebreakerDecoderImpl<TraversalDecoder>::MeshEdgebreakerDecoderImpl()
+    : decoder_(nullptr),
+      last_symbol_id_(-1),
+      last_vert_id_(-1),
+      last_face_id_(-1),
+      num_new_vertices_(0),
+      num_encoded_vertices_(0),
+      pos_data_decoder_id_(-1) {}
+
+template <class TraversalDecoder>
+bool MeshEdgebreakerDecoderImpl<TraversalDecoder>::Init(
+    MeshEdgebreakerDecoder *decoder) {
+  decoder_ = decoder;
+  return true;
+}
+
+template <class TraversalDecoder>
+const MeshAttributeCornerTable *
+MeshEdgebreakerDecoderImpl<TraversalDecoder>::GetAttributeCornerTable(
+    int att_id) const {
+  for (uint32_t i = 0; i < attribute_data_.size(); ++i) {
+    const int decoder_id = attribute_data_[i].decoder_id;
+    if (decoder_id < 0 || decoder_id >= decoder_->num_attributes_decoders()) {
+      continue;
+    }
+    const AttributesDecoderInterface *const dec =
+        decoder_->attributes_decoder(decoder_id);
+    for (int j = 0; j < dec->GetNumAttributes(); ++j) {
+      if (dec->GetAttributeId(j) == att_id) {
+        if (attribute_data_[i].is_connectivity_used) {
+          return &attribute_data_[i].connectivity_data;
+        }
+        return nullptr;
+      }
+    }
+  }
+  return nullptr;
+}
+
+template <class TraversalDecoder>
+const MeshAttributeIndicesEncodingData *
+MeshEdgebreakerDecoderImpl<TraversalDecoder>::GetAttributeEncodingData(
+    int att_id) const {
+  for (uint32_t i = 0; i < attribute_data_.size(); ++i) {
+    const int decoder_id = attribute_data_[i].decoder_id;
+    if (decoder_id < 0 || decoder_id >= decoder_->num_attributes_decoders()) {
+      continue;
+    }
+    const AttributesDecoderInterface *const dec =
+        decoder_->attributes_decoder(decoder_id);
+    for (int j = 0; j < dec->GetNumAttributes(); ++j) {
+      if (dec->GetAttributeId(j) == att_id) {
+        return &attribute_data_[i].encoding_data;
+      }
+    }
+  }
+  return &pos_encoding_data_;
+}
+
+template <class TraversalDecoder>
+template <class TraverserT>
+std::unique_ptr<PointsSequencer>
+MeshEdgebreakerDecoderImpl<TraversalDecoder>::CreateVertexTraversalSequencer(
+    MeshAttributeIndicesEncodingData *encoding_data) {
+  typedef typename TraverserT::TraversalObserver AttObserver;
+  typedef typename TraverserT::CornerTable CornerTable;
+
+  const Mesh *mesh = decoder_->mesh();
+  std::unique_ptr<MeshTraversalSequencer<TraverserT>> traversal_sequencer(
+      new MeshTraversalSequencer<TraverserT>(mesh, encoding_data));
+
+  AttObserver att_observer(corner_table_.get(), mesh, traversal_sequencer.get(),
+                           encoding_data);
+
+  TraverserT att_traverser;
+  att_traverser.Init(corner_table_.get(), att_observer);
+
+  traversal_sequencer->SetTraverser(att_traverser);
+  return std::move(traversal_sequencer);
+}
+
+template <class TraversalDecoder>
+bool MeshEdgebreakerDecoderImpl<TraversalDecoder>::CreateAttributesDecoder(
+    int32_t att_decoder_id) {
+  int8_t att_data_id;
+  if (!decoder_->buffer()->Decode(&att_data_id)) {
+    return false;
+  }
+  uint8_t decoder_type;
+  if (!decoder_->buffer()->Decode(&decoder_type)) {
+    return false;
+  }
+
+  if (att_data_id >= 0) {
+    if (att_data_id >= attribute_data_.size()) {
+      return false;  // Unexpected attribute data.
+    }
+
+    // Ensure that the attribute data is not mapped to a different attributes
+    // decoder already.
+    if (attribute_data_[att_data_id].decoder_id >= 0) {
+      return false;
+    }
+
+    attribute_data_[att_data_id].decoder_id = att_decoder_id;
+  } else {
+    // Assign the attributes decoder to |pos_encoding_data_|.
+    if (pos_data_decoder_id_ >= 0) {
+      return false;  // Some other decoder is already using the data. Error.
+    }
+    pos_data_decoder_id_ = att_decoder_id;
+  }
+
+  MeshTraversalMethod traversal_method = MESH_TRAVERSAL_DEPTH_FIRST;
+  if (decoder_->bitstream_version() >= DRACO_BITSTREAM_VERSION(1, 2)) {
+    uint8_t traversal_method_encoded;
+    if (!decoder_->buffer()->Decode(&traversal_method_encoded)) {
+      return false;
+    }
+    // Check that decoded traversal method is valid.
+    if (traversal_method_encoded >= NUM_TRAVERSAL_METHODS) {
+      return false;
+    }
+    traversal_method =
+        static_cast<MeshTraversalMethod>(traversal_method_encoded);
+  }
+
+  const Mesh *mesh = decoder_->mesh();
+  std::unique_ptr<PointsSequencer> sequencer;
+
+  if (decoder_type == MESH_VERTEX_ATTRIBUTE) {
+    // Per-vertex attribute decoder.
+
+    MeshAttributeIndicesEncodingData *encoding_data = nullptr;
+    if (att_data_id < 0) {
+      encoding_data = &pos_encoding_data_;
+    } else {
+      encoding_data = &attribute_data_[att_data_id].encoding_data;
+      // Mark the attribute connectivity data invalid to ensure it's not used
+      // later on.
+      attribute_data_[att_data_id].is_connectivity_used = false;
+    }
+    // Defining sequencer via a traversal scheme.
+    if (traversal_method == MESH_TRAVERSAL_PREDICTION_DEGREE) {
+      typedef MeshAttributeIndicesEncodingObserver<CornerTable> AttObserver;
+      typedef MaxPredictionDegreeTraverser<CornerTable, AttObserver>
+          AttTraverser;
+      sequencer = CreateVertexTraversalSequencer<AttTraverser>(encoding_data);
+    } else if (traversal_method == MESH_TRAVERSAL_DEPTH_FIRST) {
+      typedef MeshAttributeIndicesEncodingObserver<CornerTable> AttObserver;
+      typedef DepthFirstTraverser<CornerTable, AttObserver> AttTraverser;
+      sequencer = CreateVertexTraversalSequencer<AttTraverser>(encoding_data);
+    } else {
+      return false;  // Unsupported method
+    }
+  } else {
+    if (traversal_method != MESH_TRAVERSAL_DEPTH_FIRST) {
+      return false;  // Unsupported method.
+    }
+    if (att_data_id < 0) {
+      return false;  // Attribute data must be specified.
+    }
+
+    // Per-corner attribute decoder.
+
+    typedef MeshAttributeIndicesEncodingObserver<MeshAttributeCornerTable>
+        AttObserver;
+    typedef DepthFirstTraverser<MeshAttributeCornerTable, AttObserver>
+        AttTraverser;
+
+    MeshAttributeIndicesEncodingData *const encoding_data =
+        &attribute_data_[att_data_id].encoding_data;
+    const MeshAttributeCornerTable *const corner_table =
+        &attribute_data_[att_data_id].connectivity_data;
+
+    std::unique_ptr<MeshTraversalSequencer<AttTraverser>> traversal_sequencer(
+        new MeshTraversalSequencer<AttTraverser>(mesh, encoding_data));
+
+    AttObserver att_observer(corner_table, mesh, traversal_sequencer.get(),
+                             encoding_data);
+
+    AttTraverser att_traverser;
+    att_traverser.Init(corner_table, att_observer);
+
+    traversal_sequencer->SetTraverser(att_traverser);
+    sequencer = std::move(traversal_sequencer);
+  }
+
+  if (!sequencer) {
+    return false;
+  }
+
+  std::unique_ptr<SequentialAttributeDecodersController> att_controller(
+      new SequentialAttributeDecodersController(std::move(sequencer)));
+
+  return decoder_->SetAttributesDecoder(att_decoder_id,
+                                        std::move(att_controller));
+}
+
+template <class TraversalDecoder>
+bool MeshEdgebreakerDecoderImpl<TraversalDecoder>::DecodeConnectivity() {
+  num_new_vertices_ = 0;
+  new_to_parent_vertex_map_.clear();
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+    uint32_t num_new_verts;
+    if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+      if (!decoder_->buffer()->Decode(&num_new_verts)) {
+        return false;
+      }
+    } else {
+      if (!DecodeVarint(&num_new_verts, decoder_->buffer())) {
+        return false;
+      }
+    }
+    num_new_vertices_ = num_new_verts;
+  }
+#endif
+
+  uint32_t num_encoded_vertices;
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+    if (!decoder_->buffer()->Decode(&num_encoded_vertices)) {
+      return false;
+    }
+
+  } else
+#endif
+  {
+    if (!DecodeVarint(&num_encoded_vertices, decoder_->buffer())) {
+      return false;
+    }
+  }
+  num_encoded_vertices_ = num_encoded_vertices;
+
+  uint32_t num_faces;
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+    if (!decoder_->buffer()->Decode(&num_faces)) {
+      return false;
+    }
+
+  } else
+#endif
+  {
+    if (!DecodeVarint(&num_faces, decoder_->buffer())) {
+      return false;
+    }
+  }
+  if (num_faces > std::numeric_limits<CornerIndex::ValueType>::max() / 3) {
+    return false;  // Draco cannot handle this many faces.
+  }
+
+  if (static_cast<uint32_t>(num_encoded_vertices_) > num_faces * 3) {
+    return false;  // There cannot be more vertices than 3 * num_faces.
+  }
+  uint8_t num_attribute_data;
+  if (!decoder_->buffer()->Decode(&num_attribute_data)) {
+    return false;
+  }
+
+  uint32_t num_encoded_symbols;
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+    if (!decoder_->buffer()->Decode(&num_encoded_symbols)) {
+      return false;
+    }
+
+  } else
+#endif
+  {
+    if (!DecodeVarint(&num_encoded_symbols, decoder_->buffer())) {
+      return false;
+    }
+  }
+
+  if (num_faces < num_encoded_symbols) {
+    // Number of faces needs to be the same or greater than the number of
+    // symbols (it can be greater because the initial face may not be encoded as
+    // a symbol).
+    return false;
+  }
+  const uint32_t max_encoded_faces =
+      num_encoded_symbols + (num_encoded_symbols / 3);
+  if (num_faces > max_encoded_faces) {
+    // Faces can only be 1 1/3 times bigger than number of encoded symbols. This
+    // could only happen if all new encoded components started with interior
+    // triangles. E.g. A mesh with multiple tetrahedrons.
+    return false;
+  }
+
+  uint32_t num_encoded_split_symbols;
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+    if (!decoder_->buffer()->Decode(&num_encoded_split_symbols)) {
+      return false;
+    }
+
+  } else
+#endif
+  {
+    if (!DecodeVarint(&num_encoded_split_symbols, decoder_->buffer())) {
+      return false;
+    }
+  }
+
+  if (num_encoded_split_symbols > num_encoded_symbols) {
+    return false;  // Split symbols are a sub-set of all symbols.
+  }
+
+  // Decode topology (connectivity).
+  vertex_traversal_length_.clear();
+  corner_table_ = std::unique_ptr<CornerTable>(new CornerTable());
+  if (corner_table_ == nullptr) {
+    return false;
+  }
+  processed_corner_ids_.clear();
+  processed_corner_ids_.reserve(num_faces);
+  processed_connectivity_corners_.clear();
+  processed_connectivity_corners_.reserve(num_faces);
+  topology_split_data_.clear();
+  hole_event_data_.clear();
+  init_face_configurations_.clear();
+  init_corners_.clear();
+
+  last_symbol_id_ = -1;
+  last_face_id_ = -1;
+  last_vert_id_ = -1;
+
+  attribute_data_.clear();
+  // Add one attribute data for each attribute decoder.
+  attribute_data_.resize(num_attribute_data);
+
+  if (!corner_table_->Reset(
+          num_faces, num_encoded_vertices_ + num_encoded_split_symbols)) {
+    return false;
+  }
+
+  // Start with all vertices marked as holes (boundaries).
+  // Only vertices decoded with TOPOLOGY_C symbol (and the initial face) will
+  // be marked as non hole vertices. We need to allocate the array larger
+  // because split symbols can create extra vertices during the decoding
+  // process (these extra vertices are then eliminated during deduplication).
+  is_vert_hole_.assign(num_encoded_vertices_ + num_encoded_split_symbols, true);
+
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  int32_t topology_split_decoded_bytes = -1;
+  if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+    uint32_t encoded_connectivity_size;
+    if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+      if (!decoder_->buffer()->Decode(&encoded_connectivity_size)) {
+        return false;
+      }
+    } else {
+      if (!DecodeVarint(&encoded_connectivity_size, decoder_->buffer())) {
+        return false;
+      }
+    }
+    if (encoded_connectivity_size == 0 ||
+        encoded_connectivity_size > decoder_->buffer()->remaining_size()) {
+      return false;
+    }
+    DecoderBuffer event_buffer;
+    event_buffer.Init(
+        decoder_->buffer()->data_head() + encoded_connectivity_size,
+        decoder_->buffer()->remaining_size() - encoded_connectivity_size,
+        decoder_->buffer()->bitstream_version());
+    // Decode hole and topology split events.
+    topology_split_decoded_bytes =
+        DecodeHoleAndTopologySplitEvents(&event_buffer);
+    if (topology_split_decoded_bytes == -1) {
+      return false;
+    }
+
+  } else
+#endif
+  {
+    if (DecodeHoleAndTopologySplitEvents(decoder_->buffer()) == -1) {
+      return false;
+    }
+  }
+
+  traversal_decoder_.Init(this);
+  // Add one extra vertex for each split symbol.
+  traversal_decoder_.SetNumEncodedVertices(num_encoded_vertices_ +
+                                           num_encoded_split_symbols);
+  traversal_decoder_.SetNumAttributeData(num_attribute_data);
+
+  DecoderBuffer traversal_end_buffer;
+  if (!traversal_decoder_.Start(&traversal_end_buffer)) {
+    return false;
+  }
+
+  const int num_connectivity_verts = DecodeConnectivity(num_encoded_symbols);
+  if (num_connectivity_verts == -1) {
+    return false;
+  }
+
+  // Set the main buffer to the end of the traversal.
+  decoder_->buffer()->Init(traversal_end_buffer.data_head(),
+                           traversal_end_buffer.remaining_size(),
+                           decoder_->buffer()->bitstream_version());
+
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+    // Skip topology split data that was already decoded earlier.
+    decoder_->buffer()->Advance(topology_split_decoded_bytes);
+  }
+#endif
+
+  // Decode connectivity of non-position attributes.
+  if (attribute_data_.size() > 0) {
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+    if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 1)) {
+      for (CornerIndex ci(0); ci < corner_table_->num_corners(); ci += 3) {
+        if (!DecodeAttributeConnectivitiesOnFaceLegacy(ci)) {
+          return false;
+        }
+      }
+
+    } else
+#endif
+    {
+      for (CornerIndex ci(0); ci < corner_table_->num_corners(); ci += 3) {
+        if (!DecodeAttributeConnectivitiesOnFace(ci)) {
+          return false;
+        }
+      }
+    }
+  }
+  traversal_decoder_.Done();
+
+  // Decode attribute connectivity.
+  // Prepare data structure for decoding non-position attribute connectivity.
+  for (uint32_t i = 0; i < attribute_data_.size(); ++i) {
+    attribute_data_[i].connectivity_data.InitEmpty(corner_table_.get());
+    // Add all seams.
+    for (int32_t c : attribute_data_[i].attribute_seam_corners) {
+      attribute_data_[i].connectivity_data.AddSeamEdge(CornerIndex(c));
+    }
+    // Recompute vertices from the newly added seam edges.
+    attribute_data_[i].connectivity_data.RecomputeVertices(nullptr, nullptr);
+  }
+
+  pos_encoding_data_.Init(corner_table_->num_vertices());
+  for (uint32_t i = 0; i < attribute_data_.size(); ++i) {
+    // For non-position attributes, preallocate the vertex to value mapping
+    // using the maximum number of vertices from the base corner table and the
+    // attribute corner table (since the attribute decoder may use either of
+    // it).
+    int32_t att_connectivity_verts =
+        attribute_data_[i].connectivity_data.num_vertices();
+    if (att_connectivity_verts < corner_table_->num_vertices()) {
+      att_connectivity_verts = corner_table_->num_vertices();
+    }
+    attribute_data_[i].encoding_data.Init(att_connectivity_verts);
+  }
+  if (!AssignPointsToCorners(num_connectivity_verts)) {
+    return false;
+  }
+  return true;
+}
+
+template <class TraversalDecoder>
+bool MeshEdgebreakerDecoderImpl<TraversalDecoder>::OnAttributesDecoded() {
+  return true;
+}
+
+template <class TraversalDecoder>
+int MeshEdgebreakerDecoderImpl<TraversalDecoder>::DecodeConnectivity(
+    int num_symbols) {
+  // Algorithm does the reverse decoding of the symbols encoded with the
+  // edgebreaker method. The reverse decoding always keeps track of the active
+  // edge identified by its opposite corner (active corner). New faces are
+  // always added to this active edge. There may be multiple active corners at
+  // one time that either correspond to separate mesh components or to
+  // sub-components of one mesh that are going to be merged together using the
+  // TOPOLOGY_S symbol. We can store these active edges on a stack, because the
+  // decoder always processes only the latest active edge. TOPOLOGY_S then
+  // removes the top edge from the stack and TOPOLOGY_E adds a new edge to the
+  // stack.
+  std::vector<CornerIndex> active_corner_stack;
+
+  // Additional active edges may be added as a result of topology split events.
+  // They can be added in arbitrary order, but we always know the split symbol
+  // id they belong to, so we can address them using this symbol id.
+  std::unordered_map<int, CornerIndex> topology_split_active_corners;
+
+  // Vector used for storing vertices that were marked as isolated during the
+  // decoding process. Currently used only when the mesh doesn't contain any
+  // non-position connectivity data.
+  std::vector<VertexIndex> invalid_vertices;
+  const bool remove_invalid_vertices = attribute_data_.empty();
+
+  int max_num_vertices = static_cast<int>(is_vert_hole_.size());
+  int num_faces = 0;
+  for (int symbol_id = 0; symbol_id < num_symbols; ++symbol_id) {
+    const FaceIndex face(num_faces++);
+    // Used to flag cases where we need to look for topology split events.
+    bool check_topology_split = false;
+    const uint32_t symbol = traversal_decoder_.DecodeSymbol();
+    if (symbol == TOPOLOGY_C) {
+      // Create a new face between two edges on the open boundary.
+      // The first edge is opposite to the corner "a" from the image below.
+      // The other edge is opposite to the corner "b" that can be reached
+      // through a CCW traversal around the vertex "v".
+      // One new active boundary edge is created, opposite to the new corner
+      // "x".
+      //
+      //     *-------*
+      //    / \     / \
+      //   /   \   /   \
+      //  /     \ /     \
+      // *-------v-------*
+      //  \b    /x\    a/
+      //   \   /   \   /
+      //    \ /  C  \ /
+      //     *.......*
+
+      // Find the corner "b" from the corner "a" which is the corner on the
+      // top of the active stack.
+      if (active_corner_stack.empty()) {
+        return -1;
+      }
+
+      const CornerIndex corner_a = active_corner_stack.back();
+      const VertexIndex vertex_x =
+          corner_table_->Vertex(corner_table_->Next(corner_a));
+      const CornerIndex corner_b =
+          corner_table_->Next(corner_table_->LeftMostCorner(vertex_x));
+
+      // New tip corner.
+      const CornerIndex corner(3 * face.value());
+      // Update opposite corner mappings.
+      SetOppositeCorners(corner_a, corner + 1);
+      SetOppositeCorners(corner_b, corner + 2);
+
+      // Update vertex mapping.
+      const VertexIndex vert_a_prev =
+          corner_table_->Vertex(corner_table_->Previous(corner_a));
+      const VertexIndex vert_b_next =
+          corner_table_->Vertex(corner_table_->Next(corner_b));
+      if (vertex_x == vert_a_prev || vertex_x == vert_b_next) {
+        // Encoding is invalid, because face vertices are degenerate.
+        return -1;
+      }
+      corner_table_->MapCornerToVertex(corner, vertex_x);
+      corner_table_->MapCornerToVertex(corner + 1, vert_b_next);
+      corner_table_->MapCornerToVertex(corner + 2, vert_a_prev);
+      corner_table_->SetLeftMostCorner(vert_a_prev, corner + 2);
+      // Mark the vertex |x| as interior.
+      is_vert_hole_[vertex_x.value()] = false;
+      // Update the corner on the active stack.
+      active_corner_stack.back() = corner;
+    } else if (symbol == TOPOLOGY_R || symbol == TOPOLOGY_L) {
+      // Create a new face extending from the open boundary edge opposite to the
+      // corner "a" from the image below. Two new boundary edges are created
+      // opposite to corners "r" and "l". New active corner is set to either "r"
+      // or "l" depending on the decoded symbol. One new vertex is created
+      // at the opposite corner to corner "a".
+      //     *-------*
+      //    /a\     / \
+      //   /   \   /   \
+      //  /     \ /     \
+      // *-------v-------*
+      //  .l   r.
+      //   .   .
+      //    . .
+      //     *
+      if (active_corner_stack.empty()) {
+        return -1;
+      }
+      const CornerIndex corner_a = active_corner_stack.back();
+
+      // First corner on the new face is either corner "l" or "r".
+      const CornerIndex corner(3 * face.value());
+      CornerIndex opp_corner, corner_l, corner_r;
+      if (symbol == TOPOLOGY_R) {
+        // "r" is the new first corner.
+        opp_corner = corner + 2;
+        corner_l = corner + 1;
+        corner_r = corner;
+      } else {
+        // "l" is the new first corner.
+        opp_corner = corner + 1;
+        corner_l = corner;
+        corner_r = corner + 2;
+      }
+      SetOppositeCorners(opp_corner, corner_a);
+      // Update vertex mapping.
+      const VertexIndex new_vert_index = corner_table_->AddNewVertex();
+
+      if (corner_table_->num_vertices() > max_num_vertices) {
+        return -1;  // Unexpected number of decoded vertices.
+      }
+
+      corner_table_->MapCornerToVertex(opp_corner, new_vert_index);
+      corner_table_->SetLeftMostCorner(new_vert_index, opp_corner);
+
+      const VertexIndex vertex_r =
+          corner_table_->Vertex(corner_table_->Previous(corner_a));
+      corner_table_->MapCornerToVertex(corner_r, vertex_r);
+      // Update left-most corner on the vertex on the |corner_r|.
+      corner_table_->SetLeftMostCorner(vertex_r, corner_r);
+
+      corner_table_->MapCornerToVertex(
+          corner_l, corner_table_->Vertex(corner_table_->Next(corner_a)));
+      active_corner_stack.back() = corner;
+      check_topology_split = true;
+    } else if (symbol == TOPOLOGY_S) {
+      // Create a new face that merges two last active edges from the active
+      // stack. No new vertex is created, but two vertices at corners "p" and
+      // "n" need to be merged into a single vertex.
+      //
+      // *-------v-------*
+      //  \a   p/x\n   b/
+      //   \   /   \   /
+      //    \ /  S  \ /
+      //     *.......*
+      //
+      if (active_corner_stack.empty()) {
+        return -1;
+      }
+      const CornerIndex corner_b = active_corner_stack.back();
+      active_corner_stack.pop_back();
+
+      // Corner "a" can correspond either to a normal active edge, or to an edge
+      // created from the topology split event.
+      const auto it = topology_split_active_corners.find(symbol_id);
+      if (it != topology_split_active_corners.end()) {
+        // Topology split event. Move the retrieved edge to the stack.
+        active_corner_stack.push_back(it->second);
+      }
+      if (active_corner_stack.empty()) {
+        return -1;
+      }
+      const CornerIndex corner_a = active_corner_stack.back();
+
+      if (corner_table_->Opposite(corner_a) != kInvalidCornerIndex ||
+          corner_table_->Opposite(corner_b) != kInvalidCornerIndex) {
+        // One of the corners is already opposite to an existing face, which
+        // should not happen unless the input was tempered with.
+        return -1;
+      }
+
+      // First corner on the new face is corner "x" from the image above.
+      const CornerIndex corner(3 * face.value());
+      // Update the opposite corner mapping.
+      SetOppositeCorners(corner_a, corner + 2);
+      SetOppositeCorners(corner_b, corner + 1);
+      // Update vertices. For the vertex at corner "x", use the vertex id from
+      // the corner "p".
+      const VertexIndex vertex_p =
+          corner_table_->Vertex(corner_table_->Previous(corner_a));
+      corner_table_->MapCornerToVertex(corner, vertex_p);
+      corner_table_->MapCornerToVertex(
+          corner + 1, corner_table_->Vertex(corner_table_->Next(corner_a)));
+      const VertexIndex vert_b_prev =
+          corner_table_->Vertex(corner_table_->Previous(corner_b));
+      corner_table_->MapCornerToVertex(corner + 2, vert_b_prev);
+      corner_table_->SetLeftMostCorner(vert_b_prev, corner + 2);
+      CornerIndex corner_n = corner_table_->Next(corner_b);
+      const VertexIndex vertex_n = corner_table_->Vertex(corner_n);
+      traversal_decoder_.MergeVertices(vertex_p, vertex_n);
+      // Update the left most corner on the newly merged vertex.
+      corner_table_->SetLeftMostCorner(vertex_p,
+                                       corner_table_->LeftMostCorner(vertex_n));
+
+      // Also update the vertex id at corner "n" and all corners that are
+      // connected to it in the CCW direction.
+      while (corner_n != kInvalidCornerIndex) {
+        corner_table_->MapCornerToVertex(corner_n, vertex_p);
+        corner_n = corner_table_->SwingLeft(corner_n);
+      }
+      // Make sure the old vertex n is now mapped to an invalid corner (make it
+      // isolated).
+      corner_table_->MakeVertexIsolated(vertex_n);
+      if (remove_invalid_vertices) {
+        invalid_vertices.push_back(vertex_n);
+      }
+      active_corner_stack.back() = corner;
+    } else if (symbol == TOPOLOGY_E) {
+      const CornerIndex corner(3 * face.value());
+      const VertexIndex first_vert_index = corner_table_->AddNewVertex();
+      // Create three new vertices at the corners of the new face.
+      corner_table_->MapCornerToVertex(corner, first_vert_index);
+      corner_table_->MapCornerToVertex(corner + 1,
+                                       corner_table_->AddNewVertex());
+      corner_table_->MapCornerToVertex(corner + 2,
+                                       corner_table_->AddNewVertex());
+
+      if (corner_table_->num_vertices() > max_num_vertices) {
+        return -1;  // Unexpected number of decoded vertices.
+      }
+
+      corner_table_->SetLeftMostCorner(first_vert_index, corner);
+      corner_table_->SetLeftMostCorner(first_vert_index + 1, corner + 1);
+      corner_table_->SetLeftMostCorner(first_vert_index + 2, corner + 2);
+      // Add the tip corner to the active stack.
+      active_corner_stack.push_back(corner);
+      check_topology_split = true;
+    } else {
+      // Error. Unknown symbol decoded.
+      return -1;
+    }
+    // Inform the traversal decoder that a new corner has been reached.
+    traversal_decoder_.NewActiveCornerReached(active_corner_stack.back());
+
+    if (check_topology_split) {
+      // Check for topology splits happens only for TOPOLOGY_L, TOPOLOGY_R and
+      // TOPOLOGY_E symbols because those are the symbols that correspond to
+      // faces that can be directly connected a TOPOLOGY_S face through the
+      // topology split event.
+      // If a topology split is detected, we need to add a new active edge
+      // onto the active_corner_stack because it will be used later when the
+      // corresponding TOPOLOGY_S event is decoded.
+
+      // Symbol id used by the encoder (reverse).
+      const int encoder_symbol_id = num_symbols - symbol_id - 1;
+      EdgeFaceName split_edge;
+      int encoder_split_symbol_id;
+      while (IsTopologySplit(encoder_symbol_id, &split_edge,
+                             &encoder_split_symbol_id)) {
+        if (encoder_split_symbol_id < 0) {
+          return -1;  // Wrong split symbol id.
+        }
+        // Symbol was part of a topology split. Now we need to determine which
+        // edge should be added to the active edges stack.
+        const CornerIndex act_top_corner = active_corner_stack.back();
+        // The current symbol has one active edge (stored in act_top_corner) and
+        // two remaining inactive edges that are attached to it.
+        //              *
+        //             / \
+        //  left_edge /   \ right_edge
+        //           /     \
+        //          *.......*
+        //         active_edge
+
+        CornerIndex new_active_corner;
+        if (split_edge == RIGHT_FACE_EDGE) {
+          new_active_corner = corner_table_->Next(act_top_corner);
+        } else {
+          new_active_corner = corner_table_->Previous(act_top_corner);
+        }
+        // Add the new active edge.
+        // Convert the encoder split symbol id to decoder symbol id.
+        const int decoder_split_symbol_id =
+            num_symbols - encoder_split_symbol_id - 1;
+        topology_split_active_corners[decoder_split_symbol_id] =
+            new_active_corner;
+      }
+    }
+  }
+  if (corner_table_->num_vertices() > max_num_vertices) {
+    return -1;  // Unexpected number of decoded vertices.
+  }
+  // Decode start faces and connect them to the faces from the active stack.
+  while (active_corner_stack.size() > 0) {
+    const CornerIndex corner = active_corner_stack.back();
+    active_corner_stack.pop_back();
+    const bool interior_face =
+        traversal_decoder_.DecodeStartFaceConfiguration();
+    if (interior_face) {
+      // The start face is interior, we need to find three corners that are
+      // opposite to it. The first opposite corner "a" is the corner from the
+      // top of the active corner stack and the remaining two corners "b" and
+      // "c" are then the next corners from the left-most corners of vertices
+      // "n" and "x" respectively.
+      //
+      //           *-------*
+      //          / \     / \
+      //         /   \   /   \
+      //        /     \ /     \
+      //       *-------p-------*
+      //      / \a    . .    c/ \
+      //     /   \   .   .   /   \
+      //    /     \ .  I  . /     \
+      //   *-------n.......x------*
+      //    \     / \     / \     /
+      //     \   /   \   /   \   /
+      //      \ /     \b/     \ /
+      //       *-------*-------*
+      //
+
+      if (num_faces >= corner_table_->num_faces()) {
+        return -1;  // More faces than expected added to the mesh.
+      }
+
+      const CornerIndex corner_a = corner;
+      const VertexIndex vert_n =
+          corner_table_->Vertex(corner_table_->Next(corner_a));
+      const CornerIndex corner_b =
+          corner_table_->Next(corner_table_->LeftMostCorner(vert_n));
+
+      const VertexIndex vert_x =
+          corner_table_->Vertex(corner_table_->Next(corner_b));
+      const CornerIndex corner_c =
+          corner_table_->Next(corner_table_->LeftMostCorner(vert_x));
+
+      const VertexIndex vert_p =
+          corner_table_->Vertex(corner_table_->Next(corner_c));
+
+      const FaceIndex face(num_faces++);
+      // The first corner of the initial face is the corner opposite to "a".
+      const CornerIndex new_corner(3 * face.value());
+      SetOppositeCorners(new_corner, corner);
+      SetOppositeCorners(new_corner + 1, corner_b);
+      SetOppositeCorners(new_corner + 2, corner_c);
+
+      // Map new corners to existing vertices.
+      corner_table_->MapCornerToVertex(new_corner, vert_x);
+      corner_table_->MapCornerToVertex(new_corner + 1, vert_p);
+      corner_table_->MapCornerToVertex(new_corner + 2, vert_n);
+
+      // Mark all three vertices as interior.
+      for (int ci = 0; ci < 3; ++ci) {
+        is_vert_hole_[corner_table_->Vertex(new_corner + ci).value()] = false;
+      }
+
+      init_face_configurations_.push_back(true);
+      init_corners_.push_back(new_corner);
+    } else {
+      // The initial face wasn't interior and the traversal had to start from
+      // an open boundary. In this case no new face is added, but we need to
+      // keep record about the first opposite corner to this boundary.
+      init_face_configurations_.push_back(false);
+      init_corners_.push_back(corner);
+    }
+  }
+  if (num_faces != corner_table_->num_faces()) {
+    return -1;  // Unexpected number of decoded faces.
+  }
+
+  int num_vertices = corner_table_->num_vertices();
+  // If any vertex was marked as isolated, we want to remove it from the corner
+  // table to ensure that all vertices in range <0, num_vertices> are valid.
+  for (const VertexIndex invalid_vert : invalid_vertices) {
+    // Find the last valid vertex and swap it with the isolated vertex.
+    VertexIndex src_vert(num_vertices - 1);
+    while (corner_table_->LeftMostCorner(src_vert) == kInvalidCornerIndex) {
+      // The last vertex is invalid, proceed to the previous one.
+      src_vert = VertexIndex(--num_vertices - 1);
+    }
+    if (src_vert < invalid_vert) {
+      continue;  // No need to swap anything.
+    }
+
+    // Remap all corners mapped to |src_vert| to |invalid_vert|.
+    VertexCornersIterator<CornerTable> vcit(corner_table_.get(), src_vert);
+    for (; !vcit.End(); ++vcit) {
+      const CornerIndex cid = vcit.Corner();
+      corner_table_->MapCornerToVertex(cid, invalid_vert);
+    }
+    corner_table_->SetLeftMostCorner(invalid_vert,
+                                     corner_table_->LeftMostCorner(src_vert));
+
+    // Make the |src_vert| invalid.
+    corner_table_->MakeVertexIsolated(src_vert);
+    is_vert_hole_[invalid_vert.value()] = is_vert_hole_[src_vert.value()];
+    is_vert_hole_[src_vert.value()] = false;
+
+    // The last vertex is now invalid.
+    num_vertices--;
+  }
+  return num_vertices;
+}
+
+template <class TraversalDecoder>
+int32_t
+MeshEdgebreakerDecoderImpl<TraversalDecoder>::DecodeHoleAndTopologySplitEvents(
+    DecoderBuffer *decoder_buffer) {
+  // Prepare a new decoder from the provided buffer offset.
+  uint32_t num_topology_splits;
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+    if (!decoder_buffer->Decode(&num_topology_splits)) {
+      return -1;
+    }
+
+  } else
+#endif
+  {
+    if (!DecodeVarint(&num_topology_splits, decoder_buffer)) {
+      return -1;
+    }
+  }
+  if (num_topology_splits > 0) {
+    if (num_topology_splits >
+        static_cast<uint32_t>(corner_table_->num_faces())) {
+      return -1;
+    }
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+    if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(1, 2)) {
+      for (uint32_t i = 0; i < num_topology_splits; ++i) {
+        TopologySplitEventData event_data;
+        if (!decoder_buffer->Decode(&event_data.split_symbol_id)) {
+          return -1;
+        }
+        if (!decoder_buffer->Decode(&event_data.source_symbol_id)) {
+          return -1;
+        }
+        uint8_t edge_data;
+        if (!decoder_buffer->Decode(&edge_data)) {
+          return -1;
+        }
+        event_data.source_edge = edge_data & 1;
+        topology_split_data_.push_back(event_data);
+      }
+
+    } else
+#endif
+    {
+      // Decode source and split symbol ids using delta and varint coding. See
+      // description in mesh_edgebreaker_encoder_impl.cc for more details.
+      int last_source_symbol_id = 0;
+      for (uint32_t i = 0; i < num_topology_splits; ++i) {
+        TopologySplitEventData event_data;
+        uint32_t delta;
+        if (!DecodeVarint<uint32_t>(&delta, decoder_buffer)) {
+          return -1;
+        }
+        event_data.source_symbol_id = delta + last_source_symbol_id;
+        if (!DecodeVarint<uint32_t>(&delta, decoder_buffer)) {
+          return -1;
+        }
+        if (delta > event_data.source_symbol_id) {
+          return -1;
+        }
+        event_data.split_symbol_id =
+            event_data.source_symbol_id - static_cast<int32_t>(delta);
+        last_source_symbol_id = event_data.source_symbol_id;
+        topology_split_data_.push_back(event_data);
+      }
+      // Split edges are decoded from a direct bit decoder.
+      decoder_buffer->StartBitDecoding(false, nullptr);
+      for (uint32_t i = 0; i < num_topology_splits; ++i) {
+        uint32_t edge_data;
+        if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+          decoder_buffer->DecodeLeastSignificantBits32(2, &edge_data);
+        } else {
+          decoder_buffer->DecodeLeastSignificantBits32(1, &edge_data);
+        }
+        TopologySplitEventData &event_data = topology_split_data_[i];
+        event_data.source_edge = edge_data & 1;
+      }
+      decoder_buffer->EndBitDecoding();
+    }
+  }
+  uint32_t num_hole_events = 0;
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+    if (!decoder_buffer->Decode(&num_hole_events)) {
+      return -1;
+    }
+  } else if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 1)) {
+    if (!DecodeVarint(&num_hole_events, decoder_buffer)) {
+      return -1;
+    }
+  }
+#endif
+  if (num_hole_events > 0) {
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+    if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(1, 2)) {
+      for (uint32_t i = 0; i < num_hole_events; ++i) {
+        HoleEventData event_data;
+        if (!decoder_buffer->Decode(&event_data)) {
+          return -1;
+        }
+        hole_event_data_.push_back(event_data);
+      }
+
+    } else
+#endif
+    {
+      // Decode hole symbol ids using delta and varint coding.
+      int last_symbol_id = 0;
+      for (uint32_t i = 0; i < num_hole_events; ++i) {
+        HoleEventData event_data;
+        uint32_t delta;
+        if (!DecodeVarint<uint32_t>(&delta, decoder_buffer)) {
+          return -1;
+        }
+        event_data.symbol_id = delta + last_symbol_id;
+        last_symbol_id = event_data.symbol_id;
+        hole_event_data_.push_back(event_data);
+      }
+    }
+  }
+  return static_cast<int32_t>(decoder_buffer->decoded_size());
+}
+
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+template <class TraversalDecoder>
+bool MeshEdgebreakerDecoderImpl<TraversalDecoder>::
+    DecodeAttributeConnectivitiesOnFaceLegacy(CornerIndex corner) {
+  // Three corners of the face.
+  const CornerIndex corners[3] = {corner, corner_table_->Next(corner),
+                                  corner_table_->Previous(corner)};
+
+  for (int c = 0; c < 3; ++c) {
+    const CornerIndex opp_corner = corner_table_->Opposite(corners[c]);
+    if (opp_corner == kInvalidCornerIndex) {
+      // Don't decode attribute seams on boundary edges (every boundary edge
+      // is automatically an attribute seam).
+      for (uint32_t i = 0; i < attribute_data_.size(); ++i) {
+        attribute_data_[i].attribute_seam_corners.push_back(corners[c].value());
+      }
+      continue;
+    }
+
+    for (uint32_t i = 0; i < attribute_data_.size(); ++i) {
+      const bool is_seam = traversal_decoder_.DecodeAttributeSeam(i);
+      if (is_seam) {
+        attribute_data_[i].attribute_seam_corners.push_back(corners[c].value());
+      }
+    }
+  }
+  return true;
+}
+#endif
+
+template <class TraversalDecoder>
+bool MeshEdgebreakerDecoderImpl<
+    TraversalDecoder>::DecodeAttributeConnectivitiesOnFace(CornerIndex corner) {
+  // Three corners of the face.
+  const CornerIndex corners[3] = {corner, corner_table_->Next(corner),
+                                  corner_table_->Previous(corner)};
+
+  const FaceIndex src_face_id = corner_table_->Face(corner);
+  for (int c = 0; c < 3; ++c) {
+    const CornerIndex opp_corner = corner_table_->Opposite(corners[c]);
+    if (opp_corner == kInvalidCornerIndex) {
+      // Don't decode attribute seams on boundary edges (every boundary edge
+      // is automatically an attribute seam).
+      for (uint32_t i = 0; i < attribute_data_.size(); ++i) {
+        attribute_data_[i].attribute_seam_corners.push_back(corners[c].value());
+      }
+      continue;
+    }
+    const FaceIndex opp_face_id = corner_table_->Face(opp_corner);
+    // Don't decode edges when the opposite face has been already processed.
+    if (opp_face_id < src_face_id) {
+      continue;
+    }
+
+    for (uint32_t i = 0; i < attribute_data_.size(); ++i) {
+      const bool is_seam = traversal_decoder_.DecodeAttributeSeam(i);
+      if (is_seam) {
+        attribute_data_[i].attribute_seam_corners.push_back(corners[c].value());
+      }
+    }
+  }
+  return true;
+}
+
+template <class TraversalDecoder>
+bool MeshEdgebreakerDecoderImpl<TraversalDecoder>::AssignPointsToCorners(
+    int num_connectivity_verts) {
+  // Map between the existing and deduplicated point ids.
+  // Note that at this point we have one point id for each corner of the
+  // mesh so there is corner_table_->num_corners() point ids.
+  decoder_->mesh()->SetNumFaces(corner_table_->num_faces());
+
+  if (attribute_data_.empty()) {
+    // We have connectivity for position only. In this case all vertex indices
+    // are equal to point indices.
+    for (FaceIndex f(0); f < decoder_->mesh()->num_faces(); ++f) {
+      Mesh::Face face;
+      const CornerIndex start_corner(3 * f.value());
+      for (int c = 0; c < 3; ++c) {
+        // Get the vertex index on the corner and use it as a point index.
+        const int32_t vert_id = corner_table_->Vertex(start_corner + c).value();
+        face[c] = vert_id;
+      }
+      decoder_->mesh()->SetFace(f, face);
+    }
+    decoder_->point_cloud()->set_num_points(num_connectivity_verts);
+    return true;
+  }
+  // Else we need to deduplicate multiple attributes.
+
+  // Map between point id and an associated corner id. Only one corner for
+  // each point is stored. The corners are used to sample the attribute values
+  // in the last stage of the deduplication.
+  std::vector<int32_t> point_to_corner_map;
+  // Map between every corner and their new point ids.
+  std::vector<int32_t> corner_to_point_map(corner_table_->num_corners());
+  for (int v = 0; v < corner_table_->num_vertices(); ++v) {
+    CornerIndex c = corner_table_->LeftMostCorner(VertexIndex(v));
+    if (c == kInvalidCornerIndex) {
+      continue;  // Isolated vertex.
+    }
+    CornerIndex deduplication_first_corner = c;
+    if (is_vert_hole_[v]) {
+      // If the vertex is on a boundary, start deduplication from the left most
+      // corner that is guaranteed to lie on the boundary.
+      deduplication_first_corner = c;
+    } else {
+      // If we are not on the boundary we need to find the first seam (of any
+      // attribute).
+      for (uint32_t i = 0; i < attribute_data_.size(); ++i) {
+        if (!attribute_data_[i].connectivity_data.IsCornerOnSeam(c)) {
+          continue;  // No seam for this attribute, ignore it.
+        }
+        // Else there needs to be at least one seam edge.
+
+        // At this point, we use identity mapping between corners and point ids.
+        const VertexIndex vert_id =
+            attribute_data_[i].connectivity_data.Vertex(c);
+        CornerIndex act_c = corner_table_->SwingRight(c);
+        bool seam_found = false;
+        while (act_c != c) {
+          if (act_c == kInvalidCornerIndex) {
+            return false;
+          }
+          if (attribute_data_[i].connectivity_data.Vertex(act_c) != vert_id) {
+            // Attribute seam found. Stop.
+            deduplication_first_corner = act_c;
+            seam_found = true;
+            break;
+          }
+          act_c = corner_table_->SwingRight(act_c);
+        }
+        if (seam_found) {
+          break;  // No reason to process other attributes if we found a seam.
+        }
+      }
+    }
+
+    // Do a deduplication pass over the corners on the processed vertex.
+    // At this point each corner corresponds to one point id and our goal is to
+    // merge similar points into a single point id.
+    // We do a single pass in a clockwise direction over the corners and we add
+    // a new point id whenever one of the attributes change.
+    c = deduplication_first_corner;
+    // Create a new point.
+    corner_to_point_map[c.value()] =
+        static_cast<uint32_t>(point_to_corner_map.size());
+    point_to_corner_map.push_back(c.value());
+    // Traverse in CW direction.
+    CornerIndex prev_c = c;
+    c = corner_table_->SwingRight(c);
+    while (c != kInvalidCornerIndex && c != deduplication_first_corner) {
+      bool attribute_seam = false;
+      for (uint32_t i = 0; i < attribute_data_.size(); ++i) {
+        if (attribute_data_[i].connectivity_data.Vertex(c) !=
+            attribute_data_[i].connectivity_data.Vertex(prev_c)) {
+          // Attribute index changed from the previous corner. We need to add a
+          // new point here.
+          attribute_seam = true;
+          break;
+        }
+      }
+      if (attribute_seam) {
+        corner_to_point_map[c.value()] =
+            static_cast<uint32_t>(point_to_corner_map.size());
+        point_to_corner_map.push_back(c.value());
+      } else {
+        corner_to_point_map[c.value()] = corner_to_point_map[prev_c.value()];
+      }
+      prev_c = c;
+      c = corner_table_->SwingRight(c);
+    }
+  }
+  // Add faces.
+  for (FaceIndex f(0); f < decoder_->mesh()->num_faces(); ++f) {
+    Mesh::Face face;
+    for (int c = 0; c < 3; ++c) {
+      // Remap old points to the new ones.
+      face[c] = corner_to_point_map[3 * f.value() + c];
+    }
+    decoder_->mesh()->SetFace(f, face);
+  }
+  decoder_->point_cloud()->set_num_points(
+      static_cast<uint32_t>(point_to_corner_map.size()));
+  return true;
+}
+
+template class MeshEdgebreakerDecoderImpl<MeshEdgebreakerTraversalDecoder>;
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+template class MeshEdgebreakerDecoderImpl<
+    MeshEdgebreakerTraversalPredictiveDecoder>;
+#endif
+template class MeshEdgebreakerDecoderImpl<
+    MeshEdgebreakerTraversalValenceDecoder>;
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder_impl.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder_impl.h
new file mode 100644
index 000000000..78053f91d
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder_impl.h
@@ -0,0 +1,228 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_IMPL_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_IMPL_H_
+
+#include <unordered_map>
+#include <unordered_set>
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/compression/mesh/mesh_edgebreaker_decoder_impl_interface.h"
+#include "draco/compression/mesh/mesh_edgebreaker_shared.h"
+#include "draco/compression/mesh/traverser/mesh_traversal_sequencer.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/draco_features.h"
+#include "draco/mesh/corner_table.h"
+#include "draco/mesh/mesh_attribute_corner_table.h"
+
+namespace draco {
+
+// Implementation of the edgebreaker decoder that decodes data encoded with the
+// MeshEdgebreakerEncoderImpl class. The implementation of the decoder is based
+// on the algorithm presented in Isenburg et al'02 "Spirale Reversi: Reverse
+// decoding of the Edgebreaker encoding". Note that the encoding is still based
+// on the standard edgebreaker method as presented in "3D Compression
+// Made Simple: Edgebreaker on a Corner-Table" by Rossignac at al.'01.
+// http://www.cc.gatech.edu/~jarek/papers/CornerTableSMI.pdf. One difference is
+// caused by the properties of the spirale reversi algorithm that decodes the
+// symbols from the last one to the first one. To make the decoding more
+// efficient, we encode all symbols in the reverse order, therefore the decoder
+// can process them one by one.
+// The main advantage of the spirale reversi method is that the partially
+// decoded mesh has valid connectivity data at any time during the decoding
+// process (valid with respect to the decoded portion of the mesh). The standard
+// Edgebreaker decoder used two passes (forward decoding + zipping) which not
+// only prevented us from having a valid connectivity but it was also slower.
+// The main benefit of having the valid connectivity is that we can use the
+// known connectivity to predict encoded symbols that can improve the
+// compression rate.
+template <class TraversalDecoderT>
+class MeshEdgebreakerDecoderImpl : public MeshEdgebreakerDecoderImplInterface {
+ public:
+  MeshEdgebreakerDecoderImpl();
+  bool Init(MeshEdgebreakerDecoder *decoder) override;
+
+  const MeshAttributeCornerTable *GetAttributeCornerTable(
+      int att_id) const override;
+  const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int att_id) const override;
+
+  bool CreateAttributesDecoder(int32_t att_decoder_id) override;
+  bool DecodeConnectivity() override;
+  bool OnAttributesDecoded() override;
+  MeshEdgebreakerDecoder *GetDecoder() const override { return decoder_; }
+  const CornerTable *GetCornerTable() const override {
+    return corner_table_.get();
+  }
+
+ private:
+  // Creates a vertex traversal sequencer for the specified |TraverserT| type.
+  template <class TraverserT>
+  std::unique_ptr<PointsSequencer> CreateVertexTraversalSequencer(
+      MeshAttributeIndicesEncodingData *encoding_data);
+
+  // Decodes connectivity between vertices (vertex indices).
+  // Returns the number of vertices created by the decoder or -1 on error.
+  int DecodeConnectivity(int num_symbols);
+
+  // Returns true if the current symbol was part of a topology split event. This
+  // means that the current face was connected to the left edge of a face
+  // encoded with the TOPOLOGY_S symbol. |out_symbol_edge| can be used to
+  // identify which edge of the source symbol was connected to the TOPOLOGY_S
+  // symbol.
+  bool IsTopologySplit(int encoder_symbol_id, EdgeFaceName *out_face_edge,
+                       int *out_encoder_split_symbol_id) {
+    if (topology_split_data_.size() == 0) {
+      return false;
+    }
+    if (topology_split_data_.back().source_symbol_id >
+        static_cast<uint32_t>(encoder_symbol_id)) {
+      // Something is wrong; if the desired source symbol is greater than the
+      // current encoder_symbol_id, we missed it, or the input was tampered
+      // (|encoder_symbol_id| keeps decreasing).
+      // Return invalid symbol id to notify the decoder that there was an
+      // error.
+      *out_encoder_split_symbol_id = -1;
+      return true;
+    }
+    if (topology_split_data_.back().source_symbol_id != encoder_symbol_id) {
+      return false;
+    }
+    *out_face_edge =
+        static_cast<EdgeFaceName>(topology_split_data_.back().source_edge);
+    *out_encoder_split_symbol_id = topology_split_data_.back().split_symbol_id;
+    // Remove the latest split event.
+    topology_split_data_.pop_back();
+    return true;
+  }
+
+  // Decodes event data for hole and topology split events and stores them for
+  // future use.
+  // Returns the number of parsed bytes, or -1 on error.
+  int32_t DecodeHoleAndTopologySplitEvents(DecoderBuffer *decoder_buffer);
+
+  // Decodes all non-position attribute connectivity on the currently
+  // processed face.
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  bool DecodeAttributeConnectivitiesOnFaceLegacy(CornerIndex corner);
+#endif
+  bool DecodeAttributeConnectivitiesOnFace(CornerIndex corner);
+
+  // Initializes mapping between corners and point ids.
+  bool AssignPointsToCorners(int num_connectivity_verts);
+
+  bool IsFaceVisited(CornerIndex corner_id) const {
+    if (corner_id < 0) {
+      return true;  // Invalid corner signalizes that the face does not exist.
+    }
+    return visited_faces_[corner_table_->Face(corner_id).value()];
+  }
+
+  void SetOppositeCorners(CornerIndex corner_0, CornerIndex corner_1) {
+    corner_table_->SetOppositeCorner(corner_0, corner_1);
+    corner_table_->SetOppositeCorner(corner_1, corner_0);
+  }
+
+  MeshEdgebreakerDecoder *decoder_;
+
+  std::unique_ptr<CornerTable> corner_table_;
+
+  // Stack used for storing corners that need to be traversed when decoding
+  // mesh vertices. New corner is added for each initial face and a split
+  // symbol, and one corner is removed when the end symbol is reached.
+  // Stored as member variable to prevent frequent memory reallocations when
+  // handling meshes with lots of disjoint components.  Originally, we used
+  // recursive functions to handle this behavior, but that can cause stack
+  // memory overflow when compressing huge meshes.
+  std::vector<CornerIndex> corner_traversal_stack_;
+
+  // Array stores the number of visited visited for each mesh traversal.
+  std::vector<int> vertex_traversal_length_;
+
+  // List of decoded topology split events.
+  std::vector<TopologySplitEventData> topology_split_data_;
+
+  // List of decoded hole events.
+  std::vector<HoleEventData> hole_event_data_;
+
+  // Configuration of the initial face for each mesh component.
+  std::vector<bool> init_face_configurations_;
+
+  // Initial corner for each traversal.
+  std::vector<CornerIndex> init_corners_;
+
+  // Id of the last processed input symbol.
+  int last_symbol_id_;
+
+  // Id of the last decoded vertex.
+  int last_vert_id_;
+
+  // Id of the last decoded face.
+  int last_face_id_;
+
+  // Array for marking visited faces.
+  std::vector<bool> visited_faces_;
+  // Array for marking visited vertices.
+  std::vector<bool> visited_verts_;
+  // Array for marking vertices on open boundaries.
+  std::vector<bool> is_vert_hole_;
+
+  // The number of new vertices added by the encoder (because of non-manifold
+  // vertices on the input mesh).
+  // If there are no non-manifold edges/vertices on the input mesh, this should
+  // be 0.
+  int num_new_vertices_;
+  // For every newly added vertex, this array stores it's mapping to the
+  // parent vertex id of the encoded mesh.
+  std::unordered_map<int, int> new_to_parent_vertex_map_;
+  // The number of vertices that were encoded (can be different from the number
+  // of vertices of the input mesh).
+  int num_encoded_vertices_;
+
+  // Array for storing the encoded corner ids in the order their associated
+  // vertices were decoded.
+  std::vector<int32_t> processed_corner_ids_;
+
+  // Array storing corners in the order they were visited during the
+  // connectivity decoding (always storing the tip corner of each newly visited
+  // face).
+  std::vector<int> processed_connectivity_corners_;
+
+  MeshAttributeIndicesEncodingData pos_encoding_data_;
+
+  // Id of an attributes decoder that uses |pos_encoding_data_|.
+  int pos_data_decoder_id_;
+
+  // Data for non-position attributes used by the decoder.
+  struct AttributeData {
+    AttributeData() : decoder_id(-1), is_connectivity_used(true) {}
+    // Id of the attribute decoder that was used to decode this attribute data.
+    int decoder_id;
+    MeshAttributeCornerTable connectivity_data;
+    // Flag that can mark the connectivity_data invalid. In such case the base
+    // corner table of the mesh should be used instead.
+    bool is_connectivity_used;
+    MeshAttributeIndicesEncodingData encoding_data;
+    // Opposite corners to attribute seam edges.
+    std::vector<int32_t> attribute_seam_corners;
+  };
+  std::vector<AttributeData> attribute_data_;
+
+  TraversalDecoderT traversal_decoder_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_IMPL_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder_impl_interface.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder_impl_interface.h
new file mode 100644
index 000000000..31fabf252
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder_impl_interface.h
@@ -0,0 +1,47 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_IMPL_INTERFACE_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_IMPL_INTERFACE_H_
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/mesh/mesh_attribute_corner_table.h"
+
+namespace draco {
+
+// Forward declaration is necessary here to avoid circular dependencies.
+class MeshEdgebreakerDecoder;
+
+// Abstract interface used by MeshEdgebreakerDecoder to interact with the actual
+// implementation of the edgebreaker decoding method.
+class MeshEdgebreakerDecoderImplInterface {
+ public:
+  virtual ~MeshEdgebreakerDecoderImplInterface() = default;
+  virtual bool Init(MeshEdgebreakerDecoder *decoder) = 0;
+
+  virtual const MeshAttributeCornerTable *GetAttributeCornerTable(
+      int att_id) const = 0;
+  virtual const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int att_id) const = 0;
+  virtual bool CreateAttributesDecoder(int32_t att_decoder_id) = 0;
+  virtual bool DecodeConnectivity() = 0;
+  virtual bool OnAttributesDecoded() = 0;
+
+  virtual MeshEdgebreakerDecoder *GetDecoder() const = 0;
+  virtual const CornerTable *GetCornerTable() const = 0;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_IMPL_INTERFACE_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder.cc
new file mode 100644
index 000000000..5aff5d8cc
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder.cc
@@ -0,0 +1,195 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/mesh/mesh_edgebreaker_encoder.h"
+
+#include "draco/compression/mesh/mesh_edgebreaker_encoder_impl.h"
+#include "draco/compression/mesh/mesh_edgebreaker_traversal_predictive_encoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_traversal_valence_encoder.h"
+
+namespace draco {
+
+MeshEdgebreakerEncoder::MeshEdgebreakerEncoder() {}
+
+bool MeshEdgebreakerEncoder::InitializeEncoder() {
+  const bool is_standard_edgebreaker_available =
+      options()->IsFeatureSupported(features::kEdgebreaker);
+  const bool is_predictive_edgebreaker_available =
+      options()->IsFeatureSupported(features::kPredictiveEdgebreaker);
+
+  impl_ = nullptr;
+  // For tiny meshes it's usually better to use the basic edgebreaker as the
+  // overhead of the predictive one may turn out to be too big.
+  // TODO(b/111065939): Check if this can be improved.
+  const bool is_tiny_mesh = mesh()->num_faces() < 1000;
+
+  int selected_edgebreaker_method =
+      options()->GetGlobalInt("edgebreaker_method", -1);
+  if (selected_edgebreaker_method == -1) {
+    if (is_standard_edgebreaker_available &&
+        (options()->GetSpeed() >= 5 || !is_predictive_edgebreaker_available ||
+         is_tiny_mesh)) {
+      selected_edgebreaker_method = MESH_EDGEBREAKER_STANDARD_ENCODING;
+    } else {
+      selected_edgebreaker_method = MESH_EDGEBREAKER_VALENCE_ENCODING;
+    }
+  }
+
+  if (selected_edgebreaker_method == MESH_EDGEBREAKER_STANDARD_ENCODING) {
+    if (is_standard_edgebreaker_available) {
+      buffer()->Encode(
+          static_cast<uint8_t>(MESH_EDGEBREAKER_STANDARD_ENCODING));
+      impl_ = std::unique_ptr<MeshEdgebreakerEncoderImplInterface>(
+          new MeshEdgebreakerEncoderImpl<MeshEdgebreakerTraversalEncoder>());
+    }
+  } else if (selected_edgebreaker_method == MESH_EDGEBREAKER_VALENCE_ENCODING) {
+    buffer()->Encode(static_cast<uint8_t>(MESH_EDGEBREAKER_VALENCE_ENCODING));
+    impl_ = std::unique_ptr<MeshEdgebreakerEncoderImplInterface>(
+        new MeshEdgebreakerEncoderImpl<
+            MeshEdgebreakerTraversalValenceEncoder>());
+  }
+  if (!impl_) {
+    return false;
+  }
+  if (!impl_->Init(this)) {
+    return false;
+  }
+  return true;
+}
+
+bool MeshEdgebreakerEncoder::GenerateAttributesEncoder(int32_t att_id) {
+  if (!impl_->GenerateAttributesEncoder(att_id)) {
+    return false;
+  }
+  return true;
+}
+
+bool MeshEdgebreakerEncoder::EncodeAttributesEncoderIdentifier(
+    int32_t att_encoder_id) {
+  if (!impl_->EncodeAttributesEncoderIdentifier(att_encoder_id)) {
+    return false;
+  }
+  return true;
+}
+
+Status MeshEdgebreakerEncoder::EncodeConnectivity() {
+  return impl_->EncodeConnectivity();
+}
+
+void MeshEdgebreakerEncoder::ComputeNumberOfEncodedPoints() {
+  if (!impl_) {
+    return;
+  }
+  const CornerTable *const corner_table = impl_->GetCornerTable();
+  if (!corner_table) {
+    return;
+  }
+  size_t num_points =
+      corner_table->num_vertices() - corner_table->NumIsolatedVertices();
+
+  if (mesh()->num_attributes() > 1) {
+    // Gather all corner tables for all non-position attributes.
+    std::vector<const MeshAttributeCornerTable *> attribute_corner_tables;
+    for (int i = 0; i < mesh()->num_attributes(); ++i) {
+      if (mesh()->attribute(i)->attribute_type() ==
+          GeometryAttribute::POSITION) {
+        continue;
+      }
+      const MeshAttributeCornerTable *const att_corner_table =
+          GetAttributeCornerTable(i);
+      // Attribute corner table may not be used in some configurations. For
+      // these cases we can assume the attribute connectivity to be the same as
+      // the connectivity of the position data.
+      if (att_corner_table) {
+        attribute_corner_tables.push_back(att_corner_table);
+      }
+    }
+
+    // Add a new point based on the configuration of interior attribute seams
+    // (replicating what the decoder would do).
+    for (VertexIndex vi(0); vi < corner_table->num_vertices(); ++vi) {
+      if (corner_table->IsVertexIsolated(vi)) {
+        continue;
+      }
+      // Go around all corners of the vertex and keep track of the observed
+      // attribute seams.
+      const CornerIndex first_corner_index = corner_table->LeftMostCorner(vi);
+      const PointIndex first_point_index =
+          mesh()->CornerToPointId(first_corner_index);
+
+      PointIndex last_point_index = first_point_index;
+      CornerIndex last_corner_index = first_corner_index;
+      CornerIndex corner_index = corner_table->SwingRight(first_corner_index);
+      size_t num_attribute_seams = 0;
+      while (corner_index != kInvalidCornerIndex) {
+        const PointIndex point_index = mesh()->CornerToPointId(corner_index);
+        bool seam_found = false;
+        if (point_index != last_point_index) {
+          // Point index changed - new attribute seam detected.
+          seam_found = true;
+          last_point_index = point_index;
+        } else {
+          // Even though point indices matches, there still may be a seam caused
+          // by non-manifold connectivity of non-position attribute data.
+          for (int i = 0; i < attribute_corner_tables.size(); ++i) {
+            if (attribute_corner_tables[i]->Vertex(corner_index) !=
+                attribute_corner_tables[i]->Vertex(last_corner_index)) {
+              seam_found = true;
+              break;  // No need to process other attributes.
+            }
+          }
+        }
+        if (seam_found) {
+          ++num_attribute_seams;
+        }
+
+        if (corner_index == first_corner_index) {
+          break;
+        }
+
+        // Proceed to the next corner
+        last_corner_index = corner_index;
+        corner_index = corner_table->SwingRight(corner_index);
+      }
+
+      if (!corner_table->IsOnBoundary(vi) && num_attribute_seams > 0) {
+        // If the last visited point index is the same as the first point index
+        // we traveled all the way around the vertex. In this case the number of
+        // new points should be num_attribute_seams - 1
+        num_points += num_attribute_seams - 1;
+      } else {
+        // Else the vertex was either on a boundary (i.e. we couldn't travel all
+        // around the vertex), or we ended up at a different point. In both of
+        // these cases, the number of new points is equal to the number of
+        // attribute seams.
+        num_points += num_attribute_seams;
+      }
+    }
+  }
+  set_num_encoded_points(num_points);
+}
+
+void MeshEdgebreakerEncoder::ComputeNumberOfEncodedFaces() {
+  if (!impl_) {
+    return;
+  }
+  const CornerTable *const corner_table = impl_->GetCornerTable();
+  if (!corner_table) {
+    return;
+  }
+  set_num_encoded_faces(corner_table->num_faces() -
+                        corner_table->NumDegeneratedFaces());
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder.h
new file mode 100644
index 000000000..70d4d5061
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder.h
@@ -0,0 +1,73 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_ENCODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_ENCODER_H_
+
+#include <unordered_map>
+
+#include "draco/compression/mesh/mesh_edgebreaker_encoder_impl_interface.h"
+#include "draco/compression/mesh/mesh_edgebreaker_shared.h"
+#include "draco/compression/mesh/mesh_encoder.h"
+#include "draco/mesh/corner_table.h"
+
+namespace draco {
+
+// Class implements the edge breaker geometry compression method as described
+// in "3D Compression Made Simple: Edgebreaker on a Corner-Table" by Rossignac
+// at al.'01. http://www.cc.gatech.edu/~jarek/papers/CornerTableSMI.pdf
+class MeshEdgebreakerEncoder : public MeshEncoder {
+ public:
+  MeshEdgebreakerEncoder();
+
+  const CornerTable *GetCornerTable() const override {
+    return impl_->GetCornerTable();
+  }
+
+  const MeshAttributeCornerTable *GetAttributeCornerTable(
+      int att_id) const override {
+    return impl_->GetAttributeCornerTable(att_id);
+  }
+
+  const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int att_id) const override {
+    return impl_->GetAttributeEncodingData(att_id);
+  }
+
+  uint8_t GetEncodingMethod() const override {
+    return MESH_EDGEBREAKER_ENCODING;
+  }
+
+ protected:
+  bool InitializeEncoder() override;
+  Status EncodeConnectivity() override;
+  bool GenerateAttributesEncoder(int32_t att_id) override;
+  bool EncodeAttributesEncoderIdentifier(int32_t att_encoder_id) override;
+  void ComputeNumberOfEncodedPoints() override;
+  void ComputeNumberOfEncodedFaces() override;
+
+ private:
+  // The actual implementation of the edge breaker method. The implementations
+  // are in general specializations of a template class
+  // MeshEdgebreakerEncoderImpl where the template arguments control encoding
+  // of the connectivity data. The actual implementation is selected in this
+  // class based on the provided encoding options. Because this choice is done
+  // in run-time, the actual implementation has to be hidden behind the
+  // abstract interface MeshEdgebreakerEncoderImplInterface.
+  std::unique_ptr<MeshEdgebreakerEncoderImplInterface> impl_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder_impl.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder_impl.cc
new file mode 100644
index 000000000..0791dc670
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder_impl.cc
@@ -0,0 +1,854 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/mesh/mesh_edgebreaker_encoder_impl.h"
+
+#include <algorithm>
+
+#include "draco/compression/attributes/sequential_attribute_encoders_controller.h"
+#include "draco/compression/mesh/mesh_edgebreaker_encoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_traversal_predictive_encoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_traversal_valence_encoder.h"
+#include "draco/compression/mesh/traverser/depth_first_traverser.h"
+#include "draco/compression/mesh/traverser/max_prediction_degree_traverser.h"
+#include "draco/compression/mesh/traverser/mesh_attribute_indices_encoding_observer.h"
+#include "draco/compression/mesh/traverser/mesh_traversal_sequencer.h"
+#include "draco/compression/mesh/traverser/traverser_base.h"
+#include "draco/mesh/corner_table_iterators.h"
+#include "draco/mesh/mesh_misc_functions.h"
+
+namespace draco {
+// TODO(draco-eng) consider converting 'typedef' to 'using' and deduplicate.
+typedef CornerIndex CornerIndex;
+typedef FaceIndex FaceIndex;
+typedef VertexIndex VertexIndex;
+
+template <class TraversalEncoder>
+MeshEdgebreakerEncoderImpl<TraversalEncoder>::MeshEdgebreakerEncoderImpl()
+    : encoder_(nullptr),
+      mesh_(nullptr),
+      last_encoded_symbol_id_(-1),
+      num_split_symbols_(0),
+      use_single_connectivity_(false) {}
+
+template <class TraversalEncoder>
+bool MeshEdgebreakerEncoderImpl<TraversalEncoder>::Init(
+    MeshEdgebreakerEncoder *encoder) {
+  encoder_ = encoder;
+  mesh_ = encoder->mesh();
+  attribute_encoder_to_data_id_map_.clear();
+
+  if (encoder_->options()->IsGlobalOptionSet("split_mesh_on_seams")) {
+    use_single_connectivity_ =
+        encoder_->options()->GetGlobalBool("split_mesh_on_seams", false);
+  } else if (encoder_->options()->GetSpeed() >= 6) {
+    // Else use default setting based on speed.
+    use_single_connectivity_ = true;
+  } else {
+    use_single_connectivity_ = false;
+  }
+  return true;
+}
+
+template <class TraversalEncoder>
+const MeshAttributeCornerTable *
+MeshEdgebreakerEncoderImpl<TraversalEncoder>::GetAttributeCornerTable(
+    int att_id) const {
+  for (uint32_t i = 0; i < attribute_data_.size(); ++i) {
+    if (attribute_data_[i].attribute_index == att_id) {
+      if (attribute_data_[i].is_connectivity_used) {
+        return &attribute_data_[i].connectivity_data;
+      }
+      return nullptr;
+    }
+  }
+  return nullptr;
+}
+
+template <class TraversalEncoder>
+const MeshAttributeIndicesEncodingData *
+MeshEdgebreakerEncoderImpl<TraversalEncoder>::GetAttributeEncodingData(
+    int att_id) const {
+  for (uint32_t i = 0; i < attribute_data_.size(); ++i) {
+    if (attribute_data_[i].attribute_index == att_id) {
+      return &attribute_data_[i].encoding_data;
+    }
+  }
+  return &pos_encoding_data_;
+}
+
+template <class TraversalEncoder>
+template <class TraverserT>
+std::unique_ptr<PointsSequencer>
+MeshEdgebreakerEncoderImpl<TraversalEncoder>::CreateVertexTraversalSequencer(
+    MeshAttributeIndicesEncodingData *encoding_data) {
+  typedef typename TraverserT::TraversalObserver AttObserver;
+  typedef typename TraverserT::CornerTable CornerTable;
+
+  std::unique_ptr<MeshTraversalSequencer<TraverserT>> traversal_sequencer(
+      new MeshTraversalSequencer<TraverserT>(mesh_, encoding_data));
+
+  AttObserver att_observer(corner_table_.get(), mesh_,
+                           traversal_sequencer.get(), encoding_data);
+
+  TraverserT att_traverser;
+  att_traverser.Init(corner_table_.get(), att_observer);
+
+  // Set order of corners to simulate the corner order of the decoder.
+  traversal_sequencer->SetCornerOrder(processed_connectivity_corners_);
+  traversal_sequencer->SetTraverser(att_traverser);
+  return std::move(traversal_sequencer);
+}
+
+template <class TraversalEncoder>
+bool MeshEdgebreakerEncoderImpl<TraversalEncoder>::GenerateAttributesEncoder(
+    int32_t att_id) {
+  // For now, either create one encoder for each attribute or use a single
+  // encoder for all attributes. Ideally we can share the same encoder for
+  // a sub-set of attributes with the same connectivity (this is especially true
+  // for per-vertex attributes).
+  if (use_single_connectivity_ && GetEncoder()->num_attributes_encoders() > 0) {
+    // We are using single connectivity and we already have an attribute
+    // encoder. Add the attribute to the encoder and return.
+    GetEncoder()->attributes_encoder(0)->AddAttributeId(att_id);
+    return true;
+  }
+  const int32_t element_type =
+      GetEncoder()->mesh()->GetAttributeElementType(att_id);
+  const PointAttribute *const att =
+      GetEncoder()->point_cloud()->attribute(att_id);
+  int32_t att_data_id = -1;
+  for (uint32_t i = 0; i < attribute_data_.size(); ++i) {
+    if (attribute_data_[i].attribute_index == att_id) {
+      att_data_id = i;
+      break;
+    }
+  }
+  MeshTraversalMethod traversal_method = MESH_TRAVERSAL_DEPTH_FIRST;
+  std::unique_ptr<PointsSequencer> sequencer;
+  if (use_single_connectivity_ ||
+      att->attribute_type() == GeometryAttribute::POSITION ||
+      element_type == MESH_VERTEX_ATTRIBUTE ||
+      (element_type == MESH_CORNER_ATTRIBUTE &&
+       attribute_data_[att_data_id].connectivity_data.no_interior_seams())) {
+    // Per-vertex attribute reached, use the basic corner table to traverse the
+    // mesh.
+    MeshAttributeIndicesEncodingData *encoding_data;
+    if (use_single_connectivity_ ||
+        att->attribute_type() == GeometryAttribute::POSITION) {
+      encoding_data = &pos_encoding_data_;
+    } else {
+      encoding_data = &attribute_data_[att_data_id].encoding_data;
+
+      // Ensure we use the correct number of vertices in the encoding data.
+      encoding_data->vertex_to_encoded_attribute_value_index_map.assign(
+          corner_table_->num_vertices(), -1);
+
+      // Mark the attribute specific connectivity data as not used as we use the
+      // position attribute connectivity data.
+      attribute_data_[att_data_id].is_connectivity_used = false;
+    }
+
+    if (GetEncoder()->options()->GetSpeed() == 0 &&
+        att->attribute_type() == GeometryAttribute::POSITION) {
+      traversal_method = MESH_TRAVERSAL_PREDICTION_DEGREE;
+      if (use_single_connectivity_ && mesh_->num_attributes() > 1) {
+        // Make sure we don't use the prediction degree traversal when we encode
+        // multiple attributes using the same connectivity.
+        // TODO(ostava): We should investigate this and see if the prediction
+        // degree can be actually used efficiently for non-position attributes.
+        traversal_method = MESH_TRAVERSAL_DEPTH_FIRST;
+      }
+    }
+    // Defining sequencer via a traversal scheme.
+    if (traversal_method == MESH_TRAVERSAL_PREDICTION_DEGREE) {
+      typedef MeshAttributeIndicesEncodingObserver<CornerTable> AttObserver;
+      typedef MaxPredictionDegreeTraverser<CornerTable, AttObserver>
+          AttTraverser;
+      sequencer = CreateVertexTraversalSequencer<AttTraverser>(encoding_data);
+    } else if (traversal_method == MESH_TRAVERSAL_DEPTH_FIRST) {
+      typedef MeshAttributeIndicesEncodingObserver<CornerTable> AttObserver;
+      typedef DepthFirstTraverser<CornerTable, AttObserver> AttTraverser;
+      sequencer = CreateVertexTraversalSequencer<AttTraverser>(encoding_data);
+    }
+  } else {
+    // Per-corner attribute encoder.
+    typedef MeshAttributeIndicesEncodingObserver<MeshAttributeCornerTable>
+        AttObserver;
+    typedef DepthFirstTraverser<MeshAttributeCornerTable, AttObserver>
+        AttTraverser;
+
+    MeshAttributeIndicesEncodingData *const encoding_data =
+        &attribute_data_[att_data_id].encoding_data;
+    const MeshAttributeCornerTable *const corner_table =
+        &attribute_data_[att_data_id].connectivity_data;
+
+    // Ensure we use the correct number of vertices in the encoding data.
+    attribute_data_[att_data_id]
+        .encoding_data.vertex_to_encoded_attribute_value_index_map.assign(
+            attribute_data_[att_data_id].connectivity_data.num_vertices(), -1);
+
+    std::unique_ptr<MeshTraversalSequencer<AttTraverser>> traversal_sequencer(
+        new MeshTraversalSequencer<AttTraverser>(mesh_, encoding_data));
+
+    AttObserver att_observer(corner_table, mesh_, traversal_sequencer.get(),
+                             encoding_data);
+
+    AttTraverser att_traverser;
+    att_traverser.Init(corner_table, att_observer);
+
+    // Set order of corners to simulate the corner order of the decoder.
+    traversal_sequencer->SetCornerOrder(processed_connectivity_corners_);
+    traversal_sequencer->SetTraverser(att_traverser);
+    sequencer = std::move(traversal_sequencer);
+  }
+
+  if (!sequencer) {
+    return false;
+  }
+
+  if (att_data_id == -1) {
+    pos_traversal_method_ = traversal_method;
+  } else {
+    attribute_data_[att_data_id].traversal_method = traversal_method;
+  }
+
+  std::unique_ptr<SequentialAttributeEncodersController> att_controller(
+      new SequentialAttributeEncodersController(std::move(sequencer), att_id));
+
+  // Update the mapping between the encoder id and the attribute data id.
+  // This will be used by the decoder to select the appropriate attribute
+  // decoder and the correct connectivity.
+  attribute_encoder_to_data_id_map_.push_back(att_data_id);
+  GetEncoder()->AddAttributesEncoder(std::move(att_controller));
+  return true;
+}  // namespace draco
+
+template <class TraversalEncoder>
+bool MeshEdgebreakerEncoderImpl<TraversalEncoder>::
+    EncodeAttributesEncoderIdentifier(int32_t att_encoder_id) {
+  const int8_t att_data_id = attribute_encoder_to_data_id_map_[att_encoder_id];
+  encoder_->buffer()->Encode(att_data_id);
+
+  // Also encode the type of the encoder that we used.
+  int32_t element_type = MESH_VERTEX_ATTRIBUTE;
+  MeshTraversalMethod traversal_method;
+  if (att_data_id >= 0) {
+    const int32_t att_id = attribute_data_[att_data_id].attribute_index;
+    element_type = GetEncoder()->mesh()->GetAttributeElementType(att_id);
+    traversal_method = attribute_data_[att_data_id].traversal_method;
+  } else {
+    traversal_method = pos_traversal_method_;
+  }
+  if (element_type == MESH_VERTEX_ATTRIBUTE ||
+      (element_type == MESH_CORNER_ATTRIBUTE &&
+       attribute_data_[att_data_id].connectivity_data.no_interior_seams())) {
+    // Per-vertex encoder.
+    encoder_->buffer()->Encode(static_cast<uint8_t>(MESH_VERTEX_ATTRIBUTE));
+  } else {
+    // Per-corner encoder.
+    encoder_->buffer()->Encode(static_cast<uint8_t>(MESH_CORNER_ATTRIBUTE));
+  }
+  // Encode the mesh traversal method.
+  encoder_->buffer()->Encode(static_cast<uint8_t>(traversal_method));
+  return true;
+}
+
+template <class TraversalEncoder>
+Status MeshEdgebreakerEncoderImpl<TraversalEncoder>::EncodeConnectivity() {
+  // To encode the mesh, we need face connectivity data stored in a corner
+  // table. To compute the connectivity we must use indices associated with
+  // POSITION attribute, because they define which edges can be connected
+  // together, unless the option |use_single_connectivity_| is set in which case
+  // we break the mesh along attribute seams and use the same connectivity for
+  // all attributes.
+  if (use_single_connectivity_) {
+    corner_table_ = CreateCornerTableFromAllAttributes(mesh_);
+  } else {
+    corner_table_ = CreateCornerTableFromPositionAttribute(mesh_);
+  }
+  if (corner_table_ == nullptr ||
+      corner_table_->num_faces() == corner_table_->NumDegeneratedFaces()) {
+    // Failed to construct the corner table.
+    // TODO(ostava): Add better error reporting.
+    return Status(Status::DRACO_ERROR, "All triangles are degenerate.");
+  }
+
+  traversal_encoder_.Init(this);
+
+  // Also encode the total number of vertices that is going to be encoded.
+  // This can be different from the mesh_->num_points() + num_new_vertices,
+  // because some of the vertices of the input mesh can be ignored (e.g.
+  // vertices on degenerated faces or isolated vertices not attached to any
+  // face).
+  const uint32_t num_vertices_to_be_encoded =
+      corner_table_->num_vertices() - corner_table_->NumIsolatedVertices();
+  EncodeVarint(num_vertices_to_be_encoded, encoder_->buffer());
+
+  const uint32_t num_faces =
+      corner_table_->num_faces() - corner_table_->NumDegeneratedFaces();
+  EncodeVarint(num_faces, encoder_->buffer());
+
+  // Reset encoder data that may have been initialized in previous runs.
+  visited_faces_.assign(mesh_->num_faces(), false);
+  pos_encoding_data_.vertex_to_encoded_attribute_value_index_map.assign(
+      corner_table_->num_vertices(), -1);
+  pos_encoding_data_.encoded_attribute_value_index_to_corner_map.clear();
+  pos_encoding_data_.encoded_attribute_value_index_to_corner_map.reserve(
+      corner_table_->num_faces() * 3);
+  visited_vertex_ids_.assign(corner_table_->num_vertices(), false);
+  vertex_traversal_length_.clear();
+  last_encoded_symbol_id_ = -1;
+  num_split_symbols_ = 0;
+  topology_split_event_data_.clear();
+  face_to_split_symbol_map_.clear();
+  visited_holes_.clear();
+  vertex_hole_id_.assign(corner_table_->num_vertices(), -1);
+  processed_connectivity_corners_.clear();
+  processed_connectivity_corners_.reserve(corner_table_->num_faces());
+  pos_encoding_data_.num_values = 0;
+
+  if (!FindHoles()) {
+    return Status(Status::DRACO_ERROR, "Failed to process mesh holes.");
+  }
+
+  if (!InitAttributeData()) {
+    return Status(Status::DRACO_ERROR, "Failed to initialize attribute data.");
+  }
+
+  const uint8_t num_attribute_data =
+      static_cast<uint8_t>(attribute_data_.size());
+  encoder_->buffer()->Encode(num_attribute_data);
+  traversal_encoder_.SetNumAttributeData(num_attribute_data);
+
+  const int num_corners = corner_table_->num_corners();
+
+  traversal_encoder_.Start();
+
+  std::vector<CornerIndex> init_face_connectivity_corners;
+  // Traverse the surface starting from each unvisited corner.
+  for (int c_id = 0; c_id < num_corners; ++c_id) {
+    CornerIndex corner_index(c_id);
+    const FaceIndex face_id = corner_table_->Face(corner_index);
+    if (visited_faces_[face_id.value()]) {
+      continue;  // Face has been already processed.
+    }
+    if (corner_table_->IsDegenerated(face_id)) {
+      continue;  // Ignore degenerated faces.
+    }
+
+    CornerIndex start_corner;
+    const bool interior_config =
+        FindInitFaceConfiguration(face_id, &start_corner);
+    traversal_encoder_.EncodeStartFaceConfiguration(interior_config);
+
+    if (interior_config) {
+      // Select the correct vertex on the face as the root.
+      corner_index = start_corner;
+      const VertexIndex vert_id = corner_table_->Vertex(corner_index);
+      // Mark all vertices of a given face as visited.
+      const VertexIndex next_vert_id =
+          corner_table_->Vertex(corner_table_->Next(corner_index));
+      const VertexIndex prev_vert_id =
+          corner_table_->Vertex(corner_table_->Previous(corner_index));
+
+      visited_vertex_ids_[vert_id.value()] = true;
+      visited_vertex_ids_[next_vert_id.value()] = true;
+      visited_vertex_ids_[prev_vert_id.value()] = true;
+      // New traversal started. Initiate it's length with the first vertex.
+      vertex_traversal_length_.push_back(1);
+
+      // Mark the face as visited.
+      visited_faces_[face_id.value()] = true;
+      // Start compressing from the opposite face of the "next" corner. This way
+      // the first encoded corner corresponds to the tip corner of the regular
+      // edgebreaker traversal (essentially the initial face can be then viewed
+      // as a TOPOLOGY_C face).
+      init_face_connectivity_corners.push_back(
+          corner_table_->Next(corner_index));
+      const CornerIndex opp_id =
+          corner_table_->Opposite(corner_table_->Next(corner_index));
+      const FaceIndex opp_face_id = corner_table_->Face(opp_id);
+      if (opp_face_id != kInvalidFaceIndex &&
+          !visited_faces_[opp_face_id.value()]) {
+        if (!EncodeConnectivityFromCorner(opp_id)) {
+          return Status(Status::DRACO_ERROR,
+                        "Failed to encode mesh component.");
+        }
+      }
+    } else {
+      // Boundary configuration. We start on a boundary rather than on a face.
+      // First encode the hole that's opposite to the start_corner.
+      EncodeHole(corner_table_->Next(start_corner), true);
+      // Start processing the face opposite to the boundary edge (the face
+      // containing the start_corner).
+      if (!EncodeConnectivityFromCorner(start_corner)) {
+        return Status(Status::DRACO_ERROR, "Failed to encode mesh component.");
+      }
+    }
+  }
+  // Reverse the order of connectivity corners to match the order in which
+  // they are going to be decoded.
+  std::reverse(processed_connectivity_corners_.begin(),
+               processed_connectivity_corners_.end());
+  // Append the init face connectivity corners (which are processed in order by
+  // the decoder after the regular corners.
+  processed_connectivity_corners_.insert(processed_connectivity_corners_.end(),
+                                         init_face_connectivity_corners.begin(),
+                                         init_face_connectivity_corners.end());
+  // Encode connectivity for all non-position attributes.
+  if (attribute_data_.size() > 0) {
+    // Use the same order of corner that will be used by the decoder.
+    visited_faces_.assign(mesh_->num_faces(), false);
+    for (CornerIndex ci : processed_connectivity_corners_) {
+      EncodeAttributeConnectivitiesOnFace(ci);
+    }
+  }
+  traversal_encoder_.Done();
+
+  // Encode the number of symbols.
+  const uint32_t num_encoded_symbols =
+      static_cast<uint32_t>(traversal_encoder_.NumEncodedSymbols());
+  EncodeVarint(num_encoded_symbols, encoder_->buffer());
+
+  // Encode the number of split symbols.
+  EncodeVarint(num_split_symbols_, encoder_->buffer());
+
+  // Append the traversal buffer.
+  if (!EncodeSplitData()) {
+    return Status(Status::DRACO_ERROR, "Failed to encode split data.");
+  }
+  encoder_->buffer()->Encode(traversal_encoder_.buffer().data(),
+                             traversal_encoder_.buffer().size());
+
+  return OkStatus();
+}
+
+template <class TraversalEncoder>
+bool MeshEdgebreakerEncoderImpl<TraversalEncoder>::EncodeSplitData() {
+  uint32_t num_events =
+      static_cast<uint32_t>(topology_split_event_data_.size());
+  EncodeVarint(num_events, encoder_->buffer());
+  if (num_events > 0) {
+    // Encode split symbols using delta and varint coding. Split edges are
+    // encoded using direct bit coding.
+    int last_source_symbol_id = 0;  // Used for delta coding.
+    for (uint32_t i = 0; i < num_events; ++i) {
+      const TopologySplitEventData &event_data = topology_split_event_data_[i];
+      // Encode source symbol id as delta from the previous source symbol id.
+      // Source symbol ids are always stored in increasing order so the delta is
+      // going to be positive.
+      EncodeVarint<uint32_t>(
+          event_data.source_symbol_id - last_source_symbol_id,
+          encoder_->buffer());
+      // Encode split symbol id as delta from the current source symbol id.
+      // Split symbol id is always smaller than source symbol id so the below
+      // delta is going to be positive.
+      EncodeVarint<uint32_t>(
+          event_data.source_symbol_id - event_data.split_symbol_id,
+          encoder_->buffer());
+      last_source_symbol_id = event_data.source_symbol_id;
+    }
+    encoder_->buffer()->StartBitEncoding(num_events, false);
+    for (uint32_t i = 0; i < num_events; ++i) {
+      const TopologySplitEventData &event_data = topology_split_event_data_[i];
+      encoder_->buffer()->EncodeLeastSignificantBits32(1,
+                                                       event_data.source_edge);
+    }
+    encoder_->buffer()->EndBitEncoding();
+  }
+  return true;
+}
+
+template <class TraversalEncoder>
+bool MeshEdgebreakerEncoderImpl<TraversalEncoder>::FindInitFaceConfiguration(
+    FaceIndex face_id, CornerIndex *out_corner) const {
+  CornerIndex corner_index = CornerIndex(3 * face_id.value());
+  for (int i = 0; i < 3; ++i) {
+    if (corner_table_->Opposite(corner_index) == kInvalidCornerIndex) {
+      // If there is a boundary edge, the configuration is exterior and return
+      // the CornerIndex opposite to the first boundary edge.
+      *out_corner = corner_index;
+      return false;
+    }
+    if (vertex_hole_id_[corner_table_->Vertex(corner_index).value()] != -1) {
+      // Boundary vertex found. Find the first boundary edge attached to the
+      // point and return the corner opposite to it.
+      CornerIndex right_corner = corner_index;
+      while (right_corner != kInvalidCornerIndex) {
+        corner_index = right_corner;
+        right_corner = corner_table_->SwingRight(right_corner);
+      }
+      // |corner_index| now lies on a boundary edge and its previous corner is
+      // guaranteed to be the opposite corner of the boundary edge.
+      *out_corner = corner_table_->Previous(corner_index);
+      return false;
+    }
+    corner_index = corner_table_->Next(corner_index);
+  }
+  // Else we have an interior configuration. Return the first corner id.
+  *out_corner = corner_index;
+  return true;
+}
+
+template <class TraversalEncoder>
+bool MeshEdgebreakerEncoderImpl<TraversalEncoder>::EncodeConnectivityFromCorner(
+    CornerIndex corner_id) {
+  corner_traversal_stack_.clear();
+  corner_traversal_stack_.push_back(corner_id);
+  const int num_faces = mesh_->num_faces();
+  while (!corner_traversal_stack_.empty()) {
+    // Currently processed corner.
+    corner_id = corner_traversal_stack_.back();
+    // Make sure the face hasn't been visited yet.
+    if (corner_id == kInvalidCornerIndex ||
+        visited_faces_[corner_table_->Face(corner_id).value()]) {
+      // This face has been already traversed.
+      corner_traversal_stack_.pop_back();
+      continue;
+    }
+    int num_visited_faces = 0;
+    while (num_visited_faces < num_faces) {
+      // Mark the current face as visited.
+      ++num_visited_faces;
+      ++last_encoded_symbol_id_;
+
+      const FaceIndex face_id = corner_table_->Face(corner_id);
+      visited_faces_[face_id.value()] = true;
+      processed_connectivity_corners_.push_back(corner_id);
+      traversal_encoder_.NewCornerReached(corner_id);
+      const VertexIndex vert_id = corner_table_->Vertex(corner_id);
+      const bool on_boundary = (vertex_hole_id_[vert_id.value()] != -1);
+      if (!IsVertexVisited(vert_id)) {
+        // A new unvisited vertex has been reached. We need to store its
+        // position difference using next, prev, and opposite vertices.
+        visited_vertex_ids_[vert_id.value()] = true;
+        if (!on_boundary) {
+          // If the vertex is on boundary it must correspond to an unvisited
+          // hole and it will be encoded with TOPOLOGY_S symbol later).
+          traversal_encoder_.EncodeSymbol(TOPOLOGY_C);
+          // Move to the right triangle.
+          corner_id = GetRightCorner(corner_id);
+          continue;
+        }
+      }
+      // The current vertex has been already visited or it was on a boundary.
+      // We need to determine whether we can visit any of it's neighboring
+      // faces.
+      const CornerIndex right_corner_id = GetRightCorner(corner_id);
+      const CornerIndex left_corner_id = GetLeftCorner(corner_id);
+      const FaceIndex right_face_id = corner_table_->Face(right_corner_id);
+      const FaceIndex left_face_id = corner_table_->Face(left_corner_id);
+      if (IsRightFaceVisited(corner_id)) {
+        // Right face has been already visited.
+        // Check whether there is a topology split event.
+        if (right_face_id != kInvalidFaceIndex) {
+          CheckAndStoreTopologySplitEvent(last_encoded_symbol_id_,
+                                          face_id.value(), RIGHT_FACE_EDGE,
+                                          right_face_id.value());
+        }
+        if (IsLeftFaceVisited(corner_id)) {
+          // Both neighboring faces are visited. End reached.
+          // Check whether there is a topology split event on the left face.
+          if (left_face_id != kInvalidFaceIndex) {
+            CheckAndStoreTopologySplitEvent(last_encoded_symbol_id_,
+                                            face_id.value(), LEFT_FACE_EDGE,
+                                            left_face_id.value());
+          }
+          traversal_encoder_.EncodeSymbol(TOPOLOGY_E);
+          corner_traversal_stack_.pop_back();
+          break;  // Break from the while (num_visited_faces < num_faces) loop.
+        } else {
+          traversal_encoder_.EncodeSymbol(TOPOLOGY_R);
+          // Go to the left face.
+          corner_id = left_corner_id;
+        }
+      } else {
+        // Right face was not visited.
+        if (IsLeftFaceVisited(corner_id)) {
+          // Check whether there is a topology split event on the left face.
+          if (left_face_id != kInvalidFaceIndex) {
+            CheckAndStoreTopologySplitEvent(last_encoded_symbol_id_,
+                                            face_id.value(), LEFT_FACE_EDGE,
+                                            left_face_id.value());
+          }
+          traversal_encoder_.EncodeSymbol(TOPOLOGY_L);
+          // Left face visited, go to the right one.
+          corner_id = right_corner_id;
+        } else {
+          traversal_encoder_.EncodeSymbol(TOPOLOGY_S);
+          ++num_split_symbols_;
+          // Both neighboring faces are unvisited, we need to visit both of
+          // them.
+          if (on_boundary) {
+            // The tip vertex is on a hole boundary. If the hole hasn't been
+            // visited yet we need to encode it.
+            const int hole_id = vertex_hole_id_[vert_id.value()];
+            if (!visited_holes_[hole_id]) {
+              EncodeHole(corner_id, false);
+            }
+          }
+          face_to_split_symbol_map_[face_id.value()] = last_encoded_symbol_id_;
+          // Split the traversal.
+          // First make the top of the current corner stack point to the left
+          // face (this one will be processed second).
+          corner_traversal_stack_.back() = left_corner_id;
+          // Add a new corner to the top of the stack (right face needs to
+          // be traversed first).
+          corner_traversal_stack_.push_back(right_corner_id);
+          // Break from the while (num_visited_faces < num_faces) loop.
+          break;
+        }
+      }
+    }
+  }
+  return true;  // All corners have been processed.
+}
+
+template <class TraversalEncoder>
+int MeshEdgebreakerEncoderImpl<TraversalEncoder>::EncodeHole(
+    CornerIndex start_corner_id, bool encode_first_vertex) {
+  // We know that the start corner lies on a hole but we first need to find the
+  // boundary edge going from that vertex. It is the first edge in CW
+  // direction.
+  CornerIndex corner_id = start_corner_id;
+  corner_id = corner_table_->Previous(corner_id);
+  while (corner_table_->Opposite(corner_id) != kInvalidCornerIndex) {
+    corner_id = corner_table_->Opposite(corner_id);
+    corner_id = corner_table_->Next(corner_id);
+  }
+  const VertexIndex start_vertex_id = corner_table_->Vertex(start_corner_id);
+
+  int num_encoded_hole_verts = 0;
+  if (encode_first_vertex) {
+    visited_vertex_ids_[start_vertex_id.value()] = true;
+    ++num_encoded_hole_verts;
+  }
+
+  // corner_id is now opposite to the boundary edge.
+  // Mark the hole as visited.
+  visited_holes_[vertex_hole_id_[start_vertex_id.value()]] = true;
+  // Get the start vertex of the edge and use it as a reference.
+  VertexIndex start_vert_id =
+      corner_table_->Vertex(corner_table_->Next(corner_id));
+  // Get the end vertex of the edge.
+  VertexIndex act_vertex_id =
+      corner_table_->Vertex(corner_table_->Previous(corner_id));
+  while (act_vertex_id != start_vertex_id) {
+    // Encode the end vertex of the boundary edge.
+
+    start_vert_id = act_vertex_id;
+
+    // Mark the vertex as visited.
+    visited_vertex_ids_[act_vertex_id.value()] = true;
+    ++num_encoded_hole_verts;
+    corner_id = corner_table_->Next(corner_id);
+    // Look for the next attached open boundary edge.
+    while (corner_table_->Opposite(corner_id) != kInvalidCornerIndex) {
+      corner_id = corner_table_->Opposite(corner_id);
+      corner_id = corner_table_->Next(corner_id);
+    }
+    act_vertex_id = corner_table_->Vertex(corner_table_->Previous(corner_id));
+  }
+  return num_encoded_hole_verts;
+}
+
+template <class TraversalEncoder>
+CornerIndex MeshEdgebreakerEncoderImpl<TraversalEncoder>::GetRightCorner(
+    CornerIndex corner_id) const {
+  const CornerIndex next_corner_id = corner_table_->Next(corner_id);
+  return corner_table_->Opposite(next_corner_id);
+}
+
+template <class TraversalEncoder>
+CornerIndex MeshEdgebreakerEncoderImpl<TraversalEncoder>::GetLeftCorner(
+    CornerIndex corner_id) const {
+  const CornerIndex prev_corner_id = corner_table_->Previous(corner_id);
+  return corner_table_->Opposite(prev_corner_id);
+}
+
+template <class TraversalEncoder>
+bool MeshEdgebreakerEncoderImpl<TraversalEncoder>::IsRightFaceVisited(
+    CornerIndex corner_id) const {
+  const CornerIndex next_corner_id = corner_table_->Next(corner_id);
+  const CornerIndex opp_corner_id = corner_table_->Opposite(next_corner_id);
+  if (opp_corner_id != kInvalidCornerIndex) {
+    return visited_faces_[corner_table_->Face(opp_corner_id).value()];
+  }
+  // Else we are on a boundary.
+  return true;
+}
+
+template <class TraversalEncoder>
+bool MeshEdgebreakerEncoderImpl<TraversalEncoder>::IsLeftFaceVisited(
+    CornerIndex corner_id) const {
+  const CornerIndex prev_corner_id = corner_table_->Previous(corner_id);
+  const CornerIndex opp_corner_id = corner_table_->Opposite(prev_corner_id);
+  if (opp_corner_id != kInvalidCornerIndex) {
+    return visited_faces_[corner_table_->Face(opp_corner_id).value()];
+  }
+  // Else we are on a boundary.
+  return true;
+}
+
+template <class TraversalEncoder>
+bool MeshEdgebreakerEncoderImpl<TraversalEncoder>::FindHoles() {
+  // TODO(ostava): Add more error checking for invalid geometry data.
+  const int num_corners = corner_table_->num_corners();
+  // Go over all corners and detect non-visited open boundaries
+  for (CornerIndex i(0); i < num_corners; ++i) {
+    if (corner_table_->IsDegenerated(corner_table_->Face(i))) {
+      continue;  // Don't process corners assigned to degenerated faces.
+    }
+    if (corner_table_->Opposite(i) == kInvalidCornerIndex) {
+      // No opposite corner means no opposite face, so the opposite edge
+      // of the corner is an open boundary.
+      // Check whether we have already traversed the boundary.
+      VertexIndex boundary_vert_id =
+          corner_table_->Vertex(corner_table_->Next(i));
+      if (vertex_hole_id_[boundary_vert_id.value()] != -1) {
+        // The start vertex of the boundary edge is already assigned to an
+        // open boundary. No need to traverse it again.
+        continue;
+      }
+      // Else we found a new open boundary and we are going to traverse along it
+      // and mark all visited vertices.
+      const int boundary_id = static_cast<int>(visited_holes_.size());
+      visited_holes_.push_back(false);
+
+      CornerIndex corner_id = i;
+      while (vertex_hole_id_[boundary_vert_id.value()] == -1) {
+        // Mark the first vertex on the open boundary.
+        vertex_hole_id_[boundary_vert_id.value()] = boundary_id;
+        corner_id = corner_table_->Next(corner_id);
+        // Look for the next attached open boundary edge.
+        while (corner_table_->Opposite(corner_id) != kInvalidCornerIndex) {
+          corner_id = corner_table_->Opposite(corner_id);
+          corner_id = corner_table_->Next(corner_id);
+        }
+        // Id of the next vertex in the vertex on the hole.
+        boundary_vert_id =
+            corner_table_->Vertex(corner_table_->Next(corner_id));
+      }
+    }
+  }
+  return true;
+}
+
+template <class TraversalEncoder>
+int MeshEdgebreakerEncoderImpl<TraversalEncoder>::GetSplitSymbolIdOnFace(
+    int face_id) const {
+  auto it = face_to_split_symbol_map_.find(face_id);
+  if (it == face_to_split_symbol_map_.end()) {
+    return -1;
+  }
+  return it->second;
+}
+
+template <class TraversalEncoder>
+void MeshEdgebreakerEncoderImpl<
+    TraversalEncoder>::CheckAndStoreTopologySplitEvent(int src_symbol_id,
+                                                       int /* src_face_id */,
+                                                       EdgeFaceName src_edge,
+                                                       int neighbor_face_id) {
+  const int symbol_id = GetSplitSymbolIdOnFace(neighbor_face_id);
+  if (symbol_id == -1) {
+    return;  // Not a split symbol, no topology split event could happen.
+  }
+  TopologySplitEventData event_data;
+
+  event_data.split_symbol_id = symbol_id;
+  event_data.source_symbol_id = src_symbol_id;
+  event_data.source_edge = src_edge;
+  topology_split_event_data_.push_back(event_data);
+}
+
+template <class TraversalEncoder>
+bool MeshEdgebreakerEncoderImpl<TraversalEncoder>::InitAttributeData() {
+  if (use_single_connectivity_) {
+    return true;  // All attributes use the same connectivity.
+  }
+
+  const int num_attributes = mesh_->num_attributes();
+  // Ignore the position attribute. It's decoded separately.
+  attribute_data_.resize(num_attributes - 1);
+  if (num_attributes == 1) {
+    return true;
+  }
+  int data_index = 0;
+  for (int i = 0; i < num_attributes; ++i) {
+    const int32_t att_index = i;
+    if (mesh_->attribute(att_index)->attribute_type() ==
+        GeometryAttribute::POSITION) {
+      continue;
+    }
+    const PointAttribute *const att = mesh_->attribute(att_index);
+    attribute_data_[data_index].attribute_index = att_index;
+    attribute_data_[data_index]
+        .encoding_data.encoded_attribute_value_index_to_corner_map.clear();
+    attribute_data_[data_index]
+        .encoding_data.encoded_attribute_value_index_to_corner_map.reserve(
+            corner_table_->num_corners());
+    attribute_data_[data_index].encoding_data.num_values = 0;
+    attribute_data_[data_index].connectivity_data.InitFromAttribute(
+        mesh_, corner_table_.get(), att);
+    ++data_index;
+  }
+  return true;
+}
+
+// TODO(ostava): Note that if the input mesh used the same attribute index on
+// multiple different vertices, such attribute will be duplicated using the
+// encoding below. Eventually, we may consider either using a different encoding
+// scheme for such cases, or at least deduplicating the attributes in the
+// decoder.
+template <class TraversalEncoder>
+bool MeshEdgebreakerEncoderImpl<
+    TraversalEncoder>::EncodeAttributeConnectivitiesOnFace(CornerIndex corner) {
+  // Three corners of the face.
+  const CornerIndex corners[3] = {corner, corner_table_->Next(corner),
+                                  corner_table_->Previous(corner)};
+
+  const FaceIndex src_face_id = corner_table_->Face(corner);
+  visited_faces_[src_face_id.value()] = true;
+  for (int c = 0; c < 3; ++c) {
+    const CornerIndex opp_corner = corner_table_->Opposite(corners[c]);
+    if (opp_corner == kInvalidCornerIndex) {
+      continue;  // Don't encode attribute seams on boundary edges.
+    }
+    const FaceIndex opp_face_id = corner_table_->Face(opp_corner);
+    // Don't encode edges when the opposite face has been already processed.
+    if (visited_faces_[opp_face_id.value()]) {
+      continue;
+    }
+
+    for (uint32_t i = 0; i < attribute_data_.size(); ++i) {
+      if (attribute_data_[i].connectivity_data.IsCornerOppositeToSeamEdge(
+              corners[c])) {
+        traversal_encoder_.EncodeAttributeSeam(i, true);
+      } else {
+        traversal_encoder_.EncodeAttributeSeam(i, false);
+      }
+    }
+  }
+  return true;
+}
+
+template class MeshEdgebreakerEncoderImpl<MeshEdgebreakerTraversalEncoder>;
+template class MeshEdgebreakerEncoderImpl<
+    MeshEdgebreakerTraversalPredictiveEncoder>;
+template class MeshEdgebreakerEncoderImpl<
+    MeshEdgebreakerTraversalValenceEncoder>;
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder_impl.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder_impl.h
new file mode 100644
index 000000000..fb3377163
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder_impl.h
@@ -0,0 +1,210 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_ENCODER_IMPL_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_ENCODER_IMPL_H_
+
+#include <unordered_map>
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/mesh/mesh_edgebreaker_encoder_impl_interface.h"
+#include "draco/compression/mesh/mesh_edgebreaker_shared.h"
+#include "draco/compression/mesh/traverser/mesh_traversal_sequencer.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/mesh/mesh_attribute_corner_table.h"
+
+namespace draco {
+
+// Class implementing the edgebreaker encoding as described in "3D Compression
+// Made Simple: Edgebreaker on a Corner-Table" by Rossignac at al.'01.
+// http://www.cc.gatech.edu/~jarek/papers/CornerTableSMI.pdf
+template <class TraversalEncoderT>
+class MeshEdgebreakerEncoderImpl : public MeshEdgebreakerEncoderImplInterface {
+ public:
+  MeshEdgebreakerEncoderImpl();
+  explicit MeshEdgebreakerEncoderImpl(
+      const TraversalEncoderT &traversal_encoder);
+  bool Init(MeshEdgebreakerEncoder *encoder) override;
+
+  const MeshAttributeCornerTable *GetAttributeCornerTable(
+      int att_id) const override;
+  const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int att_id) const override;
+
+  bool GenerateAttributesEncoder(int32_t att_id) override;
+  bool EncodeAttributesEncoderIdentifier(int32_t att_encoder_id) override;
+  Status EncodeConnectivity() override;
+
+  const CornerTable *GetCornerTable() const override {
+    return corner_table_.get();
+  }
+  bool IsFaceEncoded(FaceIndex fi) const override {
+    return visited_faces_[fi.value()];
+  }
+  MeshEdgebreakerEncoder *GetEncoder() const override { return encoder_; }
+
+ private:
+  // Initializes data needed for encoding non-position attributes.
+  // Returns false on error.
+  bool InitAttributeData();
+
+  // Creates a vertex traversal sequencer for the specified |TraverserT| type.
+  template <class TraverserT>
+  std::unique_ptr<PointsSequencer> CreateVertexTraversalSequencer(
+      MeshAttributeIndicesEncodingData *encoding_data);
+
+  // Finds the configuration of the initial face that starts the traversal.
+  // Configurations are determined by location of holes around the init face
+  // and they are described in mesh_edgebreaker_shared.h.
+  // Returns true if the face configuration is interior and false if it is
+  // exterior.
+  bool FindInitFaceConfiguration(FaceIndex face_id,
+                                 CornerIndex *out_corner_id) const;
+
+  // Encodes the connectivity between vertices.
+  bool EncodeConnectivityFromCorner(CornerIndex corner_id);
+
+  // Encodes all vertices of a hole starting at start_corner_id.
+  // The vertex associated with the first corner is encoded only if
+  // |encode_first_vertex| is true.
+  // Returns the number of encoded hole vertices.
+  int EncodeHole(CornerIndex start_corner_id, bool encode_first_vertex);
+
+  // Encodes topology split data.
+  // Returns nullptr on error.
+  bool EncodeSplitData();
+
+  CornerIndex GetRightCorner(CornerIndex corner_id) const;
+  CornerIndex GetLeftCorner(CornerIndex corner_id) const;
+
+  bool IsRightFaceVisited(CornerIndex corner_id) const;
+  bool IsLeftFaceVisited(CornerIndex corner_id) const;
+  bool IsVertexVisited(VertexIndex vert_id) const {
+    return visited_vertex_ids_[vert_id.value()];
+  }
+
+  // Finds and stores data about all holes in the input mesh.
+  bool FindHoles();
+
+  // For faces encoded with symbol TOPOLOGY_S (split), this method returns
+  // the encoded symbol id or -1 if the face wasn't encoded by a split symbol.
+  int GetSplitSymbolIdOnFace(int face_id) const;
+
+  // Checks whether there is a topology split event on a neighboring face and
+  // stores the event data if necessary. For more info about topology split
+  // events, see description of TopologySplitEventData in
+  // mesh_edgebreaker_shared.h.
+  void CheckAndStoreTopologySplitEvent(int src_symbol_id, int src_face_id,
+                                       EdgeFaceName src_edge,
+                                       int neighbor_face_id);
+
+  // Encodes connectivity of all attributes on a newly traversed face.
+  bool EncodeAttributeConnectivitiesOnFace(CornerIndex corner);
+
+  // This function is used to to assign correct encoding order of attributes
+  // to unprocessed corners. The encoding order is equal to the order in which
+  // the attributes are going to be processed by the decoder and it is necessary
+  // for proper prediction of attribute values.
+  bool AssignPositionEncodingOrderToAllCorners();
+
+  // This function is used to generate encoding order for all non-position
+  // attributes.
+  // Returns false when one or more attributes failed to be processed.
+  bool GenerateEncodingOrderForAttributes();
+
+  // The main encoder that owns this class.
+  MeshEdgebreakerEncoder *encoder_;
+  // Mesh that's being encoded.
+  const Mesh *mesh_;
+  // Corner table stores the mesh face connectivity data.
+  std::unique_ptr<CornerTable> corner_table_;
+  // Stack used for storing corners that need to be traversed when encoding
+  // the connectivity. New corner is added for each initial face and a split
+  // symbol, and one corner is removed when the end symbol is reached.
+  // Stored as member variable to prevent frequent memory reallocations when
+  // handling meshes with lots of disjoint components. Originally, we used
+  // recursive functions to handle this behavior, but that can cause stack
+  // memory overflow when compressing huge meshes.
+  std::vector<CornerIndex> corner_traversal_stack_;
+  // Array for marking visited faces.
+  std::vector<bool> visited_faces_;
+
+  // Attribute data for position encoding.
+  MeshAttributeIndicesEncodingData pos_encoding_data_;
+
+  // Traversal method used for the position attribute.
+  MeshTraversalMethod pos_traversal_method_;
+
+  // Array storing corners in the order they were visited during the
+  // connectivity encoding (always storing the tip corner of each newly visited
+  // face).
+  std::vector<CornerIndex> processed_connectivity_corners_;
+
+  // Array for storing visited vertex ids of all input vertices.
+  std::vector<bool> visited_vertex_ids_;
+
+  // For each traversal, this array stores the number of visited vertices.
+  std::vector<int> vertex_traversal_length_;
+  // Array for storing all topology split events encountered during the mesh
+  // traversal.
+  std::vector<TopologySplitEventData> topology_split_event_data_;
+  // Map between face_id and symbol_id. Contains entries only for faces that
+  // were encoded with TOPOLOGY_S symbol.
+  std::unordered_map<int, int> face_to_split_symbol_map_;
+
+  // Array for marking holes that has been reached during the traversal.
+  std::vector<bool> visited_holes_;
+  // Array for mapping vertices to hole ids. If a vertex is not on a hole, the
+  // stored value is -1.
+  std::vector<int> vertex_hole_id_;
+
+  // Id of the last encoded symbol.
+  int last_encoded_symbol_id_;
+
+  // The number of encoded split symbols.
+  uint32_t num_split_symbols_;
+
+  // Struct holding data used for encoding each non-position attribute.
+  // TODO(ostava): This should be probably renamed to something better.
+  struct AttributeData {
+    AttributeData() : attribute_index(-1), is_connectivity_used(true) {}
+    int attribute_index;
+    MeshAttributeCornerTable connectivity_data;
+    // Flag that can mark the connectivity_data invalid. In such case the base
+    // corner table of the mesh should be used instead.
+    bool is_connectivity_used;
+    // Data about attribute encoding order.
+    MeshAttributeIndicesEncodingData encoding_data;
+    // Traversal method used to generate the encoding data for this attribute.
+    MeshTraversalMethod traversal_method;
+  };
+  std::vector<AttributeData> attribute_data_;
+
+  // Array storing mapping between attribute encoder id and attribute data id.
+  std::vector<int32_t> attribute_encoder_to_data_id_map_;
+
+  TraversalEncoderT traversal_encoder_;
+
+  // If set, the encoder is going to use the same connectivity for all
+  // attributes. This effectively breaks the mesh along all attribute seams.
+  // In general, this approach should be much faster compared to encoding each
+  // connectivity separately, but the decoded model may contain higher number of
+  // duplicate attribute values which may decrease the compression ratio.
+  bool use_single_connectivity_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_ENCODER_IMPL_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder_impl_interface.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder_impl_interface.h
new file mode 100644
index 000000000..627d51262
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder_impl_interface.h
@@ -0,0 +1,57 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_ENCODER_IMPL_INTERFACE_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_ENCODER_IMPL_INTERFACE_H_
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/mesh/corner_table.h"
+#include "draco/mesh/mesh_attribute_corner_table.h"
+
+namespace draco {
+
+// Forward declaration is necessary here to avoid circular dependencies.
+class MeshEdgebreakerEncoder;
+
+// Abstract interface used by MeshEdgebreakerEncoder to interact with the actual
+// implementation of the edgebreaker method. The implementations are in general
+// specializations of a template class MeshEdgebreakerEncoderImpl where the
+// template arguments control encoding of the connectivity data. Because the
+// choice of the implementation is done in run-time, we need to hide it behind
+// the abstract interface MeshEdgebreakerEncoderImplInterface.
+class MeshEdgebreakerEncoderImplInterface {
+ public:
+  virtual ~MeshEdgebreakerEncoderImplInterface() = default;
+  virtual bool Init(MeshEdgebreakerEncoder *encoder) = 0;
+
+  virtual const MeshAttributeCornerTable *GetAttributeCornerTable(
+      int att_id) const = 0;
+  virtual const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int att_id) const = 0;
+  virtual bool GenerateAttributesEncoder(int32_t att_id) = 0;
+  virtual bool EncodeAttributesEncoderIdentifier(int32_t att_encoder_id) = 0;
+  virtual Status EncodeConnectivity() = 0;
+
+  // Returns corner table of the encoded mesh.
+  virtual const CornerTable *GetCornerTable() const = 0;
+
+  // Returns true if a given face has been already encoded.
+  virtual bool IsFaceEncoded(FaceIndex fi) const = 0;
+
+  virtual MeshEdgebreakerEncoder *GetEncoder() const = 0;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_ENCODER_IMPL_INTERFACE_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoding_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoding_test.cc
new file mode 100644
index 000000000..831388245
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoding_test.cc
@@ -0,0 +1,247 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include <sstream>
+
+#include "draco/compression/encode.h"
+#include "draco/compression/mesh/mesh_edgebreaker_decoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_encoder.h"
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+#include "draco/io/mesh_io.h"
+#include "draco/io/obj_decoder.h"
+#include "draco/mesh/mesh_are_equivalent.h"
+#include "draco/mesh/mesh_cleanup.h"
+#include "draco/mesh/triangle_soup_mesh_builder.h"
+
+namespace draco {
+
+class MeshEdgebreakerEncodingTest : public ::testing::Test {
+ protected:
+  void TestFile(const std::string &file_name) { TestFile(file_name, -1); }
+
+  void TestFile(const std::string &file_name, int compression_level) {
+    const std::unique_ptr<Mesh> mesh(ReadMeshFromTestFile(file_name));
+    ASSERT_NE(mesh, nullptr) << "Failed to load test model " << file_name;
+
+    TestMesh(mesh.get(), compression_level);
+  }
+
+  void TestMesh(Mesh *mesh, int compression_level) {
+    EncoderBuffer buffer;
+    MeshEdgebreakerEncoder encoder;
+    EncoderOptions encoder_options = EncoderOptions::CreateDefaultOptions();
+    encoder_options.SetSpeed(10 - compression_level, 10 - compression_level);
+    encoder.SetMesh(*mesh);
+    ASSERT_TRUE(encoder.Encode(encoder_options, &buffer).ok());
+
+    DecoderBuffer dec_buffer;
+    dec_buffer.Init(buffer.data(), buffer.size());
+    MeshEdgebreakerDecoder decoder;
+
+    std::unique_ptr<Mesh> decoded_mesh(new Mesh());
+    DecoderOptions dec_options;
+    ASSERT_TRUE(
+        decoder.Decode(dec_options, &dec_buffer, decoded_mesh.get()).ok());
+
+    // Cleanup the input mesh to make sure that input and output can be
+    // compared (edgebreaker method discards degenerated triangles and isolated
+    // vertices).
+    const MeshCleanupOptions options;
+    MeshCleanup cleanup;
+    ASSERT_TRUE(cleanup(mesh, options)) << "Failed to clean the input mesh.";
+
+    MeshAreEquivalent eq;
+    ASSERT_TRUE(eq(*mesh, *decoded_mesh.get()))
+        << "Decoded mesh is not the same as the input";
+  }
+};
+
+TEST_F(MeshEdgebreakerEncodingTest, TestNmOBJ) {
+  const std::string file_name = "test_nm.obj";
+  TestFile(file_name);
+}
+
+TEST_F(MeshEdgebreakerEncodingTest, ThreeFacesOBJ) {
+  const std::string file_name = "extra_vertex.obj";
+  TestFile(file_name);
+}
+
+TEST_F(MeshEdgebreakerEncodingTest, TestPly) {
+  // Tests whether the edgebreaker successfully encodes and decodes the test
+  // file (ply with color).
+  const std::string file_name = "test_pos_color.ply";
+  TestFile(file_name);
+}
+
+TEST_F(MeshEdgebreakerEncodingTest, TestMultiAttributes) {
+  // Tests encoding of model with many attributes.
+  const std::string file_name = "cube_att.obj";
+  TestFile(file_name, 10);
+}
+
+TEST_F(MeshEdgebreakerEncodingTest, TestEncoderReuse) {
+  // Tests whether the edgebreaker encoder can be reused multiple times to
+  // encode a given mesh.
+  const std::string file_name = "test_pos_color.ply";
+  const std::unique_ptr<Mesh> mesh(ReadMeshFromTestFile(file_name));
+  ASSERT_NE(mesh, nullptr) << "Failed to load test model " << file_name;
+
+  MeshEdgebreakerEncoder encoder;
+  EncoderOptions encoder_options = EncoderOptions::CreateDefaultOptions();
+  encoder.SetMesh(*mesh);
+  EncoderBuffer buffer_0, buffer_1;
+  ASSERT_TRUE(encoder.Encode(encoder_options, &buffer_0).ok());
+  ASSERT_TRUE(encoder.Encode(encoder_options, &buffer_1).ok());
+
+  // Make sure both buffer are identical.
+  ASSERT_EQ(buffer_0.size(), buffer_1.size());
+  for (int i = 0; i < buffer_0.size(); ++i) {
+    ASSERT_EQ(buffer_0.data()[i], buffer_1.data()[i]);
+  }
+}
+
+TEST_F(MeshEdgebreakerEncodingTest, TestDecoderReuse) {
+  // Tests whether the edgebreaker decoder can be reused multiple times to
+  // decode a given mesh.
+  const std::string file_name = "test_pos_color.ply";
+  const std::unique_ptr<Mesh> mesh(ReadMeshFromTestFile(file_name));
+  ASSERT_NE(mesh, nullptr) << "Failed to load test model " << file_name;
+
+  MeshEdgebreakerEncoder encoder;
+  EncoderOptions encoder_options = EncoderOptions::CreateDefaultOptions();
+  encoder.SetMesh(*mesh);
+  EncoderBuffer buffer;
+  ASSERT_TRUE(encoder.Encode(encoder_options, &buffer).ok());
+
+  DecoderBuffer dec_buffer;
+  dec_buffer.Init(buffer.data(), buffer.size());
+
+  MeshEdgebreakerDecoder decoder;
+
+  // Decode the mesh two times.
+  std::unique_ptr<Mesh> decoded_mesh_0(new Mesh());
+  DecoderOptions dec_options;
+  ASSERT_TRUE(
+      decoder.Decode(dec_options, &dec_buffer, decoded_mesh_0.get()).ok());
+
+  dec_buffer.Init(buffer.data(), buffer.size());
+  std::unique_ptr<Mesh> decoded_mesh_1(new Mesh());
+  ASSERT_TRUE(
+      decoder.Decode(dec_options, &dec_buffer, decoded_mesh_1.get()).ok());
+
+  // Make sure both of the meshes are identical.
+  MeshAreEquivalent eq;
+  ASSERT_TRUE(eq(*decoded_mesh_0.get(), *decoded_mesh_1.get()))
+      << "Decoded meshes are not the same";
+}
+
+TEST_F(MeshEdgebreakerEncodingTest, TestSingleConnectivityEncoding) {
+  // Tests whether the edgebreaker method successfully encodes a mesh with
+  // multiple attributes using single connectivity by breaking the mesh along
+  // attribute seams.
+  const std::string file_name = "cube_att.obj";
+  const std::unique_ptr<Mesh> mesh(ReadMeshFromTestFile(file_name));
+  ASSERT_NE(mesh, nullptr) << "Failed to load test model " << file_name;
+
+  for (int i = 0; i < 2; ++i) {
+    // Set the option to enable/disable single connectivity encoding.
+    EncoderOptionsBase<GeometryAttribute::Type> options =
+        EncoderOptionsBase<GeometryAttribute::Type>::CreateDefaultOptions();
+    options.SetGlobalBool("split_mesh_on_seams", i == 0 ? true : false);
+
+    EncoderBuffer buffer;
+    draco::Encoder encoder;
+    encoder.Reset(options);
+    encoder.SetSpeedOptions(0, 0);
+    encoder.SetAttributeQuantization(GeometryAttribute::POSITION, 8);
+    encoder.SetAttributeQuantization(GeometryAttribute::TEX_COORD, 8);
+    encoder.SetAttributeQuantization(GeometryAttribute::NORMAL, 8);
+    encoder.SetEncodingMethod(MESH_EDGEBREAKER_ENCODING);
+    ASSERT_TRUE(encoder.EncodeMeshToBuffer(*mesh, &buffer).ok());
+
+    DecoderBuffer dec_buffer;
+    dec_buffer.Init(buffer.data(), buffer.size());
+
+    Decoder decoder;
+    auto dec_mesh = decoder.DecodeMeshFromBuffer(&dec_buffer).value();
+    ASSERT_NE(dec_mesh, nullptr);
+    ASSERT_EQ(dec_mesh->num_points(), 24);
+    ASSERT_EQ(dec_mesh->num_attributes(), 3);
+    ASSERT_EQ(dec_mesh->attribute(0)->size(), i == 0 ? 24 : 8);
+    ASSERT_EQ(dec_mesh->attribute(1)->size(), 24);
+    ASSERT_EQ(dec_mesh->attribute(2)->size(), 24);
+  }
+}
+
+TEST_F(MeshEdgebreakerEncodingTest, TestWrongAttributeOrder) {
+  // Tests whether the edgebreaker method successfully encodes a mesh where the
+  // input attributes are in wrong order (because of their internal
+  // dependencies). In such case the attributes should be rearranged to the
+  // correct order.
+  TriangleSoupMeshBuilder mb;
+  mb.Start(1);
+  const int32_t norm_att_id =
+      mb.AddAttribute(GeometryAttribute::NORMAL, 3, DT_FLOAT32);
+  const int32_t pos_att_id =
+      mb.AddAttribute(GeometryAttribute::POSITION, 3, DT_FLOAT32);
+
+  mb.SetAttributeValuesForFace(
+      pos_att_id, FaceIndex(0), Vector3f(0.f, 0.f, 0.f).data(),
+      Vector3f(1.f, 0.f, 0.f).data(), Vector3f(0.f, 1.f, 0.f).data());
+
+  mb.SetAttributeValuesForFace(
+      norm_att_id, FaceIndex(0), Vector3f(0.f, 0.f, 1.f).data(),
+      Vector3f(0.f, 0.f, 0.f).data(), Vector3f(0.f, 0.f, 1.f).data());
+  std::unique_ptr<Mesh> mesh = mb.Finalize();
+  ASSERT_NE(mesh, nullptr);
+  ASSERT_EQ(mesh->num_attributes(), 2);
+  ASSERT_EQ(mesh->attribute(0)->attribute_type(), GeometryAttribute::NORMAL);
+  ASSERT_EQ(mesh->attribute(1)->attribute_type(), GeometryAttribute::POSITION);
+
+  EncoderBuffer buffer;
+  draco::Encoder encoder;
+  encoder.SetSpeedOptions(3, 3);
+  encoder.SetAttributeQuantization(GeometryAttribute::POSITION, 8);
+  encoder.SetAttributeQuantization(GeometryAttribute::NORMAL, 8);
+  encoder.SetEncodingMethod(MESH_EDGEBREAKER_ENCODING);
+  ASSERT_TRUE(encoder.EncodeMeshToBuffer(*mesh, &buffer).ok());
+
+  DecoderBuffer dec_buffer;
+  dec_buffer.Init(buffer.data(), buffer.size());
+
+  Decoder decoder;
+  auto dec_mesh = decoder.DecodeMeshFromBuffer(&dec_buffer).value();
+  ASSERT_NE(dec_mesh, nullptr);
+  ASSERT_EQ(dec_mesh->num_attributes(), 2);
+  ASSERT_EQ(dec_mesh->attribute(0)->attribute_type(),
+            GeometryAttribute::POSITION);
+  ASSERT_EQ(dec_mesh->attribute(1)->attribute_type(),
+            GeometryAttribute::NORMAL);
+}
+
+TEST_F(MeshEdgebreakerEncodingTest, TestDegenerateMesh) {
+  // Tests whether we can process a mesh that contains degenerate faces only.
+  const std::string file_name = "degenerate_mesh.obj";
+  const std::unique_ptr<Mesh> mesh(ReadMeshFromTestFile(file_name));
+  ASSERT_NE(mesh, nullptr) << "Failed to load test model " << file_name;
+  EncoderBuffer buffer;
+  MeshEdgebreakerEncoder encoder;
+  EncoderOptions encoder_options = EncoderOptions::CreateDefaultOptions();
+  encoder.SetMesh(*mesh);
+  // We expect the encoding to fail as edgebreaker can only process valid faces.
+  ASSERT_FALSE(encoder.Encode(encoder_options, &buffer).ok());
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_shared.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_shared.h
new file mode 100644
index 000000000..cb3c29dd6
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_shared.h
@@ -0,0 +1,131 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_SHARED_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_SHARED_H_
+
+#include <stdint.h>
+
+namespace draco {
+
+// Shared declarations used by both edgebreaker encoder and decoder.
+
+// A variable length encoding for storing all possible topology configurations
+// during traversal of mesh's surface. The configurations are based on visited
+// state of neighboring triangles around a currently processed face corner.
+// Note that about half of the encountered configurations is expected to be of
+// type TOPOLOGY_C. It's guaranteed that the encoding will use at most 2 bits
+// per triangle for meshes with no holes and up to 6 bits per triangle for
+// general meshes. In addition, the encoding will take up to 4 bits per triangle
+// for each non-position attribute attached to the mesh.
+//
+//     *-------*          *-------*          *-------*
+//    / \     / \        / \     / \        / \     / \
+//   /   \   /   \      /   \   /   \      /   \   /   \
+//  /     \ /     \    /     \ /     \    /     \ /     \
+// *-------v-------*  *-------v-------*  *-------v-------*
+//  \     /x\     /          /x\     /    \     /x\
+//   \   /   \   /          /   \   /      \   /   \
+//    \ /  C  \ /          /  L  \ /        \ /  R  \
+//     *-------*          *-------*          *-------*
+//
+//     *       *
+//    / \     / \
+//   /   \   /   \
+//  /     \ /     \
+// *-------v-------*          v
+//  \     /x\     /          /x\
+//   \   /   \   /          /   \
+//    \ /  S  \ /          /  E  \
+//     *-------*          *-------*
+//
+// TODO(ostava): Get rid of the topology bit pattern. It's important only for
+// encoding but the algorithms should use EdgebreakerSymbol instead.
+enum EdgebreakerTopologyBitPattern {
+  TOPOLOGY_C = 0x0,  // 0
+  TOPOLOGY_S = 0x1,  // 1 0 0
+  TOPOLOGY_L = 0x3,  // 1 1 0
+  TOPOLOGY_R = 0x5,  // 1 0 1
+  TOPOLOGY_E = 0x7,  // 1 1 1
+  // A special symbol that's not actually encoded, but it can be used to mark
+  // the initial face that triggers the mesh encoding of a single connected
+  // component.
+  TOPOLOGY_INIT_FACE,
+  // A special value used to indicate an invalid symbol.
+  TOPOLOGY_INVALID
+};
+
+enum EdgebreakerSymbol {
+  EDGEBREAKER_SYMBOL_C = 0,
+  EDGEBREAKER_SYMBOL_S,
+  EDGEBREAKER_SYMBOL_L,
+  EDGEBREAKER_SYMBOL_R,
+  EDGEBREAKER_SYMBOL_E,
+  EDGEBREAKER_SYMBOL_INVALID
+};
+
+// Bit-length of symbols in the EdgebreakerTopologyBitPattern stored as a
+// lookup table for faster indexing.
+constexpr int32_t edge_breaker_topology_bit_pattern_length[] = {1, 3, 0, 3,
+                                                                0, 3, 0, 3};
+
+// Zero-indexed symbol id for each of topology pattern.
+constexpr EdgebreakerSymbol edge_breaker_topology_to_symbol_id[] = {
+    EDGEBREAKER_SYMBOL_C,       EDGEBREAKER_SYMBOL_S,
+    EDGEBREAKER_SYMBOL_INVALID, EDGEBREAKER_SYMBOL_L,
+    EDGEBREAKER_SYMBOL_INVALID, EDGEBREAKER_SYMBOL_R,
+    EDGEBREAKER_SYMBOL_INVALID, EDGEBREAKER_SYMBOL_E};
+
+// Reverse mapping between symbol id and topology pattern symbol.
+constexpr EdgebreakerTopologyBitPattern edge_breaker_symbol_to_topology_id[] = {
+    TOPOLOGY_C, TOPOLOGY_S, TOPOLOGY_L, TOPOLOGY_R, TOPOLOGY_E};
+
+// Types of edges used during mesh traversal relative to the tip vertex of a
+// visited triangle.
+enum EdgeFaceName : uint8_t { LEFT_FACE_EDGE = 0, RIGHT_FACE_EDGE = 1 };
+
+// Struct used for storing data about a source face that connects to an
+// already traversed face that was either the initial face or a face encoded
+// with either topology S (split) symbol. Such connection can be only caused by
+// topology changes on the traversed surface (if its genus != 0, i.e. when the
+// surface has topological handles or holes).
+// For each occurrence of such event we always encode the split symbol id,
+// source symbol id and source edge id (left, or right). There will be always
+// exactly two occurrences of this event for every topological handle on the
+// traversed mesh and one occurrence for a hole.
+struct TopologySplitEventData {
+  uint32_t split_symbol_id;
+  uint32_t source_symbol_id;
+  // We need to use uint32_t instead of EdgeFaceName because the most recent
+  // version of gcc does not allow that when optimizations are turned on.
+  uint32_t source_edge : 1;
+};
+
+// Hole event is used to store info about the first symbol that reached a
+// vertex of so far unvisited hole. This can happen only on either the initial
+// face or during a regular traversal when TOPOLOGY_S is encountered.
+struct HoleEventData {
+  int32_t symbol_id;
+  HoleEventData() : symbol_id(0) {}
+  explicit HoleEventData(int32_t sym_id) : symbol_id(sym_id) {}
+};
+
+// List of supported modes for valence based edgebreaker coding.
+enum EdgebreakerValenceCodingMode {
+  EDGEBREAKER_VALENCE_MODE_2_7 = 0,  // Use contexts for valences in range 2-7.
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_SHARED_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_decoder.h
new file mode 100644
index 000000000..ce91adc87
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_decoder.h
@@ -0,0 +1,201 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_DECODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_DECODER_H_
+
+#include "draco/compression/bit_coders/rans_bit_decoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_decoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_decoder_impl_interface.h"
+#include "draco/compression/mesh/mesh_edgebreaker_shared.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+typedef RAnsBitDecoder BinaryDecoder;
+
+// Default implementation of the edgebreaker traversal decoder that reads the
+// traversal data directly from a buffer.
+class MeshEdgebreakerTraversalDecoder {
+ public:
+  MeshEdgebreakerTraversalDecoder()
+      : attribute_connectivity_decoders_(nullptr),
+        num_attribute_data_(0),
+        decoder_impl_(nullptr) {}
+  void Init(MeshEdgebreakerDecoderImplInterface *decoder) {
+    decoder_impl_ = decoder;
+    buffer_.Init(decoder->GetDecoder()->buffer()->data_head(),
+                 decoder->GetDecoder()->buffer()->remaining_size(),
+                 decoder->GetDecoder()->buffer()->bitstream_version());
+  }
+
+  // Returns the Draco bitstream version.
+  uint16_t BitstreamVersion() const {
+    return decoder_impl_->GetDecoder()->bitstream_version();
+  }
+
+  // Used to tell the decoder what is the number of expected decoded vertices.
+  // Ignored by default.
+  void SetNumEncodedVertices(int /* num_vertices */) {}
+
+  // Set the number of non-position attribute data for which we need to decode
+  // the connectivity.
+  void SetNumAttributeData(int num_data) { num_attribute_data_ = num_data; }
+
+  // Called before the traversal decoding is started.
+  // Returns a buffer decoder that points to data that was encoded after the
+  // traversal.
+  bool Start(DecoderBuffer *out_buffer) {
+    // Decode symbols from the main buffer decoder and face configurations from
+    // the start_face_buffer decoder.
+    if (!DecodeTraversalSymbols()) {
+      return false;
+    }
+
+    if (!DecodeStartFaces()) {
+      return false;
+    }
+
+    if (!DecodeAttributeSeams()) {
+      return false;
+    }
+    *out_buffer = buffer_;
+    return true;
+  }
+
+  // Returns the configuration of a new initial face.
+  inline bool DecodeStartFaceConfiguration() {
+    uint32_t face_configuration;
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+    if (buffer_.bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+      start_face_buffer_.DecodeLeastSignificantBits32(1, &face_configuration);
+
+    } else
+#endif
+    {
+      face_configuration = start_face_decoder_.DecodeNextBit();
+    }
+    return face_configuration;
+  }
+
+  // Returns the next edgebreaker symbol that was reached during the traversal.
+  inline uint32_t DecodeSymbol() {
+    uint32_t symbol;
+    symbol_buffer_.DecodeLeastSignificantBits32(1, &symbol);
+    if (symbol == TOPOLOGY_C) {
+      return symbol;
+    }
+    // Else decode two additional bits.
+    uint32_t symbol_suffix;
+    symbol_buffer_.DecodeLeastSignificantBits32(2, &symbol_suffix);
+    symbol |= (symbol_suffix << 1);
+    return symbol;
+  }
+
+  // Called whenever a new active corner is set in the decoder.
+  inline void NewActiveCornerReached(CornerIndex /* corner */) {}
+
+  // Called whenever |source| vertex is about to be merged into the |dest|
+  // vertex.
+  inline void MergeVertices(VertexIndex /* dest */, VertexIndex /* source */) {}
+
+  // Returns true if there is an attribute seam for the next processed pair
+  // of visited faces.
+  // |attribute| is used to mark the id of the non-position attribute (in range
+  // of <0, num_attributes - 1>).
+  inline bool DecodeAttributeSeam(int attribute) {
+    return attribute_connectivity_decoders_[attribute].DecodeNextBit();
+  }
+
+  // Called when the traversal is finished.
+  void Done() {
+    if (symbol_buffer_.bit_decoder_active()) {
+      symbol_buffer_.EndBitDecoding();
+    }
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+    if (buffer_.bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+      start_face_buffer_.EndBitDecoding();
+
+    } else
+#endif
+    {
+      start_face_decoder_.EndDecoding();
+    }
+  }
+
+ protected:
+  DecoderBuffer *buffer() { return &buffer_; }
+
+  bool DecodeTraversalSymbols() {
+    uint64_t traversal_size;
+    symbol_buffer_ = buffer_;
+    if (!symbol_buffer_.StartBitDecoding(true, &traversal_size)) {
+      return false;
+    }
+    buffer_ = symbol_buffer_;
+    if (traversal_size > static_cast<uint64_t>(buffer_.remaining_size())) {
+      return false;
+    }
+    buffer_.Advance(traversal_size);
+    return true;
+  }
+
+  bool DecodeStartFaces() {
+    // Create a decoder that is set to the end of the encoded traversal data.
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+    if (buffer_.bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+      start_face_buffer_ = buffer_;
+      uint64_t traversal_size;
+      if (!start_face_buffer_.StartBitDecoding(true, &traversal_size)) {
+        return false;
+      }
+      buffer_ = start_face_buffer_;
+      if (traversal_size > static_cast<uint64_t>(buffer_.remaining_size())) {
+        return false;
+      }
+      buffer_.Advance(traversal_size);
+      return true;
+    }
+#endif
+    return start_face_decoder_.StartDecoding(&buffer_);
+  }
+
+  bool DecodeAttributeSeams() {
+    // Prepare attribute decoding.
+    if (num_attribute_data_ > 0) {
+      attribute_connectivity_decoders_ = std::unique_ptr<BinaryDecoder[]>(
+          new BinaryDecoder[num_attribute_data_]);
+      for (int i = 0; i < num_attribute_data_; ++i) {
+        if (!attribute_connectivity_decoders_[i].StartDecoding(&buffer_)) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+ private:
+  // Buffer that contains the encoded data.
+  DecoderBuffer buffer_;
+  DecoderBuffer symbol_buffer_;
+  BinaryDecoder start_face_decoder_;
+  DecoderBuffer start_face_buffer_;
+  std::unique_ptr<BinaryDecoder[]> attribute_connectivity_decoders_;
+  int num_attribute_data_;
+  const MeshEdgebreakerDecoderImplInterface *decoder_impl_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_encoder.h
new file mode 100644
index 000000000..08cb66e4c
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_encoder.h
@@ -0,0 +1,139 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_ENCODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_ENCODER_H_
+
+#include "draco/compression/bit_coders/rans_bit_encoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_encoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_encoder_impl_interface.h"
+#include "draco/core/macros.h"
+
+namespace draco {
+
+typedef RAnsBitEncoder BinaryEncoder;
+
+// Default implementation of the edgebreaker traversal encoder. Face
+// configurations are stored directly into the output buffer and the symbols
+// are first collected and then encoded in the reverse order to make the
+// decoding faster.
+class MeshEdgebreakerTraversalEncoder {
+ public:
+  MeshEdgebreakerTraversalEncoder()
+      : encoder_impl_(nullptr),
+        attribute_connectivity_encoders_(nullptr),
+        num_attribute_data_(0) {}
+  bool Init(MeshEdgebreakerEncoderImplInterface *encoder) {
+    encoder_impl_ = encoder;
+    return true;
+  }
+
+  // Set the number of non-position attribute data for which we need to encode
+  // the connectivity.
+  void SetNumAttributeData(int num_data) { num_attribute_data_ = num_data; }
+
+  // Called before the traversal encoding is started.
+  void Start() {
+    start_face_encoder_.StartEncoding();
+    if (num_attribute_data_ > 0) {
+      // Init and start arithmetic encoders for storing configuration types
+      // of non-position attributes.
+      attribute_connectivity_encoders_ = std::unique_ptr<BinaryEncoder[]>(
+          new BinaryEncoder[num_attribute_data_]);
+      for (int i = 0; i < num_attribute_data_; ++i) {
+        attribute_connectivity_encoders_[i].StartEncoding();
+      }
+    }
+  }
+
+  // Called when a traversal starts from a new initial face.
+  inline void EncodeStartFaceConfiguration(bool interior) {
+    start_face_encoder_.EncodeBit(interior);
+  }
+
+  // Called when a new corner is reached during the traversal. No-op for the
+  // default encoder.
+  inline void NewCornerReached(CornerIndex /* corner */) {}
+
+  // Called whenever a new symbol is reached during the edgebreaker traversal.
+  inline void EncodeSymbol(EdgebreakerTopologyBitPattern symbol) {
+    // Store the symbol. It will be encoded after all symbols are processed.
+    symbols_.push_back(symbol);
+  }
+
+  // Called for every pair of connected and visited faces. |is_seam| specifies
+  // whether there is an attribute seam between the two faces.
+
+  inline void EncodeAttributeSeam(int attribute, bool is_seam) {
+    attribute_connectivity_encoders_[attribute].EncodeBit(is_seam ? 1 : 0);
+  }
+
+  // Called when the traversal is finished.
+  void Done() {
+    EncodeTraversalSymbols();
+    EncodeStartFaces();
+    EncodeAttributeSeams();
+  }
+
+  // Returns the number of encoded symbols.
+  int NumEncodedSymbols() const { return static_cast<int>(symbols_.size()); }
+
+  const EncoderBuffer &buffer() const { return traversal_buffer_; }
+
+ protected:
+  void EncodeTraversalSymbols() {
+    // Bit encode the collected symbols.
+    // Allocate enough storage for the bit encoder.
+    // It's guaranteed that each face will need only up to 3 bits.
+    traversal_buffer_.StartBitEncoding(
+        encoder_impl_->GetEncoder()->mesh()->num_faces() * 3, true);
+    for (int i = static_cast<int>(symbols_.size() - 1); i >= 0; --i) {
+      traversal_buffer_.EncodeLeastSignificantBits32(
+          edge_breaker_topology_bit_pattern_length[symbols_[i]], symbols_[i]);
+    }
+    traversal_buffer_.EndBitEncoding();
+  }
+
+  void EncodeStartFaces() {
+    start_face_encoder_.EndEncoding(&traversal_buffer_);
+  }
+
+  void EncodeAttributeSeams() {
+    if (attribute_connectivity_encoders_ != nullptr) {
+      for (int i = 0; i < num_attribute_data_; ++i) {
+        attribute_connectivity_encoders_[i].EndEncoding(&traversal_buffer_);
+      }
+    }
+  }
+
+  EncoderBuffer *GetOutputBuffer() { return &traversal_buffer_; }
+  const MeshEdgebreakerEncoderImplInterface *encoder_impl() const {
+    return encoder_impl_;
+  }
+
+ private:
+  BinaryEncoder start_face_encoder_;
+  EncoderBuffer traversal_buffer_;
+  const MeshEdgebreakerEncoderImplInterface *encoder_impl_;
+  // Symbols collected during the traversal.
+  std::vector<EdgebreakerTopologyBitPattern> symbols_;
+  // Arithmetic encoder for encoding attribute seams.
+  // One context for each non-position attribute.
+  std::unique_ptr<BinaryEncoder[]> attribute_connectivity_encoders_;
+  int num_attribute_data_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_predictive_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_predictive_decoder.h
new file mode 100644
index 000000000..3f9004585
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_predictive_decoder.h
@@ -0,0 +1,134 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_PREDICTIVE_DECODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_PREDICTIVE_DECODER_H_
+
+#include "draco/compression/mesh/mesh_edgebreaker_traversal_decoder.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Decoder for traversal encoded with the
+// MeshEdgebreakerTraversalPredictiveEncoder. The decoder maintains valences
+// of the decoded portion of the traversed mesh and it uses them to predict
+// symbols that are about to be decoded.
+class MeshEdgebreakerTraversalPredictiveDecoder
+    : public MeshEdgebreakerTraversalDecoder {
+ public:
+  MeshEdgebreakerTraversalPredictiveDecoder()
+      : corner_table_(nullptr),
+        num_vertices_(0),
+        last_symbol_(-1),
+        predicted_symbol_(-1) {}
+  void Init(MeshEdgebreakerDecoderImplInterface *decoder) {
+    MeshEdgebreakerTraversalDecoder::Init(decoder);
+    corner_table_ = decoder->GetCornerTable();
+  }
+  void SetNumEncodedVertices(int num_vertices) { num_vertices_ = num_vertices; }
+
+  bool Start(DecoderBuffer *out_buffer) {
+    if (!MeshEdgebreakerTraversalDecoder::Start(out_buffer)) {
+      return false;
+    }
+    int32_t num_split_symbols;
+    if (!out_buffer->Decode(&num_split_symbols) || num_split_symbols < 0)
+      return false;
+    if (num_split_symbols >= num_vertices_) {
+      return false;
+    }
+    // Set the valences of all initial vertices to 0.
+    vertex_valences_.resize(num_vertices_, 0);
+    if (!prediction_decoder_.StartDecoding(out_buffer)) {
+      return false;
+    }
+    return true;
+  }
+
+  inline uint32_t DecodeSymbol() {
+    // First check if we have a predicted symbol.
+    if (predicted_symbol_ != -1) {
+      // Double check that the predicted symbol was predicted correctly.
+      if (prediction_decoder_.DecodeNextBit()) {
+        last_symbol_ = predicted_symbol_;
+        return predicted_symbol_;
+      }
+    }
+    // We don't have a predicted symbol or the symbol was mis-predicted.
+    // Decode it directly.
+    last_symbol_ = MeshEdgebreakerTraversalDecoder::DecodeSymbol();
+    return last_symbol_;
+  }
+
+  inline void NewActiveCornerReached(CornerIndex corner) {
+    const CornerIndex next = corner_table_->Next(corner);
+    const CornerIndex prev = corner_table_->Previous(corner);
+    // Update valences.
+    switch (last_symbol_) {
+      case TOPOLOGY_C:
+      case TOPOLOGY_S:
+        vertex_valences_[corner_table_->Vertex(next).value()] += 1;
+        vertex_valences_[corner_table_->Vertex(prev).value()] += 1;
+        break;
+      case TOPOLOGY_R:
+        vertex_valences_[corner_table_->Vertex(corner).value()] += 1;
+        vertex_valences_[corner_table_->Vertex(next).value()] += 1;
+        vertex_valences_[corner_table_->Vertex(prev).value()] += 2;
+        break;
+      case TOPOLOGY_L:
+        vertex_valences_[corner_table_->Vertex(corner).value()] += 1;
+        vertex_valences_[corner_table_->Vertex(next).value()] += 2;
+        vertex_valences_[corner_table_->Vertex(prev).value()] += 1;
+        break;
+      case TOPOLOGY_E:
+        vertex_valences_[corner_table_->Vertex(corner).value()] += 2;
+        vertex_valences_[corner_table_->Vertex(next).value()] += 2;
+        vertex_valences_[corner_table_->Vertex(prev).value()] += 2;
+        break;
+      default:
+        break;
+    }
+    // Compute the new predicted symbol.
+    if (last_symbol_ == TOPOLOGY_C || last_symbol_ == TOPOLOGY_R) {
+      const VertexIndex pivot =
+          corner_table_->Vertex(corner_table_->Next(corner));
+      if (vertex_valences_[pivot.value()] < 6) {
+        predicted_symbol_ = TOPOLOGY_R;
+      } else {
+        predicted_symbol_ = TOPOLOGY_C;
+      }
+    } else {
+      predicted_symbol_ = -1;
+    }
+  }
+
+  inline void MergeVertices(VertexIndex dest, VertexIndex source) {
+    // Update valences on the merged vertices.
+    vertex_valences_[dest.value()] += vertex_valences_[source.value()];
+  }
+
+ private:
+  const CornerTable *corner_table_;
+  int num_vertices_;
+  std::vector<int> vertex_valences_;
+  BinaryDecoder prediction_decoder_;
+  int last_symbol_;
+  int predicted_symbol_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_PREDICTIVE_DECODER_H_
+#endif
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_predictive_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_predictive_encoder.h
new file mode 100644
index 000000000..eb937fe80
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_predictive_encoder.h
@@ -0,0 +1,172 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_PREDICTIVE_ENCODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_PREDICTIVE_ENCODER_H_
+
+#include "draco/compression/mesh/mesh_edgebreaker_traversal_encoder.h"
+
+namespace draco {
+
+// Encoder that tries to predict the edgebreaker traversal symbols based on the
+// vertex valences of the unencoded portion of the mesh. The current prediction
+// scheme assumes that each vertex has valence 6 which can be used to predict
+// the symbol preceding the one that is currently encoded. Predictions are
+// encoded using an arithmetic coding which can lead to less than 1 bit per
+// triangle encoding for highly regular meshes.
+class MeshEdgebreakerTraversalPredictiveEncoder
+    : public MeshEdgebreakerTraversalEncoder {
+ public:
+  MeshEdgebreakerTraversalPredictiveEncoder()
+      : corner_table_(nullptr),
+        prev_symbol_(-1),
+        num_split_symbols_(0),
+        last_corner_(kInvalidCornerIndex),
+        num_symbols_(0) {}
+
+  bool Init(MeshEdgebreakerEncoderImplInterface *encoder) {
+    if (!MeshEdgebreakerTraversalEncoder::Init(encoder)) {
+      return false;
+    }
+    corner_table_ = encoder->GetCornerTable();
+    // Initialize valences of all vertices.
+    vertex_valences_.resize(corner_table_->num_vertices());
+    for (uint32_t i = 0; i < vertex_valences_.size(); ++i) {
+      vertex_valences_[i] = corner_table_->Valence(VertexIndex(i));
+    }
+    return true;
+  }
+
+  inline void NewCornerReached(CornerIndex corner) { last_corner_ = corner; }
+
+  inline int32_t ComputePredictedSymbol(VertexIndex pivot) {
+    const int valence = vertex_valences_[pivot.value()];
+    if (valence < 0) {
+      // This situation can happen only for split vertices. Returning
+      // TOPOLOGY_INVALID always cases misprediction.
+      return TOPOLOGY_INVALID;
+    }
+    if (valence < 6) {
+      return TOPOLOGY_R;
+    }
+    return TOPOLOGY_C;
+  }
+
+  inline void EncodeSymbol(EdgebreakerTopologyBitPattern symbol) {
+    ++num_symbols_;
+    // Update valences on the mesh. And compute the predicted preceding symbol.
+    // Note that the valences are computed for the so far unencoded part of the
+    // mesh. Adding a new symbol either reduces valences on the vertices or
+    // leaves the valence unchanged.
+    int32_t predicted_symbol = -1;
+    const CornerIndex next = corner_table_->Next(last_corner_);
+    const CornerIndex prev = corner_table_->Previous(last_corner_);
+    switch (symbol) {
+      case TOPOLOGY_C:
+        // Compute prediction.
+        predicted_symbol = ComputePredictedSymbol(corner_table_->Vertex(next));
+        FALLTHROUGH_INTENDED;
+      case TOPOLOGY_S:
+        // Update valences.
+        vertex_valences_[corner_table_->Vertex(next).value()] -= 1;
+        vertex_valences_[corner_table_->Vertex(prev).value()] -= 1;
+        if (symbol == TOPOLOGY_S) {
+          // Whenever we reach a split symbol, mark its tip vertex as invalid by
+          // setting the valence to a negative value. Any prediction that will
+          // use this vertex will then cause a misprediction. This is currently
+          // necessary because the decoding works in the reverse direction and
+          // the decoder doesn't know about these vertices until the split
+          // symbol is decoded at which point two vertices are merged into one.
+          // This can be most likely solved on the encoder side by splitting the
+          // tip vertex into two, but since split symbols are relatively rare,
+          // it's probably not worth doing it.
+          vertex_valences_[corner_table_->Vertex(last_corner_).value()] = -1;
+          ++num_split_symbols_;
+        }
+        break;
+      case TOPOLOGY_R:
+        // Compute prediction.
+        predicted_symbol = ComputePredictedSymbol(corner_table_->Vertex(next));
+        // Update valences.
+        vertex_valences_[corner_table_->Vertex(last_corner_).value()] -= 1;
+        vertex_valences_[corner_table_->Vertex(next).value()] -= 1;
+        vertex_valences_[corner_table_->Vertex(prev).value()] -= 2;
+        break;
+      case TOPOLOGY_L:
+        vertex_valences_[corner_table_->Vertex(last_corner_).value()] -= 1;
+        vertex_valences_[corner_table_->Vertex(next).value()] -= 2;
+        vertex_valences_[corner_table_->Vertex(prev).value()] -= 1;
+        break;
+      case TOPOLOGY_E:
+        vertex_valences_[corner_table_->Vertex(last_corner_).value()] -= 2;
+        vertex_valences_[corner_table_->Vertex(next).value()] -= 2;
+        vertex_valences_[corner_table_->Vertex(prev).value()] -= 2;
+        break;
+      default:
+        break;
+    }
+    // Flag used when it's necessary to explicitly store the previous symbol.
+    bool store_prev_symbol = true;
+    if (predicted_symbol != -1) {
+      if (predicted_symbol == prev_symbol_) {
+        predictions_.push_back(true);
+        store_prev_symbol = false;
+      } else if (prev_symbol_ != -1) {
+        predictions_.push_back(false);
+      }
+    }
+    if (store_prev_symbol && prev_symbol_ != -1) {
+      MeshEdgebreakerTraversalEncoder::EncodeSymbol(
+          static_cast<EdgebreakerTopologyBitPattern>(prev_symbol_));
+    }
+    prev_symbol_ = symbol;
+  }
+
+  void Done() {
+    // We still need to store the last encoded symbol.
+    if (prev_symbol_ != -1) {
+      MeshEdgebreakerTraversalEncoder::EncodeSymbol(
+          static_cast<EdgebreakerTopologyBitPattern>(prev_symbol_));
+    }
+    // Store the init face configurations and the explicitly encoded symbols.
+    MeshEdgebreakerTraversalEncoder::Done();
+    // Encode the number of split symbols.
+    GetOutputBuffer()->Encode(num_split_symbols_);
+    // Store the predictions.
+    BinaryEncoder prediction_encoder;
+    prediction_encoder.StartEncoding();
+    for (int i = static_cast<int>(predictions_.size()) - 1; i >= 0; --i) {
+      prediction_encoder.EncodeBit(predictions_[i]);
+    }
+    prediction_encoder.EndEncoding(GetOutputBuffer());
+  }
+
+  int NumEncodedSymbols() const { return num_symbols_; }
+
+ private:
+  const CornerTable *corner_table_;
+  std::vector<int> vertex_valences_;
+  std::vector<bool> predictions_;
+  // Previously encoded symbol.
+  int32_t prev_symbol_;
+  // The total number of encoded split symbols.
+  int32_t num_split_symbols_;
+  CornerIndex last_corner_;
+  // Explicitly count the number of encoded symbols.
+  int num_symbols_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_PREDICTIVE_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_valence_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_valence_decoder.h
new file mode 100644
index 000000000..c00373727
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_valence_decoder.h
@@ -0,0 +1,215 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_VALENCE_DECODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_VALENCE_DECODER_H_
+
+#include "draco/compression/entropy/symbol_decoding.h"
+#include "draco/compression/mesh/mesh_edgebreaker_traversal_decoder.h"
+#include "draco/core/varint_decoding.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Decoder for traversal encoded with MeshEdgebreakerTraversalValenceEncoder.
+// The decoder maintains valences of the decoded portion of the traversed mesh
+// and it uses them to select entropy context used for decoding of the actual
+// symbols.
+class MeshEdgebreakerTraversalValenceDecoder
+    : public MeshEdgebreakerTraversalDecoder {
+ public:
+  MeshEdgebreakerTraversalValenceDecoder()
+      : corner_table_(nullptr),
+        num_vertices_(0),
+        last_symbol_(-1),
+        active_context_(-1),
+        min_valence_(2),
+        max_valence_(7) {}
+  void Init(MeshEdgebreakerDecoderImplInterface *decoder) {
+    MeshEdgebreakerTraversalDecoder::Init(decoder);
+    corner_table_ = decoder->GetCornerTable();
+  }
+  void SetNumEncodedVertices(int num_vertices) { num_vertices_ = num_vertices; }
+
+  bool Start(DecoderBuffer *out_buffer) {
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+    if (BitstreamVersion() < DRACO_BITSTREAM_VERSION(2, 2)) {
+      if (!MeshEdgebreakerTraversalDecoder::DecodeTraversalSymbols()) {
+        return false;
+      }
+    }
+#endif
+    if (!MeshEdgebreakerTraversalDecoder::DecodeStartFaces()) {
+      return false;
+    }
+    if (!MeshEdgebreakerTraversalDecoder::DecodeAttributeSeams()) {
+      return false;
+    }
+    *out_buffer = *buffer();
+
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+    if (BitstreamVersion() < DRACO_BITSTREAM_VERSION(2, 2)) {
+      uint32_t num_split_symbols;
+      if (BitstreamVersion() < DRACO_BITSTREAM_VERSION(2, 0)) {
+        if (!out_buffer->Decode(&num_split_symbols)) {
+          return false;
+        }
+      } else {
+        if (!DecodeVarint(&num_split_symbols, out_buffer)) {
+          return false;
+        }
+      }
+      if (num_split_symbols >= static_cast<uint32_t>(num_vertices_)) {
+        return false;
+      }
+
+      int8_t mode;
+      if (!out_buffer->Decode(&mode)) {
+        return false;
+      }
+      if (mode == EDGEBREAKER_VALENCE_MODE_2_7) {
+        min_valence_ = 2;
+        max_valence_ = 7;
+      } else {
+        // Unsupported mode.
+        return false;
+      }
+
+    } else
+#endif
+    {
+      min_valence_ = 2;
+      max_valence_ = 7;
+    }
+
+    if (num_vertices_ < 0) {
+      return false;
+    }
+    // Set the valences of all initial vertices to 0.
+    vertex_valences_.resize(num_vertices_, 0);
+
+    const int num_unique_valences = max_valence_ - min_valence_ + 1;
+
+    // Decode all symbols for all contexts.
+    context_symbols_.resize(num_unique_valences);
+    context_counters_.resize(context_symbols_.size());
+    for (int i = 0; i < context_symbols_.size(); ++i) {
+      uint32_t num_symbols;
+      if (!DecodeVarint<uint32_t>(&num_symbols, out_buffer)) {
+        return false;
+      }
+      if (num_symbols > static_cast<uint32_t>(corner_table_->num_faces())) {
+        return false;
+      }
+      if (num_symbols > 0) {
+        context_symbols_[i].resize(num_symbols);
+        DecodeSymbols(num_symbols, 1, out_buffer, context_symbols_[i].data());
+        // All symbols are going to be processed from the back.
+        context_counters_[i] = num_symbols;
+      }
+    }
+    return true;
+  }
+
+  inline uint32_t DecodeSymbol() {
+    // First check if we have a valid context.
+    if (active_context_ != -1) {
+      const int context_counter = --context_counters_[active_context_];
+      if (context_counter < 0) {
+        return TOPOLOGY_INVALID;
+      }
+      const int symbol_id = context_symbols_[active_context_][context_counter];
+      last_symbol_ = edge_breaker_symbol_to_topology_id[symbol_id];
+    } else {
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+      if (BitstreamVersion() < DRACO_BITSTREAM_VERSION(2, 2)) {
+        // We don't have a predicted symbol or the symbol was mis-predicted.
+        // Decode it directly.
+        last_symbol_ = MeshEdgebreakerTraversalDecoder::DecodeSymbol();
+
+      } else
+#endif
+      {
+        // The first symbol must be E.
+        last_symbol_ = TOPOLOGY_E;
+      }
+    }
+    return last_symbol_;
+  }
+
+  inline void NewActiveCornerReached(CornerIndex corner) {
+    const CornerIndex next = corner_table_->Next(corner);
+    const CornerIndex prev = corner_table_->Previous(corner);
+    // Update valences.
+    switch (last_symbol_) {
+      case TOPOLOGY_C:
+      case TOPOLOGY_S:
+        vertex_valences_[corner_table_->Vertex(next)] += 1;
+        vertex_valences_[corner_table_->Vertex(prev)] += 1;
+        break;
+      case TOPOLOGY_R:
+        vertex_valences_[corner_table_->Vertex(corner)] += 1;
+        vertex_valences_[corner_table_->Vertex(next)] += 1;
+        vertex_valences_[corner_table_->Vertex(prev)] += 2;
+        break;
+      case TOPOLOGY_L:
+        vertex_valences_[corner_table_->Vertex(corner)] += 1;
+        vertex_valences_[corner_table_->Vertex(next)] += 2;
+        vertex_valences_[corner_table_->Vertex(prev)] += 1;
+        break;
+      case TOPOLOGY_E:
+        vertex_valences_[corner_table_->Vertex(corner)] += 2;
+        vertex_valences_[corner_table_->Vertex(next)] += 2;
+        vertex_valences_[corner_table_->Vertex(prev)] += 2;
+        break;
+      default:
+        break;
+    }
+    // Compute the new context that is going to be used to decode the next
+    // symbol.
+    const int active_valence = vertex_valences_[corner_table_->Vertex(next)];
+    int clamped_valence;
+    if (active_valence < min_valence_) {
+      clamped_valence = min_valence_;
+    } else if (active_valence > max_valence_) {
+      clamped_valence = max_valence_;
+    } else {
+      clamped_valence = active_valence;
+    }
+
+    active_context_ = (clamped_valence - min_valence_);
+  }
+
+  inline void MergeVertices(VertexIndex dest, VertexIndex source) {
+    // Update valences on the merged vertices.
+    vertex_valences_[dest] += vertex_valences_[source];
+  }
+
+ private:
+  const CornerTable *corner_table_;
+  int num_vertices_;
+  IndexTypeVector<VertexIndex, int> vertex_valences_;
+  int last_symbol_;
+  int active_context_;
+
+  int min_valence_;
+  int max_valence_;
+  std::vector<std::vector<uint32_t>> context_symbols_;
+  // Points to the active symbol in each context.
+  std::vector<int> context_counters_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_VALENCE_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_valence_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_valence_encoder.h
new file mode 100644
index 000000000..c492c84bb
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_valence_encoder.h
@@ -0,0 +1,226 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_VALENCE_ENCODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_VALENCE_ENCODER_H_
+
+#include "draco/compression/entropy/symbol_encoding.h"
+#include "draco/compression/mesh/mesh_edgebreaker_traversal_encoder.h"
+#include "draco/core/varint_encoding.h"
+
+namespace draco {
+
+// Predictive encoder for the Edgebreaker symbols based on valences of the
+// previously encoded vertices, following the method described in: Szymczak'02,
+// "Optimized Edgebreaker Encoding for Large and Regular Triangle Meshes". Each
+// valence is used to specify a different entropy context for encoding of the
+// symbols.
+// Encoder can operate in various predefined modes that can be used to select
+// the way in which the entropy contexts are computed (e.g. using different
+// clamping for valences, or even using different inputs to compute the
+// contexts), see EdgebreakerValenceCodingMode in mesh_edgebreaker_shared.h for
+// a list of supported modes.
+class MeshEdgebreakerTraversalValenceEncoder
+    : public MeshEdgebreakerTraversalEncoder {
+ public:
+  MeshEdgebreakerTraversalValenceEncoder()
+      : corner_table_(nullptr),
+        prev_symbol_(-1),
+        last_corner_(kInvalidCornerIndex),
+        num_symbols_(0),
+        min_valence_(2),
+        max_valence_(7) {}
+
+  bool Init(MeshEdgebreakerEncoderImplInterface *encoder) {
+    if (!MeshEdgebreakerTraversalEncoder::Init(encoder)) {
+      return false;
+    }
+    min_valence_ = 2;
+    max_valence_ = 7;
+    corner_table_ = encoder->GetCornerTable();
+
+    // Initialize valences of all vertices.
+    vertex_valences_.resize(corner_table_->num_vertices());
+    for (VertexIndex i(0); i < static_cast<uint32_t>(vertex_valences_.size());
+         ++i) {
+      vertex_valences_[i] = corner_table_->Valence(VertexIndex(i));
+    }
+
+    // Replicate the corner to vertex map from the corner table. We need to do
+    // this because the map may get updated during encoding because we add new
+    // vertices when we encounter split symbols.
+    corner_to_vertex_map_.resize(corner_table_->num_corners());
+    for (CornerIndex i(0); i < corner_table_->num_corners(); ++i) {
+      corner_to_vertex_map_[i] = corner_table_->Vertex(i);
+    }
+    const int32_t num_unique_valences = max_valence_ - min_valence_ + 1;
+
+    context_symbols_.resize(num_unique_valences);
+    return true;
+  }
+
+  inline void NewCornerReached(CornerIndex corner) { last_corner_ = corner; }
+
+  inline void EncodeSymbol(EdgebreakerTopologyBitPattern symbol) {
+    ++num_symbols_;
+    // Update valences on the mesh and compute the context that is going to be
+    // used to encode the processed symbol.
+    // Note that the valences are computed for the so far unencoded part of the
+    // mesh (i.e. the decoding is reverse). Adding a new symbol either reduces
+    // valences on the vertices or leaves the valence unchanged.
+
+    const CornerIndex next = corner_table_->Next(last_corner_);
+    const CornerIndex prev = corner_table_->Previous(last_corner_);
+
+    // Get valence on the tip corner of the active edge (outgoing edge that is
+    // going to be used in reverse decoding of the connectivity to predict the
+    // next symbol).
+    const int active_valence = vertex_valences_[corner_to_vertex_map_[next]];
+    switch (symbol) {
+      case TOPOLOGY_C:
+        // Compute prediction.
+        FALLTHROUGH_INTENDED;
+      case TOPOLOGY_S:
+        // Update valences.
+        vertex_valences_[corner_to_vertex_map_[next]] -= 1;
+        vertex_valences_[corner_to_vertex_map_[prev]] -= 1;
+        if (symbol == TOPOLOGY_S) {
+          // Whenever we reach a split symbol, we need to split the vertex into
+          // two and attach all corners on the left and right sides of the split
+          // vertex to the respective vertices (see image below). This is
+          // necessary since the decoder works in the reverse order and it
+          // merges the two vertices only after the split symbol is processed.
+          //
+          //     * -----
+          //    / \--------
+          //   /   \--------
+          //  /     \-------
+          // *-------v-------*
+          //  \     /c\     /
+          //   \   /   \   /
+          //    \ /n S p\ /
+          //     *.......*
+          //
+
+          // Count the number of faces on the left side of the split vertex and
+          // update the valence on the "left vertex".
+          int num_left_faces = 0;
+          CornerIndex act_c = corner_table_->Opposite(prev);
+          while (act_c != kInvalidCornerIndex) {
+            if (encoder_impl()->IsFaceEncoded(corner_table_->Face(act_c))) {
+              break;  // Stop when we reach the first visited face.
+            }
+            ++num_left_faces;
+            act_c = corner_table_->Opposite(corner_table_->Next(act_c));
+          }
+          vertex_valences_[corner_to_vertex_map_[last_corner_]] =
+              num_left_faces + 1;
+
+          // Create a new vertex for the right side and count the number of
+          // faces that should be attached to this vertex.
+          const int new_vert_id = static_cast<int>(vertex_valences_.size());
+          int num_right_faces = 0;
+
+          act_c = corner_table_->Opposite(next);
+          while (act_c != kInvalidCornerIndex) {
+            if (encoder_impl()->IsFaceEncoded(corner_table_->Face(act_c))) {
+              break;  // Stop when we reach the first visited face.
+            }
+            ++num_right_faces;
+            // Map corners on the right side to the newly created vertex.
+            corner_to_vertex_map_[corner_table_->Next(act_c)] = new_vert_id;
+            act_c = corner_table_->Opposite(corner_table_->Previous(act_c));
+          }
+          vertex_valences_.push_back(num_right_faces + 1);
+        }
+        break;
+      case TOPOLOGY_R:
+        // Update valences.
+        vertex_valences_[corner_to_vertex_map_[last_corner_]] -= 1;
+        vertex_valences_[corner_to_vertex_map_[next]] -= 1;
+        vertex_valences_[corner_to_vertex_map_[prev]] -= 2;
+        break;
+      case TOPOLOGY_L:
+
+        vertex_valences_[corner_to_vertex_map_[last_corner_]] -= 1;
+        vertex_valences_[corner_to_vertex_map_[next]] -= 2;
+        vertex_valences_[corner_to_vertex_map_[prev]] -= 1;
+        break;
+      case TOPOLOGY_E:
+        vertex_valences_[corner_to_vertex_map_[last_corner_]] -= 2;
+        vertex_valences_[corner_to_vertex_map_[next]] -= 2;
+        vertex_valences_[corner_to_vertex_map_[prev]] -= 2;
+        break;
+      default:
+        break;
+    }
+
+    if (prev_symbol_ != -1) {
+      int clamped_valence;
+      if (active_valence < min_valence_) {
+        clamped_valence = min_valence_;
+      } else if (active_valence > max_valence_) {
+        clamped_valence = max_valence_;
+      } else {
+        clamped_valence = active_valence;
+      }
+
+      const int context = clamped_valence - min_valence_;
+      context_symbols_[context].push_back(
+          edge_breaker_topology_to_symbol_id[prev_symbol_]);
+    }
+
+    prev_symbol_ = symbol;
+  }
+
+  void Done() {
+    // Store the init face configurations and attribute seam data
+    MeshEdgebreakerTraversalEncoder::EncodeStartFaces();
+    MeshEdgebreakerTraversalEncoder::EncodeAttributeSeams();
+
+    // Store the contexts.
+    for (int i = 0; i < context_symbols_.size(); ++i) {
+      EncodeVarint<uint32_t>(static_cast<uint32_t>(context_symbols_[i].size()),
+                             GetOutputBuffer());
+      if (context_symbols_[i].size() > 0) {
+        EncodeSymbols(context_symbols_[i].data(),
+                      static_cast<int>(context_symbols_[i].size()), 1, nullptr,
+                      GetOutputBuffer());
+      }
+    }
+  }
+
+  int NumEncodedSymbols() const { return num_symbols_; }
+
+ private:
+  const CornerTable *corner_table_;
+  // Explicit map between corners and vertices. We cannot use the one stored
+  // in the |corner_table_| because we may need to add additional vertices to
+  // handle split symbols.
+  IndexTypeVector<CornerIndex, VertexIndex> corner_to_vertex_map_;
+  IndexTypeVector<VertexIndex, int> vertex_valences_;
+  // Previously encoded symbol.
+  int32_t prev_symbol_;
+  CornerIndex last_corner_;
+  // Explicitly count the number of encoded symbols.
+  int num_symbols_;
+
+  int min_valence_;
+  int max_valence_;
+  std::vector<std::vector<uint32_t>> context_symbols_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_VALENCE_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_encoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_encoder.cc
new file mode 100644
index 000000000..483ea02a7
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_encoder.cc
@@ -0,0 +1,34 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/mesh/mesh_encoder.h"
+
+namespace draco {
+
+MeshEncoder::MeshEncoder() : mesh_(nullptr), num_encoded_faces_(0) {}
+
+void MeshEncoder::SetMesh(const Mesh &m) {
+  mesh_ = &m;
+  SetPointCloud(m);
+}
+
+Status MeshEncoder::EncodeGeometryData() {
+  DRACO_RETURN_IF_ERROR(EncodeConnectivity());
+  if (options()->GetGlobalBool("store_number_of_encoded_faces", false)) {
+    ComputeNumberOfEncodedFaces();
+  }
+  return OkStatus();
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_encoder.h
new file mode 100644
index 000000000..30ec4fa34
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_encoder.h
@@ -0,0 +1,84 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_ENCODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_ENCODER_H_
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/compression/point_cloud/point_cloud_encoder.h"
+#include "draco/mesh/mesh.h"
+#include "draco/mesh/mesh_attribute_corner_table.h"
+
+namespace draco {
+
+// Abstract base class for all mesh encoders. It provides some basic
+// functionality that's shared between different encoders.
+class MeshEncoder : public PointCloudEncoder {
+ public:
+  MeshEncoder();
+
+  // Sets the mesh that is going be encoded. Must be called before the Encode()
+  // method.
+  void SetMesh(const Mesh &m);
+
+  EncodedGeometryType GetGeometryType() const override {
+    return TRIANGULAR_MESH;
+  }
+
+  // Returns the number of faces that were encoded during the last Encode().
+  // function call. Valid only if "store_number_of_encoded_faces" flag was set
+  // in the provided EncoderOptions.
+  size_t num_encoded_faces() const { return num_encoded_faces_; }
+
+  // Returns the base connectivity of the encoded mesh (or nullptr if it is not
+  // initialized).
+  virtual const CornerTable *GetCornerTable() const { return nullptr; }
+
+  // Returns the attribute connectivity data or nullptr if it does not exist.
+  virtual const MeshAttributeCornerTable *GetAttributeCornerTable(
+      int /* att_id */) const {
+    return nullptr;
+  }
+
+  // Returns the encoding data for a given attribute or nullptr when the data
+  // does not exist.
+  virtual const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int /* att_id */) const {
+    return nullptr;
+  }
+
+  const Mesh *mesh() const { return mesh_; }
+
+ protected:
+  Status EncodeGeometryData() override;
+
+  // Needs to be implemented by the derived classes.
+  virtual Status EncodeConnectivity() = 0;
+
+  // Computes and sets the num_encoded_faces_ for the encoder.
+  virtual void ComputeNumberOfEncodedFaces() = 0;
+
+  void set_mesh(const Mesh *mesh) { mesh_ = mesh; }
+  void set_num_encoded_faces(size_t num_faces) {
+    num_encoded_faces_ = num_faces;
+  }
+
+ private:
+  const Mesh *mesh_;
+  size_t num_encoded_faces_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_encoder_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_encoder_test.cc
new file mode 100644
index 000000000..55f683696
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_encoder_test.cc
@@ -0,0 +1,116 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/mesh/mesh_encoder.h"
+
+#include "draco/compression/expert_encode.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+#include "draco/io/obj_decoder.h"
+
+namespace draco {
+
+struct MeshEncoderTestParams {
+  MeshEncoderTestParams(const std::string &encoding_method, int cl)
+      : encoding_method(encoding_method), cl(cl) {}
+  std::string encoding_method;
+  int cl;
+};
+
+class MeshEncoderTest : public ::testing::TestWithParam<MeshEncoderTestParams> {
+ protected:
+  MeshEncoderTest() {}
+
+  // Fills out_method with id of the encoding method used for the test.
+  // Returns false if the encoding method is not set properly.
+  bool GetMethod(MeshEncoderMethod *out_method) const {
+    if (GetParam().encoding_method == "sequential") {
+      *out_method = MESH_SEQUENTIAL_ENCODING;
+      return true;
+    }
+    if (GetParam().encoding_method == "edgebreaker") {
+      *out_method = MESH_EDGEBREAKER_ENCODING;
+      return true;
+    }
+    return false;
+  }
+
+  void TestGolden(const std::string &file_name) {
+    // This test verifies that a given set of meshes are encoded to an expected
+    // output. This is useful for catching bugs in code changes that are not
+    // supposed to change the encoding.
+    // The test is expected to fail when the encoding is modified. In such case,
+    // the golden files need to be updated to reflect the changes.
+    MeshEncoderMethod method;
+    ASSERT_TRUE(GetMethod(&method))
+        << "Test is run for an unknown encoding method";
+
+    std::string golden_file_name = file_name;
+    golden_file_name += '.';
+    golden_file_name += GetParam().encoding_method;
+    golden_file_name += ".cl";
+    golden_file_name += std::to_string(GetParam().cl);
+    golden_file_name += ".";
+    golden_file_name += std::to_string(kDracoMeshBitstreamVersionMajor);
+    golden_file_name += ".";
+    golden_file_name += std::to_string(kDracoMeshBitstreamVersionMinor);
+    golden_file_name += ".drc";
+    const std::unique_ptr<Mesh> mesh(ReadMeshFromTestFile(file_name));
+    ASSERT_NE(mesh, nullptr) << "Failed to load test model " << file_name;
+
+    ExpertEncoder encoder(*mesh);
+    encoder.SetEncodingMethod(method);
+    encoder.SetSpeedOptions(10 - GetParam().cl, 10 - GetParam().cl);
+    encoder.SetAttributeQuantization(0, 20);
+    for (int i = 1; i < mesh->num_attributes(); ++i) {
+      encoder.SetAttributeQuantization(i, 12);
+    }
+    EncoderBuffer buffer;
+    ASSERT_TRUE(encoder.EncodeToBuffer(&buffer).ok())
+        << "Failed encoding test mesh " << file_name << " with method "
+        << GetParam().encoding_method;
+    // Check that the encoded mesh was really encoded with the selected method.
+    DecoderBuffer decoder_buffer;
+    decoder_buffer.Init(buffer.data(), buffer.size());
+    decoder_buffer.Advance(8);  // Skip the header to the encoding method id.
+    uint8_t encoded_method;
+    ASSERT_TRUE(decoder_buffer.Decode(&encoded_method));
+    ASSERT_EQ(encoded_method, method);
+    if (!FLAGS_update_golden_files) {
+      EXPECT_TRUE(
+          CompareGoldenFile(golden_file_name, buffer.data(), buffer.size()))
+          << "Encoded data is different from the golden file. Please verify "
+             "that the encoding works as expected and update the golden file "
+             "if necessary (run the test with --update_golden_files flag).";
+    } else {
+      // Save the files into the local folder.
+      EXPECT_TRUE(
+          GenerateGoldenFile(golden_file_name, buffer.data(), buffer.size()))
+          << "Failed to generate new golden file for " << file_name;
+    }
+  }
+};
+
+TEST_P(MeshEncoderTest, EncodeGoldenMeshTestNm) { TestGolden("test_nm.obj"); }
+
+TEST_P(MeshEncoderTest, EncodeGoldenMeshCubeAtt) { TestGolden("cube_att.obj"); }
+
+INSTANTIATE_TEST_SUITE_P(
+    MeshEncoderTests, MeshEncoderTest,
+    ::testing::Values(MeshEncoderTestParams("sequential", 3),
+                      MeshEncoderTestParams("edgebreaker", 4),
+                      MeshEncoderTestParams("edgebreaker", 10)));
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_sequential_decoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_sequential_decoder.cc
new file mode 100644
index 000000000..be349f543
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_sequential_decoder.cc
@@ -0,0 +1,169 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/mesh/mesh_sequential_decoder.h"
+
+#include "draco/compression/attributes/linear_sequencer.h"
+#include "draco/compression/attributes/sequential_attribute_decoders_controller.h"
+#include "draco/compression/entropy/symbol_decoding.h"
+#include "draco/core/varint_decoding.h"
+
+namespace draco {
+
+MeshSequentialDecoder::MeshSequentialDecoder() {}
+
+bool MeshSequentialDecoder::DecodeConnectivity() {
+  uint32_t num_faces;
+  uint32_t num_points;
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+    if (!buffer()->Decode(&num_faces)) {
+      return false;
+    }
+    if (!buffer()->Decode(&num_points)) {
+      return false;
+    }
+
+  } else
+#endif
+  {
+    if (!DecodeVarint(&num_faces, buffer())) {
+      return false;
+    }
+    if (!DecodeVarint(&num_points, buffer())) {
+      return false;
+    }
+  }
+
+  // Check that num_faces and num_points are valid values.
+  const uint64_t faces_64 = static_cast<uint64_t>(num_faces);
+  const uint64_t points_64 = static_cast<uint64_t>(num_points);
+  // Compressed sequential encoding can only handle (2^32 - 1) / 3 indices.
+  if (faces_64 > 0xffffffff / 3) {
+    return false;
+  }
+  if (faces_64 > buffer()->remaining_size() / 3) {
+    // The number of faces is unreasonably high, because face indices do not
+    // fit in the remaining size of the buffer.
+    return false;
+  }
+  if (points_64 > faces_64 * 3) {
+    return false;
+  }
+  uint8_t connectivity_method;
+  if (!buffer()->Decode(&connectivity_method)) {
+    return false;
+  }
+  if (connectivity_method == 0) {
+    if (!DecodeAndDecompressIndices(num_faces)) {
+      return false;
+    }
+  } else {
+    if (num_points < 256) {
+      // Decode indices as uint8_t.
+      for (uint32_t i = 0; i < num_faces; ++i) {
+        Mesh::Face face;
+        for (int j = 0; j < 3; ++j) {
+          uint8_t val;
+          if (!buffer()->Decode(&val)) {
+            return false;
+          }
+          face[j] = val;
+        }
+        mesh()->AddFace(face);
+      }
+    } else if (num_points < (1 << 16)) {
+      // Decode indices as uint16_t.
+      for (uint32_t i = 0; i < num_faces; ++i) {
+        Mesh::Face face;
+        for (int j = 0; j < 3; ++j) {
+          uint16_t val;
+          if (!buffer()->Decode(&val)) {
+            return false;
+          }
+          face[j] = val;
+        }
+        mesh()->AddFace(face);
+      }
+    } else if (mesh()->num_points() < (1 << 21) &&
+               bitstream_version() >= DRACO_BITSTREAM_VERSION(2, 2)) {
+      // Decode indices as uint32_t.
+      for (uint32_t i = 0; i < num_faces; ++i) {
+        Mesh::Face face;
+        for (int j = 0; j < 3; ++j) {
+          uint32_t val;
+          if (!DecodeVarint(&val, buffer())) {
+            return false;
+          }
+          face[j] = val;
+        }
+        mesh()->AddFace(face);
+      }
+    } else {
+      // Decode faces as uint32_t (default).
+      for (uint32_t i = 0; i < num_faces; ++i) {
+        Mesh::Face face;
+        for (int j = 0; j < 3; ++j) {
+          uint32_t val;
+          if (!buffer()->Decode(&val)) {
+            return false;
+          }
+          face[j] = val;
+        }
+        mesh()->AddFace(face);
+      }
+    }
+  }
+  point_cloud()->set_num_points(num_points);
+  return true;
+}
+
+bool MeshSequentialDecoder::CreateAttributesDecoder(int32_t att_decoder_id) {
+  // Always create the basic attribute decoder.
+  return SetAttributesDecoder(
+      att_decoder_id,
+      std::unique_ptr<AttributesDecoder>(
+          new SequentialAttributeDecodersController(
+              std::unique_ptr<PointsSequencer>(
+                  new LinearSequencer(point_cloud()->num_points())))));
+}
+
+bool MeshSequentialDecoder::DecodeAndDecompressIndices(uint32_t num_faces) {
+  // Get decoded indices differences that were encoded with an entropy code.
+  std::vector<uint32_t> indices_buffer(num_faces * 3);
+  if (!DecodeSymbols(num_faces * 3, 1, buffer(), indices_buffer.data())) {
+    return false;
+  }
+  // Reconstruct the indices from the differences.
+  // See MeshSequentialEncoder::CompressAndEncodeIndices() for more details.
+  int32_t last_index_value = 0;
+  int vertex_index = 0;
+  for (uint32_t i = 0; i < num_faces; ++i) {
+    Mesh::Face face;
+    for (int j = 0; j < 3; ++j) {
+      const uint32_t encoded_val = indices_buffer[vertex_index++];
+      int32_t index_diff = (encoded_val >> 1);
+      if (encoded_val & 1) {
+        index_diff = -index_diff;
+      }
+      const int32_t index_value = index_diff + last_index_value;
+      face[j] = index_value;
+      last_index_value = index_value;
+    }
+    mesh()->AddFace(face);
+  }
+  return true;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_sequential_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_sequential_decoder.h
new file mode 100644
index 000000000..3a86c75d5
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_sequential_decoder.h
@@ -0,0 +1,39 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_SEQUENTIAL_DECODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_SEQUENTIAL_DECODER_H_
+
+#include "draco/compression/mesh/mesh_decoder.h"
+
+namespace draco {
+
+// Class for decoding data encoded by MeshSequentialEncoder.
+class MeshSequentialDecoder : public MeshDecoder {
+ public:
+  MeshSequentialDecoder();
+
+ protected:
+  bool DecodeConnectivity() override;
+  bool CreateAttributesDecoder(int32_t att_decoder_id) override;
+
+ private:
+  // Decodes face indices that were compressed with an entropy code.
+  // Returns false on error.
+  bool DecodeAndDecompressIndices(uint32_t num_faces);
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_SEQUENTIAL_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_sequential_encoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_sequential_encoder.cc
new file mode 100644
index 000000000..02ac7779e
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_sequential_encoder.cc
@@ -0,0 +1,132 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/mesh/mesh_sequential_encoder.h"
+
+#include <cstdlib>
+
+#include "draco/compression/attributes/linear_sequencer.h"
+#include "draco/compression/attributes/sequential_attribute_encoders_controller.h"
+#include "draco/compression/entropy/symbol_encoding.h"
+#include "draco/core/varint_encoding.h"
+
+namespace draco {
+
+MeshSequentialEncoder::MeshSequentialEncoder() {}
+
+Status MeshSequentialEncoder::EncodeConnectivity() {
+  // Serialize indices.
+  const uint32_t num_faces = mesh()->num_faces();
+  EncodeVarint(num_faces, buffer());
+  EncodeVarint(static_cast<uint32_t>(mesh()->num_points()), buffer());
+
+  // We encode all attributes in the original (possibly duplicated) format.
+  // TODO(ostava): This may not be optimal if we have only one attribute or if
+  // all attributes share the same index mapping.
+  if (options()->GetGlobalBool("compress_connectivity", false)) {
+    // 0 = Encode compressed indices.
+    buffer()->Encode(static_cast<uint8_t>(0));
+    if (!CompressAndEncodeIndices()) {
+      return Status(Status::DRACO_ERROR, "Failed to compress connectivity.");
+    }
+  } else {
+    // 1 = Encode indices directly.
+    buffer()->Encode(static_cast<uint8_t>(1));
+    // Store vertex indices using a smallest data type that fits their range.
+    // TODO(ostava): This can be potentially improved by using a tighter
+    // fit that is not bound by a bit-length of any particular data type.
+    if (mesh()->num_points() < 256) {
+      // Serialize indices as uint8_t.
+      for (FaceIndex i(0); i < num_faces; ++i) {
+        const auto &face = mesh()->face(i);
+        buffer()->Encode(static_cast<uint8_t>(face[0].value()));
+        buffer()->Encode(static_cast<uint8_t>(face[1].value()));
+        buffer()->Encode(static_cast<uint8_t>(face[2].value()));
+      }
+    } else if (mesh()->num_points() < (1 << 16)) {
+      // Serialize indices as uint16_t.
+      for (FaceIndex i(0); i < num_faces; ++i) {
+        const auto &face = mesh()->face(i);
+        buffer()->Encode(static_cast<uint16_t>(face[0].value()));
+        buffer()->Encode(static_cast<uint16_t>(face[1].value()));
+        buffer()->Encode(static_cast<uint16_t>(face[2].value()));
+      }
+    } else if (mesh()->num_points() < (1 << 21)) {
+      // Serialize indices as varint.
+      for (FaceIndex i(0); i < num_faces; ++i) {
+        const auto &face = mesh()->face(i);
+        EncodeVarint(static_cast<uint32_t>(face[0].value()), buffer());
+        EncodeVarint(static_cast<uint32_t>(face[1].value()), buffer());
+        EncodeVarint(static_cast<uint32_t>(face[2].value()), buffer());
+      }
+    } else {
+      // Serialize faces as uint32_t (default).
+      for (FaceIndex i(0); i < num_faces; ++i) {
+        const auto &face = mesh()->face(i);
+        buffer()->Encode(face);
+      }
+    }
+  }
+  return OkStatus();
+}
+
+bool MeshSequentialEncoder::GenerateAttributesEncoder(int32_t att_id) {
+  // Create only one attribute encoder that is going to encode all points in a
+  // linear sequence.
+  if (att_id == 0) {
+    // Create a new attribute encoder only for the first attribute.
+    AddAttributesEncoder(std::unique_ptr<AttributesEncoder>(
+        new SequentialAttributeEncodersController(
+            std::unique_ptr<PointsSequencer>(
+                new LinearSequencer(point_cloud()->num_points())),
+            att_id)));
+  } else {
+    // Reuse the existing attribute encoder for other attributes.
+    attributes_encoder(0)->AddAttributeId(att_id);
+  }
+  return true;
+}
+
+bool MeshSequentialEncoder::CompressAndEncodeIndices() {
+  // Collect all indices to a buffer and encode them.
+  // Each new index is a difference from the previous value.
+  std::vector<uint32_t> indices_buffer;
+  int32_t last_index_value = 0;
+  const int num_faces = mesh()->num_faces();
+  for (FaceIndex i(0); i < num_faces; ++i) {
+    const auto &face = mesh()->face(i);
+    for (int j = 0; j < 3; ++j) {
+      const int32_t index_value = face[j].value();
+      const int32_t index_diff = index_value - last_index_value;
+      // Encode signed value to an unsigned one (put the sign to lsb pos).
+      const uint32_t encoded_val =
+          (abs(index_diff) << 1) | (index_diff < 0 ? 1 : 0);
+      indices_buffer.push_back(encoded_val);
+      last_index_value = index_value;
+    }
+  }
+  EncodeSymbols(indices_buffer.data(), static_cast<int>(indices_buffer.size()),
+                1, nullptr, buffer());
+  return true;
+}
+
+void MeshSequentialEncoder::ComputeNumberOfEncodedPoints() {
+  set_num_encoded_points(mesh()->num_points());
+}
+
+void MeshSequentialEncoder::ComputeNumberOfEncodedFaces() {
+  set_num_encoded_faces(mesh()->num_faces());
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_sequential_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_sequential_encoder.h
new file mode 100644
index 000000000..672609642
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/mesh_sequential_encoder.h
@@ -0,0 +1,57 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// The encoder compresses all attribute values using an order preserving
+// attribute encoder (that can still support quantization, prediction schemes,
+// and other features).
+// The mesh connectivity data can be encoded using two modes that are controlled
+// using a global encoder options flag called "compress_connectivity"
+// 1. When "compress_connectivity" == true:
+//      All point ids are first delta coded and then compressed using an entropy
+//      coding.
+// 2. When "compress_connectivity" == false:
+//      All point ids are encoded directly using either 8, 16, or 32 bits per
+//      value based on the maximum point id value.
+
+#ifndef DRACO_COMPRESSION_MESH_MESH_SEQUENTIAL_ENCODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_SEQUENTIAL_ENCODER_H_
+
+#include "draco/compression/mesh/mesh_encoder.h"
+
+namespace draco {
+
+// Class that encodes mesh data using a simple binary representation of mesh's
+// connectivity and geometry.
+// TODO(ostava): Use a better name.
+class MeshSequentialEncoder : public MeshEncoder {
+ public:
+  MeshSequentialEncoder();
+  uint8_t GetEncodingMethod() const override {
+    return MESH_SEQUENTIAL_ENCODING;
+  }
+
+ protected:
+  Status EncodeConnectivity() override;
+  bool GenerateAttributesEncoder(int32_t att_id) override;
+  void ComputeNumberOfEncodedPoints() override;
+  void ComputeNumberOfEncodedFaces() override;
+
+ private:
+  // Returns false on error.
+  bool CompressAndEncodeIndices();
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_SEQUENTIAL_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/traverser/depth_first_traverser.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/traverser/depth_first_traverser.h
new file mode 100644
index 000000000..0b387ec3a
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/traverser/depth_first_traverser.h
@@ -0,0 +1,172 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_TRAVERSER_DEPTH_FIRST_TRAVERSER_H_
+#define DRACO_COMPRESSION_MESH_TRAVERSER_DEPTH_FIRST_TRAVERSER_H_
+
+#include <vector>
+
+#include "draco/compression/mesh/traverser/traverser_base.h"
+#include "draco/mesh/corner_table.h"
+
+namespace draco {
+
+// Basic traverser that traverses a mesh in a DFS like fashion using the
+// CornerTable data structure. The necessary bookkeeping is available via the
+// TraverserBase. Callbacks are handled through template argument
+// TraversalObserverT.
+//
+// TraversalObserverT can perform an action on a traversal event such as newly
+// visited face, or corner, but it does not affect the traversal itself.
+//
+// Concept TraversalObserverT requires:
+//
+// public:
+// void OnNewFaceVisited(FaceIndex face);
+//    - Called whenever a previously unvisited face is reached.
+//
+// void OnNewVertexVisited(VertexIndex vert, CornerIndex corner)
+//    - Called when a new vertex is visited. |corner| is used to indicate the
+//      which of the vertex's corners has been reached.
+
+template <class CornerTableT, class TraversalObserverT>
+class DepthFirstTraverser
+    : public TraverserBase<CornerTableT, TraversalObserverT> {
+ public:
+  typedef CornerTableT CornerTable;
+  typedef TraversalObserverT TraversalObserver;
+  typedef TraverserBase<CornerTable, TraversalObserver> Base;
+
+  DepthFirstTraverser() {}
+
+  // Called before any traversing starts.
+  void OnTraversalStart() {}
+
+  // Called when all the traversing is done.
+  void OnTraversalEnd() {}
+
+  bool TraverseFromCorner(CornerIndex corner_id) {
+    if (this->IsFaceVisited(corner_id)) {
+      return true;  // Already traversed.
+    }
+
+    corner_traversal_stack_.clear();
+    corner_traversal_stack_.push_back(corner_id);
+    // For the first face, check the remaining corners as they may not be
+    // processed yet.
+    const VertexIndex next_vert =
+        this->corner_table()->Vertex(this->corner_table()->Next(corner_id));
+    const VertexIndex prev_vert =
+        this->corner_table()->Vertex(this->corner_table()->Previous(corner_id));
+    if (next_vert == kInvalidVertexIndex || prev_vert == kInvalidVertexIndex) {
+      return false;
+    }
+    if (!this->IsVertexVisited(next_vert)) {
+      this->MarkVertexVisited(next_vert);
+      this->traversal_observer().OnNewVertexVisited(
+          next_vert, this->corner_table()->Next(corner_id));
+    }
+    if (!this->IsVertexVisited(prev_vert)) {
+      this->MarkVertexVisited(prev_vert);
+      this->traversal_observer().OnNewVertexVisited(
+          prev_vert, this->corner_table()->Previous(corner_id));
+    }
+
+    // Start the actual traversal.
+    while (!corner_traversal_stack_.empty()) {
+      // Currently processed corner.
+      corner_id = corner_traversal_stack_.back();
+      FaceIndex face_id(corner_id.value() / 3);
+      // Make sure the face hasn't been visited yet.
+      if (corner_id == kInvalidCornerIndex || this->IsFaceVisited(face_id)) {
+        // This face has been already traversed.
+        corner_traversal_stack_.pop_back();
+        continue;
+      }
+      while (true) {
+        this->MarkFaceVisited(face_id);
+        this->traversal_observer().OnNewFaceVisited(face_id);
+        const VertexIndex vert_id = this->corner_table()->Vertex(corner_id);
+        if (vert_id == kInvalidVertexIndex) {
+          return false;
+        }
+        if (!this->IsVertexVisited(vert_id)) {
+          const bool on_boundary = this->corner_table()->IsOnBoundary(vert_id);
+          this->MarkVertexVisited(vert_id);
+          this->traversal_observer().OnNewVertexVisited(vert_id, corner_id);
+          if (!on_boundary) {
+            corner_id = this->corner_table()->GetRightCorner(corner_id);
+            face_id = FaceIndex(corner_id.value() / 3);
+            continue;
+          }
+        }
+        // The current vertex has been already visited or it was on a boundary.
+        // We need to determine whether we can visit any of it's neighboring
+        // faces.
+        const CornerIndex right_corner_id =
+            this->corner_table()->GetRightCorner(corner_id);
+        const CornerIndex left_corner_id =
+            this->corner_table()->GetLeftCorner(corner_id);
+        const FaceIndex right_face_id(
+            (right_corner_id == kInvalidCornerIndex
+                 ? kInvalidFaceIndex
+                 : FaceIndex(right_corner_id.value() / 3)));
+        const FaceIndex left_face_id(
+            (left_corner_id == kInvalidCornerIndex
+                 ? kInvalidFaceIndex
+                 : FaceIndex(left_corner_id.value() / 3)));
+        if (this->IsFaceVisited(right_face_id)) {
+          // Right face has been already visited.
+          if (this->IsFaceVisited(left_face_id)) {
+            // Both neighboring faces are visited. End reached.
+            corner_traversal_stack_.pop_back();
+            break;  // Break from the while (true) loop.
+          } else {
+            // Go to the left face.
+            corner_id = left_corner_id;
+            face_id = left_face_id;
+          }
+        } else {
+          // Right face was not visited.
+          if (this->IsFaceVisited(left_face_id)) {
+            // Left face visited, go to the right one.
+            corner_id = right_corner_id;
+            face_id = right_face_id;
+          } else {
+            // Both neighboring faces are unvisited, we need to visit both of
+            // them.
+
+            // Split the traversal.
+            // First make the top of the current corner stack point to the left
+            // face (this one will be processed second).
+            corner_traversal_stack_.back() = left_corner_id;
+            // Add a new corner to the top of the stack (right face needs to
+            // be traversed first).
+            corner_traversal_stack_.push_back(right_corner_id);
+            // Break from the while (true) loop.
+            break;
+          }
+        }
+      }
+    }
+    return true;
+  }
+
+ private:
+  std::vector<CornerIndex> corner_traversal_stack_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_TRAVERSER_DEPTH_FIRST_TRAVERSER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/traverser/max_prediction_degree_traverser.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/traverser/max_prediction_degree_traverser.h
new file mode 100644
index 000000000..514193eae
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/traverser/max_prediction_degree_traverser.h
@@ -0,0 +1,226 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_TRAVERSER_MAX_PREDICTION_DEGREE_TRAVERSER_H_
+#define DRACO_COMPRESSION_MESH_TRAVERSER_MAX_PREDICTION_DEGREE_TRAVERSER_H_
+
+#include <vector>
+
+#include "draco/compression/mesh/traverser/traverser_base.h"
+#include "draco/mesh/corner_table.h"
+
+namespace draco {
+
+// PredictionDegreeTraverser provides framework for traversal over a corner
+// table data structure following paper "Multi-way Geometry Encoding" by
+// Cohen-or at al.'02. The traversal is implicitly guided by prediction degree
+// of the destination vertices. A prediction degree is computed as the number of
+// possible faces that can be used as source points for traversal to the given
+// destination vertex (see image below, where faces F1 and F2 are already
+// traversed and face F0 is not traversed yet. The prediction degree of vertex
+// V is then equal to two).
+//
+//            X-----V-----o
+//           / \   / \   / \
+//          / F0\ /   \ / F2\
+//         X-----o-----o-----B
+//                \ F1/
+//                 \ /
+//                  A
+//
+// The class implements the same interface as the DepthFirstTraverser
+// (depth_first_traverser.h) and it can be controlled via the same template
+// trait classes |CornerTableT| and |TraversalObserverT|, that are used
+// for controlling and monitoring of the traversal respectively. For details,
+// please see depth_first_traverser.h.
+template <class CornerTableT, class TraversalObserverT>
+class MaxPredictionDegreeTraverser
+    : public TraverserBase<CornerTable, TraversalObserverT> {
+ public:
+  typedef CornerTableT CornerTable;
+  typedef TraversalObserverT TraversalObserver;
+  typedef TraverserBase<CornerTable, TraversalObserver> Base;
+
+  MaxPredictionDegreeTraverser() {}
+
+  // Called before any traversing starts.
+  void OnTraversalStart() {
+    prediction_degree_.resize(this->corner_table()->num_vertices(), 0);
+  }
+
+  // Called when all the traversing is done.
+  void OnTraversalEnd() {}
+
+  bool TraverseFromCorner(CornerIndex corner_id) {
+    if (prediction_degree_.size() == 0) {
+      return true;
+    }
+
+    // Traversal starts from the |corner_id|. It's going to follow either the
+    // right or the left neighboring faces to |corner_id| based on their
+    // prediction degree.
+    traversal_stacks_[0].push_back(corner_id);
+    best_priority_ = 0;
+    // For the first face, check the remaining corners as they may not be
+    // processed yet.
+    const VertexIndex next_vert =
+        this->corner_table()->Vertex(this->corner_table()->Next(corner_id));
+    const VertexIndex prev_vert =
+        this->corner_table()->Vertex(this->corner_table()->Previous(corner_id));
+    if (!this->IsVertexVisited(next_vert)) {
+      this->MarkVertexVisited(next_vert);
+      this->traversal_observer().OnNewVertexVisited(
+          next_vert, this->corner_table()->Next(corner_id));
+    }
+    if (!this->IsVertexVisited(prev_vert)) {
+      this->MarkVertexVisited(prev_vert);
+      this->traversal_observer().OnNewVertexVisited(
+          prev_vert, this->corner_table()->Previous(corner_id));
+    }
+    const VertexIndex tip_vertex = this->corner_table()->Vertex(corner_id);
+    if (!this->IsVertexVisited(tip_vertex)) {
+      this->MarkVertexVisited(tip_vertex);
+      this->traversal_observer().OnNewVertexVisited(tip_vertex, corner_id);
+    }
+    // Start the actual traversal.
+    while ((corner_id = PopNextCornerToTraverse()) != kInvalidCornerIndex) {
+      FaceIndex face_id(corner_id.value() / 3);
+      // Make sure the face hasn't been visited yet.
+      if (this->IsFaceVisited(face_id)) {
+        // This face has been already traversed.
+        continue;
+      }
+
+      while (true) {
+        face_id = FaceIndex(corner_id.value() / 3);
+        this->MarkFaceVisited(face_id);
+        this->traversal_observer().OnNewFaceVisited(face_id);
+
+        // If the newly reached vertex hasn't been visited, mark it and notify
+        // the observer.
+        const VertexIndex vert_id = this->corner_table()->Vertex(corner_id);
+        if (!this->IsVertexVisited(vert_id)) {
+          this->MarkVertexVisited(vert_id);
+          this->traversal_observer().OnNewVertexVisited(vert_id, corner_id);
+        }
+
+        // Check whether we can traverse to the right and left neighboring
+        // faces.
+        const CornerIndex right_corner_id =
+            this->corner_table()->GetRightCorner(corner_id);
+        const CornerIndex left_corner_id =
+            this->corner_table()->GetLeftCorner(corner_id);
+        const FaceIndex right_face_id(
+            (right_corner_id == kInvalidCornerIndex
+                 ? kInvalidFaceIndex
+                 : FaceIndex(right_corner_id.value() / 3)));
+        const FaceIndex left_face_id(
+            (left_corner_id == kInvalidCornerIndex
+                 ? kInvalidFaceIndex
+                 : FaceIndex(left_corner_id.value() / 3)));
+        const bool is_right_face_visited = this->IsFaceVisited(right_face_id);
+        const bool is_left_face_visited = this->IsFaceVisited(left_face_id);
+
+        if (!is_left_face_visited) {
+          // We can go to the left face.
+          const int priority = ComputePriority(left_corner_id);
+          if (is_right_face_visited && priority <= best_priority_) {
+            // Right face has been already visited and the priority is equal or
+            // better than the best priority. We are sure that the left face
+            // would be traversed next so there is no need to put it onto the
+            // stack.
+            corner_id = left_corner_id;
+            continue;
+          } else {
+            AddCornerToTraversalStack(left_corner_id, priority);
+          }
+        }
+        if (!is_right_face_visited) {
+          // Go to the right face.
+          const int priority = ComputePriority(right_corner_id);
+          if (priority <= best_priority_) {
+            // We are sure that the right face would be traversed next so there
+            // is no need to put it onto the stack.
+            corner_id = right_corner_id;
+            continue;
+          } else {
+            AddCornerToTraversalStack(right_corner_id, priority);
+          }
+        }
+
+        // Couldn't proceed directly to the next corner
+        break;
+      }
+    }
+    return true;
+  }
+
+ private:
+  // Retrieves the next available corner (edge) to traverse. Edges are processed
+  // based on their priorities.
+  // Returns kInvalidCornerIndex when there is no edge available.
+  CornerIndex PopNextCornerToTraverse() {
+    for (int i = best_priority_; i < kMaxPriority; ++i) {
+      if (!traversal_stacks_[i].empty()) {
+        const CornerIndex ret = traversal_stacks_[i].back();
+        traversal_stacks_[i].pop_back();
+        best_priority_ = i;
+        return ret;
+      }
+    }
+    return kInvalidCornerIndex;
+  }
+
+  inline void AddCornerToTraversalStack(CornerIndex ci, int priority) {
+    traversal_stacks_[priority].push_back(ci);
+    // Make sure that the best available priority is up to date.
+    if (priority < best_priority_) {
+      best_priority_ = priority;
+    }
+  }
+
+  // Returns the priority of traversing edge leading to |corner_id|.
+  inline int ComputePriority(CornerIndex corner_id) {
+    const VertexIndex v_tip = this->corner_table()->Vertex(corner_id);
+    // Priority 0 when traversing to already visited vertices.
+    int priority = 0;
+    if (!this->IsVertexVisited(v_tip)) {
+      const int degree = ++prediction_degree_[v_tip];
+      // Priority 1 when prediction degree > 1, otherwise 2.
+      priority = (degree > 1 ? 1 : 2);
+    }
+    // Clamp the priority to the maximum number of buckets.
+    if (priority >= kMaxPriority) {
+      priority = kMaxPriority - 1;
+    }
+    return priority;
+  }
+
+  // For efficiency reasons, the priority traversal is implemented using buckets
+  // where each buckets represent a stack of available corners for a given
+  // priority. Corners with the highest priority are always processed first.
+  static constexpr int kMaxPriority = 3;
+  std::vector<CornerIndex> traversal_stacks_[kMaxPriority];
+
+  // Keep the track of the best available priority to improve the performance
+  // of PopNextCornerToTraverse() method.
+  int best_priority_;
+
+  // Prediction degree available for each vertex.
+  IndexTypeVector<VertexIndex, int> prediction_degree_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_TRAVERSER_MAX_PREDICTION_DEGREE_TRAVERSER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/traverser/mesh_attribute_indices_encoding_observer.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/traverser/mesh_attribute_indices_encoding_observer.h
new file mode 100644
index 000000000..e66dd14b2
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/traverser/mesh_attribute_indices_encoding_observer.h
@@ -0,0 +1,76 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_TRAVERSER_MESH_ATTRIBUTE_INDICES_ENCODING_OBSERVER_H_
+#define DRACO_COMPRESSION_MESH_TRAVERSER_MESH_ATTRIBUTE_INDICES_ENCODING_OBSERVER_H_
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/compression/attributes/points_sequencer.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Class that can be used to generate encoding (and decoding) order of attribute
+// values based on the traversal of the encoded mesh. The class should be used
+// as the TraversalObserverT member of a Traverser class such as the
+// DepthFirstTraverser (depth_first_traverser.h).
+// TODO(hemmer): rename to AttributeIndicesCodingTraverserObserver
+template <class CornerTableT>
+class MeshAttributeIndicesEncodingObserver {
+ public:
+  MeshAttributeIndicesEncodingObserver()
+      : att_connectivity_(nullptr),
+        encoding_data_(nullptr),
+        mesh_(nullptr),
+        sequencer_(nullptr) {}
+  MeshAttributeIndicesEncodingObserver(
+      const CornerTableT *connectivity, const Mesh *mesh,
+      PointsSequencer *sequencer,
+      MeshAttributeIndicesEncodingData *encoding_data)
+      : att_connectivity_(connectivity),
+        encoding_data_(encoding_data),
+        mesh_(mesh),
+        sequencer_(sequencer) {}
+
+  // Interface for TraversalObserverT
+
+  void OnNewFaceVisited(FaceIndex /* face */) {}
+
+  inline void OnNewVertexVisited(VertexIndex vertex, CornerIndex corner) {
+    const PointIndex point_id =
+        mesh_->face(FaceIndex(corner.value() / 3))[corner.value() % 3];
+    // Append the visited attribute to the encoding order.
+    sequencer_->AddPointId(point_id);
+
+    // Keep track of visited corners.
+    encoding_data_->encoded_attribute_value_index_to_corner_map.push_back(
+        corner);
+
+    encoding_data_
+        ->vertex_to_encoded_attribute_value_index_map[vertex.value()] =
+        encoding_data_->num_values;
+
+    encoding_data_->num_values++;
+  }
+
+ private:
+  const CornerTableT *att_connectivity_;
+  MeshAttributeIndicesEncodingData *encoding_data_;
+  const Mesh *mesh_;
+  PointsSequencer *sequencer_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_TRAVERSER_MESH_ATTRIBUTE_INDICES_ENCODING_OBSERVER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/traverser/mesh_traversal_sequencer.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/traverser/mesh_traversal_sequencer.h
new file mode 100644
index 000000000..ebe1d5f7a
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/traverser/mesh_traversal_sequencer.h
@@ -0,0 +1,113 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_TRAVERSER_MESH_TRAVERSAL_SEQUENCER_H_
+#define DRACO_COMPRESSION_MESH_TRAVERSER_MESH_TRAVERSAL_SEQUENCER_H_
+
+#include "draco/attributes/geometry_indices.h"
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/compression/attributes/points_sequencer.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Sequencer that generates point sequence in an order given by a deterministic
+// traversal on the mesh surface. Note that all attributes encoded with this
+// sequence must share the same connectivity.
+// TODO(hemmer): Consider refactoring such that this is an observer.
+template <class TraverserT>
+class MeshTraversalSequencer : public PointsSequencer {
+ public:
+  MeshTraversalSequencer(const Mesh *mesh,
+                         const MeshAttributeIndicesEncodingData *encoding_data)
+      : mesh_(mesh), encoding_data_(encoding_data), corner_order_(nullptr) {}
+  void SetTraverser(const TraverserT &t) { traverser_ = t; }
+
+  // Function that can be used to set an order in which the mesh corners should
+  // be processed. This is an optional flag used usually only by the encoder
+  // to match the same corner order that is going to be used by the decoder.
+  // Note that |corner_order| should contain only one corner per face (it can
+  // have all corners but only the first encountered corner for each face is
+  // going to be used to start a traversal). If the corner order is not set, the
+  // corners are processed sequentially based on their ids.
+  void SetCornerOrder(const std::vector<CornerIndex> &corner_order) {
+    corner_order_ = &corner_order;
+  }
+
+  bool UpdatePointToAttributeIndexMapping(PointAttribute *attribute) override {
+    const auto *corner_table = traverser_.corner_table();
+    attribute->SetExplicitMapping(mesh_->num_points());
+    const size_t num_faces = mesh_->num_faces();
+    const size_t num_points = mesh_->num_points();
+    for (FaceIndex f(0); f < static_cast<uint32_t>(num_faces); ++f) {
+      const auto &face = mesh_->face(f);
+      for (int p = 0; p < 3; ++p) {
+        const PointIndex point_id = face[p];
+        const VertexIndex vert_id =
+            corner_table->Vertex(CornerIndex(3 * f.value() + p));
+        if (vert_id == kInvalidVertexIndex) {
+          return false;
+        }
+        const AttributeValueIndex att_entry_id(
+            encoding_data_
+                ->vertex_to_encoded_attribute_value_index_map[vert_id.value()]);
+        if (point_id >= num_points || att_entry_id.value() >= num_points) {
+          // There cannot be more attribute values than the number of points.
+          return false;
+        }
+        attribute->SetPointMapEntry(point_id, att_entry_id);
+      }
+    }
+    return true;
+  }
+
+ protected:
+  bool GenerateSequenceInternal() override {
+    // Preallocate memory for storing point indices. We expect the number of
+    // points to be the same as the number of corner table vertices.
+    out_point_ids()->reserve(traverser_.corner_table()->num_vertices());
+
+    traverser_.OnTraversalStart();
+    if (corner_order_) {
+      for (uint32_t i = 0; i < corner_order_->size(); ++i) {
+        if (!ProcessCorner(corner_order_->at(i))) {
+          return false;
+        }
+      }
+    } else {
+      const int32_t num_faces = traverser_.corner_table()->num_faces();
+      for (int i = 0; i < num_faces; ++i) {
+        if (!ProcessCorner(CornerIndex(3 * i))) {
+          return false;
+        }
+      }
+    }
+    traverser_.OnTraversalEnd();
+    return true;
+  }
+
+ private:
+  bool ProcessCorner(CornerIndex corner_id) {
+    return traverser_.TraverseFromCorner(corner_id);
+  }
+
+  TraverserT traverser_;
+  const Mesh *mesh_;
+  const MeshAttributeIndicesEncodingData *encoding_data_;
+  const std::vector<CornerIndex> *corner_order_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_TRAVERSER_MESH_TRAVERSAL_SEQUENCER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/traverser/traverser_base.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/traverser/traverser_base.h
new file mode 100644
index 000000000..f2f8da79d
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/mesh/traverser/traverser_base.h
@@ -0,0 +1,87 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_TRAVERSER_TRAVERSER_BASE_H_
+#define DRACO_COMPRESSION_MESH_TRAVERSER_TRAVERSER_BASE_H_
+
+#include "draco/mesh/corner_table.h"
+
+namespace draco {
+
+// Class providing the basic traversal functionality needed by traversers (such
+// as the DepthFirstTraverser, see depth_first_traverser.h). It keeps a pointer
+// to the corner table that is used for the traversal, plus it provides a basic
+// bookkeeping of visited faces and vertices during the traversal.
+template <class CornerTableT, class TraversalObserverT>
+class TraverserBase {
+ public:
+  typedef CornerTableT CornerTable;
+  typedef TraversalObserverT TraversalObserver;
+
+  TraverserBase() : corner_table_(nullptr) {}
+  virtual ~TraverserBase() = default;
+
+  virtual void Init(const CornerTable *corner_table,
+                    TraversalObserver traversal_observer) {
+    corner_table_ = corner_table;
+    is_face_visited_.assign(corner_table->num_faces(), false);
+    is_vertex_visited_.assign(corner_table_->num_vertices(), false);
+    traversal_observer_ = traversal_observer;
+  }
+
+  const CornerTable &GetCornerTable() const { return *corner_table_; }
+
+  inline bool IsFaceVisited(FaceIndex face_id) const {
+    if (face_id == kInvalidFaceIndex) {
+      return true;  // Invalid faces are always considered as visited.
+    }
+    return is_face_visited_[face_id.value()];
+  }
+
+  // Returns true if the face containing the given corner was visited.
+  inline bool IsFaceVisited(CornerIndex corner_id) const {
+    if (corner_id == kInvalidCornerIndex) {
+      return true;  // Invalid faces are always considered as visited.
+    }
+    return is_face_visited_[corner_id.value() / 3];
+  }
+
+  inline void MarkFaceVisited(FaceIndex face_id) {
+    is_face_visited_[face_id.value()] = true;
+  }
+  inline bool IsVertexVisited(VertexIndex vert_id) const {
+    return is_vertex_visited_[vert_id.value()];
+  }
+  inline void MarkVertexVisited(VertexIndex vert_id) {
+    is_vertex_visited_[vert_id.value()] = true;
+  }
+
+  inline const CornerTable *corner_table() const { return corner_table_; }
+  inline const TraversalObserverT &traversal_observer() const {
+    return traversal_observer_;
+  }
+  inline TraversalObserverT &traversal_observer() {
+    return traversal_observer_;
+  }
+
+ private:
+  const CornerTable *corner_table_;
+  TraversalObserverT traversal_observer_;
+  std::vector<bool> is_face_visited_;
+  std::vector<bool> is_vertex_visited_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_TRAVERSER_TRAVERSER_BASE_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_decoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_decoder.cc
new file mode 100644
index 000000000..de46f05af
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_decoder.cc
@@ -0,0 +1,26 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_decoder.h"
+
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+
+namespace draco {
+
+template class DynamicIntegerPointsKdTreeDecoder<0>;
+template class DynamicIntegerPointsKdTreeDecoder<2>;
+template class DynamicIntegerPointsKdTreeDecoder<4>;
+template class DynamicIntegerPointsKdTreeDecoder<6>;
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_decoder.h
new file mode 100644
index 000000000..87bc2b7ef
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_decoder.h
@@ -0,0 +1,330 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// See dynamic_integer_points_kd_tree_encoder.h for documentation.
+
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_DYNAMIC_INTEGER_POINTS_KD_TREE_DECODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_DYNAMIC_INTEGER_POINTS_KD_TREE_DECODER_H_
+
+#include <array>
+#include <memory>
+#include <stack>
+
+#include "draco/compression/bit_coders/adaptive_rans_bit_decoder.h"
+#include "draco/compression/bit_coders/direct_bit_decoder.h"
+#include "draco/compression/bit_coders/folded_integer_bit_decoder.h"
+#include "draco/compression/bit_coders/rans_bit_decoder.h"
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+#include "draco/core/bit_utils.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/math_utils.h"
+
+namespace draco {
+
+template <int compression_level_t>
+struct DynamicIntegerPointsKdTreeDecoderCompressionPolicy
+    : public DynamicIntegerPointsKdTreeDecoderCompressionPolicy<
+          compression_level_t - 1> {};
+
+template <>
+struct DynamicIntegerPointsKdTreeDecoderCompressionPolicy<0> {
+  typedef DirectBitDecoder NumbersDecoder;
+  typedef DirectBitDecoder AxisDecoder;
+  typedef DirectBitDecoder HalfDecoder;
+  typedef DirectBitDecoder RemainingBitsDecoder;
+  static constexpr bool select_axis = false;
+};
+
+template <>
+struct DynamicIntegerPointsKdTreeDecoderCompressionPolicy<2>
+    : public DynamicIntegerPointsKdTreeDecoderCompressionPolicy<1> {
+  typedef RAnsBitDecoder NumbersDecoder;
+};
+
+template <>
+struct DynamicIntegerPointsKdTreeDecoderCompressionPolicy<4>
+    : public DynamicIntegerPointsKdTreeDecoderCompressionPolicy<3> {
+  typedef FoldedBit32Decoder<RAnsBitDecoder> NumbersDecoder;
+};
+
+template <>
+struct DynamicIntegerPointsKdTreeDecoderCompressionPolicy<6>
+    : public DynamicIntegerPointsKdTreeDecoderCompressionPolicy<5> {
+  static constexpr bool select_axis = true;
+};
+
+// Decodes a point cloud encoded by DynamicIntegerPointsKdTreeEncoder.
+template <int compression_level_t>
+class DynamicIntegerPointsKdTreeDecoder {
+  static_assert(compression_level_t >= 0, "Compression level must in [0..6].");
+  static_assert(compression_level_t <= 6, "Compression level must in [0..6].");
+  typedef DynamicIntegerPointsKdTreeDecoderCompressionPolicy<
+      compression_level_t>
+      Policy;
+
+  typedef typename Policy::NumbersDecoder NumbersDecoder;
+  typedef typename Policy::AxisDecoder AxisDecoder;
+  typedef typename Policy::HalfDecoder HalfDecoder;
+  typedef typename Policy::RemainingBitsDecoder RemainingBitsDecoder;
+  typedef std::vector<uint32_t> VectorUint32;
+
+ public:
+  explicit DynamicIntegerPointsKdTreeDecoder(uint32_t dimension)
+      : bit_length_(0),
+        num_points_(0),
+        num_decoded_points_(0),
+        dimension_(dimension),
+        p_(dimension, 0),
+        axes_(dimension, 0),
+        // Init the stack with the maximum depth of the tree.
+        // +1 for a second leaf.
+        base_stack_(32 * dimension + 1, VectorUint32(dimension, 0)),
+        levels_stack_(32 * dimension + 1, VectorUint32(dimension, 0)) {}
+
+  // Decodes a integer point cloud from |buffer|.
+  template <class OutputIteratorT>
+  bool DecodePoints(DecoderBuffer *buffer, OutputIteratorT &oit);
+
+#ifndef DRACO_OLD_GCC
+  template <class OutputIteratorT>
+  bool DecodePoints(DecoderBuffer *buffer, OutputIteratorT &&oit);
+#endif  // DRACO_OLD_GCC
+
+  const uint32_t dimension() const { return dimension_; }
+
+ private:
+  uint32_t GetAxis(uint32_t num_remaining_points, const VectorUint32 &levels,
+                   uint32_t last_axis);
+
+  template <class OutputIteratorT>
+  bool DecodeInternal(uint32_t num_points, OutputIteratorT &oit);
+
+  void DecodeNumber(int nbits, uint32_t *value) {
+    numbers_decoder_.DecodeLeastSignificantBits32(nbits, value);
+  }
+
+  struct DecodingStatus {
+    DecodingStatus(uint32_t num_remaining_points_, uint32_t last_axis_,
+                   uint32_t stack_pos_)
+        : num_remaining_points(num_remaining_points_),
+          last_axis(last_axis_),
+          stack_pos(stack_pos_) {}
+
+    uint32_t num_remaining_points;
+    uint32_t last_axis;
+    uint32_t stack_pos;  // used to get base and levels
+  };
+
+  uint32_t bit_length_;
+  uint32_t num_points_;
+  uint32_t num_decoded_points_;
+  uint32_t dimension_;
+  NumbersDecoder numbers_decoder_;
+  RemainingBitsDecoder remaining_bits_decoder_;
+  AxisDecoder axis_decoder_;
+  HalfDecoder half_decoder_;
+  VectorUint32 p_;
+  VectorUint32 axes_;
+  std::vector<VectorUint32> base_stack_;
+  std::vector<VectorUint32> levels_stack_;
+};
+
+// Decodes a point cloud from |buffer|.
+#ifndef DRACO_OLD_GCC
+template <int compression_level_t>
+template <class OutputIteratorT>
+bool DynamicIntegerPointsKdTreeDecoder<compression_level_t>::DecodePoints(
+    DecoderBuffer *buffer, OutputIteratorT &&oit) {
+  OutputIteratorT local = std::forward<OutputIteratorT>(oit);
+  return DecodePoints(buffer, local);
+}
+#endif  // DRACO_OLD_GCC
+
+template <int compression_level_t>
+template <class OutputIteratorT>
+bool DynamicIntegerPointsKdTreeDecoder<compression_level_t>::DecodePoints(
+    DecoderBuffer *buffer, OutputIteratorT &oit) {
+  if (!buffer->Decode(&bit_length_)) {
+    return false;
+  }
+  if (bit_length_ > 32) {
+    return false;
+  }
+  if (!buffer->Decode(&num_points_)) {
+    return false;
+  }
+  if (num_points_ == 0) {
+    return true;
+  }
+  num_decoded_points_ = 0;
+
+  if (!numbers_decoder_.StartDecoding(buffer)) {
+    return false;
+  }
+  if (!remaining_bits_decoder_.StartDecoding(buffer)) {
+    return false;
+  }
+  if (!axis_decoder_.StartDecoding(buffer)) {
+    return false;
+  }
+  if (!half_decoder_.StartDecoding(buffer)) {
+    return false;
+  }
+
+  if (!DecodeInternal(num_points_, oit)) {
+    return false;
+  }
+
+  numbers_decoder_.EndDecoding();
+  remaining_bits_decoder_.EndDecoding();
+  axis_decoder_.EndDecoding();
+  half_decoder_.EndDecoding();
+
+  return true;
+}
+
+template <int compression_level_t>
+uint32_t DynamicIntegerPointsKdTreeDecoder<compression_level_t>::GetAxis(
+    uint32_t num_remaining_points, const VectorUint32 &levels,
+    uint32_t last_axis) {
+  if (!Policy::select_axis) {
+    return DRACO_INCREMENT_MOD(last_axis, dimension_);
+  }
+
+  uint32_t best_axis = 0;
+  if (num_remaining_points < 64) {
+    for (uint32_t axis = 1; axis < dimension_; ++axis) {
+      if (levels[best_axis] > levels[axis]) {
+        best_axis = axis;
+      }
+    }
+  } else {
+    axis_decoder_.DecodeLeastSignificantBits32(4, &best_axis);
+  }
+
+  return best_axis;
+}
+
+template <int compression_level_t>
+template <class OutputIteratorT>
+bool DynamicIntegerPointsKdTreeDecoder<compression_level_t>::DecodeInternal(
+    uint32_t num_points, OutputIteratorT &oit) {
+  typedef DecodingStatus Status;
+  base_stack_[0] = VectorUint32(dimension_, 0);
+  levels_stack_[0] = VectorUint32(dimension_, 0);
+  DecodingStatus init_status(num_points, 0, 0);
+  std::stack<Status> status_stack;
+  status_stack.push(init_status);
+
+  // TODO(hemmer): use preallocated vector instead of stack.
+  while (!status_stack.empty()) {
+    const DecodingStatus status = status_stack.top();
+    status_stack.pop();
+
+    const uint32_t num_remaining_points = status.num_remaining_points;
+    const uint32_t last_axis = status.last_axis;
+    const uint32_t stack_pos = status.stack_pos;
+    const VectorUint32 &old_base = base_stack_[stack_pos];
+    const VectorUint32 &levels = levels_stack_[stack_pos];
+
+    if (num_remaining_points > num_points) {
+      return false;
+    }
+
+    const uint32_t axis = GetAxis(num_remaining_points, levels, last_axis);
+    if (axis >= dimension_) {
+      return false;
+    }
+
+    const uint32_t level = levels[axis];
+
+    // All axes have been fully subdivided, just output points.
+    if ((bit_length_ - level) == 0) {
+      for (uint32_t i = 0; i < num_remaining_points; i++) {
+        *oit = old_base;
+        ++oit;
+        ++num_decoded_points_;
+      }
+      continue;
+    }
+
+    DRACO_DCHECK_EQ(true, num_remaining_points != 0);
+
+    // Fast decoding of remaining bits if number of points is 1 or 2.
+    if (num_remaining_points <= 2) {
+      // TODO(hemmer): axes_ not necessary, remove would change bitstream!
+      axes_[0] = axis;
+      for (uint32_t i = 1; i < dimension_; i++) {
+        axes_[i] = DRACO_INCREMENT_MOD(axes_[i - 1], dimension_);
+      }
+      for (uint32_t i = 0; i < num_remaining_points; ++i) {
+        for (uint32_t j = 0; j < dimension_; j++) {
+          p_[axes_[j]] = 0;
+          const uint32_t num_remaining_bits = bit_length_ - levels[axes_[j]];
+          if (num_remaining_bits) {
+            remaining_bits_decoder_.DecodeLeastSignificantBits32(
+                num_remaining_bits, &p_[axes_[j]]);
+          }
+          p_[axes_[j]] = old_base[axes_[j]] | p_[axes_[j]];
+        }
+        *oit = p_;
+        ++oit;
+        ++num_decoded_points_;
+      }
+      continue;
+    }
+
+    if (num_decoded_points_ > num_points_) {
+      return false;
+    }
+
+    const int num_remaining_bits = bit_length_ - level;
+    const uint32_t modifier = 1 << (num_remaining_bits - 1);
+    base_stack_[stack_pos + 1] = old_base;         // copy
+    base_stack_[stack_pos + 1][axis] += modifier;  // new base
+
+    const int incoming_bits = MostSignificantBit(num_remaining_points);
+
+    uint32_t number = 0;
+    DecodeNumber(incoming_bits, &number);
+
+    uint32_t first_half = num_remaining_points / 2 - number;
+    uint32_t second_half = num_remaining_points - first_half;
+
+    if (first_half != second_half) {
+      if (!half_decoder_.DecodeNextBit()) {
+        std::swap(first_half, second_half);
+      }
+    }
+
+    levels_stack_[stack_pos][axis] += 1;
+    levels_stack_[stack_pos + 1] = levels_stack_[stack_pos];  // copy
+    if (first_half) {
+      status_stack.push(DecodingStatus(first_half, axis, stack_pos));
+    }
+    if (second_half) {
+      status_stack.push(DecodingStatus(second_half, axis, stack_pos + 1));
+    }
+  }
+  return true;
+}
+
+extern template class DynamicIntegerPointsKdTreeDecoder<0>;
+extern template class DynamicIntegerPointsKdTreeDecoder<2>;
+extern template class DynamicIntegerPointsKdTreeDecoder<4>;
+extern template class DynamicIntegerPointsKdTreeDecoder<6>;
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_DYNAMIC_INTEGER_POINTS_KD_TREE_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_encoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_encoder.cc
new file mode 100644
index 000000000..e7abf52c4
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_encoder.cc
@@ -0,0 +1,26 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_encoder.h"
+
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+
+namespace draco {
+
+template class DynamicIntegerPointsKdTreeEncoder<0>;
+template class DynamicIntegerPointsKdTreeEncoder<2>;
+template class DynamicIntegerPointsKdTreeEncoder<4>;
+template class DynamicIntegerPointsKdTreeEncoder<6>;
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_encoder.h
new file mode 100644
index 000000000..14fa32d70
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_encoder.h
@@ -0,0 +1,371 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_DYNAMIC_INTEGER_POINTS_KD_TREE_ENCODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_DYNAMIC_INTEGER_POINTS_KD_TREE_ENCODER_H_
+
+#include <algorithm>
+#include <array>
+#include <memory>
+#include <stack>
+#include <vector>
+
+#include "draco/compression/bit_coders/adaptive_rans_bit_encoder.h"
+#include "draco/compression/bit_coders/direct_bit_encoder.h"
+#include "draco/compression/bit_coders/folded_integer_bit_encoder.h"
+#include "draco/compression/bit_coders/rans_bit_encoder.h"
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+#include "draco/core/bit_utils.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/math_utils.h"
+
+namespace draco {
+
+// This policy class provides several configurations for the encoder that allow
+// to trade speed vs compression rate. Level 0 is fastest while 6 is the best
+// compression rate. The decoder must select the same level.
+template <int compression_level_t>
+struct DynamicIntegerPointsKdTreeEncoderCompressionPolicy
+    : public DynamicIntegerPointsKdTreeEncoderCompressionPolicy<
+          compression_level_t - 1> {};
+
+template <>
+struct DynamicIntegerPointsKdTreeEncoderCompressionPolicy<0> {
+  typedef DirectBitEncoder NumbersEncoder;
+  typedef DirectBitEncoder AxisEncoder;
+  typedef DirectBitEncoder HalfEncoder;
+  typedef DirectBitEncoder RemainingBitsEncoder;
+  static constexpr bool select_axis = false;
+};
+
+template <>
+struct DynamicIntegerPointsKdTreeEncoderCompressionPolicy<2>
+    : public DynamicIntegerPointsKdTreeEncoderCompressionPolicy<1> {
+  typedef RAnsBitEncoder NumbersEncoder;
+};
+
+template <>
+struct DynamicIntegerPointsKdTreeEncoderCompressionPolicy<4>
+    : public DynamicIntegerPointsKdTreeEncoderCompressionPolicy<3> {
+  typedef FoldedBit32Encoder<RAnsBitEncoder> NumbersEncoder;
+};
+
+template <>
+struct DynamicIntegerPointsKdTreeEncoderCompressionPolicy<6>
+    : public DynamicIntegerPointsKdTreeEncoderCompressionPolicy<5> {
+  static constexpr bool select_axis = true;
+};
+
+// This class encodes a given integer point cloud based on the point cloud
+// compression algorithm in:
+// Olivier Devillers and Pierre-Marie Gandoin
+// "Geometric compression for interactive transmission"
+//
+// In principle the algorithm keeps on splitting the point cloud in the middle
+// while alternating the axes. In 3D this results in an Octree like structure.
+// In each step we encode the number of points in the first half.
+// The algorithm does not preserve the order of points.
+//
+// However, the algorithm here differs from the original as follows:
+// The algorithm keeps on splitting the point cloud in the middle of the axis
+// that keeps the point cloud as clustered as possible, which gives a better
+// compression rate.
+// The number of points is encode by the deviation from the half of the points
+// in the smaller half of the two. This results in a better compression rate as
+// there are more leading zeros, which is then compressed better by the
+// arithmetic encoding.
+template <int compression_level_t>
+class DynamicIntegerPointsKdTreeEncoder {
+  static_assert(compression_level_t >= 0, "Compression level must in [0..6].");
+  static_assert(compression_level_t <= 6, "Compression level must in [0..6].");
+  typedef DynamicIntegerPointsKdTreeEncoderCompressionPolicy<
+      compression_level_t>
+      Policy;
+  typedef typename Policy::NumbersEncoder NumbersEncoder;
+  typedef typename Policy::AxisEncoder AxisEncoder;
+  typedef typename Policy::HalfEncoder HalfEncoder;
+  typedef typename Policy::RemainingBitsEncoder RemainingBitsEncoder;
+  typedef std::vector<uint32_t> VectorUint32;
+
+ public:
+  explicit DynamicIntegerPointsKdTreeEncoder(uint32_t dimension)
+      : bit_length_(0),
+        dimension_(dimension),
+        deviations_(dimension, 0),
+        num_remaining_bits_(dimension, 0),
+        axes_(dimension, 0),
+        base_stack_(32 * dimension + 1, VectorUint32(dimension, 0)),
+        levels_stack_(32 * dimension + 1, VectorUint32(dimension, 0)) {}
+
+  // Encodes an integer point cloud given by [begin,end) into buffer.
+  // |bit_length| gives the highest bit used for all coordinates.
+  template <class RandomAccessIteratorT>
+  bool EncodePoints(RandomAccessIteratorT begin, RandomAccessIteratorT end,
+                    const uint32_t &bit_length, EncoderBuffer *buffer);
+
+  // Encodes an integer point cloud given by [begin,end) into buffer.
+  template <class RandomAccessIteratorT>
+  bool EncodePoints(RandomAccessIteratorT begin, RandomAccessIteratorT end,
+                    EncoderBuffer *buffer) {
+    return EncodePoints(begin, end, 32, buffer);
+  }
+
+  const uint32_t dimension() const { return dimension_; }
+
+ private:
+  template <class RandomAccessIteratorT>
+  uint32_t GetAndEncodeAxis(RandomAccessIteratorT begin,
+                            RandomAccessIteratorT end,
+                            const VectorUint32 &old_base,
+                            const VectorUint32 &levels, uint32_t last_axis);
+  template <class RandomAccessIteratorT>
+  void EncodeInternal(RandomAccessIteratorT begin, RandomAccessIteratorT end);
+
+  class Splitter {
+   public:
+    Splitter(uint32_t axis, uint32_t value) : axis_(axis), value_(value) {}
+    template <class PointT>
+    bool operator()(const PointT &a) const {
+      return a[axis_] < value_;
+    }
+
+   private:
+    const uint32_t axis_;
+    const uint32_t value_;
+  };
+
+  void EncodeNumber(int nbits, uint32_t value) {
+    numbers_encoder_.EncodeLeastSignificantBits32(nbits, value);
+  }
+
+  template <class RandomAccessIteratorT>
+  struct EncodingStatus {
+    EncodingStatus(RandomAccessIteratorT begin_, RandomAccessIteratorT end_,
+                   uint32_t last_axis_, uint32_t stack_pos_)
+        : begin(begin_),
+          end(end_),
+          last_axis(last_axis_),
+          stack_pos(stack_pos_) {
+      num_remaining_points = static_cast<uint32_t>(end - begin);
+    }
+
+    RandomAccessIteratorT begin;
+    RandomAccessIteratorT end;
+    uint32_t last_axis;
+    uint32_t num_remaining_points;
+    uint32_t stack_pos;  // used to get base and levels
+  };
+
+  uint32_t bit_length_;
+  uint32_t num_points_;
+  uint32_t dimension_;
+  NumbersEncoder numbers_encoder_;
+  RemainingBitsEncoder remaining_bits_encoder_;
+  AxisEncoder axis_encoder_;
+  HalfEncoder half_encoder_;
+  VectorUint32 deviations_;
+  VectorUint32 num_remaining_bits_;
+  VectorUint32 axes_;
+  std::vector<VectorUint32> base_stack_;
+  std::vector<VectorUint32> levels_stack_;
+};
+
+template <int compression_level_t>
+template <class RandomAccessIteratorT>
+bool DynamicIntegerPointsKdTreeEncoder<compression_level_t>::EncodePoints(
+    RandomAccessIteratorT begin, RandomAccessIteratorT end,
+    const uint32_t &bit_length, EncoderBuffer *buffer) {
+  bit_length_ = bit_length;
+  num_points_ = static_cast<uint32_t>(end - begin);
+
+  buffer->Encode(bit_length_);
+  buffer->Encode(num_points_);
+  if (num_points_ == 0) {
+    return true;
+  }
+
+  numbers_encoder_.StartEncoding();
+  remaining_bits_encoder_.StartEncoding();
+  axis_encoder_.StartEncoding();
+  half_encoder_.StartEncoding();
+
+  EncodeInternal(begin, end);
+
+  numbers_encoder_.EndEncoding(buffer);
+  remaining_bits_encoder_.EndEncoding(buffer);
+  axis_encoder_.EndEncoding(buffer);
+  half_encoder_.EndEncoding(buffer);
+
+  return true;
+}
+template <int compression_level_t>
+template <class RandomAccessIteratorT>
+uint32_t
+DynamicIntegerPointsKdTreeEncoder<compression_level_t>::GetAndEncodeAxis(
+    RandomAccessIteratorT begin, RandomAccessIteratorT end,
+    const VectorUint32 &old_base, const VectorUint32 &levels,
+    uint32_t last_axis) {
+  if (!Policy::select_axis) {
+    return DRACO_INCREMENT_MOD(last_axis, dimension_);
+  }
+
+  // For many points this function selects the axis that should be used
+  // for the split by keeping as many points as possible bundled.
+  // In the best case we do not split the point cloud at all.
+  // For lower number of points, we simply choose the axis that is refined the
+  // least so far.
+
+  DRACO_DCHECK_EQ(true, end - begin != 0);
+
+  uint32_t best_axis = 0;
+  if (end - begin < 64) {
+    for (uint32_t axis = 1; axis < dimension_; ++axis) {
+      if (levels[best_axis] > levels[axis]) {
+        best_axis = axis;
+      }
+    }
+  } else {
+    const uint32_t size = static_cast<uint32_t>(end - begin);
+    for (uint32_t i = 0; i < dimension_; i++) {
+      deviations_[i] = 0;
+      num_remaining_bits_[i] = bit_length_ - levels[i];
+      if (num_remaining_bits_[i] > 0) {
+        const uint32_t split =
+            old_base[i] + (1 << (num_remaining_bits_[i] - 1));
+        for (auto it = begin; it != end; ++it) {
+          deviations_[i] += ((*it)[i] < split);
+        }
+        deviations_[i] = std::max(size - deviations_[i], deviations_[i]);
+      }
+    }
+
+    uint32_t max_value = 0;
+    best_axis = 0;
+    for (uint32_t i = 0; i < dimension_; i++) {
+      // If axis can be subdivided.
+      if (num_remaining_bits_[i]) {
+        // Check if this is the better axis.
+        if (max_value < deviations_[i]) {
+          max_value = deviations_[i];
+          best_axis = i;
+        }
+      }
+    }
+    axis_encoder_.EncodeLeastSignificantBits32(4, best_axis);
+  }
+
+  return best_axis;
+}
+
+template <int compression_level_t>
+template <class RandomAccessIteratorT>
+void DynamicIntegerPointsKdTreeEncoder<compression_level_t>::EncodeInternal(
+    RandomAccessIteratorT begin, RandomAccessIteratorT end) {
+  typedef EncodingStatus<RandomAccessIteratorT> Status;
+
+  base_stack_[0] = VectorUint32(dimension_, 0);
+  levels_stack_[0] = VectorUint32(dimension_, 0);
+  Status init_status(begin, end, 0, 0);
+  std::stack<Status> status_stack;
+  status_stack.push(init_status);
+
+  // TODO(hemmer): use preallocated vector instead of stack.
+  while (!status_stack.empty()) {
+    Status status = status_stack.top();
+    status_stack.pop();
+
+    begin = status.begin;
+    end = status.end;
+    const uint32_t last_axis = status.last_axis;
+    const uint32_t stack_pos = status.stack_pos;
+    const VectorUint32 &old_base = base_stack_[stack_pos];
+    const VectorUint32 &levels = levels_stack_[stack_pos];
+
+    const uint32_t axis =
+        GetAndEncodeAxis(begin, end, old_base, levels, last_axis);
+    const uint32_t level = levels[axis];
+    const uint32_t num_remaining_points = static_cast<uint32_t>(end - begin);
+
+    // If this happens all axis are subdivided to the end.
+    if ((bit_length_ - level) == 0) {
+      continue;
+    }
+
+    // Fast encoding of remaining bits if number of points is 1 or 2.
+    // Doing this also for 2 gives a slight additional speed up.
+    if (num_remaining_points <= 2) {
+      // TODO(hemmer): axes_ not necessary, remove would change bitstream!
+      axes_[0] = axis;
+      for (uint32_t i = 1; i < dimension_; i++) {
+        axes_[i] = DRACO_INCREMENT_MOD(axes_[i - 1], dimension_);
+      }
+      for (uint32_t i = 0; i < num_remaining_points; ++i) {
+        const auto &p = *(begin + i);
+        for (uint32_t j = 0; j < dimension_; j++) {
+          const uint32_t num_remaining_bits = bit_length_ - levels[axes_[j]];
+          if (num_remaining_bits) {
+            remaining_bits_encoder_.EncodeLeastSignificantBits32(
+                num_remaining_bits, p[axes_[j]]);
+          }
+        }
+      }
+      continue;
+    }
+
+    const uint32_t num_remaining_bits = bit_length_ - level;
+    const uint32_t modifier = 1 << (num_remaining_bits - 1);
+    base_stack_[stack_pos + 1] = old_base;  // copy
+    base_stack_[stack_pos + 1][axis] += modifier;
+    const VectorUint32 &new_base = base_stack_[stack_pos + 1];
+
+    const RandomAccessIteratorT split =
+        std::partition(begin, end, Splitter(axis, new_base[axis]));
+
+    DRACO_DCHECK_EQ(true, (end - begin) > 0);
+
+    // Encode number of points in first and second half.
+    const int required_bits = MostSignificantBit(num_remaining_points);
+
+    const uint32_t first_half = static_cast<uint32_t>(split - begin);
+    const uint32_t second_half = static_cast<uint32_t>(end - split);
+    const bool left = first_half < second_half;
+
+    if (first_half != second_half) {
+      half_encoder_.EncodeBit(left);
+    }
+
+    if (left) {
+      EncodeNumber(required_bits, num_remaining_points / 2 - first_half);
+    } else {
+      EncodeNumber(required_bits, num_remaining_points / 2 - second_half);
+    }
+
+    levels_stack_[stack_pos][axis] += 1;
+    levels_stack_[stack_pos + 1] = levels_stack_[stack_pos];  // copy
+    if (split != begin) {
+      status_stack.push(Status(begin, split, axis, stack_pos));
+    }
+    if (split != end) {
+      status_stack.push(Status(split, end, axis, stack_pos + 1));
+    }
+  }
+}
+extern template class DynamicIntegerPointsKdTreeEncoder<0>;
+extern template class DynamicIntegerPointsKdTreeEncoder<2>;
+extern template class DynamicIntegerPointsKdTreeEncoder<4>;
+extern template class DynamicIntegerPointsKdTreeEncoder<6>;
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_DYNAMIC_INTEGER_POINTS_KD_TREE_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_decoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_decoder.cc
new file mode 100644
index 000000000..dffaa4c8d
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_decoder.cc
@@ -0,0 +1,152 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/point_cloud/algorithms/float_points_tree_decoder.h"
+
+#include <algorithm>
+
+#include "draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_decoder.h"
+#include "draco/compression/point_cloud/algorithms/quantize_points_3.h"
+#include "draco/core/math_utils.h"
+#include "draco/core/quantization_utils.h"
+
+namespace draco {
+
+struct Converter {
+  typedef std::vector<uint32_t> SourceType;
+  typedef Point3ui TargetType;
+  Point3ui operator()(const std::vector<uint32_t> &v) {
+    return Point3ui(v[0], v[1], v[2]);
+  }
+};
+
+// Output iterator that is used to decode values directly into the data buffer
+// of the modified PointAttribute.
+template <class OutputIterator, class Converter>
+class ConversionOutputIterator {
+  typedef ConversionOutputIterator<OutputIterator, Converter> Self;
+  typedef typename Converter::SourceType SourceType;
+  typedef typename Converter::TargetType TargetType;
+
+ public:
+  explicit ConversionOutputIterator(OutputIterator oit) : oit_(oit) {}
+
+  const Self &operator++() {
+    ++oit_;
+    return *this;
+  }
+  Self operator++(int) {
+    Self copy = *this;
+    ++oit_;
+    return copy;
+  }
+  Self &operator*() { return *this; }
+  const Self &operator=(const SourceType &source) {
+    *oit_ = Converter()(source);
+    return *this;
+  }
+
+ private:
+  OutputIterator oit_;
+};
+
+FloatPointsTreeDecoder::FloatPointsTreeDecoder()
+    : num_points_(0), compression_level_(0), num_points_from_header_(0) {
+  qinfo_.quantization_bits = 0;
+  qinfo_.range = 0;
+}
+
+bool FloatPointsTreeDecoder::DecodePointCloudKdTreeInternal(
+    DecoderBuffer *buffer, std::vector<Point3ui> *qpoints) {
+  if (!buffer->Decode(&qinfo_.quantization_bits)) {
+    return false;
+  }
+  if (qinfo_.quantization_bits > 31) {
+    return false;
+  }
+  if (!buffer->Decode(&qinfo_.range)) {
+    return false;
+  }
+  if (!buffer->Decode(&num_points_)) {
+    return false;
+  }
+  if (num_points_from_header_ > 0 && num_points_ != num_points_from_header_) {
+    return false;
+  }
+  if (!buffer->Decode(&compression_level_)) {
+    return false;
+  }
+
+  // Only allow compression level in [0..6].
+  if (6 < compression_level_) {
+    DRACO_LOGE("FloatPointsTreeDecoder: compression level %i not supported.\n",
+               compression_level_);
+    return false;
+  }
+
+  std::back_insert_iterator<std::vector<Point3ui>> oit_qpoints =
+      std::back_inserter(*qpoints);
+  ConversionOutputIterator<std::back_insert_iterator<std::vector<Point3ui>>,
+                           Converter>
+      oit(oit_qpoints);
+  if (num_points_ > 0) {
+    qpoints->reserve(num_points_);
+    switch (compression_level_) {
+      case 0: {
+        DynamicIntegerPointsKdTreeDecoder<0> qpoints_decoder(3);
+        qpoints_decoder.DecodePoints(buffer, oit);
+        break;
+      }
+      case 1: {
+        DynamicIntegerPointsKdTreeDecoder<1> qpoints_decoder(3);
+        qpoints_decoder.DecodePoints(buffer, oit);
+        break;
+      }
+      case 2: {
+        DynamicIntegerPointsKdTreeDecoder<2> qpoints_decoder(3);
+        qpoints_decoder.DecodePoints(buffer, oit);
+        break;
+      }
+      case 3: {
+        DynamicIntegerPointsKdTreeDecoder<3> qpoints_decoder(3);
+        qpoints_decoder.DecodePoints(buffer, oit);
+        break;
+      }
+      case 4: {
+        DynamicIntegerPointsKdTreeDecoder<4> qpoints_decoder(3);
+        qpoints_decoder.DecodePoints(buffer, oit);
+        break;
+      }
+      case 5: {
+        DynamicIntegerPointsKdTreeDecoder<5> qpoints_decoder(3);
+        qpoints_decoder.DecodePoints(buffer, oit);
+        break;
+      }
+      case 6: {
+        DynamicIntegerPointsKdTreeDecoder<6> qpoints_decoder(3);
+        qpoints_decoder.DecodePoints(buffer, oit);
+        break;
+      }
+      default:
+        return false;
+    }
+  }
+
+  if (qpoints->size() != num_points_) {
+    return false;
+  }
+  return true;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_decoder.h
new file mode 100644
index 000000000..4f09ed2c3
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_decoder.h
@@ -0,0 +1,141 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_FLOAT_POINTS_TREE_DECODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_FLOAT_POINTS_TREE_DECODER_H_
+
+#include <memory>
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/point_cloud/algorithms/point_cloud_compression_method.h"
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+#include "draco/compression/point_cloud/algorithms/quantize_points_3.h"
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+
+// Decodes a point cloud encoded by PointCloudTreeEncoder.
+class FloatPointsTreeDecoder {
+ public:
+  FloatPointsTreeDecoder();
+
+  // Decodes a point cloud from |buffer|.
+  template <class OutputIteratorT>
+  bool DecodePointCloud(DecoderBuffer *buffer, OutputIteratorT &out);
+
+#ifndef DRACO_OLD_GCC
+  template <class OutputIteratorT>
+  bool DecodePointCloud(DecoderBuffer *buffer, OutputIteratorT &&out);
+#endif  // DRACO_OLD_GCC
+
+  // Initializes a DecoderBuffer from |data|, and calls function above.
+  template <class OutputIteratorT>
+  bool DecodePointCloud(const char *data, size_t data_size,
+                        OutputIteratorT out) {
+    if (data == 0 || data_size <= 0) {
+      return false;
+    }
+
+    DecoderBuffer buffer;
+    buffer.Init(data, data_size);
+    buffer.set_bitstream_version(kDracoPointCloudBitstreamVersion);
+    return DecodePointCloud(&buffer, out);
+  }
+
+  uint32_t quantization_bits() const { return qinfo_.quantization_bits; }
+  uint32_t compression_level() const { return compression_level_; }
+  float range() const { return qinfo_.range; }
+  uint32_t num_points() const { return num_points_; }
+  uint32_t version() const { return version_; }
+  std::string identification_string() const {
+    if (method_ == KDTREE) {
+      return "FloatPointsTreeDecoder: IntegerPointsKDTreeDecoder";
+    } else {
+      return "FloatPointsTreeDecoder: Unsupported Method";
+    }
+  }
+
+  void set_num_points_from_header(uint32_t num_points) {
+    num_points_from_header_ = num_points;
+  }
+
+ private:
+  bool DecodePointCloudKdTreeInternal(DecoderBuffer *buffer,
+                                      std::vector<Point3ui> *qpoints);
+
+  static const uint32_t version_ = 3;
+  QuantizationInfo qinfo_;
+  PointCloudCompressionMethod method_;
+  uint32_t num_points_;
+  uint32_t compression_level_;
+
+  // Member variable to check if the number of points from the file header
+  // matches the number of points in the compression header. If
+  // |num_points_from_header_| is 0, do not perform the check. Defaults to 0.
+  uint32_t num_points_from_header_;
+};
+
+#ifndef DRACO_OLD_GCC
+// TODO(vytyaz): Reenable once USD migrates from GCC 4.8 to a higher version
+// that can disambiguate calls to overloaded methods taking rvalue reference.
+template <class OutputIteratorT>
+bool FloatPointsTreeDecoder::DecodePointCloud(DecoderBuffer *buffer,
+                                              OutputIteratorT &&out) {
+  OutputIteratorT local = std::forward<OutputIteratorT>(out);
+  return DecodePointCloud(buffer, local);
+}
+#endif  // DRACO_OLD_GCC
+
+template <class OutputIteratorT>
+bool FloatPointsTreeDecoder::DecodePointCloud(DecoderBuffer *buffer,
+                                              OutputIteratorT &out) {
+  std::vector<Point3ui> qpoints;
+
+  uint32_t decoded_version;
+  if (!buffer->Decode(&decoded_version)) {
+    return false;
+  }
+
+  if (decoded_version == 3) {
+    int8_t method_number;
+    if (!buffer->Decode(&method_number)) {
+      return false;
+    }
+
+    method_ = static_cast<PointCloudCompressionMethod>(method_number);
+
+    if (method_ == KDTREE) {
+      if (!DecodePointCloudKdTreeInternal(buffer, &qpoints)) {
+        return false;
+      }
+    } else {  // Unsupported method.
+      fprintf(stderr, "Method not supported. \n");
+      return false;
+    }
+  } else if (decoded_version == 2) {  // Version 2 only uses KDTREE method.
+    if (!DecodePointCloudKdTreeInternal(buffer, &qpoints)) {
+      return false;
+    }
+  } else {  // Unsupported version.
+    fprintf(stderr, "Version not supported. \n");
+    return false;
+  }
+
+  DequantizePoints3(qpoints.begin(), qpoints.end(), qinfo_, out);
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_FLOAT_POINTS_TREE_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_encoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_encoder.cc
new file mode 100644
index 000000000..317430f2b
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_encoder.cc
@@ -0,0 +1,94 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/point_cloud/algorithms/float_points_tree_encoder.h"
+
+#include <algorithm>
+#include <cmath>
+
+#include "draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_encoder.h"
+#include "draco/core/math_utils.h"
+
+namespace draco {
+
+const uint32_t FloatPointsTreeEncoder::version_ = 3;
+
+FloatPointsTreeEncoder::FloatPointsTreeEncoder(
+    PointCloudCompressionMethod method)
+    : method_(method), num_points_(0), compression_level_(6) {
+  qinfo_.quantization_bits = 16;
+  qinfo_.range = 0;
+}
+
+FloatPointsTreeEncoder::FloatPointsTreeEncoder(
+    PointCloudCompressionMethod method, uint32_t quantization_bits,
+    uint32_t compression_level)
+    : method_(method), num_points_(0), compression_level_(compression_level) {
+  DRACO_DCHECK_LE(compression_level_, 6);
+  qinfo_.quantization_bits = quantization_bits;
+  qinfo_.range = 0;
+}
+
+bool FloatPointsTreeEncoder::EncodePointCloudKdTreeInternal(
+    std::vector<Point3ui> *qpoints) {
+  DRACO_DCHECK_LE(compression_level_, 6);
+  switch (compression_level_) {
+    case 0: {
+      DynamicIntegerPointsKdTreeEncoder<0> qpoints_encoder(3);
+      qpoints_encoder.EncodePoints(qpoints->begin(), qpoints->end(),
+                                   qinfo_.quantization_bits + 1, &buffer_);
+      break;
+    }
+    case 1: {
+      DynamicIntegerPointsKdTreeEncoder<1> qpoints_encoder(3);
+      qpoints_encoder.EncodePoints(qpoints->begin(), qpoints->end(),
+                                   qinfo_.quantization_bits + 1, &buffer_);
+      break;
+    }
+    case 2: {
+      DynamicIntegerPointsKdTreeEncoder<2> qpoints_encoder(3);
+      qpoints_encoder.EncodePoints(qpoints->begin(), qpoints->end(),
+                                   qinfo_.quantization_bits + 1, &buffer_);
+      break;
+    }
+    case 3: {
+      DynamicIntegerPointsKdTreeEncoder<3> qpoints_encoder(3);
+      qpoints_encoder.EncodePoints(qpoints->begin(), qpoints->end(),
+                                   qinfo_.quantization_bits + 1, &buffer_);
+      break;
+    }
+    case 4: {
+      DynamicIntegerPointsKdTreeEncoder<4> qpoints_encoder(3);
+      qpoints_encoder.EncodePoints(qpoints->begin(), qpoints->end(),
+                                   qinfo_.quantization_bits + 1, &buffer_);
+      break;
+    }
+    case 5: {
+      DynamicIntegerPointsKdTreeEncoder<5> qpoints_encoder(3);
+      qpoints_encoder.EncodePoints(qpoints->begin(), qpoints->end(),
+                                   qinfo_.quantization_bits + 1, &buffer_);
+      break;
+    }
+    default: {
+      DynamicIntegerPointsKdTreeEncoder<6> qpoints_encoder(3);
+      qpoints_encoder.EncodePoints(qpoints->begin(), qpoints->end(),
+                                   qinfo_.quantization_bits + 1, &buffer_);
+      break;
+    }
+  }
+
+  return true;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_encoder.h
new file mode 100644
index 000000000..26ba94f1f
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_encoder.h
@@ -0,0 +1,126 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_FLOAT_POINTS_TREE_ENCODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_FLOAT_POINTS_TREE_ENCODER_H_
+
+#include <memory>
+#include <vector>
+
+#include "draco/compression/point_cloud/algorithms/point_cloud_compression_method.h"
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+#include "draco/compression/point_cloud/algorithms/quantize_points_3.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// This class encodes a given point cloud based on the point cloud compression
+// algorithm in:
+// Olivier Devillers and Pierre-Marie Gandoin
+// "Geometric compression for interactive transmission"
+//
+// In principle the algorithm keeps on splitting the point cloud in the middle
+// while alternating the axes. For 3D this results in an Octree like structure.
+// In each step we encode the number of points in the first half.
+// The algorithm uses quantization and does not preserve the order of points.
+//
+// However, the algorithm here differs from the original as follows:
+// The algorithm keeps on splitting the point cloud in the middle of the axis
+// that keeps the point cloud as clustered as possible, which gives a better
+// compression rate.
+// The number of points is encode by the deviation from the half of the points
+// in the smaller half of the two. This results in a better compression rate as
+// there are more leading zeros, which is then compressed better by the
+// arithmetic encoding.
+
+// TODO(hemmer): Remove class because it duplicates quantization code.
+class FloatPointsTreeEncoder {
+ public:
+  explicit FloatPointsTreeEncoder(PointCloudCompressionMethod method);
+  explicit FloatPointsTreeEncoder(PointCloudCompressionMethod method,
+                                  uint32_t quantization_bits,
+                                  uint32_t compression_level);
+
+  template <class InputIteratorT>
+  bool EncodePointCloud(InputIteratorT points_begin, InputIteratorT points_end);
+  EncoderBuffer *buffer() { return &buffer_; }
+
+  uint32_t version() const { return version_; }
+  uint32_t quantization_bits() const { return qinfo_.quantization_bits; }
+  uint32_t &quantization_bits() { return qinfo_.quantization_bits; }
+  uint32_t compression_level() const { return compression_level_; }
+  uint32_t &compression_level() { return compression_level_; }
+  float range() const { return qinfo_.range; }
+  uint32_t num_points() const { return num_points_; }
+  std::string identification_string() const {
+    if (method_ == KDTREE) {
+      return "FloatPointsTreeEncoder: IntegerPointsKDTreeEncoder";
+    } else {
+      return "FloatPointsTreeEncoder: Unsupported Method";
+    }
+  }
+
+ private:
+  void Clear() { buffer_.Clear(); }
+  bool EncodePointCloudKdTreeInternal(std::vector<Point3ui> *qpoints);
+
+  static const uint32_t version_;
+  QuantizationInfo qinfo_;
+  PointCloudCompressionMethod method_;
+  uint32_t num_points_;
+  EncoderBuffer buffer_;
+  uint32_t compression_level_;
+};
+
+template <class InputIteratorT>
+bool FloatPointsTreeEncoder::EncodePointCloud(InputIteratorT points_begin,
+                                              InputIteratorT points_end) {
+  Clear();
+
+  // Collect necessary data for encoding.
+  num_points_ = std::distance(points_begin, points_end);
+
+  // TODO(hemmer): Extend quantization tools to make this more automatic.
+  // Compute range of points for quantization
+  std::vector<Point3ui> qpoints;
+  qpoints.reserve(num_points_);
+  QuantizePoints3(points_begin, points_end, &qinfo_,
+                  std::back_inserter(qpoints));
+
+  // Encode header.
+  buffer()->Encode(version_);
+  buffer()->Encode(static_cast<int8_t>(method_));
+  buffer()->Encode(qinfo_.quantization_bits);
+  buffer()->Encode(qinfo_.range);
+  buffer()->Encode(num_points_);
+
+  if (method_ == KDTREE) {
+    buffer()->Encode(compression_level_);
+  }
+
+  if (num_points_ == 0) {
+    return true;
+  }
+
+  if (method_ == KDTREE) {
+    return EncodePointCloudKdTreeInternal(&qpoints);
+  } else {  // Unsupported method.
+    fprintf(stderr, "Method not supported. \n");
+    return false;
+  }
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_FLOAT_POINTS_TREE_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_decoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_decoder.cc
new file mode 100644
index 000000000..d0428a28e
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_decoder.cc
@@ -0,0 +1,45 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/point_cloud/algorithms/integer_points_kd_tree_decoder.h"
+
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+
+namespace draco {
+
+template class IntegerPointsKdTreeDecoder<Point3ui, 0>;
+template class IntegerPointsKdTreeDecoder<Point3ui, 1>;
+template class IntegerPointsKdTreeDecoder<Point3ui, 2>;
+template class IntegerPointsKdTreeDecoder<Point3ui, 3>;
+template class IntegerPointsKdTreeDecoder<Point3ui, 4>;
+template class IntegerPointsKdTreeDecoder<Point3ui, 5>;
+template class IntegerPointsKdTreeDecoder<Point3ui, 6>;
+template class IntegerPointsKdTreeDecoder<Point3ui, 7>;
+template class IntegerPointsKdTreeDecoder<Point3ui, 8>;
+template class IntegerPointsKdTreeDecoder<Point3ui, 9>;
+template class IntegerPointsKdTreeDecoder<Point3ui, 10>;
+
+template class IntegerPointsKdTreeDecoder<Point4ui, 0>;
+template class IntegerPointsKdTreeDecoder<Point4ui, 1>;
+template class IntegerPointsKdTreeDecoder<Point4ui, 2>;
+template class IntegerPointsKdTreeDecoder<Point4ui, 3>;
+template class IntegerPointsKdTreeDecoder<Point4ui, 4>;
+template class IntegerPointsKdTreeDecoder<Point4ui, 5>;
+template class IntegerPointsKdTreeDecoder<Point4ui, 6>;
+template class IntegerPointsKdTreeDecoder<Point4ui, 7>;
+template class IntegerPointsKdTreeDecoder<Point4ui, 8>;
+template class IntegerPointsKdTreeDecoder<Point4ui, 9>;
+template class IntegerPointsKdTreeDecoder<Point4ui, 10>;
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_decoder.h
new file mode 100644
index 000000000..94e523cad
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_decoder.h
@@ -0,0 +1,314 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// TODO(hemmer): Make this a wrapper using DynamicIntegerPointsKdTreeDecoder.
+//
+// See integer_points_kd_tree_encoder.h for documentation.
+
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_INTEGER_POINTS_KD_TREE_DECODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_INTEGER_POINTS_KD_TREE_DECODER_H_
+
+#include <array>
+#include <memory>
+
+#include "draco/compression/bit_coders/adaptive_rans_bit_decoder.h"
+#include "draco/compression/bit_coders/direct_bit_decoder.h"
+#include "draco/compression/bit_coders/folded_integer_bit_decoder.h"
+#include "draco/compression/bit_coders/rans_bit_decoder.h"
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+#include "draco/compression/point_cloud/algorithms/queuing_policy.h"
+#include "draco/core/bit_utils.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/math_utils.h"
+
+namespace draco {
+
+template <int compression_level_t>
+struct IntegerPointsKdTreeDecoderCompressionPolicy
+    : public IntegerPointsKdTreeDecoderCompressionPolicy<compression_level_t -
+                                                         1> {};
+
+template <>
+struct IntegerPointsKdTreeDecoderCompressionPolicy<0> {
+  typedef DirectBitDecoder NumbersDecoder;
+  typedef DirectBitDecoder AxisDecoder;
+  typedef DirectBitDecoder HalfDecoder;
+  typedef DirectBitDecoder RemainingBitsDecoder;
+  static constexpr bool select_axis = false;
+
+  template <class T>
+  using QueuingStrategy = Stack<T>;
+};
+
+template <>
+struct IntegerPointsKdTreeDecoderCompressionPolicy<2>
+    : public IntegerPointsKdTreeDecoderCompressionPolicy<1> {
+  typedef RAnsBitDecoder NumbersDecoder;
+};
+
+template <>
+struct IntegerPointsKdTreeDecoderCompressionPolicy<4>
+    : public IntegerPointsKdTreeDecoderCompressionPolicy<3> {
+  typedef FoldedBit32Decoder<RAnsBitDecoder> NumbersDecoder;
+};
+
+template <>
+struct IntegerPointsKdTreeDecoderCompressionPolicy<6>
+    : public IntegerPointsKdTreeDecoderCompressionPolicy<5> {
+  static constexpr bool select_axis = true;
+};
+
+template <>
+struct IntegerPointsKdTreeDecoderCompressionPolicy<8>
+    : public IntegerPointsKdTreeDecoderCompressionPolicy<7> {
+  typedef FoldedBit32Decoder<AdaptiveRAnsBitDecoder> NumbersDecoder;
+  template <class T>
+  using QueuingStrategy = Queue<T>;
+};
+
+template <>
+struct IntegerPointsKdTreeDecoderCompressionPolicy<10>
+    : public IntegerPointsKdTreeDecoderCompressionPolicy<9> {
+  template <class T>
+  using QueuingStrategy = PriorityQueue<T>;
+};
+
+// Decodes a point cloud encoded by IntegerPointsKdTreeEncoder.
+// |PointDiT| is a type representing a point with uint32_t coordinates.
+// must provide construction from three uint32_t and operator[].
+template <class PointDiT, int compression_level_t>
+class IntegerPointsKdTreeDecoder {
+  typedef IntegerPointsKdTreeDecoderCompressionPolicy<compression_level_t>
+      Policy;
+
+  typedef typename Policy::NumbersDecoder NumbersDecoder;
+  typedef typename Policy::AxisDecoder AxisDecoder;
+  typedef typename Policy::HalfDecoder HalfDecoder;
+  typedef typename Policy::RemainingBitsDecoder RemainingBitsDecoder;
+
+ public:
+  IntegerPointsKdTreeDecoder() : bit_length_(0) {}
+
+  // Decodes a integer point cloud from |buffer|.
+  template <class OutputIteratorT>
+  bool DecodePoints(DecoderBuffer *buffer, OutputIteratorT oit);
+
+ private:
+  // For the sake of readability of code, we decided to make this exception
+  // from the naming scheme.
+  static constexpr int D = PointTraits<PointDiT>::Dimension();
+
+  uint32_t GetAxis(uint32_t num_remaining_points, const PointDiT &base,
+                   std::array<uint32_t, D> levels, uint32_t last_axis);
+
+  template <class OutputIteratorT>
+  void DecodeInternal(uint32_t num_remaining_points, PointDiT base,
+                      std::array<uint32_t, D> levels, uint32_t last_axis,
+                      OutputIteratorT oit);
+
+  void DecodeNumber(int nbits, uint32_t *value) {
+    numbers_decoder_.DecodeLeastSignificantBits32(nbits, value);
+  }
+
+  struct DecodingStatus {
+    DecodingStatus(
+        uint32_t num_remaining_points_, const PointDiT &old_base_,
+        std::array<uint32_t, PointTraits<PointDiT>::Dimension()> levels_,
+        uint32_t last_axis_)
+        : num_remaining_points(num_remaining_points_),
+          old_base(old_base_),
+          levels(levels_),
+          last_axis(last_axis_) {}
+
+    uint32_t num_remaining_points;
+    PointDiT old_base;
+    std::array<uint32_t, D> levels;
+    uint32_t last_axis;
+    friend bool operator<(const DecodingStatus &l, const DecodingStatus &r) {
+      return l.num_remaining_points < r.num_remaining_points;
+    }
+  };
+
+  uint32_t bit_length_;
+  uint32_t num_points_;
+  NumbersDecoder numbers_decoder_;
+  RemainingBitsDecoder remaining_bits_decoder_;
+  AxisDecoder axis_decoder_;
+  HalfDecoder half_decoder_;
+};
+
+// Decodes a point cloud from |buffer|.
+template <class PointDiT, int compression_level_t>
+template <class OutputIteratorT>
+bool IntegerPointsKdTreeDecoder<PointDiT, compression_level_t>::DecodePoints(
+    DecoderBuffer *buffer, OutputIteratorT oit) {
+  if (!buffer->Decode(&bit_length_)) {
+    return false;
+  }
+  if (!buffer->Decode(&num_points_)) {
+    return false;
+  }
+  if (num_points_ == 0) {
+    return true;
+  }
+
+  if (!numbers_decoder_.StartDecoding(buffer)) {
+    return false;
+  }
+  if (!remaining_bits_decoder_.StartDecoding(buffer)) {
+    return false;
+  }
+  if (!axis_decoder_.StartDecoding(buffer)) {
+    return false;
+  }
+  if (!half_decoder_.StartDecoding(buffer)) {
+    return false;
+  }
+
+  DecodeInternal(num_points_, PointTraits<PointDiT>::Origin(),
+                 PointTraits<PointDiT>::ZeroArray(), 0, oit);
+
+  numbers_decoder_.EndDecoding();
+  remaining_bits_decoder_.EndDecoding();
+  axis_decoder_.EndDecoding();
+  half_decoder_.EndDecoding();
+
+  return true;
+}
+
+template <class PointDiT, int compression_level_t>
+uint32_t IntegerPointsKdTreeDecoder<PointDiT, compression_level_t>::GetAxis(
+    uint32_t num_remaining_points, const PointDiT & /* base */,
+    std::array<uint32_t, D> levels, uint32_t last_axis) {
+  if (!Policy::select_axis) {
+    return DRACO_INCREMENT_MOD(last_axis, D);
+  }
+
+  uint32_t best_axis = 0;
+  if (num_remaining_points < 64) {
+    for (uint32_t axis = 1; axis < D; ++axis) {
+      if (levels[best_axis] > levels[axis]) {
+        best_axis = axis;
+      }
+    }
+  } else {
+    axis_decoder_.DecodeLeastSignificantBits32(4, &best_axis);
+  }
+
+  return best_axis;
+}
+
+template <class PointDiT, int compression_level_t>
+template <class OutputIteratorT>
+void IntegerPointsKdTreeDecoder<PointDiT, compression_level_t>::DecodeInternal(
+    uint32_t num_remaining_points, PointDiT old_base,
+    std::array<uint32_t, D> levels, uint32_t last_axis, OutputIteratorT oit) {
+  DecodingStatus init_status(num_remaining_points, old_base, levels, last_axis);
+  typename Policy::template QueuingStrategy<DecodingStatus> status_q;
+  status_q.push(init_status);
+
+  while (!status_q.empty()) {
+    const DecodingStatus status = status_q.front();
+    status_q.pop();
+
+    num_remaining_points = status.num_remaining_points;
+    old_base = status.old_base;
+    levels = status.levels;
+    last_axis = status.last_axis;
+
+    const uint32_t axis =
+        GetAxis(num_remaining_points, old_base, levels, last_axis);
+
+    const uint32_t level = levels[axis];
+
+    // All axes have been fully subdivided, just output points.
+    if ((bit_length_ - level) == 0) {
+      for (int i = 0; i < static_cast<int>(num_remaining_points); i++) {
+        *oit++ = old_base;
+      }
+      continue;
+    }
+
+    DRACO_DCHECK_EQ(true, num_remaining_points != 0);
+    if (num_remaining_points <= 2) {
+      std::array<uint32_t, D> axes;
+      axes[0] = axis;
+      for (int i = 1; i < D; i++) {
+        axes[i] = DRACO_INCREMENT_MOD(axes[i - 1], D);
+      }
+
+      std::array<uint32_t, D> num_remaining_bits;
+      for (int i = 0; i < D; i++) {
+        num_remaining_bits[i] = bit_length_ - levels[axes[i]];
+      }
+
+      for (uint32_t i = 0; i < num_remaining_points; ++i) {
+        // Get remaining bits, mind the carry if not starting at x.
+        PointDiT p = PointTraits<PointDiT>::Origin();
+        for (int j = 0; j < static_cast<int>(D); j++) {
+          if (num_remaining_bits[j]) {
+            remaining_bits_decoder_.DecodeLeastSignificantBits32(
+                num_remaining_bits[j], &p[axes[j]]);
+          }
+          p[axes[j]] = old_base[axes[j]] | p[axes[j]];
+        }
+        *oit++ = p;
+      }
+      continue;
+    }
+
+    const int num_remaining_bits = bit_length_ - level;
+    const uint32_t modifier = 1 << (num_remaining_bits - 1);
+    PointDiT new_base(old_base);
+    new_base[axis] += modifier;
+
+    const int incoming_bits = MostSignificantBit(num_remaining_points);
+
+    uint32_t number = 0;
+    DecodeNumber(incoming_bits, &number);
+
+    uint32_t first_half = num_remaining_points / 2 - number;
+    uint32_t second_half = num_remaining_points - first_half;
+
+    if (first_half != second_half) {
+      if (!half_decoder_.DecodeNextBit()) {
+        std::swap(first_half, second_half);
+      }
+    }
+
+    levels[axis] += 1;
+    if (first_half) {
+      status_q.push(DecodingStatus(first_half, old_base, levels, axis));
+    }
+    if (second_half) {
+      status_q.push(DecodingStatus(second_half, new_base, levels, axis));
+    }
+  }
+}
+
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 0>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 1>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 2>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 3>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 4>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 5>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 6>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 7>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 8>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 9>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 10>;
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_INTEGER_POINTS_KD_TREE_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_encoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_encoder.cc
new file mode 100644
index 000000000..ee1059500
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_encoder.cc
@@ -0,0 +1,45 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/point_cloud/algorithms/integer_points_kd_tree_encoder.h"
+
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+
+namespace draco {
+
+template class IntegerPointsKdTreeEncoder<Point3ui, 0>;
+template class IntegerPointsKdTreeEncoder<Point3ui, 1>;
+template class IntegerPointsKdTreeEncoder<Point3ui, 2>;
+template class IntegerPointsKdTreeEncoder<Point3ui, 3>;
+template class IntegerPointsKdTreeEncoder<Point3ui, 4>;
+template class IntegerPointsKdTreeEncoder<Point3ui, 5>;
+template class IntegerPointsKdTreeEncoder<Point3ui, 6>;
+template class IntegerPointsKdTreeEncoder<Point3ui, 7>;
+template class IntegerPointsKdTreeEncoder<Point3ui, 8>;
+template class IntegerPointsKdTreeEncoder<Point3ui, 9>;
+template class IntegerPointsKdTreeEncoder<Point3ui, 10>;
+
+template class IntegerPointsKdTreeEncoder<Point4ui, 0>;
+template class IntegerPointsKdTreeEncoder<Point4ui, 1>;
+template class IntegerPointsKdTreeEncoder<Point4ui, 2>;
+template class IntegerPointsKdTreeEncoder<Point4ui, 3>;
+template class IntegerPointsKdTreeEncoder<Point4ui, 4>;
+template class IntegerPointsKdTreeEncoder<Point4ui, 5>;
+template class IntegerPointsKdTreeEncoder<Point4ui, 6>;
+template class IntegerPointsKdTreeEncoder<Point4ui, 7>;
+template class IntegerPointsKdTreeEncoder<Point4ui, 8>;
+template class IntegerPointsKdTreeEncoder<Point4ui, 9>;
+template class IntegerPointsKdTreeEncoder<Point4ui, 10>;
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_encoder.h
new file mode 100644
index 000000000..b8811092e
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_encoder.h
@@ -0,0 +1,404 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// TODO(hemmer): Make this a wrapper using DynamicIntegerPointsKdTreeEncoder.
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_INTEGER_POINTS_KD_TREE_ENCODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_INTEGER_POINTS_KD_TREE_ENCODER_H_
+
+#include <algorithm>
+#include <array>
+#include <memory>
+#include <vector>
+
+#include "draco/compression/bit_coders/adaptive_rans_bit_encoder.h"
+#include "draco/compression/bit_coders/direct_bit_encoder.h"
+#include "draco/compression/bit_coders/folded_integer_bit_encoder.h"
+#include "draco/compression/bit_coders/rans_bit_encoder.h"
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+#include "draco/compression/point_cloud/algorithms/queuing_policy.h"
+#include "draco/core/bit_utils.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/math_utils.h"
+
+namespace draco {
+
+// This policy class provides several configurations for the encoder that allow
+// to trade speed vs compression rate. Level 0 is fastest while 10 is the best
+// compression rate. The decoder must select the same level.
+template <int compression_level_t>
+struct IntegerPointsKdTreeEncoderCompressionPolicy
+    : public IntegerPointsKdTreeEncoderCompressionPolicy<compression_level_t -
+                                                         1> {};
+
+template <>
+struct IntegerPointsKdTreeEncoderCompressionPolicy<0> {
+  typedef DirectBitEncoder NumbersEncoder;
+  typedef DirectBitEncoder AxisEncoder;
+  typedef DirectBitEncoder HalfEncoder;
+  typedef DirectBitEncoder RemainingBitsEncoder;
+  static constexpr bool select_axis = false;
+
+  template <class T>
+  using QueuingStrategy = Stack<T>;
+};
+
+template <>
+struct IntegerPointsKdTreeEncoderCompressionPolicy<2>
+    : public IntegerPointsKdTreeEncoderCompressionPolicy<1> {
+  typedef RAnsBitEncoder NumbersEncoder;
+};
+
+template <>
+struct IntegerPointsKdTreeEncoderCompressionPolicy<4>
+    : public IntegerPointsKdTreeEncoderCompressionPolicy<3> {
+  typedef FoldedBit32Encoder<RAnsBitEncoder> NumbersEncoder;
+};
+
+template <>
+struct IntegerPointsKdTreeEncoderCompressionPolicy<6>
+    : public IntegerPointsKdTreeEncoderCompressionPolicy<5> {
+  static constexpr bool select_axis = true;
+};
+
+template <>
+struct IntegerPointsKdTreeEncoderCompressionPolicy<8>
+    : public IntegerPointsKdTreeEncoderCompressionPolicy<7> {
+  typedef FoldedBit32Encoder<AdaptiveRAnsBitEncoder> NumbersEncoder;
+  template <class T>
+  using QueuingStrategy = Queue<T>;
+};
+
+template <>
+struct IntegerPointsKdTreeEncoderCompressionPolicy<10>
+    : public IntegerPointsKdTreeEncoderCompressionPolicy<9> {
+  template <class T>
+  using QueuingStrategy = PriorityQueue<T>;
+};
+
+// This class encodes a given integer point cloud based on the point cloud
+// compression algorithm in:
+// Olivier Devillers and Pierre-Marie Gandoin
+// "Geometric compression for interactive transmission"
+//
+// In principle the algorithm keeps on splitting the point cloud in the middle
+// while alternating the axes. In 3D this results in an Octree like structure.
+// In each step we encode the number of points in the first half.
+// The algorithm does not preserve the order of points.
+//
+// However, the algorithm here differs from the original as follows:
+// The algorithm keeps on splitting the point cloud in the middle of the axis
+// that keeps the point cloud as clustered as possible, which gives a better
+// compression rate.
+// The number of points is encode by the deviation from the half of the points
+// in the smaller half of the two. This results in a better compression rate as
+// there are more leading zeros, which is then compressed better by the
+// arithmetic encoding.
+//
+// |PointDiT| is a type representing a point with uint32_t coordinates.
+// must provide construction from three uint32_t and operator[].
+template <class PointDiT, int compression_level_t>
+class IntegerPointsKdTreeEncoder {
+  typedef IntegerPointsKdTreeEncoderCompressionPolicy<compression_level_t>
+      Policy;
+  typedef typename Policy::NumbersEncoder NumbersEncoder;
+  typedef typename Policy::AxisEncoder AxisEncoder;
+  typedef typename Policy::HalfEncoder HalfEncoder;
+  typedef typename Policy::RemainingBitsEncoder RemainingBitsEncoder;
+
+ public:
+  IntegerPointsKdTreeEncoder() : bit_length_(0) {}
+
+  // Encodes an integer point cloud given by [begin,end) into buffer.
+  // |bit_length| gives the highest bit used for all coordinates.
+  template <class RandomAccessIteratorT>
+  bool EncodePoints(RandomAccessIteratorT begin, RandomAccessIteratorT end,
+                    const uint32_t &bit_length, EncoderBuffer *buffer);
+
+  // Encodes an integer point cloud given by [begin,end) into buffer.
+  template <class RandomAccessIteratorT>
+  bool EncodePoints(RandomAccessIteratorT begin, RandomAccessIteratorT end,
+                    EncoderBuffer *buffer) {
+    return EncodePoints(begin, end, 32, buffer);
+  }
+
+ private:
+  // For the sack of readability of code, we decided to make this exception
+  // from the naming scheme.
+  static constexpr int D = PointTraits<PointDiT>::Dimension();
+  template <class RandomAccessIteratorT>
+  uint32_t GetAxis(RandomAccessIteratorT begin, RandomAccessIteratorT end,
+                   const PointDiT &old_base, std::array<uint32_t, D> levels,
+                   uint32_t last_axis);
+
+  template <class RandomAccessIteratorT>
+  void EncodeInternal(RandomAccessIteratorT begin, RandomAccessIteratorT end,
+                      PointDiT old_base, std::array<uint32_t, D> levels,
+                      uint32_t last_axis);
+
+  class Splitter {
+   public:
+    Splitter(int axis, uint32_t value) : axis_(axis), value_(value) {}
+    bool operator()(const PointDiT &a) { return a[axis_] < value_; }
+
+   private:
+    int axis_;
+    uint32_t value_;
+  };
+
+  void EncodeNumber(int nbits, uint32_t value) {
+    numbers_encoder_.EncodeLeastSignificantBits32(nbits, value);
+  }
+
+  template <class RandomAccessIteratorT>
+  struct EncodingStatus {
+    EncodingStatus(
+        RandomAccessIteratorT begin_, RandomAccessIteratorT end_,
+        const PointDiT &old_base_,
+        std::array<uint32_t, PointTraits<PointDiT>::Dimension()> levels_,
+        uint32_t last_axis_)
+        : begin(begin_),
+          end(end_),
+          old_base(old_base_),
+          levels(levels_),
+          last_axis(last_axis_) {
+      num_remaining_points = end - begin;
+    }
+
+    RandomAccessIteratorT begin;
+    RandomAccessIteratorT end;
+    PointDiT old_base;
+    std::array<uint32_t, D> levels;
+    uint32_t last_axis;
+    uint32_t num_remaining_points;
+    friend bool operator<(const EncodingStatus &l, const EncodingStatus &r) {
+      return l.num_remaining_points < r.num_remaining_points;
+    }
+  };
+
+  uint32_t bit_length_;
+  uint32_t num_points_;
+  NumbersEncoder numbers_encoder_;
+  RemainingBitsEncoder remaining_bits_encoder_;
+  AxisEncoder axis_encoder_;
+  HalfEncoder half_encoder_;
+};
+
+template <class PointDiT, int compression_level_t>
+template <class RandomAccessIteratorT>
+bool IntegerPointsKdTreeEncoder<PointDiT, compression_level_t>::EncodePoints(
+    RandomAccessIteratorT begin, RandomAccessIteratorT end,
+    const uint32_t &bit_length, EncoderBuffer *buffer) {
+  bit_length_ = bit_length;
+  num_points_ = end - begin;
+
+  buffer->Encode(bit_length_);
+  buffer->Encode(num_points_);
+  if (num_points_ == 0) {
+    return true;
+  }
+
+  numbers_encoder_.StartEncoding();
+  remaining_bits_encoder_.StartEncoding();
+  axis_encoder_.StartEncoding();
+  half_encoder_.StartEncoding();
+
+  EncodeInternal(begin, end, PointTraits<PointDiT>::Origin(),
+                 PointTraits<PointDiT>::ZeroArray(), 0);
+
+  numbers_encoder_.EndEncoding(buffer);
+  remaining_bits_encoder_.EndEncoding(buffer);
+  axis_encoder_.EndEncoding(buffer);
+  half_encoder_.EndEncoding(buffer);
+
+  return true;
+}
+template <class PointDiT, int compression_level_t>
+template <class RandomAccessIteratorT>
+uint32_t IntegerPointsKdTreeEncoder<PointDiT, compression_level_t>::GetAxis(
+    RandomAccessIteratorT begin, RandomAccessIteratorT end,
+    const PointDiT &old_base, std::array<uint32_t, D> levels,
+    uint32_t last_axis) {
+  if (!Policy::select_axis) {
+    return DRACO_INCREMENT_MOD(last_axis, D);
+  }
+
+  // For many points this function selects the axis that should be used
+  // for the split by keeping as many points as possible bundled.
+  // In the best case we do not split the point cloud at all.
+  // For lower number of points, we simply choose the axis that is refined the
+  // least so far.
+
+  DRACO_DCHECK_EQ(true, end - begin != 0);
+
+  uint32_t best_axis = 0;
+  if (end - begin < 64) {
+    for (uint32_t axis = 1; axis < D; ++axis) {
+      if (levels[best_axis] > levels[axis]) {
+        best_axis = axis;
+      }
+    }
+  } else {
+    const uint32_t size = (end - begin);
+    std::array<uint32_t, D> num_remaining_bits =
+        PointTraits<PointDiT>::ZeroArray();
+    for (int i = 0; i < D; i++) {
+      num_remaining_bits[i] = bit_length_ - levels[i];
+    }
+    PointDiT split(old_base);
+
+    for (int i = 0; i < D; i++) {
+      if (num_remaining_bits[i]) {
+        split[i] += 1 << (num_remaining_bits[i] - 1);
+      }
+    }
+
+    std::array<uint32_t, D> deviations = PointTraits<PointDiT>::ZeroArray();
+    for (auto it = begin; it != end; ++it) {
+      for (int i = 0; i < D; i++) {
+        deviations[i] += ((*it)[i] < split[i]);
+      }
+    }
+    for (int i = 0; i < D; i++) {
+      deviations[i] = std::max(size - deviations[i], deviations[i]);
+    }
+
+    uint32_t max_value = 0;
+    best_axis = 0;
+    for (int i = 0; i < D; i++) {
+      // If axis can be subdivided.
+      if (num_remaining_bits[i]) {
+        // Check if this is the better axis.
+        if (max_value < deviations[i]) {
+          max_value = deviations[i];
+          best_axis = i;
+        }
+      }
+    }
+    axis_encoder_.EncodeLeastSignificantBits32(4, best_axis);
+  }
+
+  return best_axis;
+}
+
+template <class PointDiT, int compression_level_t>
+template <class RandomAccessIteratorT>
+void IntegerPointsKdTreeEncoder<PointDiT, compression_level_t>::EncodeInternal(
+    RandomAccessIteratorT begin, RandomAccessIteratorT end, PointDiT old_base,
+    std::array<uint32_t, D> levels, uint32_t last_axis) {
+  EncodingStatus<RandomAccessIteratorT> init_status(begin, end, old_base,
+                                                    levels, last_axis);
+  typename Policy::template QueuingStrategy<
+      EncodingStatus<RandomAccessIteratorT>>
+      status_q;
+
+  status_q.push(init_status);
+
+  while (!status_q.empty()) {
+    EncodingStatus<RandomAccessIteratorT> status = status_q.front();
+    status_q.pop();
+
+    begin = status.begin;
+    end = status.end;
+    old_base = status.old_base;
+    levels = status.levels;
+    last_axis = status.last_axis;
+
+    const uint32_t axis = GetAxis(begin, end, old_base, levels, last_axis);
+    const uint32_t level = levels[axis];
+    const uint32_t num_remaining_points = end - begin;
+
+    // If this happens all axis are subdivided to the end.
+    if ((bit_length_ - level) == 0) {
+      continue;
+    }
+
+    // Fast encoding of remaining bits if number of points is 1.
+    // Doing this also for 2 gives a slight additional speed up.
+    if (num_remaining_points <= 2) {
+      std::array<uint32_t, D> axes;
+      axes[0] = axis;
+      for (int i = 1; i < D; i++) {
+        axes[i] = DRACO_INCREMENT_MOD(axes[i - 1], D);
+      }
+
+      std::array<uint32_t, D> num_remaining_bits;
+      for (int i = 0; i < D; i++) {
+        num_remaining_bits[i] = bit_length_ - levels[axes[i]];
+      }
+
+      for (uint32_t i = 0; i < num_remaining_points; ++i) {
+        const PointDiT &p = *(begin + i);
+        for (int j = 0; j < D; j++) {
+          if (num_remaining_bits[j]) {
+            remaining_bits_encoder_.EncodeLeastSignificantBits32(
+                num_remaining_bits[j], p[axes[j]]);
+          }
+        }
+      }
+      continue;
+    }
+
+    const uint32_t num_remaining_bits = bit_length_ - level;
+    const uint32_t modifier = 1 << (num_remaining_bits - 1);
+    PointDiT new_base(old_base);
+    new_base[axis] += modifier;
+    const RandomAccessIteratorT split =
+        std::partition(begin, end, Splitter(axis, new_base[axis]));
+
+    DRACO_DCHECK_EQ(true, (end - begin) > 0);
+
+    // Encode number of points in first and second half.
+    const int required_bits = MostSignificantBit(num_remaining_points);
+
+    const uint32_t first_half = split - begin;
+    const uint32_t second_half = end - split;
+    const bool left = first_half < second_half;
+
+    if (first_half != second_half) {
+      half_encoder_.EncodeBit(left);
+    }
+
+    if (left) {
+      EncodeNumber(required_bits, num_remaining_points / 2 - first_half);
+    } else {
+      EncodeNumber(required_bits, num_remaining_points / 2 - second_half);
+    }
+
+    levels[axis] += 1;
+    if (split != begin) {
+      status_q.push(EncodingStatus<RandomAccessIteratorT>(
+          begin, split, old_base, levels, axis));
+    }
+    if (split != end) {
+      status_q.push(EncodingStatus<RandomAccessIteratorT>(split, end, new_base,
+                                                          levels, axis));
+    }
+  }
+}
+
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 0>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 1>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 2>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 3>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 4>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 5>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 6>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 7>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 8>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 9>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 10>;
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_INTEGER_POINTS_KD_TREE_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/point_cloud_compression_method.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/point_cloud_compression_method.h
new file mode 100644
index 000000000..9541c9668
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/point_cloud_compression_method.h
@@ -0,0 +1,34 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_POINT_CLOUD_COMPRESSION_METHOD_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_POINT_CLOUD_COMPRESSION_METHOD_H_
+
+namespace draco {
+
+// Enum indicating the used compression method, used by Encoder and Decoder.
+enum PointCloudCompressionMethod {
+  RESERVED_POINT_CLOUD_METHOD_0 = 0,  // Reserved for internal use.
+  // Generalized version of Encoding using the Octree method by Olivier
+  // Devillers to d dimensions.
+  // "Progressive lossless compression of arbitrary simplicial complexes"
+  // https://doi.org/10.1145/566570.566591
+  KDTREE = 1,
+  RESERVED_POINT_CLOUD_METHOD_2 = 2,  // Reserved for internal use.
+  RESERVED_POINT_CLOUD_METHOD_3 = 0,  // Reserved for internal use.
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_POINT_CLOUD_COMPRESSION_METHOD_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/point_cloud_types.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/point_cloud_types.h
new file mode 100644
index 000000000..893efbefa
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/point_cloud_types.h
@@ -0,0 +1,76 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_POINT_CLOUD_TYPES_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_POINT_CLOUD_TYPES_H_
+
+#include <inttypes.h>
+
+#include <vector>
+
+#include "draco/core/vector_d.h"
+
+namespace draco {
+
+// Using Eigen as this is favored by project Cartographer.
+typedef Vector3f Point3f;
+typedef Vector4f Point4f;
+typedef Vector3ui Point3ui;
+typedef Vector4ui Point4ui;
+typedef Vector5ui Point5ui;
+typedef Vector6ui Point6ui;
+typedef Vector7ui Point7ui;
+
+typedef std::vector<Point3f> PointCloud3f;
+
+template <class PointDT>
+struct PointDLess;
+
+template <class CoeffT, int dimension_t>
+struct PointDLess<VectorD<CoeffT, dimension_t>> {
+  bool operator()(const VectorD<CoeffT, dimension_t> &a,
+                  const VectorD<CoeffT, dimension_t> &b) const {
+    return a < b;
+  }
+};
+
+template <class PointDT>
+class PointTraits {};
+
+template <class CoordinateTypeT, int dimension_t>
+class PointTraits<VectorD<CoordinateTypeT, dimension_t>> {
+ public:
+  typedef VectorD<CoordinateTypeT, dimension_t> PointD;
+  typedef CoordinateTypeT CoordinateType;
+
+  static constexpr uint32_t Dimension() { return dimension_t; }
+  static PointD Origin() {
+    PointD origin;
+    for (uint32_t i = 0; i < dimension_t; i++) {
+      origin(i) = 0;
+    }
+    return origin;
+  }
+  static std::array<uint32_t, dimension_t> ZeroArray() {
+    std::array<uint32_t, dimension_t> zero;
+    for (uint32_t i = 0; i < dimension_t; i++) {
+      zero[i] = 0;
+    }
+    return zero;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_POINT_CLOUD_TYPES_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/quantize_points_3.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/quantize_points_3.h
new file mode 100644
index 000000000..01943ad9e
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/quantize_points_3.h
@@ -0,0 +1,84 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_QUANTIZE_POINTS_3_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_QUANTIZE_POINTS_3_H_
+
+#include <inttypes.h>
+
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+#include "draco/core/quantization_utils.h"
+
+namespace draco {
+
+// TODO(hemmer): Make this a stable bounding box.
+struct QuantizationInfo {
+  uint32_t quantization_bits;
+  float range;
+};
+
+template <class PointIterator, class OutputIterator>
+OutputIterator QuantizePoints3(const PointIterator &begin,
+                               const PointIterator &end, QuantizationInfo *info,
+                               OutputIterator oit) {
+  DRACO_DCHECK_GE(info->quantization_bits, 0);
+
+  float max_range = 0;
+  for (auto it = begin; it != end; ++it) {
+    max_range = std::max(std::fabs((*it)[0]), max_range);
+    max_range = std::max(std::fabs((*it)[1]), max_range);
+    max_range = std::max(std::fabs((*it)[2]), max_range);
+  }
+
+  const uint32_t max_quantized_value((1 << info->quantization_bits) - 1);
+  Quantizer quantize;
+  quantize.Init(max_range, max_quantized_value);
+  info->range = max_range;
+
+  Point3ui qpoint;
+  for (auto it = begin; it != end; ++it) {
+    // Quantize and all positive.
+    qpoint[0] = quantize((*it)[0]) + max_quantized_value;
+    qpoint[1] = quantize((*it)[1]) + max_quantized_value;
+    qpoint[2] = quantize((*it)[2]) + max_quantized_value;
+    *oit++ = (qpoint);
+  }
+
+  return oit;
+}
+
+template <class QPointIterator, class OutputIterator>
+void DequantizePoints3(const QPointIterator &begin, const QPointIterator &end,
+                       const QuantizationInfo &info, OutputIterator &oit) {
+  DRACO_DCHECK_GE(info.quantization_bits, 0);
+  DRACO_DCHECK_GE(info.range, 0);
+
+  const uint32_t quantization_bits = info.quantization_bits;
+  const float range = info.range;
+  const uint32_t max_quantized_value((1 << quantization_bits) - 1);
+  Dequantizer dequantize;
+  dequantize.Init(range, max_quantized_value);
+
+  for (auto it = begin; it != end; ++it) {
+    const float x = dequantize((*it)[0] - max_quantized_value);
+    const float y = dequantize((*it)[1] - max_quantized_value);
+    const float z = dequantize((*it)[2] - max_quantized_value);
+    *oit = Point3f(x, y, z);
+    ++oit;
+  }
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_QUANTIZE_POINTS_3_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/queuing_policy.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/queuing_policy.h
new file mode 100644
index 000000000..2db0ea213
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/algorithms/queuing_policy.h
@@ -0,0 +1,75 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File defining a coherent interface for different queuing strategies.
+
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_QUEUING_POLICY_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_QUEUING_POLICY_H_
+
+#include <queue>
+#include <stack>
+#include <utility>
+
+namespace draco {
+
+template <class T>
+class Queue {
+ public:
+  bool empty() const { return q_.empty(); }
+  typename std::queue<T>::size_type size() const { return q_.size(); }
+  void clear() { return q_.clear(); }
+  void push(const T &value) { q_.push(value); }
+  void push(T &&value) { q_.push(std::move(value)); }
+  void pop() { q_.pop(); }
+  typename std::queue<T>::const_reference front() const { return q_.front(); }
+
+ private:
+  std::queue<T> q_;
+};
+
+template <class T>
+class Stack {
+ public:
+  bool empty() const { return s_.empty(); }
+  typename std::stack<T>::size_type size() const { return s_.size(); }
+  void clear() { return s_.clear(); }
+  void push(const T &value) { s_.push(value); }
+  void push(T &&value) { s_.push(std::move(value)); }
+  void pop() { s_.pop(); }
+  typename std::stack<T>::const_reference front() const { return s_.top(); }
+
+ private:
+  std::stack<T> s_;
+};
+
+template <class T, class Compare = std::less<T> >
+class PriorityQueue {
+  typedef std::priority_queue<T, std::vector<T>, Compare> QType;
+
+ public:
+  bool empty() const { return s_.empty(); }
+  typename QType::size_type size() const { return s_.size(); }
+  void clear() { return s_.clear(); }
+  void push(const T &value) { s_.push(value); }
+  void push(T &&value) { s_.push(std::move(value)); }
+  void pop() { s_.pop(); }
+  typename QType::const_reference front() const { return s_.top(); }
+
+ private:
+  QType s_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_QUEUING_POLICY_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_decoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_decoder.cc
new file mode 100644
index 000000000..85f7bc94e
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_decoder.cc
@@ -0,0 +1,199 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/point_cloud/point_cloud_decoder.h"
+
+#include "draco/metadata/metadata_decoder.h"
+
+namespace draco {
+
+PointCloudDecoder::PointCloudDecoder()
+    : point_cloud_(nullptr),
+      buffer_(nullptr),
+      version_major_(0),
+      version_minor_(0),
+      options_(nullptr) {}
+
+Status PointCloudDecoder::DecodeHeader(DecoderBuffer *buffer,
+                                       DracoHeader *out_header) {
+  constexpr char kIoErrorMsg[] = "Failed to parse Draco header.";
+  if (!buffer->Decode(out_header->draco_string, 5)) {
+    return Status(Status::IO_ERROR, kIoErrorMsg);
+  }
+  if (memcmp(out_header->draco_string, "DRACO", 5) != 0) {
+    return Status(Status::DRACO_ERROR, "Not a Draco file.");
+  }
+  if (!buffer->Decode(&(out_header->version_major))) {
+    return Status(Status::IO_ERROR, kIoErrorMsg);
+  }
+  if (!buffer->Decode(&(out_header->version_minor))) {
+    return Status(Status::IO_ERROR, kIoErrorMsg);
+  }
+  if (!buffer->Decode(&(out_header->encoder_type))) {
+    return Status(Status::IO_ERROR, kIoErrorMsg);
+  }
+  if (!buffer->Decode(&(out_header->encoder_method))) {
+    return Status(Status::IO_ERROR, kIoErrorMsg);
+  }
+  if (!buffer->Decode(&(out_header->flags))) {
+    return Status(Status::IO_ERROR, kIoErrorMsg);
+  }
+  return OkStatus();
+}
+
+Status PointCloudDecoder::DecodeMetadata() {
+  std::unique_ptr<GeometryMetadata> metadata =
+      std::unique_ptr<GeometryMetadata>(new GeometryMetadata());
+  MetadataDecoder metadata_decoder;
+  if (!metadata_decoder.DecodeGeometryMetadata(buffer_, metadata.get())) {
+    return Status(Status::DRACO_ERROR, "Failed to decode metadata.");
+  }
+  point_cloud_->AddMetadata(std::move(metadata));
+  return OkStatus();
+}
+
+Status PointCloudDecoder::Decode(const DecoderOptions &options,
+                                 DecoderBuffer *in_buffer,
+                                 PointCloud *out_point_cloud) {
+  options_ = &options;
+  buffer_ = in_buffer;
+  point_cloud_ = out_point_cloud;
+  DracoHeader header;
+  DRACO_RETURN_IF_ERROR(DecodeHeader(buffer_, &header))
+  // Sanity check that we are really using the right decoder (mostly for cases
+  // where the Decode method was called manually outside of our main API.
+  if (header.encoder_type != GetGeometryType()) {
+    return Status(Status::DRACO_ERROR,
+                  "Using incompatible decoder for the input geometry.");
+  }
+  // TODO(ostava): We should check the method as well, but currently decoders
+  // don't expose the decoding method id.
+  version_major_ = header.version_major;
+  version_minor_ = header.version_minor;
+
+  const uint8_t max_supported_major_version =
+      header.encoder_type == POINT_CLOUD ? kDracoPointCloudBitstreamVersionMajor
+                                         : kDracoMeshBitstreamVersionMajor;
+  const uint8_t max_supported_minor_version =
+      header.encoder_type == POINT_CLOUD ? kDracoPointCloudBitstreamVersionMinor
+                                         : kDracoMeshBitstreamVersionMinor;
+
+  // Check for version compatibility.
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (version_major_ < 1 || version_major_ > max_supported_major_version) {
+    return Status(Status::UNKNOWN_VERSION, "Unknown major version.");
+  }
+  if (version_major_ == max_supported_major_version &&
+      version_minor_ > max_supported_minor_version) {
+    return Status(Status::UNKNOWN_VERSION, "Unknown minor version.");
+  }
+#else
+  if (version_major_ != max_supported_major_version) {
+    return Status(Status::UNKNOWN_VERSION, "Unsupported major version.");
+  }
+  if (version_minor_ != max_supported_minor_version) {
+    return Status(Status::UNKNOWN_VERSION, "Unsupported minor version.");
+  }
+#endif
+  buffer_->set_bitstream_version(
+      DRACO_BITSTREAM_VERSION(version_major_, version_minor_));
+
+  if (bitstream_version() >= DRACO_BITSTREAM_VERSION(1, 3) &&
+      (header.flags & METADATA_FLAG_MASK)) {
+    DRACO_RETURN_IF_ERROR(DecodeMetadata())
+  }
+  if (!InitializeDecoder()) {
+    return Status(Status::DRACO_ERROR, "Failed to initialize the decoder.");
+  }
+  if (!DecodeGeometryData()) {
+    return Status(Status::DRACO_ERROR, "Failed to decode geometry data.");
+  }
+  if (!DecodePointAttributes()) {
+    return Status(Status::DRACO_ERROR, "Failed to decode point attributes.");
+  }
+  return OkStatus();
+}
+
+bool PointCloudDecoder::DecodePointAttributes() {
+  uint8_t num_attributes_decoders;
+  if (!buffer_->Decode(&num_attributes_decoders)) {
+    return false;
+  }
+  // Create all attribute decoders. This is implementation specific and the
+  // derived classes can use any data encoded in the
+  // PointCloudEncoder::EncodeAttributesEncoderIdentifier() call.
+  for (int i = 0; i < num_attributes_decoders; ++i) {
+    if (!CreateAttributesDecoder(i)) {
+      return false;
+    }
+  }
+
+  // Initialize all attributes decoders. No data is decoded here.
+  for (auto &att_dec : attributes_decoders_) {
+    if (!att_dec->Init(this, point_cloud_)) {
+      return false;
+    }
+  }
+
+  // Decode any data needed by the attribute decoders.
+  for (int i = 0; i < num_attributes_decoders; ++i) {
+    if (!attributes_decoders_[i]->DecodeAttributesDecoderData(buffer_)) {
+      return false;
+    }
+  }
+
+  // Create map between attribute and decoder ids.
+  for (int i = 0; i < num_attributes_decoders; ++i) {
+    const int32_t num_attributes = attributes_decoders_[i]->GetNumAttributes();
+    for (int j = 0; j < num_attributes; ++j) {
+      int att_id = attributes_decoders_[i]->GetAttributeId(j);
+      if (att_id >= attribute_to_decoder_map_.size()) {
+        attribute_to_decoder_map_.resize(att_id + 1);
+      }
+      attribute_to_decoder_map_[att_id] = i;
+    }
+  }
+
+  // Decode the actual attributes using the created attribute decoders.
+  if (!DecodeAllAttributes()) {
+    return false;
+  }
+
+  if (!OnAttributesDecoded()) {
+    return false;
+  }
+  return true;
+}
+
+bool PointCloudDecoder::DecodeAllAttributes() {
+  for (auto &att_dec : attributes_decoders_) {
+    if (!att_dec->DecodeAttributes(buffer_)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+const PointAttribute *PointCloudDecoder::GetPortableAttribute(
+    int32_t parent_att_id) {
+  if (parent_att_id < 0 || parent_att_id >= point_cloud_->num_attributes()) {
+    return nullptr;
+  }
+  const int32_t parent_att_decoder_id =
+      attribute_to_decoder_map_[parent_att_id];
+  return attributes_decoders_[parent_att_decoder_id]->GetPortableAttribute(
+      parent_att_id);
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_decoder.h
new file mode 100644
index 000000000..4af7f5cd3
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_decoder.h
@@ -0,0 +1,118 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_DECODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_DECODER_H_
+
+#include "draco/compression/attributes/attributes_decoder_interface.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/config/decoder_options.h"
+#include "draco/core/status.h"
+#include "draco/point_cloud/point_cloud.h"
+
+namespace draco {
+
+// Abstract base class for all point cloud and mesh decoders. It provides a
+// basic functionality that is shared between different decoders.
+class PointCloudDecoder {
+ public:
+  PointCloudDecoder();
+  virtual ~PointCloudDecoder() = default;
+
+  virtual EncodedGeometryType GetGeometryType() const { return POINT_CLOUD; }
+
+  // Decodes a Draco header int other provided |out_header|.
+  // Returns false on error.
+  static Status DecodeHeader(DecoderBuffer *buffer, DracoHeader *out_header);
+
+  // The main entry point for point cloud decoding.
+  Status Decode(const DecoderOptions &options, DecoderBuffer *in_buffer,
+                PointCloud *out_point_cloud);
+
+  bool SetAttributesDecoder(
+      int att_decoder_id, std::unique_ptr<AttributesDecoderInterface> decoder) {
+    if (att_decoder_id < 0) {
+      return false;
+    }
+    if (att_decoder_id >= static_cast<int>(attributes_decoders_.size())) {
+      attributes_decoders_.resize(att_decoder_id + 1);
+    }
+    attributes_decoders_[att_decoder_id] = std::move(decoder);
+    return true;
+  }
+
+  // Returns an attribute containing decoded data in their portable form that
+  // is guaranteed to be the same for both encoder and decoder. I.e., it returns
+  // an attribute before it was transformed back into its final form which may
+  // be slightly different (non-portable) across platforms. For example, for
+  // attributes encoded with quantization, this method returns an attribute
+  // that contains the quantized values (before the dequantization step).
+  const PointAttribute *GetPortableAttribute(int32_t point_attribute_id);
+
+  uint16_t bitstream_version() const {
+    return DRACO_BITSTREAM_VERSION(version_major_, version_minor_);
+  }
+
+  const AttributesDecoderInterface *attributes_decoder(int dec_id) {
+    return attributes_decoders_[dec_id].get();
+  }
+  int32_t num_attributes_decoders() const {
+    return static_cast<int32_t>(attributes_decoders_.size());
+  }
+
+  // Get a mutable pointer to the decoded point cloud. This is intended to be
+  // used mostly by other decoder subsystems.
+  PointCloud *point_cloud() { return point_cloud_; }
+  const PointCloud *point_cloud() const { return point_cloud_; }
+
+  DecoderBuffer *buffer() { return buffer_; }
+  const DecoderOptions *options() const { return options_; }
+
+ protected:
+  // Can be implemented by derived classes to perform any custom initialization
+  // of the decoder. Called in the Decode() method.
+  virtual bool InitializeDecoder() { return true; }
+
+  // Creates an attribute decoder.
+  virtual bool CreateAttributesDecoder(int32_t att_decoder_id) = 0;
+  virtual bool DecodeGeometryData() { return true; }
+  virtual bool DecodePointAttributes();
+
+  virtual bool DecodeAllAttributes();
+  virtual bool OnAttributesDecoded() { return true; }
+
+  Status DecodeMetadata();
+
+ private:
+  // Point cloud that is being filled in by the decoder.
+  PointCloud *point_cloud_;
+
+  std::vector<std::unique_ptr<AttributesDecoderInterface>> attributes_decoders_;
+
+  // Map between attribute id and decoder id.
+  std::vector<int32_t> attribute_to_decoder_map_;
+
+  // Input buffer holding the encoded data.
+  DecoderBuffer *buffer_;
+
+  // Bit-stream version of the encoder that encoded the input data.
+  uint8_t version_major_;
+  uint8_t version_minor_;
+
+  const DecoderOptions *options_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_encoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_encoder.cc
new file mode 100644
index 000000000..a1fda8d5a
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_encoder.cc
@@ -0,0 +1,306 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/point_cloud/point_cloud_encoder.h"
+
+#include "draco/metadata/metadata_encoder.h"
+
+namespace draco {
+
+PointCloudEncoder::PointCloudEncoder()
+    : point_cloud_(nullptr), buffer_(nullptr), num_encoded_points_(0) {}
+
+void PointCloudEncoder::SetPointCloud(const PointCloud &pc) {
+  point_cloud_ = &pc;
+}
+
+Status PointCloudEncoder::Encode(const EncoderOptions &options,
+                                 EncoderBuffer *out_buffer) {
+  options_ = &options;
+  buffer_ = out_buffer;
+
+  // Cleanup from previous runs.
+  attributes_encoders_.clear();
+  attribute_to_encoder_map_.clear();
+  attributes_encoder_ids_order_.clear();
+
+  if (!point_cloud_) {
+    return Status(Status::DRACO_ERROR, "Invalid input geometry.");
+  }
+  DRACO_RETURN_IF_ERROR(EncodeHeader())
+  DRACO_RETURN_IF_ERROR(EncodeMetadata())
+  if (!InitializeEncoder()) {
+    return Status(Status::DRACO_ERROR, "Failed to initialize encoder.");
+  }
+  if (!EncodeEncoderData()) {
+    return Status(Status::DRACO_ERROR, "Failed to encode internal data.");
+  }
+  DRACO_RETURN_IF_ERROR(EncodeGeometryData());
+  if (!EncodePointAttributes()) {
+    return Status(Status::DRACO_ERROR, "Failed to encode point attributes.");
+  }
+  if (options.GetGlobalBool("store_number_of_encoded_points", false)) {
+    ComputeNumberOfEncodedPoints();
+  }
+  return OkStatus();
+}
+
+Status PointCloudEncoder::EncodeHeader() {
+  // Encode the header according to our v1 specification.
+  // Five bytes for Draco format.
+  buffer_->Encode("DRACO", 5);
+  // Version (major, minor).
+  const uint8_t encoder_type = GetGeometryType();
+  uint8_t version_major, version_minor;
+  version_major = encoder_type == POINT_CLOUD
+                      ? kDracoPointCloudBitstreamVersionMajor
+                      : kDracoMeshBitstreamVersionMajor;
+  version_minor = encoder_type == POINT_CLOUD
+                      ? kDracoPointCloudBitstreamVersionMinor
+                      : kDracoMeshBitstreamVersionMinor;
+
+  buffer_->Encode(version_major);
+  buffer_->Encode(version_minor);
+  // Type of the encoder (point cloud, mesh, ...).
+  buffer_->Encode(encoder_type);
+  // Unique identifier for the selected encoding method (edgebreaker, etc...).
+  buffer_->Encode(GetEncodingMethod());
+  // Reserved for flags.
+  uint16_t flags = 0;
+  // First bit of |flags| is reserved for metadata.
+  if (point_cloud_->GetMetadata()) {
+    flags |= METADATA_FLAG_MASK;
+  }
+  buffer_->Encode(flags);
+  return OkStatus();
+}
+
+Status PointCloudEncoder::EncodeMetadata() {
+  if (!point_cloud_->GetMetadata()) {
+    return OkStatus();
+  }
+  MetadataEncoder metadata_encoder;
+  if (!metadata_encoder.EncodeGeometryMetadata(buffer_,
+                                               point_cloud_->GetMetadata())) {
+    return Status(Status::DRACO_ERROR, "Failed to encode metadata.");
+  }
+  return OkStatus();
+}
+
+bool PointCloudEncoder::EncodePointAttributes() {
+  if (!GenerateAttributesEncoders()) {
+    return false;
+  }
+
+  // Encode the number of attribute encoders.
+  buffer_->Encode(static_cast<uint8_t>(attributes_encoders_.size()));
+
+  // Initialize all the encoders (this is used for example to init attribute
+  // dependencies, no data is encoded in this step).
+  for (auto &att_enc : attributes_encoders_) {
+    if (!att_enc->Init(this, point_cloud_)) {
+      return false;
+    }
+  }
+
+  // Rearrange attributes to respect dependencies between individual attributes.
+  if (!RearrangeAttributesEncoders()) {
+    return false;
+  }
+
+  // Encode any data that is necessary to create the corresponding attribute
+  // decoder.
+  for (int att_encoder_id : attributes_encoder_ids_order_) {
+    if (!EncodeAttributesEncoderIdentifier(att_encoder_id)) {
+      return false;
+    }
+  }
+
+  // Also encode any attribute encoder data (such as the info about encoded
+  // attributes).
+  for (int att_encoder_id : attributes_encoder_ids_order_) {
+    if (!attributes_encoders_[att_encoder_id]->EncodeAttributesEncoderData(
+            buffer_)) {
+      return false;
+    }
+  }
+
+  // Lastly encode all the attributes using the provided attribute encoders.
+  if (!EncodeAllAttributes()) {
+    return false;
+  }
+  return true;
+}
+
+bool PointCloudEncoder::GenerateAttributesEncoders() {
+  for (int i = 0; i < point_cloud_->num_attributes(); ++i) {
+    if (!GenerateAttributesEncoder(i)) {
+      return false;
+    }
+  }
+  attribute_to_encoder_map_.resize(point_cloud_->num_attributes());
+  for (uint32_t i = 0; i < attributes_encoders_.size(); ++i) {
+    for (uint32_t j = 0; j < attributes_encoders_[i]->num_attributes(); ++j) {
+      attribute_to_encoder_map_[attributes_encoders_[i]->GetAttributeId(j)] = i;
+    }
+  }
+  return true;
+}
+
+bool PointCloudEncoder::EncodeAllAttributes() {
+  for (int att_encoder_id : attributes_encoder_ids_order_) {
+    if (!attributes_encoders_[att_encoder_id]->EncodeAttributes(buffer_)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool PointCloudEncoder::MarkParentAttribute(int32_t parent_att_id) {
+  if (parent_att_id < 0 || parent_att_id >= point_cloud_->num_attributes()) {
+    return false;
+  }
+  const int32_t parent_att_encoder_id =
+      attribute_to_encoder_map_[parent_att_id];
+  if (!attributes_encoders_[parent_att_encoder_id]->MarkParentAttribute(
+          parent_att_id)) {
+    return false;
+  }
+  return true;
+}
+
+const PointAttribute *PointCloudEncoder::GetPortableAttribute(
+    int32_t parent_att_id) {
+  if (parent_att_id < 0 || parent_att_id >= point_cloud_->num_attributes()) {
+    return nullptr;
+  }
+  const int32_t parent_att_encoder_id =
+      attribute_to_encoder_map_[parent_att_id];
+  return attributes_encoders_[parent_att_encoder_id]->GetPortableAttribute(
+      parent_att_id);
+}
+
+bool PointCloudEncoder::RearrangeAttributesEncoders() {
+  // Find the encoding order of the attribute encoders that is determined by
+  // the parent dependencies between individual encoders. Instead of traversing
+  // a graph we encode the attributes in multiple iterations where encoding of
+  // attributes that depend on other attributes may get postponed until the
+  // parent attributes are processed.
+  // This is simpler to implement than graph traversal and it automatically
+  // detects any cycles in the dependency graph.
+  // TODO(ostava): Current implementation needs to encode all attributes of a
+  // single encoder to be encoded in a single "chunk", therefore we need to sort
+  // attribute encoders before we sort individual attributes. This requirement
+  // can be lifted for encoders that can encode individual attributes separately
+  // but it will require changes in the current API.
+  attributes_encoder_ids_order_.resize(attributes_encoders_.size());
+  std::vector<bool> is_encoder_processed(attributes_encoders_.size(), false);
+  uint32_t num_processed_encoders = 0;
+  while (num_processed_encoders < attributes_encoders_.size()) {
+    // Flagged when any of the encoder get processed.
+    bool encoder_processed = false;
+    for (uint32_t i = 0; i < attributes_encoders_.size(); ++i) {
+      if (is_encoder_processed[i]) {
+        continue;  // Encoder already processed.
+      }
+      // Check if all parent encoders are already processed.
+      bool can_be_processed = true;
+      for (uint32_t p = 0; p < attributes_encoders_[i]->num_attributes(); ++p) {
+        const int32_t att_id = attributes_encoders_[i]->GetAttributeId(p);
+        for (int ap = 0;
+             ap < attributes_encoders_[i]->NumParentAttributes(att_id); ++ap) {
+          const uint32_t parent_att_id =
+              attributes_encoders_[i]->GetParentAttributeId(att_id, ap);
+          const int32_t parent_encoder_id =
+              attribute_to_encoder_map_[parent_att_id];
+          if (parent_att_id != i && !is_encoder_processed[parent_encoder_id]) {
+            can_be_processed = false;
+            break;
+          }
+        }
+      }
+      if (!can_be_processed) {
+        continue;  // Try to process the encoder in the next iteration.
+      }
+      // Encoder can be processed. Update the encoding order.
+      attributes_encoder_ids_order_[num_processed_encoders++] = i;
+      is_encoder_processed[i] = true;
+      encoder_processed = true;
+    }
+    if (!encoder_processed &&
+        num_processed_encoders < attributes_encoders_.size()) {
+      // No encoder was processed but there are still some remaining unprocessed
+      // encoders.
+      return false;
+    }
+  }
+
+  // Now for every encoder, reorder the attributes to satisfy their
+  // dependencies (an attribute may still depend on other attributes within an
+  // encoder).
+  std::vector<int32_t> attribute_encoding_order;
+  std::vector<bool> is_attribute_processed(point_cloud_->num_attributes(),
+                                           false);
+  int num_processed_attributes;
+  for (uint32_t ae_order = 0; ae_order < attributes_encoders_.size();
+       ++ae_order) {
+    const int ae = attributes_encoder_ids_order_[ae_order];
+    const int32_t num_encoder_attributes =
+        attributes_encoders_[ae]->num_attributes();
+    if (num_encoder_attributes < 2) {
+      continue;  // No need to resolve dependencies for a single attribute.
+    }
+    num_processed_attributes = 0;
+    attribute_encoding_order.resize(num_encoder_attributes);
+    while (num_processed_attributes < num_encoder_attributes) {
+      // Flagged when any of the attributes get processed.
+      bool attribute_processed = false;
+      for (int i = 0; i < num_encoder_attributes; ++i) {
+        const int32_t att_id = attributes_encoders_[ae]->GetAttributeId(i);
+        if (is_attribute_processed[i]) {
+          continue;  // Attribute already processed.
+        }
+        // Check if all parent attributes are already processed.
+        bool can_be_processed = true;
+        for (int p = 0;
+             p < attributes_encoders_[ae]->NumParentAttributes(att_id); ++p) {
+          const int32_t parent_att_id =
+              attributes_encoders_[ae]->GetParentAttributeId(att_id, p);
+          if (!is_attribute_processed[parent_att_id]) {
+            can_be_processed = false;
+            break;
+          }
+        }
+        if (!can_be_processed) {
+          continue;  // Try to process the attribute in the next iteration.
+        }
+        // Attribute can be processed. Update the encoding order.
+        attribute_encoding_order[num_processed_attributes++] = i;
+        is_attribute_processed[i] = true;
+        attribute_processed = true;
+      }
+      if (!attribute_processed &&
+          num_processed_attributes < num_encoder_attributes) {
+        // No attribute was processed but there are still some remaining
+        // unprocessed attributes.
+        return false;
+      }
+    }
+    // Update the order of the attributes within the encoder.
+    attributes_encoders_[ae]->SetAttributeIds(attribute_encoding_order);
+  }
+  return true;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_encoder.h
new file mode 100644
index 000000000..8883f17a7
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_encoder.h
@@ -0,0 +1,158 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_ENCODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_ENCODER_H_
+
+#include "draco/compression/attributes/attributes_encoder.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/config/encoder_options.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/status.h"
+#include "draco/point_cloud/point_cloud.h"
+
+namespace draco {
+
+// Abstract base class for all point cloud and mesh encoders. It provides a
+// basic functionality that's shared between different encoders.
+class PointCloudEncoder {
+ public:
+  PointCloudEncoder();
+  virtual ~PointCloudEncoder() = default;
+
+  // Sets the point cloud that is going be encoded. Must be called before the
+  // Encode() method.
+  void SetPointCloud(const PointCloud &pc);
+
+  // The main entry point that encodes provided point cloud.
+  Status Encode(const EncoderOptions &options, EncoderBuffer *out_buffer);
+
+  virtual EncodedGeometryType GetGeometryType() const { return POINT_CLOUD; }
+
+  // Returns the unique identifier of the encoding method (such as Edgebreaker
+  // for mesh compression).
+  virtual uint8_t GetEncodingMethod() const = 0;
+
+  // Returns the number of points that were encoded during the last Encode()
+  // function call. Valid only if "store_number_of_encoded_points" flag was set
+  // in the provided EncoderOptions.
+  size_t num_encoded_points() const { return num_encoded_points_; }
+
+  int num_attributes_encoders() const {
+    return static_cast<int>(attributes_encoders_.size());
+  }
+  AttributesEncoder *attributes_encoder(int i) {
+    return attributes_encoders_[i].get();
+  }
+
+  // Adds a new attribute encoder, returning its id.
+  int AddAttributesEncoder(std::unique_ptr<AttributesEncoder> att_enc) {
+    attributes_encoders_.push_back(std::move(att_enc));
+    return static_cast<int>(attributes_encoders_.size() - 1);
+  }
+
+  // Marks one attribute as a parent of another attribute. Must be called after
+  // all attribute encoders are created (usually in the
+  // AttributeEncoder::Init() method).
+  bool MarkParentAttribute(int32_t parent_att_id);
+
+  // Returns an attribute containing portable version of the attribute data that
+  // is guaranteed to be encoded losslessly. This attribute can be used safely
+  // as predictor for other attributes.
+  const PointAttribute *GetPortableAttribute(int32_t point_attribute_id);
+
+  EncoderBuffer *buffer() { return buffer_; }
+  const EncoderOptions *options() const { return options_; }
+  const PointCloud *point_cloud() const { return point_cloud_; }
+
+ protected:
+  // Can be implemented by derived classes to perform any custom initialization
+  // of the encoder. Called in the Encode() method.
+  virtual bool InitializeEncoder() { return true; }
+
+  // Should be used to encode any encoder-specific data.
+  virtual bool EncodeEncoderData() { return true; }
+
+  // Encodes any global geometry data (such as the number of points).
+  virtual Status EncodeGeometryData() { return OkStatus(); }
+
+  // encode all attribute values. The attribute encoders are sorted to resolve
+  // any attribute dependencies and all the encoded data is stored into the
+  // |buffer_|.
+  // Returns false if the encoding failed.
+  virtual bool EncodePointAttributes();
+
+  // Generate attribute encoders that are going to be used for encoding
+  // point attribute data. Calls GenerateAttributesEncoder() for every attribute
+  // of the encoded PointCloud.
+  virtual bool GenerateAttributesEncoders();
+
+  // Creates attribute encoder for a specific point attribute. This function
+  // needs to be implemented by the derived classes. The derived classes need
+  // to either 1. Create a new attribute encoder and add it using the
+  // AddAttributeEncoder method, or 2. add the attribute to an existing
+  // attribute encoder (using AttributesEncoder::AddAttributeId() method).
+  virtual bool GenerateAttributesEncoder(int32_t att_id) = 0;
+
+  // Encodes any data that is necessary to recreate a given attribute encoder.
+  // Note: this is called in order in which the attribute encoders are going to
+  // be encoded.
+  virtual bool EncodeAttributesEncoderIdentifier(int32_t /* att_encoder_id */) {
+    return true;
+  }
+
+  // Encodes all the attribute data using the created attribute encoders.
+  virtual bool EncodeAllAttributes();
+
+  // Computes and sets the num_encoded_points_ for the encoder.
+  virtual void ComputeNumberOfEncodedPoints() = 0;
+
+  void set_num_encoded_points(size_t num_points) {
+    num_encoded_points_ = num_points;
+  }
+
+ private:
+  // Encodes Draco header that is the same for all encoders.
+  Status EncodeHeader();
+
+  // Encode metadata.
+  Status EncodeMetadata();
+
+  // Rearranges attribute encoders and their attributes to reflect the
+  // underlying attribute dependencies. This ensures that the attributes are
+  // encoded in the correct order (parent attributes before their children).
+  bool RearrangeAttributesEncoders();
+
+  const PointCloud *point_cloud_;
+  std::vector<std::unique_ptr<AttributesEncoder>> attributes_encoders_;
+
+  // Map between attribute id and encoder id.
+  std::vector<int32_t> attribute_to_encoder_map_;
+
+  // Encoding order of individual attribute encoders (i.e., the order in which
+  // they are processed during encoding that may be different from the order
+  // in which they were created because of attribute dependencies.
+  std::vector<int32_t> attributes_encoder_ids_order_;
+
+  // This buffer holds the final encoded data.
+  EncoderBuffer *buffer_;
+
+  const EncoderOptions *options_;
+
+  size_t num_encoded_points_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_decoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_decoder.cc
new file mode 100644
index 000000000..2deebbc48
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_decoder.cc
@@ -0,0 +1,40 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/point_cloud/point_cloud_kd_tree_decoder.h"
+
+#include "draco/compression/attributes/kd_tree_attributes_decoder.h"
+
+namespace draco {
+
+bool PointCloudKdTreeDecoder::DecodeGeometryData() {
+  int32_t num_points;
+  if (!buffer()->Decode(&num_points)) {
+    return false;
+  }
+  if (num_points < 0) {
+    return false;
+  }
+  point_cloud()->set_num_points(num_points);
+  return true;
+}
+
+bool PointCloudKdTreeDecoder::CreateAttributesDecoder(int32_t att_decoder_id) {
+  // Always create the basic attribute decoder.
+  return SetAttributesDecoder(
+      att_decoder_id,
+      std::unique_ptr<AttributesDecoder>(new KdTreeAttributesDecoder()));
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_decoder.h
new file mode 100644
index 000000000..6e192f2a5
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_decoder.h
@@ -0,0 +1,31 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_KD_TREE_DECODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_KD_TREE_DECODER_H_
+
+#include "draco/compression/point_cloud/point_cloud_decoder.h"
+
+namespace draco {
+
+// Decodes PointCloud encoded with the PointCloudKdTreeEncoder.
+class PointCloudKdTreeDecoder : public PointCloudDecoder {
+ protected:
+  bool DecodeGeometryData() override;
+  bool CreateAttributesDecoder(int32_t att_decoder_id) override;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_KD_TREE_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_encoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_encoder.cc
new file mode 100644
index 000000000..92b6c84cd
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_encoder.cc
@@ -0,0 +1,43 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/point_cloud/point_cloud_kd_tree_encoder.h"
+
+#include "draco/compression/attributes/kd_tree_attributes_encoder.h"
+
+namespace draco {
+
+Status PointCloudKdTreeEncoder::EncodeGeometryData() {
+  const int32_t num_points = point_cloud()->num_points();
+  buffer()->Encode(num_points);
+  return OkStatus();
+}
+
+bool PointCloudKdTreeEncoder::GenerateAttributesEncoder(int32_t att_id) {
+  if (num_attributes_encoders() == 0) {
+    // Create a new attribute encoder only for the first attribute.
+    AddAttributesEncoder(std::unique_ptr<AttributesEncoder>(
+        new KdTreeAttributesEncoder(att_id)));
+    return true;
+  }
+  // Add a new attribute to the attribute encoder.
+  attributes_encoder(0)->AddAttributeId(att_id);
+  return true;
+}
+
+void PointCloudKdTreeEncoder::ComputeNumberOfEncodedPoints() {
+  set_num_encoded_points(point_cloud()->num_points());
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_encoder.h
new file mode 100644
index 000000000..6acbb949d
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_encoder.h
@@ -0,0 +1,45 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_KD_TREE_ENCODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_KD_TREE_ENCODER_H_
+
+#include "draco/compression/point_cloud/point_cloud_encoder.h"
+
+namespace draco {
+
+// Encodes a PointCloud using one of the available Kd-tree compression methods.
+// See FloatPointsKdTreeEncoder and DynamicIntegerPointsKdTreeEncoder for more
+// details. Currently, the input PointCloud must satisfy the following
+// requirements to use this encoder:
+//  1. PointCloud has only one attribute of type GeometryAttribute::POSITION.
+//  2. The position attribute has three components (x,y,z).
+//  3. The position values are stored as either DT_FLOAT32 or DT_UINT32.
+//  4. If the position values are stored as DT_FLOAT32, quantization needs to
+//     be enabled for the position attribute.
+class PointCloudKdTreeEncoder : public PointCloudEncoder {
+ public:
+  uint8_t GetEncodingMethod() const override {
+    return POINT_CLOUD_KD_TREE_ENCODING;
+  }
+
+ protected:
+  Status EncodeGeometryData() override;
+  bool GenerateAttributesEncoder(int32_t att_id) override;
+  void ComputeNumberOfEncodedPoints() override;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_KD_TREE_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_encoding_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_encoding_test.cc
new file mode 100644
index 000000000..2249bb09e
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_encoding_test.cc
@@ -0,0 +1,458 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/point_cloud/point_cloud_kd_tree_decoder.h"
+#include "draco/compression/point_cloud/point_cloud_kd_tree_encoder.h"
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+#include "draco/core/vector_d.h"
+#include "draco/io/obj_decoder.h"
+#include "draco/point_cloud/point_cloud_builder.h"
+
+namespace draco {
+
+class PointCloudKdTreeEncodingTest : public ::testing::Test {
+ protected:
+  void ComparePointClouds(const PointCloud &p0, const PointCloud &p1) const {
+    ASSERT_EQ(p0.num_points(), p1.num_points());
+    ASSERT_EQ(p0.num_attributes(), p1.num_attributes());
+    // Currently works only with one attribute.
+    ASSERT_EQ(p0.num_attributes(), p1.num_attributes());
+    for (auto index = 0; index < p0.num_attributes(); index += 1) {
+      ASSERT_EQ(p0.attribute(index)->num_components(),
+                p1.attribute(index)->num_components());
+      std::vector<double> points_0, points_1;
+      std::vector<double> att_entry_0(p0.attribute(index)->num_components());
+      std::vector<double> att_entry_1(p0.attribute(index)->num_components());
+      for (PointIndex i(0); i < p0.num_points(); ++i) {
+        p0.attribute(index)->ConvertValue(p0.attribute(index)->mapped_index(i),
+                                          &att_entry_0[0]);
+        p1.attribute(index)->ConvertValue(p1.attribute(index)->mapped_index(i),
+                                          &att_entry_1[0]);
+        for (int d = 0; d < p0.attribute(index)->num_components(); ++d) {
+          points_0.push_back(att_entry_0[d]);
+          points_1.push_back(att_entry_1[d]);
+        }
+      }
+      // To compare the point clouds we sort points components from both inputs
+      // separately, and then we compare all matching coordinates one by one.
+      // TODO(ostava): Note that this is not guaranteed to work for quantized
+      // point clouds because the order of points may actually change because
+      // of the quantization. The test should be make more robust to handle such
+      // case.
+      std::sort(points_0.begin(), points_0.end());
+      std::sort(points_1.begin(), points_1.end());
+      for (uint32_t i = 0; i < points_0.size(); ++i) {
+        ASSERT_LE(std::fabs(points_0[i] - points_1[i]), 1e-2);
+      }
+    }
+  }
+
+  void TestKdTreeEncoding(const PointCloud &pc) {
+    EncoderBuffer buffer;
+    PointCloudKdTreeEncoder encoder;
+    EncoderOptions options = EncoderOptions::CreateDefaultOptions();
+    options.SetGlobalInt("quantization_bits", 16);
+    for (int compression_level = 0; compression_level <= 6;
+         ++compression_level) {
+      options.SetSpeed(10 - compression_level, 10 - compression_level);
+      encoder.SetPointCloud(pc);
+      ASSERT_TRUE(encoder.Encode(options, &buffer).ok());
+
+      DecoderBuffer dec_buffer;
+      dec_buffer.Init(buffer.data(), buffer.size());
+      PointCloudKdTreeDecoder decoder;
+
+      std::unique_ptr<PointCloud> out_pc(new PointCloud());
+      DecoderOptions dec_options;
+      ASSERT_TRUE(decoder.Decode(dec_options, &dec_buffer, out_pc.get()).ok());
+
+      ComparePointClouds(pc, *out_pc);
+    }
+  }
+
+  void TestFloatEncoding(const std::string &file_name) {
+    std::unique_ptr<PointCloud> pc = ReadPointCloudFromTestFile(file_name);
+    ASSERT_NE(pc, nullptr);
+
+    TestKdTreeEncoding(*pc);
+  }
+};
+
+TEST_F(PointCloudKdTreeEncodingTest, TestFloatKdTreeEncoding) {
+  TestFloatEncoding("cube_subd.obj");
+}
+
+TEST_F(PointCloudKdTreeEncodingTest, TestIntKdTreeEncoding) {
+  constexpr int num_points = 120;
+  std::vector<std::array<uint32_t, 3>> points(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<uint32_t, 3> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 127);
+    pos[1] = 13 * ((i * 3) % 321);
+    pos[2] = 29 * ((i * 19) % 450);
+    points[i] = pos;
+  }
+
+  PointCloudBuilder builder;
+  builder.Start(num_points);
+  const int att_id =
+      builder.AddAttribute(GeometryAttribute::POSITION, 3, DT_UINT32);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id, PointIndex(i),
+                                      &(points[i.value()])[0]);
+  }
+  std::unique_ptr<PointCloud> pc = builder.Finalize(false);
+  ASSERT_NE(pc, nullptr);
+
+  TestKdTreeEncoding(*pc);
+}
+
+// test higher dimensions with more attributes
+TEST_F(PointCloudKdTreeEncodingTest, TestIntKdTreeEncodingHigherDimension) {
+  constexpr int num_points = 120;
+  std::vector<std::array<uint32_t, 3>> points3(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<uint32_t, 3> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 127);
+    pos[1] = 13 * ((i * 3) % 321);
+    pos[2] = 29 * ((i * 19) % 450);
+    points3[i] = pos;
+  }
+  std::vector<std::array<uint32_t, 2>> points2(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<uint32_t, 2> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 127) + 1;
+    pos[1] = 13 * ((i * 3) % 321) + 1;
+    points2[i] = pos;
+  }
+  std::vector<std::array<uint32_t, 1>> points1(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<uint32_t, 1> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 127) + 11;
+    points1[i] = pos;
+  }
+
+  PointCloudBuilder builder;
+  builder.Start(num_points);
+  const int att_id3 =
+      builder.AddAttribute(GeometryAttribute::POSITION, 3, DT_UINT32);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id3, PointIndex(i),
+                                      &(points3[i.value()])[0]);
+  }
+  const int att_id2 =
+      builder.AddAttribute(GeometryAttribute::POSITION, 2, DT_UINT32);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id2, PointIndex(i),
+                                      &(points2[i.value()])[0]);
+  }
+  const int att_id1 =
+      builder.AddAttribute(GeometryAttribute::GENERIC, 1, DT_UINT32);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id1, PointIndex(i),
+                                      &(points1[i.value()])[0]);
+  }
+
+  std::unique_ptr<PointCloud> pc = builder.Finalize(false);
+  ASSERT_NE(pc, nullptr);
+
+  TestKdTreeEncoding(*pc);
+}
+
+// Test 16 and 8 bit encoding.
+TEST_F(PointCloudKdTreeEncodingTest,
+       TestIntKdTreeEncodingHigherDimensionVariedTypes) {
+  constexpr int num_points = 120;
+  std::vector<std::array<uint32_t, 3>> points3(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<uint32_t, 3> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 127);
+    pos[1] = 13 * ((i * 3) % 321);
+    pos[2] = 29 * ((i * 19) % 450);
+    points3[i] = pos;
+  }
+  std::vector<std::array<uint16_t, 2>> points2(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<uint16_t, 2> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 127) + 1;
+    pos[1] = 13 * ((i * 3) % 321) + 1;
+    points2[i] = pos;
+  }
+  std::vector<std::array<uint8_t, 1>> points1(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<uint8_t, 1> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 127) + 11;
+    points1[i] = pos;
+  }
+
+  PointCloudBuilder builder;
+  builder.Start(num_points);
+  const int att_id3 =
+      builder.AddAttribute(GeometryAttribute::POSITION, 3, DT_UINT32);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id3, PointIndex(i),
+                                      &(points3[i.value()])[0]);
+  }
+  const int att_id2 =
+      builder.AddAttribute(GeometryAttribute::POSITION, 2, DT_UINT16);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id2, PointIndex(i),
+                                      &(points2[i.value()])[0]);
+  }
+  const int att_id1 =
+      builder.AddAttribute(GeometryAttribute::GENERIC, 1, DT_UINT8);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id1, PointIndex(i),
+                                      &(points1[i.value()])[0]);
+  }
+
+  std::unique_ptr<PointCloud> pc = builder.Finalize(false);
+  ASSERT_NE(pc, nullptr);
+
+  TestKdTreeEncoding(*pc);
+}
+
+// Test 16 only encoding for one attribute.
+TEST_F(PointCloudKdTreeEncodingTest, TestIntKdTreeEncoding16Bit) {
+  constexpr int num_points = 120;
+  std::vector<std::array<uint16_t, 3>> points3(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<uint16_t, 3> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 127);
+    pos[1] = 13 * ((i * 3) % 321);
+    pos[2] = 29 * ((i * 19) % 450);
+    points3[i] = pos;
+  }
+
+  PointCloudBuilder builder;
+  builder.Start(num_points);
+  const int att_id3 =
+      builder.AddAttribute(GeometryAttribute::POSITION, 3, DT_UINT16);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id3, PointIndex(i),
+                                      &(points3[i.value()])[0]);
+  }
+
+  std::unique_ptr<PointCloud> pc = builder.Finalize(false);
+  ASSERT_NE(pc, nullptr);
+
+  TestKdTreeEncoding(*pc);
+}
+
+// Test 16 and 8 bit encoding with size bigger than 32bit encoding.
+TEST_F(PointCloudKdTreeEncodingTest,
+       TestIntKdTreeEncodingHigherDimensionVariedTypesBig16BitEncoding) {
+  constexpr int num_points = 120;
+  std::vector<std::array<uint32_t, 3>> points3(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<uint32_t, 3> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 127);
+    pos[1] = 13 * ((i * 3) % 321);
+    pos[2] = 29 * ((i * 19) % 450);
+    points3[i] = pos;
+  }
+  // The total size of the 16bit encoding must be bigger than the total size of
+  // the 32bit encoding.
+  std::vector<std::array<uint16_t, 7>> points7(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<uint16_t, 7> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 127) + 1;
+    pos[1] = 13 * ((i * 3) % 321) + 1;
+    pos[2] = pos[0] + 13;
+    pos[3] = pos[2] + 13;
+    pos[4] = pos[3] + 13;
+    pos[5] = pos[4] + 13;
+    pos[6] = pos[5] + 13;
+    points7[i] = pos;
+  }
+  std::vector<std::array<uint8_t, 1>> points1(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<uint8_t, 1> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 127) + 11;
+    points1[i] = pos;
+  }
+
+  PointCloudBuilder builder;
+  builder.Start(num_points);
+  const int att_id3 =
+      builder.AddAttribute(GeometryAttribute::POSITION, 3, DT_UINT32);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id3, PointIndex(i),
+                                      &(points3[i.value()])[0]);
+  }
+  const int att_id2 =
+      builder.AddAttribute(GeometryAttribute::POSITION, 7, DT_UINT16);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id2, PointIndex(i),
+                                      &(points7[i.value()])[0]);
+  }
+  const int att_id1 =
+      builder.AddAttribute(GeometryAttribute::GENERIC, 1, DT_UINT8);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id1, PointIndex(i),
+                                      &(points1[i.value()])[0]);
+  }
+
+  std::unique_ptr<PointCloud> pc = builder.Finalize(false);
+  ASSERT_NE(pc, nullptr);
+
+  TestKdTreeEncoding(*pc);
+}
+
+// Test encoding of quantized values.
+TEST_F(PointCloudKdTreeEncodingTest,
+       TestIntKdTreeEncodingHigherDimensionFloatTypes) {
+  constexpr int num_points = 130;
+  std::vector<std::array<uint32_t, 3>> points3(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<uint32_t, 3> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 125);
+    pos[1] = 13 * ((i * 3) % 334);
+    pos[2] = 29 * ((i * 19) % 470);
+    points3[i] = pos;
+  }
+  std::vector<std::array<float, 2>> points_float(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<float, 2> pos;
+    // Generate some pseudo-random points.
+    pos[0] = static_cast<float>(8 * ((i * 7) % 127) + 1) / 2.5f;
+    pos[1] = static_cast<float>(13 * ((i * 3) % 321) + 1) / 3.2f;
+    points_float[i] = pos;
+  }
+
+  PointCloudBuilder builder;
+  builder.Start(num_points);
+  const int att_id3 =
+      builder.AddAttribute(GeometryAttribute::POSITION, 3, DT_UINT32);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id3, PointIndex(i),
+                                      &(points3[i.value()])[0]);
+  }
+  const int att_id_float =
+      builder.AddAttribute(GeometryAttribute::GENERIC, 2, DT_FLOAT32);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id_float, PointIndex(i),
+                                      &(points_float[i.value()])[0]);
+  }
+
+  std::unique_ptr<PointCloud> pc = builder.Finalize(false);
+  ASSERT_NE(pc, nullptr);
+
+  TestKdTreeEncoding(*pc);
+}
+
+// Test encoding of signed integer values
+TEST_F(PointCloudKdTreeEncodingTest, TestIntKdTreeEncodingSignedTypes) {
+  constexpr int num_points = 120;
+  std::vector<std::array<uint32_t, 3>> points3(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<uint32_t, 3> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 127);
+    pos[1] = 13 * ((i * 3) % 321);
+    pos[2] = 29 * ((i * 19) % 450);
+    points3[i] = pos;
+  }
+  std::vector<std::array<int32_t, 2>> points2(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<int32_t, 2> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 127) + 1;
+    if (i % 3 == 0) {
+      pos[0] = -pos[0];
+    }
+    pos[1] = 13 * ((i * 3) % 321) + 1;
+    points2[i] = pos;
+  }
+  std::vector<std::array<int16_t, 1>> points1(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<int16_t, 1> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 127) + 11;
+    if (i % 5 == 0) {
+      pos[0] = -pos[0];
+    }
+    points1[i] = pos;
+  }
+
+  PointCloudBuilder builder;
+  builder.Start(num_points);
+  const int att_id3 =
+      builder.AddAttribute(GeometryAttribute::POSITION, 3, DT_UINT32);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id3, PointIndex(i),
+                                      &(points3[i.value()])[0]);
+  }
+  const int att_id2 =
+      builder.AddAttribute(GeometryAttribute::POSITION, 2, DT_INT32);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id2, PointIndex(i),
+                                      &(points2[i.value()])[0]);
+  }
+
+  const int att_id1 =
+      builder.AddAttribute(GeometryAttribute::GENERIC, 1, DT_INT16);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id1, PointIndex(i),
+                                      &(points1[i.value()])[0]);
+  }
+
+  std::unique_ptr<PointCloud> pc = builder.Finalize(false);
+  ASSERT_NE(pc, nullptr);
+
+  TestKdTreeEncoding(*pc);
+}
+
+// Test encoding of integer point clouds with > 16 dimensions.
+TEST_F(PointCloudKdTreeEncodingTest, TestIntKdTreeEncodingHighDimensional) {
+  constexpr int num_points = 120;
+  constexpr int num_dims = 42;
+  std::vector<std::array<uint32_t, num_dims>> points(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<uint32_t, num_dims> pos;
+    // Generate some pseudo-random points.
+    for (int d = 0; d < num_dims; ++d) {
+      pos[d] = 8 * ((i + d) * (7 + (d % 4)) % (127 + d % 3));
+    }
+    points[i] = pos;
+  }
+  PointCloudBuilder builder;
+  builder.Start(num_points);
+  const int att_id =
+      builder.AddAttribute(GeometryAttribute::POSITION, num_dims, DT_UINT32);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id, PointIndex(i),
+                                      &(points[i.value()])[0]);
+  }
+
+  std::unique_ptr<PointCloud> pc = builder.Finalize(false);
+  ASSERT_NE(pc, nullptr);
+
+  TestKdTreeEncoding(*pc);
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_decoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_decoder.cc
new file mode 100644
index 000000000..b9382d310
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_decoder.cc
@@ -0,0 +1,42 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/point_cloud/point_cloud_sequential_decoder.h"
+
+#include "draco/compression/attributes/linear_sequencer.h"
+#include "draco/compression/attributes/sequential_attribute_decoders_controller.h"
+
+namespace draco {
+
+bool PointCloudSequentialDecoder::DecodeGeometryData() {
+  int32_t num_points;
+  if (!buffer()->Decode(&num_points)) {
+    return false;
+  }
+  point_cloud()->set_num_points(num_points);
+  return true;
+}
+
+bool PointCloudSequentialDecoder::CreateAttributesDecoder(
+    int32_t att_decoder_id) {
+  // Always create the basic attribute decoder.
+  return SetAttributesDecoder(
+      att_decoder_id,
+      std::unique_ptr<AttributesDecoder>(
+          new SequentialAttributeDecodersController(
+              std::unique_ptr<PointsSequencer>(
+                  new LinearSequencer(point_cloud()->num_points())))));
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_decoder.h
new file mode 100644
index 000000000..9968dc275
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_decoder.h
@@ -0,0 +1,33 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_SEQUENTIAL_DECODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_SEQUENTIAL_DECODER_H_
+
+#include "draco/compression/point_cloud/point_cloud_decoder.h"
+
+namespace draco {
+
+// Point cloud decoder for data encoded by the PointCloudSequentialEncoder.
+// All attribute values are decoded using an identity mapping between point ids
+// and attribute value ids.
+class PointCloudSequentialDecoder : public PointCloudDecoder {
+ protected:
+  bool DecodeGeometryData() override;
+  bool CreateAttributesDecoder(int32_t att_decoder_id) override;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_SEQUENTIAL_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_encoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_encoder.cc
new file mode 100644
index 000000000..fa7b6fd90
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_encoder.cc
@@ -0,0 +1,49 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/point_cloud/point_cloud_sequential_encoder.h"
+
+#include "draco/compression/attributes/linear_sequencer.h"
+#include "draco/compression/attributes/sequential_attribute_encoders_controller.h"
+
+namespace draco {
+
+Status PointCloudSequentialEncoder::EncodeGeometryData() {
+  const int32_t num_points = point_cloud()->num_points();
+  buffer()->Encode(num_points);
+  return OkStatus();
+}
+
+bool PointCloudSequentialEncoder::GenerateAttributesEncoder(int32_t att_id) {
+  // Create only one attribute encoder that is going to encode all points in a
+  // linear sequence.
+  if (att_id == 0) {
+    // Create a new attribute encoder only for the first attribute.
+    AddAttributesEncoder(std::unique_ptr<AttributesEncoder>(
+        new SequentialAttributeEncodersController(
+            std::unique_ptr<PointsSequencer>(
+                new LinearSequencer(point_cloud()->num_points())),
+            att_id)));
+  } else {
+    // Reuse the existing attribute encoder for other attributes.
+    attributes_encoder(0)->AddAttributeId(att_id);
+  }
+  return true;
+}
+
+void PointCloudSequentialEncoder::ComputeNumberOfEncodedPoints() {
+  set_num_encoded_points(point_cloud()->num_points());
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_encoder.h
new file mode 100644
index 000000000..40d8edcdb
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_encoder.h
@@ -0,0 +1,43 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_SEQUENTIAL_ENCODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_SEQUENTIAL_ENCODER_H_
+
+#include "draco/compression/point_cloud/point_cloud_encoder.h"
+
+namespace draco {
+
+// A basic point cloud encoder that iterates over all points and encodes all
+// attribute values for every visited point. The attribute values encoding
+// can be controlled using provided encoding option to enable features such
+// as quantization or prediction schemes.
+// This encoder preserves the order and the number of input points, but the
+// mapping between point ids and attribute values may be different for the
+// decoded point cloud.
+class PointCloudSequentialEncoder : public PointCloudEncoder {
+ public:
+  uint8_t GetEncodingMethod() const override {
+    return POINT_CLOUD_SEQUENTIAL_ENCODING;
+  }
+
+ protected:
+  Status EncodeGeometryData() override;
+  bool GenerateAttributesEncoder(int32_t att_id) override;
+  void ComputeNumberOfEncodedPoints() override;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_SEQUENTIAL_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_encoding_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_encoding_test.cc
new file mode 100644
index 000000000..32be120dc
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_encoding_test.cc
@@ -0,0 +1,92 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/point_cloud/point_cloud_sequential_decoder.h"
+#include "draco/compression/point_cloud/point_cloud_sequential_encoder.h"
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+#include "draco/io/obj_decoder.h"
+
+namespace draco {
+
+class PointCloudSequentialEncodingTest : public ::testing::Test {
+ protected:
+  std::unique_ptr<PointCloud> EncodeAndDecodePointCloud(const PointCloud *pc) {
+    EncoderBuffer buffer;
+    PointCloudSequentialEncoder encoder;
+    EncoderOptions options = EncoderOptions::CreateDefaultOptions();
+    encoder.SetPointCloud(*pc);
+    if (!encoder.Encode(options, &buffer).ok()) {
+      return nullptr;
+    }
+
+    DecoderBuffer dec_buffer;
+    dec_buffer.Init(buffer.data(), buffer.size());
+    PointCloudSequentialDecoder decoder;
+
+    std::unique_ptr<PointCloud> out_pc(new PointCloud());
+    DecoderOptions dec_options;
+    if (!decoder.Decode(dec_options, &dec_buffer, out_pc.get()).ok()) {
+      return nullptr;
+    }
+    return out_pc;
+  }
+
+  void TestEncoding(const std::string &file_name) {
+    std::unique_ptr<PointCloud> pc = ReadPointCloudFromTestFile(file_name);
+    ASSERT_NE(pc, nullptr);
+
+    std::unique_ptr<PointCloud> decoded_pc =
+        EncodeAndDecodePointCloud(pc.get());
+    ASSERT_NE(decoded_pc.get(), nullptr);
+    ASSERT_EQ(decoded_pc->num_points(), pc->num_points());
+  }
+};
+
+TEST_F(PointCloudSequentialEncodingTest, DoesEncodeAndDecode) {
+  TestEncoding("test_nm.obj");
+}
+
+TEST_F(PointCloudSequentialEncodingTest, EncodingPointCloudWithMetadata) {
+  std::unique_ptr<PointCloud> pc = ReadPointCloudFromTestFile("test_nm.obj");
+  ASSERT_NE(pc, nullptr);
+  // Add metadata to point cloud.
+  std::unique_ptr<GeometryMetadata> metadata =
+      std::unique_ptr<GeometryMetadata>(new GeometryMetadata());
+  const uint32_t pos_att_id =
+      pc->GetNamedAttributeId(GeometryAttribute::POSITION);
+  std::unique_ptr<AttributeMetadata> pos_metadata =
+      std::unique_ptr<AttributeMetadata>(new AttributeMetadata());
+  pos_metadata->AddEntryString("name", "position");
+  pc->AddAttributeMetadata(pos_att_id, std::move(pos_metadata));
+
+  std::unique_ptr<PointCloud> decoded_pc = EncodeAndDecodePointCloud(pc.get());
+  ASSERT_NE(decoded_pc.get(), nullptr);
+
+  const GeometryMetadata *const pc_metadata = decoded_pc->GetMetadata();
+  ASSERT_NE(pc_metadata, nullptr);
+  // Test getting attribute metadata by id.
+  ASSERT_NE(pc->GetAttributeMetadataByAttributeId(pos_att_id), nullptr);
+  // Test getting attribute metadata by entry name value pair.
+  const AttributeMetadata *const requested_att_metadata =
+      pc_metadata->GetAttributeMetadataByStringEntry("name", "position");
+  ASSERT_NE(requested_att_metadata, nullptr);
+  ASSERT_EQ(requested_att_metadata->att_unique_id(),
+            pc->attribute(pos_att_id)->unique_id());
+}
+
+// TODO(ostava): Test the reusability of a single instance of the encoder and
+// decoder class.
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/bit_utils.cc b/Engine/lib/assimp/contrib/draco/src/draco/core/bit_utils.cc
new file mode 100644
index 000000000..37119a717
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/bit_utils.cc
@@ -0,0 +1,36 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/core/bit_utils.h"
+
+namespace draco {
+
+void ConvertSignedIntsToSymbols(const int32_t *in, int in_values,
+                                uint32_t *out) {
+  // Convert the quantized values into a format more suitable for entropy
+  // encoding.
+  // Put the sign bit into LSB pos and shift the rest one bit left.
+  for (int i = 0; i < in_values; ++i) {
+    out[i] = ConvertSignedIntToSymbol(in[i]);
+  }
+}
+
+void ConvertSymbolsToSignedInts(const uint32_t *in, int in_values,
+                                int32_t *out) {
+  for (int i = 0; i < in_values; ++i) {
+    out[i] = ConvertSymbolToSignedInt(in[i]);
+  }
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/bit_utils.h b/Engine/lib/assimp/contrib/draco/src/draco/core/bit_utils.h
new file mode 100644
index 000000000..a102095c7
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/bit_utils.h
@@ -0,0 +1,124 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File containing a basic set of bit manipulation utilities used within the
+// Draco library.
+
+#ifndef DRACO_CORE_BIT_UTILS_H_
+#define DRACO_CORE_BIT_UTILS_H_
+
+#include <inttypes.h>
+#include <stdint.h>
+
+#include <type_traits>
+
+#if defined(_MSC_VER)
+#include <intrin.h>
+#endif  // defined(_MSC_VER)
+
+namespace draco {
+
+// Returns the number of '1' bits within the input 32 bit integer.
+inline int CountOneBits32(uint32_t n) {
+  n -= ((n >> 1) & 0x55555555);
+  n = ((n >> 2) & 0x33333333) + (n & 0x33333333);
+  return (((n + (n >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24;
+}
+
+inline uint32_t ReverseBits32(uint32_t n) {
+  n = ((n >> 1) & 0x55555555) | ((n & 0x55555555) << 1);
+  n = ((n >> 2) & 0x33333333) | ((n & 0x33333333) << 2);
+  n = ((n >> 4) & 0x0F0F0F0F) | ((n & 0x0F0F0F0F) << 4);
+  n = ((n >> 8) & 0x00FF00FF) | ((n & 0x00FF00FF) << 8);
+  return (n >> 16) | (n << 16);
+}
+
+// Copies the |nbits| from the src integer into the |dst| integer using the
+// provided bit offsets |dst_offset| and |src_offset|.
+inline void CopyBits32(uint32_t *dst, int dst_offset, uint32_t src,
+                       int src_offset, int nbits) {
+  const uint32_t mask = (~static_cast<uint32_t>(0)) >> (32 - nbits)
+                                                           << dst_offset;
+  *dst = (*dst & (~mask)) | (((src >> src_offset) << dst_offset) & mask);
+}
+
+// Returns the location of the most significant bit in the input integer |n|.
+// The functionality is not defined for |n == 0|.
+inline int MostSignificantBit(uint32_t n) {
+#if defined(__GNUC__)
+  return 31 ^ __builtin_clz(n);
+#elif defined(_MSC_VER)
+
+  unsigned long where;
+  _BitScanReverse(&where, n);
+  return (int)where;
+#else
+  // TODO(fgalligan): Optimize this code.
+  int msb = -1;
+  while (n != 0) {
+    msb++;
+    n >>= 1;
+  }
+  return msb;
+#endif
+}
+
+// Helper function that converts signed integer values into unsigned integer
+// symbols that can be encoded using an entropy encoder.
+void ConvertSignedIntsToSymbols(const int32_t *in, int in_values,
+                                uint32_t *out);
+
+// Converts unsigned integer symbols encoded with an entropy encoder back to
+// signed values.
+void ConvertSymbolsToSignedInts(const uint32_t *in, int in_values,
+                                int32_t *out);
+
+// Helper function that converts a single signed integer value into an unsigned
+// integer symbol that can be encoded using an entropy encoder.
+template <class IntTypeT>
+typename std::make_unsigned<IntTypeT>::type ConvertSignedIntToSymbol(
+    IntTypeT val) {
+  typedef typename std::make_unsigned<IntTypeT>::type UnsignedType;
+  static_assert(std::is_integral<IntTypeT>::value, "IntTypeT is not integral.");
+  // Early exit if val is positive.
+  if (val >= 0) {
+    return static_cast<UnsignedType>(val) << 1;
+  }
+  val = -(val + 1);  // Map -1 to 0, -2 to -1, etc..
+  UnsignedType ret = static_cast<UnsignedType>(val);
+  ret <<= 1;
+  ret |= 1;
+  return ret;
+}
+
+// Converts a single unsigned integer symbol encoded with an entropy encoder
+// back to a signed value.
+template <class IntTypeT>
+typename std::make_signed<IntTypeT>::type ConvertSymbolToSignedInt(
+    IntTypeT val) {
+  static_assert(std::is_integral<IntTypeT>::value, "IntTypeT is not integral.");
+  typedef typename std::make_signed<IntTypeT>::type SignedType;
+  const bool is_positive = !static_cast<bool>(val & 1);
+  val >>= 1;
+  if (is_positive) {
+    return static_cast<SignedType>(val);
+  }
+  SignedType ret = static_cast<SignedType>(val);
+  ret = -ret - 1;
+  return ret;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_BIT_UTILS_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/bounding_box.cc b/Engine/lib/assimp/contrib/draco/src/draco/core/bounding_box.cc
new file mode 100644
index 000000000..8a0709678
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/bounding_box.cc
@@ -0,0 +1,30 @@
+// Copyright 2018 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "draco/core/bounding_box.h"
+
+namespace draco {
+
+BoundingBox::BoundingBox()
+    : BoundingBox(Vector3f(std::numeric_limits<float>::max(),
+                           std::numeric_limits<float>::max(),
+                           std::numeric_limits<float>::max()),
+                  Vector3f(-std::numeric_limits<float>::max(),
+                           -std::numeric_limits<float>::max(),
+                           -std::numeric_limits<float>::max())) {}
+
+BoundingBox::BoundingBox(const Vector3f &min_point, const Vector3f &max_point)
+    : min_point_(min_point), max_point_(max_point) {}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/bounding_box.h b/Engine/lib/assimp/contrib/draco/src/draco/core/bounding_box.h
new file mode 100644
index 000000000..31ba2d683
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/bounding_box.h
@@ -0,0 +1,72 @@
+// Copyright 2018 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_BOUNDING_BOX_H_
+#define DRACO_CORE_BOUNDING_BOX_H_
+
+#include "draco/core/vector_d.h"
+
+namespace draco {
+
+// Class for computing the bounding box of points in 3D space.
+class BoundingBox {
+ public:
+  // Creates bounding box object with minimum and maximum points initialized to
+  // the largest positive and the smallest negative values, respectively. The
+  // resulting abstract bounding box effectively has no points and can be
+  // updated by providing any point to Update() method.
+  BoundingBox();
+
+  // Creates bounding box object with minimum and maximum points initialized to
+  // |min_point| and |max_point|, respectively.
+  BoundingBox(const Vector3f &min_point, const Vector3f &max_point);
+
+  // Returns the minimum point of the bounding box.
+  inline const Vector3f &GetMinPoint() const { return min_point_; }
+
+  // Returns the maximum point of the bounding box.
+  inline const Vector3f &GetMaxPoint() const { return max_point_; }
+
+  // Conditionally updates the bounding box with a given |new_point|.
+  void Update(const Vector3f &new_point) {
+    for (int i = 0; i < 3; i++) {
+      if (new_point[i] < min_point_[i]) {
+        min_point_[i] = new_point[i];
+      }
+      if (new_point[i] > max_point_[i]) {
+        max_point_[i] = new_point[i];
+      }
+    }
+  }
+
+  // Updates bounding box with minimum and maximum points of the |other|
+  // bounding box.
+  void Update(const BoundingBox &other) {
+    Update(other.GetMinPoint());
+    Update(other.GetMaxPoint());
+  }
+
+  // Returns the size of the bounding box along each axis.
+  Vector3f Size() const { return max_point_ - min_point_; }
+
+  // Returns the center of the bounding box.
+  Vector3f Center() const { return (min_point_ + max_point_) / 2; }
+
+ private:
+  Vector3f min_point_;
+  Vector3f max_point_;
+};
+}  // namespace draco
+
+#endif  //  DRACO_CORE_BOUNDING_BOX_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/buffer_bit_coding_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/core/buffer_bit_coding_test.cc
new file mode 100644
index 000000000..892b35b4f
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/buffer_bit_coding_test.cc
@@ -0,0 +1,115 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/draco_test_base.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+class BufferBitCodingTest : public ::testing::Test {
+ public:
+  typedef DecoderBuffer::BitDecoder BitDecoder;
+  typedef EncoderBuffer::BitEncoder BitEncoder;
+};
+
+TEST_F(BufferBitCodingTest, TestBitCodersByteAligned) {
+  constexpr int buffer_size = 32;
+  char buffer[buffer_size];
+  BitEncoder encoder(buffer);
+  const uint8_t data[] = {0x76, 0x54, 0x32, 0x10, 0x76, 0x54, 0x32, 0x10};
+  const int bytes_to_encode = sizeof(data);
+
+  for (int i = 0; i < bytes_to_encode; ++i) {
+    encoder.PutBits(data[i], sizeof(data[i]) * 8);
+    ASSERT_EQ((i + 1) * sizeof(data[i]) * 8, encoder.Bits());
+  }
+
+  BitDecoder decoder;
+  decoder.reset(static_cast<const void *>(buffer), bytes_to_encode);
+  for (int i = 0; i < bytes_to_encode; ++i) {
+    uint32_t x = 0;
+    ASSERT_TRUE(decoder.GetBits(8, &x));
+    ASSERT_EQ(x, data[i]);
+  }
+
+  ASSERT_EQ(bytes_to_encode * 8u, decoder.BitsDecoded());
+}
+
+TEST_F(BufferBitCodingTest, TestBitCodersNonByte) {
+  constexpr int buffer_size = 32;
+  char buffer[buffer_size];
+  BitEncoder encoder(buffer);
+  const uint8_t data[] = {0x76, 0x54, 0x32, 0x10, 0x76, 0x54, 0x32, 0x10};
+  const uint32_t bits_to_encode = 51;
+  const int bytes_to_encode = (bits_to_encode / 8) + 1;
+
+  for (int i = 0; i < bytes_to_encode; ++i) {
+    const int num_bits = (encoder.Bits() + 8 <= bits_to_encode)
+                             ? 8
+                             : bits_to_encode - encoder.Bits();
+    encoder.PutBits(data[i], num_bits);
+  }
+
+  BitDecoder decoder;
+  decoder.reset(static_cast<const void *>(buffer), bytes_to_encode);
+  int64_t bits_to_decode = encoder.Bits();
+  for (int i = 0; i < bytes_to_encode; ++i) {
+    uint32_t x = 0;
+    const int num_bits = (bits_to_decode > 8) ? 8 : bits_to_decode;
+    ASSERT_TRUE(decoder.GetBits(num_bits, &x));
+    const int bits_to_shift = 8 - num_bits;
+    const uint8_t test_byte =
+        ((data[i] << bits_to_shift) & 0xff) >> bits_to_shift;
+    ASSERT_EQ(x, test_byte);
+    bits_to_decode -= 8;
+  }
+
+  ASSERT_EQ(bits_to_encode, decoder.BitsDecoded());
+}
+
+TEST_F(BufferBitCodingTest, TestSingleBits) {
+  const int data = 0xaaaa;
+
+  BitDecoder decoder;
+  decoder.reset(static_cast<const void *>(&data), sizeof(data));
+
+  for (uint32_t i = 0; i < 16; ++i) {
+    uint32_t x = 0;
+    ASSERT_TRUE(decoder.GetBits(1, &x));
+    ASSERT_EQ(x, (i % 2));
+  }
+
+  ASSERT_EQ(16u, decoder.BitsDecoded());
+}
+
+TEST_F(BufferBitCodingTest, TestMultipleBits) {
+  const uint8_t data[] = {0x76, 0x54, 0x32, 0x10, 0x76, 0x54, 0x32, 0x10};
+
+  BitDecoder decoder;
+  decoder.reset(static_cast<const void *>(data), sizeof(data));
+
+  uint32_t x = 0;
+  for (uint32_t i = 0; i < 2; ++i) {
+    ASSERT_TRUE(decoder.GetBits(16, &x));
+    ASSERT_EQ(x, 0x5476u);
+    ASSERT_EQ(16 + (i * 32), decoder.BitsDecoded());
+
+    ASSERT_TRUE(decoder.GetBits(16, &x));
+    ASSERT_EQ(x, 0x1032u);
+    ASSERT_EQ(32 + (i * 32), decoder.BitsDecoded());
+  }
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/cycle_timer.cc b/Engine/lib/assimp/contrib/draco/src/draco/core/cycle_timer.cc
new file mode 100644
index 000000000..58df4df77
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/cycle_timer.cc
@@ -0,0 +1,49 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/core/cycle_timer.h"
+
+namespace draco {
+void DracoTimer::Start() {
+#ifdef _WIN32
+  QueryPerformanceCounter(&tv_start_);
+#else
+  gettimeofday(&tv_start_, nullptr);
+#endif
+}
+
+void DracoTimer::Stop() {
+#ifdef _WIN32
+  QueryPerformanceCounter(&tv_end_);
+#else
+  gettimeofday(&tv_end_, nullptr);
+#endif
+}
+
+int64_t DracoTimer::GetInMs() {
+#ifdef _WIN32
+  LARGE_INTEGER elapsed = {0};
+  elapsed.QuadPart = tv_end_.QuadPart - tv_start_.QuadPart;
+
+  LARGE_INTEGER frequency = {0};
+  QueryPerformanceFrequency(&frequency);
+  return elapsed.QuadPart * 1000 / frequency.QuadPart;
+#else
+  const int64_t seconds = (tv_end_.tv_sec - tv_start_.tv_sec) * 1000;
+  const int64_t milliseconds = (tv_end_.tv_usec - tv_start_.tv_usec) / 1000;
+  return seconds + milliseconds;
+#endif
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/cycle_timer.h b/Engine/lib/assimp/contrib/draco/src/draco/core/cycle_timer.h
new file mode 100644
index 000000000..f480cc9d3
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/cycle_timer.h
@@ -0,0 +1,51 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_CYCLE_TIMER_H_
+#define DRACO_CORE_CYCLE_TIMER_H_
+
+#ifdef _WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+typedef LARGE_INTEGER DracoTimeVal;
+#else
+#include <sys/time.h>
+typedef timeval DracoTimeVal;
+#endif
+
+#include <cinttypes>
+#include <cstddef>
+
+namespace draco {
+
+class DracoTimer {
+ public:
+  DracoTimer() {}
+  ~DracoTimer() {}
+  void Start();
+  void Stop();
+  int64_t GetInMs();
+
+ private:
+  DracoTimeVal tv_start_;
+  DracoTimeVal tv_end_;
+};
+
+typedef DracoTimer CycleTimer;
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_CYCLE_TIMER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/data_buffer.cc b/Engine/lib/assimp/contrib/draco/src/draco/core/data_buffer.cc
new file mode 100644
index 000000000..f0b43d67d
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/data_buffer.cc
@@ -0,0 +1,61 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/core/data_buffer.h"
+
+#include <algorithm>
+
+namespace draco {
+
+DataBuffer::DataBuffer() {}
+
+bool DataBuffer::Update(const void *data, int64_t size) {
+  const int64_t offset = 0;
+  return this->Update(data, size, offset);
+}
+
+bool DataBuffer::Update(const void *data, int64_t size, int64_t offset) {
+  if (data == nullptr) {
+    if (size + offset < 0) {
+      return false;
+    }
+    // If no data is provided, just resize the buffer.
+    data_.resize(size + offset);
+  } else {
+    if (size < 0) {
+      return false;
+    }
+    if (size + offset > static_cast<int64_t>(data_.size())) {
+      data_.resize(size + offset);
+    }
+    const uint8_t *const byte_data = static_cast<const uint8_t *>(data);
+    std::copy(byte_data, byte_data + size, data_.data() + offset);
+  }
+  descriptor_.buffer_update_count++;
+  return true;
+}
+
+void DataBuffer::Resize(int64_t size) {
+  data_.resize(size);
+  descriptor_.buffer_update_count++;
+}
+
+void DataBuffer::WriteDataToStream(std::ostream &stream) {
+  if (data_.size() == 0) {
+    return;
+  }
+  stream.write(reinterpret_cast<char *>(data_.data()), data_.size());
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/data_buffer.h b/Engine/lib/assimp/contrib/draco/src/draco/core/data_buffer.h
new file mode 100644
index 000000000..8ee690540
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/data_buffer.h
@@ -0,0 +1,82 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_DATA_BUFFER_H_
+#define DRACO_CORE_DATA_BUFFER_H_
+
+#include <cstring>
+#include <ostream>
+#include <vector>
+
+#include "draco/core/draco_types.h"
+
+namespace draco {
+
+// Buffer descriptor servers as a unique identifier of a buffer.
+struct DataBufferDescriptor {
+  DataBufferDescriptor() : buffer_id(0), buffer_update_count(0) {}
+  // Id of the data buffer.
+  int64_t buffer_id;
+  // The number of times the buffer content was updated.
+  int64_t buffer_update_count;
+};
+
+// Class used for storing raw buffer data.
+class DataBuffer {
+ public:
+  DataBuffer();
+  bool Update(const void *data, int64_t size);
+  bool Update(const void *data, int64_t size, int64_t offset);
+
+  // Reallocate the buffer storage to a new size keeping the data unchanged.
+  void Resize(int64_t new_size);
+  void WriteDataToStream(std::ostream &stream);
+  // Reads data from the buffer. Potentially unsafe, called needs to ensure
+  // the accessed memory is valid.
+  void Read(int64_t byte_pos, void *out_data, size_t data_size) const {
+    memcpy(out_data, data() + byte_pos, data_size);
+  }
+
+  // Writes data to the buffer. Unsafe, caller must ensure the accessed memory
+  // is valid.
+  void Write(int64_t byte_pos, const void *in_data, size_t data_size) {
+    memcpy(const_cast<uint8_t *>(data()) + byte_pos, in_data, data_size);
+  }
+
+  // Copies data from another buffer to this buffer.
+  void Copy(int64_t dst_offset, const DataBuffer *src_buf, int64_t src_offset,
+            int64_t size) {
+    memcpy(const_cast<uint8_t *>(data()) + dst_offset,
+           src_buf->data() + src_offset, size);
+  }
+
+  void set_update_count(int64_t buffer_update_count) {
+    descriptor_.buffer_update_count = buffer_update_count;
+  }
+  int64_t update_count() const { return descriptor_.buffer_update_count; }
+  size_t data_size() const { return data_.size(); }
+  const uint8_t *data() const { return data_.data(); }
+  uint8_t *data() { return &data_[0]; }
+  int64_t buffer_id() const { return descriptor_.buffer_id; }
+  void set_buffer_id(int64_t buffer_id) { descriptor_.buffer_id = buffer_id; }
+
+ private:
+  std::vector<uint8_t> data_;
+  // Counter incremented by Update() calls.
+  DataBufferDescriptor descriptor_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_DATA_BUFFER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/decoder_buffer.cc b/Engine/lib/assimp/contrib/draco/src/draco/core/decoder_buffer.cc
new file mode 100644
index 000000000..4e8ed618d
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/decoder_buffer.cc
@@ -0,0 +1,72 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/core/decoder_buffer.h"
+
+#include "draco/core/macros.h"
+#include "draco/core/varint_decoding.h"
+
+namespace draco {
+
+DecoderBuffer::DecoderBuffer()
+    : data_(nullptr),
+      data_size_(0),
+      pos_(0),
+      bit_mode_(false),
+      bitstream_version_(0) {}
+
+void DecoderBuffer::Init(const char *data, size_t data_size) {
+  Init(data, data_size, bitstream_version_);
+}
+
+void DecoderBuffer::Init(const char *data, size_t data_size, uint16_t version) {
+  data_ = data;
+  data_size_ = data_size;
+  bitstream_version_ = version;
+  pos_ = 0;
+}
+
+bool DecoderBuffer::StartBitDecoding(bool decode_size, uint64_t *out_size) {
+  if (decode_size) {
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+    if (bitstream_version_ < DRACO_BITSTREAM_VERSION(2, 2)) {
+      if (!Decode(out_size)) {
+        return false;
+      }
+    } else
+#endif
+    {
+      if (!DecodeVarint(out_size, this)) {
+        return false;
+      }
+    }
+  }
+  bit_mode_ = true;
+  bit_decoder_.reset(data_head(), remaining_size());
+  return true;
+}
+
+void DecoderBuffer::EndBitDecoding() {
+  bit_mode_ = false;
+  const uint64_t bits_decoded = bit_decoder_.BitsDecoded();
+  const uint64_t bytes_decoded = (bits_decoded + 7) / 8;
+  pos_ += bytes_decoded;
+}
+
+DecoderBuffer::BitDecoder::BitDecoder()
+    : bit_buffer_(nullptr), bit_buffer_end_(nullptr), bit_offset_(0) {}
+
+DecoderBuffer::BitDecoder::~BitDecoder() {}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/decoder_buffer.h b/Engine/lib/assimp/contrib/draco/src/draco/core/decoder_buffer.h
new file mode 100644
index 000000000..0559abbe4
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/decoder_buffer.h
@@ -0,0 +1,216 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_DECODER_BUFFER_H_
+#define DRACO_CORE_DECODER_BUFFER_H_
+
+#include <stdint.h>
+
+#include <cstring>
+#include <memory>
+
+#include "draco/core/macros.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Class is a wrapper around input data used by MeshDecoder. It provides a
+// basic interface for decoding either typed or variable-bit sized data.
+class DecoderBuffer {
+ public:
+  DecoderBuffer();
+  DecoderBuffer(const DecoderBuffer &buf) = default;
+
+  DecoderBuffer &operator=(const DecoderBuffer &buf) = default;
+
+  // Sets the buffer's internal data. Note that no copy of the input data is
+  // made so the data owner needs to keep the data valid and unchanged for
+  // runtime of the decoder.
+  void Init(const char *data, size_t data_size);
+
+  // Sets the buffer's internal data. |version| is the Draco bitstream version.
+  void Init(const char *data, size_t data_size, uint16_t version);
+
+  // Starts decoding a bit sequence.
+  // decode_size must be true if the size of the encoded bit data was included,
+  // during encoding. The size is then returned to out_size.
+  // Returns false on error.
+  bool StartBitDecoding(bool decode_size, uint64_t *out_size);
+
+  // Ends the decoding of the bit sequence and return to the default
+  // byte-aligned decoding.
+  void EndBitDecoding();
+
+  // Decodes up to 32 bits into out_val. Can be called only in between
+  // StartBitDecoding and EndBitDecoding. Otherwise returns false.
+  bool DecodeLeastSignificantBits32(int nbits, uint32_t *out_value) {
+    if (!bit_decoder_active()) {
+      return false;
+    }
+    bit_decoder_.GetBits(nbits, out_value);
+    return true;
+  }
+
+  // Decodes an arbitrary data type.
+  // Can be used only when we are not decoding a bit-sequence.
+  // Returns false on error.
+  template <typename T>
+  bool Decode(T *out_val) {
+    if (!Peek(out_val)) {
+      return false;
+    }
+    pos_ += sizeof(T);
+    return true;
+  }
+
+  bool Decode(void *out_data, size_t size_to_decode) {
+    if (data_size_ < static_cast<int64_t>(pos_ + size_to_decode)) {
+      return false;  // Buffer overflow.
+    }
+    memcpy(out_data, (data_ + pos_), size_to_decode);
+    pos_ += size_to_decode;
+    return true;
+  }
+
+  // Decodes an arbitrary data, but does not advance the reading position.
+  template <typename T>
+  bool Peek(T *out_val) {
+    const size_t size_to_decode = sizeof(T);
+    if (data_size_ < static_cast<int64_t>(pos_ + size_to_decode)) {
+      return false;  // Buffer overflow.
+    }
+    memcpy(out_val, (data_ + pos_), size_to_decode);
+    return true;
+  }
+
+  bool Peek(void *out_data, size_t size_to_peek) {
+    if (data_size_ < static_cast<int64_t>(pos_ + size_to_peek)) {
+      return false;  // Buffer overflow.
+    }
+    memcpy(out_data, (data_ + pos_), size_to_peek);
+    return true;
+  }
+
+  // Discards #bytes from the input buffer.
+  void Advance(int64_t bytes) { pos_ += bytes; }
+
+  // Moves the parsing position to a specific offset from the beginning of the
+  // input data.
+  void StartDecodingFrom(int64_t offset) { pos_ = offset; }
+
+  void set_bitstream_version(uint16_t version) { bitstream_version_ = version; }
+
+  // Returns the data array at the current decoder position.
+  const char *data_head() const { return data_ + pos_; }
+  int64_t remaining_size() const { return data_size_ - pos_; }
+  int64_t decoded_size() const { return pos_; }
+  bool bit_decoder_active() const { return bit_mode_; }
+
+  // Returns the bitstream associated with the data. Returns 0 if unknown.
+  uint16_t bitstream_version() const { return bitstream_version_; }
+
+ private:
+  // Internal helper class to decode bits from a bit buffer.
+  class BitDecoder {
+   public:
+    BitDecoder();
+    ~BitDecoder();
+
+    // Sets the bit buffer to |b|. |s| is the size of |b| in bytes.
+    inline void reset(const void *b, size_t s) {
+      bit_offset_ = 0;
+      bit_buffer_ = static_cast<const uint8_t *>(b);
+      bit_buffer_end_ = bit_buffer_ + s;
+    }
+
+    // Returns number of bits decoded so far.
+    inline uint64_t BitsDecoded() const {
+      return static_cast<uint64_t>(bit_offset_);
+    }
+
+    // Return number of bits available for decoding
+    inline uint64_t AvailBits() const {
+      return ((bit_buffer_end_ - bit_buffer_) * 8) - bit_offset_;
+    }
+
+    inline uint32_t EnsureBits(int k) {
+      DRACO_DCHECK_LE(k, 24);
+      DRACO_DCHECK_LE(static_cast<uint64_t>(k), AvailBits());
+
+      uint32_t buf = 0;
+      for (int i = 0; i < k; ++i) {
+        buf |= PeekBit(i) << i;
+      }
+      return buf;  // Okay to return extra bits
+    }
+
+    inline void ConsumeBits(int k) { bit_offset_ += k; }
+
+    // Returns |nbits| bits in |x|.
+    inline bool GetBits(int32_t nbits, uint32_t *x) {
+      DRACO_DCHECK_GE(nbits, 0);
+      DRACO_DCHECK_LE(nbits, 32);
+      uint32_t value = 0;
+      for (int32_t bit = 0; bit < nbits; ++bit) {
+        value |= GetBit() << bit;
+      }
+      *x = value;
+      return true;
+    }
+
+   private:
+    // TODO(fgalligan): Add support for error reporting on range check.
+    // Returns one bit from the bit buffer.
+    inline int GetBit() {
+      const size_t off = bit_offset_;
+      const size_t byte_offset = off >> 3;
+      const int bit_shift = static_cast<int>(off & 0x7);
+      if (bit_buffer_ + byte_offset < bit_buffer_end_) {
+        const int bit = (bit_buffer_[byte_offset] >> bit_shift) & 1;
+        bit_offset_ = off + 1;
+        return bit;
+      }
+      return 0;
+    }
+
+    inline int PeekBit(int offset) {
+      const size_t off = bit_offset_ + offset;
+      const size_t byte_offset = off >> 3;
+      const int bit_shift = static_cast<int>(off & 0x7);
+      if (bit_buffer_ + byte_offset < bit_buffer_end_) {
+        const int bit = (bit_buffer_[byte_offset] >> bit_shift) & 1;
+        return bit;
+      }
+      return 0;
+    }
+
+    const uint8_t *bit_buffer_;
+    const uint8_t *bit_buffer_end_;
+    size_t bit_offset_;
+  };
+  friend class BufferBitCodingTest;
+
+  const char *data_;
+  int64_t data_size_;
+
+  // Current parsing position of the decoder.
+  int64_t pos_;
+  BitDecoder bit_decoder_;
+  bool bit_mode_;
+  uint16_t bitstream_version_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_DECODER_BUFFER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/divide.cc b/Engine/lib/assimp/contrib/draco/src/draco/core/divide.cc
new file mode 100644
index 000000000..6d2e57120
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/divide.cc
@@ -0,0 +1,88 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// This file is based off libvpx's divide.c.
+
+#include "draco/core/divide.h"
+
+namespace draco {
+
+const struct fastdiv_elem vp10_fastdiv_tab[256] = {
+    {0, 0},          {0, 0},          {0, 1},          {1431655766, 2},
+    {0, 2},          {2576980378, 3}, {1431655766, 3}, {613566757, 3},
+    {0, 3},          {3340530120, 4}, {2576980378, 4}, {1952257862, 4},
+    {1431655766, 4}, {991146300, 4},  {613566757, 4},  {286331154, 4},
+    {0, 4},          {3789677026, 5}, {3340530120, 5}, {2938661835, 5},
+    {2576980378, 5}, {2249744775, 5}, {1952257862, 5}, {1680639377, 5},
+    {1431655766, 5}, {1202590843, 5}, {991146300, 5},  {795364315, 5},
+    {613566757, 5},  {444306962, 5},  {286331154, 5},  {138547333, 5},
+    {0, 5},          {4034666248, 6}, {3789677026, 6}, {3558687189, 6},
+    {3340530120, 6}, {3134165325, 6}, {2938661835, 6}, {2753184165, 6},
+    {2576980378, 6}, {2409371898, 6}, {2249744775, 6}, {2097542168, 6},
+    {1952257862, 6}, {1813430637, 6}, {1680639377, 6}, {1553498810, 6},
+    {1431655766, 6}, {1314785907, 6}, {1202590843, 6}, {1094795586, 6},
+    {991146300, 6},  {891408307, 6},  {795364315, 6},  {702812831, 6},
+    {613566757, 6},  {527452125, 6},  {444306962, 6},  {363980280, 6},
+    {286331154, 6},  {211227900, 6},  {138547333, 6},  {68174085, 6},
+    {0, 6},          {4162814457, 7}, {4034666248, 7}, {3910343360, 7},
+    {3789677026, 7}, {3672508268, 7}, {3558687189, 7}, {3448072337, 7},
+    {3340530120, 7}, {3235934265, 7}, {3134165325, 7}, {3035110223, 7},
+    {2938661835, 7}, {2844718599, 7}, {2753184165, 7}, {2663967058, 7},
+    {2576980378, 7}, {2492141518, 7}, {2409371898, 7}, {2328596727, 7},
+    {2249744775, 7}, {2172748162, 7}, {2097542168, 7}, {2024065048, 7},
+    {1952257862, 7}, {1882064321, 7}, {1813430637, 7}, {1746305385, 7},
+    {1680639377, 7}, {1616385542, 7}, {1553498810, 7}, {1491936009, 7},
+    {1431655766, 7}, {1372618415, 7}, {1314785907, 7}, {1258121734, 7},
+    {1202590843, 7}, {1148159575, 7}, {1094795586, 7}, {1042467791, 7},
+    {991146300, 7},  {940802361, 7},  {891408307, 7},  {842937507, 7},
+    {795364315, 7},  {748664025, 7},  {702812831, 7},  {657787785, 7},
+    {613566757, 7},  {570128403, 7},  {527452125, 7},  {485518043, 7},
+    {444306962, 7},  {403800345, 7},  {363980280, 7},  {324829460, 7},
+    {286331154, 7},  {248469183, 7},  {211227900, 7},  {174592167, 7},
+    {138547333, 7},  {103079216, 7},  {68174085, 7},   {33818641, 7},
+    {0, 7},          {4228378656, 8}, {4162814457, 8}, {4098251237, 8},
+    {4034666248, 8}, {3972037425, 8}, {3910343360, 8}, {3849563281, 8},
+    {3789677026, 8}, {3730665024, 8}, {3672508268, 8}, {3615188300, 8},
+    {3558687189, 8}, {3502987511, 8}, {3448072337, 8}, {3393925206, 8},
+    {3340530120, 8}, {3287871517, 8}, {3235934265, 8}, {3184703642, 8},
+    {3134165325, 8}, {3084305374, 8}, {3035110223, 8}, {2986566663, 8},
+    {2938661835, 8}, {2891383213, 8}, {2844718599, 8}, {2798656110, 8},
+    {2753184165, 8}, {2708291480, 8}, {2663967058, 8}, {2620200175, 8},
+    {2576980378, 8}, {2534297473, 8}, {2492141518, 8}, {2450502814, 8},
+    {2409371898, 8}, {2368739540, 8}, {2328596727, 8}, {2288934667, 8},
+    {2249744775, 8}, {2211018668, 8}, {2172748162, 8}, {2134925265, 8},
+    {2097542168, 8}, {2060591247, 8}, {2024065048, 8}, {1987956292, 8},
+    {1952257862, 8}, {1916962805, 8}, {1882064321, 8}, {1847555765, 8},
+    {1813430637, 8}, {1779682582, 8}, {1746305385, 8}, {1713292966, 8},
+    {1680639377, 8}, {1648338801, 8}, {1616385542, 8}, {1584774030, 8},
+    {1553498810, 8}, {1522554545, 8}, {1491936009, 8}, {1461638086, 8},
+    {1431655766, 8}, {1401984144, 8}, {1372618415, 8}, {1343553873, 8},
+    {1314785907, 8}, {1286310003, 8}, {1258121734, 8}, {1230216764, 8},
+    {1202590843, 8}, {1175239808, 8}, {1148159575, 8}, {1121346142, 8},
+    {1094795586, 8}, {1068504060, 8}, {1042467791, 8}, {1016683080, 8},
+    {991146300, 8},  {965853890, 8},  {940802361, 8},  {915988286, 8},
+    {891408307, 8},  {867059126, 8},  {842937507, 8},  {819040276, 8},
+    {795364315, 8},  {771906565, 8},  {748664025, 8},  {725633745, 8},
+    {702812831, 8},  {680198441, 8},  {657787785, 8},  {635578121, 8},
+    {613566757, 8},  {591751050, 8},  {570128403, 8},  {548696263, 8},
+    {527452125, 8},  {506393524, 8},  {485518043, 8},  {464823301, 8},
+    {444306962, 8},  {423966729, 8},  {403800345, 8},  {383805589, 8},
+    {363980280, 8},  {344322273, 8},  {324829460, 8},  {305499766, 8},
+    {286331154, 8},  {267321616, 8},  {248469183, 8},  {229771913, 8},
+    {211227900, 8},  {192835267, 8},  {174592167, 8},  {156496785, 8},
+    {138547333, 8},  {120742053, 8},  {103079216, 8},  {85557118, 8},
+    {68174085, 8},   {50928466, 8},   {33818641, 8},   {16843010, 8},
+};
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/divide.h b/Engine/lib/assimp/contrib/draco/src/draco/core/divide.h
new file mode 100644
index 000000000..7e3838a00
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/divide.h
@@ -0,0 +1,42 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_DIVIDE_H_
+#define DRACO_CORE_DIVIDE_H_
+// An implementation of the divide by multiply algorithm
+// https://gmplib.org/~tege/divcnst-pldi94.pdf
+// This file is based off libvpx's divide.h.
+
+#include <stdint.h>
+
+#include <climits>
+
+namespace draco {
+
+struct fastdiv_elem {
+  unsigned mult;
+  unsigned shift;
+};
+
+extern const struct fastdiv_elem vp10_fastdiv_tab[256];
+
+static inline unsigned fastdiv(unsigned x, int y) {
+  unsigned t =
+      ((uint64_t)x * vp10_fastdiv_tab[y].mult) >> (sizeof(x) * CHAR_BIT);
+  return (t + x) >> vp10_fastdiv_tab[y].shift;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_DIVIDE_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/draco_index_type.h b/Engine/lib/assimp/contrib/draco/src/draco/core/draco_index_type.h
new file mode 100644
index 000000000..d9dd3f64f
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/draco_index_type.h
@@ -0,0 +1,183 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// This files provides a basic framework for strongly typed indices that are
+// used within the Draco library. The motivation of using strongly typed indices
+// is to prevent bugs caused by mixing up incompatible indices, such as indexing
+// mesh faces with point indices and vice versa.
+//
+// Usage:
+//      Define strongly typed index using macro:
+//
+//        DEFINE_NEW_DRACO_INDEX_TYPE(value_type, name)
+//
+//      where |value_type| is the data type of the index value (such as int32_t)
+//      and |name| is a unique typename of the new index.
+//
+//      E.g., we can define new index types as:
+//
+//        DEFINE_NEW_DRACO_INDEX_TYPE(int, PointIndex)
+//        DEFINE_NEW_DRACO_INDEX_TYPE(int, FaceIndex)
+//
+//      The new types can then be used in the similar way as the regular weakly
+//      typed indices (such as int32, int64, ...), but they cannot be
+//      accidentally misassigned. E.g.:
+//
+//        PointIndex point_index(10);
+//        FaceIndex face_index;
+//        face_index = point_index;  // Compile error!
+//
+//      One can still cast one type to another explicitly by accessing the index
+//      value directly using the .value() method:
+//
+//        face_index = FaceIndex(point_index.value());  // Compiles OK.
+//
+//      Strongly typed indices support most of the common binary and unary
+//      operators and support for additional operators can be added if
+//      necessary.
+
+#ifndef DRACO_CORE_DRACO_INDEX_TYPE_H_
+#define DRACO_CORE_DRACO_INDEX_TYPE_H_
+
+#include <ostream>
+
+#include "draco/draco_features.h"
+
+namespace draco {
+
+#define DEFINE_NEW_DRACO_INDEX_TYPE(value_type, name) \
+  struct name##_tag_type_ {};                         \
+  typedef IndexType<value_type, name##_tag_type_> name;
+
+template <class ValueTypeT, class TagT>
+class IndexType {
+ public:
+  typedef IndexType<ValueTypeT, TagT> ThisIndexType;
+  typedef ValueTypeT ValueType;
+
+  constexpr IndexType() : value_(ValueTypeT()) {}
+  constexpr explicit IndexType(ValueTypeT value) : value_(value) {}
+
+  constexpr ValueTypeT value() const { return value_; }
+
+  constexpr bool operator==(const IndexType &i) const {
+    return value_ == i.value_;
+  }
+  constexpr bool operator==(const ValueTypeT &val) const {
+    return value_ == val;
+  }
+  constexpr bool operator!=(const IndexType &i) const {
+    return value_ != i.value_;
+  }
+  constexpr bool operator!=(const ValueTypeT &val) const {
+    return value_ != val;
+  }
+  constexpr bool operator<(const IndexType &i) const {
+    return value_ < i.value_;
+  }
+  constexpr bool operator<(const ValueTypeT &val) const { return value_ < val; }
+  constexpr bool operator>(const IndexType &i) const {
+    return value_ > i.value_;
+  }
+  constexpr bool operator>(const ValueTypeT &val) const { return value_ > val; }
+  constexpr bool operator>=(const IndexType &i) const {
+    return value_ >= i.value_;
+  }
+  constexpr bool operator>=(const ValueTypeT &val) const {
+    return value_ >= val;
+  }
+
+  inline ThisIndexType &operator++() {
+    ++value_;
+    return *this;
+  }
+  inline ThisIndexType operator++(int) {
+    const ThisIndexType ret(value_);
+    ++value_;
+    return ret;
+  }
+
+  inline ThisIndexType &operator--() {
+    --value_;
+    return *this;
+  }
+  inline ThisIndexType operator--(int) {
+    const ThisIndexType ret(value_);
+    --value_;
+    return ret;
+  }
+
+  constexpr ThisIndexType operator+(const IndexType &i) const {
+    return ThisIndexType(value_ + i.value_);
+  }
+  constexpr ThisIndexType operator+(const ValueTypeT &val) const {
+    return ThisIndexType(value_ + val);
+  }
+  constexpr ThisIndexType operator-(const IndexType &i) const {
+    return ThisIndexType(value_ - i.value_);
+  }
+  constexpr ThisIndexType operator-(const ValueTypeT &val) const {
+    return ThisIndexType(value_ - val);
+  }
+
+  inline ThisIndexType &operator+=(const IndexType &i) {
+    value_ += i.value_;
+    return *this;
+  }
+  inline ThisIndexType operator+=(const ValueTypeT &val) {
+    value_ += val;
+    return *this;
+  }
+  inline ThisIndexType &operator-=(const IndexType &i) {
+    value_ -= i.value_;
+    return *this;
+  }
+  inline ThisIndexType operator-=(const ValueTypeT &val) {
+    value_ -= val;
+    return *this;
+  }
+  inline ThisIndexType &operator=(const ThisIndexType &i) {
+    value_ = i.value_;
+    return *this;
+  }
+  inline ThisIndexType &operator=(const ValueTypeT &val) {
+    value_ = val;
+    return *this;
+  }
+
+ private:
+  ValueTypeT value_;
+};
+
+// Stream operator << provided for logging purposes.
+template <class ValueTypeT, class TagT>
+std::ostream &operator<<(std::ostream &os, IndexType<ValueTypeT, TagT> index) {
+  return os << index.value();
+}
+
+}  // namespace draco
+
+// Specialize std::hash for the strongly indexed types.
+namespace std {
+
+template <class ValueTypeT, class TagT>
+struct hash<draco::IndexType<ValueTypeT, TagT>> {
+  size_t operator()(const draco::IndexType<ValueTypeT, TagT> &i) const {
+    return static_cast<size_t>(i.value());
+  }
+};
+
+}  // namespace std
+
+#endif  // DRACO_CORE_DRACO_INDEX_TYPE_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/draco_index_type_vector.h b/Engine/lib/assimp/contrib/draco/src/draco/core/draco_index_type_vector.h
new file mode 100644
index 000000000..aae1e7aaf
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/draco_index_type_vector.h
@@ -0,0 +1,83 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_DRACO_INDEX_TYPE_VECTOR_H_
+#define DRACO_CORE_DRACO_INDEX_TYPE_VECTOR_H_
+
+#include <cstddef>
+#include <utility>
+#include <vector>
+
+#include "draco/core/draco_index_type.h"
+
+namespace draco {
+
+// A wrapper around the standard std::vector that supports indexing of the
+// vector entries using the strongly typed indices as defined in
+// draco_index_type.h .
+// TODO(ostava): Make the interface more complete. It's currently missing
+// features such as iterators.
+// TODO(vytyaz): Add more unit tests for this class.
+template <class IndexTypeT, class ValueTypeT>
+class IndexTypeVector {
+ public:
+  typedef typename std::vector<ValueTypeT>::const_reference const_reference;
+  typedef typename std::vector<ValueTypeT>::reference reference;
+
+  IndexTypeVector() {}
+  explicit IndexTypeVector(size_t size) : vector_(size) {}
+  IndexTypeVector(size_t size, const ValueTypeT &val) : vector_(size, val) {}
+
+  void clear() { vector_.clear(); }
+  void reserve(size_t size) { vector_.reserve(size); }
+  void resize(size_t size) { vector_.resize(size); }
+  void resize(size_t size, const ValueTypeT &val) { vector_.resize(size, val); }
+  void assign(size_t size, const ValueTypeT &val) { vector_.assign(size, val); }
+
+  void swap(IndexTypeVector<IndexTypeT, ValueTypeT> &arg) {
+    vector_.swap(arg.vector_);
+  }
+
+  size_t size() const { return vector_.size(); }
+  bool empty() const { return vector_.empty(); }
+
+  void push_back(const ValueTypeT &val) { vector_.push_back(val); }
+  void push_back(ValueTypeT &&val) { vector_.push_back(std::move(val)); }
+
+  template <typename... Args>
+  void emplace_back(Args &&...args) {
+    vector_.emplace_back(std::forward<Args>(args)...);
+  }
+
+  inline reference operator[](const IndexTypeT &index) {
+    return vector_[index.value()];
+  }
+  inline const_reference operator[](const IndexTypeT &index) const {
+    return vector_[index.value()];
+  }
+  inline reference at(const IndexTypeT &index) {
+    return vector_[index.value()];
+  }
+  inline const_reference at(const IndexTypeT &index) const {
+    return vector_[index.value()];
+  }
+  const ValueTypeT *data() const { return vector_.data(); }
+
+ private:
+  std::vector<ValueTypeT> vector_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_DRACO_INDEX_TYPE_VECTOR_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/draco_test_base.h b/Engine/lib/assimp/contrib/draco/src/draco/core/draco_test_base.h
new file mode 100644
index 000000000..f5c9d751e
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/draco_test_base.h
@@ -0,0 +1,11 @@
+// Wrapper for including googletest indirectly. Useful when the location of the
+// googletest sources must change depending on build environment and repository
+// source location.
+#ifndef DRACO_CORE_DRACO_TEST_BASE_H_
+#define DRACO_CORE_DRACO_TEST_BASE_H_
+
+static bool FLAGS_update_golden_files;
+#include "gtest/gtest.h"
+#include "testing/draco_test_config.h"
+
+#endif  // DRACO_CORE_DRACO_TEST_BASE_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/draco_test_utils.cc b/Engine/lib/assimp/contrib/draco/src/draco/core/draco_test_utils.cc
new file mode 100644
index 000000000..edca9856d
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/draco_test_utils.cc
@@ -0,0 +1,80 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/core/draco_test_utils.h"
+
+#include <fstream>
+
+#include "draco/core/macros.h"
+#include "draco/io/file_utils.h"
+#include "draco_test_base.h"
+
+namespace draco {
+
+namespace {
+static constexpr char kTestDataDir[] = DRACO_TEST_DATA_DIR;
+static constexpr char kTestTempDir[] = DRACO_TEST_TEMP_DIR;
+}  // namespace
+
+std::string GetTestFileFullPath(const std::string &file_name) {
+  return std::string(kTestDataDir) + std::string("/") + file_name;
+}
+
+std::string GetTestTempFileFullPath(const std::string &file_name) {
+  return std::string(kTestTempDir) + std::string("/") + file_name;
+}
+
+bool GenerateGoldenFile(const std::string &golden_file_name, const void *data,
+                        int data_size) {
+  const std::string path = GetTestFileFullPath(golden_file_name);
+  return WriteBufferToFile(data, data_size, path);
+}
+
+bool CompareGoldenFile(const std::string &golden_file_name, const void *data,
+                       int data_size) {
+  const std::string golden_path = GetTestFileFullPath(golden_file_name);
+  std::ifstream in_file(golden_path, std::ios::binary);
+  if (!in_file || data_size < 0) {
+    return false;
+  }
+  const char *const data_c8 = static_cast<const char *>(data);
+  constexpr int buffer_size = 1024;
+  char buffer[buffer_size];
+  size_t extracted_size = 0;
+  size_t remaining_data_size = data_size;
+  int offset = 0;
+  while ((extracted_size = in_file.read(buffer, buffer_size).gcount()) > 0) {
+    if (remaining_data_size <= 0)
+      break;  // Input and golden sizes are different.
+    size_t size_to_check = extracted_size;
+    if (remaining_data_size < size_to_check)
+      size_to_check = remaining_data_size;
+    for (uint32_t i = 0; i < size_to_check; ++i) {
+      if (buffer[i] != data_c8[offset++]) {
+        LOG(INFO) << "Test output differed from golden file at byte "
+                  << offset - 1;
+        return false;
+      }
+    }
+    remaining_data_size -= extracted_size;
+  }
+  if (remaining_data_size != extracted_size) {
+    // Both of these values should be 0 at the end.
+    LOG(INFO) << "Test output size differed from golden file size";
+    return false;
+  }
+  return true;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/draco_test_utils.h b/Engine/lib/assimp/contrib/draco/src/draco/core/draco_test_utils.h
new file mode 100644
index 000000000..fa548f52d
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/draco_test_utils.h
@@ -0,0 +1,93 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_DRACO_TEST_UTILS_H_
+#define DRACO_CORE_DRACO_TEST_UTILS_H_
+
+#include "draco/core/draco_test_base.h"
+#include "draco/io/mesh_io.h"
+#include "draco/io/point_cloud_io.h"
+
+namespace draco {
+
+// Returns the full path to a given file system entry, such as test file or test
+// directory.
+std::string GetTestFileFullPath(const std::string &entry_name);
+
+// Returns the full path to a given temporary file (a location where tests store
+// generated files).
+std::string GetTestTempFileFullPath(const std::string &file_name);
+
+// Generates a new golden file and saves it into the correct folder.
+// Returns false if the file couldn't be created.
+bool GenerateGoldenFile(const std::string &golden_file_name, const void *data,
+                        int data_size);
+
+// Compare a golden file content with the input data.
+// Function will log the first byte position where the data differ.
+// Returns false if there are any differences.
+bool CompareGoldenFile(const std::string &golden_file_name, const void *data,
+                       int data_size);
+
+// Loads a mesh / point cloud specified by a |file_name| that is going to be
+// automatically converted to the correct path available to the testing
+// instance.
+inline std::unique_ptr<Mesh> ReadMeshFromTestFile(
+    const std::string &file_name) {
+  const std::string path = GetTestFileFullPath(file_name);
+  return ReadMeshFromFile(path).value();
+}
+inline std::unique_ptr<Mesh> ReadMeshFromTestFile(const std::string &file_name,
+                                                  bool use_metadata) {
+  const std::string path = GetTestFileFullPath(file_name);
+  return ReadMeshFromFile(path, use_metadata).value();
+}
+inline std::unique_ptr<Mesh> ReadMeshFromTestFile(const std::string &file_name,
+                                                  const Options &options) {
+  const std::string path = GetTestFileFullPath(file_name);
+  return ReadMeshFromFile(path, options).value();
+}
+
+inline std::unique_ptr<PointCloud> ReadPointCloudFromTestFile(
+    const std::string &file_name) {
+  const std::string path = GetTestFileFullPath(file_name);
+  return ReadPointCloudFromFile(path).value();
+}
+
+// Evaluates an expression that returns draco::Status. If the status is not OK,
+// the macro asserts and logs the error message.
+#define DRACO_ASSERT_OK(expression)                                      \
+  {                                                                      \
+    const draco::Status _local_status = (expression);                    \
+    ASSERT_TRUE(_local_status.ok()) << _local_status.error_msg_string(); \
+  }
+
+// In case StatusOr<T> is ok(), this macro assigns value stored in StatusOr<T>
+// to |lhs|, otherwise it asserts and logs the error message.
+//
+//   DRACO_ASSIGN_OR_ASSERT(lhs, expression)
+//
+#define DRACO_ASSIGN_OR_ASSERT(lhs, expression)                                \
+  DRACO_ASSIGN_OR_ASSERT_IMPL_(DRACO_MACROS_IMPL_CONCAT_(_statusor, __LINE__), \
+                               lhs, expression, _status)
+
+// The actual implementation of the above macro.
+#define DRACO_ASSIGN_OR_ASSERT_IMPL_(statusor, lhs, expression, error_expr) \
+  auto statusor = (expression);                                             \
+  ASSERT_TRUE(statusor.ok()) << statusor.status().error_msg_string();       \
+  lhs = std::move(statusor).value();
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_DRACO_TEST_UTILS_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/draco_types.cc b/Engine/lib/assimp/contrib/draco/src/draco/core/draco_types.cc
new file mode 100644
index 000000000..9bde05fda
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/draco_types.cc
@@ -0,0 +1,61 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/core/draco_types.h"
+
+namespace draco {
+
+int32_t DataTypeLength(DataType dt) {
+  switch (dt) {
+    case DT_INT8:
+    case DT_UINT8:
+      return 1;
+    case DT_INT16:
+    case DT_UINT16:
+      return 2;
+    case DT_INT32:
+    case DT_UINT32:
+      return 4;
+    case DT_INT64:
+    case DT_UINT64:
+      return 8;
+    case DT_FLOAT32:
+      return 4;
+    case DT_FLOAT64:
+      return 8;
+    case DT_BOOL:
+      return 1;
+    default:
+      return -1;
+  }
+}
+
+bool IsDataTypeIntegral(DataType dt) {
+  switch (dt) {
+    case DT_INT8:
+    case DT_UINT8:
+    case DT_INT16:
+    case DT_UINT16:
+    case DT_INT32:
+    case DT_UINT32:
+    case DT_INT64:
+    case DT_UINT64:
+    case DT_BOOL:
+      return true;
+    default:
+      return false;
+  }
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/draco_types.h b/Engine/lib/assimp/contrib/draco/src/draco/core/draco_types.h
new file mode 100644
index 000000000..d14437a02
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/draco_types.h
@@ -0,0 +1,52 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_DRACO_TYPES_H_
+#define DRACO_CORE_DRACO_TYPES_H_
+
+#include <stdint.h>
+
+#include <string>
+
+#include "draco/draco_features.h"
+
+namespace draco {
+
+enum DataType {
+  // Not a legal value for DataType. Used to indicate a field has not been set.
+  DT_INVALID = 0,
+  DT_INT8,
+  DT_UINT8,
+  DT_INT16,
+  DT_UINT16,
+  DT_INT32,
+  DT_UINT32,
+  DT_INT64,
+  DT_UINT64,
+  DT_FLOAT32,
+  DT_FLOAT64,
+  DT_BOOL,
+  DT_TYPES_COUNT
+};
+
+int32_t DataTypeLength(DataType dt);
+
+// Equivalent to std::is_integral for draco::DataType. Returns true for all
+// signed and unsigned integer types (including DT_BOOL). Returns false
+// otherwise.
+bool IsDataTypeIntegral(DataType dt);
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_DRACO_TYPES_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/draco_version.h b/Engine/lib/assimp/contrib/draco/src/draco/core/draco_version.h
new file mode 100644
index 000000000..14a504a50
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/draco_version.h
@@ -0,0 +1,27 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_DRACO_VERSION_H_
+#define DRACO_CORE_DRACO_VERSION_H_
+
+namespace draco {
+
+// Draco version is comprised of <major>.<minor>.<revision>.
+static const char kDracoVersion[] = "1.4.1";
+
+const char *Version() { return kDracoVersion; }
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_DRACO_VERSION_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/encoder_buffer.cc b/Engine/lib/assimp/contrib/draco/src/draco/core/encoder_buffer.cc
new file mode 100644
index 000000000..df98677a8
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/encoder_buffer.cc
@@ -0,0 +1,93 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/core/encoder_buffer.h"
+
+#include <cstring>  // for memcpy
+
+#include "draco/core/varint_encoding.h"
+
+namespace draco {
+
+EncoderBuffer::EncoderBuffer()
+    : bit_encoder_reserved_bytes_(false), encode_bit_sequence_size_(false) {}
+
+void EncoderBuffer::Clear() {
+  buffer_.clear();
+  bit_encoder_reserved_bytes_ = 0;
+}
+
+void EncoderBuffer::Resize(int64_t nbytes) { buffer_.resize(nbytes); }
+
+bool EncoderBuffer::StartBitEncoding(int64_t required_bits, bool encode_size) {
+  if (bit_encoder_active()) {
+    return false;  // Bit encoding mode already active.
+  }
+  if (required_bits <= 0) {
+    return false;  // Invalid size.
+  }
+  encode_bit_sequence_size_ = encode_size;
+  const int64_t required_bytes = (required_bits + 7) / 8;
+  bit_encoder_reserved_bytes_ = required_bytes;
+  uint64_t buffer_start_size = buffer_.size();
+  if (encode_size) {
+    // Reserve memory for storing the encoded bit sequence size. It will be
+    // filled once the bit encoding ends.
+    buffer_start_size += sizeof(uint64_t);
+  }
+  // Resize buffer to fit the maximum size of encoded bit data.
+  buffer_.resize(buffer_start_size + required_bytes);
+  // Get the buffer data pointer for the bit encoder.
+  const char *const data = buffer_.data() + buffer_start_size;
+  bit_encoder_ =
+      std::unique_ptr<BitEncoder>(new BitEncoder(const_cast<char *>(data)));
+  return true;
+}
+
+void EncoderBuffer::EndBitEncoding() {
+  if (!bit_encoder_active()) {
+    return;
+  }
+  // Get the number of encoded bits and bytes (rounded up).
+  const uint64_t encoded_bits = bit_encoder_->Bits();
+  const uint64_t encoded_bytes = (encoded_bits + 7) / 8;
+  // Flush all cached bits that are not in the bit encoder's main buffer.
+  bit_encoder_->Flush(0);
+  // Encode size if needed.
+  if (encode_bit_sequence_size_) {
+    char *out_mem = const_cast<char *>(data() + size());
+    // Make the out_mem point to the memory reserved for storing the size.
+    out_mem = out_mem - (bit_encoder_reserved_bytes_ + sizeof(uint64_t));
+
+    EncoderBuffer var_size_buffer;
+    EncodeVarint(encoded_bytes, &var_size_buffer);
+    const uint32_t size_len = static_cast<uint32_t>(var_size_buffer.size());
+    char *const dst = out_mem + size_len;
+    const char *const src = out_mem + sizeof(uint64_t);
+    memmove(dst, src, encoded_bytes);
+
+    // Store the size of the encoded data.
+    memcpy(out_mem, var_size_buffer.data(), size_len);
+
+    // We need to account for the difference between the preallocated and actual
+    // storage needed for storing the encoded length. This will be used later to
+    // compute the correct size of |buffer_|.
+    bit_encoder_reserved_bytes_ += sizeof(uint64_t) - size_len;
+  }
+  // Resize the underlying buffer to match the number of encoded bits.
+  buffer_.resize(buffer_.size() - bit_encoder_reserved_bytes_ + encoded_bytes);
+  bit_encoder_reserved_bytes_ = 0;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/encoder_buffer.h b/Engine/lib/assimp/contrib/draco/src/draco/core/encoder_buffer.h
new file mode 100644
index 000000000..b153a6297
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/encoder_buffer.h
@@ -0,0 +1,152 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_ENCODER_BUFFER_H_
+#define DRACO_CORE_ENCODER_BUFFER_H_
+
+#include <memory>
+#include <vector>
+
+#include "draco/core/bit_utils.h"
+#include "draco/core/macros.h"
+
+namespace draco {
+
+// Class representing a buffer that can be used for either for byte-aligned
+// encoding of arbitrary data structures or for encoding of variable-length
+// bit data.
+class EncoderBuffer {
+ public:
+  EncoderBuffer();
+  void Clear();
+  void Resize(int64_t nbytes);
+
+  // Start encoding a bit sequence. A maximum size of the sequence needs to
+  // be known upfront.
+  // If encode_size is true, the size of encoded bit sequence is stored before
+  // the sequence. Decoder can then use this size to skip over the bit sequence
+  // if needed.
+  // Returns false on error.
+  bool StartBitEncoding(int64_t required_bits, bool encode_size);
+
+  // End the encoding of the bit sequence and return to the default byte-aligned
+  // encoding.
+  void EndBitEncoding();
+
+  // Encode up to 32 bits into the buffer. Can be called only in between
+  // StartBitEncoding and EndBitEncoding. Otherwise returns false.
+  bool EncodeLeastSignificantBits32(int nbits, uint32_t value) {
+    if (!bit_encoder_active()) {
+      return false;
+    }
+    bit_encoder_->PutBits(value, nbits);
+    return true;
+  }
+  // Encode an arbitrary data type.
+  // Can be used only when we are not encoding a bit-sequence.
+  // Returns false when the value couldn't be encoded.
+  template <typename T>
+  bool Encode(const T &data) {
+    if (bit_encoder_active()) {
+      return false;
+    }
+    const uint8_t *src_data = reinterpret_cast<const uint8_t *>(&data);
+    buffer_.insert(buffer_.end(), src_data, src_data + sizeof(T));
+    return true;
+  }
+  bool Encode(const void *data, size_t data_size) {
+    if (bit_encoder_active()) {
+      return false;
+    }
+    const uint8_t *src_data = reinterpret_cast<const uint8_t *>(data);
+    buffer_.insert(buffer_.end(), src_data, src_data + data_size);
+    return true;
+  }
+
+  bool bit_encoder_active() const { return bit_encoder_reserved_bytes_ > 0; }
+  const char *data() const { return buffer_.data(); }
+  size_t size() const { return buffer_.size(); }
+  std::vector<char> *buffer() { return &buffer_; }
+
+ private:
+  // Internal helper class to encode bits to a bit buffer.
+  class BitEncoder {
+   public:
+    // |data| is the buffer to write the bits into.
+    explicit BitEncoder(char *data) : bit_buffer_(data), bit_offset_(0) {}
+
+    // Write |nbits| of |data| into the bit buffer.
+    void PutBits(uint32_t data, int32_t nbits) {
+      DRACO_DCHECK_GE(nbits, 0);
+      DRACO_DCHECK_LE(nbits, 32);
+      for (int32_t bit = 0; bit < nbits; ++bit) {
+        PutBit((data >> bit) & 1);
+      }
+    }
+
+    // Return number of bits encoded so far.
+    uint64_t Bits() const { return static_cast<uint64_t>(bit_offset_); }
+
+    // TODO(fgalligan): Remove this function once we know we do not need the
+    // old API anymore.
+    // This is a function of an old API, that currently does nothing.
+    void Flush(int /* left_over_bit_value */) {}
+
+    // Return the number of bits required to store the given number
+    static uint32_t BitsRequired(uint32_t x) {
+      return static_cast<uint32_t>(MostSignificantBit(x));
+    }
+
+   private:
+    void PutBit(uint8_t value) {
+      const int byte_size = 8;
+      const uint64_t off = static_cast<uint64_t>(bit_offset_);
+      const uint64_t byte_offset = off / byte_size;
+      const int bit_shift = off % byte_size;
+
+      // TODO(fgalligan): Check performance if we add a branch and only do one
+      // memory write if bit_shift is 7. Also try using a temporary variable to
+      // hold the bits before writing to the buffer.
+
+      bit_buffer_[byte_offset] &= ~(1 << bit_shift);
+      bit_buffer_[byte_offset] |= value << bit_shift;
+      bit_offset_++;
+    }
+
+    char *bit_buffer_;
+    size_t bit_offset_;
+  };
+  friend class BufferBitCodingTest;
+  // All data is stored in this vector.
+  std::vector<char> buffer_;
+
+  // Bit encoder is used when encoding variable-length bit data.
+  // TODO(ostava): Currently encoder needs to be recreated each time
+  // StartBitEncoding method is called. This is not necessary if BitEncoder
+  // supported reset function which can easily added but let's leave that for
+  // later.
+  std::unique_ptr<BitEncoder> bit_encoder_;
+
+  // The number of bytes reserved for bit encoder.
+  // Values > 0 indicate we are in the bit encoding mode.
+  int64_t bit_encoder_reserved_bytes_;
+
+  // Flag used indicating that we need to store the length of the currently
+  // processed bit sequence.
+  bool encode_bit_sequence_size_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_ENCODER_BUFFER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/hash_utils.cc b/Engine/lib/assimp/contrib/draco/src/draco/core/hash_utils.cc
new file mode 100644
index 000000000..fbbd653f3
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/hash_utils.cc
@@ -0,0 +1,58 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/core/hash_utils.h"
+
+#include <cstddef>
+#include <functional>
+#include <limits>
+
+namespace draco {
+
+// Will never return 1 or 0.
+uint64_t FingerprintString(const char *s, size_t len) {
+  const uint64_t seed = 0x87654321;
+  const int hash_loop_count = static_cast<int>(len / 8) + 1;
+  uint64_t hash = seed;
+
+  for (int i = 0; i < hash_loop_count; ++i) {
+    const int off = i * 8;
+    const int num_chars_left = static_cast<int>(len) - off;
+    uint64_t new_hash = seed;
+
+    if (num_chars_left > 7) {
+      const int off2 = i * 8;
+      new_hash = static_cast<uint64_t>(s[off2]) << 56 |
+                 static_cast<uint64_t>(s[off2 + 1]) << 48 |
+                 static_cast<uint64_t>(s[off2 + 2]) << 40 |
+                 static_cast<uint64_t>(s[off2 + 3]) << 32 |
+                 static_cast<uint64_t>(s[off2 + 4]) << 24 |
+                 static_cast<uint64_t>(s[off2 + 5]) << 16 |
+                 static_cast<uint64_t>(s[off2 + 6]) << 8 | s[off2 + 7];
+    } else {
+      for (int j = 0; j < num_chars_left; ++j) {
+        new_hash |= static_cast<uint64_t>(s[off + j])
+                    << (64 - ((num_chars_left - j) * 8));
+      }
+    }
+
+    hash = HashCombine(new_hash, hash);
+  }
+
+  if (hash < std::numeric_limits<uint64_t>::max() - 1) {
+    hash += 2;
+  }
+  return hash;
+}
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/hash_utils.h b/Engine/lib/assimp/contrib/draco/src/draco/core/hash_utils.h
new file mode 100644
index 000000000..aa61523e7
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/hash_utils.h
@@ -0,0 +1,64 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_HASH_UTILS_H_
+#define DRACO_CORE_HASH_UTILS_H_
+
+#include <stdint.h>
+
+#include <cstddef>
+#include <functional>
+
+namespace draco {
+
+template <typename T1, typename T2>
+size_t HashCombine(T1 a, T2 b) {
+  const size_t hash1 = std::hash<T1>()(a);
+  const size_t hash2 = std::hash<T2>()(b);
+  return (hash1 << 2) ^ (hash2 << 1);
+}
+
+template <typename T>
+size_t HashCombine(T a, size_t hash) {
+  const size_t hasha = std::hash<T>()(a);
+  return (hash) ^ (hasha + 239);
+}
+
+inline uint64_t HashCombine(uint64_t a, uint64_t b) {
+  return (a + 1013) ^ (b + 107) << 1;
+}
+
+// Will never return 1 or 0.
+uint64_t FingerprintString(const char *s, size_t len);
+
+// Hash for std::array.
+template <typename T>
+struct HashArray {
+  size_t operator()(const T &a) const {
+    size_t hash = 79;  // Magic number.
+    for (unsigned int i = 0; i < std::tuple_size<T>::value; ++i) {
+      hash = HashCombine(hash, ValueHash(a[i]));
+    }
+    return hash;
+  }
+
+  template <typename V>
+  size_t ValueHash(const V &val) const {
+    return std::hash<V>()(val);
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_HASH_UTILS_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/macros.h b/Engine/lib/assimp/contrib/draco/src/draco/core/macros.h
new file mode 100644
index 000000000..147bbaafc
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/macros.h
@@ -0,0 +1,119 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_MACROS_H_
+#define DRACO_CORE_MACROS_H_
+
+#include "assert.h"
+#include "draco/draco_features.h"
+
+#ifdef ANDROID_LOGGING
+#include <android/log.h>
+#define LOG_TAG "draco"
+#define DRACO_LOGI(...) \
+  __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
+#define DRACO_LOGE(...) \
+  __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+#else
+#define DRACO_LOGI printf
+#define DRACO_LOGE printf
+#endif
+
+#include <iostream>
+namespace draco {
+
+#ifndef DISALLOW_COPY_AND_ASSIGN
+#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
+  TypeName(const TypeName &) = delete;     \
+  void operator=(const TypeName &) = delete;
+#endif
+
+#ifndef FALLTHROUGH_INTENDED
+#if defined(__clang__) && defined(__has_warning)
+#if __has_feature(cxx_attributes) && __has_warning("-Wimplicit-fallthrough")
+#define FALLTHROUGH_INTENDED [[clang::fallthrough]]
+#endif
+#elif defined(__GNUC__) && __GNUC__ >= 7
+#define FALLTHROUGH_INTENDED [[gnu::fallthrough]]
+#endif
+
+// If FALLTHROUGH_INTENDED is still not defined, define it.
+#ifndef FALLTHROUGH_INTENDED
+#define FALLTHROUGH_INTENDED \
+  do {                       \
+  } while (0)
+#endif
+#endif
+
+#ifndef LOG
+#define LOG(...) std::cout
+#endif
+
+#ifndef VLOG
+#define VLOG(...) std::cout
+#endif
+
+}  // namespace draco
+
+#ifdef DRACO_DEBUG
+#define DRACO_DCHECK(x) (assert(x));
+#define DRACO_DCHECK_EQ(a, b) assert((a) == (b));
+#define DRACO_DCHECK_NE(a, b) assert((a) != (b));
+#define DRACO_DCHECK_GE(a, b) assert((a) >= (b));
+#define DRACO_DCHECK_GT(a, b) assert((a) > (b));
+#define DRACO_DCHECK_LE(a, b) assert((a) <= (b));
+#define DRACO_DCHECK_LT(a, b) assert((a) < (b));
+#define DRACO_DCHECK_NOTNULL(x) assert((x) != NULL);
+#else
+#define DRACO_DCHECK(x)
+#define DRACO_DCHECK_EQ(a, b)
+#define DRACO_DCHECK_NE(a, b)
+#define DRACO_DCHECK_GE(a, b)
+#define DRACO_DCHECK_GT(a, b)
+#define DRACO_DCHECK_LE(a, b)
+#define DRACO_DCHECK_LT(a, b)
+#define DRACO_DCHECK_NOTNULL(x)
+#endif
+
+// Helper macros for concatenating macro values.
+#define DRACO_MACROS_IMPL_CONCAT_INNER_(x, y) x##y
+#define DRACO_MACROS_IMPL_CONCAT_(x, y) DRACO_MACROS_IMPL_CONCAT_INNER_(x, y)
+
+// Expand the n-th argument of the macro. Used to select an argument based on
+// the number of entries in a variadic macro argument. Example usage:
+//
+// #define FUNC_1(x) x
+// #define FUNC_2(x, y) x + y
+// #define FUNC_3(x, y, z) x + y + z
+//
+// #define VARIADIC_MACRO(...)
+//   DRACO_SELECT_NTH_FROM_3(__VA_ARGS__, FUNC_3, FUNC_2, FUNC_1) __VA_ARGS__
+//
+#define DRACO_SELECT_NTH_FROM_2(_1, _2, NAME) NAME
+#define DRACO_SELECT_NTH_FROM_3(_1, _2, _3, NAME) NAME
+#define DRACO_SELECT_NTH_FROM_4(_1, _2, _3, _4, NAME) NAME
+
+// Macro that converts the Draco bit-stream into one uint16_t number.
+// Useful mostly when checking version numbers.
+#define DRACO_BITSTREAM_VERSION(MAJOR, MINOR) \
+  ((static_cast<uint16_t>(MAJOR) << 8) | MINOR)
+
+// Macro that converts the uint16_t Draco bit-stream number into the major
+// and minor components respectively.
+#define DRACO_BISTREAM_VERSION_MAJOR(VERSION) \
+  (static_cast<uint8_t>(VERSION >> 8))
+#define DRACO_BISTREAM_VERSION_MINOR(VERSION) \
+  (static_cast<uint8_t>(VERSION & 0xFF))
+
+#endif  // DRACO_CORE_MACROS_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/math_utils.h b/Engine/lib/assimp/contrib/draco/src/draco/core/math_utils.h
new file mode 100644
index 000000000..7f382fa34
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/math_utils.h
@@ -0,0 +1,55 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_MATH_UTILS_H_
+#define DRACO_CORE_MATH_UTILS_H_
+
+#include <inttypes.h>
+
+#include "draco/core/vector_d.h"
+
+#define DRACO_INCREMENT_MOD(I, M) (((I) == ((M)-1)) ? 0 : ((I) + 1))
+
+// Returns floor(sqrt(x)) where x is an integer number. The main intend of this
+// function is to provide a cross platform and deterministic implementation of
+// square root for integer numbers. This function is not intended to be a
+// replacement for std::sqrt() for general cases. IntSqrt is in fact about 3X
+// slower compared to most implementation of std::sqrt().
+inline uint64_t IntSqrt(uint64_t number) {
+  if (number == 0) {
+    return 0;
+  }
+  // First estimate good initial value of the square root as log2(number).
+  uint64_t act_number = number;
+  uint64_t square_root = 1;
+  while (act_number >= 2) {
+    // Double the square root until |square_root * square_root > number|.
+    square_root *= 2;
+    act_number /= 4;
+  }
+  // Perform Newton's (or Babylonian) method to find the true floor(sqrt()).
+  do {
+    // New |square_root| estimate is computed as the average between
+    // |square_root| and |number / square_root|.
+    square_root = (square_root + number / square_root) / 2;
+
+    // Note that after the first iteration, the estimate is always going to be
+    // larger or equal to the true square root value. Therefore to check
+    // convergence, we can simply detect condition when the square of the
+    // estimated square root is larger than the input.
+  } while (square_root * square_root > number);
+  return square_root;
+}
+
+#endif  // DRACO_CORE_MATH_UTILS_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/math_utils_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/core/math_utils_test.cc
new file mode 100644
index 000000000..8c255d046
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/math_utils_test.cc
@@ -0,0 +1,22 @@
+#include "draco/core/math_utils.h"
+
+#include <cmath>
+#include <random>
+
+#include "draco/core/draco_test_base.h"
+
+using draco::Vector3f;
+
+TEST(MathUtils, Mod) { EXPECT_EQ(DRACO_INCREMENT_MOD(1, 1 << 1), 0); }
+
+TEST(MathUtils, IntSqrt) {
+  ASSERT_EQ(IntSqrt(0), 0);
+  // 64-bit pseudo random number generator seeded with a predefined number.
+  std::mt19937_64 generator(109);
+  std::uniform_int_distribution<uint64_t> distribution(0, 1ull << 60);
+
+  for (int i = 0; i < 10000; ++i) {
+    const uint64_t number = distribution(generator);
+    ASSERT_EQ(IntSqrt(number), static_cast<uint64_t>(floor(std::sqrt(number))));
+  }
+}
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/options.cc b/Engine/lib/assimp/contrib/draco/src/draco/core/options.cc
new file mode 100644
index 000000000..9b81db489
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/options.cc
@@ -0,0 +1,94 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/core/options.h"
+
+#include <cstdlib>
+#include <string>
+#include <utility>
+
+namespace draco {
+
+Options::Options() {}
+
+void Options::MergeAndReplace(const Options &other_options) {
+  for (const auto &item : other_options.options_) {
+    options_[item.first] = item.second;
+  }
+}
+
+void Options::SetInt(const std::string &name, int val) {
+  options_[name] = std::to_string(val);
+}
+
+void Options::SetFloat(const std::string &name, float val) {
+  options_[name] = std::to_string(val);
+}
+
+void Options::SetBool(const std::string &name, bool val) {
+  options_[name] = std::to_string(val ? 1 : 0);
+}
+
+void Options::SetString(const std::string &name, const std::string &val) {
+  options_[name] = val;
+}
+
+int Options::GetInt(const std::string &name) const { return GetInt(name, -1); }
+
+int Options::GetInt(const std::string &name, int default_val) const {
+  const auto it = options_.find(name);
+  if (it == options_.end()) {
+    return default_val;
+  }
+  return std::atoi(it->second.c_str());
+}
+
+float Options::GetFloat(const std::string &name) const {
+  return GetFloat(name, -1);
+}
+
+float Options::GetFloat(const std::string &name, float default_val) const {
+  const auto it = options_.find(name);
+  if (it == options_.end()) {
+    return default_val;
+  }
+  return static_cast<float>(std::atof(it->second.c_str()));
+}
+
+bool Options::GetBool(const std::string &name) const {
+  return GetBool(name, false);
+}
+
+bool Options::GetBool(const std::string &name, bool default_val) const {
+  const int ret = GetInt(name, -1);
+  if (ret == -1) {
+    return default_val;
+  }
+  return static_cast<bool>(ret);
+}
+
+std::string Options::GetString(const std::string &name) const {
+  return GetString(name, "");
+}
+
+std::string Options::GetString(const std::string &name,
+                               const std::string &default_val) const {
+  const auto it = options_.find(name);
+  if (it == options_.end()) {
+    return default_val;
+  }
+  return it->second;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/options.h b/Engine/lib/assimp/contrib/draco/src/draco/core/options.h
new file mode 100644
index 000000000..1bc4dc0fb
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/options.h
@@ -0,0 +1,150 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_OPTIONS_H_
+#define DRACO_CORE_OPTIONS_H_
+
+#include <cstdlib>
+#include <map>
+#include <string>
+
+namespace draco {
+
+// Class for storing generic options as a <name, value> pair in a string map.
+// The API provides helper methods for directly storing values of various types
+// such as ints and bools. One named option should be set with only a single
+// data type.
+class Options {
+ public:
+  Options();
+
+  // Merges |other_options| on top of the existing options of this instance
+  // replacing all entries that are present in both options instances.
+  void MergeAndReplace(const Options &other_options);
+
+  void SetInt(const std::string &name, int val);
+  void SetFloat(const std::string &name, float val);
+  void SetBool(const std::string &name, bool val);
+  void SetString(const std::string &name, const std::string &val);
+  template <class VectorT>
+  void SetVector(const std::string &name, const VectorT &vec) {
+    SetVector(name, &vec[0], VectorT::dimension);
+  }
+  template <typename DataTypeT>
+  void SetVector(const std::string &name, const DataTypeT *vec, int num_dims);
+
+  // Getters will return a default value if the entry is not found. The default
+  // value can be specified in the overloaded version of each function.
+  int GetInt(const std::string &name) const;
+  int GetInt(const std::string &name, int default_val) const;
+  float GetFloat(const std::string &name) const;
+  float GetFloat(const std::string &name, float default_val) const;
+  bool GetBool(const std::string &name) const;
+  bool GetBool(const std::string &name, bool default_val) const;
+  std::string GetString(const std::string &name) const;
+  std::string GetString(const std::string &name,
+                        const std::string &default_val) const;
+  template <class VectorT>
+  VectorT GetVector(const std::string &name, const VectorT &default_val) const;
+  // Unlike other Get functions, this function returns false if the option does
+  // not exist, otherwise it fills |out_val| with the vector values. If a
+  // default value is needed, it can be set in |out_val|.
+  template <typename DataTypeT>
+  bool GetVector(const std::string &name, int num_dims,
+                 DataTypeT *out_val) const;
+
+  bool IsOptionSet(const std::string &name) const {
+    return options_.count(name) > 0;
+  }
+
+ private:
+  // All entries are internally stored as strings and converted to the desired
+  // return type based on the used Get* method.
+  // TODO(ostava): Consider adding type safety mechanism that would prevent
+  // unsafe operations such as a conversion from vector to int.
+  std::map<std::string, std::string> options_;
+};
+
+template <typename DataTypeT>
+void Options::SetVector(const std::string &name, const DataTypeT *vec,
+                        int num_dims) {
+  std::string out;
+  for (int i = 0; i < num_dims; ++i) {
+    if (i > 0) {
+      out += " ";
+    }
+
+// GNU STL on android doesn't include a proper std::to_string, but the libc++
+// version does
+#if defined(ANDROID) && !defined(_LIBCPP_VERSION)
+    out += to_string(vec[i]);
+#else
+    out += std::to_string(vec[i]);
+#endif
+  }
+  options_[name] = out;
+}
+
+template <class VectorT>
+VectorT Options::GetVector(const std::string &name,
+                           const VectorT &default_val) const {
+  VectorT ret = default_val;
+  GetVector(name, VectorT::dimension, &ret[0]);
+  return ret;
+}
+
+template <typename DataTypeT>
+bool Options::GetVector(const std::string &name, int num_dims,
+                        DataTypeT *out_val) const {
+  const auto it = options_.find(name);
+  if (it == options_.end()) {
+    return false;
+  }
+  const std::string value = it->second;
+  if (value.length() == 0) {
+    return true;  // Option set but no data is present
+  }
+  const char *act_str = value.c_str();
+  char *next_str;
+  for (int i = 0; i < num_dims; ++i) {
+    if (std::is_integral<DataTypeT>::value) {
+#ifdef ANDROID
+      const int val = strtol(act_str, &next_str, 10);
+#else
+      const int val = static_cast<int>(std::strtol(act_str, &next_str, 10));
+#endif
+      if (act_str == next_str) {
+        return true;  // End reached.
+      }
+      act_str = next_str;
+      out_val[i] = static_cast<DataTypeT>(val);
+    } else {
+#ifdef ANDROID
+      const float val = strtof(act_str, &next_str);
+#else
+      const float val = std::strtof(act_str, &next_str);
+#endif
+      if (act_str == next_str) {
+        return true;  // End reached.
+      }
+      act_str = next_str;
+      out_val[i] = static_cast<DataTypeT>(val);
+    }
+  }
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_OPTIONS_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/quantization_utils.cc b/Engine/lib/assimp/contrib/draco/src/draco/core/quantization_utils.cc
new file mode 100644
index 000000000..58dcf5c8c
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/quantization_utils.cc
@@ -0,0 +1,42 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/core/quantization_utils.h"
+
+namespace draco {
+
+Quantizer::Quantizer() : inverse_delta_(1.f) {}
+
+void Quantizer::Init(float range, int32_t max_quantized_value) {
+  inverse_delta_ = static_cast<float>(max_quantized_value) / range;
+}
+
+void Quantizer::Init(float delta) { inverse_delta_ = 1.f / delta; }
+
+Dequantizer::Dequantizer() : delta_(1.f) {}
+
+bool Dequantizer::Init(float range, int32_t max_quantized_value) {
+  if (max_quantized_value <= 0) {
+    return false;
+  }
+  delta_ = range / static_cast<float>(max_quantized_value);
+  return true;
+}
+
+bool Dequantizer::Init(float delta) {
+  delta_ = delta;
+  return true;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/quantization_utils.h b/Engine/lib/assimp/contrib/draco/src/draco/core/quantization_utils.h
new file mode 100644
index 000000000..0f60f1e1b
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/quantization_utils.h
@@ -0,0 +1,82 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// A set of classes for quantizing and dequantizing of floating point values
+// into integers.
+// The quantization works on all floating point numbers within (-range, +range)
+// interval producing integers in range
+// (-max_quantized_value, +max_quantized_value).
+
+#ifndef DRACO_CORE_QUANTIZATION_UTILS_H_
+#define DRACO_CORE_QUANTIZATION_UTILS_H_
+
+#include <stdint.h>
+
+#include <cmath>
+
+#include "draco/core/macros.h"
+
+namespace draco {
+
+// Class for quantizing single precision floating point values. The values
+// should be centered around zero and be within interval (-range, +range), where
+// the range is specified in the Init() method. Alternatively, the quantization
+// can be defined by |delta| that specifies the distance between two quantized
+// values. Note that the quantizer always snaps the values to the nearest
+// integer value. E.g. for |delta| == 1.f, values -0.4f and 0.4f would be
+// both quantized to 0 while value 0.6f would be quantized to 1. If a value
+// lies exactly between two quantized states, it is always rounded up. E.g.,
+// for |delta| == 1.f, value -0.5f would be quantized to 0 while 0.5f would be
+// quantized to 1.
+class Quantizer {
+ public:
+  Quantizer();
+  void Init(float range, int32_t max_quantized_value);
+  void Init(float delta);
+  inline int32_t QuantizeFloat(float val) const {
+    val *= inverse_delta_;
+    return static_cast<int32_t>(floor(val + 0.5f));
+  }
+  inline int32_t operator()(float val) const { return QuantizeFloat(val); }
+
+ private:
+  float inverse_delta_;
+};
+
+// Class for dequantizing values that were previously quantized using the
+// Quantizer class.
+class Dequantizer {
+ public:
+  Dequantizer();
+
+  // Initializes the dequantizer. Both parameters must correspond to the values
+  // provided to the initializer of the Quantizer class.
+  // Returns false when the initialization fails.
+  bool Init(float range, int32_t max_quantized_value);
+
+  // Initializes the dequantizer using the |delta| between two quantized values.
+  bool Init(float delta);
+
+  inline float DequantizeFloat(int32_t val) const {
+    return static_cast<float>(val) * delta_;
+  }
+  inline float operator()(int32_t val) const { return DequantizeFloat(val); }
+
+ private:
+  float delta_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_QUANTIZATION_UTILS_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/quantization_utils_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/core/quantization_utils_test.cc
new file mode 100644
index 000000000..b4f0473f2
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/quantization_utils_test.cc
@@ -0,0 +1,91 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/core/quantization_utils.h"
+
+#include "draco/core/draco_test_base.h"
+
+namespace draco {
+
+class QuantizationUtilsTest : public ::testing::Test {};
+
+TEST_F(QuantizationUtilsTest, TestQuantizer) {
+  Quantizer quantizer;
+  quantizer.Init(10.f, 255);
+  EXPECT_EQ(quantizer.QuantizeFloat(0.f), 0);
+  EXPECT_EQ(quantizer.QuantizeFloat(10.f), 255);
+  EXPECT_EQ(quantizer.QuantizeFloat(-10.f), -255);
+  EXPECT_EQ(quantizer.QuantizeFloat(4.999f), 127);
+  EXPECT_EQ(quantizer.QuantizeFloat(5.f), 128);
+  EXPECT_EQ(quantizer.QuantizeFloat(-4.9999f), -127);
+  // Note: Both -5.f and +5.f lie exactly on the boundary between two
+  // quantized values (127.5f and -127.5f). Due to rounding, both values are
+  // then converted to 128 and -127 respectively.
+  EXPECT_EQ(quantizer.QuantizeFloat(-5.f), -127);
+  EXPECT_EQ(quantizer.QuantizeFloat(-5.0001f), -128);
+
+  // Out of range quantization.
+  // The behavior is technically undefined, but both quantizer and dequantizer
+  // should still work correctly unless the quantized values overflow.
+  EXPECT_LT(quantizer.QuantizeFloat(-15.f), -255);
+  EXPECT_GT(quantizer.QuantizeFloat(15.f), 255);
+}
+
+TEST_F(QuantizationUtilsTest, TestDequantizer) {
+  Dequantizer dequantizer;
+  ASSERT_TRUE(dequantizer.Init(10.f, 255));
+  EXPECT_EQ(dequantizer.DequantizeFloat(0), 0.f);
+  EXPECT_EQ(dequantizer.DequantizeFloat(255), 10.f);
+  EXPECT_EQ(dequantizer.DequantizeFloat(-255), -10.f);
+  EXPECT_EQ(dequantizer.DequantizeFloat(128), 10.f * (128.f / 255.f));
+
+  // Test that the dequantizer fails to initialize with invalid input
+  // parameters.
+  ASSERT_FALSE(dequantizer.Init(1.f, 0));
+  ASSERT_FALSE(dequantizer.Init(1.f, -4));
+}
+
+TEST_F(QuantizationUtilsTest, TestDeltaQuantization) {
+  // Test verifies that the quantizer and dequantizer work correctly when
+  // initialized with a delta value.
+  Quantizer quantizer_delta;
+  quantizer_delta.Init(0.5f);
+
+  Quantizer quantizer_range;
+  quantizer_range.Init(50.f, 100);
+
+  EXPECT_EQ(quantizer_delta.QuantizeFloat(1.2f), 2);
+  EXPECT_EQ(quantizer_delta.QuantizeFloat(10.f),
+            quantizer_range.QuantizeFloat(10.f));
+  EXPECT_EQ(quantizer_delta.QuantizeFloat(-3.3f),
+            quantizer_range.QuantizeFloat(-3.3f));
+  EXPECT_EQ(quantizer_delta.QuantizeFloat(0.25f),
+            quantizer_range.QuantizeFloat(0.25f));
+
+  Dequantizer dequantizer_delta;
+  dequantizer_delta.Init(0.5f);
+
+  Dequantizer dequantizer_range;
+  dequantizer_range.Init(50.f, 100);
+
+  EXPECT_EQ(dequantizer_delta.DequantizeFloat(2), 1.f);
+  EXPECT_EQ(dequantizer_delta.DequantizeFloat(-4),
+            dequantizer_range.DequantizeFloat(-4));
+  EXPECT_EQ(dequantizer_delta.DequantizeFloat(9),
+            dequantizer_range.DequantizeFloat(9));
+  EXPECT_EQ(dequantizer_delta.DequantizeFloat(0),
+            dequantizer_range.DequantizeFloat(0));
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/status.h b/Engine/lib/assimp/contrib/draco/src/draco/core/status.h
new file mode 100644
index 000000000..449ad8566
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/status.h
@@ -0,0 +1,77 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_STATUS_H_
+#define DRACO_CORE_STATUS_H_
+
+#include <string>
+
+namespace draco {
+
+// Class encapsulating a return status of an operation with an optional error
+// message. Intended to be used as a return type for functions instead of bool.
+class Status {
+ public:
+  enum Code {
+    OK = 0,
+    DRACO_ERROR = -1,          // Used for general errors.
+    IO_ERROR = -2,             // Error when handling input or output stream.
+    INVALID_PARAMETER = -3,    // Invalid parameter passed to a function.
+    UNSUPPORTED_VERSION = -4,  // Input not compatible with the current version.
+    UNKNOWN_VERSION = -5,      // Input was created with an unknown version of
+                               // the library.
+    UNSUPPORTED_FEATURE = -6,  // Input contains feature that is not supported.
+  };
+
+  Status() : code_(OK) {}
+  Status(const Status &status) = default;
+  Status(Status &&status) = default;
+  explicit Status(Code code) : code_(code) {}
+  Status(Code code, const std::string &error_msg)
+      : code_(code), error_msg_(error_msg) {}
+
+  Code code() const { return code_; }
+  const std::string &error_msg_string() const { return error_msg_; }
+  const char *error_msg() const { return error_msg_.c_str(); }
+
+  bool operator==(Code code) const { return code == code_; }
+  bool ok() const { return code_ == OK; }
+
+  Status &operator=(const Status &) = default;
+
+ private:
+  Code code_;
+  std::string error_msg_;
+};
+
+inline std::ostream &operator<<(std::ostream &os, const Status &status) {
+  os << status.error_msg_string();
+  return os;
+}
+
+inline Status OkStatus() { return Status(Status::OK); }
+
+// Evaluates an expression that returns draco::Status. If the status is not OK,
+// the macro returns the status object.
+#define DRACO_RETURN_IF_ERROR(expression)             \
+  {                                                   \
+    const draco::Status _local_status = (expression); \
+    if (!_local_status.ok()) {                        \
+      return _local_status;                           \
+    }                                                 \
+  }
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_STATUS_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/status_or.h b/Engine/lib/assimp/contrib/draco/src/draco/core/status_or.h
new file mode 100644
index 000000000..156b9bc02
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/status_or.h
@@ -0,0 +1,81 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_STATUS_OR_H_
+#define DRACO_CORE_STATUS_OR_H_
+
+#include "draco/core/macros.h"
+#include "draco/core/status.h"
+
+namespace draco {
+
+// Class StatusOr is used to wrap a Status along with a value of a specified
+// type |T|. StatusOr is intended to be returned from functions in situations
+// where it is desirable to carry over more information about the potential
+// errors encountered during the function execution. If there are not errors,
+// the caller can simply use the return value, otherwise the Status object
+// provides more info about the encountered problem.
+template <class T>
+class StatusOr {
+ public:
+  StatusOr() {}
+  // Note: Constructors are intentionally not explicit to allow returning
+  // Status or the return value directly from functions.
+  StatusOr(const StatusOr &) = default;
+  StatusOr(StatusOr &&) = default;
+  StatusOr(const Status &status) : status_(status) {}
+  StatusOr(const T &value) : status_(OkStatus()), value_(value) {}
+  StatusOr(T &&value) : status_(OkStatus()), value_(std::move(value)) {}
+  StatusOr(const Status &status, const T &value)
+      : status_(status), value_(value) {}
+
+  const Status &status() const { return status_; }
+  const T &value() const & { return value_; }
+  const T &&value() const && { return std::move(value_); }
+  T &&value() && { return std::move(value_); }
+
+  // For consistency with existing Google StatusOr API we also include
+  // ValueOrDie() that currently returns the value().
+  const T &ValueOrDie() const & { return value(); }
+  T &&ValueOrDie() && { return std::move(value()); }
+
+  bool ok() const { return status_.ok(); }
+
+ private:
+  Status status_;
+  T value_;
+};
+
+// In case StatusOr<T> is ok(), this macro assigns value stored in StatusOr<T>
+// to |lhs|, otherwise it returns the error Status.
+//
+//   DRACO_ASSIGN_OR_RETURN(lhs, expression)
+//
+#define DRACO_ASSIGN_OR_RETURN(lhs, expression)                                \
+  DRACO_ASSIGN_OR_RETURN_IMPL_(DRACO_MACROS_IMPL_CONCAT_(_statusor, __LINE__), \
+                               lhs, expression, _status)
+
+// The actual implementation of the above macro.
+#define DRACO_ASSIGN_OR_RETURN_IMPL_(statusor, lhs, expression, error_expr) \
+  auto statusor = (expression);                                             \
+  if (!statusor.ok()) {                                                     \
+    auto _status = std::move(statusor.status());                            \
+    (void)_status; /* error_expression may not use it */                    \
+    return error_expr;                                                      \
+  }                                                                         \
+  lhs = std::move(statusor).value();
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_STATUS_OR_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/status_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/core/status_test.cc
new file mode 100644
index 000000000..c1ad4ab30
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/status_test.cc
@@ -0,0 +1,38 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/core/status.h"
+
+#include <sstream>
+
+#include "draco/core/draco_test_base.h"
+
+namespace {
+
+class StatusTest : public ::testing::Test {
+ protected:
+  StatusTest() {}
+};
+
+TEST_F(StatusTest, TestStatusOutput) {
+  // Tests that the Status can be stored in a provided std::ostream.
+  const draco::Status status(draco::Status::DRACO_ERROR, "Error msg.");
+  ASSERT_EQ(status.code(), draco::Status::DRACO_ERROR);
+
+  std::stringstream str;
+  str << status;
+  ASSERT_EQ(str.str(), "Error msg.");
+}
+
+}  // namespace
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/varint_decoding.h b/Engine/lib/assimp/contrib/draco/src/draco/core/varint_decoding.h
new file mode 100644
index 000000000..cff47e930
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/varint_decoding.h
@@ -0,0 +1,81 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_VARINT_DECODING_H_
+#define DRACO_CORE_VARINT_DECODING_H_
+
+#include <type_traits>
+
+#include "draco/core/bit_utils.h"
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+
+namespace {
+
+// Decodes a specified unsigned integer as varint. |depth| is the current
+// recursion call depth. The first call to the function must be 1.
+template <typename IntTypeT>
+bool DecodeVarintUnsigned(int depth, IntTypeT *out_val, DecoderBuffer *buffer) {
+  constexpr IntTypeT max_depth = sizeof(IntTypeT) + 1 + (sizeof(IntTypeT) >> 3);
+  if (depth > max_depth) {
+    return false;
+  }
+  // Coding of unsigned values.
+  // 0-6 bit - data
+  // 7 bit - next byte?
+  uint8_t in;
+  if (!buffer->Decode(&in)) {
+    return false;
+  }
+  if (in & (1 << 7)) {
+    // Next byte is available, decode it first.
+    if (!DecodeVarintUnsigned<IntTypeT>(depth + 1, out_val, buffer)) {
+      return false;
+    }
+    // Append decoded info from this byte.
+    *out_val <<= 7;
+    *out_val |= in & ((1 << 7) - 1);
+  } else {
+    // Last byte reached
+    *out_val = in;
+  }
+  return true;
+}
+
+}  // namespace
+
+// Decodes a specified integer as varint. Note that the IntTypeT must be the
+// same as the one used in the corresponding EncodeVarint() call.
+// out_val is undefined if this returns false.
+template <typename IntTypeT>
+bool DecodeVarint(IntTypeT *out_val, DecoderBuffer *buffer) {
+  if (std::is_unsigned<IntTypeT>::value) {
+    if (!DecodeVarintUnsigned<IntTypeT>(1, out_val, buffer)) {
+      return false;
+    }
+  } else {
+    // IntTypeT is a signed value. Decode the symbol and convert to signed.
+    typename std::make_unsigned<IntTypeT>::type symbol;
+    if (!DecodeVarintUnsigned(1, &symbol, buffer)) {
+      return false;
+    }
+    *out_val = ConvertSymbolToSignedInt(symbol);
+  }
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_VARINT_DECODING_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/varint_encoding.h b/Engine/lib/assimp/contrib/draco/src/draco/core/varint_encoding.h
new file mode 100644
index 000000000..9a8a53936
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/varint_encoding.h
@@ -0,0 +1,61 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_VARINT_ENCODING_H_
+#define DRACO_CORE_VARINT_ENCODING_H_
+
+#include <type_traits>
+
+#include "draco/core/bit_utils.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// Encodes a specified integer as varint. Note that different coding is used
+// when IntTypeT is an unsigned data type.
+template <typename IntTypeT>
+bool EncodeVarint(IntTypeT val, EncoderBuffer *out_buffer) {
+  if (std::is_unsigned<IntTypeT>::value) {
+    // Coding of unsigned values.
+    // 0-6 bit - data
+    // 7 bit - next byte?
+    uint8_t out = 0;
+    out |= val & ((1 << 7) - 1);
+    if (val >= (1 << 7)) {
+      out |= (1 << 7);
+      if (!out_buffer->Encode(out)) {
+        return false;
+      }
+      if (!EncodeVarint<IntTypeT>(val >> 7, out_buffer)) {
+        return false;
+      }
+      return true;
+    }
+    if (!out_buffer->Encode(out)) {
+      return false;
+    }
+  } else {
+    // IntTypeT is a signed value. Convert to unsigned symbol and encode.
+    const typename std::make_unsigned<IntTypeT>::type symbol =
+        ConvertSignedIntToSymbol(val);
+    if (!EncodeVarint(symbol, out_buffer)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_VARINT_ENCODING_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/vector_d.h b/Engine/lib/assimp/contrib/draco/src/draco/core/vector_d.h
new file mode 100644
index 000000000..a3c46a46a
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/vector_d.h
@@ -0,0 +1,355 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_VECTOR_D_H_
+#define DRACO_CORE_VECTOR_D_H_
+
+#include <inttypes.h>
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <limits>
+
+#include "draco/core/macros.h"
+
+namespace draco {
+// D-dimensional vector class with basic operations.
+template <class ScalarT, int dimension_t>
+class VectorD {
+ public:
+  static constexpr int dimension = dimension_t;
+
+  typedef ScalarT Scalar;
+  typedef VectorD<Scalar, dimension_t> Self;
+
+  // TODO(hemmer): Deprecate.
+  typedef ScalarT CoefficientType;
+
+  VectorD() {
+    for (int i = 0; i < dimension; ++i) {
+      (*this)[i] = Scalar(0);
+    }
+  }
+
+  // The following constructor does not compile in opt mode, which for now led
+  // to the constructors further down, which is not ideal.
+  // TODO(hemmer): fix constructor below and remove others.
+  // template <typename... Args>
+  // explicit VectorD(Args... args) : v_({args...}) {}
+
+  VectorD(const Scalar &c0, const Scalar &c1) : v_({{c0, c1}}) {
+    DRACO_DCHECK_EQ(dimension, 2);
+    v_[0] = c0;
+    v_[1] = c1;
+  }
+
+  VectorD(const Scalar &c0, const Scalar &c1, const Scalar &c2)
+      : v_({{c0, c1, c2}}) {
+    DRACO_DCHECK_EQ(dimension, 3);
+  }
+
+  VectorD(const Scalar &c0, const Scalar &c1, const Scalar &c2,
+          const Scalar &c3)
+      : v_({{c0, c1, c2, c3}}) {
+    DRACO_DCHECK_EQ(dimension, 4);
+  }
+
+  VectorD(const Scalar &c0, const Scalar &c1, const Scalar &c2,
+          const Scalar &c3, const Scalar &c4)
+      : v_({{c0, c1, c2, c3, c4}}) {
+    DRACO_DCHECK_EQ(dimension, 5);
+  }
+
+  VectorD(const Scalar &c0, const Scalar &c1, const Scalar &c2,
+          const Scalar &c3, const Scalar &c4, const Scalar &c5)
+      : v_({{c0, c1, c2, c3, c4, c5}}) {
+    DRACO_DCHECK_EQ(dimension, 6);
+  }
+
+  VectorD(const Scalar &c0, const Scalar &c1, const Scalar &c2,
+          const Scalar &c3, const Scalar &c4, const Scalar &c5,
+          const Scalar &c6)
+      : v_({{c0, c1, c2, c3, c4, c5, c6}}) {
+    DRACO_DCHECK_EQ(dimension, 7);
+  }
+
+  VectorD(const Self &o) {
+    for (int i = 0; i < dimension; ++i) {
+      (*this)[i] = o[i];
+    }
+  }
+
+  // Constructs the vector from another vector with a different data type or a
+  // different number of components. If the |src_vector| has more components
+  // than |this| vector, the excess components are truncated. If the
+  // |src_vector| has fewer components than |this| vector, the remaining
+  // components are padded with 0.
+  // Note that the constructor is intentionally explicit to avoid accidental
+  // conversions between different vector types.
+  template <class OtherScalarT, int other_dimension_t>
+  explicit VectorD(const VectorD<OtherScalarT, other_dimension_t> &src_vector) {
+    for (int i = 0; i < dimension; ++i) {
+      if (i < other_dimension_t) {
+        v_[i] = Scalar(src_vector[i]);
+      } else {
+        v_[i] = Scalar(0);
+      }
+    }
+  }
+
+  Scalar &operator[](int i) { return v_[i]; }
+  const Scalar &operator[](int i) const { return v_[i]; }
+  // TODO(hemmer): remove.
+  // Similar to interface of Eigen library.
+  Scalar &operator()(int i) { return v_[i]; }
+  const Scalar &operator()(int i) const { return v_[i]; }
+
+  // Unary operators.
+  Self operator-() const {
+    Self ret;
+    for (int i = 0; i < dimension; ++i) {
+      ret[i] = -(*this)[i];
+    }
+    return ret;
+  }
+
+  // Binary operators.
+  Self operator+(const Self &o) const {
+    Self ret;
+    for (int i = 0; i < dimension; ++i) {
+      ret[i] = (*this)[i] + o[i];
+    }
+    return ret;
+  }
+
+  Self operator-(const Self &o) const {
+    Self ret;
+    for (int i = 0; i < dimension; ++i) {
+      ret[i] = (*this)[i] - o[i];
+    }
+    return ret;
+  }
+
+  Self operator*(const Self &o) const {
+    Self ret;
+    for (int i = 0; i < dimension; ++i) {
+      ret[i] = (*this)[i] * o[i];
+    }
+    return ret;
+  }
+
+  Self &operator+=(const Self &o) {
+    for (int i = 0; i < dimension; ++i) {
+      (*this)[i] += o[i];
+    }
+    return *this;
+  }
+
+  Self &operator-=(const Self &o) {
+    for (int i = 0; i < dimension; ++i) {
+      (*this)[i] -= o[i];
+    }
+    return *this;
+  }
+
+  Self &operator*=(const Self &o) {
+    for (int i = 0; i < dimension; ++i) {
+      (*this)[i] *= o[i];
+    }
+    return *this;
+  }
+
+  Self operator*(const Scalar &o) const {
+    Self ret;
+    for (int i = 0; i < dimension; ++i) {
+      ret[i] = (*this)[i] * o;
+    }
+    return ret;
+  }
+
+  Self operator/(const Scalar &o) const {
+    Self ret;
+    for (int i = 0; i < dimension; ++i) {
+      ret[i] = (*this)[i] / o;
+    }
+    return ret;
+  }
+
+  Self operator+(const Scalar &o) const {
+    Self ret;
+    for (int i = 0; i < dimension; ++i) {
+      ret[i] = (*this)[i] + o;
+    }
+    return ret;
+  }
+
+  Self operator-(const Scalar &o) const {
+    Self ret;
+    for (int i = 0; i < dimension; ++i) {
+      ret[i] = (*this)[i] - o;
+    }
+    return ret;
+  }
+
+  bool operator==(const Self &o) const {
+    for (int i = 0; i < dimension; ++i) {
+      if ((*this)[i] != o[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  bool operator!=(const Self &x) const { return !((*this) == x); }
+
+  bool operator<(const Self &x) const {
+    for (int i = 0; i < dimension - 1; ++i) {
+      if (v_[i] < x.v_[i]) {
+        return true;
+      }
+      if (v_[i] > x.v_[i]) {
+        return false;
+      }
+    }
+    // Only one check needed for the last dimension.
+    if (v_[dimension - 1] < x.v_[dimension - 1]) {
+      return true;
+    }
+    return false;
+  }
+
+  // Functions.
+  Scalar SquaredNorm() const { return this->Dot(*this); }
+
+  // Computes L1, the sum of absolute values of all entries.
+  Scalar AbsSum() const {
+    Scalar result(0);
+    for (int i = 0; i < dimension; ++i) {
+      Scalar next_value = std::abs(v_[i]);
+      if (result > std::numeric_limits<Scalar>::max() - next_value) {
+        // Return the max if adding would have caused an overflow.
+        return std::numeric_limits<Scalar>::max();
+      }
+      result += next_value;
+    }
+    return result;
+  }
+
+  Scalar Dot(const Self &o) const {
+    Scalar ret(0);
+    for (int i = 0; i < dimension; ++i) {
+      ret += (*this)[i] * o[i];
+    }
+    return ret;
+  }
+
+  void Normalize() {
+    const Scalar magnitude = std::sqrt(this->SquaredNorm());
+    if (magnitude == 0) {
+      return;
+    }
+    for (int i = 0; i < dimension; ++i) {
+      (*this)[i] /= magnitude;
+    }
+  }
+
+  Self GetNormalized() const {
+    Self ret(*this);
+    ret.Normalize();
+    return ret;
+  }
+
+  const Scalar &MaxCoeff() const {
+    return *std::max_element(v_.begin(), v_.end());
+  }
+
+  const Scalar &MinCoeff() const {
+    return *std::min_element(v_.begin(), v_.end());
+  }
+
+  Scalar *data() { return &(v_[0]); }
+  const Scalar *data() const { return &(v_[0]); }
+
+ private:
+  std::array<Scalar, dimension> v_;
+};
+
+// Scalar multiplication from the other side too.
+template <class ScalarT, int dimension_t>
+VectorD<ScalarT, dimension_t> operator*(
+    const ScalarT &o, const VectorD<ScalarT, dimension_t> &v) {
+  return v * o;
+}
+
+// Calculates the squared distance between two points.
+template <class ScalarT, int dimension_t>
+ScalarT SquaredDistance(const VectorD<ScalarT, dimension_t> &v1,
+                        const VectorD<ScalarT, dimension_t> &v2) {
+  ScalarT difference;
+  ScalarT squared_distance = 0;
+  // Check each index separately so difference is never negative and underflow
+  // is avoided for unsigned types.
+  for (int i = 0; i < dimension_t; ++i) {
+    if (v1[i] >= v2[i]) {
+      difference = v1[i] - v2[i];
+    } else {
+      difference = v2[i] - v1[i];
+    }
+    squared_distance += (difference * difference);
+  }
+  return squared_distance;
+}
+
+// Global function computing the cross product of two 3D vectors.
+template <class ScalarT>
+VectorD<ScalarT, 3> CrossProduct(const VectorD<ScalarT, 3> &u,
+                                 const VectorD<ScalarT, 3> &v) {
+  // Preventing accidental use with uint32_t and the like.
+  static_assert(std::is_signed<ScalarT>::value,
+                "ScalarT must be a signed type. ");
+  VectorD<ScalarT, 3> r;
+  r[0] = (u[1] * v[2]) - (u[2] * v[1]);
+  r[1] = (u[2] * v[0]) - (u[0] * v[2]);
+  r[2] = (u[0] * v[1]) - (u[1] * v[0]);
+  return r;
+}
+
+template <class ScalarT, int dimension_t>
+inline std::ostream &operator<<(
+    std::ostream &out, const draco::VectorD<ScalarT, dimension_t> &vec) {
+  for (int i = 0; i < dimension_t - 1; ++i) {
+    out << vec[i] << " ";
+  }
+  out << vec[dimension_t - 1];
+  return out;
+}
+
+typedef VectorD<float, 2> Vector2f;
+typedef VectorD<float, 3> Vector3f;
+typedef VectorD<float, 4> Vector4f;
+typedef VectorD<float, 5> Vector5f;
+typedef VectorD<float, 6> Vector6f;
+typedef VectorD<float, 7> Vector7f;
+
+typedef VectorD<uint32_t, 2> Vector2ui;
+typedef VectorD<uint32_t, 3> Vector3ui;
+typedef VectorD<uint32_t, 4> Vector4ui;
+typedef VectorD<uint32_t, 5> Vector5ui;
+typedef VectorD<uint32_t, 6> Vector6ui;
+typedef VectorD<uint32_t, 7> Vector7ui;
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_VECTOR_D_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/core/vector_d_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/core/vector_d_test.cc
new file mode 100644
index 000000000..d66128fb1
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/core/vector_d_test.cc
@@ -0,0 +1,306 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/core/vector_d.h"
+
+#include <sstream>
+
+#include "draco/core/draco_test_base.h"
+
+namespace {
+
+typedef draco::Vector2f Vector2f;
+typedef draco::Vector3f Vector3f;
+typedef draco::Vector4f Vector4f;
+typedef draco::Vector5f Vector5f;
+typedef draco::Vector2ui Vector2ui;
+typedef draco::Vector3ui Vector3ui;
+typedef draco::Vector4ui Vector4ui;
+typedef draco::Vector5ui Vector5ui;
+
+typedef draco::VectorD<int32_t, 3> Vector3i;
+typedef draco::VectorD<int32_t, 4> Vector4i;
+
+template <class CoeffT, int dimension_t>
+void TestSquaredDistance(const draco::VectorD<CoeffT, dimension_t> v1,
+                         const draco::VectorD<CoeffT, dimension_t> v2,
+                         const CoeffT result) {
+  CoeffT squared_distance = SquaredDistance(v1, v2);
+  ASSERT_EQ(squared_distance, result);
+  squared_distance = SquaredDistance(v2, v1);
+  ASSERT_EQ(squared_distance, result);
+}
+
+TEST(VectorDTest, TestOperators) {
+  {
+    const Vector3f v;
+    ASSERT_EQ(v[0], 0);
+    ASSERT_EQ(v[1], 0);
+    ASSERT_EQ(v[2], 0);
+  }
+  Vector3f v(1, 2, 3);
+  ASSERT_EQ(v[0], 1);
+  ASSERT_EQ(v[1], 2);
+  ASSERT_EQ(v[2], 3);
+
+  Vector3f w = v;
+  ASSERT_TRUE(v == w);
+  ASSERT_FALSE(v != w);
+  ASSERT_EQ(w[0], 1);
+  ASSERT_EQ(w[1], 2);
+  ASSERT_EQ(w[2], 3);
+
+  w = -v;
+  ASSERT_EQ(w[0], -1);
+  ASSERT_EQ(w[1], -2);
+  ASSERT_EQ(w[2], -3);
+
+  w = v + v;
+  ASSERT_EQ(w[0], 2);
+  ASSERT_EQ(w[1], 4);
+  ASSERT_EQ(w[2], 6);
+
+  w = w - v;
+  ASSERT_EQ(w[0], 1);
+  ASSERT_EQ(w[1], 2);
+  ASSERT_EQ(w[2], 3);
+
+  // Scalar multiplication from left and right.
+  w = v * 2.f;
+  ASSERT_EQ(w[0], 2);
+  ASSERT_EQ(w[1], 4);
+  ASSERT_EQ(w[2], 6);
+  w = 2.f * v;
+  ASSERT_EQ(w[0], 2);
+  ASSERT_EQ(w[1], 4);
+  ASSERT_EQ(w[2], 6);
+
+  ASSERT_EQ(v.SquaredNorm(), 14);
+  ASSERT_EQ(v.Dot(v), 14);
+
+  Vector3f new_v = v;
+  new_v.Normalize();
+  const float tolerance = 1e-5;
+  const float magnitude = std::sqrt(v.SquaredNorm());
+  const float new_magnitude = std::sqrt(new_v.SquaredNorm());
+  ASSERT_NEAR(new_magnitude, 1, tolerance);
+  for (int i = 0; i < 3; ++i) {
+    new_v[i] *= magnitude;
+    ASSERT_NEAR(new_v[i], v[i], tolerance);
+  }
+
+  Vector3f x(0, 0, 0);
+  x.Normalize();
+  for (int i = 0; i < 3; ++i) {
+    ASSERT_EQ(0, x[i]);
+  }
+}
+
+TEST(VectorDTest, TestAdditionAssignmentOperator) {
+  Vector3ui v(1, 2, 3);
+  Vector3ui w(4, 5, 6);
+
+  w += v;
+  ASSERT_EQ(w[0], 5);
+  ASSERT_EQ(w[1], 7);
+  ASSERT_EQ(w[2], 9);
+
+  w += w;
+  ASSERT_EQ(w[0], 10);
+  ASSERT_EQ(w[1], 14);
+  ASSERT_EQ(w[2], 18);
+}
+
+TEST(VectorDTest, TestSubtractionAssignmentOperator) {
+  Vector3ui v(1, 2, 3);
+  Vector3ui w(4, 6, 8);
+
+  w -= v;
+  ASSERT_EQ(w[0], 3);
+  ASSERT_EQ(w[1], 4);
+  ASSERT_EQ(w[2], 5);
+
+  w -= w;
+  ASSERT_EQ(w[0], 0);
+  ASSERT_EQ(w[1], 0);
+  ASSERT_EQ(w[2], 0);
+}
+
+TEST(VectorDTest, TestMultiplicationAssignmentOperator) {
+  Vector3ui v(1, 2, 3);
+  Vector3ui w(4, 5, 6);
+
+  w *= v;
+  ASSERT_EQ(w[0], 4);
+  ASSERT_EQ(w[1], 10);
+  ASSERT_EQ(w[2], 18);
+
+  v *= v;
+  ASSERT_EQ(v[0], 1);
+  ASSERT_EQ(v[1], 4);
+  ASSERT_EQ(v[2], 9);
+}
+
+TEST(VectorTest, TestGetNormalized) {
+  const Vector3f original(2, 3, -4);
+  const Vector3f normalized = original.GetNormalized();
+  const float magnitude = sqrt(original.SquaredNorm());
+  const float tolerance = 1e-5f;
+  ASSERT_NEAR(normalized[0], original[0] / magnitude, tolerance);
+  ASSERT_NEAR(normalized[1], original[1] / magnitude, tolerance);
+  ASSERT_NEAR(normalized[2], original[2] / magnitude, tolerance);
+}
+
+TEST(VectorTest, TestGetNormalizedWithZeroLengthVector) {
+  const Vector3f original(0, 0, 0);
+  const Vector3f normalized = original.GetNormalized();
+  ASSERT_EQ(normalized[0], 0);
+  ASSERT_EQ(normalized[1], 0);
+  ASSERT_EQ(normalized[2], 0);
+}
+
+TEST(VectorDTest, TestSquaredDistance) {
+  // Test Vector2f: float, 2D.
+  Vector2f v1_2f(5.5, 10.5);
+  Vector2f v2_2f(3.5, 15.5);
+  float result_f = 29;
+  TestSquaredDistance(v1_2f, v2_2f, result_f);
+
+  // Test Vector3f: float, 3D.
+  Vector3f v1_3f(5.5, 10.5, 2.3);
+  Vector3f v2_3f(3.5, 15.5, 0);
+  result_f = 34.29;
+  TestSquaredDistance(v1_3f, v2_3f, result_f);
+
+  // Test Vector4f: float, 4D.
+  Vector4f v1_4f(5.5, 10.5, 2.3, 7.2);
+  Vector4f v2_4f(3.5, 15.5, 0, 9.9);
+  result_f = 41.58;
+  TestSquaredDistance(v1_4f, v2_4f, result_f);
+
+  // Test Vector5f: float, 5D.
+  Vector5f v1_5f(5.5, 10.5, 2.3, 7.2, 1.0);
+  Vector5f v2_5f(3.5, 15.5, 0, 9.9, 0.2);
+  result_f = 42.22;
+  TestSquaredDistance(v1_5f, v2_5f, result_f);
+
+  // Test Vector 2ui: uint32_t, 2D.
+  Vector2ui v1_2ui(5, 10);
+  Vector2ui v2_2ui(3, 15);
+  uint32_t result_ui = 29;
+  TestSquaredDistance(v1_2ui, v2_2ui, result_ui);
+
+  // Test Vector 3ui: uint32_t, 3D.
+  Vector3ui v1_3ui(5, 10, 2);
+  Vector3ui v2_3ui(3, 15, 0);
+  result_ui = 33;
+  TestSquaredDistance(v1_3ui, v2_3ui, result_ui);
+
+  // Test Vector 4ui: uint32_t, 4D.
+  Vector4ui v1_4ui(5, 10, 2, 7);
+  Vector4ui v2_4ui(3, 15, 0, 9);
+  result_ui = 37;
+  TestSquaredDistance(v1_4ui, v2_4ui, result_ui);
+
+  // Test Vector 5ui: uint32_t, 5D.
+  Vector5ui v1_5ui(5, 10, 2, 7, 1);
+  Vector5ui v2_5ui(3, 15, 0, 9, 12);
+  result_ui = 158;
+  TestSquaredDistance(v1_5ui, v2_5ui, result_ui);
+}
+
+TEST(VectorDTest, TestCrossProduct3D) {
+  const Vector3i e1(1, 0, 0);
+  const Vector3i e2(0, 1, 0);
+  const Vector3i e3(0, 0, 1);
+  const Vector3i o(0, 0, 0);
+  ASSERT_EQ(e3, draco::CrossProduct(e1, e2));
+  ASSERT_EQ(e1, draco::CrossProduct(e2, e3));
+  ASSERT_EQ(e2, draco::CrossProduct(e3, e1));
+  ASSERT_EQ(-e3, draco::CrossProduct(e2, e1));
+  ASSERT_EQ(-e1, draco::CrossProduct(e3, e2));
+  ASSERT_EQ(-e2, draco::CrossProduct(e1, e3));
+  ASSERT_EQ(o, draco::CrossProduct(e1, e1));
+  ASSERT_EQ(o, draco::CrossProduct(e2, e2));
+  ASSERT_EQ(o, draco::CrossProduct(e3, e3));
+
+  // Orthogonality of result for some general vectors.
+  const Vector3i v1(123, -62, 223);
+  const Vector3i v2(734, 244, -13);
+  const Vector3i orth = draco::CrossProduct(v1, v2);
+  ASSERT_EQ(0, v1.Dot(orth));
+  ASSERT_EQ(0, v2.Dot(orth));
+}
+
+TEST(VectorDTest, TestAbsSum) {
+  // Testing const of function and zero.
+  const Vector3i v(0, 0, 0);
+  ASSERT_EQ(v.AbsSum(), 0);
+  // Testing semantic.
+  ASSERT_EQ(Vector3i(0, 0, 0).AbsSum(), 0);
+  ASSERT_EQ(Vector3i(1, 2, 3).AbsSum(), 6);
+  ASSERT_EQ(Vector3i(-1, -2, -3).AbsSum(), 6);
+  ASSERT_EQ(Vector3i(-2, 4, -8).AbsSum(), 14);
+  // Other dimension.
+  ASSERT_EQ(Vector4i(-2, 4, -8, 3).AbsSum(), 17);
+}
+
+TEST(VectorDTest, TestMinMaxCoeff) {
+  // Test verifies that MinCoeff() and MaxCoeff() functions work as intended.
+  const Vector4i vi(-10, 5, 2, 3);
+  ASSERT_EQ(vi.MinCoeff(), -10);
+  ASSERT_EQ(vi.MaxCoeff(), 5);
+
+  const Vector3f vf(6.f, 1000.f, -101.f);
+  ASSERT_EQ(vf.MinCoeff(), -101.f);
+  ASSERT_EQ(vf.MaxCoeff(), 1000.f);
+}
+
+TEST(VectorDTest, TestOstream) {
+  // Tests that the vector can be stored in a provided std::ostream.
+  const draco::VectorD<int64_t, 3> vector(1, 2, 3);
+  std::stringstream str;
+  str << vector << " ";
+  ASSERT_EQ(str.str(), "1 2 3 ");
+}
+
+TEST(VectorDTest, TestConvertConstructor) {
+  // Tests that a vector can be constructed from another vector with a different
+  // type.
+  const draco::VectorD<int64_t, 3> vector(1, 2, 3);
+
+  const draco::VectorD<float, 3> vector3f(vector);
+  ASSERT_EQ(vector3f, draco::Vector3f(1.f, 2.f, 3.f));
+
+  const draco::VectorD<float, 2> vector2f(vector);
+  ASSERT_EQ(vector2f, draco::Vector2f(1.f, 2.f));
+
+  const draco::VectorD<float, 4> vector4f(vector3f);
+  ASSERT_EQ(vector4f, draco::Vector4f(1.f, 2.f, 3.f, 0.f));
+
+  const draco::VectorD<double, 1> vector1d(vector3f);
+  ASSERT_EQ(vector1d[0], 1.0);
+}
+
+TEST(VectorDTest, TestBinaryOps) {
+  // Tests the binary multiplication operator of the VectorD class.
+  const draco::Vector4f vector_0(1.f, 2.3f, 4.2f, -10.f);
+  ASSERT_EQ(vector_0 * draco::Vector4f(1.f, 1.f, 1.f, 1.f), vector_0);
+  ASSERT_EQ(vector_0 * draco::Vector4f(0.f, 0.f, 0.f, 0.f),
+            draco::Vector4f(0.f, 0.f, 0.f, 0.f));
+  ASSERT_EQ(vector_0 * draco::Vector4f(0.1f, 0.2f, 0.3f, 0.4f),
+            draco::Vector4f(0.1f, 0.46f, 1.26f, -4.f));
+}
+
+}  // namespace
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/file_reader_factory.cc b/Engine/lib/assimp/contrib/draco/src/draco/io/file_reader_factory.cc
new file mode 100644
index 000000000..ac7b09288
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/file_reader_factory.cc
@@ -0,0 +1,45 @@
+#include "draco/io/file_reader_factory.h"
+
+#include <vector>
+
+namespace draco {
+namespace {
+
+#define FILEREADER_LOG_ERROR(error_string)                             \
+  do {                                                                 \
+    fprintf(stderr, "%s:%d (%s): %s.\n", __FILE__, __LINE__, __func__, \
+            error_string);                                             \
+  } while (false)
+
+std::vector<FileReaderFactory::OpenFunction> *GetFileReaderOpenFunctions() {
+  static auto open_functions =
+      new (std::nothrow) std::vector<FileReaderFactory::OpenFunction>();
+  return open_functions;
+}
+
+}  // namespace
+
+bool FileReaderFactory::RegisterReader(OpenFunction open_function) {
+  if (open_function == nullptr) {
+    return false;
+  }
+  auto open_functions = GetFileReaderOpenFunctions();
+  const size_t num_readers = open_functions->size();
+  open_functions->push_back(open_function);
+  return open_functions->size() == num_readers + 1;
+}
+
+std::unique_ptr<FileReaderInterface> FileReaderFactory::OpenReader(
+    const std::string &file_name) {
+  for (auto open_function : *GetFileReaderOpenFunctions()) {
+    auto reader = open_function(file_name);
+    if (reader == nullptr) {
+      continue;
+    }
+    return reader;
+  }
+  FILEREADER_LOG_ERROR("No file reader able to open input");
+  return nullptr;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/file_reader_factory.h b/Engine/lib/assimp/contrib/draco/src/draco/io/file_reader_factory.h
new file mode 100644
index 000000000..12bd7a5af
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/file_reader_factory.h
@@ -0,0 +1,34 @@
+#ifndef DRACO_IO_FILE_READER_FACTORY_H_
+#define DRACO_IO_FILE_READER_FACTORY_H_
+
+#include <memory>
+#include <string>
+
+#include "draco/io/file_reader_interface.h"
+
+namespace draco {
+
+class FileReaderFactory {
+ public:
+  using OpenFunction =
+      std::unique_ptr<FileReaderInterface> (*)(const std::string &file_name);
+
+  FileReaderFactory() = delete;
+  FileReaderFactory(const FileReaderFactory &) = delete;
+  FileReaderFactory &operator=(const FileReaderFactory &) = delete;
+  ~FileReaderFactory() = default;
+
+  // Registers the OpenFunction for a FileReaderInterface and returns true when
+  // registration succeeds.
+  static bool RegisterReader(OpenFunction open_function);
+
+  // Passes |file_name| to each OpenFunction until one succeeds. Returns nullptr
+  // when no reader is found for |file_name|. Otherwise a FileReaderInterface is
+  // returned.
+  static std::unique_ptr<FileReaderInterface> OpenReader(
+      const std::string &file_name);
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_FILE_READER_FACTORY_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/file_reader_factory_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/io/file_reader_factory_test.cc
new file mode 100644
index 000000000..d304d6345
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/file_reader_factory_test.cc
@@ -0,0 +1,85 @@
+#include "draco/io/file_reader_factory.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "draco/core/draco_test_base.h"
+#include "draco/io/file_reader_interface.h"
+
+namespace draco {
+namespace {
+
+class AlwaysFailFileReader : public FileReaderInterface {
+ public:
+  static std::unique_ptr<FileReaderInterface> Open(
+      const std::string & /*file_name*/) {
+    return nullptr;
+  }
+
+  AlwaysFailFileReader() = delete;
+  AlwaysFailFileReader(const AlwaysFailFileReader &) = delete;
+  AlwaysFailFileReader &operator=(const AlwaysFailFileReader &) = delete;
+  // Note this isn't overridden as the class can never be instantiated. This
+  // avoids an unused function warning.
+  // ~AlwaysFailFileReader() override = default;
+
+  bool ReadFileToBuffer(std::vector<char> * /*buffer*/) override {
+    return false;
+  }
+
+  bool ReadFileToBuffer(std::vector<uint8_t> * /*buffer*/) override {
+    return false;
+  }
+
+  size_t GetFileSize() override { return 0; }
+
+ private:
+  static bool is_registered_;
+};
+
+class AlwaysOkFileReader : public FileReaderInterface {
+ public:
+  static std::unique_ptr<FileReaderInterface> Open(
+      const std::string & /*file_name*/) {
+    return std::unique_ptr<AlwaysOkFileReader>(new AlwaysOkFileReader());
+  }
+
+  AlwaysOkFileReader(const AlwaysOkFileReader &) = delete;
+  AlwaysOkFileReader &operator=(const AlwaysOkFileReader &) = delete;
+  ~AlwaysOkFileReader() override = default;
+
+  bool ReadFileToBuffer(std::vector<char> * /*buffer*/) override {
+    return true;
+  }
+
+  bool ReadFileToBuffer(std::vector<uint8_t> * /*buffer*/) override {
+    return true;
+  }
+
+  size_t GetFileSize() override { return 0; }
+
+ private:
+  AlwaysOkFileReader() = default;
+  static bool is_registered_;
+};
+
+bool AlwaysFailFileReader::is_registered_ =
+    FileReaderFactory::RegisterReader(AlwaysFailFileReader::Open);
+
+bool AlwaysOkFileReader::is_registered_ =
+    FileReaderFactory::RegisterReader(AlwaysOkFileReader::Open);
+
+TEST(FileReaderFactoryTest, RegistrationFail) {
+  EXPECT_FALSE(FileReaderFactory::RegisterReader(nullptr));
+}
+
+TEST(FileReaderFactoryTest, OpenReader) {
+  auto reader = FileReaderFactory::OpenReader("fake file");
+  EXPECT_NE(reader, nullptr);
+  std::vector<char> *buffer = nullptr;
+  EXPECT_TRUE(reader->ReadFileToBuffer(buffer));
+}
+
+}  // namespace
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/file_reader_interface.h b/Engine/lib/assimp/contrib/draco/src/draco/io/file_reader_interface.h
new file mode 100644
index 000000000..a6e6a0da0
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/file_reader_interface.h
@@ -0,0 +1,32 @@
+#ifndef DRACO_IO_FILE_READER_INTERFACE_H_
+#define DRACO_IO_FILE_READER_INTERFACE_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+namespace draco {
+
+class FileReaderInterface {
+ public:
+  FileReaderInterface() = default;
+  FileReaderInterface(const FileReaderInterface &) = delete;
+  FileReaderInterface &operator=(const FileReaderInterface &) = delete;
+
+  FileReaderInterface(FileReaderInterface &&) = default;
+  FileReaderInterface &operator=(FileReaderInterface &&) = default;
+
+  // Closes the file.
+  virtual ~FileReaderInterface() = default;
+
+  // Reads the entire contents of the input file into |buffer| and returns true.
+  virtual bool ReadFileToBuffer(std::vector<char> *buffer) = 0;
+  virtual bool ReadFileToBuffer(std::vector<uint8_t> *buffer) = 0;
+
+  // Returns the size of the file.
+  virtual size_t GetFileSize() = 0;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_FILE_READER_INTERFACE_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/file_reader_test_common.h b/Engine/lib/assimp/contrib/draco/src/draco/io/file_reader_test_common.h
new file mode 100644
index 000000000..0d07d4a54
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/file_reader_test_common.h
@@ -0,0 +1,13 @@
+#ifndef DRACO_IO_FILE_READER_TEST_COMMON_H_
+#define DRACO_IO_FILE_READER_TEST_COMMON_H_
+
+#include <cstddef>
+
+namespace draco {
+
+const size_t kFileSizeCarDrc = 69892;
+const size_t kFileSizeCubePcDrc = 224;
+
+}  // namespace draco
+
+#endif  // DRACO_IO_FILE_READER_TEST_COMMON_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/file_utils.cc b/Engine/lib/assimp/contrib/draco/src/draco/io/file_utils.cc
new file mode 100644
index 000000000..f93cbd899
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/file_utils.cc
@@ -0,0 +1,110 @@
+// Copyright 2018 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/file_utils.h"
+
+#include "draco/io/file_reader_factory.h"
+#include "draco/io/file_reader_interface.h"
+#include "draco/io/file_writer_factory.h"
+#include "draco/io/file_writer_interface.h"
+#include "draco/io/file_writer_utils.h"
+#include "draco/io/parser_utils.h"
+
+namespace draco {
+
+void SplitPath(const std::string &full_path, std::string *out_folder_path,
+               std::string *out_file_name) {
+  SplitPathPrivate(full_path, out_folder_path, out_file_name);
+}
+
+std::string ReplaceFileExtension(const std::string &in_file_name,
+                                 const std::string &new_extension) {
+  const auto pos = in_file_name.find_last_of(".");
+  if (pos == std::string::npos) {
+    // No extension found.
+    return in_file_name + "." + new_extension;
+  }
+  return in_file_name.substr(0, pos + 1) + new_extension;
+}
+
+std::string LowercaseFileExtension(const std::string &filename) {
+  const size_t pos = filename.find_last_of('.');
+  if (pos == 0 || pos == std::string::npos || pos == filename.length() - 1) {
+    return "";
+  }
+  return parser::ToLower(filename.substr(pos + 1));
+}
+
+std::string GetFullPath(const std::string &input_file_relative_path,
+                        const std::string &sibling_file_full_path) {
+  const auto pos = sibling_file_full_path.find_last_of("/\\");
+  std::string input_file_full_path;
+  if (pos != std::string::npos) {
+    input_file_full_path = sibling_file_full_path.substr(0, pos + 1);
+  }
+  input_file_full_path += input_file_relative_path;
+  return input_file_full_path;
+}
+
+bool ReadFileToBuffer(const std::string &file_name, std::vector<char> *buffer) {
+  std::unique_ptr<FileReaderInterface> file_reader =
+      FileReaderFactory::OpenReader(file_name);
+  if (file_reader == nullptr) {
+    return false;
+  }
+  return file_reader->ReadFileToBuffer(buffer);
+}
+
+bool ReadFileToBuffer(const std::string &file_name,
+                      std::vector<uint8_t> *buffer) {
+  std::unique_ptr<FileReaderInterface> file_reader =
+      FileReaderFactory::OpenReader(file_name);
+  if (file_reader == nullptr) {
+    return false;
+  }
+  return file_reader->ReadFileToBuffer(buffer);
+}
+
+bool WriteBufferToFile(const char *buffer, size_t buffer_size,
+                       const std::string &file_name) {
+  std::unique_ptr<FileWriterInterface> file_writer =
+      FileWriterFactory::OpenWriter(file_name);
+  if (file_writer == nullptr) {
+    return false;
+  }
+  return file_writer->Write(buffer, buffer_size);
+}
+
+bool WriteBufferToFile(const unsigned char *buffer, size_t buffer_size,
+                       const std::string &file_name) {
+  return WriteBufferToFile(reinterpret_cast<const char *>(buffer), buffer_size,
+                           file_name);
+}
+
+bool WriteBufferToFile(const void *buffer, size_t buffer_size,
+                       const std::string &file_name) {
+  return WriteBufferToFile(reinterpret_cast<const char *>(buffer), buffer_size,
+                           file_name);
+}
+
+size_t GetFileSize(const std::string &file_name) {
+  std::unique_ptr<FileReaderInterface> file_reader =
+      FileReaderFactory::OpenReader(file_name);
+  if (file_reader == nullptr) {
+    return 0;
+  }
+  return file_reader->GetFileSize();
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/file_utils.h b/Engine/lib/assimp/contrib/draco/src/draco/io/file_utils.h
new file mode 100644
index 000000000..4b734e049
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/file_utils.h
@@ -0,0 +1,73 @@
+// Copyright 2018 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_FILE_UTILS_H_
+#define DRACO_IO_FILE_UTILS_H_
+
+#include <string>
+#include <vector>
+
+namespace draco {
+
+// Splits full path to a file into a folder path + file name.
+// |out_folder_path| will contain the path to the folder containing the file
+// excluding the final slash. If no folder is specified in the |full_path|, then
+// |out_folder_path| is set to "."
+void SplitPath(const std::string &full_path, std::string *out_folder_path,
+               std::string *out_file_name);
+
+// Replaces file extension in |in_file_name| with |new_extension|.
+// If |in_file_name| does not have any extension, the extension is appended.
+std::string ReplaceFileExtension(const std::string &in_file_name,
+                                 const std::string &new_extension);
+
+// Returns the file extension in lowercase if present, else "". Extension is
+// defined as the string after the last '.' character. If the file starts with
+// '.' (e.g. Linux hidden files), the first delimiter is ignored.
+std::string LowercaseFileExtension(const std::string &filename);
+
+// Given a path of the input file |input_file_relative_path| relative to the
+// parent directory of |sibling_file_full_path|, this function returns full path
+// to the input file. If |sibling_file_full_path| has no directory, the relative
+// path itself |input_file_relative_path| is returned. A common use case is for
+// the |input_file_relative_path| to be just a file name. See usage examples in
+// the unit test.
+std::string GetFullPath(const std::string &input_file_relative_path,
+                        const std::string &sibling_file_full_path);
+
+// Convenience method. Uses draco::FileReaderFactory internally. Reads contents
+// of file referenced by |file_name| into |buffer| and returns true upon
+// success.
+bool ReadFileToBuffer(const std::string &file_name, std::vector<char> *buffer);
+bool ReadFileToBuffer(const std::string &file_name,
+                      std::vector<uint8_t> *buffer);
+
+// Convenience method. Uses draco::FileWriterFactory internally. Writes contents
+// of |buffer| to file referred to by |file_name|. File is overwritten if it
+// exists. Returns true after successful write.
+bool WriteBufferToFile(const char *buffer, size_t buffer_size,
+                       const std::string &file_name);
+bool WriteBufferToFile(const unsigned char *buffer, size_t buffer_size,
+                       const std::string &file_name);
+bool WriteBufferToFile(const void *buffer, size_t buffer_size,
+                       const std::string &file_name);
+
+// Convenience method. Uses draco::FileReaderFactory internally. Returns size of
+// file referenced by |file_name|. Returns 0 when referenced file is empty or
+// does not exist.
+size_t GetFileSize(const std::string &file_name);
+
+}  // namespace draco
+
+#endif  // DRACO_IO_FILE_UTILS_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/file_utils_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/io/file_utils_test.cc
new file mode 100644
index 000000000..4085ff0cd
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/file_utils_test.cc
@@ -0,0 +1,69 @@
+// Copyright 2018 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/file_utils.h"
+
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+
+namespace {
+
+TEST(FileUtilsTest, SplitsPath) {
+  // Tests that the function SplitPath correctly splits a set of test paths.
+  std::string folder_path, file_name;
+  draco::SplitPath("file.x", &folder_path, &file_name);
+  ASSERT_EQ(folder_path, ".");
+  ASSERT_EQ(file_name, "file.x");
+
+  draco::SplitPath("a/b/file.y", &folder_path, &file_name);
+  ASSERT_EQ(folder_path, "a/b");
+  ASSERT_EQ(file_name, "file.y");
+
+  draco::SplitPath("//a/b/c/d/file.z", &folder_path, &file_name);
+  ASSERT_EQ(folder_path, "//a/b/c/d");
+  ASSERT_EQ(file_name, "file.z");
+}
+
+TEST(FileUtilsTest, ReplaceExtension) {
+  // Tests that the function ReplaceFileExtension correctly replaces extensions
+  // of specified files.
+  ASSERT_EQ(draco::ReplaceFileExtension("a.abc", "x"), "a.x");
+  ASSERT_EQ(draco::ReplaceFileExtension("abc", "x"), "abc.x");  // No extension
+  ASSERT_EQ(draco::ReplaceFileExtension("a/b/c.d", "xyz"), "a/b/c.xyz");
+}
+
+TEST(FileUtilsTest, LowercaseFileExtension) {
+  ASSERT_EQ(draco::LowercaseFileExtension("image.jpeg"), "jpeg");
+  ASSERT_EQ(draco::LowercaseFileExtension("image.JPEG"), "jpeg");
+  ASSERT_EQ(draco::LowercaseFileExtension("image.png"), "png");
+  ASSERT_EQ(draco::LowercaseFileExtension("image.pNg"), "png");
+  ASSERT_EQ(draco::LowercaseFileExtension("FILE.glb"), "glb");
+  ASSERT_EQ(draco::LowercaseFileExtension(".file.gltf"), "gltf");
+  ASSERT_EQ(draco::LowercaseFileExtension("the.file.gltf"), "gltf");
+  ASSERT_EQ(draco::LowercaseFileExtension("FILE_glb"), "");
+  ASSERT_EQ(draco::LowercaseFileExtension(""), "");
+  ASSERT_EQ(draco::LowercaseFileExtension("image."), "");
+}
+
+TEST(FileUtilsTest, GetFullPath) {
+  // Tests that full path is returned when a sibling file has full path.
+  ASSERT_EQ(draco::GetFullPath("xo.png", "/d/i/r/xo.gltf"), "/d/i/r/xo.png");
+  ASSERT_EQ(draco::GetFullPath("buf/01.bin", "dir/xo.gltf"), "dir/buf/01.bin");
+  ASSERT_EQ(draco::GetFullPath("xo.mtl", "/xo.obj"), "/xo.mtl");
+
+  // Tests that only file name is returned when a sibling file has no full path.
+  ASSERT_EQ(draco::GetFullPath("xo.mtl", "xo.obj"), "xo.mtl");
+}
+
+}  // namespace
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/file_writer_factory.cc b/Engine/lib/assimp/contrib/draco/src/draco/io/file_writer_factory.cc
new file mode 100644
index 000000000..cb6851602
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/file_writer_factory.cc
@@ -0,0 +1,45 @@
+#include "draco/io/file_writer_factory.h"
+
+#include <vector>
+
+namespace draco {
+namespace {
+
+#define FILEWRITER_LOG_ERROR(error_string)                             \
+  do {                                                                 \
+    fprintf(stderr, "%s:%d (%s): %s.\n", __FILE__, __LINE__, __func__, \
+            error_string);                                             \
+  } while (false)
+
+std::vector<FileWriterFactory::OpenFunction> *GetFileWriterOpenFunctions() {
+  static auto open_functions =
+      new (std::nothrow) std::vector<FileWriterFactory::OpenFunction>();
+  return open_functions;
+}
+
+}  // namespace
+
+bool FileWriterFactory::RegisterWriter(OpenFunction open_function) {
+  if (open_function == nullptr) {
+    return false;
+  }
+  auto open_functions = GetFileWriterOpenFunctions();
+  const size_t num_writers = open_functions->size();
+  open_functions->push_back(open_function);
+  return open_functions->size() == num_writers + 1;
+}
+
+std::unique_ptr<FileWriterInterface> FileWriterFactory::OpenWriter(
+    const std::string &file_name) {
+  for (auto open_function : *GetFileWriterOpenFunctions()) {
+    auto writer = open_function(file_name);
+    if (writer == nullptr) {
+      continue;
+    }
+    return writer;
+  }
+  FILEWRITER_LOG_ERROR("No file writer able to open output");
+  return nullptr;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/file_writer_factory.h b/Engine/lib/assimp/contrib/draco/src/draco/io/file_writer_factory.h
new file mode 100644
index 000000000..ecf735d83
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/file_writer_factory.h
@@ -0,0 +1,34 @@
+#ifndef DRACO_IO_FILE_WRITER_FACTORY_H_
+#define DRACO_IO_FILE_WRITER_FACTORY_H_
+
+#include <memory>
+#include <string>
+
+#include "draco/io/file_writer_interface.h"
+
+namespace draco {
+
+class FileWriterFactory {
+ public:
+  using OpenFunction =
+      std::unique_ptr<FileWriterInterface> (*)(const std::string &file_name);
+
+  FileWriterFactory() = delete;
+  FileWriterFactory(const FileWriterFactory &) = delete;
+  FileWriterFactory &operator=(const FileWriterFactory &) = delete;
+  ~FileWriterFactory() = default;
+
+  // Registers the OpenFunction for a FileWriterInterface and returns true when
+  // registration succeeds.
+  static bool RegisterWriter(OpenFunction open_function);
+
+  // Passes |file_name| to each OpenFunction until one succeeds. Returns nullptr
+  // when no writer is found for |file_name|. Otherwise a FileWriterInterface is
+  // returned.
+  static std::unique_ptr<FileWriterInterface> OpenWriter(
+      const std::string &file_name);
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_FILE_WRITER_FACTORY_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/file_writer_factory_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/io/file_writer_factory_test.cc
new file mode 100644
index 000000000..fbad5cf7a
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/file_writer_factory_test.cc
@@ -0,0 +1,70 @@
+#include "draco/io/file_writer_factory.h"
+
+#include <cstdint>
+#include <memory>
+#include <string>
+
+#include "draco/core/draco_test_base.h"
+#include "draco/io/file_writer_interface.h"
+
+namespace draco {
+namespace {
+
+class AlwaysFailFileWriter : public FileWriterInterface {
+ public:
+  static std::unique_ptr<FileWriterInterface> Open(
+      const std::string & /*file_name*/) {
+    return nullptr;
+  }
+
+  AlwaysFailFileWriter() = delete;
+  AlwaysFailFileWriter(const AlwaysFailFileWriter &) = delete;
+  AlwaysFailFileWriter &operator=(const AlwaysFailFileWriter &) = delete;
+  // Note this isn't overridden as the class can never be instantiated. This
+  // avoids an unused function warning.
+  // ~AlwaysFailFileWriter() override = default;
+
+  bool Write(const char * /*buffer*/, size_t /*size*/) override {
+    return false;
+  }
+
+ private:
+  static bool is_registered_;
+};
+
+class AlwaysOkFileWriter : public FileWriterInterface {
+ public:
+  static std::unique_ptr<FileWriterInterface> Open(
+      const std::string & /*file_name*/) {
+    return std::unique_ptr<AlwaysOkFileWriter>(new AlwaysOkFileWriter());
+  }
+
+  AlwaysOkFileWriter(const AlwaysOkFileWriter &) = delete;
+  AlwaysOkFileWriter &operator=(const AlwaysOkFileWriter &) = delete;
+  ~AlwaysOkFileWriter() override = default;
+
+  bool Write(const char * /*buffer*/, size_t /*size*/) override { return true; }
+
+ private:
+  AlwaysOkFileWriter() = default;
+  static bool is_registered_;
+};
+
+bool AlwaysFailFileWriter::is_registered_ =
+    FileWriterFactory::RegisterWriter(AlwaysFailFileWriter::Open);
+
+bool AlwaysOkFileWriter::is_registered_ =
+    FileWriterFactory::RegisterWriter(AlwaysOkFileWriter::Open);
+
+TEST(FileWriterFactoryTest, RegistrationFail) {
+  EXPECT_FALSE(FileWriterFactory::RegisterWriter(nullptr));
+}
+
+TEST(FileWriterFactoryTest, OpenWriter) {
+  auto writer = FileWriterFactory::OpenWriter("fake file");
+  EXPECT_NE(writer, nullptr);
+  EXPECT_TRUE(writer->Write(nullptr, 0u));
+}
+
+}  // namespace
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/file_writer_interface.h b/Engine/lib/assimp/contrib/draco/src/draco/io/file_writer_interface.h
new file mode 100644
index 000000000..719f7cc8c
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/file_writer_interface.h
@@ -0,0 +1,26 @@
+#ifndef DRACO_IO_FILE_WRITER_INTERFACE_H_
+#define DRACO_IO_FILE_WRITER_INTERFACE_H_
+
+#include <cstddef>
+
+namespace draco {
+
+class FileWriterInterface {
+ public:
+  FileWriterInterface() = default;
+  FileWriterInterface(const FileWriterInterface &) = delete;
+  FileWriterInterface &operator=(const FileWriterInterface &) = delete;
+
+  FileWriterInterface(FileWriterInterface &&) = default;
+  FileWriterInterface &operator=(FileWriterInterface &&) = default;
+
+  // Closes the file.
+  virtual ~FileWriterInterface() = default;
+
+  // Writes |size| bytes from |buffer| to file.
+  virtual bool Write(const char *buffer, size_t size) = 0;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_FILE_WRITER_INTERFACE_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/file_writer_utils.cc b/Engine/lib/assimp/contrib/draco/src/draco/io/file_writer_utils.cc
new file mode 100644
index 000000000..bcadccfc6
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/file_writer_utils.cc
@@ -0,0 +1,57 @@
+#include "draco/io/file_writer_utils.h"
+
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <string>
+
+#include "draco/draco_features.h"
+
+namespace draco {
+
+void SplitPathPrivate(const std::string &full_path,
+                      std::string *out_folder_path,
+                      std::string *out_file_name) {
+  const auto pos = full_path.find_last_of("/\\");
+  if (pos != std::string::npos) {
+    if (out_folder_path) {
+      *out_folder_path = full_path.substr(0, pos);
+    }
+    if (out_file_name) {
+      *out_file_name = full_path.substr(pos + 1, full_path.length());
+    }
+  } else {
+    if (out_folder_path) {
+      *out_folder_path = ".";
+    }
+    if (out_file_name) {
+      *out_file_name = full_path;
+    }
+  }
+}
+
+bool DirectoryExists(const std::string &path) {
+  struct stat path_stat;
+
+  // Check if |path| exists.
+  if (stat(path.c_str(), &path_stat) != 0) {
+    return false;
+  }
+
+  // Check if |path| is a directory.
+  if (path_stat.st_mode & S_IFDIR) {
+    return true;
+  }
+  return false;
+}
+
+bool CheckAndCreatePathForFile(const std::string &filename) {
+  std::string path;
+  std::string basename;
+  SplitPathPrivate(filename, &path, &basename);
+
+  const bool directory_exists = DirectoryExists(path);
+  return directory_exists;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/file_writer_utils.h b/Engine/lib/assimp/contrib/draco/src/draco/io/file_writer_utils.h
new file mode 100644
index 000000000..e5ba28361
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/file_writer_utils.h
@@ -0,0 +1,38 @@
+// Copyright 2020 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_FILE_WRITER_UTILS_H_
+#define DRACO_IO_FILE_WRITER_UTILS_H_
+
+#include <string>
+
+namespace draco {
+
+// Splits full path to a file into a folder path + file name.
+// |out_folder_path| will contain the path to the folder containing the file
+// excluding the final slash. If no folder is specified in the |full_path|, then
+// |out_folder_path| is set to "."
+void SplitPathPrivate(const std::string &full_path,
+                      std::string *out_folder_path, std::string *out_file_name);
+
+// Checks is |path| exists and if it is a directory.
+bool DirectoryExists(const std::string &path);
+
+// Checks if the path for file is valid. If not this function will try and
+// create the path. Returns false on error.
+bool CheckAndCreatePathForFile(const std::string &filename);
+
+}  // namespace draco
+
+#endif  // DRACO_IO_FILE_WRITER_UTILS_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/mesh_io.cc b/Engine/lib/assimp/contrib/draco/src/draco/io/mesh_io.cc
new file mode 100644
index 000000000..e0dc69c6f
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/mesh_io.cc
@@ -0,0 +1,87 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/mesh_io.h"
+
+#include <fstream>
+#include <string>
+
+#include "draco/io/file_utils.h"
+#include "draco/io/obj_decoder.h"
+#include "draco/io/ply_decoder.h"
+
+namespace draco {
+
+StatusOr<std::unique_ptr<Mesh>> ReadMeshFromFile(const std::string &file_name) {
+  const Options options;
+  return ReadMeshFromFile(file_name, options, nullptr);
+}
+
+StatusOr<std::unique_ptr<Mesh>> ReadMeshFromFile(const std::string &file_name,
+                                                 bool use_metadata) {
+  Options options;
+  options.SetBool("use_metadata", use_metadata);
+  return ReadMeshFromFile(file_name, options, nullptr);
+}
+
+StatusOr<std::unique_ptr<Mesh>> ReadMeshFromFile(const std::string &file_name,
+                                                 const Options &options) {
+  return ReadMeshFromFile(file_name, options, nullptr);
+}
+
+StatusOr<std::unique_ptr<Mesh>> ReadMeshFromFile(
+    const std::string &file_name, const Options &options,
+    std::vector<std::string> *mesh_files) {
+  std::unique_ptr<Mesh> mesh(new Mesh());
+  // Analyze file extension.
+  const std::string extension = LowercaseFileExtension(file_name);
+  if (extension != "gltf" && mesh_files) {
+    // The GLTF decoder will fill |mesh_files|, but for other file types we set
+    // the root file here to avoid duplicating code.
+    mesh_files->push_back(file_name);
+  }
+  if (extension == "obj") {
+    // Wavefront OBJ file format.
+    ObjDecoder obj_decoder;
+    obj_decoder.set_use_metadata(options.GetBool("use_metadata", false));
+    const Status obj_status = obj_decoder.DecodeFromFile(file_name, mesh.get());
+    if (!obj_status.ok()) {
+      return obj_status;
+    }
+    return std::move(mesh);
+  }
+  if (extension == "ply") {
+    // Wavefront PLY file format.
+    PlyDecoder ply_decoder;
+    DRACO_RETURN_IF_ERROR(ply_decoder.DecodeFromFile(file_name, mesh.get()));
+    return std::move(mesh);
+  }
+
+  // Otherwise not an obj file. Assume the file was encoded with one of the
+  // draco encoding methods.
+  std::vector<char> file_data;
+  if (!ReadFileToBuffer(file_name, &file_data)) {
+    return Status(Status::DRACO_ERROR, "Unable to read input file.");
+  }
+  DecoderBuffer buffer;
+  buffer.Init(file_data.data(), file_data.size());
+  Decoder decoder;
+  auto statusor = decoder.DecodeMeshFromBuffer(&buffer);
+  if (!statusor.ok() || statusor.value() == nullptr) {
+    return Status(Status::DRACO_ERROR, "Error decoding input.");
+  }
+  return std::move(statusor).value();
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/mesh_io.h b/Engine/lib/assimp/contrib/draco/src/draco/io/mesh_io.h
new file mode 100644
index 000000000..9af178c73
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/mesh_io.h
@@ -0,0 +1,107 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_MESH_IO_H_
+#define DRACO_IO_MESH_IO_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/decode.h"
+#include "draco/compression/expert_encode.h"
+#include "draco/core/options.h"
+
+namespace draco {
+
+template <typename OutStreamT>
+OutStreamT WriteMeshIntoStream(const Mesh *mesh, OutStreamT &&os,
+                               MeshEncoderMethod method,
+                               const EncoderOptions &options) {
+  EncoderBuffer buffer;
+  EncoderOptions local_options = options;
+  ExpertEncoder encoder(*mesh);
+  encoder.Reset(local_options);
+  encoder.SetEncodingMethod(method);
+  if (!encoder.EncodeToBuffer(&buffer).ok()) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+
+  os.write(static_cast<const char *>(buffer.data()), buffer.size());
+
+  return os;
+}
+
+template <typename OutStreamT>
+OutStreamT WriteMeshIntoStream(const Mesh *mesh, OutStreamT &&os,
+                               MeshEncoderMethod method) {
+  const EncoderOptions options = EncoderOptions::CreateDefaultOptions();
+  return WriteMeshIntoStream(mesh, os, method, options);
+}
+
+template <typename OutStreamT>
+OutStreamT &WriteMeshIntoStream(const Mesh *mesh, OutStreamT &&os) {
+  return WriteMeshIntoStream(mesh, os, MESH_EDGEBREAKER_ENCODING);
+}
+
+template <typename InStreamT>
+InStreamT &ReadMeshFromStream(std::unique_ptr<Mesh> *mesh, InStreamT &&is) {
+  // Determine size of stream and write into a vector
+  const auto start_pos = is.tellg();
+  is.seekg(0, std::ios::end);
+  const std::streampos is_size = is.tellg() - start_pos;
+  is.seekg(start_pos);
+  std::vector<char> data(is_size);
+  is.read(&data[0], is_size);
+
+  // Create a mesh from that data.
+  DecoderBuffer buffer;
+  buffer.Init(&data[0], data.size());
+  Decoder decoder;
+  auto statusor = decoder.DecodeMeshFromBuffer(&buffer);
+  *mesh = std::move(statusor).value();
+  if (!statusor.ok() || *mesh == nullptr) {
+    is.setstate(std::ios_base::badbit);
+  }
+
+  return is;
+}
+
+// Reads a mesh from a file. The function automatically chooses the correct
+// decoder based on the extension of the files. Currently, .obj and .ply files
+// are supported. Other file extensions are processed by the default
+// draco::MeshDecoder.
+// Returns nullptr with an error status if the decoding failed.
+StatusOr<std::unique_ptr<Mesh>> ReadMeshFromFile(const std::string &file_name);
+
+// Reads a mesh from a file. The function does the same thing as the previous
+// one except using metadata to encode additional information when
+// |use_metadata| is set to true.
+// Returns nullptr with an error status if the decoding failed.
+StatusOr<std::unique_ptr<Mesh>> ReadMeshFromFile(const std::string &file_name,
+                                                 bool use_metadata);
+
+// Reads a mesh from a file. Reading is configured with |options|:
+// use_metadata  : Read obj file info like material names and object names into
+// metadata. Default is false.
+// The second form returns the files associated with the mesh via the
+// |mesh_files| argument.
+// Returns nullptr with an error status if the decoding failed.
+StatusOr<std::unique_ptr<Mesh>> ReadMeshFromFile(const std::string &file_name,
+                                                 const Options &options);
+StatusOr<std::unique_ptr<Mesh>> ReadMeshFromFile(
+    const std::string &file_name, const Options &options,
+    std::vector<std::string> *mesh_files);
+
+}  // namespace draco
+
+#endif  // DRACO_IO_MESH_IO_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/obj_decoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/io/obj_decoder.cc
new file mode 100644
index 000000000..9b4eab626
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/obj_decoder.cc
@@ -0,0 +1,708 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/obj_decoder.h"
+
+#include <cctype>
+#include <cmath>
+
+#include "draco/io/file_utils.h"
+#include "draco/io/parser_utils.h"
+#include "draco/metadata/geometry_metadata.h"
+
+namespace draco {
+
+ObjDecoder::ObjDecoder()
+    : counting_mode_(true),
+      num_obj_faces_(0),
+      num_positions_(0),
+      num_tex_coords_(0),
+      num_normals_(0),
+      num_materials_(0),
+      last_sub_obj_id_(0),
+      pos_att_id_(-1),
+      tex_att_id_(-1),
+      norm_att_id_(-1),
+      material_att_id_(-1),
+      sub_obj_att_id_(-1),
+      deduplicate_input_values_(true),
+      last_material_id_(0),
+      use_metadata_(false),
+      out_mesh_(nullptr),
+      out_point_cloud_(nullptr) {}
+
+Status ObjDecoder::DecodeFromFile(const std::string &file_name,
+                                  Mesh *out_mesh) {
+  out_mesh_ = out_mesh;
+  return DecodeFromFile(file_name, static_cast<PointCloud *>(out_mesh));
+}
+
+Status ObjDecoder::DecodeFromFile(const std::string &file_name,
+                                  PointCloud *out_point_cloud) {
+  std::vector<char> buffer;
+  if (!ReadFileToBuffer(file_name, &buffer)) {
+    return Status(Status::DRACO_ERROR, "Unable to read input file.");
+  }
+  buffer_.Init(buffer.data(), buffer.size());
+
+  out_point_cloud_ = out_point_cloud;
+  input_file_name_ = file_name;
+  return DecodeInternal();
+}
+
+Status ObjDecoder::DecodeFromBuffer(DecoderBuffer *buffer, Mesh *out_mesh) {
+  out_mesh_ = out_mesh;
+  return DecodeFromBuffer(buffer, static_cast<PointCloud *>(out_mesh));
+}
+
+Status ObjDecoder::DecodeFromBuffer(DecoderBuffer *buffer,
+                                    PointCloud *out_point_cloud) {
+  out_point_cloud_ = out_point_cloud;
+  buffer_.Init(buffer->data_head(), buffer->remaining_size());
+  return DecodeInternal();
+}
+
+Status ObjDecoder::DecodeInternal() {
+  // In the first pass, count the number of different elements in the geometry.
+  // In case the desired output is just a point cloud (i.e., when
+  // out_mesh_ == nullptr) the decoder will ignore all information about the
+  // connectivity that may be included in the source data.
+  counting_mode_ = true;
+  ResetCounters();
+  material_name_to_id_.clear();
+  last_sub_obj_id_ = 0;
+  // Parse all lines.
+  Status status(Status::OK);
+  while (ParseDefinition(&status) && status.ok()) {
+  }
+  if (!status.ok()) {
+    return status;
+  }
+
+  bool use_identity_mapping = false;
+  if (num_obj_faces_ == 0) {
+    // Mesh has no faces. In this case we try to read the geometry as a point
+    // cloud where every attribute entry is a point.
+
+    // Ensure the number of all entries is same for all attributes.
+    if (num_positions_ == 0) {
+      return Status(Status::DRACO_ERROR, "No position attribute");
+    }
+    if (num_tex_coords_ > 0 && num_tex_coords_ != num_positions_) {
+      return Status(Status::DRACO_ERROR,
+                    "Invalid number of texture coordinates for a point cloud");
+    }
+    if (num_normals_ > 0 && num_normals_ != num_positions_) {
+      return Status(Status::DRACO_ERROR,
+                    "Invalid number of normals for a point cloud");
+    }
+
+    out_mesh_ = nullptr;  // Treat the output geometry as a point cloud.
+    use_identity_mapping = true;
+  }
+
+  // Initialize point cloud and mesh properties.
+  if (out_mesh_) {
+    // Start decoding a mesh with the given number of faces. For point clouds we
+    // silently ignore all data about the mesh connectivity.
+    out_mesh_->SetNumFaces(num_obj_faces_);
+  }
+  if (num_obj_faces_ > 0) {
+    out_point_cloud_->set_num_points(3 * num_obj_faces_);
+  } else {
+    out_point_cloud_->set_num_points(num_positions_);
+  }
+
+  // Add attributes if they are present in the input data.
+  if (num_positions_ > 0) {
+    GeometryAttribute va;
+    va.Init(GeometryAttribute::POSITION, nullptr, 3, DT_FLOAT32, false,
+            sizeof(float) * 3, 0);
+    pos_att_id_ = out_point_cloud_->AddAttribute(va, use_identity_mapping,
+                                                 num_positions_);
+  }
+  if (num_tex_coords_ > 0) {
+    GeometryAttribute va;
+    va.Init(GeometryAttribute::TEX_COORD, nullptr, 2, DT_FLOAT32, false,
+            sizeof(float) * 2, 0);
+    tex_att_id_ = out_point_cloud_->AddAttribute(va, use_identity_mapping,
+                                                 num_tex_coords_);
+  }
+  if (num_normals_ > 0) {
+    GeometryAttribute va;
+    va.Init(GeometryAttribute::NORMAL, nullptr, 3, DT_FLOAT32, false,
+            sizeof(float) * 3, 0);
+    norm_att_id_ =
+        out_point_cloud_->AddAttribute(va, use_identity_mapping, num_normals_);
+  }
+  if (num_materials_ > 0 && num_obj_faces_ > 0) {
+    GeometryAttribute va;
+    const auto geometry_attribute_type = GeometryAttribute::GENERIC;
+    if (num_materials_ < 256) {
+      va.Init(geometry_attribute_type, nullptr, 1, DT_UINT8, false, 1, 0);
+    } else if (num_materials_ < (1 << 16)) {
+      va.Init(geometry_attribute_type, nullptr, 1, DT_UINT16, false, 2, 0);
+    } else {
+      va.Init(geometry_attribute_type, nullptr, 1, DT_UINT32, false, 4, 0);
+    }
+    material_att_id_ =
+        out_point_cloud_->AddAttribute(va, false, num_materials_);
+
+    // Fill the material entries.
+    for (int i = 0; i < num_materials_; ++i) {
+      const AttributeValueIndex avi(i);
+      out_point_cloud_->attribute(material_att_id_)->SetAttributeValue(avi, &i);
+    }
+
+    if (use_metadata_) {
+      // Use metadata to store the name of materials.
+      std::unique_ptr<AttributeMetadata> material_metadata =
+          std::unique_ptr<AttributeMetadata>(new AttributeMetadata());
+      material_metadata->AddEntryString("name", "material");
+      // Add all material names.
+      for (const auto &itr : material_name_to_id_) {
+        material_metadata->AddEntryInt(itr.first, itr.second);
+      }
+      if (!material_file_name_.empty()) {
+        material_metadata->AddEntryString("file_name", material_file_name_);
+      }
+
+      out_point_cloud_->AddAttributeMetadata(material_att_id_,
+                                             std::move(material_metadata));
+    }
+  }
+  if (!obj_name_to_id_.empty() && num_obj_faces_ > 0) {
+    GeometryAttribute va;
+    if (obj_name_to_id_.size() < 256) {
+      va.Init(GeometryAttribute::GENERIC, nullptr, 1, DT_UINT8, false, 1, 0);
+    } else if (obj_name_to_id_.size() < (1 << 16)) {
+      va.Init(GeometryAttribute::GENERIC, nullptr, 1, DT_UINT16, false, 2, 0);
+    } else {
+      va.Init(GeometryAttribute::GENERIC, nullptr, 1, DT_UINT32, false, 4, 0);
+    }
+    sub_obj_att_id_ = out_point_cloud_->AddAttribute(
+        va, false, static_cast<uint32_t>(obj_name_to_id_.size()));
+    // Fill the sub object id entries.
+    for (const auto &itr : obj_name_to_id_) {
+      const AttributeValueIndex i(itr.second);
+      out_point_cloud_->attribute(sub_obj_att_id_)->SetAttributeValue(i, &i);
+    }
+    if (use_metadata_) {
+      // Use metadata to store the name of materials.
+      std::unique_ptr<AttributeMetadata> sub_obj_metadata =
+          std::unique_ptr<AttributeMetadata>(new AttributeMetadata());
+      sub_obj_metadata->AddEntryString("name", "sub_obj");
+      // Add all sub object names.
+      for (const auto &itr : obj_name_to_id_) {
+        const AttributeValueIndex i(itr.second);
+        sub_obj_metadata->AddEntryInt(itr.first, itr.second);
+      }
+      out_point_cloud_->AddAttributeMetadata(sub_obj_att_id_,
+                                             std::move(sub_obj_metadata));
+    }
+  }
+
+  // Perform a second iteration of parsing and fill all the data.
+  counting_mode_ = false;
+  ResetCounters();
+  // Start parsing from the beginning of the buffer again.
+  buffer()->StartDecodingFrom(0);
+  while (ParseDefinition(&status) && status.ok()) {
+  }
+  if (!status.ok()) {
+    return status;
+  }
+  if (out_mesh_) {
+    // Add faces with identity mapping between vertex and corner indices.
+    // Duplicate vertices will get removed later.
+    Mesh::Face face;
+    for (FaceIndex i(0); i < num_obj_faces_; ++i) {
+      for (int c = 0; c < 3; ++c) {
+        face[c] = 3 * i.value() + c;
+      }
+      out_mesh_->SetFace(i, face);
+    }
+  }
+
+#ifdef DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED
+  if (deduplicate_input_values_) {
+    out_point_cloud_->DeduplicateAttributeValues();
+  }
+#endif
+#ifdef DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+  out_point_cloud_->DeduplicatePointIds();
+#endif
+  return status;
+}
+
+void ObjDecoder::ResetCounters() {
+  num_obj_faces_ = 0;
+  num_positions_ = 0;
+  num_tex_coords_ = 0;
+  num_normals_ = 0;
+  last_material_id_ = 0;
+  last_sub_obj_id_ = 0;
+}
+
+bool ObjDecoder::ParseDefinition(Status *status) {
+  char c;
+  parser::SkipWhitespace(buffer());
+  if (!buffer()->Peek(&c)) {
+    // End of file reached?.
+    return false;
+  }
+  if (c == '#') {
+    // Comment, ignore the line.
+    parser::SkipLine(buffer());
+    return true;
+  }
+  if (ParseVertexPosition(status)) {
+    return true;
+  }
+  if (ParseNormal(status)) {
+    return true;
+  }
+  if (ParseTexCoord(status)) {
+    return true;
+  }
+  if (ParseFace(status)) {
+    return true;
+  }
+  if (ParseMaterial(status)) {
+    return true;
+  }
+  if (ParseMaterialLib(status)) {
+    return true;
+  }
+  if (ParseObject(status)) {
+    return true;
+  }
+  // No known definition was found. Ignore the line.
+  parser::SkipLine(buffer());
+  return true;
+}
+
+bool ObjDecoder::ParseVertexPosition(Status *status) {
+  std::array<char, 2> c;
+  if (!buffer()->Peek(&c)) {
+    return false;
+  }
+  if (c[0] != 'v' || c[1] != ' ') {
+    return false;
+  }
+  // Vertex definition found!
+  buffer()->Advance(2);
+  if (!counting_mode_) {
+    // Parse three float numbers for vertex position coordinates.
+    float val[3];
+    for (int i = 0; i < 3; ++i) {
+      parser::SkipWhitespace(buffer());
+      if (!parser::ParseFloat(buffer(), val + i)) {
+        *status = Status(Status::DRACO_ERROR, "Failed to parse a float number");
+        // The definition is processed so return true.
+        return true;
+      }
+    }
+    out_point_cloud_->attribute(pos_att_id_)
+        ->SetAttributeValue(AttributeValueIndex(num_positions_), val);
+  }
+  ++num_positions_;
+  parser::SkipLine(buffer());
+  return true;
+}
+
+bool ObjDecoder::ParseNormal(Status *status) {
+  std::array<char, 2> c;
+  if (!buffer()->Peek(&c)) {
+    return false;
+  }
+  if (c[0] != 'v' || c[1] != 'n') {
+    return false;
+  }
+  // Normal definition found!
+  buffer()->Advance(2);
+  if (!counting_mode_) {
+    // Parse three float numbers for the normal vector.
+    float val[3];
+    for (int i = 0; i < 3; ++i) {
+      parser::SkipWhitespace(buffer());
+      if (!parser::ParseFloat(buffer(), val + i)) {
+        *status = Status(Status::DRACO_ERROR, "Failed to parse a float number");
+        // The definition is processed so return true.
+        return true;
+      }
+    }
+    out_point_cloud_->attribute(norm_att_id_)
+        ->SetAttributeValue(AttributeValueIndex(num_normals_), val);
+  }
+  ++num_normals_;
+  parser::SkipLine(buffer());
+  return true;
+}
+
+bool ObjDecoder::ParseTexCoord(Status *status) {
+  std::array<char, 2> c;
+  if (!buffer()->Peek(&c)) {
+    return false;
+  }
+  if (c[0] != 'v' || c[1] != 't') {
+    return false;
+  }
+  // Texture coord definition found!
+  buffer()->Advance(2);
+  if (!counting_mode_) {
+    // Parse two float numbers for the texture coordinate.
+    float val[2];
+    for (int i = 0; i < 2; ++i) {
+      parser::SkipWhitespace(buffer());
+      if (!parser::ParseFloat(buffer(), val + i)) {
+        *status = Status(Status::DRACO_ERROR, "Failed to parse a float number");
+        // The definition is processed so return true.
+        return true;
+      }
+    }
+    out_point_cloud_->attribute(tex_att_id_)
+        ->SetAttributeValue(AttributeValueIndex(num_tex_coords_), val);
+  }
+  ++num_tex_coords_;
+  parser::SkipLine(buffer());
+  return true;
+}
+
+bool ObjDecoder::ParseFace(Status *status) {
+  char c;
+  if (!buffer()->Peek(&c)) {
+    return false;
+  }
+  if (c != 'f') {
+    return false;
+  }
+  // Face definition found!
+  buffer()->Advance(1);
+  if (!counting_mode_) {
+    std::array<int32_t, 3> indices[4];
+    // Parse face indices (we try to look for up to four to support quads).
+    int num_valid_indices = 0;
+    for (int i = 0; i < 4; ++i) {
+      if (!ParseVertexIndices(&indices[i])) {
+        if (i == 3) {
+          break;  // It's OK if there is no fourth vertex index.
+        }
+        *status = Status(Status::DRACO_ERROR, "Failed to parse vertex indices");
+        return true;
+      }
+      ++num_valid_indices;
+    }
+    // Process the first face.
+    for (int i = 0; i < 3; ++i) {
+      const PointIndex vert_id(3 * num_obj_faces_ + i);
+      MapPointToVertexIndices(vert_id, indices[i]);
+    }
+    ++num_obj_faces_;
+    if (num_valid_indices == 4) {
+      // Add an additional triangle for the quad.
+      //
+      //   3----2
+      //   |  / |
+      //   | /  |
+      //   0----1
+      //
+      const PointIndex vert_id(3 * num_obj_faces_);
+      MapPointToVertexIndices(vert_id, indices[0]);
+      MapPointToVertexIndices(vert_id + 1, indices[2]);
+      MapPointToVertexIndices(vert_id + 2, indices[3]);
+      ++num_obj_faces_;
+    }
+  } else {
+    // We are in the counting mode.
+    // We need to determine how many triangles are in the obj face.
+    // Go over the line and check how many gaps there are between non-empty
+    // sub-strings.
+    parser::SkipWhitespace(buffer());
+    int num_indices = 0;
+    bool is_end = false;
+    while (buffer()->Peek(&c) && c != '\n') {
+      if (parser::PeekWhitespace(buffer(), &is_end)) {
+        buffer()->Advance(1);
+      } else {
+        // Non-whitespace reached.. assume it's index declaration, skip it.
+        num_indices++;
+        while (!parser::PeekWhitespace(buffer(), &is_end) && !is_end) {
+          buffer()->Advance(1);
+        }
+      }
+    }
+    if (num_indices < 3 || num_indices > 4) {
+      *status =
+          Status(Status::DRACO_ERROR, "Invalid number of indices on a face");
+      return false;
+    }
+    // Either one or two new triangles.
+    num_obj_faces_ += num_indices - 2;
+  }
+  parser::SkipLine(buffer());
+  return true;
+}
+
+bool ObjDecoder::ParseMaterialLib(Status *status) {
+  // Allow only one material library per file for now.
+  if (!material_name_to_id_.empty()) {
+    return false;
+  }
+  std::array<char, 6> c;
+  if (!buffer()->Peek(&c)) {
+    return false;
+  }
+  if (std::memcmp(&c[0], "mtllib", 6) != 0) {
+    return false;
+  }
+  buffer()->Advance(6);
+  DecoderBuffer line_buffer = parser::ParseLineIntoDecoderBuffer(buffer());
+  parser::SkipWhitespace(&line_buffer);
+  material_file_name_.clear();
+  if (!parser::ParseString(&line_buffer, &material_file_name_)) {
+    *status = Status(Status::DRACO_ERROR, "Failed to parse material file name");
+    return true;
+  }
+  parser::SkipLine(&line_buffer);
+
+  if (!material_file_name_.empty()) {
+    if (!ParseMaterialFile(material_file_name_, status)) {
+      // Silently ignore problems with material files for now.
+      return true;
+    }
+  }
+  return true;
+}
+
+bool ObjDecoder::ParseMaterial(Status * /* status */) {
+  // In second pass, skip when we don't use materials.
+  if (!counting_mode_ && material_att_id_ < 0) {
+    return false;
+  }
+  std::array<char, 6> c;
+  if (!buffer()->Peek(&c)) {
+    return false;
+  }
+  if (std::memcmp(&c[0], "usemtl", 6) != 0) {
+    return false;
+  }
+  buffer()->Advance(6);
+  DecoderBuffer line_buffer = parser::ParseLineIntoDecoderBuffer(buffer());
+  parser::SkipWhitespace(&line_buffer);
+  std::string mat_name;
+  parser::ParseLine(&line_buffer, &mat_name);
+  if (mat_name.length() == 0) {
+    return false;
+  }
+  auto it = material_name_to_id_.find(mat_name);
+  if (it == material_name_to_id_.end()) {
+    // In first pass, materials found in obj that's not in the .mtl file
+    // will be added to the list.
+    last_material_id_ = num_materials_;
+    material_name_to_id_[mat_name] = num_materials_++;
+
+    return true;
+  }
+  last_material_id_ = it->second;
+  return true;
+}
+
+bool ObjDecoder::ParseObject(Status *status) {
+  std::array<char, 2> c;
+  if (!buffer()->Peek(&c)) {
+    return false;
+  }
+  if (std::memcmp(&c[0], "o ", 2) != 0) {
+    return false;
+  }
+  buffer()->Advance(1);
+  DecoderBuffer line_buffer = parser::ParseLineIntoDecoderBuffer(buffer());
+  parser::SkipWhitespace(&line_buffer);
+  std::string obj_name;
+  if (!parser::ParseString(&line_buffer, &obj_name)) {
+    return false;
+  }
+  if (obj_name.length() == 0) {
+    return true;  // Ignore empty name entries.
+  }
+  auto it = obj_name_to_id_.find(obj_name);
+  if (it == obj_name_to_id_.end()) {
+    const int num_obj = static_cast<int>(obj_name_to_id_.size());
+    obj_name_to_id_[obj_name] = num_obj;
+    last_sub_obj_id_ = num_obj;
+  } else {
+    last_sub_obj_id_ = it->second;
+  }
+  return true;
+}
+
+bool ObjDecoder::ParseVertexIndices(std::array<int32_t, 3> *out_indices) {
+  // Parsed attribute indices can be in format:
+  // 1. POS_INDEX
+  // 2. POS_INDEX/TEX_COORD_INDEX
+  // 3. POS_INDEX/TEX_COORD_INDEX/NORMAL_INDEX
+  // 4. POS_INDEX//NORMAL_INDEX
+  parser::SkipCharacters(buffer(), " \t");
+  if (!parser::ParseSignedInt(buffer(), &(*out_indices)[0]) ||
+      (*out_indices)[0] == 0) {
+    return false;  // Position index must be present and valid.
+  }
+  (*out_indices)[1] = (*out_indices)[2] = 0;
+  char ch;
+  if (!buffer()->Peek(&ch)) {
+    return true;  // It may be OK if we cannot read any more characters.
+  }
+  if (ch != '/') {
+    return true;
+  }
+  buffer()->Advance(1);
+  // Check if we should skip texture index or not.
+  if (!buffer()->Peek(&ch)) {
+    return false;  // Here, we should be always able to read the next char.
+  }
+  if (ch != '/') {
+    // Must be texture coord index.
+    if (!parser::ParseSignedInt(buffer(), &(*out_indices)[1]) ||
+        (*out_indices)[1] == 0) {
+      return false;  // Texture index must be present and valid.
+    }
+  }
+  if (!buffer()->Peek(&ch)) {
+    return true;
+  }
+  if (ch == '/') {
+    buffer()->Advance(1);
+    // Read normal index.
+    if (!parser::ParseSignedInt(buffer(), &(*out_indices)[2]) ||
+        (*out_indices)[2] == 0) {
+      return false;  // Normal index must be present and valid.
+    }
+  }
+  return true;
+}
+
+void ObjDecoder::MapPointToVertexIndices(
+    PointIndex vert_id, const std::array<int32_t, 3> &indices) {
+  // Use face entries to store mapping between vertex and attribute indices
+  // (positions, texture coordinates and normal indices).
+  // Any given index is used when indices[x] != 0. For positive values, the
+  // point is mapped directly to the specified attribute index. Negative input
+  // indices indicate addressing from the last element (e.g. -1 is the last
+  // attribute value of a given type, -2 the second last, etc.).
+  if (indices[0] > 0) {
+    out_point_cloud_->attribute(pos_att_id_)
+        ->SetPointMapEntry(vert_id, AttributeValueIndex(indices[0] - 1));
+  } else if (indices[0] < 0) {
+    out_point_cloud_->attribute(pos_att_id_)
+        ->SetPointMapEntry(vert_id,
+                           AttributeValueIndex(num_positions_ + indices[0]));
+  }
+
+  if (tex_att_id_ >= 0) {
+    if (indices[1] > 0) {
+      out_point_cloud_->attribute(tex_att_id_)
+          ->SetPointMapEntry(vert_id, AttributeValueIndex(indices[1] - 1));
+    } else if (indices[1] < 0) {
+      out_point_cloud_->attribute(tex_att_id_)
+          ->SetPointMapEntry(vert_id,
+                             AttributeValueIndex(num_tex_coords_ + indices[1]));
+    } else {
+      // Texture index not provided but expected. Insert 0 entry as the
+      // default value.
+      out_point_cloud_->attribute(tex_att_id_)
+          ->SetPointMapEntry(vert_id, AttributeValueIndex(0));
+    }
+  }
+
+  if (norm_att_id_ >= 0) {
+    if (indices[2] > 0) {
+      out_point_cloud_->attribute(norm_att_id_)
+          ->SetPointMapEntry(vert_id, AttributeValueIndex(indices[2] - 1));
+    } else if (indices[2] < 0) {
+      out_point_cloud_->attribute(norm_att_id_)
+          ->SetPointMapEntry(vert_id,
+                             AttributeValueIndex(num_normals_ + indices[2]));
+    } else {
+      // Normal index not provided but expected. Insert 0 entry as the default
+      // value.
+      out_point_cloud_->attribute(norm_att_id_)
+          ->SetPointMapEntry(vert_id, AttributeValueIndex(0));
+    }
+  }
+
+  // Assign material index to the point if it is available.
+  if (material_att_id_ >= 0) {
+    out_point_cloud_->attribute(material_att_id_)
+        ->SetPointMapEntry(vert_id, AttributeValueIndex(last_material_id_));
+  }
+
+  // Assign sub-object index to the point if it is available.
+  if (sub_obj_att_id_ >= 0) {
+    out_point_cloud_->attribute(sub_obj_att_id_)
+        ->SetPointMapEntry(vert_id, AttributeValueIndex(last_sub_obj_id_));
+  }
+}
+
+bool ObjDecoder::ParseMaterialFile(const std::string &file_name,
+                                   Status *status) {
+  const std::string full_path = GetFullPath(file_name, input_file_name_);
+  std::vector<char> buffer;
+  if (!ReadFileToBuffer(full_path, &buffer)) {
+    return false;
+  }
+
+  // Backup the original decoder buffer.
+  DecoderBuffer old_buffer = buffer_;
+
+  buffer_.Init(buffer.data(), buffer.size());
+
+  num_materials_ = 0;
+  while (ParseMaterialFileDefinition(status)) {
+  }
+
+  // Restore the original buffer.
+  buffer_ = old_buffer;
+  return true;
+}
+
+bool ObjDecoder::ParseMaterialFileDefinition(Status * /* status */) {
+  char c;
+  parser::SkipWhitespace(buffer());
+  if (!buffer()->Peek(&c)) {
+    // End of file reached?.
+    return false;
+  }
+  if (c == '#') {
+    // Comment, ignore the line.
+    parser::SkipLine(buffer());
+    return true;
+  }
+  std::string str;
+  if (!parser::ParseString(buffer(), &str)) {
+    return false;
+  }
+  if (str == "newmtl") {
+    parser::SkipWhitespace(buffer());
+    parser::ParseLine(buffer(), &str);
+    if (str.empty()) {
+      return false;
+    }
+    // Add new material to our map.
+    material_name_to_id_[str] = num_materials_++;
+  }
+  return true;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/obj_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/io/obj_decoder.h
new file mode 100644
index 000000000..baeab5b0c
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/obj_decoder.h
@@ -0,0 +1,129 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_OBJ_DECODER_H_
+#define DRACO_IO_OBJ_DECODER_H_
+
+#include <string>
+#include <unordered_map>
+
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/status.h"
+#include "draco/draco_features.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Decodes a Wavefront OBJ file into draco::Mesh (or draco::PointCloud if the
+// connectivity data is not needed).. This decoder can handle decoding of
+// positions, texture coordinates, normals and triangular faces.
+// All other geometry properties are ignored.
+class ObjDecoder {
+ public:
+  ObjDecoder();
+
+  // Decodes an obj file stored in the input file.
+  // Returns nullptr if the decoding failed.
+  Status DecodeFromFile(const std::string &file_name, Mesh *out_mesh);
+  Status DecodeFromFile(const std::string &file_name,
+                        PointCloud *out_point_cloud);
+
+  Status DecodeFromBuffer(DecoderBuffer *buffer, Mesh *out_mesh);
+  Status DecodeFromBuffer(DecoderBuffer *buffer, PointCloud *out_point_cloud);
+
+  // Flag that can be used to turn on/off deduplication of input values.
+  // This should be disabled only when we are sure that the input data does not
+  // contain any duplicate entries.
+  // Default: true
+  void set_deduplicate_input_values(bool v) { deduplicate_input_values_ = v; }
+  // Flag for whether using metadata to record other information in the obj
+  // file, e.g. material names, object names.
+  void set_use_metadata(bool flag) { use_metadata_ = flag; }
+
+ protected:
+  Status DecodeInternal();
+  DecoderBuffer *buffer() { return &buffer_; }
+
+ private:
+  // Resets internal counters for attributes and faces.
+  void ResetCounters();
+
+  // Parses the next mesh property definition (position, tex coord, normal, or
+  // face). If the parsed data is unrecognized, it will be skipped.
+  // Returns false when the end of file was reached.
+  bool ParseDefinition(Status *status);
+
+  // Attempts to parse definition of position, normal, tex coord, or face
+  // respectively.
+  // Returns false when the parsed data didn't contain the given definition.
+  bool ParseVertexPosition(Status *status);
+  bool ParseNormal(Status *status);
+  bool ParseTexCoord(Status *status);
+  bool ParseFace(Status *status);
+  bool ParseMaterialLib(Status *status);
+  bool ParseMaterial(Status *status);
+  bool ParseObject(Status *status);
+
+  // Parses triplet of position, tex coords and normal indices.
+  // Returns false on error.
+  bool ParseVertexIndices(std::array<int32_t, 3> *out_indices);
+
+  // Maps specified point index to the parsed vertex indices (triplet of
+  // position, texture coordinate, and normal indices) .
+  void MapPointToVertexIndices(PointIndex vert_id,
+                               const std::array<int32_t, 3> &indices);
+
+  // Parses material file definitions from a separate file.
+  bool ParseMaterialFile(const std::string &file_name, Status *status);
+  bool ParseMaterialFileDefinition(Status *status);
+
+  // If set to true, the parser will count the number of various definitions
+  // but it will not parse the actual data or add any new entries to the mesh.
+  bool counting_mode_;
+  int num_obj_faces_;
+  int num_positions_;
+  int num_tex_coords_;
+  int num_normals_;
+  int num_materials_;
+  int last_sub_obj_id_;
+
+  int pos_att_id_;
+  int tex_att_id_;
+  int norm_att_id_;
+  int material_att_id_;
+  int sub_obj_att_id_;  // Attribute id for storing sub-objects.
+
+  bool deduplicate_input_values_;
+
+  int last_material_id_;
+  std::string material_file_name_;
+
+  std::string input_file_name_;
+
+  std::unordered_map<std::string, int> material_name_to_id_;
+  std::unordered_map<std::string, int> obj_name_to_id_;
+
+  bool use_metadata_;
+
+  DecoderBuffer buffer_;
+
+  // Data structure that stores the decoded data. |out_point_cloud_| must be
+  // always set but |out_mesh_| is optional.
+  Mesh *out_mesh_;
+  PointCloud *out_point_cloud_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_OBJ_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/obj_decoder_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/io/obj_decoder_test.cc
new file mode 100644
index 000000000..b19fe6e2c
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/obj_decoder_test.cc
@@ -0,0 +1,193 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/obj_decoder.h"
+
+#include <sstream>
+
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+
+namespace draco {
+
+class ObjDecoderTest : public ::testing::Test {
+ protected:
+  template <class Geometry>
+  std::unique_ptr<Geometry> DecodeObj(const std::string &file_name) const {
+    return DecodeObj<Geometry>(file_name, false);
+  }
+
+  template <class Geometry>
+  std::unique_ptr<Geometry> DecodeObj(const std::string &file_name,
+                                      bool deduplicate_input_values) const {
+    const std::string path = GetTestFileFullPath(file_name);
+    ObjDecoder decoder;
+    decoder.set_deduplicate_input_values(deduplicate_input_values);
+    std::unique_ptr<Geometry> geometry(new Geometry());
+    if (!decoder.DecodeFromFile(path, geometry.get()).ok()) {
+      return nullptr;
+    }
+    return geometry;
+  }
+
+  template <class Geometry>
+  std::unique_ptr<Geometry> DecodeObjWithMetadata(
+      const std::string &file_name) const {
+    const std::string path = GetTestFileFullPath(file_name);
+    ObjDecoder decoder;
+    decoder.set_use_metadata(true);
+    std::unique_ptr<Geometry> geometry(new Geometry());
+    if (!decoder.DecodeFromFile(path, geometry.get()).ok()) {
+      return nullptr;
+    }
+    return geometry;
+  }
+
+  void test_decoding(const std::string &file_name) {
+    const std::unique_ptr<Mesh> mesh(DecodeObj<Mesh>(file_name));
+    ASSERT_NE(mesh, nullptr) << "Failed to load test model " << file_name;
+    ASSERT_GT(mesh->num_faces(), 0);
+
+    const std::unique_ptr<PointCloud> pc(DecodeObj<PointCloud>(file_name));
+    ASSERT_NE(pc, nullptr) << "Failed to load test model " << file_name;
+    ASSERT_GT(pc->num_points(), 0);
+  }
+};
+
+TEST_F(ObjDecoderTest, ExtraVertexOBJ) {
+  const std::string file_name = "extra_vertex.obj";
+  test_decoding(file_name);
+}
+
+TEST_F(ObjDecoderTest, PartialAttributesOBJ) {
+  const std::string file_name = "cube_att_partial.obj";
+  test_decoding(file_name);
+}
+
+TEST_F(ObjDecoderTest, SubObjects) {
+  // Tests loading an Obj with sub objects.
+  const std::string file_name = "cube_att_sub_o.obj";
+  const std::unique_ptr<Mesh> mesh(DecodeObj<Mesh>(file_name));
+  ASSERT_NE(mesh, nullptr) << "Failed to load test model " << file_name;
+  ASSERT_GT(mesh->num_faces(), 0);
+
+  // A sub object attribute should be the fourth attribute of the mesh (in this
+  // case).
+  ASSERT_EQ(mesh->num_attributes(), 4);
+  ASSERT_EQ(mesh->attribute(3)->attribute_type(), GeometryAttribute::GENERIC);
+  // There should be 3 different sub objects used in the model.
+  ASSERT_EQ(mesh->attribute(3)->size(), 3);
+  // Verify that the sub object attribute has unique id == 3.
+  ASSERT_EQ(mesh->attribute(3)->unique_id(), 3);
+}
+
+TEST_F(ObjDecoderTest, SubObjectsWithMetadata) {
+  // Tests loading an Obj with sub objects.
+  const std::string file_name = "cube_att_sub_o.obj";
+  const std::unique_ptr<Mesh> mesh(DecodeObjWithMetadata<Mesh>(file_name));
+  ASSERT_NE(mesh, nullptr) << "Failed to load test model " << file_name;
+  ASSERT_GT(mesh->num_faces(), 0);
+
+  ASSERT_EQ(mesh->num_attributes(), 4);
+  ASSERT_EQ(mesh->attribute(3)->attribute_type(), GeometryAttribute::GENERIC);
+  // There should be 3 different sub objects used in the model.
+  ASSERT_EQ(mesh->attribute(3)->size(), 3);
+
+  // Test material names stored in metadata.
+  ASSERT_NE(mesh->GetMetadata(), nullptr);
+  ASSERT_NE(mesh->GetAttributeMetadataByAttributeId(3), nullptr);
+  int32_t sub_obj_id = 0;
+  ASSERT_TRUE(mesh->GetAttributeMetadataByAttributeId(3)->GetEntryInt(
+      "obj2", &sub_obj_id));
+  ASSERT_EQ(sub_obj_id, 2);
+}
+
+TEST_F(ObjDecoderTest, QuadOBJ) {
+  // Tests loading an Obj with quad faces.
+  const std::string file_name = "cube_quads.obj";
+  const std::unique_ptr<Mesh> mesh(DecodeObj<Mesh>(file_name));
+  ASSERT_NE(mesh, nullptr) << "Failed to load test model " << file_name;
+  ASSERT_EQ(mesh->num_faces(), 12);
+
+  ASSERT_EQ(mesh->num_attributes(), 3);
+  ASSERT_EQ(mesh->num_points(), 4 * 6);  // Four points per quad face.
+}
+
+TEST_F(ObjDecoderTest, ComplexPolyOBJ) {
+  // Tests that we fail to load an obj with complex polygon (expected failure).
+  const std::string file_name = "invalid/complex_poly.obj";
+  const std::unique_ptr<Mesh> mesh(DecodeObj<Mesh>(file_name));
+  ASSERT_EQ(mesh, nullptr);
+}
+
+TEST_F(ObjDecoderTest, EmptyNameOBJ) {
+  // Tests that we load an obj file that has an sub-object defined with an empty
+  // name.
+  const std::string file_name = "empty_name.obj";
+  const std::unique_ptr<Mesh> mesh(DecodeObj<Mesh>(file_name));
+  ASSERT_NE(mesh, nullptr);
+  ASSERT_EQ(mesh->num_attributes(), 1);
+  // Three valid entries in the attribute are expected.
+  ASSERT_EQ(mesh->attribute(0)->size(), 3);
+}
+
+TEST_F(ObjDecoderTest, PointCloudOBJ) {
+  // Tests that we load an obj file that does not contain any faces.
+  const std::string file_name = "test_lines.obj";
+  const std::unique_ptr<Mesh> mesh(DecodeObj<Mesh>(file_name, false));
+  ASSERT_NE(mesh, nullptr);
+  ASSERT_EQ(mesh->num_faces(), 0);
+  ASSERT_EQ(mesh->num_attributes(), 1);
+  ASSERT_EQ(mesh->attribute(0)->size(), 484);
+}
+
+TEST_F(ObjDecoderTest, WrongAttributeMapping) {
+  // Tests that we load an obj file that contains invalid mapping between
+  // attribute indices and values. In such case the invalid indices should be
+  // ignored.
+  const std::string file_name = "test_wrong_attribute_mapping.obj";
+  const std::unique_ptr<Mesh> mesh(DecodeObj<Mesh>(file_name, false));
+  ASSERT_NE(mesh, nullptr);
+  ASSERT_EQ(mesh->num_faces(), 1);
+  ASSERT_EQ(mesh->num_attributes(), 1);
+  ASSERT_EQ(mesh->attribute(0)->size(), 3);
+}
+
+TEST_F(ObjDecoderTest, TestObjDecodingAll) {
+  // test if we can read all obj that are currently in test folder.
+  test_decoding("bunny_norm.obj");
+  // test_decoding("complex_poly.obj"); // not supported see test above
+  test_decoding("cube_att.obj");
+  test_decoding("cube_att_partial.obj");
+  test_decoding("cube_att_sub_o.obj");
+  test_decoding("cube_quads.obj");
+  test_decoding("cube_subd.obj");
+  test_decoding("eof_test.obj");
+  test_decoding("extra_vertex.obj");
+  test_decoding("mat_test.obj");
+  test_decoding("one_face_123.obj");
+  test_decoding("one_face_312.obj");
+  test_decoding("one_face_321.obj");
+  test_decoding("sphere.obj");
+  test_decoding("test_nm.obj");
+  test_decoding("test_nm_trans.obj");
+  test_decoding("test_sphere.obj");
+  test_decoding("three_faces_123.obj");
+  test_decoding("three_faces_312.obj");
+  test_decoding("two_faces_123.obj");
+  test_decoding("two_faces_312.obj");
+  test_decoding("inf_nan.obj");
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/obj_encoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/io/obj_encoder.cc
new file mode 100644
index 000000000..29c6ca8f0
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/obj_encoder.cc
@@ -0,0 +1,346 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/obj_encoder.h"
+
+#include <memory>
+
+#include "draco/io/file_writer_factory.h"
+#include "draco/io/file_writer_interface.h"
+#include "draco/metadata/geometry_metadata.h"
+
+namespace draco {
+
+ObjEncoder::ObjEncoder()
+    : pos_att_(nullptr),
+      tex_coord_att_(nullptr),
+      normal_att_(nullptr),
+      material_att_(nullptr),
+      sub_obj_att_(nullptr),
+      out_buffer_(nullptr),
+      in_point_cloud_(nullptr),
+      in_mesh_(nullptr),
+      current_sub_obj_id_(-1),
+      current_material_id_(-1) {}
+
+bool ObjEncoder::EncodeToFile(const PointCloud &pc,
+                              const std::string &file_name) {
+  std::unique_ptr<FileWriterInterface> file =
+      FileWriterFactory::OpenWriter(file_name);
+  if (!file) {
+    return false;  // File could not be opened.
+  }
+  file_name_ = file_name;
+  // Encode the mesh into a buffer.
+  EncoderBuffer buffer;
+  if (!EncodeToBuffer(pc, &buffer)) {
+    return false;
+  }
+  // Write the buffer into the file.
+  file->Write(buffer.data(), buffer.size());
+  return true;
+}
+
+bool ObjEncoder::EncodeToFile(const Mesh &mesh, const std::string &file_name) {
+  in_mesh_ = &mesh;
+  return EncodeToFile(static_cast<const PointCloud &>(mesh), file_name);
+}
+
+bool ObjEncoder::EncodeToBuffer(const PointCloud &pc,
+                                EncoderBuffer *out_buffer) {
+  in_point_cloud_ = &pc;
+  out_buffer_ = out_buffer;
+  if (!EncodeInternal()) {
+    return ExitAndCleanup(false);
+  }
+  return ExitAndCleanup(true);
+}
+
+bool ObjEncoder::EncodeToBuffer(const Mesh &mesh, EncoderBuffer *out_buffer) {
+  in_mesh_ = &mesh;
+  return EncodeToBuffer(static_cast<const PointCloud &>(mesh), out_buffer);
+}
+
+bool ObjEncoder::EncodeInternal() {
+  pos_att_ = nullptr;
+  tex_coord_att_ = nullptr;
+  normal_att_ = nullptr;
+  material_att_ = nullptr;
+  sub_obj_att_ = nullptr;
+  current_sub_obj_id_ = -1;
+  current_material_id_ = -1;
+  if (!GetSubObjects()) {
+    return false;
+  }
+  if (!EncodeMaterialFileName()) {
+    return false;
+  }
+  if (!EncodePositions()) {
+    return false;
+  }
+  if (!EncodeTextureCoordinates()) {
+    return false;
+  }
+  if (!EncodeNormals()) {
+    return false;
+  }
+  if (in_mesh_ && !EncodeFaces()) {
+    return false;
+  }
+  return true;
+}
+
+bool ObjEncoder::ExitAndCleanup(bool return_value) {
+  in_mesh_ = nullptr;
+  in_point_cloud_ = nullptr;
+  out_buffer_ = nullptr;
+  pos_att_ = nullptr;
+  tex_coord_att_ = nullptr;
+  normal_att_ = nullptr;
+  material_att_ = nullptr;
+  sub_obj_att_ = nullptr;
+  current_sub_obj_id_ = -1;
+  current_material_id_ = -1;
+  file_name_.clear();
+  return return_value;
+}
+
+bool ObjEncoder::GetSubObjects() {
+  const GeometryMetadata *pc_metadata = in_point_cloud_->GetMetadata();
+  if (!pc_metadata) {
+    return true;
+  }
+  const AttributeMetadata *sub_obj_metadata =
+      pc_metadata->GetAttributeMetadataByStringEntry("name", "sub_obj");
+  if (!sub_obj_metadata) {
+    return true;
+  }
+  sub_obj_id_to_name_.clear();
+  for (const auto &entry : sub_obj_metadata->entries()) {
+    // Sub-object id must be int.
+    int value = 0;
+    if (!entry.second.GetValue(&value)) {
+      continue;
+    }
+    sub_obj_id_to_name_[value] = entry.first;
+  }
+  sub_obj_att_ = in_point_cloud_->GetAttributeByUniqueId(
+      sub_obj_metadata->att_unique_id());
+  if (sub_obj_att_ == nullptr || sub_obj_att_->size() == 0) {
+    return false;
+  }
+  return true;
+}
+
+bool ObjEncoder::EncodeMaterialFileName() {
+  const GeometryMetadata *pc_metadata = in_point_cloud_->GetMetadata();
+  const AttributeMetadata *material_metadata = nullptr;
+  if (pc_metadata) {
+    material_metadata =
+        pc_metadata->GetAttributeMetadataByStringEntry("name", "material");
+  }
+  std::string material_file_name;
+  std::string material_full_path;
+  if (!material_metadata) {
+    return true;
+  }
+  if (!material_metadata->GetEntryString("file_name", &material_file_name))
+    return false;
+  buffer()->Encode("mtllib ", 7);
+  buffer()->Encode(material_file_name.c_str(), material_file_name.size());
+  buffer()->Encode("\n", 1);
+  material_id_to_name_.clear();
+  for (const auto &entry : material_metadata->entries()) {
+    // Material id must be int.
+    int value = 0;
+    // Found entry that are not material id, e.g. file name as a string.
+    if (!entry.second.GetValue(&value)) {
+      continue;
+    }
+    material_id_to_name_[value] = entry.first;
+  }
+  material_att_ = in_point_cloud_->GetAttributeByUniqueId(
+      material_metadata->att_unique_id());
+  if (material_att_ == nullptr || material_att_->size() == 0) {
+    return false;
+  }
+  return true;
+}
+
+bool ObjEncoder::EncodePositions() {
+  const PointAttribute *const att =
+      in_point_cloud_->GetNamedAttribute(GeometryAttribute::POSITION);
+  if (att == nullptr || att->size() == 0) {
+    return false;  // Position attribute must be valid.
+  }
+  std::array<float, 3> value;
+  for (AttributeValueIndex i(0); i < static_cast<uint32_t>(att->size()); ++i) {
+    if (!att->ConvertValue<float, 3>(i, &value[0])) {
+      return false;
+    }
+    buffer()->Encode("v ", 2);
+    EncodeFloatList(&value[0], 3);
+    buffer()->Encode("\n", 1);
+  }
+  pos_att_ = att;
+  return true;
+}
+
+bool ObjEncoder::EncodeTextureCoordinates() {
+  const PointAttribute *const att =
+      in_point_cloud_->GetNamedAttribute(GeometryAttribute::TEX_COORD);
+  if (att == nullptr || att->size() == 0) {
+    return true;  // It's OK if we don't have texture coordinates.
+  }
+  std::array<float, 2> value;
+  for (AttributeValueIndex i(0); i < static_cast<uint32_t>(att->size()); ++i) {
+    if (!att->ConvertValue<float, 2>(i, &value[0])) {
+      return false;
+    }
+    buffer()->Encode("vt ", 3);
+    EncodeFloatList(&value[0], 2);
+    buffer()->Encode("\n", 1);
+  }
+  tex_coord_att_ = att;
+  return true;
+}
+
+bool ObjEncoder::EncodeNormals() {
+  const PointAttribute *const att =
+      in_point_cloud_->GetNamedAttribute(GeometryAttribute::NORMAL);
+  if (att == nullptr || att->size() == 0) {
+    return true;  // It's OK if we don't have normals.
+  }
+  std::array<float, 3> value;
+  for (AttributeValueIndex i(0); i < static_cast<uint32_t>(att->size()); ++i) {
+    if (!att->ConvertValue<float, 3>(i, &value[0])) {
+      return false;
+    }
+    buffer()->Encode("vn ", 3);
+    EncodeFloatList(&value[0], 3);
+    buffer()->Encode("\n", 1);
+  }
+  normal_att_ = att;
+  return true;
+}
+
+bool ObjEncoder::EncodeFaces() {
+  for (FaceIndex i(0); i < in_mesh_->num_faces(); ++i) {
+    if (sub_obj_att_) {
+      if (!EncodeSubObject(i)) {
+        return false;
+      }
+    }
+    if (material_att_) {
+      if (!EncodeMaterial(i)) {
+        return false;
+      }
+    }
+    buffer()->Encode('f');
+    for (int j = 0; j < 3; ++j) {
+      if (!EncodeFaceCorner(i, j)) {
+        return false;
+      }
+    }
+    buffer()->Encode("\n", 1);
+  }
+  return true;
+}
+
+bool ObjEncoder::EncodeMaterial(FaceIndex face_id) {
+  int material_id = 0;
+  // Pick the first corner, all corners of a face should have same id.
+  const PointIndex vert_index = in_mesh_->face(face_id)[0];
+  const AttributeValueIndex index_id(material_att_->mapped_index(vert_index));
+  if (!material_att_->ConvertValue<int>(index_id, &material_id)) {
+    return false;
+  }
+
+  if (material_id != current_material_id_) {
+    // Update material information.
+    buffer()->Encode("usemtl ", 7);
+    const auto mat_ptr = material_id_to_name_.find(material_id);
+    // If the material id is not found.
+    if (mat_ptr == material_id_to_name_.end()) {
+      return false;
+    }
+    buffer()->Encode(mat_ptr->second.c_str(), mat_ptr->second.size());
+    buffer()->Encode("\n", 1);
+    current_material_id_ = material_id;
+  }
+  return true;
+}
+
+bool ObjEncoder::EncodeSubObject(FaceIndex face_id) {
+  int sub_obj_id = 0;
+  // Pick the first corner, all corners of a face should have same id.
+  const PointIndex vert_index = in_mesh_->face(face_id)[0];
+  const AttributeValueIndex index_id(sub_obj_att_->mapped_index(vert_index));
+  if (!sub_obj_att_->ConvertValue<int>(index_id, &sub_obj_id)) {
+    return false;
+  }
+  if (sub_obj_id != current_sub_obj_id_) {
+    buffer()->Encode("o ", 2);
+    const auto sub_obj_ptr = sub_obj_id_to_name_.find(sub_obj_id);
+    if (sub_obj_ptr == sub_obj_id_to_name_.end()) {
+      return false;
+    }
+    buffer()->Encode(sub_obj_ptr->second.c_str(), sub_obj_ptr->second.size());
+    buffer()->Encode("\n", 1);
+    current_sub_obj_id_ = sub_obj_id;
+  }
+  return true;
+}
+
+bool ObjEncoder::EncodeFaceCorner(FaceIndex face_id, int local_corner_id) {
+  buffer()->Encode(' ');
+  const PointIndex vert_index = in_mesh_->face(face_id)[local_corner_id];
+  // Note that in the OBJ format, all indices are encoded starting from index 1.
+  // Encode position index.
+  EncodeInt(pos_att_->mapped_index(vert_index).value() + 1);
+  if (tex_coord_att_ || normal_att_) {
+    // Encoding format is pos_index/tex_coord_index/normal_index.
+    // If tex_coords are not present, we must encode pos_index//normal_index.
+    buffer()->Encode('/');
+    if (tex_coord_att_) {
+      EncodeInt(tex_coord_att_->mapped_index(vert_index).value() + 1);
+    }
+    if (normal_att_) {
+      buffer()->Encode('/');
+      EncodeInt(normal_att_->mapped_index(vert_index).value() + 1);
+    }
+  }
+  return true;
+}
+
+void ObjEncoder::EncodeFloat(float val) {
+  snprintf(num_buffer_, sizeof(num_buffer_), "%f", val);
+  buffer()->Encode(num_buffer_, strlen(num_buffer_));
+}
+
+void ObjEncoder::EncodeFloatList(float *vals, int num_vals) {
+  for (int i = 0; i < num_vals; ++i) {
+    if (i > 0) {
+      buffer()->Encode(' ');
+    }
+    EncodeFloat(vals[i]);
+  }
+}
+
+void ObjEncoder::EncodeInt(int32_t val) {
+  snprintf(num_buffer_, sizeof(num_buffer_), "%d", val);
+  buffer()->Encode(num_buffer_, strlen(num_buffer_));
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/obj_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/io/obj_encoder.h
new file mode 100644
index 000000000..509d39baf
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/obj_encoder.h
@@ -0,0 +1,92 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_OBJ_ENCODER_H_
+#define DRACO_IO_OBJ_ENCODER_H_
+
+#include <unordered_map>
+
+#include "draco/core/encoder_buffer.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Class for encoding input draco::Mesh or draco::PointCloud into the Wavefront
+// OBJ format.
+class ObjEncoder {
+ public:
+  ObjEncoder();
+
+  // Encodes the mesh or a point cloud  and saves it into a file.
+  // Returns false when either the encoding failed or when the file couldn't be
+  // opened.
+  bool EncodeToFile(const PointCloud &pc, const std::string &file_name);
+  bool EncodeToFile(const Mesh &mesh, const std::string &file_name);
+
+  // Encodes the mesh or the point cloud into a buffer.
+  bool EncodeToBuffer(const PointCloud &pc, EncoderBuffer *out_buffer);
+  bool EncodeToBuffer(const Mesh &mesh, EncoderBuffer *out_buffer);
+
+ protected:
+  bool EncodeInternal();
+  EncoderBuffer *buffer() const { return out_buffer_; }
+  bool ExitAndCleanup(bool return_value);
+
+ private:
+  bool GetSubObjects();
+  bool EncodeMaterialFileName();
+  bool EncodePositions();
+  bool EncodeTextureCoordinates();
+  bool EncodeNormals();
+  bool EncodeFaces();
+  bool EncodeSubObject(FaceIndex face_id);
+  bool EncodeMaterial(FaceIndex face_id);
+  bool EncodeFaceCorner(FaceIndex face_id, int local_corner_id);
+
+  void EncodeFloat(float val);
+  void EncodeFloatList(float *vals, int num_vals);
+  void EncodeInt(int32_t val);
+
+  // Various attributes used by the encoder. If an attribute is not used, it is
+  // set to nullptr.
+  const PointAttribute *pos_att_;
+  const PointAttribute *tex_coord_att_;
+  const PointAttribute *normal_att_;
+  const PointAttribute *material_att_;
+  const PointAttribute *sub_obj_att_;
+
+  // Buffer used for encoding float/int numbers.
+  char num_buffer_[20];
+
+  EncoderBuffer *out_buffer_;
+
+  const PointCloud *in_point_cloud_;
+  const Mesh *in_mesh_;
+
+  // Store sub object name for each value.
+  std::unordered_map<int, std::string> sub_obj_id_to_name_;
+  // Current sub object id of faces.
+  int current_sub_obj_id_;
+
+  // Store material name for each value in material attribute.
+  std::unordered_map<int, std::string> material_id_to_name_;
+  // Current material id of faces.
+  int current_material_id_;
+
+  std::string file_name_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_OBJ_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/obj_encoder_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/io/obj_encoder_test.cc
new file mode 100644
index 000000000..4838e56ca
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/obj_encoder_test.cc
@@ -0,0 +1,110 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/obj_encoder.h"
+
+#include <sstream>
+
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+#include "draco/io/file_reader_factory.h"
+#include "draco/io/file_reader_interface.h"
+#include "draco/io/obj_decoder.h"
+
+namespace draco {
+
+class ObjEncoderTest : public ::testing::Test {
+ protected:
+  void CompareMeshes(const Mesh *mesh0, const Mesh *mesh1) {
+    ASSERT_EQ(mesh0->num_faces(), mesh1->num_faces());
+    ASSERT_EQ(mesh0->num_attributes(), mesh1->num_attributes());
+    for (size_t att_id = 0; att_id < mesh0->num_attributes(); ++att_id) {
+      ASSERT_EQ(mesh0->attribute(att_id)->size(),
+                mesh1->attribute(att_id)->size());
+    }
+  }
+
+  // Encode a mesh using the ObjEncoder and then decode to verify the encoding.
+  std::unique_ptr<Mesh> EncodeAndDecodeMesh(const Mesh *mesh) {
+    EncoderBuffer encoder_buffer;
+    ObjEncoder encoder;
+    if (!encoder.EncodeToBuffer(*mesh, &encoder_buffer)) {
+      return nullptr;
+    }
+
+    DecoderBuffer decoder_buffer;
+    decoder_buffer.Init(encoder_buffer.data(), encoder_buffer.size());
+    std::unique_ptr<Mesh> decoded_mesh(new Mesh());
+    ObjDecoder decoder;
+    decoder.set_use_metadata(true);
+    if (!decoder.DecodeFromBuffer(&decoder_buffer, decoded_mesh.get()).ok()) {
+      return nullptr;
+    }
+    return decoded_mesh;
+  }
+
+  void test_encoding(const std::string &file_name) {
+    const std::unique_ptr<Mesh> mesh(ReadMeshFromTestFile(file_name, true));
+
+    ASSERT_NE(mesh, nullptr) << "Failed to load test model " << file_name;
+    ASSERT_GT(mesh->num_faces(), 0);
+
+    const std::unique_ptr<Mesh> decoded_mesh = EncodeAndDecodeMesh(mesh.get());
+    CompareMeshes(mesh.get(), decoded_mesh.get());
+  }
+};
+
+TEST_F(ObjEncoderTest, HasSubObject) { test_encoding("cube_att_sub_o.obj"); }
+
+TEST_F(ObjEncoderTest, HasMaterial) {
+  const std::unique_ptr<Mesh> mesh0(ReadMeshFromTestFile("mat_test.obj", true));
+  ASSERT_NE(mesh0, nullptr);
+  const std::unique_ptr<Mesh> mesh1 = EncodeAndDecodeMesh(mesh0.get());
+  ASSERT_NE(mesh1, nullptr);
+  ASSERT_EQ(mesh0->num_faces(), mesh1->num_faces());
+  ASSERT_EQ(mesh0->num_attributes(), mesh1->num_attributes());
+  // Position attribute should be the same.
+  ASSERT_EQ(mesh0->attribute(0)->size(), mesh1->attribute(0)->size());
+  // Since |mesh1| is decoded from buffer, it has not material file. So the
+  // size of material attribute is the number of materials used in the obj
+  // file which is 7. The size of material attribute of |mesh0| decoded from
+  // the obj file will be the number of materials defined in the .mtl file.
+  ASSERT_EQ(mesh0->attribute(1)->size(), 29);
+  ASSERT_EQ(mesh1->attribute(1)->size(), 7);
+}
+
+TEST_F(ObjEncoderTest, TestObjEncodingAll) {
+  // Test decoded mesh from encoded obj file stays the same.
+  test_encoding("bunny_norm.obj");
+  test_encoding("cube_att.obj");
+  test_encoding("cube_att_partial.obj");
+  test_encoding("cube_quads.obj");
+  test_encoding("cube_subd.obj");
+  test_encoding("extra_vertex.obj");
+  test_encoding("multiple_isolated_triangles.obj");
+  test_encoding("multiple_tetrahedrons.obj");
+  test_encoding("one_face_123.obj");
+  test_encoding("one_face_312.obj");
+  test_encoding("one_face_321.obj");
+  test_encoding("sphere.obj");
+  test_encoding("test_nm.obj");
+  test_encoding("test_nm_trans.obj");
+  test_encoding("test_sphere.obj");
+  test_encoding("three_faces_123.obj");
+  test_encoding("three_faces_312.obj");
+  test_encoding("two_faces_123.obj");
+  test_encoding("two_faces_312.obj");
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/parser_utils.cc b/Engine/lib/assimp/contrib/draco/src/draco/io/parser_utils.cc
new file mode 100644
index 000000000..12afacff6
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/parser_utils.cc
@@ -0,0 +1,261 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/parser_utils.h"
+
+#include <algorithm>
+#include <cctype>
+#include <cmath>
+#include <iterator>
+#include <limits>
+
+namespace draco {
+namespace parser {
+
+void SkipCharacters(DecoderBuffer *buffer, const char *skip_chars) {
+  if (skip_chars == nullptr) {
+    return;
+  }
+  const int num_skip_chars = static_cast<int>(strlen(skip_chars));
+  char c;
+  while (buffer->Peek(&c)) {
+    // Check all characters in the pattern.
+    bool skip = false;
+    for (int i = 0; i < num_skip_chars; ++i) {
+      if (c == skip_chars[i]) {
+        skip = true;
+        break;
+      }
+    }
+    if (!skip) {
+      return;
+    }
+    buffer->Advance(1);
+  }
+}
+
+void SkipWhitespace(DecoderBuffer *buffer) {
+  bool end_reached = false;
+  while (PeekWhitespace(buffer, &end_reached) && !end_reached) {
+    // Skip the whitespace character
+    buffer->Advance(1);
+  }
+}
+
+bool PeekWhitespace(DecoderBuffer *buffer, bool *end_reached) {
+  uint8_t c;
+  if (!buffer->Peek(&c)) {
+    *end_reached = true;
+    return false;  // eof reached.
+  }
+  if (!isspace(c)) {
+    return false;  // Non-whitespace character reached.
+  }
+  return true;
+}
+
+void SkipLine(DecoderBuffer *buffer) { ParseLine(buffer, nullptr); }
+
+bool ParseFloat(DecoderBuffer *buffer, float *value) {
+  // Read optional sign.
+  char ch;
+  if (!buffer->Peek(&ch)) {
+    return false;
+  }
+  int sign = GetSignValue(ch);
+  if (sign != 0) {
+    buffer->Advance(1);
+  } else {
+    sign = 1;
+  }
+
+  // Parse integer component.
+  bool have_digits = false;
+  double v = 0.0;
+  while (buffer->Peek(&ch) && ch >= '0' && ch <= '9') {
+    v *= 10.0;
+    v += (ch - '0');
+    buffer->Advance(1);
+    have_digits = true;
+  }
+  if (ch == '.') {
+    // Parse fractional component.
+    buffer->Advance(1);
+    double fraction = 1.0;
+    while (buffer->Peek(&ch) && ch >= '0' && ch <= '9') {
+      fraction *= 0.1;
+      v += (ch - '0') * fraction;
+      buffer->Advance(1);
+      have_digits = true;
+    }
+  }
+
+  if (!have_digits) {
+    // Check for special constants (inf, nan, ...).
+    std::string text;
+    if (!ParseString(buffer, &text)) {
+      return false;
+    }
+    if (text == "inf" || text == "Inf") {
+      v = std::numeric_limits<double>::infinity();
+    } else if (text == "nan" || text == "NaN") {
+      v = nan("");
+    } else {
+      // Invalid string.
+      return false;
+    }
+  } else {
+    // Handle exponent if present.
+    if (ch == 'e' || ch == 'E') {
+      buffer->Advance(1);  // Skip 'e' marker.
+
+      // Parse integer exponent.
+      int32_t exponent = 0;
+      if (!ParseSignedInt(buffer, &exponent)) {
+        return false;
+      }
+
+      // Apply exponent scaling to value.
+      v *= pow(static_cast<double>(10.0), exponent);
+    }
+  }
+
+  *value = (sign < 0) ? static_cast<float>(-v) : static_cast<float>(v);
+  return true;
+}
+
+bool ParseSignedInt(DecoderBuffer *buffer, int32_t *value) {
+  // Parse any explicit sign and set the appropriate largest magnitude
+  // value that can be represented without overflow.
+  char ch;
+  if (!buffer->Peek(&ch)) {
+    return false;
+  }
+  const int sign = GetSignValue(ch);
+  if (sign != 0) {
+    buffer->Advance(1);
+  }
+
+  // Attempt to parse integer body.
+  uint32_t v;
+  if (!ParseUnsignedInt(buffer, &v)) {
+    return false;
+  }
+  *value = (sign < 0) ? -v : v;
+  return true;
+}
+
+bool ParseUnsignedInt(DecoderBuffer *buffer, uint32_t *value) {
+  // Parse the number until we run out of digits.
+  uint32_t v = 0;
+  char ch;
+  bool have_digits = false;
+  while (buffer->Peek(&ch) && ch >= '0' && ch <= '9') {
+    v *= 10;
+    v += (ch - '0');
+    buffer->Advance(1);
+    have_digits = true;
+  }
+  if (!have_digits) {
+    return false;
+  }
+  *value = v;
+  return true;
+}
+
+int GetSignValue(char c) {
+  if (c == '-') {
+    return -1;
+  }
+  if (c == '+') {
+    return 1;
+  }
+  return 0;
+}
+
+bool ParseString(DecoderBuffer *buffer, std::string *out_string) {
+  out_string->clear();
+  SkipWhitespace(buffer);
+  bool end_reached = false;
+  while (!PeekWhitespace(buffer, &end_reached) && !end_reached) {
+    char c;
+    if (!buffer->Decode(&c)) {
+      return false;
+    }
+    *out_string += c;
+  }
+  return true;
+}
+
+void ParseLine(DecoderBuffer *buffer, std::string *out_string) {
+  if (out_string) {
+    out_string->clear();
+  }
+  char c;
+  bool delim_reached = false;
+  while (buffer->Peek(&c)) {
+    // Check if |c| is a delimeter. We want to parse all delimeters until we
+    // reach a non-delimeter symbol. (E.g. we want to ignore '\r\n' at the end
+    // of the line).
+    const bool is_delim = (c == '\r' || c == '\n');
+
+    // If |c| is a delimeter or it is a non-delimeter symbol before any
+    // delimeter was found, we advance the buffer to the next character.
+    if (is_delim || !delim_reached) {
+      buffer->Advance(1);
+    }
+
+    if (is_delim) {
+      // Mark that we found a delimeter symbol.
+      delim_reached = true;
+      continue;
+    }
+    if (delim_reached) {
+      // We reached a non-delimeter symbol after a delimeter was already found.
+      // Stop the parsing.
+      return;
+    }
+    // Otherwise we put the non-delimeter symbol into the output string.
+    if (out_string) {
+      out_string->push_back(c);
+    }
+  }
+}
+
+DecoderBuffer ParseLineIntoDecoderBuffer(DecoderBuffer *buffer) {
+  const char *const head = buffer->data_head();
+  char c;
+  while (buffer->Peek(&c)) {
+    // Skip the character.
+    buffer->Advance(1);
+    if (c == '\n') {
+      break;  // End of the line reached.
+    }
+    if (c == '\r') {
+      continue;  // Ignore extra line ending characters.
+    }
+  }
+  DecoderBuffer out_buffer;
+  out_buffer.Init(head, buffer->data_head() - head);
+  return out_buffer;
+}
+
+std::string ToLower(const std::string &str) {
+  std::string out;
+  std::transform(str.begin(), str.end(), std::back_inserter(out), tolower);
+  return out;
+}
+
+}  // namespace parser
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/parser_utils.h b/Engine/lib/assimp/contrib/draco/src/draco/io/parser_utils.h
new file mode 100644
index 000000000..b83cd9365
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/parser_utils.h
@@ -0,0 +1,66 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_PARSER_UTILS_H_
+#define DRACO_IO_PARSER_UTILS_H_
+
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+namespace parser {
+
+// Skips to first character not included in |skip_chars|.
+void SkipCharacters(DecoderBuffer *buffer, const char *skip_chars);
+
+// Skips any whitespace until a regular character is reached.
+void SkipWhitespace(DecoderBuffer *buffer);
+
+// Returns true if the next character is a whitespace.
+// |end_reached| is set to true when the end of the stream is reached.
+bool PeekWhitespace(DecoderBuffer *buffer, bool *end_reached);
+
+// Skips all characters until the end of the line.
+void SkipLine(DecoderBuffer *buffer);
+
+// Parses signed floating point number or returns false on error.
+bool ParseFloat(DecoderBuffer *buffer, float *value);
+
+// Parses a signed integer (can be preceded by '-' or '+' characters.
+bool ParseSignedInt(DecoderBuffer *buffer, int32_t *value);
+
+// Parses an unsigned integer. It cannot be preceded by '-' or '+'
+// characters.
+bool ParseUnsignedInt(DecoderBuffer *buffer, uint32_t *value);
+
+// Returns -1 if c == '-'.
+// Returns +1 if c == '+'.
+// Returns 0 otherwise.
+int GetSignValue(char c);
+
+// Parses a string until a whitespace or end of file is reached.
+bool ParseString(DecoderBuffer *buffer, std::string *out_string);
+
+// Parses the entire line into the buffer (excluding the new line characters).
+void ParseLine(DecoderBuffer *buffer, std::string *out_string);
+
+// Parses line and stores into a new decoder buffer.
+DecoderBuffer ParseLineIntoDecoderBuffer(DecoderBuffer *buffer);
+
+// Returns a string with all characters converted to lower case.
+std::string ToLower(const std::string &str);
+
+}  // namespace parser
+}  // namespace draco
+
+#endif  // DRACO_IO_PARSER_UTILS_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/ply_decoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/io/ply_decoder.cc
new file mode 100644
index 000000000..b78c05690
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/ply_decoder.cc
@@ -0,0 +1,320 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/ply_decoder.h"
+
+#include "draco/core/macros.h"
+#include "draco/core/status.h"
+#include "draco/io/file_utils.h"
+#include "draco/io/ply_property_reader.h"
+
+namespace draco {
+namespace {
+int64_t CountNumTriangles(const PlyElement &face_element,
+                          const PlyProperty &vertex_indices) {
+  int64_t num_triangles = 0;
+  for (int i = 0; i < face_element.num_entries(); ++i) {
+    const int64_t list_size = vertex_indices.GetListEntryNumValues(i);
+    if (list_size < 3) {
+      // Correctly encoded ply files don't have less than three vertices.
+      continue;
+    }
+    num_triangles += list_size - 2;
+  }
+  return num_triangles;
+}
+}  // namespace
+
+PlyDecoder::PlyDecoder() : out_mesh_(nullptr), out_point_cloud_(nullptr) {}
+
+Status PlyDecoder::DecodeFromFile(const std::string &file_name,
+                                  Mesh *out_mesh) {
+  out_mesh_ = out_mesh;
+  return DecodeFromFile(file_name, static_cast<PointCloud *>(out_mesh));
+}
+
+Status PlyDecoder::DecodeFromFile(const std::string &file_name,
+                                  PointCloud *out_point_cloud) {
+  std::vector<char> data;
+  if (!ReadFileToBuffer(file_name, &data)) {
+    return Status(Status::DRACO_ERROR, "Unable to read input file.");
+  }
+  buffer_.Init(data.data(), data.size());
+  return DecodeFromBuffer(&buffer_, out_point_cloud);
+}
+
+Status PlyDecoder::DecodeFromBuffer(DecoderBuffer *buffer, Mesh *out_mesh) {
+  out_mesh_ = out_mesh;
+  return DecodeFromBuffer(buffer, static_cast<PointCloud *>(out_mesh));
+}
+
+Status PlyDecoder::DecodeFromBuffer(DecoderBuffer *buffer,
+                                    PointCloud *out_point_cloud) {
+  out_point_cloud_ = out_point_cloud;
+  buffer_.Init(buffer->data_head(), buffer->remaining_size());
+  return DecodeInternal();
+}
+
+Status PlyDecoder::DecodeInternal() {
+  PlyReader ply_reader;
+  DRACO_RETURN_IF_ERROR(ply_reader.Read(buffer()));
+  // First, decode the connectivity data.
+  if (out_mesh_)
+    DRACO_RETURN_IF_ERROR(DecodeFaceData(ply_reader.GetElementByName("face")));
+  // Decode all attributes.
+  DRACO_RETURN_IF_ERROR(
+      DecodeVertexData(ply_reader.GetElementByName("vertex")));
+  // In case there are no faces this is just a point cloud which does
+  // not require deduplication.
+  if (out_mesh_ && out_mesh_->num_faces() != 0) {
+#ifdef DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED
+    if (!out_point_cloud_->DeduplicateAttributeValues()) {
+      return Status(Status::DRACO_ERROR,
+                    "Could not deduplicate attribute values");
+    }
+#endif
+#ifdef DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+    out_point_cloud_->DeduplicatePointIds();
+#endif
+  }
+  return OkStatus();
+}
+
+Status PlyDecoder::DecodeFaceData(const PlyElement *face_element) {
+  // We accept point clouds now.
+  if (face_element == nullptr) {
+    return Status(Status::INVALID_PARAMETER, "face_element is null");
+  }
+  const PlyProperty *vertex_indices =
+      face_element->GetPropertyByName("vertex_indices");
+  if (vertex_indices == nullptr) {
+    // The property name may be named either "vertex_indices" or "vertex_index".
+    vertex_indices = face_element->GetPropertyByName("vertex_index");
+  }
+  if (vertex_indices == nullptr || !vertex_indices->is_list()) {
+    return Status(Status::DRACO_ERROR, "No faces defined");
+  }
+
+  // Allocate faces.
+  out_mesh_->SetNumFaces(CountNumTriangles(*face_element, *vertex_indices));
+  const int64_t num_polygons = face_element->num_entries();
+
+  PlyPropertyReader<PointIndex::ValueType> vertex_index_reader(vertex_indices);
+  Mesh::Face face;
+  FaceIndex face_index(0);
+  for (int i = 0; i < num_polygons; ++i) {
+    const int64_t list_offset = vertex_indices->GetListEntryOffset(i);
+    const int64_t list_size = vertex_indices->GetListEntryNumValues(i);
+    if (list_size < 3) {
+      continue;  // All invalid polygons are skipped.
+    }
+
+    // Triangulate polygon assuming the polygon is convex.
+    const int64_t num_triangles = list_size - 2;
+    face[0] = vertex_index_reader.ReadValue(static_cast<int>(list_offset));
+    for (int64_t ti = 0; ti < num_triangles; ++ti) {
+      for (int64_t c = 1; c < 3; ++c) {
+        face[c] = vertex_index_reader.ReadValue(
+            static_cast<int>(list_offset + ti + c));
+      }
+      out_mesh_->SetFace(face_index, face);
+      face_index++;
+    }
+  }
+  out_mesh_->SetNumFaces(face_index.value());
+  return OkStatus();
+}
+
+template <typename DataTypeT>
+bool PlyDecoder::ReadPropertiesToAttribute(
+    const std::vector<const PlyProperty *> &properties,
+    PointAttribute *attribute, int num_vertices) {
+  std::vector<std::unique_ptr<PlyPropertyReader<DataTypeT>>> readers;
+  readers.reserve(properties.size());
+  for (int prop = 0; prop < properties.size(); ++prop) {
+    readers.push_back(std::unique_ptr<PlyPropertyReader<DataTypeT>>(
+        new PlyPropertyReader<DataTypeT>(properties[prop])));
+  }
+  std::vector<DataTypeT> memory(properties.size());
+  for (PointIndex::ValueType i = 0; i < static_cast<uint32_t>(num_vertices);
+       ++i) {
+    for (int prop = 0; prop < properties.size(); ++prop) {
+      memory[prop] = readers[prop]->ReadValue(i);
+    }
+    attribute->SetAttributeValue(AttributeValueIndex(i), memory.data());
+  }
+  return true;
+}
+
+Status PlyDecoder::DecodeVertexData(const PlyElement *vertex_element) {
+  if (vertex_element == nullptr) {
+    return Status(Status::INVALID_PARAMETER, "vertex_element is null");
+  }
+  // TODO(b/34330853): For now, try to load x,y,z vertices, red,green,blue,alpha
+  // colors, and nx,ny,nz normals. We need to add other properties later.
+  const PlyProperty *const x_prop = vertex_element->GetPropertyByName("x");
+  const PlyProperty *const y_prop = vertex_element->GetPropertyByName("y");
+  const PlyProperty *const z_prop = vertex_element->GetPropertyByName("z");
+  if (!x_prop || !y_prop || !z_prop) {
+    // Currently, we require 3 vertex coordinates (this should be generalized
+    // later on).
+    return Status(Status::INVALID_PARAMETER, "x, y, or z property is missing");
+  }
+  const PointIndex::ValueType num_vertices = vertex_element->num_entries();
+  out_point_cloud_->set_num_points(num_vertices);
+  // Decode vertex positions.
+  {
+    // All properties must have the same type.
+    if (x_prop->data_type() != y_prop->data_type() ||
+        y_prop->data_type() != z_prop->data_type()) {
+      return Status(Status::INVALID_PARAMETER,
+                    "x, y, and z properties must have the same type");
+    }
+    // TODO(ostava): For now assume the position types are float32 or int32.
+    const DataType dt = x_prop->data_type();
+    if (dt != DT_FLOAT32 && dt != DT_INT32) {
+      return Status(Status::INVALID_PARAMETER,
+                    "x, y, and z properties must be of type float32 or int32");
+    }
+
+    GeometryAttribute va;
+    va.Init(GeometryAttribute::POSITION, nullptr, 3, dt, false,
+            DataTypeLength(dt) * 3, 0);
+    const int att_id = out_point_cloud_->AddAttribute(va, true, num_vertices);
+    std::vector<const PlyProperty *> properties;
+    properties.push_back(x_prop);
+    properties.push_back(y_prop);
+    properties.push_back(z_prop);
+    if (dt == DT_FLOAT32) {
+      ReadPropertiesToAttribute<float>(
+          properties, out_point_cloud_->attribute(att_id), num_vertices);
+    } else if (dt == DT_INT32) {
+      ReadPropertiesToAttribute<int32_t>(
+          properties, out_point_cloud_->attribute(att_id), num_vertices);
+    }
+  }
+
+  // Decode normals if present.
+  const PlyProperty *const n_x_prop = vertex_element->GetPropertyByName("nx");
+  const PlyProperty *const n_y_prop = vertex_element->GetPropertyByName("ny");
+  const PlyProperty *const n_z_prop = vertex_element->GetPropertyByName("nz");
+  if (n_x_prop != nullptr && n_y_prop != nullptr && n_z_prop != nullptr) {
+    // For now, all normal properties must be set and of type float32
+    if (n_x_prop->data_type() == DT_FLOAT32 &&
+        n_y_prop->data_type() == DT_FLOAT32 &&
+        n_z_prop->data_type() == DT_FLOAT32) {
+      PlyPropertyReader<float> x_reader(n_x_prop);
+      PlyPropertyReader<float> y_reader(n_y_prop);
+      PlyPropertyReader<float> z_reader(n_z_prop);
+      GeometryAttribute va;
+      va.Init(GeometryAttribute::NORMAL, nullptr, 3, DT_FLOAT32, false,
+              sizeof(float) * 3, 0);
+      const int att_id = out_point_cloud_->AddAttribute(va, true, num_vertices);
+      for (PointIndex::ValueType i = 0; i < num_vertices; ++i) {
+        std::array<float, 3> val;
+        val[0] = x_reader.ReadValue(i);
+        val[1] = y_reader.ReadValue(i);
+        val[2] = z_reader.ReadValue(i);
+        out_point_cloud_->attribute(att_id)->SetAttributeValue(
+            AttributeValueIndex(i), &val[0]);
+      }
+    }
+  }
+
+  // Decode color data if present.
+  int num_colors = 0;
+  const PlyProperty *const r_prop = vertex_element->GetPropertyByName("red");
+  const PlyProperty *const g_prop = vertex_element->GetPropertyByName("green");
+  const PlyProperty *const b_prop = vertex_element->GetPropertyByName("blue");
+  const PlyProperty *const a_prop = vertex_element->GetPropertyByName("alpha");
+  if (r_prop) {
+    ++num_colors;
+  }
+  if (g_prop) {
+    ++num_colors;
+  }
+  if (b_prop) {
+    ++num_colors;
+  }
+  if (a_prop) {
+    ++num_colors;
+  }
+
+  if (num_colors) {
+    std::vector<std::unique_ptr<PlyPropertyReader<uint8_t>>> color_readers;
+    const PlyProperty *p;
+    if (r_prop) {
+      p = r_prop;
+      // TODO(ostava): For now ensure the data type of all components is uint8.
+      DRACO_DCHECK_EQ(true, p->data_type() == DT_UINT8);
+      if (p->data_type() != DT_UINT8) {
+        return Status(Status::INVALID_PARAMETER,
+                      "Type of 'red' property must be uint8");
+      }
+      color_readers.push_back(std::unique_ptr<PlyPropertyReader<uint8_t>>(
+          new PlyPropertyReader<uint8_t>(p)));
+    }
+    if (g_prop) {
+      p = g_prop;
+      // TODO(ostava): For now ensure the data type of all components is uint8.
+      DRACO_DCHECK_EQ(true, p->data_type() == DT_UINT8);
+      if (p->data_type() != DT_UINT8) {
+        return Status(Status::INVALID_PARAMETER,
+                      "Type of 'green' property must be uint8");
+      }
+      color_readers.push_back(std::unique_ptr<PlyPropertyReader<uint8_t>>(
+          new PlyPropertyReader<uint8_t>(p)));
+    }
+    if (b_prop) {
+      p = b_prop;
+      // TODO(ostava): For now ensure the data type of all components is uint8.
+      DRACO_DCHECK_EQ(true, p->data_type() == DT_UINT8);
+      if (p->data_type() != DT_UINT8) {
+        return Status(Status::INVALID_PARAMETER,
+                      "Type of 'blue' property must be uint8");
+      }
+      color_readers.push_back(std::unique_ptr<PlyPropertyReader<uint8_t>>(
+          new PlyPropertyReader<uint8_t>(p)));
+    }
+    if (a_prop) {
+      p = a_prop;
+      // TODO(ostava): For now ensure the data type of all components is uint8.
+      DRACO_DCHECK_EQ(true, p->data_type() == DT_UINT8);
+      if (p->data_type() != DT_UINT8) {
+        return Status(Status::INVALID_PARAMETER,
+                      "Type of 'alpha' property must be uint8");
+      }
+      color_readers.push_back(std::unique_ptr<PlyPropertyReader<uint8_t>>(
+          new PlyPropertyReader<uint8_t>(p)));
+    }
+
+    GeometryAttribute va;
+    va.Init(GeometryAttribute::COLOR, nullptr, num_colors, DT_UINT8, true,
+            sizeof(uint8_t) * num_colors, 0);
+    const int32_t att_id =
+        out_point_cloud_->AddAttribute(va, true, num_vertices);
+    for (PointIndex::ValueType i = 0; i < num_vertices; ++i) {
+      std::array<uint8_t, 4> val;
+      for (int j = 0; j < num_colors; j++) {
+        val[j] = color_readers[j]->ReadValue(i);
+      }
+      out_point_cloud_->attribute(att_id)->SetAttributeValue(
+          AttributeValueIndex(i), &val[0]);
+    }
+  }
+
+  return OkStatus();
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/ply_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/io/ply_decoder.h
new file mode 100644
index 000000000..db1e480c1
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/ply_decoder.h
@@ -0,0 +1,69 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_PLY_DECODER_H_
+#define DRACO_IO_PLY_DECODER_H_
+
+#include <string>
+
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/status.h"
+#include "draco/draco_features.h"
+#include "draco/io/ply_reader.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Decodes a PLY file into draco::Mesh (or draco::PointCloud if the
+// connectivity data is not needed).
+// TODO(b/34330853): The current implementation assumes that the input vertices
+// are defined with x, y, z properties. The decoder also reads uint8 red, green,
+// blue, alpha color information, float32 defined as nx, ny, nz properties, but
+// all other attributes are ignored for now.
+class PlyDecoder {
+ public:
+  PlyDecoder();
+
+  // Decodes an obj file stored in the input file.
+  Status DecodeFromFile(const std::string &file_name, Mesh *out_mesh);
+  Status DecodeFromFile(const std::string &file_name,
+                        PointCloud *out_point_cloud);
+
+  Status DecodeFromBuffer(DecoderBuffer *buffer, Mesh *out_mesh);
+  Status DecodeFromBuffer(DecoderBuffer *buffer, PointCloud *out_point_cloud);
+
+ protected:
+  Status DecodeInternal();
+  DecoderBuffer *buffer() { return &buffer_; }
+
+ private:
+  Status DecodeFaceData(const PlyElement *face_element);
+  Status DecodeVertexData(const PlyElement *vertex_element);
+
+  template <typename DataTypeT>
+  bool ReadPropertiesToAttribute(
+      const std::vector<const PlyProperty *> &properties,
+      PointAttribute *attribute, int num_vertices);
+
+  DecoderBuffer buffer_;
+
+  // Data structure that stores the decoded data. |out_point_cloud_| must be
+  // always set but |out_mesh_| is optional.
+  Mesh *out_mesh_;
+  PointCloud *out_point_cloud_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_PLY_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/ply_decoder_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/io/ply_decoder_test.cc
new file mode 100644
index 000000000..97977c8cc
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/ply_decoder_test.cc
@@ -0,0 +1,93 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/ply_decoder.h"
+
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+
+namespace draco {
+
+class PlyDecoderTest : public ::testing::Test {
+ protected:
+  template <class Geometry>
+  std::unique_ptr<Geometry> DecodePly(const std::string &file_name) const {
+    const std::string path = GetTestFileFullPath(file_name);
+    PlyDecoder decoder;
+    std::unique_ptr<Geometry> geometry(new Geometry());
+    Status status = decoder.DecodeFromFile(path, geometry.get());
+    if (!status.ok()) {
+      LOG(ERROR) << "Failed to decode " << file_name << ": " << status;
+      return nullptr;
+    }
+    return geometry;
+  }
+
+  void test_decoding(const std::string &file_name, int num_faces,
+                     uint32_t num_points, std::unique_ptr<Mesh> *out_mesh) {
+    // Don't test mesh decoding when the input is point cloud.
+    if (num_faces > 0) {
+      std::unique_ptr<Mesh> mesh(DecodePly<Mesh>(file_name));
+      ASSERT_NE(mesh, nullptr) << "Failed to load test model " << file_name;
+      ASSERT_EQ(mesh->num_faces(), num_faces);
+      if (out_mesh) {
+        *out_mesh = std::move(mesh);
+      }
+    }
+
+    const std::unique_ptr<PointCloud> pc(DecodePly<PointCloud>(file_name));
+    ASSERT_NE(pc, nullptr) << "Failed to load test model " << file_name;
+    ASSERT_EQ(pc->num_points(), num_points);
+  }
+  void test_decoding(const std::string &file_name) {
+    const std::unique_ptr<Mesh> mesh(DecodePly<Mesh>(file_name));
+    ASSERT_NE(mesh, nullptr) << "Failed to load test model " << file_name;
+    ASSERT_GT(mesh->num_faces(), 0);
+
+    const std::unique_ptr<PointCloud> pc(DecodePly<PointCloud>(file_name));
+    ASSERT_NE(pc, nullptr) << "Failed to load test model " << file_name;
+    ASSERT_GT(pc->num_points(), 0);
+  }
+};
+
+TEST_F(PlyDecoderTest, TestPlyDecoding) {
+  const std::string file_name = "test_pos_color.ply";
+  test_decoding(file_name, 224, 114, nullptr);
+}
+
+TEST_F(PlyDecoderTest, TestPlyNormals) {
+  const std::string file_name = "cube_att.ply";
+  std::unique_ptr<Mesh> mesh;
+  test_decoding(file_name, 12, 3 * 8, &mesh);
+  ASSERT_NE(mesh, nullptr);
+  const int att_id = mesh->GetNamedAttributeId(GeometryAttribute::NORMAL);
+  ASSERT_GE(att_id, 0);
+  const PointAttribute *const att = mesh->attribute(att_id);
+  ASSERT_EQ(att->size(), 6);  // 6 unique normal values.
+}
+
+TEST_F(PlyDecoderTest, TestPlyDecodingAll) {
+  // test if we can read all ply that are currently in test folder.
+  test_decoding("bun_zipper.ply");
+  // test_decoding("cube_att.ply"); // tested
+  test_decoding("test_extra_whitespace.ply");
+  test_decoding("test_more_datatypes.ply");
+  test_decoding("test_pos_color_ascii.ply");
+  test_decoding("int_point_cloud.ply", 0, 16, nullptr);
+  // test_decoding("test_pos_color.ply"); // tested
+  test_decoding("cube_quads.ply");
+  test_decoding("Box.ply");
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/ply_encoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/io/ply_encoder.cc
new file mode 100644
index 000000000..2f6a1a2a8
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/ply_encoder.cc
@@ -0,0 +1,211 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/ply_encoder.h"
+
+#include <memory>
+#include <sstream>
+
+#include "draco/io/file_writer_factory.h"
+#include "draco/io/file_writer_interface.h"
+
+namespace draco {
+
+PlyEncoder::PlyEncoder()
+    : out_buffer_(nullptr), in_point_cloud_(nullptr), in_mesh_(nullptr) {}
+
+bool PlyEncoder::EncodeToFile(const PointCloud &pc,
+                              const std::string &file_name) {
+  std::unique_ptr<FileWriterInterface> file =
+      FileWriterFactory::OpenWriter(file_name);
+  if (!file) {
+    return false;  // File couldn't be opened.
+  }
+  // Encode the mesh into a buffer.
+  EncoderBuffer buffer;
+  if (!EncodeToBuffer(pc, &buffer)) {
+    return false;
+  }
+  // Write the buffer into the file.
+  file->Write(buffer.data(), buffer.size());
+  return true;
+}
+
+bool PlyEncoder::EncodeToFile(const Mesh &mesh, const std::string &file_name) {
+  in_mesh_ = &mesh;
+  return EncodeToFile(static_cast<const PointCloud &>(mesh), file_name);
+}
+
+bool PlyEncoder::EncodeToBuffer(const PointCloud &pc,
+                                EncoderBuffer *out_buffer) {
+  in_point_cloud_ = &pc;
+  out_buffer_ = out_buffer;
+  if (!EncodeInternal()) {
+    return ExitAndCleanup(false);
+  }
+  return ExitAndCleanup(true);
+}
+
+bool PlyEncoder::EncodeToBuffer(const Mesh &mesh, EncoderBuffer *out_buffer) {
+  in_mesh_ = &mesh;
+  return EncodeToBuffer(static_cast<const PointCloud &>(mesh), out_buffer);
+}
+bool PlyEncoder::EncodeInternal() {
+  // Write PLY header.
+  // TODO(ostava): Currently works only for xyz positions and rgb(a) colors.
+  std::stringstream out;
+  out << "ply" << std::endl;
+  out << "format binary_little_endian 1.0" << std::endl;
+  out << "element vertex " << in_point_cloud_->num_points() << std::endl;
+
+  const int pos_att_id =
+      in_point_cloud_->GetNamedAttributeId(GeometryAttribute::POSITION);
+  int normal_att_id =
+      in_point_cloud_->GetNamedAttributeId(GeometryAttribute::NORMAL);
+  int tex_coord_att_id =
+      in_point_cloud_->GetNamedAttributeId(GeometryAttribute::TEX_COORD);
+  const int color_att_id =
+      in_point_cloud_->GetNamedAttributeId(GeometryAttribute::COLOR);
+
+  if (pos_att_id < 0) {
+    return false;
+  }
+
+  // Ensure normals are 3 component. Don't encode them otherwise.
+  if (normal_att_id >= 0 &&
+      in_point_cloud_->attribute(normal_att_id)->num_components() != 3) {
+    normal_att_id = -1;
+  }
+
+  // Ensure texture coordinates have only 2 components. Don't encode them
+  // otherwise. TODO(ostava): Add support for 3 component normals (uvw).
+  if (tex_coord_att_id >= 0 &&
+      in_point_cloud_->attribute(tex_coord_att_id)->num_components() != 2) {
+    tex_coord_att_id = -1;
+  }
+
+  out << "property " << GetAttributeDataType(pos_att_id) << " x" << std::endl;
+  out << "property " << GetAttributeDataType(pos_att_id) << " y" << std::endl;
+  out << "property " << GetAttributeDataType(pos_att_id) << " z" << std::endl;
+  if (normal_att_id >= 0) {
+    out << "property " << GetAttributeDataType(normal_att_id) << " nx"
+        << std::endl;
+    out << "property " << GetAttributeDataType(normal_att_id) << " ny"
+        << std::endl;
+    out << "property " << GetAttributeDataType(normal_att_id) << " nz"
+        << std::endl;
+  }
+  if (color_att_id >= 0) {
+    const auto *const attribute = in_point_cloud_->attribute(color_att_id);
+    if (attribute->num_components() > 0) {
+      out << "property " << GetAttributeDataType(color_att_id) << " red"
+          << std::endl;
+    }
+    if (attribute->num_components() > 1) {
+      out << "property " << GetAttributeDataType(color_att_id) << " green"
+          << std::endl;
+    }
+    if (attribute->num_components() > 2) {
+      out << "property " << GetAttributeDataType(color_att_id) << " blue"
+          << std::endl;
+    }
+    if (attribute->num_components() > 3) {
+      out << "property " << GetAttributeDataType(color_att_id) << " alpha"
+          << std::endl;
+    }
+  }
+  if (in_mesh_) {
+    out << "element face " << in_mesh_->num_faces() << std::endl;
+    out << "property list uchar int vertex_indices" << std::endl;
+    if (tex_coord_att_id >= 0) {
+      // Texture coordinates are usually encoded in the property list (one value
+      // per corner).
+      out << "property list uchar " << GetAttributeDataType(tex_coord_att_id)
+          << " texcoord" << std::endl;
+    }
+  }
+  out << "end_header" << std::endl;
+
+  // Not very efficient but the header should be small so just copy the stream
+  // to a string.
+  const std::string header_str = out.str();
+  buffer()->Encode(header_str.data(), header_str.length());
+
+  // Store point attributes.
+  for (PointIndex v(0); v < in_point_cloud_->num_points(); ++v) {
+    const auto *const pos_att = in_point_cloud_->attribute(pos_att_id);
+    buffer()->Encode(pos_att->GetAddress(pos_att->mapped_index(v)),
+                     pos_att->byte_stride());
+    if (normal_att_id >= 0) {
+      const auto *const normal_att = in_point_cloud_->attribute(normal_att_id);
+      buffer()->Encode(normal_att->GetAddress(normal_att->mapped_index(v)),
+                       normal_att->byte_stride());
+    }
+    if (color_att_id >= 0) {
+      const auto *const color_att = in_point_cloud_->attribute(color_att_id);
+      buffer()->Encode(color_att->GetAddress(color_att->mapped_index(v)),
+                       color_att->byte_stride());
+    }
+  }
+
+  if (in_mesh_) {
+    // Write face data.
+    for (FaceIndex i(0); i < in_mesh_->num_faces(); ++i) {
+      // Write the number of face indices (always 3).
+      buffer()->Encode(static_cast<uint8_t>(3));
+
+      const auto &f = in_mesh_->face(i);
+      buffer()->Encode(f[0]);
+      buffer()->Encode(f[1]);
+      buffer()->Encode(f[2]);
+
+      if (tex_coord_att_id >= 0) {
+        // Two coordinates for every corner -> 6.
+        buffer()->Encode(static_cast<uint8_t>(6));
+
+        const auto *const tex_att =
+            in_point_cloud_->attribute(tex_coord_att_id);
+        for (int c = 0; c < 3; ++c) {
+          buffer()->Encode(tex_att->GetAddress(tex_att->mapped_index(f[c])),
+                           tex_att->byte_stride());
+        }
+      }
+    }
+  }
+  return true;
+}
+
+bool PlyEncoder::ExitAndCleanup(bool return_value) {
+  in_mesh_ = nullptr;
+  in_point_cloud_ = nullptr;
+  out_buffer_ = nullptr;
+  return return_value;
+}
+
+const char *PlyEncoder::GetAttributeDataType(int attribute) {
+  // TODO(ostava): Add support for more types.
+  switch (in_point_cloud_->attribute(attribute)->data_type()) {
+    case DT_FLOAT32:
+      return "float";
+    case DT_UINT8:
+      return "uchar";
+    case DT_INT32:
+      return "int";
+    default:
+      break;
+  }
+  return nullptr;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/ply_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/io/ply_encoder.h
new file mode 100644
index 000000000..242bbd6d4
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/ply_encoder.h
@@ -0,0 +1,54 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_PLY_ENCODER_H_
+#define DRACO_IO_PLY_ENCODER_H_
+
+#include "draco/core/encoder_buffer.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Class for encoding draco::Mesh or draco::PointCloud into the PLY file format.
+class PlyEncoder {
+ public:
+  PlyEncoder();
+
+  // Encodes the mesh or a point cloud  and saves it into a file.
+  // Returns false when either the encoding failed or when the file couldn't be
+  // opened.
+  bool EncodeToFile(const PointCloud &pc, const std::string &file_name);
+  bool EncodeToFile(const Mesh &mesh, const std::string &file_name);
+
+  // Encodes the mesh or the point cloud into a buffer.
+  bool EncodeToBuffer(const PointCloud &pc, EncoderBuffer *out_buffer);
+  bool EncodeToBuffer(const Mesh &mesh, EncoderBuffer *out_buffer);
+
+ protected:
+  bool EncodeInternal();
+  EncoderBuffer *buffer() const { return out_buffer_; }
+  bool ExitAndCleanup(bool return_value);
+
+ private:
+  const char *GetAttributeDataType(int attribute);
+
+  EncoderBuffer *out_buffer_;
+
+  const PointCloud *in_point_cloud_;
+  const Mesh *in_mesh_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_PLY_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/ply_property_reader.h b/Engine/lib/assimp/contrib/draco/src/draco/io/ply_property_reader.h
new file mode 100644
index 000000000..efb8a3a1f
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/ply_property_reader.h
@@ -0,0 +1,96 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_PLY_PROPERTY_READER_H_
+#define DRACO_IO_PLY_PROPERTY_READER_H_
+
+#include <functional>
+
+#include "draco/io/ply_reader.h"
+
+namespace draco {
+
+// Class for reading PlyProperty with a given type, performing data conversion
+// if necessary.
+template <typename ReadTypeT>
+class PlyPropertyReader {
+ public:
+  explicit PlyPropertyReader(const PlyProperty *property)
+      : property_(property) {
+    // Find the suitable function for converting values.
+    switch (property->data_type()) {
+      case DT_UINT8:
+        convert_value_func_ = [=](int val_id) {
+          return this->ConvertValue<uint8_t>(val_id);
+        };
+        break;
+      case DT_INT8:
+        convert_value_func_ = [=](int val_id) {
+          return this->ConvertValue<int8_t>(val_id);
+        };
+        break;
+      case DT_UINT16:
+        convert_value_func_ = [=](int val_id) {
+          return this->ConvertValue<uint16_t>(val_id);
+        };
+        break;
+      case DT_INT16:
+        convert_value_func_ = [=](int val_id) {
+          return this->ConvertValue<int16_t>(val_id);
+        };
+        break;
+      case DT_UINT32:
+        convert_value_func_ = [=](int val_id) {
+          return this->ConvertValue<uint32_t>(val_id);
+        };
+        break;
+      case DT_INT32:
+        convert_value_func_ = [=](int val_id) {
+          return this->ConvertValue<int32_t>(val_id);
+        };
+        break;
+      case DT_FLOAT32:
+        convert_value_func_ = [=](int val_id) {
+          return this->ConvertValue<float>(val_id);
+        };
+        break;
+      case DT_FLOAT64:
+        convert_value_func_ = [=](int val_id) {
+          return this->ConvertValue<double>(val_id);
+        };
+        break;
+      default:
+        break;
+    }
+  }
+
+  ReadTypeT ReadValue(int value_id) const {
+    return convert_value_func_(value_id);
+  }
+
+ private:
+  template <typename SourceTypeT>
+  ReadTypeT ConvertValue(int value_id) const {
+    const void *const address = property_->GetDataEntryAddress(value_id);
+    const SourceTypeT src_val = *reinterpret_cast<const SourceTypeT *>(address);
+    return static_cast<ReadTypeT>(src_val);
+  }
+
+  const PlyProperty *property_;
+  std::function<ReadTypeT(int)> convert_value_func_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_PLY_PROPERTY_READER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/ply_property_writer.h b/Engine/lib/assimp/contrib/draco/src/draco/io/ply_property_writer.h
new file mode 100644
index 000000000..4f243b286
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/ply_property_writer.h
@@ -0,0 +1,94 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_PLY_PROPERTY_WRITER_H_
+#define DRACO_IO_PLY_PROPERTY_WRITER_H_
+
+#include <functional>
+
+#include "draco/io/ply_reader.h"
+
+namespace draco {
+
+// Class for writing PlyProperty with a given type, performing data conversion
+// if necessary.
+template <typename WriteTypeT>
+class PlyPropertyWriter {
+ public:
+  explicit PlyPropertyWriter(PlyProperty *property) : property_(property) {
+    // Find the suitable function for converting values.
+    switch (property->data_type()) {
+      case DT_UINT8:
+        convert_value_func_ = [=](WriteTypeT val) {
+          return this->ConvertValue<uint8_t>(val);
+        };
+        break;
+      case DT_INT8:
+        convert_value_func_ = [=](WriteTypeT val) {
+          return this->ConvertValue<int8_t>(val);
+        };
+        break;
+      case DT_UINT16:
+        convert_value_func_ = [=](WriteTypeT val) {
+          return this->ConvertValue<uint16_t>(val);
+        };
+        break;
+      case DT_INT16:
+        convert_value_func_ = [=](WriteTypeT val) {
+          return this->ConvertValue<int16_t>(val);
+        };
+        break;
+      case DT_UINT32:
+        convert_value_func_ = [=](WriteTypeT val) {
+          return this->ConvertValue<uint32_t>(val);
+        };
+        break;
+      case DT_INT32:
+        convert_value_func_ = [=](WriteTypeT val) {
+          return this->ConvertValue<int32_t>(val);
+        };
+        break;
+      case DT_FLOAT32:
+        convert_value_func_ = [=](WriteTypeT val) {
+          return this->ConvertValue<float>(val);
+        };
+        break;
+      case DT_FLOAT64:
+        convert_value_func_ = [=](WriteTypeT val) {
+          return this->ConvertValue<double>(val);
+        };
+        break;
+      default:
+        break;
+    }
+  }
+
+  void PushBackValue(WriteTypeT value) const {
+    return convert_value_func_(value);
+  }
+
+ private:
+  template <typename SourceTypeT>
+  void ConvertValue(WriteTypeT value) const {
+    const SourceTypeT src_val = static_cast<SourceTypeT>(value);
+    property_->push_back_value(&src_val);
+  }
+
+  PlyProperty *property_;
+  std::function<void(WriteTypeT)> convert_value_func_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_PLY_PROPERTY_WRITER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/ply_reader.cc b/Engine/lib/assimp/contrib/draco/src/draco/io/ply_reader.cc
new file mode 100644
index 000000000..ea7f2689a
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/ply_reader.cc
@@ -0,0 +1,312 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/ply_reader.h"
+
+#include <array>
+#include <regex>
+
+#include "draco/core/status.h"
+#include "draco/io/parser_utils.h"
+#include "draco/io/ply_property_writer.h"
+
+namespace draco {
+
+PlyProperty::PlyProperty(const std::string &name, DataType data_type,
+                         DataType list_type)
+    : name_(name), data_type_(data_type), list_data_type_(list_type) {
+  data_type_num_bytes_ = DataTypeLength(data_type);
+  list_data_type_num_bytes_ = DataTypeLength(list_type);
+}
+
+PlyElement::PlyElement(const std::string &name, int64_t num_entries)
+    : name_(name), num_entries_(num_entries) {}
+
+PlyReader::PlyReader() : format_(kLittleEndian) {}
+
+Status PlyReader::Read(DecoderBuffer *buffer) {
+  std::string value;
+  // The first line needs to by "ply".
+  if (!parser::ParseString(buffer, &value) || value != "ply") {
+    return Status(Status::INVALID_PARAMETER, "Not a valid ply file");
+  }
+  parser::SkipLine(buffer);
+
+  // The second line needs to be the format of the ply file.
+  parser::ParseLine(buffer, &value);
+  std::string format, version;
+  const std::vector<std::string> words = SplitWords(value);
+  if (words.size() >= 3 && words[0] == "format") {
+    format = words[1];
+    version = words[2];
+  } else {
+    return Status(Status::INVALID_PARAMETER, "Missing or wrong format line");
+  }
+  if (version != "1.0") {
+    return Status(Status::UNSUPPORTED_VERSION, "Unsupported PLY version");
+  }
+  if (format == "binary_big_endian") {
+    return Status(Status::UNSUPPORTED_VERSION,
+                  "Unsupported format. Currently we support only ascii and"
+                  " binary_little_endian format.");
+  }
+  if (format == "ascii") {
+    format_ = kAscii;
+  } else {
+    format_ = kLittleEndian;
+  }
+  DRACO_RETURN_IF_ERROR(ParseHeader(buffer));
+  if (!ParsePropertiesData(buffer)) {
+    return Status(Status::INVALID_PARAMETER, "Couldn't parse properties");
+  }
+  return OkStatus();
+}
+
+Status PlyReader::ParseHeader(DecoderBuffer *buffer) {
+  while (true) {
+    DRACO_ASSIGN_OR_RETURN(bool end, ParseEndHeader(buffer));
+    if (end) {
+      break;
+    }
+    if (ParseElement(buffer)) {
+      continue;
+    }
+    DRACO_ASSIGN_OR_RETURN(bool property_parsed, ParseProperty(buffer));
+    if (property_parsed) {
+      continue;
+    }
+    parser::SkipLine(buffer);
+  }
+  return OkStatus();
+}
+
+StatusOr<bool> PlyReader::ParseEndHeader(DecoderBuffer *buffer) {
+  parser::SkipWhitespace(buffer);
+  std::array<char, 10> c;
+  if (!buffer->Peek(&c)) {
+    return Status(Status::INVALID_PARAMETER,
+                  "End of file reached before the end_header");
+  }
+  if (std::memcmp(&c[0], "end_header", 10) != 0) {
+    return false;
+  }
+  parser::SkipLine(buffer);
+  return true;
+}
+
+bool PlyReader::ParseElement(DecoderBuffer *buffer) {
+  DecoderBuffer line_buffer(*buffer);
+  std::string line;
+  parser::ParseLine(&line_buffer, &line);
+
+  std::string element_name;
+  int64_t count;
+  const std::vector<std::string> words = SplitWords(line);
+  if (words.size() >= 3 && words[0] == "element") {
+    element_name = words[1];
+    const std::string count_str = words[2];
+    count = strtoll(count_str.c_str(), nullptr, 10);
+  } else {
+    return false;
+  }
+  element_index_[element_name] = static_cast<uint32_t>(elements_.size());
+  elements_.emplace_back(PlyElement(element_name, count));
+  *buffer = line_buffer;
+  return true;
+}
+
+StatusOr<bool> PlyReader::ParseProperty(DecoderBuffer *buffer) {
+  if (elements_.empty()) {
+    return false;  // Ignore properties if there is no active element.
+  }
+  DecoderBuffer line_buffer(*buffer);
+  std::string line;
+  parser::ParseLine(&line_buffer, &line);
+
+  std::string data_type_str, list_type_str, property_name;
+  bool property_search = false;
+  const std::vector<std::string> words = SplitWords(line);
+  if (words.size() >= 3 && words[0] == "property" && words[1] != "list") {
+    property_search = true;
+    data_type_str = words[1];
+    property_name = words[2];
+  }
+
+  bool property_list_search = false;
+  if (words.size() >= 5 && words[0] == "property" && words[1] == "list") {
+    property_list_search = true;
+    list_type_str = words[2];
+    data_type_str = words[3];
+    property_name = words[4];
+  }
+  if (!property_search && !property_list_search) {
+    return false;
+  }
+  const DataType data_type = GetDataTypeFromString(data_type_str);
+  if (data_type == DT_INVALID) {
+    return Status(Status::INVALID_PARAMETER, "Wrong property data type");
+  }
+  DataType list_type = DT_INVALID;
+  if (property_list_search) {
+    list_type = GetDataTypeFromString(list_type_str);
+    if (list_type == DT_INVALID) {
+      return Status(Status::INVALID_PARAMETER, "Wrong property list type");
+    }
+  }
+  elements_.back().AddProperty(
+      PlyProperty(property_name, data_type, list_type));
+  *buffer = line_buffer;
+  return true;
+}
+
+bool PlyReader::ParsePropertiesData(DecoderBuffer *buffer) {
+  for (int i = 0; i < static_cast<int>(elements_.size()); ++i) {
+    if (format_ == kLittleEndian) {
+      if (!ParseElementData(buffer, i)) {
+        return false;
+      }
+    } else if (format_ == kAscii) {
+      if (!ParseElementDataAscii(buffer, i)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+bool PlyReader::ParseElementData(DecoderBuffer *buffer, int element_index) {
+  PlyElement &element = elements_[element_index];
+  for (int entry = 0; entry < element.num_entries(); ++entry) {
+    for (int i = 0; i < element.num_properties(); ++i) {
+      PlyProperty &prop = element.property(i);
+      if (prop.is_list()) {
+        // Parse the number of entries for the list element.
+        int64_t num_entries = 0;
+        buffer->Decode(&num_entries, prop.list_data_type_num_bytes());
+        // Store offset to the main data entry.
+        prop.list_data_.push_back(prop.data_.size() /
+                                  prop.data_type_num_bytes_);
+        // Store the number of entries.
+        prop.list_data_.push_back(num_entries);
+        // Read and store the actual property data
+        const int64_t num_bytes_to_read =
+            prop.data_type_num_bytes() * num_entries;
+        prop.data_.insert(prop.data_.end(), buffer->data_head(),
+                          buffer->data_head() + num_bytes_to_read);
+        buffer->Advance(num_bytes_to_read);
+      } else {
+        // Non-list property
+        prop.data_.insert(prop.data_.end(), buffer->data_head(),
+                          buffer->data_head() + prop.data_type_num_bytes());
+        buffer->Advance(prop.data_type_num_bytes());
+      }
+    }
+  }
+  return true;
+}
+
+bool PlyReader::ParseElementDataAscii(DecoderBuffer *buffer,
+                                      int element_index) {
+  PlyElement &element = elements_[element_index];
+  for (int entry = 0; entry < element.num_entries(); ++entry) {
+    for (int i = 0; i < element.num_properties(); ++i) {
+      PlyProperty &prop = element.property(i);
+      PlyPropertyWriter<double> prop_writer(&prop);
+      int32_t num_entries = 1;
+      if (prop.is_list()) {
+        parser::SkipWhitespace(buffer);
+        // Parse the number of entries for the list element.
+        if (!parser::ParseSignedInt(buffer, &num_entries)) {
+          return false;
+        }
+
+        // Store offset to the main data entry.
+        prop.list_data_.push_back(prop.data_.size() /
+                                  prop.data_type_num_bytes_);
+        // Store the number of entries.
+        prop.list_data_.push_back(num_entries);
+      }
+      // Read and store the actual property data.
+      for (int v = 0; v < num_entries; ++v) {
+        parser::SkipWhitespace(buffer);
+        if (prop.data_type() == DT_FLOAT32 || prop.data_type() == DT_FLOAT64) {
+          float val;
+          if (!parser::ParseFloat(buffer, &val)) {
+            return false;
+          }
+          prop_writer.PushBackValue(val);
+        } else {
+          int32_t val;
+          if (!parser::ParseSignedInt(buffer, &val)) {
+            return false;
+          }
+          prop_writer.PushBackValue(val);
+        }
+      }
+    }
+  }
+  return true;
+}
+
+std::vector<std::string> PlyReader::SplitWords(const std::string &line) {
+  std::vector<std::string> output;
+  std::string::size_type start = 0;
+  std::string::size_type end = 0;
+
+  // Check for isspace chars.
+  while ((end = line.find_first_of(" \t\n\v\f\r", start)) !=
+         std::string::npos) {
+    const std::string word(line.substr(start, end - start));
+    if (!std::all_of(word.begin(), word.end(), isspace)) {
+      output.push_back(word);
+    }
+    start = end + 1;
+  }
+
+  const std::string last_word(line.substr(start));
+  if (!std::all_of(last_word.begin(), last_word.end(), isspace)) {
+    output.push_back(last_word);
+  }
+  return output;
+}
+
+DataType PlyReader::GetDataTypeFromString(const std::string &name) const {
+  if (name == "char" || name == "int8") {
+    return DT_INT8;
+  }
+  if (name == "uchar" || name == "uint8") {
+    return DT_UINT8;
+  }
+  if (name == "short" || name == "int16") {
+    return DT_INT16;
+  }
+  if (name == "ushort" || name == "uint16") {
+    return DT_UINT16;
+  }
+  if (name == "int" || name == "int32") {
+    return DT_INT32;
+  }
+  if (name == "uint" || name == "uint32") {
+    return DT_UINT32;
+  }
+  if (name == "float" || name == "float32") {
+    return DT_FLOAT32;
+  }
+  if (name == "double" || name == "float64") {
+    return DT_FLOAT64;
+  }
+  return DT_INVALID;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/ply_reader.h b/Engine/lib/assimp/contrib/draco/src/draco/io/ply_reader.h
new file mode 100644
index 000000000..e0f15a313
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/ply_reader.h
@@ -0,0 +1,155 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File contains helper classes used for parsing of PLY files. The classes are
+// used by the PlyDecoder (ply_decoder.h) to read a point cloud or mesh from a
+// source PLY file.
+// TODO(ostava): Currently, we support only binary PLYs encoded in the little
+// endian format ("format binary_little_endian 1.0").
+
+#ifndef DRACO_IO_PLY_READER_H_
+#define DRACO_IO_PLY_READER_H_
+
+#include <map>
+#include <vector>
+
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/draco_types.h"
+#include "draco/core/status.h"
+#include "draco/core/status_or.h"
+
+namespace draco {
+
+// A single PLY property of a given PLY element. For "vertex" element this can
+// contain data such as "x", "y", or "z" coordinate of the vertex, while for
+// "face" element this usually contains corner indices.
+class PlyProperty {
+ public:
+  friend class PlyReader;
+
+  PlyProperty(const std::string &name, DataType data_type, DataType list_type);
+  void ReserveData(int num_entries) {
+    data_.reserve(DataTypeLength(data_type_) * num_entries);
+  }
+
+  int64_t GetListEntryOffset(int entry_id) const {
+    return list_data_[entry_id * 2];
+  }
+  int64_t GetListEntryNumValues(int entry_id) const {
+    return list_data_[entry_id * 2 + 1];
+  }
+  const void *GetDataEntryAddress(int entry_id) const {
+    return data_.data() + entry_id * data_type_num_bytes_;
+  }
+  void push_back_value(const void *data) {
+    data_.insert(data_.end(), static_cast<const uint8_t *>(data),
+                 static_cast<const uint8_t *>(data) + data_type_num_bytes_);
+  }
+
+  const std::string &name() const { return name_; }
+  bool is_list() const { return list_data_type_ != DT_INVALID; }
+  DataType data_type() const { return data_type_; }
+  int data_type_num_bytes() const { return data_type_num_bytes_; }
+  DataType list_data_type() const { return list_data_type_; }
+  int list_data_type_num_bytes() const { return list_data_type_num_bytes_; }
+
+ private:
+  std::string name_;
+  std::vector<uint8_t> data_;
+  // List data contain pairs of <offset, number_of_values>
+  std::vector<int64_t> list_data_;
+  DataType data_type_;
+  int data_type_num_bytes_;
+  DataType list_data_type_;
+  int list_data_type_num_bytes_;
+};
+
+// A single PLY element such as "vertex" or "face". Each element can store
+// arbitrary properties such as vertex coordinates or face indices.
+class PlyElement {
+ public:
+  PlyElement(const std::string &name, int64_t num_entries);
+  void AddProperty(const PlyProperty &prop) {
+    property_index_[prop.name()] = static_cast<int>(properties_.size());
+    properties_.emplace_back(prop);
+    if (!properties_.back().is_list()) {
+      properties_.back().ReserveData(static_cast<int>(num_entries_));
+    }
+  }
+
+  const PlyProperty *GetPropertyByName(const std::string &name) const {
+    const auto it = property_index_.find(name);
+    if (it != property_index_.end()) {
+      return &properties_[it->second];
+    }
+    return nullptr;
+  }
+
+  int num_properties() const { return static_cast<int>(properties_.size()); }
+  int num_entries() const { return static_cast<int>(num_entries_); }
+  const PlyProperty &property(int prop_index) const {
+    return properties_[prop_index];
+  }
+  PlyProperty &property(int prop_index) { return properties_[prop_index]; }
+
+ private:
+  std::string name_;
+  int64_t num_entries_;
+  std::vector<PlyProperty> properties_;
+  std::map<std::string, int> property_index_;
+};
+
+// Class responsible for parsing PLY data. It produces a list of PLY elements
+// and their properties that can be used to construct a mesh or a point cloud.
+class PlyReader {
+ public:
+  PlyReader();
+  Status Read(DecoderBuffer *buffer);
+
+  const PlyElement *GetElementByName(const std::string &name) const {
+    const auto it = element_index_.find(name);
+    if (it != element_index_.end()) {
+      return &elements_[it->second];
+    }
+    return nullptr;
+  }
+
+  int num_elements() const { return static_cast<int>(elements_.size()); }
+  const PlyElement &element(int element_index) const {
+    return elements_[element_index];
+  }
+
+ private:
+  enum Format { kLittleEndian = 0, kAscii };
+
+  Status ParseHeader(DecoderBuffer *buffer);
+  StatusOr<bool> ParseEndHeader(DecoderBuffer *buffer);
+  bool ParseElement(DecoderBuffer *buffer);
+  StatusOr<bool> ParseProperty(DecoderBuffer *buffer);
+  bool ParsePropertiesData(DecoderBuffer *buffer);
+  bool ParseElementData(DecoderBuffer *buffer, int element_index);
+  bool ParseElementDataAscii(DecoderBuffer *buffer, int element_index);
+
+  // Splits |line| by whitespace characters.
+  std::vector<std::string> SplitWords(const std::string &line);
+  DataType GetDataTypeFromString(const std::string &name) const;
+
+  std::vector<PlyElement> elements_;
+  std::map<std::string, int> element_index_;
+  Format format_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_PLY_READER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/ply_reader_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/io/ply_reader_test.cc
new file mode 100644
index 000000000..05ff63dd4
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/ply_reader_test.cc
@@ -0,0 +1,143 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/ply_reader.h"
+
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+#include "draco/io/file_utils.h"
+#include "draco/io/ply_property_reader.h"
+
+namespace draco {
+
+class PlyReaderTest : public ::testing::Test {
+ protected:
+  std::vector<char> ReadPlyFile(const std::string &file_name) const {
+    const std::string path = GetTestFileFullPath(file_name);
+
+    std::vector<char> data;
+    EXPECT_TRUE(ReadFileToBuffer(path, &data));
+    return data;
+  }
+};
+
+TEST_F(PlyReaderTest, TestReader) {
+  const std::string file_name = "test_pos_color.ply";
+  const std::vector<char> data = ReadPlyFile(file_name);
+  DecoderBuffer buf;
+  buf.Init(data.data(), data.size());
+  PlyReader reader;
+  Status status = reader.Read(&buf);
+  ASSERT_TRUE(status.ok()) << status;
+  ASSERT_EQ(reader.num_elements(), 2);
+  ASSERT_EQ(reader.element(0).num_properties(), 7);
+  ASSERT_EQ(reader.element(1).num_properties(), 1);
+  ASSERT_TRUE(reader.element(1).property(0).is_list());
+
+  ASSERT_TRUE(reader.element(0).GetPropertyByName("red") != nullptr);
+  const PlyProperty *const prop = reader.element(0).GetPropertyByName("red");
+  PlyPropertyReader<uint8_t> reader_uint8(prop);
+  PlyPropertyReader<uint32_t> reader_uint32(prop);
+  PlyPropertyReader<float> reader_float(prop);
+  for (int i = 0; i < reader.element(0).num_entries(); ++i) {
+    ASSERT_EQ(reader_uint8.ReadValue(i), reader_uint32.ReadValue(i));
+    ASSERT_EQ(reader_uint8.ReadValue(i), reader_float.ReadValue(i));
+  }
+}
+
+TEST_F(PlyReaderTest, TestReaderAscii) {
+  const std::string file_name = "test_pos_color.ply";
+  const std::vector<char> data = ReadPlyFile(file_name);
+  ASSERT_NE(data.size(), 0u);
+  DecoderBuffer buf;
+  buf.Init(data.data(), data.size());
+  PlyReader reader;
+  Status status = reader.Read(&buf);
+  ASSERT_TRUE(status.ok()) << status;
+
+  const std::string file_name_ascii = "test_pos_color_ascii.ply";
+  const std::vector<char> data_ascii = ReadPlyFile(file_name_ascii);
+  buf.Init(data_ascii.data(), data_ascii.size());
+  PlyReader reader_ascii;
+  status = reader_ascii.Read(&buf);
+  ASSERT_TRUE(status.ok()) << status;
+  ASSERT_EQ(reader.num_elements(), reader_ascii.num_elements());
+  ASSERT_EQ(reader.element(0).num_properties(),
+            reader_ascii.element(0).num_properties());
+
+  ASSERT_TRUE(reader.element(0).GetPropertyByName("x") != nullptr);
+  const PlyProperty *const prop = reader.element(0).GetPropertyByName("x");
+  const PlyProperty *const prop_ascii =
+      reader_ascii.element(0).GetPropertyByName("x");
+  PlyPropertyReader<float> reader_float(prop);
+  PlyPropertyReader<float> reader_float_ascii(prop_ascii);
+  for (int i = 0; i < reader.element(0).num_entries(); ++i) {
+    ASSERT_NEAR(reader_float.ReadValue(i), reader_float_ascii.ReadValue(i),
+                1e-4f);
+  }
+}
+
+TEST_F(PlyReaderTest, TestReaderExtraWhitespace) {
+  const std::string file_name = "test_extra_whitespace.ply";
+  const std::vector<char> data = ReadPlyFile(file_name);
+  ASSERT_NE(data.size(), 0u);
+  DecoderBuffer buf;
+  buf.Init(data.data(), data.size());
+  PlyReader reader;
+  Status status = reader.Read(&buf);
+  ASSERT_TRUE(status.ok()) << status;
+
+  ASSERT_EQ(reader.num_elements(), 2);
+  ASSERT_EQ(reader.element(0).num_properties(), 7);
+  ASSERT_EQ(reader.element(1).num_properties(), 1);
+  ASSERT_TRUE(reader.element(1).property(0).is_list());
+
+  ASSERT_TRUE(reader.element(0).GetPropertyByName("red") != nullptr);
+  const PlyProperty *const prop = reader.element(0).GetPropertyByName("red");
+  PlyPropertyReader<uint8_t> reader_uint8(prop);
+  PlyPropertyReader<uint32_t> reader_uint32(prop);
+  PlyPropertyReader<float> reader_float(prop);
+  for (int i = 0; i < reader.element(0).num_entries(); ++i) {
+    ASSERT_EQ(reader_uint8.ReadValue(i), reader_uint32.ReadValue(i));
+    ASSERT_EQ(reader_uint8.ReadValue(i), reader_float.ReadValue(i));
+  }
+}
+
+TEST_F(PlyReaderTest, TestReaderMoreDataTypes) {
+  const std::string file_name = "test_more_datatypes.ply";
+  const std::vector<char> data = ReadPlyFile(file_name);
+  ASSERT_NE(data.size(), 0u);
+  DecoderBuffer buf;
+  buf.Init(data.data(), data.size());
+  PlyReader reader;
+  Status status = reader.Read(&buf);
+  ASSERT_TRUE(status.ok()) << status;
+
+  ASSERT_EQ(reader.num_elements(), 2);
+  ASSERT_EQ(reader.element(0).num_properties(), 7);
+  ASSERT_EQ(reader.element(1).num_properties(), 1);
+  ASSERT_TRUE(reader.element(1).property(0).is_list());
+
+  ASSERT_TRUE(reader.element(0).GetPropertyByName("red") != nullptr);
+  const PlyProperty *const prop = reader.element(0).GetPropertyByName("red");
+  PlyPropertyReader<uint8_t> reader_uint8(prop);
+  PlyPropertyReader<uint32_t> reader_uint32(prop);
+  PlyPropertyReader<float> reader_float(prop);
+  for (int i = 0; i < reader.element(0).num_entries(); ++i) {
+    ASSERT_EQ(reader_uint8.ReadValue(i), reader_uint32.ReadValue(i));
+    ASSERT_EQ(reader_uint8.ReadValue(i), reader_float.ReadValue(i));
+  }
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/point_cloud_io.cc b/Engine/lib/assimp/contrib/draco/src/draco/io/point_cloud_io.cc
new file mode 100644
index 000000000..643820bde
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/point_cloud_io.cc
@@ -0,0 +1,58 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/point_cloud_io.h"
+
+#include "draco/io/file_utils.h"
+#include "draco/io/obj_decoder.h"
+#include "draco/io/parser_utils.h"
+#include "draco/io/ply_decoder.h"
+
+namespace draco {
+
+StatusOr<std::unique_ptr<PointCloud>> ReadPointCloudFromFile(
+    const std::string &file_name) {
+  std::unique_ptr<PointCloud> pc(new PointCloud());
+  // Analyze file extension.
+  const std::string extension = parser::ToLower(
+      file_name.size() >= 4 ? file_name.substr(file_name.size() - 4)
+                            : file_name);
+  if (extension == ".obj") {
+    // Wavefront OBJ file format.
+    ObjDecoder obj_decoder;
+    const Status obj_status = obj_decoder.DecodeFromFile(file_name, pc.get());
+    if (!obj_status.ok()) {
+      return obj_status;
+    }
+    return std::move(pc);
+  }
+  if (extension == ".ply") {
+    // Wavefront PLY file format.
+    PlyDecoder ply_decoder;
+    DRACO_RETURN_IF_ERROR(ply_decoder.DecodeFromFile(file_name, pc.get()));
+    return std::move(pc);
+  }
+
+  std::vector<char> buffer;
+  if (!ReadFileToBuffer(file_name, &buffer)) {
+    return Status(Status::DRACO_ERROR, "Unable to read input file.");
+  }
+  DecoderBuffer decoder_buffer;
+  decoder_buffer.Init(buffer.data(), buffer.size());
+  Decoder decoder;
+  auto status_or = decoder.DecodePointCloudFromBuffer(&decoder_buffer);
+  return std::move(status_or).value();
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/point_cloud_io.h b/Engine/lib/assimp/contrib/draco/src/draco/io/point_cloud_io.h
new file mode 100644
index 000000000..4e1eb3596
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/point_cloud_io.h
@@ -0,0 +1,89 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_POINT_CLOUD_IO_H_
+#define DRACO_IO_POINT_CLOUD_IO_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/decode.h"
+#include "draco/compression/expert_encode.h"
+
+namespace draco {
+
+template <typename OutStreamT>
+OutStreamT WritePointCloudIntoStream(const PointCloud *pc, OutStreamT &&os,
+                                     PointCloudEncodingMethod method,
+                                     const EncoderOptions &options) {
+  EncoderBuffer buffer;
+  EncoderOptions local_options = options;
+  ExpertEncoder encoder(*pc);
+  encoder.Reset(local_options);
+  encoder.SetEncodingMethod(method);
+  if (!encoder.EncodeToBuffer(&buffer).ok()) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+
+  os.write(static_cast<const char *>(buffer.data()), buffer.size());
+
+  return os;
+}
+
+template <typename OutStreamT>
+OutStreamT WritePointCloudIntoStream(const PointCloud *pc, OutStreamT &&os,
+                                     PointCloudEncodingMethod method) {
+  const EncoderOptions options = EncoderOptions::CreateDefaultOptions();
+  return WritePointCloudIntoStream(pc, os, method, options);
+}
+
+template <typename OutStreamT>
+OutStreamT &WritePointCloudIntoStream(const PointCloud *pc, OutStreamT &&os) {
+  return WritePointCloudIntoStream(pc, os, POINT_CLOUD_SEQUENTIAL_ENCODING);
+}
+
+template <typename InStreamT>
+InStreamT &ReadPointCloudFromStream(std::unique_ptr<PointCloud> *point_cloud,
+                                    InStreamT &&is) {
+  // Determine size of stream and write into a vector
+  const auto start_pos = is.tellg();
+  is.seekg(0, std::ios::end);
+  const std::streampos is_size = is.tellg() - start_pos;
+  is.seekg(start_pos);
+  std::vector<char> data(is_size);
+  is.read(&data[0], is_size);
+
+  // Create a point cloud from that data.
+  DecoderBuffer buffer;
+  buffer.Init(&data[0], data.size());
+  Decoder decoder;
+  auto statusor = decoder.DecodePointCloudFromBuffer(&buffer);
+  *point_cloud = std::move(statusor).value();
+  if (!statusor.ok() || *point_cloud == nullptr) {
+    is.setstate(std::ios_base::badbit);
+  }
+
+  return is;
+}
+
+// Reads a point cloud from a file. The function automatically chooses the
+// correct decoder based on the extension of the files. Currently, .obj and .ply
+// files are supported. Other file extensions are processed by the default
+// draco::PointCloudDecoder.
+// Returns nullptr with an error status if the decoding failed.
+StatusOr<std::unique_ptr<PointCloud>> ReadPointCloudFromFile(
+    const std::string &file_name);
+
+}  // namespace draco
+
+#endif  // DRACO_IO_POINT_CLOUD_IO_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/point_cloud_io_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/io/point_cloud_io_test.cc
new file mode 100644
index 000000000..73674d06f
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/point_cloud_io_test.cc
@@ -0,0 +1,115 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/point_cloud_io.h"
+
+#include <sstream>
+
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+#include "draco/io/obj_decoder.h"
+
+namespace draco {
+
+class IoPointCloudIoTest : public ::testing::Test {
+ protected:
+  void test_compression_method(PointCloudEncodingMethod method,
+                               int expected_num_attributes,
+                               const std::string &file_name) {
+    const std::unique_ptr<PointCloud> encoded_pc =
+        ReadPointCloudFromTestFile(file_name);
+    ASSERT_NE(encoded_pc, nullptr) << "Failed to load test model " << file_name;
+    ASSERT_GE(encoded_pc->num_attributes(), expected_num_attributes)
+        << "Failed to load test model: " << file_name
+        << " wrong number of attributes" << std::endl;
+
+    // Set quantization.
+    EncoderOptions options = EncoderOptions::CreateDefaultOptions();
+    for (int i = 0; i <= GeometryAttribute::NAMED_ATTRIBUTES_COUNT; i++) {
+      options.SetAttributeInt(GeometryAttribute::Type(i), "quantization_bits",
+                              14);
+    }
+
+    std::stringstream ss;
+    WritePointCloudIntoStream(encoded_pc.get(), ss, method, options);
+    ASSERT_TRUE(ss.good());
+
+    std::unique_ptr<PointCloud> decoded_pc;
+    ReadPointCloudFromStream(&decoded_pc, ss);
+    ASSERT_TRUE(ss.good());
+
+    for (int i = 0; i <= GeometryAttribute::NAMED_ATTRIBUTES_COUNT; i++) {
+      ASSERT_EQ(encoded_pc->NumNamedAttributes(GeometryAttribute::Type(i)),
+                decoded_pc->NumNamedAttributes(GeometryAttribute::Type(i)));
+    }
+
+    ASSERT_EQ(encoded_pc->num_points(), decoded_pc->num_points());
+  }
+};
+
+TEST_F(IoPointCloudIoTest, EncodeSequentialPointCloudTestNmObj) {
+  test_compression_method(POINT_CLOUD_SEQUENTIAL_ENCODING, 2, "test_nm.obj");
+}
+TEST_F(IoPointCloudIoTest, EncodeSequentialPointCloudTestPosObj) {
+  test_compression_method(POINT_CLOUD_SEQUENTIAL_ENCODING, 1,
+                          "point_cloud_test_pos.obj");
+}
+TEST_F(IoPointCloudIoTest, EncodeSequentialPointCloudTestPosPly) {
+  test_compression_method(POINT_CLOUD_SEQUENTIAL_ENCODING, 1,
+                          "point_cloud_test_pos.ply");
+}
+TEST_F(IoPointCloudIoTest, EncodeSequentialPointCloudTestPosNormObj) {
+  test_compression_method(POINT_CLOUD_SEQUENTIAL_ENCODING, 2,
+                          "point_cloud_test_pos_norm.obj");
+}
+TEST_F(IoPointCloudIoTest, EncodeSequentialPointCloudTestPosNormPly) {
+  test_compression_method(POINT_CLOUD_SEQUENTIAL_ENCODING, 2,
+                          "point_cloud_test_pos_norm.ply");
+}
+
+TEST_F(IoPointCloudIoTest, EncodeKdTreePointCloudTestPosObj) {
+  test_compression_method(POINT_CLOUD_KD_TREE_ENCODING, 1,
+                          "point_cloud_test_pos.obj");
+}
+TEST_F(IoPointCloudIoTest, EncodeKdTreePointCloudTestPosPly) {
+  test_compression_method(POINT_CLOUD_KD_TREE_ENCODING, 1,
+                          "point_cloud_test_pos.ply");
+}
+
+TEST_F(IoPointCloudIoTest, ObjFileInput) {
+  // Tests whether loading obj point clouds from files works as expected.
+  const std::unique_ptr<PointCloud> pc =
+      ReadPointCloudFromTestFile("test_nm.obj");
+  ASSERT_NE(pc, nullptr) << "Failed to load the obj point cloud.";
+  EXPECT_EQ(pc->num_points(), 97) << "Obj point cloud not loaded properly.";
+}
+
+// Test if we handle wrong input for all file extensions.
+TEST_F(IoPointCloudIoTest, WrongFileObj) {
+  const std::unique_ptr<PointCloud> pc =
+      ReadPointCloudFromTestFile("wrong_file_name.obj");
+  ASSERT_EQ(pc, nullptr);
+}
+TEST_F(IoPointCloudIoTest, WrongFilePly) {
+  const std::unique_ptr<PointCloud> pc =
+      ReadPointCloudFromTestFile("wrong_file_name.ply");
+  ASSERT_EQ(pc, nullptr);
+}
+TEST_F(IoPointCloudIoTest, WrongFile) {
+  const std::unique_ptr<PointCloud> pc =
+      ReadPointCloudFromTestFile("wrong_file_name");
+  ASSERT_EQ(pc, nullptr);
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/stdio_file_reader.cc b/Engine/lib/assimp/contrib/draco/src/draco/io/stdio_file_reader.cc
new file mode 100644
index 000000000..a99c96f8f
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/stdio_file_reader.cc
@@ -0,0 +1,103 @@
+#include "draco/io/stdio_file_reader.h"
+
+#include <algorithm>
+#include <cstdint>
+#include <cstdio>
+#include <string>
+#include <vector>
+
+#if defined(_WIN32)
+#include <fcntl.h>
+#include <io.h>
+#endif
+
+#include "draco/io/file_reader_factory.h"
+
+namespace draco {
+
+#define FILEREADER_LOG_ERROR(error_string)                             \
+  do {                                                                 \
+    fprintf(stderr, "%s:%d (%s): %s.\n", __FILE__, __LINE__, __func__, \
+            error_string);                                             \
+  } while (false)
+
+bool StdioFileReader::registered_in_factory_ =
+    FileReaderFactory::RegisterReader(StdioFileReader::Open);
+
+StdioFileReader::~StdioFileReader() { fclose(file_); }
+
+std::unique_ptr<FileReaderInterface> StdioFileReader::Open(
+    const std::string &file_name) {
+  if (file_name.empty()) {
+    return nullptr;
+  }
+
+  FILE *raw_file_ptr = fopen(file_name.c_str(), "rb");
+
+  if (raw_file_ptr == nullptr) {
+    return nullptr;
+  }
+
+  std::unique_ptr<FileReaderInterface> file(new (std::nothrow)
+                                                StdioFileReader(raw_file_ptr));
+  if (file == nullptr) {
+    FILEREADER_LOG_ERROR("Out of memory");
+    fclose(raw_file_ptr);
+    return nullptr;
+  }
+
+  return file;
+}
+
+bool StdioFileReader::ReadFileToBuffer(std::vector<char> *buffer) {
+  if (buffer == nullptr) {
+    return false;
+  }
+  buffer->clear();
+
+  const size_t file_size = GetFileSize();
+  if (file_size == 0) {
+    FILEREADER_LOG_ERROR("Unable to obtain file size or file empty");
+    return false;
+  }
+
+  buffer->resize(file_size);
+  return fread(buffer->data(), 1, file_size, file_) == file_size;
+}
+
+bool StdioFileReader::ReadFileToBuffer(std::vector<uint8_t> *buffer) {
+  if (buffer == nullptr) {
+    return false;
+  }
+  buffer->clear();
+
+  const size_t file_size = GetFileSize();
+  if (file_size == 0) {
+    FILEREADER_LOG_ERROR("Unable to obtain file size or file empty");
+    return false;
+  }
+
+  buffer->resize(file_size);
+  return fread(buffer->data(), 1, file_size, file_) == file_size;
+}
+
+size_t StdioFileReader::GetFileSize() {
+  if (fseek(file_, SEEK_SET, SEEK_END) != 0) {
+    FILEREADER_LOG_ERROR("Seek to EoF failed");
+    return false;
+  }
+
+#if _FILE_OFFSET_BITS == 64
+  const size_t file_size = static_cast<size_t>(ftello(file_));
+#elif defined _WIN64
+  const size_t file_size = static_cast<size_t>(_ftelli64(file_));
+#else
+  const size_t file_size = static_cast<size_t>(ftell(file_));
+#endif
+
+  rewind(file_);
+
+  return file_size;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/stdio_file_reader.h b/Engine/lib/assimp/contrib/draco/src/draco/io/stdio_file_reader.h
new file mode 100644
index 000000000..f822c891c
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/stdio_file_reader.h
@@ -0,0 +1,48 @@
+#ifndef DRACO_IO_STDIO_FILE_READER_H_
+#define DRACO_IO_STDIO_FILE_READER_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "draco/io/file_reader_interface.h"
+
+namespace draco {
+
+class StdioFileReader : public FileReaderInterface {
+ public:
+  // Creates and returns a StdioFileReader that reads from |file_name|.
+  // Returns nullptr when the file does not exist or cannot be read.
+  static std::unique_ptr<FileReaderInterface> Open(
+      const std::string &file_name);
+
+  StdioFileReader() = delete;
+  StdioFileReader(const StdioFileReader &) = delete;
+  StdioFileReader &operator=(const StdioFileReader &) = delete;
+
+  StdioFileReader(StdioFileReader &&) = default;
+  StdioFileReader &operator=(StdioFileReader &&) = default;
+
+  // Closes |file_|.
+  ~StdioFileReader() override;
+
+  // Reads the entire contents of the input file into |buffer| and returns true.
+  bool ReadFileToBuffer(std::vector<char> *buffer) override;
+  bool ReadFileToBuffer(std::vector<uint8_t> *buffer) override;
+
+  // Returns the size of the file.
+  size_t GetFileSize() override;
+
+ private:
+  StdioFileReader(FILE *file) : file_(file) {}
+
+  FILE *file_ = nullptr;
+  static bool registered_in_factory_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_STDIO_FILE_READER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/stdio_file_reader_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/io/stdio_file_reader_test.cc
new file mode 100644
index 000000000..487819a02
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/stdio_file_reader_test.cc
@@ -0,0 +1,49 @@
+#include "draco/io/stdio_file_reader.h"
+
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+#include "draco/io/file_reader_test_common.h"
+
+namespace draco {
+namespace {
+
+TEST(StdioFileReaderTest, FailOpen) {
+  EXPECT_EQ(StdioFileReader::Open(""), nullptr);
+  EXPECT_EQ(StdioFileReader::Open("fake file"), nullptr);
+}
+
+TEST(StdioFileReaderTest, Open) {
+  EXPECT_NE(StdioFileReader::Open(GetTestFileFullPath("car.drc")), nullptr);
+  EXPECT_NE(StdioFileReader::Open(GetTestFileFullPath("cube_pc.drc")), nullptr);
+}
+
+TEST(StdioFileReaderTest, FailRead) {
+  auto reader = StdioFileReader::Open(GetTestFileFullPath("car.drc"));
+  ASSERT_NE(reader, nullptr);
+  std::vector<char> *buffer = nullptr;
+  EXPECT_FALSE(reader->ReadFileToBuffer(buffer));
+}
+
+TEST(StdioFileReaderTest, ReadFile) {
+  std::vector<char> buffer;
+
+  auto reader = StdioFileReader::Open(GetTestFileFullPath("car.drc"));
+  ASSERT_NE(reader, nullptr);
+  EXPECT_TRUE(reader->ReadFileToBuffer(&buffer));
+  EXPECT_EQ(buffer.size(), kFileSizeCarDrc);
+
+  reader = StdioFileReader::Open(GetTestFileFullPath("cube_pc.drc"));
+  ASSERT_NE(reader, nullptr);
+  EXPECT_TRUE(reader->ReadFileToBuffer(&buffer));
+  EXPECT_EQ(buffer.size(), kFileSizeCubePcDrc);
+}
+
+TEST(StdioFileReaderTest, GetFileSize) {
+  auto reader = StdioFileReader::Open(GetTestFileFullPath("car.drc"));
+  ASSERT_EQ(reader->GetFileSize(), kFileSizeCarDrc);
+  reader = StdioFileReader::Open(GetTestFileFullPath("cube_pc.drc"));
+  ASSERT_EQ(reader->GetFileSize(), kFileSizeCubePcDrc);
+}
+
+}  // namespace
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/stdio_file_writer.cc b/Engine/lib/assimp/contrib/draco/src/draco/io/stdio_file_writer.cc
new file mode 100644
index 000000000..2467d070b
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/stdio_file_writer.cc
@@ -0,0 +1,59 @@
+#include "draco/io/stdio_file_writer.h"
+
+#include <algorithm>
+#include <cstdint>
+#include <cstdio>
+#include <memory>
+#include <string>
+
+#include "draco/draco_features.h"
+#include "draco/io/file_writer_factory.h"
+#include "draco/io/file_writer_utils.h"
+
+namespace draco {
+
+#define FILEWRITER_LOG_ERROR(error_string)                             \
+  do {                                                                 \
+    fprintf(stderr, "%s:%d (%s): %s.\n", __FILE__, __LINE__, __func__, \
+            error_string);                                             \
+  } while (false)
+
+bool StdioFileWriter::registered_in_factory_ =
+    FileWriterFactory::RegisterWriter(StdioFileWriter::Open);
+
+StdioFileWriter::~StdioFileWriter() { fclose(file_); }
+
+std::unique_ptr<FileWriterInterface> StdioFileWriter::Open(
+    const std::string &file_name) {
+  if (file_name.empty()) {
+    return nullptr;
+  }
+  if (!CheckAndCreatePathForFile(file_name)) {
+    return nullptr;
+  }
+
+  FILE *raw_file_ptr = fopen(file_name.c_str(), "wb");
+  if (raw_file_ptr == nullptr) {
+    return nullptr;
+  }
+
+  std::unique_ptr<StdioFileWriter> file(new (std::nothrow)
+                                            StdioFileWriter(raw_file_ptr));
+  if (file == nullptr) {
+    FILEWRITER_LOG_ERROR("Out of memory");
+    fclose(raw_file_ptr);
+    return nullptr;
+  }
+
+#ifndef DRACO_OLD_GCC
+  return file;
+#else
+  return std::move(file);
+#endif
+}
+
+bool StdioFileWriter::Write(const char *buffer, size_t size) {
+  return fwrite(buffer, 1, size, file_) == size;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/stdio_file_writer.h b/Engine/lib/assimp/contrib/draco/src/draco/io/stdio_file_writer.h
new file mode 100644
index 000000000..4e3925562
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/stdio_file_writer.h
@@ -0,0 +1,42 @@
+#ifndef DRACO_IO_STDIO_FILE_WRITER_H_
+#define DRACO_IO_STDIO_FILE_WRITER_H_
+
+#include <cstddef>
+#include <cstdio>
+#include <memory>
+#include <string>
+
+#include "draco/io/file_writer_interface.h"
+
+namespace draco {
+
+class StdioFileWriter : public FileWriterInterface {
+ public:
+  // Creates and returns a StdioFileWriter that writes to |file_name|.
+  // Returns nullptr when |file_name| cannot be opened for writing.
+  static std::unique_ptr<FileWriterInterface> Open(
+      const std::string &file_name);
+
+  StdioFileWriter() = delete;
+  StdioFileWriter(const StdioFileWriter &) = delete;
+  StdioFileWriter &operator=(const StdioFileWriter &) = delete;
+
+  StdioFileWriter(StdioFileWriter &&) = default;
+  StdioFileWriter &operator=(StdioFileWriter &&) = default;
+
+  // Closes |file_|.
+  ~StdioFileWriter() override;
+
+  // Writes |size| bytes to |file_| from |buffer|. Returns true for success.
+  bool Write(const char *buffer, size_t size) override;
+
+ private:
+  StdioFileWriter(FILE *file) : file_(file) {}
+
+  FILE *file_ = nullptr;
+  static bool registered_in_factory_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_STDIO_FILE_WRITER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/io/stdio_file_writer_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/io/stdio_file_writer_test.cc
new file mode 100644
index 000000000..ed607d1d0
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/io/stdio_file_writer_test.cc
@@ -0,0 +1,38 @@
+#include "draco/io/stdio_file_writer.h"
+
+#include <cstdio>
+#include <cstring>
+
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+
+namespace draco {
+namespace {
+
+void CheckFileWriter(const std::string &data, const std::string &filename) {
+  auto writer = StdioFileWriter::Open(filename);
+  ASSERT_NE(writer, nullptr);
+  ASSERT_TRUE(writer->Write(data.data(), data.size()));
+  writer.reset();
+  std::unique_ptr<FILE, decltype(&fclose)> file(fopen(filename.c_str(), "r"),
+                                                fclose);
+  ASSERT_NE(file, nullptr);
+  std::string read_buffer(data.size(), ' ');
+  ASSERT_EQ(fread(reinterpret_cast<void *>(&read_buffer[0]), 1, data.size(),
+                  file.get()),
+            data.size());
+  ASSERT_EQ(read_buffer, data);
+}
+
+TEST(StdioFileWriterTest, FailOpen) {
+  EXPECT_EQ(StdioFileWriter::Open(""), nullptr);
+}
+
+TEST(StdioFileWriterTest, BasicWrite) {
+  const std::string kWriteString = "Hello";
+  const std::string kTempFilePath = GetTestTempFileFullPath("hello");
+  CheckFileWriter(kWriteString, kTempFilePath);
+}
+
+}  // namespace
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/animation_decoder_webidl_wrapper.cc b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/animation_decoder_webidl_wrapper.cc
new file mode 100644
index 000000000..7e9e6d15d
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/animation_decoder_webidl_wrapper.cc
@@ -0,0 +1,101 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/javascript/emscripten/animation_decoder_webidl_wrapper.h"
+
+#include <vector>
+
+#include "draco/compression/decode.h"
+#include "draco/mesh/mesh.h"
+#include "draco/mesh/mesh_stripifier.h"
+
+using draco::DecoderBuffer;
+using draco::PointAttribute;
+using draco::Status;
+
+DracoFloat32Array::DracoFloat32Array() {}
+
+float DracoFloat32Array::GetValue(int index) const { return values_[index]; }
+
+bool DracoFloat32Array::SetValues(const float *values, int count) {
+  if (values) {
+    values_.assign(values, values + count);
+  } else {
+    values_.resize(count);
+  }
+  return true;
+}
+
+AnimationDecoder::AnimationDecoder() {}
+
+// Decodes animation data from the provided buffer.
+const draco::Status *AnimationDecoder::DecodeBufferToKeyframeAnimation(
+    draco::DecoderBuffer *in_buffer, draco::KeyframeAnimation *animation) {
+  draco::DecoderOptions dec_options;
+  last_status_ = decoder_.Decode(dec_options, in_buffer, animation);
+  return &last_status_;
+}
+
+bool AnimationDecoder::GetTimestamps(const draco::KeyframeAnimation &animation,
+                                     DracoFloat32Array *timestamp) {
+  if (!timestamp) {
+    return false;
+  }
+  const int num_frames = animation.num_frames();
+  const draco::PointAttribute *timestamp_att = animation.timestamps();
+  // Timestamp attribute has only 1 component, so the number of components is
+  // equal to the number of frames.
+  timestamp->SetValues(nullptr, num_frames);
+  int entry_id = 0;
+  float timestamp_value = -1.0;
+  for (draco::PointIndex i(0); i < num_frames; ++i) {
+    const draco::AttributeValueIndex val_index = timestamp_att->mapped_index(i);
+    if (!timestamp_att->ConvertValue<float>(val_index, &timestamp_value)) {
+      return false;
+    }
+    timestamp->SetValue(entry_id++, timestamp_value);
+  }
+  return true;
+}
+
+bool AnimationDecoder::GetKeyframes(const draco::KeyframeAnimation &animation,
+                                    int keyframes_id,
+                                    DracoFloat32Array *animation_data) {
+  const int num_frames = animation.num_frames();
+  // Get animation data.
+  const draco::PointAttribute *animation_data_att =
+      animation.keyframes(keyframes_id);
+  if (!animation_data_att) {
+    return false;
+  }
+
+  const int components = animation_data_att->num_components();
+  const int num_entries = num_frames * components;
+  const int kMaxAttributeFloatValues = 4;
+
+  std::vector<float> values(components, -1.0);
+  int entry_id = 0;
+  animation_data->SetValues(nullptr, num_entries);
+  for (draco::PointIndex i(0); i < num_frames; ++i) {
+    const draco::AttributeValueIndex val_index =
+        animation_data_att->mapped_index(i);
+    if (!animation_data_att->ConvertValue<float>(val_index, &values[0])) {
+      return false;
+    }
+    for (int j = 0; j < components; ++j) {
+      animation_data->SetValue(entry_id++, values[j]);
+    }
+  }
+  return true;
+}
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/animation_decoder_webidl_wrapper.h b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/animation_decoder_webidl_wrapper.h
new file mode 100644
index 000000000..7486d1503
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/animation_decoder_webidl_wrapper.h
@@ -0,0 +1,73 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_JAVASCRIPT_EMSCRIPTEN_ANIMATION_DECODER_WEBIDL_WRAPPER_H_
+#define DRACO_JAVASCRIPT_EMSCRIPTEN_ANIMATION_DECODER_WEBIDL_WRAPPER_H_
+
+#include <vector>
+
+#include "draco/animation/keyframe_animation_decoder.h"
+#include "draco/attributes/attribute_transform_type.h"
+#include "draco/attributes/point_attribute.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/decode.h"
+#include "draco/core/decoder_buffer.h"
+
+typedef draco::AttributeTransformType draco_AttributeTransformType;
+typedef draco::GeometryAttribute draco_GeometryAttribute;
+typedef draco_GeometryAttribute::Type draco_GeometryAttribute_Type;
+typedef draco::EncodedGeometryType draco_EncodedGeometryType;
+typedef draco::Status draco_Status;
+typedef draco::Status::Code draco_StatusCode;
+
+class DracoFloat32Array {
+ public:
+  DracoFloat32Array();
+  float GetValue(int index) const;
+
+  // In case |values| is nullptr, the data is allocated but not initialized.
+  bool SetValues(const float *values, int count);
+
+  // Directly sets a value for a specific index. The array has to be already
+  // allocated at this point (using SetValues() method).
+  void SetValue(int index, float val) { values_[index] = val; }
+
+  int size() const { return values_.size(); }
+
+ private:
+  std::vector<float> values_;
+};
+
+// Class used by emscripten WebIDL Binder [1] to wrap calls to decode animation
+// data.
+class AnimationDecoder {
+ public:
+  AnimationDecoder();
+
+  // Decodes animation data from the provided buffer.
+  const draco::Status *DecodeBufferToKeyframeAnimation(
+      draco::DecoderBuffer *in_buffer, draco::KeyframeAnimation *animation);
+
+  static bool GetTimestamps(const draco::KeyframeAnimation &animation,
+                            DracoFloat32Array *timestamp);
+
+  static bool GetKeyframes(const draco::KeyframeAnimation &animation,
+                           int keyframes_id, DracoFloat32Array *animation_data);
+
+ private:
+  draco::KeyframeAnimationDecoder decoder_;
+  draco::Status last_status_;
+};
+
+#endif  // DRACO_JAVASCRIPT_EMSCRIPTEN_ANIMATION_DECODER_WEBIDL_WRAPPER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/animation_encoder_webidl_wrapper.cc b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/animation_encoder_webidl_wrapper.cc
new file mode 100644
index 000000000..53a10e5e4
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/animation_encoder_webidl_wrapper.cc
@@ -0,0 +1,89 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/javascript/emscripten/animation_encoder_webidl_wrapper.h"
+
+#include "draco/animation/keyframe_animation.h"
+#include "draco/animation/keyframe_animation_encoder.h"
+
+DracoInt8Array::DracoInt8Array() {}
+
+int DracoInt8Array::GetValue(int index) const { return values_[index]; }
+
+bool DracoInt8Array::SetValues(const char *values, int count) {
+  values_.assign(values, values + count);
+  return true;
+}
+
+AnimationBuilder::AnimationBuilder() {}
+
+bool AnimationBuilder::SetTimestamps(draco::KeyframeAnimation *animation,
+                                     long num_frames, const float *timestamps) {
+  if (!animation || !timestamps) {
+    return false;
+  }
+  std::vector<draco::KeyframeAnimation::TimestampType> timestamps_arr(
+      timestamps, timestamps + num_frames);
+  return animation->SetTimestamps(timestamps_arr);
+}
+
+int AnimationBuilder::AddKeyframes(draco::KeyframeAnimation *animation,
+                                   long num_frames, long num_components,
+                                   const float *animation_data) {
+  if (!animation || !animation_data) {
+    return -1;
+  }
+  std::vector<float> keyframes_arr(
+      animation_data, animation_data + num_frames * num_components);
+  return animation->AddKeyframes(draco::DT_FLOAT32, num_components,
+                                 keyframes_arr);
+}
+
+AnimationEncoder::AnimationEncoder()
+    : timestamps_quantization_bits_(-1),
+      keyframes_quantization_bits_(-1),
+      options_(draco::EncoderOptions::CreateDefaultOptions()) {}
+
+void AnimationEncoder::SetTimestampsQuantization(long quantization_bits) {
+  timestamps_quantization_bits_ = quantization_bits;
+}
+
+void AnimationEncoder::SetKeyframesQuantization(long quantization_bits) {
+  keyframes_quantization_bits_ = quantization_bits;
+}
+
+int AnimationEncoder::EncodeAnimationToDracoBuffer(
+    draco::KeyframeAnimation *animation, DracoInt8Array *draco_buffer) {
+  if (!animation) {
+    return 0;
+  }
+  draco::EncoderBuffer buffer;
+
+  if (timestamps_quantization_bits_ > 0) {
+    options_.SetAttributeInt(0, "quantization_bits",
+                             timestamps_quantization_bits_);
+  }
+  if (keyframes_quantization_bits_ > 0) {
+    for (int i = 1; i <= animation->num_animations(); ++i) {
+      options_.SetAttributeInt(i, "quantization_bits",
+                               keyframes_quantization_bits_);
+    }
+  }
+  if (!encoder_.EncodeKeyframeAnimation(*animation, options_, &buffer).ok()) {
+    return 0;
+  }
+
+  draco_buffer->SetValues(buffer.data(), buffer.size());
+  return buffer.size();
+}
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/animation_encoder_webidl_wrapper.h b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/animation_encoder_webidl_wrapper.h
new file mode 100644
index 000000000..f2ac733d1
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/animation_encoder_webidl_wrapper.h
@@ -0,0 +1,66 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_JAVASCRIPT_EMSCRIPTEN_ANIMATION_ENCODER_WEBIDL_WRAPPER_H_
+#define DRACO_JAVASCRIPT_EMSCRIPTEN_ANIMATION_ENCODER_WEBIDL_WRAPPER_H_
+
+#include <vector>
+
+#include "draco/animation/keyframe_animation_encoder.h"
+#include "draco/attributes/point_attribute.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/config/encoder_options.h"
+#include "draco/compression/encode.h"
+
+class DracoInt8Array {
+ public:
+  DracoInt8Array();
+  int GetValue(int index) const;
+  bool SetValues(const char *values, int count);
+
+  size_t size() { return values_.size(); }
+
+ private:
+  std::vector<int> values_;
+};
+
+class AnimationBuilder {
+ public:
+  AnimationBuilder();
+
+  bool SetTimestamps(draco::KeyframeAnimation *animation, long num_frames,
+                     const float *timestamps);
+
+  int AddKeyframes(draco::KeyframeAnimation *animation, long num_frames,
+                   long num_components, const float *animation_data);
+};
+
+class AnimationEncoder {
+ public:
+  AnimationEncoder();
+
+  void SetTimestampsQuantization(long quantization_bits);
+  // TODO: Use expert encoder to set per attribute quantization.
+  void SetKeyframesQuantization(long quantization_bits);
+  int EncodeAnimationToDracoBuffer(draco::KeyframeAnimation *animation,
+                                   DracoInt8Array *draco_buffer);
+
+ private:
+  draco::KeyframeAnimationEncoder encoder_;
+  long timestamps_quantization_bits_;
+  long keyframes_quantization_bits_;
+  draco::EncoderOptions options_;
+};
+
+#endif  // DRACO_JAVASCRIPT_EMSCRIPTEN_ANIMATION_ENCODER_WEBIDL_WRAPPER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/decoder_functions.js b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/decoder_functions.js
new file mode 100644
index 000000000..577900ff9
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/decoder_functions.js
@@ -0,0 +1,33 @@
+// Copyright 2020 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Returns encoded geometry type stored in the |array|. In general, |array|
+// should be a javascript Int8Array containing the encoded data. For backward
+// compatibility, |array| can also represent a Module.DecoderBuffer object.
+Module['Decoder'].prototype.GetEncodedGeometryType = function(array) {
+  if (array.__class__ && array.__class__ === Module.DecoderBuffer) {
+    // |array| is a DecoderBuffer. Pass it to the deprecated function.
+    return Module.Decoder.prototype.GetEncodedGeometryType_Deprecated(array);
+  }
+  if (array.byteLength < 8)
+    return Module.INVALID_GEOMETRY_TYPE;
+  switch (array[7]) {
+    case 0:
+      return Module.POINT_CLOUD;
+    case 1:
+      return Module.TRIANGULAR_MESH;
+    default:
+      return Module.INVALID_GEOMETRY_TYPE;
+  }
+};
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/decoder_webidl_wrapper.cc b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/decoder_webidl_wrapper.cc
new file mode 100644
index 000000000..66fe77dbd
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/decoder_webidl_wrapper.cc
@@ -0,0 +1,363 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/javascript/emscripten/decoder_webidl_wrapper.h"
+
+#include "draco/compression/decode.h"
+#include "draco/mesh/mesh.h"
+#include "draco/mesh/mesh_stripifier.h"
+
+using draco::DecoderBuffer;
+using draco::Mesh;
+using draco::Metadata;
+using draco::PointAttribute;
+using draco::PointCloud;
+using draco::Status;
+
+MetadataQuerier::MetadataQuerier() : entry_names_metadata_(nullptr) {}
+
+bool MetadataQuerier::HasEntry(const Metadata &metadata,
+                               const char *entry_name) const {
+  return metadata.entries().count(entry_name) > 0;
+}
+
+long MetadataQuerier::GetIntEntry(const Metadata &metadata,
+                                  const char *entry_name) const {
+  int32_t value = 0;
+  const std::string name(entry_name);
+  metadata.GetEntryInt(name, &value);
+  return value;
+}
+
+void MetadataQuerier::GetIntEntryArray(const draco::Metadata &metadata,
+                                       const char *entry_name,
+                                       DracoInt32Array *out_values) const {
+  const std::string name(entry_name);
+  std::vector<int32_t> values;
+  metadata.GetEntryIntArray(name, &values);
+  out_values->MoveData(std::move(values));
+}
+
+double MetadataQuerier::GetDoubleEntry(const Metadata &metadata,
+                                       const char *entry_name) const {
+  double value = 0;
+  const std::string name(entry_name);
+  metadata.GetEntryDouble(name, &value);
+  return value;
+}
+
+const char *MetadataQuerier::GetStringEntry(const Metadata &metadata,
+                                            const char *entry_name) {
+  const std::string name(entry_name);
+  if (!metadata.GetEntryString(name, &last_string_returned_)) {
+    return nullptr;
+  }
+
+  const char *value = last_string_returned_.c_str();
+  return value;
+}
+
+long MetadataQuerier::NumEntries(const Metadata &metadata) const {
+  return metadata.num_entries();
+}
+
+const char *MetadataQuerier::GetEntryName(const Metadata &metadata,
+                                          int entry_id) {
+  if (entry_names_metadata_ != &metadata) {
+    entry_names_.clear();
+    entry_names_metadata_ = &metadata;
+    // Initialize the list of entry names.
+    for (auto &&entry : metadata.entries()) {
+      entry_names_.push_back(entry.first);
+    }
+  }
+  if (entry_id < 0 || entry_id >= entry_names_.size()) {
+    return nullptr;
+  }
+  return entry_names_[entry_id].c_str();
+}
+
+Decoder::Decoder() {}
+
+draco_EncodedGeometryType Decoder::GetEncodedGeometryType_Deprecated(
+    DecoderBuffer *in_buffer) {
+  return draco::Decoder::GetEncodedGeometryType(in_buffer).value();
+}
+
+const Status *Decoder::DecodeBufferToPointCloud(DecoderBuffer *in_buffer,
+                                                PointCloud *out_point_cloud) {
+  last_status_ = decoder_.DecodeBufferToGeometry(in_buffer, out_point_cloud);
+  return &last_status_;
+}
+
+const draco::Status *Decoder::DecodeArrayToPointCloud(
+    const char *data, size_t data_size, PointCloud *out_point_cloud) {
+  DecoderBuffer buffer;
+  buffer.Init(data, data_size);
+  return DecodeBufferToPointCloud(&buffer, out_point_cloud);
+}
+
+const Status *Decoder::DecodeBufferToMesh(DecoderBuffer *in_buffer,
+                                          Mesh *out_mesh) {
+  last_status_ = decoder_.DecodeBufferToGeometry(in_buffer, out_mesh);
+  return &last_status_;
+}
+
+const draco::Status *Decoder::DecodeArrayToMesh(const char *data,
+                                                size_t data_size,
+                                                Mesh *out_mesh) {
+  DecoderBuffer buffer;
+  buffer.Init(data, data_size);
+  return DecodeBufferToMesh(&buffer, out_mesh);
+}
+
+long Decoder::GetAttributeId(const PointCloud &pc,
+                             draco_GeometryAttribute_Type type) const {
+  return pc.GetNamedAttributeId(type);
+}
+
+const PointAttribute *Decoder::GetAttribute(const PointCloud &pc, long att_id) {
+  return pc.attribute(att_id);
+}
+
+const PointAttribute *Decoder::GetAttributeByUniqueId(const PointCloud &pc,
+                                                      long unique_id) {
+  return pc.GetAttributeByUniqueId(unique_id);
+}
+
+long Decoder::GetAttributeIdByName(const PointCloud &pc,
+                                   const char *attribute_name) {
+  const std::string entry_value(attribute_name);
+  return pc.GetAttributeIdByMetadataEntry("name", entry_value);
+}
+
+long Decoder::GetAttributeIdByMetadataEntry(const PointCloud &pc,
+                                            const char *metadata_name,
+                                            const char *metadata_value) {
+  const std::string entry_name(metadata_name);
+  const std::string entry_value(metadata_value);
+  return pc.GetAttributeIdByMetadataEntry(entry_name, entry_value);
+}
+
+bool Decoder::GetFaceFromMesh(const Mesh &m,
+                              draco::FaceIndex::ValueType face_id,
+                              DracoInt32Array *out_values) {
+  const Mesh::Face &face = m.face(draco::FaceIndex(face_id));
+  const auto ptr = reinterpret_cast<const int32_t *>(face.data());
+  out_values->MoveData(std::vector<int32_t>({ptr, ptr + face.size()}));
+  return true;
+}
+
+long Decoder::GetTriangleStripsFromMesh(const Mesh &m,
+                                        DracoInt32Array *strip_values) {
+  draco::MeshStripifier stripifier;
+  std::vector<int32_t> strip_indices;
+  if (!stripifier.GenerateTriangleStripsWithDegenerateTriangles(
+          m, std::back_inserter(strip_indices))) {
+    return 0;
+  }
+  strip_values->MoveData(std::move(strip_indices));
+  return stripifier.num_strips();
+}
+
+template <typename T>
+bool GetTrianglesArray(const draco::Mesh &m, const int out_size,
+                       T *out_values) {
+  const uint32_t num_faces = m.num_faces();
+  if (num_faces * 3 * sizeof(T) != out_size) {
+    return false;
+  }
+
+  for (uint32_t face_id = 0; face_id < num_faces; ++face_id) {
+    const Mesh::Face &face = m.face(draco::FaceIndex(face_id));
+    out_values[face_id * 3 + 0] = static_cast<T>(face[0].value());
+    out_values[face_id * 3 + 1] = static_cast<T>(face[1].value());
+    out_values[face_id * 3 + 2] = static_cast<T>(face[2].value());
+  }
+  return true;
+}
+
+bool Decoder::GetTrianglesUInt16Array(const draco::Mesh &m, int out_size,
+                                      void *out_values) {
+  if (m.num_points() > std::numeric_limits<uint16_t>::max()) {
+    return false;
+  }
+  return GetTrianglesArray<uint16_t>(m, out_size,
+                                     reinterpret_cast<uint16_t *>(out_values));
+}
+
+bool Decoder::GetTrianglesUInt32Array(const draco::Mesh &m, int out_size,
+                                      void *out_values) {
+  return GetTrianglesArray<uint32_t>(m, out_size,
+                                     reinterpret_cast<uint32_t *>(out_values));
+}
+
+bool Decoder::GetAttributeFloat(const PointAttribute &pa,
+                                draco::AttributeValueIndex::ValueType val_index,
+                                DracoFloat32Array *out_values) {
+  const int kMaxAttributeFloatValues = 4;
+  const int components = pa.num_components();
+  float values[kMaxAttributeFloatValues] = {-2.0, -2.0, -2.0, -2.0};
+  if (!pa.ConvertValue<float>(draco::AttributeValueIndex(val_index), values))
+    return false;
+  out_values->MoveData({values, values + components});
+  return true;
+}
+
+bool Decoder::GetAttributeFloatForAllPoints(const PointCloud &pc,
+                                            const PointAttribute &pa,
+                                            DracoFloat32Array *out_values) {
+  const int components = pa.num_components();
+  const int num_points = pc.num_points();
+  const int num_entries = num_points * components;
+  const int kMaxAttributeFloatValues = 4;
+  float values[kMaxAttributeFloatValues] = {-2.0, -2.0, -2.0, -2.0};
+  int entry_id = 0;
+
+  out_values->Resize(num_entries);
+  for (draco::PointIndex i(0); i < num_points; ++i) {
+    const draco::AttributeValueIndex val_index = pa.mapped_index(i);
+    if (!pa.ConvertValue<float>(val_index, values)) {
+      return false;
+    }
+    for (int j = 0; j < components; ++j) {
+      out_values->SetValue(entry_id++, values[j]);
+    }
+  }
+  return true;
+}
+
+bool Decoder::GetAttributeFloatArrayForAllPoints(const PointCloud &pc,
+                                                 const PointAttribute &pa,
+                                                 int out_size,
+                                                 void *out_values) {
+  const int components = pa.num_components();
+  const int num_points = pc.num_points();
+  const int data_size = num_points * components * sizeof(float);
+  if (data_size != out_size) {
+    return false;
+  }
+  const bool requested_type_is_float = pa.data_type() == draco::DT_FLOAT32;
+  const int kMaxAttributeFloatValues = 4;
+  float values[kMaxAttributeFloatValues] = {-2.0, -2.0, -2.0, -2.0};
+  int entry_id = 0;
+  float *const floats = reinterpret_cast<float *>(out_values);
+
+  for (draco::PointIndex i(0); i < num_points; ++i) {
+    const draco::AttributeValueIndex val_index = pa.mapped_index(i);
+    if (requested_type_is_float) {
+      pa.GetValue(val_index, values);
+    } else {
+      if (!pa.ConvertValue<float>(val_index, values)) {
+        return false;
+      }
+    }
+    for (int j = 0; j < components; ++j) {
+      floats[entry_id++] = values[j];
+    }
+  }
+  return true;
+}
+
+bool Decoder::GetAttributeInt8ForAllPoints(const PointCloud &pc,
+                                           const PointAttribute &pa,
+                                           DracoInt8Array *out_values) {
+  return GetAttributeDataForAllPoints<DracoInt8Array, int8_t>(
+      pc, pa, draco::DT_INT8, draco::DT_UINT8, out_values);
+}
+
+bool Decoder::GetAttributeUInt8ForAllPoints(const PointCloud &pc,
+                                            const PointAttribute &pa,
+                                            DracoUInt8Array *out_values) {
+  return GetAttributeDataForAllPoints<DracoUInt8Array, uint8_t>(
+      pc, pa, draco::DT_INT8, draco::DT_UINT8, out_values);
+}
+
+bool Decoder::GetAttributeInt16ForAllPoints(const PointCloud &pc,
+                                            const PointAttribute &pa,
+                                            DracoInt16Array *out_values) {
+  return GetAttributeDataForAllPoints<DracoInt16Array, int16_t>(
+      pc, pa, draco::DT_INT16, draco::DT_UINT16, out_values);
+}
+
+bool Decoder::GetAttributeUInt16ForAllPoints(const PointCloud &pc,
+                                             const PointAttribute &pa,
+                                             DracoUInt16Array *out_values) {
+  return GetAttributeDataForAllPoints<DracoUInt16Array, uint16_t>(
+      pc, pa, draco::DT_INT16, draco::DT_UINT16, out_values);
+}
+
+bool Decoder::GetAttributeInt32ForAllPoints(const PointCloud &pc,
+                                            const PointAttribute &pa,
+                                            DracoInt32Array *out_values) {
+  return GetAttributeDataForAllPoints<DracoInt32Array, int32_t>(
+      pc, pa, draco::DT_INT32, draco::DT_UINT32, out_values);
+}
+
+bool Decoder::GetAttributeIntForAllPoints(const PointCloud &pc,
+                                          const PointAttribute &pa,
+                                          DracoInt32Array *out_values) {
+  return GetAttributeInt32ForAllPoints(pc, pa, out_values);
+}
+
+bool Decoder::GetAttributeUInt32ForAllPoints(const PointCloud &pc,
+                                             const PointAttribute &pa,
+                                             DracoUInt32Array *out_values) {
+  return GetAttributeDataForAllPoints<DracoUInt32Array, uint32_t>(
+      pc, pa, draco::DT_INT32, draco::DT_UINT32, out_values);
+}
+
+bool Decoder::GetAttributeDataArrayForAllPoints(const draco::PointCloud &pc,
+                                                const draco::PointAttribute &pa,
+                                                draco_DataType data_type,
+                                                int out_size,
+                                                void *out_values) {
+  switch (data_type) {
+    case draco::DT_INT8:
+      return GetAttributeDataArrayForAllPoints<int8_t>(pc, pa, draco::DT_INT8,
+                                                       out_size, out_values);
+    case draco::DT_INT16:
+      return GetAttributeDataArrayForAllPoints<int16_t>(pc, pa, draco::DT_INT16,
+                                                        out_size, out_values);
+    case draco::DT_INT32:
+      return GetAttributeDataArrayForAllPoints<int32_t>(pc, pa, draco::DT_INT32,
+                                                        out_size, out_values);
+    case draco::DT_UINT8:
+      return GetAttributeDataArrayForAllPoints<uint8_t>(pc, pa, draco::DT_UINT8,
+                                                        out_size, out_values);
+    case draco::DT_UINT16:
+      return GetAttributeDataArrayForAllPoints<uint16_t>(
+          pc, pa, draco::DT_UINT16, out_size, out_values);
+    case draco::DT_UINT32:
+      return GetAttributeDataArrayForAllPoints<uint32_t>(
+          pc, pa, draco::DT_UINT32, out_size, out_values);
+    case draco::DT_FLOAT32:
+      return GetAttributeFloatArrayForAllPoints(pc, pa, out_size, out_values);
+    default:
+      return false;
+  }
+}
+
+void Decoder::SkipAttributeTransform(draco_GeometryAttribute_Type att_type) {
+  decoder_.SetSkipAttributeTransform(att_type);
+}
+
+const Metadata *Decoder::GetMetadata(const PointCloud &pc) const {
+  return pc.GetMetadata();
+}
+
+const Metadata *Decoder::GetAttributeMetadata(const PointCloud &pc,
+                                              long att_id) const {
+  return pc.GetAttributeMetadataByAttributeId(att_id);
+}
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/decoder_webidl_wrapper.h b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/decoder_webidl_wrapper.h
new file mode 100644
index 000000000..75ae76aa6
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/decoder_webidl_wrapper.h
@@ -0,0 +1,330 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_JAVASCRIPT_EMSCRIPTEN_DECODER_WEBIDL_WRAPPER_H_
+#define DRACO_JAVASCRIPT_EMSCRIPTEN_DECODER_WEBIDL_WRAPPER_H_
+
+#include <vector>
+
+#include "draco/attributes/attribute_transform_type.h"
+#include "draco/attributes/point_attribute.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/decode.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/mesh/mesh.h"
+
+typedef draco::AttributeTransformType draco_AttributeTransformType;
+typedef draco::GeometryAttribute draco_GeometryAttribute;
+typedef draco_GeometryAttribute::Type draco_GeometryAttribute_Type;
+typedef draco::EncodedGeometryType draco_EncodedGeometryType;
+typedef draco::Status draco_Status;
+typedef draco::Status::Code draco_StatusCode;
+typedef draco::DataType draco_DataType;
+
+// To generate Draco JavaScript bindings you must have emscripten installed.
+// Then run make -f Makefile.emcc jslib.
+template <typename T>
+class DracoArray {
+ public:
+  T GetValue(int index) const { return values_[index]; }
+
+  void Resize(int size) { values_.resize(size); }
+  void MoveData(std::vector<T> &&values) { values_ = std::move(values); }
+
+  // Directly sets a value for a specific index. The array has to be already
+  // allocated at this point (using Resize() method).
+  void SetValue(int index, T val) { values_[index] = val; }
+
+  int size() const { return values_.size(); }
+
+ private:
+  std::vector<T> values_;
+};
+
+using DracoFloat32Array = DracoArray<float>;
+using DracoInt8Array = DracoArray<int8_t>;
+using DracoUInt8Array = DracoArray<uint8_t>;
+using DracoInt16Array = DracoArray<int16_t>;
+using DracoUInt16Array = DracoArray<uint16_t>;
+using DracoInt32Array = DracoArray<int32_t>;
+using DracoUInt32Array = DracoArray<uint32_t>;
+
+class MetadataQuerier {
+ public:
+  MetadataQuerier();
+
+  bool HasEntry(const draco::Metadata &metadata, const char *entry_name) const;
+
+  // This function does not guarantee that entry's type is long.
+  long GetIntEntry(const draco::Metadata &metadata,
+                   const char *entry_name) const;
+
+  // This function does not guarantee that entry types are long.
+  void GetIntEntryArray(const draco::Metadata &metadata, const char *entry_name,
+                        DracoInt32Array *out_values) const;
+
+  // This function does not guarantee that entry's type is double.
+  double GetDoubleEntry(const draco::Metadata &metadata,
+                        const char *entry_name) const;
+
+  // This function does not guarantee that entry's type is char*.
+  const char *GetStringEntry(const draco::Metadata &metadata,
+                             const char *entry_name);
+
+  long NumEntries(const draco::Metadata &metadata) const;
+  const char *GetEntryName(const draco::Metadata &metadata, int entry_id);
+
+ private:
+  // Cached values for metadata entries.
+  std::vector<std::string> entry_names_;
+  const draco::Metadata *entry_names_metadata_;
+
+  // Cached value for GetStringEntry() to avoid scoping issues.
+  std::string last_string_returned_;
+};
+
+// Class used by emscripten WebIDL Binder [1] to wrap calls to decode Draco
+// data.
+// [1]http://kripken.github.io/emscripten-site/docs/porting/connecting_cpp_and_javascript/WebIDL-Binder.html
+class Decoder {
+ public:
+  Decoder();
+
+  // Returns the geometry type stored in the |in_buffer|. Return values can be
+  // INVALID_GEOMETRY_TYPE, POINT_CLOUD, or MESH.
+  // Deprecated: Use decoder.GetEncodedGeometryType(array), where |array| is
+  // an Int8Array containing the encoded data.
+  static draco_EncodedGeometryType GetEncodedGeometryType_Deprecated(
+      draco::DecoderBuffer *in_buffer);
+
+  // Decodes a point cloud from the provided buffer.
+  // Deprecated: Use DecodeArrayToPointCloud.
+  const draco::Status *DecodeBufferToPointCloud(
+      draco::DecoderBuffer *in_buffer, draco::PointCloud *out_point_cloud);
+
+  // Decodes a point cloud from the provided array.
+  const draco::Status *DecodeArrayToPointCloud(
+      const char *data, size_t data_size, draco::PointCloud *out_point_cloud);
+
+  // Decodes a triangular mesh from the provided buffer.
+  // Deprecated: Use DecodeArrayToMesh.
+  const draco::Status *DecodeBufferToMesh(draco::DecoderBuffer *in_buffer,
+                                          draco::Mesh *out_mesh);
+
+  // Decodes a mesh from the provided array.
+  const draco::Status *DecodeArrayToMesh(const char *data, size_t data_size,
+                                         draco::Mesh *out_mesh);
+
+  // Returns an attribute id for the first attribute of a given type.
+  long GetAttributeId(const draco::PointCloud &pc,
+                      draco_GeometryAttribute_Type type) const;
+
+  // Returns an attribute id of an attribute that contains a valid metadata
+  // entry "name" with value |attribute_name|.
+  static long GetAttributeIdByName(const draco::PointCloud &pc,
+                                   const char *attribute_name);
+
+  // Returns an attribute id of an attribute with a specified metadata pair
+  // <|metadata_name|, |metadata_value|>.
+  static long GetAttributeIdByMetadataEntry(const draco::PointCloud &pc,
+                                            const char *metadata_name,
+                                            const char *metadata_value);
+
+  // Returns an attribute id of an attribute that has the unique id.
+  static const draco::PointAttribute *GetAttributeByUniqueId(
+      const draco::PointCloud &pc, long unique_id);
+
+  // Returns a PointAttribute pointer from |att_id| index.
+  static const draco::PointAttribute *GetAttribute(const draco::PointCloud &pc,
+                                                   long att_id);
+
+  // Returns Mesh::Face values in |out_values| from |face_id| index.
+  static bool GetFaceFromMesh(const draco::Mesh &m,
+                              draco::FaceIndex::ValueType face_id,
+                              DracoInt32Array *out_values);
+
+  // Returns triangle strips for mesh |m|. If there's multiple strips,
+  // the strips will be separated by degenerate faces.
+  static long GetTriangleStripsFromMesh(const draco::Mesh &m,
+                                        DracoInt32Array *strip_values);
+
+  // Returns all faces as triangles. Fails if indices exceed the data range (in
+  // particular for uint16), or the output array size does not match.
+  // |out_size| is the size in bytes of |out_values|. |out_values| must be
+  // allocated before calling this function.
+  static bool GetTrianglesUInt16Array(const draco::Mesh &m, int out_size,
+                                      void *out_values);
+  static bool GetTrianglesUInt32Array(const draco::Mesh &m, int out_size,
+                                      void *out_values);
+
+  // Returns float attribute values in |out_values| from |entry_index| index.
+  static bool GetAttributeFloat(
+      const draco::PointAttribute &pa,
+      draco::AttributeValueIndex::ValueType entry_index,
+      DracoFloat32Array *out_values);
+
+  // Returns float attribute values for all point ids of the point cloud.
+  // I.e., the |out_values| is going to contain m.num_points() entries.
+  static bool GetAttributeFloatForAllPoints(const draco::PointCloud &pc,
+                                            const draco::PointAttribute &pa,
+                                            DracoFloat32Array *out_values);
+
+  // Returns float attribute values for all point ids of the point cloud.
+  // I.e., the |out_values| is going to contain m.num_points() entries.
+  static bool GetAttributeFloatArrayForAllPoints(
+      const draco::PointCloud &pc, const draco::PointAttribute &pa,
+      int out_size, void *out_values);
+
+  // Returns int8_t attribute values for all point ids of the point cloud.
+  // I.e., the |out_values| is going to contain m.num_points() entries.
+  static bool GetAttributeInt8ForAllPoints(const draco::PointCloud &pc,
+                                           const draco::PointAttribute &pa,
+                                           DracoInt8Array *out_values);
+
+  // Returns uint8_t attribute values for all point ids of the point cloud.
+  // I.e., the |out_values| is going to contain m.num_points() entries.
+  static bool GetAttributeUInt8ForAllPoints(const draco::PointCloud &pc,
+                                            const draco::PointAttribute &pa,
+                                            DracoUInt8Array *out_values);
+
+  // Returns int16_t attribute values for all point ids of the point cloud.
+  // I.e., the |out_values| is going to contain m.num_points() entries.
+  static bool GetAttributeInt16ForAllPoints(const draco::PointCloud &pc,
+                                            const draco::PointAttribute &pa,
+                                            DracoInt16Array *out_values);
+
+  // Returns uint16_t attribute values for all point ids of the point cloud.
+  // I.e., the |out_values| is going to contain m.num_points() entries.
+  static bool GetAttributeUInt16ForAllPoints(const draco::PointCloud &pc,
+                                             const draco::PointAttribute &pa,
+                                             DracoUInt16Array *out_values);
+
+  // Returns int32_t attribute values for all point ids of the point cloud.
+  // I.e., the |out_values| is going to contain m.num_points() entries.
+  static bool GetAttributeInt32ForAllPoints(const draco::PointCloud &pc,
+                                            const draco::PointAttribute &pa,
+                                            DracoInt32Array *out_values);
+
+  // Deprecated: Use GetAttributeInt32ForAllPoints() instead.
+  static bool GetAttributeIntForAllPoints(const draco::PointCloud &pc,
+                                          const draco::PointAttribute &pa,
+                                          DracoInt32Array *out_values);
+
+  // Returns uint32_t attribute values for all point ids of the point cloud.
+  // I.e., the |out_values| is going to contain m.num_points() entries.
+  static bool GetAttributeUInt32ForAllPoints(const draco::PointCloud &pc,
+                                             const draco::PointAttribute &pa,
+                                             DracoUInt32Array *out_values);
+
+  // Returns |data_type| attribute values for all point ids of the point cloud.
+  // I.e., the |out_values| is going to contain m.num_points() entries.
+  // |out_size| is the size in bytes of |out_values|. |out_values| must be
+  // allocated before calling this function.
+  static bool GetAttributeDataArrayForAllPoints(const draco::PointCloud &pc,
+                                                const draco::PointAttribute &pa,
+                                                draco_DataType data_type,
+                                                int out_size, void *out_values);
+
+  // Tells the decoder to skip an attribute transform (e.g. dequantization) for
+  // an attribute of a given type.
+  void SkipAttributeTransform(draco_GeometryAttribute_Type att_type);
+
+  const draco::Metadata *GetMetadata(const draco::PointCloud &pc) const;
+  const draco::Metadata *GetAttributeMetadata(const draco::PointCloud &pc,
+                                              long att_id) const;
+
+ private:
+  template <class DracoArrayT, class ValueTypeT>
+  static bool GetAttributeDataForAllPoints(const draco::PointCloud &pc,
+                                           const draco::PointAttribute &pa,
+                                           draco::DataType draco_signed_type,
+                                           draco::DataType draco_unsigned_type,
+                                           DracoArrayT *out_values) {
+    const int components = pa.num_components();
+    const int num_points = pc.num_points();
+    const int num_entries = num_points * components;
+
+    if ((pa.data_type() == draco_signed_type ||
+         pa.data_type() == draco_unsigned_type) &&
+        pa.is_mapping_identity()) {
+      // Copy values directly to the output vector.
+      const ValueTypeT *ptr = reinterpret_cast<const ValueTypeT *>(
+          pa.GetAddress(draco::AttributeValueIndex(0)));
+      out_values->MoveData({ptr, ptr + num_entries});
+      return true;
+    }
+
+    // Copy values one by one.
+    std::vector<ValueTypeT> values(components);
+    int entry_id = 0;
+
+    out_values->Resize(num_entries);
+    for (draco::PointIndex i(0); i < num_points; ++i) {
+      const draco::AttributeValueIndex val_index = pa.mapped_index(i);
+      if (!pa.ConvertValue<ValueTypeT>(val_index, &values[0])) {
+        return false;
+      }
+      for (int j = 0; j < components; ++j) {
+        out_values->SetValue(entry_id++, values[j]);
+      }
+    }
+    return true;
+  }
+
+  template <class T>
+  static bool GetAttributeDataArrayForAllPoints(const draco::PointCloud &pc,
+                                                const draco::PointAttribute &pa,
+                                                const draco::DataType type,
+                                                int out_size,
+                                                void *out_values) {
+    const int components = pa.num_components();
+    const int num_points = pc.num_points();
+    const int data_size = num_points * components * sizeof(T);
+    if (data_size != out_size) {
+      return false;
+    }
+    const bool requested_type_matches = pa.data_type() == type;
+    if (requested_type_matches && pa.is_mapping_identity()) {
+      // Copy values directly to the output vector.
+      const auto ptr = pa.GetAddress(draco::AttributeValueIndex(0));
+      ::memcpy(out_values, ptr, data_size);
+      return true;
+    }
+
+    // Copy values one by one.
+    std::vector<T> values(components);
+    int entry_id = 0;
+
+    T *const typed_output = reinterpret_cast<T *>(out_values);
+    for (draco::PointIndex i(0); i < num_points; ++i) {
+      const draco::AttributeValueIndex val_index = pa.mapped_index(i);
+      if (requested_type_matches) {
+        pa.GetValue(val_index, values.data());
+      } else {
+        if (!pa.ConvertValue<T>(val_index, values.data())) {
+          return false;
+        }
+      }
+      for (int j = 0; j < components; ++j) {
+        typed_output[entry_id++] = values[j];
+      }
+    }
+    return true;
+  }
+
+  draco::Decoder decoder_;
+  draco::Status last_status_;
+};
+
+#endif  // DRACO_JAVASCRIPT_EMSCRIPTEN_DECODER_WEBIDL_WRAPPER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_animation_decoder_glue_wrapper.cc b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_animation_decoder_glue_wrapper.cc
new file mode 100644
index 000000000..83ed98fdc
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_animation_decoder_glue_wrapper.cc
@@ -0,0 +1,28 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// This file is used by emscripten's WebIDL Binder.
+// http://kripken.github.io/emscripten-site/docs/porting/connecting_cpp_and_javascript/WebIDL-Binder.html
+#include "draco/attributes/attribute_octahedron_transform.h"
+#include "draco/attributes/attribute_quantization_transform.h"
+#include "draco/attributes/geometry_attribute.h"
+#include "draco/attributes/point_attribute.h"
+#include "draco/compression/decode.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/javascript/emscripten/animation_decoder_webidl_wrapper.h"
+#include "draco/mesh/mesh.h"
+#include "draco/point_cloud/point_cloud.h"
+
+// glue_animation_decoder.cpp is generated by Makefile.emcc build_glue target.
+#include "glue_animation_decoder.cpp"
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_animation_encoder_glue_wrapper.cc b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_animation_encoder_glue_wrapper.cc
new file mode 100644
index 000000000..29e7ed3ba
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_animation_encoder_glue_wrapper.cc
@@ -0,0 +1,25 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// This file is used by emscripten's WebIDL Binder.
+// http://kripken.github.io/emscripten-site/docs/porting/connecting_cpp_and_javascript/WebIDL-Binder.html
+#include "draco/attributes/geometry_attribute.h"
+#include "draco/attributes/point_attribute.h"
+#include "draco/compression/encode.h"
+#include "draco/javascript/emscripten/animation_encoder_webidl_wrapper.h"
+#include "draco/mesh/mesh.h"
+#include "draco/point_cloud/point_cloud.h"
+
+// glue_animation_encoder.cpp is generated by Makefile.emcc build_glue target.
+#include "glue_animation_encoder.cpp"
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_animation_web_decoder.idl b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_animation_web_decoder.idl
new file mode 100644
index 000000000..c9fe76b59
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_animation_web_decoder.idl
@@ -0,0 +1,52 @@
+// Interface exposed to emscripten's WebIDL Binder.
+// http://kripken.github.io/emscripten-site/docs/porting/connecting_cpp_and_javascript/WebIDL-Binder.html
+[Prefix="draco::"]
+interface DecoderBuffer {
+  void DecoderBuffer();
+  void Init([Const] byte[] data, unsigned long data_size);
+};
+
+enum draco_StatusCode {
+  "draco_Status::OK",
+  "draco_Status::DRACO_ERROR",
+  "draco_Status::IO_ERROR",
+  "draco_Status::INVALID_PARAMETER",
+  "draco_Status::UNSUPPORTED_VERSION",
+  "draco_Status::UNKNOWN_VERSION",
+};
+
+[Prefix="draco::"]
+interface Status {
+  draco_StatusCode code();
+  boolean ok();
+  [Const] DOMString error_msg();
+};
+
+// Draco version of typed arrays. The memory of these arrays is allocated on the
+// emscripten heap.
+interface DracoFloat32Array {
+  void DracoFloat32Array();
+  float GetValue(long index);
+  long size();
+};
+
+[Prefix="draco::"]
+interface KeyframeAnimation {
+  void KeyframeAnimation();
+  long num_frames();
+  long num_animations();
+};
+
+interface AnimationDecoder {
+  void AnimationDecoder();
+
+  [Const] Status DecodeBufferToKeyframeAnimation(DecoderBuffer in_buffer,
+                                                 KeyframeAnimation animation);
+
+  boolean GetTimestamps([Ref, Const] KeyframeAnimation animation,
+                        DracoFloat32Array timestamp);
+
+  boolean GetKeyframes([Ref, Const] KeyframeAnimation animation,
+                        long keyframes_id,
+                        DracoFloat32Array animation_data);
+};
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_animation_web_encoder.idl b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_animation_web_encoder.idl
new file mode 100644
index 000000000..e74a4c9e4
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_animation_web_encoder.idl
@@ -0,0 +1,34 @@
+// Interface exposed to emscripten's WebIDL Binder.
+// http://kripken.github.io/emscripten-site/docs/porting/connecting_cpp_and_javascript/WebIDL-Binder.html
+// Draco version of typed arrays. The memory of these arrays is allocated on the
+// emscripten heap.
+interface DracoInt8Array {
+  void DracoInt8Array();
+  long GetValue(long index);
+  long size();
+};
+
+[Prefix="draco::"]
+interface KeyframeAnimation {
+  void KeyframeAnimation();
+  long num_frames();
+};
+
+interface AnimationBuilder {
+  void AnimationBuilder();
+  boolean SetTimestamps(KeyframeAnimation animation, long num_frames,
+                       [Const] float[] timestamps);
+
+  long AddKeyframes(KeyframeAnimation animation, long num_frames,
+                    long num_components, [Const] float[] animation_data);
+};
+
+interface AnimationEncoder {
+  void AnimationEncoder();
+
+  void SetTimestampsQuantization(long quantization_bits);
+  void SetKeyframesQuantization(long quantization_bits);
+
+  long EncodeAnimationToDracoBuffer(KeyframeAnimation animation,
+                                    DracoInt8Array encoded_data);
+};
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_decoder_glue_wrapper.cc b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_decoder_glue_wrapper.cc
new file mode 100644
index 000000000..249d86a3e
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_decoder_glue_wrapper.cc
@@ -0,0 +1,28 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// This file is used by emscripten's WebIDL Binder.
+// http://kripken.github.io/emscripten-site/docs/porting/connecting_cpp_and_javascript/WebIDL-Binder.html
+#include "draco/attributes/attribute_octahedron_transform.h"
+#include "draco/attributes/attribute_quantization_transform.h"
+#include "draco/attributes/geometry_attribute.h"
+#include "draco/attributes/point_attribute.h"
+#include "draco/compression/decode.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/javascript/emscripten/decoder_webidl_wrapper.h"
+#include "draco/mesh/mesh.h"
+#include "draco/point_cloud/point_cloud.h"
+
+// glue.cpp is generated by Makefile.emcc build_glue target.
+#include "glue_decoder.cpp"
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_encoder_glue_wrapper.cc b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_encoder_glue_wrapper.cc
new file mode 100644
index 000000000..05a0af2f1
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_encoder_glue_wrapper.cc
@@ -0,0 +1,25 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// This file is used by emscripten's WebIDL Binder.
+// http://kripken.github.io/emscripten-site/docs/porting/connecting_cpp_and_javascript/WebIDL-Binder.html
+#include "draco/attributes/geometry_attribute.h"
+#include "draco/attributes/point_attribute.h"
+#include "draco/compression/encode.h"
+#include "draco/javascript/emscripten/encoder_webidl_wrapper.h"
+#include "draco/mesh/mesh.h"
+#include "draco/point_cloud/point_cloud.h"
+
+// glue.cpp is generated by Makefile.emcc build_glue target.
+#include "glue_encoder.cpp"
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_web_decoder.idl b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_web_decoder.idl
new file mode 100644
index 000000000..366694185
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_web_decoder.idl
@@ -0,0 +1,283 @@
+// Interface exposed to emscripten's WebIDL Binder.
+// http://kripken.github.io/emscripten-site/docs/porting/connecting_cpp_and_javascript/WebIDL-Binder.html
+
+// Deprecated: DecoderBuffer is no longer supported and will be removed in
+//             future releases. Please refer to Decoder declaration below for
+//             new decoding functions that do not use DecoderBuffer.
+[Prefix="draco::"]
+interface DecoderBuffer {
+  void DecoderBuffer();
+  void Init([Const] byte[] data, unsigned long data_size);
+};
+
+// TODO(fgalligan): Can we remove this?
+enum draco_AttributeTransformType {
+  "draco::ATTRIBUTE_INVALID_TRANSFORM",
+  "draco::ATTRIBUTE_NO_TRANSFORM",
+  "draco::ATTRIBUTE_QUANTIZATION_TRANSFORM",
+  "draco::ATTRIBUTE_OCTAHEDRON_TRANSFORM"
+};
+
+[Prefix="draco::"]
+interface AttributeTransformData {
+  void AttributeTransformData();
+  long transform_type();
+};
+
+enum draco_GeometryAttribute_Type {
+  "draco_GeometryAttribute::INVALID",
+  "draco_GeometryAttribute::POSITION",
+  "draco_GeometryAttribute::NORMAL",
+  "draco_GeometryAttribute::COLOR",
+  "draco_GeometryAttribute::TEX_COORD",
+  "draco_GeometryAttribute::GENERIC"
+};
+
+[Prefix="draco::"]
+interface GeometryAttribute {
+  void GeometryAttribute();
+};
+
+enum draco_EncodedGeometryType {
+  "draco::INVALID_GEOMETRY_TYPE",
+  "draco::POINT_CLOUD",
+  "draco::TRIANGULAR_MESH"
+};
+
+enum draco_DataType {
+  "draco::DT_INVALID",
+  "draco::DT_INT8",
+  "draco::DT_UINT8",
+  "draco::DT_INT16",
+  "draco::DT_UINT16",
+  "draco::DT_INT32",
+  "draco::DT_UINT32",
+  "draco::DT_INT64",
+  "draco::DT_UINT64",
+  "draco::DT_FLOAT32",
+  "draco::DT_FLOAT64",
+  "draco::DT_BOOL",
+  "draco::DT_TYPES_COUNT"
+};
+
+[Prefix="draco::"]
+interface PointAttribute {
+  void PointAttribute();
+  long size();
+  [Const] AttributeTransformData GetAttributeTransformData();
+
+  // From GeometryAttribute
+  long attribute_type();
+  long data_type();
+  byte num_components();
+  boolean normalized();
+  long byte_stride();
+  long byte_offset();
+  long unique_id();
+};
+
+[Prefix="draco::"]
+interface AttributeQuantizationTransform {
+  void AttributeQuantizationTransform();
+  boolean InitFromAttribute([Ref, Const] PointAttribute att);
+  long quantization_bits();
+  float min_value(long axis);
+  float range();
+};
+
+[Prefix="draco::"]
+interface AttributeOctahedronTransform {
+  void AttributeOctahedronTransform();
+  boolean InitFromAttribute([Ref, Const] PointAttribute att);
+  long quantization_bits();
+};
+
+
+[Prefix="draco::"]
+interface PointCloud {
+  void PointCloud();
+
+  long num_attributes();
+  long num_points();
+};
+
+[Prefix="draco::"]
+interface Mesh : PointCloud {
+  void Mesh();
+  long num_faces();
+
+  // From PointCloud
+  long num_attributes();
+  long num_points();
+};
+
+[Prefix="draco::"]
+interface Metadata {
+  void Metadata();
+};
+
+enum draco_StatusCode {
+  "draco_Status::OK",
+  "draco_Status::DRACO_ERROR",
+  "draco_Status::IO_ERROR",
+  "draco_Status::INVALID_PARAMETER",
+  "draco_Status::UNSUPPORTED_VERSION",
+  "draco_Status::UNKNOWN_VERSION",
+};
+
+[Prefix="draco::"]
+interface Status {
+  draco_StatusCode code();
+  boolean ok();
+  [Const] DOMString error_msg();
+};
+
+// Draco version of typed arrays. The memory of these arrays is allocated on the
+// emscripten heap.
+interface DracoFloat32Array {
+  void DracoFloat32Array();
+  float GetValue(long index);
+  long size();
+};
+
+interface DracoInt8Array {
+  void DracoInt8Array();
+  byte GetValue(long index);
+  long size();
+};
+
+interface DracoUInt8Array {
+  void DracoUInt8Array();
+  octet GetValue(long index);
+  long size();
+};
+
+interface DracoInt16Array {
+  void DracoInt16Array();
+  short GetValue(long index);
+  long size();
+};
+
+interface DracoUInt16Array {
+  void DracoUInt16Array();
+  unsigned short GetValue(long index);
+  long size();
+};
+
+interface DracoInt32Array {
+  void DracoInt32Array();
+  long GetValue(long index);
+  long size();
+};
+
+interface DracoUInt32Array {
+  void DracoUInt32Array();
+  unsigned long GetValue(long index);
+  long size();
+};
+
+interface MetadataQuerier {
+  void MetadataQuerier();
+
+  boolean HasEntry([Ref, Const] Metadata metadata,
+                   [Const] DOMString entry_name);
+  long GetIntEntry([Ref, Const] Metadata metadata,
+                   [Const] DOMString entry_name);
+  void GetIntEntryArray([Ref, Const] Metadata metadata,
+                        [Const] DOMString entry_name,
+                        DracoInt32Array out_values);
+  double GetDoubleEntry([Ref, Const] Metadata metadata,
+                        [Const] DOMString entry_name);
+  [Const] DOMString GetStringEntry([Ref, Const] Metadata metadata,
+                                   [Const] DOMString entry_name);
+
+  long NumEntries([Ref, Const] Metadata metadata);
+  [Const] DOMString GetEntryName([Ref, Const] Metadata metadata, long entry_id);
+};
+
+interface Decoder {
+  void Decoder();
+
+  [Const] Status DecodeArrayToPointCloud([Const] byte[] data,
+                                         unsigned long data_size,
+                                         PointCloud out_point_cloud);
+
+  [Const] Status DecodeArrayToMesh([Const] byte[] data,
+                                   unsigned long data_size,
+                                   Mesh out_mesh);
+
+  long GetAttributeId([Ref, Const] PointCloud pc,
+                      draco_GeometryAttribute_Type type);
+  long GetAttributeIdByName([Ref, Const] PointCloud pc, [Const] DOMString name);
+  long GetAttributeIdByMetadataEntry([Ref, Const] PointCloud pc,
+                                     [Const] DOMString name,
+                                     [Const] DOMString value);
+
+  [Const] PointAttribute GetAttribute([Ref, Const] PointCloud pc, long att_id);
+  [Const] PointAttribute GetAttributeByUniqueId([Ref, Const] PointCloud pc,
+                                                long unique_id);
+
+  [Const] Metadata GetMetadata([Ref, Const] PointCloud pc);
+  [Const] Metadata GetAttributeMetadata([Ref, Const] PointCloud pc,
+                                        long att_id);
+
+  boolean GetFaceFromMesh([Ref, Const] Mesh m, long face_id,
+                          DracoInt32Array out_values);
+  long GetTriangleStripsFromMesh([Ref, Const] Mesh m,
+                                 DracoInt32Array strip_values);
+
+  boolean GetTrianglesUInt16Array([Ref, Const] Mesh m,
+                                  long out_size, VoidPtr out_values);
+  boolean GetTrianglesUInt32Array([Ref, Const] Mesh m,
+                                  long out_size, VoidPtr out_values);
+
+  boolean GetAttributeFloat([Ref, Const] PointAttribute pa,
+                            long att_index,
+                            DracoFloat32Array out_values);
+
+  boolean GetAttributeFloatForAllPoints([Ref, Const] PointCloud pc,
+                                        [Ref, Const] PointAttribute pa,
+                                        DracoFloat32Array out_values);
+
+  // Deprecated, use GetAttributeInt32ForAllPoints instead.
+  boolean GetAttributeIntForAllPoints([Ref, Const] PointCloud pc,
+                                      [Ref, Const] PointAttribute pa,
+                                      DracoInt32Array out_values);
+
+  boolean GetAttributeInt8ForAllPoints([Ref, Const] PointCloud pc,
+                                       [Ref, Const] PointAttribute pa,
+                                       DracoInt8Array out_values);
+  boolean GetAttributeUInt8ForAllPoints([Ref, Const] PointCloud pc,
+                                        [Ref, Const] PointAttribute pa,
+                                        DracoUInt8Array out_values);
+  boolean GetAttributeInt16ForAllPoints([Ref, Const] PointCloud pc,
+                                        [Ref, Const] PointAttribute pa,
+                                        DracoInt16Array out_values);
+  boolean GetAttributeUInt16ForAllPoints([Ref, Const] PointCloud pc,
+                                         [Ref, Const] PointAttribute pa,
+                                         DracoUInt16Array out_values);
+  boolean GetAttributeInt32ForAllPoints([Ref, Const] PointCloud pc,
+                                        [Ref, Const] PointAttribute pa,
+                                        DracoInt32Array out_values);
+  boolean GetAttributeUInt32ForAllPoints([Ref, Const] PointCloud pc,
+                                         [Ref, Const] PointAttribute pa,
+                                         DracoUInt32Array out_values);
+
+  boolean GetAttributeDataArrayForAllPoints([Ref, Const] PointCloud pc,
+                                            [Ref, Const] PointAttribute pa,
+                                            draco_DataType data_type,
+                                            long out_size, VoidPtr out_values);
+
+  void SkipAttributeTransform(draco_GeometryAttribute_Type att_type);
+
+  // Deprecated: Use decoder.GetEncodedGeometryType(array) instead, where
+  //             |array| is an Int8Array containing the encoded data.
+  draco_EncodedGeometryType GetEncodedGeometryType_Deprecated(
+                                DecoderBuffer in_buffer);
+
+  // Deprecated: UseDecodeArrayToPointCloud instead.
+  [Const] Status DecodeBufferToPointCloud(DecoderBuffer in_buffer,
+                                          PointCloud out_point_cloud);
+  // Deprecated: UseDecodeArrayToMesh instead.
+  [Const] Status DecodeBufferToMesh(DecoderBuffer in_buffer, Mesh out_mesh);
+};
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_web_encoder.idl b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_web_encoder.idl
new file mode 100644
index 000000000..d3261b18e
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/draco_web_encoder.idl
@@ -0,0 +1,208 @@
+// Interface exposed to emscripten's WebIDL Binder.
+// http://kripken.github.io/emscripten-site/docs/porting/connecting_cpp_and_javascript/WebIDL-Binder.html
+enum draco_GeometryAttribute_Type {
+  "draco_GeometryAttribute::INVALID",
+  "draco_GeometryAttribute::POSITION",
+  "draco_GeometryAttribute::NORMAL",
+  "draco_GeometryAttribute::COLOR",
+  "draco_GeometryAttribute::TEX_COORD",
+  "draco_GeometryAttribute::GENERIC"
+};
+
+[Prefix="draco::"]
+interface GeometryAttribute {
+  void GeometryAttribute();
+};
+
+enum draco_EncodedGeometryType {
+  "draco::INVALID_GEOMETRY_TYPE",
+  "draco::POINT_CLOUD",
+  "draco::TRIANGULAR_MESH"
+};
+
+enum draco_MeshEncoderMethod {
+  "draco::MESH_SEQUENTIAL_ENCODING",
+  "draco::MESH_EDGEBREAKER_ENCODING"
+};
+
+[Prefix="draco::"]
+interface PointAttribute {
+  void PointAttribute();
+  long size();
+
+  // From GeometryAttribute
+  long attribute_type();
+  long data_type();
+  byte num_components();
+  boolean normalized();
+  long byte_stride();
+  long byte_offset();
+  long unique_id();
+};
+
+[Prefix="draco::"]
+interface PointCloud {
+  void PointCloud();
+
+  long num_attributes();
+  long num_points();
+};
+
+[Prefix="draco::"]
+interface Mesh : PointCloud {
+  void Mesh();
+  long num_faces();
+
+  // From PointCloud
+  long num_attributes();
+  long num_points();
+  void set_num_points(long num_points);
+};
+
+[Prefix="draco::"]
+interface Metadata {
+  void Metadata();
+};
+
+interface DracoInt8Array {
+  void DracoInt8Array();
+  long GetValue(long index);
+  long size();
+};
+
+interface MetadataBuilder {
+  void MetadataBuilder();
+
+  boolean AddStringEntry(Metadata metadata,
+                         [Const] DOMString entry_name,
+                         [Const] DOMString entry_value);
+  boolean AddIntEntry(Metadata metadata,
+                      [Const] DOMString entry_name,
+                      long entry_value);
+  boolean AddIntEntryArray(Metadata metadata,
+                          [Const] DOMString entry_name,
+                          [Const] long[] att_values,
+                          long num_values);
+  boolean AddDoubleEntry(Metadata metadata,
+                         [Const] DOMString entry_name,
+                         double entry_value);
+};
+
+interface PointCloudBuilder {
+  void PointCloudBuilder();
+  long AddFloatAttribute(PointCloud pc, draco_GeometryAttribute_Type type,
+                         long num_vertices, long num_components,
+                         [Const] float[] att_values);
+  long AddInt8Attribute(PointCloud pc, draco_GeometryAttribute_Type type,
+                        long num_vertices, long num_components,
+                        [Const] byte[] att_values);
+  long AddUInt8Attribute(PointCloud pc, draco_GeometryAttribute_Type type,
+                         long num_vertices, long num_components,
+                         [Const] octet[] att_values);
+  long AddInt16Attribute(PointCloud pc, draco_GeometryAttribute_Type type,
+                         long num_vertices, long num_components,
+                         [Const] short[] att_values);
+  long AddUInt16Attribute(PointCloud pc, draco_GeometryAttribute_Type type,
+                          long num_vertices, long num_components,
+                          [Const] unsigned short[] att_values);
+  long AddInt32Attribute(PointCloud pc, draco_GeometryAttribute_Type type,
+                         long num_vertices, long num_components,
+                         [Const] long[] att_values);
+  long AddUInt32Attribute(PointCloud pc, draco_GeometryAttribute_Type type,
+                          long num_vertices, long num_components,
+                          [Const] unsigned long[] att_values);
+
+  boolean AddMetadata(PointCloud pc, [Const] Metadata metadata);
+  boolean SetMetadataForAttribute(PointCloud pc, long attribute_id,
+                                  [Const] Metadata metadata);
+};
+
+interface MeshBuilder : PointCloudBuilder {
+  void MeshBuilder();
+
+  boolean AddFacesToMesh(Mesh mesh, long num_faces, [Const] long[] faces);
+
+  // Deprecated.
+  long AddFloatAttributeToMesh(Mesh mesh, draco_GeometryAttribute_Type type,
+                               long num_vertices, long num_components,
+                               [Const] float[] att_values);
+  // Deprecated.
+  long AddInt32AttributeToMesh(Mesh mesh, draco_GeometryAttribute_Type type,
+                               long num_vertices, long num_components,
+                               [Const] long[] att_values);
+  // Deprecated.
+  boolean AddMetadataToMesh(Mesh mesh, [Const] Metadata metadata);
+
+  // From PointCloudBuilder
+  long AddFloatAttribute(PointCloud pc, draco_GeometryAttribute_Type type,
+                         long num_vertices, long num_components,
+                         [Const] float[] att_values);
+  long AddInt8Attribute(PointCloud pc, draco_GeometryAttribute_Type type,
+                        long num_vertices, long num_components,
+                        [Const] byte[] att_values);
+  long AddUInt8Attribute(PointCloud pc, draco_GeometryAttribute_Type type,
+                         long num_vertices, long num_components,
+                         [Const] octet[] att_values);
+  long AddInt16Attribute(PointCloud pc, draco_GeometryAttribute_Type type,
+                         long num_vertices, long num_components,
+                         [Const] short[] att_values);
+  long AddUInt16Attribute(PointCloud pc, draco_GeometryAttribute_Type type,
+                          long num_vertices, long num_components,
+                          [Const] unsigned short[] att_values);
+  long AddInt32Attribute(PointCloud pc, draco_GeometryAttribute_Type type,
+                         long num_vertices, long num_components,
+                         [Const] long[] att_values);
+  long AddUInt32Attribute(PointCloud pc, draco_GeometryAttribute_Type type,
+                          long num_vertices, long num_components,
+                          [Const] unsigned long[] att_values);
+
+  boolean AddMetadata(PointCloud pc, [Const] Metadata metadata);
+  boolean SetMetadataForAttribute(PointCloud pc, long attribute_id,
+                                  [Const] Metadata metadata);
+};
+
+interface Encoder {
+  void Encoder();
+  void SetEncodingMethod(long method);
+  void SetAttributeQuantization(draco_GeometryAttribute_Type type,
+                                long quantization_bits);
+  void SetAttributeExplicitQuantization(draco_GeometryAttribute_Type type,
+                                        long quantization_bits,
+                                        long num_components,
+                                        [Const] float[] origin,
+                                        float range);
+  void SetSpeedOptions(long encoding_speed, long decoding_speed);
+  void SetTrackEncodedProperties(boolean flag);
+
+  long EncodeMeshToDracoBuffer(Mesh mesh,
+                               DracoInt8Array encoded_data);
+  long EncodePointCloudToDracoBuffer(PointCloud pc, boolean deduplicate_values,
+                                     DracoInt8Array encoded_data);
+
+  // Returns the number of encoded points or faces from the last Encode
+  // operation. Returns 0 if SetTrackEncodedProperties was not set to true.
+  long GetNumberOfEncodedPoints();
+  long GetNumberOfEncodedFaces();
+};
+
+interface ExpertEncoder {
+  void ExpertEncoder(PointCloud pc);
+  void SetEncodingMethod(long method);
+  void SetAttributeQuantization(long att_id,
+                                long quantization_bits);
+  void SetAttributeExplicitQuantization(long att_id,
+                                        long quantization_bits,
+                                        long num_components,
+                                        [Const] float[] origin,
+                                        float range);
+  void SetSpeedOptions(long encoding_speed, long decoding_speed);
+  void SetTrackEncodedProperties(boolean flag);
+
+  long EncodeToDracoBuffer(boolean deduplicate_values,
+                           DracoInt8Array encoded_data);
+
+  // Returns the number of encoded points or faces from the last Encode
+  // operation. Returns 0 if SetTrackEncodedProperties was not set to true.
+  long GetNumberOfEncodedPoints();
+  long GetNumberOfEncodedFaces();
+};
\ No newline at end of file
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/encoder_webidl_wrapper.cc b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/encoder_webidl_wrapper.cc
new file mode 100644
index 000000000..0a1ff7cdb
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/encoder_webidl_wrapper.cc
@@ -0,0 +1,359 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/javascript/emscripten/encoder_webidl_wrapper.h"
+
+#include "draco/compression/encode.h"
+#include "draco/mesh/mesh.h"
+
+DracoInt8Array::DracoInt8Array() {}
+
+int8_t DracoInt8Array::GetValue(int index) const { return values_[index]; }
+
+bool DracoInt8Array::SetValues(const char *values, int count) {
+  values_.assign(values, values + count);
+  return true;
+}
+
+using draco::Mesh;
+using draco::Metadata;
+using draco::PointCloud;
+
+MetadataBuilder::MetadataBuilder() {}
+
+bool MetadataBuilder::AddStringEntry(Metadata *metadata, const char *entry_name,
+                                     const char *entry_value) {
+  if (!metadata) {
+    return false;
+  }
+  const std::string name{entry_name};
+  const std::string value{entry_value};
+  metadata->AddEntryString(entry_name, entry_value);
+  return true;
+}
+
+bool MetadataBuilder::AddIntEntry(Metadata *metadata, const char *entry_name,
+                                  long entry_value) {
+  if (!metadata) {
+    return false;
+  }
+  const std::string name{entry_name};
+  metadata->AddEntryInt(name, entry_value);
+  return true;
+}
+
+bool MetadataBuilder::AddIntEntryArray(draco::Metadata *metadata,
+                                       const char *entry_name,
+                                       const int32_t *entry_values,
+                                       int32_t num_values) {
+  if (!metadata) {
+    return false;
+  }
+  const std::string name{entry_name};
+  metadata->AddEntryIntArray(name, {entry_values, entry_values + num_values});
+  return true;
+}
+
+bool MetadataBuilder::AddDoubleEntry(Metadata *metadata, const char *entry_name,
+                                     double entry_value) {
+  if (!metadata) {
+    return false;
+  }
+  const std::string name{entry_name};
+  metadata->AddEntryDouble(name, entry_value);
+  return true;
+}
+
+int PointCloudBuilder::AddFloatAttribute(PointCloud *pc,
+                                         draco_GeometryAttribute_Type type,
+                                         long num_vertices, long num_components,
+                                         const float *att_values) {
+  return AddAttribute(pc, type, num_vertices, num_components, att_values,
+                      draco::DT_FLOAT32);
+}
+
+int PointCloudBuilder::AddInt8Attribute(PointCloud *pc,
+                                        draco_GeometryAttribute_Type type,
+                                        long num_vertices, long num_components,
+                                        const char *att_values) {
+  return AddAttribute(pc, type, num_vertices, num_components, att_values,
+                      draco::DT_INT8);
+}
+
+int PointCloudBuilder::AddUInt8Attribute(PointCloud *pc,
+                                         draco_GeometryAttribute_Type type,
+                                         long num_vertices, long num_components,
+                                         const uint8_t *att_values) {
+  return AddAttribute(pc, type, num_vertices, num_components, att_values,
+                      draco::DT_UINT8);
+}
+
+int PointCloudBuilder::AddInt16Attribute(PointCloud *pc,
+                                         draco_GeometryAttribute_Type type,
+                                         long num_vertices, long num_components,
+                                         const int16_t *att_values) {
+  return AddAttribute(pc, type, num_vertices, num_components, att_values,
+                      draco::DT_INT16);
+}
+
+int PointCloudBuilder::AddUInt16Attribute(PointCloud *pc,
+                                          draco_GeometryAttribute_Type type,
+                                          long num_vertices,
+                                          long num_components,
+                                          const uint16_t *att_values) {
+  return AddAttribute(pc, type, num_vertices, num_components, att_values,
+                      draco::DT_UINT16);
+}
+
+int PointCloudBuilder::AddInt32Attribute(PointCloud *pc,
+                                         draco_GeometryAttribute_Type type,
+                                         long num_vertices, long num_components,
+                                         const int32_t *att_values) {
+  return AddAttribute(pc, type, num_vertices, num_components, att_values,
+                      draco::DT_INT32);
+}
+
+int PointCloudBuilder::AddUInt32Attribute(PointCloud *pc,
+                                          draco_GeometryAttribute_Type type,
+                                          long num_vertices,
+                                          long num_components,
+                                          const uint32_t *att_values) {
+  return AddAttribute(pc, type, num_vertices, num_components, att_values,
+                      draco::DT_UINT32);
+}
+
+bool PointCloudBuilder::AddMetadata(PointCloud *pc, const Metadata *metadata) {
+  if (!pc) {
+    return false;
+  }
+  // Not allow write over metadata.
+  if (pc->metadata()) {
+    return false;
+  }
+  std::unique_ptr<draco::GeometryMetadata> new_metadata =
+      std::unique_ptr<draco::GeometryMetadata>(
+          new draco::GeometryMetadata(*metadata));
+  pc->AddMetadata(std::move(new_metadata));
+  return true;
+}
+
+bool PointCloudBuilder::SetMetadataForAttribute(PointCloud *pc,
+                                                long attribute_id,
+                                                const Metadata *metadata) {
+  if (!pc) {
+    return false;
+  }
+  // If empty metadata, just ignore.
+  if (!metadata) {
+    return false;
+  }
+  if (attribute_id < 0 || attribute_id >= pc->num_attributes()) {
+    return false;
+  }
+
+  if (!pc->metadata()) {
+    std::unique_ptr<draco::GeometryMetadata> geometry_metadata =
+        std::unique_ptr<draco::GeometryMetadata>(new draco::GeometryMetadata());
+    pc->AddMetadata(std::move(geometry_metadata));
+  }
+
+  // Get unique attribute id for the attribute.
+  const long unique_id = pc->attribute(attribute_id)->unique_id();
+
+  std::unique_ptr<draco::AttributeMetadata> att_metadata =
+      std::unique_ptr<draco::AttributeMetadata>(
+          new draco::AttributeMetadata(*metadata));
+  att_metadata->set_att_unique_id(unique_id);
+  pc->metadata()->AddAttributeMetadata(std::move(att_metadata));
+  return true;
+}
+
+MeshBuilder::MeshBuilder() {}
+
+bool MeshBuilder::AddFacesToMesh(Mesh *mesh, long num_faces, const int *faces) {
+  if (!mesh) {
+    return false;
+  }
+  mesh->SetNumFaces(num_faces);
+  for (draco::FaceIndex i(0); i < num_faces; ++i) {
+    draco::Mesh::Face face;
+    face[0] = faces[i.value() * 3];
+    face[1] = faces[i.value() * 3 + 1];
+    face[2] = faces[i.value() * 3 + 2];
+    mesh->SetFace(i, face);
+  }
+  return true;
+}
+
+int MeshBuilder::AddFloatAttributeToMesh(Mesh *mesh,
+                                         draco_GeometryAttribute_Type type,
+                                         long num_vertices, long num_components,
+                                         const float *att_values) {
+  return AddFloatAttribute(mesh, type, num_vertices, num_components,
+                           att_values);
+}
+
+int MeshBuilder::AddInt32AttributeToMesh(draco::Mesh *mesh,
+                                         draco_GeometryAttribute_Type type,
+                                         long num_vertices, long num_components,
+                                         const int32_t *att_values) {
+  return AddInt32Attribute(mesh, type, num_vertices, num_components,
+                           att_values);
+}
+
+bool MeshBuilder::AddMetadataToMesh(Mesh *mesh, const Metadata *metadata) {
+  return AddMetadata(mesh, metadata);
+}
+
+Encoder::Encoder() {}
+
+void Encoder::SetEncodingMethod(long method) {
+  encoder_.SetEncodingMethod(method);
+}
+
+void Encoder::SetAttributeQuantization(draco_GeometryAttribute_Type type,
+                                       long quantization_bits) {
+  encoder_.SetAttributeQuantization(type, quantization_bits);
+}
+
+void Encoder::SetAttributeExplicitQuantization(
+    draco_GeometryAttribute_Type type, long quantization_bits,
+    long num_components, const float *origin, float range) {
+  encoder_.SetAttributeExplicitQuantization(type, quantization_bits,
+                                            num_components, origin, range);
+}
+
+void Encoder::SetSpeedOptions(long encoding_speed, long decoding_speed) {
+  encoder_.SetSpeedOptions(encoding_speed, decoding_speed);
+}
+
+void Encoder::SetTrackEncodedProperties(bool flag) {
+  encoder_.SetTrackEncodedProperties(flag);
+}
+
+int Encoder::EncodeMeshToDracoBuffer(Mesh *mesh, DracoInt8Array *draco_buffer) {
+  if (!mesh) {
+    return 0;
+  }
+  draco::EncoderBuffer buffer;
+  if (mesh->GetNamedAttributeId(draco::GeometryAttribute::POSITION) == -1) {
+    return 0;
+  }
+  if (!mesh->DeduplicateAttributeValues()) {
+    return 0;
+  }
+  mesh->DeduplicatePointIds();
+  if (!encoder_.EncodeMeshToBuffer(*mesh, &buffer).ok()) {
+    return 0;
+  }
+  draco_buffer->SetValues(buffer.data(), buffer.size());
+  return buffer.size();
+}
+
+int Encoder::EncodePointCloudToDracoBuffer(draco::PointCloud *pc,
+                                           bool deduplicate_values,
+                                           DracoInt8Array *draco_buffer) {
+  // TODO(ostava): Refactor common functionality with EncodeMeshToDracoBuffer().
+  if (!pc) {
+    return 0;
+  }
+  draco::EncoderBuffer buffer;
+  if (pc->GetNamedAttributeId(draco::GeometryAttribute::POSITION) == -1) {
+    return 0;
+  }
+  if (deduplicate_values) {
+    if (!pc->DeduplicateAttributeValues()) {
+      return 0;
+    }
+    pc->DeduplicatePointIds();
+  }
+  if (!encoder_.EncodePointCloudToBuffer(*pc, &buffer).ok()) {
+    return 0;
+  }
+  draco_buffer->SetValues(buffer.data(), buffer.size());
+  return buffer.size();
+}
+
+int Encoder::GetNumberOfEncodedPoints() {
+  return encoder_.num_encoded_points();
+}
+
+int Encoder::GetNumberOfEncodedFaces() { return encoder_.num_encoded_faces(); }
+
+ExpertEncoder::ExpertEncoder(PointCloud *pc) : pc_(pc) {
+  // Web-IDL interface does not support constructor overloading so instead we
+  // use RTTI to determine whether the input is a mesh or a point cloud.
+  Mesh *mesh = dynamic_cast<Mesh *>(pc);
+  if (mesh) {
+    encoder_ =
+        std::unique_ptr<draco::ExpertEncoder>(new draco::ExpertEncoder(*mesh));
+  } else {
+    encoder_ =
+        std::unique_ptr<draco::ExpertEncoder>(new draco::ExpertEncoder(*pc));
+  }
+}
+
+void ExpertEncoder::SetEncodingMethod(long method) {
+  encoder_->SetEncodingMethod(method);
+}
+
+void ExpertEncoder::SetAttributeQuantization(long att_id,
+                                             long quantization_bits) {
+  encoder_->SetAttributeQuantization(att_id, quantization_bits);
+}
+
+void ExpertEncoder::SetAttributeExplicitQuantization(long att_id,
+                                                     long quantization_bits,
+                                                     long num_components,
+                                                     const float *origin,
+                                                     float range) {
+  encoder_->SetAttributeExplicitQuantization(att_id, quantization_bits,
+                                             num_components, origin, range);
+}
+
+void ExpertEncoder::SetSpeedOptions(long encoding_speed, long decoding_speed) {
+  encoder_->SetSpeedOptions(encoding_speed, decoding_speed);
+}
+
+void ExpertEncoder::SetTrackEncodedProperties(bool flag) {
+  encoder_->SetTrackEncodedProperties(flag);
+}
+
+int ExpertEncoder::EncodeToDracoBuffer(bool deduplicate_values,
+                                       DracoInt8Array *draco_buffer) {
+  if (!pc_) {
+    return 0;
+  }
+  if (deduplicate_values) {
+    if (!pc_->DeduplicateAttributeValues()) {
+      return 0;
+    }
+    pc_->DeduplicatePointIds();
+  }
+
+  draco::EncoderBuffer buffer;
+  if (!encoder_->EncodeToBuffer(&buffer).ok()) {
+    return 0;
+  }
+  draco_buffer->SetValues(buffer.data(), buffer.size());
+  return buffer.size();
+}
+
+int ExpertEncoder::GetNumberOfEncodedPoints() {
+  return encoder_->num_encoded_points();
+}
+
+int ExpertEncoder::GetNumberOfEncodedFaces() {
+  return encoder_->num_encoded_faces();
+}
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/encoder_webidl_wrapper.h b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/encoder_webidl_wrapper.h
new file mode 100644
index 000000000..b1cce7997
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/encoder_webidl_wrapper.h
@@ -0,0 +1,186 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_JAVASCRIPT_EMSCRIPTEN_ENCODER_WEBIDL_WRAPPER_H_
+#define DRACO_JAVASCRIPT_EMSCRIPTEN_ENCODER_WEBIDL_WRAPPER_H_
+
+#include <vector>
+
+#include "draco/attributes/point_attribute.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/config/encoder_options.h"
+#include "draco/compression/encode.h"
+#include "draco/compression/expert_encode.h"
+#include "draco/mesh/mesh.h"
+
+typedef draco::GeometryAttribute draco_GeometryAttribute;
+typedef draco::GeometryAttribute::Type draco_GeometryAttribute_Type;
+typedef draco::EncodedGeometryType draco_EncodedGeometryType;
+typedef draco::MeshEncoderMethod draco_MeshEncoderMethod;
+
+class DracoInt8Array {
+ public:
+  DracoInt8Array();
+  int8_t GetValue(int index) const;
+  bool SetValues(const char *values, int count);
+
+  size_t size() { return values_.size(); }
+
+ private:
+  std::vector<int8_t> values_;
+};
+
+class MetadataBuilder {
+ public:
+  MetadataBuilder();
+  bool AddStringEntry(draco::Metadata *metadata, const char *entry_name,
+                      const char *entry_value);
+  bool AddIntEntry(draco::Metadata *metadata, const char *entry_name,
+                   long entry_value);
+  bool AddIntEntryArray(draco::Metadata *metadata, const char *entry_name,
+                        const int32_t *entry_values, int32_t num_values);
+  bool AddDoubleEntry(draco::Metadata *metadata, const char *entry_name,
+                      double entry_value);
+};
+
+class PointCloudBuilder {
+ public:
+  PointCloudBuilder() {}
+  int AddFloatAttribute(draco::PointCloud *pc,
+                        draco_GeometryAttribute_Type type, long num_vertices,
+                        long num_components, const float *att_values);
+  int AddInt8Attribute(draco::PointCloud *pc, draco_GeometryAttribute_Type type,
+                       long num_vertices, long num_components,
+                       const char *att_values);
+  int AddUInt8Attribute(draco::PointCloud *pc,
+                        draco_GeometryAttribute_Type type, long num_vertices,
+                        long num_components, const uint8_t *att_values);
+  int AddInt16Attribute(draco::PointCloud *pc,
+                        draco_GeometryAttribute_Type type, long num_vertices,
+                        long num_components, const int16_t *att_values);
+  int AddUInt16Attribute(draco::PointCloud *pc,
+                         draco_GeometryAttribute_Type type, long num_vertices,
+                         long num_components, const uint16_t *att_values);
+  int AddInt32Attribute(draco::PointCloud *pc,
+                        draco_GeometryAttribute_Type type, long num_vertices,
+                        long num_components, const int32_t *att_values);
+  int AddUInt32Attribute(draco::PointCloud *pc,
+                         draco_GeometryAttribute_Type type, long num_vertices,
+                         long num_components, const uint32_t *att_values);
+  bool SetMetadataForAttribute(draco::PointCloud *pc, long attribute_id,
+                               const draco::Metadata *metadata);
+  bool AddMetadata(draco::PointCloud *pc, const draco::Metadata *metadata);
+
+ private:
+  template <typename DataTypeT>
+  int AddAttribute(draco::PointCloud *pc, draco_GeometryAttribute_Type type,
+                   long num_vertices, long num_components,
+                   const DataTypeT *att_values,
+                   draco::DataType draco_data_type) {
+    if (!pc) {
+      return -1;
+    }
+    std::unique_ptr<draco::PointAttribute> att(new draco::PointAttribute());
+    att->Init(type, num_components, draco_data_type,
+              /* normalized */ false, num_vertices);
+    const int att_id = pc->AddAttribute(std::move(att));
+    draco::PointAttribute *const att_ptr = pc->attribute(att_id);
+
+    for (draco::PointIndex i(0); i < num_vertices; ++i) {
+      att_ptr->SetAttributeValue(att_ptr->mapped_index(i),
+                                 &att_values[i.value() * num_components]);
+    }
+    if (pc->num_points() == 0) {
+      pc->set_num_points(num_vertices);
+    } else if (pc->num_points() != num_vertices) {
+      return -1;
+    }
+    return att_id;
+  }
+};
+
+// TODO(draco-eng): Regenerate wasm decoder.
+// TODO(draco-eng): Add script to generate and test all Javascipt code.
+class MeshBuilder : public PointCloudBuilder {
+ public:
+  MeshBuilder();
+
+  bool AddFacesToMesh(draco::Mesh *mesh, long num_faces, const int *faces);
+
+  // Deprecated: Use AddFloatAttribute() instead.
+  int AddFloatAttributeToMesh(draco::Mesh *mesh,
+                              draco_GeometryAttribute_Type type,
+                              long num_vertices, long num_components,
+                              const float *att_values);
+
+  // Deprecated: Use AddInt32Attribute() instead.
+  int AddInt32AttributeToMesh(draco::Mesh *mesh,
+                              draco_GeometryAttribute_Type type,
+                              long num_vertices, long num_components,
+                              const int32_t *att_values);
+
+  // Deprecated: Use AddMetadata() instead.
+  bool AddMetadataToMesh(draco::Mesh *mesh, const draco::Metadata *metadata);
+};
+
+class Encoder {
+ public:
+  Encoder();
+
+  void SetEncodingMethod(long method);
+  void SetAttributeQuantization(draco_GeometryAttribute_Type type,
+                                long quantization_bits);
+  void SetAttributeExplicitQuantization(draco_GeometryAttribute_Type type,
+                                        long quantization_bits,
+                                        long num_components,
+                                        const float *origin, float range);
+  void SetSpeedOptions(long encoding_speed, long decoding_speed);
+  void SetTrackEncodedProperties(bool flag);
+
+  int EncodeMeshToDracoBuffer(draco::Mesh *mesh, DracoInt8Array *buffer);
+
+  int EncodePointCloudToDracoBuffer(draco::PointCloud *pc,
+                                    bool deduplicate_values,
+                                    DracoInt8Array *buffer);
+  int GetNumberOfEncodedPoints();
+  int GetNumberOfEncodedFaces();
+
+ private:
+  draco::Encoder encoder_;
+};
+
+class ExpertEncoder {
+ public:
+  ExpertEncoder(draco::PointCloud *pc);
+
+  void SetEncodingMethod(long method);
+  void SetAttributeQuantization(long att_id, long quantization_bits);
+  void SetAttributeExplicitQuantization(long att_id, long quantization_bits,
+                                        long num_components,
+                                        const float *origin, float range);
+  void SetSpeedOptions(long encoding_speed, long decoding_speed);
+  void SetTrackEncodedProperties(bool flag);
+
+  int EncodeToDracoBuffer(bool deduplicate_values, DracoInt8Array *buffer);
+
+  int GetNumberOfEncodedPoints();
+  int GetNumberOfEncodedFaces();
+
+ private:
+  std::unique_ptr<draco::ExpertEncoder> encoder_;
+
+  draco::PointCloud *pc_;
+};
+
+#endif  // DRACO_JAVASCRIPT_EMSCRIPTEN_ENCODER_WEBIDL_WRAPPER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/finalize.js b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/finalize.js
new file mode 100644
index 000000000..fe2828e58
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/finalize.js
@@ -0,0 +1,22 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Calls the 'onModuleParsed' callback if provided. This file is included as the
+// last one in the generated javascript and it gives the caller a way to check
+// that all previous content was successfully processed.
+// Note: emscripten's |onRuntimeInitialized| is called before any --post-js
+// files are included which is not equivalent to this callback.
+if (typeof Module['onModuleParsed'] === 'function') {
+  Module['onModuleParsed']();
+}
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/prepareCallbacks.js b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/prepareCallbacks.js
new file mode 100644
index 000000000..7e150bb3e
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/prepareCallbacks.js
@@ -0,0 +1,38 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Prepares callbacks that can be used to inform the caller that the module has
+// been fully loaded.
+var isRuntimeInitialized = false;
+var isModuleParsed = false;
+
+// These two callbacks can be called in arbitrary order. We call the final
+// function |onModuleLoaded| after both of these callbacks have been called.
+Module['onRuntimeInitialized'] = function() {
+  isRuntimeInitialized = true;
+  if (isModuleParsed) {
+    if (typeof Module['onModuleLoaded'] === 'function') {
+      Module['onModuleLoaded'](Module);
+    }
+  }
+};
+
+Module['onModuleParsed'] = function() {
+  isModuleParsed = true;
+  if (isRuntimeInitialized) {
+    if (typeof Module['onModuleLoaded'] === 'function') {
+      Module['onModuleLoaded'](Module);
+    }
+  }
+};
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/version.js b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/version.js
new file mode 100644
index 000000000..46fb25271
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/javascript/emscripten/version.js
@@ -0,0 +1,29 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Returns true if the specified Draco version is supported by this decoder.
+function isVersionSupported(versionString) {
+  if (typeof versionString !== 'string')
+    return false;
+  const version = versionString.split('.');
+  if (version.length < 2 || version.length > 3)
+    return false;  // Unexpected version string.
+  if (version[0] == 1 && version[1] >= 0 && version[1] <= 4)
+    return true;
+  if (version[0] != 0 || version[1] > 10)
+    return false;
+  return true;
+}
+
+Module['isVersionSupported'] = isVersionSupported;
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/maya/draco_maya_plugin.cc b/Engine/lib/assimp/contrib/draco/src/draco/maya/draco_maya_plugin.cc
new file mode 100644
index 000000000..25b0240b2
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/maya/draco_maya_plugin.cc
@@ -0,0 +1,265 @@
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/maya/draco_maya_plugin.h"
+
+#ifdef DRACO_MAYA_PLUGIN
+
+namespace draco {
+namespace maya {
+
+static void decode_faces(std::unique_ptr<draco::Mesh> &drc_mesh,
+                         Drc2PyMesh *out_mesh) {
+  int num_faces = drc_mesh->num_faces();
+  out_mesh->faces = new int[num_faces * 3];
+  out_mesh->faces_num = num_faces;
+  for (int i = 0; i < num_faces; i++) {
+    const draco::Mesh::Face &face = drc_mesh->face(draco::FaceIndex(i));
+    out_mesh->faces[i * 3 + 0] = face[0].value();
+    out_mesh->faces[i * 3 + 1] = face[1].value();
+    out_mesh->faces[i * 3 + 2] = face[2].value();
+  }
+}
+static void decode_vertices(std::unique_ptr<draco::Mesh> &drc_mesh,
+                            Drc2PyMesh *out_mesh) {
+  const auto pos_att =
+      drc_mesh->GetNamedAttribute(draco::GeometryAttribute::POSITION);
+  if (pos_att == nullptr) {
+    out_mesh->vertices = new float[0];
+    out_mesh->vertices_num = 0;
+    return;
+  }
+
+  int num_vertices = drc_mesh->num_points();
+  out_mesh->vertices = new float[num_vertices * 3];
+  out_mesh->vertices_num = num_vertices;
+  for (int i = 0; i < num_vertices; i++) {
+    draco::PointIndex pi(i);
+    const draco::AttributeValueIndex val_index = pos_att->mapped_index(pi);
+    float out_vertex[3];
+    bool is_ok = pos_att->ConvertValue<float, 3>(val_index, out_vertex);
+    if (!is_ok) return;
+    out_mesh->vertices[i * 3 + 0] = out_vertex[0];
+    out_mesh->vertices[i * 3 + 1] = out_vertex[1];
+    out_mesh->vertices[i * 3 + 2] = out_vertex[2];
+  }
+}
+static void decode_normals(std::unique_ptr<draco::Mesh> &drc_mesh,
+                           Drc2PyMesh *out_mesh) {
+  const auto normal_att =
+      drc_mesh->GetNamedAttribute(draco::GeometryAttribute::NORMAL);
+  if (normal_att == nullptr) {
+    out_mesh->normals = new float[0];
+    out_mesh->normals_num = 0;
+    return;
+  }
+  int num_normals = drc_mesh->num_points();
+  out_mesh->normals = new float[num_normals * 3];
+  out_mesh->normals_num = num_normals;
+
+  for (int i = 0; i < num_normals; i++) {
+    draco::PointIndex pi(i);
+    const draco::AttributeValueIndex val_index = normal_att->mapped_index(pi);
+    float out_normal[3];
+    bool is_ok = normal_att->ConvertValue<float, 3>(val_index, out_normal);
+    if (!is_ok) return;
+    out_mesh->normals[i * 3 + 0] = out_normal[0];
+    out_mesh->normals[i * 3 + 1] = out_normal[1];
+    out_mesh->normals[i * 3 + 2] = out_normal[2];
+  }
+}
+static void decode_uvs(std::unique_ptr<draco::Mesh> &drc_mesh,
+                       Drc2PyMesh *out_mesh) {
+  const auto uv_att =
+      drc_mesh->GetNamedAttribute(draco::GeometryAttribute::TEX_COORD);
+  if (uv_att == nullptr) {
+    out_mesh->uvs = new float[0];
+    out_mesh->uvs_num = 0;
+    out_mesh->uvs_real_num = 0;
+    return;
+  }
+  int num_uvs = drc_mesh->num_points();
+  out_mesh->uvs = new float[num_uvs * 2];
+  out_mesh->uvs_num = num_uvs;
+  out_mesh->uvs_real_num = uv_att->size();
+
+  for (int i = 0; i < num_uvs; i++) {
+    draco::PointIndex pi(i);
+    const draco::AttributeValueIndex val_index = uv_att->mapped_index(pi);
+    float out_uv[2];
+    bool is_ok = uv_att->ConvertValue<float, 2>(val_index, out_uv);
+    if (!is_ok) return;
+    out_mesh->uvs[i * 2 + 0] = out_uv[0];
+    out_mesh->uvs[i * 2 + 1] = out_uv[1];
+  }
+}
+
+void drc2py_free(Drc2PyMesh **mesh_ptr) {
+  Drc2PyMesh *mesh = *mesh_ptr;
+  if (!mesh) return;
+  if (mesh->faces) {
+    delete[] mesh->faces;
+    mesh->faces = nullptr;
+    mesh->faces_num = 0;
+  }
+  if (mesh->vertices) {
+    delete[] mesh->vertices;
+    mesh->vertices = nullptr;
+    mesh->vertices_num = 0;
+  }
+  if (mesh->normals) {
+    delete[] mesh->normals;
+    mesh->normals = nullptr;
+    mesh->normals_num = 0;
+  }
+  if (mesh->uvs) {
+    delete[] mesh->uvs;
+    mesh->uvs = nullptr;
+    mesh->uvs_num = 0;
+  }
+  delete mesh;
+  *mesh_ptr = nullptr;
+}
+
+DecodeResult drc2py_decode(char *data, unsigned int length,
+                           Drc2PyMesh **res_mesh) {
+  draco::DecoderBuffer buffer;
+  buffer.Init(data, length);
+  auto type_statusor = draco::Decoder::GetEncodedGeometryType(&buffer);
+  if (!type_statusor.ok()) {
+    return DecodeResult::KO_GEOMETRY_TYPE_INVALID;
+  }
+  const draco::EncodedGeometryType geom_type = type_statusor.value();
+  if (geom_type != draco::TRIANGULAR_MESH) {
+    return DecodeResult::KO_TRIANGULAR_MESH_NOT_FOUND;
+  }
+
+  draco::Decoder decoder;
+  auto statusor = decoder.DecodeMeshFromBuffer(&buffer);
+  if (!statusor.ok()) {
+    return DecodeResult::KO_MESH_DECODING;
+  }
+  std::unique_ptr<draco::Mesh> drc_mesh = std::move(statusor).value();
+
+  *res_mesh = new Drc2PyMesh();
+  decode_faces(drc_mesh, *res_mesh);
+  decode_vertices(drc_mesh, *res_mesh);
+  decode_normals(drc_mesh, *res_mesh);
+  decode_uvs(drc_mesh, *res_mesh);
+  return DecodeResult::OK;
+}
+
+// As encode references see https://github.com/google/draco/issues/116
+EncodeResult drc2py_encode(Drc2PyMesh *in_mesh, char *file_path) {
+  if (in_mesh->faces_num == 0) return EncodeResult::KO_WRONG_INPUT;
+  if (in_mesh->vertices_num == 0) return EncodeResult::KO_WRONG_INPUT;
+  // TODO: Add check to protect against quad faces. At the moment only
+  // Triangular faces are supported
+
+  std::unique_ptr<draco::Mesh> drc_mesh(new draco::Mesh());
+
+  // Marshall Faces
+  int num_faces = in_mesh->faces_num;
+  drc_mesh->SetNumFaces(num_faces);
+  for (int i = 0; i < num_faces; ++i) {
+    Mesh::Face face;
+    face[0] = in_mesh->faces[i * 3 + 0];
+    face[1] = in_mesh->faces[i * 3 + 1];
+    face[2] = in_mesh->faces[i * 3 + 2];
+    drc_mesh->SetFace(FaceIndex(i), face);
+  }
+
+  // Marshall Vertices
+  int num_points = in_mesh->vertices_num;
+  drc_mesh->set_num_points(num_points);
+  GeometryAttribute va;
+  va.Init(GeometryAttribute::POSITION, nullptr, 3, DT_FLOAT32, false,
+          sizeof(float) * 3, 0);
+  int pos_att_id = drc_mesh->AddAttribute(va, true, num_points);
+  float point[3];
+  for (int i = 0; i < num_points; ++i) {
+    point[0] = in_mesh->vertices[i * 3 + 0];
+    point[1] = in_mesh->vertices[i * 3 + 1];
+    point[2] = in_mesh->vertices[i * 3 + 2];
+    drc_mesh->attribute(pos_att_id)
+        ->SetAttributeValue(AttributeValueIndex(i), point);
+  }
+
+  // Marshall Normals
+  int num_normals = in_mesh->normals_num;
+  int norm_att_id;
+  if (num_normals > 0) {
+    GeometryAttribute va;
+    va.Init(GeometryAttribute::NORMAL, nullptr, 3, DT_FLOAT32, false,
+            sizeof(float) * 3, 0);
+    norm_att_id = drc_mesh->AddAttribute(va, true, num_normals);
+
+    float norm[3];
+    for (int i = 0; i < num_normals; ++i) {
+      norm[0] = in_mesh->normals[i * 3 + 0];
+      norm[1] = in_mesh->normals[i * 3 + 1];
+      norm[2] = in_mesh->normals[i * 3 + 2];
+      drc_mesh->attribute(norm_att_id)
+          ->SetAttributeValue(AttributeValueIndex(i), norm);
+    }
+  }
+
+  // Marshall Uvs
+  int num_uvs = in_mesh->uvs_num;
+  int uv_att_id;
+  if (num_uvs > 0) {
+    GeometryAttribute va;
+    va.Init(GeometryAttribute::TEX_COORD, nullptr, 2, DT_FLOAT32, false,
+            sizeof(float) * 2, 0);
+    uv_att_id = drc_mesh->AddAttribute(va, true, num_uvs);
+    float uv[3];
+    for (int i = 0; i < num_uvs; ++i) {
+      uv[0] = in_mesh->uvs[i * 2 + 0];
+      uv[1] = in_mesh->uvs[i * 2 + 1];
+      drc_mesh->attribute(uv_att_id)->SetAttributeValue(AttributeValueIndex(i),
+                                                        uv);
+    }
+  }
+
+// Deduplicate Attributes and Points
+#ifdef DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED
+  drc_mesh->DeduplicateAttributeValues();
+#endif
+#ifdef DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+  drc_mesh->DeduplicatePointIds();
+#endif
+
+  // Encode Mesh
+  draco::Encoder encoder;  // Use default encode settings (See draco_encoder.cc
+                           // Options struct)
+  draco::EncoderBuffer buffer;
+  const draco::Status status = encoder.EncodeMeshToBuffer(*drc_mesh, &buffer);
+  if (!status.ok()) {
+    // Use status.error_msg() to check the error
+    return EncodeResult::KO_MESH_ENCODING;
+  }
+
+  // Save to file
+  std::string file = file_path;
+  std::ofstream out_file(file, std::ios::binary);
+  if (!out_file) {
+    return EncodeResult::KO_FILE_CREATION;
+  }
+  out_file.write(buffer.data(), buffer.size());
+  return EncodeResult::OK;
+}
+
+}  // namespace maya
+
+}  // namespace draco
+
+#endif  // DRACO_MAYA_PLUGIN
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/maya/draco_maya_plugin.h b/Engine/lib/assimp/contrib/draco/src/draco/maya/draco_maya_plugin.h
new file mode 100644
index 000000000..372e25fbf
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/maya/draco_maya_plugin.h
@@ -0,0 +1,81 @@
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MAYA_DRACO_MAYA_PLUGIN_H_
+#define DRACO_MAYA_DRACO_MAYA_PLUGIN_H_
+
+#include <fstream>
+
+#include "draco/compression/decode.h"
+#include "draco/compression/encode.h"
+
+#ifdef DRACO_MAYA_PLUGIN
+
+// If compiling with Visual Studio.
+#if defined(_MSC_VER)
+#define EXPORT_API __declspec(dllexport)
+#else
+// Other platforms don't need this.
+#define EXPORT_API
+#endif  // defined(_MSC_VER)
+
+namespace draco {
+namespace maya {
+
+enum class EncodeResult {
+  OK = 0,
+  KO_WRONG_INPUT = -1,
+  KO_MESH_ENCODING = -2,
+  KO_FILE_CREATION = -3
+};
+enum class DecodeResult {
+  OK = 0,
+  KO_GEOMETRY_TYPE_INVALID = -1,
+  KO_TRIANGULAR_MESH_NOT_FOUND = -2,
+  KO_MESH_DECODING = -3
+};
+
+extern "C" {
+struct EXPORT_API Drc2PyMesh {
+  Drc2PyMesh()
+      : faces_num(0),
+        faces(nullptr),
+        vertices_num(0),
+        vertices(nullptr),
+        normals_num(0),
+        normals(nullptr),
+        uvs_num(0),
+        uvs_real_num(0),
+        uvs(nullptr) {}
+  int faces_num;
+  int *faces;
+  int vertices_num;
+  float *vertices;
+  int normals_num;
+  float *normals;
+  int uvs_num;
+  int uvs_real_num;
+  float *uvs;
+};
+
+EXPORT_API DecodeResult drc2py_decode(char *data, unsigned int length,
+                                      Drc2PyMesh **res_mesh);
+EXPORT_API void drc2py_free(Drc2PyMesh **res_mesh);
+EXPORT_API EncodeResult drc2py_encode(Drc2PyMesh *in_mesh, char *file_path);
+}  // extern "C"
+
+}  // namespace maya
+}  // namespace draco
+
+#endif  // DRACO_MAYA_PLUGIN
+
+#endif  // DRACO_MAYA_DRACO_MAYA_PLUGIN_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/mesh/corner_table.cc b/Engine/lib/assimp/contrib/draco/src/draco/mesh/corner_table.cc
new file mode 100644
index 000000000..3f92f651a
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/mesh/corner_table.cc
@@ -0,0 +1,441 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/mesh/corner_table.h"
+
+#include <limits>
+
+#include "draco/attributes/geometry_indices.h"
+#include "draco/mesh/corner_table_iterators.h"
+
+namespace draco {
+
+CornerTable::CornerTable()
+    : num_original_vertices_(0),
+      num_degenerated_faces_(0),
+      num_isolated_vertices_(0),
+      valence_cache_(*this) {}
+
+std::unique_ptr<CornerTable> CornerTable::Create(
+    const IndexTypeVector<FaceIndex, FaceType> &faces) {
+  std::unique_ptr<CornerTable> ct(new CornerTable());
+  if (!ct->Init(faces)) {
+    return nullptr;
+  }
+  return ct;
+}
+
+bool CornerTable::Init(const IndexTypeVector<FaceIndex, FaceType> &faces) {
+  valence_cache_.ClearValenceCache();
+  valence_cache_.ClearValenceCacheInaccurate();
+  corner_to_vertex_map_.resize(faces.size() * 3);
+  for (FaceIndex fi(0); fi < static_cast<uint32_t>(faces.size()); ++fi) {
+    for (int i = 0; i < 3; ++i) {
+      corner_to_vertex_map_[FirstCorner(fi) + i] = faces[fi][i];
+    }
+  }
+  int num_vertices = -1;
+  if (!ComputeOppositeCorners(&num_vertices)) {
+    return false;
+  }
+  if (!BreakNonManifoldEdges()) {
+    return false;
+  }
+  if (!ComputeVertexCorners(num_vertices)) {
+    return false;
+  }
+  return true;
+}
+
+bool CornerTable::Reset(int num_faces) {
+  return Reset(num_faces, num_faces * 3);
+}
+
+bool CornerTable::Reset(int num_faces, int num_vertices) {
+  if (num_faces < 0 || num_vertices < 0) {
+    return false;
+  }
+  const unsigned int num_faces_unsigned = num_faces;
+  if (num_faces_unsigned >
+      std::numeric_limits<CornerIndex::ValueType>::max() / 3) {
+    return false;
+  }
+  corner_to_vertex_map_.assign(num_faces_unsigned * 3, kInvalidVertexIndex);
+  opposite_corners_.assign(num_faces_unsigned * 3, kInvalidCornerIndex);
+  vertex_corners_.reserve(num_vertices);
+  valence_cache_.ClearValenceCache();
+  valence_cache_.ClearValenceCacheInaccurate();
+  return true;
+}
+
+bool CornerTable::ComputeOppositeCorners(int *num_vertices) {
+  DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+  if (num_vertices == nullptr) {
+    return false;
+  }
+  opposite_corners_.resize(num_corners(), kInvalidCornerIndex);
+
+  // Out implementation for finding opposite corners is based on keeping track
+  // of outgoing half-edges for each vertex of the mesh. Half-edges (defined by
+  // their opposite corners) are processed one by one and whenever a new
+  // half-edge (corner) is processed, we check whether the sink vertex of
+  // this half-edge contains its sibling half-edge. If yes, we connect them and
+  // remove the sibling half-edge from the sink vertex, otherwise we add the new
+  // half-edge to its source vertex.
+
+  // First compute the number of outgoing half-edges (corners) attached to each
+  // vertex.
+  std::vector<int> num_corners_on_vertices;
+  num_corners_on_vertices.reserve(num_corners());
+  for (CornerIndex c(0); c < num_corners(); ++c) {
+    const VertexIndex v1 = Vertex(c);
+    if (v1.value() >= static_cast<int>(num_corners_on_vertices.size())) {
+      num_corners_on_vertices.resize(v1.value() + 1, 0);
+    }
+    // For each corner there is always exactly one outgoing half-edge attached
+    // to its vertex.
+    num_corners_on_vertices[v1.value()]++;
+  }
+
+  // Create a storage for half-edges on each vertex. We store all half-edges in
+  // one array, where each entry is identified by the half-edge's sink vertex id
+  // and the associated half-edge corner id (corner opposite to the half-edge).
+  // Each vertex will be assigned storage for up to
+  // |num_corners_on_vertices[vert_id]| half-edges. Unused half-edges are marked
+  // with |sink_vert| == kInvalidVertexIndex.
+  struct VertexEdgePair {
+    VertexEdgePair()
+        : sink_vert(kInvalidVertexIndex), edge_corner(kInvalidCornerIndex) {}
+    VertexIndex sink_vert;
+    CornerIndex edge_corner;
+  };
+  std::vector<VertexEdgePair> vertex_edges(num_corners(), VertexEdgePair());
+
+  // For each vertex compute the offset (location where the first half-edge
+  // entry of a given vertex is going to be stored). This way each vertex is
+  // guaranteed to have a non-overlapping storage with respect to the other
+  // vertices.
+  std::vector<int> vertex_offset(num_corners_on_vertices.size());
+  int offset = 0;
+  for (size_t i = 0; i < num_corners_on_vertices.size(); ++i) {
+    vertex_offset[i] = offset;
+    offset += num_corners_on_vertices[i];
+  }
+
+  // Now go over the all half-edges (using their opposite corners) and either
+  // insert them to the |vertex_edge| array or connect them with existing
+  // half-edges.
+  for (CornerIndex c(0); c < num_corners(); ++c) {
+    const VertexIndex tip_v = Vertex(c);
+    const VertexIndex source_v = Vertex(Next(c));
+    const VertexIndex sink_v = Vertex(Previous(c));
+
+    const FaceIndex face_index = Face(c);
+    if (c == FirstCorner(face_index)) {
+      // Check whether the face is degenerated, if so ignore it.
+      const VertexIndex v0 = Vertex(c);
+      if (v0 == source_v || v0 == sink_v || source_v == sink_v) {
+        ++num_degenerated_faces_;
+        c += 2;  // Ignore the next two corners of the same face.
+        continue;
+      }
+    }
+
+    CornerIndex opposite_c(kInvalidCornerIndex);
+    // The maximum number of half-edges attached to the sink vertex.
+    const int num_corners_on_vert = num_corners_on_vertices[sink_v.value()];
+    // Where to look for the first half-edge on the sink vertex.
+    offset = vertex_offset[sink_v.value()];
+    for (int i = 0; i < num_corners_on_vert; ++i, ++offset) {
+      const VertexIndex other_v = vertex_edges[offset].sink_vert;
+      if (other_v == kInvalidVertexIndex) {
+        break;  // No matching half-edge found on the sink vertex.
+      }
+      if (other_v == source_v) {
+        if (tip_v == Vertex(vertex_edges[offset].edge_corner)) {
+          continue;  // Don't connect mirrored faces.
+        }
+        // A matching half-edge was found on the sink vertex. Mark the
+        // half-edge's opposite corner.
+        opposite_c = vertex_edges[offset].edge_corner;
+        // Remove the half-edge from the sink vertex. We remap all subsequent
+        // half-edges one slot down.
+        // TODO(ostava): This can be optimized a little bit, by remapping only
+        // the half-edge on the last valid slot into the deleted half-edge's
+        // slot.
+        for (int j = i + 1; j < num_corners_on_vert; ++j, ++offset) {
+          vertex_edges[offset] = vertex_edges[offset + 1];
+          if (vertex_edges[offset].sink_vert == kInvalidVertexIndex) {
+            break;  // Unused half-edge reached.
+          }
+        }
+        // Mark the last entry as unused.
+        vertex_edges[offset].sink_vert = kInvalidVertexIndex;
+        break;
+      }
+    }
+    if (opposite_c == kInvalidCornerIndex) {
+      // No opposite corner found. Insert the new edge
+      const int num_corners_on_source_vert =
+          num_corners_on_vertices[source_v.value()];
+      offset = vertex_offset[source_v.value()];
+      for (int i = 0; i < num_corners_on_source_vert; ++i, ++offset) {
+        // Find the first unused half-edge slot on the source vertex.
+        if (vertex_edges[offset].sink_vert == kInvalidVertexIndex) {
+          vertex_edges[offset].sink_vert = sink_v;
+          vertex_edges[offset].edge_corner = c;
+          break;
+        }
+      }
+    } else {
+      // Opposite corner found.
+      opposite_corners_[c] = opposite_c;
+      opposite_corners_[opposite_c] = c;
+    }
+  }
+  *num_vertices = static_cast<int>(num_corners_on_vertices.size());
+  return true;
+}
+
+bool CornerTable::BreakNonManifoldEdges() {
+  // This function detects and breaks non-manifold edges that are caused by
+  // folds in 1-ring neighborhood around a vertex. Non-manifold edges can occur
+  // when the 1-ring surface around a vertex self-intersects in a common edge.
+  // For example imagine a surface around a pivot vertex 0, where the 1-ring
+  // is defined by vertices |1, 2, 3, 1, 4|. The surface passes edge <0, 1>
+  // twice which would result in a non-manifold edge that needs to be broken.
+  // For now all faces connected to these non-manifold edges are disconnected
+  // resulting in open boundaries on the mesh. New vertices will be created
+  // automatically for each new disjoint patch in the ComputeVertexCorners()
+  // method.
+  // Note that all other non-manifold edges are implicitly handled by the
+  // function ComputeVertexCorners() that automatically creates new vertices
+  // on disjoint 1-ring surface patches.
+
+  std::vector<bool> visited_corners(num_corners(), false);
+  std::vector<std::pair<VertexIndex, CornerIndex>> sink_vertices;
+  bool mesh_connectivity_updated = false;
+  do {
+    mesh_connectivity_updated = false;
+    for (CornerIndex c(0); c < num_corners(); ++c) {
+      if (visited_corners[c.value()]) {
+        continue;
+      }
+      sink_vertices.clear();
+
+      // First swing all the way to find the left-most corner connected to the
+      // corner's vertex.
+      CornerIndex first_c = c;
+      CornerIndex current_c = c;
+      CornerIndex next_c;
+      while (next_c = SwingLeft(current_c),
+             next_c != first_c && next_c != kInvalidCornerIndex &&
+                 !visited_corners[next_c.value()]) {
+        current_c = next_c;
+      }
+
+      first_c = current_c;
+
+      // Swing right from the first corner and check if all visited edges
+      // are unique.
+      do {
+        visited_corners[current_c.value()] = true;
+        // Each new edge is defined by the pivot vertex (that is the same for
+        // all faces) and by the sink vertex (that is the |next| vertex from the
+        // currently processed pivot corner. I.e., each edge is uniquely defined
+        // by the sink vertex index.
+        const CornerIndex sink_c = Next(current_c);
+        const VertexIndex sink_v = corner_to_vertex_map_[sink_c];
+
+        // Corner that defines the edge on the face.
+        const CornerIndex edge_corner = Previous(current_c);
+        bool vertex_connectivity_updated = false;
+        // Go over all processed edges (sink vertices). If the current sink
+        // vertex has been already encountered before it may indicate a
+        // non-manifold edge that needs to be broken.
+        for (auto &&attached_sink_vertex : sink_vertices) {
+          if (attached_sink_vertex.first == sink_v) {
+            // Sink vertex has been already processed.
+            const CornerIndex other_edge_corner = attached_sink_vertex.second;
+            const CornerIndex opp_edge_corner = Opposite(edge_corner);
+
+            if (opp_edge_corner == other_edge_corner) {
+              // We are closing the loop so no need to change the connectivity.
+              continue;
+            }
+
+            // Break the connectivity on the non-manifold edge.
+            // TODO(ostava): It may be possible to reconnect the faces in a way
+            // that the final surface would be manifold.
+            const CornerIndex opp_other_edge_corner =
+                Opposite(other_edge_corner);
+            if (opp_edge_corner != kInvalidCornerIndex) {
+              SetOppositeCorner(opp_edge_corner, kInvalidCornerIndex);
+            }
+            if (opp_other_edge_corner != kInvalidCornerIndex) {
+              SetOppositeCorner(opp_other_edge_corner, kInvalidCornerIndex);
+            }
+
+            SetOppositeCorner(edge_corner, kInvalidCornerIndex);
+            SetOppositeCorner(other_edge_corner, kInvalidCornerIndex);
+
+            vertex_connectivity_updated = true;
+            break;
+          }
+        }
+        if (vertex_connectivity_updated) {
+          // Because of the updated connectivity, not all corners connected to
+          // this vertex have been processed and we need to go over them again.
+          // TODO(ostava): This can be optimized as we don't really need to
+          // iterate over all corners.
+          mesh_connectivity_updated = true;
+          break;
+        }
+        // Insert new sink vertex information <sink vertex index, edge corner>.
+        std::pair<VertexIndex, CornerIndex> new_sink_vert;
+        new_sink_vert.first = corner_to_vertex_map_[Previous(current_c)];
+        new_sink_vert.second = sink_c;
+        sink_vertices.push_back(new_sink_vert);
+
+        current_c = SwingRight(current_c);
+      } while (current_c != first_c && current_c != kInvalidCornerIndex);
+    }
+  } while (mesh_connectivity_updated);
+  return true;
+}
+
+bool CornerTable::ComputeVertexCorners(int num_vertices) {
+  DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+  num_original_vertices_ = num_vertices;
+  vertex_corners_.resize(num_vertices, kInvalidCornerIndex);
+  // Arrays for marking visited vertices and corners that allow us to detect
+  // non-manifold vertices.
+  std::vector<bool> visited_vertices(num_vertices, false);
+  std::vector<bool> visited_corners(num_corners(), false);
+
+  for (FaceIndex f(0); f < num_faces(); ++f) {
+    const CornerIndex first_face_corner = FirstCorner(f);
+    // Check whether the face is degenerated. If so ignore it.
+    if (IsDegenerated(f)) {
+      continue;
+    }
+
+    for (int k = 0; k < 3; ++k) {
+      const CornerIndex c = first_face_corner + k;
+      if (visited_corners[c.value()]) {
+        continue;
+      }
+      VertexIndex v = corner_to_vertex_map_[c];
+      // Note that one vertex maps to many corners, but we just keep track
+      // of the vertex which has a boundary on the left if the vertex lies on
+      // the boundary. This means that all the related corners can be accessed
+      // by iterating over the SwingRight() operator.
+      // In case of a vertex inside the mesh, the choice is arbitrary.
+      bool is_non_manifold_vertex = false;
+      if (visited_vertices[v.value()]) {
+        // A visited vertex of an unvisited corner found. Must be a non-manifold
+        // vertex.
+        // Create a new vertex for it.
+        vertex_corners_.push_back(kInvalidCornerIndex);
+        non_manifold_vertex_parents_.push_back(v);
+        visited_vertices.push_back(false);
+        v = VertexIndex(num_vertices++);
+        is_non_manifold_vertex = true;
+      }
+      // Mark the vertex as visited.
+      visited_vertices[v.value()] = true;
+
+      // First swing all the way to the left and mark all corners on the way.
+      CornerIndex act_c(c);
+      while (act_c != kInvalidCornerIndex) {
+        visited_corners[act_c.value()] = true;
+        // Vertex will eventually point to the left most corner.
+        vertex_corners_[v] = act_c;
+        if (is_non_manifold_vertex) {
+          // Update vertex index in the corresponding face.
+          corner_to_vertex_map_[act_c] = v;
+        }
+        act_c = SwingLeft(act_c);
+        if (act_c == c) {
+          break;  // Full circle reached.
+        }
+      }
+      if (act_c == kInvalidCornerIndex) {
+        // If we have reached an open boundary we need to swing right from the
+        // initial corner to mark all corners in the opposite direction.
+        act_c = SwingRight(c);
+        while (act_c != kInvalidCornerIndex) {
+          visited_corners[act_c.value()] = true;
+          if (is_non_manifold_vertex) {
+            // Update vertex index in the corresponding face.
+            corner_to_vertex_map_[act_c] = v;
+          }
+          act_c = SwingRight(act_c);
+        }
+      }
+    }
+  }
+
+  // Count the number of isolated (unprocessed) vertices.
+  num_isolated_vertices_ = 0;
+  for (bool visited : visited_vertices) {
+    if (!visited) {
+      ++num_isolated_vertices_;
+    }
+  }
+  return true;
+}
+
+bool CornerTable::IsDegenerated(FaceIndex face) const {
+  if (face == kInvalidFaceIndex) {
+    return true;
+  }
+  const CornerIndex first_face_corner = FirstCorner(face);
+  const VertexIndex v0 = Vertex(first_face_corner);
+  const VertexIndex v1 = Vertex(Next(first_face_corner));
+  const VertexIndex v2 = Vertex(Previous(first_face_corner));
+  if (v0 == v1 || v0 == v2 || v1 == v2) {
+    return true;
+  }
+  return false;
+}
+
+int CornerTable::Valence(VertexIndex v) const {
+  if (v == kInvalidVertexIndex) {
+    return -1;
+  }
+  return ConfidentValence(v);
+}
+
+int CornerTable::ConfidentValence(VertexIndex v) const {
+  DRACO_DCHECK_GE(v.value(), 0);
+  DRACO_DCHECK_LT(v.value(), num_vertices());
+  VertexRingIterator<CornerTable> vi(this, v);
+  int valence = 0;
+  for (; !vi.End(); vi.Next()) {
+    ++valence;
+  }
+  return valence;
+}
+
+void CornerTable::UpdateFaceToVertexMap(const VertexIndex vertex) {
+  DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+  VertexCornersIterator<CornerTable> it(this, vertex);
+  for (; !it.End(); ++it) {
+    const CornerIndex corner = *it;
+    corner_to_vertex_map_[corner] = vertex;
+  }
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/mesh/corner_table.h b/Engine/lib/assimp/contrib/draco/src/draco/mesh/corner_table.h
new file mode 100644
index 000000000..3aa720fde
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/mesh/corner_table.h
@@ -0,0 +1,396 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MESH_CORNER_TABLE_H_
+#define DRACO_MESH_CORNER_TABLE_H_
+
+#include <array>
+#include <memory>
+
+#include "draco/attributes/geometry_indices.h"
+#include "draco/core/draco_index_type_vector.h"
+#include "draco/core/macros.h"
+#include "draco/mesh/valence_cache.h"
+
+namespace draco {
+
+// CornerTable is used to represent connectivity of triangular meshes.
+// For every corner of all faces, the corner table stores the index of the
+// opposite corner in the neighboring face (if it exists) as illustrated in the
+// figure below (see corner |c| and it's opposite corner |o|).
+//
+//     *
+//    /c\
+//   /   \
+//  /n   p\
+// *-------*
+//  \     /
+//   \   /
+//    \o/
+//     *
+//
+// All corners are defined by unique CornerIndex and each triplet of corners
+// that define a single face id always ordered consecutively as:
+//     { 3 * FaceIndex, 3 * FaceIndex + 1, 3 * FaceIndex +2 }.
+// This representation of corners allows CornerTable to easily retrieve Next and
+// Previous corners on any face (see corners |n| and |p| in the figure above).
+// Using the Next, Previous, and Opposite corners then enables traversal of any
+// 2-manifold surface.
+// If the CornerTable is constructed from a non-manifold surface, the input
+// non-manifold edges and vertices are automatically split.
+class CornerTable {
+ public:
+  // Corner table face type.
+  typedef std::array<VertexIndex, 3> FaceType;
+
+  CornerTable();
+  static std::unique_ptr<CornerTable> Create(
+      const IndexTypeVector<FaceIndex, FaceType> &faces);
+
+  // Initializes the CornerTable from provides set of indexed faces.
+  // The input faces can represent a non-manifold topology, in which case the
+  // non-manifold edges and vertices are going to be split.
+  bool Init(const IndexTypeVector<FaceIndex, FaceType> &faces);
+
+  // Resets the corner table to the given number of invalid faces.
+  bool Reset(int num_faces);
+
+  // Resets the corner table to the given number of invalid faces and vertices.
+  bool Reset(int num_faces, int num_vertices);
+
+  inline int num_vertices() const {
+    return static_cast<int>(vertex_corners_.size());
+  }
+  inline int num_corners() const {
+    return static_cast<int>(corner_to_vertex_map_.size());
+  }
+  inline int num_faces() const {
+    return static_cast<int>(corner_to_vertex_map_.size() / 3);
+  }
+
+  inline CornerIndex Opposite(CornerIndex corner) const {
+    if (corner == kInvalidCornerIndex) {
+      return corner;
+    }
+    return opposite_corners_[corner];
+  }
+  inline CornerIndex Next(CornerIndex corner) const {
+    if (corner == kInvalidCornerIndex) {
+      return corner;
+    }
+    return LocalIndex(++corner) ? corner : corner - 3;
+  }
+  inline CornerIndex Previous(CornerIndex corner) const {
+    if (corner == kInvalidCornerIndex) {
+      return corner;
+    }
+    return LocalIndex(corner) ? corner - 1 : corner + 2;
+  }
+  inline VertexIndex Vertex(CornerIndex corner) const {
+    if (corner == kInvalidCornerIndex) {
+      return kInvalidVertexIndex;
+    }
+    return ConfidentVertex(corner);
+  }
+  inline VertexIndex ConfidentVertex(CornerIndex corner) const {
+    DRACO_DCHECK_GE(corner.value(), 0);
+    DRACO_DCHECK_LT(corner.value(), num_corners());
+    return corner_to_vertex_map_[corner];
+  }
+  inline FaceIndex Face(CornerIndex corner) const {
+    if (corner == kInvalidCornerIndex) {
+      return kInvalidFaceIndex;
+    }
+    return FaceIndex(corner.value() / 3);
+  }
+  inline CornerIndex FirstCorner(FaceIndex face) const {
+    if (face == kInvalidFaceIndex) {
+      return kInvalidCornerIndex;
+    }
+    return CornerIndex(face.value() * 3);
+  }
+  inline std::array<CornerIndex, 3> AllCorners(FaceIndex face) const {
+    const CornerIndex ci = CornerIndex(face.value() * 3);
+    return {{ci, ci + 1, ci + 2}};
+  }
+  inline int LocalIndex(CornerIndex corner) const { return corner.value() % 3; }
+
+  inline FaceType FaceData(FaceIndex face) const {
+    const CornerIndex first_corner = FirstCorner(face);
+    FaceType face_data;
+    for (int i = 0; i < 3; ++i) {
+      face_data[i] = corner_to_vertex_map_[first_corner + i];
+    }
+    return face_data;
+  }
+
+  void SetFaceData(FaceIndex face, FaceType data) {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    const CornerIndex first_corner = FirstCorner(face);
+    for (int i = 0; i < 3; ++i) {
+      corner_to_vertex_map_[first_corner + i] = data[i];
+    }
+  }
+
+  // Returns the left-most corner of a single vertex 1-ring. If a vertex is not
+  // on a boundary (in which case it has a full 1-ring), this function returns
+  // any of the corners mapped to the given vertex.
+  inline CornerIndex LeftMostCorner(VertexIndex v) const {
+    return vertex_corners_[v];
+  }
+
+  // Returns the parent vertex index of a given corner table vertex.
+  VertexIndex VertexParent(VertexIndex vertex) const {
+    if (vertex.value() < static_cast<uint32_t>(num_original_vertices_)) {
+      return vertex;
+    }
+    return non_manifold_vertex_parents_[vertex - num_original_vertices_];
+  }
+
+  // Returns true if the corner is valid.
+  inline bool IsValid(CornerIndex c) const {
+    return Vertex(c) != kInvalidVertexIndex;
+  }
+
+  // Returns the valence (or degree) of a vertex.
+  // Returns -1 if the given vertex index is not valid.
+  int Valence(VertexIndex v) const;
+  // Same as above but does not check for validity and does not return -1
+  int ConfidentValence(VertexIndex v) const;
+  // Returns the valence of the vertex at the given corner.
+  inline int Valence(CornerIndex c) const {
+    if (c == kInvalidCornerIndex) {
+      return -1;
+    }
+    return ConfidentValence(c);
+  }
+  inline int ConfidentValence(CornerIndex c) const {
+    DRACO_DCHECK_LT(c.value(), num_corners());
+    return ConfidentValence(ConfidentVertex(c));
+  }
+
+  // Returns true if the specified vertex is on a boundary.
+  inline bool IsOnBoundary(VertexIndex vert) const {
+    const CornerIndex corner = LeftMostCorner(vert);
+    if (SwingLeft(corner) == kInvalidCornerIndex) {
+      return true;
+    }
+    return false;
+  }
+
+  //     *-------*
+  //    / \     / \
+  //   /   \   /   \
+  //  /   sl\c/sr   \
+  // *-------v-------*
+  // Returns the corner on the adjacent face on the right that maps to
+  // the same vertex as the given corner (sr in the above diagram).
+  inline CornerIndex SwingRight(CornerIndex corner) const {
+    return Previous(Opposite(Previous(corner)));
+  }
+  // Returns the corner on the left face that maps to the same vertex as the
+  // given corner (sl in the above diagram).
+  inline CornerIndex SwingLeft(CornerIndex corner) const {
+    return Next(Opposite(Next(corner)));
+  }
+
+  // Get opposite corners on the left and right faces respectively (see image
+  // below, where L and R are the left and right corners of a corner X.
+  //
+  // *-------*-------*
+  //  \L    /X\    R/
+  //   \   /   \   /
+  //    \ /     \ /
+  //     *-------*
+  inline CornerIndex GetLeftCorner(CornerIndex corner_id) const {
+    if (corner_id == kInvalidCornerIndex) {
+      return kInvalidCornerIndex;
+    }
+    return Opposite(Previous(corner_id));
+  }
+  inline CornerIndex GetRightCorner(CornerIndex corner_id) const {
+    if (corner_id == kInvalidCornerIndex) {
+      return kInvalidCornerIndex;
+    }
+    return Opposite(Next(corner_id));
+  }
+
+  // Returns the number of new vertices that were created as a result of
+  // splitting of non-manifold vertices of the input geometry.
+  int NumNewVertices() const { return num_vertices() - num_original_vertices_; }
+  int NumOriginalVertices() const { return num_original_vertices_; }
+
+  // Returns the number of faces with duplicated vertex indices.
+  int NumDegeneratedFaces() const { return num_degenerated_faces_; }
+
+  // Returns the number of isolated vertices (vertices that have
+  // vertex_corners_ mapping set to kInvalidCornerIndex.
+  int NumIsolatedVertices() const { return num_isolated_vertices_; }
+
+  bool IsDegenerated(FaceIndex face) const;
+
+  // Methods that modify an existing corner table.
+  // Sets the opposite corner mapping between two corners. Caller must ensure
+  // that the indices are valid.
+  inline void SetOppositeCorner(CornerIndex corner_id,
+                                CornerIndex opp_corner_id) {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    opposite_corners_[corner_id] = opp_corner_id;
+  }
+
+  // Sets opposite corners for both input corners.
+  inline void SetOppositeCorners(CornerIndex corner_0, CornerIndex corner_1) {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    if (corner_0 != kInvalidCornerIndex) {
+      SetOppositeCorner(corner_0, corner_1);
+    }
+    if (corner_1 != kInvalidCornerIndex) {
+      SetOppositeCorner(corner_1, corner_0);
+    }
+  }
+
+  // Updates mapping between a corner and a vertex.
+  inline void MapCornerToVertex(CornerIndex corner_id, VertexIndex vert_id) {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    corner_to_vertex_map_[corner_id] = vert_id;
+  }
+
+  VertexIndex AddNewVertex() {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    // Add a new invalid vertex.
+    vertex_corners_.push_back(kInvalidCornerIndex);
+    return VertexIndex(static_cast<uint32_t>(vertex_corners_.size() - 1));
+  }
+
+  // Adds a new face connected to three vertices. Note that connectivity is not
+  // automatically updated and all opposite corners need to be set explicitly.
+  FaceIndex AddNewFace(const std::array<VertexIndex, 3> &vertices) {
+    // Add a new invalid face.
+    const FaceIndex new_face_index(num_faces());
+    for (int i = 0; i < 3; ++i) {
+      corner_to_vertex_map_.push_back(vertices[i]);
+      SetLeftMostCorner(vertices[i],
+                        CornerIndex(corner_to_vertex_map_.size() - 1));
+    }
+    opposite_corners_.resize(corner_to_vertex_map_.size(), kInvalidCornerIndex);
+    return new_face_index;
+  }
+
+  // Sets a new left most corner for a given vertex.
+  void SetLeftMostCorner(VertexIndex vert, CornerIndex corner) {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    if (vert != kInvalidVertexIndex) {
+      vertex_corners_[vert] = corner;
+    }
+  }
+
+  // Updates the vertex to corner map on a specified vertex. This should be
+  // called in cases where the mapping may be invalid (e.g. when the corner
+  // table was constructed manually).
+  void UpdateVertexToCornerMap(VertexIndex vert) {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    const CornerIndex first_c = vertex_corners_[vert];
+    if (first_c == kInvalidCornerIndex) {
+      return;  // Isolated vertex.
+    }
+    CornerIndex act_c = SwingLeft(first_c);
+    CornerIndex c = first_c;
+    while (act_c != kInvalidCornerIndex && act_c != first_c) {
+      c = act_c;
+      act_c = SwingLeft(act_c);
+    }
+    if (act_c != first_c) {
+      vertex_corners_[vert] = c;
+    }
+  }
+
+  // Sets the new number of vertices. It's a responsibility of the caller to
+  // ensure that no corner is mapped beyond the range of the new number of
+  // vertices.
+  inline void SetNumVertices(int num_vertices) {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    vertex_corners_.resize(num_vertices, kInvalidCornerIndex);
+  }
+
+  // Makes a vertex isolated (not attached to any corner).
+  void MakeVertexIsolated(VertexIndex vert) {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    vertex_corners_[vert] = kInvalidCornerIndex;
+  }
+
+  // Returns true if a vertex is not attached to any face.
+  inline bool IsVertexIsolated(VertexIndex v) const {
+    return LeftMostCorner(v) == kInvalidCornerIndex;
+  }
+
+  // Makes a given face invalid (all corners are marked as invalid).
+  void MakeFaceInvalid(FaceIndex face) {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    if (face != kInvalidFaceIndex) {
+      const CornerIndex first_corner = FirstCorner(face);
+      for (int i = 0; i < 3; ++i) {
+        corner_to_vertex_map_[first_corner + i] = kInvalidVertexIndex;
+      }
+    }
+  }
+
+  // Updates mapping between faces and a vertex using the corners mapped to
+  // the provided vertex.
+  void UpdateFaceToVertexMap(const VertexIndex vertex);
+
+  // Allows access to an internal object for caching valences.  The object can
+  // be instructed to cache or uncache all valences and then its interfaces
+  // queried directly for valences with differing performance/confidence
+  // qualities.  If the mesh or table is modified the cache should be discarded
+  // and not relied on as it does not automatically update or invalidate for
+  // performance reasons.
+  const draco::ValenceCache<CornerTable> &GetValenceCache() const {
+    return valence_cache_;
+  }
+
+ private:
+  // Computes opposite corners mapping from the data stored in
+  // |corner_to_vertex_map_|.
+  bool ComputeOppositeCorners(int *num_vertices);
+
+  // Finds and breaks non-manifold edges in the 1-ring neighborhood around
+  // vertices (vertices themselves will be split in the ComputeVertexCorners()
+  // function if necessary).
+  bool BreakNonManifoldEdges();
+
+  // Computes the lookup map for going from a vertex to a corner. This method
+  // can handle non-manifold vertices by splitting them into multiple manifold
+  // vertices.
+  bool ComputeVertexCorners(int num_vertices);
+
+  // Each three consecutive corners represent one face.
+  IndexTypeVector<CornerIndex, VertexIndex> corner_to_vertex_map_;
+  IndexTypeVector<CornerIndex, CornerIndex> opposite_corners_;
+  IndexTypeVector<VertexIndex, CornerIndex> vertex_corners_;
+
+  int num_original_vertices_;
+  int num_degenerated_faces_;
+  int num_isolated_vertices_;
+  IndexTypeVector<VertexIndex, VertexIndex> non_manifold_vertex_parents_;
+
+  draco::ValenceCache<CornerTable> valence_cache_;
+};
+
+// A special case to denote an invalid corner table triangle.
+static constexpr CornerTable::FaceType kInvalidFace(
+    {{kInvalidVertexIndex, kInvalidVertexIndex, kInvalidVertexIndex}});
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_CORNER_TABLE_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/mesh/corner_table_iterators.h b/Engine/lib/assimp/contrib/draco/src/draco/mesh/corner_table_iterators.h
new file mode 100644
index 000000000..7122aa1be
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/mesh/corner_table_iterators.h
@@ -0,0 +1,289 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MESH_CORNER_TABLE_ITERATORS_H_
+#define DRACO_MESH_CORNER_TABLE_ITERATORS_H_
+
+#include "draco/mesh/corner_table.h"
+
+namespace draco {
+
+// Class for iterating over vertices in a 1-ring around the specified vertex.
+template <class CornerTableT>
+class VertexRingIterator
+    : public std::iterator<std::forward_iterator_tag, VertexIndex> {
+ public:
+  // std::iterator interface requires a default constructor.
+  VertexRingIterator()
+      : corner_table_(nullptr),
+        start_corner_(kInvalidCornerIndex),
+        corner_(start_corner_),
+        left_traversal_(true) {}
+
+  // Create the iterator from the provided corner table and the central vertex.
+  VertexRingIterator(const CornerTableT *table, VertexIndex vert_id)
+      : corner_table_(table),
+        start_corner_(table->LeftMostCorner(vert_id)),
+        corner_(start_corner_),
+        left_traversal_(true) {}
+
+  // Gets the last visited ring vertex.
+  VertexIndex Vertex() const {
+    CornerIndex ring_corner = left_traversal_ ? corner_table_->Previous(corner_)
+                                              : corner_table_->Next(corner_);
+    return corner_table_->Vertex(ring_corner);
+  }
+
+  // Returns one of the corners opposite to the edge connecting the currently
+  // iterated ring vertex with the central vertex.
+  CornerIndex EdgeCorner() const {
+    return left_traversal_ ? corner_table_->Next(corner_)
+                           : corner_table_->Previous(corner_);
+  }
+
+  // Returns true when all ring vertices have been visited.
+  bool End() const { return corner_ == kInvalidCornerIndex; }
+
+  // Proceeds to the next ring vertex if possible.
+  void Next() {
+    if (left_traversal_) {
+      corner_ = corner_table_->SwingLeft(corner_);
+      if (corner_ == kInvalidCornerIndex) {
+        // Open boundary reached.
+        corner_ = start_corner_;
+        left_traversal_ = false;
+      } else if (corner_ == start_corner_) {
+        // End reached.
+        corner_ = kInvalidCornerIndex;
+      }
+    } else {
+      // Go to the right until we reach a boundary there (no explicit check
+      // is needed in this case).
+      corner_ = corner_table_->SwingRight(corner_);
+    }
+  }
+
+  // std::iterator interface.
+  value_type operator*() const { return Vertex(); }
+  VertexRingIterator &operator++() {
+    Next();
+    return *this;
+  }
+  VertexRingIterator operator++(int) {
+    const VertexRingIterator result = *this;
+    ++(*this);
+    return result;
+  }
+  bool operator!=(const VertexRingIterator &other) const {
+    return corner_ != other.corner_ || start_corner_ != other.start_corner_;
+  }
+  bool operator==(const VertexRingIterator &other) const {
+    return !this->operator!=(other);
+  }
+
+  // Helper function for getting a valid end iterator.
+  static VertexRingIterator EndIterator(VertexRingIterator other) {
+    VertexRingIterator ret = other;
+    ret.corner_ = kInvalidCornerIndex;
+    return ret;
+  }
+
+ private:
+  const CornerTableT *corner_table_;
+  // The first processed corner.
+  CornerIndex start_corner_;
+  // The last processed corner.
+  CornerIndex corner_;
+  // Traversal direction.
+  bool left_traversal_;
+};
+
+// Class for iterating over faces adjacent to the specified input face.
+template <class CornerTableT>
+class FaceAdjacencyIterator
+    : public std::iterator<std::forward_iterator_tag, FaceIndex> {
+ public:
+  // std::iterator interface requires a default constructor.
+  FaceAdjacencyIterator()
+      : corner_table_(nullptr),
+        start_corner_(kInvalidCornerIndex),
+        corner_(start_corner_) {}
+
+  // Create the iterator from the provided corner table and the central vertex.
+  FaceAdjacencyIterator(const CornerTableT *table, FaceIndex face_id)
+      : corner_table_(table),
+        start_corner_(table->FirstCorner(face_id)),
+        corner_(start_corner_) {
+    // We need to start with a corner that has a valid opposite face (if
+    // there is any such corner).
+    if (corner_table_->Opposite(corner_) == kInvalidCornerIndex) {
+      FindNextFaceNeighbor();
+    }
+  }
+
+  // Gets the last visited adjacent face.
+  FaceIndex Face() const {
+    return corner_table_->Face(corner_table_->Opposite(corner_));
+  }
+
+  // Returns true when all adjacent faces have been visited.
+  bool End() const { return corner_ == kInvalidCornerIndex; }
+
+  // Proceeds to the next adjacent face if possible.
+  void Next() { FindNextFaceNeighbor(); }
+
+  // std::iterator interface.
+  value_type operator*() const { return Face(); }
+  FaceAdjacencyIterator &operator++() {
+    Next();
+    return *this;
+  }
+  FaceAdjacencyIterator operator++(int) {
+    const FaceAdjacencyIterator result = *this;
+    ++(*this);
+    return result;
+  }
+  bool operator!=(const FaceAdjacencyIterator &other) const {
+    return corner_ != other.corner_ || start_corner_ != other.start_corner_;
+  }
+  bool operator==(const FaceAdjacencyIterator &other) const {
+    return !this->operator!=(other);
+  }
+
+  // Helper function for getting a valid end iterator.
+  static FaceAdjacencyIterator EndIterator(FaceAdjacencyIterator other) {
+    FaceAdjacencyIterator ret = other;
+    ret.corner_ = kInvalidCornerIndex;
+    return ret;
+  }
+
+ private:
+  // Finds the next corner with a valid opposite face.
+  void FindNextFaceNeighbor() {
+    while (corner_ != kInvalidCornerIndex) {
+      corner_ = corner_table_->Next(corner_);
+      if (corner_ == start_corner_) {
+        corner_ = kInvalidCornerIndex;
+        return;
+      }
+      if (corner_table_->Opposite(corner_) != kInvalidCornerIndex) {
+        // Valid opposite face.
+        return;
+      }
+    }
+  }
+
+  const CornerTableT *corner_table_;
+  // The first processed corner.
+  CornerIndex start_corner_;
+  // The last processed corner.
+  CornerIndex corner_;
+};
+
+// Class for iterating over corners attached to a specified vertex.
+template <class CornerTableT = CornerTable>
+class VertexCornersIterator
+    : public std::iterator<std::forward_iterator_tag, CornerIndex> {
+ public:
+  // std::iterator interface requires a default constructor.
+  VertexCornersIterator()
+      : corner_table_(nullptr),
+        start_corner_(-1),
+        corner_(start_corner_),
+        left_traversal_(true) {}
+
+  // Create the iterator from the provided corner table and the central vertex.
+  VertexCornersIterator(const CornerTableT *table, VertexIndex vert_id)
+      : corner_table_(table),
+        start_corner_(table->LeftMostCorner(vert_id)),
+        corner_(start_corner_),
+        left_traversal_(true) {}
+
+  // Create the iterator from the provided corner table and the first corner.
+  VertexCornersIterator(const CornerTableT *table, CornerIndex corner_id)
+      : corner_table_(table),
+        start_corner_(corner_id),
+        corner_(start_corner_),
+        left_traversal_(true) {}
+
+  // Gets the last visited corner.
+  CornerIndex Corner() const { return corner_; }
+
+  // Returns true when all ring vertices have been visited.
+  bool End() const { return corner_ == kInvalidCornerIndex; }
+
+  // Proceeds to the next corner if possible.
+  void Next() {
+    if (left_traversal_) {
+      corner_ = corner_table_->SwingLeft(corner_);
+      if (corner_ == kInvalidCornerIndex) {
+        // Open boundary reached.
+        corner_ = corner_table_->SwingRight(start_corner_);
+        left_traversal_ = false;
+      } else if (corner_ == start_corner_) {
+        // End reached.
+        corner_ = kInvalidCornerIndex;
+      }
+    } else {
+      // Go to the right until we reach a boundary there (no explicit check
+      // is needed in this case).
+      corner_ = corner_table_->SwingRight(corner_);
+    }
+  }
+
+  // std::iterator interface.
+  CornerIndex operator*() const { return Corner(); }
+  VertexCornersIterator &operator++() {
+    Next();
+    return *this;
+  }
+  VertexCornersIterator operator++(int) {
+    const VertexCornersIterator result = *this;
+    ++(*this);
+    return result;
+  }
+  bool operator!=(const VertexCornersIterator &other) const {
+    return corner_ != other.corner_ || start_corner_ != other.start_corner_;
+  }
+  bool operator==(const VertexCornersIterator &other) const {
+    return !this->operator!=(other);
+  }
+
+  // Helper function for getting a valid end iterator.
+  static VertexCornersIterator EndIterator(VertexCornersIterator other) {
+    VertexCornersIterator ret = other;
+    ret.corner_ = kInvalidCornerIndex;
+    return ret;
+  }
+
+ protected:
+  const CornerTableT *corner_table() const { return corner_table_; }
+  CornerIndex start_corner() const { return start_corner_; }
+  CornerIndex &corner() { return corner_; }
+  bool is_left_traversal() const { return left_traversal_; }
+  void swap_traversal() { left_traversal_ = !left_traversal_; }
+
+ private:
+  const CornerTableT *corner_table_;
+  // The first processed corner.
+  CornerIndex start_corner_;
+  // The last processed corner.
+  CornerIndex corner_;
+  // Traversal direction.
+  bool left_traversal_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_CORNER_TABLE_ITERATORS_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh.cc b/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh.cc
new file mode 100644
index 000000000..3be4b1494
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh.cc
@@ -0,0 +1,40 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/mesh/mesh.h"
+
+#include <array>
+
+namespace draco {
+
+// Shortcut for typed conditionals.
+template <bool B, class T, class F>
+using conditional_t = typename std::conditional<B, T, F>::type;
+
+Mesh::Mesh() {}
+
+#ifdef DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+void Mesh::ApplyPointIdDeduplication(
+    const IndexTypeVector<PointIndex, PointIndex> &id_map,
+    const std::vector<PointIndex> &unique_point_ids) {
+  PointCloud::ApplyPointIdDeduplication(id_map, unique_point_ids);
+  for (FaceIndex f(0); f < num_faces(); ++f) {
+    for (int32_t c = 0; c < 3; ++c) {
+      faces_[f][c] = id_map[faces_[f][c]];
+    }
+  }
+}
+#endif
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh.h b/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh.h
new file mode 100644
index 000000000..f4506da81
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh.h
@@ -0,0 +1,152 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MESH_MESH_H_
+#define DRACO_MESH_MESH_H_
+
+#include <memory>
+
+#include "draco/attributes/geometry_indices.h"
+#include "draco/core/hash_utils.h"
+#include "draco/core/macros.h"
+#include "draco/core/status.h"
+#include "draco/draco_features.h"
+#include "draco/point_cloud/point_cloud.h"
+
+namespace draco {
+
+// List of different variants of mesh attributes.
+enum MeshAttributeElementType {
+  // All corners attached to a vertex share the same attribute value. A typical
+  // example are the vertex positions and often vertex colors.
+  MESH_VERTEX_ATTRIBUTE = 0,
+  // The most general attribute where every corner of the mesh can have a
+  // different attribute value. Often used for texture coordinates or normals.
+  MESH_CORNER_ATTRIBUTE,
+  // All corners of a single face share the same value.
+  MESH_FACE_ATTRIBUTE
+};
+
+// Mesh class can be used to represent general triangular meshes. Internally,
+// Mesh is just an extended PointCloud with extra connectivity data that defines
+// what points are connected together in triangles.
+class Mesh : public PointCloud {
+ public:
+  typedef std::array<PointIndex, 3> Face;
+
+  Mesh();
+
+  void AddFace(const Face &face) { faces_.push_back(face); }
+
+  void SetFace(FaceIndex face_id, const Face &face) {
+    if (face_id >= static_cast<uint32_t>(faces_.size())) {
+      faces_.resize(face_id.value() + 1, Face());
+    }
+    faces_[face_id] = face;
+  }
+
+  // Sets the total number of faces. Creates new empty faces or deletes
+  // existing ones if necessary.
+  void SetNumFaces(size_t num_faces) { faces_.resize(num_faces, Face()); }
+
+  FaceIndex::ValueType num_faces() const {
+    return static_cast<uint32_t>(faces_.size());
+  }
+  const Face &face(FaceIndex face_id) const {
+    DRACO_DCHECK_LE(0, face_id.value());
+    DRACO_DCHECK_LT(face_id.value(), static_cast<int>(faces_.size()));
+    return faces_[face_id];
+  }
+
+  void SetAttribute(int att_id, std::unique_ptr<PointAttribute> pa) override {
+    PointCloud::SetAttribute(att_id, std::move(pa));
+    if (static_cast<int>(attribute_data_.size()) <= att_id) {
+      attribute_data_.resize(att_id + 1);
+    }
+  }
+
+  void DeleteAttribute(int att_id) override {
+    PointCloud::DeleteAttribute(att_id);
+    if (att_id >= 0 && att_id < static_cast<int>(attribute_data_.size())) {
+      attribute_data_.erase(attribute_data_.begin() + att_id);
+    }
+  }
+
+  MeshAttributeElementType GetAttributeElementType(int att_id) const {
+    return attribute_data_[att_id].element_type;
+  }
+
+  void SetAttributeElementType(int att_id, MeshAttributeElementType et) {
+    attribute_data_[att_id].element_type = et;
+  }
+
+  // Returns the point id of for a corner |ci|.
+  inline PointIndex CornerToPointId(int ci) const {
+    if (ci < 0 || static_cast<uint32_t>(ci) == kInvalidCornerIndex.value()) {
+      return kInvalidPointIndex;
+    }
+    return this->face(FaceIndex(ci / 3))[ci % 3];
+  }
+
+  // Returns the point id of a corner |ci|.
+  inline PointIndex CornerToPointId(CornerIndex ci) const {
+    return this->CornerToPointId(ci.value());
+  }
+
+  struct AttributeData {
+    AttributeData() : element_type(MESH_CORNER_ATTRIBUTE) {}
+    MeshAttributeElementType element_type;
+  };
+
+ protected:
+#ifdef DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+  // Extends the point deduplication to face corners. This method is called from
+  // the PointCloud::DeduplicatePointIds() and it remaps all point ids stored in
+  // |faces_| to the new deduplicated point ids using the map |id_map|.
+  void ApplyPointIdDeduplication(
+      const IndexTypeVector<PointIndex, PointIndex> &id_map,
+      const std::vector<PointIndex> &unique_point_ids) override;
+#endif
+
+ private:
+  // Mesh specific per-attribute data.
+  std::vector<AttributeData> attribute_data_;
+
+  // Vertex indices valid for all attributes. Each attribute has its own map
+  // that converts vertex indices into attribute indices.
+  IndexTypeVector<FaceIndex, Face> faces_;
+
+  friend struct MeshHasher;
+};
+
+// Functor for computing a hash from data stored within a mesh.
+// Note that this can be quite slow. Two meshes will have the same hash only
+// when they have exactly the same connectivity and attribute values.
+struct MeshHasher {
+  size_t operator()(const Mesh &mesh) const {
+    PointCloudHasher pc_hasher;
+    size_t hash = pc_hasher(mesh);
+    // Hash faces.
+    for (FaceIndex i(0); i < static_cast<uint32_t>(mesh.faces_.size()); ++i) {
+      for (int j = 0; j < 3; ++j) {
+        hash = HashCombine(mesh.faces_[i][j].value(), hash);
+      }
+    }
+    return hash;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_MESH_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_are_equivalent.cc b/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_are_equivalent.cc
new file mode 100644
index 000000000..b832379af
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_are_equivalent.cc
@@ -0,0 +1,205 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/mesh/mesh_are_equivalent.h"
+
+#include <algorithm>
+
+namespace draco {
+
+void MeshAreEquivalent::PrintPosition(const Mesh &mesh, FaceIndex f,
+                                      int32_t c) {
+  fprintf(stderr, "Printing position for (%i,%i)\n", f.value(), c);
+  const auto pos_att = mesh.GetNamedAttribute(GeometryAttribute::POSITION);
+  const PointIndex ver_index = mesh.face(f)[c];
+  const AttributeValueIndex pos_index = pos_att->mapped_index(ver_index);
+  const auto pos = pos_att->GetValue<float, 3>(pos_index);
+  fprintf(stderr, "Position (%f,%f,%f)\n", pos[0], pos[1], pos[2]);
+}
+
+Vector3f MeshAreEquivalent::GetPosition(const Mesh &mesh, FaceIndex f,
+                                        int32_t c) {
+  const auto pos_att = mesh.GetNamedAttribute(GeometryAttribute::POSITION);
+  const PointIndex ver_index = mesh.face(f)[c];
+  const AttributeValueIndex pos_index = pos_att->mapped_index(ver_index);
+  const auto pos = pos_att->GetValue<float, 3>(pos_index);
+  return Vector3f(pos[0], pos[1], pos[2]);
+}
+
+void MeshAreEquivalent::InitCornerIndexOfSmallestPointXYZ() {
+  DRACO_DCHECK_EQ(mesh_infos_[0].corner_index_of_smallest_vertex.size(), 0);
+  DRACO_DCHECK_EQ(mesh_infos_[1].corner_index_of_smallest_vertex.size(), 0);
+  for (int i = 0; i < 2; ++i) {
+    mesh_infos_[i].corner_index_of_smallest_vertex.reserve(num_faces_);
+    for (FaceIndex f(0); f < num_faces_; ++f) {
+      mesh_infos_[i].corner_index_of_smallest_vertex.push_back(
+          ComputeCornerIndexOfSmallestPointXYZ(mesh_infos_[i].mesh, f));
+    }
+  }
+  DRACO_DCHECK_EQ(mesh_infos_[0].corner_index_of_smallest_vertex.size(),
+                  num_faces_);
+  DRACO_DCHECK_EQ(mesh_infos_[1].corner_index_of_smallest_vertex.size(),
+                  num_faces_);
+}
+
+void MeshAreEquivalent::InitOrderedFaceIndex() {
+  DRACO_DCHECK_EQ(mesh_infos_[0].ordered_index_of_face.size(), 0);
+  DRACO_DCHECK_EQ(mesh_infos_[1].ordered_index_of_face.size(), 0);
+  for (int32_t i = 0; i < 2; ++i) {
+    mesh_infos_[i].ordered_index_of_face.reserve(num_faces_);
+    for (FaceIndex j(0); j < num_faces_; ++j) {
+      mesh_infos_[i].ordered_index_of_face.push_back(j);
+    }
+    const FaceIndexLess less(mesh_infos_[i]);
+    std::sort(mesh_infos_[i].ordered_index_of_face.begin(),
+              mesh_infos_[i].ordered_index_of_face.end(), less);
+
+    DRACO_DCHECK_EQ(mesh_infos_[i].ordered_index_of_face.size(), num_faces_);
+    DRACO_DCHECK(std::is_sorted(mesh_infos_[i].ordered_index_of_face.begin(),
+                                mesh_infos_[i].ordered_index_of_face.end(),
+                                less));
+  }
+}
+
+int32_t MeshAreEquivalent::ComputeCornerIndexOfSmallestPointXYZ(
+    const Mesh &mesh, FaceIndex f) {
+  Vector3f pos[3];  // For the three corners.
+  for (int32_t i = 0; i < 3; ++i) {
+    pos[i] = GetPosition(mesh, f, i);
+  }
+  const auto min_it = std::min_element(pos, pos + 3);
+  return static_cast<int32_t>(min_it - pos);
+}
+
+void MeshAreEquivalent::Init(const Mesh &mesh0, const Mesh &mesh1) {
+  mesh_infos_.clear();
+  DRACO_DCHECK_EQ(mesh_infos_.size(), 0);
+
+  num_faces_ = mesh1.num_faces();
+  mesh_infos_.push_back(MeshInfo(mesh0));
+  mesh_infos_.push_back(MeshInfo(mesh1));
+
+  DRACO_DCHECK_EQ(mesh_infos_.size(), 2);
+  DRACO_DCHECK_EQ(mesh_infos_[0].corner_index_of_smallest_vertex.size(), 0);
+  DRACO_DCHECK_EQ(mesh_infos_[1].corner_index_of_smallest_vertex.size(), 0);
+  DRACO_DCHECK_EQ(mesh_infos_[0].ordered_index_of_face.size(), 0);
+  DRACO_DCHECK_EQ(mesh_infos_[1].ordered_index_of_face.size(), 0);
+
+  InitCornerIndexOfSmallestPointXYZ();
+  InitOrderedFaceIndex();
+}
+
+bool MeshAreEquivalent::operator()(const Mesh &mesh0, const Mesh &mesh1) {
+  if (mesh0.num_faces() != mesh1.num_faces()) {
+    return false;
+  }
+  if (mesh0.num_attributes() != mesh1.num_attributes()) {
+    return false;
+  }
+
+  // The following function inits mesh info, i.e., computes the order of
+  // faces with respect to the lex order. This way one can then compare the
+  // the two meshes face by face. It also determines the first corner of each
+  // face with respect to lex order.
+  Init(mesh0, mesh1);
+
+  // Check for every attribute that is valid that every corner is identical.
+  typedef GeometryAttribute::Type AttributeType;
+  const int att_max = AttributeType::NAMED_ATTRIBUTES_COUNT;
+  for (int att_id = 0; att_id < att_max; ++att_id) {
+    // First check for existence of the attribute in both meshes.
+    const PointAttribute *const att0 =
+        mesh0.GetNamedAttribute(AttributeType(att_id));
+    const PointAttribute *const att1 =
+        mesh1.GetNamedAttribute(AttributeType(att_id));
+    if (att0 == nullptr && att1 == nullptr) {
+      continue;
+    }
+    if (att0 == nullptr) {
+      return false;
+    }
+    if (att1 == nullptr) {
+      return false;
+    }
+    if (att0->data_type() != att1->data_type()) {
+      return false;
+    }
+    if (att0->num_components() != att1->num_components()) {
+      return false;
+    }
+    if (att0->normalized() != att1->normalized()) {
+      return false;
+    }
+    if (att0->byte_stride() != att1->byte_stride()) {
+      return false;
+    }
+
+    DRACO_DCHECK(att0->IsValid());
+    DRACO_DCHECK(att1->IsValid());
+
+    // Prepare blocks of memory to hold data of corners for this attribute.
+    std::unique_ptr<uint8_t[]> data0(new uint8_t[att0->byte_stride()]);
+    std::unique_ptr<uint8_t[]> data1(new uint8_t[att0->byte_stride()]);
+
+    // Check every corner of every face.
+    for (int i = 0; i < num_faces_; ++i) {
+      const FaceIndex f0 = mesh_infos_[0].ordered_index_of_face[i];
+      const FaceIndex f1 = mesh_infos_[1].ordered_index_of_face[i];
+      const int c0_off = mesh_infos_[0].corner_index_of_smallest_vertex[f0];
+      const int c1_off = mesh_infos_[1].corner_index_of_smallest_vertex[f1];
+
+      for (int c = 0; c < 3; ++c) {
+        // Get the index of each corner.
+        const PointIndex corner0 = mesh0.face(f0)[(c0_off + c) % 3];
+        const PointIndex corner1 = mesh1.face(f1)[(c1_off + c) % 3];
+        // Map it to the right index for that attribute.
+        const AttributeValueIndex index0 = att0->mapped_index(corner0);
+        const AttributeValueIndex index1 = att1->mapped_index(corner1);
+
+        // Obtaining the data.
+        att0->GetValue(index0, data0.get());
+        att1->GetValue(index1, data1.get());
+        // Compare the data as is in memory.
+        if (memcmp(data0.get(), data1.get(), att0->byte_stride()) != 0) {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+
+bool MeshAreEquivalent::FaceIndexLess::operator()(FaceIndex f0,
+                                                  FaceIndex f1) const {
+  if (f0 == f1) {
+    return false;
+  }
+  const int c0 = mesh_info.corner_index_of_smallest_vertex[f0];
+  const int c1 = mesh_info.corner_index_of_smallest_vertex[f1];
+
+  for (int i = 0; i < 3; ++i) {
+    const Vector3f vf0 = GetPosition(mesh_info.mesh, f0, (c0 + i) % 3);
+    const Vector3f vf1 = GetPosition(mesh_info.mesh, f1, (c1 + i) % 3);
+    if (vf0 < vf1) {
+      return true;
+    }
+    if (vf1 < vf0) {
+      return false;
+    }
+  }
+  // In case the two faces are equivalent.
+  return false;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_are_equivalent.h b/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_are_equivalent.h
new file mode 100644
index 000000000..71ef4a93c
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_are_equivalent.h
@@ -0,0 +1,71 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MESH_MESH_ARE_EQUIVALENT_H_
+#define DRACO_MESH_MESH_ARE_EQUIVALENT_H_
+
+#include "draco/core/vector_d.h"
+#include "draco/mesh/mesh.h"
+
+// This file defines a functor to compare two meshes for equivalency up
+// to permutation of the vertices.
+namespace draco {
+
+// A functor to compare two meshes for equivalency up to permutation of the
+// vertices.
+class MeshAreEquivalent {
+ public:
+  // Returns true if both meshes are equivalent up to permutation of
+  // the internal order of vertices. This includes all attributes.
+  bool operator()(const Mesh &mesh0, const Mesh &mesh1);
+
+ private:
+  // Internal type to keep overview.
+  struct MeshInfo {
+    explicit MeshInfo(const Mesh &in_mesh) : mesh(in_mesh) {}
+    const Mesh &mesh;
+    std::vector<FaceIndex> ordered_index_of_face;
+    IndexTypeVector<FaceIndex, int> corner_index_of_smallest_vertex;
+  };
+
+  // Prepare functor for actual comparison.
+  void Init(const Mesh &mesh0, const Mesh &mesh1);
+
+  // Get position as Vector3f of corner c of face f.
+  static Vector3f GetPosition(const Mesh &mesh, FaceIndex f, int32_t c);
+  // Internal helper function mostly for debugging.
+  void PrintPosition(const Mesh &mesh, FaceIndex f, int32_t c);
+  // Get the corner index of the lex smallest vertex of face f.
+  static int32_t ComputeCornerIndexOfSmallestPointXYZ(const Mesh &mesh,
+                                                      FaceIndex f);
+
+  // Less compare functor for two faces (represented by their indices)
+  // with respect to their lex order.
+  struct FaceIndexLess {
+    explicit FaceIndexLess(const MeshInfo &in_mesh_info)
+        : mesh_info(in_mesh_info) {}
+    bool operator()(FaceIndex f0, FaceIndex f1) const;
+    const MeshInfo &mesh_info;
+  };
+
+  void InitCornerIndexOfSmallestPointXYZ();
+  void InitOrderedFaceIndex();
+
+  std::vector<MeshInfo> mesh_infos_;
+  int32_t num_faces_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_MESH_ARE_EQUIVALENT_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_are_equivalent_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_are_equivalent_test.cc
new file mode 100644
index 000000000..74db3f7de
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_are_equivalent_test.cc
@@ -0,0 +1,98 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/mesh/mesh_are_equivalent.h"
+
+#include <sstream>
+
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+#include "draco/io/mesh_io.h"
+#include "draco/io/obj_decoder.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+class MeshAreEquivalentTest : public ::testing::Test {};
+
+TEST_F(MeshAreEquivalentTest, TestOnIndenticalMesh) {
+  const std::string file_name = "test_nm.obj";
+  const std::unique_ptr<Mesh> mesh(ReadMeshFromTestFile(file_name));
+  ASSERT_NE(mesh, nullptr) << "Failed to load test model." << file_name;
+  MeshAreEquivalent equiv;
+  ASSERT_TRUE(equiv(*mesh, *mesh));
+}
+
+TEST_F(MeshAreEquivalentTest, TestPermutedOneFace) {
+  const std::string file_name_0 = "one_face_123.obj";
+  const std::string file_name_1 = "one_face_312.obj";
+  const std::string file_name_2 = "one_face_321.obj";
+  const std::unique_ptr<Mesh> mesh_0(ReadMeshFromTestFile(file_name_0));
+  const std::unique_ptr<Mesh> mesh_1(ReadMeshFromTestFile(file_name_1));
+  const std::unique_ptr<Mesh> mesh_2(ReadMeshFromTestFile(file_name_2));
+  ASSERT_NE(mesh_0, nullptr) << "Failed to load test model." << file_name_0;
+  ASSERT_NE(mesh_1, nullptr) << "Failed to load test model." << file_name_1;
+  ASSERT_NE(mesh_2, nullptr) << "Failed to load test model." << file_name_2;
+  MeshAreEquivalent equiv;
+  ASSERT_TRUE(equiv(*mesh_0, *mesh_0));
+  ASSERT_TRUE(equiv(*mesh_0, *mesh_1));   // Face rotated.
+  ASSERT_FALSE(equiv(*mesh_0, *mesh_2));  // Face inverted.
+}
+
+TEST_F(MeshAreEquivalentTest, TestPermutedTwoFaces) {
+  const std::string file_name_0 = "two_faces_123.obj";
+  const std::string file_name_1 = "two_faces_312.obj";
+  const std::unique_ptr<Mesh> mesh_0(ReadMeshFromTestFile(file_name_0));
+  const std::unique_ptr<Mesh> mesh_1(ReadMeshFromTestFile(file_name_1));
+  ASSERT_NE(mesh_0, nullptr) << "Failed to load test model." << file_name_0;
+  ASSERT_NE(mesh_1, nullptr) << "Failed to load test model." << file_name_1;
+  MeshAreEquivalent equiv;
+  ASSERT_TRUE(equiv(*mesh_0, *mesh_0));
+  ASSERT_TRUE(equiv(*mesh_1, *mesh_1));
+  ASSERT_TRUE(equiv(*mesh_0, *mesh_1));
+}
+
+TEST_F(MeshAreEquivalentTest, TestPermutedThreeFaces) {
+  const std::string file_name_0 = "three_faces_123.obj";
+  const std::string file_name_1 = "three_faces_312.obj";
+  const std::unique_ptr<Mesh> mesh_0(ReadMeshFromTestFile(file_name_0));
+  const std::unique_ptr<Mesh> mesh_1(ReadMeshFromTestFile(file_name_1));
+  ASSERT_NE(mesh_0, nullptr) << "Failed to load test model." << file_name_0;
+  ASSERT_NE(mesh_1, nullptr) << "Failed to load test model." << file_name_1;
+  MeshAreEquivalent equiv;
+  ASSERT_TRUE(equiv(*mesh_0, *mesh_0));
+  ASSERT_TRUE(equiv(*mesh_1, *mesh_1));
+  ASSERT_TRUE(equiv(*mesh_0, *mesh_1));
+}
+
+// This test checks that the edgebreaker algorithm does not change the mesh up
+// to the order of faces and vertices.
+TEST_F(MeshAreEquivalentTest, TestOnBigMesh) {
+  const std::string file_name = "test_nm.obj";
+  const std::unique_ptr<Mesh> mesh0(ReadMeshFromTestFile(file_name));
+  ASSERT_NE(mesh0, nullptr) << "Failed to load test model." << file_name;
+
+  std::unique_ptr<Mesh> mesh1;
+  std::stringstream ss;
+  WriteMeshIntoStream(mesh0.get(), ss, MESH_EDGEBREAKER_ENCODING);
+  ReadMeshFromStream(&mesh1, ss);
+  ASSERT_TRUE(ss.good()) << "Mesh IO failed.";
+
+  MeshAreEquivalent equiv;
+  ASSERT_TRUE(equiv(*mesh0, *mesh0));
+  ASSERT_TRUE(equiv(*mesh1, *mesh1));
+  ASSERT_TRUE(equiv(*mesh0, *mesh1));
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_attribute_corner_table.cc b/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_attribute_corner_table.cc
new file mode 100644
index 000000000..28b68d5fd
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_attribute_corner_table.cc
@@ -0,0 +1,211 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/mesh/mesh_attribute_corner_table.h"
+
+#include "draco/mesh/corner_table_iterators.h"
+#include "draco/mesh/mesh_misc_functions.h"
+
+namespace draco {
+
+MeshAttributeCornerTable::MeshAttributeCornerTable()
+    : no_interior_seams_(true), corner_table_(nullptr), valence_cache_(*this) {}
+
+bool MeshAttributeCornerTable::InitEmpty(const CornerTable *table) {
+  if (table == nullptr) {
+    return false;
+  }
+  valence_cache_.ClearValenceCache();
+  valence_cache_.ClearValenceCacheInaccurate();
+  is_edge_on_seam_.assign(table->num_corners(), false);
+  is_vertex_on_seam_.assign(table->num_vertices(), false);
+  corner_to_vertex_map_.assign(table->num_corners(), kInvalidVertexIndex);
+  vertex_to_attribute_entry_id_map_.reserve(table->num_vertices());
+  vertex_to_left_most_corner_map_.reserve(table->num_vertices());
+  corner_table_ = table;
+  no_interior_seams_ = true;
+  return true;
+}
+
+bool MeshAttributeCornerTable::InitFromAttribute(const Mesh *mesh,
+                                                 const CornerTable *table,
+                                                 const PointAttribute *att) {
+  if (!InitEmpty(table)) {
+    return false;
+  }
+  valence_cache_.ClearValenceCache();
+  valence_cache_.ClearValenceCacheInaccurate();
+
+  // Find all necessary data for encoding attributes. For now we check which of
+  // the mesh vertices is part of an attribute seam, because seams require
+  // special handling.
+  for (CornerIndex c(0); c < corner_table_->num_corners(); ++c) {
+    const FaceIndex f = corner_table_->Face(c);
+    if (corner_table_->IsDegenerated(f)) {
+      continue;  // Ignore corners on degenerated faces.
+    }
+    const CornerIndex opp_corner = corner_table_->Opposite(c);
+    if (opp_corner == kInvalidCornerIndex) {
+      // Boundary. Mark it as seam edge.
+      is_edge_on_seam_[c.value()] = true;
+      // Mark seam vertices.
+      VertexIndex v;
+      v = corner_table_->Vertex(corner_table_->Next(c));
+      is_vertex_on_seam_[v.value()] = true;
+      v = corner_table_->Vertex(corner_table_->Previous(c));
+      is_vertex_on_seam_[v.value()] = true;
+      continue;
+    }
+    if (opp_corner < c) {
+      continue;  // Opposite corner was already processed.
+    }
+
+    CornerIndex act_c(c), act_sibling_c(opp_corner);
+    for (int i = 0; i < 2; ++i) {
+      // Get the sibling corners. I.e., the two corners attached to the same
+      // vertex but divided by the seam edge.
+      act_c = corner_table_->Next(act_c);
+      act_sibling_c = corner_table_->Previous(act_sibling_c);
+      const PointIndex point_id = mesh->CornerToPointId(act_c.value());
+      const PointIndex sibling_point_id =
+          mesh->CornerToPointId(act_sibling_c.value());
+      if (att->mapped_index(point_id) != att->mapped_index(sibling_point_id)) {
+        no_interior_seams_ = false;
+        is_edge_on_seam_[c.value()] = true;
+        is_edge_on_seam_[opp_corner.value()] = true;
+        // Mark seam vertices.
+        is_vertex_on_seam_[corner_table_
+                               ->Vertex(corner_table_->Next(CornerIndex(c)))
+                               .value()] = true;
+        is_vertex_on_seam_[corner_table_
+                               ->Vertex(corner_table_->Previous(CornerIndex(c)))
+                               .value()] = true;
+        is_vertex_on_seam_
+            [corner_table_->Vertex(corner_table_->Next(opp_corner)).value()] =
+                true;
+        is_vertex_on_seam_[corner_table_
+                               ->Vertex(corner_table_->Previous(opp_corner))
+                               .value()] = true;
+        break;
+      }
+    }
+  }
+  RecomputeVertices(mesh, att);
+  return true;
+}
+
+void MeshAttributeCornerTable::AddSeamEdge(CornerIndex c) {
+  DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+  is_edge_on_seam_[c.value()] = true;
+  // Mark seam vertices.
+  is_vertex_on_seam_[corner_table_->Vertex(corner_table_->Next(c)).value()] =
+      true;
+  is_vertex_on_seam_[corner_table_->Vertex(corner_table_->Previous(c))
+                         .value()] = true;
+
+  const CornerIndex opp_corner = corner_table_->Opposite(c);
+  if (opp_corner != kInvalidCornerIndex) {
+    no_interior_seams_ = false;
+    is_edge_on_seam_[opp_corner.value()] = true;
+    is_vertex_on_seam_[corner_table_->Vertex(corner_table_->Next(opp_corner))
+                           .value()] = true;
+    is_vertex_on_seam_
+        [corner_table_->Vertex(corner_table_->Previous(opp_corner)).value()] =
+            true;
+  }
+}
+
+void MeshAttributeCornerTable::RecomputeVertices(const Mesh *mesh,
+                                                 const PointAttribute *att) {
+  DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+  if (mesh != nullptr && att != nullptr) {
+    RecomputeVerticesInternal<true>(mesh, att);
+  } else {
+    RecomputeVerticesInternal<false>(nullptr, nullptr);
+  }
+}
+
+template <bool init_vertex_to_attribute_entry_map>
+void MeshAttributeCornerTable::RecomputeVerticesInternal(
+    const Mesh *mesh, const PointAttribute *att) {
+  DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+  vertex_to_attribute_entry_id_map_.clear();
+  vertex_to_left_most_corner_map_.clear();
+  int num_new_vertices = 0;
+  for (VertexIndex v(0); v < corner_table_->num_vertices(); ++v) {
+    const CornerIndex c = corner_table_->LeftMostCorner(v);
+    if (c == kInvalidCornerIndex) {
+      continue;  // Isolated vertex?
+    }
+    AttributeValueIndex first_vert_id(num_new_vertices++);
+    if (init_vertex_to_attribute_entry_map) {
+      const PointIndex point_id = mesh->CornerToPointId(c.value());
+      vertex_to_attribute_entry_id_map_.push_back(att->mapped_index(point_id));
+    } else {
+      // Identity mapping
+      vertex_to_attribute_entry_id_map_.push_back(first_vert_id);
+    }
+    CornerIndex first_c = c;
+    CornerIndex act_c;
+    // Check if the vertex is on a seam edge, if it is we need to find the first
+    // attribute entry on the seam edge when traversing in the CCW direction.
+    if (is_vertex_on_seam_[v.value()]) {
+      // Try to swing left on the modified corner table. We need to get the
+      // first corner that defines an attribute seam.
+      act_c = SwingLeft(first_c);
+      while (act_c != kInvalidCornerIndex) {
+        first_c = act_c;
+        act_c = SwingLeft(act_c);
+      }
+    }
+    corner_to_vertex_map_[first_c.value()] = VertexIndex(first_vert_id.value());
+    vertex_to_left_most_corner_map_.push_back(first_c);
+    act_c = corner_table_->SwingRight(first_c);
+    while (act_c != kInvalidCornerIndex && act_c != first_c) {
+      if (IsCornerOppositeToSeamEdge(corner_table_->Next(act_c))) {
+        first_vert_id = AttributeValueIndex(num_new_vertices++);
+        if (init_vertex_to_attribute_entry_map) {
+          const PointIndex point_id = mesh->CornerToPointId(act_c.value());
+          vertex_to_attribute_entry_id_map_.push_back(
+              att->mapped_index(point_id));
+        } else {
+          // Identity mapping.
+          vertex_to_attribute_entry_id_map_.push_back(first_vert_id);
+        }
+        vertex_to_left_most_corner_map_.push_back(act_c);
+      }
+      corner_to_vertex_map_[act_c.value()] = VertexIndex(first_vert_id.value());
+      act_c = corner_table_->SwingRight(act_c);
+    }
+  }
+}
+
+int MeshAttributeCornerTable::Valence(VertexIndex v) const {
+  if (v == kInvalidVertexIndex) {
+    return -1;
+  }
+  return ConfidentValence(v);
+}
+
+int MeshAttributeCornerTable::ConfidentValence(VertexIndex v) const {
+  DRACO_DCHECK_LT(v.value(), num_vertices());
+  draco::VertexRingIterator<MeshAttributeCornerTable> vi(this, v);
+  int valence = 0;
+  for (; !vi.End(); vi.Next()) {
+    ++valence;
+  }
+  return valence;
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_attribute_corner_table.h b/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_attribute_corner_table.h
new file mode 100644
index 000000000..7dad25cf1
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_attribute_corner_table.h
@@ -0,0 +1,196 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MESH_MESH_ATTRIBUTE_CORNER_TABLE_H_
+#define DRACO_MESH_MESH_ATTRIBUTE_CORNER_TABLE_H_
+
+#include "draco/core/macros.h"
+#include "draco/mesh/corner_table.h"
+#include "draco/mesh/mesh.h"
+#include "draco/mesh/valence_cache.h"
+
+namespace draco {
+
+// Class for storing connectivity of mesh attributes. The connectivity is stored
+// as a difference from the base mesh's corner table, where the differences are
+// represented by attribute seam edges. This class provides a basic
+// functionality for detecting the seam edges for a given attribute and for
+// traversing the constrained corner table with the seam edges.
+class MeshAttributeCornerTable {
+ public:
+  MeshAttributeCornerTable();
+  bool InitEmpty(const CornerTable *table);
+  bool InitFromAttribute(const Mesh *mesh, const CornerTable *table,
+                         const PointAttribute *att);
+
+  void AddSeamEdge(CornerIndex opp_corner);
+
+  // Recomputes vertices using the newly added seam edges (needs to be called
+  // whenever the seam edges are updated).
+  // |mesh| and |att| can be null, in which case mapping between vertices and
+  // attribute value ids is set to identity.
+  void RecomputeVertices(const Mesh *mesh, const PointAttribute *att);
+
+  inline bool IsCornerOppositeToSeamEdge(CornerIndex corner) const {
+    return is_edge_on_seam_[corner.value()];
+  }
+
+  inline CornerIndex Opposite(CornerIndex corner) const {
+    if (corner == kInvalidCornerIndex || IsCornerOppositeToSeamEdge(corner)) {
+      return kInvalidCornerIndex;
+    }
+    return corner_table_->Opposite(corner);
+  }
+
+  inline CornerIndex Next(CornerIndex corner) const {
+    return corner_table_->Next(corner);
+  }
+
+  inline CornerIndex Previous(CornerIndex corner) const {
+    return corner_table_->Previous(corner);
+  }
+
+  // Returns true when a corner is attached to any attribute seam.
+  inline bool IsCornerOnSeam(CornerIndex corner) const {
+    return is_vertex_on_seam_[corner_table_->Vertex(corner).value()];
+  }
+
+  // Similar to CornerTable::GetLeftCorner and CornerTable::GetRightCorner, but
+  // does not go over seam edges.
+  inline CornerIndex GetLeftCorner(CornerIndex corner) const {
+    return Opposite(Previous(corner));
+  }
+  inline CornerIndex GetRightCorner(CornerIndex corner) const {
+    return Opposite(Next(corner));
+  }
+
+  // Similar to CornerTable::SwingRight, but it does not go over seam edges.
+  inline CornerIndex SwingRight(CornerIndex corner) const {
+    return Previous(Opposite(Previous(corner)));
+  }
+
+  // Similar to CornerTable::SwingLeft, but it does not go over seam edges.
+  inline CornerIndex SwingLeft(CornerIndex corner) const {
+    return Next(Opposite(Next(corner)));
+  }
+
+  int num_vertices() const {
+    return static_cast<int>(vertex_to_attribute_entry_id_map_.size());
+  }
+  int num_faces() const { return static_cast<int>(corner_table_->num_faces()); }
+  int num_corners() const { return corner_table_->num_corners(); }
+
+  VertexIndex Vertex(CornerIndex corner) const {
+    DRACO_DCHECK_LT(corner.value(), corner_to_vertex_map_.size());
+    return ConfidentVertex(corner);
+  }
+  VertexIndex ConfidentVertex(CornerIndex corner) const {
+    return corner_to_vertex_map_[corner.value()];
+  }
+  // Returns the attribute entry id associated to the given vertex.
+  VertexIndex VertexParent(VertexIndex vert) const {
+    return VertexIndex(vertex_to_attribute_entry_id_map_[vert.value()].value());
+  }
+
+  inline CornerIndex LeftMostCorner(VertexIndex v) const {
+    return vertex_to_left_most_corner_map_[v.value()];
+  }
+
+  inline FaceIndex Face(CornerIndex corner) const {
+    return corner_table_->Face(corner);
+  }
+
+  inline CornerIndex FirstCorner(FaceIndex face) const {
+    return corner_table_->FirstCorner(face);
+  }
+
+  inline std::array<CornerIndex, 3> AllCorners(FaceIndex face) const {
+    return corner_table_->AllCorners(face);
+  }
+
+  inline bool IsOnBoundary(VertexIndex vert) const {
+    const CornerIndex corner = LeftMostCorner(vert);
+    if (corner == kInvalidCornerIndex) {
+      return true;
+    }
+    if (SwingLeft(corner) == kInvalidCornerIndex) {
+      return true;
+    }
+    return false;
+  }
+
+  bool no_interior_seams() const { return no_interior_seams_; }
+  const CornerTable *corner_table() const { return corner_table_; }
+
+  // TODO(draco-eng): extract valence functions into a reusable class/object
+  // also from 'corner_table.*'
+
+  // Returns the valence (or degree) of a vertex.
+  // Returns -1 if the given vertex index is not valid.
+  int Valence(VertexIndex v) const;
+  // Same as above but does not check for validity and does not return -1
+  int ConfidentValence(VertexIndex v) const;
+  // Returns the valence of the vertex at the given corner.
+  inline int Valence(CornerIndex c) const {
+    DRACO_DCHECK_LT(c.value(), corner_table_->num_corners());
+    if (c == kInvalidCornerIndex) {
+      return -1;
+    }
+    return ConfidentValence(c);
+  }
+  inline int ConfidentValence(CornerIndex c) const {
+    DRACO_DCHECK_LT(c.value(), corner_table_->num_corners());
+    return ConfidentValence(Vertex(c));
+  }
+
+  // Allows access to an internal object for caching valences.  The object can
+  // be instructed to cache or uncache all valences and then its interfaces
+  // queried directly for valences with differing performance/confidence
+  // qualities.  If the mesh or table is modified the cache should be discarded
+  // and not relied on as it does not automatically update or invalidate for
+  // performance reasons.
+  const ValenceCache<MeshAttributeCornerTable> &GetValenceCache() const {
+    return valence_cache_;
+  }
+
+ private:
+  template <bool init_vertex_to_attribute_entry_map>
+  void RecomputeVerticesInternal(const Mesh *mesh, const PointAttribute *att);
+
+  std::vector<bool> is_edge_on_seam_;
+  std::vector<bool> is_vertex_on_seam_;
+
+  // If this is set to true, it means that there are no attribute seams between
+  // two faces. This can be used to speed up some algorithms.
+  bool no_interior_seams_;
+
+  std::vector<VertexIndex> corner_to_vertex_map_;
+
+  // Map between vertices and their associated left most corners. A left most
+  // corner is a corner that is adjacent to a boundary or an attribute seam from
+  // right (i.e., SwingLeft from that corner will return an invalid corner). If
+  // no such corner exists for a given vertex, then any corner attached to the
+  // vertex can be used.
+  std::vector<CornerIndex> vertex_to_left_most_corner_map_;
+
+  // Map between vertex ids and attribute entry ids (i.e. the values stored in
+  // the attribute buffer). The attribute entry id can be retrieved using the
+  // VertexParent() method.
+  std::vector<AttributeValueIndex> vertex_to_attribute_entry_id_map_;
+  const CornerTable *corner_table_;
+  ValenceCache<MeshAttributeCornerTable> valence_cache_;
+};
+
+}  // namespace draco
+#endif  // DRACO_MESH_MESH_ATTRIBUTE_CORNER_TABLE_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_cleanup.cc b/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_cleanup.cc
new file mode 100644
index 000000000..75b55f045
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_cleanup.cc
@@ -0,0 +1,251 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/mesh/mesh_cleanup.h"
+
+#include <unordered_set>
+
+#include "draco/core/hash_utils.h"
+
+namespace draco {
+
+bool MeshCleanup::operator()(Mesh *mesh, const MeshCleanupOptions &options) {
+  if (!options.remove_degenerated_faces && !options.remove_unused_attributes &&
+      !options.remove_duplicate_faces && !options.make_geometry_manifold) {
+    return true;  // Nothing to cleanup.
+  }
+  const PointAttribute *const pos_att =
+      mesh->GetNamedAttribute(GeometryAttribute::POSITION);
+  if (pos_att == nullptr) {
+    return false;
+  }
+
+  if (options.remove_degenerated_faces) {
+    RemoveDegeneratedFaces(mesh);
+  }
+
+  if (options.remove_duplicate_faces) {
+    RemoveDuplicateFaces(mesh);
+  }
+
+  if (options.remove_unused_attributes) {
+    RemoveUnusedAttributes(mesh);
+  }
+
+  return true;
+}
+
+void MeshCleanup::RemoveDegeneratedFaces(Mesh *mesh) {
+  const PointAttribute *const pos_att =
+      mesh->GetNamedAttribute(GeometryAttribute::POSITION);
+  FaceIndex::ValueType num_degenerated_faces = 0;
+  // Array for storing position indices on a face.
+  std::array<AttributeValueIndex, 3> pos_indices;
+  for (FaceIndex f(0); f < mesh->num_faces(); ++f) {
+    const Mesh::Face &face = mesh->face(f);
+    for (int p = 0; p < 3; ++p) {
+      pos_indices[p] = pos_att->mapped_index(face[p]);
+    }
+    if (pos_indices[0] == pos_indices[1] || pos_indices[0] == pos_indices[2] ||
+        pos_indices[1] == pos_indices[2]) {
+      ++num_degenerated_faces;
+    } else if (num_degenerated_faces > 0) {
+      // Copy the face to its new location.
+      mesh->SetFace(f - num_degenerated_faces, face);
+    }
+  }
+  if (num_degenerated_faces > 0) {
+    mesh->SetNumFaces(mesh->num_faces() - num_degenerated_faces);
+  }
+}
+
+void MeshCleanup::RemoveDuplicateFaces(Mesh *mesh) {
+  const PointAttribute *const pos_att =
+      mesh->GetNamedAttribute(GeometryAttribute::POSITION);
+
+  typedef std::array<AttributeValueIndex::ValueType, 3> PosTriplet;
+  PosTriplet pos_indices;
+  std::unordered_set<PosTriplet, HashArray<PosTriplet>> is_face_used;
+
+  uint32_t num_duplicate_faces = 0;
+  for (FaceIndex fi(0); fi < mesh->num_faces(); ++fi) {
+    const auto f = mesh->face(fi);
+    for (int c = 0; c < 3; ++c) {
+      pos_indices[c] = pos_att->mapped_index(f[c]).value();
+    }
+    // Shift the position indices until the smallest index is the first one.
+    while (pos_indices[0] > pos_indices[1] || pos_indices[0] > pos_indices[2]) {
+      // Shift to the left.
+      std::swap(pos_indices[0], pos_indices[1]);
+      std::swap(pos_indices[1], pos_indices[2]);
+    }
+    // Check if have encountered the same position triplet on a different face.
+    if (is_face_used.find(pos_indices) != is_face_used.end()) {
+      // Duplicate face. Ignore it.
+      num_duplicate_faces++;
+    } else {
+      // Insert new face to the set.
+      is_face_used.insert(pos_indices);
+      if (num_duplicate_faces > 0) {
+        // Copy the face to its new location.
+        mesh->SetFace(fi - num_duplicate_faces, f);
+      }
+    }
+  }
+  if (num_duplicate_faces > 0) {
+    mesh->SetNumFaces(mesh->num_faces() - num_duplicate_faces);
+  }
+}
+
+void MeshCleanup::RemoveUnusedAttributes(Mesh *mesh) {
+  // Array that is going to store whether a corresponding point is used.
+  std::vector<bool> is_point_used;
+  PointIndex::ValueType num_new_points = 0;
+  is_point_used.resize(mesh->num_points(), false);
+  for (FaceIndex f(0); f < mesh->num_faces(); ++f) {
+    const Mesh::Face &face = mesh->face(f);
+    for (int p = 0; p < 3; ++p) {
+      if (!is_point_used[face[p].value()]) {
+        is_point_used[face[p].value()] = true;
+        ++num_new_points;
+      }
+    }
+  }
+
+  bool points_changed = false;
+  const PointIndex::ValueType num_original_points = mesh->num_points();
+  // Map from old points to the new ones.
+  IndexTypeVector<PointIndex, PointIndex> point_map(num_original_points);
+  if (num_new_points < static_cast<int>(mesh->num_points())) {
+    // Some of the points were removed. We need to remap the old points to the
+    // new ones.
+    num_new_points = 0;
+    for (PointIndex i(0); i < num_original_points; ++i) {
+      if (is_point_used[i.value()]) {
+        point_map[i] = num_new_points++;
+      } else {
+        point_map[i] = kInvalidPointIndex;
+      }
+    }
+    // Go over faces and update their points.
+    for (FaceIndex f(0); f < mesh->num_faces(); ++f) {
+      Mesh::Face face = mesh->face(f);
+      for (int p = 0; p < 3; ++p) {
+        face[p] = point_map[face[p]];
+      }
+      mesh->SetFace(f, face);
+    }
+    // Set the new number of points.
+    mesh->set_num_points(num_new_points);
+    points_changed = true;
+  } else {
+    // No points were removed. Initialize identity map between the old and new
+    // points.
+    for (PointIndex i(0); i < num_original_points; ++i) {
+      point_map[i] = i;
+    }
+  }
+
+  // Update index mapping for attributes.
+  IndexTypeVector<AttributeValueIndex, uint8_t> is_att_index_used;
+  IndexTypeVector<AttributeValueIndex, AttributeValueIndex> att_index_map;
+  for (int a = 0; a < mesh->num_attributes(); ++a) {
+    PointAttribute *const att = mesh->attribute(a);
+    // First detect which attribute entries are used (included in a point).
+    is_att_index_used.assign(att->size(), 0);
+    att_index_map.clear();
+    AttributeValueIndex::ValueType num_used_entries = 0;
+    for (PointIndex i(0); i < num_original_points; ++i) {
+      if (point_map[i] != kInvalidPointIndex) {
+        const AttributeValueIndex entry_id = att->mapped_index(i);
+        if (!is_att_index_used[entry_id]) {
+          is_att_index_used[entry_id] = 1;
+          ++num_used_entries;
+        }
+      }
+    }
+    bool att_indices_changed = false;
+    // If there are some unused attribute entries, remap the attribute values
+    // in the attribute buffer.
+    if (num_used_entries < static_cast<int>(att->size())) {
+      att_index_map.resize(att->size());
+      num_used_entries = 0;
+      for (AttributeValueIndex i(0); i < static_cast<uint32_t>(att->size());
+           ++i) {
+        if (is_att_index_used[i]) {
+          att_index_map[i] = num_used_entries;
+          if (i > num_used_entries) {
+            const uint8_t *const src_add = att->GetAddress(i);
+            att->buffer()->Write(
+                att->GetBytePos(AttributeValueIndex(num_used_entries)), src_add,
+                att->byte_stride());
+          }
+          ++num_used_entries;
+        }
+      }
+      // Update the number of unique entries in the vertex buffer.
+      att->Resize(num_used_entries);
+      att_indices_changed = true;
+    }
+    // If either the points or attribute indices have changed, we need to
+    // update the attribute index mapping.
+    if (points_changed || att_indices_changed) {
+      if (att->is_mapping_identity()) {
+        // The mapping was identity. It'll remain identity only if the
+        // number of point and attribute indices is still the same.
+        if (num_used_entries != static_cast<int>(mesh->num_points())) {
+          // We need to create an explicit mapping.
+          // First we need to initialize the explicit map to the original
+          // number of points to recreate the original identity map.
+          att->SetExplicitMapping(num_original_points);
+          // Set the entries of the explicit map to identity.
+          for (PointIndex::ValueType i = 0; i < num_original_points; ++i) {
+            att->SetPointMapEntry(PointIndex(i), AttributeValueIndex(i));
+          }
+        }
+      }
+      if (!att->is_mapping_identity()) {
+        // Explicit mapping between points and local attribute indices.
+        for (PointIndex i(0); i < num_original_points; ++i) {
+          // The new point id that maps to the currently processed attribute
+          // entry.
+          const PointIndex new_point_id = point_map[i];
+          if (new_point_id == kInvalidPointIndex) {
+            continue;
+          }
+          // Index of the currently processed attribute entry in the original
+          // mesh.
+          const AttributeValueIndex original_entry_index = att->mapped_index(i);
+          // New index of the same entry after unused entries were removed.
+          const AttributeValueIndex new_entry_index =
+              att_indices_changed ? att_index_map[original_entry_index]
+                                  : original_entry_index;
+
+          // Update the mapping. Note that the new point index is always smaller
+          // than the processed index |i|, making this operation safe.
+          att->SetPointMapEntry(new_point_id, new_entry_index);
+        }
+        // If the number of points changed, we need to set a new explicit map
+        // size.
+        att->SetExplicitMapping(mesh->num_points());
+      }
+    }
+  }
+}
+
+Status MeshCleanup::MakeGeometryManifold(Mesh *mesh) {
+  return Status(Status::DRACO_ERROR, "Unsupported function.");
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_cleanup.h b/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_cleanup.h
new file mode 100644
index 000000000..09aae2e1c
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_cleanup.h
@@ -0,0 +1,65 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MESH_MESH_CLEANUP_H_
+#define DRACO_MESH_MESH_CLEANUP_H_
+
+#include "draco/core/status.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Options used by the MeshCleanup class.
+struct MeshCleanupOptions {
+  MeshCleanupOptions()
+      : remove_degenerated_faces(true),
+        remove_duplicate_faces(true),
+        remove_unused_attributes(true),
+        make_geometry_manifold(false) {}
+  // If true, the cleanup tool removes any face where two or more vertices
+  // share the same position index.
+  bool remove_degenerated_faces;
+
+  // If true, the cleanup tool removes all duplicate faces. A pair of faces is
+  // duplicate if both faces share the same position indices on all vertices
+  // (that is, position values have to be duduplicated). Note that all
+  // non-position properties are currently ignored.
+  bool remove_duplicate_faces;
+
+  // If true, the cleanup tool removes any unused attribute value or unused
+  // point id. For example, it can be used to remove isolated vertices.
+  bool remove_unused_attributes;
+
+  // If true, the cleanup tool splits vertices along non-manifold edges and
+  // vertices. This ensures that the connectivity defined by position indices
+  // is manifold.
+  bool make_geometry_manifold;
+};
+
+// Tool that can be used for removing bad or unused data from draco::Meshes.
+class MeshCleanup {
+ public:
+  // Performs in-place cleanup of the input mesh according to the input options.
+  bool operator()(Mesh *mesh, const MeshCleanupOptions &options);
+
+ private:
+  static void RemoveDegeneratedFaces(Mesh *mesh);
+  static void RemoveDuplicateFaces(Mesh *mesh);
+  static void RemoveUnusedAttributes(Mesh *mesh);
+  static Status MakeGeometryManifold(Mesh *mesh);
+};
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_MESH_CLEANUP_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_cleanup_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_cleanup_test.cc
new file mode 100644
index 000000000..89c350e94
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_cleanup_test.cc
@@ -0,0 +1,192 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/mesh/mesh_cleanup.h"
+
+#include "draco/core/draco_test_base.h"
+#include "draco/core/vector_d.h"
+#include "draco/mesh/triangle_soup_mesh_builder.h"
+
+namespace draco {
+
+class MeshCleanupTest : public ::testing::Test {};
+
+TEST_F(MeshCleanupTest, TestDegneratedFaces) {
+  // This test verifies that the mesh cleanup tools removes degenerated faces.
+  TriangleSoupMeshBuilder mb;
+  mb.Start(2);
+  const int pos_att_id =
+      mb.AddAttribute(GeometryAttribute::POSITION, 3, DT_FLOAT32);
+  // clang-format off
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(0),
+                               Vector3f(0.f, 0.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(0.f, 1.f, 0.f).data());
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(1),
+                               Vector3f(0.f, 1.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data());
+  // clang-format on
+
+  std::unique_ptr<Mesh> mesh = mb.Finalize();
+  ASSERT_NE(mesh, nullptr) << "Failed to build the test mesh.";
+  ASSERT_EQ(mesh->num_faces(), 2) << "Wrong number of faces in the input mesh.";
+  MeshCleanupOptions cleanup_options;
+  MeshCleanup cleanup;
+  ASSERT_TRUE(cleanup(mesh.get(), cleanup_options))
+      << "Failed to cleanup the mesh.";
+  ASSERT_EQ(mesh->num_faces(), 1) << "Failed to remove degenerated faces.";
+}
+
+TEST_F(MeshCleanupTest, TestDegneratedFacesAndIsolatedVertices) {
+  // This test verifies that the mesh cleanup tools removes degenerated faces
+  // and isolated vertices.
+  TriangleSoupMeshBuilder mb;
+  mb.Start(2);
+  const int pos_att_id =
+      mb.AddAttribute(GeometryAttribute::POSITION, 3, DT_FLOAT32);
+
+  // Dummy integer attribute for which we do not expect the number of entries
+  // to change after the degnerate face and isolated vertex are removed.
+  const int int_att_id =
+      mb.AddAttribute(GeometryAttribute::GENERIC, 2, DT_INT32);
+
+  // clang-format off
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(0),
+                               Vector3f(0.f, 0.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(0.f, 1.f, 0.f).data());
+  mb.SetAttributeValuesForFace(int_att_id, FaceIndex(0),
+                               VectorD<int32_t, 2>(0, 0).data(),
+                               VectorD<int32_t, 2>(0, 1).data(),
+                               VectorD<int32_t, 2>(0, 2).data());
+
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(1),
+                               Vector3f(10.f, 1.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(10.f, 1.f, 0.f).data());
+  mb.SetAttributeValuesForFace(int_att_id, FaceIndex(1),
+                               VectorD<int32_t, 2>(0, 0).data(),
+                               VectorD<int32_t, 2>(0, 1).data(),
+                               VectorD<int32_t, 2>(0, 2).data());
+  // clang-format on
+
+  std::unique_ptr<Mesh> mesh = mb.Finalize();
+  ASSERT_NE(mesh, nullptr) << "Failed to build the test mesh.";
+  ASSERT_EQ(mesh->num_faces(), 2) << "Wrong number of faces in the input mesh.";
+  ASSERT_EQ(mesh->num_points(), 5)
+      << "Wrong number of point ids in the input mesh.";
+  ASSERT_EQ(mesh->attribute(int_att_id)->size(), 3);
+  const MeshCleanupOptions cleanup_options;
+  MeshCleanup cleanup;
+  ASSERT_TRUE(cleanup(mesh.get(), cleanup_options))
+      << "Failed to cleanup the mesh.";
+  ASSERT_EQ(mesh->num_faces(), 1) << "Failed to remove degenerated faces.";
+  ASSERT_EQ(mesh->num_points(), 3)
+      << "Failed to remove isolated attribute indices.";
+  ASSERT_EQ(mesh->attribute(int_att_id)->size(), 3);
+}
+
+TEST_F(MeshCleanupTest, TestAttributes) {
+  TriangleSoupMeshBuilder mb;
+  mb.Start(2);
+  const int pos_att_id =
+      mb.AddAttribute(GeometryAttribute::POSITION, 3, DT_FLOAT32);
+  const int generic_att_id =
+      mb.AddAttribute(GeometryAttribute::GENERIC, 2, DT_FLOAT32);
+  // clang-format off
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(0),
+                               Vector3f(0.f, 0.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(0.f, 1.f, 0.f).data());
+  mb.SetAttributeValuesForFace(generic_att_id, FaceIndex(0),
+                               Vector2f(0.f, 0.f).data(),
+                               Vector2f(0.f, 0.f).data(),
+                               Vector2f(0.f, 0.f).data());
+
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(1),
+                               Vector3f(10.f, 1.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(10.f, 1.f, 0.f).data());
+  mb.SetAttributeValuesForFace(generic_att_id, FaceIndex(1),
+                               Vector2f(1.f, 0.f).data(),
+                               Vector2f(1.f, 0.f).data(),
+                               Vector2f(1.f, 0.f).data());
+  // clang-format on
+
+  std::unique_ptr<Mesh> mesh = mb.Finalize();
+  ASSERT_NE(mesh, nullptr) << "Failed to build the test mesh.";
+  ASSERT_EQ(mesh->num_faces(), 2) << "Wrong number of faces in the input mesh.";
+  ASSERT_EQ(mesh->num_points(), 5)
+      << "Wrong number of point ids in the input mesh.";
+  ASSERT_EQ(mesh->attribute(1)->size(), 2u)
+      << "Wrong number of generic attribute entries.";
+  const MeshCleanupOptions cleanup_options;
+  MeshCleanup cleanup;
+  ASSERT_TRUE(cleanup(mesh.get(), cleanup_options))
+      << "Failed to cleanup the mesh.";
+  ASSERT_EQ(mesh->num_faces(), 1) << "Failed to remove degenerated faces.";
+  ASSERT_EQ(mesh->num_points(), 3)
+      << "Failed to remove isolated attribute indices.";
+  ASSERT_EQ(mesh->attribute(0)->size(), 3u)
+      << "Wrong number of unique positions after cleanup.";
+  ASSERT_EQ(mesh->attribute(1)->size(), 1u)
+      << "Wrong number of generic attribute entries after cleanup.";
+}
+
+TEST_F(MeshCleanupTest, TestDuplicateFaces) {
+  TriangleSoupMeshBuilder mb;
+  mb.Start(5);
+  const int pos_att_id =
+      mb.AddAttribute(GeometryAttribute::POSITION, 3, DT_FLOAT32);
+
+  // Five faces where only two are unique.
+
+  // clang-format off
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(0),
+                               Vector3f(0.f, 0.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(0.f, 1.f, 0.f).data());
+
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(1),
+                               Vector3f(0.f, 0.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(0.f, 1.f, 0.f).data());
+
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(2),
+                               Vector3f(0.f, 0.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(0.f, 1.f, 1.f).data());
+
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(3),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(0.f, 1.f, 0.f).data(),
+                              Vector3f(0.f, 0.f, 0.f).data());
+
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(4),
+                               Vector3f(0.f, 0.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(0.f, 1.f, 1.f).data());
+  // clang-format on
+
+  std::unique_ptr<Mesh> mesh = mb.Finalize();
+  ASSERT_NE(mesh, nullptr);
+  ASSERT_EQ(mesh->num_faces(), 5);
+  const MeshCleanupOptions cleanup_options;
+  MeshCleanup cleanup;
+  ASSERT_TRUE(cleanup(mesh.get(), cleanup_options));
+  ASSERT_EQ(mesh->num_faces(), 2);
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_misc_functions.cc b/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_misc_functions.cc
new file mode 100644
index 000000000..4485b3369
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_misc_functions.cc
@@ -0,0 +1,63 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/mesh/mesh_misc_functions.h"
+
+namespace draco {
+
+std::unique_ptr<CornerTable> CreateCornerTableFromPositionAttribute(
+    const Mesh *mesh) {
+  return CreateCornerTableFromAttribute(mesh, GeometryAttribute::POSITION);
+}
+
+std::unique_ptr<CornerTable> CreateCornerTableFromAttribute(
+    const Mesh *mesh, GeometryAttribute::Type type) {
+  typedef CornerTable::FaceType FaceType;
+
+  const PointAttribute *const att = mesh->GetNamedAttribute(type);
+  if (att == nullptr) {
+    return nullptr;
+  }
+  IndexTypeVector<FaceIndex, FaceType> faces(mesh->num_faces());
+  FaceType new_face;
+  for (FaceIndex i(0); i < mesh->num_faces(); ++i) {
+    const Mesh::Face &face = mesh->face(i);
+    for (int j = 0; j < 3; ++j) {
+      // Map general vertex indices to attribute indices.
+      new_face[j] = att->mapped_index(face[j]).value();
+    }
+    faces[FaceIndex(i)] = new_face;
+  }
+  // Build the corner table.
+  return CornerTable::Create(faces);
+}
+
+std::unique_ptr<CornerTable> CreateCornerTableFromAllAttributes(
+    const Mesh *mesh) {
+  typedef CornerTable::FaceType FaceType;
+  IndexTypeVector<FaceIndex, FaceType> faces(mesh->num_faces());
+  FaceType new_face;
+  for (FaceIndex i(0); i < mesh->num_faces(); ++i) {
+    const Mesh::Face &face = mesh->face(i);
+    // Each face is identified by point indices that automatically split the
+    // mesh along attribute seams.
+    for (int j = 0; j < 3; ++j) {
+      new_face[j] = face[j].value();
+    }
+    faces[i] = new_face;
+  }
+  // Build the corner table.
+  return CornerTable::Create(faces);
+}
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_misc_functions.h b/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_misc_functions.h
new file mode 100644
index 000000000..b450bc80c
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_misc_functions.h
@@ -0,0 +1,98 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// This file contains misc functions that are needed by several mesh related
+// algorithms.
+
+#ifndef DRACO_MESH_MESH_MISC_FUNCTIONS_H_
+#define DRACO_MESH_MESH_MISC_FUNCTIONS_H_
+
+#include "draco/mesh/corner_table.h"
+#include "draco/mesh/mesh.h"
+
+// The file contains functions that use both Mesh and CornerTable as inputs.
+namespace draco {
+
+// Creates a CornerTable from the position attribute of |mesh|. Returns nullptr
+// on error.
+std::unique_ptr<CornerTable> CreateCornerTableFromPositionAttribute(
+    const Mesh *mesh);
+
+// Creates a CornerTable from the first named attribute of |mesh| with a given
+// type. Returns nullptr on error.
+std::unique_ptr<CornerTable> CreateCornerTableFromAttribute(
+    const Mesh *mesh, GeometryAttribute::Type type);
+
+// Creates a CornerTable from all attributes of |mesh|. Boundaries are
+// automatically introduced on all attribute seams. Returns nullptr on error.
+std::unique_ptr<CornerTable> CreateCornerTableFromAllAttributes(
+    const Mesh *mesh);
+
+// Returns true when the given corner lies opposite to an attribute seam.
+inline bool IsCornerOppositeToAttributeSeam(CornerIndex ci,
+                                            const PointAttribute &att,
+                                            const Mesh &mesh,
+                                            const CornerTable &ct) {
+  const CornerIndex opp_ci = ct.Opposite(ci);
+  if (opp_ci == kInvalidCornerIndex) {
+    return false;  // No opposite corner == no attribute seam.
+  }
+  // Compare attribute value indices on both ends of the opposite edge.
+  CornerIndex c0 = ct.Next(ci);
+  CornerIndex c1 = ct.Previous(opp_ci);
+  if (att.mapped_index(mesh.CornerToPointId(c0)) !=
+      att.mapped_index(mesh.CornerToPointId(c1))) {
+    return true;
+  }
+  c0 = ct.Previous(ci);
+  c1 = ct.Next(opp_ci);
+  if (att.mapped_index(mesh.CornerToPointId(c0)) !=
+      att.mapped_index(mesh.CornerToPointId(c1))) {
+    return true;
+  }
+  return false;
+}
+
+// Interpolates an attribute value on a face using given barycentric
+// coordinates. InterpolatedVectorT should be a VectorD that corresponds to the
+// values stored in the attribute.
+// TODO(ostava): Find a better place for this.
+template <typename InterpolatedVectorT>
+InterpolatedVectorT ComputeInterpolatedAttributeValueOnMeshFace(
+    const Mesh &mesh, const PointAttribute &attribute, FaceIndex fi,
+    const std::array<float, 3> &barycentric_coord) {
+  const Mesh::Face &face = mesh.face(fi);
+  // Get values for all three corners of the face.
+  InterpolatedVectorT val[3];
+  for (int c = 0; c < 3; ++c) {
+    attribute.GetMappedValue(face[c], &(val[c][0]));
+  }
+  // Return an interpolated value.
+  InterpolatedVectorT res;
+  for (int d = 0; d < InterpolatedVectorT::dimension; ++d) {
+    const float interpolated_component = barycentric_coord[0] * val[0][d] +
+                                         barycentric_coord[1] * val[1][d] +
+                                         barycentric_coord[2] * val[2][d];
+    if (std::is_integral<typename InterpolatedVectorT::Scalar>::value) {
+      res[d] = std::floor(interpolated_component + 0.5f);
+    } else {
+      res[d] = interpolated_component;
+    }
+  }
+  return res;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_MESH_MISC_FUNCTIONS_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_stripifier.cc b/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_stripifier.cc
new file mode 100644
index 000000000..f68062eba
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_stripifier.cc
@@ -0,0 +1,102 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/mesh/mesh_stripifier.h"
+
+namespace draco {
+
+void MeshStripifier::GenerateStripsFromCorner(int local_strip_id,
+                                              CornerIndex ci) {
+  // Clear the storage for strip faces.
+  strip_faces_[local_strip_id].clear();
+  // Start corner of the strip (where the strip starts).
+  CornerIndex start_ci = ci;
+  FaceIndex fi = corner_table_->Face(ci);
+  // We need to grow the strip both forward and backward (2 passes).
+  // Note that the backward pass can change the start corner of the strip (the
+  // start corner is going to be moved to the end of the backward strip).
+  for (int pass = 0; pass < 2; ++pass) {
+    if (pass == 1) {
+      // Backward pass.
+      // Start the traversal from the B that is the left sibling of the next
+      // corner to the start corner C = |start_ci|.
+      //
+      //      *-------*-------*-------*
+      //     / \     / \C    / \     /
+      //    /   \   /   \   /   \   /
+      //   /     \ /    B\ /     \ /
+      //  *-------*-------*-------*
+      //
+      // Perform the backward pass only when there is no attribute seam between
+      // the initial face and the first face of the backward traversal.
+      if (GetOppositeCorner(corner_table_->Previous(start_ci)) ==
+          kInvalidCornerIndex) {
+        break;  // Attribute seam or a boundary.
+      }
+
+      ci = corner_table_->Next(start_ci);
+      ci = corner_table_->SwingLeft(ci);
+      if (ci == kInvalidCornerIndex) {
+        break;
+      }
+
+      fi = corner_table_->Face(ci);
+    }
+    int num_added_faces = 0;
+    while (!is_face_visited_[fi]) {
+      is_face_visited_[fi] = true;
+      strip_faces_[local_strip_id].push_back(fi);
+      ++num_added_faces;
+      if (num_added_faces > 1) {
+        // Move to the correct source corner to traverse to the next face.
+        if (num_added_faces & 1) {
+          // Odd number of faces added.
+          ci = corner_table_->Next(ci);
+        } else {
+          // Even number of faces added.
+          if (pass == 1) {
+            // If we are processing the backward pass, update the start corner
+            // of the strip on every even face reached (we cannot use odd faces
+            // for start of the strip as the strips would start in a wrong
+            // direction).
+            start_ci = ci;
+          }
+          ci = corner_table_->Previous(ci);
+        }
+      }
+      ci = GetOppositeCorner(ci);
+      if (ci == kInvalidCornerIndex) {
+        break;
+      }
+      fi = corner_table_->Face(ci);
+    }
+    // Strip end reached.
+    if (pass == 1 && (num_added_faces & 1)) {
+      // If we processed the backward strip and we add an odd number of faces to
+      // the strip, we need to remove the last one as it cannot be used to start
+      // the strip (the strip would start in a wrong direction from that face).
+      is_face_visited_[strip_faces_[local_strip_id].back()] = false;
+      strip_faces_[local_strip_id].pop_back();
+    }
+  }
+  strip_start_corners_[local_strip_id] = start_ci;
+
+  // Reset all visited flags for all faces (we need to process other strips from
+  // the given face before we choose the final strip that we are going to use).
+  for (int i = 0; i < strip_faces_[local_strip_id].size(); ++i) {
+    is_face_visited_[strip_faces_[local_strip_id][i]] = false;
+  }
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_stripifier.h b/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_stripifier.h
new file mode 100644
index 000000000..262e3c792
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/mesh/mesh_stripifier.h
@@ -0,0 +1,260 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MESH_MESH_STRIPIFIER_H_
+#define DRACO_MESH_MESH_STRIPIFIER_H_
+
+#include "draco/mesh/mesh_misc_functions.h"
+
+namespace draco {
+
+// Class that generates triangle strips from a provided draco::Mesh data
+// structure. The strips represent a more memory efficient storage of triangle
+// connectivity that can be used directly on the GPU (see
+// https://en.wikipedia.org/wiki/Triangle_strip ). In general, a mesh needs to
+// be represented by several triangle strips and it has been proven that finding
+// the optimal set of triangle strips is an NP-complete problem. The algorithm
+// implemented by this class finds this set of triangle strips based on a greedy
+// heuristic that always selects the longest available strip that covers the
+// next unprocessed face. The longest strip is found by analyzing all strips
+// that can cover the given face (three strips corresponding to three
+// directions).
+class MeshStripifier {
+ public:
+  MeshStripifier()
+      : mesh_(nullptr),
+        num_strips_(0),
+        num_encoded_faces_(0),
+        last_encoded_point_(kInvalidPointIndex) {}
+
+  // Generate triangle strips for a given mesh and output them to the output
+  // iterator |out_it|. In most cases |out_it| stores the values in a buffer
+  // that can be used directly on the GPU. Note that the algorithm can generate
+  // multiple strips to represent the whole mesh. In such cases multiple strips
+  // are separated using a so called primitive restart index that is specified
+  // by the |primitive_restart_index| (usually defined as the maximum allowed
+  // value for the given type).
+  // https://www.khronos.org/opengl/wiki/Vertex_Rendering#Primitive_Restart
+  template <typename OutputIteratorT, typename IndexTypeT>
+  bool GenerateTriangleStripsWithPrimitiveRestart(
+      const Mesh &mesh, IndexTypeT primitive_restart_index,
+      OutputIteratorT out_it);
+
+  // The same as above but disjoint triangle strips are separated by degenerate
+  // triangles instead of the primitive restart index. Degenerate triangles are
+  // zero area triangles that are automatically discarded by the GPU. Using
+  // degenerate triangles usually results in a slightly longer output indices
+  // array compared to the similar triangle strips that use primitive restart
+  // index. The advantage of this method is that it is supported by all hardware
+  // and all relevant APIs (including WebGL 1.0).
+  template <typename OutputIteratorT>
+  bool GenerateTriangleStripsWithDegenerateTriangles(const Mesh &mesh,
+                                                     OutputIteratorT out_it);
+
+  // Returns the number of strips generated by the last call of the
+  // GenerateTriangleStrips() method.
+  int num_strips() const { return num_strips_; }
+
+ private:
+  bool Prepare(const Mesh &mesh) {
+    mesh_ = &mesh;
+    num_strips_ = 0;
+    num_encoded_faces_ = 0;
+    // TODO(ostava): We may be able to avoid computing the corner table if we
+    // already have it stored somewhere.
+    corner_table_ = CreateCornerTableFromPositionAttribute(mesh_);
+    if (corner_table_ == nullptr) {
+      return false;
+    }
+
+    // Mark all faces as unvisited.
+    is_face_visited_.assign(mesh.num_faces(), false);
+    return true;
+  }
+
+  // Returns local id of the longest strip that can be created from the given
+  // face |fi|.
+  int FindLongestStripFromFace(FaceIndex fi) {
+    // There are three possible strip directions that can contain the provided
+    // input face. We try all of them and select the direction that result in
+    // the longest strip.
+    const CornerIndex first_ci = corner_table_->FirstCorner(fi);
+    int longest_strip_id = -1;
+    int longest_strip_length = 0;
+    for (int i = 0; i < 3; ++i) {
+      GenerateStripsFromCorner(i, first_ci + i);
+      if (strip_faces_[i].size() > longest_strip_length) {
+        longest_strip_length = static_cast<int>(strip_faces_[i].size());
+        longest_strip_id = i;
+      }
+    }
+    return longest_strip_id;
+  }
+
+  // Generates strip from the data stored in |strip_faces_| and
+  // |strip_start_start_corners_| and stores it to |out_it|.
+  template <typename OutputIteratorT>
+  void StoreStrip(int local_strip_id, OutputIteratorT out_it) {
+    ++num_strips_;
+
+    const int num_strip_faces = strip_faces_[local_strip_id].size();
+    CornerIndex ci = strip_start_corners_[local_strip_id];
+    for (int i = 0; i < num_strip_faces; ++i) {
+      const FaceIndex fi = corner_table_->Face(ci);
+      is_face_visited_[fi] = true;
+      ++num_encoded_faces_;
+
+      if (i == 0) {
+        // Add the start face (three indices).
+        *out_it++ = CornerToPointIndex(ci).value();
+        *out_it++ = CornerToPointIndex(corner_table_->Next(ci)).value();
+        last_encoded_point_ = CornerToPointIndex(corner_table_->Previous(ci));
+        *out_it++ = last_encoded_point_.value();
+      } else {
+        // Store the point on the newly reached corner.
+        last_encoded_point_ = CornerToPointIndex(ci);
+        *out_it++ = last_encoded_point_.value();
+
+        // Go to the correct source corner to proceed to the next face.
+        if (i & 1) {
+          ci = corner_table_->Previous(ci);
+        } else {
+          ci = corner_table_->Next(ci);
+        }
+      }
+      ci = corner_table_->Opposite(ci);
+    }
+  }
+
+  PointIndex CornerToPointIndex(CornerIndex ci) const {
+    return mesh_->CornerToPointId(ci);
+  }
+
+  // Returns the opposite corner in case the opposite triangle does not lie
+  // across an attribute seam. Otherwise return kInvalidCornerIndex.
+  CornerIndex GetOppositeCorner(CornerIndex ci) const {
+    const CornerIndex oci = corner_table_->Opposite(ci);
+    if (oci < 0) {
+      return kInvalidCornerIndex;
+    }
+    // Ensure the point ids are same on both sides of the shared edge between
+    // the triangles.
+    if (CornerToPointIndex(corner_table_->Next(ci)) !=
+        CornerToPointIndex(corner_table_->Previous(oci))) {
+      return kInvalidCornerIndex;
+    }
+    if (CornerToPointIndex(corner_table_->Previous(ci)) !=
+        CornerToPointIndex(corner_table_->Next(oci))) {
+      return kInvalidCornerIndex;
+    }
+    return oci;
+  }
+
+  void GenerateStripsFromCorner(int local_strip_id, CornerIndex ci);
+
+  const Mesh *mesh_;
+  std::unique_ptr<CornerTable> corner_table_;
+
+  // Store strip faces for each of three possible directions from a given face.
+  std::vector<FaceIndex> strip_faces_[3];
+  // Start corner for each direction of the strip containing the processed face.
+  CornerIndex strip_start_corners_[3];
+  IndexTypeVector<FaceIndex, bool> is_face_visited_;
+  // The number of strips generated by this method.
+  int num_strips_;
+  // The number of encoded triangles.
+  int num_encoded_faces_;
+  // Last encoded point.
+  PointIndex last_encoded_point_;
+};
+
+template <typename OutputIteratorT, typename IndexTypeT>
+bool MeshStripifier::GenerateTriangleStripsWithPrimitiveRestart(
+    const Mesh &mesh, IndexTypeT primitive_restart_index,
+    OutputIteratorT out_it) {
+  if (!Prepare(mesh)) {
+    return false;
+  }
+
+  // Go over all faces and generate strips from the first unvisited one.
+  for (FaceIndex fi(0); fi < mesh.num_faces(); ++fi) {
+    if (is_face_visited_[fi]) {
+      continue;
+    }
+
+    const int longest_strip_id = FindLongestStripFromFace(fi);
+
+    // Separate triangle strips with the primitive restart index.
+    if (num_strips_ > 0) {
+      *out_it++ = primitive_restart_index;
+    }
+
+    StoreStrip(longest_strip_id, out_it);
+  }
+
+  return true;
+}
+
+template <typename OutputIteratorT>
+bool MeshStripifier::GenerateTriangleStripsWithDegenerateTriangles(
+    const Mesh &mesh, OutputIteratorT out_it) {
+  if (!Prepare(mesh)) {
+    return false;
+  }
+
+  // Go over all faces and generate strips from the first unvisited one.
+  for (FaceIndex fi(0); fi < mesh.num_faces(); ++fi) {
+    if (is_face_visited_[fi]) {
+      continue;
+    }
+
+    const int longest_strip_id = FindLongestStripFromFace(fi);
+
+    // Separate triangle strips by degenerate triangles. There will be either
+    // three or four degenerate triangles inserted based on the number of
+    // triangles that are already encoded in the output strip (three degenerate
+    // triangles for even number of existing triangles, four degenerate
+    // triangles for odd number of triangles).
+    if (num_strips_ > 0) {
+      // Duplicate last encoded index (first degenerate face).
+      *out_it++ = last_encoded_point_.value();
+
+      // Connect it to the start point of the new triangle strip (second
+      // degenerate face).
+      const CornerIndex new_start_corner =
+          strip_start_corners_[longest_strip_id];
+      const PointIndex new_start_point = CornerToPointIndex(new_start_corner);
+      *out_it++ = new_start_point.value();
+      num_encoded_faces_ += 2;
+      // If we have previously encoded number of faces we need to duplicate the
+      // point one more time to preserve the correct orientation of the next
+      // strip.
+      if (num_encoded_faces_ & 1) {
+        *out_it++ = new_start_point.value();
+        num_encoded_faces_ += 1;
+      }
+      // The last degenerate face will be added implicitly in the StoreStrip()
+      // function below as the first point index is going to be encoded there
+      // again.
+    }
+
+    StoreStrip(longest_strip_id, out_it);
+  }
+
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_MESH_STRIPIFIER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/mesh/triangle_soup_mesh_builder.cc b/Engine/lib/assimp/contrib/draco/src/draco/mesh/triangle_soup_mesh_builder.cc
new file mode 100644
index 000000000..60b0c50b8
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/mesh/triangle_soup_mesh_builder.cc
@@ -0,0 +1,89 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/mesh/triangle_soup_mesh_builder.h"
+
+namespace draco {
+
+void TriangleSoupMeshBuilder::Start(int num_faces) {
+  mesh_ = std::unique_ptr<Mesh>(new Mesh());
+  mesh_->SetNumFaces(num_faces);
+  mesh_->set_num_points(num_faces * 3);
+  attribute_element_types_.clear();
+}
+
+int TriangleSoupMeshBuilder::AddAttribute(
+    GeometryAttribute::Type attribute_type, int8_t num_components,
+    DataType data_type) {
+  GeometryAttribute va;
+  va.Init(attribute_type, nullptr, num_components, data_type, false,
+          DataTypeLength(data_type) * num_components, 0);
+  attribute_element_types_.push_back(-1);
+  return mesh_->AddAttribute(va, true, mesh_->num_points());
+}
+
+void TriangleSoupMeshBuilder::SetAttributeValuesForFace(
+    int att_id, FaceIndex face_id, const void *corner_value_0,
+    const void *corner_value_1, const void *corner_value_2) {
+  const int start_index = 3 * face_id.value();
+  PointAttribute *const att = mesh_->attribute(att_id);
+  att->SetAttributeValue(AttributeValueIndex(start_index), corner_value_0);
+  att->SetAttributeValue(AttributeValueIndex(start_index + 1), corner_value_1);
+  att->SetAttributeValue(AttributeValueIndex(start_index + 2), corner_value_2);
+  // TODO(ostava): The below code should be called only for one attribute.
+  // It will work OK even for multiple attributes, but it's redundant.
+  mesh_->SetFace(face_id,
+                 {{PointIndex(start_index), PointIndex(start_index + 1),
+                   PointIndex(start_index + 2)}});
+  attribute_element_types_[att_id] = MESH_CORNER_ATTRIBUTE;
+}
+
+void TriangleSoupMeshBuilder::SetPerFaceAttributeValueForFace(
+    int att_id, FaceIndex face_id, const void *value) {
+  const int start_index = 3 * face_id.value();
+  PointAttribute *const att = mesh_->attribute(att_id);
+  att->SetAttributeValue(AttributeValueIndex(start_index), value);
+  att->SetAttributeValue(AttributeValueIndex(start_index + 1), value);
+  att->SetAttributeValue(AttributeValueIndex(start_index + 2), value);
+  mesh_->SetFace(face_id,
+                 {{PointIndex(start_index), PointIndex(start_index + 1),
+                   PointIndex(start_index + 2)}});
+  int8_t &element_type = attribute_element_types_[att_id];
+  if (element_type < 0) {
+    element_type = MESH_FACE_ATTRIBUTE;
+  }
+}
+
+std::unique_ptr<Mesh> TriangleSoupMeshBuilder::Finalize() {
+#ifdef DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED
+  // First deduplicate attribute values.
+  if (!mesh_->DeduplicateAttributeValues()) {
+    return nullptr;
+  }
+#endif
+#ifdef DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+  // Also deduplicate vertex indices.
+  mesh_->DeduplicatePointIds();
+#endif
+  for (size_t i = 0; i < attribute_element_types_.size(); ++i) {
+    if (attribute_element_types_[i] >= 0) {
+      mesh_->SetAttributeElementType(
+          static_cast<int>(i),
+          static_cast<MeshAttributeElementType>(attribute_element_types_[i]));
+    }
+  }
+  return std::move(mesh_);
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/mesh/triangle_soup_mesh_builder.h b/Engine/lib/assimp/contrib/draco/src/draco/mesh/triangle_soup_mesh_builder.h
new file mode 100644
index 000000000..89466e1d8
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/mesh/triangle_soup_mesh_builder.h
@@ -0,0 +1,63 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MESH_TRIANGLE_SOUP_MESH_BUILDER_H_
+#define DRACO_MESH_TRIANGLE_SOUP_MESH_BUILDER_H_
+
+#include "draco/draco_features.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Class for building meshes directly from attribute values that can be
+// specified for each face corner. All attributes are automatically
+// deduplicated.
+class TriangleSoupMeshBuilder {
+ public:
+  // Starts mesh building for a given number of faces.
+  // TODO(ostava): Currently it's necessary to select the correct number of
+  // faces upfront. This should be generalized, but it will require us to
+  // rewrite our attribute resizing functions.
+  void Start(int num_faces);
+
+  // Adds an empty attribute to the mesh. Returns the new attribute's id.
+  int AddAttribute(GeometryAttribute::Type attribute_type,
+                   int8_t num_components, DataType data_type);
+
+  // Sets values for a given attribute on all corners of a given face.
+  void SetAttributeValuesForFace(int att_id, FaceIndex face_id,
+                                 const void *corner_value_0,
+                                 const void *corner_value_1,
+                                 const void *corner_value_2);
+
+  // Sets value for a per-face attribute. If all faces of a given attribute are
+  // set with this method, the attribute will be marked as per-face, otherwise
+  // it will be marked as per-corner attribute.
+  void SetPerFaceAttributeValueForFace(int att_id, FaceIndex face_id,
+                                       const void *value);
+
+  // Finalizes the mesh or returns nullptr on error.
+  // Once this function is called, the builder becomes invalid and cannot be
+  // used until the method Start() is called again.
+  std::unique_ptr<Mesh> Finalize();
+
+ private:
+  std::vector<int8_t> attribute_element_types_;
+
+  std::unique_ptr<Mesh> mesh_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_TRIANGLE_SOUP_MESH_BUILDER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/mesh/triangle_soup_mesh_builder_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/mesh/triangle_soup_mesh_builder_test.cc
new file mode 100644
index 000000000..171f8fe24
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/mesh/triangle_soup_mesh_builder_test.cc
@@ -0,0 +1,197 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/mesh/triangle_soup_mesh_builder.h"
+
+#include "draco/core/draco_test_base.h"
+#include "draco/core/vector_d.h"
+
+namespace draco {
+
+class TriangleSoupMeshBuilderTest : public ::testing::Test {};
+
+TEST_F(TriangleSoupMeshBuilderTest, CubeTest) {
+  // This tests, verifies that the mesh builder constructs a valid cube out
+  // of the provided triangle soup data.
+  TriangleSoupMeshBuilder mb;
+  mb.Start(12);
+  const int pos_att_id =
+      mb.AddAttribute(GeometryAttribute::POSITION, 3, DT_FLOAT32);
+  // clang-format off
+  // Front face.
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(0),
+                               Vector3f(0.f, 0.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(0.f, 1.f, 0.f).data());
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(1),
+                               Vector3f(0.f, 1.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(1.f, 1.f, 0.f).data());
+
+  // Back face.
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(2),
+                               Vector3f(0.f, 1.f, 1.f).data(),
+                               Vector3f(1.f, 0.f, 1.f).data(),
+                               Vector3f(0.f, 0.f, 1.f).data());
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(3),
+                               Vector3f(1.f, 1.f, 1.f).data(),
+                               Vector3f(1.f, 0.f, 1.f).data(),
+                               Vector3f(0.f, 1.f, 1.f).data());
+
+  // Top face.
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(4),
+                               Vector3f(0.f, 1.f, 0.f).data(),
+                               Vector3f(1.f, 1.f, 0.f).data(),
+                               Vector3f(0.f, 1.f, 1.f).data());
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(5),
+                               Vector3f(0.f, 1.f, 1.f).data(),
+                               Vector3f(1.f, 1.f, 0.f).data(),
+                               Vector3f(1.f, 1.f, 1.f).data());
+
+  // Bottom face.
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(6),
+                               Vector3f(0.f, 0.f, 1.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(0.f, 0.f, 0.f).data());
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(7),
+                               Vector3f(1.f, 0.f, 1.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(0.f, 0.f, 1.f).data());
+
+  // Right face.
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(8),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 1.f).data(),
+                               Vector3f(1.f, 1.f, 0.f).data());
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(9),
+                               Vector3f(1.f, 1.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 1.f).data(),
+                               Vector3f(1.f, 1.f, 1.f).data());
+
+  // Left face.
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(10),
+                               Vector3f(0.f, 1.f, 0.f).data(),
+                               Vector3f(0.f, 0.f, 1.f).data(),
+                               Vector3f(0.f, 0.f, 0.f).data());
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(11),
+                               Vector3f(0.f, 1.f, 1.f).data(),
+                               Vector3f(0.f, 0.f, 1.f).data(),
+                               Vector3f(0.f, 1.f, 0.f).data());
+  // clang-format on
+
+  std::unique_ptr<Mesh> mesh = mb.Finalize();
+  ASSERT_NE(mesh, nullptr) << "Failed to build the cube mesh.";
+  EXPECT_EQ(mesh->num_points(), 8) << "Unexpected number of vertices.";
+  EXPECT_EQ(mesh->num_faces(), 12) << "Unexpected number of faces.";
+}
+
+TEST_F(TriangleSoupMeshBuilderTest, TestPerFaceAttribs) {
+  // This tests, verifies that the mesh builder constructs a valid cube with
+  // per face Boolean attributes.
+  TriangleSoupMeshBuilder mb;
+  mb.Start(12);
+  const int pos_att_id =
+      mb.AddAttribute(GeometryAttribute::POSITION, 3, DT_FLOAT32);
+  const int gen_att_id =
+      mb.AddAttribute(GeometryAttribute::GENERIC, 1, DT_BOOL);
+  uint8_t bool_true = 1;
+  uint8_t bool_false = 0;
+  // clang-format off
+  // Front face.
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(0),
+                               Vector3f(0.f, 0.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(0.f, 1.f, 0.f).data());
+  mb.SetPerFaceAttributeValueForFace(gen_att_id, FaceIndex(0), &bool_false);
+
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(1),
+                               Vector3f(0.f, 1.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(1.f, 1.f, 0.f).data());
+  mb.SetPerFaceAttributeValueForFace(gen_att_id, FaceIndex(1), &bool_true);
+
+  // Back face.
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(2),
+                               Vector3f(0.f, 1.f, 1.f).data(),
+                               Vector3f(1.f, 0.f, 1.f).data(),
+                               Vector3f(0.f, 0.f, 1.f).data());
+  mb.SetPerFaceAttributeValueForFace(gen_att_id, FaceIndex(2), &bool_true);
+
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(3),
+                               Vector3f(1.f, 1.f, 1.f).data(),
+                               Vector3f(1.f, 0.f, 1.f).data(),
+                               Vector3f(0.f, 1.f, 1.f).data());
+  mb.SetPerFaceAttributeValueForFace(gen_att_id, FaceIndex(3), &bool_true);
+
+  // Top face.
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(4),
+                               Vector3f(0.f, 1.f, 0.f).data(),
+                               Vector3f(1.f, 1.f, 0.f).data(),
+                               Vector3f(0.f, 1.f, 1.f).data());
+  mb.SetPerFaceAttributeValueForFace(gen_att_id, FaceIndex(4), &bool_false);;
+
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(5),
+                               Vector3f(0.f, 1.f, 1.f).data(),
+                               Vector3f(1.f, 1.f, 0.f).data(),
+                               Vector3f(1.f, 1.f, 1.f).data());
+  mb.SetPerFaceAttributeValueForFace(gen_att_id, FaceIndex(5), &bool_false);
+
+  // Bottom face.
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(6),
+                               Vector3f(0.f, 0.f, 1.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(0.f, 0.f, 0.f).data());
+  mb.SetPerFaceAttributeValueForFace(gen_att_id, FaceIndex(6), &bool_true);
+
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(7),
+                               Vector3f(1.f, 0.f, 1.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(0.f, 0.f, 1.f).data());
+  mb.SetPerFaceAttributeValueForFace(gen_att_id, FaceIndex(7), &bool_true);
+
+  // Right face.
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(8),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 1.f).data(),
+                               Vector3f(1.f, 1.f, 0.f).data());
+  mb.SetPerFaceAttributeValueForFace(gen_att_id, FaceIndex(8), &bool_false);
+
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(9),
+                               Vector3f(1.f, 1.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 1.f).data(),
+                               Vector3f(1.f, 1.f, 1.f).data());
+  mb.SetPerFaceAttributeValueForFace(gen_att_id, FaceIndex(9), &bool_true);
+
+  // Left face.
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(10),
+                               Vector3f(0.f, 1.f, 0.f).data(),
+                               Vector3f(0.f, 0.f, 1.f).data(),
+                               Vector3f(0.f, 0.f, 0.f).data());
+  mb.SetPerFaceAttributeValueForFace(gen_att_id, FaceIndex(10), &bool_true);
+
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(11),
+                               Vector3f(0.f, 1.f, 1.f).data(),
+                               Vector3f(0.f, 0.f, 1.f).data(),
+                               Vector3f(0.f, 1.f, 0.f).data());
+  mb.SetPerFaceAttributeValueForFace(gen_att_id, FaceIndex(11), &bool_false);
+  // clang-format on
+
+  std::unique_ptr<Mesh> mesh = mb.Finalize();
+  ASSERT_NE(mesh, nullptr) << "Failed to build the cube mesh.";
+  EXPECT_EQ(mesh->num_faces(), 12) << "Unexpected number of faces.";
+  EXPECT_EQ(mesh->GetAttributeElementType(gen_att_id), MESH_FACE_ATTRIBUTE)
+      << "Unexpected attribute element type.";
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/mesh/valence_cache.h b/Engine/lib/assimp/contrib/draco/src/draco/mesh/valence_cache.h
new file mode 100644
index 000000000..3540377db
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/mesh/valence_cache.h
@@ -0,0 +1,142 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MESH_VALENCE_CACHE_H_
+#define DRACO_MESH_VALENCE_CACHE_H_
+
+#include "draco/attributes/geometry_indices.h"
+#include "draco/core/draco_index_type_vector.h"
+#include "draco/core/macros.h"
+
+namespace draco {
+
+// ValenceCache provides support for the caching of valences off of some kind of
+// CornerTable 'type' of class.
+// No valences should be queried before Caching is
+// performed and values should be removed/recached when changes to the
+// underlying mesh are taking place.
+
+template <class CornerTableT>
+class ValenceCache {
+  const CornerTableT &table_;
+
+ public:
+  explicit ValenceCache(const CornerTableT &table) : table_(table) {}
+
+  // Do not call before CacheValences() / CacheValencesInaccurate().
+  inline int8_t ValenceFromCacheInaccurate(CornerIndex c) const {
+    if (c == kInvalidCornerIndex) {
+      return -1;
+    }
+    return ValenceFromCacheInaccurate(table_.Vertex(c));
+  }
+  inline int32_t ValenceFromCache(CornerIndex c) const {
+    if (c == kInvalidCornerIndex) {
+      return -1;
+    }
+    return ValenceFromCache(table_.Vertex(c));
+  }
+
+  inline int32_t ConfidentValenceFromCache(VertexIndex v) const {
+    DRACO_DCHECK_LT(v.value(), table_.num_vertices());
+    DRACO_DCHECK_EQ(vertex_valence_cache_32_bit_.size(), table_.num_vertices());
+    return vertex_valence_cache_32_bit_[v];
+  }
+
+  // Collect the valence for all vertices so they can be reused later.  The
+  // 'inaccurate' versions of this family of functions clips the true valence
+  // of the vertices to 8 signed bits as a space optimization.  This clipping
+  // will lead to occasionally wrong results.  If accurate results are required
+  // under all circumstances, do not use the 'inaccurate' version or else
+  // use it and fetch the correct result in the event the value appears clipped.
+  // The topology of the mesh should be a constant when Valence Cache functions
+  // are being used.  Modification of the mesh while cache(s) are filled will
+  // not guarantee proper results on subsequent calls unless they are rebuilt.
+  void CacheValencesInaccurate() const {
+    if (vertex_valence_cache_8_bit_.size() == 0) {
+      const VertexIndex vertex_count = VertexIndex(table_.num_vertices());
+      vertex_valence_cache_8_bit_.resize(vertex_count.value());
+      for (VertexIndex v = VertexIndex(0); v < vertex_count; v += 1) {
+        vertex_valence_cache_8_bit_[v] = static_cast<int8_t>(
+            (std::min)(static_cast<int32_t>(std::numeric_limits<int8_t>::max()),
+                       table_.Valence(v)));
+      }
+    }
+  }
+  void CacheValences() const {
+    if (vertex_valence_cache_32_bit_.size() == 0) {
+      const VertexIndex vertex_count = VertexIndex(table_.num_vertices());
+      vertex_valence_cache_32_bit_.resize(vertex_count.value());
+      for (VertexIndex v = VertexIndex(0); v < vertex_count; v += 1) {
+        vertex_valence_cache_32_bit_[v] = table_.Valence(v);
+      }
+    }
+  }
+
+  inline int8_t ConfidentValenceFromCacheInaccurate(CornerIndex c) const {
+    DRACO_DCHECK_GE(c.value(), 0);
+    return ConfidentValenceFromCacheInaccurate(table_.ConfidentVertex(c));
+  }
+  inline int32_t ConfidentValenceFromCache(CornerIndex c) const {
+    DRACO_DCHECK_GE(c.value(), 0);
+    return ConfidentValenceFromCache(table_.ConfidentVertex(c));
+  }
+  inline int8_t ValenceFromCacheInaccurate(VertexIndex v) const {
+    DRACO_DCHECK_EQ(vertex_valence_cache_8_bit_.size(), table_.num_vertices());
+    if (v == kInvalidVertexIndex || v.value() >= table_.num_vertices()) {
+      return -1;
+    }
+    return ConfidentValenceFromCacheInaccurate(v);
+  }
+  inline int8_t ConfidentValenceFromCacheInaccurate(VertexIndex v) const {
+    DRACO_DCHECK_LT(v.value(), table_.num_vertices());
+    DRACO_DCHECK_EQ(vertex_valence_cache_8_bit_.size(), table_.num_vertices());
+    return vertex_valence_cache_8_bit_[v];
+  }
+
+  // TODO(draco-eng) Add unit tests for ValenceCache functions.
+  inline int32_t ValenceFromCache(VertexIndex v) const {
+    DRACO_DCHECK_EQ(vertex_valence_cache_32_bit_.size(), table_.num_vertices());
+    if (v == kInvalidVertexIndex || v.value() >= table_.num_vertices()) {
+      return -1;
+    }
+    return ConfidentValenceFromCache(v);
+  }
+
+  // Clear the cache of valences and deallocate the memory.
+  void ClearValenceCacheInaccurate() const {
+    vertex_valence_cache_8_bit_.clear();
+    // Force erasure.
+    IndexTypeVector<VertexIndex, int8_t>().swap(vertex_valence_cache_8_bit_);
+  }
+  void ClearValenceCache() const {
+    vertex_valence_cache_32_bit_.clear();
+    // Force erasure.
+    IndexTypeVector<VertexIndex, int32_t>().swap(vertex_valence_cache_32_bit_);
+  }
+
+  bool IsCacheEmpty() const {
+    return vertex_valence_cache_8_bit_.size() == 0 &&
+           vertex_valence_cache_32_bit_.size() == 0;
+  }
+
+ private:
+  // Retain valences and clip them to char size.
+  mutable IndexTypeVector<VertexIndex, int8_t> vertex_valence_cache_8_bit_;
+  mutable IndexTypeVector<VertexIndex, int32_t> vertex_valence_cache_32_bit_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_VALENCE_CACHE_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/metadata/geometry_metadata.cc b/Engine/lib/assimp/contrib/draco/src/draco/metadata/geometry_metadata.cc
new file mode 100644
index 000000000..b83898140
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/metadata/geometry_metadata.cc
@@ -0,0 +1,44 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/metadata/geometry_metadata.h"
+
+#include <utility>
+
+namespace draco {
+
+const AttributeMetadata *GeometryMetadata::GetAttributeMetadataByStringEntry(
+    const std::string &entry_name, const std::string &entry_value) const {
+  for (auto &&att_metadata : att_metadatas_) {
+    std::string value;
+    if (!att_metadata->GetEntryString(entry_name, &value)) {
+      continue;
+    }
+    if (value == entry_value) {
+      return att_metadata.get();
+    }
+  }
+  // No attribute has the requested entry.
+  return nullptr;
+}
+
+bool GeometryMetadata::AddAttributeMetadata(
+    std::unique_ptr<AttributeMetadata> att_metadata) {
+  if (!att_metadata.get()) {
+    return false;
+  }
+  att_metadatas_.push_back(std::move(att_metadata));
+  return true;
+}
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/metadata/geometry_metadata.h b/Engine/lib/assimp/contrib/draco/src/draco/metadata/geometry_metadata.h
new file mode 100644
index 000000000..ec7ecb9ee
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/metadata/geometry_metadata.h
@@ -0,0 +1,140 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_METADATA_GEOMETRY_METADATA_H_
+#define DRACO_METADATA_GEOMETRY_METADATA_H_
+
+#include "draco/metadata/metadata.h"
+
+namespace draco {
+
+// Class for representing specifically metadata of attributes. It must have an
+// attribute id which should be identical to it's counterpart attribute in
+// the point cloud it belongs to.
+class AttributeMetadata : public Metadata {
+ public:
+  AttributeMetadata() : att_unique_id_(0) {}
+  explicit AttributeMetadata(const Metadata &metadata)
+      : Metadata(metadata), att_unique_id_(0) {}
+
+  void set_att_unique_id(uint32_t att_unique_id) {
+    att_unique_id_ = att_unique_id;
+  }
+  // The unique id of the attribute that this metadata belongs to.
+  uint32_t att_unique_id() const { return att_unique_id_; }
+
+ private:
+  uint32_t att_unique_id_;
+
+  friend struct AttributeMetadataHasher;
+  friend class PointCloud;
+};
+
+// Functor for computing a hash from data stored in a AttributeMetadata class.
+struct AttributeMetadataHasher {
+  size_t operator()(const AttributeMetadata &metadata) const {
+    size_t hash = metadata.att_unique_id_;
+    MetadataHasher metadata_hasher;
+    hash = HashCombine(metadata_hasher(static_cast<const Metadata &>(metadata)),
+                       hash);
+    return hash;
+  }
+};
+
+// Class for representing the metadata for a point cloud. It could have a list
+// of attribute metadata.
+class GeometryMetadata : public Metadata {
+ public:
+  GeometryMetadata() {}
+  explicit GeometryMetadata(const Metadata &metadata) : Metadata(metadata) {}
+
+  const AttributeMetadata *GetAttributeMetadataByStringEntry(
+      const std::string &entry_name, const std::string &entry_value) const;
+  bool AddAttributeMetadata(std::unique_ptr<AttributeMetadata> att_metadata);
+
+  void DeleteAttributeMetadataByUniqueId(int32_t att_unique_id) {
+    if (att_unique_id < 0) {
+      return;
+    }
+    for (auto itr = att_metadatas_.begin(); itr != att_metadatas_.end();
+         ++itr) {
+      if (itr->get()->att_unique_id() == static_cast<uint32_t>(att_unique_id)) {
+        att_metadatas_.erase(itr);
+        return;
+      }
+    }
+  }
+
+  const AttributeMetadata *GetAttributeMetadataByUniqueId(
+      int32_t att_unique_id) const {
+    if (att_unique_id < 0) {
+      return nullptr;
+    }
+
+    // TODO(draco-eng): Consider using unordered_map instead of vector to store
+    // attribute metadata.
+    for (auto &&att_metadata : att_metadatas_) {
+      if (att_metadata->att_unique_id() ==
+          static_cast<uint32_t>(att_unique_id)) {
+        return att_metadata.get();
+      }
+    }
+    return nullptr;
+  }
+
+  AttributeMetadata *attribute_metadata(int32_t att_unique_id) {
+    if (att_unique_id < 0) {
+      return nullptr;
+    }
+
+    // TODO(draco-eng): Consider use unordered_map instead of vector to store
+    // attribute metadata.
+    for (auto &&att_metadata : att_metadatas_) {
+      if (att_metadata->att_unique_id() ==
+          static_cast<uint32_t>(att_unique_id)) {
+        return att_metadata.get();
+      }
+    }
+    return nullptr;
+  }
+
+  const std::vector<std::unique_ptr<AttributeMetadata>> &attribute_metadatas()
+      const {
+    return att_metadatas_;
+  }
+
+ private:
+  std::vector<std::unique_ptr<AttributeMetadata>> att_metadatas_;
+
+  friend struct GeometryMetadataHasher;
+};
+
+// Functor for computing a hash from data stored in a GeometryMetadata class.
+struct GeometryMetadataHasher {
+  size_t operator()(const GeometryMetadata &metadata) const {
+    size_t hash = metadata.att_metadatas_.size();
+    AttributeMetadataHasher att_metadata_hasher;
+    for (auto &&att_metadata : metadata.att_metadatas_) {
+      hash = HashCombine(att_metadata_hasher(*att_metadata), hash);
+    }
+    MetadataHasher metadata_hasher;
+    hash = HashCombine(metadata_hasher(static_cast<const Metadata &>(metadata)),
+                       hash);
+    return hash;
+  }
+};
+
+}  // namespace draco
+
+#endif  // THIRD_PARTY_DRACO_METADATA_GEOMETRY_METADATA_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata.cc b/Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata.cc
new file mode 100644
index 000000000..9141907ed
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata.cc
@@ -0,0 +1,132 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/metadata/metadata.h"
+
+#include <utility>
+
+namespace draco {
+
+EntryValue::EntryValue(const EntryValue &value) {
+  data_.resize(value.data_.size());
+  memcpy(&data_[0], &value.data_[0], value.data_.size());
+}
+
+EntryValue::EntryValue(const std::string &value) {
+  data_.resize(value.size());
+  memcpy(&data_[0], &value[0], value.size());
+}
+
+template <>
+bool EntryValue::GetValue(std::string *value) const {
+  if (data_.empty()) {
+    return false;
+  }
+  value->resize(data_.size());
+  memcpy(&value->at(0), &data_[0], data_.size());
+  return true;
+}
+
+Metadata::Metadata(const Metadata &metadata) {
+  entries_.insert(metadata.entries_.begin(), metadata.entries_.end());
+  for (const auto &sub_metadata_entry : metadata.sub_metadatas_) {
+    std::unique_ptr<Metadata> sub_metadata =
+        std::unique_ptr<Metadata>(new Metadata(*sub_metadata_entry.second));
+    sub_metadatas_[sub_metadata_entry.first] = std::move(sub_metadata);
+  }
+}
+
+void Metadata::AddEntryInt(const std::string &name, int32_t value) {
+  AddEntry(name, value);
+}
+
+bool Metadata::GetEntryInt(const std::string &name, int32_t *value) const {
+  return GetEntry(name, value);
+}
+
+void Metadata::AddEntryIntArray(const std::string &name,
+                                const std::vector<int32_t> &value) {
+  AddEntry(name, value);
+}
+
+bool Metadata::GetEntryIntArray(const std::string &name,
+                                std::vector<int32_t> *value) const {
+  return GetEntry(name, value);
+}
+
+void Metadata::AddEntryDouble(const std::string &name, double value) {
+  AddEntry(name, value);
+}
+
+bool Metadata::GetEntryDouble(const std::string &name, double *value) const {
+  return GetEntry(name, value);
+}
+
+void Metadata::AddEntryDoubleArray(const std::string &name,
+                                   const std::vector<double> &value) {
+  AddEntry(name, value);
+}
+
+bool Metadata::GetEntryDoubleArray(const std::string &name,
+                                   std::vector<double> *value) const {
+  return GetEntry(name, value);
+}
+
+void Metadata::AddEntryString(const std::string &name,
+                              const std::string &value) {
+  AddEntry(name, value);
+}
+
+bool Metadata::GetEntryString(const std::string &name,
+                              std::string *value) const {
+  return GetEntry(name, value);
+}
+
+void Metadata::AddEntryBinary(const std::string &name,
+                              const std::vector<uint8_t> &value) {
+  AddEntry(name, value);
+}
+
+bool Metadata::GetEntryBinary(const std::string &name,
+                              std::vector<uint8_t> *value) const {
+  return GetEntry(name, value);
+}
+
+bool Metadata::AddSubMetadata(const std::string &name,
+                              std::unique_ptr<Metadata> sub_metadata) {
+  auto sub_ptr = sub_metadatas_.find(name);
+  // Avoid accidentally writing over a sub-metadata with the same name.
+  if (sub_ptr != sub_metadatas_.end()) {
+    return false;
+  }
+  sub_metadatas_[name] = std::move(sub_metadata);
+  return true;
+}
+
+const Metadata *Metadata::GetSubMetadata(const std::string &name) const {
+  auto sub_ptr = sub_metadatas_.find(name);
+  if (sub_ptr == sub_metadatas_.end()) {
+    return nullptr;
+  }
+  return sub_ptr->second.get();
+}
+
+void Metadata::RemoveEntry(const std::string &name) {
+  // Actually just remove "name", no need to check if it exists.
+  auto entry_ptr = entries_.find(name);
+  if (entry_ptr != entries_.end()) {
+    entries_.erase(entry_ptr);
+  }
+}
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata.h b/Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata.h
new file mode 100644
index 000000000..56d05e46a
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata.h
@@ -0,0 +1,208 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_METADATA_METADATA_H_
+#define DRACO_METADATA_METADATA_H_
+
+#include <cstring>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "draco/core/hash_utils.h"
+
+namespace draco {
+
+// Class for storing a value of an entry in Metadata. Internally it is
+// represented by a buffer of data. It can be accessed by various data types,
+// e.g. int, float, binary data or string.
+class EntryValue {
+ public:
+  template <typename DataTypeT>
+  explicit EntryValue(const DataTypeT &data) {
+    const size_t data_type_size = sizeof(DataTypeT);
+    data_.resize(data_type_size);
+    memcpy(&data_[0], &data, data_type_size);
+  }
+
+  template <typename DataTypeT>
+  explicit EntryValue(const std::vector<DataTypeT> &data) {
+    const size_t total_size = sizeof(DataTypeT) * data.size();
+    data_.resize(total_size);
+    memcpy(&data_[0], &data[0], total_size);
+  }
+
+  EntryValue(const EntryValue &value);
+  explicit EntryValue(const std::string &value);
+
+  template <typename DataTypeT>
+  bool GetValue(DataTypeT *value) const {
+    const size_t data_type_size = sizeof(DataTypeT);
+    if (data_type_size != data_.size()) {
+      return false;
+    }
+    memcpy(value, &data_[0], data_type_size);
+    return true;
+  }
+
+  template <typename DataTypeT>
+  bool GetValue(std::vector<DataTypeT> *value) const {
+    if (data_.empty()) {
+      return false;
+    }
+    const size_t data_type_size = sizeof(DataTypeT);
+    if (data_.size() % data_type_size != 0) {
+      return false;
+    }
+    value->resize(data_.size() / data_type_size);
+    memcpy(&value->at(0), &data_[0], data_.size());
+    return true;
+  }
+
+  const std::vector<uint8_t> &data() const { return data_; }
+
+ private:
+  std::vector<uint8_t> data_;
+
+  friend struct EntryValueHasher;
+};
+
+// Functor for computing a hash from data stored within an EntryValue.
+struct EntryValueHasher {
+  size_t operator()(const EntryValue &ev) const {
+    size_t hash = ev.data_.size();
+    for (size_t i = 0; i < ev.data_.size(); ++i) {
+      hash = HashCombine(ev.data_[i], hash);
+    }
+    return hash;
+  }
+};
+
+// Class for holding generic metadata. It has a list of entries which consist of
+// an entry name and an entry value. Each Metadata could also have nested
+// metadata.
+class Metadata {
+ public:
+  Metadata() {}
+  Metadata(const Metadata &metadata);
+  // In theory, we support all types of data as long as it could be serialized
+  // to binary data. We provide the following functions for inserting and
+  // accessing entries of common data types. For now, developers need to know
+  // the type of entries they are requesting.
+  void AddEntryInt(const std::string &name, int32_t value);
+
+  // Returns false if Metadata does not contain an entry with a key of |name|.
+  // This function does not guarantee that entry's type is int32_t.
+  bool GetEntryInt(const std::string &name, int32_t *value) const;
+
+  void AddEntryIntArray(const std::string &name,
+                        const std::vector<int32_t> &value);
+
+  // Returns false if Metadata does not contain an entry with a key of |name|.
+  // This function does not guarantee that entry's type is a vector of int32_t.
+  bool GetEntryIntArray(const std::string &name,
+                        std::vector<int32_t> *value) const;
+
+  void AddEntryDouble(const std::string &name, double value);
+
+  // Returns false if Metadata does not contain an entry with a key of |name|.
+  // This function does not guarantee that entry's type is double.
+  bool GetEntryDouble(const std::string &name, double *value) const;
+
+  void AddEntryDoubleArray(const std::string &name,
+                           const std::vector<double> &value);
+
+  // Returns false if Metadata does not contain an entry with a key of |name|.
+  // This function does not guarantee that entry's type is a vector of double.
+  bool GetEntryDoubleArray(const std::string &name,
+                           std::vector<double> *value) const;
+
+  void AddEntryString(const std::string &name, const std::string &value);
+
+  // Returns false if Metadata does not contain an entry with a key of |name|.
+  // This function does not guarantee that entry's type is std::string.
+  bool GetEntryString(const std::string &name, std::string *value) const;
+
+  // Add a blob of data as an entry.
+  void AddEntryBinary(const std::string &name,
+                      const std::vector<uint8_t> &value);
+
+  // Returns false if Metadata does not contain an entry with a key of |name|.
+  // This function does not guarantee that entry's type is a vector of uint8_t.
+  bool GetEntryBinary(const std::string &name,
+                      std::vector<uint8_t> *value) const;
+
+  bool AddSubMetadata(const std::string &name,
+                      std::unique_ptr<Metadata> sub_metadata);
+  const Metadata *GetSubMetadata(const std::string &name) const;
+
+  void RemoveEntry(const std::string &name);
+
+  int num_entries() const { return static_cast<int>(entries_.size()); }
+  const std::map<std::string, EntryValue> &entries() const { return entries_; }
+  const std::map<std::string, std::unique_ptr<Metadata>> &sub_metadatas()
+      const {
+    return sub_metadatas_;
+  }
+
+ private:
+  // Make this function private to avoid adding undefined data types.
+  template <typename DataTypeT>
+  void AddEntry(const std::string &entry_name, const DataTypeT &entry_value) {
+    const auto itr = entries_.find(entry_name);
+    if (itr != entries_.end()) {
+      entries_.erase(itr);
+    }
+    entries_.insert(std::make_pair(entry_name, EntryValue(entry_value)));
+  }
+
+  // Make this function private to avoid adding undefined data types.
+  template <typename DataTypeT>
+  bool GetEntry(const std::string &entry_name, DataTypeT *entry_value) const {
+    const auto itr = entries_.find(entry_name);
+    if (itr == entries_.end()) {
+      return false;
+    }
+    return itr->second.GetValue(entry_value);
+  }
+
+  std::map<std::string, EntryValue> entries_;
+  std::map<std::string, std::unique_ptr<Metadata>> sub_metadatas_;
+
+  friend struct MetadataHasher;
+};
+
+// Functor for computing a hash from data stored within a metadata class.
+struct MetadataHasher {
+  size_t operator()(const Metadata &metadata) const {
+    size_t hash =
+        HashCombine(metadata.entries_.size(), metadata.sub_metadatas_.size());
+    EntryValueHasher entry_value_hasher;
+    for (const auto &entry : metadata.entries_) {
+      hash = HashCombine(entry.first, hash);
+      hash = HashCombine(entry_value_hasher(entry.second), hash);
+    }
+    MetadataHasher metadata_hasher;
+    for (auto &&sub_metadata : metadata.sub_metadatas_) {
+      hash = HashCombine(sub_metadata.first, hash);
+      hash = HashCombine(metadata_hasher(*sub_metadata.second), hash);
+    }
+    return hash;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_METADATA_METADATA_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata_decoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata_decoder.cc
new file mode 100644
index 000000000..a8e66f854
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata_decoder.cc
@@ -0,0 +1,148 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/metadata/metadata_decoder.h"
+
+#include <string>
+
+#include "draco/core/varint_decoding.h"
+
+namespace draco {
+
+MetadataDecoder::MetadataDecoder() : buffer_(nullptr) {}
+
+bool MetadataDecoder::DecodeMetadata(DecoderBuffer *in_buffer,
+                                     Metadata *metadata) {
+  if (!metadata) {
+    return false;
+  }
+  buffer_ = in_buffer;
+  return DecodeMetadata(metadata);
+}
+
+bool MetadataDecoder::DecodeGeometryMetadata(DecoderBuffer *in_buffer,
+                                             GeometryMetadata *metadata) {
+  if (!metadata) {
+    return false;
+  }
+  buffer_ = in_buffer;
+  uint32_t num_att_metadata = 0;
+  if (!DecodeVarint(&num_att_metadata, buffer_)) {
+    return false;
+  }
+  // Decode attribute metadata.
+  for (uint32_t i = 0; i < num_att_metadata; ++i) {
+    uint32_t att_unique_id;
+    if (!DecodeVarint(&att_unique_id, buffer_)) {
+      return false;
+    }
+    std::unique_ptr<AttributeMetadata> att_metadata =
+        std::unique_ptr<AttributeMetadata>(new AttributeMetadata());
+    att_metadata->set_att_unique_id(att_unique_id);
+    if (!DecodeMetadata(static_cast<Metadata *>(att_metadata.get()))) {
+      return false;
+    }
+    metadata->AddAttributeMetadata(std::move(att_metadata));
+  }
+  return DecodeMetadata(static_cast<Metadata *>(metadata));
+}
+
+bool MetadataDecoder::DecodeMetadata(Metadata *metadata) {
+  struct MetadataPair {
+    Metadata *parent_metadata;
+    Metadata *decoded_metadata;
+  };
+  std::vector<MetadataPair> metadata_stack;
+  metadata_stack.push_back({nullptr, metadata});
+  while (!metadata_stack.empty()) {
+    const MetadataPair mp = metadata_stack.back();
+    metadata_stack.pop_back();
+    metadata = mp.decoded_metadata;
+
+    if (mp.parent_metadata != nullptr) {
+      std::string sub_metadata_name;
+      if (!DecodeName(&sub_metadata_name)) {
+        return false;
+      }
+      std::unique_ptr<Metadata> sub_metadata =
+          std::unique_ptr<Metadata>(new Metadata());
+      metadata = sub_metadata.get();
+      if (!mp.parent_metadata->AddSubMetadata(sub_metadata_name,
+                                              std::move(sub_metadata))) {
+        return false;
+      }
+    }
+    if (metadata == nullptr) {
+      return false;
+    }
+
+    uint32_t num_entries = 0;
+    if (!DecodeVarint(&num_entries, buffer_)) {
+      return false;
+    }
+    for (uint32_t i = 0; i < num_entries; ++i) {
+      if (!DecodeEntry(metadata)) {
+        return false;
+      }
+    }
+    uint32_t num_sub_metadata = 0;
+    if (!DecodeVarint(&num_sub_metadata, buffer_)) {
+      return false;
+    }
+    if (num_sub_metadata > buffer_->remaining_size()) {
+      // The decoded number of metadata items is unreasonably high.
+      return false;
+    }
+    for (uint32_t i = 0; i < num_sub_metadata; ++i) {
+      metadata_stack.push_back({metadata, nullptr});
+    }
+  }
+  return true;
+}
+
+bool MetadataDecoder::DecodeEntry(Metadata *metadata) {
+  std::string entry_name;
+  if (!DecodeName(&entry_name)) {
+    return false;
+  }
+  uint32_t data_size = 0;
+  if (!DecodeVarint(&data_size, buffer_)) {
+    return false;
+  }
+  if (data_size == 0) {
+    return false;
+  }
+  std::vector<uint8_t> entry_value(data_size);
+  if (!buffer_->Decode(&entry_value[0], data_size)) {
+    return false;
+  }
+  metadata->AddEntryBinary(entry_name, entry_value);
+  return true;
+}
+
+bool MetadataDecoder::DecodeName(std::string *name) {
+  uint8_t name_len = 0;
+  if (!buffer_->Decode(&name_len)) {
+    return false;
+  }
+  name->resize(name_len);
+  if (name_len == 0) {
+    return true;
+  }
+  if (!buffer_->Decode(&name->at(0), name_len)) {
+    return false;
+  }
+  return true;
+}
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata_decoder.h b/Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata_decoder.h
new file mode 100644
index 000000000..b4c4943fb
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata_decoder.h
@@ -0,0 +1,42 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_METADATA_METADATA_DECODER_H_
+#define DRACO_METADATA_METADATA_DECODER_H_
+
+#include "draco/core/decoder_buffer.h"
+#include "draco/metadata/geometry_metadata.h"
+#include "draco/metadata/metadata.h"
+
+namespace draco {
+
+// Class for decoding the metadata.
+class MetadataDecoder {
+ public:
+  MetadataDecoder();
+  bool DecodeMetadata(DecoderBuffer *in_buffer, Metadata *metadata);
+  bool DecodeGeometryMetadata(DecoderBuffer *in_buffer,
+                              GeometryMetadata *metadata);
+
+ private:
+  bool DecodeMetadata(Metadata *metadata);
+  bool DecodeEntries(Metadata *metadata);
+  bool DecodeEntry(Metadata *metadata);
+  bool DecodeName(std::string *name);
+
+  DecoderBuffer *buffer_;
+};
+}  // namespace draco
+
+#endif  // DRACO_METADATA_METADATA_DECODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata_encoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata_encoder.cc
new file mode 100644
index 000000000..168be83c6
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata_encoder.cc
@@ -0,0 +1,97 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/metadata/metadata_encoder.h"
+
+#include "draco/core/varint_encoding.h"
+
+namespace draco {
+
+bool MetadataEncoder::EncodeMetadata(EncoderBuffer *out_buffer,
+                                     const Metadata *metadata) {
+  const std::map<std::string, EntryValue> &entries = metadata->entries();
+  // Encode number of entries.
+  EncodeVarint(static_cast<uint32_t>(metadata->num_entries()), out_buffer);
+  // Encode all entries.
+  for (const auto &entry : entries) {
+    if (!EncodeString(out_buffer, entry.first)) {
+      return false;
+    }
+    const std::vector<uint8_t> &entry_value = entry.second.data();
+    const uint32_t data_size = static_cast<uint32_t>(entry_value.size());
+    EncodeVarint(data_size, out_buffer);
+    out_buffer->Encode(entry_value.data(), data_size);
+  }
+  const std::map<std::string, std::unique_ptr<Metadata>> &sub_metadatas =
+      metadata->sub_metadatas();
+  // Encode number of sub-metadata
+  EncodeVarint(static_cast<uint32_t>(sub_metadatas.size()), out_buffer);
+  // Encode each sub-metadata
+  for (auto &&sub_metadata_entry : sub_metadatas) {
+    if (!EncodeString(out_buffer, sub_metadata_entry.first)) {
+      return false;
+    }
+    EncodeMetadata(out_buffer, sub_metadata_entry.second.get());
+  }
+
+  return true;
+}
+
+bool MetadataEncoder::EncodeAttributeMetadata(
+    EncoderBuffer *out_buffer, const AttributeMetadata *metadata) {
+  if (!metadata) {
+    return false;
+  }
+  // Encode attribute id.
+  EncodeVarint(metadata->att_unique_id(), out_buffer);
+  EncodeMetadata(out_buffer, static_cast<const Metadata *>(metadata));
+  return true;
+}
+
+bool MetadataEncoder::EncodeGeometryMetadata(EncoderBuffer *out_buffer,
+                                             const GeometryMetadata *metadata) {
+  if (!metadata) {
+    return false;
+  }
+  // Encode number of attribute metadata.
+  const std::vector<std::unique_ptr<AttributeMetadata>> &att_metadatas =
+      metadata->attribute_metadatas();
+  // TODO(draco-eng): Limit the number of attributes.
+  EncodeVarint(static_cast<uint32_t>(att_metadatas.size()), out_buffer);
+  // Encode each attribute metadata
+  for (auto &&att_metadata : att_metadatas) {
+    EncodeAttributeMetadata(out_buffer, att_metadata.get());
+  }
+  // Encode normal metadata part.
+  EncodeMetadata(out_buffer, static_cast<const Metadata *>(metadata));
+
+  return true;
+}
+
+bool MetadataEncoder::EncodeString(EncoderBuffer *out_buffer,
+                                   const std::string &str) {
+  // We only support string of maximum length 255 which is using one byte to
+  // encode the length.
+  if (str.size() > 255) {
+    return false;
+  }
+  if (str.empty()) {
+    out_buffer->Encode(static_cast<uint8_t>(0));
+  } else {
+    out_buffer->Encode(static_cast<uint8_t>(str.size()));
+    out_buffer->Encode(str.c_str(), str.size());
+  }
+  return true;
+}
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata_encoder.h b/Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata_encoder.h
new file mode 100644
index 000000000..5bce5d5b5
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata_encoder.h
@@ -0,0 +1,41 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_METADATA_METADATA_ENCODER_H_
+#define DRACO_METADATA_METADATA_ENCODER_H_
+
+#include "draco/core/encoder_buffer.h"
+#include "draco/metadata/geometry_metadata.h"
+#include "draco/metadata/metadata.h"
+
+namespace draco {
+
+// Class for encoding metadata. It could encode either base Metadata class or
+// a metadata of a geometry, e.g. a point cloud.
+class MetadataEncoder {
+ public:
+  MetadataEncoder() {}
+
+  bool EncodeGeometryMetadata(EncoderBuffer *out_buffer,
+                              const GeometryMetadata *metadata);
+  bool EncodeMetadata(EncoderBuffer *out_buffer, const Metadata *metadata);
+
+ private:
+  bool EncodeAttributeMetadata(EncoderBuffer *out_buffer,
+                               const AttributeMetadata *metadata);
+  bool EncodeString(EncoderBuffer *out_buffer, const std::string &str);
+};
+}  // namespace draco
+
+#endif  // DRACO_METADATA_METADATA_ENCODER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata_encoder_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata_encoder_test.cc
new file mode 100644
index 000000000..e5f14bf02
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata_encoder_test.cc
@@ -0,0 +1,167 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/metadata/metadata_encoder.h"
+
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/draco_test_base.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/metadata/metadata.h"
+#include "draco/metadata/metadata_decoder.h"
+
+namespace {
+
+class MetadataEncoderTest : public ::testing::Test {
+ protected:
+  MetadataEncoderTest() {}
+
+  void TestEncodingMetadata() {
+    ASSERT_TRUE(encoder.EncodeMetadata(&encoder_buffer, &metadata));
+
+    draco::Metadata decoded_metadata;
+    decoder_buffer.Init(encoder_buffer.data(), encoder_buffer.size());
+    ASSERT_TRUE(decoder.DecodeMetadata(&decoder_buffer, &decoded_metadata));
+    CheckMetadatasAreEqual(metadata, decoded_metadata);
+  }
+
+  void TestEncodingGeometryMetadata() {
+    ASSERT_TRUE(
+        encoder.EncodeGeometryMetadata(&encoder_buffer, &geometry_metadata));
+
+    draco::GeometryMetadata decoded_metadata;
+    decoder_buffer.Init(encoder_buffer.data(), encoder_buffer.size());
+    ASSERT_TRUE(
+        decoder.DecodeGeometryMetadata(&decoder_buffer, &decoded_metadata));
+    CheckGeometryMetadatasAreEqual(geometry_metadata, decoded_metadata);
+  }
+
+  void CheckBlobOfDataAreEqual(const std::vector<uint8_t> &data0,
+                               const std::vector<uint8_t> &data1) {
+    ASSERT_EQ(data0.size(), data1.size());
+    for (int i = 0; i < data0.size(); ++i) {
+      ASSERT_EQ(data0[i], data1[i]);
+    }
+  }
+
+  void CheckGeometryMetadatasAreEqual(
+      const draco::GeometryMetadata &metadata0,
+      const draco::GeometryMetadata &metadata1) {
+    ASSERT_EQ(metadata0.attribute_metadatas().size(),
+              metadata1.attribute_metadatas().size());
+    const std::vector<std::unique_ptr<draco::AttributeMetadata>>
+        &att_metadatas0 = metadata0.attribute_metadatas();
+    const std::vector<std::unique_ptr<draco::AttributeMetadata>>
+        &att_metadatas1 = metadata1.attribute_metadatas();
+    // Compare each attribute metadata.
+    for (int i = 0; i < metadata0.attribute_metadatas().size(); ++i) {
+      CheckMetadatasAreEqual(
+          static_cast<const draco::Metadata &>(*att_metadatas0[i]),
+          static_cast<const draco::Metadata &>(*att_metadatas1[i]));
+    }
+    // Compare entries and sub metadata.
+    CheckMetadatasAreEqual(static_cast<const draco::Metadata &>(metadata0),
+                           static_cast<const draco::Metadata &>(metadata1));
+  }
+
+  void CheckMetadatasAreEqual(const draco::Metadata &metadata0,
+                              const draco::Metadata &metadata1) {
+    ASSERT_EQ(metadata0.num_entries(), metadata1.num_entries());
+    const std::map<std::string, draco::EntryValue> &entries0 =
+        metadata0.entries();
+    const std::map<std::string, draco::EntryValue> &entries1 =
+        metadata1.entries();
+    for (const auto &entry : entries0) {
+      const std::string &entry_name = entry.first;
+      const std::vector<uint8_t> &data0 = entry.second.data();
+      const auto entry1_ptr = entries1.find(entry_name);
+      ASSERT_NE(entry1_ptr, entries1.end());
+      const std::vector<uint8_t> &data1 = entry1_ptr->second.data();
+      CheckBlobOfDataAreEqual(data0, data1);
+    }
+    // Check nested metadata.
+    ASSERT_EQ(metadata0.sub_metadatas().size(),
+              metadata1.sub_metadatas().size());
+    const std::map<std::string, std::unique_ptr<draco::Metadata>>
+        &sub_metadatas0 = metadata0.sub_metadatas();
+    // Encode each sub-metadata
+    for (auto &&sub_metadata_entry0 : sub_metadatas0) {
+      const auto sub_metadata_ptr1 =
+          metadata1.GetSubMetadata(sub_metadata_entry0.first);
+      ASSERT_NE(sub_metadata_ptr1, nullptr);
+      CheckMetadatasAreEqual(*sub_metadata_entry0.second, *sub_metadata_ptr1);
+    }
+  }
+
+  draco::MetadataEncoder encoder;
+  draco::MetadataDecoder decoder;
+  draco::EncoderBuffer encoder_buffer;
+  draco::DecoderBuffer decoder_buffer;
+  draco::Metadata metadata;
+  draco::GeometryMetadata geometry_metadata;
+};
+
+TEST_F(MetadataEncoderTest, TestSingleEntry) {
+  metadata.AddEntryInt("int", 100);
+  ASSERT_EQ(metadata.num_entries(), 1);
+
+  TestEncodingMetadata();
+}
+
+TEST_F(MetadataEncoderTest, TestMultipleEntries) {
+  metadata.AddEntryInt("int", 100);
+  metadata.AddEntryDouble("double", 1.234);
+  const std::string entry_value = "test string entry";
+  metadata.AddEntryString("string", entry_value);
+  ASSERT_EQ(metadata.num_entries(), 3);
+
+  TestEncodingMetadata();
+}
+
+TEST_F(MetadataEncoderTest, TestEncodingArrayEntries) {
+  std::vector<int32_t> int_array({1, 2, 3});
+  metadata.AddEntryIntArray("int_array", int_array);
+  std::vector<double> double_array({0.1, 0.2, 0.3});
+  metadata.AddEntryDoubleArray("double_array", double_array);
+  ASSERT_EQ(metadata.num_entries(), 2);
+
+  TestEncodingMetadata();
+}
+
+TEST_F(MetadataEncoderTest, TestEncodingBinaryEntry) {
+  const std::vector<uint8_t> binarydata({0x1, 0x2, 0x3, 0x4});
+  metadata.AddEntryBinary("binary_data", binarydata);
+
+  TestEncodingMetadata();
+}
+
+TEST_F(MetadataEncoderTest, TestEncodingNestedMetadata) {
+  metadata.AddEntryDouble("double", 1.234);
+  std::unique_ptr<draco::Metadata> sub_metadata =
+      std::unique_ptr<draco::Metadata>(new draco::Metadata());
+  sub_metadata->AddEntryInt("int", 100);
+  metadata.AddSubMetadata("sub0", std::move(sub_metadata));
+
+  TestEncodingMetadata();
+}
+
+TEST_F(MetadataEncoderTest, TestEncodingGeometryMetadata) {
+  std::unique_ptr<draco::AttributeMetadata> att_metadata =
+      std::unique_ptr<draco::AttributeMetadata>(new draco::AttributeMetadata);
+  att_metadata->AddEntryInt("int", 100);
+  att_metadata->AddEntryString("name", "pos");
+  ASSERT_TRUE(geometry_metadata.AddAttributeMetadata(std::move(att_metadata)));
+
+  TestEncodingGeometryMetadata();
+}
+}  // namespace
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata_test.cc
new file mode 100644
index 000000000..cf7ae6eee
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/metadata/metadata_test.cc
@@ -0,0 +1,157 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/metadata/metadata.h"
+
+#include <memory>
+#include <string>
+
+#include "draco/core/draco_test_base.h"
+#include "draco/metadata/geometry_metadata.h"
+
+namespace {
+
+class MetadataTest : public ::testing::Test {
+ protected:
+  MetadataTest() {}
+
+  draco::Metadata metadata;
+  draco::GeometryMetadata geometry_metadata;
+};
+
+TEST_F(MetadataTest, TestRemoveEntry) {
+  metadata.AddEntryInt("int", 100);
+  metadata.RemoveEntry("int");
+  int32_t int_value = 0;
+  ASSERT_FALSE(metadata.GetEntryInt("int", &int_value));
+}
+
+TEST_F(MetadataTest, TestSingleEntry) {
+  metadata.AddEntryInt("int", 100);
+  int32_t int_value = 0;
+  ASSERT_TRUE(metadata.GetEntryInt("int", &int_value));
+  ASSERT_EQ(int_value, 100);
+
+  metadata.AddEntryDouble("double", 1.234);
+  double double_value = 0.0;
+  ASSERT_TRUE(metadata.GetEntryDouble("double", &double_value));
+  ASSERT_EQ(double_value, 1.234);
+}
+
+TEST_F(MetadataTest, TestWriteOverEntry) {
+  metadata.AddEntryInt("int", 100);
+  metadata.AddEntryInt("int", 200);
+  int32_t int_value = 0;
+  ASSERT_TRUE(metadata.GetEntryInt("int", &int_value));
+  ASSERT_EQ(int_value, 200);
+}
+
+TEST_F(MetadataTest, TestArrayEntry) {
+  std::vector<int32_t> int_array({1, 2, 3});
+  metadata.AddEntryIntArray("int_array", int_array);
+  std::vector<int32_t> return_int_array;
+  ASSERT_TRUE(metadata.GetEntryIntArray("int_array", &return_int_array));
+  ASSERT_EQ(return_int_array.size(), 3);
+  ASSERT_EQ(return_int_array[0], 1);
+  ASSERT_EQ(return_int_array[1], 2);
+  ASSERT_EQ(return_int_array[2], 3);
+
+  std::vector<double> double_array({0.1, 0.2, 0.3});
+  metadata.AddEntryDoubleArray("double_array", double_array);
+  std::vector<double> return_double_array;
+  ASSERT_TRUE(
+      metadata.GetEntryDoubleArray("double_array", &return_double_array));
+  ASSERT_EQ(return_double_array.size(), 3);
+  ASSERT_EQ(return_double_array[0], 0.1);
+  ASSERT_EQ(return_double_array[1], 0.2);
+  ASSERT_EQ(return_double_array[2], 0.3);
+}
+
+TEST_F(MetadataTest, TestStringEntry) {
+  const std::string entry_value = "test string entry";
+  metadata.AddEntryString("string", entry_value);
+  std::string return_value;
+  ASSERT_TRUE(metadata.GetEntryString("string", &return_value));
+  ASSERT_EQ(entry_value.size(), return_value.size());
+  ASSERT_EQ(entry_value, return_value);
+}
+
+TEST_F(MetadataTest, TestBinaryEntry) {
+  const std::vector<uint8_t> binarydata({0x1, 0x2, 0x3, 0x4});
+  metadata.AddEntryBinary("binary_data", binarydata);
+  std::vector<uint8_t> return_binarydata;
+  ASSERT_TRUE(metadata.GetEntryBinary("binary_data", &return_binarydata));
+  ASSERT_EQ(binarydata.size(), return_binarydata.size());
+  for (int i = 0; i < binarydata.size(); ++i) {
+    ASSERT_EQ(binarydata[i], return_binarydata[i]);
+  }
+}
+
+TEST_F(MetadataTest, TestNestedMetadata) {
+  std::unique_ptr<draco::Metadata> sub_metadata =
+      std::unique_ptr<draco::Metadata>(new draco::Metadata());
+  sub_metadata->AddEntryInt("int", 100);
+
+  metadata.AddSubMetadata("sub0", std::move(sub_metadata));
+  const auto sub_metadata_ptr = metadata.GetSubMetadata("sub0");
+  ASSERT_NE(sub_metadata_ptr, nullptr);
+
+  int32_t int_value = 0;
+  ASSERT_TRUE(sub_metadata_ptr->GetEntryInt("int", &int_value));
+  ASSERT_EQ(int_value, 100);
+}
+
+TEST_F(MetadataTest, TestHardCopyMetadata) {
+  metadata.AddEntryInt("int", 100);
+  std::unique_ptr<draco::Metadata> sub_metadata =
+      std::unique_ptr<draco::Metadata>(new draco::Metadata());
+  sub_metadata->AddEntryInt("int", 200);
+  metadata.AddSubMetadata("sub0", std::move(sub_metadata));
+
+  draco::Metadata copied_metadata(metadata);
+
+  int32_t int_value = 0;
+  ASSERT_TRUE(copied_metadata.GetEntryInt("int", &int_value));
+  ASSERT_EQ(int_value, 100);
+
+  const auto sub_metadata_ptr = copied_metadata.GetSubMetadata("sub0");
+  ASSERT_NE(sub_metadata_ptr, nullptr);
+
+  int32_t sub_int_value = 0;
+  ASSERT_TRUE(sub_metadata_ptr->GetEntryInt("int", &sub_int_value));
+  ASSERT_EQ(sub_int_value, 200);
+}
+
+TEST_F(MetadataTest, TestGeometryMetadata) {
+  std::unique_ptr<draco::AttributeMetadata> att_metadata =
+      std::unique_ptr<draco::AttributeMetadata>(new draco::AttributeMetadata());
+  att_metadata->set_att_unique_id(10);
+  att_metadata->AddEntryInt("int", 100);
+  att_metadata->AddEntryString("name", "pos");
+
+  ASSERT_FALSE(geometry_metadata.AddAttributeMetadata(nullptr));
+  ASSERT_TRUE(geometry_metadata.AddAttributeMetadata(std::move(att_metadata)));
+
+  ASSERT_NE(geometry_metadata.GetAttributeMetadataByUniqueId(10), nullptr);
+  ASSERT_EQ(geometry_metadata.GetAttributeMetadataByUniqueId(1), nullptr);
+
+  const draco::AttributeMetadata *requested_att_metadata =
+      geometry_metadata.GetAttributeMetadataByStringEntry("name", "pos");
+  ASSERT_NE(requested_att_metadata, nullptr);
+  ASSERT_EQ(
+      geometry_metadata.GetAttributeMetadataByStringEntry("name", "not_exists"),
+      nullptr);
+}
+
+}  // namespace
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/point_cloud/point_cloud.cc b/Engine/lib/assimp/contrib/draco/src/draco/point_cloud/point_cloud.cc
new file mode 100644
index 000000000..a9f9ea2af
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/point_cloud/point_cloud.cc
@@ -0,0 +1,275 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/point_cloud/point_cloud.h"
+
+#include <algorithm>
+#include <unordered_map>
+
+namespace draco {
+
+PointCloud::PointCloud() : num_points_(0) {}
+
+int32_t PointCloud::NumNamedAttributes(GeometryAttribute::Type type) const {
+  if (type == GeometryAttribute::INVALID ||
+      type >= GeometryAttribute::NAMED_ATTRIBUTES_COUNT) {
+    return 0;
+  }
+  return static_cast<int32_t>(named_attribute_index_[type].size());
+}
+
+int32_t PointCloud::GetNamedAttributeId(GeometryAttribute::Type type) const {
+  return GetNamedAttributeId(type, 0);
+}
+
+int32_t PointCloud::GetNamedAttributeId(GeometryAttribute::Type type,
+                                        int i) const {
+  if (NumNamedAttributes(type) <= i) {
+    return -1;
+  }
+  return named_attribute_index_[type][i];
+}
+
+const PointAttribute *PointCloud::GetNamedAttribute(
+    GeometryAttribute::Type type) const {
+  return GetNamedAttribute(type, 0);
+}
+
+const PointAttribute *PointCloud::GetNamedAttribute(
+    GeometryAttribute::Type type, int i) const {
+  const int32_t att_id = GetNamedAttributeId(type, i);
+  if (att_id == -1) {
+    return nullptr;
+  }
+  return attributes_[att_id].get();
+}
+
+const PointAttribute *PointCloud::GetNamedAttributeByUniqueId(
+    GeometryAttribute::Type type, uint32_t unique_id) const {
+  for (size_t att_id = 0; att_id < named_attribute_index_[type].size();
+       ++att_id) {
+    if (attributes_[named_attribute_index_[type][att_id]]->unique_id() ==
+        unique_id) {
+      return attributes_[named_attribute_index_[type][att_id]].get();
+    }
+  }
+  return nullptr;
+}
+
+const PointAttribute *PointCloud::GetAttributeByUniqueId(
+    uint32_t unique_id) const {
+  const int32_t att_id = GetAttributeIdByUniqueId(unique_id);
+  if (att_id == -1) {
+    return nullptr;
+  }
+  return attributes_[att_id].get();
+}
+
+int32_t PointCloud::GetAttributeIdByUniqueId(uint32_t unique_id) const {
+  for (size_t att_id = 0; att_id < attributes_.size(); ++att_id) {
+    if (attributes_[att_id]->unique_id() == unique_id) {
+      return static_cast<int32_t>(att_id);
+    }
+  }
+  return -1;
+}
+
+int PointCloud::AddAttribute(std::unique_ptr<PointAttribute> pa) {
+  SetAttribute(static_cast<int>(attributes_.size()), std::move(pa));
+  return static_cast<int>(attributes_.size() - 1);
+}
+
+int PointCloud::AddAttribute(
+    const GeometryAttribute &att, bool identity_mapping,
+    AttributeValueIndex::ValueType num_attribute_values) {
+  auto pa = CreateAttribute(att, identity_mapping, num_attribute_values);
+  if (!pa) {
+    return -1;
+  }
+  const int32_t att_id = AddAttribute(std::move(pa));
+  return att_id;
+}
+
+std::unique_ptr<PointAttribute> PointCloud::CreateAttribute(
+    const GeometryAttribute &att, bool identity_mapping,
+    AttributeValueIndex::ValueType num_attribute_values) const {
+  if (att.attribute_type() == GeometryAttribute::INVALID) {
+    return nullptr;
+  }
+  std::unique_ptr<PointAttribute> pa =
+      std::unique_ptr<PointAttribute>(new PointAttribute(att));
+  // Initialize point cloud specific attribute data.
+  if (!identity_mapping) {
+    // First create mapping between indices.
+    pa->SetExplicitMapping(num_points_);
+  } else {
+    pa->SetIdentityMapping();
+    num_attribute_values = std::max(num_points_, num_attribute_values);
+  }
+  if (num_attribute_values > 0) {
+    pa->Reset(num_attribute_values);
+  }
+  return pa;
+}
+
+void PointCloud::SetAttribute(int att_id, std::unique_ptr<PointAttribute> pa) {
+  DRACO_DCHECK(att_id >= 0);
+  if (static_cast<int>(attributes_.size()) <= att_id) {
+    attributes_.resize(att_id + 1);
+  }
+  if (pa->attribute_type() < GeometryAttribute::NAMED_ATTRIBUTES_COUNT) {
+    named_attribute_index_[pa->attribute_type()].push_back(att_id);
+  }
+  pa->set_unique_id(att_id);
+  attributes_[att_id] = std::move(pa);
+}
+
+void PointCloud::DeleteAttribute(int att_id) {
+  if (att_id < 0 || att_id >= attributes_.size()) {
+    return;  // Attribute does not exist.
+  }
+  const GeometryAttribute::Type att_type =
+      attributes_[att_id]->attribute_type();
+  const uint32_t unique_id = attribute(att_id)->unique_id();
+  attributes_.erase(attributes_.begin() + att_id);
+  // Remove metadata if applicable.
+  if (metadata_) {
+    metadata_->DeleteAttributeMetadataByUniqueId(unique_id);
+  }
+
+  // Remove the attribute from the named attribute list if applicable.
+  if (att_type < GeometryAttribute::NAMED_ATTRIBUTES_COUNT) {
+    const auto it = std::find(named_attribute_index_[att_type].begin(),
+                              named_attribute_index_[att_type].end(), att_id);
+    if (it != named_attribute_index_[att_type].end()) {
+      named_attribute_index_[att_type].erase(it);
+    }
+  }
+
+  // Update ids of all subsequent named attributes (decrease them by one).
+  for (int i = 0; i < GeometryAttribute::NAMED_ATTRIBUTES_COUNT; ++i) {
+    for (int j = 0; j < named_attribute_index_[i].size(); ++j) {
+      if (named_attribute_index_[i][j] > att_id) {
+        named_attribute_index_[i][j]--;
+      }
+    }
+  }
+}
+
+#ifdef DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+void PointCloud::DeduplicatePointIds() {
+  // Hashing function for a single vertex.
+  auto point_hash = [this](PointIndex p) {
+    PointIndex::ValueType hash = 0;
+    for (int32_t i = 0; i < this->num_attributes(); ++i) {
+      const AttributeValueIndex att_id = attribute(i)->mapped_index(p);
+      hash = static_cast<uint32_t>(HashCombine(att_id.value(), hash));
+    }
+    return hash;
+  };
+  // Comparison function between two vertices.
+  auto point_compare = [this](PointIndex p0, PointIndex p1) {
+    for (int32_t i = 0; i < this->num_attributes(); ++i) {
+      const AttributeValueIndex att_id0 = attribute(i)->mapped_index(p0);
+      const AttributeValueIndex att_id1 = attribute(i)->mapped_index(p1);
+      if (att_id0 != att_id1) {
+        return false;
+      }
+    }
+    return true;
+  };
+
+  std::unordered_map<PointIndex, PointIndex, decltype(point_hash),
+                     decltype(point_compare)>
+      unique_point_map(num_points_, point_hash, point_compare);
+  int32_t num_unique_points = 0;
+  IndexTypeVector<PointIndex, PointIndex> index_map(num_points_);
+  std::vector<PointIndex> unique_points;
+  // Go through all vertices and find their duplicates.
+  for (PointIndex i(0); i < num_points_; ++i) {
+    const auto it = unique_point_map.find(i);
+    if (it != unique_point_map.end()) {
+      index_map[i] = it->second;
+    } else {
+      unique_point_map.insert(std::make_pair(i, PointIndex(num_unique_points)));
+      index_map[i] = num_unique_points++;
+      unique_points.push_back(i);
+    }
+  }
+  if (num_unique_points == num_points_) {
+    return;  // All vertices are already unique.
+  }
+
+  ApplyPointIdDeduplication(index_map, unique_points);
+  set_num_points(num_unique_points);
+}
+
+void PointCloud::ApplyPointIdDeduplication(
+    const IndexTypeVector<PointIndex, PointIndex> &id_map,
+    const std::vector<PointIndex> &unique_point_ids) {
+  int32_t num_unique_points = 0;
+  for (PointIndex i : unique_point_ids) {
+    const PointIndex new_point_id = id_map[i];
+    if (new_point_id >= num_unique_points) {
+      // New unique vertex reached. Copy attribute indices to the proper
+      // position.
+      for (int32_t a = 0; a < num_attributes(); ++a) {
+        attribute(a)->SetPointMapEntry(new_point_id,
+                                       attribute(a)->mapped_index(i));
+      }
+      num_unique_points = new_point_id.value() + 1;
+    }
+  }
+  for (int32_t a = 0; a < num_attributes(); ++a) {
+    attribute(a)->SetExplicitMapping(num_unique_points);
+  }
+}
+#endif
+
+#ifdef DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED
+bool PointCloud::DeduplicateAttributeValues() {
+  // Go over all attributes and create mapping between duplicate entries.
+  if (num_points() == 0) {
+    return true;  // Nothing to deduplicate.
+  }
+  // Deduplicate all attributes.
+  for (int32_t att_id = 0; att_id < num_attributes(); ++att_id) {
+    if (!attribute(att_id)->DeduplicateValues(*attribute(att_id))) {
+      return false;
+    }
+  }
+  return true;
+}
+#endif
+
+// TODO(xiaoxumeng): Consider to cash the BBox.
+BoundingBox PointCloud::ComputeBoundingBox() const {
+  BoundingBox bounding_box;
+  auto pc_att = GetNamedAttribute(GeometryAttribute::POSITION);
+  // TODO(xiaoxumeng): Make the BoundingBox a template type, it may not be easy
+  // because PointCloud is not a template.
+  // Or simply add some preconditioning here to make sure the position attribute
+  // is valid, because the current code works only if the position attribute is
+  // defined with 3 components of DT_FLOAT32.
+  // Consider using pc_att->ConvertValue<float, 3>(i, &p[0]) (Enforced
+  // transformation from Vector with any dimension to Vector3f)
+  Vector3f p;
+  for (AttributeValueIndex i(0); i < static_cast<uint32_t>(pc_att->size());
+       ++i) {
+    pc_att->GetValue(i, &p[0]);
+    bounding_box.Update(p);
+  }
+  return bounding_box;
+}
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/point_cloud/point_cloud.h b/Engine/lib/assimp/contrib/draco/src/draco/point_cloud/point_cloud.h
new file mode 100644
index 000000000..d11bd47a3
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/point_cloud/point_cloud.h
@@ -0,0 +1,244 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_POINT_CLOUD_POINT_CLOUD_H_
+#define DRACO_POINT_CLOUD_POINT_CLOUD_H_
+
+#include "draco/attributes/point_attribute.h"
+#include "draco/core/bounding_box.h"
+#include "draco/core/vector_d.h"
+#include "draco/draco_features.h"
+#include "draco/metadata/geometry_metadata.h"
+
+namespace draco {
+
+// PointCloud is a collection of n-dimensional points that are described by a
+// set of PointAttributes that can represent data such as positions or colors
+// of individual points (see point_attribute.h).
+class PointCloud {
+ public:
+  PointCloud();
+  virtual ~PointCloud() = default;
+
+  // Returns the number of named attributes of a given type.
+  int32_t NumNamedAttributes(GeometryAttribute::Type type) const;
+
+  // Returns attribute id of the first named attribute with a given type or -1
+  // when the attribute is not used by the point cloud.
+  int32_t GetNamedAttributeId(GeometryAttribute::Type type) const;
+
+  // Returns the id of the i-th named attribute of a given type.
+  int32_t GetNamedAttributeId(GeometryAttribute::Type type, int i) const;
+
+  // Returns the first named attribute of a given type or nullptr if the
+  // attribute is not used by the point cloud.
+  const PointAttribute *GetNamedAttribute(GeometryAttribute::Type type) const;
+
+  // Returns the i-th named attribute of a given type.
+  const PointAttribute *GetNamedAttribute(GeometryAttribute::Type type,
+                                          int i) const;
+
+  // Returns the named attribute of a given unique id.
+  const PointAttribute *GetNamedAttributeByUniqueId(
+      GeometryAttribute::Type type, uint32_t id) const;
+
+  // Returns the attribute of a given unique id.
+  const PointAttribute *GetAttributeByUniqueId(uint32_t id) const;
+  int32_t GetAttributeIdByUniqueId(uint32_t unique_id) const;
+
+  int32_t num_attributes() const {
+    return static_cast<int32_t>(attributes_.size());
+  }
+  const PointAttribute *attribute(int32_t att_id) const {
+    DRACO_DCHECK_LE(0, att_id);
+    DRACO_DCHECK_LT(att_id, static_cast<int32_t>(attributes_.size()));
+    return attributes_[att_id].get();
+  }
+
+  // Returned attribute can be modified, but it's caller's responsibility to
+  // maintain the attribute's consistency with draco::PointCloud.
+  PointAttribute *attribute(int32_t att_id) {
+    DRACO_DCHECK_LE(0, att_id);
+    DRACO_DCHECK_LT(att_id, static_cast<int32_t>(attributes_.size()));
+    return attributes_[att_id].get();
+  }
+
+  // Adds a new attribute to the point cloud.
+  // Returns the attribute id.
+  int AddAttribute(std::unique_ptr<PointAttribute> pa);
+
+  // Creates and adds a new attribute to the point cloud. The attribute has
+  // properties derived from the provided GeometryAttribute |att|.
+  // If |identity_mapping| is set to true, the attribute will use identity
+  // mapping between point indices and attribute value indices (i.e., each
+  // point has a unique attribute value). If |identity_mapping| is false, the
+  // mapping between point indices and attribute value indices is set to
+  // explicit, and it needs to be initialized manually using the
+  // PointAttribute::SetPointMapEntry() method. |num_attribute_values| can be
+  // used to specify the number of attribute values that are going to be
+  // stored in the newly created attribute. Returns attribute id of the newly
+  // created attribute or -1 in case of failure.
+  int AddAttribute(const GeometryAttribute &att, bool identity_mapping,
+                   AttributeValueIndex::ValueType num_attribute_values);
+
+  // Creates and returns a new attribute or nullptr in case of failure. This
+  // method is similar to AddAttribute(), except that it returns the new
+  // attribute instead of adding it to the point cloud.
+  std::unique_ptr<PointAttribute> CreateAttribute(
+      const GeometryAttribute &att, bool identity_mapping,
+      AttributeValueIndex::ValueType num_attribute_values) const;
+
+  // Assigns an attribute id to a given PointAttribute. If an attribute with
+  // the same attribute id already exists, it is deleted.
+  virtual void SetAttribute(int att_id, std::unique_ptr<PointAttribute> pa);
+
+  // Deletes an attribute with specified attribute id. Note that this changes
+  // attribute ids of all subsequent attributes.
+  virtual void DeleteAttribute(int att_id);
+
+#ifdef DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED
+  // Deduplicates all attribute values (all attribute entries with the same
+  // value are merged into a single entry).
+  virtual bool DeduplicateAttributeValues();
+#endif
+
+#ifdef DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+  // Removes duplicate point ids (two point ids are duplicate when all of their
+  // attributes are mapped to the same entry ids).
+  virtual void DeduplicatePointIds();
+#endif
+
+  // Get bounding box.
+  BoundingBox ComputeBoundingBox() const;
+
+  // Add metadata.
+  void AddMetadata(std::unique_ptr<GeometryMetadata> metadata) {
+    metadata_ = std::move(metadata);
+  }
+
+  // Add metadata for an attribute.
+  void AddAttributeMetadata(int32_t att_id,
+                            std::unique_ptr<AttributeMetadata> metadata) {
+    if (!metadata_) {
+      metadata_ = std::unique_ptr<GeometryMetadata>(new GeometryMetadata());
+    }
+    const int32_t att_unique_id = attribute(att_id)->unique_id();
+    metadata->set_att_unique_id(att_unique_id);
+    metadata_->AddAttributeMetadata(std::move(metadata));
+  }
+
+  const AttributeMetadata *GetAttributeMetadataByAttributeId(
+      int32_t att_id) const {
+    if (metadata_ == nullptr) {
+      return nullptr;
+    }
+    const uint32_t unique_id = attribute(att_id)->unique_id();
+    return metadata_->GetAttributeMetadataByUniqueId(unique_id);
+  }
+
+  // Returns the attribute metadata that has the requested metadata entry.
+  const AttributeMetadata *GetAttributeMetadataByStringEntry(
+      const std::string &name, const std::string &value) const {
+    if (metadata_ == nullptr) {
+      return nullptr;
+    }
+    return metadata_->GetAttributeMetadataByStringEntry(name, value);
+  }
+
+  // Returns the first attribute that has the requested metadata entry.
+  int GetAttributeIdByMetadataEntry(const std::string &name,
+                                    const std::string &value) const {
+    if (metadata_ == nullptr) {
+      return -1;
+    }
+    const AttributeMetadata *att_metadata =
+        metadata_->GetAttributeMetadataByStringEntry(name, value);
+    if (!att_metadata) {
+      return -1;
+    }
+    return GetAttributeIdByUniqueId(att_metadata->att_unique_id());
+  }
+
+  // Get a const pointer of the metadata of the point cloud.
+  const GeometryMetadata *GetMetadata() const { return metadata_.get(); }
+
+  // Get a pointer to the metadata of the point cloud.
+  GeometryMetadata *metadata() { return metadata_.get(); }
+
+  // Returns the number of n-dimensional points stored within the point cloud.
+  PointIndex::ValueType num_points() const { return num_points_; }
+
+  // Sets the number of points. It's the caller's responsibility to ensure the
+  // new number is valid with respect to the PointAttributes stored in the point
+  // cloud.
+  void set_num_points(PointIndex::ValueType num) { num_points_ = num; }
+
+ protected:
+#ifdef DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+  // Applies id mapping of deduplicated points (called by DeduplicatePointIds).
+  virtual void ApplyPointIdDeduplication(
+      const IndexTypeVector<PointIndex, PointIndex> &id_map,
+      const std::vector<PointIndex> &unique_point_ids);
+#endif
+
+ private:
+  // Metadata for the point cloud.
+  std::unique_ptr<GeometryMetadata> metadata_;
+
+  // Attributes describing the point cloud.
+  std::vector<std::unique_ptr<PointAttribute>> attributes_;
+
+  // Ids of named attributes of the given type.
+  std::vector<int32_t>
+      named_attribute_index_[GeometryAttribute::NAMED_ATTRIBUTES_COUNT];
+
+  // The number of n-dimensional points. All point attribute values are stored
+  // in corresponding PointAttribute instances in the |attributes_| array.
+  PointIndex::ValueType num_points_;
+
+  friend struct PointCloudHasher;
+};
+
+// Functor for computing a hash from data stored within a point cloud.
+// Note that this can be quite slow. Two point clouds will have the same hash
+// only when all points have the same order and when all attribute values are
+// exactly the same.
+struct PointCloudHasher {
+  size_t operator()(const PointCloud &pc) const {
+    size_t hash = pc.num_points_;
+    hash = HashCombine(pc.attributes_.size(), hash);
+    for (int i = 0; i < GeometryAttribute::NAMED_ATTRIBUTES_COUNT; ++i) {
+      hash = HashCombine(pc.named_attribute_index_[i].size(), hash);
+      for (int j = 0; j < static_cast<int>(pc.named_attribute_index_[i].size());
+           ++j) {
+        hash = HashCombine(pc.named_attribute_index_[i][j], hash);
+      }
+    }
+    // Hash attributes.
+    for (int i = 0; i < static_cast<int>(pc.attributes_.size()); ++i) {
+      PointAttributeHasher att_hasher;
+      hash = HashCombine(att_hasher(*pc.attributes_[i]), hash);
+    }
+    // Hash metadata.
+    GeometryMetadataHasher metadata_hasher;
+    if (pc.metadata_) {
+      hash = HashCombine(metadata_hasher(*pc.metadata_), hash);
+    }
+    return hash;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_POINT_CLOUD_POINT_CLOUD_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/point_cloud/point_cloud_builder.cc b/Engine/lib/assimp/contrib/draco/src/draco/point_cloud/point_cloud_builder.cc
new file mode 100644
index 000000000..431ae505f
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/point_cloud/point_cloud_builder.cc
@@ -0,0 +1,76 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/point_cloud/point_cloud_builder.h"
+
+namespace draco {
+
+PointCloudBuilder::PointCloudBuilder() {}
+
+void PointCloudBuilder::Start(PointIndex::ValueType num_points) {
+  point_cloud_ = std::unique_ptr<PointCloud>(new PointCloud());
+  point_cloud_->set_num_points(num_points);
+}
+
+int PointCloudBuilder::AddAttribute(GeometryAttribute::Type attribute_type,
+                                    int8_t num_components, DataType data_type) {
+  GeometryAttribute ga;
+  ga.Init(attribute_type, nullptr, num_components, data_type, false,
+          DataTypeLength(data_type) * num_components, 0);
+  return point_cloud_->AddAttribute(ga, true, point_cloud_->num_points());
+}
+
+void PointCloudBuilder::SetAttributeValueForPoint(int att_id,
+                                                  PointIndex point_index,
+                                                  const void *attribute_value) {
+  PointAttribute *const att = point_cloud_->attribute(att_id);
+  att->SetAttributeValue(att->mapped_index(point_index), attribute_value);
+}
+
+void PointCloudBuilder::SetAttributeValuesForAllPoints(
+    int att_id, const void *attribute_values, int stride) {
+  PointAttribute *const att = point_cloud_->attribute(att_id);
+  const int data_stride =
+      DataTypeLength(att->data_type()) * att->num_components();
+  if (stride == 0) {
+    stride = data_stride;
+  }
+  if (stride == data_stride) {
+    // Fast copy path.
+    att->buffer()->Write(0, attribute_values,
+                         point_cloud_->num_points() * data_stride);
+  } else {
+    // Copy attribute entries one by one.
+    for (PointIndex i(0); i < point_cloud_->num_points(); ++i) {
+      att->SetAttributeValue(
+          att->mapped_index(i),
+          static_cast<const uint8_t *>(attribute_values) + stride * i.value());
+    }
+  }
+}
+
+std::unique_ptr<PointCloud> PointCloudBuilder::Finalize(
+    bool deduplicate_points) {
+  if (deduplicate_points) {
+#ifdef DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED
+    point_cloud_->DeduplicateAttributeValues();
+#endif
+#ifdef DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+    point_cloud_->DeduplicatePointIds();
+#endif
+  }
+  return std::move(point_cloud_);
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/point_cloud/point_cloud_builder.h b/Engine/lib/assimp/contrib/draco/src/draco/point_cloud/point_cloud_builder.h
new file mode 100644
index 000000000..cf55a728b
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/point_cloud/point_cloud_builder.h
@@ -0,0 +1,80 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_POINT_CLOUD_POINT_CLOUD_BUILDER_H_
+#define DRACO_POINT_CLOUD_POINT_CLOUD_BUILDER_H_
+
+#include "draco/point_cloud/point_cloud.h"
+
+namespace draco {
+
+// A helper class for constructing PointCloud instances from other data sources.
+// Usage:
+//   PointCloudBuilder builder;
+//   // Initialize the builder for a given number of points (required).
+//   builder.Start(num_points);
+//   // Specify desired attributes.
+//   int pos_att_id =
+//       builder.AddAttribute(GeometryAttribute::POSITION, 3, DT_FLOAT32);
+//   // Add attribute values.
+//   for (PointIndex i(0); i < num_points; ++i) {
+//     builder.SetAttributeValueForPoint(pos_att_id, i, input_pos[i.value()]);
+//   }
+//   // Get the final PointCloud.
+//   constexpr bool deduplicate_points = false;
+//   std::unique_ptr<PointCloud> pc = builder.Finalize(deduplicate_points);
+
+class PointCloudBuilder {
+ public:
+  PointCloudBuilder();
+
+  // Starts collecting point cloud data.
+  // The behavior of other functions is undefined before this method is called.
+  void Start(PointIndex::ValueType num_points);
+
+  int AddAttribute(GeometryAttribute::Type attribute_type,
+                   int8_t num_components, DataType data_type);
+
+  // Sets attribute value for a specific point.
+  // |attribute_value| must contain data in the format specified by the
+  // AddAttribute method.
+  void SetAttributeValueForPoint(int att_id, PointIndex point_index,
+                                 const void *attribute_value);
+
+  // Sets attribute values for all points. All the values must be stored in the
+  // input |attribute_values| buffer. |stride| can be used to define the byte
+  // offset between two consecutive attribute values. If |stride| is set to 0,
+  // the stride is automatically computed based on the format of the given
+  // attribute.
+  void SetAttributeValuesForAllPoints(int att_id, const void *attribute_values,
+                                      int stride);
+
+  // Finalizes the PointCloud or returns nullptr on error.
+  // If |deduplicate_points| is set to true, the following happens:
+  //   1. Attribute values with duplicate entries are deduplicated.
+  //   2. Point ids that are mapped to the same attribute values are
+  //      deduplicated.
+  // Therefore, if |deduplicate_points| is true the final PointCloud can have
+  // a different number of point from the value specified in the Start method.
+  // Once this function is called, the builder becomes invalid and cannot be
+  // used until the method Start() is called again.
+  std::unique_ptr<PointCloud> Finalize(bool deduplicate_points);
+
+ private:
+  std::unique_ptr<PointCloud> point_cloud_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_POINT_CLOUD_POINT_CLOUD_BUILDER_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/point_cloud/point_cloud_builder_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/point_cloud/point_cloud_builder_test.cc
new file mode 100644
index 000000000..3222a4c8d
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/point_cloud/point_cloud_builder_test.cc
@@ -0,0 +1,171 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/point_cloud/point_cloud_builder.h"
+
+#include "draco/core/draco_test_base.h"
+
+namespace draco {
+
+class PointCloudBuilderTest : public ::testing::Test {
+ protected:
+  // Test data.
+  // clang-format off
+  std::vector<float> pos_data_ = {10.f, 0.f, 1.f,
+                                  11.f, 1.f, 2.f,
+                                  12.f, 2.f, 8.f,
+                                  13.f, 4.f, 7.f,
+                                  14.f, 5.f, 6.f,
+                                  15.f, 6.f, 5.f,
+                                  16.f, 1.f, 3.f,
+                                  17.f, 1.f, 2.f,
+                                  11.f, 1.f, 2.f,
+                                  10.f, 0.f, 1.f};
+  std::vector<int16_t> intensity_data_ = {100,
+                                          200,
+                                          500,
+                                          700,
+                                          400,
+                                          400,
+                                          400,
+                                          100,
+                                          100,
+                                          100};
+  // clang-format on
+};
+
+TEST_F(PointCloudBuilderTest, IndividualTest_NoDedup) {
+  // This test verifies that PointCloudBuilder can construct point cloud using
+  // SetAttributeValueForPoint API without deduplication.
+  PointCloudBuilder builder;
+  builder.Start(10);
+  const int pos_att_id =
+      builder.AddAttribute(GeometryAttribute::POSITION, 3, DT_FLOAT32);
+  const int intensity_att_id =
+      builder.AddAttribute(GeometryAttribute::GENERIC, 1, DT_INT16);
+  for (PointIndex i(0); i < 10; ++i) {
+    builder.SetAttributeValueForPoint(pos_att_id, i,
+                                      pos_data_.data() + 3 * i.value());
+    builder.SetAttributeValueForPoint(intensity_att_id, i,
+                                      intensity_data_.data() + i.value());
+  }
+  std::unique_ptr<PointCloud> res = builder.Finalize(false);
+  ASSERT_TRUE(res != nullptr);
+  ASSERT_EQ(res->num_points(), 10);
+}
+
+TEST_F(PointCloudBuilderTest, IndividualTest_Dedup) {
+  // This test verifies that PointCloudBuilder can construct point cloud using
+  // SetAttributeValueForPoint API with deduplication.
+  PointCloudBuilder builder;
+  builder.Start(10);
+  const int pos_att_id =
+      builder.AddAttribute(GeometryAttribute::POSITION, 3, DT_FLOAT32);
+  const int intensity_att_id =
+      builder.AddAttribute(GeometryAttribute::GENERIC, 1, DT_INT16);
+  for (PointIndex i(0); i < 10; ++i) {
+    builder.SetAttributeValueForPoint(pos_att_id, i,
+                                      pos_data_.data() + 3 * i.value());
+    builder.SetAttributeValueForPoint(intensity_att_id, i,
+                                      intensity_data_.data() + i.value());
+  }
+  std::unique_ptr<PointCloud> res = builder.Finalize(true);
+  ASSERT_TRUE(res != nullptr);
+  ASSERT_EQ(res->num_points(), 9);
+}
+
+TEST_F(PointCloudBuilderTest, BatchTest) {
+  // This test verifies that PointCloudBuilder can construct point cloud using
+  // SetAttributeValuesForAllPoints API.
+  PointCloudBuilder builder;
+  builder.Start(10);
+  const int pos_att_id =
+      builder.AddAttribute(GeometryAttribute::POSITION, 3, DT_FLOAT32);
+  const int intensity_att_id =
+      builder.AddAttribute(GeometryAttribute::GENERIC, 1, DT_INT16);
+  builder.SetAttributeValuesForAllPoints(pos_att_id, pos_data_.data(), 0);
+  builder.SetAttributeValuesForAllPoints(intensity_att_id,
+                                         intensity_data_.data(), 0);
+  std::unique_ptr<PointCloud> res = builder.Finalize(false);
+  ASSERT_TRUE(res != nullptr);
+  ASSERT_EQ(res->num_points(), 10);
+  for (PointIndex i(0); i < 10; ++i) {
+    float pos_val[3];
+    res->attribute(pos_att_id)->GetMappedValue(i, pos_val);
+    for (int c = 0; c < 3; ++c) {
+      ASSERT_EQ(pos_val[c], pos_data_[3 * i.value() + c]);
+    }
+    int16_t int_val;
+    res->attribute(intensity_att_id)->GetMappedValue(i, &int_val);
+    ASSERT_EQ(intensity_data_[i.value()], int_val);
+  }
+}
+
+TEST_F(PointCloudBuilderTest, MultiUse) {
+  // This test verifies that PointCloudBuilder can be used multiple times
+  PointCloudBuilder builder;
+  {
+    builder.Start(10);
+    const int pos_att_id =
+        builder.AddAttribute(GeometryAttribute::POSITION, 3, DT_FLOAT32);
+    const int intensity_att_id =
+        builder.AddAttribute(GeometryAttribute::GENERIC, 1, DT_INT16);
+    builder.SetAttributeValuesForAllPoints(pos_att_id, pos_data_.data(), 0);
+    builder.SetAttributeValuesForAllPoints(intensity_att_id,
+                                           intensity_data_.data(), 0);
+    std::unique_ptr<PointCloud> res = builder.Finalize(false);
+    ASSERT_TRUE(res != nullptr);
+    ASSERT_EQ(res->num_points(), 10);
+    for (PointIndex i(0); i < 10; ++i) {
+      float pos_val[3];
+      res->attribute(pos_att_id)->GetMappedValue(i, pos_val);
+      for (int c = 0; c < 3; ++c) {
+        ASSERT_EQ(pos_val[c], pos_data_[3 * i.value() + c]);
+      }
+      int16_t int_val;
+      res->attribute(intensity_att_id)->GetMappedValue(i, &int_val);
+      ASSERT_EQ(intensity_data_[i.value()], int_val);
+    }
+  }
+
+  {
+    // Use only a sub-set of data (offsetted to avoid possible reuse of old
+    // data).
+    builder.Start(4);
+    const int pos_att_id =
+        builder.AddAttribute(GeometryAttribute::POSITION, 3, DT_FLOAT32);
+    const int intensity_att_id =
+        builder.AddAttribute(GeometryAttribute::GENERIC, 1, DT_INT16);
+    constexpr int offset = 5;
+    builder.SetAttributeValuesForAllPoints(pos_att_id,
+                                           pos_data_.data() + 3 * offset, 0);
+    builder.SetAttributeValuesForAllPoints(intensity_att_id,
+                                           intensity_data_.data() + offset, 0);
+    std::unique_ptr<PointCloud> res = builder.Finalize(false);
+    ASSERT_TRUE(res != nullptr);
+    ASSERT_EQ(res->num_points(), 4);
+    for (PointIndex i(0); i < 4; ++i) {
+      float pos_val[3];
+      res->attribute(pos_att_id)->GetMappedValue(i, pos_val);
+      for (int c = 0; c < 3; ++c) {
+        ASSERT_EQ(pos_val[c], pos_data_[3 * (i.value() + offset) + c]);
+      }
+      int16_t int_val;
+      res->attribute(intensity_att_id)->GetMappedValue(i, &int_val);
+      ASSERT_EQ(intensity_data_[i.value() + offset], int_val);
+    }
+  }
+}
+
+}  // namespace draco
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/point_cloud/point_cloud_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/point_cloud/point_cloud_test.cc
new file mode 100644
index 000000000..4e9460370
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/point_cloud/point_cloud_test.cc
@@ -0,0 +1,132 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/point_cloud/point_cloud.h"
+
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+#include "draco/metadata/geometry_metadata.h"
+
+namespace {
+
+class PointCloudTest : public ::testing::Test {
+ protected:
+  PointCloudTest() {}
+};
+
+TEST_F(PointCloudTest, TestAttributeDeletion) {
+  draco::PointCloud pc;
+  // Test whether we can correctly delete an attribute from a point cloud.
+  // Create some attributes for the point cloud.
+  draco::GeometryAttribute pos_att;
+  pos_att.Init(draco::GeometryAttribute::POSITION, nullptr, 3,
+               draco::DT_FLOAT32, false, 12, 0);
+  draco::GeometryAttribute norm_att;
+  norm_att.Init(draco::GeometryAttribute::NORMAL, nullptr, 3, draco::DT_FLOAT32,
+                false, 12, 0);
+  draco::GeometryAttribute gen_att;
+  gen_att.Init(draco::GeometryAttribute::GENERIC, nullptr, 3, draco::DT_FLOAT32,
+               false, 12, 0);
+
+  // Add one position, two normal and two generic attributes.
+  pc.AddAttribute(pos_att, false, 0);
+  pc.AddAttribute(gen_att, false, 0);
+  pc.AddAttribute(norm_att, false, 0);
+  pc.AddAttribute(gen_att, false, 0);
+  pc.AddAttribute(norm_att, false, 0);
+
+  ASSERT_EQ(pc.num_attributes(), 5);
+  ASSERT_EQ(pc.attribute(0)->attribute_type(),
+            draco::GeometryAttribute::POSITION);
+  ASSERT_EQ(pc.attribute(3)->attribute_type(),
+            draco::GeometryAttribute::GENERIC);
+
+  // Delete generic attribute.
+  pc.DeleteAttribute(1);
+  ASSERT_EQ(pc.num_attributes(), 4);
+  ASSERT_EQ(pc.attribute(1)->attribute_type(),
+            draco::GeometryAttribute::NORMAL);
+  ASSERT_EQ(pc.NumNamedAttributes(draco::GeometryAttribute::NORMAL), 2);
+  ASSERT_EQ(pc.GetNamedAttributeId(draco::GeometryAttribute::NORMAL, 1), 3);
+
+  // Delete the first normal attribute.
+  pc.DeleteAttribute(1);
+  ASSERT_EQ(pc.num_attributes(), 3);
+  ASSERT_EQ(pc.attribute(1)->attribute_type(),
+            draco::GeometryAttribute::GENERIC);
+  ASSERT_EQ(pc.NumNamedAttributes(draco::GeometryAttribute::NORMAL), 1);
+  ASSERT_EQ(pc.GetNamedAttributeId(draco::GeometryAttribute::NORMAL, 0), 2);
+}
+
+TEST_F(PointCloudTest, TestPointCloudWithMetadata) {
+  draco::PointCloud pc;
+  std::unique_ptr<draco::GeometryMetadata> metadata =
+      std::unique_ptr<draco::GeometryMetadata>(new draco::GeometryMetadata());
+
+  // Add a position attribute metadata.
+  draco::GeometryAttribute pos_att;
+  pos_att.Init(draco::GeometryAttribute::POSITION, nullptr, 3,
+               draco::DT_FLOAT32, false, 12, 0);
+  const uint32_t pos_att_id = pc.AddAttribute(pos_att, false, 0);
+  ASSERT_EQ(pos_att_id, 0);
+  std::unique_ptr<draco::AttributeMetadata> pos_metadata =
+      std::unique_ptr<draco::AttributeMetadata>(new draco::AttributeMetadata());
+  pos_metadata->AddEntryString("name", "position");
+  pc.AddAttributeMetadata(pos_att_id, std::move(pos_metadata));
+  const draco::GeometryMetadata *pc_metadata = pc.GetMetadata();
+  ASSERT_NE(pc_metadata, nullptr);
+  // Add a generic material attribute metadata.
+  draco::GeometryAttribute material_att;
+  material_att.Init(draco::GeometryAttribute::GENERIC, nullptr, 3,
+                    draco::DT_FLOAT32, false, 12, 0);
+  const uint32_t material_att_id = pc.AddAttribute(material_att, false, 0);
+  ASSERT_EQ(material_att_id, 1);
+  std::unique_ptr<draco::AttributeMetadata> material_metadata =
+      std::unique_ptr<draco::AttributeMetadata>(new draco::AttributeMetadata());
+  material_metadata->AddEntryString("name", "material");
+  // The material attribute has id of 1 now.
+  pc.AddAttributeMetadata(material_att_id, std::move(material_metadata));
+
+  // Test if the attribute metadata is correctly added.
+  const draco::AttributeMetadata *requested_pos_metadata =
+      pc.GetAttributeMetadataByStringEntry("name", "position");
+  ASSERT_NE(requested_pos_metadata, nullptr);
+  const draco::AttributeMetadata *requested_mat_metadata =
+      pc.GetAttributeMetadataByStringEntry("name", "material");
+  ASSERT_NE(requested_mat_metadata, nullptr);
+
+  // Attribute id should be preserved.
+  ASSERT_EQ(
+      pc.GetAttributeIdByUniqueId(requested_pos_metadata->att_unique_id()), 0);
+  ASSERT_EQ(
+      pc.GetAttributeIdByUniqueId(requested_mat_metadata->att_unique_id()), 1);
+
+  // Test deleting attribute with metadata.
+  pc.DeleteAttribute(pos_att_id);
+  ASSERT_EQ(pc.GetAttributeMetadataByStringEntry("name", "position"), nullptr);
+
+  requested_mat_metadata =
+      pc.GetAttributeMetadataByStringEntry("name", "material");
+  // The unique id should not be changed.
+  ASSERT_EQ(requested_mat_metadata->att_unique_id(), 1);
+  // Now position attribute is removed, material attribute should have the
+  // attribute id of 0.
+  ASSERT_EQ(
+      pc.GetAttributeIdByUniqueId(requested_mat_metadata->att_unique_id()), 0);
+  // Should be able to get metadata using the current attribute id.
+  // Attribute id of material attribute is changed from 1 to 0.
+  ASSERT_NE(pc.GetAttributeMetadataByAttributeId(0), nullptr);
+}
+
+}  // namespace
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/tools/draco_decoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/tools/draco_decoder.cc
new file mode 100644
index 000000000..610709d62
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/tools/draco_decoder.cc
@@ -0,0 +1,168 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include <cinttypes>
+
+#include "draco/compression/decode.h"
+#include "draco/core/cycle_timer.h"
+#include "draco/io/file_utils.h"
+#include "draco/io/obj_encoder.h"
+#include "draco/io/parser_utils.h"
+#include "draco/io/ply_encoder.h"
+
+namespace {
+
+struct Options {
+  Options();
+
+  std::string input;
+  std::string output;
+};
+
+Options::Options() {}
+
+void Usage() {
+  printf("Usage: draco_decoder [options] -i input\n");
+  printf("\n");
+  printf("Main options:\n");
+  printf("  -h | -?               show help.\n");
+  printf("  -o <output>           output file name.\n");
+}
+
+int ReturnError(const draco::Status &status) {
+  printf("Failed to decode the input file %s\n", status.error_msg());
+  return -1;
+}
+
+}  // namespace
+
+int main(int argc, char **argv) {
+  Options options;
+  const int argc_check = argc - 1;
+
+  for (int i = 1; i < argc; ++i) {
+    if (!strcmp("-h", argv[i]) || !strcmp("-?", argv[i])) {
+      Usage();
+      return 0;
+    } else if (!strcmp("-i", argv[i]) && i < argc_check) {
+      options.input = argv[++i];
+    } else if (!strcmp("-o", argv[i]) && i < argc_check) {
+      options.output = argv[++i];
+    }
+  }
+  if (argc < 3 || options.input.empty()) {
+    Usage();
+    return -1;
+  }
+
+  std::vector<char> data;
+  if (!draco::ReadFileToBuffer(options.input, &data)) {
+    printf("Failed opening the input file.\n");
+    return -1;
+  }
+
+  if (data.empty()) {
+    printf("Empty input file.\n");
+    return -1;
+  }
+
+  // Create a draco decoding buffer. Note that no data is copied in this step.
+  draco::DecoderBuffer buffer;
+  buffer.Init(data.data(), data.size());
+
+  draco::CycleTimer timer;
+  // Decode the input data into a geometry.
+  std::unique_ptr<draco::PointCloud> pc;
+  draco::Mesh *mesh = nullptr;
+  auto type_statusor = draco::Decoder::GetEncodedGeometryType(&buffer);
+  if (!type_statusor.ok()) {
+    return ReturnError(type_statusor.status());
+  }
+  const draco::EncodedGeometryType geom_type = type_statusor.value();
+  if (geom_type == draco::TRIANGULAR_MESH) {
+    timer.Start();
+    draco::Decoder decoder;
+    auto statusor = decoder.DecodeMeshFromBuffer(&buffer);
+    if (!statusor.ok()) {
+      return ReturnError(statusor.status());
+    }
+    std::unique_ptr<draco::Mesh> in_mesh = std::move(statusor).value();
+    timer.Stop();
+    if (in_mesh) {
+      mesh = in_mesh.get();
+      pc = std::move(in_mesh);
+    }
+  } else if (geom_type == draco::POINT_CLOUD) {
+    // Failed to decode it as mesh, so let's try to decode it as a point cloud.
+    timer.Start();
+    draco::Decoder decoder;
+    auto statusor = decoder.DecodePointCloudFromBuffer(&buffer);
+    if (!statusor.ok()) {
+      return ReturnError(statusor.status());
+    }
+    pc = std::move(statusor).value();
+    timer.Stop();
+  }
+
+  if (pc == nullptr) {
+    printf("Failed to decode the input file.\n");
+    return -1;
+  }
+
+  if (options.output.empty()) {
+    // Save the output model into a ply file.
+    options.output = options.input + ".ply";
+  }
+
+  // Save the decoded geometry into a file.
+  // TODO(fgalligan): Change extension code to look for '.'.
+  const std::string extension = draco::parser::ToLower(
+      options.output.size() >= 4
+          ? options.output.substr(options.output.size() - 4)
+          : options.output);
+
+  if (extension == ".obj") {
+    draco::ObjEncoder obj_encoder;
+    if (mesh) {
+      if (!obj_encoder.EncodeToFile(*mesh, options.output)) {
+        printf("Failed to store the decoded mesh as OBJ.\n");
+        return -1;
+      }
+    } else {
+      if (!obj_encoder.EncodeToFile(*pc.get(), options.output)) {
+        printf("Failed to store the decoded point cloud as OBJ.\n");
+        return -1;
+      }
+    }
+  } else if (extension == ".ply") {
+    draco::PlyEncoder ply_encoder;
+    if (mesh) {
+      if (!ply_encoder.EncodeToFile(*mesh, options.output)) {
+        printf("Failed to store the decoded mesh as PLY.\n");
+        return -1;
+      }
+    } else {
+      if (!ply_encoder.EncodeToFile(*pc.get(), options.output)) {
+        printf("Failed to store the decoded point cloud as PLY.\n");
+        return -1;
+      }
+    }
+  } else {
+    printf("Invalid extension of the output file. Use either .ply or .obj.\n");
+    return -1;
+  }
+  printf("Decoded geometry saved to %s (%" PRId64 " ms to decode)\n",
+         options.output.c_str(), timer.GetInMs());
+  return 0;
+}
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/tools/draco_encoder.cc b/Engine/lib/assimp/contrib/draco/src/draco/tools/draco_encoder.cc
new file mode 100644
index 000000000..7e3632d7d
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/tools/draco_encoder.cc
@@ -0,0 +1,369 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include <cinttypes>
+#include <cstdlib>
+
+#include "draco/compression/encode.h"
+#include "draco/core/cycle_timer.h"
+#include "draco/io/file_utils.h"
+#include "draco/io/mesh_io.h"
+#include "draco/io/point_cloud_io.h"
+
+namespace {
+
+struct Options {
+  Options();
+
+  bool is_point_cloud;
+  int pos_quantization_bits;
+  int tex_coords_quantization_bits;
+  bool tex_coords_deleted;
+  int normals_quantization_bits;
+  bool normals_deleted;
+  int generic_quantization_bits;
+  bool generic_deleted;
+  int compression_level;
+  bool use_metadata;
+  std::string input;
+  std::string output;
+};
+
+Options::Options()
+    : is_point_cloud(false),
+      pos_quantization_bits(11),
+      tex_coords_quantization_bits(10),
+      tex_coords_deleted(false),
+      normals_quantization_bits(8),
+      normals_deleted(false),
+      generic_quantization_bits(8),
+      generic_deleted(false),
+      compression_level(7),
+      use_metadata(false) {}
+
+void Usage() {
+  printf("Usage: draco_encoder [options] -i input\n");
+  printf("\n");
+  printf("Main options:\n");
+  printf("  -h | -?               show help.\n");
+  printf("  -i <input>            input file name.\n");
+  printf("  -o <output>           output file name.\n");
+  printf(
+      "  -point_cloud          forces the input to be encoded as a point "
+      "cloud.\n");
+  printf(
+      "  -qp <value>           quantization bits for the position "
+      "attribute, default=11.\n");
+  printf(
+      "  -qt <value>           quantization bits for the texture coordinate "
+      "attribute, default=10.\n");
+  printf(
+      "  -qn <value>           quantization bits for the normal vector "
+      "attribute, default=8.\n");
+  printf(
+      "  -qg <value>           quantization bits for any generic attribute, "
+      "default=8.\n");
+  printf(
+      "  -cl <value>           compression level [0-10], most=10, least=0, "
+      "default=7.\n");
+  printf(
+      "  --skip ATTRIBUTE_NAME skip a given attribute (NORMAL, TEX_COORD, "
+      "GENERIC)\n");
+  printf(
+      "  --metadata            use metadata to encode extra information in "
+      "mesh files.\n");
+  printf(
+      "\nUse negative quantization values to skip the specified attribute\n");
+}
+
+int StringToInt(const std::string &s) {
+  char *end;
+  return strtol(s.c_str(), &end, 10);  // NOLINT
+}
+
+void PrintOptions(const draco::PointCloud &pc, const Options &options) {
+  printf("Encoder options:\n");
+  printf("  Compression level = %d\n", options.compression_level);
+  if (options.pos_quantization_bits == 0) {
+    printf("  Positions: No quantization\n");
+  } else {
+    printf("  Positions: Quantization = %d bits\n",
+           options.pos_quantization_bits);
+  }
+
+  if (pc.GetNamedAttributeId(draco::GeometryAttribute::TEX_COORD) >= 0) {
+    if (options.tex_coords_quantization_bits == 0) {
+      printf("  Texture coordinates: No quantization\n");
+    } else {
+      printf("  Texture coordinates: Quantization = %d bits\n",
+             options.tex_coords_quantization_bits);
+    }
+  } else if (options.tex_coords_deleted) {
+    printf("  Texture coordinates: Skipped\n");
+  }
+
+  if (pc.GetNamedAttributeId(draco::GeometryAttribute::NORMAL) >= 0) {
+    if (options.normals_quantization_bits == 0) {
+      printf("  Normals: No quantization\n");
+    } else {
+      printf("  Normals: Quantization = %d bits\n",
+             options.normals_quantization_bits);
+    }
+  } else if (options.normals_deleted) {
+    printf("  Normals: Skipped\n");
+  }
+
+  if (pc.GetNamedAttributeId(draco::GeometryAttribute::GENERIC) >= 0) {
+    if (options.generic_quantization_bits == 0) {
+      printf("  Generic: No quantization\n");
+    } else {
+      printf("  Generic: Quantization = %d bits\n",
+             options.generic_quantization_bits);
+    }
+  } else if (options.generic_deleted) {
+    printf("  Generic: Skipped\n");
+  }
+  printf("\n");
+}
+
+int EncodePointCloudToFile(const draco::PointCloud &pc, const std::string &file,
+                           draco::Encoder *encoder) {
+  draco::CycleTimer timer;
+  // Encode the geometry.
+  draco::EncoderBuffer buffer;
+  timer.Start();
+  const draco::Status status = encoder->EncodePointCloudToBuffer(pc, &buffer);
+  if (!status.ok()) {
+    printf("Failed to encode the point cloud.\n");
+    printf("%s\n", status.error_msg());
+    return -1;
+  }
+  timer.Stop();
+  // Save the encoded geometry into a file.
+  if (!draco::WriteBufferToFile(buffer.data(), buffer.size(), file)) {
+    printf("Failed to write the output file.\n");
+    return -1;
+  }
+  printf("Encoded point cloud saved to %s (%" PRId64 " ms to encode).\n",
+         file.c_str(), timer.GetInMs());
+  printf("\nEncoded size = %zu bytes\n\n", buffer.size());
+  return 0;
+}
+
+int EncodeMeshToFile(const draco::Mesh &mesh, const std::string &file,
+                     draco::Encoder *encoder) {
+  draco::CycleTimer timer;
+  // Encode the geometry.
+  draco::EncoderBuffer buffer;
+  timer.Start();
+  const draco::Status status = encoder->EncodeMeshToBuffer(mesh, &buffer);
+  if (!status.ok()) {
+    printf("Failed to encode the mesh.\n");
+    printf("%s\n", status.error_msg());
+    return -1;
+  }
+  timer.Stop();
+  // Save the encoded geometry into a file.
+  if (!draco::WriteBufferToFile(buffer.data(), buffer.size(), file)) {
+    printf("Failed to create the output file.\n");
+    return -1;
+  }
+  printf("Encoded mesh saved to %s (%" PRId64 " ms to encode).\n", file.c_str(),
+         timer.GetInMs());
+  printf("\nEncoded size = %zu bytes\n\n", buffer.size());
+  return 0;
+}
+
+}  // anonymous namespace
+
+int main(int argc, char **argv) {
+  Options options;
+  const int argc_check = argc - 1;
+
+  for (int i = 1; i < argc; ++i) {
+    if (!strcmp("-h", argv[i]) || !strcmp("-?", argv[i])) {
+      Usage();
+      return 0;
+    } else if (!strcmp("-i", argv[i]) && i < argc_check) {
+      options.input = argv[++i];
+    } else if (!strcmp("-o", argv[i]) && i < argc_check) {
+      options.output = argv[++i];
+    } else if (!strcmp("-point_cloud", argv[i])) {
+      options.is_point_cloud = true;
+    } else if (!strcmp("-qp", argv[i]) && i < argc_check) {
+      options.pos_quantization_bits = StringToInt(argv[++i]);
+      if (options.pos_quantization_bits > 30) {
+        printf(
+            "Error: The maximum number of quantization bits for the position "
+            "attribute is 30.\n");
+        return -1;
+      }
+    } else if (!strcmp("-qt", argv[i]) && i < argc_check) {
+      options.tex_coords_quantization_bits = StringToInt(argv[++i]);
+      if (options.tex_coords_quantization_bits > 30) {
+        printf(
+            "Error: The maximum number of quantization bits for the texture "
+            "coordinate attribute is 30.\n");
+        return -1;
+      }
+    } else if (!strcmp("-qn", argv[i]) && i < argc_check) {
+      options.normals_quantization_bits = StringToInt(argv[++i]);
+      if (options.normals_quantization_bits > 30) {
+        printf(
+            "Error: The maximum number of quantization bits for the normal "
+            "attribute is 30.\n");
+        return -1;
+      }
+    } else if (!strcmp("-qg", argv[i]) && i < argc_check) {
+      options.generic_quantization_bits = StringToInt(argv[++i]);
+      if (options.generic_quantization_bits > 30) {
+        printf(
+            "Error: The maximum number of quantization bits for generic "
+            "attributes is 30.\n");
+        return -1;
+      }
+    } else if (!strcmp("-cl", argv[i]) && i < argc_check) {
+      options.compression_level = StringToInt(argv[++i]);
+    } else if (!strcmp("--skip", argv[i]) && i < argc_check) {
+      if (!strcmp("NORMAL", argv[i + 1])) {
+        options.normals_quantization_bits = -1;
+      } else if (!strcmp("TEX_COORD", argv[i + 1])) {
+        options.tex_coords_quantization_bits = -1;
+      } else if (!strcmp("GENERIC", argv[i + 1])) {
+        options.generic_quantization_bits = -1;
+      } else {
+        printf("Error: Invalid attribute name after --skip\n");
+        return -1;
+      }
+      ++i;
+    } else if (!strcmp("--metadata", argv[i])) {
+      options.use_metadata = true;
+    }
+  }
+  if (argc < 3 || options.input.empty()) {
+    Usage();
+    return -1;
+  }
+
+  std::unique_ptr<draco::PointCloud> pc;
+  draco::Mesh *mesh = nullptr;
+  if (!options.is_point_cloud) {
+    auto maybe_mesh =
+        draco::ReadMeshFromFile(options.input, options.use_metadata);
+    if (!maybe_mesh.ok()) {
+      printf("Failed loading the input mesh: %s.\n",
+             maybe_mesh.status().error_msg());
+      return -1;
+    }
+    mesh = maybe_mesh.value().get();
+    pc = std::move(maybe_mesh).value();
+  } else {
+    auto maybe_pc = draco::ReadPointCloudFromFile(options.input);
+    if (!maybe_pc.ok()) {
+      printf("Failed loading the input point cloud: %s.\n",
+             maybe_pc.status().error_msg());
+      return -1;
+    }
+    pc = std::move(maybe_pc).value();
+  }
+
+  if (options.pos_quantization_bits < 0) {
+    printf("Error: Position attribute cannot be skipped.\n");
+    return -1;
+  }
+
+  // Delete attributes if needed. This needs to happen before we set any
+  // quantization settings.
+  if (options.tex_coords_quantization_bits < 0) {
+    if (pc->NumNamedAttributes(draco::GeometryAttribute::TEX_COORD) > 0) {
+      options.tex_coords_deleted = true;
+    }
+    while (pc->NumNamedAttributes(draco::GeometryAttribute::TEX_COORD) > 0) {
+      pc->DeleteAttribute(
+          pc->GetNamedAttributeId(draco::GeometryAttribute::TEX_COORD, 0));
+    }
+  }
+  if (options.normals_quantization_bits < 0) {
+    if (pc->NumNamedAttributes(draco::GeometryAttribute::NORMAL) > 0) {
+      options.normals_deleted = true;
+    }
+    while (pc->NumNamedAttributes(draco::GeometryAttribute::NORMAL) > 0) {
+      pc->DeleteAttribute(
+          pc->GetNamedAttributeId(draco::GeometryAttribute::NORMAL, 0));
+    }
+  }
+  if (options.generic_quantization_bits < 0) {
+    if (pc->NumNamedAttributes(draco::GeometryAttribute::GENERIC) > 0) {
+      options.generic_deleted = true;
+    }
+    while (pc->NumNamedAttributes(draco::GeometryAttribute::GENERIC) > 0) {
+      pc->DeleteAttribute(
+          pc->GetNamedAttributeId(draco::GeometryAttribute::GENERIC, 0));
+    }
+  }
+#ifdef DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+  // If any attribute has been deleted, run deduplication of point indices again
+  // as some points can be possibly combined.
+  if (options.tex_coords_deleted || options.normals_deleted ||
+      options.generic_deleted) {
+    pc->DeduplicatePointIds();
+  }
+#endif
+
+  // Convert compression level to speed (that 0 = slowest, 10 = fastest).
+  const int speed = 10 - options.compression_level;
+
+  draco::Encoder encoder;
+
+  // Setup encoder options.
+  if (options.pos_quantization_bits > 0) {
+    encoder.SetAttributeQuantization(draco::GeometryAttribute::POSITION,
+                                     options.pos_quantization_bits);
+  }
+  if (options.tex_coords_quantization_bits > 0) {
+    encoder.SetAttributeQuantization(draco::GeometryAttribute::TEX_COORD,
+                                     options.tex_coords_quantization_bits);
+  }
+  if (options.normals_quantization_bits > 0) {
+    encoder.SetAttributeQuantization(draco::GeometryAttribute::NORMAL,
+                                     options.normals_quantization_bits);
+  }
+  if (options.generic_quantization_bits > 0) {
+    encoder.SetAttributeQuantization(draco::GeometryAttribute::GENERIC,
+                                     options.generic_quantization_bits);
+  }
+  encoder.SetSpeedOptions(speed, speed);
+
+  if (options.output.empty()) {
+    // Create a default output file by attaching .drc to the input file name.
+    options.output = options.input + ".drc";
+  }
+
+  PrintOptions(*pc.get(), options);
+
+  int ret = -1;
+  const bool input_is_mesh = mesh && mesh->num_faces() > 0;
+  if (input_is_mesh)
+    ret = EncodeMeshToFile(*mesh, options.output, &encoder);
+  else
+    ret = EncodePointCloudToFile(*pc.get(), options.output, &encoder);
+
+  if (ret != -1 && options.compression_level < 10) {
+    printf(
+        "For better compression, increase the compression level up to '-cl 10' "
+        ".\n\n");
+  }
+
+  return ret;
+}
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/tools/fuzz/build.sh b/Engine/lib/assimp/contrib/draco/src/draco/tools/fuzz/build.sh
new file mode 100644
index 000000000..bbeb10591
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/tools/fuzz/build.sh
@@ -0,0 +1,35 @@
+#!/bin/bash -eu
+# Copyright 2020 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+# build project
+cmake $SRC/draco
+# The draco_decoder and draco_encoder binaries don't build nicely with OSS-Fuzz
+# options, so just build the Draco shared libraries.
+make -j$(nproc) draco
+
+# build fuzzers
+for fuzzer in $(find $SRC/draco/src/draco/tools/fuzz -name '*.cc'); do
+  fuzzer_basename=$(basename -s .cc $fuzzer)
+  $CXX $CXXFLAGS \
+    -I $SRC/ \
+    -I $SRC/draco/src \
+    -I $WORK/ \
+    $LIB_FUZZING_ENGINE \
+    $fuzzer \
+    $WORK/libdraco.a \
+    -o $OUT/$fuzzer_basename
+done
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/tools/fuzz/draco_mesh_decoder_fuzzer.cc b/Engine/lib/assimp/contrib/draco/src/draco/tools/fuzz/draco_mesh_decoder_fuzzer.cc
new file mode 100644
index 000000000..9a508365d
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/tools/fuzz/draco_mesh_decoder_fuzzer.cc
@@ -0,0 +1,29 @@
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <fuzzer/FuzzedDataProvider.h>
+
+#include "draco/src/draco/compression/decode.h"
+#include "draco/src/draco/core/decoder_buffer.h"
+#include "draco/src/draco/mesh/mesh.h"
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  draco::DecoderBuffer buffer;
+  buffer.Init(reinterpret_cast<const char *>(data), size);
+
+  draco::Decoder decoder;
+  decoder.DecodeMeshFromBuffer(&buffer);
+
+  return 0;
+}
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/tools/fuzz/draco_mesh_decoder_without_dequantization_fuzzer.cc b/Engine/lib/assimp/contrib/draco/src/draco/tools/fuzz/draco_mesh_decoder_without_dequantization_fuzzer.cc
new file mode 100644
index 000000000..4c612ccf6
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/tools/fuzz/draco_mesh_decoder_without_dequantization_fuzzer.cc
@@ -0,0 +1,30 @@
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <fuzzer/FuzzedDataProvider.h>
+
+#include "draco/src/draco/compression/decode.h"
+#include "draco/src/draco/core/decoder_buffer.h"
+#include "draco/src/draco/mesh/mesh.h"
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  draco::DecoderBuffer buffer;
+  buffer.Init(reinterpret_cast<const char *>(data), size);
+
+  draco::Decoder decoder;
+  decoder.SetSkipAttributeTransform(draco::GeometryAttribute::POSITION);
+  decoder.DecodeMeshFromBuffer(&buffer);
+
+  return 0;
+}
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/tools/fuzz/draco_pc_decoder_fuzzer.cc b/Engine/lib/assimp/contrib/draco/src/draco/tools/fuzz/draco_pc_decoder_fuzzer.cc
new file mode 100644
index 000000000..3a764f1c9
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/tools/fuzz/draco_pc_decoder_fuzzer.cc
@@ -0,0 +1,29 @@
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <fuzzer/FuzzedDataProvider.h>
+
+#include "draco/src/draco/compression/decode.h"
+#include "draco/src/draco/core/decoder_buffer.h"
+#include "draco/src/draco/point_cloud/point_cloud.h"
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  draco::DecoderBuffer buffer;
+  buffer.Init(reinterpret_cast<const char *>(data), size);
+
+  draco::Decoder decoder;
+  decoder.DecodePointCloudFromBuffer(&buffer);
+
+  return 0;
+}
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/tools/fuzz/draco_pc_decoder_without_dequantization_fuzzer.cc b/Engine/lib/assimp/contrib/draco/src/draco/tools/fuzz/draco_pc_decoder_without_dequantization_fuzzer.cc
new file mode 100644
index 000000000..1d0c539b4
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/tools/fuzz/draco_pc_decoder_without_dequantization_fuzzer.cc
@@ -0,0 +1,30 @@
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <fuzzer/FuzzedDataProvider.h>
+
+#include "draco/src/draco/compression/decode.h"
+#include "draco/src/draco/core/decoder_buffer.h"
+#include "draco/src/draco/point_cloud/point_cloud.h"
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  draco::DecoderBuffer buffer;
+  buffer.Init(reinterpret_cast<const char *>(data), size);
+
+  draco::Decoder decoder;
+  decoder.SetSkipAttributeTransform(draco::GeometryAttribute::POSITION);
+  decoder.DecodePointCloudFromBuffer(&buffer);
+
+  return 0;
+}
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/unity/draco_unity_plugin.cc b/Engine/lib/assimp/contrib/draco/src/draco/unity/draco_unity_plugin.cc
new file mode 100644
index 000000000..e80279b89
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/unity/draco_unity_plugin.cc
@@ -0,0 +1,407 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/unity/draco_unity_plugin.h"
+
+#ifdef DRACO_UNITY_PLUGIN
+
+namespace {
+// Returns a DracoAttribute from a PointAttribute.
+draco::DracoAttribute *CreateDracoAttribute(const draco::PointAttribute *attr) {
+  draco::DracoAttribute *const attribute = new draco::DracoAttribute();
+  attribute->attribute_type =
+      static_cast<draco::GeometryAttribute::Type>(attr->attribute_type());
+  attribute->data_type = static_cast<draco::DataType>(attr->data_type());
+  attribute->num_components = attr->num_components();
+  attribute->unique_id = attr->unique_id();
+  attribute->private_attribute = static_cast<const void *>(attr);
+  return attribute;
+}
+
+// Returns the attribute data in |attr| as an array of type T.
+template <typename T>
+T *CopyAttributeData(int num_points, const draco::PointAttribute *attr) {
+  const int num_components = attr->num_components();
+  T *const data = new T[num_points * num_components];
+
+  for (draco::PointIndex i(0); i < num_points; ++i) {
+    const draco::AttributeValueIndex val_index = attr->mapped_index(i);
+    bool got_data = false;
+    switch (num_components) {
+      case 1:
+        got_data = attr->ConvertValue<T, 1>(val_index,
+                                            data + i.value() * num_components);
+        break;
+      case 2:
+        got_data = attr->ConvertValue<T, 2>(val_index,
+                                            data + i.value() * num_components);
+        break;
+      case 3:
+        got_data = attr->ConvertValue<T, 3>(val_index,
+                                            data + i.value() * num_components);
+        break;
+      case 4:
+        got_data = attr->ConvertValue<T, 4>(val_index,
+                                            data + i.value() * num_components);
+        break;
+      default:
+        break;
+    }
+    if (!got_data) {
+      delete[] data;
+      return nullptr;
+    }
+  }
+
+  return data;
+}
+
+// Returns the attribute data in |attr| as an array of void*.
+void *ConvertAttributeData(int num_points, const draco::PointAttribute *attr) {
+  switch (attr->data_type()) {
+    case draco::DataType::DT_INT8:
+      return static_cast<void *>(CopyAttributeData<int8_t>(num_points, attr));
+    case draco::DataType::DT_UINT8:
+      return static_cast<void *>(CopyAttributeData<uint8_t>(num_points, attr));
+    case draco::DataType::DT_INT16:
+      return static_cast<void *>(CopyAttributeData<int16_t>(num_points, attr));
+    case draco::DataType::DT_UINT16:
+      return static_cast<void *>(CopyAttributeData<uint16_t>(num_points, attr));
+    case draco::DataType::DT_INT32:
+      return static_cast<void *>(CopyAttributeData<int32_t>(num_points, attr));
+    case draco::DataType::DT_UINT32:
+      return static_cast<void *>(CopyAttributeData<uint32_t>(num_points, attr));
+    case draco::DataType::DT_FLOAT32:
+      return static_cast<void *>(CopyAttributeData<float>(num_points, attr));
+    default:
+      return nullptr;
+  }
+}
+}  // namespace
+
+namespace draco {
+
+void EXPORT_API ReleaseDracoMesh(DracoMesh **mesh_ptr) {
+  if (!mesh_ptr) {
+    return;
+  }
+  const DracoMesh *const mesh = *mesh_ptr;
+  if (!mesh) {
+    return;
+  }
+  const Mesh *const m = static_cast<const Mesh *>(mesh->private_mesh);
+  delete m;
+  delete mesh;
+  *mesh_ptr = nullptr;
+}
+
+void EXPORT_API ReleaseDracoAttribute(DracoAttribute **attr_ptr) {
+  if (!attr_ptr) {
+    return;
+  }
+  const DracoAttribute *const attr = *attr_ptr;
+  if (!attr) {
+    return;
+  }
+  delete attr;
+  *attr_ptr = nullptr;
+}
+
+void EXPORT_API ReleaseDracoData(DracoData **data_ptr) {
+  if (!data_ptr) {
+    return;
+  }
+  const DracoData *const data = *data_ptr;
+  switch (data->data_type) {
+    case draco::DataType::DT_INT8:
+      delete[] static_cast<int8_t *>(data->data);
+      break;
+    case draco::DataType::DT_UINT8:
+      delete[] static_cast<uint8_t *>(data->data);
+      break;
+    case draco::DataType::DT_INT16:
+      delete[] static_cast<int16_t *>(data->data);
+      break;
+    case draco::DataType::DT_UINT16:
+      delete[] static_cast<uint16_t *>(data->data);
+      break;
+    case draco::DataType::DT_INT32:
+      delete[] static_cast<int32_t *>(data->data);
+      break;
+    case draco::DataType::DT_UINT32:
+      delete[] static_cast<uint32_t *>(data->data);
+      break;
+    case draco::DataType::DT_FLOAT32:
+      delete[] static_cast<float *>(data->data);
+      break;
+    default:
+      break;
+  }
+  delete data;
+  *data_ptr = nullptr;
+}
+
+int EXPORT_API DecodeDracoMesh(char *data, unsigned int length,
+                               DracoMesh **mesh) {
+  if (mesh == nullptr || *mesh != nullptr) {
+    return -1;
+  }
+  draco::DecoderBuffer buffer;
+  buffer.Init(data, length);
+  auto type_statusor = draco::Decoder::GetEncodedGeometryType(&buffer);
+  if (!type_statusor.ok()) {
+    // TODO(draco-eng): Use enum instead.
+    return -2;
+  }
+  const draco::EncodedGeometryType geom_type = type_statusor.value();
+  if (geom_type != draco::TRIANGULAR_MESH) {
+    return -3;
+  }
+
+  draco::Decoder decoder;
+  auto statusor = decoder.DecodeMeshFromBuffer(&buffer);
+  if (!statusor.ok()) {
+    return -4;
+  }
+  std::unique_ptr<draco::Mesh> in_mesh = std::move(statusor).value();
+
+  *mesh = new DracoMesh();
+  DracoMesh *const unity_mesh = *mesh;
+  unity_mesh->num_faces = in_mesh->num_faces();
+  unity_mesh->num_vertices = in_mesh->num_points();
+  unity_mesh->num_attributes = in_mesh->num_attributes();
+  unity_mesh->private_mesh = static_cast<void *>(in_mesh.release());
+
+  return unity_mesh->num_faces;
+}
+
+bool EXPORT_API GetAttribute(const DracoMesh *mesh, int index,
+                             DracoAttribute **attribute) {
+  if (mesh == nullptr || attribute == nullptr || *attribute != nullptr) {
+    return false;
+  }
+  const Mesh *const m = static_cast<const Mesh *>(mesh->private_mesh);
+  const PointAttribute *const attr = m->attribute(index);
+  if (attr == nullptr) {
+    return false;
+  }
+
+  *attribute = CreateDracoAttribute(attr);
+  return true;
+}
+
+bool EXPORT_API GetAttributeByType(const DracoMesh *mesh,
+                                   GeometryAttribute::Type type, int index,
+                                   DracoAttribute **attribute) {
+  if (mesh == nullptr || attribute == nullptr || *attribute != nullptr) {
+    return false;
+  }
+  const Mesh *const m = static_cast<const Mesh *>(mesh->private_mesh);
+  GeometryAttribute::Type att_type = static_cast<GeometryAttribute::Type>(type);
+  const PointAttribute *const attr = m->GetNamedAttribute(att_type, index);
+  if (attr == nullptr) {
+    return false;
+  }
+  *attribute = CreateDracoAttribute(attr);
+  return true;
+}
+
+bool EXPORT_API GetAttributeByUniqueId(const DracoMesh *mesh, int unique_id,
+                                       DracoAttribute **attribute) {
+  if (mesh == nullptr || attribute == nullptr || *attribute != nullptr) {
+    return false;
+  }
+  const Mesh *const m = static_cast<const Mesh *>(mesh->private_mesh);
+  const PointAttribute *const attr = m->GetAttributeByUniqueId(unique_id);
+  if (attr == nullptr) {
+    return false;
+  }
+  *attribute = CreateDracoAttribute(attr);
+  return true;
+}
+
+bool EXPORT_API GetMeshIndices(const DracoMesh *mesh, DracoData **indices) {
+  if (mesh == nullptr || indices == nullptr || *indices != nullptr) {
+    return false;
+  }
+  const Mesh *const m = static_cast<const Mesh *>(mesh->private_mesh);
+  int *const temp_indices = new int[m->num_faces() * 3];
+  for (draco::FaceIndex face_id(0); face_id < m->num_faces(); ++face_id) {
+    const Mesh::Face &face = m->face(draco::FaceIndex(face_id));
+    memcpy(temp_indices + face_id.value() * 3,
+           reinterpret_cast<const int *>(face.data()), sizeof(int) * 3);
+  }
+  DracoData *const draco_data = new DracoData();
+  draco_data->data = temp_indices;
+  draco_data->data_type = DT_INT32;
+  *indices = draco_data;
+  return true;
+}
+
+bool EXPORT_API GetAttributeData(const DracoMesh *mesh,
+                                 const DracoAttribute *attribute,
+                                 DracoData **data) {
+  if (mesh == nullptr || data == nullptr || *data != nullptr) {
+    return false;
+  }
+  const Mesh *const m = static_cast<const Mesh *>(mesh->private_mesh);
+  const PointAttribute *const attr =
+      static_cast<const PointAttribute *>(attribute->private_attribute);
+
+  void *temp_data = ConvertAttributeData(m->num_points(), attr);
+  if (temp_data == nullptr) {
+    return false;
+  }
+  DracoData *const draco_data = new DracoData();
+  draco_data->data = temp_data;
+  draco_data->data_type = static_cast<DataType>(attr->data_type());
+  *data = draco_data;
+  return true;
+}
+
+void ReleaseUnityMesh(DracoToUnityMesh **mesh_ptr) {
+  DracoToUnityMesh *mesh = *mesh_ptr;
+  if (!mesh) {
+    return;
+  }
+  if (mesh->indices) {
+    delete[] mesh->indices;
+    mesh->indices = nullptr;
+  }
+  if (mesh->position) {
+    delete[] mesh->position;
+    mesh->position = nullptr;
+  }
+  if (mesh->has_normal && mesh->normal) {
+    delete[] mesh->normal;
+    mesh->has_normal = false;
+    mesh->normal = nullptr;
+  }
+  if (mesh->has_texcoord && mesh->texcoord) {
+    delete[] mesh->texcoord;
+    mesh->has_texcoord = false;
+    mesh->texcoord = nullptr;
+  }
+  if (mesh->has_color && mesh->color) {
+    delete[] mesh->color;
+    mesh->has_color = false;
+    mesh->color = nullptr;
+  }
+  delete mesh;
+  *mesh_ptr = nullptr;
+}
+
+int DecodeMeshForUnity(char *data, unsigned int length,
+                       DracoToUnityMesh **tmp_mesh) {
+  draco::DecoderBuffer buffer;
+  buffer.Init(data, length);
+  auto type_statusor = draco::Decoder::GetEncodedGeometryType(&buffer);
+  if (!type_statusor.ok()) {
+    // TODO(draco-eng): Use enum instead.
+    return -1;
+  }
+  const draco::EncodedGeometryType geom_type = type_statusor.value();
+  if (geom_type != draco::TRIANGULAR_MESH) {
+    return -2;
+  }
+
+  draco::Decoder decoder;
+  auto statusor = decoder.DecodeMeshFromBuffer(&buffer);
+  if (!statusor.ok()) {
+    return -3;
+  }
+  std::unique_ptr<draco::Mesh> in_mesh = std::move(statusor).value();
+
+  *tmp_mesh = new DracoToUnityMesh();
+  DracoToUnityMesh *unity_mesh = *tmp_mesh;
+  unity_mesh->num_faces = in_mesh->num_faces();
+  unity_mesh->num_vertices = in_mesh->num_points();
+
+  unity_mesh->indices = new int[in_mesh->num_faces() * 3];
+  for (draco::FaceIndex face_id(0); face_id < in_mesh->num_faces(); ++face_id) {
+    const Mesh::Face &face = in_mesh->face(draco::FaceIndex(face_id));
+    memcpy(unity_mesh->indices + face_id.value() * 3,
+           reinterpret_cast<const int *>(face.data()), sizeof(int) * 3);
+  }
+
+  // TODO(draco-eng): Add other attributes.
+  unity_mesh->position = new float[in_mesh->num_points() * 3];
+  const auto pos_att =
+      in_mesh->GetNamedAttribute(draco::GeometryAttribute::POSITION);
+  for (draco::PointIndex i(0); i < in_mesh->num_points(); ++i) {
+    const draco::AttributeValueIndex val_index = pos_att->mapped_index(i);
+    if (!pos_att->ConvertValue<float, 3>(
+            val_index, unity_mesh->position + i.value() * 3)) {
+      ReleaseUnityMesh(&unity_mesh);
+      return -8;
+    }
+  }
+  // Get normal attributes.
+  const auto normal_att =
+      in_mesh->GetNamedAttribute(draco::GeometryAttribute::NORMAL);
+  if (normal_att != nullptr) {
+    unity_mesh->normal = new float[in_mesh->num_points() * 3];
+    unity_mesh->has_normal = true;
+    for (draco::PointIndex i(0); i < in_mesh->num_points(); ++i) {
+      const draco::AttributeValueIndex val_index = normal_att->mapped_index(i);
+      if (!normal_att->ConvertValue<float, 3>(
+              val_index, unity_mesh->normal + i.value() * 3)) {
+        ReleaseUnityMesh(&unity_mesh);
+        return -8;
+      }
+    }
+  }
+  // Get color attributes.
+  const auto color_att =
+      in_mesh->GetNamedAttribute(draco::GeometryAttribute::COLOR);
+  if (color_att != nullptr) {
+    unity_mesh->color = new float[in_mesh->num_points() * 4];
+    unity_mesh->has_color = true;
+    for (draco::PointIndex i(0); i < in_mesh->num_points(); ++i) {
+      const draco::AttributeValueIndex val_index = color_att->mapped_index(i);
+      if (!color_att->ConvertValue<float, 4>(
+              val_index, unity_mesh->color + i.value() * 4)) {
+        ReleaseUnityMesh(&unity_mesh);
+        return -8;
+      }
+      if (color_att->num_components() < 4) {
+        // If the alpha component wasn't set in the input data we should set
+        // it to an opaque value.
+        unity_mesh->color[i.value() * 4 + 3] = 1.f;
+      }
+    }
+  }
+  // Get texture coordinates attributes.
+  const auto texcoord_att =
+      in_mesh->GetNamedAttribute(draco::GeometryAttribute::TEX_COORD);
+  if (texcoord_att != nullptr) {
+    unity_mesh->texcoord = new float[in_mesh->num_points() * 2];
+    unity_mesh->has_texcoord = true;
+    for (draco::PointIndex i(0); i < in_mesh->num_points(); ++i) {
+      const draco::AttributeValueIndex val_index =
+          texcoord_att->mapped_index(i);
+      if (!texcoord_att->ConvertValue<float, 2>(
+              val_index, unity_mesh->texcoord + i.value() * 2)) {
+        ReleaseUnityMesh(&unity_mesh);
+        return -8;
+      }
+    }
+  }
+
+  return in_mesh->num_faces();
+}
+
+}  // namespace draco
+
+#endif  // DRACO_UNITY_PLUGIN
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/unity/draco_unity_plugin.h b/Engine/lib/assimp/contrib/draco/src/draco/unity/draco_unity_plugin.h
new file mode 100644
index 000000000..2f878889b
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/unity/draco_unity_plugin.h
@@ -0,0 +1,154 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_UNITY_DRACO_UNITY_PLUGIN_H_
+#define DRACO_UNITY_DRACO_UNITY_PLUGIN_H_
+
+#include "draco/attributes/geometry_attribute.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/decode.h"
+#include "draco/core/draco_types.h"
+
+#ifdef DRACO_UNITY_PLUGIN
+
+// If compiling with Visual Studio.
+#if defined(_MSC_VER)
+#define EXPORT_API __declspec(dllexport)
+#else
+// Other platforms don't need this.
+#define EXPORT_API
+#endif  // defined(_MSC_VER)
+
+namespace draco {
+
+extern "C" {
+
+// Struct representing Draco attribute data within Unity.
+struct EXPORT_API DracoData {
+  DracoData() : data_type(DT_INVALID), data(nullptr) {}
+
+  DataType data_type;
+  void *data;
+};
+
+// Struct representing a Draco attribute within Unity.
+struct EXPORT_API DracoAttribute {
+  DracoAttribute()
+      : attribute_type(GeometryAttribute::INVALID),
+        data_type(DT_INVALID),
+        num_components(0),
+        unique_id(0),
+        private_attribute(nullptr) {}
+
+  GeometryAttribute::Type attribute_type;
+  DataType data_type;
+  int num_components;
+  int unique_id;
+  const void *private_attribute;
+};
+
+// Struct representing a Draco mesh within Unity.
+struct EXPORT_API DracoMesh {
+  DracoMesh()
+      : num_faces(0),
+        num_vertices(0),
+        num_attributes(0),
+        private_mesh(nullptr) {}
+
+  int num_faces;
+  int num_vertices;
+  int num_attributes;
+  void *private_mesh;
+};
+
+// Release data associated with DracoMesh.
+void EXPORT_API ReleaseDracoMesh(DracoMesh **mesh_ptr);
+// Release data associated with DracoAttribute.
+void EXPORT_API ReleaseDracoAttribute(DracoAttribute **attr_ptr);
+// Release attribute data.
+void EXPORT_API ReleaseDracoData(DracoData **data_ptr);
+
+// Decodes compressed Draco mesh in |data| and returns |mesh|. On input, |mesh|
+// must be null. The returned |mesh| must be released with ReleaseDracoMesh.
+int EXPORT_API DecodeDracoMesh(char *data, unsigned int length,
+                               DracoMesh **mesh);
+
+// Returns |attribute| at |index| in |mesh|.  On input, |attribute| must be
+// null. The returned |attribute| must be released with ReleaseDracoAttribute.
+bool EXPORT_API GetAttribute(const DracoMesh *mesh, int index,
+                             DracoAttribute **attribute);
+// Returns |attribute| of |type| at |index| in |mesh|. E.g. If the mesh has
+// two texture coordinates then GetAttributeByType(mesh,
+// AttributeType.TEX_COORD, 1, &attr); will return the second TEX_COORD
+// attribute. On input, |attribute| must be null. The returned |attribute| must
+// be released with ReleaseDracoAttribute.
+bool EXPORT_API GetAttributeByType(const DracoMesh *mesh,
+                                   GeometryAttribute::Type type, int index,
+                                   DracoAttribute **attribute);
+// Returns |attribute| with |unique_id| in |mesh|. On input, |attribute| must be
+// null. The returned |attribute| must be released with ReleaseDracoAttribute.
+bool EXPORT_API GetAttributeByUniqueId(const DracoMesh *mesh, int unique_id,
+                                       DracoAttribute **attribute);
+// Returns the indices as well as the type of data in |indices|. On input,
+// |indices| must be null. The returned |indices| must be released with
+// ReleaseDracoData.
+bool EXPORT_API GetMeshIndices(const DracoMesh *mesh, DracoData **indices);
+// Returns the attribute data from attribute as well as the type of data in
+// |data|. On input, |data| must be null. The returned |data| must be released
+// with ReleaseDracoData.
+bool EXPORT_API GetAttributeData(const DracoMesh *mesh,
+                                 const DracoAttribute *attribute,
+                                 DracoData **data);
+
+// DracoToUnityMesh is deprecated.
+struct EXPORT_API DracoToUnityMesh {
+  DracoToUnityMesh()
+      : num_faces(0),
+        indices(nullptr),
+        num_vertices(0),
+        position(nullptr),
+        has_normal(false),
+        normal(nullptr),
+        has_texcoord(false),
+        texcoord(nullptr),
+        has_color(false),
+        color(nullptr) {}
+
+  int num_faces;
+  int *indices;
+  int num_vertices;
+  float *position;
+  bool has_normal;
+  float *normal;
+  bool has_texcoord;
+  float *texcoord;
+  bool has_color;
+  float *color;
+};
+
+// ReleaseUnityMesh is deprecated.
+void EXPORT_API ReleaseUnityMesh(DracoToUnityMesh **mesh_ptr);
+
+// To use this function, you do not allocate memory for |tmp_mesh|, just
+// define and pass a null pointer. Otherwise there will be memory leak.
+// DecodeMeshForUnity is deprecated.
+int EXPORT_API DecodeMeshForUnity(char *data, unsigned int length,
+                                  DracoToUnityMesh **tmp_mesh);
+}  // extern "C"
+
+}  // namespace draco
+
+#endif  // DRACO_UNITY_PLUGIN
+
+#endif  // DRACO_UNITY_DRACO_UNITY_PLUGIN_H_
diff --git a/Engine/lib/assimp/contrib/draco/src/draco/unity/draco_unity_plugin_test.cc b/Engine/lib/assimp/contrib/draco/src/draco/unity/draco_unity_plugin_test.cc
new file mode 100644
index 000000000..81be7ee57
--- /dev/null
+++ b/Engine/lib/assimp/contrib/draco/src/draco/unity/draco_unity_plugin_test.cc
@@ -0,0 +1,243 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/unity/draco_unity_plugin.h"
+
+#include <fstream>
+#include <memory>
+#include <sstream>
+#include <string>
+
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+
+namespace {
+
+draco::DracoMesh *DecodeToDracoMesh(const std::string &file_name) {
+  std::ifstream input_file(draco::GetTestFileFullPath(file_name),
+                           std::ios::binary);
+  if (!input_file) {
+    return nullptr;
+  }
+  // Read the file stream into a buffer.
+  std::streampos file_size = 0;
+  input_file.seekg(0, std::ios::end);
+  file_size = input_file.tellg() - file_size;
+  input_file.seekg(0, std::ios::beg);
+  std::vector<char> data(file_size);
+  input_file.read(data.data(), file_size);
+  if (data.empty()) {
+    return nullptr;
+  }
+
+  draco::DracoMesh *draco_mesh = nullptr;
+  draco::DecodeDracoMesh(data.data(), data.size(), &draco_mesh);
+  return draco_mesh;
+}
+
+TEST(DracoUnityPluginTest, TestDecode) {
+  draco::DracoMesh *draco_mesh =
+      DecodeToDracoMesh("test_nm.obj.edgebreaker.cl4.2.2.drc");
+  ASSERT_NE(draco_mesh, nullptr);
+  ASSERT_EQ(draco_mesh->num_faces, 170);
+  ASSERT_EQ(draco_mesh->num_vertices, 99);
+  ASSERT_NE(draco_mesh->private_mesh, nullptr);
+
+  draco::DracoData *indices = nullptr;
+  ASSERT_TRUE(GetMeshIndices(draco_mesh, &indices));
+  ASSERT_EQ(indices->data_type, draco::DT_INT32);
+  draco::ReleaseDracoData(&indices);
+
+  for (int i = 0; i < draco_mesh->num_attributes; ++i) {
+    draco::DracoAttribute *draco_attribute = nullptr;
+    ASSERT_TRUE(draco::GetAttribute(draco_mesh, i, &draco_attribute));
+    ASSERT_NE(draco_attribute->data_type, draco::DT_INVALID);
+    ASSERT_GT(draco_attribute->num_components, 0);
+    ASSERT_NE(draco_attribute->private_attribute, nullptr);
+
+    draco::DracoData *attribute_data = nullptr;
+    ASSERT_TRUE(
+        draco::GetAttributeData(draco_mesh, draco_attribute, &attribute_data));
+    draco::ReleaseDracoData(&attribute_data);
+    draco::ReleaseDracoAttribute(&draco_attribute);
+  }
+  draco::ReleaseDracoMesh(&draco_mesh);
+}
+
+TEST(DracoUnityPluginTest, TestAttributeTypes) {
+  draco::DracoMesh *draco_mesh = DecodeToDracoMesh("color_attr.drc");
+  ASSERT_NE(draco_mesh, nullptr);
+
+  draco::DracoAttribute *pos_attribute = nullptr;
+  ASSERT_TRUE(draco::GetAttributeByType(
+      draco_mesh, draco::GeometryAttribute::POSITION, 0, &pos_attribute));
+  ASSERT_EQ(pos_attribute->attribute_type, draco::GeometryAttribute::POSITION);
+  ASSERT_EQ(pos_attribute->data_type, draco::DT_FLOAT32);
+  ASSERT_EQ(pos_attribute->num_components, 3);
+  ASSERT_EQ(pos_attribute->unique_id, 0);
+  ASSERT_NE(pos_attribute->private_attribute, nullptr);
+  draco::ReleaseDracoAttribute(&pos_attribute);
+
+  draco::DracoAttribute *color_attribute = nullptr;
+  ASSERT_TRUE(draco::GetAttributeByType(
+      draco_mesh, draco::GeometryAttribute::COLOR, 0, &color_attribute));
+  ASSERT_EQ(color_attribute->attribute_type, draco::GeometryAttribute::COLOR);
+  ASSERT_EQ(color_attribute->data_type, draco::DT_UINT8);
+  ASSERT_EQ(color_attribute->num_components, 4);
+  ASSERT_EQ(color_attribute->unique_id, 1);
+  ASSERT_NE(color_attribute->private_attribute, nullptr);
+  draco::ReleaseDracoAttribute(&color_attribute);
+
+  draco::DracoAttribute *bad_attribute = nullptr;
+  ASSERT_FALSE(draco::GetAttributeByType(
+      draco_mesh, draco::GeometryAttribute::NORMAL, 0, &bad_attribute));
+  ASSERT_FALSE(draco::GetAttributeByType(
+      draco_mesh, draco::GeometryAttribute::TEX_COORD, 0, &bad_attribute));
+  ASSERT_FALSE(draco::GetAttributeByType(
+      draco_mesh, draco::GeometryAttribute::GENERIC, 0, &bad_attribute));
+
+  draco::ReleaseDracoMesh(&draco_mesh);
+
+  draco_mesh = DecodeToDracoMesh("cube_att_sub_o_2.drc");
+  ASSERT_NE(draco_mesh, nullptr);
+
+  draco::DracoAttribute *norm_attribute = nullptr;
+  ASSERT_TRUE(draco::GetAttributeByType(
+      draco_mesh, draco::GeometryAttribute::NORMAL, 0, &norm_attribute));
+  ASSERT_EQ(norm_attribute->attribute_type, draco::GeometryAttribute::NORMAL);
+  ASSERT_EQ(norm_attribute->data_type, draco::DT_FLOAT32);
+  ASSERT_EQ(norm_attribute->num_components, 3);
+  ASSERT_EQ(norm_attribute->unique_id, 2);
+  ASSERT_NE(norm_attribute->private_attribute, nullptr);
+  draco::ReleaseDracoAttribute(&norm_attribute);
+
+  draco::DracoAttribute *texcoord_attribute = nullptr;
+  ASSERT_TRUE(draco::GetAttributeByType(
+      draco_mesh, draco::GeometryAttribute::TEX_COORD, 0, &texcoord_attribute));
+  ASSERT_EQ(texcoord_attribute->attribute_type,
+            draco::GeometryAttribute::TEX_COORD);
+  ASSERT_EQ(texcoord_attribute->data_type, draco::DT_FLOAT32);
+  ASSERT_EQ(texcoord_attribute->num_components, 2);
+  ASSERT_EQ(texcoord_attribute->unique_id, 1);
+  ASSERT_NE(texcoord_attribute->private_attribute, nullptr);
+  draco::ReleaseDracoAttribute(&texcoord_attribute);
+
+  draco::DracoAttribute *generic_attribute = nullptr;
+  ASSERT_TRUE(draco::GetAttributeByType(
+      draco_mesh, draco::GeometryAttribute::GENERIC, 0, &generic_attribute));
+  ASSERT_EQ(generic_attribute->attribute_type,
+            draco::GeometryAttribute::GENERIC);
+  ASSERT_EQ(generic_attribute->data_type, draco::DT_UINT8);
+  ASSERT_EQ(generic_attribute->num_components, 1);
+  ASSERT_EQ(generic_attribute->unique_id, 3);
+  ASSERT_NE(generic_attribute->private_attribute, nullptr);
+  draco::ReleaseDracoAttribute(&generic_attribute);
+
+  ASSERT_FALSE(draco::GetAttributeByType(
+      draco_mesh, draco::GeometryAttribute::TEX_COORD, 1, &bad_attribute));
+
+  draco::ReleaseDracoMesh(&draco_mesh);
+}
+
+TEST(DracoUnityPluginTest, TestAttributeUniqueId) {
+  draco::DracoMesh *draco_mesh = DecodeToDracoMesh("cube_att_sub_o_2.drc");
+  ASSERT_NE(draco_mesh, nullptr);
+
+  draco::DracoAttribute *pos_attribute = nullptr;
+  ASSERT_TRUE(draco::GetAttributeByUniqueId(draco_mesh, 0, &pos_attribute));
+  ASSERT_EQ(pos_attribute->attribute_type, draco::GeometryAttribute::POSITION);
+  ASSERT_EQ(pos_attribute->data_type, draco::DT_FLOAT32);
+  ASSERT_EQ(pos_attribute->num_components, 3);
+  ASSERT_EQ(pos_attribute->unique_id, 0);
+  ASSERT_NE(pos_attribute->private_attribute, nullptr);
+  draco::ReleaseDracoAttribute(&pos_attribute);
+
+  draco::DracoAttribute *norm_attribute = nullptr;
+  ASSERT_TRUE(draco::GetAttributeByUniqueId(draco_mesh, 2, &norm_attribute));
+  ASSERT_EQ(norm_attribute->attribute_type, draco::GeometryAttribute::NORMAL);
+  ASSERT_EQ(norm_attribute->data_type, draco::DT_FLOAT32);
+  ASSERT_EQ(norm_attribute->num_components, 3);
+  ASSERT_EQ(norm_attribute->unique_id, 2);
+  ASSERT_NE(norm_attribute->private_attribute, nullptr);
+  draco::ReleaseDracoAttribute(&norm_attribute);
+
+  draco::DracoAttribute *texcoord_attribute = nullptr;
+  ASSERT_TRUE(
+      draco::GetAttributeByUniqueId(draco_mesh, 1, &texcoord_attribute));
+  ASSERT_EQ(texcoord_attribute->attribute_type,
+            draco::GeometryAttribute::TEX_COORD);
+  ASSERT_EQ(texcoord_attribute->data_type, draco::DT_FLOAT32);
+  ASSERT_EQ(texcoord_attribute->num_components, 2);
+  ASSERT_EQ(texcoord_attribute->unique_id, 1);
+  ASSERT_NE(texcoord_attribute->private_attribute, nullptr);
+  draco::ReleaseDracoAttribute(&texcoord_attribute);
+
+  draco::DracoAttribute *generic_attribute = nullptr;
+  ASSERT_TRUE(draco::GetAttributeByUniqueId(draco_mesh, 3, &generic_attribute));
+  ASSERT_EQ(generic_attribute->attribute_type,
+            draco::GeometryAttribute::GENERIC);
+  ASSERT_EQ(generic_attribute->data_type, draco::DT_UINT8);
+  ASSERT_EQ(generic_attribute->num_components, 1);
+  ASSERT_EQ(generic_attribute->unique_id, 3);
+  ASSERT_NE(generic_attribute->private_attribute, nullptr);
+  draco::ReleaseDracoAttribute(&generic_attribute);
+
+  draco::DracoAttribute *bad_attribute = nullptr;
+  ASSERT_FALSE(draco::GetAttributeByUniqueId(draco_mesh, 4, &bad_attribute));
+
+  draco::ReleaseDracoMesh(&draco_mesh);
+}
+
+class DeprecatedDracoUnityPluginTest : public ::testing::Test {
+ protected:
+  DeprecatedDracoUnityPluginTest() : unity_mesh_(nullptr) {}
+
+  void TestDecodingToDracoUnityMesh(const std::string &file_name,
+                                    int expected_num_faces,
+                                    int expected_num_vertices) {
+    // Tests that decoders can successfully skip attribute transform.
+    std::ifstream input_file(draco::GetTestFileFullPath(file_name),
+                             std::ios::binary);
+    ASSERT_TRUE(input_file);
+
+    // Read the file stream into a buffer.
+    std::streampos file_size = 0;
+    input_file.seekg(0, std::ios::end);
+    file_size = input_file.tellg() - file_size;
+    input_file.seekg(0, std::ios::beg);
+    std::vector<char> data(file_size);
+    input_file.read(data.data(), file_size);
+
+    ASSERT_FALSE(data.empty());
+
+    const int num_faces =
+        draco::DecodeMeshForUnity(data.data(), data.size(), &unity_mesh_);
+
+    ASSERT_EQ(num_faces, expected_num_faces);
+    ASSERT_EQ(unity_mesh_->num_faces, expected_num_faces);
+    ASSERT_EQ(unity_mesh_->num_vertices, expected_num_vertices);
+    ASSERT_TRUE(unity_mesh_->has_normal);
+    ASSERT_NE(unity_mesh_->normal, nullptr);
+    // TODO(fgalligan): Also test color and tex_coord attributes.
+
+    draco::ReleaseUnityMesh(&unity_mesh_);
+  }
+
+  draco::DracoToUnityMesh *unity_mesh_;
+};
+
+TEST_F(DeprecatedDracoUnityPluginTest, DeprecatedDecodingToDracoUnityMesh) {
+  TestDecodingToDracoUnityMesh("test_nm.obj.edgebreaker.1.0.0.drc", 170, 99);
+}
+}  // namespace
diff --git a/Engine/lib/assimp/contrib/gtest/CMakeLists.txt b/Engine/lib/assimp/contrib/gtest/CMakeLists.txt
index 621d0f042..1d8362797 100644
--- a/Engine/lib/assimp/contrib/gtest/CMakeLists.txt
+++ b/Engine/lib/assimp/contrib/gtest/CMakeLists.txt
@@ -45,7 +45,7 @@ endif()
 # ${gtest_BINARY_DIR}.
 # Language "C" is required for find_package(Threads).
 project(gtest CXX C)
-cmake_minimum_required(VERSION 2.6.2)
+cmake_minimum_required(VERSION 3.10)
 
 if (COMMAND set_up_hermetic_build)
   set_up_hermetic_build()
diff --git a/Engine/lib/assimp/contrib/gtest/docs/Documentation.md b/Engine/lib/assimp/contrib/gtest/docs/Documentation.md
index 8ca1aac75..e5d041f3a 100644
--- a/Engine/lib/assimp/contrib/gtest/docs/Documentation.md
+++ b/Engine/lib/assimp/contrib/gtest/docs/Documentation.md
@@ -11,4 +11,4 @@ documentation for that specific version instead.**
 To contribute code to Google Test, read:
 
   * [DevGuide](DevGuide.md) -- read this _before_ writing your first patch.
-  * [PumpManual](PumpManual.md) -- how we generate some of Google Test's source files.
\ No newline at end of file
+  * [PumpManual](PumpManual.md) -- how we generate some of Google Test's source files.
diff --git a/Engine/lib/assimp/contrib/gtest/docs/V1_5_Documentation.md b/Engine/lib/assimp/contrib/gtest/docs/V1_5_Documentation.md
index 46bba2ec8..6febc65c9 100644
--- a/Engine/lib/assimp/contrib/gtest/docs/V1_5_Documentation.md
+++ b/Engine/lib/assimp/contrib/gtest/docs/V1_5_Documentation.md
@@ -9,4 +9,4 @@ This page lists all official documentation wiki pages for Google Test **1.5.0**
 To contribute code to Google Test, read:
 
   * DevGuide -- read this _before_ writing your first patch.
-  * [PumpManual](V1_5_PumpManual.md) -- how we generate some of Google Test's source files.
\ No newline at end of file
+  * [PumpManual](V1_5_PumpManual.md) -- how we generate some of Google Test's source files.
diff --git a/Engine/lib/assimp/contrib/gtest/docs/V1_5_PumpManual.md b/Engine/lib/assimp/contrib/gtest/docs/V1_5_PumpManual.md
index 15710789d..e6485a01d 100644
--- a/Engine/lib/assimp/contrib/gtest/docs/V1_5_PumpManual.md
+++ b/Engine/lib/assimp/contrib/gtest/docs/V1_5_PumpManual.md
@@ -174,4 +174,4 @@ You can find real-world applications of Pump in [Google Test](http://www.google.
 ## Tips ##
 
   * If a meta variable is followed by a letter or digit, you can separate them using `[[]]`, which inserts an empty string. For example `Foo$j[[]]Helper` generate `Foo1Helper` when `j` is 1.
-  * To avoid extra-long Pump source lines, you can break a line anywhere you want by inserting `[[]]` followed by a new line. Since any new-line character next to `[[` or `]]` is ignored, the generated code won't contain this new line.
\ No newline at end of file
+  * To avoid extra-long Pump source lines, you can break a line anywhere you want by inserting `[[]]` followed by a new line. Since any new-line character next to `[[` or `]]` is ignored, the generated code won't contain this new line.
diff --git a/Engine/lib/assimp/contrib/gtest/docs/V1_5_XcodeGuide.md b/Engine/lib/assimp/contrib/gtest/docs/V1_5_XcodeGuide.md
index bf24bf51b..21d7f5c05 100644
--- a/Engine/lib/assimp/contrib/gtest/docs/V1_5_XcodeGuide.md
+++ b/Engine/lib/assimp/contrib/gtest/docs/V1_5_XcodeGuide.md
@@ -90,4 +90,4 @@ The Debugger has exited with status 0.
 
 # Summary #
 
-Unit testing is a valuable way to ensure your data model stays valid even during rapid development or refactoring. The Google Testing Framework is a great unit testing framework for C and C++ which integrates well with an Xcode development environment.
\ No newline at end of file
+Unit testing is a valuable way to ensure your data model stays valid even during rapid development or refactoring. The Google Testing Framework is a great unit testing framework for C and C++ which integrates well with an Xcode development environment.
diff --git a/Engine/lib/assimp/contrib/gtest/docs/V1_6_Documentation.md b/Engine/lib/assimp/contrib/gtest/docs/V1_6_Documentation.md
index ca924660a..1085673d1 100644
--- a/Engine/lib/assimp/contrib/gtest/docs/V1_6_Documentation.md
+++ b/Engine/lib/assimp/contrib/gtest/docs/V1_6_Documentation.md
@@ -11,4 +11,4 @@ documentation for that specific version instead.**
 To contribute code to Google Test, read:
 
   * [DevGuide](DevGuide.md) -- read this _before_ writing your first patch.
-  * [PumpManual](V1_6_PumpManual.md) -- how we generate some of Google Test's source files.
\ No newline at end of file
+  * [PumpManual](V1_6_PumpManual.md) -- how we generate some of Google Test's source files.
diff --git a/Engine/lib/assimp/contrib/gtest/docs/V1_6_XcodeGuide.md b/Engine/lib/assimp/contrib/gtest/docs/V1_6_XcodeGuide.md
index bf24bf51b..21d7f5c05 100644
--- a/Engine/lib/assimp/contrib/gtest/docs/V1_6_XcodeGuide.md
+++ b/Engine/lib/assimp/contrib/gtest/docs/V1_6_XcodeGuide.md
@@ -90,4 +90,4 @@ The Debugger has exited with status 0.
 
 # Summary #
 
-Unit testing is a valuable way to ensure your data model stays valid even during rapid development or refactoring. The Google Testing Framework is a great unit testing framework for C and C++ which integrates well with an Xcode development environment.
\ No newline at end of file
+Unit testing is a valuable way to ensure your data model stays valid even during rapid development or refactoring. The Google Testing Framework is a great unit testing framework for C and C++ which integrates well with an Xcode development environment.
diff --git a/Engine/lib/assimp/contrib/gtest/docs/V1_7_Documentation.md b/Engine/lib/assimp/contrib/gtest/docs/V1_7_Documentation.md
index 282697a50..6dc7d05b4 100644
--- a/Engine/lib/assimp/contrib/gtest/docs/V1_7_Documentation.md
+++ b/Engine/lib/assimp/contrib/gtest/docs/V1_7_Documentation.md
@@ -11,4 +11,4 @@ documentation for that specific version instead.**
 To contribute code to Google Test, read:
 
   * [DevGuide](DevGuide.md) -- read this _before_ writing your first patch.
-  * [PumpManual](V1_7_PumpManual.md) -- how we generate some of Google Test's source files.
\ No newline at end of file
+  * [PumpManual](V1_7_PumpManual.md) -- how we generate some of Google Test's source files.
diff --git a/Engine/lib/assimp/contrib/gtest/docs/V1_7_XcodeGuide.md b/Engine/lib/assimp/contrib/gtest/docs/V1_7_XcodeGuide.md
index bf24bf51b..21d7f5c05 100644
--- a/Engine/lib/assimp/contrib/gtest/docs/V1_7_XcodeGuide.md
+++ b/Engine/lib/assimp/contrib/gtest/docs/V1_7_XcodeGuide.md
@@ -90,4 +90,4 @@ The Debugger has exited with status 0.
 
 # Summary #
 
-Unit testing is a valuable way to ensure your data model stays valid even during rapid development or refactoring. The Google Testing Framework is a great unit testing framework for C and C++ which integrates well with an Xcode development environment.
\ No newline at end of file
+Unit testing is a valuable way to ensure your data model stays valid even during rapid development or refactoring. The Google Testing Framework is a great unit testing framework for C and C++ which integrates well with an Xcode development environment.
diff --git a/Engine/lib/assimp/contrib/gtest/docs/XcodeGuide.md b/Engine/lib/assimp/contrib/gtest/docs/XcodeGuide.md
index bf24bf51b..21d7f5c05 100644
--- a/Engine/lib/assimp/contrib/gtest/docs/XcodeGuide.md
+++ b/Engine/lib/assimp/contrib/gtest/docs/XcodeGuide.md
@@ -90,4 +90,4 @@ The Debugger has exited with status 0.
 
 # Summary #
 
-Unit testing is a valuable way to ensure your data model stays valid even during rapid development or refactoring. The Google Testing Framework is a great unit testing framework for C and C++ which integrates well with an Xcode development environment.
\ No newline at end of file
+Unit testing is a valuable way to ensure your data model stays valid even during rapid development or refactoring. The Google Testing Framework is a great unit testing framework for C and C++ which integrates well with an Xcode development environment.
diff --git a/Engine/lib/assimp/contrib/gtest/include/gtest/internal/gtest-internal.h b/Engine/lib/assimp/contrib/gtest/include/gtest/internal/gtest-internal.h
index ebd1cf615..e66c74841 100644
--- a/Engine/lib/assimp/contrib/gtest/include/gtest/internal/gtest-internal.h
+++ b/Engine/lib/assimp/contrib/gtest/include/gtest/internal/gtest-internal.h
@@ -1,4 +1,4 @@
-// Copyright 2005, Google Inc.
+// Copyright 2005, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
diff --git a/Engine/lib/assimp/contrib/gtest/include/gtest/internal/gtest-param-util.h b/Engine/lib/assimp/contrib/gtest/include/gtest/internal/gtest-param-util.h
index 82cab9b02..9d725a433 100644
--- a/Engine/lib/assimp/contrib/gtest/include/gtest/internal/gtest-param-util.h
+++ b/Engine/lib/assimp/contrib/gtest/include/gtest/internal/gtest-param-util.h
@@ -644,7 +644,7 @@ class ParameterizedTestCaseInfo : public ParameterizedTestCaseInfoBase {
 
     // Check for invalid characters
     for (std::string::size_type index = 0; index < name.size(); ++index) {
-      if (!isalnum(name[index]) && name[index] != '_')
+      if (!IsAlNum(name[index]) && name[index] != '_')
         return false;
     }
 
diff --git a/Engine/lib/assimp/contrib/gtest/include/gtest/internal/gtest-port.h b/Engine/lib/assimp/contrib/gtest/include/gtest/internal/gtest-port.h
index 0094ed507..f66d9cd32 100644
--- a/Engine/lib/assimp/contrib/gtest/include/gtest/internal/gtest-port.h
+++ b/Engine/lib/assimp/contrib/gtest/include/gtest/internal/gtest-port.h
@@ -312,10 +312,22 @@
     __pragma(warning(disable: warnings))
 # define GTEST_DISABLE_MSC_WARNINGS_POP_()          \
     __pragma(warning(pop))
+# if defined(__clang__)
+#  define GTEST_DISABLE_CLANG_DEPRECATED_WARNINGS_PUSH_() \
+      _Pragma("clang diagnostic push") \
+      _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
+#  define GTEST_DISABLE_CLANG_WARNINGS_POP_() \
+      _Pragma("clang diagnostic pop")
+# else
+#  define GTEST_DISABLE_CLANG_DEPRECATED_WARNINGS_PUSH_()
+#  define GTEST_DISABLE_CLANG_WARNINGS_POP_()
+# endif
 #else
 // Older versions of MSVC don't have __pragma.
 # define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings)
 # define GTEST_DISABLE_MSC_WARNINGS_POP_()
+# define GTEST_DISABLE_CLANG_DEPRECATED_WARNINGS_PUSH_()
+# define GTEST_DISABLE_CLANG_WARNINGS_POP_()
 #endif
 
 #ifndef GTEST_LANG_CXX11
@@ -2352,6 +2364,7 @@ inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
 // Functions deprecated by MSVC 8.0.
 
 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996 /* deprecated function */)
+GTEST_DISABLE_CLANG_DEPRECATED_WARNINGS_PUSH_()
 
 inline const char* StrNCpy(char* dest, const char* src, size_t n) {
   return strncpy(dest, src, n);
@@ -2399,6 +2412,7 @@ inline const char* GetEnv(const char* name) {
 #endif
 }
 
+GTEST_DISABLE_CLANG_WARNINGS_POP_()
 GTEST_DISABLE_MSC_WARNINGS_POP_()
 
 #if GTEST_OS_WINDOWS_MOBILE
diff --git a/Engine/lib/assimp/contrib/gtest/src/gtest-port.cc b/Engine/lib/assimp/contrib/gtest/src/gtest-port.cc
index e5bf3dd2b..e04aa9a57 100644
--- a/Engine/lib/assimp/contrib/gtest/src/gtest-port.cc
+++ b/Engine/lib/assimp/contrib/gtest/src/gtest-port.cc
@@ -926,7 +926,7 @@ GTestLog::~GTestLog() {
 // Disable Microsoft deprecation warnings for POSIX functions called from
 // this class (creat, dup, dup2, and close)
 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996)
-
+GTEST_DISABLE_CLANG_DEPRECATED_WARNINGS_PUSH_()
 #if GTEST_HAS_STREAM_REDIRECTION
 
 // Object that captures an output stream (stdout/stderr).
@@ -1010,6 +1010,7 @@ class CapturedStream {
 };
 
 GTEST_DISABLE_MSC_WARNINGS_POP_()
+GTEST_DISABLE_CLANG_WARNINGS_POP_()
 
 static CapturedStream* g_captured_stderr = NULL;
 static CapturedStream* g_captured_stdout = NULL;
diff --git a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/CMakeDirectoryInformation.cmake b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/CMakeDirectoryInformation.cmake
deleted file mode 100644
index 0deaa3cb5..000000000
--- a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/CMakeDirectoryInformation.cmake
+++ /dev/null
@@ -1,16 +0,0 @@
-# CMAKE generated file: DO NOT EDIT!
-# Generated by "Unix Makefiles" Generator, CMake Version 3.21
-
-# Relative path conversion top directories.
-set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/home/ragora/Downloads/assimp-5.0.1")
-set(CMAKE_RELATIVE_PATH_TOP_BINARY "/home/ragora/Downloads/assimp-5.0.1")
-
-# Force unix paths in dependencies.
-set(CMAKE_FORCE_UNIX_PATHS 1)
-
-
-# The C and CXX include file regular expressions for this directory.
-set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$")
-set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$")
-set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})
-set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN})
diff --git a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/DependInfo.cmake b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/DependInfo.cmake
deleted file mode 100644
index 7960f10e0..000000000
--- a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/DependInfo.cmake
+++ /dev/null
@@ -1,19 +0,0 @@
-
-# Consider dependencies only in project.
-set(CMAKE_DEPENDS_IN_PROJECT_ONLY OFF)
-
-# The set of languages for which implicit dependencies are needed:
-set(CMAKE_DEPENDS_LANGUAGES
-  )
-
-# The set of dependency files which are needed:
-set(CMAKE_DEPENDS_DEPENDENCY_FILES
-  "/home/ragora/Downloads/assimp-5.0.1/contrib/irrXML/irrXML.cpp" "contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o" "gcc" "contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o.d"
-  )
-
-# Targets to which this target links.
-set(CMAKE_TARGET_LINKED_INFO_FILES
-  )
-
-# Fortran module output directory.
-set(CMAKE_Fortran_TARGET_MODULE_DIR "")
diff --git a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/build.make b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/build.make
deleted file mode 100644
index 767bf6bb8..000000000
--- a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/build.make
+++ /dev/null
@@ -1,111 +0,0 @@
-# CMAKE generated file: DO NOT EDIT!
-# Generated by "Unix Makefiles" Generator, CMake Version 3.21
-
-# Delete rule output on recipe failure.
-.DELETE_ON_ERROR:
-
-#=============================================================================
-# Special targets provided by cmake.
-
-# Disable implicit rules so canonical targets will work.
-.SUFFIXES:
-
-# Disable VCS-based implicit rules.
-% : %,v
-
-# Disable VCS-based implicit rules.
-% : RCS/%
-
-# Disable VCS-based implicit rules.
-% : RCS/%,v
-
-# Disable VCS-based implicit rules.
-% : SCCS/s.%
-
-# Disable VCS-based implicit rules.
-% : s.%
-
-.SUFFIXES: .hpux_make_needs_suffix_list
-
-# Command-line flag to silence nested $(MAKE).
-$(VERBOSE)MAKESILENT = -s
-
-#Suppress display of executed commands.
-$(VERBOSE).SILENT:
-
-# A target that is always out of date.
-cmake_force:
-.PHONY : cmake_force
-
-#=============================================================================
-# Set environment variables for the build.
-
-# The shell in which to execute make rules.
-SHELL = /bin/sh
-
-# The CMake executable.
-CMAKE_COMMAND = /usr/bin/cmake
-
-# The command to remove a file.
-RM = /usr/bin/cmake -E rm -f
-
-# Escaping for special characters.
-EQUALS = =
-
-# The top-level source directory on which CMake was run.
-CMAKE_SOURCE_DIR = /home/ragora/Downloads/assimp-5.0.1
-
-# The top-level build directory on which CMake was run.
-CMAKE_BINARY_DIR = /home/ragora/Downloads/assimp-5.0.1
-
-# Include any dependencies generated for this target.
-include contrib/irrXML/CMakeFiles/IrrXML.dir/depend.make
-# Include any dependencies generated by the compiler for this target.
-include contrib/irrXML/CMakeFiles/IrrXML.dir/compiler_depend.make
-
-# Include the progress variables for this target.
-include contrib/irrXML/CMakeFiles/IrrXML.dir/progress.make
-
-# Include the compile flags for this target's objects.
-include contrib/irrXML/CMakeFiles/IrrXML.dir/flags.make
-
-contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o: contrib/irrXML/CMakeFiles/IrrXML.dir/flags.make
-contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o: contrib/irrXML/irrXML.cpp
-contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o: contrib/irrXML/CMakeFiles/IrrXML.dir/compiler_depend.ts
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/ragora/Downloads/assimp-5.0.1/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o"
-	cd /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o -MF CMakeFiles/IrrXML.dir/irrXML.cpp.o.d -o CMakeFiles/IrrXML.dir/irrXML.cpp.o -c /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML/irrXML.cpp
-
-contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.i: cmake_force
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/IrrXML.dir/irrXML.cpp.i"
-	cd /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML/irrXML.cpp > CMakeFiles/IrrXML.dir/irrXML.cpp.i
-
-contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.s: cmake_force
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/IrrXML.dir/irrXML.cpp.s"
-	cd /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML/irrXML.cpp -o CMakeFiles/IrrXML.dir/irrXML.cpp.s
-
-# Object files for target IrrXML
-IrrXML_OBJECTS = \
-"CMakeFiles/IrrXML.dir/irrXML.cpp.o"
-
-# External object files for target IrrXML
-IrrXML_EXTERNAL_OBJECTS =
-
-lib/libIrrXML.a: contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o
-lib/libIrrXML.a: contrib/irrXML/CMakeFiles/IrrXML.dir/build.make
-lib/libIrrXML.a: contrib/irrXML/CMakeFiles/IrrXML.dir/link.txt
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/ragora/Downloads/assimp-5.0.1/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Linking CXX static library ../../lib/libIrrXML.a"
-	cd /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML && $(CMAKE_COMMAND) -P CMakeFiles/IrrXML.dir/cmake_clean_target.cmake
-	cd /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML && $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/IrrXML.dir/link.txt --verbose=$(VERBOSE)
-
-# Rule to build all files generated by this target.
-contrib/irrXML/CMakeFiles/IrrXML.dir/build: lib/libIrrXML.a
-.PHONY : contrib/irrXML/CMakeFiles/IrrXML.dir/build
-
-contrib/irrXML/CMakeFiles/IrrXML.dir/clean:
-	cd /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML && $(CMAKE_COMMAND) -P CMakeFiles/IrrXML.dir/cmake_clean.cmake
-.PHONY : contrib/irrXML/CMakeFiles/IrrXML.dir/clean
-
-contrib/irrXML/CMakeFiles/IrrXML.dir/depend:
-	cd /home/ragora/Downloads/assimp-5.0.1 && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/ragora/Downloads/assimp-5.0.1 /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML /home/ragora/Downloads/assimp-5.0.1 /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML/CMakeFiles/IrrXML.dir/DependInfo.cmake --color=$(COLOR)
-.PHONY : contrib/irrXML/CMakeFiles/IrrXML.dir/depend
-
diff --git a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/cmake_clean.cmake b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/cmake_clean.cmake
deleted file mode 100644
index 488785da7..000000000
--- a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/cmake_clean.cmake
+++ /dev/null
@@ -1,11 +0,0 @@
-file(REMOVE_RECURSE
-  "../../lib/libIrrXML.a"
-  "../../lib/libIrrXML.pdb"
-  "CMakeFiles/IrrXML.dir/irrXML.cpp.o"
-  "CMakeFiles/IrrXML.dir/irrXML.cpp.o.d"
-)
-
-# Per-language clean rules from dependency scanning.
-foreach(lang CXX)
-  include(CMakeFiles/IrrXML.dir/cmake_clean_${lang}.cmake OPTIONAL)
-endforeach()
diff --git a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/cmake_clean_target.cmake b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/cmake_clean_target.cmake
deleted file mode 100644
index e6a95a903..000000000
--- a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/cmake_clean_target.cmake
+++ /dev/null
@@ -1,3 +0,0 @@
-file(REMOVE_RECURSE
-  "../../lib/libIrrXML.a"
-)
diff --git a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/compiler_depend.make b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/compiler_depend.make
deleted file mode 100644
index 490d7fce8..000000000
--- a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/compiler_depend.make
+++ /dev/null
@@ -1,2 +0,0 @@
-# Empty compiler generated dependencies file for IrrXML.
-# This may be replaced when dependencies are built.
diff --git a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/compiler_depend.ts b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/compiler_depend.ts
deleted file mode 100644
index b57672af1..000000000
--- a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/compiler_depend.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-# CMAKE generated file: DO NOT EDIT!
-# Timestamp file for compiler generated dependencies management for IrrXML.
diff --git a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/depend.make b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/depend.make
deleted file mode 100644
index f8c27ad70..000000000
--- a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/depend.make
+++ /dev/null
@@ -1,2 +0,0 @@
-# Empty dependencies file for IrrXML.
-# This may be replaced when dependencies are built.
diff --git a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/flags.make b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/flags.make
deleted file mode 100644
index f012a643f..000000000
--- a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/flags.make
+++ /dev/null
@@ -1,10 +0,0 @@
-# CMAKE generated file: DO NOT EDIT!
-# Generated by "Unix Makefiles" Generator, CMake Version 3.21
-
-# compile CXX with /usr/bin/c++
-CXX_DEFINES = -DASSIMP_BUILD_NO_C4D_IMPORTER -DASSIMP_BUILD_NO_OWN_ZLIB
-
-CXX_INCLUDES = -I/home/ragora/Downloads/assimp-5.0.1/include -I/home/ragora/Downloads/assimp-5.0.1 -I/home/ragora/Downloads/assimp-5.0.1/code -I/home/ragora/Downloads/assimp-5.0.1/.
-
-CXX_FLAGS = -g -fvisibility=hidden -fno-strict-aliasing -Wall -fPIC -std=c++0x 
-
diff --git a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o
deleted file mode 100644
index c4404fedd594a6c91567dad31e47c4cbabb7e972..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 295872
zcmeEv2VBkF|M<PtZD~?OLzA)^(oj-zbEA||LLn(aOG8map(_npkr9RL5R%o>4WSY$
zp_G(DWQ6GdKA+FIqv08z=lOo0@Bhck?fw3ob3SLh&pGdP#%DF%#)^+hrLg}|DP|Pz
z6FZbbF=z2}9?S{MobrzEEgwoN0e>XnCj~!g_`!clZ}`&(<FWwz!ml5GmIK%yegp8c
zJU|8bDZ)<)egokL|0&AwM+M`m7^(qO$M_(CgE6iNPz&Qj01n0YFo44`J_4XN#&rPd
zVq6d4Ncic)ZxjwQ0BDGDBY?&jAB~|2KvRs5!O#rgSd5zkw7~c{3@rhU$2c9J6~-q3
zWWdiFeiL!nB!D&;w*@#E<8~O@1Dt~KsTfWJI342-039(t14Ac(Gci63;B1UL19XAk
z9Qe(}Ve<gGVthV8H;ga9&>f%$#us9^2%sm%7Xw^^@ue7g0rbYW4?tgx`vF{raesgT
z7!SlS2;g#z2LlYj_zHk4F&+vq4CAW+uEuycz%>|O3oruXkpS0Wd_BMo7>@$T#P~*l
z(HP$ZFb3nX7{*~3kKty32^il3a4W{Q0o;!99T+BJxD&%&0FyAj8{i&{?*+II<H;EA
z$M67#DF9P3eh}axj2{M=hVdg99>wq&hQ~2Hf#FFEPXSEF_-TM=Fn$(b2FA|;Jdg1U
z05dUu5nvX^F9E!a@hbqYV*DDwY>ek%m<uou<M|j~2Uvh{7KViYZ(#f;hPMC~Vf;3R
zcL3hScrk`00824`55qEm_c8te!-oLN;a35_N*wkGU=_w6WB3H%Q;b&wtikv*fVCK}
z1Na={^#EUByaB^T3||6l!gw>lR~UZ{@D0XW0KUceI}BSfe2?J=fFI%a34U!j>@&bG
z82^f4JHT%k{|>MN;}kyNzvu@%m=7R7#svV<FfNFp5Qf44MKCT3uouR~0E%N=0-z+u
zr7)Dnus4Q%0Ls8m7JhwkSU-Sr81Ika0D$rsR{*GpaV3BQF|G_y1>>p!)iAD(p$3M7
z01n2uCO|EW4*@t7<HG<B$M^^gwK3GeP#2&c#z$hPkKrhQ1{gO4XoPWNfTJ;P0?-uW
zV=y$sa4bM`j9UO4hjB}Q<1tRh&<eu|02vs!1~?JplK|Ra+!n*h0PQet4{!>`rvjXY
z@#z2^FzyI&2F9HL&cygE3}*v$#<&Z>IT)V{a3028F`N(34dV*{x?|h};6jWq0_chH
z#Q>LJd?`RLjC*6~1JD=aegKzY+#g^7#se`70=OLG!2m-rz5?J%jE4dY!}ux;S7R6s
za1F-S0*t_TB*1kTUk`8t#-ji-F}@LCG{!e!7y~dC<8c7vF}@jK0>-xh+=}sS0Jmd&
z2f##(@5FEyz$A?C2Dk^~djamlcrw8K7(W0o1>>n09>nkvhKDgs!|({eqZmI1@Hoa#
z06dBDQy8WLJdN=)7@oy21H*F|p2zS4z)Xx^1ek^KO8_rp{0fFw0bav+HikJE=3<zK
zVLpb}0Ty7K1+Wm~Hvrzm_$>^J0N%#<9e{T+UJS4V<D~%aVZ03BeT+W<_z>ge04p$F
z3Gfldt1xT;*a$xd2J^Ya^l6NUW+?_Utl^p*@Z<*gQ5Z}XBbwg8U=~1lH4$_ziW`}S
z1TcjW9azm^KE*GTHw|Yn^BB=MIfGdanGkW-%zSn-8z#I#hB6}ZrDj_=yX5^VE5X}X
zM2RetDnJfyd;9(`Htb)~#lNWgPfnn}i@GrN+ZfR_V&uozOTjc~V=$%SUGfONftd!R
zK*4xU^WZm#iT&d|P`1nFQwF(u`I=Bnmj;+n%of5QRlh(V0E1n9ef&*O8uTy7$8&+Q
z=dxv^M|=8=9&PDlYcti|b%FabYcJoWrf!Q|m(2|b@pT`j>>udszRYc@tG~b5=+SOI
z-a+om0;anM2aI<OaMko*<~Em;cE~Vggah#O4$xAbz1%Zkk#eUL%43w5`gku?4)pf-
zT<Gl%<$DL15HAshK{U$1gr`gh;?&U^>Nw8T-`$0%zxE;@FL&)_t_yvZxoVI1S?;~m
z$8~|fHq_J8%Xj#w5jrDuwV}EJ%RJ|6Ll*F^cIQTpSVZv-^qRKF(<4CHRM|kE$o0QQ
z7ym^*%L4um!u&h?wWsEBN7j#f`M=g5<Ur(%ZK&Z-HsQb2A3fEUw>3S?!~e1V_^B2k
z#R%zUa!5C0FhSWOR5CWJ<z>tejrel|gJmv^cmu*&=2C35z+8q3LDh^HSt5w}fXlHR
z;N5Y;#LLm<!i;s<0h+`EX6a1>2(1q3g1BI=Vi(Vdc4@nj*U>>0ojVA8T)U}Ir=O{H
zv;(Mx_CzH**P3Vu<LB!oJfG%CS%quGl~}x_Loy8-+$MS6TqZI*KoQ~W5=ohdif1>T
zN5I7sE&nsJFrrzRkcZ5`7N$cpPeFk~nW$fy29jY6;b?j@!>t&eT98YN!Y-ayrqbJ@
z&82#h#ZX;j!%(iGEZJ{z3d0Ry=AsZLmg?vgl)BR^Wcy@ffLMcRb`)KJbeadnRUUjf
z9n>F%i=p&GX`?7s0DmLhf9m~y(NtOsA9z1$U<5s<YJ-`%j-RaB&qW!Hg15)hzzp*S
zB#hR~M>&kf{dp>FJwK%yp>L?PWPZv{K0wp>Xj%M}7kpj>G5%ZcN|-}crrCoF?>SYA
zsL3A*k+gxgmeQ*ED0NiiIfdT*V?lir5fx5RY2Y&`0J89b(GCIdzSIL0^NLCX>;ED<
ztN<a8`4G+4@sA?Ym7sJDR2p~@GH^O#WU14JQcz<cFXLE2K+Xx$){9aK1!?z0C?5zs
zPKfqFgmOrTRwqI!BJfQjknoTQEm@S3Bs!3Ix$jO?KsuEME)5oy1`d=H?CO-G80bP6
zDVNw`*AY_1N886wiDXx?7^QnbrGc~K?2oFr16A<?QLURq6+aSqJW;K~L=|uUu!`GJ
z0Vk+5@WSL%Y2foY%C62m6!Vfw1Ha07cGv}k+~K2b=BIq*!&JP1(!r2~eqi@NH!5yG
zRZJD6HHx5$o)@816ZjWFTDb^ivk;91;X(+1BMb?dBD4rm%6AcxiX*4>1!p-Q?K=$-
z=N65!o8J=fSNyap8f6^~g(uQzuV|DD1il3o1wGe&@DUjm^3ghI;H#h&(I|WPEdhVc
zPkT(Gtf!&yoiy5O8YPp!xBhlU&|B>^N;x0x292_d-xBa9ep)4s5<x@Z+iA2W8s!{;
zZ~kFM5@Vog^FzRE-hqhN^Vla71%Uhg%kL#x1it>)KS)H%5M*s(`AkR|j-`ck08O?I
zz$}iUR{`(l%45zu5QGF)CnW$B0*)2{II{k+a-hsb)w!r97ahh%84=k!JaVJ~p3S>F
zJ9T;X<vd4(RZ}D*uR&g&DvcyQ(Fl$v5*}7X36O)pYNUfmGNPpz5xJle^oFcDN;|&{
zZH%@@X`#vXQcdn`6(u5@TQG`@$nIJ(PQ{z}xi4{A#|>o5`)<n4ufBq={MA>#<`sK}
zkn`-Ho>yGm{WrZ$q$8X3NwE<BLR_Z}j3UxsjZiU!q6K2Mr<>4(u@S(CrWC-k2-dTC
zbBm^6wuGz$j#|x5NqEX2rc;^R;>Fl#fw>ei#M%nXrK#XZ>uf6lCBX=h0wctcU~OcP
z6G@!p><|>u08Ej>$f*`!#3=Bw6B_3QNH8Lrq}cxHrh0Y^N{{<0p0w9csia@-=W5)k
zFCwy`OtwkN?HeFW7fbL@wvN_A>y-a&>saQ)P)En}_$=+A<(Xhir!Qbc3uqv5$6(Ui
zbhCk6>4>fo*&tUCvC|2;!=&d&(DMbN>G_OAPCJ?Oa&B@dn`jC|$Jn<sqHW1=<{e0C
z(NVlETXJhQVN*tgl~V%5;H7eQCWOJ)I1vmrGVd7s4kDUb3<HoI^u2q~x9&kuFyu?T
zNMKA5p+rga1`ihf!<$P5^iS7V^uq5Q6bg%8)bSmGVhZJZ2a8^Yo+85X`BzPVcR;LC
z7-LXOpb<P~vdlFFfI>v`_@On7+?+N(W)6`u#uvt+18OjklN<nzK|t*;nW6kSnSmnp
z$1~F+Go!AugfglnFHk%p+P()G;Cdko7wW~#&3QSHT3pgb)CwFNzAz=a)T$biLalf*
z8q>ke2<<%kgBk50GvZt21C=P3JWr9lS}b{<{z3A5wsCIYEEEXihsufgNJd!T2tH24
zCo)14w*`$+B2A1hf3$6W*9J7H;&hOV!if*;M0&J42J&!dTfi79Lk#NxS_4YYGY^em
z=oj)1`vzjz7cyd;oES0mVz&0l;~hewXbliAdJ&JD$^QTSi@-1G4M0$mPe?{?0(v&C
zMTCZhPF`AYwZ#8a4AHkFJO3Sxv=g`Pfm8P&>pDp>JUBU$6HPp_bY>UH>4Dy3OT=HY
z6G{1Q(!Nt~{M%(GVvWCK=P%j$OLjK@lAV82Klmj(d$2l%e<(Y#<@if_n*Wxq{68f<
zp|2^}#)o?UvO9m-ogTmJPQu;t%kBi$KpK!e+SdO=vJ<UMF_2#YTx!`2rb8yvHUq5Y
z!f5+p2yk5qXlpPEMm`UoV52<AZOBE|2YeUE2M76ZR)nJI8N5z6WNkt;Y!hM8tC1vS
zz}nK-AWcRLaw~yNo|A?4mUA8pI2gxcQB7>S1Xt0$XAEXBxKgR${A*y*t560_#?i2{
zmdJ>axlZI4P0t3W8hFGAJGX&ZqJkV>g|PA@OeUljGjB#oMbN9L@N7cQ2))LR$2FCU
zb|8qsv{#0@W|AI2j<*bY8SS27`+$*#Sq@YLhl@iY6M2E?<s=o$xg;T|2*HSoJi)wF
zgc>6+BM%ijxh@eEA)26K1EylbpQB<!Cn^FFJ(%=oEP5S5#8J`oI)aGEqg4z91jijS
zSMmb=873gOtq=iGA~pf*fPi%-^!!jXMu>P^NgyCW2a<q=BmrRzkR6H%$n}4~z8WB2
z1Jkw+-fx2u1&_osA;KF_qoW;&D9Dd1nWcd6Z9w=I;-yZ$4?GT#?}J1kM`CT3LtS1!
zw-I|DEZ}i1V_p|+E*4`?g_jFquZ?l8<oa;Pu#*o7jeo+Y#L1gXEk@18Z*uz-#W13E
zaDo^HWDH|wq8KxqTo;fL<ZzdVq^|~EfHj9sB{n(yfo#wuKn}pp*^ryUe&7M)^_gKO
zWap92VAJUz;TKu$9mKz}4CCVEgBet)Kc4@@Jmzo^v@A|?5bY+?Rm$NPf0dDp`4J;2
z0E#ydo@!n;g4m489p*a^CNDF&MD`A`D-Koq4>1$Ynu{jTxB&)rHPE=6X<LR0Cb>xi
zcNh`e1cDJa;R)vDCe<j4hno<O<aRwdj1$}>+JPtnO)OroWJI%0mx@Hw%V6gJPA5T$
z1cPeBozylq=qEa<tt+33qPMc>@6k+d8W~N0Pwud*Mm*{~MU~!)7d8m?^d7M%=$Kp&
z$*VaYOuh*Edtg%UP3UEz*U5Gh9fK+g9m8%rjHj;aJY6liUwo!VcJ)v28O<(35B1xB
zehwfF2}uT+CjXFZ&mtLKha}>7njisSYYQ*SBPJ*)O%3KG%L8%$6SL_zrM_VgQr|-j
zWIj@v2#HQ6Ky{;nHju+WQ;H+^IjM-$#FYA@a{q@M=68s~VKJB}e?N=S{{t+Bqz40d
z3_%bMk3p?(K#CFpfAN^&9+VJX?diXw%fO^=V+OvD2zyTn=na3V0b=l%KR^)v(qKzB
zS~+W?5exn7ecD*lY(f$jR7u#zfp%vgot%8C7G{W$Pq39Qg5HAqpNLtP9aw~xVmNy@
zK#nvGL9u9I9C9Hufd|P8**Vq1BE@6?=oBa)K6XmT=O!l~a_*3fDI%<x5@-#{V78*I
zE`dY3?va6XQYfD5*94T<O@rTpjSC2CyouNh&d8Wv94JDBW<V(LAoz<Sp+o5{O(GF=
zFu|aHpuj>)&Ql_@1JS;Cq7JYv1115f`<659iQN;?BtY5$qynWH#5A)DuajcYn^7rE
zgE+hBVQE_okpS|QLV+OLb0yDHqksoBgII4cp*M$>g79u5EsQo!p7081eN>qvPSD&m
zp;r?PYiLX*Thu_(4eeYc_ffFxg?2PzoNP=3*%**Ts7>&M8q?52V}M5?igR8^J5|^U
zj0#x{G>1@C(4c`M3>4I)_lTrzh@>b}WBU8hdkDun0W4-%I9fQ6r+$%y%wz^4BQ+CM
zpGhx_cFAC5V%{mlFwR>pj!yET-9{1F!c9U9RyK-cHwaF^S~C^YZDW?I3o~LYJFJ-n
zw#+w8QZ~#EqNlARSW?yzuc@}{K87?|$4rM*#C{RftW2<u$+l+_)yxP&0|ntt{9yXS
z&Knjzo9IZeDYK!^P$h^_T?pMrR#})ELoMV{QzPiv(68BSn=+H+q(nKn{t`qn1l2Q9
zS44yr!WPvHWH%P_Zm`0op?y{+E`?ooSfPPRrpCS7G{Kt5vR(HoK+A^t4pB{ubTL4^
ztz(>N6dU8FE?K;?VScq?z91(BcN0N8oQ>9mv(XkV7IQ4-^6-xTzqrjLARw39blF$%
zyWED@ZGduUMC4;<#pO4p5c-esn@+ZiQa1w=Rh-R%^oXA2VMEB&AXpcd5p^;$INa#g
z&vGNqPHTdT|3z-psi`BnHTAdn(-3k{1K%N<%CV=QquP+jB26m9s1RdjGpf4?Cpqpf
zKJ|-F{X4WGTQ+kcv?5{PE9BTFq{Hv>Dej)&^2V1va;ma_j8pO2Km&U;3^}Z7<nObp
zF2)LnSKa(sUX??V12_a{b2Wiuc?x9bs6M~1Id!svwYxX=x0uz??#v1|mhdBkV#HCa
z5cg(tt2@8A6;R-RUaNvOw1L(M3mH8271{ATy4T;43dZ}df4?a3ivqtW@V8K4@<_NX
zM$gknSHJUhG1gv_r|HZ!VqZc-r_+C~I8Oc}t*wb`Y1r59{5{!IIQe(2f56{U04M)0
z_5Yi)|8f1@{@MEfZ1x;_7+P9+E_Fw}Y3aIj={Q%nB|VN1ZhGq;(i6T&_C9~kDP(Y-
zA@5Eb16`W|CwaLKT(zzZoJqcH9}<zc^GRJ4Z{8&y780?e4`q(=uB&T2QAD;l8OMhw
zg?zTSc2cNzNVkUo_B|L3IkYcCtB{e?#?K^tYSHG(pcokE`m1qXBehl7vBIqfudf&T
z+1MpTo2#?62sW+Ii#!DATs!RJ36>@D=ShYfd7Yffux$q48={1~fN=N+PE7mqtk!dh
zMDCHm<^N0xsy&y$bAo}r69SgIl)0YLZpXZl50kJL*ms^t<90&Vkp0W;(?6C^Z^)q2
zne?Wfvg||w&TbFrN;LAKL96H8+R;(cDmg5>TfY!BC0>~auS7cl&EXCev|oe$0=pD@
zpaA$I1G9Ozf)J++yX|rUf|LV6$|-@pJS5-TXqA+<z1(C6IYTJV*-99VF~}U^?hYXy
z*}iWQLI$PpBxe;vCJvX$^khV<q!j%!sx9X<6X$psp2aZT!U~yz`Q0jvcA6k6=@3mu
z3sZ%-$vxCOyU83VS^g)hiZ;GL)3{a5?zyUL>T+i>&&>p#dkbYiR2t`sWAW^VW4894
zb^T~_P4+CsX`;=Cu|wGN_J5Se*$~9&&g0<F<PTUJa?k;D{0$bzS%(5T|Kf1Ke|RS5
zFAj$mMmiDX7l-@B;W{&9f+u0-%$4|D&W@vall8#i;R-aQ#W8y3a9!A&Dw)b$idbm=
z#ob`lj7P)xrN4o~$JQ`@>2H5V)%^GCZ_0#4g6ssuF+e~!$pAATpJK@U7Yy<;L^2F%
zyltk0?aB#&)t_6OmmmS$hY@)m{3@KVp}^tRWv@bpBD{o5N?T-Wf^LBB10j|eBC{pe
zt>b;?hlP&~P=+duU2YA3RRUDuuXf-VGB+}-rtzJg(7hN?5*ZiKLIvXx@jFfsZZJ;J
zBoyBy5Z^>)b6$?lE5_D&Aq4D1$N`!_Y%<BIrom2G?wvIZAZaF;IGrw1LA%`}!qO>$
zqL+}zsWF~tt3x^{_{BUL0o+1@qMNLv=|x~KWOlV%k*x#iIs49`F#~>(G_Of5f?k9+
zyFe~nr-CuPNOCtEED790RD{frBo5k{5$%BPb?9_a26vA-Sg<fg{`#4KzcHWR9>08K
zM-xsAVz?sxz0>$56?*RYC7&fD&k_BDhAT{qKRA9PdEbe#@2POug9c+aKoS0|o`A-$
z%0D)INsj$%`~n+dpC<Z`jXPqC886=i#mdx_z2^k$S%JhVDH>pe+V!`Lxt<D^y!va*
z{r7k#+U33om}VMCgk(5#lE~{vBF{i20)t5gIVQClU1<i1=$YirMj&7y0N&*Iwg~wZ
zC=I)VGKC4wZbDBCECX@Hc@QGlded?UAoIlzTiaw{_1QcUm*D&{$m?bcC2#~WQDBU{
zP8UJbNlrkWSmx^J5)|~EF$$S6DMPx75WS|MU2gs%uaYF{!WBDM`r_RN?D@(*Lz&r~
zW|>d{v@s5~yTII@fV^Ukpa<gJq#gnCm=FS)Sj{OUq(1r7Qwl=OF$;XuDH#ZSbfp(h
zM&y-qxbmO|m2!$53Wh$L@^Bp#656~Z&V+jX4vD)}4)rnj(xm{E-#Tl?L&#2Y0H`Ji
zR3n-N&Ee3e4L6GnW49g(?3M_&S`#^<zHvh1x_jTG5gEg-Si(QrHakF+ywhzu3>L@|
zjU5_Pf<?a!e<@9JD2%5rFdFUQyw_#K%gAs-r$oEQFAJ?gB<2YX6eU&|8rvWzP7LhU
zg;O2bMDBArp}19}IRW^>z=$@NKn<Qim~%+UbqORVA0kpj1L!?4d)P&jLx!j*CycD5
z5NLVXlz@#Su!7iZnBBiQ7SeuaEI>b_a*;<D`&qgCfPK3ekJ9$1#>MZ<Fm%Tq6rRb`
zJDn#0P?|+Y9}T25nR60iLJLNC<x`u`Y7O~55o{VL0M`bRS}Aw<5t+hGbd<m>PVyN0
z1_I}uZ<vx14SdX8h=hs7fEoT5CKnoeMBzU<xsbOP(NGR%0;+BU+t46z9w)+YeJz0J
zT;Mdun&vb_bmkQ&*rV2MZmmP1Fn<WP8%;cs+>byzGe9y35t+Hp7hXf-h#N)>Ve*ln
zFgJ$mzJL+DsgWSUi95?8SZE`9pFGV0W<?S^AzAPuD7bMnhzj1|o^k_A1}^#M)}nL$
z8b6@}>^#v#CAB3Z(Fe+S!<p-X|4dVV*erS8Oo_tA{7zHp;k>VOuKu4Qy=uT<-kgZS
z2P3B(mpBjx(&kvVAj!zLUFZQRne-^$gq>@~8^ff>|A~qk)1!K-6dd*MQcuZ9af0!4
zgPEY3@TBTeBVN@Y8mKyy=u);cjY0j(h@q$R3e*_FkOu9BGdRf<SivAwp?G!{w($^~
z-06MDF2*655gmi(SN9mO-E(0Yam?<{xswfxvG;{wr~_{*C<WJnr&UeE;~OV-AxRe+
zkko;xO-167OF3dNm`ScX31_(>9L+9<2{F5a(4ZlnIbuyakUeNnMvRCPC|a1EY$)*>
zn<g=cLokR+^5`k-mg$f&ye)%<vZ>3hUguUcEh1Gv=qfU4lSbD7;;wO`GjIwVz|Ea|
z_=9}6r<g9x8y{LH%s#f?5_<1n<hQ^_&{_0$LPs$rqy_ROwG*d#;3#M@gV6n}(b_UM
zv=FH##<}d>4Ym>VcGBYO`Yy3;7<d@09`_U#7>i0Ik6BftGe)^^A1_|_{fExJm5{1L
zIne^n**9dY{O~La3{}n<zb3$mcfmyoRsRcz--eOr+_;ySpu0FoYC{3S_!L|ry1#_8
zk-G@gxt@=}adcrA>wm<?6IhKFoq;WYji(M+CODiVFF^V9G%oYvvGR};DHG1rB?gxE
zVC4ltENSJDOV<BuMjnTH44~d$v+_tn@hXd;n|3nax}_kUfnBXUbhUJ6B^T69qL;EU
z8w1gcj^kt!S}{^dG4cPJoyVzO7jE{a^m&5Ifz{TNorel&L$(zGK|SNNpB(^(2q)2>
zu=5agz^lr!^QIB9?KkZ_R7@JG3$LArvVk?rE_NOn%C_@9k!&Q5pnZ>a9=lb%b{?)_
zXFE@TOxfAagM*Zv>^x3Ii3($)K_xred31;+?Ytikh5wS7$F@*@V}^CH@=%jIPk^4R
zJT{rTSb1b{cPo#RX*VnHOSj_4DaC8#!HxcZ!N?P2m+)6+*8hT)*OTc3geUd0&Q>1o
zz5pF|G&!^hQADKgB8|EkKRbC|#0F-gac4UZ%IGP-?v@^J9UI?wwqVGLf~AK(Pu;0Z
zdU#iBg*P9bq(7(!xfaN4=#gc0H}pEUwW~SBTk0RL5ircoh8|gXXG0H#buskFAj!zr
zoymcMnd`if63=5U5d6HS?guW{&DP^>2Tvv_XJaDgPUar28tk3qsQ>J$(Yn|+-ORmC
zCGi+WFi)evTNch1sNsyCv-2<${uh{e)?G-^V~2Dz^AI5;+Q7^^MVfhpZDvB4!GxJd
zJd;`pr0Ztpp=d;6A{n-xNs_RQXE37vl9k8XfxoOg7`C8Saa<3a{X$)=Jfx5`aLh4u
zhZbA`h?Fs|k%s~ci3!KC@g{Y%@$j33t^_VU9utozCNKe&_8+zIZue;6UHB~v55^IB
zPYW=)zt6(cWLtP3FF<Wzllh0%9b887H(7Ul-K;y}Qz%f4o~=955B?+T&L7?*tUG2d
zEYkg-UB4rV^jnr)w-ji(-7N5NC-V;kV;8j+j;}yMSRVg@T}P1puNifmn*F5e$-A4p
zCz}rC-`S=kTTTQc4?O88A(H$Fiw@Dnlw;3L_<eg0)uX#ThpsKc=G;9Z0a7xFyNvLv
z-K!s2b2E98Lr<bTT%^fI_L-?mAlgjE4np4#f*{08IYC|QI8FuGX^48T&A83va@{zH
zB+R%U_5A;g4aXUG&?3@L!DGWAcOwyq$YvHuT5#Yh<_31R-#8f(_S;o<Vi;fOyIY;j
zMX=v^jW<5f;)**d9FYDGFMsp1v;PY-=zrCA1ETk&yc6Bl*>b~T<_}qJT~_Fjme{D#
z#d7O8zwVYBZw(vad&s;N8mcDPZN$~nTq6PIWjDKxHy3u3Nmc>h5yJso{fe~P`gcxf
z+TCjF+|I668*iCitv24cF2$$@fY+95@jw#?2f#Ty-Vj&>P45~a8Tq&yaiZ4wbTij}
zP;yV^+7FTf)s2XZd#Dyn+s+l0jD#=W@%9-Ml*p5a6d&X}NC5X>s}Zd7Ck-{?-G70V
zHm;kM)&p?~E3GdNafoRsx$b&*8x3}okj595Ry|s1s0bbl4bkH7GS7Hx|8FqQuolw*
zTi~kMYhELPuk%<#aQzn&-_@M;F0g}OBy-Fl%kE|nyn^%#=n`HNhzt$fkFxJ({*bGI
z?3KWXuomS2SrGj#BIx?Luoh85A7~NpdPOBsf1dkPnGRJ%?KxMXH^9}8Fp*#;!KL~5
zN_6u3&L<!gF1`MfxAgRIB@qx0t|TJY3k`|wUF5nTcO9!5-{r`qD*LJ)xXd4}>1l_H
z|JqIHRiVUX+k_#CZuKV;730g8h>h=@RheK|PDq4Ki-&!SQQh{U(4(#nLTzS}OSepL
z_|uOgDnx{(bp*=6R`MvI2fWX*j2kZ@Cdk7?8c)N_W6{%r55gxm(M6b)#*Od?-iu=A
z3pX1gwJs4hw@}%Yh1E0k4TNY1xDYVciD$(f*9DgGdyKyd#c?W(R_f6f`)GPRvw~e3
z3@BmZj>YsQ)d+e9%p^LLk?q8eH>PJ0+vg<-rU*OwJ0v5~UVf<JQ2KGW)faS~XousB
z=s<1*VjPOeMso;(Qn7Q4hP?;f8gdn~<W>}xf(fE=-tX}pc7{}XTGLpvKIlg2KV6{+
zdK!$BG$#Fcv;(Nq-Mbm}Zva|c<}?x1J!5)WSeLy(lIv8yBYz}sI;t`KI6=SwOWuf|
zq#bP9$cAiq#~2bP;NHU932eJ=KE*o_IMfFdvGXS@e`|Xx6veXvlfBIVNle}yt8y@F
zU=AYgMl8es@H@qS{!6|@uDo0ae|-UQ9S#E`KB3IBr>yg?ciz+d1RH@oTR_eu?%M_<
zU5aPEq9F2YA!napPv=@d|A##UB#Q%#_bU#Zo`4~q-enL&?&v-CR~$0Ad;-OgUvVHZ
zCcfg3$^ME1P>uMC17ywJj{+~?uQ+f@ByK+by=>4#>YfeggT$cV<b_Vg;2{Nd>tPJA
z`yXhn1Kkg);YxGj=HS2Yj=VRBCE#5U+}k`WAoQQvLDA{nxE>@DG?H^k9$O-z8-%$M
zskqzi!kr}&XMaTj(CRn#SD;mGW(#~w<-G^oAPq7b0g%}UfXqhV@08i--r_$dvw6R$
z(fz_xUXjhd@Dy$EiIGA5*j-#B_bprj4_}SpmDc!Z9c&Il(wcDb5;weZ&Zwce8T@xk
z>dRdv^_lLHnn?~wjuhx5sfmh$Iq}~Y)H6Z3AO&>-(Xs!Wpa#!9TJQt`#N}oGE23KY
z|B|TYXt;8}WHslDOI&I9e^pjbVvAQ;jv8_eIN+bU&z5`db|c9c%RBFNya%B_l+=G|
zC9KnJ)ZOI}ub^hjAyQByIn-T9calRK8U5pnw>efdvn7iDJ{(Et-tbo>Kn(th1_;96
zZsM7I=jUwdH3S>~12#2VWn+SG1s%=c7|`$mgm#8oanDki{Q(4yy^M|=filmQz{T)6
zhkw{kzSvdzp6V`r*OP<n2htY|oPUAnb^gzZUeaUzKPh_E{x6AM_I|`)l9&6f!~b)V
zx695Lbo!EHu)OCV;G_e5N`?lkx=EJp{RMx4F}*$XZYJ^=^4!P)8MHwhHw3sn=M#Ty
zx2Z*Uk14V99|wzF2aZZw*zm~|@}LDixw;J^umiP|fm=-+9U#0snq4z5=f;Ua9DE>8
za??tvHHilpbxqIBD^RU#95=7du4!1(XYUZ`dMAkh6#t`Gw$qn;XNeQ&!I{Xn!*n>#
zv`y>c>jj4&Wi@j6!Md$1K_sqy(|83Dt&=}94Y`6Kgqw(ctqF4agSS&E+O{Z~ejKRG
zt_kdK0k>%p!>yE&^9+u^+(h(8W^fU>B8yDuY3SpE4#nV><i0}s!N4KH1j`utSW*4B
zWybSXitW(>u}FFbf7hdfJWxDd9c98$Kw}DqDvY!kd*s+`AU{}C&CZnxY6Xh7M?Fq_
ziU-nyKP*&{C%Bls7{GDovgqjeGNs7~-Bb#m0d6Cp(J(PY5r|$U2GP`a-D%WDI`-Sb
zvU@7UUW|R0O_$qS$kh>;HmHJf@G6=?WZlTSJK63*-f-f}Oi)QFoE~=vIv`E7w*`6)
zMfH$E7)=PW)7Uk_d;r!{z`Fs&g9BoJg%kXVFQf4De8GtZZqJ|kf|K&!_ys5055M39
zw+j{WjO)MU3r?KUc)#ETWBe)6=S|Jf4S(<pPP9&6aN=h1C%@p-K=}9S*sK~Ijp9lK
z!k0vBi=@}}ED(yZKwxu2Gz5QF9>8a<dEIfuK0zELMu8lF>#{dvVmW{;4_-NdQX#&L
z>IR2GlzB5mJR64#Lpb_CY8(jzba>No-wzzf8_s?IZ{qm`6}#Nt@RK|r-RHo|UV$(F
zkmu_Hjk@rB(l^Lu`P5S2_=r}WI6jNZ@rf4*`}&_|_iVcq1~UFkFyiO`5WhG4qx`-T
zfjI0w2Pn&yH5{QruzPkZq@Wepa}H_S{w|IW-4W3M3I;f<!6n}V!zU8(!2}@sjECDZ
zTbK^j;K;8-QV#h2Uzz8>xV;2)D*Fq5zxBPoe<Qb#qH~zNG8)H7D<s%4a820w@gqiG
z_EVa_Hp&|Ndr<yFQEs5*lRTbxqlq7zzw;zV+e{QVSrCkw*m@!iVTiBqCt-jlCk?^W
ziJh+UoG{LNe-}T;`aN3z`3w3x+OqLSdHE2aSXW+N%%i&l7bm~8$x++kjx)B}PDPHh
z|F8J>$Un@#*>vIXZZK#581Dv;DkS~eSU2p{Kz#c={e4t-Jsq~I0ndhB>dLWUvSNn)
z({uF~xBegH*4%Gn5aST6MfluCAKq^~kTwIlGL@}&5ZV(nunrA!!jgvpOs@l5vD2P{
z5kLGET|=}(9rx?M#`L;XQcaxgHb@;qAHuDJ{QxX_3$QOrlOEc{!n^gLt<z>W6xVs{
zK?~T-Ehf+sVly26o;YM|oEwJv3DhcK1W2jcb!!4oOGyojybl&x(tm|Eyt@g8|LB{d
zf0{JI*`%SM{_92-q*`+}9dM{ZY&!T?P=({KVXxs3z0-AgpbsSXG%jGFr-c;!J+z#?
z(8FmpvC#7qtwuwz^FQ|Yfw*6qBI98hhxj)U?F)r}?C0R!_g$8U%3lBYbasMsW>QsT
zWc=F5z7rdy5-9tZj}sYVp{`7g*s3hGQCT@kpRT$#z#=Q^K+D#{<x?y|4%pF~8>ZDX
z_F0*;_L~2py%m>oK0egmXZQMb(I=CIl{@`Cf)*}csgQnL_*S3vY9Gz-sZO%(8r61n
zL+_udj#rAxjlX^8TXU$B@}5bjTXjlriR8KGroBIUQ0@(L`k4bS9d1o~@nM?d=>^gQ
zyzN~MdnZz!XRQCKHpphDYlYDCP^<a<0-qRtmUYxuJz%|f`{=vJ^&IzHh~0PO&e>=E
zj<hyMo_lFJc-5uRK3iJs0-qRspBeaMM9rqrZycV>20lruyJR+#<-@q%TC5PaSVaDA
zua;(;WP0|;nU3OO0<-9@8g%7jrDF4F!OBUr`60?1XbHi|;=Ri1)|?+!94=IO+T35M
z(0z@9(xSV3dxDeu^m_kn&7EQKcllkMlEa0vG!9uBPiQrdixd;y+G4Kl`0|KpaT3j=
z#e82iLrNz}=!-+nUYA1tZ<c9t(ZTb~llwDf7xD93DypP!5)w_BWS+fPDf7%MAM*#T
z*@bmEQso8wGfqEie!gbPwiS6b%91h;cf#|emE>;U{HQMJtf(2T&k7#suyNuXzW%a$
zsZ(rLnyz2Wr<B_;sNBWr=%Ml)sht8ZcHgtz^Wl@oe5QKA?EUMcBwRZVrRW&tf2qj1
zD@h&8RM2s))L*hBni}l5*vn)_zc19<DG!%l7QZ2Xrl{i7hHon>PQ`uuQsEOh`5j|z
zN1TT1wapKNt=@&oE{Yg@EA(87!C{N>#b-v(%a@3E+<EX@*_JQjTWurFYWJ7NZf`RY
zUg5%5*Vyu=LY(?0sO<gZ-q%E)&0rM09G3EC>l7sefnk@l#xIyJJ;3^At&~5XXNA3^
z&kO0}SDn^>nPYmnSMdu`Gl{UqJ)34`xbHrBJaYy`iOQU>CJ^_+F=ooUalzU8Pn@*%
zlBmbdEf6ggKBQf)_{3>o!g`9UK*EYerHOK;$%}lB5483VPtUd(Vtw6GWQ)w2)D!0A
zgRSRGP4|rK&n&9VUU5IhI8G-e{`08xRSq@+0{&XAg7GsIhfVv&=vTjs;j(jLVKY^l
z|8b(c$XPwT!{hR+7(14EFP!YAa%)VKjZM}q+xoCbPqkLL^vM@*gl;X<9I&%r_y@1l
ziUzwrQ^gXV<+y81*qPdAy!1H6P3kxyp+*^#X7_~on*(H}3Pv+d^_i-W(3k4EQ}vu%
z>hibC`;7OFOUQDJrf%M=IWvAjbu&$5Wy!F!1Diyxj>jB+urhpg>UiJO{+6pE%O^>w
z$Ei3Zhiu^+bY_D}jLLcU>|w=IT#`-01xHtFn=bV=rM8@-Y@==ZUblOalEFjsq|>4;
z;!`6pq?`NA3UM%y<ooUvF0nW#<c7SO@nLF*x!=c^m+vgPV;4SQdctnwti~q`&#U!M
z&X^cm*)X+^Qf7D1qcU$*;zvK@YkJ0R;Q=uTdBYbt%+>d=b9p!1^j+a%Q$6N}gisaz
zicuk&*B7RQ9l2$B<f@e85vruai~R+r)AM$$6|dO6p)@$HkL3M#bk~yBkhIuSHO4KG
zG}EoGCy5wD)ZB>vt~_+b3ilCdqXmnnwcgx2)ZU@)@~UkY<qB?1z5Hz4_1SlV-Lq$^
zgp^lH+&>t@n$}GHIOS9C>G98O=gsxi?q$7yV)o?X;j@YoG$&k;4Y#X}Ou3}NP;fcx
z*w-&Wt~B-}wN6i}P_5?aH2$+T1qKc3Z*NGAb(vpTGJNZl(h`S=D4Stxmj$d;uD3{a
zD5z97Qhe-B+2fdgDJ5E<ov(fF*2|)bih5g?CI(clZLDvIFH;hB*}T<xO^RjdeREB}
z_{@}*eiZ)z#w^juM;cmHC4L_2dIKpBrWn?n=588S|0w&*cwK271;vGe@%^R6ugJa1
z)mKnN<M)L8J>P)BVFHeR8Iz2~Cu}IXo;~aNAQWawIj-idH&A2LMyq=H>=lNUOWz+B
z(Gs-2Mxnk^(dZv5VSO&#{;7qYf?~o7%KlRk3yemq+Y00cZXB=h*jDPIs@2O`i7Ah$
z#VR7Lr|oQ{mIvJB|E{gEc664c^2go$HL<T3ZW7-qyga}`#bDHezEMV5HsO_{=hZZv
zacvM6Tr|C~!7i_4|LsIto2pjs*Q3W$9tpI)mQpN(7e%t?+AA!d@M&PSwx-0aDS0I!
zZaICfk6xTIX-co;VIpTMTlVQpcqqj9JTZ1zK)FLhLra>1qTu(dDS7M5VkInPjk9L>
zr=@&Vd05jhKf81=Yl>mY^xM7xGqW2NChVEyK4XHRsL{RJw3K7*Cb8b5(wAS{k-S#M
zj{mFpr!&wmzPEe>jQVa%G1(%}v|hcY;pS1P2|Fq)R3Ycel2>b;EBP*(w68R9-QFZN
z!BFhkgo!pLSt5E9N008Ms&`uWX32^5iMEWdgC~XwZkaY=`B-y1&GN@3VQYr-@0Qd!
zHEzNN8@tQy^y|G2C8bzS9iyyoReEjI4c`F9P5xYSA*M;zfpO6N`m)0Q>~1#XTe3sm
zU&+-<1#to`kIi?&5F-hpI`w;;xIV?wqqn}r9)W&`Y8v7zXindHJKyv)8ogjL--BU>
zJ0ZG$^gOTSTRv+ZnWC?^PvC*Sh)2p;TZS&<i=6O2V+JIc`uu2eje~6hyk90Jd_qw@
zuSCUDSjtMXw_m^(m1Qd&jx2GFecd<QU{Ye-g88#DQ%r>0EGG&C256f%-;#(l$%<3{
zI87*5@v%nKhrzpOs<E#{!(SRfM@v}Rj4&V5C+0g0#mY@3;dWb9FNf^1gwYfJbUQ;R
zFf-**uQrwIe#-*}Q&(I1m9H~?*<i-sFm$0;fYuO8!$S^RjzpK)C8jK)r5YrpDJllZ
zjvj3~WWt6u*WNUwtDH;8v!}<tW-67Hd^;SMSMrT={o|l1hIvEe>l;eLw`?B2=hj%o
z%ECSNcGa6~4#d9Rce5k&(h1}2InU>;6`k5F^l{5;cfZkD!-(F#G+$~=(a?D^db)Ei
z?%Jnfpx3|dO2h%PoGh*51M=sp=nn0da&^O5@7@!buPAR+jH_7cwRX04$IG-@bPE-P
z-uBt1Z*{cx$VQ<WxA+XcXEW5a=0~cJdat9V5h|AOdPCdl#MDDdj_wfqen9>;ZR<HM
z>5f}LMof~LtEI7fr{&J2vBeap6EbHR_fyo|1>=o{on~CrxpeR5^l|m3^M(hy)=%+p
zU+`M+0sn~S3JuJ>2q-qRzmw0ULWRjY4fIy?IgVePS+qIBs-*CEuj8Ahr<AblK|-wH
zcMZ25a%iK}xKbJAA|2~KW2}Rv%ml5Mgs11I+oq%%sVh=*Yd6*%`c^pq-sSKYC))05
zZkc1>rYkEhp1ROKtx+xQ-C*<3jrkex&Khrj@l9FDevV1<`*?jl*1J%fth>=ge%V8&
z?X0;X_vFb8y)Pm3Puce7S6>8eyX5XBAb&mBqVA6V3(Zxc^X*ixNCdg{Nl|?>u6?z7
zz23$t2VRI?{-|ao8#_NpSI}v=`aLfhHLZcddGTdu)=t@!s;68u%6h&`^dwbArEsK6
zf{fY5>l)Gvl=vTL_4AN$KQn1ozwp2*x)r5cW9R!>3+xOYdU|q<?;+!jo6!_-POR6o
zs#l+P`>6Ds$^J5G{)*}6FBR%f(A9hU;BoW_y$PiQ=x1+*WPdrczNEoT6L_9V@u{Pp
zf;SYdGj0luo4sX0?0j`uzWs&jJ5%JWTi5t*QN1|)LHzZMfp1oxIPt3N`(WjdG@1Cg
z`vYAUbv%;lSd;IZF;L^XV8^y4qLbHE#ucs4UOZ^0cV%4acXPS5sRu+e23p@+qr*}c
zdDU<E)%Xl0VH0&N=daiIXfH4mKfd~+j=$!X#~0fNrmwQM2@+bn_*!P`x}x!kiVu#;
z-qAldaOa-zZ7*^W@{sS?amQd|+gB6n6|=K$(GMN@Rv4<_G}w7TY${^oA@f|)-1Wc6
zP26ZPRli|Is8_^-#bXm@@u{%XcS3Dy%rkEiNQk*pD#QC>-RA3|P6-zl%LWM8JzOIl
zKDhFGMEDlXRJo*i8?*FY+q#}*ouz~wn)hJ4!sLZ5J`{(OYBe{6M;gBH${kc9PdzE_
z+s9hP`%aSe2ukqgihfRN+jL&l8(kT*|7*Nizcj;%qvsA<ajEu=qSVDH)TKUaFZfV;
zu`a9%{z^X}clATwqkY4vy@$!WpD)n7t6-<MOIj)MjrGl`YXbL*?e14SMr_Hb*@f<}
z&mK?9TK4#Q_;b;;nKRCd^7qwBwsoo4<@|bxo#3n?1-ouJ#ZitGZZ)x_p0&NWMb`dx
z{K~V3sV^yRF$>j>-W#+1L%P-l2333LMYWlaWHcjtojaL3@S5Ur(LvYx?`3_NW>zFM
zy2j3JwDdlS0lhl*n$f1tZWr%gDlp$){h8u{n!aMMdlmcA&YpbHGEUG=V9}w-i>eN;
zEoT;)RzJSuK=IKTS-sWGK&fTU6Mo9Tz?923-VLBhpQ5&#O)XHR9UG!K@aXl|l9ZKA
z)}l+~Cx0F{Wh!Oz44H(IyBkZDs^<(k*gIu>;}T&v%D%b+=5zUd>A{mIbG3~5CVxz4
z4(jVQ*!+`bVujl3;X&V?`9+O!v<s4*FiWRSEdT0ZsS#(6jkqsK32C~t_2{+wRK6!^
zW?r684(~Ra+UFA0GfMU4qwLG3eP)JCr0hFs)a*TS!@`llTILtzLqvi#B9`;NkDn>?
z;Kc5;Tjq99+XJt=>S#CeXYJRfteWDGv~8{b-qPJe#Ix&1#VcINtsfsZL;4X_>l9Vi
z%3s`bzHa<P`OLamkB^nD=wIC=UtD@`fPp)I!<_7a-qoe+Psp{anje<W%y5;67)xuo
zBv{Z;=PM*QW3h0`RTbIE{tY)+W2;XL*!9vNVXp9+atm?snsdQ#R#r?NAu~$4Wv949
z-q9r^zW2Au7Y%=4p#LTAvvP-?kHDky9Lrl*Hb>Ed7ttgus_w{)wD4IIZ&!0|alcj8
zR!cN=X-V5|9}%e6R*5L7_#kJsx+JDT)Jf53<RsmS-bo9`M!U}y-ZXzk$kuZdxuMSP
z#{Q3mj_36sabLG?4`0FTlgE!*I&E@K*`=GbPiC`Jg^hX~WB!eld1lg&g<THoy_6o+
ze`>G!@{{tDPQH}RaTzx_{GH5Yr^EH5X9^Ub>-}-j4yls8Gvhu}hA;197N0YlQh99N
zD<9QCdTpBKcQ56%_HQ>Z-`8K~w(F?ccERBBZfBp&?w=rbT3qAVt6D~wc5Q~x<sHv#
z9;klLsoqR+xmSKL$WAYKgt?)i!LHa3Vfl^16`y8PpDdhMz4dI7@w`2I`P$T{Za3C^
zA^Th{eC#%vHLH%iYcW_;Qa0XzI$`yEO~<T3${%EI7CA=7T^giNph$iBWc<eZ^xIxq
zecffuuS*zB$up#6lv59TUOUr2`I2l=k?nYXkEVfZ%Tr>fo+}yD9vFVdKvyQhe}(5A
zdbZoH0hRktj96&*p!rMo(j(>TW<4{#eS<$V@kWjNoSd7X!_D1oW3JY<2nuQoEsCJ_
z5t2F`?I%H5m3m~qPm!3FLd*D%CHudcPHDV3-m2=ZrGcd4djTDnVUlCAE&b-Hl?yt`
zFCT9$zq#aQhI9;N5w&CQqdf)(O!Dg|saILa@J~NleS5O}X}M&F-Vzt2m-7c?+ZtVv
zwxb42&4F~!hMDiXm{VodE@+=-ye`jcykfSzfnn2aukkCRULBtLCg_|rOs!NSSA+Q~
z=0lS%mBl`ax<tu3e6b{;%&Pj%v%}QyJG9nR3Ln46qO4|aU7cAeoGLIY+jo(Q=K7dy
z)0foJ%ymoo7OSO~KBhFL*ymYQ7qCuKZ0!%^EzMUA-)=l_zS?>I3>LMI{9ASNyIP5r
zQ5Tdy9#5H`Z{;jd__Wl1la9O}t$Milo##u(E9q>|`e-pjeu`+@hd~=EqZ}w+i#*?J
zoRb!!tSAc4^U5C@e(hdqv7x(KP=~F2$yS%G*<lIGUbRh)y%?lGF>uptUm2@K@3({{
zB4uK!`ecWG(ZkqVlvyd&>E~*d!j-oAwpB_SN?oC}G<gUHyo!3{X11YY;A73uSHXfq
z_lWcw*!Jo2F^~Os&bbW@H_;T`srB+)txh;gQ}hPol;R6Y=oV{{*(To9&{Ogojw|lt
zYY(}h`!Loi1GxWzd09d2BJ<x4;eRtEE666iTxMP53B}pevi;{K9Vx8zGpc@=acH<p
zPNknpyyMUVPiE2|#+p#C&GlQqB=MBuK5B!8nzq}kHWl-^NpvW~Dp$dD#H3|a4`cg>
zU$~QSU+Lr$%LlRFr~?lgy->J6XbEek`K-mlFo80~8DAeSlU*`ldXroDHIJ=k&=jQ>
zpEJ&t@n5UcmKGN;-C<C-gtdZluF$}0u!~8M(4s{Kz+kF@MBzI;l3o@(jEz<a+NM?I
zWO5*FO!(Nu;Yl^CHP@b0+{fRrZD~qJS>@Z^dMjj)D>km}C2lQRp7CDcO8B&0o+S<*
zgXh&<IvxBmz{@~-(MT8C=(BTr9rrR`A<Ig1U2<i@nzy@$_FAgHBv}6bxI491?~Hok
z_td;Jy5-I1iFQ_PrX#Y%)fcJ7w}d#mg`bgaKRfw$pr&N9Yj25tESFyPJCl6P;$}+}
zD~dk&Zc$YGkuRW7yuLN_1$9MUc-{-Yebny`@@JofD)lSryX)i$o3NtIyYAKw;M;q|
z$h9?d4n^F%X{w1?+$F(ePp_CmDXm7$Uu7w$Mrjm>C_HGSWKW1+8~1$O-P-tfdfA6H
zt|ziwmHJUWJJ!1v)uxvQnM5raJjG3EL*7Yg^Wl}&C6J>T<+;f`y|^Tb{Sp2_t(oqW
z6H|5eupWz_Ua5FcwKelFWpu?I`%UQ~Rjlxi1->H;<DxgbovJqD%-p~|EO-7V*XxQy
zs&v8&>IQ^azwmRX4A-r038@myUS2=o%b|Kd*7thT*fDvowTI?;s`WNWGB_}6rA~Uw
zn<K|Z_=w1t@Xhzv=<Ticj+!+!M`ZM<3(^NEF4{G|@~1_U#l3Sc#u!nGrD=ng)KppR
z7HAMROnek|m-3|oCd>FV{`WpYXP;DA=|`3u^nUw5GvKWBH;T6XZXJ1Dk>r_*&Wl-I
z`4ht*1nTUHtrQN;tTzkq@SK=zz}NI%H2aP6LFTa-^P3ka9qL+Wq8|+qh-uJF3I|RQ
z;BS6LW^uW2)z`6<<o${V8z4hka({`$@~GL=S+(KJn9P33Lb5hq`TkNXOQ#H(uVyCL
za4UBG{K$%^iF=aQ?h$*HxhbYl(4*gV?_`bM@_riCwYC!Hq#yEUq;4tMQD(K2vS=T5
z!=oq`W$cq1Xu6lHIj#oIGSX>#Oq^)pxhHC4iq6e3N$<a>=INGW+H3sPbYu*#PRxH~
znHPG(kUyCwDlxn11a;A|$h?OuGB<ow3E!tTGI`0EDwQvT+E>?E)hxLZ8r4RtP8(s~
zf5=Lcr6+a>`mR3^-_*L|#6w#3s*U6HN|#*mqu7nof}#98{Ao>r%91Pm;R6#C{7-D4
zn}`%&leKxcVxM_)M^@p<1CXzCp9%+6NUI;NmzA}3<M9t!d}f(Ly&6Rytk@E+Zzuhs
zety=2+2U=3uHPutncMVOvRKV(PQk1<8sSeyM)yAd;Ol^vxw5RV6FbVqA1FUwaPDk?
zSK+Kv!>hw&z~Ae2=7D^#)W-GcklO`H<Kzp@*JnxI|Ds%N7nE{Pa&FTV!M3lDi5c%h
z$tt^jQ2g_(Qxli_etR5KV*PN%aLUW7J)(z=Th2YP&py@ceN=vK)3$NV9}fAto!D^T
z0p;qsOH0>_z?A=>B+zjBwN=NFb8}AXtyn$p#D?|iy_e2%mJE}h?0M+)gC$~{oDCh@
zX89NupA3?1DEeYG?{TT+sb_K{m!7yFBqy15Cfn-l`U_Kr*O|V)VpebZI*jo}w|(Uy
zqZfYtR?b^4q8_TWL%?2<b~orw?HTGz)f$)tFe@@eUbJTFh4&re^i@bV?h=3UrK)*m
zaV7%ABLx-A;#TsvEMK|n15Ex?I_G!T>}eVucT6<c_PR(C%bl<6^o~id+DyH5%u`nM
zx1I39ul&<U>eZ61<}du54vSOXjK3*<vehV6f!5|}ty}Mx$eJC#ds~QHtI_fIapBHW
z({$tVTxXmx6w7)tHK5#dM6YCLA)9(XOKMgrbxTN<Sop~qFwIY_EjL+_gyuOvMX}LK
z)2iI`wQTlSU85aItZ#xvH^bCT?glE&5NbIzXv3Y_EK1p_xRM<KN``{TO=3o&N*4rL
z?uUtmO>51px@H{b7N=X;=DaCG`U&+=Ov`hNgEddjmU*h33@;b#EpkEnBIUz$-;4LG
zoJER*MPU3lQD;3HwEIz%IOWy!meGe}jQEO2dh1+}_MrrTAKEMbZq%nyNRm55+3tv1
zzU5fVBK}~*>mp~RX_S~(zyrP2Jg6CIrwB>jdQhJF#GRbpa@nlS%i_@Vo*6!NvrL}V
zJf$6!x1YAyntKU2W{p-pCkwMXwEcvl`JS)90S)F0n5QV}oR;>d%&Laj?Ic<3NSh}A
zRykkEZ|lbLs2P+MhxhH5b2WHol0Ed3VMeW<!2t=Kq#++i%#bhX(_(={`CE$1!>0|C
z7OQQiWIRB1H_Mj%Wcc2;BFc94J*)J+7v6drpKmH#on*MvOGwV>io>L1uBs9)^1bxa
z#c~_(x9FN3TN(bUT+zV1xmdj3alYkcR)*h}6Caza?mkuT+bp%_RLe`HTOZ$QJBVam
zzkHx~z`_^Q&B+t;?+>#WE2cO_<O{3T*iI*WkI<%vRkT*M2j&YFZQYc<<^84C%?rM*
zGBKfFyLV@@`<v5!eBQZzkThsn*ZZA?y<WRm?k@c`eNKHjJ#Ki-^64e-`(JkqI50Rk
zK*~nlt*^l8;i_(Z1$UgOy{)<`q{TMqvPRo*lP3d?o65x<TRW=a?fH3qO|}cM(rXoS
z<jehBS|oz1q)ZEA<s$}H_)Tl+ZQ?C*NIa+Z{JaT4RniLiv6t4;n=?&}wkduRm~poD
zNwq~#Rlm@kil2n;p02%;)386dUGJ@k<LfuQ52v?$Vh$~T%gTS;9IX4cUr@W&TTPSi
zyW1p8z9%?&$rT9~IFETO>iWs)*u0=wMpBicb^_trMhoOW9ac%V=O43kvU#uu-=tB+
zb3T5XEa1fQR~Dj{ZD&c%8?x2G)b)^TYxwk27c{a<3d=omcAQ>(`gX*dbhqg0kf5dg
z+qWx@jEECsxiwY$Hz&%r8=80sJ#}Ll<VZJ{8yM|Xd_+5Z+RfY7%p^$o{IF~{);v*@
zAPJB3wh=kQf|>_3=f*x>`>o>igqCSR&HdZ=Dz2nm8Rqh4o|s8JZAN<A)ttcQa_wM4
zlaG>5Sh1gTBsLl9I7z-TA9E-p;!1N^{3(gtUZoNClkR4}Y0woL)}mJ%8|fpv-z=hF
zUHbhggFk1jWo_4S9i@1>Pi;E=?DS!Gjqmk~NcuJ<?1S>#XR`%A+sVZ4Ja#&6t!1dL
z(M0>aikETP)QgEtS9CM)wn}Vx?|M}#Xov(~=@ErT4Q|&>wYH?U3!J~zFSqzbRG4?~
zadRaL3?=k#xxzp?y>3#T>vJ1jxz(fFd{f^F$t#?bza_ABMT(!;yNR-A(-w}g88oTm
zve1Oo9Xsuw>~%l>YKFw-keZ#cxsKIs77v~XiSM5DqOC^8neS@z+SUQr-woI!Ki{Cy
z?1?^A?pkQXNRwJy|0$zbL3=az&v%_PvsNnF`?bijCSTLS69xUHzuU#nj*eSfH8E77
z&heRZ{Oq_^i;TXt72#of#w3I{R<zYeI4>~Eoxx9)u`-|2bR<wW{M`|6CA<9c<?9{G
z96KiF8Craws$ym+c)R!Z*!Q#z^@EeOmUxca?DxUTqo#Jib)8-VAL_54`7G1XpjE(c
zC;Brp=<u3$C(YP<`F;nDUN2xRO$v$1R6u_W3|gi9yu9jFo-On8*jdw7ZoX=PlG@3L
z+oo2|gOfrwWu7!>mGgVNv|jgF)}tb~{0|vBSy4^yBkiOgvOM;xj<^edPM*4LN_QTc
z6tXe%yFsgr-)HoP-|M|h(Go}NQlHop3CExIovlH?rgDDb(N#m2hNh&(m4(#S%`FSr
zQYR2+>a(lLY0m}5_o;rf4hc*TJ+^h%OVg1W6ZTxN9p=zp75w2)Mcc=^%lyV~cBVeL
zC~x;<s{GRpyI*W>tx<m^+<WZF#fA>+-!eb@D&-#867xv+UdxSL`eKJ_&Lv3+dR2`|
zdR^nwf8LvM*N5*g@NTflv#n5RKkb*dMEKLpip=Pt;>+hBs%f&a%;djS;N|QY+;?1d
z!5$x#_0Ph_$oohfs=0a`<+Umt^18f1K6l=L$?@ZYzuqlKiuTO3P>vjH@FY~cX4Go=
zH=3z6E;;(4UuO%y5iAd$q#}NIoN#$?zd`x-&Tf^N_O^K|1w7?!@&<{z78f*$6z$od
zGa_bB&5E*u``!cQoEEK#i<!Yc&Pe2(-^Qf%x61TG)$D{1A2zt-cdunwWO&T2wNjRE
zhYJ~8?X4pIw6;&~hT5f}216n(<mcYbQ5tjM?PGq=w!Q)eDS3k}PMsb%HgA9Am9Xa{
z)m4k0d~vV66<OLM9t_QX>)_a2F++afs>yk*bjxO;r@I!`4*gi_>nf8wP=0Ppp^|LI
z+nFW$p^Hc5uWAt)B|mWSq`Vhxr7dgTizFJJzjZD+p?K66@6WrHIxH4i9CyCof2m5?
zf=JgFeFnbMo8UKbOg<}RVD+@M+V1+F_EpwvT)op$IP~^{p;wB==wH>Vs<3s`ux>XK
z<R5b?_4>K?ws2PPM`x3cl~xL4lJ>1}@@NsN7Jv1QFG!_qY+h2~_Bqcj%iAA~y(fPo
z)HXy!^6m#Kzsp8bHWu||Wr}QHz4u{#%cAOMeZ~z;xI8=U^6HVTBWgn4ywC4dv3;On
zzx#4W?tPzdaF5B<)G=>Oo}10^{k&{>T3S`6iI>`q**m_vj`Z2FtajbId+M)NJ5)N(
zU}o&;r9Ia>sOg#B^VhScTzotER`Ri`n=Xs%UrqI{YPqs8HLP6i-gmo0SNgnc9{Ti>
zvIxKQt3G}jO+%kvOdiy0`GQL`!=6v*n;(}nbtyf-?fJ)T1Lq`*KCx7&9qc6i*h^xd
z^Sqh5ZNW2qx85<elMOA`+#DkErn%DXt>a{cl?q2gg-@+#CFLL6d}`TEb=$fvw)!HO
zZBEYpZ!~&ryZ0)kYWlJRgSWq+*+$0Q8e?8+cCd8LfaeBVJyw>MyNNyj?6;-BcFomy
zQ73n&-qhL`7MHZ(v(NjeW!ueXg_^$FsJdsy?w7G4bam~ypU=}w&%S&j^CUURVf^Sg
zr)$b5%icYFXO&Xhx_$Z7ofp(%rav6|rB?H!klEdf%(^))_utp3ri`7KIHK*T%?Yjd
znt}t9jcpSi*jr!QZvA3Qs`TMwhi;{|1wG0v8QrKhq_MC>)$_IR<EvM-FOS-}f9TyE
zHA|IVJIFth&)rjzaOkppS@EZBh8s5w0#Za4IVVipebaMiQKRD=Mxu=6sW&QBPd0w7
zY4Cj<nmvu)aA<M;gVddpAyFgFgc-VJEErR_u|W97{@h!V7YD3c9ava%vi!4pYpBDC
zK6<T^F)FN}&2u~opT{pAU@5V@&%VLNCmfCG&aXUdT?^k{o>y2iqBd(rQ^wt+84q`Q
zeu!V$xO}~{_RPsI;`3at9J8J?BkgtD+WHTN*DKs<Ylv?eH{gcCvP^L^kK=d7*xuK7
zJ6<xd#!}*w?#DsaAL8W)Z&@`rCqD1f(kJ5+t{zI*n_z7jtMcg?#lP@v%Nq&fs<hxW
zb*USw?&=+m8mC+5`(pXT)Ab)`RPDcBlO<v~88yrxb!Uvqh6`goq;9Mz{5E^y)#uCC
zR~@=$TIcJZJ43yddUV#s+VS;jqK)xxhOP8zO)3u`p4(LrpJ%H$Ble#0<CDvF4fod@
z#HUjiJSS!NSnrRSTT;U&AN*Emb8Lgcr6bFCstmUED38y(EqnFt=u?$PO-?G=z56oF
zQlg(pK%rJYd4oD%!_pY_PrHsDnq46OP1>xkCFtFhgz1tON9r}cANNURgHQX{HR|7{
zYP?z&!}t=s-?(n0=xr5N-ZhiDmQ`;Pmjp~+QE0o_czA-Pgkg2n#LRCppV~%oT6dmk
zU7YA%wFLPzv&kd;_Bct{RE#JZ_T*i->=jvE)!s86hRS_V*fiHfvxLuGXr;lYEqtH+
z{U1h;QCUARCQfFus^^0=eg8!&$t$)Gye5*q*LP%C!lOXGo$K3f_FJa-{#*T#IfWD3
zYuhuA9K1Jt--hLULo|}|zh2gxe>N)W-5I-tc`;5JAxkq1vppYWj51DpbiZG1Onuwr
z8100%>9_hd+2)H#8E9A?G@~xLR%2iPxlh?D*`Tvh3u9wgv#v9|!==AJThN?de`WCL
zq=oasE={hU|7miu`2HQS{W7vC9+X#o<!;A*Uei0M`O!i_1-qQpbNX*gG>Q;T=v8pl
zy-(!!{A!l;fm8RlIu1D{_;7&#wcf>JpZ533+O@4itn|y4t>3n;dUe%t%rgrQ(JL>*
z`F#3%AD?D=cBW9|jUiF{7Jq(o*4Q9x(2`vno{vsgqL!GRGVYS=wim41C3h35&INTS
z-}1UsBX~%?-+E8OIeF5RdwLya_Bm&M;&IF%(KUf>$*-<|%s&uRJLsjEdd!2@HL!M(
z7*rdby|B0U`O??3wnVWEGrry*d+M>#+t2)!VGM<#rLQ%5zo`87jB?;{8^eByW^1AK
z(WHnoNmDLuc3u<Y=J57Sy>*s~*_4=%seR?L#q2Mc*gUIz?AH6?YYSgfN=Hb<l>B&$
zarRGhwxn9s&MtmB_?`dO_I-;im&7=3dE);#r=RTutqnu=>>4xEYk^v<(<1#(qOS+s
z);(DAOf=${Rc+sR6YJNrQtWJk_Na>6%<OlvB-qt{QNZZkdk6EKv+5W^^X@a?%H+lR
z-m*u`=!Z)NJoXjU61cZ0wAM#E_x98Q-(u>_<}?&HT+SVPqQvM_8~=bXCuq~6kQ|Fe
z0aH{;7FD&$IV_%OJITRN$lWl-O6?+F%y%n&bBiP1QQFf}9-pKM>hPB}lutcbVtvp#
zr772s+Wz8TN|Z|Ay5y^k2dAdI4P;45eV#e-`;Dn?^{S(0-O+MuxjlK`=B>9JZmyVi
zdzAh@&#);ooQ<a39`sGu=IFP%v=7aEWBZqd9o@dWkBY`>Ee-#LVY}a0z7v0^?mIAK
z&Ul%^sI#rs4`V+~uRT3iv~qm^w<%GHjn?^(Xjk8TqUS5zaMIjbZ`J>_&G@Q1=9bn(
zBl}D4dk2K}P9KnUjkao2(efwLZul#{{}OoMg`cY1!BDLs<?lzkObKHS`#L)G;LE`I
z`qdA&t(Ts2a==x?xeN6R=S)enk-T&(deQ);&CjK8t`1)FoOO5TE7fO8Q=ggXUca&5
z-{#QO8RIY4ZCyRlDm*YMN79OJbMM`UU1>M<@4cD5s$F<`uiRJrZzhbreQxom8z;x`
zjmpuUu`Qv@%i-m;dkUj!JXA}!<left!othB$zr^l(&<fsa}P|oU9)x9N7)GqkIxUz
zZ#2sK*2b6mhVk+C^pETA-S)g0e$B{MdPifP;|2--fe~>x@9sT0>CBu_pZ7OzKb^Hb
z;;ja2-fj(zqzGNvx%w^Yg+^ocWX|_aA8;srFm;*)bCY%g-}~vbG}Hgb*f)SzwrpF+
zcE`4D+qTh3I!?#7-5tAQyJOq7*|BZ@$vJ&4-v7>hx4y6T+PlVBW7eFrYE`m!tpr#Z
zgM^<4h%Dd!C^}5;W)2|t0Y*)XFPx__)z9q0x(9}B@RQ>bz)%;=;ds;<So@t|46KT1
zu46I-8KG!^oJa`bFGN|QF2m6GV^7EisFB`-`%;Jv7y}`<A37q34zg&#cx@75Cp=FU
z;sM~!7~Q9nfGZIy&=NoI>0t+vTEt|vpo|gfPog00+SQ@wO_WBSla>eu!ec1Pro!jb
zEE!0){c#PVOt7|zOoaK*N{m3?AiN?9#-(YzGmGbJC^Ik+Jzx)|yGE6aG`Ob!2(Ji{
zpB^Zuv|_zl(I;aL^Xv!+I<oif2x1^|sFV+c{GgH-1<?zib4nO%iy!hjqP90SMUUoV
zU~<5WzTMnsCcKB4Gt4DURf&Bg#}d@0ixL&qCRU8ulN^L2@{{{1G7=QK_~n-98^p3f
z`en{QL${?40M86Kza;?426|*NO#}olEh8$BQMJyVYV`sU0R?bCPqQ`&-i#Trp$J&4
zFqqf#OfN-@G*<M{9{RMrf$;tDSt%<a_hv+Q$oaz6QpkA-T`gj#)s(8y_b&)UT|^;>
z(M%5d!uQt+7>LgyaG25Y@~5@-!dzbsPyAIn+llNy!srTR0Gt%|PM{pn=sL=eW4U$9
z5ePw~pe>yU*)S1E(W&U=Dd~}6>D3tvNxGC9gn0KeD|R`=<Et>M(!)r|M!ys;$;w(W
zwRNM~3GZU<d+@`l&?L-xM5ulo6^1erw*2S`K}N$A6)u;ZIX@)&-W7se;uwU-7s}yY
zKK9C^GP(EV*0l>LjOu$jHt)BkI()0Jou`Cx_k9-C#*to;@jDOyw1&Pgx~|8hFZpzF
zZo8o)xLJ3kWBJ9<dG}$(DOV1Po)1-_L`6IOXYscr+MZ|m!gjr7-6^G#XZ;XDCV89C
z#Cw2dv)uMh3>`^2aS*@6#7URve@vJGlS9LH$GCRUZzL{`#eQjOt+qliD*0t;eQK-h
z&Sg!cva)th|2ToQvh>86tT8NjciY$BqZXUn)LPFTqv`c*xu(!nmbdg2u^lvWi;6Z`
zs_YSa(a-<*05&x-)mE(roc{wc#$v?T;@B7giyv}f2+a!N7H9o@5hW_?O6G~SIePid
zSa1_aZLs9enesS>wi>dI)09Cxy?TG-p|HaSg|n)zZ0eA6H7DG=8Zw@&thX`ujRRWP
z_)cx&+dasDO^mX$VdaPKk%Ba&+MaJa<)EmwuEkj4JFvjd5$9Xwi!BX4>WF>4XGq?M
zLoWmo;dq>~+J%iO$n|4_;Pa7svZsO#P4Qp>wioUrO4^O~-3|Bgd*1?@^=$RDOw|X7
zpbw?V(_wdcbRH?zWWhi6hz8tOCY;%5BexrwKU@e+uOoEAQ+CQ&IY1b{94@cLXs!7R
zo_{ZvLniNZulf8u=eUkl`?>Y1U|Y1>sigzU;-Xo&Hvx~Yur-c&R9V8AJ?4_I%xvfg
zObDob>4jN>Q=Q~xMS6(Lw=GYn#|u_Bc_*83V)H)F#yvV=MoMBxcbn8q7hGt{g9fr)
zmN!Bivw&DeYkLl9TC*^rqaq_QHrG&j3b<TCDy1a%-ti`uxM;4N4UK~Zn{WP==-1&S
zLghkH=sn_nQ#eb#u&tJOc?)+;7+%5|KqW95^mH(UH#>~Cq9z0fQ%H-O<QgmjR>wBE
zlx;m?`5I+yq@Ce8S4lsl-29%SMjvL?>HV)cYn{gQ)F0Z<-!(^5nboxXNM+0M_-K|B
zZ5*G_f^0ARYpZn{rMepKF;>z7N@zOW<J>u<@NdP~sR6x0@6-s@wfv4r;5w&}TG%^k
zKo$e75&-zXxGh6bOKCc5NQ_Uq-g&kSKZs`&HhhSRYCtxj;@+1K%nV|QT9W%t>0)Z%
z1<@|5YHj6w5VYjaZ`N}$H6;5U)v39zI4}}dwZzXJSEhs#T7Ir<&9xwvAos5OGQ>r7
zAn?tkB=45^JX45gmu@mr(=flUSKrdkYV%+UN~NWQ=nYy)HpC*=r)>{eU>Du*oaiFB
z?<nd62<DTRl5LNWUDlAOLsbGwk5T(>uL(6QAz^2)pg$w*wCfyQwNY<j*}eMc)wOI7
z!P45>T_`1E41a{il59S5eGOZ*q3NanJv8Cz;o6P$fwmW1S$Bx#bs&2bcXkPxg%hJl
z8wHX%2^O78NDjKE2-GwJ3Rz~5aLt-P&zgs(9}#mM9$gC50D2}qB8^ej@(ae1$Ri<-
zaXvk7t|*XD{0hlU6_GoH6tYUw!Z<8qWP=J8V_rV-9+(09c;*U!0<*S+fc5&;1o5ea
zja?Kg8iDs1^EsnQ6w`Dnl}m(@bevtKlStG$dA4;G{kreebI;p7oQ!IjdLK6!zp%T~
zN*h*5)N~8Qd*wdC`z_c~1p@L1sQaA?jxiF-Y5CcOz<#zfh9thD|79+9j=s~kAr-x5
zTQ=@(gdsN2v?Y}QRBvkKx2f9NJJ^eMWW2UXT3@~GMb37*8SW<5Jd}pr*BjZovPtRe
zznvgX>&3krQnF%_rp?zDvqRK1`vlv(Vt(LhkhpA}^rUu&^>~q{V`w#-e1rq1^<_8h
zfMv-DwueQtg;ATf941@_=+i{TP%tPpUz@@n1|g^3ER|#Y5+-t+h_BqzDxGk+3TVmg
zPCa=~iwf-AV~NA*5@Up>NSmg~N_4t!M$A_aSxboU&d9MfY2j;m!a6BLjZ?y~z`XEI
zIuJeyVbiC_TS~E^i~EBOnA<#t8kl><xeRg1G8EAI(75%tv1-)**TZU5FAs~m(q)HT
zydnd<nB)v{`WnHN*DcLX6RlHC-?JId*pSnb!&!scB9uPWQobyd#Kka_E0t0sl=8Vo
zi?XE3r6Lr&y>CKPG5Rakq=Yr9+%4}d`4D+1%|aV*ArNIKdSy<z4yK@92_$tZGF16-
z;c-{qVpNaMMr9pmKC6<9d|6>HO(PyYMJPgrs^?Zy_1~%-c!PpA(44$T7n$cGxmT>r
z2YlKK3C6J0?JBaAw9W&urL5;kCYS8)PGr9hI?kg$1KmOk2h1fzT05Idl{eRMqxuL|
zOcK`A<(ApL+lFo%EdiD&syB-tikm*DVKBgNcFlL9zxb-T8J265x0yPQDl}AUG18iS
z`HJqILZ7F+eGf9Ip~vT`Q2?7s-QwjojLE>zGw%E*9<x~7fpv<Hr<IF_^WZqMv*y;K
zbY;XI8|*%4Lstoya&yBQr8-Dvui$oG%YOO9;Oy>yd@*<#(@;rov34M%IUxL9<@t0o
zWZu~M!c$v1u#9w|M>@q|kJo%r-Gk4|;rSY;$w{qfX;kCrG)DR0$Tsls%M9GpXdy0~
zp=$e%h0f7ktNRPomlx5>jm-1@&!#Uy1CRQorCwyzSX3MRa=Cmps`GMZ8^x7lt9plP
zRJ6}Rt^IXB*g(xj7q4*DU$M!#<8aQbSjUq;huRGZ5+<TtHW(RFJm0fk2^={P+$5>D
zjGdRbNw+8?u#)zSqN0Dg-@W4^*lBazO^U*jyH8T5w)2SJF759T<NOL>^ebthPBtQR
z?4JB8jZ?!&Wdqomvp?Vhdn^O{Q{?JFG1KLwKOZOQKn^mkArO=Ps_jfw<^Ah{e6yUy
zNzE9H=Gkc!G`8Vp<iW`7k&Xk{&8mn=)G*Y8-$$34Go$JUY2?q@R2>C&!PpYzz>Rra
z?-m#w?l^-_$A;ln^;Vh*^qhp;QK{uU9@yh1VH?bPA~US8S_ITY;eAqB(Ul;00D=PG
z0c@SozyQ2<t$1=<O#F|4K@0#^i0wSSZI^;~^#9=nz(SkAeLIj%)+ClAW2;1yWsW@n
zgxEehKn@P2;)Z-QfwV}1rGo<E3^*E!0IgE=6E&99FFn9Ok0|7-YV+Bw)Rh7#@7X#v
zdf9cPem?W%9bw{;x~E7%6|05ZlI(i<xwT_fqX(`fU0))v^;Sj{^X8=ig!~h0fP(53
zmw*@*BQQ(S@(}B$B#3Q_0FOzkL6&;-FB)m8Yn=VPCtA8QbGo%yfnqfmsz}D6!S1g9
z<j{v*-L0*i4yd#nzh2kOziPN(!^5A8;?+@C;gRTxVxu4eyMmBMEie*yua-_+Id<T;
zg7L|m&nl27QIySBF>P>@!p;rk)a^eG-CkR!iysY_BmLqcG7&l+qA~DTH_#<XA>UpR
z+a6WE#0^^Lu+&v3=@qYZ-DekWX$`c*CA`E%wWCFJ{TA0!ScZRgkE&2dm-+SyKfg~^
zk(CNq;(p$>1U0%u_*wulDJ-;OeitsdqgJuUp_<(@AVMpYTBp^K+~QtUw{-?h-}1z#
z1CVlfNS!RE?O5{%n?etq2DZoaBN;+NL%ejQgzXwKWAS>PkrBDZ0Rq;&@K7;)m8PKd
zsg7_$d<<<2Dk7qPTnG}fZ&6Z++hBqUn6Hsy54f?dWI)7=a6+4~3%XG}qy|RJ6WA|O
zs#A@j8$F-EOY49FG3#sA;P%?*aGw>IRMMl#r*w%|Z$>x6Dg&A$HN`CR;&@7HHo8yh
zMfVTi%@I;7b=Jlh+#!@U^x97})92RpKYsGCbdg2F3aIc6IjWC^?Gj$2CoqAIE(qSU
zigO-yQeef4J3#=!%`vKGbPCTk35DRneGMmslR&%&%{e2GKd>SI+S|`%e?wu!Tt885
zoqKmqSDEg{Gl}29H>piIA%0Smn1+PV!PYnjLb^B1AFovl$oIxMc9EB2%#vVBflvy5
z+>qQNG;S8|ODm9XeGxU)PLjA=XvoBwUdR$4p>8zcE4VBNpuyo80wHG7-DT7_Z%-#v
z4L27!QH`V@uyTWG5)E!Hw3*u8!X(2>k}hs8Yt7vZ0zaRzfD&#9366fbcFX!dzZtpQ
z`Y&0p6;b5|@9}C9%n99-%m(A%_Q*~$IHy2W%MCo>MHk%MaeXYTtlVlL!9Ik}0^`So
z@PLS}>yR9c%{AOS+|5Fk0I}6oD*jclejNikxt6M;&e0Blh*|yJjK~b)VI7eY6@eYP
z6b5Y?Ka2$X!i5vc*DS~_PG}jp+kJg60YP|ks!Ai~g{P8Mt$K^VDt+O<*aj77sp^Cb
zuF1?1=CaQQL?8+$;HDcYppu$YdHDy9DMM(>8EH@$icHZ62Y7+@S|Ky2gxxd49^-+e
z#}WpmblcZQUFdy8u|i>vfPhNKuH<x5n}^%tm|$f_hJMr>gyH2j3d`LREw93Bb?dPO
z#ht-c5|+S@5>cmI^x6*j+thhuhqTiOyu(sA*%A$57EHQ%dWUGpLSwKrQfb7F;L24w
zi5Et%)e4d1Gk&f+8c@3g;{G}%?ZvR*my=d25-adZUuTg}K17mN&4l|ej=Gy|9hh~A
z3o=wWX$Wk=A+sd90R{{xR2Puw5%mHafE0vxRV2E^!fm^no8t=CU)^0p=g)RX)*98~
z?gN>1H>C!a#FPhz?zKZKYR1cYk`aa#^+Sd5I_xrc0y$IIg%QJj2j-sFW^p2~pdD0)
z3!74!gcYonW_D;6wGN{+r{f<(vT27X5NG7EGV6{7?wgP^C||X8!U)wSRnDSkFq)97
zb&ArE9jj<XI1&s>EGY6RU+?FNk>Q)e)^ZC)V3jF!o$`1K3PELzD4y8_O*}jz^COk7
zE6xzVfAL#^V@7JQePU5t4=Ar(@4R6Hv~us7t*4X3*4E7(`EtA2aXCqtG&Vm;R5mk&
zUj#Eny-YV_<!9C@DNOq$VfE#;9dGaY$+Zai4z>#?zrlop?WTGu;f5pOMmL5IOJVIA
z`Bt+#u3AvK)xEX>MN*r!2aI=pTx{m<ILSIM9i(y<00WVhHIKAiH=d?vmA~gy#Xv1f
zJ<iAAX?3_)_A*PtmFkri<}5b*tv6zWl3<q@(K!(5jx)?~a6u8d#{<ImtPo;qp#mC1
z0(=D%i)|l-7rBa5%8IOO_JK0}#+w9aT=dV!Aph|kBm?-L4gY*D@~g6z)-*o?&oVRf
zPv#n7Nvh8ppgmet=<xtR?_YDRU3j6L4ZxpYt$JtD@je`RT=211r+#JYtpDP4H<HX`
zB6`0sYzs{O{$0?+x!`x?L;gyVxtx<i${;C=8*5mBJuj(J))pHD+CkydpespgwmKr-
z1L)7$j*k?*6N%5lPJ}^F9wP^lue3hn0BHlh=;T}#sKod*Sf6b~uc)3lHYRrNRqU}b
z{geUM%h?B&DTL}JVSv$0*|ju+)Z=s$ZZF#~k5$H)rt<Ay3ne<GeI~h=f{;>gAkk`0
zxzJ&j#MjC7YZsqPy`@G(n)T}_3`PAVR5sc#>QG^m22`vW;NsGHsO_r_KvN^^e<-)<
zpl)YoOrJ$%Oq)uEl_`97gHkLPrvow8rVld6>@HViWj`{x=3$g--|D$Gt@D^ZGX&FT
zi@^G>*w2EeLJY$)f=?E(zaN`GNL342rh}kMo;Q{w>EWOV_4)e_GjVhFnElA?bKF<e
zPNxO>$bLu<0pBEm0*mijzD$qb5G7n&*-W-(cDdY+QEQgtOfpE|WH_><)JK-WJz{JJ
zW9*Neyc$bCA@b0m*wAKoFn*ht?BSRpE>Q7q5x%*4Q7NI0t;V<DY5cnH!3v^HUO-Za
z=NU?AKLll?fR+v9)bOYwuKc;UafYewQRLT~vI7TFu20pF?S9zcuX`6AwsI{2C-L%2
zKSNh8TXUEjv{1}1ffW)}D0)q}(<wl#n+{rEZ#jWiCb~P%+s!f^EUZYorgso%1_A2B
zlsCgDB~*@u4}6{GPEy7=Kht=c5Ib(^Xtm%@SK0RPkoHVhtDsEl6SwZF+gsF7QX)6W
z9eoS)jC$X%&K-g6e|{y_dIQ2uo9PV2y;%MJtue!t!>QS8(&|OT5RCizxCubZM4pAU
z{qYV&ukOhzs>f~9k-N$1dV_O&cu=TSeUuJj$1<~P%6=M?u#VqZk=lJnSJLd=WQWZj
zGxPaiSxM?C(~%|Xtt{t_qFk%&4N3b~@<G1$of~?8&4VcT|2Z#q=DDP_6_9%`j!gOe
z@FhdgJxBt@ks$QJaD<^1B4P@242p9h2%-eF`1~@}lNQwP0YSK+LAfpfZ;NW>K}vFE
z$S6S0Dw0NR`UwXQUQ1i&b?kT3`*prb$7o-g%#b<v$2K98o|s8D#a=$5wg9!mKlg2r
z-UF{dd6zWmt+vFT+q(eh!d#;XctSsOCGK89T_tX`)4aiWtUus&E4(VWK+ta9ft_Z(
zGPOv*2we}1zeeuEqCB>W;sxrg(;e`MtPk(MeSaOMd`jGJhkC}#YHl~0P5eAREI6?a
z=<V0uG1gD5?US~S<H9vS#Mb?qF1csIyZ^Snw`Vc&Rxv(aopRaqYVz}`;JIe#^#tPu
zY#%SUpomWt&v#vs?+$--^4YS>^%>k#H|h?;vth`UZA0z;4*V{V;?a5X#d}1HxMI(f
z?pdjob@XVT=;xhp<3`(->tf=C>nEG^N1=wO8`u5v3ca64WzbIE90G4}PhKwT=TAKz
ze4nozyH3ga_bq;|qwQkBU!H(JEFJg10jyq)-XN`lSG>ndB=hNY^*a{Hy&}v1xW2_e
z|Ia+m#tVqY>ZA9!Td!Z8>VOImgvl=z38iI2zzg_w(}>z*I$UlN>}Sq@*T(@O%EbsN
zCEceGPqtzZIl;H`r_K`M>b<6?;y$SDW)5_FrQ7<oT#us8^|H3-`Fi&DpqqZTxKA;x
zsM^8#NO3eDSsGkpiFV>fM7HmsHv4Ei%c)*_$~<o$Hbt33p4D#QhU|h(&t`&>H>2Oz
zKx<LF@A=iLO*u|EHjMJsQD*tEq`V3;^~g0?(t)3)o#goTt64Csnfk0V0Yz||yolXg
zJ5eaWmTP{v;BoEfJ+h11L_qQw{S8wsV{aNCR2Th_L+An6G%$ga#==+q$1L>vl{CZt
z-IY7FAE_4XXdV$I9dP*wOTf!U8zGa-yw35_nu6CFu(K%nR#|VxQTMq0bnLi0cm(TK
z{I8Ig*4Zr*F66p~ayEo12IAtDhM1q5$duiK4^qxO%@$fK1FHp00x`|wc<#LuJl`_t
z+?V#=x6h5iK{C(!a2{w>8??xLrc=T_BMyFnP`b#qxTx5O^L@rS_y3aOf1nAR|A}5k
zpbdn1*9=~1E}9lJKb)Q=XxlMg2c+7o4=n^NIbu*FZnu%6pariMuqEutf4}T5#|rwS
znvBO6S}_(aiUX`i2CJHl65TT)VkvKJjOdDko)lvhDI$S5$6nfYOAjr%4<<}p6djMN
z4uM*#lV$l4@*Fij_20)wkm|pGcKLCltz(Hj@3@xCwSK(nZRadOD{&!KMO=a?B54QI
zGoc7{`B|$u<|!suN<&VdxyCo2-=8FJw@4$!_7ONKCMH`%Gbq%z?TbXCgkDST3iCcN
zRi+5uVJ#4{8K6Q$G&pcxz-=eZlKp9##%ZbXgW;=qomnSSv;7&5{VB(~^Vo}4LOUh|
zK0YuXEC^7Lz6WyT#ps6hVJAQN&%ifn!wzW&P=^v&T2eg_z0yY!luX^vS0n>y8gIy@
ziP;B!;`m>hG(+?-!N7*usljCghWK<{8q9BP1d1y+(1H|Lx%MlKx-6;p^T8NF2aI}3
z_KWcuU@4#>+TavK4PbV&A0p(MbHKiHoGg{>7u~Z!u(6^u7J>-4CY98JN)HbZ^wl$V
z&Fp6-n@;ZQ%;HdnvL$evM5PpHsD6PtkVv}poW3qfWI^!4*$vP_x1@d!29VGY6kPMs
zZWds)B2QIh$*El8DNb<r;Wo1vqST>DZAz<#9vCKs;ke~#IR~I~3)josL|fgohi{lj
zumDA8<!iVGNNl~KQ+OG+dP&6H$gaO9p={enjXW)4XX-hR{)T$bG)*p57jd4w(coKs
z36-@WLtHYTY}*pHM~QI7uH3l@)jY3j_{##}5vN3aU36Oq!WA{zR-Hqoz=!t<7~~AV
zC`svO&-^H1qi!yk%oBg|x44Umx2Jqx-n{SQ_Bg22!zCu|fEI`sP$eiD{H7QNK$A!#
z3NnHDhi_uaAv6MU%+An~uKvYx2Z!gXXN*1+VofZOfQQ{jZ7AcI5Nk%P{Z~IFh4o2R
zHnn6tnbc<36hvD3SjdM!>Td*n<qdoFAal&&j`K;ou(V#m!Is{V;^{?PCT2U8cE}Pc
zgM3w>zOYT$W1N6G#F&kalj!Rxj?obq&=FpvB7xSZAz*%eAh7d-(y_+B^$!h&3^`)&
zISDsaTT2!-Pv1^IT$tLLzut<a!Mi)`?|)!Dirb{tA`Mn(o3-(?CP8r!hSS^Cf<?Pm
z6?`&En4x|9Zms`-nVdl!u}IZs{7e#Ibp58O(8C?Cd?(VDGG5TaMiR`MJ4x3@F?<>H
zDyHy~kFls!9DyTmw5N<1T}3!t4X*rvtYoz5L)pw9@1*$omk*iT53<picA+(ip(Ex?
zs;SaLLSeww#0j#c9eOMlQPH#@mK}CNi&QejfdOIzrQ=J(m1IQh9W8+ywE+R2vuY?J
zkPLMpeN_xe7>kV`Ko&Bw#dT&qW`wMP>Zo%pdph~8+ZN%GWf#KG-z=UoZM22OTNenC
z!dLo`lVhyaALyW{=7dg#>3+HSuCQ(fK}L>vL!vV_4qZ?r@8ExVLkvwI691$ip^>s1
zBpC%#&C+vFnfX8rI~{zl@H3!}rRV<OPU6+sk$EK{S|wP`VY}J_+2DY;OsE?f38sT@
zcD<ai*{CD#<+#FC>{#KJuRh!-ba<TYAxCAIcT$3;e*GwX=13Z~a&q@On&Y~$V>@*7
z<e409LY>tc&8Ce}IQt4Q407s9wB2UycQCGiEV{V5%=`WT#hlX&WpdYqzSmGom;J8}
zZ>)@4lnkj`l2_TMg=Tt_;l?ugZ&>EWp~$exvN;7o4xo(C2ncOJS0?$j8sSE{i3IjC
zG}KjgTN5#TDVvCbvB%j9D8dQRN&GIjb3g_p!eW#5;W9`#V&|mU%)D7XE}ZZeC=1@<
zzM$90lL~@i5lp@VFoGz;WQ_uv&0Kk_U(LXS9fO6I#vx(HlG-5Cil>&w4LE=DhA>_&
z@yax{XE{c`0#v3(!kd8?*yM&epoSvd<(BK75og0UHs!HgAI=nxq+&WSiJON;s~x5=
z1Cm>GB*dC(@w1l<cFOAJLu;s9j+Pgq71ffONhO#j9w1Q*EnP45a$LvLXSz@HmznIN
z%;1NUuZzY@5|>F?tQO7IIzT`i@QT0C7l-CNo~Ntw25&HPg;I)KMi?^`U6&4^_+>nc
z1@!h%&)1J;5%c_Nv99xM%H*!&A?FgH-QJdAEoM0I3m3}Z$Q5`E1K+Op!lyIW=HTV1
zugAAmY*C{szxLjre9N7?FUA86)0}PR%<L!#1^UF5*)cRmF7IZ5tp1RMOpYU;DGLbg
zWGJ`JJZr2cc%sWrdsV9b(s-~4>rpit=v;EO$4tq5hJTCugP<UsWbKZ@yV?la*)-9V
zx=Bi;lZ(1YO$u`&=JEQ(9<X+dv8P_&Lx4!Uld&XG%g)@WmwL;!%_y35ik8qLZN3R-
zXFC04hhJ%)JL`b2u*N;~&LwS1cRU3no>bK~Y+ZR~>xO0L#19MwtCJKRiFGQLU9xi*
zJ$d_QMd{m0La8C~kxOlSX{7kvIS~ZM_W_W|ak#SD;>WK!x;GObk8>05OIpjoajD8r
zi(=?8!;V9&v-i;Dm0__}Q}W%_C+sHZ7U;T;wHA6E)w|KiqsOL?&T5qfl+~vrgVT0v
z^r|*NTD&$|Q_P+1Sp~5wij>n+;oj@ohn-thSr-gD2~I2tuho+QxN-;WtckoDOC#75
zyFRSoHH)-g!<Mr~^MIG$8z{2AnNYu2D`V>UH2}MVsABwbMxePO=gVP8p9_JP@$VZW
z4Bwy$*cXBeRr@@sv9WyEld>rp`AlFPlP`D0A~KIsv-e;R&xhEnzahmuX-=kuV-J3d
z+x`;j%)RI!d%oUCWPN4BEE_R23!W#V{V0#l2w7Py&lXIcQA9<+;iv0YLIOS+FIGRJ
zp6@za?bcD=cVYqY7D9g5U@LzX^3}1dx@ZkjMds`$tLn1S)A}RKvbR>y=q#-JD9iD+
z$>>iRuvAvqm`@M<IBuRObI6=x02)D#3gi3GKNCOW{JQb|b+lg=1LjJiP>h11F%$mj
z7Kdk0Pu_jB%atO#?mi!z)Y)jnkk|UnLZ6zbHf)<)QK^Gyj<6M?a@!WKEqnrkt8@?N
zIw6|k*TXWq7|U>O#BGs;+qqS6V<D`<oYvYl&*HjW>QnG`#>^2yeXDhIuVzws+r8$O
zK%o+dM8t6hAHps1Q397#_@IS=@Jm8MIzm;|7qZO7_9J{6#-Mv_Gcg}7SYDzy6)>j0
z8&Nrp9i7V`ns6M!=Ox+{(L%e}OS)S+819+}<mJ&SIu~82lSpmMzTYVgzJ$T`BUidZ
z45x0pJ9r4MzNK5=p-F%B7$Kq^Claq|tSiUvLv(X|srC$A$3>bi@d-g@pcJ#sibzCh
zOvh4fQ#W%8yaZISv=h8ih&8%uiF9*@OzwulKD)9Fso@q{yu;WjhU&UQEITiWJn|WQ
z(iIh%)=EIew>LlU5=!**)L=Pj={oX5U8G0?7Y}LaP>d3p*ZR4G7|0k#e>bTkz-N0H
z;uK2Mq6d2ucf8qT=@9LJiLww6|Km3F$>aD7dALB?GU95BS|qaEkpgNY;V4x0G=$n`
z69xz9G?W2}7=PNBx<iQYRk3V8LyhMkR3~ZZlKP{jJiYI?D%W%b_Ieo-WIIe@>D}fC
zRBI|r;m#AZbQZT`?8hexIGV&`>-_Q_LSr4sV&DY5XDI5H;E)+)Gp)=c`AD13Rd5Uz
z><0&`hb+7b4*Dt2%;Kfg9P&w%^6FEirKZB%{GuLTlavQ1w5G+w<6L7z*EWX_cZmGk
z#44Rqd}-*Kc(;{49~Pp1+u9`Qf!a^*{R{~Vs$Siamc{%U<lfV+1b@fnAbt#27)W+o
z+N`9l=!Do5fo4`=mzhn!S-;y9>)DxM?Wi}Q(MarFvlg)IB4%UJXi%q8UdWBpxQRxo
z76)e+m`X({N3Ir^-lfe@Em2PXxEnT`ugq`-qS(9AS7cy3t$blfrn2p!)Ejw6q(aPB
zRAkU6gTkaGiNb`H8<t!^rZSVRoKMadDs9^;l0R@Fk>5~PCLO(wuM~&LB(lb*w5|0e
zObRx6v&uW4oaIZ{Ww}Y1hfw}N{Rnbn0fExC(+`TZ1=W00gjS9Gfd`{7Z5}0Ud#2u+
zA!IhTG2|V$e4AxQ8F!}Mde#x-^(EK*!kPi(#8qj9<uc()voCZ_(XAn-URML<_H_df
zBDaKHbZnxx`Jk_N`Wrnln#BxK=CQtn+~JiNAOengvi5gfw@Ink+!)8aCY*CRJM>Vo
zVpeD8QK7MrbFA!NVmyzdLODA$_}w8B8pdwnV4HYO&6MxFK@AJv)F6;Ndx_yg+|7oh
zd^L0($2QU%{Gw4DXt%nEb#sTl8gUDGY|B|}FA5OTb>gZ?rfk9oF-#$>&+XqtW5(EH
zMpVP8Msj}U&S^WUWvGncbwww-W>M}-E)hp{%<-Eh-)0VLiNM9I3$KuP->!yTe(PKO
z7@yJ@2)2t`)%%O_v81I~4C3AZ_e6!JX*&c?>2T{l9$BvfQF~b=sZSvPn7)1A{%}Xe
z&-B>ps_{q4qj9;ZoHAkw1p?g|5i8#~7MQ?WQiHMA+8$1`7r!&wxXc5L{w?TKo8gcC
z19xk_gXTcP7|^?UwX#Twx_s;C1Fa?4N7Xz3wjA(lPs;t~$-(u}{bseOHA2rb^G8$`
zPZr^s2%f@nuKY7v+y!Te6r&haC&{T;Ds+lWCg+Z6Ic7PY<!{!|zzS!k32IgSH~6<D
zr`8@T{&i|c{few>b(Sgoo)E9$EGBV9q6jqj-R@DKwI~O)fzNrb2NtrCscH7i%3k8Y
zt!nGYB>NPJnxGEP(lTVyo@;&7?9*ccFh_?4*C!3rVNwe6{Wh6LOWpT^SzaC>%u=TE
zPpzoUWeN35JUV4%J?)q$rlqJi0m6r}(QHP|eS=i?A+%G<^DhdsA?YOX*AKrm7|S1b
zf1rQghnOhBBjx@z%pn?KCTs_R#vai_F=af?6g7(GVNCxf)3yov9jR#-L3v{cS-E8}
zCsh;8bS-Z8Y*mw~l_+XvXy4`tEVIhE)SmXqS=*><+Op<5P)32?+hVg=s9tIx5wX;m
z1*B`ty2Kk(x{1pgCFvYr1@uMcDLjqf8KwOqUMr7gnibx)muO@tRonX2rKd68y{?i&
z#n+MB6ud<X$8zuf$RifM;`!UagT+-tx5>zZ-q9poVGqlUWZh?V=|nNs>_<!BSre?+
z?2#?yJ*QsO0iKN}y7@D=M%_{-o5%)TVPjMs5tQH~DgAHSbmqgO=H+|L^EU@92L79F
z<;h1Pqc<9(H$QfpUSlz4L~VKMowdmv&M+sdy@bczLc9)bvrQ23R!y?GhMwnGL(|tn
z_LUjiUR_@*N_k|j#dOozvTuF%MxDH+3Ud~u`FW$*L9Q^+%F^B72di!=Glaf3c(Zlr
zz$<-9f|QxyXw}&mDe>0xb`RuRmVG-h26kZEXzd+J?gl-ZaTnq`KVwDn^sU>1o4?KM
z9<_i?_8Hgg=5<O+L^M5I6K$oUxCjITv0lhReZRQ)j4O7da$UbEs00bW|H}W@eZTa`
z|M~lWtB!^Jazjk7+=W;AXdKCK6&Xu%v2eb#$_05_^xoL<YExh~`H*o}u%KX_J>Pac
z9Y7mDz_;L@W<6shu>}6iNzcdY1Ju|4LqdvS4du9t7DA&KKHBQf4A8vZ+Hwq%#e5k^
zNELVb$VAVPER7Isvvp6Oo-p2C%oL@K!`r>upRj|M8?=p|9FoiC_U_#zyzdE0H}R9k
zav0$jQ+pMV^1};$!Vn=PI!lQ7nIJ#cc6I8UyZ?0S=sW}?;b`p3eF13e82(A!eI|9=
z_M&-!rKil$+06L;Vp!?N)>rAb%6nXEf0_EJxb`=^lE@M{?{fM0XR7?O7em|BTn4R6
zLg{IE{p(uymy-K0Xv0PtxA15Z@J>uQ!v%D2`%Rx>9}K0}K0Sh@0*9*Uqk@Ny%dSZu
zfU6Qyr`7F+c`fJ++@S*(v_|-Cylw%DE=L8#aukONNx*v~ZZ9wAmO^k*Rpg|fc2|X=
znJG+0X7a&Jv4`8cLazE%p2{4s%7HgKwVmElLl~<lRNZaiU7O+U`NK2f277qLLat`1
zRF=tgnS>_WhQ@|74{rVJL3xq8M)uGhx2^x#i6MM#TPPuzv6?}~Q}DS{md~Z3*PDAq
zSNb9tKt$vfJ8_%9i-heOz`HDcf9(g(C8g`g)(J+dM7voeufds$o`Y>Wu|3)4FInNE
z7xyIGO~;1tBEU(kSw6n5VLA5fW=x(>lTPIcmw8$v$M9n?u6D97VkxMIj)a|P%6zXn
zpBbfh3JbEupa~Nrcb;VUEE!GQJu{m_ov%4ZO=kSbxh~q8WWu9(>38X*4Id>JzuheJ
z!Qai;)sJF;I3&B=9FW>n`dRE=!J#<X=>@SmF6Eh*M&at9@b)Ls$}X%Oh@5naTy0=|
zTB+VK`_4+QE4*0M6n=m1Nv92#sFyYw_%*man}xY)`qS|qPI;WrX)B9^U_kOw0M2Av
zrV~P9=gT9I_eB`eInS_%blZ2?`(#VS7BUi22kY8h@gDxnNaV6s<3dUz?8(B3)-?C?
zW>mbRZs${nMW#tP0+FU!_W|k#<4IEy9qlNRQ46IP3yJs5O+<=Lk({F&72qCE2Ullj
zc+$AzmO$Z~nZk^nIZp0L=N8wBiq`&Y*Pil@3;jlMK`J{tRRLI(Zjy;woxWYHu6@Ap
z9%X9=SD;S1hk3}M3##1fd>c=N992S|#!KQowBJnKQ~aa9hBh0+YcnnkQ^17ek6hGS
z*w$NOh)u}fpag<=a}iIfVYiclFrE%NKA#}uqvRu|z5;(=z=9*HuF*?G%=b3#m%4i}
z2wVEO9g<A9730~1Rzg++eD*5OqY$7Y-(67B)L|v?%W(TsN(hGZ=+Z=cuS}e|Qz{0g
zqm4qe0(FS<!^A=ba)ccG>uZY6=rRc~{MW)Qwd(<QjPk|0k)KlPKf5ko(!gRh)R?4-
z@t0%Ic&1JPAp#}bKw?1EjI?`qn4ry4K!%7Q%`0M$%u=(iY+`@B)OY}z1xVWA1s`}7
z_9y)Wf!Jlir&m8LZ4;Wz%H2)Ft-_vk{ygT`l9r!!39Y!|<*%2_WQHSUAv_kGrJ0*3
zaHKD|y>l9D$_FguWdBQ0@mRauCe_`ISO(0r1WX6F?!Z8?hwn}8v8&#C(QU1*Ozpx#
zb33vd<m{MD`AsW8+*Ylnhvbn#9myOGcwvmbb)sRJwGPc0lE4gmdzpBIh3ePwPzIzc
zCERxVQRJ;8P>s`8!>GsJeN4>CxF+4f!wM5^RtwD#^%uM+p;lB2*@&46et;tok>iqG
z?ZV0jjY=?pM|-T+RRJvne<n3EO`*ZW5ah)^5{Wc2j@1b;CJ$d$($_w^+j9w*&tqMe
z7TV?&G{dS%3RBo$7@ZqyXf`p%)8G$6Dnn=<)wf!c`B;i%92a=_jTT}7ryzqY>UuK{
zBug_jSmoJ=zt!ON5e)P0ymDVP{Q@{B_TO3|WC8)uG7K70kP5<l2I2-<t&pzPBg3o5
zvgGtL1#khtW%Whg4B5c~m>N9e5qELW9r)pA=JhM_@TbOAI|!tyMB|UX#?PQ>d2{JA
zn9WR{$G1=&rvdYbF4Nkj82wE1122-^HpC6Z@SN78^>T6S1@2!=Pp1M|R_%UH2|8E#
zN=C~oaXf?;#OBY)_aWz~Tx4#`9~Yg(W<Nus7+s2^`8ORW(rg+)9Zzp_L$~+c^PjmL
zggU+aY**AzGIzNl@k|X;l&WJ`yDWV}cghzKJSl%(dO5&Zs$>toc-h<d^~?MG1h1sG
z`*Ip8G7%`H)SF|0G3*VTEvj#g+v`_w!Hp=61wbCmaiK;6zA7oHJ&e5K44y8`kT>Ag
zd7oY1D(DHtHf`X>UAFsuI}Q|-(7lR&vuYoTZ0wMvt?jE0MZ3-fd~U@ZAqcW$>~);+
zoiNJwE9gi@mQEZhN>3~N#FuPeTyg_EJaP16WWyF;ba}#`m6*6`zQ8=J+2z~8Fk6+{
z;8(`>K@`;rkN`~rZr2W;^ZZB_<Vl<^To#J?4TLgPMSS2W>dly^EL0&3D^>-!C^kzj
zF=KS*cfnWVg`JyK`8icU@#0c}hpzNikjKGC0?{jMg7a0OUU^%2mJ=djO&}w6D2a%z
zghsIwKz$wa6_Tpzs$&e&sBKGw-r0LsTzczh4JdQyE^L)ZWs%FYSoDnx#IEXIXXVs-
zsGm-#d0)na1qyFEw)i3QRRJ!gAaPTq?ij7J8mZn~`*Lg*TRfL(kLxd>h?rn|>KVAe
zUZTI)Gd%{EDuDd7L$%6-rE#D~MHv-N)HE(DtPjQOiqUZ%WN6ZM(#v2|4D`$D`(c$W
z6;Rx0oI*08hZhyfyT7FQ9Skvg_d5yE?im!(?kEdu<!hBOCI*Z!FtXb4+G%+4H*Q`q
z)-=;@J}z{y1CKSy0yYKh>Ud8jRCa$55t+ko-uNQ+V@IN_u7eGa8%30F_AS1{9-oty
zB-k84&k3GaqtWG|zWB<35G<?iji2!uA4$Q;vk3PbKB^$8&^lM$%?aUWFz$2=<l@g(
z$|0=@`}Y7zlYbJ?7>E@|3*R*A%`Lv|Lct-JVM!TZlFzbRQ<mRY;IV6+LgkrN!1>ui
zi$3QFnG+$_`y3>U1o9RQ@Y=X%*og^gie5?b4RwZeZv_6QPS6AUpgoKZuXprt`CAv_
zeo)}HsJx#(=2#4QU7I?Pfus>qm;M}co@0crRly`b)zr4HOJdVrXEg_HldHdGG}J0k
zIpSUlRSn0n({<ZGVTD5Nnm}^qK8HYk(YY`&Mh|yt$^u%Z7)?AMt`#6LN5KlQ0AVH-
z=v^^ZB6o5#`FYx*fjWq3a-=#}1wRxsVKvWzRV907^+>(-6Wb$fRg!EI>!zO!Az+@T
zAKG_~HrRz$#l^`4ZY^^8W2YGlHxkaPCZ0|Cgc$<*1+GnF@={!YiJ7IAvG9>ED!UL2
zqH3&c(2(x*QaUovP#AM`X=G5(ocu5isXIS;5LLJEq7}ppnhvYZRvy(2u0~h}c?;p`
zvD5@-FXP}W)N<-@o$X#&WWw+=p3(J`b|ynlD#=_pn<XUd6TuH`fh8<i1U|9u2_*3<
z{diijW`ej?K7|9ok$<qA6$=dr#DF>I@!1Ro`H_(v=JyOhvCwa_Y(2)qLI15xzz=*%
z3WNs$zkQ#9>foDNrR|qk9v0!b{UzmTXR~{C8J%NUjeY(nLSvQ~ag37U9im#PvZs3m
z?<yjWySxI87SLZZ(}vM3^zE=%Z%=YF0A{&8te<0V&6a&ihC`{x`9HxJJ06`ju5RIL
zyPR>iC(>OTIqZPC(l^l_%I^{lC@IeB<b<c*!JoZ9npo<>Ad+TkT$4I20T;MtOxHHG
z!cZ1$S!~{YvlZY#w<)Y4TrbRR7jHT!y&+F~ZaQ?4^oShBM>=gm-&*6`*HBAZbP=95
zbT|z)l-bM`67E2i>G9^&C(6IPwKmB(Pk`^g6b|``xmb}kLsEM)uv>c*Sv~5UK#is-
zNEO0l<7gbV-n>JuUeVMX<BVfxHW$Pvik}Sj7rHC891$Z(N3~390{$8>CoX#uSUL$@
z(wVKK0BReJce+F@CBT#^3%jK6(N=#_vFKyd8v-BcLpBQRH+!-sy9*|kfQ(=qLPMU2
z&3N`Iv}ML0I)xEM8$JUPlXpkGb_W7D%T-`#UoC}{(`V#q>m=O*QOhCiM<LzBAMwsa
zhb8zgpfMa6zh7#kxG?mGMq8^s`--N7<;)|*7F4-pi8l9o__9ap(dW<)d|E;cmN7rI
zb3P!$q}q4ZB)|)2h~eY)8X*Nlmki&Hf^cVl>`H4nfjZN%<|&zn?X6m|2Fh6O*osqg
z%Q9U@dE_4A`92fN#xi-x)fMs5x#tP9h&``zaV<8TdaAk#)a??aIWp{yt`w&X3%nCA
z16=mV-%qR#Le{kb(bZcT#*4Q}&rj${J<hV!9FEkY!{gnzYG>gUY>|`f%favWi`VfR
z{3^-z!`Np#n28`dkyau<YendYqfH)r*cAp#xMo04`^SsUK-)~J;z5Y05fjaD&%_^$
zU(mdwnj?0z;tdGNk!EMj0O+hJ=PkCU)?CxSAz9bK5L!1AswTd97@8cYXxi)<__!0s
z2k1b>?|FfI*FXjN!DI<9_Kmx`kz=*e1&}>Q)Jm=QLamUJBo4f2z4OV&eNi$LH;l!M
zQ>gEt=ZCgDyZjACn%>v0N<RJ{%1j2q=|zbn#tIslx?*f;tc3{-;IH;7_rRf_TIQJi
zIkEi49n?sa;F>5f>YA1mLRS!J6$($8DD~IQRU9F~&EV0$ro7?Rz!UM<k<rY|ihtFp
zCks}3>WnyzQ3Cl&0r!{#`819^Xb&NVz<@rD%??@-9plBBujl7l^D8Ms`ZR4;kL&vY
z#)fceHbCD`qwMZc1a5f51sbJ_?eo@ig0~bjI*vZm+5K}sByDlWG)ltJhO`Y{Brw2E
z&3I^(=_L~Ab7mRvI8r;na=BSR`tQD&G`}2Wra0traLw|^v-532ty{)y0+THRT;6m6
z;)o0J<(N}9KLK2P2H7wb5fzto>7gB*4KRG7#0+FAj@RnGHQxB{Hqtp88oh*K(H!lD
zvKaJ9xHRy2sU#t@bKXrpA1lXoQ$ERL?oFq_uZVGK5>XcejIkM#+F{3I7hg+O1Pzqa
zF}}+jFx1!L<|lN48`3y^u5c8Ld9Vxn*C1pc!!-R2Q4BLh2<O+u87rUEMXT2D&$Ixj
zw9!DHMI1qP7bGhY6tek|h%X6g>oei^0+MC);yG0vc8M+QC6Ylv-ME}9)NC{JVJ7Q!
z7+L%rNAl>8UE=tO@{m`rZOLdQc(ruA*2d-hMEPip`*WKU9#zP!EkxhW0G5@=W+>@w
zGPRo$h!W8_uWxbV(e}x5Nc<)=nC9SZ&RSFO;Aivv1rFY7AGa(orsZM>7r$IyZSP%G
zvte*-Uo`i#M-CHbdmGsttRCGwk9s)W?p_?rh}4}CzG7KBjZ4H^#xN7Cuk(;BfBi9?
zvD1rH7ZlP0IZgaU|J&=iS0g~SFZ*&+8gUiJv3wmtuN1N4FZNp-CY>my{!f*;Odd7C
znzfwYeC&)iT}m?K?m`~?N!We?(@AgTh#BtQ?=U&nv$N<^l+lV+*1(NoM$h>!eNsT{
z%*A9aPl3V+vEtzTw9Q;<s5MtRN0hfR3-hQ^u@dN09Zs~G85A4z<01}gdL<$S|3+Iv
zGZ+M_Zb#xOY6(}+k}(XU#`_!6k3igB>tLWCOlt=KwZK}~2WFK%OfeNxo(fQ>8*nB2
z3e()jsoA*B<0Gy@<-F(S0yWpHh0eKi_$z#5K{C~ngrLdNRLnG3mDOs-CWEb>6UQxc
z3u`^dAtb~Uc5@c17eCIeQl-wYClQHd2W;$On`YS?C0BpCoe3aYofoy;aOzisyKgF(
zXTt9rE?Uj}*pbOqK!aNB%)*lqXCE`na@WT17Ru!g=7*PK8QxNY>9ebvaz5SXqZQ(U
z%CQH7TTDU{m<!d-4wI2BpJ+p5P6?1a8Im(I#iWypDIjYOWdq-uZ%uOcIuw$JOSq|m
zm5I{9cS&<*d5rp{hPBvPBv*V!2aJ+`&#q^+^%K3q&WG-bmP*xad1B`V2M_|Y$wV(u
zkB+bqAG>U{1LCQJFpm=-0E+(H0XK2)M57|2QrCmDr|xxqELg)v;q<5^kVp4Wa`=*3
zJn@KZ(COh*t`*|rOru)CtW*R|mko{por<GH)z2b|T&iL?V(0b<yQ%aW39i^=M(|K`
zK@wk4KwPHkoc6D~U)H`2+m7w3aKv!A4FfSeu;!k6=1E%VGT0SpZ$o`Mcz?L>F|~7(
zIUjWaE@nphraH|l5o&7Bl(?r3e`Qc4HGu*;&c6pRU!nr&)1ZJE8^9Az*En&mO{czT
z@S_o<B30PET9U&tCvl~ha6!;m=Iac22HiGl>6Wd(9+{6()#Akzo2MlkM!Y`tDuYLW
z=FZ_zfUbBi#3Z`AWtze1%=dg2GQDV&(bVSreTKlZV#Q*`Hi_-rksblS9Q~iiQS)Zg
z05L%KDOl@Pg+%ZF{et4muK!MPT<vb_wnJLa#@Nkz{s=c9YD9M$Hf#R6Kb_;j{b6`P
z)@+cV$&9{0!p5z$q&1-Y3pBT<ATyqh200^&7+iTNy`UrWkWem7n&h#dZyQdX*>d!+
z1z6W-LZ5@1t&;19{-62!JXv*zDPJj7u}V3xX`LM0lMFLCGe<74D7?EoaKZQJC{W#=
zc1F+l&o<eq;)#_>_}~9TV3C74h`YStry|JFLE3o<tg}9=BT<_xiK$-GECmc;V&#)S
zjIbubXoX<sxFiXsO~gLKh=-B>$f-cBWFv;f4KC9@NJ5<N2i0i0&)7Ayvk|sl19NhN
zV|3mOB!|4rQGrel!BtIE6N!yH{Lp;$vdus>bw}-QNfraRP`7<s9FYD~LZJMGqbr_;
zs`c3GwV)$QeEn_SmK|O>fI<3tIMR34>_uI9@xwF1)ZZ7_t4h~n4i7=HrqO8?5~gai
z&O&RoRNvCb$d*&{sU3d^D{mpl>i+Qiwkpm7EE1hnSFGJEDNi8S6Cu2>$Z3R4ve$G_
zu(@C4ab4wjMf5;iQ70S9P`CKCDc8wk8eRpdz-H;hp{meGs#U!IEm0M5qnY^x({)Q*
z0=!yD@qD^GL$kit`?cXRT~=SJyLuj-fk{TmvqIdmg=3-yPm5a_yiLkWBr?6z)!eSD
zVnfu(EyIc%(gyNtHptXC1X(W5Q?5s7oU|c_ej#clr4GSyy?5t51K-B}O+3ZE-@F>$
zyv2j+MyyoAxf*Q^wobDPp0N(@J@~fjP|q{9z)Mli>tW^_FeyVe)}Oa&|8d{859t59
zZ>unD-c64%@&;mIXev~Z2M>{(SQoq&(V~d$OC1_79NT`zsfgEkl7;L>&&9-5JvH?6
zE(a{epA548bykB;1q34pL&%;&H5>GrHu|6wp_SXx0uj9n$Sdu&Li{^O!h;V)aEW7m
zn<)_MT!V)xSYp;!5h~Ts*h{4j7ivJQ61L_1oM4{i8L2jn9(Yfyp;tv2zIfpA6B(}x
zfls|?CqbP#36j&sFm>1I>}NrK6`|YF`qGjIIR4Y8WWJ2~r(V^qhN{ru>3ol2daVFk
zirpE8eOMQu&c>LLy-XaOi~YqvZBfTqbjX3%)Tcpgn&eJg%B|HNE|`8t=J!ENNQe`k
zTufGl0-u3_mVuW3&vuaa1O9sjeXs8z01yCR$4A>=_rU>we};T-`zXkN9smH{6afHT
z5CE}Yz#*dE$=L7hAN8Z)e7p$2Ap`*l!Gfv36W%|5VB8<=?}hZ^<u6?SpSbo%`+NDj
z^FJ^^H+ktlEQ9~CVGrvs`^4|qNBt;;@Abonf7lT52L?+2)6NG+`U86}Vej?-<N5r_
z!+*yd-s?yC*b4Y>JRpTXNFP2S{0`LL`9%L47yl6Y%V!{=f1EG>8%O+CT>8&GeCXT!
z#{Y=TKh9VCgYe-C`foh&{r$i7Q7i)39|XwtgZRPY|1Wu_zj@04yPo)8dQtzSUc-OM
z+xRc-Lj0cJ|Chh?|0PfTH}60B`;mwH-#m=>_y5SF@}GJ7h;Qa^Jo?>_f6K%B*aHp*
z{Db(R!w>u+008iJI{W{nPRReEL;oB9zxp%rA9OzYd;S~$yYY?ihqC|xvL8<UV|+^d
z!(aN}IOV_MMt{cbLtp+k&i${r^Pf2Wdz;N~-05HOkNIr*PmQ?$pz&d&<~L6DuNubx
zv@!Ev*tq}ALHkz?#eenz{o?}qULHR3_g5T%uYo=o#P3ZVzt3O)-^R!6KgY-C-#Y)>
z`1tU}=QsX$`N;f@%fEB~(GMW0KRWtxe#dY8@A9$n8~?j}0Dyf60|5M|d=UTU{BIf`
zeGvYQ|6M-5{1-MteslgVABDg1zsraGZ~Xtt$N6vG-{k}0_j6OEA3^ym@Bgx<(f`I3
z{}l(4`A0tFf8&3b51Zfk{}xO9cg?8Z_<zbr&41AN$j8iY{O|H{{a@HX|5)VT3+l(q
zUvc<znfznzXa9}=T|PE`+xSoUz<-za`K=@Rv0nUT=i?g7{pTF|;N<@12>eeD+dt>o
zz;6!wJO3X#_WzvE`@eCqf5m|W{~&zK=l{psdB8_id~bhAXadp{MMVrz6zRPPN+_XA
zZz`CC5FnTULa5S3MT(+W5D~FqR}{OVsQ9xhDvA|R><z@;-#ats+<o@hon#}v|NVR*
z<U7wjbLPy<nYnXs!YV0mkZ3;Fjr!7DHcq+h%V|-~P|;k7b(tKuAnMO7(Nsb^spYH@
z(}!!M+~;qGl$Yf1ZqZ%n@g*(bWh<G&NMtnnV)|f6G`<Z)Qw24t6+(Y|Nx9G8eM$Ih
z+PzBbv@j0oc!0HGla%+s@{}&&{M#<&y<*Cv`?Gyg-Z-WmCxq>&UfEn2i9B!q()v@j
zS^JFx^pITtU~s)%0#tMA#i<vSU0H5L`E!FG{fNdbTkQGTvrx)??b#sZzV>XD@_sSx
z=^3_Xx0HVp)1D8*_AHh1WZTociZK+4_}Vj2%6;vbBIUmJtderOkJi|x_6^&!Ny<Mn
zPH1_`M`3$LN_n#Fi5zSU$$gO88(_`ZJeMZrzWsbg3D;+raQ(s(uHR6?^;@O<eA5W^
zKV^|^fSFIbrTlm-&xy7#Qq>ehB8BF!@cIei^=VS>ZNHS)#p_Rt+Rv8q94t>67201Y
z<#{pX*<twxDff++tx`TD=KB8O^}D6KHI`3~`WKO(2lb8TG%3FquTQx%w4Wj6x5t!k
z49l~n+!vpPC6sTF@|tMhZ8z-r+$!b1{@GnZd8E2A9EteGPnwkb#!rTn7Z@Yq_!%E<
zzm)s@TPWqe_-v4J-}u=o<-YN=TgrXoCt@9oM112XP0D@aCqv3xVEbXc%9e89_*p3B
zzVWj`%6;+KT0;45Dff+^h%JajtW5h4&MVSND9?~`-}uRva^Lt_DCH9{ekr-(_}NfG
z{adBn7oXiy?i)XmLrleyh;RI)Nx5(QWJtMh{A5eHZ~QEj@)pJkjX#W^4N`tDmP7v8
zD&@ZMvs=o2@zDc7UwPW0rs7D%hEe^4{F5Q&zVVY?Lis`|PmkHZ938Ir8%nr-tCT15
zKP~Wkx0LTPjZpv1UVMigVm61Ctz`;>^HTGdYUJL)tf9x1P~Kh2>&3L8PS}RAQtpe<
z5-In!;YKMht_{zL#@B`~r2Oa@A8Us`R<t*I{yfk?%6&fel5(Gq<{s-u@u5@TL(JaU
z+-tP7uGq7cI%2DLB3);vGyU?I=mrJ<j`o{NUZ%dWQvOULJC8=|TOqpciF7ALb@z#`
zZ(y7Kms=3)|NEjF7M#7r=z0b1>{TwzZFB8mhkx9yE1~=`DPI@U{wqWK?@M{Bpj}~n
zQk&WanfNS`@{<#_yH&K^cZjZUB3&1!GyT!8ws9m9@%6`#VrN?-JC8)`t0Q*0CDL_>
z>bi@rr2Z%nT}k~>#U2Xz`=fCQ<^805jR``SM^=aZQ6S~bf_8=FsSRy|On)3I<tHU-
zck^hwJBiMmnZ%4QGmqrl#PrAeq8kwWJFG9IkM+m)zmz|a$j%+n`tA^2N%MAx=t}C3
zKSkF*(fnu>ogeFtG>%6iF=rPkOTu_QCgp97NaKCBEw*|6eJS6I<tbl9+ppILXX0^j
zY@BL!X~DI}$wSH2XveG}7e?#qC7SN2k@FrC>wQvJapyIr&sK?@VKHN5pzRD(zDdg4
zV?A)rwOz_T!*aPlHh#>K@^*>Z+$7rO+NQGLQ(T)niN@FFPo%Dr+Pp;UoEp>SUSXSW
zl=4=_A?@c$(b#X3@~5#p<?*ne3#7btqBb{-wz-OZP+5GNn~TQR=C`G;lG;2=?3^0o
zvwa+A$L<;__w5-TlJb2q*MDu>Y+QI-$`h^Eru<haPs8iaa4|LGWP_BOeOX!5m>lD_
z4c5;LTR|l9Kh&f=8Tyee<(I~kuMEo<N_nCj)i}7Ofs`kEp0i!_{bTBjKEK*0<-WL9
zKgL`boS~b)bgZSk8v5H@%B>kKhx3ksQf|L!`RUQP{wnpGeOO#v4{<ry^v@cx^Gu8%
zTSGq{lJZqC<;%nJx21ewOu2h*Wa7F|%9D+2gEV6(66tOJ(sreE59{ldW(xfK#|de+
zIP!@35?+6Qc>Pi-_r>)VDYw&0uXm5l?Vf9(l-EcUS9eTp$Ll`PJsAl;YA5Bf(2wf%
zOo9JAq`8!vH7<I64|~0d>)UCjAQDM7t_#Ip3v-eBgZF<@{w0>Dd=mP*wS?<;OZlFd
z>vx6MN779};`7|JfTu}$qTFh(^L@$$1!W`O|C6XZHDaH7#1*ARs+!B<KB?hb8L>sF
zk(wU;p&nk#!w>gxeH(-8J<_8;%ERqlSFDlXyVOWsk3P-A?Ok#LJI8wT^*#J}4>zk;
z{3kWi(8KLhl(-90BTYT}<{sYC!&`fJTMuvV;buo2|4EH>^l)=W6#q$$oZ{j7Hcsp{
zsgbT8y}7fA|D;ATJ-nxfn>*zAPin;6sl|U%BX)-sSCASR;L+QsFbVX7J^CRYZg;Z@
z?2Pc}M|$|_9zM#$&-CzY4<F;<V?8|2!^eC01P`C+;RPOE=;4z+{A>@O=Hb&le1?b5
z^6)txKG(zNd-y^RU+m#aJp6nQU+Uq@JbZ<RU*zEzd$_)J7dtglBbRvet3CX355LmG
z*Le6<9=_JY*LnDQ58vS7*LnE$9)5#|-{j#pd-$y$ew&Bi?%{WM_?;epmxu54@OM1?
zJrDoD!*_Z3ZV&(1!$0xx&piAK5C77`zw+>JJp4Nk-{;}`J^Tj`|Ix#L^6+0g{5KE(
z!^8jd@V`Agc-=d}CpD7d;blF%yoXotaD9t6w(?+~@6lKB@TwkO-NS2mcufyK#KUWO
z_~9OYgohvL;dMN`u7{_2c)Eul=i&7|{CE#<;NcBDys?Kj_3&mMu5Wkq_-WzMxAO4T
z9^S^o+j)2g5AW#VCwurQ9^To*yLfmv56|@Q9v<G)!+U#pUk^Xk!~1*qKo1}6;X^%q
zxQFXo|2%$9_vp{?@X;Qg<>5IVKE}hxdiXdGpWxvWJ-oofCwcf}4?o+(r+N5v51--T
zvpjr`htKu!`5wN&!xwt^Vh>;9;pcn!QV(C|;VV3RrH5ba;g@*$Y7f8M!>{!4t2}(I
zhp+SS^&Y;#!>{-78$J9c58vqFH+%Rk9)7Eb-|pdedidQQzRAPy_3+IeexHZm@8J)4
z_=6t)u!leD;afcXaSz|>;ZJ(_Qy%`bhi~)nXFU8_4}adnU-a;oJp2_8-|peBd-x6y
zf6K$)_V5op{6i1_*uy{Z@XtK_^Eh6`F6r^NJ54Q*lSl0HuHa;yKSdVUCvGuC*V^xb
z7ZK?5r2YONqQP@~OXP<DptOT^u`&?%Pj}+yT7iZ4SiQWQ4F&E_TwYoRexhxvyvz&S
z?R=^OasPBHwSCGNQ+AQHBQHfliOT@;vLNtXRxdBn0dHhOEH88cA8)z500sO$%jG2q
z;Cn2W7X^U-ZMl8g2Q>IOOWTF=a2iUwSS}A&f#+K;4?BTBV0ju4_s{*7*Nfww?GULS
z$0u2C-)@a5yU_9zVwm~nM#~$-@s}(=F^>OedBZr~rMy9n;`ltv&6CL3&kL5@Hz;BX
zzP8-HO%lVaR50J39K*~vO)Q@r$46VfFpjUZ{E|4n#qy1De3#`n$ML@`zax&<t!U5#
zar|`4AByAWSpIMvUu(IW^;r0p<xeBB|Nh1DZE^fCn=)RC<AW{V9><F;-x<fRuzXh>
ze<<MT@SId<!n*;F&jLZd3V6N97MpF1vF2j2Mv%f1*=c2Y^-zDj=!XS7k^NCtAAJt1
z{>=CA4VKpm?cXByw*|aj$`@fmx8V)Sb{igfG}NpAWr9?j$e#)UPme^OhmI2atv&h|
z1N({WbhCEi{Ty$3?a-fPV&D9KRO#VQ@4MecV2ZX_epIL*F8U7xo~Yi>Jo<{k5|R$j
zi?v@GTAmi#?<MvJ1w4`c5muib>UD)!;L)Gw;mZSF6Q1LrC-vUt(cc&F^ppl+z50aX
zFR`Q7>(>*4rP0{0Bv%X-``N<J6t4QE0Z&h99B2PE(eELBBv@jNeZ9k0`=<zhOh%&G
z9~bcSl;&~v?-qR*yIw^is^2C2f5O#%onQ%1Pl-N%mscSpeFI)E<>Ao&25IkXkNy_R
z<Ky|gwew({owQ&uq^CrmoA(#{9W9SOAMYeQ*YfCdaOImU?;6^dS9&AgTONI`{hP!u
zBN$-mDbeTJ=I4RUXPM<0p`95HM|N7?F^>OZdHawz6#bFGRwg|q`u>2%v$y39L%s4@
z0k4;Gf5<n8osAy-o0i9qtGdBfsb0$FI6J2XJUu1){C%L<pI~|PIlIPlmF3ar>B>K_
zd_-tp<6Jk`ilwKF47tX+(DLZ>agFnXmJbW{8t1aX)-63{U>t93dGtL2jdM@SqwgVT
zJZD%Qecwa*O#!c$;&!<v1REp{Z+P@6hZ%q3=U3l=*GsuO^i%E3vHI+g4;K5ETONI0
zukqYsdGxuw@=8Hq(^CpUJAur8`dS`+&aQD@YkBlJyT<tw%O{3*W{8~@wT=DgdjiT&
zvwTdb*Eknh9(|ud<9UPS@#Fk;%cJkf=(<oQxG>RtuM_ZKs>XfNtv-H!o$S$fxBB?J
zVcv01Pl=zumsuX4Pd>8zlrRpB#IvJ=TZQzLcz&AY@p)sT<!6U>ddR=Nvpo8qLl@y~
zgIkXDl<A?qz0^BD;ECdMvDHW4f9NTC^FDTZ%B;|iW@Pj3b9zerd^x0!;nDYYw7<Gq
z9-lWxTOL0jXIUPfPc~Q{Kd+y&JU-9V3N~!%DMLd4HU5J<e5K{_`Q%;8=Y)20<zMN+
zEm?X>^nH&DC2kWfpC9UVoxj)eg(25CzhU{}kZYVP1h;nSDe?2At>wB)kl#@i)SYK}
zeBLnc!=|Ui&&R7RkIyGhTOL2JzqUL+&$Lf7_9uk?Yn+Qbe3Rwz`Q$Ilqwlw9JTvPV
z`_cDXMoUdAEngbeTSfl$rsc~*u5td^@)aT1I5$i;_M`8&w1~LR9Lp~b^*w|?6Yxay
z=nbo173y`rTK8CEKYo67wp@3Mkw{~?a;)X6Lp#q)z2{nfdB}Aqbid_ShFtwGcbutr
zO~}>%fdNnC|Jhc5Rj610AG17u+<svB+ECw5{*_YS)VnU^pNRkUEMFgT^?!)v8$z!B
z-(Y$4{TcQDJIk*R_3CGbAmOB^#P|E@mfsNSHG?d$Jo;YEXX592%Wn?#>gRULqwm!O
z+YkHMYx!-VzJ~B>Cm4UC@71WjspWUX>HAwAeXmCKg_cL(t5N$a170uXiO^24T-wiL
zR=+dk=L`SF@^?ZWxNSdm8W=y{3wfdN0hWIda;<l{<-0;2q%Zq<+49{X&k<hrL}UNs
zkmm^>X!$20?<M>)%cJkx3=#gm<zIyQ*23!t8;tan==(N0ehMuAD%9UA`UfrlCgisZ
zH%CtCDbe?Bv|XJn-xunY&$4`f$b;>){XA&-4<XmM{bG6aeH-QN8k>H6D%5K~<^?=W
zY~q($R{u<#{^o$Er~DLh?f0FQ{}OWT_X<sn{<n}9NF^s({zu5w&l#5g8FG!oLze#?
z@*J`Ao8^%d^<DeDV^dRaO31a}7g%04<l67gT3$Zn+V9ny89Nn1uKhm3@`@qXe!t%G
z=zBZ2i(_9~UM19PyH03s>{pHBxt3QCx%T_@mPg;)(YSqVdCgF-JUwu@UdnS}+_c{Z
zTK-}jUl8#0ltV&0+P`;OUMu9<zaLs2ea~ltw6|tUW9NuaUqg6*%cJl4XdG5q9(~V8
z`}Z}=>xOo;e-CM8?5BlX`*(!p=^@wtz1H&MLazP$h2_!re1hiKPqRP}oHK;_dxg)j
zyg|sdf1kEI`ks%r>mSP-hkE55+Zg*zLtazuTONJSN8|R0<;_FA^4|kqFXffEer(V-
z;E~tjcyG&hguJ@cJ2Bw;Z$b9UYNJniGSmm@#eSZ$d|Sx%{%fD*?}mP=%?j;|oo7S6
z+G%U~3n5oKV=aF<<f>n7`Sy^j{z=0lZ-hM9PTSAN0aqUc*)J7?8<u*Jx8n3C20T3_
zeqB4w^62|i>2l>&mbVJqtNrqo<<a-4wBOrzF!tMo`d#AGJj<i+Q}q<SKH!P`zrpI`
z^Y9y%N8humCw?AslBqZPo|XDJ*78$Af7H)=EswrurGEZmd6!VHe%9`2?8oPgUY1AS
zzdBm{S!#Lo{VVn79m{)!_SK&gIvM*tL$3Z5SRQ@<s*~8?XnFMgE4^d<#`5U<SA!(Z
zjZZfA`-k>*<r`=Dz>s$r``23@eb37LY`pn=VfpY-ukktP6l4GNkgs#{$cdK6_j@19
zqwiU@l6ogw-XXN3_Am1AJ1vjCm!&5NpIaV%FH7&7n{+mQ=7jb&K82Q#3AxVvn=Kz3
zay`M^W4WFVM<N=Z6Elqc==)dde;>;yg?83Rd?s2RKi-yG9)16+nZ#$4<<a-A^n~Rr
z%iUAmNbu3~jpkj9Khwi{2bjX(GsW^5A%8&Z-)4FA{VN@BpIIJ#&&vF4zWFrnYV6Ms
z?Of<^q@U%{_pE}nX+KLXUl{853ct<r#UXE->I%wrGxnE+e6{F@2Ru>UIMeC}hx)#v
zU+dv-S-v#X>-}uA?xx=OaX!%UWuabAI;LChp0=ARwcjuE@XeM--|q_2sr~G=Jo<ju
zXTob_8h@hicbT8hH=hE_qwjZVe70CVF7#95@SBIX>0#_&9_lp?7g-)Zp6|B&%22N-
zP&+Iy2)V}L2M@0q2+~uo3iZKu#eVu*9({l8Y2i~WkG?<FTH^4c<?BN`8izW;#wk5z
zPRKP5BR%{w%dZdh8i#K!j~}<ydK>#UhWb;*&sLV-9P+xt&#?TKkf#ZsY5B&G?-Rb+
z^5}bOx{iEkdGviVU9VI77=NPgoBdDhoM3tMeX~o2_q06vzM1BSvn)S9^d}gW_H(=C
zn?kPl^(jGM(^KNd?Qxdh8|wABQZLKz54px?iskNY6I0<auG+{7%cJkD?GXN)<(or0
z8lN96e=y{_F4yj7{Cqg%&xoB)mPg-DTP1vy<<a-k1`1zj`RdS)#%HVLkB402b9gW?
z(o^Eca|g?}hWeme?Ps**(f89dKId7!E!5W${dJZ<74k=fe_;8OA=mgE6m&#-O7wlU
z8j}B;SpICNe^TrWvOM}e+xf!JwmkYiTM%~px!m#%p&gCSo0h*6a*a>pVBn>vyb|&j
zV&_!Lw}<>o;ZrStJ>;riZF%%Pw>_eN$nv-1^zT?6ea}tv%-;d8m-2q7KSb<A@~2K6
zd1}9=xl^V@vQF>cD)_c#{^S<zdiTgL$QzuOGqzh!K|$A?+_Sp3$(&KVq8lr^v5i16
zuy1aRm4ur1S-l5j_2}I%vv?`H)T(!H+Zf|^-qhZ?{f9KqYTr9(UDupxd6}8)U+Zo`
zk!TC26eQ9QG$s-RBXbOTM)ekzvfc#xe^qZ`DeFz3|5x>LoUvP4=T4rQ*LGUb)ci@~
zd*{Y<0Tsnv)h1`^)STJ9O{1a)Vtdh=@aX*ZvdjQa(D^NKu(W7Cq)SoY_L%8K|6=Ii
z)&Hp@Xv{RDgrSG>n0OcYyP_yF?y3YKF3L=<D~!%>FJV^%^Wgxxf@jkKbVc!wV5<^z
z1<x*&$8<%Zzbguh30-tn6eigfMi=Kr*tH3}B51?`bOndt0J@@hN8(x)O&HzU1ZgK&
zb%thX#*PWTnFqxROz*HDQU2hzqDzVNJWNZ{mnzBj4!YXgWSfNt_YFEWVMI)E?_k#A
z^@$q54aUyJl{O~aHk!pbXD369bBXHa;3ZYJ?P_XRjB_?8mRL7;L{fEQyYmx<9lcAe
zupJ{~IaHYFB-pF9G<&t4{RVXH(l2X3j~+uZhh`1!(zRcv>GGk&i`nJH?zrMNfh|hf
z1a@z36=Mqqmb6>6J{Gs*?8cSF?-g6x{bctMO{eCKYnqice%7q4DS1<;O`eofkY6-A
zYesWwZ=8k9$hgT<@+N7Q*l@;)TC^CSS7i3GL-Ob3ndS|fG&6tF*sQ^M)20{Z6@P8e
zh?2LwK{Jxv@)~nVO1ql?kIOBXJgo#5yO$Ve>D1`Bi3?HdsllE*bKs2p$T;(_;$zY-
z2&aT{+_b#Bvm)b)@(K#@n)bPYm7+Y{&Py04%`8M=f^A&vo<E3JQhWG>H71O7LZz<`
z@U>;D_(lyI+M`8V9w6K%&UR)D`0B&^l42@M)UaaYzS>G|T`M<3;m(p<$Lq)ew$4;o
ziq;u<60PHXHZKC*Trz{yN*i;&ASTb2pba7tlS?^*Y&&qq+a@zUz{`?Mg>J?yl)*{_
zF4>}R8yVe}21`{jx`f-!pe4m^H=)u*y8@0wi+0nBg1gV5Ia5vgo;<ZMr>Jy+Y;RJT
z$@~6z!VE}sOBs`kTDElwV91ob-29w^ZWD5*=HwRTP3@OI4IGON=f4OOrt?^1v3(P#
zi*A~+$V9q?0cuwonBpXl%U>l;7QP@Hg$aCNEso4YgCtJ>?<WhJ3f+vEEWySO#;vbI
z?CrEymv9sW)gQoQVdqOdS=hh<P8K%zpG}tH!-ONfxW0+g>0}8`OQ7457@#Fgmbm4x
zq{+e;grhKlFRaCpnP{@a>Hqy?VN;=-F_R^@Pl9OrI>a1g_;m><OHlm*Ocr*&)RTn`
z9N=VObN|_7DLza%(u?bxIGs+G;5-YuH;DmS!erqUzXa=Xa(Az4Z);+PVX(n*({55u
zc(*|U@oa2P^gh=Y61x#{_M%mJHcZ&ySbGVFbqO0Ls5H^^=6K*y20BveYoU`5xDlmx
zq)qPRNi*`M77fjtRn$GFD90Rz%@{Z|YhZ57sYyv&-xhIpf;IX-u@j7k&`#F0qTtzD
zR_=tevc~1)hxfoV*t)ggBgojW#%}C7Oqo7yLe`kTZf0<r)hayZOEBMf)h%HH#mRjW
zDA@GC*o$dRuwZggg1KP#LrLoV_7cvS;x`27ccO96At=q9DfZgZ&6(mGfe}fn5piQZ
zxj7Tppg23p&6$$z;GA)1hBT;>pCV>xm12tUT3f;tiIe-LNU+u6@eRu)7bTb?b{CYS
z4hKYR>PR?6ir)sH--$*ShoCf5q}XdqH${qX1V$vOM#K&6<fcemgW~KYH$_UeQ^FK6
zTkB+35i_)kn<6Eyovrhy^~*0RD#**6G&VnHQl>p(YneGTbL7yh9s>rS+GS|C|4$Tr
z-k7v(p=<hNG^;CnBr7Xt+O%NFk6A+x#IW><p6<lt8nZb}7)YJIxtTdbj9_qZ%YjeP
z$V$!-vpmyNxCHY&u$0-Nd2kd}P%t?+I26yEsBR@{VO%Obz^-6>C3i*ctemW(2~#J}
z47MO+v+PS8S(EZ+W)<X38ecS_G`{=lDz10T&ZF4gDN3eyj3~L@F{?@Py%RT!53qOG
zo-bmOtBMPLvZjg)zFE_X4Sr!V!8fAhf^YIveDM34m)K~swVo!A?oRKYsJKmTuo0i?
zPKV>mi!zJ7yePBy%L|LYybv!R+B<y6#z~etsMrk3V&1isWSpP)m85si|LkK58^1)U
ziG8w<Rr^mKn>Td!6#H0J`X;Gs%`?RC1+8wAr%#e2^yF)Aix&Fl6y{~x`@`f7#JDg#
zr(pVjVPRljd*YC^7cI@R=`ax1iy=AVf+rTGwbL@rPM2xDgQ)&zhDsORmaP-`)1zQ=
z@C>Ka9{Ej`&Zls|+R^ea2fI0vfJBqjU=LP_%)%)}voj0w3iC=o(%S@~95Q+O)Z9FL
z3YPQ`YhkV*m@_rlVZrr~spxqR&+{NrWtmOEl<8CRvS#E@Et;NV4m!X9XBXad6r1W;
zTvDow)59HFqTXPAGO3QQ2}e#6sV?r?m^_nAs*AHw+Ef>3AjXAcQe83@2KFs78xrq0
zWE=ieS4unnRQDelDn6~mwacHMN*yA<snYor4%j489k(aEHi=XhcWvoXUEJlROmzvb
zFGZ^3>rJ96Ca>{*ZLxWc#U<snIDH9ujrGaoHNGb7>Ll`7+_f=DC7HYyXQ8xtEzUrU
z3(4fQWGu-0e%`#sHvD<b{-{jycKmtmKQdH&4vA}*KN*!eM1E7H^C=v#N#r$dPk3z-
zc`feR(&e?d%S)Np5?)`5yvEm4UTYWk{wE9K-W;}q;r&}QH+#WZIb-r?v}hUpds=>0
zZb5K(msJ$p17_t<8aLSrhm`6rcxY5!@>Ue`bM$A!OxlhbNoG3=a;h`on&3B{Fw{{w
z881QY>6qBKw`dpiL9s!Pf1}*=O45B&>a+E>Q_S5(x9L--26s2+L;!A(4)}3J!n2$3
zob_Kk|Hz-^j$plsnQwqvw8wkduCs0Kk-OLgXH~&DeQ>a4PmXhnCXXvF@;uf`iahIE
z9AM-Fd&Rs~^DiP_yulJ9AJ@Lbk+<9Y#E}n<H}T9q(G4Nb!IFZ``U4GmVDG;TdhrHJ
z40>Gq5(hoz=YBcG@|0;eEziEdkvXt%Nb8t47)rXbWlNV#3MNkre&#gz3E!AQ6aD$-
zlB~37n?HV1@bYl?ym9%H@{95(Pb&V^VfMd8bLU0(E<?MN@=Ec4a$)qSCt0th?E`|J
zXz{c?=2+Z564X?qcjBbTJ3GNqeDq0IaNZ9F5=^P!QCJ`-;Za!dL^=LZ7*x_Cwm8wG
z<e48GKt&}CAinb74Is8s+5r@IebNIc?#faOAilPg1IWDFj6W-ASHzeBRFqlr0HTx|
zbG?0*8VGm*B^m;phoVCuw}c_USN^*pz*b5-1mdnwdI-c_S&AXR*A_nn;(ItZu7?x#
zO<aC#nLlmBg#4nsAyaa4^D+~^Wr_L8-sUBp2ZOVWDFuOH{!xo*nS=We$%+|aL3Yv|
zmgNVsGi;Mvke6c~Bj!(=X4<8OlZpuZ!hr*M!{$GIF*^1okhbAMOc5+$6|hfzOIiiY
zv*Xw_&z1a(RiH)eFiX7e!z@<pFpJBUr5I*G4%5+)#4rnLDrSop4zptJ$=FwX39F>x
zRqVB;dkL%fh9ot->>C}$tr7N(js$B&%=j@@iWy#J48#^EnzNiMX?TS@+?blpPs`~`
z5ycKKw%)Q7!z*}6s1(C1sObQQ7yDY8;Z^Llr5j$wHzcXyW#3tmJ#6$WF{TF#Gdl!#
z0l`lKP7QugFLtR4SBvN?*nzFgn0qF&6_gb_40x$*mv?sXz;xOq^W1w#n=JCt;{e=x
z$8E}k=1iMDW{CZrJem2SFXU$1oGHO=#MszL;n752Ss+1s6Sw}si};y^VLgc^7PlFP
zlY1E`dJ|}?2%G&c&Tr!17>WxK<{S#R-j)>Mpom>qLg%7`B1lig42mLCR&0PcCBvX7
zN@`FT2Z|dML32tR6h)aO4~nQJ`YbhOP!wfG2Srh-+I)b6qWGmKi9vxcetHH)E)I&=
z<siYJFmHDHGevHRgMt$&42s;O28D5;xIqy#r^G>#o5Y}qYN8LKVg^Mn42n|zm=0{4
z|3#)KegR2hP!wjio0=EA88bs({)$T_g|Tlah9f?v{Y52NDN4plZb?>h<E=!WW5Cmp
z;CBPolHU(lHuyR`_+5&B{^LFkfScdZth^;~)Ca#N)qaef5uhIdyfg4Iz|H?Ar1lGe
zqka}})UO4O{@e-N{0?Qc{~&PGzX%-te;+vd^Eq(zXFqV%{{<ZN#{|Ba568bPaP&ui
zKeExI{Xw8d`_q79d-Z?RF?O(j^?$Hoe{KXjX9WM&c-{{j{n-i}{n7u~fc<~VqyH5+
z`d?Xo!=<r<{aXt->fQe{?Bb06p9FgJUw;F-v5)@iZyaa;^*4gEejeCIe=Y-#{^)Py
zW&8S@ZrT28U<d7g0v!AIJK(5Kk>5vb>}Lfr*Zw^OIL4<gaE#B1z)`Qi@0k4`4tn$_
zA2{~!G~lSe066-;1~~e2190^JF5swt7&z+R1CIXe2af)vm;eMH^9Ai63>@uOw(3Zv
zVer-bPIK*-Lxr2m%<qm@o(3H4`|KP6`ium2OugoJ>#O}?qBp~+eDFtkws7N5Cg>Ld
zH@Qpo`g@#>-uy0j<=227<4{^ZbHNVQTLc{IT>u>GttOn~&<*tFcZjS1!LQ%7A8r@+
zSAWo_fgby-D{zzB)qXngA;5869tvFh%lLzO9S^1-&HrgvMeOSDYc~2ZV5h#68~r%Y
zuMlqZ<3X?gj{@^MKtBQWj{(mI{s!=gz&`_i7Vzr9zs<+gTL8Qb@Iv5bteTI}PXeyL
zAK!5EzhY|qjSuF-{2bs@K#%Jzjw_7+)Igso{%3<7jQ@1dWBg};9^;Q3<3AJh7=QD>
zK5Bb0{<DE&{O172_?wuh9gP26;28gTz%l;wfn)rUWBeC@KAHG03iOHMzYy$T{Fi_p
z<9{CLG5*Lg{>C?r561rj;28g<z%l+80>}6-1CH@u4jkjZ0yxHhC2)*Ca*Y2)pid_L
zn13)&n*V)K<CA7*UHrP)3izd<KNk39z=s3Jd3_de)Yk@%`r|wt?VJBiQT_MX?*Vqu
z|K-5ZpRB;9`I!83HQ3kxQIPphpkD`i{hx)59=ZMx28Le)`gcv@4?fI)0KOjdjhsAU
zipvLo<hJr3{r^;qoohj#DSE><03QS#<3Coo+Ak;HPX;~OpAQ`EF9VMDbswVkD~awF
z(4&34uSEM#gC6a_C0y<6KI0?Mqka8<H8?(hf*$Qx3u0(KYX30zZRAMd9RCx6qyLyU
z(Ee!9BR6Zh`561S-kG(=d<;kZV&JI11UTx=ST!HEe>-s0KL8x<KLZ@~+kvD0P2f1r
zD?4{=oN*n;Ja%1ht>%F=(Hs9e13!>FhU=g&&tM)y{c+$Aa?E45f}cM72a?B3-)Vd>
zk0HlAW;CkDJcb<e*qxxqJcj&0^4MKqAM@DVz%h?uoX1N1b)F{5V`v}q7~01?hW3-m
zV`v}q7~01?hW3-mV`v}q7~01?hW4ukF*F~IPog}A_A!s4eavHMAM+UUWbzp5lgVSK
zPbQC{KAAj*`UA;hxF5zmwh6{_n(Y;rhySZQhWklhp20kZddy?UF^@e2{`>47NFI9x
z>|-87j(O}+&|@A$j(O}c&|@A$ejs^l3)sgz_Be3NV;JXT@)+93Jcjl$kD>i!@)+93
zJcjl$kD>i!@)+93Jcjl$kD>i!@)+93Jcjl$kD>k1K_8h<+29ZIWbzp5lgVSKPbQC{
zKAAj*`qJjH6Kxb+9G-x2o8jT3fNuqTK5)D*)A6b6k>;JNM6di4`Thpt4WyrL2m4P#
zy&a|8^dsK)9Z0*L0{h9ftCRTgU$v{Pr(GEkhi%|z7vST84+U=a@VXD21pI%%uLX|!
z&A=yv{xjgH{|7kgD+Sk@kLfSGU#JUwJ=n*7d=_|yF%o=?9ppGZp9B3lR_*jSKGy+%
z9`rm8{|w5^=U(?E++XRqeT=w{+ik*)pEzzuiao=9;}+YM0d|mMdtU(m@q8QGI|S@t
zdrudx^HKljJ{|wcwY}3wukFP+V|!CQ?acsxUIPES0G|OI$Meg;aXh~Q9LF>2aXill
zJ&tG8<9J5>fsE%@p<avwa_nD|+jaipyg+?2c3uNJb0N++PIUiZ#wU)G8%3|<VMVF~
z8c*dqPPUL<$H_CojeQ&^g9G2p$8ek%tt^e7zc?Py&oe}?{){pPgU>|wC2sx}5m!Gk
zKImsTkDnQ0$5i(Q#JLOb^MIrOJAmVOeiJy3XVh!_O})4u!10WF9M7mfknxP;=M`u#
z^7NoB=EMCP{CDj3!yNA~-hw#bxh2{^5A5s&eemC-hW1g9@6U_}{imSEb*&fpkL%j$
zz;WD~X9wnE+J*Wxz)^n#@SefH6U}$@|6^-CeqQ_z9Op$>u#fd76aTltpG9CF{kanO
zJD|T6IQo-JzhM5ye!={V{et;9nSMe2f7LJOC&uS5PaJw2K)<{Tab67evEDVn-vj+^
zz)RaNn8&cam}jtGFwZ2@FQ_kVzf_cVnXtYuu{EeV@DG6NIf+5LfTw}}L*V+ppFz8U
zHwXPkz}o}=7<dNoJ-~Yb{{;9z;GY5?3H&qQ*}y*sJ^}a_z^4HJ68J3OUjbhT{A=J#
zfqw&h74UC?uL1rY@QT3q0#5_J4|oF)$9_RQ_6zb1kDXo~j{SmmuwRg8d+bc`aO@Yf
zgZ+Yhp~ucr566B%JJ>JCD}tTxA^z2Y?+0ER_z%F-fd2@*0dPG7G^jc7pF!Uq_%FaS
zfd2}-7x3SJ4+Q=@@R7j(0G<t8?-31}0Q@h|PXYcn@L9nB0lpBp-L%U0OM#a$n_T&<
zlCQ=@3h*_+Q-N0mUKV&7aP0R69*+Hjdh8eE86G>mJRJK4?O?wk&-U1v;NjRWXb1ZR
z`9hDKr5=v`f_AW9kXHmd<)B}x11}G}Ht-6-(|}h5-T?SPz?%cF1iU?PeV5pv4B%Bj
z-wXJ`zy|`a3VbB+YQVFBR|h@;cn#oFfY$^*3-}?x7Xm*N_)_5dj<i9mfFB0>HNX!C
zUJ-b0;Az0I-y3*1_6zE<Uyx^b?DX<*>=(3y{enE(V`qYgW51vs>=)z<J$9CQIQ9$L
z!G1wr5$qfR{Zbuxf5^kNfe!$l27Dm!2EYdc$9j*1deIL0iFS~S`G_%nRA5K_M*DTZ
zzLpz3?xT{ibF{}!UEs;sIR^CT53W1O*h%x)DXl;CJa%xNCgV@K$4+VeIo4wb#|ip#
zT%gxDV!zi1JNllKLHHgfo~PkCKsTwtoL88$3q5}r0(=GVT;O=WHqFBq0KW+A917gr
zmubCe!11}cp6?kyPY4>PdYz|+HvnD_>>wWu-2BXo+R^iHV+Ze-OKay$u#a|*0p1Ym
z?E*X*J)Ya3zMscVQ{Y%Ho<pLYaiDJmeoh6B=WKI;HwOJ`;CK#(@As~Ue$N6u){E~U
zV7)lruwH!M80)<W>|?z+elQL`j`M4J;C~gd+Y0Ra=GR<k?-0<>1CH}+K5%R=a-3fa
zK#%jw+?VM%PlI}Ke&P6U3jK(2Xa>9<*g=l-t2yY=KAsbn)(*}uw1e}j1=QOG{7goV
z^9%JjzmVhn!g_Ijp&sW~OYrmma(-dG|CjR%<ACD|InJ+f!MH8W{3;CeI?i!^O#+Vd
z3-bfcFXTACrhpxsU*^6{>-Ehqe9x*i=rIm$fY*a@iyY@yThQbD!aP}8J2=144$iN3
zP;VFTGZ{V3FVy4wLXPtb>&5wndYoU^LVx{V&M&O@|8jm|9B^DAUk?4%9{N$=?=t(J
z4!}PF{Yk+01MdjDTo7~fF?KouKLq&6z%z_E_!zx;$4}=Gjziq1O|fdH?+p42fusI<
z;J6Re=hUWN+{f+!J?;}SfOmm<k>hhijB|I;zX^8C&roZ7_W<t!{CnU%ftQ7N_5xlL
zcyHk7XCL4gXI!r_&V50TaYp_1;3w_}FwVGdNhZ#xLcJG&{r<pT13m!whrkB{{}%Wl
z;P%EkC^O?>Fz~7n&mq7wzz)uLj3?%2jOS3WgYiWD^<W?KKgJW+DPKJMgPmbeufDft
z+B+QhCeV)n{w#2O-uDJ@oJV^-yavP*_4u9u@+P3i=i@Db<2>yM^^OGp?*e`r@SVUh
z4&MRC_WlkW{cHyQAU_E>`fv8$=40ZI{u_<?aKD@h9Q~OH9P2$tc+gb)^JTTmS+kMz
zL67gNn4cvvA5$;dc>p;2|0r<u|8;96-v2LwqyIkv$9fxredPFlFZzRVMt^F7eSCgh
z-^1Gi$9lT}$9nq!$MJRtaGZBIevqFF?L}TK)fqDVVt$8)t`}{A<GAe&9OFC;IJRpB
zaI~`uIOc(yfusG+z|sE8z(;}q?*K>rr@$WyVxsL`X#x;@cwXELJjNg3Xn&W7@AdGA
z%o|gTc4`1eKkER;ancAl+Gz_M^?iZkc+N0E2tLN2Ga;TC1_mF)F%BnM>iDG)&sRPC
zL>Pycfqo$9bD-X}z{dc;2Y4><=YYQq_Hq514}2f!k>frG`LW<X@}|Hs&aHs2hk9`x
z84LbnyKo(O2mHi1p#Rw3KS7Uvwg7*ScLI+7cL9$6<NHPE&uGx2Kl#A1-Z{d95X7t_
zCYPFz8E^O=?`^=*&i%mA|3`qM|G2M1|G%)cx_Z(7AAw`NIG&NWhI-MT4#3eLTu1Qz
zwE9pla$HBS-Y%fWdT|}W@rL^roOgeN9pt#aBd-m4bsUW6_P{aDeSu?~M*zom%><5i
zE&+~t;1=L$|32Vo{}tfl!T)!Gqy97Cw+4NhXdOX6aUDT_Hk$z+e9RZLkLw6>Tt|@O
zI)WV65%e>ebp-7k$U2e_@ysxd4L+v57>ClXBlTe(`PPvFs2ATOEd-9^e-iL#te4JD
zyzj=mf%ivv--o;!_=!Bt!y5s|`P&@$`rzL>-f$h64F2B@{^L4=>mbJAYtUnRe*upE
zHwJ%@w*!v;<NAXBw+B7?GXOaHa|Up%w?KFhf|zw=Cg}0!o7MqGJ2wMI|L*{f{=We6
zLH|Djj{f_`3ErQgKTV)s^v8F9itEVu;94CgxQ-ylbp-3}0{&yYxQ^g>!}}4OceoEh
zz8Kntydvb)vtc~f2aa*Z^#$YH9rW0)9N=i@9N?G-E(MPE*8@lU4*{PF{%-@0`t884
zg8rHU>jL_@3^@981#q<gq=&!m;d?y%N8sq^KfrOERE7Hs^ydiRsBa1!=hqw<hj@Q+
zDe&hZZY_WpLHvgT&jy|c{5-IO=Vtia_I}V$2RnFf_Ac0Y)1&_w_zbXv`F1Ao!vmY<
zW5PWPcpu=if#W`W4)A=?uLM8m1IKomcQ(w&)Qf&z1N<DYe=l&fgZprdkBP1M82jk|
zcfisA-+`n5wF4i_$Jm(*{xkuO^_nvf^D%nlX6~C0^YekDpH~4#KW_q#em(>o$Kf-;
zQU8{Qf9~PGdiX(*XVCtkz;Qk{0FLt!^FN+TWVx`}xZ!>bpX==i`cBuQlR%HW3vfJ-
z!ue}{r>okT1p4{FuLX|!&A`$B&w!);AK<931mh6nRu?$N&9}eBdNIG@{TJr9zF;5Y
zJRAH(JC^`QJD4XILfkOUX934NiT9zHC-FJ^eNgWru=5!3w}ZB5KkfjI`j3Dw20K3k
zKNt965T7N$djmfY_$c6Jj;lWtfScT?+`LO;J|;h)pUZ%wpJoi0kI`QM_BR7ZJ9zGm
z@p&Kg=>J~e=>H$U(f=a?AI!)2vlRSk3LNV-XSU{J^vKQL&wQAhHY!Iy*8)dBHv&gL
z9|n%&@PEKjzth9N@bKR}yb|O+v|kH2&UgHM%j<)f>o~zYc`NW_^5n~)$2^I=iwm=j
z|G1znS})Gu3xQ*vTm~HTB<e9wqW_q$P>*>M_5W3#+ym{!{PqX%=OJ$0f`6Nj8K0OZ
z$6M+++QEFd0^)=5>;@e3;drPQ^C7+$aSznH66`z-{4KEa8gSI_0)7$L`2qOF!129^
zRlxE5_7dQyLEJ6{o(CNF^K*cspBDf}Kd%P98tiWZj&>dbj`1;Tjro}VMgPA6j{g4&
z9Q{8m@WFiSI01jmJEF?5Uh|AT5jXd+iMUyVl%t<l0!Ke@0FHh>0365R)4)-`!^1!I
z@Si=r0^~ikUlTay!{dSb@*&<oCX)~GJ{R*L@-8mSwjc4_0O#-JK^rwsVm`bAIOapt
zV?IRxF(0BH^C9X>n-5z_yG-|#5B}(L_EVs}TY|Bz?HT|a?`Ly?o3W>Qd_Mv2M?L{P
z-Y@**;rM<Fj)y~G-r;z_{V?8tWrO`S;3u8~%m9w(SEx_s_W<Di#ivj&?*H-U%}p-S
zxSbB|!u193mr=jQqrU+-#x0qCzYF}qexCsx``z5Ds{i;N1@5mtggD^-2cI({$MqNe
zuLkY%_50i4C-%G9E2^K^@3^mS4}PLPnSRIp681apXRzOKKa)(qqyGO#zvKI0*ze;Z
zp4jhKLp=Wnal>`w4d9sPF%KZ$3wrGL)Fk>H*VAmUvkv^ke#iYoJC8n@e#dnI`yKN(
z_B-b7WcnTTrS10y&@RklnBQ=}IvVu2@BJ7!<|VX`^Q8^w(f%mlX#aiSKKs~@$ATX1
z<2eA@5xHGXjtj;^bpaLSs~KL`1YAGLD+NH;TvK+i2n<gNE}AgLfttW|tQvF}aa~`J
z1a6#KD&zZj;AMmv)Cjn#SI;Rr5MLn)ER%SS4CMaAFRbgp>BOg;=fGIvKgj@@N_^T;
z4$LH8TLOJ9@wF2ixP<ulA_uM@-bw;<J@LnvI`9bbHr*W1yrliL;~d9#kbZ}BpuP{I
z`Z|&rbY3gZNpl9iCp#m{Iq(<pzA{b@l0H>C`;T_QTEtgN!0Hjd_#~%qLj27cj&~q_
zVN=I5i9aPjxG;!#zI33T^Q)itXE{6hr0-GS_*~+b$OP5*I@He3GEP>Le(w-xX9Mxu
zWkYu-@eAiW{UgL{c69t%;-e38d<XFic|lu$2afvra4)CV=LO1Nm$>OUnDYIy@vkU3
zM0puW7`2GsDC0k!_+jN;z0HWXY2tV%;vZCXyf^WciyR+Lys?a*T;j)dcKRvAZ>;9H
z*}IyLwrih^H*@BL{61-y-iNAwRAr~Tk@Q_<LwXPK&*TQ{apLV{Uc5;BHpyde6aR6H
zt5@$&)t}!6I=-Luw@JPK5KlST=?_kIU)4^YB+es<H;{Z)kNDa{-SwHo&oBoC!Dj&R
zO?4cfPJG*N$LA7XAPda7#9#00^vj6X@9DU{@1*UjJks%7N&js{#~&pAVt2>45Kj?1
zPZNKjnbSW{{BK!bUL~&2zuzQ2UF^J1e1+uUuZaIC@!3awob>O{#FsfYBYzS<v&a?b
z|NEwKyY@K8D@uPV|E0I%Rf&Hk_G=OUx`r#LOZ=I^jyEH|`eMi16W=c5qzCan3!Q!_
z@v^cWjU--8@>mgZt#=mjnUZgp6CWVoUrhY^0nVShh%cA<axd}cM>zcp#8v+q@wX>C
z{ddF%r8)i+@dqn7uJ5^NKfWyaU(ZXFA1v#XzR#xorFqWI$ub_5-*<@PXAm!t4e}V`
z{l))<#J_Fk>|8*+pXC4Bh`%TE_a5Ru%eu3Jxa!{{-ZRtH`#14p(;P1+_O!jj4s*N#
z@d3v<-i&x=SH}kvSN&<kKbCcWF7eLd-?_x!ZSCxDB(C~9iI0)~-A;VoVrOS3ab1Ug
zBK}wvr~i}q%3+QlDdSG#Hc{4>dc@bseC$ko_6g2T58{tW-WyB&bGflNi+JOn&d!Cz
zH%xc@V&Z*d9lxIVrfN=q8}T0`FTF^-;zdsXI`PR99siVgN7=7_Lp)8!!#~8Ily$wl
z%ma<{?bDq7BZ$wCen}%fe1X%qBK}J!$2$^#U-W~CPhRNsrxP!f`=%MhGt!-YKJk%f
zIlh+o%6!MKCtf6eK2H3^^PT>G#5>7-<;TR2aq`Gl#J5R4EidbU#(7hBcfrBLr^@=9
zMtr>VV*}zJiM~JaOc_7Ji02&d>YYIRcF8~Uh!2$en&rg1Nq)YHc)M}V{>{XjNuIx-
zcvm?fd7AjJKF-c-#NU!Qd`Nt`tk>TX|8=~x^9S*hrNa&~9TI%BU-qThZzI)-A1V3g
zXyWaqzgrM*B=^zni9glA+0P`dc1|OHOk=0dCY~<e7ZO)H%ZWcD`?gDo-#OaZzm~Y#
z*+Tqg84uftZ@<9Vd5yT**-LzZ+^76Xyg>S?LS<*q6q|FNZuQ;wwTbJ#s~&OP?=>T?
z`@NHi>wd2b@lUF{dPfu2dUJ^Pk^EUiT=#pkh%ayC>|e=T_Ip<oKXiuEZzit$y+?>o
zUE%aQiR*rE7x6|JPX9Y`-S3sD;>xvOu95Zo7~;C$JDzxs=(`iw{a#<<H=OV4%O|e;
zy(z>8EOGkP#C89+miXsKIQ<sls^3QZCCP7}6F)Z1+4+w6Fxj8ikbR2AP4{oLiQgxA
zxFd1ZcO{-*$JLuhT=#DU#JBWx`iqIH{tDtPXFL7F#C5;7m3Z^cPQQz|?)N?=zFhXt
zsWQ(rKDytlM0}j&)ds|Mzt@cT(kafLQ;F+-Zz%C4(%z}Wb-y=@_##=qmJ`?g-fH4c
zo$36!kGSsl9wq)!zSF-#T=#o#5-*Z{#TUeNzqgn8Xt|G0k^QO0U-x?l5r6Cq=T9Bt
zy5BpF_@(olz9aF;3mxx9{4|+gS;Td}H=g*n;{UnCb-%Zq_+9l}y*Crr{odWg56N=+
z7m4eB?+xNDCOQ3H;=14anfTxRo&F%%=W6_QzgL5J{rOJcj=1jkP9fe(_P2wG>wa$>
zaoz6~5!e0RV&b~rTSZ*=d+Ukoe(w(Ay5D<*xbF9!Bd+_sw}|V0?-Sy>-`h`I_j|t)
zze46+c{zX5e$oBRk;HYsSC9A&ZC!sgC9Zb564(7+Z{okoIyjuT+9@Kg`@M6B|0Mga
zrNq_FM&i2PyOa1~a_;vCakcX{aoz8IL|pfK`-s2P)Wxlg<a>?3?z<`x*Zp2?;(Zo6
zJI52({a!=jhaBbfJ&0?)eTdJJ`<l_jb-$NGJVo;7LgKoATSENpzRsU@#8rO-@fYVf
z{Z`_G(j0%5c=Ha9?;)=Hy|0KrH^u2IO1rgRbiY@P_~WuaX+m80d##CoQp?#NOkDSS
zrxEWR+#8tBT;jTaJD2!|lbn7dan;{Ry#8{h-%ecjdpn6wmUEWhiR=EYjO^<*ZdLj?
z`^OPieIw$B%X5VO#C88RjQGT*&i*Xos$W3-wF{m8dg8j@yOnsF+$TIsT=#pg5U(ot
zo8J)E{oW76=T3G0)R1wZant=?ZQ|<|IDK2<y5BpQcyHMcoIzaodpX1(=<4hj5!e0R
zT;dO%?ey0W*Ztm&#1B2k=^rGn`@P4B|0DN<uMyY%-rK~RHFNgACa(Lv{lxV>-ExPy
z>ooql-#eK2hq8Y@j=1jk8WZm!=O?|0>wa$_@x!J&KMIKJey@o5^~XE?D&o4|TSNSB
z*}vUKT=#pA5x-aV4Q~_I{oaSfGn_k-{ls;@_dD^28oCS84tHNQ{<_~gfq06X%bi4A
z_j?0~>wa%Eaoz8oMO^oLvx)0|?*ihw-@BZ+?)PpWuKT@vi0gju3F5lndzrZI_ueDE
zFU`gAW8(MBb$l;z-Or@fj*Y+W_bL&u+uP|5C$4rH5!d}*OX4|Wot@6a)y`<*y5Ad1
z{FEln&e_D(&c(!azjp=kC(d<tZXm99o+PgOy%&h<e(xRPi#0D1ui4MlyO(&S3657d
z!hO|wq58_iKa;##m-uhp-1R3Ae_!^ajflU{(&>8=*Zop|;urLC`U2v*Uz$dIR0F5K
zgt+dP))3E^@%8|5-7jq+{(_vN?k2ALpU;V3Tj>0$bfkO@zL@h^)z={YN_(ekO<ea&
z9f`jq^X*LHy8p=|K3ML9mJ(O}#l-KC_}oie_dgF4KSlOG?-N)39^w}abnPuK_YFD@
zb-#2l@qMx{Y(!l5OD&0iI?>r5NL=?zBZ&X6htp3duKT6A#Peo3{aWI>U%HO?#6eE~
z1aY13&k>(=n$zzjUS8JCFFgDk;`+R~tlUp%oYhW6;^WJ@dXFN$Z>8hM5wD~DLj1Nq
zPT!MwINyo)lKtuo;`_wTJmSyEdCs-OE9Sa-?;)=F?SA6D<s9i{;;Mg*_>r>j{e-yY
z!*7XeKK!0|=X~eq!Seh~`$gk(DDmIUa{89UH6L~$ezN4@5yUkgo=N<|6P*3I#5EtD
zOFUol-A3Y?-|i&7NY<n6#8tnOcv(5${++ny!!mLnqjA&srH&)6`K=N0;muup`x96F
zFyfmf{<DZ{e$#oZ{yaC+*}vYSzm@o^$xi<gam|Ns5Kq6@>Axqg`S4fb!-hEhVX`4t
zKQ$j7O}vqe*N((BA9f}Fj_fP4iEBO_PyA=OA3Tq^#_=NJnh&obevRCB+)Z5P?`Gm(
zE_ZQwk+|w#C7v((kBRGi|C+eY_r1iAl=GI#X|8^azs~oX#Md@;y5_`nzPBSjMZO<K
zT<7~J;=fmn*v}l|I^P!&e?soBZX~Yr_jclA+D7c>72>LYllb>bo&HziI^X{xUT~4q
zr%OK8c<TH;k$6Pbmwv=mKZN*Zu|I>j&i8r5pKRm&*+5+NHxsY0#OYrkuJiph;@4Mo
z`n|+;zW+>oV~*1wn(n@8e007aMZB5pD>@L@`L5>*YUi(Z&hD9{*ZH1D{DYcKe=c#I
z?<<Jwe7~CbJ;ypb_jvgI#J6NQ{maDF&JN-Wt2zBQ#8v+T@rO=y`pV*07$1itHHl}4
zzA16d18s=cmVLr#;<_&yOZ>+?SMg%v_sjk4QsPUcJy#PyUgrBP#D~cK@_yp|<o@D0
z;#=ih@=fCZh@Fp#_Z;W^-%Gqhn&Uqae?Zz>@i<qm@mGCS;%Cb_SUuvZKY@6Y5zg*O
z#3y%jyeILa<-Y7x;>VVE`fTE=A4hyqYp0)0T=ffxx0m-PE+zg;BWFk7E7$m}k@e{&
z(tml7(?3L9^^X&O>2#-mjkxOHCVtBCPX7h*eX?Kqk$4-)tC9NdI`#kbQ{DF!h&P_-
z_>sg_Uyt~An)isSK7;t<vd<Yw{Ns~cy;;Qj$atMeT%V)OCw^=zXJ;+(Ph`GaN4#8T
zr{6++l#I`9#5>Enyqow7OPrn0i5JTJO_hGr_^ZAW@uBB9JI53MUG|erh@U#e>3b93
zo9Xx<;?K%>E+oF?OsAht{OnZ6R}eo*^4?{{udnR%w-a9~`|W#)&yoA$XNa$rb>}7G
zkDcu7e@Oh(^Bw=3_z$%mPnG*KjlZ6IS0=u3oYOZZuKL!*r^|iHFyhr^y%<IOSQ#Hh
z#8rO|@d@ReKdXtWel785Mmhb1#3OPZ@;LGA7Eb>baa|8~5r1=_)BjHV=oH6O8n~|-
z=Tyl{#}YsHJf~|!{2p0f`Vqf>snZW7K0Vv<Da0Ghc6=7``f}fW74c7JIQ<6VdvhIs
zh`8#XAii1dw|5d({Vw8V8$0_y6Msa$|BLu-(qBi)K1k#Iq>Q(E#3Q|({no^n%yYaW
z@%7CeA3}Ub4ad(QK2*-HW)d%uygHwF%`VQ)6~qU~{o0MhE6aSpmw2b)&dyfiy52oY
zyyHPm|26SClE?NFZ+@85*J|j#YMiT%ao^V={{1w^I}`6E?d?JQAlaYf5kE)9VFB@8
zl4q6^uP^KSrNp0F==`~#xW?x(;%`X1z99a(jOQPTYk&Pg{8?Fds>(W3DR9G_+pE47
z@y#8apG}CXzBTba!<@b!@gd6`A42?L$unmW*YP=(_|Y;Bmk~d)le2#b@inr4yOnso
ziB7+X_}#*vBYvyorB{h}l>Ngu#DA0LK|c`Bll@Y8$txQFoI>Z%!Nm8-xNk_jlg#TD
z#AnI8>rK4=0%w09@hfEgnm}ClZ<C3iH`m#@fVl3*E+XDWzQ2vQ>hB@GNb={)#7D|~
z#}4ABNq+d6xa#*4?|*^w{~*c78vpx6r|Y)zGR>U+1k$&c{Y*3BomV=258}Fi>rZ^s
zP^Zr$e)Xx27ZU$b^86Cw*)mU85T7J=ZXo{G2xtE`;=|8&d<*fa?HqrGxZc-&L|pY>
z65l85PBodw8s{5i9X*_Q&r@8zt%(0T#PN>AFPHp0g1D}yXA-X``|}yZRX>mT3dvV`
zeyRSilKYG6NWUb{`S~#M=_?(7mbk8`ZxYw_bPw^$Rh^yhiI45$coiAH>gN%XmueH&
ze0~h^tTUXQmc&)xfq0)<PCtma>PHf<v%=}85ZCo$Ch;r9{>8*~y|{vSIT=@X5!dzN
ze&RD_e7;Ov*NYv*EB12!e?wf?iyw$r8te4cWgn;gqU*)s#0z>leM929UbG;dDfd(T
ziR*eXjCd6p&xOQwy(l6+SMuiy;<{d}Cf-!;FK#EU`Tt(xx1H+R`wDT@ze)U7iRbsk
zHUIxg{5)Als>wQ|@mKv}#J9-xO^EAy(VF<#Mb7`e#C5$GLcH1_r=Lh%*NdsdpON+Y
zLgKn!TtfV%S<e0~#C5&cM7;J=r+=2Xt{1NmH^1A<d_E!`=6~Xs$o*P5$wL}{)gMf}
zNX}bY5!dyiBk_|bIDbYE*YzTc_~#3q{v6_({}&Tqv)t*|5?B3o#IKY2_&9N0FP<UZ
zRnB=nAg=4h*Ti+b(EOqC)b*l5E9b9rT`y`8*Y%<~alJq4L|o4gyAi)h_QS)8t9~@`
z8nSPhPF(eKiC2|<*JZ@@eDZ4I^X0r{GjYvVj}ZUuA{Vc>i0k>}2gE1kJN<9OHD5(q
z$HxDOithV5#Pz)KSmJNWe!eqt)%PI2UDmHL#PxhKpZIreoj>Oh*YnAh#M6g5{jJ0`
zU)@7|w%mU`M_kV*w-X;N<NI^sdOrCb@%Lo?EhG2YI?nZcvLf;Fb)5f45!ds{V~H=5
z{by(5dfwQR_^u<J{RzZXKZW>JGT$#DuJ<8ph@aTs+22H5^$!xymH50$T=j1euX(Ps
z{{wM7pZuM8)_A9{DdR}vuji9T5`RGYuPt#spFD+lBUyj5i0k>}c;YYhasDhNuIH1h
zi1(c6^mh=~^U3>&e<k_kP2zff_&)K%DbD_n#8v+X@t!@L{t&s}(s-)=Na9NhoxUY;
zJ)i7A{1v(H7*1TzCr1<4=O0su>v}hnc$(P1n7E!#UP)Zftu_<a{rn@uryb+k`#N#G
zzt~M&*T?UO>-zX7aXoKLZSU&Q_+MDheSbW0T_2ke&l~9UgNUnsB=J{dUe6@1=ZEu&
zpWnpUzmB+`AKpUzmkLh5gZKzJ&)H2}<M}!9rVE^%--)ZfjI8Gxx19M-e*|&WrxCwO
z=2v^-dOz5i_yEaABZ%wxIg|J=r#gRT5ZC*`dBiKr{JfmF-Vd%L{<@s+-A7#S2OlNA
zQ}zvS6W9IRhs3WL;r!oET<-^eBi>&6{V;ictNo()gGUqZDf{y_#Pxo#6Y;d;oIgW}
z>;CEt;sa(l{WRjbUz$Vwg-K3-1##71Lwwf&r+=8Z-rsE{-ln0`?<B7JUBm|*?DRho
z*ZaXgiSL*5jYH&lwZ>oX2ah7&U!ME4B(D3blZfw=`89~R-VdHeyt3>!rV!Wr!CAyV
zlJkL!iR=B~6~t@SaPhg7xZdC0L;Q>kr+=Ba>fa>(!U<0Q2XVb0Ozq^#HO>#!b>AOD
zT<-@@Aij8^(|04T>s=q>`tyxrh^s!I_(wU;{`ti9esCr6ZrM(M6LGyC+)P~8yC;e3
zdiN@Ey&wF5xZV%`N_<<9^QWvl_tQ9QKG*t{U%1%m>w5I{iC@0R=}#uE_PY~*B-`mn
z5!dx1m-slzkLM8A^<pt`{khY%#C5&6j`+<Zoj(r~*Y#p6@gwFq{oBNKz4(y$sv%DQ
zCvjabQcrQ^8vi+B|1jdZUK~wae^19r#C5&sLi~iIU45q!*YzTs`24<3Ka04o7yA2I
z)&G@8I{lTT*ZjYp_+L|<{t@D;f0Fo1r#bxx#5MnaLcE<k&-;V8>Qm(YTm651nX`Wc
zaa}Lch}WFu^zDf2deNEq;L%P$oVczRXA+-X-|43l*Y#o^@$4#2e;IR`N9%~sm3{1H
z;<{cuLOf5NyS+?2%>TsGWc++jT=l;ZA1C)y$7Hy6Xus%saRTu)$yeQo>w3|b_=2OH
z-SNaV|4$;myU^*+C$9RH#3#!A$!)}Sy|{<?hy5b<^E`1~FLn~weElhLT`zthuIoja
zE)o0Dc<Oplhq%5k(SW#~?=>TSO+#n5D{<BLChpXcNDgt;Par;0`fDL^JwLpFc%5;s
zhHHsyzS>CquX;}Z6mdO2e4h9s*~ffJT=Ug8#B=5Qid|hj8h<?xtVaBw!<?=Wan-jZ
z{`PpM?@wIM4~G%&H_GYHCa&j)vx)aU!s#z3uKDU3;$;>){e8ss{O~d2jm9|r8^rbe
z@Ll5PPjmWjiR<~{kHk-3=JXZ1xvv_3JwL2Qd`e}fYeZbn16vXQOYf(Mt9}&m3UWR+
zkGP)iEg@c8&Y#y2SN#pd+sgg&qr_GJ6!Em$uDu@;*Ym^Ah<_#bQ-2fJ^TYDpW8>Uo
zxcfexxSk(2BtH6Lr|(N#&ku(XUoG*`-<PKStLKMvN#EvhXMYWGJwMz){2w{rev-JJ
z?>$GngRB?3iL3r|;`1b){}5Mw`OMgOzEI%4uS;Cd59<@ZM)FBl;(C7AoA}{Poc&S6
zb-l|a{_!HGKZm%UAD&CR*D+3iEpgq?ZzMjoq0>K3T<<SlBChM>yTo;U{DQc?f2jFS
z$4|D5lbW(0QLgLb5yaPIJ3mh*uKMo8Yt41~T;h6uIFa}$Ij2}jT+a_LBd-6?$5!Ik
z%KiRJ#5JC85Wh>-yU&QL{#)W-iJ#?qy7p<@R9}VosV6wyam4k0uo3arV!s=49Y1}D
zUs%@JA46R42lI&!YwGlii0l2}QsOC9oPGmwy&t@p_!aY=ej9PUAAFJc5f?fAF5-GW
z_$l#4XFGk0JV(;_>;2$C#IJMmNIl|uKiGiywJY5P8N_ve)suLd>~FJ(>wak*@edn2
z`-_RI{zBq|a-9Aq;(C8~2l3o2r+=Eb>R%wfwT#n$L|pF&zaW0tLZ|<SxZV#|=<Uk2
zUrrqFzSrM3qg?k_$CG}JwD)A<dOw&+e3R_oMiJNZ!?DDh4|e{XLtO6%7ZdL#=eL&=
z*ZaF`h#$Gk*?*Y0>YpV3l$;NIPF(K?_YzM#%h|8o$9>g!>iys$#BWb?x@N?6y=zPS
z%_UCXpSbFW5r0$mlT(T7{orikkIDVxCB*f9@LJ-!-rY%D*SklF>;2&K#Pxpg6XL&&
zb?w!k@2nJji|?QRLi%~KU#isCUB~(w#9wORbSDzm^`bfP_v9R-7ja!L1`vOHp0hum
zxULtIh&Pny-RBe6^<pLQgJs`#6LDQH?jXK*sPktVaa}K7B)&)T)fdEdz1T~<>$%Q;
zisW65zpfVt5zml){PDzfy=X%GL^<EfB(Cd4KjNPjIDf_x*Y)Bo;?ECr`g4hE{$ECX
zK^LdrNL=-I5`U<g(?3sK^Z$0@{i{0t=fqY29r5pvclvUty0034T`#H-Unu$iSmL@~
zG$Q_oyr0mOxULs{h~FaptN&l3`lIVbKIt#ZaDFc&uIt58;(y9M_FCe)UTh>@UFQ44
z#KZhgyn;NJ|A4saKP6uAH0OV1IoH(o>Uwbq@k3Lcz8P^{FWM1*agfswA+GuVbmFy6
zcKWHrRX>~f9P$4O;<{d3L;QbDoc;TW>w57taa}K7Bd+Vkhs1Tg_?Eb?7Zqjw*Eqja
z!}-&i_>~PDKbiO&GX6&p-*b@D=Mn#0o~KMAu6C9ZzyAzp=L+Kb`&h3fu67<JK2Gxd
zR^sg>|GY+gt*bWj0r4s`T)~&b*N=1jC*of&bv#w(fyVjIGaau;{JAQQ_mpv}`nC>7
zvWZug{p4)ojYWSc@#<w<!R^F%i+&sNy3)T}WM8TN^pZHdOMFaaXXs-O|B3j)HJrY(
zj0?42xWe&z#Mg?x9q}r%F3%^PEBmp_i9da;vwsiqZIc{-nRuNAj{ih_*Ex>=L%d9`
z<7wiTw(D1!hZ)4n^l|zj#2X#vcsB8(IgX!AeE->wUqbxRsgB=6d{;BaUnBmg#QzK8
zg@sOERn~cJSL;I^Z%DlM#g5M)KH?(BmlN;4(D9pzpDFR#Lj1vsPX7V%iN>+u^B3{o
zBtEr=yK?n^x!7qmB9>n&`?q$)?-1UN_}cT`^#h1^l{lV3{6X<!Jn^v&ot<gK7s>g_
z0^%FwoM$=liDLgs;@`D%_HQ8m-ocLFO}y+;jz3ELd71Ce67MDR;SJ*H)t#LWiJvjX
z@vn(bmT~(F@k1q^sq*|^`?2P6&Q3MrEy_856!E<>A5S3uovaJ3h*yyHx-)V8JvCE^
zcaix2CHn&P^YaSMAAMh2dD)(hFFxIURbE~4@D0RAOQL_6_>~Ra_1lTRD(lVn#0!pb
z`U<k%YP~&VJU1aeRPw+;;bvL+%bBo$k0<?pd9P&}@jK-EbBUiU`Exb#+vL392H{$-
zggNpO@IS$yJ!D7y*-N}iKX*~ZQSPg;{|DGPM!3dD?KC2;?dnKe+tru2w(AVxTJL13
zdkOI0!Jn(ij{0*mac$RDu=5+(*-3h}vxm60>j&c6uGG=asK!Uzb%=1&E>rImsk;;K
zUxk@3L&%Q$lSN$HH4E(g0(LGYz1mqvT-$XA@pEQ7V=s~YyQL2O|L0A+eujFh$o@{_
zp!FV4{2tj?w-v5-Buz%Lfd2&cXOJDWznJ)fW$vP@!Oo9h=U&pQoyUn!ko>ia?8xy_
zq=Kx6#{VC{eqG@lhepJImVDHS_)YTt8S+)_OFE342Yf%&yN>K=yKW)AskOUkE7<uS
z?Cd1H+R<|zZI{~l1MKVrJ2kW2H>y`Vb&0<(>snLd9|_MBZsM>v_@ke>+3sI#{}SOw
z|DBWAzi$!F`lp1eUbX{~uYrGSEx5l@a@<$8Q;oRJuVaYo{OT;cOkmE~*ZDO8_&2U9
z`}YE}qw&0oxX!Oz$xaQi^*Zpc!Ty(INA3SaT<4cQhb$A=_zLXQmwgS#rv-7HUxS3J
z9i3lufPV@0FCjbX=X&BgzwRck^XnC|uk-6y;9o$!)nt9<b{$1r=S3^wrd^+doj#;j
z|A!M-JCnf9XJF?%(yJZ)`B(K*=ht<l*ZK7}*#8vl>+d~MJ8HkIbdYJ+C!jw{IP2Sx
zzN%bvCh$FAXS&DEV&Xc#E+ww>>t3?2^Xom}A49$S$&R+SN}dyGyL5il5pLpO>{Jt5
znZQ31X1<IfJ8FLdah+d_z|L;4vxf9)=SJc>zqXMbX=dbG;2(nhvg6!0+FrF^gSgJG
zbmBU{x(GM%G4^$SodtXs)VrAMXuTH^*Lk78r_I>^0PJibz1n%6xZ3$hxUus-*!h+8
zYNxC;MB}6L>rmo4zxoO{_TK~hV@R*|XM+A+&|l=y-$ME-a?NYN-vK*cc<lT{ypQbv
z%1v+=oAyS6M$9k`2|nq<&9`q`;{NIYdh^^(+cg~YJ3(LQ(Ju!5TcE$nqu)sUyQADi
z&k;Yp&~g2J+uDzJ9PRj5pf~N!mG<rhZrb&Ix;T~Zz8abFbGqO(;){fj6t4AZeDaB(
z(bipXF7YjL|GOOQzbUrOmmS2_pI?CQ0DaYo?i==}g>ciZH$XqYqhCV2a~F5fYTzcG
zLyW=TqrV5seEYg3?yvuW9>>oc#C3e`0dDMf5&My|oIUgHYheFy;gtf0_FIE~JLvm*
z^x2?)74$Pb`X$75d~PJJ<MTn{IzFERZra;a+WRta9G|;{8=3J_$HU*m7fBo17Px<K
ze0mbs@tH%sOq#nsU%09F6^HEK_k!N|U)KnN&-0*v*&+M)ZqQ?YrOG@um%jx1dcxWN
z;ly=(<^ebUR26>~f&CZ3{u<DuKQ|HA@p(URWB*UF^*Y#p0qlPXdbD4Dk`o#Co(KKW
z!nwUILH``+dwcZ5iR<{BMO??{g~WAyt_5z|`=!)<EpQy4n}nNo89#M=ZYRD->{OiW
z{=w}%g1C;)R>W@|<gV{1+|>K5*fw95fZq78Yv<LV{~ze@1wHoHo1lLN^xt^&zY^E|
zTLn2dGJYC6Rm4^^;M>4{58)i2A;fQQ;w~CXeAzt5rvo=}cueY;1KhOthI3uPa^m`4
z#X90w)^++ji9g%R@yCg;m38@5;_DkYeahMHE4Q~g@kxE0uC{O!&!-)-e`f%H3it@J
zqwDop;xlC4PA9JCbr*yEC&B(k(yRT=#MRC=;^)i#+ndC1KgLzESGZ~KR;ahUJZIpz
z9VOi8p8$PJkG?Z;eeeG?u=6<BnL>JP?>yp<7zcvSU1X=F!;!avZxLp`{7iP#exqql
zr0v!Gf0A%how4(QlSRe=*RgMkW|JMYe;#q2zn766oxe|#UhTX<T<yF^ymlk!=pL~D
zsQ7Na98=`J(e|qSHpFY?INiy@O&lI^$o^df{9)kB$&T7zLtOLBt;99YJObS0nQNtv
zCxBy~*-l*Z%typE&+I3zc_vjB8jX+UnL~+dp6N+k+dGW-3GG}1MhiFbd<f!p9`FZ&
zuOmBZ|5oCfXC5K0`C$jxe*o-%O?tKeD{-}R&<uC6#z*tak;FC6v=(mKdq33Mm-Je1
zHt6pI{Y;O3331Ic>%q=uuya4@wce+QYo7Um>}Z}jdZsgK+I273?<id3qxPo|*F3X;
z>}a038TdV5|8cUT_Fo{b`QaV1qj{$MEN7JctVUezq!Ayu&|Tj^xQW9ihwR^DNw0p+
zA^wkXAowf>J9j%||9%+wUBI`K9ku@fam_Q|5!XEP4{(!b7E2vvXS;uBd~`oki@4^Q
z<B4mYX-8c1OfTY^XHFxod1eK1ZSPv*PfI+n7jF9HPKetJ!0!P55!q4u-x1e5^AB;&
z5BhrrOue^*{pNGrHyTg1e=>2k)1SEJnJnU(XJ!jG_1*^ct|GnGdlTqy1^r_l{qw{%
z&+Gv^w}74BNw4)*ILC=J4w`4$3pf57JDO+40KXaR&n7!+|9s*TC%TJnB0Js1)~mob
zf_?q}Y1L1)zn|>ud1<A&?qcKrO<<><aJJJH^f!Y3RFD2N;u^Pk#MRH$#HSetg3r~$
zjh{DI;{JLa`1QcQBs*&VXW|;?TJzk+#=fzmaqbNKI<P-nILBuUagFmFu(JW|Tta&F
zb0g?=4`nXf;?X}(T;u#1akamfxULtG`OZ0Q*O#g8`-;L%eAYW;|L#tDwSPMC<4<uH
zjS+6_TmyEl0=^FTCbFaUw-DEUe4p%SKbBwMjGB6{2Kz?~*Y>LY6Nzg-b^$wU!Olq1
ztDQp7Uj_Ol9{nof+K;z@oi$+R3DRr5J3xOW=)d;pBMY6##ODgoA1<8Z(^$CCUk>_i
z9{otrUk3Wg9{m!~uLk|q9{oeaXSQ({eIVTUd8tG8?;nM8yUHwbBIP=+Y7p1;y{&L#
z{}Okp{rgnXYrmWg`c<G`>d{|DT>ZHN>|6|Xo+iE4`zmp@vx~U4>u0ck5!gRiHd-1V
zwSNS0wcmia+RqSPCa}E{?2jP5+CK;MD?op#NB;ommxKOgkN#uOF9ZE=9(~nwoyhoq
zA?WK1=lFE?@Lt4Qi?QLvpOQwODcsb%6zW|}`a(HxT?YCKKz}dr^MOB4b~OIGKz|<S
zfAZ)nEpZ~_r~K1`dh!j&r!DBkq}8A5(T@SWbdlB1_UJDH{UWP$f8FHKKSf;g$>(5a
zA=vqw^cuIy5-e@6&Wodnhx0<XiJPQqTgwR2tNn98FH4`*U+U4XC$9cH0Cr?+VC}q2
zdad^z;%es$;@Yl=3^LO$*@9X7hYQ#EsQqJ!tNoV5)qWqaFI!z}KZo>c|2)vkmfz~v
zdGuRBFSk%uztf}t2J~{PYW1ly3Aw$sg`4=ut-sYb^XPkf_+a9iPqK-xZ*R><CI~n6
z%8`jJSV8*D2RZ#^pqHa2TksfgIij=t4YH&0{{r-K<Z1Q)c=U%#vNL{8wMzF_BjFs+
z4A9GwxxHY7M_&MXc{E}5=X&&OKrfGatp09~{w3m?PxSwJHtmv>ZS7Q)b%5Jdi@45<
z`ozO|A>7!PM;g|C4(YXD&I5gcRl2{{dGxmsSAVvGowLBsPSR_=dx)!@{lv9hm6kc9
zrd<=kem&tFw<g5ZekbB;f2eR{KOgL$MSAuBV$e?j{YH=e1<;QN{YM`C&!8U%`h#V2
zQz>BhyfR(5@jnmr9X$FW9zKe==97uU=L~g~OcieG9SikdLHcDz5Pa5yKGz}p_y2&8
z0saBm(fIENeGcdkl6@1$r>=10MmFf%c=UZhp9T6HkA4Q|&jkHSkN$elj|Tn29{nqz
z9|ihPJ$n7U!WsvC-!eru-^%rU%XHx;KE}SD?e+zJ2Gl!->}bDCBCh8Q%Yd8nTg~Yk
z!T#xBe;ep=oc~5#&*v-3O^a!lv9Dw3IN_#Ur-A*Bpf~p0S9FEliEF#YgPoCJXFloG
z&IQEP&TU|41lW1fqyGf-!$JRtM_*BH4z+)^-}UDjm21DZ7rlv(v9JA}1AG|NJB#dV
zyOt2we%}Dx^vhte^%&TfRANis1wHnAHMx0K|Fz%i0yp-%iv5#>n|2KmX1)vpJ@)(Q
z#I;@Xz>fNE>|92A?e}YltDUW2XOJ-<pPe54@1P&3;^1oyIdsrCsQtRcwcnc(*M9FW
z+{DM&zgy~<34DMs^W`G4qxG&OuKoT1*^y}**#*2m*#DF4sQng~I+3<l`#nRr@!!~a
zUu;bPeyT9@WdYgI{#r_0>%AT9^aDFjkzVb*NL=lF2X^{`opN%>rR`FE1L3A!eL&yY
zqwhyt-&-36+{}ySVrvO-oL_5+pCZZrdf~>O-r&zWz<UATM|LzmzY*8=mXpIljl*Fn
z&R8wtkwK2vCqA^M<86o^a<t=}g&Y6N2Y<55I^GMo@&9m#Bd3v_2jp;K7U}hj^+Di0
z#fJIv3fa*(>?E#n*h5_7@B?v;Ls>b5)wpRKY7y5s93x!guqxF#+W@%nKilC*2ePAa
z7)kn%M1Ljl9>UC*yU32l;X&dWho^~a9Nr+Vao9s#<M0D<jl*BWwOyU$5ZuHk6Z{_{
zT;r^MW)s(WHwCzvcXh?q8sIqZ?jru&Qg^`v!i_)O!Jlt|cLQEl2Bi9_aXy&1`hNs*
zjq{1bHO?J~Yn*!%*EkOmZu~d%ZoACuQNWG=hf5m@$&U8R3erpSBQFBiHQ$)}nCxgA
zz9z15_=UK}p@KYg(RgYc4kxa0IDxpvp#^bm*A(F<K3yaR=F0`7SN~TLSO2deuKwRe
zT>XE7xca}HxcdLDaP7y4^y41j#{X>NeDL{^>}Y!rk%wX0-jAF-ax(A?Vdl$F;TnH!
zZw_&tcV`1P^R9~6x(YbXySs_&bM6O)8$UaX4fEwY;HLmDCl3YHPwlU&#MS>JiEDo~
zB(D8+67m06+xfs(Ilh1VNRfo0s1%cAl&o5{sI1zuluQjFwY64_t!AyPgdquG2uWoK
zA<X{}h7kJp9YX$3-w>i9^!4xiyRYZI?w!x>bKO1XUj3feYv(!7`&^&<bKQTQ`+3fD
zo}FX*>tu_Y{>rwvY5$v<Q@#2_{tsI5CjTcaZt{Q0;wJxpTioPdYjKnRPZl@%|H+*4
zq<JHao~WfMe~4@H&k1NG(wezxe^cKSEB+0R9}B!6Gg?iz$}#P5iN#GjTx)UD4vQ^r
z+Tme~n|657;-($eFgNXx#JRo$obu0MzR@bjw8L(TbpVw^@oPA~3-A+|(P|KL)1Icj
zqapryh@a|+pKWpTJ0jOv+<cGRQj7m}wl;ah;`{OZ^P<IH*;~i2v-tOkntyKbq-L6L
zwfH~BX>M*-Fzs-Bj^+tV^xE*}&G{sAYUjQ>BzPQW#hdn=>EM@J++2UFu=q7SwaG%}
z<eLh<Z(8xj_g#yd@@p;rR7YLdW+=Z8l;3)(-Z1T8%0I&5+Xw2nF3c&<-cZhHE8dio
zYjKn3REuvvSr>L8l-~==UuMOd@*lT&gvY~kP)-Vz^Nkg6%Bi!s$@3qJw>w4`w#S`%
zP3^#47=WJ4?e-jK@h*j0KNQO8p;7QS!-_X~UTSfZ=XDmJ#&7y>f%3aU`OjMMcg)c*
zz6|l^y(Yc#EpW4I1&YexF=E&EAm-FQ-E>Iscr0@}{&<U<d1jc!%{(*4;%1&Hw78jP
zW?S6MGxII}ePSe77F*oRGY?zb%rh@q{P>(mu&lGVnP<LXPVIAS5UC&jVQ#lio4fSu
zHb30rW;`5c@h1<{`aaBeQ=45i3LYn0@n*bTU~yCar569-a$VR}%y(0pU7-9Yt$0)Z
zD;EEQ-?Y62<s1X${BFgYa)O)xRGeualjpv7Yq8<W%JlX@%y(0pM{5*34z}V=`KMX@
z`axQB7L;R-?exlAE8diIgT+mrODult5xV?)q5PvX3Lf9J;!XLr7Vn*_MVq0V&QMP4
zd-R5BA5+eu7B_izwfL+3v_6G7wdavg{%9-yUcSzg1M!_8eje~6fZu7AWAc0o;yXh8
zT1Wgx7B}<EcNRDE%%2uF^UU7Mw3%r)GtV4iaWl_!vH16iT7QDY%{(*Q;%1&X*WzZL
zDYCekXXY}eemPuQ29Hauc+;NGIC!<i&3IU6@w553_5pM9O$6UP@6{Wo-HdO7#ZCE#
zT0Apf>pL^2@_A|tUKnM?oAPrl{x=Vn0x0KDU3Bnxs}*m`xzpk%&xbAk{&Zc~Q&4^f
zD1W0BZ_2N;xVgT!9m;7B<s5mR-mu%Vo5f9@{VcwErq-u3r}jJq%D=#hH+f!a@mKkz
z;3_Dm9hCE=6>rLU!Qv**w=MpDx-RTJD8DU~|GO1GEL*?$KZtJw@m=rN8+N<(vbdQa
z23q`Y?%$CXpLew`_iX0Wo(F^P9ag+)hX*XafD%*7V^GdP8U>G^Tk)oxZ!B)||Ha}a
z|E9}zp{5<KzD94iWKQ|F)+l&9#fmq+=UDvq3$-W@%4r4VR9Nw*oZBsK^1s*OCjX}`
zK6bP=d67Bge<1k&&x$v``#hk7OgkL5uikFWoXX)tSMb6B;7t^HeRmyyx>b(Jzrczg
z$noV?{JuO%EU@BNk%?L!vf|T^(tNcQKbhk{vEofWTdny2PzBYp$Afxp+QH=0jyZ)<
z(PKHjyA^NpIoXPD!ST6Pyvb*}6@R5pBQoELH~Car@f;p`#)>!j{2SsEOt4yiZN;1M
z@F&FY2k{3yq&Hfq6<&utiaAx2hfWYUz!874#lPnH^DK++#tkvU;wH~aEpFz|>nvWE
z7Nirog*oN9k4C}cvsV1tf%?UlA%1U&|Ivy!`TTBi(_hV3Xt8Ox4_fN&1m={_UQm99
z6>rKPVR6&H<1Bvea9!9W=2ZTkP=2KqZ_0nf;_c4RqNkypW>C(5taww-7K@vH`NQJ(
zjMRlSd04M0&!$j*XXd8e%J$bUc7u4HN`e>mU@gV}!_R4D#ypkJQ$z4-V(=K;Y7@b7
z%zJ-3pEQWacE|#b?VJM~`?nZ4j;nIuI6f<Y<Nj3%9QV^I;0gSkR@MBR>V@-p4RAbO
z)B?xjR~>LXKGJ6vw9pEV*XH~0iR1Y|BE;kQNiuLe&q)K0=T}+4@%$|ZIG#5a1IP2y
za^QGATmc-<w=01ss=Aq_3i#m$s&zH+j=*bx9|61;cqia>z>frO1~<Lj8F&H@dg6S@
z3|>tHo&@p9z>fx=2K*S{S-`sh&jH>Qcrox}ftLgC2D}0|A1Z=ZD}g6Nd=+rK?pF=G
z2gKI^$LpE3!0|e29q?XIj+sQLo$>l`0#7c)@%nQj@Kh)#8F*jdX~6OGi!9(LKzt5x
zzElysS`55D#Fqmf0K5YDiNGs?rva}5J`i{{@Ik<9fDZ;<3!L8q1+Uft&wzMy@St`c
z0z82aD#T9$o(Mb>crx&zz|(-A3_J_?FyJ}BhXXGLehTn%;3I%n06!IYCGafZRlxa{
zqu|wQ;C$!}cn$DTP);pyeoGm=S_k}eh&P`<P&@OfL-1+>A1sNV3Gs=*`K?RvYBKP%
zAU+K^f3z07ng#qEh|d8&26!>>bAguw9}Bz!_&DH|z;l3C0nY_q4SYQC8sK@rYk^My
zUI#oMc<^Df+NO4%2s~jAy+M2u@I>H~fhPkm0G<Z?Jm6Wt&j+3ZybyRX@FL*lz^4GO
z06rCXCGcY4RlqL*UJbkicn$Drz-xh*0<Qx;9k@BkrgokIJb_ONiSwm_;MGLnWe}eX
zd?xTT;In{d0lx@%4)EE)i-BJZyd3x?z$<`X3cM0{Iq)jrmjSN^emU?O;8y^z1wIFO
z9q=oGN1E#mYUjDY6M$a@JQ4Uj;K{(R2A&4|8sJ&LuLYh1d_M4E;MV~!2Yx;93g9;Y
zuLNEJybAb@z^j4Z1iS|L&A@AcF92Q#{1)KmO)Rzlt-urZ(i_BY1D*(cA@F42w*yZD
zz6f|0@H>F#0ACEe82A$4<-nH$uK<20@Jis7z^j1Y1-u&g-N0*r-vhiB_%h&i!0!bf
zd;qAnsh#fwp3p*X5WgRIBJkzFlYu_~JPr7Rz_Wlq1Uv`$3gE@S9|m3y{1M<4z#j!(
z3A_q;74XM^R|9_>cn$C;fY$<l5_lc(r+`QH)*IB$PXkW?{tWO$;46VA1Ai8H8t~_U
zX90g6cn<JYz>9&u0K6Rdi@+;@zXZGzcs1}U;4cHO2L1~08sM)2uLZsucpdQ9fSVg8
zsr_FEp3qWn5Pt)BBJef9lYzepJPr6;z_WnA4Lk?<THwXN{{_4p_&VSf!2b=r5_k>p
zD&X$`uLk}u@EYLn0j~wV9(Wz__ko*>s?^RO08iLQZxH_wcp~r(z>|T01UwD+$H23I
ze*!!Q_@}^&fqw?P9QfzJD}a9iyb^dV@G9V60<Q+X5qJ&o{{XKAz6p38@UMWIi|^FV
zUjt9rS8ovi26!Uy&A^j^e+xVf_;<jwfPW7>2ly7?#lU|6UJm?6;1$5P0<Q#K2fPaS
zPr$2z{|vka_%Fa~fo}s|2mDvy<_9>aoqq$Ku%F%_{yXqQ;M;*G1OG4ZG~j;#&jS7@
z@EqWO0WSvrH*g+S!TCd);(htG!+1^kX8`XG{AA#RfoH4drf)_8KV3aH=TdpV&sNV(
zA4~&&j(T3n+gAX8L_P0IiK(SBc+}@VblmLE+#KU*la3=M-pnDy>9{aY{n28^HgP&G
zOd+Ti(^kZ3o;U5Y9|5({YOVS+W92a5>lD9A{n2t9@PDgqQ~n^}G(Vg2vw^>-xEa$E
zfYW?y%DE8uM^Mhyz?&#;mIc6fH&CsY0&fa@Iq+t{9|yiC@E3sdscZ1+8sL0L5BR&l
z&6uPYJ_WvS5UC%&2F^n}cmc1ICqVok5Ptyhrrap>@`1q3{Y}JM0dEWOt$}v}eh~0(
zzz+uA7kC@sgMqgNehTn*z|RDJ2=H9s?SY>UyaVv*zz+p}DR46<(92f?PlWiJfgcWh
z3Gj}<mjgcn_!Gc80e=Dbk-*;o-Wm8iz>fm{3GgJ~UjaWF_*US@0RJ!WF2Hx^or=a!
zSK#{qKNk4Gz`FtO2>dwU#{y3V-UqmutLbHP{{`jK1LB84d{5w~15W`y4tOu%1;Bd)
zp9Z`S@QZ<`0>28lnG5OV8-X7W@r!|<0Q`R7{eV9Xyg%?4fDZuv2JjPszXLoC_@}@J
z0{;g1AmBd(9}N6&;OW5k<Vl(OF$4Gkz=r_u0Q@B2Nx(CK_XIu^cz@t@+&4=m@L>k3
z^+@2ufsX-x3h;@*M*zP7_^H5W1J43}74Xx5-w1pp@H>Ey0)8)WI-fBMe$GPYGiEXO
zpHjb^VW3*S4&|H)96x^<4g6z>KMVLK;B>xZmaV|)e90_-03TzZS~uf^H|2RQ@cn>~
z1>P3;IN(PB&jEfc@Lb@1fR6`05O^N&;lL*VKLdC^@EqV1fu9F_67W*slYw6Xya4z-
z;O7Cq3HbTI7XvQ@ejo56;Q0BGIj5tSpNIIV5dS*xV&M3>(gnajhWHZTn}AOP{v+^G
z;M;*u2fq6rdV|K*4B-0!zYzGrz{`Li4tyr?F2H92?*;rK;3oo~4SXo@i-C^<ehKh%
zfnN%I67X{1CBQEOelhUNfnNpu3g9;ap9B03;8y~_7x-M@j{?66_;bML0bdRLYT)aD
zUjuvt@N0o@1U?`57U0(b{|)%{z$1I=4H{QB0B-@j0(dLnHv&Ht_)Wl%27WW}6yOVh
z4*-4(@J!&h0v`$dHsE7`F9bdj`0c<i0KN$LMZoU>ekJh5!0~gvCBPR!{8He{fZqxH
zQQ(!pp9Ovw@K=G~4SXH&dw_2Mz6|((fZq%J2jKSs{~h@Kz?(GJ8#Jz#1K$Vu1Hjt=
ze-L;_;12;m7WfL_=Kr(F_hI0JApQ~HrvQHx_?f_~fad~#40s{%$AMo6{0ZQf1Ah|u
zb-<qjejD(of!_`M8Q>2CUkUsf;Lieo1^9Eo*8+bY_y@pO0sj*C3&6Jke-Zfaz+VF1
zWG}rz{a6jWCGeMl9}N5z;2nX#3cM@u)xi4ze+~E`;I9K84*U(^X98aXd_3?sffoUP
z3;2b=-v)j;@U_6N1O6}Iw*g-V{BGd?2L3Sc8sIB|zXSXg;O_$e7x4FhZveg?_(tIG
z1OEZ|2f()j{}A}@E%XMBpAEqG0say2Ho!jy-VyjGz`Fwf6nG!tp8+2T{Bz*LfPVq}
z4B)lEbAf*eyb$<C;4^^#2l!>cHvzvE_*cMh0sb{`{Ji)Z;15FlX5dc({}%X5z`q0j
z7Vz(ZzYly1@GpS>0Q@`PKLXzdd@JyOfY$-vYj3?l<LW2i2Lk^Ycn9FW08awG4R}xB
zzXBfs{5Rm4z<&om3ix*5=K}vP@X5gc0A2$8Pv92={|oq4!2br`k)Knu?yef|0^aUy
zadR$mjK$5q-Ob{AQb(wzhh9ZY`E8l^ws?2u$6I^=^8ps0%6yQ;uVOyj;>(zyX7P>8
z&#?IS%+Im-Z_INnzGo8+@-2QK^YbizDD$ZnKZ<#&#gAh?)8hS^Ut;le=H|VXY5!B1
z&$Hr3GdJ%|O#DRVH(Bu|%x|;!Eav9i+mthh`CV50eCGFA{1)a9S$r9DbM9x#f0(&B
zH#7Wc=H}eV@E4hza}4U%-Pwy)U-EO}P5C*k%sxoG8Sn!MsD)O1>K$wk1I~xUfX@cb
zyJo;21HMl{^uyc0_XYk7@cn=%aQ*1z1mJyu^V8tfzFc{VKLFxS1AZWI^M8;O-wOEW
z5Z@a3C~icGKM45wzz+tF_hYvKz8&J*0zZ&DgUW9Qd=T(MfL{Q-J@7@qI{@DZ{7~R~
z@1Zxy_b}j{fF}Yk1b#U18-RBN{sa#uD*p)Jd&Bv8C*Vf_KN9!=;GKaN0Y3`(V&F-@
zUju$L@O|KX?-<~{fp-CZD)6qr@qGAL;Lkz4Io8n2pVJPl7HXg4f@k`nHyrPhfsX**
z9e4q7bIhWb7Xt4I@oxZ60gm@;^#Y#SQg2Y6=GaFh7kD2X5<JcVo(lXG;C+E_1a6L@
z^zt4&S&;7u5T66QAMgWs5~2A1z+VM!j>YuyR^TT>{J}iwP&sM9F9bdi_~8BZ2E`8o
zekt(5z)#>wisI9O=K;?E{wnYx!2bvQB;arHWJl#^0-wv19r2;S9|3+c@O^m_r1)XL
zGk^~Vej)HvfIk3y1n_*GOsV`+fo}z#1^gqPWGUX93(?C7JjoItNr0C@z(*OV)}_F+
zfuGEiGL>^W@SlO70sK>*tSSCX;0N+#O?)))4B%%0zYzG@z)#`Hoys`}_^-gn0RMs~
zeTqL9xcOpO;$wjy$_E4D<A9$CJO}u>z;l6L0(?C1#lZ7`uLC{-__x6GfuF?(C(3go
z@C$)Y0)7kd$-ut^UI6^qM7=@fp9g$2@biJs1zrezIq)LjZvmeIyy@Y3gM6m~?+?5f
z_&LBY06r6V3Gmy1PXqoG@KWIK0iO=M86VVlQ)~wCMBo<!uK->K{1M<Yfv*KV3wRqo
zX&~Q=fKLEE8~6>tF9!Ys@JoPy0sK<nyYWd0`IZAe0r+LWOMzbw{3hU60Ivc*2lzVR
zR|4Mxd@k@7e3C?YUIn}#@Oi+`1b#K}H-KLQ{43zs0^gla!pL_%@Kb?b2mB7;*8_hY
z_zl3f0j~gl&{2AWd~XDv3j8MECBSb6{t)m5z~2OZ3-E7%-wM20lHQ<vZUcS<@P)t!
z0>2&jI^c_dZvlP>@B@$58|1qfcnR<&z!w2u3jAf@cLE=AjNYK~D}fgRzYF-y!0!hB
zGw^$Wx9g%esQhKX?+1P_@YjIf2Yd_g`+*PZsyC?o<-p$r{s8ck_+*{p9|S%N_(Q;l
zbkiFYzXJGL;12`;3iu<yw<YThD(6w)?Yl>L74X5p9|Qg}@W+8)*dtob6Tp83{v_~e
zJ)`kY0lyFU)4)qoqVdlF-wu2w@cny5<DUh7Sf40=4){sHp9ek#_$uIAfWH9zu2j82
z?ffF}!}><~OTd=^uLfQN{AJ*akJlSi{wu&co)G1)0zU!xYT%juqw%i+e;xSi!1o#u
zjei69O5kgNe}7^${!QS$)1v$>;HLtA8~CHZ*8;zCpx&T%_!sasz}Er4a8NY<-@qRn
z9OX5@e+B*y@O{&x@$Ukk0{lJT=^4@Z^}w$J{yy;bL!$8?03Uf$lz#|(3GfZTp9cOB
z@Pjg=<$Mf$Ebvc&&j$V}@Sa1X<$MPGY~Y^*zYO>nz+0RgEvFXv4Zyzyz8?5S;O&R$
z4H^&s0lvrZDBlEp1n{qb7Xtqpc!yJ><$MD?9r$M8=L7#1_%`6*0iQWSZ&3c<1Ahtl
z7U0cKjmG}~{Ab`l0zW=08ow3zXyA3g_c|>a{}b?J;6DS;2L221&wy_OK7OR$p!)s_
zd^zynfY$;49r(wi^aho)9e9)MDE}|;w}Jlw{1@PV0$+7{w4A?yZvy@|aPyS%$)pEf
z5_#Q3t#{|=v`XXW#GCSSTIKL_;?4Lut*+(g#0Nw9mB9Dp=d^kNcyr)ufbRwT9pEj1
zo3TN@djmIZOS~oUR-7C0eSoI`-xqi`@cn?70#5+G062M=WeM>84OHt@z$yMpe(g2j
z6yJvVCg2orzOU~G;1r+C@hv$CTG5~RKET$%DLzg8(UJn3o|^9)G@nxuqxjM4kCri3
zy!k%EeBcyc97L<%ss>I^&G#i<2b|)|IerCjdTRb3;3?n~zmVhC1E;6vbB@n|Q+yT2
z{{{R2X0&S0I|IFZAn+rBQ#sZAS~~Dn5I+HUYv4t|sT^}`n-BaTh+hHxVBk*yr*h2P
zv>vz_J0#l%ye*W|ig$9VZ#&>Azz+eQ4ZJ<@Qs5ncF9d!l@Rh(11HJ)xBJjU}9}c`d
zPezn~N8tT{9|1fAIJMjUy#Gu9-U;I806!A=GT@zouLgb;@J+yzfH&PkZ&3b615W~e
z4Dd|gU4Typ-WB+K;Ku@A0lXXVwZM-9{yuPOw^O*?wgESD56R4ZtyHh>1b8v`sS@vD
zpjv11L4tTs;HAJ*fG+^v3;0Uly@8wiGpT%js}#Jt9pY0VzC9nDD84W7e!%&yPw?s(
z;3q(QK5%L`^Z$)=fcJy=<-qx^Pw=X_Z;<lgw>SYe_W=^;w>SYe_w^A^3y6Mb%?DTF
zl#e;yqyQfX@uPtc0zMn~VBm{^rvqOFJOlV^z$u>(d0cG*J_O>M^GN{Ze-dzW{}}O1
z;KLz)C~$Ls7sa0pd^*HaKHqXa=KG#0ei+1?`>%-ese170dMJlau>)@IkD_=!l@53-
zK8YdDr_2FQ0iG2Q{m>sc<@qP)IRW@-5I+YvpSlLGE(6Y|t^r>SoKHmqz6m&=at6F9
zpKMY7X9Pq)>;s(g+?N8>k^=lpje^H);O1O|UMK~A7Q`<Aem3wYfu93>J@7HWKLbvA
z9?p3-<&#C)JQw0S0UrxI9r!rl6M*Lcp94G>_%h(*fv*Oh2YeIo3Ba53NiF4{54;ob
ziNMo=PXayx_+;R7fENH?2K+qWtAU>nd=v0O;7$4DoANIL-U;{=;OW4p0-pffoRiYa
zbAVp}@ymdh0ACG!8t_fPOMy2{&>NKhbl{zU&j6kd{6gRpfR_QE1AHd%Wx!_vUk&^s
z;G2NY2Huo*2DMQB7YEPuLnq*u08a;gDewuv%Yn}Uei`s(z%K{B8u%5!HvyjmyeXgD
zQ~p;1?*x1<@O0o;0iOVT9`HH9uLiyh_%*;+1HTsdCgAgdH{~}Wl>c?WI|08QcslSK
zfKLEk0elYd8-XtaeiQK3z;6b=3HSowO<U;=%KsMNoq*p8JRSILz$XA-2z(Ck+kr0w
zz6khg;CBGu1bi{@=B@Px<-Y`Y67Z$KGlAa;d@}G#;PZgr1$;U1yMeC-eh=_1z?T7U
zd63?q{O<+c75II?hXcPKcrozhz-I!dUC>-dSP1+9h`$Rs#gCxG)KU%nL5+gPTHp@>
z{}wovGoH(7ey|Rr%@q*8KX8hl!STt!ABOn8z$yM3jvo#D5s1$PPVtL4z8v_Y5MK$r
z3V1c}$AH%Ye;l~EKty&=0N<;P-XKo-e8~AE0e=$Wy91~ApEy1X_)`#H4E$-}Gl5e%
z&34x>E(HDz#NP#+;@fh3HSm=X|0ZyXH{UC<8Thjh{}XVE@6Y8YwADdW&F3IK8Tj+S
zvw*JxUJU#N;1$4M1b#bk%4Zhmvl94A5dSi8ieJF-wZN+(-dx0?dc6#MuXcKaIF+-U
z%Si(M3dDB@PVuWaJ`4D(5PueMiZ|bvT?TwL#9s!S;?4JHR|0<x;;Vtb4!jol8^Fzv
zBvF0W0N?8ny<ytHeBVS8@HZiTIPkZC7Xp79_;lb@FLS+Y0r0gD|0M8#0bdV%9q?_y
z{|)?a;N)w*pQ3$x9Ypo5f%r7w?*PvM{x0wW;8gySruxNsz~6)T<-peiUjzJo;G2Pe
z0Q@K5<ohW5CUnq2RId*qJ_Yy&;Mu@G0)8%VD*tOPe>U)sA$~FNPk^ri{weTJfqw@4
zFW{d8Z-1!Xpn81){7B%Gr@5a#9e6FoPXPWU@HxOY0$&FFKfoUbPQERg=@-`n-vsg7
zfPV$N)nR&r>h(476yV<g&j!93cq#C2fnN-q^6bEQE(ZP`#IFMWJ@8L~Zvp-n@E?FT
zOVk@wFY-N(eY*nxQHKPN!+~!FUI@Gn_<Z0$0bc?9XW(mr{{sAd;FPEN|B7wEw?TZX
z!}SK$>sR0@z<&dt4g7cD=K?3+Y;K=9z_&yEGT{FOz8d%+z&8Q^6L`~(dV})+3wS5s
ze*=$nn>MqkG<UpOmzL=DWb>>fzc9C3X?|I0q}znt(%eY5@zbV7y4BNe<IWz@v!JA;
zN5RzYeTEJxD9j(3pF3f2Zeih|+`RMCdt}UrKRDSVc(5*cs?JGHXRw`)5@ij`i*%cm
zmp3lIEHA&fbeyVfVSa;3I8`1dspE#8I&R3&;Tetb0&$#{x|#iIwWF?yX@c|}bWKcf
zN{Jc)8Cf$5BEh)XapU%xlwUfkU{=1n>to9A-d$;^YmLsXxMRfi96Ge5Wb`S+X@KUJ
z49y!cDtTP$Pz46%PRq~8;1OkpJEom7I4UbDE|jEMRGP2{WT>4=>_sb^(#B^aNOv}y
zqQ++<NOv|HyQg+Abgfp6QOe^uC2wj;es4A76-=2lG|x2>tSFrY&5UNK1OdHrOG<KQ
z4y6W+mgpQ^JCcMMjH5YM7@9qBRCiAvHLz4wZ2a`nog3p=kfQ?{R;Cf@#n#wS#RfZW
z_de4~RsUt@me9N~wWKJw)H$07&DEf+RGPbJZpm;CTF3qzR&tNtd8+Kv{87dEc?G$J
zgD2;f<mQ#;mkckM=1$id&i0<}=m%=FFl8J&LTOw(LTN^9uQeP9(H)^Q!+S>{Ntl5+
z(o|dRnjOJz^j)(f>^QyH8cRDuOlCW=BiLo_x*fqTc~|TR_CY589U(>;$Bs}G*N#vW
zI!>cILXrQDK$6&D(Qr=_cLY`AU9%(DO}A@ygdL|BTVrWQh{<dxb_BbuUAH6HB{ynE
z2s_Ml@0B-o%8dMy(rk5NlCIvc4OIhYMppK?tUPr-E}n_{7pW%Y`XccJNa`E=6f8Eu
zJSZ(D!C-(#PoxI-Q0HgrO<eXkp)w73hUng=6d8Ssr%#(aZoGO=nlW<NsGgEs%HE#5
zVzc*d-tZ!^d1D%+aaqRS#&pzgL>tp_x{+;c?-#qEjl+xdZsYJG<8Na+pfsY5=@1ax
z#@;(%O2M?@1*N5h`599t6y#3H2;RB&$jHtZojq>IsUuGrn5`~b_?FtEyP0>UV&P`?
z*>weS$GLX@=v0wAikf(&I{58qy1;mv8G1-F!;U7F?#b%3zOZm=o;tVBI4``OF}wdR
z=?=Tpo$ii!3yiZnN;CYrgW|orgXSRL?ugl~cS(2HrS5ch#9LsT-BIM(9Te}~9W-6J
zx?>n!Gq#THDbx5mpqYE5pk8_7)O8wqfA5Ye&4{C@(u{bDDvGD5A}A_2UeiTsI@jt}
zGPN7c429|nQT7@2*U9Y@F1vHp^cz!5g95BK_wnfCNW<Rcebb0XA4eMY38QZs-ugZ<
zSC~UBV?XI|NQQcKdhlrmjg?VeGP-1qLrxVC^^Ie!2)1#kcIavkacOJ_w(-bz=xgO2
zr)?an9lF|SOG7Y@+Dft=`dWEQdcigh)ec?d{Y5a619x0@%twf{V@YL;fmF6RE|^ax
z?ar}h%N<-h3YE$ikEFL~wyXY-%s!08qYOU&8ZmW3e)i1b*pJPEV`f~%&?j&89}Nti
zI(<s)W$5?|>y3qt$Sumxu&*}6Usi*}&d4pCzKaXX8dhYzdx$%?9`w;;eWL}rjmn*<
zJ}jUj&A^Mlv>q{~4V*Sq^}{YMuF+l5BSlDXNa0lV0n5%bqPx^aXIj5g1Y^&>=OFGL
zsV|1EoW-1E#<g3i_YWCG#icVd3iFHd^*-f2FuM0r?LKPi^pd>%=;v9DD<vzpWLkbn
zw3J3&Px6=|?IZ3E?i{dZS6dqY6lp8#yU}loj47tUOyoI5#uT;_Q)En84HEO5BI7A6
zYnZy-r@>Hh?m~8P?kQ3g89IhzN^?(<yR^8tC!UxD-ILkQG@`rIMrT^TQ}|7hc7^MU
ziF=BSDWNe_WK1EAnj*zg8Z|}Q=h_}qWQ;Wavq)PS{}gE}>$}l!ii|0y!A#^iMaC4i
z6H{bNSq&2NoFd~XEVz*{zA4f!&OJq{dlN&a$e7aHQ{*l!F7AmZCPDXPwlj_BF168_
z*6$R4Q>0zt`eNdqB4bKu%oG_@NTa4mv6Mzlk@j2O?!AlYWOVTKk`i@dOz&W0&afMP
z(9($88Fp~txBkYwMig66Mj!3Ox3|YsI~CtV4VoE@t=P9u!Ub{lA)&g49^a=|>h4w7
zr&rS3mY4(KF6kRp>JDx-X>{N0xLBXQiK({SH}=V|+&Aj87DwMmEgrL9?UEK(rT%}k
z_>PP9Y4Mn9%Pp>sR1Nm7crV`dnU){i>5`FEG%7{<=vL|qdk^i=Lr+YFQ>UpLfYq(u
z!h8346YAc(VA2$IH)?wR#DXaWr3F)`#C<QSomTf`omTq5?17ChgzGl7$XtzRR6FCn
zULH5f+g0M0KD9W1N=!?~<kjHg!QhsOIA_D)em$NI8=OvACFWn?oHH9l=Fz96%6kX*
z5=g_$o@}CHwKV>*Y8SFIW7RHeC&p?_QH>d^F@-d4ti}`rx4e6dRlAtRkJaE7D)-T$
z!Pp9JvJM@qr5RphRe5`kRePF_j@7*Q$Esb(&Wu&NteqIEF-0|Iti}}5xUm{jOykC?
zUCfTgs(S{^gHdIo;y%vxD42HU<O2GChTOdT4Eqz6m@_7vzwP&D@p|@9mph6Jm7V=R
z6w@+Bju<tr!G5KtYvGh42-%r80=@DI^K*mSPht*N(jmY;{^4O%-%%r;wCr@64et`{
zEu9!ytz{qK!p4I=TXt_a9zxHcagL04JlLK-<3UY{jT;ZjbO&eHp5wu;!LAz*J5JMg
zJOsDvH8_fdjR$*1vc`jSe&1jO(tq8VTVmrK54NYzcu=>7Hf}s9(_J?n>>BL4@v!4G
zW5<K(-{5ne20c@h(O12dQU4TIqW)3M{+PSrOclN5UQNHTch1E-&-cl{V0v!hv?=r<
z^Qd0q)NnA_)gM;s=kSJ>`kkqXmg=G+q~T@Pc-r*wqk?}2%_xW?ymxM~dPg%MzIPKv
z875q8OmjnWQAR2?`v~=K92rH<9O~Pl5f`=Mzc;fKhk*ULn`;QD=_CFjU{8!N1WMx{
z0%RFB1WGBw*`B8LRgHayKxuuSx-P;s7+}$Gu`#1bM2A4BGvyr*fgK+g;vWKeI0Wp^
z6<k9=O|tP10edclA&?jU5FpF2A&?i>5KuMt83K8JLm(P1Hl`T@c`yrz|G?F->BU)K
z$A<!Y2*jM%HW;}@8GTCf)eR*xV(-bSpPNnYMGf!%b`D?@U+PhIsb|@F9%bjrWxMXM
zjedoMI-!WYQ?bFz!M%_9<EKv=S1@JbRP~K2!Smel<4f|*Jxh#Aa;HqnH(#`(S;>@1
zh3cQh8^XeZDfy-xbz{7FN|<hx=X0F;-1Ys}>1V2|trNSA8#k$}Y+P}E$+W3catjMe
zXO5eZ9O;&)FBL|*O_^Gn-|eIkryo15RQ=l=Z%>*sy<2g~R3$2%$%W@n9yhT>-SVft
z>!f7r^kV#8nMOW8X^8$lAzPltpcSvTsxP={x?A+OI{53WA})P4>so@onTI}ybqS!~
z!$WV{2KDrt^CoYzcI98rzWlX*5vqT45B);cWBs!{^vhV^oY&+((nG&O@E_u#Un%JK
z^3bmq^z>UIrrpij)&4btes2%G`EE39|CSzl^Ic%5-^W95zT*n@`+DeuAFNhwfcxKm
z9{N@)mKO9+@X#j;dio6u({E<&>c6h6$MJiBhdxE{KhQ&;CiqjEn7qx}mB0B7BW%Cc
z9{OzdNBuz_`W)6{`<>^ZpDg&F@1ZXh^o1V!a@OPcJ=jCPK=5zlp|2G5Z9ViWSdZ=B
z&O`sC;D3mRzFP2a@1b8K_;>KouNU-(dgyCekL@?pL%&(@pXH(7Cg?Bn&<9^cujWr2
zzlV9~TdCtUEx7+Ddgv1c{ox+^uB^xQ@93d7->;4NAK{@-6Z|`Q=re`-AL*gb7WADx
z^f^NQ^E~wCcgnE+=r?)HamTD($DdLm|7$$-<%0eW5B+>Wzt}^+P-s8;jXG0rvv$?L
zQt&^@LvMc94cniN3C7o~UH&Tt|A##Es|7tBQ;e@!yZmbe{lgymPX&FFhkmo5f7C<2
zP0&B*p*KGkiT(GyhrT6$k2vb-w-8Oco3*R`+X(ujJ@lOf{fi#@WY**S{gQ`1RnXHp
zg{ik$yXv1N=wI>BXA1RS?V-;W^sjm7a|HeC9{NI|{%?5bO9efhlbLomYghZv7W8j<
z=;sLaU+bZ-5cL1@&@UGB>pb-4cLQ+z|Jy@fCA43Shkm7?f5$^#E!6)#5B*v}Pv_)j
z+?cg%{A>{P?|bMs3HATLL%&7P({JvXyv^E`zxf?e?EeiO`o9GKk395EIYIRQ*hAk^
z(0}5gZ^e2%e$DaFCkpz@JoH@!{d5m~s-Q3N(5DOfi5~haL7(TLA0z0~J@k_WeLoMq
z`JG$r|4%*i<?N5+x4k+iV_d&>?SJ!x{I`1eFA)4Yc=#_C{D1QBUoQ9`=HXu@_&4>?
zuM+$dJ@l&u|7ITg8o{4_Ym#yO+SUK&_mOe@weiqz68t-Q=(h;<Z|k8qzgvRi{|FDg
z`SE$Ie>)F-OaA={^gq%=--`8k{plEw@t?$c%>N4yeTtAjUDJzq{FvXxM*lB8^qE5b
z8$I;q_dn2|errD7{Bs2VO&<C}LI0J9zD#KUuRZkTg8my1{X8Lmx+WWM`z;Xk^c%<V
z>MI5PcOLo`g8q9C{Yuv3{=3CPUoGf=@X)Uj^gnv&Ygmu-M;8yh`5k%Of9RTey!}@v
z<o~OOemm>Y|2Gf4`MrD8|L&nr*dzA({dNz1dqMwS4}FrL|HDI{!g?IPe|qTq3HrZ0
z^yxzWe|zY&1pPlA`Z0q3e;)eDf<EGL{4QlZw*PJ(`q_fMiHClUpx@m?KcDqDe{}U|
zze?8Q{@2{Ye}$0$ULN`<1^*Tv`f5SHw}*bMpl|7+-yrDs@z8G)^!s|~>sXKDcRvsP
zc0r%up^xktJOA$Qp>HYZ5Ae{p5%dRo=sOAeRv!9f)?@p(_Ryya`hz_5X@dS>4}GRk
z|D!zg*@AzPhklHpKiWe-LCF6Y4}GzqKh|UZoGs|PdFba!dXM}UupY<XaUS}`f<D<p
zzf8!#yNA9?&>!c~eyaq1iiiIiq5i!*^fiLMw}*a%kbfT!{U$-5>Y=X_^nE?_e+l(J
z-b3G%2QHp}oZz8P5cK^#^z8+Gvd8#K67>B&{8I#dcMtzGLEpneKb-Zv3htji(IfwC
z!GEBKK1a}}d*}-VeTIj=jP<+<>OaIoUoQBc<e{H0=rcX^3k7{okN#gK=!bgvR|)zQ
z5C2tyzL$r74eNOo^xrU#{A&dNQ#|ya3i=Tq`pts=R1f_&*7GW;f0l>-FTwvb4}J5!
zV$c6adgxmT`raP>pD5@@dH8o_J+@!AhdxEnpYEaWC*<G9qyCwK{!9=5Y(YQTL!Tq)
zFZR$E3i>e~`Z7U3)<Zvs_1OQp9{Tx$f2v3SEfn;59{$S&{R9tvm7u@cL%&MUPx8>O
z5%dKf`t_{G{wws*e=7L*_2|FNf_{pJ|29EC)k7a?5j+3h;-POT=u15GZCH=(U+SSx
z6!c{t`XoVrp@%+M&`<Z!rwaNR9{M!a<NKeP9{S;eewK%Rw4lGpLq9>N|7;I^q2Pas
zhrUekr+ez-{rsz3(9iME&lB`lc<3tx{be5dg@XQa4}B%;ar|BBp<f~B=X&T@3i_)&
z^s9yX&-2i)75uO9&~Fg@>3=ff9e=fgzQRMlS<v6$p|2D4*Lmo-3;OFl^pU+|k6$->
z=vxZ<n>_Sw1pUn(`cACJ<KF@geOJN%Ru6rupuf#SpDySZdg!wR{p}w5F@k=Phkml4
zzr#acD(Dw`=*tEDp&t7AtjF=Q#6!P8@E<Ikzb2~POyLNB+^2Us^;pUJc4orjS11;j
zL(~R^q#;z#C)3T=YBBc#ZB@CqP{`EBd@n<16+@AHyEjRK<+=ULvxaNizpHwg%51E@
zx6)FXd#L<yG5#G8s^?Z%q`P84{jC?8)6I5jG4-VS)AtA1_0Ll=lK%#-KeZ1omQ7@=
zdQtLEWdCFqlRtfbfbCzQUYGp;VgIoDU+eJC66#OiA7J~__f(L-U9Uv`;*Sn|ACU?P
z7Na-Yuc;?e{sUU;h~*}b*S1f!;!^uf=KPJG+OM^c|5l|B^0x~9n*H}>U$dfET<D%q
zV)ppk#`<e8SUtCFBIbW;)2tT~=w?l|lm(BG;QAl^|GjBHGcM0zf4VmXmrD-PTju=F
zyrxSvTagI;Pbe`v|7%!(Ml>{dX4ym*DzVi5^Em%Z)>Hc*qGIj*>3_<|-_F05{i$qR
zC>9sGCyAJy|0dRl?SJN;FuVP0IDg##=>PBS{JW@nN&YPk)>)eRo1E?T>#Ts(ei6Fa
zRxPHVsr?cKf4Zh8`Hy7({f#lNZU1W>`U$Kb6QZB1^iuw9IDb=r%Afv!-EO}Z*<Y<1
zEY<8k$(lcOt3*TJXT9D3Nj&kjjfMu#Y@Zqhr2KP)_NV_}xAWgm9k`_SAH@DQS_#|!
zEtFpJFJu47tf%&){~xyf^Bn%`57iY9tN&Pse=Xgttri@AG}qbwOC0_`vVU0p7drg6
zvp?3K?tioWe{%SjCkE+9!s<`|CnvRk4&5xS7OX$r|6%)gQDTa;$KRqvQb!_T_3y0o
zl7AWdWBuv#Yuo=)hkw_O+CQxRvmE}lbhEo!u>SP<v+e(^!+!|-ht0oFI{de@KhD4O
z`J?Usi^IQ={YU6#sDD(uQG?}2hkp{?tgjZVKYe~>`?po|6Ghtn{~Y@t6O<Btu>I-(
zOjHUH`}mV4_|xYPw*T=C|4r=QFKQh;v;B)4`otr&a7KuJvLpY|oIm#82}1sNIQ(yA
z|FHajap>P=eV35@e{|$OPso3OkpJ;}$o>CMobA_3>81W(Dfp)e{?|GDOFQX`^I^2U
z73}{1$f2Ll`u|!2YcsOmk^g4Se*-(y@r&NS+T*vUy3a`AnEhw&QCdj<Glh%o-%aVI
z_N(5kg_~JG{uzQl-KQt{Pdr+?hRvT>IQ*B>Kf9;}=Z}*F|5qIT<?P>Cr&0fC*Z&2F
ze>MB#{x?+cr~AC5`rpU?S@q8PiS7Tp!@o|b|1iP7qZ$yB|8MLcHh*?dda3`L(?1KT
z1>64=!GEyBKaq{Y=ARi3{TSAV&7T)I@=xUavH!A!{OLX)sr}xKGk>~IMAGle6KB}`
z`MV?kEFu3<LjHsIlKqco<FNJ{p!8Dzmka)<3;wq{{HxeMZ2sKn(63>A*!=mKBmXMS
zALq}}LjL_)$nEz^H@&}x&7XagUTVL2^v`l?!TIxS!T&~w|J^)r!{*QV4*%jh?T`EK
z7{UK-hyN<}51T(<clgg^f877Z3jWRZmfL?L3rFg1sDHHQPx_ohYX6l&{c{BWE)M?`
zy0EF1WAv*2(f04`@UId4#|!?$9sXn4KWzTI)S+L*`mp_fmLvboLjUCp`9JLNPw1hW
zEG++K>H?c8Hs<_gIP1IAx4eF0w?BPBq169vexgz%5gdQ?UQkW9!D9A{;ST>Y_77{n
zlN|n;g8zAf|D6v1AKCvP&eyE$`hV}xH|?nvVe{wLj{M6wf1E#yg#0u1k^AqTUfMrw
z{!CMPssFNm*8PX`=TyOek;DJ<KH7hXF2*!p#BRS^9R8{F&%SEG`d=XU|KRZN)K^;$
z4DsLW@K2zB7PkDS3H~Rj3+xnWzki;1d?1gc>Q()tUH|JH`lYNtsa~m{*!ruLUh2Qi
zoWI%6=>5YCA^+zb{$I0yl5U3jENuU$9R3mdXKA%y|CI^;|8@B9%M({#i2pW+{|5H2
z<IJi4vjqR)>T@Qtu=}s1zZPE2db6_Yf0EKm?Z0NbPCS!^<Ud>RztiFW7yHv^mblpd
ziyZz5^ud5yma~}rFA@BIcKGjcq85gYzaJd_E7>2%U%B9aXoB4SBiKJ|{Iykjsr_r%
zAIIP2g8#V={~2kz{$c$;+Tp*P{@GqF*#GqXTlVp<%HbawsQu5?#pn(7X!rj^4*xp#
zuVW?k|6IX;cl7}aS=i%$>>w>{8RGws!@rikEI=(d{^kk(XE^-N8?61q#@}g5FZKUC
z`mzDF;P|^n@W0&Q|2X@HjlYW>{*~;H<8Qv;zslkNak{R5cfG2AwEO>n1LXc|nV}^^
z>XrJ5t<Q7lN3!0GUsH^&f7YR2#QLtf8;m?={64AlQva3Fmp!P(_|y2kQE0z!9saL#
z#ow%V)=%vGH#z*P**}N%<bSi^f8c>~`&aP5eI}&-`zpOu|HOZ^up0bt5&VZa{4<AY
zVc7V&%b}me`mpiyvqN9adeeVgjhOz=R9_H5HMQrT<|k{#@R0T!tn^a*)pGmgurc-D
zBBA}t9RAtEv~Uya&B`7>(;WV3^kpGxDPtk|FBbgocKD|b*TS&zv&7-QlKrc}f2rXA
zvBSUa6fF!JKgsGo5vr-(e;r3?ec1T9%%Pvm`mpiyp+jHA`YhcI+zPSB&v%tx8b4(`
zQgc{I{dbShetW7nh*JF{Sz7pYy|aE|kDn$=FZpj^e;hye3jW<4{$I0y*!bz{@Xw+z
zn^8-3@Tl+KxnJ-vaQH7BsfB8IHCXKWU+>UA&U$rtY_Qn+Cms6Lar%Gc&~J#-|9=ks
zcX9f6QWt2Y@$*ld{-?5@zMBV^gi(5{5}|tD+}b`_>80_Pz&A9lq2$y;<Nr~i|8I5p
zSH<anqr-m#S7;&lKPLEp;PB7N)_GUzRsEw~|92ez#m#hsV*Q^G{5z-<OiIyi|GGH+
z+bF%%{;7Lvf2{vgg8#V=|BBOfl`HFOuAkWTAMNn3X&zgDnoEpc$%18>!$0{9{d%Qd
z)jt}&0e3q57t)t4sRir*tl+=N;a|i4$;OD+w*MCn|77~ICAE~Xj>iA<g8#wl0|JF(
z`ag1}7KZsBp!8DzFK7Qu@P9$@KiT1*%>Jr+4Hmop84mwC!T%+}e=hsm_dn*azkU5U
zu|YPG$SaQgE8@)m1xNm=`{@3|_IpLh|8GbB)$DJ7{$S^y+D`8Ox;XRisq|9+mkas7
zCgfkr{&xE(j@Atw*8WwF{IggeHhvy*<iAG9pXO3C{!F>wJMu4Q|FHJ&to{K&6&thv
zRmGYA;Yu&He*%5knOboCye;HEp8f6iuVw$R_FwAAKjEyvzW(}!-io%L*}mP8|7aoq
zbwd6hIr2|q|FHIN)n0D@;yCl)PwA!huN3lsN63E=``hhb!Tx+3t7)!CLj5!Sq}Y*v
z73=MIGk#4m=R5M>%=w%7pN=2&`wK>I#{W`B{?&2jzn1m(`>)SgKi4G6Ydxx?@C`@)
zZT8cV%Q=+t|4_((Pu0K*$GrcWaJCk9j#>rJZ2u-oFZF*l`(yikB>2;P%98&z>|Ye(
z-{0Y1$Nr|DsQ#Y_{uep?x3hoP`<GW7`WENt#Q8Sl`dZlS_ktt;<_S6y^Z#7Pe?Mg)
zwO<nZ=hi#xC$@hJrI-3Ik^OQ0tQGvvarj@u{`n#PXE^*P3;r7g|K$$<I`%jDn>6hD
z-{bJFVt*XJ^!?xV{{OqfKXr_D<hN1AKIZz_&kp}uq5gDBvhAO7nB4#K**~S;SwFGs
zzrdldW_{T8qpuzMpIQHSi2s*LFO9z>`m#^8EN4CKzuyV<@0Tdof7!WO_z>&O%C3JO
zrI-9`*uRX0<iADmuTXl0W9HASv0A9Qx4~ljUz;fVXVRCIss;D|9|ivpm0t3n5~u&W
zN-xzvNARaxTI})H_HfyMKKma)m4L;r|5%59DeJ@L-(?PcRh;^*4*e^v4?F&Tr}R?$
zm2vyw_@!GS?DjjRquhR(<8-5i9e<BhddWYLzN}U)IDh>v_~$$Pr?7vaPNV)&ms-CW
z$#M8+u|JMq`bgKV|5Atl$Lt^0|6e)uTUdW+G}Yjloqw$(|H(rB^pT*Qe-Cw^y}~j3
ze~TP#oU2#$kGB7@N-y<aIs0d_lI9=!NW}KP#Nl6<qlIC|-<b~oHG)4Kylnrs9scjK
zzsaAg5p(=|-Ql0mO1Bh_UwV&V`?u>Pw|_fs_^{(|Yo(XkKaKrO{?z_W1^>wo|0(Pr
zcKm(Dp}(8;-A%*sTDM9R?scSG|Mjd7JN`CRda3^Nxc<x8it1076z%pO=kT99UJJvH
zzh^uAlUwVW;_;U*Dcb%|IQ)C$Y5%bO{}G4(a`wmhi!Q0z{(m_9v*Pss)!|<)_|scb
z+rOVWK<uWfYQKM+!v0~$-^(2Oa@L2<zi&A7H^r$x;3zr&Wvrje<Ik-0s4!cR$UaIh
zjo%I2e#<$O#xG52cKe;;@IPjP7OLtsSZx1HhkrSJ*}7VA{-Ts@|9KAoEcTz=z&-Z!
z&nq1MRqT)B_h7;QWrzPt_7Cg-=1Fq@y~X;l{cm@rZ>s8;W;N^@A%FV)ExY|rcld8+
zf1U>GThX$KWI6n6**}w&G=AC({&zY2PtMmuUOD|2JN%QVv($qA^!+c*xg^uCKRW!Y
z*x2Y<7IXalR_UeoFJ^xnzlnl>|D)yp-_HJF$KO<?m;5V*`gaukuXXqjpQvjbcKrR=
zp)Y5B*zvcky1**UzmKy%?D%_>(o6N<%=KT+9Y^D@vrzxb9sUz0X<^v$_hN^CMH^+N
z7CinY3H~2A{1YZ?|FHf49fyDOw%Xr}bE-f6{z7wIZ2kM<4(bBE)c)P#^lzi|Qu`+g
z{#^zCaSs3C>>qagUFOh_WqsKE`<+8y9H+ilSGoNzXMIO%Tv&9kL_xCBOYN7+?N`B}
z)PLQD_Pfa8zpOwD!|MO8L;p1E!^U5iW99m<XZ`2Vss_*O`gc}(ss3xY{>!2My`=g(
z{2xD03r`C1pW*N?rh}zgaR2Ee_}}mF|07QSyB+@X1pmH*|2q!<LFem=A09IP);jzv
z*&oLr{r*F9U2J{39NbOr{|SXUFl_uyap-5TK5YEG;m|K&ec1S;|Fe|FU-BWk|8e}$
z?=QsE|2Vn+B}KaaVdL)rrI-9Sus@E!fr9^FhyQcz-yx*`2RQue*dP0Uu;72S!+*n+
z`1-%rq5qEcVg27%onT4FujW&=e^~#gD81DF<#e*D7VQ6%r20Gjzh?h_A?-iM;h#i5
z_N<n=;8EXyM!)}HkH2*e|Be@EA$?~6F1pkxdDG$FhEA5%QXM>MfBO9f+rM3Rx%~@E
zwD2_6o0aXK@6f-<db;NW7h9jB^iuzA5b_@(<o}?<e@>}(rQa;a#rD6~;lGf6EL$xV
zET-dkmf-)B!+*_mEgZ&rv$FlSIQ*07&4yZXf=AtdBL)A|9&-P+nxTcKH{$|$W&8J3
zda3>Av41fOsQ%f4|J4rv^DfecVe{u4hyQkZv!fQAKhF^SpK|y=9;bhm!$0AOSbzGi
zH+%p2*x~;N`!CkbQ2(e)t>26^>nZo&t+RDZ&yevOQF^KWk~sfNwxa$!N65dI!~d;|
zwXlDPf3m~BnEi47J6G_Z<?wHQsrIMuEWyQYzv&MDoK8Bjn#ENAaf1Kr4*%?OEj*3&
zW@Y>Duiju&iuU!#`^vRqbx8g#m0s$<#3Qv+wJs*Oe|fx+{}~Sd^Dfsy`pzF*bg5Bt
zn!~@A{c--AAowqF_&;)m_6VE*7CQWk>CL`ca)L)a|4kJ9H#z+OVE?fB?+b^24g2H#
zH(BuS)l2UGtgCh6Ve?<I(o6lHcC@ZP&VT0#{<#kSg>m|iarloG{0jyDxeotY_Fu^T
zXI8paW-AhT%%Ly4M#s=^7UE*-S2*%7=KOK~n=0i0rNe*uwc7Rg5dTjd{wvuZ=f4XC
z|IWST@w0Kh_7D61fy0$v8b8bFVv$;^gGaspOcVS|9R5kyYvHM^H!EGL*@{G7aOlfe
z|8z+Et#sr+nZDRnE!DxJ&VPoGf0I6P`*q`qEA0IJZ-;*pUF=c|&VOZs|4@hjc{l3B
z!{)zqrI-3|CHv>-VuJa9mf&CE@PC^9Q$x=Gu66jgIab#n=fBy4|ECWBA8*x(^EAM<
zi2eMgNvhm`Ww&XG>YfIR&MJzAI`ogQerq%|cxLO<m0oK9dB^F<WY*L9L%I61&;MpP
z{Fg4&!rr?#Ou+WPz~R4={c~7P{+A2>pE~^4-=TePZfGB|{Xca0x9O=PvHo)e|J1&6
z|4rr--}Dgwo=PvZf2QC+SMa~W;lG0Y!~XyM5{G{o`)}a<sr}~({@*zK*Duk+(?jOJ
zjSl~;6lJECoZwN<f7b~92OKZA|1o!Jq3YfSi!L>a&T{C-v;OO7Xz<L|XDhwbe^s16
zj-Ts<{O3CSGb^=mpOF3MGKYVyX+PM1ZV>#pIQ+}+(f(ok&o>VLv{c<vSpORZ|I8EQ
z{%f^N`-km6gOy%t|6;-aX2JhvhyQ5y58HpPclcMbKkh%b2>!o2{LAmv^{4NQ#6`Di
zl>F@QFQbd?YRL&6_5O34;NP*I-2UtC(?a$3u)$*c7dZ4y?$@$c8>nNCe-o5m>c0(~
ze;d}*{If{N|5k_p>+GMx<KLuV=YONazs|HD>&bty;QyDy|BnZ?W7z)lyTd=Lzs?l*
zpQVET=>Bs5UH_2w58Ho6DZSMG<$`~u;D3+9|6TSE+kcii{Hxd>_n*53|0V<E`v0*)
z*Z&mL@x0cp8iidQ`pk!Q%>L2P;F+x->(HOg`nnK(r9*%6BU*T9h<=?zKbiH3A^Kk(
z`gyDm`~0^~>80^AZ-8zo?7s(u{_Aw2+<y-~suO=bB>%&dUh>bO54+TY?|&Z>{6{(b
zi>tKpO?p-Ts7tNijL`R7N&d^(ALp-!1^<~2|0a)VkFfWj%N_cWtf&9^#>LM69!LJw
zoPRZoY5uDc@^6+V_g{-Av~UFL&C2#a&Y>U8`mp^k*P%a;_3Mo>uWkQ(9QpxIYC+ik
z_l`q9hV_TBuUXmt+a3DZtPlJA^B1L;#$S1wcEbJd8HMckZ$}N3`)|=xI^)+&;=H!=
z@2K>W|7iNKS1q{zJuCR1;qcFSS{qjARsEywf11O;lKpZ2dtUIL?eMQ-|Ezjv{lxZv
z$e~YrM#qQkfA=}^U&;Abvp?;BFADiLA0+qR_LW*Vl=Wt1=ikGjAM~tNgzbM59Qth5
zKWB`2ZTsKn(C^E_u>EhnL*JG4?L++kbm%i#zyEFx3$XM5P3fiaUp7cb;{NxVLiYZ5
z%wW0y&VF9|zTD70=K95vN-z0m(ajEO!Ts+I!T&6WfBRM1c&=X6Kk8EJHzU~&|Ap+2
z``?>_|D_K9yV*bN`r#uE{g12<+y5SL<X^@4S94Wq|642MpO7y1-+eD?VfScL1<&mE
z+gs_S{wq$`k=TCg1pj^x{|)T_ZHRv#hyOhG$MI7m_!m0-UwJ9M`cHEB*9i50SMXox
z@ZZM%{|Tx8%?|&~LjBhZ{%aim8>-{0|EmuF<P2q|7VQ5I1pjRg{}w!PysFcvf7GSc
zZ$`E{{4?1<nL}y(ZxH-DW$5w0yH#)v`zJ)Lf@fy_Gx#v2Z>l!<bj9FEnc)Ai;GfC<
zO)URf_CK(`ME%6hr;zpa6EnweXZ`-_`XnxP{*z4p7^I#r=lrYQ(=Sl_eJ12z=I~GW
zQ|sF7-mqZX|5}GW=^w3odAA+w=Q{Eq-Buf?9jx_~f31-JoeuxH|7jh63|F6ooj-lg
zXwd)l5&Fr(WbNO)t==a8je`G^4*$d^y5fKD*RWvQ|51m3<xuUP)Gq43N${^`|75G+
zMEbE(wLI2Z>&>GHGu`sGL%-oD9dV!u<N|DcE$i+5uZ}Ogn0VXYY=2_vuj+=&8v0>B
zwcz}-S*U-@A$tEe^Mom5JNw)FpQ(;nw`RT3nf2aBn+QYn+NMV;{hsP2EB#0U>+QVk
z_UO<4wmyyZX&oE-+xk?cm&R``w_idBt*7z(gZeXi)2>t>+nW^SeB)2e0Ijc6LG)R?
pt=~(%tb0nwna3>pvShWi&N4)=?e?Sddr4ncuIUI>KU{46{{d-py;A@H

diff --git a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o.d b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o.d
deleted file mode 100644
index 2d4217a77..000000000
--- a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o.d
+++ /dev/null
@@ -1,50 +0,0 @@
-contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o: \
- /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML/irrXML.cpp \
- /usr/include/stdc-predef.h \
- /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML/irrXML.h \
- /usr/include/stdio.h /usr/include/bits/libc-header-start.h \
- /usr/include/features.h /usr/include/sys/cdefs.h \
- /usr/include/bits/wordsize.h /usr/include/bits/long-double.h \
- /usr/include/gnu/stubs.h /usr/include/gnu/stubs-64.h \
- /usr/lib/gcc/x86_64-pc-linux-gnu/11.1.0/include/stddef.h \
- /usr/lib/gcc/x86_64-pc-linux-gnu/11.1.0/include/stdarg.h \
- /usr/include/bits/types.h /usr/include/bits/timesize.h \
- /usr/include/bits/typesizes.h /usr/include/bits/time64.h \
- /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__mbstate_t.h \
- /usr/include/bits/types/__fpos64_t.h /usr/include/bits/types/__FILE.h \
- /usr/include/bits/types/FILE.h /usr/include/bits/types/struct_FILE.h \
- /usr/include/bits/types/cookie_io_functions_t.h \
- /usr/include/bits/stdio_lim.h /usr/include/bits/floatn.h \
- /usr/include/bits/floatn-common.h \
- /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML/irrString.h \
- /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML/irrTypes.h \
- /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML/irrArray.h \
- /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML/heapsort.h \
- /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML/CXMLReaderImpl.h \
- /usr/include/c++/11.1.0/cassert \
- /usr/include/c++/11.1.0/x86_64-pc-linux-gnu/bits/c++config.h \
- /usr/include/c++/11.1.0/x86_64-pc-linux-gnu/bits/os_defines.h \
- /usr/include/c++/11.1.0/x86_64-pc-linux-gnu/bits/cpu_defines.h \
- /usr/include/assert.h /usr/include/c++/11.1.0/stdlib.h \
- /usr/include/c++/11.1.0/cstdlib /usr/include/stdlib.h \
- /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
- /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
- /usr/include/sys/types.h /usr/include/bits/types/clock_t.h \
- /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
- /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
- /usr/include/endian.h /usr/include/bits/endian.h \
- /usr/include/bits/endianness.h /usr/include/bits/byteswap.h \
- /usr/include/bits/uintn-identity.h /usr/include/sys/select.h \
- /usr/include/bits/select.h /usr/include/bits/types/sigset_t.h \
- /usr/include/bits/types/__sigset_t.h \
- /usr/include/bits/types/struct_timeval.h \
- /usr/include/bits/types/struct_timespec.h \
- /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
- /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/struct_mutex.h \
- /usr/include/bits/struct_rwlock.h /usr/include/alloca.h \
- /usr/include/bits/stdlib-float.h /usr/include/c++/11.1.0/bits/std_abs.h \
- /usr/include/c++/11.1.0/cctype /usr/include/ctype.h \
- /usr/include/c++/11.1.0/cstdint \
- /usr/lib/gcc/x86_64-pc-linux-gnu/11.1.0/include/stdint.h \
- /usr/include/stdint.h /usr/include/bits/wchar.h \
- /usr/include/bits/stdint-uintn.h
diff --git a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/link.txt b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/link.txt
deleted file mode 100644
index 349d378be..000000000
--- a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/link.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-/usr/bin/ar qc ../../lib/libIrrXML.a CMakeFiles/IrrXML.dir/irrXML.cpp.o
-/usr/bin/ranlib ../../lib/libIrrXML.a
diff --git a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/progress.make b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/progress.make
deleted file mode 100644
index 6c287f17b..000000000
--- a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/IrrXML.dir/progress.make
+++ /dev/null
@@ -1,3 +0,0 @@
-CMAKE_PROGRESS_1 = 
-CMAKE_PROGRESS_2 = 
-
diff --git a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/progress.marks b/Engine/lib/assimp/contrib/irrXML/CMakeFiles/progress.marks
deleted file mode 100644
index 573541ac9..000000000
--- a/Engine/lib/assimp/contrib/irrXML/CMakeFiles/progress.marks
+++ /dev/null
@@ -1 +0,0 @@
-0
diff --git a/Engine/lib/assimp/contrib/irrXML/CMakeLists.txt b/Engine/lib/assimp/contrib/irrXML/CMakeLists.txt
deleted file mode 100644
index 7f58af3d8..000000000
--- a/Engine/lib/assimp/contrib/irrXML/CMakeLists.txt
+++ /dev/null
@@ -1,29 +0,0 @@
-set( IrrXML_SRCS
-  CXMLReaderImpl.h
-  heapsort.h
-  irrArray.h
-  irrString.h
-  irrTypes.h
-  irrXML.cpp
-  irrXML.h
-)
-
-if ( MSVC )
-  ADD_DEFINITIONS( -D_SCL_SECURE_NO_WARNINGS )
-  ADD_DEFINITIONS( -D_CRT_SECURE_NO_WARNINGS )
-endif ( MSVC )
-
-IF(CMAKE_SYSTEM_NAME MATCHES "(Darwin|FreeBSD)")
-  add_library(IrrXML ${IrrXML_SRCS})
-ELSE()
-  add_library(IrrXML STATIC ${IrrXML_SRCS})
-ENDIF()
-set(IRRXML_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}" CACHE INTERNAL "IrrXML_Include" )
-set(IRRXML_LIBRARY "IrrXML" CACHE INTERNAL "IrrXML" )
-
-install(TARGETS IrrXML
-  LIBRARY DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
-  ARCHIVE DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
-  RUNTIME DESTINATION ${ASSIMP_BIN_INSTALL_DIR}
-  FRAMEWORK DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
-  COMPONENT ${LIBASSIMP_COMPONENT})
diff --git a/Engine/lib/assimp/contrib/irrXML/CXMLReaderImpl.h b/Engine/lib/assimp/contrib/irrXML/CXMLReaderImpl.h
deleted file mode 100644
index 6f3bec5fa..000000000
--- a/Engine/lib/assimp/contrib/irrXML/CXMLReaderImpl.h
+++ /dev/null
@@ -1,813 +0,0 @@
-// Copyright (C) 2002-2005 Nikolaus Gebhardt
-// This file is part of the "Irrlicht Engine" and the "irrXML" project.
-// For conditions of distribution and use, see copyright notice in irrlicht.h and/or irrXML.h
-
-#ifndef __ICXML_READER_IMPL_H_INCLUDED__
-#define __ICXML_READER_IMPL_H_INCLUDED__
-
-#include "irrXML.h"
-#include "irrString.h"
-#include "irrArray.h"
-
-#include <cassert>
-#include <stdlib.h>    
-#include <cctype>
-#include <cstdint>
-//using namespace Assimp;
-
-
-#ifdef _DEBUG
-#define IRR_DEBUGPRINT(x) printf((x));
-#else // _DEBUG 
-#define IRR_DEBUGPRINT(x)
-#endif // _DEBUG
-
-
-namespace irr
-{
-namespace io
-{
-
-
-//! implementation of the IrrXMLReader
-template<class char_type, class superclass>
-class CXMLReaderImpl : public IIrrXMLReader<char_type, superclass>
-{
-public:
-
-	//! Constructor
-	CXMLReaderImpl(IFileReadCallBack* callback, bool deleteCallBack = true)
-		: TextData(0), P(0), TextBegin(0), TextSize(0), CurrentNodeType(EXN_NONE),
-		SourceFormat(ETF_ASCII), TargetFormat(ETF_ASCII)
-	{
-		if (!callback)
-			return;
-
-		storeTargetFormat();
-
-		// read whole xml file
-
-		readFile(callback);
-		
-		// clean up
-
-		if (deleteCallBack)
-			delete callback;
-
-		// create list with special characters
-
-		createSpecialCharacterList();
-
-		// set pointer to text begin
-		P = TextBegin;
-	}
-    	
-
-	//! Destructor
-	virtual ~CXMLReaderImpl()
-	{
-		delete [] TextData;
-	}
-
-
-	//! Reads forward to the next xml node. 
-	//! \return Returns false, if there was no further node. 
-	virtual bool read()
-	{
-		// if not end reached, parse the node
-		if (P && (unsigned int)(P - TextBegin) < TextSize - 1 && *P != 0)
-		{
-			parseCurrentNode();
-			return true;
-		}
-
-		_IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
-		return false;
-	}
-
-
-	//! Returns the type of the current XML node.
-	virtual EXML_NODE getNodeType() const
-	{
-		return CurrentNodeType;
-	}
-
-
-	//! Returns attribute count of the current XML node.
-	virtual int getAttributeCount() const
-	{
-		return Attributes.size();
-	}
-
-
-	//! Returns name of an attribute.
-	virtual const char_type* getAttributeName(int idx) const
-	{
-		if (idx < 0 || idx >= (int)Attributes.size())
-			return 0;
-
-		return Attributes[idx].Name.c_str();
-	}
-
-
-	//! Returns the value of an attribute. 
-	virtual const char_type* getAttributeValue(int idx) const
-	{
-		if (idx < 0 || idx >= (int)Attributes.size())
-			return 0;
-
-		return Attributes[idx].Value.c_str();
-	}
-
-
-	//! Returns the value of an attribute. 
-	virtual const char_type* getAttributeValue(const char_type* name) const
-	{
-		const SAttribute* attr = getAttributeByName(name);
-		if (!attr)
-			return 0;
-
-		return attr->Value.c_str();
-	}
-
-
-	//! Returns the value of an attribute
-	virtual const char_type* getAttributeValueSafe(const char_type* name) const
-	{
-		const SAttribute* attr = getAttributeByName(name);
-		if (!attr)
-			return EmptyString.c_str();
-
-		return attr->Value.c_str();
-	}
-
-
-
-	//! Returns the value of an attribute as integer. 
-	int getAttributeValueAsInt(const char_type* name) const
-	{
-		return (int)getAttributeValueAsFloat(name);
-	}
-
-
-	//! Returns the value of an attribute as integer. 
-	int getAttributeValueAsInt(int idx) const
-	{
-		return (int)getAttributeValueAsFloat(idx);
-	}
-
-
-	//! Returns the value of an attribute as float. 
-	float getAttributeValueAsFloat(const char_type* name) const
-	{
-		const SAttribute* attr = getAttributeByName(name);
-		if (!attr)
-			return 0;
-
-		core::stringc c = attr->Value.c_str();
-        return static_cast<float>(atof(c.c_str()));
-        //return fast_atof(c.c_str());
-	}
-
-
-	//! Returns the value of an attribute as float. 
-	float getAttributeValueAsFloat(int idx) const
-	{
-		const char_type* attrvalue = getAttributeValue(idx);
-		if (!attrvalue)
-			return 0;
-
-		core::stringc c = attrvalue;
-        return static_cast<float>(atof(c.c_str()));
-		//return fast_atof(c.c_str());
-	}
-
-
-	//! Returns the name of the current node.
-	virtual const char_type* getNodeName() const
-	{
-		return NodeName.c_str();
-	}
-
-
-	//! Returns data of the current node.
-	virtual const char_type* getNodeData() const
-	{
-		return NodeName.c_str();
-	}
-
-
-	//! Returns if an element is an empty element, like <foo />
-	virtual bool isEmptyElement() const
-	{
-		return IsEmptyElement;
-	}
-
-	//! Returns format of the source xml file.
-	virtual ETEXT_FORMAT getSourceFormat() const
-	{
-		return SourceFormat;
-	}
-
-	//! Returns format of the strings returned by the parser.
-	virtual ETEXT_FORMAT getParserFormat() const
-	{
-		return TargetFormat;
-	}
-
-private:
-
-	// Reads the current xml node
-	void parseCurrentNode()
-	{
-		char_type* start = P;
-
-		// move forward until '<' found
-		while(*P != L'<' && *P)
-			++P;
-
-		if (!*P)
-			return;
-
-		if (P - start > 0)
-		{
-			// we found some text, store it
-			if (setText(start, P))
-				return;
-		}
-
-		++P;
-
-		// based on current token, parse and report next element
-		switch(*P)
-		{
-		case L'/':
-			parseClosingXMLElement(); 
-			break;
-		case L'?':
-			ignoreDefinition();	
-			break;
-		case L'!':
-			if (!parseCDATA())
-				parseComment();	
-			break;
-		default:
-			parseOpeningXMLElement();
-			break;
-		}
-	}
-
-
-	//! sets the state that text was found. Returns true if set should be set
-	bool setText(char_type* start, char_type* end)
-	{
-		// check if text is more than 2 characters, and if not, check if there is 
-		// only white space, so that this text won't be reported
-		if (end - start < 3)
-		{
-			char_type* p = start;
-			for(; p != end; ++p)
-				if (!isWhiteSpace(*p))
-					break;
-
-			if (p == end)
-				return false;
-		}
-
-		// set current text to the parsed text, and replace xml special characters
-		core::string<char_type> s(start, (int)(end - start));
-		NodeName = replaceSpecialCharacters(s);
-
-		// current XML node type is text
-		CurrentNodeType = EXN_TEXT;
-
-		return true;
-	}
-
-
-
-	//! ignores an xml definition like <?xml something />
-	void ignoreDefinition()
-	{
-		CurrentNodeType = EXN_UNKNOWN;
-
-		// move until end marked with '>' reached
-		while(*P != L'>')
-			++P;
-
-		++P;
-	}
-
-
-	//! parses a comment
-	void parseComment()
-	{
-		CurrentNodeType = EXN_COMMENT;
-		P += 1;
-
-		char_type *pCommentBegin = P;
-
-		int count = 1;
-
-		// move until end of comment reached
-		while(count)
-		{
-			if (*P == L'>')
-				--count;
-			else
-			if (*P == L'<')
-				++count;
-
-			++P;
-		}
-
-		P -= 3;
-		NodeName = core::string<char_type>(pCommentBegin+2, (int)(P - pCommentBegin-2));
-		P += 3;
-	}
-
-
-	//! parses an opening xml element and reads attributes
-	void parseOpeningXMLElement()
-	{
-		CurrentNodeType = EXN_ELEMENT;
-		IsEmptyElement = false;
-		Attributes.clear();
-
-		// find name
-		const char_type* startName = P;
-
-		// find end of element
-		while(*P != L'>' && !isWhiteSpace(*P))
-			++P;
-
-		const char_type* endName = P;
-
-		// find Attributes
-		while(*P != L'>')
-		{
-			if (isWhiteSpace(*P))
-				++P;
-			else
-			{
-				if (*P != L'/')
-				{
-					// we've got an attribute
-
-					// read the attribute names
-					const char_type* attributeNameBegin = P;
-
-					while(!isWhiteSpace(*P) && *P != L'=')
-						++P;
-
-					const char_type* attributeNameEnd = P;
-					++P;
-
-					// read the attribute value
-					// check for quotes and single quotes, thx to murphy
-					while( (*P != L'\"') && (*P != L'\'') && *P) 
-						++P;
-
-					if (!*P) // malformatted xml file
-						return;
-
-					const char_type attributeQuoteChar = *P;
-
-					++P;
-					const char_type* attributeValueBegin = P;
-					
-					while(*P != attributeQuoteChar && *P)
-						++P;
-
-					if (!*P) // malformatted xml file
-						return;
-
-					const char_type* attributeValueEnd = P;
-					++P;
-
-					SAttribute attr;
-					attr.Name = core::string<char_type>(attributeNameBegin, 
-						(int)(attributeNameEnd - attributeNameBegin));
-
-					core::string<char_type> s(attributeValueBegin, 
-						(int)(attributeValueEnd - attributeValueBegin));
-
-					attr.Value = replaceSpecialCharacters(s);
-					Attributes.push_back(attr);
-				}
-				else
-				{
-					// tag is closed directly
-					++P;
-					IsEmptyElement = true;
-					break;
-				}
-			}
-		}
-
-		// check if this tag is closing directly
-		if (endName > startName && *(endName-1) == L'/')
-		{
-			// directly closing tag
-			IsEmptyElement = true;
-			endName--;
-		}
-		
-		NodeName = core::string<char_type>(startName, (int)(endName - startName));
-
-		++P;
-	}
-
-
-	//! parses an closing xml tag
-	void parseClosingXMLElement()
-	{
-		CurrentNodeType = EXN_ELEMENT_END;
-		IsEmptyElement = false;
-		Attributes.clear();
-
-		++P;
-		const char_type* pBeginClose = P;
-
-		while(*P != L'>')
-			++P;
-
-    // remove trailing whitespace, if any
-    while( std::isspace( P[-1]))
-      --P;
-
-		NodeName = core::string<char_type>(pBeginClose, (int)(P - pBeginClose));
-		++P;
-	}
-
-	//! parses a possible CDATA section, returns false if begin was not a CDATA section
-	bool parseCDATA()
-	{
-		if (*(P+1) != L'[')
-			return false;
-
-		CurrentNodeType = EXN_CDATA;
-
-		// skip '<![CDATA['
-		int count=0;
-		while( *P && count<8 )
-		{
-			++P;
-			++count;
-		}
-
-		if (!*P)
-			return true;
-
-		char_type *cDataBegin = P;
-		char_type *cDataEnd = 0;
-
-		// find end of CDATA
-		while(*P && !cDataEnd)
-		{
-			if (*P == L'>' && 
-			   (*(P-1) == L']') &&
-			   (*(P-2) == L']'))
-			{
-				cDataEnd = P - 2;
-			}
-
-			++P;
-		}
-
-		if ( cDataEnd )
-			NodeName = core::string<char_type>(cDataBegin, (int)(cDataEnd - cDataBegin));
-		else
-			NodeName = "";
-
-		return true;
-	}
-
-
-	// structure for storing attribute-name pairs
-	struct SAttribute
-	{
-		core::string<char_type> Name;
-		core::string<char_type> Value;
-	};
-
-	// finds a current attribute by name, returns 0 if not found
-	const SAttribute* getAttributeByName(const char_type* name) const
-	{
-		if (!name)
-			return 0;
-
-		core::string<char_type> n = name;
-
-		for (int i=0; i<(int)Attributes.size(); ++i)
-			if (Attributes[i].Name == n)
-				return &Attributes[i];
-
-		return 0;
-	}
-
-	// replaces xml special characters in a string and creates a new one
-	core::string<char_type> replaceSpecialCharacters(
-		core::string<char_type>& origstr)
-	{
-		int pos = origstr.findFirst(L'&');
-		int oldPos = 0;
-
-		if (pos == -1)
-			return origstr;
-
-		core::string<char_type> newstr;
-
-		while(pos != -1 && pos < origstr.size()-2)
-		{
-			// check if it is one of the special characters
-
-			int specialChar = -1;
-			for (int i=0; i<(int)SpecialCharacters.size(); ++i)
-			{
-				const char_type* p = &origstr.c_str()[pos]+1;
-
-				if (equalsn(&SpecialCharacters[i][1], p, SpecialCharacters[i].size()-1))
-				{
-					specialChar = i;
-					break;
-				}
-			}
-
-			if (specialChar != -1)
-			{
-				newstr.append(origstr.subString(oldPos, pos - oldPos));
-				newstr.append(SpecialCharacters[specialChar][0]);
-				pos += SpecialCharacters[specialChar].size();
-			}
-			else
-			{
-				newstr.append(origstr.subString(oldPos, pos - oldPos + 1));
-				pos += 1;
-			}
-
-			// find next &
-			oldPos = pos;
-			pos = origstr.findNext(L'&', pos);		
-		}
-
-		if (oldPos < origstr.size()-1)
-			newstr.append(origstr.subString(oldPos, origstr.size()-oldPos));
-
-		return newstr;
-	}
-
-
-
-	//! reads the xml file and converts it into the wanted character format.
-	bool readFile(IFileReadCallBack* callback)
-	{
-		int size = callback->getSize();		
-		size += 4; // We need two terminating 0's at the end.
-		           // For ASCII we need 1 0's, for UTF-16 2, for UTF-32 4.
-
-		char* data8 = new char[size];
-
-		if (!callback->read(data8, size-4))
-		{
-			delete [] data8;
-			return false;
-		}
-
-		// add zeros at end
-
-		data8[size-1] = 0;
-		data8[size-2] = 0;
-		data8[size-3] = 0;
-		data8[size-4] = 0;
-
-		char16* data16 = reinterpret_cast<char16*>(data8);
-		char32* data32 = reinterpret_cast<char32*>(data8);	
-
-		// now we need to convert the data to the desired target format
-		// based on the byte order mark.
-
-		const unsigned char UTF8[] = {0xEF, 0xBB, 0xBF}; // 0xEFBBBF;
-		const int UTF16_BE = 0xFFFE;
-		const int UTF16_LE = 0xFEFF;
-		const int UTF32_BE = 0xFFFE0000;
-		const int UTF32_LE = 0x0000FEFF;
-
-		// check source for all utf versions and convert to target data format
-		
-		if (size >= 4 && data32[0] == (char32)UTF32_BE)
-		{
-			// UTF-32, big endian
-			SourceFormat = ETF_UTF32_BE;
-			convertTextData(data32+1, data8, (size/4)); // data32+1 because we need to skip the header
-		}
-		else
-		if (size >= 4 && data32[0] == (char32)UTF32_LE)
-		{
-			// UTF-32, little endian
-			SourceFormat = ETF_UTF32_LE;
-			convertTextData(data32+1, data8, (size/4)); // data32+1 because we need to skip the header
-		}
-		else
-		if (size >= 2 && data16[0] == UTF16_BE)
-		{
-			// UTF-16, big endian
-			SourceFormat = ETF_UTF16_BE;
-			convertTextData(data16+1, data8, (size/2)); // data16+1 because we need to skip the header
-		}
-		else
-		if (size >= 2 && data16[0] == UTF16_LE)
-		{
-			// UTF-16, little endian
-			SourceFormat = ETF_UTF16_LE;
-			convertTextData(data16+1, data8, (size/2)); // data16+1 because we need to skip the header
-		}
-		else
-		if (size >= 3 && data8[0] == UTF8[0] && data8[1] == UTF8[1] && data8[2] == UTF8[2])
-		{
-			// UTF-8
-			SourceFormat = ETF_UTF8;
-			convertTextData(data8+3, data8, size); // data8+3 because we need to skip the header
-		}
-		else
-		{
-			// ASCII
-			SourceFormat = ETF_ASCII;
-			convertTextData(data8, data8, size);
-		}
-
-		return true;
-	}
-
-
-	//! converts the text file into the desired format.
-	//! \param source: begin of the text (without byte order mark)
-	//! \param pointerToStore: pointer to text data block which can be
-	//! stored or deleted based on the nesessary conversion.
-	//! \param sizeWithoutHeader: Text size in characters without header
-	template<class src_char_type>
-	void convertTextData(src_char_type* source, char* pointerToStore, int sizeWithoutHeader)
-	{
-		// convert little to big endian if necessary
-		if (sizeof(src_char_type) > 1 && 
-			isLittleEndian(TargetFormat) != isLittleEndian(SourceFormat))
-			convertToLittleEndian(source);
-
-		// check if conversion is necessary:
-		if (sizeof(src_char_type) == sizeof(char_type))
-		{
-			// no need to convert
-			TextBegin = (char_type*)source;
-			TextData = (char_type*)pointerToStore;
-			TextSize = sizeWithoutHeader;
-		}
-		else
-		{
-			// convert source into target data format. 
-			// TODO: implement a real conversion. This one just 
-			// copies bytes. This is a problem when there are 
-			// unicode symbols using more than one character.
-
-			TextData = new char_type[sizeWithoutHeader];
-
-			// MSVC debugger complains here about loss of data ...
-			size_t numShift = sizeof( char_type) * 8;
-			assert(numShift < 64);
-			const src_char_type cc = (src_char_type)(((uint64_t(1u) << numShift) - 1));
-			for (int i=0; i<sizeWithoutHeader; ++i)
-				TextData[i] = char_type( source[i] & cc); 
-
-			TextBegin = TextData;
-			TextSize = sizeWithoutHeader;
-
-			// delete original data because no longer needed
-			delete [] pointerToStore;
-		}
-	}
-
-	//! converts whole text buffer to little endian
-	template<class src_char_type>
-	void convertToLittleEndian(src_char_type* t)
-	{
-		if (sizeof(src_char_type) == 4) 
-		{
-			// 32 bit
-
-			while(*t)
-			{
-				*t = ((*t & 0xff000000) >> 24) |
-				     ((*t & 0x00ff0000) >> 8)  |
-				     ((*t & 0x0000ff00) << 8)  |
-				     ((*t & 0x000000ff) << 24);
-				++t;
-			}
-		}
-		else
-		{
-			// 16 bit 
-
-			while(*t)
-			{
-				*t = (*t >> 8) | (*t << 8);
-				++t;
-			}
-		}
-	}
-
-	//! returns if a format is little endian
-	inline bool isLittleEndian(ETEXT_FORMAT f)
-	{
-		return f == ETF_ASCII ||
-		       f == ETF_UTF8 ||
-		       f == ETF_UTF16_LE ||
-		       f == ETF_UTF32_LE;
-	}
-
-
-	//! returns true if a character is whitespace
-	inline bool isWhiteSpace(char_type c)
-	{
-		return (c==' ' || c=='\t' || c=='\n' || c=='\r');
-	}
-
-
-	//! generates a list with xml special characters
-	void createSpecialCharacterList()
-	{
-		// list of strings containing special symbols, 
-		// the first character is the special character,
-		// the following is the symbol string without trailing &.
-
-		SpecialCharacters.push_back("&amp;");
-		SpecialCharacters.push_back("<lt;");
-		SpecialCharacters.push_back(">gt;");
-		SpecialCharacters.push_back("\"quot;");
-		SpecialCharacters.push_back("'apos;");
-		
-	}
-
-
-	//! compares the first n characters of the strings
-	bool equalsn(const char_type* str1, const char_type* str2, int len)
-	{
-		int i;
-		for(i=0; str1[i] && str2[i] && i < len; ++i)
-			if (str1[i] != str2[i])
-				return false;
-
-		// if one (or both) of the strings was smaller then they
-		// are only equal if they have the same lenght
-		return (i == len) || (str1[i] == 0 && str2[i] == 0);
-	}
-
-
-	//! stores the target text format
-	void storeTargetFormat()
-	{
-		// get target format. We could have done this using template specialization,
-		// but VisualStudio 6 don't like it and we want to support it.
-
-		switch(sizeof(char_type))
-		{
-		case 1: 
-			TargetFormat = ETF_UTF8;
-			break;
-		case 2: 
-			TargetFormat = ETF_UTF16_LE;
-			break;
-		case 4: 
-			TargetFormat = ETF_UTF32_LE;
-			break;
-		default:
-			TargetFormat = ETF_ASCII; // should never happen.
-		}
-	}
-
-
-	// instance variables:
-
-	char_type* TextData;         // data block of the text file
-	char_type* P;                // current point in text to parse
-	char_type* TextBegin;        // start of text to parse
-	unsigned int TextSize;       // size of text to parse in characters, not bytes
-
-	EXML_NODE CurrentNodeType;   // type of the currently parsed node
-	ETEXT_FORMAT SourceFormat;   // source format of the xml file
-	ETEXT_FORMAT TargetFormat;   // output format of this parser
-
-	core::string<char_type> NodeName;    // name of the node currently in
-	core::string<char_type> EmptyString; // empty string to be returned by getSafe() methods
-
-	bool IsEmptyElement;       // is the currently parsed node empty?
-
-	core::array< core::string<char_type> > SpecialCharacters; // see createSpecialCharacterList()
-
-	core::array<SAttribute> Attributes; // attributes of current element
-	
-}; // end CXMLReaderImpl
-
-
-} // end namespace
-} // end namespace
-
-#endif
diff --git a/Engine/lib/assimp/contrib/irrXML/Makefile b/Engine/lib/assimp/contrib/irrXML/Makefile
deleted file mode 100644
index d428de0c4..000000000
--- a/Engine/lib/assimp/contrib/irrXML/Makefile
+++ /dev/null
@@ -1,231 +0,0 @@
-# CMAKE generated file: DO NOT EDIT!
-# Generated by "Unix Makefiles" Generator, CMake Version 3.21
-
-# Default target executed when no arguments are given to make.
-default_target: all
-.PHONY : default_target
-
-# Allow only one "make -f Makefile2" at a time, but pass parallelism.
-.NOTPARALLEL:
-
-#=============================================================================
-# Special targets provided by cmake.
-
-# Disable implicit rules so canonical targets will work.
-.SUFFIXES:
-
-# Disable VCS-based implicit rules.
-% : %,v
-
-# Disable VCS-based implicit rules.
-% : RCS/%
-
-# Disable VCS-based implicit rules.
-% : RCS/%,v
-
-# Disable VCS-based implicit rules.
-% : SCCS/s.%
-
-# Disable VCS-based implicit rules.
-% : s.%
-
-.SUFFIXES: .hpux_make_needs_suffix_list
-
-# Command-line flag to silence nested $(MAKE).
-$(VERBOSE)MAKESILENT = -s
-
-#Suppress display of executed commands.
-$(VERBOSE).SILENT:
-
-# A target that is always out of date.
-cmake_force:
-.PHONY : cmake_force
-
-#=============================================================================
-# Set environment variables for the build.
-
-# The shell in which to execute make rules.
-SHELL = /bin/sh
-
-# The CMake executable.
-CMAKE_COMMAND = /usr/bin/cmake
-
-# The command to remove a file.
-RM = /usr/bin/cmake -E rm -f
-
-# Escaping for special characters.
-EQUALS = =
-
-# The top-level source directory on which CMake was run.
-CMAKE_SOURCE_DIR = /home/ragora/Downloads/assimp-5.0.1
-
-# The top-level build directory on which CMake was run.
-CMAKE_BINARY_DIR = /home/ragora/Downloads/assimp-5.0.1
-
-#=============================================================================
-# Targets provided globally by CMake.
-
-# Special rule for the target install/local
-install/local: preinstall
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Installing only the local directory..."
-	/usr/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
-.PHONY : install/local
-
-# Special rule for the target install/local
-install/local/fast: preinstall/fast
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Installing only the local directory..."
-	/usr/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
-.PHONY : install/local/fast
-
-# Special rule for the target install
-install: preinstall
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Install the project..."
-	/usr/bin/cmake -P cmake_install.cmake
-.PHONY : install
-
-# Special rule for the target install
-install/fast: preinstall/fast
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Install the project..."
-	/usr/bin/cmake -P cmake_install.cmake
-.PHONY : install/fast
-
-# Special rule for the target list_install_components
-list_install_components:
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Available install components are: \"Unspecified\" \"assimp-bin\" \"assimp-dev\" \"libassimp5.0.0-dev\""
-.PHONY : list_install_components
-
-# Special rule for the target list_install_components
-list_install_components/fast: list_install_components
-.PHONY : list_install_components/fast
-
-# Special rule for the target rebuild_cache
-rebuild_cache:
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running CMake to regenerate build system..."
-	/usr/bin/cmake --regenerate-during-build -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
-.PHONY : rebuild_cache
-
-# Special rule for the target rebuild_cache
-rebuild_cache/fast: rebuild_cache
-.PHONY : rebuild_cache/fast
-
-# Special rule for the target edit_cache
-edit_cache:
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running CMake cache editor..."
-	/usr/bin/ccmake -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
-.PHONY : edit_cache
-
-# Special rule for the target edit_cache
-edit_cache/fast: edit_cache
-.PHONY : edit_cache/fast
-
-# Special rule for the target install/strip
-install/strip: preinstall
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Installing the project stripped..."
-	/usr/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
-.PHONY : install/strip
-
-# Special rule for the target install/strip
-install/strip/fast: preinstall/fast
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Installing the project stripped..."
-	/usr/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
-.PHONY : install/strip/fast
-
-# The main all target
-all: cmake_check_build_system
-	cd /home/ragora/Downloads/assimp-5.0.1 && $(CMAKE_COMMAND) -E cmake_progress_start /home/ragora/Downloads/assimp-5.0.1/CMakeFiles /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML//CMakeFiles/progress.marks
-	cd /home/ragora/Downloads/assimp-5.0.1 && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 contrib/irrXML/all
-	$(CMAKE_COMMAND) -E cmake_progress_start /home/ragora/Downloads/assimp-5.0.1/CMakeFiles 0
-.PHONY : all
-
-# The main clean target
-clean:
-	cd /home/ragora/Downloads/assimp-5.0.1 && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 contrib/irrXML/clean
-.PHONY : clean
-
-# The main clean target
-clean/fast: clean
-.PHONY : clean/fast
-
-# Prepare targets for installation.
-preinstall: all
-	cd /home/ragora/Downloads/assimp-5.0.1 && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 contrib/irrXML/preinstall
-.PHONY : preinstall
-
-# Prepare targets for installation.
-preinstall/fast:
-	cd /home/ragora/Downloads/assimp-5.0.1 && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 contrib/irrXML/preinstall
-.PHONY : preinstall/fast
-
-# clear depends
-depend:
-	cd /home/ragora/Downloads/assimp-5.0.1 && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1
-.PHONY : depend
-
-# Convenience name for target.
-contrib/irrXML/CMakeFiles/IrrXML.dir/rule:
-	cd /home/ragora/Downloads/assimp-5.0.1 && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 contrib/irrXML/CMakeFiles/IrrXML.dir/rule
-.PHONY : contrib/irrXML/CMakeFiles/IrrXML.dir/rule
-
-# Convenience name for target.
-IrrXML: contrib/irrXML/CMakeFiles/IrrXML.dir/rule
-.PHONY : IrrXML
-
-# fast build rule for target.
-IrrXML/fast:
-	cd /home/ragora/Downloads/assimp-5.0.1 && $(MAKE) $(MAKESILENT) -f contrib/irrXML/CMakeFiles/IrrXML.dir/build.make contrib/irrXML/CMakeFiles/IrrXML.dir/build
-.PHONY : IrrXML/fast
-
-irrXML.o: irrXML.cpp.o
-.PHONY : irrXML.o
-
-# target to build an object file
-irrXML.cpp.o:
-	cd /home/ragora/Downloads/assimp-5.0.1 && $(MAKE) $(MAKESILENT) -f contrib/irrXML/CMakeFiles/IrrXML.dir/build.make contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.o
-.PHONY : irrXML.cpp.o
-
-irrXML.i: irrXML.cpp.i
-.PHONY : irrXML.i
-
-# target to preprocess a source file
-irrXML.cpp.i:
-	cd /home/ragora/Downloads/assimp-5.0.1 && $(MAKE) $(MAKESILENT) -f contrib/irrXML/CMakeFiles/IrrXML.dir/build.make contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.i
-.PHONY : irrXML.cpp.i
-
-irrXML.s: irrXML.cpp.s
-.PHONY : irrXML.s
-
-# target to generate assembly for a file
-irrXML.cpp.s:
-	cd /home/ragora/Downloads/assimp-5.0.1 && $(MAKE) $(MAKESILENT) -f contrib/irrXML/CMakeFiles/IrrXML.dir/build.make contrib/irrXML/CMakeFiles/IrrXML.dir/irrXML.cpp.s
-.PHONY : irrXML.cpp.s
-
-# Help Target
-help:
-	@echo "The following are some of the valid targets for this Makefile:"
-	@echo "... all (the default if no target is provided)"
-	@echo "... clean"
-	@echo "... depend"
-	@echo "... edit_cache"
-	@echo "... install"
-	@echo "... install/local"
-	@echo "... install/strip"
-	@echo "... list_install_components"
-	@echo "... rebuild_cache"
-	@echo "... IrrXML"
-	@echo "... irrXML.o"
-	@echo "... irrXML.i"
-	@echo "... irrXML.s"
-.PHONY : help
-
-
-
-#=============================================================================
-# Special targets to cleanup operation of make.
-
-# Special rule to run CMake to check the build system integrity.
-# No rule that depends on this can have commands that come from listfiles
-# because they might be regenerated.
-cmake_check_build_system:
-	cd /home/ragora/Downloads/assimp-5.0.1 && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
-.PHONY : cmake_check_build_system
-
diff --git a/Engine/lib/assimp/contrib/irrXML/cmake_install.cmake b/Engine/lib/assimp/contrib/irrXML/cmake_install.cmake
deleted file mode 100644
index bb0122a18..000000000
--- a/Engine/lib/assimp/contrib/irrXML/cmake_install.cmake
+++ /dev/null
@@ -1,48 +0,0 @@
-# Install script for directory: /home/ragora/Downloads/assimp-5.0.1/contrib/irrXML
-
-# Set the install prefix
-if(NOT DEFINED CMAKE_INSTALL_PREFIX)
-  set(CMAKE_INSTALL_PREFIX "/usr/local")
-endif()
-string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
-
-# Set the install configuration name.
-if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
-  if(BUILD_TYPE)
-    string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
-           CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
-  else()
-    set(CMAKE_INSTALL_CONFIG_NAME "")
-  endif()
-  message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
-endif()
-
-# Set the component getting installed.
-if(NOT CMAKE_INSTALL_COMPONENT)
-  if(COMPONENT)
-    message(STATUS "Install component: \"${COMPONENT}\"")
-    set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
-  else()
-    set(CMAKE_INSTALL_COMPONENT)
-  endif()
-endif()
-
-# Install shared libraries without execute permission?
-if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE)
-  set(CMAKE_INSTALL_SO_NO_EXE "0")
-endif()
-
-# Is this installation the result of a crosscompile?
-if(NOT DEFINED CMAKE_CROSSCOMPILING)
-  set(CMAKE_CROSSCOMPILING "FALSE")
-endif()
-
-# Set default install directory permissions.
-if(NOT DEFINED CMAKE_OBJDUMP)
-  set(CMAKE_OBJDUMP "/usr/bin/objdump")
-endif()
-
-if("x${CMAKE_INSTALL_COMPONENT}x" STREQUAL "xUnspecifiedx" OR NOT CMAKE_INSTALL_COMPONENT)
-  file(INSTALL DESTINATION "${CMAKE_INSTALL_PREFIX}/lib" TYPE STATIC_LIBRARY FILES "/home/ragora/Downloads/assimp-5.0.1/lib/libIrrXML.a")
-endif()
-
diff --git a/Engine/lib/assimp/contrib/irrXML/heapsort.h b/Engine/lib/assimp/contrib/irrXML/heapsort.h
deleted file mode 100644
index d0db319d0..000000000
--- a/Engine/lib/assimp/contrib/irrXML/heapsort.h
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright (C) 2002-2005 Nikolaus Gebhardt
-// This file is part of the "Irrlicht Engine".
-// For conditions of distribution and use, see copyright notice in irrlicht.h
-
-#ifndef __IRR_HEAPSORT_H_INCLUDED__
-#define __IRR_HEAPSORT_H_INCLUDED__
-
-#include "irrTypes.h"
-
-namespace irr
-{
-namespace core
-{
-
-//! Sinks an element into the heap.
-template<class T>
-inline void heapsink(T*array, s32 element, s32 max)
-{
-	while ((element<<1) < max)	// there is a left child
-	{
-		s32 j = (element<<1);
-	
-		if (j+1 < max && array[j] < array[j+1])
-			j = j+1;							// take right child
-
-		if (array[element] < array[j])
-		{
-			T t = array[j];						// swap elements
-			array[j] = array[element];
-			array[element] = t;
-			element = j;
-		}
-		else
-			return;
-	}
-}
-
-
-//! Sorts an array with size 'size' using heapsort.
-template<class T>
-inline void heapsort(T* array_, s32 size)
-{
-	// for heapsink we pretent this is not c++, where
-	// arrays start with index 0. So we decrease the array pointer,
-	// the maximum always +2 and the element always +1
-
-	T* virtualArray = array_ - 1;
-	s32 virtualSize = size + 2;
-	s32 i;
-
-	// build heap
-
-	for (i=((size-1)/2); i>=0; --i)	
-		heapsink(virtualArray, i+1, virtualSize-1);
-
-	// sort array
-
-	for (i=size-1; i>=0; --i)	
-	{
-		T t = array_[0];
-		array_[0] = array_[i];
-		array_[i] = t;
-		heapsink(virtualArray, 1, i + 1);
-	}
-}
-
-} // end namespace core
-} // end namespace irr
-
-
-
-#endif
-
diff --git a/Engine/lib/assimp/contrib/irrXML/irrArray.h b/Engine/lib/assimp/contrib/irrXML/irrArray.h
deleted file mode 100644
index 51302680e..000000000
--- a/Engine/lib/assimp/contrib/irrXML/irrArray.h
+++ /dev/null
@@ -1,443 +0,0 @@
-// Copyright (C) 2002-2005 Nikolaus Gebhardt
-// This file is part of the "Irrlicht Engine" and the "irrXML" project.
-// For conditions of distribution and use, see copyright notice in irrlicht.h and irrXML.h
-
-#ifndef __IRR_ARRAY_H_INCLUDED__
-#define __IRR_ARRAY_H_INCLUDED__
-
-#include "irrTypes.h"
-#include "heapsort.h"
-
-namespace irr
-{
-namespace core
-{
-
-//!	Self reallocating template array (like stl vector) with additional features.
-/** Some features are: Heap sorting, binary search methods, easier debugging.
-*/
-template <class T>
-class array
-{
-
-public:
-	array() 
-		: data(0), allocated(0), used(0),
-			free_when_destroyed(true), is_sorted(true)
-	{
-	}
-
-	//! Constructs a array and allocates an initial chunk of memory.
-	//! \param start_count: Amount of elements to allocate.
-	array(u32 start_count)
-		: data(0), allocated(0), used(0),
-			free_when_destroyed(true),	is_sorted(true)
-	{
-		reallocate(start_count);
-	}
-
-
-	//! Copy constructor
-	array(const array<T>& other)
-		: data(0)
-	{
-		*this = other;
-	}
-
-
-
-	//! Destructor. Frees allocated memory, if set_free_when_destroyed
-	//! was not set to false by the user before.
-	~array()
-	{
-		if (free_when_destroyed)
-			delete [] data;
-	}
-
-
-
-	//! Reallocates the array, make it bigger or smaller.
-	//! \param new_size: New size of array.
-	void reallocate(u32 new_size)
-	{
-		T* old_data = data;
-
-		data = new T[new_size];
-		allocated = new_size;
-		
-		s32 end = used < new_size ? used : new_size;
-		for (s32 i=0; i<end; ++i)
-			data[i] = old_data[i];
-
-		if (allocated < used)
-			used = allocated;
-		
-		delete [] old_data;
-	}
-
-	//! Adds an element at back of array. If the array is to small to 
-	//! add this new element, the array is made bigger.
-	//! \param element: Element to add at the back of the array.
-	void push_back(const T& element)
-	{
-		if (used + 1 > allocated)
-		{
-			// reallocate(used * 2 +1);
-			// this doesn't work if the element is in the same array. So
-			// we'll copy the element first to be sure we'll get no data
-			// corruption
-
-			T e;
-			e = element;           // copy element
-			reallocate(used * 2 +1); // increase data block
-			data[used++] = e;        // push_back
-			is_sorted = false; 
-			return;
-		}
-
-		data[used++] = element;
-		is_sorted = false;
-	}
-
-
-	//! Adds an element at the front of the array. If the array is to small to 
-	//! add this new element, the array is made bigger. Please note that this
-	//! is slow, because the whole array needs to be copied for this.
-	//! \param element: Element to add at the back of the array.
-	void push_front(const T& element)
-	{
-		if (used + 1 > allocated)
-			reallocate(used * 2 +1);
-
-		for (int i=(int)used; i>0; --i)
-			data[i] = data[i-1];
-
-		data[0] = element;
-		is_sorted = false;
-		++used;
-	}
-
-	
-	//! Insert item into array at specified position. Please use this
-	//! only if you know what you are doing (possible performance loss). 
-	//! The preferred method of adding elements should be push_back().
-	//! \param element: Element to be inserted
-	//! \param index: Where position to insert the new element.
-	void insert(const T& element, u32 index=0) 
-	{
-		_IRR_DEBUG_BREAK_IF(index>used) // access violation
-
-		if (used + 1 > allocated)
-			reallocate(used * 2 +1);
-
-		for (u32 i=used++; i>index; i--) 
-			data[i] = data[i-1];
-
-		data[index] = element;
-		is_sorted = false;
-	}
-
-
-
-
-	//! Clears the array and deletes all allocated memory.
-	void clear()
-	{
-		delete [] data;
-		data = 0;
-		used = 0;
-		allocated = 0;
-		is_sorted = true;
-	}
-
-
-
-	//! Sets pointer to new array, using this as new workspace.
-	//! \param newPointer: Pointer to new array of elements.
-	//! \param size: Size of the new array.
-	void set_pointer(T* newPointer, u32 size)
-	{
-		delete [] data;
-		data = newPointer;
-		allocated = size;
-		used = size;
-		is_sorted = false;
-	}
-
-
-
-	//! Sets if the array should delete the memory it used.
-	//! \param f: If true, the array frees the allocated memory in its
-	//! destructor, otherwise not. The default is true.
-	void set_free_when_destroyed(bool f)
-	{
-		free_when_destroyed = f;
-	}
-
-
-
-	//! Sets the size of the array.
-	//! \param usedNow: Amount of elements now used.
-	void set_used(u32 usedNow)
-	{
-		if (allocated < usedNow)
-			reallocate(usedNow);
-
-		used = usedNow;
-	}
-
-
-
-	//! Assignement operator
-	void operator=(const array<T>& other)
-	{
-		if (data)
-			delete [] data;
-
-		//if (allocated < other.allocated)
-		if (other.allocated == 0)
-			data = 0;
-		else
-			data = new T[other.allocated];
-
-		used = other.used;
-		free_when_destroyed = other.free_when_destroyed;
-		is_sorted = other.is_sorted;
-		allocated = other.allocated;
-
-		for (u32 i=0; i<other.used; ++i)
-			data[i] = other.data[i];
-	}
-
-
-	//! Direct access operator
-	T& operator [](u32 index)
-	{
-		_IRR_DEBUG_BREAK_IF(index>=used) // access violation
-
-		return data[index];
-	}
-
-
-
-	//! Direct access operator
-	const T& operator [](u32 index) const
-	{
-		_IRR_DEBUG_BREAK_IF(index>=used) // access violation
-
-		return data[index];
-	}
-
-    //! Gets last frame
-	const T& getLast() const
-	{
-		_IRR_DEBUG_BREAK_IF(!used) // access violation
-
-		return data[used-1];
-	}
-
-    //! Gets last frame
-	T& getLast()
-	{
-		_IRR_DEBUG_BREAK_IF(!used) // access violation
-
-		return data[used-1];
-	}
-    
-
-	//! Returns a pointer to the array.
-	//! \return Pointer to the array.
-	T* pointer()
-	{
-		return data;
-	}
-
-
-
-	//! Returns a const pointer to the array.
-	//! \return Pointer to the array.
-	const T* const_pointer() const
-	{
-		return data;
-	}
-
-
-
-	//! Returns size of used array.
-	//! \return Size of elements in the array.
-	u32 size() const
-	{
-		return used;
-	}
-
-
-
-	//! Returns amount memory allocated.
-	//! \return Returns amount of memory allocated. The amount of bytes
-	//! allocated would  be allocated_size() * sizeof(ElementsUsed);
-	u32 allocated_size() const
-	{
-		return allocated;
-	}
-
-
-
-	//! Returns true if array is empty
-	//! \return True if the array is empty, false if not.
-	bool empty() const
-	{
-		return used == 0;
-	}
-
-
-
-	//! Sorts the array using heapsort. There is no additional memory waste and
-	//! the algorithm performs (O) n log n in worst case.
-	void sort()
-	{
-		if (is_sorted || used<2)
-			return;
-
-		heapsort(data, used);
-		is_sorted = true;
-	}
-
-
-
-	//! Performs a binary search for an element, returns -1 if not found.
-	//! The array will be sorted before the binary search if it is not
-	//! already sorted.
-	//! \param element: Element to search for.
-	//! \return Returns position of the searched element if it was found,
-	//! otherwise -1 is returned.
-	s32 binary_search(const T& element)
-	{
-		return binary_search(element, 0, used-1);
-	}
-
-
-
-	//! Performs a binary search for an element, returns -1 if not found.
-	//! The array will be sorted before the binary search if it is not
-	//! already sorted.
-	//! \param element: Element to search for.
-	//! \param left: First left index
-	//! \param right: Last right index.
-	//! \return Returns position of the searched element if it was found,
-	//! otherwise -1 is returned.
-	s32 binary_search(const T& element, s32 left, s32 right)
-	{
-		if (!used)
-			return -1;
-
-		sort();
-
-		s32 m;
-
-		do
-		{
-			m = (left+right)>>1;
-
-			if (element < data[m])
-				right = m - 1;
-			else
-				left = m + 1;
-
-		} while((element < data[m] || data[m] < element) && left<=right);
-
-		// this last line equals to:
-		// " while((element != array[m]) && left<=right);"
-		// but we only want to use the '<' operator.
-		// the same in next line, it is "(element == array[m])"
-
-		if (!(element < data[m]) && !(data[m] < element))
-			return m;
-
-		return -1;
-	}
-
-
-	//! Finds an element in linear time, which is very slow. Use
-	//! binary_search for faster finding. Only works if =operator is implemented.
-	//! \param element: Element to search for.
-	//! \return Returns position of the searched element if it was found,
-	//! otherwise -1 is returned.
-	s32 linear_search(T& element)
-	{
-		for (u32 i=0; i<used; ++i)
-			if (!(element < data[i]) && !(data[i] < element))
-				return (s32)i;
-
-		return -1;
-	}
-
-
-	//! Finds an element in linear time, which is very slow. Use
-	//! binary_search for faster finding. Only works if =operator is implemented.
-	//! \param element: Element to search for.
-	//! \return Returns position of the searched element if it was found,
-	//! otherwise -1 is returned.
-	s32 linear_reverse_search(T& element)
-	{
-		for (s32 i=used-1; i>=0; --i)
-			if (data[i] == element)
-				return (s32)i;
-
-		return -1;
-	}
-
-
-
-	//! Erases an element from the array. May be slow, because all elements 
-	//! following after the erased element have to be copied.
-	//! \param index: Index of element to be erased.
-	void erase(u32 index)
-	{
-		_IRR_DEBUG_BREAK_IF(index>=used || index<0) // access violation
-
-		for (u32 i=index+1; i<used; ++i)
-			data[i-1] = data[i];
-
-		--used;
-	}
-
-
-	//! Erases some elements from the array. may be slow, because all elements 
-	//! following after the erased element have to be copied.
-	//! \param index: Index of the first element to be erased.
-	//! \param count: Amount of elements to be erased.
-	void erase(u32 index, s32 count)
-	{
-		_IRR_DEBUG_BREAK_IF(index>=used || index<0 || count<1 || index+count>used) // access violation
-
-		for (u32 i=index+count; i<used; ++i)
-			data[i-count] = data[i];
-
-		used-= count;
-	}
-
-
-	//! Sets if the array is sorted
-	void set_sorted(bool _is_sorted)
-	{
-		is_sorted = _is_sorted;
-	}
-
-			
-	private:
-
-		T* data;
-		u32 allocated;
-		u32 used;
-		bool free_when_destroyed;
-		bool is_sorted;
-};
-
-
-} // end namespace core
-} // end namespace irr
-
-
-
-#endif
-
diff --git a/Engine/lib/assimp/contrib/irrXML/irrString.h b/Engine/lib/assimp/contrib/irrXML/irrString.h
deleted file mode 100644
index ff0097b71..000000000
--- a/Engine/lib/assimp/contrib/irrXML/irrString.h
+++ /dev/null
@@ -1,664 +0,0 @@
-// Copyright (C) 2002-2005 Nikolaus Gebhardt
-// This file is part of the "Irrlicht Engine" and the "irrXML" project.
-// For conditions of distribution and use, see copyright notice in irrlicht.h and irrXML.h
-
-#ifndef __IRR_STRING_H_INCLUDED__
-#define __IRR_STRING_H_INCLUDED__
-
-#include "irrTypes.h"
-
-namespace irr
-{
-namespace core
-{
-
-//!	Very simple string class with some useful features.
-/**	string<c8> and string<wchar_t> work both with unicode AND ascii,
-so you can assign unicode to string<c8> and ascii to string<wchar_t> 
-(and the other way round) if your ever would want to. 
-Note that the conversation between both is not done using an encoding.
-
-Known bugs:
-Special characters like 'Ä', 'Ü' and 'Ö' are ignored in the
-methods make_upper, make_lower and equals_ignore_case.
-*/
-template <class T>
-class string
-{
-public:
-
-	//! Default constructor
-	string()
-	: array(0), allocated(1), used(1)
-	{
-		array = new T[1];
-		array[0] = 0x0;
-	}
-
-
-
-	//! Constructor
-	string(const string<T>& other)
-	: array(0), allocated(0), used(0)
-	{
-		*this = other;
-	}
-
-
-	//! Constructs a string from an int
-	string(int number)
-	: array(0), allocated(0), used(0)
-	{
-		// store if negative and make positive
-
-		bool negative = false;
-		if (number < 0)
-		{
-			number *= -1;
-			negative = true;
-		}
-
-		// temporary buffer for 16 numbers
-
-		c8 tmpbuf[16];
-		tmpbuf[15] = 0;
-		s32 idx = 15;	
-
-		// special case '0'
-
-		if (!number) 
-		{
-			tmpbuf[14] = '0';
-			*this = &tmpbuf[14];
-			return;
-		}
-
-		// add numbers
-
-		while(number && idx)
-		{
-			idx--;	
-			tmpbuf[idx] = (c8)('0' + (number % 10));
-			number = number / 10;					
-		}
-
-		// add sign
-
-		if (negative)
-		{
-			idx--;
-			tmpbuf[idx] = '-';			
-		}
-
-		*this = &tmpbuf[idx];
-	}
-
-
-
-	//! Constructor for copying a string from a pointer with a given lenght
-	template <class B>
-	string(const B* c, s32 lenght)
-	: array(0), allocated(0), used(0)
-	{
-		if (!c)
-			return;
-
-        allocated = used = lenght+1;
-		array = new T[used];
-
-		for (s32 l = 0; l<lenght; ++l)
-			array[l] = (T)c[l];
-
-		array[lenght] = 0;
-	}
-
-
-
-	//! Constructor for unicode and ascii strings
-	template <class B>
-	string(const B* c)
-	: array(0),allocated(0), used(0)
-	{
-		*this = c;
-	}
-
-
-
-	//! destructor
-	~string()
-	{
-		delete [] array;
-	}
-
-
-
-	//! Assignment operator
-	string<T>& operator=(const string<T>& other) 
-	{
-		if (this == &other)
-			return *this;
-
-		delete [] array;
-		allocated = used = other.size()+1;
-		array = new T[used];
-
-		const T* p = other.c_str();
-		for (s32 i=0; i<used; ++i, ++p)
-			array[i] = *p;
-
-		return *this;
-	}
-
-
-
-	//! Assignment operator for strings, ascii and unicode
-	template <class B>
-	string<T>& operator=(const B* c) 
-	{
-		if (!c)
-		{
-			if (!array)
-			{
-				array = new T[1];
-				allocated = 1;
-				used = 1;
-			}
-			array[0] = 0x0;
-			return *this;
-		}
-
-		if ((void*)c == (void*)array)
-			return *this;
-
-		s32 len = 0;
-		const B* p = c;
-		while(*p)
-		{
-			++len;
-			++p;
-		}
-
-		// we'll take the old string for a while, because the new string could be
-		// a part of the current string.
-		T* oldArray = array;
-
-        allocated = used = len+1;
-		array = new T[used];
-
-		for (s32 l = 0; l<len+1; ++l)
-			array[l] = (T)c[l];
-
-		delete [] oldArray;
-		return *this;
-	}
-
-	//! Add operator for other strings
-	string<T> operator+(const string<T>& other) 
-	{ 
-		string<T> str(*this); 
-		str.append(other); 
-
-		return str; 
-	} 
-
-	//! Add operator for strings, ascii and unicode 
-	template <class B> 
-	string<T> operator+(const B* c) 
-	{ 
-		string<T> str(*this); 
-		str.append(c); 
-
-		return str; 
-	}
-
-
-
-	//! Direct access operator
-	T& operator [](const s32 index)  const
-	{
-		_IRR_DEBUG_BREAK_IF(index>=used) // bad index
-
-		return array[index];
-	}
-
-
-	//! Comparison operator
-	bool operator ==(const T* str) const
-	{
-		int i;
-		for(i=0; array[i] && str[i]; ++i)
-			if (array[i] != str[i])
-				return false;
-
-		return !array[i] && !str[i];
-	}
-
-
-
-	//! Comparison operator
-	bool operator ==(const string<T>& other) const
-	{
-		for(s32 i=0; array[i] && other.array[i]; ++i)
-			if (array[i] != other.array[i])
-				return false;
-
-		return used == other.used;
-	}
-
-
-
-	//! Is smaller operator
-	bool operator <(const string<T>& other) const
-	{
-		for(s32 i=0; array[i] && other.array[i]; ++i)
-			if (array[i] != other.array[i])
-				return (array[i] < other.array[i]);
-
-		return used < other.used;
-	}
-
-
-
-	//! Equals not operator
-	bool operator !=(const string<T>& other) const
-	{
-		return !(*this == other);
-	}
-
-
-    
-	//! Returns length of string
-	/** \return Returns length of the string in characters. */
-	s32 size() const
-	{
-		return used-1;
-	}
-
-
-
-	//! Returns character string
-	/** \return Returns pointer to C-style zero terminated string. */
-	const T* c_str() const
-	{
-		return array;
-	}
-
-
-
-	//! Makes the string lower case.
-	void make_lower()
-	{
-		const T A = (T)'A';
-		const T Z = (T)'Z';
-		const T diff = (T)'a' - A;
-
-		for (s32 i=0; i<used; ++i)
-		{
-			if (array[i]>=A && array[i]<=Z)
-				array[i] += diff;
-		}
-	}
-
-
-
-	//! Makes the string upper case.
-	void make_upper()
-	{
-		const T a = (T)'a';
-		const T z = (T)'z';
-		const T diff = (T)'A' - a;
-
-		for (s32 i=0; i<used; ++i)
-		{
-			if (array[i]>=a && array[i]<=z)
-				array[i] += diff;
-		}
-	}
-
-
-
-	//! Compares the string ignoring case.
-	/** \param other: Other string to compare.
-	\return Returns true if the string are equal ignoring case. */
-	bool equals_ignore_case(const string<T>& other) const
-	{
-		for(s32 i=0; array[i] && other[i]; ++i)
-			if (toLower(array[i]) != toLower(other[i]))
-				return false;
-
-		return used == other.used;
-	}
-
-
-	//! compares the first n characters of the strings
-	bool equalsn(const string<T>& other, int len)
-	{
-		int i;
-		for(i=0; array[i] && other[i] && i < len; ++i)
-			if (array[i] != other[i])
-				return false;
-
-		// if one (or both) of the strings was smaller then they
-		// are only equal if they have the same lenght
-		return (i == len) || (used == other.used);
-	}
-
-
-	//! compares the first n characters of the strings
-	bool equalsn(const T* str, int len)
-	{
-		int i;	
-		for(i=0; array[i] && str[i] && i < len; ++i)
-			if (array[i] != str[i])
-				return false;
-
-		// if one (or both) of the strings was smaller then they
-		// are only equal if they have the same lenght
-		return (i == len) || (array[i] == 0 && str[i] == 0);
-	}
-
-
-	//! Appends a character to this string
-	/** \param character: Character to append. */
-	void append(T character)
-	{
-		if (used + 1 > allocated)
-			reallocate((s32)used + 1);
-
-		used += 1;
-
-		array[used-2] = character;
-		array[used-1] = 0;
-	}
-
-	//! Appends a string to this string
-	/** \param other: String to append. */
-	void append(const string<T>& other)
-	{
-		--used;
-
-		s32 len = other.size();
-		
-		if (used + len + 1 > allocated)
-			reallocate((s32)used + (s32)len + 1);
-
-		for (s32 l=0; l<len+1; ++l)
-			array[l+used] = other[l];
-
-		used = used + len + 1;
-	}
-
-
-	//! Appends a string of the length l to this string.
-	/** \param other: other String to append to this string.
-	 \param length: How much characters of the other string to add to this one. */
-	void append(const string<T>& other, s32 length)
-	{
-		s32 len = other.size();
-
-		if (len < length)
-		{
-			append(other);
-			return;
-		}
-
-		len = length;
-		--used;
-		
-		if (used + len > allocated)
-			reallocate((s32)used + (s32)len);
-
-		for (s32 l=0; l<len; ++l)
-			array[l+used] = other[l];
-
-		used = used + len;
-	}
-
-
-	//! Reserves some memory.
-	/** \param count: Amount of characters to reserve. */
-	void reserve(s32 count)
-	{
-		if (count < allocated)
-			return;
-
-		reallocate(count);
-	}
-
-
-	//! finds first occurrence of character in string
-	/** \param c: Character to search for.
-	\return Returns position where the character has been found,
-	or -1 if not found. */
-	s32 findFirst(T c) const
-	{
-		for (s32 i=0; i<used; ++i)
-			if (array[i] == c)
-				return i;
-
-		return -1;
-	}
-
-	//! finds first occurrence of a character of a list in string
-	/** \param c: List of strings to find. For example if the method
-	should find the first occurance of 'a' or 'b', this parameter should be "ab".
-	\param count: Amount of characters in the list. Ususally, 
-	this should be strlen(ofParameter1)
-	\return Returns position where one of the character has been found,
-	or -1 if not found. */
-	s32 findFirstChar(T* c, int count) const
-	{
-		for (s32 i=0; i<used; ++i)
-			for (int j=0; j<count; ++j)
-				if (array[i] == c[j])
-					return i;
-
-		return -1;
-	}
-
-
-	//! Finds first position of a character not in a given list.
-	/** \param c: List of characters not to find. For example if the method
-	 should find the first occurance of a character not 'a' or 'b', this parameter should be "ab".
-	\param count: Amount of characters in the list. Ususally, 
-	this should be strlen(ofParameter1)
-	\return Returns position where the character has been found,
-	or -1 if not found. */
-	template <class B> 
-	s32 findFirstCharNotInList(B* c, int count) const
-	{
-		for (int i=0; i<used; ++i)
-		{
-            int j;
-			for (j=0; j<count; ++j)
-				if (array[i] == c[j])
-					break;
-
-			if (j==count)
-				return i;
-		}
-
-		return -1;
-	}
-
-	//! Finds last position of a character not in a given list.
-	/** \param c: List of characters not to find. For example if the method
-	 should find the first occurance of a character not 'a' or 'b', this parameter should be "ab".
-	\param count: Amount of characters in the list. Ususally, 
-	this should be strlen(ofParameter1)
-	\return Returns position where the character has been found,
-	or -1 if not found. */
-	template <class B> 
-	s32 findLastCharNotInList(B* c, int count) const
-	{
-		for (int i=used-2; i>=0; --i)
-		{
-            int j;
-			for (j=0; j<count; ++j)
-				if (array[i] == c[j])
-					break;
-
-			if (j==count)
-				return i;
-		}
-
-		return -1;
-	}
-
-	//! finds next occurrence of character in string
-	/** \param c: Character to search for.
-	\param startPos: Position in string to start searching. 
-	\return Returns position where the character has been found,
-	or -1 if not found. */
-	s32 findNext(T c, s32 startPos) const
-	{
-		for (s32 i=startPos; i<used; ++i)
-			if (array[i] == c)
-				return i;
-
-		return -1;
-	}
-
-
-	//! finds last occurrence of character in string
-	//! \param c: Character to search for.
-	//! \return Returns position where the character has been found,
-	//! or -1 if not found.
-	s32 findLast(T c) const
-	{
-		for (s32 i=used-1; i>=0; --i)
-			if (array[i] == c)
-				return i;
-
-		return -1;
-	}
-
-
-	//! Returns a substring
-	//! \param begin: Start of substring.
-	//! \param length: Length of substring.
-	string<T> subString(s32 begin, s32 length)
-	{
-		if (length <= 0)
-			return string<T>("");
-
-		string<T> o;
-		o.reserve(length+1);
-
-		for (s32 i=0; i<length; ++i)
-			o.array[i] = array[i+begin];
-
-		o.array[length] = 0;
-		o.used = o.allocated;
-
-		return o;
-	}
-
-
-	void operator += (T c)
-	{
-		append(c);
-	}
-
-	void operator += (const string<T>& other)
-	{
-		append(other);
-	}
-
-	void operator += (int i)
-	{
-		append(string<T>(i));
-	}
-
-	//! replaces all characters of a special type with another one
-	void replace(T toReplace, T replaceWith)
-	{
-		for (s32 i=0; i<used; ++i)
-			if (array[i] == toReplace)
-				array[i] = replaceWith;
-	}
-
-	//! trims the string.
-	/** Removes whitespace from begin and end of the string. */
-	void trim()
-	{
-		const char whitespace[] = " \t\n";
-		const int whitespacecount = 3;
-
-		// find start and end of real string without whitespace
-		int begin = findFirstCharNotInList(whitespace, whitespacecount);
-		if (begin == -1)
-			return;
-
-		int end = findLastCharNotInList(whitespace, whitespacecount);
-		if (end == -1)
-			return;
-
-		*this = subString(begin, (end +1) - begin);
-	}
-
-
-	//! Erases a character from the string. May be slow, because all elements 
-	//! following after the erased element have to be copied.
-	//! \param index: Index of element to be erased.
-	void erase(int index)
-	{
-		_IRR_DEBUG_BREAK_IF(index>=used || index<0) // access violation
-
-		for (int i=index+1; i<used; ++i)
-			array[i-1] = array[i];
-
-		--used;
-	}
-
-    	
-
-private:
-
-	//! Returns a character converted to lower case
-	T toLower(const T& t) const
-	{
-		if (t>=(T)'A' && t<=(T)'Z')
-			return t + ((T)'a' - (T)'A');
-		else
-			return t;
-	}
-
-	//! Reallocate the array, make it bigger or smaler
-	void reallocate(s32 new_size)
-	{
-		T* old_array = array;
-
-		array = new T[new_size];
-		allocated = new_size;
-		
-		s32 amount = used < new_size ? used : new_size;
-		for (s32 i=0; i<amount; ++i)
-			array[i] = old_array[i];
-
-		if (allocated < used)
-			used = allocated;
-		
-		delete [] old_array;
-	}
-
-
-	//--- member variables
-
-	T* array;
-	s32 allocated;
-	s32 used;
-};
-
-
-//! Typedef for character strings
-typedef string<irr::c8> stringc;
-
-//! Typedef for wide character strings
-typedef string<wchar_t> stringw;
-
-} // end namespace core
-} // end namespace irr
-
-#endif
-
diff --git a/Engine/lib/assimp/contrib/irrXML/irrTypes.h b/Engine/lib/assimp/contrib/irrXML/irrTypes.h
deleted file mode 100644
index a7f12ec75..000000000
--- a/Engine/lib/assimp/contrib/irrXML/irrTypes.h
+++ /dev/null
@@ -1,108 +0,0 @@
-// Copyright (C) 2002-2005 Nikolaus Gebhardt
-// This file is part of the "Irrlicht Engine".
-// For conditions of distribution and use, see copyright notice in irrlicht.h
-
-#ifndef __IRR_TYPES_H_INCLUDED__
-#define __IRR_TYPES_H_INCLUDED__
-
-namespace irr
-{
-
-//! 8 bit unsigned variable.
-/** This is a typedef for unsigned char, it ensures portability of the engine. */
-typedef unsigned char		u8; 
-
-//! 8 bit signed variable.
-/** This is a typedef for signed char, it ensures portability of the engine. */
-typedef signed char			s8; 
-
-//! 8 bit character variable.
-/** This is a typedef for char, it ensures portability of the engine. */
-typedef char				c8; 
-
-
-
-//! 16 bit unsigned variable.
-/** This is a typedef for unsigned short, it ensures portability of the engine. */
-typedef unsigned short		u16;
-
-//! 16 bit signed variable.
-/** This is a typedef for signed short, it ensures portability of the engine. */
-typedef signed short		s16; 
-
-
-
-//! 32 bit unsigned variable.
-/** This is a typedef for unsigned int, it ensures portability of the engine. */
-typedef unsigned int		u32;
-
-//! 32 bit signed variable.
-/** This is a typedef for signed int, it ensures portability of the engine. */
-typedef signed int			s32; 
-
-
-
-// 64 bit signed variable.
-// This is a typedef for __int64, it ensures portability of the engine. 
-// This type is currently not used by the engine and not supported by compilers
-// other than Microsoft Compilers, so it is outcommented.
-//typedef __int64				s64; 
-
-
-
-//! 32 bit floating point variable.
-/** This is a typedef for float, it ensures portability of the engine. */
-typedef float				f32; 
-
-//! 64 bit floating point variable.
-/** This is a typedef for double, it ensures portability of the engine. */
-typedef double				f64; 
-
-
-} // end namespace
-
-
-// define the wchar_t type if not already built in.
-#ifdef _MSC_VER 
-#ifndef _WCHAR_T_DEFINED
-//! A 16 bit wide character type.
-/**
-	Defines the wchar_t-type.
-	In VS6, its not possible to tell
-	the standard compiler to treat wchar_t as a built-in type, and 
-	sometimes we just don't want to include the huge stdlib.h or wchar.h,
-	so we'll use this.
-*/
-typedef unsigned short wchar_t;
-#define _WCHAR_T_DEFINED
-#endif // wchar is not defined
-#endif // microsoft compiler
-
-//! define a break macro for debugging only in Win32 mode.
-// WORKAROUND (assimp): remove __asm
-#if defined(WIN32) && defined(_MSC_VER) && defined(_DEBUG)
-#if defined(_M_IX86)
-#define _IRR_DEBUG_BREAK_IF( _CONDITION_ ) /*if (_CONDITION_) {_asm int 3}*/
-#else
-#define _IRR_DEBUG_BREAK_IF( _CONDITION_ )
-#endif
-#else 
-#define _IRR_DEBUG_BREAK_IF( _CONDITION_ )
-#endif
-
-//! Defines a small statement to work around a microsoft compiler bug.
-/** The microsft compiler 7.0 - 7.1 has a bug:
-When you call unmanaged code that returns a bool type value of false from managed code, 
-the return value may appear as true. See 
-http://support.microsoft.com/default.aspx?kbid=823071 for details. 
-Compiler version defines: VC6.0 : 1200, VC7.0 : 1300, VC7.1 : 1310, VC8.0 : 1400*/
-
-// WORKAROUND (assimp): remove __asm 
-#if defined(WIN32) && defined(_MSC_VER) && (_MSC_VER > 1299) && (_MSC_VER < 1400)
-#define _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX /*__asm mov eax,100*/
-#else
-#define _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX
-#endif // _IRR_MANAGED_MARSHALLING_BUGFIX
-
-#endif // __IRR_TYPES_H_INCLUDED__
-
diff --git a/Engine/lib/assimp/contrib/irrXML/irrXML.cpp b/Engine/lib/assimp/contrib/irrXML/irrXML.cpp
deleted file mode 100644
index 5a4b04507..000000000
--- a/Engine/lib/assimp/contrib/irrXML/irrXML.cpp
+++ /dev/null
@@ -1,151 +0,0 @@
-// Copyright (C) 2002-2005 Nikolaus Gebhardt
-// This file is part of the "Irrlicht Engine" and the "irrXML" project.
-// For conditions of distribution and use, see copyright notice in irrlicht.h and/or irrXML.h
-
-// Need to include Assimp, too. We're using Assimp's version of fast_atof
-// so we need stdint.h. But no PCH.
-
-
-#include "irrXML.h"
-#include "irrString.h"
-#include "irrArray.h"
-//#include <assimp/fast_atof.h>
-#include "CXMLReaderImpl.h"
-
-namespace irr
-{
-namespace io
-{
-
-//! Implementation of the file read callback for ordinary files
-class IRRXML_API CFileReadCallBack : public IFileReadCallBack
-{
-public:
-
-	//! construct from filename
-	CFileReadCallBack(const char* filename)
-		: File(0), Size(0), Close(true)
-	{
-		// open file
-		File = fopen(filename, "rb");
-
-		if (File)
-			getFileSize();
-	}
-
-	//! construct from FILE pointer
-	CFileReadCallBack(FILE* file)
-		: File(file), Size(0), Close(false)
-	{
-		if (File)
-			getFileSize();
-	}
-
-	//! destructor
-	virtual ~CFileReadCallBack()
-	{
-		if (Close && File)
-			fclose(File);
-	}
-
-	//! Reads an amount of bytes from the file.
-	virtual int read(void* buffer, int sizeToRead)
-	{
-		if (!File)
-			return 0;
-
-		return (int)fread(buffer, 1, sizeToRead, File);
-	}
-
-	//! Returns size of file in bytes
-	virtual int getSize()
-	{
-		return Size;
-	}
-
-private:
-
-	//! retrieves the file size of the open file
-	void getFileSize()
-	{
-		fseek(File, 0, SEEK_END);
-		Size = ftell(File);
-		fseek(File, 0, SEEK_SET);
-	}
-
-	FILE* File;
-	int Size;
-	bool Close;
-
-}; // end class CFileReadCallBack
-
-
-
-// FACTORY FUNCTIONS:
-
-
-//! Creates an instance of an UFT-8 or ASCII character xml parser. 
-IrrXMLReader* createIrrXMLReader(const char* filename)
-{
-	return new CXMLReaderImpl<char, IXMLBase>(new CFileReadCallBack(filename)); 
-}
-
-
-//! Creates an instance of an UFT-8 or ASCII character xml parser. 
-IrrXMLReader* createIrrXMLReader(FILE* file)
-{
-	return new CXMLReaderImpl<char, IXMLBase>(new CFileReadCallBack(file)); 
-}
-
-
-//! Creates an instance of an UFT-8 or ASCII character xml parser. 
-IrrXMLReader* createIrrXMLReader(IFileReadCallBack* callback)
-{
-	return new CXMLReaderImpl<char, IXMLBase>(callback, false); 
-}
-
-
-//! Creates an instance of an UTF-16 xml parser. 
-IrrXMLReaderUTF16* createIrrXMLReaderUTF16(const char* filename)
-{
-	return new CXMLReaderImpl<char16, IXMLBase>(new CFileReadCallBack(filename)); 
-}
-
-
-//! Creates an instance of an UTF-16 xml parser. 
-IrrXMLReaderUTF16* createIrrXMLReaderUTF16(FILE* file)
-{
-	return new CXMLReaderImpl<char16, IXMLBase>(new CFileReadCallBack(file)); 
-}
-
-
-//! Creates an instance of an UTF-16 xml parser. 
-IrrXMLReaderUTF16* createIrrXMLReaderUTF16(IFileReadCallBack* callback)
-{
-	return new CXMLReaderImpl<char16, IXMLBase>(callback, false); 
-}
-
-
-//! Creates an instance of an UTF-32 xml parser. 
-IrrXMLReaderUTF32* createIrrXMLReaderUTF32(const char* filename)
-{
-	return new CXMLReaderImpl<char32, IXMLBase>(new CFileReadCallBack(filename)); 
-}
-
-
-//! Creates an instance of an UTF-32 xml parser. 
-IrrXMLReaderUTF32* createIrrXMLReaderUTF32(FILE* file)
-{
-	return new CXMLReaderImpl<char32, IXMLBase>(new CFileReadCallBack(file)); 
-}
-
-
-//! Creates an instance of an UTF-32 xml parser. 
-IrrXMLReaderUTF32* createIrrXMLReaderUTF32(IFileReadCallBack* callback)
-{
-	return new CXMLReaderImpl<char32, IXMLBase>(callback, false); 
-}
-
-
-} // end namespace io
-} // end namespace irr
diff --git a/Engine/lib/assimp/contrib/irrXML/irrXML.h b/Engine/lib/assimp/contrib/irrXML/irrXML.h
deleted file mode 100644
index d724b3162..000000000
--- a/Engine/lib/assimp/contrib/irrXML/irrXML.h
+++ /dev/null
@@ -1,546 +0,0 @@
-// Copyright (C) 2002-2005 Nikolaus Gebhardt
-// This file is part of the "Irrlicht Engine" and the "irrXML" project.
-// For conditions of distribution and use, see copyright notice in irrlicht.h and/or irrXML.h
-
-#ifndef __IRR_XML_H_INCLUDED__
-#define __IRR_XML_H_INCLUDED__
-
-#include <stdio.h>
-
-#ifdef _WIN32
-#   define IRRXML_API __declspec(dllexport)
-#else
-#   define IRRXML_API __attribute__ ((visibility("default")))
-#endif // _WIN32
-
-/** \mainpage irrXML 1.2 API documentation
- <div align="center"><img src="logobig.png" ></div>
-
- \section intro Introduction
-
-  Welcome to the irrXML API documentation.
-  Here you'll find any information you'll need to develop applications with
-  irrXML. If you look for a tutorial on how to start, take a look at the \ref irrxmlexample,
-  at the homepage of irrXML at <A HREF="http://xml.irrlicht3d.org" >xml.irrlicht3d.org</A> 
-  or into the SDK in the directory \example.
- 
-  irrXML is intended to be a high speed and easy-to-use XML Parser for C++, and
-  this documentation is an important part of it. If you have any questions or
-  suggestions, just send a email to the author of the engine, Nikolaus Gebhardt
-  (niko (at) irrlicht3d.org). For more informations about this parser, see \ref history.
-
-  \section features Features
-
-  irrXML provides forward-only, read-only 
-     access to a stream of non validated XML data. It was fully implemented by
-	 Nikolaus Gebhardt. Its current features are:
-
-	 - It it fast as lighting and has very low memory usage. It was 
-	   developed with the intention of being used in 3D games, as it already has been.
-	 - irrXML is very small: It only consists of 60 KB of code and can be added easily
-	   to your existing project.
-	 - Of course, it is platform independent and works with lots of compilers.
-	 - It is able to parse ASCII, UTF-8, UTF-16 and UTF-32 text files, both in 
-	   little and big endian format. 
-	 - Independent of the input file format, the parser can return all strings in ASCII, UTF-8,
-	   UTF-16 and UTF-32 format. 
-	 - With its optional file access abstraction it has the advantage that it can read not
-	   only from files but from any type of data (memory, network, ...). For example when 
-	   used with the Irrlicht Engine, it directly reads from compressed .zip files. 
-	 - Just like the Irrlicht Engine for which it was originally created, it is extremely easy 
-	   to use.
-	 - It has no external dependencies, it does not even need the STL. 
-
-	 Although irrXML has some strenghts, it currently also has the following limitations:
-
-	 - The input xml file is not validated and assumed to be correct. 
-
-    \section irrxmlexample Example
-
-    The following code demonstrates the basic usage of irrXML. A simple xml
-	file like this is parsed:
-    \code
-	<?xml version="1.0"?>
-	<config>
-		<!-- This is a config file for the mesh viewer -->
-		<model file="dwarf.dea" />
-		<messageText caption="Irrlicht Engine Mesh Viewer">
-		Welcome to the Mesh Viewer of the &quot;Irrlicht Engine&quot;.
-		</messageText>
-	</config>
-	\endcode
-
-	The code for parsing this file would look like this:
-	\code
-	#include <irrXML.h>
-	using namespace irr; // irrXML is located in the namespace irr::io
-	using namespace io;
-
-	#include <string> // we use STL strings to store data in this example
-
-	void main()
-	{
-		// create the reader using one of the factory functions
-
-		IrrXMLReader* xml = createIrrXMLReader("config.xml");
-
-		// strings for storing the data we want to get out of the file
-		std::string modelFile;
-		std::string messageText;
-		std::string caption;
-
-		// parse the file until end reached
-
-		while(xml && xml->read())
-		{
-			switch(xml->getNodeType())
-			{
-			case EXN_TEXT:
-				// in this xml file, the only text which occurs is the messageText
-				messageText = xml->getNodeData();
-				break;
-			case EXN_ELEMENT:
-				{
-					if (!strcmp("model", xml->getNodeName()))
-						modelFile = xml->getAttributeValue("file");
-					else
-					if (!strcmp("messageText", xml->getNodeName()))
-						caption = xml->getAttributeValue("caption");
-				}
-				break;
-			}
-		}
-
-		// delete the xml parser after usage
-		delete xml;
-	}
-	\endcode
-
-	\section howto How to use
-
-	Simply add the source files in the /src directory of irrXML to your project. Done.
-
-	\section license License
-
-	The irrXML license is based on the zlib license. Basicly, this means you can do with
-	irrXML whatever you want:
-
-	Copyright (C) 2002-2005 Nikolaus Gebhardt
-
-	This software is provided 'as-is', without any express or implied
-	warranty.  In no event will the authors be held liable for any damages
-	arising from the use of this software.
-
-	Permission is granted to anyone to use this software for any purpose,
-	including commercial applications, and to alter it and redistribute it
-	freely, subject to the following restrictions:
-
-	1. The origin of this software must not be misrepresented; you must not
-		claim that you wrote the original software. If you use this software
-		in a product, an acknowledgment in the product documentation would be
-		appreciated but is not required.
-
-	2. Altered source versions must be plainly marked as such, and must not be
-		misrepresented as being the original software.
-
-	3. This notice may not be removed or altered from any source distribution.
-
-	\section history History
-
-	As lots of references in this documentation and the source show, this xml 
-	parser has originally been a part of the 
-	<A HREF="http://irrlicht.sourceforge.net" >Irrlicht Engine</A>. But because
-	the parser has become very useful with the latest release, people asked for a 
-	separate version of it, to be able to use it in non Irrlicht projects. With
-	irrXML 1.0, this has now been done.
-*/
-
-namespace irr
-{
-namespace io
-{
-	//! Enumeration of all supported source text file formats 
-	enum ETEXT_FORMAT
-	{
-		//! ASCII, file without byte order mark, or not a text file
-		ETF_ASCII,
-
-		//! UTF-8 format
-		ETF_UTF8,
-
-		//! UTF-16 format, big endian
-		ETF_UTF16_BE,
-
-		//! UTF-16 format, little endian
-		ETF_UTF16_LE,
-
-		//! UTF-32 format, big endian
-		ETF_UTF32_BE,
-
-		//! UTF-32 format, little endian
-		ETF_UTF32_LE
-	};
-
-
-	//! Enumeration for all xml nodes which are parsed by IrrXMLReader
-	enum EXML_NODE
-	{
-		//! No xml node. This is usually the node if you did not read anything yet.
-		EXN_NONE,
-
-		//! A xml element, like <foo>
-		EXN_ELEMENT,
-
-		//! End of an xml element, like </foo>
-		EXN_ELEMENT_END,
-
-		//! Text within a xml element: <foo> this is the text. </foo>
-		EXN_TEXT,
-
-		//! An xml comment like &lt;!-- I am a comment --&gt; or a DTD definition.
-		EXN_COMMENT,
-
-		//! An xml cdata section like &lt;![CDATA[ this is some CDATA ]]&gt;
-		EXN_CDATA,
-
-		//! Unknown element.
-		EXN_UNKNOWN
-	};
-
-	//! Callback class for file read abstraction. 
-	/** With this, it is possible to make the xml parser read in other things 
-	than just files. The Irrlicht engine is using this for example to 
-	read xml from compressed .zip files. To make the parser read in 
-	any other data, derive a class from this interface, implement the 
-	two methods to read your data and give a pointer to an instance of
-	your implementation when calling createIrrXMLReader(), 
-	createIrrXMLReaderUTF16() or createIrrXMLReaderUTF32() */
-	class IRRXML_API IFileReadCallBack
-	{
-	public:
-
-		//! virtual destructor
-		virtual ~IFileReadCallBack() {};
-
-		//! Reads an amount of bytes from the file.
-		/** \param buffer: Pointer to buffer where to read bytes will be written to.
-		\param sizeToRead: Amount of bytes to read from the file.
-		\return Returns how much bytes were read. */
-		virtual int read(void* buffer, int sizeToRead) = 0;
-
-		//! Returns size of file in bytes
-		virtual int getSize() = 0;
-	};
-
-	//! Empty class to be used as parent class for IrrXMLReader.
-	/** If you need another class as base class for the xml reader, you can do this by creating
-	the reader using for example new CXMLReaderImpl<char, YourBaseClass>(yourcallback);
-	The Irrlicht Engine for example needs IUnknown as base class for every object to
-	let it automaticly reference countend, hence it replaces IXMLBase with IUnknown.
-	See irrXML.cpp on how this can be done in detail. */
-	class IXMLBase
-	{
-	};	
-
-	//! Interface providing easy read access to a XML file.
-	/** You can create an instance of this reader using one of the factory functions
-	createIrrXMLReader(), createIrrXMLReaderUTF16() and createIrrXMLReaderUTF32().
-	If using the parser from the Irrlicht Engine, please use IFileSystem::createXMLReader() 
-	instead.
-	For a detailed intro how to use the parser, see \ref irrxmlexample and \ref features.
-
-	The typical usage of this parser looks like this:
-	\code
-	#include <irrXML.h>
-	using namespace irr; // irrXML is located in the namespace irr::io
-	using namespace io;
-
-	void main()
-	{
-		// create the reader using one of the factory functions
-		IrrXMLReader* xml = createIrrXMLReader("config.xml");
-
-		if (xml == 0)
-			return; // file could not be opened
-
-		// parse the file until end reached
-		while(xml->read())
-		{
-			// based on xml->getNodeType(), do something.
-		}
-
-		// delete the xml parser after usage
-		delete xml;
-	}
-	\endcode
-	See \ref irrxmlexample for a more detailed example.
-	*/
-	template<class char_type, class super_class>
-	class IIrrXMLReader : public super_class
-	{
-	public:
-
-		//! Destructor
-		virtual ~IIrrXMLReader() {};
-
-		//! Reads forward to the next xml node. 
-		/** \return Returns false, if there was no further node.  */
-		virtual bool read() = 0;
-
-		//! Returns the type of the current XML node.
-		virtual EXML_NODE getNodeType() const = 0;
-
-        //! Returns attribute count of the current XML node. 
-		/** This is usually
-		non null if the current node is EXN_ELEMENT, and the element has attributes.
-		\return Returns amount of attributes of this xml node. */
-		virtual int getAttributeCount() const = 0;
-
-		//! Returns name of an attribute. 
-		/** \param idx: Zero based index, should be something between 0 and getAttributeCount()-1.
-		\return Name of the attribute, 0 if an attribute with this index does not exist. */
-		virtual const char_type* getAttributeName(int idx) const = 0;
-
-		//! Returns the value of an attribute. 
-		/** \param idx: Zero based index, should be something between 0 and getAttributeCount()-1.
-		\return Value of the attribute, 0 if an attribute with this index does not exist. */
-		virtual const char_type* getAttributeValue(int idx) const = 0;
-
-		//! Returns the value of an attribute. 
-		/** \param name: Name of the attribute.
-		\return Value of the attribute, 0 if an attribute with this name does not exist. */
-		virtual const char_type* getAttributeValue(const char_type* name) const = 0;
-
-		//! Returns the value of an attribute in a safe way.
-		/** Like getAttributeValue(), but does not 
-		return 0 if the attribute does not exist. An empty string ("") is returned then.
-		\param name: Name of the attribute.
-		\return Value of the attribute, and "" if an attribute with this name does not exist */
-		virtual const char_type* getAttributeValueSafe(const char_type* name) const = 0;
-
-		//! Returns the value of an attribute as integer. 
-		/** \param name Name of the attribute.
-		\return Value of the attribute as integer, and 0 if an attribute with this name does not exist or
-		the value could not be interpreted as integer. */
-		virtual int getAttributeValueAsInt(const char_type* name) const = 0;
-
-		//! Returns the value of an attribute as integer. 
-		/** \param idx: Zero based index, should be something between 0 and getAttributeCount()-1.
-		\return Value of the attribute as integer, and 0 if an attribute with this index does not exist or
-		the value could not be interpreted as integer. */
-		virtual int getAttributeValueAsInt(int idx) const = 0;
-
-		//! Returns the value of an attribute as float. 
-		/** \param name: Name of the attribute.
-		\return Value of the attribute as float, and 0 if an attribute with this name does not exist or
-		the value could not be interpreted as float. */
-		virtual float getAttributeValueAsFloat(const char_type* name) const = 0;
-
-		//! Returns the value of an attribute as float. 
-		/** \param idx: Zero based index, should be something between 0 and getAttributeCount()-1.
-		\return Value of the attribute as float, and 0 if an attribute with this index does not exist or
-		the value could not be interpreted as float. */
-		virtual float getAttributeValueAsFloat(int idx) const = 0;
-
-		//! Returns the name of the current node. 
-		/** Only non null, if the node type is EXN_ELEMENT.
-		\return Name of the current node or 0 if the node has no name. */
-		virtual const char_type* getNodeName() const = 0;
-
-		//! Returns data of the current node. 
-		/** Only non null if the node has some
-		data and it is of type EXN_TEXT or EXN_UNKNOWN. */
-		virtual const char_type* getNodeData() const = 0;
-
-		//! Returns if an element is an empty element, like <foo />
-		virtual bool isEmptyElement() const = 0;
-
-		//! Returns format of the source xml file. 
-		/** It is not necessary to use
-		this method because the parser will convert the input file format
-		to the format wanted by the user when creating the parser. This
-		method is useful to get/display additional informations. */
-		virtual ETEXT_FORMAT getSourceFormat() const = 0;
-
-		//! Returns format of the strings returned by the parser. 
-		/** This will be UTF8 for example when you created a parser with
-		IrrXMLReaderUTF8() and UTF32 when it has been created using 
-		IrrXMLReaderUTF32. It should not be necessary to call this
-		method and only exists for informational purposes. */
-		virtual ETEXT_FORMAT getParserFormat() const = 0;
-	};
-
-
-	//! defines the utf-16 type.
-	/** Not using wchar_t for this because 
-	wchar_t has 16 bit on windows and 32 bit on other operating systems. */
-	typedef unsigned short char16;
-
-	//! defines the utf-32 type. 
-	/** Not using wchar_t for this because 
-	wchar_t has 16 bit on windows and 32 bit on other operating systems. */
-	typedef unsigned long char32;
-
-	//! A UTF-8 or ASCII character xml parser.
-	/** This means that all character data will be returned in 8 bit ASCII or UTF-8 by this parser. 
-	The file to read can be in any format, it will be converted to UTF-8 if it is not
-	in this format.
-	Create an instance of this with createIrrXMLReader(); 
-	See IIrrXMLReader for description on how to use it. */
-	typedef IIrrXMLReader<char, IXMLBase> IrrXMLReader;
-
-	//! A UTF-16 xml parser. 
-	/** This means that all character data will be returned in UTF-16 by this parser. 
-	The file to read can be in any format, it will be converted to UTF-16 if it is not
-	in this format.
-	Create an instance of this with createIrrXMLReaderUTF16(); 
-	See IIrrXMLReader for description on how to use it.  */
-	typedef IIrrXMLReader<char16, IXMLBase> IrrXMLReaderUTF16;
-
-	//! A UTF-32 xml parser. 
-	/** This means that all character data will be returned in UTF-32 by this parser. 
-	The file to read can be in any format, it will be converted to UTF-32 if it is not
-	in this format.
-	Create an instance of this with createIrrXMLReaderUTF32(); 
-	See IIrrXMLReader for description on how to use it. */
-	typedef IIrrXMLReader<char32, IXMLBase> IrrXMLReaderUTF32;
-
-
-	//! Creates an instance of an UFT-8 or ASCII character xml parser.
-	/** This means that all character data will be returned in 8 bit ASCII or UTF-8. 
-	The file to read can be in any format, it will be converted to UTF-8 if it is not in this format.
-	If you are using the Irrlicht Engine, it is better not to use this function but
-	IFileSystem::createXMLReaderUTF8() instead.
-	\param filename: Name of file to be opened.
-	\return Returns a pointer to the created xml parser. This pointer should be 
-	deleted using 'delete' after no longer needed. Returns 0 if an error occured
-	and the file could not be opened. */
-    IRRXML_API IrrXMLReader* createIrrXMLReader(const char* filename);
-
-	//! Creates an instance of an UFT-8 or ASCII character xml parser.
-	/** This means that all character data will be returned in 8 bit ASCII or UTF-8. The file to read can 
-	be in any format, it will be converted to UTF-8 if it is not in this format.
-	If you are using the Irrlicht Engine, it is better not to use this function but
-	IFileSystem::createXMLReaderUTF8() instead.
-	\param file: Pointer to opened file, must have been opened in binary mode, e.g.
-	using fopen("foo.bar", "wb"); The file will not be closed after it has been read.
-	\return Returns a pointer to the created xml parser. This pointer should be 
-	deleted using 'delete' after no longer needed. Returns 0 if an error occured
-	and the file could not be opened. */
-    IRRXML_API IrrXMLReader* createIrrXMLReader(FILE* file);
-
-	//! Creates an instance of an UFT-8 or ASCII character xml parser. 
-	/** This means that all character data will be returned in 8 bit ASCII or UTF-8. The file to read can 
-	 be in any format, it will be converted to UTF-8 if it is not in this format.
-	 If you are using the Irrlicht Engine, it is better not to use this function but
-	 IFileSystem::createXMLReaderUTF8() instead.
-	 \param callback: Callback for file read abstraction. Implement your own
-	 callback to make the xml parser read in other things than just files. See
-	 IFileReadCallBack for more information about this.
-	 \return Returns a pointer to the created xml parser. This pointer should be 
-	 deleted using 'delete' after no longer needed. Returns 0 if an error occured
-	 and the file could not be opened. */
-    IRRXML_API IrrXMLReader* createIrrXMLReader(IFileReadCallBack* callback);
-
-	//! Creates an instance of an UFT-16 xml parser. 
-	/** This means that
-	all character data will be returned in UTF-16. The file to read can 
-	be in any format, it will be converted to UTF-16 if it is not in this format.
-	If you are using the Irrlicht Engine, it is better not to use this function but
-	IFileSystem::createXMLReader() instead.
-	\param filename: Name of file to be opened.
-	\return Returns a pointer to the created xml parser. This pointer should be 
-	deleted using 'delete' after no longer needed. Returns 0 if an error occured
-	and the file could not be opened. */
-    IRRXML_API IrrXMLReaderUTF16* createIrrXMLReaderUTF16(const char* filename);
-
-	//! Creates an instance of an UFT-16 xml parser. 
-	/** This means that all character data will be returned in UTF-16. The file to read can 
-	be in any format, it will be converted to UTF-16 if it is not in this format.
-	If you are using the Irrlicht Engine, it is better not to use this function but
-	IFileSystem::createXMLReader() instead.
-	\param file: Pointer to opened file, must have been opened in binary mode, e.g.
-	using fopen("foo.bar", "wb"); The file will not be closed after it has been read.
-	\return Returns a pointer to the created xml parser. This pointer should be 
-	deleted using 'delete' after no longer needed. Returns 0 if an error occured
-	and the file could not be opened. */
-    IRRXML_API IrrXMLReaderUTF16* createIrrXMLReaderUTF16(FILE* file);
-
-	//! Creates an instance of an UFT-16 xml parser. 
-	/** This means that all character data will be returned in UTF-16. The file to read can 
-	be in any format, it will be converted to UTF-16 if it is not in this format.
-	If you are using the Irrlicht Engine, it is better not to use this function but
-	IFileSystem::createXMLReader() instead.
-	\param callback: Callback for file read abstraction. Implement your own
-	callback to make the xml parser read in other things than just files. See
-	IFileReadCallBack for more information about this.
-	\return Returns a pointer to the created xml parser. This pointer should be 
-	deleted using 'delete' after no longer needed. Returns 0 if an error occured
-	and the file could not be opened. */
-    IRRXML_API IrrXMLReaderUTF16* createIrrXMLReaderUTF16(IFileReadCallBack* callback);
-
-
-	//! Creates an instance of an UFT-32 xml parser. 
-	/** This means that all character data will be returned in UTF-32. The file to read can 
-	be in any format, it will be converted to UTF-32 if it is not in this format.
-	If you are using the Irrlicht Engine, it is better not to use this function but
-	IFileSystem::createXMLReader() instead.
-	\param filename: Name of file to be opened.
-	\return Returns a pointer to the created xml parser. This pointer should be 
-	deleted using 'delete' after no longer needed. Returns 0 if an error occured
-	and the file could not be opened. */
-    IRRXML_API IrrXMLReaderUTF32* createIrrXMLReaderUTF32(const char* filename);
-
-	//! Creates an instance of an UFT-32 xml parser. 
-	/** This means that all character data will be returned in UTF-32. The file to read can 
-	be in any format, it will be converted to UTF-32 if it is not in this format.
-	if you are using the Irrlicht Engine, it is better not to use this function but
-	IFileSystem::createXMLReader() instead.
-	\param file: Pointer to opened file, must have been opened in binary mode, e.g.
-	using fopen("foo.bar", "wb"); The file will not be closed after it has been read.
-	\return Returns a pointer to the created xml parser. This pointer should be 
-	deleted using 'delete' after no longer needed. Returns 0 if an error occured
-	and the file could not be opened. */
-    IRRXML_API IrrXMLReaderUTF32* createIrrXMLReaderUTF32(FILE* file);
-
-	//! Creates an instance of an UFT-32 xml parser. 
-	/** This means that
-	all character data will be returned in UTF-32. The file to read can 
-	be in any format, it will be converted to UTF-32 if it is not in this format.
-	If you are using the Irrlicht Engine, it is better not to use this function but
-	IFileSystem::createXMLReader() instead.
-	\param callback: Callback for file read abstraction. Implement your own
-	callback to make the xml parser read in other things than just files. See
-	IFileReadCallBack for more information about this.
-	\return Returns a pointer to the created xml parser. This pointer should be 
-	deleted using 'delete' after no longer needed. Returns 0 if an error occured
-	and the file could not be opened. */
-    IRRXML_API IrrXMLReaderUTF32* createIrrXMLReaderUTF32(IFileReadCallBack* callback);
-	
-
-	/*! \file irrxml.h
-    \brief Header file of the irrXML, the Irrlicht XML parser.
-    
-    This file includes everything needed for using irrXML, 
-    the XML parser of the Irrlicht Engine. To use irrXML,
-	you only need to include this file in your project:
-
-	\code
-	#include <irrXML.h>
-	\endcode
-
-	It is also common to use the two namespaces in which irrXML is included, 
-	directly after #including irrXML.h:
-
-	\code
-	#include <irrXML.h>
-	using namespace irr;
-	using namespace io;
-	\endcode
-	*/
-
-} // end namespace io
-} // end namespace irr
-
-#endif // __IRR_XML_H_INCLUDED__
-
diff --git a/Engine/lib/assimp/contrib/irrXML_note.txt b/Engine/lib/assimp/contrib/irrXML_note.txt
deleted file mode 100644
index ff7897ec2..000000000
--- a/Engine/lib/assimp/contrib/irrXML_note.txt
+++ /dev/null
@@ -1,6 +0,0 @@
-
-IrrXML
-Downloaded September 2008
-
-- fixed a minor compiler warning (vs 2005, shift too large)
-- fixed an issue regarding wchar_t/unsigned short
diff --git a/Engine/lib/assimp/contrib/openddlparser/CMakeLists.txt b/Engine/lib/assimp/contrib/openddlparser/CMakeLists.txt
index 9e903ca3f..407f0847e 100644
--- a/Engine/lib/assimp/contrib/openddlparser/CMakeLists.txt
+++ b/Engine/lib/assimp/contrib/openddlparser/CMakeLists.txt
@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED( VERSION 2.6 )
+CMAKE_MINIMUM_REQUIRED( VERSION 3.10 )
 PROJECT( OpenDDL-Parser )
 SET ( OPENDDL_PARSER_VERSION_MAJOR 0 )
 SET ( OPENDDL_PARSER_VERSION_MINOR 1 )
@@ -6,20 +6,12 @@ SET ( OPENDDL_PARSER_VERSION_PATCH 0 )
 SET ( OPENDDL_PARSER_VERSION ${OPENDDL_PARSER_VERSION_MAJOR}.${OPENDDL_PARSER_VERSION_MINOR}.${OPENDDL_PARSER_VERSION_PATCH} )
 SET ( PROJECT_VERSION "${OPENDDL_PARSER_VERSION}" )
 
-option( DDL_USE_CPP11           "Set to ON to use C++11 features ( always on on windows )."                   ON )
 option( DDL_DEBUG_OUTPUT        "Set to ON to use output debug texts"                                         OFF )
 option( DDL_STATIC_LIBRARY		"Set to ON to build static libary of OpenDDL Parser."                         ON )
 option( COVERALLS               "Generate coveralls data"                                                     OFF )
 
-if ( DDL_USE_CPP11 )
-    if( CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX )
-        set( OPENDDL_CXXFLAGS -std=c++0x )
-    elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-        set( OPENDDL_CXXFLAGS --std=c++11 )
-    endif()
-else( DDL_USE_CPP11 )
-    add_definitions( -DOPENDDL_NO_USE_CPP11 )
-endif( DDL_USE_CPP11)
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 if( CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX )
     find_package(Threads)
@@ -31,6 +23,11 @@ if ( DDL_STATIC_LIBRARY )
 	add_definitions( -DOPENDDL_STATIC_LIBARY )
 endif()
 
+if (MSVC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /D_SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING")
+    add_definitions(-DGTEST_HAS_TR1_TUPLE=0)
+endif()
+
 add_definitions( -DOPENDDLPARSER_BUILD )
 add_definitions( -D_VARIADIC_MAX=10 )
 add_definitions( -DGTEST_HAS_PTHREAD=0 )
@@ -49,7 +46,7 @@ link_directories(
     ${CMAKE_HOME_DIRECTORY}/lib
 )
 
-set( CMAKE_MODULE_PATH  ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}/cmake )
+SET( CMAKE_MODULE_PATH  ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}/cmake )
 SET( CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_HOME_DIRECTORY}/lib )
 SET( CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_HOME_DIRECTORY}/lib )
 SET( CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_HOME_DIRECTORY}/bin )
@@ -97,6 +94,7 @@ SET ( openddl_parser_src
     include/openddlparser/OpenDDLStream.h
     include/openddlparser/DDLNode.h
     include/openddlparser/Value.h
+    include/openddlparser/TPoolAllocator.h
     README.md
 )
  
@@ -123,7 +121,6 @@ SET ( gtest_src
     ${GTEST_PATH}/src/gtest-test-part.cc
     ${GTEST_PATH}/src/gtest-typed-test.cc
     ${GTEST_PATH}/src/gtest.cc
-    ${GTEST_PATH}/src/gtest_main.cc
 )
 
 SET( openddl_parser_unittest_src  
@@ -137,7 +134,10 @@ SET( openddl_parser_unittest_src
     test/OpenDDLIntegrationTest.cpp
     test/ValueTest.cpp
     test/OpenDDLDefectsTest.cpp
+	test/OssFuzzTest.cpp
+    test/main.cpp
 )
+add_definitions(-DOPENDDL_TEST_DATA="${CMAKE_CURRENT_LIST_DIR}/test/TestData")
 
 SOURCE_GROUP( code  FILES ${openddl_parser_unittest_src} )
 SOURCE_GROUP( gtest FILES ${gtest_src} )
diff --git a/Engine/lib/assimp/contrib/openddlparser/code/DDLNode.cpp b/Engine/lib/assimp/contrib/openddlparser/code/DDLNode.cpp
index a7c557fc5..724c5d67b 100644
--- a/Engine/lib/assimp/contrib/openddlparser/code/DDLNode.cpp
+++ b/Engine/lib/assimp/contrib/openddlparser/code/DDLNode.cpp
@@ -1,7 +1,7 @@
 /*-----------------------------------------------------------------------------------------------
 The MIT License (MIT)
 
-Copyright (c) 2014-2015 Kim Kulling
+Copyright (c) 2014-2020 Kim Kulling
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
@@ -22,6 +22,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 -----------------------------------------------------------------------------------------------*/
 #include <openddlparser/DDLNode.h>
 #include <openddlparser/OpenDDLParser.h>
+#include <openddlparser/OpenDDLStream.h>
 
 #include <algorithm>
 
@@ -29,77 +30,76 @@ BEGIN_ODDLPARSER_NS
 
 DDLNode::DllNodeList DDLNode::s_allocatedNodes;
 
-template<class T>
-inline
-static void releaseDataType( T *ptr ) {
-    if( ddl_nullptr == ptr ) {
+template <class T>
+inline static void releaseDataType(T *ptr) {
+    if (nullptr == ptr) {
         return;
     }
 
-    T *current( ddl_nullptr );
-    while( ptr ) {
+    T *current(nullptr);
+    while (ptr) {
         current = ptr;
         ptr = ptr->m_next;
         delete current;
     }
 }
 
-static void releaseReferencedNames( Reference *ref ) {
-    if( ddl_nullptr == ref ) {
+static void releaseReferencedNames(Reference *ref) {
+    if (nullptr == ref) {
         return;
     }
 
     delete ref;
 }
 
-DDLNode::DDLNode( const std::string &type, const std::string &name, size_t idx, DDLNode *parent )
-: m_type( type )
-, m_name( name )
-, m_parent( parent )
-, m_children()
-, m_properties( ddl_nullptr )
-, m_value( ddl_nullptr )
-, m_dtArrayList( ddl_nullptr )
-, m_references( ddl_nullptr )
-, m_idx( idx ) {
-    if( m_parent ) {
-        m_parent->m_children.push_back( this );
+DDLNode::DDLNode(const std::string &type, const std::string &name, size_t idx, DDLNode *parent) :
+        m_type(type),
+        m_name(name),
+        m_parent(parent),
+        m_children(),
+        m_properties(nullptr),
+        m_value(nullptr),
+        m_dtArrayList(nullptr),
+        m_references(nullptr),
+        m_idx(idx) {
+    if (m_parent) {
+        m_parent->m_children.push_back(this);
     }
 }
 
 DDLNode::~DDLNode() {
     delete m_properties;
     delete m_value;
-    releaseReferencedNames( m_references );
+    releaseReferencedNames(m_references);
 
     delete m_dtArrayList;
-    m_dtArrayList = ddl_nullptr;
-    if( s_allocatedNodes[ m_idx ] == this ) {
-        s_allocatedNodes[ m_idx ] = ddl_nullptr;
+    m_dtArrayList = nullptr;
+    if (s_allocatedNodes[m_idx] == this) {
+        s_allocatedNodes[m_idx] = nullptr;
     }
-    for ( size_t i = 0; i<m_children.size(); i++ ){
-        delete m_children[ i ];
+    for (size_t i = 0; i < m_children.size(); i++) {
+        delete m_children[i];
     }
 }
 
-void DDLNode::attachParent( DDLNode *parent ) {
-    if( m_parent == parent ) {
+void DDLNode::attachParent(DDLNode *parent) {
+    if (m_parent == parent) {
         return;
     }
 
     m_parent = parent;
-    if( ddl_nullptr != m_parent ) {
-        m_parent->m_children.push_back( this );
+    if (nullptr != m_parent) {
+        m_parent->m_children.push_back(this);
     }
 }
 
 void DDLNode::detachParent() {
-    if( ddl_nullptr != m_parent ) {
-        DDLNodeIt it = std::find( m_parent->m_children.begin(), m_parent->m_children.end(), this );
-        if( m_parent->m_children.end() != it ) {
-            m_parent->m_children.erase( it );
+    if (nullptr != m_parent) {
+        DDLNodeIt it = std::find(m_parent->m_children.begin(), m_parent->m_children.end(), this);
+        if (m_parent->m_children.end() != it) {
+            m_parent->m_children.erase(it);
         }
-        m_parent = ddl_nullptr;
+        m_parent = nullptr;
     }
 }
 
@@ -111,7 +111,7 @@ const DDLNode::DllNodeList &DDLNode::getChildNodeList() const {
     return m_children;
 }
 
-void DDLNode::setType( const std::string &type ) {
+void DDLNode::setType(const std::string &type) {
     m_type = type;
 }
 
@@ -119,7 +119,7 @@ const std::string &DDLNode::getType() const {
     return m_type;
 }
 
-void DDLNode::setName( const std::string &name ) {
+void DDLNode::setName(const std::string &name) {
     m_name = name;
 }
 
@@ -127,8 +127,8 @@ const std::string &DDLNode::getName() const {
     return m_name;
 }
 
-void DDLNode::setProperties( Property *prop ) {
-    if(m_properties!=ddl_nullptr)
+void DDLNode::setProperties(Property *prop) {
+    if (m_properties != nullptr)
         delete m_properties;
     m_properties = prop;
 }
@@ -137,37 +137,37 @@ Property *DDLNode::getProperties() const {
     return m_properties;
 }
 
-bool DDLNode::hasProperty( const std::string &name ) {
-    const Property *prop( findPropertyByName( name ) );
-    return ( ddl_nullptr != prop );
+bool DDLNode::hasProperty(const std::string &name) {
+    const Property *prop(findPropertyByName(name));
+    return (nullptr != prop);
 }
 
 bool DDLNode::hasProperties() const {
-    return( ddl_nullptr != m_properties );
+    return (nullptr != m_properties);
 }
 
-Property *DDLNode::findPropertyByName( const std::string &name ) {
-    if( name.empty() ) {
-        return ddl_nullptr;
+Property *DDLNode::findPropertyByName(const std::string &name) {
+    if (name.empty()) {
+        return nullptr;
     }
 
-    if( ddl_nullptr == m_properties ) {
-        return ddl_nullptr;
+    if (nullptr == m_properties) {
+        return nullptr;
     }
 
-    Property *current( m_properties );
-    while( ddl_nullptr != current ) {
-        int res = strncmp( current->m_key->m_buffer, name.c_str(), name.size() );
-        if( 0 == res ) {
+    Property *current(m_properties);
+    while (nullptr != current) {
+        int res = strncmp(current->m_key->m_buffer, name.c_str(), name.size());
+        if (0 == res) {
             return current;
         }
         current = current->m_next;
     }
 
-    return ddl_nullptr;
+    return nullptr;
 }
 
-void DDLNode::setValue( Value *val ) {
+void DDLNode::setValue(Value *val) {
     m_value = val;
 }
 
@@ -175,7 +175,7 @@ Value *DDLNode::getValue() const {
     return m_value;
 }
 
-void DDLNode::setDataArrayList( DataArrayList  *dtArrayList ) {
+void DDLNode::setDataArrayList(DataArrayList *dtArrayList) {
     m_dtArrayList = dtArrayList;
 }
 
@@ -183,7 +183,7 @@ DataArrayList *DDLNode::getDataArrayList() const {
     return m_dtArrayList;
 }
 
-void DDLNode::setReferences( Reference *refs ) {
+void DDLNode::setReferences(Reference *refs) {
     m_references = refs;
 }
 
@@ -191,22 +191,32 @@ Reference *DDLNode::getReferences() const {
     return m_references;
 }
 
-void DDLNode::dump(IOStreamBase &/*stream*/) {
-    // Todo!    
+void DDLNode::dump(IOStreamBase &stream) {
+    if (!stream.isOpen()) {
+        return;
+    }
+
+    const std::string &type = this->getType();
+    stream.write("type = " + type);
+    Value::Iterator it(getValue());
+    while (it.hasNext()) {
+        Value *v = it.getNext();
+        v->dump(stream);
+    }
 }
 
-DDLNode *DDLNode::create( const std::string &type, const std::string &name, DDLNode *parent ) {
-    const size_t idx( s_allocatedNodes.size() );
-    DDLNode *node = new DDLNode( type, name, idx, parent );
-    s_allocatedNodes.push_back( node );
-    
+DDLNode *DDLNode::create(const std::string &type, const std::string &name, DDLNode *parent) {
+    const size_t idx(s_allocatedNodes.size());
+    DDLNode *node = new DDLNode(type, name, idx, parent);
+    s_allocatedNodes.push_back(node);
+
     return node;
 }
 
 void DDLNode::releaseNodes() {
-    if( s_allocatedNodes.size() > 0 ) {
-        for( DDLNodeIt it = s_allocatedNodes.begin(); it != s_allocatedNodes.end(); it++ ) {
-            if( *it ) {
+    if (s_allocatedNodes.size() > 0) {
+        for (DDLNodeIt it = s_allocatedNodes.begin(); it != s_allocatedNodes.end(); it++) {
+            if (*it) {
                 delete *it;
             }
         }
diff --git a/Engine/lib/assimp/contrib/openddlparser/code/OpenDDLCommon.cpp b/Engine/lib/assimp/contrib/openddlparser/code/OpenDDLCommon.cpp
index 5c341a780..d853efae8 100644
--- a/Engine/lib/assimp/contrib/openddlparser/code/OpenDDLCommon.cpp
+++ b/Engine/lib/assimp/contrib/openddlparser/code/OpenDDLCommon.cpp
@@ -1,7 +1,7 @@
 /*-----------------------------------------------------------------------------------------------
 The MIT License (MIT)
 
-Copyright (c) 2014-2015 Kim Kulling
+Copyright (c) 2014-2020 Kim Kulling
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
@@ -20,17 +20,17 @@ COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 -----------------------------------------------------------------------------------------------*/
-#include <openddlparser/OpenDDLCommon.h>
 #include <openddlparser/DDLNode.h>
+#include <openddlparser/OpenDDLCommon.h>
 #include <openddlparser/Value.h>
 
 BEGIN_ODDLPARSER_NS
 
-Text::Text( const char *buffer, size_t numChars )
-: m_capacity( 0 )
-, m_len( 0 )
-, m_buffer( ddl_nullptr ) {
-    set( buffer, numChars );
+Text::Text(const char *buffer, size_t numChars) :
+        m_capacity(0),
+        m_len(0),
+        m_buffer(nullptr) {
+    set(buffer, numChars);
 }
 
 Text::~Text() {
@@ -39,103 +39,98 @@ Text::~Text() {
 
 void Text::clear() {
     delete[] m_buffer;
-    m_buffer = ddl_nullptr;
+    m_buffer = nullptr;
     m_capacity = 0;
     m_len = 0;
 }
 
-void Text::set( const char *buffer, size_t numChars ) {
+void Text::set(const char *buffer, size_t numChars) {
     clear();
-    if( numChars > 0 ) {
+    if (numChars > 0) {
         m_len = numChars;
         m_capacity = m_len + 1;
-        m_buffer = new char[ m_capacity ];
-        strncpy( m_buffer, buffer, numChars );
-        m_buffer[ numChars ] = '\0';
+        m_buffer = new char[m_capacity];
+        strncpy(m_buffer, buffer, numChars);
+        m_buffer[numChars] = '\0';
     }
 }
 
-bool Text::operator == ( const std::string &name ) const {
-    if( m_len != name.size() ) {
+bool Text::operator==(const std::string &name) const {
+    if (m_len != name.size()) {
         return false;
     }
-    const int res( strncmp( m_buffer, name.c_str(), name.size() ) );
+    const int res(strncmp(m_buffer, name.c_str(), name.size()));
 
-    return ( 0 == res );
+    return (0 == res);
 }
 
-bool Text::operator == ( const Text &rhs ) const {
-    if( m_len != rhs.m_len ) {
+bool Text::operator==(const Text &rhs) const {
+    if (m_len != rhs.m_len) {
         return false;
     }
 
-    const int res( strncmp( m_buffer, rhs.m_buffer, m_len ) );
+    const int res(strncmp(m_buffer, rhs.m_buffer, m_len));
 
-    return ( 0 == res );
+    return (0 == res);
 }
 
-Name::Name( NameType type, Text *id )
-: m_type( type )
-, m_id( id ) {
+Name::Name(NameType type, Text *id) :
+        m_type(type), m_id(id) {
     // empty
 }
 
 Name::~Name() {
     delete m_id;
-    m_id = ddl_nullptr;
+    m_id = nullptr;
 }
 
-Name::Name( const Name &name ){
-    m_type=name.m_type;
-    m_id=new Text(name.m_id->m_buffer,name.m_id->m_len);
+Name::Name(const Name &name) {
+    m_type = name.m_type;
+    m_id = new Text(name.m_id->m_buffer, name.m_id->m_len);
 }
 
-
-
-    Reference::Reference()
-: m_numRefs( 0 )
-, m_referencedName( ddl_nullptr ) {
+Reference::Reference() :
+        m_numRefs(0), m_referencedName(nullptr) {
     // empty
 }
 
-Reference::Reference( size_t numrefs, Name **names )
-: m_numRefs( numrefs )
-, m_referencedName( ddl_nullptr ) {
-    if ( numrefs > 0 ) {
-        m_referencedName = new Name *[ numrefs ];
-        for ( size_t i = 0; i < numrefs; i++ ) {
-            m_referencedName[ i ] = names[i];
+Reference::Reference(size_t numrefs, Name **names) :
+        m_numRefs(numrefs), m_referencedName(nullptr) {
+    if (numrefs > 0) {
+        m_referencedName = new Name *[numrefs];
+        for (size_t i = 0; i < numrefs; i++) {
+            m_referencedName[i] = names[i];
         }
     }
 }
 Reference::Reference(const Reference &ref) {
-    m_numRefs=ref.m_numRefs;
-    if(m_numRefs!=0){
-        m_referencedName = new Name*[m_numRefs];
-        for ( size_t i = 0; i < m_numRefs; i++ ) {
+    m_numRefs = ref.m_numRefs;
+    if (m_numRefs != 0) {
+        m_referencedName = new Name *[m_numRefs];
+        for (size_t i = 0; i < m_numRefs; i++) {
             m_referencedName[i] = new Name(*ref.m_referencedName[i]);
         }
     }
 }
 
 Reference::~Reference() {
-    for( size_t i = 0; i < m_numRefs; i++ ) {
-        delete m_referencedName[ i ];
+    for (size_t i = 0; i < m_numRefs; i++) {
+        delete m_referencedName[i];
     }
     m_numRefs = 0;
-    delete [] m_referencedName;
-    m_referencedName = ddl_nullptr;
+    delete[] m_referencedName;
+    m_referencedName = nullptr;
 }
 
 size_t Reference::sizeInBytes() {
-    if ( 0 == m_numRefs ) {
+    if (0 == m_numRefs) {
         return 0;
     }
 
-    size_t size( 0 );
-    for ( size_t i = 0; i < m_numRefs; i++ ) {
-        Name *name( m_referencedName[ i ] );
-        if ( ddl_nullptr != name ) {
+    size_t size(0);
+    for (size_t i = 0; i < m_numRefs; i++) {
+        Name *name(m_referencedName[i]);
+        if (nullptr != name) {
             size += name->m_id->m_len;
         }
     }
@@ -143,60 +138,53 @@ size_t Reference::sizeInBytes() {
     return size;
 }
 
-Property::Property( Text *id )
-: m_key( id )
-, m_value( ddl_nullptr )
-, m_ref( ddl_nullptr )
-, m_next( ddl_nullptr ) {
+Property::Property(Text *id) :
+        m_key(id), m_value(nullptr), m_ref(nullptr), m_next(nullptr) {
     // empty
 }
 
 Property::~Property() {
     delete m_key;
-    if(m_value!=ddl_nullptr)
+    if (m_value != nullptr)
         delete m_value;
-    if(m_ref!=ddl_nullptr)
-        delete(m_ref);
-    if(m_next!=ddl_nullptr)
+    if (m_ref != nullptr)
+        delete (m_ref);
+    if (m_next != nullptr)
         delete m_next;
 }
 
-DataArrayList::DataArrayList()
-: m_numItems( 0 )
-, m_dataList( ddl_nullptr )
-, m_next( ddl_nullptr )
-, m_refs(ddl_nullptr)
-, m_numRefs(0){
+DataArrayList::DataArrayList() :
+        m_numItems(0), m_dataList(nullptr), m_next(nullptr), m_refs(nullptr), m_numRefs(0) {
     // empty
 }
 
 DataArrayList::~DataArrayList() {
     delete m_dataList;
-    if(m_next!=ddl_nullptr)
+    if (m_next != nullptr)
         delete m_next;
-    if(m_refs!=ddl_nullptr)
+    if (m_refs != nullptr)
         delete m_refs;
 }
 
 size_t DataArrayList::size() {
-    size_t result( 0 );
-    if ( ddl_nullptr == m_next ) {
-        if ( m_dataList != ddl_nullptr ) {
+    size_t result(0);
+    if (nullptr == m_next) {
+        if (m_dataList != nullptr) {
             result = 1;
         }
         return result;
     }
 
-    DataArrayList *n( m_next );
-    while( ddl_nullptr != n ) {
+    DataArrayList *n(m_next);
+    while (nullptr != n) {
         result++;
         n = n->m_next;
     }
     return result;
 }
 
-Context::Context()
-: m_root( ddl_nullptr ) {
+Context::Context() :
+        m_root(nullptr) {
     // empty
 }
 
@@ -206,7 +194,7 @@ Context::~Context() {
 
 void Context::clear() {
     delete m_root;
-    m_root = ddl_nullptr;
+    m_root = nullptr;
 }
 
 END_ODDLPARSER_NS
diff --git a/Engine/lib/assimp/contrib/openddlparser/code/OpenDDLExport.cpp b/Engine/lib/assimp/contrib/openddlparser/code/OpenDDLExport.cpp
index e45fb041a..d235b553b 100644
--- a/Engine/lib/assimp/contrib/openddlparser/code/OpenDDLExport.cpp
+++ b/Engine/lib/assimp/contrib/openddlparser/code/OpenDDLExport.cpp
@@ -1,7 +1,7 @@
 /*-----------------------------------------------------------------------------------------------
 The MIT License (MIT)
 
-Copyright (c) 2014-2015 Kim Kulling
+Copyright (c) 2014-2020 Kim Kulling
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
@@ -20,10 +20,10 @@ COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 -----------------------------------------------------------------------------------------------*/
-#include <openddlparser/OpenDDLExport.h>
 #include <openddlparser/DDLNode.h>
-#include <openddlparser/Value.h>
+#include <openddlparser/OpenDDLExport.h>
 #include <openddlparser/OpenDDLParser.h>
+#include <openddlparser/Value.h>
 
 #include <sstream>
 
@@ -33,9 +33,8 @@ struct DDLNodeIterator {
     const DDLNode::DllNodeList &m_childs;
     size_t m_idx;
 
-    DDLNodeIterator( const DDLNode::DllNodeList &childs ) 
-    : m_childs( childs )
-    , m_idx( 0 ) {
+    DDLNodeIterator(const DDLNode::DllNodeList &childs) :
+            m_childs(childs), m_idx(0) {
         // empty
     }
 
@@ -43,10 +42,10 @@ struct DDLNodeIterator {
         // empty
     }
 
-    bool getNext( DDLNode **node ) {
-        if( m_childs.size() > (m_idx+1) ) {
+    bool getNext(DDLNode **node) {
+        if (m_childs.size() > (m_idx + 1)) {
             m_idx++;
-            *node = m_childs[ m_idx ];
+            *node = m_childs[m_idx];
             return true;
         }
 
@@ -55,65 +54,65 @@ struct DDLNodeIterator {
 
 private:
     DDLNodeIterator() ddl_no_copy;
-    DDLNodeIterator &operator = ( const DDLNodeIterator & ) ddl_no_copy;
+    DDLNodeIterator &operator=(const DDLNodeIterator &) ddl_no_copy;
 };
 
-static void writeLineEnd( std::string &statement ) {
+static void writeLineEnd(std::string &statement) {
     statement += "\n";
 }
 
-OpenDDLExport::OpenDDLExport( IOStreamBase *stream )
-: m_stream( stream ) {
-    if (ddl_nullptr == m_stream) {
+OpenDDLExport::OpenDDLExport(IOStreamBase *stream) :
+        m_stream(stream) {
+    if (nullptr == m_stream) {
         m_stream = new IOStreamBase();
     }
 }
 
 OpenDDLExport::~OpenDDLExport() {
-    if (ddl_nullptr != m_stream) {
+    if (nullptr != m_stream) {
         m_stream->close();
     }
     delete m_stream;
 }
 
-bool OpenDDLExport::exportContext( Context *ctx, const std::string &filename ) {
-    if( ddl_nullptr == ctx ) {
+bool OpenDDLExport::exportContext(Context *ctx, const std::string &filename) {
+    if (nullptr == ctx) {
         return false;
     }
 
-    DDLNode *root( ctx->m_root );
-    if ( ddl_nullptr == root ) {
+    DDLNode *root(ctx->m_root);
+    if (nullptr == root) {
         return true;
     }
 
     if (!filename.empty()) {
-        if (!m_stream->open( filename )) {
+        if (!m_stream->open(filename)) {
             return false;
         }
     }
 
-    const bool retValue( handleNode( root ) );
-    
+    const bool retValue(handleNode(root));
+
     return retValue;
 }
 
-bool OpenDDLExport::handleNode( DDLNode *node ) {
-    if( ddl_nullptr == node ) {
+bool OpenDDLExport::handleNode(DDLNode *node) {
+    if (nullptr == node) {
         return true;
     }
 
     const DDLNode::DllNodeList &childs = node->getChildNodeList();
-    if( childs.empty() ) {
+    if (childs.empty()) {
         return true;
     }
-    DDLNode *current( ddl_nullptr );
-    DDLNodeIterator it( childs );
+    DDLNode *current(nullptr);
+    DDLNodeIterator it(childs);
     std::string statement;
-    bool success( true );
-    while( it.getNext( &current ) ) {
-        if( ddl_nullptr != current ) {
-            success |= writeNode( current, statement );
-            if( !handleNode( current ) ) {
+    bool success(true);
+    while (it.getNext(&current)) {
+        if (nullptr != current) {
+            success |= writeNode(current, statement);
+            if (!handleNode(current)) {
                 success = false;
             }
         }
@@ -122,56 +121,56 @@ bool OpenDDLExport::handleNode( DDLNode *node ) {
     return success;
 }
 
-bool OpenDDLExport::writeToStream( const std::string &statement ) {
-    if (ddl_nullptr == m_stream ) {
+bool OpenDDLExport::writeToStream(const std::string &statement) {
+    if (nullptr == m_stream) {
         return false;
     }
 
-    if ( !statement.empty()) {
-        m_stream->write( statement );
+    if (!statement.empty()) {
+        m_stream->write(statement);
     }
 
     return true;
 }
 
-bool OpenDDLExport::writeNode( DDLNode *node, std::string &statement ) {
-    writeNodeHeader( node, statement );
+bool OpenDDLExport::writeNode(DDLNode *node, std::string &statement) {
+    writeNodeHeader(node, statement);
     if (node->hasProperties()) {
-        writeProperties( node, statement );
+        writeProperties(node, statement);
     }
-    writeLineEnd( statement );
+    writeLineEnd(statement);
 
     statement = "}";
-    DataArrayList *al( node->getDataArrayList() );
-    if ( ddl_nullptr != al ) {
-        writeValueType( al->m_dataList->m_type, al->m_numItems, statement );
-        writeValueArray( al, statement );
+    DataArrayList *al(node->getDataArrayList());
+    if (nullptr != al) {
+        writeValueType(al->m_dataList->m_type, al->m_numItems, statement);
+        writeValueArray(al, statement);
     }
-    Value *v( node->getValue() );
-    if (ddl_nullptr != v ) {
-        writeValueType( v->m_type, 1, statement );
+    Value *v(node->getValue());
+    if (nullptr != v) {
+        writeValueType(v->m_type, 1, statement);
         statement = "{";
-        writeLineEnd( statement );
-        writeValue( v, statement );
+        writeLineEnd(statement);
+        writeValue(v, statement);
         statement = "}";
-        writeLineEnd( statement );
+        writeLineEnd(statement);
     }
     statement = "}";
-    writeLineEnd( statement );
+    writeLineEnd(statement);
 
-    writeToStream( statement );
+    writeToStream(statement);
 
     return true;
 }
 
-bool OpenDDLExport::writeNodeHeader( DDLNode *node, std::string &statement ) {
-    if (ddl_nullptr == node) {
+bool OpenDDLExport::writeNodeHeader(DDLNode *node, std::string &statement) {
+    if (nullptr == node) {
         return false;
     }
 
     statement += node->getType();
-    const std::string &name( node->getName() );
-    if ( !name.empty() ) {
+    const std::string &name(node->getName());
+    if (!name.empty()) {
         statement += " ";
         statement += "$";
         statement += name;
@@ -180,30 +179,30 @@ bool OpenDDLExport::writeNodeHeader( DDLNode *node, std::string &statement ) {
     return true;
 }
 
-bool OpenDDLExport::writeProperties( DDLNode *node, std::string &statement ) {
-    if ( ddl_nullptr == node ) {
+bool OpenDDLExport::writeProperties(DDLNode *node, std::string &statement) {
+    if (nullptr == node) {
         return false;
     }
 
-    Property *prop( node->getProperties() );
+    Property *prop(node->getProperties());
     // if no properties are there, return
-    if ( ddl_nullptr == prop ) {
+    if (nullptr == prop) {
         return true;
     }
 
-    if ( ddl_nullptr != prop ) {
+    if (nullptr != prop) {
         // for instance (attrib = "position", bla=2)
         statement += "(";
-        bool first( true );
-        while ( ddl_nullptr != prop ) {
+        bool first(true);
+        while (nullptr != prop) {
             if (!first) {
                 statement += ", ";
             } else {
                 first = false;
             }
-            statement += std::string( prop->m_key->m_buffer );
+            statement += std::string(prop->m_key->m_buffer);
             statement += " = ";
-            writeValue( prop->m_value, statement );
+            writeValue(prop->m_value, statement);
             prop = prop->m_next;
         }
 
@@ -213,19 +212,19 @@ bool OpenDDLExport::writeProperties( DDLNode *node, std::string &statement ) {
     return true;
 }
 
-bool OpenDDLExport::writeValueType( Value::ValueType type, size_t numItems, std::string &statement ) {
-    if ( Value::ddl_types_max == type) {
+bool OpenDDLExport::writeValueType(Value::ValueType type, size_t numItems, std::string &statement) {
+    if (Value::ValueType::ddl_types_max == type) {
         return false;
     }
 
-    const std::string typeStr( getTypeToken( type ) );
+    const std::string typeStr(getTypeToken(type));
     statement += typeStr;
     // if we have an array to write
-    if ( numItems > 1 ) {
+    if (numItems > 1) {
         statement += "[";
-        char buffer[ 256 ];
-        ::memset( buffer, '\0', 256 * sizeof( char ) );
-        sprintf( buffer, "%d", static_cast<int>( numItems ) );
+        char buffer[256];
+        ::memset(buffer, '\0', 256 * sizeof(char));
+        sprintf(buffer, "%d", static_cast<int>(numItems));
         statement += buffer;
         statement += "]";
     }
@@ -233,115 +232,93 @@ bool OpenDDLExport::writeValueType( Value::ValueType type, size_t numItems, std:
     return true;
 }
 
-bool OpenDDLExport::writeValue( Value *val, std::string &statement ) {
-    if (ddl_nullptr == val) {
+bool OpenDDLExport::writeValue(Value *val, std::string &statement) {
+    if (nullptr == val) {
         return false;
     }
 
-    switch ( val->m_type ) {
-        case Value::ddl_bool:
-            if ( true == val->getBool() ) {
+    switch (val->m_type) {
+        case Value::ValueType::ddl_bool:
+            if (true == val->getBool()) {
                 statement += "true";
             } else {
                 statement += "false";
             }
             break;
-        case Value::ddl_int8: 
-            {
-                std::stringstream stream;
-                const int i = static_cast<int>( val->getInt8() );
-                stream << i;
-                statement += stream.str();
-            }
+        case Value::ValueType::ddl_int8 : {
+            std::stringstream stream;
+            const int i = static_cast<int>(val->getInt8());
+            stream << i;
+            statement += stream.str();
+        } break;
+        case Value::ValueType::ddl_int16: {
+            std::stringstream stream;
+            char buffer[256];
+            ::memset(buffer, '\0', 256 * sizeof(char));
+            sprintf(buffer, "%d", val->getInt16());
+            statement += buffer;
+        } break;
+        case Value::ValueType::ddl_int32: {
+            std::stringstream stream;
+            char buffer[256];
+            ::memset(buffer, '\0', 256 * sizeof(char));
+            const int i = static_cast<int>(val->getInt32());
+            sprintf(buffer, "%d", i);
+            statement += buffer;
+        } break;
+        case Value::ValueType::ddl_int64: {
+            std::stringstream stream;
+            const int i = static_cast<int>(val->getInt64());
+            stream << i;
+            statement += stream.str();
+        } break;
+        case Value::ValueType::ddl_unsigned_int8: {
+            std::stringstream stream;
+            const int i = static_cast<unsigned int>(val->getUnsignedInt8());
+            stream << i;
+            statement += stream.str();
+        } break;
+        case Value::ValueType::ddl_unsigned_int16: {
+            std::stringstream stream;
+            const int i = static_cast<unsigned int>(val->getUnsignedInt16());
+            stream << i;
+            statement += stream.str();
+        } break;
+        case Value::ValueType::ddl_unsigned_int32: {
+            std::stringstream stream;
+            const int i = static_cast<unsigned int>(val->getUnsignedInt32());
+            stream << i;
+            statement += stream.str();
+        } break;
+        case Value::ValueType::ddl_unsigned_int64: {
+            std::stringstream stream;
+            const int i = static_cast<unsigned int>(val->getUnsignedInt64());
+            stream << i;
+            statement += stream.str();
+        } break;
+        case Value::ValueType::ddl_half:
             break;
-        case Value::ddl_int16:
-            {
-                std::stringstream stream;
-                char buffer[ 256 ];
-                ::memset( buffer, '\0', 256 * sizeof( char ) );
-                sprintf( buffer, "%d", val->getInt16() );
-                statement += buffer;
-        }
+        case Value::ValueType::ddl_float: {
+            std::stringstream stream;
+            stream << val->getFloat();
+            statement += stream.str();
+        } break;
+        case Value::ValueType::ddl_double: {
+            std::stringstream stream;
+            stream << val->getDouble();
+            statement += stream.str();
+        } break;
+        case Value::ValueType::ddl_string: {
+            std::stringstream stream;
+            stream << val->getString();
+            statement += "\"";
+            statement += stream.str();
+            statement += "\"";
+        } break;
+        case Value::ValueType::ddl_ref:
             break;
-        case Value::ddl_int32:
-            {
-                std::stringstream stream;
-                char buffer[ 256 ];
-                ::memset( buffer, '\0', 256 * sizeof( char ) );
-                const int i = static_cast< int >( val->getInt32() );
-                sprintf( buffer, "%d", i );
-                statement += buffer;
-            }
-            break;
-        case Value::ddl_int64:
-            {
-                std::stringstream stream;
-                const int i = static_cast< int >( val->getInt64() );
-                stream << i;
-                statement += stream.str();
-            }
-            break;
-        case Value::ddl_unsigned_int8:
-            {
-                std::stringstream stream;
-                const int i = static_cast< unsigned int >( val->getUnsignedInt8() );
-                stream << i;
-                statement += stream.str();
-            }
-            break;
-        case Value::ddl_unsigned_int16:
-            {
-                std::stringstream stream;
-                const int i = static_cast< unsigned int >( val->getUnsignedInt16() );
-                stream << i;
-                statement += stream.str();
-            }
-            break;
-        case Value::ddl_unsigned_int32:
-            {
-                std::stringstream stream;
-                const int i = static_cast< unsigned int >( val->getUnsignedInt32() );
-                stream << i;
-                statement += stream.str();
-            }
-            break;
-        case Value::ddl_unsigned_int64:
-            {
-                std::stringstream stream;
-                const int i = static_cast< unsigned int >( val->getUnsignedInt64() );
-                stream << i;
-                statement += stream.str();
-            }
-            break;
-        case Value::ddl_half:
-            break;
-        case Value::ddl_float:
-            {
-                std::stringstream stream;
-                stream << val->getFloat();
-                statement += stream.str();
-            }
-            break;
-        case Value::ddl_double:
-            {
-                std::stringstream stream;
-                stream << val->getDouble();
-                statement += stream.str();
-            }
-            break;
-        case Value::ddl_string:
-            {
-                std::stringstream stream;
-                stream << val->getString();
-                statement += "\"";
-                statement += stream.str();
-                statement += "\"";
-             }
-            break;
-        case Value::ddl_ref:
-            break;
-        case Value::ddl_none:
-        case Value::ddl_types_max:
+        case Value::ValueType::ddl_none:
+        case Value::ValueType::ddl_types_max:
         default:
             break;
     }
@@ -349,8 +326,8 @@ bool OpenDDLExport::writeValue( Value *val, std::string &statement ) {
     return true;
 }
 
-bool OpenDDLExport::writeValueArray( DataArrayList *al, std::string &statement ) {
-    if (ddl_nullptr == al) {
+bool OpenDDLExport::writeValueArray(DataArrayList *al, std::string &statement) {
+    if (nullptr == al) {
         return false;
     }
 
@@ -358,17 +335,18 @@ bool OpenDDLExport::writeValueArray( DataArrayList *al, std::string &statement )
         return true;
     }
 
-    DataArrayList *nextDataArrayList = al ;
-    while (ddl_nullptr != nextDataArrayList) {
-        if (ddl_nullptr != nextDataArrayList) {
+    DataArrayList *nextDataArrayList = al;
+    Value *nextValue(nextDataArrayList->m_dataList);
+    while (nullptr != nextDataArrayList) {
+        if (nullptr != nextDataArrayList) {
             statement += "{ ";
-            Value *nextValue( nextDataArrayList->m_dataList );
-            size_t idx( 0 );
-            while (ddl_nullptr != nextValue) {
+            nextValue = nextDataArrayList->m_dataList;
+            size_t idx(0);
+            while (nullptr != nextValue) {
                 if (idx > 0) {
                     statement += ", ";
                 }
-                writeValue( nextValue, statement );
+                writeValue(nextValue, statement);
                 nextValue = nextValue->m_next;
                 idx++;
             }
@@ -381,4 +359,3 @@ bool OpenDDLExport::writeValueArray( DataArrayList *al, std::string &statement )
 }
 
 END_ODDLPARSER_NS
-
diff --git a/Engine/lib/assimp/contrib/openddlparser/code/OpenDDLParser.cpp b/Engine/lib/assimp/contrib/openddlparser/code/OpenDDLParser.cpp
index 91831ba27..e2bef97a7 100644
--- a/Engine/lib/assimp/contrib/openddlparser/code/OpenDDLParser.cpp
+++ b/Engine/lib/assimp/contrib/openddlparser/code/OpenDDLParser.cpp
@@ -1,7 +1,7 @@
 /*-----------------------------------------------------------------------------------------------
 The MIT License (MIT)
 
-Copyright (c) 2014-2015 Kim Kulling
+Copyright (c) 2014-2020 Kim Kulling
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
@@ -20,135 +20,111 @@ COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 -----------------------------------------------------------------------------------------------*/
-#include <openddlparser/OpenDDLParser.h>
 #include <openddlparser/OpenDDLExport.h>
+#include <openddlparser/OpenDDLParser.h>
 
+#include <math.h>
+#include <algorithm>
 #include <cassert>
 #include <iostream>
 #include <sstream>
-#include <algorithm>
-#include <memory>
-#include <math.h>
 
 #ifdef _WIN32
-#  include <windows.h>
+#include <windows.h>
 #endif // _WIN32
 
-
 BEGIN_ODDLPARSER_NS
 
 static const char *Version = "0.4.0";
 
 namespace Grammar {
-    static const char *OpenBracketToken   = "{";
-    static const char *CloseBracketToken  = "}";
-    static const char *OpenPropertyToken  = "(";
-    static const char *ClosePropertyToken = ")";
-    static const char *OpenArrayToken     = "[";
-    static const char *CloseArrayToken    = "]";
-    static const char *BoolTrue           = "true";
-    static const char *BoolFalse          = "false";
-    static const char *CommaSeparator     = ",";
 
-    static const char *PrimitiveTypeToken[ Value::ddl_types_max ] = {
-        "bool",
-        "int8",
-        "int16",
-        "int32",
-        "int64",
-        "unsigned_int8",
-        "unsigned_int16",
-        "unsigned_int32",
-        "unsigned_int64",
-        "half",
-        "float",
-        "double",
-        "string",
-        "ref"
-    };
+static const char *OpenBracketToken = "{";
+static const char *CloseBracketToken = "}";
+static const char *OpenPropertyToken = "(";
+static const char *ClosePropertyToken = ")";
+static const char *OpenArrayToken = "[";
+static const char *CloseArrayToken = "]";
+static const char *BoolTrue = "true";
+static const char *BoolFalse = "false";
+static const char *CommaSeparator = ",";
+
+static const char *PrimitiveTypeToken[(size_t)Value::ValueType::ddl_types_max] = {
+    "bool",
+    "int8",
+    "int16",
+    "int32",
+    "int64",
+    "unsigned_int8",
+    "unsigned_int16",
+    "unsigned_int32",
+    "unsigned_int64",
+    "half",
+    "float",
+    "double",
+    "string",
+    "ref"
+};
 } // Namespace Grammar
 
-const char *getTypeToken( Value::ValueType  type ) {
-    return Grammar::PrimitiveTypeToken[ type ];
+const char *getTypeToken(Value::ValueType type) {
+    return Grammar::PrimitiveTypeToken[(size_t)type];
 }
 
-static void logInvalidTokenError( char *in, const std::string &exp, OpenDDLParser::logCallback callback ) {
-    std::stringstream stream;
-    stream << "Invalid token \"" << *in << "\"" << " expected \"" << exp << "\"" << std::endl;
-    std::string full( in );
-    std::string part( full.substr( 0, 50 ) );
-    stream << part;
-    callback( ddl_error_msg, stream.str() );
-}
-
-static bool isIntegerType( Value::ValueType integerType ) {
-    if( integerType != Value::ddl_int8 && integerType != Value::ddl_int16 &&
-            integerType != Value::ddl_int32 && integerType != Value::ddl_int64 ) {
-        return false;
+static void logInvalidTokenError(char *in, const std::string &exp, OpenDDLParser::logCallback callback) {
+    if (callback) {
+        std::string full(in);
+        std::string part(full.substr(0, 50));
+        std::stringstream stream;
+        stream << "Invalid token \"" << *in << "\" "
+               << "(expected \"" << exp << "\") "
+               << "in: \"" << part << "\"";
+        callback(ddl_error_msg, stream.str());
     }
-    
-    return true;
 }
 
-static bool isUnsignedIntegerType( Value::ValueType integerType ) {
-    if( integerType != Value::ddl_unsigned_int8 && integerType != Value::ddl_unsigned_int16 &&
-            integerType != Value::ddl_unsigned_int32 && integerType != Value::ddl_unsigned_int64 ) {
+static bool isIntegerType(Value::ValueType integerType) {
+    if (integerType != Value::ValueType::ddl_int8 && integerType != Value::ValueType::ddl_int16 &&
+            integerType != Value::ValueType::ddl_int32 && integerType != Value::ValueType::ddl_int64) {
         return false;
     }
 
     return true;
 }
 
-static DDLNode *createDDLNode( Text *id, OpenDDLParser *parser ) {
-    // Basic checks
-    if( ddl_nullptr == id || ddl_nullptr == parser ) {
-        return ddl_nullptr;
-    }
-    
-    // If the buffer is empty ( an empty node ) return nullptr
-    if ( ddl_nullptr == id->m_buffer ) {
-        return ddl_nullptr;
+static bool isUnsignedIntegerType(Value::ValueType integerType) {
+    if (integerType != Value::ValueType::ddl_unsigned_int8 && integerType != Value::ValueType::ddl_unsigned_int16 &&
+            integerType != Value::ValueType::ddl_unsigned_int32 && integerType != Value::ValueType::ddl_unsigned_int64) {
+        return false;
     }
 
-    const std::string type( id->m_buffer );
-    DDLNode *parent( parser->top() );
-    DDLNode *node = DDLNode::create( type, "", parent );
-    
+    return true;
+}
+
+static DDLNode *createDDLNode(Text *id, OpenDDLParser *parser) {
+    if (nullptr == id || nullptr == parser || id->m_buffer == nullptr) {
+        return nullptr;
+    }
+
+    const std::string type(id->m_buffer);
+    DDLNode *parent(parser->top());
+    DDLNode *node = DDLNode::create(type, "", parent);
+
     return node;
 }
 
-static void logMessage( LogSeverity severity, const std::string &msg ) {
-    std::string log;
-    if( ddl_debug_msg == severity ) {
-        log += "Debug:";
-    } else if( ddl_info_msg == severity ) {
-        log += "Info :";
-    } else if( ddl_warn_msg == severity ) {
-        log += "Warn :";
-    } else if( ddl_error_msg == severity ) {
-        log += "Error:";
-    } else {
-        log += "None :";
-    }
-
-    log += msg;
-    std::cout << log;
-}
-
-OpenDDLParser::OpenDDLParser()
-: m_logCallback( logMessage )
-, m_buffer()
-, m_stack()
-, m_context( ddl_nullptr ) {
+OpenDDLParser::OpenDDLParser() :
+        m_logCallback(nullptr),
+        m_buffer(),
+        m_stack(),
+        m_context(nullptr) {
     // empty
 }
 
-OpenDDLParser::OpenDDLParser( const char *buffer, size_t len )
-: m_logCallback( &logMessage )
-, m_buffer()
-, m_context( ddl_nullptr ) {
-    if( 0 != len ) {
-        setBuffer( buffer, len );
+OpenDDLParser::OpenDDLParser(const char *buffer, size_t len) :
+        m_logCallback(nullptr), m_buffer(), m_context(nullptr) {
+    if (0 != len) {
+        setBuffer(buffer, len);
     }
 }
 
@@ -156,42 +132,55 @@ OpenDDLParser::~OpenDDLParser() {
     clear();
 }
 
-void OpenDDLParser::setLogCallback( logCallback callback ) {
-    if( ddl_nullptr != callback ) {
-        // install user-specific log callback
-        m_logCallback = callback;
-    } else {
-        // install default log callback
-        m_logCallback = &logMessage;
+void OpenDDLParser::logToStream(FILE *f, LogSeverity severity, const std::string &message) {
+    if (f) {
+        const char *tag = "none";
+        switch (severity) {
+        case ddl_debug_msg: tag = "debug"; break;
+        case ddl_info_msg:  tag = "info";  break;
+        case ddl_warn_msg:  tag = "warn";  break;
+        case ddl_error_msg: tag = "error"; break;
+        }
+        fprintf(f, "OpenDDLParser: (%5s) %s\n", tag, message.c_str());
     }
 }
 
+OpenDDLParser::logCallback OpenDDLParser::StdLogCallback (FILE *destination) {
+    using namespace std::placeholders;
+    return std::bind(logToStream, destination ? destination : stderr, _1, _2);
+}
+
+void OpenDDLParser::setLogCallback(logCallback callback) {
+    // install user-specific log callback; null = no log callback
+    m_logCallback = callback;
+}
+
 OpenDDLParser::logCallback OpenDDLParser::getLogCallback() const {
     return m_logCallback;
 }
 
-void OpenDDLParser::setBuffer( const char *buffer, size_t len ) {
+void OpenDDLParser::setBuffer(const char *buffer, size_t len) {
     clear();
-    if( 0 == len ) {
+    if (0 == len) {
         return;
     }
 
-    m_buffer.resize( len );
-    ::memcpy(&m_buffer[ 0 ], buffer, len );
+    m_buffer.resize(len);
+    ::memcpy(&m_buffer[0], buffer, len);
 }
 
-void OpenDDLParser::setBuffer( const std::vector<char> &buffer ) {
+void OpenDDLParser::setBuffer(const std::vector<char> &buffer) {
     clear();
-    m_buffer.resize( buffer.size() );
-    std::copy( buffer.begin(), buffer.end(), m_buffer.begin() );
+    m_buffer.resize(buffer.size());
+    std::copy(buffer.begin(), buffer.end(), m_buffer.begin());
 }
 
 const char *OpenDDLParser::getBuffer() const {
-    if( m_buffer.empty() ) {
-        return ddl_nullptr;
+    if (m_buffer.empty()) {
+        return nullptr;
     }
 
-    return &m_buffer[ 0 ];
+    return &m_buffer[0];
 }
 
 size_t OpenDDLParser::getBufferSize() const {
@@ -199,266 +188,280 @@ size_t OpenDDLParser::getBufferSize() const {
 }
 
 void OpenDDLParser::clear() {
-    m_buffer.resize( 0 );
-    if( ddl_nullptr != m_context ) {
-        delete m_context;
-        m_context=ddl_nullptr;
-    }
-
-//    DDLNode::releaseNodes();
+    m_buffer.resize(0);
+    delete m_context;
+    m_context = nullptr;
 }
 
-bool OpenDDLParser::parse() {
-    if( m_buffer.empty() ) {
+bool OpenDDLParser::validate() {
+    if (m_buffer.empty()) {
+        return true;
+    }
+
+    if (!isCharacter(m_buffer[0]) && !isNumeric(m_buffer[0])) {
         return false;
     }
 
-    normalizeBuffer( m_buffer );
+    return true;
+}
+
+bool OpenDDLParser::parse() {
+    if (m_buffer.empty()) {
+        return false;
+    }
+
+    normalizeBuffer(m_buffer);
+    if (!validate()) {
+        return false;
+    }
 
     m_context = new Context;
-    m_context->m_root = DDLNode::create( "root", "", ddl_nullptr );
-    pushNode( m_context->m_root );
+    m_context->m_root = DDLNode::create("root", "", nullptr);
+    pushNode(m_context->m_root);
 
     // do the main parsing
-    char *current( &m_buffer[ 0 ] );
-    char *end( &m_buffer[m_buffer.size() - 1 ] + 1 );
-    size_t pos( current - &m_buffer[ 0 ] );
-    while( pos < m_buffer.size() ) {
-        current = parseNextNode( current, end );
-        if ( current == ddl_nullptr ) {
+    char *current(&m_buffer[0]);
+    char *end(&m_buffer[m_buffer.size() - 1] + 1);
+    size_t pos(current - &m_buffer[0]);
+    while (pos < m_buffer.size()) {
+        current = parseNextNode(current, end);
+        if (current == nullptr) {
             return false;
         }
-        pos = current - &m_buffer[ 0 ];
+        pos = current - &m_buffer[0];
     }
     return true;
 }
 
-bool OpenDDLParser::exportContext( Context *ctx, const std::string &filename ) {
-    if( ddl_nullptr == ctx ) {
+bool OpenDDLParser::exportContext(Context *ctx, const std::string &filename) {
+    if (nullptr == ctx) {
         return false;
     }
 
     OpenDDLExport myExporter;
-    return myExporter.exportContext( ctx, filename );
+    return myExporter.exportContext(ctx, filename);
 }
 
-char *OpenDDLParser::parseNextNode( char *in, char *end ) {
-    in = parseHeader( in, end );
-    in = parseStructure( in, end );
+char *OpenDDLParser::parseNextNode(char *in, char *end) {
+    in = parseHeader(in, end);
+    in = parseStructure(in, end);
 
     return in;
 }
 
 #ifdef DEBUG_HEADER_NAME
-static void dumpId( Identifier *id ) {
-    if( ddl_nullptr != id ) {
-        if ( ddl_nullptr != id->m_text.m_buffer ) {
+static void dumpId(Identifier *id) {
+    if (nullptr != id) {
+        if (nullptr != id->m_text.m_buffer) {
             std::cout << id->m_text.m_buffer << std::endl;
-	    }
+        }
     }
 }
 #endif
 
-char *OpenDDLParser::parseHeader( char *in, char *end ) {
-    if( ddl_nullptr == in || in == end ) {
+char *OpenDDLParser::parseHeader(char *in, char *end) {
+    if (nullptr == in || in == end) {
         return in;
     }
 
-    Text *id( ddl_nullptr );
-    in = OpenDDLParser::parseIdentifier( in, end, &id );
+    Text *id(nullptr);
+    in = OpenDDLParser::parseIdentifier(in, end, &id);
 
 #ifdef DEBUG_HEADER_NAME
-    dumpId( id );
+    dumpId(id);
 #endif // DEBUG_HEADER_NAME
 
-    in = lookForNextToken( in, end );
-    if( ddl_nullptr != id ) {
+    in = lookForNextToken(in, end);
+    if (nullptr != id) {
         // store the node
-        DDLNode *node( createDDLNode( id, this ) );
-        if( ddl_nullptr != node ) {
-            pushNode( node );
+        DDLNode *node(createDDLNode(id, this));
+        if (nullptr != node) {
+            pushNode(node);
         } else {
             std::cerr << "nullptr returned by creating DDLNode." << std::endl;
         }
         delete id;
 
-		Name *name_(ddl_nullptr);
-		in = OpenDDLParser::parseName(in, end, &name_);
-		std::unique_ptr<Name> name(name_);
-        if( ddl_nullptr != name && ddl_nullptr != node ) {
-            const std::string nodeName( name->m_id->m_buffer );
-            node->setName( nodeName );
+        Name *name(nullptr);
+        in = OpenDDLParser::parseName(in, end, &name);
+        if (nullptr != name && nullptr != node && nullptr != name->m_id->m_buffer) {
+            const std::string nodeName(name->m_id->m_buffer);
+            node->setName(nodeName);
+            delete name;
         }
 
+        Property *first(nullptr);
+        in = lookForNextToken(in, end);
+        if (in != end && *in == Grammar::OpenPropertyToken[0]) {
+            in++;
+            Property *prop(nullptr), *prev(nullptr);
+            while (in != end && *in != Grammar::ClosePropertyToken[0]) {
+                in = OpenDDLParser::parseProperty(in, end, &prop);
+                in = lookForNextToken(in, end);
+                if(in == end) {
+                    break;
+                }
 
-		std::unique_ptr<Property> first;
-		in = lookForNextToken(in, end);
-		if (*in == Grammar::OpenPropertyToken[0]) {
-			in++;
-			std::unique_ptr<Property> prop, prev;
-			while (*in != Grammar::ClosePropertyToken[0] && in != end) {
-				Property *prop_(ddl_nullptr);
-				in = OpenDDLParser::parseProperty(in, end, &prop_);
-				prop.reset(prop_);
-				in = lookForNextToken(in, end);
+                if (*in != Grammar::CommaSeparator[0] && *in != Grammar::ClosePropertyToken[0]) {
+                    logInvalidTokenError(in, Grammar::ClosePropertyToken, m_logCallback);
+                    return nullptr;
+                }
 
-				if (*in != Grammar::CommaSeparator[0] && *in != Grammar::ClosePropertyToken[0]) {
-					logInvalidTokenError(in, Grammar::ClosePropertyToken, m_logCallback);
-					return ddl_nullptr;
-				}
+                if (nullptr != prop && *in != Grammar::CommaSeparator[0]) {
+                    if (nullptr == first) {
+                        first = prop;
+                    }
+                    if (nullptr != prev) {
+                        prev->m_next = prop;
+                    }
+                    prev = prop;
+                }
+            }
+            if(in != end) {
+                ++in;
+            }
+        }
 
-				if (ddl_nullptr != prop && *in != Grammar::CommaSeparator[0]) {
-					if (ddl_nullptr == first) {
-						first = std::move(prop);
-					}
-					if (ddl_nullptr != prev) {
-						prev->m_next = prop.release();
-					}
-					prev = std::move(prop);
-				}
-			}
-			++in;
-		}
-
-		// set the properties
-		if (first && ddl_nullptr != node) {
-			node->setProperties(first.release());
-		}
+        // set the properties
+        if (nullptr != first && nullptr != node) {
+            node->setProperties(first);
+        }
     }
 
     return in;
 }
 
-char *OpenDDLParser::parseStructure( char *in, char *end ) {
-    if( ddl_nullptr == in || in == end ) {
+char *OpenDDLParser::parseStructure(char *in, char *end) {
+    if (nullptr == in || in == end) {
         return in;
     }
 
-    bool error( false );
-    in = lookForNextToken( in, end );
-    if( *in == *Grammar::OpenBracketToken) {
+    bool error(false);
+    in = lookForNextToken(in, end);
+    if (*in == *Grammar::OpenBracketToken) {
         // loop over all children ( data and nodes )
         do {
-            in = parseStructureBody( in, end, error );
-            if(in == ddl_nullptr){
-                return ddl_nullptr;
+            in = parseStructureBody(in, end, error);
+            if (in == nullptr) {
+                return nullptr;
             }
-        } while ( *in != *Grammar::CloseBracketToken);
+        } while (*in != *Grammar::CloseBracketToken);
         ++in;
     } else {
         ++in;
-        logInvalidTokenError( in, std::string( Grammar::OpenBracketToken ), m_logCallback );
-        return ddl_nullptr;
+        logInvalidTokenError(in, std::string(Grammar::OpenBracketToken), m_logCallback);
+        error = true;
+        return nullptr;
     }
-    in = lookForNextToken( in, end );
+    in = lookForNextToken(in, end);
 
     // pop node from stack after successful parsing
-    if( !error ) {
+    if (!error) {
         popNode();
     }
 
     return in;
 }
 
-static void setNodeValues( DDLNode *currentNode, Value *values ) {
-    if( ddl_nullptr != values ){
-        if( ddl_nullptr != currentNode ) {
-            currentNode->setValue( values );
+static void setNodeValues(DDLNode *currentNode, Value *values) {
+    if (nullptr != values) {
+        if (nullptr != currentNode) {
+            currentNode->setValue(values);
         }
     }
 }
 
-static void setNodeReferences( DDLNode *currentNode, Reference *refs ) {
-    if( ddl_nullptr != refs ) {
-        if( ddl_nullptr != currentNode ) {
-            currentNode->setReferences( refs );
+static void setNodeReferences(DDLNode *currentNode, Reference *refs) {
+    if (nullptr != refs) {
+        if (nullptr != currentNode) {
+            currentNode->setReferences(refs);
         }
     }
 }
 
-static void setNodeDataArrayList( DDLNode *currentNode, DataArrayList *dtArrayList ) {
-    if( ddl_nullptr != dtArrayList ) {
-        if( ddl_nullptr != currentNode ) {
-            currentNode->setDataArrayList( dtArrayList );
+static void setNodeDataArrayList(DDLNode *currentNode, DataArrayList *dtArrayList) {
+    if (nullptr != dtArrayList) {
+        if (nullptr != currentNode) {
+            currentNode->setDataArrayList(dtArrayList);
         }
     }
 }
 
-char *OpenDDLParser::parseStructureBody( char *in, char *end, bool &error ) {
-    if( !isNumeric( *in ) && !isCharacter( *in ) ) {
+char *OpenDDLParser::parseStructureBody(char *in, char *end, bool &error) {
+    if (!isNumeric(*in) && !isCharacter(*in)) {
         ++in;
     }
 
-    in = lookForNextToken( in, end );
-    Value::ValueType type( Value::ddl_none );
-    size_t arrayLen( 0 );
-    in = OpenDDLParser::parsePrimitiveDataType( in, end, type, arrayLen );
-    if( Value::ddl_none != type ) {
+    in = lookForNextToken(in, end);
+    Value::ValueType type(Value::ValueType::ddl_none);
+    size_t arrayLen(0);
+    in = OpenDDLParser::parsePrimitiveDataType(in, end, type, arrayLen);
+    if (Value::ValueType::ddl_none != type) {
         // parse a primitive data type
-        in = lookForNextToken( in, end );
-        if( *in == Grammar::OpenBracketToken[ 0 ] ) {
-            Reference *refs( ddl_nullptr );
-            DataArrayList *dtArrayList( ddl_nullptr );
-            Value *values( ddl_nullptr );
-            if( 1 == arrayLen ) {
-                size_t numRefs( 0 ), numValues( 0 );
-                in = parseDataList( in, end, type, &values, numValues, &refs, numRefs );
-                setNodeValues( top(), values );
-                setNodeReferences( top(), refs );
-            } else if( arrayLen > 1 ) {
-                in = parseDataArrayList( in, end, type, &dtArrayList );
-                setNodeDataArrayList( top(), dtArrayList );
+        in = lookForNextToken(in, end);
+        if (*in == Grammar::OpenBracketToken[0]) {
+            Reference *refs(nullptr);
+            DataArrayList *dtArrayList(nullptr);
+            Value *values(nullptr);
+            if (1 == arrayLen) {
+                size_t numRefs(0), numValues(0);
+                in = parseDataList(in, end, type, &values, numValues, &refs, numRefs);
+                setNodeValues(top(), values);
+                setNodeReferences(top(), refs);
+            } else if (arrayLen > 1) {
+                in = parseDataArrayList(in, end, type, &dtArrayList);
+                setNodeDataArrayList(top(), dtArrayList);
             } else {
                 std::cerr << "0 for array is invalid." << std::endl;
                 error = true;
             }
         }
 
-        in = lookForNextToken( in, end );
-        if( *in != '}' ) {
-            logInvalidTokenError( in, std::string( Grammar::CloseBracketToken ), m_logCallback );
-            return ddl_nullptr;
+        in = lookForNextToken(in, end);
+        if (*in != '}') {
+            logInvalidTokenError(in, std::string(Grammar::CloseBracketToken), m_logCallback);
+            return nullptr;
         } else {
             //in++;
         }
     } else {
         // parse a complex data type
-        in = parseNextNode( in, end );
+        in = parseNextNode(in, end);
     }
 
     return in;
 }
 
-void OpenDDLParser::pushNode( DDLNode *node ) {
-    if( ddl_nullptr == node ) {
+void OpenDDLParser::pushNode(DDLNode *node) {
+    if (nullptr == node) {
         return;
     }
 
-    m_stack.push_back( node );
+    m_stack.push_back(node);
 }
 
 DDLNode *OpenDDLParser::popNode() {
-    if( m_stack.empty() ) {
-        return ddl_nullptr;
+    if (m_stack.empty()) {
+        return nullptr;
     }
 
-    DDLNode *topNode( top() );
+    DDLNode *topNode(top());
     m_stack.pop_back();
     return topNode;
 }
 
 DDLNode *OpenDDLParser::top() {
-    if( m_stack.empty() ) {
-        return ddl_nullptr;
+    if (m_stack.empty()) {
+        return nullptr;
     }
 
-    DDLNode *top( m_stack.back() );
+    DDLNode *top(m_stack.back());
     return top;
 }
 
 DDLNode *OpenDDLParser::getRoot() const {
-    if( ddl_nullptr == m_context ) {
-        return ddl_nullptr;
+    if (nullptr == m_context) {
+        return nullptr;
     }
 
     return m_context->m_root;
@@ -468,31 +471,30 @@ Context *OpenDDLParser::getContext() const {
     return m_context;
 }
 
-void OpenDDLParser::normalizeBuffer( std::vector<char> &buffer) {
-    if( buffer.empty() ) {
+void OpenDDLParser::normalizeBuffer(std::vector<char> &buffer) {
+    if (buffer.empty()) {
         return;
     }
 
     std::vector<char> newBuffer;
-    const size_t len( buffer.size() );
-    char *end( &buffer[ len-1 ] + 1 );
-    for( size_t readIdx = 0; readIdx<len; ++readIdx ) {
-        char *c( &buffer[readIdx] );
+    const size_t len(buffer.size());
+    char *end(&buffer[len - 1] + 1);
+    for (size_t readIdx = 0; readIdx < len; ++readIdx) {
+        char *c(&buffer[readIdx]);
         // check for a comment
         if (isCommentOpenTag(c, end)) {
             ++readIdx;
-            while (!isCommentCloseTag(&buffer[readIdx], end)) {
+            while (readIdx < len && !isCommentCloseTag(&buffer[readIdx], end)) {
                 ++readIdx;
             }
             ++readIdx;
-            ++readIdx;
-        } else if( !isComment<char>( c, end ) && !isNewLine( *c ) ) {
-            newBuffer.push_back( buffer[ readIdx ] );
+        } else if (!isComment<char>(c, end) && !isNewLine(*c)) {
+            newBuffer.push_back(buffer[readIdx]);
         } else {
-            if( isComment<char>( c, end ) ) {
+            if (isComment<char>(c, end)) {
                 ++readIdx;
                 // skip the comment and the rest of the line
-                while( !isEndofLine( buffer[ readIdx ] ) ) {
+                while (readIdx < len && !isEndofLine(buffer[readIdx])) {
                     ++readIdx;
                 }
             }
@@ -501,29 +503,29 @@ void OpenDDLParser::normalizeBuffer( std::vector<char> &buffer) {
     buffer = newBuffer;
 }
 
-char *OpenDDLParser::parseName( char *in, char *end, Name **name ) {
-    *name = ddl_nullptr;
-    if( ddl_nullptr == in || in == end ) {
+char *OpenDDLParser::parseName(char *in, char *end, Name **name) {
+    *name = nullptr;
+    if (nullptr == in || in == end) {
         return in;
     }
 
     // ignore blanks
-    in = lookForNextToken( in, end );
-    if( *in != '$' && *in != '%' ) {
+    in = lookForNextToken(in, end);
+    if (*in != '$' && *in != '%') {
         return in;
     }
 
-    NameType ntype( GlobalName );
-    if( *in == '%' ) {
+    NameType ntype(GlobalName);
+    if (*in == '%') {
         ntype = LocalName;
     }
     in++;
-    Name *currentName( ddl_nullptr );
-    Text *id( ddl_nullptr );
-    in = parseIdentifier( in, end, &id );
-    if( id ) {
-        currentName = new Name( ntype, id );
-        if( currentName ) {
+    Name *currentName(nullptr);
+    Text *id(nullptr);
+    in = parseIdentifier(in, end, &id);
+    if (id) {
+        currentName = new Name(ntype, id);
+        if (currentName) {
             *name = currentName;
         }
     }
@@ -531,70 +533,72 @@ char *OpenDDLParser::parseName( char *in, char *end, Name **name ) {
     return in;
 }
 
-char *OpenDDLParser::parseIdentifier( char *in, char *end, Text **id ) {
-    *id = ddl_nullptr;
-    if( ddl_nullptr == in || in == end ) {
+char *OpenDDLParser::parseIdentifier(char *in, char *end, Text **id) {
+    *id = nullptr;
+    if (nullptr == in || in == end) {
         return in;
     }
 
     // ignore blanks
-    in = lookForNextToken( in, end );
+    in = lookForNextToken(in, end);
+    if (in == end) {
+        return in;
+    }
 
     // staring with a number is forbidden
-    if( isNumeric<const char>( *in ) ) {
+    if (isNumeric<const char>(*in)) {
         return in;
     }
 
     // get size of id
-    size_t idLen( 0 );
-    char *start( in );
-    while( !isSeparator( *in ) && 
-            !isNewLine( *in ) && ( in != end ) && 
-            *in != Grammar::OpenPropertyToken[ 0 ] &&
-            *in != Grammar::ClosePropertyToken[ 0 ] && 
-            *in != '$' ) {
+    size_t idLen(0);
+    char *start(in);
+    while ((in != end) && !isSeparator(*in) && !isNewLine(*in) &&
+            *in != Grammar::OpenPropertyToken[0] &&
+            *in != Grammar::ClosePropertyToken[0] &&
+            *in != '$') {
         ++in;
         ++idLen;
     }
 
-    const size_t len( idLen );
-    *id = new Text( start, len );
+    const size_t len(idLen);
+    *id = new Text(start, len);
 
     return in;
 }
 
-char *OpenDDLParser::parsePrimitiveDataType( char *in, char *end, Value::ValueType &type, size_t &len ) {
-    type = Value::ddl_none;
+char *OpenDDLParser::parsePrimitiveDataType(char *in, char *end, Value::ValueType &type, size_t &len) {
+    type = Value::ValueType::ddl_none;
     len = 0;
-    if( ddl_nullptr == in || in == end ) {
+    if (nullptr == in || in == end) {
         return in;
     }
 
-    size_t prim_len( 0 );
-    for( unsigned int i = 0; i < Value::ddl_types_max; i++ ) {
-        prim_len = strlen( Grammar::PrimitiveTypeToken[ i ] );
-        if( 0 == strncmp( in, Grammar::PrimitiveTypeToken[ i ], prim_len ) ) {
-            type = static_cast<Value::ValueType>( i );
+    size_t prim_len(0);
+    for (size_t i = 0; i < (size_t) Value::ValueType::ddl_types_max; i++) {
+        prim_len = strlen(Grammar::PrimitiveTypeToken[i]);
+        if (0 == strncmp(in, Grammar::PrimitiveTypeToken[i], prim_len)) {
+            type = static_cast<Value::ValueType>(i);
             break;
         }
     }
 
-    if( Value::ddl_none == type ) {
-        in = lookForNextToken( in, end );
+    if (Value::ValueType::ddl_none == type) {
+        in = lookForNextToken(in, end);
         return in;
     } else {
         in += prim_len;
     }
 
-    bool ok( true );
-    if( *in == Grammar::OpenArrayToken[ 0 ] ) {
+    bool ok(true);
+    if (*in == Grammar::OpenArrayToken[0]) {
         ok = false;
         ++in;
-        char *start( in );
-        while ( in != end ) {
+        char *start(in);
+        while (in != end) {
             ++in;
-            if( *in == Grammar::CloseArrayToken[ 0 ] ) {
-                len = ::atoi( start );
+            if (*in == Grammar::CloseArrayToken[0]) {
+                len = ::atoi(start);
                 ok = true;
                 ++in;
                 break;
@@ -603,29 +607,29 @@ char *OpenDDLParser::parsePrimitiveDataType( char *in, char *end, Value::ValueTy
     } else {
         len = 1;
     }
-    if( !ok ) {
-        type = Value::ddl_none;
+    if (!ok) {
+        type = Value::ValueType::ddl_none;
     }
 
     return in;
 }
 
-char *OpenDDLParser::parseReference( char *in, char *end, std::vector<Name*> &names ) {
-    if( ddl_nullptr == in || in == end ) {
+char *OpenDDLParser::parseReference(char *in, char *end, std::vector<Name *> &names) {
+    if (nullptr == in || in == end) {
         return in;
     }
 
-    Name *nextName( ddl_nullptr );
-    in = parseName( in, end, &nextName );
-    if( nextName ) {
-        names.push_back( nextName );
+    Name *nextName(nullptr);
+    in = parseName(in, end, &nextName);
+    if (nextName) {
+        names.push_back(nextName);
     }
-    while( Grammar::CommaSeparator[ 0 ] == *in ) {
-        in = getNextSeparator( in, end );
-        if( Grammar::CommaSeparator[ 0 ] == *in ) {
-            in = parseName( in, end, &nextName );
-            if( nextName ) {
-                names.push_back( nextName );
+    while (Grammar::CommaSeparator[0] == *in) {
+        in = getNextSeparator(in, end);
+        if (Grammar::CommaSeparator[0] == *in) {
+            in = parseName(in, end, &nextName);
+            if (nextName) {
+                names.push_back(nextName);
             }
         } else {
             break;
@@ -635,86 +639,86 @@ char *OpenDDLParser::parseReference( char *in, char *end, std::vector<Name*> &na
     return in;
 }
 
-char *OpenDDLParser::parseBooleanLiteral( char *in, char *end, Value **boolean ) {
-    *boolean = ddl_nullptr;
-    if( ddl_nullptr == in || in == end ) {
+char *OpenDDLParser::parseBooleanLiteral(char *in, char *end, Value **boolean) {
+    *boolean = nullptr;
+    if (nullptr == in || in == end) {
         return in;
     }
 
-    in = lookForNextToken( in, end );
-    char *start( in );
-    size_t len( 0 );
-    while( !isSeparator( *in ) && in != end ) {
+    in = lookForNextToken(in, end);
+    char *start(in);
+    size_t len(0);
+    while (!isSeparator(*in) && in != end) {
         ++in;
         ++len;
     }
     ++len;
-    int res = ::strncmp( Grammar::BoolTrue, start, strlen( Grammar::BoolTrue ) );
-    if( 0 != res ) {
-        res = ::strncmp( Grammar::BoolFalse, start, strlen( Grammar::BoolFalse ) );
-        if( 0 != res ) {
-            *boolean = ddl_nullptr;
+    int res = ::strncmp(Grammar::BoolTrue, start, strlen(Grammar::BoolTrue));
+    if (0 != res) {
+        res = ::strncmp(Grammar::BoolFalse, start, strlen(Grammar::BoolFalse));
+        if (0 != res) {
+            *boolean = nullptr;
             return in;
         }
-        *boolean = ValueAllocator::allocPrimData( Value::ddl_bool );
-        (*boolean)->setBool( false );
+        *boolean = ValueAllocator::allocPrimData(Value::ValueType::ddl_bool);
+        (*boolean)->setBool(false);
     } else {
-        *boolean = ValueAllocator::allocPrimData( Value::ddl_bool );
-        (*boolean)->setBool( true );
+        *boolean = ValueAllocator::allocPrimData(Value::ValueType::ddl_bool);
+        (*boolean)->setBool(true);
     }
 
     return in;
 }
 
-char *OpenDDLParser::parseIntegerLiteral( char *in, char *end, Value **integer, Value::ValueType integerType ) {
-    *integer = ddl_nullptr;
-    if( ddl_nullptr == in || in == end ) {
+char *OpenDDLParser::parseIntegerLiteral(char *in, char *end, Value **integer, Value::ValueType integerType) {
+    *integer = nullptr;
+    if (nullptr == in || in == end) {
         return in;
     }
 
-    if( !(isIntegerType( integerType ) || isUnsignedIntegerType(integerType)) ) {
+    if (!(isIntegerType(integerType) || isUnsignedIntegerType(integerType))) {
         return in;
     }
 
-    in = lookForNextToken( in, end );
-    char *start( in );
-    while( !isSeparator( *in ) && in != end ) {
+    in = lookForNextToken(in, end);
+    char *start(in);
+    while (!isSeparator(*in) && in != end) {
         ++in;
     }
 
-    if( isNumeric( *start ) ) {
+    if (isNumeric(*start)) {
 #ifdef OPENDDL_NO_USE_CPP11
-        const int64 value( atol( start ) ); // maybe not really 64bit as atoll is but exists without c++11
-        const uint64 uvalue( strtoul( start,ddl_nullptr,10 ) );
+        const int64 value(atol(start)); // maybe not really 64bit as atoll is but exists without c++11
+        const uint64 uvalue(strtoul(start, nullptr, 10));
 #else
-        const int64 value( atoll( start ) );
-        const uint64 uvalue( strtoull( start,ddl_nullptr,10 ) );
+        const int64 value(atoll(start));
+        const uint64 uvalue(strtoull(start, nullptr, 10));
 #endif
-        *integer = ValueAllocator::allocPrimData( integerType );
-        switch( integerType ) {
-            case Value::ddl_int8:
-                ( *integer )->setInt8( (int8) value );
+        *integer = ValueAllocator::allocPrimData(integerType);
+        switch (integerType) {
+            case Value::ValueType::ddl_int8:
+                (*integer)->setInt8((int8)value);
                 break;
-            case Value::ddl_int16:
-                ( *integer )->setInt16( ( int16 ) value );
+            case Value::ValueType::ddl_int16:
+                (*integer)->setInt16((int16)value);
                 break;
-            case Value::ddl_int32:
-                ( *integer )->setInt32( ( int32 ) value );
+            case Value::ValueType::ddl_int32:
+                (*integer)->setInt32((int32)value);
                 break;
-            case Value::ddl_int64:
-                ( *integer )->setInt64( ( int64 ) value );
+            case Value::ValueType::ddl_int64:
+                (*integer)->setInt64((int64)value);
                 break;
-            case Value::ddl_unsigned_int8:
-                ( *integer )->setUnsignedInt8( (uint8) uvalue );
+            case Value::ValueType::ddl_unsigned_int8:
+                (*integer)->setUnsignedInt8((uint8)uvalue);
                 break;
-            case Value::ddl_unsigned_int16:
-                ( *integer )->setUnsignedInt16( ( uint16 ) uvalue );
+            case Value::ValueType::ddl_unsigned_int16:
+                (*integer)->setUnsignedInt16((uint16)uvalue);
                 break;
-            case Value::ddl_unsigned_int32:
-                ( *integer )->setUnsignedInt32( ( uint32 ) uvalue );
+            case Value::ValueType::ddl_unsigned_int32:
+                (*integer)->setUnsignedInt32((uint32)uvalue);
                 break;
-            case Value::ddl_unsigned_int64:
-                ( *integer )->setUnsignedInt64( ( uint64 ) uvalue );
+            case Value::ValueType::ddl_unsigned_int64:
+                (*integer)->setUnsignedInt64((uint64)uvalue);
                 break;
             default:
                 break;
@@ -724,105 +728,105 @@ char *OpenDDLParser::parseIntegerLiteral( char *in, char *end, Value **integer,
     return in;
 }
 
-char *OpenDDLParser::parseFloatingLiteral( char *in, char *end, Value **floating, Value::ValueType floatType) {
-    *floating = ddl_nullptr;
-    if( ddl_nullptr == in || in == end ) {
+char *OpenDDLParser::parseFloatingLiteral(char *in, char *end, Value **floating, Value::ValueType floatType) {
+    *floating = nullptr;
+    if (nullptr == in || in == end) {
         return in;
     }
 
-    in = lookForNextToken( in, end );
-    char *start( in );
-    while( !isSeparator( *in ) && in != end ) {
+    in = lookForNextToken(in, end);
+    char *start(in);
+    while (!isSeparator(*in) && in != end) {
         ++in;
     }
 
     // parse the float value
-    bool ok( false );
-    if ( isHexLiteral( start, end ) ) {
-        parseHexaLiteral( start, end, floating );
+    bool ok(false);
+    if (isHexLiteral(start, end)) {
+        parseHexaLiteral(start, end, floating);
         return in;
     }
 
-    if( isNumeric( *start ) ) {
+    if (isNumeric(*start)) {
         ok = true;
     } else {
-        if( *start == '-' ) {
-            if( isNumeric( *(start+1) ) ) {
+        if (*start == '-') {
+            if (isNumeric(*(start + 1))) {
                 ok = true;
             }
         }
     }
 
-    if( ok ) {
-        if ( floatType == Value::ddl_double ) {
-            const double value( atof( start ) );
-            *floating = ValueAllocator::allocPrimData( Value::ddl_double );
-            ( *floating )->setDouble( value );
+    if (ok) {
+        if (floatType == Value::ValueType::ddl_double) {
+            const double value(atof(start));
+            *floating = ValueAllocator::allocPrimData(Value::ValueType::ddl_double);
+            (*floating)->setDouble(value);
         } else {
-            const float value( ( float ) atof( start ) );
-            *floating = ValueAllocator::allocPrimData( Value::ddl_float );
-            ( *floating )->setFloat( value );
+            const float value((float)atof(start));
+            *floating = ValueAllocator::allocPrimData(Value::ValueType::ddl_float);
+            (*floating)->setFloat(value);
         }
     }
 
     return in;
 }
 
-char *OpenDDLParser::parseStringLiteral( char *in, char *end, Value **stringData ) {
-    *stringData = ddl_nullptr;
-    if( ddl_nullptr == in || in == end ) {
+char *OpenDDLParser::parseStringLiteral(char *in, char *end, Value **stringData) {
+    *stringData = nullptr;
+    if (nullptr == in || in == end) {
         return in;
     }
 
-    in = lookForNextToken( in, end );
-    size_t len( 0 );
-    char *start( in );
-    if( *start == '\"' ) {
+    in = lookForNextToken(in, end);
+    size_t len(0);
+    char *start(in);
+    if (*start == '\"') {
         ++start;
         ++in;
-        while( *in != '\"' && in != end ) {
+        while (*in != '\"' && in != end) {
             ++in;
             ++len;
         }
 
-        *stringData = ValueAllocator::allocPrimData( Value::ddl_string, len );
-        ::strncpy( ( char* ) ( *stringData )->m_data, start, len );
-        ( *stringData )->m_data[len] = '\0';
+        *stringData = ValueAllocator::allocPrimData(Value::ValueType::ddl_string, len);
+        ::strncpy((char *)(*stringData)->m_data, start, len);
+        (*stringData)->m_data[len] = '\0';
         ++in;
     }
 
     return in;
 }
 
-static void createPropertyWithData( Text *id, Value *primData, Property **prop ) {
-    if( ddl_nullptr != primData ) {
-        ( *prop ) = new Property( id );
-        ( *prop )->m_value = primData;
+static void createPropertyWithData(Text *id, Value *primData, Property **prop) {
+    if (nullptr != primData) {
+        (*prop) = new Property(id);
+        (*prop)->m_value = primData;
     }
 }
 
-char *OpenDDLParser::parseHexaLiteral( char *in, char *end, Value **data ) {
-    *data = ddl_nullptr;
-    if( ddl_nullptr == in || in == end ) {
+char *OpenDDLParser::parseHexaLiteral(char *in, char *end, Value **data) {
+    *data = nullptr;
+    if (nullptr == in || in == end) {
         return in;
     }
 
-    in = lookForNextToken( in, end );
-    if( *in != '0' ) {
+    in = lookForNextToken(in, end);
+    if (*in != '0') {
         return in;
     }
 
     ++in;
-    if( *in != 'x' && *in != 'X' ) {
+    if (*in != 'x' && *in != 'X') {
         return in;
     }
 
     ++in;
-    bool ok( true );
-    char *start( in );
-    int pos( 0 );
-    while( !isSeparator( *in ) && in != end ) {
-        if( ( *in < '0' && *in > '9' ) || ( *in < 'a' && *in > 'f' ) || ( *in < 'A' && *in > 'F' ) ) {
+    bool ok(true);
+    char *start(in);
+    int pos(0);
+    while (!isSeparator(*in) && in != end) {
+        if ((*in < '0' && *in > '9') || (*in < 'a' && *in > 'f') || (*in < 'A' && *in > 'F')) {
             ok = false;
             break;
         }
@@ -830,57 +834,57 @@ char *OpenDDLParser::parseHexaLiteral( char *in, char *end, Value **data ) {
         ++in;
     }
 
-    if( !ok ) {
+    if (!ok) {
         return in;
     }
 
-    int value( 0 );
-    while( pos > 0 ) {
-        int v = hex2Decimal( *start );
+    int value(0);
+    while (pos > 0) {
+        int v = hex2Decimal(*start);
         --pos;
-        value = ( value << 4 ) | v;
+        value = (value << 4) | v;
         ++start;
     }
 
-    *data = ValueAllocator::allocPrimData( Value::ddl_unsigned_int64 );
-    if( ddl_nullptr != *data ) {
-        ( *data )->setUnsignedInt64( value );
+    *data = ValueAllocator::allocPrimData(Value::ValueType::ddl_unsigned_int64);
+    if (nullptr != *data) {
+        (*data)->setUnsignedInt64(value);
     }
 
     return in;
 }
 
-char *OpenDDLParser::parseProperty( char *in, char *end, Property **prop ) {
-    *prop = ddl_nullptr;
-    if( ddl_nullptr == in || in == end ) {
+char *OpenDDLParser::parseProperty(char *in, char *end, Property **prop) {
+    *prop = nullptr;
+    if (nullptr == in || in == end) {
         return in;
     }
 
-    in = lookForNextToken( in, end );
-    Text *id( ddl_nullptr );
-    in = parseIdentifier( in, end, &id );
-    if( ddl_nullptr != id ) {
-        in = lookForNextToken( in, end );
-        if( *in == '=' ) {
+    in = lookForNextToken(in, end);
+    Text *id = nullptr;
+    in = parseIdentifier(in, end, &id);
+    if (nullptr != id) {
+        in = lookForNextToken(in, end);
+        if (in != end && *in == '=') {
             ++in;
-            in = getNextToken( in, end );
-            Value *primData( ddl_nullptr );
-            if( isInteger( in, end ) ) {
-                in = parseIntegerLiteral( in, end, &primData );
-                createPropertyWithData( id, primData, prop );
-            } else if( isFloat( in, end ) ) {
-                in = parseFloatingLiteral( in, end, &primData );
-                createPropertyWithData( id, primData, prop );
-            } else if( isStringLiteral( *in ) ) { // string data
-                in = parseStringLiteral( in, end, &primData );
-                createPropertyWithData( id, primData, prop );
-            } else {                              // reference data
-                std::vector<Name*> names;
-                in = parseReference( in, end, names );
-                if( !names.empty() ) {
-                    Reference *ref = new Reference( names.size(), &names[ 0 ] );
-                    ( *prop ) = new Property( id );
-                    ( *prop )->m_ref = ref;
+            in = getNextToken(in, end);
+            Value *primData(nullptr);
+            if (isInteger(in, end)) {
+                in = parseIntegerLiteral(in, end, &primData);
+                createPropertyWithData(id, primData, prop);
+            } else if (isFloat(in, end)) {
+                in = parseFloatingLiteral(in, end, &primData);
+                createPropertyWithData(id, primData, prop);
+            } else if (isStringLiteral(*in)) { // string data
+                in = parseStringLiteral(in, end, &primData);
+                createPropertyWithData(id, primData, prop);
+            } else { // reference data
+                std::vector<Name *> names;
+                in = parseReference(in, end, names);
+                if (!names.empty()) {
+                    Reference *ref = new Reference(names.size(), &names[0]);
+                    (*prop) = new Property(id);
+                    (*prop)->m_ref = ref;
                 }
             }
         } else {
@@ -891,77 +895,77 @@ char *OpenDDLParser::parseProperty( char *in, char *end, Property **prop ) {
     return in;
 }
 
-char *OpenDDLParser::parseDataList( char *in, char *end, Value::ValueType type, Value **data, 
-                                    size_t &numValues, Reference **refs, size_t &numRefs ) {
-    *data = ddl_nullptr;
+char *OpenDDLParser::parseDataList(char *in, char *end, Value::ValueType type, Value **data,
+        size_t &numValues, Reference **refs, size_t &numRefs) {
+    *data = nullptr;
     numValues = numRefs = 0;
-    if( ddl_nullptr == in || in == end ) {
+    if (nullptr == in || in == end) {
         return in;
     }
 
-    in = lookForNextToken( in, end );
-    if( *in == '{' ) {
+    in = lookForNextToken(in, end);
+    if (*in == '{') {
         ++in;
-        Value *current( ddl_nullptr ), *prev( ddl_nullptr );
-        while( '}' != *in ) {
-            current = ddl_nullptr;
-            in = lookForNextToken( in, end );
-            if ( Value::ddl_ref == type ) {
-                std::vector<Name*> names;
-                in = parseReference( in, end, names );
-                if ( !names.empty() ) {
-                    Reference *ref = new Reference( names.size(), &names[ 0 ] );
+        Value *current(nullptr), *prev(nullptr);
+        while ('}' != *in) {
+            current = nullptr;
+            in = lookForNextToken(in, end);
+            if (Value::ValueType::ddl_ref == type) {
+                std::vector<Name *> names;
+                in = parseReference(in, end, names);
+                if (!names.empty()) {
+                    Reference *ref = new Reference(names.size(), &names[0]);
                     *refs = ref;
                     numRefs = names.size();
                 }
-            } else  if ( Value::ddl_none == type ) {
-                if (isInteger( in, end )) {
-                    in = parseIntegerLiteral( in, end, &current );
-                } else if (isFloat( in, end )) {
-                    in = parseFloatingLiteral( in, end, &current );
-                } else if (isStringLiteral( *in )) {
-                    in = parseStringLiteral( in, end, &current );
-                } else if (isHexLiteral( in, end )) {
-                    in = parseHexaLiteral( in, end, &current );
+            } else if (Value::ValueType::ddl_none == type) {
+                if (isInteger(in, end)) {
+                    in = parseIntegerLiteral(in, end, &current);
+                } else if (isFloat(in, end)) {
+                    in = parseFloatingLiteral(in, end, &current);
+                } else if (isStringLiteral(*in)) {
+                    in = parseStringLiteral(in, end, &current);
+                } else if (isHexLiteral(in, end)) {
+                    in = parseHexaLiteral(in, end, &current);
                 }
             } else {
-                switch(type){
-                    case Value::ddl_int8:
-                    case Value::ddl_int16:
-                    case Value::ddl_int32:
-                    case Value::ddl_int64:
-                    case Value::ddl_unsigned_int8:
-                    case Value::ddl_unsigned_int16:
-                    case Value::ddl_unsigned_int32:
-                    case Value::ddl_unsigned_int64:
-                        in = parseIntegerLiteral( in, end, &current, type);
+                switch (type) {
+                    case Value::ValueType::ddl_int8:
+                    case Value::ValueType::ddl_int16:
+                    case Value::ValueType::ddl_int32:
+                    case Value::ValueType::ddl_int64:
+                    case Value::ValueType::ddl_unsigned_int8:
+                    case Value::ValueType::ddl_unsigned_int16:
+                    case Value::ValueType::ddl_unsigned_int32:
+                    case Value::ValueType::ddl_unsigned_int64:
+                        in = parseIntegerLiteral(in, end, &current, type);
                         break;
-                    case Value::ddl_half:
-                    case Value::ddl_float:
-                    case Value::ddl_double:
-                        in = parseFloatingLiteral( in, end, &current, type);
+                    case Value::ValueType::ddl_half:
+                    case Value::ValueType::ddl_float:
+                    case Value::ValueType::ddl_double:
+                        in = parseFloatingLiteral(in, end, &current, type);
                         break;
-                    case Value::ddl_string:
-                        in = parseStringLiteral( in, end, &current );
+                    case Value::ValueType::ddl_string:
+                        in = parseStringLiteral(in, end, &current);
                         break;
                     default:
                         break;
                 }
             }
 
-            if( ddl_nullptr != current ) {
-                if( ddl_nullptr == *data ) {
+            if (nullptr != current) {
+                if (nullptr == *data) {
                     *data = current;
                     prev = current;
                 } else {
-                    prev->setNext( current );
+                    prev->setNext(current);
                     prev = current;
                 }
                 ++numValues;
             }
 
-            in = getNextSeparator( in, end );
-            if( ',' != *in && Grammar::CloseBracketToken[ 0 ] != *in && !isSpace( *in ) ) {
+            in = getNextSeparator(in, end);
+            if (',' != *in && Grammar::CloseBracketToken[0] != *in && !isSpace(*in)) {
                 break;
             }
         }
@@ -971,53 +975,53 @@ char *OpenDDLParser::parseDataList( char *in, char *end, Value::ValueType type,
     return in;
 }
 
-static DataArrayList *createDataArrayList( Value *currentValue, size_t numValues, 
-                                           Reference *refs, size_t numRefs ) {
-    DataArrayList *dataList( new DataArrayList );
+static DataArrayList *createDataArrayList(Value *currentValue, size_t numValues,
+        Reference *refs, size_t numRefs) {
+    DataArrayList *dataList(new DataArrayList);
     dataList->m_dataList = currentValue;
     dataList->m_numItems = numValues;
-    dataList->m_refs     = refs;
-    dataList->m_numRefs  = numRefs;
+    dataList->m_refs = refs;
+    dataList->m_numRefs = numRefs;
 
     return dataList;
 }
 
-char *OpenDDLParser::parseDataArrayList( char *in, char *end,Value::ValueType type, 
-                                         DataArrayList **dataArrayList ) {
-    if ( ddl_nullptr == dataArrayList ) {
+char *OpenDDLParser::parseDataArrayList(char *in, char *end, Value::ValueType type,
+        DataArrayList **dataArrayList) {
+    if (nullptr == dataArrayList) {
         return in;
     }
 
-    *dataArrayList = ddl_nullptr;
-    if( ddl_nullptr == in || in == end ) {
+    *dataArrayList = nullptr;
+    if (nullptr == in || in == end) {
         return in;
     }
 
-    in = lookForNextToken( in, end );
-    if( *in == Grammar::OpenBracketToken[ 0 ] ) {
+    in = lookForNextToken(in, end);
+    if (*in == Grammar::OpenBracketToken[0]) {
         ++in;
-        Value *currentValue( ddl_nullptr );
-        Reference *refs( ddl_nullptr );
-        DataArrayList *prev( ddl_nullptr ), *currentDataList( ddl_nullptr );
+        Value *currentValue(nullptr);
+        Reference *refs(nullptr);
+        DataArrayList *prev(nullptr), *currentDataList(nullptr);
         do {
-            size_t numRefs( 0 ), numValues( 0 );
-            currentValue = ddl_nullptr;
+            size_t numRefs(0), numValues(0);
+            currentValue = nullptr;
 
-            in = parseDataList( in, end, type, &currentValue, numValues, &refs, numRefs );
-            if( ddl_nullptr != currentValue || 0 != numRefs ) {
-                if( ddl_nullptr == prev ) {
-                    *dataArrayList = createDataArrayList( currentValue, numValues, refs, numRefs );
+            in = parseDataList(in, end, type, &currentValue, numValues, &refs, numRefs);
+            if (nullptr != currentValue || 0 != numRefs) {
+                if (nullptr == prev) {
+                    *dataArrayList = createDataArrayList(currentValue, numValues, refs, numRefs);
                     prev = *dataArrayList;
                 } else {
-                    currentDataList = createDataArrayList( currentValue, numValues, refs, numRefs );
-                    if( ddl_nullptr != prev ) {
+                    currentDataList = createDataArrayList(currentValue, numValues, refs, numRefs);
+                    if (nullptr != prev) {
                         prev->m_next = currentDataList;
                         prev = currentDataList;
                     }
                 }
             }
-        } while( Grammar::CommaSeparator[ 0 ] == *in && in != end );
-        in = lookForNextToken( in, end );
+        } while (Grammar::CommaSeparator[0] == *in && in != end);
+        in = lookForNextToken(in, end);
         ++in;
     }
 
diff --git a/Engine/lib/assimp/contrib/openddlparser/code/OpenDDLStream.cpp b/Engine/lib/assimp/contrib/openddlparser/code/OpenDDLStream.cpp
index 7ea8331bd..1a38dfa27 100644
--- a/Engine/lib/assimp/contrib/openddlparser/code/OpenDDLStream.cpp
+++ b/Engine/lib/assimp/contrib/openddlparser/code/OpenDDLStream.cpp
@@ -1,7 +1,7 @@
 /*-----------------------------------------------------------------------------------------------
 The MIT License (MIT)
 
-Copyright (c) 2014-2015 Kim Kulling
+Copyright (c) 2014-2020 Kim Kulling
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
@@ -37,22 +37,22 @@ std::string StreamFormatterBase::format(const std::string &statement) {
     return tmp;
 }
 
-IOStreamBase::IOStreamBase(StreamFormatterBase *formatter)
-    : m_formatter(formatter)
-    , m_file(ddl_nullptr) {
-    if (ddl_nullptr == m_formatter) {
+IOStreamBase::IOStreamBase(StreamFormatterBase *formatter) :
+        m_formatter(formatter),
+        m_file(nullptr) {
+    if (nullptr == m_formatter) {
         m_formatter = new StreamFormatterBase;
     }
 }
 
 IOStreamBase::~IOStreamBase() {
     delete m_formatter;
-    m_formatter = ddl_nullptr;
+    m_formatter = nullptr;
 }
 
 bool IOStreamBase::open(const std::string &name) {
     m_file = ::fopen(name.c_str(), "a");
-    if (m_file == ddl_nullptr) {
+    if (m_file == nullptr) {
         return false;
     }
 
@@ -60,33 +60,33 @@ bool IOStreamBase::open(const std::string &name) {
 }
 
 bool IOStreamBase::close() {
-    if (ddl_nullptr == m_file) {
+    if (nullptr == m_file) {
         return false;
     }
 
     ::fclose(m_file);
-    m_file = ddl_nullptr;
+    m_file = nullptr;
 
     return true;
 }
 
 bool IOStreamBase::isOpen() const {
-    return ( ddl_nullptr != m_file );
+    return (nullptr != m_file);
 }
 
-size_t IOStreamBase::read( size_t sizeToRead, std::string &statement ) {
-    if (ddl_nullptr == m_file) {
+size_t IOStreamBase::read(size_t sizeToRead, std::string &statement) {
+    if (nullptr == m_file) {
         return 0;
     }
-    
+
     statement.resize(sizeToRead);
-    const size_t readBytes = ::fread( &statement[0], 1, sizeToRead, m_file );
+    const size_t readBytes = ::fread(&statement[0], 1, sizeToRead, m_file);
 
     return readBytes;
 }
 
 size_t IOStreamBase::write(const std::string &statement) {
-    if (ddl_nullptr == m_file) {
+    if (nullptr == m_file) {
         return 0;
     }
     std::string formatStatement = m_formatter->format(statement);
diff --git a/Engine/lib/assimp/contrib/openddlparser/code/Value.cpp b/Engine/lib/assimp/contrib/openddlparser/code/Value.cpp
index b5a35e722..5a8aa39be 100644
--- a/Engine/lib/assimp/contrib/openddlparser/code/Value.cpp
+++ b/Engine/lib/assimp/contrib/openddlparser/code/Value.cpp
@@ -1,7 +1,7 @@
 /*-----------------------------------------------------------------------------------------------
 The MIT License (MIT)
 
-Copyright (c) 2014-2015 Kim Kulling
+Copyright (c) 2014-2020 Kim Kulling
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
@@ -20,30 +20,30 @@ COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 -----------------------------------------------------------------------------------------------*/
+#include <openddlparser/OpenDDLStream.h>
 #include <openddlparser/Value.h>
 
-#include <iostream>
 #include <cassert>
 
 BEGIN_ODDLPARSER_NS
 
-static Value::Iterator end( ddl_nullptr );
+static Value::Iterator end(nullptr);
 
-Value::Iterator::Iterator()
-: m_start( ddl_nullptr )
-, m_current( ddl_nullptr ) {
+Value::Iterator::Iterator() :
+        m_start(nullptr),
+        m_current(nullptr) {
     // empty
 }
 
-Value::Iterator::Iterator( Value *start )
-: m_start( start )
-, m_current( start ) {
+Value::Iterator::Iterator(Value *start) :
+        m_start(start),
+        m_current(start) {
     // empty
 }
 
-Value::Iterator::Iterator( const Iterator &rhs )
-: m_start( rhs.m_start )
-, m_current( rhs.m_current ) {
+Value::Iterator::Iterator(const Iterator &rhs) :
+        m_start(rhs.m_start),
+        m_current(rhs.m_current) {
     // empty
 }
 
@@ -52,36 +52,36 @@ Value::Iterator::~Iterator() {
 }
 
 bool Value::Iterator::hasNext() const {
-    if( ddl_nullptr == m_current ) {
+    if (nullptr == m_current) {
         return false;
     }
-    return ( ddl_nullptr != m_current->getNext() );
+    return (nullptr != m_current->getNext());
 }
 
 Value *Value::Iterator::getNext() {
-    if( !hasNext() ) {
-        return ddl_nullptr;
+    if (!hasNext()) {
+        return nullptr;
     }
 
-    Value *v( m_current->getNext() );
+    Value *v(m_current->getNext());
     m_current = v;
 
     return v;
 }
 
-const Value::Iterator Value::Iterator::operator++( int ) {
-    if( ddl_nullptr == m_current ) {
+const Value::Iterator Value::Iterator::operator++(int) {
+    if (nullptr == m_current) {
         return end;
     }
 
     m_current = m_current->getNext();
-    Iterator inst( m_current );
+    Iterator inst(m_current);
 
     return inst;
 }
 
-Value::Iterator &Value::Iterator::operator++( ) {
-    if( ddl_nullptr == m_current ) {
+Value::Iterator &Value::Iterator::operator++() {
+    if (nullptr == m_current) {
         return end;
     }
 
@@ -90,263 +90,262 @@ Value::Iterator &Value::Iterator::operator++( ) {
     return *this;
 }
 
-bool Value::Iterator::operator == ( const Iterator &rhs ) const {
-    return ( m_current == rhs.m_current );
+bool Value::Iterator::operator==(const Iterator &rhs) const {
+    return (m_current == rhs.m_current);
 }
 
-Value *Value::Iterator::operator->( ) const {
-    if(ddl_nullptr == m_current ) {
-        return ddl_nullptr;
+Value *Value::Iterator::operator->() const {
+    if (nullptr == m_current) {
+        return nullptr;
     }
     return m_current;
 }
 
-Value::Value( ValueType type )
-: m_type( type )
-, m_size( 0 )
-, m_data( ddl_nullptr )
-, m_next( ddl_nullptr ) {
+Value::Value(ValueType type) :
+        m_type(type),
+        m_size(0),
+        m_data(nullptr),
+        m_next(nullptr) {
     // empty
 }
 
 Value::~Value() {
-    if(m_data!=ddl_nullptr) {
-        if (m_type == ddl_ref ) {
-            Reference *tmp = (Reference *) m_data;
-            if (tmp != ddl_nullptr)
+    if (m_data != nullptr) {
+        if (m_type == ValueType::ddl_ref) {
+            Reference *tmp = (Reference *)m_data;
+            if (tmp != nullptr) {
                 delete tmp;
-        }else
+            }
+        } else {
             delete[] m_data;
-
+        }
     }
-    if(m_next!=ddl_nullptr)
-        delete m_next;
+    delete m_next;
 }
 
-void Value::setBool( bool value ) {
-    assert( ddl_bool == m_type );
-    ::memcpy( m_data, &value, m_size );
+void Value::setBool(bool value) {
+    assert(ValueType::ddl_bool == m_type);
+    ::memcpy(m_data, &value, m_size);
 }
 
 bool Value::getBool() {
-    assert( ddl_bool == m_type );
-    return ( *m_data == 1 );
+    assert(ValueType::ddl_bool == m_type);
+    return (*m_data == 1);
 }
 
-void Value::setInt8( int8 value ) {
-    assert( ddl_int8 == m_type );
-    ::memcpy( m_data, &value, m_size );
+void Value::setInt8(int8 value) {
+    assert(ValueType::ddl_int8 == m_type);
+    ::memcpy(m_data, &value, m_size);
 }
 
 int8 Value::getInt8() {
-    assert( ddl_int8 == m_type );
-    return ( int8 ) ( *m_data );
+    assert(ValueType::ddl_int8 == m_type);
+    return (int8)(*m_data);
 }
 
-void Value::setInt16( int16 value ) {
-    assert( ddl_int16 == m_type );
-    ::memcpy( m_data, &value, m_size );
+void Value::setInt16(int16 value) {
+    assert(ValueType::ddl_int16 == m_type);
+    ::memcpy(m_data, &value, m_size);
 }
 
 int16 Value::getInt16() {
-    assert( ddl_int16 == m_type );
+    assert(ValueType::ddl_int16 == m_type);
     int16 i;
-    ::memcpy( &i, m_data, m_size );
+    ::memcpy(&i, m_data, m_size);
     return i;
 }
 
-void Value::setInt32( int32 value ) {
-    assert( ddl_int32 == m_type );
-    ::memcpy( m_data, &value, m_size );
+void Value::setInt32(int32 value) {
+    assert(ValueType::ddl_int32 == m_type);
+    ::memcpy(m_data, &value, m_size);
 }
 
 int32 Value::getInt32() {
-    assert( ddl_int32 == m_type );
+    assert(ValueType::ddl_int32 == m_type);
     int32 i;
-    ::memcpy( &i, m_data, m_size );
+    ::memcpy(&i, m_data, m_size);
     return i;
 }
 
-void Value::setInt64( int64 value ) {
-    assert( ddl_int64 == m_type );
-    ::memcpy( m_data, &value, m_size );
+void Value::setInt64(int64 value) {
+    assert(ValueType::ddl_int64 == m_type);
+    ::memcpy(m_data, &value, m_size);
 }
 
 int64 Value::getInt64() {
-    assert( ddl_int64 == m_type );
+    assert(ValueType::ddl_int64 == m_type);
     int64 i;
-    ::memcpy( &i, m_data, m_size );
+    ::memcpy(&i, m_data, m_size);
     return i;
 }
 
-void Value::setUnsignedInt8( uint8 value ) {
-    assert( ddl_unsigned_int8 == m_type );
-    ::memcpy( m_data, &value, m_size );
+void Value::setUnsignedInt8(uint8 value) {
+    assert(ValueType::ddl_unsigned_int8 == m_type);
+    ::memcpy(m_data, &value, m_size);
 }
 
 uint8 Value::getUnsignedInt8() const {
-    assert( ddl_unsigned_int8 == m_type );
+    assert(ValueType::ddl_unsigned_int8 == m_type);
     uint8 i;
-    ::memcpy( &i, m_data, m_size );
+    ::memcpy(&i, m_data, m_size);
     return i;
 }
 
-void Value::setUnsignedInt16( uint16 value ) {
-    assert( ddl_unsigned_int16 == m_type );
-    ::memcpy( m_data, &value, m_size );
+void Value::setUnsignedInt16(uint16 value) {
+    assert(ValueType::ddl_unsigned_int16 == m_type);
+    ::memcpy(m_data, &value, m_size);
 }
 
 uint16 Value::getUnsignedInt16() const {
-    assert( ddl_unsigned_int16 == m_type );
+    assert(ValueType::ddl_unsigned_int16 == m_type);
     uint16 i;
-    ::memcpy( &i, m_data, m_size );
+    ::memcpy(&i, m_data, m_size);
     return i;
 }
 
-void Value::setUnsignedInt32( uint32 value ) {
-    assert( ddl_unsigned_int32 == m_type );
-    ::memcpy( m_data, &value, m_size );
+void Value::setUnsignedInt32(uint32 value) {
+    assert(ValueType::ddl_unsigned_int32 == m_type);
+    ::memcpy(m_data, &value, m_size);
 }
 
 uint32 Value::getUnsignedInt32() const {
-    assert( ddl_unsigned_int32 == m_type );
+    assert(ValueType::ddl_unsigned_int32 == m_type);
     uint32 i;
-    ::memcpy( &i, m_data, m_size );
+    ::memcpy(&i, m_data, m_size);
     return i;
 }
 
-void Value::setUnsignedInt64( uint64 value ) {
-    assert( ddl_unsigned_int64 == m_type );
-    ::memcpy( m_data, &value, m_size );
+void Value::setUnsignedInt64(uint64 value) {
+    assert(ValueType::ddl_unsigned_int64 == m_type);
+    ::memcpy(m_data, &value, m_size);
 }
 
 uint64 Value::getUnsignedInt64() const {
-    assert( ddl_unsigned_int64 == m_type );
+    assert(ValueType::ddl_unsigned_int64 == m_type);
     uint64 i;
-    ::memcpy( &i, m_data, m_size );
+    ::memcpy(&i, m_data, m_size);
     return i;
 }
 
-void Value::setFloat( float value ) {
-    assert( ddl_float == m_type );
-    ::memcpy( m_data, &value, m_size );
+void Value::setFloat(float value) {
+    assert(ValueType::ddl_float == m_type);
+    ::memcpy(m_data, &value, m_size);
 }
 
 float Value::getFloat() const {
-    if( m_type == ddl_float ) {
+    if (m_type == ValueType::ddl_float) {
         float v;
-        ::memcpy( &v, m_data, m_size );
-        return ( float ) v;
+        ::memcpy(&v, m_data, m_size);
+        return (float)v;
     } else {
         float tmp;
-        ::memcpy( &tmp, m_data, 4 );
-        return ( float ) tmp;
+        ::memcpy(&tmp, m_data, 4);
+        return (float)tmp;
     }
 }
 
-void Value::setDouble( double value ) {
-    assert( ddl_double == m_type );
-    ::memcpy( m_data, &value, m_size );
+void Value::setDouble(double value) {
+    assert(ValueType::ddl_double == m_type);
+    ::memcpy(m_data, &value, m_size);
 }
 
 double Value::getDouble() const {
-    if ( m_type == ddl_double ) {
+    if (m_type == ValueType::ddl_double) {
         double v;
-        ::memcpy( &v, m_data, m_size );
-        return ( float ) v;
-    }
-    else {
+        ::memcpy(&v, m_data, m_size);
+        return (float)v;
+    } else {
         double tmp;
-        ::memcpy( &tmp, m_data, 4 );
-        return ( double ) tmp;
+        ::memcpy(&tmp, m_data, 4);
+        return (double)tmp;
     }
 }
 
-void Value::setString( const std::string &str ) {
-    assert( ddl_string == m_type );
-    ::memcpy( m_data, str.c_str(), str.size() );
-    m_data[ str.size() ] = '\0';
+void Value::setString(const std::string &str) {
+    assert(ValueType::ddl_string == m_type);
+    ::memcpy(m_data, str.c_str(), str.size());
+    m_data[str.size()] = '\0';
 }
 
 const char *Value::getString() const {
-    assert( ddl_string == m_type );
-    return (const char*) m_data;
+    assert(ValueType::ddl_string == m_type);
+    return (const char *)m_data;
 }
 
-void Value::setRef( Reference *ref ) {
-    assert( ddl_ref == m_type );
+void Value::setRef(Reference *ref) {
+    assert(ValueType::ddl_ref == m_type);
 
-    if ( ddl_nullptr != ref ) {
-        const size_t sizeInBytes( ref->sizeInBytes() );
-        if ( sizeInBytes > 0 ) {
-            if ( ddl_nullptr != m_data ) {
-                delete [] m_data;
+    if (nullptr != ref) {
+        const size_t sizeInBytes(ref->sizeInBytes());
+        if (sizeInBytes > 0) {
+            if (nullptr != m_data) {
+                delete[] m_data;
             }
 
-            m_data = (unsigned char*) new Reference(*ref);
+            m_data = (unsigned char *)new Reference(*ref);
         }
     }
 }
 
 Reference *Value::getRef() const {
-    assert( ddl_ref == m_type );
+    assert(ValueType::ddl_ref == m_type);
 
-    return (Reference*) m_data;
+    return (Reference *)m_data;
 }
 
-void Value::dump( IOStreamBase &/*stream*/ ) {
-    switch( m_type ) {
-        case ddl_none:
-            std::cout << "None" << std::endl;
+void Value::dump(IOStreamBase &stream) {
+    switch (m_type) {
+        case ValueType::ddl_none:
+            stream.write("None\n");
             break;
-        case ddl_bool:
-            std::cout << getBool() << std::endl;
+        case ValueType::ddl_bool:
+            stream.write(std::to_string(getBool()) + "\n");
             break;
-        case ddl_int8:
-            std::cout << getInt8() << std::endl;
+        case ValueType::ddl_int8:
+            stream.write(std::to_string(getInt8()) + "\n");
             break;
-        case ddl_int16:
-            std::cout << getInt16() << std::endl;
+        case ValueType::ddl_int16:
+            stream.write(std::to_string(getInt16()) + "\n");
             break;
-        case ddl_int32:
-            std::cout << getInt32() << std::endl;
+        case ValueType::ddl_int32:
+            stream.write(std::to_string(getInt32()) + "\n");
             break;
-        case ddl_int64:
-            std::cout << getInt64() << std::endl;
+        case ValueType::ddl_int64:
+            stream.write(std::to_string(getInt64()) + "\n");
             break;
-        case ddl_unsigned_int8:
-            std::cout << "Not supported" << std::endl;
+        case ValueType::ddl_unsigned_int8:
+            stream.write("Not supported\n");
             break;
-        case ddl_unsigned_int16:
-            std::cout << "Not supported" << std::endl;
+        case ValueType::ddl_unsigned_int16:
+            stream.write("Not supported\n");
             break;
-        case ddl_unsigned_int32:
-            std::cout << "Not supported" << std::endl;
+        case ValueType::ddl_unsigned_int32:
+            stream.write("Not supported\n");
             break;
-        case ddl_unsigned_int64:
-            std::cout << "Not supported" << std::endl;
+        case ValueType::ddl_unsigned_int64:
+            stream.write("Not supported\n");
             break;
-        case ddl_half:
-            std::cout << "Not supported" << std::endl;
+        case ValueType::ddl_half:
+            stream.write("Not supported\n");
             break;
-        case ddl_float:
-            std::cout << getFloat() << std::endl;
+        case ValueType::ddl_float:
+            stream.write(std::to_string(getFloat()) + "\n");
             break;
-        case ddl_double:
-            std::cout << getDouble() << std::endl;
+        case ValueType::ddl_double:
+            stream.write(std::to_string(getDouble()) + "\n");
             break;
-        case ddl_string:
-            std::cout << getString() << std::endl;
+        case ValueType::ddl_string:
+            stream.write(std::string(getString()) + "\n");
             break;
-        case ddl_ref:
-            std::cout << "Not supported" << std::endl;
+        case ValueType::ddl_ref:
+            stream.write("Not supported\n");
             break;
         default:
             break;
     }
 }
 
-void Value::setNext( Value *next ) {
+void Value::setNext(Value *next) {
     m_next = next;
 }
 
@@ -354,86 +353,86 @@ Value *Value::getNext() const {
     return m_next;
 }
 
-size_t Value::size() const{
-    size_t result=1;
-    Value *n=m_next;
-    while( n!=ddl_nullptr) {
+size_t Value::size() const {
+    size_t result = 1;
+    Value *n = m_next;
+    while (n != nullptr) {
         result++;
-        n=n->m_next;
+        n = n->m_next;
     }
     return result;
 }
 
-Value *ValueAllocator::allocPrimData( Value::ValueType type, size_t len ) {
-    if( type == Value::ddl_none || Value::ddl_types_max == type ) {
-        return ddl_nullptr;
+Value *ValueAllocator::allocPrimData(Value::ValueType type, size_t len) {
+    if (type == Value::ValueType::ddl_none || Value::ValueType::ddl_types_max == type) {
+        return nullptr;
     }
 
-    Value *data = new Value( type );
-    switch( type ) {
-        case Value::ddl_bool:
-            data->m_size = sizeof( bool );
+    Value *data = new Value(type);
+    switch (type) {
+        case Value::ValueType::ddl_bool:
+            data->m_size = sizeof(bool);
             break;
-        case Value::ddl_int8:
-            data->m_size = sizeof( int8 );
+        case Value::ValueType::ddl_int8:
+            data->m_size = sizeof(int8);
             break;
-        case Value::ddl_int16:
-            data->m_size = sizeof( int16 );
+        case Value::ValueType::ddl_int16:
+            data->m_size = sizeof(int16);
             break;
-        case Value::ddl_int32:
-            data->m_size = sizeof( int32 );
+        case Value::ValueType::ddl_int32:
+            data->m_size = sizeof(int32);
             break;
-        case Value::ddl_int64:
-            data->m_size = sizeof( int64 );
+        case Value::ValueType::ddl_int64:
+            data->m_size = sizeof(int64);
             break;
-        case Value::ddl_unsigned_int8:
-            data->m_size = sizeof( uint8 );
+        case Value::ValueType::ddl_unsigned_int8:
+            data->m_size = sizeof(uint8);
             break;
-        case Value::ddl_unsigned_int16:
-            data->m_size = sizeof( uint16 );
+        case Value::ValueType::ddl_unsigned_int16:
+            data->m_size = sizeof(uint16);
             break;
-        case Value::ddl_unsigned_int32:
-            data->m_size = sizeof( uint32 );
+        case Value::ValueType::ddl_unsigned_int32:
+            data->m_size = sizeof(uint32);
             break;
-        case Value::ddl_unsigned_int64:
-            data->m_size = sizeof( uint64 );
+        case Value::ValueType::ddl_unsigned_int64:
+            data->m_size = sizeof(uint64);
             break;
-        case Value::ddl_half:
-            data->m_size = sizeof( short );
+        case Value::ValueType::ddl_half:
+            data->m_size = sizeof(short);
             break;
-        case Value::ddl_float:
-            data->m_size = sizeof( float );
+        case Value::ValueType::ddl_float:
+            data->m_size = sizeof(float);
             break;
-        case Value::ddl_double:
-            data->m_size = sizeof( double );
+        case Value::ValueType::ddl_double:
+            data->m_size = sizeof(double);
             break;
-        case Value::ddl_string:
-            data->m_size = sizeof( char )*(len+1);
+        case Value::ValueType::ddl_string:
+            data->m_size = sizeof(char) * (len + 1);
             break;
-        case Value::ddl_ref:
+        case Value::ValueType::ddl_ref:
             data->m_size = 0;
             break;
-        case Value::ddl_none:
-        case Value::ddl_types_max:
+        case Value::ValueType::ddl_none:
+        case Value::ValueType::ddl_types_max:
         default:
             break;
     }
 
-    if( data->m_size ) {
-        data->m_data = new unsigned char[ data->m_size ];
-        ::memset(data->m_data,0,data->m_size);
+    if (data->m_size) {
+        data->m_data = new unsigned char[data->m_size];
+        ::memset(data->m_data, 0, data->m_size);
     }
 
     return data;
 }
 
-void ValueAllocator::releasePrimData( Value **data ) {
-    if( !data ) {
+void ValueAllocator::releasePrimData(Value **data) {
+    if (!data) {
         return;
     }
 
     delete *data;
-    *data = ddl_nullptr;
+    *data = nullptr;
 }
 
 END_ODDLPARSER_NS
diff --git a/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/DDLNode.h b/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/DDLNode.h
index 915bd3041..593a5f145 100644
--- a/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/DDLNode.h
+++ b/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/DDLNode.h
@@ -1,7 +1,7 @@
 /*-----------------------------------------------------------------------------------------------
 The MIT License (MIT)
 
-Copyright (c) 2014-2015 Kim Kulling
+Copyright (c) 2014-2020 Kim Kulling
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
@@ -24,8 +24,8 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #include <openddlparser/OpenDDLCommon.h>
 
-#include <vector>
 #include <string>
+#include <vector>
 
 BEGIN_ODDLPARSER_NS
 
@@ -53,10 +53,10 @@ public:
     friend class OpenDDLParser;
 
     /// @brief  The child-node-list type.
-    typedef std::vector<DDLNode*> DllNodeList;
+    typedef std::vector<DDLNode *> DllNodeList;
 
     /// @brief  The child-node-list iterator.
-    typedef std::vector<DDLNode*>::iterator DDLNodeIt;
+    typedef std::vector<DDLNode *>::iterator DDLNodeIt;
 
 public:
     ///	@brief  The class destructor.
@@ -64,7 +64,7 @@ public:
 
     ///	@brief  Will attach a parent node instance, an older one will be released.
     /// @param  parent      [in] The parent node instance.
-    void attachParent( DDLNode *parent );
+    void attachParent(DDLNode *parent);
 
     /// @brief  Will try to detach a parent node instance, if there is any.
     void detachParent();
@@ -79,7 +79,7 @@ public:
 
     /// Set the type of the DDLNode instance.
     /// @param  type    [in] The type.
-    void setType( const std::string &type );
+    void setType(const std::string &type);
 
     /// @brief  Returns the type of the DDLNode instance.
     /// @return The type of the DDLNode instance.
@@ -87,7 +87,7 @@ public:
 
     /// Set the name of the DDLNode instance.
     /// @param  name        [in] The name.
-    void setName( const std::string &name );
+    void setName(const std::string &name);
 
     /// @brief  Returns the name of the DDLNode instance.
     /// @return The name of the DDLNode instance.
@@ -95,7 +95,7 @@ public:
 
     /// @brief  Set a new property set.
     ///	@param  prop        [in] The first element of the property set.
-    void setProperties( Property *prop );
+    void setProperties(Property *prop);
 
     ///	@brief  Returns the first element of the assigned property set.
     ///	@return The first property of the assigned property set.
@@ -104,7 +104,7 @@ public:
     ///	@brief  Looks for a given property.
     /// @param  name        [in] The name for the property to look for.
     /// @return true, if a corresponding property is assigned to the node, false if not.
-    bool hasProperty( const std::string &name );
+    bool hasProperty(const std::string &name);
 
     ///	@brief  Will return true, if any properties are assigned to the node instance.
     ///	@return True, if properties are assigned.
@@ -113,11 +113,11 @@ public:
     ///	@brief  Search for a given property and returns it. Will return ddl_nullptr if no property was found.
     /// @param  name        [in] The name for the property to look for.
     /// @return The property or ddl_nullptr if no property was found.
-    Property *findPropertyByName( const std::string &name );
-    
+    Property *findPropertyByName(const std::string &name);
+
     /// @brief  Set a new value set.
     /// @param  val         [in] The first value instance of the value set.
-    void setValue( Value *val );
+    void setValue(Value *val);
 
     ///	@brief  Returns the first element of the assigned value set.
     ///	@return The first property of the assigned value set.
@@ -125,7 +125,7 @@ public:
 
     /// @brief  Set a new DataArrayList.
     /// @param  dtArrayList [in] The DataArrayList instance.
-    void setDataArrayList( DataArrayList *dtArrayList );
+    void setDataArrayList(DataArrayList *dtArrayList);
 
     ///	@brief  Returns the DataArrayList.
     ///	@return The DataArrayList.
@@ -133,7 +133,7 @@ public:
 
     /// @brief  Set a new Reference set.
     /// @param  refs        [in] The first value instance of the Reference set.
-    void setReferences( Reference  *refs );
+    void setReferences(Reference *refs);
 
     ///	@brief  Returns the first element of the assigned Reference set.
     ///	@return The first property of the assigned Reference set.
@@ -148,20 +148,20 @@ public:
     ///	@param  name        [in] The name for the new DDLNode instance.
     /// @param  parent      [in] The parent node instance or ddl_nullptr if no parent node is there.
     /// @return The new created node instance.
-    static DDLNode *create( const std::string &type, const std::string &name, DDLNode *parent = ddl_nullptr );
+    static DDLNode *create(const std::string &type, const std::string &name, DDLNode *parent = nullptr);
 
 private:
-    DDLNode( const std::string &type, const std::string &name, size_t idx, DDLNode *parent = ddl_nullptr );
+    DDLNode(const std::string &type, const std::string &name, size_t idx, DDLNode *parent = nullptr);
     DDLNode();
-    DDLNode( const DDLNode & ) ddl_no_copy;
-    DDLNode &operator = ( const DDLNode & ) ddl_no_copy;
+    DDLNode(const DDLNode &) ddl_no_copy;
+    DDLNode &operator=(const DDLNode &) ddl_no_copy;
     static void releaseNodes();
 
 private:
     std::string m_type;
     std::string m_name;
     DDLNode *m_parent;
-    std::vector<DDLNode*> m_children;
+    std::vector<DDLNode *> m_children;
     Property *m_properties;
     Value *m_value;
     DataArrayList *m_dtArrayList;
diff --git a/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/OpenDDLCommon.h b/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/OpenDDLCommon.h
index bec62cc9d..6ccc83b88 100644
--- a/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/OpenDDLCommon.h
+++ b/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/OpenDDLCommon.h
@@ -1,7 +1,7 @@
 /*-----------------------------------------------------------------------------------------------
 The MIT License (MIT)
 
-Copyright (c) 2014-2015 Kim Kulling
+Copyright (c) 2014-2020 Kim Kulling
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
@@ -23,49 +23,49 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #pragma once
 
 #include <cstddef>
-#include <vector>
 #include <string>
+#include <vector>
 
 #include <stdio.h>
 #include <string.h>
 #ifndef _WIN32
-#  include <inttypes.h>
+#include <inttypes.h>
 #endif
 
-#if defined(_MSC_VER) && !defined( OPENDDL_STATIC_LIBARY )
+#if defined(_MSC_VER) && !defined(OPENDDL_STATIC_LIBARY)
 
-#   define TAG_DLL_EXPORT __declspec(dllexport)
-#   define TAG_DLL_IMPORT __declspec(dllimport )
-#   ifdef OPENDDLPARSER_BUILD
-#       define DLL_ODDLPARSER_EXPORT TAG_DLL_EXPORT
-#   else
-#       define DLL_ODDLPARSER_EXPORT TAG_DLL_IMPORT
-#   endif // OPENDDLPARSER_BUILD
-#   pragma warning( disable : 4251 )
+#define TAG_DLL_EXPORT __declspec(dllexport)
+#define TAG_DLL_IMPORT __declspec(dllimport)
+#ifdef OPENDDLPARSER_BUILD
+#define DLL_ODDLPARSER_EXPORT TAG_DLL_EXPORT
 #else
-#   define DLL_ODDLPARSER_EXPORT
+#define DLL_ODDLPARSER_EXPORT TAG_DLL_IMPORT
+#endif // OPENDDLPARSER_BUILD
+#pragma warning(disable : 4251)
+#else
+#define DLL_ODDLPARSER_EXPORT
 #endif // _WIN32
 
 // Namespace declarations, override this to avoid any conflicts
 #define BEGIN_ODDLPARSER_NS namespace ODDLParser {
-#define END_ODDLPARSER_NS   } // namespace ODDLParser
-#define USE_ODDLPARSER_NS   using namespace ODDLParser;
+#define END_ODDLPARSER_NS } // namespace ODDLParser
+#define USE_ODDLPARSER_NS using namespace ODDLParser;
 
 BEGIN_ODDLPARSER_NS
 
 // We will use C++11 optional
 #ifndef OPENDDL_NO_USE_CPP11
-    // All C++11 constructs
-#   define ddl_nullptr nullptr
-#   define ddl_override override
-#   define ddl_final final
-#   define ddl_no_copy = delete
+// All C++11 constructs
+#define nullptr nullptr
+#define ddl_override override
+#define ddl_final final
+#define ddl_no_copy = delete
 #else
-    // Fall-back for older compilers
-#   define ddl_nullptr NULL
-#   define ddl_override
-#   define ddl_final
-#   define ddl_no_copy
+// Fall-back for older compilers
+#define nullptr NULL
+#define ddl_override
+#define ddl_final
+#define ddl_no_copy
 #endif // OPENDDL_NO_USE_CPP11
 
 // Forward declarations
@@ -80,36 +80,36 @@ struct DataArrayList;
 
 // Platform-specific typedefs
 #ifdef _WIN32
-typedef signed __int64    int64_impl;
-typedef unsigned __int64  uint64_impl;
+typedef signed __int64 int64_impl;
+typedef unsigned __int64 uint64_impl;
 #else
-typedef int64_t           int64_impl;
-typedef uint64_t          uint64_impl;
+typedef int64_t int64_impl;
+typedef uint64_t uint64_impl;
 #endif
 
 // OpenDDL-specific data typedefs
-typedef signed char       int8;    ///< Signed integer, 1 byte
-typedef signed short      int16;   ///< Signed integer, 2 byte
-typedef signed int        int32;   ///< Signed integer, 4 byte
-typedef int64_impl        int64;   ///< Signed integer, 8 byte
-typedef unsigned char     uint8;   ///< Unsigned integer, 1 byte
-typedef unsigned short    uint16;  ///< Unsigned integer, 2 byte
-typedef unsigned int      uint32;  ///< Unsigned integer, 4 byte
-typedef uint64_impl       uint64;  ///< Unsigned integer, 8 byte
+using int8 = signed char; ///< Signed integer, 1 byte
+using int16 = signed short; ///< Signed integer, 2 byte
+using int32 = signed int; ///< Signed integer, 4 byte
+using int64 = int64_impl; ///< Signed integer, 8 byte
+using uint8 = unsigned char; ///< Unsigned integer, 1 byte
+using uint16 = unsigned short ; ///< Unsigned integer, 2 byte
+using uint32 = unsigned int; ///< Unsigned integer, 4 byte
+using uint64 = uint64_impl ; ///< Unsigned integer, 8 byte
 
 ///	@brief  Stores a text.
 ///
 /// A text is stored in a simple character buffer. Texts buffer can be
 /// greater than the number of stored characters in them.
 struct DLL_ODDLPARSER_EXPORT Text {
-    size_t m_capacity;  ///< The capacity of the text.
-    size_t m_len;       ///< The length of the text.
-    char *m_buffer;     ///< The buffer with the text.
+    size_t m_capacity; ///< The capacity of the text.
+    size_t m_len; ///< The length of the text.
+    char *m_buffer; ///< The buffer with the text.
 
     ///	@brief  The constructor with a given text buffer.
     /// @param  buffer      [in] The buffer.
     /// @param  numChars    [in] The number of characters in the buffer.
-    Text( const char *buffer, size_t numChars );
+    Text(const char *buffer, size_t numChars);
 
     ///	@brief  The destructor.
     ~Text();
@@ -120,55 +120,54 @@ struct DLL_ODDLPARSER_EXPORT Text {
     ///	@brief  Set a new text.
     /// @param  buffer      [in] The buffer.
     /// @param  numChars    [in] The number of characters in the buffer.
-    void set( const char *buffer, size_t numChars );
+    void set(const char *buffer, size_t numChars);
 
     ///	@brief  The compare operator for std::strings.
-    bool operator == ( const std::string &name ) const;
+    bool operator==(const std::string &name) const;
 
     ///	@brief  The compare operator for Texts.
-    bool operator == ( const Text &rhs ) const;
+    bool operator==(const Text &rhs) const;
 
 private:
-    Text( const Text & ) ddl_no_copy;
-    Text &operator = ( const Text & ) ddl_no_copy;
+    Text(const Text &) ddl_no_copy;
+    Text &operator=(const Text &) ddl_no_copy;
 };
 
 ///	@brief  Description of the type of a name.
 enum NameType {
     GlobalName, ///< Name is global.
-    LocalName   ///< Name is local.
+    LocalName ///< Name is local.
 };
 
 ///	@brief  Stores an OpenDDL-specific name
 struct DLL_ODDLPARSER_EXPORT Name {
-    NameType    m_type; ///< The type of the name ( @see NameType ).
-    Text        *m_id;  ///< The id.
+    NameType m_type; ///< The type of the name ( @see NameType ).
+    Text *m_id; ///< The id.
 
     ///	@brief  The constructor with the type and the id.
     ///	@param  type    [in] The name type.
     ///	@param  id      [in] The id.
-    Name( NameType type, Text *id );
-    Name( const Name &name );
+    Name(NameType type, Text *id);
+    Name(const Name &name);
     ///	@brief  The destructor.
     ~Name();
 
 private:
-
-    Name &operator = ( const Name& ) ddl_no_copy;
+    Name &operator=(const Name &) ddl_no_copy;
 };
 
 ///	@brief  Stores a bundle of references.
 struct DLL_ODDLPARSER_EXPORT Reference {
-    size_t   m_numRefs;         ///< The number of stored references.
-    Name   **m_referencedName;  ///< The reference names.
+    size_t m_numRefs; ///< The number of stored references.
+    Name **m_referencedName; ///< The reference names.
 
     ///	@brief  The default constructor.
     Reference();
-    Reference( const Reference &ref );
+    Reference(const Reference &ref);
     ///	@brief  The constructor with an array of ref names.
     /// @param  numrefs     [in] The number of ref names.
     /// @param  names       [in] The ref names.
-    Reference( size_t numrefs, Name **names );
+    Reference(size_t numrefs, Name **names);
 
     ///	@brief  The destructor.
     ~Reference();
@@ -178,38 +177,38 @@ struct DLL_ODDLPARSER_EXPORT Reference {
     size_t sizeInBytes();
 
 private:
-    Reference &operator = ( const Reference & ) ddl_no_copy;
+    Reference &operator=(const Reference &) ddl_no_copy;
 };
 
 ///	@brief  Stores a property list.
 struct DLL_ODDLPARSER_EXPORT Property {
-    Text       *m_key;      ///< The identifier / key of the property.
-    Value      *m_value;    ///< The value assigned to its key / id ( ddl_nullptr if none ).
-    Reference  *m_ref;      ///< References assigned to its key / id ( ddl_nullptr if none ).
-    Property   *m_next;     ///< The next property ( ddl_nullptr if none ).
+    Text *m_key; ///< The identifier / key of the property.
+    Value *m_value; ///< The value assigned to its key / id ( ddl_nullptr if none ).
+    Reference *m_ref; ///< References assigned to its key / id ( ddl_nullptr if none ).
+    Property *m_next; ///< The next property ( ddl_nullptr if none ).
 
     ///	@brief  The default constructor.
     Property();
 
     ///	@brief  The constructor for initialization.
     /// @param  id      [in] The identifier
-    Property( Text *id );
+    Property(Text *id);
 
     ///	@brief  The destructor.
     ~Property();
 
 private:
-    Property( const Property & ) ddl_no_copy;
-    Property &operator = ( const Property & ) ddl_no_copy;
+    Property(const Property &) ddl_no_copy;
+    Property &operator=(const Property &) ddl_no_copy;
 };
 
 ///	@brief  Stores a data array list.
 struct DLL_ODDLPARSER_EXPORT DataArrayList {
-    size_t         m_numItems;  ///< The number of items in the list.
-    Value         *m_dataList;  ///< The data list ( a Value ).
-    DataArrayList *m_next;      ///< The next data array list ( ddl_nullptr if last ).
-    Reference     *m_refs;
-    size_t         m_numRefs;
+    size_t m_numItems; ///< The number of items in the list.
+    Value *m_dataList; ///< The data list ( a Value ).
+    DataArrayList *m_next; ///< The next data array list ( ddl_nullptr if last ).
+    Reference *m_refs;
+    size_t m_numRefs;
 
     ///	@brief  The default constructor for initialization.
     DataArrayList();
@@ -221,13 +220,13 @@ struct DLL_ODDLPARSER_EXPORT DataArrayList {
     size_t size();
 
 private:
-    DataArrayList( const DataArrayList & ) ddl_no_copy;
-    DataArrayList &operator = ( const DataArrayList & ) ddl_no_copy;
+    DataArrayList(const DataArrayList &) ddl_no_copy;
+    DataArrayList &operator=(const DataArrayList &) ddl_no_copy;
 };
 
 ///	@brief  Stores the context of a parsed OpenDDL declaration.
 struct DLL_ODDLPARSER_EXPORT Context {
-    DDLNode *m_root;    ///< The root node of the OpenDDL node tree.
+    DDLNode *m_root; ///< The root node of the OpenDDL node tree.
 
     ///	@brief  Constructor for initialization.
     Context();
@@ -239,8 +238,8 @@ struct DLL_ODDLPARSER_EXPORT Context {
     void clear();
 
 private:
-    Context( const Context & ) ddl_no_copy;
-    Context &operator = ( const Context & ) ddl_no_copy;
+    Context(const Context &) ddl_no_copy;
+    Context &operator=(const Context &) ddl_no_copy;
 };
 
 END_ODDLPARSER_NS
diff --git a/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/OpenDDLExport.h b/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/OpenDDLExport.h
index 020d662a0..945253594 100644
--- a/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/OpenDDLExport.h
+++ b/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/OpenDDLExport.h
@@ -1,7 +1,7 @@
 /*-----------------------------------------------------------------------------------------------
 The MIT License (MIT)
 
-Copyright (c) 2014-2015 Kim Kulling
+Copyright (c) 2014-2020 Kim Kulling
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
@@ -40,7 +40,7 @@ class IOStreamBase;
 class DLL_ODDLPARSER_EXPORT OpenDDLExport {
 public:
     ///	@brief  The class constructor
-    OpenDDLExport( IOStreamBase *stream = ddl_nullptr );
+    OpenDDLExport(IOStreamBase *stream = nullptr);
 
     ///	@brief  The class destructor.
     ~OpenDDLExport();
@@ -49,29 +49,29 @@ public:
     /// @param  ctx         [in] Pointer to the context.
     /// @param  filename    [in] The filename for the export.
     /// @return True in case of success, false in case of an error.
-    bool exportContext( Context *ctx, const std::string &filename );
+    bool exportContext(Context *ctx, const std::string &filename);
 
     ///	@brief  Handles a node export.
     /// @param  node        [in] The node to handle with.
     /// @return True in case of success, false in case of an error.
-    bool handleNode( DDLNode *node );
+    bool handleNode(DDLNode *node);
 
     ///	@brief  Writes the statement to the stream.
     /// @param  statement   [in]  The content to write.
     /// @return True in case of success, false in case of an error.
-    bool writeToStream( const std::string &statement );
+    bool writeToStream(const std::string &statement);
 
 protected:
-    bool writeNode( DDLNode *node, std::string &statement );
-    bool writeNodeHeader( DDLNode *node, std::string &statement );
-    bool writeProperties( DDLNode *node, std::string &statement );
-    bool writeValueType( Value::ValueType type, size_t numItems, std::string &statement );
-    bool writeValue( Value *val, std::string &statement );
-    bool writeValueArray( DataArrayList *al, std::string &statement );
+    bool writeNode(DDLNode *node, std::string &statement);
+    bool writeNodeHeader(DDLNode *node, std::string &statement);
+    bool writeProperties(DDLNode *node, std::string &statement);
+    bool writeValueType(Value::ValueType type, size_t numItems, std::string &statement);
+    bool writeValue(Value *val, std::string &statement);
+    bool writeValueArray(DataArrayList *al, std::string &statement);
 
 private:
-    OpenDDLExport( const OpenDDLExport & ) ddl_no_copy;
-    OpenDDLExport &operator = ( const OpenDDLExport  & ) ddl_no_copy;
+    OpenDDLExport(const OpenDDLExport &) ddl_no_copy;
+    OpenDDLExport &operator=(const OpenDDLExport &) ddl_no_copy;
 
 private:
     IOStreamBase *m_stream;
diff --git a/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/OpenDDLParser.h b/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/OpenDDLParser.h
index ef7f3a72e..3fbb4b6af 100644
--- a/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/OpenDDLParser.h
+++ b/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/OpenDDLParser.h
@@ -1,7 +1,7 @@
 /*-----------------------------------------------------------------------------------------------
 The MIT License (MIT)
 
-Copyright (c) 2014-2015 Kim Kulling
+Copyright (c) 2014-2020 Kim Kulling
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
@@ -22,13 +22,14 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 -----------------------------------------------------------------------------------------------*/
 #pragma once
 
-#include <openddlparser/OpenDDLCommon.h>
 #include <openddlparser/DDLNode.h>
+#include <openddlparser/OpenDDLCommon.h>
 #include <openddlparser/OpenDDLParserUtils.h>
 #include <openddlparser/Value.h>
 
-#include <vector>
 #include <string>
+#include <vector>
+#include <functional>
 
 BEGIN_ODDLPARSER_NS
 
@@ -39,14 +40,9 @@ struct Identifier;
 struct Reference;
 struct Property;
 
-template<class T>
-inline
-bool isEmbeddedCommentOpenTag( T *in, T *end ) {
-    if ( in == end ) {
-        return false;
-    }
-
-    if ( in == '/' && in+1 == '*' ) {
+template <class T>
+inline bool isEmbeddedCommentOpenTag(T *in, T *end) {
+    if (in == '/' && in + 1 == '*') {
         return true;
     }
 
@@ -58,11 +54,10 @@ bool isEmbeddedCommentOpenTag( T *in, T *end ) {
 /// @param  end     [in] The end position in the buffer.
 ///	@return Pointer showing to the next token or the end of the buffer.
 ///	@detail Will not increase buffer when already a valid buffer was found.
-template<class T>
-inline
-T *lookForNextToken( T *in, T *end ) {
-    while( ( in != end ) && ( isSpace( *in ) || isNewLine( *in ) || ',' == *in ) ) {
-        in++;
+template <class T>
+inline T *lookForNextToken(T *in, T *end) {
+    while ((in != end) && (isSpace(*in) || isNewLine(*in) || ',' == *in)) {
+        ++in;
     }
     return in;
 }
@@ -72,26 +67,25 @@ T *lookForNextToken( T *in, T *end ) {
 /// @param  end     [in] The end position in the buffer.
 ///	@return Pointer showing to the next token or the end of the buffer.
 ///	@detail Will  increase buffer by a minimum of one.
-template<class T>
-inline
-T *getNextToken( T *in, T *end ) {
-    T *tmp( in );
-    in = lookForNextToken( in, end );
-    if( tmp == in ) {
-        in++;
+template <class T>
+inline T *getNextToken(T *in, T *end) {
+    T *tmp(in);
+    in = lookForNextToken(in, end);
+    if (tmp == in) {
+        ++in;
     }
     return in;
 }
 
 ///	@brief  Defines the log severity.
 enum LogSeverity {
-    ddl_debug_msg = 0,  ///< Debug message, for debugging
-    ddl_info_msg,       ///< Info messages, normal mode
-    ddl_warn_msg,       ///< Parser warnings
-    ddl_error_msg       ///< Parser errors
+    ddl_debug_msg = 0, ///< Debug message, for debugging
+    ddl_info_msg, ///< Info messages, normal mode
+    ddl_warn_msg, ///< Parser warnings
+    ddl_error_msg ///< Parser errors
 };
 
-DLL_ODDLPARSER_EXPORT const char *getTypeToken( Value::ValueType  type );
+DLL_ODDLPARSER_EXPORT const char *getTypeToken(Value::ValueType type);
 
 //-------------------------------------------------------------------------------------------------
 ///	@class		OpenDDLParser
@@ -104,8 +98,8 @@ DLL_ODDLPARSER_EXPORT const char *getTypeToken( Value::ValueType  type );
 //-------------------------------------------------------------------------------------------------
 class DLL_ODDLPARSER_EXPORT OpenDDLParser {
 public:
-    ///	@brief  The log callback function pointer.
-    typedef void( *logCallback )( LogSeverity severity, const std::string &msg );
+    ///	@brief  The log callback function.
+    typedef std::function<void (LogSeverity severity, const std::string &msg)> logCallback;
 
 public:
     ///	@brief  The default class constructor.
@@ -114,27 +108,32 @@ public:
     ///	@brief  The class constructor.
     ///	@param  buffer      [in] The buffer
     ///	@param  len         [in] Size of the buffer
-    OpenDDLParser( const char *buffer, size_t len );
+    OpenDDLParser(const char *buffer, size_t len);
 
     ///	@brief  The class destructor.
     ~OpenDDLParser();
 
     ///	@brief  Setter for an own log callback function.
     /// @param  callback    [in] The own callback.
-    void setLogCallback( logCallback callback );
+    void setLogCallback(logCallback callback);
 
     ///	@brief  Getter for the log callback.
     /// @return The current log callback.
     logCallback getLogCallback() const;
 
+    /// @brief  A default log callback that writes to a FILE.
+    /// @param  destination [in] Output stream. NULL will use stderr.
+    /// @return A callback that you can pass to setLogCallback.
+    static logCallback StdLogCallback(FILE *destination = nullptr);
+
     ///	@brief  Assigns a new buffer to parse.
     ///	@param  buffer      [in] The buffer
     ///	@param  len         [in] Size of the buffer
-    void setBuffer( const char *buffer, size_t len );
+    void setBuffer(const char *buffer, size_t len);
 
     ///	@brief  Assigns a new buffer to parse.
     /// @param  buffer      [in] The buffer as a std::vector.
-    void setBuffer( const std::vector<char> &buffer );
+    void setBuffer(const std::vector<char> &buffer);
 
     ///	@brief  Returns the buffer pointer.
     /// @return The buffer pointer.
@@ -147,12 +146,15 @@ public:
     ///	@brief  Clears all parser data, including buffer and active context.
     void clear();
 
+    bool validate();
+
     ///	@brief  Starts the parsing of the OpenDDL-file.
     /// @return True in case of success, false in case of an error.
     /// @remark In case of errors check log.
     bool parse();
 
-    bool exportContext( Context *ctx, const std::string &filename );
+    
+    bool exportContext(Context *ctx, const std::string &filename);
 
     ///	@brief  Returns the root node.
     /// @return The root node.
@@ -163,39 +165,42 @@ public:
     Context *getContext() const;
 
 public: // parser helpers
-    char *parseNextNode( char *current, char *end );
-    char *parseHeader( char *in, char *end );
-    char *parseStructure( char *in, char *end );
-    char *parseStructureBody( char *in, char *end, bool &error );
-    void pushNode( DDLNode *node );
+    char *parseNextNode(char *current, char *end);
+    char *parseHeader(char *in, char *end);
+    char *parseStructure(char *in, char *end);
+    char *parseStructureBody(char *in, char *end, bool &error);
+    void pushNode(DDLNode *node);
     DDLNode *popNode();
     DDLNode *top();
-    static void normalizeBuffer( std::vector<char> &buffer );
-    static char *parseName( char *in, char *end, Name **name );
-    static char *parseIdentifier( char *in, char *end, Text **id );
-    static char *parsePrimitiveDataType( char *in, char *end, Value::ValueType &type, size_t &len );
-    static char *parseReference( char *in, char *end, std::vector<Name*> &names );
-    static char *parseBooleanLiteral( char *in, char *end, Value **boolean );
-    static char *parseIntegerLiteral( char *in, char *end, Value **integer, Value::ValueType integerType = Value::ddl_int32 );
-    static char *parseFloatingLiteral( char *in, char *end, Value **floating, Value::ValueType floatType= Value::ddl_float );
-    static char *parseStringLiteral( char *in, char *end, Value **stringData );
-    static char *parseHexaLiteral( char *in, char *end, Value **data );
-    static char *parseProperty( char *in, char *end, Property **prop );
-    static char *parseDataList( char *in, char *end, Value::ValueType type, Value **data, size_t &numValues, Reference **refs, size_t &numRefs );
-    static char *parseDataArrayList( char *in, char *end, Value::ValueType type, DataArrayList **dataList );
+    static void normalizeBuffer(std::vector<char> &buffer);
+    static char *parseName(char *in, char *end, Name **name);
+    static char *parseIdentifier(char *in, char *end, Text **id);
+    static char *parsePrimitiveDataType(char *in, char *end, Value::ValueType &type, size_t &len);
+    static char *parseReference(char *in, char *end, std::vector<Name *> &names);
+    static char *parseBooleanLiteral(char *in, char *end, Value **boolean);
+    static char *parseIntegerLiteral(char *in, char *end, Value **integer, Value::ValueType integerType = Value::ValueType::ddl_int32);
+    static char *parseFloatingLiteral(char *in, char *end, Value **floating, Value::ValueType floatType = Value::ValueType::ddl_float);
+    static char *parseStringLiteral(char *in, char *end, Value **stringData);
+    static char *parseHexaLiteral(char *in, char *end, Value **data);
+    static char *parseProperty(char *in, char *end, Property **prop);
+    static char *parseDataList(char *in, char *end, Value::ValueType type, Value **data, size_t &numValues, Reference **refs, size_t &numRefs);
+    static char *parseDataArrayList(char *in, char *end, Value::ValueType type, DataArrayList **dataList);
     static const char *getVersion();
 
 private:
-    OpenDDLParser( const OpenDDLParser & ) ddl_no_copy;
-    OpenDDLParser &operator = ( const OpenDDLParser & ) ddl_no_copy;
+    OpenDDLParser(const OpenDDLParser &) ddl_no_copy;
+    OpenDDLParser &operator=(const OpenDDLParser &) ddl_no_copy;
 
 private:
     logCallback m_logCallback;
     std::vector<char> m_buffer;
 
-    typedef std::vector<DDLNode*> DDLNodeStack;
+    typedef std::vector<DDLNode *> DDLNodeStack;
     DDLNodeStack m_stack;
     Context *m_context;
+
+    ///	@brief  Callback for StdLogCallback(). Not meant to be called directly.
+    static void logToStream (FILE *, LogSeverity, const std::string &);
 };
 
 END_ODDLPARSER_NS
diff --git a/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/OpenDDLParserUtils.h b/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/OpenDDLParserUtils.h
index f0762ac67..42ad675f8 100644
--- a/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/OpenDDLParserUtils.h
+++ b/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/OpenDDLParserUtils.h
@@ -1,7 +1,7 @@
 /*-----------------------------------------------------------------------------------------------
 The MIT License (MIT)
 
-Copyright (c) 2014-2015 Kim Kulling
+Copyright (c) 2014-2020 Kim Kulling
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
@@ -26,64 +26,319 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 BEGIN_ODDLPARSER_NS
 
-template<class T>
-inline
-bool isUpperCase( T in ) {
-    return ( in >= 'A' && in <= 'Z' );
+template <class T>
+inline bool isUpperCase(T in) {
+    return (in >= 'A' && in <= 'Z');
 }
 
-template<class T>
-inline
-bool isLowerCase( T in ) {
-    return ( in >= 'a' && in <= 'z' );
+template <class T>
+inline bool isLowerCase(T in) {
+    return (in >= 'a' && in <= 'z');
 }
 
-template<class T>
-inline
-bool isSpace( const T in ) {
-    return ( ' ' == in || '\t' == in );
+template <class T>
+inline bool isSpace(const T in) {
+    return (' ' == in || '\t' == in);
 }
 
-template<class T>
-inline
-bool isNewLine( const T in ) {
-    return ( '\n' == in || ( '\r' == in ) );
+template <class T>
+inline bool isNewLine(const T in) {
+    return ('\n' == in || ('\r' == in));
 }
 
-template<class T>
-inline
-bool isSeparator( T in ) {
-    if( isSpace( in ) || ',' == in || '{' == in || '}' == in || '[' == in || '(' == in || ')' == in ) {
+template <class T>
+inline bool isSeparator(T in) {
+    if (isSpace(in) || ',' == in || '{' == in || '}' == in || '[' == in || '(' == in || ')' == in) {
         return true;
     }
     return false;
 }
 
-template<class T>
-inline
-bool isNumeric( const T in ) {
-    return ( in >= '0' && in <= '9' );
+static const unsigned char chartype_table[256] = {
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0, // 0-15
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0, // 16-31
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0, // 32-47
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0, // 48-63
+
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0, // 64-79
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0, // 80-95
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0, // 96-111
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0, // 112-127
+
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0, // > 127
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+};
+
+template <class T>
+inline bool isNumeric(const T in) {
+    size_t idx = static_cast<size_t>(in);
+    return idx < sizeof(chartype_table) && (chartype_table[idx] == 1);
 }
 
-template<class T>
-inline
-bool isNotEndOfToken( T *in, T *end ) {
-    return ( '}' != *in && ',' != *in && !isSpace( *in ) && ')' != *in && in != end );
+template <class T>
+inline bool isNotEndOfToken(T *in, T *end) {
+    return ('}' != *in && ',' != *in && !isSpace(*in) && ')' != *in && in != end);
 }
 
-template<class T>
-inline
-bool isInteger( T *in, T *end ) {
-    if( in != end ) {
-        if( *in == '-' ) {
+template <class T>
+inline bool isInteger(T *in, T *end) {
+    if (in != end) {
+        if (*in == '-') {
             ++in;
         }
     }
 
-    bool result( false );
-    while( isNotEndOfToken( in, end ) ) {
-        result = isNumeric( *in );
-        if( !result ) {
+    bool result(false);
+    while (isNotEndOfToken(in, end)) {
+        result = isNumeric(*in);
+        if (!result) {
             break;
         }
         ++in;
@@ -92,40 +347,39 @@ bool isInteger( T *in, T *end ) {
     return result;
 }
 
-template<class T>
-inline
-bool isFloat( T *in, T *end ) {
-    if( in != end ) {
-        if( *in == '-' ) {
+template <class T>
+inline bool isFloat(T *in, T *end) {
+    if (in != end) {
+        if (*in == '-') {
             ++in;
         }
     }
 
     // check for <1>.0f
-    bool result( false );
-    while( isNotEndOfToken( in, end ) ) {
-        if( *in == '.' ) {
+    bool result(false);
+    while (isNotEndOfToken(in, end)) {
+        if (*in == '.') {
             result = true;
             break;
         }
-        result = isNumeric( *in );
-        if( !result ) {
+        result = isNumeric(*in);
+        if (!result) {
             return false;
         }
         ++in;
     }
 
     // check for 1<.>0f
-    if( *in == '.' ) {
+    if (*in == '.') {
         ++in;
     } else {
         return false;
     }
 
     // check for 1.<0>f
-    while( isNotEndOfToken( in, end ) ) {
-        result = isNumeric( *in );
-        if( !result ) {
+    while (isNotEndOfToken(in, end)) {
+        result = isNumeric(*in);
+        if (!result) {
             return false;
         }
         ++in;
@@ -134,24 +388,21 @@ bool isFloat( T *in, T *end ) {
     return result;
 }
 
-template<class T>
-inline
-bool isCharacter( const T in ) {
-    return ( ( in >= 'a' && in <= 'z' ) || ( in >= 'A' && in <= 'Z' ) );
+template <class T>
+inline bool isCharacter(const T in) {
+    return ((in >= 'a' && in <= 'z') || (in >= 'A' && in <= 'Z'));
 }
 
-template<class T>
-inline
-bool isStringLiteral( const T in ) {
-    return ( in == '\"' );
+template <class T>
+inline bool isStringLiteral(const T in) {
+    return (in == '\"');
 }
 
-template<class T>
-inline
-bool isHexLiteral( T *in, T *end ) {
-    if( *in == '0' ) {
-        if( in + 1 != end ) {
-            if( *( in + 1 ) == 'x' || *( in + 1 ) == 'X' ) {
+template <class T>
+inline bool isHexLiteral(T *in, T *end) {
+    if (*in == '0') {
+        if (in + 1 != end) {
+            if (*(in + 1) == 'x' || *(in + 1) == 'X') {
                 return true;
             }
         }
@@ -160,13 +411,12 @@ bool isHexLiteral( T *in, T *end ) {
     return false;
 }
 
-template<class T>
-inline
-bool isReference( T *in, T *end ) {
-    if( *in == 'r' ) {
-        if( *(in+1) == 'e' ) {
-            if( *(in+2) == 'f' ) {
-                if( ( in + 2 ) != end ) {
+template <class T>
+inline bool isReference(T *in, T *end) {
+    if (*in == 'r') {
+        if (*(in + 1) == 'e') {
+            if (*(in + 2) == 'f') {
+                if ((in + 2) != end) {
                     return true;
                 }
             }
@@ -176,16 +426,14 @@ bool isReference( T *in, T *end ) {
     return false;
 }
 
-template<class T>
-inline
-bool isEndofLine( const T in ) {
-    return ( '\n' == in );
+template <class T>
+inline bool isEndofLine(const T in) {
+    return ('\n' == in);
 }
 
-template<class T>
-inline
-static T *getNextSeparator( T *in, T *end ) {
-    while( !isSeparator( *in ) || in == end ) {
+template <class T>
+inline static T *getNextSeparator(T *in, T *end) {
+    while (!isSeparator(*in) || in == end) {
         ++in;
     }
     return in;
@@ -193,30 +441,28 @@ static T *getNextSeparator( T *in, T *end ) {
 
 static const int ErrorHex2Decimal = 9999999;
 
-inline
-int hex2Decimal( char in ) {
-    if( isNumeric( in ) ) {
-        return ( in - 48 );
+inline int hex2Decimal(char in) {
+    if (isNumeric(in)) {
+        return (in - 48);
     }
 
-    char hexCodeLower( 'a' ), hexCodeUpper( 'A' );
-    for( int i = 0; i<16; i++ ) {
-        if( in == hexCodeLower + i || in == hexCodeUpper + i ) {
-            return ( i+10 );
+    char hexCodeLower('a'), hexCodeUpper('A');
+    for (int i = 0; i < 16; i++) {
+        if (in == hexCodeLower + i || in == hexCodeUpper + i) {
+            return (i + 10);
         }
     }
 
     return ErrorHex2Decimal;
 }
 
-template<class T>
-inline
-bool isComment( T *in, T *end ) {
-    if ( *in=='/' ) {
-        if ( in+1!=end ) {
-            if ( *( in+1 )=='/' ) {
-                char *drive( ( in+2 ) );
-                if ( (isUpperCase<T>( *drive )||isLowerCase<T>( *drive ))&&*( drive+1 )=='/' )  {
+template <class T>
+inline bool isComment(T *in, T *end) {
+    if (*in == '/') {
+        if (in + 1 != end) {
+            if (*(in + 1) == '/') {
+                char *drive((in + 2));
+                if ((isUpperCase<T>(*drive) || isLowerCase<T>(*drive)) && *(drive + 1) == '/') {
                     return false;
                 } else {
                     return true;
@@ -228,9 +474,8 @@ bool isComment( T *in, T *end ) {
     return false;
 }
 
-template<class T>
-inline
-bool isCommentOpenTag(T *in, T *end ) {
+template <class T>
+inline bool isCommentOpenTag(T *in, T *end) {
     if (*in == '/') {
         if (in + 1 != end) {
             if (*(in + 1) == '*') {
@@ -242,9 +487,8 @@ bool isCommentOpenTag(T *in, T *end ) {
     return false;
 }
 
-template<class T>
-inline
-bool isCommentCloseTag(T *in, T *end) {
+template <class T>
+inline bool isCommentCloseTag(T *in, T *end) {
     if (*in == '*') {
         if (in + 1 != end) {
             if (*(in + 1) == '/') {
@@ -257,4 +501,3 @@ bool isCommentCloseTag(T *in, T *end) {
 }
 
 END_ODDLPARSER_NS
-
diff --git a/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/OpenDDLStream.h b/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/OpenDDLStream.h
index 93370da03..93bde5f7c 100644
--- a/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/OpenDDLStream.h
+++ b/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/OpenDDLStream.h
@@ -1,7 +1,7 @@
 /*-----------------------------------------------------------------------------------------------
 The MIT License (MIT)
 
-Copyright (c) 2014-2015 Kim Kulling
+Copyright (c) 2014-2020 Kim Kulling
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
@@ -38,7 +38,7 @@ public:
     /// @brief  The class destructor, virtual.
     virtual ~StreamFormatterBase();
 
-    /// @brief  Will format the sring and return the new formatted result.
+    /// @brief  Will format the string and return the new formatted result.
     /// @param  statement   [in] The string to reformat.
     /// @return The reformatted result.
     virtual std::string format(const std::string &statement);
@@ -52,7 +52,7 @@ class DLL_ODDLPARSER_EXPORT IOStreamBase {
 public:
     /// @brief  The class constructor with the formatter.
     /// @param  formatter   [in] The formatter to use.
-    explicit IOStreamBase(StreamFormatterBase *formatter = ddl_nullptr);
+    explicit IOStreamBase(StreamFormatterBase *formatter = nullptr);
 
     /// @brief  The class destructor, virtual.
     virtual ~IOStreamBase();
@@ -74,7 +74,7 @@ public:
     /// @param  sizeToRead  [in] The size to read in bytes.
     /// @param  statement   [out] The read statements.
     /// @return The bytes read from the stream.
-    virtual size_t read( size_t sizeToRead, std::string &statement );
+    virtual size_t read(size_t sizeToRead, std::string &statement);
 
     /// @brief  Will write a string into the stream.
     /// @param  statement  [in] The string to write.
diff --git a/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/TPoolAllocator.h b/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/TPoolAllocator.h
new file mode 100644
index 000000000..6076c7324
--- /dev/null
+++ b/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/TPoolAllocator.h
@@ -0,0 +1,226 @@
+/*-----------------------------------------------------------------------------------------------
+The MIT License (MIT)
+
+Copyright (c) 2014-2019 Kim Kulling
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+-----------------------------------------------------------------------------------------------*/
+#pragma once
+
+#include <openddlparser/OpenDDLCommon.h>
+#include <string>
+
+BEGIN_ODDLPARSER_NS
+
+//-------------------------------------------------------------------------------------------------
+///	@class		TPoolAllocator
+///	@ingroup	CPPCore
+///
+///	@brief  This class implements a simple pool-based allocation scheme.
+/// Initially you have to define its size. Each allocation will be done from this initially created
+/// pool. You have to release all pooled instances after the usage.
+/// This allocation scheme is fast and does no call any new-calls during the lifetime of the
+/// allocator.
+//-------------------------------------------------------------------------------------------------
+template <class T>
+class TPoolAllocator {
+public:
+    TPoolAllocator();
+    TPoolAllocator(size_t numItems);
+    ~TPoolAllocator();
+    T *alloc();
+    void release();
+    void reserve(size_t size);
+    void clear();
+    size_t capacity() const;
+    size_t reservedMem() const;
+    size_t freeMem() const;
+    void dumpAllocations(std::string &allocs);
+    void resize(size_t growSize);
+
+    CPPCORE_NONE_COPYING(TPoolAllocator)
+
+private:
+    struct Pool {
+        size_t m_poolsize;
+        T *m_pool;
+        size_t m_currentIdx;
+        Pool *m_next;
+
+        Pool() :
+                m_poolsize(0u), m_pool(nullptr), m_currentIdx(0u), m_next(nullptr) {
+            // empty
+        }
+
+        Pool(size_t numItems, Pool *prev) :
+                m_poolsize(numItems), m_pool(nullptr), m_currentIdx(0u), m_next(prev) {
+            m_pool = new T[m_poolsize];
+        }
+
+        ~Pool() {
+            delete[] m_pool;
+            m_pool = nullptr;
+        }
+
+        CPPCORE_NONE_COPYING(Pool)
+    };
+
+    Pool *getFreePool() {
+        Pool *current(m_freeList);
+        if (nullptr != m_freeList) {
+            m_freeList = m_freeList->m_next;
+        }
+        return current;
+    }
+
+    Pool *m_first;
+    Pool *m_current;
+    Pool *m_freeList;
+    size_t m_capacity;
+};
+
+template <class T>
+inline TPoolAllocator<T>::TPoolAllocator() :
+        m_first(nullptr), m_current(nullptr), m_freeList(nullptr), m_capacity(0L) {
+    // empty
+}
+
+template <class T>
+inline TPoolAllocator<T>::TPoolAllocator(size_t numItems) :
+        m_first(nullptr), m_current(nullptr), m_freeList(nullptr), m_capacity(0L) {
+    m_first = new Pool(numItems);
+    m_capacity += numItems;
+    m_current = m_first;
+}
+
+template <class T>
+inline TPoolAllocator<T>::~TPoolAllocator() {
+    clear();
+}
+
+template <class T>
+inline T *TPoolAllocator<T>::alloc() {
+    if (nullptr == m_current) {
+        return nullptr;
+    }
+
+    if (m_current->m_currentIdx == m_current->m_poolsize) {
+        resize(m_current->m_poolsize);
+    }
+
+    T *ptr(&m_current->m_pool[m_current->m_currentIdx]);
+    m_current->m_currentIdx++;
+
+    return ptr;
+}
+
+template <class T>
+inline void TPoolAllocator<T>::release() {
+    if (nullptr == m_current) {
+        return;
+    }
+
+    Pool *current(m_first);
+    while (nullptr != current) {
+        current->m_currentIdx = 0;
+        current = current->m_next;
+    }
+    m_freeList = m_first->m_next;
+    m_current = m_first;
+}
+
+template <class T>
+inline void TPoolAllocator<T>::reserve(size_t size) {
+    clear();
+
+    m_first = new Pool(size, nullptr);
+    m_current = m_first;
+
+    m_current->m_pool = new T[size];
+    m_current->m_poolsize = size;
+
+    m_capacity = size;
+}
+
+template <class T>
+inline void TPoolAllocator<T>::clear() {
+    if (nullptr == m_current) {
+        return;
+    }
+
+    Pool *next(m_first);
+    while (nullptr != next) {
+        Pool *current = next;
+        next = current->m_next;
+        delete current;
+    }
+    m_current = nullptr;
+    m_freeList = nullptr;
+}
+
+template <class T>
+inline size_t TPoolAllocator<T>::capacity() const {
+    return m_capacity;
+}
+
+template <class T>
+inline size_t TPoolAllocator<T>::reservedMem() const {
+    return m_capacity * sizeof(T);
+}
+
+template <class T>
+inline size_t TPoolAllocator<T>::freeMem() const {
+    if (nullptr == m_current) {
+        return 0L;
+    }
+
+    return (m_current->m_poolsize - m_current->m_currentIdx);
+}
+
+template <class T>
+inline void TPoolAllocator<T>::dumpAllocations(std::string &allocs) {
+    allocs.clear();
+    allocs += "Number allocations = ";
+    allocs += std::to_string(m_current->m_currentIdx);
+    allocs += "\n";
+}
+
+template <class T>
+inline void TPoolAllocator<T>::resize(size_t growSize) {
+    if (nullptr != m_current) {
+        if (growSize < m_current->m_poolsize) {
+            return;
+        }
+    }
+
+    if (nullptr == m_first) {
+        m_first = new Pool(growSize, nullptr);
+        m_current = m_first;
+        m_capacity += m_current->m_poolsize;
+    } else {
+        Pool *pool = getFreePool();
+        if (nullptr == pool) {
+            pool = new Pool(growSize, nullptr);
+            m_capacity += growSize;
+        }
+        m_current->m_next = pool;
+        m_current = m_current->m_next;
+    }
+}
+
+END_ODDLPARSER_NS
\ No newline at end of file
diff --git a/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/Value.h b/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/Value.h
index 77c6da06b..75af7816b 100644
--- a/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/Value.h
+++ b/Engine/lib/assimp/contrib/openddlparser/include/openddlparser/Value.h
@@ -1,7 +1,7 @@
 /*-----------------------------------------------------------------------------------------------
 The MIT License (MIT)
 
-Copyright (c) 2014-2015 Kim Kulling
+Copyright (c) 2014-2020 Kim Kulling
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
@@ -101,7 +101,7 @@ public:
     };
 
     ///	@brief  This enum describes the data type stored in the value.
-    enum ValueType {
+    enum class ValueType {
         ddl_none = -1,          ///< Nothing specified
         ddl_bool = 0,           ///< A boolean type
         ddl_int8,               ///< Integer type, 8 bytes
diff --git a/Engine/lib/assimp/contrib/poly2tri/README b/Engine/lib/assimp/contrib/poly2tri/README
index 2857e2983..883e9a581 100644
--- a/Engine/lib/assimp/contrib/poly2tri/README
+++ b/Engine/lib/assimp/contrib/poly2tri/README
@@ -1,4 +1,4 @@
-==================
+==================
 INSTALLATION GUIDE
 ==================
 
@@ -48,4 +48,4 @@ Examples:
   ./p2t nazca_monkey.dat 0 0 9
   
   ./p2t random 10 100 5.0
-  ./p2t random 1000 20000 0.025
\ No newline at end of file
+  ./p2t random 1000 20000 0.025
diff --git a/Engine/lib/assimp/contrib/poly2tri/poly2tri/common/shapes.cc b/Engine/lib/assimp/contrib/poly2tri/poly2tri/common/shapes.cc
index d0de13e64..c94e11c03 100644
--- a/Engine/lib/assimp/contrib/poly2tri/poly2tri/common/shapes.cc
+++ b/Engine/lib/assimp/contrib/poly2tri/poly2tri/common/shapes.cc
@@ -362,4 +362,4 @@ void Triangle::DebugPrint()
   cout << points_[2]->x << "," << points_[2]->y << endl;
 }
 
-}
\ No newline at end of file
+}
diff --git a/Engine/lib/assimp/contrib/poly2tri/poly2tri/common/shapes.h b/Engine/lib/assimp/contrib/poly2tri/poly2tri/common/shapes.h
index ac7389a2d..d3660f716 100644
--- a/Engine/lib/assimp/contrib/poly2tri/poly2tri/common/shapes.h
+++ b/Engine/lib/assimp/contrib/poly2tri/poly2tri/common/shapes.h
@@ -324,4 +324,4 @@ inline void Triangle::IsInterior(bool b)
 
 }
 
-#endif
\ No newline at end of file
+#endif
diff --git a/Engine/lib/assimp/contrib/poly2tri/poly2tri/poly2tri.h b/Engine/lib/assimp/contrib/poly2tri/poly2tri/poly2tri.h
index 29a08d052..ba5cc159e 100644
--- a/Engine/lib/assimp/contrib/poly2tri/poly2tri/poly2tri.h
+++ b/Engine/lib/assimp/contrib/poly2tri/poly2tri/poly2tri.h
@@ -35,4 +35,4 @@
 #include "common/shapes.h"
 #include "sweep/cdt.h"
 
-#endif
\ No newline at end of file
+#endif
diff --git a/Engine/lib/assimp/contrib/poly2tri/poly2tri/sweep/advancing_front.cc b/Engine/lib/assimp/contrib/poly2tri/poly2tri/sweep/advancing_front.cc
index 38723beef..9739babce 100644
--- a/Engine/lib/assimp/contrib/poly2tri/poly2tri/sweep/advancing_front.cc
+++ b/Engine/lib/assimp/contrib/poly2tri/poly2tri/sweep/advancing_front.cc
@@ -105,4 +105,4 @@ AdvancingFront::~AdvancingFront()
 {
 }
 
-}
\ No newline at end of file
+}
diff --git a/Engine/lib/assimp/contrib/poly2tri/poly2tri/sweep/advancing_front.h b/Engine/lib/assimp/contrib/poly2tri/poly2tri/sweep/advancing_front.h
index 645dcec97..3bfec5368 100644
--- a/Engine/lib/assimp/contrib/poly2tri/poly2tri/sweep/advancing_front.h
+++ b/Engine/lib/assimp/contrib/poly2tri/poly2tri/sweep/advancing_front.h
@@ -115,4 +115,4 @@ inline void AdvancingFront::set_search(Node* node)
 
 }
 
-#endif
\ No newline at end of file
+#endif
diff --git a/Engine/lib/assimp/contrib/poly2tri/poly2tri/sweep/cdt.cc b/Engine/lib/assimp/contrib/poly2tri/poly2tri/sweep/cdt.cc
index 09d088ae3..b79f5a8de 100644
--- a/Engine/lib/assimp/contrib/poly2tri/poly2tri/sweep/cdt.cc
+++ b/Engine/lib/assimp/contrib/poly2tri/poly2tri/sweep/cdt.cc
@@ -68,4 +68,4 @@ CDT::~CDT()
   delete sweep_;
 }
 
-}
\ No newline at end of file
+}
diff --git a/Engine/lib/assimp/contrib/poly2tri/poly2tri/sweep/cdt.h b/Engine/lib/assimp/contrib/poly2tri/poly2tri/sweep/cdt.h
index ea3286d9a..4a9a292d3 100644
--- a/Engine/lib/assimp/contrib/poly2tri/poly2tri/sweep/cdt.h
+++ b/Engine/lib/assimp/contrib/poly2tri/poly2tri/sweep/cdt.h
@@ -102,4 +102,4 @@ public:
 
 }
 
-#endif
\ No newline at end of file
+#endif
diff --git a/Engine/lib/assimp/contrib/poly2tri/poly2tri/sweep/sweep.cc b/Engine/lib/assimp/contrib/poly2tri/poly2tri/sweep/sweep.cc
index 826905ceb..8e3d794c0 100644
--- a/Engine/lib/assimp/contrib/poly2tri/poly2tri/sweep/sweep.cc
+++ b/Engine/lib/assimp/contrib/poly2tri/poly2tri/sweep/sweep.cc
@@ -36,6 +36,11 @@
 
 namespace p2t {
 
+#ifdef _MSC_VER
+#    pragma warning(push)
+#    pragma warning( disable : 4702 )
+#endif // _MSC_VER
+
 // Triangulate simple polygon with holes
 void Sweep::Triangulate(SweepContext& tcx)
 {
@@ -52,8 +57,8 @@ void Sweep::SweepPoints(SweepContext& tcx)
   for (size_t i = 1; i < tcx.point_count(); i++) {
     Point& point = *tcx.GetPoint(i);
     Node* node = &PointEvent(tcx, point);
-    for (unsigned int i = 0; i < point.edge_list.size(); i++) {
-      EdgeEvent(tcx, point.edge_list[i], node);
+    for (unsigned int ii = 0; ii < point.edge_list.size(); ii++) {
+      EdgeEvent(tcx, point.edge_list[ii], node);
     }
   }
 }
@@ -124,7 +129,7 @@ void Sweep::EdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle* triangl
       EdgeEvent( tcx, ep, *p1, triangle, *p1 );
     } else {
 	  // ASSIMP_CHANGE (aramis_acg)
-      std::runtime_error("EdgeEvent - collinear points not supported");
+      throw std::runtime_error("EdgeEvent - collinear points not supported");
     }
     return;
   }
@@ -795,5 +800,8 @@ Sweep::~Sweep() {
 
 }
 
-}
+#ifdef _MSC_VER
+#    pragma warning( pop )
+#endif // _MSC_VER
 
+}
diff --git a/Engine/lib/assimp/contrib/poly2tri/poly2tri/sweep/sweep.h b/Engine/lib/assimp/contrib/poly2tri/poly2tri/sweep/sweep.h
index 33e34a714..ad429fd96 100644
--- a/Engine/lib/assimp/contrib/poly2tri/poly2tri/sweep/sweep.h
+++ b/Engine/lib/assimp/contrib/poly2tri/poly2tri/sweep/sweep.h
@@ -282,4 +282,4 @@ private:
 
 }
 
-#endif
\ No newline at end of file
+#endif
diff --git a/Engine/lib/assimp/contrib/pugixml/CMakeLists.txt b/Engine/lib/assimp/contrib/pugixml/CMakeLists.txt
new file mode 100644
index 000000000..af6b577e6
--- /dev/null
+++ b/Engine/lib/assimp/contrib/pugixml/CMakeLists.txt
@@ -0,0 +1,87 @@
+cmake_minimum_required(VERSION 3.10)
+
+project(pugixml)
+
+option(BUILD_SHARED_LIBS "Build shared instead of static library" OFF)
+option(BUILD_TESTS "Build tests" OFF)
+option(BUILD_PKGCONFIG "Build in PKGCONFIG mode" OFF)
+
+set(BUILD_DEFINES "" CACHE STRING "Build defines")
+
+if(MSVC)
+	option(STATIC_CRT "Use static CRT libraries" OFF)
+
+	# Rewrite command line flags to use /MT if necessary
+	if(STATIC_CRT)
+		foreach(flag_var
+				CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
+				CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+			if(${flag_var} MATCHES "/MD")
+				string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
+			endif(${flag_var} MATCHES "/MD")
+		endforeach(flag_var)
+	endif()
+endif()
+
+# Pre-defines standard install locations on *nix systems.
+include(GNUInstallDirs)
+mark_as_advanced(CLEAR CMAKE_INSTALL_LIBDIR CMAKE_INSTALL_INCLUDEDIR)
+
+set(HEADERS src/pugixml.hpp src/pugiconfig.hpp)
+set(SOURCES src/pugixml.cpp)
+
+if(DEFINED BUILD_DEFINES)
+	foreach(DEFINE ${BUILD_DEFINES})
+		add_definitions("-D" ${DEFINE})
+	endforeach()
+endif()
+#message(pugixml"   "${BUILD_SHARED_LIBS})
+#if(BUILD_SHARED_LIBS)
+#	add_library(pugixml SHARED ${HEADERS} ${SOURCES})
+#else()
+	add_library(pugixml STATIC ${HEADERS} ${SOURCES})
+#endif()
+
+# Export symbols for shared library builds
+if(BUILD_SHARED_LIBS AND MSVC)
+	target_compile_definitions(pugixml PRIVATE "PUGIXML_API=__declspec(dllexport)")
+endif()
+
+# Enable C++11 long long for compilers that are capable of it
+if(NOT ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} STRLESS 3.1 AND ";${CMAKE_CXX_COMPILE_FEATURES};" MATCHES ";cxx_long_long_type;")
+	target_compile_features(pugixml PUBLIC cxx_long_long_type)
+endif()
+
+set_target_properties(pugixml PROPERTIES VERSION 1.9 SOVERSION 1)
+get_target_property(PUGIXML_VERSION_STRING pugixml VERSION)
+
+if(BUILD_PKGCONFIG)
+	# Install library into its own directory under LIBDIR
+	set(INSTALL_SUFFIX /pugixml-${PUGIXML_VERSION_STRING})
+endif()
+
+target_include_directories(pugixml PUBLIC
+	$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/src>
+	$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}${INSTALL_SUFFIX}>)
+
+install(TARGETS pugixml EXPORT pugixml-config
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}${INSTALL_SUFFIX}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}${INSTALL_SUFFIX}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+install(FILES ${HEADERS} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}${INSTALL_SUFFIX})
+install(EXPORT pugixml-config DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/pugixml)
+
+if(BUILD_PKGCONFIG)
+	configure_file(scripts/pugixml.pc.in ${PROJECT_BINARY_DIR}/pugixml.pc @ONLY)
+	install(FILES ${PROJECT_BINARY_DIR}/pugixml.pc DESTINATION ${CMAKE_INSTALL_PREFIX}/lib/pkgconfig)
+endif()
+
+if(BUILD_TESTS)
+	file(GLOB TEST_SOURCES tests/*.cpp)
+	file(GLOB FUZZ_SOURCES tests/fuzz_*.cpp)
+	list(REMOVE_ITEM TEST_SOURCES ${FUZZ_SOURCES})
+
+	add_executable(check ${TEST_SOURCES})
+	target_link_libraries(check pugixml)
+	add_custom_command(TARGET check POST_BUILD COMMAND check WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
+endif()
diff --git a/Engine/lib/assimp/contrib/pugixml/contrib/foreach.hpp b/Engine/lib/assimp/contrib/pugixml/contrib/foreach.hpp
new file mode 100644
index 000000000..c42315194
--- /dev/null
+++ b/Engine/lib/assimp/contrib/pugixml/contrib/foreach.hpp
@@ -0,0 +1,63 @@
+/*
+ * Boost.Foreach support for pugixml classes.
+ * This file is provided to the public domain.
+ * Written by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
+ */
+
+#ifndef HEADER_PUGIXML_FOREACH_HPP
+#define HEADER_PUGIXML_FOREACH_HPP
+
+#include <boost/range/iterator.hpp>
+
+#include "pugixml.hpp"
+
+/*
+ * These types add support for BOOST_FOREACH macro to xml_node and xml_document classes (child iteration only).
+ * Example usage:
+ * BOOST_FOREACH(xml_node n, doc) {}
+ */
+
+namespace boost
+{
+	template<> struct range_mutable_iterator<pugi::xml_node>
+	{
+		typedef pugi::xml_node::iterator type;
+	};
+
+	template<> struct range_const_iterator<pugi::xml_node>
+	{
+		typedef pugi::xml_node::iterator type;
+	};
+
+	template<> struct range_mutable_iterator<pugi::xml_document>
+	{
+		typedef pugi::xml_document::iterator type;
+	};
+
+	template<> struct range_const_iterator<pugi::xml_document>
+	{
+		typedef pugi::xml_document::iterator type;
+	};
+}
+
+/*
+ * These types add support for BOOST_FOREACH macro to xml_node and xml_document classes (child/attribute iteration).
+ * Example usage:
+ * BOOST_FOREACH(xml_node n, children(doc)) {}
+ * BOOST_FOREACH(xml_node n, attributes(doc)) {}
+ */
+
+namespace pugi
+{
+	inline xml_object_range<xml_node_iterator> children(const pugi::xml_node& node)
+	{
+		return node.children();
+	}
+
+	inline xml_object_range<xml_attribute_iterator> attributes(const pugi::xml_node& node)
+	{
+		return node.attributes();
+	}
+}
+
+#endif
diff --git a/Engine/lib/assimp/contrib/pugixml/readme.txt b/Engine/lib/assimp/contrib/pugixml/readme.txt
new file mode 100644
index 000000000..bfb1875cb
--- /dev/null
+++ b/Engine/lib/assimp/contrib/pugixml/readme.txt
@@ -0,0 +1,50 @@
+pugixml 1.11 - an XML processing library
+
+Copyright (C) 2006-2020, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
+Report bugs and download new versions at https://pugixml.org/
+
+This is the distribution of pugixml, which is a C++ XML processing library,
+which consists of a DOM-like interface with rich traversal/modification
+capabilities, an extremely fast XML parser which constructs the DOM tree from
+an XML file/buffer, and an XPath 1.0 implementation for complex data-driven
+tree queries. Full Unicode support is also available, with Unicode interface
+variants and conversions between different Unicode encodings (which happen
+automatically during parsing/saving).
+
+The distribution contains the following folders:
+
+	docs/ - documentation
+		docs/samples - pugixml usage examples
+		docs/quickstart.html - quick start guide
+		docs/manual.html - complete manual
+
+	scripts/ - project files for IDE/build systems
+
+	src/ - header and source files
+
+	readme.txt - this file.
+
+This library is distributed under the MIT License:
+
+Copyright (c) 2006-2019 Arseny Kapoulkine
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
diff --git a/Engine/lib/assimp/contrib/pugixml/src/pugiconfig.hpp b/Engine/lib/assimp/contrib/pugixml/src/pugiconfig.hpp
new file mode 100644
index 000000000..03f854bf1
--- /dev/null
+++ b/Engine/lib/assimp/contrib/pugixml/src/pugiconfig.hpp
@@ -0,0 +1,77 @@
+/**
+ * pugixml parser - version 1.11
+ * --------------------------------------------------------
+ * Copyright (C) 2006-2020, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
+ * Report bugs and download new versions at https://pugixml.org/
+ *
+ * This library is distributed under the MIT License. See notice at the end
+ * of this file.
+ *
+ * This work is based on the pugxml parser, which is:
+ * Copyright (C) 2003, by Kristen Wegner (kristen@tima.net)
+ */
+
+#ifndef HEADER_PUGICONFIG_HPP
+#define HEADER_PUGICONFIG_HPP
+
+// Uncomment this to enable wchar_t mode
+// #define PUGIXML_WCHAR_MODE
+
+// Uncomment this to enable compact mode
+// #define PUGIXML_COMPACT
+
+// Uncomment this to disable XPath
+// #define PUGIXML_NO_XPATH
+
+// Uncomment this to disable STL
+// #define PUGIXML_NO_STL
+
+// Uncomment this to disable exceptions
+// #define PUGIXML_NO_EXCEPTIONS
+
+// Set this to control attributes for public classes/functions, i.e.:
+// #define PUGIXML_API __declspec(dllexport) // to export all public symbols from DLL
+// #define PUGIXML_CLASS __declspec(dllimport) // to import all classes from DLL
+// #define PUGIXML_FUNCTION __fastcall // to set calling conventions to all public functions to fastcall
+// In absence of PUGIXML_CLASS/PUGIXML_FUNCTION definitions PUGIXML_API is used instead
+
+// Tune these constants to adjust memory-related behavior
+// #define PUGIXML_MEMORY_PAGE_SIZE 32768
+// #define PUGIXML_MEMORY_OUTPUT_STACK 10240
+// #define PUGIXML_MEMORY_XPATH_PAGE_SIZE 4096
+
+// Tune this constant to adjust max nesting for XPath queries
+// #define PUGIXML_XPATH_DEPTH_LIMIT 1024
+
+// Uncomment this to switch to header-only version
+#define PUGIXML_HEADER_ONLY
+
+// Uncomment this to enable long long support
+// #define PUGIXML_HAS_LONG_LONG
+
+#endif
+
+/**
+ * Copyright (c) 2006-2020 Arseny Kapoulkine
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
diff --git a/Engine/lib/assimp/contrib/pugixml/src/pugixml.cpp b/Engine/lib/assimp/contrib/pugixml/src/pugixml.cpp
new file mode 100644
index 000000000..efdcdf699
--- /dev/null
+++ b/Engine/lib/assimp/contrib/pugixml/src/pugixml.cpp
@@ -0,0 +1,13020 @@
+/**
+ * pugixml parser - version 1.11
+ * --------------------------------------------------------
+ * Copyright (C) 2006-2020, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
+ * Report bugs and download new versions at https://pugixml.org/
+ *
+ * This library is distributed under the MIT License. See notice at the end
+ * of this file.
+ *
+ * This work is based on the pugxml parser, which is:
+ * Copyright (C) 2003, by Kristen Wegner (kristen@tima.net)
+ */
+
+#ifndef SOURCE_PUGIXML_CPP
+#define SOURCE_PUGIXML_CPP
+
+#include "pugixml.hpp"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include <limits.h>
+
+#ifdef PUGIXML_WCHAR_MODE
+#	include <wchar.h>
+#endif
+
+#ifndef PUGIXML_NO_XPATH
+#	include <math.h>
+#	include <float.h>
+#endif
+
+#ifndef PUGIXML_NO_STL
+#	include <istream>
+#	include <ostream>
+#	include <string>
+#endif
+
+// For placement new
+#include <new>
+
+#ifdef _MSC_VER
+#	pragma warning(push)
+#	pragma warning(disable: 4127) // conditional expression is constant
+#	pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#	pragma warning(disable: 4702) // unreachable code
+#	pragma warning(disable: 4996) // this function or variable may be unsafe
+#endif
+
+#if defined(_MSC_VER) && defined(__c2__)
+#	pragma clang diagnostic push
+#	pragma clang diagnostic ignored "-Wdeprecated" // this function or variable may be unsafe
+#endif
+
+#ifdef __INTEL_COMPILER
+#	pragma warning(disable: 177) // function was declared but never referenced
+#	pragma warning(disable: 279) // controlling expression is constant
+#	pragma warning(disable: 1478 1786) // function was declared "deprecated"
+#	pragma warning(disable: 1684) // conversion from pointer to same-sized integral type
+#endif
+
+#if defined(__BORLANDC__) && defined(PUGIXML_HEADER_ONLY)
+#	pragma warn -8080 // symbol is declared but never used; disabling this inside push/pop bracket does not make the warning go away
+#endif
+
+#ifdef __BORLANDC__
+#	pragma option push
+#	pragma warn -8008 // condition is always false
+#	pragma warn -8066 // unreachable code
+#endif
+
+#ifdef __SNC__
+// Using diag_push/diag_pop does not disable the warnings inside templates due to a compiler bug
+#	pragma diag_suppress=178 // function was declared but never referenced
+#	pragma diag_suppress=237 // controlling expression is constant
+#endif
+
+#ifdef __TI_COMPILER_VERSION__
+#	pragma diag_suppress 179 // function was declared but never referenced
+#endif
+
+// Inlining controls
+#if defined(_MSC_VER) && _MSC_VER >= 1300
+#	define PUGI__NO_INLINE __declspec(noinline)
+#elif defined(__GNUC__)
+#	define PUGI__NO_INLINE __attribute__((noinline))
+#else
+#	define PUGI__NO_INLINE
+#endif
+
+// Branch weight controls
+#if defined(__GNUC__) && !defined(__c2__)
+#	define PUGI__UNLIKELY(cond) __builtin_expect(cond, 0)
+#else
+#	define PUGI__UNLIKELY(cond) (cond)
+#endif
+
+// Simple static assertion
+#define PUGI__STATIC_ASSERT(cond) { static const char condition_failed[(cond) ? 1 : -1] = {0}; (void)condition_failed[0]; }
+
+// Digital Mars C++ bug workaround for passing char loaded from memory via stack
+#ifdef __DMC__
+#	define PUGI__DMC_VOLATILE volatile
+#else
+#	define PUGI__DMC_VOLATILE
+#endif
+
+// Integer sanitizer workaround; we only apply this for clang since gcc8 has no_sanitize but not unsigned-integer-overflow and produces "attribute directive ignored" warnings
+#if defined(__clang__) && defined(__has_attribute)
+#	if __has_attribute(no_sanitize)
+#		define PUGI__UNSIGNED_OVERFLOW __attribute__((no_sanitize("unsigned-integer-overflow")))
+#	else
+#		define PUGI__UNSIGNED_OVERFLOW
+#	endif
+#else
+#	define PUGI__UNSIGNED_OVERFLOW
+#endif
+
+// Borland C++ bug workaround for not defining ::memcpy depending on header include order (can't always use std::memcpy because some compilers don't have it at all)
+#if defined(__BORLANDC__) && !defined(__MEM_H_USING_LIST)
+using std::memcpy;
+using std::memmove;
+using std::memset;
+#endif
+
+// Some MinGW/GCC versions have headers that erroneously omit LLONG_MIN/LLONG_MAX/ULLONG_MAX definitions from limits.h in some configurations
+#if defined(PUGIXML_HAS_LONG_LONG) && defined(__GNUC__) && !defined(LLONG_MAX) && !defined(LLONG_MIN) && !defined(ULLONG_MAX)
+#	define LLONG_MIN (-LLONG_MAX - 1LL)
+#	define LLONG_MAX __LONG_LONG_MAX__
+#	define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
+#endif
+
+// In some environments MSVC is a compiler but the CRT lacks certain MSVC-specific features
+#if defined(_MSC_VER) && !defined(__S3E__)
+#	define PUGI__MSVC_CRT_VERSION _MSC_VER
+#endif
+
+// Not all platforms have snprintf; we define a wrapper that uses snprintf if possible. This only works with buffers with a known size.
+#if __cplusplus >= 201103
+#	define PUGI__SNPRINTF(buf, ...) snprintf(buf, sizeof(buf), __VA_ARGS__)
+#elif defined(PUGI__MSVC_CRT_VERSION) && PUGI__MSVC_CRT_VERSION >= 1400
+#	define PUGI__SNPRINTF(buf, ...) _snprintf_s(buf, _countof(buf), _TRUNCATE, __VA_ARGS__)
+#else
+#	define PUGI__SNPRINTF sprintf
+#endif
+
+// We put implementation details into an anonymous namespace in source mode, but have to keep it in non-anonymous namespace in header-only mode to prevent binary bloat.
+#ifdef PUGIXML_HEADER_ONLY
+#	define PUGI__NS_BEGIN namespace pugi { namespace impl {
+#	define PUGI__NS_END } }
+#	define PUGI__FN inline
+#	define PUGI__FN_NO_INLINE inline
+#else
+#	if defined(_MSC_VER) && _MSC_VER < 1300 // MSVC6 seems to have an amusing bug with anonymous namespaces inside namespaces
+#		define PUGI__NS_BEGIN namespace pugi { namespace impl {
+#		define PUGI__NS_END } }
+#	else
+#		define PUGI__NS_BEGIN namespace pugi { namespace impl { namespace {
+#		define PUGI__NS_END } } }
+#	endif
+#	define PUGI__FN
+#	define PUGI__FN_NO_INLINE PUGI__NO_INLINE
+#endif
+
+// uintptr_t
+#if (defined(_MSC_VER) && _MSC_VER < 1600) || (defined(__BORLANDC__) && __BORLANDC__ < 0x561)
+namespace pugi
+{
+#	ifndef _UINTPTR_T_DEFINED
+	typedef size_t uintptr_t;
+#	endif
+
+	typedef unsigned __int8 uint8_t;
+	typedef unsigned __int16 uint16_t;
+	typedef unsigned __int32 uint32_t;
+}
+#else
+#	include <stdint.h>
+#endif
+
+// Memory allocation
+PUGI__NS_BEGIN
+	PUGI__FN void* default_allocate(size_t size)
+	{
+		return malloc(size);
+	}
+
+	PUGI__FN void default_deallocate(void* ptr)
+	{
+		free(ptr);
+	}
+
+	template <typename T>
+	struct xml_memory_management_function_storage
+	{
+		static allocation_function allocate;
+		static deallocation_function deallocate;
+	};
+
+	// Global allocation functions are stored in class statics so that in header mode linker deduplicates them
+	// Without a template<> we'll get multiple definitions of the same static
+	template <typename T> allocation_function xml_memory_management_function_storage<T>::allocate = default_allocate;
+	template <typename T> deallocation_function xml_memory_management_function_storage<T>::deallocate = default_deallocate;
+
+	typedef xml_memory_management_function_storage<int> xml_memory;
+PUGI__NS_END
+
+// String utilities
+PUGI__NS_BEGIN
+	// Get string length
+	PUGI__FN size_t strlength(const char_t* s)
+	{
+		assert(s);
+
+	#ifdef PUGIXML_WCHAR_MODE
+		return wcslen(s);
+	#else
+		return strlen(s);
+	#endif
+	}
+
+	// Compare two strings
+	PUGI__FN bool strequal(const char_t* src, const char_t* dst)
+	{
+		assert(src && dst);
+
+	#ifdef PUGIXML_WCHAR_MODE
+		return wcscmp(src, dst) == 0;
+	#else
+		return strcmp(src, dst) == 0;
+	#endif
+	}
+
+	// Compare lhs with [rhs_begin, rhs_end)
+	PUGI__FN bool strequalrange(const char_t* lhs, const char_t* rhs, size_t count)
+	{
+		for (size_t i = 0; i < count; ++i)
+			if (lhs[i] != rhs[i])
+				return false;
+
+		return lhs[count] == 0;
+	}
+
+	// Get length of wide string, even if CRT lacks wide character support
+	PUGI__FN size_t strlength_wide(const wchar_t* s)
+	{
+		assert(s);
+
+	#ifdef PUGIXML_WCHAR_MODE
+		return wcslen(s);
+	#else
+		const wchar_t* end = s;
+		while (*end) end++;
+		return static_cast<size_t>(end - s);
+	#endif
+	}
+PUGI__NS_END
+
+// auto_ptr-like object for exception recovery
+PUGI__NS_BEGIN
+	template <typename T> struct auto_deleter
+	{
+		typedef void (*D)(T*);
+
+		T* data;
+		D deleter;
+
+		auto_deleter(T* data_, D deleter_): data(data_), deleter(deleter_)
+		{
+		}
+
+		~auto_deleter()
+		{
+			if (data) deleter(data);
+		}
+
+		T* release()
+		{
+			T* result = data;
+			data = 0;
+			return result;
+		}
+	};
+PUGI__NS_END
+
+#ifdef PUGIXML_COMPACT
+PUGI__NS_BEGIN
+	class compact_hash_table
+	{
+	public:
+		compact_hash_table(): _items(0), _capacity(0), _count(0)
+		{
+		}
+
+		void clear()
+		{
+			if (_items)
+			{
+				xml_memory::deallocate(_items);
+				_items = 0;
+				_capacity = 0;
+				_count = 0;
+			}
+		}
+
+		void* find(const void* key)
+		{
+			if (_capacity == 0) return 0;
+
+			item_t* item = get_item(key);
+			assert(item);
+			assert(item->key == key || (item->key == 0 && item->value == 0));
+
+			return item->value;
+		}
+
+		void insert(const void* key, void* value)
+		{
+			assert(_capacity != 0 && _count < _capacity - _capacity / 4);
+
+			item_t* item = get_item(key);
+			assert(item);
+
+			if (item->key == 0)
+			{
+				_count++;
+				item->key = key;
+			}
+
+			item->value = value;
+		}
+
+		bool reserve(size_t extra = 16)
+		{
+			if (_count + extra >= _capacity - _capacity / 4)
+				return rehash(_count + extra);
+
+			return true;
+		}
+
+	private:
+		struct item_t
+		{
+			const void* key;
+			void* value;
+		};
+
+		item_t* _items;
+		size_t _capacity;
+
+		size_t _count;
+
+		bool rehash(size_t count);
+
+		item_t* get_item(const void* key)
+		{
+			assert(key);
+			assert(_capacity > 0);
+
+			size_t hashmod = _capacity - 1;
+			size_t bucket = hash(key) & hashmod;
+
+			for (size_t probe = 0; probe <= hashmod; ++probe)
+			{
+				item_t& probe_item = _items[bucket];
+
+				if (probe_item.key == key || probe_item.key == 0)
+					return &probe_item;
+
+				// hash collision, quadratic probing
+				bucket = (bucket + probe + 1) & hashmod;
+			}
+
+			assert(false && "Hash table is full"); // unreachable
+			return 0;
+		}
+
+		static PUGI__UNSIGNED_OVERFLOW unsigned int hash(const void* key)
+		{
+			unsigned int h = static_cast<unsigned int>(reinterpret_cast<uintptr_t>(key) & 0xffffffff);
+
+			// MurmurHash3 32-bit finalizer
+			h ^= h >> 16;
+			h *= 0x85ebca6bu;
+			h ^= h >> 13;
+			h *= 0xc2b2ae35u;
+			h ^= h >> 16;
+
+			return h;
+		}
+	};
+
+	PUGI__FN_NO_INLINE bool compact_hash_table::rehash(size_t count)
+	{
+		size_t capacity = 32;
+		while (count >= capacity - capacity / 4)
+			capacity *= 2;
+
+		compact_hash_table rt;
+		rt._capacity = capacity;
+		rt._items = static_cast<item_t*>(xml_memory::allocate(sizeof(item_t) * capacity));
+
+		if (!rt._items)
+			return false;
+
+		memset(rt._items, 0, sizeof(item_t) * capacity);
+
+		for (size_t i = 0; i < _capacity; ++i)
+			if (_items[i].key)
+				rt.insert(_items[i].key, _items[i].value);
+
+		if (_items)
+			xml_memory::deallocate(_items);
+
+		_capacity = capacity;
+		_items = rt._items;
+
+		assert(_count == rt._count);
+
+		return true;
+	}
+
+PUGI__NS_END
+#endif
+
+PUGI__NS_BEGIN
+#ifdef PUGIXML_COMPACT
+	static const uintptr_t xml_memory_block_alignment = 4;
+#else
+	static const uintptr_t xml_memory_block_alignment = sizeof(void*);
+#endif
+
+	// extra metadata bits
+	static const uintptr_t xml_memory_page_contents_shared_mask = 64;
+	static const uintptr_t xml_memory_page_name_allocated_mask = 32;
+	static const uintptr_t xml_memory_page_value_allocated_mask = 16;
+	static const uintptr_t xml_memory_page_type_mask = 15;
+
+	// combined masks for string uniqueness
+	static const uintptr_t xml_memory_page_name_allocated_or_shared_mask = xml_memory_page_name_allocated_mask | xml_memory_page_contents_shared_mask;
+	static const uintptr_t xml_memory_page_value_allocated_or_shared_mask = xml_memory_page_value_allocated_mask | xml_memory_page_contents_shared_mask;
+
+#ifdef PUGIXML_COMPACT
+	#define PUGI__GETHEADER_IMPL(object, page, flags) // unused
+	#define PUGI__GETPAGE_IMPL(header) (header).get_page()
+#else
+	#define PUGI__GETHEADER_IMPL(object, page, flags) (((reinterpret_cast<char*>(object) - reinterpret_cast<char*>(page)) << 8) | (flags))
+	// this macro casts pointers through void* to avoid 'cast increases required alignment of target type' warnings
+	#define PUGI__GETPAGE_IMPL(header) static_cast<impl::xml_memory_page*>(const_cast<void*>(static_cast<const void*>(reinterpret_cast<const char*>(&header) - (header >> 8))))
+#endif
+
+	#define PUGI__GETPAGE(n) PUGI__GETPAGE_IMPL((n)->header)
+	#define PUGI__NODETYPE(n) static_cast<xml_node_type>((n)->header & impl::xml_memory_page_type_mask)
+
+	struct xml_allocator;
+
+	struct xml_memory_page
+	{
+		static xml_memory_page* construct(void* memory)
+		{
+			xml_memory_page* result = static_cast<xml_memory_page*>(memory);
+
+			result->allocator = 0;
+			result->prev = 0;
+			result->next = 0;
+			result->busy_size = 0;
+			result->freed_size = 0;
+
+		#ifdef PUGIXML_COMPACT
+			result->compact_string_base = 0;
+			result->compact_shared_parent = 0;
+			result->compact_page_marker = 0;
+		#endif
+
+			return result;
+		}
+
+		xml_allocator* allocator;
+
+		xml_memory_page* prev;
+		xml_memory_page* next;
+
+		size_t busy_size;
+		size_t freed_size;
+
+	#ifdef PUGIXML_COMPACT
+		char_t* compact_string_base;
+		void* compact_shared_parent;
+		uint32_t* compact_page_marker;
+	#endif
+	};
+
+	static const size_t xml_memory_page_size =
+	#ifdef PUGIXML_MEMORY_PAGE_SIZE
+		(PUGIXML_MEMORY_PAGE_SIZE)
+	#else
+		32768
+	#endif
+		- sizeof(xml_memory_page);
+
+	struct xml_memory_string_header
+	{
+		uint16_t page_offset; // offset from page->data
+		uint16_t full_size; // 0 if string occupies whole page
+	};
+
+	struct xml_allocator
+	{
+		xml_allocator(xml_memory_page* root): _root(root), _busy_size(root->busy_size)
+		{
+		#ifdef PUGIXML_COMPACT
+			_hash = 0;
+		#endif
+		}
+
+		xml_memory_page* allocate_page(size_t data_size)
+		{
+			size_t size = sizeof(xml_memory_page) + data_size;
+
+			// allocate block with some alignment, leaving memory for worst-case padding
+			void* memory = xml_memory::allocate(size);
+			if (!memory) return 0;
+
+			// prepare page structure
+			xml_memory_page* page = xml_memory_page::construct(memory);
+			assert(page);
+
+			page->allocator = _root->allocator;
+
+			return page;
+		}
+
+		static void deallocate_page(xml_memory_page* page)
+		{
+			xml_memory::deallocate(page);
+		}
+
+		void* allocate_memory_oob(size_t size, xml_memory_page*& out_page);
+
+		void* allocate_memory(size_t size, xml_memory_page*& out_page)
+		{
+			if (PUGI__UNLIKELY(_busy_size + size > xml_memory_page_size))
+				return allocate_memory_oob(size, out_page);
+
+			void* buf = reinterpret_cast<char*>(_root) + sizeof(xml_memory_page) + _busy_size;
+
+			_busy_size += size;
+
+			out_page = _root;
+
+			return buf;
+		}
+
+	#ifdef PUGIXML_COMPACT
+		void* allocate_object(size_t size, xml_memory_page*& out_page)
+		{
+			void* result = allocate_memory(size + sizeof(uint32_t), out_page);
+			if (!result) return 0;
+
+			// adjust for marker
+			ptrdiff_t offset = static_cast<char*>(result) - reinterpret_cast<char*>(out_page->compact_page_marker);
+
+			if (PUGI__UNLIKELY(static_cast<uintptr_t>(offset) >= 256 * xml_memory_block_alignment))
+			{
+				// insert new marker
+				uint32_t* marker = static_cast<uint32_t*>(result);
+
+				*marker = static_cast<uint32_t>(reinterpret_cast<char*>(marker) - reinterpret_cast<char*>(out_page));
+				out_page->compact_page_marker = marker;
+
+				// since we don't reuse the page space until we reallocate it, we can just pretend that we freed the marker block
+				// this will make sure deallocate_memory correctly tracks the size
+				out_page->freed_size += sizeof(uint32_t);
+
+				return marker + 1;
+			}
+			else
+			{
+				// roll back uint32_t part
+				_busy_size -= sizeof(uint32_t);
+
+				return result;
+			}
+		}
+	#else
+		void* allocate_object(size_t size, xml_memory_page*& out_page)
+		{
+			return allocate_memory(size, out_page);
+		}
+	#endif
+
+		void deallocate_memory(void* ptr, size_t size, xml_memory_page* page)
+		{
+			if (page == _root) page->busy_size = _busy_size;
+
+			assert(ptr >= reinterpret_cast<char*>(page) + sizeof(xml_memory_page) && ptr < reinterpret_cast<char*>(page) + sizeof(xml_memory_page) + page->busy_size);
+			(void)!ptr;
+
+			page->freed_size += size;
+			assert(page->freed_size <= page->busy_size);
+
+			if (page->freed_size == page->busy_size)
+			{
+				if (page->next == 0)
+				{
+					assert(_root == page);
+
+					// top page freed, just reset sizes
+					page->busy_size = 0;
+					page->freed_size = 0;
+
+				#ifdef PUGIXML_COMPACT
+					// reset compact state to maximize efficiency
+					page->compact_string_base = 0;
+					page->compact_shared_parent = 0;
+					page->compact_page_marker = 0;
+				#endif
+
+					_busy_size = 0;
+				}
+				else
+				{
+					assert(_root != page);
+					assert(page->prev);
+
+					// remove from the list
+					page->prev->next = page->next;
+					page->next->prev = page->prev;
+
+					// deallocate
+					deallocate_page(page);
+				}
+			}
+		}
+
+		char_t* allocate_string(size_t length)
+		{
+			static const size_t max_encoded_offset = (1 << 16) * xml_memory_block_alignment;
+
+			PUGI__STATIC_ASSERT(xml_memory_page_size <= max_encoded_offset);
+
+			// allocate memory for string and header block
+			size_t size = sizeof(xml_memory_string_header) + length * sizeof(char_t);
+
+			// round size up to block alignment boundary
+			size_t full_size = (size + (xml_memory_block_alignment - 1)) & ~(xml_memory_block_alignment - 1);
+
+			xml_memory_page* page;
+			xml_memory_string_header* header = static_cast<xml_memory_string_header*>(allocate_memory(full_size, page));
+
+			if (!header) return 0;
+
+			// setup header
+			ptrdiff_t page_offset = reinterpret_cast<char*>(header) - reinterpret_cast<char*>(page) - sizeof(xml_memory_page);
+
+			assert(page_offset % xml_memory_block_alignment == 0);
+			assert(page_offset >= 0 && static_cast<size_t>(page_offset) < max_encoded_offset);
+			header->page_offset = static_cast<uint16_t>(static_cast<size_t>(page_offset) / xml_memory_block_alignment);
+
+			// full_size == 0 for large strings that occupy the whole page
+			assert(full_size % xml_memory_block_alignment == 0);
+			assert(full_size < max_encoded_offset || (page->busy_size == full_size && page_offset == 0));
+			header->full_size = static_cast<uint16_t>(full_size < max_encoded_offset ? full_size / xml_memory_block_alignment : 0);
+
+			// round-trip through void* to avoid 'cast increases required alignment of target type' warning
+			// header is guaranteed a pointer-sized alignment, which should be enough for char_t
+			return static_cast<char_t*>(static_cast<void*>(header + 1));
+		}
+
+		void deallocate_string(char_t* string)
+		{
+			// this function casts pointers through void* to avoid 'cast increases required alignment of target type' warnings
+			// we're guaranteed the proper (pointer-sized) alignment on the input string if it was allocated via allocate_string
+
+			// get header
+			xml_memory_string_header* header = static_cast<xml_memory_string_header*>(static_cast<void*>(string)) - 1;
+			assert(header);
+
+			// deallocate
+			size_t page_offset = sizeof(xml_memory_page) + header->page_offset * xml_memory_block_alignment;
+			xml_memory_page* page = reinterpret_cast<xml_memory_page*>(static_cast<void*>(reinterpret_cast<char*>(header) - page_offset));
+
+			// if full_size == 0 then this string occupies the whole page
+			size_t full_size = header->full_size == 0 ? page->busy_size : header->full_size * xml_memory_block_alignment;
+
+			deallocate_memory(header, full_size, page);
+		}
+
+		bool reserve()
+		{
+		#ifdef PUGIXML_COMPACT
+			return _hash->reserve();
+		#else
+			return true;
+		#endif
+		}
+
+		xml_memory_page* _root;
+		size_t _busy_size;
+
+	#ifdef PUGIXML_COMPACT
+		compact_hash_table* _hash;
+	#endif
+	};
+
+	PUGI__FN_NO_INLINE void* xml_allocator::allocate_memory_oob(size_t size, xml_memory_page*& out_page)
+	{
+		const size_t large_allocation_threshold = xml_memory_page_size / 4;
+
+		xml_memory_page* page = allocate_page(size <= large_allocation_threshold ? xml_memory_page_size : size);
+		out_page = page;
+
+		if (!page) return 0;
+
+		if (size <= large_allocation_threshold)
+		{
+			_root->busy_size = _busy_size;
+
+			// insert page at the end of linked list
+			page->prev = _root;
+			_root->next = page;
+			_root = page;
+
+			_busy_size = size;
+		}
+		else
+		{
+			// insert page before the end of linked list, so that it is deleted as soon as possible
+			// the last page is not deleted even if it's empty (see deallocate_memory)
+			assert(_root->prev);
+
+			page->prev = _root->prev;
+			page->next = _root;
+
+			_root->prev->next = page;
+			_root->prev = page;
+
+			page->busy_size = size;
+		}
+
+		return reinterpret_cast<char*>(page) + sizeof(xml_memory_page);
+	}
+PUGI__NS_END
+
+#ifdef PUGIXML_COMPACT
+PUGI__NS_BEGIN
+	static const uintptr_t compact_alignment_log2 = 2;
+	static const uintptr_t compact_alignment = 1 << compact_alignment_log2;
+
+	class compact_header
+	{
+	public:
+		compact_header(xml_memory_page* page, unsigned int flags)
+		{
+			PUGI__STATIC_ASSERT(xml_memory_block_alignment == compact_alignment);
+
+			ptrdiff_t offset = (reinterpret_cast<char*>(this) - reinterpret_cast<char*>(page->compact_page_marker));
+			assert(offset % compact_alignment == 0 && static_cast<uintptr_t>(offset) < 256 * compact_alignment);
+
+			_page = static_cast<unsigned char>(offset >> compact_alignment_log2);
+			_flags = static_cast<unsigned char>(flags);
+		}
+
+		void operator&=(uintptr_t mod)
+		{
+			_flags &= static_cast<unsigned char>(mod);
+		}
+
+		void operator|=(uintptr_t mod)
+		{
+			_flags |= static_cast<unsigned char>(mod);
+		}
+
+		uintptr_t operator&(uintptr_t mod) const
+		{
+			return _flags & mod;
+		}
+
+		xml_memory_page* get_page() const
+		{
+			// round-trip through void* to silence 'cast increases required alignment of target type' warnings
+			const char* page_marker = reinterpret_cast<const char*>(this) - (_page << compact_alignment_log2);
+			const char* page = page_marker - *reinterpret_cast<const uint32_t*>(static_cast<const void*>(page_marker));
+
+			return const_cast<xml_memory_page*>(reinterpret_cast<const xml_memory_page*>(static_cast<const void*>(page)));
+		}
+
+	private:
+		unsigned char _page;
+		unsigned char _flags;
+	};
+
+	PUGI__FN xml_memory_page* compact_get_page(const void* object, int header_offset)
+	{
+		const compact_header* header = reinterpret_cast<const compact_header*>(static_cast<const char*>(object) - header_offset);
+
+		return header->get_page();
+	}
+
+	template <int header_offset, typename T> PUGI__FN_NO_INLINE T* compact_get_value(const void* object)
+	{
+		return static_cast<T*>(compact_get_page(object, header_offset)->allocator->_hash->find(object));
+	}
+
+	template <int header_offset, typename T> PUGI__FN_NO_INLINE void compact_set_value(const void* object, T* value)
+	{
+		compact_get_page(object, header_offset)->allocator->_hash->insert(object, value);
+	}
+
+	template <typename T, int header_offset, int start = -126> class compact_pointer
+	{
+	public:
+		compact_pointer(): _data(0)
+		{
+		}
+
+		void operator=(const compact_pointer& rhs)
+		{
+			*this = rhs + 0;
+		}
+
+		void operator=(T* value)
+		{
+			if (value)
+			{
+				// value is guaranteed to be compact-aligned; 'this' is not
+				// our decoding is based on 'this' aligned to compact alignment downwards (see operator T*)
+				// so for negative offsets (e.g. -3) we need to adjust the diff by compact_alignment - 1 to
+				// compensate for arithmetic shift rounding for negative values
+				ptrdiff_t diff = reinterpret_cast<char*>(value) - reinterpret_cast<char*>(this);
+				ptrdiff_t offset = ((diff + int(compact_alignment - 1)) >> compact_alignment_log2) - start;
+
+				if (static_cast<uintptr_t>(offset) <= 253)
+					_data = static_cast<unsigned char>(offset + 1);
+				else
+				{
+					compact_set_value<header_offset>(this, value);
+
+					_data = 255;
+				}
+			}
+			else
+				_data = 0;
+		}
+
+		operator T*() const
+		{
+			if (_data)
+			{
+				if (_data < 255)
+				{
+					uintptr_t base = reinterpret_cast<uintptr_t>(this) & ~(compact_alignment - 1);
+
+					return reinterpret_cast<T*>(base + (_data - 1 + start) * compact_alignment);
+				}
+				else
+					return compact_get_value<header_offset, T>(this);
+			}
+			else
+				return 0;
+		}
+
+		T* operator->() const
+		{
+			return *this;
+		}
+
+	private:
+		unsigned char _data;
+	};
+
+	template <typename T, int header_offset> class compact_pointer_parent
+	{
+	public:
+		compact_pointer_parent(): _data(0)
+		{
+		}
+
+		void operator=(const compact_pointer_parent& rhs)
+		{
+			*this = rhs + 0;
+		}
+
+		void operator=(T* value)
+		{
+			if (value)
+			{
+				// value is guaranteed to be compact-aligned; 'this' is not
+				// our decoding is based on 'this' aligned to compact alignment downwards (see operator T*)
+				// so for negative offsets (e.g. -3) we need to adjust the diff by compact_alignment - 1 to
+				// compensate for arithmetic shift behavior for negative values
+				ptrdiff_t diff = reinterpret_cast<char*>(value) - reinterpret_cast<char*>(this);
+				ptrdiff_t offset = ((diff + int(compact_alignment - 1)) >> compact_alignment_log2) + 65533;
+
+				if (static_cast<uintptr_t>(offset) <= 65533)
+				{
+					_data = static_cast<unsigned short>(offset + 1);
+				}
+				else
+				{
+					xml_memory_page* page = compact_get_page(this, header_offset);
+
+					if (PUGI__UNLIKELY(page->compact_shared_parent == 0))
+						page->compact_shared_parent = value;
+
+					if (page->compact_shared_parent == value)
+					{
+						_data = 65534;
+					}
+					else
+					{
+						compact_set_value<header_offset>(this, value);
+
+						_data = 65535;
+					}
+				}
+			}
+			else
+			{
+				_data = 0;
+			}
+		}
+
+		operator T*() const
+		{
+			if (_data)
+			{
+				if (_data < 65534)
+				{
+					uintptr_t base = reinterpret_cast<uintptr_t>(this) & ~(compact_alignment - 1);
+
+					return reinterpret_cast<T*>(base + (_data - 1 - 65533) * compact_alignment);
+				}
+				else if (_data == 65534)
+					return static_cast<T*>(compact_get_page(this, header_offset)->compact_shared_parent);
+				else
+					return compact_get_value<header_offset, T>(this);
+			}
+			else
+				return 0;
+		}
+
+		T* operator->() const
+		{
+			return *this;
+		}
+
+	private:
+		uint16_t _data;
+	};
+
+	template <int header_offset, int base_offset> class compact_string
+	{
+	public:
+		compact_string(): _data(0)
+		{
+		}
+
+		void operator=(const compact_string& rhs)
+		{
+			*this = rhs + 0;
+		}
+
+		void operator=(char_t* value)
+		{
+			if (value)
+			{
+				xml_memory_page* page = compact_get_page(this, header_offset);
+
+				if (PUGI__UNLIKELY(page->compact_string_base == 0))
+					page->compact_string_base = value;
+
+				ptrdiff_t offset = value - page->compact_string_base;
+
+				if (static_cast<uintptr_t>(offset) < (65535 << 7))
+				{
+					// round-trip through void* to silence 'cast increases required alignment of target type' warnings
+					uint16_t* base = reinterpret_cast<uint16_t*>(static_cast<void*>(reinterpret_cast<char*>(this) - base_offset));
+
+					if (*base == 0)
+					{
+						*base = static_cast<uint16_t>((offset >> 7) + 1);
+						_data = static_cast<unsigned char>((offset & 127) + 1);
+					}
+					else
+					{
+						ptrdiff_t remainder = offset - ((*base - 1) << 7);
+
+						if (static_cast<uintptr_t>(remainder) <= 253)
+						{
+							_data = static_cast<unsigned char>(remainder + 1);
+						}
+						else
+						{
+							compact_set_value<header_offset>(this, value);
+
+							_data = 255;
+						}
+					}
+				}
+				else
+				{
+					compact_set_value<header_offset>(this, value);
+
+					_data = 255;
+				}
+			}
+			else
+			{
+				_data = 0;
+			}
+		}
+
+		operator char_t*() const
+		{
+			if (_data)
+			{
+				if (_data < 255)
+				{
+					xml_memory_page* page = compact_get_page(this, header_offset);
+
+					// round-trip through void* to silence 'cast increases required alignment of target type' warnings
+					const uint16_t* base = reinterpret_cast<const uint16_t*>(static_cast<const void*>(reinterpret_cast<const char*>(this) - base_offset));
+					assert(*base);
+
+					ptrdiff_t offset = ((*base - 1) << 7) + (_data - 1);
+
+					return page->compact_string_base + offset;
+				}
+				else
+				{
+					return compact_get_value<header_offset, char_t>(this);
+				}
+			}
+			else
+				return 0;
+		}
+
+	private:
+		unsigned char _data;
+	};
+PUGI__NS_END
+#endif
+
+#ifdef PUGIXML_COMPACT
+namespace pugi
+{
+	struct xml_attribute_struct
+	{
+		xml_attribute_struct(impl::xml_memory_page* page): header(page, 0), namevalue_base(0)
+		{
+			PUGI__STATIC_ASSERT(sizeof(xml_attribute_struct) == 8);
+		}
+
+		impl::compact_header header;
+
+		uint16_t namevalue_base;
+
+		impl::compact_string<4, 2> name;
+		impl::compact_string<5, 3> value;
+
+		impl::compact_pointer<xml_attribute_struct, 6> prev_attribute_c;
+		impl::compact_pointer<xml_attribute_struct, 7, 0> next_attribute;
+	};
+
+	struct xml_node_struct
+	{
+		xml_node_struct(impl::xml_memory_page* page, xml_node_type type): header(page, type), namevalue_base(0)
+		{
+			PUGI__STATIC_ASSERT(sizeof(xml_node_struct) == 12);
+		}
+
+		impl::compact_header header;
+
+		uint16_t namevalue_base;
+
+		impl::compact_string<4, 2> name;
+		impl::compact_string<5, 3> value;
+
+		impl::compact_pointer_parent<xml_node_struct, 6> parent;
+
+		impl::compact_pointer<xml_node_struct, 8, 0> first_child;
+
+		impl::compact_pointer<xml_node_struct,  9>    prev_sibling_c;
+		impl::compact_pointer<xml_node_struct, 10, 0> next_sibling;
+
+		impl::compact_pointer<xml_attribute_struct, 11, 0> first_attribute;
+	};
+}
+#else
+namespace pugi
+{
+	struct xml_attribute_struct
+	{
+		xml_attribute_struct(impl::xml_memory_page* page): name(0), value(0), prev_attribute_c(0), next_attribute(0)
+		{
+			header = PUGI__GETHEADER_IMPL(this, page, 0);
+		}
+
+		uintptr_t header;
+
+		char_t*	name;
+		char_t*	value;
+
+		xml_attribute_struct* prev_attribute_c;
+		xml_attribute_struct* next_attribute;
+	};
+
+	struct xml_node_struct
+	{
+		xml_node_struct(impl::xml_memory_page* page, xml_node_type type): name(0), value(0), parent(0), first_child(0), prev_sibling_c(0), next_sibling(0), first_attribute(0)
+		{
+			header = PUGI__GETHEADER_IMPL(this, page, type);
+		}
+
+		uintptr_t header;
+
+		char_t* name;
+		char_t* value;
+
+		xml_node_struct* parent;
+
+		xml_node_struct* first_child;
+
+		xml_node_struct* prev_sibling_c;
+		xml_node_struct* next_sibling;
+
+		xml_attribute_struct* first_attribute;
+	};
+}
+#endif
+
+PUGI__NS_BEGIN
+	struct xml_extra_buffer
+	{
+		char_t* buffer;
+		xml_extra_buffer* next;
+	};
+
+	struct xml_document_struct: public xml_node_struct, public xml_allocator
+	{
+		xml_document_struct(xml_memory_page* page): xml_node_struct(page, node_document), xml_allocator(page), buffer(0), extra_buffers(0)
+		{
+		}
+
+		const char_t* buffer;
+
+		xml_extra_buffer* extra_buffers;
+
+	#ifdef PUGIXML_COMPACT
+		compact_hash_table hash;
+	#endif
+	};
+
+	template <typename Object> inline xml_allocator& get_allocator(const Object* object)
+	{
+		assert(object);
+
+		return *PUGI__GETPAGE(object)->allocator;
+	}
+
+	template <typename Object> inline xml_document_struct& get_document(const Object* object)
+	{
+		assert(object);
+
+		return *static_cast<xml_document_struct*>(PUGI__GETPAGE(object)->allocator);
+	}
+PUGI__NS_END
+
+// Low-level DOM operations
+PUGI__NS_BEGIN
+	inline xml_attribute_struct* allocate_attribute(xml_allocator& alloc)
+	{
+		xml_memory_page* page;
+		void* memory = alloc.allocate_object(sizeof(xml_attribute_struct), page);
+		if (!memory) return 0;
+
+		return new (memory) xml_attribute_struct(page);
+	}
+
+	inline xml_node_struct* allocate_node(xml_allocator& alloc, xml_node_type type)
+	{
+		xml_memory_page* page;
+		void* memory = alloc.allocate_object(sizeof(xml_node_struct), page);
+		if (!memory) return 0;
+
+		return new (memory) xml_node_struct(page, type);
+	}
+
+	inline void destroy_attribute(xml_attribute_struct* a, xml_allocator& alloc)
+	{
+		if (a->header & impl::xml_memory_page_name_allocated_mask)
+			alloc.deallocate_string(a->name);
+
+		if (a->header & impl::xml_memory_page_value_allocated_mask)
+			alloc.deallocate_string(a->value);
+
+		alloc.deallocate_memory(a, sizeof(xml_attribute_struct), PUGI__GETPAGE(a));
+	}
+
+	inline void destroy_node(xml_node_struct* n, xml_allocator& alloc)
+	{
+		if (n->header & impl::xml_memory_page_name_allocated_mask)
+			alloc.deallocate_string(n->name);
+
+		if (n->header & impl::xml_memory_page_value_allocated_mask)
+			alloc.deallocate_string(n->value);
+
+		for (xml_attribute_struct* attr = n->first_attribute; attr; )
+		{
+			xml_attribute_struct* next = attr->next_attribute;
+
+			destroy_attribute(attr, alloc);
+
+			attr = next;
+		}
+
+		for (xml_node_struct* child = n->first_child; child; )
+		{
+			xml_node_struct* next = child->next_sibling;
+
+			destroy_node(child, alloc);
+
+			child = next;
+		}
+
+		alloc.deallocate_memory(n, sizeof(xml_node_struct), PUGI__GETPAGE(n));
+	}
+
+	inline void append_node(xml_node_struct* child, xml_node_struct* node)
+	{
+		child->parent = node;
+
+		xml_node_struct* head = node->first_child;
+
+		if (head)
+		{
+			xml_node_struct* tail = head->prev_sibling_c;
+
+			tail->next_sibling = child;
+			child->prev_sibling_c = tail;
+			head->prev_sibling_c = child;
+		}
+		else
+		{
+			node->first_child = child;
+			child->prev_sibling_c = child;
+		}
+	}
+
+	inline void prepend_node(xml_node_struct* child, xml_node_struct* node)
+	{
+		child->parent = node;
+
+		xml_node_struct* head = node->first_child;
+
+		if (head)
+		{
+			child->prev_sibling_c = head->prev_sibling_c;
+			head->prev_sibling_c = child;
+		}
+		else
+			child->prev_sibling_c = child;
+
+		child->next_sibling = head;
+		node->first_child = child;
+	}
+
+	inline void insert_node_after(xml_node_struct* child, xml_node_struct* node)
+	{
+		xml_node_struct* parent = node->parent;
+
+		child->parent = parent;
+
+		if (node->next_sibling)
+			node->next_sibling->prev_sibling_c = child;
+		else
+			parent->first_child->prev_sibling_c = child;
+
+		child->next_sibling = node->next_sibling;
+		child->prev_sibling_c = node;
+
+		node->next_sibling = child;
+	}
+
+	inline void insert_node_before(xml_node_struct* child, xml_node_struct* node)
+	{
+		xml_node_struct* parent = node->parent;
+
+		child->parent = parent;
+
+		if (node->prev_sibling_c->next_sibling)
+			node->prev_sibling_c->next_sibling = child;
+		else
+			parent->first_child = child;
+
+		child->prev_sibling_c = node->prev_sibling_c;
+		child->next_sibling = node;
+
+		node->prev_sibling_c = child;
+	}
+
+	inline void remove_node(xml_node_struct* node)
+	{
+		xml_node_struct* parent = node->parent;
+
+		if (node->next_sibling)
+			node->next_sibling->prev_sibling_c = node->prev_sibling_c;
+		else
+			parent->first_child->prev_sibling_c = node->prev_sibling_c;
+
+		if (node->prev_sibling_c->next_sibling)
+			node->prev_sibling_c->next_sibling = node->next_sibling;
+		else
+			parent->first_child = node->next_sibling;
+
+		node->parent = 0;
+		node->prev_sibling_c = 0;
+		node->next_sibling = 0;
+	}
+
+	inline void append_attribute(xml_attribute_struct* attr, xml_node_struct* node)
+	{
+		xml_attribute_struct* head = node->first_attribute;
+
+		if (head)
+		{
+			xml_attribute_struct* tail = head->prev_attribute_c;
+
+			tail->next_attribute = attr;
+			attr->prev_attribute_c = tail;
+			head->prev_attribute_c = attr;
+		}
+		else
+		{
+			node->first_attribute = attr;
+			attr->prev_attribute_c = attr;
+		}
+	}
+
+	inline void prepend_attribute(xml_attribute_struct* attr, xml_node_struct* node)
+	{
+		xml_attribute_struct* head = node->first_attribute;
+
+		if (head)
+		{
+			attr->prev_attribute_c = head->prev_attribute_c;
+			head->prev_attribute_c = attr;
+		}
+		else
+			attr->prev_attribute_c = attr;
+
+		attr->next_attribute = head;
+		node->first_attribute = attr;
+	}
+
+	inline void insert_attribute_after(xml_attribute_struct* attr, xml_attribute_struct* place, xml_node_struct* node)
+	{
+		if (place->next_attribute)
+			place->next_attribute->prev_attribute_c = attr;
+		else
+			node->first_attribute->prev_attribute_c = attr;
+
+		attr->next_attribute = place->next_attribute;
+		attr->prev_attribute_c = place;
+		place->next_attribute = attr;
+	}
+
+	inline void insert_attribute_before(xml_attribute_struct* attr, xml_attribute_struct* place, xml_node_struct* node)
+	{
+		if (place->prev_attribute_c->next_attribute)
+			place->prev_attribute_c->next_attribute = attr;
+		else
+			node->first_attribute = attr;
+
+		attr->prev_attribute_c = place->prev_attribute_c;
+		attr->next_attribute = place;
+		place->prev_attribute_c = attr;
+	}
+
+	inline void remove_attribute(xml_attribute_struct* attr, xml_node_struct* node)
+	{
+		if (attr->next_attribute)
+			attr->next_attribute->prev_attribute_c = attr->prev_attribute_c;
+		else
+			node->first_attribute->prev_attribute_c = attr->prev_attribute_c;
+
+		if (attr->prev_attribute_c->next_attribute)
+			attr->prev_attribute_c->next_attribute = attr->next_attribute;
+		else
+			node->first_attribute = attr->next_attribute;
+
+		attr->prev_attribute_c = 0;
+		attr->next_attribute = 0;
+	}
+
+	PUGI__FN_NO_INLINE xml_node_struct* append_new_node(xml_node_struct* node, xml_allocator& alloc, xml_node_type type = node_element)
+	{
+		if (!alloc.reserve()) return 0;
+
+		xml_node_struct* child = allocate_node(alloc, type);
+		if (!child) return 0;
+
+		append_node(child, node);
+
+		return child;
+	}
+
+	PUGI__FN_NO_INLINE xml_attribute_struct* append_new_attribute(xml_node_struct* node, xml_allocator& alloc)
+	{
+		if (!alloc.reserve()) return 0;
+
+		xml_attribute_struct* attr = allocate_attribute(alloc);
+		if (!attr) return 0;
+
+		append_attribute(attr, node);
+
+		return attr;
+	}
+PUGI__NS_END
+
+// Helper classes for code generation
+PUGI__NS_BEGIN
+	struct opt_false
+	{
+		enum { value = 0 };
+	};
+
+	struct opt_true
+	{
+		enum { value = 1 };
+	};
+PUGI__NS_END
+
+// Unicode utilities
+PUGI__NS_BEGIN
+	inline uint16_t endian_swap(uint16_t value)
+	{
+		return static_cast<uint16_t>(((value & 0xff) << 8) | (value >> 8));
+	}
+
+	inline uint32_t endian_swap(uint32_t value)
+	{
+		return ((value & 0xff) << 24) | ((value & 0xff00) << 8) | ((value & 0xff0000) >> 8) | (value >> 24);
+	}
+
+	struct utf8_counter
+	{
+		typedef size_t value_type;
+
+		static value_type low(value_type result, uint32_t ch)
+		{
+			// U+0000..U+007F
+			if (ch < 0x80) return result + 1;
+			// U+0080..U+07FF
+			else if (ch < 0x800) return result + 2;
+			// U+0800..U+FFFF
+			else return result + 3;
+		}
+
+		static value_type high(value_type result, uint32_t)
+		{
+			// U+10000..U+10FFFF
+			return result + 4;
+		}
+	};
+
+	struct utf8_writer
+	{
+		typedef uint8_t* value_type;
+
+		static value_type low(value_type result, uint32_t ch)
+		{
+			// U+0000..U+007F
+			if (ch < 0x80)
+			{
+				*result = static_cast<uint8_t>(ch);
+				return result + 1;
+			}
+			// U+0080..U+07FF
+			else if (ch < 0x800)
+			{
+				result[0] = static_cast<uint8_t>(0xC0 | (ch >> 6));
+				result[1] = static_cast<uint8_t>(0x80 | (ch & 0x3F));
+				return result + 2;
+			}
+			// U+0800..U+FFFF
+			else
+			{
+				result[0] = static_cast<uint8_t>(0xE0 | (ch >> 12));
+				result[1] = static_cast<uint8_t>(0x80 | ((ch >> 6) & 0x3F));
+				result[2] = static_cast<uint8_t>(0x80 | (ch & 0x3F));
+				return result + 3;
+			}
+		}
+
+		static value_type high(value_type result, uint32_t ch)
+		{
+			// U+10000..U+10FFFF
+			result[0] = static_cast<uint8_t>(0xF0 | (ch >> 18));
+			result[1] = static_cast<uint8_t>(0x80 | ((ch >> 12) & 0x3F));
+			result[2] = static_cast<uint8_t>(0x80 | ((ch >> 6) & 0x3F));
+			result[3] = static_cast<uint8_t>(0x80 | (ch & 0x3F));
+			return result + 4;
+		}
+
+		static value_type any(value_type result, uint32_t ch)
+		{
+			return (ch < 0x10000) ? low(result, ch) : high(result, ch);
+		}
+	};
+
+	struct utf16_counter
+	{
+		typedef size_t value_type;
+
+		static value_type low(value_type result, uint32_t)
+		{
+			return result + 1;
+		}
+
+		static value_type high(value_type result, uint32_t)
+		{
+			return result + 2;
+		}
+	};
+
+	struct utf16_writer
+	{
+		typedef uint16_t* value_type;
+
+		static value_type low(value_type result, uint32_t ch)
+		{
+			*result = static_cast<uint16_t>(ch);
+
+			return result + 1;
+		}
+
+		static value_type high(value_type result, uint32_t ch)
+		{
+			uint32_t msh = static_cast<uint32_t>(ch - 0x10000) >> 10;
+			uint32_t lsh = static_cast<uint32_t>(ch - 0x10000) & 0x3ff;
+
+			result[0] = static_cast<uint16_t>(0xD800 + msh);
+			result[1] = static_cast<uint16_t>(0xDC00 + lsh);
+
+			return result + 2;
+		}
+
+		static value_type any(value_type result, uint32_t ch)
+		{
+			return (ch < 0x10000) ? low(result, ch) : high(result, ch);
+		}
+	};
+
+	struct utf32_counter
+	{
+		typedef size_t value_type;
+
+		static value_type low(value_type result, uint32_t)
+		{
+			return result + 1;
+		}
+
+		static value_type high(value_type result, uint32_t)
+		{
+			return result + 1;
+		}
+	};
+
+	struct utf32_writer
+	{
+		typedef uint32_t* value_type;
+
+		static value_type low(value_type result, uint32_t ch)
+		{
+			*result = ch;
+
+			return result + 1;
+		}
+
+		static value_type high(value_type result, uint32_t ch)
+		{
+			*result = ch;
+
+			return result + 1;
+		}
+
+		static value_type any(value_type result, uint32_t ch)
+		{
+			*result = ch;
+
+			return result + 1;
+		}
+	};
+
+	struct latin1_writer
+	{
+		typedef uint8_t* value_type;
+
+		static value_type low(value_type result, uint32_t ch)
+		{
+			*result = static_cast<uint8_t>(ch > 255 ? '?' : ch);
+
+			return result + 1;
+		}
+
+		static value_type high(value_type result, uint32_t ch)
+		{
+			(void)ch;
+
+			*result = '?';
+
+			return result + 1;
+		}
+	};
+
+	struct utf8_decoder
+	{
+		typedef uint8_t type;
+
+		template <typename Traits> static inline typename Traits::value_type process(const uint8_t* data, size_t size, typename Traits::value_type result, Traits)
+		{
+			const uint8_t utf8_byte_mask = 0x3f;
+
+			while (size)
+			{
+				uint8_t lead = *data;
+
+				// 0xxxxxxx -> U+0000..U+007F
+				if (lead < 0x80)
+				{
+					result = Traits::low(result, lead);
+					data += 1;
+					size -= 1;
+
+					// process aligned single-byte (ascii) blocks
+					if ((reinterpret_cast<uintptr_t>(data) & 3) == 0)
+					{
+						// round-trip through void* to silence 'cast increases required alignment of target type' warnings
+						while (size >= 4 && (*static_cast<const uint32_t*>(static_cast<const void*>(data)) & 0x80808080) == 0)
+						{
+							result = Traits::low(result, data[0]);
+							result = Traits::low(result, data[1]);
+							result = Traits::low(result, data[2]);
+							result = Traits::low(result, data[3]);
+							data += 4;
+							size -= 4;
+						}
+					}
+				}
+				// 110xxxxx -> U+0080..U+07FF
+				else if (static_cast<unsigned int>(lead - 0xC0) < 0x20 && size >= 2 && (data[1] & 0xc0) == 0x80)
+				{
+					result = Traits::low(result, ((lead & ~0xC0) << 6) | (data[1] & utf8_byte_mask));
+					data += 2;
+					size -= 2;
+				}
+				// 1110xxxx -> U+0800-U+FFFF
+				else if (static_cast<unsigned int>(lead - 0xE0) < 0x10 && size >= 3 && (data[1] & 0xc0) == 0x80 && (data[2] & 0xc0) == 0x80)
+				{
+					result = Traits::low(result, ((lead & ~0xE0) << 12) | ((data[1] & utf8_byte_mask) << 6) | (data[2] & utf8_byte_mask));
+					data += 3;
+					size -= 3;
+				}
+				// 11110xxx -> U+10000..U+10FFFF
+				else if (static_cast<unsigned int>(lead - 0xF0) < 0x08 && size >= 4 && (data[1] & 0xc0) == 0x80 && (data[2] & 0xc0) == 0x80 && (data[3] & 0xc0) == 0x80)
+				{
+					result = Traits::high(result, ((lead & ~0xF0) << 18) | ((data[1] & utf8_byte_mask) << 12) | ((data[2] & utf8_byte_mask) << 6) | (data[3] & utf8_byte_mask));
+					data += 4;
+					size -= 4;
+				}
+				// 10xxxxxx or 11111xxx -> invalid
+				else
+				{
+					data += 1;
+					size -= 1;
+				}
+			}
+
+			return result;
+		}
+	};
+
+	template <typename opt_swap> struct utf16_decoder
+	{
+		typedef uint16_t type;
+
+		template <typename Traits> static inline typename Traits::value_type process(const uint16_t* data, size_t size, typename Traits::value_type result, Traits)
+		{
+			while (size)
+			{
+				uint16_t lead = opt_swap::value ? endian_swap(*data) : *data;
+
+				// U+0000..U+D7FF
+				if (lead < 0xD800)
+				{
+					result = Traits::low(result, lead);
+					data += 1;
+					size -= 1;
+				}
+				// U+E000..U+FFFF
+				else if (static_cast<unsigned int>(lead - 0xE000) < 0x2000)
+				{
+					result = Traits::low(result, lead);
+					data += 1;
+					size -= 1;
+				}
+				// surrogate pair lead
+				else if (static_cast<unsigned int>(lead - 0xD800) < 0x400 && size >= 2)
+				{
+					uint16_t next = opt_swap::value ? endian_swap(data[1]) : data[1];
+
+					if (static_cast<unsigned int>(next - 0xDC00) < 0x400)
+					{
+						result = Traits::high(result, 0x10000 + ((lead & 0x3ff) << 10) + (next & 0x3ff));
+						data += 2;
+						size -= 2;
+					}
+					else
+					{
+						data += 1;
+						size -= 1;
+					}
+				}
+				else
+				{
+					data += 1;
+					size -= 1;
+				}
+			}
+
+			return result;
+		}
+	};
+
+	template <typename opt_swap> struct utf32_decoder
+	{
+		typedef uint32_t type;
+
+		template <typename Traits> static inline typename Traits::value_type process(const uint32_t* data, size_t size, typename Traits::value_type result, Traits)
+		{
+			while (size)
+			{
+				uint32_t lead = opt_swap::value ? endian_swap(*data) : *data;
+
+				// U+0000..U+FFFF
+				if (lead < 0x10000)
+				{
+					result = Traits::low(result, lead);
+					data += 1;
+					size -= 1;
+				}
+				// U+10000..U+10FFFF
+				else
+				{
+					result = Traits::high(result, lead);
+					data += 1;
+					size -= 1;
+				}
+			}
+
+			return result;
+		}
+	};
+
+	struct latin1_decoder
+	{
+		typedef uint8_t type;
+
+		template <typename Traits> static inline typename Traits::value_type process(const uint8_t* data, size_t size, typename Traits::value_type result, Traits)
+		{
+			while (size)
+			{
+				result = Traits::low(result, *data);
+				data += 1;
+				size -= 1;
+			}
+
+			return result;
+		}
+	};
+
+	template <size_t size> struct wchar_selector;
+
+	template <> struct wchar_selector<2>
+	{
+		typedef uint16_t type;
+		typedef utf16_counter counter;
+		typedef utf16_writer writer;
+		typedef utf16_decoder<opt_false> decoder;
+	};
+
+	template <> struct wchar_selector<4>
+	{
+		typedef uint32_t type;
+		typedef utf32_counter counter;
+		typedef utf32_writer writer;
+		typedef utf32_decoder<opt_false> decoder;
+	};
+
+	typedef wchar_selector<sizeof(wchar_t)>::counter wchar_counter;
+	typedef wchar_selector<sizeof(wchar_t)>::writer wchar_writer;
+
+	struct wchar_decoder
+	{
+		typedef wchar_t type;
+
+		template <typename Traits> static inline typename Traits::value_type process(const wchar_t* data, size_t size, typename Traits::value_type result, Traits traits)
+		{
+			typedef wchar_selector<sizeof(wchar_t)>::decoder decoder;
+
+			return decoder::process(reinterpret_cast<const typename decoder::type*>(data), size, result, traits);
+		}
+	};
+
+#ifdef PUGIXML_WCHAR_MODE
+	PUGI__FN void convert_wchar_endian_swap(wchar_t* result, const wchar_t* data, size_t length)
+	{
+		for (size_t i = 0; i < length; ++i)
+			result[i] = static_cast<wchar_t>(endian_swap(static_cast<wchar_selector<sizeof(wchar_t)>::type>(data[i])));
+	}
+#endif
+PUGI__NS_END
+
+PUGI__NS_BEGIN
+	enum chartype_t
+	{
+		ct_parse_pcdata = 1,	// \0, &, \r, <
+		ct_parse_attr = 2,		// \0, &, \r, ', "
+		ct_parse_attr_ws = 4,	// \0, &, \r, ', ", \n, tab
+		ct_space = 8,			// \r, \n, space, tab
+		ct_parse_cdata = 16,	// \0, ], >, \r
+		ct_parse_comment = 32,	// \0, -, >, \r
+		ct_symbol = 64,			// Any symbol > 127, a-z, A-Z, 0-9, _, :, -, .
+		ct_start_symbol = 128	// Any symbol > 127, a-z, A-Z, _, :
+	};
+
+	static const unsigned char chartype_table[256] =
+	{
+		55,  0,   0,   0,   0,   0,   0,   0,      0,   12,  12,  0,   0,   63,  0,   0,   // 0-15
+		0,   0,   0,   0,   0,   0,   0,   0,      0,   0,   0,   0,   0,   0,   0,   0,   // 16-31
+		8,   0,   6,   0,   0,   0,   7,   6,      0,   0,   0,   0,   0,   96,  64,  0,   // 32-47
+		64,  64,  64,  64,  64,  64,  64,  64,     64,  64,  192, 0,   1,   0,   48,  0,   // 48-63
+		0,   192, 192, 192, 192, 192, 192, 192,    192, 192, 192, 192, 192, 192, 192, 192, // 64-79
+		192, 192, 192, 192, 192, 192, 192, 192,    192, 192, 192, 0,   0,   16,  0,   192, // 80-95
+		0,   192, 192, 192, 192, 192, 192, 192,    192, 192, 192, 192, 192, 192, 192, 192, // 96-111
+		192, 192, 192, 192, 192, 192, 192, 192,    192, 192, 192, 0, 0, 0, 0, 0,           // 112-127
+
+		192, 192, 192, 192, 192, 192, 192, 192,    192, 192, 192, 192, 192, 192, 192, 192, // 128+
+		192, 192, 192, 192, 192, 192, 192, 192,    192, 192, 192, 192, 192, 192, 192, 192,
+		192, 192, 192, 192, 192, 192, 192, 192,    192, 192, 192, 192, 192, 192, 192, 192,
+		192, 192, 192, 192, 192, 192, 192, 192,    192, 192, 192, 192, 192, 192, 192, 192,
+		192, 192, 192, 192, 192, 192, 192, 192,    192, 192, 192, 192, 192, 192, 192, 192,
+		192, 192, 192, 192, 192, 192, 192, 192,    192, 192, 192, 192, 192, 192, 192, 192,
+		192, 192, 192, 192, 192, 192, 192, 192,    192, 192, 192, 192, 192, 192, 192, 192,
+		192, 192, 192, 192, 192, 192, 192, 192,    192, 192, 192, 192, 192, 192, 192, 192
+	};
+
+	enum chartypex_t
+	{
+		ctx_special_pcdata = 1,   // Any symbol >= 0 and < 32 (except \t, \r, \n), &, <, >
+		ctx_special_attr = 2,     // Any symbol >= 0 and < 32, &, <, ", '
+		ctx_start_symbol = 4,	  // Any symbol > 127, a-z, A-Z, _
+		ctx_digit = 8,			  // 0-9
+		ctx_symbol = 16			  // Any symbol > 127, a-z, A-Z, 0-9, _, -, .
+	};
+
+	static const unsigned char chartypex_table[256] =
+	{
+		3,  3,  3,  3,  3,  3,  3,  3,     3,  2,  2,  3,  3,  2,  3,  3,     // 0-15
+		3,  3,  3,  3,  3,  3,  3,  3,     3,  3,  3,  3,  3,  3,  3,  3,     // 16-31
+		0,  0,  2,  0,  0,  0,  3,  2,     0,  0,  0,  0,  0, 16, 16,  0,     // 32-47
+		24, 24, 24, 24, 24, 24, 24, 24,    24, 24, 0,  0,  3,  0,  1,  0,     // 48-63
+
+		0,  20, 20, 20, 20, 20, 20, 20,    20, 20, 20, 20, 20, 20, 20, 20,    // 64-79
+		20, 20, 20, 20, 20, 20, 20, 20,    20, 20, 20, 0,  0,  0,  0,  20,    // 80-95
+		0,  20, 20, 20, 20, 20, 20, 20,    20, 20, 20, 20, 20, 20, 20, 20,    // 96-111
+		20, 20, 20, 20, 20, 20, 20, 20,    20, 20, 20, 0,  0,  0,  0,  0,     // 112-127
+
+		20, 20, 20, 20, 20, 20, 20, 20,    20, 20, 20, 20, 20, 20, 20, 20,    // 128+
+		20, 20, 20, 20, 20, 20, 20, 20,    20, 20, 20, 20, 20, 20, 20, 20,
+		20, 20, 20, 20, 20, 20, 20, 20,    20, 20, 20, 20, 20, 20, 20, 20,
+		20, 20, 20, 20, 20, 20, 20, 20,    20, 20, 20, 20, 20, 20, 20, 20,
+		20, 20, 20, 20, 20, 20, 20, 20,    20, 20, 20, 20, 20, 20, 20, 20,
+		20, 20, 20, 20, 20, 20, 20, 20,    20, 20, 20, 20, 20, 20, 20, 20,
+		20, 20, 20, 20, 20, 20, 20, 20,    20, 20, 20, 20, 20, 20, 20, 20,
+		20, 20, 20, 20, 20, 20, 20, 20,    20, 20, 20, 20, 20, 20, 20, 20
+	};
+
+#ifdef PUGIXML_WCHAR_MODE
+	#define PUGI__IS_CHARTYPE_IMPL(c, ct, table) ((static_cast<unsigned int>(c) < 128 ? table[static_cast<unsigned int>(c)] : table[128]) & (ct))
+#else
+	#define PUGI__IS_CHARTYPE_IMPL(c, ct, table) (table[static_cast<unsigned char>(c)] & (ct))
+#endif
+
+	#define PUGI__IS_CHARTYPE(c, ct) PUGI__IS_CHARTYPE_IMPL(c, ct, chartype_table)
+	#define PUGI__IS_CHARTYPEX(c, ct) PUGI__IS_CHARTYPE_IMPL(c, ct, chartypex_table)
+
+	PUGI__FN bool is_little_endian()
+	{
+		unsigned int ui = 1;
+
+		return *reinterpret_cast<unsigned char*>(&ui) == 1;
+	}
+
+	PUGI__FN xml_encoding get_wchar_encoding()
+	{
+		PUGI__STATIC_ASSERT(sizeof(wchar_t) == 2 || sizeof(wchar_t) == 4);
+
+		if (sizeof(wchar_t) == 2)
+			return is_little_endian() ? encoding_utf16_le : encoding_utf16_be;
+		else
+			return is_little_endian() ? encoding_utf32_le : encoding_utf32_be;
+	}
+
+	PUGI__FN bool parse_declaration_encoding(const uint8_t* data, size_t size, const uint8_t*& out_encoding, size_t& out_length)
+	{
+	#define PUGI__SCANCHAR(ch) { if (offset >= size || data[offset] != ch) return false; offset++; }
+	#define PUGI__SCANCHARTYPE(ct) { while (offset < size && PUGI__IS_CHARTYPE(data[offset], ct)) offset++; }
+
+		// check if we have a non-empty XML declaration
+		if (size < 6 || !((data[0] == '<') & (data[1] == '?') & (data[2] == 'x') & (data[3] == 'm') & (data[4] == 'l') && PUGI__IS_CHARTYPE(data[5], ct_space)))
+			return false;
+
+		// scan XML declaration until the encoding field
+		for (size_t i = 6; i + 1 < size; ++i)
+		{
+			// declaration can not contain ? in quoted values
+			if (data[i] == '?')
+				return false;
+
+			if (data[i] == 'e' && data[i + 1] == 'n')
+			{
+				size_t offset = i;
+
+				// encoding follows the version field which can't contain 'en' so this has to be the encoding if XML is well formed
+				PUGI__SCANCHAR('e'); PUGI__SCANCHAR('n'); PUGI__SCANCHAR('c'); PUGI__SCANCHAR('o');
+				PUGI__SCANCHAR('d'); PUGI__SCANCHAR('i'); PUGI__SCANCHAR('n'); PUGI__SCANCHAR('g');
+
+				// S? = S?
+				PUGI__SCANCHARTYPE(ct_space);
+				PUGI__SCANCHAR('=');
+				PUGI__SCANCHARTYPE(ct_space);
+
+				// the only two valid delimiters are ' and "
+				uint8_t delimiter = (offset < size && data[offset] == '"') ? '"' : '\'';
+
+				PUGI__SCANCHAR(delimiter);
+
+				size_t start = offset;
+
+				out_encoding = data + offset;
+
+				PUGI__SCANCHARTYPE(ct_symbol);
+
+				out_length = offset - start;
+
+				PUGI__SCANCHAR(delimiter);
+
+				return true;
+			}
+		}
+
+		return false;
+
+	#undef PUGI__SCANCHAR
+	#undef PUGI__SCANCHARTYPE
+	}
+
+	PUGI__FN xml_encoding guess_buffer_encoding(const uint8_t* data, size_t size)
+	{
+		// skip encoding autodetection if input buffer is too small
+		if (size < 4) return encoding_utf8;
+
+		uint8_t d0 = data[0], d1 = data[1], d2 = data[2], d3 = data[3];
+
+		// look for BOM in first few bytes
+		if (d0 == 0 && d1 == 0 && d2 == 0xfe && d3 == 0xff) return encoding_utf32_be;
+		if (d0 == 0xff && d1 == 0xfe && d2 == 0 && d3 == 0) return encoding_utf32_le;
+		if (d0 == 0xfe && d1 == 0xff) return encoding_utf16_be;
+		if (d0 == 0xff && d1 == 0xfe) return encoding_utf16_le;
+		if (d0 == 0xef && d1 == 0xbb && d2 == 0xbf) return encoding_utf8;
+
+		// look for <, <? or <?xm in various encodings
+		if (d0 == 0 && d1 == 0 && d2 == 0 && d3 == 0x3c) return encoding_utf32_be;
+		if (d0 == 0x3c && d1 == 0 && d2 == 0 && d3 == 0) return encoding_utf32_le;
+		if (d0 == 0 && d1 == 0x3c && d2 == 0 && d3 == 0x3f) return encoding_utf16_be;
+		if (d0 == 0x3c && d1 == 0 && d2 == 0x3f && d3 == 0) return encoding_utf16_le;
+
+		// look for utf16 < followed by node name (this may fail, but is better than utf8 since it's zero terminated so early)
+		if (d0 == 0 && d1 == 0x3c) return encoding_utf16_be;
+		if (d0 == 0x3c && d1 == 0) return encoding_utf16_le;
+
+		// no known BOM detected; parse declaration
+		const uint8_t* enc = 0;
+		size_t enc_length = 0;
+
+		if (d0 == 0x3c && d1 == 0x3f && d2 == 0x78 && d3 == 0x6d && parse_declaration_encoding(data, size, enc, enc_length))
+		{
+			// iso-8859-1 (case-insensitive)
+			if (enc_length == 10
+				&& (enc[0] | ' ') == 'i' && (enc[1] | ' ') == 's' && (enc[2] | ' ') == 'o'
+				&& enc[3] == '-' && enc[4] == '8' && enc[5] == '8' && enc[6] == '5' && enc[7] == '9'
+				&& enc[8] == '-' && enc[9] == '1')
+				return encoding_latin1;
+
+			// latin1 (case-insensitive)
+			if (enc_length == 6
+				&& (enc[0] | ' ') == 'l' && (enc[1] | ' ') == 'a' && (enc[2] | ' ') == 't'
+				&& (enc[3] | ' ') == 'i' && (enc[4] | ' ') == 'n'
+				&& enc[5] == '1')
+				return encoding_latin1;
+		}
+
+		return encoding_utf8;
+	}
+
+	PUGI__FN xml_encoding get_buffer_encoding(xml_encoding encoding, const void* contents, size_t size)
+	{
+		// replace wchar encoding with utf implementation
+		if (encoding == encoding_wchar) return get_wchar_encoding();
+
+		// replace utf16 encoding with utf16 with specific endianness
+		if (encoding == encoding_utf16) return is_little_endian() ? encoding_utf16_le : encoding_utf16_be;
+
+		// replace utf32 encoding with utf32 with specific endianness
+		if (encoding == encoding_utf32) return is_little_endian() ? encoding_utf32_le : encoding_utf32_be;
+
+		// only do autodetection if no explicit encoding is requested
+		if (encoding != encoding_auto) return encoding;
+
+		// try to guess encoding (based on XML specification, Appendix F.1)
+		const uint8_t* data = static_cast<const uint8_t*>(contents);
+
+		return guess_buffer_encoding(data, size);
+	}
+
+	PUGI__FN bool get_mutable_buffer(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, bool is_mutable)
+	{
+		size_t length = size / sizeof(char_t);
+
+		if (is_mutable)
+		{
+			out_buffer = static_cast<char_t*>(const_cast<void*>(contents));
+			out_length = length;
+		}
+		else
+		{
+			char_t* buffer = static_cast<char_t*>(xml_memory::allocate((length + 1) * sizeof(char_t)));
+			if (!buffer) return false;
+
+			if (contents)
+				memcpy(buffer, contents, length * sizeof(char_t));
+			else
+				assert(length == 0);
+
+			buffer[length] = 0;
+
+			out_buffer = buffer;
+			out_length = length + 1;
+		}
+
+		return true;
+	}
+
+#ifdef PUGIXML_WCHAR_MODE
+	PUGI__FN bool need_endian_swap_utf(xml_encoding le, xml_encoding re)
+	{
+		return (le == encoding_utf16_be && re == encoding_utf16_le) || (le == encoding_utf16_le && re == encoding_utf16_be) ||
+			   (le == encoding_utf32_be && re == encoding_utf32_le) || (le == encoding_utf32_le && re == encoding_utf32_be);
+	}
+
+	PUGI__FN bool convert_buffer_endian_swap(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, bool is_mutable)
+	{
+		const char_t* data = static_cast<const char_t*>(contents);
+		size_t length = size / sizeof(char_t);
+
+		if (is_mutable)
+		{
+			char_t* buffer = const_cast<char_t*>(data);
+
+			convert_wchar_endian_swap(buffer, data, length);
+
+			out_buffer = buffer;
+			out_length = length;
+		}
+		else
+		{
+			char_t* buffer = static_cast<char_t*>(xml_memory::allocate((length + 1) * sizeof(char_t)));
+			if (!buffer) return false;
+
+			convert_wchar_endian_swap(buffer, data, length);
+			buffer[length] = 0;
+
+			out_buffer = buffer;
+			out_length = length + 1;
+		}
+
+		return true;
+	}
+
+	template <typename D> PUGI__FN bool convert_buffer_generic(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, D)
+	{
+		const typename D::type* data = static_cast<const typename D::type*>(contents);
+		size_t data_length = size / sizeof(typename D::type);
+
+		// first pass: get length in wchar_t units
+		size_t length = D::process(data, data_length, 0, wchar_counter());
+
+		// allocate buffer of suitable length
+		char_t* buffer = static_cast<char_t*>(xml_memory::allocate((length + 1) * sizeof(char_t)));
+		if (!buffer) return false;
+
+		// second pass: convert utf16 input to wchar_t
+		wchar_writer::value_type obegin = reinterpret_cast<wchar_writer::value_type>(buffer);
+		wchar_writer::value_type oend = D::process(data, data_length, obegin, wchar_writer());
+
+		assert(oend == obegin + length);
+		*oend = 0;
+
+		out_buffer = buffer;
+		out_length = length + 1;
+
+		return true;
+	}
+
+	PUGI__FN bool convert_buffer(char_t*& out_buffer, size_t& out_length, xml_encoding encoding, const void* contents, size_t size, bool is_mutable)
+	{
+		// get native encoding
+		xml_encoding wchar_encoding = get_wchar_encoding();
+
+		// fast path: no conversion required
+		if (encoding == wchar_encoding)
+			return get_mutable_buffer(out_buffer, out_length, contents, size, is_mutable);
+
+		// only endian-swapping is required
+		if (need_endian_swap_utf(encoding, wchar_encoding))
+			return convert_buffer_endian_swap(out_buffer, out_length, contents, size, is_mutable);
+
+		// source encoding is utf8
+		if (encoding == encoding_utf8)
+			return convert_buffer_generic(out_buffer, out_length, contents, size, utf8_decoder());
+
+		// source encoding is utf16
+		if (encoding == encoding_utf16_be || encoding == encoding_utf16_le)
+		{
+			xml_encoding native_encoding = is_little_endian() ? encoding_utf16_le : encoding_utf16_be;
+
+			return (native_encoding == encoding) ?
+				convert_buffer_generic(out_buffer, out_length, contents, size, utf16_decoder<opt_false>()) :
+				convert_buffer_generic(out_buffer, out_length, contents, size, utf16_decoder<opt_true>());
+		}
+
+		// source encoding is utf32
+		if (encoding == encoding_utf32_be || encoding == encoding_utf32_le)
+		{
+			xml_encoding native_encoding = is_little_endian() ? encoding_utf32_le : encoding_utf32_be;
+
+			return (native_encoding == encoding) ?
+				convert_buffer_generic(out_buffer, out_length, contents, size, utf32_decoder<opt_false>()) :
+				convert_buffer_generic(out_buffer, out_length, contents, size, utf32_decoder<opt_true>());
+		}
+
+		// source encoding is latin1
+		if (encoding == encoding_latin1)
+			return convert_buffer_generic(out_buffer, out_length, contents, size, latin1_decoder());
+
+		assert(false && "Invalid encoding"); // unreachable
+		return false;
+	}
+#else
+	template <typename D> PUGI__FN bool convert_buffer_generic(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, D)
+	{
+		const typename D::type* data = static_cast<const typename D::type*>(contents);
+		size_t data_length = size / sizeof(typename D::type);
+
+		// first pass: get length in utf8 units
+		size_t length = D::process(data, data_length, 0, utf8_counter());
+
+		// allocate buffer of suitable length
+		char_t* buffer = static_cast<char_t*>(xml_memory::allocate((length + 1) * sizeof(char_t)));
+		if (!buffer) return false;
+
+		// second pass: convert utf16 input to utf8
+		uint8_t* obegin = reinterpret_cast<uint8_t*>(buffer);
+		uint8_t* oend = D::process(data, data_length, obegin, utf8_writer());
+
+		assert(oend == obegin + length);
+		*oend = 0;
+
+		out_buffer = buffer;
+		out_length = length + 1;
+
+		return true;
+	}
+
+	PUGI__FN size_t get_latin1_7bit_prefix_length(const uint8_t* data, size_t size)
+	{
+		for (size_t i = 0; i < size; ++i)
+			if (data[i] > 127)
+				return i;
+
+		return size;
+	}
+
+	PUGI__FN bool convert_buffer_latin1(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, bool is_mutable)
+	{
+		const uint8_t* data = static_cast<const uint8_t*>(contents);
+		size_t data_length = size;
+
+		// get size of prefix that does not need utf8 conversion
+		size_t prefix_length = get_latin1_7bit_prefix_length(data, data_length);
+		assert(prefix_length <= data_length);
+
+		const uint8_t* postfix = data + prefix_length;
+		size_t postfix_length = data_length - prefix_length;
+
+		// if no conversion is needed, just return the original buffer
+		if (postfix_length == 0) return get_mutable_buffer(out_buffer, out_length, contents, size, is_mutable);
+
+		// first pass: get length in utf8 units
+		size_t length = prefix_length + latin1_decoder::process(postfix, postfix_length, 0, utf8_counter());
+
+		// allocate buffer of suitable length
+		char_t* buffer = static_cast<char_t*>(xml_memory::allocate((length + 1) * sizeof(char_t)));
+		if (!buffer) return false;
+
+		// second pass: convert latin1 input to utf8
+		memcpy(buffer, data, prefix_length);
+
+		uint8_t* obegin = reinterpret_cast<uint8_t*>(buffer);
+		uint8_t* oend = latin1_decoder::process(postfix, postfix_length, obegin + prefix_length, utf8_writer());
+
+		assert(oend == obegin + length);
+		*oend = 0;
+
+		out_buffer = buffer;
+		out_length = length + 1;
+
+		return true;
+	}
+
+	PUGI__FN bool convert_buffer(char_t*& out_buffer, size_t& out_length, xml_encoding encoding, const void* contents, size_t size, bool is_mutable)
+	{
+		// fast path: no conversion required
+		if (encoding == encoding_utf8)
+			return get_mutable_buffer(out_buffer, out_length, contents, size, is_mutable);
+
+		// source encoding is utf16
+		if (encoding == encoding_utf16_be || encoding == encoding_utf16_le)
+		{
+			xml_encoding native_encoding = is_little_endian() ? encoding_utf16_le : encoding_utf16_be;
+
+			return (native_encoding == encoding) ?
+				convert_buffer_generic(out_buffer, out_length, contents, size, utf16_decoder<opt_false>()) :
+				convert_buffer_generic(out_buffer, out_length, contents, size, utf16_decoder<opt_true>());
+		}
+
+		// source encoding is utf32
+		if (encoding == encoding_utf32_be || encoding == encoding_utf32_le)
+		{
+			xml_encoding native_encoding = is_little_endian() ? encoding_utf32_le : encoding_utf32_be;
+
+			return (native_encoding == encoding) ?
+				convert_buffer_generic(out_buffer, out_length, contents, size, utf32_decoder<opt_false>()) :
+				convert_buffer_generic(out_buffer, out_length, contents, size, utf32_decoder<opt_true>());
+		}
+
+		// source encoding is latin1
+		if (encoding == encoding_latin1)
+			return convert_buffer_latin1(out_buffer, out_length, contents, size, is_mutable);
+
+		assert(false && "Invalid encoding"); // unreachable
+		return false;
+	}
+#endif
+
+	PUGI__FN size_t as_utf8_begin(const wchar_t* str, size_t length)
+	{
+		// get length in utf8 characters
+		return wchar_decoder::process(str, length, 0, utf8_counter());
+	}
+
+	PUGI__FN void as_utf8_end(char* buffer, size_t size, const wchar_t* str, size_t length)
+	{
+		// convert to utf8
+		uint8_t* begin = reinterpret_cast<uint8_t*>(buffer);
+		uint8_t* end = wchar_decoder::process(str, length, begin, utf8_writer());
+
+		assert(begin + size == end);
+		(void)!end;
+		(void)!size;
+	}
+
+#ifndef PUGIXML_NO_STL
+	PUGI__FN std::string as_utf8_impl(const wchar_t* str, size_t length)
+	{
+		// first pass: get length in utf8 characters
+		size_t size = as_utf8_begin(str, length);
+
+		// allocate resulting string
+		std::string result;
+		result.resize(size);
+
+		// second pass: convert to utf8
+		if (size > 0) as_utf8_end(&result[0], size, str, length);
+
+		return result;
+	}
+
+	PUGI__FN std::basic_string<wchar_t> as_wide_impl(const char* str, size_t size)
+	{
+		const uint8_t* data = reinterpret_cast<const uint8_t*>(str);
+
+		// first pass: get length in wchar_t units
+		size_t length = utf8_decoder::process(data, size, 0, wchar_counter());
+
+		// allocate resulting string
+		std::basic_string<wchar_t> result;
+		result.resize(length);
+
+		// second pass: convert to wchar_t
+		if (length > 0)
+		{
+			wchar_writer::value_type begin = reinterpret_cast<wchar_writer::value_type>(&result[0]);
+			wchar_writer::value_type end = utf8_decoder::process(data, size, begin, wchar_writer());
+
+			assert(begin + length == end);
+			(void)!end;
+		}
+
+		return result;
+	}
+#endif
+
+	template <typename Header>
+	inline bool strcpy_insitu_allow(size_t length, const Header& header, uintptr_t header_mask, char_t* target)
+	{
+		// never reuse shared memory
+		if (header & xml_memory_page_contents_shared_mask) return false;
+
+		size_t target_length = strlength(target);
+
+		// always reuse document buffer memory if possible
+		if ((header & header_mask) == 0) return target_length >= length;
+
+		// reuse heap memory if waste is not too great
+		const size_t reuse_threshold = 32;
+
+		return target_length >= length && (target_length < reuse_threshold || target_length - length < target_length / 2);
+	}
+
+	template <typename String, typename Header>
+	PUGI__FN bool strcpy_insitu(String& dest, Header& header, uintptr_t header_mask, const char_t* source, size_t source_length)
+	{
+		if (source_length == 0)
+		{
+			// empty string and null pointer are equivalent, so just deallocate old memory
+			xml_allocator* alloc = PUGI__GETPAGE_IMPL(header)->allocator;
+
+			if (header & header_mask) alloc->deallocate_string(dest);
+
+			// mark the string as not allocated
+			dest = 0;
+			header &= ~header_mask;
+
+			return true;
+		}
+		else if (dest && strcpy_insitu_allow(source_length, header, header_mask, dest))
+		{
+			// we can reuse old buffer, so just copy the new data (including zero terminator)
+			memcpy(dest, source, source_length * sizeof(char_t));
+			dest[source_length] = 0;
+
+			return true;
+		}
+		else
+		{
+			xml_allocator* alloc = PUGI__GETPAGE_IMPL(header)->allocator;
+
+			if (!alloc->reserve()) return false;
+
+			// allocate new buffer
+			char_t* buf = alloc->allocate_string(source_length + 1);
+			if (!buf) return false;
+
+			// copy the string (including zero terminator)
+			memcpy(buf, source, source_length * sizeof(char_t));
+			buf[source_length] = 0;
+
+			// deallocate old buffer (*after* the above to protect against overlapping memory and/or allocation failures)
+			if (header & header_mask) alloc->deallocate_string(dest);
+
+			// the string is now allocated, so set the flag
+			dest = buf;
+			header |= header_mask;
+
+			return true;
+		}
+	}
+
+	struct gap
+	{
+		char_t* end;
+		size_t size;
+
+		gap(): end(0), size(0)
+		{
+		}
+
+		// Push new gap, move s count bytes further (skipping the gap).
+		// Collapse previous gap.
+		void push(char_t*& s, size_t count)
+		{
+			if (end) // there was a gap already; collapse it
+			{
+				// Move [old_gap_end, new_gap_start) to [old_gap_start, ...)
+				assert(s >= end);
+				memmove(end - size, end, reinterpret_cast<char*>(s) - reinterpret_cast<char*>(end));
+			}
+
+			s += count; // end of current gap
+
+			// "merge" two gaps
+			end = s;
+			size += count;
+		}
+
+		// Collapse all gaps, return past-the-end pointer
+		char_t* flush(char_t* s)
+		{
+			if (end)
+			{
+				// Move [old_gap_end, current_pos) to [old_gap_start, ...)
+				assert(s >= end);
+				memmove(end - size, end, reinterpret_cast<char*>(s) - reinterpret_cast<char*>(end));
+
+				return s - size;
+			}
+			else return s;
+		}
+	};
+
+	PUGI__FN char_t* strconv_escape(char_t* s, gap& g)
+	{
+		char_t* stre = s + 1;
+
+		switch (*stre)
+		{
+			case '#':	// &#...
+			{
+				unsigned int ucsc = 0;
+
+				if (stre[1] == 'x') // &#x... (hex code)
+				{
+					stre += 2;
+
+					char_t ch = *stre;
+
+					if (ch == ';') return stre;
+
+					for (;;)
+					{
+						if (static_cast<unsigned int>(ch - '0') <= 9)
+							ucsc = 16 * ucsc + (ch - '0');
+						else if (static_cast<unsigned int>((ch | ' ') - 'a') <= 5)
+							ucsc = 16 * ucsc + ((ch | ' ') - 'a' + 10);
+						else if (ch == ';')
+							break;
+						else // cancel
+							return stre;
+
+						ch = *++stre;
+					}
+
+					++stre;
+				}
+				else	// &#... (dec code)
+				{
+					char_t ch = *++stre;
+
+					if (ch == ';') return stre;
+
+					for (;;)
+					{
+						if (static_cast<unsigned int>(ch - '0') <= 9)
+							ucsc = 10 * ucsc + (ch - '0');
+						else if (ch == ';')
+							break;
+						else // cancel
+							return stre;
+
+						ch = *++stre;
+					}
+
+					++stre;
+				}
+
+			#ifdef PUGIXML_WCHAR_MODE
+				s = reinterpret_cast<char_t*>(wchar_writer::any(reinterpret_cast<wchar_writer::value_type>(s), ucsc));
+			#else
+				s = reinterpret_cast<char_t*>(utf8_writer::any(reinterpret_cast<uint8_t*>(s), ucsc));
+			#endif
+
+				g.push(s, stre - s);
+				return stre;
+			}
+
+			case 'a':	// &a
+			{
+				++stre;
+
+				if (*stre == 'm') // &am
+				{
+					if (*++stre == 'p' && *++stre == ';') // &amp;
+					{
+						*s++ = '&';
+						++stre;
+
+						g.push(s, stre - s);
+						return stre;
+					}
+				}
+				else if (*stre == 'p') // &ap
+				{
+					if (*++stre == 'o' && *++stre == 's' && *++stre == ';') // &apos;
+					{
+						*s++ = '\'';
+						++stre;
+
+						g.push(s, stre - s);
+						return stre;
+					}
+				}
+				break;
+			}
+
+			case 'g': // &g
+			{
+				if (*++stre == 't' && *++stre == ';') // &gt;
+				{
+					*s++ = '>';
+					++stre;
+
+					g.push(s, stre - s);
+					return stre;
+				}
+				break;
+			}
+
+			case 'l': // &l
+			{
+				if (*++stre == 't' && *++stre == ';') // &lt;
+				{
+					*s++ = '<';
+					++stre;
+
+					g.push(s, stre - s);
+					return stre;
+				}
+				break;
+			}
+
+			case 'q': // &q
+			{
+				if (*++stre == 'u' && *++stre == 'o' && *++stre == 't' && *++stre == ';') // &quot;
+				{
+					*s++ = '"';
+					++stre;
+
+					g.push(s, stre - s);
+					return stre;
+				}
+				break;
+			}
+
+			default:
+				break;
+		}
+
+		return stre;
+	}
+
+	// Parser utilities
+	#define PUGI__ENDSWITH(c, e)        ((c) == (e) || ((c) == 0 && endch == (e)))
+	#define PUGI__SKIPWS()              { while (PUGI__IS_CHARTYPE(*s, ct_space)) ++s; }
+	#define PUGI__OPTSET(OPT)           ( optmsk & (OPT) )
+	#define PUGI__PUSHNODE(TYPE)        { cursor = append_new_node(cursor, *alloc, TYPE); if (!cursor) PUGI__THROW_ERROR(status_out_of_memory, s); }
+	#define PUGI__POPNODE()             { cursor = cursor->parent; }
+	#define PUGI__SCANFOR(X)            { while (*s != 0 && !(X)) ++s; }
+	#define PUGI__SCANWHILE(X)          { while (X) ++s; }
+	#define PUGI__SCANWHILE_UNROLL(X)   { for (;;) { char_t ss = s[0]; if (PUGI__UNLIKELY(!(X))) { break; } ss = s[1]; if (PUGI__UNLIKELY(!(X))) { s += 1; break; } ss = s[2]; if (PUGI__UNLIKELY(!(X))) { s += 2; break; } ss = s[3]; if (PUGI__UNLIKELY(!(X))) { s += 3; break; } s += 4; } }
+	#define PUGI__ENDSEG()              { ch = *s; *s = 0; ++s; }
+	#define PUGI__THROW_ERROR(err, m)   return error_offset = m, error_status = err, static_cast<char_t*>(0)
+	#define PUGI__CHECK_ERROR(err, m)   { if (*s == 0) PUGI__THROW_ERROR(err, m); }
+
+	PUGI__FN char_t* strconv_comment(char_t* s, char_t endch)
+	{
+		gap g;
+
+		while (true)
+		{
+			PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPE(ss, ct_parse_comment));
+
+			if (*s == '\r') // Either a single 0x0d or 0x0d 0x0a pair
+			{
+				*s++ = '\n'; // replace first one with 0x0a
+
+				if (*s == '\n') g.push(s, 1);
+			}
+			else if (s[0] == '-' && s[1] == '-' && PUGI__ENDSWITH(s[2], '>')) // comment ends here
+			{
+				*g.flush(s) = 0;
+
+				return s + (s[2] == '>' ? 3 : 2);
+			}
+			else if (*s == 0)
+			{
+				return 0;
+			}
+			else ++s;
+		}
+	}
+
+	PUGI__FN char_t* strconv_cdata(char_t* s, char_t endch)
+	{
+		gap g;
+
+		while (true)
+		{
+			PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPE(ss, ct_parse_cdata));
+
+			if (*s == '\r') // Either a single 0x0d or 0x0d 0x0a pair
+			{
+				*s++ = '\n'; // replace first one with 0x0a
+
+				if (*s == '\n') g.push(s, 1);
+			}
+			else if (s[0] == ']' && s[1] == ']' && PUGI__ENDSWITH(s[2], '>')) // CDATA ends here
+			{
+				*g.flush(s) = 0;
+
+				return s + 1;
+			}
+			else if (*s == 0)
+			{
+				return 0;
+			}
+			else ++s;
+		}
+	}
+
+	typedef char_t* (*strconv_pcdata_t)(char_t*);
+
+	template <typename opt_trim, typename opt_eol, typename opt_escape> struct strconv_pcdata_impl
+	{
+		static char_t* parse(char_t* s)
+		{
+			gap g;
+
+			char_t* begin = s;
+
+			while (true)
+			{
+				PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPE(ss, ct_parse_pcdata));
+
+				if (*s == '<') // PCDATA ends here
+				{
+					char_t* end = g.flush(s);
+
+					if (opt_trim::value)
+						while (end > begin && PUGI__IS_CHARTYPE(end[-1], ct_space))
+							--end;
+
+					*end = 0;
+
+					return s + 1;
+				}
+				else if (opt_eol::value && *s == '\r') // Either a single 0x0d or 0x0d 0x0a pair
+				{
+					*s++ = '\n'; // replace first one with 0x0a
+
+					if (*s == '\n') g.push(s, 1);
+				}
+				else if (opt_escape::value && *s == '&')
+				{
+					s = strconv_escape(s, g);
+				}
+				else if (*s == 0)
+				{
+					char_t* end = g.flush(s);
+
+					if (opt_trim::value)
+						while (end > begin && PUGI__IS_CHARTYPE(end[-1], ct_space))
+							--end;
+
+					*end = 0;
+
+					return s;
+				}
+				else ++s;
+			}
+		}
+	};
+
+	PUGI__FN strconv_pcdata_t get_strconv_pcdata(unsigned int optmask)
+	{
+		PUGI__STATIC_ASSERT(parse_escapes == 0x10 && parse_eol == 0x20 && parse_trim_pcdata == 0x0800);
+
+		switch (((optmask >> 4) & 3) | ((optmask >> 9) & 4)) // get bitmask for flags (trim eol escapes); this simultaneously checks 3 options from assertion above
+		{
+		case 0: return strconv_pcdata_impl<opt_false, opt_false, opt_false>::parse;
+		case 1: return strconv_pcdata_impl<opt_false, opt_false, opt_true>::parse;
+		case 2: return strconv_pcdata_impl<opt_false, opt_true, opt_false>::parse;
+		case 3: return strconv_pcdata_impl<opt_false, opt_true, opt_true>::parse;
+		case 4: return strconv_pcdata_impl<opt_true, opt_false, opt_false>::parse;
+		case 5: return strconv_pcdata_impl<opt_true, opt_false, opt_true>::parse;
+		case 6: return strconv_pcdata_impl<opt_true, opt_true, opt_false>::parse;
+		case 7: return strconv_pcdata_impl<opt_true, opt_true, opt_true>::parse;
+		default: assert(false); return 0; // unreachable
+		}
+	}
+
+	typedef char_t* (*strconv_attribute_t)(char_t*, char_t);
+
+	template <typename opt_escape> struct strconv_attribute_impl
+	{
+		static char_t* parse_wnorm(char_t* s, char_t end_quote)
+		{
+			gap g;
+
+			// trim leading whitespaces
+			if (PUGI__IS_CHARTYPE(*s, ct_space))
+			{
+				char_t* str = s;
+
+				do ++str;
+				while (PUGI__IS_CHARTYPE(*str, ct_space));
+
+				g.push(s, str - s);
+			}
+
+			while (true)
+			{
+				PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPE(ss, ct_parse_attr_ws | ct_space));
+
+				if (*s == end_quote)
+				{
+					char_t* str = g.flush(s);
+
+					do *str-- = 0;
+					while (PUGI__IS_CHARTYPE(*str, ct_space));
+
+					return s + 1;
+				}
+				else if (PUGI__IS_CHARTYPE(*s, ct_space))
+				{
+					*s++ = ' ';
+
+					if (PUGI__IS_CHARTYPE(*s, ct_space))
+					{
+						char_t* str = s + 1;
+						while (PUGI__IS_CHARTYPE(*str, ct_space)) ++str;
+
+						g.push(s, str - s);
+					}
+				}
+				else if (opt_escape::value && *s == '&')
+				{
+					s = strconv_escape(s, g);
+				}
+				else if (!*s)
+				{
+					return 0;
+				}
+				else ++s;
+			}
+		}
+
+		static char_t* parse_wconv(char_t* s, char_t end_quote)
+		{
+			gap g;
+
+			while (true)
+			{
+				PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPE(ss, ct_parse_attr_ws));
+
+				if (*s == end_quote)
+				{
+					*g.flush(s) = 0;
+
+					return s + 1;
+				}
+				else if (PUGI__IS_CHARTYPE(*s, ct_space))
+				{
+					if (*s == '\r')
+					{
+						*s++ = ' ';
+
+						if (*s == '\n') g.push(s, 1);
+					}
+					else *s++ = ' ';
+				}
+				else if (opt_escape::value && *s == '&')
+				{
+					s = strconv_escape(s, g);
+				}
+				else if (!*s)
+				{
+					return 0;
+				}
+				else ++s;
+			}
+		}
+
+		static char_t* parse_eol(char_t* s, char_t end_quote)
+		{
+			gap g;
+
+			while (true)
+			{
+				PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPE(ss, ct_parse_attr));
+
+				if (*s == end_quote)
+				{
+					*g.flush(s) = 0;
+
+					return s + 1;
+				}
+				else if (*s == '\r')
+				{
+					*s++ = '\n';
+
+					if (*s == '\n') g.push(s, 1);
+				}
+				else if (opt_escape::value && *s == '&')
+				{
+					s = strconv_escape(s, g);
+				}
+				else if (!*s)
+				{
+					return 0;
+				}
+				else ++s;
+			}
+		}
+
+		static char_t* parse_simple(char_t* s, char_t end_quote)
+		{
+			gap g;
+
+			while (true)
+			{
+				PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPE(ss, ct_parse_attr));
+
+				if (*s == end_quote)
+				{
+					*g.flush(s) = 0;
+
+					return s + 1;
+				}
+				else if (opt_escape::value && *s == '&')
+				{
+					s = strconv_escape(s, g);
+				}
+				else if (!*s)
+				{
+					return 0;
+				}
+				else ++s;
+			}
+		}
+	};
+
+	PUGI__FN strconv_attribute_t get_strconv_attribute(unsigned int optmask)
+	{
+		PUGI__STATIC_ASSERT(parse_escapes == 0x10 && parse_eol == 0x20 && parse_wconv_attribute == 0x40 && parse_wnorm_attribute == 0x80);
+
+		switch ((optmask >> 4) & 15) // get bitmask for flags (wnorm wconv eol escapes); this simultaneously checks 4 options from assertion above
+		{
+		case 0:  return strconv_attribute_impl<opt_false>::parse_simple;
+		case 1:  return strconv_attribute_impl<opt_true>::parse_simple;
+		case 2:  return strconv_attribute_impl<opt_false>::parse_eol;
+		case 3:  return strconv_attribute_impl<opt_true>::parse_eol;
+		case 4:  return strconv_attribute_impl<opt_false>::parse_wconv;
+		case 5:  return strconv_attribute_impl<opt_true>::parse_wconv;
+		case 6:  return strconv_attribute_impl<opt_false>::parse_wconv;
+		case 7:  return strconv_attribute_impl<opt_true>::parse_wconv;
+		case 8:  return strconv_attribute_impl<opt_false>::parse_wnorm;
+		case 9:  return strconv_attribute_impl<opt_true>::parse_wnorm;
+		case 10: return strconv_attribute_impl<opt_false>::parse_wnorm;
+		case 11: return strconv_attribute_impl<opt_true>::parse_wnorm;
+		case 12: return strconv_attribute_impl<opt_false>::parse_wnorm;
+		case 13: return strconv_attribute_impl<opt_true>::parse_wnorm;
+		case 14: return strconv_attribute_impl<opt_false>::parse_wnorm;
+		case 15: return strconv_attribute_impl<opt_true>::parse_wnorm;
+		default: assert(false); return 0; // unreachable
+		}
+	}
+
+	inline xml_parse_result make_parse_result(xml_parse_status status, ptrdiff_t offset = 0)
+	{
+		xml_parse_result result;
+		result.status = status;
+		result.offset = offset;
+
+		return result;
+	}
+
+	struct xml_parser
+	{
+		xml_allocator* alloc;
+		char_t* error_offset;
+		xml_parse_status error_status;
+
+		xml_parser(xml_allocator* alloc_): alloc(alloc_), error_offset(0), error_status(status_ok)
+		{
+		}
+
+		// DOCTYPE consists of nested sections of the following possible types:
+		// <!-- ... -->, <? ... ?>, "...", '...'
+		// <![...]]>
+		// <!...>
+		// First group can not contain nested groups
+		// Second group can contain nested groups of the same type
+		// Third group can contain all other groups
+		char_t* parse_doctype_primitive(char_t* s)
+		{
+			if (*s == '"' || *s == '\'')
+			{
+				// quoted string
+				char_t ch = *s++;
+				PUGI__SCANFOR(*s == ch);
+				if (!*s) PUGI__THROW_ERROR(status_bad_doctype, s);
+
+				s++;
+			}
+			else if (s[0] == '<' && s[1] == '?')
+			{
+				// <? ... ?>
+				s += 2;
+				PUGI__SCANFOR(s[0] == '?' && s[1] == '>'); // no need for ENDSWITH because ?> can't terminate proper doctype
+				if (!*s) PUGI__THROW_ERROR(status_bad_doctype, s);
+
+				s += 2;
+			}
+			else if (s[0] == '<' && s[1] == '!' && s[2] == '-' && s[3] == '-')
+			{
+				s += 4;
+				PUGI__SCANFOR(s[0] == '-' && s[1] == '-' && s[2] == '>'); // no need for ENDSWITH because --> can't terminate proper doctype
+				if (!*s) PUGI__THROW_ERROR(status_bad_doctype, s);
+
+				s += 3;
+			}
+			else PUGI__THROW_ERROR(status_bad_doctype, s);
+
+			return s;
+		}
+
+		char_t* parse_doctype_ignore(char_t* s)
+		{
+			size_t depth = 0;
+
+			assert(s[0] == '<' && s[1] == '!' && s[2] == '[');
+			s += 3;
+
+			while (*s)
+			{
+				if (s[0] == '<' && s[1] == '!' && s[2] == '[')
+				{
+					// nested ignore section
+					s += 3;
+					depth++;
+				}
+				else if (s[0] == ']' && s[1] == ']' && s[2] == '>')
+				{
+					// ignore section end
+					s += 3;
+
+					if (depth == 0)
+						return s;
+
+					depth--;
+				}
+				else s++;
+			}
+
+			PUGI__THROW_ERROR(status_bad_doctype, s);
+		}
+
+		char_t* parse_doctype_group(char_t* s, char_t endch)
+		{
+			size_t depth = 0;
+
+			assert((s[0] == '<' || s[0] == 0) && s[1] == '!');
+			s += 2;
+
+			while (*s)
+			{
+				if (s[0] == '<' && s[1] == '!' && s[2] != '-')
+				{
+					if (s[2] == '[')
+					{
+						// ignore
+						s = parse_doctype_ignore(s);
+						if (!s) return s;
+					}
+					else
+					{
+						// some control group
+						s += 2;
+						depth++;
+					}
+				}
+				else if (s[0] == '<' || s[0] == '"' || s[0] == '\'')
+				{
+					// unknown tag (forbidden), or some primitive group
+					s = parse_doctype_primitive(s);
+					if (!s) return s;
+				}
+				else if (*s == '>')
+				{
+					if (depth == 0)
+						return s;
+
+					depth--;
+					s++;
+				}
+				else s++;
+			}
+
+			if (depth != 0 || endch != '>') PUGI__THROW_ERROR(status_bad_doctype, s);
+
+			return s;
+		}
+
+		char_t* parse_exclamation(char_t* s, xml_node_struct* cursor, unsigned int optmsk, char_t endch)
+		{
+			// parse node contents, starting with exclamation mark
+			++s;
+
+			if (*s == '-') // '<!-...'
+			{
+				++s;
+
+				if (*s == '-') // '<!--...'
+				{
+					++s;
+
+					if (PUGI__OPTSET(parse_comments))
+					{
+						PUGI__PUSHNODE(node_comment); // Append a new node on the tree.
+						cursor->value = s; // Save the offset.
+					}
+
+					if (PUGI__OPTSET(parse_eol) && PUGI__OPTSET(parse_comments))
+					{
+						s = strconv_comment(s, endch);
+
+						if (!s) PUGI__THROW_ERROR(status_bad_comment, cursor->value);
+					}
+					else
+					{
+						// Scan for terminating '-->'.
+						PUGI__SCANFOR(s[0] == '-' && s[1] == '-' && PUGI__ENDSWITH(s[2], '>'));
+						PUGI__CHECK_ERROR(status_bad_comment, s);
+
+						if (PUGI__OPTSET(parse_comments))
+							*s = 0; // Zero-terminate this segment at the first terminating '-'.
+
+						s += (s[2] == '>' ? 3 : 2); // Step over the '\0->'.
+					}
+				}
+				else PUGI__THROW_ERROR(status_bad_comment, s);
+			}
+			else if (*s == '[')
+			{
+				// '<![CDATA[...'
+				if (*++s=='C' && *++s=='D' && *++s=='A' && *++s=='T' && *++s=='A' && *++s == '[')
+				{
+					++s;
+
+					if (PUGI__OPTSET(parse_cdata))
+					{
+						PUGI__PUSHNODE(node_cdata); // Append a new node on the tree.
+						cursor->value = s; // Save the offset.
+
+						if (PUGI__OPTSET(parse_eol))
+						{
+							s = strconv_cdata(s, endch);
+
+							if (!s) PUGI__THROW_ERROR(status_bad_cdata, cursor->value);
+						}
+						else
+						{
+							// Scan for terminating ']]>'.
+							PUGI__SCANFOR(s[0] == ']' && s[1] == ']' && PUGI__ENDSWITH(s[2], '>'));
+							PUGI__CHECK_ERROR(status_bad_cdata, s);
+
+							*s++ = 0; // Zero-terminate this segment.
+						}
+					}
+					else // Flagged for discard, but we still have to scan for the terminator.
+					{
+						// Scan for terminating ']]>'.
+						PUGI__SCANFOR(s[0] == ']' && s[1] == ']' && PUGI__ENDSWITH(s[2], '>'));
+						PUGI__CHECK_ERROR(status_bad_cdata, s);
+
+						++s;
+					}
+
+					s += (s[1] == '>' ? 2 : 1); // Step over the last ']>'.
+				}
+				else PUGI__THROW_ERROR(status_bad_cdata, s);
+			}
+			else if (s[0] == 'D' && s[1] == 'O' && s[2] == 'C' && s[3] == 'T' && s[4] == 'Y' && s[5] == 'P' && PUGI__ENDSWITH(s[6], 'E'))
+			{
+				s -= 2;
+
+				if (cursor->parent) PUGI__THROW_ERROR(status_bad_doctype, s);
+
+				char_t* mark = s + 9;
+
+				s = parse_doctype_group(s, endch);
+				if (!s) return s;
+
+				assert((*s == 0 && endch == '>') || *s == '>');
+				if (*s) *s++ = 0;
+
+				if (PUGI__OPTSET(parse_doctype))
+				{
+					while (PUGI__IS_CHARTYPE(*mark, ct_space)) ++mark;
+
+					PUGI__PUSHNODE(node_doctype);
+
+					cursor->value = mark;
+				}
+			}
+			else if (*s == 0 && endch == '-') PUGI__THROW_ERROR(status_bad_comment, s);
+			else if (*s == 0 && endch == '[') PUGI__THROW_ERROR(status_bad_cdata, s);
+			else PUGI__THROW_ERROR(status_unrecognized_tag, s);
+
+			return s;
+		}
+
+		char_t* parse_question(char_t* s, xml_node_struct*& ref_cursor, unsigned int optmsk, char_t endch)
+		{
+			// load into registers
+			xml_node_struct* cursor = ref_cursor;
+			char_t ch = 0;
+
+			// parse node contents, starting with question mark
+			++s;
+
+			// read PI target
+			char_t* target = s;
+
+			if (!PUGI__IS_CHARTYPE(*s, ct_start_symbol)) PUGI__THROW_ERROR(status_bad_pi, s);
+
+			PUGI__SCANWHILE(PUGI__IS_CHARTYPE(*s, ct_symbol));
+			PUGI__CHECK_ERROR(status_bad_pi, s);
+
+			// determine node type; stricmp / strcasecmp is not portable
+			bool declaration = (target[0] | ' ') == 'x' && (target[1] | ' ') == 'm' && (target[2] | ' ') == 'l' && target + 3 == s;
+
+			if (declaration ? PUGI__OPTSET(parse_declaration) : PUGI__OPTSET(parse_pi))
+			{
+				if (declaration)
+				{
+					// disallow non top-level declarations
+					if (cursor->parent) PUGI__THROW_ERROR(status_bad_pi, s);
+
+					PUGI__PUSHNODE(node_declaration);
+				}
+				else
+				{
+					PUGI__PUSHNODE(node_pi);
+				}
+
+				cursor->name = target;
+
+				PUGI__ENDSEG();
+
+				// parse value/attributes
+				if (ch == '?')
+				{
+					// empty node
+					if (!PUGI__ENDSWITH(*s, '>')) PUGI__THROW_ERROR(status_bad_pi, s);
+					s += (*s == '>');
+
+					PUGI__POPNODE();
+				}
+				else if (PUGI__IS_CHARTYPE(ch, ct_space))
+				{
+					PUGI__SKIPWS();
+
+					// scan for tag end
+					char_t* value = s;
+
+					PUGI__SCANFOR(s[0] == '?' && PUGI__ENDSWITH(s[1], '>'));
+					PUGI__CHECK_ERROR(status_bad_pi, s);
+
+					if (declaration)
+					{
+						// replace ending ? with / so that 'element' terminates properly
+						*s = '/';
+
+						// we exit from this function with cursor at node_declaration, which is a signal to parse() to go to LOC_ATTRIBUTES
+						s = value;
+					}
+					else
+					{
+						// store value and step over >
+						cursor->value = value;
+
+						PUGI__POPNODE();
+
+						PUGI__ENDSEG();
+
+						s += (*s == '>');
+					}
+				}
+				else PUGI__THROW_ERROR(status_bad_pi, s);
+			}
+			else
+			{
+				// scan for tag end
+				PUGI__SCANFOR(s[0] == '?' && PUGI__ENDSWITH(s[1], '>'));
+				PUGI__CHECK_ERROR(status_bad_pi, s);
+
+				s += (s[1] == '>' ? 2 : 1);
+			}
+
+			// store from registers
+			ref_cursor = cursor;
+
+			return s;
+		}
+
+		char_t* parse_tree(char_t* s, xml_node_struct* root, unsigned int optmsk, char_t endch)
+		{
+			strconv_attribute_t strconv_attribute = get_strconv_attribute(optmsk);
+			strconv_pcdata_t strconv_pcdata = get_strconv_pcdata(optmsk);
+
+			char_t ch = 0;
+			xml_node_struct* cursor = root;
+			char_t* mark = s;
+
+			while (*s != 0)
+			{
+				if (*s == '<')
+				{
+					++s;
+
+				LOC_TAG:
+					if (PUGI__IS_CHARTYPE(*s, ct_start_symbol)) // '<#...'
+					{
+						PUGI__PUSHNODE(node_element); // Append a new node to the tree.
+
+						cursor->name = s;
+
+						PUGI__SCANWHILE_UNROLL(PUGI__IS_CHARTYPE(ss, ct_symbol)); // Scan for a terminator.
+						PUGI__ENDSEG(); // Save char in 'ch', terminate & step over.
+
+						if (ch == '>')
+						{
+							// end of tag
+						}
+						else if (PUGI__IS_CHARTYPE(ch, ct_space))
+						{
+						LOC_ATTRIBUTES:
+							while (true)
+							{
+								PUGI__SKIPWS(); // Eat any whitespace.
+
+								if (PUGI__IS_CHARTYPE(*s, ct_start_symbol)) // <... #...
+								{
+									xml_attribute_struct* a = append_new_attribute(cursor, *alloc); // Make space for this attribute.
+									if (!a) PUGI__THROW_ERROR(status_out_of_memory, s);
+
+									a->name = s; // Save the offset.
+
+									PUGI__SCANWHILE_UNROLL(PUGI__IS_CHARTYPE(ss, ct_symbol)); // Scan for a terminator.
+									PUGI__ENDSEG(); // Save char in 'ch', terminate & step over.
+
+									if (PUGI__IS_CHARTYPE(ch, ct_space))
+									{
+										PUGI__SKIPWS(); // Eat any whitespace.
+
+										ch = *s;
+										++s;
+									}
+
+									if (ch == '=') // '<... #=...'
+									{
+										PUGI__SKIPWS(); // Eat any whitespace.
+
+										if (*s == '"' || *s == '\'') // '<... #="...'
+										{
+											ch = *s; // Save quote char to avoid breaking on "''" -or- '""'.
+											++s; // Step over the quote.
+											a->value = s; // Save the offset.
+
+											s = strconv_attribute(s, ch);
+
+											if (!s) PUGI__THROW_ERROR(status_bad_attribute, a->value);
+
+											// After this line the loop continues from the start;
+											// Whitespaces, / and > are ok, symbols and EOF are wrong,
+											// everything else will be detected
+											if (PUGI__IS_CHARTYPE(*s, ct_start_symbol)) PUGI__THROW_ERROR(status_bad_attribute, s);
+										}
+										else PUGI__THROW_ERROR(status_bad_attribute, s);
+									}
+									else PUGI__THROW_ERROR(status_bad_attribute, s);
+								}
+								else if (*s == '/')
+								{
+									++s;
+
+									if (*s == '>')
+									{
+										PUGI__POPNODE();
+										s++;
+										break;
+									}
+									else if (*s == 0 && endch == '>')
+									{
+										PUGI__POPNODE();
+										break;
+									}
+									else PUGI__THROW_ERROR(status_bad_start_element, s);
+								}
+								else if (*s == '>')
+								{
+									++s;
+
+									break;
+								}
+								else if (*s == 0 && endch == '>')
+								{
+									break;
+								}
+								else PUGI__THROW_ERROR(status_bad_start_element, s);
+							}
+
+							// !!!
+						}
+						else if (ch == '/') // '<#.../'
+						{
+							if (!PUGI__ENDSWITH(*s, '>')) PUGI__THROW_ERROR(status_bad_start_element, s);
+
+							PUGI__POPNODE(); // Pop.
+
+							s += (*s == '>');
+						}
+						else if (ch == 0)
+						{
+							// we stepped over null terminator, backtrack & handle closing tag
+							--s;
+
+							if (endch != '>') PUGI__THROW_ERROR(status_bad_start_element, s);
+						}
+						else PUGI__THROW_ERROR(status_bad_start_element, s);
+					}
+					else if (*s == '/')
+					{
+						++s;
+
+						mark = s;
+
+						char_t* name = cursor->name;
+						if (!name) PUGI__THROW_ERROR(status_end_element_mismatch, mark);
+
+						while (PUGI__IS_CHARTYPE(*s, ct_symbol))
+						{
+							if (*s++ != *name++) PUGI__THROW_ERROR(status_end_element_mismatch, mark);
+						}
+
+						if (*name)
+						{
+							if (*s == 0 && name[0] == endch && name[1] == 0) PUGI__THROW_ERROR(status_bad_end_element, s);
+							else PUGI__THROW_ERROR(status_end_element_mismatch, mark);
+						}
+
+						PUGI__POPNODE(); // Pop.
+
+						PUGI__SKIPWS();
+
+						if (*s == 0)
+						{
+							if (endch != '>') PUGI__THROW_ERROR(status_bad_end_element, s);
+						}
+						else
+						{
+							if (*s != '>') PUGI__THROW_ERROR(status_bad_end_element, s);
+							++s;
+						}
+					}
+					else if (*s == '?') // '<?...'
+					{
+						s = parse_question(s, cursor, optmsk, endch);
+						if (!s) return s;
+
+						assert(cursor);
+						if (PUGI__NODETYPE(cursor) == node_declaration) goto LOC_ATTRIBUTES;
+					}
+					else if (*s == '!') // '<!...'
+					{
+						s = parse_exclamation(s, cursor, optmsk, endch);
+						if (!s) return s;
+					}
+					else if (*s == 0 && endch == '?') PUGI__THROW_ERROR(status_bad_pi, s);
+					else PUGI__THROW_ERROR(status_unrecognized_tag, s);
+				}
+				else
+				{
+					mark = s; // Save this offset while searching for a terminator.
+
+					PUGI__SKIPWS(); // Eat whitespace if no genuine PCDATA here.
+
+					if (*s == '<' || !*s)
+					{
+						// We skipped some whitespace characters because otherwise we would take the tag branch instead of PCDATA one
+						assert(mark != s);
+
+						if (!PUGI__OPTSET(parse_ws_pcdata | parse_ws_pcdata_single) || PUGI__OPTSET(parse_trim_pcdata))
+						{
+							continue;
+						}
+						else if (PUGI__OPTSET(parse_ws_pcdata_single))
+						{
+							if (s[0] != '<' || s[1] != '/' || cursor->first_child) continue;
+						}
+					}
+
+					if (!PUGI__OPTSET(parse_trim_pcdata))
+						s = mark;
+
+					if (cursor->parent || PUGI__OPTSET(parse_fragment))
+					{
+						if (PUGI__OPTSET(parse_embed_pcdata) && cursor->parent && !cursor->first_child && !cursor->value)
+						{
+							cursor->value = s; // Save the offset.
+						}
+						else
+						{
+							PUGI__PUSHNODE(node_pcdata); // Append a new node on the tree.
+
+							cursor->value = s; // Save the offset.
+
+							PUGI__POPNODE(); // Pop since this is a standalone.
+						}
+
+						s = strconv_pcdata(s);
+
+						if (!*s) break;
+					}
+					else
+					{
+						PUGI__SCANFOR(*s == '<'); // '...<'
+						if (!*s) break;
+
+						++s;
+					}
+
+					// We're after '<'
+					goto LOC_TAG;
+				}
+			}
+
+			// check that last tag is closed
+			if (cursor != root) PUGI__THROW_ERROR(status_end_element_mismatch, s);
+
+			return s;
+		}
+
+	#ifdef PUGIXML_WCHAR_MODE
+		static char_t* parse_skip_bom(char_t* s)
+		{
+			unsigned int bom = 0xfeff;
+			return (s[0] == static_cast<wchar_t>(bom)) ? s + 1 : s;
+		}
+	#else
+		static char_t* parse_skip_bom(char_t* s)
+		{
+			return (s[0] == '\xef' && s[1] == '\xbb' && s[2] == '\xbf') ? s + 3 : s;
+		}
+	#endif
+
+		static bool has_element_node_siblings(xml_node_struct* node)
+		{
+			while (node)
+			{
+				if (PUGI__NODETYPE(node) == node_element) return true;
+
+				node = node->next_sibling;
+			}
+
+			return false;
+		}
+
+		static xml_parse_result parse(char_t* buffer, size_t length, xml_document_struct* xmldoc, xml_node_struct* root, unsigned int optmsk)
+		{
+			// early-out for empty documents
+			if (length == 0)
+				return make_parse_result(PUGI__OPTSET(parse_fragment) ? status_ok : status_no_document_element);
+
+			// get last child of the root before parsing
+			xml_node_struct* last_root_child = root->first_child ? root->first_child->prev_sibling_c + 0 : 0;
+
+			// create parser on stack
+			xml_parser parser(static_cast<xml_allocator*>(xmldoc));
+
+			// save last character and make buffer zero-terminated (speeds up parsing)
+			char_t endch = buffer[length - 1];
+			buffer[length - 1] = 0;
+
+			// skip BOM to make sure it does not end up as part of parse output
+			char_t* buffer_data = parse_skip_bom(buffer);
+
+			// perform actual parsing
+			parser.parse_tree(buffer_data, root, optmsk, endch);
+
+			xml_parse_result result = make_parse_result(parser.error_status, parser.error_offset ? parser.error_offset - buffer : 0);
+			assert(result.offset >= 0 && static_cast<size_t>(result.offset) <= length);
+
+			if (result)
+			{
+				// since we removed last character, we have to handle the only possible false positive (stray <)
+				if (endch == '<')
+					return make_parse_result(status_unrecognized_tag, length - 1);
+
+				// check if there are any element nodes parsed
+				xml_node_struct* first_root_child_parsed = last_root_child ? last_root_child->next_sibling + 0 : root->first_child+ 0;
+
+				if (!PUGI__OPTSET(parse_fragment) && !has_element_node_siblings(first_root_child_parsed))
+					return make_parse_result(status_no_document_element, length - 1);
+			}
+			else
+			{
+				// roll back offset if it occurs on a null terminator in the source buffer
+				if (result.offset > 0 && static_cast<size_t>(result.offset) == length - 1 && endch == 0)
+					result.offset--;
+			}
+
+			return result;
+		}
+	};
+
+	// Output facilities
+	PUGI__FN xml_encoding get_write_native_encoding()
+	{
+	#ifdef PUGIXML_WCHAR_MODE
+		return get_wchar_encoding();
+	#else
+		return encoding_utf8;
+	#endif
+	}
+
+	PUGI__FN xml_encoding get_write_encoding(xml_encoding encoding)
+	{
+		// replace wchar encoding with utf implementation
+		if (encoding == encoding_wchar) return get_wchar_encoding();
+
+		// replace utf16 encoding with utf16 with specific endianness
+		if (encoding == encoding_utf16) return is_little_endian() ? encoding_utf16_le : encoding_utf16_be;
+
+		// replace utf32 encoding with utf32 with specific endianness
+		if (encoding == encoding_utf32) return is_little_endian() ? encoding_utf32_le : encoding_utf32_be;
+
+		// only do autodetection if no explicit encoding is requested
+		if (encoding != encoding_auto) return encoding;
+
+		// assume utf8 encoding
+		return encoding_utf8;
+	}
+
+	template <typename D, typename T> PUGI__FN size_t convert_buffer_output_generic(typename T::value_type dest, const char_t* data, size_t length, D, T)
+	{
+		PUGI__STATIC_ASSERT(sizeof(char_t) == sizeof(typename D::type));
+
+		typename T::value_type end = D::process(reinterpret_cast<const typename D::type*>(data), length, dest, T());
+
+		return static_cast<size_t>(end - dest) * sizeof(*dest);
+	}
+
+	template <typename D, typename T> PUGI__FN size_t convert_buffer_output_generic(typename T::value_type dest, const char_t* data, size_t length, D, T, bool opt_swap)
+	{
+		PUGI__STATIC_ASSERT(sizeof(char_t) == sizeof(typename D::type));
+
+		typename T::value_type end = D::process(reinterpret_cast<const typename D::type*>(data), length, dest, T());
+
+		if (opt_swap)
+		{
+			for (typename T::value_type i = dest; i != end; ++i)
+				*i = endian_swap(*i);
+		}
+
+		return static_cast<size_t>(end - dest) * sizeof(*dest);
+	}
+
+#ifdef PUGIXML_WCHAR_MODE
+	PUGI__FN size_t get_valid_length(const char_t* data, size_t length)
+	{
+		if (length < 1) return 0;
+
+		// discard last character if it's the lead of a surrogate pair
+		return (sizeof(wchar_t) == 2 && static_cast<unsigned int>(static_cast<uint16_t>(data[length - 1]) - 0xD800) < 0x400) ? length - 1 : length;
+	}
+
+	PUGI__FN size_t convert_buffer_output(char_t* r_char, uint8_t* r_u8, uint16_t* r_u16, uint32_t* r_u32, const char_t* data, size_t length, xml_encoding encoding)
+	{
+		// only endian-swapping is required
+		if (need_endian_swap_utf(encoding, get_wchar_encoding()))
+		{
+			convert_wchar_endian_swap(r_char, data, length);
+
+			return length * sizeof(char_t);
+		}
+
+		// convert to utf8
+		if (encoding == encoding_utf8)
+			return convert_buffer_output_generic(r_u8, data, length, wchar_decoder(), utf8_writer());
+
+		// convert to utf16
+		if (encoding == encoding_utf16_be || encoding == encoding_utf16_le)
+		{
+			xml_encoding native_encoding = is_little_endian() ? encoding_utf16_le : encoding_utf16_be;
+
+			return convert_buffer_output_generic(r_u16, data, length, wchar_decoder(), utf16_writer(), native_encoding != encoding);
+		}
+
+		// convert to utf32
+		if (encoding == encoding_utf32_be || encoding == encoding_utf32_le)
+		{
+			xml_encoding native_encoding = is_little_endian() ? encoding_utf32_le : encoding_utf32_be;
+
+			return convert_buffer_output_generic(r_u32, data, length, wchar_decoder(), utf32_writer(), native_encoding != encoding);
+		}
+
+		// convert to latin1
+		if (encoding == encoding_latin1)
+			return convert_buffer_output_generic(r_u8, data, length, wchar_decoder(), latin1_writer());
+
+		assert(false && "Invalid encoding"); // unreachable
+		return 0;
+	}
+#else
+	PUGI__FN size_t get_valid_length(const char_t* data, size_t length)
+	{
+		if (length < 5) return 0;
+
+		for (size_t i = 1; i <= 4; ++i)
+		{
+			uint8_t ch = static_cast<uint8_t>(data[length - i]);
+
+			// either a standalone character or a leading one
+			if ((ch & 0xc0) != 0x80) return length - i;
+		}
+
+		// there are four non-leading characters at the end, sequence tail is broken so might as well process the whole chunk
+		return length;
+	}
+
+	PUGI__FN size_t convert_buffer_output(char_t* /* r_char */, uint8_t* r_u8, uint16_t* r_u16, uint32_t* r_u32, const char_t* data, size_t length, xml_encoding encoding)
+	{
+		if (encoding == encoding_utf16_be || encoding == encoding_utf16_le)
+		{
+			xml_encoding native_encoding = is_little_endian() ? encoding_utf16_le : encoding_utf16_be;
+
+			return convert_buffer_output_generic(r_u16, data, length, utf8_decoder(), utf16_writer(), native_encoding != encoding);
+		}
+
+		if (encoding == encoding_utf32_be || encoding == encoding_utf32_le)
+		{
+			xml_encoding native_encoding = is_little_endian() ? encoding_utf32_le : encoding_utf32_be;
+
+			return convert_buffer_output_generic(r_u32, data, length, utf8_decoder(), utf32_writer(), native_encoding != encoding);
+		}
+
+		if (encoding == encoding_latin1)
+			return convert_buffer_output_generic(r_u8, data, length, utf8_decoder(), latin1_writer());
+
+		assert(false && "Invalid encoding"); // unreachable
+		return 0;
+	}
+#endif
+
+	class xml_buffered_writer
+	{
+		xml_buffered_writer(const xml_buffered_writer&);
+		xml_buffered_writer& operator=(const xml_buffered_writer&);
+
+	public:
+		xml_buffered_writer(xml_writer& writer_, xml_encoding user_encoding): writer(writer_), bufsize(0), encoding(get_write_encoding(user_encoding))
+		{
+			PUGI__STATIC_ASSERT(bufcapacity >= 8);
+		}
+
+		size_t flush()
+		{
+			flush(buffer, bufsize);
+			bufsize = 0;
+			return 0;
+		}
+
+		void flush(const char_t* data, size_t size)
+		{
+			if (size == 0) return;
+
+			// fast path, just write data
+			if (encoding == get_write_native_encoding())
+				writer.write(data, size * sizeof(char_t));
+			else
+			{
+				// convert chunk
+				size_t result = convert_buffer_output(scratch.data_char, scratch.data_u8, scratch.data_u16, scratch.data_u32, data, size, encoding);
+				assert(result <= sizeof(scratch));
+
+				// write data
+				writer.write(scratch.data_u8, result);
+			}
+		}
+
+		void write_direct(const char_t* data, size_t length)
+		{
+			// flush the remaining buffer contents
+			flush();
+
+			// handle large chunks
+			if (length > bufcapacity)
+			{
+				if (encoding == get_write_native_encoding())
+				{
+					// fast path, can just write data chunk
+					writer.write(data, length * sizeof(char_t));
+					return;
+				}
+
+				// need to convert in suitable chunks
+				while (length > bufcapacity)
+				{
+					// get chunk size by selecting such number of characters that are guaranteed to fit into scratch buffer
+					// and form a complete codepoint sequence (i.e. discard start of last codepoint if necessary)
+					size_t chunk_size = get_valid_length(data, bufcapacity);
+					assert(chunk_size);
+
+					// convert chunk and write
+					flush(data, chunk_size);
+
+					// iterate
+					data += chunk_size;
+					length -= chunk_size;
+				}
+
+				// small tail is copied below
+				bufsize = 0;
+			}
+
+			memcpy(buffer + bufsize, data, length * sizeof(char_t));
+			bufsize += length;
+		}
+
+		void write_buffer(const char_t* data, size_t length)
+		{
+			size_t offset = bufsize;
+
+			if (offset + length <= bufcapacity)
+			{
+				memcpy(buffer + offset, data, length * sizeof(char_t));
+				bufsize = offset + length;
+			}
+			else
+			{
+				write_direct(data, length);
+			}
+		}
+
+		void write_string(const char_t* data)
+		{
+			// write the part of the string that fits in the buffer
+			size_t offset = bufsize;
+
+			while (*data && offset < bufcapacity)
+				buffer[offset++] = *data++;
+
+			// write the rest
+			if (offset < bufcapacity)
+			{
+				bufsize = offset;
+			}
+			else
+			{
+				// backtrack a bit if we have split the codepoint
+				size_t length = offset - bufsize;
+				size_t extra = length - get_valid_length(data - length, length);
+
+				bufsize = offset - extra;
+
+				write_direct(data - extra, strlength(data) + extra);
+			}
+		}
+
+		void write(char_t d0)
+		{
+			size_t offset = bufsize;
+			if (offset > bufcapacity - 1) offset = flush();
+
+			buffer[offset + 0] = d0;
+			bufsize = offset + 1;
+		}
+
+		void write(char_t d0, char_t d1)
+		{
+			size_t offset = bufsize;
+			if (offset > bufcapacity - 2) offset = flush();
+
+			buffer[offset + 0] = d0;
+			buffer[offset + 1] = d1;
+			bufsize = offset + 2;
+		}
+
+		void write(char_t d0, char_t d1, char_t d2)
+		{
+			size_t offset = bufsize;
+			if (offset > bufcapacity - 3) offset = flush();
+
+			buffer[offset + 0] = d0;
+			buffer[offset + 1] = d1;
+			buffer[offset + 2] = d2;
+			bufsize = offset + 3;
+		}
+
+		void write(char_t d0, char_t d1, char_t d2, char_t d3)
+		{
+			size_t offset = bufsize;
+			if (offset > bufcapacity - 4) offset = flush();
+
+			buffer[offset + 0] = d0;
+			buffer[offset + 1] = d1;
+			buffer[offset + 2] = d2;
+			buffer[offset + 3] = d3;
+			bufsize = offset + 4;
+		}
+
+		void write(char_t d0, char_t d1, char_t d2, char_t d3, char_t d4)
+		{
+			size_t offset = bufsize;
+			if (offset > bufcapacity - 5) offset = flush();
+
+			buffer[offset + 0] = d0;
+			buffer[offset + 1] = d1;
+			buffer[offset + 2] = d2;
+			buffer[offset + 3] = d3;
+			buffer[offset + 4] = d4;
+			bufsize = offset + 5;
+		}
+
+		void write(char_t d0, char_t d1, char_t d2, char_t d3, char_t d4, char_t d5)
+		{
+			size_t offset = bufsize;
+			if (offset > bufcapacity - 6) offset = flush();
+
+			buffer[offset + 0] = d0;
+			buffer[offset + 1] = d1;
+			buffer[offset + 2] = d2;
+			buffer[offset + 3] = d3;
+			buffer[offset + 4] = d4;
+			buffer[offset + 5] = d5;
+			bufsize = offset + 6;
+		}
+
+		// utf8 maximum expansion: x4 (-> utf32)
+		// utf16 maximum expansion: x2 (-> utf32)
+		// utf32 maximum expansion: x1
+		enum
+		{
+			bufcapacitybytes =
+			#ifdef PUGIXML_MEMORY_OUTPUT_STACK
+				PUGIXML_MEMORY_OUTPUT_STACK
+			#else
+				10240
+			#endif
+			,
+			bufcapacity = bufcapacitybytes / (sizeof(char_t) + 4)
+		};
+
+		char_t buffer[bufcapacity];
+
+		union
+		{
+			uint8_t data_u8[4 * bufcapacity];
+			uint16_t data_u16[2 * bufcapacity];
+			uint32_t data_u32[bufcapacity];
+			char_t data_char[bufcapacity];
+		} scratch;
+
+		xml_writer& writer;
+		size_t bufsize;
+		xml_encoding encoding;
+	};
+
+	PUGI__FN void text_output_escaped(xml_buffered_writer& writer, const char_t* s, chartypex_t type, unsigned int flags)
+	{
+		while (*s)
+		{
+			const char_t* prev = s;
+
+			// While *s is a usual symbol
+			PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPEX(ss, type));
+
+			writer.write_buffer(prev, static_cast<size_t>(s - prev));
+
+			switch (*s)
+			{
+				case 0: break;
+				case '&':
+					writer.write('&', 'a', 'm', 'p', ';');
+					++s;
+					break;
+				case '<':
+					writer.write('&', 'l', 't', ';');
+					++s;
+					break;
+				case '>':
+					writer.write('&', 'g', 't', ';');
+					++s;
+					break;
+				case '"':
+					if (flags & format_attribute_single_quote)
+						writer.write('"');
+					else
+						writer.write('&', 'q', 'u', 'o', 't', ';');
+					++s;
+					break;
+				case '\'':
+					if (flags & format_attribute_single_quote)
+						writer.write('&', 'a', 'p', 'o', 's', ';');
+					else
+						writer.write('\'');
+					++s;
+					break;
+				default: // s is not a usual symbol
+				{
+					unsigned int ch = static_cast<unsigned int>(*s++);
+					assert(ch < 32);
+
+					if (!(flags & format_skip_control_chars))
+						writer.write('&', '#', static_cast<char_t>((ch / 10) + '0'), static_cast<char_t>((ch % 10) + '0'), ';');
+				}
+			}
+		}
+	}
+
+	PUGI__FN void text_output(xml_buffered_writer& writer, const char_t* s, chartypex_t type, unsigned int flags)
+	{
+		if (flags & format_no_escapes)
+			writer.write_string(s);
+		else
+			text_output_escaped(writer, s, type, flags);
+	}
+
+	PUGI__FN void text_output_cdata(xml_buffered_writer& writer, const char_t* s)
+	{
+		do
+		{
+			writer.write('<', '!', '[', 'C', 'D');
+			writer.write('A', 'T', 'A', '[');
+
+			const char_t* prev = s;
+
+			// look for ]]> sequence - we can't output it as is since it terminates CDATA
+			while (*s && !(s[0] == ']' && s[1] == ']' && s[2] == '>')) ++s;
+
+			// skip ]] if we stopped at ]]>, > will go to the next CDATA section
+			if (*s) s += 2;
+
+			writer.write_buffer(prev, static_cast<size_t>(s - prev));
+
+			writer.write(']', ']', '>');
+		}
+		while (*s);
+	}
+
+	PUGI__FN void text_output_indent(xml_buffered_writer& writer, const char_t* indent, size_t indent_length, unsigned int depth)
+	{
+		switch (indent_length)
+		{
+		case 1:
+		{
+			for (unsigned int i = 0; i < depth; ++i)
+				writer.write(indent[0]);
+			break;
+		}
+
+		case 2:
+		{
+			for (unsigned int i = 0; i < depth; ++i)
+				writer.write(indent[0], indent[1]);
+			break;
+		}
+
+		case 3:
+		{
+			for (unsigned int i = 0; i < depth; ++i)
+				writer.write(indent[0], indent[1], indent[2]);
+			break;
+		}
+
+		case 4:
+		{
+			for (unsigned int i = 0; i < depth; ++i)
+				writer.write(indent[0], indent[1], indent[2], indent[3]);
+			break;
+		}
+
+		default:
+		{
+			for (unsigned int i = 0; i < depth; ++i)
+				writer.write_buffer(indent, indent_length);
+		}
+		}
+	}
+
+	PUGI__FN void node_output_comment(xml_buffered_writer& writer, const char_t* s)
+	{
+		writer.write('<', '!', '-', '-');
+
+		while (*s)
+		{
+			const char_t* prev = s;
+
+			// look for -\0 or -- sequence - we can't output it since -- is illegal in comment body
+			while (*s && !(s[0] == '-' && (s[1] == '-' || s[1] == 0))) ++s;
+
+			writer.write_buffer(prev, static_cast<size_t>(s - prev));
+
+			if (*s)
+			{
+				assert(*s == '-');
+
+				writer.write('-', ' ');
+				++s;
+			}
+		}
+
+		writer.write('-', '-', '>');
+	}
+
+	PUGI__FN void node_output_pi_value(xml_buffered_writer& writer, const char_t* s)
+	{
+		while (*s)
+		{
+			const char_t* prev = s;
+
+			// look for ?> sequence - we can't output it since ?> terminates PI
+			while (*s && !(s[0] == '?' && s[1] == '>')) ++s;
+
+			writer.write_buffer(prev, static_cast<size_t>(s - prev));
+
+			if (*s)
+			{
+				assert(s[0] == '?' && s[1] == '>');
+
+				writer.write('?', ' ', '>');
+				s += 2;
+			}
+		}
+	}
+
+	PUGI__FN void node_output_attributes(xml_buffered_writer& writer, xml_node_struct* node, const char_t* indent, size_t indent_length, unsigned int flags, unsigned int depth)
+	{
+		const char_t* default_name = PUGIXML_TEXT(":anonymous");
+		const char_t enquotation_char = (flags & format_attribute_single_quote) ? '\'' : '"';
+
+		for (xml_attribute_struct* a = node->first_attribute; a; a = a->next_attribute)
+		{
+			if ((flags & (format_indent_attributes | format_raw)) == format_indent_attributes)
+			{
+				writer.write('\n');
+
+				text_output_indent(writer, indent, indent_length, depth + 1);
+			}
+			else
+			{
+				writer.write(' ');
+			}
+
+			writer.write_string(a->name ? a->name + 0 : default_name);
+			writer.write('=', enquotation_char);
+
+			if (a->value)
+				text_output(writer, a->value, ctx_special_attr, flags);
+
+			writer.write(enquotation_char);
+		}
+	}
+
+	PUGI__FN bool node_output_start(xml_buffered_writer& writer, xml_node_struct* node, const char_t* indent, size_t indent_length, unsigned int flags, unsigned int depth)
+	{
+		const char_t* default_name = PUGIXML_TEXT(":anonymous");
+		const char_t* name = node->name ? node->name + 0 : default_name;
+
+		writer.write('<');
+		writer.write_string(name);
+
+		if (node->first_attribute)
+			node_output_attributes(writer, node, indent, indent_length, flags, depth);
+
+		// element nodes can have value if parse_embed_pcdata was used
+		if (!node->value)
+		{
+			if (!node->first_child)
+			{
+				if (flags & format_no_empty_element_tags)
+				{
+					writer.write('>', '<', '/');
+					writer.write_string(name);
+					writer.write('>');
+
+					return false;
+				}
+				else
+				{
+					if ((flags & format_raw) == 0)
+						writer.write(' ');
+
+					writer.write('/', '>');
+
+					return false;
+				}
+			}
+			else
+			{
+				writer.write('>');
+
+				return true;
+			}
+		}
+		else
+		{
+			writer.write('>');
+
+			text_output(writer, node->value, ctx_special_pcdata, flags);
+
+			if (!node->first_child)
+			{
+				writer.write('<', '/');
+				writer.write_string(name);
+				writer.write('>');
+
+				return false;
+			}
+			else
+			{
+				return true;
+			}
+		}
+	}
+
+	PUGI__FN void node_output_end(xml_buffered_writer& writer, xml_node_struct* node)
+	{
+		const char_t* default_name = PUGIXML_TEXT(":anonymous");
+		const char_t* name = node->name ? node->name + 0 : default_name;
+
+		writer.write('<', '/');
+		writer.write_string(name);
+		writer.write('>');
+	}
+
+	PUGI__FN void node_output_simple(xml_buffered_writer& writer, xml_node_struct* node, unsigned int flags)
+	{
+		const char_t* default_name = PUGIXML_TEXT(":anonymous");
+
+		switch (PUGI__NODETYPE(node))
+		{
+			case node_pcdata:
+				text_output(writer, node->value ? node->value + 0 : PUGIXML_TEXT(""), ctx_special_pcdata, flags);
+				break;
+
+			case node_cdata:
+				text_output_cdata(writer, node->value ? node->value + 0 : PUGIXML_TEXT(""));
+				break;
+
+			case node_comment:
+				node_output_comment(writer, node->value ? node->value + 0 : PUGIXML_TEXT(""));
+				break;
+
+			case node_pi:
+				writer.write('<', '?');
+				writer.write_string(node->name ? node->name + 0 : default_name);
+
+				if (node->value)
+				{
+					writer.write(' ');
+					node_output_pi_value(writer, node->value);
+				}
+
+				writer.write('?', '>');
+				break;
+
+			case node_declaration:
+				writer.write('<', '?');
+				writer.write_string(node->name ? node->name + 0 : default_name);
+				node_output_attributes(writer, node, PUGIXML_TEXT(""), 0, flags | format_raw, 0);
+				writer.write('?', '>');
+				break;
+
+			case node_doctype:
+				writer.write('<', '!', 'D', 'O', 'C');
+				writer.write('T', 'Y', 'P', 'E');
+
+				if (node->value)
+				{
+					writer.write(' ');
+					writer.write_string(node->value);
+				}
+
+				writer.write('>');
+				break;
+
+			default:
+				assert(false && "Invalid node type"); // unreachable
+		}
+	}
+
+	enum indent_flags_t
+	{
+		indent_newline = 1,
+		indent_indent = 2
+	};
+
+	PUGI__FN void node_output(xml_buffered_writer& writer, xml_node_struct* root, const char_t* indent, unsigned int flags, unsigned int depth)
+	{
+		size_t indent_length = ((flags & (format_indent | format_indent_attributes)) && (flags & format_raw) == 0) ? strlength(indent) : 0;
+		unsigned int indent_flags = indent_indent;
+
+		xml_node_struct* node = root;
+
+		do
+		{
+			assert(node);
+
+			// begin writing current node
+			if (PUGI__NODETYPE(node) == node_pcdata || PUGI__NODETYPE(node) == node_cdata)
+			{
+				node_output_simple(writer, node, flags);
+
+				indent_flags = 0;
+			}
+			else
+			{
+				if ((indent_flags & indent_newline) && (flags & format_raw) == 0)
+					writer.write('\n');
+
+				if ((indent_flags & indent_indent) && indent_length)
+					text_output_indent(writer, indent, indent_length, depth);
+
+				if (PUGI__NODETYPE(node) == node_element)
+				{
+					indent_flags = indent_newline | indent_indent;
+
+					if (node_output_start(writer, node, indent, indent_length, flags, depth))
+					{
+						// element nodes can have value if parse_embed_pcdata was used
+						if (node->value)
+							indent_flags = 0;
+
+						node = node->first_child;
+						depth++;
+						continue;
+					}
+				}
+				else if (PUGI__NODETYPE(node) == node_document)
+				{
+					indent_flags = indent_indent;
+
+					if (node->first_child)
+					{
+						node = node->first_child;
+						continue;
+					}
+				}
+				else
+				{
+					node_output_simple(writer, node, flags);
+
+					indent_flags = indent_newline | indent_indent;
+				}
+			}
+
+			// continue to the next node
+			while (node != root)
+			{
+				if (node->next_sibling)
+				{
+					node = node->next_sibling;
+					break;
+				}
+
+				node = node->parent;
+
+				// write closing node
+				if (PUGI__NODETYPE(node) == node_element)
+				{
+					depth--;
+
+					if ((indent_flags & indent_newline) && (flags & format_raw) == 0)
+						writer.write('\n');
+
+					if ((indent_flags & indent_indent) && indent_length)
+						text_output_indent(writer, indent, indent_length, depth);
+
+					node_output_end(writer, node);
+
+					indent_flags = indent_newline | indent_indent;
+				}
+			}
+		}
+		while (node != root);
+
+		if ((indent_flags & indent_newline) && (flags & format_raw) == 0)
+			writer.write('\n');
+	}
+
+	PUGI__FN bool has_declaration(xml_node_struct* node)
+	{
+		for (xml_node_struct* child = node->first_child; child; child = child->next_sibling)
+		{
+			xml_node_type type = PUGI__NODETYPE(child);
+
+			if (type == node_declaration) return true;
+			if (type == node_element) return false;
+		}
+
+		return false;
+	}
+
+	PUGI__FN bool is_attribute_of(xml_attribute_struct* attr, xml_node_struct* node)
+	{
+		for (xml_attribute_struct* a = node->first_attribute; a; a = a->next_attribute)
+			if (a == attr)
+				return true;
+
+		return false;
+	}
+
+	PUGI__FN bool allow_insert_attribute(xml_node_type parent)
+	{
+		return parent == node_element || parent == node_declaration;
+	}
+
+	PUGI__FN bool allow_insert_child(xml_node_type parent, xml_node_type child)
+	{
+		if (parent != node_document && parent != node_element) return false;
+		if (child == node_document || child == node_null) return false;
+		if (parent != node_document && (child == node_declaration || child == node_doctype)) return false;
+
+		return true;
+	}
+
+	PUGI__FN bool allow_move(xml_node parent, xml_node child)
+	{
+		// check that child can be a child of parent
+		if (!allow_insert_child(parent.type(), child.type()))
+			return false;
+
+		// check that node is not moved between documents
+		if (parent.root() != child.root())
+			return false;
+
+		// check that new parent is not in the child subtree
+		xml_node cur = parent;
+
+		while (cur)
+		{
+			if (cur == child)
+				return false;
+
+			cur = cur.parent();
+		}
+
+		return true;
+	}
+
+	template <typename String, typename Header>
+	PUGI__FN void node_copy_string(String& dest, Header& header, uintptr_t header_mask, char_t* source, Header& source_header, xml_allocator* alloc)
+	{
+		assert(!dest && (header & header_mask) == 0);
+
+		if (source)
+		{
+			if (alloc && (source_header & header_mask) == 0)
+			{
+				dest = source;
+
+				// since strcpy_insitu can reuse document buffer memory we need to mark both source and dest as shared
+				header |= xml_memory_page_contents_shared_mask;
+				source_header |= xml_memory_page_contents_shared_mask;
+			}
+			else
+				strcpy_insitu(dest, header, header_mask, source, strlength(source));
+		}
+	}
+
+	PUGI__FN void node_copy_contents(xml_node_struct* dn, xml_node_struct* sn, xml_allocator* shared_alloc)
+	{
+		node_copy_string(dn->name, dn->header, xml_memory_page_name_allocated_mask, sn->name, sn->header, shared_alloc);
+		node_copy_string(dn->value, dn->header, xml_memory_page_value_allocated_mask, sn->value, sn->header, shared_alloc);
+
+		for (xml_attribute_struct* sa = sn->first_attribute; sa; sa = sa->next_attribute)
+		{
+			xml_attribute_struct* da = append_new_attribute(dn, get_allocator(dn));
+
+			if (da)
+			{
+				node_copy_string(da->name, da->header, xml_memory_page_name_allocated_mask, sa->name, sa->header, shared_alloc);
+				node_copy_string(da->value, da->header, xml_memory_page_value_allocated_mask, sa->value, sa->header, shared_alloc);
+			}
+		}
+	}
+
+	PUGI__FN void node_copy_tree(xml_node_struct* dn, xml_node_struct* sn)
+	{
+		xml_allocator& alloc = get_allocator(dn);
+		xml_allocator* shared_alloc = (&alloc == &get_allocator(sn)) ? &alloc : 0;
+
+		node_copy_contents(dn, sn, shared_alloc);
+
+		xml_node_struct* dit = dn;
+		xml_node_struct* sit = sn->first_child;
+
+		while (sit && sit != sn)
+		{
+			// loop invariant: dit is inside the subtree rooted at dn
+			assert(dit);
+
+			// when a tree is copied into one of the descendants, we need to skip that subtree to avoid an infinite loop
+			if (sit != dn)
+			{
+				xml_node_struct* copy = append_new_node(dit, alloc, PUGI__NODETYPE(sit));
+
+				if (copy)
+				{
+					node_copy_contents(copy, sit, shared_alloc);
+
+					if (sit->first_child)
+					{
+						dit = copy;
+						sit = sit->first_child;
+						continue;
+					}
+				}
+			}
+
+			// continue to the next node
+			do
+			{
+				if (sit->next_sibling)
+				{
+					sit = sit->next_sibling;
+					break;
+				}
+
+				sit = sit->parent;
+				dit = dit->parent;
+
+				// loop invariant: dit is inside the subtree rooted at dn while sit is inside sn
+				assert(sit == sn || dit);
+			}
+			while (sit != sn);
+		}
+
+		assert(!sit || dit == dn->parent);
+	}
+
+	PUGI__FN void node_copy_attribute(xml_attribute_struct* da, xml_attribute_struct* sa)
+	{
+		xml_allocator& alloc = get_allocator(da);
+		xml_allocator* shared_alloc = (&alloc == &get_allocator(sa)) ? &alloc : 0;
+
+		node_copy_string(da->name, da->header, xml_memory_page_name_allocated_mask, sa->name, sa->header, shared_alloc);
+		node_copy_string(da->value, da->header, xml_memory_page_value_allocated_mask, sa->value, sa->header, shared_alloc);
+	}
+
+	inline bool is_text_node(xml_node_struct* node)
+	{
+		xml_node_type type = PUGI__NODETYPE(node);
+
+		return type == node_pcdata || type == node_cdata;
+	}
+
+	// get value with conversion functions
+	template <typename U> PUGI__FN PUGI__UNSIGNED_OVERFLOW U string_to_integer(const char_t* value, U minv, U maxv)
+	{
+		U result = 0;
+		const char_t* s = value;
+
+		while (PUGI__IS_CHARTYPE(*s, ct_space))
+			s++;
+
+		bool negative = (*s == '-');
+
+		s += (*s == '+' || *s == '-');
+
+		bool overflow = false;
+
+		if (s[0] == '0' && (s[1] | ' ') == 'x')
+		{
+			s += 2;
+
+			// since overflow detection relies on length of the sequence skip leading zeros
+			while (*s == '0')
+				s++;
+
+			const char_t* start = s;
+
+			for (;;)
+			{
+				if (static_cast<unsigned>(*s - '0') < 10)
+					result = result * 16 + (*s - '0');
+				else if (static_cast<unsigned>((*s | ' ') - 'a') < 6)
+					result = result * 16 + ((*s | ' ') - 'a' + 10);
+				else
+					break;
+
+				s++;
+			}
+
+			size_t digits = static_cast<size_t>(s - start);
+
+			overflow = digits > sizeof(U) * 2;
+		}
+		else
+		{
+			// since overflow detection relies on length of the sequence skip leading zeros
+			while (*s == '0')
+				s++;
+
+			const char_t* start = s;
+
+			for (;;)
+			{
+				if (static_cast<unsigned>(*s - '0') < 10)
+					result = result * 10 + (*s - '0');
+				else
+					break;
+
+				s++;
+			}
+
+			size_t digits = static_cast<size_t>(s - start);
+
+			PUGI__STATIC_ASSERT(sizeof(U) == 8 || sizeof(U) == 4 || sizeof(U) == 2);
+
+			const size_t max_digits10 = sizeof(U) == 8 ? 20 : sizeof(U) == 4 ? 10 : 5;
+			const char_t max_lead = sizeof(U) == 8 ? '1' : sizeof(U) == 4 ? '4' : '6';
+			const size_t high_bit = sizeof(U) * 8 - 1;
+
+			overflow = digits >= max_digits10 && !(digits == max_digits10 && (*start < max_lead || (*start == max_lead && result >> high_bit)));
+		}
+
+		if (negative)
+		{
+			// Workaround for crayc++ CC-3059: Expected no overflow in routine.
+		#ifdef _CRAYC
+			return (overflow || result > ~minv + 1) ? minv : ~result + 1;
+		#else
+			return (overflow || result > 0 - minv) ? minv : 0 - result;
+		#endif
+		}
+		else
+			return (overflow || result > maxv) ? maxv : result;
+	}
+
+	PUGI__FN int get_value_int(const char_t* value)
+	{
+		return string_to_integer<unsigned int>(value, static_cast<unsigned int>(INT_MIN), INT_MAX);
+	}
+
+	PUGI__FN unsigned int get_value_uint(const char_t* value)
+	{
+		return string_to_integer<unsigned int>(value, 0, UINT_MAX);
+	}
+
+	PUGI__FN double get_value_double(const char_t* value)
+	{
+	#ifdef PUGIXML_WCHAR_MODE
+		return wcstod(value, 0);
+	#else
+		return strtod(value, 0);
+	#endif
+	}
+
+	PUGI__FN float get_value_float(const char_t* value)
+	{
+	#ifdef PUGIXML_WCHAR_MODE
+		return static_cast<float>(wcstod(value, 0));
+	#else
+		return static_cast<float>(strtod(value, 0));
+	#endif
+	}
+
+	PUGI__FN bool get_value_bool(const char_t* value)
+	{
+		// only look at first char
+		char_t first = *value;
+
+		// 1*, t* (true), T* (True), y* (yes), Y* (YES)
+		return (first == '1' || first == 't' || first == 'T' || first == 'y' || first == 'Y');
+	}
+
+#ifdef PUGIXML_HAS_LONG_LONG
+	PUGI__FN long long get_value_llong(const char_t* value)
+	{
+		return string_to_integer<unsigned long long>(value, static_cast<unsigned long long>(LLONG_MIN), LLONG_MAX);
+	}
+
+	PUGI__FN unsigned long long get_value_ullong(const char_t* value)
+	{
+		return string_to_integer<unsigned long long>(value, 0, ULLONG_MAX);
+	}
+#endif
+
+	template <typename U> PUGI__FN PUGI__UNSIGNED_OVERFLOW char_t* integer_to_string(char_t* begin, char_t* end, U value, bool negative)
+	{
+		char_t* result = end - 1;
+		U rest = negative ? 0 - value : value;
+
+		do
+		{
+			*result-- = static_cast<char_t>('0' + (rest % 10));
+			rest /= 10;
+		}
+		while (rest);
+
+		assert(result >= begin);
+		(void)begin;
+
+		*result = '-';
+
+		return result + !negative;
+	}
+
+	// set value with conversion functions
+	template <typename String, typename Header>
+	PUGI__FN bool set_value_ascii(String& dest, Header& header, uintptr_t header_mask, char* buf)
+	{
+	#ifdef PUGIXML_WCHAR_MODE
+		char_t wbuf[128];
+		assert(strlen(buf) < sizeof(wbuf) / sizeof(wbuf[0]));
+
+		size_t offset = 0;
+		for (; buf[offset]; ++offset) wbuf[offset] = buf[offset];
+
+		return strcpy_insitu(dest, header, header_mask, wbuf, offset);
+	#else
+		return strcpy_insitu(dest, header, header_mask, buf, strlen(buf));
+	#endif
+	}
+
+	template <typename U, typename String, typename Header>
+	PUGI__FN bool set_value_integer(String& dest, Header& header, uintptr_t header_mask, U value, bool negative)
+	{
+		char_t buf[64];
+		char_t* end = buf + sizeof(buf) / sizeof(buf[0]);
+		char_t* begin = integer_to_string(buf, end, value, negative);
+
+		return strcpy_insitu(dest, header, header_mask, begin, end - begin);
+	}
+
+	template <typename String, typename Header>
+	PUGI__FN bool set_value_convert(String& dest, Header& header, uintptr_t header_mask, float value, int precision)
+	{
+		char buf[128];
+		PUGI__SNPRINTF(buf, "%.*g", precision, double(value));
+
+		return set_value_ascii(dest, header, header_mask, buf);
+	}
+
+	template <typename String, typename Header>
+	PUGI__FN bool set_value_convert(String& dest, Header& header, uintptr_t header_mask, double value, int precision)
+	{
+		char buf[128];
+		PUGI__SNPRINTF(buf, "%.*g", precision, value);
+
+		return set_value_ascii(dest, header, header_mask, buf);
+	}
+
+	template <typename String, typename Header>
+	PUGI__FN bool set_value_bool(String& dest, Header& header, uintptr_t header_mask, bool value)
+	{
+		return strcpy_insitu(dest, header, header_mask, value ? PUGIXML_TEXT("true") : PUGIXML_TEXT("false"), value ? 4 : 5);
+	}
+
+	PUGI__FN xml_parse_result load_buffer_impl(xml_document_struct* doc, xml_node_struct* root, void* contents, size_t size, unsigned int options, xml_encoding encoding, bool is_mutable, bool own, char_t** out_buffer)
+	{
+		// check input buffer
+		if (!contents && size) return make_parse_result(status_io_error);
+
+		// get actual encoding
+		xml_encoding buffer_encoding = impl::get_buffer_encoding(encoding, contents, size);
+
+		// get private buffer
+		char_t* buffer = 0;
+		size_t length = 0;
+
+		// coverity[var_deref_model]
+		if (!impl::convert_buffer(buffer, length, buffer_encoding, contents, size, is_mutable)) return impl::make_parse_result(status_out_of_memory);
+
+		// delete original buffer if we performed a conversion
+		if (own && buffer != contents && contents) impl::xml_memory::deallocate(contents);
+
+		// grab onto buffer if it's our buffer, user is responsible for deallocating contents himself
+		if (own || buffer != contents) *out_buffer = buffer;
+
+		// store buffer for offset_debug
+		doc->buffer = buffer;
+
+		// parse
+		xml_parse_result res = impl::xml_parser::parse(buffer, length, doc, root, options);
+
+		// remember encoding
+		res.encoding = buffer_encoding;
+
+		return res;
+	}
+
+	// we need to get length of entire file to load it in memory; the only (relatively) sane way to do it is via seek/tell trick
+	PUGI__FN xml_parse_status get_file_size(FILE* file, size_t& out_result)
+	{
+	#if defined(PUGI__MSVC_CRT_VERSION) && PUGI__MSVC_CRT_VERSION >= 1400 && !defined(_WIN32_WCE)
+		// there are 64-bit versions of fseek/ftell, let's use them
+		typedef __int64 length_type;
+
+		_fseeki64(file, 0, SEEK_END);
+		length_type length = _ftelli64(file);
+		_fseeki64(file, 0, SEEK_SET);
+	#elif defined(__MINGW32__) && !defined(__NO_MINGW_LFS) && (!defined(__STRICT_ANSI__) || defined(__MINGW64_VERSION_MAJOR))
+		// there are 64-bit versions of fseek/ftell, let's use them
+		typedef off64_t length_type;
+
+		fseeko64(file, 0, SEEK_END);
+		length_type length = ftello64(file);
+		fseeko64(file, 0, SEEK_SET);
+	#else
+		// if this is a 32-bit OS, long is enough; if this is a unix system, long is 64-bit, which is enough; otherwise we can't do anything anyway.
+		typedef long length_type;
+
+		fseek(file, 0, SEEK_END);
+		length_type length = ftell(file);
+		fseek(file, 0, SEEK_SET);
+	#endif
+
+		// check for I/O errors
+		if (length < 0) return status_io_error;
+
+		// check for overflow
+		size_t result = static_cast<size_t>(length);
+
+		if (static_cast<length_type>(result) != length) return status_out_of_memory;
+
+		// finalize
+		out_result = result;
+
+		return status_ok;
+	}
+
+	// This function assumes that buffer has extra sizeof(char_t) writable bytes after size
+	PUGI__FN size_t zero_terminate_buffer(void* buffer, size_t size, xml_encoding encoding)
+	{
+		// We only need to zero-terminate if encoding conversion does not do it for us
+	#ifdef PUGIXML_WCHAR_MODE
+		xml_encoding wchar_encoding = get_wchar_encoding();
+
+		if (encoding == wchar_encoding || need_endian_swap_utf(encoding, wchar_encoding))
+		{
+			size_t length = size / sizeof(char_t);
+
+			static_cast<char_t*>(buffer)[length] = 0;
+			return (length + 1) * sizeof(char_t);
+		}
+	#else
+		if (encoding == encoding_utf8)
+		{
+			static_cast<char*>(buffer)[size] = 0;
+			return size + 1;
+		}
+	#endif
+
+		return size;
+	}
+
+	PUGI__FN xml_parse_result load_file_impl(xml_document_struct* doc, FILE* file, unsigned int options, xml_encoding encoding, char_t** out_buffer)
+	{
+		if (!file) return make_parse_result(status_file_not_found);
+
+		// get file size (can result in I/O errors)
+		size_t size = 0;
+		xml_parse_status size_status = get_file_size(file, size);
+		if (size_status != status_ok) return make_parse_result(size_status);
+
+		size_t max_suffix_size = sizeof(char_t);
+
+		// allocate buffer for the whole file
+		char* contents = static_cast<char*>(xml_memory::allocate(size + max_suffix_size));
+		if (!contents) return make_parse_result(status_out_of_memory);
+
+		// read file in memory
+		size_t read_size = fread(contents, 1, size, file);
+
+		if (read_size != size)
+		{
+			xml_memory::deallocate(contents);
+			return make_parse_result(status_io_error);
+		}
+
+		xml_encoding real_encoding = get_buffer_encoding(encoding, contents, size);
+
+		return load_buffer_impl(doc, doc, contents, zero_terminate_buffer(contents, size, real_encoding), options, real_encoding, true, true, out_buffer);
+	}
+
+	PUGI__FN void close_file(FILE* file)
+	{
+		fclose(file);
+	}
+
+#ifndef PUGIXML_NO_STL
+	template <typename T> struct xml_stream_chunk
+	{
+		static xml_stream_chunk* create()
+		{
+			void* memory = xml_memory::allocate(sizeof(xml_stream_chunk));
+			if (!memory) return 0;
+
+			return new (memory) xml_stream_chunk();
+		}
+
+		static void destroy(xml_stream_chunk* chunk)
+		{
+			// free chunk chain
+			while (chunk)
+			{
+				xml_stream_chunk* next_ = chunk->next;
+
+				xml_memory::deallocate(chunk);
+
+				chunk = next_;
+			}
+		}
+
+		xml_stream_chunk(): next(0), size(0)
+		{
+		}
+
+		xml_stream_chunk* next;
+		size_t size;
+
+		T data[xml_memory_page_size / sizeof(T)];
+	};
+
+	template <typename T> PUGI__FN xml_parse_status load_stream_data_noseek(std::basic_istream<T>& stream, void** out_buffer, size_t* out_size)
+	{
+		auto_deleter<xml_stream_chunk<T> > chunks(0, xml_stream_chunk<T>::destroy);
+
+		// read file to a chunk list
+		size_t total = 0;
+		xml_stream_chunk<T>* last = 0;
+
+		while (!stream.eof())
+		{
+			// allocate new chunk
+			xml_stream_chunk<T>* chunk = xml_stream_chunk<T>::create();
+			if (!chunk) return status_out_of_memory;
+
+			// append chunk to list
+			if (last) last = last->next = chunk;
+			else chunks.data = last = chunk;
+
+			// read data to chunk
+			stream.read(chunk->data, static_cast<std::streamsize>(sizeof(chunk->data) / sizeof(T)));
+			chunk->size = static_cast<size_t>(stream.gcount()) * sizeof(T);
+
+			// read may set failbit | eofbit in case gcount() is less than read length, so check for other I/O errors
+			if (stream.bad() || (!stream.eof() && stream.fail())) return status_io_error;
+
+			// guard against huge files (chunk size is small enough to make this overflow check work)
+			if (total + chunk->size < total) return status_out_of_memory;
+			total += chunk->size;
+		}
+
+		size_t max_suffix_size = sizeof(char_t);
+
+		// copy chunk list to a contiguous buffer
+		char* buffer = static_cast<char*>(xml_memory::allocate(total + max_suffix_size));
+		if (!buffer) return status_out_of_memory;
+
+		char* write = buffer;
+
+		for (xml_stream_chunk<T>* chunk = chunks.data; chunk; chunk = chunk->next)
+		{
+			assert(write + chunk->size <= buffer + total);
+			memcpy(write, chunk->data, chunk->size);
+			write += chunk->size;
+		}
+
+		assert(write == buffer + total);
+
+		// return buffer
+		*out_buffer = buffer;
+		*out_size = total;
+
+		return status_ok;
+	}
+
+	template <typename T> PUGI__FN xml_parse_status load_stream_data_seek(std::basic_istream<T>& stream, void** out_buffer, size_t* out_size)
+	{
+		// get length of remaining data in stream
+		typename std::basic_istream<T>::pos_type pos = stream.tellg();
+		stream.seekg(0, std::ios::end);
+		std::streamoff length = stream.tellg() - pos;
+		stream.seekg(pos);
+
+		if (stream.fail() || pos < 0) return status_io_error;
+
+		// guard against huge files
+		size_t read_length = static_cast<size_t>(length);
+
+		if (static_cast<std::streamsize>(read_length) != length || length < 0) return status_out_of_memory;
+
+		size_t max_suffix_size = sizeof(char_t);
+
+		// read stream data into memory (guard against stream exceptions with buffer holder)
+		auto_deleter<void> buffer(xml_memory::allocate(read_length * sizeof(T) + max_suffix_size), xml_memory::deallocate);
+		if (!buffer.data) return status_out_of_memory;
+
+		stream.read(static_cast<T*>(buffer.data), static_cast<std::streamsize>(read_length));
+
+		// read may set failbit | eofbit in case gcount() is less than read_length (i.e. line ending conversion), so check for other I/O errors
+		if (stream.bad() || (!stream.eof() && stream.fail())) return status_io_error;
+
+		// return buffer
+		size_t actual_length = static_cast<size_t>(stream.gcount());
+		assert(actual_length <= read_length);
+
+		*out_buffer = buffer.release();
+		*out_size = actual_length * sizeof(T);
+
+		return status_ok;
+	}
+
+	template <typename T> PUGI__FN xml_parse_result load_stream_impl(xml_document_struct* doc, std::basic_istream<T>& stream, unsigned int options, xml_encoding encoding, char_t** out_buffer)
+	{
+		void* buffer = 0;
+		size_t size = 0;
+		xml_parse_status status = status_ok;
+
+		// if stream has an error bit set, bail out (otherwise tellg() can fail and we'll clear error bits)
+		if (stream.fail()) return make_parse_result(status_io_error);
+
+		// load stream to memory (using seek-based implementation if possible, since it's faster and takes less memory)
+		if (stream.tellg() < 0)
+		{
+			stream.clear(); // clear error flags that could be set by a failing tellg
+			status = load_stream_data_noseek(stream, &buffer, &size);
+		}
+		else
+			status = load_stream_data_seek(stream, &buffer, &size);
+
+		if (status != status_ok) return make_parse_result(status);
+
+		xml_encoding real_encoding = get_buffer_encoding(encoding, buffer, size);
+
+		return load_buffer_impl(doc, doc, buffer, zero_terminate_buffer(buffer, size, real_encoding), options, real_encoding, true, true, out_buffer);
+	}
+#endif
+
+#if defined(PUGI__MSVC_CRT_VERSION) || defined(__BORLANDC__) || (defined(__MINGW32__) && (!defined(__STRICT_ANSI__) || defined(__MINGW64_VERSION_MAJOR)))
+	PUGI__FN FILE* open_file_wide(const wchar_t* path, const wchar_t* mode)
+	{
+#if defined(PUGI__MSVC_CRT_VERSION) && PUGI__MSVC_CRT_VERSION >= 1400
+		FILE* file = 0;
+		return _wfopen_s(&file, path, mode) == 0 ? file : 0;
+#else
+		return _wfopen(path, mode);
+#endif
+	}
+#else
+	PUGI__FN char* convert_path_heap(const wchar_t* str)
+	{
+		assert(str);
+
+		// first pass: get length in utf8 characters
+		size_t length = strlength_wide(str);
+		size_t size = as_utf8_begin(str, length);
+
+		// allocate resulting string
+		char* result = static_cast<char*>(xml_memory::allocate(size + 1));
+		if (!result) return 0;
+
+		// second pass: convert to utf8
+		as_utf8_end(result, size, str, length);
+
+		// zero-terminate
+		result[size] = 0;
+
+		return result;
+	}
+
+	PUGI__FN FILE* open_file_wide(const wchar_t* path, const wchar_t* mode)
+	{
+		// there is no standard function to open wide paths, so our best bet is to try utf8 path
+		char* path_utf8 = convert_path_heap(path);
+		if (!path_utf8) return 0;
+
+		// convert mode to ASCII (we mirror _wfopen interface)
+		char mode_ascii[4] = {0};
+		for (size_t i = 0; mode[i]; ++i) mode_ascii[i] = static_cast<char>(mode[i]);
+
+		// try to open the utf8 path
+		FILE* result = fopen(path_utf8, mode_ascii);
+
+		// free dummy buffer
+		xml_memory::deallocate(path_utf8);
+
+		return result;
+	}
+#endif
+
+	PUGI__FN FILE* open_file(const char* path, const char* mode)
+	{
+#if defined(PUGI__MSVC_CRT_VERSION) && PUGI__MSVC_CRT_VERSION >= 1400
+		FILE* file = 0;
+		return fopen_s(&file, path, mode) == 0 ? file : 0;
+#else
+		return fopen(path, mode);
+#endif
+	}
+
+	PUGI__FN bool save_file_impl(const xml_document& doc, FILE* file, const char_t* indent, unsigned int flags, xml_encoding encoding)
+	{
+		if (!file) return false;
+
+		xml_writer_file writer(file);
+		doc.save(writer, indent, flags, encoding);
+
+		return ferror(file) == 0;
+	}
+
+	struct name_null_sentry
+	{
+		xml_node_struct* node;
+		char_t* name;
+
+		name_null_sentry(xml_node_struct* node_): node(node_), name(node_->name)
+		{
+			node->name = 0;
+		}
+
+		~name_null_sentry()
+		{
+			node->name = name;
+		}
+	};
+PUGI__NS_END
+
+namespace pugi
+{
+	PUGI__FN xml_writer_file::xml_writer_file(void* file_): file(file_)
+	{
+	}
+
+	PUGI__FN void xml_writer_file::write(const void* data, size_t size)
+	{
+		size_t result = fwrite(data, 1, size, static_cast<FILE*>(file));
+		(void)!result; // unfortunately we can't do proper error handling here
+	}
+
+#ifndef PUGIXML_NO_STL
+	PUGI__FN xml_writer_stream::xml_writer_stream(std::basic_ostream<char, std::char_traits<char> >& stream): narrow_stream(&stream), wide_stream(0)
+	{
+	}
+
+	PUGI__FN xml_writer_stream::xml_writer_stream(std::basic_ostream<wchar_t, std::char_traits<wchar_t> >& stream): narrow_stream(0), wide_stream(&stream)
+	{
+	}
+
+	PUGI__FN void xml_writer_stream::write(const void* data, size_t size)
+	{
+		if (narrow_stream)
+		{
+			assert(!wide_stream);
+			narrow_stream->write(reinterpret_cast<const char*>(data), static_cast<std::streamsize>(size));
+		}
+		else
+		{
+			assert(wide_stream);
+			assert(size % sizeof(wchar_t) == 0);
+
+			wide_stream->write(reinterpret_cast<const wchar_t*>(data), static_cast<std::streamsize>(size / sizeof(wchar_t)));
+		}
+	}
+#endif
+
+	PUGI__FN xml_tree_walker::xml_tree_walker(): _depth(0)
+	{
+	}
+
+	PUGI__FN xml_tree_walker::~xml_tree_walker()
+	{
+	}
+
+	PUGI__FN int xml_tree_walker::depth() const
+	{
+		return _depth;
+	}
+
+	PUGI__FN bool xml_tree_walker::begin(xml_node&)
+	{
+		return true;
+	}
+
+	PUGI__FN bool xml_tree_walker::end(xml_node&)
+	{
+		return true;
+	}
+
+	PUGI__FN xml_attribute::xml_attribute(): _attr(0)
+	{
+	}
+
+	PUGI__FN xml_attribute::xml_attribute(xml_attribute_struct* attr): _attr(attr)
+	{
+	}
+
+	PUGI__FN static void unspecified_bool_xml_attribute(xml_attribute***)
+	{
+	}
+
+	PUGI__FN xml_attribute::operator xml_attribute::unspecified_bool_type() const
+	{
+		return _attr ? unspecified_bool_xml_attribute : 0;
+	}
+
+	PUGI__FN bool xml_attribute::operator!() const
+	{
+		return !_attr;
+	}
+
+	PUGI__FN bool xml_attribute::operator==(const xml_attribute& r) const
+	{
+		return (_attr == r._attr);
+	}
+
+	PUGI__FN bool xml_attribute::operator!=(const xml_attribute& r) const
+	{
+		return (_attr != r._attr);
+	}
+
+	PUGI__FN bool xml_attribute::operator<(const xml_attribute& r) const
+	{
+		return (_attr < r._attr);
+	}
+
+	PUGI__FN bool xml_attribute::operator>(const xml_attribute& r) const
+	{
+		return (_attr > r._attr);
+	}
+
+	PUGI__FN bool xml_attribute::operator<=(const xml_attribute& r) const
+	{
+		return (_attr <= r._attr);
+	}
+
+	PUGI__FN bool xml_attribute::operator>=(const xml_attribute& r) const
+	{
+		return (_attr >= r._attr);
+	}
+
+	PUGI__FN xml_attribute xml_attribute::next_attribute() const
+	{
+		return _attr ? xml_attribute(_attr->next_attribute) : xml_attribute();
+	}
+
+	PUGI__FN xml_attribute xml_attribute::previous_attribute() const
+	{
+		return _attr && _attr->prev_attribute_c->next_attribute ? xml_attribute(_attr->prev_attribute_c) : xml_attribute();
+	}
+
+	PUGI__FN const char_t* xml_attribute::as_string(const char_t* def) const
+	{
+		return (_attr && _attr->value) ? _attr->value + 0 : def;
+	}
+
+	PUGI__FN int xml_attribute::as_int(int def) const
+	{
+		return (_attr && _attr->value) ? impl::get_value_int(_attr->value) : def;
+	}
+
+	PUGI__FN unsigned int xml_attribute::as_uint(unsigned int def) const
+	{
+		return (_attr && _attr->value) ? impl::get_value_uint(_attr->value) : def;
+	}
+
+	PUGI__FN double xml_attribute::as_double(double def) const
+	{
+		return (_attr && _attr->value) ? impl::get_value_double(_attr->value) : def;
+	}
+
+	PUGI__FN float xml_attribute::as_float(float def) const
+	{
+		return (_attr && _attr->value) ? impl::get_value_float(_attr->value) : def;
+	}
+
+	PUGI__FN bool xml_attribute::as_bool(bool def) const
+	{
+		return (_attr && _attr->value) ? impl::get_value_bool(_attr->value) : def;
+	}
+
+#ifdef PUGIXML_HAS_LONG_LONG
+	PUGI__FN long long xml_attribute::as_llong(long long def) const
+	{
+		return (_attr && _attr->value) ? impl::get_value_llong(_attr->value) : def;
+	}
+
+	PUGI__FN unsigned long long xml_attribute::as_ullong(unsigned long long def) const
+	{
+		return (_attr && _attr->value) ? impl::get_value_ullong(_attr->value) : def;
+	}
+#endif
+
+	PUGI__FN bool xml_attribute::empty() const
+	{
+		return !_attr;
+	}
+
+	PUGI__FN const char_t* xml_attribute::name() const
+	{
+		return (_attr && _attr->name) ? _attr->name + 0 : PUGIXML_TEXT("");
+	}
+
+	PUGI__FN const char_t* xml_attribute::value() const
+	{
+		return (_attr && _attr->value) ? _attr->value + 0 : PUGIXML_TEXT("");
+	}
+
+	PUGI__FN size_t xml_attribute::hash_value() const
+	{
+		return static_cast<size_t>(reinterpret_cast<uintptr_t>(_attr) / sizeof(xml_attribute_struct));
+	}
+
+	PUGI__FN xml_attribute_struct* xml_attribute::internal_object() const
+	{
+		return _attr;
+	}
+
+	PUGI__FN xml_attribute& xml_attribute::operator=(const char_t* rhs)
+	{
+		set_value(rhs);
+		return *this;
+	}
+
+	PUGI__FN xml_attribute& xml_attribute::operator=(int rhs)
+	{
+		set_value(rhs);
+		return *this;
+	}
+
+	PUGI__FN xml_attribute& xml_attribute::operator=(unsigned int rhs)
+	{
+		set_value(rhs);
+		return *this;
+	}
+
+	PUGI__FN xml_attribute& xml_attribute::operator=(long rhs)
+	{
+		set_value(rhs);
+		return *this;
+	}
+
+	PUGI__FN xml_attribute& xml_attribute::operator=(unsigned long rhs)
+	{
+		set_value(rhs);
+		return *this;
+	}
+
+	PUGI__FN xml_attribute& xml_attribute::operator=(double rhs)
+	{
+		set_value(rhs);
+		return *this;
+	}
+
+	PUGI__FN xml_attribute& xml_attribute::operator=(float rhs)
+	{
+		set_value(rhs);
+		return *this;
+	}
+
+	PUGI__FN xml_attribute& xml_attribute::operator=(bool rhs)
+	{
+		set_value(rhs);
+		return *this;
+	}
+
+#ifdef PUGIXML_HAS_LONG_LONG
+	PUGI__FN xml_attribute& xml_attribute::operator=(long long rhs)
+	{
+		set_value(rhs);
+		return *this;
+	}
+
+	PUGI__FN xml_attribute& xml_attribute::operator=(unsigned long long rhs)
+	{
+		set_value(rhs);
+		return *this;
+	}
+#endif
+
+	PUGI__FN bool xml_attribute::set_name(const char_t* rhs)
+	{
+		if (!_attr) return false;
+
+		return impl::strcpy_insitu(_attr->name, _attr->header, impl::xml_memory_page_name_allocated_mask, rhs, impl::strlength(rhs));
+	}
+
+	PUGI__FN bool xml_attribute::set_value(const char_t* rhs)
+	{
+		if (!_attr) return false;
+
+		return impl::strcpy_insitu(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs, impl::strlength(rhs));
+	}
+
+	PUGI__FN bool xml_attribute::set_value(int rhs)
+	{
+		if (!_attr) return false;
+
+		return impl::set_value_integer<unsigned int>(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs, rhs < 0);
+	}
+
+	PUGI__FN bool xml_attribute::set_value(unsigned int rhs)
+	{
+		if (!_attr) return false;
+
+		return impl::set_value_integer<unsigned int>(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs, false);
+	}
+
+	PUGI__FN bool xml_attribute::set_value(long rhs)
+	{
+		if (!_attr) return false;
+
+		return impl::set_value_integer<unsigned long>(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs, rhs < 0);
+	}
+
+	PUGI__FN bool xml_attribute::set_value(unsigned long rhs)
+	{
+		if (!_attr) return false;
+
+		return impl::set_value_integer<unsigned long>(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs, false);
+	}
+
+	PUGI__FN bool xml_attribute::set_value(double rhs)
+	{
+		if (!_attr) return false;
+
+		return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs, default_double_precision);
+	}
+
+	PUGI__FN bool xml_attribute::set_value(double rhs, int precision)
+	{
+		if (!_attr) return false;
+
+		return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs, precision);
+	}
+
+	PUGI__FN bool xml_attribute::set_value(float rhs)
+	{
+		if (!_attr) return false;
+
+		return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs, default_float_precision);
+	}
+
+	PUGI__FN bool xml_attribute::set_value(float rhs, int precision)
+	{
+		if (!_attr) return false;
+
+		return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs, precision);
+	}
+
+	PUGI__FN bool xml_attribute::set_value(bool rhs)
+	{
+		if (!_attr) return false;
+
+		return impl::set_value_bool(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs);
+	}
+
+#ifdef PUGIXML_HAS_LONG_LONG
+	PUGI__FN bool xml_attribute::set_value(long long rhs)
+	{
+		if (!_attr) return false;
+
+		return impl::set_value_integer<unsigned long long>(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs, rhs < 0);
+	}
+
+	PUGI__FN bool xml_attribute::set_value(unsigned long long rhs)
+	{
+		if (!_attr) return false;
+
+		return impl::set_value_integer<unsigned long long>(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs, false);
+	}
+#endif
+
+#ifdef __BORLANDC__
+	PUGI__FN bool operator&&(const xml_attribute& lhs, bool rhs)
+	{
+		return (bool)lhs && rhs;
+	}
+
+	PUGI__FN bool operator||(const xml_attribute& lhs, bool rhs)
+	{
+		return (bool)lhs || rhs;
+	}
+#endif
+
+	PUGI__FN xml_node::xml_node(): _root(0)
+	{
+	}
+
+	PUGI__FN xml_node::xml_node(xml_node_struct* p): _root(p)
+	{
+	}
+
+	PUGI__FN static void unspecified_bool_xml_node(xml_node***)
+	{
+	}
+
+	PUGI__FN xml_node::operator xml_node::unspecified_bool_type() const
+	{
+		return _root ? unspecified_bool_xml_node : 0;
+	}
+
+	PUGI__FN bool xml_node::operator!() const
+	{
+		return !_root;
+	}
+
+	PUGI__FN xml_node::iterator xml_node::begin() const
+	{
+		return iterator(_root ? _root->first_child + 0 : 0, _root);
+	}
+
+	PUGI__FN xml_node::iterator xml_node::end() const
+	{
+		return iterator(0, _root);
+	}
+
+	PUGI__FN xml_node::attribute_iterator xml_node::attributes_begin() const
+	{
+		return attribute_iterator(_root ? _root->first_attribute + 0 : 0, _root);
+	}
+
+	PUGI__FN xml_node::attribute_iterator xml_node::attributes_end() const
+	{
+		return attribute_iterator(0, _root);
+	}
+
+	PUGI__FN xml_object_range<xml_node_iterator> xml_node::children() const
+	{
+		return xml_object_range<xml_node_iterator>(begin(), end());
+	}
+
+	PUGI__FN xml_object_range<xml_named_node_iterator> xml_node::children(const char_t* name_) const
+	{
+		return xml_object_range<xml_named_node_iterator>(xml_named_node_iterator(child(name_)._root, _root, name_), xml_named_node_iterator(0, _root, name_));
+	}
+
+	PUGI__FN xml_object_range<xml_attribute_iterator> xml_node::attributes() const
+	{
+		return xml_object_range<xml_attribute_iterator>(attributes_begin(), attributes_end());
+	}
+
+	PUGI__FN bool xml_node::operator==(const xml_node& r) const
+	{
+		return (_root == r._root);
+	}
+
+	PUGI__FN bool xml_node::operator!=(const xml_node& r) const
+	{
+		return (_root != r._root);
+	}
+
+	PUGI__FN bool xml_node::operator<(const xml_node& r) const
+	{
+		return (_root < r._root);
+	}
+
+	PUGI__FN bool xml_node::operator>(const xml_node& r) const
+	{
+		return (_root > r._root);
+	}
+
+	PUGI__FN bool xml_node::operator<=(const xml_node& r) const
+	{
+		return (_root <= r._root);
+	}
+
+	PUGI__FN bool xml_node::operator>=(const xml_node& r) const
+	{
+		return (_root >= r._root);
+	}
+
+	PUGI__FN bool xml_node::empty() const
+	{
+		return !_root;
+	}
+
+	PUGI__FN const char_t* xml_node::name() const
+	{
+		return (_root && _root->name) ? _root->name + 0 : PUGIXML_TEXT("");
+	}
+
+	PUGI__FN xml_node_type xml_node::type() const
+	{
+		return _root ? PUGI__NODETYPE(_root) : node_null;
+	}
+
+	PUGI__FN const char_t* xml_node::value() const
+	{
+		return (_root && _root->value) ? _root->value + 0 : PUGIXML_TEXT("");
+	}
+
+	PUGI__FN xml_node xml_node::child(const char_t* name_) const
+	{
+		if (!_root) return xml_node();
+
+		for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
+			if (i->name && impl::strequal(name_, i->name)) return xml_node(i);
+
+		return xml_node();
+	}
+
+	PUGI__FN xml_attribute xml_node::attribute(const char_t* name_) const
+	{
+		if (!_root) return xml_attribute();
+
+		for (xml_attribute_struct* i = _root->first_attribute; i; i = i->next_attribute)
+			if (i->name && impl::strequal(name_, i->name))
+				return xml_attribute(i);
+
+		return xml_attribute();
+	}
+
+	PUGI__FN xml_node xml_node::next_sibling(const char_t* name_) const
+	{
+		if (!_root) return xml_node();
+
+		for (xml_node_struct* i = _root->next_sibling; i; i = i->next_sibling)
+			if (i->name && impl::strequal(name_, i->name)) return xml_node(i);
+
+		return xml_node();
+	}
+
+	PUGI__FN xml_node xml_node::next_sibling() const
+	{
+		return _root ? xml_node(_root->next_sibling) : xml_node();
+	}
+
+	PUGI__FN xml_node xml_node::previous_sibling(const char_t* name_) const
+	{
+		if (!_root) return xml_node();
+
+		for (xml_node_struct* i = _root->prev_sibling_c; i->next_sibling; i = i->prev_sibling_c)
+			if (i->name && impl::strequal(name_, i->name)) return xml_node(i);
+
+		return xml_node();
+	}
+
+	PUGI__FN xml_attribute xml_node::attribute(const char_t* name_, xml_attribute& hint_) const
+	{
+		xml_attribute_struct* hint = hint_._attr;
+
+		// if hint is not an attribute of node, behavior is not defined
+		assert(!hint || (_root && impl::is_attribute_of(hint, _root)));
+
+		if (!_root) return xml_attribute();
+
+		// optimistically search from hint up until the end
+		for (xml_attribute_struct* i = hint; i; i = i->next_attribute)
+			if (i->name && impl::strequal(name_, i->name))
+			{
+				// update hint to maximize efficiency of searching for consecutive attributes
+				hint_._attr = i->next_attribute;
+
+				return xml_attribute(i);
+			}
+
+		// wrap around and search from the first attribute until the hint
+		// 'j' null pointer check is technically redundant, but it prevents a crash in case the assertion above fails
+		for (xml_attribute_struct* j = _root->first_attribute; j && j != hint; j = j->next_attribute)
+			if (j->name && impl::strequal(name_, j->name))
+			{
+				// update hint to maximize efficiency of searching for consecutive attributes
+				hint_._attr = j->next_attribute;
+
+				return xml_attribute(j);
+			}
+
+		return xml_attribute();
+	}
+
+	PUGI__FN xml_node xml_node::previous_sibling() const
+	{
+		if (!_root) return xml_node();
+
+		if (_root->prev_sibling_c->next_sibling) return xml_node(_root->prev_sibling_c);
+		else return xml_node();
+	}
+
+	PUGI__FN xml_node xml_node::parent() const
+	{
+		return _root ? xml_node(_root->parent) : xml_node();
+	}
+
+	PUGI__FN xml_node xml_node::root() const
+	{
+		return _root ? xml_node(&impl::get_document(_root)) : xml_node();
+	}
+
+	PUGI__FN xml_text xml_node::text() const
+	{
+		return xml_text(_root);
+	}
+
+	PUGI__FN const char_t* xml_node::child_value() const
+	{
+		if (!_root) return PUGIXML_TEXT("");
+
+		// element nodes can have value if parse_embed_pcdata was used
+		if (PUGI__NODETYPE(_root) == node_element && _root->value)
+			return _root->value;
+
+		for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
+			if (impl::is_text_node(i) && i->value)
+				return i->value;
+
+		return PUGIXML_TEXT("");
+	}
+
+	PUGI__FN const char_t* xml_node::child_value(const char_t* name_) const
+	{
+		return child(name_).child_value();
+	}
+
+	PUGI__FN xml_attribute xml_node::first_attribute() const
+	{
+		return _root ? xml_attribute(_root->first_attribute) : xml_attribute();
+	}
+
+	PUGI__FN xml_attribute xml_node::last_attribute() const
+	{
+		return _root && _root->first_attribute ? xml_attribute(_root->first_attribute->prev_attribute_c) : xml_attribute();
+	}
+
+	PUGI__FN xml_node xml_node::first_child() const
+	{
+		return _root ? xml_node(_root->first_child) : xml_node();
+	}
+
+	PUGI__FN xml_node xml_node::last_child() const
+	{
+		return _root && _root->first_child ? xml_node(_root->first_child->prev_sibling_c) : xml_node();
+	}
+
+	PUGI__FN bool xml_node::set_name(const char_t* rhs)
+	{
+		xml_node_type type_ = _root ? PUGI__NODETYPE(_root) : node_null;
+
+		if (type_ != node_element && type_ != node_pi && type_ != node_declaration)
+			return false;
+
+		return impl::strcpy_insitu(_root->name, _root->header, impl::xml_memory_page_name_allocated_mask, rhs, impl::strlength(rhs));
+	}
+
+	PUGI__FN bool xml_node::set_value(const char_t* rhs)
+	{
+		xml_node_type type_ = _root ? PUGI__NODETYPE(_root) : node_null;
+
+		if (type_ != node_pcdata && type_ != node_cdata && type_ != node_comment && type_ != node_pi && type_ != node_doctype)
+			return false;
+
+		return impl::strcpy_insitu(_root->value, _root->header, impl::xml_memory_page_value_allocated_mask, rhs, impl::strlength(rhs));
+	}
+
+	PUGI__FN xml_attribute xml_node::append_attribute(const char_t* name_)
+	{
+		if (!impl::allow_insert_attribute(type())) return xml_attribute();
+
+		impl::xml_allocator& alloc = impl::get_allocator(_root);
+		if (!alloc.reserve()) return xml_attribute();
+
+		xml_attribute a(impl::allocate_attribute(alloc));
+		if (!a) return xml_attribute();
+
+		impl::append_attribute(a._attr, _root);
+
+		a.set_name(name_);
+
+		return a;
+	}
+
+	PUGI__FN xml_attribute xml_node::prepend_attribute(const char_t* name_)
+	{
+		if (!impl::allow_insert_attribute(type())) return xml_attribute();
+
+		impl::xml_allocator& alloc = impl::get_allocator(_root);
+		if (!alloc.reserve()) return xml_attribute();
+
+		xml_attribute a(impl::allocate_attribute(alloc));
+		if (!a) return xml_attribute();
+
+		impl::prepend_attribute(a._attr, _root);
+
+		a.set_name(name_);
+
+		return a;
+	}
+
+	PUGI__FN xml_attribute xml_node::insert_attribute_after(const char_t* name_, const xml_attribute& attr)
+	{
+		if (!impl::allow_insert_attribute(type())) return xml_attribute();
+		if (!attr || !impl::is_attribute_of(attr._attr, _root)) return xml_attribute();
+
+		impl::xml_allocator& alloc = impl::get_allocator(_root);
+		if (!alloc.reserve()) return xml_attribute();
+
+		xml_attribute a(impl::allocate_attribute(alloc));
+		if (!a) return xml_attribute();
+
+		impl::insert_attribute_after(a._attr, attr._attr, _root);
+
+		a.set_name(name_);
+
+		return a;
+	}
+
+	PUGI__FN xml_attribute xml_node::insert_attribute_before(const char_t* name_, const xml_attribute& attr)
+	{
+		if (!impl::allow_insert_attribute(type())) return xml_attribute();
+		if (!attr || !impl::is_attribute_of(attr._attr, _root)) return xml_attribute();
+
+		impl::xml_allocator& alloc = impl::get_allocator(_root);
+		if (!alloc.reserve()) return xml_attribute();
+
+		xml_attribute a(impl::allocate_attribute(alloc));
+		if (!a) return xml_attribute();
+
+		impl::insert_attribute_before(a._attr, attr._attr, _root);
+
+		a.set_name(name_);
+
+		return a;
+	}
+
+	PUGI__FN xml_attribute xml_node::append_copy(const xml_attribute& proto)
+	{
+		if (!proto) return xml_attribute();
+		if (!impl::allow_insert_attribute(type())) return xml_attribute();
+
+		impl::xml_allocator& alloc = impl::get_allocator(_root);
+		if (!alloc.reserve()) return xml_attribute();
+
+		xml_attribute a(impl::allocate_attribute(alloc));
+		if (!a) return xml_attribute();
+
+		impl::append_attribute(a._attr, _root);
+		impl::node_copy_attribute(a._attr, proto._attr);
+
+		return a;
+	}
+
+	PUGI__FN xml_attribute xml_node::prepend_copy(const xml_attribute& proto)
+	{
+		if (!proto) return xml_attribute();
+		if (!impl::allow_insert_attribute(type())) return xml_attribute();
+
+		impl::xml_allocator& alloc = impl::get_allocator(_root);
+		if (!alloc.reserve()) return xml_attribute();
+
+		xml_attribute a(impl::allocate_attribute(alloc));
+		if (!a) return xml_attribute();
+
+		impl::prepend_attribute(a._attr, _root);
+		impl::node_copy_attribute(a._attr, proto._attr);
+
+		return a;
+	}
+
+	PUGI__FN xml_attribute xml_node::insert_copy_after(const xml_attribute& proto, const xml_attribute& attr)
+	{
+		if (!proto) return xml_attribute();
+		if (!impl::allow_insert_attribute(type())) return xml_attribute();
+		if (!attr || !impl::is_attribute_of(attr._attr, _root)) return xml_attribute();
+
+		impl::xml_allocator& alloc = impl::get_allocator(_root);
+		if (!alloc.reserve()) return xml_attribute();
+
+		xml_attribute a(impl::allocate_attribute(alloc));
+		if (!a) return xml_attribute();
+
+		impl::insert_attribute_after(a._attr, attr._attr, _root);
+		impl::node_copy_attribute(a._attr, proto._attr);
+
+		return a;
+	}
+
+	PUGI__FN xml_attribute xml_node::insert_copy_before(const xml_attribute& proto, const xml_attribute& attr)
+	{
+		if (!proto) return xml_attribute();
+		if (!impl::allow_insert_attribute(type())) return xml_attribute();
+		if (!attr || !impl::is_attribute_of(attr._attr, _root)) return xml_attribute();
+
+		impl::xml_allocator& alloc = impl::get_allocator(_root);
+		if (!alloc.reserve()) return xml_attribute();
+
+		xml_attribute a(impl::allocate_attribute(alloc));
+		if (!a) return xml_attribute();
+
+		impl::insert_attribute_before(a._attr, attr._attr, _root);
+		impl::node_copy_attribute(a._attr, proto._attr);
+
+		return a;
+	}
+
+	PUGI__FN xml_node xml_node::append_child(xml_node_type type_)
+	{
+		if (!impl::allow_insert_child(type(), type_)) return xml_node();
+
+		impl::xml_allocator& alloc = impl::get_allocator(_root);
+		if (!alloc.reserve()) return xml_node();
+
+		xml_node n(impl::allocate_node(alloc, type_));
+		if (!n) return xml_node();
+
+		impl::append_node(n._root, _root);
+
+		if (type_ == node_declaration) n.set_name(PUGIXML_TEXT("xml"));
+
+		return n;
+	}
+
+	PUGI__FN xml_node xml_node::prepend_child(xml_node_type type_)
+	{
+		if (!impl::allow_insert_child(type(), type_)) return xml_node();
+
+		impl::xml_allocator& alloc = impl::get_allocator(_root);
+		if (!alloc.reserve()) return xml_node();
+
+		xml_node n(impl::allocate_node(alloc, type_));
+		if (!n) return xml_node();
+
+		impl::prepend_node(n._root, _root);
+
+		if (type_ == node_declaration) n.set_name(PUGIXML_TEXT("xml"));
+
+		return n;
+	}
+
+	PUGI__FN xml_node xml_node::insert_child_before(xml_node_type type_, const xml_node& node)
+	{
+		if (!impl::allow_insert_child(type(), type_)) return xml_node();
+		if (!node._root || node._root->parent != _root) return xml_node();
+
+		impl::xml_allocator& alloc = impl::get_allocator(_root);
+		if (!alloc.reserve()) return xml_node();
+
+		xml_node n(impl::allocate_node(alloc, type_));
+		if (!n) return xml_node();
+
+		impl::insert_node_before(n._root, node._root);
+
+		if (type_ == node_declaration) n.set_name(PUGIXML_TEXT("xml"));
+
+		return n;
+	}
+
+	PUGI__FN xml_node xml_node::insert_child_after(xml_node_type type_, const xml_node& node)
+	{
+		if (!impl::allow_insert_child(type(), type_)) return xml_node();
+		if (!node._root || node._root->parent != _root) return xml_node();
+
+		impl::xml_allocator& alloc = impl::get_allocator(_root);
+		if (!alloc.reserve()) return xml_node();
+
+		xml_node n(impl::allocate_node(alloc, type_));
+		if (!n) return xml_node();
+
+		impl::insert_node_after(n._root, node._root);
+
+		if (type_ == node_declaration) n.set_name(PUGIXML_TEXT("xml"));
+
+		return n;
+	}
+
+	PUGI__FN xml_node xml_node::append_child(const char_t* name_)
+	{
+		xml_node result = append_child(node_element);
+
+		result.set_name(name_);
+
+		return result;
+	}
+
+	PUGI__FN xml_node xml_node::prepend_child(const char_t* name_)
+	{
+		xml_node result = prepend_child(node_element);
+
+		result.set_name(name_);
+
+		return result;
+	}
+
+	PUGI__FN xml_node xml_node::insert_child_after(const char_t* name_, const xml_node& node)
+	{
+		xml_node result = insert_child_after(node_element, node);
+
+		result.set_name(name_);
+
+		return result;
+	}
+
+	PUGI__FN xml_node xml_node::insert_child_before(const char_t* name_, const xml_node& node)
+	{
+		xml_node result = insert_child_before(node_element, node);
+
+		result.set_name(name_);
+
+		return result;
+	}
+
+	PUGI__FN xml_node xml_node::append_copy(const xml_node& proto)
+	{
+		xml_node_type type_ = proto.type();
+		if (!impl::allow_insert_child(type(), type_)) return xml_node();
+
+		impl::xml_allocator& alloc = impl::get_allocator(_root);
+		if (!alloc.reserve()) return xml_node();
+
+		xml_node n(impl::allocate_node(alloc, type_));
+		if (!n) return xml_node();
+
+		impl::append_node(n._root, _root);
+		impl::node_copy_tree(n._root, proto._root);
+
+		return n;
+	}
+
+	PUGI__FN xml_node xml_node::prepend_copy(const xml_node& proto)
+	{
+		xml_node_type type_ = proto.type();
+		if (!impl::allow_insert_child(type(), type_)) return xml_node();
+
+		impl::xml_allocator& alloc = impl::get_allocator(_root);
+		if (!alloc.reserve()) return xml_node();
+
+		xml_node n(impl::allocate_node(alloc, type_));
+		if (!n) return xml_node();
+
+		impl::prepend_node(n._root, _root);
+		impl::node_copy_tree(n._root, proto._root);
+
+		return n;
+	}
+
+	PUGI__FN xml_node xml_node::insert_copy_after(const xml_node& proto, const xml_node& node)
+	{
+		xml_node_type type_ = proto.type();
+		if (!impl::allow_insert_child(type(), type_)) return xml_node();
+		if (!node._root || node._root->parent != _root) return xml_node();
+
+		impl::xml_allocator& alloc = impl::get_allocator(_root);
+		if (!alloc.reserve()) return xml_node();
+
+		xml_node n(impl::allocate_node(alloc, type_));
+		if (!n) return xml_node();
+
+		impl::insert_node_after(n._root, node._root);
+		impl::node_copy_tree(n._root, proto._root);
+
+		return n;
+	}
+
+	PUGI__FN xml_node xml_node::insert_copy_before(const xml_node& proto, const xml_node& node)
+	{
+		xml_node_type type_ = proto.type();
+		if (!impl::allow_insert_child(type(), type_)) return xml_node();
+		if (!node._root || node._root->parent != _root) return xml_node();
+
+		impl::xml_allocator& alloc = impl::get_allocator(_root);
+		if (!alloc.reserve()) return xml_node();
+
+		xml_node n(impl::allocate_node(alloc, type_));
+		if (!n) return xml_node();
+
+		impl::insert_node_before(n._root, node._root);
+		impl::node_copy_tree(n._root, proto._root);
+
+		return n;
+	}
+
+	PUGI__FN xml_node xml_node::append_move(const xml_node& moved)
+	{
+		if (!impl::allow_move(*this, moved)) return xml_node();
+
+		impl::xml_allocator& alloc = impl::get_allocator(_root);
+		if (!alloc.reserve()) return xml_node();
+
+		// disable document_buffer_order optimization since moving nodes around changes document order without changing buffer pointers
+		impl::get_document(_root).header |= impl::xml_memory_page_contents_shared_mask;
+
+		impl::remove_node(moved._root);
+		impl::append_node(moved._root, _root);
+
+		return moved;
+	}
+
+	PUGI__FN xml_node xml_node::prepend_move(const xml_node& moved)
+	{
+		if (!impl::allow_move(*this, moved)) return xml_node();
+
+		impl::xml_allocator& alloc = impl::get_allocator(_root);
+		if (!alloc.reserve()) return xml_node();
+
+		// disable document_buffer_order optimization since moving nodes around changes document order without changing buffer pointers
+		impl::get_document(_root).header |= impl::xml_memory_page_contents_shared_mask;
+
+		impl::remove_node(moved._root);
+		impl::prepend_node(moved._root, _root);
+
+		return moved;
+	}
+
+	PUGI__FN xml_node xml_node::insert_move_after(const xml_node& moved, const xml_node& node)
+	{
+		if (!impl::allow_move(*this, moved)) return xml_node();
+		if (!node._root || node._root->parent != _root) return xml_node();
+		if (moved._root == node._root) return xml_node();
+
+		impl::xml_allocator& alloc = impl::get_allocator(_root);
+		if (!alloc.reserve()) return xml_node();
+
+		// disable document_buffer_order optimization since moving nodes around changes document order without changing buffer pointers
+		impl::get_document(_root).header |= impl::xml_memory_page_contents_shared_mask;
+
+		impl::remove_node(moved._root);
+		impl::insert_node_after(moved._root, node._root);
+
+		return moved;
+	}
+
+	PUGI__FN xml_node xml_node::insert_move_before(const xml_node& moved, const xml_node& node)
+	{
+		if (!impl::allow_move(*this, moved)) return xml_node();
+		if (!node._root || node._root->parent != _root) return xml_node();
+		if (moved._root == node._root) return xml_node();
+
+		impl::xml_allocator& alloc = impl::get_allocator(_root);
+		if (!alloc.reserve()) return xml_node();
+
+		// disable document_buffer_order optimization since moving nodes around changes document order without changing buffer pointers
+		impl::get_document(_root).header |= impl::xml_memory_page_contents_shared_mask;
+
+		impl::remove_node(moved._root);
+		impl::insert_node_before(moved._root, node._root);
+
+		return moved;
+	}
+
+	PUGI__FN bool xml_node::remove_attribute(const char_t* name_)
+	{
+		return remove_attribute(attribute(name_));
+	}
+
+	PUGI__FN bool xml_node::remove_attribute(const xml_attribute& a)
+	{
+		if (!_root || !a._attr) return false;
+		if (!impl::is_attribute_of(a._attr, _root)) return false;
+
+		impl::xml_allocator& alloc = impl::get_allocator(_root);
+		if (!alloc.reserve()) return false;
+
+		impl::remove_attribute(a._attr, _root);
+		impl::destroy_attribute(a._attr, alloc);
+
+		return true;
+	}
+
+	PUGI__FN bool xml_node::remove_attributes()
+	{
+		if (!_root) return false;
+
+		impl::xml_allocator& alloc = impl::get_allocator(_root);
+		if (!alloc.reserve()) return false;
+
+		for (xml_attribute_struct* attr = _root->first_attribute; attr; )
+		{
+			xml_attribute_struct* next = attr->next_attribute;
+
+			impl::destroy_attribute(attr, alloc);
+
+			attr = next;
+		}
+
+		_root->first_attribute = 0;
+
+		return true;
+	}
+
+	PUGI__FN bool xml_node::remove_child(const char_t* name_)
+	{
+		return remove_child(child(name_));
+	}
+
+	PUGI__FN bool xml_node::remove_child(const xml_node& n)
+	{
+		if (!_root || !n._root || n._root->parent != _root) return false;
+
+		impl::xml_allocator& alloc = impl::get_allocator(_root);
+		if (!alloc.reserve()) return false;
+
+		impl::remove_node(n._root);
+		impl::destroy_node(n._root, alloc);
+
+		return true;
+	}
+
+	PUGI__FN bool xml_node::remove_children()
+	{
+		if (!_root) return false;
+
+		impl::xml_allocator& alloc = impl::get_allocator(_root);
+		if (!alloc.reserve()) return false;
+
+		for (xml_node_struct* cur = _root->first_child; cur; )
+		{
+			xml_node_struct* next = cur->next_sibling;
+
+			impl::destroy_node(cur, alloc);
+
+			cur = next;
+		}
+
+		_root->first_child = 0;
+
+		return true;
+	}
+
+	PUGI__FN xml_parse_result xml_node::append_buffer(const void* contents, size_t size, unsigned int options, xml_encoding encoding)
+	{
+		// append_buffer is only valid for elements/documents
+		if (!impl::allow_insert_child(type(), node_element)) return impl::make_parse_result(status_append_invalid_root);
+
+		// get document node
+		impl::xml_document_struct* doc = &impl::get_document(_root);
+
+		// disable document_buffer_order optimization since in a document with multiple buffers comparing buffer pointers does not make sense
+		doc->header |= impl::xml_memory_page_contents_shared_mask;
+
+		// get extra buffer element (we'll store the document fragment buffer there so that we can deallocate it later)
+		impl::xml_memory_page* page = 0;
+		impl::xml_extra_buffer* extra = static_cast<impl::xml_extra_buffer*>(doc->allocate_memory(sizeof(impl::xml_extra_buffer) + sizeof(void*), page));
+		(void)page;
+
+		if (!extra) return impl::make_parse_result(status_out_of_memory);
+
+	#ifdef PUGIXML_COMPACT
+		// align the memory block to a pointer boundary; this is required for compact mode where memory allocations are only 4b aligned
+		// note that this requires up to sizeof(void*)-1 additional memory, which the allocation above takes into account
+		extra = reinterpret_cast<impl::xml_extra_buffer*>((reinterpret_cast<uintptr_t>(extra) + (sizeof(void*) - 1)) & ~(sizeof(void*) - 1));
+	#endif
+
+		// add extra buffer to the list
+		extra->buffer = 0;
+		extra->next = doc->extra_buffers;
+		doc->extra_buffers = extra;
+
+		// name of the root has to be NULL before parsing - otherwise closing node mismatches will not be detected at the top level
+		impl::name_null_sentry sentry(_root);
+
+		return impl::load_buffer_impl(doc, _root, const_cast<void*>(contents), size, options, encoding, false, false, &extra->buffer);
+	}
+
+	PUGI__FN xml_node xml_node::find_child_by_attribute(const char_t* name_, const char_t* attr_name, const char_t* attr_value) const
+	{
+		if (!_root) return xml_node();
+
+		for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
+			if (i->name && impl::strequal(name_, i->name))
+			{
+				for (xml_attribute_struct* a = i->first_attribute; a; a = a->next_attribute)
+					if (a->name && impl::strequal(attr_name, a->name) && impl::strequal(attr_value, a->value ? a->value + 0 : PUGIXML_TEXT("")))
+						return xml_node(i);
+			}
+
+		return xml_node();
+	}
+
+	PUGI__FN xml_node xml_node::find_child_by_attribute(const char_t* attr_name, const char_t* attr_value) const
+	{
+		if (!_root) return xml_node();
+
+		for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
+			for (xml_attribute_struct* a = i->first_attribute; a; a = a->next_attribute)
+				if (a->name && impl::strequal(attr_name, a->name) && impl::strequal(attr_value, a->value ? a->value + 0 : PUGIXML_TEXT("")))
+					return xml_node(i);
+
+		return xml_node();
+	}
+
+#ifndef PUGIXML_NO_STL
+	PUGI__FN string_t xml_node::path(char_t delimiter) const
+	{
+		if (!_root) return string_t();
+
+		size_t offset = 0;
+
+		for (xml_node_struct* i = _root; i; i = i->parent)
+		{
+			offset += (i != _root);
+			offset += i->name ? impl::strlength(i->name) : 0;
+		}
+
+		string_t result;
+		result.resize(offset);
+
+		for (xml_node_struct* j = _root; j; j = j->parent)
+		{
+			if (j != _root)
+				result[--offset] = delimiter;
+
+			if (j->name)
+			{
+				size_t length = impl::strlength(j->name);
+
+				offset -= length;
+				memcpy(&result[offset], j->name, length * sizeof(char_t));
+			}
+		}
+
+		assert(offset == 0);
+
+		return result;
+	}
+#endif
+
+	PUGI__FN xml_node xml_node::first_element_by_path(const char_t* path_, char_t delimiter) const
+	{
+		xml_node context = path_[0] == delimiter ? root() : *this;
+
+		if (!context._root) return xml_node();
+
+		const char_t* path_segment = path_;
+
+		while (*path_segment == delimiter) ++path_segment;
+
+		const char_t* path_segment_end = path_segment;
+
+		while (*path_segment_end && *path_segment_end != delimiter) ++path_segment_end;
+
+		if (path_segment == path_segment_end) return context;
+
+		const char_t* next_segment = path_segment_end;
+
+		while (*next_segment == delimiter) ++next_segment;
+
+		if (*path_segment == '.' && path_segment + 1 == path_segment_end)
+			return context.first_element_by_path(next_segment, delimiter);
+		else if (*path_segment == '.' && *(path_segment+1) == '.' && path_segment + 2 == path_segment_end)
+			return context.parent().first_element_by_path(next_segment, delimiter);
+		else
+		{
+			for (xml_node_struct* j = context._root->first_child; j; j = j->next_sibling)
+			{
+				if (j->name && impl::strequalrange(j->name, path_segment, static_cast<size_t>(path_segment_end - path_segment)))
+				{
+					xml_node subsearch = xml_node(j).first_element_by_path(next_segment, delimiter);
+
+					if (subsearch) return subsearch;
+				}
+			}
+
+			return xml_node();
+		}
+	}
+
+	PUGI__FN bool xml_node::traverse(xml_tree_walker& walker)
+	{
+		walker._depth = -1;
+
+		xml_node arg_begin(_root);
+		if (!walker.begin(arg_begin)) return false;
+
+		xml_node_struct* cur = _root ? _root->first_child + 0 : 0;
+
+		if (cur)
+		{
+			++walker._depth;
+
+			do
+			{
+				xml_node arg_for_each(cur);
+				if (!walker.for_each(arg_for_each))
+					return false;
+
+				if (cur->first_child)
+				{
+					++walker._depth;
+					cur = cur->first_child;
+				}
+				else if (cur->next_sibling)
+					cur = cur->next_sibling;
+				else
+				{
+					while (!cur->next_sibling && cur != _root && cur->parent)
+					{
+						--walker._depth;
+						cur = cur->parent;
+					}
+
+					if (cur != _root)
+						cur = cur->next_sibling;
+				}
+			}
+			while (cur && cur != _root);
+		}
+
+		assert(walker._depth == -1);
+
+		xml_node arg_end(_root);
+		return walker.end(arg_end);
+	}
+
+	PUGI__FN size_t xml_node::hash_value() const
+	{
+		return static_cast<size_t>(reinterpret_cast<uintptr_t>(_root) / sizeof(xml_node_struct));
+	}
+
+	PUGI__FN xml_node_struct* xml_node::internal_object() const
+	{
+		return _root;
+	}
+
+	PUGI__FN void xml_node::print(xml_writer& writer, const char_t* indent, unsigned int flags, xml_encoding encoding, unsigned int depth) const
+	{
+		if (!_root) return;
+
+		impl::xml_buffered_writer buffered_writer(writer, encoding);
+
+		impl::node_output(buffered_writer, _root, indent, flags, depth);
+
+		buffered_writer.flush();
+	}
+
+#ifndef PUGIXML_NO_STL
+	PUGI__FN void xml_node::print(std::basic_ostream<char, std::char_traits<char> >& stream, const char_t* indent, unsigned int flags, xml_encoding encoding, unsigned int depth) const
+	{
+		xml_writer_stream writer(stream);
+
+		print(writer, indent, flags, encoding, depth);
+	}
+
+	PUGI__FN void xml_node::print(std::basic_ostream<wchar_t, std::char_traits<wchar_t> >& stream, const char_t* indent, unsigned int flags, unsigned int depth) const
+	{
+		xml_writer_stream writer(stream);
+
+		print(writer, indent, flags, encoding_wchar, depth);
+	}
+#endif
+
+	PUGI__FN ptrdiff_t xml_node::offset_debug() const
+	{
+		if (!_root) return -1;
+
+		impl::xml_document_struct& doc = impl::get_document(_root);
+
+		// we can determine the offset reliably only if there is exactly once parse buffer
+		if (!doc.buffer || doc.extra_buffers) return -1;
+
+		switch (type())
+		{
+		case node_document:
+			return 0;
+
+		case node_element:
+		case node_declaration:
+		case node_pi:
+			return _root->name && (_root->header & impl::xml_memory_page_name_allocated_or_shared_mask) == 0 ? _root->name - doc.buffer : -1;
+
+		case node_pcdata:
+		case node_cdata:
+		case node_comment:
+		case node_doctype:
+			return _root->value && (_root->header & impl::xml_memory_page_value_allocated_or_shared_mask) == 0 ? _root->value - doc.buffer : -1;
+
+		default:
+			assert(false && "Invalid node type"); // unreachable
+			return -1;
+		}
+	}
+
+#ifdef __BORLANDC__
+	PUGI__FN bool operator&&(const xml_node& lhs, bool rhs)
+	{
+		return (bool)lhs && rhs;
+	}
+
+	PUGI__FN bool operator||(const xml_node& lhs, bool rhs)
+	{
+		return (bool)lhs || rhs;
+	}
+#endif
+
+	PUGI__FN xml_text::xml_text(xml_node_struct* root): _root(root)
+	{
+	}
+
+	PUGI__FN xml_node_struct* xml_text::_data() const
+	{
+		if (!_root || impl::is_text_node(_root)) return _root;
+
+		// element nodes can have value if parse_embed_pcdata was used
+		if (PUGI__NODETYPE(_root) == node_element && _root->value)
+			return _root;
+
+		for (xml_node_struct* node = _root->first_child; node; node = node->next_sibling)
+			if (impl::is_text_node(node))
+				return node;
+
+		return 0;
+	}
+
+	PUGI__FN xml_node_struct* xml_text::_data_new()
+	{
+		xml_node_struct* d = _data();
+		if (d) return d;
+
+		return xml_node(_root).append_child(node_pcdata).internal_object();
+	}
+
+	PUGI__FN xml_text::xml_text(): _root(0)
+	{
+	}
+
+	PUGI__FN static void unspecified_bool_xml_text(xml_text***)
+	{
+	}
+
+	PUGI__FN xml_text::operator xml_text::unspecified_bool_type() const
+	{
+		return _data() ? unspecified_bool_xml_text : 0;
+	}
+
+	PUGI__FN bool xml_text::operator!() const
+	{
+		return !_data();
+	}
+
+	PUGI__FN bool xml_text::empty() const
+	{
+		return _data() == 0;
+	}
+
+	PUGI__FN const char_t* xml_text::get() const
+	{
+		xml_node_struct* d = _data();
+
+		return (d && d->value) ? d->value + 0 : PUGIXML_TEXT("");
+	}
+
+	PUGI__FN const char_t* xml_text::as_string(const char_t* def) const
+	{
+		xml_node_struct* d = _data();
+
+		return (d && d->value) ? d->value + 0 : def;
+	}
+
+	PUGI__FN int xml_text::as_int(int def) const
+	{
+		xml_node_struct* d = _data();
+
+		return (d && d->value) ? impl::get_value_int(d->value) : def;
+	}
+
+	PUGI__FN unsigned int xml_text::as_uint(unsigned int def) const
+	{
+		xml_node_struct* d = _data();
+
+		return (d && d->value) ? impl::get_value_uint(d->value) : def;
+	}
+
+	PUGI__FN double xml_text::as_double(double def) const
+	{
+		xml_node_struct* d = _data();
+
+		return (d && d->value) ? impl::get_value_double(d->value) : def;
+	}
+
+	PUGI__FN float xml_text::as_float(float def) const
+	{
+		xml_node_struct* d = _data();
+
+		return (d && d->value) ? impl::get_value_float(d->value) : def;
+	}
+
+	PUGI__FN bool xml_text::as_bool(bool def) const
+	{
+		xml_node_struct* d = _data();
+
+		return (d && d->value) ? impl::get_value_bool(d->value) : def;
+	}
+
+#ifdef PUGIXML_HAS_LONG_LONG
+	PUGI__FN long long xml_text::as_llong(long long def) const
+	{
+		xml_node_struct* d = _data();
+
+		return (d && d->value) ? impl::get_value_llong(d->value) : def;
+	}
+
+	PUGI__FN unsigned long long xml_text::as_ullong(unsigned long long def) const
+	{
+		xml_node_struct* d = _data();
+
+		return (d && d->value) ? impl::get_value_ullong(d->value) : def;
+	}
+#endif
+
+	PUGI__FN bool xml_text::set(const char_t* rhs)
+	{
+		xml_node_struct* dn = _data_new();
+
+		return dn ? impl::strcpy_insitu(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs, impl::strlength(rhs)) : false;
+	}
+
+	PUGI__FN bool xml_text::set(int rhs)
+	{
+		xml_node_struct* dn = _data_new();
+
+		return dn ? impl::set_value_integer<unsigned int>(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs, rhs < 0) : false;
+	}
+
+	PUGI__FN bool xml_text::set(unsigned int rhs)
+	{
+		xml_node_struct* dn = _data_new();
+
+		return dn ? impl::set_value_integer<unsigned int>(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs, false) : false;
+	}
+
+	PUGI__FN bool xml_text::set(long rhs)
+	{
+		xml_node_struct* dn = _data_new();
+
+		return dn ? impl::set_value_integer<unsigned long>(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs, rhs < 0) : false;
+	}
+
+	PUGI__FN bool xml_text::set(unsigned long rhs)
+	{
+		xml_node_struct* dn = _data_new();
+
+		return dn ? impl::set_value_integer<unsigned long>(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs, false) : false;
+	}
+
+	PUGI__FN bool xml_text::set(float rhs)
+	{
+		xml_node_struct* dn = _data_new();
+
+		return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs, default_float_precision) : false;
+	}
+
+	PUGI__FN bool xml_text::set(float rhs, int precision)
+	{
+		xml_node_struct* dn = _data_new();
+
+		return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs, precision) : false;
+	}
+
+	PUGI__FN bool xml_text::set(double rhs)
+	{
+		xml_node_struct* dn = _data_new();
+
+		return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs, default_double_precision) : false;
+	}
+
+	PUGI__FN bool xml_text::set(double rhs, int precision)
+	{
+		xml_node_struct* dn = _data_new();
+
+		return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs, precision) : false;
+	}
+
+	PUGI__FN bool xml_text::set(bool rhs)
+	{
+		xml_node_struct* dn = _data_new();
+
+		return dn ? impl::set_value_bool(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false;
+	}
+
+#ifdef PUGIXML_HAS_LONG_LONG
+	PUGI__FN bool xml_text::set(long long rhs)
+	{
+		xml_node_struct* dn = _data_new();
+
+		return dn ? impl::set_value_integer<unsigned long long>(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs, rhs < 0) : false;
+	}
+
+	PUGI__FN bool xml_text::set(unsigned long long rhs)
+	{
+		xml_node_struct* dn = _data_new();
+
+		return dn ? impl::set_value_integer<unsigned long long>(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs, false) : false;
+	}
+#endif
+
+	PUGI__FN xml_text& xml_text::operator=(const char_t* rhs)
+	{
+		set(rhs);
+		return *this;
+	}
+
+	PUGI__FN xml_text& xml_text::operator=(int rhs)
+	{
+		set(rhs);
+		return *this;
+	}
+
+	PUGI__FN xml_text& xml_text::operator=(unsigned int rhs)
+	{
+		set(rhs);
+		return *this;
+	}
+
+	PUGI__FN xml_text& xml_text::operator=(long rhs)
+	{
+		set(rhs);
+		return *this;
+	}
+
+	PUGI__FN xml_text& xml_text::operator=(unsigned long rhs)
+	{
+		set(rhs);
+		return *this;
+	}
+
+	PUGI__FN xml_text& xml_text::operator=(double rhs)
+	{
+		set(rhs);
+		return *this;
+	}
+
+	PUGI__FN xml_text& xml_text::operator=(float rhs)
+	{
+		set(rhs);
+		return *this;
+	}
+
+	PUGI__FN xml_text& xml_text::operator=(bool rhs)
+	{
+		set(rhs);
+		return *this;
+	}
+
+#ifdef PUGIXML_HAS_LONG_LONG
+	PUGI__FN xml_text& xml_text::operator=(long long rhs)
+	{
+		set(rhs);
+		return *this;
+	}
+
+	PUGI__FN xml_text& xml_text::operator=(unsigned long long rhs)
+	{
+		set(rhs);
+		return *this;
+	}
+#endif
+
+	PUGI__FN xml_node xml_text::data() const
+	{
+		return xml_node(_data());
+	}
+
+#ifdef __BORLANDC__
+	PUGI__FN bool operator&&(const xml_text& lhs, bool rhs)
+	{
+		return (bool)lhs && rhs;
+	}
+
+	PUGI__FN bool operator||(const xml_text& lhs, bool rhs)
+	{
+		return (bool)lhs || rhs;
+	}
+#endif
+
+	PUGI__FN xml_node_iterator::xml_node_iterator()
+	{
+	}
+
+	PUGI__FN xml_node_iterator::xml_node_iterator(const xml_node& node): _wrap(node), _parent(node.parent())
+	{
+	}
+
+	PUGI__FN xml_node_iterator::xml_node_iterator(xml_node_struct* ref, xml_node_struct* parent): _wrap(ref), _parent(parent)
+	{
+	}
+
+	PUGI__FN bool xml_node_iterator::operator==(const xml_node_iterator& rhs) const
+	{
+		return _wrap._root == rhs._wrap._root && _parent._root == rhs._parent._root;
+	}
+
+	PUGI__FN bool xml_node_iterator::operator!=(const xml_node_iterator& rhs) const
+	{
+		return _wrap._root != rhs._wrap._root || _parent._root != rhs._parent._root;
+	}
+
+	PUGI__FN xml_node& xml_node_iterator::operator*() const
+	{
+		assert(_wrap._root);
+		return _wrap;
+	}
+
+	PUGI__FN xml_node* xml_node_iterator::operator->() const
+	{
+		assert(_wrap._root);
+		return const_cast<xml_node*>(&_wrap); // BCC5 workaround
+	}
+
+	PUGI__FN const xml_node_iterator& xml_node_iterator::operator++()
+	{
+		assert(_wrap._root);
+		_wrap._root = _wrap._root->next_sibling;
+		return *this;
+	}
+
+	PUGI__FN xml_node_iterator xml_node_iterator::operator++(int)
+	{
+		xml_node_iterator temp = *this;
+		++*this;
+		return temp;
+	}
+
+	PUGI__FN const xml_node_iterator& xml_node_iterator::operator--()
+	{
+		_wrap = _wrap._root ? _wrap.previous_sibling() : _parent.last_child();
+		return *this;
+	}
+
+	PUGI__FN xml_node_iterator xml_node_iterator::operator--(int)
+	{
+		xml_node_iterator temp = *this;
+		--*this;
+		return temp;
+	}
+
+	PUGI__FN xml_attribute_iterator::xml_attribute_iterator()
+	{
+	}
+
+	PUGI__FN xml_attribute_iterator::xml_attribute_iterator(const xml_attribute& attr, const xml_node& parent): _wrap(attr), _parent(parent)
+	{
+	}
+
+	PUGI__FN xml_attribute_iterator::xml_attribute_iterator(xml_attribute_struct* ref, xml_node_struct* parent): _wrap(ref), _parent(parent)
+	{
+	}
+
+	PUGI__FN bool xml_attribute_iterator::operator==(const xml_attribute_iterator& rhs) const
+	{
+		return _wrap._attr == rhs._wrap._attr && _parent._root == rhs._parent._root;
+	}
+
+	PUGI__FN bool xml_attribute_iterator::operator!=(const xml_attribute_iterator& rhs) const
+	{
+		return _wrap._attr != rhs._wrap._attr || _parent._root != rhs._parent._root;
+	}
+
+	PUGI__FN xml_attribute& xml_attribute_iterator::operator*() const
+	{
+		assert(_wrap._attr);
+		return _wrap;
+	}
+
+	PUGI__FN xml_attribute* xml_attribute_iterator::operator->() const
+	{
+		assert(_wrap._attr);
+		return const_cast<xml_attribute*>(&_wrap); // BCC5 workaround
+	}
+
+	PUGI__FN const xml_attribute_iterator& xml_attribute_iterator::operator++()
+	{
+		assert(_wrap._attr);
+		_wrap._attr = _wrap._attr->next_attribute;
+		return *this;
+	}
+
+	PUGI__FN xml_attribute_iterator xml_attribute_iterator::operator++(int)
+	{
+		xml_attribute_iterator temp = *this;
+		++*this;
+		return temp;
+	}
+
+	PUGI__FN const xml_attribute_iterator& xml_attribute_iterator::operator--()
+	{
+		_wrap = _wrap._attr ? _wrap.previous_attribute() : _parent.last_attribute();
+		return *this;
+	}
+
+	PUGI__FN xml_attribute_iterator xml_attribute_iterator::operator--(int)
+	{
+		xml_attribute_iterator temp = *this;
+		--*this;
+		return temp;
+	}
+
+	PUGI__FN xml_named_node_iterator::xml_named_node_iterator(): _name(0)
+	{
+	}
+
+	PUGI__FN xml_named_node_iterator::xml_named_node_iterator(const xml_node& node, const char_t* name): _wrap(node), _parent(node.parent()), _name(name)
+	{
+	}
+
+	PUGI__FN xml_named_node_iterator::xml_named_node_iterator(xml_node_struct* ref, xml_node_struct* parent, const char_t* name): _wrap(ref), _parent(parent), _name(name)
+	{
+	}
+
+	PUGI__FN bool xml_named_node_iterator::operator==(const xml_named_node_iterator& rhs) const
+	{
+		return _wrap._root == rhs._wrap._root && _parent._root == rhs._parent._root;
+	}
+
+	PUGI__FN bool xml_named_node_iterator::operator!=(const xml_named_node_iterator& rhs) const
+	{
+		return _wrap._root != rhs._wrap._root || _parent._root != rhs._parent._root;
+	}
+
+	PUGI__FN xml_node& xml_named_node_iterator::operator*() const
+	{
+		assert(_wrap._root);
+		return _wrap;
+	}
+
+	PUGI__FN xml_node* xml_named_node_iterator::operator->() const
+	{
+		assert(_wrap._root);
+		return const_cast<xml_node*>(&_wrap); // BCC5 workaround
+	}
+
+	PUGI__FN const xml_named_node_iterator& xml_named_node_iterator::operator++()
+	{
+		assert(_wrap._root);
+		_wrap = _wrap.next_sibling(_name);
+		return *this;
+	}
+
+	PUGI__FN xml_named_node_iterator xml_named_node_iterator::operator++(int)
+	{
+		xml_named_node_iterator temp = *this;
+		++*this;
+		return temp;
+	}
+
+	PUGI__FN const xml_named_node_iterator& xml_named_node_iterator::operator--()
+	{
+		if (_wrap._root)
+			_wrap = _wrap.previous_sibling(_name);
+		else
+		{
+			_wrap = _parent.last_child();
+
+			if (!impl::strequal(_wrap.name(), _name))
+				_wrap = _wrap.previous_sibling(_name);
+		}
+
+		return *this;
+	}
+
+	PUGI__FN xml_named_node_iterator xml_named_node_iterator::operator--(int)
+	{
+		xml_named_node_iterator temp = *this;
+		--*this;
+		return temp;
+	}
+
+	PUGI__FN xml_parse_result::xml_parse_result(): status(status_internal_error), offset(0), encoding(encoding_auto)
+	{
+	}
+
+	PUGI__FN xml_parse_result::operator bool() const
+	{
+		return status == status_ok;
+	}
+
+	PUGI__FN const char* xml_parse_result::description() const
+	{
+		switch (status)
+		{
+		case status_ok: return "No error";
+
+		case status_file_not_found: return "File was not found";
+		case status_io_error: return "Error reading from file/stream";
+		case status_out_of_memory: return "Could not allocate memory";
+		case status_internal_error: return "Internal error occurred";
+
+		case status_unrecognized_tag: return "Could not determine tag type";
+
+		case status_bad_pi: return "Error parsing document declaration/processing instruction";
+		case status_bad_comment: return "Error parsing comment";
+		case status_bad_cdata: return "Error parsing CDATA section";
+		case status_bad_doctype: return "Error parsing document type declaration";
+		case status_bad_pcdata: return "Error parsing PCDATA section";
+		case status_bad_start_element: return "Error parsing start element tag";
+		case status_bad_attribute: return "Error parsing element attribute";
+		case status_bad_end_element: return "Error parsing end element tag";
+		case status_end_element_mismatch: return "Start-end tags mismatch";
+
+		case status_append_invalid_root: return "Unable to append nodes: root is not an element or document";
+
+		case status_no_document_element: return "No document element found";
+
+		default: return "Unknown error";
+		}
+	}
+
+	PUGI__FN xml_document::xml_document(): _buffer(0)
+	{
+		_create();
+	}
+
+	PUGI__FN xml_document::~xml_document()
+	{
+		_destroy();
+	}
+
+#ifdef PUGIXML_HAS_MOVE
+	PUGI__FN xml_document::xml_document(xml_document&& rhs) PUGIXML_NOEXCEPT_IF_NOT_COMPACT: _buffer(0)
+	{
+		_create();
+		_move(rhs);
+	}
+
+	PUGI__FN xml_document& xml_document::operator=(xml_document&& rhs) PUGIXML_NOEXCEPT_IF_NOT_COMPACT
+	{
+		if (this == &rhs) return *this;
+
+		_destroy();
+		_create();
+		_move(rhs);
+
+		return *this;
+	}
+#endif
+
+	PUGI__FN void xml_document::reset()
+	{
+		_destroy();
+		_create();
+	}
+
+	PUGI__FN void xml_document::reset(const xml_document& proto)
+	{
+		reset();
+
+		impl::node_copy_tree(_root, proto._root);
+	}
+
+	PUGI__FN void xml_document::_create()
+	{
+		assert(!_root);
+
+	#ifdef PUGIXML_COMPACT
+		// space for page marker for the first page (uint32_t), rounded up to pointer size; assumes pointers are at least 32-bit
+		const size_t page_offset = sizeof(void*);
+	#else
+		const size_t page_offset = 0;
+	#endif
+
+		// initialize sentinel page
+		PUGI__STATIC_ASSERT(sizeof(impl::xml_memory_page) + sizeof(impl::xml_document_struct) + page_offset <= sizeof(_memory));
+
+		// prepare page structure
+		impl::xml_memory_page* page = impl::xml_memory_page::construct(_memory);
+		assert(page);
+
+		page->busy_size = impl::xml_memory_page_size;
+
+		// setup first page marker
+	#ifdef PUGIXML_COMPACT
+		// round-trip through void* to avoid 'cast increases required alignment of target type' warning
+		page->compact_page_marker = reinterpret_cast<uint32_t*>(static_cast<void*>(reinterpret_cast<char*>(page) + sizeof(impl::xml_memory_page)));
+		*page->compact_page_marker = sizeof(impl::xml_memory_page);
+	#endif
+
+		// allocate new root
+		_root = new (reinterpret_cast<char*>(page) + sizeof(impl::xml_memory_page) + page_offset) impl::xml_document_struct(page);
+		_root->prev_sibling_c = _root;
+
+		// setup sentinel page
+		page->allocator = static_cast<impl::xml_document_struct*>(_root);
+
+		// setup hash table pointer in allocator
+	#ifdef PUGIXML_COMPACT
+		page->allocator->_hash = &static_cast<impl::xml_document_struct*>(_root)->hash;
+	#endif
+
+		// verify the document allocation
+		assert(reinterpret_cast<char*>(_root) + sizeof(impl::xml_document_struct) <= _memory + sizeof(_memory));
+	}
+
+	PUGI__FN void xml_document::_destroy()
+	{
+		assert(_root);
+
+		// destroy static storage
+		if (_buffer)
+		{
+			impl::xml_memory::deallocate(_buffer);
+			_buffer = 0;
+		}
+
+		// destroy extra buffers (note: no need to destroy linked list nodes, they're allocated using document allocator)
+		for (impl::xml_extra_buffer* extra = static_cast<impl::xml_document_struct*>(_root)->extra_buffers; extra; extra = extra->next)
+		{
+			if (extra->buffer) impl::xml_memory::deallocate(extra->buffer);
+		}
+
+		// destroy dynamic storage, leave sentinel page (it's in static memory)
+		impl::xml_memory_page* root_page = PUGI__GETPAGE(_root);
+		assert(root_page && !root_page->prev);
+		assert(reinterpret_cast<char*>(root_page) >= _memory && reinterpret_cast<char*>(root_page) < _memory + sizeof(_memory));
+
+		for (impl::xml_memory_page* page = root_page->next; page; )
+		{
+			impl::xml_memory_page* next = page->next;
+
+			impl::xml_allocator::deallocate_page(page);
+
+			page = next;
+		}
+
+	#ifdef PUGIXML_COMPACT
+		// destroy hash table
+		static_cast<impl::xml_document_struct*>(_root)->hash.clear();
+	#endif
+
+		_root = 0;
+	}
+
+#ifdef PUGIXML_HAS_MOVE
+	PUGI__FN void xml_document::_move(xml_document& rhs) PUGIXML_NOEXCEPT_IF_NOT_COMPACT
+	{
+		impl::xml_document_struct* doc = static_cast<impl::xml_document_struct*>(_root);
+		impl::xml_document_struct* other = static_cast<impl::xml_document_struct*>(rhs._root);
+
+		// save first child pointer for later; this needs hash access
+		xml_node_struct* other_first_child = other->first_child;
+
+	#ifdef PUGIXML_COMPACT
+		// reserve space for the hash table up front; this is the only operation that can fail
+		// if it does, we have no choice but to throw (if we have exceptions)
+		if (other_first_child)
+		{
+			size_t other_children = 0;
+			for (xml_node_struct* node = other_first_child; node; node = node->next_sibling)
+				other_children++;
+
+			// in compact mode, each pointer assignment could result in a hash table request
+			// during move, we have to relocate document first_child and parents of all children
+			// normally there's just one child and its parent has a pointerless encoding but
+			// we assume the worst here
+			if (!other->_hash->reserve(other_children + 1))
+			{
+			#ifdef PUGIXML_NO_EXCEPTIONS
+				return;
+			#else
+				throw std::bad_alloc();
+			#endif
+			}
+		}
+	#endif
+
+		// move allocation state
+		doc->_root = other->_root;
+		doc->_busy_size = other->_busy_size;
+
+		// move buffer state
+		doc->buffer = other->buffer;
+		doc->extra_buffers = other->extra_buffers;
+		_buffer = rhs._buffer;
+
+	#ifdef PUGIXML_COMPACT
+		// move compact hash; note that the hash table can have pointers to other but they will be "inactive", similarly to nodes removed with remove_child
+		doc->hash = other->hash;
+		doc->_hash = &doc->hash;
+
+		// make sure we don't access other hash up until the end when we reinitialize other document
+		other->_hash = 0;
+	#endif
+
+		// move page structure
+		impl::xml_memory_page* doc_page = PUGI__GETPAGE(doc);
+		assert(doc_page && !doc_page->prev && !doc_page->next);
+
+		impl::xml_memory_page* other_page = PUGI__GETPAGE(other);
+		assert(other_page && !other_page->prev);
+
+		// relink pages since root page is embedded into xml_document
+		if (impl::xml_memory_page* page = other_page->next)
+		{
+			assert(page->prev == other_page);
+
+			page->prev = doc_page;
+
+			doc_page->next = page;
+			other_page->next = 0;
+		}
+
+		// make sure pages point to the correct document state
+		for (impl::xml_memory_page* page = doc_page->next; page; page = page->next)
+		{
+			assert(page->allocator == other);
+
+			page->allocator = doc;
+
+		#ifdef PUGIXML_COMPACT
+			// this automatically migrates most children between documents and prevents ->parent assignment from allocating
+			if (page->compact_shared_parent == other)
+				page->compact_shared_parent = doc;
+		#endif
+		}
+
+		// move tree structure
+		assert(!doc->first_child);
+
+		doc->first_child = other_first_child;
+
+		for (xml_node_struct* node = other_first_child; node; node = node->next_sibling)
+		{
+		#ifdef PUGIXML_COMPACT
+			// most children will have migrated when we reassigned compact_shared_parent
+			assert(node->parent == other || node->parent == doc);
+
+			node->parent = doc;
+		#else
+			assert(node->parent == other);
+			node->parent = doc;
+		#endif
+		}
+
+		// reset other document
+		new (other) impl::xml_document_struct(PUGI__GETPAGE(other));
+		rhs._buffer = 0;
+	}
+#endif
+
+#ifndef PUGIXML_NO_STL
+	PUGI__FN xml_parse_result xml_document::load(std::basic_istream<char, std::char_traits<char> >& stream, unsigned int options, xml_encoding encoding)
+	{
+		reset();
+
+		return impl::load_stream_impl(static_cast<impl::xml_document_struct*>(_root), stream, options, encoding, &_buffer);
+	}
+
+	PUGI__FN xml_parse_result xml_document::load(std::basic_istream<wchar_t, std::char_traits<wchar_t> >& stream, unsigned int options)
+	{
+		reset();
+
+		return impl::load_stream_impl(static_cast<impl::xml_document_struct*>(_root), stream, options, encoding_wchar, &_buffer);
+	}
+#endif
+
+	PUGI__FN xml_parse_result xml_document::load_string(const char_t* contents, unsigned int options)
+	{
+		// Force native encoding (skip autodetection)
+	#ifdef PUGIXML_WCHAR_MODE
+		xml_encoding encoding = encoding_wchar;
+	#else
+		xml_encoding encoding = encoding_utf8;
+	#endif
+
+		return load_buffer(contents, impl::strlength(contents) * sizeof(char_t), options, encoding);
+	}
+
+	PUGI__FN xml_parse_result xml_document::load(const char_t* contents, unsigned int options)
+	{
+		return load_string(contents, options);
+	}
+
+	PUGI__FN xml_parse_result xml_document::load_file(const char* path_, unsigned int options, xml_encoding encoding)
+	{
+		reset();
+
+		using impl::auto_deleter; // MSVC7 workaround
+		auto_deleter<FILE> file(impl::open_file(path_, "rb"), impl::close_file);
+
+		return impl::load_file_impl(static_cast<impl::xml_document_struct*>(_root), file.data, options, encoding, &_buffer);
+	}
+
+	PUGI__FN xml_parse_result xml_document::load_file(const wchar_t* path_, unsigned int options, xml_encoding encoding)
+	{
+		reset();
+
+		using impl::auto_deleter; // MSVC7 workaround
+		auto_deleter<FILE> file(impl::open_file_wide(path_, L"rb"), impl::close_file);
+
+		return impl::load_file_impl(static_cast<impl::xml_document_struct*>(_root), file.data, options, encoding, &_buffer);
+	}
+
+	PUGI__FN xml_parse_result xml_document::load_buffer(const void* contents, size_t size, unsigned int options, xml_encoding encoding)
+	{
+		reset();
+
+		return impl::load_buffer_impl(static_cast<impl::xml_document_struct*>(_root), _root, const_cast<void*>(contents), size, options, encoding, false, false, &_buffer);
+	}
+
+	PUGI__FN xml_parse_result xml_document::load_buffer_inplace(void* contents, size_t size, unsigned int options, xml_encoding encoding)
+	{
+		reset();
+
+		return impl::load_buffer_impl(static_cast<impl::xml_document_struct*>(_root), _root, contents, size, options, encoding, true, false, &_buffer);
+	}
+
+	PUGI__FN xml_parse_result xml_document::load_buffer_inplace_own(void* contents, size_t size, unsigned int options, xml_encoding encoding)
+	{
+		reset();
+
+		return impl::load_buffer_impl(static_cast<impl::xml_document_struct*>(_root), _root, contents, size, options, encoding, true, true, &_buffer);
+	}
+
+	PUGI__FN void xml_document::save(xml_writer& writer, const char_t* indent, unsigned int flags, xml_encoding encoding) const
+	{
+		impl::xml_buffered_writer buffered_writer(writer, encoding);
+
+		if ((flags & format_write_bom) && encoding != encoding_latin1)
+		{
+			// BOM always represents the codepoint U+FEFF, so just write it in native encoding
+		#ifdef PUGIXML_WCHAR_MODE
+			unsigned int bom = 0xfeff;
+			buffered_writer.write(static_cast<wchar_t>(bom));
+		#else
+			buffered_writer.write('\xef', '\xbb', '\xbf');
+		#endif
+		}
+
+		if (!(flags & format_no_declaration) && !impl::has_declaration(_root))
+		{
+			buffered_writer.write_string(PUGIXML_TEXT("<?xml version=\"1.0\""));
+			if (encoding == encoding_latin1) buffered_writer.write_string(PUGIXML_TEXT(" encoding=\"ISO-8859-1\""));
+			buffered_writer.write('?', '>');
+			if (!(flags & format_raw)) buffered_writer.write('\n');
+		}
+
+		impl::node_output(buffered_writer, _root, indent, flags, 0);
+
+		buffered_writer.flush();
+	}
+
+#ifndef PUGIXML_NO_STL
+	PUGI__FN void xml_document::save(std::basic_ostream<char, std::char_traits<char> >& stream, const char_t* indent, unsigned int flags, xml_encoding encoding) const
+	{
+		xml_writer_stream writer(stream);
+
+		save(writer, indent, flags, encoding);
+	}
+
+	PUGI__FN void xml_document::save(std::basic_ostream<wchar_t, std::char_traits<wchar_t> >& stream, const char_t* indent, unsigned int flags) const
+	{
+		xml_writer_stream writer(stream);
+
+		save(writer, indent, flags, encoding_wchar);
+	}
+#endif
+
+	PUGI__FN bool xml_document::save_file(const char* path_, const char_t* indent, unsigned int flags, xml_encoding encoding) const
+	{
+		using impl::auto_deleter; // MSVC7 workaround
+		auto_deleter<FILE> file(impl::open_file(path_, (flags & format_save_file_text) ? "w" : "wb"), impl::close_file);
+
+		return impl::save_file_impl(*this, file.data, indent, flags, encoding);
+	}
+
+	PUGI__FN bool xml_document::save_file(const wchar_t* path_, const char_t* indent, unsigned int flags, xml_encoding encoding) const
+	{
+		using impl::auto_deleter; // MSVC7 workaround
+		auto_deleter<FILE> file(impl::open_file_wide(path_, (flags & format_save_file_text) ? L"w" : L"wb"), impl::close_file);
+
+		return impl::save_file_impl(*this, file.data, indent, flags, encoding);
+	}
+
+	PUGI__FN xml_node xml_document::document_element() const
+	{
+		assert(_root);
+
+		for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
+			if (PUGI__NODETYPE(i) == node_element)
+				return xml_node(i);
+
+		return xml_node();
+	}
+
+#ifndef PUGIXML_NO_STL
+	PUGI__FN std::string PUGIXML_FUNCTION as_utf8(const wchar_t* str)
+	{
+		assert(str);
+
+		return impl::as_utf8_impl(str, impl::strlength_wide(str));
+	}
+
+	PUGI__FN std::string PUGIXML_FUNCTION as_utf8(const std::basic_string<wchar_t>& str)
+	{
+		return impl::as_utf8_impl(str.c_str(), str.size());
+	}
+
+	PUGI__FN std::basic_string<wchar_t> PUGIXML_FUNCTION as_wide(const char* str)
+	{
+		assert(str);
+
+		return impl::as_wide_impl(str, strlen(str));
+	}
+
+	PUGI__FN std::basic_string<wchar_t> PUGIXML_FUNCTION as_wide(const std::string& str)
+	{
+		return impl::as_wide_impl(str.c_str(), str.size());
+	}
+#endif
+
+	PUGI__FN void PUGIXML_FUNCTION set_memory_management_functions(allocation_function allocate, deallocation_function deallocate)
+	{
+		impl::xml_memory::allocate = allocate;
+		impl::xml_memory::deallocate = deallocate;
+	}
+
+	PUGI__FN allocation_function PUGIXML_FUNCTION get_memory_allocation_function()
+	{
+		return impl::xml_memory::allocate;
+	}
+
+	PUGI__FN deallocation_function PUGIXML_FUNCTION get_memory_deallocation_function()
+	{
+		return impl::xml_memory::deallocate;
+	}
+}
+
+#if !defined(PUGIXML_NO_STL) && (defined(_MSC_VER) || defined(__ICC))
+namespace std
+{
+	// Workarounds for (non-standard) iterator category detection for older versions (MSVC7/IC8 and earlier)
+	PUGI__FN std::bidirectional_iterator_tag _Iter_cat(const pugi::xml_node_iterator&)
+	{
+		return std::bidirectional_iterator_tag();
+	}
+
+	PUGI__FN std::bidirectional_iterator_tag _Iter_cat(const pugi::xml_attribute_iterator&)
+	{
+		return std::bidirectional_iterator_tag();
+	}
+
+	PUGI__FN std::bidirectional_iterator_tag _Iter_cat(const pugi::xml_named_node_iterator&)
+	{
+		return std::bidirectional_iterator_tag();
+	}
+}
+#endif
+
+#if !defined(PUGIXML_NO_STL) && defined(__SUNPRO_CC)
+namespace std
+{
+	// Workarounds for (non-standard) iterator category detection
+	PUGI__FN std::bidirectional_iterator_tag __iterator_category(const pugi::xml_node_iterator&)
+	{
+		return std::bidirectional_iterator_tag();
+	}
+
+	PUGI__FN std::bidirectional_iterator_tag __iterator_category(const pugi::xml_attribute_iterator&)
+	{
+		return std::bidirectional_iterator_tag();
+	}
+
+	PUGI__FN std::bidirectional_iterator_tag __iterator_category(const pugi::xml_named_node_iterator&)
+	{
+		return std::bidirectional_iterator_tag();
+	}
+}
+#endif
+
+#ifndef PUGIXML_NO_XPATH
+// STL replacements
+PUGI__NS_BEGIN
+	struct equal_to
+	{
+		template <typename T> bool operator()(const T& lhs, const T& rhs) const
+		{
+			return lhs == rhs;
+		}
+	};
+
+	struct not_equal_to
+	{
+		template <typename T> bool operator()(const T& lhs, const T& rhs) const
+		{
+			return lhs != rhs;
+		}
+	};
+
+	struct less
+	{
+		template <typename T> bool operator()(const T& lhs, const T& rhs) const
+		{
+			return lhs < rhs;
+		}
+	};
+
+	struct less_equal
+	{
+		template <typename T> bool operator()(const T& lhs, const T& rhs) const
+		{
+			return lhs <= rhs;
+		}
+	};
+
+	template <typename T> inline void swap(T& lhs, T& rhs)
+	{
+		T temp = lhs;
+		lhs = rhs;
+		rhs = temp;
+	}
+
+	template <typename I, typename Pred> PUGI__FN I min_element(I begin, I end, const Pred& pred)
+	{
+		I result = begin;
+
+		for (I it = begin + 1; it != end; ++it)
+			if (pred(*it, *result))
+				result = it;
+
+		return result;
+	}
+
+	template <typename I> PUGI__FN void reverse(I begin, I end)
+	{
+		while (end - begin > 1)
+			swap(*begin++, *--end);
+	}
+
+	template <typename I> PUGI__FN I unique(I begin, I end)
+	{
+		// fast skip head
+		while (end - begin > 1 && *begin != *(begin + 1))
+			begin++;
+
+		if (begin == end)
+			return begin;
+
+		// last written element
+		I write = begin++;
+
+		// merge unique elements
+		while (begin != end)
+		{
+			if (*begin != *write)
+				*++write = *begin++;
+			else
+				begin++;
+		}
+
+		// past-the-end (write points to live element)
+		return write + 1;
+	}
+
+	template <typename T, typename Pred> PUGI__FN void insertion_sort(T* begin, T* end, const Pred& pred)
+	{
+		if (begin == end)
+			return;
+
+		for (T* it = begin + 1; it != end; ++it)
+		{
+			T val = *it;
+			T* hole = it;
+
+			// move hole backwards
+			while (hole > begin && pred(val, *(hole - 1)))
+			{
+				*hole = *(hole - 1);
+				hole--;
+			}
+
+			// fill hole with element
+			*hole = val;
+		}
+	}
+
+	template <typename I, typename Pred> inline I median3(I first, I middle, I last, const Pred& pred)
+	{
+		if (pred(*middle, *first))
+			swap(middle, first);
+		if (pred(*last, *middle))
+			swap(last, middle);
+		if (pred(*middle, *first))
+			swap(middle, first);
+
+		return middle;
+	}
+
+	template <typename T, typename Pred> PUGI__FN void partition3(T* begin, T* end, T pivot, const Pred& pred, T** out_eqbeg, T** out_eqend)
+	{
+		// invariant: array is split into 4 groups: = < ? > (each variable denotes the boundary between the groups)
+		T* eq = begin;
+		T* lt = begin;
+		T* gt = end;
+
+		while (lt < gt)
+		{
+			if (pred(*lt, pivot))
+				lt++;
+			else if (*lt == pivot)
+				swap(*eq++, *lt++);
+			else
+				swap(*lt, *--gt);
+		}
+
+		// we now have just 4 groups: = < >; move equal elements to the middle
+		T* eqbeg = gt;
+
+		for (T* it = begin; it != eq; ++it)
+			swap(*it, *--eqbeg);
+
+		*out_eqbeg = eqbeg;
+		*out_eqend = gt;
+	}
+
+	template <typename I, typename Pred> PUGI__FN void sort(I begin, I end, const Pred& pred)
+	{
+		// sort large chunks
+		while (end - begin > 16)
+		{
+			// find median element
+			I middle = begin + (end - begin) / 2;
+			I median = median3(begin, middle, end - 1, pred);
+
+			// partition in three chunks (< = >)
+			I eqbeg, eqend;
+			partition3(begin, end, *median, pred, &eqbeg, &eqend);
+
+			// loop on larger half
+			if (eqbeg - begin > end - eqend)
+			{
+				sort(eqend, end, pred);
+				end = eqbeg;
+			}
+			else
+			{
+				sort(begin, eqbeg, pred);
+				begin = eqend;
+			}
+		}
+
+		// insertion sort small chunk
+		insertion_sort(begin, end, pred);
+	}
+
+	PUGI__FN bool hash_insert(const void** table, size_t size, const void* key)
+	{
+		assert(key);
+
+		unsigned int h = static_cast<unsigned int>(reinterpret_cast<uintptr_t>(key));
+
+		// MurmurHash3 32-bit finalizer
+		h ^= h >> 16;
+		h *= 0x85ebca6bu;
+		h ^= h >> 13;
+		h *= 0xc2b2ae35u;
+		h ^= h >> 16;
+
+		size_t hashmod = size - 1;
+		size_t bucket = h & hashmod;
+
+		for (size_t probe = 0; probe <= hashmod; ++probe)
+		{
+			if (table[bucket] == 0)
+			{
+				table[bucket] = key;
+				return true;
+			}
+
+			if (table[bucket] == key)
+				return false;
+
+			// hash collision, quadratic probing
+			bucket = (bucket + probe + 1) & hashmod;
+		}
+
+		assert(false && "Hash table is full"); // unreachable
+		return false;
+	}
+PUGI__NS_END
+
+// Allocator used for AST and evaluation stacks
+PUGI__NS_BEGIN
+	static const size_t xpath_memory_page_size =
+	#ifdef PUGIXML_MEMORY_XPATH_PAGE_SIZE
+		PUGIXML_MEMORY_XPATH_PAGE_SIZE
+	#else
+		4096
+	#endif
+		;
+
+	static const uintptr_t xpath_memory_block_alignment = sizeof(double) > sizeof(void*) ? sizeof(double) : sizeof(void*);
+
+	struct xpath_memory_block
+	{
+		xpath_memory_block* next;
+		size_t capacity;
+
+		union
+		{
+			char data[xpath_memory_page_size];
+			double alignment;
+		};
+	};
+
+	struct xpath_allocator
+	{
+		xpath_memory_block* _root;
+		size_t _root_size;
+		bool* _error;
+
+		xpath_allocator(xpath_memory_block* root, bool* error = 0): _root(root), _root_size(0), _error(error)
+		{
+		}
+
+		void* allocate(size_t size)
+		{
+			// round size up to block alignment boundary
+			size = (size + xpath_memory_block_alignment - 1) & ~(xpath_memory_block_alignment - 1);
+
+			if (_root_size + size <= _root->capacity)
+			{
+				void* buf = &_root->data[0] + _root_size;
+				_root_size += size;
+				return buf;
+			}
+			else
+			{
+				// make sure we have at least 1/4th of the page free after allocation to satisfy subsequent allocation requests
+				size_t block_capacity_base = sizeof(_root->data);
+				size_t block_capacity_req = size + block_capacity_base / 4;
+				size_t block_capacity = (block_capacity_base > block_capacity_req) ? block_capacity_base : block_capacity_req;
+
+				size_t block_size = block_capacity + offsetof(xpath_memory_block, data);
+
+				xpath_memory_block* block = static_cast<xpath_memory_block*>(xml_memory::allocate(block_size));
+				if (!block)
+				{
+					if (_error) *_error = true;
+					return 0;
+				}
+
+				block->next = _root;
+				block->capacity = block_capacity;
+
+				_root = block;
+				_root_size = size;
+
+				return block->data;
+			}
+		}
+
+		void* reallocate(void* ptr, size_t old_size, size_t new_size)
+		{
+			// round size up to block alignment boundary
+			old_size = (old_size + xpath_memory_block_alignment - 1) & ~(xpath_memory_block_alignment - 1);
+			new_size = (new_size + xpath_memory_block_alignment - 1) & ~(xpath_memory_block_alignment - 1);
+
+			// we can only reallocate the last object
+			assert(ptr == 0 || static_cast<char*>(ptr) + old_size == &_root->data[0] + _root_size);
+
+			// try to reallocate the object inplace
+			if (ptr && _root_size - old_size + new_size <= _root->capacity)
+			{
+				_root_size = _root_size - old_size + new_size;
+				return ptr;
+			}
+
+			// allocate a new block
+			void* result = allocate(new_size);
+			if (!result) return 0;
+
+			// we have a new block
+			if (ptr)
+			{
+				// copy old data (we only support growing)
+				assert(new_size >= old_size);
+				memcpy(result, ptr, old_size);
+
+				// free the previous page if it had no other objects
+				assert(_root->data == result);
+				assert(_root->next);
+
+				if (_root->next->data == ptr)
+				{
+					// deallocate the whole page, unless it was the first one
+					xpath_memory_block* next = _root->next->next;
+
+					if (next)
+					{
+						xml_memory::deallocate(_root->next);
+						_root->next = next;
+					}
+				}
+			}
+
+			return result;
+		}
+
+		void revert(const xpath_allocator& state)
+		{
+			// free all new pages
+			xpath_memory_block* cur = _root;
+
+			while (cur != state._root)
+			{
+				xpath_memory_block* next = cur->next;
+
+				xml_memory::deallocate(cur);
+
+				cur = next;
+			}
+
+			// restore state
+			_root = state._root;
+			_root_size = state._root_size;
+		}
+
+		void release()
+		{
+			xpath_memory_block* cur = _root;
+			assert(cur);
+
+			while (cur->next)
+			{
+				xpath_memory_block* next = cur->next;
+
+				xml_memory::deallocate(cur);
+
+				cur = next;
+			}
+		}
+	};
+
+	struct xpath_allocator_capture
+	{
+		xpath_allocator_capture(xpath_allocator* alloc): _target(alloc), _state(*alloc)
+		{
+		}
+
+		~xpath_allocator_capture()
+		{
+			_target->revert(_state);
+		}
+
+		xpath_allocator* _target;
+		xpath_allocator _state;
+	};
+
+	struct xpath_stack
+	{
+		xpath_allocator* result;
+		xpath_allocator* temp;
+	};
+
+	struct xpath_stack_data
+	{
+		xpath_memory_block blocks[2];
+		xpath_allocator result;
+		xpath_allocator temp;
+		xpath_stack stack;
+		bool oom;
+
+		xpath_stack_data(): result(blocks + 0, &oom), temp(blocks + 1, &oom), oom(false)
+		{
+			blocks[0].next = blocks[1].next = 0;
+			blocks[0].capacity = blocks[1].capacity = sizeof(blocks[0].data);
+
+			stack.result = &result;
+			stack.temp = &temp;
+		}
+
+		~xpath_stack_data()
+		{
+			result.release();
+			temp.release();
+		}
+	};
+PUGI__NS_END
+
+// String class
+PUGI__NS_BEGIN
+	class xpath_string
+	{
+		const char_t* _buffer;
+		bool _uses_heap;
+		size_t _length_heap;
+
+		static char_t* duplicate_string(const char_t* string, size_t length, xpath_allocator* alloc)
+		{
+			char_t* result = static_cast<char_t*>(alloc->allocate((length + 1) * sizeof(char_t)));
+			if (!result) return 0;
+
+			memcpy(result, string, length * sizeof(char_t));
+			result[length] = 0;
+
+			return result;
+		}
+
+		xpath_string(const char_t* buffer, bool uses_heap_, size_t length_heap): _buffer(buffer), _uses_heap(uses_heap_), _length_heap(length_heap)
+		{
+		}
+
+	public:
+		static xpath_string from_const(const char_t* str)
+		{
+			return xpath_string(str, false, 0);
+		}
+
+		static xpath_string from_heap_preallocated(const char_t* begin, const char_t* end)
+		{
+			assert(begin <= end && *end == 0);
+
+			return xpath_string(begin, true, static_cast<size_t>(end - begin));
+		}
+
+		static xpath_string from_heap(const char_t* begin, const char_t* end, xpath_allocator* alloc)
+		{
+			assert(begin <= end);
+
+			if (begin == end)
+				return xpath_string();
+
+			size_t length = static_cast<size_t>(end - begin);
+			const char_t* data = duplicate_string(begin, length, alloc);
+
+			return data ? xpath_string(data, true, length) : xpath_string();
+		}
+
+		xpath_string(): _buffer(PUGIXML_TEXT("")), _uses_heap(false), _length_heap(0)
+		{
+		}
+
+		void append(const xpath_string& o, xpath_allocator* alloc)
+		{
+			// skip empty sources
+			if (!*o._buffer) return;
+
+			// fast append for constant empty target and constant source
+			if (!*_buffer && !_uses_heap && !o._uses_heap)
+			{
+				_buffer = o._buffer;
+			}
+			else
+			{
+				// need to make heap copy
+				size_t target_length = length();
+				size_t source_length = o.length();
+				size_t result_length = target_length + source_length;
+
+				// allocate new buffer
+				char_t* result = static_cast<char_t*>(alloc->reallocate(_uses_heap ? const_cast<char_t*>(_buffer) : 0, (target_length + 1) * sizeof(char_t), (result_length + 1) * sizeof(char_t)));
+				if (!result) return;
+
+				// append first string to the new buffer in case there was no reallocation
+				if (!_uses_heap) memcpy(result, _buffer, target_length * sizeof(char_t));
+
+				// append second string to the new buffer
+				memcpy(result + target_length, o._buffer, source_length * sizeof(char_t));
+				result[result_length] = 0;
+
+				// finalize
+				_buffer = result;
+				_uses_heap = true;
+				_length_heap = result_length;
+			}
+		}
+
+		const char_t* c_str() const
+		{
+			return _buffer;
+		}
+
+		size_t length() const
+		{
+			return _uses_heap ? _length_heap : strlength(_buffer);
+		}
+
+		char_t* data(xpath_allocator* alloc)
+		{
+			// make private heap copy
+			if (!_uses_heap)
+			{
+				size_t length_ = strlength(_buffer);
+				const char_t* data_ = duplicate_string(_buffer, length_, alloc);
+
+				if (!data_) return 0;
+
+				_buffer = data_;
+				_uses_heap = true;
+				_length_heap = length_;
+			}
+
+			return const_cast<char_t*>(_buffer);
+		}
+
+		bool empty() const
+		{
+			return *_buffer == 0;
+		}
+
+		bool operator==(const xpath_string& o) const
+		{
+			return strequal(_buffer, o._buffer);
+		}
+
+		bool operator!=(const xpath_string& o) const
+		{
+			return !strequal(_buffer, o._buffer);
+		}
+
+		bool uses_heap() const
+		{
+			return _uses_heap;
+		}
+	};
+PUGI__NS_END
+
+PUGI__NS_BEGIN
+	PUGI__FN bool starts_with(const char_t* string, const char_t* pattern)
+	{
+		while (*pattern && *string == *pattern)
+		{
+			string++;
+			pattern++;
+		}
+
+		return *pattern == 0;
+	}
+
+	PUGI__FN const char_t* find_char(const char_t* s, char_t c)
+	{
+	#ifdef PUGIXML_WCHAR_MODE
+		return wcschr(s, c);
+	#else
+		return strchr(s, c);
+	#endif
+	}
+
+	PUGI__FN const char_t* find_substring(const char_t* s, const char_t* p)
+	{
+	#ifdef PUGIXML_WCHAR_MODE
+		// MSVC6 wcsstr bug workaround (if s is empty it always returns 0)
+		return (*p == 0) ? s : wcsstr(s, p);
+	#else
+		return strstr(s, p);
+	#endif
+	}
+
+	// Converts symbol to lower case, if it is an ASCII one
+	PUGI__FN char_t tolower_ascii(char_t ch)
+	{
+		return static_cast<unsigned int>(ch - 'A') < 26 ? static_cast<char_t>(ch | ' ') : ch;
+	}
+
+	PUGI__FN xpath_string string_value(const xpath_node& na, xpath_allocator* alloc)
+	{
+		if (na.attribute())
+			return xpath_string::from_const(na.attribute().value());
+		else
+		{
+			xml_node n = na.node();
+
+			switch (n.type())
+			{
+			case node_pcdata:
+			case node_cdata:
+			case node_comment:
+			case node_pi:
+				return xpath_string::from_const(n.value());
+
+			case node_document:
+			case node_element:
+			{
+				xpath_string result;
+
+				// element nodes can have value if parse_embed_pcdata was used
+				if (n.value()[0])
+					result.append(xpath_string::from_const(n.value()), alloc);
+
+				xml_node cur = n.first_child();
+
+				while (cur && cur != n)
+				{
+					if (cur.type() == node_pcdata || cur.type() == node_cdata)
+						result.append(xpath_string::from_const(cur.value()), alloc);
+
+					if (cur.first_child())
+						cur = cur.first_child();
+					else if (cur.next_sibling())
+						cur = cur.next_sibling();
+					else
+					{
+						while (!cur.next_sibling() && cur != n)
+							cur = cur.parent();
+
+						if (cur != n) cur = cur.next_sibling();
+					}
+				}
+
+				return result;
+			}
+
+			default:
+				return xpath_string();
+			}
+		}
+	}
+
+	PUGI__FN bool node_is_before_sibling(xml_node_struct* ln, xml_node_struct* rn)
+	{
+		assert(ln->parent == rn->parent);
+
+		// there is no common ancestor (the shared parent is null), nodes are from different documents
+		if (!ln->parent) return ln < rn;
+
+		// determine sibling order
+		xml_node_struct* ls = ln;
+		xml_node_struct* rs = rn;
+
+		while (ls && rs)
+		{
+			if (ls == rn) return true;
+			if (rs == ln) return false;
+
+			ls = ls->next_sibling;
+			rs = rs->next_sibling;
+		}
+
+		// if rn sibling chain ended ln must be before rn
+		return !rs;
+	}
+
+	PUGI__FN bool node_is_before(xml_node_struct* ln, xml_node_struct* rn)
+	{
+		// find common ancestor at the same depth, if any
+		xml_node_struct* lp = ln;
+		xml_node_struct* rp = rn;
+
+		while (lp && rp && lp->parent != rp->parent)
+		{
+			lp = lp->parent;
+			rp = rp->parent;
+		}
+
+		// parents are the same!
+		if (lp && rp) return node_is_before_sibling(lp, rp);
+
+		// nodes are at different depths, need to normalize heights
+		bool left_higher = !lp;
+
+		while (lp)
+		{
+			lp = lp->parent;
+			ln = ln->parent;
+		}
+
+		while (rp)
+		{
+			rp = rp->parent;
+			rn = rn->parent;
+		}
+
+		// one node is the ancestor of the other
+		if (ln == rn) return left_higher;
+
+		// find common ancestor... again
+		while (ln->parent != rn->parent)
+		{
+			ln = ln->parent;
+			rn = rn->parent;
+		}
+
+		return node_is_before_sibling(ln, rn);
+	}
+
+	PUGI__FN bool node_is_ancestor(xml_node_struct* parent, xml_node_struct* node)
+	{
+		while (node && node != parent) node = node->parent;
+
+		return parent && node == parent;
+	}
+
+	PUGI__FN const void* document_buffer_order(const xpath_node& xnode)
+	{
+		xml_node_struct* node = xnode.node().internal_object();
+
+		if (node)
+		{
+			if ((get_document(node).header & xml_memory_page_contents_shared_mask) == 0)
+			{
+				if (node->name && (node->header & impl::xml_memory_page_name_allocated_or_shared_mask) == 0) return node->name;
+				if (node->value && (node->header & impl::xml_memory_page_value_allocated_or_shared_mask) == 0) return node->value;
+			}
+
+			return 0;
+		}
+
+		xml_attribute_struct* attr = xnode.attribute().internal_object();
+
+		if (attr)
+		{
+			if ((get_document(attr).header & xml_memory_page_contents_shared_mask) == 0)
+			{
+				if ((attr->header & impl::xml_memory_page_name_allocated_or_shared_mask) == 0) return attr->name;
+				if ((attr->header & impl::xml_memory_page_value_allocated_or_shared_mask) == 0) return attr->value;
+			}
+
+			return 0;
+		}
+
+		return 0;
+	}
+
+	struct document_order_comparator
+	{
+		bool operator()(const xpath_node& lhs, const xpath_node& rhs) const
+		{
+			// optimized document order based check
+			const void* lo = document_buffer_order(lhs);
+			const void* ro = document_buffer_order(rhs);
+
+			if (lo && ro) return lo < ro;
+
+			// slow comparison
+			xml_node ln = lhs.node(), rn = rhs.node();
+
+			// compare attributes
+			if (lhs.attribute() && rhs.attribute())
+			{
+				// shared parent
+				if (lhs.parent() == rhs.parent())
+				{
+					// determine sibling order
+					for (xml_attribute a = lhs.attribute(); a; a = a.next_attribute())
+						if (a == rhs.attribute())
+							return true;
+
+					return false;
+				}
+
+				// compare attribute parents
+				ln = lhs.parent();
+				rn = rhs.parent();
+			}
+			else if (lhs.attribute())
+			{
+				// attributes go after the parent element
+				if (lhs.parent() == rhs.node()) return false;
+
+				ln = lhs.parent();
+			}
+			else if (rhs.attribute())
+			{
+				// attributes go after the parent element
+				if (rhs.parent() == lhs.node()) return true;
+
+				rn = rhs.parent();
+			}
+
+			if (ln == rn) return false;
+
+			if (!ln || !rn) return ln < rn;
+
+			return node_is_before(ln.internal_object(), rn.internal_object());
+		}
+	};
+
+	PUGI__FN double gen_nan()
+	{
+	#if defined(__STDC_IEC_559__) || ((FLT_RADIX - 0 == 2) && (FLT_MAX_EXP - 0 == 128) && (FLT_MANT_DIG - 0 == 24))
+		PUGI__STATIC_ASSERT(sizeof(float) == sizeof(uint32_t));
+		typedef uint32_t UI; // BCC5 workaround
+		union { float f; UI i; } u;
+		u.i = 0x7fc00000;
+		return double(u.f);
+	#else
+		// fallback
+		const volatile double zero = 0.0;
+		return zero / zero;
+	#endif
+	}
+
+	PUGI__FN bool is_nan(double value)
+	{
+	#if defined(PUGI__MSVC_CRT_VERSION) || defined(__BORLANDC__)
+		return !!_isnan(value);
+	#elif defined(fpclassify) && defined(FP_NAN)
+		return fpclassify(value) == FP_NAN;
+	#else
+		// fallback
+		const volatile double v = value;
+		return v != v;
+	#endif
+	}
+
+	PUGI__FN const char_t* convert_number_to_string_special(double value)
+	{
+	#if defined(PUGI__MSVC_CRT_VERSION) || defined(__BORLANDC__)
+		if (_finite(value)) return (value == 0) ? PUGIXML_TEXT("0") : 0;
+		if (_isnan(value)) return PUGIXML_TEXT("NaN");
+		return value > 0 ? PUGIXML_TEXT("Infinity") : PUGIXML_TEXT("-Infinity");
+	#elif defined(fpclassify) && defined(FP_NAN) && defined(FP_INFINITE) && defined(FP_ZERO)
+		switch (fpclassify(value))
+		{
+		case FP_NAN:
+			return PUGIXML_TEXT("NaN");
+
+		case FP_INFINITE:
+			return value > 0 ? PUGIXML_TEXT("Infinity") : PUGIXML_TEXT("-Infinity");
+
+		case FP_ZERO:
+			return PUGIXML_TEXT("0");
+
+		default:
+			return 0;
+		}
+	#else
+		// fallback
+		const volatile double v = value;
+
+		if (v == 0) return PUGIXML_TEXT("0");
+		if (v != v) return PUGIXML_TEXT("NaN");
+		if (v * 2 == v) return value > 0 ? PUGIXML_TEXT("Infinity") : PUGIXML_TEXT("-Infinity");
+		return 0;
+	#endif
+	}
+
+	PUGI__FN bool convert_number_to_boolean(double value)
+	{
+		return (value != 0 && !is_nan(value));
+	}
+
+	PUGI__FN void truncate_zeros(char* begin, char* end)
+	{
+		while (begin != end && end[-1] == '0') end--;
+
+		*end = 0;
+	}
+
+	// gets mantissa digits in the form of 0.xxxxx with 0. implied and the exponent
+#if defined(PUGI__MSVC_CRT_VERSION) && PUGI__MSVC_CRT_VERSION >= 1400 && !defined(_WIN32_WCE)
+	PUGI__FN void convert_number_to_mantissa_exponent(double value, char (&buffer)[32], char** out_mantissa, int* out_exponent)
+	{
+		// get base values
+		int sign, exponent;
+		_ecvt_s(buffer, sizeof(buffer), value, DBL_DIG + 1, &exponent, &sign);
+
+		// truncate redundant zeros
+		truncate_zeros(buffer, buffer + strlen(buffer));
+
+		// fill results
+		*out_mantissa = buffer;
+		*out_exponent = exponent;
+	}
+#else
+	PUGI__FN void convert_number_to_mantissa_exponent(double value, char (&buffer)[32], char** out_mantissa, int* out_exponent)
+	{
+		// get a scientific notation value with IEEE DBL_DIG decimals
+		PUGI__SNPRINTF(buffer, "%.*e", DBL_DIG, value);
+
+		// get the exponent (possibly negative)
+		char* exponent_string = strchr(buffer, 'e');
+		assert(exponent_string);
+
+		int exponent = atoi(exponent_string + 1);
+
+		// extract mantissa string: skip sign
+		char* mantissa = buffer[0] == '-' ? buffer + 1 : buffer;
+		assert(mantissa[0] != '0' && mantissa[1] == '.');
+
+		// divide mantissa by 10 to eliminate integer part
+		mantissa[1] = mantissa[0];
+		mantissa++;
+		exponent++;
+
+		// remove extra mantissa digits and zero-terminate mantissa
+		truncate_zeros(mantissa, exponent_string);
+
+		// fill results
+		*out_mantissa = mantissa;
+		*out_exponent = exponent;
+	}
+#endif
+
+	PUGI__FN xpath_string convert_number_to_string(double value, xpath_allocator* alloc)
+	{
+		// try special number conversion
+		const char_t* special = convert_number_to_string_special(value);
+		if (special) return xpath_string::from_const(special);
+
+		// get mantissa + exponent form
+		char mantissa_buffer[32];
+
+		char* mantissa;
+		int exponent;
+		convert_number_to_mantissa_exponent(value, mantissa_buffer, &mantissa, &exponent);
+
+		// allocate a buffer of suitable length for the number
+		size_t result_size = strlen(mantissa_buffer) + (exponent > 0 ? exponent : -exponent) + 4;
+		char_t* result = static_cast<char_t*>(alloc->allocate(sizeof(char_t) * result_size));
+		if (!result) return xpath_string();
+
+		// make the number!
+		char_t* s = result;
+
+		// sign
+		if (value < 0) *s++ = '-';
+
+		// integer part
+		if (exponent <= 0)
+		{
+			*s++ = '0';
+		}
+		else
+		{
+			while (exponent > 0)
+			{
+				assert(*mantissa == 0 || static_cast<unsigned int>(*mantissa - '0') <= 9);
+				*s++ = *mantissa ? *mantissa++ : '0';
+				exponent--;
+			}
+		}
+
+		// fractional part
+		if (*mantissa)
+		{
+			// decimal point
+			*s++ = '.';
+
+			// extra zeroes from negative exponent
+			while (exponent < 0)
+			{
+				*s++ = '0';
+				exponent++;
+			}
+
+			// extra mantissa digits
+			while (*mantissa)
+			{
+				assert(static_cast<unsigned int>(*mantissa - '0') <= 9);
+				*s++ = *mantissa++;
+			}
+		}
+
+		// zero-terminate
+		assert(s < result + result_size);
+		*s = 0;
+
+		return xpath_string::from_heap_preallocated(result, s);
+	}
+
+	PUGI__FN bool check_string_to_number_format(const char_t* string)
+	{
+		// parse leading whitespace
+		while (PUGI__IS_CHARTYPE(*string, ct_space)) ++string;
+
+		// parse sign
+		if (*string == '-') ++string;
+
+		if (!*string) return false;
+
+		// if there is no integer part, there should be a decimal part with at least one digit
+		if (!PUGI__IS_CHARTYPEX(string[0], ctx_digit) && (string[0] != '.' || !PUGI__IS_CHARTYPEX(string[1], ctx_digit))) return false;
+
+		// parse integer part
+		while (PUGI__IS_CHARTYPEX(*string, ctx_digit)) ++string;
+
+		// parse decimal part
+		if (*string == '.')
+		{
+			++string;
+
+			while (PUGI__IS_CHARTYPEX(*string, ctx_digit)) ++string;
+		}
+
+		// parse trailing whitespace
+		while (PUGI__IS_CHARTYPE(*string, ct_space)) ++string;
+
+		return *string == 0;
+	}
+
+	PUGI__FN double convert_string_to_number(const char_t* string)
+	{
+		// check string format
+		if (!check_string_to_number_format(string)) return gen_nan();
+
+		// parse string
+	#ifdef PUGIXML_WCHAR_MODE
+		return wcstod(string, 0);
+	#else
+		return strtod(string, 0);
+	#endif
+	}
+
+	PUGI__FN bool convert_string_to_number_scratch(char_t (&buffer)[32], const char_t* begin, const char_t* end, double* out_result)
+	{
+		size_t length = static_cast<size_t>(end - begin);
+		char_t* scratch = buffer;
+
+		if (length >= sizeof(buffer) / sizeof(buffer[0]))
+		{
+			// need to make dummy on-heap copy
+			scratch = static_cast<char_t*>(xml_memory::allocate((length + 1) * sizeof(char_t)));
+			if (!scratch) return false;
+		}
+
+		// copy string to zero-terminated buffer and perform conversion
+		memcpy(scratch, begin, length * sizeof(char_t));
+		scratch[length] = 0;
+
+		*out_result = convert_string_to_number(scratch);
+
+		// free dummy buffer
+		if (scratch != buffer) xml_memory::deallocate(scratch);
+
+		return true;
+	}
+
+	PUGI__FN double round_nearest(double value)
+	{
+		return floor(value + 0.5);
+	}
+
+	PUGI__FN double round_nearest_nzero(double value)
+	{
+		// same as round_nearest, but returns -0 for [-0.5, -0]
+		// ceil is used to differentiate between +0 and -0 (we return -0 for [-0.5, -0] and +0 for +0)
+		return (value >= -0.5 && value <= 0) ? ceil(value) : floor(value + 0.5);
+	}
+
+	PUGI__FN const char_t* qualified_name(const xpath_node& node)
+	{
+		return node.attribute() ? node.attribute().name() : node.node().name();
+	}
+
+	PUGI__FN const char_t* local_name(const xpath_node& node)
+	{
+		const char_t* name = qualified_name(node);
+		const char_t* p = find_char(name, ':');
+
+		return p ? p + 1 : name;
+	}
+
+	struct namespace_uri_predicate
+	{
+		const char_t* prefix;
+		size_t prefix_length;
+
+		namespace_uri_predicate(const char_t* name)
+		{
+			const char_t* pos = find_char(name, ':');
+
+			prefix = pos ? name : 0;
+			prefix_length = pos ? static_cast<size_t>(pos - name) : 0;
+		}
+
+		bool operator()(xml_attribute a) const
+		{
+			const char_t* name = a.name();
+
+			if (!starts_with(name, PUGIXML_TEXT("xmlns"))) return false;
+
+			return prefix ? name[5] == ':' && strequalrange(name + 6, prefix, prefix_length) : name[5] == 0;
+		}
+	};
+
+	PUGI__FN const char_t* namespace_uri(xml_node node)
+	{
+		namespace_uri_predicate pred = node.name();
+
+		xml_node p = node;
+
+		while (p)
+		{
+			xml_attribute a = p.find_attribute(pred);
+
+			if (a) return a.value();
+
+			p = p.parent();
+		}
+
+		return PUGIXML_TEXT("");
+	}
+
+	PUGI__FN const char_t* namespace_uri(xml_attribute attr, xml_node parent)
+	{
+		namespace_uri_predicate pred = attr.name();
+
+		// Default namespace does not apply to attributes
+		if (!pred.prefix) return PUGIXML_TEXT("");
+
+		xml_node p = parent;
+
+		while (p)
+		{
+			xml_attribute a = p.find_attribute(pred);
+
+			if (a) return a.value();
+
+			p = p.parent();
+		}
+
+		return PUGIXML_TEXT("");
+	}
+
+	PUGI__FN const char_t* namespace_uri(const xpath_node& node)
+	{
+		return node.attribute() ? namespace_uri(node.attribute(), node.parent()) : namespace_uri(node.node());
+	}
+
+	PUGI__FN char_t* normalize_space(char_t* buffer)
+	{
+		char_t* write = buffer;
+
+		for (char_t* it = buffer; *it; )
+		{
+			char_t ch = *it++;
+
+			if (PUGI__IS_CHARTYPE(ch, ct_space))
+			{
+				// replace whitespace sequence with single space
+				while (PUGI__IS_CHARTYPE(*it, ct_space)) it++;
+
+				// avoid leading spaces
+				if (write != buffer) *write++ = ' ';
+			}
+			else *write++ = ch;
+		}
+
+		// remove trailing space
+		if (write != buffer && PUGI__IS_CHARTYPE(write[-1], ct_space)) write--;
+
+		// zero-terminate
+		*write = 0;
+
+		return write;
+	}
+
+	PUGI__FN char_t* translate(char_t* buffer, const char_t* from, const char_t* to, size_t to_length)
+	{
+		char_t* write = buffer;
+
+		while (*buffer)
+		{
+			PUGI__DMC_VOLATILE char_t ch = *buffer++;
+
+			const char_t* pos = find_char(from, ch);
+
+			if (!pos)
+				*write++ = ch; // do not process
+			else if (static_cast<size_t>(pos - from) < to_length)
+				*write++ = to[pos - from]; // replace
+		}
+
+		// zero-terminate
+		*write = 0;
+
+		return write;
+	}
+
+	PUGI__FN unsigned char* translate_table_generate(xpath_allocator* alloc, const char_t* from, const char_t* to)
+	{
+		unsigned char table[128] = {0};
+
+		while (*from)
+		{
+			unsigned int fc = static_cast<unsigned int>(*from);
+			unsigned int tc = static_cast<unsigned int>(*to);
+
+			if (fc >= 128 || tc >= 128)
+				return 0;
+
+			// code=128 means "skip character"
+			if (!table[fc])
+				table[fc] = static_cast<unsigned char>(tc ? tc : 128);
+
+			from++;
+			if (tc) to++;
+		}
+
+		for (int i = 0; i < 128; ++i)
+			if (!table[i])
+				table[i] = static_cast<unsigned char>(i);
+
+		void* result = alloc->allocate(sizeof(table));
+		if (!result) return 0;
+
+		memcpy(result, table, sizeof(table));
+
+		return static_cast<unsigned char*>(result);
+	}
+
+	PUGI__FN char_t* translate_table(char_t* buffer, const unsigned char* table)
+	{
+		char_t* write = buffer;
+
+		while (*buffer)
+		{
+			char_t ch = *buffer++;
+			unsigned int index = static_cast<unsigned int>(ch);
+
+			if (index < 128)
+			{
+				unsigned char code = table[index];
+
+				// code=128 means "skip character" (table size is 128 so 128 can be a special value)
+				// this code skips these characters without extra branches
+				*write = static_cast<char_t>(code);
+				write += 1 - (code >> 7);
+			}
+			else
+			{
+				*write++ = ch;
+			}
+		}
+
+		// zero-terminate
+		*write = 0;
+
+		return write;
+	}
+
+	inline bool is_xpath_attribute(const char_t* name)
+	{
+		return !(starts_with(name, PUGIXML_TEXT("xmlns")) && (name[5] == 0 || name[5] == ':'));
+	}
+
+	struct xpath_variable_boolean: xpath_variable
+	{
+		xpath_variable_boolean(): xpath_variable(xpath_type_boolean), value(false)
+		{
+		}
+
+		bool value;
+		char_t name[1];
+	};
+
+	struct xpath_variable_number: xpath_variable
+	{
+		xpath_variable_number(): xpath_variable(xpath_type_number), value(0)
+		{
+		}
+
+		double value;
+		char_t name[1];
+	};
+
+	struct xpath_variable_string: xpath_variable
+	{
+		xpath_variable_string(): xpath_variable(xpath_type_string), value(0)
+		{
+		}
+
+		~xpath_variable_string()
+		{
+			if (value) xml_memory::deallocate(value);
+		}
+
+		char_t* value;
+		char_t name[1];
+	};
+
+	struct xpath_variable_node_set: xpath_variable
+	{
+		xpath_variable_node_set(): xpath_variable(xpath_type_node_set)
+		{
+		}
+
+		xpath_node_set value;
+		char_t name[1];
+	};
+
+	static const xpath_node_set dummy_node_set;
+
+	PUGI__FN PUGI__UNSIGNED_OVERFLOW unsigned int hash_string(const char_t* str)
+	{
+		// Jenkins one-at-a-time hash (http://en.wikipedia.org/wiki/Jenkins_hash_function#one-at-a-time)
+		unsigned int result = 0;
+
+		while (*str)
+		{
+			result += static_cast<unsigned int>(*str++);
+			result += result << 10;
+			result ^= result >> 6;
+		}
+
+		result += result << 3;
+		result ^= result >> 11;
+		result += result << 15;
+
+		return result;
+	}
+
+	template <typename T> PUGI__FN T* new_xpath_variable(const char_t* name)
+	{
+		size_t length = strlength(name);
+		if (length == 0) return 0; // empty variable names are invalid
+
+		// $$ we can't use offsetof(T, name) because T is non-POD, so we just allocate additional length characters
+		void* memory = xml_memory::allocate(sizeof(T) + length * sizeof(char_t));
+		if (!memory) return 0;
+
+		T* result = new (memory) T();
+
+		memcpy(result->name, name, (length + 1) * sizeof(char_t));
+
+		return result;
+	}
+
+	PUGI__FN xpath_variable* new_xpath_variable(xpath_value_type type, const char_t* name)
+	{
+		switch (type)
+		{
+		case xpath_type_node_set:
+			return new_xpath_variable<xpath_variable_node_set>(name);
+
+		case xpath_type_number:
+			return new_xpath_variable<xpath_variable_number>(name);
+
+		case xpath_type_string:
+			return new_xpath_variable<xpath_variable_string>(name);
+
+		case xpath_type_boolean:
+			return new_xpath_variable<xpath_variable_boolean>(name);
+
+		default:
+			return 0;
+		}
+	}
+
+	template <typename T> PUGI__FN void delete_xpath_variable(T* var)
+	{
+		var->~T();
+		xml_memory::deallocate(var);
+	}
+
+	PUGI__FN void delete_xpath_variable(xpath_value_type type, xpath_variable* var)
+	{
+		switch (type)
+		{
+		case xpath_type_node_set:
+			delete_xpath_variable(static_cast<xpath_variable_node_set*>(var));
+			break;
+
+		case xpath_type_number:
+			delete_xpath_variable(static_cast<xpath_variable_number*>(var));
+			break;
+
+		case xpath_type_string:
+			delete_xpath_variable(static_cast<xpath_variable_string*>(var));
+			break;
+
+		case xpath_type_boolean:
+			delete_xpath_variable(static_cast<xpath_variable_boolean*>(var));
+			break;
+
+		default:
+			assert(false && "Invalid variable type"); // unreachable
+		}
+	}
+
+	PUGI__FN bool copy_xpath_variable(xpath_variable* lhs, const xpath_variable* rhs)
+	{
+		switch (rhs->type())
+		{
+		case xpath_type_node_set:
+			return lhs->set(static_cast<const xpath_variable_node_set*>(rhs)->value);
+
+		case xpath_type_number:
+			return lhs->set(static_cast<const xpath_variable_number*>(rhs)->value);
+
+		case xpath_type_string:
+			return lhs->set(static_cast<const xpath_variable_string*>(rhs)->value);
+
+		case xpath_type_boolean:
+			return lhs->set(static_cast<const xpath_variable_boolean*>(rhs)->value);
+
+		default:
+			assert(false && "Invalid variable type"); // unreachable
+			return false;
+		}
+	}
+
+	PUGI__FN bool get_variable_scratch(char_t (&buffer)[32], xpath_variable_set* set, const char_t* begin, const char_t* end, xpath_variable** out_result)
+	{
+		size_t length = static_cast<size_t>(end - begin);
+		char_t* scratch = buffer;
+
+		if (length >= sizeof(buffer) / sizeof(buffer[0]))
+		{
+			// need to make dummy on-heap copy
+			scratch = static_cast<char_t*>(xml_memory::allocate((length + 1) * sizeof(char_t)));
+			if (!scratch) return false;
+		}
+
+		// copy string to zero-terminated buffer and perform lookup
+		memcpy(scratch, begin, length * sizeof(char_t));
+		scratch[length] = 0;
+
+		*out_result = set->get(scratch);
+
+		// free dummy buffer
+		if (scratch != buffer) xml_memory::deallocate(scratch);
+
+		return true;
+	}
+PUGI__NS_END
+
+// Internal node set class
+PUGI__NS_BEGIN
+	PUGI__FN xpath_node_set::type_t xpath_get_order(const xpath_node* begin, const xpath_node* end)
+	{
+		if (end - begin < 2)
+			return xpath_node_set::type_sorted;
+
+		document_order_comparator cmp;
+
+		bool first = cmp(begin[0], begin[1]);
+
+		for (const xpath_node* it = begin + 1; it + 1 < end; ++it)
+			if (cmp(it[0], it[1]) != first)
+				return xpath_node_set::type_unsorted;
+
+		return first ? xpath_node_set::type_sorted : xpath_node_set::type_sorted_reverse;
+	}
+
+	PUGI__FN xpath_node_set::type_t xpath_sort(xpath_node* begin, xpath_node* end, xpath_node_set::type_t type, bool rev)
+	{
+		xpath_node_set::type_t order = rev ? xpath_node_set::type_sorted_reverse : xpath_node_set::type_sorted;
+
+		if (type == xpath_node_set::type_unsorted)
+		{
+			xpath_node_set::type_t sorted = xpath_get_order(begin, end);
+
+			if (sorted == xpath_node_set::type_unsorted)
+			{
+				sort(begin, end, document_order_comparator());
+
+				type = xpath_node_set::type_sorted;
+			}
+			else
+				type = sorted;
+		}
+
+		if (type != order) reverse(begin, end);
+
+		return order;
+	}
+
+	PUGI__FN xpath_node xpath_first(const xpath_node* begin, const xpath_node* end, xpath_node_set::type_t type)
+	{
+		if (begin == end) return xpath_node();
+
+		switch (type)
+		{
+		case xpath_node_set::type_sorted:
+			return *begin;
+
+		case xpath_node_set::type_sorted_reverse:
+			return *(end - 1);
+
+		case xpath_node_set::type_unsorted:
+			return *min_element(begin, end, document_order_comparator());
+
+		default:
+			assert(false && "Invalid node set type"); // unreachable
+			return xpath_node();
+		}
+	}
+
+	class xpath_node_set_raw
+	{
+		xpath_node_set::type_t _type;
+
+		xpath_node* _begin;
+		xpath_node* _end;
+		xpath_node* _eos;
+
+	public:
+		xpath_node_set_raw(): _type(xpath_node_set::type_unsorted), _begin(0), _end(0), _eos(0)
+		{
+		}
+
+		xpath_node* begin() const
+		{
+			return _begin;
+		}
+
+		xpath_node* end() const
+		{
+			return _end;
+		}
+
+		bool empty() const
+		{
+			return _begin == _end;
+		}
+
+		size_t size() const
+		{
+			return static_cast<size_t>(_end - _begin);
+		}
+
+		xpath_node first() const
+		{
+			return xpath_first(_begin, _end, _type);
+		}
+
+		void push_back_grow(const xpath_node& node, xpath_allocator* alloc);
+
+		void push_back(const xpath_node& node, xpath_allocator* alloc)
+		{
+			if (_end != _eos)
+				*_end++ = node;
+			else
+				push_back_grow(node, alloc);
+		}
+
+		void append(const xpath_node* begin_, const xpath_node* end_, xpath_allocator* alloc)
+		{
+			if (begin_ == end_) return;
+
+			size_t size_ = static_cast<size_t>(_end - _begin);
+			size_t capacity = static_cast<size_t>(_eos - _begin);
+			size_t count = static_cast<size_t>(end_ - begin_);
+
+			if (size_ + count > capacity)
+			{
+				// reallocate the old array or allocate a new one
+				xpath_node* data = static_cast<xpath_node*>(alloc->reallocate(_begin, capacity * sizeof(xpath_node), (size_ + count) * sizeof(xpath_node)));
+				if (!data) return;
+
+				// finalize
+				_begin = data;
+				_end = data + size_;
+				_eos = data + size_ + count;
+			}
+
+			memcpy(_end, begin_, count * sizeof(xpath_node));
+			_end += count;
+		}
+
+		void sort_do()
+		{
+			_type = xpath_sort(_begin, _end, _type, false);
+		}
+
+		void truncate(xpath_node* pos)
+		{
+			assert(_begin <= pos && pos <= _end);
+
+			_end = pos;
+		}
+
+		void remove_duplicates(xpath_allocator* alloc)
+		{
+			if (_type == xpath_node_set::type_unsorted && _end - _begin > 2)
+			{
+				xpath_allocator_capture cr(alloc);
+
+				size_t size_ = static_cast<size_t>(_end - _begin);
+
+				size_t hash_size = 1;
+				while (hash_size < size_ + size_ / 2) hash_size *= 2;
+
+				const void** hash_data = static_cast<const void**>(alloc->allocate(hash_size * sizeof(void**)));
+				if (!hash_data) return;
+
+				memset(hash_data, 0, hash_size * sizeof(const void**));
+
+				xpath_node* write = _begin;
+
+				for (xpath_node* it = _begin; it != _end; ++it)
+				{
+					const void* attr = it->attribute().internal_object();
+					const void* node = it->node().internal_object();
+					const void* key = attr ? attr : node;
+
+					if (key && hash_insert(hash_data, hash_size, key))
+					{
+						*write++ = *it;
+					}
+				}
+
+				_end = write;
+			}
+			else
+			{
+				_end = unique(_begin, _end);
+			}
+		}
+
+		xpath_node_set::type_t type() const
+		{
+			return _type;
+		}
+
+		void set_type(xpath_node_set::type_t value)
+		{
+			_type = value;
+		}
+	};
+
+	PUGI__FN_NO_INLINE void xpath_node_set_raw::push_back_grow(const xpath_node& node, xpath_allocator* alloc)
+	{
+		size_t capacity = static_cast<size_t>(_eos - _begin);
+
+		// get new capacity (1.5x rule)
+		size_t new_capacity = capacity + capacity / 2 + 1;
+
+		// reallocate the old array or allocate a new one
+		xpath_node* data = static_cast<xpath_node*>(alloc->reallocate(_begin, capacity * sizeof(xpath_node), new_capacity * sizeof(xpath_node)));
+		if (!data) return;
+
+		// finalize
+		_begin = data;
+		_end = data + capacity;
+		_eos = data + new_capacity;
+
+		// push
+		*_end++ = node;
+	}
+PUGI__NS_END
+
+PUGI__NS_BEGIN
+	struct xpath_context
+	{
+		xpath_node n;
+		size_t position, size;
+
+		xpath_context(const xpath_node& n_, size_t position_, size_t size_): n(n_), position(position_), size(size_)
+		{
+		}
+	};
+
+	enum lexeme_t
+	{
+		lex_none = 0,
+		lex_equal,
+		lex_not_equal,
+		lex_less,
+		lex_greater,
+		lex_less_or_equal,
+		lex_greater_or_equal,
+		lex_plus,
+		lex_minus,
+		lex_multiply,
+		lex_union,
+		lex_var_ref,
+		lex_open_brace,
+		lex_close_brace,
+		lex_quoted_string,
+		lex_number,
+		lex_slash,
+		lex_double_slash,
+		lex_open_square_brace,
+		lex_close_square_brace,
+		lex_string,
+		lex_comma,
+		lex_axis_attribute,
+		lex_dot,
+		lex_double_dot,
+		lex_double_colon,
+		lex_eof
+	};
+
+	struct xpath_lexer_string
+	{
+		const char_t* begin;
+		const char_t* end;
+
+		xpath_lexer_string(): begin(0), end(0)
+		{
+		}
+
+		bool operator==(const char_t* other) const
+		{
+			size_t length = static_cast<size_t>(end - begin);
+
+			return strequalrange(other, begin, length);
+		}
+	};
+
+	class xpath_lexer
+	{
+		const char_t* _cur;
+		const char_t* _cur_lexeme_pos;
+		xpath_lexer_string _cur_lexeme_contents;
+
+		lexeme_t _cur_lexeme;
+
+	public:
+		explicit xpath_lexer(const char_t* query): _cur(query)
+		{
+			next();
+		}
+
+		const char_t* state() const
+		{
+			return _cur;
+		}
+
+		void next()
+		{
+			const char_t* cur = _cur;
+
+			while (PUGI__IS_CHARTYPE(*cur, ct_space)) ++cur;
+
+			// save lexeme position for error reporting
+			_cur_lexeme_pos = cur;
+
+			switch (*cur)
+			{
+			case 0:
+				_cur_lexeme = lex_eof;
+				break;
+
+			case '>':
+				if (*(cur+1) == '=')
+				{
+					cur += 2;
+					_cur_lexeme = lex_greater_or_equal;
+				}
+				else
+				{
+					cur += 1;
+					_cur_lexeme = lex_greater;
+				}
+				break;
+
+			case '<':
+				if (*(cur+1) == '=')
+				{
+					cur += 2;
+					_cur_lexeme = lex_less_or_equal;
+				}
+				else
+				{
+					cur += 1;
+					_cur_lexeme = lex_less;
+				}
+				break;
+
+			case '!':
+				if (*(cur+1) == '=')
+				{
+					cur += 2;
+					_cur_lexeme = lex_not_equal;
+				}
+				else
+				{
+					_cur_lexeme = lex_none;
+				}
+				break;
+
+			case '=':
+				cur += 1;
+				_cur_lexeme = lex_equal;
+
+				break;
+
+			case '+':
+				cur += 1;
+				_cur_lexeme = lex_plus;
+
+				break;
+
+			case '-':
+				cur += 1;
+				_cur_lexeme = lex_minus;
+
+				break;
+
+			case '*':
+				cur += 1;
+				_cur_lexeme = lex_multiply;
+
+				break;
+
+			case '|':
+				cur += 1;
+				_cur_lexeme = lex_union;
+
+				break;
+
+			case '$':
+				cur += 1;
+
+				if (PUGI__IS_CHARTYPEX(*cur, ctx_start_symbol))
+				{
+					_cur_lexeme_contents.begin = cur;
+
+					while (PUGI__IS_CHARTYPEX(*cur, ctx_symbol)) cur++;
+
+					if (cur[0] == ':' && PUGI__IS_CHARTYPEX(cur[1], ctx_symbol)) // qname
+					{
+						cur++; // :
+
+						while (PUGI__IS_CHARTYPEX(*cur, ctx_symbol)) cur++;
+					}
+
+					_cur_lexeme_contents.end = cur;
+
+					_cur_lexeme = lex_var_ref;
+				}
+				else
+				{
+					_cur_lexeme = lex_none;
+				}
+
+				break;
+
+			case '(':
+				cur += 1;
+				_cur_lexeme = lex_open_brace;
+
+				break;
+
+			case ')':
+				cur += 1;
+				_cur_lexeme = lex_close_brace;
+
+				break;
+
+			case '[':
+				cur += 1;
+				_cur_lexeme = lex_open_square_brace;
+
+				break;
+
+			case ']':
+				cur += 1;
+				_cur_lexeme = lex_close_square_brace;
+
+				break;
+
+			case ',':
+				cur += 1;
+				_cur_lexeme = lex_comma;
+
+				break;
+
+			case '/':
+				if (*(cur+1) == '/')
+				{
+					cur += 2;
+					_cur_lexeme = lex_double_slash;
+				}
+				else
+				{
+					cur += 1;
+					_cur_lexeme = lex_slash;
+				}
+				break;
+
+			case '.':
+				if (*(cur+1) == '.')
+				{
+					cur += 2;
+					_cur_lexeme = lex_double_dot;
+				}
+				else if (PUGI__IS_CHARTYPEX(*(cur+1), ctx_digit))
+				{
+					_cur_lexeme_contents.begin = cur; // .
+
+					++cur;
+
+					while (PUGI__IS_CHARTYPEX(*cur, ctx_digit)) cur++;
+
+					_cur_lexeme_contents.end = cur;
+
+					_cur_lexeme = lex_number;
+				}
+				else
+				{
+					cur += 1;
+					_cur_lexeme = lex_dot;
+				}
+				break;
+
+			case '@':
+				cur += 1;
+				_cur_lexeme = lex_axis_attribute;
+
+				break;
+
+			case '"':
+			case '\'':
+			{
+				char_t terminator = *cur;
+
+				++cur;
+
+				_cur_lexeme_contents.begin = cur;
+				while (*cur && *cur != terminator) cur++;
+				_cur_lexeme_contents.end = cur;
+
+				if (!*cur)
+					_cur_lexeme = lex_none;
+				else
+				{
+					cur += 1;
+					_cur_lexeme = lex_quoted_string;
+				}
+
+				break;
+			}
+
+			case ':':
+				if (*(cur+1) == ':')
+				{
+					cur += 2;
+					_cur_lexeme = lex_double_colon;
+				}
+				else
+				{
+					_cur_lexeme = lex_none;
+				}
+				break;
+
+			default:
+				if (PUGI__IS_CHARTYPEX(*cur, ctx_digit))
+				{
+					_cur_lexeme_contents.begin = cur;
+
+					while (PUGI__IS_CHARTYPEX(*cur, ctx_digit)) cur++;
+
+					if (*cur == '.')
+					{
+						cur++;
+
+						while (PUGI__IS_CHARTYPEX(*cur, ctx_digit)) cur++;
+					}
+
+					_cur_lexeme_contents.end = cur;
+
+					_cur_lexeme = lex_number;
+				}
+				else if (PUGI__IS_CHARTYPEX(*cur, ctx_start_symbol))
+				{
+					_cur_lexeme_contents.begin = cur;
+
+					while (PUGI__IS_CHARTYPEX(*cur, ctx_symbol)) cur++;
+
+					if (cur[0] == ':')
+					{
+						if (cur[1] == '*') // namespace test ncname:*
+						{
+							cur += 2; // :*
+						}
+						else if (PUGI__IS_CHARTYPEX(cur[1], ctx_symbol)) // namespace test qname
+						{
+							cur++; // :
+
+							while (PUGI__IS_CHARTYPEX(*cur, ctx_symbol)) cur++;
+						}
+					}
+
+					_cur_lexeme_contents.end = cur;
+
+					_cur_lexeme = lex_string;
+				}
+				else
+				{
+					_cur_lexeme = lex_none;
+				}
+			}
+
+			_cur = cur;
+		}
+
+		lexeme_t current() const
+		{
+			return _cur_lexeme;
+		}
+
+		const char_t* current_pos() const
+		{
+			return _cur_lexeme_pos;
+		}
+
+		const xpath_lexer_string& contents() const
+		{
+			assert(_cur_lexeme == lex_var_ref || _cur_lexeme == lex_number || _cur_lexeme == lex_string || _cur_lexeme == lex_quoted_string);
+
+			return _cur_lexeme_contents;
+		}
+	};
+
+	enum ast_type_t
+	{
+		ast_unknown,
+		ast_op_or,						// left or right
+		ast_op_and,						// left and right
+		ast_op_equal,					// left = right
+		ast_op_not_equal,				// left != right
+		ast_op_less,					// left < right
+		ast_op_greater,					// left > right
+		ast_op_less_or_equal,			// left <= right
+		ast_op_greater_or_equal,		// left >= right
+		ast_op_add,						// left + right
+		ast_op_subtract,				// left - right
+		ast_op_multiply,				// left * right
+		ast_op_divide,					// left / right
+		ast_op_mod,						// left % right
+		ast_op_negate,					// left - right
+		ast_op_union,					// left | right
+		ast_predicate,					// apply predicate to set; next points to next predicate
+		ast_filter,						// select * from left where right
+		ast_string_constant,			// string constant
+		ast_number_constant,			// number constant
+		ast_variable,					// variable
+		ast_func_last,					// last()
+		ast_func_position,				// position()
+		ast_func_count,					// count(left)
+		ast_func_id,					// id(left)
+		ast_func_local_name_0,			// local-name()
+		ast_func_local_name_1,			// local-name(left)
+		ast_func_namespace_uri_0,		// namespace-uri()
+		ast_func_namespace_uri_1,		// namespace-uri(left)
+		ast_func_name_0,				// name()
+		ast_func_name_1,				// name(left)
+		ast_func_string_0,				// string()
+		ast_func_string_1,				// string(left)
+		ast_func_concat,				// concat(left, right, siblings)
+		ast_func_starts_with,			// starts_with(left, right)
+		ast_func_contains,				// contains(left, right)
+		ast_func_substring_before,		// substring-before(left, right)
+		ast_func_substring_after,		// substring-after(left, right)
+		ast_func_substring_2,			// substring(left, right)
+		ast_func_substring_3,			// substring(left, right, third)
+		ast_func_string_length_0,		// string-length()
+		ast_func_string_length_1,		// string-length(left)
+		ast_func_normalize_space_0,		// normalize-space()
+		ast_func_normalize_space_1,		// normalize-space(left)
+		ast_func_translate,				// translate(left, right, third)
+		ast_func_boolean,				// boolean(left)
+		ast_func_not,					// not(left)
+		ast_func_true,					// true()
+		ast_func_false,					// false()
+		ast_func_lang,					// lang(left)
+		ast_func_number_0,				// number()
+		ast_func_number_1,				// number(left)
+		ast_func_sum,					// sum(left)
+		ast_func_floor,					// floor(left)
+		ast_func_ceiling,				// ceiling(left)
+		ast_func_round,					// round(left)
+		ast_step,						// process set left with step
+		ast_step_root,					// select root node
+
+		ast_opt_translate_table,		// translate(left, right, third) where right/third are constants
+		ast_opt_compare_attribute		// @name = 'string'
+	};
+
+	enum axis_t
+	{
+		axis_ancestor,
+		axis_ancestor_or_self,
+		axis_attribute,
+		axis_child,
+		axis_descendant,
+		axis_descendant_or_self,
+		axis_following,
+		axis_following_sibling,
+		axis_namespace,
+		axis_parent,
+		axis_preceding,
+		axis_preceding_sibling,
+		axis_self
+	};
+
+	enum nodetest_t
+	{
+		nodetest_none,
+		nodetest_name,
+		nodetest_type_node,
+		nodetest_type_comment,
+		nodetest_type_pi,
+		nodetest_type_text,
+		nodetest_pi,
+		nodetest_all,
+		nodetest_all_in_namespace
+	};
+
+	enum predicate_t
+	{
+		predicate_default,
+		predicate_posinv,
+		predicate_constant,
+		predicate_constant_one
+	};
+
+	enum nodeset_eval_t
+	{
+		nodeset_eval_all,
+		nodeset_eval_any,
+		nodeset_eval_first
+	};
+
+	template <axis_t N> struct axis_to_type
+	{
+		static const axis_t axis;
+	};
+
+	template <axis_t N> const axis_t axis_to_type<N>::axis = N;
+
+	class xpath_ast_node
+	{
+	private:
+		// node type
+		char _type;
+		char _rettype;
+
+		// for ast_step
+		char _axis;
+
+		// for ast_step/ast_predicate/ast_filter
+		char _test;
+
+		// tree node structure
+		xpath_ast_node* _left;
+		xpath_ast_node* _right;
+		xpath_ast_node* _next;
+
+		union
+		{
+			// value for ast_string_constant
+			const char_t* string;
+			// value for ast_number_constant
+			double number;
+			// variable for ast_variable
+			xpath_variable* variable;
+			// node test for ast_step (node name/namespace/node type/pi target)
+			const char_t* nodetest;
+			// table for ast_opt_translate_table
+			const unsigned char* table;
+		} _data;
+
+		xpath_ast_node(const xpath_ast_node&);
+		xpath_ast_node& operator=(const xpath_ast_node&);
+
+		template <class Comp> static bool compare_eq(xpath_ast_node* lhs, xpath_ast_node* rhs, const xpath_context& c, const xpath_stack& stack, const Comp& comp)
+		{
+			xpath_value_type lt = lhs->rettype(), rt = rhs->rettype();
+
+			if (lt != xpath_type_node_set && rt != xpath_type_node_set)
+			{
+				if (lt == xpath_type_boolean || rt == xpath_type_boolean)
+					return comp(lhs->eval_boolean(c, stack), rhs->eval_boolean(c, stack));
+				else if (lt == xpath_type_number || rt == xpath_type_number)
+					return comp(lhs->eval_number(c, stack), rhs->eval_number(c, stack));
+				else if (lt == xpath_type_string || rt == xpath_type_string)
+				{
+					xpath_allocator_capture cr(stack.result);
+
+					xpath_string ls = lhs->eval_string(c, stack);
+					xpath_string rs = rhs->eval_string(c, stack);
+
+					return comp(ls, rs);
+				}
+			}
+			else if (lt == xpath_type_node_set && rt == xpath_type_node_set)
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				xpath_node_set_raw ls = lhs->eval_node_set(c, stack, nodeset_eval_all);
+				xpath_node_set_raw rs = rhs->eval_node_set(c, stack, nodeset_eval_all);
+
+				for (const xpath_node* li = ls.begin(); li != ls.end(); ++li)
+					for (const xpath_node* ri = rs.begin(); ri != rs.end(); ++ri)
+					{
+						xpath_allocator_capture cri(stack.result);
+
+						if (comp(string_value(*li, stack.result), string_value(*ri, stack.result)))
+							return true;
+					}
+
+				return false;
+			}
+			else
+			{
+				if (lt == xpath_type_node_set)
+				{
+					swap(lhs, rhs);
+					swap(lt, rt);
+				}
+
+				if (lt == xpath_type_boolean)
+					return comp(lhs->eval_boolean(c, stack), rhs->eval_boolean(c, stack));
+				else if (lt == xpath_type_number)
+				{
+					xpath_allocator_capture cr(stack.result);
+
+					double l = lhs->eval_number(c, stack);
+					xpath_node_set_raw rs = rhs->eval_node_set(c, stack, nodeset_eval_all);
+
+					for (const xpath_node* ri = rs.begin(); ri != rs.end(); ++ri)
+					{
+						xpath_allocator_capture cri(stack.result);
+
+						if (comp(l, convert_string_to_number(string_value(*ri, stack.result).c_str())))
+							return true;
+					}
+
+					return false;
+				}
+				else if (lt == xpath_type_string)
+				{
+					xpath_allocator_capture cr(stack.result);
+
+					xpath_string l = lhs->eval_string(c, stack);
+					xpath_node_set_raw rs = rhs->eval_node_set(c, stack, nodeset_eval_all);
+
+					for (const xpath_node* ri = rs.begin(); ri != rs.end(); ++ri)
+					{
+						xpath_allocator_capture cri(stack.result);
+
+						if (comp(l, string_value(*ri, stack.result)))
+							return true;
+					}
+
+					return false;
+				}
+			}
+
+			assert(false && "Wrong types"); // unreachable
+			return false;
+		}
+
+		static bool eval_once(xpath_node_set::type_t type, nodeset_eval_t eval)
+		{
+			return type == xpath_node_set::type_sorted ? eval != nodeset_eval_all : eval == nodeset_eval_any;
+		}
+
+		template <class Comp> static bool compare_rel(xpath_ast_node* lhs, xpath_ast_node* rhs, const xpath_context& c, const xpath_stack& stack, const Comp& comp)
+		{
+			xpath_value_type lt = lhs->rettype(), rt = rhs->rettype();
+
+			if (lt != xpath_type_node_set && rt != xpath_type_node_set)
+				return comp(lhs->eval_number(c, stack), rhs->eval_number(c, stack));
+			else if (lt == xpath_type_node_set && rt == xpath_type_node_set)
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				xpath_node_set_raw ls = lhs->eval_node_set(c, stack, nodeset_eval_all);
+				xpath_node_set_raw rs = rhs->eval_node_set(c, stack, nodeset_eval_all);
+
+				for (const xpath_node* li = ls.begin(); li != ls.end(); ++li)
+				{
+					xpath_allocator_capture cri(stack.result);
+
+					double l = convert_string_to_number(string_value(*li, stack.result).c_str());
+
+					for (const xpath_node* ri = rs.begin(); ri != rs.end(); ++ri)
+					{
+						xpath_allocator_capture crii(stack.result);
+
+						if (comp(l, convert_string_to_number(string_value(*ri, stack.result).c_str())))
+							return true;
+					}
+				}
+
+				return false;
+			}
+			else if (lt != xpath_type_node_set && rt == xpath_type_node_set)
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				double l = lhs->eval_number(c, stack);
+				xpath_node_set_raw rs = rhs->eval_node_set(c, stack, nodeset_eval_all);
+
+				for (const xpath_node* ri = rs.begin(); ri != rs.end(); ++ri)
+				{
+					xpath_allocator_capture cri(stack.result);
+
+					if (comp(l, convert_string_to_number(string_value(*ri, stack.result).c_str())))
+						return true;
+				}
+
+				return false;
+			}
+			else if (lt == xpath_type_node_set && rt != xpath_type_node_set)
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				xpath_node_set_raw ls = lhs->eval_node_set(c, stack, nodeset_eval_all);
+				double r = rhs->eval_number(c, stack);
+
+				for (const xpath_node* li = ls.begin(); li != ls.end(); ++li)
+				{
+					xpath_allocator_capture cri(stack.result);
+
+					if (comp(convert_string_to_number(string_value(*li, stack.result).c_str()), r))
+						return true;
+				}
+
+				return false;
+			}
+			else
+			{
+				assert(false && "Wrong types"); // unreachable
+				return false;
+			}
+		}
+
+		static void apply_predicate_boolean(xpath_node_set_raw& ns, size_t first, xpath_ast_node* expr, const xpath_stack& stack, bool once)
+		{
+			assert(ns.size() >= first);
+			assert(expr->rettype() != xpath_type_number);
+
+			size_t i = 1;
+			size_t size = ns.size() - first;
+
+			xpath_node* last = ns.begin() + first;
+
+			// remove_if... or well, sort of
+			for (xpath_node* it = last; it != ns.end(); ++it, ++i)
+			{
+				xpath_context c(*it, i, size);
+
+				if (expr->eval_boolean(c, stack))
+				{
+					*last++ = *it;
+
+					if (once) break;
+				}
+			}
+
+			ns.truncate(last);
+		}
+
+		static void apply_predicate_number(xpath_node_set_raw& ns, size_t first, xpath_ast_node* expr, const xpath_stack& stack, bool once)
+		{
+			assert(ns.size() >= first);
+			assert(expr->rettype() == xpath_type_number);
+
+			size_t i = 1;
+			size_t size = ns.size() - first;
+
+			xpath_node* last = ns.begin() + first;
+
+			// remove_if... or well, sort of
+			for (xpath_node* it = last; it != ns.end(); ++it, ++i)
+			{
+				xpath_context c(*it, i, size);
+
+				if (expr->eval_number(c, stack) == static_cast<double>(i))
+				{
+					*last++ = *it;
+
+					if (once) break;
+				}
+			}
+
+			ns.truncate(last);
+		}
+
+		static void apply_predicate_number_const(xpath_node_set_raw& ns, size_t first, xpath_ast_node* expr, const xpath_stack& stack)
+		{
+			assert(ns.size() >= first);
+			assert(expr->rettype() == xpath_type_number);
+
+			size_t size = ns.size() - first;
+
+			xpath_node* last = ns.begin() + first;
+
+			xpath_context c(xpath_node(), 1, size);
+
+			double er = expr->eval_number(c, stack);
+
+			if (er >= 1.0 && er <= static_cast<double>(size))
+			{
+				size_t eri = static_cast<size_t>(er);
+
+				if (er == static_cast<double>(eri))
+				{
+					xpath_node r = last[eri - 1];
+
+					*last++ = r;
+				}
+			}
+
+			ns.truncate(last);
+		}
+
+		void apply_predicate(xpath_node_set_raw& ns, size_t first, const xpath_stack& stack, bool once)
+		{
+			if (ns.size() == first) return;
+
+			assert(_type == ast_filter || _type == ast_predicate);
+
+			if (_test == predicate_constant || _test == predicate_constant_one)
+				apply_predicate_number_const(ns, first, _right, stack);
+			else if (_right->rettype() == xpath_type_number)
+				apply_predicate_number(ns, first, _right, stack, once);
+			else
+				apply_predicate_boolean(ns, first, _right, stack, once);
+		}
+
+		void apply_predicates(xpath_node_set_raw& ns, size_t first, const xpath_stack& stack, nodeset_eval_t eval)
+		{
+			if (ns.size() == first) return;
+
+			bool last_once = eval_once(ns.type(), eval);
+
+			for (xpath_ast_node* pred = _right; pred; pred = pred->_next)
+				pred->apply_predicate(ns, first, stack, !pred->_next && last_once);
+		}
+
+		bool step_push(xpath_node_set_raw& ns, xml_attribute_struct* a, xml_node_struct* parent, xpath_allocator* alloc)
+		{
+			assert(a);
+
+			const char_t* name = a->name ? a->name + 0 : PUGIXML_TEXT("");
+
+			switch (_test)
+			{
+			case nodetest_name:
+				if (strequal(name, _data.nodetest) && is_xpath_attribute(name))
+				{
+					ns.push_back(xpath_node(xml_attribute(a), xml_node(parent)), alloc);
+					return true;
+				}
+				break;
+
+			case nodetest_type_node:
+			case nodetest_all:
+				if (is_xpath_attribute(name))
+				{
+					ns.push_back(xpath_node(xml_attribute(a), xml_node(parent)), alloc);
+					return true;
+				}
+				break;
+
+			case nodetest_all_in_namespace:
+				if (starts_with(name, _data.nodetest) && is_xpath_attribute(name))
+				{
+					ns.push_back(xpath_node(xml_attribute(a), xml_node(parent)), alloc);
+					return true;
+				}
+				break;
+
+			default:
+				;
+			}
+
+			return false;
+		}
+
+		bool step_push(xpath_node_set_raw& ns, xml_node_struct* n, xpath_allocator* alloc)
+		{
+			assert(n);
+
+			xml_node_type type = PUGI__NODETYPE(n);
+
+			switch (_test)
+			{
+			case nodetest_name:
+				if (type == node_element && n->name && strequal(n->name, _data.nodetest))
+				{
+					ns.push_back(xml_node(n), alloc);
+					return true;
+				}
+				break;
+
+			case nodetest_type_node:
+				ns.push_back(xml_node(n), alloc);
+				return true;
+
+			case nodetest_type_comment:
+				if (type == node_comment)
+				{
+					ns.push_back(xml_node(n), alloc);
+					return true;
+				}
+				break;
+
+			case nodetest_type_text:
+				if (type == node_pcdata || type == node_cdata)
+				{
+					ns.push_back(xml_node(n), alloc);
+					return true;
+				}
+				break;
+
+			case nodetest_type_pi:
+				if (type == node_pi)
+				{
+					ns.push_back(xml_node(n), alloc);
+					return true;
+				}
+				break;
+
+			case nodetest_pi:
+				if (type == node_pi && n->name && strequal(n->name, _data.nodetest))
+				{
+					ns.push_back(xml_node(n), alloc);
+					return true;
+				}
+				break;
+
+			case nodetest_all:
+				if (type == node_element)
+				{
+					ns.push_back(xml_node(n), alloc);
+					return true;
+				}
+				break;
+
+			case nodetest_all_in_namespace:
+				if (type == node_element && n->name && starts_with(n->name, _data.nodetest))
+				{
+					ns.push_back(xml_node(n), alloc);
+					return true;
+				}
+				break;
+
+			default:
+				assert(false && "Unknown axis"); // unreachable
+			}
+
+			return false;
+		}
+
+		template <class T> void step_fill(xpath_node_set_raw& ns, xml_node_struct* n, xpath_allocator* alloc, bool once, T)
+		{
+			const axis_t axis = T::axis;
+
+			switch (axis)
+			{
+			case axis_attribute:
+			{
+				for (xml_attribute_struct* a = n->first_attribute; a; a = a->next_attribute)
+					if (step_push(ns, a, n, alloc) & once)
+						return;
+
+				break;
+			}
+
+			case axis_child:
+			{
+				for (xml_node_struct* c = n->first_child; c; c = c->next_sibling)
+					if (step_push(ns, c, alloc) & once)
+						return;
+
+				break;
+			}
+
+			case axis_descendant:
+			case axis_descendant_or_self:
+			{
+				if (axis == axis_descendant_or_self)
+					if (step_push(ns, n, alloc) & once)
+						return;
+
+				xml_node_struct* cur = n->first_child;
+
+				while (cur)
+				{
+					if (step_push(ns, cur, alloc) & once)
+						return;
+
+					if (cur->first_child)
+						cur = cur->first_child;
+					else
+					{
+						while (!cur->next_sibling)
+						{
+							cur = cur->parent;
+
+							if (cur == n) return;
+						}
+
+						cur = cur->next_sibling;
+					}
+				}
+
+				break;
+			}
+
+			case axis_following_sibling:
+			{
+				for (xml_node_struct* c = n->next_sibling; c; c = c->next_sibling)
+					if (step_push(ns, c, alloc) & once)
+						return;
+
+				break;
+			}
+
+			case axis_preceding_sibling:
+			{
+				for (xml_node_struct* c = n->prev_sibling_c; c->next_sibling; c = c->prev_sibling_c)
+					if (step_push(ns, c, alloc) & once)
+						return;
+
+				break;
+			}
+
+			case axis_following:
+			{
+				xml_node_struct* cur = n;
+
+				// exit from this node so that we don't include descendants
+				while (!cur->next_sibling)
+				{
+					cur = cur->parent;
+
+					if (!cur) return;
+				}
+
+				cur = cur->next_sibling;
+
+				while (cur)
+				{
+					if (step_push(ns, cur, alloc) & once)
+						return;
+
+					if (cur->first_child)
+						cur = cur->first_child;
+					else
+					{
+						while (!cur->next_sibling)
+						{
+							cur = cur->parent;
+
+							if (!cur) return;
+						}
+
+						cur = cur->next_sibling;
+					}
+				}
+
+				break;
+			}
+
+			case axis_preceding:
+			{
+				xml_node_struct* cur = n;
+
+				// exit from this node so that we don't include descendants
+				while (!cur->prev_sibling_c->next_sibling)
+				{
+					cur = cur->parent;
+
+					if (!cur) return;
+				}
+
+				cur = cur->prev_sibling_c;
+
+				while (cur)
+				{
+					if (cur->first_child)
+						cur = cur->first_child->prev_sibling_c;
+					else
+					{
+						// leaf node, can't be ancestor
+						if (step_push(ns, cur, alloc) & once)
+							return;
+
+						while (!cur->prev_sibling_c->next_sibling)
+						{
+							cur = cur->parent;
+
+							if (!cur) return;
+
+							if (!node_is_ancestor(cur, n))
+								if (step_push(ns, cur, alloc) & once)
+									return;
+						}
+
+						cur = cur->prev_sibling_c;
+					}
+				}
+
+				break;
+			}
+
+			case axis_ancestor:
+			case axis_ancestor_or_self:
+			{
+				if (axis == axis_ancestor_or_self)
+					if (step_push(ns, n, alloc) & once)
+						return;
+
+				xml_node_struct* cur = n->parent;
+
+				while (cur)
+				{
+					if (step_push(ns, cur, alloc) & once)
+						return;
+
+					cur = cur->parent;
+				}
+
+				break;
+			}
+
+			case axis_self:
+			{
+				step_push(ns, n, alloc);
+
+				break;
+			}
+
+			case axis_parent:
+			{
+				if (n->parent)
+					step_push(ns, n->parent, alloc);
+
+				break;
+			}
+
+			default:
+				assert(false && "Unimplemented axis"); // unreachable
+			}
+		}
+
+		template <class T> void step_fill(xpath_node_set_raw& ns, xml_attribute_struct* a, xml_node_struct* p, xpath_allocator* alloc, bool once, T v)
+		{
+			const axis_t axis = T::axis;
+
+			switch (axis)
+			{
+			case axis_ancestor:
+			case axis_ancestor_or_self:
+			{
+				if (axis == axis_ancestor_or_self && _test == nodetest_type_node) // reject attributes based on principal node type test
+					if (step_push(ns, a, p, alloc) & once)
+						return;
+
+				xml_node_struct* cur = p;
+
+				while (cur)
+				{
+					if (step_push(ns, cur, alloc) & once)
+						return;
+
+					cur = cur->parent;
+				}
+
+				break;
+			}
+
+			case axis_descendant_or_self:
+			case axis_self:
+			{
+				if (_test == nodetest_type_node) // reject attributes based on principal node type test
+					step_push(ns, a, p, alloc);
+
+				break;
+			}
+
+			case axis_following:
+			{
+				xml_node_struct* cur = p;
+
+				while (cur)
+				{
+					if (cur->first_child)
+						cur = cur->first_child;
+					else
+					{
+						while (!cur->next_sibling)
+						{
+							cur = cur->parent;
+
+							if (!cur) return;
+						}
+
+						cur = cur->next_sibling;
+					}
+
+					if (step_push(ns, cur, alloc) & once)
+						return;
+				}
+
+				break;
+			}
+
+			case axis_parent:
+			{
+				step_push(ns, p, alloc);
+
+				break;
+			}
+
+			case axis_preceding:
+			{
+				// preceding:: axis does not include attribute nodes and attribute ancestors (they are the same as parent's ancestors), so we can reuse node preceding
+				step_fill(ns, p, alloc, once, v);
+				break;
+			}
+
+			default:
+				assert(false && "Unimplemented axis"); // unreachable
+			}
+		}
+
+		template <class T> void step_fill(xpath_node_set_raw& ns, const xpath_node& xn, xpath_allocator* alloc, bool once, T v)
+		{
+			const axis_t axis = T::axis;
+			const bool axis_has_attributes = (axis == axis_ancestor || axis == axis_ancestor_or_self || axis == axis_descendant_or_self || axis == axis_following || axis == axis_parent || axis == axis_preceding || axis == axis_self);
+
+			if (xn.node())
+				step_fill(ns, xn.node().internal_object(), alloc, once, v);
+			else if (axis_has_attributes && xn.attribute() && xn.parent())
+				step_fill(ns, xn.attribute().internal_object(), xn.parent().internal_object(), alloc, once, v);
+		}
+
+		template <class T> xpath_node_set_raw step_do(const xpath_context& c, const xpath_stack& stack, nodeset_eval_t eval, T v)
+		{
+			const axis_t axis = T::axis;
+			const bool axis_reverse = (axis == axis_ancestor || axis == axis_ancestor_or_self || axis == axis_preceding || axis == axis_preceding_sibling);
+			const xpath_node_set::type_t axis_type = axis_reverse ? xpath_node_set::type_sorted_reverse : xpath_node_set::type_sorted;
+
+			bool once =
+				(axis == axis_attribute && _test == nodetest_name) ||
+				(!_right && eval_once(axis_type, eval)) ||
+			    // coverity[mixed_enums]
+				(_right && !_right->_next && _right->_test == predicate_constant_one);
+
+			xpath_node_set_raw ns;
+			ns.set_type(axis_type);
+
+			if (_left)
+			{
+				xpath_node_set_raw s = _left->eval_node_set(c, stack, nodeset_eval_all);
+
+				// self axis preserves the original order
+				if (axis == axis_self) ns.set_type(s.type());
+
+				for (const xpath_node* it = s.begin(); it != s.end(); ++it)
+				{
+					size_t size = ns.size();
+
+					// in general, all axes generate elements in a particular order, but there is no order guarantee if axis is applied to two nodes
+					if (axis != axis_self && size != 0) ns.set_type(xpath_node_set::type_unsorted);
+
+					step_fill(ns, *it, stack.result, once, v);
+					if (_right) apply_predicates(ns, size, stack, eval);
+				}
+			}
+			else
+			{
+				step_fill(ns, c.n, stack.result, once, v);
+				if (_right) apply_predicates(ns, 0, stack, eval);
+			}
+
+			// child, attribute and self axes always generate unique set of nodes
+			// for other axis, if the set stayed sorted, it stayed unique because the traversal algorithms do not visit the same node twice
+			if (axis != axis_child && axis != axis_attribute && axis != axis_self && ns.type() == xpath_node_set::type_unsorted)
+				ns.remove_duplicates(stack.temp);
+
+			return ns;
+		}
+
+	public:
+		xpath_ast_node(ast_type_t type, xpath_value_type rettype_, const char_t* value):
+			_type(static_cast<char>(type)), _rettype(static_cast<char>(rettype_)), _axis(0), _test(0), _left(0), _right(0), _next(0)
+		{
+			assert(type == ast_string_constant);
+			_data.string = value;
+		}
+
+		xpath_ast_node(ast_type_t type, xpath_value_type rettype_, double value):
+			_type(static_cast<char>(type)), _rettype(static_cast<char>(rettype_)), _axis(0), _test(0), _left(0), _right(0), _next(0)
+		{
+			assert(type == ast_number_constant);
+			_data.number = value;
+		}
+
+		xpath_ast_node(ast_type_t type, xpath_value_type rettype_, xpath_variable* value):
+			_type(static_cast<char>(type)), _rettype(static_cast<char>(rettype_)), _axis(0), _test(0), _left(0), _right(0), _next(0)
+		{
+			assert(type == ast_variable);
+			_data.variable = value;
+		}
+
+		xpath_ast_node(ast_type_t type, xpath_value_type rettype_, xpath_ast_node* left = 0, xpath_ast_node* right = 0):
+			_type(static_cast<char>(type)), _rettype(static_cast<char>(rettype_)), _axis(0), _test(0), _left(left), _right(right), _next(0)
+		{
+		}
+
+		xpath_ast_node(ast_type_t type, xpath_ast_node* left, axis_t axis, nodetest_t test, const char_t* contents):
+			_type(static_cast<char>(type)), _rettype(xpath_type_node_set), _axis(static_cast<char>(axis)), _test(static_cast<char>(test)), _left(left), _right(0), _next(0)
+		{
+			assert(type == ast_step);
+			_data.nodetest = contents;
+		}
+
+		xpath_ast_node(ast_type_t type, xpath_ast_node* left, xpath_ast_node* right, predicate_t test):
+			_type(static_cast<char>(type)), _rettype(xpath_type_node_set), _axis(0), _test(static_cast<char>(test)), _left(left), _right(right), _next(0)
+		{
+			assert(type == ast_filter || type == ast_predicate);
+		}
+
+		void set_next(xpath_ast_node* value)
+		{
+			_next = value;
+		}
+
+		void set_right(xpath_ast_node* value)
+		{
+			_right = value;
+		}
+
+		bool eval_boolean(const xpath_context& c, const xpath_stack& stack)
+		{
+			switch (_type)
+			{
+			case ast_op_or:
+				return _left->eval_boolean(c, stack) || _right->eval_boolean(c, stack);
+
+			case ast_op_and:
+				return _left->eval_boolean(c, stack) && _right->eval_boolean(c, stack);
+
+			case ast_op_equal:
+				return compare_eq(_left, _right, c, stack, equal_to());
+
+			case ast_op_not_equal:
+				return compare_eq(_left, _right, c, stack, not_equal_to());
+
+			case ast_op_less:
+				return compare_rel(_left, _right, c, stack, less());
+
+			case ast_op_greater:
+				return compare_rel(_right, _left, c, stack, less());
+
+			case ast_op_less_or_equal:
+				return compare_rel(_left, _right, c, stack, less_equal());
+
+			case ast_op_greater_or_equal:
+				return compare_rel(_right, _left, c, stack, less_equal());
+
+			case ast_func_starts_with:
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				xpath_string lr = _left->eval_string(c, stack);
+				xpath_string rr = _right->eval_string(c, stack);
+
+				return starts_with(lr.c_str(), rr.c_str());
+			}
+
+			case ast_func_contains:
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				xpath_string lr = _left->eval_string(c, stack);
+				xpath_string rr = _right->eval_string(c, stack);
+
+				return find_substring(lr.c_str(), rr.c_str()) != 0;
+			}
+
+			case ast_func_boolean:
+				return _left->eval_boolean(c, stack);
+
+			case ast_func_not:
+				return !_left->eval_boolean(c, stack);
+
+			case ast_func_true:
+				return true;
+
+			case ast_func_false:
+				return false;
+
+			case ast_func_lang:
+			{
+				if (c.n.attribute()) return false;
+
+				xpath_allocator_capture cr(stack.result);
+
+				xpath_string lang = _left->eval_string(c, stack);
+
+				for (xml_node n = c.n.node(); n; n = n.parent())
+				{
+					xml_attribute a = n.attribute(PUGIXML_TEXT("xml:lang"));
+
+					if (a)
+					{
+						const char_t* value = a.value();
+
+						// strnicmp / strncasecmp is not portable
+						for (const char_t* lit = lang.c_str(); *lit; ++lit)
+						{
+							if (tolower_ascii(*lit) != tolower_ascii(*value)) return false;
+							++value;
+						}
+
+						return *value == 0 || *value == '-';
+					}
+				}
+
+				return false;
+			}
+
+			case ast_opt_compare_attribute:
+			{
+				const char_t* value = (_right->_type == ast_string_constant) ? _right->_data.string : _right->_data.variable->get_string();
+
+				xml_attribute attr = c.n.node().attribute(_left->_data.nodetest);
+
+				return attr && strequal(attr.value(), value) && is_xpath_attribute(attr.name());
+			}
+
+			case ast_variable:
+			{
+				assert(_rettype == _data.variable->type());
+
+				if (_rettype == xpath_type_boolean)
+					return _data.variable->get_boolean();
+
+				// variable needs to be converted to the correct type, this is handled by the fallthrough block below
+				break;
+			}
+
+			default:
+				;
+			}
+
+			// none of the ast types that return the value directly matched, we need to perform type conversion
+			switch (_rettype)
+			{
+			case xpath_type_number:
+				return convert_number_to_boolean(eval_number(c, stack));
+
+			case xpath_type_string:
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				return !eval_string(c, stack).empty();
+			}
+
+			case xpath_type_node_set:
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				return !eval_node_set(c, stack, nodeset_eval_any).empty();
+			}
+
+			default:
+				assert(false && "Wrong expression for return type boolean"); // unreachable
+				return false;
+			}
+		}
+
+		double eval_number(const xpath_context& c, const xpath_stack& stack)
+		{
+			switch (_type)
+			{
+			case ast_op_add:
+				return _left->eval_number(c, stack) + _right->eval_number(c, stack);
+
+			case ast_op_subtract:
+				return _left->eval_number(c, stack) - _right->eval_number(c, stack);
+
+			case ast_op_multiply:
+				return _left->eval_number(c, stack) * _right->eval_number(c, stack);
+
+			case ast_op_divide:
+				return _left->eval_number(c, stack) / _right->eval_number(c, stack);
+
+			case ast_op_mod:
+				return fmod(_left->eval_number(c, stack), _right->eval_number(c, stack));
+
+			case ast_op_negate:
+				return -_left->eval_number(c, stack);
+
+			case ast_number_constant:
+				return _data.number;
+
+			case ast_func_last:
+				return static_cast<double>(c.size);
+
+			case ast_func_position:
+				return static_cast<double>(c.position);
+
+			case ast_func_count:
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				return static_cast<double>(_left->eval_node_set(c, stack, nodeset_eval_all).size());
+			}
+
+			case ast_func_string_length_0:
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				return static_cast<double>(string_value(c.n, stack.result).length());
+			}
+
+			case ast_func_string_length_1:
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				return static_cast<double>(_left->eval_string(c, stack).length());
+			}
+
+			case ast_func_number_0:
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				return convert_string_to_number(string_value(c.n, stack.result).c_str());
+			}
+
+			case ast_func_number_1:
+				return _left->eval_number(c, stack);
+
+			case ast_func_sum:
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				double r = 0;
+
+				xpath_node_set_raw ns = _left->eval_node_set(c, stack, nodeset_eval_all);
+
+				for (const xpath_node* it = ns.begin(); it != ns.end(); ++it)
+				{
+					xpath_allocator_capture cri(stack.result);
+
+					r += convert_string_to_number(string_value(*it, stack.result).c_str());
+				}
+
+				return r;
+			}
+
+			case ast_func_floor:
+			{
+				double r = _left->eval_number(c, stack);
+
+				return r == r ? floor(r) : r;
+			}
+
+			case ast_func_ceiling:
+			{
+				double r = _left->eval_number(c, stack);
+
+				return r == r ? ceil(r) : r;
+			}
+
+			case ast_func_round:
+				return round_nearest_nzero(_left->eval_number(c, stack));
+
+			case ast_variable:
+			{
+				assert(_rettype == _data.variable->type());
+
+				if (_rettype == xpath_type_number)
+					return _data.variable->get_number();
+
+				// variable needs to be converted to the correct type, this is handled by the fallthrough block below
+				break;
+			}
+
+			default:
+				;
+			}
+
+			// none of the ast types that return the value directly matched, we need to perform type conversion
+			switch (_rettype)
+			{
+			case xpath_type_boolean:
+				return eval_boolean(c, stack) ? 1 : 0;
+
+			case xpath_type_string:
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				return convert_string_to_number(eval_string(c, stack).c_str());
+			}
+
+			case xpath_type_node_set:
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				return convert_string_to_number(eval_string(c, stack).c_str());
+			}
+
+			default:
+				assert(false && "Wrong expression for return type number"); // unreachable
+				return 0;
+			}
+		}
+
+		xpath_string eval_string_concat(const xpath_context& c, const xpath_stack& stack)
+		{
+			assert(_type == ast_func_concat);
+
+			xpath_allocator_capture ct(stack.temp);
+
+			// count the string number
+			size_t count = 1;
+			for (xpath_ast_node* nc = _right; nc; nc = nc->_next) count++;
+
+			// allocate a buffer for temporary string objects
+			xpath_string* buffer = static_cast<xpath_string*>(stack.temp->allocate(count * sizeof(xpath_string)));
+			if (!buffer) return xpath_string();
+
+			// evaluate all strings to temporary stack
+			xpath_stack swapped_stack = {stack.temp, stack.result};
+
+			buffer[0] = _left->eval_string(c, swapped_stack);
+
+			size_t pos = 1;
+			for (xpath_ast_node* n = _right; n; n = n->_next, ++pos) buffer[pos] = n->eval_string(c, swapped_stack);
+			assert(pos == count);
+
+			// get total length
+			size_t length = 0;
+			for (size_t i = 0; i < count; ++i) length += buffer[i].length();
+
+			// create final string
+			char_t* result = static_cast<char_t*>(stack.result->allocate((length + 1) * sizeof(char_t)));
+			if (!result) return xpath_string();
+
+			char_t* ri = result;
+
+			for (size_t j = 0; j < count; ++j)
+				for (const char_t* bi = buffer[j].c_str(); *bi; ++bi)
+					*ri++ = *bi;
+
+			*ri = 0;
+
+			return xpath_string::from_heap_preallocated(result, ri);
+		}
+
+		xpath_string eval_string(const xpath_context& c, const xpath_stack& stack)
+		{
+			switch (_type)
+			{
+			case ast_string_constant:
+				return xpath_string::from_const(_data.string);
+
+			case ast_func_local_name_0:
+			{
+				xpath_node na = c.n;
+
+				return xpath_string::from_const(local_name(na));
+			}
+
+			case ast_func_local_name_1:
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				xpath_node_set_raw ns = _left->eval_node_set(c, stack, nodeset_eval_first);
+				xpath_node na = ns.first();
+
+				return xpath_string::from_const(local_name(na));
+			}
+
+			case ast_func_name_0:
+			{
+				xpath_node na = c.n;
+
+				return xpath_string::from_const(qualified_name(na));
+			}
+
+			case ast_func_name_1:
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				xpath_node_set_raw ns = _left->eval_node_set(c, stack, nodeset_eval_first);
+				xpath_node na = ns.first();
+
+				return xpath_string::from_const(qualified_name(na));
+			}
+
+			case ast_func_namespace_uri_0:
+			{
+				xpath_node na = c.n;
+
+				return xpath_string::from_const(namespace_uri(na));
+			}
+
+			case ast_func_namespace_uri_1:
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				xpath_node_set_raw ns = _left->eval_node_set(c, stack, nodeset_eval_first);
+				xpath_node na = ns.first();
+
+				return xpath_string::from_const(namespace_uri(na));
+			}
+
+			case ast_func_string_0:
+				return string_value(c.n, stack.result);
+
+			case ast_func_string_1:
+				return _left->eval_string(c, stack);
+
+			case ast_func_concat:
+				return eval_string_concat(c, stack);
+
+			case ast_func_substring_before:
+			{
+				xpath_allocator_capture cr(stack.temp);
+
+				xpath_stack swapped_stack = {stack.temp, stack.result};
+
+				xpath_string s = _left->eval_string(c, swapped_stack);
+				xpath_string p = _right->eval_string(c, swapped_stack);
+
+				const char_t* pos = find_substring(s.c_str(), p.c_str());
+
+				return pos ? xpath_string::from_heap(s.c_str(), pos, stack.result) : xpath_string();
+			}
+
+			case ast_func_substring_after:
+			{
+				xpath_allocator_capture cr(stack.temp);
+
+				xpath_stack swapped_stack = {stack.temp, stack.result};
+
+				xpath_string s = _left->eval_string(c, swapped_stack);
+				xpath_string p = _right->eval_string(c, swapped_stack);
+
+				const char_t* pos = find_substring(s.c_str(), p.c_str());
+				if (!pos) return xpath_string();
+
+				const char_t* rbegin = pos + p.length();
+				const char_t* rend = s.c_str() + s.length();
+
+				return s.uses_heap() ? xpath_string::from_heap(rbegin, rend, stack.result) : xpath_string::from_const(rbegin);
+			}
+
+			case ast_func_substring_2:
+			{
+				xpath_allocator_capture cr(stack.temp);
+
+				xpath_stack swapped_stack = {stack.temp, stack.result};
+
+				xpath_string s = _left->eval_string(c, swapped_stack);
+				size_t s_length = s.length();
+
+				double first = round_nearest(_right->eval_number(c, stack));
+
+				if (is_nan(first)) return xpath_string(); // NaN
+				else if (first >= static_cast<double>(s_length + 1)) return xpath_string();
+
+				size_t pos = first < 1 ? 1 : static_cast<size_t>(first);
+				assert(1 <= pos && pos <= s_length + 1);
+
+				const char_t* rbegin = s.c_str() + (pos - 1);
+				const char_t* rend = s.c_str() + s.length();
+
+				return s.uses_heap() ? xpath_string::from_heap(rbegin, rend, stack.result) : xpath_string::from_const(rbegin);
+			}
+
+			case ast_func_substring_3:
+			{
+				xpath_allocator_capture cr(stack.temp);
+
+				xpath_stack swapped_stack = {stack.temp, stack.result};
+
+				xpath_string s = _left->eval_string(c, swapped_stack);
+				size_t s_length = s.length();
+
+				double first = round_nearest(_right->eval_number(c, stack));
+				double last = first + round_nearest(_right->_next->eval_number(c, stack));
+
+				if (is_nan(first) || is_nan(last)) return xpath_string();
+				else if (first >= static_cast<double>(s_length + 1)) return xpath_string();
+				else if (first >= last) return xpath_string();
+				else if (last < 1) return xpath_string();
+
+				size_t pos = first < 1 ? 1 : static_cast<size_t>(first);
+				size_t end = last >= static_cast<double>(s_length + 1) ? s_length + 1 : static_cast<size_t>(last);
+
+				assert(1 <= pos && pos <= end && end <= s_length + 1);
+				const char_t* rbegin = s.c_str() + (pos - 1);
+				const char_t* rend = s.c_str() + (end - 1);
+
+				return (end == s_length + 1 && !s.uses_heap()) ? xpath_string::from_const(rbegin) : xpath_string::from_heap(rbegin, rend, stack.result);
+			}
+
+			case ast_func_normalize_space_0:
+			{
+				xpath_string s = string_value(c.n, stack.result);
+
+				char_t* begin = s.data(stack.result);
+				if (!begin) return xpath_string();
+
+				char_t* end = normalize_space(begin);
+
+				return xpath_string::from_heap_preallocated(begin, end);
+			}
+
+			case ast_func_normalize_space_1:
+			{
+				xpath_string s = _left->eval_string(c, stack);
+
+				char_t* begin = s.data(stack.result);
+				if (!begin) return xpath_string();
+
+				char_t* end = normalize_space(begin);
+
+				return xpath_string::from_heap_preallocated(begin, end);
+			}
+
+			case ast_func_translate:
+			{
+				xpath_allocator_capture cr(stack.temp);
+
+				xpath_stack swapped_stack = {stack.temp, stack.result};
+
+				xpath_string s = _left->eval_string(c, stack);
+				xpath_string from = _right->eval_string(c, swapped_stack);
+				xpath_string to = _right->_next->eval_string(c, swapped_stack);
+
+				char_t* begin = s.data(stack.result);
+				if (!begin) return xpath_string();
+
+				char_t* end = translate(begin, from.c_str(), to.c_str(), to.length());
+
+				return xpath_string::from_heap_preallocated(begin, end);
+			}
+
+			case ast_opt_translate_table:
+			{
+				xpath_string s = _left->eval_string(c, stack);
+
+				char_t* begin = s.data(stack.result);
+				if (!begin) return xpath_string();
+
+				char_t* end = translate_table(begin, _data.table);
+
+				return xpath_string::from_heap_preallocated(begin, end);
+			}
+
+			case ast_variable:
+			{
+				assert(_rettype == _data.variable->type());
+
+				if (_rettype == xpath_type_string)
+					return xpath_string::from_const(_data.variable->get_string());
+
+				// variable needs to be converted to the correct type, this is handled by the fallthrough block below
+				break;
+			}
+
+			default:
+				;
+			}
+
+			// none of the ast types that return the value directly matched, we need to perform type conversion
+			switch (_rettype)
+			{
+			case xpath_type_boolean:
+				return xpath_string::from_const(eval_boolean(c, stack) ? PUGIXML_TEXT("true") : PUGIXML_TEXT("false"));
+
+			case xpath_type_number:
+				return convert_number_to_string(eval_number(c, stack), stack.result);
+
+			case xpath_type_node_set:
+			{
+				xpath_allocator_capture cr(stack.temp);
+
+				xpath_stack swapped_stack = {stack.temp, stack.result};
+
+				xpath_node_set_raw ns = eval_node_set(c, swapped_stack, nodeset_eval_first);
+				return ns.empty() ? xpath_string() : string_value(ns.first(), stack.result);
+			}
+
+			default:
+				assert(false && "Wrong expression for return type string"); // unreachable
+				return xpath_string();
+			}
+		}
+
+		xpath_node_set_raw eval_node_set(const xpath_context& c, const xpath_stack& stack, nodeset_eval_t eval)
+		{
+			switch (_type)
+			{
+			case ast_op_union:
+			{
+				xpath_allocator_capture cr(stack.temp);
+
+				xpath_stack swapped_stack = {stack.temp, stack.result};
+
+				xpath_node_set_raw ls = _left->eval_node_set(c, stack, eval);
+				xpath_node_set_raw rs = _right->eval_node_set(c, swapped_stack, eval);
+
+				// we can optimize merging two sorted sets, but this is a very rare operation, so don't bother
+				ls.set_type(xpath_node_set::type_unsorted);
+
+				ls.append(rs.begin(), rs.end(), stack.result);
+				ls.remove_duplicates(stack.temp);
+
+				return ls;
+			}
+
+			case ast_filter:
+			{
+				xpath_node_set_raw set = _left->eval_node_set(c, stack, _test == predicate_constant_one ? nodeset_eval_first : nodeset_eval_all);
+
+				// either expression is a number or it contains position() call; sort by document order
+				if (_test != predicate_posinv) set.sort_do();
+
+				bool once = eval_once(set.type(), eval);
+
+				apply_predicate(set, 0, stack, once);
+
+				return set;
+			}
+
+			case ast_func_id:
+				return xpath_node_set_raw();
+
+			case ast_step:
+			{
+				switch (_axis)
+				{
+				case axis_ancestor:
+					return step_do(c, stack, eval, axis_to_type<axis_ancestor>());
+
+				case axis_ancestor_or_self:
+					return step_do(c, stack, eval, axis_to_type<axis_ancestor_or_self>());
+
+				case axis_attribute:
+					return step_do(c, stack, eval, axis_to_type<axis_attribute>());
+
+				case axis_child:
+					return step_do(c, stack, eval, axis_to_type<axis_child>());
+
+				case axis_descendant:
+					return step_do(c, stack, eval, axis_to_type<axis_descendant>());
+
+				case axis_descendant_or_self:
+					return step_do(c, stack, eval, axis_to_type<axis_descendant_or_self>());
+
+				case axis_following:
+					return step_do(c, stack, eval, axis_to_type<axis_following>());
+
+				case axis_following_sibling:
+					return step_do(c, stack, eval, axis_to_type<axis_following_sibling>());
+
+				case axis_namespace:
+					// namespaced axis is not supported
+					return xpath_node_set_raw();
+
+				case axis_parent:
+					return step_do(c, stack, eval, axis_to_type<axis_parent>());
+
+				case axis_preceding:
+					return step_do(c, stack, eval, axis_to_type<axis_preceding>());
+
+				case axis_preceding_sibling:
+					return step_do(c, stack, eval, axis_to_type<axis_preceding_sibling>());
+
+				case axis_self:
+					return step_do(c, stack, eval, axis_to_type<axis_self>());
+
+				default:
+					assert(false && "Unknown axis"); // unreachable
+					return xpath_node_set_raw();
+				}
+			}
+
+			case ast_step_root:
+			{
+				assert(!_right); // root step can't have any predicates
+
+				xpath_node_set_raw ns;
+
+				ns.set_type(xpath_node_set::type_sorted);
+
+				if (c.n.node()) ns.push_back(c.n.node().root(), stack.result);
+				else if (c.n.attribute()) ns.push_back(c.n.parent().root(), stack.result);
+
+				return ns;
+			}
+
+			case ast_variable:
+			{
+				assert(_rettype == _data.variable->type());
+
+				if (_rettype == xpath_type_node_set)
+				{
+					const xpath_node_set& s = _data.variable->get_node_set();
+
+					xpath_node_set_raw ns;
+
+					ns.set_type(s.type());
+					ns.append(s.begin(), s.end(), stack.result);
+
+					return ns;
+				}
+
+				// variable needs to be converted to the correct type, this is handled by the fallthrough block below
+				break;
+			}
+
+			default:
+				;
+			}
+
+			// none of the ast types that return the value directly matched, but conversions to node set are invalid
+			assert(false && "Wrong expression for return type node set"); // unreachable
+			return xpath_node_set_raw();
+		}
+
+		void optimize(xpath_allocator* alloc)
+		{
+			if (_left)
+				_left->optimize(alloc);
+
+			if (_right)
+				_right->optimize(alloc);
+
+			if (_next)
+				_next->optimize(alloc);
+
+			// coverity[var_deref_model]
+			optimize_self(alloc);
+		}
+
+		void optimize_self(xpath_allocator* alloc)
+		{
+			// Rewrite [position()=expr] with [expr]
+			// Note that this step has to go before classification to recognize [position()=1]
+			if ((_type == ast_filter || _type == ast_predicate) &&
+				_right && // workaround for clang static analyzer (_right is never null for ast_filter/ast_predicate)
+				_right->_type == ast_op_equal && _right->_left->_type == ast_func_position && _right->_right->_rettype == xpath_type_number)
+			{
+				_right = _right->_right;
+			}
+
+			// Classify filter/predicate ops to perform various optimizations during evaluation
+			if ((_type == ast_filter || _type == ast_predicate) && _right) // workaround for clang static analyzer (_right is never null for ast_filter/ast_predicate)
+			{
+				assert(_test == predicate_default);
+
+				if (_right->_type == ast_number_constant && _right->_data.number == 1.0)
+					_test = predicate_constant_one;
+				else if (_right->_rettype == xpath_type_number && (_right->_type == ast_number_constant || _right->_type == ast_variable || _right->_type == ast_func_last))
+					_test = predicate_constant;
+				else if (_right->_rettype != xpath_type_number && _right->is_posinv_expr())
+					_test = predicate_posinv;
+			}
+
+			// Rewrite descendant-or-self::node()/child::foo with descendant::foo
+			// The former is a full form of //foo, the latter is much faster since it executes the node test immediately
+			// Do a similar kind of rewrite for self/descendant/descendant-or-self axes
+			// Note that we only rewrite positionally invariant steps (//foo[1] != /descendant::foo[1])
+			if (_type == ast_step && (_axis == axis_child || _axis == axis_self || _axis == axis_descendant || _axis == axis_descendant_or_self) &&
+				_left && _left->_type == ast_step && _left->_axis == axis_descendant_or_self && _left->_test == nodetest_type_node && !_left->_right &&
+				is_posinv_step())
+			{
+				if (_axis == axis_child || _axis == axis_descendant)
+					_axis = axis_descendant;
+				else
+					_axis = axis_descendant_or_self;
+
+				_left = _left->_left;
+			}
+
+			// Use optimized lookup table implementation for translate() with constant arguments
+			if (_type == ast_func_translate &&
+				_right && // workaround for clang static analyzer (_right is never null for ast_func_translate)
+				_right->_type == ast_string_constant && _right->_next->_type == ast_string_constant)
+			{
+				unsigned char* table = translate_table_generate(alloc, _right->_data.string, _right->_next->_data.string);
+
+				if (table)
+				{
+					_type = ast_opt_translate_table;
+					_data.table = table;
+				}
+			}
+
+			// Use optimized path for @attr = 'value' or @attr = $value
+			if (_type == ast_op_equal &&
+				_left && _right && // workaround for clang static analyzer and Coverity (_left and _right are never null for ast_op_equal)
+                // coverity[mixed_enums]
+				_left->_type == ast_step && _left->_axis == axis_attribute && _left->_test == nodetest_name && !_left->_left && !_left->_right &&
+				(_right->_type == ast_string_constant || (_right->_type == ast_variable && _right->_rettype == xpath_type_string)))
+			{
+				_type = ast_opt_compare_attribute;
+			}
+		}
+
+		bool is_posinv_expr() const
+		{
+			switch (_type)
+			{
+			case ast_func_position:
+			case ast_func_last:
+				return false;
+
+			case ast_string_constant:
+			case ast_number_constant:
+			case ast_variable:
+				return true;
+
+			case ast_step:
+			case ast_step_root:
+				return true;
+
+			case ast_predicate:
+			case ast_filter:
+				return true;
+
+			default:
+				if (_left && !_left->is_posinv_expr()) return false;
+
+				for (xpath_ast_node* n = _right; n; n = n->_next)
+					if (!n->is_posinv_expr()) return false;
+
+				return true;
+			}
+		}
+
+		bool is_posinv_step() const
+		{
+			assert(_type == ast_step);
+
+			for (xpath_ast_node* n = _right; n; n = n->_next)
+			{
+				assert(n->_type == ast_predicate);
+
+				if (n->_test != predicate_posinv)
+					return false;
+			}
+
+			return true;
+		}
+
+		xpath_value_type rettype() const
+		{
+			return static_cast<xpath_value_type>(_rettype);
+		}
+	};
+
+	static const size_t xpath_ast_depth_limit =
+	#ifdef PUGIXML_XPATH_DEPTH_LIMIT
+		PUGIXML_XPATH_DEPTH_LIMIT
+	#else
+		1024
+	#endif
+		;
+
+	struct xpath_parser
+	{
+		xpath_allocator* _alloc;
+		xpath_lexer _lexer;
+
+		const char_t* _query;
+		xpath_variable_set* _variables;
+
+		xpath_parse_result* _result;
+
+		char_t _scratch[32];
+
+		size_t _depth;
+
+		xpath_ast_node* error(const char* message)
+		{
+			_result->error = message;
+			_result->offset = _lexer.current_pos() - _query;
+
+			return 0;
+		}
+
+		xpath_ast_node* error_oom()
+		{
+			assert(_alloc->_error);
+			*_alloc->_error = true;
+
+			return 0;
+		}
+
+		xpath_ast_node* error_rec()
+		{
+			return error("Exceeded maximum allowed query depth");
+		}
+
+		void* alloc_node()
+		{
+			return _alloc->allocate(sizeof(xpath_ast_node));
+		}
+
+		xpath_ast_node* alloc_node(ast_type_t type, xpath_value_type rettype, const char_t* value)
+		{
+			void* memory = alloc_node();
+			return memory ? new (memory) xpath_ast_node(type, rettype, value) : 0;
+		}
+
+		xpath_ast_node* alloc_node(ast_type_t type, xpath_value_type rettype, double value)
+		{
+			void* memory = alloc_node();
+			return memory ? new (memory) xpath_ast_node(type, rettype, value) : 0;
+		}
+
+		xpath_ast_node* alloc_node(ast_type_t type, xpath_value_type rettype, xpath_variable* value)
+		{
+			void* memory = alloc_node();
+			return memory ? new (memory) xpath_ast_node(type, rettype, value) : 0;
+		}
+
+		xpath_ast_node* alloc_node(ast_type_t type, xpath_value_type rettype, xpath_ast_node* left = 0, xpath_ast_node* right = 0)
+		{
+			void* memory = alloc_node();
+			return memory ? new (memory) xpath_ast_node(type, rettype, left, right) : 0;
+		}
+
+		xpath_ast_node* alloc_node(ast_type_t type, xpath_ast_node* left, axis_t axis, nodetest_t test, const char_t* contents)
+		{
+			void* memory = alloc_node();
+			return memory ? new (memory) xpath_ast_node(type, left, axis, test, contents) : 0;
+		}
+
+		xpath_ast_node* alloc_node(ast_type_t type, xpath_ast_node* left, xpath_ast_node* right, predicate_t test)
+		{
+			void* memory = alloc_node();
+			return memory ? new (memory) xpath_ast_node(type, left, right, test) : 0;
+		}
+
+		const char_t* alloc_string(const xpath_lexer_string& value)
+		{
+			if (!value.begin)
+				return PUGIXML_TEXT("");
+
+			size_t length = static_cast<size_t>(value.end - value.begin);
+
+			char_t* c = static_cast<char_t*>(_alloc->allocate((length + 1) * sizeof(char_t)));
+			if (!c) return 0;
+
+			memcpy(c, value.begin, length * sizeof(char_t));
+			c[length] = 0;
+
+			return c;
+		}
+
+		xpath_ast_node* parse_function(const xpath_lexer_string& name, size_t argc, xpath_ast_node* args[2])
+		{
+			switch (name.begin[0])
+			{
+			case 'b':
+				if (name == PUGIXML_TEXT("boolean") && argc == 1)
+					return alloc_node(ast_func_boolean, xpath_type_boolean, args[0]);
+
+				break;
+
+			case 'c':
+				if (name == PUGIXML_TEXT("count") && argc == 1)
+				{
+					if (args[0]->rettype() != xpath_type_node_set) return error("Function has to be applied to node set");
+					return alloc_node(ast_func_count, xpath_type_number, args[0]);
+				}
+				else if (name == PUGIXML_TEXT("contains") && argc == 2)
+					return alloc_node(ast_func_contains, xpath_type_boolean, args[0], args[1]);
+				else if (name == PUGIXML_TEXT("concat") && argc >= 2)
+					return alloc_node(ast_func_concat, xpath_type_string, args[0], args[1]);
+				else if (name == PUGIXML_TEXT("ceiling") && argc == 1)
+					return alloc_node(ast_func_ceiling, xpath_type_number, args[0]);
+
+				break;
+
+			case 'f':
+				if (name == PUGIXML_TEXT("false") && argc == 0)
+					return alloc_node(ast_func_false, xpath_type_boolean);
+				else if (name == PUGIXML_TEXT("floor") && argc == 1)
+					return alloc_node(ast_func_floor, xpath_type_number, args[0]);
+
+				break;
+
+			case 'i':
+				if (name == PUGIXML_TEXT("id") && argc == 1)
+					return alloc_node(ast_func_id, xpath_type_node_set, args[0]);
+
+				break;
+
+			case 'l':
+				if (name == PUGIXML_TEXT("last") && argc == 0)
+					return alloc_node(ast_func_last, xpath_type_number);
+				else if (name == PUGIXML_TEXT("lang") && argc == 1)
+					return alloc_node(ast_func_lang, xpath_type_boolean, args[0]);
+				else if (name == PUGIXML_TEXT("local-name") && argc <= 1)
+				{
+					if (argc == 1 && args[0]->rettype() != xpath_type_node_set) return error("Function has to be applied to node set");
+					return alloc_node(argc == 0 ? ast_func_local_name_0 : ast_func_local_name_1, xpath_type_string, args[0]);
+				}
+
+				break;
+
+			case 'n':
+				if (name == PUGIXML_TEXT("name") && argc <= 1)
+				{
+					if (argc == 1 && args[0]->rettype() != xpath_type_node_set) return error("Function has to be applied to node set");
+					return alloc_node(argc == 0 ? ast_func_name_0 : ast_func_name_1, xpath_type_string, args[0]);
+				}
+				else if (name == PUGIXML_TEXT("namespace-uri") && argc <= 1)
+				{
+					if (argc == 1 && args[0]->rettype() != xpath_type_node_set) return error("Function has to be applied to node set");
+					return alloc_node(argc == 0 ? ast_func_namespace_uri_0 : ast_func_namespace_uri_1, xpath_type_string, args[0]);
+				}
+				else if (name == PUGIXML_TEXT("normalize-space") && argc <= 1)
+					return alloc_node(argc == 0 ? ast_func_normalize_space_0 : ast_func_normalize_space_1, xpath_type_string, args[0], args[1]);
+				else if (name == PUGIXML_TEXT("not") && argc == 1)
+					return alloc_node(ast_func_not, xpath_type_boolean, args[0]);
+				else if (name == PUGIXML_TEXT("number") && argc <= 1)
+					return alloc_node(argc == 0 ? ast_func_number_0 : ast_func_number_1, xpath_type_number, args[0]);
+
+				break;
+
+			case 'p':
+				if (name == PUGIXML_TEXT("position") && argc == 0)
+					return alloc_node(ast_func_position, xpath_type_number);
+
+				break;
+
+			case 'r':
+				if (name == PUGIXML_TEXT("round") && argc == 1)
+					return alloc_node(ast_func_round, xpath_type_number, args[0]);
+
+				break;
+
+			case 's':
+				if (name == PUGIXML_TEXT("string") && argc <= 1)
+					return alloc_node(argc == 0 ? ast_func_string_0 : ast_func_string_1, xpath_type_string, args[0]);
+				else if (name == PUGIXML_TEXT("string-length") && argc <= 1)
+					return alloc_node(argc == 0 ? ast_func_string_length_0 : ast_func_string_length_1, xpath_type_number, args[0]);
+				else if (name == PUGIXML_TEXT("starts-with") && argc == 2)
+					return alloc_node(ast_func_starts_with, xpath_type_boolean, args[0], args[1]);
+				else if (name == PUGIXML_TEXT("substring-before") && argc == 2)
+					return alloc_node(ast_func_substring_before, xpath_type_string, args[0], args[1]);
+				else if (name == PUGIXML_TEXT("substring-after") && argc == 2)
+					return alloc_node(ast_func_substring_after, xpath_type_string, args[0], args[1]);
+				else if (name == PUGIXML_TEXT("substring") && (argc == 2 || argc == 3))
+					return alloc_node(argc == 2 ? ast_func_substring_2 : ast_func_substring_3, xpath_type_string, args[0], args[1]);
+				else if (name == PUGIXML_TEXT("sum") && argc == 1)
+				{
+					if (args[0]->rettype() != xpath_type_node_set) return error("Function has to be applied to node set");
+					return alloc_node(ast_func_sum, xpath_type_number, args[0]);
+				}
+
+				break;
+
+			case 't':
+				if (name == PUGIXML_TEXT("translate") && argc == 3)
+					return alloc_node(ast_func_translate, xpath_type_string, args[0], args[1]);
+				else if (name == PUGIXML_TEXT("true") && argc == 0)
+					return alloc_node(ast_func_true, xpath_type_boolean);
+
+				break;
+
+			default:
+				break;
+			}
+
+			return error("Unrecognized function or wrong parameter count");
+		}
+
+		axis_t parse_axis_name(const xpath_lexer_string& name, bool& specified)
+		{
+			specified = true;
+
+			switch (name.begin[0])
+			{
+			case 'a':
+				if (name == PUGIXML_TEXT("ancestor"))
+					return axis_ancestor;
+				else if (name == PUGIXML_TEXT("ancestor-or-self"))
+					return axis_ancestor_or_self;
+				else if (name == PUGIXML_TEXT("attribute"))
+					return axis_attribute;
+
+				break;
+
+			case 'c':
+				if (name == PUGIXML_TEXT("child"))
+					return axis_child;
+
+				break;
+
+			case 'd':
+				if (name == PUGIXML_TEXT("descendant"))
+					return axis_descendant;
+				else if (name == PUGIXML_TEXT("descendant-or-self"))
+					return axis_descendant_or_self;
+
+				break;
+
+			case 'f':
+				if (name == PUGIXML_TEXT("following"))
+					return axis_following;
+				else if (name == PUGIXML_TEXT("following-sibling"))
+					return axis_following_sibling;
+
+				break;
+
+			case 'n':
+				if (name == PUGIXML_TEXT("namespace"))
+					return axis_namespace;
+
+				break;
+
+			case 'p':
+				if (name == PUGIXML_TEXT("parent"))
+					return axis_parent;
+				else if (name == PUGIXML_TEXT("preceding"))
+					return axis_preceding;
+				else if (name == PUGIXML_TEXT("preceding-sibling"))
+					return axis_preceding_sibling;
+
+				break;
+
+			case 's':
+				if (name == PUGIXML_TEXT("self"))
+					return axis_self;
+
+				break;
+
+			default:
+				break;
+			}
+
+			specified = false;
+			return axis_child;
+		}
+
+		nodetest_t parse_node_test_type(const xpath_lexer_string& name)
+		{
+			switch (name.begin[0])
+			{
+			case 'c':
+				if (name == PUGIXML_TEXT("comment"))
+					return nodetest_type_comment;
+
+				break;
+
+			case 'n':
+				if (name == PUGIXML_TEXT("node"))
+					return nodetest_type_node;
+
+				break;
+
+			case 'p':
+				if (name == PUGIXML_TEXT("processing-instruction"))
+					return nodetest_type_pi;
+
+				break;
+
+			case 't':
+				if (name == PUGIXML_TEXT("text"))
+					return nodetest_type_text;
+
+				break;
+
+			default:
+				break;
+			}
+
+			return nodetest_none;
+		}
+
+		// PrimaryExpr ::= VariableReference | '(' Expr ')' | Literal | Number | FunctionCall
+		xpath_ast_node* parse_primary_expression()
+		{
+			switch (_lexer.current())
+			{
+			case lex_var_ref:
+			{
+				xpath_lexer_string name = _lexer.contents();
+
+				if (!_variables)
+					return error("Unknown variable: variable set is not provided");
+
+				xpath_variable* var = 0;
+				if (!get_variable_scratch(_scratch, _variables, name.begin, name.end, &var))
+					return error_oom();
+
+				if (!var)
+					return error("Unknown variable: variable set does not contain the given name");
+
+				_lexer.next();
+
+				return alloc_node(ast_variable, var->type(), var);
+			}
+
+			case lex_open_brace:
+			{
+				_lexer.next();
+
+				xpath_ast_node* n = parse_expression();
+				if (!n) return 0;
+
+				if (_lexer.current() != lex_close_brace)
+					return error("Expected ')' to match an opening '('");
+
+				_lexer.next();
+
+				return n;
+			}
+
+			case lex_quoted_string:
+			{
+				const char_t* value = alloc_string(_lexer.contents());
+				if (!value) return 0;
+
+				_lexer.next();
+
+				return alloc_node(ast_string_constant, xpath_type_string, value);
+			}
+
+			case lex_number:
+			{
+				double value = 0;
+
+				if (!convert_string_to_number_scratch(_scratch, _lexer.contents().begin, _lexer.contents().end, &value))
+					return error_oom();
+
+				_lexer.next();
+
+				return alloc_node(ast_number_constant, xpath_type_number, value);
+			}
+
+			case lex_string:
+			{
+				xpath_ast_node* args[2] = {0};
+				size_t argc = 0;
+
+				xpath_lexer_string function = _lexer.contents();
+				_lexer.next();
+
+				xpath_ast_node* last_arg = 0;
+
+				if (_lexer.current() != lex_open_brace)
+					return error("Unrecognized function call");
+				_lexer.next();
+
+				size_t old_depth = _depth;
+
+				while (_lexer.current() != lex_close_brace)
+				{
+					if (argc > 0)
+					{
+						if (_lexer.current() != lex_comma)
+							return error("No comma between function arguments");
+						_lexer.next();
+					}
+
+					if (++_depth > xpath_ast_depth_limit)
+						return error_rec();
+
+					xpath_ast_node* n = parse_expression();
+					if (!n) return 0;
+
+					if (argc < 2) args[argc] = n;
+					else last_arg->set_next(n);
+
+					argc++;
+					last_arg = n;
+				}
+
+				_lexer.next();
+
+				_depth = old_depth;
+
+				return parse_function(function, argc, args);
+			}
+
+			default:
+				return error("Unrecognizable primary expression");
+			}
+		}
+
+		// FilterExpr ::= PrimaryExpr | FilterExpr Predicate
+		// Predicate ::= '[' PredicateExpr ']'
+		// PredicateExpr ::= Expr
+		xpath_ast_node* parse_filter_expression()
+		{
+			xpath_ast_node* n = parse_primary_expression();
+			if (!n) return 0;
+
+			size_t old_depth = _depth;
+
+			while (_lexer.current() == lex_open_square_brace)
+			{
+				_lexer.next();
+
+				if (++_depth > xpath_ast_depth_limit)
+					return error_rec();
+
+				if (n->rettype() != xpath_type_node_set)
+					return error("Predicate has to be applied to node set");
+
+				xpath_ast_node* expr = parse_expression();
+				if (!expr) return 0;
+
+				n = alloc_node(ast_filter, n, expr, predicate_default);
+				if (!n) return 0;
+
+				if (_lexer.current() != lex_close_square_brace)
+					return error("Expected ']' to match an opening '['");
+
+				_lexer.next();
+			}
+
+			_depth = old_depth;
+
+			return n;
+		}
+
+		// Step ::= AxisSpecifier NodeTest Predicate* | AbbreviatedStep
+		// AxisSpecifier ::= AxisName '::' | '@'?
+		// NodeTest ::= NameTest | NodeType '(' ')' | 'processing-instruction' '(' Literal ')'
+		// NameTest ::= '*' | NCName ':' '*' | QName
+		// AbbreviatedStep ::= '.' | '..'
+		xpath_ast_node* parse_step(xpath_ast_node* set)
+		{
+			if (set && set->rettype() != xpath_type_node_set)
+				return error("Step has to be applied to node set");
+
+			bool axis_specified = false;
+			axis_t axis = axis_child; // implied child axis
+
+			if (_lexer.current() == lex_axis_attribute)
+			{
+				axis = axis_attribute;
+				axis_specified = true;
+
+				_lexer.next();
+			}
+			else if (_lexer.current() == lex_dot)
+			{
+				_lexer.next();
+
+				if (_lexer.current() == lex_open_square_brace)
+					return error("Predicates are not allowed after an abbreviated step");
+
+				return alloc_node(ast_step, set, axis_self, nodetest_type_node, 0);
+			}
+			else if (_lexer.current() == lex_double_dot)
+			{
+				_lexer.next();
+
+				if (_lexer.current() == lex_open_square_brace)
+					return error("Predicates are not allowed after an abbreviated step");
+
+				return alloc_node(ast_step, set, axis_parent, nodetest_type_node, 0);
+			}
+
+			nodetest_t nt_type = nodetest_none;
+			xpath_lexer_string nt_name;
+
+			if (_lexer.current() == lex_string)
+			{
+				// node name test
+				nt_name = _lexer.contents();
+				_lexer.next();
+
+				// was it an axis name?
+				if (_lexer.current() == lex_double_colon)
+				{
+					// parse axis name
+					if (axis_specified)
+						return error("Two axis specifiers in one step");
+
+					axis = parse_axis_name(nt_name, axis_specified);
+
+					if (!axis_specified)
+						return error("Unknown axis");
+
+					// read actual node test
+					_lexer.next();
+
+					if (_lexer.current() == lex_multiply)
+					{
+						nt_type = nodetest_all;
+						nt_name = xpath_lexer_string();
+						_lexer.next();
+					}
+					else if (_lexer.current() == lex_string)
+					{
+						nt_name = _lexer.contents();
+						_lexer.next();
+					}
+					else
+					{
+						return error("Unrecognized node test");
+					}
+				}
+
+				if (nt_type == nodetest_none)
+				{
+					// node type test or processing-instruction
+					if (_lexer.current() == lex_open_brace)
+					{
+						_lexer.next();
+
+						if (_lexer.current() == lex_close_brace)
+						{
+							_lexer.next();
+
+							nt_type = parse_node_test_type(nt_name);
+
+							if (nt_type == nodetest_none)
+								return error("Unrecognized node type");
+
+							nt_name = xpath_lexer_string();
+						}
+						else if (nt_name == PUGIXML_TEXT("processing-instruction"))
+						{
+							if (_lexer.current() != lex_quoted_string)
+								return error("Only literals are allowed as arguments to processing-instruction()");
+
+							nt_type = nodetest_pi;
+							nt_name = _lexer.contents();
+							_lexer.next();
+
+							if (_lexer.current() != lex_close_brace)
+								return error("Unmatched brace near processing-instruction()");
+							_lexer.next();
+						}
+						else
+						{
+							return error("Unmatched brace near node type test");
+						}
+					}
+					// QName or NCName:*
+					else
+					{
+						if (nt_name.end - nt_name.begin > 2 && nt_name.end[-2] == ':' && nt_name.end[-1] == '*') // NCName:*
+						{
+							nt_name.end--; // erase *
+
+							nt_type = nodetest_all_in_namespace;
+						}
+						else
+						{
+							nt_type = nodetest_name;
+						}
+					}
+				}
+			}
+			else if (_lexer.current() == lex_multiply)
+			{
+				nt_type = nodetest_all;
+				_lexer.next();
+			}
+			else
+			{
+				return error("Unrecognized node test");
+			}
+
+			const char_t* nt_name_copy = alloc_string(nt_name);
+			if (!nt_name_copy) return 0;
+
+			xpath_ast_node* n = alloc_node(ast_step, set, axis, nt_type, nt_name_copy);
+			if (!n) return 0;
+
+			size_t old_depth = _depth;
+
+			xpath_ast_node* last = 0;
+
+			while (_lexer.current() == lex_open_square_brace)
+			{
+				_lexer.next();
+
+				if (++_depth > xpath_ast_depth_limit)
+					return error_rec();
+
+				xpath_ast_node* expr = parse_expression();
+				if (!expr) return 0;
+
+				xpath_ast_node* pred = alloc_node(ast_predicate, 0, expr, predicate_default);
+				if (!pred) return 0;
+
+				if (_lexer.current() != lex_close_square_brace)
+					return error("Expected ']' to match an opening '['");
+				_lexer.next();
+
+				if (last) last->set_next(pred);
+				else n->set_right(pred);
+
+				last = pred;
+			}
+
+			_depth = old_depth;
+
+			return n;
+		}
+
+		// RelativeLocationPath ::= Step | RelativeLocationPath '/' Step | RelativeLocationPath '//' Step
+		xpath_ast_node* parse_relative_location_path(xpath_ast_node* set)
+		{
+			xpath_ast_node* n = parse_step(set);
+			if (!n) return 0;
+
+			size_t old_depth = _depth;
+
+			while (_lexer.current() == lex_slash || _lexer.current() == lex_double_slash)
+			{
+				lexeme_t l = _lexer.current();
+				_lexer.next();
+
+				if (++_depth > xpath_ast_depth_limit)
+					return error_rec();
+
+				if (l == lex_double_slash)
+				{
+					n = alloc_node(ast_step, n, axis_descendant_or_self, nodetest_type_node, 0);
+					if (!n) return 0;
+				}
+
+				n = parse_step(n);
+				if (!n) return 0;
+			}
+
+			_depth = old_depth;
+
+			return n;
+		}
+
+		// LocationPath ::= RelativeLocationPath | AbsoluteLocationPath
+		// AbsoluteLocationPath ::= '/' RelativeLocationPath? | '//' RelativeLocationPath
+		xpath_ast_node* parse_location_path()
+		{
+			if (_lexer.current() == lex_slash)
+			{
+				_lexer.next();
+
+				xpath_ast_node* n = alloc_node(ast_step_root, xpath_type_node_set);
+				if (!n) return 0;
+
+				// relative location path can start from axis_attribute, dot, double_dot, multiply and string lexemes; any other lexeme means standalone root path
+				lexeme_t l = _lexer.current();
+
+				if (l == lex_string || l == lex_axis_attribute || l == lex_dot || l == lex_double_dot || l == lex_multiply)
+					return parse_relative_location_path(n);
+				else
+					return n;
+			}
+			else if (_lexer.current() == lex_double_slash)
+			{
+				_lexer.next();
+
+				xpath_ast_node* n = alloc_node(ast_step_root, xpath_type_node_set);
+				if (!n) return 0;
+
+				n = alloc_node(ast_step, n, axis_descendant_or_self, nodetest_type_node, 0);
+				if (!n) return 0;
+
+				return parse_relative_location_path(n);
+			}
+
+			// else clause moved outside of if because of bogus warning 'control may reach end of non-void function being inlined' in gcc 4.0.1
+			return parse_relative_location_path(0);
+		}
+
+		// PathExpr ::= LocationPath
+		//				| FilterExpr
+		//				| FilterExpr '/' RelativeLocationPath
+		//				| FilterExpr '//' RelativeLocationPath
+		// UnionExpr ::= PathExpr | UnionExpr '|' PathExpr
+		// UnaryExpr ::= UnionExpr | '-' UnaryExpr
+		xpath_ast_node* parse_path_or_unary_expression()
+		{
+			// Clarification.
+			// PathExpr begins with either LocationPath or FilterExpr.
+			// FilterExpr begins with PrimaryExpr
+			// PrimaryExpr begins with '$' in case of it being a variable reference,
+			// '(' in case of it being an expression, string literal, number constant or
+			// function call.
+			if (_lexer.current() == lex_var_ref || _lexer.current() == lex_open_brace ||
+				_lexer.current() == lex_quoted_string || _lexer.current() == lex_number ||
+				_lexer.current() == lex_string)
+			{
+				if (_lexer.current() == lex_string)
+				{
+					// This is either a function call, or not - if not, we shall proceed with location path
+					const char_t* state = _lexer.state();
+
+					while (PUGI__IS_CHARTYPE(*state, ct_space)) ++state;
+
+					if (*state != '(')
+						return parse_location_path();
+
+					// This looks like a function call; however this still can be a node-test. Check it.
+					if (parse_node_test_type(_lexer.contents()) != nodetest_none)
+						return parse_location_path();
+				}
+
+				xpath_ast_node* n = parse_filter_expression();
+				if (!n) return 0;
+
+				if (_lexer.current() == lex_slash || _lexer.current() == lex_double_slash)
+				{
+					lexeme_t l = _lexer.current();
+					_lexer.next();
+
+					if (l == lex_double_slash)
+					{
+						if (n->rettype() != xpath_type_node_set)
+							return error("Step has to be applied to node set");
+
+						n = alloc_node(ast_step, n, axis_descendant_or_self, nodetest_type_node, 0);
+						if (!n) return 0;
+					}
+
+					// select from location path
+					return parse_relative_location_path(n);
+				}
+
+				return n;
+			}
+			else if (_lexer.current() == lex_minus)
+			{
+				_lexer.next();
+
+				// precedence 7+ - only parses union expressions
+				xpath_ast_node* n = parse_expression(7);
+				if (!n) return 0;
+
+				return alloc_node(ast_op_negate, xpath_type_number, n);
+			}
+			else
+			{
+				return parse_location_path();
+			}
+		}
+
+		struct binary_op_t
+		{
+			ast_type_t asttype;
+			xpath_value_type rettype;
+			int precedence;
+
+			binary_op_t(): asttype(ast_unknown), rettype(xpath_type_none), precedence(0)
+			{
+			}
+
+			binary_op_t(ast_type_t asttype_, xpath_value_type rettype_, int precedence_): asttype(asttype_), rettype(rettype_), precedence(precedence_)
+			{
+			}
+
+			static binary_op_t parse(xpath_lexer& lexer)
+			{
+				switch (lexer.current())
+				{
+				case lex_string:
+					if (lexer.contents() == PUGIXML_TEXT("or"))
+						return binary_op_t(ast_op_or, xpath_type_boolean, 1);
+					else if (lexer.contents() == PUGIXML_TEXT("and"))
+						return binary_op_t(ast_op_and, xpath_type_boolean, 2);
+					else if (lexer.contents() == PUGIXML_TEXT("div"))
+						return binary_op_t(ast_op_divide, xpath_type_number, 6);
+					else if (lexer.contents() == PUGIXML_TEXT("mod"))
+						return binary_op_t(ast_op_mod, xpath_type_number, 6);
+					else
+						return binary_op_t();
+
+				case lex_equal:
+					return binary_op_t(ast_op_equal, xpath_type_boolean, 3);
+
+				case lex_not_equal:
+					return binary_op_t(ast_op_not_equal, xpath_type_boolean, 3);
+
+				case lex_less:
+					return binary_op_t(ast_op_less, xpath_type_boolean, 4);
+
+				case lex_greater:
+					return binary_op_t(ast_op_greater, xpath_type_boolean, 4);
+
+				case lex_less_or_equal:
+					return binary_op_t(ast_op_less_or_equal, xpath_type_boolean, 4);
+
+				case lex_greater_or_equal:
+					return binary_op_t(ast_op_greater_or_equal, xpath_type_boolean, 4);
+
+				case lex_plus:
+					return binary_op_t(ast_op_add, xpath_type_number, 5);
+
+				case lex_minus:
+					return binary_op_t(ast_op_subtract, xpath_type_number, 5);
+
+				case lex_multiply:
+					return binary_op_t(ast_op_multiply, xpath_type_number, 6);
+
+				case lex_union:
+					return binary_op_t(ast_op_union, xpath_type_node_set, 7);
+
+				default:
+					return binary_op_t();
+				}
+			}
+		};
+
+		xpath_ast_node* parse_expression_rec(xpath_ast_node* lhs, int limit)
+		{
+			binary_op_t op = binary_op_t::parse(_lexer);
+
+			while (op.asttype != ast_unknown && op.precedence >= limit)
+			{
+				_lexer.next();
+
+				if (++_depth > xpath_ast_depth_limit)
+					return error_rec();
+
+				xpath_ast_node* rhs = parse_path_or_unary_expression();
+				if (!rhs) return 0;
+
+				binary_op_t nextop = binary_op_t::parse(_lexer);
+
+				while (nextop.asttype != ast_unknown && nextop.precedence > op.precedence)
+				{
+					rhs = parse_expression_rec(rhs, nextop.precedence);
+					if (!rhs) return 0;
+
+					nextop = binary_op_t::parse(_lexer);
+				}
+
+				if (op.asttype == ast_op_union && (lhs->rettype() != xpath_type_node_set || rhs->rettype() != xpath_type_node_set))
+					return error("Union operator has to be applied to node sets");
+
+				lhs = alloc_node(op.asttype, op.rettype, lhs, rhs);
+				if (!lhs) return 0;
+
+				op = binary_op_t::parse(_lexer);
+			}
+
+			return lhs;
+		}
+
+		// Expr ::= OrExpr
+		// OrExpr ::= AndExpr | OrExpr 'or' AndExpr
+		// AndExpr ::= EqualityExpr | AndExpr 'and' EqualityExpr
+		// EqualityExpr ::= RelationalExpr
+		//					| EqualityExpr '=' RelationalExpr
+		//					| EqualityExpr '!=' RelationalExpr
+		// RelationalExpr ::= AdditiveExpr
+		//					  | RelationalExpr '<' AdditiveExpr
+		//					  | RelationalExpr '>' AdditiveExpr
+		//					  | RelationalExpr '<=' AdditiveExpr
+		//					  | RelationalExpr '>=' AdditiveExpr
+		// AdditiveExpr ::= MultiplicativeExpr
+		//					| AdditiveExpr '+' MultiplicativeExpr
+		//					| AdditiveExpr '-' MultiplicativeExpr
+		// MultiplicativeExpr ::= UnaryExpr
+		//						  | MultiplicativeExpr '*' UnaryExpr
+		//						  | MultiplicativeExpr 'div' UnaryExpr
+		//						  | MultiplicativeExpr 'mod' UnaryExpr
+		xpath_ast_node* parse_expression(int limit = 0)
+		{
+			size_t old_depth = _depth;
+
+			if (++_depth > xpath_ast_depth_limit)
+				return error_rec();
+
+			xpath_ast_node* n = parse_path_or_unary_expression();
+			if (!n) return 0;
+
+			n = parse_expression_rec(n, limit);
+
+			_depth = old_depth;
+
+			return n;
+		}
+
+		xpath_parser(const char_t* query, xpath_variable_set* variables, xpath_allocator* alloc, xpath_parse_result* result): _alloc(alloc), _lexer(query), _query(query), _variables(variables), _result(result), _depth(0)
+		{
+		}
+
+		xpath_ast_node* parse()
+		{
+			xpath_ast_node* n = parse_expression();
+			if (!n) return 0;
+
+			assert(_depth == 0);
+
+			// check if there are unparsed tokens left
+			if (_lexer.current() != lex_eof)
+				return error("Incorrect query");
+
+			return n;
+		}
+
+		static xpath_ast_node* parse(const char_t* query, xpath_variable_set* variables, xpath_allocator* alloc, xpath_parse_result* result)
+		{
+			xpath_parser parser(query, variables, alloc, result);
+
+			return parser.parse();
+		}
+	};
+
+	struct xpath_query_impl
+	{
+		static xpath_query_impl* create()
+		{
+			void* memory = xml_memory::allocate(sizeof(xpath_query_impl));
+			if (!memory) return 0;
+
+			return new (memory) xpath_query_impl();
+		}
+
+		static void destroy(xpath_query_impl* impl)
+		{
+			// free all allocated pages
+			impl->alloc.release();
+
+			// free allocator memory (with the first page)
+			xml_memory::deallocate(impl);
+		}
+
+		xpath_query_impl(): root(0), alloc(&block, &oom), oom(false)
+		{
+			block.next = 0;
+			block.capacity = sizeof(block.data);
+		}
+
+		xpath_ast_node* root;
+		xpath_allocator alloc;
+		xpath_memory_block block;
+		bool oom;
+	};
+
+	PUGI__FN impl::xpath_ast_node* evaluate_node_set_prepare(xpath_query_impl* impl)
+	{
+		if (!impl) return 0;
+
+		if (impl->root->rettype() != xpath_type_node_set)
+		{
+		#ifdef PUGIXML_NO_EXCEPTIONS
+			return 0;
+		#else
+			xpath_parse_result res;
+			res.error = "Expression does not evaluate to node set";
+
+			throw xpath_exception(res);
+		#endif
+		}
+
+		return impl->root;
+	}
+PUGI__NS_END
+
+namespace pugi
+{
+#ifndef PUGIXML_NO_EXCEPTIONS
+	PUGI__FN xpath_exception::xpath_exception(const xpath_parse_result& result_): _result(result_)
+	{
+		assert(_result.error);
+	}
+
+	PUGI__FN const char* xpath_exception::what() const throw()
+	{
+		return _result.error;
+	}
+
+	PUGI__FN const xpath_parse_result& xpath_exception::result() const
+	{
+		return _result;
+	}
+#endif
+
+	PUGI__FN xpath_node::xpath_node()
+	{
+	}
+
+	PUGI__FN xpath_node::xpath_node(const xml_node& node_): _node(node_)
+	{
+	}
+
+	PUGI__FN xpath_node::xpath_node(const xml_attribute& attribute_, const xml_node& parent_): _node(attribute_ ? parent_ : xml_node()), _attribute(attribute_)
+	{
+	}
+
+	PUGI__FN xml_node xpath_node::node() const
+	{
+		return _attribute ? xml_node() : _node;
+	}
+
+	PUGI__FN xml_attribute xpath_node::attribute() const
+	{
+		return _attribute;
+	}
+
+	PUGI__FN xml_node xpath_node::parent() const
+	{
+		return _attribute ? _node : _node.parent();
+	}
+
+	PUGI__FN static void unspecified_bool_xpath_node(xpath_node***)
+	{
+	}
+
+	PUGI__FN xpath_node::operator xpath_node::unspecified_bool_type() const
+	{
+		return (_node || _attribute) ? unspecified_bool_xpath_node : 0;
+	}
+
+	PUGI__FN bool xpath_node::operator!() const
+	{
+		return !(_node || _attribute);
+	}
+
+	PUGI__FN bool xpath_node::operator==(const xpath_node& n) const
+	{
+		return _node == n._node && _attribute == n._attribute;
+	}
+
+	PUGI__FN bool xpath_node::operator!=(const xpath_node& n) const
+	{
+		return _node != n._node || _attribute != n._attribute;
+	}
+
+#ifdef __BORLANDC__
+	PUGI__FN bool operator&&(const xpath_node& lhs, bool rhs)
+	{
+		return (bool)lhs && rhs;
+	}
+
+	PUGI__FN bool operator||(const xpath_node& lhs, bool rhs)
+	{
+		return (bool)lhs || rhs;
+	}
+#endif
+
+	PUGI__FN void xpath_node_set::_assign(const_iterator begin_, const_iterator end_, type_t type_)
+	{
+		assert(begin_ <= end_);
+
+		size_t size_ = static_cast<size_t>(end_ - begin_);
+
+		// use internal buffer for 0 or 1 elements, heap buffer otherwise
+		xpath_node* storage = (size_ <= 1) ? _storage : static_cast<xpath_node*>(impl::xml_memory::allocate(size_ * sizeof(xpath_node)));
+
+		if (!storage)
+		{
+		#ifdef PUGIXML_NO_EXCEPTIONS
+			return;
+		#else
+			throw std::bad_alloc();
+		#endif
+		}
+
+		// deallocate old buffer
+		if (_begin != _storage)
+			impl::xml_memory::deallocate(_begin);
+
+		// size check is necessary because for begin_ = end_ = nullptr, memcpy is UB
+		if (size_)
+			memcpy(storage, begin_, size_ * sizeof(xpath_node));
+
+		_begin = storage;
+		_end = storage + size_;
+		_type = type_;
+	}
+
+#ifdef PUGIXML_HAS_MOVE
+	PUGI__FN void xpath_node_set::_move(xpath_node_set& rhs) PUGIXML_NOEXCEPT
+	{
+		_type = rhs._type;
+		_storage[0] = rhs._storage[0];
+		_begin = (rhs._begin == rhs._storage) ? _storage : rhs._begin;
+		_end = _begin + (rhs._end - rhs._begin);
+
+		rhs._type = type_unsorted;
+		rhs._begin = rhs._storage;
+		rhs._end = rhs._storage;
+	}
+#endif
+
+	PUGI__FN xpath_node_set::xpath_node_set(): _type(type_unsorted), _begin(_storage), _end(_storage)
+	{
+	}
+
+	PUGI__FN xpath_node_set::xpath_node_set(const_iterator begin_, const_iterator end_, type_t type_): _type(type_unsorted), _begin(_storage), _end(_storage)
+	{
+		_assign(begin_, end_, type_);
+	}
+
+	PUGI__FN xpath_node_set::~xpath_node_set()
+	{
+		if (_begin != _storage)
+			impl::xml_memory::deallocate(_begin);
+	}
+
+	PUGI__FN xpath_node_set::xpath_node_set(const xpath_node_set& ns): _type(type_unsorted), _begin(_storage), _end(_storage)
+	{
+		_assign(ns._begin, ns._end, ns._type);
+	}
+
+	PUGI__FN xpath_node_set& xpath_node_set::operator=(const xpath_node_set& ns)
+	{
+		if (this == &ns) return *this;
+
+		_assign(ns._begin, ns._end, ns._type);
+
+		return *this;
+	}
+
+#ifdef PUGIXML_HAS_MOVE
+	PUGI__FN xpath_node_set::xpath_node_set(xpath_node_set&& rhs) PUGIXML_NOEXCEPT: _type(type_unsorted), _begin(_storage), _end(_storage)
+	{
+		_move(rhs);
+	}
+
+	PUGI__FN xpath_node_set& xpath_node_set::operator=(xpath_node_set&& rhs) PUGIXML_NOEXCEPT
+	{
+		if (this == &rhs) return *this;
+
+		if (_begin != _storage)
+			impl::xml_memory::deallocate(_begin);
+
+		_move(rhs);
+
+		return *this;
+	}
+#endif
+
+	PUGI__FN xpath_node_set::type_t xpath_node_set::type() const
+	{
+		return _type;
+	}
+
+	PUGI__FN size_t xpath_node_set::size() const
+	{
+		return _end - _begin;
+	}
+
+	PUGI__FN bool xpath_node_set::empty() const
+	{
+		return _begin == _end;
+	}
+
+	PUGI__FN const xpath_node& xpath_node_set::operator[](size_t index) const
+	{
+		assert(index < size());
+		return _begin[index];
+	}
+
+	PUGI__FN xpath_node_set::const_iterator xpath_node_set::begin() const
+	{
+		return _begin;
+	}
+
+	PUGI__FN xpath_node_set::const_iterator xpath_node_set::end() const
+	{
+		return _end;
+	}
+
+	PUGI__FN void xpath_node_set::sort(bool reverse)
+	{
+		_type = impl::xpath_sort(_begin, _end, _type, reverse);
+	}
+
+	PUGI__FN xpath_node xpath_node_set::first() const
+	{
+		return impl::xpath_first(_begin, _end, _type);
+	}
+
+	PUGI__FN xpath_parse_result::xpath_parse_result(): error("Internal error"), offset(0)
+	{
+	}
+
+	PUGI__FN xpath_parse_result::operator bool() const
+	{
+		return error == 0;
+	}
+
+	PUGI__FN const char* xpath_parse_result::description() const
+	{
+		return error ? error : "No error";
+	}
+
+	PUGI__FN xpath_variable::xpath_variable(xpath_value_type type_): _type(type_), _next(0)
+	{
+	}
+
+	PUGI__FN const char_t* xpath_variable::name() const
+	{
+		switch (_type)
+		{
+		case xpath_type_node_set:
+			return static_cast<const impl::xpath_variable_node_set*>(this)->name;
+
+		case xpath_type_number:
+			return static_cast<const impl::xpath_variable_number*>(this)->name;
+
+		case xpath_type_string:
+			return static_cast<const impl::xpath_variable_string*>(this)->name;
+
+		case xpath_type_boolean:
+			return static_cast<const impl::xpath_variable_boolean*>(this)->name;
+
+		default:
+			assert(false && "Invalid variable type"); // unreachable
+			return 0;
+		}
+	}
+
+	PUGI__FN xpath_value_type xpath_variable::type() const
+	{
+		return _type;
+	}
+
+	PUGI__FN bool xpath_variable::get_boolean() const
+	{
+		return (_type == xpath_type_boolean) ? static_cast<const impl::xpath_variable_boolean*>(this)->value : false;
+	}
+
+	PUGI__FN double xpath_variable::get_number() const
+	{
+		return (_type == xpath_type_number) ? static_cast<const impl::xpath_variable_number*>(this)->value : impl::gen_nan();
+	}
+
+	PUGI__FN const char_t* xpath_variable::get_string() const
+	{
+		const char_t* value = (_type == xpath_type_string) ? static_cast<const impl::xpath_variable_string*>(this)->value : 0;
+		return value ? value : PUGIXML_TEXT("");
+	}
+
+	PUGI__FN const xpath_node_set& xpath_variable::get_node_set() const
+	{
+		return (_type == xpath_type_node_set) ? static_cast<const impl::xpath_variable_node_set*>(this)->value : impl::dummy_node_set;
+	}
+
+	PUGI__FN bool xpath_variable::set(bool value)
+	{
+		if (_type != xpath_type_boolean) return false;
+
+		static_cast<impl::xpath_variable_boolean*>(this)->value = value;
+		return true;
+	}
+
+	PUGI__FN bool xpath_variable::set(double value)
+	{
+		if (_type != xpath_type_number) return false;
+
+		static_cast<impl::xpath_variable_number*>(this)->value = value;
+		return true;
+	}
+
+	PUGI__FN bool xpath_variable::set(const char_t* value)
+	{
+		if (_type != xpath_type_string) return false;
+
+		impl::xpath_variable_string* var = static_cast<impl::xpath_variable_string*>(this);
+
+		// duplicate string
+		size_t size = (impl::strlength(value) + 1) * sizeof(char_t);
+
+		char_t* copy = static_cast<char_t*>(impl::xml_memory::allocate(size));
+		if (!copy) return false;
+
+		memcpy(copy, value, size);
+
+		// replace old string
+		if (var->value) impl::xml_memory::deallocate(var->value);
+		var->value = copy;
+
+		return true;
+	}
+
+	PUGI__FN bool xpath_variable::set(const xpath_node_set& value)
+	{
+		if (_type != xpath_type_node_set) return false;
+
+		static_cast<impl::xpath_variable_node_set*>(this)->value = value;
+		return true;
+	}
+
+	PUGI__FN xpath_variable_set::xpath_variable_set()
+	{
+		for (size_t i = 0; i < sizeof(_data) / sizeof(_data[0]); ++i)
+			_data[i] = 0;
+	}
+
+	PUGI__FN xpath_variable_set::~xpath_variable_set()
+	{
+		for (size_t i = 0; i < sizeof(_data) / sizeof(_data[0]); ++i)
+			_destroy(_data[i]);
+	}
+
+	PUGI__FN xpath_variable_set::xpath_variable_set(const xpath_variable_set& rhs)
+	{
+		for (size_t i = 0; i < sizeof(_data) / sizeof(_data[0]); ++i)
+			_data[i] = 0;
+
+		_assign(rhs);
+	}
+
+	PUGI__FN xpath_variable_set& xpath_variable_set::operator=(const xpath_variable_set& rhs)
+	{
+		if (this == &rhs) return *this;
+
+		_assign(rhs);
+
+		return *this;
+	}
+
+#ifdef PUGIXML_HAS_MOVE
+	PUGI__FN xpath_variable_set::xpath_variable_set(xpath_variable_set&& rhs) PUGIXML_NOEXCEPT
+	{
+		for (size_t i = 0; i < sizeof(_data) / sizeof(_data[0]); ++i)
+		{
+			_data[i] = rhs._data[i];
+			rhs._data[i] = 0;
+		}
+	}
+
+	PUGI__FN xpath_variable_set& xpath_variable_set::operator=(xpath_variable_set&& rhs) PUGIXML_NOEXCEPT
+	{
+		for (size_t i = 0; i < sizeof(_data) / sizeof(_data[0]); ++i)
+		{
+			_destroy(_data[i]);
+
+			_data[i] = rhs._data[i];
+			rhs._data[i] = 0;
+		}
+
+		return *this;
+	}
+#endif
+
+	PUGI__FN void xpath_variable_set::_assign(const xpath_variable_set& rhs)
+	{
+		xpath_variable_set temp;
+
+		for (size_t i = 0; i < sizeof(_data) / sizeof(_data[0]); ++i)
+			if (rhs._data[i] && !_clone(rhs._data[i], &temp._data[i]))
+				return;
+
+		_swap(temp);
+	}
+
+	PUGI__FN void xpath_variable_set::_swap(xpath_variable_set& rhs)
+	{
+		for (size_t i = 0; i < sizeof(_data) / sizeof(_data[0]); ++i)
+		{
+			xpath_variable* chain = _data[i];
+
+			_data[i] = rhs._data[i];
+			rhs._data[i] = chain;
+		}
+	}
+
+	PUGI__FN xpath_variable* xpath_variable_set::_find(const char_t* name) const
+	{
+		const size_t hash_size = sizeof(_data) / sizeof(_data[0]);
+		size_t hash = impl::hash_string(name) % hash_size;
+
+		// look for existing variable
+		for (xpath_variable* var = _data[hash]; var; var = var->_next)
+			if (impl::strequal(var->name(), name))
+				return var;
+
+		return 0;
+	}
+
+	PUGI__FN bool xpath_variable_set::_clone(xpath_variable* var, xpath_variable** out_result)
+	{
+		xpath_variable* last = 0;
+
+		while (var)
+		{
+			// allocate storage for new variable
+			xpath_variable* nvar = impl::new_xpath_variable(var->_type, var->name());
+			if (!nvar) return false;
+
+			// link the variable to the result immediately to handle failures gracefully
+			if (last)
+				last->_next = nvar;
+			else
+				*out_result = nvar;
+
+			last = nvar;
+
+			// copy the value; this can fail due to out-of-memory conditions
+			if (!impl::copy_xpath_variable(nvar, var)) return false;
+
+			var = var->_next;
+		}
+
+		return true;
+	}
+
+	PUGI__FN void xpath_variable_set::_destroy(xpath_variable* var)
+	{
+		while (var)
+		{
+			xpath_variable* next = var->_next;
+
+			impl::delete_xpath_variable(var->_type, var);
+
+			var = next;
+		}
+	}
+
+	PUGI__FN xpath_variable* xpath_variable_set::add(const char_t* name, xpath_value_type type)
+	{
+		const size_t hash_size = sizeof(_data) / sizeof(_data[0]);
+		size_t hash = impl::hash_string(name) % hash_size;
+
+		// look for existing variable
+		for (xpath_variable* var = _data[hash]; var; var = var->_next)
+			if (impl::strequal(var->name(), name))
+				return var->type() == type ? var : 0;
+
+		// add new variable
+		xpath_variable* result = impl::new_xpath_variable(type, name);
+
+		if (result)
+		{
+			result->_next = _data[hash];
+
+			_data[hash] = result;
+		}
+
+		return result;
+	}
+
+	PUGI__FN bool xpath_variable_set::set(const char_t* name, bool value)
+	{
+		xpath_variable* var = add(name, xpath_type_boolean);
+		return var ? var->set(value) : false;
+	}
+
+	PUGI__FN bool xpath_variable_set::set(const char_t* name, double value)
+	{
+		xpath_variable* var = add(name, xpath_type_number);
+		return var ? var->set(value) : false;
+	}
+
+	PUGI__FN bool xpath_variable_set::set(const char_t* name, const char_t* value)
+	{
+		xpath_variable* var = add(name, xpath_type_string);
+		return var ? var->set(value) : false;
+	}
+
+	PUGI__FN bool xpath_variable_set::set(const char_t* name, const xpath_node_set& value)
+	{
+		xpath_variable* var = add(name, xpath_type_node_set);
+		return var ? var->set(value) : false;
+	}
+
+	PUGI__FN xpath_variable* xpath_variable_set::get(const char_t* name)
+	{
+		return _find(name);
+	}
+
+	PUGI__FN const xpath_variable* xpath_variable_set::get(const char_t* name) const
+	{
+		return _find(name);
+	}
+
+	PUGI__FN xpath_query::xpath_query(const char_t* query, xpath_variable_set* variables): _impl(0)
+	{
+		impl::xpath_query_impl* qimpl = impl::xpath_query_impl::create();
+
+		if (!qimpl)
+		{
+		#ifdef PUGIXML_NO_EXCEPTIONS
+			_result.error = "Out of memory";
+		#else
+			throw std::bad_alloc();
+		#endif
+		}
+		else
+		{
+			using impl::auto_deleter; // MSVC7 workaround
+			auto_deleter<impl::xpath_query_impl> impl(qimpl, impl::xpath_query_impl::destroy);
+
+			qimpl->root = impl::xpath_parser::parse(query, variables, &qimpl->alloc, &_result);
+
+			if (qimpl->root)
+			{
+				qimpl->root->optimize(&qimpl->alloc);
+
+				_impl = impl.release();
+				_result.error = 0;
+			}
+			else
+			{
+			#ifdef PUGIXML_NO_EXCEPTIONS
+				if (qimpl->oom) _result.error = "Out of memory";
+			#else
+				if (qimpl->oom) throw std::bad_alloc();
+				throw xpath_exception(_result);
+			#endif
+			}
+		}
+	}
+
+	PUGI__FN xpath_query::xpath_query(): _impl(0)
+	{
+	}
+
+	PUGI__FN xpath_query::~xpath_query()
+	{
+		if (_impl)
+			impl::xpath_query_impl::destroy(static_cast<impl::xpath_query_impl*>(_impl));
+	}
+
+#ifdef PUGIXML_HAS_MOVE
+	PUGI__FN xpath_query::xpath_query(xpath_query&& rhs) PUGIXML_NOEXCEPT
+	{
+		_impl = rhs._impl;
+		_result = rhs._result;
+		rhs._impl = 0;
+		rhs._result = xpath_parse_result();
+	}
+
+	PUGI__FN xpath_query& xpath_query::operator=(xpath_query&& rhs) PUGIXML_NOEXCEPT
+	{
+		if (this == &rhs) return *this;
+
+		if (_impl)
+			impl::xpath_query_impl::destroy(static_cast<impl::xpath_query_impl*>(_impl));
+
+		_impl = rhs._impl;
+		_result = rhs._result;
+		rhs._impl = 0;
+		rhs._result = xpath_parse_result();
+
+		return *this;
+	}
+#endif
+
+	PUGI__FN xpath_value_type xpath_query::return_type() const
+	{
+		if (!_impl) return xpath_type_none;
+
+		return static_cast<impl::xpath_query_impl*>(_impl)->root->rettype();
+	}
+
+	PUGI__FN bool xpath_query::evaluate_boolean(const xpath_node& n) const
+	{
+		if (!_impl) return false;
+
+		impl::xpath_context c(n, 1, 1);
+		impl::xpath_stack_data sd;
+
+		bool r = static_cast<impl::xpath_query_impl*>(_impl)->root->eval_boolean(c, sd.stack);
+
+		if (sd.oom)
+		{
+		#ifdef PUGIXML_NO_EXCEPTIONS
+			return false;
+		#else
+			throw std::bad_alloc();
+		#endif
+		}
+
+		return r;
+	}
+
+	PUGI__FN double xpath_query::evaluate_number(const xpath_node& n) const
+	{
+		if (!_impl) return impl::gen_nan();
+
+		impl::xpath_context c(n, 1, 1);
+		impl::xpath_stack_data sd;
+
+		double r = static_cast<impl::xpath_query_impl*>(_impl)->root->eval_number(c, sd.stack);
+
+		if (sd.oom)
+		{
+		#ifdef PUGIXML_NO_EXCEPTIONS
+			return impl::gen_nan();
+		#else
+			throw std::bad_alloc();
+		#endif
+		}
+
+		return r;
+	}
+
+#ifndef PUGIXML_NO_STL
+	PUGI__FN string_t xpath_query::evaluate_string(const xpath_node& n) const
+	{
+		if (!_impl) return string_t();
+
+		impl::xpath_context c(n, 1, 1);
+		impl::xpath_stack_data sd;
+
+		impl::xpath_string r = static_cast<impl::xpath_query_impl*>(_impl)->root->eval_string(c, sd.stack);
+
+		if (sd.oom)
+		{
+		#ifdef PUGIXML_NO_EXCEPTIONS
+			return string_t();
+		#else
+			throw std::bad_alloc();
+		#endif
+		}
+
+		return string_t(r.c_str(), r.length());
+	}
+#endif
+
+	PUGI__FN size_t xpath_query::evaluate_string(char_t* buffer, size_t capacity, const xpath_node& n) const
+	{
+		impl::xpath_context c(n, 1, 1);
+		impl::xpath_stack_data sd;
+
+		impl::xpath_string r = _impl ? static_cast<impl::xpath_query_impl*>(_impl)->root->eval_string(c, sd.stack) : impl::xpath_string();
+
+		if (sd.oom)
+		{
+		#ifdef PUGIXML_NO_EXCEPTIONS
+			r = impl::xpath_string();
+		#else
+			throw std::bad_alloc();
+		#endif
+		}
+
+		size_t full_size = r.length() + 1;
+
+		if (capacity > 0)
+		{
+			size_t size = (full_size < capacity) ? full_size : capacity;
+			assert(size > 0);
+
+			memcpy(buffer, r.c_str(), (size - 1) * sizeof(char_t));
+			buffer[size - 1] = 0;
+		}
+
+		return full_size;
+	}
+
+	PUGI__FN xpath_node_set xpath_query::evaluate_node_set(const xpath_node& n) const
+	{
+		impl::xpath_ast_node* root = impl::evaluate_node_set_prepare(static_cast<impl::xpath_query_impl*>(_impl));
+		if (!root) return xpath_node_set();
+
+		impl::xpath_context c(n, 1, 1);
+		impl::xpath_stack_data sd;
+
+		impl::xpath_node_set_raw r = root->eval_node_set(c, sd.stack, impl::nodeset_eval_all);
+
+		if (sd.oom)
+		{
+		#ifdef PUGIXML_NO_EXCEPTIONS
+			return xpath_node_set();
+		#else
+			throw std::bad_alloc();
+		#endif
+		}
+
+		return xpath_node_set(r.begin(), r.end(), r.type());
+	}
+
+	PUGI__FN xpath_node xpath_query::evaluate_node(const xpath_node& n) const
+	{
+		impl::xpath_ast_node* root = impl::evaluate_node_set_prepare(static_cast<impl::xpath_query_impl*>(_impl));
+		if (!root) return xpath_node();
+
+		impl::xpath_context c(n, 1, 1);
+		impl::xpath_stack_data sd;
+
+		impl::xpath_node_set_raw r = root->eval_node_set(c, sd.stack, impl::nodeset_eval_first);
+
+		if (sd.oom)
+		{
+		#ifdef PUGIXML_NO_EXCEPTIONS
+			return xpath_node();
+		#else
+			throw std::bad_alloc();
+		#endif
+		}
+
+		return r.first();
+	}
+
+	PUGI__FN const xpath_parse_result& xpath_query::result() const
+	{
+		return _result;
+	}
+
+	PUGI__FN static void unspecified_bool_xpath_query(xpath_query***)
+	{
+	}
+
+	PUGI__FN xpath_query::operator xpath_query::unspecified_bool_type() const
+	{
+		return _impl ? unspecified_bool_xpath_query : 0;
+	}
+
+	PUGI__FN bool xpath_query::operator!() const
+	{
+		return !_impl;
+	}
+
+	PUGI__FN xpath_node xml_node::select_node(const char_t* query, xpath_variable_set* variables) const
+	{
+		xpath_query q(query, variables);
+		return q.evaluate_node(*this);
+	}
+
+	PUGI__FN xpath_node xml_node::select_node(const xpath_query& query) const
+	{
+		return query.evaluate_node(*this);
+	}
+
+	PUGI__FN xpath_node_set xml_node::select_nodes(const char_t* query, xpath_variable_set* variables) const
+	{
+		xpath_query q(query, variables);
+		return q.evaluate_node_set(*this);
+	}
+
+	PUGI__FN xpath_node_set xml_node::select_nodes(const xpath_query& query) const
+	{
+		return query.evaluate_node_set(*this);
+	}
+
+	PUGI__FN xpath_node xml_node::select_single_node(const char_t* query, xpath_variable_set* variables) const
+	{
+		xpath_query q(query, variables);
+		return q.evaluate_node(*this);
+	}
+
+	PUGI__FN xpath_node xml_node::select_single_node(const xpath_query& query) const
+	{
+		return query.evaluate_node(*this);
+	}
+}
+
+#endif
+
+#ifdef __BORLANDC__
+#	pragma option pop
+#endif
+
+// Intel C++ does not properly keep warning state for function templates,
+// so popping warning state at the end of translation unit leads to warnings in the middle.
+#if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
+#	pragma warning(pop)
+#endif
+
+#if defined(_MSC_VER) && defined(__c2__)
+#	pragma clang diagnostic pop
+#endif
+
+// Undefine all local macros (makes sure we're not leaking macros in header-only mode)
+#undef PUGI__NO_INLINE
+#undef PUGI__UNLIKELY
+#undef PUGI__STATIC_ASSERT
+#undef PUGI__DMC_VOLATILE
+#undef PUGI__UNSIGNED_OVERFLOW
+#undef PUGI__MSVC_CRT_VERSION
+#undef PUGI__SNPRINTF
+#undef PUGI__NS_BEGIN
+#undef PUGI__NS_END
+#undef PUGI__FN
+#undef PUGI__FN_NO_INLINE
+#undef PUGI__GETHEADER_IMPL
+#undef PUGI__GETPAGE_IMPL
+#undef PUGI__GETPAGE
+#undef PUGI__NODETYPE
+#undef PUGI__IS_CHARTYPE_IMPL
+#undef PUGI__IS_CHARTYPE
+#undef PUGI__IS_CHARTYPEX
+#undef PUGI__ENDSWITH
+#undef PUGI__SKIPWS
+#undef PUGI__OPTSET
+#undef PUGI__PUSHNODE
+#undef PUGI__POPNODE
+#undef PUGI__SCANFOR
+#undef PUGI__SCANWHILE
+#undef PUGI__SCANWHILE_UNROLL
+#undef PUGI__ENDSEG
+#undef PUGI__THROW_ERROR
+#undef PUGI__CHECK_ERROR
+
+#endif
+
+/**
+ * Copyright (c) 2006-2020 Arseny Kapoulkine
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
diff --git a/Engine/lib/assimp/contrib/pugixml/src/pugixml.hpp b/Engine/lib/assimp/contrib/pugixml/src/pugixml.hpp
new file mode 100644
index 000000000..7e2ce7776
--- /dev/null
+++ b/Engine/lib/assimp/contrib/pugixml/src/pugixml.hpp
@@ -0,0 +1,1499 @@
+/**
+ * pugixml parser - version 1.11
+ * --------------------------------------------------------
+ * Copyright (C) 2006-2020, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
+ * Report bugs and download new versions at https://pugixml.org/
+ *
+ * This library is distributed under the MIT License. See notice at the end
+ * of this file.
+ *
+ * This work is based on the pugxml parser, which is:
+ * Copyright (C) 2003, by Kristen Wegner (kristen@tima.net)
+ */
+
+#ifndef PUGIXML_VERSION
+// Define version macro; evaluates to major * 1000 + minor * 10 + patch so that it's safe to use in less-than comparisons
+// Note: pugixml used major * 100 + minor * 10 + patch format up until 1.9 (which had version identifier 190); starting from pugixml 1.10, the minor version number is two digits
+#	define PUGIXML_VERSION 1110
+#endif
+
+// Include user configuration file (this can define various configuration macros)
+#include "pugiconfig.hpp"
+
+#ifndef HEADER_PUGIXML_HPP
+#define HEADER_PUGIXML_HPP
+
+// Include stddef.h for size_t and ptrdiff_t
+#include <stddef.h>
+
+// Include exception header for XPath
+#if !defined(PUGIXML_NO_XPATH) && !defined(PUGIXML_NO_EXCEPTIONS)
+#	include <exception>
+#endif
+
+// Include STL headers
+#ifndef PUGIXML_NO_STL
+#	include <iterator>
+#	include <iosfwd>
+#	include <string>
+#endif
+
+// Macro for deprecated features
+#ifndef PUGIXML_DEPRECATED
+#	if defined(__GNUC__)
+#		define PUGIXML_DEPRECATED __attribute__((deprecated))
+#	elif defined(_MSC_VER) && _MSC_VER >= 1300
+#		define PUGIXML_DEPRECATED __declspec(deprecated)
+#	else
+#		define PUGIXML_DEPRECATED
+#	endif
+#endif
+
+// If no API is defined, assume default
+#ifndef PUGIXML_API
+#	define PUGIXML_API
+#endif
+
+// If no API for classes is defined, assume default
+#ifndef PUGIXML_CLASS
+#	define PUGIXML_CLASS PUGIXML_API
+#endif
+
+// If no API for functions is defined, assume default
+#ifndef PUGIXML_FUNCTION
+#	define PUGIXML_FUNCTION PUGIXML_API
+#endif
+
+// If the platform is known to have long long support, enable long long functions
+#ifndef PUGIXML_HAS_LONG_LONG
+#	if __cplusplus >= 201103
+#		define PUGIXML_HAS_LONG_LONG
+#	elif defined(_MSC_VER) && _MSC_VER >= 1400
+#		define PUGIXML_HAS_LONG_LONG
+#	endif
+#endif
+
+// If the platform is known to have move semantics support, compile move ctor/operator implementation
+#ifndef PUGIXML_HAS_MOVE
+#	if __cplusplus >= 201103
+#		define PUGIXML_HAS_MOVE
+#	elif defined(_MSC_VER) && _MSC_VER >= 1600
+#		define PUGIXML_HAS_MOVE
+#	endif
+#endif
+
+// If C++ is 2011 or higher, add 'noexcept' specifiers
+#ifndef PUGIXML_NOEXCEPT
+#	if __cplusplus >= 201103
+#		define PUGIXML_NOEXCEPT noexcept
+#	elif defined(_MSC_VER) && _MSC_VER >= 1900
+#		define PUGIXML_NOEXCEPT noexcept
+#	else
+#		define PUGIXML_NOEXCEPT
+#	endif
+#endif
+
+// Some functions can not be noexcept in compact mode
+#ifdef PUGIXML_COMPACT
+#	define PUGIXML_NOEXCEPT_IF_NOT_COMPACT
+#else
+#	define PUGIXML_NOEXCEPT_IF_NOT_COMPACT PUGIXML_NOEXCEPT
+#endif
+
+// If C++ is 2011 or higher, add 'override' qualifiers
+#ifndef PUGIXML_OVERRIDE
+#	if __cplusplus >= 201103
+#		define PUGIXML_OVERRIDE override
+#	elif defined(_MSC_VER) && _MSC_VER >= 1700
+#		define PUGIXML_OVERRIDE override
+#	else
+#		define PUGIXML_OVERRIDE
+#	endif
+#endif
+
+// If C++ is 2011 or higher, use 'nullptr'
+#ifndef PUGIXML_NULL
+#	if __cplusplus >= 201103
+#		define PUGIXML_NULL nullptr
+#	else
+#		define PUGIXML_NULL 0
+#	endif
+#endif
+
+// Character interface macros
+#ifdef PUGIXML_WCHAR_MODE
+#	define PUGIXML_TEXT(t) L ## t
+#	define PUGIXML_CHAR wchar_t
+#else
+#	define PUGIXML_TEXT(t) t
+#	define PUGIXML_CHAR char
+#endif
+
+namespace pugi
+{
+	// Character type used for all internal storage and operations; depends on PUGIXML_WCHAR_MODE
+	typedef PUGIXML_CHAR char_t;
+
+#ifndef PUGIXML_NO_STL
+	// String type used for operations that work with STL string; depends on PUGIXML_WCHAR_MODE
+	typedef std::basic_string<PUGIXML_CHAR, std::char_traits<PUGIXML_CHAR>, std::allocator<PUGIXML_CHAR> > string_t;
+#endif
+}
+
+// The PugiXML namespace
+namespace pugi
+{
+	// Tree node types
+	enum xml_node_type
+	{
+		node_null,			// Empty (null) node handle
+		node_document,		// A document tree's absolute root
+		node_element,		// Element tag, i.e. '<node/>'
+		node_pcdata,		// Plain character data, i.e. 'text'
+		node_cdata,			// Character data, i.e. '<![CDATA[text]]>'
+		node_comment,		// Comment tag, i.e. '<!-- text -->'
+		node_pi,			// Processing instruction, i.e. '<?name?>'
+		node_declaration,	// Document declaration, i.e. '<?xml version="1.0"?>'
+		node_doctype		// Document type declaration, i.e. '<!DOCTYPE doc>'
+	};
+
+	// Parsing options
+
+	// Minimal parsing mode (equivalent to turning all other flags off).
+	// Only elements and PCDATA sections are added to the DOM tree, no text conversions are performed.
+	const unsigned int parse_minimal = 0x0000;
+
+	// This flag determines if processing instructions (node_pi) are added to the DOM tree. This flag is off by default.
+	const unsigned int parse_pi = 0x0001;
+
+	// This flag determines if comments (node_comment) are added to the DOM tree. This flag is off by default.
+	const unsigned int parse_comments = 0x0002;
+
+	// This flag determines if CDATA sections (node_cdata) are added to the DOM tree. This flag is on by default.
+	const unsigned int parse_cdata = 0x0004;
+
+	// This flag determines if plain character data (node_pcdata) that consist only of whitespace are added to the DOM tree.
+	// This flag is off by default; turning it on usually results in slower parsing and more memory consumption.
+	const unsigned int parse_ws_pcdata = 0x0008;
+
+	// This flag determines if character and entity references are expanded during parsing. This flag is on by default.
+	const unsigned int parse_escapes = 0x0010;
+
+	// This flag determines if EOL characters are normalized (converted to #xA) during parsing. This flag is on by default.
+	const unsigned int parse_eol = 0x0020;
+
+	// This flag determines if attribute values are normalized using CDATA normalization rules during parsing. This flag is on by default.
+	const unsigned int parse_wconv_attribute = 0x0040;
+
+	// This flag determines if attribute values are normalized using NMTOKENS normalization rules during parsing. This flag is off by default.
+	const unsigned int parse_wnorm_attribute = 0x0080;
+
+	// This flag determines if document declaration (node_declaration) is added to the DOM tree. This flag is off by default.
+	const unsigned int parse_declaration = 0x0100;
+
+	// This flag determines if document type declaration (node_doctype) is added to the DOM tree. This flag is off by default.
+	const unsigned int parse_doctype = 0x0200;
+
+	// This flag determines if plain character data (node_pcdata) that is the only child of the parent node and that consists only
+	// of whitespace is added to the DOM tree.
+	// This flag is off by default; turning it on may result in slower parsing and more memory consumption.
+	const unsigned int parse_ws_pcdata_single = 0x0400;
+
+	// This flag determines if leading and trailing whitespace is to be removed from plain character data. This flag is off by default.
+	const unsigned int parse_trim_pcdata = 0x0800;
+
+	// This flag determines if plain character data that does not have a parent node is added to the DOM tree, and if an empty document
+	// is a valid document. This flag is off by default.
+	const unsigned int parse_fragment = 0x1000;
+
+	// This flag determines if plain character data is be stored in the parent element's value. This significantly changes the structure of
+	// the document; this flag is only recommended for parsing documents with many PCDATA nodes in memory-constrained environments.
+	// This flag is off by default.
+	const unsigned int parse_embed_pcdata = 0x2000;
+
+	// The default parsing mode.
+	// Elements, PCDATA and CDATA sections are added to the DOM tree, character/reference entities are expanded,
+	// End-of-Line characters are normalized, attribute values are normalized using CDATA normalization rules.
+	const unsigned int parse_default = parse_cdata | parse_escapes | parse_wconv_attribute | parse_eol;
+
+	// The full parsing mode.
+	// Nodes of all types are added to the DOM tree, character/reference entities are expanded,
+	// End-of-Line characters are normalized, attribute values are normalized using CDATA normalization rules.
+	const unsigned int parse_full = parse_default | parse_pi | parse_comments | parse_declaration | parse_doctype;
+
+	// These flags determine the encoding of input data for XML document
+	enum xml_encoding
+	{
+		encoding_auto,		// Auto-detect input encoding using BOM or < / <? detection; use UTF8 if BOM is not found
+		encoding_utf8,		// UTF8 encoding
+		encoding_utf16_le,	// Little-endian UTF16
+		encoding_utf16_be,	// Big-endian UTF16
+		encoding_utf16,		// UTF16 with native endianness
+		encoding_utf32_le,	// Little-endian UTF32
+		encoding_utf32_be,	// Big-endian UTF32
+		encoding_utf32,		// UTF32 with native endianness
+		encoding_wchar,		// The same encoding wchar_t has (either UTF16 or UTF32)
+		encoding_latin1
+	};
+
+	// Formatting flags
+
+	// Indent the nodes that are written to output stream with as many indentation strings as deep the node is in DOM tree. This flag is on by default.
+	const unsigned int format_indent = 0x01;
+
+	// Write encoding-specific BOM to the output stream. This flag is off by default.
+	const unsigned int format_write_bom = 0x02;
+
+	// Use raw output mode (no indentation and no line breaks are written). This flag is off by default.
+	const unsigned int format_raw = 0x04;
+
+	// Omit default XML declaration even if there is no declaration in the document. This flag is off by default.
+	const unsigned int format_no_declaration = 0x08;
+
+	// Don't escape attribute values and PCDATA contents. This flag is off by default.
+	const unsigned int format_no_escapes = 0x10;
+
+	// Open file using text mode in xml_document::save_file. This enables special character (i.e. new-line) conversions on some systems. This flag is off by default.
+	const unsigned int format_save_file_text = 0x20;
+
+	// Write every attribute on a new line with appropriate indentation. This flag is off by default.
+	const unsigned int format_indent_attributes = 0x40;
+
+	// Don't output empty element tags, instead writing an explicit start and end tag even if there are no children. This flag is off by default.
+	const unsigned int format_no_empty_element_tags = 0x80;
+
+	// Skip characters belonging to range [0; 32) instead of "&#xNN;" encoding. This flag is off by default.
+	const unsigned int format_skip_control_chars = 0x100;
+
+	// Use single quotes ' instead of double quotes " for enclosing attribute values. This flag is off by default.
+	const unsigned int format_attribute_single_quote = 0x200;
+
+	// The default set of formatting flags.
+	// Nodes are indented depending on their depth in DOM tree, a default declaration is output if document has none.
+	const unsigned int format_default = format_indent;
+
+	const int default_double_precision = 17;
+	const int default_float_precision = 9;
+
+	// Forward declarations
+	struct xml_attribute_struct;
+	struct xml_node_struct;
+
+	class xml_node_iterator;
+	class xml_attribute_iterator;
+	class xml_named_node_iterator;
+
+	class xml_tree_walker;
+
+	struct xml_parse_result;
+
+	class xml_node;
+
+	class xml_text;
+
+	#ifndef PUGIXML_NO_XPATH
+	class xpath_node;
+	class xpath_node_set;
+	class xpath_query;
+	class xpath_variable_set;
+	#endif
+
+	// Range-based for loop support
+	template <typename It> class xml_object_range
+	{
+	public:
+		typedef It const_iterator;
+		typedef It iterator;
+
+		xml_object_range(It b, It e): _begin(b), _end(e)
+		{
+		}
+
+		It begin() const { return _begin; }
+		It end() const { return _end; }
+
+	private:
+		It _begin, _end;
+	};
+
+	// Writer interface for node printing (see xml_node::print)
+	class PUGIXML_CLASS xml_writer
+	{
+	public:
+		virtual ~xml_writer() {}
+
+		// Write memory chunk into stream/file/whatever
+		virtual void write(const void* data, size_t size) = 0;
+	};
+
+	// xml_writer implementation for FILE*
+	class PUGIXML_CLASS xml_writer_file: public xml_writer
+	{
+	public:
+		// Construct writer from a FILE* object; void* is used to avoid header dependencies on stdio
+		xml_writer_file(void* file);
+
+		virtual void write(const void* data, size_t size) PUGIXML_OVERRIDE;
+
+	private:
+		void* file;
+	};
+
+	#ifndef PUGIXML_NO_STL
+	// xml_writer implementation for streams
+	class PUGIXML_CLASS xml_writer_stream: public xml_writer
+	{
+	public:
+		// Construct writer from an output stream object
+		xml_writer_stream(std::basic_ostream<char, std::char_traits<char> >& stream);
+		xml_writer_stream(std::basic_ostream<wchar_t, std::char_traits<wchar_t> >& stream);
+
+		virtual void write(const void* data, size_t size) PUGIXML_OVERRIDE;
+
+	private:
+		std::basic_ostream<char, std::char_traits<char> >* narrow_stream;
+		std::basic_ostream<wchar_t, std::char_traits<wchar_t> >* wide_stream;
+	};
+	#endif
+
+	// A light-weight handle for manipulating attributes in DOM tree
+	class PUGIXML_CLASS xml_attribute
+	{
+		friend class xml_attribute_iterator;
+		friend class xml_node;
+
+	private:
+		xml_attribute_struct* _attr;
+
+		typedef void (*unspecified_bool_type)(xml_attribute***);
+
+	public:
+		// Default constructor. Constructs an empty attribute.
+		xml_attribute();
+
+		// Constructs attribute from internal pointer
+		explicit xml_attribute(xml_attribute_struct* attr);
+
+		// Safe bool conversion operator
+		operator unspecified_bool_type() const;
+
+		// Borland C++ workaround
+		bool operator!() const;
+
+		// Comparison operators (compares wrapped attribute pointers)
+		bool operator==(const xml_attribute& r) const;
+		bool operator!=(const xml_attribute& r) const;
+		bool operator<(const xml_attribute& r) const;
+		bool operator>(const xml_attribute& r) const;
+		bool operator<=(const xml_attribute& r) const;
+		bool operator>=(const xml_attribute& r) const;
+
+		// Check if attribute is empty
+		bool empty() const;
+
+		// Get attribute name/value, or "" if attribute is empty
+		const char_t* name() const;
+		const char_t* value() const;
+
+		// Get attribute value, or the default value if attribute is empty
+		const char_t* as_string(const char_t* def = PUGIXML_TEXT("")) const;
+
+		// Get attribute value as a number, or the default value if conversion did not succeed or attribute is empty
+		int as_int(int def = 0) const;
+		unsigned int as_uint(unsigned int def = 0) const;
+		double as_double(double def = 0) const;
+		float as_float(float def = 0) const;
+
+	#ifdef PUGIXML_HAS_LONG_LONG
+		long long as_llong(long long def = 0) const;
+		unsigned long long as_ullong(unsigned long long def = 0) const;
+	#endif
+
+		// Get attribute value as bool (returns true if first character is in '1tTyY' set), or the default value if attribute is empty
+		bool as_bool(bool def = false) const;
+
+		// Set attribute name/value (returns false if attribute is empty or there is not enough memory)
+		bool set_name(const char_t* rhs);
+		bool set_value(const char_t* rhs);
+
+		// Set attribute value with type conversion (numbers are converted to strings, boolean is converted to "true"/"false")
+		bool set_value(int rhs);
+		bool set_value(unsigned int rhs);
+		bool set_value(long rhs);
+		bool set_value(unsigned long rhs);
+		bool set_value(double rhs);
+		bool set_value(double rhs, int precision);
+		bool set_value(float rhs);
+		bool set_value(float rhs, int precision);
+		bool set_value(bool rhs);
+
+	#ifdef PUGIXML_HAS_LONG_LONG
+		bool set_value(long long rhs);
+		bool set_value(unsigned long long rhs);
+	#endif
+
+		// Set attribute value (equivalent to set_value without error checking)
+		xml_attribute& operator=(const char_t* rhs);
+		xml_attribute& operator=(int rhs);
+		xml_attribute& operator=(unsigned int rhs);
+		xml_attribute& operator=(long rhs);
+		xml_attribute& operator=(unsigned long rhs);
+		xml_attribute& operator=(double rhs);
+		xml_attribute& operator=(float rhs);
+		xml_attribute& operator=(bool rhs);
+
+	#ifdef PUGIXML_HAS_LONG_LONG
+		xml_attribute& operator=(long long rhs);
+		xml_attribute& operator=(unsigned long long rhs);
+	#endif
+
+		// Get next/previous attribute in the attribute list of the parent node
+		xml_attribute next_attribute() const;
+		xml_attribute previous_attribute() const;
+
+		// Get hash value (unique for handles to the same object)
+		size_t hash_value() const;
+
+		// Get internal pointer
+		xml_attribute_struct* internal_object() const;
+	};
+
+#ifdef __BORLANDC__
+	// Borland C++ workaround
+	bool PUGIXML_FUNCTION operator&&(const xml_attribute& lhs, bool rhs);
+	bool PUGIXML_FUNCTION operator||(const xml_attribute& lhs, bool rhs);
+#endif
+
+	// A light-weight handle for manipulating nodes in DOM tree
+	class PUGIXML_CLASS xml_node
+	{
+		friend class xml_attribute_iterator;
+		friend class xml_node_iterator;
+		friend class xml_named_node_iterator;
+
+	protected:
+		xml_node_struct* _root;
+
+		typedef void (*unspecified_bool_type)(xml_node***);
+
+	public:
+		// Default constructor. Constructs an empty node.
+		xml_node();
+
+		// Constructs node from internal pointer
+		explicit xml_node(xml_node_struct* p);
+
+		// Safe bool conversion operator
+		operator unspecified_bool_type() const;
+
+		// Borland C++ workaround
+		bool operator!() const;
+
+		// Comparison operators (compares wrapped node pointers)
+		bool operator==(const xml_node& r) const;
+		bool operator!=(const xml_node& r) const;
+		bool operator<(const xml_node& r) const;
+		bool operator>(const xml_node& r) const;
+		bool operator<=(const xml_node& r) const;
+		bool operator>=(const xml_node& r) const;
+
+		// Check if node is empty.
+		bool empty() const;
+
+		// Get node type
+		xml_node_type type() const;
+
+		// Get node name, or "" if node is empty or it has no name
+		const char_t* name() const;
+
+		// Get node value, or "" if node is empty or it has no value
+		// Note: For <node>text</node> node.value() does not return "text"! Use child_value() or text() methods to access text inside nodes.
+		const char_t* value() const;
+
+		// Get attribute list
+		xml_attribute first_attribute() const;
+		xml_attribute last_attribute() const;
+
+		// Get children list
+		xml_node first_child() const;
+		xml_node last_child() const;
+
+		// Get next/previous sibling in the children list of the parent node
+		xml_node next_sibling() const;
+		xml_node previous_sibling() const;
+
+		// Get parent node
+		xml_node parent() const;
+
+		// Get root of DOM tree this node belongs to
+		xml_node root() const;
+
+		// Get text object for the current node
+		xml_text text() const;
+
+		// Get child, attribute or next/previous sibling with the specified name
+		xml_node child(const char_t* name) const;
+		xml_attribute attribute(const char_t* name) const;
+		xml_node next_sibling(const char_t* name) const;
+		xml_node previous_sibling(const char_t* name) const;
+
+		// Get attribute, starting the search from a hint (and updating hint so that searching for a sequence of attributes is fast)
+		xml_attribute attribute(const char_t* name, xml_attribute& hint) const;
+
+		// Get child value of current node; that is, value of the first child node of type PCDATA/CDATA
+		const char_t* child_value() const;
+
+		// Get child value of child with specified name. Equivalent to child(name).child_value().
+		const char_t* child_value(const char_t* name) const;
+
+		// Set node name/value (returns false if node is empty, there is not enough memory, or node can not have name/value)
+		bool set_name(const char_t* rhs);
+		bool set_value(const char_t* rhs);
+
+		// Add attribute with specified name. Returns added attribute, or empty attribute on errors.
+		xml_attribute append_attribute(const char_t* name);
+		xml_attribute prepend_attribute(const char_t* name);
+		xml_attribute insert_attribute_after(const char_t* name, const xml_attribute& attr);
+		xml_attribute insert_attribute_before(const char_t* name, const xml_attribute& attr);
+
+		// Add a copy of the specified attribute. Returns added attribute, or empty attribute on errors.
+		xml_attribute append_copy(const xml_attribute& proto);
+		xml_attribute prepend_copy(const xml_attribute& proto);
+		xml_attribute insert_copy_after(const xml_attribute& proto, const xml_attribute& attr);
+		xml_attribute insert_copy_before(const xml_attribute& proto, const xml_attribute& attr);
+
+		// Add child node with specified type. Returns added node, or empty node on errors.
+		xml_node append_child(xml_node_type type = node_element);
+		xml_node prepend_child(xml_node_type type = node_element);
+		xml_node insert_child_after(xml_node_type type, const xml_node& node);
+		xml_node insert_child_before(xml_node_type type, const xml_node& node);
+
+		// Add child element with specified name. Returns added node, or empty node on errors.
+		xml_node append_child(const char_t* name);
+		xml_node prepend_child(const char_t* name);
+		xml_node insert_child_after(const char_t* name, const xml_node& node);
+		xml_node insert_child_before(const char_t* name, const xml_node& node);
+
+		// Add a copy of the specified node as a child. Returns added node, or empty node on errors.
+		xml_node append_copy(const xml_node& proto);
+		xml_node prepend_copy(const xml_node& proto);
+		xml_node insert_copy_after(const xml_node& proto, const xml_node& node);
+		xml_node insert_copy_before(const xml_node& proto, const xml_node& node);
+
+		// Move the specified node to become a child of this node. Returns moved node, or empty node on errors.
+		xml_node append_move(const xml_node& moved);
+		xml_node prepend_move(const xml_node& moved);
+		xml_node insert_move_after(const xml_node& moved, const xml_node& node);
+		xml_node insert_move_before(const xml_node& moved, const xml_node& node);
+
+		// Remove specified attribute
+		bool remove_attribute(const xml_attribute& a);
+		bool remove_attribute(const char_t* name);
+
+		// Remove all attributes
+		bool remove_attributes();
+
+		// Remove specified child
+		bool remove_child(const xml_node& n);
+		bool remove_child(const char_t* name);
+
+		// Remove all children
+		bool remove_children();
+
+		// Parses buffer as an XML document fragment and appends all nodes as children of the current node.
+		// Copies/converts the buffer, so it may be deleted or changed after the function returns.
+		// Note: append_buffer allocates memory that has the lifetime of the owning document; removing the appended nodes does not immediately reclaim that memory.
+		xml_parse_result append_buffer(const void* contents, size_t size, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
+
+		// Find attribute using predicate. Returns first attribute for which predicate returned true.
+		template <typename Predicate> xml_attribute find_attribute(Predicate pred) const
+		{
+			if (!_root) return xml_attribute();
+
+			for (xml_attribute attrib = first_attribute(); attrib; attrib = attrib.next_attribute())
+				if (pred(attrib))
+					return attrib;
+
+			return xml_attribute();
+		}
+
+		// Find child node using predicate. Returns first child for which predicate returned true.
+		template <typename Predicate> xml_node find_child(Predicate pred) const
+		{
+			if (!_root) return xml_node();
+
+			for (xml_node node = first_child(); node; node = node.next_sibling())
+				if (pred(node))
+					return node;
+
+			return xml_node();
+		}
+
+		// Find node from subtree using predicate. Returns first node from subtree (depth-first), for which predicate returned true.
+		template <typename Predicate> xml_node find_node(Predicate pred) const
+		{
+			if (!_root) return xml_node();
+
+			xml_node cur = first_child();
+
+			while (cur._root && cur._root != _root)
+			{
+				if (pred(cur)) return cur;
+
+				if (cur.first_child()) cur = cur.first_child();
+				else if (cur.next_sibling()) cur = cur.next_sibling();
+				else
+				{
+					while (!cur.next_sibling() && cur._root != _root) cur = cur.parent();
+
+					if (cur._root != _root) cur = cur.next_sibling();
+				}
+			}
+
+			return xml_node();
+		}
+
+		// Find child node by attribute name/value
+		xml_node find_child_by_attribute(const char_t* name, const char_t* attr_name, const char_t* attr_value) const;
+		xml_node find_child_by_attribute(const char_t* attr_name, const char_t* attr_value) const;
+
+	#ifndef PUGIXML_NO_STL
+		// Get the absolute node path from root as a text string.
+		string_t path(char_t delimiter = '/') const;
+	#endif
+
+		// Search for a node by path consisting of node names and . or .. elements.
+		xml_node first_element_by_path(const char_t* path, char_t delimiter = '/') const;
+
+		// Recursively traverse subtree with xml_tree_walker
+		bool traverse(xml_tree_walker& walker);
+
+	#ifndef PUGIXML_NO_XPATH
+		// Select single node by evaluating XPath query. Returns first node from the resulting node set.
+		xpath_node select_node(const char_t* query, xpath_variable_set* variables = PUGIXML_NULL) const;
+		xpath_node select_node(const xpath_query& query) const;
+
+		// Select node set by evaluating XPath query
+		xpath_node_set select_nodes(const char_t* query, xpath_variable_set* variables = PUGIXML_NULL) const;
+		xpath_node_set select_nodes(const xpath_query& query) const;
+
+		// (deprecated: use select_node instead) Select single node by evaluating XPath query.
+		PUGIXML_DEPRECATED xpath_node select_single_node(const char_t* query, xpath_variable_set* variables = PUGIXML_NULL) const;
+		PUGIXML_DEPRECATED xpath_node select_single_node(const xpath_query& query) const;
+
+	#endif
+
+		// Print subtree using a writer object
+		void print(xml_writer& writer, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, xml_encoding encoding = encoding_auto, unsigned int depth = 0) const;
+
+	#ifndef PUGIXML_NO_STL
+		// Print subtree to stream
+		void print(std::basic_ostream<char, std::char_traits<char> >& os, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, xml_encoding encoding = encoding_auto, unsigned int depth = 0) const;
+		void print(std::basic_ostream<wchar_t, std::char_traits<wchar_t> >& os, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, unsigned int depth = 0) const;
+	#endif
+
+		// Child nodes iterators
+		typedef xml_node_iterator iterator;
+
+		iterator begin() const;
+		iterator end() const;
+
+		// Attribute iterators
+		typedef xml_attribute_iterator attribute_iterator;
+
+		attribute_iterator attributes_begin() const;
+		attribute_iterator attributes_end() const;
+
+		// Range-based for support
+		xml_object_range<xml_node_iterator> children() const;
+		xml_object_range<xml_named_node_iterator> children(const char_t* name) const;
+		xml_object_range<xml_attribute_iterator> attributes() const;
+
+		// Get node offset in parsed file/string (in char_t units) for debugging purposes
+		ptrdiff_t offset_debug() const;
+
+		// Get hash value (unique for handles to the same object)
+		size_t hash_value() const;
+
+		// Get internal pointer
+		xml_node_struct* internal_object() const;
+	};
+
+#ifdef __BORLANDC__
+	// Borland C++ workaround
+	bool PUGIXML_FUNCTION operator&&(const xml_node& lhs, bool rhs);
+	bool PUGIXML_FUNCTION operator||(const xml_node& lhs, bool rhs);
+#endif
+
+	// A helper for working with text inside PCDATA nodes
+	class PUGIXML_CLASS xml_text
+	{
+		friend class xml_node;
+
+		xml_node_struct* _root;
+
+		typedef void (*unspecified_bool_type)(xml_text***);
+
+		explicit xml_text(xml_node_struct* root);
+
+		xml_node_struct* _data_new();
+		xml_node_struct* _data() const;
+
+	public:
+		// Default constructor. Constructs an empty object.
+		xml_text();
+
+		// Safe bool conversion operator
+		operator unspecified_bool_type() const;
+
+		// Borland C++ workaround
+		bool operator!() const;
+
+		// Check if text object is empty
+		bool empty() const;
+
+		// Get text, or "" if object is empty
+		const char_t* get() const;
+
+		// Get text, or the default value if object is empty
+		const char_t* as_string(const char_t* def = PUGIXML_TEXT("")) const;
+
+		// Get text as a number, or the default value if conversion did not succeed or object is empty
+		int as_int(int def = 0) const;
+		unsigned int as_uint(unsigned int def = 0) const;
+		double as_double(double def = 0) const;
+		float as_float(float def = 0) const;
+
+	#ifdef PUGIXML_HAS_LONG_LONG
+		long long as_llong(long long def = 0) const;
+		unsigned long long as_ullong(unsigned long long def = 0) const;
+	#endif
+
+		// Get text as bool (returns true if first character is in '1tTyY' set), or the default value if object is empty
+		bool as_bool(bool def = false) const;
+
+		// Set text (returns false if object is empty or there is not enough memory)
+		bool set(const char_t* rhs);
+
+		// Set text with type conversion (numbers are converted to strings, boolean is converted to "true"/"false")
+		bool set(int rhs);
+		bool set(unsigned int rhs);
+		bool set(long rhs);
+		bool set(unsigned long rhs);
+		bool set(double rhs);
+		bool set(double rhs, int precision);
+		bool set(float rhs);
+		bool set(float rhs, int precision);
+		bool set(bool rhs);
+
+	#ifdef PUGIXML_HAS_LONG_LONG
+		bool set(long long rhs);
+		bool set(unsigned long long rhs);
+	#endif
+
+		// Set text (equivalent to set without error checking)
+		xml_text& operator=(const char_t* rhs);
+		xml_text& operator=(int rhs);
+		xml_text& operator=(unsigned int rhs);
+		xml_text& operator=(long rhs);
+		xml_text& operator=(unsigned long rhs);
+		xml_text& operator=(double rhs);
+		xml_text& operator=(float rhs);
+		xml_text& operator=(bool rhs);
+
+	#ifdef PUGIXML_HAS_LONG_LONG
+		xml_text& operator=(long long rhs);
+		xml_text& operator=(unsigned long long rhs);
+	#endif
+
+		// Get the data node (node_pcdata or node_cdata) for this object
+		xml_node data() const;
+	};
+
+#ifdef __BORLANDC__
+	// Borland C++ workaround
+	bool PUGIXML_FUNCTION operator&&(const xml_text& lhs, bool rhs);
+	bool PUGIXML_FUNCTION operator||(const xml_text& lhs, bool rhs);
+#endif
+
+	// Child node iterator (a bidirectional iterator over a collection of xml_node)
+	class PUGIXML_CLASS xml_node_iterator
+	{
+		friend class xml_node;
+
+	private:
+		mutable xml_node _wrap;
+		xml_node _parent;
+
+		xml_node_iterator(xml_node_struct* ref, xml_node_struct* parent);
+
+	public:
+		// Iterator traits
+		typedef ptrdiff_t difference_type;
+		typedef xml_node value_type;
+		typedef xml_node* pointer;
+		typedef xml_node& reference;
+
+	#ifndef PUGIXML_NO_STL
+		typedef std::bidirectional_iterator_tag iterator_category;
+	#endif
+
+		// Default constructor
+		xml_node_iterator();
+
+		// Construct an iterator which points to the specified node
+		xml_node_iterator(const xml_node& node);
+
+		// Iterator operators
+		bool operator==(const xml_node_iterator& rhs) const;
+		bool operator!=(const xml_node_iterator& rhs) const;
+
+		xml_node& operator*() const;
+		xml_node* operator->() const;
+
+		const xml_node_iterator& operator++();
+		xml_node_iterator operator++(int);
+
+		const xml_node_iterator& operator--();
+		xml_node_iterator operator--(int);
+	};
+
+	// Attribute iterator (a bidirectional iterator over a collection of xml_attribute)
+	class PUGIXML_CLASS xml_attribute_iterator
+	{
+		friend class xml_node;
+
+	private:
+		mutable xml_attribute _wrap;
+		xml_node _parent;
+
+		xml_attribute_iterator(xml_attribute_struct* ref, xml_node_struct* parent);
+
+	public:
+		// Iterator traits
+		typedef ptrdiff_t difference_type;
+		typedef xml_attribute value_type;
+		typedef xml_attribute* pointer;
+		typedef xml_attribute& reference;
+
+	#ifndef PUGIXML_NO_STL
+		typedef std::bidirectional_iterator_tag iterator_category;
+	#endif
+
+		// Default constructor
+		xml_attribute_iterator();
+
+		// Construct an iterator which points to the specified attribute
+		xml_attribute_iterator(const xml_attribute& attr, const xml_node& parent);
+
+		// Iterator operators
+		bool operator==(const xml_attribute_iterator& rhs) const;
+		bool operator!=(const xml_attribute_iterator& rhs) const;
+
+		xml_attribute& operator*() const;
+		xml_attribute* operator->() const;
+
+		const xml_attribute_iterator& operator++();
+		xml_attribute_iterator operator++(int);
+
+		const xml_attribute_iterator& operator--();
+		xml_attribute_iterator operator--(int);
+	};
+
+	// Named node range helper
+	class PUGIXML_CLASS xml_named_node_iterator
+	{
+		friend class xml_node;
+
+	public:
+		// Iterator traits
+		typedef ptrdiff_t difference_type;
+		typedef xml_node value_type;
+		typedef xml_node* pointer;
+		typedef xml_node& reference;
+
+	#ifndef PUGIXML_NO_STL
+		typedef std::bidirectional_iterator_tag iterator_category;
+	#endif
+
+		// Default constructor
+		xml_named_node_iterator();
+
+		// Construct an iterator which points to the specified node
+		xml_named_node_iterator(const xml_node& node, const char_t* name);
+
+		// Iterator operators
+		bool operator==(const xml_named_node_iterator& rhs) const;
+		bool operator!=(const xml_named_node_iterator& rhs) const;
+
+		xml_node& operator*() const;
+		xml_node* operator->() const;
+
+		const xml_named_node_iterator& operator++();
+		xml_named_node_iterator operator++(int);
+
+		const xml_named_node_iterator& operator--();
+		xml_named_node_iterator operator--(int);
+
+	private:
+		mutable xml_node _wrap;
+		xml_node _parent;
+		const char_t* _name;
+
+		xml_named_node_iterator(xml_node_struct* ref, xml_node_struct* parent, const char_t* name);
+	};
+
+	// Abstract tree walker class (see xml_node::traverse)
+	class PUGIXML_CLASS xml_tree_walker
+	{
+		friend class xml_node;
+
+	private:
+		int _depth;
+
+	protected:
+		// Get current traversal depth
+		int depth() const;
+
+	public:
+		xml_tree_walker();
+		virtual ~xml_tree_walker();
+
+		// Callback that is called when traversal begins
+		virtual bool begin(xml_node& node);
+
+		// Callback that is called for each node traversed
+		virtual bool for_each(xml_node& node) = 0;
+
+		// Callback that is called when traversal ends
+		virtual bool end(xml_node& node);
+	};
+
+	// Parsing status, returned as part of xml_parse_result object
+	enum xml_parse_status
+	{
+		status_ok = 0,				// No error
+
+		status_file_not_found,		// File was not found during load_file()
+		status_io_error,			// Error reading from file/stream
+		status_out_of_memory,		// Could not allocate memory
+		status_internal_error,		// Internal error occurred
+
+		status_unrecognized_tag,	// Parser could not determine tag type
+
+		status_bad_pi,				// Parsing error occurred while parsing document declaration/processing instruction
+		status_bad_comment,			// Parsing error occurred while parsing comment
+		status_bad_cdata,			// Parsing error occurred while parsing CDATA section
+		status_bad_doctype,			// Parsing error occurred while parsing document type declaration
+		status_bad_pcdata,			// Parsing error occurred while parsing PCDATA section
+		status_bad_start_element,	// Parsing error occurred while parsing start element tag
+		status_bad_attribute,		// Parsing error occurred while parsing element attribute
+		status_bad_end_element,		// Parsing error occurred while parsing end element tag
+		status_end_element_mismatch,// There was a mismatch of start-end tags (closing tag had incorrect name, some tag was not closed or there was an excessive closing tag)
+
+		status_append_invalid_root,	// Unable to append nodes since root type is not node_element or node_document (exclusive to xml_node::append_buffer)
+
+		status_no_document_element	// Parsing resulted in a document without element nodes
+	};
+
+	// Parsing result
+	struct PUGIXML_CLASS xml_parse_result
+	{
+		// Parsing status (see xml_parse_status)
+		xml_parse_status status;
+
+		// Last parsed offset (in char_t units from start of input data)
+		ptrdiff_t offset;
+
+		// Source document encoding
+		xml_encoding encoding;
+
+		// Default constructor, initializes object to failed state
+		xml_parse_result();
+
+		// Cast to bool operator
+		operator bool() const;
+
+		// Get error description
+		const char* description() const;
+	};
+
+	// Document class (DOM tree root)
+	class PUGIXML_CLASS xml_document: public xml_node
+	{
+	private:
+		char_t* _buffer;
+
+		char _memory[192];
+
+		// Non-copyable semantics
+		xml_document(const xml_document&);
+		xml_document& operator=(const xml_document&);
+
+		void _create();
+		void _destroy();
+		void _move(xml_document& rhs) PUGIXML_NOEXCEPT_IF_NOT_COMPACT;
+
+	public:
+		// Default constructor, makes empty document
+		xml_document();
+
+		// Destructor, invalidates all node/attribute handles to this document
+		~xml_document();
+
+	#ifdef PUGIXML_HAS_MOVE
+		// Move semantics support
+		xml_document(xml_document&& rhs) PUGIXML_NOEXCEPT_IF_NOT_COMPACT;
+		xml_document& operator=(xml_document&& rhs) PUGIXML_NOEXCEPT_IF_NOT_COMPACT;
+	#endif
+
+		// Removes all nodes, leaving the empty document
+		void reset();
+
+		// Removes all nodes, then copies the entire contents of the specified document
+		void reset(const xml_document& proto);
+
+	#ifndef PUGIXML_NO_STL
+		// Load document from stream.
+		xml_parse_result load(std::basic_istream<char, std::char_traits<char> >& stream, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
+		xml_parse_result load(std::basic_istream<wchar_t, std::char_traits<wchar_t> >& stream, unsigned int options = parse_default);
+	#endif
+
+		// (deprecated: use load_string instead) Load document from zero-terminated string. No encoding conversions are applied.
+		PUGIXML_DEPRECATED xml_parse_result load(const char_t* contents, unsigned int options = parse_default);
+
+		// Load document from zero-terminated string. No encoding conversions are applied.
+		xml_parse_result load_string(const char_t* contents, unsigned int options = parse_default);
+
+		// Load document from file
+		xml_parse_result load_file(const char* path, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
+		xml_parse_result load_file(const wchar_t* path, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
+
+		// Load document from buffer. Copies/converts the buffer, so it may be deleted or changed after the function returns.
+		xml_parse_result load_buffer(const void* contents, size_t size, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
+
+		// Load document from buffer, using the buffer for in-place parsing (the buffer is modified and used for storage of document data).
+		// You should ensure that buffer data will persist throughout the document's lifetime, and free the buffer memory manually once document is destroyed.
+		xml_parse_result load_buffer_inplace(void* contents, size_t size, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
+
+		// Load document from buffer, using the buffer for in-place parsing (the buffer is modified and used for storage of document data).
+		// You should allocate the buffer with pugixml allocation function; document will free the buffer when it is no longer needed (you can't use it anymore).
+		xml_parse_result load_buffer_inplace_own(void* contents, size_t size, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
+
+		// Save XML document to writer (semantics is slightly different from xml_node::print, see documentation for details).
+		void save(xml_writer& writer, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, xml_encoding encoding = encoding_auto) const;
+
+	#ifndef PUGIXML_NO_STL
+		// Save XML document to stream (semantics is slightly different from xml_node::print, see documentation for details).
+		void save(std::basic_ostream<char, std::char_traits<char> >& stream, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, xml_encoding encoding = encoding_auto) const;
+		void save(std::basic_ostream<wchar_t, std::char_traits<wchar_t> >& stream, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default) const;
+	#endif
+
+		// Save XML to file
+		bool save_file(const char* path, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, xml_encoding encoding = encoding_auto) const;
+		bool save_file(const wchar_t* path, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, xml_encoding encoding = encoding_auto) const;
+
+		// Get document element
+		xml_node document_element() const;
+	};
+
+#ifndef PUGIXML_NO_XPATH
+	// XPath query return type
+	enum xpath_value_type
+	{
+		xpath_type_none,	  // Unknown type (query failed to compile)
+		xpath_type_node_set,  // Node set (xpath_node_set)
+		xpath_type_number,	  // Number
+		xpath_type_string,	  // String
+		xpath_type_boolean	  // Boolean
+	};
+
+	// XPath parsing result
+	struct PUGIXML_CLASS xpath_parse_result
+	{
+		// Error message (0 if no error)
+		const char* error;
+
+		// Last parsed offset (in char_t units from string start)
+		ptrdiff_t offset;
+
+		// Default constructor, initializes object to failed state
+		xpath_parse_result();
+
+		// Cast to bool operator
+		operator bool() const;
+
+		// Get error description
+		const char* description() const;
+	};
+
+	// A single XPath variable
+	class PUGIXML_CLASS xpath_variable
+	{
+		friend class xpath_variable_set;
+
+	protected:
+		xpath_value_type _type;
+		xpath_variable* _next;
+
+		xpath_variable(xpath_value_type type);
+
+		// Non-copyable semantics
+		xpath_variable(const xpath_variable&);
+		xpath_variable& operator=(const xpath_variable&);
+
+	public:
+		// Get variable name
+		const char_t* name() const;
+
+		// Get variable type
+		xpath_value_type type() const;
+
+		// Get variable value; no type conversion is performed, default value (false, NaN, empty string, empty node set) is returned on type mismatch error
+		bool get_boolean() const;
+		double get_number() const;
+		const char_t* get_string() const;
+		const xpath_node_set& get_node_set() const;
+
+		// Set variable value; no type conversion is performed, false is returned on type mismatch error
+		bool set(bool value);
+		bool set(double value);
+		bool set(const char_t* value);
+		bool set(const xpath_node_set& value);
+	};
+
+	// A set of XPath variables
+	class PUGIXML_CLASS xpath_variable_set
+	{
+	private:
+		xpath_variable* _data[64];
+
+		void _assign(const xpath_variable_set& rhs);
+		void _swap(xpath_variable_set& rhs);
+
+		xpath_variable* _find(const char_t* name) const;
+
+		static bool _clone(xpath_variable* var, xpath_variable** out_result);
+		static void _destroy(xpath_variable* var);
+
+	public:
+		// Default constructor/destructor
+		xpath_variable_set();
+		~xpath_variable_set();
+
+		// Copy constructor/assignment operator
+		xpath_variable_set(const xpath_variable_set& rhs);
+		xpath_variable_set& operator=(const xpath_variable_set& rhs);
+
+	#ifdef PUGIXML_HAS_MOVE
+		// Move semantics support
+		xpath_variable_set(xpath_variable_set&& rhs) PUGIXML_NOEXCEPT;
+		xpath_variable_set& operator=(xpath_variable_set&& rhs) PUGIXML_NOEXCEPT;
+	#endif
+
+		// Add a new variable or get the existing one, if the types match
+		xpath_variable* add(const char_t* name, xpath_value_type type);
+
+		// Set value of an existing variable; no type conversion is performed, false is returned if there is no such variable or if types mismatch
+		bool set(const char_t* name, bool value);
+		bool set(const char_t* name, double value);
+		bool set(const char_t* name, const char_t* value);
+		bool set(const char_t* name, const xpath_node_set& value);
+
+		// Get existing variable by name
+		xpath_variable* get(const char_t* name);
+		const xpath_variable* get(const char_t* name) const;
+	};
+
+	// A compiled XPath query object
+	class PUGIXML_CLASS xpath_query
+	{
+	private:
+		void* _impl;
+		xpath_parse_result _result;
+
+		typedef void (*unspecified_bool_type)(xpath_query***);
+
+		// Non-copyable semantics
+		xpath_query(const xpath_query&);
+		xpath_query& operator=(const xpath_query&);
+
+	public:
+		// Construct a compiled object from XPath expression.
+		// If PUGIXML_NO_EXCEPTIONS is not defined, throws xpath_exception on compilation errors.
+		explicit xpath_query(const char_t* query, xpath_variable_set* variables = PUGIXML_NULL);
+
+		// Constructor
+		xpath_query();
+
+		// Destructor
+		~xpath_query();
+
+	#ifdef PUGIXML_HAS_MOVE
+		// Move semantics support
+		xpath_query(xpath_query&& rhs) PUGIXML_NOEXCEPT;
+		xpath_query& operator=(xpath_query&& rhs) PUGIXML_NOEXCEPT;
+	#endif
+
+		// Get query expression return type
+		xpath_value_type return_type() const;
+
+		// Evaluate expression as boolean value in the specified context; performs type conversion if necessary.
+		// If PUGIXML_NO_EXCEPTIONS is not defined, throws std::bad_alloc on out of memory errors.
+		bool evaluate_boolean(const xpath_node& n) const;
+
+		// Evaluate expression as double value in the specified context; performs type conversion if necessary.
+		// If PUGIXML_NO_EXCEPTIONS is not defined, throws std::bad_alloc on out of memory errors.
+		double evaluate_number(const xpath_node& n) const;
+
+	#ifndef PUGIXML_NO_STL
+		// Evaluate expression as string value in the specified context; performs type conversion if necessary.
+		// If PUGIXML_NO_EXCEPTIONS is not defined, throws std::bad_alloc on out of memory errors.
+		string_t evaluate_string(const xpath_node& n) const;
+	#endif
+
+		// Evaluate expression as string value in the specified context; performs type conversion if necessary.
+		// At most capacity characters are written to the destination buffer, full result size is returned (includes terminating zero).
+		// If PUGIXML_NO_EXCEPTIONS is not defined, throws std::bad_alloc on out of memory errors.
+		// If PUGIXML_NO_EXCEPTIONS is defined, returns empty  set instead.
+		size_t evaluate_string(char_t* buffer, size_t capacity, const xpath_node& n) const;
+
+		// Evaluate expression as node set in the specified context.
+		// If PUGIXML_NO_EXCEPTIONS is not defined, throws xpath_exception on type mismatch and std::bad_alloc on out of memory errors.
+		// If PUGIXML_NO_EXCEPTIONS is defined, returns empty node set instead.
+		xpath_node_set evaluate_node_set(const xpath_node& n) const;
+
+		// Evaluate expression as node set in the specified context.
+		// Return first node in document order, or empty node if node set is empty.
+		// If PUGIXML_NO_EXCEPTIONS is not defined, throws xpath_exception on type mismatch and std::bad_alloc on out of memory errors.
+		// If PUGIXML_NO_EXCEPTIONS is defined, returns empty node instead.
+		xpath_node evaluate_node(const xpath_node& n) const;
+
+		// Get parsing result (used to get compilation errors in PUGIXML_NO_EXCEPTIONS mode)
+		const xpath_parse_result& result() const;
+
+		// Safe bool conversion operator
+		operator unspecified_bool_type() const;
+
+		// Borland C++ workaround
+		bool operator!() const;
+	};
+
+	#ifndef PUGIXML_NO_EXCEPTIONS
+        #if defined(_MSC_VER)
+          // C4275 can be ignored in Visual C++ if you are deriving
+          // from a type in the Standard C++ Library
+          #pragma warning(push)
+          #pragma warning(disable: 4275)
+        #endif
+	// XPath exception class
+	class PUGIXML_CLASS xpath_exception: public std::exception
+	{
+	private:
+		xpath_parse_result _result;
+
+	public:
+		// Construct exception from parse result
+		explicit xpath_exception(const xpath_parse_result& result);
+
+		// Get error message
+		virtual const char* what() const throw() PUGIXML_OVERRIDE;
+
+		// Get parse result
+		const xpath_parse_result& result() const;
+	};
+        #if defined(_MSC_VER)
+          #pragma warning(pop)
+        #endif
+	#endif
+
+	// XPath node class (either xml_node or xml_attribute)
+	class PUGIXML_CLASS xpath_node
+	{
+	private:
+		xml_node _node;
+		xml_attribute _attribute;
+
+		typedef void (*unspecified_bool_type)(xpath_node***);
+
+	public:
+		// Default constructor; constructs empty XPath node
+		xpath_node();
+
+		// Construct XPath node from XML node/attribute
+		xpath_node(const xml_node& node);
+		xpath_node(const xml_attribute& attribute, const xml_node& parent);
+
+		// Get node/attribute, if any
+		xml_node node() const;
+		xml_attribute attribute() const;
+
+		// Get parent of contained node/attribute
+		xml_node parent() const;
+
+		// Safe bool conversion operator
+		operator unspecified_bool_type() const;
+
+		// Borland C++ workaround
+		bool operator!() const;
+
+		// Comparison operators
+		bool operator==(const xpath_node& n) const;
+		bool operator!=(const xpath_node& n) const;
+	};
+
+#ifdef __BORLANDC__
+	// Borland C++ workaround
+	bool PUGIXML_FUNCTION operator&&(const xpath_node& lhs, bool rhs);
+	bool PUGIXML_FUNCTION operator||(const xpath_node& lhs, bool rhs);
+#endif
+
+	// A fixed-size collection of XPath nodes
+	class PUGIXML_CLASS xpath_node_set
+	{
+	public:
+		// Collection type
+		enum type_t
+		{
+			type_unsorted,			// Not ordered
+			type_sorted,			// Sorted by document order (ascending)
+			type_sorted_reverse		// Sorted by document order (descending)
+		};
+
+		// Constant iterator type
+		typedef const xpath_node* const_iterator;
+
+		// We define non-constant iterator to be the same as constant iterator so that various generic algorithms (i.e. boost foreach) work
+		typedef const xpath_node* iterator;
+
+		// Default constructor. Constructs empty set.
+		xpath_node_set();
+
+		// Constructs a set from iterator range; data is not checked for duplicates and is not sorted according to provided type, so be careful
+		xpath_node_set(const_iterator begin, const_iterator end, type_t type = type_unsorted);
+
+		// Destructor
+		~xpath_node_set();
+
+		// Copy constructor/assignment operator
+		xpath_node_set(const xpath_node_set& ns);
+		xpath_node_set& operator=(const xpath_node_set& ns);
+
+	#ifdef PUGIXML_HAS_MOVE
+		// Move semantics support
+		xpath_node_set(xpath_node_set&& rhs) PUGIXML_NOEXCEPT;
+		xpath_node_set& operator=(xpath_node_set&& rhs) PUGIXML_NOEXCEPT;
+	#endif
+
+		// Get collection type
+		type_t type() const;
+
+		// Get collection size
+		size_t size() const;
+
+		// Indexing operator
+		const xpath_node& operator[](size_t index) const;
+
+		// Collection iterators
+		const_iterator begin() const;
+		const_iterator end() const;
+
+		// Sort the collection in ascending/descending order by document order
+		void sort(bool reverse = false);
+
+		// Get first node in the collection by document order
+		xpath_node first() const;
+
+		// Check if collection is empty
+		bool empty() const;
+
+	private:
+		type_t _type;
+
+		xpath_node _storage[1];
+
+		xpath_node* _begin;
+		xpath_node* _end;
+
+		void _assign(const_iterator begin, const_iterator end, type_t type);
+		void _move(xpath_node_set& rhs) PUGIXML_NOEXCEPT;
+	};
+#endif
+
+#ifndef PUGIXML_NO_STL
+	// Convert wide string to UTF8
+	std::basic_string<char, std::char_traits<char>, std::allocator<char> > PUGIXML_FUNCTION as_utf8(const wchar_t* str);
+	std::basic_string<char, std::char_traits<char>, std::allocator<char> > PUGIXML_FUNCTION as_utf8(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >& str);
+
+	// Convert UTF8 to wide string
+	std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > PUGIXML_FUNCTION as_wide(const char* str);
+	std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > PUGIXML_FUNCTION as_wide(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >& str);
+#endif
+
+	// Memory allocation function interface; returns pointer to allocated memory or NULL on failure
+	typedef void* (*allocation_function)(size_t size);
+
+	// Memory deallocation function interface
+	typedef void (*deallocation_function)(void* ptr);
+
+	// Override default memory management functions. All subsequent allocations/deallocations will be performed via supplied functions.
+	void PUGIXML_FUNCTION set_memory_management_functions(allocation_function allocate, deallocation_function deallocate);
+
+	// Get current memory management functions
+	allocation_function PUGIXML_FUNCTION get_memory_allocation_function();
+	deallocation_function PUGIXML_FUNCTION get_memory_deallocation_function();
+}
+
+#if !defined(PUGIXML_NO_STL) && (defined(_MSC_VER) || defined(__ICC))
+namespace std
+{
+	// Workarounds for (non-standard) iterator category detection for older versions (MSVC7/IC8 and earlier)
+	std::bidirectional_iterator_tag PUGIXML_FUNCTION _Iter_cat(const pugi::xml_node_iterator&);
+	std::bidirectional_iterator_tag PUGIXML_FUNCTION _Iter_cat(const pugi::xml_attribute_iterator&);
+	std::bidirectional_iterator_tag PUGIXML_FUNCTION _Iter_cat(const pugi::xml_named_node_iterator&);
+}
+#endif
+
+#if !defined(PUGIXML_NO_STL) && defined(__SUNPRO_CC)
+namespace std
+{
+	// Workarounds for (non-standard) iterator category detection
+	std::bidirectional_iterator_tag PUGIXML_FUNCTION __iterator_category(const pugi::xml_node_iterator&);
+	std::bidirectional_iterator_tag PUGIXML_FUNCTION __iterator_category(const pugi::xml_attribute_iterator&);
+	std::bidirectional_iterator_tag PUGIXML_FUNCTION __iterator_category(const pugi::xml_named_node_iterator&);
+}
+#endif
+
+#endif
+
+// Make sure implementation is included in header-only mode
+// Use macro expansion in #include to work around QMake (QTBUG-11923)
+#if defined(PUGIXML_HEADER_ONLY) && !defined(PUGIXML_SOURCE)
+#	define PUGIXML_SOURCE "pugixml.cpp"
+#	include PUGIXML_SOURCE
+#endif
+
+/**
+ * Copyright (c) 2006-2020 Arseny Kapoulkine
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/allocators.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/allocators.h
index 655f4a385..44ec5295c 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/allocators.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/allocators.h
@@ -1,6 +1,6 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
 // 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
@@ -52,6 +52,19 @@ concept Allocator {
 \endcode
 */
 
+
+/*! \def RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY
+    \ingroup RAPIDJSON_CONFIG
+    \brief User-defined kDefaultChunkCapacity definition.
+
+    User can define this as any \c size that is a power of 2.
+*/
+
+#ifndef RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY
+#define RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY (64 * 1024)
+#endif
+
+
 ///////////////////////////////////////////////////////////////////////////////
 // CrtAllocator
 
@@ -64,19 +77,19 @@ public:
     static const bool kNeedFree = true;
     void* Malloc(size_t size) { 
         if (size) //  behavior of malloc(0) is implementation defined.
-            return std::malloc(size);
+            return RAPIDJSON_MALLOC(size);
         else
             return NULL; // standardize to returning NULL.
     }
     void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) {
         (void)originalSize;
         if (newSize == 0) {
-            std::free(originalPtr);
+            RAPIDJSON_FREE(originalPtr);
             return NULL;
         }
-        return std::realloc(originalPtr, newSize);
+        return RAPIDJSON_REALLOC(originalPtr, newSize);
     }
-    static void Free(void *ptr) { std::free(ptr); }
+    static void Free(void *ptr) { RAPIDJSON_FREE(ptr); }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -248,7 +261,7 @@ private:
             return false;
     }
 
-    static const int kDefaultChunkCapacity = 64 * 1024; //!< Default chunk capacity.
+    static const int kDefaultChunkCapacity = RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY; //!< Default chunk capacity.
 
     //! Chunk header for perpending to each chunk.
     /*! Chunks are stored as a singly linked list.
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/cursorstreamwrapper.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/cursorstreamwrapper.h
new file mode 100644
index 000000000..fd6513db1
--- /dev/null
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/cursorstreamwrapper.h
@@ -0,0 +1,78 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_CURSORSTREAMWRAPPER_H_
+#define RAPIDJSON_CURSORSTREAMWRAPPER_H_
+
+#include "stream.h"
+
+#if defined(__GNUC__)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(effc++)
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER <= 1800
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(4702)  // unreachable code
+RAPIDJSON_DIAG_OFF(4512)  // assignment operator could not be generated
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+
+//! Cursor stream wrapper for counting line and column number if error exists.
+/*!
+    \tparam InputStream     Any stream that implements Stream Concept
+*/
+template <typename InputStream, typename Encoding = UTF8<> >
+class CursorStreamWrapper : public GenericStreamWrapper<InputStream, Encoding> {
+public:
+    typedef typename Encoding::Ch Ch;
+
+    CursorStreamWrapper(InputStream& is):
+        GenericStreamWrapper<InputStream, Encoding>(is), line_(1), col_(0) {}
+
+    // counting line and column number
+    Ch Take() {
+        Ch ch = this->is_.Take();
+        if(ch == '\n') {
+            line_ ++;
+            col_ = 0;
+        } else {
+            col_ ++;
+        }
+        return ch;
+    }
+
+    //! Get the error line number, if error exists.
+    size_t GetLine() const { return line_; }
+    //! Get the error column number, if error exists.
+    size_t GetColumn() const { return col_; }
+
+private:
+    size_t line_;   //!< Current Line
+    size_t col_;    //!< Current Column
+};
+
+#if defined(_MSC_VER) && _MSC_VER <= 1800
+RAPIDJSON_DIAG_POP
+#endif
+
+#if defined(__GNUC__)
+RAPIDJSON_DIAG_POP
+#endif
+
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_CURSORSTREAMWRAPPER_H_
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/document.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/document.h
index 93b091f64..028235ec6 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/document.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/document.h
@@ -1,6 +1,6 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
 // 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
@@ -24,28 +24,26 @@
 #include "encodedstream.h"
 #include <new>      // placement new
 #include <limits>
-
-RAPIDJSON_DIAG_PUSH
-#ifdef _MSC_VER
-RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
-RAPIDJSON_DIAG_OFF(4244) // conversion from kXxxFlags to 'uint16_t', possible loss of data
+#ifdef __cpp_lib_three_way_comparison
+#include <compare>
 #endif
 
+RAPIDJSON_DIAG_PUSH
 #ifdef __clang__
 RAPIDJSON_DIAG_OFF(padded)
 RAPIDJSON_DIAG_OFF(switch-enum)
 RAPIDJSON_DIAG_OFF(c++98-compat)
+#elif defined(_MSC_VER)
+RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
+RAPIDJSON_DIAG_OFF(4244) // conversion from kXxxFlags to 'uint16_t', possible loss of data
 #endif
 
 #ifdef __GNUC__
 RAPIDJSON_DIAG_OFF(effc++)
-#if __GNUC__ >= 6
-RAPIDJSON_DIAG_OFF(terminate) // ignore throwing RAPIDJSON_ASSERT in RAPIDJSON_NOEXCEPT functions
-#endif
 #endif // __GNUC__
 
 #ifndef RAPIDJSON_NOMEMBERITERATORCLASS
-#include <iterator> // std::iterator, std::random_access_iterator_tag
+#include <iterator> // std::random_access_iterator_tag
 #endif
 
 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS
@@ -61,6 +59,48 @@ class GenericValue;
 template <typename Encoding, typename Allocator, typename StackAllocator>
 class GenericDocument;
 
+/*! \def RAPIDJSON_DEFAULT_ALLOCATOR
+    \ingroup RAPIDJSON_CONFIG
+    \brief Allows to choose default allocator.
+
+    User can define this to use CrtAllocator or MemoryPoolAllocator.
+*/
+#ifndef RAPIDJSON_DEFAULT_ALLOCATOR
+#define RAPIDJSON_DEFAULT_ALLOCATOR MemoryPoolAllocator<CrtAllocator>
+#endif
+
+/*! \def RAPIDJSON_DEFAULT_STACK_ALLOCATOR
+    \ingroup RAPIDJSON_CONFIG
+    \brief Allows to choose default stack allocator for Document.
+
+    User can define this to use CrtAllocator or MemoryPoolAllocator.
+*/
+#ifndef RAPIDJSON_DEFAULT_STACK_ALLOCATOR
+#define RAPIDJSON_DEFAULT_STACK_ALLOCATOR CrtAllocator
+#endif
+
+/*! \def RAPIDJSON_VALUE_DEFAULT_OBJECT_CAPACITY
+    \ingroup RAPIDJSON_CONFIG
+    \brief User defined kDefaultObjectCapacity value.
+
+    User can define this as any natural number.
+*/
+#ifndef RAPIDJSON_VALUE_DEFAULT_OBJECT_CAPACITY
+// number of objects that rapidjson::Value allocates memory for by default
+#define RAPIDJSON_VALUE_DEFAULT_OBJECT_CAPACITY 16
+#endif
+
+/*! \def RAPIDJSON_VALUE_DEFAULT_ARRAY_CAPACITY
+    \ingroup RAPIDJSON_CONFIG
+    \brief User defined kDefaultArrayCapacity value.
+
+    User can define this as any natural number.
+*/
+#ifndef RAPIDJSON_VALUE_DEFAULT_ARRAY_CAPACITY
+// number of array elements that rapidjson::Value allocates memory for by default
+#define RAPIDJSON_VALUE_DEFAULT_ARRAY_CAPACITY 16
+#endif
+
 //! Name-value pair in a JSON object value.
 /*!
     This class was internal to GenericValue. It used to be a inner struct.
@@ -68,9 +108,45 @@ class GenericDocument;
     https://code.google.com/p/rapidjson/issues/detail?id=64
 */
 template <typename Encoding, typename Allocator> 
-struct GenericMember { 
+class GenericMember {
+public:
     GenericValue<Encoding, Allocator> name;     //!< name of member (must be a string)
     GenericValue<Encoding, Allocator> value;    //!< value of member.
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+    //! Move constructor in C++11
+    GenericMember(GenericMember&& rhs) RAPIDJSON_NOEXCEPT
+        : name(std::move(rhs.name)),
+          value(std::move(rhs.value))
+    {
+    }
+
+    //! Move assignment in C++11
+    GenericMember& operator=(GenericMember&& rhs) RAPIDJSON_NOEXCEPT {
+        return *this = static_cast<GenericMember&>(rhs);
+    }
+#endif
+
+    //! Assignment with move semantics.
+    /*! \param rhs Source of the assignment. Its name and value will become a null value after assignment.
+    */
+    GenericMember& operator=(GenericMember& rhs) RAPIDJSON_NOEXCEPT {
+        if (RAPIDJSON_LIKELY(this != &rhs)) {
+            name = rhs.name;
+            value = rhs.value;
+        }
+        return *this;
+    }
+
+    // swap() for std::sort() and other potential use in STL.
+    friend inline void swap(GenericMember& a, GenericMember& b) RAPIDJSON_NOEXCEPT {
+        a.name.Swap(b.name);
+        a.value.Swap(b.value);
+    }
+
+private:
+    //! Copy constructor is not permitted.
+    GenericMember(const GenericMember& rhs);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -98,16 +174,13 @@ struct GenericMember {
     \see GenericMember, GenericValue::MemberIterator, GenericValue::ConstMemberIterator
  */
 template <bool Const, typename Encoding, typename Allocator>
-class GenericMemberIterator
-    : public std::iterator<std::random_access_iterator_tag
-        , typename internal::MaybeAddConst<Const,GenericMember<Encoding,Allocator> >::Type> {
+class GenericMemberIterator {
 
     friend class GenericValue<Encoding,Allocator>;
     template <bool, typename, typename> friend class GenericMemberIterator;
 
     typedef GenericMember<Encoding,Allocator> PlainType;
     typedef typename internal::MaybeAddConst<Const,PlainType>::Type ValueType;
-    typedef std::iterator<std::random_access_iterator_tag,ValueType> BaseType;
 
 public:
     //! Iterator type itself
@@ -117,12 +190,21 @@ public:
     //! Non-constant iterator type
     typedef GenericMemberIterator<false,Encoding,Allocator> NonConstIterator;
 
+    /** \name std::iterator_traits support */
+    //@{
+    typedef ValueType      value_type;
+    typedef ValueType *    pointer;
+    typedef ValueType &    reference;
+    typedef std::ptrdiff_t difference_type;
+    typedef std::random_access_iterator_tag iterator_category;
+    //@}
+
     //! Pointer to (const) GenericMember
-    typedef typename BaseType::pointer         Pointer;
+    typedef pointer         Pointer;
     //! Reference to (const) GenericMember
-    typedef typename BaseType::reference       Reference;
+    typedef reference       Reference;
     //! Signed integer type (e.g. \c ptrdiff_t)
-    typedef typename BaseType::difference_type DifferenceType;
+    typedef difference_type DifferenceType;
 
     //! Default constructor (singular value)
     /*! Creates an iterator pointing to no element.
@@ -168,12 +250,16 @@ public:
 
     //! @name relations
     //@{
-    bool operator==(ConstIterator that) const { return ptr_ == that.ptr_; }
-    bool operator!=(ConstIterator that) const { return ptr_ != that.ptr_; }
-    bool operator<=(ConstIterator that) const { return ptr_ <= that.ptr_; }
-    bool operator>=(ConstIterator that) const { return ptr_ >= that.ptr_; }
-    bool operator< (ConstIterator that) const { return ptr_ < that.ptr_; }
-    bool operator> (ConstIterator that) const { return ptr_ > that.ptr_; }
+    template <bool Const_> bool operator==(const GenericMemberIterator<Const_, Encoding, Allocator>& that) const { return ptr_ == that.ptr_; }
+    template <bool Const_> bool operator!=(const GenericMemberIterator<Const_, Encoding, Allocator>& that) const { return ptr_ != that.ptr_; }
+    template <bool Const_> bool operator<=(const GenericMemberIterator<Const_, Encoding, Allocator>& that) const { return ptr_ <= that.ptr_; }
+    template <bool Const_> bool operator>=(const GenericMemberIterator<Const_, Encoding, Allocator>& that) const { return ptr_ >= that.ptr_; }
+    template <bool Const_> bool operator< (const GenericMemberIterator<Const_, Encoding, Allocator>& that) const { return ptr_ < that.ptr_; }
+    template <bool Const_> bool operator> (const GenericMemberIterator<Const_, Encoding, Allocator>& that) const { return ptr_ > that.ptr_; }
+
+#ifdef __cpp_lib_three_way_comparison
+    template <bool Const_> std::strong_ordering operator<=>(const GenericMemberIterator<Const_, Encoding, Allocator>& that) const { return ptr_ <=> that.ptr_; }
+#endif
     //@}
 
     //! @name dereference
@@ -198,17 +284,19 @@ private:
 // class-based member iterator implementation disabled, use plain pointers
 
 template <bool Const, typename Encoding, typename Allocator>
-struct GenericMemberIterator;
+class GenericMemberIterator;
 
 //! non-const GenericMemberIterator
 template <typename Encoding, typename Allocator>
-struct GenericMemberIterator<false,Encoding,Allocator> {
+class GenericMemberIterator<false,Encoding,Allocator> {
+public:
     //! use plain pointer as iterator type
     typedef GenericMember<Encoding,Allocator>* Iterator;
 };
 //! const GenericMemberIterator
 template <typename Encoding, typename Allocator>
-struct GenericMemberIterator<true,Encoding,Allocator> {
+class GenericMemberIterator<true,Encoding,Allocator> {
+public:
     //! use plain const pointer as iterator type
     typedef const GenericMember<Encoding,Allocator>* Iterator;
 };
@@ -445,6 +533,26 @@ struct TypeHelper<ValueType, unsigned> {
     static ValueType& Set(ValueType& v, unsigned data, typename ValueType::AllocatorType&) { return v.SetUint(data); }
 };
 
+#ifdef _MSC_VER
+RAPIDJSON_STATIC_ASSERT(sizeof(long) == sizeof(int));
+template<typename ValueType>
+struct TypeHelper<ValueType, long> {
+    static bool Is(const ValueType& v) { return v.IsInt(); }
+    static long Get(const ValueType& v) { return v.GetInt(); }
+    static ValueType& Set(ValueType& v, long data) { return v.SetInt(data); }
+    static ValueType& Set(ValueType& v, long data, typename ValueType::AllocatorType&) { return v.SetInt(data); }
+};
+
+RAPIDJSON_STATIC_ASSERT(sizeof(unsigned long) == sizeof(unsigned));
+template<typename ValueType>
+struct TypeHelper<ValueType, unsigned long> {
+    static bool Is(const ValueType& v) { return v.IsUint(); }
+    static unsigned long Get(const ValueType& v) { return v.GetUint(); }
+    static ValueType& Set(ValueType& v, unsigned long data) { return v.SetUint(data); }
+    static ValueType& Set(ValueType& v, unsigned long data, typename ValueType::AllocatorType&) { return v.SetUint(data); }
+};
+#endif
+
 template<typename ValueType> 
 struct TypeHelper<ValueType, int64_t> {
     static bool Is(const ValueType& v) { return v.IsInt64(); }
@@ -547,7 +655,7 @@ template <bool, typename> class GenericObject;
     \tparam Encoding    Encoding of the value. (Even non-string values need to have the same encoding in a document)
     \tparam Allocator   Allocator type for allocating memory of object, array and string.
 */
-template <typename Encoding, typename Allocator = MemoryPoolAllocator<> > 
+template <typename Encoding, typename Allocator = RAPIDJSON_DEFAULT_ALLOCATOR >
 class GenericValue {
 public:
     //! Name-value pair in an object.
@@ -601,11 +709,11 @@ public:
         \note Default content for number is zero.
     */
     explicit GenericValue(Type type) RAPIDJSON_NOEXCEPT : data_() {
-        static const uint16_t defaultFlags[7] = {
+        static const uint16_t defaultFlags[] = {
             kNullFlag, kFalseFlag, kTrueFlag, kObjectFlag, kArrayFlag, kShortStringFlag,
             kNumberAnyFlag
         };
-        RAPIDJSON_ASSERT(type >= kNullType && type <= kNumberType);
+        RAPIDJSON_NOEXCEPT_ASSERT(type >= kNullType && type <= kNumberType);
         data_.f.flags = defaultFlags[type];
 
         // Use ShortString to store empty string.
@@ -807,9 +915,10 @@ public:
     /*! \param rhs Source of the assignment. It will become a null value after assignment.
     */
     GenericValue& operator=(GenericValue& rhs) RAPIDJSON_NOEXCEPT {
-        RAPIDJSON_ASSERT(this != &rhs);
-        this->~GenericValue();
-        RawAssign(rhs);
+        if (RAPIDJSON_LIKELY(this != &rhs)) {
+            this->~GenericValue();
+            RawAssign(rhs);
+        }
         return *this;
     }
 
@@ -901,7 +1010,7 @@ public:
     //! Equal-to operator
     /*!
         \note If an object contains duplicated named member, comparing equality with any object is always \c false.
-        \note Linear time complexity (number of all values in the subtree and total lengths of all strings).
+        \note Complexity is quadratic in Object's member number and linear for the rest (number of all values in the subtree and total lengths of all strings).
     */
     template <typename SourceAllocator>
     bool operator==(const GenericValue<Encoding, SourceAllocator>& rhs) const {
@@ -1070,6 +1179,9 @@ public:
     //! Get the number of members in the object.
     SizeType MemberCount() const { RAPIDJSON_ASSERT(IsObject()); return data_.o.size; }
 
+    //! Get the capacity of object.
+    SizeType MemberCapacity() const { RAPIDJSON_ASSERT(IsObject()); return data_.o.capacity; }
+
     //! Check whether the object is empty.
     bool ObjectEmpty() const { RAPIDJSON_ASSERT(IsObject()); return data_.o.size == 0; }
 
@@ -1138,6 +1250,21 @@ public:
     /*! \pre IsObject() == true */
     MemberIterator MemberEnd()              { RAPIDJSON_ASSERT(IsObject()); return MemberIterator(GetMembersPointer() + data_.o.size); }
 
+    //! Request the object to have enough capacity to store members.
+    /*! \param newCapacity  The capacity that the object at least need to have.
+        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
+        \return The value itself for fluent API.
+        \note Linear time complexity.
+    */
+    GenericValue& MemberReserve(SizeType newCapacity, Allocator &allocator) {
+        RAPIDJSON_ASSERT(IsObject());
+        if (newCapacity > data_.o.capacity) {
+            SetMembersPointer(reinterpret_cast<Member*>(allocator.Realloc(GetMembersPointer(), data_.o.capacity * sizeof(Member), newCapacity * sizeof(Member))));
+            data_.o.capacity = newCapacity;
+        }
+        return *this;
+    }
+
     //! Check whether a member exists in the object.
     /*!
         \param name Member name to be searched.
@@ -1243,17 +1370,8 @@ public:
         RAPIDJSON_ASSERT(name.IsString());
 
         ObjectData& o = data_.o;
-        if (o.size >= o.capacity) {
-            if (o.capacity == 0) {
-                o.capacity = kDefaultObjectCapacity;
-                SetMembersPointer(reinterpret_cast<Member*>(allocator.Malloc(o.capacity * sizeof(Member))));
-            }
-            else {
-                SizeType oldCapacity = o.capacity;
-                o.capacity += (oldCapacity + 1) / 2; // grow by factor 1.5
-                SetMembersPointer(reinterpret_cast<Member*>(allocator.Realloc(GetMembersPointer(), oldCapacity * sizeof(Member), o.capacity * sizeof(Member))));
-            }
-        }
+        if (o.size >= o.capacity)
+            MemberReserve(o.capacity == 0 ? kDefaultObjectCapacity : (o.capacity + (o.capacity + 1) / 2), allocator);
         Member* members = GetMembersPointer();
         members[o.size].name.RawAssign(name);
         members[o.size].value.RawAssign(value);
@@ -1480,7 +1598,7 @@ public:
         MemberIterator pos = MemberBegin() + (first - MemberBegin());
         for (MemberIterator itr = pos; itr != last; ++itr)
             itr->~Member();
-        std::memmove(&*pos, &*last, static_cast<size_t>(MemberEnd() - last) * sizeof(Member));
+        std::memmove(static_cast<void*>(&*pos), &*last, static_cast<size_t>(MemberEnd() - last) * sizeof(Member));
         data_.o.size -= static_cast<SizeType>(last - first);
         return pos;
     }
@@ -1683,8 +1801,8 @@ public:
         RAPIDJSON_ASSERT(last <= End());
         ValueIterator pos = Begin() + (first - Begin());
         for (ValueIterator itr = pos; itr != last; ++itr)
-            itr->~GenericValue();       
-        std::memmove(pos, last, static_cast<size_t>(End() - last) * sizeof(GenericValue));
+            itr->~GenericValue();
+        std::memmove(static_cast<void*>(pos), last, static_cast<size_t>(End() - last) * sizeof(GenericValue));
         data_.a.size -= static_cast<SizeType>(last - first);
         return pos;
     }
@@ -1885,25 +2003,26 @@ private:
 
         // Initial flags of different types.
         kNullFlag = kNullType,
-        kTrueFlag = kTrueType | kBoolFlag,
-        kFalseFlag = kFalseType | kBoolFlag,
-        kNumberIntFlag = kNumberType | kNumberFlag | kIntFlag | kInt64Flag,
-        kNumberUintFlag = kNumberType | kNumberFlag | kUintFlag | kUint64Flag | kInt64Flag,
-        kNumberInt64Flag = kNumberType | kNumberFlag | kInt64Flag,
-        kNumberUint64Flag = kNumberType | kNumberFlag | kUint64Flag,
-        kNumberDoubleFlag = kNumberType | kNumberFlag | kDoubleFlag,
-        kNumberAnyFlag = kNumberType | kNumberFlag | kIntFlag | kInt64Flag | kUintFlag | kUint64Flag | kDoubleFlag,
-        kConstStringFlag = kStringType | kStringFlag,
-        kCopyStringFlag = kStringType | kStringFlag | kCopyFlag,
-        kShortStringFlag = kStringType | kStringFlag | kCopyFlag | kInlineStrFlag,
+        // These casts are added to suppress the warning on MSVC about bitwise operations between enums of different types.
+        kTrueFlag = static_cast<int>(kTrueType) | static_cast<int>(kBoolFlag),
+        kFalseFlag = static_cast<int>(kFalseType) | static_cast<int>(kBoolFlag),
+        kNumberIntFlag = static_cast<int>(kNumberType) | static_cast<int>(kNumberFlag | kIntFlag | kInt64Flag),
+        kNumberUintFlag = static_cast<int>(kNumberType) | static_cast<int>(kNumberFlag | kUintFlag | kUint64Flag | kInt64Flag),
+        kNumberInt64Flag = static_cast<int>(kNumberType) | static_cast<int>(kNumberFlag | kInt64Flag),
+        kNumberUint64Flag = static_cast<int>(kNumberType) | static_cast<int>(kNumberFlag | kUint64Flag),
+        kNumberDoubleFlag = static_cast<int>(kNumberType) | static_cast<int>(kNumberFlag | kDoubleFlag),
+        kNumberAnyFlag = static_cast<int>(kNumberType) | static_cast<int>(kNumberFlag | kIntFlag | kInt64Flag | kUintFlag | kUint64Flag | kDoubleFlag),
+        kConstStringFlag = static_cast<int>(kStringType) | static_cast<int>(kStringFlag),
+        kCopyStringFlag = static_cast<int>(kStringType) | static_cast<int>(kStringFlag | kCopyFlag),
+        kShortStringFlag = static_cast<int>(kStringType) | static_cast<int>(kStringFlag | kCopyFlag | kInlineStrFlag),
         kObjectFlag = kObjectType,
         kArrayFlag = kArrayType,
 
         kTypeMask = 0x07
     };
 
-    static const SizeType kDefaultArrayCapacity = 16;
-    static const SizeType kDefaultObjectCapacity = 16;
+    static const SizeType kDefaultArrayCapacity = RAPIDJSON_VALUE_DEFAULT_ARRAY_CAPACITY;
+    static const SizeType kDefaultObjectCapacity = RAPIDJSON_VALUE_DEFAULT_OBJECT_CAPACITY;
 
     struct Flag {
 #if RAPIDJSON_48BITPOINTER_OPTIMIZATION
@@ -1999,7 +2118,7 @@ private:
         if (count) {
             GenericValue* e = static_cast<GenericValue*>(allocator.Malloc(count * sizeof(GenericValue)));
             SetElementsPointer(e);
-            std::memcpy(e, values, count * sizeof(GenericValue));
+            std::memcpy(static_cast<void*>(e), values, count * sizeof(GenericValue));
         }
         else
             SetElementsPointer(0);
@@ -2012,7 +2131,7 @@ private:
         if (count) {
             Member* m = static_cast<Member*>(allocator.Malloc(count * sizeof(Member)));
             SetMembersPointer(m);
-            std::memcpy(m, members, count * sizeof(Member));
+            std::memcpy(static_cast<void*>(m), members, count * sizeof(Member));
         }
         else
             SetMembersPointer(0);
@@ -2083,7 +2202,7 @@ typedef GenericValue<UTF8<> > Value;
     \tparam StackAllocator Allocator for allocating memory for stack during parsing.
     \warning Although GenericDocument inherits from GenericValue, the API does \b not provide any virtual functions, especially no virtual destructor.  To avoid memory leaks, do not \c delete a GenericDocument object via a pointer to a GenericValue.
 */
-template <typename Encoding, typename Allocator = MemoryPoolAllocator<>, typename StackAllocator = CrtAllocator>
+template <typename Encoding, typename Allocator = RAPIDJSON_DEFAULT_ALLOCATOR, typename StackAllocator = RAPIDJSON_DEFAULT_STACK_ALLOCATOR >
 class GenericDocument : public GenericValue<Encoding, Allocator> {
 public:
     typedef typename Encoding::Ch Ch;                       //!< Character type derived from Encoding.
@@ -2347,7 +2466,7 @@ public:
     //!@name Handling parse errors
     //!@{
 
-    //! Whether a parse error has occured in the last parsing.
+    //! Whether a parse error has occurred in the last parsing.
     bool HasParseError() const { return parseResult_.IsError(); }
 
     //! Get the \ref ParseErrorCode of last parsing.
@@ -2468,6 +2587,7 @@ private:
 //! GenericDocument with UTF8 encoding
 typedef GenericDocument<UTF8<> > Document;
 
+
 //! Helper class for accessing Value of array type.
 /*!
     Instance of this helper class is obtained by \c GenericValue::GetArray().
@@ -2492,6 +2612,7 @@ public:
     GenericArray& operator=(const GenericArray& rhs) { value_ = rhs.value_; return *this; }
     ~GenericArray() {}
 
+    operator ValueType&() const { return value_; }
     SizeType Size() const { return value_.Size(); }
     SizeType Capacity() const { return value_.Capacity(); }
     bool Empty() const { return value_.Empty(); }
@@ -2547,7 +2668,9 @@ public:
     GenericObject& operator=(const GenericObject& rhs) { value_ = rhs.value_; return *this; }
     ~GenericObject() {}
 
+    operator ValueType&() const { return value_; }
     SizeType MemberCount() const { return value_.MemberCount(); }
+    SizeType MemberCapacity() const { return value_.MemberCapacity(); }
     bool ObjectEmpty() const { return value_.ObjectEmpty(); }
     template <typename T> ValueType& operator[](T* name) const { return value_[name]; }
     template <typename SourceAllocator> ValueType& operator[](const GenericValue<EncodingType, SourceAllocator>& name) const { return value_[name]; }
@@ -2556,6 +2679,7 @@ public:
 #endif
     MemberIterator MemberBegin() const { return value_.MemberBegin(); }
     MemberIterator MemberEnd() const { return value_.MemberEnd(); }
+    GenericObject MemberReserve(SizeType newCapacity, AllocatorType &allocator) const { value_.MemberReserve(newCapacity, allocator); return *this; }
     bool HasMember(const Ch* name) const { return value_.HasMember(name); }
 #if RAPIDJSON_HAS_STDSTRING
     bool HasMember(const std::basic_string<Ch>& name) const { return value_.HasMember(name); }
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/encodedstream.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/encodedstream.h
index 223601c05..cf046b892 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/encodedstream.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/encodedstream.h
@@ -1,6 +1,6 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
 // 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/encodings.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/encodings.h
index 0df1c3435..50ad18bdc 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/encodings.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/encodings.h
@@ -1,6 +1,6 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
 // 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
@@ -17,7 +17,7 @@
 
 #include "rapidjson.h"
 
-#ifdef _MSC_VER
+#if defined(_MSC_VER) && !defined(__clang__)
 RAPIDJSON_DIAG_PUSH
 RAPIDJSON_DIAG_OFF(4244) // conversion from 'type1' to 'type2', possible loss of data
 RAPIDJSON_DIAG_OFF(4702)  // unreachable code
@@ -144,9 +144,9 @@ struct UTF8 {
 
     template <typename InputStream>
     static bool Decode(InputStream& is, unsigned* codepoint) {
-#define COPY() c = is.Take(); *codepoint = (*codepoint << 6) | (static_cast<unsigned char>(c) & 0x3Fu)
-#define TRANS(mask) result &= ((GetRange(static_cast<unsigned char>(c)) & mask) != 0)
-#define TAIL() COPY(); TRANS(0x70)
+#define RAPIDJSON_COPY() c = is.Take(); *codepoint = (*codepoint << 6) | (static_cast<unsigned char>(c) & 0x3Fu)
+#define RAPIDJSON_TRANS(mask) result &= ((GetRange(static_cast<unsigned char>(c)) & mask) != 0)
+#define RAPIDJSON_TAIL() RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x70)
         typename InputStream::Ch c = is.Take();
         if (!(c & 0x80)) {
             *codepoint = static_cast<unsigned char>(c);
@@ -161,44 +161,44 @@ struct UTF8 {
         }
         bool result = true;
         switch (type) {
-        case 2: TAIL(); return result;
-        case 3: TAIL(); TAIL(); return result;
-        case 4: COPY(); TRANS(0x50); TAIL(); return result;
-        case 5: COPY(); TRANS(0x10); TAIL(); TAIL(); return result;
-        case 6: TAIL(); TAIL(); TAIL(); return result;
-        case 10: COPY(); TRANS(0x20); TAIL(); return result;
-        case 11: COPY(); TRANS(0x60); TAIL(); TAIL(); return result;
+        case 2: RAPIDJSON_TAIL(); return result;
+        case 3: RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result;
+        case 4: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x50); RAPIDJSON_TAIL(); return result;
+        case 5: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x10); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result;
+        case 6: RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result;
+        case 10: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x20); RAPIDJSON_TAIL(); return result;
+        case 11: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x60); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result;
         default: return false;
         }
-#undef COPY
-#undef TRANS
-#undef TAIL
+#undef RAPIDJSON_COPY
+#undef RAPIDJSON_TRANS
+#undef RAPIDJSON_TAIL
     }
 
     template <typename InputStream, typename OutputStream>
     static bool Validate(InputStream& is, OutputStream& os) {
-#define COPY() os.Put(c = is.Take())
-#define TRANS(mask) result &= ((GetRange(static_cast<unsigned char>(c)) & mask) != 0)
-#define TAIL() COPY(); TRANS(0x70)
+#define RAPIDJSON_COPY() os.Put(c = is.Take())
+#define RAPIDJSON_TRANS(mask) result &= ((GetRange(static_cast<unsigned char>(c)) & mask) != 0)
+#define RAPIDJSON_TAIL() RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x70)
         Ch c;
-        COPY();
+        RAPIDJSON_COPY();
         if (!(c & 0x80))
             return true;
 
         bool result = true;
         switch (GetRange(static_cast<unsigned char>(c))) {
-        case 2: TAIL(); return result;
-        case 3: TAIL(); TAIL(); return result;
-        case 4: COPY(); TRANS(0x50); TAIL(); return result;
-        case 5: COPY(); TRANS(0x10); TAIL(); TAIL(); return result;
-        case 6: TAIL(); TAIL(); TAIL(); return result;
-        case 10: COPY(); TRANS(0x20); TAIL(); return result;
-        case 11: COPY(); TRANS(0x60); TAIL(); TAIL(); return result;
+        case 2: RAPIDJSON_TAIL(); return result;
+        case 3: RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result;
+        case 4: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x50); RAPIDJSON_TAIL(); return result;
+        case 5: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x10); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result;
+        case 6: RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result;
+        case 10: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x20); RAPIDJSON_TAIL(); return result;
+        case 11: RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x60); RAPIDJSON_TAIL(); RAPIDJSON_TAIL(); return result;
         default: return false;
         }
-#undef COPY
-#undef TRANS
-#undef TAIL
+#undef RAPIDJSON_COPY
+#undef RAPIDJSON_TRANS
+#undef RAPIDJSON_TAIL
     }
 
     static unsigned char GetRange(unsigned char c) {
@@ -384,7 +384,7 @@ struct UTF16BE : UTF16<CharType> {
     static CharType Take(InputByteStream& is) {
         RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
         unsigned c = static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;
-        c |= static_cast<uint8_t>(is.Take());
+        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take()));
         return static_cast<CharType>(c);
     }
 
@@ -709,7 +709,7 @@ struct Transcoder<Encoding, Encoding> {
 
 RAPIDJSON_NAMESPACE_END
 
-#if defined(__GNUC__) || defined(_MSC_VER)
+#if defined(__GNUC__) || (defined(_MSC_VER) && !defined(__clang__))
 RAPIDJSON_DIAG_POP
 #endif
 
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/error/en.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/error/en.h
index 2db838bff..5d2e57b7f 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/error/en.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/error/en.h
@@ -1,6 +1,6 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
 // 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
@@ -65,6 +65,54 @@ inline const RAPIDJSON_ERROR_CHARTYPE* GetParseError_En(ParseErrorCode parseErro
     }
 }
 
+//! Maps error code of validation into error message.
+/*!
+    \ingroup RAPIDJSON_ERRORS
+    \param validateErrorCode Error code obtained from validator.
+    \return the error message.
+    \note User can make a copy of this function for localization.
+        Using switch-case is safer for future modification of error codes.
+*/
+inline const RAPIDJSON_ERROR_CHARTYPE* GetValidateError_En(ValidateErrorCode validateErrorCode) {
+    switch (validateErrorCode) {
+        case kValidateErrors:                           return RAPIDJSON_ERROR_STRING("One or more validation errors have occurred");
+        case kValidateErrorNone:                        return RAPIDJSON_ERROR_STRING("No error.");
+
+        case kValidateErrorMultipleOf:                  return RAPIDJSON_ERROR_STRING("Number '%actual' is not a multiple of the 'multipleOf' value '%expected'.");
+        case kValidateErrorMaximum:                     return RAPIDJSON_ERROR_STRING("Number '%actual' is greater than the 'maximum' value '%expected'.");
+        case kValidateErrorExclusiveMaximum:            return RAPIDJSON_ERROR_STRING("Number '%actual' is greater than or equal to the 'exclusiveMaximum' value '%expected'.");
+        case kValidateErrorMinimum:                     return RAPIDJSON_ERROR_STRING("Number '%actual' is less than the 'minimum' value '%expected'.");
+        case kValidateErrorExclusiveMinimum:            return RAPIDJSON_ERROR_STRING("Number '%actual' is less than or equal to the 'exclusiveMinimum' value '%expected'.");
+
+        case kValidateErrorMaxLength:                   return RAPIDJSON_ERROR_STRING("String '%actual' is longer than the 'maxLength' value '%expected'.");
+        case kValidateErrorMinLength:                   return RAPIDJSON_ERROR_STRING("String '%actual' is shorter than the 'minLength' value '%expected'.");
+        case kValidateErrorPattern:                     return RAPIDJSON_ERROR_STRING("String '%actual' does not match the 'pattern' regular expression.");
+
+        case kValidateErrorMaxItems:                    return RAPIDJSON_ERROR_STRING("Array of length '%actual' is longer than the 'maxItems' value '%expected'.");
+        case kValidateErrorMinItems:                    return RAPIDJSON_ERROR_STRING("Array of length '%actual' is shorter than the 'minItems' value '%expected'.");
+        case kValidateErrorUniqueItems:                 return RAPIDJSON_ERROR_STRING("Array has duplicate items at indices '%duplicates' but 'uniqueItems' is true.");
+        case kValidateErrorAdditionalItems:             return RAPIDJSON_ERROR_STRING("Array has an additional item at index '%disallowed' that is not allowed by the schema.");
+
+        case kValidateErrorMaxProperties:               return RAPIDJSON_ERROR_STRING("Object has '%actual' members which is more than 'maxProperties' value '%expected'.");
+        case kValidateErrorMinProperties:               return RAPIDJSON_ERROR_STRING("Object has '%actual' members which is less than 'minProperties' value '%expected'.");
+        case kValidateErrorRequired:                    return RAPIDJSON_ERROR_STRING("Object is missing the following members required by the schema: '%missing'.");
+        case kValidateErrorAdditionalProperties:        return RAPIDJSON_ERROR_STRING("Object has an additional member '%disallowed' that is not allowed by the schema.");
+        case kValidateErrorPatternProperties:           return RAPIDJSON_ERROR_STRING("Object has 'patternProperties' that are not allowed by the schema.");
+        case kValidateErrorDependencies:                return RAPIDJSON_ERROR_STRING("Object has missing property or schema dependencies, refer to following errors.");
+
+        case kValidateErrorEnum:                        return RAPIDJSON_ERROR_STRING("Property has a value that is not one of its allowed enumerated values.");
+        case kValidateErrorType:                        return RAPIDJSON_ERROR_STRING("Property has a type '%actual' that is not in the following list: '%expected'.");
+
+        case kValidateErrorOneOf:                       return RAPIDJSON_ERROR_STRING("Property did not match any of the sub-schemas specified by 'oneOf', refer to following errors.");
+        case kValidateErrorOneOfMatch:                  return RAPIDJSON_ERROR_STRING("Property matched more than one of the sub-schemas specified by 'oneOf'.");
+        case kValidateErrorAllOf:                       return RAPIDJSON_ERROR_STRING("Property did not match all of the sub-schemas specified by 'allOf', refer to following errors.");
+        case kValidateErrorAnyOf:                       return RAPIDJSON_ERROR_STRING("Property did not match any of the sub-schemas specified by 'anyOf', refer to following errors.");
+        case kValidateErrorNot:                         return RAPIDJSON_ERROR_STRING("Property matched the sub-schema specified by 'not'.");
+
+        default:                                        return RAPIDJSON_ERROR_STRING("Unknown error.");
+    }
+}
+
 RAPIDJSON_NAMESPACE_END
 
 #ifdef __clang__
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/error/error.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/error/error.h
index 9311d2f03..6270da11a 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/error/error.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/error/error.h
@@ -1,6 +1,6 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
 // 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
@@ -152,6 +152,61 @@ private:
 */
 typedef const RAPIDJSON_ERROR_CHARTYPE* (*GetParseErrorFunc)(ParseErrorCode);
 
+///////////////////////////////////////////////////////////////////////////////
+// ValidateErrorCode
+
+//! Error codes when validating.
+/*! \ingroup RAPIDJSON_ERRORS
+    \see GenericSchemaValidator
+*/
+enum ValidateErrorCode {
+    kValidateErrors    = -1,                   //!< Top level error code when kValidateContinueOnErrorsFlag set.
+    kValidateErrorNone = 0,                    //!< No error.
+
+    kValidateErrorMultipleOf,                  //!< Number is not a multiple of the 'multipleOf' value.
+    kValidateErrorMaximum,                     //!< Number is greater than the 'maximum' value.
+    kValidateErrorExclusiveMaximum,            //!< Number is greater than or equal to the 'maximum' value.
+    kValidateErrorMinimum,                     //!< Number is less than the 'minimum' value.
+    kValidateErrorExclusiveMinimum,            //!< Number is less than or equal to the 'minimum' value.
+
+    kValidateErrorMaxLength,                   //!< String is longer than the 'maxLength' value.
+    kValidateErrorMinLength,                   //!< String is longer than the 'maxLength' value.
+    kValidateErrorPattern,                     //!< String does not match the 'pattern' regular expression.
+
+    kValidateErrorMaxItems,                    //!< Array is longer than the 'maxItems' value.
+    kValidateErrorMinItems,                    //!< Array is shorter than the 'minItems' value.
+    kValidateErrorUniqueItems,                 //!< Array has duplicate items but 'uniqueItems' is true.
+    kValidateErrorAdditionalItems,             //!< Array has additional items that are not allowed by the schema.
+
+    kValidateErrorMaxProperties,               //!< Object has more members than 'maxProperties' value.
+    kValidateErrorMinProperties,               //!< Object has less members than 'minProperties' value.
+    kValidateErrorRequired,                    //!< Object is missing one or more members required by the schema.
+    kValidateErrorAdditionalProperties,        //!< Object has additional members that are not allowed by the schema.
+    kValidateErrorPatternProperties,           //!< See other errors.
+    kValidateErrorDependencies,                //!< Object has missing property or schema dependencies.
+
+    kValidateErrorEnum,                        //!< Property has a value that is not one of its allowed enumerated values
+    kValidateErrorType,                        //!< Property has a type that is not allowed by the schema..
+
+    kValidateErrorOneOf,                       //!< Property did not match any of the sub-schemas specified by 'oneOf'.
+    kValidateErrorOneOfMatch,                  //!< Property matched more than one of the sub-schemas specified by 'oneOf'.
+    kValidateErrorAllOf,                       //!< Property did not match all of the sub-schemas specified by 'allOf'.
+    kValidateErrorAnyOf,                       //!< Property did not match any of the sub-schemas specified by 'anyOf'.
+    kValidateErrorNot                          //!< Property matched the sub-schema specified by 'not'.
+};
+
+//! Function pointer type of GetValidateError().
+/*! \ingroup RAPIDJSON_ERRORS
+
+    This is the prototype for \c GetValidateError_X(), where \c X is a locale.
+    User can dynamically change locale in runtime, e.g.:
+\code
+    GetValidateErrorFunc GetValidateError = GetValidateError_En; // or whatever
+    const RAPIDJSON_ERROR_CHARTYPE* s = GetValidateError(validator.GetInvalidSchemaCode());
+\endcode
+*/
+typedef const RAPIDJSON_ERROR_CHARTYPE* (*GetValidateErrorFunc)(ValidateErrorCode);
+
 RAPIDJSON_NAMESPACE_END
 
 #ifdef __clang__
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/filereadstream.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/filereadstream.h
index b56ea13b3..f8bb43cb0 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/filereadstream.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/filereadstream.h
@@ -1,6 +1,6 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
 // 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
@@ -59,7 +59,7 @@ public:
 
     // For encoding detection only.
     const Ch* Peek4() const {
-        return (current_ + 4 <= bufferLast_) ? current_ : 0;
+        return (current_ + 4 - !eof_ <= bufferLast_) ? current_ : 0;
     }
 
 private:
@@ -68,7 +68,7 @@ private:
             ++current_;
         else if (!eof_) {
             count_ += readCount_;
-            readCount_ = fread(buffer_, 1, bufferSize_, fp_);
+            readCount_ = std::fread(buffer_, 1, bufferSize_, fp_);
             bufferLast_ = buffer_ + readCount_ - 1;
             current_ = buffer_;
 
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/filewritestream.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/filewritestream.h
index 6378dd60e..5d89588c2 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/filewritestream.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/filewritestream.h
@@ -1,6 +1,6 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
 // 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
@@ -25,7 +25,7 @@ RAPIDJSON_DIAG_OFF(unreachable-code)
 
 RAPIDJSON_NAMESPACE_BEGIN
 
-//! Wrapper of C file stream for input using fread().
+//! Wrapper of C file stream for output using fwrite().
 /*!
     \note implements Stream concept
 */
@@ -62,7 +62,7 @@ public:
 
     void Flush() {
         if (current_ != buffer_) {
-            size_t result = fwrite(buffer_, 1, static_cast<size_t>(current_ - buffer_), fp_);
+            size_t result = std::fwrite(buffer_, 1, static_cast<size_t>(current_ - buffer_), fp_);
             if (result < static_cast<size_t>(current_ - buffer_)) {
                 // failure deliberately ignored at this time
                 // added to avoid warn_unused_result build errors
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/fwd.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/fwd.h
index e8104e841..d62f77f0e 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/fwd.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/fwd.h
@@ -1,6 +1,6 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
 // 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
@@ -102,7 +102,7 @@ class PrettyWriter;
 // document.h
 
 template <typename Encoding, typename Allocator> 
-struct GenericMember;
+class GenericMember;
 
 template <bool Const, typename Encoding, typename Allocator>
 class GenericMemberIterator;
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/biginteger.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/biginteger.h
index 9d3e88c99..12455788f 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/biginteger.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/biginteger.h
@@ -1,6 +1,6 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
 // 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
@@ -17,7 +17,7 @@
 
 #include "../rapidjson.h"
 
-#if defined(_MSC_VER) && defined(_M_AMD64)
+#if defined(_MSC_VER) && !defined(__INTEL_COMPILER) && defined(_M_AMD64)
 #include <intrin.h> // for _umul128
 #pragma intrinsic(_umul128)
 #endif
@@ -133,7 +133,7 @@ public:
         RAPIDJSON_ASSERT(count_ + offset <= kCapacity);
 
         if (interShift == 0) {
-            std::memmove(&digits_[count_ - 1 + offset], &digits_[count_ - 1], count_ * sizeof(Type));
+            std::memmove(digits_ + offset, digits_, count_ * sizeof(Type));
             count_ += offset;
         }
         else {
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/clzll.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/clzll.h
new file mode 100644
index 000000000..8fc5118aa
--- /dev/null
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/clzll.h
@@ -0,0 +1,71 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_CLZLL_H_
+#define RAPIDJSON_CLZLL_H_
+
+#include "../rapidjson.h"
+
+#if defined(_MSC_VER) && !defined(UNDER_CE)
+#include <intrin.h>
+#if defined(_WIN64)
+#pragma intrinsic(_BitScanReverse64)
+#else
+#pragma intrinsic(_BitScanReverse)
+#endif
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal {
+
+inline uint32_t clzll(uint64_t x) {
+    // Passing 0 to __builtin_clzll is UB in GCC and results in an
+    // infinite loop in the software implementation.
+    RAPIDJSON_ASSERT(x != 0);
+
+#if defined(_MSC_VER) && !defined(UNDER_CE)
+    unsigned long r = 0;
+#if defined(_WIN64)
+    _BitScanReverse64(&r, x);
+#else
+    // Scan the high 32 bits.
+    if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32)))
+        return 63 - (r + 32);
+
+    // Scan the low 32 bits.
+    _BitScanReverse(&r, static_cast<uint32_t>(x & 0xFFFFFFFF));
+#endif // _WIN64
+
+    return 63 - r;
+#elif (defined(__GNUC__) && __GNUC__ >= 4) || RAPIDJSON_HAS_BUILTIN(__builtin_clzll)
+    // __builtin_clzll wrapper
+    return static_cast<uint32_t>(__builtin_clzll(x));
+#else
+    // naive version
+    uint32_t r = 0;
+    while (!(x & (static_cast<uint64_t>(1) << 63))) {
+        x <<= 1;
+        ++r;
+    }
+
+    return r;
+#endif // _MSC_VER
+}
+
+#define RAPIDJSON_CLZLL RAPIDJSON_NAMESPACE::internal::clzll
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_CLZLL_H_
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/diyfp.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/diyfp.h
index 29abf8046..a40797ec2 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/diyfp.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/diyfp.h
@@ -1,15 +1,15 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
 //
 // http://opensource.org/licenses/MIT
 //
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
 // specific language governing permissions and limitations under the License.
 
 // This is a C++ header-only implementation of Grisu2 algorithm from the publication:
@@ -20,10 +20,11 @@
 #define RAPIDJSON_DIYFP_H_
 
 #include "../rapidjson.h"
+#include "clzll.h"
+#include <limits>
 
 #if defined(_MSC_VER) && defined(_M_AMD64) && !defined(__INTEL_COMPILER)
 #include <intrin.h>
-#pragma intrinsic(_BitScanReverse64)
 #pragma intrinsic(_umul128)
 #endif
 
@@ -56,7 +57,7 @@ struct DiyFp {
         if (biased_e != 0) {
             f = significand + kDpHiddenBit;
             e = biased_e - kDpExponentBias;
-        } 
+        }
         else {
             f = significand;
             e = kDpMinExponent + 1;
@@ -99,21 +100,8 @@ struct DiyFp {
     }
 
     DiyFp Normalize() const {
-#if defined(_MSC_VER) && defined(_M_AMD64)
-        unsigned long index;
-        _BitScanReverse64(&index, f);
-        return DiyFp(f << (63 - index), e - (63 - index));
-#elif defined(__GNUC__) && __GNUC__ >= 4
-        int s = __builtin_clzll(f);
+        int s = static_cast<int>(clzll(f));
         return DiyFp(f << s, e - s);
-#else
-        DiyFp res = *this;
-        while (!(res.f & (static_cast<uint64_t>(1) << 63))) {
-            res.f <<= 1;
-            res.e--;
-        }
-        return res;
-#endif
     }
 
     DiyFp NormalizeBoundary() const {
@@ -141,7 +129,16 @@ struct DiyFp {
             double d;
             uint64_t u64;
         }u;
-        const uint64_t be = (e == kDpDenormalExponent && (f & kDpHiddenBit) == 0) ? 0 : 
+        RAPIDJSON_ASSERT(f <= kDpHiddenBit + kDpSignificandMask);
+        if (e < kDpDenormalExponent) {
+            // Underflow.
+            return 0.0;
+        }
+        if (e >= kDpMaxExponent) {
+            // Overflow.
+            return std::numeric_limits<double>::infinity();
+        }
+        const uint64_t be = (e == kDpDenormalExponent && (f & kDpHiddenBit) == 0) ? 0 :
             static_cast<uint64_t>(e + kDpExponentBias);
         u.u64 = (f & kDpSignificandMask) | (be << kDpSignificandSize);
         return u.d;
@@ -220,9 +217,10 @@ inline DiyFp GetCachedPowerByIndex(size_t index) {
         641,   667,   694,   720,   747,   774,   800,   827,   853,   880,
         907,   933,   960,   986,  1013,  1039,  1066
     };
+    RAPIDJSON_ASSERT(index < 87);
     return DiyFp(kCachedPowers_F[index], kCachedPowers_E[index]);
 }
-    
+
 inline DiyFp GetCachedPower(int e, int* K) {
 
     //int k = static_cast<int>(ceil((-61 - e) * 0.30102999566398114)) + 374;
@@ -238,10 +236,11 @@ inline DiyFp GetCachedPower(int e, int* K) {
 }
 
 inline DiyFp GetCachedPower10(int exp, int *outExp) {
-     unsigned index = (static_cast<unsigned>(exp) + 348u) / 8u;
-     *outExp = -348 + static_cast<int>(index) * 8;
-     return GetCachedPowerByIndex(index);
- }
+    RAPIDJSON_ASSERT(exp >= -348);
+    unsigned index = static_cast<unsigned>(exp + 348) / 8u;
+    *outExp = -348 + static_cast<int>(index) * 8;
+    return GetCachedPowerByIndex(index);
+}
 
 #ifdef __GNUC__
 RAPIDJSON_DIAG_POP
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/dtoa.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/dtoa.h
index bf2e9b2e5..621402fd3 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/dtoa.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/dtoa.h
@@ -1,6 +1,6 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
 // 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/ieee754.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/ieee754.h
index c2684ba2a..68c9e9664 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/ieee754.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/ieee754.h
@@ -1,6 +1,6 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
 // 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/itoa.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/itoa.h
index 01a4e7e72..9fe8c932f 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/itoa.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/itoa.h
@@ -1,15 +1,15 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
 //
 // http://opensource.org/licenses/MIT
 //
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
 // specific language governing permissions and limitations under the License.
 
 #ifndef RAPIDJSON_ITOA_
@@ -37,12 +37,14 @@ inline const char* GetDigitsLut() {
 }
 
 inline char* u32toa(uint32_t value, char* buffer) {
+    RAPIDJSON_ASSERT(buffer != 0);
+
     const char* cDigitsLut = GetDigitsLut();
 
     if (value < 10000) {
         const uint32_t d1 = (value / 100) << 1;
         const uint32_t d2 = (value % 100) << 1;
-        
+
         if (value >= 1000)
             *buffer++ = cDigitsLut[d1];
         if (value >= 100)
@@ -55,13 +57,13 @@ inline char* u32toa(uint32_t value, char* buffer) {
         // value = bbbbcccc
         const uint32_t b = value / 10000;
         const uint32_t c = value % 10000;
-        
+
         const uint32_t d1 = (b / 100) << 1;
         const uint32_t d2 = (b % 100) << 1;
-        
+
         const uint32_t d3 = (c / 100) << 1;
         const uint32_t d4 = (c % 100) << 1;
-        
+
         if (value >= 10000000)
             *buffer++ = cDigitsLut[d1];
         if (value >= 1000000)
@@ -69,7 +71,7 @@ inline char* u32toa(uint32_t value, char* buffer) {
         if (value >= 100000)
             *buffer++ = cDigitsLut[d2];
         *buffer++ = cDigitsLut[d2 + 1];
-        
+
         *buffer++ = cDigitsLut[d3];
         *buffer++ = cDigitsLut[d3 + 1];
         *buffer++ = cDigitsLut[d4];
@@ -77,10 +79,10 @@ inline char* u32toa(uint32_t value, char* buffer) {
     }
     else {
         // value = aabbbbcccc in decimal
-        
+
         const uint32_t a = value / 100000000; // 1 to 42
         value %= 100000000;
-        
+
         if (a >= 10) {
             const unsigned i = a << 1;
             *buffer++ = cDigitsLut[i];
@@ -91,13 +93,13 @@ inline char* u32toa(uint32_t value, char* buffer) {
 
         const uint32_t b = value / 10000; // 0 to 9999
         const uint32_t c = value % 10000; // 0 to 9999
-        
+
         const uint32_t d1 = (b / 100) << 1;
         const uint32_t d2 = (b % 100) << 1;
-        
+
         const uint32_t d3 = (c / 100) << 1;
         const uint32_t d4 = (c % 100) << 1;
-        
+
         *buffer++ = cDigitsLut[d1];
         *buffer++ = cDigitsLut[d1 + 1];
         *buffer++ = cDigitsLut[d2];
@@ -111,6 +113,7 @@ inline char* u32toa(uint32_t value, char* buffer) {
 }
 
 inline char* i32toa(int32_t value, char* buffer) {
+    RAPIDJSON_ASSERT(buffer != 0);
     uint32_t u = static_cast<uint32_t>(value);
     if (value < 0) {
         *buffer++ = '-';
@@ -121,6 +124,7 @@ inline char* i32toa(int32_t value, char* buffer) {
 }
 
 inline char* u64toa(uint64_t value, char* buffer) {
+    RAPIDJSON_ASSERT(buffer != 0);
     const char* cDigitsLut = GetDigitsLut();
     const uint64_t  kTen8 = 100000000;
     const uint64_t  kTen9 = kTen8 * 10;
@@ -131,13 +135,13 @@ inline char* u64toa(uint64_t value, char* buffer) {
     const uint64_t kTen14 = kTen8 * 1000000;
     const uint64_t kTen15 = kTen8 * 10000000;
     const uint64_t kTen16 = kTen8 * kTen8;
-    
+
     if (value < kTen8) {
         uint32_t v = static_cast<uint32_t>(value);
         if (v < 10000) {
             const uint32_t d1 = (v / 100) << 1;
             const uint32_t d2 = (v % 100) << 1;
-            
+
             if (v >= 1000)
                 *buffer++ = cDigitsLut[d1];
             if (v >= 100)
@@ -150,13 +154,13 @@ inline char* u64toa(uint64_t value, char* buffer) {
             // value = bbbbcccc
             const uint32_t b = v / 10000;
             const uint32_t c = v % 10000;
-            
+
             const uint32_t d1 = (b / 100) << 1;
             const uint32_t d2 = (b % 100) << 1;
-            
+
             const uint32_t d3 = (c / 100) << 1;
             const uint32_t d4 = (c % 100) << 1;
-            
+
             if (value >= 10000000)
                 *buffer++ = cDigitsLut[d1];
             if (value >= 1000000)
@@ -164,7 +168,7 @@ inline char* u64toa(uint64_t value, char* buffer) {
             if (value >= 100000)
                 *buffer++ = cDigitsLut[d2];
             *buffer++ = cDigitsLut[d2 + 1];
-            
+
             *buffer++ = cDigitsLut[d3];
             *buffer++ = cDigitsLut[d3 + 1];
             *buffer++ = cDigitsLut[d4];
@@ -174,22 +178,22 @@ inline char* u64toa(uint64_t value, char* buffer) {
     else if (value < kTen16) {
         const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
         const uint32_t v1 = static_cast<uint32_t>(value % kTen8);
-        
+
         const uint32_t b0 = v0 / 10000;
         const uint32_t c0 = v0 % 10000;
-        
+
         const uint32_t d1 = (b0 / 100) << 1;
         const uint32_t d2 = (b0 % 100) << 1;
-        
+
         const uint32_t d3 = (c0 / 100) << 1;
         const uint32_t d4 = (c0 % 100) << 1;
 
         const uint32_t b1 = v1 / 10000;
         const uint32_t c1 = v1 % 10000;
-        
+
         const uint32_t d5 = (b1 / 100) << 1;
         const uint32_t d6 = (b1 % 100) << 1;
-        
+
         const uint32_t d7 = (c1 / 100) << 1;
         const uint32_t d8 = (c1 % 100) << 1;
 
@@ -207,9 +211,8 @@ inline char* u64toa(uint64_t value, char* buffer) {
             *buffer++ = cDigitsLut[d3 + 1];
         if (value >= kTen9)
             *buffer++ = cDigitsLut[d4];
-        if (value >= kTen8)
-            *buffer++ = cDigitsLut[d4 + 1];
-        
+
+        *buffer++ = cDigitsLut[d4 + 1];
         *buffer++ = cDigitsLut[d5];
         *buffer++ = cDigitsLut[d5 + 1];
         *buffer++ = cDigitsLut[d6];
@@ -222,7 +225,7 @@ inline char* u64toa(uint64_t value, char* buffer) {
     else {
         const uint32_t a = static_cast<uint32_t>(value / kTen16); // 1 to 1844
         value %= kTen16;
-        
+
         if (a < 10)
             *buffer++ = static_cast<char>('0' + static_cast<char>(a));
         else if (a < 100) {
@@ -232,7 +235,7 @@ inline char* u64toa(uint64_t value, char* buffer) {
         }
         else if (a < 1000) {
             *buffer++ = static_cast<char>('0' + static_cast<char>(a / 100));
-            
+
             const uint32_t i = (a % 100) << 1;
             *buffer++ = cDigitsLut[i];
             *buffer++ = cDigitsLut[i + 1];
@@ -245,28 +248,28 @@ inline char* u64toa(uint64_t value, char* buffer) {
             *buffer++ = cDigitsLut[j];
             *buffer++ = cDigitsLut[j + 1];
         }
-        
+
         const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
         const uint32_t v1 = static_cast<uint32_t>(value % kTen8);
-        
+
         const uint32_t b0 = v0 / 10000;
         const uint32_t c0 = v0 % 10000;
-        
+
         const uint32_t d1 = (b0 / 100) << 1;
         const uint32_t d2 = (b0 % 100) << 1;
-        
+
         const uint32_t d3 = (c0 / 100) << 1;
         const uint32_t d4 = (c0 % 100) << 1;
-        
+
         const uint32_t b1 = v1 / 10000;
         const uint32_t c1 = v1 % 10000;
-        
+
         const uint32_t d5 = (b1 / 100) << 1;
         const uint32_t d6 = (b1 % 100) << 1;
-        
+
         const uint32_t d7 = (c1 / 100) << 1;
         const uint32_t d8 = (c1 % 100) << 1;
-        
+
         *buffer++ = cDigitsLut[d1];
         *buffer++ = cDigitsLut[d1 + 1];
         *buffer++ = cDigitsLut[d2];
@@ -284,11 +287,12 @@ inline char* u64toa(uint64_t value, char* buffer) {
         *buffer++ = cDigitsLut[d8];
         *buffer++ = cDigitsLut[d8 + 1];
     }
-    
+
     return buffer;
 }
 
 inline char* i64toa(int64_t value, char* buffer) {
+    RAPIDJSON_ASSERT(buffer != 0);
     uint64_t u = static_cast<uint64_t>(value);
     if (value < 0) {
         *buffer++ = '-';
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/meta.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/meta.h
index 5a9aaa428..27092dc0d 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/meta.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/meta.h
@@ -1,6 +1,6 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
 // 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
@@ -21,7 +21,8 @@
 RAPIDJSON_DIAG_PUSH
 RAPIDJSON_DIAG_OFF(effc++)
 #endif
-#if defined(_MSC_VER)
+
+#if defined(_MSC_VER) && !defined(__clang__)
 RAPIDJSON_DIAG_PUSH
 RAPIDJSON_DIAG_OFF(6334)
 #endif
@@ -174,7 +175,11 @@ template <typename T> struct RemoveSfinaeTag<SfinaeTag&(*)(T)> { typedef T Type;
 RAPIDJSON_NAMESPACE_END
 //@endcond
 
-#if defined(__GNUC__) || defined(_MSC_VER)
+#if defined(_MSC_VER) && !defined(__clang__)
+RAPIDJSON_DIAG_POP
+#endif
+
+#ifdef __GNUC__
 RAPIDJSON_DIAG_POP
 #endif
 
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/pow10.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/pow10.h
index 02f475d70..eae1a43ed 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/pow10.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/pow10.h
@@ -1,6 +1,6 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
 // 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/regex.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/regex.h
index e1a2faae5..6446c403a 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/regex.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/regex.h
@@ -1,6 +1,6 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
 // 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
@@ -23,20 +23,14 @@
 RAPIDJSON_DIAG_PUSH
 RAPIDJSON_DIAG_OFF(padded)
 RAPIDJSON_DIAG_OFF(switch-enum)
-RAPIDJSON_DIAG_OFF(implicit-fallthrough)
+#elif defined(_MSC_VER)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
 #endif
 
 #ifdef __GNUC__
 RAPIDJSON_DIAG_PUSH
 RAPIDJSON_DIAG_OFF(effc++)
-#if __GNUC__ >= 7
-RAPIDJSON_DIAG_OFF(implicit-fallthrough)
-#endif
-#endif
-
-#ifdef _MSC_VER
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
 #endif
 
 #ifndef RAPIDJSON_REGEX_VERBOSE
@@ -120,7 +114,8 @@ public:
     template <typename, typename> friend class GenericRegexSearch;
 
     GenericRegex(const Ch* source, Allocator* allocator = 0) : 
-        states_(allocator, 256), ranges_(allocator, 256), root_(kRegexInvalidState), stateCount_(), rangeCount_(), 
+        ownAllocator_(allocator ? 0 : RAPIDJSON_NEW(Allocator)()), allocator_(allocator ? allocator : ownAllocator_), 
+        states_(allocator_, 256), ranges_(allocator_, 256), root_(kRegexInvalidState), stateCount_(), rangeCount_(), 
         anchorBegin_(), anchorEnd_()
     {
         GenericStringStream<Encoding> ss(source);
@@ -128,7 +123,10 @@ public:
         Parse(ds);
     }
 
-    ~GenericRegex() {}
+    ~GenericRegex()
+    {
+        RAPIDJSON_DELETE(ownAllocator_);
+    }
 
     bool IsValid() const {
         return root_ != kRegexInvalidState;
@@ -190,10 +188,9 @@ private:
 
     template <typename InputStream>
     void Parse(DecodedStream<InputStream, Encoding>& ds) {
-        Allocator allocator;
-        Stack<Allocator> operandStack(&allocator, 256);     // Frag
-        Stack<Allocator> operatorStack(&allocator, 256);    // Operator
-        Stack<Allocator> atomCountStack(&allocator, 256);   // unsigned (Atom per parenthesis)
+        Stack<Allocator> operandStack(allocator_, 256);    // Frag
+        Stack<Allocator> operatorStack(allocator_, 256);   // Operator
+        Stack<Allocator> atomCountStack(allocator_, 256);  // unsigned (Atom per parenthesis)
 
         *atomCountStack.template Push<unsigned>() = 0;
 
@@ -290,6 +287,7 @@ private:
                     if (!CharacterEscape(ds, &codepoint))
                         return; // Unsupported escape character
                     // fall through to default
+                    RAPIDJSON_DELIBERATE_FALLTHROUGH;
 
                 default: // Pattern character
                     PushOperand(operandStack, codepoint);
@@ -394,8 +392,7 @@ private:
                 }
                 return false;
 
-            default: 
-                RAPIDJSON_ASSERT(op == kOneOrMore);
+            case kOneOrMore:
                 if (operandStack.GetSize() >= sizeof(Frag)) {
                     Frag e = *operandStack.template Pop<Frag>(1);
                     SizeType s = NewState(kRegexInvalidState, e.start, 0);
@@ -404,6 +401,10 @@ private:
                     return true;
                 }
                 return false;
+
+            default: 
+                // syntax error (e.g. unclosed kLeftParenthesis)
+                return false;
         }
     }
 
@@ -516,6 +517,7 @@ private:
                 else if (!CharacterEscape(ds, &codepoint))
                     return false;
                 // fall through to default
+                RAPIDJSON_DELIBERATE_FALLTHROUGH;
 
             default:
                 switch (step) {
@@ -525,6 +527,7 @@ private:
                         break;
                     }
                     // fall through to step 0 for other characters
+                    RAPIDJSON_DELIBERATE_FALLTHROUGH;
 
                 case 0:
                     {
@@ -584,6 +587,8 @@ private:
         }
     }
 
+    Allocator* ownAllocator_;
+    Allocator* allocator_;
     Stack<Allocator> states_;
     Stack<Allocator> ranges_;
     SizeType root_;
@@ -723,11 +728,11 @@ typedef GenericRegexSearch<Regex> RegexSearch;
 } // namespace internal
 RAPIDJSON_NAMESPACE_END
 
-#ifdef __clang__
+#ifdef __GNUC__
 RAPIDJSON_DIAG_POP
 #endif
 
-#ifdef _MSC_VER
+#if defined(__clang__) || defined(_MSC_VER)
 RAPIDJSON_DIAG_POP
 #endif
 
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/stack.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/stack.h
index 5c5398c35..73abd706e 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/stack.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/stack.h
@@ -1,6 +1,6 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
 // 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
@@ -17,6 +17,7 @@
 
 #include "../allocators.h"
 #include "swap.h"
+#include <cstddef>
 
 #if defined(__clang__)
 RAPIDJSON_DIAG_PUSH
@@ -100,7 +101,7 @@ public:
     void ShrinkToFit() { 
         if (Empty()) {
             // If the stack is empty, completely deallocate the memory.
-            Allocator::Free(stack_);
+            Allocator::Free(stack_); // NOLINT (+clang-analyzer-unix.Malloc)
             stack_ = 0;
             stackTop_ = 0;
             stackEnd_ = 0;
@@ -114,7 +115,7 @@ public:
     template<typename T>
     RAPIDJSON_FORCEINLINE void Reserve(size_t count = 1) {
          // Expand the stack if needed
-        if (RAPIDJSON_UNLIKELY(stackTop_ + sizeof(T) * count > stackEnd_))
+        if (RAPIDJSON_UNLIKELY(static_cast<std::ptrdiff_t>(sizeof(T) * count) > (stackEnd_ - stackTop_)))
             Expand<T>(count);
     }
 
@@ -127,7 +128,7 @@ public:
     template<typename T>
     RAPIDJSON_FORCEINLINE T* PushUnsafe(size_t count = 1) {
         RAPIDJSON_ASSERT(stackTop_);
-        RAPIDJSON_ASSERT(stackTop_ + sizeof(T) * count <= stackEnd_);
+        RAPIDJSON_ASSERT(static_cast<std::ptrdiff_t>(sizeof(T) * count) <= (stackEnd_ - stackTop_));
         T* ret = reinterpret_cast<T*>(stackTop_);
         stackTop_ += sizeof(T) * count;
         return ret;
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/strfunc.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/strfunc.h
index 226439a76..baecb6cc8 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/strfunc.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/strfunc.h
@@ -1,6 +1,6 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
 // 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/strtod.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/strtod.h
index adf49e349..d61a67a49 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/strtod.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/strtod.h
@@ -1,6 +1,6 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
 // 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
@@ -19,6 +19,8 @@
 #include "biginteger.h"
 #include "diyfp.h"
 #include "pow10.h"
+#include <climits>
+#include <limits>
 
 RAPIDJSON_NAMESPACE_BEGIN
 namespace internal {
@@ -126,20 +128,20 @@ inline bool StrtodFast(double d, int p, double* result) {
 }
 
 // Compute an approximation and see if it is within 1/2 ULP
-inline bool StrtodDiyFp(const char* decimals, size_t length, size_t decimalPosition, int exp, double* result) {
+inline bool StrtodDiyFp(const char* decimals, int dLen, int dExp, double* result) {
     uint64_t significand = 0;
-    size_t i = 0;   // 2^64 - 1 = 18446744073709551615, 1844674407370955161 = 0x1999999999999999    
-    for (; i < length; i++) {
+    int i = 0;   // 2^64 - 1 = 18446744073709551615, 1844674407370955161 = 0x1999999999999999    
+    for (; i < dLen; i++) {
         if (significand  >  RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) ||
             (significand == RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) && decimals[i] > '5'))
             break;
         significand = significand * 10u + static_cast<unsigned>(decimals[i] - '0');
     }
     
-    if (i < length && decimals[i] >= '5') // Rounding
+    if (i < dLen && decimals[i] >= '5') // Rounding
         significand++;
 
-    size_t remaining = length - i;
+    int remaining = dLen - i;
     const int kUlpShift = 3;
     const int kUlp = 1 << kUlpShift;
     int64_t error = (remaining == 0) ? 0 : kUlp / 2;
@@ -148,24 +150,24 @@ inline bool StrtodDiyFp(const char* decimals, size_t length, size_t decimalPosit
     v = v.Normalize();
     error <<= -v.e;
 
-    const int dExp = static_cast<int>(decimalPosition) - static_cast<int>(i) + exp;
+    dExp += remaining;
 
     int actualExp;
     DiyFp cachedPower = GetCachedPower10(dExp, &actualExp);
     if (actualExp != dExp) {
         static const DiyFp kPow10[] = {
-            DiyFp(RAPIDJSON_UINT64_C2(0xa0000000, 00000000), -60),  // 10^1
-            DiyFp(RAPIDJSON_UINT64_C2(0xc8000000, 00000000), -57),  // 10^2
-            DiyFp(RAPIDJSON_UINT64_C2(0xfa000000, 00000000), -54),  // 10^3
-            DiyFp(RAPIDJSON_UINT64_C2(0x9c400000, 00000000), -50),  // 10^4
-            DiyFp(RAPIDJSON_UINT64_C2(0xc3500000, 00000000), -47),  // 10^5
-            DiyFp(RAPIDJSON_UINT64_C2(0xf4240000, 00000000), -44),  // 10^6
-            DiyFp(RAPIDJSON_UINT64_C2(0x98968000, 00000000), -40)   // 10^7
+            DiyFp(RAPIDJSON_UINT64_C2(0xa0000000, 0x00000000), -60),  // 10^1
+            DiyFp(RAPIDJSON_UINT64_C2(0xc8000000, 0x00000000), -57),  // 10^2
+            DiyFp(RAPIDJSON_UINT64_C2(0xfa000000, 0x00000000), -54),  // 10^3
+            DiyFp(RAPIDJSON_UINT64_C2(0x9c400000, 0x00000000), -50),  // 10^4
+            DiyFp(RAPIDJSON_UINT64_C2(0xc3500000, 0x00000000), -47),  // 10^5
+            DiyFp(RAPIDJSON_UINT64_C2(0xf4240000, 0x00000000), -44),  // 10^6
+            DiyFp(RAPIDJSON_UINT64_C2(0x98968000, 0x00000000), -40)   // 10^7
         };
-        int  adjustment = dExp - actualExp - 1;
-        RAPIDJSON_ASSERT(adjustment >= 0 && adjustment < 7);
-        v = v * kPow10[adjustment];
-        if (length + static_cast<unsigned>(adjustment)> 19u) // has more digits than decimal digits in 64-bit
+        int adjustment = dExp - actualExp;
+        RAPIDJSON_ASSERT(adjustment >= 1 && adjustment < 8);
+        v = v * kPow10[adjustment - 1];
+        if (dLen + adjustment > 19) // has more digits than decimal digits in 64-bit
             error += kUlp / 2;
     }
 
@@ -203,9 +205,9 @@ inline bool StrtodDiyFp(const char* decimals, size_t length, size_t decimalPosit
     return halfWay - static_cast<unsigned>(error) >= precisionBits || precisionBits >= halfWay + static_cast<unsigned>(error);
 }
 
-inline double StrtodBigInteger(double approx, const char* decimals, size_t length, size_t decimalPosition, int exp) {
-    const BigInteger dInt(decimals, length);
-    const int dExp = static_cast<int>(decimalPosition) - static_cast<int>(length) + exp;
+inline double StrtodBigInteger(double approx, const char* decimals, int dLen, int dExp) {
+    RAPIDJSON_ASSERT(dLen >= 0);
+    const BigInteger dInt(decimals, static_cast<unsigned>(dLen));
     Double a(approx);
     int cmp = CheckWithinHalfULP(a.Value(), dInt, dExp);
     if (cmp < 0)
@@ -225,42 +227,61 @@ inline double StrtodFullPrecision(double d, int p, const char* decimals, size_t
     RAPIDJSON_ASSERT(d >= 0.0);
     RAPIDJSON_ASSERT(length >= 1);
 
-    double result;
+    double result = 0.0;
     if (StrtodFast(d, p, &result))
         return result;
 
+    RAPIDJSON_ASSERT(length <= INT_MAX);
+    int dLen = static_cast<int>(length);
+
+    RAPIDJSON_ASSERT(length >= decimalPosition);
+    RAPIDJSON_ASSERT(length - decimalPosition <= INT_MAX);
+    int dExpAdjust = static_cast<int>(length - decimalPosition);
+
+    RAPIDJSON_ASSERT(exp >= INT_MIN + dExpAdjust);
+    int dExp = exp - dExpAdjust;
+
+    // Make sure length+dExp does not overflow
+    RAPIDJSON_ASSERT(dExp <= INT_MAX - dLen);
+
     // Trim leading zeros
-    while (*decimals == '0' && length > 1) {
-        length--;
+    while (dLen > 0 && *decimals == '0') {
+        dLen--;
         decimals++;
-        decimalPosition--;
     }
 
     // Trim trailing zeros
-    while (decimals[length - 1] == '0' && length > 1) {
-        length--;
-        decimalPosition--;
-        exp++;
+    while (dLen > 0 && decimals[dLen - 1] == '0') {
+        dLen--;
+        dExp++;
+    }
+
+    if (dLen == 0) { // Buffer only contains zeros.
+        return 0.0;
     }
 
     // Trim right-most digits
-    const int kMaxDecimalDigit = 780;
-    if (static_cast<int>(length) > kMaxDecimalDigit) {
-        int delta = (static_cast<int>(length) - kMaxDecimalDigit);
-        exp += delta;
-        decimalPosition -= static_cast<unsigned>(delta);
-        length = kMaxDecimalDigit;
+    const int kMaxDecimalDigit = 767 + 1;
+    if (dLen > kMaxDecimalDigit) {
+        dExp += dLen - kMaxDecimalDigit;
+        dLen = kMaxDecimalDigit;
     }
 
-    // If too small, underflow to zero
-    if (int(length) + exp < -324)
+    // If too small, underflow to zero.
+    // Any x <= 10^-324 is interpreted as zero.
+    if (dLen + dExp <= -324)
         return 0.0;
 
-    if (StrtodDiyFp(decimals, length, decimalPosition, exp, &result))
+    // If too large, overflow to infinity.
+    // Any x >= 10^309 is interpreted as +infinity.
+    if (dLen + dExp > 309)
+        return std::numeric_limits<double>::infinity();
+
+    if (StrtodDiyFp(decimals, dLen, dExp, &result))
         return result;
 
     // Use approximation from StrtodDiyFp and make adjustment with BigInteger comparison
-    return StrtodBigInteger(result, decimals, length, decimalPosition, exp);
+    return StrtodBigInteger(result, decimals, dLen, dExp);
 }
 
 } // namespace internal
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/swap.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/swap.h
index 666e49f97..2cf92f93a 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/swap.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/internal/swap.h
@@ -1,6 +1,6 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
 //
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/istreamwrapper.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/istreamwrapper.h
index 8639c8c3c..01437ec01 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/istreamwrapper.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/istreamwrapper.h
@@ -1,6 +1,6 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
 // 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
@@ -17,13 +17,12 @@
 
 #include "stream.h"
 #include <iosfwd>
+#include <ios>
 
 #ifdef __clang__
 RAPIDJSON_DIAG_PUSH
 RAPIDJSON_DIAG_OFF(padded)
-#endif
-
-#ifdef _MSC_VER
+#elif defined(_MSC_VER)
 RAPIDJSON_DIAG_PUSH
 RAPIDJSON_DIAG_OFF(4351) // new behavior: elements of array 'array' will be default initialized
 #endif
@@ -50,57 +49,71 @@ template <typename StreamType>
 class BasicIStreamWrapper {
 public:
     typedef typename StreamType::char_type Ch;
-    BasicIStreamWrapper(StreamType& stream) : stream_(stream), count_(), peekBuffer_() {}
 
-    Ch Peek() const { 
-        typename StreamType::int_type c = stream_.peek();
-        return RAPIDJSON_LIKELY(c != StreamType::traits_type::eof()) ? static_cast<Ch>(c) : static_cast<Ch>('\0');
+    //! Constructor.
+    /*!
+        \param stream stream opened for read.
+    */
+    BasicIStreamWrapper(StreamType &stream) : stream_(stream), buffer_(peekBuffer_), bufferSize_(4), bufferLast_(0), current_(buffer_), readCount_(0), count_(0), eof_(false) { 
+        Read();
     }
 
-    Ch Take() { 
-        typename StreamType::int_type c = stream_.get();
-        if (RAPIDJSON_LIKELY(c != StreamType::traits_type::eof())) {
-            count_++;
-            return static_cast<Ch>(c);
-        }
-        else
-            return '\0';
+    //! Constructor.
+    /*!
+        \param stream stream opened for read.
+        \param buffer user-supplied buffer.
+        \param bufferSize size of buffer in bytes. Must >=4 bytes.
+    */
+    BasicIStreamWrapper(StreamType &stream, char* buffer, size_t bufferSize) : stream_(stream), buffer_(buffer), bufferSize_(bufferSize), bufferLast_(0), current_(buffer_), readCount_(0), count_(0), eof_(false) { 
+        RAPIDJSON_ASSERT(bufferSize >= 4);
+        Read();
     }
 
-    // tellg() may return -1 when failed. So we count by ourself.
-    size_t Tell() const { return count_; }
+    Ch Peek() const { return *current_; }
+    Ch Take() { Ch c = *current_; Read(); return c; }
+    size_t Tell() const { return count_ + static_cast<size_t>(current_ - buffer_); }
 
-    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
+    // Not implemented
     void Put(Ch) { RAPIDJSON_ASSERT(false); }
-    void Flush() { RAPIDJSON_ASSERT(false); }
+    void Flush() { RAPIDJSON_ASSERT(false); } 
+    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
     size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
 
     // For encoding detection only.
     const Ch* Peek4() const {
-        RAPIDJSON_ASSERT(sizeof(Ch) == 1); // Only usable for byte stream.
-        int i;
-        bool hasError = false;
-        for (i = 0; i < 4; ++i) {
-            typename StreamType::int_type c = stream_.get();
-            if (c == StreamType::traits_type::eof()) {
-                hasError = true;
-                stream_.clear();
-                break;
-            }
-            peekBuffer_[i] = static_cast<Ch>(c);
-        }
-        for (--i; i >= 0; --i)
-            stream_.putback(peekBuffer_[i]);
-        return !hasError ? peekBuffer_ : 0;
+        return (current_ + 4 - !eof_ <= bufferLast_) ? current_ : 0;
     }
 
 private:
+    BasicIStreamWrapper();
     BasicIStreamWrapper(const BasicIStreamWrapper&);
     BasicIStreamWrapper& operator=(const BasicIStreamWrapper&);
 
-    StreamType& stream_;
-    size_t count_;  //!< Number of characters read. Note:
-    mutable Ch peekBuffer_[4];
+    void Read() {
+        if (current_ < bufferLast_)
+            ++current_;
+        else if (!eof_) {
+            count_ += readCount_;
+            readCount_ = bufferSize_;
+            bufferLast_ = buffer_ + readCount_ - 1;
+            current_ = buffer_;
+
+            if (!stream_.read(buffer_, static_cast<std::streamsize>(bufferSize_))) {
+                readCount_ = static_cast<size_t>(stream_.gcount());
+                *(bufferLast_ = buffer_ + readCount_) = '\0';
+                eof_ = true;
+            }
+        }
+    }
+
+    StreamType &stream_;
+    Ch peekBuffer_[4], *buffer_;
+    size_t bufferSize_;
+    Ch *bufferLast_;
+    Ch *current_;
+    size_t readCount_;
+    size_t count_;  //!< Number of characters read
+    bool eof_;
 };
 
 typedef BasicIStreamWrapper<std::istream> IStreamWrapper;
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/memorybuffer.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/memorybuffer.h
index 39bee1dec..ffbc41ed1 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/memorybuffer.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/memorybuffer.h
@@ -1,6 +1,6 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
 // 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/memorystream.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/memorystream.h
index 1d71d8a4f..77af6c999 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/memorystream.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/memorystream.h
@@ -1,6 +1,6 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
 // 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/ostreamwrapper.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/ostreamwrapper.h
index 6f4667c08..11ed4d33f 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/ostreamwrapper.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/ostreamwrapper.h
@@ -1,6 +1,6 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
 // 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/pointer.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/pointer.h
index 0f377efec..90e5903bc 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/pointer.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/pointer.h
@@ -1,6 +1,6 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
 // 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
@@ -21,9 +21,7 @@
 #ifdef __clang__
 RAPIDJSON_DIAG_PUSH
 RAPIDJSON_DIAG_OFF(switch-enum)
-#endif
-
-#ifdef _MSC_VER
+#elif defined(_MSC_VER)
 RAPIDJSON_DIAG_PUSH
 RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
 #endif
@@ -165,7 +163,12 @@ public:
     GenericPointer(const Token* tokens, size_t tokenCount) : allocator_(), ownAllocator_(), nameBuffer_(), tokens_(const_cast<Token*>(tokens)), tokenCount_(tokenCount), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {}
 
     //! Copy constructor.
-    GenericPointer(const GenericPointer& rhs, Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
+    GenericPointer(const GenericPointer& rhs) : allocator_(rhs.allocator_), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
+        *this = rhs;
+    }
+
+    //! Copy constructor.
+    GenericPointer(const GenericPointer& rhs, Allocator* allocator) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
         *this = rhs;
     }
 
@@ -197,6 +200,36 @@ public:
         return *this;
     }
 
+    //! Swap the content of this pointer with an other.
+    /*!
+        \param other The pointer to swap with.
+        \note Constant complexity.
+    */
+    GenericPointer& Swap(GenericPointer& other) RAPIDJSON_NOEXCEPT {
+        internal::Swap(allocator_, other.allocator_);
+        internal::Swap(ownAllocator_, other.ownAllocator_);
+        internal::Swap(nameBuffer_, other.nameBuffer_);
+        internal::Swap(tokens_, other.tokens_);
+        internal::Swap(tokenCount_, other.tokenCount_);
+        internal::Swap(parseErrorOffset_, other.parseErrorOffset_);
+        internal::Swap(parseErrorCode_, other.parseErrorCode_);
+        return *this;
+    }
+
+    //! free-standing swap function helper
+    /*!
+        Helper function to enable support for common swap implementation pattern based on \c std::swap:
+        \code
+        void swap(MyClass& a, MyClass& b) {
+            using std::swap;
+            swap(a.pointer, b.pointer);
+            // ...
+        }
+        \endcode
+        \see Swap()
+     */
+    friend inline void swap(GenericPointer& a, GenericPointer& b) RAPIDJSON_NOEXCEPT { a.Swap(b); }
+
     //@}
 
     //!@name Append token
@@ -353,6 +386,33 @@ public:
     */
     bool operator!=(const GenericPointer& rhs) const { return !(*this == rhs); }
 
+    //! Less than operator.
+    /*!
+        \note Invalid pointers are always greater than valid ones.
+    */
+    bool operator<(const GenericPointer& rhs) const {
+        if (!IsValid())
+            return false;
+        if (!rhs.IsValid())
+            return true;
+
+        if (tokenCount_ != rhs.tokenCount_)
+            return tokenCount_ < rhs.tokenCount_;
+
+        for (size_t i = 0; i < tokenCount_; i++) {
+            if (tokens_[i].index != rhs.tokens_[i].index)
+                return tokens_[i].index < rhs.tokens_[i].index;
+
+            if (tokens_[i].length != rhs.tokens_[i].length)
+                return tokens_[i].length < rhs.tokens_[i].length;
+
+            if (int cmp = std::memcmp(tokens_[i].name, rhs.tokens_[i].name, sizeof(Ch) * tokens_[i].length))
+                return cmp < 0;
+        }
+
+        return false;
+    }
+
     //@}
 
     //!@name Stringify
@@ -428,10 +488,11 @@ public:
                     v = &((*v)[t->index]);
                 }
                 else {
-                    typename ValueType::MemberIterator m = v->FindMember(GenericStringRef<Ch>(t->name, t->length));
+                    typename ValueType::MemberIterator m = v->FindMember(GenericValue<EncodingType>(GenericStringRef<Ch>(t->name, t->length)));
                     if (m == v->MemberEnd()) {
                         v->AddMember(ValueType(t->name, t->length, allocator).Move(), ValueType().Move(), allocator);
-                        v = &(--v->MemberEnd())->value; // Assumes AddMember() appends at the end
+                        m = v->MemberEnd();
+                        v = &(--m)->value; // Assumes AddMember() appends at the end
                         exist = false;
                     }
                     else
@@ -483,7 +544,7 @@ public:
             switch (v->GetType()) {
             case kObjectType:
                 {
-                    typename ValueType::MemberIterator m = v->FindMember(GenericStringRef<Ch>(t->name, t->length));
+                    typename ValueType::MemberIterator m = v->FindMember(GenericValue<EncodingType>(GenericStringRef<Ch>(t->name, t->length)));
                     if (m == v->MemberEnd())
                         break;
                     v = &m->value;
@@ -532,14 +593,14 @@ public:
     */
     ValueType& GetWithDefault(ValueType& root, const ValueType& defaultValue, typename ValueType::AllocatorType& allocator) const {
         bool alreadyExist;
-        Value& v = Create(root, allocator, &alreadyExist);
+        ValueType& v = Create(root, allocator, &alreadyExist);
         return alreadyExist ? v : v.CopyFrom(defaultValue, allocator);
     }
 
     //! Query a value in a subtree with default null-terminated string.
     ValueType& GetWithDefault(ValueType& root, const Ch* defaultValue, typename ValueType::AllocatorType& allocator) const {
         bool alreadyExist;
-        Value& v = Create(root, allocator, &alreadyExist);
+        ValueType& v = Create(root, allocator, &alreadyExist);
         return alreadyExist ? v : v.SetString(defaultValue, allocator);
     }
 
@@ -547,7 +608,7 @@ public:
     //! Query a value in a subtree with default std::basic_string.
     ValueType& GetWithDefault(ValueType& root, const std::basic_string<Ch>& defaultValue, typename ValueType::AllocatorType& allocator) const {
         bool alreadyExist;
-        Value& v = Create(root, allocator, &alreadyExist);
+        ValueType& v = Create(root, allocator, &alreadyExist);
         return alreadyExist ? v : v.SetString(defaultValue, allocator);
     }
 #endif
@@ -719,7 +780,7 @@ public:
             switch (v->GetType()) {
             case kObjectType:
                 {
-                    typename ValueType::MemberIterator m = v->FindMember(GenericStringRef<Ch>(t->name, t->length));
+                    typename ValueType::MemberIterator m = v->FindMember(GenericValue<EncodingType>(GenericStringRef<Ch>(t->name, t->length)));
                     if (m == v->MemberEnd())
                         return false;
                     v = &m->value;
@@ -1347,11 +1408,7 @@ bool EraseValueByPointer(T& root, const CharType(&source)[N]) {
 
 RAPIDJSON_NAMESPACE_END
 
-#ifdef __clang__
-RAPIDJSON_DIAG_POP
-#endif
-
-#ifdef _MSC_VER
+#if defined(__clang__) || defined(_MSC_VER)
 RAPIDJSON_DIAG_POP
 #endif
 
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/prettywriter.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/prettywriter.h
index 98dfb3060..fe45df1d1 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/prettywriter.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/prettywriter.h
@@ -1,6 +1,6 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
 // 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
@@ -39,7 +39,7 @@ enum PrettyFormatOptions {
 
 //! Writer with indentation and spacing.
 /*!
-    \tparam OutputStream Type of ouptut os.
+    \tparam OutputStream Type of output os.
     \tparam SourceEncoding Encoding of source string.
     \tparam TargetEncoding Encoding of output stream.
     \tparam StackAllocator Type of allocator for allocating memory of stack.
@@ -60,7 +60,7 @@ public:
 
 
     explicit PrettyWriter(StackAllocator* allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) : 
-        Base(allocator, levelDepth), indentChar_(' '), indentCharCount_(4) {}
+        Base(allocator, levelDepth), indentChar_(' '), indentCharCount_(4), formatOptions_(kFormatDefault) {}
 
 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS
     PrettyWriter(PrettyWriter&& rhs) :
@@ -92,26 +92,26 @@ public:
     */
     //@{
 
-    bool Null()                 { PrettyPrefix(kNullType);   return Base::WriteNull(); }
-    bool Bool(bool b)           { PrettyPrefix(b ? kTrueType : kFalseType); return Base::WriteBool(b); }
-    bool Int(int i)             { PrettyPrefix(kNumberType); return Base::WriteInt(i); }
-    bool Uint(unsigned u)       { PrettyPrefix(kNumberType); return Base::WriteUint(u); }
-    bool Int64(int64_t i64)     { PrettyPrefix(kNumberType); return Base::WriteInt64(i64); }
-    bool Uint64(uint64_t u64)   { PrettyPrefix(kNumberType); return Base::WriteUint64(u64);  }
-    bool Double(double d)       { PrettyPrefix(kNumberType); return Base::WriteDouble(d); }
+    bool Null()                 { PrettyPrefix(kNullType);   return Base::EndValue(Base::WriteNull()); }
+    bool Bool(bool b)           { PrettyPrefix(b ? kTrueType : kFalseType); return Base::EndValue(Base::WriteBool(b)); }
+    bool Int(int i)             { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteInt(i)); }
+    bool Uint(unsigned u)       { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteUint(u)); }
+    bool Int64(int64_t i64)     { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteInt64(i64)); }
+    bool Uint64(uint64_t u64)   { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteUint64(u64));  }
+    bool Double(double d)       { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteDouble(d)); }
 
     bool RawNumber(const Ch* str, SizeType length, bool copy = false) {
         RAPIDJSON_ASSERT(str != 0);
         (void)copy;
         PrettyPrefix(kNumberType);
-        return Base::WriteString(str, length);
+        return Base::EndValue(Base::WriteString(str, length));
     }
 
     bool String(const Ch* str, SizeType length, bool copy = false) {
         RAPIDJSON_ASSERT(str != 0);
         (void)copy;
         PrettyPrefix(kStringType);
-        return Base::WriteString(str, length);
+        return Base::EndValue(Base::WriteString(str, length));
     }
 
 #if RAPIDJSON_HAS_STDSTRING
@@ -146,7 +146,7 @@ public:
             Base::os_->Put('\n');
             WriteIndent();
         }
-        bool ret = Base::WriteEndObject();
+        bool ret = Base::EndValue(Base::WriteEndObject());
         (void)ret;
         RAPIDJSON_ASSERT(ret == true);
         if (Base::level_stack_.Empty()) // end of json text
@@ -170,7 +170,7 @@ public:
             Base::os_->Put('\n');
             WriteIndent();
         }
-        bool ret = Base::WriteEndArray();
+        bool ret = Base::EndValue(Base::WriteEndArray());
         (void)ret;
         RAPIDJSON_ASSERT(ret == true);
         if (Base::level_stack_.Empty()) // end of json text
@@ -201,7 +201,7 @@ public:
     bool RawValue(const Ch* json, size_t length, Type type) {
         RAPIDJSON_ASSERT(json != 0);
         PrettyPrefix(type);
-        return Base::WriteRawValue(json, length);
+        return Base::EndValue(Base::WriteRawValue(json, length));
     }
 
 protected:
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/rapidjson.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/rapidjson.h
index 5716fdc06..78aa89a0e 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/rapidjson.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/rapidjson.h
@@ -1,6 +1,6 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
 // 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
@@ -26,7 +26,7 @@
 
     Some RapidJSON features are configurable to adapt the library to a wide
     variety of platforms, environments and usage scenarios.  Most of the
-    features can be configured in terms of overriden or predefined
+    features can be configured in terms of overridden or predefined
     preprocessor macros at compile-time.
 
     Some additional customization is available in the \ref RAPIDJSON_ERRORS APIs.
@@ -219,7 +219,7 @@
 #    elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
 #      define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
 #    else
-#      error Unknown machine endianess detected. User needs to define RAPIDJSON_ENDIAN.
+#      error Unknown machine endianness detected. User needs to define RAPIDJSON_ENDIAN.
 #    endif // __BYTE_ORDER__
 // Detect with GLIBC's endian.h
 #  elif defined(__GLIBC__)
@@ -229,7 +229,7 @@
 #    elif (__BYTE_ORDER == __BIG_ENDIAN)
 #      define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
 #    else
-#      error Unknown machine endianess detected. User needs to define RAPIDJSON_ENDIAN.
+#      error Unknown machine endianness detected. User needs to define RAPIDJSON_ENDIAN.
 #   endif // __GLIBC__
 // Detect with _LITTLE_ENDIAN and _BIG_ENDIAN macro
 #  elif defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN)
@@ -246,7 +246,7 @@
 #  elif defined(RAPIDJSON_DOXYGEN_RUNNING)
 #    define RAPIDJSON_ENDIAN
 #  else
-#    error Unknown machine endianess detected. User needs to define RAPIDJSON_ENDIAN.   
+#    error Unknown machine endianness detected. User needs to define RAPIDJSON_ENDIAN.   
 #  endif
 #endif // RAPIDJSON_ENDIAN
 
@@ -269,16 +269,11 @@
 /*! \ingroup RAPIDJSON_CONFIG
     \param x pointer to align
 
-    Some machines require strict data alignment. Currently the default uses 4 bytes
-    alignment on 32-bit platforms and 8 bytes alignment for 64-bit platforms.
+    Some machines require strict data alignment. The default is 8 bytes.
     User can customize by defining the RAPIDJSON_ALIGN function macro.
 */
 #ifndef RAPIDJSON_ALIGN
-#if RAPIDJSON_64BIT == 1
-#define RAPIDJSON_ALIGN(x) (((x) + static_cast<uint64_t>(7u)) & ~static_cast<uint64_t>(7u))
-#else
-#define RAPIDJSON_ALIGN(x) (((x) + 3u) & ~3u)
-#endif
+#define RAPIDJSON_ALIGN(x) (((x) + static_cast<size_t>(7u)) & ~static_cast<size_t>(7u))
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -433,7 +428,7 @@ template <> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; };
 template <size_t x> struct StaticAssertTest {};
 RAPIDJSON_NAMESPACE_END
 
-#if defined(__GNUC__)
+#if defined(__GNUC__) || defined(__clang__)
 #define RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE __attribute__((unused))
 #else
 #define RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE 
@@ -495,6 +490,12 @@ RAPIDJSON_NAMESPACE_END
 #define RAPIDJSON_VERSION_CODE(x,y,z) \
   (((x)*100000) + ((y)*100) + (z))
 
+#if defined(__has_builtin)
+#define RAPIDJSON_HAS_BUILTIN(x) __has_builtin(x)
+#else
+#define RAPIDJSON_HAS_BUILTIN(x) 0
+#endif
+
 ///////////////////////////////////////////////////////////////////////////////
 // RAPIDJSON_DIAG_PUSH/POP, RAPIDJSON_DIAG_OFF
 
@@ -543,13 +544,14 @@ RAPIDJSON_NAMESPACE_END
 #ifndef RAPIDJSON_HAS_CXX11_RVALUE_REFS
 #if defined(__clang__)
 #if __has_feature(cxx_rvalue_references) && \
-    (defined(_LIBCPP_VERSION) || defined(__GLIBCXX__) && __GLIBCXX__ >= 20080306)
+    (defined(_MSC_VER) || defined(_LIBCPP_VERSION) || defined(__GLIBCXX__) && __GLIBCXX__ >= 20080306)
 #define RAPIDJSON_HAS_CXX11_RVALUE_REFS 1
 #else
 #define RAPIDJSON_HAS_CXX11_RVALUE_REFS 0
 #endif
 #elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,3,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
-      (defined(_MSC_VER) && _MSC_VER >= 1600)
+      (defined(_MSC_VER) && _MSC_VER >= 1600) || \
+      (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__))
 
 #define RAPIDJSON_HAS_CXX11_RVALUE_REFS 1
 #else
@@ -560,8 +562,9 @@ RAPIDJSON_NAMESPACE_END
 #ifndef RAPIDJSON_HAS_CXX11_NOEXCEPT
 #if defined(__clang__)
 #define RAPIDJSON_HAS_CXX11_NOEXCEPT __has_feature(cxx_noexcept)
-#elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__))
-//    (defined(_MSC_VER) && _MSC_VER >= ????) // not yet supported
+#elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
+    (defined(_MSC_VER) && _MSC_VER >= 1900) || \
+    (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__))
 #define RAPIDJSON_HAS_CXX11_NOEXCEPT 1
 #else
 #define RAPIDJSON_HAS_CXX11_NOEXCEPT 0
@@ -575,22 +578,83 @@ RAPIDJSON_NAMESPACE_END
 
 // no automatic detection, yet
 #ifndef RAPIDJSON_HAS_CXX11_TYPETRAITS
+#if (defined(_MSC_VER) && _MSC_VER >= 1700)
+#define RAPIDJSON_HAS_CXX11_TYPETRAITS 1
+#else
 #define RAPIDJSON_HAS_CXX11_TYPETRAITS 0
 #endif
+#endif
 
 #ifndef RAPIDJSON_HAS_CXX11_RANGE_FOR
 #if defined(__clang__)
 #define RAPIDJSON_HAS_CXX11_RANGE_FOR __has_feature(cxx_range_for)
 #elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
-      (defined(_MSC_VER) && _MSC_VER >= 1700)
+      (defined(_MSC_VER) && _MSC_VER >= 1700) || \
+      (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__))
 #define RAPIDJSON_HAS_CXX11_RANGE_FOR 1
 #else
 #define RAPIDJSON_HAS_CXX11_RANGE_FOR 0
 #endif
 #endif // RAPIDJSON_HAS_CXX11_RANGE_FOR
 
+///////////////////////////////////////////////////////////////////////////////
+// C++17 features
+
+#if defined(__has_cpp_attribute)
+# if __has_cpp_attribute(fallthrough)
+#  define RAPIDJSON_DELIBERATE_FALLTHROUGH [[fallthrough]]
+# else
+#  define RAPIDJSON_DELIBERATE_FALLTHROUGH
+# endif
+#else
+# define RAPIDJSON_DELIBERATE_FALLTHROUGH
+#endif
+
 //!@endcond
 
+//! Assertion (in non-throwing contexts).
+ /*! \ingroup RAPIDJSON_CONFIG
+    Some functions provide a \c noexcept guarantee, if the compiler supports it.
+    In these cases, the \ref RAPIDJSON_ASSERT macro cannot be overridden to
+    throw an exception.  This macro adds a separate customization point for
+    such cases.
+
+    Defaults to C \c assert() (as \ref RAPIDJSON_ASSERT), if \c noexcept is
+    supported, and to \ref RAPIDJSON_ASSERT otherwise.
+ */
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_NOEXCEPT_ASSERT
+
+#ifndef RAPIDJSON_NOEXCEPT_ASSERT
+#ifdef RAPIDJSON_ASSERT_THROWS
+#if RAPIDJSON_HAS_CXX11_NOEXCEPT
+#define RAPIDJSON_NOEXCEPT_ASSERT(x)
+#else
+#include <cassert>
+#define RAPIDJSON_NOEXCEPT_ASSERT(x) assert(x)
+#endif // RAPIDJSON_HAS_CXX11_NOEXCEPT
+#else
+#define RAPIDJSON_NOEXCEPT_ASSERT(x) RAPIDJSON_ASSERT(x)
+#endif // RAPIDJSON_ASSERT_THROWS
+#endif // RAPIDJSON_NOEXCEPT_ASSERT
+
+///////////////////////////////////////////////////////////////////////////////
+// malloc/realloc/free
+
+#ifndef RAPIDJSON_MALLOC
+///! customization point for global \c malloc
+#define RAPIDJSON_MALLOC(size) std::malloc(size)
+#endif
+#ifndef RAPIDJSON_REALLOC
+///! customization point for global \c realloc
+#define RAPIDJSON_REALLOC(ptr, new_size) std::realloc(ptr, new_size)
+#endif
+#ifndef RAPIDJSON_FREE
+///! customization point for global \c free
+#define RAPIDJSON_FREE(ptr) std::free(ptr)
+#endif
+
 ///////////////////////////////////////////////////////////////////////////////
 // new/delete
 
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/reader.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/reader.h
index 120c31115..09ace4eba 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/reader.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/reader.h
@@ -1,6 +1,6 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
 //
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
@@ -20,6 +20,7 @@
 #include "allocators.h"
 #include "stream.h"
 #include "encodedstream.h"
+#include "internal/clzll.h"
 #include "internal/meta.h"
 #include "internal/stack.h"
 #include "internal/strtod.h"
@@ -37,17 +38,15 @@
 #include <arm_neon.h>
 #endif
 
-#ifdef _MSC_VER
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(4127)  // conditional expression is constant
-RAPIDJSON_DIAG_OFF(4702)  // unreachable code
-#endif
-
 #ifdef __clang__
 RAPIDJSON_DIAG_PUSH
 RAPIDJSON_DIAG_OFF(old-style-cast)
 RAPIDJSON_DIAG_OFF(padded)
 RAPIDJSON_DIAG_OFF(switch-enum)
+#elif defined(_MSC_VER)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(4127)  // conditional expression is constant
+RAPIDJSON_DIAG_OFF(4702)  // unreachable code
 #endif
 
 #ifdef __GNUC__
@@ -155,6 +154,7 @@ enum ParseFlag {
     kParseNumbersAsStringsFlag = 64,    //!< Parse all numbers (ints/doubles) as strings.
     kParseTrailingCommasFlag = 128, //!< Allow trailing commas at the end of objects and arrays.
     kParseNanAndInfFlag = 256,      //!< Allow parsing NaN, Inf, Infinity, -Inf and -Infinity as doubles.
+    kParseEscapedApostropheFlag = 512,  //!< Allow escaped apostrophe in strings.
     kParseDefaultFlags = RAPIDJSON_PARSE_DEFAULT_FLAGS  //!< Default parse flags. Can be customized by defining RAPIDJSON_PARSE_DEFAULT_FLAGS
 };
 
@@ -445,16 +445,16 @@ inline const char *SkipWhitespace_SIMD(const char* p) {
 
         x = vmvnq_u8(x);                       // Negate
         x = vrev64q_u8(x);                     // Rev in 64
-        uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0);   // extract
-        uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1);  // extract
+        uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0);   // extract
+        uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1);  // extract
 
         if (low == 0) {
             if (high != 0) {
-                int lz =__builtin_clzll(high);;
+                uint32_t lz = internal::clzll(high);
                 return p + 8 + (lz >> 3);
             }
         } else {
-            int lz = __builtin_clzll(low);;
+            uint32_t lz = internal::clzll(low);
             return p + (lz >> 3);
         }
     }
@@ -481,16 +481,16 @@ inline const char *SkipWhitespace_SIMD(const char* p, const char* end) {
 
         x = vmvnq_u8(x);                       // Negate
         x = vrev64q_u8(x);                     // Rev in 64
-        uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0);   // extract
-        uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1);  // extract
+        uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0);   // extract
+        uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1);  // extract
 
         if (low == 0) {
             if (high != 0) {
-                int lz = __builtin_clzll(high);
+                uint32_t lz = internal::clzll(high);
                 return p + 8 + (lz >> 3);
             }
         } else {
-            int lz = __builtin_clzll(low);
+            uint32_t lz = internal::clzll(low);
             return p + (lz >> 3);
         }
     }
@@ -544,7 +544,8 @@ public:
     /*! \param stackAllocator Optional allocator for allocating stack memory. (Only use for non-destructive parsing)
         \param stackCapacity stack capacity in bytes for storing a single decoded string.  (Only use for non-destructive parsing)
     */
-    GenericReader(StackAllocator* stackAllocator = 0, size_t stackCapacity = kDefaultStackCapacity) : stack_(stackAllocator, stackCapacity), parseResult_() {}
+    GenericReader(StackAllocator* stackAllocator = 0, size_t stackCapacity = kDefaultStackCapacity) :
+        stack_(stackAllocator, stackCapacity), parseResult_(), state_(IterativeParsingStartState) {}
 
     //! Parse JSON text.
     /*! \tparam parseFlags Combination of \ref ParseFlag.
@@ -607,7 +608,7 @@ public:
         parseResult_.Clear();
         state_ = IterativeParsingStartState;
     }
-    
+
     //! Parse one token from JSON text
     /*! \tparam InputStream Type of input stream, implementing Stream concept
         \tparam Handler Type of handler, implementing Handler concept.
@@ -619,11 +620,11 @@ public:
     bool IterativeParseNext(InputStream& is, Handler& handler) {
         while (RAPIDJSON_LIKELY(is.Peek() != '\0')) {
             SkipWhitespaceAndComments<parseFlags>(is);
-            
+
             Token t = Tokenize(is.Peek());
             IterativeParsingState n = Predict(state_, t);
             IterativeParsingState d = Transit<parseFlags>(state_, t, n, is, handler);
-            
+
             // If we've finished or hit an error...
             if (RAPIDJSON_UNLIKELY(IsIterativeParsingCompleteState(d))) {
                 // Report errors.
@@ -631,11 +632,11 @@ public:
                     HandleError(state_, is);
                     return false;
                 }
-            
+
                 // Transition to the finish state.
                 RAPIDJSON_ASSERT(d == IterativeParsingFinishState);
                 state_ = d;
-                
+
                 // If StopWhenDone is not set...
                 if (!(parseFlags & kParseStopWhenDoneFlag)) {
                     // ... and extra non-whitespace data is found...
@@ -646,11 +647,11 @@ public:
                         return false;
                     }
                 }
-                
+
                 // Success! We are done!
                 return true;
             }
-            
+
             // Transition to the new state.
             state_ = d;
 
@@ -658,7 +659,7 @@ public:
             if (!IsIterativeParsingDelimiterState(n))
                 return true;
         }
-        
+
         // We reached the end of file.
         stack_.Clear();
 
@@ -666,18 +667,18 @@ public:
             HandleError(state_, is);
             return false;
         }
-        
+
         return true;
     }
-    
+
     //! Check if token-by-token parsing JSON text is complete
     /*! \return Whether the JSON has been fully decoded.
      */
-    RAPIDJSON_FORCEINLINE bool IterativeParseComplete() {
+    RAPIDJSON_FORCEINLINE bool IterativeParseComplete() const {
         return IsIterativeParsingCompleteState(state_);
     }
 
-    //! Whether a parse error has occured in the last parsing.
+    //! Whether a parse error has occurred in the last parsing.
     bool HasParseError() const { return parseResult_.IsError(); }
 
     //! Get the \ref ParseErrorCode of last parsing.
@@ -900,7 +901,7 @@ private:
             return false;
     }
 
-    // Helper function to parse four hexidecimal digits in \uXXXX in ParseString().
+    // Helper function to parse four hexadecimal digits in \uXXXX in ParseString().
     template<typename InputStream>
     unsigned ParseHex4(InputStream& is, size_t escapeOffset) {
         unsigned codepoint = 0;
@@ -991,7 +992,7 @@ private:
 //!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
 #define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
         static const char escape[256] = {
-            Z16, Z16, 0, 0,'\"', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'/',
+            Z16, Z16, 0, 0,'\"', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, '/',
             Z16, Z16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'\\', 0, 0, 0,
             0, 0,'\b', 0, 0, 0,'\f', 0, 0, 0, 0, 0, 0, 0,'\n', 0,
             0, 0,'\r', 0,'\t', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -1007,26 +1008,38 @@ private:
 
             Ch c = is.Peek();
             if (RAPIDJSON_UNLIKELY(c == '\\')) {    // Escape
-                size_t escapeOffset = is.Tell();    // For invalid escaping, report the inital '\\' as error offset
+                size_t escapeOffset = is.Tell();    // For invalid escaping, report the initial '\\' as error offset
                 is.Take();
                 Ch e = is.Peek();
                 if ((sizeof(Ch) == 1 || unsigned(e) < 256) && RAPIDJSON_LIKELY(escape[static_cast<unsigned char>(e)])) {
                     is.Take();
                     os.Put(static_cast<typename TEncoding::Ch>(escape[static_cast<unsigned char>(e)]));
                 }
+                else if ((parseFlags & kParseEscapedApostropheFlag) && RAPIDJSON_LIKELY(e == '\'')) { // Allow escaped apostrophe
+                    is.Take();
+                    os.Put('\'');
+                }
                 else if (RAPIDJSON_LIKELY(e == 'u')) {    // Unicode
                     is.Take();
                     unsigned codepoint = ParseHex4(is, escapeOffset);
                     RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-                    if (RAPIDJSON_UNLIKELY(codepoint >= 0xD800 && codepoint <= 0xDBFF)) {
-                        // Handle UTF-16 surrogate pair
-                        if (RAPIDJSON_UNLIKELY(!Consume(is, '\\') || !Consume(is, 'u')))
+                    if (RAPIDJSON_UNLIKELY(codepoint >= 0xD800 && codepoint <= 0xDFFF)) {
+                        // high surrogate, check if followed by valid low surrogate
+                        if (RAPIDJSON_LIKELY(codepoint <= 0xDBFF)) {
+                            // Handle UTF-16 surrogate pair
+                            if (RAPIDJSON_UNLIKELY(!Consume(is, '\\') || !Consume(is, 'u')))
+                                RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
+                            unsigned codepoint2 = ParseHex4(is, escapeOffset);
+                            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+                            if (RAPIDJSON_UNLIKELY(codepoint2 < 0xDC00 || codepoint2 > 0xDFFF))
+                                RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
+                            codepoint = (((codepoint - 0xD800) << 10) | (codepoint2 - 0xDC00)) + 0x10000;
+                        }
+                        // single low surrogate
+                        else
+                        {
                             RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
-                        unsigned codepoint2 = ParseHex4(is, escapeOffset);
-                        RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-                        if (RAPIDJSON_UNLIKELY(codepoint2 < 0xDC00 || codepoint2 > 0xDFFF))
-                            RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
-                        codepoint = (((codepoint - 0xD800) << 10) | (codepoint2 - 0xDC00)) + 0x10000;
+                        }
                     }
                     TEncoding::Encode(os, codepoint);
                 }
@@ -1245,19 +1258,19 @@ private:
             x = vorrq_u8(x, vcltq_u8(s, s3));
 
             x = vrev64q_u8(x);                     // Rev in 64
-            uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0);   // extract
-            uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1);  // extract
+            uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0);   // extract
+            uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1);  // extract
 
             SizeType length = 0;
             bool escaped = false;
             if (low == 0) {
                 if (high != 0) {
-                    unsigned lz = (unsigned)__builtin_clzll(high);;
+                    uint32_t lz = internal::clzll(high);
                     length = 8 + (lz >> 3);
                     escaped = true;
                 }
             } else {
-                unsigned lz = (unsigned)__builtin_clzll(low);;
+                uint32_t lz = internal::clzll(low);
                 length = lz >> 3;
                 escaped = true;
             }
@@ -1315,19 +1328,19 @@ private:
             x = vorrq_u8(x, vcltq_u8(s, s3));
 
             x = vrev64q_u8(x);                     // Rev in 64
-            uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0);   // extract
-            uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1);  // extract
+            uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0);   // extract
+            uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1);  // extract
 
             SizeType length = 0;
             bool escaped = false;
             if (low == 0) {
                 if (high != 0) {
-                    unsigned lz = (unsigned)__builtin_clzll(high);
+                    uint32_t lz = internal::clzll(high);
                     length = 8 + (lz >> 3);
                     escaped = true;
                 }
             } else {
-                unsigned lz = (unsigned)__builtin_clzll(low);
+                uint32_t lz = internal::clzll(low);
                 length = lz >> 3;
                 escaped = true;
             }
@@ -1371,17 +1384,17 @@ private:
             x = vorrq_u8(x, vcltq_u8(s, s3));
 
             x = vrev64q_u8(x);                     // Rev in 64
-            uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0);   // extract
-            uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1);  // extract
+            uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0);   // extract
+            uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1);  // extract
 
             if (low == 0) {
                 if (high != 0) {
-                    int lz = __builtin_clzll(high);
+                    uint32_t lz = internal::clzll(high);
                     p += 8 + (lz >> 3);
                     break;
                 }
             } else {
-                int lz = __builtin_clzll(low);
+                uint32_t lz = internal::clzll(low);
                 p += lz >> 3;
                 break;
             }
@@ -1404,7 +1417,7 @@ private:
         RAPIDJSON_FORCEINLINE Ch Peek() const { return is.Peek(); }
         RAPIDJSON_FORCEINLINE Ch TakePush() { return is.Take(); }
         RAPIDJSON_FORCEINLINE Ch Take() { return is.Take(); }
-		  RAPIDJSON_FORCEINLINE void Push(char) {}
+        RAPIDJSON_FORCEINLINE void Push(char) {}
 
         size_t Tell() { return is.Tell(); }
         size_t Length() { return 0; }
@@ -1524,7 +1537,7 @@ private:
                     }
                 }
             }
-            
+
             if (RAPIDJSON_UNLIKELY(!useNanOrInf)) {
                 RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
             }
@@ -1562,8 +1575,6 @@ private:
         // Force double for big integer
         if (useDouble) {
             while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
-                if (RAPIDJSON_UNLIKELY(d >= 1.7976931348623157e307)) // DBL_MAX / 10.0
-                    RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset);
                 d = d * 10 + (s.TakePush() - '0');
             }
         }
@@ -1633,9 +1644,18 @@ private:
             if (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
                 exp = static_cast<int>(s.Take() - '0');
                 if (expMinus) {
+                    // (exp + expFrac) must not underflow int => we're detecting when -exp gets
+                    // dangerously close to INT_MIN (a pessimistic next digit 9 would push it into
+                    // underflow territory):
+                    //
+                    //        -(exp * 10 + 9) + expFrac >= INT_MIN
+                    //   <=>  exp <= (expFrac - INT_MIN - 9) / 10
+                    RAPIDJSON_ASSERT(expFrac <= 0);
+                    int maxExp = (expFrac + 2147483639) / 10;
+
                     while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
                         exp = exp * 10 + static_cast<int>(s.Take() - '0');
-                        if (exp >= 214748364) {                         // Issue #313: prevent overflow exponent
+                        if (RAPIDJSON_UNLIKELY(exp > maxExp)) {
                             while (RAPIDJSON_UNLIKELY(s.Peek() >= '0' && s.Peek() <= '9'))  // Consume the rest of exponent
                                 s.Take();
                         }
@@ -1694,6 +1714,13 @@ private:
                else
                    d = internal::StrtodNormalPrecision(d, p);
 
+               // Use > max, instead of == inf, to fix bogus warning -Wfloat-equal
+               if (d > (std::numeric_limits<double>::max)()) {
+                   // Overflow
+                   // TODO: internal::StrtodX should report overflow (or underflow)
+                   RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset);
+               }
+
                cont = handler.Double(minus ? -d : d);
            }
            else if (useNanOrInf) {
@@ -1756,12 +1783,12 @@ private:
 
         // Single value state
         IterativeParsingValueState,
-        
+
         // Delimiter states (at bottom)
         IterativeParsingElementDelimiterState,
         IterativeParsingMemberDelimiterState,
         IterativeParsingKeyValueDelimiterState,
-        
+
         cIterativeParsingStateCount
     };
 
@@ -1785,7 +1812,7 @@ private:
         kTokenCount
     };
 
-    RAPIDJSON_FORCEINLINE Token Tokenize(Ch c) {
+    RAPIDJSON_FORCEINLINE Token Tokenize(Ch c) const {
 
 //!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
 #define N NumberToken
@@ -1812,7 +1839,7 @@ private:
             return NumberToken;
     }
 
-    RAPIDJSON_FORCEINLINE IterativeParsingState Predict(IterativeParsingState state, Token token) {
+    RAPIDJSON_FORCEINLINE IterativeParsingState Predict(IterativeParsingState state, Token token) const {
         // current state x one lookahead token -> new state
         static const char G[cIterativeParsingStateCount][kTokenCount] = {
             // Finish(sink state)
@@ -2151,46 +2178,46 @@ private:
         }
     }
 
-    RAPIDJSON_FORCEINLINE bool IsIterativeParsingDelimiterState(IterativeParsingState s) {
+    RAPIDJSON_FORCEINLINE bool IsIterativeParsingDelimiterState(IterativeParsingState s) const {
         return s >= IterativeParsingElementDelimiterState;
     }
-    
-    RAPIDJSON_FORCEINLINE bool IsIterativeParsingCompleteState(IterativeParsingState s) {
+
+    RAPIDJSON_FORCEINLINE bool IsIterativeParsingCompleteState(IterativeParsingState s) const {
         return s <= IterativeParsingErrorState;
     }
-    
+
     template <unsigned parseFlags, typename InputStream, typename Handler>
     ParseResult IterativeParse(InputStream& is, Handler& handler) {
         parseResult_.Clear();
         ClearStackOnExit scope(*this);
         IterativeParsingState state = IterativeParsingStartState;
-        
+
         SkipWhitespaceAndComments<parseFlags>(is);
         RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
         while (is.Peek() != '\0') {
             Token t = Tokenize(is.Peek());
             IterativeParsingState n = Predict(state, t);
             IterativeParsingState d = Transit<parseFlags>(state, t, n, is, handler);
-            
+
             if (d == IterativeParsingErrorState) {
                 HandleError(state, is);
                 break;
             }
-            
+
             state = d;
-            
+
             // Do not further consume streams if a root JSON has been parsed.
             if ((parseFlags & kParseStopWhenDoneFlag) && state == IterativeParsingFinishState)
                 break;
-            
+
             SkipWhitespaceAndComments<parseFlags>(is);
             RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
         }
-        
+
         // Handle the end of file.
         if (state != IterativeParsingFinishState)
             HandleError(state, is);
-        
+
         return parseResult_;
     }
 
@@ -2205,7 +2232,7 @@ typedef GenericReader<UTF8<>, UTF8<> > Reader;
 
 RAPIDJSON_NAMESPACE_END
 
-#ifdef __clang__
+#if defined(__clang__) || defined(_MSC_VER)
 RAPIDJSON_DIAG_POP
 #endif
 
@@ -2214,8 +2241,4 @@ RAPIDJSON_DIAG_POP
 RAPIDJSON_DIAG_POP
 #endif
 
-#ifdef _MSC_VER
-RAPIDJSON_DIAG_POP
-#endif
-
 #endif // RAPIDJSON_READER_H_
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/schema.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/schema.h
index abcf1a102..11f716096 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/schema.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/schema.h
@@ -17,6 +17,8 @@
 
 #include "document.h"
 #include "pointer.h"
+#include "stringbuffer.h"
+#include "error/en.h"
 #include <cmath> // abs, floor
 
 #if !defined(RAPIDJSON_SCHEMA_USE_INTERNALREGEX)
@@ -25,7 +27,7 @@
 #define RAPIDJSON_SCHEMA_USE_INTERNALREGEX 0
 #endif
 
-#if !RAPIDJSON_SCHEMA_USE_INTERNALREGEX && !defined(RAPIDJSON_SCHEMA_USE_STDREGEX) && (__cplusplus >=201103L || (defined(_MSC_VER) && _MSC_VER >= 1800))
+#if !RAPIDJSON_SCHEMA_USE_INTERNALREGEX && defined(RAPIDJSON_SCHEMA_USE_STDREGEX) && (__cplusplus >=201103L || (defined(_MSC_VER) && _MSC_VER >= 1800))
 #define RAPIDJSON_SCHEMA_USE_STDREGEX 1
 #else
 #define RAPIDJSON_SCHEMA_USE_STDREGEX 0
@@ -62,9 +64,7 @@ RAPIDJSON_DIAG_OFF(weak-vtables)
 RAPIDJSON_DIAG_OFF(exit-time-destructors)
 RAPIDJSON_DIAG_OFF(c++98-compat-pedantic)
 RAPIDJSON_DIAG_OFF(variadic-macros)
-#endif
-
-#ifdef _MSC_VER
+#elif defined(_MSC_VER)
 RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
 #endif
 
@@ -114,13 +114,36 @@ inline void PrintValidatorPointers(unsigned depth, const wchar_t* s, const wchar
 #define RAPIDJSON_INVALID_KEYWORD_VERBOSE(keyword)
 #endif
 
-#define RAPIDJSON_INVALID_KEYWORD_RETURN(keyword)\
+#define RAPIDJSON_INVALID_KEYWORD_RETURN(code)\
 RAPIDJSON_MULTILINEMACRO_BEGIN\
-    context.invalidKeyword = keyword.GetString();\
-    RAPIDJSON_INVALID_KEYWORD_VERBOSE(keyword.GetString());\
+    context.invalidCode = code;\
+    context.invalidKeyword = SchemaType::GetValidateErrorKeyword(code).GetString();\
+    RAPIDJSON_INVALID_KEYWORD_VERBOSE(context.invalidKeyword);\
     return false;\
 RAPIDJSON_MULTILINEMACRO_END
 
+///////////////////////////////////////////////////////////////////////////////
+// ValidateFlag
+
+/*! \def RAPIDJSON_VALIDATE_DEFAULT_FLAGS
+    \ingroup RAPIDJSON_CONFIG
+    \brief User-defined kValidateDefaultFlags definition.
+
+    User can define this as any \c ValidateFlag combinations.
+*/
+#ifndef RAPIDJSON_VALIDATE_DEFAULT_FLAGS
+#define RAPIDJSON_VALIDATE_DEFAULT_FLAGS kValidateNoFlags
+#endif
+
+//! Combination of validate flags
+/*! \see
+ */
+enum ValidateFlag {
+    kValidateNoFlags = 0,                                       //!< No flags are set.
+    kValidateContinueOnErrorFlag = 1,                           //!< Don't stop after first validation error.
+    kValidateDefaultFlags = RAPIDJSON_VALIDATE_DEFAULT_FLAGS    //!< Default validate flags. Can be customized by defining RAPIDJSON_VALIDATE_DEFAULT_FLAGS
+};
+
 ///////////////////////////////////////////////////////////////////////////////
 // Forward declarations
 
@@ -139,6 +162,8 @@ class ISchemaValidator {
 public:
     virtual ~ISchemaValidator() {}
     virtual bool IsValid() const = 0;
+    virtual void SetValidateFlags(unsigned flags) = 0;
+    virtual unsigned GetValidateFlags() const = 0;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -148,7 +173,7 @@ template <typename SchemaType>
 class ISchemaStateFactory {
 public:
     virtual ~ISchemaStateFactory() {}
-    virtual ISchemaValidator* CreateSchemaValidator(const SchemaType&) = 0;
+    virtual ISchemaValidator* CreateSchemaValidator(const SchemaType&, const bool inheritContinueOnErrors) = 0;
     virtual void DestroySchemaValidator(ISchemaValidator* validator) = 0;
     virtual void* CreateHasher() = 0;
     virtual uint64_t GetHashCode(void* hasher) = 0;
@@ -157,6 +182,62 @@ public:
     virtual void FreeState(void* p) = 0;
 };
 
+///////////////////////////////////////////////////////////////////////////////
+// IValidationErrorHandler
+
+template <typename SchemaType>
+class IValidationErrorHandler {
+public:
+    typedef typename SchemaType::Ch Ch;
+    typedef typename SchemaType::SValue SValue;
+
+    virtual ~IValidationErrorHandler() {}
+
+    virtual void NotMultipleOf(int64_t actual, const SValue& expected) = 0;
+    virtual void NotMultipleOf(uint64_t actual, const SValue& expected) = 0;
+    virtual void NotMultipleOf(double actual, const SValue& expected) = 0;
+    virtual void AboveMaximum(int64_t actual, const SValue& expected, bool exclusive) = 0;
+    virtual void AboveMaximum(uint64_t actual, const SValue& expected, bool exclusive) = 0;
+    virtual void AboveMaximum(double actual, const SValue& expected, bool exclusive) = 0;
+    virtual void BelowMinimum(int64_t actual, const SValue& expected, bool exclusive) = 0;
+    virtual void BelowMinimum(uint64_t actual, const SValue& expected, bool exclusive) = 0;
+    virtual void BelowMinimum(double actual, const SValue& expected, bool exclusive) = 0;
+
+    virtual void TooLong(const Ch* str, SizeType length, SizeType expected) = 0;
+    virtual void TooShort(const Ch* str, SizeType length, SizeType expected) = 0;
+    virtual void DoesNotMatch(const Ch* str, SizeType length) = 0;
+
+    virtual void DisallowedItem(SizeType index) = 0;
+    virtual void TooFewItems(SizeType actualCount, SizeType expectedCount) = 0;
+    virtual void TooManyItems(SizeType actualCount, SizeType expectedCount) = 0;
+    virtual void DuplicateItems(SizeType index1, SizeType index2) = 0;
+
+    virtual void TooManyProperties(SizeType actualCount, SizeType expectedCount) = 0;
+    virtual void TooFewProperties(SizeType actualCount, SizeType expectedCount) = 0;
+    virtual void StartMissingProperties() = 0;
+    virtual void AddMissingProperty(const SValue& name) = 0;
+    virtual bool EndMissingProperties() = 0;
+    virtual void PropertyViolations(ISchemaValidator** subvalidators, SizeType count) = 0;
+    virtual void DisallowedProperty(const Ch* name, SizeType length) = 0;
+
+    virtual void StartDependencyErrors() = 0;
+    virtual void StartMissingDependentProperties() = 0;
+    virtual void AddMissingDependentProperty(const SValue& targetName) = 0;
+    virtual void EndMissingDependentProperties(const SValue& sourceName) = 0;
+    virtual void AddDependencySchemaError(const SValue& souceName, ISchemaValidator* subvalidator) = 0;
+    virtual bool EndDependencyErrors() = 0;
+
+    virtual void DisallowedValue(const ValidateErrorCode code) = 0;
+    virtual void StartDisallowedType() = 0;
+    virtual void AddExpectedType(const typename SchemaType::ValueType& expectedType) = 0;
+    virtual void EndDisallowedType(const typename SchemaType::ValueType& actualType) = 0;
+    virtual void NotAllOf(ISchemaValidator** subvalidators, SizeType count) = 0;
+    virtual void NoneOf(ISchemaValidator** subvalidators, SizeType count) = 0;
+    virtual void NotOneOf(ISchemaValidator** subvalidators, SizeType count, bool matched) = 0;
+    virtual void Disallowed() = 0;
+};
+
+
 ///////////////////////////////////////////////////////////////////////////////
 // Hasher
 
@@ -261,6 +342,7 @@ template <typename SchemaDocumentType>
 struct SchemaValidationContext {
     typedef Schema<SchemaDocumentType> SchemaType;
     typedef ISchemaStateFactory<SchemaType> SchemaValidatorFactoryType;
+    typedef IValidationErrorHandler<SchemaType> ErrorHandlerType;
     typedef typename SchemaType::ValueType ValueType;
     typedef typename ValueType::Ch Ch;
 
@@ -270,11 +352,13 @@ struct SchemaValidationContext {
         kPatternValidatorWithAdditionalProperty
     };
 
-    SchemaValidationContext(SchemaValidatorFactoryType& f, const SchemaType* s) :
+    SchemaValidationContext(SchemaValidatorFactoryType& f, ErrorHandlerType& eh, const SchemaType* s) :
         factory(f),
+        error_handler(eh),
         schema(s),
         valueSchema(),
         invalidKeyword(),
+        invalidCode(),
         hasher(),
         arrayElementHashCodes(),
         validators(),
@@ -311,9 +395,11 @@ struct SchemaValidationContext {
     }
 
     SchemaValidatorFactoryType& factory;
+    ErrorHandlerType& error_handler;
     const SchemaType* schema;
     const SchemaType* valueSchema;
     const Ch* invalidKeyword;
+    ValidateErrorCode invalidCode;
     void* hasher; // Only validator access
     void* arrayElementHashCodes; // Only validator access this
     ISchemaValidator** validators;
@@ -345,16 +431,20 @@ public:
     typedef SchemaValidationContext<SchemaDocumentType> Context;
     typedef Schema<SchemaDocumentType> SchemaType;
     typedef GenericValue<EncodingType, AllocatorType> SValue;
+    typedef IValidationErrorHandler<Schema> ErrorHandler;
     friend class GenericSchemaDocument<ValueType, AllocatorType>;
 
     Schema(SchemaDocumentType* schemaDocument, const PointerType& p, const ValueType& value, const ValueType& document, AllocatorType* allocator) :
         allocator_(allocator),
+        uri_(schemaDocument->GetURI(), *allocator),
+        pointer_(p, allocator),
         typeless_(schemaDocument->GetTypeless()),
         enum_(),
         enumCount_(),
         not_(),
         type_((1 << kTotalSchemaType) - 1), // typeless
         validatorCount_(),
+        notValidatorIndex_(),
         properties_(),
         additionalPropertiesSchema_(),
         patternProperties_(),
@@ -378,9 +468,9 @@ public:
         minLength_(0),
         maxLength_(~SizeType(0)),
         exclusiveMinimum_(false),
-        exclusiveMaximum_(false)
+        exclusiveMaximum_(false),
+        defaultValueLength_(0)
     {
-        typedef typename SchemaDocumentType::ValueType ValueType;
         typedef typename ValueType::ConstValueIterator ConstValueIterator;
         typedef typename ValueType::ConstMemberIterator ConstMemberIterator;
 
@@ -396,18 +486,19 @@ public:
                     AddType(*itr);
         }
 
-        if (const ValueType* v = GetMember(value, GetEnumString()))
+        if (const ValueType* v = GetMember(value, GetEnumString())) {
             if (v->IsArray() && v->Size() > 0) {
                 enum_ = static_cast<uint64_t*>(allocator_->Malloc(sizeof(uint64_t) * v->Size()));
                 for (ConstValueIterator itr = v->Begin(); itr != v->End(); ++itr) {
                     typedef Hasher<EncodingType, MemoryPoolAllocator<> > EnumHasherType;
-                    char buffer[256 + 24];
+                    char buffer[256u + 24];
                     MemoryPoolAllocator<> hasherAllocator(buffer, sizeof(buffer));
                     EnumHasherType h(&hasherAllocator, 256);
                     itr->Accept(h);
                     enum_[enumCount_++] = h.GetHashCode();
                 }
             }
+        }
 
         if (schemaDocument) {
             AssignIfExist(allOf_, *schemaDocument, p, value, GetAllOfString(), document);
@@ -573,6 +664,12 @@ public:
         if (const ValueType* v = GetMember(value, GetMultipleOfString()))
             if (v->IsNumber() && v->GetDouble() > 0.0)
                 multipleOf_.CopyFrom(*v, *allocator_);
+
+        // Default
+        if (const ValueType* v = GetMember(value, GetDefaultValueString()))
+            if (v->IsString())
+                defaultValueLength_ = v->GetStringLength();
+
     }
 
     ~Schema() {
@@ -596,6 +693,14 @@ public:
 #endif
     }
 
+    const SValue& GetURI() const {
+        return uri_;
+    }
+
+    const PointerType& GetPointer() const {
+        return pointer_;
+    }
+
     bool BeginValue(Context& context) const {
         if (context.inArray) {
             if (uniqueItems_)
@@ -610,8 +715,14 @@ public:
                     context.valueSchema = additionalItemsSchema_;
                 else if (additionalItems_)
                     context.valueSchema = typeless_;
-                else
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetItemsString());
+                else {
+                    context.error_handler.DisallowedItem(context.arrayElementIndex);
+                    // Must set valueSchema for when kValidateContinueOnErrorFlag is set, else reports spurious type error
+                    context.valueSchema = typeless_;
+                    // Must bump arrayElementIndex for when kValidateContinueOnErrorFlag is set
+                    context.arrayElementIndex++;
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorAdditionalItems);
+                }
             }
             else
                 context.valueSchema = typeless_;
@@ -636,36 +747,47 @@ public:
                 }
 
             if (context.objectPatternValidatorType == Context::kPatternValidatorOnly) {
-                if (!patternValid)
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString());
+                if (!patternValid) {
+                    context.error_handler.PropertyViolations(context.patternPropertiesValidators, count);
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorPatternProperties);
+                }
             }
             else if (context.objectPatternValidatorType == Context::kPatternValidatorWithProperty) {
-                if (!patternValid || !otherValid)
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString());
+                if (!patternValid || !otherValid) {
+                    context.error_handler.PropertyViolations(context.patternPropertiesValidators, count + 1);
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorPatternProperties);
+                }
+            }
+            else if (!patternValid && !otherValid) { // kPatternValidatorWithAdditionalProperty)
+                context.error_handler.PropertyViolations(context.patternPropertiesValidators, count + 1);
+                RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorPatternProperties);
             }
-            else if (!patternValid && !otherValid) // kPatternValidatorWithAdditionalProperty)
-                RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString());
         }
 
-        if (enum_) {
+        // For enums only check if we have a hasher
+        if (enum_ && context.hasher) {
             const uint64_t h = context.factory.GetHashCode(context.hasher);
             for (SizeType i = 0; i < enumCount_; i++)
                 if (enum_[i] == h)
                     goto foundEnum;
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetEnumString());
+            context.error_handler.DisallowedValue(kValidateErrorEnum);
+            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorEnum);
             foundEnum:;
         }
 
         if (allOf_.schemas)
             for (SizeType i = allOf_.begin; i < allOf_.begin + allOf_.count; i++)
-                if (!context.validators[i]->IsValid())
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetAllOfString());
+                if (!context.validators[i]->IsValid()) {
+                    context.error_handler.NotAllOf(&context.validators[allOf_.begin], allOf_.count);
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorAllOf);
+                }
         
         if (anyOf_.schemas) {
             for (SizeType i = anyOf_.begin; i < anyOf_.begin + anyOf_.count; i++)
                 if (context.validators[i]->IsValid())
                     goto foundAny;
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetAnyOfString());
+            context.error_handler.NoneOf(&context.validators[anyOf_.begin], anyOf_.count);
+            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorAnyOf);
             foundAny:;
         }
 
@@ -673,30 +795,39 @@ public:
             bool oneValid = false;
             for (SizeType i = oneOf_.begin; i < oneOf_.begin + oneOf_.count; i++)
                 if (context.validators[i]->IsValid()) {
-                    if (oneValid)
-                        RAPIDJSON_INVALID_KEYWORD_RETURN(GetOneOfString());
-                    else
+                    if (oneValid) {
+                        context.error_handler.NotOneOf(&context.validators[oneOf_.begin], oneOf_.count, true);
+                        RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorOneOfMatch);
+                    } else
                         oneValid = true;
                 }
-            if (!oneValid)
-                RAPIDJSON_INVALID_KEYWORD_RETURN(GetOneOfString());
+            if (!oneValid) {
+                context.error_handler.NotOneOf(&context.validators[oneOf_.begin], oneOf_.count, false);
+                RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorOneOf);
+            }
         }
 
-        if (not_ && context.validators[notValidatorIndex_]->IsValid())
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetNotString());
+        if (not_ && context.validators[notValidatorIndex_]->IsValid()) {
+            context.error_handler.Disallowed();
+            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorNot);
+        }
 
         return true;
     }
 
-    bool Null(Context& context) const { 
-        if (!(type_ & (1 << kNullSchemaType)))
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+    bool Null(Context& context) const {
+        if (!(type_ & (1 << kNullSchemaType))) {
+            DisallowedType(context, GetNullString());
+            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorType);
+        }
         return CreateParallelValidator(context);
     }
     
-    bool Bool(Context& context, bool) const { 
-        if (!(type_ & (1 << kBooleanSchemaType)))
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+    bool Bool(Context& context, bool) const {
+        if (!(type_ & (1 << kBooleanSchemaType))) {
+            DisallowedType(context, GetBooleanString());
+            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorType);
+        }
         return CreateParallelValidator(context);
     }
 
@@ -725,8 +856,10 @@ public:
     }
 
     bool Double(Context& context, double d) const {
-        if (!(type_ & (1 << kNumberSchemaType)))
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+        if (!(type_ & (1 << kNumberSchemaType))) {
+            DisallowedType(context, GetNumberString());
+            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorType);
+        }
 
         if (!minimum_.IsNull() && !CheckDoubleMinimum(context, d))
             return false;
@@ -741,28 +874,38 @@ public:
     }
     
     bool String(Context& context, const Ch* str, SizeType length, bool) const {
-        if (!(type_ & (1 << kStringSchemaType)))
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+        if (!(type_ & (1 << kStringSchemaType))) {
+            DisallowedType(context, GetStringString());
+            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorType);
+        }
 
         if (minLength_ != 0 || maxLength_ != SizeType(~0)) {
             SizeType count;
             if (internal::CountStringCodePoint<EncodingType>(str, length, &count)) {
-                if (count < minLength_)
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinLengthString());
-                if (count > maxLength_)
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxLengthString());
+                if (count < minLength_) {
+                    context.error_handler.TooShort(str, length, minLength_);
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorMinLength);
+                }
+                if (count > maxLength_) {
+                    context.error_handler.TooLong(str, length, maxLength_);
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorMaxLength);
+                }
             }
         }
 
-        if (pattern_ && !IsPatternMatch(pattern_, str, length))
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternString());
+        if (pattern_ && !IsPatternMatch(pattern_, str, length)) {
+            context.error_handler.DoesNotMatch(str, length);
+            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorPattern);
+        }
 
         return CreateParallelValidator(context);
     }
 
-    bool StartObject(Context& context) const { 
-        if (!(type_ & (1 << kObjectSchemaType)))
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+    bool StartObject(Context& context) const {
+        if (!(type_ & (1 << kObjectSchemaType))) {
+            DisallowedType(context, GetObjectString());
+            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorType);
+        }
 
         if (hasDependencies_ || hasRequired_) {
             context.propertyExist = static_cast<bool*>(context.factory.MallocState(sizeof(bool) * propertyCount_));
@@ -789,7 +932,7 @@ public:
                 }
         }
 
-        SizeType index;
+        SizeType index  = 0;
         if (FindPropertyIndex(ValueType(str, len).Move(), &index)) {
             if (context.patternPropertiesSchemaCount > 0) {
                 context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = properties_[index].schema;
@@ -820,64 +963,129 @@ public:
             return true;
         }
 
-        if (context.patternPropertiesSchemaCount == 0) // patternProperties are not additional properties
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetAdditionalPropertiesString());
-
-        return true;
-    }
-
-    bool EndObject(Context& context, SizeType memberCount) const {
-        if (hasRequired_)
-            for (SizeType index = 0; index < propertyCount_; index++)
-                if (properties_[index].required)
-                    if (!context.propertyExist[index])
-                        RAPIDJSON_INVALID_KEYWORD_RETURN(GetRequiredString());
-
-        if (memberCount < minProperties_)
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinPropertiesString());
-
-        if (memberCount > maxProperties_)
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxPropertiesString());
-
-        if (hasDependencies_) {
-            for (SizeType sourceIndex = 0; sourceIndex < propertyCount_; sourceIndex++)
-                if (context.propertyExist[sourceIndex]) {
-                    if (properties_[sourceIndex].dependencies) {
-                        for (SizeType targetIndex = 0; targetIndex < propertyCount_; targetIndex++)
-                            if (properties_[sourceIndex].dependencies[targetIndex] && !context.propertyExist[targetIndex])
-                                RAPIDJSON_INVALID_KEYWORD_RETURN(GetDependenciesString());
-                    }
-                    else if (properties_[sourceIndex].dependenciesSchema)
-                        if (!context.validators[properties_[sourceIndex].dependenciesValidatorIndex]->IsValid())
-                            RAPIDJSON_INVALID_KEYWORD_RETURN(GetDependenciesString());
-                }
+        if (context.patternPropertiesSchemaCount == 0) { // patternProperties are not additional properties
+            // Must set valueSchema for when kValidateContinueOnErrorFlag is set, else reports spurious type error
+            context.valueSchema = typeless_;
+            context.error_handler.DisallowedProperty(str, len);
+            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorAdditionalProperties);
         }
 
         return true;
     }
 
-    bool StartArray(Context& context) const { 
-        if (!(type_ & (1 << kArraySchemaType)))
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+    bool EndObject(Context& context, SizeType memberCount) const {
+        if (hasRequired_) {
+            context.error_handler.StartMissingProperties();
+            for (SizeType index = 0; index < propertyCount_; index++)
+                if (properties_[index].required && !context.propertyExist[index])
+                    if (properties_[index].schema->defaultValueLength_ == 0 )
+                        context.error_handler.AddMissingProperty(properties_[index].name);
+            if (context.error_handler.EndMissingProperties())
+                RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorRequired);
+        }
 
+        if (memberCount < minProperties_) {
+            context.error_handler.TooFewProperties(memberCount, minProperties_);
+            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorMinProperties);
+        }
+
+        if (memberCount > maxProperties_) {
+            context.error_handler.TooManyProperties(memberCount, maxProperties_);
+            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorMaxProperties);
+        }
+
+        if (hasDependencies_) {
+            context.error_handler.StartDependencyErrors();
+            for (SizeType sourceIndex = 0; sourceIndex < propertyCount_; sourceIndex++) {
+                const Property& source = properties_[sourceIndex];
+                if (context.propertyExist[sourceIndex]) {
+                    if (source.dependencies) {
+                        context.error_handler.StartMissingDependentProperties();
+                        for (SizeType targetIndex = 0; targetIndex < propertyCount_; targetIndex++)
+                            if (source.dependencies[targetIndex] && !context.propertyExist[targetIndex])
+                                context.error_handler.AddMissingDependentProperty(properties_[targetIndex].name);
+                        context.error_handler.EndMissingDependentProperties(source.name);
+                    }
+                    else if (source.dependenciesSchema) {
+                        ISchemaValidator* dependenciesValidator = context.validators[source.dependenciesValidatorIndex];
+                        if (!dependenciesValidator->IsValid())
+                            context.error_handler.AddDependencySchemaError(source.name, dependenciesValidator);
+                    }
+                }
+            }
+            if (context.error_handler.EndDependencyErrors())
+                RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorDependencies);  
+        }
+
+        return true;
+    }
+
+    bool StartArray(Context& context) const {
         context.arrayElementIndex = 0;
-        context.inArray = true;
+        context.inArray = true;  // Ensure we note that we are in an array
+
+        if (!(type_ & (1 << kArraySchemaType))) {
+            DisallowedType(context, GetArrayString());
+            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorType);
+        }
 
         return CreateParallelValidator(context);
     }
 
-    bool EndArray(Context& context, SizeType elementCount) const { 
+    bool EndArray(Context& context, SizeType elementCount) const {
         context.inArray = false;
         
-        if (elementCount < minItems_)
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinItemsString());
+        if (elementCount < minItems_) {
+            context.error_handler.TooFewItems(elementCount, minItems_);
+            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorMinItems);
+        }
         
-        if (elementCount > maxItems_)
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxItemsString());
+        if (elementCount > maxItems_) {
+            context.error_handler.TooManyItems(elementCount, maxItems_);
+            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorMaxItems);
+        }
 
         return true;
     }
 
+    static const ValueType& GetValidateErrorKeyword(ValidateErrorCode validateErrorCode) {
+        switch (validateErrorCode) {
+            case kValidateErrorMultipleOf:              return GetMultipleOfString();
+            case kValidateErrorMaximum:                 return GetMaximumString();
+            case kValidateErrorExclusiveMaximum:        return GetMaximumString(); // Same
+            case kValidateErrorMinimum:                 return GetMinimumString();
+            case kValidateErrorExclusiveMinimum:        return GetMinimumString(); // Same
+
+            case kValidateErrorMaxLength:               return GetMaxLengthString();
+            case kValidateErrorMinLength:               return GetMinLengthString();
+            case kValidateErrorPattern:                 return GetPatternString();
+
+            case kValidateErrorMaxItems:                return GetMaxItemsString();
+            case kValidateErrorMinItems:                return GetMinItemsString();
+            case kValidateErrorUniqueItems:             return GetUniqueItemsString();
+            case kValidateErrorAdditionalItems:         return GetAdditionalItemsString();
+
+            case kValidateErrorMaxProperties:           return GetMaxPropertiesString();
+            case kValidateErrorMinProperties:           return GetMinPropertiesString();
+            case kValidateErrorRequired:                return GetRequiredString();
+            case kValidateErrorAdditionalProperties:    return GetAdditionalPropertiesString();
+            case kValidateErrorPatternProperties:       return GetPatternPropertiesString();
+            case kValidateErrorDependencies:            return GetDependenciesString();
+
+            case kValidateErrorEnum:                    return GetEnumString();
+            case kValidateErrorType:                    return GetTypeString();
+
+            case kValidateErrorOneOf:                   return GetOneOfString();
+            case kValidateErrorOneOfMatch:              return GetOneOfString(); // Same
+            case kValidateErrorAllOf:                   return GetAllOfString();
+            case kValidateErrorAnyOf:                   return GetAnyOfString();
+            case kValidateErrorNot:                     return GetNotString();
+
+            default:                                    return GetNullString();
+        }
+    }
+
+
     // Generate functions for string literal according to Ch
 #define RAPIDJSON_STRING_(name, ...) \
     static const ValueType& Get##name##String() {\
@@ -919,6 +1127,7 @@ public:
     RAPIDJSON_STRING_(ExclusiveMinimum, 'e', 'x', 'c', 'l', 'u', 's', 'i', 'v', 'e', 'M', 'i', 'n', 'i', 'm', 'u', 'm')
     RAPIDJSON_STRING_(ExclusiveMaximum, 'e', 'x', 'c', 'l', 'u', 's', 'i', 'v', 'e', 'M', 'a', 'x', 'i', 'm', 'u', 'm')
     RAPIDJSON_STRING_(MultipleOf, 'm', 'u', 'l', 't', 'i', 'p', 'l', 'e', 'O', 'f')
+    RAPIDJSON_STRING_(DefaultValue, 'd', 'e', 'f', 'a', 'u', 'l', 't')
 
 #undef RAPIDJSON_STRING_
 
@@ -935,7 +1144,7 @@ private:
     };
 
 #if RAPIDJSON_SCHEMA_USE_INTERNALREGEX
-        typedef internal::GenericRegex<EncodingType> RegexType;
+        typedef internal::GenericRegex<EncodingType, AllocatorType> RegexType;
 #elif RAPIDJSON_SCHEMA_USE_STDREGEX
         typedef std::basic_regex<Ch> RegexType;
 #else
@@ -995,7 +1204,7 @@ private:
     template <typename ValueType>
     RegexType* CreatePattern(const ValueType& value) {
         if (value.IsString()) {
-            RegexType* r = new (allocator_->Malloc(sizeof(RegexType))) RegexType(value.GetString());
+            RegexType* r = new (allocator_->Malloc(sizeof(RegexType))) RegexType(value.GetString(), allocator_);
             if (!r->IsValid()) {
                 r->~RegexType();
                 AllocatorType::Free(r);
@@ -1013,12 +1222,15 @@ private:
 #elif RAPIDJSON_SCHEMA_USE_STDREGEX
     template <typename ValueType>
     RegexType* CreatePattern(const ValueType& value) {
-        if (value.IsString())
+        if (value.IsString()) {
+            RegexType *r = static_cast<RegexType*>(allocator_->Malloc(sizeof(RegexType)));
             try {
-                return new (allocator_->Malloc(sizeof(RegexType))) RegexType(value.GetString(), std::size_t(value.GetStringLength()), std::regex_constants::ECMAScript);
+                return new (r) RegexType(value.GetString(), std::size_t(value.GetStringLength()), std::regex_constants::ECMAScript);
             }
             catch (const std::regex_error&) {
+                AllocatorType::Free(r);
             }
+        }
         return 0;
     }
 
@@ -1052,31 +1264,32 @@ private:
             context.validators = static_cast<ISchemaValidator**>(context.factory.MallocState(sizeof(ISchemaValidator*) * validatorCount_));
             context.validatorCount = validatorCount_;
 
+            // Always return after first failure for these sub-validators
             if (allOf_.schemas)
-                CreateSchemaValidators(context, allOf_);
+                CreateSchemaValidators(context, allOf_, false);
 
             if (anyOf_.schemas)
-                CreateSchemaValidators(context, anyOf_);
+                CreateSchemaValidators(context, anyOf_, false);
             
             if (oneOf_.schemas)
-                CreateSchemaValidators(context, oneOf_);
+                CreateSchemaValidators(context, oneOf_, false);
             
             if (not_)
-                context.validators[notValidatorIndex_] = context.factory.CreateSchemaValidator(*not_);
-            
+                context.validators[notValidatorIndex_] = context.factory.CreateSchemaValidator(*not_, false);
+
             if (hasSchemaDependencies_) {
                 for (SizeType i = 0; i < propertyCount_; i++)
                     if (properties_[i].dependenciesSchema)
-                        context.validators[properties_[i].dependenciesValidatorIndex] = context.factory.CreateSchemaValidator(*properties_[i].dependenciesSchema);
+                        context.validators[properties_[i].dependenciesValidatorIndex] = context.factory.CreateSchemaValidator(*properties_[i].dependenciesSchema, false);
             }
         }
 
         return true;
     }
 
-    void CreateSchemaValidators(Context& context, const SchemaArray& schemas) const {
+    void CreateSchemaValidators(Context& context, const SchemaArray& schemas, const bool inheritContinueOnErrors) const {
         for (SizeType i = 0; i < schemas.count; i++)
-            context.validators[schemas.begin + i] = context.factory.CreateSchemaValidator(*schemas.schemas[i]);
+            context.validators[schemas.begin + i] = context.factory.CreateSchemaValidator(*schemas.schemas[i], inheritContinueOnErrors);
     }
 
     // O(n)
@@ -1094,16 +1307,21 @@ private:
     }
 
     bool CheckInt(Context& context, int64_t i) const {
-        if (!(type_ & ((1 << kIntegerSchemaType) | (1 << kNumberSchemaType))))
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+        if (!(type_ & ((1 << kIntegerSchemaType) | (1 << kNumberSchemaType)))) {
+            DisallowedType(context, GetIntegerString());
+            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorType);
+        }
 
         if (!minimum_.IsNull()) {
             if (minimum_.IsInt64()) {
-                if (exclusiveMinimum_ ? i <= minimum_.GetInt64() : i < minimum_.GetInt64())
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString());
+                if (exclusiveMinimum_ ? i <= minimum_.GetInt64() : i < minimum_.GetInt64()) {
+                    context.error_handler.BelowMinimum(i, minimum_, exclusiveMinimum_);
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(exclusiveMinimum_ ? kValidateErrorExclusiveMinimum : kValidateErrorMinimum);
+                }
             }
             else if (minimum_.IsUint64()) {
-                RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString()); // i <= max(int64_t) < minimum.GetUint64()
+                context.error_handler.BelowMinimum(i, minimum_, exclusiveMinimum_);
+                RAPIDJSON_INVALID_KEYWORD_RETURN(exclusiveMinimum_ ? kValidateErrorExclusiveMinimum : kValidateErrorMinimum); // i <= max(int64_t) < minimum.GetUint64()
             }
             else if (!CheckDoubleMinimum(context, static_cast<double>(i)))
                 return false;
@@ -1111,8 +1329,10 @@ private:
 
         if (!maximum_.IsNull()) {
             if (maximum_.IsInt64()) {
-                if (exclusiveMaximum_ ? i >= maximum_.GetInt64() : i > maximum_.GetInt64())
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString());
+                if (exclusiveMaximum_ ? i >= maximum_.GetInt64() : i > maximum_.GetInt64()) {
+                    context.error_handler.AboveMaximum(i, maximum_, exclusiveMaximum_);
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(exclusiveMaximum_ ? kValidateErrorExclusiveMaximum : kValidateErrorMaximum);
+                }
             }
             else if (maximum_.IsUint64()) { }
                 /* do nothing */ // i <= max(int64_t) < maximum_.GetUint64()
@@ -1122,8 +1342,10 @@ private:
 
         if (!multipleOf_.IsNull()) {
             if (multipleOf_.IsUint64()) {
-                if (static_cast<uint64_t>(i >= 0 ? i : -i) % multipleOf_.GetUint64() != 0)
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMultipleOfString());
+                if (static_cast<uint64_t>(i >= 0 ? i : -i) % multipleOf_.GetUint64() != 0) {
+                    context.error_handler.NotMultipleOf(i, multipleOf_);
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorMultipleOf);
+                }
             }
             else if (!CheckDoubleMultipleOf(context, static_cast<double>(i)))
                 return false;
@@ -1133,13 +1355,17 @@ private:
     }
 
     bool CheckUint(Context& context, uint64_t i) const {
-        if (!(type_ & ((1 << kIntegerSchemaType) | (1 << kNumberSchemaType))))
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+        if (!(type_ & ((1 << kIntegerSchemaType) | (1 << kNumberSchemaType)))) {
+            DisallowedType(context, GetIntegerString());
+            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorType);
+        }
 
         if (!minimum_.IsNull()) {
             if (minimum_.IsUint64()) {
-                if (exclusiveMinimum_ ? i <= minimum_.GetUint64() : i < minimum_.GetUint64())
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString());
+                if (exclusiveMinimum_ ? i <= minimum_.GetUint64() : i < minimum_.GetUint64()) {
+                    context.error_handler.BelowMinimum(i, minimum_, exclusiveMinimum_);
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(exclusiveMinimum_ ? kValidateErrorExclusiveMinimum : kValidateErrorMinimum);
+                }
             }
             else if (minimum_.IsInt64())
                 /* do nothing */; // i >= 0 > minimum.Getint64()
@@ -1149,19 +1375,25 @@ private:
 
         if (!maximum_.IsNull()) {
             if (maximum_.IsUint64()) {
-                if (exclusiveMaximum_ ? i >= maximum_.GetUint64() : i > maximum_.GetUint64())
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString());
+                if (exclusiveMaximum_ ? i >= maximum_.GetUint64() : i > maximum_.GetUint64()) {
+                    context.error_handler.AboveMaximum(i, maximum_, exclusiveMaximum_);
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(exclusiveMaximum_ ? kValidateErrorExclusiveMaximum : kValidateErrorMaximum);
+                }
+            }
+            else if (maximum_.IsInt64()) {
+                context.error_handler.AboveMaximum(i, maximum_, exclusiveMaximum_);
+                RAPIDJSON_INVALID_KEYWORD_RETURN(exclusiveMaximum_ ? kValidateErrorExclusiveMaximum : kValidateErrorMaximum); // i >= 0 > maximum_
             }
-            else if (maximum_.IsInt64())
-                RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString()); // i >= 0 > maximum_
             else if (!CheckDoubleMaximum(context, static_cast<double>(i)))
                 return false;
         }
 
         if (!multipleOf_.IsNull()) {
             if (multipleOf_.IsUint64()) {
-                if (i % multipleOf_.GetUint64() != 0)
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMultipleOfString());
+                if (i % multipleOf_.GetUint64() != 0) {
+                    context.error_handler.NotMultipleOf(i, multipleOf_);
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorMultipleOf);
+                }
             }
             else if (!CheckDoubleMultipleOf(context, static_cast<double>(i)))
                 return false;
@@ -1171,14 +1403,18 @@ private:
     }
 
     bool CheckDoubleMinimum(Context& context, double d) const {
-        if (exclusiveMinimum_ ? d <= minimum_.GetDouble() : d < minimum_.GetDouble())
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString());
+        if (exclusiveMinimum_ ? d <= minimum_.GetDouble() : d < minimum_.GetDouble()) {
+            context.error_handler.BelowMinimum(d, minimum_, exclusiveMinimum_);
+            RAPIDJSON_INVALID_KEYWORD_RETURN(exclusiveMinimum_ ? kValidateErrorExclusiveMinimum : kValidateErrorMinimum);
+        }
         return true;
     }
 
     bool CheckDoubleMaximum(Context& context, double d) const {
-        if (exclusiveMaximum_ ? d >= maximum_.GetDouble() : d > maximum_.GetDouble())
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString());
+        if (exclusiveMaximum_ ? d >= maximum_.GetDouble() : d > maximum_.GetDouble()) {
+            context.error_handler.AboveMaximum(d, maximum_, exclusiveMaximum_);
+            RAPIDJSON_INVALID_KEYWORD_RETURN(exclusiveMaximum_ ? kValidateErrorExclusiveMaximum : kValidateErrorMaximum);
+        }
         return true;
     }
 
@@ -1186,11 +1422,29 @@ private:
         double a = std::abs(d), b = std::abs(multipleOf_.GetDouble());
         double q = std::floor(a / b);
         double r = a - q * b;
-        if (r > 0.0)
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetMultipleOfString());
+        if (r > 0.0) {
+            context.error_handler.NotMultipleOf(d, multipleOf_);
+            RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorMultipleOf);
+        }
         return true;
     }
 
+    void DisallowedType(Context& context, const ValueType& actualType) const {
+        ErrorHandler& eh = context.error_handler;
+        eh.StartDisallowedType();
+
+        if (type_ & (1 << kNullSchemaType)) eh.AddExpectedType(GetNullString());
+        if (type_ & (1 << kBooleanSchemaType)) eh.AddExpectedType(GetBooleanString());
+        if (type_ & (1 << kObjectSchemaType)) eh.AddExpectedType(GetObjectString());
+        if (type_ & (1 << kArraySchemaType)) eh.AddExpectedType(GetArrayString());
+        if (type_ & (1 << kStringSchemaType)) eh.AddExpectedType(GetStringString());
+
+        if (type_ & (1 << kNumberSchemaType)) eh.AddExpectedType(GetNumberString());
+        else if (type_ & (1 << kIntegerSchemaType)) eh.AddExpectedType(GetIntegerString());
+
+        eh.EndDisallowedType(actualType);
+    }
+
     struct Property {
         Property() : schema(), dependenciesSchema(), dependenciesValidatorIndex(), dependencies(), required(false) {}
         ~Property() { AllocatorType::Free(dependencies); }
@@ -1215,6 +1469,8 @@ private:
     };
 
     AllocatorType* allocator_;
+    SValue uri_;
+    PointerType pointer_;
     const SchemaType* typeless_;
     uint64_t* enum_;
     SizeType enumCount_;
@@ -1256,6 +1512,8 @@ private:
     SValue multipleOf_;
     bool exclusiveMinimum_;
     bool exclusiveMaximum_;
+    
+    SizeType defaultValueLength_;
 };
 
 template<typename Stack, typename Ch>
@@ -1324,6 +1582,7 @@ public:
     typedef typename EncodingType::Ch Ch;
     typedef internal::Schema<GenericSchemaDocument> SchemaType;
     typedef GenericPointer<ValueType, Allocator> PointerType;
+    typedef GenericValue<EncodingType, Allocator> URIType;
     friend class internal::Schema<GenericSchemaDocument>;
     template <typename, typename, typename>
     friend class GenericSchemaValidator;
@@ -1333,10 +1592,13 @@ public:
         Compile a JSON document into schema document.
 
         \param document A JSON document as source.
+        \param uri The base URI of this schema document for purposes of violation reporting.
+        \param uriLength Length of \c name, in code points.
         \param remoteProvider An optional remote schema document provider for resolving remote reference. Can be null.
         \param allocator An optional allocator instance for allocating memory. Can be null.
     */
-    explicit GenericSchemaDocument(const ValueType& document, IRemoteSchemaDocumentProviderType* remoteProvider = 0, Allocator* allocator = 0) :
+    explicit GenericSchemaDocument(const ValueType& document, const Ch* uri = 0, SizeType uriLength = 0,
+        IRemoteSchemaDocumentProviderType* remoteProvider = 0, Allocator* allocator = 0) :
         remoteProvider_(remoteProvider),
         allocator_(allocator),
         ownAllocator_(),
@@ -1348,8 +1610,11 @@ public:
         if (!allocator_)
             ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();
 
+        Ch noUri[1] = {0};
+        uri_.SetString(uri ? uri : noUri, uriLength, *allocator_);
+
         typeless_ = static_cast<SchemaType*>(allocator_->Malloc(sizeof(SchemaType)));
-        new (typeless_) SchemaType(this, PointerType(), ValueType(kObjectType).Move(), ValueType(kObjectType).Move(), 0);
+        new (typeless_) SchemaType(this, PointerType(), ValueType(kObjectType).Move(), ValueType(kObjectType).Move(), allocator_);
 
         // Generate root schema, it will call CreateSchema() to create sub-schemas,
         // And call AddRefSchema() if there are $ref.
@@ -1387,7 +1652,8 @@ public:
         root_(rhs.root_),
         typeless_(rhs.typeless_),
         schemaMap_(std::move(rhs.schemaMap_)),
-        schemaRef_(std::move(rhs.schemaRef_))
+        schemaRef_(std::move(rhs.schemaRef_)),
+        uri_(std::move(rhs.uri_))
     {
         rhs.remoteProvider_ = 0;
         rhs.allocator_ = 0;
@@ -1409,6 +1675,8 @@ public:
         RAPIDJSON_DELETE(ownAllocator_);
     }
 
+    const URIType& GetURI() const { return uri_; }
+
     //! Get the root schema.
     const SchemaType& GetRoot() const { return *root_; }
 
@@ -1491,6 +1759,7 @@ private:
                                 if (const SchemaType* sc = remoteDocument->GetSchema(pointer)) {
                                     if (schema)
                                         *schema = sc;
+                                    new (schemaMap_.template Push<SchemaEntry>()) SchemaEntry(source, const_cast<SchemaType*>(sc), false, allocator_);
                                     return true;
                                 }
                             }
@@ -1539,6 +1808,7 @@ private:
     SchemaType* typeless_;
     internal::Stack<Allocator> schemaMap_;  // Stores created Pointer -> Schemas
     internal::Stack<Allocator> schemaRef_;  // Stores Pointer from $ref and schema which holds the $ref
+    URIType uri_;
 };
 
 //! GenericSchemaDocument using Value type.
@@ -1567,13 +1837,16 @@ template <
     typename StateAllocator = CrtAllocator>
 class GenericSchemaValidator :
     public internal::ISchemaStateFactory<typename SchemaDocumentType::SchemaType>, 
-    public internal::ISchemaValidator
-{
+    public internal::ISchemaValidator,
+    public internal::IValidationErrorHandler<typename SchemaDocumentType::SchemaType> {
 public:
     typedef typename SchemaDocumentType::SchemaType SchemaType;
     typedef typename SchemaDocumentType::PointerType PointerType;
     typedef typename SchemaType::EncodingType EncodingType;
+    typedef typename SchemaType::SValue SValue;
     typedef typename EncodingType::Ch Ch;
+    typedef GenericStringRef<Ch> StringRefType;
+    typedef GenericValue<EncodingType, StateAllocator> ValueType;
 
     //! Constructor without output handler.
     /*!
@@ -1595,7 +1868,11 @@ public:
         schemaStack_(allocator, schemaStackCapacity),
         documentStack_(allocator, documentStackCapacity),
         outputHandler_(0),
-        valid_(true)
+        error_(kObjectType),
+        currentError_(),
+        missingDependents_(),
+        valid_(true),
+        flags_(kValidateDefaultFlags)
 #if RAPIDJSON_SCHEMA_VERBOSE
         , depth_(0)
 #endif
@@ -1623,7 +1900,11 @@ public:
         schemaStack_(allocator, schemaStackCapacity),
         documentStack_(allocator, documentStackCapacity),
         outputHandler_(&outputHandler),
-        valid_(true)
+        error_(kObjectType),
+        currentError_(),
+        missingDependents_(),
+        valid_(true),
+        flags_(kValidateDefaultFlags)
 #if RAPIDJSON_SCHEMA_VERBOSE
         , depth_(0)
 #endif
@@ -1641,28 +1922,267 @@ public:
         while (!schemaStack_.Empty())
             PopSchema();
         documentStack_.Clear();
+        ResetError();
+    }
+
+    //! Reset the error state.
+    void ResetError() {
+        error_.SetObject();
+        currentError_.SetNull();
+        missingDependents_.SetNull();
         valid_ = true;
     }
 
+    //! Implementation of ISchemaValidator
+    void SetValidateFlags(unsigned flags) {
+        flags_ = flags;
+    }
+    virtual unsigned GetValidateFlags() const {
+        return flags_;
+    }
+
     //! Checks whether the current state is valid.
     // Implementation of ISchemaValidator
-    virtual bool IsValid() const { return valid_; }
+    virtual bool IsValid() const {
+        if (!valid_) return false;
+        if (GetContinueOnErrors() && !error_.ObjectEmpty()) return false;
+        return true;
+    }
+
+    //! Gets the error object.
+    ValueType& GetError() { return error_; }
+    const ValueType& GetError() const { return error_; }
 
     //! Gets the JSON pointer pointed to the invalid schema.
+    //  If reporting all errors, the stack will be empty.
     PointerType GetInvalidSchemaPointer() const {
-        return schemaStack_.Empty() ? PointerType() : schemaDocument_->GetPointer(&CurrentSchema());
+        return schemaStack_.Empty() ? PointerType() : CurrentSchema().GetPointer();
     }
 
     //! Gets the keyword of invalid schema.
+    //  If reporting all errors, the stack will be empty, so return "errors".
     const Ch* GetInvalidSchemaKeyword() const {
-        return schemaStack_.Empty() ? 0 : CurrentContext().invalidKeyword;
+        if (!schemaStack_.Empty()) return CurrentContext().invalidKeyword;
+        if (GetContinueOnErrors() && !error_.ObjectEmpty()) return (const Ch*)GetErrorsString();
+        return 0;
+    }
+
+    //! Gets the error code of invalid schema.
+    //  If reporting all errors, the stack will be empty, so return kValidateErrors.
+    ValidateErrorCode GetInvalidSchemaCode() const {
+        if (!schemaStack_.Empty()) return CurrentContext().invalidCode;
+        if (GetContinueOnErrors() && !error_.ObjectEmpty()) return kValidateErrors;
+        return kValidateErrorNone;
     }
 
     //! Gets the JSON pointer pointed to the invalid value.
+    //  If reporting all errors, the stack will be empty.
     PointerType GetInvalidDocumentPointer() const {
-        return documentStack_.Empty() ? PointerType() : PointerType(documentStack_.template Bottom<Ch>(), documentStack_.GetSize() / sizeof(Ch));
+        if (documentStack_.Empty()) {
+            return PointerType();
+        }
+        else {
+            return PointerType(documentStack_.template Bottom<Ch>(), documentStack_.GetSize() / sizeof(Ch));
+        }
     }
 
+    void NotMultipleOf(int64_t actual, const SValue& expected) {
+        AddNumberError(kValidateErrorMultipleOf, ValueType(actual).Move(), expected);
+    }
+    void NotMultipleOf(uint64_t actual, const SValue& expected) {
+        AddNumberError(kValidateErrorMultipleOf, ValueType(actual).Move(), expected);
+    }
+    void NotMultipleOf(double actual, const SValue& expected) {
+        AddNumberError(kValidateErrorMultipleOf, ValueType(actual).Move(), expected);
+    }
+    void AboveMaximum(int64_t actual, const SValue& expected, bool exclusive) {
+        AddNumberError(exclusive ? kValidateErrorExclusiveMaximum : kValidateErrorMaximum, ValueType(actual).Move(), expected,
+            exclusive ? &SchemaType::GetExclusiveMaximumString : 0);
+    }
+    void AboveMaximum(uint64_t actual, const SValue& expected, bool exclusive) {
+        AddNumberError(exclusive ? kValidateErrorExclusiveMaximum : kValidateErrorMaximum, ValueType(actual).Move(), expected,
+            exclusive ? &SchemaType::GetExclusiveMaximumString : 0);
+    }
+    void AboveMaximum(double actual, const SValue& expected, bool exclusive) {
+        AddNumberError(exclusive ? kValidateErrorExclusiveMaximum : kValidateErrorMaximum, ValueType(actual).Move(), expected,
+            exclusive ? &SchemaType::GetExclusiveMaximumString : 0);
+    }
+    void BelowMinimum(int64_t actual, const SValue& expected, bool exclusive) {
+        AddNumberError(exclusive ? kValidateErrorExclusiveMinimum : kValidateErrorMinimum, ValueType(actual).Move(), expected,
+            exclusive ? &SchemaType::GetExclusiveMinimumString : 0);
+    }
+    void BelowMinimum(uint64_t actual, const SValue& expected, bool exclusive) {
+        AddNumberError(exclusive ? kValidateErrorExclusiveMinimum : kValidateErrorMinimum, ValueType(actual).Move(), expected,
+            exclusive ? &SchemaType::GetExclusiveMinimumString : 0);
+    }
+    void BelowMinimum(double actual, const SValue& expected, bool exclusive) {
+        AddNumberError(exclusive ? kValidateErrorExclusiveMinimum : kValidateErrorMinimum, ValueType(actual).Move(), expected,
+            exclusive ? &SchemaType::GetExclusiveMinimumString : 0);
+    }
+
+    void TooLong(const Ch* str, SizeType length, SizeType expected) {
+        AddNumberError(kValidateErrorMaxLength,
+            ValueType(str, length, GetStateAllocator()).Move(), SValue(expected).Move());
+    }
+    void TooShort(const Ch* str, SizeType length, SizeType expected) {
+        AddNumberError(kValidateErrorMinLength,
+            ValueType(str, length, GetStateAllocator()).Move(), SValue(expected).Move());
+    }
+    void DoesNotMatch(const Ch* str, SizeType length) {
+        currentError_.SetObject();
+        currentError_.AddMember(GetActualString(), ValueType(str, length, GetStateAllocator()).Move(), GetStateAllocator());
+        AddCurrentError(kValidateErrorPattern);
+    }
+
+    void DisallowedItem(SizeType index) {
+        currentError_.SetObject();
+        currentError_.AddMember(GetDisallowedString(), ValueType(index).Move(), GetStateAllocator());
+        AddCurrentError(kValidateErrorAdditionalItems, true);
+    }
+    void TooFewItems(SizeType actualCount, SizeType expectedCount) {
+        AddNumberError(kValidateErrorMinItems,
+            ValueType(actualCount).Move(), SValue(expectedCount).Move());
+    }
+    void TooManyItems(SizeType actualCount, SizeType expectedCount) {
+        AddNumberError(kValidateErrorMaxItems,
+            ValueType(actualCount).Move(), SValue(expectedCount).Move());
+    }
+    void DuplicateItems(SizeType index1, SizeType index2) {
+        ValueType duplicates(kArrayType);
+        duplicates.PushBack(index1, GetStateAllocator());
+        duplicates.PushBack(index2, GetStateAllocator());
+        currentError_.SetObject();
+        currentError_.AddMember(GetDuplicatesString(), duplicates, GetStateAllocator());
+        AddCurrentError(kValidateErrorUniqueItems, true);
+    }
+
+    void TooManyProperties(SizeType actualCount, SizeType expectedCount) {
+        AddNumberError(kValidateErrorMaxProperties,
+            ValueType(actualCount).Move(), SValue(expectedCount).Move());
+    }
+    void TooFewProperties(SizeType actualCount, SizeType expectedCount) {
+        AddNumberError(kValidateErrorMinProperties,
+            ValueType(actualCount).Move(), SValue(expectedCount).Move());
+    }
+    void StartMissingProperties() {
+        currentError_.SetArray();
+    }
+    void AddMissingProperty(const SValue& name) {
+        currentError_.PushBack(ValueType(name, GetStateAllocator()).Move(), GetStateAllocator());
+    }
+    bool EndMissingProperties() {
+        if (currentError_.Empty())
+            return false;
+        ValueType error(kObjectType);
+        error.AddMember(GetMissingString(), currentError_, GetStateAllocator());
+        currentError_ = error;
+        AddCurrentError(kValidateErrorRequired);
+        return true;
+    }
+    void PropertyViolations(ISchemaValidator** subvalidators, SizeType count) {
+        for (SizeType i = 0; i < count; ++i)
+            MergeError(static_cast<GenericSchemaValidator*>(subvalidators[i])->GetError());
+    }
+    void DisallowedProperty(const Ch* name, SizeType length) {
+        currentError_.SetObject();
+        currentError_.AddMember(GetDisallowedString(), ValueType(name, length, GetStateAllocator()).Move(), GetStateAllocator());
+        AddCurrentError(kValidateErrorAdditionalProperties, true);
+    }
+
+    void StartDependencyErrors() {
+        currentError_.SetObject();
+    }
+    void StartMissingDependentProperties() {
+        missingDependents_.SetArray();
+    }
+    void AddMissingDependentProperty(const SValue& targetName) {
+        missingDependents_.PushBack(ValueType(targetName, GetStateAllocator()).Move(), GetStateAllocator());
+    }
+    void EndMissingDependentProperties(const SValue& sourceName) {
+        if (!missingDependents_.Empty()) {
+            // Create equivalent 'required' error
+            ValueType error(kObjectType);
+            ValidateErrorCode code = kValidateErrorRequired;
+            error.AddMember(GetMissingString(), missingDependents_.Move(), GetStateAllocator());
+            AddErrorCode(error, code);
+            AddErrorInstanceLocation(error, false);
+            // When appending to a pointer ensure its allocator is used
+            PointerType schemaRef = GetInvalidSchemaPointer().Append(SchemaType::GetValidateErrorKeyword(kValidateErrorDependencies), &GetInvalidSchemaPointer().GetAllocator());
+            AddErrorSchemaLocation(error, schemaRef.Append(sourceName.GetString(), sourceName.GetStringLength(), &GetInvalidSchemaPointer().GetAllocator()));
+            ValueType wrapper(kObjectType);
+            wrapper.AddMember(ValueType(SchemaType::GetValidateErrorKeyword(code), GetStateAllocator()).Move(), error, GetStateAllocator());
+            currentError_.AddMember(ValueType(sourceName, GetStateAllocator()).Move(), wrapper, GetStateAllocator());
+        }
+    }
+    void AddDependencySchemaError(const SValue& sourceName, ISchemaValidator* subvalidator) {
+        currentError_.AddMember(ValueType(sourceName, GetStateAllocator()).Move(),
+            static_cast<GenericSchemaValidator*>(subvalidator)->GetError(), GetStateAllocator());
+    }
+    bool EndDependencyErrors() {
+        if (currentError_.ObjectEmpty())
+            return false;
+        ValueType error(kObjectType);
+        error.AddMember(GetErrorsString(), currentError_, GetStateAllocator());
+        currentError_ = error;
+        AddCurrentError(kValidateErrorDependencies);
+        return true;
+    }
+
+    void DisallowedValue(const ValidateErrorCode code = kValidateErrorEnum) {
+        currentError_.SetObject();
+        AddCurrentError(code);
+    }
+    void StartDisallowedType() {
+        currentError_.SetArray();
+    }
+    void AddExpectedType(const typename SchemaType::ValueType& expectedType) {
+        currentError_.PushBack(ValueType(expectedType, GetStateAllocator()).Move(), GetStateAllocator());
+    }
+    void EndDisallowedType(const typename SchemaType::ValueType& actualType) {
+        ValueType error(kObjectType);
+        error.AddMember(GetExpectedString(), currentError_, GetStateAllocator());
+        error.AddMember(GetActualString(), ValueType(actualType, GetStateAllocator()).Move(), GetStateAllocator());
+        currentError_ = error;
+        AddCurrentError(kValidateErrorType);
+    }
+    void NotAllOf(ISchemaValidator** subvalidators, SizeType count) {
+        // Treat allOf like oneOf and anyOf to match https://rapidjson.org/md_doc_schema.html#allOf-anyOf-oneOf
+        AddErrorArray(kValidateErrorAllOf, subvalidators, count);
+        //for (SizeType i = 0; i < count; ++i) {
+        //    MergeError(static_cast<GenericSchemaValidator*>(subvalidators[i])->GetError());
+        //}
+    }
+    void NoneOf(ISchemaValidator** subvalidators, SizeType count) {
+        AddErrorArray(kValidateErrorAnyOf, subvalidators, count);
+    }
+    void NotOneOf(ISchemaValidator** subvalidators, SizeType count, bool matched = false) {
+        AddErrorArray(matched ? kValidateErrorOneOfMatch : kValidateErrorOneOf, subvalidators, count);
+    }
+    void Disallowed() {
+        currentError_.SetObject();
+        AddCurrentError(kValidateErrorNot);
+    }
+
+#define RAPIDJSON_STRING_(name, ...) \
+    static const StringRefType& Get##name##String() {\
+        static const Ch s[] = { __VA_ARGS__, '\0' };\
+        static const StringRefType v(s, static_cast<SizeType>(sizeof(s) / sizeof(Ch) - 1)); \
+        return v;\
+    }
+
+    RAPIDJSON_STRING_(InstanceRef, 'i', 'n', 's', 't', 'a', 'n', 'c', 'e', 'R', 'e', 'f')
+    RAPIDJSON_STRING_(SchemaRef, 's', 'c', 'h', 'e', 'm', 'a', 'R', 'e', 'f')
+    RAPIDJSON_STRING_(Expected, 'e', 'x', 'p', 'e', 'c', 't', 'e', 'd')
+    RAPIDJSON_STRING_(Actual, 'a', 'c', 't', 'u', 'a', 'l')
+    RAPIDJSON_STRING_(Disallowed, 'd', 'i', 's', 'a', 'l', 'l', 'o', 'w', 'e', 'd')
+    RAPIDJSON_STRING_(Missing, 'm', 'i', 's', 's', 'i', 'n', 'g')
+    RAPIDJSON_STRING_(Errors, 'e', 'r', 'r', 'o', 'r', 's')
+    RAPIDJSON_STRING_(ErrorCode, 'e', 'r', 'r', 'o', 'r', 'C', 'o', 'd', 'e')
+    RAPIDJSON_STRING_(ErrorMessage, 'e', 'r', 'r', 'o', 'r', 'M', 'e', 's', 's', 'a', 'g', 'e')
+    RAPIDJSON_STRING_(Duplicates, 'd', 'u', 'p', 'l', 'i', 'c', 'a', 't', 'e', 's')
+
+#undef RAPIDJSON_STRING_
+
 #if RAPIDJSON_SCHEMA_VERBOSE
 #define RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_() \
 RAPIDJSON_MULTILINEMACRO_BEGIN\
@@ -1676,7 +2196,7 @@ RAPIDJSON_MULTILINEMACRO_END
 
 #define RAPIDJSON_SCHEMA_HANDLE_BEGIN_(method, arg1)\
     if (!valid_) return false; \
-    if (!BeginValue() || !CurrentSchema().method arg1) {\
+    if ((!BeginValue() && !GetContinueOnErrors()) || (!CurrentSchema().method arg1 && !GetContinueOnErrors())) {\
         RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_();\
         return valid_ = false;\
     }
@@ -1694,14 +2214,15 @@ RAPIDJSON_MULTILINEMACRO_END
     }
 
 #define RAPIDJSON_SCHEMA_HANDLE_END_(method, arg2)\
-    return valid_ = EndValue() && (!outputHandler_ || outputHandler_->method arg2)
+    valid_ = (EndValue() || GetContinueOnErrors()) && (!outputHandler_ || outputHandler_->method arg2);\
+    return valid_;
 
 #define RAPIDJSON_SCHEMA_HANDLE_VALUE_(method, arg1, arg2) \
     RAPIDJSON_SCHEMA_HANDLE_BEGIN_   (method, arg1);\
     RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(method, arg2);\
     RAPIDJSON_SCHEMA_HANDLE_END_     (method, arg2)
 
-    bool Null()             { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Null,   (CurrentContext()   ), ( )); }
+    bool Null()             { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Null,   (CurrentContext()), ( )); }
     bool Bool(bool b)       { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Bool,   (CurrentContext(), b), (b)); }
     bool Int(int i)         { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Int,    (CurrentContext(), i), (i)); }
     bool Uint(unsigned u)   { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Uint,   (CurrentContext(), u), (u)); }
@@ -1722,15 +2243,15 @@ RAPIDJSON_MULTILINEMACRO_END
     bool Key(const Ch* str, SizeType len, bool copy) {
         if (!valid_) return false;
         AppendToken(str, len);
-        if (!CurrentSchema().Key(CurrentContext(), str, len, copy)) return valid_ = false;
+        if (!CurrentSchema().Key(CurrentContext(), str, len, copy) && !GetContinueOnErrors()) return valid_ = false;
         RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(Key, (str, len, copy));
         return valid_ = !outputHandler_ || outputHandler_->Key(str, len, copy);
     }
     
-    bool EndObject(SizeType memberCount) { 
+    bool EndObject(SizeType memberCount) {
         if (!valid_) return false;
         RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(EndObject, (memberCount));
-        if (!CurrentSchema().EndObject(CurrentContext(), memberCount)) return valid_ = false;
+        if (!CurrentSchema().EndObject(CurrentContext(), memberCount) && !GetContinueOnErrors()) return valid_ = false;
         RAPIDJSON_SCHEMA_HANDLE_END_(EndObject, (memberCount));
     }
 
@@ -1743,7 +2264,7 @@ RAPIDJSON_MULTILINEMACRO_END
     bool EndArray(SizeType elementCount) {
         if (!valid_) return false;
         RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(EndArray, (elementCount));
-        if (!CurrentSchema().EndArray(CurrentContext(), elementCount)) return valid_ = false;
+        if (!CurrentSchema().EndArray(CurrentContext(), elementCount) && !GetContinueOnErrors()) return valid_ = false;
         RAPIDJSON_SCHEMA_HANDLE_END_(EndArray, (elementCount));
     }
 
@@ -1753,12 +2274,14 @@ RAPIDJSON_MULTILINEMACRO_END
 #undef RAPIDJSON_SCHEMA_HANDLE_VALUE_
 
     // Implementation of ISchemaStateFactory<SchemaType>
-    virtual ISchemaValidator* CreateSchemaValidator(const SchemaType& root) {
-        return new (GetStateAllocator().Malloc(sizeof(GenericSchemaValidator))) GenericSchemaValidator(*schemaDocument_, root,
+    virtual ISchemaValidator* CreateSchemaValidator(const SchemaType& root, const bool inheritContinueOnErrors) {
+        ISchemaValidator* sv = new (GetStateAllocator().Malloc(sizeof(GenericSchemaValidator))) GenericSchemaValidator(*schemaDocument_, root, documentStack_.template Bottom<char>(), documentStack_.GetSize(),
 #if RAPIDJSON_SCHEMA_VERBOSE
         depth_ + 1,
 #endif
         &GetStateAllocator());
+        sv->SetValidateFlags(inheritContinueOnErrors ? GetValidateFlags() : GetValidateFlags() & ~(unsigned)kValidateContinueOnErrorFlag);
+        return sv;
     }
 
     virtual void DestroySchemaValidator(ISchemaValidator* validator) {
@@ -1797,6 +2320,7 @@ private:
     GenericSchemaValidator( 
         const SchemaDocumentType& schemaDocument,
         const SchemaType& root,
+        const char* basePath, size_t basePathSize,
 #if RAPIDJSON_SCHEMA_VERBOSE
         unsigned depth,
 #endif
@@ -1811,11 +2335,17 @@ private:
         schemaStack_(allocator, schemaStackCapacity),
         documentStack_(allocator, documentStackCapacity),
         outputHandler_(0),
-        valid_(true)
+        error_(kObjectType),
+        currentError_(),
+        missingDependents_(),
+        valid_(true),
+        flags_(kValidateDefaultFlags)
 #if RAPIDJSON_SCHEMA_VERBOSE
         , depth_(depth)
 #endif
     {
+        if (basePath && basePathSize)
+            memcpy(documentStack_.template Push<char>(basePathSize), basePath, basePathSize);
     }
 
     StateAllocator& GetStateAllocator() {
@@ -1824,6 +2354,10 @@ private:
         return *stateAllocator_;
     }
 
+    bool GetContinueOnErrors() const {
+        return flags_ & kValidateContinueOnErrorFlag;
+    }
+
     bool BeginValue() {
         if (schemaStack_.Empty())
             PushSchema(root_);
@@ -1831,7 +2365,7 @@ private:
             if (CurrentContext().inArray)
                 internal::TokenHelper<internal::Stack<StateAllocator>, Ch>::AppendIndexToken(documentStack_, CurrentContext().arrayElementIndex);
 
-            if (!CurrentSchema().BeginValue(CurrentContext()))
+            if (!CurrentSchema().BeginValue(CurrentContext()) && !GetContinueOnErrors())
                 return false;
 
             SizeType count = CurrentContext().patternPropertiesSchemaCount;
@@ -1847,7 +2381,7 @@ private:
                 SizeType& validatorCount = CurrentContext().patternPropertiesValidatorCount;
                 va = static_cast<ISchemaValidator**>(MallocState(sizeof(ISchemaValidator*) * count));
                 for (SizeType i = 0; i < count; i++)
-                    va[validatorCount++] = CreateSchemaValidator(*sa[i]);
+                    va[validatorCount++] = CreateSchemaValidator(*sa[i], true);  // Inherit continueOnError
             }
 
             CurrentContext().arrayUniqueness = valueUniqueness;
@@ -1856,7 +2390,7 @@ private:
     }
 
     bool EndValue() {
-        if (!CurrentSchema().EndValue(CurrentContext()))
+        if (!CurrentSchema().EndValue(CurrentContext()) && !GetContinueOnErrors())
             return false;
 
 #if RAPIDJSON_SCHEMA_VERBOSE
@@ -1867,20 +2401,28 @@ private:
         documentStack_.template Pop<Ch>(1);
         internal::PrintValidatorPointers(depth_, sb.GetString(), documentStack_.template Bottom<Ch>());
 #endif
-
-        uint64_t h = CurrentContext().arrayUniqueness ? static_cast<HasherType*>(CurrentContext().hasher)->GetHashCode() : 0;
+        void* hasher = CurrentContext().hasher;
+        uint64_t h = hasher && CurrentContext().arrayUniqueness ? static_cast<HasherType*>(hasher)->GetHashCode() : 0;
         
         PopSchema();
 
         if (!schemaStack_.Empty()) {
             Context& context = CurrentContext();
-            if (context.valueUniqueness) {
+            // Only check uniqueness if there is a hasher
+            if (hasher && context.valueUniqueness) {
                 HashCodeArray* a = static_cast<HashCodeArray*>(context.arrayElementHashCodes);
                 if (!a)
                     CurrentContext().arrayElementHashCodes = a = new (GetStateAllocator().Malloc(sizeof(HashCodeArray))) HashCodeArray(kArrayType);
                 for (typename HashCodeArray::ConstValueIterator itr = a->Begin(); itr != a->End(); ++itr)
-                    if (itr->GetUint64() == h)
-                        RAPIDJSON_INVALID_KEYWORD_RETURN(SchemaType::GetUniqueItemsString());
+                    if (itr->GetUint64() == h) {
+                        DuplicateItems(static_cast<SizeType>(itr - a->Begin()), a->Size());
+                        // Cleanup before returning if continuing
+                        if (GetContinueOnErrors()) {
+                            a->PushBack(h, GetStateAllocator());
+                            while (!documentStack_.Empty() && *documentStack_.template Pop<Ch>(1) != '/');
+                        }
+                        RAPIDJSON_INVALID_KEYWORD_RETURN(kValidateErrorUniqueItems);
+                    }
                 a->PushBack(h, GetStateAllocator());
             }
         }
@@ -1909,7 +2451,7 @@ private:
         }
     }
 
-    RAPIDJSON_FORCEINLINE void PushSchema(const SchemaType& schema) { new (schemaStack_.template Push<Context>()) Context(*this, &schema); }
+    RAPIDJSON_FORCEINLINE void PushSchema(const SchemaType& schema) { new (schemaStack_.template Push<Context>()) Context(*this, *this, &schema); }
     
     RAPIDJSON_FORCEINLINE void PopSchema() {
         Context* c = schemaStack_.template Pop<Context>(1);
@@ -1920,6 +2462,79 @@ private:
         c->~Context();
     }
 
+    void AddErrorInstanceLocation(ValueType& result, bool parent) {
+        GenericStringBuffer<EncodingType> sb;
+        PointerType instancePointer = GetInvalidDocumentPointer();
+        ((parent && instancePointer.GetTokenCount() > 0)
+         ? PointerType(instancePointer.GetTokens(), instancePointer.GetTokenCount() - 1)
+         : instancePointer).StringifyUriFragment(sb);
+        ValueType instanceRef(sb.GetString(), static_cast<SizeType>(sb.GetSize() / sizeof(Ch)),
+                              GetStateAllocator());
+        result.AddMember(GetInstanceRefString(), instanceRef, GetStateAllocator());
+    }
+
+    void AddErrorSchemaLocation(ValueType& result, PointerType schema = PointerType()) {
+        GenericStringBuffer<EncodingType> sb;
+        SizeType len = CurrentSchema().GetURI().GetStringLength();
+        if (len) memcpy(sb.Push(len), CurrentSchema().GetURI().GetString(), len * sizeof(Ch));
+        if (schema.GetTokenCount()) schema.StringifyUriFragment(sb);
+        else GetInvalidSchemaPointer().StringifyUriFragment(sb);
+        ValueType schemaRef(sb.GetString(), static_cast<SizeType>(sb.GetSize() / sizeof(Ch)),
+            GetStateAllocator());
+        result.AddMember(GetSchemaRefString(), schemaRef, GetStateAllocator());
+    }
+
+    void AddErrorCode(ValueType& result, const ValidateErrorCode code) {
+        result.AddMember(GetErrorCodeString(), code, GetStateAllocator());
+    }
+
+    void AddError(ValueType& keyword, ValueType& error) {
+        typename ValueType::MemberIterator member = error_.FindMember(keyword);
+        if (member == error_.MemberEnd())
+            error_.AddMember(keyword, error, GetStateAllocator());
+        else {
+            if (member->value.IsObject()) {
+                ValueType errors(kArrayType);
+                errors.PushBack(member->value, GetStateAllocator());
+                member->value = errors;
+            }
+            member->value.PushBack(error, GetStateAllocator());
+        }
+    }
+
+    void AddCurrentError(const ValidateErrorCode code, bool parent = false) {
+        AddErrorCode(currentError_, code);
+        AddErrorInstanceLocation(currentError_, parent);
+        AddErrorSchemaLocation(currentError_);
+        AddError(ValueType(SchemaType::GetValidateErrorKeyword(code), GetStateAllocator(), false).Move(), currentError_);
+    }
+
+    void MergeError(ValueType& other) {
+        for (typename ValueType::MemberIterator it = other.MemberBegin(), end = other.MemberEnd(); it != end; ++it) {
+            AddError(it->name, it->value);
+        }
+    }
+
+    void AddNumberError(const ValidateErrorCode code, ValueType& actual, const SValue& expected,
+        const typename SchemaType::ValueType& (*exclusive)() = 0) {
+        currentError_.SetObject();
+        currentError_.AddMember(GetActualString(), actual, GetStateAllocator());
+        currentError_.AddMember(GetExpectedString(), ValueType(expected, GetStateAllocator()).Move(), GetStateAllocator());
+        if (exclusive)
+            currentError_.AddMember(ValueType(exclusive(), GetStateAllocator()).Move(), true, GetStateAllocator());
+        AddCurrentError(code);
+    }
+
+    void AddErrorArray(const ValidateErrorCode code,
+        ISchemaValidator** subvalidators, SizeType count) {
+        ValueType errors(kArrayType);
+        for (SizeType i = 0; i < count; ++i)
+            errors.PushBack(static_cast<GenericSchemaValidator*>(subvalidators[i])->GetError(), GetStateAllocator());
+        currentError_.SetObject();
+        currentError_.AddMember(GetErrorsString(), errors, GetStateAllocator());
+        AddCurrentError(code);
+    }
+
     const SchemaType& CurrentSchema() const { return *schemaStack_.template Top<Context>()->schema; }
     Context& CurrentContext() { return *schemaStack_.template Top<Context>(); }
     const Context& CurrentContext() const { return *schemaStack_.template Top<Context>(); }
@@ -1933,7 +2548,11 @@ private:
     internal::Stack<StateAllocator> schemaStack_;    //!< stack to store the current path of schema (BaseSchemaType *)
     internal::Stack<StateAllocator> documentStack_;  //!< stack to store the current path of validating document (Ch)
     OutputHandler* outputHandler_;
+    ValueType error_;
+    ValueType currentError_;
+    ValueType missingDependents_;
     bool valid_;
+    unsigned flags_;
 #if RAPIDJSON_SCHEMA_VERBOSE
     unsigned depth_;
 #endif
@@ -1964,13 +2583,14 @@ class SchemaValidatingReader {
 public:
     typedef typename SchemaDocumentType::PointerType PointerType;
     typedef typename InputStream::Ch Ch;
+    typedef GenericValue<SourceEncoding, StackAllocator> ValueType;
 
     //! Constructor
     /*!
         \param is Input stream.
         \param sd Schema document.
     */
-    SchemaValidatingReader(InputStream& is, const SchemaDocumentType& sd) : is_(is), sd_(sd), invalidSchemaKeyword_(), isValid_(true) {}
+    SchemaValidatingReader(InputStream& is, const SchemaDocumentType& sd) : is_(is), sd_(sd), invalidSchemaKeyword_(), invalidSchemaCode_(kValidateErrorNone), error_(kObjectType), isValid_(true) {}
 
     template <typename Handler>
     bool operator()(Handler& handler) {
@@ -1983,11 +2603,14 @@ public:
             invalidSchemaPointer_ = PointerType();
             invalidSchemaKeyword_ = 0;
             invalidDocumentPointer_ = PointerType();
+            error_.SetObject();
         }
         else {
             invalidSchemaPointer_ = validator.GetInvalidSchemaPointer();
             invalidSchemaKeyword_ = validator.GetInvalidSchemaKeyword();
+            invalidSchemaCode_ = validator.GetInvalidSchemaCode();
             invalidDocumentPointer_ = validator.GetInvalidDocumentPointer();
+            error_.CopyFrom(validator.GetError(), allocator_);
         }
 
         return parseResult_;
@@ -1998,6 +2621,8 @@ public:
     const PointerType& GetInvalidSchemaPointer() const { return invalidSchemaPointer_; }
     const Ch* GetInvalidSchemaKeyword() const { return invalidSchemaKeyword_; }
     const PointerType& GetInvalidDocumentPointer() const { return invalidDocumentPointer_; }
+    const ValueType& GetError() const { return error_; }
+    ValidateErrorCode GetInvalidSchemaCode() const { return invalidSchemaCode_; }
 
 private:
     InputStream& is_;
@@ -2007,6 +2632,9 @@ private:
     PointerType invalidSchemaPointer_;
     const Ch* invalidSchemaKeyword_;
     PointerType invalidDocumentPointer_;
+    ValidateErrorCode invalidSchemaCode_;
+    StackAllocator allocator_;
+    ValueType error_;
     bool isValid_;
 };
 
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/stream.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/stream.h
index fef82c252..1fd70915c 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/stream.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/stream.h
@@ -1,15 +1,15 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
-// 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
 //
 // http://opensource.org/licenses/MIT
 //
-// Unless required by applicable law or agreed to in writing, software distributed 
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
 // specific language governing permissions and limitations under the License.
 
 #include "rapidjson.h"
@@ -100,6 +100,50 @@ inline void PutN(Stream& stream, Ch c, size_t n) {
         PutUnsafe(stream, c);
 }
 
+///////////////////////////////////////////////////////////////////////////////
+// GenericStreamWrapper
+
+//! A Stream Wrapper
+/*! \tThis string stream is a wrapper for any stream by just forwarding any
+    \treceived message to the origin stream.
+    \note implements Stream concept
+*/
+
+#if defined(_MSC_VER) && _MSC_VER <= 1800
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(4702)  // unreachable code
+RAPIDJSON_DIAG_OFF(4512)  // assignment operator could not be generated
+#endif
+
+template <typename InputStream, typename Encoding = UTF8<> >
+class GenericStreamWrapper {
+public:
+    typedef typename Encoding::Ch Ch;
+    GenericStreamWrapper(InputStream& is): is_(is) {}
+
+    Ch Peek() const { return is_.Peek(); }
+    Ch Take() { return is_.Take(); }
+    size_t Tell() { return is_.Tell(); }
+    Ch* PutBegin() { return is_.PutBegin(); }
+    void Put(Ch ch) { is_.Put(ch); }
+    void Flush() { is_.Flush(); }
+    size_t PutEnd(Ch* ch) { return is_.PutEnd(ch); }
+
+    // wrapper for MemoryStream
+    const Ch* Peek4() const { return is_.Peek4(); }
+
+    // wrapper for AutoUTFInputStream
+    UTFType GetType() const { return is_.GetType(); }
+    bool HasBOM() const { return is_.HasBOM(); }
+
+protected:
+    InputStream& is_;
+};
+
+#if defined(_MSC_VER) && _MSC_VER <= 1800
+RAPIDJSON_DIAG_POP
+#endif
+
 ///////////////////////////////////////////////////////////////////////////////
 // StringStream
 
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/stringbuffer.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/stringbuffer.h
index 4e38b82c3..82ad3ca6b 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/stringbuffer.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/stringbuffer.h
@@ -1,6 +1,6 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
 // 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
diff --git a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/writer.h b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/writer.h
index e610ebb60..8b389219a 100644
--- a/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/writer.h
+++ b/Engine/lib/assimp/contrib/rapidjson/include/rapidjson/writer.h
@@ -1,6 +1,6 @@
 // Tencent is pleased to support the open source community by making RapidJSON available.
 // 
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
@@ -16,6 +16,7 @@
 #define RAPIDJSON_WRITER_H_
 
 #include "stream.h"
+#include "internal/clzll.h"
 #include "internal/meta.h"
 #include "internal/stack.h"
 #include "internal/strfunc.h"
@@ -36,16 +37,14 @@
 #include <arm_neon.h>
 #endif
 
-#ifdef _MSC_VER
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
-#endif
-
 #ifdef __clang__
 RAPIDJSON_DIAG_PUSH
 RAPIDJSON_DIAG_OFF(padded)
 RAPIDJSON_DIAG_OFF(unreachable-code)
 RAPIDJSON_DIAG_OFF(c++98-compat)
+#elif defined(_MSC_VER)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
 #endif
 
 RAPIDJSON_NAMESPACE_BEGIN
@@ -228,7 +227,7 @@ public:
       return Key(str.data(), SizeType(str.size()));
     }
 #endif
-	
+
     bool EndObject(SizeType memberCount = 0) {
         (void)memberCount;
         RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level)); // not inside an Object
@@ -284,6 +283,8 @@ public:
         os_->Flush();
     }
 
+    static const size_t kDefaultLevelDepth = 32;
+
 protected:
     //! Information for each nested level
     struct Level {
@@ -292,8 +293,6 @@ protected:
         bool inArray;       //!< true if in array, otherwise in object
     };
 
-    static const size_t kDefaultLevelDepth = 32;
-
     bool WriteNull()  {
         PutReserve(*os_, 4);
         PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'u'); PutUnsafe(*os_, 'l'); PutUnsafe(*os_, 'l'); return true;
@@ -460,9 +459,13 @@ protected:
 
     bool WriteRawValue(const Ch* json, size_t length) {
         PutReserve(*os_, length);
-        for (size_t i = 0; i < length; i++) {
-            RAPIDJSON_ASSERT(json[i] != '\0');
-            PutUnsafe(*os_, json[i]);
+        GenericStringStream<SourceEncoding> is(json);
+        while (RAPIDJSON_LIKELY(is.Tell() < length)) {
+            RAPIDJSON_ASSERT(is.Peek() != '\0');
+            if (RAPIDJSON_UNLIKELY(!(writeFlags & kWriteValidateEncodingFlag ? 
+                Transcoder<SourceEncoding, TargetEncoding>::Validate(is, *os_) :
+                Transcoder<SourceEncoding, TargetEncoding>::TranscodeUnsafe(is, *os_))))
+                return false;
         }
         return true;
     }
@@ -666,19 +669,19 @@ inline bool Writer<StringBuffer>::ScanWriteUnescapedString(StringStream& is, siz
         x = vorrq_u8(x, vcltq_u8(s, s3));
 
         x = vrev64q_u8(x);                     // Rev in 64
-        uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0);   // extract
-        uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1);  // extract
+        uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(x), 0);   // extract
+        uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(x), 1);  // extract
 
         SizeType len = 0;
         bool escaped = false;
         if (low == 0) {
             if (high != 0) {
-                unsigned lz = (unsigned)__builtin_clzll(high);
+                uint32_t lz = internal::clzll(high);
                 len = 8 + (lz >> 3);
                 escaped = true;
             }
         } else {
-            unsigned lz = (unsigned)__builtin_clzll(low);
+            uint32_t lz = internal::clzll(low);
             len = lz >> 3;
             escaped = true;
         }
@@ -700,11 +703,7 @@ inline bool Writer<StringBuffer>::ScanWriteUnescapedString(StringStream& is, siz
 
 RAPIDJSON_NAMESPACE_END
 
-#ifdef _MSC_VER
-RAPIDJSON_DIAG_POP
-#endif
-
-#ifdef __clang__
+#if defined(_MSC_VER) || defined(__clang__)
 RAPIDJSON_DIAG_POP
 #endif
 
diff --git a/Engine/lib/assimp/contrib/stb_image/stb_image.h b/Engine/lib/assimp/contrib/stb/stb_image.h
similarity index 92%
rename from Engine/lib/assimp/contrib/stb_image/stb_image.h
rename to Engine/lib/assimp/contrib/stb/stb_image.h
index 571b0dcea..65a205f6e 100644
--- a/Engine/lib/assimp/contrib/stb_image/stb_image.h
+++ b/Engine/lib/assimp/contrib/stb/stb_image.h
@@ -1,4 +1,4 @@
-/* stb_image - v2.19 - public domain image loader - http://nothings.org/stb
+/* stb_image - v2.26 - public domain image loader - http://nothings.org/stb
                                   no warranty implied; use at your own risk
 
    Do this:
@@ -48,6 +48,13 @@ LICENSE
 
 RECENT REVISION HISTORY:
 
+      2.26  (2020-07-13) many minor fixes
+      2.25  (2020-02-02) fix warnings
+      2.24  (2020-02-02) fix warnings; thread-local failure_reason and flip_vertically
+      2.23  (2019-08-11) fix clang static analysis warning
+      2.22  (2019-03-04) gif fixes, fix warnings
+      2.21  (2019-02-25) fix typo in comment
+      2.20  (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs
       2.19  (2018-02-11) fix warning
       2.18  (2018-01-30) fix warnings
       2.17  (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings
@@ -84,23 +91,33 @@ RECENT REVISION HISTORY:
     Fabian "ryg" Giesen                    Anael Seghezzi (is-16-bit query)
     Arseny Kapoulkine
     John-Mark Allen
+    Carmelo J Fdez-Aguera
 
  Bug & warning fixes
-    Marc LeBlanc            David Woo          Guillaume George   Martins Mozeiko
-    Christpher Lloyd        Jerry Jansson      Joseph Thomson     Phil Jordan
-    Dave Moore              Roy Eltham         Hayaki Saito       Nathan Reed
-    Won Chun                Luke Graham        Johan Duparc       Nick Verigakis
-    the Horde3D community   Thomas Ruf         Ronny Chevalier    github:rlyeh
-    Janez Zemva             John Bartholomew   Michal Cichon      github:romigrou
-    Jonathan Blow           Ken Hamada         Tero Hanninen      github:svdijk
-    Laurent Gomila          Cort Stratton      Sergio Gonzalez    github:snagar
-    Aruelien Pocheville     Thibault Reuille   Cass Everitt       github:Zelex
-    Ryamond Barbiero        Paul Du Bois       Engin Manap        github:grim210
-    Aldo Culquicondor       Philipp Wiesemann  Dale Weiler        github:sammyhw
-    Oriol Ferrer Mesia      Josh Tobin         Matthew Gregan     github:phprus
-    Julian Raschke          Gregory Mullen     Baldur Karlsson    github:poppolopoppo
-    Christian Floisand      Kevin Schmidt                         github:darealshinji
-    Blazej Dariusz Roszkowski                                     github:Michaelangel007
+    Marc LeBlanc            David Woo          Guillaume George     Martins Mozeiko
+    Christpher Lloyd        Jerry Jansson      Joseph Thomson       Blazej Dariusz Roszkowski
+    Phil Jordan                                Dave Moore           Roy Eltham
+    Hayaki Saito            Nathan Reed        Won Chun
+    Luke Graham             Johan Duparc       Nick Verigakis       the Horde3D community
+    Thomas Ruf              Ronny Chevalier                         github:rlyeh
+    Janez Zemva             John Bartholomew   Michal Cichon        github:romigrou
+    Jonathan Blow           Ken Hamada         Tero Hanninen        github:svdijk
+                            Laurent Gomila     Cort Stratton        github:snagar
+    Aruelien Pocheville     Sergio Gonzalez    Thibault Reuille     github:Zelex
+    Cass Everitt            Ryamond Barbiero                        github:grim210
+    Paul Du Bois            Engin Manap        Aldo Culquicondor    github:sammyhw
+    Philipp Wiesemann       Dale Weiler        Oriol Ferrer Mesia   github:phprus
+    Josh Tobin                                 Matthew Gregan       github:poppolopoppo
+    Julian Raschke          Gregory Mullen     Christian Floisand   github:darealshinji
+    Baldur Karlsson         Kevin Schmidt      JR Smith             github:Michaelangel007
+                            Brad Weinberger    Matvey Cherevko      [reserved]
+    Luca Sas                Alexander Veselov  Zack Middleton       [reserved]
+    Ryan C. Gordon          [reserved]                              [reserved]
+                     DO NOT ADD YOUR NAME HERE
+
+  To add your name to the credits, pick a random blank space in the middle and fill it.
+  80% of merge conflicts on stb PRs are due to people adding their name at the end
+  of the credits.
 */
 
 #ifndef STBI_INCLUDE_STB_IMAGE_H
@@ -161,6 +178,16 @@ RECENT REVISION HISTORY:
 //
 // ===========================================================================
 //
+// UNICODE:
+//
+//   If compiling for Windows and you wish to use Unicode filenames, compile
+//   with
+//       #define STBI_WINDOWS_UTF8
+//   and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert
+//   Windows wchar_t filenames to utf8.
+//
+// ===========================================================================
+//
 // Philosophy
 //
 // stb libraries are designed with the following priorities:
@@ -171,12 +198,12 @@ RECENT REVISION HISTORY:
 //
 // Sometimes I let "good performance" creep up in priority over "easy to maintain",
 // and for best performance I may provide less-easy-to-use APIs that give higher
-// performance, in addition to the easy to use ones. Nevertheless, it's important
+// performance, in addition to the easy-to-use ones. Nevertheless, it's important
 // to keep in mind that from the standpoint of you, a client of this library,
 // all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all.
 //
 // Some secondary priorities arise directly from the first two, some of which
-// make more explicit reasons why performance can't be emphasized.
+// provide more explicit reasons why performance can't be emphasized.
 //
 //    - Portable ("ease of use")
 //    - Small source code footprint ("easy to maintain")
@@ -219,11 +246,10 @@ RECENT REVISION HISTORY:
 //
 // HDR image support   (disable by defining STBI_NO_HDR)
 //
-// stb_image now supports loading HDR images in general, and currently
-// the Radiance .HDR file format, although the support is provided
-// generically. You can still load any file through the existing interface;
-// if you attempt to load an HDR file, it will be automatically remapped to
-// LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1;
+// stb_image supports loading HDR images in general, and currently the Radiance
+// .HDR file format specifically. You can still load any file through the existing
+// interface; if you attempt to load an HDR file, it will be automatically remapped
+// to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1;
 // both of these constants can be reconfigured through this interface:
 //
 //     stbi_hdr_to_ldr_gamma(2.2f);
@@ -257,7 +283,7 @@ RECENT REVISION HISTORY:
 //
 // By default we convert iphone-formatted PNGs back to RGB, even though
 // they are internally encoded differently. You can disable this conversion
-// by by calling stbi_convert_iphone_png_to_rgb(0), in which case
+// by calling stbi_convert_iphone_png_to_rgb(0), in which case
 // you will always just get the native iphone "format" through (which
 // is BGR stored in RGB).
 //
@@ -301,7 +327,14 @@ RECENT REVISION HISTORY:
 //   - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still
 //     want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB
 //
-
+//  - If you define STBI_MAX_DIMENSIONS, stb_image will reject images greater
+//    than that size (in either width or height) without further processing.
+//    This is to let programs in the wild set an upper bound to prevent
+//    denial-of-service attacks on untrusted data, as one could generate a
+//    valid image of gigantic dimensions and force stb_image to allocate a
+//    huge block of memory and spend disproportionate time decoding it. By
+//    default this is set to (1 << 24), which is 16777216, but that's still
+//    very big.
 
 #ifndef STBI_NO_STDIO
 #include <stdio.h>
@@ -319,6 +352,7 @@ enum
    STBI_rgb_alpha  = 4
 };
 
+#include <stdlib.h>
 typedef unsigned char stbi_uc;
 typedef unsigned short stbi_us;
 
@@ -326,11 +360,13 @@ typedef unsigned short stbi_us;
 extern "C" {
 #endif
 
+#ifndef STBIDEF
 #ifdef STB_IMAGE_STATIC
 #define STBIDEF static
 #else
 #define STBIDEF extern
 #endif
+#endif
 
 //////////////////////////////////////////////////////////////////////////////
 //
@@ -355,10 +391,6 @@ typedef struct
 
 STBIDEF stbi_uc *stbi_load_from_memory   (stbi_uc           const *buffer, int len   , int *x, int *y, int *channels_in_file, int desired_channels);
 STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk  , void *user, int *x, int *y, int *channels_in_file, int desired_channels);
-#ifndef STBI_NO_GIF
-STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp);
-#endif
-
 
 #ifndef STBI_NO_STDIO
 STBIDEF stbi_uc *stbi_load            (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
@@ -366,6 +398,14 @@ STBIDEF stbi_uc *stbi_load_from_file  (FILE *f, int *x, int *y, int *channels_in
 // for stbi_load_from_file, file pointer is left pointing immediately after image
 #endif
 
+#ifndef STBI_NO_GIF
+STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp);
+#endif
+
+#ifdef STBI_WINDOWS_UTF8
+STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input);
+#endif
+
 ////////////////////////////////////
 //
 // 16-bits-per-channel interface
@@ -413,7 +453,7 @@ STBIDEF int      stbi_is_hdr_from_file(FILE *f);
 
 
 // get a VERY brief reason for failure
-// NOT THREADSAFE
+// on most compilers (and ALL modern mainstream compilers) this is threadsafe
 STBIDEF const char *stbi_failure_reason  (void);
 
 // free the loaded image -- this is just free()
@@ -446,6 +486,11 @@ STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert);
 // flip the image vertically, so the first pixel in the output array is the bottom left
 STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip);
 
+// as above, but only applies to images loaded on the thread that calls the function
+// this function is only available if your compiler supports thread-local variables;
+// calling it will fail to link if your compiler doesn't
+STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip);
+
 // ZLIB client - used by PNG, available for other purposes
 
 STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen);
@@ -525,6 +570,12 @@ STBIDEF int   stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const ch
 #define STBI_ASSERT(x) assert(x)
 #endif
 
+#ifdef __cplusplus
+#define STBI_EXTERN extern "C"
+#else
+#define STBI_EXTERN extern
+#endif
+
 
 #ifndef _MSC_VER
    #ifdef __cplusplus
@@ -536,6 +587,23 @@ STBIDEF int   stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const ch
    #define stbi_inline __forceinline
 #endif
 
+#ifndef STBI_NO_THREAD_LOCALS
+   #if defined(__cplusplus) &&  __cplusplus >= 201103L
+      #define STBI_THREAD_LOCAL       thread_local
+   #elif defined(__GNUC__) && __GNUC__ < 5
+      #define STBI_THREAD_LOCAL       __thread
+   #elif defined(_MSC_VER)
+      #define STBI_THREAD_LOCAL       __declspec(thread)
+   #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__)
+      #define STBI_THREAD_LOCAL       _Thread_local
+   #endif
+
+   #ifndef STBI_THREAD_LOCAL
+      #if defined(__GNUC__)
+        #define STBI_THREAD_LOCAL       __thread
+      #endif
+   #endif
+#endif
 
 #ifdef _MSC_VER
 typedef unsigned short stbi__uint16;
@@ -649,14 +717,18 @@ static int stbi__cpuid3(void)
 
 #define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name
 
+#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
 static int stbi__sse2_available(void)
 {
    int info3 = stbi__cpuid3();
    return ((info3 >> 26) & 1) != 0;
 }
+#endif
+
 #else // assume GCC-style if not VC++
 #define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
 
+#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
 static int stbi__sse2_available(void)
 {
    // If we're even attempting to compile this on GCC/Clang, that means
@@ -664,6 +736,8 @@ static int stbi__sse2_available(void)
    // instructions at will, and so are we.
    return 1;
 }
+#endif
+
 #endif
 #endif
 
@@ -682,6 +756,10 @@ static int stbi__sse2_available(void)
 #define STBI_SIMD_ALIGN(type, name) type name
 #endif
 
+#ifndef STBI_MAX_DIMENSIONS
+#define STBI_MAX_DIMENSIONS (1 << 24)
+#endif
+
 ///////////////////////////////////////////////
 //
 //  stbi__context struct and start_xxx functions
@@ -699,6 +777,7 @@ typedef struct
    int read_from_callbacks;
    int buflen;
    stbi_uc buffer_start[128];
+   int callback_already_read;
 
    stbi_uc *img_buffer, *img_buffer_end;
    stbi_uc *img_buffer_original, *img_buffer_original_end;
@@ -712,6 +791,7 @@ static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len)
 {
    s->io.read = NULL;
    s->read_from_callbacks = 0;
+   s->callback_already_read = 0;
    s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer;
    s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len;
 }
@@ -723,7 +803,8 @@ static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *
    s->io_user_data = user;
    s->buflen = sizeof(s->buffer_start);
    s->read_from_callbacks = 1;
-   s->img_buffer_original = s->buffer_start;
+   s->callback_already_read = 0;
+   s->img_buffer = s->img_buffer_original = s->buffer_start;
    stbi__refill_buffer(s);
    s->img_buffer_original_end = s->img_buffer_end;
 }
@@ -737,12 +818,17 @@ static int stbi__stdio_read(void *user, char *data, int size)
 
 static void stbi__stdio_skip(void *user, int n)
 {
+   int ch;
    fseek((FILE*) user, n, SEEK_CUR);
+   ch = fgetc((FILE*) user);  /* have to read a byte to reset feof()'s flag */
+   if (ch != EOF) {
+      ungetc(ch, (FILE *) user);  /* push byte back onto stream if valid. */
+   }
 }
 
 static int stbi__stdio_eof(void *user)
 {
-   return feof((FILE*) user);
+   return feof((FILE*) user) || ferror((FILE *) user);
 }
 
 static stbi_io_callbacks stbi__stdio_callbacks =
@@ -840,19 +926,24 @@ static void    *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int
 static int      stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp);
 #endif
 
-// this is not threadsafe
-static const char *stbi__g_failure_reason;
+static
+#ifdef STBI_THREAD_LOCAL
+STBI_THREAD_LOCAL
+#endif
+const char *stbi__g_failure_reason;
 
 STBIDEF const char *stbi_failure_reason(void)
 {
    return stbi__g_failure_reason;
 }
 
+#ifndef STBI_NO_FAILURE_STRINGS
 static int stbi__err(const char *str)
 {
    stbi__g_failure_reason = str;
    return 0;
 }
+#endif
 
 static void *stbi__malloc(size_t size)
 {
@@ -891,11 +982,13 @@ static int stbi__mul2sizes_valid(int a, int b)
    return a <= INT_MAX/b;
 }
 
+#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)
 // returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow
 static int stbi__mad2sizes_valid(int a, int b, int add)
 {
    return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add);
 }
+#endif
 
 // returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow
 static int stbi__mad3sizes_valid(int a, int b, int c, int add)
@@ -913,12 +1006,14 @@ static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add)
 }
 #endif
 
+#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)
 // mallocs with size overflow checking
 static void *stbi__malloc_mad2(int a, int b, int add)
 {
    if (!stbi__mad2sizes_valid(a, b, add)) return NULL;
    return stbi__malloc(a*b + add);
 }
+#endif
 
 static void *stbi__malloc_mad3(int a, int b, int c, int add)
 {
@@ -962,13 +1057,29 @@ static float   *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp);
 static stbi_uc *stbi__hdr_to_ldr(float   *data, int x, int y, int comp);
 #endif
 
-static int stbi__vertically_flip_on_load = 0;
+static int stbi__vertically_flip_on_load_global = 0;
 
 STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip)
 {
-    stbi__vertically_flip_on_load = flag_true_if_should_flip;
+   stbi__vertically_flip_on_load_global = flag_true_if_should_flip;
 }
 
+#ifndef STBI_THREAD_LOCAL
+#define stbi__vertically_flip_on_load  stbi__vertically_flip_on_load_global
+#else
+static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set;
+
+STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip)
+{
+   stbi__vertically_flip_on_load_local = flag_true_if_should_flip;
+   stbi__vertically_flip_on_load_set = 1;
+}
+
+#define stbi__vertically_flip_on_load  (stbi__vertically_flip_on_load_set       \
+                                         ? stbi__vertically_flip_on_load_local  \
+                                         : stbi__vertically_flip_on_load_global)
+#endif // STBI_THREAD_LOCAL
+
 static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)
 {
    memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields
@@ -990,6 +1101,8 @@ static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int re
    #endif
    #ifndef STBI_NO_PSD
    if (stbi__psd_test(s))  return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc);
+   #else
+   STBI_NOTUSED(bpc);
    #endif
    #ifndef STBI_NO_PIC
    if (stbi__pic_test(s))  return stbi__pic_load(s,x,y,comp,req_comp, ri);
@@ -1070,6 +1183,7 @@ static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel)
    }
 }
 
+#ifndef STBI_NO_GIF
 static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel)
 {
    int slice;
@@ -1077,10 +1191,11 @@ static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int byt
 
    stbi_uc *bytes = (stbi_uc *)image;
    for (slice = 0; slice < z; ++slice) {
-      stbi__vertical_flip(bytes, w, h, bytes_per_pixel); 
-      bytes += slice_size; 
+      stbi__vertical_flip(bytes, w, h, bytes_per_pixel);
+      bytes += slice_size;
    }
 }
+#endif
 
 static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
 {
@@ -1090,8 +1205,10 @@ static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x,
    if (result == NULL)
       return NULL;
 
+   // it is the responsibility of the loaders to make sure we get either 8 or 16 bit.
+   STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16);
+
    if (ri.bits_per_channel != 8) {
-      STBI_ASSERT(ri.bits_per_channel == 16);
       result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
       ri.bits_per_channel = 8;
    }
@@ -1114,8 +1231,10 @@ static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x,
    if (result == NULL)
       return NULL;
 
+   // it is the responsibility of the loaders to make sure we get either 8 or 16 bit.
+   STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16);
+
    if (ri.bits_per_channel != 16) {
-      STBI_ASSERT(ri.bits_per_channel == 8);
       result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
       ri.bits_per_channel = 16;
    }
@@ -1131,7 +1250,7 @@ static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x,
    return (stbi__uint16 *) result;
 }
 
-#if !defined(STBI_NO_HDR) || !defined(STBI_NO_LINEAR)
+#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR)
 static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp)
 {
    if (stbi__vertically_flip_on_load && result != NULL) {
@@ -1143,10 +1262,38 @@ static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, in
 
 #ifndef STBI_NO_STDIO
 
+#if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8)
+STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide);
+STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default);
+#endif
+
+#if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8)
+STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)
+{
+	return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL);
+}
+#endif
+
 static FILE *stbi__fopen(char const *filename, char const *mode)
 {
    FILE *f;
-#if defined(_MSC_VER) && _MSC_VER >= 1400
+#if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8)
+   wchar_t wMode[64];
+   wchar_t wFilename[1024];
+	if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)))
+      return 0;
+
+	if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)))
+      return 0;
+
+#if _MSC_VER >= 1400
+	if (0 != _wfopen_s(&f, wFilename, wMode))
+		f = 0;
+#else
+   f = _wfopen(wFilename, wMode);
+#endif
+
+#elif defined(_MSC_VER) && _MSC_VER >= 1400
    if (0 != fopen_s(&f, filename, mode))
       f=0;
 #else
@@ -1237,15 +1384,15 @@ STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *u
 STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp)
 {
    unsigned char *result;
-   stbi__context s; 
-   stbi__start_mem(&s,buffer,len); 
-   
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+
    result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp);
    if (stbi__vertically_flip_on_load) {
-      stbi__vertical_flip_slices( result, *x, *y, *z, *comp ); 
+      stbi__vertical_flip_slices( result, *x, *y, *z, *comp );
    }
 
-   return result; 
+   return result;
 }
 #endif
 
@@ -1390,6 +1537,7 @@ enum
 static void stbi__refill_buffer(stbi__context *s)
 {
    int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen);
+   s->callback_already_read += (int) (s->img_buffer - s->img_buffer_original);
    if (n == 0) {
       // at end of file, treat same as if from memory, but need to handle case
       // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file
@@ -1414,6 +1562,9 @@ stbi_inline static stbi_uc stbi__get8(stbi__context *s)
    return 0;
 }
 
+#if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
+// nothing
+#else
 stbi_inline static int stbi__at_eof(stbi__context *s)
 {
    if (s->io.read) {
@@ -1425,9 +1576,14 @@ stbi_inline static int stbi__at_eof(stbi__context *s)
 
    return s->img_buffer >= s->img_buffer_end;
 }
+#endif
 
+#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC)
+// nothing
+#else
 static void stbi__skip(stbi__context *s, int n)
 {
+   if (n == 0) return;  // already there!
    if (n < 0) {
       s->img_buffer = s->img_buffer_end;
       return;
@@ -1442,7 +1598,11 @@ static void stbi__skip(stbi__context *s, int n)
    }
    s->img_buffer += n;
 }
+#endif
 
+#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM)
+// nothing
+#else
 static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)
 {
    if (s->io.read) {
@@ -1466,18 +1626,27 @@ static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)
    } else
       return 0;
 }
+#endif
 
+#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)
+// nothing
+#else
 static int stbi__get16be(stbi__context *s)
 {
    int z = stbi__get8(s);
    return (z << 8) + stbi__get8(s);
 }
+#endif
 
+#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)
+// nothing
+#else
 static stbi__uint32 stbi__get32be(stbi__context *s)
 {
    stbi__uint32 z = stbi__get16be(s);
    return (z << 16) + stbi__get16be(s);
 }
+#endif
 
 #if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF)
 // nothing
@@ -1499,7 +1668,9 @@ static stbi__uint32 stbi__get32le(stbi__context *s)
 
 #define STBI__BYTECAST(x)  ((stbi_uc) ((x) & 255))  // truncate int to byte without warnings
 
-
+#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
+// nothing
+#else
 //////////////////////////////////////////////////////////////////////////////
 //
 //  generic converter from built-in img_n to req_comp
@@ -1515,7 +1686,11 @@ static stbi_uc stbi__compute_y(int r, int g, int b)
 {
    return (stbi_uc) (((r*77) + (g*150) +  (29*b)) >> 8);
 }
+#endif
 
+#if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
+// nothing
+#else
 static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y)
 {
    int i,j;
@@ -1539,19 +1714,19 @@ static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int r
       // convert source image with img_n components to one with req_comp components;
       // avoid switch per pixel, so use switch per scanline and massive macros
       switch (STBI__COMBO(img_n, req_comp)) {
-         STBI__CASE(1,2) { dest[0]=src[0], dest[1]=255;                                     } break;
+         STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255;                                     } break;
          STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0];                                  } break;
-         STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=255;                     } break;
+         STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255;                     } break;
          STBI__CASE(2,1) { dest[0]=src[0];                                                  } break;
          STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0];                                  } break;
-         STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1];                  } break;
-         STBI__CASE(3,4) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=255;        } break;
+         STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1];                  } break;
+         STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255;        } break;
          STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]);                   } break;
-         STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]), dest[1] = 255;    } break;
+         STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255;    } break;
          STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]);                   } break;
-         STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]), dest[1] = src[3]; } break;
-         STBI__CASE(4,3) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2];                    } break;
-         default: STBI_ASSERT(0);
+         STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break;
+         STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];                    } break;
+         default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return stbi__errpuc("unsupported", "Unsupported format conversion");
       }
       #undef STBI__CASE
    }
@@ -1559,12 +1734,20 @@ static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int r
    STBI_FREE(data);
    return good;
 }
+#endif
 
+#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)
+// nothing
+#else
 static stbi__uint16 stbi__compute_y_16(int r, int g, int b)
 {
    return (stbi__uint16) (((r*77) + (g*150) +  (29*b)) >> 8);
 }
+#endif
 
+#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)
+// nothing
+#else
 static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y)
 {
    int i,j;
@@ -1588,19 +1771,19 @@ static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int r
       // convert source image with img_n components to one with req_comp components;
       // avoid switch per pixel, so use switch per scanline and massive macros
       switch (STBI__COMBO(img_n, req_comp)) {
-         STBI__CASE(1,2) { dest[0]=src[0], dest[1]=0xffff;                                     } break;
+         STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff;                                     } break;
          STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0];                                     } break;
-         STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=0xffff;                     } break;
+         STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff;                     } break;
          STBI__CASE(2,1) { dest[0]=src[0];                                                     } break;
          STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0];                                     } break;
-         STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1];                     } break;
-         STBI__CASE(3,4) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=0xffff;        } break;
+         STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1];                     } break;
+         STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff;        } break;
          STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]);                   } break;
-         STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]), dest[1] = 0xffff; } break;
+         STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break;
          STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]);                   } break;
-         STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]), dest[1] = src[3]; } break;
-         STBI__CASE(4,3) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2];                       } break;
-         default: STBI_ASSERT(0);
+         STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break;
+         STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];                       } break;
+         default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return (stbi__uint16*) stbi__errpuc("unsupported", "Unsupported format conversion");
       }
       #undef STBI__CASE
    }
@@ -1608,6 +1791,7 @@ static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int r
    STBI_FREE(data);
    return good;
 }
+#endif
 
 #ifndef STBI_NO_LINEAR
 static float   *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
@@ -1623,7 +1807,11 @@ static float   *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
       for (k=0; k < n; ++k) {
          output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale);
       }
-      if (k < comp) output[i*comp + k] = data[i*comp+k]/255.0f;
+   }
+   if (n < comp) {
+      for (i=0; i < x*y; ++i) {
+         output[i*comp + n] = data[i*comp + n]/255.0f;
+      }
    }
    STBI_FREE(data);
    return output;
@@ -1904,7 +2092,7 @@ stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)
 
    sgn = (stbi__int32)j->code_buffer >> 31; // sign bit is always in MSB
    k = stbi_lrot(j->code_buffer, n);
-   STBI_ASSERT(n >= 0 && n < (int) (sizeof(stbi__bmask)/sizeof(*stbi__bmask)));
+   if (n < 0 || n >= (int) (sizeof(stbi__bmask)/sizeof(*stbi__bmask))) return 0;
    j->code_buffer = k & ~stbi__bmask[n];
    k &= stbi__bmask[n];
    j->code_bits -= n;
@@ -2015,6 +2203,7 @@ static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__
       // first scan for DC coefficient, must be first
       memset(data,0,64*sizeof(data[0])); // 0 all the ac values now
       t = stbi__jpeg_huff_decode(j, hdc);
+      if (t == -1) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
       diff = t ? stbi__extend_receive(j, t) : 0;
 
       dc = j->img_comp[b].dc_pred + diff;
@@ -3005,6 +3194,8 @@ static int stbi__process_frame_header(stbi__jpeg *z, int scan)
    p  = stbi__get8(s);            if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline
    s->img_y = stbi__get16be(s);   if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG
    s->img_x = stbi__get16be(s);   if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires
+   if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
+   if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
    c = stbi__get8(s);
    if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG");
    s->img_n = c;
@@ -3596,7 +3787,7 @@ static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp
       int k;
       unsigned int i,j;
       stbi_uc *output;
-      stbi_uc *coutput[4];
+      stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL };
 
       stbi__resample res_comp[4];
 
@@ -3717,7 +3908,7 @@ static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp
                if (n == 1)
                   for (i=0; i < z->s->img_x; ++i) out[i] = y[i];
                else
-                  for (i=0; i < z->s->img_x; ++i) *out++ = y[i], *out++ = 255;
+                  for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; }
             }
          }
       }
@@ -3885,16 +4076,23 @@ typedef struct
    stbi__zhuffman z_length, z_distance;
 } stbi__zbuf;
 
+stbi_inline static int stbi__zeof(stbi__zbuf *z)
+{
+   return (z->zbuffer >= z->zbuffer_end);
+}
+
 stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z)
 {
-   if (z->zbuffer >= z->zbuffer_end) return 0;
-   return *z->zbuffer++;
+   return stbi__zeof(z) ? 0 : *z->zbuffer++;
 }
 
 static void stbi__fill_bits(stbi__zbuf *z)
 {
    do {
-      STBI_ASSERT(z->code_buffer < (1U << z->num_bits));
+      if (z->code_buffer >= (1U << z->num_bits)) {
+        z->zbuffer = z->zbuffer_end;  /* treat this as EOF so we fail. */
+        return;
+      }
       z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits;
       z->num_bits += 8;
    } while (z->num_bits <= 24);
@@ -3919,10 +4117,11 @@ static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z)
    for (s=STBI__ZFAST_BITS+1; ; ++s)
       if (k < z->maxcode[s])
          break;
-   if (s == 16) return -1; // invalid code!
+   if (s >= 16) return -1; // invalid code!
    // code size is s, so:
    b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s];
-   STBI_ASSERT(z->size[b] == s);
+   if ((unsigned int)b >= sizeof (z->size)) return -1; // some data was corrupt somewhere!
+   if (z->size[b] != s) return -1;  // was originally an assert, but report failure instead.
    a->code_buffer >>= s;
    a->num_bits -= s;
    return z->value[b];
@@ -3931,7 +4130,12 @@ static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z)
 stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)
 {
    int b,s;
-   if (a->num_bits < 16) stbi__fill_bits(a);
+   if (a->num_bits < 16) {
+      if (stbi__zeof(a)) {
+         return -1;   /* report error for unexpected end of data. */
+      }
+      stbi__fill_bits(a);
+   }
    b = z->fast[a->code_buffer & STBI__ZFAST_MASK];
    if (b) {
       s = b >> 9;
@@ -3945,13 +4149,16 @@ stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)
 static int stbi__zexpand(stbi__zbuf *z, char *zout, int n)  // need to make room for n bytes
 {
    char *q;
-   int cur, limit, old_limit;
+   unsigned int cur, limit, old_limit;
    z->zout = zout;
    if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG");
-   cur   = (int) (z->zout     - z->zout_start);
-   limit = old_limit = (int) (z->zout_end - z->zout_start);
-   while (cur + n > limit)
+   cur   = (unsigned int) (z->zout - z->zout_start);
+   limit = old_limit = (unsigned) (z->zout_end - z->zout_start);
+   if (UINT_MAX - cur < (unsigned) n) return stbi__err("outofmem", "Out of memory");
+   while (cur + n > limit) {
+      if(limit > UINT_MAX / 2) return stbi__err("outofmem", "Out of memory");
       limit *= 2;
+   }
    q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit);
    STBI_NOTUSED(old_limit);
    if (q == NULL) return stbi__err("outofmem", "Out of memory");
@@ -4049,11 +4256,12 @@ static int stbi__compute_huffman_codes(stbi__zbuf *a)
             c = stbi__zreceive(a,2)+3;
             if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG");
             fill = lencodes[n-1];
-         } else if (c == 17)
+         } else if (c == 17) {
             c = stbi__zreceive(a,3)+3;
-         else {
-            STBI_ASSERT(c == 18);
+         } else if (c == 18) {
             c = stbi__zreceive(a,7)+11;
+         } else {
+            return stbi__err("bad codelengths", "Corrupt PNG");
          }
          if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG");
          memset(lencodes+n, fill, c);
@@ -4079,7 +4287,7 @@ static int stbi__parse_uncompressed_block(stbi__zbuf *a)
       a->code_buffer >>= 8;
       a->num_bits -= 8;
    }
-   STBI_ASSERT(a->num_bits == 0);
+   if (a->num_bits < 0) return stbi__err("zlib corrupt","Corrupt PNG");
    // now fill header the normal way
    while (k < 4)
       header[k++] = stbi__zget8(a);
@@ -4101,6 +4309,7 @@ static int stbi__parse_zlib_header(stbi__zbuf *a)
    int cm    = cmf & 15;
    /* int cinfo = cmf >> 4; */
    int flg   = stbi__zget8(a);
+   if (stbi__zeof(a)) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec
    if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec
    if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png
    if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png
@@ -4362,7 +4571,7 @@ static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 r
          return stbi__err("invalid filter","Corrupt PNG");
 
       if (depth < 8) {
-         STBI_ASSERT(img_width_bytes <= x);
+         if (img_width_bytes > x) return stbi__err("invalid width","Corrupt PNG");
          cur += x*out_n - img_width_bytes; // store output to the rightmost img_len bytes, so we can decode in place
          filter_bytes = 1;
          width = img_width_bytes;
@@ -4731,7 +4940,7 @@ static void stbi__de_iphone(stbi__png *z)
 static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)
 {
    stbi_uc palette[1024], pal_img_n=0;
-   stbi_uc has_trans=0, tc[3];
+   stbi_uc has_trans=0, tc[3]={0};
    stbi__uint16 tc16[3];
    stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0;
    int first=1,k,interlace=0, color=0, is_iphone=0;
@@ -4757,8 +4966,10 @@ static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)
             if (!first) return stbi__err("multiple IHDR","Corrupt PNG");
             first = 0;
             if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG");
-            s->img_x = stbi__get32be(s); if (s->img_x > (1 << 24)) return stbi__err("too large","Very large image (corrupt?)");
-            s->img_y = stbi__get32be(s); if (s->img_y > (1 << 24)) return stbi__err("too large","Very large image (corrupt?)");
+            s->img_x = stbi__get32be(s);
+            s->img_y = stbi__get32be(s);
+            if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
+            if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
             z->depth = stbi__get8(s);  if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16)  return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only");
             color = stbi__get8(s);  if (color > 6)         return stbi__err("bad ctype","Corrupt PNG");
             if (color == 3 && z->depth == 16)                  return stbi__err("bad ctype","Corrupt PNG");
@@ -4875,6 +5086,8 @@ static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)
                ++s->img_n;
             }
             STBI_FREE(z->expanded); z->expanded = NULL;
+            // end of PNG chunk, read and skip CRC
+            stbi__get32be(s);
             return 1;
          }
 
@@ -4905,10 +5118,12 @@ static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, st
    void *result=NULL;
    if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
    if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) {
-      if (p->depth < 8)
+      if (p->depth <= 8)
          ri->bits_per_channel = 8;
+      else if (p->depth == 16)
+         ri->bits_per_channel = 16;
       else
-         ri->bits_per_channel = p->depth;
+         return stbi__errpuc("bad bits_per_channel", "PNG not supported: unsupported color depth");
       result = p->out;
       p->out = NULL;
       if (req_comp && req_comp != p->s->img_out_n) {
@@ -5009,11 +5224,11 @@ static int stbi__high_bit(unsigned int z)
 {
    int n=0;
    if (z == 0) return -1;
-   if (z >= 0x10000) n += 16, z >>= 16;
-   if (z >= 0x00100) n +=  8, z >>=  8;
-   if (z >= 0x00010) n +=  4, z >>=  4;
-   if (z >= 0x00004) n +=  2, z >>=  2;
-   if (z >= 0x00002) n +=  1, z >>=  1;
+   if (z >= 0x10000) { n += 16; z >>= 16; }
+   if (z >= 0x00100) { n +=  8; z >>=  8; }
+   if (z >= 0x00010) { n +=  4; z >>=  4; }
+   if (z >= 0x00004) { n +=  2; z >>=  2; }
+   if (z >= 0x00002) { n +=  1;/* >>=  1;*/ }
    return n;
 }
 
@@ -5030,7 +5245,7 @@ static int stbi__bitcount(unsigned int a)
 // extract an arbitrarily-aligned N-bit value (N=bits)
 // from v, and then make it 8-bits long and fractionally
 // extend it to full full range.
-static int stbi__shiftsigned(int v, int shift, int bits)
+static int stbi__shiftsigned(unsigned int v, int shift, int bits)
 {
    static unsigned int mul_table[9] = {
       0,
@@ -5044,7 +5259,7 @@ static int stbi__shiftsigned(int v, int shift, int bits)
       v <<= -shift;
    else
       v >>= shift;
-   STBI_ASSERT(v >= 0 && v < 256);
+   STBI_ASSERT(v < 256);
    v >>= (8-bits);
    STBI_ASSERT(bits >= 0 && bits <= 8);
    return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits];
@@ -5054,6 +5269,7 @@ typedef struct
 {
    int bpp, offset, hsz;
    unsigned int mr,mg,mb,ma, all_a;
+   int extra_read;
 } stbi__bmp_data;
 
 static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info)
@@ -5066,6 +5282,9 @@ static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info)
    info->offset = stbi__get32le(s);
    info->hsz = hsz = stbi__get32le(s);
    info->mr = info->mg = info->mb = info->ma = 0;
+   info->extra_read = 14;
+
+   if (info->offset < 0) return stbi__errpuc("bad BMP", "bad BMP");
 
    if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown");
    if (hsz == 12) {
@@ -5109,6 +5328,7 @@ static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info)
                info->mr = stbi__get32le(s);
                info->mg = stbi__get32le(s);
                info->mb = stbi__get32le(s);
+               info->extra_read += 12;
                // not documented, but generated by photoshop and handled by mspaint
                if (info->mr == info->mg && info->mg == info->mb) {
                   // ?!?!?
@@ -5157,6 +5377,9 @@ static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req
    flip_vertically = ((int) s->img_y) > 0;
    s->img_y = abs((int) s->img_y);
 
+   if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+   if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+
    mr = info.mr;
    mg = info.mg;
    mb = info.mb;
@@ -5165,13 +5388,22 @@ static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req
 
    if (info.hsz == 12) {
       if (info.bpp < 24)
-         psize = (info.offset - 14 - 24) / 3;
+         psize = (info.offset - info.extra_read - 24) / 3;
    } else {
       if (info.bpp < 16)
-         psize = (info.offset - 14 - info.hsz) >> 2;
+         psize = (info.offset - info.extra_read - info.hsz) >> 2;
+   }
+   if (psize == 0) {
+      STBI_ASSERT(info.offset == s->callback_already_read + (int) (s->img_buffer - s->img_buffer_original));
+      if (info.offset != s->callback_already_read + (s->img_buffer - s->buffer_start)) {
+        return stbi__errpuc("bad offset", "Corrupt BMP");
+      }
    }
 
-   s->img_n = ma ? 4 : 3;
+   if (info.bpp == 24 && ma == 0xff000000)
+      s->img_n = 3;
+   else
+      s->img_n = ma ? 4 : 3;
    if (req_comp && req_comp >= 3) // we can directly decode 3 or 4
       target = req_comp;
    else
@@ -5193,7 +5425,7 @@ static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req
          if (info.hsz != 12) stbi__get8(s);
          pal[i][3] = 255;
       }
-      stbi__skip(s, info.offset - 14 - info.hsz - psize * (info.hsz == 12 ? 3 : 4));
+      stbi__skip(s, info.offset - info.extra_read - info.hsz - psize * (info.hsz == 12 ? 3 : 4));
       if (info.bpp == 1) width = (s->img_x + 7) >> 3;
       else if (info.bpp == 4) width = (s->img_x + 1) >> 1;
       else if (info.bpp == 8) width = s->img_x;
@@ -5207,6 +5439,8 @@ static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req
                out[z++] = pal[color][0];
                out[z++] = pal[color][1];
                out[z++] = pal[color][2];
+               if (target == 4) out[z++] = 255;
+               if (i+1 == (int) s->img_x) break;
                if((--bit_offset) < 0) {
                   bit_offset = 7;
                   v = stbi__get8(s);
@@ -5240,7 +5474,7 @@ static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req
       int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0;
       int z = 0;
       int easy=0;
-      stbi__skip(s, info.offset - 14 - info.hsz);
+      stbi__skip(s, info.offset - info.extra_read - info.hsz);
       if (info.bpp == 24) width = 3 * s->img_x;
       else if (info.bpp == 16) width = 2*s->img_x;
       else /* bpp = 32 and pad = 0 */ width=0;
@@ -5258,6 +5492,7 @@ static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req
          gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg);
          bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb);
          ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma);
+         if (rcount > 8 || gcount > 8 || bcount > 8 || acount > 8) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); }
       }
       for (j=0; j < (int) s->img_y; ++j) {
          if (easy) {
@@ -5299,7 +5534,7 @@ static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req
          stbi_uc *p1 = out +      j     *s->img_x*target;
          stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target;
          for (i=0; i < (int) s->img_x*target; ++i) {
-            t = p1[i], p1[i] = p2[i], p2[i] = t;
+            t = p1[i]; p1[i] = p2[i]; p2[i] = t;
          }
       }
    }
@@ -5479,6 +5714,11 @@ static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req
    int RLE_repeating = 0;
    int read_next_pixel = 1;
    STBI_NOTUSED(ri);
+   STBI_NOTUSED(tga_x_origin); // @TODO
+   STBI_NOTUSED(tga_y_origin); // @TODO
+
+   if (tga_height > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+   if (tga_width > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
 
    //   do a tiny bit of precessing
    if ( tga_image_type >= 8 )
@@ -5519,6 +5759,11 @@ static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req
       //   do I need to load a palette?
       if ( tga_indexed)
       {
+         if (tga_palette_len == 0) {  /* you have to have at least one entry! */
+            STBI_FREE(tga_data);
+            return stbi__errpuc("bad palette", "Corrupt TGA");
+         }
+
          //   any data to skip? (offset usually = 0)
          stbi__skip(s, tga_palette_start );
          //   load the palette
@@ -5642,6 +5887,7 @@ static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req
    //   Microsoft's C compilers happy... [8^(
    tga_palette_start = tga_palette_len = tga_palette_bits =
          tga_x_origin = tga_y_origin = 0;
+   STBI_NOTUSED(tga_palette_start);
    //   OK, done
    return tga_data;
 }
@@ -5726,6 +5972,9 @@ static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req
    h = stbi__get32be(s);
    w = stbi__get32be(s);
 
+   if (h > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+   if (w > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+
    // Make sure the depth is 8 bits.
    bitdepth = stbi__get16be(s);
    if (bitdepth != 8 && bitdepth != 16)
@@ -5789,7 +6038,7 @@ static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req
       //     Else if n is 128, noop.
       // Endloop
 
-      // The RLE-compressed data is preceeded by a 2-byte data count for each row in the data,
+      // The RLE-compressed data is preceded by a 2-byte data count for each row in the data,
       // which we're going to just skip.
       stbi__skip(s, h * channelCount * 2 );
 
@@ -6080,6 +6329,10 @@ static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_c
 
    x = stbi__get16be(s);
    y = stbi__get16be(s);
+
+   if (y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+   if (x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+
    if (stbi__at_eof(s))  return stbi__errpuc("bad file","file too short (pic header)");
    if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode");
 
@@ -6127,7 +6380,7 @@ typedef struct
    int w,h;
    stbi_uc *out;                 // output buffer (always 4 components)
    stbi_uc *background;          // The current "background" as far as a gif is concerned
-   stbi_uc *history; 
+   stbi_uc *history;
    int flags, bgindex, ratio, transparent, eflags;
    stbi_uc  pal[256][4];
    stbi_uc lpal[256][4];
@@ -6188,6 +6441,9 @@ static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_in
    g->ratio = stbi__get8(s);
    g->transparent = -1;
 
+   if (g->w > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
+   if (g->h > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
+
    if (comp != 0) *comp = 4;  // can't actually tell whether it's 3 or 4 until we parse the comments
 
    if (is_info) return 1;
@@ -6215,7 +6471,7 @@ static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp)
 static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)
 {
    stbi_uc *p, *c;
-   int idx; 
+   int idx;
 
    // recurse to decode the prefixes, since the linked-list is backwards,
    // and working backwards through an interleaved image would be nasty
@@ -6224,12 +6480,12 @@ static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)
 
    if (g->cur_y >= g->max_y) return;
 
-   idx = g->cur_x + g->cur_y; 
+   idx = g->cur_x + g->cur_y;
    p = &g->out[idx];
-   g->history[idx / 4] = 1;  
+   g->history[idx / 4] = 1;
 
    c = &g->color_table[g->codes[code].suffix * 4];
-   if (c[3] > 128) { // don't render transparent pixels; 
+   if (c[3] > 128) { // don't render transparent pixels;
       p[0] = c[2];
       p[1] = c[1];
       p[2] = c[0];
@@ -6338,31 +6594,36 @@ static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g)
 // two back is the image from two frames ago, used for a very specific disposal format
 static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back)
 {
-   int dispose; 
-   int first_frame; 
-   int pi; 
-   int pcount; 
+   int dispose;
+   int first_frame;
+   int pi;
+   int pcount;
+   STBI_NOTUSED(req_comp);
 
    // on first frame, any non-written pixels get the background colour (non-transparent)
-   first_frame = 0; 
+   first_frame = 0;
    if (g->out == 0) {
-      if (!stbi__gif_header(s, g, comp,0))     return 0; // stbi__g_failure_reason set by stbi__gif_header
-      g->out = (stbi_uc *) stbi__malloc(4 * g->w * g->h);
-      g->background = (stbi_uc *) stbi__malloc(4 * g->w * g->h); 
-      g->history = (stbi_uc *) stbi__malloc(g->w * g->h); 
-      if (g->out == 0)                      return stbi__errpuc("outofmem", "Out of memory");
+      if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header
+      if (!stbi__mad3sizes_valid(4, g->w, g->h, 0))
+         return stbi__errpuc("too large", "GIF image is too large");
+      pcount = g->w * g->h;
+      g->out = (stbi_uc *) stbi__malloc(4 * pcount);
+      g->background = (stbi_uc *) stbi__malloc(4 * pcount);
+      g->history = (stbi_uc *) stbi__malloc(pcount);
+      if (!g->out || !g->background || !g->history)
+         return stbi__errpuc("outofmem", "Out of memory");
 
-      // image is treated as "tranparent" at the start - ie, nothing overwrites the current background; 
+      // image is treated as "transparent" at the start - ie, nothing overwrites the current background;
       // background colour is only used for pixels that are not rendered first frame, after that "background"
-      // color refers to teh color that was there the previous frame. 
-      memset( g->out, 0x00, 4 * g->w * g->h ); 
-      memset( g->background, 0x00, 4 * g->w * g->h ); // state of the background (starts transparent)
-      memset( g->history, 0x00, g->w * g->h );        // pixels that were affected previous frame
-      first_frame = 1; 
+      // color refers to the color that was there the previous frame.
+      memset(g->out, 0x00, 4 * pcount);
+      memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent)
+      memset(g->history, 0x00, pcount);        // pixels that were affected previous frame
+      first_frame = 1;
    } else {
-      // second frame - how do we dispoase of the previous one?
-      dispose = (g->eflags & 0x1C) >> 2; 
-      pcount = g->w * g->h; 
+      // second frame - how do we dispose of the previous one?
+      dispose = (g->eflags & 0x1C) >> 2;
+      pcount = g->w * g->h;
 
       if ((dispose == 3) && (two_back == 0)) {
          dispose = 2; // if I don't have an image to revert back to, default to the old background
@@ -6371,32 +6632,32 @@ static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, i
       if (dispose == 3) { // use previous graphic
          for (pi = 0; pi < pcount; ++pi) {
             if (g->history[pi]) {
-               memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 ); 
+               memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 );
             }
          }
-      } else if (dispose == 2) { 
-         // restore what was changed last frame to background before that frame; 
+      } else if (dispose == 2) {
+         // restore what was changed last frame to background before that frame;
          for (pi = 0; pi < pcount; ++pi) {
             if (g->history[pi]) {
-               memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 ); 
+               memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 );
             }
          }
       } else {
-         // This is a non-disposal case eithe way, so just 
+         // This is a non-disposal case eithe way, so just
          // leave the pixels as is, and they will become the new background
          // 1: do not dispose
          // 0:  not specified.
       }
 
-      // background is what out is after the undoing of the previou frame; 
-      memcpy( g->background, g->out, 4 * g->w * g->h ); 
+      // background is what out is after the undoing of the previou frame;
+      memcpy( g->background, g->out, 4 * g->w * g->h );
    }
 
-   // clear my history; 
+   // clear my history;
    memset( g->history, 0x00, g->w * g->h );        // pixels that were affected previous frame
 
    for (;;) {
-      int tag = stbi__get8(s); 
+      int tag = stbi__get8(s);
       switch (tag) {
          case 0x2C: /* Image Descriptor */
          {
@@ -6418,6 +6679,13 @@ static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, i
             g->cur_x   = g->start_x;
             g->cur_y   = g->start_y;
 
+            // if the width of the specified rectangle is 0, that means
+            // we may not see *any* pixels or the image is malformed;
+            // to make sure this is caught, move the current y down to
+            // max_y (which is what out_gif_code checks).
+            if (w == 0)
+               g->cur_y = g->max_y;
+
             g->lflags = stbi__get8(s);
 
             if (g->lflags & 0x40) {
@@ -6434,19 +6702,19 @@ static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, i
             } else if (g->flags & 0x80) {
                g->color_table = (stbi_uc *) g->pal;
             } else
-               return stbi__errpuc("missing color table", "Corrupt GIF");            
-            
-            o = stbi__process_gif_raster(s, g);
-            if (o == NULL) return NULL;
+               return stbi__errpuc("missing color table", "Corrupt GIF");
 
-            // if this was the first frame, 
-            pcount = g->w * g->h; 
+            o = stbi__process_gif_raster(s, g);
+            if (!o) return NULL;
+
+            // if this was the first frame,
+            pcount = g->w * g->h;
             if (first_frame && (g->bgindex > 0)) {
                // if first frame, any pixel not drawn to gets the background color
                for (pi = 0; pi < pcount; ++pi) {
                   if (g->history[pi] == 0) {
-                     g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be; 
-                     memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 ); 
+                     g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be;
+                     memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 );
                   }
                }
             }
@@ -6457,7 +6725,7 @@ static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, i
          case 0x21: // Comment Extension.
          {
             int len;
-            int ext = stbi__get8(s); 
+            int ext = stbi__get8(s);
             if (ext == 0xF9) { // Graphic Control Extension.
                len = stbi__get8(s);
                if (len == 4) {
@@ -6466,23 +6734,23 @@ static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, i
 
                   // unset old transparent
                   if (g->transparent >= 0) {
-                     g->pal[g->transparent][3] = 255; 
-                  } 
+                     g->pal[g->transparent][3] = 255;
+                  }
                   if (g->eflags & 0x01) {
                      g->transparent = stbi__get8(s);
                      if (g->transparent >= 0) {
-                        g->pal[g->transparent][3] = 0; 
+                        g->pal[g->transparent][3] = 0;
                      }
                   } else {
                      // don't need transparent
-                     stbi__skip(s, 1); 
-                     g->transparent = -1; 
+                     stbi__skip(s, 1);
+                     g->transparent = -1;
                   }
                } else {
                   stbi__skip(s, len);
                   break;
                }
-            } 
+            }
             while ((len = stbi__get8(s)) != 0) {
                stbi__skip(s, len);
             }
@@ -6501,15 +6769,15 @@ static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, i
 static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp)
 {
    if (stbi__gif_test(s)) {
-      int layers = 0; 
+      int layers = 0;
       stbi_uc *u = 0;
       stbi_uc *out = 0;
-      stbi_uc *two_back = 0; 
+      stbi_uc *two_back = 0;
       stbi__gif g;
-      int stride; 
+      int stride;
       memset(&g, 0, sizeof(g));
       if (delays) {
-         *delays = 0; 
+         *delays = 0;
       }
 
       do {
@@ -6519,44 +6787,54 @@ static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y,
          if (u) {
             *x = g.w;
             *y = g.h;
-            ++layers; 
-            stride = g.w * g.h * 4; 
-         
+            ++layers;
+            stride = g.w * g.h * 4;
+
             if (out) {
-               out = (stbi_uc*) STBI_REALLOC( out, layers * stride ); 
+               void *tmp = (stbi_uc*) STBI_REALLOC( out, layers * stride );
+               if (NULL == tmp) {
+                  STBI_FREE(g.out);
+                  STBI_FREE(g.history);
+                  STBI_FREE(g.background);
+                  return stbi__errpuc("outofmem", "Out of memory");
+               }
+               else {
+                   out = (stbi_uc*) tmp;
+               }
+
                if (delays) {
-                  *delays = (int*) STBI_REALLOC( *delays, sizeof(int) * layers ); 
+                  *delays = (int*) STBI_REALLOC( *delays, sizeof(int) * layers );
                }
             } else {
-               out = (stbi_uc*)stbi__malloc( layers * stride ); 
+               out = (stbi_uc*)stbi__malloc( layers * stride );
                if (delays) {
-                  *delays = (int*) stbi__malloc( layers * sizeof(int) ); 
+                  *delays = (int*) stbi__malloc( layers * sizeof(int) );
                }
             }
-            memcpy( out + ((layers - 1) * stride), u, stride ); 
+            memcpy( out + ((layers - 1) * stride), u, stride );
             if (layers >= 2) {
-               two_back = out - 2 * stride; 
+               two_back = out - 2 * stride;
             }
 
             if (delays) {
-               (*delays)[layers - 1U] = g.delay; 
+               (*delays)[layers - 1U] = g.delay;
             }
          }
-      } while (u != 0); 
+      } while (u != 0);
 
-      // free temp buffer; 
-      STBI_FREE(g.out); 
-      STBI_FREE(g.history); 
-      STBI_FREE(g.background); 
+      // free temp buffer;
+      STBI_FREE(g.out);
+      STBI_FREE(g.history);
+      STBI_FREE(g.background);
 
-      // do the final conversion after loading everything; 
+      // do the final conversion after loading everything;
       if (req_comp && req_comp != 4)
          out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h);
 
-      *z = layers; 
+      *z = layers;
       return out;
    } else {
-      return stbi__errpuc("not GIF", "Image was not as a gif type."); 
+      return stbi__errpuc("not GIF", "Image was not as a gif type.");
    }
 }
 
@@ -6565,6 +6843,7 @@ static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req
    stbi_uc *u = 0;
    stbi__gif g;
    memset(&g, 0, sizeof(g));
+   STBI_NOTUSED(ri);
 
    u = stbi__gif_load_next(s, &g, comp, req_comp, 0);
    if (u == (stbi_uc *) s) u = 0;  // end of animated gif marker
@@ -6573,14 +6852,17 @@ static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req
       *y = g.h;
 
       // moved conversion to after successful load so that the same
-      // can be done for multiple frames. 
+      // can be done for multiple frames.
       if (req_comp && req_comp != 4)
          u = stbi__convert_format(u, 4, req_comp, g.w, g.h);
+   } else if (g.out) {
+      // if there was an error and we allocated an image buffer, free it!
+      STBI_FREE(g.out);
    }
 
-   // free buffers needed for multiple frame loading; 
+   // free buffers needed for multiple frame loading;
    STBI_FREE(g.history);
-   STBI_FREE(g.background); 
+   STBI_FREE(g.background);
 
    return u;
 }
@@ -6705,6 +6987,9 @@ static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int re
    token += 3;
    width = (int) strtol(token, NULL, 10);
 
+   if (height > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)");
+   if (width > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)");
+
    *x = width;
    *y = height;
 
@@ -6852,7 +7137,12 @@ static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp)
       return 0;
    if (x) *x = s->img_x;
    if (y) *y = s->img_y;
-   if (comp) *comp = info.ma ? 4 : 3;
+   if (comp) {
+      if (info.bpp == 24 && info.ma == 0xff000000)
+         *comp = 3;
+      else
+         *comp = info.ma ? 4 : 3;
+   }
    return 1;
 }
 #endif
@@ -7014,6 +7304,9 @@ static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req
    if (!stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n))
       return 0;
 
+   if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+   if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+
    *x = s->img_x;
    *y = s->img_y;
    if (comp) *comp = s->img_n;
@@ -7238,6 +7531,7 @@ STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user
 
 /*
    revision history:
+      2.20  (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs
       2.19  (2018-02-11) fix warning
       2.18  (2018-01-30) fix warnings
       2.17  (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug
@@ -7459,4 +7753,4 @@ AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ------------------------------------------------------------------------------
-*/
\ No newline at end of file
+*/
diff --git a/Engine/lib/assimp/contrib/unzip/crypt.c b/Engine/lib/assimp/contrib/unzip/crypt.c
new file mode 100644
index 000000000..299ce03d2
--- /dev/null
+++ b/Engine/lib/assimp/contrib/unzip/crypt.c
@@ -0,0 +1,171 @@
+/* crypt.c -- base code for traditional PKWARE encryption
+   Version 1.01e, February 12th, 2005
+
+   Copyright (C) 1998-2005 Gilles Vollant
+   Modifications for Info-ZIP crypting
+     Copyright (C) 2003 Terry Thorsen
+
+   This code is a modified version of crypting code in Info-ZIP distribution
+
+   Copyright (C) 1990-2000 Info-ZIP.  All rights reserved.
+
+   This program is distributed under the terms of the same license as zlib.
+   See the accompanying LICENSE file for the full text of the license.
+
+   This encryption code is a direct transcription of the algorithm from
+   Roger Schlafly, described by Phil Katz in the file appnote.txt. This
+   file (appnote.txt) is distributed with the PKZIP program (even in the
+   version without encryption capabilities).
+
+   If you don't need crypting in your application, just define symbols
+   NOCRYPT and NOUNCRYPT.
+*/
+
+#if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && !defined(__CYGWIN__)
+    #define MICROSOFT_WINDOWS_WINBASE_H_DEFINE_INTERLOCKED_CPLUSPLUS_OVERLOADS 0
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <time.h>
+
+#ifdef _WIN32
+#  include <windows.h>
+#  include <wincrypt.h>
+#else
+#  include <sys/stat.h>
+#  include <fcntl.h>
+#  include <unistd.h>
+#endif
+
+#include "zlib.h"
+
+#include "crypt.h"
+
+#ifdef _WIN32
+#   pragma warning(push)
+#   pragma warning(disable : 4244)
+#endif // _WIN32
+
+/***************************************************************************/
+
+#define CRC32(c, b) ((*(pcrc_32_tab+(((uint32_t)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))
+
+#ifndef ZCR_SEED2
+#  define ZCR_SEED2 3141592654UL     /* use PI as default pattern */
+#endif
+
+/***************************************************************************/
+
+uint8_t decrypt_byte(uint32_t *pkeys)
+{
+    unsigned temp;  /* POTENTIAL BUG:  temp*(temp^1) may overflow in an
+                     * unpredictable manner on 16-bit systems; not a problem
+                     * with any known compiler so far, though */
+
+    temp = ((uint32_t)(*(pkeys+2)) & 0xffff) | 2;
+    return (uint8_t)(((temp * (temp ^ 1)) >> 8) & 0xff);
+}
+
+uint8_t update_keys(uint32_t *pkeys, const z_crc_t *pcrc_32_tab, int32_t c)
+{
+    (*(pkeys+0)) = (uint32_t)CRC32((*(pkeys+0)), c);
+    (*(pkeys+1)) += (*(pkeys+0)) & 0xff;
+    (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1;
+    {
+        register int32_t keyshift = (int32_t)((*(pkeys + 1)) >> 24);
+        (*(pkeys+2)) = (uint32_t)CRC32((*(pkeys+2)), keyshift);
+    }
+    return c;
+}
+
+void init_keys(const char *passwd, uint32_t *pkeys, const z_crc_t *pcrc_32_tab)
+{
+    *(pkeys+0) = 305419896L;
+    *(pkeys+1) = 591751049L;
+    *(pkeys+2) = 878082192L;
+    while (*passwd != 0)
+    {
+        update_keys(pkeys, pcrc_32_tab, *passwd);
+        passwd += 1;
+    }
+}
+
+/***************************************************************************/
+
+int cryptrand(unsigned char *buf, unsigned int len)
+{
+    static unsigned calls = 0;
+    int rlen = 0;
+#ifdef _WIN32
+    HCRYPTPROV provider;
+    unsigned __int64 pentium_tsc[1];
+    int result = 0;
+
+
+    if (CryptAcquireContext(&provider, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT | CRYPT_SILENT))
+    {
+        result = CryptGenRandom(provider, len, buf);
+        CryptReleaseContext(provider, 0);
+        if (result)
+            return len;
+    }
+
+    for (rlen = 0; rlen < (int)len; ++rlen)
+    {
+        if (rlen % 8 == 0)
+            QueryPerformanceCounter((LARGE_INTEGER *)pentium_tsc);
+        buf[rlen] = ((unsigned char*)pentium_tsc)[rlen % 8];
+    }
+#else
+    int frand = open("/dev/urandom", O_RDONLY);
+    if (frand != -1)
+    {
+        rlen = (int)read(frand, buf, len);
+        close(frand);
+    }
+#endif
+    if (rlen < (int)len)
+    {
+        /* Ensure different random header each time */
+        if (++calls == 1)
+            srand((unsigned)(time(NULL) ^ ZCR_SEED2));
+
+        while (rlen < (int)len)
+            buf[rlen++] = (rand() >> 7) & 0xff;
+    }
+    return rlen;
+}
+
+int crypthead(const char *passwd, uint8_t *buf, int buf_size, uint32_t *pkeys, 
+              const z_crc_t *pcrc_32_tab, uint8_t verify1, uint8_t verify2)
+{
+    uint8_t n = 0;                      /* index in random header */
+    uint8_t header[RAND_HEAD_LEN-2];    /* random header */
+    uint16_t t = 0;                     /* temporary */
+
+    if (buf_size < RAND_HEAD_LEN)
+        return 0;
+
+    init_keys(passwd, pkeys, pcrc_32_tab);
+
+    /* First generate RAND_HEAD_LEN-2 random bytes. */
+    cryptrand(header, RAND_HEAD_LEN-2);
+
+    /* Encrypt random header (last two bytes is high word of crc) */
+    init_keys(passwd, pkeys, pcrc_32_tab);
+
+    for (n = 0; n < RAND_HEAD_LEN-2; n++)
+        buf[n] = (uint8_t)zencode(pkeys, pcrc_32_tab, header[n], t);
+
+    buf[n++] = (uint8_t)zencode(pkeys, pcrc_32_tab, verify1, t);
+    buf[n++] = (uint8_t)zencode(pkeys, pcrc_32_tab, verify2, t);
+    return n;
+}
+
+#ifdef _WIN32
+#   pragma warning(pop)
+#endif // _WIN32
+
+/***************************************************************************/
diff --git a/Engine/lib/assimp/contrib/unzip/crypt.h b/Engine/lib/assimp/contrib/unzip/crypt.h
index 2aa99c284..78146eb83 100644
--- a/Engine/lib/assimp/contrib/unzip/crypt.h
+++ b/Engine/lib/assimp/contrib/unzip/crypt.h
@@ -1,132 +1,63 @@
-/* crypt.h -- base code for crypt/uncrypt ZIPfile
-
-
+/* crypt.h -- base code for traditional PKWARE encryption
    Version 1.01e, February 12th, 2005
 
    Copyright (C) 1998-2005 Gilles Vollant
+   Modifications for Info-ZIP crypting
+     Copyright (C) 2003 Terry Thorsen
 
-   This code is a modified version of crypting code in Infozip distribution
+   This code is a modified version of crypting code in Info-ZIP distribution
 
-   The encryption/decryption parts of this source code (as opposed to the
-   non-echoing password parts) were originally written in Europe.  The
-   whole source package can be freely distributed, including from the USA.
-   (Prior to January 2000, re-export from the US was a violation of US law.)
+   Copyright (C) 1990-2000 Info-ZIP.  All rights reserved.
 
-   This encryption code is a direct transcription of the algorithm from
-   Roger Schlafly, described by Phil Katz in the file appnote.txt.  This
-   file (appnote.txt) is distributed with the PKZIP program (even in the
-   version without encryption capabilities).
-
-   If you don't need crypting in your application, just define symbols
-   NOCRYPT and NOUNCRYPT.
-
-   This code support the "Traditional PKWARE Encryption".
-
-   The new AES encryption added on Zip format by Winzip (see the page
-   http://www.winzip.com/aes_info.htm ) and PKWare PKZip 5.x Strong
-   Encryption is not supported.
+   This program is distributed under the terms of the same license as zlib.
+   See the accompanying LICENSE file for the full text of the license.
 */
 
-#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))
+#ifndef _MINICRYPT_H
+#define _MINICRYPT_H
 
-/***********************************************************************
- * Return the next byte in the pseudo-random sequence
- */
-static int decrypt_byte(unsigned long* pkeys, const z_crc_t* pcrc_32_tab)
-{
-    unsigned temp;  /* POTENTIAL BUG:  temp*(temp^1) may overflow in an
-                     * unpredictable manner on 16-bit systems; not a problem
-                     * with any known compiler so far, though */
+#if ZLIB_VERNUM < 0x1270
+#if !defined(Z_U4)
+typedef unsigned long z_crc_t;
+#endif
+#endif
 
-    temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2;
-    return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);
-}
-
-/***********************************************************************
- * Update the encryption keys with the next byte of plain text
- */
-static int update_keys(unsigned long* pkeys,const z_crc_t* pcrc_32_tab,int c)
-{
-    (*(pkeys+0)) = CRC32((*(pkeys+0)), c);
-    (*(pkeys+1)) += (*(pkeys+0)) & 0xff;
-    (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1;
-    {
-      register int keyshift = (int)((*(pkeys+1)) >> 24);
-      (*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift);
-    }
-    return c;
-}
-
-
-/***********************************************************************
- * Initialize the encryption keys and the random header according to
- * the given password.
- */
-static void init_keys(const char* passwd,unsigned long* pkeys,const z_crc_t* pcrc_32_tab)
-{
-    *(pkeys+0) = 305419896L;
-    *(pkeys+1) = 591751049L;
-    *(pkeys+2) = 878082192L;
-    while (*passwd != '\0') {
-        update_keys(pkeys,pcrc_32_tab,(int)*passwd);
-        passwd++;
-    }
-}
-
-#define zdecode(pkeys,pcrc_32_tab,c) \
-    (update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab)))
-
-#define zencode(pkeys,pcrc_32_tab,c,t) \
-    (t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c))
-
-#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 #define RAND_HEAD_LEN  12
-   /* "last resort" source for second part of crypt seed pattern */
-#  ifndef ZCR_SEED2
-#    define ZCR_SEED2 3141592654UL     /* use PI as default pattern */
-#  endif
 
-static int crypthead(passwd, buf, bufSize, pkeys, pcrc_32_tab, crcForCrypting)
-    const char *passwd;         /* password string */
-    unsigned char *buf;         /* where to write header */
-    int bufSize;
-    unsigned long* pkeys;
-    const unsigned long* pcrc_32_tab;
-    unsigned long crcForCrypting;
-{
-    int n;                       /* index in random header */
-    int t;                       /* temporary */
-    int c;                       /* random byte */
-    unsigned char header[RAND_HEAD_LEN-2]; /* random header */
-    static unsigned calls = 0;   /* ensure different random header each time */
+/***************************************************************************/
 
-    if (bufSize<RAND_HEAD_LEN)
-      return 0;
+#define zdecode(pkeys,pcrc_32_tab,c) \
+    (update_keys(pkeys,pcrc_32_tab, c ^= decrypt_byte(pkeys)))
 
-    /* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the
-     * output of rand() to get less predictability, since rand() is
-     * often poorly implemented.
-     */
-    if (++calls == 1)
-    {
-        srand((unsigned)(time(NULL) ^ ZCR_SEED2));
-    }
-    init_keys(passwd, pkeys, pcrc_32_tab);
-    for (n = 0; n < RAND_HEAD_LEN-2; n++)
-    {
-        c = (rand() >> 7) & 0xff;
-        header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t);
-    }
-    /* Encrypt random header (last two bytes is high word of crc) */
-    init_keys(passwd, pkeys, pcrc_32_tab);
-    for (n = 0; n < RAND_HEAD_LEN-2; n++)
-    {
-        buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t);
-    }
-    buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t);
-    buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t);
-    return n;
+#define zencode(pkeys,pcrc_32_tab,c,t) \
+    (t = decrypt_byte(pkeys), update_keys(pkeys,pcrc_32_tab,c), t^(c))
+
+/***************************************************************************/
+
+/* Return the next byte in the pseudo-random sequence */
+uint8_t decrypt_byte(uint32_t *pkeys);
+
+/* Update the encryption keys with the next byte of plain text */
+uint8_t update_keys(uint32_t *pkeys, const z_crc_t *pcrc_32_tab, int32_t c);
+
+/* Initialize the encryption keys and the random header according to the given password. */
+void init_keys(const char *passwd, uint32_t *pkeys, const z_crc_t *pcrc_32_tab);
+
+/* Generate cryptographically secure random numbers */
+int cryptrand(unsigned char *buf, unsigned int len);
+
+/* Create encryption header */
+int crypthead(const char *passwd, uint8_t *buf, int buf_size, uint32_t *pkeys, 
+    const z_crc_t *pcrc_32_tab, uint8_t verify1, uint8_t verify2);
+
+/***************************************************************************/
+
+#ifdef __cplusplus
 }
+#endif
 
 #endif
diff --git a/Engine/lib/assimp/contrib/unzip/ioapi.c b/Engine/lib/assimp/contrib/unzip/ioapi.c
index f1bee23e6..30a296d0f 100644
--- a/Engine/lib/assimp/contrib/unzip/ioapi.c
+++ b/Engine/lib/assimp/contrib/unzip/ioapi.c
@@ -1,172 +1,340 @@
 /* ioapi.c -- IO base function header for compress/uncompress .zip
-   files using zlib + zip or unzip API
+   part of the MiniZip project
 
-   Version 1.01e, February 12th, 2005
+   Copyright (C) 1998-2010 Gilles Vollant
+     http://www.winimage.com/zLibDll/minizip.html
+   Modifications for Zip64 support
+     Copyright (C) 2009-2010 Mathias Svensson
+     http://result42.com
 
-   Copyright (C) 1998-2005 Gilles Vollant
+   This program is distributed under the terms of the same license as zlib.
+   See the accompanying LICENSE file for the full text of the license.
 */
 
-#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-#include "zlib.h"
+#if defined unix || defined __APPLE__
+#include <sys/types.h>
+#include <unistd.h>
+#endif
+
 #include "ioapi.h"
 
+#ifdef _WIN32
+#   define snprintf _snprintf
+#   pragma warning(push)
+#   pragma warning(disable : 4131 4100)
+#   ifdef __clang__
+#       pragma clang diagnostic push
+#       pragma clang diagnostic ignored "-Wunused-parameter"
+#   endif
+#endif // _WIN32
 
 
-/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
+voidpf call_zopen64(const zlib_filefunc64_32_def *pfilefunc, const void *filename, int mode)
+{
+    if (pfilefunc->zfile_func64.zopen64_file != NULL)
+        return (*(pfilefunc->zfile_func64.zopen64_file)) (pfilefunc->zfile_func64.opaque, filename, mode);
+    return (*(pfilefunc->zopen32_file))(pfilefunc->zfile_func64.opaque, (const char*)filename, mode);
+}
 
-#ifndef SEEK_CUR
-#define SEEK_CUR    1
-#endif
+voidpf call_zopendisk64(const zlib_filefunc64_32_def *pfilefunc, voidpf filestream, uint32_t number_disk, int mode)
+{
+    if (pfilefunc->zfile_func64.zopendisk64_file != NULL)
+        return (*(pfilefunc->zfile_func64.zopendisk64_file)) (pfilefunc->zfile_func64.opaque, filestream, number_disk, mode);
+    return (*(pfilefunc->zopendisk32_file))(pfilefunc->zfile_func64.opaque, filestream, number_disk, mode);
+}
 
-#ifndef SEEK_END
-#define SEEK_END    2
-#endif
+long call_zseek64(const zlib_filefunc64_32_def *pfilefunc, voidpf filestream, uint64_t offset, int origin)
+{
+    uint32_t offset_truncated = 0;
+    if (pfilefunc->zfile_func64.zseek64_file != NULL)
+        return (*(pfilefunc->zfile_func64.zseek64_file)) (pfilefunc->zfile_func64.opaque,filestream,offset,origin);
+    offset_truncated = (uint32_t)offset;
+    if (offset_truncated != offset)
+        return -1;
+    return (*(pfilefunc->zseek32_file))(pfilefunc->zfile_func64.opaque,filestream, offset_truncated, origin);
+}
 
-#ifndef SEEK_SET
-#define SEEK_SET    0
-#endif
+uint64_t call_ztell64(const zlib_filefunc64_32_def *pfilefunc, voidpf filestream)
+{
+    uint64_t position;
+    if (pfilefunc->zfile_func64.zseek64_file != NULL)
+        return (*(pfilefunc->zfile_func64.ztell64_file)) (pfilefunc->zfile_func64.opaque, filestream);
+    position = (*(pfilefunc->ztell32_file))(pfilefunc->zfile_func64.opaque, filestream);
+    if ((position) == UINT32_MAX)
+        return (uint64_t)-1;
+    return position;
+}
 
-voidpf ZCALLBACK fopen_file_func OF((
-   voidpf opaque,
-   const char* filename,
-   int mode));
+void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def *p_filefunc64_32, const zlib_filefunc_def *p_filefunc32)
+{
+    p_filefunc64_32->zfile_func64.zopen64_file = NULL;
+    p_filefunc64_32->zfile_func64.zopendisk64_file = NULL;
+    p_filefunc64_32->zopen32_file = p_filefunc32->zopen_file;
+    p_filefunc64_32->zopendisk32_file = p_filefunc32->zopendisk_file;
+    p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file;
+    p_filefunc64_32->zfile_func64.zread_file = p_filefunc32->zread_file;
+    p_filefunc64_32->zfile_func64.zwrite_file = p_filefunc32->zwrite_file;
+    p_filefunc64_32->zfile_func64.ztell64_file = NULL;
+    p_filefunc64_32->zfile_func64.zseek64_file = NULL;
+    p_filefunc64_32->zfile_func64.zclose_file = p_filefunc32->zclose_file;
+    p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file;
+    p_filefunc64_32->zfile_func64.opaque = p_filefunc32->opaque;
+    p_filefunc64_32->zseek32_file = p_filefunc32->zseek_file;
+    p_filefunc64_32->ztell32_file = p_filefunc32->ztell_file;
+}
 
-uLong ZCALLBACK fread_file_func OF((
-   voidpf opaque,
-   voidpf stream,
-   void* buf,
-   uLong size));
+static voidpf   ZCALLBACK fopen_file_func(voidpf opaque, const char *filename, int mode);
+static uint32_t ZCALLBACK fread_file_func(voidpf opaque, voidpf stream, void* buf, uint32_t size);
+static uint32_t ZCALLBACK fwrite_file_func(voidpf opaque, voidpf stream, const void *buf, uint32_t size);
+static uint64_t ZCALLBACK ftell64_file_func(voidpf opaque, voidpf stream);
+static long     ZCALLBACK fseek64_file_func(voidpf opaque, voidpf stream, uint64_t offset, int origin);
+static int      ZCALLBACK fclose_file_func(voidpf opaque, voidpf stream);
+static int      ZCALLBACK ferror_file_func(voidpf opaque, voidpf stream);
 
-uLong ZCALLBACK fwrite_file_func OF((
-   voidpf opaque,
-   voidpf stream,
-   const void* buf,
-   uLong size));
+typedef struct
+{
+    FILE *file;
+    int filenameLength;
+    void *filename;
+} FILE_IOPOSIX;
 
-long ZCALLBACK ftell_file_func OF((
-   voidpf opaque,
-   voidpf stream));
+static voidpf file_build_ioposix(FILE *file, const char *filename)
+{
+    FILE_IOPOSIX *ioposix = NULL;
+    if (file == NULL)
+        return NULL;
+    ioposix = (FILE_IOPOSIX*)malloc(sizeof(FILE_IOPOSIX));
+    ioposix->file = file;
+    ioposix->filenameLength = (int)strlen(filename) + 1;
+    ioposix->filename = (char*)malloc(ioposix->filenameLength * sizeof(char));
+    memcpy((char*)ioposix->filename, filename, ioposix->filenameLength);
+    return (voidpf)ioposix;
+}
 
-long ZCALLBACK fseek_file_func OF((
-   voidpf opaque,
-   voidpf stream,
-   uLong offset,
-   int origin));
-
-int ZCALLBACK fclose_file_func OF((
-   voidpf opaque,
-   voidpf stream));
-
-int ZCALLBACK ferror_file_func OF((
-   voidpf opaque,
-   voidpf stream));
-
-
-voidpf ZCALLBACK fopen_file_func (opaque, filename, mode)
-   voidpf opaque;
-   const char* filename;
-   int mode;
+static voidpf ZCALLBACK fopen_file_func(voidpf opaque, const char *filename, int mode)
 {
     FILE* file = NULL;
-    const char* mode_fopen = NULL;
-    if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
+    const char *mode_fopen = NULL;
+    if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER) == ZLIB_FILEFUNC_MODE_READ)
         mode_fopen = "rb";
-    else
-    if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
+    else if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
         mode_fopen = "r+b";
-    else
-    if (mode & ZLIB_FILEFUNC_MODE_CREATE)
+    else if (mode & ZLIB_FILEFUNC_MODE_CREATE)
         mode_fopen = "wb";
 
-    if ((filename!=NULL) && (mode_fopen != NULL))
+    if ((filename != NULL) && (mode_fopen != NULL))
+    {
         file = fopen(filename, mode_fopen);
+        return file_build_ioposix(file, filename);
+    }
     return file;
 }
 
-
-uLong ZCALLBACK fread_file_func (opaque, stream, buf, size)
-   voidpf opaque;
-   voidpf stream;
-   void* buf;
-   uLong size;
+static voidpf ZCALLBACK fopen64_file_func(voidpf opaque, const void *filename, int mode)
 {
-    uLong ret;
-    ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream);
+    FILE* file = NULL;
+    const char *mode_fopen = NULL;
+    if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER) == ZLIB_FILEFUNC_MODE_READ)
+        mode_fopen = "rb";
+    else if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
+        mode_fopen = "r+b";
+    else if (mode & ZLIB_FILEFUNC_MODE_CREATE)
+        mode_fopen = "wb";
+
+    if ((filename != NULL) && (mode_fopen != NULL))
+    {
+        file = fopen64((const char*)filename, mode_fopen);
+        return file_build_ioposix(file, (const char*)filename);
+    }
+    return file;
+}
+
+static voidpf ZCALLBACK fopendisk64_file_func(voidpf opaque, voidpf stream, uint32_t number_disk, int mode)
+{
+    FILE_IOPOSIX *ioposix = NULL;
+    char *diskFilename = NULL;
+    voidpf ret = NULL;
+    int i = 0;
+
+    if (stream == NULL)
+        return NULL;
+    ioposix = (FILE_IOPOSIX*)stream;
+    diskFilename = (char*)malloc(ioposix->filenameLength * sizeof(char));
+    strncpy(diskFilename, (const char*)ioposix->filename, ioposix->filenameLength);
+    for (i = ioposix->filenameLength - 1; i >= 0; i -= 1)
+    {
+        if (diskFilename[i] != '.')
+            continue;
+        snprintf(&diskFilename[i], ioposix->filenameLength - i, ".z%02u", number_disk + 1);
+        break;
+    }
+    if (i >= 0)
+        ret = fopen64_file_func(opaque, diskFilename, mode);
+    free(diskFilename);
     return ret;
 }
 
-
-uLong ZCALLBACK fwrite_file_func (opaque, stream, buf, size)
-   voidpf opaque;
-   voidpf stream;
-   const void* buf;
-   uLong size;
+static voidpf ZCALLBACK fopendisk_file_func(voidpf opaque, voidpf stream, uint32_t number_disk, int mode)
 {
-    uLong ret;
-    ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream);
+    FILE_IOPOSIX *ioposix = NULL;
+    char *diskFilename = NULL;
+    voidpf ret = NULL;
+    int i = 0;
+
+    if (stream == NULL)
+        return NULL;
+    ioposix = (FILE_IOPOSIX*)stream;
+    diskFilename = (char*)malloc(ioposix->filenameLength * sizeof(char));
+    strncpy(diskFilename, (const char*)ioposix->filename, ioposix->filenameLength);
+    for (i = ioposix->filenameLength - 1; i >= 0; i -= 1)
+    {
+        if (diskFilename[i] != '.')
+            continue;
+        snprintf(&diskFilename[i], ioposix->filenameLength - i, ".z%02u", number_disk + 1);
+        break;
+    }
+    if (i >= 0)
+        ret = fopen_file_func(opaque, diskFilename, mode);
+    free(diskFilename);
     return ret;
 }
 
-long ZCALLBACK ftell_file_func (opaque, stream)
-   voidpf opaque;
-   voidpf stream;
+static uint32_t ZCALLBACK fread_file_func(voidpf opaque, voidpf stream, void* buf, uint32_t size)
 {
-    long ret;
-    ret = ftell((FILE *)stream);
+    FILE_IOPOSIX *ioposix = NULL;
+    uint32_t read = (uint32_t)-1;
+    if (stream == NULL)
+        return read;
+    ioposix = (FILE_IOPOSIX*)stream;
+    read = (uint32_t)fread(buf, 1, (size_t)size, ioposix->file);
+    return read;
+}
+
+static uint32_t ZCALLBACK fwrite_file_func(voidpf opaque, voidpf stream, const void *buf, uint32_t size)
+{
+    FILE_IOPOSIX *ioposix = NULL;
+    uint32_t written = (uint32_t)-1;
+    if (stream == NULL)
+        return written;
+    ioposix = (FILE_IOPOSIX*)stream;
+    written = (uint32_t)fwrite(buf, 1, (size_t)size, ioposix->file);
+    return written;
+}
+
+static long ZCALLBACK ftell_file_func(voidpf opaque, voidpf stream)
+{
+    FILE_IOPOSIX *ioposix = NULL;
+    long ret = -1;
+    if (stream == NULL)
+        return ret;
+    ioposix = (FILE_IOPOSIX*)stream;
+    ret = ftell(ioposix->file);
     return ret;
 }
 
-long ZCALLBACK fseek_file_func (opaque, stream, offset, origin)
-   voidpf opaque;
-   voidpf stream;
-   uLong offset;
-   int origin;
+static uint64_t ZCALLBACK ftell64_file_func(voidpf opaque, voidpf stream)
 {
-    int fseek_origin=0;
-    long ret;
+    FILE_IOPOSIX *ioposix = NULL;
+    uint64_t ret = (uint64_t)-1;
+    if (stream == NULL)
+        return ret;
+    ioposix = (FILE_IOPOSIX*)stream;
+    ret = ftello64(ioposix->file);
+    return ret;
+}
+
+static long ZCALLBACK fseek_file_func(voidpf opaque, voidpf stream, uint32_t offset, int origin)
+{
+    FILE_IOPOSIX *ioposix = NULL;
+    int fseek_origin = 0;
+    long ret = 0;
+
+    if (stream == NULL)
+        return -1;
+    ioposix = (FILE_IOPOSIX*)stream;
+
     switch (origin)
     {
-    case ZLIB_FILEFUNC_SEEK_CUR :
-        fseek_origin = SEEK_CUR;
-        break;
-    case ZLIB_FILEFUNC_SEEK_END :
-        fseek_origin = SEEK_END;
-        break;
-    case ZLIB_FILEFUNC_SEEK_SET :
-        fseek_origin = SEEK_SET;
-        break;
-    default: return -1;
+        case ZLIB_FILEFUNC_SEEK_CUR:
+            fseek_origin = SEEK_CUR;
+            break;
+        case ZLIB_FILEFUNC_SEEK_END:
+            fseek_origin = SEEK_END;
+            break;
+        case ZLIB_FILEFUNC_SEEK_SET:
+            fseek_origin = SEEK_SET;
+            break;
+        default:
+            return -1;
     }
-    ret = 0;
-    fseek((FILE *)stream, offset, fseek_origin);
+    if (fseek(ioposix->file, offset, fseek_origin) != 0)
+        ret = -1;
     return ret;
 }
 
-int ZCALLBACK fclose_file_func (opaque, stream)
-   voidpf opaque;
-   voidpf stream;
+static long ZCALLBACK fseek64_file_func(voidpf opaque, voidpf stream, uint64_t offset, int origin)
 {
-    int ret;
-    ret = fclose((FILE *)stream);
+    FILE_IOPOSIX *ioposix = NULL;
+    int fseek_origin = 0;
+    long ret = 0;
+
+    if (stream == NULL)
+        return -1;
+    ioposix = (FILE_IOPOSIX*)stream;
+
+    switch (origin)
+    {
+        case ZLIB_FILEFUNC_SEEK_CUR:
+            fseek_origin = SEEK_CUR;
+            break;
+        case ZLIB_FILEFUNC_SEEK_END:
+            fseek_origin = SEEK_END;
+            break;
+        case ZLIB_FILEFUNC_SEEK_SET:
+            fseek_origin = SEEK_SET;
+            break;
+        default:
+            return -1;
+    }
+
+    if (fseeko64(ioposix->file, offset, fseek_origin) != 0)
+        ret = -1;
+
     return ret;
 }
 
-int ZCALLBACK ferror_file_func (opaque, stream)
-   voidpf opaque;
-   voidpf stream;
+static int ZCALLBACK fclose_file_func(voidpf opaque, voidpf stream)
 {
-    int ret;
-    ret = ferror((FILE *)stream);
+    FILE_IOPOSIX *ioposix = NULL;
+    int ret = -1;
+    if (stream == NULL)
+        return ret;
+    ioposix = (FILE_IOPOSIX*)stream;
+    if (ioposix->filename != NULL)
+        free(ioposix->filename);
+    ret = fclose(ioposix->file);
+    free(ioposix);
     return ret;
 }
 
-void fill_fopen_filefunc (pzlib_filefunc_def)
-  zlib_filefunc_def* pzlib_filefunc_def;
+static int ZCALLBACK ferror_file_func(voidpf opaque, voidpf stream)
+{
+    FILE_IOPOSIX *ioposix = NULL;
+    int ret = -1;
+    if (stream == NULL)
+        return ret;
+    ioposix = (FILE_IOPOSIX*)stream;
+    ret = ferror(ioposix->file);
+    return ret;
+}
+
+void fill_fopen_filefunc(zlib_filefunc_def *pzlib_filefunc_def)
 {
     pzlib_filefunc_def->zopen_file = fopen_file_func;
+    pzlib_filefunc_def->zopendisk_file = fopendisk_file_func;
     pzlib_filefunc_def->zread_file = fread_file_func;
     pzlib_filefunc_def->zwrite_file = fwrite_file_func;
     pzlib_filefunc_def->ztell_file = ftell_file_func;
@@ -175,3 +343,23 @@ void fill_fopen_filefunc (pzlib_filefunc_def)
     pzlib_filefunc_def->zerror_file = ferror_file_func;
     pzlib_filefunc_def->opaque = NULL;
 }
+
+void fill_fopen64_filefunc(zlib_filefunc64_def *pzlib_filefunc_def)
+{
+    pzlib_filefunc_def->zopen64_file = fopen64_file_func;
+    pzlib_filefunc_def->zopendisk64_file = fopendisk64_file_func;
+    pzlib_filefunc_def->zread_file = fread_file_func;
+    pzlib_filefunc_def->zwrite_file = fwrite_file_func;
+    pzlib_filefunc_def->ztell64_file = ftell64_file_func;
+    pzlib_filefunc_def->zseek64_file = fseek64_file_func;
+    pzlib_filefunc_def->zclose_file = fclose_file_func;
+    pzlib_filefunc_def->zerror_file = ferror_file_func;
+    pzlib_filefunc_def->opaque = NULL;
+}
+
+#ifdef _WIN32
+#   pragma warning(pop)
+#   ifdef __clang__
+#       pragma clang diagnostic pop
+#   endif
+#endif // _WIN32
diff --git a/Engine/lib/assimp/contrib/unzip/ioapi.h b/Engine/lib/assimp/contrib/unzip/ioapi.h
index 7d457baab..0e49543e5 100644
--- a/Engine/lib/assimp/contrib/unzip/ioapi.h
+++ b/Engine/lib/assimp/contrib/unzip/ioapi.h
@@ -1,33 +1,43 @@
 /* ioapi.h -- IO base function header for compress/uncompress .zip
-   files using zlib + zip or unzip API
+   part of the MiniZip project
 
-   Version 1.01e, February 12th, 2005
+   Copyright (C) 1998-2010 Gilles Vollant
+     http://www.winimage.com/zLibDll/minizip.html
+   Modifications for Zip64 support
+     Copyright (C) 2009-2010 Mathias Svensson
+     http://result42.com
 
-   Copyright (C) 1998-2005 Gilles Vollant
+   This program is distributed under the terms of the same license as zlib.
+   See the accompanying LICENSE file for the full text of the license.
 */
 
-#ifndef _ZLIBIOAPI_H
-#define _ZLIBIOAPI_H
+#ifndef _ZLIBIOAPI64_H
+#define _ZLIBIOAPI64_H
 
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
 
-#define ZLIB_FILEFUNC_SEEK_CUR (1)
-#define ZLIB_FILEFUNC_SEEK_END (2)
-#define ZLIB_FILEFUNC_SEEK_SET (0)
+#include "zlib.h"
 
-#define ZLIB_FILEFUNC_MODE_READ      (1)
-#define ZLIB_FILEFUNC_MODE_WRITE     (2)
-#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3)
-
-#define ZLIB_FILEFUNC_MODE_EXISTING (4)
-#define ZLIB_FILEFUNC_MODE_CREATE   (8)
-
-
-#ifndef ZCALLBACK
-
-#if (defined(WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK)
-#define ZCALLBACK CALLBACK
+#if defined(USE_FILE32API)
+#   define fopen64 fopen
+#   define ftello64 ftell
+#   define fseeko64 fseek
 #else
-#define ZCALLBACK
+#if defined(_MSC_VER)
+#   define fopen64 fopen
+#   if (_MSC_VER >= 1400) && (!(defined(NO_MSCVER_FILE64_FUNC)))
+#       define ftello64 _ftelli64
+#       define fseeko64 _fseeki64
+#   else /* old MSC */
+#       define ftello64 ftell
+#       define fseeko64 fseek
+#   endif
+#else
+#   define fopen64 fopen
+#   define ftello64 ftello
+#   define fseeko64 fseeko
 #endif
 #endif
 
@@ -35,41 +45,101 @@
 extern "C" {
 #endif
 
-typedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, const char* filename, int mode));
-typedef uLong  (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size));
-typedef uLong  (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size));
-typedef long   (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream));
-typedef long   (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin));
-typedef int    (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream));
-typedef int    (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream));
+#define ZLIB_FILEFUNC_SEEK_CUR (1)
+#define ZLIB_FILEFUNC_SEEK_END (2)
+#define ZLIB_FILEFUNC_SEEK_SET (0)
 
+#define ZLIB_FILEFUNC_MODE_READ             (1)
+#define ZLIB_FILEFUNC_MODE_WRITE            (2)
+#define ZLIB_FILEFUNC_MODE_READWRITEFILTER  (3)
+#define ZLIB_FILEFUNC_MODE_EXISTING         (4)
+#define ZLIB_FILEFUNC_MODE_CREATE           (8)
+
+#ifndef ZCALLBACK
+#  if (defined(WIN32) || defined(_WIN32) || defined (WINDOWS) || \
+       defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK)
+#    define ZCALLBACK CALLBACK
+#  else
+#    define ZCALLBACK
+#  endif
+#endif
+
+typedef voidpf   (ZCALLBACK *open_file_func)     (voidpf opaque, const char *filename, int mode);
+typedef voidpf   (ZCALLBACK *opendisk_file_func) (voidpf opaque, voidpf stream, uint32_t number_disk, int mode);
+typedef uint32_t (ZCALLBACK *read_file_func)     (voidpf opaque, voidpf stream, void* buf, uint32_t size);
+typedef uint32_t (ZCALLBACK *write_file_func)    (voidpf opaque, voidpf stream, const void *buf, uint32_t size);
+typedef int      (ZCALLBACK *close_file_func)    (voidpf opaque, voidpf stream);
+typedef int      (ZCALLBACK *error_file_func)    (voidpf opaque, voidpf stream);
+
+typedef long     (ZCALLBACK *tell_file_func)     (voidpf opaque, voidpf stream);
+typedef long     (ZCALLBACK *seek_file_func)     (voidpf opaque, voidpf stream, uint32_t offset, int origin);
+
+/* here is the "old" 32 bits structure structure */
 typedef struct zlib_filefunc_def_s
 {
     open_file_func      zopen_file;
+    opendisk_file_func  zopendisk_file;
     read_file_func      zread_file;
     write_file_func     zwrite_file;
     tell_file_func      ztell_file;
     seek_file_func      zseek_file;
     close_file_func     zclose_file;
-    testerror_file_func zerror_file;
+    error_file_func     zerror_file;
     voidpf              opaque;
 } zlib_filefunc_def;
 
+typedef uint64_t (ZCALLBACK *tell64_file_func)    (voidpf opaque, voidpf stream);
+typedef long     (ZCALLBACK *seek64_file_func)    (voidpf opaque, voidpf stream, uint64_t offset, int origin);
+typedef voidpf   (ZCALLBACK *open64_file_func)    (voidpf opaque, const void *filename, int mode);
+typedef voidpf   (ZCALLBACK *opendisk64_file_func)(voidpf opaque, voidpf stream, uint32_t number_disk, int mode);
 
+typedef struct zlib_filefunc64_def_s
+{
+    open64_file_func     zopen64_file;
+    opendisk64_file_func zopendisk64_file;
+    read_file_func       zread_file;
+    write_file_func      zwrite_file;
+    tell64_file_func     ztell64_file;
+    seek64_file_func     zseek64_file;
+    close_file_func      zclose_file;
+    error_file_func      zerror_file;
+    voidpf               opaque;
+} zlib_filefunc64_def;
 
-void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
+void fill_fopen_filefunc(zlib_filefunc_def *pzlib_filefunc_def);
+void fill_fopen64_filefunc(zlib_filefunc64_def *pzlib_filefunc_def);
 
-#define ZREAD(filefunc,filestream,buf,size) ((*((filefunc).zread_file))((filefunc).opaque,filestream,buf,size))
-#define ZWRITE(filefunc,filestream,buf,size) ((*((filefunc).zwrite_file))((filefunc).opaque,filestream,buf,size))
-#define ZTELL(filefunc,filestream) ((*((filefunc).ztell_file))((filefunc).opaque,filestream))
-#define ZSEEK(filefunc,filestream,pos,mode) ((*((filefunc).zseek_file))((filefunc).opaque,filestream,pos,mode))
-#define ZCLOSE(filefunc,filestream) ((*((filefunc).zclose_file))((filefunc).opaque,filestream))
-#define ZERROR(filefunc,filestream) ((*((filefunc).zerror_file))((filefunc).opaque,filestream))
+/* now internal definition, only for zip.c and unzip.h */
+typedef struct zlib_filefunc64_32_def_s
+{
+    zlib_filefunc64_def zfile_func64;
+    open_file_func      zopen32_file;
+    opendisk_file_func  zopendisk32_file;
+    tell_file_func      ztell32_file;
+    seek_file_func      zseek32_file;
+} zlib_filefunc64_32_def;
 
+#define ZREAD64(filefunc,filestream,buf,size)       ((*((filefunc).zfile_func64.zread_file))        ((filefunc).zfile_func64.opaque,filestream,buf,size))
+#define ZWRITE64(filefunc,filestream,buf,size)      ((*((filefunc).zfile_func64.zwrite_file))       ((filefunc).zfile_func64.opaque,filestream,buf,size))
+/*#define ZTELL64(filefunc,filestream)                ((*((filefunc).ztell64_file))                   ((filefunc).opaque,filestream))*/
+/*#define ZSEEK64(filefunc,filestream,pos,mode)       ((*((filefunc).zseek64_file))                   ((filefunc).opaque,filestream,pos,mode))*/
+#define ZCLOSE64(filefunc,filestream)               ((*((filefunc).zfile_func64.zclose_file))       ((filefunc).zfile_func64.opaque,filestream))
+#define ZERROR64(filefunc,filestream)               ((*((filefunc).zfile_func64.zerror_file))       ((filefunc).zfile_func64.opaque,filestream))
+
+voidpf   call_zopen64(const zlib_filefunc64_32_def *pfilefunc,const void*filename, int mode);
+voidpf   call_zopendisk64(const zlib_filefunc64_32_def *pfilefunc, voidpf filestream, uint32_t number_disk, int mode);
+long     call_zseek64(const zlib_filefunc64_32_def *pfilefunc, voidpf filestream, uint64_t offset, int origin);
+uint64_t call_ztell64(const zlib_filefunc64_32_def *pfilefunc, voidpf filestream);
+
+void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def *p_filefunc64_32, const zlib_filefunc_def *p_filefunc32);
+
+#define ZOPEN64(filefunc,filename,mode)             (call_zopen64((&(filefunc)),(filename),(mode)))
+#define ZOPENDISK64(filefunc,filestream,diskn,mode) (call_zopendisk64((&(filefunc)),(filestream),(diskn),(mode)))
+#define ZTELL64(filefunc,filestream)                (call_ztell64((&(filefunc)),(filestream)))
+#define ZSEEK64(filefunc,filestream,pos,mode)       (call_zseek64((&(filefunc)),(filestream),(pos),(mode)))
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif
-
diff --git a/Engine/lib/assimp/contrib/unzip/unzip.c b/Engine/lib/assimp/contrib/unzip/unzip.c
index fea6e8913..f1eddeeda 100644
--- a/Engine/lib/assimp/contrib/unzip/unzip.c
+++ b/Engine/lib/assimp/contrib/unzip/unzip.c
@@ -1,1058 +1,1040 @@
 /* unzip.c -- IO for uncompress .zip files using zlib
-   Version 1.01e, February 12th, 2005
+   Version 1.1, February 14h, 2010
+   part of the MiniZip project
 
-   Copyright (C) 1998-2005 Gilles Vollant
+   Copyright (C) 1998-2010 Gilles Vollant
+     http://www.winimage.com/zLibDll/minizip.html
+   Modifications of Unzip for Zip64
+     Copyright (C) 2007-2008 Even Rouault
+   Modifications for Zip64 support on both zip and unzip
+     Copyright (C) 2009-2010 Mathias Svensson
+     http://result42.com
+   Modifications for AES, PKWARE disk spanning
+     Copyright (C) 2010-2014 Nathan Moinvaziri
 
-   Read unzip.h for more info
+   This program is distributed under the terms of the same license as zlib.
+   See the accompanying LICENSE file for the full text of the license.
 */
 
-/* Decryption code comes from crypt.c by Info-ZIP but has been greatly reduced in terms of
-compatibility with older software. The following is from the original crypt.c. Code
-woven in by Terry Thorsen 1/2003.
-*/
-/*
-  Copyright (c) 1990-2000 Info-ZIP.  All rights reserved.
-
-  See the accompanying file LICENSE, version 2000-Apr-09 or later
-  (the contents of which are also included in zip.h) for terms of use.
-  If, for some reason, all these files are missing, the Info-ZIP license
-  also may be found at:  ftp://ftp.info-zip.org/pub/infozip/license.html
-*/
-/*
-  crypt.c (full version) by Info-ZIP.      Last revised:  [see crypt.h]
-
-  The encryption/decryption parts of this source code (as opposed to the
-  non-echoing password parts) were originally written in Europe.  The
-  whole source package can be freely distributed, including from the USA.
-  (Prior to January 2000, re-export from the US was a violation of US law.)
- */
-
-/*
-  This encryption code is a direct transcription of the algorithm from
-  Roger Schlafly, described by Phil Katz in the file appnote.txt.  This
-  file (appnote.txt) is distributed with the PKZIP program (even in the
-  version without encryption capabilities).
- */
-
-
 #include <stdio.h>
 #include <stdlib.h>
+#include <stdint.h>
 #include <string.h>
+#include <errno.h>
+
 #include "zlib.h"
 #include "unzip.h"
 
-#if ZLIB_VERNUM < 0x1270
-typedef unsigned long z_crc_t;
+#ifdef HAVE_AES
+#  define AES_METHOD          (99)
+#  define AES_PWVERIFYSIZE    (2)
+#  define AES_MAXSALTLENGTH   (16)
+#  define AES_AUTHCODESIZE    (10)
+#  define AES_HEADERSIZE      (11)
+#  define AES_KEYSIZE(mode)   (64 + (mode * 64))
+
+#  include "aes/aes.h"
+#  include "aes/fileenc.h"
+#endif
+#ifdef HAVE_APPLE_COMPRESSION
+#  include <compression.h>
 #endif
 
-#ifdef STDC
-#  include <stddef.h>
-#  include <string.h>
-#  include <stdlib.h>
-#endif
-#ifdef NO_ERRNO_H
-    extern int errno;
-#else
-#   include <errno.h>
+#ifndef NOUNCRYPT
+#  include "crypt.h"
 #endif
 
+#define DISKHEADERMAGIC             (0x08074b50)
+#define LOCALHEADERMAGIC            (0x04034b50)
+#define CENTRALHEADERMAGIC          (0x02014b50)
+#define ENDHEADERMAGIC              (0x06054b50)
+#define ZIP64ENDHEADERMAGIC         (0x06064b50)
+#define ZIP64ENDLOCHEADERMAGIC      (0x07064b50)
 
-#ifndef local
-#  define local static
+#define SIZECENTRALDIRITEM          (0x2e)
+#define SIZECENTRALHEADERLOCATOR    (0x14)
+#define SIZEZIPLOCALHEADER          (0x1e)
+
+#ifndef BUFREADCOMMENT
+#  define BUFREADCOMMENT            (0x400)
 #endif
-/* compile with -Dlocal if your debugger can't find static symbols */
-
-
-#ifndef CASESENSITIVITYDEFAULT_NO
-#  if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES)
-#    define CASESENSITIVITYDEFAULT_NO
-#  endif
-#endif
-
 
 #ifndef UNZ_BUFSIZE
-#define UNZ_BUFSIZE (16384)
+#  define UNZ_BUFSIZE               (UINT16_MAX)
 #endif
-
 #ifndef UNZ_MAXFILENAMEINZIP
-#define UNZ_MAXFILENAMEINZIP (256)
+#  define UNZ_MAXFILENAMEINZIP      (256)
 #endif
 
 #ifndef ALLOC
-# define ALLOC(size) (malloc(size))
+#  define ALLOC(size) (malloc(size))
 #endif
 #ifndef TRYFREE
-# define TRYFREE(p) {if (p) free(p);}
+#  define TRYFREE(p) {if (p) free(p);}
 #endif
 
-#define SIZECENTRALDIRITEM (0x2e)
-#define SIZEZIPLOCALHEADER (0x1e)
-
-
-
+#ifdef _WIN32
+#   pragma warning(push)
+#   pragma warning(disable : 4131 4244 4189 4245)
+#endif // _WIN32
 
 const char unz_copyright[] =
    " unzip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll";
 
-/* unz_file_info_interntal contain internal info about a file in zipfile*/
-typedef struct unz_file_info_internal_s
+/* unz_file_info_internal contain internal info about a file in zipfile*/
+typedef struct unz_file_info64_internal_s
 {
-    uLong offset_curfile;/* relative offset of local header 4 bytes */
-} unz_file_info_internal;
-
-
-/* file_in_zip_read_info_s contain internal information about a file in zipfile,
-    when reading and decompress it */
-typedef struct
-{
-    char  *read_buffer;         /* internal buffer for compressed data */
-    z_stream stream;            /* zLib stream structure for inflate */
-
-    uLong pos_in_zipfile;       /* position in byte on the zipfile, for fseek*/
-    uLong stream_initialised;   /* flag set if stream structure is initialised*/
-
-    uLong offset_local_extrafield;/* offset of the local extra field */
-    uInt  size_local_extrafield;/* size of the local extra field */
-    uLong pos_local_extrafield;   /* position in the local extra field in read*/
-
-    uLong crc32;                /* crc32 of all data uncompressed */
-    uLong crc32_wait;           /* crc32 we must obtain after decompress all */
-    uLong rest_read_compressed; /* number of byte to be decompressed */
-    uLong rest_read_uncompressed;/*number of byte to be obtained after decomp*/
-    zlib_filefunc_def z_filefunc;
-    voidpf filestream;        /* io structore of the zipfile */
-    uLong compression_method;   /* compression method (0==store) */
-    uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
-    int   raw;
-} file_in_zip_read_info_s;
-
-
-/* unz_s contain internal information about the zipfile
-*/
-typedef struct
-{
-    zlib_filefunc_def z_filefunc;
-    voidpf filestream;        /* io structore of the zipfile */
-    unz_global_info gi;       /* public global information */
-    uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
-    uLong num_file;             /* number of the current file in the zipfile*/
-    uLong pos_in_central_dir;   /* pos of the current file in the central dir*/
-    uLong current_file_ok;      /* flag about the usability of the current file*/
-    uLong central_pos;          /* position of the beginning of the central dir*/
-
-    uLong size_central_dir;     /* size of the central directory  */
-    uLong offset_central_dir;   /* offset of start of central directory with
-                                   respect to the starting disk number */
-
-    unz_file_info cur_file_info; /* public info about the current file in zip*/
-    unz_file_info_internal cur_file_info_internal; /* private info about it*/
-    file_in_zip_read_info_s* pfile_in_zip_read; /* structure about the current
-                                        file if we are decompressing it */
-    int encrypted;
-#    ifndef NOUNCRYPT
-    unsigned long keys[3];     /* keys defining the pseudo-random sequence */
-    const z_crc_t* pcrc_32_tab;
-#    endif
-} unz_s;
-
-
-#ifndef NOUNCRYPT
-#include "crypt.h"
+    uint64_t offset_curfile;            /* relative offset of local header 8 bytes */
+    uint64_t byte_before_the_zipfile;   /* byte before the zipfile, (>0 for sfx) */
+#ifdef HAVE_AES
+    uint8_t  aes_encryption_mode;
+    uint16_t aes_compression_method;
+    uint16_t aes_version;
 #endif
+} unz_file_info64_internal;
 
-/* ===========================================================================
-     Read a byte from a gz_stream; update next_in and avail_in. Return EOF
-   for end of file.
-   IN assertion: the stream s has been sucessfully opened for reading.
-*/
-
-
-local int unzlocal_getByte OF((
-    const zlib_filefunc_def* pzlib_filefunc_def,
-    voidpf filestream,
-    int *pi));
-
-local int unzlocal_getByte(pzlib_filefunc_def,filestream,pi)
-    const zlib_filefunc_def* pzlib_filefunc_def;
-    voidpf filestream;
-    int *pi;
+/* file_in_zip_read_info_s contain internal information about a file in zipfile */
+typedef struct
 {
-    unsigned char c;
-    int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1);
-    if (err==1)
+    uint8_t *read_buffer;               /* internal buffer for compressed data */
+    z_stream stream;                    /* zLib stream structure for inflate */
+#ifdef HAVE_BZIP2
+    bz_stream bstream;                  /* bzLib stream structure for bziped */
+#endif
+#ifdef HAVE_APPLE_COMPRESSION
+    compression_stream astream;         /* libcompression stream structure */
+#endif
+#ifdef HAVE_AES
+    fcrypt_ctx aes_ctx;
+#endif
+    uint64_t pos_in_zipfile;            /* position in byte on the zipfile, for fseek */
+    uint8_t  stream_initialised;        /* flag set if stream structure is initialised */
+
+    uint64_t offset_local_extrafield;   /* offset of the local extra field */
+    uint16_t size_local_extrafield;     /* size of the local extra field */
+    uint64_t pos_local_extrafield;      /* position in the local extra field in read */
+    uint64_t total_out_64;
+
+    uint32_t crc32;                     /* crc32 of all data uncompressed */
+    uint32_t crc32_wait;                /* crc32 we must obtain after decompress all */
+    uint64_t rest_read_compressed;      /* number of byte to be decompressed */
+    uint64_t rest_read_uncompressed;    /* number of byte to be obtained after decomp */
+
+    zlib_filefunc64_32_def z_filefunc;
+
+    voidpf   filestream;                /* io structore of the zipfile */
+    uint16_t compression_method;        /* compression method (0==store) */
+    uint64_t byte_before_the_zipfile;   /* byte before the zipfile, (>0 for sfx) */
+    int      raw;
+} file_in_zip64_read_info_s;
+
+/* unz64_s contain internal information about the zipfile */
+typedef struct
+{
+    zlib_filefunc64_32_def z_filefunc;
+
+    voidpf filestream;                  /* io structure of the current zipfile */
+    voidpf filestream_with_CD;          /* io structure of the disk with the central directory */
+
+    unz_global_info64 gi;               /* public global information */
+
+    uint64_t byte_before_the_zipfile;   /* byte before the zipfile, (>0 for sfx) */
+    uint64_t num_file;                  /* number of the current file in the zipfile */
+    uint64_t pos_in_central_dir;        /* pos of the current file in the central dir */
+    uint64_t current_file_ok;           /* flag about the usability of the current file */
+    uint64_t central_pos;               /* position of the beginning of the central dir */
+    uint32_t number_disk;               /* number of the current disk, used for spanning ZIP */
+    uint64_t size_central_dir;          /* size of the central directory */
+    uint64_t offset_central_dir;        /* offset of start of central directory with
+                                           respect to the starting disk number */
+
+    unz_file_info64 cur_file_info;      /* public info about the current file in zip*/
+    unz_file_info64_internal cur_file_info_internal;
+                                        /* private info about it*/
+    file_in_zip64_read_info_s *pfile_in_zip_read;
+                                        /* structure about the current file if we are decompressing it */
+    int is_zip64;                       /* is the current file zip64 */
+#ifndef NOUNCRYPT
+    uint32_t keys[3];                   /* keys defining the pseudo-random sequence */
+    const z_crc_t *pcrc_32_tab;
+#endif
+} unz64_s;
+
+/* Read a byte from a gz_stream; Return EOF for end of file. */
+static int unzReadUInt8(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, uint8_t *value)
+{
+    uint8_t c = 0;
+    if (ZREAD64(*pzlib_filefunc_def, filestream, &c, 1) == 1)
     {
-        *pi = (int)c;
+        *value = (uint8_t)c;
         return UNZ_OK;
     }
-    else
-    {
-        if (ZERROR(*pzlib_filefunc_def,filestream))
-            return UNZ_ERRNO;
-        else
-            return UNZ_EOF;
-    }
+    *value = 0;
+    if (ZERROR64(*pzlib_filefunc_def, filestream))
+        return UNZ_ERRNO;
+    return UNZ_EOF;
 }
 
-
-/* ===========================================================================
-   Reads a long in LSB order from the given gz_stream. Sets
-*/
-local int unzlocal_getShort OF((
-    const zlib_filefunc_def* pzlib_filefunc_def,
-    voidpf filestream,
-    uLong *pX));
-
-local int unzlocal_getShort (pzlib_filefunc_def,filestream,pX)
-    const zlib_filefunc_def* pzlib_filefunc_def;
-    voidpf filestream;
-    uLong *pX;
+static int unzReadUInt16(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, uint16_t *value)
 {
-    uLong x ;
-    int i = 0;
-    int err;
+    uint16_t x;
+    uint8_t c = 0;
+    int err = UNZ_OK;
 
-    err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
-    x = (uLong)i;
+    err = unzReadUInt8(pzlib_filefunc_def, filestream, &c);
+    x = (uint16_t)c;
+    if (err == UNZ_OK)
+        err = unzReadUInt8(pzlib_filefunc_def, filestream, &c);
+    x |= ((uint16_t)c) << 8;
 
-    if (err==UNZ_OK)
-        err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
-    x += ((uLong)i)<<8;
-
-    if (err==UNZ_OK)
-        *pX = x;
+    if (err == UNZ_OK)
+        *value = x;
     else
-        *pX = 0;
+        *value = 0;
     return err;
 }
 
-local int unzlocal_getLong OF((
-    const zlib_filefunc_def* pzlib_filefunc_def,
-    voidpf filestream,
-    uLong *pX));
-
-local int unzlocal_getLong (pzlib_filefunc_def,filestream,pX)
-    const zlib_filefunc_def* pzlib_filefunc_def;
-    voidpf filestream;
-    uLong *pX;
+static int unzReadUInt32(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, uint32_t *value)
 {
-    uLong x ;
-    int i = 0;
-    int err;
+    uint32_t x = 0;
+    uint8_t c = 0;
+    int err = UNZ_OK;
 
-    err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
-    x = (uLong)i;
+    err = unzReadUInt8(pzlib_filefunc_def, filestream, &c);
+    x = (uint32_t)c;
+    if (err == UNZ_OK)
+        err = unzReadUInt8(pzlib_filefunc_def, filestream, &c);
+    x |= ((uint32_t)c) << 8;
+    if (err == UNZ_OK)
+        err = unzReadUInt8(pzlib_filefunc_def, filestream, &c);
+    x |= ((uint32_t)c) << 16;
+    if (err == UNZ_OK)
+        err = unzReadUInt8(pzlib_filefunc_def, filestream, &c);
+    x += ((uint32_t)c) << 24;
 
-    if (err==UNZ_OK)
-        err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
-    x += ((uLong)i)<<8;
-
-    if (err==UNZ_OK)
-        err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
-    x += ((uLong)i)<<16;
-
-    if (err==UNZ_OK)
-        err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
-    x += ((uLong)i)<<24;
-
-    if (err==UNZ_OK)
-        *pX = x;
+    if (err == UNZ_OK)
+        *value = x;
     else
-        *pX = 0;
+        *value = 0;
     return err;
 }
 
-
-/* My own strcmpi / strcasecmp */
-local int strcmpcasenosensitive_internal (fileName1,fileName2)
-    const char* fileName1;
-    const char* fileName2;
+static int unzReadUInt64(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, uint64_t *value)
 {
-    for (;;)
-    {
-        char c1=*(fileName1++);
-        char c2=*(fileName2++);
-        if ((c1>='a') && (c1<='z'))
-            c1 -= 0x20;
-        if ((c2>='a') && (c2<='z'))
-            c2 -= 0x20;
-        if (c1=='\0')
-            return ((c2=='\0') ? 0 : -1);
-        if (c2=='\0')
-            return 1;
-        if (c1<c2)
-            return -1;
-        if (c1>c2)
-            return 1;
-    }
+    uint64_t x = 0;
+    uint8_t i = 0;
+    int err = UNZ_OK;
+
+    err = unzReadUInt8(pzlib_filefunc_def, filestream, &i);
+    x = (uint64_t)i;
+    if (err == UNZ_OK)
+        err = unzReadUInt8(pzlib_filefunc_def, filestream, &i);
+    x |= ((uint64_t)i) << 8;
+    if (err == UNZ_OK)
+        err = unzReadUInt8(pzlib_filefunc_def, filestream, &i);
+    x |= ((uint64_t)i) << 16;
+    if (err == UNZ_OK)
+        err = unzReadUInt8(pzlib_filefunc_def, filestream, &i);
+    x |= ((uint64_t)i) << 24;
+    if (err == UNZ_OK)
+        err = unzReadUInt8(pzlib_filefunc_def, filestream, &i);
+    x |= ((uint64_t)i) << 32;
+    if (err == UNZ_OK)
+        err = unzReadUInt8(pzlib_filefunc_def, filestream, &i);
+    x |= ((uint64_t)i) << 40;
+    if (err == UNZ_OK)
+        err = unzReadUInt8(pzlib_filefunc_def, filestream, &i);
+    x |= ((uint64_t)i) << 48;
+    if (err == UNZ_OK)
+        err = unzReadUInt8(pzlib_filefunc_def, filestream, &i);
+    x |= ((uint64_t)i) << 56;
+
+    if (err == UNZ_OK)
+        *value = x;
+    else
+        *value = 0;
+    return err;
 }
 
-
-#ifdef  CASESENSITIVITYDEFAULT_NO
-#define CASESENSITIVITYDEFAULTVALUE 2
-#else
-#define CASESENSITIVITYDEFAULTVALUE 1
-#endif
-
-#ifndef STRCMPCASENOSENTIVEFUNCTION
-#define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal
-#endif
-
-/*
-   Compare two filename (fileName1,fileName2).
-   If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
-   If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
-                                                                or strcasecmp)
-   If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
-        (like 1 on Unix, 2 on Windows)
-
-*/
-extern int ZEXPORT unzStringFileNameCompare (fileName1,fileName2,iCaseSensitivity)
-    const char* fileName1;
-    const char* fileName2;
-    int iCaseSensitivity;
+/* Locate the Central directory of a zip file (at the end, just before the global comment) */
+static uint64_t unzSearchCentralDir(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream)
 {
-    if (iCaseSensitivity==0)
-        iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;
+    uint8_t buf[BUFREADCOMMENT + 4];
+    uint64_t file_size = 0;
+    uint64_t back_read = 4;
+    uint64_t max_back = UINT16_MAX; /* maximum size of global comment */
+    uint64_t pos_found = 0;
+    uint32_t read_size = 0;
+    uint64_t read_pos = 0;
+    uint32_t i = 0;
 
-    if (iCaseSensitivity==1)
-        return strcmp(fileName1,fileName2);
-
-    return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2);
-}
-
-#ifndef BUFREADCOMMENT
-#define BUFREADCOMMENT (0x400)
-#endif
-
-/*
-  Locate the Central directory of a zipfile (at the end, just before
-    the global comment)
-*/
-local uLong unzlocal_SearchCentralDir OF((
-    const zlib_filefunc_def* pzlib_filefunc_def,
-    voidpf filestream));
-
-local uLong unzlocal_SearchCentralDir(pzlib_filefunc_def,filestream)
-    const zlib_filefunc_def* pzlib_filefunc_def;
-    voidpf filestream;
-{
-    unsigned char* buf;
-    uLong uSizeFile;
-    uLong uBackRead;
-    uLong uMaxBack=0xffff; /* maximum size of global comment */
-    uLong uPosFound=0;
-
-    if (ZSEEK(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
+    if (ZSEEK64(*pzlib_filefunc_def, filestream, 0, ZLIB_FILEFUNC_SEEK_END) != 0)
         return 0;
 
+    file_size = ZTELL64(*pzlib_filefunc_def, filestream);
 
-    uSizeFile = ZTELL(*pzlib_filefunc_def,filestream);
+    if (max_back > file_size)
+        max_back = file_size;
 
-    if (uMaxBack>uSizeFile)
-        uMaxBack = uSizeFile;
-
-    buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
-    if (buf==NULL)
-        return 0;
-
-    uBackRead = 4;
-    while (uBackRead<uMaxBack)
+    while (back_read < max_back)
     {
-        uLong uReadSize,uReadPos ;
-        int i;
-        if (uBackRead+BUFREADCOMMENT>uMaxBack)
-            uBackRead = uMaxBack;
+        if (back_read + BUFREADCOMMENT > max_back)
+            back_read = max_back;
         else
-            uBackRead+=BUFREADCOMMENT;
-        uReadPos = uSizeFile-uBackRead ;
+            back_read += BUFREADCOMMENT;
 
-        uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
-                     (BUFREADCOMMENT+4) : (uSizeFile-uReadPos);
-        if (ZSEEK(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
+        read_pos = file_size - back_read;
+        read_size = ((BUFREADCOMMENT + 4) < (file_size - read_pos)) ?
+                     (BUFREADCOMMENT + 4) : (uint32_t)(file_size - read_pos);
+
+        if (ZSEEK64(*pzlib_filefunc_def, filestream, read_pos, ZLIB_FILEFUNC_SEEK_SET) != 0)
+            break;
+        if (ZREAD64(*pzlib_filefunc_def, filestream, buf, read_size) != read_size)
             break;
 
-        if (ZREAD(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
-            break;
-
-        for (i=(int)uReadSize-3; (i--)>0;)
-            if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
-                ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
+        for (i = read_size - 3; (i--) > 0;)
+            if (((*(buf+i)) == (ENDHEADERMAGIC & 0xff)) &&
+                ((*(buf+i+1)) == (ENDHEADERMAGIC >> 8 & 0xff)) &&
+                ((*(buf+i+2)) == (ENDHEADERMAGIC >> 16 & 0xff)) &&
+                ((*(buf+i+3)) == (ENDHEADERMAGIC >> 24 & 0xff)))
             {
-                uPosFound = uReadPos+i;
+                pos_found = read_pos+i;
                 break;
             }
 
-        if (uPosFound!=0)
+        if (pos_found != 0)
             break;
     }
-    TRYFREE(buf);
-    return uPosFound;
+
+    return pos_found;
 }
 
-/*
-  Open a Zip file. path contain the full pathname (by example,
-     on a Windows NT computer "c:\\test\\zlib114.zip" or on an Unix computer
-     "zlib/zlib114.zip".
-     If the zipfile cannot be opened (file doesn't exist or in not valid), the
-       return value is NULL.
-     Else, the return value is a unzFile Handle, usable with other function
-       of this unzip package.
-*/
-extern unzFile ZEXPORT unzOpen2 (path, pzlib_filefunc_def)
-    const char *path;
-    zlib_filefunc_def* pzlib_filefunc_def;
+/* Locate the Central directory 64 of a zipfile (at the end, just before the global comment) */
+static uint64_t unzSearchCentralDir64(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream,
+    const uint64_t endcentraloffset)
 {
-    unz_s us;
-    unz_s *s;
-    uLong central_pos,uL;
+    uint64_t offset = 0;
+    uint32_t value32 = 0;
 
-    uLong number_disk;          /* number of the current dist, used for
-                                   spaning ZIP, unsupported, always 0*/
-    uLong number_disk_with_CD;  /* number the the disk with central dir, used
-                                   for spaning ZIP, unsupported, always 0*/
-    uLong number_entry_CD;      /* total number of entries in
-                                   the central dir
-                                   (same than number_entry on nospan) */
+    /* Zip64 end of central directory locator */
+    if (ZSEEK64(*pzlib_filefunc_def, filestream, endcentraloffset - SIZECENTRALHEADERLOCATOR, ZLIB_FILEFUNC_SEEK_SET) != 0)
+        return 0;
 
-    int err=UNZ_OK;
+    /* Read locator signature */
+    if (unzReadUInt32(pzlib_filefunc_def, filestream, &value32) != UNZ_OK)
+        return 0;
+    if (value32 != ZIP64ENDLOCHEADERMAGIC)
+        return 0;
+    /* Number of the disk with the start of the zip64 end of  central directory */
+    if (unzReadUInt32(pzlib_filefunc_def, filestream, &value32) != UNZ_OK)
+        return 0;
+    /* Relative offset of the zip64 end of central directory record */
+    if (unzReadUInt64(pzlib_filefunc_def, filestream, &offset) != UNZ_OK)
+        return 0;
+    /* Total number of disks */
+    if (unzReadUInt32(pzlib_filefunc_def, filestream, &value32) != UNZ_OK)
+        return 0;
+    /* Goto end of central directory record */
+    if (ZSEEK64(*pzlib_filefunc_def, filestream, offset, ZLIB_FILEFUNC_SEEK_SET) != 0)
+        return 0;
+     /* The signature */
+    if (unzReadUInt32(pzlib_filefunc_def, filestream, &value32) != UNZ_OK)
+        return 0;
+    if (value32 != ZIP64ENDHEADERMAGIC)
+        return 0;
 
-    if (unz_copyright[0]!=' ')
+    return offset;
+}
+
+static unzFile unzOpenInternal(const void *path, zlib_filefunc64_32_def *pzlib_filefunc64_32_def)
+{
+    unz64_s us;
+    unz64_s *s = NULL;
+    uint64_t central_pos = 0;
+    uint64_t central_pos64 = 0;
+    uint64_t number_entry_CD = 0;
+    uint16_t value16 = 0;
+    uint32_t value32 = 0;
+    uint64_t value64 = 0;
+    voidpf filestream = NULL;
+    int err = UNZ_OK;
+
+    if (unz_copyright[0] != ' ')
         return NULL;
 
-    if (pzlib_filefunc_def==NULL)
-        fill_fopen_filefunc(&us.z_filefunc);
+    us.filestream = NULL;
+    us.filestream_with_CD = NULL;
+    us.z_filefunc.zseek32_file = NULL;
+    us.z_filefunc.ztell32_file = NULL;
+
+    if (pzlib_filefunc64_32_def == NULL)
+        fill_fopen64_filefunc(&us.z_filefunc.zfile_func64);
     else
-        us.z_filefunc = *pzlib_filefunc_def;
+        us.z_filefunc = *pzlib_filefunc64_32_def;
 
-    us.filestream= (*(us.z_filefunc.zopen_file))(us.z_filefunc.opaque,
-                                                 path,
-                                                 ZLIB_FILEFUNC_MODE_READ |
-                                                 ZLIB_FILEFUNC_MODE_EXISTING);
-    if (us.filestream==NULL)
+    us.filestream = ZOPEN64(us.z_filefunc, path, ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_EXISTING);
+
+    if (us.filestream == NULL)
         return NULL;
 
-    central_pos = unzlocal_SearchCentralDir(&us.z_filefunc,us.filestream);
-    if (central_pos==0)
-        err=UNZ_ERRNO;
+    us.filestream_with_CD = us.filestream;
+    us.is_zip64 = 0;
 
-    if (ZSEEK(us.z_filefunc, us.filestream,
-                                      central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
-        err=UNZ_ERRNO;
-
-    /* the signature, already checked */
-    if (unzlocal_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
-        err=UNZ_ERRNO;
-
-    /* number of this disk */
-    if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK)
-        err=UNZ_ERRNO;
-
-    /* number of the disk with the start of the central directory */
-    if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK)
-        err=UNZ_ERRNO;
-
-    /* total number of entries in the central dir on this disk */
-    if (unzlocal_getShort(&us.z_filefunc, us.filestream,&us.gi.number_entry)!=UNZ_OK)
-        err=UNZ_ERRNO;
-
-    /* total number of entries in the central dir */
-    if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_entry_CD)!=UNZ_OK)
-        err=UNZ_ERRNO;
-
-    if ((number_entry_CD!=us.gi.number_entry) ||
-        (number_disk_with_CD!=0) ||
-        (number_disk!=0))
-        err=UNZ_BADZIPFILE;
-
-    /* size of the central directory */
-    if (unzlocal_getLong(&us.z_filefunc, us.filestream,&us.size_central_dir)!=UNZ_OK)
-        err=UNZ_ERRNO;
-
-    /* offset of start of central directory with respect to the
-          starting disk number */
-    if (unzlocal_getLong(&us.z_filefunc, us.filestream,&us.offset_central_dir)!=UNZ_OK)
-        err=UNZ_ERRNO;
-
-    /* zipfile comment length */
-    if (unzlocal_getShort(&us.z_filefunc, us.filestream,&us.gi.size_comment)!=UNZ_OK)
-        err=UNZ_ERRNO;
-
-    if ((central_pos<us.offset_central_dir+us.size_central_dir) &&
-        (err==UNZ_OK))
-        err=UNZ_BADZIPFILE;
-
-    if (err!=UNZ_OK)
+    /* Search for end of central directory header */
+    central_pos = unzSearchCentralDir(&us.z_filefunc, us.filestream);
+    if (central_pos)
     {
-        ZCLOSE(us.z_filefunc, us.filestream);
+        if (ZSEEK64(us.z_filefunc, us.filestream, central_pos, ZLIB_FILEFUNC_SEEK_SET) != 0)
+            err = UNZ_ERRNO;
+
+        /* The signature, already checked */
+        if (unzReadUInt32(&us.z_filefunc, us.filestream, &value32) != UNZ_OK)
+            err = UNZ_ERRNO;
+        /* Number of this disk */
+        if (unzReadUInt16(&us.z_filefunc, us.filestream, &value16) != UNZ_OK)
+            err = UNZ_ERRNO;
+        us.number_disk = value16;
+        /* Number of the disk with the start of the central directory */
+        if (unzReadUInt16(&us.z_filefunc, us.filestream, &value16) != UNZ_OK)
+            err = UNZ_ERRNO;
+        us.gi.number_disk_with_CD = value16;
+        /* Total number of entries in the central directory on this disk */
+        if (unzReadUInt16(&us.z_filefunc, us.filestream, &value16) != UNZ_OK)
+            err = UNZ_ERRNO;
+        us.gi.number_entry = value16;
+        /* Total number of entries in the central directory */
+        if (unzReadUInt16(&us.z_filefunc, us.filestream, &value16) != UNZ_OK)
+            err = UNZ_ERRNO;
+        number_entry_CD = value16;
+        if (number_entry_CD != us.gi.number_entry)
+            err = UNZ_BADZIPFILE;
+        /* Size of the central directory */
+        if (unzReadUInt32(&us.z_filefunc, us.filestream, &value32) != UNZ_OK)
+            err = UNZ_ERRNO;
+        us.size_central_dir = value32;
+        /* Offset of start of central directory with respect to the starting disk number */
+        if (unzReadUInt32(&us.z_filefunc, us.filestream, &value32) != UNZ_OK)
+            err = UNZ_ERRNO;
+        us.offset_central_dir = value32;
+        /* Zipfile comment length */
+        if (unzReadUInt16(&us.z_filefunc, us.filestream, &us.gi.size_comment) != UNZ_OK)
+            err = UNZ_ERRNO;
+
+        if (err == UNZ_OK)
+        {
+            /* Search for Zip64 end of central directory header */
+            central_pos64 = unzSearchCentralDir64(&us.z_filefunc, us.filestream, central_pos);
+            if (central_pos64)
+            {
+                central_pos = central_pos64;
+                us.is_zip64 = 1;
+
+                if (ZSEEK64(us.z_filefunc, us.filestream, central_pos, ZLIB_FILEFUNC_SEEK_SET) != 0)
+                    err = UNZ_ERRNO;
+
+                /* the signature, already checked */
+                if (unzReadUInt32(&us.z_filefunc, us.filestream, &value32) != UNZ_OK)
+                    err = UNZ_ERRNO;
+                /* size of zip64 end of central directory record */
+                if (unzReadUInt64(&us.z_filefunc, us.filestream, &value64) != UNZ_OK)
+                    err = UNZ_ERRNO;
+                /* version made by */
+                if (unzReadUInt16(&us.z_filefunc, us.filestream, &value16) != UNZ_OK)
+                    err = UNZ_ERRNO;
+                /* version needed to extract */
+                if (unzReadUInt16(&us.z_filefunc, us.filestream, &value16) != UNZ_OK)
+                    err = UNZ_ERRNO;
+                /* number of this disk */
+                if (unzReadUInt32(&us.z_filefunc, us.filestream, &us.number_disk) != UNZ_OK)
+                    err = UNZ_ERRNO;
+                /* number of the disk with the start of the central directory */
+                if (unzReadUInt32(&us.z_filefunc, us.filestream, &us.gi.number_disk_with_CD) != UNZ_OK)
+                    err = UNZ_ERRNO;
+                /* total number of entries in the central directory on this disk */
+                if (unzReadUInt64(&us.z_filefunc, us.filestream, &us.gi.number_entry) != UNZ_OK)
+                    err = UNZ_ERRNO;
+                /* total number of entries in the central directory */
+                if (unzReadUInt64(&us.z_filefunc, us.filestream, &number_entry_CD) != UNZ_OK)
+                    err = UNZ_ERRNO;
+                if (number_entry_CD != us.gi.number_entry)
+                    err = UNZ_BADZIPFILE;
+                /* size of the central directory */
+                if (unzReadUInt64(&us.z_filefunc, us.filestream, &us.size_central_dir) != UNZ_OK)
+                    err = UNZ_ERRNO;
+                /* offset of start of central directory with respect to the starting disk number */
+                if (unzReadUInt64(&us.z_filefunc, us.filestream, &us.offset_central_dir) != UNZ_OK)
+                    err = UNZ_ERRNO;
+            }
+            else if ((us.gi.number_entry == UINT16_MAX) || (us.size_central_dir == UINT16_MAX) || (us.offset_central_dir == UINT32_MAX))
+                err = UNZ_BADZIPFILE;
+        }
+    }
+    else
+        err = UNZ_ERRNO;
+
+    if ((err == UNZ_OK) && (central_pos < us.offset_central_dir + us.size_central_dir))
+        err = UNZ_BADZIPFILE;
+
+    if (err != UNZ_OK)
+    {
+        ZCLOSE64(us.z_filefunc, us.filestream);
         return NULL;
     }
 
-    us.byte_before_the_zipfile = central_pos -
-                            (us.offset_central_dir+us.size_central_dir);
+    if (us.gi.number_disk_with_CD == 0)
+    {
+        /* If there is only one disk open another stream so we don't have to seek between the CD
+           and the file headers constantly */
+        filestream = ZOPEN64(us.z_filefunc, path, ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_EXISTING);
+        if (filestream != NULL)
+            us.filestream = filestream;
+    }
+
+    /* Hack for zip files that have no respect for zip64
+    if ((central_pos > 0xffffffff) && (us.offset_central_dir < 0xffffffff))
+        us.offset_central_dir = central_pos - us.size_central_dir;*/
+
+    us.byte_before_the_zipfile = central_pos - (us.offset_central_dir + us.size_central_dir);
     us.central_pos = central_pos;
     us.pfile_in_zip_read = NULL;
-    us.encrypted = 0;
 
-
-    s=(unz_s*)ALLOC(sizeof(unz_s));
-    *s=us;
-    unzGoToFirstFile((unzFile)s);
+    s = (unz64_s*)ALLOC(sizeof(unz64_s));
+    if (s != NULL)
+    {
+        *s = us;
+        unzGoToFirstFile((unzFile)s);
+    }
     return (unzFile)s;
 }
 
-
-extern unzFile ZEXPORT unzOpen (path)
-    const char *path;
+extern unzFile ZEXPORT unzOpen2(const char *path, zlib_filefunc_def *pzlib_filefunc32_def)
 {
-    return unzOpen2(path, NULL);
+    if (pzlib_filefunc32_def != NULL)
+    {
+        zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
+        fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill, pzlib_filefunc32_def);
+        return unzOpenInternal(path, &zlib_filefunc64_32_def_fill);
+    }
+    return unzOpenInternal(path, NULL);
 }
 
-/*
-  Close a ZipFile opened with unzipOpen.
-  If there is files inside the .Zip opened with unzipOpenCurrentFile (see later),
-    these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
-  return UNZ_OK if there is no problem. */
-extern int ZEXPORT unzClose (file)
-    unzFile file;
+extern unzFile ZEXPORT unzOpen2_64(const void *path, zlib_filefunc64_def *pzlib_filefunc_def)
 {
-    unz_s* s;
-    if (file==NULL)
-        return UNZ_PARAMERROR;
-    s=(unz_s*)file;
+    if (pzlib_filefunc_def != NULL)
+    {
+        zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
+        zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def;
+        zlib_filefunc64_32_def_fill.ztell32_file = NULL;
+        zlib_filefunc64_32_def_fill.zseek32_file = NULL;
+        return unzOpenInternal(path, &zlib_filefunc64_32_def_fill);
+    }
+    return unzOpenInternal(path, NULL);
+}
 
-    if (s->pfile_in_zip_read!=NULL)
+extern unzFile ZEXPORT unzOpen(const char *path)
+{
+    return unzOpenInternal(path, NULL);
+}
+
+extern unzFile ZEXPORT unzOpen64(const void *path)
+{
+    return unzOpenInternal(path, NULL);
+}
+
+extern int ZEXPORT unzClose(unzFile file)
+{
+    unz64_s *s;
+    if (file == NULL)
+        return UNZ_PARAMERROR;
+    s = (unz64_s*)file;
+
+    if (s->pfile_in_zip_read != NULL)
         unzCloseCurrentFile(file);
 
-    ZCLOSE(s->z_filefunc, s->filestream);
+    if ((s->filestream != NULL) && (s->filestream != s->filestream_with_CD))
+        ZCLOSE64(s->z_filefunc, s->filestream);
+    if (s->filestream_with_CD != NULL)
+        ZCLOSE64(s->z_filefunc, s->filestream_with_CD);
+
+    s->filestream = NULL;
+    s->filestream_with_CD = NULL;
     TRYFREE(s);
     return UNZ_OK;
 }
 
-
-/*
-  Write info about the ZipFile in the *pglobal_info structure.
-  No preparation of the structure is needed
-  return UNZ_OK if there is no problem. */
-extern int ZEXPORT unzGetGlobalInfo (file,pglobal_info)
-    unzFile file;
-    unz_global_info *pglobal_info;
+/* Goto to the next available disk for spanned archives */
+static int unzGoToNextDisk(unzFile file)
 {
-    unz_s* s;
-    if (file==NULL)
+    unz64_s *s;
+    uint32_t number_disk_next = 0;
+
+    s = (unz64_s*)file;
+    if (s == NULL)
         return UNZ_PARAMERROR;
-    s=(unz_s*)file;
-    *pglobal_info=s->gi;
-    return UNZ_OK;
-}
+    number_disk_next = s->number_disk;
 
-
-/*
-   Translate date/time from Dos format to tm_unz (readable more easilty)
-*/
-local void unzlocal_DosDateToTmuDate (ulDosDate, ptm)
-    uLong ulDosDate;
-    tm_unz* ptm;
-{
-    uLong uDate;
-    uDate = (uLong)(ulDosDate>>16);
-    ptm->tm_mday = (uInt)(uDate&0x1f) ;
-    ptm->tm_mon =  (uInt)((((uDate)&0x1E0)/0x20)-1) ;
-    ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ;
-
-    ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800);
-    ptm->tm_min =  (uInt) ((ulDosDate&0x7E0)/0x20) ;
-    ptm->tm_sec =  (uInt) (2*(ulDosDate&0x1f)) ;
-}
-
-/*
-  Get Info about the current file in the zipfile, with internal only info
-*/
-local int unzlocal_GetCurrentFileInfoInternal OF((unzFile file,
-                                                  unz_file_info *pfile_info,
-                                                  unz_file_info_internal
-                                                  *pfile_info_internal,
-                                                  char *szFileName,
-                                                  uLong fileNameBufferSize,
-                                                  void *extraField,
-                                                  uLong extraFieldBufferSize,
-                                                  char *szComment,
-                                                  uLong commentBufferSize));
-
-local int unzlocal_GetCurrentFileInfoInternal (file,
-                                              pfile_info,
-                                              pfile_info_internal,
-                                              szFileName, fileNameBufferSize,
-                                              extraField, extraFieldBufferSize,
-                                              szComment,  commentBufferSize)
-    unzFile file;
-    unz_file_info *pfile_info;
-    unz_file_info_internal *pfile_info_internal;
-    char *szFileName;
-    uLong fileNameBufferSize;
-    void *extraField;
-    uLong extraFieldBufferSize;
-    char *szComment;
-    uLong commentBufferSize;
-{
-    unz_s* s;
-    unz_file_info file_info;
-    unz_file_info_internal file_info_internal;
-    int err=UNZ_OK;
-    uLong uMagic;
-    long lSeek=0;
-
-    if (file==NULL)
-        return UNZ_PARAMERROR;
-    s=(unz_s*)file;
-    if (ZSEEK(s->z_filefunc, s->filestream,
-              s->pos_in_central_dir+s->byte_before_the_zipfile,
-              ZLIB_FILEFUNC_SEEK_SET)!=0)
-        err=UNZ_ERRNO;
-
-
-    /* we check the magic */
-    if (err==UNZ_OK)
-    {
-        if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
-        {
-            err=UNZ_ERRNO;
-        }
-        else if (uMagic!=0x02014b50)
-        {
-            err=UNZ_BADZIPFILE;
-        }
-    }
-
-    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.version) != UNZ_OK)
-        err=UNZ_ERRNO;
-
-    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.version_needed) != UNZ_OK)
-        err=UNZ_ERRNO;
-
-    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.flag) != UNZ_OK)
-        err=UNZ_ERRNO;
-
-    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.compression_method) != UNZ_OK)
-        err=UNZ_ERRNO;
-
-    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.dosDate) != UNZ_OK)
-        err=UNZ_ERRNO;
-
-    unzlocal_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date);
-
-    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.crc) != UNZ_OK)
-        err=UNZ_ERRNO;
-
-    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.compressed_size) != UNZ_OK)
-        err=UNZ_ERRNO;
-
-    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.uncompressed_size) != UNZ_OK)
-        err=UNZ_ERRNO;
-
-    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_filename) != UNZ_OK)
-        err=UNZ_ERRNO;
-
-    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_extra) != UNZ_OK)
-        err=UNZ_ERRNO;
-
-    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_comment) != UNZ_OK)
-        err=UNZ_ERRNO;
-
-    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.disk_num_start) != UNZ_OK)
-        err=UNZ_ERRNO;
-
-    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.internal_fa) != UNZ_OK)
-        err=UNZ_ERRNO;
-
-    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.external_fa) != UNZ_OK)
-        err=UNZ_ERRNO;
-
-    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info_internal.offset_curfile) != UNZ_OK)
-        err=UNZ_ERRNO;
-
-    lSeek+=file_info.size_filename;
-    if ((err==UNZ_OK) && (szFileName!=NULL))
-    {
-        uLong uSizeRead ;
-        if (file_info.size_filename<fileNameBufferSize)
-        {
-            *(szFileName+file_info.size_filename)='\0';
-            uSizeRead = file_info.size_filename;
-        }
-        else
-            uSizeRead = fileNameBufferSize;
-
-        if ((file_info.size_filename>0) && (fileNameBufferSize>0))
-            if (ZREAD(s->z_filefunc, s->filestream,szFileName,uSizeRead)!=uSizeRead)
-                err=UNZ_ERRNO;
-        lSeek -= uSizeRead;
-    }
-
-
-    if ((err==UNZ_OK) && (extraField!=NULL))
-    {
-        uLong uSizeRead ;
-        if (file_info.size_file_extra<extraFieldBufferSize)
-            uSizeRead = file_info.size_file_extra;
-        else
-            uSizeRead = extraFieldBufferSize;
-
-        if (lSeek!=0)
-        {
-            if (ZSEEK(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
-                lSeek=0;
-            else
-                err=UNZ_ERRNO;
-        }
-        if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0))
-            if (ZREAD(s->z_filefunc, s->filestream,extraField,uSizeRead)!=uSizeRead)
-                err=UNZ_ERRNO;
-        lSeek += file_info.size_file_extra - uSizeRead;
-    }
+    if ((s->pfile_in_zip_read != NULL) && (s->pfile_in_zip_read->rest_read_uncompressed > 0))
+        /* We are currently reading a file and we need the next sequential disk */
+        number_disk_next += 1;
     else
-    {
-        lSeek+=file_info.size_file_extra;
-    }
+        /* Goto the disk for the current file */
+        number_disk_next = s->cur_file_info.disk_num_start;
 
-    if ((err==UNZ_OK) && (szComment!=NULL))
+    if (number_disk_next != s->number_disk)
     {
-        uLong uSizeRead ;
-        if (file_info.size_file_comment<commentBufferSize)
+        /* Switch disks */
+        if ((s->filestream != NULL) && (s->filestream != s->filestream_with_CD))
+            ZCLOSE64(s->z_filefunc, s->filestream);
+
+        if (number_disk_next == s->gi.number_disk_with_CD)
         {
-            *(szComment+file_info.size_file_comment)='\0';
-            uSizeRead = file_info.size_file_comment;
+            s->filestream = s->filestream_with_CD;
         }
         else
         {
-            uSizeRead = commentBufferSize;
+            s->filestream = ZOPENDISK64(s->z_filefunc, s->filestream_with_CD, number_disk_next,
+                ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_EXISTING);
         }
 
-        if (lSeek!=0)
-        {
-            if (ZSEEK(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)!=0)
-                err=UNZ_ERRNO;
-        }
-        if ((file_info.size_file_comment>0) && (commentBufferSize>0))
-            if (ZREAD(s->z_filefunc, s->filestream,szComment,uSizeRead)!=uSizeRead)
-                err=UNZ_ERRNO;
+        if (s->filestream == NULL)
+            return UNZ_ERRNO;
+
+        s->number_disk = number_disk_next;
     }
-    else
-    {
-    }
-
-    if ((err==UNZ_OK) && (pfile_info!=NULL))
-        *pfile_info=file_info;
-
-    if ((err==UNZ_OK) && (pfile_info_internal!=NULL))
-        *pfile_info_internal=file_info_internal;
-
-    return err;
-}
-
-
-
-/*
-  Write info about the ZipFile in the *pglobal_info structure.
-  No preparation of the structure is needed
-  return UNZ_OK if there is no problem.
-*/
-extern int ZEXPORT unzGetCurrentFileInfo (file,
-                                          pfile_info,
-                                          szFileName, fileNameBufferSize,
-                                          extraField, extraFieldBufferSize,
-                                          szComment,  commentBufferSize)
-    unzFile file;
-    unz_file_info *pfile_info;
-    char *szFileName;
-    uLong fileNameBufferSize;
-    void *extraField;
-    uLong extraFieldBufferSize;
-    char *szComment;
-    uLong commentBufferSize;
-{
-    return unzlocal_GetCurrentFileInfoInternal(file,pfile_info,NULL,
-                                                szFileName,fileNameBufferSize,
-                                                extraField,extraFieldBufferSize,
-                                                szComment,commentBufferSize);
-}
-
-/*
-  Set the current file of the zipfile to the first file.
-  return UNZ_OK if there is no problem
-*/
-extern int ZEXPORT unzGoToFirstFile (file)
-    unzFile file;
-{
-    int err=UNZ_OK;
-    unz_s* s;
-    if (file==NULL)
-        return UNZ_PARAMERROR;
-    s=(unz_s*)file;
-    s->pos_in_central_dir=s->offset_central_dir;
-    s->num_file=0;
-    err=unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
-                                             &s->cur_file_info_internal,
-                                             NULL,0,NULL,0,NULL,0);
-    s->current_file_ok = (err == UNZ_OK);
-    return err;
-}
-
-/*
-  Set the current file of the zipfile to the next file.
-  return UNZ_OK if there is no problem
-  return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
-*/
-extern int ZEXPORT unzGoToNextFile (file)
-    unzFile file;
-{
-    unz_s* s;
-    int err;
-
-    if (file==NULL)
-        return UNZ_PARAMERROR;
-    s=(unz_s*)file;
-    if (!s->current_file_ok)
-        return UNZ_END_OF_LIST_OF_FILE;
-    if (s->gi.number_entry != 0xffff)    /* 2^16 files overflow hack */
-      if (s->num_file+1==s->gi.number_entry)
-        return UNZ_END_OF_LIST_OF_FILE;
-
-    s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
-            s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;
-    s->num_file++;
-    err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
-                                               &s->cur_file_info_internal,
-                                               NULL,0,NULL,0,NULL,0);
-    s->current_file_ok = (err == UNZ_OK);
-    return err;
-}
-
-
-/*
-  Try locate the file szFileName in the zipfile.
-  For the iCaseSensitivity signification, see unzipStringFileNameCompare
-
-  return value :
-  UNZ_OK if the file is found. It becomes the current file.
-  UNZ_END_OF_LIST_OF_FILE if the file is not found
-*/
-extern int ZEXPORT unzLocateFile (file, szFileName, iCaseSensitivity)
-    unzFile file;
-    const char *szFileName;
-    int iCaseSensitivity;
-{
-    unz_s* s;
-    int err;
-
-    /* We remember the 'current' position in the file so that we can jump
-     * back there if we fail.
-     */
-    unz_file_info cur_file_infoSaved;
-    unz_file_info_internal cur_file_info_internalSaved;
-    uLong num_fileSaved;
-    uLong pos_in_central_dirSaved;
-
-
-    if (file==NULL)
-        return UNZ_PARAMERROR;
-
-    if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP)
-        return UNZ_PARAMERROR;
-
-    s=(unz_s*)file;
-    if (!s->current_file_ok)
-        return UNZ_END_OF_LIST_OF_FILE;
-
-    /* Save the current state */
-    num_fileSaved = s->num_file;
-    pos_in_central_dirSaved = s->pos_in_central_dir;
-    cur_file_infoSaved = s->cur_file_info;
-    cur_file_info_internalSaved = s->cur_file_info_internal;
-
-    err = unzGoToFirstFile(file);
-
-    while (err == UNZ_OK)
-    {
-        char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];
-        err = unzGetCurrentFileInfo(file,NULL,
-                                    szCurrentFileName,sizeof(szCurrentFileName)-1,
-                                    NULL,0,NULL,0);
-        if (err == UNZ_OK)
-        {
-            if (unzStringFileNameCompare(szCurrentFileName,
-                                            szFileName,iCaseSensitivity)==0)
-                return UNZ_OK;
-            err = unzGoToNextFile(file);
-        }
-    }
-
-    /* We failed, so restore the state of the 'current file' to where we
-     * were.
-     */
-    s->num_file = num_fileSaved ;
-    s->pos_in_central_dir = pos_in_central_dirSaved ;
-    s->cur_file_info = cur_file_infoSaved;
-    s->cur_file_info_internal = cur_file_info_internalSaved;
-    return err;
-}
-
-
-/*
-///////////////////////////////////////////
-// Contributed by Ryan Haksi (mailto://cryogen@infoserve.net)
-// I need random access
-//
-// Further optimization could be realized by adding an ability
-// to cache the directory in memory. The goal being a single
-// comprehensive file read to put the file I need in a memory.
-*/
-
-/*
-typedef struct unz_file_pos_s
-{
-    uLong pos_in_zip_directory;   // offset in file
-    uLong num_of_file;            // # of file
-} unz_file_pos;
-*/
-
-extern int ZEXPORT unzGetFilePos(file, file_pos)
-    unzFile file;
-    unz_file_pos* file_pos;
-{
-    unz_s* s;
-
-    if (file==NULL || file_pos==NULL)
-        return UNZ_PARAMERROR;
-    s=(unz_s*)file;
-    if (!s->current_file_ok)
-        return UNZ_END_OF_LIST_OF_FILE;
-
-    file_pos->pos_in_zip_directory  = s->pos_in_central_dir;
-    file_pos->num_of_file           = s->num_file;
 
     return UNZ_OK;
 }
 
-extern int ZEXPORT unzGoToFilePos(file, file_pos)
-    unzFile file;
-    unz_file_pos* file_pos;
+extern int ZEXPORT unzGetGlobalInfo(unzFile file, unz_global_info* pglobal_info32)
 {
-    unz_s* s;
-    int err;
-
-    if (file==NULL || file_pos==NULL)
+    unz64_s *s = NULL;
+    if (file == NULL)
         return UNZ_PARAMERROR;
-    s=(unz_s*)file;
+    s = (unz64_s*)file;
 
-    /* jump to the right spot */
-    s->pos_in_central_dir = file_pos->pos_in_zip_directory;
-    s->num_file           = file_pos->num_of_file;
-
-    /* set the current file */
-    err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
-                                               &s->cur_file_info_internal,
-                                               NULL,0,NULL,0,NULL,0);
-    /* return results */
-    s->current_file_ok = (err == UNZ_OK);
-    return err;
+    pglobal_info32->number_entry = (uint32_t)s->gi.number_entry;
+    pglobal_info32->size_comment = s->gi.size_comment;
+    pglobal_info32->number_disk_with_CD = s->gi.number_disk_with_CD;
+    return UNZ_OK;
 }
 
-/*
-// Unzip Helper Functions - should be here?
-///////////////////////////////////////////
-*/
-
-/*
-  Read the local header of the current zipfile
-  Check the coherency of the local header and info in the end of central
-        directory about this file
-  store in *piSizeVar the size of extra info in local header
-        (filename and size of extra field data)
-*/
-local int unzlocal_CheckCurrentFileCoherencyHeader (s,piSizeVar,
-                                                    poffset_local_extrafield,
-                                                    psize_local_extrafield)
-    unz_s* s;
-    uInt* piSizeVar;
-    uLong *poffset_local_extrafield;
-    uInt  *psize_local_extrafield;
+extern int ZEXPORT unzGetGlobalInfo64(unzFile file, unz_global_info64 *pglobal_info)
 {
-    uLong uMagic,uData,uFlags;
-    uLong size_filename;
-    uLong size_extra_field;
-    int err=UNZ_OK;
+    unz64_s *s = NULL;
+    if (file == NULL)
+        return UNZ_PARAMERROR;
+    s = (unz64_s*)file;
+    *pglobal_info = s->gi;
+    return UNZ_OK;
+}
 
-    *piSizeVar = 0;
-    *poffset_local_extrafield = 0;
-    *psize_local_extrafield = 0;
+extern int ZEXPORT unzGetGlobalComment(unzFile file, char *comment, uint16_t comment_size)
+{
+    unz64_s *s = NULL;
+    uint16_t bytes_to_read = comment_size;
+    if (file == NULL)
+        return (int)UNZ_PARAMERROR;
+    s = (unz64_s*)file;
 
-    if (ZSEEK(s->z_filefunc, s->filestream,s->cur_file_info_internal.offset_curfile +
-                                s->byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0)
+    if (bytes_to_read > s->gi.size_comment)
+        bytes_to_read = s->gi.size_comment;
+
+    if (ZSEEK64(s->z_filefunc, s->filestream_with_CD, s->central_pos + 22, ZLIB_FILEFUNC_SEEK_SET) != 0)
         return UNZ_ERRNO;
 
-
-    if (err==UNZ_OK)
+    if (bytes_to_read > 0)
     {
-        if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
-            err=UNZ_ERRNO;
-        else if (uMagic!=0x04034b50)
-            err=UNZ_BADZIPFILE;
+        *comment = 0;
+        if (ZREAD64(s->z_filefunc, s->filestream_with_CD, comment, bytes_to_read) != bytes_to_read)
+            return UNZ_ERRNO;
     }
 
-    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
-        err=UNZ_ERRNO;
-/*
-    else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
-        err=UNZ_BADZIPFILE;
-*/
-    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uFlags) != UNZ_OK)
-        err=UNZ_ERRNO;
+    if ((comment != NULL) && (comment_size > s->gi.size_comment))
+        *(comment + s->gi.size_comment) = 0;
 
-    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
-        err=UNZ_ERRNO;
-    else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method))
-        err=UNZ_BADZIPFILE;
+    return (int)bytes_to_read;
+}
 
-    if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) &&
-                         (s->cur_file_info.compression_method!=Z_DEFLATED))
-        err=UNZ_BADZIPFILE;
+static int unzGetCurrentFileInfoField(unzFile file, uint32_t *seek, void *field, uint16_t field_size, uint16_t size_file_field, int null_terminated_field)
+{
+    unz64_s *s = NULL;
+    uint32_t bytes_to_read = 0;
+    int err = UNZ_OK;
 
-    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* date/time */
-        err=UNZ_ERRNO;
+    if (file == NULL)
+        return (int)UNZ_PARAMERROR;
+    s = (unz64_s*)file;
 
-    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* crc */
-        err=UNZ_ERRNO;
-    else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) &&
-                              ((uFlags & 8)==0))
-        err=UNZ_BADZIPFILE;
+    /* Read field */
+    if (field != NULL)
+    {
+        if (size_file_field < field_size)
+        {
+            if (null_terminated_field)
+                *((char *)field+size_file_field) = 0;
 
-    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size compr */
-        err=UNZ_ERRNO;
-    else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) &&
-                              ((uFlags & 8)==0))
-        err=UNZ_BADZIPFILE;
+            bytes_to_read = size_file_field;
+        }
+        else
+            bytes_to_read = field_size;
+        
+        if (*seek != 0)
+        {
+            if (ZSEEK64(s->z_filefunc, s->filestream_with_CD, *seek, ZLIB_FILEFUNC_SEEK_CUR) == 0)
+                *seek = 0;
+            else
+                err = UNZ_ERRNO;
+        }
+        
+        if ((size_file_field > 0) && (field_size > 0))
+        {
+            if (ZREAD64(s->z_filefunc, s->filestream_with_CD, field, bytes_to_read) != bytes_to_read)
+                err = UNZ_ERRNO;
+        }
+        *seek += size_file_field - bytes_to_read;
+    }
+    else
+    {
+        *seek += size_file_field;
+    }
 
-    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size uncompr */
-        err=UNZ_ERRNO;
-    else if ((err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) &&
-                              ((uFlags & 8)==0))
-        err=UNZ_BADZIPFILE;
+    return err;
+}
 
+/* Get info about the current file in the zipfile, with internal only info */
+static int unzGetCurrentFileInfoInternal(unzFile file, unz_file_info64 *pfile_info,
+    unz_file_info64_internal *pfile_info_internal, char *filename, uint16_t filename_size, void *extrafield,
+    uint16_t extrafield_size, char *comment, uint16_t comment_size)
+{
+    unz64_s *s = NULL;
+    unz_file_info64 file_info;
+    unz_file_info64_internal file_info_internal;
+    uint32_t magic = 0;
+    uint64_t current_pos = 0;
+    uint32_t seek = 0;
+    uint32_t extra_pos = 0;
+    uint16_t extra_header_id = 0;
+    uint16_t extra_data_size = 0;
+    uint16_t value16 = 0;
+    uint32_t value32 = 0;
+    uint64_t value64 = 0;
+    int err = UNZ_OK;
 
-    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&size_filename) != UNZ_OK)
-        err=UNZ_ERRNO;
-    else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename))
-        err=UNZ_BADZIPFILE;
+    if (file == NULL)
+        return UNZ_PARAMERROR;
+    s = (unz64_s*)file;
 
-    *piSizeVar += (uInt)size_filename;
+    if (ZSEEK64(s->z_filefunc, s->filestream_with_CD,
+            s->pos_in_central_dir + s->byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0)
+        err = UNZ_ERRNO;
 
-    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&size_extra_field) != UNZ_OK)
-        err=UNZ_ERRNO;
-    *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile +
-                                    SIZEZIPLOCALHEADER + size_filename;
-    *psize_local_extrafield = (uInt)size_extra_field;
+    /* Check the magic */
+    if (err == UNZ_OK)
+    {
+        if (unzReadUInt32(&s->z_filefunc, s->filestream_with_CD, &magic) != UNZ_OK)
+            err = UNZ_ERRNO;
+        else if (magic != CENTRALHEADERMAGIC)
+            err = UNZ_BADZIPFILE;
+    }
 
-    *piSizeVar += (uInt)size_extra_field;
+    /* Read central directory header */
+    if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &file_info.version) != UNZ_OK)
+        err = UNZ_ERRNO;
+    if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &file_info.version_needed) != UNZ_OK)
+        err = UNZ_ERRNO;
+    if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &file_info.flag) != UNZ_OK)
+        err = UNZ_ERRNO;
+    if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &file_info.compression_method) != UNZ_OK)
+        err = UNZ_ERRNO;
+    if (unzReadUInt32(&s->z_filefunc, s->filestream_with_CD, &file_info.dos_date) != UNZ_OK)
+        err = UNZ_ERRNO;
+    if (unzReadUInt32(&s->z_filefunc, s->filestream_with_CD, &file_info.crc) != UNZ_OK)
+        err = UNZ_ERRNO;
+    if (unzReadUInt32(&s->z_filefunc, s->filestream_with_CD, &value32) != UNZ_OK)
+        err = UNZ_ERRNO;
+    file_info.compressed_size = value32;
+    if (unzReadUInt32(&s->z_filefunc, s->filestream_with_CD, &value32) != UNZ_OK)
+        err = UNZ_ERRNO;
+    file_info.uncompressed_size = value32;
+    if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &file_info.size_filename) != UNZ_OK)
+        err = UNZ_ERRNO;
+    if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &file_info.size_file_extra) != UNZ_OK)
+        err = UNZ_ERRNO;
+    if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &file_info.size_file_comment) != UNZ_OK)
+        err = UNZ_ERRNO;
+    if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &value16) != UNZ_OK)
+        err = UNZ_ERRNO;
+    file_info.disk_num_start = value16;
+    if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &file_info.internal_fa) != UNZ_OK)
+        err = UNZ_ERRNO;
+    if (unzReadUInt32(&s->z_filefunc, s->filestream_with_CD, &file_info.external_fa) != UNZ_OK)
+        err = UNZ_ERRNO;
+    /* Relative offset of local header */
+    if (unzReadUInt32(&s->z_filefunc, s->filestream_with_CD, &value32) != UNZ_OK)
+        err = UNZ_ERRNO;
+
+    file_info.size_file_extra_internal = 0;
+    file_info.disk_offset = value32;
+    file_info_internal.offset_curfile = value32;
+#ifdef HAVE_AES
+    file_info_internal.aes_compression_method = 0;
+    file_info_internal.aes_encryption_mode = 0;
+    file_info_internal.aes_version = 0;
+#endif
+
+    if (err == UNZ_OK)
+        err = unzGetCurrentFileInfoField(file, &seek, filename, filename_size, file_info.size_filename, 1);
+
+    /* Read extrafield */
+    if (err == UNZ_OK)
+        err = unzGetCurrentFileInfoField(file, &seek, extrafield, extrafield_size, file_info.size_file_extra, 0);
+
+    if ((err == UNZ_OK) && (file_info.size_file_extra != 0))
+    {
+        if (seek != 0)
+        {
+            if (ZSEEK64(s->z_filefunc, s->filestream_with_CD, seek, ZLIB_FILEFUNC_SEEK_CUR) == 0)
+                seek = 0;
+            else
+                err = UNZ_ERRNO;
+        }
+
+        /* We are going to parse the extra field so we need to move back */
+        current_pos = ZTELL64(s->z_filefunc, s->filestream_with_CD);
+        if (current_pos < file_info.size_file_extra)
+            err = UNZ_ERRNO;
+        current_pos -= file_info.size_file_extra;
+        if (ZSEEK64(s->z_filefunc, s->filestream_with_CD, current_pos, ZLIB_FILEFUNC_SEEK_SET) != 0)
+            err = UNZ_ERRNO;
+
+        while ((err != UNZ_ERRNO) && (extra_pos < file_info.size_file_extra))
+        {
+            if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &extra_header_id) != UNZ_OK)
+                err = UNZ_ERRNO;
+            if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &extra_data_size) != UNZ_OK)
+                err = UNZ_ERRNO;
+
+            /* ZIP64 extra fields */
+            if (extra_header_id == 0x0001)
+            {
+                /* Subtract size of ZIP64 field, since ZIP64 is handled internally */
+                file_info.size_file_extra_internal += 2 + 2 + extra_data_size;
+
+                if (file_info.uncompressed_size == UINT32_MAX)
+                {
+                    if (unzReadUInt64(&s->z_filefunc, s->filestream_with_CD, &file_info.uncompressed_size) != UNZ_OK)
+                        err = UNZ_ERRNO;
+                }
+                if (file_info.compressed_size == UINT32_MAX)
+                {
+                    if (unzReadUInt64(&s->z_filefunc, s->filestream_with_CD, &file_info.compressed_size) != UNZ_OK)
+                        err = UNZ_ERRNO;
+                }
+                if (file_info_internal.offset_curfile == UINT32_MAX)
+                {
+                    /* Relative Header offset */
+                    if (unzReadUInt64(&s->z_filefunc, s->filestream_with_CD, &value64) != UNZ_OK)
+                        err = UNZ_ERRNO;
+                    file_info_internal.offset_curfile = value64;
+                    file_info.disk_offset = value64;
+                }
+                if (file_info.disk_num_start == UINT32_MAX)
+                {
+                    /* Disk Start Number */
+                    if (unzReadUInt32(&s->z_filefunc, s->filestream_with_CD, &file_info.disk_num_start) != UNZ_OK)
+                        err = UNZ_ERRNO;
+                }
+            }
+#ifdef HAVE_AES
+            /* AES header */
+            else if (extra_header_id == 0x9901)
+            {
+                uint8_t value8 = 0;
+
+                /* Subtract size of AES field, since AES is handled internally */
+                file_info.size_file_extra_internal += 2 + 2 + extra_data_size;
+
+                /* Verify version info */
+                if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &value16) != UNZ_OK)
+                    err = UNZ_ERRNO;
+                /* Support AE-1 and AE-2 */
+                if (value16 != 1 && value16 != 2)
+                    err = UNZ_ERRNO;
+                file_info_internal.aes_version = value16;
+                if (unzReadUInt8(&s->z_filefunc, s->filestream_with_CD, &value8) != UNZ_OK)
+                    err = UNZ_ERRNO;
+                if ((char)value8 != 'A')
+                    err = UNZ_ERRNO;
+                if (unzReadUInt8(&s->z_filefunc, s->filestream_with_CD, &value8) != UNZ_OK)
+                    err = UNZ_ERRNO;
+                if ((char)value8 != 'E')
+                    err = UNZ_ERRNO;
+                /* Get AES encryption strength and actual compression method */
+                if (unzReadUInt8(&s->z_filefunc, s->filestream_with_CD, &value8) != UNZ_OK)
+                    err = UNZ_ERRNO;
+                file_info_internal.aes_encryption_mode = value8;
+                if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &value16) != UNZ_OK)
+                    err = UNZ_ERRNO;
+                file_info_internal.aes_compression_method = value16;
+            }
+#endif
+            else
+            {
+                if (ZSEEK64(s->z_filefunc, s->filestream_with_CD,extra_data_size, ZLIB_FILEFUNC_SEEK_CUR) != 0)
+                    err = UNZ_ERRNO;
+            }
+
+            extra_pos += 2 + 2 + extra_data_size;
+        }
+    }
+
+    if (file_info.disk_num_start == s->gi.number_disk_with_CD)
+        file_info_internal.byte_before_the_zipfile = s->byte_before_the_zipfile;
+    else
+        file_info_internal.byte_before_the_zipfile = 0;
+
+    if (err == UNZ_OK)
+        err = unzGetCurrentFileInfoField(file, &seek, comment, comment_size, file_info.size_file_comment, 1);
+
+    if ((err == UNZ_OK) && (pfile_info != NULL))
+        *pfile_info = file_info;
+    if ((err == UNZ_OK) && (pfile_info_internal != NULL))
+        *pfile_info_internal = file_info_internal;
+
+    return err;
+}
+
+extern int ZEXPORT unzGetCurrentFileInfo(unzFile file, unz_file_info *pfile_info, char *filename,
+    uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size)
+{
+    unz_file_info64 file_info64;
+    int err = UNZ_OK;
+
+    err = unzGetCurrentFileInfoInternal(file, &file_info64, NULL, filename, filename_size,
+                extrafield, extrafield_size, comment, comment_size);
+
+    if ((err == UNZ_OK) && (pfile_info != NULL))
+    {
+        pfile_info->version = file_info64.version;
+        pfile_info->version_needed = file_info64.version_needed;
+        pfile_info->flag = file_info64.flag;
+        pfile_info->compression_method = file_info64.compression_method;
+        pfile_info->dos_date = file_info64.dos_date;
+        pfile_info->crc = file_info64.crc;
+
+        pfile_info->size_filename = file_info64.size_filename;
+        pfile_info->size_file_extra = file_info64.size_file_extra - file_info64.size_file_extra_internal;
+        pfile_info->size_file_comment = file_info64.size_file_comment;
+
+        pfile_info->disk_num_start = (uint16_t)file_info64.disk_num_start;
+        pfile_info->internal_fa = file_info64.internal_fa;
+        pfile_info->external_fa = file_info64.external_fa;
+
+        pfile_info->compressed_size = (uint32_t)file_info64.compressed_size;
+        pfile_info->uncompressed_size = (uint32_t)file_info64.uncompressed_size;
+    }
+    return err;
+}
+
+extern int ZEXPORT unzGetCurrentFileInfo64(unzFile file, unz_file_info64 * pfile_info, char *filename,
+    uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size)
+{
+    return unzGetCurrentFileInfoInternal(file, pfile_info, NULL, filename, filename_size,
+        extrafield, extrafield_size, comment,comment_size);
+}
+
+/* Read the local header of the current zipfile. Check the coherency of the local header and info in the
+   end of central directory about this file store in *piSizeVar the size of extra info in local header
+   (filename and size of extra field data) */
+static int unzCheckCurrentFileCoherencyHeader(unz64_s *s, uint32_t *psize_variable, uint64_t *poffset_local_extrafield,
+    uint16_t *psize_local_extrafield)
+{
+    uint32_t magic = 0;
+    uint16_t value16 = 0;
+    uint32_t value32 = 0;
+    uint32_t flags = 0;
+    uint16_t size_filename = 0;
+    uint16_t size_extra_field = 0;
+    uint16_t compression_method = 0;
+    int err = UNZ_OK;
+
+    if (psize_variable == NULL)
+        return UNZ_PARAMERROR;
+    *psize_variable = 0;
+    if (poffset_local_extrafield == NULL)
+        return UNZ_PARAMERROR;
+    *poffset_local_extrafield = 0;
+    if (psize_local_extrafield == NULL)
+        return UNZ_PARAMERROR;
+    *psize_local_extrafield = 0;
+
+    err = unzGoToNextDisk((unzFile)s);
+    if (err != UNZ_OK)
+        return err;
+
+    if (ZSEEK64(s->z_filefunc, s->filestream, s->cur_file_info_internal.offset_curfile +
+        s->cur_file_info_internal.byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0)
+        return UNZ_ERRNO;
+
+    if (err == UNZ_OK)
+    {
+        if (unzReadUInt32(&s->z_filefunc, s->filestream, &magic) != UNZ_OK)
+            err = UNZ_ERRNO;
+        else if (magic != LOCALHEADERMAGIC)
+            err = UNZ_BADZIPFILE;
+    }
+
+    if (unzReadUInt16(&s->z_filefunc, s->filestream, &value16) != UNZ_OK)
+        err = UNZ_ERRNO;
+    if (unzReadUInt16(&s->z_filefunc, s->filestream, &value16) != UNZ_OK)
+        err = UNZ_ERRNO;
+    flags = value16;
+    if (unzReadUInt16(&s->z_filefunc, s->filestream, &value16) != UNZ_OK)
+        err = UNZ_ERRNO;
+    else if ((err == UNZ_OK) && (value16 != s->cur_file_info.compression_method))
+        err = UNZ_BADZIPFILE;
+
+    compression_method = s->cur_file_info.compression_method;
+#ifdef HAVE_AES
+    if (compression_method == AES_METHOD)
+        compression_method = s->cur_file_info_internal.aes_compression_method;
+#endif
+
+    if ((err == UNZ_OK) && (compression_method != 0) && (compression_method != Z_DEFLATED))
+    {
+#ifdef HAVE_BZIP2
+        if (compression_method != Z_BZIP2ED)
+#endif
+            err = UNZ_BADZIPFILE;
+    }
+
+    if (unzReadUInt32(&s->z_filefunc, s->filestream, &value32) != UNZ_OK) /* date/time */
+        err = UNZ_ERRNO;
+    if (unzReadUInt32(&s->z_filefunc, s->filestream, &value32) != UNZ_OK) /* crc */
+        err = UNZ_ERRNO;
+    else if ((err == UNZ_OK) && (value32 != s->cur_file_info.crc) && ((flags & 8) == 0))
+        err = UNZ_BADZIPFILE;
+    if (unzReadUInt32(&s->z_filefunc, s->filestream, &value32) != UNZ_OK) /* size compr */
+        err = UNZ_ERRNO;
+    else if ((value32 != UINT32_MAX) && (err == UNZ_OK) && (value32 != s->cur_file_info.compressed_size) && ((flags & 8) == 0))
+        err = UNZ_BADZIPFILE;
+    if (unzReadUInt32(&s->z_filefunc, s->filestream, &value32) != UNZ_OK) /* size uncompr */
+        err = UNZ_ERRNO;
+    else if ((value32 != UINT32_MAX) && (err == UNZ_OK) && (value32 != s->cur_file_info.uncompressed_size) && ((flags & 8) == 0))
+        err = UNZ_BADZIPFILE;
+    if (unzReadUInt16(&s->z_filefunc, s->filestream, &size_filename) != UNZ_OK)
+        err = UNZ_ERRNO;
+    else if ((err == UNZ_OK) && (size_filename != s->cur_file_info.size_filename))
+        err = UNZ_BADZIPFILE;
+
+    *psize_variable += size_filename;
+
+    if (unzReadUInt16(&s->z_filefunc, s->filestream, &size_extra_field) != UNZ_OK)
+        err = UNZ_ERRNO;
+
+    *poffset_local_extrafield = s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER + size_filename;
+    *psize_local_extrafield = size_extra_field;
+    *psize_variable += size_extra_field;
 
     return err;
 }
@@ -1061,62 +1043,68 @@ local int unzlocal_CheckCurrentFileCoherencyHeader (s,piSizeVar,
   Open for reading data the current file in the zipfile.
   If there is no error and the file is opened, the return value is UNZ_OK.
 */
-extern int ZEXPORT unzOpenCurrentFile3 (file, method, level, raw, password)
-    unzFile file;
-    int* method;
-    int* level;
-    int raw;
-    const char* password;
+extern int ZEXPORT unzOpenCurrentFile3(unzFile file, int *method, int *level, int raw, const char *password)
 {
-    int err=UNZ_OK;
-    uInt iSizeVar;
-    unz_s* s;
-    file_in_zip_read_info_s* pfile_in_zip_read_info;
-    uLong offset_local_extrafield;  /* offset of the local extra field */
-    uInt  size_local_extrafield;    /* size of the local extra field */
-#    ifndef NOUNCRYPT
+    unz64_s *s = NULL;
+    file_in_zip64_read_info_s *pfile_in_zip_read_info = NULL;
+    uint16_t compression_method = 0;
+    uint64_t offset_local_extrafield = 0;
+    uint16_t size_local_extrafield = 0;
+    uint32_t size_variable = 0;
+    int err = UNZ_OK;
+#ifndef NOUNCRYPT
     char source[12];
-#    else
+#else
     if (password != NULL)
         return UNZ_PARAMERROR;
-#    endif
-
-    if (file==NULL)
+#endif
+    if (file == NULL)
         return UNZ_PARAMERROR;
-    s=(unz_s*)file;
+    s = (unz64_s*)file;
     if (!s->current_file_ok)
         return UNZ_PARAMERROR;
 
     if (s->pfile_in_zip_read != NULL)
         unzCloseCurrentFile(file);
 
-    if (unzlocal_CheckCurrentFileCoherencyHeader(s,&iSizeVar,
-                &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK)
+    if (unzCheckCurrentFileCoherencyHeader(s, &size_variable, &offset_local_extrafield, &size_local_extrafield) != UNZ_OK)
         return UNZ_BADZIPFILE;
 
-    pfile_in_zip_read_info = (file_in_zip_read_info_s*)
-                                        ALLOC(sizeof(file_in_zip_read_info_s));
-    if (pfile_in_zip_read_info==NULL)
+    pfile_in_zip_read_info = (file_in_zip64_read_info_s*)ALLOC(sizeof(file_in_zip64_read_info_s));
+    if (pfile_in_zip_read_info == NULL)
         return UNZ_INTERNALERROR;
 
-    pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE);
+    pfile_in_zip_read_info->read_buffer = (uint8_t*)ALLOC(UNZ_BUFSIZE);
     pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
     pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
-    pfile_in_zip_read_info->pos_local_extrafield=0;
-    pfile_in_zip_read_info->raw=raw;
+    pfile_in_zip_read_info->pos_local_extrafield = 0;
+    pfile_in_zip_read_info->raw = raw;
 
-    if (pfile_in_zip_read_info->read_buffer==NULL)
+    if (pfile_in_zip_read_info->read_buffer == NULL)
     {
         TRYFREE(pfile_in_zip_read_info);
         return UNZ_INTERNALERROR;
     }
 
-    pfile_in_zip_read_info->stream_initialised=0;
+    pfile_in_zip_read_info->stream_initialised = 0;
 
-    if (method!=NULL)
-        *method = (int)s->cur_file_info.compression_method;
+    compression_method = s->cur_file_info.compression_method;
+#ifdef HAVE_AES
+    if (compression_method == AES_METHOD)
+    {
+        compression_method = s->cur_file_info_internal.aes_compression_method;
+        if (password == NULL)
+        {
+            TRYFREE(pfile_in_zip_read_info);
+            return UNZ_PARAMERROR;
+        }
+    }
+#endif
 
-    if (level!=NULL)
+    if (method != NULL)
+        *method = compression_method;
+
+    if (level != NULL)
     {
         *level = 6;
         switch (s->cur_file_info.flag & 0x06)
@@ -1127,238 +1115,430 @@ extern int ZEXPORT unzOpenCurrentFile3 (file, method, level, raw, password)
         }
     }
 
-    if ((s->cur_file_info.compression_method!=0) &&
-        (s->cur_file_info.compression_method!=Z_DEFLATED))
-        return UNZ_BADZIPFILE;
-
-    pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc;
-    pfile_in_zip_read_info->crc32=0;
-    pfile_in_zip_read_info->compression_method =
-            s->cur_file_info.compression_method;
-    pfile_in_zip_read_info->filestream=s->filestream;
-    pfile_in_zip_read_info->z_filefunc=s->z_filefunc;
-    pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile;
-
-    pfile_in_zip_read_info->stream.total_out = 0;
-
-    if ((s->cur_file_info.compression_method==Z_DEFLATED) &&
-        (!raw))
+    if ((compression_method != 0) && (compression_method != Z_DEFLATED))
     {
-      pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
-      pfile_in_zip_read_info->stream.zfree = (free_func)0;
-      pfile_in_zip_read_info->stream.opaque = (voidpf)0;
-      pfile_in_zip_read_info->stream.next_in = (voidpf)0;
-      pfile_in_zip_read_info->stream.avail_in = 0;
-
-      err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);
-      if (err == Z_OK)
-        pfile_in_zip_read_info->stream_initialised=1;
-      else
-      {
-        TRYFREE(pfile_in_zip_read_info);
-        return err;
-      }
-        /* windowBits is passed < 0 to tell that there is no zlib header.
-         * Note that in this case inflate *requires* an extra "dummy" byte
-         * after the compressed stream in order to complete decompression and
-         * return Z_STREAM_END.
-         * In unzip, i don't wait absolutely Z_STREAM_END because I known the
-         * size of both compressed and uncompressed data
-         */
+#ifdef HAVE_BZIP2
+        if (compression_method != Z_BZIP2ED)
+#endif
+        {
+            TRYFREE(pfile_in_zip_read_info);
+            return UNZ_BADZIPFILE;
+        }
     }
-    pfile_in_zip_read_info->rest_read_compressed =
-            s->cur_file_info.compressed_size ;
-    pfile_in_zip_read_info->rest_read_uncompressed =
-            s->cur_file_info.uncompressed_size ;
 
+    pfile_in_zip_read_info->crc32_wait = s->cur_file_info.crc;
+    pfile_in_zip_read_info->crc32 = 0;
+    pfile_in_zip_read_info->total_out_64 = 0;
+    pfile_in_zip_read_info->compression_method = compression_method;
+    pfile_in_zip_read_info->filestream = s->filestream;
+    pfile_in_zip_read_info->z_filefunc = s->z_filefunc;
+    if (s->number_disk == s->gi.number_disk_with_CD)
+        pfile_in_zip_read_info->byte_before_the_zipfile = s->byte_before_the_zipfile;
+    else
+        pfile_in_zip_read_info->byte_before_the_zipfile = 0;
+    pfile_in_zip_read_info->stream.total_out = 0;
+    pfile_in_zip_read_info->stream.total_in = 0;
+    pfile_in_zip_read_info->stream.next_in = NULL;
 
-    pfile_in_zip_read_info->pos_in_zipfile =
-            s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER +
-              iSizeVar;
+    if (!raw)
+    {
+        if (compression_method == Z_BZIP2ED)
+        {
+#ifdef HAVE_BZIP2
+            pfile_in_zip_read_info->bstream.bzalloc = (void *(*) (void *, int, int))0;
+            pfile_in_zip_read_info->bstream.bzfree = (free_func)0;
+            pfile_in_zip_read_info->bstream.opaque = (voidpf)0;
+            pfile_in_zip_read_info->bstream.state = (voidpf)0;
 
-    pfile_in_zip_read_info->stream.avail_in = (uInt)0;
+            pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
+            pfile_in_zip_read_info->stream.zfree = (free_func)0;
+            pfile_in_zip_read_info->stream.opaque = (voidpf)0;
+            pfile_in_zip_read_info->stream.next_in = (voidpf)0;
+            pfile_in_zip_read_info->stream.avail_in = 0;
+
+            err = BZ2_bzDecompressInit(&pfile_in_zip_read_info->bstream, 0, 0);
+            if (err == Z_OK)
+            {
+                pfile_in_zip_read_info->stream_initialised = Z_BZIP2ED;
+            }
+            else
+            {
+                TRYFREE(pfile_in_zip_read_info);
+                return err;
+            }
+#else
+            pfile_in_zip_read_info->raw = 1;
+#endif
+        }
+        else if (compression_method == Z_DEFLATED)
+        {
+            pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
+            pfile_in_zip_read_info->stream.zfree = (free_func)0;
+            pfile_in_zip_read_info->stream.opaque = (voidpf)s;
+            pfile_in_zip_read_info->stream.next_in = 0;
+            pfile_in_zip_read_info->stream.avail_in = 0;
+
+#ifdef HAVE_APPLE_COMPRESSION
+            err = compression_stream_init(&pfile_in_zip_read_info->astream, COMPRESSION_STREAM_DECODE, COMPRESSION_ZLIB);
+            if (err == COMPRESSION_STATUS_ERROR)
+                err = UNZ_INTERNALERROR;
+            else
+                err = Z_OK;
+#else
+            err = inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);
+#endif
+            if (err == Z_OK)
+            {
+                pfile_in_zip_read_info->stream_initialised = Z_DEFLATED;
+            }
+            else
+            {
+                TRYFREE(pfile_in_zip_read_info);
+                return err;
+            }
+            /* windowBits is passed < 0 to tell that there is no zlib header.
+             * Note that in this case inflate *requires* an extra "dummy" byte
+             * after the compressed stream in order to complete decompression and
+             * return Z_STREAM_END.
+             * In unzip, i don't wait absolutely Z_STREAM_END because I known the
+             * size of both compressed and uncompressed data
+             */
+        }
+    }
+
+    pfile_in_zip_read_info->rest_read_compressed = s->cur_file_info.compressed_size;
+    pfile_in_zip_read_info->rest_read_uncompressed = s->cur_file_info.uncompressed_size;
+    pfile_in_zip_read_info->pos_in_zipfile = s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER + size_variable;
+    pfile_in_zip_read_info->stream.avail_in = 0;
 
     s->pfile_in_zip_read = pfile_in_zip_read_info;
 
-#    ifndef NOUNCRYPT
-    if (password != NULL)
+#ifndef NOUNCRYPT
+    s->pcrc_32_tab = NULL;
+
+    if ((password != NULL) && ((s->cur_file_info.flag & 1) != 0))
     {
-        int i;
-        s->pcrc_32_tab = get_crc_table();
-        init_keys(password,s->keys,s->pcrc_32_tab);
-        if (ZSEEK(s->z_filefunc, s->filestream,
-                  s->pfile_in_zip_read->pos_in_zipfile +
-                     s->pfile_in_zip_read->byte_before_the_zipfile,
-                  SEEK_SET)!=0)
-            return UNZ_INTERNALERROR;
-        if(ZREAD(s->z_filefunc, s->filestream,source, 12)<12)
+        if (ZSEEK64(s->z_filefunc, s->filestream,
+                  s->pfile_in_zip_read->pos_in_zipfile + s->pfile_in_zip_read->byte_before_the_zipfile,
+                  ZLIB_FILEFUNC_SEEK_SET) != 0)
             return UNZ_INTERNALERROR;
+#ifdef HAVE_AES
+        if (s->cur_file_info.compression_method == AES_METHOD)
+        {
+            unsigned char passverify_archive[AES_PWVERIFYSIZE];
+            unsigned char passverify_password[AES_PWVERIFYSIZE];
+            unsigned char salt_value[AES_MAXSALTLENGTH];
+            uint32_t salt_length = 0;
 
-        for (i = 0; i<12; i++)
-            zdecode(s->keys,s->pcrc_32_tab,source[i]);
+            if ((s->cur_file_info_internal.aes_encryption_mode < 1) ||
+                (s->cur_file_info_internal.aes_encryption_mode > 3))
+                return UNZ_INTERNALERROR;
 
-        s->pfile_in_zip_read->pos_in_zipfile+=12;
-        s->encrypted=1;
+            salt_length = SALT_LENGTH(s->cur_file_info_internal.aes_encryption_mode);
+
+            if (ZREAD64(s->z_filefunc, s->filestream, salt_value, salt_length) != salt_length)
+                return UNZ_INTERNALERROR;
+            if (ZREAD64(s->z_filefunc, s->filestream, passverify_archive, AES_PWVERIFYSIZE) != AES_PWVERIFYSIZE)
+                return UNZ_INTERNALERROR;
+
+            fcrypt_init(s->cur_file_info_internal.aes_encryption_mode, (uint8_t *)password,
+                (uint32_t)strlen(password), salt_value, passverify_password, &s->pfile_in_zip_read->aes_ctx);
+
+            if (memcmp(passverify_archive, passverify_password, AES_PWVERIFYSIZE) != 0)
+                return UNZ_BADPASSWORD;
+
+            s->pfile_in_zip_read->rest_read_compressed -= salt_length + AES_PWVERIFYSIZE;
+            s->pfile_in_zip_read->rest_read_compressed -= AES_AUTHCODESIZE;
+
+            s->pfile_in_zip_read->pos_in_zipfile += salt_length + AES_PWVERIFYSIZE;
+        }
+        else
+#endif
+        {
+            int i;
+            s->pcrc_32_tab = (const z_crc_t*)get_crc_table();
+            init_keys(password, s->keys, s->pcrc_32_tab);
+
+            if (ZREAD64(s->z_filefunc, s->filestream, source, 12) < 12)
+                return UNZ_INTERNALERROR;
+
+            for (i = 0; i < 12; i++)
+                zdecode(s->keys, s->pcrc_32_tab, source[i]);
+
+            s->pfile_in_zip_read->rest_read_compressed -= 12;
+            s->pfile_in_zip_read->pos_in_zipfile += 12;
+        }
     }
-#    endif
-
+#endif
 
     return UNZ_OK;
 }
 
-extern int ZEXPORT unzOpenCurrentFile (file)
-    unzFile file;
+extern int ZEXPORT unzOpenCurrentFile(unzFile file)
 {
     return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL);
 }
 
-extern int ZEXPORT unzOpenCurrentFilePassword (file, password)
-    unzFile file;
-    const char* password;
+extern int ZEXPORT unzOpenCurrentFilePassword(unzFile file, const char *password)
 {
     return unzOpenCurrentFile3(file, NULL, NULL, 0, password);
 }
 
-extern int ZEXPORT unzOpenCurrentFile2 (file,method,level,raw)
-    unzFile file;
-    int* method;
-    int* level;
-    int raw;
+extern int ZEXPORT unzOpenCurrentFile2(unzFile file, int *method, int *level, int raw)
 {
     return unzOpenCurrentFile3(file, method, level, raw, NULL);
 }
 
-/*
-  Read bytes from the current file.
-  buf contain buffer where data must be copied
-  len the size of buf.
+/* Read bytes from the current file.
+   buf contain buffer where data must be copied
+   len the size of buf.
 
-  return the number of byte copied if somes bytes are copied
-  return 0 if the end of file was reached
-  return <0 with error code if there is an error
-    (UNZ_ERRNO for IO error, or zLib error for uncompress error)
-*/
-extern int ZEXPORT unzReadCurrentFile  (file, buf, len)
-    unzFile file;
-    voidp buf;
-    unsigned len;
+   return the number of byte copied if some bytes are copied
+   return 0 if the end of file was reached
+   return <0 with error code if there is an error (UNZ_ERRNO for IO error, or zLib error for uncompress error) */
+extern int ZEXPORT unzReadCurrentFile(unzFile file, voidp buf, uint32_t len)
 {
-    int err=UNZ_OK;
-    uInt iRead = 0;
-    unz_s* s;
-    file_in_zip_read_info_s* pfile_in_zip_read_info;
-    if (file==NULL)
+    unz64_s *s = NULL;
+    uint32_t read = 0;
+    int err = UNZ_OK;
+
+    if (file == NULL)
         return UNZ_PARAMERROR;
-    s=(unz_s*)file;
-    pfile_in_zip_read_info=s->pfile_in_zip_read;
+    s = (unz64_s*)file;
 
-    if (pfile_in_zip_read_info==NULL)
+    if (s->pfile_in_zip_read == NULL)
         return UNZ_PARAMERROR;
-
-
-    if (pfile_in_zip_read_info->read_buffer == NULL)
+    if (s->pfile_in_zip_read->read_buffer == NULL)
         return UNZ_END_OF_LIST_OF_FILE;
-    if (len==0)
+    if (len == 0)
         return 0;
+    if (len > UINT16_MAX)
+        return UNZ_PARAMERROR;
 
-    pfile_in_zip_read_info->stream.next_out = (Bytef*)buf;
+    s->pfile_in_zip_read->stream.next_out = (uint8_t*)buf;
+    s->pfile_in_zip_read->stream.avail_out = (uint16_t)len;
 
-    pfile_in_zip_read_info->stream.avail_out = (uInt)len;
-
-    if ((len>pfile_in_zip_read_info->rest_read_uncompressed) &&
-        (!(pfile_in_zip_read_info->raw)))
-        pfile_in_zip_read_info->stream.avail_out =
-            (uInt)pfile_in_zip_read_info->rest_read_uncompressed;
-
-    if ((len>pfile_in_zip_read_info->rest_read_compressed+
-           pfile_in_zip_read_info->stream.avail_in) &&
-         (pfile_in_zip_read_info->raw))
-        pfile_in_zip_read_info->stream.avail_out =
-            (uInt)pfile_in_zip_read_info->rest_read_compressed+
-            pfile_in_zip_read_info->stream.avail_in;
-
-    while (pfile_in_zip_read_info->stream.avail_out>0)
+    if (s->pfile_in_zip_read->raw)
     {
-        if ((pfile_in_zip_read_info->stream.avail_in==0) &&
-            (pfile_in_zip_read_info->rest_read_compressed>0))
+        if (len > s->pfile_in_zip_read->rest_read_compressed + s->pfile_in_zip_read->stream.avail_in)
+            s->pfile_in_zip_read->stream.avail_out = (uint16_t)s->pfile_in_zip_read->rest_read_compressed +
+                s->pfile_in_zip_read->stream.avail_in;
+    }
+    else
+    {
+        if (len > s->pfile_in_zip_read->rest_read_uncompressed)
+            s->pfile_in_zip_read->stream.avail_out = (uint16_t)s->pfile_in_zip_read->rest_read_uncompressed;
+    }
+
+    do
+    {
+        if (s->pfile_in_zip_read->stream.avail_in == 0)
         {
-            uInt uReadThis = UNZ_BUFSIZE;
-            if (pfile_in_zip_read_info->rest_read_compressed<uReadThis)
-                uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;
-            if (uReadThis == 0)
-                return UNZ_EOF;
-            if (ZSEEK(pfile_in_zip_read_info->z_filefunc,
-                      pfile_in_zip_read_info->filestream,
-                      pfile_in_zip_read_info->pos_in_zipfile +
-                         pfile_in_zip_read_info->byte_before_the_zipfile,
-                         ZLIB_FILEFUNC_SEEK_SET)!=0)
-                return UNZ_ERRNO;
-            if (ZREAD(pfile_in_zip_read_info->z_filefunc,
-                      pfile_in_zip_read_info->filestream,
-                      pfile_in_zip_read_info->read_buffer,
-                      uReadThis)!=uReadThis)
-                return UNZ_ERRNO;
+            uint32_t bytes_to_read = UNZ_BUFSIZE;
+            uint32_t bytes_not_read = 0;
+            uint32_t bytes_read = 0;
+            uint32_t total_bytes_read = 0;
 
+            if (s->pfile_in_zip_read->stream.next_in != NULL)
+                bytes_not_read = (uint32_t)(s->pfile_in_zip_read->read_buffer + UNZ_BUFSIZE -
+                    s->pfile_in_zip_read->stream.next_in);
+            bytes_to_read -= bytes_not_read;
+            if (bytes_not_read > 0)
+                memcpy(s->pfile_in_zip_read->read_buffer, s->pfile_in_zip_read->stream.next_in, bytes_not_read);
+            if (s->pfile_in_zip_read->rest_read_compressed < bytes_to_read)
+                bytes_to_read = (uint16_t)s->pfile_in_zip_read->rest_read_compressed;
 
-#            ifndef NOUNCRYPT
-            if(s->encrypted)
+            while (total_bytes_read != bytes_to_read)
             {
-                uInt i;
-                for(i=0;i<uReadThis;i++)
-                  pfile_in_zip_read_info->read_buffer[i] =
-                      zdecode(s->keys,s->pcrc_32_tab,
-                              pfile_in_zip_read_info->read_buffer[i]);
+                if (ZSEEK64(s->pfile_in_zip_read->z_filefunc, s->pfile_in_zip_read->filestream,
+                        s->pfile_in_zip_read->pos_in_zipfile + s->pfile_in_zip_read->byte_before_the_zipfile,
+                        ZLIB_FILEFUNC_SEEK_SET) != 0)
+                    return UNZ_ERRNO;
+
+                bytes_read = ZREAD64(s->pfile_in_zip_read->z_filefunc, s->pfile_in_zip_read->filestream,
+                          s->pfile_in_zip_read->read_buffer + bytes_not_read + total_bytes_read,
+                          bytes_to_read - total_bytes_read);
+
+                total_bytes_read += bytes_read;
+                s->pfile_in_zip_read->pos_in_zipfile += bytes_read;
+
+                if (bytes_read == 0)
+                {
+                    if (ZERROR64(s->pfile_in_zip_read->z_filefunc, s->pfile_in_zip_read->filestream))
+                        return UNZ_ERRNO;
+
+                    err = unzGoToNextDisk(file);
+                    if (err != UNZ_OK)
+                        return err;
+
+                    s->pfile_in_zip_read->pos_in_zipfile = 0;
+                    s->pfile_in_zip_read->filestream = s->filestream;
+                }
             }
-#            endif
 
+#ifndef NOUNCRYPT
+            if ((s->cur_file_info.flag & 1) != 0)
+            {
+#ifdef HAVE_AES
+                if (s->cur_file_info.compression_method == AES_METHOD)
+                {
+                    fcrypt_decrypt(s->pfile_in_zip_read->read_buffer, bytes_to_read, &s->pfile_in_zip_read->aes_ctx);
+                }
+                else
+#endif
+                if (s->pcrc_32_tab != NULL)
+                {
+                    uint32_t i = 0;
 
-            pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
+                    for (i = 0; i < total_bytes_read; i++)
+                      s->pfile_in_zip_read->read_buffer[i] =
+                          zdecode(s->keys, s->pcrc_32_tab, s->pfile_in_zip_read->read_buffer[i]);
+                }
+            }
+#endif
 
-            pfile_in_zip_read_info->rest_read_compressed-=uReadThis;
-
-            pfile_in_zip_read_info->stream.next_in =
-                (Bytef*)pfile_in_zip_read_info->read_buffer;
-            pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;
+            s->pfile_in_zip_read->rest_read_compressed -= total_bytes_read;
+            s->pfile_in_zip_read->stream.next_in = (uint8_t*)s->pfile_in_zip_read->read_buffer;
+            s->pfile_in_zip_read->stream.avail_in = (uint16_t)(bytes_not_read + total_bytes_read);
         }
 
-        if ((pfile_in_zip_read_info->compression_method==0) || (pfile_in_zip_read_info->raw))
+        if ((s->pfile_in_zip_read->compression_method == 0) || (s->pfile_in_zip_read->raw))
         {
-            uInt uDoCopy,i ;
+            uint32_t i = 0;
+            uint32_t copy = 0;
 
-            if ((pfile_in_zip_read_info->stream.avail_in == 0) &&
-                (pfile_in_zip_read_info->rest_read_compressed == 0))
-                return (iRead==0) ? UNZ_EOF : iRead;
+            if ((s->pfile_in_zip_read->stream.avail_in == 0) &&
+                (s->pfile_in_zip_read->rest_read_compressed == 0))
+                return (read == 0) ? UNZ_EOF : read;
 
-            if (pfile_in_zip_read_info->stream.avail_out <
-                            pfile_in_zip_read_info->stream.avail_in)
-                uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
+            if (s->pfile_in_zip_read->stream.avail_out < s->pfile_in_zip_read->stream.avail_in)
+                copy = s->pfile_in_zip_read->stream.avail_out;
             else
-                uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
+                copy = s->pfile_in_zip_read->stream.avail_in;
 
-            for (i=0;i<uDoCopy;i++)
-                *(pfile_in_zip_read_info->stream.next_out+i) =
-                        *(pfile_in_zip_read_info->stream.next_in+i);
+            for (i = 0; i < copy; i++)
+                *(s->pfile_in_zip_read->stream.next_out + i) =
+                        *(s->pfile_in_zip_read->stream.next_in + i);
 
-            pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,
-                                pfile_in_zip_read_info->stream.next_out,
-                                uDoCopy);
-            pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy;
-            pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
-            pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
-            pfile_in_zip_read_info->stream.next_out += uDoCopy;
-            pfile_in_zip_read_info->stream.next_in += uDoCopy;
-            pfile_in_zip_read_info->stream.total_out += uDoCopy;
-            iRead += uDoCopy;
+            s->pfile_in_zip_read->total_out_64 = s->pfile_in_zip_read->total_out_64 + copy;
+            s->pfile_in_zip_read->rest_read_uncompressed -= copy;
+            s->pfile_in_zip_read->crc32 = (uint32_t)crc32(s->pfile_in_zip_read->crc32,
+                                s->pfile_in_zip_read->stream.next_out, copy);
+
+            s->pfile_in_zip_read->stream.avail_in -= copy;
+            s->pfile_in_zip_read->stream.avail_out -= copy;
+            s->pfile_in_zip_read->stream.next_out += copy;
+            s->pfile_in_zip_read->stream.next_in += copy;
+            s->pfile_in_zip_read->stream.total_out += copy;
+
+            read += copy;
         }
+        else if (s->pfile_in_zip_read->compression_method == Z_BZIP2ED)
+        {
+#ifdef HAVE_BZIP2
+            uint64_t total_out_before = 0;
+            uint64_t total_out_after = 0;
+            uint64_t out_bytes = 0;
+            const uint8_t *buf_before = NULL;
+
+            s->pfile_in_zip_read->bstream.next_in        = (char*)s->pfile_in_zip_read->stream.next_in;
+            s->pfile_in_zip_read->bstream.avail_in       = s->pfile_in_zip_read->stream.avail_in;
+            s->pfile_in_zip_read->bstream.total_in_lo32  = (uint32_t)s->pfile_in_zip_read->stream.total_in;
+            s->pfile_in_zip_read->bstream.total_in_hi32  = s->pfile_in_zip_read->stream.total_in >> 32;
+            
+            s->pfile_in_zip_read->bstream.next_out       = (char*)s->pfile_in_zip_read->stream.next_out;
+            s->pfile_in_zip_read->bstream.avail_out      = s->pfile_in_zip_read->stream.avail_out;
+            s->pfile_in_zip_read->bstream.total_out_lo32 = (uint32_t)s->pfile_in_zip_read->stream.total_out;
+            s->pfile_in_zip_read->bstream.total_out_hi32 = s->pfile_in_zip_read->stream.total_out >> 32;
+
+            total_out_before = s->pfile_in_zip_read->bstream.total_out_lo32 + 
+                (((uint32_t)s->pfile_in_zip_read->bstream.total_out_hi32) << 32);
+            buf_before = (const uint8_t*)s->pfile_in_zip_read->bstream.next_out;
+
+            err = BZ2_bzDecompress(&s->pfile_in_zip_read->bstream);
+
+            total_out_after = s->pfile_in_zip_read->bstream.total_out_lo32 + 
+                (((uint32_t)s->pfile_in_zip_read->bstream.total_out_hi32) << 32);
+
+            out_bytes = total_out_after - total_out_before;
+
+            s->pfile_in_zip_read->total_out_64 = s->pfile_in_zip_read->total_out_64 + out_bytes;
+            s->pfile_in_zip_read->rest_read_uncompressed -= out_bytes;
+            s->pfile_in_zip_read->crc32 = crc32(s->pfile_in_zip_read->crc32, buf_before, (uint32_t)out_bytes);
+
+            read += (uint32_t)out_bytes;
+
+            s->pfile_in_zip_read->stream.next_in   = (uint8_t*)s->pfile_in_zip_read->bstream.next_in;
+            s->pfile_in_zip_read->stream.avail_in  = s->pfile_in_zip_read->bstream.avail_in;
+            s->pfile_in_zip_read->stream.total_in  = s->pfile_in_zip_read->bstream.total_in_lo32;
+            s->pfile_in_zip_read->stream.next_out  = (uint8_t*)s->pfile_in_zip_read->bstream.next_out;
+            s->pfile_in_zip_read->stream.avail_out = s->pfile_in_zip_read->bstream.avail_out;
+            s->pfile_in_zip_read->stream.total_out = s->pfile_in_zip_read->bstream.total_out_lo32;
+
+            if (err == BZ_STREAM_END)
+                return (read == 0) ? UNZ_EOF : read;
+            if (err != BZ_OK)
+                break;
+#endif
+        }
+#ifdef HAVE_APPLE_COMPRESSION
         else
         {
-            uLong uTotalOutBefore,uTotalOutAfter;
-            const Bytef *bufBefore;
-            uLong uOutThis;
-            int flush=Z_SYNC_FLUSH;
+            uint64_t total_out_before = 0;
+            uint64_t total_out_after = 0;
+            uint64_t out_bytes = 0;
+            const uint8_t *buf_before = NULL;
 
-            uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
-            bufBefore = pfile_in_zip_read_info->stream.next_out;
+            s->pfile_in_zip_read->astream.src_ptr = s->pfile_in_zip_read->stream.next_in;
+            s->pfile_in_zip_read->astream.src_size = s->pfile_in_zip_read->stream.avail_in;
+            s->pfile_in_zip_read->astream.dst_ptr = s->pfile_in_zip_read->stream.next_out;
+            s->pfile_in_zip_read->astream.dst_size = len;
+
+            total_out_before = s->pfile_in_zip_read->stream.total_out;
+            buf_before = s->pfile_in_zip_read->stream.next_out;
+
+            compression_status status;
+            compression_stream_flags flags;
+
+            if (s->pfile_in_zip_read->stream.avail_in == 0)
+            {
+                flags = COMPRESSION_STREAM_FINALIZE;
+            }
+
+            status = compression_stream_process(&s->pfile_in_zip_read->astream, flags);
+
+            total_out_after = len - s->pfile_in_zip_read->astream.dst_size;
+            out_bytes = total_out_after - total_out_before;
+
+            s->pfile_in_zip_read->total_out_64 += out_bytes;
+            s->pfile_in_zip_read->rest_read_uncompressed -= out_bytes;
+            s->pfile_in_zip_read->crc32 =
+                crc32(s->pfile_in_zip_read->crc32, buf_before, (uint32_t)out_bytes);
+
+            read += (uint32_t)out_bytes;
+
+            s->pfile_in_zip_read->stream.next_in = s->pfile_in_zip_read->astream.src_ptr;
+            s->pfile_in_zip_read->stream.avail_in = s->pfile_in_zip_read->astream.src_size;
+            s->pfile_in_zip_read->stream.next_out = s->pfile_in_zip_read->astream.dst_ptr;
+            s->pfile_in_zip_read->stream.avail_out = s->pfile_in_zip_read->astream.dst_size;
+
+            if (status == COMPRESSION_STATUS_END)
+                return (read == 0) ? UNZ_EOF : read;
+            if (status == COMPRESSION_STATUS_ERROR)
+                return Z_DATA_ERROR;
+            return read;
+        }
+#else
+        else
+        {
+            uint64_t total_out_before = 0;
+            uint64_t total_out_after = 0;
+            uint64_t out_bytes = 0;
+            const uint8_t *buf_before = NULL;
+            int flush = Z_SYNC_FLUSH;
+
+            total_out_before = s->pfile_in_zip_read->stream.total_out;
+            buf_before = s->pfile_in_zip_read->stream.next_out;
 
             /*
             if ((pfile_in_zip_read_info->rest_read_uncompressed ==
@@ -1366,250 +1546,455 @@ extern int ZEXPORT unzReadCurrentFile  (file, buf, len)
                 (pfile_in_zip_read_info->rest_read_compressed == 0))
                 flush = Z_FINISH;
             */
-            err=inflate(&pfile_in_zip_read_info->stream,flush);
+            err = inflate(&s->pfile_in_zip_read->stream, flush);
 
-            if ((err>=0) && (pfile_in_zip_read_info->stream.msg!=NULL))
-              err = Z_DATA_ERROR;
+            if ((err >= 0) && (s->pfile_in_zip_read->stream.msg != NULL))
+                err = Z_DATA_ERROR;
 
-            uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
-            uOutThis = uTotalOutAfter-uTotalOutBefore;
+            total_out_after = s->pfile_in_zip_read->stream.total_out;
+            out_bytes = total_out_after - total_out_before;
 
-            pfile_in_zip_read_info->crc32 =
-                crc32(pfile_in_zip_read_info->crc32,bufBefore,
-                        (uInt)(uOutThis));
+            s->pfile_in_zip_read->total_out_64 += out_bytes;
+            s->pfile_in_zip_read->rest_read_uncompressed -= out_bytes;
+            s->pfile_in_zip_read->crc32 =
+                (uint32_t)crc32(s->pfile_in_zip_read->crc32,buf_before, (uint32_t)out_bytes);
 
-            pfile_in_zip_read_info->rest_read_uncompressed -=
-                uOutThis;
+            read += (uint32_t)out_bytes;
 
-            iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
-
-            if (err==Z_STREAM_END)
-                return (iRead==0) ? UNZ_EOF : iRead;
-            if (err!=Z_OK)
+            if (err == Z_STREAM_END)
+                return (read == 0) ? UNZ_EOF : read;
+            if (err != Z_OK)
                 break;
         }
+#endif
     }
+    while (s->pfile_in_zip_read->stream.avail_out > 0);
 
-    if (err==Z_OK)
-        return iRead;
+    if (err == Z_OK)
+        return read;
     return err;
 }
 
-
-/*
-  Give the current position in uncompressed data
-*/
-extern z_off_t ZEXPORT unztell (file)
-    unzFile file;
+extern int ZEXPORT unzGetLocalExtrafield(unzFile file, voidp buf, uint32_t len)
 {
-    unz_s* s;
-    file_in_zip_read_info_s* pfile_in_zip_read_info;
-    if (file==NULL)
-        return UNZ_PARAMERROR;
-    s=(unz_s*)file;
-    pfile_in_zip_read_info=s->pfile_in_zip_read;
+    unz64_s *s = NULL;
+    uint64_t size_to_read = 0;
+    uint32_t read_now = 0;
 
-    if (pfile_in_zip_read_info==NULL)
+    if (file == NULL)
+        return UNZ_PARAMERROR;
+    s = (unz64_s*)file;
+    if (s->pfile_in_zip_read == NULL)
         return UNZ_PARAMERROR;
 
-    return (z_off_t)pfile_in_zip_read_info->stream.total_out;
-}
+    size_to_read = s->pfile_in_zip_read->size_local_extrafield - s->pfile_in_zip_read->pos_local_extrafield;
 
-
-/*
-  return 1 if the end of file was reached, 0 elsewhere
-*/
-extern int ZEXPORT unzeof (file)
-    unzFile file;
-{
-    unz_s* s;
-    file_in_zip_read_info_s* pfile_in_zip_read_info;
-    if (file==NULL)
-        return UNZ_PARAMERROR;
-    s=(unz_s*)file;
-    pfile_in_zip_read_info=s->pfile_in_zip_read;
-
-    if (pfile_in_zip_read_info==NULL)
-        return UNZ_PARAMERROR;
-
-    if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
-        return 1;
-    else
-        return 0;
-}
-
-
-
-/*
-  Read extra field from the current file (opened by unzOpenCurrentFile)
-  This is the local-header version of the extra field (sometimes, there is
-    more info in the local-header version than in the central-header)
-
-  if buf==NULL, it return the size of the local extra field that can be read
-
-  if buf!=NULL, len is the size of the buffer, the extra header is copied in
-    buf.
-  the return value is the number of bytes copied in buf, or (if <0)
-    the error code
-*/
-extern int ZEXPORT unzGetLocalExtrafield (file,buf,len)
-    unzFile file;
-    voidp buf;
-    unsigned len;
-{
-    unz_s* s;
-    file_in_zip_read_info_s* pfile_in_zip_read_info;
-    uInt read_now;
-    uLong size_to_read;
-
-    if (file==NULL)
-        return UNZ_PARAMERROR;
-    s=(unz_s*)file;
-    pfile_in_zip_read_info=s->pfile_in_zip_read;
-
-    if (pfile_in_zip_read_info==NULL)
-        return UNZ_PARAMERROR;
-
-    size_to_read = (pfile_in_zip_read_info->size_local_extrafield -
-                pfile_in_zip_read_info->pos_local_extrafield);
-
-    if (buf==NULL)
+    if (buf == NULL)
         return (int)size_to_read;
 
-    if (len>size_to_read)
-        read_now = (uInt)size_to_read;
+    if (len > size_to_read)
+        read_now = (uint32_t)size_to_read;
     else
-        read_now = (uInt)len ;
+        read_now = len;
 
-    if (read_now==0)
+    if (read_now == 0)
         return 0;
 
-    if (ZSEEK(pfile_in_zip_read_info->z_filefunc,
-              pfile_in_zip_read_info->filestream,
-              pfile_in_zip_read_info->offset_local_extrafield +
-              pfile_in_zip_read_info->pos_local_extrafield,
-              ZLIB_FILEFUNC_SEEK_SET)!=0)
+    if (ZSEEK64(s->pfile_in_zip_read->z_filefunc, s->pfile_in_zip_read->filestream,
+        s->pfile_in_zip_read->offset_local_extrafield + s->pfile_in_zip_read->pos_local_extrafield,
+        ZLIB_FILEFUNC_SEEK_SET) != 0)
         return UNZ_ERRNO;
 
-    if (ZREAD(pfile_in_zip_read_info->z_filefunc,
-              pfile_in_zip_read_info->filestream,
-              buf,read_now)!=read_now)
+    if (ZREAD64(s->pfile_in_zip_read->z_filefunc, s->pfile_in_zip_read->filestream, buf, read_now) != read_now)
         return UNZ_ERRNO;
 
     return (int)read_now;
 }
 
-/*
-  Close the file in zip opened with unzipOpenCurrentFile
-  Return UNZ_CRCERROR if all the file was read but the CRC is not good
-*/
-extern int ZEXPORT unzCloseCurrentFile (file)
-    unzFile file;
+extern int ZEXPORT unzCloseCurrentFile(unzFile file)
 {
-    int err=UNZ_OK;
+    unz64_s *s = NULL;
+    file_in_zip64_read_info_s *pfile_in_zip_read_info = NULL;
+    int err = UNZ_OK;
 
-    unz_s* s;
-    file_in_zip_read_info_s* pfile_in_zip_read_info;
-    if (file==NULL)
+    if (file == NULL)
         return UNZ_PARAMERROR;
-    s=(unz_s*)file;
-    pfile_in_zip_read_info=s->pfile_in_zip_read;
-
-    if (pfile_in_zip_read_info==NULL)
+    s = (unz64_s*)file;
+    pfile_in_zip_read_info = s->pfile_in_zip_read;
+    if (pfile_in_zip_read_info == NULL)
         return UNZ_PARAMERROR;
 
-
-    if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) &&
-        (!pfile_in_zip_read_info->raw))
+#ifdef HAVE_AES
+    if (s->cur_file_info.compression_method == AES_METHOD)
     {
-        if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)
-            err=UNZ_CRCERROR;
-    }
+        unsigned char authcode[AES_AUTHCODESIZE];
+        unsigned char rauthcode[AES_AUTHCODESIZE];
 
+        if (ZREAD64(s->z_filefunc, s->filestream, authcode, AES_AUTHCODESIZE) != AES_AUTHCODESIZE)
+            return UNZ_ERRNO;
+
+        if (fcrypt_end(rauthcode, &s->pfile_in_zip_read->aes_ctx) != AES_AUTHCODESIZE)
+            err = UNZ_CRCERROR;
+        if (memcmp(authcode, rauthcode, AES_AUTHCODESIZE) != 0)
+            err = UNZ_CRCERROR;
+    }
+    /* AES zip version AE-1 will expect a valid crc as well */
+    if ((s->cur_file_info.compression_method != AES_METHOD) ||
+        (s->cur_file_info_internal.aes_version == 0x0001))
+#endif
+    {
+        if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) &&
+            (!pfile_in_zip_read_info->raw))
+        {
+            if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)
+                err = UNZ_CRCERROR;
+        }
+    }
 
     TRYFREE(pfile_in_zip_read_info->read_buffer);
     pfile_in_zip_read_info->read_buffer = NULL;
-    if (pfile_in_zip_read_info->stream_initialised)
+    if (pfile_in_zip_read_info->stream_initialised == Z_DEFLATED)
+    {
+#ifdef HAVE_APPLE_COMPRESSION
+        if (compression_stream_destroy)
+            compression_stream_destroy(&pfile_in_zip_read_info->astream);
+#else
         inflateEnd(&pfile_in_zip_read_info->stream);
+#endif
+        
+    }
+#ifdef HAVE_BZIP2
+    else if (pfile_in_zip_read_info->stream_initialised == Z_BZIP2ED)
+        BZ2_bzDecompressEnd(&pfile_in_zip_read_info->bstream);
+#endif
 
     pfile_in_zip_read_info->stream_initialised = 0;
     TRYFREE(pfile_in_zip_read_info);
 
-    s->pfile_in_zip_read=NULL;
+    s->pfile_in_zip_read = NULL;
 
     return err;
 }
 
-
-/*
-  Get the global comment string of the ZipFile, in the szComment buffer.
-  uSizeBuf is the size of the szComment buffer.
-  return the number of byte copied or an error code <0
-*/
-extern int ZEXPORT unzGetGlobalComment (file, szComment, uSizeBuf)
-    unzFile file;
-    char *szComment;
-    uLong uSizeBuf;
+extern int ZEXPORT unzGoToFirstFile2(unzFile file, unz_file_info64 *pfile_info, char *filename,
+    uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size)
 {
-    int err=UNZ_OK;
-    unz_s* s;
-    uLong uReadThis ;
-    if (file==NULL)
+    unz64_s *s = NULL;
+    int err = UNZ_OK;
+
+    if (file == NULL)
         return UNZ_PARAMERROR;
-    s=(unz_s*)file;
+    s = (unz64_s*)file;
 
-    uReadThis = uSizeBuf;
-    if (uReadThis>s->gi.size_comment)
-        uReadThis = s->gi.size_comment;
+    s->pos_in_central_dir = s->offset_central_dir;
+    s->num_file = 0;
 
-    if (ZSEEK(s->z_filefunc,s->filestream,s->central_pos+22,ZLIB_FILEFUNC_SEEK_SET)!=0)
-        return UNZ_ERRNO;
+    err = unzGetCurrentFileInfoInternal(file, &s->cur_file_info, &s->cur_file_info_internal,
+            filename, filename_size, extrafield, extrafield_size, comment,comment_size);
 
-    if (uReadThis>0)
+    s->current_file_ok = (err == UNZ_OK);
+    if ((err == UNZ_OK) && (pfile_info != NULL))
+        memcpy(pfile_info, &s->cur_file_info, sizeof(unz_file_info64));
+
+    return err;
+}
+
+extern int ZEXPORT unzGoToFirstFile(unzFile file)
+{
+    return unzGoToFirstFile2(file, NULL, NULL, 0, NULL, 0, NULL, 0);
+}
+
+extern int ZEXPORT unzGoToNextFile2(unzFile file, unz_file_info64 *pfile_info, char *filename,
+    uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size)
+{
+    unz64_s *s = NULL;
+    int err = UNZ_OK;
+
+    if (file == NULL)
+        return UNZ_PARAMERROR;
+    s = (unz64_s*)file;
+
+    if (!s->current_file_ok)
+        return UNZ_END_OF_LIST_OF_FILE;
+    if (s->gi.number_entry != UINT16_MAX)    /* 2^16 files overflow hack */
     {
-      *szComment='\0';
-      if (ZREAD(s->z_filefunc,s->filestream,szComment,uReadThis)!=uReadThis)
-        return UNZ_ERRNO;
+        if (s->num_file+1 == s->gi.number_entry)
+            return UNZ_END_OF_LIST_OF_FILE;
     }
 
-    if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment))
-        *(szComment+s->gi.size_comment)='\0';
-    return (int)uReadThis;
+    s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
+            s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment;
+    s->num_file += 1;
+
+    err = unzGetCurrentFileInfoInternal(file, &s->cur_file_info, &s->cur_file_info_internal,
+            filename, filename_size, extrafield,extrafield_size, comment, comment_size);
+
+    s->current_file_ok = (err == UNZ_OK);
+    if ((err == UNZ_OK) && (pfile_info != NULL))
+        memcpy(pfile_info, &s->cur_file_info, sizeof(unz_file_info64));
+
+    return err;
 }
 
-/* Additions by RX '2004 */
-extern uLong ZEXPORT unzGetOffset (file)
-    unzFile file;
+extern int ZEXPORT unzGoToNextFile(unzFile file)
 {
-    unz_s* s;
-
-    if (file==NULL)
-          return UNZ_PARAMERROR;
-    s=(unz_s*)file;
-    if (!s->current_file_ok)
-      return 0;
-    if (s->gi.number_entry != 0 && s->gi.number_entry != 0xffff)
-      if (s->num_file==s->gi.number_entry)
-         return 0;
-    return s->pos_in_central_dir;
+    return unzGoToNextFile2(file, NULL, NULL, 0, NULL, 0, NULL, 0);
 }
 
-extern int ZEXPORT unzSetOffset (file, pos)
-        unzFile file;
-        uLong pos;
+extern int ZEXPORT unzLocateFile(unzFile file, const char *filename, unzFileNameComparer filename_compare_func)
 {
-    unz_s* s;
-    int err;
+    unz64_s *s = NULL;
+    unz_file_info64 cur_file_info_saved;
+    unz_file_info64_internal cur_file_info_internal_saved;
+    uint64_t num_file_saved = 0;
+    uint64_t pos_in_central_dir_saved = 0;
+    char current_filename[UNZ_MAXFILENAMEINZIP+1];
+    int err = UNZ_OK;
 
-    if (file==NULL)
+    if (file == NULL)
         return UNZ_PARAMERROR;
-    s=(unz_s*)file;
+    if (strlen(filename) >= UNZ_MAXFILENAMEINZIP)
+        return UNZ_PARAMERROR;
+    s = (unz64_s*)file;
+    if (!s->current_file_ok)
+        return UNZ_END_OF_LIST_OF_FILE;
 
-    s->pos_in_central_dir = pos;
-    s->num_file = s->gi.number_entry;      /* hack */
-    err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
-                                              &s->cur_file_info_internal,
-                                              NULL,0,NULL,0,NULL,0);
+    /* Save the current state */
+    num_file_saved = s->num_file;
+    pos_in_central_dir_saved = s->pos_in_central_dir;
+    cur_file_info_saved = s->cur_file_info;
+    cur_file_info_internal_saved = s->cur_file_info_internal;
+
+    err = unzGoToFirstFile2(file, NULL, current_filename, sizeof(current_filename)-1, NULL, 0, NULL, 0);
+
+    while (err == UNZ_OK)
+    {
+        if (filename_compare_func != NULL)
+            err = filename_compare_func(file, current_filename, filename);
+        else
+            err = strcmp(current_filename, filename);
+        if (err == 0)
+            return UNZ_OK;
+        err = unzGoToNextFile2(file, NULL, current_filename, sizeof(current_filename)-1, NULL, 0, NULL, 0);
+    }
+
+    /* We failed, so restore the state of the 'current file' to where we were. */
+    s->num_file = num_file_saved;
+    s->pos_in_central_dir = pos_in_central_dir_saved;
+    s->cur_file_info = cur_file_info_saved;
+    s->cur_file_info_internal = cur_file_info_internal_saved;
+    return err;
+}
+
+extern int ZEXPORT unzGetFilePos(unzFile file, unz_file_pos *file_pos)
+{
+    unz64_file_pos file_pos64;
+    int err = unzGetFilePos64(file, &file_pos64);
+    if (err == UNZ_OK)
+    {
+        file_pos->pos_in_zip_directory = (uint32_t)file_pos64.pos_in_zip_directory;
+        file_pos->num_of_file = (uint32_t)file_pos64.num_of_file;
+    }
+    return err;
+}
+
+extern int ZEXPORT unzGoToFilePos(unzFile file, unz_file_pos *file_pos)
+{
+    unz64_file_pos file_pos64;
+    if (file_pos == NULL)
+        return UNZ_PARAMERROR;
+    file_pos64.pos_in_zip_directory = file_pos->pos_in_zip_directory;
+    file_pos64.num_of_file = file_pos->num_of_file;
+    return unzGoToFilePos64(file, &file_pos64);
+}
+
+extern int ZEXPORT unzGetFilePos64(unzFile file, unz64_file_pos *file_pos)
+{
+    unz64_s *s = NULL;
+
+    if (file == NULL || file_pos == NULL)
+        return UNZ_PARAMERROR;
+    s = (unz64_s*)file;
+    if (!s->current_file_ok)
+        return UNZ_END_OF_LIST_OF_FILE;
+
+    file_pos->pos_in_zip_directory  = s->pos_in_central_dir;
+    file_pos->num_of_file = s->num_file;
+    return UNZ_OK;
+}
+
+extern int ZEXPORT unzGoToFilePos64(unzFile file, const unz64_file_pos *file_pos)
+{
+    unz64_s *s = NULL;
+    int err = UNZ_OK;
+
+    if (file == NULL || file_pos == NULL)
+        return UNZ_PARAMERROR;
+    s = (unz64_s*)file;
+
+    /* Jump to the right spot */
+    s->pos_in_central_dir = file_pos->pos_in_zip_directory;
+    s->num_file = file_pos->num_of_file;
+
+    /* Set the current file */
+    err = unzGetCurrentFileInfoInternal(file, &s->cur_file_info, &s->cur_file_info_internal, NULL, 0, NULL, 0, NULL, 0);
+    /* Return results */
     s->current_file_ok = (err == UNZ_OK);
     return err;
 }
+
+extern int32_t ZEXPORT unzGetOffset(unzFile file)
+{
+    uint64_t offset64 = 0;
+
+    if (file == NULL)
+        return UNZ_PARAMERROR;
+    offset64 = unzGetOffset64(file);
+    return (int32_t)offset64;
+}
+
+extern int64_t ZEXPORT unzGetOffset64(unzFile file)
+{
+    unz64_s *s = NULL;
+
+    if (file == NULL)
+        return UNZ_PARAMERROR;
+    s = (unz64_s*)file;
+    if (!s->current_file_ok)
+        return 0;
+    if (s->gi.number_entry != 0 && s->gi.number_entry != UINT16_MAX)
+    {
+        if (s->num_file == s->gi.number_entry)
+            return 0;
+    }
+    return s->pos_in_central_dir;
+}
+
+extern int ZEXPORT unzSetOffset(unzFile file, uint32_t pos)
+{
+    return unzSetOffset64(file, pos);
+}
+
+extern int ZEXPORT unzSetOffset64(unzFile file, uint64_t pos)
+{
+    unz64_s *s = NULL;
+    int err = UNZ_OK;
+
+    if (file == NULL)
+        return UNZ_PARAMERROR;
+    s = (unz64_s*)file;
+    s->pos_in_central_dir = pos;
+    s->num_file = s->gi.number_entry; /* hack */
+
+    err = unzGetCurrentFileInfoInternal(file, &s->cur_file_info, &s->cur_file_info_internal, NULL, 0, NULL, 0, NULL, 0);
+
+    s->current_file_ok = (err == UNZ_OK);
+    return err;
+}
+
+extern int32_t ZEXPORT unzTell(unzFile file)
+{
+    unz64_s *s = NULL;
+    if (file == NULL)
+        return UNZ_PARAMERROR;
+    s = (unz64_s*)file;
+    if (s->pfile_in_zip_read == NULL)
+        return UNZ_PARAMERROR;
+    return (int32_t)s->pfile_in_zip_read->stream.total_out;
+}
+
+extern int64_t ZEXPORT unzTell64(unzFile file)
+{
+    unz64_s *s = NULL;
+    if (file == NULL)
+        return UNZ_PARAMERROR;
+    s = (unz64_s*)file;
+    if (s->pfile_in_zip_read == NULL)
+        return UNZ_PARAMERROR;
+    return s->pfile_in_zip_read->total_out_64;
+}
+
+extern int ZEXPORT unzSeek(unzFile file, uint32_t offset, int origin)
+{
+    return unzSeek64(file, offset, origin);
+}
+
+extern int ZEXPORT unzSeek64(unzFile file, uint64_t offset, int origin)
+{
+    unz64_s *s = NULL;
+    uint64_t stream_pos_begin = 0;
+    uint64_t stream_pos_end = 0;
+    uint64_t position = 0;
+    int is_within_buffer = 0;
+
+    if (file == NULL)
+        return UNZ_PARAMERROR;
+    s = (unz64_s*)file;
+
+    if (s->pfile_in_zip_read == NULL)
+        return UNZ_ERRNO;
+    if (s->pfile_in_zip_read->compression_method != 0)
+        return UNZ_ERRNO;
+
+    if (origin == SEEK_SET)
+        position = offset;
+    else if (origin == SEEK_CUR)
+        position = s->pfile_in_zip_read->total_out_64 + offset;
+    else if (origin == SEEK_END)
+        position = s->cur_file_info.compressed_size + offset;
+    else
+        return UNZ_PARAMERROR;
+
+    if (position > s->cur_file_info.compressed_size)
+        return UNZ_PARAMERROR;
+
+    stream_pos_end = s->pfile_in_zip_read->pos_in_zipfile;
+    stream_pos_begin = stream_pos_end;
+
+    if (stream_pos_begin > UNZ_BUFSIZE)
+        stream_pos_begin -= UNZ_BUFSIZE;
+    else
+        stream_pos_begin = 0;
+
+    is_within_buffer = 
+        (s->pfile_in_zip_read->stream.avail_in != 0) &&
+        (s->pfile_in_zip_read->rest_read_compressed != 0 || s->cur_file_info.compressed_size < UNZ_BUFSIZE) &&
+        (position >= stream_pos_begin && position < stream_pos_end);
+
+    if (is_within_buffer)
+    {
+        s->pfile_in_zip_read->stream.next_in += position - s->pfile_in_zip_read->total_out_64;
+        s->pfile_in_zip_read->stream.avail_in = (uInt)(stream_pos_end - position);
+    }
+    else
+    {
+        s->pfile_in_zip_read->stream.avail_in = 0;
+        s->pfile_in_zip_read->stream.next_in = 0;
+
+        s->pfile_in_zip_read->pos_in_zipfile = s->pfile_in_zip_read->offset_local_extrafield + position;
+        s->pfile_in_zip_read->rest_read_compressed = s->cur_file_info.compressed_size - position;
+    }
+
+    s->pfile_in_zip_read->rest_read_uncompressed -= (position - s->pfile_in_zip_read->total_out_64);
+    s->pfile_in_zip_read->stream.total_out = (uint32_t)position;
+    s->pfile_in_zip_read->total_out_64 = position;
+
+    return UNZ_OK;
+}
+
+extern int ZEXPORT unzEndOfFile(unzFile file)
+{
+    unz64_s *s = NULL;
+    if (file == NULL)
+        return UNZ_PARAMERROR;
+    s = (unz64_s*)file;
+    if (s->pfile_in_zip_read == NULL)
+        return UNZ_PARAMERROR;
+    if (s->pfile_in_zip_read->rest_read_uncompressed == 0)
+        return 1;
+    return 0;
+}
+
+#ifdef _WIN32
+#   pragma warning(pop)
+#endif // _WIN32
\ No newline at end of file
diff --git a/Engine/lib/assimp/contrib/unzip/unzip.h b/Engine/lib/assimp/contrib/unzip/unzip.h
index b247937c8..ea4c90a4d 100644
--- a/Engine/lib/assimp/contrib/unzip/unzip.h
+++ b/Engine/lib/assimp/contrib/unzip/unzip.h
@@ -1,49 +1,21 @@
 /* unzip.h -- IO for uncompress .zip files using zlib
-   Version 1.01e, February 12th, 2005
-
-   Copyright (C) 1998-2005 Gilles Vollant
-
-   This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g
-     WinZip, InfoZip tools and compatible.
-
-   Multi volume ZipFile (span) are not supported.
-   Encryption compatible with pkzip 2.04g only supported
-   Old compressions used by old PKZip 1.x are not supported
-
-
-   I WAIT FEEDBACK at mail info@winimage.com
-   Visit also http://www.winimage.com/zLibDll/unzip.htm for evolution
-
-   Condition of use and distribution are the same than zlib :
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
+   Version 1.1, February 14h, 2010
+   part of the MiniZip project
 
+   Copyright (C) 1998-2010 Gilles Vollant
+     http://www.winimage.com/zLibDll/minizip.html
+   Modifications of Unzip for Zip64
+     Copyright (C) 2007-2008 Even Rouault
+   Modifications for Zip64 support on both zip and unzip
+     Copyright (C) 2009-2010 Mathias Svensson
+     http://result42.com
 
+   This program is distributed under the terms of the same license as zlib.
+   See the accompanying LICENSE file for the full text of the license.
 */
 
-/* for more info about .ZIP format, see
-      http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip
-      http://www.info-zip.org/pub/infozip/doc/
-   PkWare has also a specification at :
-      ftp://ftp.pkware.com/probdesc.zip
-*/
-
-#ifndef _unz_H
-#define _unz_H
+#ifndef _UNZ_H
+#define _UNZ_H
 
 #ifdef __cplusplus
 extern "C" {
@@ -57,16 +29,21 @@ extern "C" {
 #include "ioapi.h"
 #endif
 
+#ifdef HAVE_BZIP2
+#include "bzlib.h"
+#endif
+
+#define Z_BZIP2ED 12
+
 #if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)
 /* like the STRICT of WIN32, we define a pointer that cannot be converted
     from (void*) without cast */
-typedef struct TagunzFile__ { int unused; } unzFile__;
-typedef unzFile__ *unzFile;
+typedef struct TagunzFile__ { int unused; } unz_file__;
+typedef unz_file__ *unzFile;
 #else
 typedef voidp unzFile;
 #endif
 
-
 #define UNZ_OK                          (0)
 #define UNZ_END_OF_LIST_OF_FILE         (-100)
 #define UNZ_ERRNO                       (Z_ERRNO)
@@ -75,280 +52,255 @@ typedef voidp unzFile;
 #define UNZ_BADZIPFILE                  (-103)
 #define UNZ_INTERNALERROR               (-104)
 #define UNZ_CRCERROR                    (-105)
-
-/* tm_unz contain date/time info */
-typedef struct tm_unz_s
-{
-    uInt tm_sec;            /* seconds after the minute - [0,59] */
-    uInt tm_min;            /* minutes after the hour - [0,59] */
-    uInt tm_hour;           /* hours since midnight - [0,23] */
-    uInt tm_mday;           /* day of the month - [1,31] */
-    uInt tm_mon;            /* months since January - [0,11] */
-    uInt tm_year;           /* years - [1980..2044] */
-} tm_unz;
+#define UNZ_BADPASSWORD                 (-106)
 
 /* unz_global_info structure contain global data about the ZIPfile
    These data comes from the end of central dir */
+typedef struct unz_global_info64_s
+{
+    uint64_t number_entry;          /* total number of entries in the central dir on this disk */
+    uint32_t number_disk_with_CD;   /* number the the disk with central dir, used for spanning ZIP*/
+    uint16_t size_comment;          /* size of the global comment of the zipfile */
+} unz_global_info64;
+
 typedef struct unz_global_info_s
 {
-    uLong number_entry;         /* total number of entries in
-                       the central dir on this disk */
-    uLong size_comment;         /* size of the global comment of the zipfile */
+    uint32_t number_entry;          /* total number of entries in the central dir on this disk */
+    uint32_t number_disk_with_CD;   /* number the the disk with central dir, used for spanning ZIP*/
+    uint16_t size_comment;          /* size of the global comment of the zipfile */
 } unz_global_info;
 
-
 /* unz_file_info contain information about a file in the zipfile */
+typedef struct unz_file_info64_s
+{
+    uint16_t version;               /* version made by                 2 bytes */
+    uint16_t version_needed;        /* version needed to extract       2 bytes */
+    uint16_t flag;                  /* general purpose bit flag        2 bytes */
+    uint16_t compression_method;    /* compression method              2 bytes */
+    uint32_t dos_date;              /* last mod file date in Dos fmt   4 bytes */
+    uint32_t crc;                   /* crc-32                          4 bytes */
+    uint64_t compressed_size;       /* compressed size                 8 bytes */
+    uint64_t uncompressed_size;     /* uncompressed size               8 bytes */
+    uint16_t size_filename;         /* filename length                 2 bytes */
+    uint16_t size_file_extra;       /* extra field length              2 bytes */
+    uint16_t size_file_comment;     /* file comment length             2 bytes */
+
+    uint32_t disk_num_start;        /* disk number start               4 bytes */
+    uint16_t internal_fa;           /* internal file attributes        2 bytes */
+    uint32_t external_fa;           /* external file attributes        4 bytes */
+
+    uint64_t disk_offset;
+
+    uint16_t size_file_extra_internal;
+} unz_file_info64;
+
 typedef struct unz_file_info_s
 {
-    uLong version;              /* version made by                 2 bytes */
-    uLong version_needed;       /* version needed to extract       2 bytes */
-    uLong flag;                 /* general purpose bit flag        2 bytes */
-    uLong compression_method;   /* compression method              2 bytes */
-    uLong dosDate;              /* last mod file date in Dos fmt   4 bytes */
-    uLong crc;                  /* crc-32                          4 bytes */
-    uLong compressed_size;      /* compressed size                 4 bytes */
-    uLong uncompressed_size;    /* uncompressed size               4 bytes */
-    uLong size_filename;        /* filename length                 2 bytes */
-    uLong size_file_extra;      /* extra field length              2 bytes */
-    uLong size_file_comment;    /* file comment length             2 bytes */
+    uint16_t version;               /* version made by                 2 bytes */
+    uint16_t version_needed;        /* version needed to extract       2 bytes */
+    uint16_t flag;                  /* general purpose bit flag        2 bytes */
+    uint16_t compression_method;    /* compression method              2 bytes */
+    uint32_t dos_date;              /* last mod file date in Dos fmt   4 bytes */
+    uint32_t crc;                   /* crc-32                          4 bytes */
+    uint32_t compressed_size;       /* compressed size                 4 bytes */
+    uint32_t uncompressed_size;     /* uncompressed size               4 bytes */
+    uint16_t size_filename;         /* filename length                 2 bytes */
+    uint16_t size_file_extra;       /* extra field length              2 bytes */
+    uint16_t size_file_comment;     /* file comment length             2 bytes */
 
-    uLong disk_num_start;       /* disk number start               2 bytes */
-    uLong internal_fa;          /* internal file attributes        2 bytes */
-    uLong external_fa;          /* external file attributes        4 bytes */
+    uint16_t disk_num_start;        /* disk number start               2 bytes */
+    uint16_t internal_fa;           /* internal file attributes        2 bytes */
+    uint32_t external_fa;           /* external file attributes        4 bytes */
 
-    tm_unz tmu_date;
+    uint64_t disk_offset;
 } unz_file_info;
 
-extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1,
-                                                 const char* fileName2,
-                                                 int iCaseSensitivity));
-/*
-   Compare two filename (fileName1,fileName2).
-   If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
-   If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
-                                or strcasecmp)
-   If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
-    (like 1 on Unix, 2 on Windows)
-*/
+/***************************************************************************/
+/* Opening and close a zip file */
 
+extern unzFile ZEXPORT unzOpen(const char *path);
+extern unzFile ZEXPORT unzOpen64(const void *path);
+/* Open a Zip file.
 
-extern unzFile ZEXPORT unzOpen OF((const char *path));
-/*
-  Open a Zip file. path contain the full pathname (by example,
-     on a Windows XP computer "c:\\zlib\\zlib113.zip" or on an Unix computer
-     "zlib/zlib113.zip".
-     If the zipfile cannot be opened (file don't exist or in not valid), the
-       return value is NULL.
-     Else, the return value is a unzFile Handle, usable with other function
-       of this unzip package.
-*/
+   path should contain the full path (by example, on a Windows XP computer 
+      "c:\\zlib\\zlib113.zip" or on an Unix computer "zlib/zlib113.zip". 
+   return NULL if zipfile cannot be opened or doesn't exist
+   return unzFile handle if no error
 
-extern unzFile ZEXPORT unzOpen2 OF((const char *path,
-                                    zlib_filefunc_def* pzlib_filefunc_def));
-/*
-   Open a Zip file, like unzOpen, but provide a set of file low level API
-      for read/write the zip file (see ioapi.h)
-*/
+   NOTE: The "64" function take a const void *pointer, because  the path is just the value passed to the
+   open64_file_func callback. Under Windows, if UNICODE is defined, using fill_fopen64_filefunc, the path 
+   is a pointer to a wide unicode string  (LPCTSTR is LPCWSTR), so const char *does not describe the reality */
 
-extern int ZEXPORT unzClose OF((unzFile file));
-/*
-  Close a ZipFile opened with unzipOpen.
-  If there is files inside the .Zip opened with unzOpenCurrentFile (see later),
-    these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
-  return UNZ_OK if there is no problem. */
+extern unzFile ZEXPORT unzOpen2(const char *path, zlib_filefunc_def *pzlib_filefunc_def);
+/* Open a Zip file, like unzOpen, but provide a set of file low level API for read/write operations */
+extern unzFile ZEXPORT unzOpen2_64(const void *path, zlib_filefunc64_def *pzlib_filefunc_def);
+/* Open a Zip file, like unz64Open, but provide a set of file low level API for read/write 64-bit operations */
 
-extern int ZEXPORT unzGetGlobalInfo OF((unzFile file,
-                                        unz_global_info *pglobal_info));
-/*
-  Write info about the ZipFile in the *pglobal_info structure.
-  No preparation of the structure is needed
-  return UNZ_OK if there is no problem. */
+extern int ZEXPORT unzClose(unzFile file);
+/* Close a ZipFile opened with unzOpen. If there is files inside the .Zip opened with unzOpenCurrentFile,
+   these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
 
+   return UNZ_OK if there is no error */
 
-extern int ZEXPORT unzGetGlobalComment OF((unzFile file,
-                                           char *szComment,
-                                           uLong uSizeBuf));
-/*
-  Get the global comment string of the ZipFile, in the szComment buffer.
-  uSizeBuf is the size of the szComment buffer.
-  return the number of byte copied or an error code <0
-*/
+extern int ZEXPORT unzGetGlobalInfo(unzFile file, unz_global_info *pglobal_info);
+extern int ZEXPORT unzGetGlobalInfo64(unzFile file, unz_global_info64 *pglobal_info);
+/* Write info about the ZipFile in the *pglobal_info structure.
 
+   return UNZ_OK if no error */
+
+extern int ZEXPORT unzGetGlobalComment(unzFile file, char *comment, uint16_t comment_size);
+/* Get the global comment string of the ZipFile, in the comment buffer.
+
+   uSizeBuf is the size of the szComment buffer.
+   return the number of byte copied or an error code <0 */
 
 /***************************************************************************/
-/* Unzip package allow you browse the directory of the zipfile */
+/* Reading the content of the current zipfile, you can open it, read data from it, and close it
+   (you can close it before reading all the file) */
 
-extern int ZEXPORT unzGoToFirstFile OF((unzFile file));
-/*
-  Set the current file of the zipfile to the first file.
-  return UNZ_OK if there is no problem
-*/
+extern int ZEXPORT unzOpenCurrentFile(unzFile file);
+/* Open for reading data the current file in the zipfile.
 
-extern int ZEXPORT unzGoToNextFile OF((unzFile file));
-/*
-  Set the current file of the zipfile to the next file.
-  return UNZ_OK if there is no problem
-  return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
-*/
+   return UNZ_OK if no error */
 
-extern int ZEXPORT unzLocateFile OF((unzFile file,
-                     const char *szFileName,
-                     int iCaseSensitivity));
-/*
-  Try locate the file szFileName in the zipfile.
-  For the iCaseSensitivity signification, see unzStringFileNameCompare
+extern int ZEXPORT unzOpenCurrentFilePassword(unzFile file, const char *password);
+/* Open for reading data the current file in the zipfile.
+   password is a crypting password
 
-  return value :
-  UNZ_OK if the file is found. It becomes the current file.
-  UNZ_END_OF_LIST_OF_FILE if the file is not found
-*/
+   return UNZ_OK if no error */
 
+extern int ZEXPORT unzOpenCurrentFile2(unzFile file, int *method, int *level, int raw);
+/* Same as unzOpenCurrentFile, but open for read raw the file (not uncompress)
+   if raw==1 *method will receive method of compression, *level will receive level of compression
+
+   NOTE: you can set level parameter as NULL (if you did not want known level,
+         but you CANNOT set method parameter as NULL */
+
+extern int ZEXPORT unzOpenCurrentFile3(unzFile file, int *method, int *level, int raw, const char *password);
+/* Same as unzOpenCurrentFile, but takes extra parameter password for encrypted files */
+
+extern int ZEXPORT unzReadCurrentFile(unzFile file, voidp buf, uint32_t len);
+/* Read bytes from the current file (opened by unzOpenCurrentFile)
+   buf contain buffer where data must be copied
+   len the size of buf.
+
+   return the number of byte copied if somes bytes are copied
+   return 0 if the end of file was reached
+   return <0 with error code if there is an error (UNZ_ERRNO for IO error, or zLib error for uncompress error) */
+
+extern int ZEXPORT unzGetCurrentFileInfo(unzFile file, unz_file_info *pfile_info, char *filename, 
+    uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size);
+extern int ZEXPORT unzGetCurrentFileInfo64(unzFile file, unz_file_info64 *pfile_info, char *filename,
+    uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size);
+/* Get Info about the current file
+
+   pfile_info if != NULL, the *pfile_info structure will contain somes info about the current file
+   filename if != NULL, the file name string will be copied in filename 
+   filename_size is the size of the filename buffer
+   extrafield if != NULL, the extra field information from the central header will be copied in to
+   extrafield_size is the size of the extraField buffer 
+   comment if != NULL, the comment string of the file will be copied in to
+   comment_size is the size of the comment buffer */
+
+extern int ZEXPORT unzGetLocalExtrafield(unzFile file, voidp buf, uint32_t len);
+/* Read extra field from the current file (opened by unzOpenCurrentFile)
+   This is the local-header version of the extra field (sometimes, there is
+   more info in the local-header version than in the central-header)
+
+   if buf == NULL, it return the size of the local extra field
+   if buf != NULL, len is the size of the buffer, the extra header is copied in buf.
+
+   return number of bytes copied in buf, or (if <0) the error code */
+
+extern int ZEXPORT unzCloseCurrentFile(unzFile file);
+/* Close the file in zip opened with unzOpenCurrentFile
+
+   return UNZ_CRCERROR if all the file was read but the CRC is not good */
+
+/***************************************************************************/
+/* Browse the directory of the zipfile */
+
+typedef int (*unzFileNameComparer)(unzFile file, const char *filename1, const char *filename2);
+typedef int (*unzIteratorFunction)(unzFile file);
+typedef int (*unzIteratorFunction2)(unzFile file, unz_file_info64 *pfile_info, char *filename,
+    uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size);
+
+extern int ZEXPORT unzGoToFirstFile(unzFile file);
+/* Set the current file of the zipfile to the first file.
+
+   return UNZ_OK if no error */
+
+extern int ZEXPORT unzGoToFirstFile2(unzFile file, unz_file_info64 *pfile_info, char *filename,
+    uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size);
+/* Set the current file of the zipfile to the first file and retrieves the current info on success. 
+   Not as seek intensive as unzGoToFirstFile + unzGetCurrentFileInfo.
+
+   return UNZ_OK if no error */
+
+extern int ZEXPORT unzGoToNextFile(unzFile file);
+/* Set the current file of the zipfile to the next file.
+
+   return UNZ_OK if no error
+   return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest */
+
+extern int ZEXPORT unzGoToNextFile2(unzFile file, unz_file_info64 *pfile_info, char *filename,
+    uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size);
+/* Set the current file of the zipfile to the next file and retrieves the current 
+   info on success. Does less seeking around than unzGotoNextFile + unzGetCurrentFileInfo.
+
+   return UNZ_OK if no error
+   return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest */
+
+extern int ZEXPORT unzLocateFile(unzFile file, const char *filename, unzFileNameComparer filename_compare_func);
+/* Try locate the file szFileName in the zipfile. For custom filename comparison pass in comparison function.
+
+   return UNZ_OK if the file is found (it becomes the current file)
+   return UNZ_END_OF_LIST_OF_FILE if the file is not found */
+
+/***************************************************************************/
+/* Raw access to zip file */
 
-/* ****************************************** */
-/* Ryan supplied functions */
-/* unz_file_info contain information about a file in the zipfile */
 typedef struct unz_file_pos_s
 {
-    uLong pos_in_zip_directory;   /* offset in zip file directory */
-    uLong num_of_file;            /* # of file */
+    uint32_t pos_in_zip_directory;  /* offset in zip file directory */
+    uint32_t num_of_file;           /* # of file */
 } unz_file_pos;
 
-extern int ZEXPORT unzGetFilePos(
-    unzFile file,
-    unz_file_pos* file_pos);
+extern int ZEXPORT unzGetFilePos(unzFile file, unz_file_pos *file_pos);
+extern int ZEXPORT unzGoToFilePos(unzFile file, unz_file_pos *file_pos);
 
-extern int ZEXPORT unzGoToFilePos(
-    unzFile file,
-    unz_file_pos* file_pos);
+typedef struct unz64_file_pos_s
+{
+    uint64_t pos_in_zip_directory;   /* offset in zip file directory */
+    uint64_t num_of_file;            /* # of file */
+} unz64_file_pos;
 
-/* ****************************************** */
-
-extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file,
-                         unz_file_info *pfile_info,
-                         char *szFileName,
-                         uLong fileNameBufferSize,
-                         void *extraField,
-                         uLong extraFieldBufferSize,
-                         char *szComment,
-                         uLong commentBufferSize));
-/*
-  Get Info about the current file
-  if pfile_info!=NULL, the *pfile_info structure will contain somes info about
-        the current file
-  if szFileName!=NULL, the filemane string will be copied in szFileName
-            (fileNameBufferSize is the size of the buffer)
-  if extraField!=NULL, the extra field information will be copied in extraField
-            (extraFieldBufferSize is the size of the buffer).
-            This is the Central-header version of the extra field
-  if szComment!=NULL, the comment string of the file will be copied in szComment
-            (commentBufferSize is the size of the buffer)
-*/
-
-/***************************************************************************/
-/* for reading the content of the current zipfile, you can open it, read data
-   from it, and close it (you can close it before reading all the file)
-   */
-
-extern int ZEXPORT unzOpenCurrentFile OF((unzFile file));
-/*
-  Open for reading data the current file in the zipfile.
-  If there is no error, the return value is UNZ_OK.
-*/
-
-extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file,
-                                                  const char* password));
-/*
-  Open for reading data the current file in the zipfile.
-  password is a crypting password
-  If there is no error, the return value is UNZ_OK.
-*/
-
-extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file,
-                                           int* method,
-                                           int* level,
-                                           int raw));
-/*
-  Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
-    if raw==1
-  *method will receive method of compression, *level will receive level of
-     compression
-  note : you can set level parameter as NULL (if you did not want known level,
-         but you CANNOT set method parameter as NULL
-*/
-
-extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file,
-                                           int* method,
-                                           int* level,
-                                           int raw,
-                                           const char* password));
-/*
-  Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
-    if raw==1
-  *method will receive method of compression, *level will receive level of
-     compression
-  note : you can set level parameter as NULL (if you did not want known level,
-         but you CANNOT set method parameter as NULL
-*/
-
-
-extern int ZEXPORT unzCloseCurrentFile OF((unzFile file));
-/*
-  Close the file in zip opened with unzOpenCurrentFile
-  Return UNZ_CRCERROR if all the file was read but the CRC is not good
-*/
-
-extern int ZEXPORT unzReadCurrentFile OF((unzFile file,
-                      voidp buf,
-                      unsigned len));
-/*
-  Read bytes from the current file (opened by unzOpenCurrentFile)
-  buf contain buffer where data must be copied
-  len the size of buf.
-
-  return the number of byte copied if somes bytes are copied
-  return 0 if the end of file was reached
-  return <0 with error code if there is an error
-    (UNZ_ERRNO for IO error, or zLib error for uncompress error)
-*/
-
-extern z_off_t ZEXPORT unztell OF((unzFile file));
-/*
-  Give the current position in uncompressed data
-*/
-
-extern int ZEXPORT unzeof OF((unzFile file));
-/*
-  return 1 if the end of file was reached, 0 elsewhere
-*/
-
-extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file,
-                                             voidp buf,
-                                             unsigned len));
-/*
-  Read extra field from the current file (opened by unzOpenCurrentFile)
-  This is the local-header version of the extra field (sometimes, there is
-    more info in the local-header version than in the central-header)
-
-  if buf==NULL, it return the size of the local extra field
-
-  if buf!=NULL, len is the size of the buffer, the extra header is copied in
-    buf.
-  the return value is the number of bytes copied in buf, or (if <0)
-    the error code
-*/
-
-/***************************************************************************/
+extern int ZEXPORT unzGetFilePos64(unzFile file, unz64_file_pos *file_pos);
+extern int ZEXPORT unzGoToFilePos64(unzFile file, const unz64_file_pos *file_pos);
 
+extern int32_t ZEXPORT unzGetOffset(unzFile file);
+extern int64_t ZEXPORT unzGetOffset64(unzFile file);
 /* Get the current file offset */
-extern uLong ZEXPORT unzGetOffset (unzFile file);
 
+extern int ZEXPORT unzSetOffset(unzFile file, uint32_t pos);
+extern int ZEXPORT unzSetOffset64(unzFile file, uint64_t pos);
 /* Set the current file offset */
-extern int ZEXPORT unzSetOffset (unzFile file, uLong pos);
 
+extern int32_t ZEXPORT unzTell(unzFile file);
+extern int64_t ZEXPORT unzTell64(unzFile file);
+/* return current position in uncompressed data */
 
+extern int ZEXPORT unzSeek(unzFile file, uint32_t offset, int origin);
+extern int ZEXPORT unzSeek64(unzFile file, uint64_t offset, int origin);
+/* Seek within the uncompressed data if compression method is storage */
+
+extern int ZEXPORT unzEndOfFile(unzFile file);
+/* return 1 if the end of file was reached, 0 elsewhere */
+
+/***************************************************************************/
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* _unz_H */
+#endif /* _UNZ_H */
diff --git a/Engine/lib/assimp/contrib/utf8cpp/source/utf8/checked.h b/Engine/lib/assimp/contrib/utf8cpp/source/utf8/checked.h
index 133115513..648636e46 100644
--- a/Engine/lib/assimp/contrib/utf8cpp/source/utf8/checked.h
+++ b/Engine/lib/assimp/contrib/utf8cpp/source/utf8/checked.h
@@ -1,4 +1,4 @@
-// Copyright 2006 Nemanja Trifunovic
+// Copyright 2006-2016 Nemanja Trifunovic
 
 /*
 Permission is hereby granted, free of charge, to any person or organization
@@ -41,8 +41,8 @@ namespace utf8
     class invalid_code_point : public exception {
         uint32_t cp;
     public:
-        invalid_code_point(uint32_t cp) : cp(cp) {}
-        virtual const char* what() const throw() { return "Invalid code point"; }
+        invalid_code_point(uint32_t codepoint) : cp(codepoint) {}
+        virtual const char* what() const NOEXCEPT OVERRIDE { return "Invalid code point"; }
         uint32_t code_point() const {return cp;}
     };
 
@@ -50,7 +50,7 @@ namespace utf8
         uint8_t u8;
     public:
         invalid_utf8 (uint8_t u) : u8(u) {}
-        virtual const char* what() const throw() { return "Invalid UTF-8"; }
+        virtual const char* what() const NOEXCEPT OVERRIDE { return "Invalid UTF-8"; }
         uint8_t utf8_octet() const {return u8;}
     };
 
@@ -58,13 +58,13 @@ namespace utf8
         uint16_t u16;
     public:
         invalid_utf16 (uint16_t u) : u16(u) {}
-        virtual const char* what() const throw() { return "Invalid UTF-16"; }
+        virtual const char* what() const NOEXCEPT OVERRIDE { return "Invalid UTF-16"; }
         uint16_t utf16_word() const {return u16;}
     };
 
     class not_enough_room : public exception {
     public:
-        virtual const char* what() const throw() { return "Not enough space"; }
+        virtual const char* what() const NOEXCEPT OVERRIDE { return "Not enough space"; }
     };
 
     /// The library API - functions intended to be called by the users
@@ -107,7 +107,9 @@ namespace utf8
                         *out++ = *it;
                     break;
                 case internal::NOT_ENOUGH_ROOM:
-                    throw not_enough_room();
+                    out = utf8::append (replacement, out);
+                    start = end;
+                    break;
                 case internal::INVALID_LEAD:
                     out = utf8::append (replacement, out);
                     ++start;
@@ -174,23 +176,19 @@ namespace utf8
         return utf8::peek_next(it, end);
     }
 
-    /// Deprecated in versions that include "prior"
-    template <typename octet_iterator>
-    uint32_t previous(octet_iterator& it, octet_iterator pass_start)
-    {
-        octet_iterator end = it;
-        while (utf8::internal::is_trail(*(--it)))
-            if (it == pass_start)
-                throw invalid_utf8(*it); // error - no lead byte in the sequence
-        octet_iterator temp = it;
-        return utf8::next(temp, end);
-    }
-
     template <typename octet_iterator, typename distance_type>
     void advance (octet_iterator& it, distance_type n, octet_iterator end)
     {
-        for (distance_type i = 0; i < n; ++i)
-            utf8::next(it, end);
+        const distance_type zero(0);
+        if (n < zero) {
+            // backward
+            for (distance_type i = n; i < zero; ++i)
+                utf8::prior(it, end);
+        } else {
+            // forward
+            for (distance_type i = zero; i < n; ++i)
+                utf8::next(it, end);
+        }
     }
 
     template <typename octet_iterator>
@@ -233,7 +231,7 @@ namespace utf8
     template <typename u16bit_iterator, typename octet_iterator>
     u16bit_iterator utf8to16 (octet_iterator start, octet_iterator end, u16bit_iterator result)
     {
-        while (start != end) {
+        while (start < end) {
             uint32_t cp = utf8::next(start, end);
             if (cp > 0xffff) { //make a surrogate pair
                 *result++ = static_cast<uint16_t>((cp >> 10)   + internal::LEAD_OFFSET);
@@ -257,7 +255,7 @@ namespace utf8
     template <typename octet_iterator, typename u32bit_iterator>
     u32bit_iterator utf8to32 (octet_iterator start, octet_iterator end, u32bit_iterator result)
     {
-        while (start != end)
+        while (start < end)
             (*result++) = utf8::next(start, end);
 
         return result;
@@ -265,16 +263,21 @@ namespace utf8
 
     // The iterator class
     template <typename octet_iterator>
-    class iterator : public std::iterator <std::bidirectional_iterator_tag, uint32_t> {
+    class iterator {
       octet_iterator it;
       octet_iterator range_start;
       octet_iterator range_end;
       public:
+      typedef uint32_t value_type;
+      typedef uint32_t* pointer;
+      typedef uint32_t& reference;
+      typedef std::ptrdiff_t difference_type;
+      typedef std::bidirectional_iterator_tag iterator_category;
       iterator () {}
       explicit iterator (const octet_iterator& octet_it,
-                         const octet_iterator& range_start,
-                         const octet_iterator& range_end) :
-               it(octet_it), range_start(range_start), range_end(range_end)
+                         const octet_iterator& rangestart,
+                         const octet_iterator& rangeend) :
+               it(octet_it), range_start(rangestart), range_end(rangeend)
       {
           if (it < range_start || it > range_end)
               throw std::out_of_range("Invalid utf-8 iterator position");
@@ -322,6 +325,9 @@ namespace utf8
 
 } // namespace utf8
 
+#if UTF_CPP_CPLUSPLUS >= 201103L // C++ 11 or later
+#include "cpp11.h"
+#endif // C++ 11 or later
+
 #endif //header guard
 
-
diff --git a/Engine/lib/assimp/contrib/utf8cpp/source/utf8/core.h b/Engine/lib/assimp/contrib/utf8cpp/source/utf8/core.h
index 693d388c0..244e89231 100644
--- a/Engine/lib/assimp/contrib/utf8cpp/source/utf8/core.h
+++ b/Engine/lib/assimp/contrib/utf8cpp/source/utf8/core.h
@@ -30,6 +30,23 @@ DEALINGS IN THE SOFTWARE.
 
 #include <iterator>
 
+// Determine the C++ standard version.
+// If the user defines UTF_CPP_CPLUSPLUS, use that.
+// Otherwise, trust the unreliable predefined macro __cplusplus
+
+#if !defined UTF_CPP_CPLUSPLUS
+    #define UTF_CPP_CPLUSPLUS __cplusplus
+#endif
+
+#if UTF_CPP_CPLUSPLUS >= 201103L // C++ 11 or later
+    #define OVERRIDE override
+    #define NOEXCEPT noexcept
+#else // C++ 98/03
+    #define OVERRIDE
+    #define NOEXCEPT throw()
+#endif // C++ 11 or later
+
+
 namespace utf8
 {
     // The typedefs for 8-bit, 16-bit and 32-bit unsigned integers
@@ -49,8 +66,8 @@ namespace internal
     const uint16_t LEAD_SURROGATE_MAX  = 0xdbffu;
     const uint16_t TRAIL_SURROGATE_MIN = 0xdc00u;
     const uint16_t TRAIL_SURROGATE_MAX = 0xdfffu;
-    const uint16_t LEAD_OFFSET         = LEAD_SURROGATE_MIN - (0x10000 >> 10);
-    const uint32_t SURROGATE_OFFSET    = 0x10000u - (LEAD_SURROGATE_MIN << 10) - TRAIL_SURROGATE_MIN;
+    const uint16_t LEAD_OFFSET         = 0xd7c0u;       // LEAD_SURROGATE_MIN - (0x10000 >> 10)
+    const uint32_t SURROGATE_OFFSET    = 0xfca02400u;   // 0x10000u - (LEAD_SURROGATE_MIN << 10) - TRAIL_SURROGATE_MIN
 
     // Maximum valid value for a Unicode code point
     const uint32_t CODE_POINT_MAX      = 0x0010ffffu;
@@ -142,7 +159,7 @@ namespace internal
 
         if (!utf8::internal::is_trail(*it))
             return INCOMPLETE_SEQUENCE;
-        
+
         return UTF8_OK;
     }
 
@@ -165,7 +182,7 @@ namespace internal
     {
         if (it == end) 
             return NOT_ENOUGH_ROOM;
-        
+
         code_point = utf8::internal::mask8(*it);
 
         UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
@@ -222,6 +239,9 @@ namespace internal
     template <typename octet_iterator>
     utf_error validate_next(octet_iterator& it, octet_iterator end, uint32_t& code_point)
     {
+        if (it == end)
+            return NOT_ENOUGH_ROOM;
+
         // Save the original value of it so we can go back in case of failure
         // Of course, it does not make much sense with i.e. stream iterators
         octet_iterator original_it = it;
@@ -234,7 +254,7 @@ namespace internal
         // Get trail octets and calculate the code point
         utf_error err = UTF8_OK;
         switch (length) {
-            case 0: 
+            case 0:
                 return INVALID_LEAD;
             case 1:
                 err = utf8::internal::get_sequence_1(it, end, cp);
@@ -310,18 +330,7 @@ namespace internal
             ((it != end) && (utf8::internal::mask8(*it++)) == bom[1]) &&
             ((it != end) && (utf8::internal::mask8(*it))   == bom[2])
            );
-    }
-	
-    //Deprecated in release 2.3 
-    template <typename octet_iterator>
-    inline bool is_bom (octet_iterator it)
-    {
-        return (
-            (utf8::internal::mask8(*it++)) == bom[0] &&
-            (utf8::internal::mask8(*it++)) == bom[1] &&
-            (utf8::internal::mask8(*it))   == bom[2]
-           );
-    }
+    }	
 } // namespace utf8
 
 #endif // header guard
diff --git a/Engine/lib/assimp/contrib/utf8cpp/source/utf8/cpp11.h b/Engine/lib/assimp/contrib/utf8cpp/source/utf8/cpp11.h
new file mode 100644
index 000000000..d93961b04
--- /dev/null
+++ b/Engine/lib/assimp/contrib/utf8cpp/source/utf8/cpp11.h
@@ -0,0 +1,103 @@
+// Copyright 2018 Nemanja Trifunovic
+
+/*
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+
+#ifndef UTF8_FOR_CPP_a184c22c_d012_11e8_a8d5_f2801f1b9fd1
+#define UTF8_FOR_CPP_a184c22c_d012_11e8_a8d5_f2801f1b9fd1
+
+#include "checked.h"
+#include <string>
+
+namespace utf8
+{
+
+    inline void append(char32_t cp, std::string& s)
+    {
+        append(uint32_t(cp), std::back_inserter(s));
+    }
+
+    inline std::string utf16to8(const std::u16string& s)
+    {
+        std::string result;
+        utf16to8(s.begin(), s.end(), std::back_inserter(result));
+        return result;
+    }
+
+    inline std::u16string utf8to16(const std::string& s)
+    {
+        std::u16string result;
+        utf8to16(s.begin(), s.end(), std::back_inserter(result));
+        return result;
+    }
+
+    inline std::string utf32to8(const std::u32string& s)
+    {
+        std::string result;
+        utf32to8(s.begin(), s.end(), std::back_inserter(result));
+        return result;
+    }
+
+    inline std::u32string utf8to32(const std::string& s)
+    {
+        std::u32string result;
+        utf8to32(s.begin(), s.end(), std::back_inserter(result));
+        return result;
+    }
+
+    inline std::size_t find_invalid(const std::string& s)
+    {
+        std::string::const_iterator invalid = find_invalid(s.begin(), s.end());
+        return (invalid == s.end()) ? std::string::npos : (invalid - s.begin());
+    }
+
+    inline bool is_valid(const std::string& s)
+    {
+        return is_valid(s.begin(), s.end());
+    }
+
+    inline std::string replace_invalid(const std::string& s, char32_t replacement)
+    {
+        std::string result;
+        replace_invalid(s.begin(), s.end(), std::back_inserter(result), replacement);
+        return result;
+    }
+
+    inline std::string replace_invalid(const std::string& s)
+    {
+        std::string result;
+        replace_invalid(s.begin(), s.end(), std::back_inserter(result));
+        return result;
+    }
+
+    inline bool starts_with_bom(const std::string& s)
+    {
+        return starts_with_bom(s.begin(), s.end());
+    }
+ 
+} // namespace utf8
+
+#endif // header guard
+
diff --git a/Engine/lib/assimp/contrib/utf8cpp/source/utf8/unchecked.h b/Engine/lib/assimp/contrib/utf8cpp/source/utf8/unchecked.h
index cb2427166..0e1b51cc7 100644
--- a/Engine/lib/assimp/contrib/utf8cpp/source/utf8/unchecked.h
+++ b/Engine/lib/assimp/contrib/utf8cpp/source/utf8/unchecked.h
@@ -32,13 +32,13 @@ DEALINGS IN THE SOFTWARE.
 
 namespace utf8
 {
-    namespace unchecked 
+    namespace unchecked
     {
         template <typename octet_iterator>
         octet_iterator append(uint32_t cp, octet_iterator result)
         {
             if (cp < 0x80)                        // one octet
-                *(result++) = static_cast<uint8_t>(cp);  
+                *(result++) = static_cast<uint8_t>(cp);
             else if (cp < 0x800) {                // two octets
                 *(result++) = static_cast<uint8_t>((cp >> 6)          | 0xc0);
                 *(result++) = static_cast<uint8_t>((cp & 0x3f)        | 0x80);
@@ -57,6 +57,46 @@ namespace utf8
             return result;
         }
 
+        template <typename octet_iterator, typename output_iterator>
+        output_iterator replace_invalid(octet_iterator start, octet_iterator end, output_iterator out, uint32_t replacement)
+        {
+            while (start != end) {
+                octet_iterator sequence_start = start;
+                internal::utf_error err_code = utf8::internal::validate_next(start, end);
+                switch (err_code) {
+                    case internal::UTF8_OK :
+                        for (octet_iterator it = sequence_start; it != start; ++it)
+                            *out++ = *it;
+                        break;
+                    case internal::NOT_ENOUGH_ROOM:
+                        out = utf8::unchecked::append (replacement, out);
+                        start = end;
+                        break;
+                    case internal::INVALID_LEAD:
+                        out = utf8::unchecked::append (replacement, out);
+                        ++start;
+                        break;
+                    case internal::INCOMPLETE_SEQUENCE:
+                    case internal::OVERLONG_SEQUENCE:
+                    case internal::INVALID_CODE_POINT:
+                        out = utf8::unchecked::append (replacement, out);
+                        ++start;
+                        // just one replacement mark for the sequence
+                        while (start != end && utf8::internal::is_trail(*start))
+                            ++start;
+                        break;
+                }
+            }
+            return out;
+        }
+
+        template <typename octet_iterator, typename output_iterator>
+        inline output_iterator replace_invalid(octet_iterator start, octet_iterator end, output_iterator out)
+        {
+            static const uint32_t replacement_marker = utf8::internal::mask16(0xfffd);
+            return utf8::unchecked::replace_invalid(start, end, out, replacement_marker);
+        }
+
         template <typename octet_iterator>
         uint32_t next(octet_iterator& it)
         {
@@ -85,13 +125,13 @@ namespace utf8
                     break;
             }
             ++it;
-            return cp;        
+            return cp;
         }
 
         template <typename octet_iterator>
         uint32_t peek_next(octet_iterator it)
         {
-            return utf8::unchecked::next(it);    
+            return utf8::unchecked::next(it);
         }
 
         template <typename octet_iterator>
@@ -102,18 +142,19 @@ namespace utf8
             return utf8::unchecked::next(temp);
         }
 
-        // Deprecated in versions that include prior, but only for the sake of consistency (see utf8::previous)
-        template <typename octet_iterator>
-        inline uint32_t previous(octet_iterator& it)
-        {
-            return utf8::unchecked::prior(it);
-        }
-
         template <typename octet_iterator, typename distance_type>
         void advance (octet_iterator& it, distance_type n)
         {
-            for (distance_type i = 0; i < n; ++i)
-                utf8::unchecked::next(it);
+            const distance_type zero(0);
+            if (n < zero) {
+                // backward
+                for (distance_type i = n; i < zero; ++i)
+                    utf8::unchecked::prior(it);
+            } else {
+                // forward
+                for (distance_type i = zero; i < n; ++i)
+                    utf8::unchecked::next(it);
+            }
         }
 
         template <typename octet_iterator>
@@ -128,7 +169,7 @@ namespace utf8
 
         template <typename u16bit_iterator, typename octet_iterator>
         octet_iterator utf16to8 (u16bit_iterator start, u16bit_iterator end, octet_iterator result)
-        {       
+        {
             while (start != end) {
                 uint32_t cp = utf8::internal::mask16(*start++);
             // Take care of surrogate pairs first
@@ -138,7 +179,7 @@ namespace utf8
                 }
                 result = utf8::unchecked::append(cp, result);
             }
-            return result;         
+            return result;
         }
 
         template <typename u16bit_iterator, typename octet_iterator>
@@ -176,9 +217,14 @@ namespace utf8
 
         // The iterator class
         template <typename octet_iterator>
-          class iterator : public std::iterator <std::bidirectional_iterator_tag, uint32_t> { 
+          class iterator {
             octet_iterator it;
             public:
+            typedef uint32_t value_type;
+            typedef uint32_t* pointer;
+            typedef uint32_t& reference;
+            typedef std::ptrdiff_t difference_type;
+            typedef std::bidirectional_iterator_tag iterator_category;
             iterator () {}
             explicit iterator (const octet_iterator& octet_it): it(octet_it) {}
             // the default "big three" are OK
diff --git a/Engine/lib/assimp/contrib/zip/.travis.sh b/Engine/lib/assimp/contrib/zip/.travis.sh
index 22974b1ff..9cb03ee87 100755
--- a/Engine/lib/assimp/contrib/zip/.travis.sh
+++ b/Engine/lib/assimp/contrib/zip/.travis.sh
@@ -15,4 +15,4 @@ else
     make -j 8
     make install
     ASAN_OPTIONS=detect_leaks=0 LSAN_OPTIONS=verbosity=1:log_threads=1 ctest -V
-fi
\ No newline at end of file
+fi
diff --git a/Engine/lib/assimp/contrib/zip/.travis.yml b/Engine/lib/assimp/contrib/zip/.travis.yml
index 86bac1cca..42f84dd25 100644
--- a/Engine/lib/assimp/contrib/zip/.travis.yml
+++ b/Engine/lib/assimp/contrib/zip/.travis.yml
@@ -19,4 +19,4 @@ after_success:
   - make
   - make test
   # Uploading report to CodeCov
-  - bash <(curl -s https://codecov.io/bash)
\ No newline at end of file
+  - bash <(curl -s https://codecov.io/bash)
diff --git a/Engine/lib/assimp/contrib/zip/CMakeLists.txt b/Engine/lib/assimp/contrib/zip/CMakeLists.txt
index b46dbb1db..bba4e7bde 100644
--- a/Engine/lib/assimp/contrib/zip/CMakeLists.txt
+++ b/Engine/lib/assimp/contrib/zip/CMakeLists.txt
@@ -1,39 +1,105 @@
-cmake_minimum_required(VERSION 2.8)
-project(zip)
-enable_language(C)
-set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
+cmake_minimum_required(VERSION 3.4)
 
-if (MSVC)
-  # Use secure functions by defaualt and suppress warnings about "deprecated" functions
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /D _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES=1")
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /D _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT=1")
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /D _CRT_NONSTDC_NO_WARNINGS=1 /D _CRT_SECURE_NO_WARNINGS=1")
-elseif ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU" OR
-        "${CMAKE_C_COMPILER_ID}" STREQUAL "Clang" OR
-        "${CMAKE_C_COMPILER_ID}" STREQUAL "AppleClang")
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99 -Wall -Wextra -Werror -pedantic")
-endif (MSVC)
+project(zip
+  LANGUAGES C
+  VERSION "0.1.19")
+set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
+set(CMAKE_VERBOSE_MAKEFILE ON)
+option(CMAKE_DISABLE_TESTING "Disable test creation" OFF)
 
 # zip
 set(SRC src/miniz.h src/zip.h src/zip.c)
-add_library(${PROJECT_NAME} ${SRC})
-target_include_directories(${PROJECT_NAME} INTERFACE src)
+
+# this is the "object library" target: compiles the sources only once
+add_library(OBJLIB OBJECT ${SRC})
+# shared libraries need PIC
+set_property(TARGET OBJLIB PROPERTY POSITION_INDEPENDENT_CODE 1)
+
+# static and shared libraries built from the same object files
+if (BUILD_SHARED_LIBS)
+  add_library(${PROJECT_NAME} SHARED $<TARGET_OBJECTS:OBJLIB>)
+  include(GenerateExportHeader)
+  generate_export_header(${PROJECT_NAME})
+else()
+  add_library(${PROJECT_NAME} STATIC $<TARGET_OBJECTS:OBJLIB>)
+endif()
+
+target_include_directories(${PROJECT_NAME} PUBLIC
+  $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
+  $<INSTALL_INTERFACE:include>
+)
 
 # test
 if (NOT CMAKE_DISABLE_TESTING)
   enable_testing()
   add_subdirectory(test)
   find_package(Sanitizers)
-  add_sanitizers(${PROJECT_NAME} test.exe)
-  add_sanitizers(${PROJECT_NAME} test_miniz.exe)
+  add_sanitizers(${PROJECT_NAME} ${test_out})
 endif()
 
+if (MSVC)
+  # Use secure functions by default and suppress warnings about "deprecated" functions
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /D _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES=1")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /D _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT=1")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /D _CRT_NONSTDC_NO_WARNINGS=1 /D _CRT_SECURE_NO_WARNINGS=1")
+elseif ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU" OR
+        "${CMAKE_C_COMPILER_ID}" STREQUAL "Clang" OR
+        "${CMAKE_C_COMPILER_ID}" STREQUAL "AppleClang")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu99 -Wall -Wextra -Werror -pedantic -Wno-deprecated")
+endif (MSVC)
+
+####
+# Installation (https://github.com/forexample/package-example) {
+
+set(CONFIG_INSTALL_DIR "lib/cmake/${PROJECT_NAME}")
+set(INCLUDE_INSTALL_DIR "include")
+
+set(GENERATED_DIR "${CMAKE_CURRENT_BINARY_DIR}/generated")
+
+# Configuration
+set(VERSION_CONFIG "${GENERATED_DIR}/${PROJECT_NAME}ConfigVersion.cmake")
+set(PROJECT_CONFIG "${GENERATED_DIR}/${PROJECT_NAME}Config.cmake")
+set(TARGETS_EXPORT_NAME "${PROJECT_NAME}Targets")
+set(NAMESPACE "${PROJECT_NAME}::")
+
+# Include module with fuction 'write_basic_package_version_file'
+include(CMakePackageConfigHelpers)
+
+# Note: PROJECT_VERSION is used as a VERSION
+write_basic_package_version_file(
+    "${VERSION_CONFIG}" COMPATIBILITY SameMajorVersion
+)
+
+# Use variables:
+#   * TARGETS_EXPORT_NAME
+#   * PROJECT_NAME
+configure_package_config_file(
+    "cmake/Config.cmake.in"
+    "${PROJECT_CONFIG}"
+    INSTALL_DESTINATION "${CONFIG_INSTALL_DIR}"
+)
+
+install(
+    FILES "${PROJECT_CONFIG}" "${VERSION_CONFIG}"
+    DESTINATION "${CONFIG_INSTALL_DIR}"
+)
+
+install(
+    EXPORT "${TARGETS_EXPORT_NAME}"
+    NAMESPACE "${NAMESPACE}"
+    DESTINATION "${CONFIG_INSTALL_DIR}"
+)
+
+# }
+
 install(TARGETS ${PROJECT_NAME}
+        EXPORT ${TARGETS_EXPORT_NAME}
         RUNTIME DESTINATION bin
         ARCHIVE DESTINATION lib
         LIBRARY DESTINATION lib
-        COMPONENT library)
-install(FILES ${PROJECT_SOURCE_DIR}/src/zip.h DESTINATION include)
+        INCLUDES DESTINATION ${INCLUDE_INSTALL_DIR}
+)
+install(FILES ${PROJECT_SOURCE_DIR}/src/zip.h DESTINATION ${INCLUDE_INSTALL_DIR}/zip)
 
 # uninstall target (https://gitlab.kitware.com/cmake/community/wikis/FAQ#can-i-do-make-uninstall-with-cmake)
 if(NOT TARGET uninstall)
@@ -45,3 +111,12 @@ if(NOT TARGET uninstall)
     add_custom_target(uninstall
         COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake/cmake_uninstall.cmake)
 endif()
+
+find_package(Doxygen)
+if(DOXYGEN_FOUND)
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile @ONLY)
+    add_custom_target(doc
+        ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+        COMMENT "Generating API documentation with Doxygen" VERBATIM)
+endif()
diff --git a/Engine/lib/assimp/contrib/zip/README.md b/Engine/lib/assimp/contrib/zip/README.md
index d5fb8cd20..308327a3f 100644
--- a/Engine/lib/assimp/contrib/zip/README.md
+++ b/Engine/lib/assimp/contrib/zip/README.md
@@ -1,10 +1,7 @@
 ### A portable (OSX/Linux/Windows), simple zip library written in C
 This is done by hacking awesome [miniz](https://code.google.com/p/miniz) library and layering functions on top of the miniz v1.15 API.
 
-[![Windows](https://ci.appveyor.com/api/projects/status/bph8dr3jacgmjv32/branch/master?svg=true&label=windows)](https://ci.appveyor.com/project/kuba--/zip)
-[![Linux](https://travis-ci.org/kuba--/zip.svg?branch=master&label=linux%2fosx)](https://travis-ci.org/kuba--/zip)
-[![Version](https://badge.fury.io/gh/kuba--%2Fzip.svg)](https://github.com/kuba--/zip/releases)
-[![Codecov](https://codecov.io/gh/kuba--/zip/branch/master/graph/badge.svg)](https://codecov.io/gh/kuba--/zip)
+[![Build](https://github.com/kuba--/zip/workflows/build/badge.svg)](https://github.com/kuba--/zip/actions?query=workflow%3Abuild)
 
 
 # The Idea
@@ -71,7 +68,7 @@ int arg = 2;
 zip_extract("foo.zip", "/tmp", on_extract_entry, &arg);
 ```
 
-*   Extract a zip entry into memory.
+* Extract a zip entry into memory.
 ```c
 void *buf = NULL;
 size_t bufsize;
@@ -89,7 +86,7 @@ zip_close(zip);
 free(buf);
 ```
 
-*   Extract a zip entry into memory (no internal allocation).
+* Extract a zip entry into memory (no internal allocation).
 ```c
 unsigned char *buf;
 size_t bufsize;
@@ -110,7 +107,7 @@ zip_close(zip);
 free(buf);
 ```
 
-*   Extract a zip entry into memory using callback.
+* Extract a zip entry into memory using callback.
 ```c
 struct buffer_t {
     char *data;
@@ -144,7 +141,7 @@ free(buf.data);
 ```
 
 
-*   Extract a zip entry into a file.
+* Extract a zip entry into a file.
 ```c
 struct zip_t *zip = zip_open("foo.zip", 0, 'r');
 {
@@ -157,10 +154,52 @@ struct zip_t *zip = zip_open("foo.zip", 0, 'r');
 zip_close(zip);
 ```
 
-*   List of all zip entries
+* Create a new zip archive in memory (stream API).
+
+```c
+char *outbuf = NULL;
+size_t outbufsize = 0;
+
+const char *inbuf = "Append some data here...\0";
+struct zip_t *zip = zip_stream_open(NULL, 0, ZIP_DEFAULT_COMPRESSION_LEVEL, 'w');
+{
+    zip_entry_open(zip, "foo-1.txt");
+    {
+        zip_entry_write(zip, inbuf, strlen(inbuf));
+    }
+    zip_entry_close(zip);
+
+    /* copy compressed stream into outbuf */
+    zip_stream_copy(zip, (void **)&outbuf, &outbufsize);
+}
+zip_stream_close(zip);
+
+free(outbuf);
+```
+
+* Extract a zip entry into a memory (stream API).
+
+```c
+char *buf = NULL;
+ssize_t bufsize = 0;
+
+struct zip_t *zip = zip_stream_open(zipstream, zipstreamsize, 0, 'r');
+{
+    zip_entry_open(zip, "foo-1.txt");
+    {
+        zip_entry_read(zip, (void **)&buf, &bufsize);
+    }
+    zip_entry_close(zip);
+}
+zip_stream_close(zip);
+
+free(buf);
+```
+
+* List of all zip entries
 ```c
 struct zip_t *zip = zip_open("foo.zip", 0, 'r');
-int i, n = zip_total_entries(zip);
+int i, n = zip_entries_total(zip);
 for (i = 0; i < n; ++i) {
     zip_entry_openbyindex(zip, i);
     {
@@ -174,7 +213,50 @@ for (i = 0; i < n; ++i) {
 zip_close(zip);
 ```
 
-## Bindings
+* Compress folder (recursively)
+```c
+void zip_walk(struct zip_t *zip, const char *path) {
+    DIR *dir;
+    struct dirent *entry;
+    char fullpath[MAX_PATH];
+    struct stat s;
+
+    memset(fullpath, 0, MAX_PATH);
+    dir = opendir(path);
+    assert(dir);
+
+    while ((entry = readdir(dir))) {
+      // skip "." and ".."
+      if (!strcmp(entry->d_name, ".\0") || !strcmp(entry->d_name, "..\0"))
+        continue;
+
+      snprintf(fullpath, sizeof(fullpath), "%s/%s", path, entry->d_name);
+      stat(fullpath, &s);
+      if (S_ISDIR(s.st_mode))
+        zip_walk(zip, fullpath);
+      else {
+        zip_entry_open(zip, fullpath);
+        zip_entry_fwrite(zip, fullpath);
+        zip_entry_close(zip);
+      }
+    }
+
+    closedir(dir);
+}
+```
+
+* Deletes zip archive entries.
+```c
+char *entries[] = {"unused.txt", "remove.ini", "delete.me"};
+
+struct zip_t *zip = zip_open("foo.zip", 0, 'd');
+{
+    zip_entries_delete(zip, entries, 3);
+}
+zip_close(zip);
+```
+
+# Bindings
 Compile zip library as a dynamic library.
 ```shell
 $ mkdir build
@@ -183,7 +265,7 @@ $ cmake -DBUILD_SHARED_LIBS=true ..
 $ make
 ```
 
-### Go (cgo)
+### [Go](https://golang.org) (cgo)
 ```go
 package main
 
@@ -213,7 +295,54 @@ func main() {
 }
 ```
 
-### Ruby (ffi)
+### [Rust](https://www.rust-lang.org) (ffi)
+```rust
+extern crate libc;
+use std::ffi::CString;
+
+#[repr(C)]
+pub struct Zip {
+    _private: [u8; 0],
+}
+
+#[link(name = "zip")]
+extern "C" {
+    fn zip_open(path: *const libc::c_char, level: libc::c_int, mode: libc::c_char) -> *mut Zip;
+    fn zip_close(zip: *mut Zip) -> libc::c_void;
+
+    fn zip_entry_open(zip: *mut Zip, entryname: *const libc::c_char) -> libc::c_int;
+    fn zip_entry_close(zip: *mut Zip) -> libc::c_int;
+    fn zip_entry_write(
+        zip: *mut Zip,
+        buf: *const libc::c_void,
+        bufsize: libc::size_t,
+    ) -> libc::c_int;
+}
+
+fn main() {
+    let path = CString::new("/tmp/rust.zip").unwrap();
+    let mode: libc::c_char = 'w' as libc::c_char;
+
+    let entryname = CString::new("test.txt").unwrap();
+    let content = "test content\0";
+
+    unsafe {
+        let zip: *mut Zip = zip_open(path.as_ptr(), 5, mode);
+        {
+            zip_entry_open(zip, entryname.as_ptr());
+            {
+                let buf = content.as_ptr() as *const libc::c_void;
+                let bufsize = content.len() as libc::size_t;
+                zip_entry_write(zip, buf, bufsize);
+            }
+            zip_entry_close(zip);
+        }
+        zip_close(zip);
+    }
+}
+```
+
+### [Ruby](http://www.ruby-lang.org) (ffi)
 Install _ffi_ gem.
 ```shell
 $ gem install ffi
@@ -246,7 +375,7 @@ Zip.zip_entry_close(ptr)
 Zip.zip_close(ptr)
 ```
 
-### Python (cffi)
+### [Python](https://www.python.org) (cffi)
 Install _cffi_ package
 ```shell
 $ pip install cffi
@@ -280,7 +409,36 @@ Zip.zip_entry_close(ptr)
 Zip.zip_close(ptr)
 ```
 
-### Ring
+### [Never](https://never-lang.readthedocs.io/) (ffi)
+```never
+extern "libzip.so" func zip_open(zipname: string, level: int, mode: char) -> c_ptr
+extern "libzip.so" func zip_close(zip: c_ptr) -> void
+
+extern "libzip.so" func zip_entry_open(zip: c_ptr, entryname: string) -> int
+extern "libzip.so" func zip_entry_close(zip: c_ptr) -> int
+extern "libzip.so" func zip_entry_write(zip: c_ptr, buf: string, bufsize: int) -> int
+extern "libzip.so" func zip_entry_fwrite(zip: c_ptr, filename: string) -> int
+
+func main() -> int
+{
+    let content = "Test content"
+
+    let zip = zip_open("/tmp/never.zip", 6, 'w');
+
+    zip_entry_open(zip, "test.file");
+    zip_entry_fwrite(zip, "/tmp/test.txt");
+    zip_entry_close(zip);
+
+    zip_entry_open(zip, "test.content");
+    zip_entry_write(zip, content, length(content));
+    zip_entry_close(zip);
+
+    zip_close(zip);
+    0
+}
+```
+
+### [Ring](http://ring-lang.net)
 The language comes with RingZip based on this library
 ```ring
 load "ziplib.ring"
@@ -297,13 +455,15 @@ new Zip {
 }
 ```
 
-# Contribution Rules/Coding Standards
-No need to throw away your coding style, just do your best to follow default clang-format style.
-Apply `clang-format` to the source files before commit:
-```sh
-for file in $(git ls-files | \grep -E '\.(c|h)$' | \grep -v -- '#')
-do
-    clang-format -i $file
-done
-```
+# Check out more cool projects which use this library:
+- [Filament](https://github.com/google/filament): Filament is a real-time physically based rendering engine for Android, iOS, Linux, macOS, Windows, and WebGL. It is designed to be as small as possible and as efficient as possible on Android.
+- [Hermes JS Engine](https://github.com/facebook/hermes): Hermes is a JavaScript engine optimized for fast start-up of React Native apps on Android. It features ahead-of-time static optimization and compact bytecode.
+- [Open Asset Import Library](https://github.com/assimp/assimp): A library to import and export various 3d-model-formats including scene-post-processing to generate missing render data.
+- [PowerToys](https://github.com/microsoft/PowerToys): Set of utilities for power users to tune and streamline their Windows 10 experience for greater productivity.
+- [The Ring Programming Language](https://ring-lang.github.io): Innovative and practical general-purpose multi-paradigm language.
+- [The V Programming Language](https://github.com/vlang/v): Simple, fast, safe, compiled. For developing maintainable software.
+- [TIC-80](https://github.com/nesbox/TIC-80): TIC-80 is a FREE and OPEN SOURCE fantasy computer for making, playing and sharing tiny games.
+- [Urho3D](https://github.com/urho3d/Urho3D): Urho3D is a free lightweight, cross-platform 2D and 3D game engine implemented in C++ and released under the MIT license. Greatly inspired by OGRE and Horde3D.
+- [Vcpkg](https://github.com/microsoft/vcpkg): Vcpkg helps you manage C and C++ libraries on Windows, Linux and MacOS.
+- [and more...](https://grep.app/search?q=kuba--/zip)
 
diff --git a/Engine/lib/assimp/contrib/zip/src/miniz.h b/Engine/lib/assimp/contrib/zip/src/miniz.h
index 2c27a94d8..0a5560b24 100644
--- a/Engine/lib/assimp/contrib/zip/src/miniz.h
+++ b/Engine/lib/assimp/contrib/zip/src/miniz.h
@@ -221,6 +221,7 @@
 #ifndef MINIZ_HEADER_INCLUDED
 #define MINIZ_HEADER_INCLUDED
 
+#include <stdint.h>
 #include <stdlib.h>
 
 // Defines to completely disable specific portions of miniz.c:
@@ -284,7 +285,8 @@
 /* Set MINIZ_USE_UNALIGNED_LOADS_AND_STORES only if not set */
 #if !defined(MINIZ_USE_UNALIGNED_LOADS_AND_STORES)
 #if MINIZ_X86_OR_X64_CPU
-/* Set MINIZ_USE_UNALIGNED_LOADS_AND_STORES to 1 on CPU's that permit efficient integer loads and stores from unaligned addresses. */
+/* Set MINIZ_USE_UNALIGNED_LOADS_AND_STORES to 1 on CPU's that permit efficient
+ * integer loads and stores from unaligned addresses. */
 #define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 1
 #define MINIZ_UNALIGNED_USE_MEMCPY
 #else
@@ -354,13 +356,51 @@ enum {
   MZ_FIXED = 4
 };
 
+/* miniz error codes. Be sure to update mz_zip_get_error_string() if you add or
+ * modify this enum. */
+typedef enum {
+  MZ_ZIP_NO_ERROR = 0,
+  MZ_ZIP_UNDEFINED_ERROR,
+  MZ_ZIP_TOO_MANY_FILES,
+  MZ_ZIP_FILE_TOO_LARGE,
+  MZ_ZIP_UNSUPPORTED_METHOD,
+  MZ_ZIP_UNSUPPORTED_ENCRYPTION,
+  MZ_ZIP_UNSUPPORTED_FEATURE,
+  MZ_ZIP_FAILED_FINDING_CENTRAL_DIR,
+  MZ_ZIP_NOT_AN_ARCHIVE,
+  MZ_ZIP_INVALID_HEADER_OR_CORRUPTED,
+  MZ_ZIP_UNSUPPORTED_MULTIDISK,
+  MZ_ZIP_DECOMPRESSION_FAILED,
+  MZ_ZIP_COMPRESSION_FAILED,
+  MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE,
+  MZ_ZIP_CRC_CHECK_FAILED,
+  MZ_ZIP_UNSUPPORTED_CDIR_SIZE,
+  MZ_ZIP_ALLOC_FAILED,
+  MZ_ZIP_FILE_OPEN_FAILED,
+  MZ_ZIP_FILE_CREATE_FAILED,
+  MZ_ZIP_FILE_WRITE_FAILED,
+  MZ_ZIP_FILE_READ_FAILED,
+  MZ_ZIP_FILE_CLOSE_FAILED,
+  MZ_ZIP_FILE_SEEK_FAILED,
+  MZ_ZIP_FILE_STAT_FAILED,
+  MZ_ZIP_INVALID_PARAMETER,
+  MZ_ZIP_INVALID_FILENAME,
+  MZ_ZIP_BUF_TOO_SMALL,
+  MZ_ZIP_INTERNAL_ERROR,
+  MZ_ZIP_FILE_NOT_FOUND,
+  MZ_ZIP_ARCHIVE_TOO_LARGE,
+  MZ_ZIP_VALIDATION_FAILED,
+  MZ_ZIP_WRITE_CALLBACK_FAILED,
+  MZ_ZIP_TOTAL_ERRORS
+} mz_zip_error;
+
 // Method
 #define MZ_DEFLATED 8
 
 #ifndef MINIZ_NO_ZLIB_APIS
 
 // Heap allocation callbacks.
-// Note that mz_alloc_func parameter types purpsosely differ from zlib's:
+// Note that mz_alloc_func parameter types purposely differ from zlib's:
 // items/size is size_t, not unsigned long.
 typedef void *(*mz_alloc_func)(void *opaque, size_t items, size_t size);
 typedef void (*mz_free_func)(void *opaque, void *address);
@@ -696,6 +736,7 @@ typedef size_t (*mz_file_read_func)(void *pOpaque, mz_uint64 file_ofs,
                                     void *pBuf, size_t n);
 typedef size_t (*mz_file_write_func)(void *pOpaque, mz_uint64 file_ofs,
                                      const void *pBuf, size_t n);
+typedef mz_bool (*mz_file_needs_keepalive)(void *pOpaque);
 
 struct mz_zip_internal_state_tag;
 typedef struct mz_zip_internal_state_tag mz_zip_internal_state;
@@ -707,13 +748,27 @@ typedef enum {
   MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED = 3
 } mz_zip_mode;
 
-typedef struct mz_zip_archive_tag {
+typedef enum {
+  MZ_ZIP_TYPE_INVALID = 0,
+  MZ_ZIP_TYPE_USER,
+  MZ_ZIP_TYPE_MEMORY,
+  MZ_ZIP_TYPE_HEAP,
+  MZ_ZIP_TYPE_FILE,
+  MZ_ZIP_TYPE_CFILE,
+  MZ_ZIP_TOTAL_TYPES
+} mz_zip_type;
+
+typedef struct {
   mz_uint64 m_archive_size;
   mz_uint64 m_central_directory_file_ofs;
-  mz_uint m_total_files;
-  mz_zip_mode m_zip_mode;
 
-  mz_uint m_file_offset_alignment;
+  /* We only support up to UINT32_MAX files in zip64 mode. */
+  mz_uint32 m_total_files;
+  mz_zip_mode m_zip_mode;
+  mz_zip_type m_zip_type;
+  mz_zip_error m_last_error;
+
+  mz_uint64 m_file_offset_alignment;
 
   mz_alloc_func m_pAlloc;
   mz_free_func m_pFree;
@@ -722,6 +777,7 @@ typedef struct mz_zip_archive_tag {
 
   mz_file_read_func m_pRead;
   mz_file_write_func m_pWrite;
+  mz_file_needs_keepalive m_pNeeds_keepalive;
   void *m_pIO_opaque;
 
   mz_zip_internal_state *m_pState;
@@ -1263,6 +1319,9 @@ mz_uint tdefl_create_comp_flags_from_zip_params(int level, int window_bits,
                                                 int strategy);
 #endif // #ifndef MINIZ_NO_ZLIB_APIS
 
+#define MZ_UINT16_MAX (0xFFFFU)
+#define MZ_UINT32_MAX (0xFFFFFFFFU)
+
 #ifdef __cplusplus
 }
 #endif
@@ -1311,6 +1370,11 @@ typedef unsigned char mz_validate_uint64[sizeof(mz_uint64) == 8 ? 1 : -1];
    ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
 #endif
 
+#define MZ_READ_LE64(p)                                                        \
+  (((mz_uint64)MZ_READ_LE32(p)) |                                              \
+   (((mz_uint64)MZ_READ_LE32((const mz_uint8 *)(p) + sizeof(mz_uint32)))       \
+    << 32U))
+
 #ifdef _MSC_VER
 #define MZ_FORCEINLINE __forceinline
 #elif defined(__GNUC__)
@@ -2130,7 +2194,8 @@ tinfl_status tinfl_decompress(tinfl_decompressor *r,
             } else
               tree_cur = pTable->m_tree[-tree_cur - 1];
           }
-          tree_cur -= ((rev_code >>= 1) & 1);
+          rev_code >>= 1;
+          tree_cur -= (rev_code & 1);
           pTable->m_tree[-tree_cur - 1] = (mz_int16)sym_index;
         }
         if (r->m_type == 2) {
@@ -3906,6 +3971,7 @@ mz_uint tdefl_create_comp_flags_from_zip_params(int level, int window_bits,
 
 #ifdef _MSC_VER
 #pragma warning(push)
+#pragma warning(disable : 4121 4127 4244)
 #pragma warning(disable : 4204) // nonstandard extension used : non-constant
                                 // aggregate initializer (also supported by GNU
                                 // C and C99, so no big deal)
@@ -4034,10 +4100,6 @@ void *tdefl_write_image_to_png_file_in_memory(const void *pImage, int w, int h,
                                                     pLen_out, 6, MZ_FALSE);
 }
 
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
 // ------------------- .ZIP archive reading
 
 #ifndef MINIZ_NO_ARCHIVE_APIS
@@ -4048,18 +4110,39 @@ void *tdefl_write_image_to_png_file_in_memory(const void *pImage, int w, int h,
 #include <stdio.h>
 #include <sys/stat.h>
 
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) || defined(__MINGW32__)
+
+#include <windows.h>
+
+static wchar_t *str2wstr(const char *str) {
+  int len = (int) strlen(str) + 1;
+  wchar_t *wstr = malloc(len * sizeof(wchar_t));
+  MultiByteToWideChar(CP_UTF8, 0, str, len * sizeof(char), wstr, len);
+  return wstr;
+}
+
 static FILE *mz_fopen(const char *pFilename, const char *pMode) {
-  FILE *pFile = NULL;
-  fopen_s(&pFile, pFilename, pMode);
+  wchar_t *wFilename = str2wstr(pFilename);
+  wchar_t *wMode = str2wstr(pMode);
+  FILE *pFile = _wfopen(wFilename, wMode);
+
+  free(wFilename);
+  free(wMode);
+
   return pFile;
 }
+
 static FILE *mz_freopen(const char *pPath, const char *pMode, FILE *pStream) {
-  FILE *pFile = NULL;
-  if (freopen_s(&pFile, pPath, pMode, pStream))
-    return NULL;
+  wchar_t *wPath = str2wstr(pPath);
+  wchar_t *wMode = str2wstr(pMode);
+  FILE *pFile = _wfreopen(wPath, wMode, pStream);
+
+  free(wPath);
+  free(wMode);
+
   return pFile;
 }
+
 #ifndef MINIZ_NO_TIME
 #include <sys/utime.h>
 #endif
@@ -4080,7 +4163,7 @@ static FILE *mz_freopen(const char *pPath, const char *pMode, FILE *pStream) {
 #include <sys/utime.h>
 #endif
 #define MZ_FILE FILE
-#define MZ_FOPEN(f, m) fopen(f, m)
+#define MZ_FOPEN(f, m) mz_fopen
 #define MZ_FCLOSE fclose
 #define MZ_FREAD fread
 #define MZ_FWRITE fwrite
@@ -4089,7 +4172,7 @@ static FILE *mz_freopen(const char *pPath, const char *pMode, FILE *pStream) {
 #define MZ_FILE_STAT_STRUCT _stat
 #define MZ_FILE_STAT _stat
 #define MZ_FFLUSH fflush
-#define MZ_FREOPEN(f, m, s) freopen(f, m, s)
+#define MZ_FREOPEN(f, m, s) mz_freopen
 #define MZ_DELETE_FILE remove
 #elif defined(__TINYC__)
 #ifndef MINIZ_NO_TIME
@@ -4160,6 +4243,17 @@ enum {
   MZ_ZIP_LOCAL_DIR_HEADER_SIZE = 30,
   MZ_ZIP_CENTRAL_DIR_HEADER_SIZE = 46,
   MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE = 22,
+
+  /* ZIP64 archive identifier and record sizes */
+  MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG = 0x06064b50,
+  MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG = 0x07064b50,
+  MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE = 56,
+  MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE = 20,
+  MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID = 0x0001,
+  MZ_ZIP_DATA_DESCRIPTOR_ID = 0x08074b50,
+  MZ_ZIP_DATA_DESCRIPTER_SIZE64 = 24,
+  MZ_ZIP_DATA_DESCRIPTER_SIZE32 = 16,
+
   // Central directory header record offsets
   MZ_ZIP_CDH_SIG_OFS = 0,
   MZ_ZIP_CDH_VERSION_MADE_BY_OFS = 4,
@@ -4199,6 +4293,31 @@ enum {
   MZ_ZIP_ECDH_CDIR_SIZE_OFS = 12,
   MZ_ZIP_ECDH_CDIR_OFS_OFS = 16,
   MZ_ZIP_ECDH_COMMENT_SIZE_OFS = 20,
+
+  /* ZIP64 End of central directory locator offsets */
+  MZ_ZIP64_ECDL_SIG_OFS = 0,                    /* 4 bytes */
+  MZ_ZIP64_ECDL_NUM_DISK_CDIR_OFS = 4,          /* 4 bytes */
+  MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS = 8,  /* 8 bytes */
+  MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS = 16, /* 4 bytes */
+
+  /* ZIP64 End of central directory header offsets */
+  MZ_ZIP64_ECDH_SIG_OFS = 0,                       /* 4 bytes */
+  MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS = 4,            /* 8 bytes */
+  MZ_ZIP64_ECDH_VERSION_MADE_BY_OFS = 12,          /* 2 bytes */
+  MZ_ZIP64_ECDH_VERSION_NEEDED_OFS = 14,           /* 2 bytes */
+  MZ_ZIP64_ECDH_NUM_THIS_DISK_OFS = 16,            /* 4 bytes */
+  MZ_ZIP64_ECDH_NUM_DISK_CDIR_OFS = 20,            /* 4 bytes */
+  MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS = 24, /* 8 bytes */
+  MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS = 32,       /* 8 bytes */
+  MZ_ZIP64_ECDH_CDIR_SIZE_OFS = 40,                /* 8 bytes */
+  MZ_ZIP64_ECDH_CDIR_OFS_OFS = 48,                 /* 8 bytes */
+  MZ_ZIP_VERSION_MADE_BY_DOS_FILESYSTEM_ID = 0,
+  MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG = 0x10,
+  MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED = 1,
+  MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG = 32,
+  MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION = 64,
+  MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_LOCAL_DIR_IS_MASKED = 8192,
+  MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8 = 1 << 11
 };
 
 typedef struct {
@@ -4211,7 +4330,24 @@ struct mz_zip_internal_state_tag {
   mz_zip_array m_central_dir;
   mz_zip_array m_central_dir_offsets;
   mz_zip_array m_sorted_central_dir_offsets;
+
+  /* The flags passed in when the archive is initially opened. */
+  uint32_t m_init_flags;
+
+  /* MZ_TRUE if the archive has a zip64 end of central directory headers, etc.
+   */
+  mz_bool m_zip64;
+
+  /* MZ_TRUE if we found zip64 extended info in the central directory (m_zip64
+   * will also be slammed to true too, even if we didn't find a zip64 end of
+   * central dir header, etc.) */
+  mz_bool m_zip64_has_extended_info_fields;
+
+  /* These fields are used by the file, FILE, memory, and memory/heap read/write
+   * helpers. */
   MZ_FILE *m_pFile;
+  mz_uint64 m_file_archive_start_ofs;
+
   void *m_pMem;
   size_t m_mem_size;
   size_t m_mem_capacity;
@@ -4363,6 +4499,13 @@ static mz_bool mz_zip_set_file_times(const char *pFilename, time_t access_time,
 #endif /* #ifndef MINIZ_NO_STDIO */
 #endif /* #ifndef MINIZ_NO_TIME */
 
+static MZ_FORCEINLINE mz_bool mz_zip_set_error(mz_zip_archive *pZip,
+                                               mz_zip_error err_num) {
+  if (pZip)
+    pZip->m_last_error = err_num;
+  return MZ_FALSE;
+}
+
 static mz_bool mz_zip_reader_init_internal(mz_zip_archive *pZip,
                                            mz_uint32 flags) {
   (void)flags;
@@ -4480,127 +4623,346 @@ mz_zip_reader_sort_central_dir_offsets_by_filename(mz_zip_archive *pZip) {
   }
 }
 
-static mz_bool mz_zip_reader_read_central_dir(mz_zip_archive *pZip,
-                                              mz_uint32 flags) {
-  mz_uint cdir_size, num_this_disk, cdir_disk_index;
-  mz_uint64 cdir_ofs;
+static mz_bool mz_zip_reader_locate_header_sig(mz_zip_archive *pZip,
+                                               mz_uint32 record_sig,
+                                               mz_uint32 record_size,
+                                               mz_int64 *pOfs) {
   mz_int64 cur_file_ofs;
-  const mz_uint8 *p;
   mz_uint32 buf_u32[4096 / sizeof(mz_uint32)];
   mz_uint8 *pBuf = (mz_uint8 *)buf_u32;
-  mz_bool sort_central_dir =
-      ((flags & MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY) == 0);
-  // Basic sanity checks - reject files which are too small, and check the first
-  // 4 bytes of the file to make sure a local header is there.
-  if (pZip->m_archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
+
+  /* Basic sanity checks - reject files which are too small */
+  if (pZip->m_archive_size < record_size)
     return MZ_FALSE;
-  // Find the end of central directory record by scanning the file from the end
-  // towards the beginning.
+
+  /* Find the record by scanning the file from the end towards the beginning. */
   cur_file_ofs =
       MZ_MAX((mz_int64)pZip->m_archive_size - (mz_int64)sizeof(buf_u32), 0);
   for (;;) {
     int i,
         n = (int)MZ_MIN(sizeof(buf_u32), pZip->m_archive_size - cur_file_ofs);
+
     if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, n) != (mz_uint)n)
       return MZ_FALSE;
-    for (i = n - 4; i >= 0; --i)
-      if (MZ_READ_LE32(pBuf + i) == MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG)
-        break;
+
+    for (i = n - 4; i >= 0; --i) {
+      mz_uint s = MZ_READ_LE32(pBuf + i);
+      if (s == record_sig) {
+        if ((pZip->m_archive_size - (cur_file_ofs + i)) >= record_size)
+          break;
+      }
+    }
+
     if (i >= 0) {
       cur_file_ofs += i;
       break;
     }
+
+    /* Give up if we've searched the entire file, or we've gone back "too far"
+     * (~64kb) */
     if ((!cur_file_ofs) || ((pZip->m_archive_size - cur_file_ofs) >=
-                            (0xFFFF + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)))
+                            (MZ_UINT16_MAX + record_size)))
       return MZ_FALSE;
+
     cur_file_ofs = MZ_MAX(cur_file_ofs - (sizeof(buf_u32) - 3), 0);
   }
-  // Read and verify the end of central directory record.
+
+  *pOfs = cur_file_ofs;
+  return MZ_TRUE;
+}
+
+static mz_bool mz_zip_reader_read_central_dir(mz_zip_archive *pZip,
+                                              mz_uint flags) {
+  mz_uint cdir_size = 0, cdir_entries_on_this_disk = 0, num_this_disk = 0,
+          cdir_disk_index = 0;
+  mz_uint64 cdir_ofs = 0;
+  mz_int64 cur_file_ofs = 0;
+  const mz_uint8 *p;
+
+  mz_uint32 buf_u32[4096 / sizeof(mz_uint32)];
+  mz_uint8 *pBuf = (mz_uint8 *)buf_u32;
+  mz_bool sort_central_dir =
+      ((flags & MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY) == 0);
+  mz_uint32 zip64_end_of_central_dir_locator_u32
+      [(MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE + sizeof(mz_uint32) - 1) /
+       sizeof(mz_uint32)];
+  mz_uint8 *pZip64_locator = (mz_uint8 *)zip64_end_of_central_dir_locator_u32;
+
+  mz_uint32 zip64_end_of_central_dir_header_u32
+      [(MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) /
+       sizeof(mz_uint32)];
+  mz_uint8 *pZip64_end_of_central_dir =
+      (mz_uint8 *)zip64_end_of_central_dir_header_u32;
+
+  mz_uint64 zip64_end_of_central_dir_ofs = 0;
+
+  /* Basic sanity checks - reject files which are too small, and check the first
+   * 4 bytes of the file to make sure a local header is there. */
+  if (pZip->m_archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
+    return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
+
+  if (!mz_zip_reader_locate_header_sig(
+          pZip, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG,
+          MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE, &cur_file_ofs))
+    return mz_zip_set_error(pZip, MZ_ZIP_FAILED_FINDING_CENTRAL_DIR);
+
+  /* Read and verify the end of central directory record. */
   if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf,
                     MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) !=
       MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
-    return MZ_FALSE;
-  if ((MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_SIG_OFS) !=
-       MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG) ||
-      ((pZip->m_total_files =
-            MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS)) !=
-       MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS)))
-    return MZ_FALSE;
+    return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
 
+  if (MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_SIG_OFS) !=
+      MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG)
+    return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
+
+  if (cur_file_ofs >= (MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE +
+                       MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE)) {
+    if (pZip->m_pRead(pZip->m_pIO_opaque,
+                      cur_file_ofs - MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE,
+                      pZip64_locator,
+                      MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) ==
+        MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) {
+      if (MZ_READ_LE32(pZip64_locator + MZ_ZIP64_ECDL_SIG_OFS) ==
+          MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG) {
+        zip64_end_of_central_dir_ofs = MZ_READ_LE64(
+            pZip64_locator + MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS);
+        if (zip64_end_of_central_dir_ofs >
+            (pZip->m_archive_size - MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE))
+          return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
+
+        if (pZip->m_pRead(pZip->m_pIO_opaque, zip64_end_of_central_dir_ofs,
+                          pZip64_end_of_central_dir,
+                          MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) ==
+            MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) {
+          if (MZ_READ_LE32(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_SIG_OFS) ==
+              MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG) {
+            pZip->m_pState->m_zip64 = MZ_TRUE;
+          }
+        }
+      }
+    }
+  }
+
+  pZip->m_total_files = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS);
+  cdir_entries_on_this_disk =
+      MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS);
   num_this_disk = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_NUM_THIS_DISK_OFS);
   cdir_disk_index = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_NUM_DISK_CDIR_OFS);
+  cdir_size = MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_SIZE_OFS);
+  cdir_ofs = MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_OFS_OFS);
+
+  if (pZip->m_pState->m_zip64) {
+    mz_uint32 zip64_total_num_of_disks =
+        MZ_READ_LE32(pZip64_locator + MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS);
+    mz_uint64 zip64_cdir_total_entries = MZ_READ_LE64(
+        pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS);
+    mz_uint64 zip64_cdir_total_entries_on_this_disk = MZ_READ_LE64(
+        pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS);
+    mz_uint64 zip64_size_of_end_of_central_dir_record = MZ_READ_LE64(
+        pZip64_end_of_central_dir + MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS);
+    mz_uint64 zip64_size_of_central_directory =
+        MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_SIZE_OFS);
+
+    if (zip64_size_of_end_of_central_dir_record <
+        (MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE - 12))
+      return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
+
+    if (zip64_total_num_of_disks != 1U)
+      return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK);
+
+    /* Check for miniz's practical limits */
+    if (zip64_cdir_total_entries > MZ_UINT32_MAX)
+      return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
+
+    pZip->m_total_files = (mz_uint32)zip64_cdir_total_entries;
+
+    if (zip64_cdir_total_entries_on_this_disk > MZ_UINT32_MAX)
+      return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
+
+    cdir_entries_on_this_disk =
+        (mz_uint32)zip64_cdir_total_entries_on_this_disk;
+
+    /* Check for miniz's current practical limits (sorry, this should be enough
+     * for millions of files) */
+    if (zip64_size_of_central_directory > MZ_UINT32_MAX)
+      return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE);
+
+    cdir_size = (mz_uint32)zip64_size_of_central_directory;
+
+    num_this_disk = MZ_READ_LE32(pZip64_end_of_central_dir +
+                                 MZ_ZIP64_ECDH_NUM_THIS_DISK_OFS);
+
+    cdir_disk_index = MZ_READ_LE32(pZip64_end_of_central_dir +
+                                   MZ_ZIP64_ECDH_NUM_DISK_CDIR_OFS);
+
+    cdir_ofs =
+        MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_OFS_OFS);
+  }
+
+  if (pZip->m_total_files != cdir_entries_on_this_disk)
+    return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK);
+
   if (((num_this_disk | cdir_disk_index) != 0) &&
       ((num_this_disk != 1) || (cdir_disk_index != 1)))
-    return MZ_FALSE;
+    return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK);
 
-  if ((cdir_size = MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_SIZE_OFS)) <
-      pZip->m_total_files * MZ_ZIP_CENTRAL_DIR_HEADER_SIZE)
-    return MZ_FALSE;
+  if (cdir_size < pZip->m_total_files * MZ_ZIP_CENTRAL_DIR_HEADER_SIZE)
+    return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 
-  cdir_ofs = MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_OFS_OFS);
   if ((cdir_ofs + (mz_uint64)cdir_size) > pZip->m_archive_size)
-    return MZ_FALSE;
+    return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 
   pZip->m_central_directory_file_ofs = cdir_ofs;
 
   if (pZip->m_total_files) {
     mz_uint i, n;
-
-    // Read the entire central directory into a heap block, and allocate another
-    // heap block to hold the unsorted central dir file record offsets, and
-    // another to hold the sorted indices.
+    /* Read the entire central directory into a heap block, and allocate another
+     * heap block to hold the unsorted central dir file record offsets, and
+     * possibly another to hold the sorted indices. */
     if ((!mz_zip_array_resize(pZip, &pZip->m_pState->m_central_dir, cdir_size,
                               MZ_FALSE)) ||
         (!mz_zip_array_resize(pZip, &pZip->m_pState->m_central_dir_offsets,
                               pZip->m_total_files, MZ_FALSE)))
-      return MZ_FALSE;
+      return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
 
     if (sort_central_dir) {
       if (!mz_zip_array_resize(pZip,
                                &pZip->m_pState->m_sorted_central_dir_offsets,
                                pZip->m_total_files, MZ_FALSE))
-        return MZ_FALSE;
+        return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
     }
 
     if (pZip->m_pRead(pZip->m_pIO_opaque, cdir_ofs,
                       pZip->m_pState->m_central_dir.m_p,
                       cdir_size) != cdir_size)
-      return MZ_FALSE;
+      return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
 
-    // Now create an index into the central directory file records, do some
-    // basic sanity checking on each record, and check for zip64 entries (which
-    // are not yet supported).
+    /* Now create an index into the central directory file records, do some
+     * basic sanity checking on each record */
     p = (const mz_uint8 *)pZip->m_pState->m_central_dir.m_p;
     for (n = cdir_size, i = 0; i < pZip->m_total_files; ++i) {
-      mz_uint total_header_size, comp_size, decomp_size, disk_index;
+      mz_uint total_header_size, disk_index, bit_flags, filename_size,
+          ext_data_size;
+      mz_uint64 comp_size, decomp_size, local_header_ofs;
+
       if ((n < MZ_ZIP_CENTRAL_DIR_HEADER_SIZE) ||
           (MZ_READ_LE32(p) != MZ_ZIP_CENTRAL_DIR_HEADER_SIG))
-        return MZ_FALSE;
+        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
+
       MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32,
                            i) =
           (mz_uint32)(p - (const mz_uint8 *)pZip->m_pState->m_central_dir.m_p);
+
       if (sort_central_dir)
         MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_sorted_central_dir_offsets,
                              mz_uint32, i) = i;
+
       comp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS);
       decomp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS);
-      if (((!MZ_READ_LE32(p + MZ_ZIP_CDH_METHOD_OFS)) &&
-           (decomp_size != comp_size)) ||
-          (decomp_size && !comp_size) || (decomp_size == 0xFFFFFFFF) ||
-          (comp_size == 0xFFFFFFFF))
-        return MZ_FALSE;
+      local_header_ofs = MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS);
+      filename_size = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);
+      ext_data_size = MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS);
+
+      if ((!pZip->m_pState->m_zip64_has_extended_info_fields) &&
+          (ext_data_size) &&
+          (MZ_MAX(MZ_MAX(comp_size, decomp_size), local_header_ofs) ==
+           MZ_UINT32_MAX)) {
+        /* Attempt to find zip64 extended information field in the entry's extra
+         * data */
+        mz_uint32 extra_size_remaining = ext_data_size;
+
+        if (extra_size_remaining) {
+          const mz_uint8 *pExtra_data;
+          void *buf = NULL;
+
+          if (MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size + ext_data_size >
+              n) {
+            buf = MZ_MALLOC(ext_data_size);
+            if (buf == NULL)
+              return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
+
+            if (pZip->m_pRead(pZip->m_pIO_opaque,
+                              cdir_ofs + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE +
+                                  filename_size,
+                              buf, ext_data_size) != ext_data_size) {
+              MZ_FREE(buf);
+              return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
+            }
+
+            pExtra_data = (mz_uint8 *)buf;
+          } else {
+            pExtra_data = p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size;
+          }
+
+          do {
+            mz_uint32 field_id;
+            mz_uint32 field_data_size;
+
+            if (extra_size_remaining < (sizeof(mz_uint16) * 2)) {
+              MZ_FREE(buf);
+              return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
+            }
+
+            field_id = MZ_READ_LE16(pExtra_data);
+            field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16));
+
+            if ((field_data_size + sizeof(mz_uint16) * 2) >
+                extra_size_remaining) {
+              MZ_FREE(buf);
+              return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
+            }
+
+            if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID) {
+              /* Ok, the archive didn't have any zip64 headers but it uses a
+               * zip64 extended information field so mark it as zip64 anyway
+               * (this can occur with infozip's zip util when it reads
+               * compresses files from stdin). */
+              pZip->m_pState->m_zip64 = MZ_TRUE;
+              pZip->m_pState->m_zip64_has_extended_info_fields = MZ_TRUE;
+              break;
+            }
+
+            pExtra_data += sizeof(mz_uint16) * 2 + field_data_size;
+            extra_size_remaining =
+                extra_size_remaining - sizeof(mz_uint16) * 2 - field_data_size;
+          } while (extra_size_remaining);
+
+          MZ_FREE(buf);
+        }
+      }
+
+      /* I've seen archives that aren't marked as zip64 that uses zip64 ext
+       * data, argh */
+      if ((comp_size != MZ_UINT32_MAX) && (decomp_size != MZ_UINT32_MAX)) {
+        if (((!MZ_READ_LE32(p + MZ_ZIP_CDH_METHOD_OFS)) &&
+             (decomp_size != comp_size)) ||
+            (decomp_size && !comp_size))
+          return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
+      }
+
       disk_index = MZ_READ_LE16(p + MZ_ZIP_CDH_DISK_START_OFS);
-      if ((disk_index != num_this_disk) && (disk_index != 1))
-        return MZ_FALSE;
-      if (((mz_uint64)MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS) +
-           MZ_ZIP_LOCAL_DIR_HEADER_SIZE + comp_size) > pZip->m_archive_size)
-        return MZ_FALSE;
+      if ((disk_index == MZ_UINT16_MAX) ||
+          ((disk_index != num_this_disk) && (disk_index != 1)))
+        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK);
+
+      if (comp_size != MZ_UINT32_MAX) {
+        if (((mz_uint64)MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS) +
+             MZ_ZIP_LOCAL_DIR_HEADER_SIZE + comp_size) > pZip->m_archive_size)
+          return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
+      }
+
+      bit_flags = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS);
+      if (bit_flags & MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_LOCAL_DIR_IS_MASKED)
+        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);
+
       if ((total_header_size = MZ_ZIP_CENTRAL_DIR_HEADER_SIZE +
                                MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS) +
                                MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS) +
                                MZ_READ_LE16(p + MZ_ZIP_CDH_COMMENT_LEN_OFS)) >
           n)
-        return MZ_FALSE;
+        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
+
       n -= total_header_size;
       p += total_header_size;
     }
@@ -5018,13 +5380,9 @@ mz_bool mz_zip_reader_extract_to_mem_no_alloc(mz_zip_archive *pZip,
   } else {
     // Temporarily allocate a read buffer.
     read_buf_size = MZ_MIN(file_stat.m_comp_size, MZ_ZIP_MAX_IO_BUF_SIZE);
-#ifdef _MSC_VER
-    if (((0, sizeof(size_t) == sizeof(mz_uint32))) &&
-        (read_buf_size > 0x7FFFFFFF))
-#else
     if (((sizeof(size_t) == sizeof(mz_uint32))) && (read_buf_size > 0x7FFFFFFF))
-#endif
       return MZ_FALSE;
+
     if (NULL == (pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1,
                                             (size_t)read_buf_size)))
       return MZ_FALSE;
@@ -5111,11 +5469,7 @@ void *mz_zip_reader_extract_to_heap(mz_zip_archive *pZip, mz_uint file_index,
   uncomp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS);
 
   alloc_size = (flags & MZ_ZIP_FLAG_COMPRESSED_DATA) ? comp_size : uncomp_size;
-#ifdef _MSC_VER
-  if (((0, sizeof(size_t) == sizeof(mz_uint32))) && (alloc_size > 0x7FFFFFFF))
-#else
   if (((sizeof(size_t) == sizeof(mz_uint32))) && (alloc_size > 0x7FFFFFFF))
-#endif
     return NULL;
   if (NULL ==
       (pBuf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)alloc_size)))
@@ -5217,14 +5571,10 @@ mz_bool mz_zip_reader_extract_to_callback(mz_zip_archive *pZip,
   if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!file_stat.m_method)) {
     // The file is stored or the caller has requested the compressed data.
     if (pZip->m_pState->m_pMem) {
-#ifdef _MSC_VER
-      if (((0, sizeof(size_t) == sizeof(mz_uint32))) &&
-          (file_stat.m_comp_size > 0xFFFFFFFF))
-#else
       if (((sizeof(size_t) == sizeof(mz_uint32))) &&
           (file_stat.m_comp_size > 0xFFFFFFFF))
-#endif
         return MZ_FALSE;
+
       if (pCallback(pOpaque, out_buf_ofs, pRead_buf,
                     (size_t)file_stat.m_comp_size) != file_stat.m_comp_size)
         status = TINFL_STATUS_FAILED;
@@ -5946,7 +6296,10 @@ mz_bool mz_zip_writer_add_file(mz_zip_archive *pZip, const char *pArchive_name,
                                mz_uint32 ext_attributes) {
   mz_uint uncomp_crc32 = MZ_CRC32_INIT, level, num_alignment_padding_bytes;
   mz_uint16 method = 0, dos_time = 0, dos_date = 0;
+#ifndef MINIZ_NO_TIME
   time_t file_modified_time;
+#endif
+
   mz_uint64 local_dir_header_ofs, cur_archive_file_ofs, uncomp_size = 0,
                                                         comp_size = 0;
   size_t archive_name_size;
@@ -5983,10 +6336,12 @@ mz_bool mz_zip_writer_add_file(mz_zip_archive *pZip, const char *pArchive_name,
         comment_size + archive_name_size) > 0xFFFFFFFF))
     return MZ_FALSE;
 
+#ifndef MINIZ_NO_TIME
   memset(&file_modified_time, 0, sizeof(file_modified_time));
   if (!mz_zip_get_file_modified_time(pSrc_filename, &file_modified_time))
     return MZ_FALSE;
   mz_zip_time_t_to_dos_time(file_modified_time, &dos_time, &dos_date);
+#endif
 
   pSrc_file = MZ_FOPEN(pSrc_filename, "rb");
   if (!pSrc_file)
@@ -6471,6 +6826,10 @@ void *mz_zip_extract_archive_file_to_heap(const char *pZip_filename,
   return p;
 }
 
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
 #endif // #ifndef MINIZ_NO_STDIO
 
 #endif // #ifndef MINIZ_NO_ARCHIVE_WRITING_APIS
diff --git a/Engine/lib/assimp/contrib/zip/src/zip.c b/Engine/lib/assimp/contrib/zip/src/zip.c
index ff3a8fe1e..29af2ec99 100644
--- a/Engine/lib/assimp/contrib/zip/src/zip.c
+++ b/Engine/lib/assimp/contrib/zip/src/zip.c
@@ -24,21 +24,32 @@
   ((((P)[0] >= 'A' && (P)[0] <= 'Z') || ((P)[0] >= 'a' && (P)[0] <= 'z')) &&   \
    (P)[1] == ':')
 #define FILESYSTEM_PREFIX_LEN(P) (HAS_DEVICE(P) ? 2 : 0)
-#define ISSLASH(C) ((C) == '/' || (C) == '\\')
 
 #else
 
-#include <unistd.h> // needed for symlink() on BSD
-int symlink(const char *target, const char *linkpath); // needed on Linux
+#include <unistd.h> // needed for symlink()
 
 #define MKDIR(DIRNAME) mkdir(DIRNAME, 0755)
 #define STRCLONE(STR) ((STR) ? strdup(STR) : NULL)
 
 #endif
 
+#ifdef __MINGW32__
+#include <sys/types.h>
+#include <unistd.h>
+#endif
+
 #include "miniz.h"
 #include "zip.h"
 
+#ifdef _MSC_VER
+#include <io.h>
+#pragma warning(disable : 4706 4244 4028)
+
+#define ftruncate(fd, sz) (-(_chsize_s((fd), (sz)) != 0))
+#define fileno _fileno
+#endif
+
 #ifndef HAS_DEVICE
 #define HAS_DEVICE(P) 0
 #endif
@@ -48,7 +59,7 @@ int symlink(const char *target, const char *linkpath); // needed on Linux
 #endif
 
 #ifndef ISSLASH
-#define ISSLASH(C) ((C) == '/')
+#define ISSLASH(C) ((C) == '/' || (C) == '\\')
 #endif
 
 #define CLEANUP(ptr)                                                           \
@@ -59,71 +70,6 @@ int symlink(const char *target, const char *linkpath); // needed on Linux
     }                                                                          \
   } while (0)
 
-static const char *base_name(const char *name) {
-  char const *p;
-  char const *base = name += FILESYSTEM_PREFIX_LEN(name);
-  int all_slashes = 1;
-
-  for (p = name; *p; p++) {
-    if (ISSLASH(*p))
-      base = p + 1;
-    else
-      all_slashes = 0;
-  }
-
-  /* If NAME is all slashes, arrange to return `/'. */
-  if (*base == '\0' && ISSLASH(*name) && all_slashes)
-    --base;
-
-  return base;
-}
-
-static int mkpath(const char *path) {
-  char const *p;
-  char npath[MAX_PATH + 1];
-  int len = 0;
-  int has_device = HAS_DEVICE(path);
-
-  memset(npath, 0, MAX_PATH + 1);
-
-#ifdef _WIN32
-  // only on windows fix the path
-  npath[0] = path[0];
-  npath[1] = path[1];
-  len = 2;
-#endif // _WIN32
-    
-  for (p = path + len; *p && len < MAX_PATH; p++) {
-    if (ISSLASH(*p) && ((!has_device && len > 0) || (has_device && len > 2))) {
-      if (MKDIR(npath) == -1)
-        if (errno != EEXIST)
-          return -1;
-    }
-    npath[len++] = *p;
-  }
-
-  return 0;
-}
-
-static char *strrpl(const char *str, size_t n, char oldchar, char newchar) {
-  char c;
-  size_t i;
-  char *rpl = (char *)calloc((1 + n), sizeof(char));
-  char *begin = rpl;
-  if (!rpl) {
-    return NULL;
-  }
-
-  for (i = 0; (i < n) && (c = *str++); ++i) {
-    if (c == oldchar) {
-      c = newchar;
-    }
-    *rpl++ = c;
-  }
-
-  return begin;
-}
-
 struct zip_entry_t {
   int index;
   char *name;
@@ -146,6 +92,691 @@ struct zip_t {
   struct zip_entry_t entry;
 };
 
+enum zip_modify_t {
+  MZ_KEEP = 0,
+  MZ_DELETE = 1,
+  MZ_MOVE = 2,
+};
+
+struct zip_entry_mark_t {
+  int file_index;
+  enum zip_modify_t type;
+  mz_uint64 m_local_header_ofs;
+  mz_uint64 lf_length;
+};
+
+static const char *const zip_errlist[30] = {
+    NULL,
+    "not initialized\0",
+    "invalid entry name\0",
+    "entry not found\0",
+    "invalid zip mode\0",
+    "invalid compression level\0",
+    "no zip 64 support\0",
+    "memset error\0",
+    "cannot write data to entry\0",
+    "cannot initialize tdefl compressor\0",
+    "invalid index\0",
+    "header not found\0",
+    "cannot flush tdefl buffer\0",
+    "cannot write entry header\0",
+    "cannot create entry header\0",
+    "cannot write to central dir\0",
+    "cannot open file\0",
+    "invalid entry type\0",
+    "extracting data using no memory allocation\0",
+    "file not found\0",
+    "no permission\0",
+    "out of memory\0",
+    "invalid zip archive name\0",
+    "make dir error\0"
+    "symlink error\0"
+    "close archive error\0"
+    "capacity size too small\0",
+    "fseek error\0",
+    "fread error\0",
+    "fwrite error\0",
+};
+
+const char *zip_strerror(int errnum) {
+  errnum = -errnum;
+  if (errnum <= 0 || errnum >= 30) {
+    return NULL;
+  }
+
+  return zip_errlist[errnum];
+}
+
+static const char *zip_basename(const char *name) {
+  char const *p;
+  char const *base = name += FILESYSTEM_PREFIX_LEN(name);
+  int all_slashes = 1;
+
+  for (p = name; *p; p++) {
+    if (ISSLASH(*p))
+      base = p + 1;
+    else
+      all_slashes = 0;
+  }
+
+  /* If NAME is all slashes, arrange to return `/'. */
+  if (*base == '\0' && ISSLASH(*name) && all_slashes)
+    --base;
+
+  return base;
+}
+
+static int zip_mkpath(char *path) {
+  char *p;
+  char npath[MAX_PATH + 1];
+  int len = 0;
+  int has_device = HAS_DEVICE(path);
+
+  memset(npath, 0, MAX_PATH + 1);
+  if (has_device) {
+    // only on windows
+    npath[0] = path[0];
+    npath[1] = path[1];
+    len = 2;
+  }
+  for (p = path + len; *p && len < MAX_PATH; p++) {
+    if (ISSLASH(*p) && ((!has_device && len > 0) || (has_device && len > 2))) {
+#if defined(_WIN32) || defined(__WIN32__) || defined(_MSC_VER) ||              \
+    defined(__MINGW32__)
+#else
+      if ('\\' == *p) {
+        *p = '/';
+      }
+#endif
+
+      if (MKDIR(npath) == -1) {
+        if (errno != EEXIST) {
+          return ZIP_EMKDIR;
+        }
+      }
+    }
+    npath[len++] = *p;
+  }
+
+  return 0;
+}
+
+static char *zip_strrpl(const char *str, size_t n, char oldchar, char newchar) {
+  char c;
+  size_t i;
+  char *rpl = (char *)calloc((1 + n), sizeof(char));
+  char *begin = rpl;
+  if (!rpl) {
+    return NULL;
+  }
+
+  for (i = 0; (i < n) && (c = *str++); ++i) {
+    if (c == oldchar) {
+      c = newchar;
+    }
+    *rpl++ = c;
+  }
+
+  return begin;
+}
+
+static char *zip_name_normalize(char *name, char *const nname, size_t len) {
+  size_t offn = 0;
+  size_t offnn = 0, ncpy = 0;
+
+  if (name == NULL || nname == NULL || len <= 0) {
+    return NULL;
+  }
+  // skip trailing '/'
+  while (ISSLASH(*name))
+    name++;
+
+  for (; offn < len; offn++) {
+    if (ISSLASH(name[offn])) {
+      if (ncpy > 0 && strcmp(&nname[offnn], ".\0") &&
+          strcmp(&nname[offnn], "..\0")) {
+        offnn += ncpy;
+        nname[offnn++] = name[offn]; // append '/'
+      }
+      ncpy = 0;
+    } else {
+      nname[offnn + ncpy] = name[offn];
+      ncpy++;
+    }
+  }
+
+  // at the end, extra check what we've already copied
+  if (ncpy == 0 || !strcmp(&nname[offnn], ".\0") ||
+      !strcmp(&nname[offnn], "..\0")) {
+    nname[offnn] = 0;
+  }
+  return nname;
+}
+
+static mz_bool zip_name_match(const char *name1, const char *name2) {
+  int len2 = (int) strlen(name2);
+  char *nname2 = zip_strrpl(name2, len2, '\\', '/');
+  if (!nname2) {
+    return MZ_FALSE;
+  }
+
+  mz_bool res = (strcmp(name1, nname2) == 0) ? MZ_TRUE : MZ_FALSE;
+  CLEANUP(nname2);
+  return res;
+}
+
+static int zip_archive_truncate(mz_zip_archive *pzip) {
+  mz_zip_internal_state *pState = pzip->m_pState;
+  mz_uint64 file_size = pzip->m_archive_size;
+  if ((pzip->m_pWrite == mz_zip_heap_write_func) && (pState->m_pMem)) {
+    return 0;
+  }
+  if (pzip->m_zip_mode == MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED) {
+    if (pState->m_pFile) {
+      int fd = fileno(pState->m_pFile);
+      return ftruncate(fd, file_size);
+    }
+  }
+  return 0;
+}
+
+static int zip_archive_extract(mz_zip_archive *zip_archive, const char *dir,
+                               int (*on_extract)(const char *filename,
+                                                 void *arg),
+                               void *arg) {
+  int err = 0;
+  mz_uint i, n;
+  char path[MAX_PATH + 1];
+  char symlink_to[MAX_PATH + 1];
+  mz_zip_archive_file_stat info;
+  size_t dirlen = 0;
+  mz_uint32 xattr = 0;
+
+  memset(path, 0, sizeof(path));
+  memset(symlink_to, 0, sizeof(symlink_to));
+
+  dirlen = strlen(dir);
+  if (dirlen + 1 > MAX_PATH) {
+    return ZIP_EINVENTNAME;
+  }
+
+  memset((void *)&info, 0, sizeof(mz_zip_archive_file_stat));
+
+#if defined(_MSC_VER)
+  strcpy_s(path, MAX_PATH, dir);
+#else
+  strcpy(path, dir);
+#endif
+
+  if (!ISSLASH(path[dirlen - 1])) {
+#if defined(_WIN32) || defined(__WIN32__)
+    path[dirlen] = '\\';
+#else
+    path[dirlen] = '/';
+#endif
+    ++dirlen;
+  }
+
+  // Get and print information about each file in the archive.
+  n = mz_zip_reader_get_num_files(zip_archive);
+  for (i = 0; i < n; ++i) {
+    if (!mz_zip_reader_file_stat(zip_archive, i, &info)) {
+      // Cannot get information about zip archive;
+      err = ZIP_ENOENT;
+      goto out;
+    }
+
+    if (!zip_name_normalize(info.m_filename, info.m_filename,
+                            strlen(info.m_filename))) {
+      // Cannot normalize file name;
+      err = ZIP_EINVENTNAME;
+      goto out;
+    }
+#if defined(_MSC_VER)
+    strncpy_s(&path[dirlen], MAX_PATH - dirlen, info.m_filename,
+              MAX_PATH - dirlen);
+#else
+    strncpy(&path[dirlen], info.m_filename, MAX_PATH - dirlen);
+#endif
+    err = zip_mkpath(path);
+    if (err < 0) {
+      // Cannot make a path
+      goto out;
+    }
+
+    if ((((info.m_version_made_by >> 8) == 3) ||
+         ((info.m_version_made_by >> 8) ==
+          19)) // if zip is produced on Unix or macOS (3 and 19 from
+               // section 4.4.2.2 of zip standard)
+        && info.m_external_attr &
+               (0x20 << 24)) { // and has sym link attribute (0x80 is file, 0x40
+                               // is directory)
+#if defined(_WIN32) || defined(__WIN32__) || defined(_MSC_VER) ||              \
+    defined(__MINGW32__)
+#else
+      if (info.m_uncomp_size > MAX_PATH ||
+          !mz_zip_reader_extract_to_mem_no_alloc(zip_archive, i, symlink_to,
+                                                 MAX_PATH, 0, NULL, 0)) {
+        err = ZIP_EMEMNOALLOC;
+        goto out;
+      }
+      symlink_to[info.m_uncomp_size] = '\0';
+      if (symlink(symlink_to, path) != 0) {
+        err = ZIP_ESYMLINK;
+        goto out;
+      }
+#endif
+    } else {
+      if (!mz_zip_reader_is_file_a_directory(zip_archive, i)) {
+        if (!mz_zip_reader_extract_to_file(zip_archive, i, path, 0)) {
+          // Cannot extract zip archive to file
+          err = ZIP_ENOFILE;
+          goto out;
+        }
+      }
+
+#if defined(_MSC_VER)
+      (void)xattr; // unused
+#else
+      xattr = (info.m_external_attr >> 16) & 0xFFFF;
+      if (xattr > 0) {
+        if (chmod(path, (mode_t)xattr) < 0) {
+          err = ZIP_ENOPERM;
+          goto out;
+        }
+      }
+#endif
+    }
+
+    if (on_extract) {
+      if (on_extract(path, arg) < 0) {
+        goto out;
+      }
+    }
+  }
+
+out:
+  // Close the archive, freeing any resources it was using
+  if (!mz_zip_reader_end(zip_archive)) {
+    // Cannot end zip reader
+    err = ZIP_ECLSZIP;
+  }
+  return err;
+}
+
+static inline void zip_archive_finalize(mz_zip_archive *pzip) {
+  mz_zip_writer_finalize_archive(pzip);
+  zip_archive_truncate(pzip);
+}
+
+static int zip_entry_mark(struct zip_t *zip,
+                          struct zip_entry_mark_t *entry_mark, int n,
+                          char *const entries[], const size_t len) {
+  int err = 0;
+  if (!zip || !entry_mark || !entries) {
+    return ZIP_ENOINIT;
+  }
+
+  mz_zip_archive_file_stat file_stat;
+  mz_uint64 d_pos = (mz_uint64) ~0;
+  for (int i = 0; i < n; ++i) {
+    err = zip_entry_openbyindex(zip, i);
+    if (err) {
+      return err;
+    }
+
+    mz_bool name_matches = MZ_FALSE;
+    for (int j = 0; j < (const int)len; ++j) {
+      if (zip_name_match(zip->entry.name, entries[j])) {
+        name_matches = MZ_TRUE;
+        break;
+      }
+    }
+    if (name_matches) {
+      entry_mark[i].type = MZ_DELETE;
+    } else {
+      entry_mark[i].type = MZ_KEEP;
+    }
+
+    if (!mz_zip_reader_file_stat(&zip->archive, i, &file_stat)) {
+      return ZIP_ENOENT;
+    }
+
+    zip_entry_close(zip);
+
+    entry_mark[i].m_local_header_ofs = file_stat.m_local_header_ofs;
+    entry_mark[i].file_index = -1;
+    entry_mark[i].lf_length = 0;
+    if ((entry_mark[i].type) == MZ_DELETE &&
+        (d_pos > entry_mark[i].m_local_header_ofs)) {
+      d_pos = entry_mark[i].m_local_header_ofs;
+    }
+  }
+  for (int i = 0; i < n; ++i) {
+    if ((entry_mark[i].m_local_header_ofs > d_pos) &&
+        (entry_mark[i].type != MZ_DELETE)) {
+      entry_mark[i].type = MZ_MOVE;
+    }
+  }
+  return err;
+}
+
+static int zip_index_next(mz_uint64 *local_header_ofs_array, int cur_index) {
+  int new_index = 0;
+  for (int i = cur_index - 1; i >= 0; --i) {
+    if (local_header_ofs_array[cur_index] > local_header_ofs_array[i]) {
+      new_index = i + 1;
+      return new_index;
+    }
+  }
+  return new_index;
+}
+
+static int zip_sort(mz_uint64 *local_header_ofs_array, int cur_index) {
+  int nxt_index = zip_index_next(local_header_ofs_array, cur_index);
+
+  if (nxt_index != cur_index) {
+    mz_uint64 temp = local_header_ofs_array[cur_index];
+    for (int i = cur_index; i > nxt_index; i--) {
+      local_header_ofs_array[i] = local_header_ofs_array[i - 1];
+    }
+    local_header_ofs_array[nxt_index] = temp;
+  }
+  return nxt_index;
+}
+
+static int zip_index_update(struct zip_entry_mark_t *entry_mark, int last_index,
+                            int nxt_index) {
+  for (int j = 0; j < last_index; j++) {
+    if (entry_mark[j].file_index >= nxt_index) {
+      entry_mark[j].file_index += 1;
+    }
+  }
+  entry_mark[nxt_index].file_index = last_index;
+  return 0;
+}
+
+static int zip_entry_finalize(struct zip_t *zip,
+                              struct zip_entry_mark_t *entry_mark,
+                              const int n) {
+
+  mz_uint64 *local_header_ofs_array = (mz_uint64 *)calloc(n, sizeof(mz_uint64));
+  if (!local_header_ofs_array) {
+    return ZIP_EOOMEM;
+  }
+
+  for (int i = 0; i < n; ++i) {
+    local_header_ofs_array[i] = entry_mark[i].m_local_header_ofs;
+    int index = zip_sort(local_header_ofs_array, i);
+
+    if (index != i) {
+      zip_index_update(entry_mark, i, index);
+    }
+    entry_mark[i].file_index = index;
+  }
+
+  mz_uint64 *length = (mz_uint64 *)calloc(n, sizeof(mz_uint64));
+  if (!length) {
+    CLEANUP(local_header_ofs_array);
+    return ZIP_EOOMEM;
+  }
+  for (int i = 0; i < n - 1; i++) {
+    length[i] = local_header_ofs_array[i + 1] - local_header_ofs_array[i];
+  }
+  length[n - 1] = zip->archive.m_archive_size - local_header_ofs_array[n - 1];
+
+  for (int i = 0; i < n; i++) {
+    entry_mark[i].lf_length = length[entry_mark[i].file_index];
+  }
+
+  CLEANUP(length);
+  CLEANUP(local_header_ofs_array);
+  return 0;
+}
+
+static int zip_entry_set(struct zip_t *zip, struct zip_entry_mark_t *entry_mark,
+                         int n, char *const entries[], const size_t len) {
+  int err = 0;
+
+  if ((err = zip_entry_mark(zip, entry_mark, n, entries, len)) < 0) {
+    return err;
+  }
+  if ((err = zip_entry_finalize(zip, entry_mark, n)) < 0) {
+    return err;
+  }
+  return 0;
+}
+
+static mz_int64 zip_file_move(MZ_FILE *m_pFile, const mz_uint64 to,
+                              const mz_uint64 from, const mz_uint64 length,
+                              mz_uint8 *move_buf,
+                              const mz_int64 capacity_size) {
+  if ((mz_int64)length > capacity_size) {
+    return ZIP_ECAPSIZE;
+  }
+  if (MZ_FSEEK64(m_pFile, from, SEEK_SET)) {
+    MZ_FCLOSE(m_pFile);
+    return ZIP_EFSEEK;
+  }
+
+  if (fread(move_buf, 1, length, m_pFile) != length) {
+    MZ_FCLOSE(m_pFile);
+    return ZIP_EFREAD;
+  }
+  if (MZ_FSEEK64(m_pFile, to, SEEK_SET)) {
+    MZ_FCLOSE(m_pFile);
+    return ZIP_EFSEEK;
+  }
+  if (fwrite(move_buf, 1, length, m_pFile) != length) {
+    MZ_FCLOSE(m_pFile);
+    return ZIP_EFWRITE;
+  }
+  return (mz_int64)length;
+}
+
+static mz_int64 zip_files_move(MZ_FILE *m_pFile, mz_uint64 writen_num,
+                               mz_uint64 read_num, mz_uint64 length) {
+  int n = 0;
+  const mz_int64 page_size = 1 << 12; // 4K
+  mz_uint8 *move_buf = (mz_uint8 *)calloc(1, page_size);
+  if (move_buf == NULL) {
+    return ZIP_EOOMEM;
+  }
+
+  mz_int64 moved_length = 0;
+  mz_int64 move_count = 0;
+  while ((mz_int64)length > 0) {
+    move_count = ((mz_int64)length >= page_size) ? page_size : (mz_int64)length;
+    n = (int) zip_file_move(m_pFile, writen_num, read_num, move_count, move_buf,
+                      page_size);
+    if (n < 0) {
+      moved_length = n;
+      goto cleanup;
+    }
+
+    if (n != move_count) {
+      goto cleanup;
+    }
+
+    writen_num += move_count;
+    read_num += move_count;
+    length -= move_count;
+    moved_length += move_count;
+  }
+
+cleanup:
+  CLEANUP(move_buf);
+  return moved_length;
+}
+
+static int zip_central_dir_move(mz_zip_internal_state *pState, int begin,
+                                int end, int entry_num) {
+  if (begin == entry_num) {
+    return 0;
+  }
+
+  mz_uint64 l_size = 0;
+  mz_uint64 r_size = 0;
+  mz_uint64 d_size = 0;
+  mz_uint8 *next = NULL;
+  mz_uint8 *deleted = &MZ_ZIP_ARRAY_ELEMENT(
+      &pState->m_central_dir, mz_uint8,
+      MZ_ZIP_ARRAY_ELEMENT(&pState->m_central_dir_offsets, mz_uint32, begin));
+  l_size = (mz_uint32)(deleted - (mz_uint8 *)(pState->m_central_dir.m_p));
+  if (end == entry_num) {
+    r_size = 0;
+  } else {
+    next = &MZ_ZIP_ARRAY_ELEMENT(
+        &pState->m_central_dir, mz_uint8,
+        MZ_ZIP_ARRAY_ELEMENT(&pState->m_central_dir_offsets, mz_uint32, end));
+    r_size = pState->m_central_dir.m_size -
+             (mz_uint32)(next - (mz_uint8 *)(pState->m_central_dir.m_p));
+    d_size = next - deleted;
+  }
+
+  if (l_size == 0) {
+    memmove(pState->m_central_dir.m_p, next, r_size);
+    pState->m_central_dir.m_p = MZ_REALLOC(pState->m_central_dir.m_p, r_size);
+    for (int i = end; i < entry_num; i++) {
+      MZ_ZIP_ARRAY_ELEMENT(&pState->m_central_dir_offsets, mz_uint64, i) -=
+          d_size;
+    }
+  }
+
+  if (l_size * r_size != 0) {
+    memmove(deleted, next, r_size);
+    for (int i = end; i < entry_num; i++) {
+      MZ_ZIP_ARRAY_ELEMENT(&pState->m_central_dir_offsets, mz_uint64, i) -=
+          d_size;
+    }
+  }
+
+  pState->m_central_dir.m_size = l_size + r_size;
+  return 0;
+}
+
+static int zip_central_dir_delete(mz_zip_internal_state *pState,
+                                  int *deleted_entry_index_array,
+                                  int entry_num) {
+  int i = 0;
+  int begin = 0;
+  int end = 0;
+  int d_num = 0;
+  while (i < entry_num) {
+    while ((!deleted_entry_index_array[i]) && (i < entry_num)) {
+      i++;
+    }
+    begin = i;
+
+    while ((deleted_entry_index_array[i]) && (i < entry_num)) {
+      i++;
+    }
+    end = i;
+    zip_central_dir_move(pState, begin, end, entry_num);
+  }
+
+  i = 0;
+  while (i < entry_num) {
+    while ((!deleted_entry_index_array[i]) && (i < entry_num)) {
+      i++;
+    }
+    begin = i;
+    if (begin == entry_num) {
+      break;
+    }
+    while ((deleted_entry_index_array[i]) && (i < entry_num)) {
+      i++;
+    }
+    end = i;
+    int k = 0;
+    for (int j = end; j < entry_num; j++) {
+      MZ_ZIP_ARRAY_ELEMENT(&pState->m_central_dir_offsets, mz_uint32,
+                           begin + k) =
+          (mz_uint32)MZ_ZIP_ARRAY_ELEMENT(&pState->m_central_dir_offsets,
+                                          mz_uint32, j);
+      k++;
+    }
+    d_num += end - begin;
+  }
+
+  pState->m_central_dir_offsets.m_size =
+      sizeof(mz_uint32) * (entry_num - d_num);
+  return 0;
+}
+
+static int zip_entries_delete_mark(struct zip_t *zip,
+                                   struct zip_entry_mark_t *entry_mark,
+                                   int entry_num) {
+  mz_uint64 writen_num = 0;
+  mz_uint64 read_num = 0;
+  mz_uint64 deleted_length = 0;
+  mz_uint64 move_length = 0;
+  int i = 0;
+  int deleted_entry_num = 0;
+  int n = 0;
+
+  mz_bool *deleted_entry_flag_array =
+      (mz_bool *)calloc(entry_num, sizeof(mz_bool));
+  if (deleted_entry_flag_array == NULL) {
+    return ZIP_EOOMEM;
+  }
+
+  mz_zip_internal_state *pState = zip->archive.m_pState;
+  zip->archive.m_zip_mode = MZ_ZIP_MODE_WRITING;
+
+  if (MZ_FSEEK64(pState->m_pFile, 0, SEEK_SET)) {
+    CLEANUP(deleted_entry_flag_array);
+    return ZIP_ENOENT;
+  }
+
+  while (i < entry_num) {
+    while ((entry_mark[i].type == MZ_KEEP) && (i < entry_num)) {
+      writen_num += entry_mark[i].lf_length;
+      read_num = writen_num;
+      i++;
+    }
+
+    while ((entry_mark[i].type == MZ_DELETE) && (i < entry_num)) {
+      deleted_entry_flag_array[i] = MZ_TRUE;
+      read_num += entry_mark[i].lf_length;
+      deleted_length += entry_mark[i].lf_length;
+      i++;
+      deleted_entry_num++;
+    }
+
+    while ((entry_mark[i].type == MZ_MOVE) && (i < entry_num)) {
+      move_length += entry_mark[i].lf_length;
+      mz_uint8 *p = &MZ_ZIP_ARRAY_ELEMENT(
+          &pState->m_central_dir, mz_uint8,
+          MZ_ZIP_ARRAY_ELEMENT(&pState->m_central_dir_offsets, mz_uint32, i));
+      if (!p) {
+        CLEANUP(deleted_entry_flag_array);
+        return ZIP_ENOENT;
+      }
+      mz_uint32 offset = MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS);
+      offset -= (mz_uint32)deleted_length;
+      MZ_WRITE_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS, offset);
+      i++;
+    }
+
+    n = (int) zip_files_move(pState->m_pFile, writen_num, read_num, move_length);
+    if (n != (mz_int64)move_length) {
+      CLEANUP(deleted_entry_flag_array);
+      return n;
+    }
+    writen_num += move_length;
+    read_num += move_length;
+  }
+
+  zip->archive.m_archive_size -= deleted_length;
+  zip->archive.m_total_files = entry_num - deleted_entry_num;
+
+  zip_central_dir_delete(pState, deleted_entry_flag_array, entry_num);
+  CLEANUP(deleted_entry_flag_array);
+
+  return deleted_entry_num;
+}
+
 struct zip_t *zip_open(const char *zipname, int level, char mode) {
   struct zip_t *zip = NULL;
 
@@ -177,6 +808,7 @@ struct zip_t *zip_open(const char *zipname, int level, char mode) {
 
   case 'r':
   case 'a':
+  case 'd':
     if (!mz_zip_reader_init_file(
             &(zip->archive), zipname,
             zip->level | MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY)) {
@@ -184,7 +816,7 @@ struct zip_t *zip_open(const char *zipname, int level, char mode) {
       // zip_archive reader
       goto cleanup;
     }
-    if (mode == 'a' &&
+    if ((mode == 'a' || mode == 'd') &&
         !mz_zip_writer_init_from_reader(&(zip->archive), zipname)) {
       mz_zip_reader_end(&(zip->archive));
       goto cleanup;
@@ -207,7 +839,7 @@ void zip_close(struct zip_t *zip) {
     // Always finalize, even if adding failed for some reason, so we have a
     // valid central directory.
     mz_zip_writer_finalize_archive(&(zip->archive));
-
+    zip_archive_truncate(&(zip->archive));
     mz_zip_writer_end(&(zip->archive));
     mz_zip_reader_end(&(zip->archive));
 
@@ -215,19 +847,33 @@ void zip_close(struct zip_t *zip) {
   }
 }
 
+int zip_is64(struct zip_t *zip) {
+  if (!zip || !zip->archive.m_pState) {
+    // zip_t handler or zip state is not initialized
+    return ZIP_ENOINIT;
+  }
+
+  return (int)zip->archive.m_pState->m_zip64;
+}
+
 int zip_entry_open(struct zip_t *zip, const char *entryname) {
   size_t entrylen = 0;
   mz_zip_archive *pzip = NULL;
   mz_uint num_alignment_padding_bytes, level;
   mz_zip_archive_file_stat stats;
+  int err = 0;
 
-  if (!zip || !entryname) {
-    return -1;
+  if (!zip) {
+    return ZIP_ENOINIT;
+  }
+
+  if (!entryname) {
+    return ZIP_EINVENTNAME;
   }
 
   entrylen = strlen(entryname);
-  if (entrylen < 1) {
-    return -1;
+  if (entrylen == 0) {
+    return ZIP_EINVENTNAME;
   }
 
   /*
@@ -241,10 +887,13 @@ int zip_entry_open(struct zip_t *zip, const char *entryname) {
     and UNIX file systems etc.  If input came from standard
     input, there is no file name field.
   */
-  zip->entry.name = strrpl(entryname, entrylen, '\\', '/');
+  if (zip->entry.name) {
+    CLEANUP(zip->entry.name);
+  }
+  zip->entry.name = zip_strrpl(entryname, entrylen, '\\', '/');
   if (!zip->entry.name) {
     // Cannot parse zip entry name
-    return -1;
+    return ZIP_EINVENTNAME;
   }
 
   pzip = &(zip->archive);
@@ -252,10 +901,12 @@ int zip_entry_open(struct zip_t *zip, const char *entryname) {
     zip->entry.index =
         mz_zip_reader_locate_file(pzip, zip->entry.name, NULL, 0);
     if (zip->entry.index < 0) {
+      err = ZIP_ENOENT;
       goto cleanup;
     }
 
     if (!mz_zip_reader_file_stat(pzip, (mz_uint)zip->entry.index, &stats)) {
+      err = ZIP_ENOENT;
       goto cleanup;
     }
 
@@ -266,7 +917,9 @@ int zip_entry_open(struct zip_t *zip, const char *entryname) {
     zip->entry.header_offset = stats.m_local_header_ofs;
     zip->entry.method = stats.m_method;
     zip->entry.external_attr = stats.m_external_attr;
+#ifndef MINIZ_NO_TIME
     zip->entry.m_time = stats.m_time;
+#endif
 
     return 0;
   }
@@ -279,17 +932,26 @@ int zip_entry_open(struct zip_t *zip, const char *entryname) {
   zip->entry.header_offset = zip->archive.m_archive_size;
   memset(zip->entry.header, 0, MZ_ZIP_LOCAL_DIR_HEADER_SIZE * sizeof(mz_uint8));
   zip->entry.method = 0;
+
+  // UNIX or APPLE
+#if MZ_PLATFORM == 3 || MZ_PLATFORM == 19
+  // regular file with rw-r--r-- persmissions
+  zip->entry.external_attr = (mz_uint32)(0100644) << 16;
+#else
   zip->entry.external_attr = 0;
+#endif
 
   num_alignment_padding_bytes =
       mz_zip_writer_compute_padding_needed_for_file_alignment(pzip);
 
   if (!pzip->m_pState || (pzip->m_zip_mode != MZ_ZIP_MODE_WRITING)) {
-    // Wrong zip mode
+    // Invalid zip mode
+    err = ZIP_EINVMODE;
     goto cleanup;
   }
   if (zip->level & MZ_ZIP_FLAG_COMPRESSED_DATA) {
-    // Wrong zip compression level
+    // Invalid zip compression level
+    err = ZIP_EINVLVL;
     goto cleanup;
   }
   // no zip64 support yet
@@ -298,12 +960,14 @@ int zip_entry_open(struct zip_t *zip, const char *entryname) {
         MZ_ZIP_LOCAL_DIR_HEADER_SIZE + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE +
         entrylen) > 0xFFFFFFFF)) {
     // No zip64 support yet
+    err = ZIP_ENOSUP64;
     goto cleanup;
   }
   if (!mz_zip_writer_write_zeros(pzip, zip->entry.offset,
                                  num_alignment_padding_bytes +
                                      sizeof(zip->entry.header))) {
     // Cannot memset zip entry header
+    err = ZIP_EMEMSET;
     goto cleanup;
   }
 
@@ -317,6 +981,7 @@ int zip_entry_open(struct zip_t *zip, const char *entryname) {
   if (pzip->m_pWrite(pzip->m_pIO_opaque, zip->entry.offset, zip->entry.name,
                      entrylen) != entrylen) {
     // Cannot write data to zip entry
+    err = ZIP_EWRTENT;
     goto cleanup;
   }
 
@@ -333,6 +998,7 @@ int zip_entry_open(struct zip_t *zip, const char *entryname) {
                        (int)level, -15, MZ_DEFAULT_STRATEGY)) !=
         TDEFL_STATUS_OKAY) {
       // Cannot initialize the zip compressor
+      err = ZIP_ETDEFLINIT;
       goto cleanup;
     }
   }
@@ -343,7 +1009,7 @@ int zip_entry_open(struct zip_t *zip, const char *entryname) {
 
 cleanup:
   CLEANUP(zip->entry.name);
-  return -1;
+  return err;
 }
 
 int zip_entry_openbyindex(struct zip_t *zip, int index) {
@@ -355,28 +1021,26 @@ int zip_entry_openbyindex(struct zip_t *zip, int index) {
 
   if (!zip) {
     // zip_t handler is not initialized
-    return -1;
+    return ZIP_ENOINIT;
   }
 
   pZip = &(zip->archive);
   if (pZip->m_zip_mode != MZ_ZIP_MODE_READING) {
     // open by index requires readonly mode
-    return -1;
+    return ZIP_EINVMODE;
   }
 
   if (index < 0 || (mz_uint)index >= pZip->m_total_files) {
     // index out of range
-    return -1;
+    return ZIP_EINVIDX;
   }
-
   if (!(pHeader = &MZ_ZIP_ARRAY_ELEMENT(
             &pZip->m_pState->m_central_dir, mz_uint8,
             MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets,
                                  mz_uint32, index)))) {
     // cannot find header in central directory
-    return -1;
+    return ZIP_ENOHDR;
   }
-
   namelen = MZ_READ_LE16(pHeader + MZ_ZIP_CDH_FILENAME_LEN_OFS);
   pFilename = (const char *)pHeader + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE;
 
@@ -391,14 +1055,17 @@ int zip_entry_openbyindex(struct zip_t *zip, int index) {
     and UNIX file systems etc.  If input came from standard
     input, there is no file name field.
   */
-  zip->entry.name = strrpl(pFilename, namelen, '\\', '/');
+  if (zip->entry.name) {
+    CLEANUP(zip->entry.name);
+  }
+  zip->entry.name = zip_strrpl(pFilename, namelen, '\\', '/');
   if (!zip->entry.name) {
     // local entry name is NULL
-    return -1;
+    return ZIP_EINVENTNAME;
   }
 
   if (!mz_zip_reader_file_stat(pZip, (mz_uint)index, &stats)) {
-    return -1;
+    return ZIP_ENOENT;
   }
 
   zip->entry.index = index;
@@ -409,7 +1076,9 @@ int zip_entry_openbyindex(struct zip_t *zip, int index) {
   zip->entry.header_offset = stats.m_local_header_ofs;
   zip->entry.method = stats.m_method;
   zip->entry.external_attr = stats.m_external_attr;
+#ifndef MINIZ_NO_TIME
   zip->entry.m_time = stats.m_time;
+#endif
 
   return 0;
 }
@@ -419,17 +1088,17 @@ int zip_entry_close(struct zip_t *zip) {
   mz_uint level;
   tdefl_status done;
   mz_uint16 entrylen;
-  mz_uint16 dos_time, dos_date;
-  int status = -1;
+  mz_uint16 dos_time = 0, dos_date = 0;
+  int err = 0;
 
   if (!zip) {
     // zip_t handler is not initialized
+    err = ZIP_ENOINIT;
     goto cleanup;
   }
 
   pzip = &(zip->archive);
   if (pzip->m_zip_mode == MZ_ZIP_MODE_READING) {
-    status = 0;
     goto cleanup;
   }
 
@@ -438,6 +1107,7 @@ int zip_entry_close(struct zip_t *zip) {
     done = tdefl_compress_buffer(&(zip->entry.comp), "", 0, TDEFL_FINISH);
     if (done != TDEFL_STATUS_DONE && done != TDEFL_STATUS_OKAY) {
       // Cannot flush compressed buffer
+      err = ZIP_ETDEFLBUF;
       goto cleanup;
     }
     zip->entry.comp_size = zip->entry.state.m_comp_size;
@@ -446,18 +1116,22 @@ int zip_entry_close(struct zip_t *zip) {
   }
 
   entrylen = (mz_uint16)strlen(zip->entry.name);
-  // no zip64 support yet
   if ((zip->entry.comp_size > 0xFFFFFFFF) || (zip->entry.offset > 0xFFFFFFFF)) {
     // No zip64 support, yet
+    err = ZIP_ENOSUP64;
     goto cleanup;
   }
 
+#ifndef MINIZ_NO_TIME
   mz_zip_time_t_to_dos_time(zip->entry.m_time, &dos_time, &dos_date);
+#endif
+
   if (!mz_zip_writer_create_local_dir_header(
           pzip, zip->entry.header, entrylen, 0, zip->entry.uncomp_size,
           zip->entry.comp_size, zip->entry.uncomp_crc32, zip->entry.method, 0,
           dos_time, dos_date)) {
     // Cannot create zip entry header
+    err = ZIP_ECRTHDR;
     goto cleanup;
   }
 
@@ -465,6 +1139,7 @@ int zip_entry_close(struct zip_t *zip) {
                      zip->entry.header,
                      sizeof(zip->entry.header)) != sizeof(zip->entry.header)) {
     // Cannot write zip entry header
+    err = ZIP_EWRTHDR;
     goto cleanup;
   }
 
@@ -474,19 +1149,19 @@ int zip_entry_close(struct zip_t *zip) {
           zip->entry.method, 0, dos_time, dos_date, zip->entry.header_offset,
           zip->entry.external_attr)) {
     // Cannot write to zip central dir
+    err = ZIP_EWRTDIR;
     goto cleanup;
   }
 
   pzip->m_total_files++;
   pzip->m_archive_size = zip->entry.offset;
-  status = 0;
 
 cleanup:
   if (zip) {
     zip->entry.m_time = 0;
     CLEANUP(zip->entry.name);
   }
-  return status;
+  return err;
 }
 
 const char *zip_entry_name(struct zip_t *zip) {
@@ -501,7 +1176,7 @@ const char *zip_entry_name(struct zip_t *zip) {
 int zip_entry_index(struct zip_t *zip) {
   if (!zip) {
     // zip_t handler is not initialized
-    return -1;
+    return ZIP_ENOINIT;
   }
 
   return zip->entry.index;
@@ -510,12 +1185,12 @@ int zip_entry_index(struct zip_t *zip) {
 int zip_entry_isdir(struct zip_t *zip) {
   if (!zip) {
     // zip_t handler is not initialized
-    return -1;
+    return ZIP_ENOINIT;
   }
 
   if (zip->entry.index < 0) {
     // zip entry is not opened
-    return -1;
+    return ZIP_EINVIDX;
   }
 
   return (int)mz_zip_reader_is_file_a_directory(&zip->archive,
@@ -537,7 +1212,7 @@ int zip_entry_write(struct zip_t *zip, const void *buf, size_t bufsize) {
 
   if (!zip) {
     // zip_t handler is not initialized
-    return -1;
+    return ZIP_ENOINIT;
   }
 
   pzip = &(zip->archive);
@@ -551,7 +1226,7 @@ int zip_entry_write(struct zip_t *zip, const void *buf, size_t bufsize) {
       if ((pzip->m_pWrite(pzip->m_pIO_opaque, zip->entry.offset, buf,
                           bufsize) != bufsize)) {
         // Cannot write buffer
-        return -1;
+        return ZIP_EWRTENT;
       }
       zip->entry.offset += bufsize;
       zip->entry.comp_size += bufsize;
@@ -560,7 +1235,7 @@ int zip_entry_write(struct zip_t *zip, const void *buf, size_t bufsize) {
                                      TDEFL_NO_FLUSH);
       if (status != TDEFL_STATUS_DONE && status != TDEFL_STATUS_OKAY) {
         // Cannot compress buffer
-        return -1;
+        return ZIP_ETDEFLBUF;
       }
     }
   }
@@ -569,7 +1244,7 @@ int zip_entry_write(struct zip_t *zip, const void *buf, size_t bufsize) {
 }
 
 int zip_entry_fwrite(struct zip_t *zip, const char *filename) {
-  int status = 0;
+  int err = 0;
   size_t n = 0;
   FILE *stream = NULL;
   mz_uint8 buf[MZ_ZIP_MAX_IO_BUF_SIZE];
@@ -577,14 +1252,14 @@ int zip_entry_fwrite(struct zip_t *zip, const char *filename) {
 
   if (!zip) {
     // zip_t handler is not initialized
-    return -1;
+    return ZIP_ENOINIT;
   }
 
   memset(buf, 0, MZ_ZIP_MAX_IO_BUF_SIZE);
   memset((void *)&file_stat, 0, sizeof(struct MZ_FILE_STAT_STRUCT));
   if (MZ_FILE_STAT(filename, &file_stat) != 0) {
     // problem getting information - check errno
-    return -1;
+    return ZIP_ENOENT;
   }
 
   if ((file_stat.st_mode & 0200) == 0) {
@@ -601,19 +1276,19 @@ int zip_entry_fwrite(struct zip_t *zip, const char *filename) {
 #endif
   {
     // Cannot open filename
-    return -1;
+    return ZIP_EOPNFILE;
   }
 
   while ((n = fread(buf, sizeof(mz_uint8), MZ_ZIP_MAX_IO_BUF_SIZE, stream)) >
          0) {
     if (zip_entry_write(zip, buf, n) < 0) {
-      status = -1;
+      err = ZIP_EWRTENT;
       break;
     }
   }
   fclose(stream);
 
-  return status;
+  return err;
 }
 
 ssize_t zip_entry_read(struct zip_t *zip, void **buf, size_t *bufsize) {
@@ -623,19 +1298,19 @@ ssize_t zip_entry_read(struct zip_t *zip, void **buf, size_t *bufsize) {
 
   if (!zip) {
     // zip_t handler is not initialized
-    return -1;
+    return ZIP_ENOINIT;
   }
 
   pzip = &(zip->archive);
   if (pzip->m_zip_mode != MZ_ZIP_MODE_READING || zip->entry.index < 0) {
     // the entry is not found or we do not have read access
-    return -1;
+    return ZIP_ENOENT;
   }
 
   idx = (mz_uint)zip->entry.index;
   if (mz_zip_reader_is_file_a_directory(pzip, idx)) {
     // the entry is a directory
-    return -1;
+    return ZIP_EINVENTTYPE;
   }
 
   *buf = mz_zip_reader_extract_to_heap(pzip, idx, &size, 0);
@@ -650,18 +1325,18 @@ ssize_t zip_entry_noallocread(struct zip_t *zip, void *buf, size_t bufsize) {
 
   if (!zip) {
     // zip_t handler is not initialized
-    return -1;
+    return ZIP_ENOINIT;
   }
 
   pzip = &(zip->archive);
   if (pzip->m_zip_mode != MZ_ZIP_MODE_READING || zip->entry.index < 0) {
     // the entry is not found or we do not have read access
-    return -1;
+    return ZIP_ENOENT;
   }
 
   if (!mz_zip_reader_extract_to_mem_no_alloc(pzip, (mz_uint)zip->entry.index,
-  buf, bufsize, 0, NULL,  0)) {
-    return -1;
+                                             buf, bufsize, 0, NULL, 0)) {
+    return ZIP_EMEMNOALLOC;
   }
 
   return (ssize_t)zip->entry.uncomp_size;
@@ -670,45 +1345,43 @@ ssize_t zip_entry_noallocread(struct zip_t *zip, void *buf, size_t bufsize) {
 int zip_entry_fread(struct zip_t *zip, const char *filename) {
   mz_zip_archive *pzip = NULL;
   mz_uint idx;
-#if defined(_MSC_VER)
-#else
   mz_uint32 xattr = 0;
-#endif
   mz_zip_archive_file_stat info;
 
   if (!zip) {
     // zip_t handler is not initialized
-    return -1;
+    return ZIP_ENOINIT;
   }
 
   memset((void *)&info, 0, sizeof(mz_zip_archive_file_stat));
   pzip = &(zip->archive);
   if (pzip->m_zip_mode != MZ_ZIP_MODE_READING || zip->entry.index < 0) {
     // the entry is not found or we do not have read access
-    return -1;
+    return ZIP_ENOENT;
   }
 
   idx = (mz_uint)zip->entry.index;
   if (mz_zip_reader_is_file_a_directory(pzip, idx)) {
     // the entry is a directory
-    return -1;
+    return ZIP_EINVENTTYPE;
   }
 
   if (!mz_zip_reader_extract_to_file(pzip, idx, filename, 0)) {
-    return -1;
+    return ZIP_ENOFILE;
   }
 
 #if defined(_MSC_VER)
+  (void)xattr; // unused
 #else
   if (!mz_zip_reader_file_stat(pzip, idx, &info)) {
     // Cannot get information about zip archive;
-    return -1;
+    return ZIP_ENOFILE;
   }
 
   xattr = (info.m_external_attr >> 16) & 0xFFFF;
   if (xattr > 0) {
     if (chmod(filename, (mode_t)xattr) < 0) {
-      return -1;
+      return ZIP_ENOPERM;
     }
   }
 #endif
@@ -725,32 +1398,147 @@ int zip_entry_extract(struct zip_t *zip,
 
   if (!zip) {
     // zip_t handler is not initialized
-    return -1;
+    return ZIP_ENOINIT;
   }
 
   pzip = &(zip->archive);
   if (pzip->m_zip_mode != MZ_ZIP_MODE_READING || zip->entry.index < 0) {
     // the entry is not found or we do not have read access
-    return -1;
+    return ZIP_ENOENT;
   }
 
   idx = (mz_uint)zip->entry.index;
   return (mz_zip_reader_extract_to_callback(pzip, idx, on_extract, arg, 0))
              ? 0
-             : -1;
+             : ZIP_EINVIDX;
 }
 
-int zip_total_entries(struct zip_t *zip) {
+int zip_entries_total(struct zip_t *zip) {
   if (!zip) {
     // zip_t handler is not initialized
-    return -1;
+    return ZIP_ENOINIT;
   }
 
   return (int)zip->archive.m_total_files;
 }
 
+int zip_entries_delete(struct zip_t *zip, char *const entries[],
+                       const size_t len) {
+  int n = 0;
+  int err = 0;
+  struct zip_entry_mark_t *entry_mark = NULL;
+
+  if (zip == NULL || (entries == NULL && len != 0)) {
+    return ZIP_ENOINIT;
+  }
+
+  if (entries == NULL && len == 0) {
+    return 0;
+  }
+
+  n = zip_entries_total(zip);
+
+  entry_mark =
+      (struct zip_entry_mark_t *)calloc(n, sizeof(struct zip_entry_mark_t));
+  if (!entry_mark) {
+    return ZIP_EOOMEM;
+  }
+
+  zip->archive.m_zip_mode = MZ_ZIP_MODE_READING;
+
+  err = zip_entry_set(zip, entry_mark, n, entries, len);
+  if (err < 0) {
+    CLEANUP(entry_mark);
+    return err;
+  }
+
+  err = zip_entries_delete_mark(zip, entry_mark, n);
+  CLEANUP(entry_mark);
+  return err;
+}
+
+int zip_stream_extract(const char *stream, size_t size, const char *dir,
+                       int (*on_extract)(const char *filename, void *arg),
+                       void *arg) {
+  mz_zip_archive zip_archive;
+  if (!stream || !dir) {
+    // Cannot parse zip archive stream
+    return ZIP_ENOINIT;
+  }
+  if (!memset(&zip_archive, 0, sizeof(mz_zip_archive))) {
+    // Cannot memset zip archive
+    return ZIP_EMEMSET;
+  }
+  if (!mz_zip_reader_init_mem(&zip_archive, stream, size, 0)) {
+    // Cannot initialize zip_archive reader
+    return ZIP_ENOINIT;
+  }
+
+  return zip_archive_extract(&zip_archive, dir, on_extract, arg);
+}
+
+struct zip_t *zip_stream_open(const char *stream, size_t size, int level,
+                              char mode) {
+  struct zip_t *zip = (struct zip_t *)calloc((size_t)1, sizeof(struct zip_t));
+  if (!zip) {
+    return NULL;
+  }
+
+  if (level < 0) {
+    level = MZ_DEFAULT_LEVEL;
+  }
+  if ((level & 0xF) > MZ_UBER_COMPRESSION) {
+    // Wrong compression level
+    goto cleanup;
+  }
+  zip->level = (mz_uint)level;
+
+  if ((stream != NULL) && (size > 0) && (mode == 'r')) {
+    if (!mz_zip_reader_init_mem(&(zip->archive), stream, size, 0)) {
+      goto cleanup;
+    }
+  } else if ((stream == NULL) && (size == 0) && (mode == 'w')) {
+    // Create a new archive.
+    if (!mz_zip_writer_init_heap(&(zip->archive), 0, 1024)) {
+      // Cannot initialize zip_archive writer
+      goto cleanup;
+    }
+  } else {
+    goto cleanup;
+  }
+  return zip;
+
+cleanup:
+  CLEANUP(zip);
+  return NULL;
+}
+
+ssize_t zip_stream_copy(struct zip_t *zip, void **buf, ssize_t *bufsize) {
+  if (!zip) {
+    return ZIP_ENOINIT;
+  }
+
+  zip_archive_finalize(&(zip->archive));
+
+  if (bufsize != NULL) {
+    *bufsize = zip->archive.m_archive_size;
+  }
+  *buf = calloc(sizeof(unsigned char), zip->archive.m_archive_size);
+  memcpy(*buf, zip->archive.m_pState->m_pMem, zip->archive.m_archive_size);
+
+  return zip->archive.m_archive_size;
+}
+
+void zip_stream_close(struct zip_t *zip) {
+  if (zip) {
+    mz_zip_writer_end(&(zip->archive));
+    mz_zip_reader_end(&(zip->archive));
+    CLEANUP(zip);
+  }
+}
+
 int zip_create(const char *zipname, const char *filenames[], size_t len) {
-  int status = 0;
+  int err = 0;
   size_t i;
   mz_zip_archive zip_archive;
   struct MZ_FILE_STAT_STRUCT file_stat;
@@ -758,32 +1546,35 @@ int zip_create(const char *zipname, const char *filenames[], size_t len) {
 
   if (!zipname || strlen(zipname) < 1) {
     // zip_t archive name is empty or NULL
-    return -1;
+    return ZIP_EINVZIPNAME;
   }
 
   // Create a new archive.
   if (!memset(&(zip_archive), 0, sizeof(zip_archive))) {
     // Cannot memset zip archive
-    return -1;
+    return ZIP_EMEMSET;
   }
 
   if (!mz_zip_writer_init_file(&zip_archive, zipname, 0)) {
     // Cannot initialize zip_archive writer
-    return -1;
+    return ZIP_ENOINIT;
   }
 
-  memset((void *)&file_stat, 0, sizeof(struct MZ_FILE_STAT_STRUCT));
+  if (!memset((void *)&file_stat, 0, sizeof(struct MZ_FILE_STAT_STRUCT))) {
+    return ZIP_EMEMSET;
+  }
 
   for (i = 0; i < len; ++i) {
     const char *name = filenames[i];
     if (!name) {
-      status = -1;
+      err = ZIP_EINVENTNAME;
       break;
     }
 
     if (MZ_FILE_STAT(name, &file_stat) != 0) {
       // problem getting information - check errno
-      return -1;
+      err = ZIP_ENOFILE;
+      break;
     }
 
     if ((file_stat.st_mode & 0200) == 0) {
@@ -792,135 +1583,39 @@ int zip_create(const char *zipname, const char *filenames[], size_t len) {
     }
     ext_attributes |= (mz_uint32)((file_stat.st_mode & 0xFFFF) << 16);
 
-    if (!mz_zip_writer_add_file(&zip_archive, base_name(name), name, "", 0,
+    if (!mz_zip_writer_add_file(&zip_archive, zip_basename(name), name, "", 0,
                                 ZIP_DEFAULT_COMPRESSION_LEVEL,
                                 ext_attributes)) {
       // Cannot add file to zip_archive
-      status = -1;
+      err = ZIP_ENOFILE;
       break;
     }
   }
 
   mz_zip_writer_finalize_archive(&zip_archive);
   mz_zip_writer_end(&zip_archive);
-  return status;
+  return err;
 }
 
 int zip_extract(const char *zipname, const char *dir,
                 int (*on_extract)(const char *filename, void *arg), void *arg) {
-  int status = -1;
-  mz_uint i, n;
-  char path[MAX_PATH + 1];
-  char symlink_to[MAX_PATH + 1];
   mz_zip_archive zip_archive;
-  mz_zip_archive_file_stat info;
-  size_t dirlen = 0;
-  mz_uint32 xattr = 0;
-
-  memset(path, 0, sizeof(path));
-  memset(symlink_to, 0, sizeof(symlink_to));
-  if (!memset(&(zip_archive), 0, sizeof(zip_archive))) {
-    // Cannot memset zip archive
-    return -1;
-  }
 
   if (!zipname || !dir) {
     // Cannot parse zip archive name
-    return -1;
+    return ZIP_EINVZIPNAME;
   }
 
-  dirlen = strlen(dir);
-  if (dirlen + 1 > MAX_PATH) {
-    return -1;
+  if (!memset(&zip_archive, 0, sizeof(mz_zip_archive))) {
+    // Cannot memset zip archive
+    return ZIP_EMEMSET;
   }
 
   // Now try to open the archive.
   if (!mz_zip_reader_init_file(&zip_archive, zipname, 0)) {
     // Cannot initialize zip_archive reader
-    return -1;
+    return ZIP_ENOINIT;
   }
 
-  memset((void *)&info, 0, sizeof(mz_zip_archive_file_stat));
-
-#if defined(_MSC_VER)
-  strcpy_s(path, MAX_PATH, dir);
-#else
-  strcpy(path, dir);
-#endif
-
-  if (!ISSLASH(path[dirlen - 1])) {
-#if defined(_WIN32) || defined(__WIN32__)
-    path[dirlen] = '\\';
-#else
-    path[dirlen] = '/';
-#endif
-    ++dirlen;
-  }
-
-  // Get and print information about each file in the archive.
-  n = mz_zip_reader_get_num_files(&zip_archive);
-  for (i = 0; i < n; ++i) {
-    if (!mz_zip_reader_file_stat(&zip_archive, i, &info)) {
-      // Cannot get information about zip archive;
-      goto out;
-    }
-#if defined(_MSC_VER)
-    strncpy_s(&path[dirlen], MAX_PATH - dirlen, info.m_filename,
-              MAX_PATH - dirlen);
-#else
-    strncpy(&path[dirlen], info.m_filename, MAX_PATH - dirlen);
-#endif
-    if (mkpath(path) < 0) {
-      // Cannot make a path
-      goto out;
-    }
-
-    if ((((info.m_version_made_by >> 8) == 3) || ((info.m_version_made_by >> 8) == 19)) // if zip is produced on Unix or macOS (3 and 19 from section 4.4.2.2 of zip standard)
-        && info.m_external_attr & (0x20 << 24)) { // and has sym link attribute (0x80 is file, 0x40 is directory)
-#if defined(_WIN32) || defined(__WIN32__) || defined(_MSC_VER) ||              \
-    defined(__MINGW32__)
-#else      
-      if (info.m_uncomp_size > MAX_PATH || !mz_zip_reader_extract_to_mem_no_alloc(&zip_archive, i, symlink_to, MAX_PATH, 0, NULL, 0)) {
-        goto out;
-      }
-      symlink_to[info.m_uncomp_size] = '\0';
-      if (symlink(symlink_to, path) != 0) {
-        goto out;
-      }
-#endif
-    } else {
-      if (!mz_zip_reader_is_file_a_directory(&zip_archive, i)) {
-        if (!mz_zip_reader_extract_to_file(&zip_archive, i, path, 0)) {
-          // Cannot extract zip archive to file
-          goto out;
-        }
-      }
-
-#if defined(_MSC_VER)
-#else
-      xattr = (info.m_external_attr >> 16) & 0xFFFF;
-      if (xattr > 0) {
-        if (chmod(path, (mode_t)xattr) < 0) {
-          goto out;
-        }
-      }
-#endif
-    }
-
-    if (on_extract) {
-      if (on_extract(path, arg) < 0) {
-        goto out;
-      }
-    }
-  }
-  status = 0;
-
-out:
-  // Close the archive, freeing any resources it was using
-  if (!mz_zip_reader_end(&zip_archive)) {
-    // Cannot end zip reader
-    status = -1;
-  }
-
-  return status;
+  return zip_archive_extract(&zip_archive, dir, on_extract, arg);
 }
diff --git a/Engine/lib/assimp/contrib/zip/src/zip.h b/Engine/lib/assimp/contrib/zip/src/zip.h
index 5f39df50a..70ab2cee6 100644
--- a/Engine/lib/assimp/contrib/zip/src/zip.h
+++ b/Engine/lib/assimp/contrib/zip/src/zip.h
@@ -19,15 +19,13 @@
 extern "C" {
 #endif
 
-#if !defined(_SSIZE_T_DEFINED) && !defined(_SSIZE_T_DEFINED_) &&               \
-    !defined(_SSIZE_T) && !defined(_SSIZE_T_) && !defined(__ssize_t_defined)
-#define _SSIZE_T
+#if !defined(_POSIX_C_SOURCE) && defined(_MSC_VER)
 // 64-bit Windows is the only mainstream platform
 // where sizeof(long) != sizeof(void*)
 #ifdef _WIN64
-typedef long long  ssize_t;  /* byte count or error */
+typedef long long ssize_t; /* byte count or error */
 #else
-typedef long  ssize_t;  /* byte count or error */
+typedef long ssize_t; /* byte count or error */
 #endif
 #endif
 
@@ -35,226 +33,266 @@ typedef long  ssize_t;  /* byte count or error */
 #define MAX_PATH 32767 /* # chars in a path name including NULL */
 #endif
 
+/**
+ * @mainpage
+ *
+ * Documenation for @ref zip.
+ */
+
+/**
+ * @addtogroup zip
+ * @{
+ */
+
+/**
+ * Default zip compression level.
+ */
 #define ZIP_DEFAULT_COMPRESSION_LEVEL 6
 
-/*
-  This data structure is used throughout the library to represent zip archive
-  - forward declaration.
-*/
+/**
+ * Error codes
+ */
+#define ZIP_ENOINIT -1      // not initialized
+#define ZIP_EINVENTNAME -2  // invalid entry name
+#define ZIP_ENOENT -3       // entry not found
+#define ZIP_EINVMODE -4     // invalid zip mode
+#define ZIP_EINVLVL -5      // invalid compression level
+#define ZIP_ENOSUP64 -6     // no zip 64 support
+#define ZIP_EMEMSET -7      // memset error
+#define ZIP_EWRTENT -8      // cannot write data to entry
+#define ZIP_ETDEFLINIT -9   // cannot initialize tdefl compressor
+#define ZIP_EINVIDX -10     // invalid index
+#define ZIP_ENOHDR -11      // header not found
+#define ZIP_ETDEFLBUF -12   // cannot flush tdefl buffer
+#define ZIP_ECRTHDR -13     // cannot create entry header
+#define ZIP_EWRTHDR -14     // cannot write entry header
+#define ZIP_EWRTDIR -15     // cannot write to central dir
+#define ZIP_EOPNFILE -16    // cannot open file
+#define ZIP_EINVENTTYPE -17 // invalid entry type
+#define ZIP_EMEMNOALLOC -18 // extracting data using no memory allocation
+#define ZIP_ENOFILE -19     // file not found
+#define ZIP_ENOPERM -20     // no permission
+#define ZIP_EOOMEM -21      // out of memory
+#define ZIP_EINVZIPNAME -22 // invalid zip archive name
+#define ZIP_EMKDIR -23      // make dir error
+#define ZIP_ESYMLINK -24    // symlink error
+#define ZIP_ECLSZIP -25     // close archive error
+#define ZIP_ECAPSIZE -26    // capacity size too small
+#define ZIP_EFSEEK -27      // fseek error
+#define ZIP_EFREAD -28      // fread error
+#define ZIP_EFWRITE -29     // fwrite error
+
+/**
+ * Looks up the error message string coresponding to an error number.
+ * @param errnum error number
+ * @return error message string coresponding to errnum or NULL if error is not
+ * found.
+ */
+extern const char *zip_strerror(int errnum);
+
+/**
+ * @struct zip_t
+ *
+ * This data structure is used throughout the library to represent zip archive -
+ * forward declaration.
+ */
 struct zip_t;
 
-/*
-  Opens zip archive with compression level using the given mode.
-
-  Args:
-    zipname: zip archive file name.
-    level: compression level (0-9 are the standard zlib-style levels).
-    mode: file access mode.
-        'r': opens a file for reading/extracting (the file must exists).
-        'w': creates an empty file for writing.
-        'a': appends to an existing archive.
-
-  Returns:
-    The zip archive handler or NULL on error
-*/
+/**
+ * Opens zip archive with compression level using the given mode.
+ *
+ * @param zipname zip archive file name.
+ * @param level compression level (0-9 are the standard zlib-style levels).
+ * @param mode file access mode.
+ *        - 'r': opens a file for reading/extracting (the file must exists).
+ *        - 'w': creates an empty file for writing.
+ *        - 'a': appends to an existing archive.
+ *
+ * @return the zip archive handler or NULL on error
+ */
 extern struct zip_t *zip_open(const char *zipname, int level, char mode);
 
-/*
-  Closes the zip archive, releases resources - always finalize.
-
-  Args:
-    zip: zip archive handler.
-*/
+/**
+ * Closes the zip archive, releases resources - always finalize.
+ *
+ * @param zip zip archive handler.
+ */
 extern void zip_close(struct zip_t *zip);
 
-/*
-  Opens an entry by name in the zip archive.
-  For zip archive opened in 'w' or 'a' mode the function will append
-  a new entry. In readonly mode the function tries to locate the entry
-  in global dictionary.
+/**
+ * Determines if the archive has a zip64 end of central directory headers.
+ *
+ * @param zip zip archive handler.
+ *
+ * @return the return code - 1 (true), 0 (false), negative number (< 0) on
+ *         error.
+ */
+extern int zip_is64(struct zip_t *zip);
 
-  Args:
-    zip: zip archive handler.
-    entryname: an entry name in local dictionary.
-
-  Returns:
-    The return code - 0 on success, negative number (< 0) on error.
-*/
+/**
+ * Opens an entry by name in the zip archive.
+ *
+ * For zip archive opened in 'w' or 'a' mode the function will append
+ * a new entry. In readonly mode the function tries to locate the entry
+ * in global dictionary.
+ *
+ * @param zip zip archive handler.
+ * @param entryname an entry name in local dictionary.
+ *
+ * @return the return code - 0 on success, negative number (< 0) on error.
+ */
 extern int zip_entry_open(struct zip_t *zip, const char *entryname);
 
-/*
-  Opens a new entry by index in the zip archive.
-  This function is only valid if zip archive was opened in 'r' (readonly) mode.
-
-  Args:
-    zip: zip archive handler.
-    index: index in local dictionary.
-
-  Returns:
-    The return code - 0 on success, negative number (< 0) on error.
-*/
+/**
+ * Opens a new entry by index in the zip archive.
+ *
+ * This function is only valid if zip archive was opened in 'r' (readonly) mode.
+ *
+ * @param zip zip archive handler.
+ * @param index index in local dictionary.
+ *
+ * @return the return code - 0 on success, negative number (< 0) on error.
+ */
 extern int zip_entry_openbyindex(struct zip_t *zip, int index);
 
-/*
-  Closes a zip entry, flushes buffer and releases resources.
-
-  Args:
-    zip: zip archive handler.
-
-  Returns:
-    The return code - 0 on success, negative number (< 0) on error.
-*/
+/**
+ * Closes a zip entry, flushes buffer and releases resources.
+ *
+ * @param zip zip archive handler.
+ *
+ * @return the return code - 0 on success, negative number (< 0) on error.
+ */
 extern int zip_entry_close(struct zip_t *zip);
 
-/*
-  Returns a local name of the current zip entry.
-  The main difference between user's entry name and local entry name
-  is optional relative path.
-  Following .ZIP File Format Specification - the path stored MUST not contain
-  a drive or device letter, or a leading slash.
-  All slashes MUST be forward slashes '/' as opposed to backwards slashes '\'
-  for compatibility with Amiga and UNIX file systems etc.
-
-  Args:
-    zip: zip archive handler.
-
-  Returns:
-    The pointer to the current zip entry name, or NULL on error.
-*/
+/**
+ * Returns a local name of the current zip entry.
+ *
+ * The main difference between user's entry name and local entry name
+ * is optional relative path.
+ * Following .ZIP File Format Specification - the path stored MUST not contain
+ * a drive or device letter, or a leading slash.
+ * All slashes MUST be forward slashes '/' as opposed to backwards slashes '\'
+ * for compatibility with Amiga and UNIX file systems etc.
+ *
+ * @param zip: zip archive handler.
+ *
+ * @return the pointer to the current zip entry name, or NULL on error.
+ */
 extern const char *zip_entry_name(struct zip_t *zip);
 
-/*
-  Returns an index of the current zip entry.
-
-  Args:
-    zip: zip archive handler.
-
-  Returns:
-    The index on success, negative number (< 0) on error.
-*/
+/**
+ * Returns an index of the current zip entry.
+ *
+ * @param zip zip archive handler.
+ *
+ * @return the index on success, negative number (< 0) on error.
+ */
 extern int zip_entry_index(struct zip_t *zip);
 
-/*
-  Determines if the current zip entry is a directory entry.
-
-  Args:
-    zip: zip archive handler.
-
-  Returns:
-    The return code - 1 (true), 0 (false), negative number (< 0) on error.
-*/
+/**
+ * Determines if the current zip entry is a directory entry.
+ *
+ * @param zip zip archive handler.
+ *
+ * @return the return code - 1 (true), 0 (false), negative number (< 0) on
+ *         error.
+ */
 extern int zip_entry_isdir(struct zip_t *zip);
 
-/*
-  Returns an uncompressed size of the current zip entry.
-
-  Args:
-    zip: zip archive handler.
-
-  Returns:
-    The uncompressed size in bytes.
-*/
+/**
+ * Returns an uncompressed size of the current zip entry.
+ *
+ * @param zip zip archive handler.
+ *
+ * @return the uncompressed size in bytes.
+ */
 extern unsigned long long zip_entry_size(struct zip_t *zip);
 
-/*
-  Returns CRC-32 checksum of the current zip entry.
-
-  Args:
-    zip: zip archive handler.
-
-  Returns:
-    The CRC-32 checksum.
-*/
+/**
+ * Returns CRC-32 checksum of the current zip entry.
+ *
+ * @param zip zip archive handler.
+ *
+ * @return the CRC-32 checksum.
+ */
 extern unsigned int zip_entry_crc32(struct zip_t *zip);
 
-/*
-  Compresses an input buffer for the current zip entry.
-
-  Args:
-    zip: zip archive handler.
-    buf: input buffer.
-    bufsize: input buffer size (in bytes).
-
-  Returns:
-    The return code - 0 on success, negative number (< 0) on error.
-*/
+/**
+ * Compresses an input buffer for the current zip entry.
+ *
+ * @param zip zip archive handler.
+ * @param buf input buffer.
+ * @param bufsize input buffer size (in bytes).
+ *
+ * @return the return code - 0 on success, negative number (< 0) on error.
+ */
 extern int zip_entry_write(struct zip_t *zip, const void *buf, size_t bufsize);
 
-/*
-  Compresses a file for the current zip entry.
-
-  Args:
-    zip: zip archive handler.
-    filename: input file.
-
-  Returns:
-    The return code - 0 on success, negative number (< 0) on error.
-*/
+/**
+ * Compresses a file for the current zip entry.
+ *
+ * @param zip zip archive handler.
+ * @param filename input file.
+ *
+ * @return the return code - 0 on success, negative number (< 0) on error.
+ */
 extern int zip_entry_fwrite(struct zip_t *zip, const char *filename);
 
-/*
-  Extracts the current zip entry into output buffer.
-  The function allocates sufficient memory for a output buffer.
-
-  Args:
-    zip: zip archive handler.
-    buf: output buffer.
-    bufsize: output buffer size (in bytes).
-
-  Note:
-    - remember to release memory allocated for a output buffer.
-    - for large entries, please take a look at zip_entry_extract function.
-
-  Returns:
-    The return code - the number of bytes actually read on success.
-    Otherwise a -1 on error.
-*/
+/**
+ * Extracts the current zip entry into output buffer.
+ *
+ * The function allocates sufficient memory for a output buffer.
+ *
+ * @param zip zip archive handler.
+ * @param buf output buffer.
+ * @param bufsize output buffer size (in bytes).
+ *
+ * @note remember to release memory allocated for a output buffer.
+ *       for large entries, please take a look at zip_entry_extract function.
+ *
+ * @return the return code - the number of bytes actually read on success.
+ *         Otherwise a -1 on error.
+ */
 extern ssize_t zip_entry_read(struct zip_t *zip, void **buf, size_t *bufsize);
 
-/*
-  Extracts the current zip entry into a memory buffer using no memory
-  allocation.
+/**
+ * Extracts the current zip entry into a memory buffer using no memory
+ * allocation.
+ *
+ * @param zip zip archive handler.
+ * @param buf preallocated output buffer.
+ * @param bufsize output buffer size (in bytes).
+ *
+ * @note ensure supplied output buffer is large enough.
+ *       zip_entry_size function (returns uncompressed size for the current
+ *       entry) can be handy to estimate how big buffer is needed.
+ *       For large entries, please take a look at zip_entry_extract function.
+ *
+ * @return the return code - the number of bytes actually read on success.
+ *         Otherwise a -1 on error (e.g. bufsize is not large enough).
+ */
+extern ssize_t zip_entry_noallocread(struct zip_t *zip, void *buf,
+                                     size_t bufsize);
 
-  Args:
-    zip: zip archive handler.
-    buf: preallocated output buffer.
-    bufsize: output buffer size (in bytes).
-
-  Note:
-    - ensure supplied output buffer is large enough.
-    - zip_entry_size function (returns uncompressed size for the current entry)
-      can be handy to estimate how big buffer is needed.
-    - for large entries, please take a look at zip_entry_extract function.
-
-  Returns:
-    The return code - the number of bytes actually read on success.
-    Otherwise a -1 on error (e.g. bufsize is not large enough).
-*/
-extern ssize_t zip_entry_noallocread(struct zip_t *zip, void *buf, size_t bufsize);
-
-/*
-  Extracts the current zip entry into output file.
-
-  Args:
-    zip: zip archive handler.
-    filename: output file.
-
-  Returns:
-    The return code - 0 on success, negative number (< 0) on error.
-*/
+/**
+ * Extracts the current zip entry into output file.
+ *
+ * @param zip zip archive handler.
+ * @param filename output file.
+ *
+ * @return the return code - 0 on success, negative number (< 0) on error.
+ */
 extern int zip_entry_fread(struct zip_t *zip, const char *filename);
 
-/*
-  Extracts the current zip entry using a callback function (on_extract).
-
-  Args:
-    zip: zip archive handler.
-    on_extract: callback function.
-    arg: opaque pointer (optional argument,
-                         which you can pass to the on_extract callback)
-
-   Returns:
-    The return code - 0 on success, negative number (< 0) on error.
+/**
+ * Extracts the current zip entry using a callback function (on_extract).
+ *
+ * @param zip zip archive handler.
+ * @param on_extract callback function.
+ * @param arg opaque pointer (optional argument, which you can pass to the
+ *        on_extract callback)
+ *
+ * @return the return code - 0 on success, negative number (< 0) on error.
  */
 extern int
 zip_entry_extract(struct zip_t *zip,
@@ -262,53 +300,112 @@ zip_entry_extract(struct zip_t *zip,
                                        const void *data, size_t size),
                   void *arg);
 
-/*
-  Returns the number of all entries (files and directories) in the zip archive.
+/**
+ * Returns the number of all entries (files and directories) in the zip archive.
+ *
+ * @param zip zip archive handler.
+ *
+ * @return the return code - the number of entries on success, negative number
+ *         (< 0) on error.
+ */
+extern int zip_entries_total(struct zip_t *zip);
 
-  Args:
-    zip: zip archive handler.
+/**
+ * Deletes zip archive entries.
+ *
+ * @param zip zip archive handler.
+ * @param entries array of zip archive entries to be deleted.
+ * @param len the number of entries to be deleted.
+ * @return the number of deleted entries, or negative number (< 0) on error.
+ */
+extern int zip_entries_delete(struct zip_t *zip, char *const entries[],
+                              size_t len);
 
-  Returns:
-    The return code - the number of entries on success,
-    negative number (< 0) on error.
-*/
-extern int zip_total_entries(struct zip_t *zip);
+/**
+ * Extracts a zip archive stream into directory.
+ *
+ * If on_extract is not NULL, the callback will be called after
+ * successfully extracted each zip entry.
+ * Returning a negative value from the callback will cause abort and return an
+ * error. The last argument (void *arg) is optional, which you can use to pass
+ * data to the on_extract callback.
+ *
+ * @param stream zip archive stream.
+ * @param size stream size.
+ * @param dir output directory.
+ * @param on_extract on extract callback.
+ * @param arg opaque pointer.
+ *
+ * @return the return code - 0 on success, negative number (< 0) on error.
+ */
+extern int zip_stream_extract(const char *stream, size_t size, const char *dir,
+                              int (*on_extract)(const char *filename,
+                                                void *arg),
+                              void *arg);
 
-/*
-  Creates a new archive and puts files into a single zip archive.
+/**
+ * Opens zip archive stream into memory.
+ *
+ * @param stream zip archive stream.
+ * @param size stream size.
+ *
+ * @return the zip archive handler or NULL on error
+ */
+extern struct zip_t *zip_stream_open(const char *stream, size_t size, int level,
+                                     char mode);
 
-  Args:
-    zipname: zip archive file.
-    filenames: input files.
-    len: number of input files.
+/**
+ * Copy zip archive stream output buffer.
+ *
+ * @param zip zip archive handler.
+ * @param buf output buffer. User should free buf.
+ * @param bufsize output buffer size (in bytes).
+ *
+ * @return copy size
+ */
+extern ssize_t zip_stream_copy(struct zip_t *zip, void **buf, ssize_t *bufsize);
 
-  Returns:
-    The return code - 0 on success, negative number (< 0) on error.
-*/
+/**
+ * Close zip archive releases resources.
+ *
+ * @param zip zip archive handler.
+ *
+ * @return
+ */
+extern void zip_stream_close(struct zip_t *zip);
+
+/**
+ * Creates a new archive and puts files into a single zip archive.
+ *
+ * @param zipname zip archive file.
+ * @param filenames input files.
+ * @param len: number of input files.
+ *
+ * @return the return code - 0 on success, negative number (< 0) on error.
+ */
 extern int zip_create(const char *zipname, const char *filenames[], size_t len);
 
-/*
-  Extracts a zip archive file into directory.
-
-  If on_extract_entry is not NULL, the callback will be called after
-  successfully extracted each zip entry.
-  Returning a negative value from the callback will cause abort and return an
-  error. The last argument (void *arg) is optional, which you can use to pass
-  data to the on_extract_entry callback.
-
-  Args:
-    zipname: zip archive file.
-    dir: output directory.
-    on_extract_entry: on extract callback.
-    arg: opaque pointer.
-
-  Returns:
-    The return code - 0 on success, negative number (< 0) on error.
-*/
+/**
+ * Extracts a zip archive file into directory.
+ *
+ * If on_extract_entry is not NULL, the callback will be called after
+ * successfully extracted each zip entry.
+ * Returning a negative value from the callback will cause abort and return an
+ * error. The last argument (void *arg) is optional, which you can use to pass
+ * data to the on_extract_entry callback.
+ *
+ * @param zipname zip archive file.
+ * @param dir output directory.
+ * @param on_extract_entry on extract callback.
+ * @param arg opaque pointer.
+ *
+ * @return the return code - 0 on success, negative number (< 0) on error.
+ */
 extern int zip_extract(const char *zipname, const char *dir,
                        int (*on_extract_entry)(const char *filename, void *arg),
                        void *arg);
 
+/** @} */
 #ifdef __cplusplus
 }
 #endif
diff --git a/Engine/lib/assimp/contrib/zip/test/CMakeLists.txt b/Engine/lib/assimp/contrib/zip/test/CMakeLists.txt
index 9b2a8db10..0da1684d4 100644
--- a/Engine/lib/assimp/contrib/zip/test/CMakeLists.txt
+++ b/Engine/lib/assimp/contrib/zip/test/CMakeLists.txt
@@ -1,19 +1,38 @@
-cmake_minimum_required(VERSION 2.8)
+cmake_minimum_required(VERSION 3.4)
 
-if ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU" OR "${CMAKE_C_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_C_COMPILER_ID}" STREQUAL "AppleClang")
-  if(ENABLE_COVERAGE)
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g ")
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O0")
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fprofile-arcs")
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ftest-coverage")
-    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage")
-  endif()
-endif ()
+# tests
+set(test_write_out test_write.out)
+add_executable(${test_write_out} test_write.c)
+target_link_libraries(${test_write_out} zip)
+add_test(NAME ${test_write_out} COMMAND ${test_write_out})
+set(test_write_out ${test_write_out} PARENT_SCOPE)
 
-# test
-include_directories(../src)
-add_executable(test.exe test.c ../src/zip.c)
-add_executable(test_miniz.exe test_miniz.c)
+set(test_append_out test_append.out)
+add_executable(${test_append_out} test_append.c)
+target_link_libraries(${test_append_out} zip)
+add_test(NAME ${test_append_out} COMMAND ${test_append_out})
+set(test_append_out ${test_append_out} PARENT_SCOPE)
 
-add_test(NAME test COMMAND test.exe)
-add_test(NAME test_miniz COMMAND test_miniz.exe)
+set(test_read_out test_read.out)
+add_executable(${test_read_out} test_read.c)
+target_link_libraries(${test_read_out} zip)
+add_test(NAME ${test_read_out} COMMAND ${test_read_out})
+set(test_read_out ${test_read_out} PARENT_SCOPE)
+
+set(test_extract_out test_extract.out)
+add_executable(${test_extract_out} test_extract.c)
+target_link_libraries(${test_extract_out} zip)
+add_test(NAME ${test_extract_out} COMMAND ${test_extract_out})
+set(test_extract_out ${test_extract_out} PARENT_SCOPE)
+
+set(test_entry_out test_entry.out)
+add_executable(${test_entry_out} test_entry.c)
+target_link_libraries(${test_entry_out} zip)
+add_test(NAME ${test_entry_out} COMMAND ${test_entry_out})
+set(test_entry_out ${test_entry_out} PARENT_SCOPE)
+
+set(test_permissions_out test_permissions.out)
+add_executable(${test_permissions_out} test_permissions.c)
+target_link_libraries(${test_permissions_out} zip)
+add_test(NAME ${test_permissions_out} COMMAND ${test_permissions_out})
+set(test_permissions_out ${test_permissions_out} PARENT_SCOPE)
diff --git a/Engine/lib/assimp/contrib/zip/test/test.c b/Engine/lib/assimp/contrib/zip/test/test.c
index 454430533..9cc2248ac 100644
--- a/Engine/lib/assimp/contrib/zip/test/test.c
+++ b/Engine/lib/assimp/contrib/zip/test/test.c
@@ -29,6 +29,8 @@
 #define XFILE "7.txt\0"
 #define XMODE 0100777
 
+#define UNIXMODE 0100644
+
 #define UNUSED(x) (void)x
 
 static int total_entries = 0;
@@ -45,7 +47,7 @@ static void test_write(void) {
   assert(CRC32DATA1 == zip_entry_crc32(zip));
   ++total_entries;
   assert(0 == zip_entry_close(zip));
-
+  assert(0 == zip_is64(zip));
   zip_close(zip);
 }
 
@@ -90,6 +92,7 @@ static void test_read(void) {
   size_t buftmp;
   struct zip_t *zip = zip_open(ZIPNAME, 0, 'r');
   assert(zip != NULL);
+  assert(0 == zip_is64(zip));
 
   assert(0 == zip_entry_open(zip, "test\\test-1.txt"));
   assert(strlen(TESTDATA1) == zip_entry_size(zip));
@@ -102,7 +105,8 @@ static void test_read(void) {
   assert(0 == zip_entry_close(zip));
   free(buf);
   buf = NULL;
-  
+  bufsize = 0;
+
   assert(0 == zip_entry_open(zip, "test/test-2.txt"));
   assert(strlen(TESTDATA2) == zip_entry_size(zip));
   assert(CRC32DATA2 == zip_entry_crc32(zip));
@@ -131,7 +135,8 @@ static void test_read(void) {
   assert(0 == zip_entry_close(zip));
   free(buf);
   buf = NULL;
-  
+  bufsize = 0;
+
   buftmp = strlen(TESTDATA1);
   buf = calloc(buftmp, sizeof(char));
   assert(0 == zip_entry_open(zip, "test/test-1.txt"));
@@ -306,6 +311,7 @@ static void test_fwrite(void) {
   assert(0 == zip_entry_open(zip, WFILE));
   assert(0 == zip_entry_fwrite(zip, WFILE));
   assert(0 == zip_entry_close(zip));
+  assert(0 == zip_is64(zip));
 
   zip_close(zip);
   remove(WFILE);
@@ -433,6 +439,35 @@ static void test_mtime(void) {
   remove(ZIPNAME);
 }
 
+static void test_unix_permissions(void) {
+#if defined(_WIN64) || defined(_WIN32) || defined(__WIN32__)
+#else
+  // UNIX or APPLE
+  struct MZ_FILE_STAT_STRUCT file_stats;
+
+  remove(ZIPNAME);
+
+  struct zip_t *zip = zip_open(ZIPNAME, ZIP_DEFAULT_COMPRESSION_LEVEL, 'w');
+  assert(zip != NULL);
+
+  assert(0 == zip_entry_open(zip, RFILE));
+  assert(0 == zip_entry_write(zip, TESTDATA1, strlen(TESTDATA1)));
+  assert(0 == zip_entry_close(zip));
+
+  zip_close(zip);
+
+  remove(RFILE);
+
+  assert(0 == zip_extract(ZIPNAME, ".", NULL, NULL));
+
+  assert(0 == MZ_FILE_STAT(RFILE, &file_stats));
+  assert(UNIXMODE == file_stats.st_mode);
+
+  remove(RFILE);
+  remove(ZIPNAME);
+#endif
+}
+
 int main(int argc, char *argv[]) {
   UNUSED(argc);
   UNUSED(argv);
@@ -453,6 +488,7 @@ int main(int argc, char *argv[]) {
   test_write_permissions();
   test_exe_permissions();
   test_mtime();
+  test_unix_permissions();
 
   remove(ZIPNAME);
   return 0;
diff --git a/Engine/lib/assimp/contrib/zip/test/test_miniz.c b/Engine/lib/assimp/contrib/zip/test/test_miniz.c
index ebc0564dc..babcaecdb 100644
--- a/Engine/lib/assimp/contrib/zip/test/test_miniz.c
+++ b/Engine/lib/assimp/contrib/zip/test/test_miniz.c
@@ -23,16 +23,39 @@ int main(int argc, char *argv[]) {
   uint step = 0;
   int cmp_status;
   uLong src_len = (uLong)strlen(s_pStr);
-  uLong cmp_len = compressBound(src_len);
   uLong uncomp_len = src_len;
+  uLong cmp_len;
   uint8 *pCmp, *pUncomp;
+  size_t sz;
   uint total_succeeded = 0;
   (void)argc, (void)argv;
 
   printf("miniz.c version: %s\n", MZ_VERSION);
 
   do {
+    pCmp = (uint8 *)tdefl_compress_mem_to_heap(s_pStr, src_len, &cmp_len, 0);
+    if (!pCmp) {
+      printf("tdefl_compress_mem_to_heap failed\n");
+      return EXIT_FAILURE;
+    }
+    if (src_len <= cmp_len) {
+      printf("tdefl_compress_mem_to_heap failed: from %u to %u bytes\n",
+             (mz_uint32)uncomp_len, (mz_uint32)cmp_len);
+      free(pCmp);
+      return EXIT_FAILURE;
+    }
+
+    sz = tdefl_compress_mem_to_mem(pCmp, cmp_len, s_pStr, src_len, 0);
+    if (sz != cmp_len) {
+      printf("tdefl_compress_mem_to_mem failed: expected %u, got %u\n",
+             (mz_uint32)cmp_len, (mz_uint32)sz);
+      free(pCmp);
+      return EXIT_FAILURE;
+    }
+
     // Allocate buffers to hold compressed and uncompressed data.
+    free(pCmp);
+    cmp_len = compressBound(src_len);
     pCmp = (mz_uint8 *)malloc((size_t)cmp_len);
     pUncomp = (mz_uint8 *)malloc((size_t)src_len);
     if ((!pCmp) || (!pUncomp)) {
diff --git a/Engine/lib/assimp/contrib/zlib/CMakeLists.txt b/Engine/lib/assimp/contrib/zlib/CMakeLists.txt
index 9d1fcc943..469151ff6 100644
--- a/Engine/lib/assimp/contrib/zlib/CMakeLists.txt
+++ b/Engine/lib/assimp/contrib/zlib/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 2.4.4)
+cmake_minimum_required(VERSION 3.10.0)
 set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS ON)
 
 # CMake 3.0 changed the project command, setting policy CMP0048 reverts to the old behaviour.
@@ -72,6 +72,7 @@ endif()
 check_include_file(unistd.h Z_HAVE_UNISTD_H)
 
 if(MSVC)
+    SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4131 /wd4127 /wd4244")
     set(CMAKE_DEBUG_POSTFIX "d")
     add_definitions(-D_CRT_SECURE_NO_DEPRECATE)
     add_definitions(-D_CRT_NONSTDC_NO_DEPRECATE)
@@ -195,13 +196,11 @@ if(MINGW)
     set(ZLIB_DLL_SRCS ${CMAKE_CURRENT_BINARY_DIR}/zlib1rc.obj)
 endif(MINGW)
 
-add_library(zlib SHARED ${ZLIB_SRCS} ${ZLIB_ASMS} ${ZLIB_DLL_SRCS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS})
 add_library(zlibstatic STATIC ${ZLIB_SRCS} ${ZLIB_ASMS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS})
-set_target_properties(zlib PROPERTIES DEFINE_SYMBOL ZLIB_DLL)
-set_target_properties(zlib PROPERTIES SOVERSION 1)
 
 INSTALL( TARGETS zlibstatic
-         LIBRARY DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
-         ARCHIVE DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
-         RUNTIME DESTINATION ${ASSIMP_BIN_INSTALL_DIR}
-         COMPONENT ${LIBASSIMP_COMPONENT})
+     EXPORT "${TARGETS_EXPORT_NAME}"
+     LIBRARY DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
+     ARCHIVE DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
+     RUNTIME DESTINATION ${ASSIMP_BIN_INSTALL_DIR}
+     COMPONENT ${LIBASSIMP_COMPONENT})
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/blast/test.txt b/Engine/lib/assimp/contrib/zlib/contrib/blast/test.txt
index bfdf1c5dc..159002de5 100644
--- a/Engine/lib/assimp/contrib/zlib/contrib/blast/test.txt
+++ b/Engine/lib/assimp/contrib/zlib/contrib/blast/test.txt
@@ -1 +1 @@
-AIAIAIAIAIAIA
\ No newline at end of file
+AIAIAIAIAIAIA
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/LICENSE_1_0.txt b/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/LICENSE_1_0.txt
index 127a5bc39..36b7cd93c 100644
--- a/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/LICENSE_1_0.txt
+++ b/Engine/lib/assimp/contrib/zlib/contrib/dotzlib/LICENSE_1_0.txt
@@ -20,4 +20,4 @@ FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
 SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
 FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
\ No newline at end of file
+DEALINGS IN THE SOFTWARE.
diff --git a/Engine/lib/assimp/contrib/zlib/contrib/testzlib/testzlib.txt b/Engine/lib/assimp/contrib/zlib/contrib/testzlib/testzlib.txt
index e508bb22f..ba1bb3db6 100644
--- a/Engine/lib/assimp/contrib/zlib/contrib/testzlib/testzlib.txt
+++ b/Engine/lib/assimp/contrib/zlib/contrib/testzlib/testzlib.txt
@@ -7,4 +7,4 @@ copy to a directory file from :
 - contrib/masmx64
 - contrib/vstudio/vc7
 
-and open testzlib8.sln
\ No newline at end of file
+and open testzlib8.sln
diff --git a/Engine/lib/assimp/contrib/zlib_note.txt b/Engine/lib/assimp/contrib/zlib_note.txt
index cc274f0bf..a7ca98634 100644
--- a/Engine/lib/assimp/contrib/zlib_note.txt
+++ b/Engine/lib/assimp/contrib/zlib_note.txt
@@ -8,4 +8,4 @@ This is a heavily modified and shrinked version of zlib 1.2.3
 
 Assimp itself does not use the compression part yet, so
 it needn't be compiled (trees.c, deflate.c, compress.c).
-Currently these units are just used by assimp_cmd.
\ No newline at end of file
+Currently these units are just used by assimp_cmd.
diff --git a/Engine/lib/assimp/include/assimp/Base64.hpp b/Engine/lib/assimp/include/assimp/Base64.hpp
new file mode 100644
index 000000000..ee319aceb
--- /dev/null
+++ b/Engine/lib/assimp/include/assimp/Base64.hpp
@@ -0,0 +1,68 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+#pragma once
+#ifndef AI_BASE64_HPP_INC
+#define AI_BASE64_HPP_INC
+
+#include <stdint.h>
+#include <vector>
+#include <string>
+
+namespace Assimp {
+namespace Base64 {
+
+/// @brief Will encode the given 
+/// @param in 
+/// @param inLength 
+/// @param out 
+void Encode(const uint8_t *in, size_t inLength, std::string &out);
+void Encode(const std::vector<uint8_t>& in, std::string &out);
+std::string Encode(const std::vector<uint8_t>& in);
+
+size_t Decode(const char *in, size_t inLength, uint8_t *&out);
+size_t Decode(const std::string& in, std::vector<uint8_t>& out);
+std::vector<uint8_t> Decode(const std::string& in);
+
+} // namespace Base64
+} // namespace Assimp
+
+#endif // AI_BASE64_HPP_INC
diff --git a/Engine/lib/assimp/include/assimp/BaseImporter.h b/Engine/lib/assimp/include/assimp/BaseImporter.h
index 55f7fe375..5a3c764d4 100644
--- a/Engine/lib/assimp/include/assimp/BaseImporter.h
+++ b/Engine/lib/assimp/include/assimp/BaseImporter.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -40,23 +39,28 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
-/** @file Definition of the base class for all importer worker classes. */
+/// @file Definition of the base class for all importer worker classes.
+
+#pragma once
 #ifndef INCLUDED_AI_BASEIMPORTER_H
 #define INCLUDED_AI_BASEIMPORTER_H
 
+#ifdef __GNUC__
+#pragma GCC system_header
+#endif
+
 #include "Exceptional.h"
 
-#include <vector>
-#include <set>
-#include <map>
 #include <assimp/types.h>
 #include <assimp/ProgressHandler.hpp>
-#include <assimp/ai_assert.h>
+#include <set>
+#include <vector>
+#include <memory>
 
 struct aiScene;
 struct aiImporterDesc;
 
-namespace Assimp    {
+namespace Assimp {
 
 class Importer;
 class IOSystem;
@@ -66,8 +70,7 @@ class IOStream;
 
 // utility to do char4 to uint32 in a portable manner
 #define AI_MAKE_MAGIC(string) ((uint32_t)((string[0] << 24) + \
-    (string[1] << 16) + (string[2] << 8) + string[3]))
-
+                                          (string[1] << 16) + (string[2] << 8) + string[3]))
 
 // ---------------------------------------------------------------------------
 /** FOR IMPORTER PLUGINS ONLY: The BaseImporter defines a common interface
@@ -82,12 +85,7 @@ class IOStream;
 class ASSIMP_API BaseImporter {
     friend class Importer;
 
-private:
-    /* Pushes state into importer for the importer scale */
-    virtual void UpdateImporterScale( Importer* pImp );
-
 public:
-
     /** Constructor to be privately used by #Importer */
     BaseImporter() AI_NO_EXCEPT;
 
@@ -97,38 +95,32 @@ public:
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
      *
-     * The implementation should be as quick as possible. A check for
-     * the file extension is enough. If no suitable loader is found with
-     * this strategy, CanRead() is called again, the 'checkSig' parameter
-     * set to true this time. Now the implementation is expected to
-     * perform a full check of the file structure, possibly searching the
-     * first bytes of the file for magic identifiers or keywords.
+     * The implementation is expected to perform a full check of the file
+     * structure, possibly searching the first bytes of the file for magic
+     * identifiers or keywords.
      *
      * @param pFile Path and file name of the file to be examined.
      * @param pIOHandler The IO handler to use for accessing any file.
-     * @param checkSig Set to true if this method is called a second time.
-     *   This time, the implementation may take more time to examine the
-     *   contents of the file to be loaded for magic bytes, keywords, etc
-     *   to be able to load files with unknown/not existent file extensions.
-     * @return true if the class can read this file, false if not.
+     * @param checkSig Legacy; do not use.
+     * @return true if the class can read this file, false if not or if
+     * unsure.
      */
     virtual bool CanRead(
-        const std::string& pFile,
-        IOSystem* pIOHandler,
-        bool checkSig
-        ) const = 0;
+            const std::string &pFile,
+            IOSystem *pIOHandler,
+            bool checkSig) const = 0;
 
     // -------------------------------------------------------------------
     /** Imports the given file and returns the imported data.
      * If the import succeeds, ownership of the data is transferred to
-     * the caller. If the import fails, NULL is returned. The function
+     * the caller. If the import fails, nullptr is returned. The function
      * takes care that any partially constructed data is destroyed
      * beforehand.
      *
      * @param pImp #Importer object hosting this loader.
      * @param pFile Path of the file to be imported.
      * @param pIOHandler IO-Handler used to open this and possible other files.
-     * @return The imported data or NULL if failed. If it failed a
+     * @return The imported data or nullptr if failed. If it failed a
      * human-readable error description can be retrieved by calling
      * GetErrorText()
      *
@@ -137,21 +129,32 @@ public:
      * in InternReadFile(), this function will catch it and transform it into
      *  a suitable response to the caller.
      */
-    aiScene* ReadFile(
-        Importer* pImp,
-        const std::string& pFile,
-        IOSystem* pIOHandler
-        );
+    aiScene *ReadFile(
+            Importer *pImp,
+            const std::string &pFile,
+            IOSystem *pIOHandler);
 
     // -------------------------------------------------------------------
     /** Returns the error description of the last error that occurred.
+     * If the error is due to a std::exception, this will return the message.
+     * Exceptions can also be accessed with GetException().
      * @return A description of the last error that occurred. An empty
      * string if there was no error.
      */
-    const std::string& GetErrorText() const {
+    const std::string &GetErrorText() const {
         return m_ErrorText;
     }
 
+    // -------------------------------------------------------------------
+    /** Returns the exception of the last exception that occurred.
+     * Note: Exceptions are not the only source of error details, so GetErrorText
+     * should be consulted too.
+     * @return The last exception that occurred.
+     */
+    const std::exception_ptr& GetException() const {
+        return m_Exception;
+    }
+
     // -------------------------------------------------------------------
     /** Called prior to ReadFile().
      * The function is a request to the importer to update its configuration
@@ -159,74 +162,31 @@ public:
      * @param pImp Importer instance
      */
     virtual void SetupProperties(
-        const Importer* pImp
-        );
+            const Importer *pImp);
 
     // -------------------------------------------------------------------
     /** Called by #Importer::GetImporterInfo to get a description of
      *  some loader features. Importers must provide this information. */
-    virtual const aiImporterDesc* GetInfo() const = 0;
+    virtual const aiImporterDesc *GetInfo() const = 0;
 
     /**
      * Will be called only by scale process when scaling is requested.
      */
-    virtual void SetFileScale(double scale)
-    {
+    void SetFileScale(double scale) {
         fileScale = scale;
     }
 
-    virtual double GetFileScale() const
-    {
-        return fileScale;
-    }
-
-    enum ImporterUnits {
-        M,
-        MM,
-        CM,
-        INCHES,
-        FEET
-    };
-
-    /**
-     * Assimp Importer
-     * unit conversions available 
-     * if you need another measurment unit add it below.
-     * it's currently defined in assimp that we prefer meters.
-     * */
-    std::map<ImporterUnits, double> importerUnits = {
-        {ImporterUnits::M, 1},
-        {ImporterUnits::CM, 0.01},
-        {ImporterUnits::MM, 0.001},
-        {ImporterUnits::INCHES, 0.0254},
-        {ImporterUnits::FEET, 0.3048}
-    };
-
-    virtual void SetApplicationUnits( const ImporterUnits& unit )
-    {
-        importerScale = importerUnits[unit];
-        applicationUnits = unit;
-    }
-
-    virtual const ImporterUnits& GetApplicationUnits()
-    {
-        return applicationUnits;
-    }
-
     // -------------------------------------------------------------------
     /** Called by #Importer::GetExtensionList for each loaded importer.
      *  Take the extension list contained in the structure returned by
      *  #GetInfo and insert all file extensions into the given set.
      *  @param extension set to collect file extensions in*/
-    void GetExtensionList(std::set<std::string>& extensions);
-    
-protected:    
-    ImporterUnits applicationUnits = ImporterUnits::M;
+    void GetExtensionList(std::set<std::string> &extensions);
+
+protected:
     double importerScale = 1.0;
     double fileScale = 1.0;
 
-
-
     // -------------------------------------------------------------------
     /** Imports the given file into the given scene structure. The
      * function is expected to throw an ImportErrorException if there is
@@ -247,7 +207,7 @@ protected:
      * <li>aiAnimation::mDuration may be -1. Assimp determines the length
      *   of the animation automatically in this case as the length of
      *   the longest animation channel.</li>
-     * <li>aiMesh::mBitangents may be NULL if tangents and normals are
+     * <li>aiMesh::mBitangents may be nullptr if tangents and normals are
      *   given. In this case bitangents are computed as the cross product
      *   between normal and tangent.</li>
      * <li>There needn't be a material. If none is there a default material
@@ -268,17 +228,15 @@ protected:
      *
      * @param pFile Path of the file to be imported.
      * @param pScene The scene object to hold the imported data.
-     * NULL is not a valid parameter.
+     * nullptr is not a valid parameter.
      * @param pIOHandler The IO handler to use for any file access.
-     * NULL is not a valid parameter. */
+     * nullptr is not a valid parameter. */
     virtual void InternReadFile(
-        const std::string& pFile,
-        aiScene* pScene,
-        IOSystem* pIOHandler
-        ) = 0;
+            const std::string &pFile,
+            aiScene *pScene,
+            IOSystem *pIOHandler) = 0;
 
 public: // static utilities
-
     // -------------------------------------------------------------------
     /** A utility for CanRead().
      *
@@ -294,13 +252,13 @@ public: // static utilities
      *  @param searchBytes Number of bytes to be searched for the tokens.
      */
     static bool SearchFileHeaderForToken(
-        IOSystem* pIOSystem,
-        const std::string&  file,
-        const char** tokens,
-        unsigned int numTokens,
-        unsigned int searchBytes = 200,
-        bool tokensSol = false,
-        bool noAlphaBeforeTokens = false);
+            IOSystem *pIOSystem,
+            const std::string &file,
+            const char **tokens,
+            std::size_t numTokens,
+            unsigned int searchBytes = 200,
+            bool tokensSol = false,
+            bool noAlphaBeforeTokens = false);
 
     // -------------------------------------------------------------------
     /** @brief Check whether a file has a specific file extension
@@ -310,19 +268,19 @@ public: // static utilities
      *  @param ext2 Optional third extension
      *  @note Case-insensitive
      */
-    static bool SimpleExtensionCheck (
-        const std::string& pFile,
-        const char* ext0,
-        const char* ext1 = NULL,
-        const char* ext2 = NULL);
+    static bool SimpleExtensionCheck(
+            const std::string &pFile,
+            const char *ext0,
+            const char *ext1 = nullptr,
+            const char *ext2 = nullptr);
 
     // -------------------------------------------------------------------
     /** @brief Extract file extension from a string
      *  @param pFile Input file
      *  @return Extension without trailing dot, all lowercase
      */
-    static std::string GetExtension (
-        const std::string& pFile);
+    static std::string GetExtension(
+            const std::string &pFile);
 
     // -------------------------------------------------------------------
     /** @brief Check whether a file starts with one or more magic tokens
@@ -339,12 +297,12 @@ public: // static utilities
      *  tokens of size 2,4.
      */
     static bool CheckMagicToken(
-        IOSystem* pIOHandler,
-        const std::string& pFile,
-        const void* magic,
-        unsigned int num,
-        unsigned int offset = 0,
-        unsigned int size   = 4);
+            IOSystem *pIOHandler,
+            const std::string &pFile,
+            const void *magic,
+            std::size_t num,
+            unsigned int offset = 0,
+            unsigned int size = 4);
 
     // -------------------------------------------------------------------
     /** An utility for all text file loaders. It converts a file to our
@@ -353,7 +311,7 @@ public: // static utilities
      *  @param data File buffer to be converted to UTF8 data. The buffer
      *  is resized as appropriate. */
     static void ConvertToUTF8(
-        std::vector<char>& data);
+            std::vector<char> &data);
 
     // -------------------------------------------------------------------
     /** An utility for all text file loaders. It converts a file from our
@@ -362,13 +320,13 @@ public: // static utilities
      *  @param data File buffer to be converted from UTF8 to ISO-8859-1. The buffer
      *  is resized as appropriate. */
     static void ConvertUTF8toISO8859_1(
-        std::string& data);
+            std::string &data);
 
     // -------------------------------------------------------------------
     /// @brief  Enum to define, if empty files are ok or not.
-    enum TextFileMode { 
+    enum TextFileMode {
         ALLOW_EMPTY,
-        FORBID_EMPTY 
+        FORBID_EMPTY
     };
 
     // -------------------------------------------------------------------
@@ -381,22 +339,20 @@ public: // static utilities
      *   a binary 0.
      *  @param mode Whether it is OK to load empty text files. */
     static void TextFileToBuffer(
-        IOStream* stream,
-        std::vector<char>& data,
-        TextFileMode mode = FORBID_EMPTY);
+            IOStream *stream,
+            std::vector<char> &data,
+            TextFileMode mode = FORBID_EMPTY);
 
     // -------------------------------------------------------------------
     /** Utility function to move a std::vector into a aiScene array
     *  @param vec The vector to be moved
     *  @param out The output pointer to the allocated array.
     *  @param numOut The output count of elements copied. */
-    template<typename T>
-    AI_FORCE_INLINE
-    static void CopyVector(
-        std::vector<T>& vec,
-        T*& out,
-        unsigned int& outLength)
-    {
+    template <typename T>
+    AI_FORCE_INLINE static void CopyVector(
+            std::vector<T> &vec,
+            T *&out,
+            unsigned int &outLength) {
         outLength = unsigned(vec.size());
         if (outLength) {
             out = new T[outLength];
@@ -404,15 +360,37 @@ public: // static utilities
         }
     }
 
+    // -------------------------------------------------------------------
+    /** Utility function to move a std::vector of unique_ptrs into a aiScene array
+    *  @param vec The vector of unique_ptrs to be moved
+    *  @param out The output pointer to the allocated array.
+    *  @param numOut The output count of elements copied. */
+    template <typename T>
+    AI_FORCE_INLINE static void CopyVector(
+            std::vector<std::unique_ptr<T> > &vec,
+            T **&out,
+            unsigned int &outLength) {
+        outLength = unsigned(vec.size());
+        if (outLength) {
+            out = new T*[outLength];
+            T** outPtr = out;
+            std::for_each(vec.begin(), vec.end(), [&outPtr](std::unique_ptr<T>& uPtr){*outPtr = uPtr.release(); ++outPtr; });
+        }
+    }
+
+private:
+    /* Pushes state into importer for the importer scale */
+    void UpdateImporterScale(Importer *pImp);
+
 protected:
     /// Error description in case there was one.
     std::string m_ErrorText;
+    /// The exception, in case there was one.
+    std::exception_ptr m_Exception;
     /// Currently set progress handler.
-    ProgressHandler* m_progress;
+    ProgressHandler *m_progress;
 };
 
-
-
 } // end of namespace Assimp
 
 #endif // AI_BASEIMPORTER_H_INC
diff --git a/Engine/lib/assimp/include/assimp/Bitmap.h b/Engine/lib/assimp/include/assimp/Bitmap.h
index e6b5fb132..6a614f7cf 100644
--- a/Engine/lib/assimp/include/assimp/Bitmap.h
+++ b/Engine/lib/assimp/include/assimp/Bitmap.h
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -46,12 +44,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * Used for file formats which embed their textures into the model file.
  */
-
+#pragma once
 #ifndef AI_BITMAP_H_INC
 #define AI_BITMAP_H_INC
 
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
 #include "defs.h"
-#include <stdint.h>
+#include <cstdint>
 #include <cstddef>
 
 struct aiTexture;
@@ -60,6 +62,10 @@ namespace Assimp {
 
 class IOStream;
 
+// ---------------------------------------------------------------------------
+/** 
+ *  This class is used to store and write bitmap information.
+ */
 class ASSIMP_API Bitmap {
 protected:
 
@@ -71,13 +77,12 @@ protected:
         uint32_t offset;
 
         // We define the struct size because sizeof(Header) might return a wrong result because of structure padding.
-        // Moreover, we must use this ugly and error prone syntax because Visual Studio neither support constexpr or sizeof(name_of_field).
-        static const std::size_t header_size =
-            sizeof(uint16_t) + // type
-            sizeof(uint32_t) + // size
-            sizeof(uint16_t) + // reserved1
-            sizeof(uint16_t) + // reserved2
-            sizeof(uint32_t);  // offset
+        static constexpr std::size_t header_size =
+            sizeof(type) +
+            sizeof(size) +
+            sizeof(reserved1) +
+            sizeof(reserved2) +
+            sizeof(offset);
     };
 
     struct DIB {
@@ -94,25 +99,28 @@ protected:
         uint32_t nb_important_colors;
 
         // We define the struct size because sizeof(DIB) might return a wrong result because of structure padding.
-        // Moreover, we must use this ugly and error prone syntax because Visual Studio neither support constexpr or sizeof(name_of_field).
-        static const std::size_t dib_size =
-            sizeof(uint32_t) + // size
-            sizeof(int32_t) +  // width
-            sizeof(int32_t) +  // height
-            sizeof(uint16_t) + // planes
-            sizeof(uint16_t) + // bits_per_pixel
-            sizeof(uint32_t) + // compression
-            sizeof(uint32_t) + // image_size
-            sizeof(int32_t) +  // x_resolution
-            sizeof(int32_t) +  // y_resolution
-            sizeof(uint32_t) + // nb_colors
-            sizeof(uint32_t);  // nb_important_colors
+        static constexpr std::size_t dib_size =
+            sizeof(size) +
+            sizeof(width) +
+            sizeof(height) +
+            sizeof(planes) +
+            sizeof(bits_per_pixel) +
+            sizeof(compression) +
+            sizeof(image_size) +
+            sizeof(x_resolution) +
+            sizeof(y_resolution) +
+            sizeof(nb_colors) +
+            sizeof(nb_important_colors);
     };
 
-    static const std::size_t mBytesPerPixel = 4;
+    static constexpr std::size_t mBytesPerPixel = 4;
 
 public:
-    static void Save(aiTexture* texture, IOStream* file);
+    /// @brief  Will save an aiTexture instance as a bitmap.
+    /// @param texture  The pointer to the texture instance
+    /// @param file     The filename to save into.
+    /// @return true if successfully saved, false if not.
+    static bool Save(aiTexture* texture, IOStream* file);
 
 protected:
     static void WriteHeader(Header& header, IOStream* file);
diff --git a/Engine/lib/assimp/include/assimp/BlobIOSystem.h b/Engine/lib/assimp/include/assimp/BlobIOSystem.h
index d005e5c11..7e8d46a53 100644
--- a/Engine/lib/assimp/include/assimp/BlobIOSystem.h
+++ b/Engine/lib/assimp/include/assimp/BlobIOSystem.h
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -44,152 +42,138 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Provides cheat implementations for IOSystem and IOStream to
  *  redirect exporter output to a blob chain.*/
 
+#pragma once
 #ifndef AI_BLOBIOSYSTEM_H_INCLUDED
 #define AI_BLOBIOSYSTEM_H_INCLUDED
 
-#include <assimp/IOStream.hpp>
+#ifdef __GNUC__
+#pragma GCC system_header
+#endif
+
 #include <assimp/cexport.h>
-#include <assimp/IOSystem.hpp>
 #include <assimp/DefaultLogger.hpp>
-#include <stdint.h>
+#include <assimp/IOStream.hpp>
+#include <assimp/IOSystem.hpp>
+#include <cstdint>
 #include <set>
 #include <vector>
 
-namespace Assimp    {
-    class BlobIOSystem;
+namespace Assimp {
+class BlobIOSystem;
 
 // --------------------------------------------------------------------------------------------
 /** Redirect IOStream to a blob */
 // --------------------------------------------------------------------------------------------
-class BlobIOStream : public IOStream
-{
+class BlobIOStream : public IOStream {
 public:
-
-    BlobIOStream(BlobIOSystem* creator, const std::string& file, size_t initial = 4096)
-        : buffer()
-        , cur_size()
-        , file_size()
-        , cursor()
-        , initial(initial)
-        , file(file)
-        , creator(creator)
-    {
+    /// @brief The class constructor with all needed parameters
+    /// @param creator  Pointer to the creator instance
+    /// @param file     The filename
+    /// @param initial  The initial size
+    BlobIOStream(BlobIOSystem *creator, const std::string &file, size_t initial = 4096) :
+            buffer(),
+            cur_size(),
+            file_size(),
+            cursor(),
+            initial(initial),
+            file(file),
+            creator(creator) {
+        // empty
     }
 
-
-    virtual ~BlobIOStream();
+    ///	@brief  The class destructor.
+    ~BlobIOStream() override;
 
 public:
-
     // -------------------------------------------------------------------
-    aiExportDataBlob* GetBlob()
-    {
-        aiExportDataBlob* blob = new aiExportDataBlob();
+    aiExportDataBlob *GetBlob() {
+        aiExportDataBlob *blob = new aiExportDataBlob();
         blob->size = file_size;
         blob->data = buffer;
 
-        buffer = NULL;
+        buffer = nullptr;
 
         return blob;
     }
 
-
-public:
-
-
     // -------------------------------------------------------------------
-    virtual size_t Read( void *,
-        size_t,
-        size_t )
-    {
+    size_t Read(void *, size_t, size_t) override {
         return 0;
     }
 
     // -------------------------------------------------------------------
-    virtual size_t Write(const void* pvBuffer,
-        size_t pSize,
-        size_t pCount)
-    {
+    size_t Write(const void *pvBuffer, size_t pSize, size_t pCount) override {
         pSize *= pCount;
         if (cursor + pSize > cur_size) {
             Grow(cursor + pSize);
         }
 
-        memcpy(buffer+cursor, pvBuffer, pSize);
+        memcpy(buffer + cursor, pvBuffer, pSize);
         cursor += pSize;
 
-        file_size = std::max(file_size,cursor);
+        file_size = std::max(file_size, cursor);
         return pCount;
     }
 
     // -------------------------------------------------------------------
-    virtual aiReturn Seek(size_t pOffset,
-        aiOrigin pOrigin)
-    {
-        switch(pOrigin)
-        {
-        case aiOrigin_CUR:
-            cursor += pOffset;
-            break;
+    aiReturn Seek(size_t pOffset, aiOrigin pOrigin) override {
+        switch (pOrigin) {
+            case aiOrigin_CUR:
+                cursor += pOffset;
+                break;
 
-        case aiOrigin_END:
-            cursor = file_size - pOffset;
-            break;
+            case aiOrigin_END:
+                cursor = file_size - pOffset;
+                break;
 
-        case aiOrigin_SET:
-            cursor = pOffset;
-            break;
+            case aiOrigin_SET:
+                cursor = pOffset;
+                break;
 
-        default:
-            return AI_FAILURE;
+            default:
+                return AI_FAILURE;
         }
 
         if (cursor > file_size) {
             Grow(cursor);
         }
 
-        file_size = std::max(cursor,file_size);
+        file_size = std::max(cursor, file_size);
+
         return AI_SUCCESS;
     }
 
     // -------------------------------------------------------------------
-    virtual size_t Tell() const
-    {
+    size_t Tell() const override {
         return cursor;
     }
 
     // -------------------------------------------------------------------
-    virtual size_t FileSize() const
-    {
+    size_t FileSize() const override {
         return file_size;
     }
 
     // -------------------------------------------------------------------
-    virtual void Flush()
-    {
+    void Flush() override {
         // ignore
     }
 
-
-
 private:
-
     // -------------------------------------------------------------------
-    void Grow(size_t need = 0)
-    {
+    void Grow(size_t need = 0) {
         // 1.5 and phi are very heap-friendly growth factors (the first
         // allows for frequent re-use of heap blocks, the second
         // forms a fibonacci sequence with similar characteristics -
         // since this heavily depends on the heap implementation
         // and other factors as well, i'll just go with 1.5 since
         // it is quicker to compute).
-        size_t new_size = std::max(initial, std::max( need, cur_size+(cur_size>>1) ));
+        size_t new_size = std::max(initial, std::max(need, cur_size + (cur_size >> 1)));
 
-        const uint8_t* const old = buffer;
+        const uint8_t *const old = buffer;
         buffer = new uint8_t[new_size];
 
         if (old) {
-            memcpy(buffer,old,cur_size);
+            memcpy(buffer, old, cur_size);
             delete[] old;
         }
 
@@ -197,68 +181,73 @@ private:
     }
 
 private:
-
-    uint8_t* buffer;
-    size_t cur_size,file_size, cursor, initial;
+    uint8_t *buffer;
+    size_t cur_size, file_size, cursor, initial;
 
     const std::string file;
-    BlobIOSystem* const creator;
+    BlobIOSystem *const creator;
 };
 
-
 #define AI_BLOBIO_MAGIC "$blobfile"
 
 // --------------------------------------------------------------------------------------------
 /** Redirect IOSystem to a blob */
 // --------------------------------------------------------------------------------------------
-class BlobIOSystem : public IOSystem
-{
+class BlobIOSystem : public IOSystem {
 
     friend class BlobIOStream;
-    typedef std::pair<std::string, aiExportDataBlob*> BlobEntry;
+    typedef std::pair<std::string, aiExportDataBlob *> BlobEntry;
+
 
 public:
-
-    BlobIOSystem()
-    {
+    /// @brief The default class constructor.
+    BlobIOSystem() :
+            baseName{AI_BLOBIO_MAGIC} {
     }
 
-    virtual ~BlobIOSystem()
-    {
-        for(BlobEntry& blobby : blobs) {
+    ///	@brief  The class constructor with the base name.
+    /// @param baseName     The base name.
+    BlobIOSystem(const std::string &baseName) :
+            baseName(baseName) {
+        // empty
+    }
+
+    ~BlobIOSystem() override {
+        for (BlobEntry &blobby : blobs) {
             delete blobby.second;
         }
     }
 
 public:
-
     // -------------------------------------------------------------------
-    const char* GetMagicFileName() const
-    {
-        return AI_BLOBIO_MAGIC;
+    const char *GetMagicFileName() const {
+        return baseName.c_str();
     }
 
-
     // -------------------------------------------------------------------
-    aiExportDataBlob* GetBlobChain()
-    {
+    aiExportDataBlob *GetBlobChain() {
+        const auto magicName = std::string(this->GetMagicFileName());
+        const bool hasBaseName = baseName != AI_BLOBIO_MAGIC;
+
         // one must be the master
-        aiExportDataBlob* master = NULL, *cur;
-        for(const BlobEntry& blobby : blobs) {
-            if (blobby.first == AI_BLOBIO_MAGIC) {
+        aiExportDataBlob *master = nullptr, *cur;
+
+        for (const BlobEntry &blobby : blobs) {
+            if (blobby.first == magicName) {
                 master = blobby.second;
+                master->name.Set(hasBaseName ? blobby.first : "");
                 break;
             }
         }
+
         if (!master) {
             ASSIMP_LOG_ERROR("BlobIOSystem: no data written or master file was not closed properly.");
-            return NULL;
+            return nullptr;
         }
 
-        master->name.Set("");
-
         cur = master;
-        for(const BlobEntry& blobby : blobs) {
+
+        for (const BlobEntry &blobby : blobs) {
             if (blobby.second == master) {
                 continue;
             }
@@ -266,9 +255,13 @@ public:
             cur->next = blobby.second;
             cur = cur->next;
 
-            // extract the file extension from the file written
-            const std::string::size_type s = blobby.first.find_first_of('.');
-            cur->name.Set(s == std::string::npos ? blobby.first : blobby.first.substr(s+1));
+            if (hasBaseName) {
+                cur->name.Set(blobby.first);
+            } else {
+                // extract the file extension from the file written
+                const std::string::size_type s = blobby.first.find_first_of('.');
+                cur->name.Set(s == std::string::npos ? blobby.first : blobby.first.substr(s + 1));
+            }
         }
 
         // give up blob ownership
@@ -277,62 +270,54 @@ public:
     }
 
 public:
-
     // -------------------------------------------------------------------
-    virtual bool Exists( const char* pFile) const {
+    bool Exists(const char *pFile) const override {
         return created.find(std::string(pFile)) != created.end();
     }
 
-
     // -------------------------------------------------------------------
-    virtual char getOsSeparator() const {
+    char getOsSeparator() const override {
         return '/';
     }
 
-
     // -------------------------------------------------------------------
-    virtual IOStream* Open(const char* pFile,
-        const char* pMode)
-    {
+    IOStream *Open(const char *pFile, const char *pMode) override {
         if (pMode[0] != 'w') {
-            return NULL;
+            return nullptr;
         }
 
         created.insert(std::string(pFile));
-        return new BlobIOStream(this,std::string(pFile));
+        return new BlobIOStream(this, std::string(pFile));
     }
 
     // -------------------------------------------------------------------
-    virtual void Close( IOStream* pFile)
-    {
+    void Close(IOStream *pFile) override {
         delete pFile;
     }
 
 private:
-
     // -------------------------------------------------------------------
-    void OnDestruct(const std::string& filename, BlobIOStream* child)
-    {
+    void OnDestruct(const std::string &filename, BlobIOStream *child) {
         // we don't know in which the files are closed, so we
         // can't reliably say that the first must be the master
         // file ...
-        blobs.push_back( BlobEntry(filename,child->GetBlob()) );
+        blobs.emplace_back(filename, child->GetBlob());
     }
 
 private:
+    std::string baseName;
     std::set<std::string> created;
-    std::vector< BlobEntry > blobs;
+    std::vector<BlobEntry> blobs;
 };
 
-
 // --------------------------------------------------------------------------------------------
-BlobIOStream :: ~BlobIOStream()
-{
-    creator->OnDestruct(file,this);
+BlobIOStream::~BlobIOStream() {
+    if (nullptr != creator) {
+        creator->OnDestruct(file, this);
+    }
     delete[] buffer;
 }
 
-
-} // end Assimp
+} // namespace Assimp
 
 #endif
diff --git a/Engine/lib/assimp/include/assimp/ByteSwapper.h b/Engine/lib/assimp/include/assimp/ByteSwapper.h
index 20a2463fb..488f7a51d 100644
--- a/Engine/lib/assimp/include/assimp/ByteSwapper.h
+++ b/Engine/lib/assimp/include/assimp/ByteSwapper.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -40,17 +40,22 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
-/** @file Helper class tp perform various byte oder swappings
+/** @file Helper class tp perform various byte order swappings
    (e.g. little to big endian) */
+#pragma once
 #ifndef AI_BYTESWAPPER_H_INC
 #define AI_BYTESWAPPER_H_INC
 
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
 #include <assimp/ai_assert.h>
 #include <assimp/types.h>
-#include <stdint.h>
+#include <cstdint>
 
 #if _MSC_VER >= 1400
-#include <stdlib.h>
+#include <cstdlib>
 #endif
 
 namespace Assimp    {
@@ -206,7 +211,7 @@ template <typename T> struct ByteSwap::_swapper<T,8> {
 // --------------------------------------------------------------------------------------
 #if (defined AI_BUILD_BIG_ENDIAN)
 #   define AI_LE(t) (t)
-#   define AI_BE(t) ByteSwap::Swapped(t)
+#   define AI_BE(t) Assimp::ByteSwap::Swapped(t)
 #   define AI_LSWAP2(p)
 #   define AI_LSWAP4(p)
 #   define AI_LSWAP8(p)
@@ -214,16 +219,16 @@ template <typename T> struct ByteSwap::_swapper<T,8> {
 #   define AI_LSWAP4P(p)
 #   define AI_LSWAP8P(p)
 #   define LE_NCONST const
-#   define AI_SWAP2(p) ByteSwap::Swap2(&(p))
-#   define AI_SWAP4(p) ByteSwap::Swap4(&(p))
-#   define AI_SWAP8(p) ByteSwap::Swap8(&(p))
-#   define AI_SWAP2P(p) ByteSwap::Swap2((p))
-#   define AI_SWAP4P(p) ByteSwap::Swap4((p))
-#   define AI_SWAP8P(p) ByteSwap::Swap8((p))
+#   define AI_SWAP2(p) Assimp::ByteSwap::Swap2(&(p))
+#   define AI_SWAP4(p) Assimp::ByteSwap::Swap4(&(p))
+#   define AI_SWAP8(p) Assimp::ByteSwap::Swap8(&(p))
+#   define AI_SWAP2P(p) Assimp::ByteSwap::Swap2((p))
+#   define AI_SWAP4P(p) Assimp::ByteSwap::Swap4((p))
+#   define AI_SWAP8P(p) Assimp::ByteSwap::Swap8((p))
 #   define BE_NCONST
 #else
 #   define AI_BE(t) (t)
-#   define AI_LE(t) ByteSwap::Swapped(t)
+#   define AI_LE(t) Assimp::ByteSwap::Swapped(t)
 #   define AI_SWAP2(p)
 #   define AI_SWAP4(p)
 #   define AI_SWAP8(p)
@@ -231,12 +236,12 @@ template <typename T> struct ByteSwap::_swapper<T,8> {
 #   define AI_SWAP4P(p)
 #   define AI_SWAP8P(p)
 #   define BE_NCONST const
-#   define AI_LSWAP2(p)     ByteSwap::Swap2(&(p))
-#   define AI_LSWAP4(p)     ByteSwap::Swap4(&(p))
-#   define AI_LSWAP8(p)     ByteSwap::Swap8(&(p))
-#   define AI_LSWAP2P(p)    ByteSwap::Swap2((p))
-#   define AI_LSWAP4P(p)    ByteSwap::Swap4((p))
-#   define AI_LSWAP8P(p)    ByteSwap::Swap8((p))
+#   define AI_LSWAP2(p)     Assimp::ByteSwap::Swap2(&(p))
+#   define AI_LSWAP4(p)     Assimp::ByteSwap::Swap4(&(p))
+#   define AI_LSWAP8(p)     Assimp::ByteSwap::Swap8(&(p))
+#   define AI_LSWAP2P(p)    Assimp::ByteSwap::Swap2((p))
+#   define AI_LSWAP4P(p)    Assimp::ByteSwap::Swap4((p))
+#   define AI_LSWAP8P(p)    Assimp::ByteSwap::Swap8((p))
 #   define LE_NCONST
 #endif
 
diff --git a/Engine/lib/assimp/include/assimp/Defines.h b/Engine/lib/assimp/include/assimp/ColladaMetaData.h
similarity index 83%
rename from Engine/lib/assimp/include/assimp/Defines.h
rename to Engine/lib/assimp/include/assimp/ColladaMetaData.h
index 15e1d83c2..52eb3c508 100644
--- a/Engine/lib/assimp/include/assimp/Defines.h
+++ b/Engine/lib/assimp/include/assimp/ColladaMetaData.h
@@ -2,7 +2,8 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2012, assimp team
+Copyright (c) 2006-2022, assimp team
+
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -38,12 +39,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
-// We need those constants, workaround for any platforms where nobody defined them yet
-#if (!defined SIZE_MAX)
-#   define SIZE_MAX (~((size_t)0))
+/** @file ColladaMetaData.h
+ * Declares common metadata constants used by Collada files
+ */
+#pragma once
+#ifndef AI_COLLADAMETADATA_H_INC
+#define AI_COLLADAMETADATA_H_INC
+
+#ifdef __GNUC__
+#pragma GCC system_header
 #endif
 
-#if (!defined UINT_MAX)
-#   define UINT_MAX (~((unsigned int)0))
-#endif
+#define AI_METADATA_COLLADA_ID "Collada_id"
+#define AI_METADATA_COLLADA_SID "Collada_sid"
 
+#endif
diff --git a/Engine/lib/assimp/include/assimp/Compiler/poppack1.h b/Engine/lib/assimp/include/assimp/Compiler/poppack1.h
index e033bc147..ff501bc0c 100644
--- a/Engine/lib/assimp/include/assimp/Compiler/poppack1.h
+++ b/Engine/lib/assimp/include/assimp/Compiler/poppack1.h
@@ -1,7 +1,7 @@
 
 // ===============================================================================
-// May be included multiple times - resets structure packing to the defaults 
-// for all supported compilers. Reverts the changes made by #include <pushpack1.h> 
+// May be included multiple times - resets structure packing to the defaults
+// for all supported compilers. Reverts the changes made by #include <pushpack1.h>
 //
 // Currently this works on the following compilers:
 // MSVC 7,8,9
@@ -14,7 +14,7 @@
 #endif
 
 // reset packing to the original value
-#if defined(_MSC_VER) ||  defined(__BORLANDC__) || defined (__BCPLUSPLUS__)
+#if (defined(_MSC_VER) && !defined(__clang__)) ||  defined(__BORLANDC__) || defined (__BCPLUSPLUS__)
 #	pragma pack( pop )
 #endif
 #undef PACK_STRUCT
diff --git a/Engine/lib/assimp/include/assimp/Compiler/pushpack1.h b/Engine/lib/assimp/include/assimp/Compiler/pushpack1.h
index 4c9fbb857..b32ed172c 100644
--- a/Engine/lib/assimp/include/assimp/Compiler/pushpack1.h
+++ b/Engine/lib/assimp/include/assimp/Compiler/pushpack1.h
@@ -1,7 +1,7 @@
 
 
 // ===============================================================================
-// May be included multiple times - sets structure packing to 1 
+// May be included multiple times - sets structure packing to 1
 // for all supported compilers. #include <poppack1.h> reverts the changes.
 //
 // Currently this works on the following compilers:
@@ -22,7 +22,7 @@
 #	error poppack1.h must be included after pushpack1.h
 #endif
 
-#if defined(_MSC_VER) ||  defined(__BORLANDC__) ||	defined (__BCPLUSPLUS__)
+#if (defined(_MSC_VER) && !defined(__clang__)) ||  defined(__BORLANDC__) ||	defined (__BCPLUSPLUS__)
 #	pragma pack(push,1)
 #	define PACK_STRUCT
 #elif defined( __GNUC__ ) || defined(__clang__)
@@ -37,7 +37,7 @@
 
 #if defined(_MSC_VER)
 // C4103: Packing was changed after the inclusion of the header, probably missing #pragma pop
-#	pragma warning (disable : 4103) 
+#	pragma warning (disable : 4103)
 #endif
 
 #define AI_PUSHPACK_IS_DEFINED
diff --git a/Engine/lib/assimp/include/assimp/CreateAnimMesh.h b/Engine/lib/assimp/include/assimp/CreateAnimMesh.h
index a60173588..e5211f504 100644
--- a/Engine/lib/assimp/include/assimp/CreateAnimMesh.h
+++ b/Engine/lib/assimp/include/assimp/CreateAnimMesh.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,16 +42,36 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file CreateAnimMesh.h
  *  Create AnimMesh from Mesh
  */
+#pragma once
 #ifndef INCLUDED_AI_CREATE_ANIM_MESH_H
 #define INCLUDED_AI_CREATE_ANIM_MESH_H
 
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
 #include <assimp/mesh.h>
 
-namespace Assimp    {
+namespace Assimp {
 
-/** Create aiAnimMesh from aiMesh. */
-ASSIMP_API aiAnimMesh *aiCreateAnimMesh(const aiMesh *mesh);
+/**
+ *  Create aiAnimMesh from aiMesh.
+ *  @param  mesh            The input mesh to create an animated mesh from.
+ *  @param  needPositions   If true, positions will be copied from.
+ *  @param  needNormals     If true, normals will be copied from.
+ *  @param  needTangents    If true, tangents and bitangents will be copied from.
+ *  @param  needColors      If true, colors will be copied from.
+ *  @param  needTexCoords   If true, texCoords will be copied from.
+ *  @return The new created animated mesh.
+ */
+ASSIMP_API aiAnimMesh *aiCreateAnimMesh(const aiMesh *mesh,
+                                        bool needPositions = true,
+                                        bool needNormals = true,
+                                        bool needTangents = true,
+                                        bool needColors = true,
+                                        bool needTexCoords = true);
 
 } // end of namespace Assimp
+
 #endif // INCLUDED_AI_CREATE_ANIM_MESH_H
 
diff --git a/Engine/lib/assimp/include/assimp/DefaultIOStream.h b/Engine/lib/assimp/include/assimp/DefaultIOStream.h
index 994d728ff..aa298a667 100644
--- a/Engine/lib/assimp/include/assimp/DefaultIOStream.h
+++ b/Engine/lib/assimp/include/assimp/DefaultIOStream.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -40,16 +39,23 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
-/** @file Default file I/O using fXXX()-family of functions */
+/**
+ *  @file
+ *  @brief Default file I/O using fXXX()-family of functions
+ */
+#pragma once
 #ifndef AI_DEFAULTIOSTREAM_H_INC
 #define AI_DEFAULTIOSTREAM_H_INC
 
-#include <stdio.h>
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
+#include <cstdio>
 #include <assimp/IOStream.hpp>
 #include <assimp/importerdesc.h>
-#include <assimp/Defines.h>
 
-namespace Assimp    {
+namespace Assimp {
 
 // ----------------------------------------------------------------------------------
 //! @class  DefaultIOStream
@@ -57,8 +63,7 @@ namespace Assimp    {
 //! @note   An instance of this class can exist without a valid file handle
 //!         attached to it. All calls fail, but the instance can nevertheless be
 //!         used with no restrictions.
-class ASSIMP_API DefaultIOStream : public IOStream
-{
+class ASSIMP_API DefaultIOStream : public IOStream {
     friend class DefaultIOSystem;
 #if __ANDROID__
 # if __ANDROID_API__ > 9
@@ -69,7 +74,12 @@ class ASSIMP_API DefaultIOStream : public IOStream
 #endif // __ANDROID__
 
 protected:
+    /// @brief 
     DefaultIOStream() AI_NO_EXCEPT;
+
+    /// @brief The class constructor with the file name and the stream.
+    /// @param pFile        The file-streaam
+    /// @param strFilename  The file name
     DefaultIOStream(FILE* pFile, const std::string &strFilename);
 
 public:
@@ -78,63 +88,52 @@ public:
 
     // -------------------------------------------------------------------
     /// Read from stream
-    size_t Read(void* pvBuffer,
-        size_t pSize,
-        size_t pCount);
-
+    size_t Read(void* pvBuffer, size_t pSize, size_t pCount) override;
 
     // -------------------------------------------------------------------
     /// Write to stream
-    size_t Write(const void* pvBuffer,
-        size_t pSize,
-        size_t pCount);
+    size_t Write(const void* pvBuffer, size_t pSize, size_t pCount) override;
 
     // -------------------------------------------------------------------
     /// Seek specific position
-    aiReturn Seek(size_t pOffset,
-        aiOrigin pOrigin);
+    aiReturn Seek(size_t pOffset, aiOrigin pOrigin) override;
 
     // -------------------------------------------------------------------
     /// Get current seek position
-    size_t Tell() const;
+    size_t Tell() const override;
 
     // -------------------------------------------------------------------
     /// Get size of file
-    size_t FileSize() const;
+    size_t FileSize() const override;
 
     // -------------------------------------------------------------------
     /// Flush file contents
-    void Flush();
+    void Flush() override;
 
 private:
-    //  File data-structure, using clib
     FILE* mFile;
-    //  Filename
     std::string mFilename;
-    // Cached file size
     mutable size_t mCachedSize;
 };
 
 // ----------------------------------------------------------------------------------
-inline
-DefaultIOStream::DefaultIOStream() AI_NO_EXCEPT
-: mFile(nullptr)
-, mFilename("")
-, mCachedSize(SIZE_MAX) {
+AI_FORCE_INLINE DefaultIOStream::DefaultIOStream() AI_NO_EXCEPT :
+        mFile(nullptr),
+        mFilename(),
+        mCachedSize(SIZE_MAX) {
     // empty
 }
 
 // ----------------------------------------------------------------------------------
-inline
-DefaultIOStream::DefaultIOStream (FILE* pFile, const std::string &strFilename)
-: mFile(pFile)
-, mFilename(strFilename)
-, mCachedSize(SIZE_MAX) {
+AI_FORCE_INLINE DefaultIOStream::DefaultIOStream (FILE* pFile, const std::string &strFilename) :
+        mFile(pFile),
+        mFilename(strFilename),
+        mCachedSize(SIZE_MAX) {
     // empty
 }
+
 // ----------------------------------------------------------------------------------
 
 } // ns assimp
 
 #endif //!!AI_DEFAULTIOSTREAM_H_INC
-
diff --git a/Engine/lib/assimp/include/assimp/DefaultIOSystem.h b/Engine/lib/assimp/include/assimp/DefaultIOSystem.h
index 2dd5c801b..8545e75cf 100644
--- a/Engine/lib/assimp/include/assimp/DefaultIOSystem.h
+++ b/Engine/lib/assimp/include/assimp/DefaultIOSystem.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -40,10 +39,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
-/** @file Default implementation of IOSystem using the standard C file functions */
+/**
+ *  @file Default implementation of IOSystem using the standard C file functions
+ */
+#pragma once
 #ifndef AI_DEFAULTIOSYSTEM_H_INC
 #define AI_DEFAULTIOSYSTEM_H_INC
 
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
 #include <assimp/IOSystem.hpp>
 
 namespace Assimp    {
@@ -54,23 +60,23 @@ class ASSIMP_API DefaultIOSystem : public IOSystem {
 public:
     // -------------------------------------------------------------------
     /** Tests for the existence of a file at the given path. */
-    bool Exists( const char* pFile) const;
+    bool Exists( const char* pFile) const override;
 
     // -------------------------------------------------------------------
     /** Returns the directory separator. */
-    char getOsSeparator() const;
+    char getOsSeparator() const override;
 
     // -------------------------------------------------------------------
     /** Open a new file with a given path. */
-    IOStream* Open( const char* pFile, const char* pMode = "rb");
+    IOStream* Open( const char* pFile, const char* pMode = "rb") override;
 
     // -------------------------------------------------------------------
     /** Closes the given file and releases all resources associated with it. */
-    void Close( IOStream* pFile);
+    void Close( IOStream* pFile) override;
 
     // -------------------------------------------------------------------
     /** Compare two paths */
-    bool ComparePaths (const char* one, const char* second) const;
+    bool ComparePaths (const char* one, const char* second) const override;
 
     /** @brief get the file name of a full filepath
      * example: /tmp/archive.tar.gz -> archive.tar.gz
diff --git a/Engine/lib/assimp/include/assimp/DefaultLogger.hpp b/Engine/lib/assimp/include/assimp/DefaultLogger.hpp
index 1946e250a..723097ff2 100644
--- a/Engine/lib/assimp/include/assimp/DefaultLogger.hpp
+++ b/Engine/lib/assimp/include/assimp/DefaultLogger.hpp
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -39,23 +38,30 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 ----------------------------------------------------------------------
 */
-/** @file DefaultLogger.hpp
-*/
 
+/**
+ *  @file DefaultLogger.hpp
+ */
+
+#pragma once
 #ifndef INCLUDED_AI_DEFAULTLOGGER
 #define INCLUDED_AI_DEFAULTLOGGER
 
-#include "Logger.hpp"
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
 #include "LogStream.hpp"
+#include "Logger.hpp"
 #include "NullLogger.hpp"
 #include <vector>
 
-namespace Assimp    {
+namespace Assimp {
 // ------------------------------------------------------------------------------------
 class IOStream;
 struct LogStreamInfo;
 
-/** default name of logfile */
+/** default name of log-file */
 #define ASSIMP_DEFAULT_LOG_NAME "AssimpLog.txt"
 
 // ------------------------------------------------------------------------------------
@@ -71,27 +77,24 @@ struct LogStreamInfo;
  *  If you wish to customize the logging at an even deeper level supply your own
  *  implementation of #Logger to #set().
  *  @note The whole logging stuff causes a small extra overhead for all imports. */
-class ASSIMP_API DefaultLogger :
-    public Logger   {
-
+class ASSIMP_API DefaultLogger : public Logger {
 public:
-
     // ----------------------------------------------------------------------
     /** @brief Creates a logging instance.
      *  @param name Name for log file. Only valid in combination
      *    with the aiDefaultLogStream_FILE flag.
-     *  @param severity Log severity, VERBOSE turns on debug messages
+     *  @param severity Log severity, DEBUG turns on debug messages and VERBOSE turns on all messages.
      *  @param defStreams  Default log streams to be attached. Any bitwise
      *    combination of the aiDefaultLogStream enumerated values.
      *    If #aiDefaultLogStream_FILE is specified but an empty string is
      *    passed for 'name', no log file is created at all.
      *  @param  io IOSystem to be used to open external files (such as the
-     *   log file). Pass NULL to rely on the default implementation.
+     *   log file). Pass nullptr to rely on the default implementation.
      *  This replaces the default #NullLogger with a #DefaultLogger instance. */
-    static Logger *create(const char* name = ASSIMP_DEFAULT_LOG_NAME,
-        LogSeverity severity    = NORMAL,
-        unsigned int defStreams = aiDefaultLogStream_DEBUGGER | aiDefaultLogStream_FILE,
-        IOSystem* io            = NULL);
+    static Logger *create(const char *name = ASSIMP_DEFAULT_LOG_NAME,
+            LogSeverity severity = NORMAL,
+            unsigned int defStreams = aiDefaultLogStream_DEBUGGER | aiDefaultLogStream_FILE,
+            IOSystem *io = nullptr);
 
     // ----------------------------------------------------------------------
     /** @brief Setup a custom #Logger implementation.
@@ -101,7 +104,7 @@ public:
      *  it's much easier to use #create() and to attach your own custom
      *  output streams to it.
      *  @param logger Pass NULL to setup a default NullLogger*/
-    static void set (Logger *logger);
+    static void set(Logger *logger);
 
     // ----------------------------------------------------------------------
     /** @brief  Getter for singleton instance
@@ -123,13 +126,11 @@ public:
 
     // ----------------------------------------------------------------------
     /** @copydoc Logger::attachStream   */
-    bool attachStream(LogStream *pStream,
-        unsigned int severity);
+    bool attachStream(LogStream *pStream, unsigned int severity) override;
 
     // ----------------------------------------------------------------------
-    /** @copydoc Logger::detatchStream */
-    bool detatchStream(LogStream *pStream,
-        unsigned int severity);
+    /** @copydoc Logger::detachStream */
+    bool detachStream(LogStream *pStream, unsigned int severity) override;
 
 private:
     // ----------------------------------------------------------------------
@@ -139,23 +140,26 @@ private:
 
     // ----------------------------------------------------------------------
     /** @briefDestructor    */
-    ~DefaultLogger();
+    ~DefaultLogger() override;
+
+    /** @brief  Logs debug infos, only been written when severity level DEBUG or higher is set */
+    void OnDebug(const char *message) override;
 
     /** @brief  Logs debug infos, only been written when severity level VERBOSE is set */
-    void OnDebug(const char* message);
+    void OnVerboseDebug(const char *message) override;
 
     /** @brief  Logs an info message */
-    void OnInfo(const char*  message);
+    void OnInfo(const char *message) override;
 
     /** @brief  Logs a warning message */
-    void OnWarn(const char*  message);
+    void OnWarn(const char *message) override;
 
     /** @brief  Logs an error message */
-    void OnError(const char* message);
+    void OnError(const char *message) override;
 
     // ----------------------------------------------------------------------
     /** @brief Writes a message to all streams */
-    void WriteToStreams(const char* message, ErrorSeverity ErrorSev );
+    void WriteToStreams(const char *message, ErrorSeverity ErrorSev);
 
     // ----------------------------------------------------------------------
     /** @brief Returns the thread id.
@@ -166,9 +170,9 @@ private:
 
 private:
     //  Aliases for stream container
-    typedef std::vector<LogStreamInfo*> StreamArray;
-    typedef std::vector<LogStreamInfo*>::iterator StreamIt;
-    typedef std::vector<LogStreamInfo*>::const_iterator ConstStreamIt;
+    using StreamArray = std::vector<LogStreamInfo *>;
+    using StreamIt = std::vector<LogStreamInfo *>::iterator;
+    using ConstStreamIt = std::vector<LogStreamInfo *>::const_iterator;
 
     //! only logging instance
     static Logger *m_pLogger;
@@ -178,9 +182,10 @@ private:
     StreamArray m_StreamArray;
 
     bool noRepeatMsg;
-    char lastMsg[MAX_LOG_MESSAGE_LENGTH*2];
+    char lastMsg[MAX_LOG_MESSAGE_LENGTH * 2];
     size_t lastLen;
 };
+
 // ------------------------------------------------------------------------------------
 
 } // Namespace Assimp
diff --git a/Engine/lib/assimp/include/assimp/Exceptional.h b/Engine/lib/assimp/include/assimp/Exceptional.h
index 5109b8f07..ec3d38c5a 100644
--- a/Engine/lib/assimp/include/assimp/Exceptional.h
+++ b/Engine/lib/assimp/include/assimp/Exceptional.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2008, assimp team
+Copyright (c) 2006-2022, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -38,67 +38,109 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
-#ifndef INCLUDED_EXCEPTIONAL_H
-#define INCLUDED_EXCEPTIONAL_H
+#pragma once
+#ifndef AI_INCLUDED_EXCEPTIONAL_H
+#define AI_INCLUDED_EXCEPTIONAL_H
+
+#ifdef __GNUC__
+#pragma GCC system_header
+#endif
 
-#include <stdexcept>
 #include <assimp/DefaultIOStream.h>
+#include <assimp/TinyFormatter.h>
+#include <stdexcept>
+
 using std::runtime_error;
 
 #ifdef _MSC_VER
-#   pragma warning(disable : 4275)
+#pragma warning(disable : 4275)
 #endif
 
+// ---------------------------------------------------------------------------
+/**
+ *  The base-class for all other exceptions
+ */
+class ASSIMP_API DeadlyErrorBase : public runtime_error {
+protected:
+    /// @brief The class constructor with the formatter.
+    /// @param f    The formatter.
+    DeadlyErrorBase(Assimp::Formatter::format f);
+
+    /// @brief The class constructor with the parameter ellipse.
+    /// @tparam ...T    The type for the ellipse
+    /// @tparam U       The other type
+    /// @param f        The formatter
+    /// @param u        One parameter
+    /// @param ...args  The rest
+    template<typename... T, typename U>
+    DeadlyErrorBase(Assimp::Formatter::format f, U&& u, T&&... args) :
+            DeadlyErrorBase(std::move(f << std::forward<U>(u)), std::forward<T>(args)...) {}
+};
+
 // ---------------------------------------------------------------------------
 /** FOR IMPORTER PLUGINS ONLY: Simple exception class to be thrown if an
  *  unrecoverable error occurs while importing. Loading APIs return
- *  NULL instead of a valid aiScene then.  */
-class DeadlyImportError
-    : public runtime_error
-{
+ *  nullptr instead of a valid aiScene then.  */
+class ASSIMP_API DeadlyImportError : public DeadlyErrorBase {
 public:
-    /** Constructor with arguments */
-    explicit DeadlyImportError( const std::string& errorText)
-        : runtime_error(errorText)
-    {
+    /// @brief The class constructor with the message.
+    /// @param message  The message
+    DeadlyImportError(const char *message) :
+            DeadlyErrorBase(Assimp::Formatter::format(), std::forward<const char*>(message)) {
+        // empty
     }
 
-private:
+    /// @brief The class constructor with the parameter ellipse.
+    /// @tparam ...T    The type for the ellipse
+    /// @param ...args  The args
+    template<typename... T>
+    explicit DeadlyImportError(T&&... args) :
+            DeadlyErrorBase(Assimp::Formatter::format(), std::forward<T>(args)...) {
+        // empty
+    }
 };
 
-typedef DeadlyImportError DeadlyExportError;
+// ---------------------------------------------------------------------------
+/** FOR EXPORTER PLUGINS ONLY: Simple exception class to be thrown if an
+ *  unrecoverable error occurs while exporting. Exporting APIs return
+ *  nullptr instead of a valid aiScene then.  */
+class ASSIMP_API DeadlyExportError : public DeadlyErrorBase {
+public:
+    /** Constructor with arguments */
+    template<typename... T>
+    explicit DeadlyExportError(T&&... args) :
+            DeadlyErrorBase(Assimp::Formatter::format(), std::forward<T>(args)...) {}
+};
 
 #ifdef _MSC_VER
-#   pragma warning(default : 4275)
+#pragma warning(default : 4275)
 #endif
 
 // ---------------------------------------------------------------------------
 template <typename T>
-struct ExceptionSwallower   {
-    T operator ()() const {
+struct ExceptionSwallower {
+    T operator()() const {
         return T();
     }
 };
 
 // ---------------------------------------------------------------------------
 template <typename T>
-struct ExceptionSwallower<T*>   {
-    T* operator ()() const {
-        return NULL;
+struct ExceptionSwallower<T *> {
+    T *operator()() const {
+        return nullptr;
     }
 };
 
 // ---------------------------------------------------------------------------
 template <>
 struct ExceptionSwallower<aiReturn> {
-    aiReturn operator ()() const {
+    aiReturn operator()() const {
         try {
             throw;
-        }
-        catch (std::bad_alloc&) {
+        } catch (std::bad_alloc &) {
             return aiReturn_OUTOFMEMORY;
-        }
-        catch (...) {
+        } catch (...) {
             return aiReturn_FAILURE;
         }
     }
@@ -107,19 +149,34 @@ struct ExceptionSwallower<aiReturn> {
 // ---------------------------------------------------------------------------
 template <>
 struct ExceptionSwallower<void> {
-    void operator ()() const {
+    void operator()() const {
         return;
     }
 };
 
-#define ASSIMP_BEGIN_EXCEPTION_REGION()\
-{\
-    try {
+#define ASSIMP_BEGIN_EXCEPTION_REGION() \
+    {                                   \
+        try {
 
-#define ASSIMP_END_EXCEPTION_REGION(type)\
-    } catch(...) {\
-        return ExceptionSwallower<type>()();\
-    }\
+#define ASSIMP_END_EXCEPTION_REGION_WITH_ERROR_STRING(type, ASSIMP_END_EXCEPTION_REGION_errorString, ASSIMP_END_EXCEPTION_REGION_exception)     \
+    }                                                                                                                                           \
+    catch (const DeadlyImportError &e) {                                                                                                        \
+        ASSIMP_END_EXCEPTION_REGION_errorString = e.what();                                                                                     \
+        ASSIMP_END_EXCEPTION_REGION_exception = std::current_exception();                                                                       \
+        return ExceptionSwallower<type>()();                                                                                                    \
+    }                                                                                                                                           \
+    catch (...) {                                                                                                                               \
+        ASSIMP_END_EXCEPTION_REGION_errorString = "Unknown exception";                                                                          \
+        ASSIMP_END_EXCEPTION_REGION_exception = std::current_exception();                                                                       \
+        return ExceptionSwallower<type>()();                                                                                                    \
+    }                                                                                                                                           \
 }
 
-#endif // INCLUDED_EXCEPTIONAL_H
+#define ASSIMP_END_EXCEPTION_REGION(type)    \
+    }                                        \
+    catch (...) {                            \
+        return ExceptionSwallower<type>()(); \
+    }                                        \
+    }
+
+#endif // AI_INCLUDED_EXCEPTIONAL_H
diff --git a/Engine/lib/assimp/include/assimp/Exporter.hpp b/Engine/lib/assimp/include/assimp/Exporter.hpp
index ea0303e80..09a459442 100644
--- a/Engine/lib/assimp/include/assimp/Exporter.hpp
+++ b/Engine/lib/assimp/include/assimp/Exporter.hpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -48,13 +46,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_EXPORT_HPP_INC
 #define AI_EXPORT_HPP_INC
 
+#ifdef __GNUC__
+#pragma GCC system_header
+#endif
+
 #ifndef ASSIMP_BUILD_NO_EXPORT
 
 #include "cexport.h"
 #include <map>
+#include <functional>
 
 namespace Assimp {
-    
+
 class ExporterPimpl;
 class IOSystem;
 class ProgressHandler;
@@ -82,7 +85,7 @@ class ASSIMP_API ExportProperties;
 class ASSIMP_API Exporter {
 public:
     /** Function pointer type of a Export worker function */
-    typedef void (*fpExportFunc)(const char*, IOSystem*, const aiScene*, const ExportProperties*);
+    typedef void (*fpExportFunc)(const char *, IOSystem *, const aiScene *, const ExportProperties *);
 
     /** Internal description of an Assimp export format option */
     struct ExportFormatEntry {
@@ -96,8 +99,7 @@ public:
         unsigned int mEnforcePP;
 
         // Constructor to fill all entries
-        ExportFormatEntry( const char* pId, const char* pDesc, const char* pExtension, fpExportFunc pFunction, unsigned int pEnforcePP = 0u)
-        {
+        ExportFormatEntry(const char *pId, const char *pDesc, const char *pExtension, fpExportFunc pFunction, unsigned int pEnforcePP = 0u) {
             mDescription.id = pId;
             mDescription.description = pDesc;
             mDescription.fileExtension = pExtension;
@@ -106,12 +108,11 @@ public:
         }
 
         ExportFormatEntry() :
-            mExportFunction()
-          , mEnforcePP()
-        {
-            mDescription.id = NULL;
-            mDescription.description = NULL;
-            mDescription.fileExtension = NULL;
+                mExportFunction(),
+                mEnforcePP() {
+            mDescription.id = nullptr;
+            mDescription.description = nullptr;
+            mDescription.fileExtension = nullptr;
         }
     };
 
@@ -140,7 +141,7 @@ public:
      *
      * @param pIOHandler The IO handler to be used in all file accesses
      *   of the Importer. */
-    void SetIOHandler( IOSystem* pIOHandler);
+    void SetIOHandler(IOSystem *pIOHandler);
 
     // -------------------------------------------------------------------
     /** Retrieves the IO handler that is currently set.
@@ -149,7 +150,7 @@ public:
      * handler is active as long the application doesn't supply its own
      * custom IO handler via #SetIOHandler().
      * @return A valid IOSystem interface, never NULL. */
-    IOSystem* GetIOHandler() const;
+    IOSystem *GetIOHandler() const;
 
     // -------------------------------------------------------------------
     /** Checks whether a default IO handler is active
@@ -169,7 +170,7 @@ public:
      *    disable progress reporting.
      *  @note Progress handlers can be used to abort the loading
      *    at almost any time.*/
-    void SetProgressHandler(ProgressHandler* pHandler);
+    void SetProgressHandler(ProgressHandler *pHandler);
 
     // -------------------------------------------------------------------
     /** Exports the given scene to a chosen file format. Returns the exported
@@ -183,22 +184,22 @@ public:
     * #GetExportFormatCount / #GetExportFormatDescription to learn which
     *   export formats are available.
     * @param pPreprocessing See the documentation for #Export
-    * @return the exported data or NULL in case of error.
+    * @return the exported data or nullptr in case of error.
     * @note If the Exporter instance did already hold a blob from
     *   a previous call to #ExportToBlob, it will be disposed.
     *   Any IO handlers set via #SetIOHandler are ignored here.
     * @note Use aiCopyScene() to get a modifiable copy of a previously
     *   imported scene. */
-    const aiExportDataBlob* ExportToBlob(const aiScene* pScene, const char* pFormatId,
-        unsigned int pPreprocessing = 0u, const ExportProperties* pProperties = nullptr);
-    const aiExportDataBlob* ExportToBlob(  const aiScene* pScene, const std::string& pFormatId,
-        unsigned int pPreprocessing = 0u, const ExportProperties* pProperties = nullptr);
+    const aiExportDataBlob *ExportToBlob(const aiScene *pScene, const char *pFormatId,
+            unsigned int pPreprocessing = 0u, const ExportProperties *pProperties = nullptr);
+    const aiExportDataBlob *ExportToBlob(const aiScene *pScene, const std::string &pFormatId,
+            unsigned int pPreprocessing = 0u, const ExportProperties *pProperties = nullptr);
 
     // -------------------------------------------------------------------
     /** Convenience function to export directly to a file. Use
      *  #SetIOSystem to supply a custom IOSystem to gain fine-grained control
      *  about the output data flow of the export process.
-     * @param pBlob A data blob obtained from a previous call to #aiExportScene. Must not be NULL.
+     * @param pBlob A data blob obtained from a previous call to #aiExportScene. Must not be nullptr.
      * @param pPath Full target file name. Target must be accessible.
      * @param pPreprocessing Accepts any choice of the #aiPostProcessSteps enumerated
      *   flags, but in reality only a subset of them makes sense here. Specifying
@@ -227,10 +228,10 @@ public:
      * @return AI_SUCCESS if everything was fine.
      * @note Use aiCopyScene() to get a modifiable copy of a previously
      *   imported scene.*/
-    aiReturn Export( const aiScene* pScene, const char* pFormatId, const char* pPath,
-        unsigned int pPreprocessing = 0u, const ExportProperties* pProperties = nullptr);
-    aiReturn Export( const aiScene* pScene, const std::string& pFormatId, const std::string& pPath,
-        unsigned int pPreprocessing = 0u, const ExportProperties* pProperties = nullptr);
+    aiReturn Export(const aiScene *pScene, const char *pFormatId, const char *pPath,
+            unsigned int pPreprocessing = 0u, const ExportProperties *pProperties = nullptr);
+    aiReturn Export(const aiScene *pScene, const std::string &pFormatId, const std::string &pPath,
+            unsigned int pPreprocessing = 0u, const ExportProperties *pProperties = nullptr);
 
     // -------------------------------------------------------------------
     /** Returns an error description of an error that occurred in #Export
@@ -238,21 +239,21 @@ public:
      *
      * Returns an empty string if no error occurred.
      * @return A description of the last error, an empty string if no
-     *   error occurred. The string is never NULL.
+     *   error occurred. The string is never nullptr.
      *
      * @note The returned function remains valid until one of the
      * following methods is called: #Export, #ExportToBlob, #FreeBlob */
-    const char* GetErrorString() const;
+    const char *GetErrorString() const;
 
     // -------------------------------------------------------------------
     /** Return the blob obtained from the last call to #ExportToBlob */
-    const aiExportDataBlob* GetBlob() const;
+    const aiExportDataBlob *GetBlob() const;
 
     // -------------------------------------------------------------------
     /** Orphan the blob from the last call to #ExportToBlob. This means
      *  the caller takes ownership and is thus responsible for calling
      *  the C API function #aiReleaseExportBlob to release it. */
-    const aiExportDataBlob* GetOrphanedBlob() const;
+    const aiExportDataBlob *GetOrphanedBlob() const;
 
     // -------------------------------------------------------------------
     /** Frees the current blob.
@@ -262,7 +263,7 @@ public:
      *  automatically by the destructor. The only reason to call
      *  it manually would be to reclaim as much storage as possible
      *  without giving up the #Exporter instance yet. */
-    void FreeBlob( );
+    void FreeBlob();
 
     // -------------------------------------------------------------------
     /** Returns the number of export file formats available in the current
@@ -288,7 +289,7 @@ public:
      *  for. Valid range is 0 to #Exporter::GetExportFormatCount
      * @return A description of that specific export format.
      *  NULL if pIndex is out of range. */
-    const aiExportFormatDesc* GetExportFormatDescription( size_t pIndex ) const;
+    const aiExportFormatDesc *GetExportFormatDescription(size_t pIndex) const;
 
     // -------------------------------------------------------------------
     /** Register a custom exporter. Custom export formats are limited to
@@ -301,7 +302,7 @@ public:
      *    registered. A common cause that would prevent an exporter
      *    from being registered is that its format id is already
      *    occupied by another format. */
-    aiReturn RegisterExporter(const ExportFormatEntry& desc);
+    aiReturn RegisterExporter(const ExportFormatEntry &desc);
 
     // -------------------------------------------------------------------
     /** Remove an export format previously registered with #RegisterExporter
@@ -312,11 +313,11 @@ public:
      *    'id' field of #aiExportFormatDesc.
      *  @note Calling this method on a format description not yet registered
      *    has no effect.*/
-    void UnregisterExporter(const char* id);
+    void UnregisterExporter(const char *id);
 
 protected:
     // Just because we don't want you to know how we're hacking around.
-    ExporterPimpl* pimpl;
+    ExporterPimpl *pimpl;
 };
 
 class ASSIMP_API ExportProperties {
@@ -330,6 +331,7 @@ public:
     typedef std::map<KeyType, ai_real> FloatPropertyMap;
     typedef std::map<KeyType, std::string> StringPropertyMap;
     typedef std::map<KeyType, aiMatrix4x4> MatrixPropertyMap;
+    typedef std::map<KeyType, std::function<void *(void *)>> CallbackPropertyMap;
 
 public:
     /** Standard constructor
@@ -343,7 +345,7 @@ public:
      * This copies the configuration properties of another ExportProperties.
      * @see ExportProperties(const ExportProperties& other)
      */
-    ExportProperties(const ExportProperties& other);
+    ExportProperties(const ExportProperties &other);
 
     // -------------------------------------------------------------------
     /** Set an integer configuration property.
@@ -358,7 +360,7 @@ public:
      *   floating-point property has no effect - the loader will call
      *   GetPropertyFloat() to read the property, but it won't be there.
      */
-    bool SetPropertyInteger(const char* szName, int iValue);
+    bool SetPropertyInteger(const char *szName, int iValue);
 
     // -------------------------------------------------------------------
     /** Set a boolean configuration property. Boolean properties
@@ -367,27 +369,29 @@ public:
      *  #GetPropertyBool and vice versa.
      * @see SetPropertyInteger()
      */
-    bool SetPropertyBool(const char* szName, bool value)    {
-        return SetPropertyInteger(szName,value);
+    bool SetPropertyBool(const char *szName, bool value) {
+        return SetPropertyInteger(szName, value);
     }
 
     // -------------------------------------------------------------------
     /** Set a floating-point configuration property.
      * @see SetPropertyInteger()
      */
-    bool SetPropertyFloat(const char* szName, ai_real fValue);
+    bool SetPropertyFloat(const char *szName, ai_real fValue);
 
     // -------------------------------------------------------------------
     /** Set a string configuration property.
      * @see SetPropertyInteger()
      */
-    bool SetPropertyString(const char* szName, const std::string& sValue);
+    bool SetPropertyString(const char *szName, const std::string &sValue);
 
     // -------------------------------------------------------------------
     /** Set a matrix configuration property.
      * @see SetPropertyInteger()
      */
-    bool SetPropertyMatrix(const char* szName, const aiMatrix4x4& sValue);
+    bool SetPropertyMatrix(const char *szName, const aiMatrix4x4 &sValue);
+
+    bool SetPropertyCallback(const char *szName, const std::function<void *(void *)> &f);
 
     // -------------------------------------------------------------------
     /** Get a configuration property.
@@ -402,8 +406,8 @@ public:
      *   floating-point property has no effect - the loader will call
      *   GetPropertyFloat() to read the property, but it won't be there.
      */
-    int GetPropertyInteger(const char* szName,
-        int iErrorReturn = 0xffffffff) const;
+    int GetPropertyInteger(const char *szName,
+            int iErrorReturn = 0xffffffff) const;
 
     // -------------------------------------------------------------------
     /** Get a boolean configuration property. Boolean properties
@@ -412,16 +416,16 @@ public:
      *  #GetPropertyBool and vice versa.
      * @see GetPropertyInteger()
      */
-    bool GetPropertyBool(const char* szName, bool bErrorReturn = false) const {
-        return GetPropertyInteger(szName,bErrorReturn)!=0;
+    bool GetPropertyBool(const char *szName, bool bErrorReturn = false) const {
+        return GetPropertyInteger(szName, bErrorReturn) != 0;
     }
 
     // -------------------------------------------------------------------
     /** Get a floating-point configuration property
      * @see GetPropertyInteger()
      */
-    ai_real GetPropertyFloat(const char* szName,
-        ai_real fErrorReturn = 10e10f) const;
+    ai_real GetPropertyFloat(const char *szName,
+            ai_real fErrorReturn = 10e10f) const;
 
     // -------------------------------------------------------------------
     /** Get a string configuration property
@@ -429,8 +433,8 @@ public:
      *  The return value remains valid until the property is modified.
      * @see GetPropertyInteger()
      */
-    const std::string GetPropertyString(const char* szName,
-        const std::string& sErrorReturn = "") const;
+    const std::string GetPropertyString(const char *szName,
+            const std::string &sErrorReturn = "") const;
 
     // -------------------------------------------------------------------
     /** Get a matrix configuration property
@@ -438,36 +442,38 @@ public:
      *  The return value remains valid until the property is modified.
      * @see GetPropertyInteger()
      */
-    const aiMatrix4x4 GetPropertyMatrix(const char* szName,
-        const aiMatrix4x4& sErrorReturn = aiMatrix4x4()) const;
+    const aiMatrix4x4 GetPropertyMatrix(const char *szName,
+            const aiMatrix4x4 &sErrorReturn = aiMatrix4x4()) const;
+
+    std::function<void *(void *)> GetPropertyCallback(const char* szName) const;
 
     // -------------------------------------------------------------------
     /** Determine a integer configuration property has been set.
     * @see HasPropertyInteger()
      */
-    bool HasPropertyInteger(const char* szName) const;
+    bool HasPropertyInteger(const char *szName) const;
 
     /** Determine a boolean configuration property has been set.
     * @see HasPropertyBool()
      */
-    bool HasPropertyBool(const char* szName) const;
+    bool HasPropertyBool(const char *szName) const;
 
     /** Determine a boolean configuration property has been set.
     * @see HasPropertyFloat()
      */
-    bool HasPropertyFloat(const char* szName) const;
+    bool HasPropertyFloat(const char *szName) const;
 
     /** Determine a String configuration property has been set.
     * @see HasPropertyString()
      */
-    bool HasPropertyString(const char* szName) const;
+    bool HasPropertyString(const char *szName) const;
 
     /** Determine a Matrix configuration property has been set.
     * @see HasPropertyMatrix()
      */
-    bool HasPropertyMatrix(const char* szName) const;
+    bool HasPropertyMatrix(const char *szName) const;
 
-protected:
+    bool HasPropertyCallback(const char *szName) const;
 
     /** List of integer properties */
     IntPropertyMap mIntProperties;
@@ -480,23 +486,21 @@ protected:
 
     /** List of Matrix properties */
     MatrixPropertyMap mMatrixProperties;
+
+    CallbackPropertyMap mCallbackProperties;
 };
 
 // ----------------------------------------------------------------------------------
-inline 
-const aiExportDataBlob* Exporter::ExportToBlob(  const aiScene* pScene, const std::string& pFormatId,
-                                                 unsigned int pPreprocessing, const ExportProperties* pProperties)
-{
-    return ExportToBlob(pScene,pFormatId.c_str(),pPreprocessing, pProperties);
+inline const aiExportDataBlob *Exporter::ExportToBlob(const aiScene *pScene, const std::string &pFormatId,
+        unsigned int pPreprocessing, const ExportProperties *pProperties) {
+    return ExportToBlob(pScene, pFormatId.c_str(), pPreprocessing, pProperties);
 }
 
 // ----------------------------------------------------------------------------------
-inline
-aiReturn Exporter :: Export( const aiScene* pScene, const std::string& pFormatId, 
-                                    const std::string& pPath, unsigned int pPreprocessing, 
-                                    const ExportProperties* pProperties)
-{
-    return Export(pScene,pFormatId.c_str(),pPath.c_str(),pPreprocessing, pProperties);
+inline aiReturn Exporter ::Export(const aiScene *pScene, const std::string &pFormatId,
+        const std::string &pPath, unsigned int pPreprocessing,
+        const ExportProperties *pProperties) {
+    return Export(pScene, pFormatId.c_str(), pPath.c_str(), pPreprocessing, pProperties);
 }
 
 } // namespace Assimp
diff --git a/Engine/lib/assimp/include/assimp/GenericProperty.h b/Engine/lib/assimp/include/assimp/GenericProperty.h
index 183ecd519..073d53312 100644
--- a/Engine/lib/assimp/include/assimp/GenericProperty.h
+++ b/Engine/lib/assimp/include/assimp/GenericProperty.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -40,26 +39,30 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
+#pragma once
 #ifndef AI_GENERIC_PROPERTY_H_INCLUDED
 #define AI_GENERIC_PROPERTY_H_INCLUDED
 
-#include <assimp/Importer.hpp>
+#ifdef __GNUC__
+#    pragma GCC system_header
+#endif
+
+#include <assimp/Hash.h>
 #include <assimp/ai_assert.h>
-#include "Hash.h"
+#include <assimp/Importer.hpp>
 
 #include <map>
 
 // ------------------------------------------------------------------------------------------------
 template <class T>
-inline
-bool SetGenericProperty(std::map< unsigned int, T >& list,
-        const char* szName, const T& value) {
+inline bool SetGenericProperty(std::map<unsigned int, T> &list,
+        const char *szName, const T &value) {
     ai_assert(nullptr != szName);
     const uint32_t hash = SuperFastHash(szName);
 
     typename std::map<unsigned int, T>::iterator it = list.find(hash);
-    if (it == list.end())   {
-        list.insert(std::pair<unsigned int, T>( hash, value ));
+    if (it == list.end()) {
+        list.insert(std::pair<unsigned int, T>(hash, value));
         return false;
     }
     (*it).second = value;
@@ -69,9 +72,8 @@ bool SetGenericProperty(std::map< unsigned int, T >& list,
 
 // ------------------------------------------------------------------------------------------------
 template <class T>
-inline
-const T& GetGenericProperty(const std::map< unsigned int, T >& list,
-        const char* szName, const T& errorReturn) {
+inline const T &GetGenericProperty(const std::map<unsigned int, T> &list,
+        const char *szName, const T &errorReturn) {
     ai_assert(nullptr != szName);
     const uint32_t hash = SuperFastHash(szName);
 
@@ -85,24 +87,23 @@ const T& GetGenericProperty(const std::map< unsigned int, T >& list,
 
 // ------------------------------------------------------------------------------------------------
 // Special version for pointer types - they will be deleted when replaced with another value
-// passing NULL removes the whole property
+// passing nullptr removes the whole property
 template <class T>
-inline
-void SetGenericPropertyPtr(std::map< unsigned int, T* >& list,
-        const char* szName, T* value, bool* bWasExisting = nullptr ) {
+inline void SetGenericPropertyPtr(std::map<unsigned int, T *> &list,
+        const char *szName, T *value, bool *bWasExisting = nullptr) {
     ai_assert(nullptr != szName);
     const uint32_t hash = SuperFastHash(szName);
 
-    typename std::map<unsigned int, T*>::iterator it = list.find(hash);
-    if (it == list.end())   {
+    typename std::map<unsigned int, T *>::iterator it = list.find(hash);
+    if (it == list.end()) {
         if (bWasExisting) {
             *bWasExisting = false;
         }
 
-        list.insert(std::pair<unsigned int,T*>( hash, value ));
+        list.insert(std::pair<unsigned int, T *>(hash, value));
         return;
     }
-    if ((*it).second != value)  {
+    if ((*it).second != value) {
         delete (*it).second;
         (*it).second = value;
     }
@@ -116,9 +117,8 @@ void SetGenericPropertyPtr(std::map< unsigned int, T* >& list,
 
 // ------------------------------------------------------------------------------------------------
 template <class T>
-inline
-bool HasGenericProperty(const std::map< unsigned int, T >& list,
-        const char* szName) {
+inline bool HasGenericProperty(const std::map<unsigned int, T> &list,
+        const char *szName) {
     ai_assert(nullptr != szName);
     const uint32_t hash = SuperFastHash(szName);
 
diff --git a/Engine/lib/assimp/include/assimp/GltfMaterial.h b/Engine/lib/assimp/include/assimp/GltfMaterial.h
new file mode 100644
index 000000000..86ca8897c
--- /dev/null
+++ b/Engine/lib/assimp/include/assimp/GltfMaterial.h
@@ -0,0 +1,74 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file GltfMaterial.h
+ *  @brief glTF-specific material macros
+ *  These will be made generic at some future date
+ */
+
+#ifndef AI_GLTFMATERIAL_H_INC
+#define AI_GLTFMATERIAL_H_INC
+
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
+#include <assimp/material.h>
+
+#define AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_METALLICROUGHNESS_TEXTURE aiTextureType_UNKNOWN, 0
+#define AI_MATKEY_GLTF_ALPHAMODE "$mat.gltf.alphaMode", 0, 0
+#define AI_MATKEY_GLTF_ALPHACUTOFF "$mat.gltf.alphaCutoff", 0, 0
+
+#define _AI_MATKEY_GLTF_MAPPINGNAME_BASE "$tex.mappingname"
+#define _AI_MATKEY_GLTF_MAPPINGID_BASE "$tex.mappingid"
+#define _AI_MATKEY_GLTF_MAPPINGFILTER_MAG_BASE "$tex.mappingfiltermag"
+#define _AI_MATKEY_GLTF_MAPPINGFILTER_MIN_BASE "$tex.mappingfiltermin"
+#define _AI_MATKEY_GLTF_SCALE_BASE "$tex.scale"
+#define _AI_MATKEY_GLTF_STRENGTH_BASE "$tex.strength"
+
+#define AI_MATKEY_GLTF_MAPPINGNAME(type, N) _AI_MATKEY_GLTF_MAPPINGNAME_BASE, type, N
+#define AI_MATKEY_GLTF_MAPPINGID(type, N) _AI_MATKEY_GLTF_MAPPINGID_BASE, type, N
+#define AI_MATKEY_GLTF_MAPPINGFILTER_MAG(type, N) _AI_MATKEY_GLTF_MAPPINGFILTER_MAG_BASE, type, N
+#define AI_MATKEY_GLTF_MAPPINGFILTER_MIN(type, N) _AI_MATKEY_GLTF_MAPPINGFILTER_MIN_BASE, type, N
+#define AI_MATKEY_GLTF_TEXTURE_SCALE(type, N) _AI_MATKEY_GLTF_SCALE_BASE, type, N
+#define AI_MATKEY_GLTF_TEXTURE_STRENGTH(type, N) _AI_MATKEY_GLTF_STRENGTH_BASE, type, N
+
+#endif
diff --git a/Engine/lib/assimp/include/assimp/Hash.h b/Engine/lib/assimp/include/assimp/Hash.h
index 30657be19..5a02f5f31 100644
--- a/Engine/lib/assimp/include/assimp/Hash.h
+++ b/Engine/lib/assimp/include/assimp/Hash.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -39,10 +38,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 ----------------------------------------------------------------------
 */
-
+#pragma once
 #ifndef AI_HASH_H_INCLUDED
 #define AI_HASH_H_INCLUDED
 
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
 #include <stdint.h>
 #include <string.h>
 
@@ -72,7 +75,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 inline uint32_t SuperFastHash (const char * data, uint32_t len = 0, uint32_t hash = 0) {
 uint32_t tmp;
 int rem;
-
+size_t offset;
+    
     if (!data) return 0;
     if (!len)len = (uint32_t)::strlen(data);
 
@@ -92,7 +96,11 @@ int rem;
     switch (rem) {
         case 3: hash += get16bits (data);
                 hash ^= hash << 16;
-                hash ^= data[sizeof (uint16_t)] << 18;
+                offset = static_cast<size_t>(sizeof(uint16_t));
+                if (offset < 0) {
+                    return 0;
+                }
+                hash ^= data[offset] << 18;
                 hash += hash >> 11;
                 break;
         case 2: hash += get16bits (data);
diff --git a/Engine/lib/assimp/include/assimp/IOStream.hpp b/Engine/lib/assimp/include/assimp/IOStream.hpp
index 0623d0f70..5e19f5176 100644
--- a/Engine/lib/assimp/include/assimp/IOStream.hpp
+++ b/Engine/lib/assimp/include/assimp/IOStream.hpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -48,14 +46,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_IOSTREAM_H_INC
 #define AI_IOSTREAM_H_INC
 
-#include "types.h"
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
+#include <assimp/types.h>
 
 #ifndef __cplusplus
 #   error This header requires C++ to be used. aiFileIO.h is the \
     corresponding C interface.
 #endif
 
-namespace Assimp    {
+namespace Assimp {
 
 // ----------------------------------------------------------------------------------
 /** @brief CPP-API: Class to handle file I/O for C++
@@ -125,13 +127,13 @@ public:
 }; //! class IOStream
 
 // ----------------------------------------------------------------------------------
-inline
+AI_FORCE_INLINE
 IOStream::IOStream() AI_NO_EXCEPT {
     // empty
 }
 
 // ----------------------------------------------------------------------------------
-inline
+AI_FORCE_INLINE
 IOStream::~IOStream() {
     // empty
 }
diff --git a/Engine/lib/assimp/include/assimp/IOStreamBuffer.h b/Engine/lib/assimp/include/assimp/IOStreamBuffer.h
index 58abd97a0..09ca1c962 100644
--- a/Engine/lib/assimp/include/assimp/IOStreamBuffer.h
+++ b/Engine/lib/assimp/include/assimp/IOStreamBuffer.h
@@ -1,11 +1,8 @@
-#pragma once
-
 /*
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -42,11 +39,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
+#pragma once
+#ifndef AI_IOSTREAMBUFFER_H_INC
+#define AI_IOSTREAMBUFFER_H_INC
+
+#ifdef __GNUC__
+#pragma GCC system_header
+#endif
+
+#include <assimp/ParsingUtils.h>
 #include <assimp/types.h>
 #include <assimp/IOStream.hpp>
 
-#include "ParsingUtils.h"
-
 #include <vector>
 
 namespace Assimp {
@@ -55,11 +59,11 @@ namespace Assimp {
 /**
  *  Implementation of a cached stream buffer.
  */
-template<class T>
+template <class T>
 class IOStreamBuffer {
 public:
     /// @brief  The class constructor.
-    IOStreamBuffer( size_t cache = 4096 * 4096 );
+    IOStreamBuffer(size_t cache = 4096 * 4096);
 
     /// @brief  The class destructor.
     ~IOStreamBuffer();
@@ -67,7 +71,7 @@ public:
     /// @brief  Will open the cached access for a given stream.
     /// @param  stream      The stream to cache.
     /// @return true if successful.
-    bool open( IOStream *stream );
+    bool open(IOStream *stream);
 
     /// @brief  Will close the cached access.
     /// @return true if successful.
@@ -76,7 +80,7 @@ public:
     /// @brief  Returns the file-size.
     /// @return The file-size.
     size_t size() const;
-    
+
     /// @brief  Returns the cache size.
     /// @return The cache size.
     size_t cacheSize() const;
@@ -100,7 +104,7 @@ public:
     /// @brief  Will read the next line.
     /// @param  buffer      The buffer for the next line.
     /// @return true if successful.
-    bool getNextDataLine( std::vector<T> &buffer, T continuationToken );
+    bool getNextDataLine(std::vector<T> &buffer, T continuationToken);
 
     /// @brief  Will read the next line ascii or binary end line char.
     /// @param  buffer      The buffer for the next line.
@@ -110,7 +114,7 @@ public:
     /// @brief  Will read the next block.
     /// @param  buffer      The buffer for the next block.
     /// @return true if successful.
-    bool getNextBlock( std::vector<T> &buffer );
+    bool getNextBlock(std::vector<T> &buffer);
 
 private:
     IOStream *m_stream;
@@ -123,95 +127,92 @@ private:
     size_t m_filePos;
 };
 
-template<class T>
-inline
-IOStreamBuffer<T>::IOStreamBuffer( size_t cache )
-: m_stream( nullptr )
-, m_filesize( 0 )
-, m_cacheSize( cache )
-, m_numBlocks( 0 )
-, m_blockIdx( 0 )
-, m_cachePos( 0 )
-, m_filePos( 0 ) {
-    m_cache.resize( cache );
-    std::fill( m_cache.begin(), m_cache.end(), '\n' );
+template <class T>
+AI_FORCE_INLINE IOStreamBuffer<T>::IOStreamBuffer(size_t cache) :
+        m_stream(nullptr),
+        m_filesize(0),
+        m_cacheSize(cache),
+        m_numBlocks(0),
+        m_blockIdx(0),
+        m_cachePos(0),
+        m_filePos(0) {
+    m_cache.resize(cache);
+    std::fill(m_cache.begin(), m_cache.end(), '\n');
 }
 
-template<class T>
-inline
-IOStreamBuffer<T>::~IOStreamBuffer() {
+template <class T>
+AI_FORCE_INLINE IOStreamBuffer<T>::~IOStreamBuffer() {
     // empty
 }
 
-template<class T>
-inline
-bool IOStreamBuffer<T>::open( IOStream *stream ) {
+template <class T>
+AI_FORCE_INLINE bool IOStreamBuffer<T>::open(IOStream *stream) {
     //  file still opened!
-    if ( nullptr != m_stream ) {
+    if (nullptr != m_stream) {
         return false;
     }
 
     //  Invalid stream pointer
-    if ( nullptr == stream ) {
+    if (nullptr == stream) {
         return false;
     }
 
     m_stream = stream;
     m_filesize = m_stream->FileSize();
-    if ( m_filesize == 0 ) {
+    if (m_filesize == 0) {
         return false;
     }
-    if ( m_filesize < m_cacheSize ) {
+    if (m_filesize < m_cacheSize) {
         m_cacheSize = m_filesize;
     }
 
     m_numBlocks = m_filesize / m_cacheSize;
-    if ( ( m_filesize % m_cacheSize ) > 0 ) {
+    if ((m_filesize % m_cacheSize) > 0) {
         m_numBlocks++;
     }
 
     return true;
 }
 
-template<class T>
-inline
-bool IOStreamBuffer<T>::close() {
-    if ( nullptr == m_stream ) {
+template <class T>
+AI_FORCE_INLINE bool IOStreamBuffer<T>::close() {
+    if (nullptr == m_stream) {
         return false;
     }
 
     // init counters and state vars
-    m_stream    = nullptr;
-    m_filesize  = 0;
+    m_stream = nullptr;
+    m_filesize = 0;
     m_numBlocks = 0;
-    m_blockIdx  = 0;
-    m_cachePos  = 0;
-    m_filePos   = 0;
+    m_blockIdx = 0;
+    m_cachePos = 0;
+    m_filePos = 0;
 
     return true;
 }
 
-template<class T>
-inline
-size_t IOStreamBuffer<T>::size() const {
+template <class T>
+AI_FORCE_INLINE
+        size_t
+        IOStreamBuffer<T>::size() const {
     return m_filesize;
 }
 
-template<class T>
-inline
-size_t IOStreamBuffer<T>::cacheSize() const {
+template <class T>
+AI_FORCE_INLINE
+        size_t
+        IOStreamBuffer<T>::cacheSize() const {
     return m_cacheSize;
 }
 
-template<class T>
-inline
-bool IOStreamBuffer<T>::readNextBlock() {
-    m_stream->Seek( m_filePos, aiOrigin_SET );
-    size_t readLen = m_stream->Read( &m_cache[ 0 ], sizeof( T ), m_cacheSize );
-    if ( readLen == 0 ) {
+template <class T>
+AI_FORCE_INLINE bool IOStreamBuffer<T>::readNextBlock() {
+    m_stream->Seek(m_filePos, aiOrigin_SET);
+    size_t readLen = m_stream->Read(&m_cache[0], sizeof(T), m_cacheSize);
+    if (readLen == 0) {
         return false;
     }
-    if ( readLen < m_cacheSize ) {
+    if (readLen < m_cacheSize) {
         m_cacheSize = readLen;
     }
     m_filePos += m_cacheSize;
@@ -221,88 +222,78 @@ bool IOStreamBuffer<T>::readNextBlock() {
     return true;
 }
 
-template<class T>
-inline
-size_t IOStreamBuffer<T>::getNumBlocks() const {
+template <class T>
+AI_FORCE_INLINE size_t IOStreamBuffer<T>::getNumBlocks() const {
     return m_numBlocks;
 }
 
-template<class T>
-inline
-size_t IOStreamBuffer<T>::getCurrentBlockIndex() const {
+template <class T>
+AI_FORCE_INLINE size_t IOStreamBuffer<T>::getCurrentBlockIndex() const {
     return m_blockIdx;
 }
 
-template<class T>
-inline
-size_t IOStreamBuffer<T>::getFilePos() const {
+template <class T>
+AI_FORCE_INLINE size_t IOStreamBuffer<T>::getFilePos() const {
     return m_filePos;
 }
 
-template<class T>
-inline
-bool IOStreamBuffer<T>::getNextDataLine( std::vector<T> &buffer, T continuationToken ) {
-    buffer.resize( m_cacheSize );
-    if ( m_cachePos >= m_cacheSize || 0 == m_filePos ) {
-        if ( !readNextBlock() ) {
+template <class T>
+AI_FORCE_INLINE bool IOStreamBuffer<T>::getNextDataLine(std::vector<T> &buffer, T continuationToken) {
+    buffer.resize(m_cacheSize);
+    if (m_cachePos >= m_cacheSize || 0 == m_filePos) {
+        if (!readNextBlock()) {
             return false;
         }
     }
 
-    bool continuationFound( false );
     size_t i = 0;
-    for( ;; ) {
-        if ( continuationToken == m_cache[ m_cachePos ] ) {
-            continuationFound = true;
+    for (;;) {
+        if (continuationToken == m_cache[m_cachePos] && IsLineEnd(m_cache[m_cachePos + 1])) {
             ++m_cachePos;
-        }
-        if ( IsLineEnd( m_cache[ m_cachePos ] ) ) {
-            if ( !continuationFound ) {
-                // the end of the data line
-                break;
-            } else {
-                // skip line end
-                while ( m_cache[m_cachePos] != '\n') {
-                    ++m_cachePos;
-                }
+            while (m_cache[m_cachePos] != '\n') {
                 ++m_cachePos;
-                continuationFound = false;
             }
+            ++m_cachePos;
+        } else if (IsLineEnd(m_cache[m_cachePos])) {
+            break;
         }
 
-        buffer[ i ] = m_cache[ m_cachePos ];
+        buffer[i] = m_cache[m_cachePos];
         ++m_cachePos;
         ++i;
+
+        if(i == buffer.size()) {
+            buffer.resize(buffer.size() * 2);
+        }
+
         if (m_cachePos >= size()) {
             break;
         }
-        if ( m_cachePos >= m_cacheSize ) {
-            if ( !readNextBlock() ) {
+        if (m_cachePos >= m_cacheSize) {
+            if (!readNextBlock()) {
                 return false;
             }
         }
     }
-    
-    buffer[ i ] = '\n';
+
+    buffer[i] = '\n';
     ++m_cachePos;
 
     return true;
 }
 
-static inline
-bool isEndOfCache( size_t pos, size_t cacheSize ) {
-    return ( pos == cacheSize );
+static AI_FORCE_INLINE bool isEndOfCache(size_t pos, size_t cacheSize) {
+    return (pos == cacheSize);
 }
 
-template<class T>
-inline
-bool IOStreamBuffer<T>::getNextLine(std::vector<T> &buffer) {
+template <class T>
+AI_FORCE_INLINE bool IOStreamBuffer<T>::getNextLine(std::vector<T> &buffer) {
     buffer.resize(m_cacheSize);
-    if ( isEndOfCache( m_cachePos, m_cacheSize ) || 0 == m_filePos) {
-       if (!readNextBlock()) {
-          return false;
-       }
-      }
+    if (isEndOfCache(m_cachePos, m_cacheSize) || 0 == m_filePos) {
+        if (!readNextBlock()) {
+            return false;
+        }
+    }
 
     if (IsLineEnd(m_cache[m_cachePos])) {
         // skip line end
@@ -310,18 +301,23 @@ bool IOStreamBuffer<T>::getNextLine(std::vector<T> &buffer) {
             ++m_cachePos;
         }
         ++m_cachePos;
-        if ( isEndOfCache( m_cachePos, m_cacheSize ) ) {
-            if ( !readNextBlock() ) {
+        if (isEndOfCache(m_cachePos, m_cacheSize)) {
+            if (!readNextBlock()) {
                 return false;
             }
         }
     }
 
-    size_t i( 0 );
-    while (!IsLineEnd(m_cache[ m_cachePos ])) {
-        buffer[i] = m_cache[ m_cachePos ];
+    size_t i(0);
+    while (!IsLineEnd(m_cache[m_cachePos])) {
+        buffer[i] = m_cache[m_cachePos];
         ++m_cachePos;
         ++i;
+
+        if(i == buffer.size()) {
+            buffer.resize(buffer.size() * 2);
+        }
+
         if (m_cachePos >= m_cacheSize) {
             if (!readNextBlock()) {
                 return false;
@@ -334,15 +330,14 @@ bool IOStreamBuffer<T>::getNextLine(std::vector<T> &buffer) {
     return true;
 }
 
-template<class T>
-inline
-bool IOStreamBuffer<T>::getNextBlock( std::vector<T> &buffer) {
+template <class T>
+AI_FORCE_INLINE bool IOStreamBuffer<T>::getNextBlock(std::vector<T> &buffer) {
     // Return the last block-value if getNextLine was used before
-    if ( 0 != m_cachePos ) {      
-        buffer = std::vector<T>( m_cache.begin() + m_cachePos, m_cache.end() );
+    if (0 != m_cachePos) {
+        buffer = std::vector<T>(m_cache.begin() + m_cachePos, m_cache.end());
         m_cachePos = 0;
     } else {
-        if ( !readNextBlock() ) {
+        if (!readNextBlock()) {
             return false;
         }
 
@@ -352,4 +347,6 @@ bool IOStreamBuffer<T>::getNextBlock( std::vector<T> &buffer) {
     return true;
 }
 
-} // !ns Assimp
+} // namespace Assimp
+
+#endif // AI_IOSTREAMBUFFER_H_INC
diff --git a/Engine/lib/assimp/include/assimp/IOSystem.hpp b/Engine/lib/assimp/include/assimp/IOSystem.hpp
index 78139c283..e67a07515 100644
--- a/Engine/lib/assimp/include/assimp/IOSystem.hpp
+++ b/Engine/lib/assimp/include/assimp/IOSystem.hpp
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -50,6 +48,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_IOSYSTEM_H_INC
 #define AI_IOSYSTEM_H_INC
 
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
 #ifndef __cplusplus
 #   error This header requires C++ to be used. aiFileIO.h is the \
     corresponding C interface.
@@ -58,9 +60,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "types.h"
 
 #ifdef _WIN32
-#   include <direct.h>  
-#   include <stdlib.h>  
-#   include <stdio.h>  
+#   include <direct.h>
+#   include <cstdlib>
+#   include <cstdio>
 #else
 #   include <sys/stat.h>
 #   include <sys/types.h>
@@ -71,7 +73,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 namespace Assimp    {
 
-    class IOStream;
+class IOStream;
 
 // ---------------------------------------------------------------------------
 /** @brief CPP-API: Interface to the file system.
@@ -80,7 +82,7 @@ namespace Assimp    {
  *  to the importer library. If you implement this interface, you also want to
  *  supply a custom implementation for IOStream.
  *
- *  @see Importer::SetIOHandler() 
+ *  @see Importer::SetIOHandler()
  */
 class ASSIMP_API IOSystem
 #ifndef SWIG
@@ -222,22 +224,26 @@ public:
      */
     virtual bool ChangeDirectory( const std::string &path );
 
-    virtual bool DeleteFile( const std::string &file );
+    // -------------------------------------------------------------------
+    /**
+     *  @brief  Will delete the given file.
+     *  @param file     [in] The filename
+     *  @return true, if the file wase deleted, false if not.
+     */
+    virtual bool DeleteFile(const std::string &file);
 
 private:
     std::vector<std::string> m_pathStack;
 };
 
 // ----------------------------------------------------------------------------
-AI_FORCE_INLINE
-IOSystem::IOSystem() AI_NO_EXCEPT
-: m_pathStack() {
+AI_FORCE_INLINE IOSystem::IOSystem() AI_NO_EXCEPT :
+        m_pathStack() {
     // empty
 }
 
 // ----------------------------------------------------------------------------
-AI_FORCE_INLINE
-IOSystem::~IOSystem() {
+AI_FORCE_INLINE IOSystem::~IOSystem() {
     // empty
 }
 
@@ -248,8 +254,7 @@ IOSystem::~IOSystem() {
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
-AI_FORCE_INLINE
-IOStream* IOSystem::Open(const std::string& pFile, const std::string& pMode) {
+AI_FORCE_INLINE IOStream* IOSystem::Open(const std::string& pFile, const std::string& pMode) {
     // NOTE:
     // For compatibility, interface was changed to const char* to
     // avoid crashes between binary incompatible STL versions
@@ -257,8 +262,7 @@ IOStream* IOSystem::Open(const std::string& pFile, const std::string& pMode) {
 }
 
 // ----------------------------------------------------------------------------
-AI_FORCE_INLINE
-bool IOSystem::Exists( const std::string& pFile) const {
+AI_FORCE_INLINE bool IOSystem::Exists( const std::string& pFile) const {
     // NOTE:
     // For compatibility, interface was changed to const char* to
     // avoid crashes between binary incompatible STL versions
@@ -266,8 +270,7 @@ bool IOSystem::Exists( const std::string& pFile) const {
 }
 
 // ----------------------------------------------------------------------------
-AI_FORCE_INLINE
-bool IOSystem::ComparePaths (const std::string& one, const std::string& second) const {
+AI_FORCE_INLINE bool IOSystem::ComparePaths(const std::string& one, const std::string& second) const {
     // NOTE:
     // For compatibility, interface was changed to const char* to
     // avoid crashes between binary incompatible STL versions
@@ -275,8 +278,7 @@ bool IOSystem::ComparePaths (const std::string& one, const std::string& second)
 }
 
 // ----------------------------------------------------------------------------
-AI_FORCE_INLINE
-bool IOSystem::PushDirectory( const std::string &path ) {
+AI_FORCE_INLINE bool IOSystem::PushDirectory( const std::string &path ) {
     if ( path.empty() ) {
         return false;
     }
@@ -287,24 +289,12 @@ bool IOSystem::PushDirectory( const std::string &path ) {
 }
 
 // ----------------------------------------------------------------------------
-AI_FORCE_INLINE
-const std::string &IOSystem::CurrentDirectory() const {
-    if ( m_pathStack.empty() ) {
-        static const std::string Dummy("");
-        return Dummy;
-    }
-    return m_pathStack[ m_pathStack.size()-1 ];
-}
-
-// ----------------------------------------------------------------------------
-AI_FORCE_INLINE
-size_t IOSystem::StackSize() const {
+AI_FORCE_INLINE size_t IOSystem::StackSize() const {
     return m_pathStack.size();
 }
 
 // ----------------------------------------------------------------------------
-AI_FORCE_INLINE
-bool IOSystem::PopDirectory() {
+AI_FORCE_INLINE bool IOSystem::PopDirectory() {
     if ( m_pathStack.empty() ) {
         return false;
     }
@@ -315,8 +305,7 @@ bool IOSystem::PopDirectory() {
 }
 
 // ----------------------------------------------------------------------------
-AI_FORCE_INLINE
-bool IOSystem::CreateDirectory( const std::string &path ) {
+AI_FORCE_INLINE bool IOSystem::CreateDirectory( const std::string &path ) {
     if ( path.empty() ) {
         return false;
     }
@@ -329,8 +318,7 @@ bool IOSystem::CreateDirectory( const std::string &path ) {
 }
 
 // ----------------------------------------------------------------------------
-AI_FORCE_INLINE
-bool IOSystem::ChangeDirectory( const std::string &path ) {
+AI_FORCE_INLINE bool IOSystem::ChangeDirectory( const std::string &path ) {
     if ( path.empty() ) {
         return false;
     }
@@ -344,8 +332,7 @@ bool IOSystem::ChangeDirectory( const std::string &path ) {
 
 
 // ----------------------------------------------------------------------------
-AI_FORCE_INLINE
-bool IOSystem::DeleteFile( const std::string &file ) {
+AI_FORCE_INLINE bool IOSystem::DeleteFile( const std::string &file ) {
     if ( file.empty() ) {
         return false;
     }
diff --git a/Engine/lib/assimp/include/assimp/Importer.hpp b/Engine/lib/assimp/include/assimp/Importer.hpp
index 4941df412..05a15139a 100644
--- a/Engine/lib/assimp/include/assimp/Importer.hpp
+++ b/Engine/lib/assimp/include/assimp/Importer.hpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -48,36 +48,42 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_ASSIMP_HPP_INC
 #define AI_ASSIMP_HPP_INC
 
+#ifdef __GNUC__
+#pragma GCC system_header
+#endif
+
 #ifndef __cplusplus
-#   error This header requires C++ to be used. Use assimp.h for plain C.
+#error This header requires C++ to be used. Use assimp.h for plain C.
 #endif // __cplusplus
 
 // Public ASSIMP data structures
 #include <assimp/types.h>
 
-namespace Assimp    {
-    // =======================================================================
-    // Public interface to Assimp
-    class Importer;
-    class IOStream;
-    class IOSystem;
-    class ProgressHandler;
+#include <exception>
 
-    // =======================================================================
-    // Plugin development
-    //
-    // Include the following headers for the declarations:
-    // BaseImporter.h
-    // BaseProcess.h
-    class BaseImporter;
-    class BaseProcess;
-    class SharedPostProcessInfo;
-    class BatchLoader;
+namespace Assimp {
+// =======================================================================
+// Public interface to Assimp
+class Importer;
+class IOStream;
+class IOSystem;
+class ProgressHandler;
 
-    // =======================================================================
-    // Holy stuff, only for members of the high council of the Jedi.
-    class ImporterPimpl;
-} //! namespace Assimp
+// =======================================================================
+// Plugin development
+//
+// Include the following headers for the declarations:
+// BaseImporter.h
+// BaseProcess.h
+class BaseImporter;
+class BaseProcess;
+class SharedPostProcessInfo;
+class BatchLoader;
+
+// =======================================================================
+// Holy stuff, only for members of the high council of the Jedi.
+class ImporterPimpl;
+} // namespace Assimp
 
 #define AI_PROPERTY_WAS_NOT_EXISTING 0xffffffff
 
@@ -87,7 +93,7 @@ struct aiScene;
 struct aiImporterDesc;
 
 /** @namespace Assimp Assimp's CPP-API and all internal APIs */
-namespace Assimp    {
+namespace Assimp {
 
 // ----------------------------------------------------------------------------------
 /** CPP-API: The Importer class forms an C++ interface to the functionality of the
@@ -97,7 +103,7 @@ namespace Assimp    {
 * If the import succeeds, the function returns a pointer to the imported data.
 * The data remains property of the object, it is intended to be accessed
 * read-only. The imported data will be destroyed along with the Importer
-* object. If the import fails, ReadFile() returns a NULL pointer. In this
+* object. If the import fails, ReadFile() returns a nullptr pointer. In this
 * case you can retrieve a human-readable error description be calling
 * GetErrorString(). You can call ReadFile() multiple times with a single Importer
 * instance. Actually, constructing Importer objects involves quite many
@@ -113,7 +119,7 @@ namespace Assimp    {
 * @note One Importer instance is not thread-safe. If you use multiple
 * threads for loading, each thread should maintain its own Importer instance.
 */
-class ASSIMP_API Importer   {
+class ASSIMP_API Importer {
 public:
     /**
      *  @brief The upper limit for hints.
@@ -121,7 +127,6 @@ public:
     static const unsigned int MaxLenHint = 200;
 
 public:
-
     // -------------------------------------------------------------------
     /** Constructor. Creates an empty importer object.
      *
@@ -137,7 +142,7 @@ public:
      * If this Importer owns a scene it won't be copied.
      * Call ReadFile() to start the import process.
      */
-    Importer(const Importer& other)=delete;
+    Importer(const Importer &other) = delete;
 
     // -------------------------------------------------------------------
     /** Assignment operator has been deleted
@@ -150,7 +155,6 @@ public:
      */
     ~Importer();
 
-
     // -------------------------------------------------------------------
     /** Registers a new loader.
      *
@@ -160,7 +164,7 @@ public:
      * @return AI_SUCCESS if the loader has been added. The registration
      *   fails if there is already a loader for a specific file extension.
      */
-    aiReturn RegisterLoader(BaseImporter* pImp);
+    aiReturn RegisterLoader(BaseImporter *pImp);
 
     // -------------------------------------------------------------------
     /** Unregisters a loader.
@@ -171,7 +175,7 @@ public:
      *   if the #Importer instance is used by more than one thread) or
      *   if it has not yet been registered.
      */
-    aiReturn UnregisterLoader(BaseImporter* pImp);
+    aiReturn UnregisterLoader(BaseImporter *pImp);
 
     // -------------------------------------------------------------------
     /** Registers a new post-process step.
@@ -184,7 +188,7 @@ public:
      *   deleted with the Importer instance.
      * @return AI_SUCCESS if the step has been added correctly.
      */
-    aiReturn RegisterPPStep(BaseProcess* pImp);
+    aiReturn RegisterPPStep(BaseProcess *pImp);
 
     // -------------------------------------------------------------------
     /** Unregisters a post-process step.
@@ -195,7 +199,7 @@ public:
      *   if the #Importer instance is used by more than one thread) or
      *   if it has not yet been registered.
      */
-    aiReturn UnregisterPPStep(BaseProcess* pImp);
+    aiReturn UnregisterPPStep(BaseProcess *pImp);
 
     // -------------------------------------------------------------------
     /** Set an integer configuration property.
@@ -210,7 +214,7 @@ public:
      *   floating-point property has no effect - the loader will call
      *   GetPropertyFloat() to read the property, but it won't be there.
      */
-    bool SetPropertyInteger(const char* szName, int iValue);
+    bool SetPropertyInteger(const char *szName, int iValue);
 
     // -------------------------------------------------------------------
     /** Set a boolean configuration property. Boolean properties
@@ -219,27 +223,33 @@ public:
      *  #GetPropertyBool and vice versa.
      * @see SetPropertyInteger()
      */
-    bool SetPropertyBool(const char* szName, bool value)    {
-        return SetPropertyInteger(szName,value);
+    bool SetPropertyBool(const char *szName, bool value) {
+        return SetPropertyInteger(szName, value);
     }
 
     // -------------------------------------------------------------------
     /** Set a floating-point configuration property.
      * @see SetPropertyInteger()
      */
-    bool SetPropertyFloat(const char* szName, ai_real fValue);
+    bool SetPropertyFloat(const char *szName, ai_real fValue);
 
     // -------------------------------------------------------------------
     /** Set a string configuration property.
      * @see SetPropertyInteger()
      */
-    bool SetPropertyString(const char* szName, const std::string& sValue);
+    bool SetPropertyString(const char *szName, const std::string &sValue);
 
     // -------------------------------------------------------------------
     /** Set a matrix configuration property.
      * @see SetPropertyInteger()
      */
-    bool SetPropertyMatrix(const char* szName, const aiMatrix4x4& sValue);
+    bool SetPropertyMatrix(const char *szName, const aiMatrix4x4 &sValue);
+
+    // -------------------------------------------------------------------
+    /** Set a pointer configuration property.
+     * @see SetPropertyInteger()
+     */
+    bool SetPropertyPointer(const char *szName, void *sValue);
 
     // -------------------------------------------------------------------
     /** Get a configuration property.
@@ -254,8 +264,8 @@ public:
      *   floating-point property has no effect - the loader will call
      *   GetPropertyFloat() to read the property, but it won't be there.
      */
-    int GetPropertyInteger(const char* szName,
-        int iErrorReturn = 0xffffffff) const;
+    int GetPropertyInteger(const char *szName,
+            int iErrorReturn = 0xffffffff) const;
 
     // -------------------------------------------------------------------
     /** Get a boolean configuration property. Boolean properties
@@ -264,16 +274,16 @@ public:
      *  #GetPropertyBool and vice versa.
      * @see GetPropertyInteger()
      */
-    bool GetPropertyBool(const char* szName, bool bErrorReturn = false) const {
-        return GetPropertyInteger(szName,bErrorReturn)!=0;
+    bool GetPropertyBool(const char *szName, bool bErrorReturn = false) const {
+        return GetPropertyInteger(szName, bErrorReturn) != 0;
     }
 
     // -------------------------------------------------------------------
     /** Get a floating-point configuration property
      * @see GetPropertyInteger()
      */
-    ai_real GetPropertyFloat(const char* szName,
-        ai_real fErrorReturn = 10e10) const;
+    ai_real GetPropertyFloat(const char *szName,
+            ai_real fErrorReturn = 10e10) const;
 
     // -------------------------------------------------------------------
     /** Get a string configuration property
@@ -281,8 +291,8 @@ public:
      *  The return value remains valid until the property is modified.
      * @see GetPropertyInteger()
      */
-    const std::string GetPropertyString(const char* szName,
-        const std::string& sErrorReturn = "") const;
+    std::string GetPropertyString(const char *szName,
+            const std::string &sErrorReturn = std::string()) const;
 
     // -------------------------------------------------------------------
     /** Get a matrix configuration property
@@ -290,8 +300,17 @@ public:
      *  The return value remains valid until the property is modified.
      * @see GetPropertyInteger()
      */
-    const aiMatrix4x4 GetPropertyMatrix(const char* szName,
-        const aiMatrix4x4& sErrorReturn = aiMatrix4x4()) const;
+    aiMatrix4x4 GetPropertyMatrix(const char *szName,
+            const aiMatrix4x4 &sErrorReturn = aiMatrix4x4()) const;
+
+    // -------------------------------------------------------------------
+    /** Get a pointer configuration property
+     *
+     *  The return value remains valid until the property is modified.
+     * @see GetPropertyInteger()
+     */
+    void* GetPropertyPointer(const char *szName,
+        void *sErrorReturn = nullptr) const;
 
     // -------------------------------------------------------------------
     /** Supplies a custom IO handler to the importer to use to open and
@@ -302,13 +321,13 @@ public:
      *
      * The Importer takes ownership of the object and will destroy it
      * afterwards. The previously assigned handler will be deleted.
-     * Pass NULL to take again ownership of your IOSystem and reset Assimp
+     * Pass nullptr to take again ownership of your IOSystem and reset Assimp
      * to use its default implementation.
      *
      * @param pIOHandler The IO handler to be used in all file accesses
      *   of the Importer.
      */
-    void SetIOHandler( IOSystem* pIOHandler);
+    void SetIOHandler(IOSystem *pIOHandler);
 
     // -------------------------------------------------------------------
     /** Retrieves the IO handler that is currently set.
@@ -316,9 +335,9 @@ public:
      * interface is the default IO handler provided by ASSIMP. The default
      * handler is active as long the application doesn't supply its own
      * custom IO handler via #SetIOHandler().
-     * @return A valid IOSystem interface, never NULL.
+     * @return A valid IOSystem interface, never nullptr.
      */
-    IOSystem* GetIOHandler() const;
+    IOSystem *GetIOHandler() const;
 
     // -------------------------------------------------------------------
     /** Checks whether a default IO handler is active
@@ -335,11 +354,11 @@ public:
      *  isn't as periodically as you'd like it to have ...).
      *  This can be used to implement progress bars and loading
      *  timeouts.
-     *  @param pHandler Progress callback interface. Pass NULL to
+     *  @param pHandler Progress callback interface. Pass nullptr to
      *    disable progress reporting.
      *  @note Progress handlers can be used to abort the loading
      *    at almost any time.*/
-    void SetProgressHandler ( ProgressHandler* pHandler );
+    void SetProgressHandler(ProgressHandler *pHandler);
 
     // -------------------------------------------------------------------
     /** Retrieves the progress handler that is currently set.
@@ -347,9 +366,9 @@ public:
      * interface is the default handler provided by ASSIMP. The default
      * handler is active as long the application doesn't supply its own
      * custom handler via #SetProgressHandler().
-     * @return A valid ProgressHandler interface, never NULL.
+     * @return A valid ProgressHandler interface, never nullptr.
      */
-    ProgressHandler* GetProgressHandler() const;
+    ProgressHandler *GetProgressHandler() const;
 
     // -------------------------------------------------------------------
     /** Checks whether a default progress handler is active
@@ -379,7 +398,7 @@ public:
      * If the call succeeds, the contents of the file are returned as a
      * pointer to an aiScene object. The returned data is intended to be
      * read-only, the importer object keeps ownership of the data and will
-     * destroy it upon destruction. If the import fails, NULL is returned.
+     * destroy it upon destruction. If the import fails, nullptr is returned.
      * A human-readable error description can be retrieved by calling
      * GetErrorString(). The previous scene will be deleted during this call.
      * @param pFile Path and filename to the file to be imported.
@@ -388,16 +407,16 @@ public:
      *   #aiPostProcessSteps flags. If you wish to inspect the imported
      *   scene first in order to fine-tune your post-processing setup,
      *   consider to use #ApplyPostProcessing().
-     * @return A pointer to the imported data, NULL if the import failed.
+     * @return A pointer to the imported data, nullptr if the import failed.
      *   The pointer to the scene remains in possession of the Importer
      *   instance. Use GetOrphanedScene() to take ownership of it.
      *
      * @note Assimp is able to determine the file format of a file
      * automatically.
      */
-    const aiScene* ReadFile(
-        const char* pFile,
-        unsigned int pFlags);
+    const aiScene *ReadFile(
+            const char *pFile,
+            unsigned int pFlags);
 
     // -------------------------------------------------------------------
     /** Reads the given file from a memory buffer and returns its
@@ -406,7 +425,7 @@ public:
      * If the call succeeds, the contents of the file are returned as a
      * pointer to an aiScene object. The returned data is intended to be
      * read-only, the importer object keeps ownership of the data and will
-     * destroy it upon destruction. If the import fails, NULL is returned.
+     * destroy it upon destruction. If the import fails, nullptr is returned.
      * A human-readable error description can be retrieved by calling
      * GetErrorString(). The previous scene will be deleted during this call.
      * Calling this method doesn't affect the active IOSystem.
@@ -424,7 +443,7 @@ public:
      *   the request, the library continues and tries to determine the
      *   file format on its own, a task that may or may not be successful.
      *   Check the return value, and you'll know ...
-     * @return A pointer to the imported data, NULL if the import failed.
+     * @return A pointer to the imported data, nullptr if the import failed.
      *   The pointer to the scene remains in possession of the Importer
      *   instance. Use GetOrphanedScene() to take ownership of it.
      *
@@ -436,11 +455,11 @@ public:
      * a custom IOSystem to make Assimp find these files and use
      * the regular ReadFile() API.
      */
-    const aiScene* ReadFileFromMemory(
-        const void* pBuffer,
-        size_t pLength,
-        unsigned int pFlags,
-        const char* pHint = "");
+    const aiScene *ReadFileFromMemory(
+            const void *pBuffer,
+            size_t pLength,
+            unsigned int pFlags,
+            const char *pHint = "");
 
     // -------------------------------------------------------------------
     /** Apply post-processing to an already-imported scene.
@@ -452,17 +471,17 @@ public:
      *   #aiPostProcessSteps flags.
      *  @return A pointer to the post-processed data. This is still the
      *   same as the pointer returned by #ReadFile(). However, if
-     *   post-processing fails, the scene could now be NULL.
+     *   post-processing fails, the scene could now be nullptr.
      *   That's quite a rare case, post processing steps are not really
      *   designed to 'fail'. To be exact, the #aiProcess_ValidateDS
      *   flag is currently the only post processing step which can actually
-     *   cause the scene to be reset to NULL.
+     *   cause the scene to be reset to nullptr.
      *
      *  @note The method does nothing if no scene is currently bound
      *    to the #Importer instance.  */
-    const aiScene* ApplyPostProcessing(unsigned int pFlags);
+    const aiScene *ApplyPostProcessing(unsigned int pFlags);
 
-    const aiScene* ApplyCustomizedPostProcessing( BaseProcess *rootProcess, bool requestValidation );
+    const aiScene *ApplyCustomizedPostProcessing(BaseProcess *rootProcess, bool requestValidation);
 
     // -------------------------------------------------------------------
     /** @brief Reads the given file and returns its contents if successful.
@@ -470,9 +489,9 @@ public:
      * This function is provided for backward compatibility.
      * See the const char* version for detailed docs.
      * @see ReadFile(const char*, pFlags)  */
-    const aiScene* ReadFile(
-        const std::string& pFile,
-        unsigned int pFlags);
+    const aiScene *ReadFile(
+            const std::string &pFile,
+            unsigned int pFlags);
 
     // -------------------------------------------------------------------
     /** Frees the current scene.
@@ -480,33 +499,42 @@ public:
      *  The function does nothing if no scene has previously been
      *  read via ReadFile(). FreeScene() is called automatically by the
      *  destructor and ReadFile() itself.  */
-    void FreeScene( );
+    void FreeScene();
 
     // -------------------------------------------------------------------
     /** Returns an error description of an error that occurred in ReadFile().
      *
      * Returns an empty string if no error occurred.
      * @return A description of the last error, an empty string if no
-     *   error occurred. The string is never NULL.
+     *   error occurred. The string is never nullptr.
      *
      * @note The returned function remains valid until one of the
      * following methods is called: #ReadFile(), #FreeScene(). */
-    const char* GetErrorString() const;
+    const char *GetErrorString() const;
+
+    // -------------------------------------------------------------------
+    /** Returns an exception if one occurred during import.
+     *
+     * @return The last exception which occurred.
+     *
+     * @note The returned value remains valid until one of the
+     * following methods is called: #ReadFile(), #FreeScene(). */
+    const std::exception_ptr& GetException() const;
 
     // -------------------------------------------------------------------
     /** Returns the scene loaded by the last successful call to ReadFile()
      *
-     * @return Current scene or NULL if there is currently no scene loaded */
-    const aiScene* GetScene() const;
+     * @return Current scene or nullptr if there is currently no scene loaded */
+    const aiScene *GetScene() const;
 
     // -------------------------------------------------------------------
     /** Returns the scene loaded by the last successful call to ReadFile()
      *  and releases the scene from the ownership of the Importer
      *  instance. The application is now responsible for deleting the
      *  scene. Any further calls to GetScene() or GetOrphanedScene()
-     *  will return NULL - until a new scene has been loaded via ReadFile().
+     *  will return nullptr - until a new scene has been loaded via ReadFile().
      *
-     * @return Current scene or NULL if there is currently no scene loaded
+     * @return Current scene or nullptr if there is currently no scene loaded
      * @note Use this method with maximal caution, and only if you have to.
      *   By design, aiScene's are exclusively maintained, allocated and
      *   deallocated by Assimp and no one else. The reasoning behind this
@@ -518,7 +546,7 @@ public:
      *   On Windows, it's typically fine provided everything is linked
      *   against the multithreaded-dll version of the runtime library.
      *   It will work as well for static linkage with Assimp.*/
-    aiScene* GetOrphanedScene();
+    aiScene *GetOrphanedScene();
 
     // -------------------------------------------------------------------
     /** Returns whether a given file extension is supported by ASSIMP.
@@ -527,7 +555,7 @@ public:
      *   Must include a trailing dot '.'. Example: ".3ds", ".md3".
      *   Cases-insensitive.
      * @return true if the extension is supported, false otherwise */
-    bool IsExtensionSupported(const char* szExtension) const;
+    bool IsExtensionSupported(const char *szExtension) const;
 
     // -------------------------------------------------------------------
     /** @brief Returns whether a given file extension is supported by ASSIMP.
@@ -535,7 +563,7 @@ public:
      * This function is provided for backward compatibility.
      * See the const char* version for detailed and up-to-date docs.
      * @see IsExtensionSupported(const char*) */
-    inline bool IsExtensionSupported(const std::string& szExtension) const;
+    inline bool IsExtensionSupported(const std::string &szExtension) const;
 
     // -------------------------------------------------------------------
     /** Get a full list of all file extensions supported by ASSIMP.
@@ -547,7 +575,7 @@ public:
      * @param szOut String to receive the extension list.
      *   Format of the list: "*.3ds;*.obj;*.dae". This is useful for
      *   use with the WinAPI call GetOpenFileName(Ex). */
-    void GetExtensionList(aiString& szOut) const;
+    void GetExtensionList(aiString &szOut) const;
 
     // -------------------------------------------------------------------
     /** @brief Get a full list of all file extensions supported by ASSIMP.
@@ -555,7 +583,7 @@ public:
      * This function is provided for backward compatibility.
      * See the aiString version for detailed and up-to-date docs.
      * @see GetExtensionList(aiString&)*/
-    inline void GetExtensionList(std::string& szOut) const;
+    inline void GetExtensionList(std::string &szOut) const;
 
     // -------------------------------------------------------------------
     /** Get the number of importers currently registered with Assimp. */
@@ -566,18 +594,18 @@ public:
     *
     *  For the declaration of #aiImporterDesc, include <assimp/importerdesc.h>.
     *  @param index Index to query, must be within [0,GetImporterCount())
-    *  @return Importer meta data structure, NULL if the index does not
+    *  @return Importer meta data structure, nullptr if the index does not
     *     exist or if the importer doesn't offer meta information (
     *     importers may do this at the cost of being hated by their peers).*/
-    const aiImporterDesc* GetImporterInfo(size_t index) const;
+    const aiImporterDesc *GetImporterInfo(size_t index) const;
 
     // -------------------------------------------------------------------
     /** Find the importer corresponding to a specific index.
     *
     *  @param index Index to query, must be within [0,GetImporterCount())
-    *  @return Importer instance. NULL if the index does not
+    *  @return Importer instance. nullptr if the index does not
     *     exist. */
-    BaseImporter* GetImporter(size_t index) const;
+    BaseImporter *GetImporter(size_t index) const;
 
     // -------------------------------------------------------------------
     /** Find the importer corresponding to a specific file extension.
@@ -588,8 +616,8 @@ public:
     *    are recognized (BAH being the file extension): "BAH" (comparison
     *    is case-insensitive), ".bah", "*.bah" (wild card and dot
     *    characters at the beginning of the extension are skipped).
-    *  @return NULL if no importer is found*/
-    BaseImporter* GetImporter (const char* szExtension) const;
+    *  @return nullptr if no importer is found*/
+    BaseImporter *GetImporter(const char *szExtension) const;
 
     // -------------------------------------------------------------------
     /** Find the importer index corresponding to a specific file extension.
@@ -599,7 +627,7 @@ public:
     *    is case-insensitive), ".bah", "*.bah" (wild card and dot
     *    characters at the beginning of the extension are skipped).
     *  @return (size_t)-1 if no importer is found */
-    size_t GetImporterIndex (const char* szExtension) const;
+    size_t GetImporterIndex(const char *szExtension) const;
 
     // -------------------------------------------------------------------
     /** Returns the storage allocated by ASSIMP to hold the scene data
@@ -610,7 +638,7 @@ public:
      * @note The returned memory statistics refer to the actual
      *   size of the use data of the aiScene. Heap-related overhead
      *   is (naturally) not included.*/
-    void GetMemoryRequirements(aiMemoryInfo& in) const;
+    void GetMemoryRequirements(aiMemoryInfo &in) const;
 
     // -------------------------------------------------------------------
     /** Enables "extra verbose" mode.
@@ -623,16 +651,14 @@ public:
 
     // -------------------------------------------------------------------
     /** Private, do not use. */
-    ImporterPimpl* Pimpl() { return pimpl; }
-    const ImporterPimpl* Pimpl() const { return pimpl; }
+    ImporterPimpl *Pimpl() { return pimpl; }
+    const ImporterPimpl *Pimpl() const { return pimpl; }
 
 protected:
-
     // Just because we don't want you to know how we're hacking around.
-    ImporterPimpl* pimpl;
+    ImporterPimpl *pimpl;
 }; //! class Importer
 
-
 // ----------------------------------------------------------------------------
 // For compatibility, the interface of some functions taking a std::string was
 // changed to const char* to avoid crashes between binary incompatible STL
@@ -640,20 +666,20 @@ protected:
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
-AI_FORCE_INLINE const aiScene* Importer::ReadFile( const std::string& pFile,unsigned int pFlags){
-    return ReadFile(pFile.c_str(),pFlags);
+AI_FORCE_INLINE const aiScene *Importer::ReadFile(const std::string &pFile, unsigned int pFlags) {
+    return ReadFile(pFile.c_str(), pFlags);
 }
 // ----------------------------------------------------------------------------
-AI_FORCE_INLINE void Importer::GetExtensionList(std::string& szOut) const   {
+AI_FORCE_INLINE void Importer::GetExtensionList(std::string &szOut) const {
     aiString s;
     GetExtensionList(s);
     szOut = s.data;
 }
 // ----------------------------------------------------------------------------
-AI_FORCE_INLINE bool Importer::IsExtensionSupported(const std::string& szExtension) const   {
+AI_FORCE_INLINE bool Importer::IsExtensionSupported(const std::string &szExtension) const {
     return IsExtensionSupported(szExtension.c_str());
 }
 
-} // !namespace Assimp
+} // namespace Assimp
 
 #endif // AI_ASSIMP_HPP_INC
diff --git a/Engine/lib/assimp/include/assimp/LineSplitter.h b/Engine/lib/assimp/include/assimp/LineSplitter.h
index 4afe45b92..a8aa665db 100644
--- a/Engine/lib/assimp/include/assimp/LineSplitter.h
+++ b/Engine/lib/assimp/include/assimp/LineSplitter.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -48,9 +47,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef INCLUDED_LINE_SPLITTER_H
 #define INCLUDED_LINE_SPLITTER_H
 
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
 #include <stdexcept>
-#include "StreamReader.h"
-#include "ParsingUtils.h"
+#include <assimp/StreamReader.h>
+#include <assimp/ParsingUtils.h>
 
 namespace Assimp {
 
@@ -68,7 +71,7 @@ for(LineSplitter splitter(stream);splitter;++splitter) {
        if (strtol(splitter[2]) > 5) { .. }
     }
 
-    std::cout << "Current line is: " << splitter.get_index() << std::endl;
+    ASSIMP_LOG_VERBOSE_DEBUG("Current line is: ", splitter.get_index());
 }
 @endcode
 */
@@ -140,26 +143,23 @@ private:
     bool mSwallow, mSkip_empty_lines, mTrim;
 };
 
-inline
-LineSplitter::LineSplitter(StreamReaderLE& stream, bool skip_empty_lines, bool trim )
-: mIdx(0)
-, mCur()
-, mStream(stream)
-, mSwallow()
-, mSkip_empty_lines(skip_empty_lines)
-, mTrim(trim) {
+AI_FORCE_INLINE LineSplitter::LineSplitter(StreamReaderLE& stream, bool skip_empty_lines, bool trim ) :
+        mIdx(0),
+        mCur(),
+        mStream(stream),
+        mSwallow(),
+        mSkip_empty_lines(skip_empty_lines),
+        mTrim(trim) {
     mCur.reserve(1024);
     operator++();
     mIdx = 0;
 }
 
-inline
-LineSplitter::~LineSplitter() {
+AI_FORCE_INLINE LineSplitter::~LineSplitter() {
     // empty
 }
 
-inline
-LineSplitter& LineSplitter::operator++() {
+AI_FORCE_INLINE LineSplitter& LineSplitter::operator++() {
     if (mSwallow) {
         mSwallow = false;
         return *this;
@@ -199,18 +199,15 @@ LineSplitter& LineSplitter::operator++() {
     return *this;
 }
 
-inline
-LineSplitter &LineSplitter::operator++(int) {
+AI_FORCE_INLINE LineSplitter &LineSplitter::operator++(int) {
     return ++(*this);
 }
 
-inline
-const char *LineSplitter::operator[] (size_t idx) const {
+AI_FORCE_INLINE const char *LineSplitter::operator[] (size_t idx) const {
     const char* s = operator->()->c_str();
 
     SkipSpaces(&s);
     for (size_t i = 0; i < idx; ++i) {
-
         for (; !IsSpace(*s); ++s) {
             if (IsLineEnd(*s)) {
                 throw std::range_error("Token index out of range, EOL reached");
@@ -222,8 +219,7 @@ const char *LineSplitter::operator[] (size_t idx) const {
 }
 
 template <size_t N>
-inline
-void LineSplitter::get_tokens(const char* (&tokens)[N]) const {
+AI_FORCE_INLINE void LineSplitter::get_tokens(const char* (&tokens)[N]) const {
     const char* s = operator->()->c_str();
 
     SkipSpaces(&s);
@@ -238,45 +234,37 @@ void LineSplitter::get_tokens(const char* (&tokens)[N]) const {
     }
 }
 
-inline
-const std::string* LineSplitter::operator -> () const {
+AI_FORCE_INLINE const std::string* LineSplitter::operator -> () const {
     return &mCur;
 }
 
-inline
-std::string LineSplitter::operator* () const {
+AI_FORCE_INLINE std::string LineSplitter::operator* () const {
     return mCur;
 }
 
-inline
-LineSplitter::operator bool() const {
+AI_FORCE_INLINE LineSplitter::operator bool() const {
     return mStream.GetRemainingSize() > 0;
 }
 
-inline
-LineSplitter::operator line_idx() const {
+AI_FORCE_INLINE LineSplitter::operator line_idx() const {
     return mIdx;
 }
 
-inline
-LineSplitter::line_idx LineSplitter::get_index() const {
+AI_FORCE_INLINE LineSplitter::line_idx LineSplitter::get_index() const {
     return mIdx;
 }
 
-inline
-StreamReaderLE &LineSplitter::get_stream() {
+AI_FORCE_INLINE StreamReaderLE &LineSplitter::get_stream() {
     return mStream;
 }
 
-inline
-bool LineSplitter::match_start(const char* check) {
+AI_FORCE_INLINE bool LineSplitter::match_start(const char* check) {
     const size_t len = ::strlen(check);
 
     return len <= mCur.length() && std::equal(check, check + len, mCur.begin());
 }
 
-inline
-void LineSplitter::swallow_next_increment() {
+AI_FORCE_INLINE void LineSplitter::swallow_next_increment() {
     mSwallow = true;
 }
 
diff --git a/Engine/lib/assimp/include/assimp/LogAux.h b/Engine/lib/assimp/include/assimp/LogAux.h
index 558485272..c7b86a185 100644
--- a/Engine/lib/assimp/include/assimp/LogAux.h
+++ b/Engine/lib/assimp/include/assimp/LogAux.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,89 +42,76 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file  LogAux.h
  *  @brief Common logging usage patterns for importer implementations
  */
+#pragma once
 #ifndef INCLUDED_AI_LOGAUX_H
 #define INCLUDED_AI_LOGAUX_H
 
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
 #include <assimp/TinyFormatter.h>
 #include <assimp/Exceptional.h>
 #include <assimp/DefaultLogger.hpp>
 
 namespace Assimp {
 
+/// @brief Logger class, which will extend the class by log-functions.
+/// @tparam TDeriving 
 template<class TDeriving>
 class LogFunctions {
 public:
     // ------------------------------------------------------------------------------------------------
-    static void ThrowException(const std::string& msg)
+    template<typename... T>
+    static void ThrowException(T&&... args)
     {
-        throw DeadlyImportError(Prefix()+msg);
+        throw DeadlyImportError(Prefix(), std::forward<T>(args)...);
     }
 
     // ------------------------------------------------------------------------------------------------
-    static void LogWarn(const Formatter::format& message)   {
+    template<typename... T>
+    static void LogWarn(T&&... args) {
         if (!DefaultLogger::isNullLogger()) {
-            ASSIMP_LOG_WARN(Prefix()+(std::string)message);
+            ASSIMP_LOG_WARN(Prefix(), std::forward<T>(args)...);
         }
     }
 
     // ------------------------------------------------------------------------------------------------
-    static void LogError(const Formatter::format& message)  {
+    template<typename... T>
+    static void LogError(T&&... args)  {
         if (!DefaultLogger::isNullLogger()) {
-            ASSIMP_LOG_ERROR(Prefix()+(std::string)message);
+            ASSIMP_LOG_ERROR(Prefix(), std::forward<T>(args)...);
         }
     }
 
     // ------------------------------------------------------------------------------------------------
-    static void LogInfo(const Formatter::format& message)   {
+    template<typename... T>
+    static void LogInfo(T&&... args)  {
         if (!DefaultLogger::isNullLogger()) {
-            ASSIMP_LOG_INFO(Prefix()+(std::string)message);
+            ASSIMP_LOG_INFO(Prefix(), std::forward<T>(args)...);
         }
     }
 
     // ------------------------------------------------------------------------------------------------
-    static void LogDebug(const Formatter::format& message)  {
+    template<typename... T>
+    static void LogDebug(T&&... args)  {
         if (!DefaultLogger::isNullLogger()) {
-            ASSIMP_LOG_DEBUG(Prefix()+(std::string)message);
-        }
-    }
-
-    // https://sourceforge.net/tracker/?func=detail&atid=1067632&aid=3358562&group_id=226462
-#if !defined(__GNUC__) || !defined(__APPLE__) || __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
-
-    // ------------------------------------------------------------------------------------------------
-    static void LogWarn  (const char* message) {
-        if (!DefaultLogger::isNullLogger()) {
-            LogWarn(Formatter::format(message));
+            ASSIMP_LOG_DEBUG(Prefix(), std::forward<T>(args)...);
         }
     }
 
     // ------------------------------------------------------------------------------------------------
-    static void LogError  (const char* message) {
+    template<typename... T>
+    static void LogVerboseDebug(T&&... args)  {
         if (!DefaultLogger::isNullLogger()) {
-            LogError(Formatter::format(message));
+            ASSIMP_LOG_VERBOSE_DEBUG(Prefix(), std::forward<T>(args)...);
         }
     }
 
-    // ------------------------------------------------------------------------------------------------
-    static void LogInfo  (const char* message) {
-        if (!DefaultLogger::isNullLogger()) {
-            LogInfo(Formatter::format(message));
-        }
-    }
-
-    // ------------------------------------------------------------------------------------------------
-    static void LogDebug  (const char* message) {
-        if (!DefaultLogger::isNullLogger()) {
-            LogDebug(Formatter::format(message));
-        }
-    }
-
-#endif
-
 private:
     static const char* Prefix();
-
 };
+
 } // ! Assimp
 
-#endif
+#endif // INCLUDED_AI_LOGAUX_H
diff --git a/Engine/lib/assimp/include/assimp/LogStream.hpp b/Engine/lib/assimp/include/assimp/LogStream.hpp
index d0281e2d0..0ac74c609 100644
--- a/Engine/lib/assimp/include/assimp/LogStream.hpp
+++ b/Engine/lib/assimp/include/assimp/LogStream.hpp
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,12 +42,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file LogStream.hpp
  *  @brief Abstract base class 'LogStream', representing an output log stream.
  */
+#pragma once
 #ifndef INCLUDED_AI_LOGSTREAM_H
 #define INCLUDED_AI_LOGSTREAM_H
 
+#ifdef __GNUC__
+#pragma GCC system_header
+#endif
+
 #include "types.h"
 
-namespace Assimp    {
+namespace Assimp {
 
 class IOSystem;
 
@@ -60,7 +64,7 @@ class IOSystem;
  *  are not enough for your purpose. */
 class ASSIMP_API LogStream
 #ifndef SWIG
-    : public Intern::AllocateFromAssimpHeap
+        : public Intern::AllocateFromAssimpHeap
 #endif
 {
 protected:
@@ -80,32 +84,29 @@ public:
      *  #DefaultLogger:set(). Usually you can *expect* that a log message
      *  is exactly one line and terminated with a single \n character.
      *  @param message Message to be written */
-    virtual void write(const char* message) = 0;
+    virtual void write(const char *message) = 0;
 
     // -------------------------------------------------------------------
     /** @brief Creates a default log stream
      *  @param streams Type of the default stream
      *  @param name For aiDefaultLogStream_FILE: name of the output file
      *  @param io For aiDefaultLogStream_FILE: IOSystem to be used to open the output
-     *   file. Pass NULL for the default implementation.
+     *   file. Pass nullptr for the default implementation.
      *  @return New LogStream instance.  */
-    static LogStream* createDefaultStream(aiDefaultLogStream stream,
-        const char* name = "AssimpLog.txt",
-        IOSystem* io = nullptr );
+    static LogStream *createDefaultStream(aiDefaultLogStream stream,
+            const char *name = "AssimpLog.txt",
+            IOSystem *io = nullptr);
 
 }; // !class LogStream
 
-inline
-LogStream::LogStream() AI_NO_EXCEPT {
+inline LogStream::LogStream() AI_NO_EXCEPT {
     // empty
 }
 
-inline
-LogStream::~LogStream() {
+inline LogStream::~LogStream() {
     // empty
 }
 
-// ------------------------------------------------------------------------------------
 } // Namespace Assimp
 
-#endif
+#endif // INCLUDED_AI_LOGSTREAM_H
diff --git a/Engine/lib/assimp/include/assimp/Logger.hpp b/Engine/lib/assimp/include/assimp/Logger.hpp
index 89cade6c3..54fd5d03d 100644
--- a/Engine/lib/assimp/include/assimp/Logger.hpp
+++ b/Engine/lib/assimp/include/assimp/Logger.hpp
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,6 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Logger.hpp
  *  @brief Abstract base class 'Logger', base of the logging system.
  */
+#pragma once
 #ifndef INCLUDED_AI_LOGGER_H
 #define INCLUDED_AI_LOGGER_H
 
@@ -73,8 +73,9 @@ public:
      *  @brief  Log severity to describe the granularity of logging.
      */
     enum LogSeverity {
-        NORMAL,     //!< Normal granularity of logging
-        VERBOSE     //!< Debug infos will be logged, too
+        NORMAL,     ///< Normal granularity of logging
+        DEBUGGING,  ///< Debug messages will be logged, but not verbose debug messages.
+        VERBOSE     ///< All messages will be logged
     };
 
     // ----------------------------------------------------------------------
@@ -92,34 +93,58 @@ public:
         Err         = 8     //!< Error log message
     };
 
-public:
-
     /** @brief  Virtual destructor */
     virtual ~Logger();
 
     // ----------------------------------------------------------------------
     /** @brief  Writes a debug message
-     *   @param message Debug message*/
+     *  @param  message Debug message*/
     void debug(const char* message);
-    void debug(const std::string &message);
+
+    template<typename... T>
+    void debug(T&&... args) {
+        debug(formatMessage(std::forward<T>(args)...).c_str());
+    }
+
+    // ----------------------------------------------------------------------
+    /** @brief  Writes a debug message
+     *   @param message Debug message*/
+    void verboseDebug(const char* message);
+
+    template<typename... T>
+    void verboseDebug(T&&... args) {
+        verboseDebug(formatMessage(std::forward<T>(args)...).c_str());
+    }
 
     // ----------------------------------------------------------------------
     /** @brief  Writes a info message
      *  @param  message Info message*/
     void info(const char* message);
-    void info(const std::string &message);
+
+    template<typename... T>
+    void info(T&&... args) {
+        info(formatMessage(std::forward<T>(args)...).c_str());
+    }
 
     // ----------------------------------------------------------------------
     /** @brief  Writes a warning message
      *  @param  message Warn message*/
     void warn(const char* message);
-    void warn(const std::string &message);
+
+    template<typename... T>
+    void warn(T&&... args) {
+        warn(formatMessage(std::forward<T>(args)...).c_str());
+    }
 
     // ----------------------------------------------------------------------
     /** @brief  Writes an error message
      *  @param  message Error message*/
     void error(const char* message);
-    void error(const std::string &message);
+
+    template<typename... T>
+    void error(T&&... args) {
+        error(formatMessage(std::forward<T>(args)...).c_str());
+    }
 
     // ----------------------------------------------------------------------
     /** @brief  Set a new log severity.
@@ -154,7 +179,7 @@ public:
      *    if the result is 0 the stream is detached from the Logger and
      *    the caller retakes the possession of the stream.
      *  @return true if the stream has been detached, false otherwise.*/
-    virtual bool detatchStream(LogStream *pStream,
+    virtual bool detachStream(LogStream *pStream,
         unsigned int severity = Debugging | Err | Warn | Info) = 0;
 
 protected:
@@ -178,6 +203,16 @@ protected:
      */
     virtual void OnDebug(const char* message)= 0;
 
+    // ----------------------------------------------------------------------
+	/**
+     *  @brief Called as a request to write a specific verbose debug message
+     *  @param  message Debug message. Never longer than
+     *    MAX_LOG_MESSAGE_LENGTH characters (excluding the '0').
+     *  @note  The message string is only valid until the scope of
+     *    the function is left.
+     */
+	virtual void OnVerboseDebug(const char *message) = 0;
+
     // ----------------------------------------------------------------------
     /**
      *  @brief Called as a request to write a specific info message
@@ -207,99 +242,64 @@ protected:
      *    the function is left.
      */
     virtual void OnError(const char* message) = 0;
+protected:
+    std::string formatMessage(Assimp::Formatter::format f) {
+        return f;
+    }
+
+    template<typename... T, typename U>
+    std::string formatMessage(Assimp::Formatter::format f, U&& u, T&&... args) {
+        return formatMessage(std::move(f << std::forward<U>(u)), std::forward<T>(args)...);
+    }
 
 protected:
     LogSeverity m_Severity;
 };
 
 // ----------------------------------------------------------------------------------
-//  Default constructor
-inline
-Logger::Logger() AI_NO_EXCEPT
-: m_Severity(NORMAL) {
+inline Logger::Logger() AI_NO_EXCEPT :
+        m_Severity(NORMAL) {
     // empty
 }
 
 // ----------------------------------------------------------------------------------
-//  Virtual destructor
-inline
-Logger::~Logger() {
+inline Logger::~Logger() {
     // empty
 }
 
 // ----------------------------------------------------------------------------------
-// Construction with given logging severity
-inline
-Logger::Logger(LogSeverity severity)
-: m_Severity(severity) {
+inline Logger::Logger(LogSeverity severity) :
+        m_Severity(severity) {
     // empty
 }
 
 // ----------------------------------------------------------------------------------
-// Log severity setter
-inline
-void Logger::setLogSeverity(LogSeverity log_severity){
+inline void Logger::setLogSeverity(LogSeverity log_severity){
     m_Severity = log_severity;
 }
 
 // ----------------------------------------------------------------------------------
 // Log severity getter
-inline
-Logger::LogSeverity Logger::getLogSeverity() const {
+inline Logger::LogSeverity Logger::getLogSeverity() const {
     return m_Severity;
 }
 
-// ----------------------------------------------------------------------------------
-inline
-void Logger::debug(const std::string &message) {
-    return debug(message.c_str());
-}
-
-// ----------------------------------------------------------------------------------
-inline
-void Logger::error(const std::string &message) {
-    return error(message.c_str());
-}
-
-// ----------------------------------------------------------------------------------
-inline
-void Logger::warn(const std::string &message) {
-    return warn(message.c_str());
-}
-
-// ----------------------------------------------------------------------------------
-inline
-void Logger::info(const std::string &message) {
-    return info(message.c_str());
-}
-
-// ------------------------------------------------------------------------------------------------
-#define ASSIMP_LOG_WARN_F(string,...)\
-    DefaultLogger::get()->warn((Formatter::format(string),__VA_ARGS__))
-
-#define ASSIMP_LOG_ERROR_F(string,...)\
-    DefaultLogger::get()->error((Formatter::format(string),__VA_ARGS__))
-
-#define ASSIMP_LOG_DEBUG_F(string,...)\
-    DefaultLogger::get()->debug((Formatter::format(string),__VA_ARGS__))
-
-#define ASSIMP_LOG_INFO_F(string,...)\
-    DefaultLogger::get()->info((Formatter::format(string),__VA_ARGS__))
-
-
-#define ASSIMP_LOG_WARN(string)\
-    DefaultLogger::get()->warn(string)
-
-#define ASSIMP_LOG_ERROR(string)\
-    DefaultLogger::get()->error(string)
-
-#define ASSIMP_LOG_DEBUG(string)\
-    DefaultLogger::get()->debug(string)
-
-#define ASSIMP_LOG_INFO(string)\
-    DefaultLogger::get()->info(string)
-
-
 } // Namespace Assimp
 
+// ------------------------------------------------------------------------------------------------
+#define ASSIMP_LOG_WARN(...) \
+	Assimp::DefaultLogger::get()->warn(__VA_ARGS__)
+
+#define ASSIMP_LOG_ERROR(...) \
+	Assimp::DefaultLogger::get()->error(__VA_ARGS__)
+
+#define ASSIMP_LOG_DEBUG(...) \
+	Assimp::DefaultLogger::get()->debug(__VA_ARGS__)
+
+#define ASSIMP_LOG_VERBOSE_DEBUG(...) \
+	Assimp::DefaultLogger::get()->verboseDebug(__VA_ARGS__)
+
+#define ASSIMP_LOG_INFO(...) \
+	Assimp::DefaultLogger::get()->info(__VA_ARGS__)
+
 #endif // !! INCLUDED_AI_LOGGER_H
diff --git a/Engine/lib/assimp/include/assimp/MathFunctions.h b/Engine/lib/assimp/include/assimp/MathFunctions.h
index f49273bb3..f2a7ccdf6 100644
--- a/Engine/lib/assimp/include/assimp/MathFunctions.h
+++ b/Engine/lib/assimp/include/assimp/MathFunctions.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2016, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -41,6 +41,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #pragma once
 
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
 /** @file  MathFunctions.h
 *  @brief Implementation of math utility functions.
  *
@@ -51,36 +55,51 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 namespace Assimp {
 namespace Math {
 
-// TODO: use binary GCD for unsigned integers ....
-template < typename IntegerType >
-inline
-IntegerType gcd( IntegerType a, IntegerType b ) {
+/// @brief  Will return the greatest common divisor.
+/// @param  a   [in] Value a.
+/// @param  b   [in] Value b.
+/// @return The greatest common divisor.
+template <typename IntegerType>
+inline IntegerType gcd( IntegerType a, IntegerType b ) {
 	const IntegerType zero = (IntegerType)0;
 	while ( true ) {
-		if ( a == zero )
+		if ( a == zero ) {
 			return b;
+        }
 		b %= a;
 
-		if ( b == zero )
+		if ( b == zero ) {
 			return a;
+        }
 		a %= b;
 	}
 }
 
+/// @brief  Will return the greatest common divisor.
+/// @param  a   [in] Value a.
+/// @param  b   [in] Value b.
+/// @return The greatest common divisor.
 template < typename IntegerType >
-inline
-IntegerType lcm( IntegerType a, IntegerType b ) {
+inline IntegerType lcm( IntegerType a, IntegerType b ) {
 	const IntegerType t = gcd (a,b);
-	if (!t)
+	if (!t) {
         return t;
+    }
 	return a / t * b;
 }
-
+/// @brief  Will return the smallest epsilon-value for the requested type.
+/// @return The numercical limit epsilon depending on its type.
 template<class T>
-inline
-T getEpsilon() {
+inline T getEpsilon() {
     return std::numeric_limits<T>::epsilon();
 }
 
+/// @brief  Will return the constant PI for the requested type.
+/// @return Pi
+template<class T>
+inline T aiPi() {
+    return static_cast<T>(3.14159265358979323846);
 }
-}
+
+} // namespace Math
+} // namespace Assimp
diff --git a/Engine/lib/assimp/include/assimp/MemoryIOWrapper.h b/Engine/lib/assimp/include/assimp/MemoryIOWrapper.h
index c52278718..b4c37763d 100644
--- a/Engine/lib/assimp/include/assimp/MemoryIOWrapper.h
+++ b/Engine/lib/assimp/include/assimp/MemoryIOWrapper.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -41,17 +41,23 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 /** @file MemoryIOWrapper.h
- *  Handy IOStream/IOSystem implemetation to read directly from a memory buffer */
+ *  Handy IOStream/IOSystem implementation to read directly from a memory buffer */
+#pragma once
 #ifndef AI_MEMORYIOSTREAM_H_INC
 #define AI_MEMORYIOSTREAM_H_INC
 
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
 #include <assimp/IOStream.hpp>
 #include <assimp/IOSystem.hpp>
 #include <assimp/ai_assert.h>
+
 #include <stdint.h>
 
 namespace Assimp    {
-    
+
 #define AI_MEMORYIO_MAGIC_FILENAME "$$$___magic___$$$"
 #define AI_MEMORYIO_MAGIC_FILENAME_LENGTH 17
 
@@ -79,7 +85,7 @@ public:
     size_t Read(void* pvBuffer, size_t pSize, size_t pCount)    {
         ai_assert(nullptr != pvBuffer);
         ai_assert(0 != pSize);
-        
+
         const size_t cnt = std::min( pCount, (length-pos) / pSize);
         const size_t ofs = pSize * cnt;
 
@@ -203,7 +209,7 @@ public:
         return existing_io ? existing_io->ComparePaths(one, second) : false;
     }
 
-    bool PushDirectory( const std::string &path ) override { 
+    bool PushDirectory( const std::string &path ) override {
         return existing_io ? existing_io->PushDirectory(path) : false;
     }
 
diff --git a/Engine/lib/assimp/include/assimp/NullLogger.hpp b/Engine/lib/assimp/include/assimp/NullLogger.hpp
index c45d01bd4..1b594ea28 100644
--- a/Engine/lib/assimp/include/assimp/NullLogger.hpp
+++ b/Engine/lib/assimp/include/assimp/NullLogger.hpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -44,9 +44,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Dummy logger
 */
 
+#pragma once
 #ifndef INCLUDED_AI_NULLLOGGER_H
 #define INCLUDED_AI_NULLLOGGER_H
 
+#ifdef __GNUC__
+#pragma GCC system_header
+#endif
+
 #include "Logger.hpp"
 
 namespace Assimp {
@@ -66,6 +71,11 @@ public:
         (void)message; //this avoids compiler warnings
     }
 
+    /** @brief  Logs a verbose debug message */
+	void OnVerboseDebug(const char *message) {
+		(void)message; //this avoids compiler warnings
+	}
+
     /** @brief  Logs an info message */
     void OnInfo(const char* message) {
         (void)message; //this avoids compiler warnings
@@ -88,7 +98,7 @@ public:
     }
 
     /** @brief  Detach a still attached stream from logger */
-    bool detatchStream(LogStream *pStream, unsigned int severity) {
+    bool detachStream(LogStream *pStream, unsigned int severity) {
         (void)pStream; (void)severity; //this avoids compiler warnings
         return false;
     }
diff --git a/Engine/lib/assimp/include/assimp/ObjMaterial.h b/Engine/lib/assimp/include/assimp/ObjMaterial.h
new file mode 100644
index 000000000..bba207638
--- /dev/null
+++ b/Engine/lib/assimp/include/assimp/ObjMaterial.h
@@ -0,0 +1,84 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file OBJMATERIAL.h
+ *  @brief Obj-specific material macros
+ *  
+ */
+
+#ifndef AI_OBJMATERIAL_H_INC
+#define AI_OBJMATERIAL_H_INC
+
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
+#include <assimp/material.h>
+
+// ---------------------------------------------------------------------------
+
+// the original illum property
+#define AI_MATKEY_OBJ_ILLUM "$mat.illum", 0, 0
+
+// ---------------------------------------------------------------------------
+
+// ---------------------------------------------------------------------------
+// Pure key names for all obj texture-related properties
+//! @cond MATS_DOC_FULL
+
+// support for bump -bm 
+#define _AI_MATKEY_OBJ_BUMPMULT_BASE "$tex.bumpmult"
+//! @endcond
+
+// ---------------------------------------------------------------------------
+#define AI_MATKEY_OBJ_BUMPMULT(type, N) _AI_MATKEY_OBJ_BUMPMULT_BASE, type, N
+
+//! @cond MATS_DOC_FULL
+#define AI_MATKEY_OBJ_BUMPMULT_NORMALS(N) \
+    AI_MATKEY_OBJ_BUMPMULT(aiTextureType_NORMALS, N)
+
+#define AI_MATKEY_OBJ_BUMPMULT_HEIGHT(N) \
+    AI_MATKEY_OBJ_BUMPMULT(aiTextureType_HEIGHT, N)
+
+//! @endcond
+
+
+#endif
diff --git a/Engine/lib/assimp/include/assimp/ParsingUtils.h b/Engine/lib/assimp/include/assimp/ParsingUtils.h
index 6b9574fc6..b08f23227 100644
--- a/Engine/lib/assimp/include/assimp/ParsingUtils.h
+++ b/Engine/lib/assimp/include/assimp/ParsingUtils.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -40,17 +39,24 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
-
 /** @file ParsingUtils.h
  *  @brief Defines helper functions for text parsing
  */
+#pragma once
 #ifndef AI_PARSING_UTILS_H_INC
 #define AI_PARSING_UTILS_H_INC
 
-#include "StringComparison.h"
-#include "StringUtils.h"
+#ifdef __GNUC__
+#pragma GCC system_header
+#endif
+
+#include <assimp/StringComparison.h>
+#include <assimp/StringUtils.h>
 #include <assimp/defs.h>
 
+#include <vector>
+#include <algorithm>
+
 namespace Assimp {
 
 // NOTE: the functions below are mostly intended as replacement for
@@ -64,60 +70,41 @@ namespace Assimp {
 
 static const unsigned int BufferSize = 4096;
 
-// ---------------------------------------------------------------------------------
-template <class char_t>
-AI_FORCE_INLINE
-char_t ToLower( char_t in ) {
-    return (in >= (char_t)'A' && in <= (char_t)'Z') ? (char_t)(in+0x20) : in;
-}
 
 // ---------------------------------------------------------------------------------
 template <class char_t>
-AI_FORCE_INLINE
-char_t ToUpper( char_t in) {
-    return (in >= (char_t)'a' && in <= (char_t)'z') ? (char_t)(in-0x20) : in;
-}
-
-// ---------------------------------------------------------------------------------
-template <class char_t>
-AI_FORCE_INLINE
-bool IsUpper( char_t in) {
+AI_FORCE_INLINE bool IsUpper(char_t in) {
     return (in >= (char_t)'A' && in <= (char_t)'Z');
 }
 
 // ---------------------------------------------------------------------------------
 template <class char_t>
-AI_FORCE_INLINE
-bool IsLower( char_t in) {
+AI_FORCE_INLINE bool IsLower(char_t in) {
     return (in >= (char_t)'a' && in <= (char_t)'z');
 }
 
 // ---------------------------------------------------------------------------------
 template <class char_t>
-AI_FORCE_INLINE
-bool IsSpace( char_t in) {
+AI_FORCE_INLINE bool IsSpace(char_t in) {
     return (in == (char_t)' ' || in == (char_t)'\t');
 }
 
 // ---------------------------------------------------------------------------------
 template <class char_t>
-AI_FORCE_INLINE
-bool IsLineEnd( char_t in) {
-    return (in==(char_t)'\r'||in==(char_t)'\n'||in==(char_t)'\0'||in==(char_t)'\f');
+AI_FORCE_INLINE bool IsLineEnd(char_t in) {
+    return (in == (char_t)'\r' || in == (char_t)'\n' || in == (char_t)'\0' || in == (char_t)'\f');
 }
 
 // ---------------------------------------------------------------------------------
 template <class char_t>
-AI_FORCE_INLINE
-bool IsSpaceOrNewLine( char_t in) {
+AI_FORCE_INLINE bool IsSpaceOrNewLine(char_t in) {
     return IsSpace<char_t>(in) || IsLineEnd<char_t>(in);
 }
 
 // ---------------------------------------------------------------------------------
 template <class char_t>
-AI_FORCE_INLINE
-bool SkipSpaces( const char_t* in, const char_t** out) {
-    while( *in == ( char_t )' ' || *in == ( char_t )'\t' ) {
+AI_FORCE_INLINE bool SkipSpaces(const char_t *in, const char_t **out) {
+    while (*in == (char_t)' ' || *in == (char_t)'\t') {
         ++in;
     }
     *out = in;
@@ -126,21 +113,19 @@ bool SkipSpaces( const char_t* in, const char_t** out) {
 
 // ---------------------------------------------------------------------------------
 template <class char_t>
-AI_FORCE_INLINE
-bool SkipSpaces( const char_t** inout) {
-    return SkipSpaces<char_t>(*inout,inout);
+AI_FORCE_INLINE bool SkipSpaces(const char_t **inout) {
+    return SkipSpaces<char_t>(*inout, inout);
 }
 
 // ---------------------------------------------------------------------------------
 template <class char_t>
-AI_FORCE_INLINE
-bool SkipLine( const char_t* in, const char_t** out) {
-    while( *in != ( char_t )'\r' && *in != ( char_t )'\n' && *in != ( char_t )'\0' ) {
+AI_FORCE_INLINE bool SkipLine(const char_t *in, const char_t **out) {
+    while (*in != (char_t)'\r' && *in != (char_t)'\n' && *in != (char_t)'\0') {
         ++in;
     }
 
     // files are opened in binary mode. Ergo there are both NL and CR
-    while( *in == ( char_t )'\r' || *in == ( char_t )'\n' ) {
+    while (*in == (char_t)'\r' || *in == (char_t)'\n') {
         ++in;
     }
     *out = in;
@@ -149,16 +134,14 @@ bool SkipLine( const char_t* in, const char_t** out) {
 
 // ---------------------------------------------------------------------------------
 template <class char_t>
-AI_FORCE_INLINE
-bool SkipLine( const char_t** inout) {
-    return SkipLine<char_t>(*inout,inout);
+AI_FORCE_INLINE bool SkipLine(const char_t **inout) {
+    return SkipLine<char_t>(*inout, inout);
 }
 
 // ---------------------------------------------------------------------------------
 template <class char_t>
-AI_FORCE_INLINE
-bool SkipSpacesAndLineEnd( const char_t* in, const char_t** out) {
-    while( *in == ( char_t )' ' || *in == ( char_t )'\t' || *in == ( char_t )'\r' || *in == ( char_t )'\n' ) {
+AI_FORCE_INLINE bool SkipSpacesAndLineEnd(const char_t *in, const char_t **out) {
+    while (*in == (char_t)' ' || *in == (char_t)'\t' || *in == (char_t)'\r' || *in == (char_t)'\n') {
         ++in;
     }
     *out = in;
@@ -167,27 +150,25 @@ bool SkipSpacesAndLineEnd( const char_t* in, const char_t** out) {
 
 // ---------------------------------------------------------------------------------
 template <class char_t>
-AI_FORCE_INLINE
-bool SkipSpacesAndLineEnd( const char_t** inout) {
-    return SkipSpacesAndLineEnd<char_t>(*inout,inout);
+AI_FORCE_INLINE bool SkipSpacesAndLineEnd(const char_t **inout) {
+    return SkipSpacesAndLineEnd<char_t>(*inout, inout);
 }
 
 // ---------------------------------------------------------------------------------
 template <class char_t>
-AI_FORCE_INLINE
-bool GetNextLine( const char_t*& buffer, char_t out[ BufferSize ] ) {
-    if( ( char_t )'\0' == *buffer ) {
+AI_FORCE_INLINE bool GetNextLine(const char_t *&buffer, char_t out[BufferSize]) {
+    if ((char_t)'\0' == *buffer) {
         return false;
     }
 
-    char* _out = out;
-    char* const end = _out + BufferSize;
-    while( !IsLineEnd( *buffer ) && _out < end ) {
+    char *_out = out;
+    char *const end = _out + BufferSize;
+    while (!IsLineEnd(*buffer) && _out < end) {
         *_out++ = *buffer++;
     }
     *_out = (char_t)'\0';
 
-    while( IsLineEnd( *buffer ) && '\0' != *buffer ) {
+    while (IsLineEnd(*buffer) && '\0' != *buffer) {
         ++buffer;
     }
 
@@ -196,18 +177,16 @@ bool GetNextLine( const char_t*& buffer, char_t out[ BufferSize ] ) {
 
 // ---------------------------------------------------------------------------------
 template <class char_t>
-AI_FORCE_INLINE bool IsNumeric( char_t in) {
-    return ( in >= '0' && in <= '9' ) || '-' == in || '+' == in;
+AI_FORCE_INLINE bool IsNumeric(char_t in) {
+    return (in >= '0' && in <= '9') || '-' == in || '+' == in;
 }
 
 // ---------------------------------------------------------------------------------
 template <class char_t>
-AI_FORCE_INLINE
-bool TokenMatch(char_t*& in, const char* token, unsigned int len)
-{
-    if (!::strncmp(token,in,len) && IsSpaceOrNewLine(in[len])) {
+AI_FORCE_INLINE bool TokenMatch(char_t *&in, const char *token, unsigned int len) {
+    if (!::strncmp(token, in, len) && IsSpaceOrNewLine(in[len])) {
         if (in[len] != '\0') {
-            in += len+1;
+            in += len + 1;
         } else {
             // If EOF after the token make sure we don't go past end of buffer
             in += len;
@@ -223,37 +202,71 @@ bool TokenMatch(char_t*& in, const char* token, unsigned int len)
  *  @param token Token to check for
  *  @param len Number of characters to check
  */
-AI_FORCE_INLINE
-bool TokenMatchI(const char*& in, const char* token, unsigned int len) {
-    if (!ASSIMP_strincmp(token,in,len) && IsSpaceOrNewLine(in[len])) {
-        in += len+1;
+AI_FORCE_INLINE bool TokenMatchI(const char *&in, const char *token, unsigned int len) {
+    if (!ASSIMP_strincmp(token, in, len) && IsSpaceOrNewLine(in[len])) {
+        in += len + 1;
         return true;
     }
     return false;
 }
 
 // ---------------------------------------------------------------------------------
-AI_FORCE_INLINE
-void SkipToken(const char*& in) {
+AI_FORCE_INLINE void SkipToken(const char *&in) {
     SkipSpaces(&in);
-    while ( !IsSpaceOrNewLine( *in ) ) {
+    while (!IsSpaceOrNewLine(*in)) {
         ++in;
     }
 }
 
 // ---------------------------------------------------------------------------------
-AI_FORCE_INLINE
-std::string GetNextToken(const char*& in) {
+AI_FORCE_INLINE std::string GetNextToken(const char *&in) {
     SkipSpacesAndLineEnd(&in);
-    const char* cur = in;
-    while ( !IsSpaceOrNewLine( *in ) ) {
+    const char *cur = in;
+    while (!IsSpaceOrNewLine(*in)) {
         ++in;
     }
-    return std::string(cur,(size_t)(in-cur));
+    return std::string(cur, (size_t)(in - cur));
 }
 
 // ---------------------------------------------------------------------------------
+/** @brief  Will perform a simple tokenize.
+ *  @param  str         String to tokenize.
+ *  @param  tokens      Array with tokens, will be empty if no token was found.
+ *  @param  delimiters  Delimiter for tokenize.
+ *  @return Number of found token.
+ */
+template <class string_type>
+AI_FORCE_INLINE unsigned int tokenize(const string_type &str, std::vector<string_type> &tokens,
+        const string_type &delimiters) {
+    // Skip delimiters at beginning.
+    typename string_type::size_type lastPos = str.find_first_not_of(delimiters, 0);
 
-} // ! namespace Assimp
+    // Find first "non-delimiter".
+    typename string_type::size_type pos = str.find_first_of(delimiters, lastPos);
+    while (string_type::npos != pos || string_type::npos != lastPos) {
+        // Found a token, add it to the vector.
+        string_type tmp = str.substr(lastPos, pos - lastPos);
+        if (!tmp.empty() && ' ' != tmp[0])
+            tokens.push_back(tmp);
+
+        // Skip delimiters.  Note the "not_of"
+        lastPos = str.find_first_not_of(delimiters, pos);
+
+        // Find next "non-delimiter"
+        pos = str.find_first_of(delimiters, lastPos);
+    }
+
+    return static_cast<unsigned int>(tokens.size());
+}
+
+inline std::string ai_stdStrToLower(const std::string &str) {
+    std::string out(str);
+    for (size_t i = 0; i < str.size(); ++i) {
+        out[i] = (char) tolower((unsigned char)out[i]);
+    }
+    return out;
+}
+
+} // namespace Assimp
 
 #endif // ! AI_PARSING_UTILS_H_INC
diff --git a/Engine/lib/assimp/include/assimp/Profiler.h b/Engine/lib/assimp/include/assimp/Profiler.h
index 6ff9d41c0..fe0ffbb10 100644
--- a/Engine/lib/assimp/include/assimp/Profiler.h
+++ b/Engine/lib/assimp/include/assimp/Profiler.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -43,12 +43,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Profiler.h
  *  @brief Utility to measure the respective runtime of each import step
  */
-#ifndef INCLUDED_PROFILER_H
-#define INCLUDED_PROFILER_H
+#pragma once
+#ifndef AI_INCLUDED_PROFILER_H
+#define AI_INCLUDED_PROFILER_H
+
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
 
 #include <chrono>
 #include <assimp/DefaultLogger.hpp>
-#include "TinyFormatter.h"
+#include <assimp/TinyFormatter.h>
 
 #include <map>
 
@@ -67,12 +72,11 @@ public:
         // empty
     }
 
-public:
 
     /** Start a named timer */
     void BeginRegion(const std::string& region) {
         regions[region] = std::chrono::system_clock::now();
-        ASSIMP_LOG_DEBUG((format("START `"),region,"`"));
+        ASSIMP_LOG_DEBUG("START `",region,"`");
     }
 
 
@@ -84,7 +88,7 @@ public:
         }
 
         std::chrono::duration<double> elapsedSeconds = std::chrono::system_clock::now() - regions[region];
-        ASSIMP_LOG_DEBUG((format("END   `"),region,"`, dt= ", elapsedSeconds.count()," s"));
+        ASSIMP_LOG_DEBUG("END   `",region,"`, dt= ", elapsedSeconds.count()," s");
     }
 
 private:
@@ -95,5 +99,5 @@ private:
 }
 }
 
-#endif
+#endif // AI_INCLUDED_PROFILER_H
 
diff --git a/Engine/lib/assimp/include/assimp/ProgressHandler.hpp b/Engine/lib/assimp/include/assimp/ProgressHandler.hpp
index 4e47f1d0a..1a272bb87 100644
--- a/Engine/lib/assimp/include/assimp/ProgressHandler.hpp
+++ b/Engine/lib/assimp/include/assimp/ProgressHandler.hpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -47,9 +47,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_PROGRESSHANDLER_H_INC
 #define AI_PROGRESSHANDLER_H_INC
 
-#include "types.h"
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
 
-namespace Assimp    {
+#include <assimp/types.h>
+
+namespace Assimp {
 
 // ------------------------------------------------------------------------------------
 /** @brief CPP-API: Abstract interface for custom progress report receivers.
@@ -70,6 +74,7 @@ protected:
 public:
     /// @brief  Virtual destructor.
     virtual ~ProgressHandler () {
+        // empty
     }
 
     // -------------------------------------------------------------------
@@ -87,7 +92,7 @@ public:
      *   occasion (loaders and Assimp are generally allowed to perform
      *   all needed cleanup tasks prior to returning control to the
      *   caller). If the loading is aborted, #Importer::ReadFile()
-     *   returns always NULL.
+     *   returns always nullptr.
      *   */
     virtual bool Update(float percentage = -1.f) = 0;
 
diff --git a/Engine/lib/assimp/include/assimp/RemoveComments.h b/Engine/lib/assimp/include/assimp/RemoveComments.h
index 404b49671..c2defff63 100644
--- a/Engine/lib/assimp/include/assimp/RemoveComments.h
+++ b/Engine/lib/assimp/include/assimp/RemoveComments.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -43,9 +42,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Declares a helper class, "CommentRemover", which can be
  *  used to remove comments (single and multi line) from a text file.
  */
+#pragma once
 #ifndef AI_REMOVE_COMMENTS_H_INC
 #define AI_REMOVE_COMMENTS_H_INC
 
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
 
 #include <assimp/defs.h>
 
@@ -58,8 +61,7 @@ namespace Assimp    {
  *  to those in C or C++ so this code has been moved to a separate
  *  module.
  */
-class ASSIMP_API CommentRemover
-{
+class ASSIMP_API CommentRemover {
     // class cannot be instanced
     CommentRemover() {}
 
diff --git a/Engine/lib/assimp/include/assimp/SGSpatialSort.h b/Engine/lib/assimp/include/assimp/SGSpatialSort.h
index 5b4f3f41f..96feefabb 100644
--- a/Engine/lib/assimp/include/assimp/SGSpatialSort.h
+++ b/Engine/lib/assimp/include/assimp/SGSpatialSort.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -42,9 +42,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** Small helper classes to optimize finding vertices close to a given location
  */
+#pragma once
 #ifndef AI_D3DSSPATIALSORT_H_INC
 #define AI_D3DSSPATIALSORT_H_INC
 
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
 #include <assimp/types.h>
 #include <vector>
 #include <stdint.h>
diff --git a/Engine/lib/assimp/include/assimp/SceneCombiner.h b/Engine/lib/assimp/include/assimp/SceneCombiner.h
index f69a25f43..6da38cd15 100644
--- a/Engine/lib/assimp/include/assimp/SceneCombiner.h
+++ b/Engine/lib/assimp/include/assimp/SceneCombiner.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -43,17 +43,21 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Declares a helper class, "SceneCombiner" providing various
  *  utilities to merge scenes.
  */
+#pragma once
 #ifndef AI_SCENE_COMBINER_H_INC
 #define AI_SCENE_COMBINER_H_INC
 
+#ifdef __GNUC__
+#pragma GCC system_header
+#endif
+
 #include <assimp/ai_assert.h>
 #include <assimp/types.h>
-#include <assimp/Defines.h>
-#include <stddef.h>
-#include <set>
-#include <list>
-#include <stdint.h>
 
+#include <cstddef>
+#include <cstdint>
+#include <list>
+#include <set>
 #include <vector>
 
 struct aiScene;
@@ -68,69 +72,60 @@ struct aiMesh;
 struct aiAnimMesh;
 struct aiAnimation;
 struct aiNodeAnim;
+struct aiMeshMorphAnim;
 
-namespace Assimp    {
+namespace Assimp {
 
 // ---------------------------------------------------------------------------
 /** \brief Helper data structure for SceneCombiner.
  *
  *  Describes to which node a scene must be attached to.
  */
-struct AttachmentInfo
-{
-    AttachmentInfo()
-        :   scene           (NULL)
-        ,   attachToNode    (NULL)
-    {}
+struct AttachmentInfo {
+    AttachmentInfo() :
+            scene(nullptr),
+            attachToNode(nullptr) {}
 
-    AttachmentInfo(aiScene* _scene, aiNode* _attachToNode)
-        :   scene           (_scene)
-        ,   attachToNode    (_attachToNode)
-    {}
+    AttachmentInfo(aiScene *_scene, aiNode *_attachToNode) :
+            scene(_scene), attachToNode(_attachToNode) {}
 
-    aiScene* scene;
-    aiNode*  attachToNode;
+    aiScene *scene;
+    aiNode *attachToNode;
 };
 
 // ---------------------------------------------------------------------------
-struct NodeAttachmentInfo
-{
-    NodeAttachmentInfo()
-        :   node            (NULL)
-        ,   attachToNode    (NULL)
-        ,   resolved        (false)
-        ,   src_idx         (SIZE_MAX)
-    {}
+struct NodeAttachmentInfo {
+    NodeAttachmentInfo() :
+            node(nullptr),
+            attachToNode(nullptr),
+            resolved(false),
+            src_idx(SIZE_MAX) {}
 
-    NodeAttachmentInfo(aiNode* _scene, aiNode* _attachToNode,size_t idx)
-        :   node            (_scene)
-        ,   attachToNode    (_attachToNode)
-        ,   resolved        (false)
-        ,   src_idx         (idx)
-    {}
+    NodeAttachmentInfo(aiNode *_scene, aiNode *_attachToNode, size_t idx) :
+            node(_scene), attachToNode(_attachToNode), resolved(false), src_idx(idx) {}
 
-    aiNode*  node;
-    aiNode*  attachToNode;
-    bool     resolved;
-    size_t   src_idx;
+    aiNode *node;
+    aiNode *attachToNode;
+    bool resolved;
+    size_t src_idx;
 };
 
 // ---------------------------------------------------------------------------
 /** @def AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES
  *  Generate unique names for all named scene items
  */
-#define AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES      0x1
+#define AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES 0x1
 
 /** @def AI_INT_MERGE_SCENE_GEN_UNIQUE_MATNAMES
  *  Generate unique names for materials, too.
  *  This is not absolutely required to pass the validation.
  */
-#define AI_INT_MERGE_SCENE_GEN_UNIQUE_MATNAMES   0x2
+#define AI_INT_MERGE_SCENE_GEN_UNIQUE_MATNAMES 0x2
 
 /** @def AI_INT_MERGE_SCENE_DUPLICATES_DEEP_CPY
  * Use deep copies of duplicate scenes
  */
-#define AI_INT_MERGE_SCENE_DUPLICATES_DEEP_CPY   0x4
+#define AI_INT_MERGE_SCENE_DUPLICATES_DEEP_CPY 0x4
 
 /** @def AI_INT_MERGE_SCENE_RESOLVE_CROSS_ATTACHMENTS
  * If attachment nodes are not found in the given master scene,
@@ -145,44 +140,39 @@ struct NodeAttachmentInfo
  */
 #define AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY 0x10
 
-typedef std::pair<aiBone*,unsigned int> BoneSrcIndex;
+typedef std::pair<aiBone *, unsigned int> BoneSrcIndex;
 
 // ---------------------------------------------------------------------------
 /** @brief Helper data structure for SceneCombiner::MergeBones.
  */
-struct BoneWithHash : public std::pair<uint32_t,aiString*>  {
+struct BoneWithHash : public std::pair<uint32_t, aiString *> {
     std::vector<BoneSrcIndex> pSrcBones;
 };
 
 // ---------------------------------------------------------------------------
 /** @brief Utility for SceneCombiner
  */
-struct SceneHelper
-{
-    SceneHelper ()
-        : scene     (NULL)
-        , idlen     (0)
-    {
+struct SceneHelper {
+    SceneHelper() :
+            scene(nullptr),
+            idlen(0) {
         id[0] = 0;
     }
 
-    explicit SceneHelper (aiScene* _scene)
-        : scene     (_scene)
-        , idlen     (0)
-    {
+    explicit SceneHelper(aiScene *_scene) :
+            scene(_scene), idlen(0) {
         id[0] = 0;
     }
 
-    AI_FORCE_INLINE aiScene* operator-> () const
-    {
+    AI_FORCE_INLINE aiScene *operator->() const {
         return scene;
     }
 
     // scene we're working on
-    aiScene* scene;
+    aiScene *scene;
 
     // prefix to be added to all identifiers in the scene ...
-    char id [32];
+    char id[32];
 
     // and its strlen()
     unsigned int idlen;
@@ -214,21 +204,21 @@ public:
     /** Merges two or more scenes.
      *
      *  @param dest  Receives a pointer to the destination scene. If the
-     *    pointer doesn't point to NULL when the function is called, the
+     *    pointer doesn't point to nullptr when the function is called, the
      *    existing scene is cleared and refilled.
      *  @param src Non-empty list of scenes to be merged. The function
      *    deletes the input scenes afterwards. There may be duplicate scenes.
      *  @param flags Combination of the AI_INT_MERGE_SCENE flags defined above
      */
-    static void MergeScenes(aiScene** dest,std::vector<aiScene*>& src,
-        unsigned int flags = 0);
+    static void MergeScenes(aiScene **dest, std::vector<aiScene *> &src,
+            unsigned int flags = 0);
 
     // -------------------------------------------------------------------
     /** Merges two or more scenes and attaches all scenes to a specific
      *  position in the node graph of the master scene.
      *
      *  @param dest Receives a pointer to the destination scene. If the
-     *    pointer doesn't point to NULL when the function is called, the
+     *    pointer doesn't point to nullptr when the function is called, the
      *    existing scene is cleared and refilled.
      *  @param master Master scene. It will be deleted afterwards. All
      *    other scenes will be inserted in its node graph.
@@ -237,9 +227,9 @@ public:
      *    deletes the input scenes afterwards. There may be duplicate scenes.
      *  @param flags Combination of the AI_INT_MERGE_SCENE flags defined above
      */
-    static void MergeScenes(aiScene** dest, aiScene* master,
-        std::vector<AttachmentInfo>& src,
-        unsigned int flags = 0);
+    static void MergeScenes(aiScene **dest, aiScene *master,
+            std::vector<AttachmentInfo> &src,
+            unsigned int flags = 0);
 
     // -------------------------------------------------------------------
     /** Merges two or more meshes
@@ -255,9 +245,9 @@ public:
      *  @param begin First mesh to be processed
      *  @param end Points to the mesh after the last mesh to be processed
      */
-    static void MergeMeshes(aiMesh** dest,unsigned int flags,
-        std::vector<aiMesh*>::const_iterator begin,
-        std::vector<aiMesh*>::const_iterator end);
+    static void MergeMeshes(aiMesh **dest, unsigned int flags,
+            std::vector<aiMesh *>::const_iterator begin,
+            std::vector<aiMesh *>::const_iterator end);
 
     // -------------------------------------------------------------------
     /** Merges two or more bones
@@ -267,8 +257,8 @@ public:
      *  @param begin First mesh to be processed
      *  @param end Points to the mesh after the last mesh to be processed
      */
-    static void MergeBones(aiMesh* out,std::vector<aiMesh*>::const_iterator it,
-        std::vector<aiMesh*>::const_iterator end);
+    static void MergeBones(aiMesh *out, std::vector<aiMesh *>::const_iterator it,
+            std::vector<aiMesh *>::const_iterator end);
 
     // -------------------------------------------------------------------
     /** Merges two or more materials
@@ -281,9 +271,9 @@ public:
      *  @param begin First material to be processed
      *  @param end Points to the material after the last material to be processed
      */
-    static void MergeMaterials(aiMaterial** dest,
-        std::vector<aiMaterial*>::const_iterator begin,
-        std::vector<aiMaterial*>::const_iterator end);
+    static void MergeMaterials(aiMaterial **dest,
+            std::vector<aiMaterial *>::const_iterator begin,
+            std::vector<aiMaterial *>::const_iterator end);
 
     // -------------------------------------------------------------------
     /** Builds a list of uniquely named bones in a mesh list
@@ -292,9 +282,9 @@ public:
      *  @param it First mesh to be processed
      *  @param end Last mesh to be processed
      */
-    static void BuildUniqueBoneList(std::list<BoneWithHash>& asBones,
-        std::vector<aiMesh*>::const_iterator it,
-        std::vector<aiMesh*>::const_iterator end);
+    static void BuildUniqueBoneList(std::list<BoneWithHash> &asBones,
+            std::vector<aiMesh *>::const_iterator it,
+            std::vector<aiMesh *>::const_iterator end);
 
     // -------------------------------------------------------------------
     /** Add a name prefix to all nodes in a scene.
@@ -303,8 +293,8 @@ public:
      *  @param prefix Prefix to be added to all nodes
      *  @param len STring length
      */
-    static void AddNodePrefixes(aiNode* node, const char* prefix,
-        unsigned int len);
+    static void AddNodePrefixes(aiNode *node, const char *prefix,
+            unsigned int len);
 
     // -------------------------------------------------------------------
     /** Add an offset to all mesh indices in a node graph
@@ -312,7 +302,7 @@ public:
      *  @param Current node. This function is called recursively.
      *  @param offset Offset to be added to all mesh indices
      */
-    static void OffsetNodeMeshIndices (aiNode* node, unsigned int offset);
+    static void OffsetNodeMeshIndices(aiNode *node, unsigned int offset);
 
     // -------------------------------------------------------------------
     /** Attach a list of node graphs to well-defined nodes in a master
@@ -320,18 +310,17 @@ public:
      *
      *  @param master Master scene
      *  @param srcList List of source scenes along with their attachment
-     *    points. If an attachment point is NULL (or does not exist in
+     *    points. If an attachment point is nullptr (or does not exist in
      *    the master graph), a scene is attached to the root of the master
      *    graph (as an additional child node)
      *  @duplicates List of duplicates. If elem[n] == n the scene is not
      *    a duplicate. Otherwise elem[n] links scene n to its first occurrence.
      */
-    static void AttachToGraph ( aiScene* master,
-        std::vector<NodeAttachmentInfo>& srcList);
-
-    static void AttachToGraph (aiNode* attach,
-        std::vector<NodeAttachmentInfo>& srcList);
+    static void AttachToGraph(aiScene *master,
+            std::vector<NodeAttachmentInfo> &srcList);
 
+    static void AttachToGraph(aiNode *attach,
+            std::vector<NodeAttachmentInfo> &srcList);
 
     // -------------------------------------------------------------------
     /** Get a deep copy of a scene
@@ -339,21 +328,19 @@ public:
      *  @param dest Receives a pointer to the destination scene
      *  @param src Source scene - remains unmodified.
      */
-    static void CopyScene(aiScene** dest,const aiScene* source,bool allocate = true);
-
+    static void CopyScene(aiScene **dest, const aiScene *source, bool allocate = true);
 
     // -------------------------------------------------------------------
     /** Get a flat copy of a scene
      *
      *  Only the first hierarchy layer is copied. All pointer members of
      *  aiScene are shared by source and destination scene.  If the
-     *    pointer doesn't point to NULL when the function is called, the
+     *    pointer doesn't point to nullptr when the function is called, the
      *    existing scene is cleared and refilled.
      *  @param dest Receives a pointer to the destination scene
      *  @param src Source scene - remains unmodified.
      */
-    static void CopySceneFlat(aiScene** dest,const aiScene* source);
-
+    static void CopySceneFlat(aiScene **dest, const aiScene *source);
 
     // -------------------------------------------------------------------
     /** Get a deep copy of a mesh
@@ -361,43 +348,42 @@ public:
      *  @param dest Receives a pointer to the destination mesh
      *  @param src Source mesh - remains unmodified.
      */
-    static void Copy     (aiMesh** dest, const aiMesh* src);
+    static void Copy(aiMesh **dest, const aiMesh *src);
 
     // similar to Copy():
-    static void Copy  (aiAnimMesh** dest, const aiAnimMesh* src);
-    static void Copy  (aiMaterial** dest, const aiMaterial* src);
-    static void Copy  (aiTexture** dest, const aiTexture* src);
-    static void Copy  (aiAnimation** dest, const aiAnimation* src);
-    static void Copy  (aiCamera** dest, const aiCamera* src);
-    static void Copy  (aiBone** dest, const aiBone* src);
-    static void Copy  (aiLight** dest, const aiLight* src);
-    static void Copy  (aiNodeAnim** dest, const aiNodeAnim* src);
-    static void Copy  (aiMetadata** dest, const aiMetadata* src);
+    static void Copy(aiAnimMesh **dest, const aiAnimMesh *src);
+    static void Copy(aiMaterial **dest, const aiMaterial *src);
+    static void Copy(aiTexture **dest, const aiTexture *src);
+    static void Copy(aiAnimation **dest, const aiAnimation *src);
+    static void Copy(aiCamera **dest, const aiCamera *src);
+    static void Copy(aiBone **dest, const aiBone *src);
+    static void Copy(aiLight **dest, const aiLight *src);
+    static void Copy(aiNodeAnim **dest, const aiNodeAnim *src);
+    static void Copy(aiMeshMorphAnim **dest, const aiMeshMorphAnim *src);
+    static void Copy(aiMetadata **dest, const aiMetadata *src);
+    static void Copy(aiString **dest, const aiString *src);
 
     // recursive, of course
-    static void Copy     (aiNode** dest, const aiNode* src);
-
+    static void Copy(aiNode **dest, const aiNode *src);
 
 private:
-
     // -------------------------------------------------------------------
     // Same as AddNodePrefixes, but with an additional check
-    static void AddNodePrefixesChecked(aiNode* node, const char* prefix,
-        unsigned int len,
-        std::vector<SceneHelper>& input,
-        unsigned int cur);
+    static void AddNodePrefixesChecked(aiNode *node, const char *prefix,
+            unsigned int len,
+            std::vector<SceneHelper> &input,
+            unsigned int cur);
 
     // -------------------------------------------------------------------
     // Add node identifiers to a hashing set
-    static void AddNodeHashes(aiNode* node, std::set<unsigned int>& hashes);
-
+    static void AddNodeHashes(aiNode *node, std::set<unsigned int> &hashes);
 
     // -------------------------------------------------------------------
     // Search for duplicate names
-    static bool FindNameMatch(const aiString& name,
-        std::vector<SceneHelper>& input, unsigned int cur);
+    static bool FindNameMatch(const aiString &name,
+            std::vector<SceneHelper> &input, unsigned int cur);
 };
 
-}
+} // namespace Assimp
 
 #endif // !! AI_SCENE_COMBINER_H_INC
diff --git a/Engine/lib/assimp/include/assimp/SkeletonMeshBuilder.h b/Engine/lib/assimp/include/assimp/SkeletonMeshBuilder.h
index f9b8d9f55..2929aaa61 100644
--- a/Engine/lib/assimp/include/assimp/SkeletonMeshBuilder.h
+++ b/Engine/lib/assimp/include/assimp/SkeletonMeshBuilder.h
@@ -4,8 +4,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -47,17 +46,22 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  for animation skeletons.
  */
 
+#pragma once
 #ifndef AI_SKELETONMESHBUILDER_H_INC
 #define AI_SKELETONMESHBUILDER_H_INC
 
-#include <vector>
+#ifdef __GNUC__
+#pragma GCC system_header
+#endif
+
 #include <assimp/mesh.h>
+#include <vector>
 
 struct aiMaterial;
 struct aiScene;
 struct aiNode;
 
-namespace Assimp    {
+namespace Assimp {
 
 // ---------------------------------------------------------------------------
 /**
@@ -65,57 +69,56 @@ namespace Assimp    {
  * the resembles the node hierarchy. This is useful for file formats
  * that don't carry any mesh data but only animation data.
  */
-class ASSIMP_API SkeletonMeshBuilder
-{
+class ASSIMP_API SkeletonMeshBuilder {
 public:
-
     // -------------------------------------------------------------------
     /** The constructor processes the given scene and adds a mesh there.
      *
      * Does nothing if the scene already has mesh data.
      * @param pScene The scene for which a skeleton mesh should be constructed.
-     * @param root The node to start with. NULL is the scene root
+     * @param root The node to start with. nullptr is the scene root
      * @param bKnobsOnly Set this to true if you don't want the connectors
      *   between the knobs representing the nodes.
      */
-    SkeletonMeshBuilder( aiScene* pScene, aiNode* root = NULL,
-        bool bKnobsOnly = false);
+    SkeletonMeshBuilder(aiScene *pScene, aiNode *root = nullptr,
+            bool bKnobsOnly = false);
 
 protected:
-
     // -------------------------------------------------------------------
     /** Recursively builds a simple mesh representation for the given node
      * and also creates a joint for the node that affects this part of
      * the mesh.
      * @param pNode The node to build geometry for.
      */
-    void CreateGeometry( const aiNode* pNode);
+    void CreateGeometry(const aiNode *pNode);
 
     // -------------------------------------------------------------------
     /** Creates the mesh from the internally accumulated stuff and returns it.
      */
-    aiMesh* CreateMesh();
+    aiMesh *CreateMesh();
 
     // -------------------------------------------------------------------
     /** Creates a dummy material and returns it. */
-    aiMaterial* CreateMaterial();
+    aiMaterial *CreateMaterial();
 
-protected:
+private:
     /** space to assemble the mesh data: points */
     std::vector<aiVector3D> mVertices;
 
     /** faces */
-    struct Face
-    {
+    struct Face {
         unsigned int mIndices[3];
         Face();
-        Face( unsigned int p0, unsigned int p1, unsigned int p2)
-        { mIndices[0] = p0; mIndices[1] = p1; mIndices[2] = p2; }
+        Face(unsigned int p0, unsigned int p1, unsigned int p2) {
+            mIndices[0] = p0;
+            mIndices[1] = p1;
+            mIndices[2] = p2;
+        }
     };
     std::vector<Face> mFaces;
 
     /** bones */
-    std::vector<aiBone*> mBones;
+    std::vector<aiBone *> mBones;
 
     bool mKnobsOnly;
 };
diff --git a/Engine/lib/assimp/include/assimp/SmallVector.h b/Engine/lib/assimp/include/assimp/SmallVector.h
new file mode 100644
index 000000000..60ad26411
--- /dev/null
+++ b/Engine/lib/assimp/include/assimp/SmallVector.h
@@ -0,0 +1,164 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file Defines small vector with inplace storage.
+Based on CppCon 2016: Chandler Carruth "High Performance Code 201: Hybrid Data Structures" */
+
+#pragma once
+#ifndef AI_SMALLVECTOR_H_INC
+#define AI_SMALLVECTOR_H_INC
+
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
+namespace Assimp {
+
+// --------------------------------------------------------------------------------------------
+/// @brief Small vector with inplace storage.
+///
+/// Reduces heap allocations when list is shorter. It uses a small array for a dedicated size.
+/// When the growing gets bigger than this small cache a dynamic growing algorithm will be
+/// used.
+// --------------------------------------------------------------------------------------------
+template<typename T, unsigned int Capacity>
+class SmallVector {
+public:
+    /// @brief  The default class constructor.
+    SmallVector() :
+            mStorage(mInplaceStorage),
+            mSize(0),
+            mCapacity(Capacity) {
+        // empty
+    }
+
+    /// @brief  The class destructor.
+    ~SmallVector() {
+        if (mStorage != mInplaceStorage) {
+            delete [] mStorage;
+        }
+    }
+
+    /// @brief  Will push a new item. The capacity will grow in case of a too small capacity.
+    /// @param  item    [in] The item to push at the end of the vector.
+    void push_back(const T& item) {
+        if (mSize < mCapacity) {
+            mStorage[mSize++] = item;
+            return;
+        }
+
+        push_back_and_grow(item);
+    }
+
+    /// @brief  Will resize the vector.
+    /// @param  newSize     [in] The new size.
+    void resize(size_t newSize) {
+        if (newSize > mCapacity) {
+            grow(newSize);
+        }
+        mSize = newSize;
+    }
+
+    /// @brief  Returns the current size of the vector.
+    /// @return The current size.
+    size_t size() const {
+        return mSize;
+    }
+
+    /// @brief  Returns a pointer to the first item.
+    /// @return The first item as a pointer.
+    T* begin() {
+        return mStorage;
+    }
+
+    /// @brief  Returns a pointer to the end.
+    /// @return The end as a pointer.
+    T* end() {
+        return &mStorage[mSize];
+    }
+
+    /// @brief  Returns a const pointer to the first item.
+    /// @return The first item as a const pointer.
+    T* begin() const {
+        return mStorage;
+    }
+
+    /// @brief  Returns a const pointer to the end.
+    /// @return The end as a const pointer.
+    T* end() const {
+        return &mStorage[mSize];
+    }
+
+    SmallVector(const SmallVector &) = delete;
+    SmallVector(SmallVector &&) = delete;
+    SmallVector &operator = (const SmallVector &) = delete;
+    SmallVector &operator = (SmallVector &&) = delete;
+
+private:
+    void grow( size_t newCapacity) {
+        T* oldStorage = mStorage;
+        T* newStorage = new T[newCapacity];
+
+        std::memcpy(newStorage, oldStorage, mSize * sizeof(T));
+
+        mStorage = newStorage;
+        mCapacity = newCapacity;
+
+        if (oldStorage != mInplaceStorage) {
+            delete [] oldStorage;
+        }
+    }
+
+    void push_back_and_grow(const T& item) {
+        grow(mCapacity + Capacity);
+
+        mStorage[mSize++] = item;
+    }
+
+    T* mStorage;
+    size_t mSize;
+    size_t mCapacity;
+    T mInplaceStorage[Capacity];
+};
+
+} // end namespace Assimp
+
+#endif // !! AI_SMALLVECTOR_H_INC
diff --git a/Engine/lib/assimp/include/assimp/SmoothingGroups.h b/Engine/lib/assimp/include/assimp/SmoothingGroups.h
index 92d65cea0..4625a2916 100644
--- a/Engine/lib/assimp/include/assimp/SmoothingGroups.h
+++ b/Engine/lib/assimp/include/assimp/SmoothingGroups.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -43,10 +43,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Defines the helper data structures for importing 3DS files.
 http://www.jalix.org/ressources/graphics/3DS/_unofficials/3ds-unofficial.txt */
 
+#pragma once
 #ifndef AI_SMOOTHINGGROUPS_H_INC
 #define AI_SMOOTHINGGROUPS_H_INC
 
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
 #include <assimp/vector3.h>
+
 #include <stdint.h>
 #include <vector>
 
diff --git a/Engine/lib/assimp/include/assimp/SmoothingGroups.inl b/Engine/lib/assimp/include/assimp/SmoothingGroups.inl
index 84ea4a1b0..d5fff5bf7 100644
--- a/Engine/lib/assimp/include/assimp/SmoothingGroups.inl
+++ b/Engine/lib/assimp/include/assimp/SmoothingGroups.inl
@@ -3,12 +3,12 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2012, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
-Redistribution and use of this software in source and binary forms, 
-with or without modification, are permitted provided that the following 
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
 conditions are met:
 
 * Redistributions of source code must retain the above
@@ -25,29 +25,32 @@ conditions are met:
   derived from this software without specific prior
   written permission of the assimp team.
 
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
 
 /** @file Generation of normal vectors basing on smoothing groups */
 
+#pragma once
 #ifndef AI_SMOOTHINGGROUPS_INL_INCLUDED
 #define AI_SMOOTHINGGROUPS_INL_INCLUDED
 
-// internal headers
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
 #include <assimp/SGSpatialSort.h>
 
-// CRT header
 #include <algorithm>
 
 using namespace Assimp;
@@ -74,7 +77,7 @@ void ComputeNormalsWithSmoothingsGroups(MeshWithSmoothingGroups<T>& sMesh)
             sMesh.mNormals[face.mIndices[c]] = vNor;
     }
 
-    // calculate the position bounds so we have a reliable epsilon to check position differences against 
+    // calculate the position bounds so we have a reliable epsilon to check position differences against
     aiVector3D minVec( 1e10f, 1e10f, 1e10f), maxVec( -1e10f, -1e10f, -1e10f);
     for( unsigned int a = 0; a < sMesh.mPositions.size(); a++)
     {
@@ -88,7 +91,7 @@ void ComputeNormalsWithSmoothingsGroups(MeshWithSmoothingGroups<T>& sMesh)
     const float posEpsilon = (maxVec - minVec).Length() * 1e-5f;
     std::vector<aiVector3D> avNormals;
     avNormals.resize(sMesh.mNormals.size());
-    
+
     // now generate the spatial sort tree
     SGSpatialSort sSort;
     for( typename std::vector<T>::iterator i =  sMesh.mFaces.begin();
diff --git a/Engine/lib/assimp/include/assimp/SpatialSort.h b/Engine/lib/assimp/include/assimp/SpatialSort.h
index 61b345bcb..87b009da7 100644
--- a/Engine/lib/assimp/include/assimp/SpatialSort.h
+++ b/Engine/lib/assimp/include/assimp/SpatialSort.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -41,11 +41,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 /** Small helper classes to optimise finding vertizes close to a given location */
+#pragma once
 #ifndef AI_SPATIALSORT_H_INC
 #define AI_SPATIALSORT_H_INC
 
-#include <vector>
+#ifdef __GNUC__
+#pragma GCC system_header
+#endif
+
 #include <assimp/types.h>
+#include <vector>
+#include <limits>
 
 namespace Assimp {
 
@@ -57,10 +63,8 @@ namespace Assimp {
  * time, with O(n) worst case complexity when all vertices lay on the plane. The plane is chosen
  * so that it avoids common planes in usual data sets. */
 // ------------------------------------------------------------------------------------------------
-class ASSIMP_API SpatialSort
-{
+class ASSIMP_API SpatialSort {
 public:
-
     SpatialSort();
 
     // ------------------------------------------------------------------------------------
@@ -71,14 +75,12 @@ public:
      * @param pNumPositions Number of vectors to expect in that array.
      * @param pElementOffset Offset in bytes from the beginning of one vector in memory
      *   to the beginning of the next vector. */
-    SpatialSort( const aiVector3D* pPositions, unsigned int pNumPositions,
-        unsigned int pElementOffset);
+    SpatialSort(const aiVector3D *pPositions, unsigned int pNumPositions,
+            unsigned int pElementOffset);
 
     /** Destructor */
     ~SpatialSort();
 
-public:
-
     // ------------------------------------------------------------------------------------
     /** Sets the input data for the SpatialSort. This replaces existing data, if any.
      *  The new data receives new indices in ascending order.
@@ -92,17 +94,15 @@ public:
      *   required in order to use #FindPosition() or #GenerateMappingTable().
      *   If you don't finalize yet, you can use #Append() to add data from
      *   other sources.*/
-    void Fill( const aiVector3D* pPositions, unsigned int pNumPositions,
-        unsigned int pElementOffset,
-        bool pFinalize = true);
-
+    void Fill(const aiVector3D *pPositions, unsigned int pNumPositions,
+            unsigned int pElementOffset,
+            bool pFinalize = true);
 
     // ------------------------------------------------------------------------------------
     /** Same as #Fill(), except the method appends to existing data in the #SpatialSort. */
-    void Append( const aiVector3D* pPositions, unsigned int pNumPositions,
-        unsigned int pElementOffset,
-        bool pFinalize = true);
-
+    void Append(const aiVector3D *pPositions, unsigned int pNumPositions,
+            unsigned int pElementOffset,
+            bool pFinalize = true);
 
     // ------------------------------------------------------------------------------------
     /** Finalize the spatial hash data structure. This can be useful after
@@ -118,8 +118,8 @@ public:
      * @param poResults The container to store the indices of the found positions.
      *   Will be emptied by the call so it may contain anything.
      * @return An iterator to iterate over all vertices in the given area.*/
-    void FindPositions( const aiVector3D& pPosition, ai_real pRadius,
-        std::vector<unsigned int>& poResults) const;
+    void FindPositions(const aiVector3D &pPosition, ai_real pRadius,
+            std::vector<unsigned int> &poResults) const;
 
     // ------------------------------------------------------------------------------------
     /** Fills an array with indices of all positions identical to the given position. In
@@ -128,8 +128,8 @@ public:
      * @param pPosition The position to look for vertices.
      * @param poResults The container to store the indices of the found positions.
      *   Will be emptied by the call so it may contain anything.*/
-    void FindIdenticalPositions( const aiVector3D& pPosition,
-        std::vector<unsigned int>& poResults) const;
+    void FindIdenticalPositions(const aiVector3D &pPosition,
+            std::vector<unsigned int> &poResults) const;
 
     // ------------------------------------------------------------------------------------
     /** Compute a table that maps each vertex ID referring to a spatially close
@@ -139,34 +139,50 @@ public:
      * @param pRadius Maximal distance from the position a vertex may have to
      *   be counted in.
      *  @return Number of unique vertices (n).  */
-    unsigned int GenerateMappingTable(std::vector<unsigned int>& fill,
-        ai_real pRadius) const;
+    unsigned int GenerateMappingTable(std::vector<unsigned int> &fill,
+            ai_real pRadius) const;
 
 protected:
-    /** Normal of the sorting plane, normalized. The center is always at (0, 0, 0) */
+    /** Return the distance to the sorting plane. */
+    ai_real CalculateDistance(const aiVector3D &pPosition) const;
+
+protected:
+    /** Normal of the sorting plane, normalized.
+     */
     aiVector3D mPlaneNormal;
 
+    /** The centroid of the positions, which is used as a point on the sorting plane
+     * when calculating distance. This value is calculated in Finalize.
+    */
+    aiVector3D mCentroid;
+
     /** An entry in a spatially sorted position array. Consists of a vertex index,
      * its position and its pre-calculated distance from the reference plane */
     struct Entry {
         unsigned int mIndex; ///< The vertex referred by this entry
         aiVector3D mPosition; ///< Position
-        ai_real mDistance; ///< Distance of this vertex to the sorting plane
+        /// Distance of this vertex to the sorting plane. This is set by Finalize.
+        ai_real mDistance; 
 
         Entry() AI_NO_EXCEPT
-        : mIndex( 999999999 ), mPosition(), mDistance( 99999. ) {
-            // empty        
+                : mIndex(std::numeric_limits<unsigned int>::max()),
+                  mPosition(),
+                  mDistance(std::numeric_limits<ai_real>::max()) {
+            // empty
         }
-        Entry( unsigned int pIndex, const aiVector3D& pPosition, ai_real pDistance)
-        : mIndex( pIndex), mPosition( pPosition), mDistance( pDistance) {
+        Entry(unsigned int pIndex, const aiVector3D &pPosition) :
+                mIndex(pIndex), mPosition(pPosition), mDistance(std::numeric_limits<ai_real>::max()) {
             // empty
         }
 
-        bool operator < (const Entry& e) const { return mDistance < e.mDistance; }
+        bool operator<(const Entry &e) const { return mDistance < e.mDistance; }
     };
 
     // all positions, sorted by distance to the sorting plane
     std::vector<Entry> mPositions;
+
+    /// false until the Finalize method is called.
+    bool mFinalized;
 };
 
 } // end of namespace Assimp
diff --git a/Engine/lib/assimp/include/assimp/StandardShapes.h b/Engine/lib/assimp/include/assimp/StandardShapes.h
index 3791569b8..77880cf9e 100644
--- a/Engine/lib/assimp/include/assimp/StandardShapes.h
+++ b/Engine/lib/assimp/include/assimp/StandardShapes.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -41,12 +41,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 /** @file Declares a helper class, "StandardShapes" which generates
- *  vertices for standard shapes, such as cylnders, cones, spheres ..
+ *  vertices for standard shapes, such as cylinders, cones, spheres ..
  */
+#pragma once
 #ifndef AI_STANDARD_SHAPES_H_INC
 #define AI_STANDARD_SHAPES_H_INC
 
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
 #include <assimp/vector3.h>
+#include <stddef.h>
 #include <vector>
 
 struct aiMesh;
diff --git a/Engine/lib/assimp/include/assimp/StreamReader.h b/Engine/lib/assimp/include/assimp/StreamReader.h
index 9116c1426..44b24a33b 100644
--- a/Engine/lib/assimp/include/assimp/StreamReader.h
+++ b/Engine/lib/assimp/include/assimp/StreamReader.h
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -44,15 +42,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Defines the StreamReader class which reads data from
  *  a binary stream with a well-defined endianness.
  */
-
+#pragma once
 #ifndef AI_STREAMREADER_H_INCLUDED
 #define AI_STREAMREADER_H_INCLUDED
 
-#include <assimp/IOStream.hpp>
-#include <assimp/Defines.h>
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
+#include <assimp/ByteSwapper.h>
+#include <assimp/Exceptional.h>
+#include <assimp/IOStream.hpp>
 
-#include "ByteSwapper.h"
-#include "Exceptional.h"
 #include <memory>
 
 namespace Assimp {
@@ -70,10 +71,8 @@ namespace Assimp {
 template <bool SwapEndianess = false, bool RuntimeSwitch = false>
 class StreamReader {
 public:
-    // FIXME: use these data types throughout the whole library,
-    // then change them to 64 bit values :-)
-    using diff = int;
-    using pos  = unsigned int;
+    using diff = size_t;
+    using pos = size_t;
 
     // ---------------------------------------------------------------------
     /** Construction from a given stream with a well-defined endianness.
@@ -87,40 +86,45 @@ public:
      *    stream is in little endian byte order. Otherwise the
      *    endianness information is contained in the @c SwapEndianess
      *    template parameter and this parameter is meaningless.  */
-    StreamReader(std::shared_ptr<IOStream> stream, bool le = false)
-        : stream(stream)
-        , le(le)
-    {
+    StreamReader(std::shared_ptr<IOStream> stream, bool le = false) :
+            mStream(stream),
+            mBuffer(nullptr),
+            mCurrent(nullptr),
+            mEnd(nullptr),
+            mLimit(nullptr),
+            mLe(le) {
         ai_assert(stream);
         InternBegin();
     }
 
     // ---------------------------------------------------------------------
-    StreamReader(IOStream* stream, bool le = false)
-        : stream(std::shared_ptr<IOStream>(stream))
-        , le(le)
-    {
-        ai_assert(stream);
+    StreamReader(IOStream *stream, bool le = false) :
+            mStream(std::shared_ptr<IOStream>(stream)),
+            mBuffer(nullptr),
+            mCurrent(nullptr),
+            mEnd(nullptr),
+            mLimit(nullptr),
+            mLe(le) {
+        ai_assert(nullptr != stream);
         InternBegin();
     }
 
     // ---------------------------------------------------------------------
     ~StreamReader() {
-        delete[] buffer;
+        delete[] mBuffer;
     }
 
     // deprecated, use overloaded operator>> instead
 
     // ---------------------------------------------------------------------
-    /** Read a float from the stream  */
-    float GetF4()
-    {
+    /// Read a float from the stream.
+    float GetF4() {
         return Get<float>();
     }
 
     // ---------------------------------------------------------------------
-    /** Read a double from the stream  */
-    double GetF8()  {
+    /// Read a double from the stream.
+    double GetF8() {
         return Get<double>();
     }
 
@@ -132,7 +136,7 @@ public:
 
     // ---------------------------------------------------------------------
     /** Read a signed 8 bit integer from the stream */
-    int8_t GetI1()  {
+    int8_t GetI1() {
         return Get<int8_t>();
     }
 
@@ -150,66 +154,66 @@ public:
 
     // ---------------------------------------------------------------------
     /** Read a unsigned 16 bit integer from the stream */
-    uint16_t GetU2()    {
+    uint16_t GetU2() {
         return Get<uint16_t>();
     }
 
     // ---------------------------------------------------------------------
-    /** Read a unsigned 8 bit integer from the stream */
+    /// Read a unsigned 8 bit integer from the stream
     uint8_t GetU1() {
         return Get<uint8_t>();
     }
 
     // ---------------------------------------------------------------------
-    /** Read an unsigned 32 bit integer from the stream */
-    uint32_t GetU4()    {
+    /// Read an unsigned 32 bit integer from the stream
+    uint32_t GetU4() {
         return Get<uint32_t>();
     }
 
     // ---------------------------------------------------------------------
-    /** Read a unsigned 64 bit integer from the stream */
-    uint64_t GetU8()    {
+    /// Read a unsigned 64 bit integer from the stream
+    uint64_t GetU8() {
         return Get<uint64_t>();
     }
 
     // ---------------------------------------------------------------------
-    /** Get the remaining stream size (to the end of the stream) */
-    unsigned int GetRemainingSize() const {
-        return (unsigned int)(end - current);
+    /// Get the remaining stream size (to the end of the stream)
+    size_t GetRemainingSize() const {
+        return (unsigned int)(mEnd - mCurrent);
     }
 
     // ---------------------------------------------------------------------
     /** Get the remaining stream size (to the current read limit). The
      *  return value is the remaining size of the stream if no custom
      *  read limit has been set. */
-    unsigned int GetRemainingSizeToLimit() const {
-        return (unsigned int)(limit - current);
+    size_t GetRemainingSizeToLimit() const {
+        return (unsigned int)(mLimit - mCurrent);
     }
 
     // ---------------------------------------------------------------------
     /** Increase the file pointer (relative seeking)  */
-    void IncPtr(intptr_t plus)    {
-        current += plus;
-        if (current > limit) {
+    void IncPtr(intptr_t plus) {
+        mCurrent += plus;
+        if (mCurrent > mLimit) {
             throw DeadlyImportError("End of file or read limit was reached");
         }
     }
 
     // ---------------------------------------------------------------------
     /** Get the current file pointer */
-    int8_t* GetPtr() const  {
-        return current;
+    int8_t *GetPtr() const {
+        return mCurrent;
     }
 
     // ---------------------------------------------------------------------
     /** Set current file pointer (Get it from #GetPtr). This is if you
-     *  prefer to do pointer arithmetics on your own or want to copy
+     *  prefer to do pointer arithmetic on your own or want to copy
      *  large chunks of data at once.
      *  @param p The new pointer, which is validated against the size
      *    limit and buffer boundaries. */
-    void SetPtr(int8_t* p)  {
-        current = p;
-        if (current > limit || current < buffer) {
+    void SetPtr(int8_t *p) {
+        mCurrent = p;
+        if (mCurrent > mLimit || mCurrent < mBuffer) {
             throw DeadlyImportError("End of file or read limit was reached");
         }
     }
@@ -218,21 +222,20 @@ public:
     /** Copy n bytes to an external buffer
      *  @param out Destination for copying
      *  @param bytes Number of bytes to copy */
-    void CopyAndAdvance(void* out, size_t bytes)    {
-        int8_t* ur = GetPtr();
-        SetPtr(ur+bytes); // fire exception if eof
+    void CopyAndAdvance(void *out, size_t bytes) {
+        int8_t *ur = GetPtr();
+        SetPtr(ur + bytes); // fire exception if eof
 
-        ::memcpy(out,ur,bytes);
+        ::memcpy(out, ur, bytes);
     }
 
-    // ---------------------------------------------------------------------
-    /** Get the current offset from the beginning of the file */
-    int GetCurrentPos() const   {
-        return (unsigned int)(current - buffer);
+    /// @brief Get the current offset from the beginning of the file
+    int GetCurrentPos() const {
+        return (unsigned int)(mCurrent - mBuffer);
     }
 
     void SetCurrentPos(size_t pos) {
-        SetPtr(buffer + pos);
+        SetPtr(mBuffer + pos);
     }
 
     // ---------------------------------------------------------------------
@@ -242,15 +245,15 @@ public:
      *    the beginning of the file. Specifying UINT_MAX
      *    resets the limit to the original end of the stream.
      *  Returns the previously set limit. */
-    unsigned int SetReadLimit(unsigned int _limit)  {
+    unsigned int SetReadLimit(unsigned int _limit) {
         unsigned int prev = GetReadLimit();
         if (UINT_MAX == _limit) {
-            limit = end;
+            mLimit = mEnd;
             return prev;
         }
 
-        limit = buffer + _limit;
-        if (limit > end) {
+        mLimit = mBuffer + _limit;
+        if (mLimit > mEnd) {
             throw DeadlyImportError("StreamReader: Invalid read limit");
         }
         return prev;
@@ -259,21 +262,21 @@ public:
     // ---------------------------------------------------------------------
     /** Get the current read limit in bytes. Reading over this limit
      *  accidentally raises an exception.  */
-    unsigned int GetReadLimit() const    {
-        return (unsigned int)(limit - buffer);
+    unsigned int GetReadLimit() const {
+        return (unsigned int)(mLimit - mBuffer);
     }
 
     // ---------------------------------------------------------------------
     /** Skip to the read limit in bytes. Reading over this limit
      *  accidentally raises an exception. */
-    void SkipToReadLimit()  {
-        current = limit;
+    void SkipToReadLimit() {
+        mCurrent = mLimit;
     }
 
     // ---------------------------------------------------------------------
     /** overload operator>> and allow chaining of >> ops. */
     template <typename T>
-    StreamReader& operator >> (T& f) {
+    StreamReader &operator>>(T &f) {
         f = Get<T>();
         return *this;
     }
@@ -282,14 +285,14 @@ public:
     /** Generic read method. ByteSwap::Swap(T*) *must* be defined */
     template <typename T>
     T Get() {
-        if ( current + sizeof(T) > limit) {
+        if (mCurrent + sizeof(T) > mLimit) {
             throw DeadlyImportError("End of file or stream limit was reached");
         }
 
         T f;
-        ::memcpy (&f, current, sizeof(T));
-        Intern::Getter<SwapEndianess,T,RuntimeSwitch>() (&f,le);
-        current += sizeof(T);
+        ::memcpy(&f, mCurrent, sizeof(T));
+        Intern::Getter<SwapEndianess, T, RuntimeSwitch>()(&f, mLe);
+        mCurrent += sizeof(T);
 
         return f;
     }
@@ -297,46 +300,44 @@ public:
 private:
     // ---------------------------------------------------------------------
     void InternBegin() {
-        if (!stream) {
-            // in case someone wonders: StreamReader is frequently invoked with
-            // no prior validation whether the input stream is valid. Since
-            // no one bothers changing the error message, this message here
-            // is passed down to the caller and 'unable to open file'
-            // simply describes best what happened.
+        if (nullptr == mStream) {
             throw DeadlyImportError("StreamReader: Unable to open file");
         }
 
-        const size_t s = stream->FileSize() - stream->Tell();
-        if (!s) {
+        const size_t filesize = mStream->FileSize() - mStream->Tell();
+        if (0 == filesize) {
             throw DeadlyImportError("StreamReader: File is empty or EOF is already reached");
         }
 
-        current = buffer = new int8_t[s];
-        const size_t read = stream->Read(current,1,s);
+        mCurrent = mBuffer = new int8_t[filesize];
+        const size_t read = mStream->Read(mCurrent, 1, filesize);
         // (read < s) can only happen if the stream was opened in text mode, in which case FileSize() is not reliable
-        ai_assert(read <= s);
-        end = limit = &buffer[read-1] + 1;
+        ai_assert(read <= filesize);
+        mEnd = mLimit = &mBuffer[read - 1] + 1;
     }
 
 private:
-    std::shared_ptr<IOStream> stream;
-    int8_t *buffer, *current, *end, *limit;
-    bool le;
+    std::shared_ptr<IOStream> mStream;
+    int8_t *mBuffer;
+    int8_t *mCurrent;
+    int8_t *mEnd;
+    int8_t *mLimit;
+    bool mLe;
 };
 
 // --------------------------------------------------------------------------------------------
 // `static` StreamReaders. Their byte order is fixed and they might be a little bit faster.
 #ifdef AI_BUILD_BIG_ENDIAN
-    typedef StreamReader<true>  StreamReaderLE;
-    typedef StreamReader<false> StreamReaderBE;
+typedef StreamReader<true> StreamReaderLE;
+typedef StreamReader<false> StreamReaderBE;
 #else
-    typedef StreamReader<true>  StreamReaderBE;
-    typedef StreamReader<false> StreamReaderLE;
+typedef StreamReader<true> StreamReaderBE;
+typedef StreamReader<false> StreamReaderLE;
 #endif
 
 // `dynamic` StreamReader. The byte order of the input data is specified in the
 // c'tor. This involves runtime branching and might be a little bit slower.
-typedef StreamReader<true,true> StreamReaderAny;
+typedef StreamReader<true, true> StreamReaderAny;
 
 } // end namespace Assimp
 
diff --git a/Engine/lib/assimp/include/assimp/StreamWriter.h b/Engine/lib/assimp/include/assimp/StreamWriter.h
index c7cf6c0d7..1bdfcc650 100644
--- a/Engine/lib/assimp/include/assimp/StreamWriter.h
+++ b/Engine/lib/assimp/include/assimp/StreamWriter.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -43,11 +43,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** @file Defines the StreamWriter class which writes data to
  *  a binary stream with a well-defined endianness. */
-
+#pragma once
 #ifndef AI_STREAMWRITER_H_INCLUDED
 #define AI_STREAMWRITER_H_INCLUDED
 
-#include "ByteSwapper.h"
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
+#include <assimp/ByteSwapper.h>
 #include <assimp/IOStream.hpp>
 
 #include <memory>
diff --git a/Engine/lib/assimp/include/assimp/StringComparison.h b/Engine/lib/assimp/include/assimp/StringComparison.h
index 8acef277b..0518d426d 100644
--- a/Engine/lib/assimp/include/assimp/StringComparison.h
+++ b/Engine/lib/assimp/include/assimp/StringComparison.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -49,18 +49,23 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    These functions are not consistently available on all platforms,
    or the provided implementations behave too differently.
 */
+#pragma once
 #ifndef INCLUDED_AI_STRING_WORKERS_H
 #define INCLUDED_AI_STRING_WORKERS_H
 
+#ifdef __GNUC__
+#pragma GCC system_header
+#endif
+
+#include <assimp/StringComparison.h>
 #include <assimp/ai_assert.h>
 #include <assimp/defs.h>
-#include "StringComparison.h"
 
-#include <string.h>
-#include <stdint.h>
+#include <cstdint>
+#include <cstring>
 #include <string>
 
-namespace Assimp    {
+namespace Assimp {
 
 // -------------------------------------------------------------------------------
 /** @brief itoa with a fixed base 10
@@ -73,13 +78,12 @@ namespace Assimp    {
  * @param number Number to be written
  * @return Length of the output string, excluding the '\0'
  */
-AI_FORCE_INLINE
-unsigned int ASSIMP_itoa10( char* out, unsigned int max, int32_t number) {
-    ai_assert(NULL != out);
+inline unsigned int ASSIMP_itoa10(char *out, unsigned int max, int32_t number) {
+    ai_assert(nullptr != out);
 
     // write the unary minus to indicate we have a negative number
     unsigned int written = 1u;
-    if (number < 0 && written < max)    {
+    if (number < 0 && written < max) {
         *out++ = '-';
         ++written;
         number = -number;
@@ -88,17 +92,17 @@ unsigned int ASSIMP_itoa10( char* out, unsigned int max, int32_t number) {
     // We begin with the largest number that is not zero.
     int32_t cur = 1000000000; // 2147483648
     bool mustPrint = false;
-    while (written < max)   {
+    while (written < max) {
 
         const unsigned int digit = number / cur;
         if (mustPrint || digit > 0 || 1 == cur) {
-            // print all future zeroe's from now
+            // print all future zero's from now
             mustPrint = true;
 
-            *out++ = '0'+static_cast<char>(digit);
+            *out++ = '0' + static_cast<char>(digit);
 
             ++written;
-            number -= digit*cur;
+            number -= digit * cur;
             if (1 == cur) {
                 break;
             }
@@ -108,7 +112,7 @@ unsigned int ASSIMP_itoa10( char* out, unsigned int max, int32_t number) {
 
     // append a terminal zero
     *out++ = '\0';
-    return written-1;
+    return written - 1;
 }
 
 // -------------------------------------------------------------------------------
@@ -117,9 +121,8 @@ unsigned int ASSIMP_itoa10( char* out, unsigned int max, int32_t number) {
  *  size of the array automatically.
  */
 template <size_t length>
-AI_FORCE_INLINE
-unsigned int ASSIMP_itoa10( char(& out)[length], int32_t number) {
-    return ASSIMP_itoa10(out,length,number);
+inline unsigned int ASSIMP_itoa10(char (&out)[length], int32_t number) {
+    return ASSIMP_itoa10(out, length, number);
 }
 
 // -------------------------------------------------------------------------------
@@ -133,25 +136,19 @@ unsigned int ASSIMP_itoa10( char(& out)[length], int32_t number) {
  *  @param s2 Second input string
  *  @return 0 if the given strings are identical
  */
-AI_FORCE_INLINE
-int ASSIMP_stricmp(const char *s1, const char *s2) {
-    ai_assert( NULL != s1 );
-    ai_assert( NULL != s2 );
+inline int ASSIMP_stricmp(const char *s1, const char *s2) {
+    ai_assert(nullptr != s1);
+    ai_assert(nullptr != s2);
 
 #if (defined _MSC_VER)
 
-    return ::_stricmp(s1,s2);
-#elif defined( __GNUC__ )
-
-    return ::strcasecmp(s1,s2);
+    return ::_stricmp(s1, s2);
 #else
-
     char c1, c2;
-    do  {
-        c1 = tolower(*s1++);
-        c2 = tolower(*s2++);
-    }
-    while ( c1 && (c1 == c2) );
+    do {
+        c1 = tolower((unsigned char)*(s1++));
+        c2 = tolower((unsigned char)*(s2++));
+    } while (c1 && (c1 == c2));
     return c1 - c2;
 #endif
 }
@@ -163,10 +160,9 @@ int ASSIMP_stricmp(const char *s1, const char *s2) {
  *  @param b Second string
  *  @return 0 if a == b
  */
-AI_FORCE_INLINE
-int ASSIMP_stricmp(const std::string& a, const std::string& b) {
-    int i = (int)b.length()-(int)a.length();
-    return (i ? i : ASSIMP_stricmp(a.c_str(),b.c_str()));
+inline int ASSIMP_stricmp(const std::string &a, const std::string &b) {
+    int i = (int)b.length() - (int)a.length();
+    return (i ? i : ASSIMP_stricmp(a.c_str(), b.c_str()));
 }
 
 // -------------------------------------------------------------------------------
@@ -178,56 +174,51 @@ int ASSIMP_stricmp(const std::string& a, const std::string& b) {
  *
  *  @param s1 First input string
  *  @param s2 Second input string
- *  @param n Macimum number of characters to compare
+ *  @param n Maximum number of characters to compare
  *  @return 0 if the given strings are identical
  */
-AI_FORCE_INLINE
-int ASSIMP_strincmp(const char *s1, const char *s2, unsigned int n) {
-    ai_assert( NULL != s1 );
-    ai_assert( NULL != s2 );
-    if ( !n ) {
+inline int ASSIMP_strincmp(const char *s1, const char *s2, unsigned int n) {
+    ai_assert(nullptr != s1);
+    ai_assert(nullptr != s2);
+    if (!n) {
         return 0;
     }
 
 #if (defined _MSC_VER)
 
-    return ::_strnicmp(s1,s2,n);
+    return ::_strnicmp(s1, s2, n);
 
-#elif defined( __GNUC__ )
+#elif defined(__GNUC__)
 
-    return ::strncasecmp(s1,s2, n);
+    return ::strncasecmp(s1, s2, n);
 
 #else
     char c1, c2;
     unsigned int p = 0;
-    do
-    {
-        if (p++ >= n)return 0;
-        c1 = tolower(*s1++);
-        c2 = tolower(*s2++);
-    }
-    while ( c1 && (c1 == c2) );
+    do {
+        if (p++ >= n) return 0;
+        c1 = tolower((unsigned char)*(s1++));
+        c2 = tolower((unsigned char)*(s2++));
+    } while (c1 && (c1 == c2));
 
     return c1 - c2;
 #endif
 }
 
-
 // -------------------------------------------------------------------------------
 /** @brief Evaluates an integer power
  *
  * todo: move somewhere where it fits better in than here
  */
-AI_FORCE_INLINE
-unsigned int integer_pow( unsigned int base, unsigned int power ) {
+inline unsigned int integer_pow(unsigned int base, unsigned int power) {
     unsigned int res = 1;
-    for ( unsigned int i = 0; i < power; ++i ) {
+    for (unsigned int i = 0; i < power; ++i) {
         res *= base;
     }
 
     return res;
 }
 
-} // end of namespace
+} // namespace Assimp
 
 #endif // !  AI_STRINGCOMPARISON_H_INC
diff --git a/Engine/lib/assimp/include/assimp/StringUtils.h b/Engine/lib/assimp/include/assimp/StringUtils.h
index d68b7fa47..59c6e9ead 100644
--- a/Engine/lib/assimp/include/assimp/StringUtils.h
+++ b/Engine/lib/assimp/include/assimp/StringUtils.h
@@ -2,8 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -39,105 +38,242 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 ----------------------------------------------------------------------
 */
+#pragma once
 #ifndef INCLUDED_AI_STRINGUTILS_H
 #define INCLUDED_AI_STRINGUTILS_H
 
+#ifdef __GNUC__
+#pragma GCC system_header
+#endif
+
 #include <assimp/defs.h>
 
-#include <sstream>
-#include <stdarg.h>
+#include <cstdarg>
+#include <algorithm>
+#include <cctype>
 #include <cstdlib>
+#include <locale>
+#include <sstream>
+#include <iomanip>
 
+#ifdef _MSC_VER
+#define AI_SIZEFMT "%Iu"
+#else
+#define AI_SIZEFMT "%zu"
+#endif
+
+// ---------------------------------------------------------------------------------
 ///	@fn		ai_snprintf
-///	@brief	The portable version of the function snprintf ( C99 standard ), which works on visual studio compilers 2013 and earlier.
+///	@brief	The portable version of the function snprintf ( C99 standard ), which
+///         works on visual studio compilers 2013 and earlier.
 ///	@param	outBuf		The buffer to write in
 ///	@param	size		The buffer size
 ///	@param	format		The format string
 ///	@param	ap			The additional arguments.
-///	@return	The number of written characters if the buffer size was big enough. If an encoding error occurs, a negative number is returned.
+///	@return	The number of written characters if the buffer size was big enough.
+///         If an encoding error occurs, a negative number is returned.
+// ---------------------------------------------------------------------------------
 #if defined(_MSC_VER) && _MSC_VER < 1900
 
-    AI_FORCE_INLINE
-    int c99_ai_vsnprintf(char *outBuf, size_t size, const char *format, va_list ap) {
-		int count(-1);
-		if (0 != size) {
-			count = _vsnprintf_s(outBuf, size, _TRUNCATE, format, ap);
-		}
-		if (count == -1) {
-			count = _vscprintf(format, ap);
-		}
+inline int c99_ai_vsnprintf(char *outBuf, size_t size, const char *format, va_list ap) {
+    int count(-1);
+    if (0 != size) {
+        count = _vsnprintf_s(outBuf, size, _TRUNCATE, format, ap);
+    }
+    if (count == -1) {
+        count = _vscprintf(format, ap);
+    }
 
-		return count;
-	}
+    return count;
+}
 
-    AI_FORCE_INLINE
-    int ai_snprintf(char *outBuf, size_t size, const char *format, ...) {
-		int count;
-		va_list ap;
+inline int ai_snprintf(char *outBuf, size_t size, const char *format, ...) {
+    int count;
+    va_list ap;
 
-		va_start(ap, format);
-		count = c99_ai_vsnprintf(outBuf, size, format, ap);
-		va_end(ap);
+    va_start(ap, format);
+    count = c99_ai_vsnprintf(outBuf, size, format, ap);
+    va_end(ap);
 
-		return count;
-	}
+    return count;
+}
 
+#elif defined(__MINGW32__)
+#define ai_snprintf __mingw_snprintf
 #else
-#   define ai_snprintf snprintf
+#define ai_snprintf snprintf
 #endif
 
+// ---------------------------------------------------------------------------------
 ///	@fn		to_string
-///	@brief	The portable version of to_string ( some gcc-versions on embedded devices are not supporting this).
+///	@brief	The portable version of to_string ( some gcc-versions on embedded
+///         devices are not supporting this).
 ///	@param	value   The value to write into the std::string.
 ///	@return	The value as a std::string
+// ---------------------------------------------------------------------------------
 template <typename T>
-AI_FORCE_INLINE
-std::string to_string( T value ) {
+AI_FORCE_INLINE std::string ai_to_string(T value) {
     std::ostringstream os;
     os << value;
 
     return os.str();
 }
 
+// ---------------------------------------------------------------------------------
 ///	@fn		ai_strtof
 ///	@brief	The portable version of strtof.
 ///	@param	begin   The first character of the string.
 /// @param  end     The last character
-///	@return	The float value, 0.0f in cas of an error.
+///	@return	The float value, 0.0f in case of an error.
+// ---------------------------------------------------------------------------------
 AI_FORCE_INLINE
-float ai_strtof( const char *begin, const char *end ) {
-    if ( nullptr == begin ) {
+float ai_strtof(const char *begin, const char *end) {
+    if (nullptr == begin) {
         return 0.0f;
     }
-    float val( 0.0f );
-    if ( nullptr == end ) {
-        val = static_cast< float >( ::atof( begin ) );
+    float val(0.0f);
+    if (nullptr == end) {
+        val = static_cast<float>(::atof(begin));
     } else {
-        std::string::size_type len( end - begin );
-        std::string token( begin, len );
-        val = static_cast< float >( ::atof( token.c_str() ) );
+        std::string::size_type len(end - begin);
+        std::string token(begin, len);
+        val = static_cast<float>(::atof(token.c_str()));
     }
 
     return val;
 }
 
+// ---------------------------------------------------------------------------------
 ///	@fn		DecimalToHexa
 ///	@brief	The portable to convert a decimal value into a hexadecimal string.
 ///	@param	toConvert   Value to convert
 ///	@return	The hexadecimal string, is empty in case of an error.
-template<class T>
-AI_FORCE_INLINE
-std::string DecimalToHexa( T toConvert ) {
+// ---------------------------------------------------------------------------------
+template <class T>
+AI_FORCE_INLINE std::string ai_decimal_to_hexa(T toConvert) {
     std::string result;
     std::stringstream ss;
     ss << std::hex << toConvert;
     ss >> result;
 
-    for ( size_t i = 0; i < result.size(); ++i ) {
-        result[ i ] = toupper( result[ i ] );
+    for (size_t i = 0; i < result.size(); ++i) {
+        result[i] = (char)toupper((unsigned char)result[i]);
     }
 
     return result;
 }
 
+// ---------------------------------------------------------------------------------
+///	@brief	translate RGBA to String
+///	@param	r   aiColor.r
+///	@param	g   aiColor.g
+///	@param	b   aiColor.b
+///	@param	a   aiColor.a
+///	@param	with_head   #
+///	@return	The hexadecimal string, is empty in case of an error.
+// ---------------------------------------------------------------------------------
+AI_FORCE_INLINE std::string ai_rgba2hex(int r, int g, int b, int a, bool with_head) {
+    std::stringstream ss;
+    if (with_head) {
+        ss << "#";
+    }
+    ss << std::hex << std::setfill('0') << std::setw(8) << (r << 24 | g << 16 | b << 8 | a);
+
+    return ss.str();
+}
+
+// ---------------------------------------------------------------------------------
+/// @brief   Performs a trim from start (in place)
+/// @param  s   string to trim.
+AI_FORCE_INLINE void ai_trim_left(std::string &s) {
+    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](unsigned char ch) {
+        return !std::isspace(ch);
+    }));
+}
+
+// ---------------------------------------------------------------------------------
+/// @brief  Performs a trim from end (in place).
+/// @param  s   string to trim.
+// ---------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------------
+AI_FORCE_INLINE void ai_trim_right(std::string &s) {
+    s.erase(std::find_if(s.rbegin(), s.rend(), [](unsigned char ch) {
+        return !std::isspace(ch);
+    }).base(), s.end());
+}
+
+// ---------------------------------------------------------------------------------
+/// @brief  Performs a trim from both ends (in place).
+/// @param  s   string to trim.
+// ---------------------------------------------------------------------------------
+AI_FORCE_INLINE std::string ai_trim(std::string &s) {
+    std::string out(s);
+    ai_trim_left(out);
+    ai_trim_right(out);
+
+    return out;
+}
+
+// ---------------------------------------------------------------------------------
+template <class char_t>
+AI_FORCE_INLINE char_t ai_tolower(char_t in) {
+    return (in >= (char_t)'A' && in <= (char_t)'Z') ? (char_t)(in + 0x20) : in;
+}
+
+// ---------------------------------------------------------------------------------
+/// @brief  Performs a ToLower-operation and return the lower-case string.
+/// @param  in  The incoming string.
+/// @return The string as lowercase.
+// ---------------------------------------------------------------------------------
+AI_FORCE_INLINE std::string ai_tolower(const std::string &in) {
+    std::string out(in);
+    ai_trim_left(out);
+    ai_trim_right(out);
+    std::transform(out.begin(), out.end(), out.begin(), [](unsigned char c) { return ai_tolower(c); });
+    return out;
+}
+
+// ---------------------------------------------------------------------------------
+template <class char_t>
+AI_FORCE_INLINE char_t ai_toupper(char_t in) {
+    return (in >= (char_t)'a' && in <= (char_t)'z') ? (char_t)(in - 0x20) : in;
+}
+
+// ---------------------------------------------------------------------------------
+/// @brief  Performs a ToLower-operation and return the upper-case string.
+/// @param  in  The incoming string.
+/// @return The string as uppercase.
+AI_FORCE_INLINE std::string ai_str_toupper(const std::string &in) {
+    std::string out(in);
+    std::transform(out.begin(), out.end(), out.begin(), [](char c) { return ai_toupper(c); });
+    return out;
+}
+
+// ---------------------------------------------------------------------------------
+/// @brief  Make a string printable by replacing all non-printable characters with
+///         the specified placeholder character.
+/// @param  in  The incoming string.
+/// @param  placeholder  Placeholder character, default is a question mark.
+/// @return The string, with all non-printable characters replaced.
+AI_FORCE_INLINE std::string ai_str_toprintable(const std::string &in, char placeholder = '?') {
+    std::string out(in);
+    std::transform(out.begin(), out.end(), out.begin(), [placeholder] (unsigned char c) {
+        return isprint(c) ? (char)c :  placeholder;
+    });
+    return out;
+}
+
+// ---------------------------------------------------------------------------------
+/// @brief  Make a string printable by replacing all non-printable characters with
+///         the specified placeholder character.
+/// @param  in  The incoming string.
+/// @param  len The length of the incoming string.
+/// @param  placeholder  Placeholder character, default is a question mark.
+/// @return The string, with all non-printable characters replaced. Will return an
+///         empty string if in is null or len is <= 0.
+AI_FORCE_INLINE std::string ai_str_toprintable(const char *in, int len, char placeholder = '?') {
+    return (in && len > 0) ? ai_str_toprintable(std::string(in, len), placeholder) : std::string();
+}
+
+
 #endif // INCLUDED_AI_STRINGUTILS_H
diff --git a/Engine/lib/assimp/include/assimp/Subdivision.h b/Engine/lib/assimp/include/assimp/Subdivision.h
index 43feb73b3..9dfb38901 100644
--- a/Engine/lib/assimp/include/assimp/Subdivision.h
+++ b/Engine/lib/assimp/include/assimp/Subdivision.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -45,7 +45,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_SUBDISIVION_H_INC
 #define AI_SUBDISIVION_H_INC
 
-#include <cstddef>
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
 #include <assimp/types.h>
 
 struct aiMesh;
diff --git a/Engine/lib/assimp/include/assimp/TinyFormatter.h b/Engine/lib/assimp/include/assimp/TinyFormatter.h
index 1226b482e..df2a32eca 100644
--- a/Engine/lib/assimp/include/assimp/TinyFormatter.h
+++ b/Engine/lib/assimp/include/assimp/TinyFormatter.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -45,9 +45,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *    to get rid of the boost::format dependency. Much slinker,
  *    basically just extends stringstream.
  */
+#pragma once
 #ifndef INCLUDED_TINY_FORMATTER_H
 #define INCLUDED_TINY_FORMATTER_H
 
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
 #include <sstream>
 
 namespace Assimp {
@@ -65,24 +70,15 @@ namespace Formatter {
  *  @endcode */
 template < typename T,
     typename CharTraits = std::char_traits<T>,
-    typename Allocator  = std::allocator<T>
->
-class basic_formatter
-{
-
+    typename Allocator  = std::allocator<T> >
+class basic_formatter {
 public:
+    typedef class std::basic_string<T,CharTraits,Allocator> string;
+    typedef class std::basic_ostringstream<T,CharTraits,Allocator> stringstream;
 
-    typedef class std::basic_string<
-        T,CharTraits,Allocator
-    > string;
-
-    typedef class std::basic_ostringstream<
-        T,CharTraits,Allocator
-    > stringstream;
-
-public:
-
-    basic_formatter() {}
+    basic_formatter() {
+        // empty
+    }
 
     /* Allow basic_formatter<T>'s to be used almost interchangeably
      * with std::(w)string or const (w)char* arguments because the
@@ -92,6 +88,17 @@ public:
         underlying << sin;
     }
 
+    // Same problem as the copy constructor below, but with root cause is that stream move
+    // is not permitted on older GCC versions. Small performance impact on those platforms.
+#if defined(__GNUC__) && (__GNUC__ == 4 && __GNUC_MINOR__ <= 9)
+    basic_formatter(basic_formatter&& other) {
+        underlying << (string)other;
+    }
+#else
+    basic_formatter(basic_formatter&& other)
+        : underlying(std::move(other.underlying)) {
+    }
+#endif
 
     // The problem described here:
     // https://sourceforge.net/tracker/?func=detail&atid=1067632&aid=3358562&group_id=226462
@@ -104,41 +111,49 @@ public:
     }
 #endif
 
-
-public:
-
     operator string () const {
         return underlying.str();
     }
 
-
     /* note - this is declared const because binding temporaries does only
      * work for const references, so many function prototypes will
      * include const basic_formatter<T>& s but might still want to
      * modify the formatted string without the need for a full copy.*/
-    template <typename TToken>
-    const basic_formatter& operator << (const TToken& s) const {
+    template <typename TToken, typename std::enable_if<!std::is_base_of<std::exception, TToken>::value>::type * = nullptr>
+    const basic_formatter &operator<<(const TToken &s) const {
         underlying << s;
         return *this;
     }
 
-    template <typename TToken>
-    basic_formatter& operator << (const TToken& s) {
+    template <typename TToken, typename std::enable_if<std::is_base_of<std::exception, TToken>::value>::type * = nullptr>
+    const basic_formatter &operator<<(const TToken &s) const {
+        underlying << s.what();
+        return *this;
+    }
+
+    template <typename TToken, typename std::enable_if<!std::is_base_of<std::exception, TToken>::value>::type * = nullptr>
+    basic_formatter &operator<<(const TToken &s) {
         underlying << s;
         return *this;
     }
 
+    template <typename TToken, typename std::enable_if<std::is_base_of<std::exception, TToken>::value>::type * = nullptr>
+    basic_formatter &operator<<(const TToken &s) {
+        underlying << s.what();
+        return *this;
+    }
+
 
     // comma operator overloaded as well, choose your preferred way.
     template <typename TToken>
     const basic_formatter& operator, (const TToken& s) const {
-        underlying << s;
+        *this << s;
         return *this;
     }
 
     template <typename TToken>
     basic_formatter& operator, (const TToken& s) {
-        underlying << s;
+        *this << s;
         return *this;
     }
 
@@ -146,7 +161,7 @@ public:
     // See https://sourceforge.net/projects/assimp/forums/forum/817654/topic/4372824
     template <typename TToken>
     basic_formatter& operator, (TToken& s) {
-        underlying << s;
+        *this << s;
         return *this;
     }
 
diff --git a/Engine/lib/assimp/include/assimp/Vertex.h b/Engine/lib/assimp/include/assimp/Vertex.h
index 2a7f0256a..fd7eb037e 100644
--- a/Engine/lib/assimp/include/assimp/Vertex.h
+++ b/Engine/lib/assimp/include/assimp/Vertex.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -47,12 +47,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   that are not currently well-defined (and would cause compile errors
   due to missing operators in the math library), are commented.
   */
+#pragma once
 #ifndef AI_VERTEX_H_INC
 #define AI_VERTEX_H_INC
 
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
 #include <assimp/vector3.h>
 #include <assimp/mesh.h>
 #include <assimp/ai_assert.h>
+
 #include <functional>
 
 namespace Assimp    {
@@ -87,27 +93,18 @@ namespace Assimp    {
 
 // ------------------------------------------------------------------------------------------------
 /** Intermediate description a vertex with all possible components. Defines a full set of
- *  operators, so you may use such a 'Vertex' in basic arithmetics. All operators are applied
+ *  operators, so you may use such a 'Vertex' in basic arithmetic. All operators are applied
  *  to *all* vertex components equally. This is useful for stuff like interpolation
  *  or subdivision, but won't work if special handling is required for some vertex components. */
 // ------------------------------------------------------------------------------------------------
-class Vertex
-{
+class Vertex {
     friend Vertex operator + (const Vertex&,const Vertex&);
     friend Vertex operator - (const Vertex&,const Vertex&);
-
-//  friend Vertex operator + (const Vertex&,ai_real);
-//  friend Vertex operator - (const Vertex&,ai_real);
     friend Vertex operator * (const Vertex&,ai_real);
     friend Vertex operator / (const Vertex&,ai_real);
-
-//  friend Vertex operator + (ai_real, const Vertex&);
-//  friend Vertex operator - (ai_real, const Vertex&);
     friend Vertex operator * (ai_real, const Vertex&);
-//  friend Vertex operator / (ai_real, const Vertex&);
 
 public:
-
     Vertex() {}
 
     // ----------------------------------------------------------------------------
@@ -138,7 +135,9 @@ public:
     /** Extract a particular vertex from a anim mesh and interleave all components */
     explicit Vertex(const aiAnimMesh* msh, unsigned int idx) {
         ai_assert(idx < msh->mNumVertices);
-        position = msh->mVertices[idx];
+        if (msh->HasPositions()) {
+            position = msh->mVertices[idx];
+        }
 
         if (msh->HasNormals()) {
             normal = msh->mNormals[idx];
@@ -158,8 +157,6 @@ public:
         }
     }
 
-public:
-
     Vertex& operator += (const Vertex& v) {
         *this = *this+v;
         return *this;
@@ -170,18 +167,6 @@ public:
         return *this;
     }
 
-
-/*
-    Vertex& operator += (ai_real v) {
-        *this = *this+v;
-        return *this;
-    }
-
-    Vertex& operator -= (ai_real v) {
-        *this = *this-v;
-        return *this;
-    }
-*/
     Vertex& operator *= (ai_real v) {
         *this = *this*v;
         return *this;
@@ -192,12 +177,9 @@ public:
         return *this;
     }
 
-public:
-
     // ----------------------------------------------------------------------------
     /** Convert back to non-interleaved storage */
     void SortBack(aiMesh* out, unsigned int idx) const {
-
         ai_assert(idx<out->mNumVertices);
         out->mVertices[idx] = position;
 
@@ -242,7 +224,7 @@ private:
     }
 
     // ----------------------------------------------------------------------------
-    /** This time binary arithmetics of v0 with a floating-point number */
+    /** This time binary arithmetic of v0 with a floating-point number */
     template <template <typename, typename, typename> class op> static Vertex BinaryOp(const Vertex& v0, ai_real f) {
         // this is a heavy task for the compiler to optimize ... *pray*
 
@@ -262,7 +244,7 @@ private:
     }
 
     // ----------------------------------------------------------------------------
-    /** This time binary arithmetics of v0 with a floating-point number */
+    /** This time binary arithmetic of v0 with a floating-point number */
     template <template <typename, typename, typename> class op> static Vertex BinaryOp(ai_real f, const Vertex& v0) {
         // this is a heavy task for the compiler to optimize ... *pray*
 
@@ -291,8 +273,6 @@ public:
     aiColor4D colors[AI_MAX_NUMBER_OF_COLOR_SETS];
 };
 
-
-
 // ------------------------------------------------------------------------------------------------
 AI_FORCE_INLINE Vertex operator + (const Vertex& v0,const Vertex& v1) {
     return Vertex::BinaryOp<std::plus>(v0,v1);
@@ -302,19 +282,6 @@ AI_FORCE_INLINE Vertex operator - (const Vertex& v0,const Vertex& v1) {
     return Vertex::BinaryOp<std::minus>(v0,v1);
 }
 
-
-// ------------------------------------------------------------------------------------------------
-/*
-AI_FORCE_INLINE Vertex operator + (const Vertex& v0,ai_real f) {
-    return Vertex::BinaryOp<Intern::plus>(v0,f);
-}
-
-AI_FORCE_INLINE Vertex operator - (const Vertex& v0,ai_real f) {
-    return Vertex::BinaryOp<Intern::minus>(v0,f);
-}
-
-*/
-
 AI_FORCE_INLINE Vertex operator * (const Vertex& v0,ai_real f) {
     return Vertex::BinaryOp<Intern::multiplies>(v0,f);
 }
@@ -323,26 +290,10 @@ AI_FORCE_INLINE Vertex operator / (const Vertex& v0,ai_real f) {
     return Vertex::BinaryOp<Intern::multiplies>(v0,1.f/f);
 }
 
-// ------------------------------------------------------------------------------------------------
-/*
-AI_FORCE_INLINE Vertex operator + (ai_real f,const Vertex& v0) {
-    return Vertex::BinaryOp<Intern::plus>(f,v0);
-}
-
-AI_FORCE_INLINE Vertex operator - (ai_real f,const Vertex& v0) {
-    return Vertex::BinaryOp<Intern::minus>(f,v0);
-}
-*/
-
 AI_FORCE_INLINE Vertex operator * (ai_real f,const Vertex& v0) {
     return Vertex::BinaryOp<Intern::multiplies>(f,v0);
 }
 
-/*
-AI_FORCE_INLINE Vertex operator / (ai_real f,const Vertex& v0) {
-    return Vertex::BinaryOp<Intern::divides>(f,v0);
 }
-*/
 
-}
-#endif
+#endif // AI_VERTEX_H_INC
diff --git a/Engine/lib/assimp/include/assimp/XMLTools.h b/Engine/lib/assimp/include/assimp/XMLTools.h
index b0d327687..b2766f19b 100644
--- a/Engine/lib/assimp/include/assimp/XMLTools.h
+++ b/Engine/lib/assimp/include/assimp/XMLTools.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -40,9 +40,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
+#pragma once
 #ifndef INCLUDED_ASSIMP_XML_TOOLS_H
 #define INCLUDED_ASSIMP_XML_TOOLS_H
 
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
 #include <string>
 
 namespace Assimp {
diff --git a/Engine/lib/assimp/include/assimp/XmlParser.h b/Engine/lib/assimp/include/assimp/XmlParser.h
new file mode 100644
index 000000000..28f2be8e8
--- /dev/null
+++ b/Engine/lib/assimp/include/assimp/XmlParser.h
@@ -0,0 +1,493 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#ifndef INCLUDED_AI_IRRXML_WRAPPER
+#define INCLUDED_AI_IRRXML_WRAPPER
+
+#include <assimp/ai_assert.h>
+#include <assimp/DefaultLogger.hpp>
+
+#include "BaseImporter.h"
+#include "IOStream.hpp"
+
+#include <pugixml.hpp>
+#include <vector>
+
+namespace Assimp {
+
+/// @brief  Will find a node by its name.
+struct find_node_by_name_predicate {
+    std::string mName;
+    find_node_by_name_predicate(const std::string &name) :
+            mName(name) {
+        // empty
+    }
+
+    bool operator()(pugi::xml_node node) const {
+        return node.name() == mName;
+    }
+};
+
+/// @brief  Will convert an attribute to its int value.
+/// @tparam TNodeType The node type.
+template <class TNodeType>
+struct NodeConverter {
+public:
+    static int to_int(TNodeType &node, const char *attribName) {
+        ai_assert(nullptr != attribName);
+        return node.attribute(attribName).to_int();
+    }
+};
+
+using XmlNode = pugi::xml_node;
+using XmlAttribute = pugi::xml_attribute;
+
+/// @brief The Xml-Parser class.
+///
+/// Use this parser if you have to import any kind of xml-format.
+///
+/// An example:
+/// @code
+/// TXmlParser<XmlNode> theParser;
+/// if (theParser.parse(fileStream)) {
+///     auto node = theParser.getRootNode();
+///     for ( auto currentNode : node.children()) {
+///         // Will loop over all children
+///     }
+/// }
+/// @endcode
+/// @tparam TNodeType
+template <class TNodeType>
+class TXmlParser {
+public:
+    /// @brief The default class constructor.
+    TXmlParser() :
+            mDoc(nullptr),
+            mData() {
+        // empty
+    }
+
+    ///	@brief  The class destructor.
+    ~TXmlParser() {
+        clear();
+    }
+
+    ///	@brief  Will clear the parsed xml-file.
+    void clear() {
+        if (mData.empty()) {
+            mDoc = nullptr;
+            return;
+        }
+        mData.clear();
+        delete mDoc;
+        mDoc = nullptr;
+    }
+
+    ///	@brief  Will search for a child-node by its name
+    /// @param  name     [in] The name of the child-node.
+    /// @return The node instance or nullptr, if nothing was found.
+    TNodeType *findNode(const std::string &name) {
+        if (name.empty()) {
+            return nullptr;
+        }
+
+        if (nullptr == mDoc) {
+            return nullptr;
+        }
+
+        find_node_by_name_predicate predicate(name);
+        mCurrent = mDoc->find_node(predicate);
+        if (mCurrent.empty()) {
+            return nullptr;
+        }
+
+        return &mCurrent;
+    }
+
+    /// @brief  Will return true, if the node is a child-node.
+    /// @param  name    [in] The name of the child node to look for.
+    /// @return true, if the node is a child-node or false if not.
+    bool hasNode(const std::string &name) {
+        return nullptr != findNode(name);
+    }
+
+    /// @brief  Will parse an xml-file from a given stream.
+    /// @param  stream      The input stream.
+    /// @return true, if the parsing was successful, false if not.
+    bool parse(IOStream *stream) {
+        if (nullptr == stream) {
+            ASSIMP_LOG_DEBUG("Stream is nullptr.");
+            return false;
+        }
+
+        const size_t len = stream->FileSize();
+        mData.resize(len + 1);
+        memset(&mData[0], '\0', len + 1);
+        stream->Read(&mData[0], 1, len);
+
+        mDoc = new pugi::xml_document();
+        pugi::xml_parse_result parse_result = mDoc->load_string(&mData[0], pugi::parse_full);
+        if (parse_result.status == pugi::status_ok) {
+            return true;
+        }
+
+        ASSIMP_LOG_DEBUG("Error while parse xml.", std::string(parse_result.description()), " @ ", parse_result.offset);
+
+        return false;
+    }
+
+    /// @brief  Will return truem if a root node is there.
+    /// @return true in case of an existing root.
+    bool hasRoot() const {
+        return nullptr != mDoc;
+    }
+    /// @brief  Will return the document pointer, is nullptr if no xml-file was parsed.
+    /// @return The pointer showing to the document.
+    pugi::xml_document *getDocument() const {
+        return mDoc;
+    }
+
+    /// @brief  Will return the root node, const version.
+    /// @return The root node.
+    const TNodeType getRootNode() const {
+        static pugi::xml_node none;
+        if (nullptr == mDoc) {
+            return none;
+        }
+        return mDoc->root();
+    }
+
+    /// @brief  Will return the root node, non-const version.
+    /// @return The root node.
+    TNodeType getRootNode() {
+        static pugi::xml_node none;
+        if (nullptr == mDoc) {
+            return none;
+        }
+        return mDoc->root();
+    }
+
+    /// @brief Will check if a node with the given name is in.
+    /// @param node     [in] The node to look in.
+    /// @param name     [in] The name of the child-node.
+    /// @return true, if node was found, false if not.
+    static inline bool hasNode(XmlNode &node, const char *name) {
+        pugi::xml_node child = node.find_child(find_node_by_name_predicate(name));
+        return !child.empty();
+    }
+
+    /// @brief Will check if an attribute is part of the XmlNode.
+    /// @param xmlNode  [in] The node to search in.
+    /// @param name     [in} The attribute name to look for.
+    /// @return true, if the was found, false if not.
+    static inline bool hasAttribute(XmlNode &xmlNode, const char *name) {
+        pugi::xml_attribute attr = xmlNode.attribute(name);
+        return !attr.empty();
+    }
+
+    /// @brief Will try to get an unsigned int attribute value.
+    /// @param xmlNode  [in] The node to search in.
+    /// @param name     [in] The attribute name to look for.
+    /// @param val      [out] The unsigned int value from the attribute.
+    /// @return true, if the node contains an attribute with the given name and if the value is an unsigned int.
+    static inline bool getUIntAttribute(XmlNode &xmlNode, const char *name, unsigned int &val) {
+        pugi::xml_attribute attr = xmlNode.attribute(name);
+        if (attr.empty()) {
+            return false;
+        }
+
+        val = attr.as_uint();
+        return true;
+    }
+
+    /// @brief Will try to get an int attribute value.
+    /// @param xmlNode  [in] The node to search in.
+    /// @param name     [in] The attribute name to look for.
+    /// @param val      [out] The int value from the attribute.
+    /// @return true, if the node contains an attribute with the given name and if the value is an int.
+    static inline bool getIntAttribute(XmlNode &xmlNode, const char *name, int &val) {
+        pugi::xml_attribute attr = xmlNode.attribute(name);
+        if (attr.empty()) {
+            return false;
+        }
+
+        val = attr.as_int();
+        return true;
+    }
+
+    /// @brief Will try to get a real attribute value.
+    /// @param xmlNode  [in] The node to search in.
+    /// @param name     [in] The attribute name to look for.
+    /// @param val      [out] The real value from the attribute.
+    /// @return true, if the node contains an attribute with the given name and if the value is a real.
+    static inline bool getRealAttribute(XmlNode &xmlNode, const char *name, ai_real &val) {
+        pugi::xml_attribute attr = xmlNode.attribute(name);
+        if (attr.empty()) {
+            return false;
+        }
+#ifdef ASSIMP_DOUBLE_PRECISION
+        val = attr.as_double();
+#else
+        val = attr.as_float();
+#endif
+        return true;
+    }
+
+    /// @brief Will try to get a float attribute value.
+    /// @param xmlNode  [in] The node to search in.
+    /// @param name     [in] The attribute name to look for.
+    /// @param val      [out] The float value from the attribute.
+    /// @return true, if the node contains an attribute with the given name and if the value is a float.
+    static inline bool getFloatAttribute(XmlNode &xmlNode, const char *name, float &val) {
+        pugi::xml_attribute attr = xmlNode.attribute(name);
+        if (attr.empty()) {
+            return false;
+        }
+
+        val = attr.as_float();
+        return true;
+    }
+
+    /// @brief Will try to get a double attribute value.
+    /// @param xmlNode  [in] The node to search in.
+    /// @param name     [in] The attribute name to look for.
+    /// @param val      [out] The double value from the attribute.
+    /// @return true, if the node contains an attribute with the given name and if the value is a double.
+    static inline bool getDoubleAttribute(XmlNode &xmlNode, const char *name, double &val) {
+        pugi::xml_attribute attr = xmlNode.attribute(name);
+        if (attr.empty()) {
+            return false;
+        }
+
+        val = attr.as_double();
+        return true;
+    }
+
+    /// @brief Will try to get a std::string attribute value.
+    /// @param xmlNode  [in] The node to search in.
+    /// @param name     [in] The attribute name to look for.
+    /// @param val      [out] The std::string value from the attribute.
+    /// @return true, if the node contains an attribute with the given name and if the value is a std::string.
+    static inline bool getStdStrAttribute(XmlNode &xmlNode, const char *name, std::string &val) {
+        pugi::xml_attribute attr = xmlNode.attribute(name);
+        if (attr.empty()) {
+            return false;
+        }
+
+        val = attr.as_string();
+        return true;
+    }
+
+    /// @brief Will try to get a bool attribute value.
+    /// @param xmlNode  [in] The node to search in.
+    /// @param name     [in] The attribute name to look for.
+    /// @param val      [out] The bool value from the attribute.
+    /// @return true, if the node contains an attribute with the given name and if the value is a bool.
+    static inline bool getBoolAttribute(XmlNode &xmlNode, const char *name, bool &val) {
+        pugi::xml_attribute attr = xmlNode.attribute(name);
+        if (attr.empty()) {
+            return false;
+        }
+
+        val = attr.as_bool();
+        return true;
+    }
+
+    /// @brief Will try to get the value of the node as a string.
+    /// @param node     [in] The node to search in.
+    /// @param text     [out] The value as a text.
+    /// @return true, if the value can be read out.
+    static inline bool getValueAsString(XmlNode &node, std::string &text) {
+        text = std::string();
+        if (node.empty()) {
+            return false;
+        }
+
+        text = node.text().as_string();
+
+        return true;
+    }
+
+    /// @brief Will try to get the value of the node as a float.
+    /// @param node     [in] The node to search in.
+    /// @param text     [out] The value as a float.
+    /// @return true, if the value can be read out.
+    static inline bool getValueAsFloat(XmlNode &node, ai_real &v) {
+        if (node.empty()) {
+            return false;
+        }
+
+        v = node.text().as_float();
+
+        return true;
+    }
+
+    /// @brief Will try to get the value of the node as an integer.
+    /// @param node     [in] The node to search in.
+    /// @param text     [out] The value as a int.
+    /// @return true, if the value can be read out.
+    static inline bool getValueAsInt(XmlNode &node, int &v) {
+        if (node.empty()) {
+            return false;
+        }
+
+        v = node.text().as_int();
+
+        return true;
+    }
+
+    /// @brief Will try to get the value of the node as an bool.
+    /// @param node     [in] The node to search in.
+    /// @param text     [out] The value as a bool.
+    /// @return true, if the value can be read out.
+    static inline bool getValueAsBool(XmlNode& node, bool& v)
+    {
+        if (node.empty()) {
+            return false;
+        }
+
+        v = node.text().as_bool();
+
+        return true;
+    }
+
+private:
+    pugi::xml_document *mDoc;
+    TNodeType mCurrent;
+    std::vector<char> mData;
+};
+
+using XmlParser = TXmlParser<pugi::xml_node>;
+
+///	@brief  This class declares an iterator to loop through all children of the root node.
+class XmlNodeIterator {
+public:
+    /// @brief The iteration mode.
+    enum IterationMode {
+        PreOrderMode, ///< Pre-ordering, get the values, continue the iteration.
+        PostOrderMode ///< Post-ordering, continue the iteration, get the values.
+    };
+    ///	@brief  The class constructor
+    /// @param  parent      [in] The xml parent to to iterate through.
+    /// @param  mode        [in] The iteration mode.
+    explicit XmlNodeIterator(XmlNode &parent, IterationMode mode) :
+            mParent(parent),
+            mNodes(),
+            mIndex(0) {
+        if (mode == PreOrderMode) {
+            collectChildrenPreOrder(parent);
+        } else {
+            collectChildrenPostOrder(parent);
+        }
+    }
+
+    ///	@brief  The class destructor.
+    ~XmlNodeIterator() {
+        // empty
+    }
+
+    ///	@brief  Will iterate through all children in pre-order iteration.
+    /// @param  node    [in] The nod to iterate through.
+    void collectChildrenPreOrder(XmlNode &node) {
+        if (node != mParent && node.type() == pugi::node_element) {
+            mNodes.push_back(node);
+        }
+        for (XmlNode currentNode : node.children()) {
+            collectChildrenPreOrder(currentNode);
+        }
+    }
+
+    ///	@brief  Will iterate through all children in post-order iteration.
+    /// @param  node    [in] The nod to iterate through.
+    void collectChildrenPostOrder(XmlNode &node) {
+        for (XmlNode currentNode = node.first_child(); currentNode; currentNode = currentNode.next_sibling()) {
+            collectChildrenPostOrder(currentNode);
+        }
+        if (node != mParent) {
+            mNodes.push_back(node);
+        }
+    }
+
+    ///	@brief  Will iterate through all collected nodes.
+    /// @param  next    The next node, if there is any.
+    /// @return true, if there is a node left.
+    bool getNext(XmlNode &next) {
+        if (mIndex == mNodes.size()) {
+            return false;
+        }
+
+        next = mNodes[mIndex];
+        ++mIndex;
+
+        return true;
+    }
+
+    ///	@brief  Will return the number of collected nodes.
+    /// @return The number of collected nodes.
+    size_t size() const {
+        return mNodes.size();
+    }
+
+    ///	@brief  Returns true, if the node is empty.
+    /// @return true, if the node is empty, false if not.
+    bool isEmpty() const {
+        return mNodes.empty();
+    }
+
+    ///	@brief  Will clear all collected nodes.
+    void clear() {
+        if (mNodes.empty()) {
+            return;
+        }
+
+        mNodes.clear();
+        mIndex = 0;
+    }
+
+private:
+    XmlNode &mParent;
+    std::vector<XmlNode> mNodes;
+    size_t mIndex;
+};
+
+} // namespace Assimp
+
+#endif // !! INCLUDED_AI_IRRXML_WRAPPER
diff --git a/Engine/lib/assimp/include/assimp/ZipArchiveIOSystem.h b/Engine/lib/assimp/include/assimp/ZipArchiveIOSystem.h
index 38cbbf2a7..dac60b501 100644
--- a/Engine/lib/assimp/include/assimp/ZipArchiveIOSystem.h
+++ b/Engine/lib/assimp/include/assimp/ZipArchiveIOSystem.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -45,43 +45,50 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Implementation of IOSystem to read a ZIP file from another IOSystem
 */
 
+#pragma once
 #ifndef AI_ZIPARCHIVEIOSYSTEM_H_INC
 #define AI_ZIPARCHIVEIOSYSTEM_H_INC
 
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
 #include <assimp/IOStream.hpp>
 #include <assimp/IOSystem.hpp>
 
 namespace Assimp {
-    class ZipArchiveIOSystem : public IOSystem {
-    public:
-        //! Open a Zip using the proffered IOSystem
-        ZipArchiveIOSystem(IOSystem* pIOHandler, const char *pFilename, const char* pMode = "r");
-        ZipArchiveIOSystem(IOSystem* pIOHandler, const std::string& rFilename, const char* pMode = "r");
-        virtual ~ZipArchiveIOSystem();
-        bool Exists(const char* pFilename) const override;
-        char getOsSeparator() const override;
-        IOStream* Open(const char* pFilename, const char* pMode = "rb") override;
-        void Close(IOStream* pFile) override;
 
-        // Specific to ZIP
-        //! The file was opened and is a ZIP
-        bool isOpen() const;
+class ZipArchiveIOSystem : public IOSystem {
+public:
+    //! Open a Zip using the proffered IOSystem
+    ZipArchiveIOSystem(IOSystem* pIOHandler, const char *pFilename, const char* pMode = "r");
+    ZipArchiveIOSystem(IOSystem* pIOHandler, const std::string& rFilename, const char* pMode = "r");
+    virtual ~ZipArchiveIOSystem();
+    bool Exists(const char* pFilename) const override;
+    char getOsSeparator() const override;
+    IOStream* Open(const char* pFilename, const char* pMode = "rb") override;
+    void Close(IOStream* pFile) override;
 
-        //! Get the list of all files with their simplified paths
-        //! Intended for use within Assimp library boundaries
-        void getFileList(std::vector<std::string>& rFileList) const;
+    // Specific to ZIP
+    //! The file was opened and is a ZIP
+    bool isOpen() const;
 
-        //! Get the list of all files with extension (must be lowercase)
-        //! Intended for use within Assimp library boundaries
-        void getFileListExtension(std::vector<std::string>& rFileList, const std::string& extension) const;
+    //! Get the list of all files with their simplified paths
+    //! Intended for use within Assimp library boundaries
+    void getFileList(std::vector<std::string>& rFileList) const;
 
-        static bool isZipArchive(IOSystem* pIOHandler, const char *pFilename);
-        static bool isZipArchive(IOSystem* pIOHandler, const std::string& rFilename);
+    //! Get the list of all files with extension (must be lowercase)
+    //! Intended for use within Assimp library boundaries
+    void getFileListExtension(std::vector<std::string>& rFileList, const std::string& extension) const;
+
+    static bool isZipArchive(IOSystem* pIOHandler, const char *pFilename);
+    static bool isZipArchive(IOSystem* pIOHandler, const std::string& rFilename);
+
+private:
+    class Implement;
+    Implement *pImpl = nullptr;
+};
 
-    private:
-        class Implement;
-        Implement *pImpl = nullptr;
-    };
 } // Namespace Assimp
 
 #endif // AI_ZIPARCHIVEIOSYSTEM_H_INC
diff --git a/Engine/lib/assimp/include/assimp/aabb.h b/Engine/lib/assimp/include/assimp/aabb.h
index a20f31742..51443bc20 100644
--- a/Engine/lib/assimp/include/assimp/aabb.h
+++ b/Engine/lib/assimp/include/assimp/aabb.h
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -45,32 +43,41 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_AABB_H_INC
 #define AI_AABB_H_INC
 
+#ifdef __GNUC__
+#pragma GCC system_header
+#endif
+
 #include <assimp/vector3.h>
 
+// ---------------------------------------------------------------------------
+/** 
+ *  An axis-aligned bounding box.  
+ */
 struct aiAABB {
     C_STRUCT aiVector3D mMin;
     C_STRUCT aiVector3D mMax;
 
 #ifdef __cplusplus
-
-    aiAABB()
-    : mMin()
-    , mMax() {
+    /// @brief The default class constructor.
+    aiAABB() :
+            mMin(), mMax() {
         // empty
     }
 
-    aiAABB(const aiVector3D &min, const aiVector3D &max )
-    : mMin(min)
-    , mMax(max) {
+    /// @brief The class constructor with the minimum and maximum.
+    /// @param min  The minimum dimension.
+    /// @param max  The maximum dimension.
+    aiAABB(const aiVector3D &min, const aiVector3D &max) :
+            mMin(min), mMax(max) {
         // empty
     }
 
+    ///	@brief  The class destructor.
     ~aiAABB() {
         // empty
     }
 
-#endif 
+#endif // __cplusplus
 };
 
-
-#endif
+#endif // AI_AABB_H_INC
diff --git a/Engine/lib/assimp/include/assimp/ai_assert.h b/Engine/lib/assimp/include/assimp/ai_assert.h
index e5de5d3f3..b41c08f52 100644
--- a/Engine/lib/assimp/include/assimp/ai_assert.h
+++ b/Engine/lib/assimp/include/assimp/ai_assert.h
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -40,18 +38,37 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
+
+/** @file ai_assert.h
+ *  @brief Declares the assimp-specific assertion handler.
+ */
+
 #pragma once
 #ifndef AI_ASSERT_H_INC
 #define AI_ASSERT_H_INC
 
-#ifdef ASSIMP_BUILD_DEBUG
-#   include <assert.h>
-#   define ai_assert(expression) assert( expression )
-#   define ai_assert_entry()     assert( false )
+#include <assimp/defs.h>
+
+#if defined(ASSIMP_BUILD_DEBUG)
+
+namespace Assimp {
+
+/// @brief Assert violation behavior can be customized: see AssertHandler.h.
+/// @param failedExpression     The expression to validate.
+/// @param file                 The file location    
+/// @param line                 The line number
+ASSIMP_API void aiAssertViolation(const char* failedExpression, const char* file, int line);
+
+}
+#endif
+
+// Define assertion resolinig
+#if defined(ASSIMP_BUILD_DEBUG)
+#   define ai_assert(expression) (void)((!!(expression)) || (Assimp::aiAssertViolation(#expression, __FILE__, __LINE__), 0))
+#   define ai_assert_entry() ai_assert(false)
 #else
 #   define  ai_assert(expression)
-#   define  ai_assert_entry() 
+#   define  ai_assert_entry()
 #endif // ASSIMP_BUILD_DEBUG
 
 #endif // AI_ASSERT_H_INC
-
diff --git a/Engine/lib/assimp/include/assimp/anim.h b/Engine/lib/assimp/include/assimp/anim.h
index 02e92739e..ef56c1dc2 100644
--- a/Engine/lib/assimp/include/assimp/anim.h
+++ b/Engine/lib/assimp/include/assimp/anim.h
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -41,7 +39,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
 
-/** 
+/**
   * @file   anim.h
   * @brief  Defines the data structures in which the imported animations
   *         are returned.
@@ -50,8 +48,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_ANIM_H_INC
 #define AI_ANIM_H_INC
 
-#include <assimp/types.h>
+#ifdef __GNUC__
+#pragma GCC system_header
+#endif
+
 #include <assimp/quaternion.h>
+#include <assimp/types.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -59,8 +61,7 @@ extern "C" {
 
 // ---------------------------------------------------------------------------
 /** A time-value pair specifying a certain 3D vector for the given time. */
-struct aiVectorKey
-{
+struct aiVectorKey {
     /** The time of this key */
     double mTime;
 
@@ -71,34 +72,34 @@ struct aiVectorKey
 
     /// @brief  The default constructor.
     aiVectorKey() AI_NO_EXCEPT
-    : mTime( 0.0 )
-    , mValue() {
+            : mTime(0.0),
+              mValue() {
         // empty
     }
 
     /// @brief  Construction from a given time and key value.
 
-    aiVectorKey(double time, const aiVector3D& value)
-    : mTime( time )
-    , mValue( value ) {
+    aiVectorKey(double time, const aiVector3D &value) :
+            mTime(time), mValue(value) {
         // empty
     }
 
     typedef aiVector3D elem_type;
 
     // Comparison operators. For use with std::find();
-    bool operator == (const aiVectorKey& rhs) const {
+    bool operator==(const aiVectorKey &rhs) const {
         return rhs.mValue == this->mValue;
     }
-    bool operator != (const aiVectorKey& rhs ) const {
+    bool operator!=(const aiVectorKey &rhs) const {
         return rhs.mValue != this->mValue;
     }
 
     // Relational operators. For use with std::sort();
-    bool operator < (const aiVectorKey& rhs ) const {
+    bool operator<(const aiVectorKey &rhs) const {
         return mTime < rhs.mTime;
     }
-    bool operator > (const aiVectorKey& rhs ) const {
+    
+    bool operator>(const aiVectorKey &rhs) const {
         return mTime > rhs.mTime;
     }
 #endif // __cplusplus
@@ -107,8 +108,7 @@ struct aiVectorKey
 // ---------------------------------------------------------------------------
 /** A time-value pair specifying a rotation for the given time.
  *  Rotations are expressed with quaternions. */
-struct aiQuatKey
-{
+struct aiQuatKey {
     /** The time of this key */
     double mTime;
 
@@ -117,32 +117,32 @@ struct aiQuatKey
 
 #ifdef __cplusplus
     aiQuatKey() AI_NO_EXCEPT
-    : mTime( 0.0 )
-    , mValue() {
+            : mTime(0.0),
+              mValue() {
         // empty
     }
 
     /** Construction from a given time and key value */
-    aiQuatKey(double time, const aiQuaternion& value)
-        :   mTime   (time)
-        ,   mValue  (value)
-    {}
+    aiQuatKey(double time, const aiQuaternion &value) :
+            mTime(time), mValue(value) {}
 
     typedef aiQuaternion elem_type;
 
     // Comparison operators. For use with std::find();
-    bool operator == (const aiQuatKey& rhs ) const {
+    bool operator==(const aiQuatKey &rhs) const {
         return rhs.mValue == this->mValue;
     }
-    bool operator != (const aiQuatKey& rhs ) const {
+    
+    bool operator!=(const aiQuatKey &rhs) const {
         return rhs.mValue != this->mValue;
     }
 
     // Relational operators. For use with std::sort();
-    bool operator < (const aiQuatKey& rhs ) const {
+    bool operator<(const aiQuatKey &rhs) const {
         return mTime < rhs.mTime;
     }
-    bool operator > (const aiQuatKey& rhs ) const {
+    
+    bool operator>(const aiQuatKey &rhs) const {
         return mTime > rhs.mTime;
     }
 #endif
@@ -150,8 +150,7 @@ struct aiQuatKey
 
 // ---------------------------------------------------------------------------
 /** Binds a anim-mesh to a specific point in time. */
-struct aiMeshKey
-{
+struct aiMeshKey {
     /** The time of this key */
     double mTime;
 
@@ -164,32 +163,29 @@ struct aiMeshKey
 #ifdef __cplusplus
 
     aiMeshKey() AI_NO_EXCEPT
-    : mTime(0.0)
-    , mValue(0)
-    {
+            : mTime(0.0),
+              mValue(0) {
     }
 
     /** Construction from a given time and key value */
-    aiMeshKey(double time, const unsigned int value)
-        :   mTime   (time)
-        ,   mValue  (value)
-    {}
+    aiMeshKey(double time, const unsigned int value) :
+            mTime(time), mValue(value) {}
 
     typedef unsigned int elem_type;
 
     // Comparison operators. For use with std::find();
-    bool operator == (const aiMeshKey& o) const {
+    bool operator==(const aiMeshKey &o) const {
         return o.mValue == this->mValue;
     }
-    bool operator != (const aiMeshKey& o) const {
+    bool operator!=(const aiMeshKey &o) const {
         return o.mValue != this->mValue;
     }
 
     // Relational operators. For use with std::sort();
-    bool operator < (const aiMeshKey& o) const {
+    bool operator<(const aiMeshKey &o) const {
         return mTime < o.mTime;
     }
-    bool operator > (const aiMeshKey& o) const {
+    bool operator>(const aiMeshKey &o) const {
         return mTime > o.mTime;
     }
 
@@ -198,8 +194,7 @@ struct aiMeshKey
 
 // ---------------------------------------------------------------------------
 /** Binds a morph anim mesh to a specific point in time. */
-struct aiMeshMorphKey
-{
+struct aiMeshMorphKey {
     /** The time of this key */
     double mTime;
 
@@ -210,20 +205,17 @@ struct aiMeshMorphKey
     /** The number of values and weights */
     unsigned int mNumValuesAndWeights;
 #ifdef __cplusplus
-	aiMeshMorphKey() AI_NO_EXCEPT
-		: mTime(0.0)
-		, mValues(nullptr)
-		, mWeights(nullptr)
-		, mNumValuesAndWeights(0)
-	{
+    aiMeshMorphKey() AI_NO_EXCEPT
+            : mTime(0.0),
+              mValues(nullptr),
+              mWeights(nullptr),
+              mNumValuesAndWeights(0) {
+    }
 
-	}
-
-    ~aiMeshMorphKey()
-    {
+    ~aiMeshMorphKey() {
         if (mNumValuesAndWeights && mValues && mWeights) {
-            delete [] mValues;
-            delete [] mWeights;
+            delete[] mValues;
+            delete[] mWeights;
         }
     }
 #endif
@@ -233,25 +225,24 @@ struct aiMeshMorphKey
 /** Defines how an animation channel behaves outside the defined time
  *  range. This corresponds to aiNodeAnim::mPreState and
  *  aiNodeAnim::mPostState.*/
-enum aiAnimBehaviour
-{
+enum aiAnimBehaviour {
     /** The value from the default node transformation is taken*/
-    aiAnimBehaviour_DEFAULT  = 0x0,
+    aiAnimBehaviour_DEFAULT = 0x0,
 
     /** The nearest key value is used without interpolation */
     aiAnimBehaviour_CONSTANT = 0x1,
 
     /** The value of the nearest two keys is linearly
      *  extrapolated for the current time value.*/
-    aiAnimBehaviour_LINEAR   = 0x2,
+    aiAnimBehaviour_LINEAR = 0x2,
 
     /** The animation is repeated.
      *
      *  If the animation key go from n to m and the current
      *  time is t, use the value at (t-n) % (|m-n|).*/
-    aiAnimBehaviour_REPEAT   = 0x3,
+    aiAnimBehaviour_REPEAT = 0x3,
 
-    /** This value is not used, it is just here to force the
+/** This value is not used, it is just here to force the
      *  the compiler to map this enum to a 32 Bit integer  */
 #ifndef SWIG
     _aiAnimBehaviour_Force32Bit = INT_MAX
@@ -286,7 +277,7 @@ struct aiNodeAnim {
      *
      * If there are position keys, there will also be at least one
      * scaling and one rotation key.*/
-    C_STRUCT aiVectorKey* mPositionKeys;
+    C_STRUCT aiVectorKey *mPositionKeys;
 
     /** The number of rotation keys */
     unsigned int mNumRotationKeys;
@@ -297,7 +288,7 @@ struct aiNodeAnim {
      *
      * If there are rotation keys, there will also be at least one
      * scaling and one position key. */
-    C_STRUCT aiQuatKey* mRotationKeys;
+    C_STRUCT aiQuatKey *mRotationKeys;
 
     /** The number of scaling keys */
     unsigned int mNumScalingKeys;
@@ -307,7 +298,7 @@ struct aiNodeAnim {
      *
      * If there are scaling keys, there will also be at least one
      * position and one rotation key.*/
-    C_STRUCT aiVectorKey* mScalingKeys;
+    C_STRUCT aiVectorKey *mScalingKeys;
 
     /** Defines how the animation behaves before the first
      *  key is encountered.
@@ -325,21 +316,21 @@ struct aiNodeAnim {
 
 #ifdef __cplusplus
     aiNodeAnim() AI_NO_EXCEPT
-    : mNumPositionKeys( 0 )
-    , mPositionKeys( nullptr )
-    , mNumRotationKeys( 0 )
-    , mRotationKeys( nullptr )
-    , mNumScalingKeys( 0 )
-    , mScalingKeys( nullptr )
-    , mPreState( aiAnimBehaviour_DEFAULT )
-    , mPostState( aiAnimBehaviour_DEFAULT ) {
-         // empty
+            : mNumPositionKeys(0),
+              mPositionKeys(nullptr),
+              mNumRotationKeys(0),
+              mRotationKeys(nullptr),
+              mNumScalingKeys(0),
+              mScalingKeys(nullptr),
+              mPreState(aiAnimBehaviour_DEFAULT),
+              mPostState(aiAnimBehaviour_DEFAULT) {
+        // empty
     }
 
     ~aiNodeAnim() {
-        delete [] mPositionKeys;
-        delete [] mRotationKeys;
-        delete [] mScalingKeys;
+        delete[] mPositionKeys;
+        delete[] mRotationKeys;
+        delete[] mScalingKeys;
     }
 #endif // __cplusplus
 };
@@ -350,8 +341,7 @@ struct aiNodeAnim {
  *  aiMesh::mAnimMeshes array. The purpose of aiMeshAnim is to
  *  define keyframes linking each mesh attachment to a particular
  *  point in time. */
-struct aiMeshAnim
-{
+struct aiMeshAnim {
     /** Name of the mesh to be animated. An empty string is not allowed,
      *  animated meshes need to be named (not necessarily uniquely,
      *  the name can basically serve as wild-card to select a group
@@ -361,18 +351,16 @@ struct aiMeshAnim
     /** Size of the #mKeys array. Must be 1, at least. */
     unsigned int mNumKeys;
 
-    /** Key frames of the animation. May not be NULL. */
-    C_STRUCT aiMeshKey* mKeys;
+    /** Key frames of the animation. May not be nullptr. */
+    C_STRUCT aiMeshKey *mKeys;
 
 #ifdef __cplusplus
 
     aiMeshAnim() AI_NO_EXCEPT
-        : mNumKeys()
-        , mKeys()
-    {}
+            : mNumKeys(),
+              mKeys() {}
 
-    ~aiMeshAnim()
-    {
+    ~aiMeshAnim() {
         delete[] mKeys;
     }
 
@@ -381,8 +369,7 @@ struct aiMeshAnim
 
 // ---------------------------------------------------------------------------
 /** Describes a morphing animation of a given mesh. */
-struct aiMeshMorphAnim
-{
+struct aiMeshMorphAnim {
     /** Name of the mesh to be animated. An empty string is not allowed,
      *  animated meshes need to be named (not necessarily uniquely,
      *  the name can basically serve as wildcard to select a group
@@ -392,18 +379,16 @@ struct aiMeshMorphAnim
     /** Size of the #mKeys array. Must be 1, at least. */
     unsigned int mNumKeys;
 
-    /** Key frames of the animation. May not be NULL. */
-    C_STRUCT aiMeshMorphKey* mKeys;
+    /** Key frames of the animation. May not be nullptr. */
+    C_STRUCT aiMeshMorphKey *mKeys;
 
 #ifdef __cplusplus
 
     aiMeshMorphAnim() AI_NO_EXCEPT
-        : mNumKeys()
-        , mKeys()
-    {}
+            : mNumKeys(),
+              mKeys() {}
 
-    ~aiMeshMorphAnim()
-    {
+    ~aiMeshMorphAnim() {
         delete[] mKeys;
     }
 
@@ -431,8 +416,7 @@ struct aiAnimation {
 
     /** The node animation channels. Each channel affects a single node.
      *  The array is mNumChannels in size. */
-    C_STRUCT aiNodeAnim** mChannels;
-
+    C_STRUCT aiNodeAnim **mChannels;
 
     /** The number of mesh animation channels. Each channel affects
      *  a single mesh and defines vertex-based animation. */
@@ -440,7 +424,7 @@ struct aiAnimation {
 
     /** The mesh animation channels. Each channel affects a single mesh.
      *  The array is mNumMeshChannels in size. */
-    C_STRUCT aiMeshAnim** mMeshChannels;
+    C_STRUCT aiMeshAnim **mMeshChannels;
 
     /** The number of mesh animation channels. Each channel affects
      *  a single mesh and defines morphing animation. */
@@ -452,125 +436,118 @@ struct aiAnimation {
 
 #ifdef __cplusplus
     aiAnimation() AI_NO_EXCEPT
-    : mDuration(-1.)
-    , mTicksPerSecond(0.)
-    , mNumChannels(0)
-    , mChannels(nullptr)
-    , mNumMeshChannels(0)
-    , mMeshChannels(nullptr)
-    , mNumMorphMeshChannels(0)
-    , mMorphMeshChannels(nullptr) {
+            : mDuration(-1.),
+              mTicksPerSecond(0.),
+              mNumChannels(0),
+              mChannels(nullptr),
+              mNumMeshChannels(0),
+              mMeshChannels(nullptr),
+              mNumMorphMeshChannels(0),
+              mMorphMeshChannels(nullptr) {
         // empty
     }
 
     ~aiAnimation() {
         // DO NOT REMOVE THIS ADDITIONAL CHECK
-        if ( mNumChannels && mChannels )  {
-            for( unsigned int a = 0; a < mNumChannels; a++) {
-                delete mChannels[ a ];
+        if (mNumChannels && mChannels) {
+            for (unsigned int a = 0; a < mNumChannels; a++) {
+                delete mChannels[a];
             }
 
-            delete [] mChannels;
+            delete[] mChannels;
         }
-        if (mNumMeshChannels && mMeshChannels)  {
-            for( unsigned int a = 0; a < mNumMeshChannels; a++) {
+        if (mNumMeshChannels && mMeshChannels) {
+            for (unsigned int a = 0; a < mNumMeshChannels; a++) {
                 delete mMeshChannels[a];
             }
 
-            delete [] mMeshChannels;
+            delete[] mMeshChannels;
         }
         if (mNumMorphMeshChannels && mMorphMeshChannels) {
-                for( unsigned int a = 0; a < mNumMorphMeshChannels; a++) {
-                        delete mMorphMeshChannels[a];
-                }
-            
-            delete [] mMorphMeshChannels;
+            for (unsigned int a = 0; a < mNumMorphMeshChannels; a++) {
+                delete mMorphMeshChannels[a];
+            }
+
+            delete[] mMorphMeshChannels;
         }
     }
 #endif // __cplusplus
 };
 
 #ifdef __cplusplus
-
 }
 
 /// @brief  Some C++ utilities for inter- and extrapolation
 namespace Assimp {
 
 // ---------------------------------------------------------------------------
-/** 
+/**
   * @brief CPP-API: Utility class to simplify interpolations of various data types.
   *
   *  The type of interpolation is chosen automatically depending on the
-  *  types of the arguments. 
+  *  types of the arguments.
   */
 template <typename T>
-struct Interpolator
-{
+struct Interpolator {
     // ------------------------------------------------------------------
     /** @brief Get the result of the interpolation between a,b.
      *
      *  The interpolation algorithm depends on the type of the operands.
      *  aiQuaternion's and aiQuatKey's SLERP, the rest does a simple
      *  linear interpolation. */
-    void operator () (T& out,const T& a, const T& b, ai_real d) const {
-        out = a + (b-a)*d;
+    void operator()(T &anim_out, const T &a, const T &b, ai_real d) const {
+        anim_out = a + (b - a) * d;
     }
 }; // ! Interpolator <T>
 
 //! @cond Never
 
 template <>
-struct Interpolator <aiQuaternion>  {
-    void operator () (aiQuaternion& out,const aiQuaternion& a,
-        const aiQuaternion& b, ai_real d) const
-    {
-        aiQuaternion::Interpolate(out,a,b,d);
+struct Interpolator<aiQuaternion> {
+    void operator()(aiQuaternion &out, const aiQuaternion &a,
+            const aiQuaternion &b, ai_real d) const {
+        aiQuaternion::Interpolate(out, a, b, d);
     }
 }; // ! Interpolator <aiQuaternion>
 
 template <>
-struct Interpolator <unsigned int>  {
-    void operator () (unsigned int& out,unsigned int a,
-        unsigned int b, ai_real d) const
-    {
-        out = d>0.5f ? b : a;
+struct Interpolator<unsigned int> {
+    void operator()(unsigned int &out, unsigned int a,
+            unsigned int b, ai_real d) const {
+        out = d > 0.5f ? b : a;
     }
 }; // ! Interpolator <aiQuaternion>
 
 template <>
-struct Interpolator<aiVectorKey>  {
-    void operator () (aiVector3D& out,const aiVectorKey& a,
-        const aiVectorKey& b, ai_real d) const
-    {
+struct Interpolator<aiVectorKey> {
+    void operator()(aiVector3D &out, const aiVectorKey &a,
+            const aiVectorKey &b, ai_real d) const {
         Interpolator<aiVector3D> ipl;
-        ipl(out,a.mValue,b.mValue,d);
+        ipl(out, a.mValue, b.mValue, d);
     }
 }; // ! Interpolator <aiVectorKey>
 
 template <>
-struct Interpolator<aiQuatKey>  {
-    void operator () (aiQuaternion& out, const aiQuatKey& a,
-        const aiQuatKey& b, ai_real d) const
-    {
+struct Interpolator<aiQuatKey> {
+    void operator()(aiQuaternion &out, const aiQuatKey &a,
+            const aiQuatKey &b, ai_real d) const {
         Interpolator<aiQuaternion> ipl;
-        ipl(out,a.mValue,b.mValue,d);
+        ipl(out, a.mValue, b.mValue, d);
     }
 }; // ! Interpolator <aiQuatKey>
 
 template <>
-struct Interpolator<aiMeshKey>     {
-    void operator () (unsigned int& out, const aiMeshKey& a,
-        const aiMeshKey& b, ai_real d) const
-    {
+struct Interpolator<aiMeshKey> {
+    void operator()(unsigned int &out, const aiMeshKey &a,
+            const aiMeshKey &b, ai_real d) const {
         Interpolator<unsigned int> ipl;
-        ipl(out,a.mValue,b.mValue,d);
+        ipl(out, a.mValue, b.mValue, d);
     }
 }; // ! Interpolator <aiQuatKey>
 
 //! @endcond
 
-} //  ! end namespace Assimp
+} // namespace Assimp
 
 #endif // __cplusplus
 
diff --git a/Engine/lib/assimp/include/assimp/camera.h b/Engine/lib/assimp/include/assimp/camera.h
index a9a9f7653..09255fa05 100644
--- a/Engine/lib/assimp/include/assimp/camera.h
+++ b/Engine/lib/assimp/include/assimp/camera.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -47,6 +47,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_CAMERA_H_INC
 #define AI_CAMERA_H_INC
 
+#ifdef __GNUC__
+#pragma GCC system_header
+#endif
+
 #include "types.h"
 
 #ifdef __cplusplus
@@ -96,8 +100,7 @@ extern "C" {
  * camera already look in the right direction.
  *
 */
-struct aiCamera
-{
+struct aiCamera {
     /** The name of the camera.
      *
      *  There must be a node in the scenegraph with the same name.
@@ -123,7 +126,6 @@ struct aiCamera
      */
     C_STRUCT aiVector3D mUp;
 
-
     /** 'LookAt' - vector of the camera coordinate system relative to
      *  the coordinate space defined by the corresponding node.
      *
@@ -133,7 +135,7 @@ struct aiCamera
      */
     C_STRUCT aiVector3D mLookAt;
 
-    /** Half horizontal field of view angle, in radians.
+    /** Horizontal field of view angle, in radians.
      *
      *  The field of view angle is the angle between the center
      *  line of the screen and the left or right border.
@@ -167,28 +169,40 @@ struct aiCamera
      */
     float mAspect;
 
+    /** Half horizontal orthographic width, in scene units.
+     *
+     *  The orthographic width specifies the half width of the
+     *  orthographic view box. If non-zero the camera is
+     *  orthographic and the mAspect should define to the
+     *  ratio between the orthographic width and height
+     *  and mHorizontalFOV should be set to 0.
+     *  The default value is 0 (not orthographic).
+     */
+    float mOrthographicWidth;
 #ifdef __cplusplus
 
     aiCamera() AI_NO_EXCEPT
-        : mUp               (0.f,1.f,0.f)
-        , mLookAt           (0.f,0.f,1.f)
-        , mHorizontalFOV    (0.25f * (float)AI_MATH_PI)
-        , mClipPlaneNear    (0.1f)
-        , mClipPlaneFar     (1000.f)
-        , mAspect           (0.f)
-    {}
+            : mUp(0.f, 1.f, 0.f),
+              mLookAt(0.f, 0.f, 1.f),
+              mHorizontalFOV(0.25f * (float)AI_MATH_PI),
+              mClipPlaneNear(0.1f),
+              mClipPlaneFar(1000.f),
+              mAspect(0.f),
+              mOrthographicWidth(0.f) {}
 
     /** @brief Get a *right-handed* camera matrix from me
      *  @param out Camera matrix to be filled
      */
-    void GetCameraMatrix (aiMatrix4x4& out) const
-    {
+    void GetCameraMatrix(aiMatrix4x4 &out) const {
         /** todo: test ... should work, but i'm not absolutely sure */
 
         /** We don't know whether these vectors are already normalized ...*/
-        aiVector3D zaxis = mLookAt;     zaxis.Normalize();
-        aiVector3D yaxis = mUp;         yaxis.Normalize();
-        aiVector3D xaxis = mUp^mLookAt; xaxis.Normalize();
+        aiVector3D zaxis = mLookAt;
+        zaxis.Normalize();
+        aiVector3D yaxis = mUp;
+        yaxis.Normalize();
+        aiVector3D xaxis = mUp ^ mLookAt;
+        xaxis.Normalize();
 
         out.a4 = -(xaxis * mPosition);
         out.b4 = -(yaxis * mPosition);
@@ -213,7 +227,6 @@ struct aiCamera
 #endif
 };
 
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/Engine/lib/assimp/include/assimp/cexport.h b/Engine/lib/assimp/include/assimp/cexport.h
index 1d62dc26b..a45ece39b 100644
--- a/Engine/lib/assimp/include/assimp/cexport.h
+++ b/Engine/lib/assimp/include/assimp/cexport.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2011, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -46,39 +46,43 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_EXPORT_H_INC
 #define AI_EXPORT_H_INC
 
+#ifdef __GNUC__
+#pragma GCC system_header
+#endif
+
 #ifndef ASSIMP_BUILD_NO_EXPORT
 
-// Public ASSIMP data structures
 #include <assimp/types.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-struct aiScene;  // aiScene.h
-struct aiFileIO; // aiFileIO.h
+struct aiScene;
+struct aiFileIO;
 
 // --------------------------------------------------------------------------------
-/** Describes an file format which Assimp can export to. Use #aiGetExportFormatCount() to
-* learn how many export formats the current Assimp build supports and #aiGetExportFormatDescription()
-* to retrieve a description of an export format option.
-*/
-struct aiExportFormatDesc
-{
+/**
+ *  @brief  Describes an file format which Assimp can export to.
+ *
+ *  Use #aiGetExportFormatCount() to learn how many export-formats are supported by
+ *  the current Assimp-build and #aiGetExportFormatDescription() to retrieve the
+ *  description of the export format option.
+ */
+struct aiExportFormatDesc {
     /// a short string ID to uniquely identify the export format. Use this ID string to
     /// specify which file format you want to export to when calling #aiExportScene().
     /// Example: "dae" or "obj"
-    const char* id;
+    const char *id;
 
     /// A short description of the file format to present to users. Useful if you want
     /// to allow the user to select an export format.
-    const char* description;
+    const char *description;
 
     /// Recommended file extension for the exported file in lower case.
-    const char* fileExtension;
+    const char *fileExtension;
 };
 
-
 // --------------------------------------------------------------------------------
 /** Returns the number of export file formats available in the current Assimp build.
  * Use aiGetExportFormatDescription() to retrieve infos of a specific export format.
@@ -93,14 +97,14 @@ ASSIMP_API size_t aiGetExportFormatCount(void);
  *    0 to #aiGetExportFormatCount()
  * @return A description of that specific export format. NULL if pIndex is out of range.
  */
-ASSIMP_API const C_STRUCT aiExportFormatDesc* aiGetExportFormatDescription( size_t pIndex);
+ASSIMP_API const C_STRUCT aiExportFormatDesc *aiGetExportFormatDescription(size_t pIndex);
 
 // --------------------------------------------------------------------------------
 /** Release a description of the nth export file format. Must be returned by
 * aiGetExportFormatDescription
 * @param desc Pointer to the description
 */
-ASSIMP_API void aiReleaseExportFormatDescription( const C_STRUCT aiExportFormatDesc *desc );
+ASSIMP_API void aiReleaseExportFormatDescription(const C_STRUCT aiExportFormatDesc *desc);
 
 // --------------------------------------------------------------------------------
 /** Create a modifiable copy of a scene.
@@ -108,16 +112,15 @@ ASSIMP_API void aiReleaseExportFormatDescription( const C_STRUCT aiExportFormatD
  *  export them again. Since the scene returned by the various importer functions
  *  is const, a modifiable copy is needed.
  *  @param pIn Valid scene to be copied
- *  @param pOut Receives a modifyable copy of the scene. Use aiFreeScene() to
+ *  @param pOut Receives a modifiable copy of the scene. Use aiFreeScene() to
  *    delete it again.
  */
-ASSIMP_API void aiCopyScene(const C_STRUCT aiScene* pIn,
-    C_STRUCT aiScene** pOut);
-
+ASSIMP_API void aiCopyScene(const C_STRUCT aiScene *pIn,
+        C_STRUCT aiScene **pOut);
 
 // --------------------------------------------------------------------------------
 /** Frees a scene copy created using aiCopyScene() */
-ASSIMP_API void aiFreeScene(const C_STRUCT aiScene* pIn);
+ASSIMP_API void aiFreeScene(const C_STRUCT aiScene *pIn);
 
 // --------------------------------------------------------------------------------
 /** Exports the given scene to a chosen file format and writes the result file(s) to disk.
@@ -150,19 +153,18 @@ ASSIMP_API void aiFreeScene(const C_STRUCT aiScene* pIn);
 *   triangulate data so they would run the step anyway.
 *
 *   If assimp detects that the input scene was directly taken from the importer side of
-*   the library (i.e. not copied using aiCopyScene and potetially modified afterwards),
-*   any postprocessing steps already applied to the scene will not be applied again, unless
-*   they show non-idempotent behaviour (#aiProcess_MakeLeftHanded, #aiProcess_FlipUVs and
+*   the library (i.e. not copied using aiCopyScene and potentially modified afterwards),
+*   any post-processing steps already applied to the scene will not be applied again, unless
+*   they show non-idempotent behavior (#aiProcess_MakeLeftHanded, #aiProcess_FlipUVs and
 *   #aiProcess_FlipWindingOrder).
 * @return a status code indicating the result of the export
 * @note Use aiCopyScene() to get a modifiable copy of a previously
 *   imported scene.
 */
-ASSIMP_API aiReturn aiExportScene( const C_STRUCT aiScene* pScene,
-    const char* pFormatId,
-    const char* pFileName,
-    unsigned int pPreprocessing);
-
+ASSIMP_API aiReturn aiExportScene(const C_STRUCT aiScene *pScene,
+        const char *pFormatId,
+        const char *pFileName,
+        unsigned int pPreprocessing);
 
 // --------------------------------------------------------------------------------
 /** Exports the given scene to a chosen file format using custom IO logic supplied by you.
@@ -179,11 +181,11 @@ ASSIMP_API aiReturn aiExportScene( const C_STRUCT aiScene* pScene,
 * @note Use aiCopyScene() to get a modifiable copy of a previously
 *   imported scene.
 */
-ASSIMP_API aiReturn aiExportSceneEx( const C_STRUCT aiScene* pScene,
-    const char* pFormatId,
-    const char* pFileName,
-    C_STRUCT aiFileIO* pIO,
-    unsigned int pPreprocessing );
+ASSIMP_API aiReturn aiExportSceneEx(const C_STRUCT aiScene *pScene,
+        const char *pFormatId,
+        const char *pFileName,
+        C_STRUCT aiFileIO *pIO,
+        unsigned int pPreprocessing);
 
 // --------------------------------------------------------------------------------
 /** Describes a blob of exported scene data. Use #aiExportSceneToBlob() to create a blob containing an
@@ -195,41 +197,51 @@ ASSIMP_API aiReturn aiExportSceneEx( const C_STRUCT aiScene* pScene,
 * This is used when exporters write more than one output file for a given #aiScene. See the remarks for
 * #aiExportDataBlob::name for more information.
 */
-struct aiExportDataBlob
-{
+struct aiExportDataBlob {
     /// Size of the data in bytes
     size_t size;
 
     /// The data.
-    void* data;
+    void *data;
 
     /** Name of the blob. An empty string always
-        indicates the first (and primary) blob,
-        which contains the actual file data.
-        Any other blobs are auxiliary files produced
-        by exporters (i.e. material files). Existence
-        of such files depends on the file format. Most
-        formats don't split assets across multiple files.
-
-        If used, blob names usually contain the file
-        extension that should be used when writing
-        the data to disc.
+      * indicates the first (and primary) blob,
+      * which contains the actual file data.
+      * Any other blobs are auxiliary files produced
+      * by exporters (i.e. material files). Existence
+      * of such files depends on the file format. Most
+      * formats don't split assets across multiple files.
+      *
+      * If used, blob names usually contain the file
+      * extension that should be used when writing
+      * the data to disc.
+      *
+      * The blob names generated can be influenced by
+      * setting the #AI_CONFIG_EXPORT_BLOB_NAME export
+      * property to the name that is used for the master
+      * blob. All other names are typically derived from
+      * the base name, by the file format exporter.
      */
     C_STRUCT aiString name;
 
     /** Pointer to the next blob in the chain or NULL if there is none. */
-    C_STRUCT aiExportDataBlob * next;
+    C_STRUCT aiExportDataBlob *next;
 
 #ifdef __cplusplus
     /// Default constructor
-    aiExportDataBlob() { size = 0; data = next = NULL; }
+    aiExportDataBlob() {
+        size = 0;
+        data = next = nullptr;
+    }
     /// Releases the data
-    ~aiExportDataBlob() { delete [] static_cast<unsigned char*>( data ); delete next; }
+    ~aiExportDataBlob() {
+        delete[] static_cast<unsigned char *>(data);
+        delete next;
+    }
+
+    aiExportDataBlob(const aiExportDataBlob &) = delete;
+    aiExportDataBlob &operator=(const aiExportDataBlob &) = delete;
 
-private:
-    // no copying
-    aiExportDataBlob(const aiExportDataBlob& );
-    aiExportDataBlob& operator= (const aiExportDataBlob& );
 #endif // __cplusplus
 };
 
@@ -243,15 +255,15 @@ private:
 * @param pPreprocessing Please see the documentation for #aiExportScene
 * @return the exported data or NULL in case of error
 */
-ASSIMP_API const C_STRUCT aiExportDataBlob* aiExportSceneToBlob( const C_STRUCT aiScene* pScene, const char* pFormatId,
-    unsigned int pPreprocessing );
+ASSIMP_API const C_STRUCT aiExportDataBlob *aiExportSceneToBlob(const C_STRUCT aiScene *pScene, const char *pFormatId,
+        unsigned int pPreprocessing);
 
 // --------------------------------------------------------------------------------
 /** Releases the memory associated with the given exported data. Use this function to free a data blob
 * returned by aiExportScene().
 * @param pData the data blob returned by #aiExportSceneToBlob
 */
-ASSIMP_API void aiReleaseExportBlob( const C_STRUCT aiExportDataBlob* pData );
+ASSIMP_API void aiReleaseExportBlob(const C_STRUCT aiExportDataBlob *pData);
 
 #ifdef __cplusplus
 }
diff --git a/Engine/lib/assimp/include/assimp/cfileio.h b/Engine/lib/assimp/include/assimp/cfileio.h
index 8f7ca4546..fc1b95ad1 100644
--- a/Engine/lib/assimp/include/assimp/cfileio.h
+++ b/Engine/lib/assimp/include/assimp/cfileio.h
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -48,10 +46,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_FILEIO_H_INC
 #define AI_FILEIO_H_INC
 
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
 #include <assimp/types.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
+
 struct aiFileIO;
 struct aiFile;
 
@@ -100,8 +104,7 @@ struct aiFileIO
  *  the CRT. However, you can supply a custom implementation to Assimp by
  *  delivering a custom aiFileIO. Use this to enable reading from other sources,
  *  such as ZIP archives or memory locations. */
-struct aiFile
-{
+struct aiFile {
     /** Callback to read from a file */
     aiFileReadProc ReadProc;
 
diff --git a/Engine/lib/assimp/include/assimp/cimport.h b/Engine/lib/assimp/include/assimp/cimport.h
index dbd10f137..935ed18bd 100644
--- a/Engine/lib/assimp/include/assimp/cimport.h
+++ b/Engine/lib/assimp/include/assimp/cimport.h
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -48,16 +46,21 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_ASSIMP_H_INC
 #define AI_ASSIMP_H_INC
 
+#ifdef __GNUC__
+#pragma GCC system_header
+#endif
+
+#include <assimp/importerdesc.h>
 #include <assimp/types.h>
-#include "importerdesc.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-struct aiScene;  // aiScene.h
-struct aiFileIO; // aiFileIO.h
-typedef void (*aiLogStreamCallback)(const char* /* message */, char* /* user */);
+struct aiScene;
+struct aiFileIO;
+
+typedef void (*aiLogStreamCallback)(const char * /* message */, char * /* user */);
 
 // --------------------------------------------------------------------------------
 /** C-API: Represents a log stream. A log stream receives all log messages and
@@ -66,16 +69,14 @@ typedef void (*aiLogStreamCallback)(const char* /* message */, char* /* user */)
  *  @see aiAttachLogStream
  *  @see aiDetachLogStream */
 // --------------------------------------------------------------------------------
-struct aiLogStream
-{
+struct aiLogStream {
     /** callback to be called */
     aiLogStreamCallback callback;
 
     /** user data to be passed to the callback */
-    char* user;
+    char *user;
 };
 
-
 // --------------------------------------------------------------------------------
 /** C-API: Represents an opaque set of settings to be used during importing.
  *  @see aiCreatePropertyStore
@@ -87,7 +88,9 @@ struct aiLogStream
  *  @see aiSetPropertyMatrix
  */
 // --------------------------------------------------------------------------------
-struct aiPropertyStore { char sentinel; };
+struct aiPropertyStore {
+    char sentinel;
+};
 
 /** Our own C boolean type */
 typedef int aiBool;
@@ -111,9 +114,9 @@ typedef int aiBool;
  *   #aiPostProcessSteps flags.
  * @return Pointer to the imported data or NULL if the import failed.
  */
-ASSIMP_API const C_STRUCT aiScene* aiImportFile(
-    const char* pFile,
-    unsigned int pFlags);
+ASSIMP_API const C_STRUCT aiScene *aiImportFile(
+        const char *pFile,
+        unsigned int pFlags);
 
 // --------------------------------------------------------------------------------
 /** Reads the given file using user-defined I/O functions and returns
@@ -136,10 +139,10 @@ ASSIMP_API const C_STRUCT aiScene* aiImportFile(
  * @return Pointer to the imported data or NULL if the import failed.
  * @note Include <aiFileIO.h> for the definition of #aiFileIO.
  */
-ASSIMP_API const C_STRUCT aiScene* aiImportFileEx(
-    const char* pFile,
-    unsigned int pFlags,
-    C_STRUCT aiFileIO* pFS);
+ASSIMP_API const C_STRUCT aiScene *aiImportFileEx(
+        const char *pFile,
+        unsigned int pFlags,
+        C_STRUCT aiFileIO *pFS);
 
 // --------------------------------------------------------------------------------
 /** Same as #aiImportFileEx, but adds an extra parameter containing importer settings.
@@ -157,11 +160,11 @@ ASSIMP_API const C_STRUCT aiScene* aiImportFileEx(
  * @note Include <aiFileIO.h> for the definition of #aiFileIO.
  * @see aiImportFileEx
  */
-ASSIMP_API const C_STRUCT aiScene* aiImportFileExWithProperties(
-    const char* pFile,
-    unsigned int pFlags,
-    C_STRUCT aiFileIO* pFS,
-    const C_STRUCT aiPropertyStore* pProps);
+ASSIMP_API const C_STRUCT aiScene *aiImportFileExWithProperties(
+        const char *pFile,
+        unsigned int pFlags,
+        C_STRUCT aiFileIO *pFS,
+        const C_STRUCT aiPropertyStore *pProps);
 
 // --------------------------------------------------------------------------------
 /** Reads the given file from a given memory buffer,
@@ -194,11 +197,11 @@ ASSIMP_API const C_STRUCT aiScene* aiImportFileExWithProperties(
  * a custom IOSystem to make Assimp find these files and use
  * the regular aiImportFileEx()/aiImportFileExWithProperties() API.
  */
-ASSIMP_API const C_STRUCT aiScene* aiImportFileFromMemory(
-    const char* pBuffer,
-    unsigned int pLength,
-    unsigned int pFlags,
-    const char* pHint);
+ASSIMP_API const C_STRUCT aiScene *aiImportFileFromMemory(
+        const char *pBuffer,
+        unsigned int pLength,
+        unsigned int pFlags,
+        const char *pHint);
 
 // --------------------------------------------------------------------------------
 /** Same as #aiImportFileFromMemory, but adds an extra parameter containing importer settings.
@@ -228,12 +231,12 @@ ASSIMP_API const C_STRUCT aiScene* aiImportFileFromMemory(
  * the regular aiImportFileEx()/aiImportFileExWithProperties() API.
  * @see aiImportFileFromMemory
  */
-ASSIMP_API const C_STRUCT aiScene* aiImportFileFromMemoryWithProperties(
-    const char* pBuffer,
-    unsigned int pLength,
-    unsigned int pFlags,
-    const char* pHint,
-    const C_STRUCT aiPropertyStore* pProps);
+ASSIMP_API const C_STRUCT aiScene *aiImportFileFromMemoryWithProperties(
+        const char *pBuffer,
+        unsigned int pLength,
+        unsigned int pFlags,
+        const char *pHint,
+        const C_STRUCT aiPropertyStore *pProps);
 
 // --------------------------------------------------------------------------------
 /** Apply post-processing to an already-imported scene.
@@ -250,9 +253,9 @@ ASSIMP_API const C_STRUCT aiScene* aiImportFileFromMemoryWithProperties(
  *   the #aiProcess_ValidateDataStructure flag is currently the only post processing step
  *   which can actually cause the scene to be reset to NULL.
  */
-ASSIMP_API const C_STRUCT aiScene* aiApplyPostProcessing(
-    const C_STRUCT aiScene* pScene,
-    unsigned int pFlags);
+ASSIMP_API const C_STRUCT aiScene *aiApplyPostProcessing(
+        const C_STRUCT aiScene *pScene,
+        unsigned int pFlags);
 
 // --------------------------------------------------------------------------------
 /** Get one of the predefine log streams. This is the quick'n'easy solution to
@@ -275,8 +278,8 @@ ASSIMP_API const C_STRUCT aiScene* aiApplyPostProcessing(
  *  @return The log stream. callback is set to NULL if something went wrong.
  */
 ASSIMP_API C_STRUCT aiLogStream aiGetPredefinedLogStream(
-    C_ENUM aiDefaultLogStream pStreams,
-    const char* file);
+        C_ENUM aiDefaultLogStream pStreams,
+        const char *file);
 
 // --------------------------------------------------------------------------------
 /** Attach a custom log stream to the libraries' logging system.
@@ -289,7 +292,7 @@ ASSIMP_API C_STRUCT aiLogStream aiGetPredefinedLogStream(
  *    Alternatively (for the lazy folks) #aiDetachAllLogStreams is provided.
  */
 ASSIMP_API void aiAttachLogStream(
-    const C_STRUCT aiLogStream* stream);
+        const C_STRUCT aiLogStream *stream);
 
 // --------------------------------------------------------------------------------
 /** Enable verbose logging. Verbose logging includes debug-related stuff and
@@ -310,7 +313,7 @@ ASSIMP_API void aiEnableVerboseLogging(aiBool d);
  *  @see aiDetachAllLogStreams
  */
 ASSIMP_API C_ENUM aiReturn aiDetachLogStream(
-    const C_STRUCT aiLogStream* stream);
+        const C_STRUCT aiLogStream *stream);
 
 // --------------------------------------------------------------------------------
 /** Detach all active log streams from the libraries' logging system.
@@ -329,7 +332,7 @@ ASSIMP_API void aiDetachAllLogStreams(void);
  * @param pScene The imported data to release. NULL is a valid value.
  */
 ASSIMP_API void aiReleaseImport(
-    const C_STRUCT aiScene* pScene);
+        const C_STRUCT aiScene *pScene);
 
 // --------------------------------------------------------------------------------
 /** Returns the error text of the last failed import process.
@@ -338,7 +341,7 @@ ASSIMP_API void aiReleaseImport(
  * import process. NULL if there was no error. There can't be an error if you
  * got a non-NULL #aiScene from #aiImportFile/#aiImportFileEx/#aiApplyPostProcessing.
  */
-ASSIMP_API const char* aiGetErrorString(void);
+ASSIMP_API const char *aiGetErrorString(void);
 
 // --------------------------------------------------------------------------------
 /** Returns whether a given file extension is supported by ASSIMP
@@ -348,7 +351,7 @@ ASSIMP_API const char* aiGetErrorString(void);
  * @return AI_TRUE if the file extension is supported.
  */
 ASSIMP_API aiBool aiIsExtensionSupported(
-    const char* szExtension);
+        const char *szExtension);
 
 // --------------------------------------------------------------------------------
 /** Get a list of all file extensions supported by ASSIMP.
@@ -359,7 +362,7 @@ ASSIMP_API aiBool aiIsExtensionSupported(
  * Format of the list: "*.3ds;*.obj;*.dae". NULL is not a valid parameter.
  */
 ASSIMP_API void aiGetExtensionList(
-    C_STRUCT aiString* szOut);
+        C_STRUCT aiString *szOut);
 
 // --------------------------------------------------------------------------------
 /** Get the approximated storage required by an imported asset
@@ -367,10 +370,8 @@ ASSIMP_API void aiGetExtensionList(
  * @param in Data structure to be filled.
  */
 ASSIMP_API void aiGetMemoryRequirements(
-    const C_STRUCT aiScene* pIn,
-    C_STRUCT aiMemoryInfo* in);
-
-
+        const C_STRUCT aiScene *pIn,
+        C_STRUCT aiMemoryInfo *in);
 
 // --------------------------------------------------------------------------------
 /** Create an empty property store. Property stores are used to collect import
@@ -378,13 +379,13 @@ ASSIMP_API void aiGetMemoryRequirements(
  * @return New property store. Property stores need to be manually destroyed using
  *   the #aiReleasePropertyStore API function.
  */
-ASSIMP_API C_STRUCT aiPropertyStore* aiCreatePropertyStore(void);
+ASSIMP_API C_STRUCT aiPropertyStore *aiCreatePropertyStore(void);
 
 // --------------------------------------------------------------------------------
 /** Delete a property store.
  * @param p Property store to be deleted.
  */
-ASSIMP_API void aiReleasePropertyStore(C_STRUCT aiPropertyStore* p);
+ASSIMP_API void aiReleasePropertyStore(C_STRUCT aiPropertyStore *p);
 
 // --------------------------------------------------------------------------------
 /** Set an integer property.
@@ -399,9 +400,9 @@ ASSIMP_API void aiReleasePropertyStore(C_STRUCT aiPropertyStore* p);
  * @param value New value for the property
  */
 ASSIMP_API void aiSetImportPropertyInteger(
-    C_STRUCT aiPropertyStore* store,
-    const char* szName,
-    int value);
+        C_STRUCT aiPropertyStore *store,
+        const char *szName,
+        int value);
 
 // --------------------------------------------------------------------------------
 /** Set a floating-point property.
@@ -416,9 +417,9 @@ ASSIMP_API void aiSetImportPropertyInteger(
  * @param value New value for the property
  */
 ASSIMP_API void aiSetImportPropertyFloat(
-    C_STRUCT aiPropertyStore* store,
-    const char* szName,
-    ai_real value);
+        C_STRUCT aiPropertyStore *store,
+        const char *szName,
+        ai_real value);
 
 // --------------------------------------------------------------------------------
 /** Set a string property.
@@ -433,9 +434,9 @@ ASSIMP_API void aiSetImportPropertyFloat(
  * @param st New value for the property
  */
 ASSIMP_API void aiSetImportPropertyString(
-    C_STRUCT aiPropertyStore* store,
-    const char* szName,
-    const C_STRUCT aiString* st);
+        C_STRUCT aiPropertyStore *store,
+        const char *szName,
+        const C_STRUCT aiString *st);
 
 // --------------------------------------------------------------------------------
 /** Set a matrix property.
@@ -450,9 +451,9 @@ ASSIMP_API void aiSetImportPropertyString(
  * @param mat New value for the property
  */
 ASSIMP_API void aiSetImportPropertyMatrix(
-    C_STRUCT aiPropertyStore* store,
-    const char* szName,
-    const C_STRUCT aiMatrix4x4* mat);
+        C_STRUCT aiPropertyStore *store,
+        const char *szName,
+        const C_STRUCT aiMatrix4x4 *mat);
 
 // --------------------------------------------------------------------------------
 /** Construct a quaternion from a 3x3 rotation matrix.
@@ -461,8 +462,8 @@ ASSIMP_API void aiSetImportPropertyMatrix(
  *  @see aiQuaternion(const aiMatrix3x3& pRotMatrix)
  */
 ASSIMP_API void aiCreateQuaternionFromMatrix(
-    C_STRUCT aiQuaternion* quat,
-    const C_STRUCT aiMatrix3x3* mat);
+        C_STRUCT aiQuaternion *quat,
+        const C_STRUCT aiMatrix3x3 *mat);
 
 // --------------------------------------------------------------------------------
 /** Decompose a transformation matrix into its rotational, translational and
@@ -475,24 +476,24 @@ ASSIMP_API void aiCreateQuaternionFromMatrix(
  * @see aiMatrix4x4::Decompose (aiVector3D&, aiQuaternion&, aiVector3D&) const;
  */
 ASSIMP_API void aiDecomposeMatrix(
-    const C_STRUCT aiMatrix4x4* mat,
-    C_STRUCT aiVector3D* scaling,
-    C_STRUCT aiQuaternion* rotation,
-    C_STRUCT aiVector3D* position);
+        const C_STRUCT aiMatrix4x4 *mat,
+        C_STRUCT aiVector3D *scaling,
+        C_STRUCT aiQuaternion *rotation,
+        C_STRUCT aiVector3D *position);
 
 // --------------------------------------------------------------------------------
 /** Transpose a 4x4 matrix.
  *  @param mat Pointer to the matrix to be transposed
  */
 ASSIMP_API void aiTransposeMatrix4(
-    C_STRUCT aiMatrix4x4* mat);
+        C_STRUCT aiMatrix4x4 *mat);
 
 // --------------------------------------------------------------------------------
 /** Transpose a 3x3 matrix.
  *  @param mat Pointer to the matrix to be transposed
  */
 ASSIMP_API void aiTransposeMatrix3(
-    C_STRUCT aiMatrix3x3* mat);
+        C_STRUCT aiMatrix3x3 *mat);
 
 // --------------------------------------------------------------------------------
 /** Transform a vector by a 3x3 matrix
@@ -500,8 +501,8 @@ ASSIMP_API void aiTransposeMatrix3(
  *  @param mat Matrix to transform the vector with.
  */
 ASSIMP_API void aiTransformVecByMatrix3(
-    C_STRUCT aiVector3D* vec,
-    const C_STRUCT aiMatrix3x3* mat);
+        C_STRUCT aiVector3D *vec,
+        const C_STRUCT aiMatrix3x3 *mat);
 
 // --------------------------------------------------------------------------------
 /** Transform a vector by a 4x4 matrix
@@ -509,8 +510,8 @@ ASSIMP_API void aiTransformVecByMatrix3(
  *  @param mat Matrix to transform the vector with.
  */
 ASSIMP_API void aiTransformVecByMatrix4(
-    C_STRUCT aiVector3D* vec,
-    const C_STRUCT aiMatrix4x4* mat);
+        C_STRUCT aiVector3D *vec,
+        const C_STRUCT aiMatrix4x4 *mat);
 
 // --------------------------------------------------------------------------------
 /** Multiply two 4x4 matrices.
@@ -518,8 +519,8 @@ ASSIMP_API void aiTransformVecByMatrix4(
  *  @param src Matrix to be multiplied with 'dst'.
  */
 ASSIMP_API void aiMultiplyMatrix4(
-    C_STRUCT aiMatrix4x4* dst,
-    const C_STRUCT aiMatrix4x4* src);
+        C_STRUCT aiMatrix4x4 *dst,
+        const C_STRUCT aiMatrix4x4 *src);
 
 // --------------------------------------------------------------------------------
 /** Multiply two 3x3 matrices.
@@ -527,22 +528,22 @@ ASSIMP_API void aiMultiplyMatrix4(
  *  @param src Matrix to be multiplied with 'dst'.
  */
 ASSIMP_API void aiMultiplyMatrix3(
-    C_STRUCT aiMatrix3x3* dst,
-    const C_STRUCT aiMatrix3x3* src);
+        C_STRUCT aiMatrix3x3 *dst,
+        const C_STRUCT aiMatrix3x3 *src);
 
 // --------------------------------------------------------------------------------
 /** Get a 3x3 identity matrix.
  *  @param mat Matrix to receive its personal identity
  */
 ASSIMP_API void aiIdentityMatrix3(
-    C_STRUCT aiMatrix3x3* mat);
+        C_STRUCT aiMatrix3x3 *mat);
 
 // --------------------------------------------------------------------------------
 /** Get a 4x4 identity matrix.
  *  @param mat Matrix to receive its personal identity
  */
 ASSIMP_API void aiIdentityMatrix4(
-    C_STRUCT aiMatrix4x4* mat);
+        C_STRUCT aiMatrix4x4 *mat);
 
 // --------------------------------------------------------------------------------
 /** Returns the number of import file formats available in the current Assimp build.
@@ -557,7 +558,676 @@ ASSIMP_API size_t aiGetImportFormatCount(void);
  *    0 to #aiGetImportFormatCount()
  * @return A description of that specific import format. NULL if pIndex is out of range.
  */
-ASSIMP_API const C_STRUCT aiImporterDesc* aiGetImportFormatDescription( size_t pIndex);
+ASSIMP_API const C_STRUCT aiImporterDesc *aiGetImportFormatDescription(size_t pIndex);
+
+// --------------------------------------------------------------------------------
+/** Check if 2D vectors are equal.
+ *  @param a First vector to compare
+ *  @param b Second vector to compare
+ *  @return 1 if the vectors are equal
+ *  @return 0 if the vectors are not equal
+ */
+ASSIMP_API int aiVector2AreEqual(
+        const C_STRUCT aiVector2D *a,
+        const C_STRUCT aiVector2D *b);
+
+// --------------------------------------------------------------------------------
+/** Check if 2D vectors are equal using epsilon.
+ *  @param a First vector to compare
+ *  @param b Second vector to compare
+ *  @param epsilon Epsilon
+ *  @return 1 if the vectors are equal
+ *  @return 0 if the vectors are not equal
+ */
+ASSIMP_API int aiVector2AreEqualEpsilon(
+        const C_STRUCT aiVector2D *a,
+        const C_STRUCT aiVector2D *b,
+        const float epsilon);
+
+// --------------------------------------------------------------------------------
+/** Add 2D vectors.
+ *  @param dst First addend, receives result.
+ *  @param src Vector to be added to 'dst'.
+ */
+ASSIMP_API void aiVector2Add(
+        C_STRUCT aiVector2D *dst,
+        const C_STRUCT aiVector2D *src);
+
+// --------------------------------------------------------------------------------
+/** Subtract 2D vectors.
+ *  @param dst Minuend, receives result.
+ *  @param src Vector to be subtracted from 'dst'.
+ */
+ASSIMP_API void aiVector2Subtract(
+        C_STRUCT aiVector2D *dst,
+        const C_STRUCT aiVector2D *src);
+
+// --------------------------------------------------------------------------------
+/** Multiply a 2D vector by a scalar.
+ *  @param dst Vector to be scaled by \p s
+ *  @param s Scale factor
+ */
+ASSIMP_API void aiVector2Scale(
+        C_STRUCT aiVector2D *dst,
+        const float s);
+
+// --------------------------------------------------------------------------------
+/** Multiply each component of a 2D vector with
+ *  the components of another vector.
+ *  @param dst First vector, receives result
+ *  @param other Second vector
+ */
+ASSIMP_API void aiVector2SymMul(
+        C_STRUCT aiVector2D *dst,
+        const C_STRUCT aiVector2D *other);
+
+// --------------------------------------------------------------------------------
+/** Divide a 2D vector by a scalar.
+ *  @param dst Vector to be divided by \p s
+ *  @param s Scalar divisor
+ */
+ASSIMP_API void aiVector2DivideByScalar(
+        C_STRUCT aiVector2D *dst,
+        const float s);
+
+// --------------------------------------------------------------------------------
+/** Divide each component of a 2D vector by
+ *  the components of another vector.
+ *  @param dst Vector as the dividend
+ *  @param v Vector as the divisor
+ */
+ASSIMP_API void aiVector2DivideByVector(
+        C_STRUCT aiVector2D *dst,
+        C_STRUCT aiVector2D *v);
+
+// --------------------------------------------------------------------------------
+/** Get the length of a 2D vector.
+ *  @return v Vector to evaluate
+ */
+ASSIMP_API float aiVector2Length(
+        const C_STRUCT aiVector2D *v);
+
+// --------------------------------------------------------------------------------
+/** Get the squared length of a 2D vector.
+ *  @return v Vector to evaluate
+ */
+ASSIMP_API float aiVector2SquareLength(
+        const C_STRUCT aiVector2D *v);
+
+// --------------------------------------------------------------------------------
+/** Negate a 2D vector.
+ *  @param dst Vector to be negated
+ */
+ASSIMP_API void aiVector2Negate(
+        C_STRUCT aiVector2D *dst);
+
+// --------------------------------------------------------------------------------
+/** Get the dot product of 2D vectors.
+ *  @param a First vector
+ *  @param b Second vector
+ *  @return The dot product of vectors
+ */
+ASSIMP_API float aiVector2DotProduct(
+        const C_STRUCT aiVector2D *a,
+        const C_STRUCT aiVector2D *b);
+
+// --------------------------------------------------------------------------------
+/** Normalize a 2D vector.
+ *  @param v Vector to normalize
+ */
+ASSIMP_API void aiVector2Normalize(
+        C_STRUCT aiVector2D *v);
+
+// --------------------------------------------------------------------------------
+/** Check if 3D vectors are equal.
+ *  @param a First vector to compare
+ *  @param b Second vector to compare
+ *  @return 1 if the vectors are equal
+ *  @return 0 if the vectors are not equal
+ */
+ASSIMP_API int aiVector3AreEqual(
+        const C_STRUCT aiVector3D *a,
+        const C_STRUCT aiVector3D *b);
+
+// --------------------------------------------------------------------------------
+/** Check if 3D vectors are equal using epsilon.
+ *  @param a First vector to compare
+ *  @param b Second vector to compare
+ *  @param epsilon Epsilon
+ *  @return 1 if the vectors are equal
+ *  @return 0 if the vectors are not equal
+ */
+ASSIMP_API int aiVector3AreEqualEpsilon(
+        const C_STRUCT aiVector3D *a,
+        const C_STRUCT aiVector3D *b,
+        const float epsilon);
+
+// --------------------------------------------------------------------------------
+/** Check if vector \p a is less than vector \p b.
+ *  @param a First vector to compare
+ *  @param b Second vector to compare
+ *  @param epsilon Epsilon
+ *  @return 1 if \p a is less than \p b
+ *  @return 0 if \p a is equal or greater than \p b
+ */
+ASSIMP_API int aiVector3LessThan(
+        const C_STRUCT aiVector3D *a,
+        const C_STRUCT aiVector3D *b);
+
+// --------------------------------------------------------------------------------
+/** Add 3D vectors.
+ *  @param dst First addend, receives result.
+ *  @param src Vector to be added to 'dst'.
+ */
+ASSIMP_API void aiVector3Add(
+        C_STRUCT aiVector3D *dst,
+        const C_STRUCT aiVector3D *src);
+
+// --------------------------------------------------------------------------------
+/** Subtract 3D vectors.
+ *  @param dst Minuend, receives result.
+ *  @param src Vector to be subtracted from 'dst'.
+ */
+ASSIMP_API void aiVector3Subtract(
+        C_STRUCT aiVector3D *dst,
+        const C_STRUCT aiVector3D *src);
+
+// --------------------------------------------------------------------------------
+/** Multiply a 3D vector by a scalar.
+ *  @param dst Vector to be scaled by \p s
+ *  @param s Scale factor
+ */
+ASSIMP_API void aiVector3Scale(
+        C_STRUCT aiVector3D *dst,
+        const float s);
+
+// --------------------------------------------------------------------------------
+/** Multiply each component of a 3D vector with
+ *  the components of another vector.
+ *  @param dst First vector, receives result
+ *  @param other Second vector
+ */
+ASSIMP_API void aiVector3SymMul(
+        C_STRUCT aiVector3D *dst,
+        const C_STRUCT aiVector3D *other);
+
+// --------------------------------------------------------------------------------
+/** Divide a 3D vector by a scalar.
+ *  @param dst Vector to be divided by \p s
+ *  @param s Scalar divisor
+ */
+ASSIMP_API void aiVector3DivideByScalar(
+        C_STRUCT aiVector3D *dst,
+        const float s);
+
+// --------------------------------------------------------------------------------
+/** Divide each component of a 3D vector by
+ *  the components of another vector.
+ *  @param dst Vector as the dividend
+ *  @param v Vector as the divisor
+ */
+ASSIMP_API void aiVector3DivideByVector(
+        C_STRUCT aiVector3D *dst,
+        C_STRUCT aiVector3D *v);
+
+// --------------------------------------------------------------------------------
+/** Get the length of a 3D vector.
+ *  @return v Vector to evaluate
+ */
+ASSIMP_API float aiVector3Length(
+        const C_STRUCT aiVector3D *v);
+
+// --------------------------------------------------------------------------------
+/** Get the squared length of a 3D vector.
+ *  @return v Vector to evaluate
+ */
+ASSIMP_API float aiVector3SquareLength(
+        const C_STRUCT aiVector3D *v);
+
+// --------------------------------------------------------------------------------
+/** Negate a 3D vector.
+ *  @param dst Vector to be negated
+ */
+ASSIMP_API void aiVector3Negate(
+        C_STRUCT aiVector3D *dst);
+
+// --------------------------------------------------------------------------------
+/** Get the dot product of 3D vectors.
+ *  @param a First vector
+ *  @param b Second vector
+ *  @return The dot product of vectors
+ */
+ASSIMP_API float aiVector3DotProduct(
+        const C_STRUCT aiVector3D *a,
+        const C_STRUCT aiVector3D *b);
+
+// --------------------------------------------------------------------------------
+/** Get cross product of 3D vectors.
+ *  @param dst Vector to receive the result.
+ *  @param a First vector
+ *  @param b Second vector
+ *  @return The dot product of vectors
+ */
+ASSIMP_API void aiVector3CrossProduct(
+        C_STRUCT aiVector3D *dst,
+        const C_STRUCT aiVector3D *a,
+        const C_STRUCT aiVector3D *b);
+
+// --------------------------------------------------------------------------------
+/** Normalize a 3D vector.
+ *  @param v Vector to normalize
+ */
+ASSIMP_API void aiVector3Normalize(
+        C_STRUCT aiVector3D *v);
+
+// --------------------------------------------------------------------------------
+/** Check for division by zero and normalize a 3D vector.
+ *  @param v Vector to normalize
+ */
+ASSIMP_API void aiVector3NormalizeSafe(
+        C_STRUCT aiVector3D *v);
+
+// --------------------------------------------------------------------------------
+/** Rotate a 3D vector by a quaternion.
+ *  @param v The vector to rotate by \p q
+ *  @param q Quaternion to use to rotate \p v
+ */
+ASSIMP_API void aiVector3RotateByQuaternion(
+        C_STRUCT aiVector3D *v,
+        const C_STRUCT aiQuaternion *q);
+
+// --------------------------------------------------------------------------------
+/** Construct a 3x3 matrix from a 4x4 matrix.
+ *  @param dst Receives the output matrix
+ *  @param mat The 4x4 matrix to use
+ */
+ASSIMP_API void aiMatrix3FromMatrix4(
+        C_STRUCT aiMatrix3x3 *dst,
+        const C_STRUCT aiMatrix4x4 *mat);
+
+// --------------------------------------------------------------------------------
+/** Construct a 3x3 matrix from a quaternion.
+ *  @param mat Receives the output matrix
+ *  @param q The quaternion matrix to use
+ */
+ASSIMP_API void aiMatrix3FromQuaternion(
+        C_STRUCT aiMatrix3x3 *mat,
+        const C_STRUCT aiQuaternion *q);
+
+// --------------------------------------------------------------------------------
+/** Check if 3x3 matrices are equal.
+ *  @param a First matrix to compare
+ *  @param b Second matrix to compare
+ *  @return 1 if the matrices are equal
+ *  @return 0 if the matrices are not equal
+ */
+ASSIMP_API int aiMatrix3AreEqual(
+        const C_STRUCT aiMatrix3x3 *a,
+        const C_STRUCT aiMatrix3x3 *b);
+
+// --------------------------------------------------------------------------------
+/** Check if 3x3 matrices are equal.
+ *  @param a First matrix to compare
+ *  @param b Second matrix to compare
+ *  @param epsilon Epsilon
+ *  @return 1 if the matrices are equal
+ *  @return 0 if the matrices are not equal
+ */
+ASSIMP_API int aiMatrix3AreEqualEpsilon(
+        const C_STRUCT aiMatrix3x3 *a,
+        const C_STRUCT aiMatrix3x3 *b,
+        const float epsilon);
+
+// --------------------------------------------------------------------------------
+/** Invert a 3x3 matrix.
+ *  @param mat Matrix to invert
+ */
+ASSIMP_API void aiMatrix3Inverse(
+        C_STRUCT aiMatrix3x3 *mat);
+
+// --------------------------------------------------------------------------------
+/** Get the determinant of a 3x3 matrix.
+ *  @param mat Matrix to get the determinant from
+ */
+ASSIMP_API float aiMatrix3Determinant(
+        const C_STRUCT aiMatrix3x3 *mat);
+
+// --------------------------------------------------------------------------------
+/** Get a 3x3 rotation matrix around the Z axis.
+ *  @param mat Receives the output matrix
+ *  @param angle Rotation angle, in radians
+ */
+ASSIMP_API void aiMatrix3RotationZ(
+        C_STRUCT aiMatrix3x3 *mat,
+        const float angle);
+
+// --------------------------------------------------------------------------------
+/** Returns a 3x3 rotation matrix for a rotation around an arbitrary axis.
+ *  @param mat Receives the output matrix
+ *  @param axis Rotation axis, should be a normalized vector
+ *  @param angle Rotation angle, in radians
+ */
+ASSIMP_API void aiMatrix3FromRotationAroundAxis(
+        C_STRUCT aiMatrix3x3 *mat,
+        const C_STRUCT aiVector3D *axis,
+        const float angle);
+
+// --------------------------------------------------------------------------------
+/** Get a 3x3 translation matrix.
+ *  @param mat Receives the output matrix
+ *  @param translation The translation vector
+ */
+ASSIMP_API void aiMatrix3Translation(
+        C_STRUCT aiMatrix3x3 *mat,
+        const C_STRUCT aiVector2D *translation);
+
+// --------------------------------------------------------------------------------
+/** Create a 3x3 matrix that rotates one vector to another vector.
+ *  @param mat Receives the output matrix
+ *  @param from Vector to rotate from
+ *  @param to Vector to rotate to
+ */
+ASSIMP_API void aiMatrix3FromTo(
+        C_STRUCT aiMatrix3x3 *mat,
+        const C_STRUCT aiVector3D *from,
+        const C_STRUCT aiVector3D *to);
+
+// --------------------------------------------------------------------------------
+/** Construct a 4x4 matrix from a 3x3 matrix.
+ *  @param dst Receives the output matrix
+ *  @param mat The 3x3 matrix to use
+ */
+ASSIMP_API void aiMatrix4FromMatrix3(
+        C_STRUCT aiMatrix4x4 *dst,
+        const C_STRUCT aiMatrix3x3 *mat);
+
+// --------------------------------------------------------------------------------
+/** Construct a 4x4 matrix from scaling, rotation and position.
+ *  @param mat Receives the output matrix.
+ *  @param scaling The scaling for the x,y,z axes
+ *  @param rotation The rotation as a hamilton quaternion
+ *  @param position The position for the x,y,z axes
+ */
+ASSIMP_API void aiMatrix4FromScalingQuaternionPosition(
+        C_STRUCT aiMatrix4x4 *mat,
+        const C_STRUCT aiVector3D *scaling,
+        const C_STRUCT aiQuaternion *rotation,
+        const C_STRUCT aiVector3D *position);
+
+// --------------------------------------------------------------------------------
+/** Add 4x4 matrices.
+ *  @param dst First addend, receives result.
+ *  @param src Matrix to be added to 'dst'.
+ */
+ASSIMP_API void aiMatrix4Add(
+        C_STRUCT aiMatrix4x4 *dst,
+        const C_STRUCT aiMatrix4x4 *src);
+
+// --------------------------------------------------------------------------------
+/** Check if 4x4 matrices are equal.
+ *  @param a First matrix to compare
+ *  @param b Second matrix to compare
+ *  @return 1 if the matrices are equal
+ *  @return 0 if the matrices are not equal
+ */
+ASSIMP_API int aiMatrix4AreEqual(
+        const C_STRUCT aiMatrix4x4 *a,
+        const C_STRUCT aiMatrix4x4 *b);
+
+// --------------------------------------------------------------------------------
+/** Check if 4x4 matrices are equal.
+ *  @param a First matrix to compare
+ *  @param b Second matrix to compare
+ *  @param epsilon Epsilon
+ *  @return 1 if the matrices are equal
+ *  @return 0 if the matrices are not equal
+ */
+ASSIMP_API int aiMatrix4AreEqualEpsilon(
+        const C_STRUCT aiMatrix4x4 *a,
+        const C_STRUCT aiMatrix4x4 *b,
+        const float epsilon);
+
+// --------------------------------------------------------------------------------
+/** Invert a 4x4 matrix.
+ *  @param result Matrix to invert
+ */
+ASSIMP_API void aiMatrix4Inverse(
+        C_STRUCT aiMatrix4x4 *mat);
+
+// --------------------------------------------------------------------------------
+/** Get the determinant of a 4x4 matrix.
+ *  @param mat Matrix to get the determinant from
+ *  @return The determinant of the matrix
+ */
+ASSIMP_API float aiMatrix4Determinant(
+        const C_STRUCT aiMatrix4x4 *mat);
+
+// --------------------------------------------------------------------------------
+/** Returns true of the matrix is the identity matrix.
+ *  @param mat Matrix to get the determinant from
+ *  @return 1 if \p mat is an identity matrix.
+ *  @return 0 if \p mat is not an identity matrix.
+ */
+ASSIMP_API int aiMatrix4IsIdentity(
+        const C_STRUCT aiMatrix4x4 *mat);
+
+// --------------------------------------------------------------------------------
+/** Decompose a transformation matrix into its scaling,
+ *  rotational as euler angles, and translational components.
+ *
+ * @param mat Matrix to decompose
+ * @param scaling Receives the output scaling for the x,y,z axes
+ * @param rotation Receives the output rotation as a Euler angles
+ * @param position Receives the output position for the x,y,z axes
+ */
+ASSIMP_API void aiMatrix4DecomposeIntoScalingEulerAnglesPosition(
+        const C_STRUCT aiMatrix4x4 *mat,
+        C_STRUCT aiVector3D *scaling,
+        C_STRUCT aiVector3D *rotation,
+        C_STRUCT aiVector3D *position);
+
+// --------------------------------------------------------------------------------
+/** Decompose a transformation matrix into its scaling,
+ *  rotational split into an axis and rotational angle,
+ *  and it's translational components.
+ *
+ * @param mat Matrix to decompose
+ * @param rotation Receives the rotational component
+ * @param axis Receives the output rotation axis
+ * @param angle Receives the output rotation angle
+ * @param position Receives the output position for the x,y,z axes.
+ */
+ASSIMP_API void aiMatrix4DecomposeIntoScalingAxisAnglePosition(
+        const C_STRUCT aiMatrix4x4 *mat,
+        C_STRUCT aiVector3D *scaling,
+        C_STRUCT aiVector3D *axis,
+        ai_real *angle,
+        C_STRUCT aiVector3D *position);
+
+// --------------------------------------------------------------------------------
+/** Decompose a transformation matrix into its rotational and
+ *  translational components.
+ *
+ * @param mat Matrix to decompose
+ * @param rotation Receives the rotational component
+ * @param position Receives the translational component.
+ */
+ASSIMP_API void aiMatrix4DecomposeNoScaling(
+        const C_STRUCT aiMatrix4x4 *mat,
+        C_STRUCT aiQuaternion *rotation,
+        C_STRUCT aiVector3D *position);
+
+// --------------------------------------------------------------------------------
+/** Creates a 4x4 matrix from a set of euler angles.
+ *  @param mat Receives the output matrix
+ *  @param x Rotation angle for the x-axis, in radians
+ *  @param y Rotation angle for the y-axis, in radians
+ *  @param z Rotation angle for the z-axis, in radians
+ */
+ASSIMP_API void aiMatrix4FromEulerAngles(
+        C_STRUCT aiMatrix4x4 *mat,
+        float x, float y, float z);
+
+// --------------------------------------------------------------------------------
+/** Get a 4x4 rotation matrix around the X axis.
+ *  @param mat Receives the output matrix
+ *  @param angle Rotation angle, in radians
+ */
+ASSIMP_API void aiMatrix4RotationX(
+        C_STRUCT aiMatrix4x4 *mat,
+        const float angle);
+
+// --------------------------------------------------------------------------------
+/** Get a 4x4 rotation matrix around the Y axis.
+ *  @param mat Receives the output matrix
+ *  @param angle Rotation angle, in radians
+ */
+ASSIMP_API void aiMatrix4RotationY(
+        C_STRUCT aiMatrix4x4 *mat,
+        const float angle);
+
+// --------------------------------------------------------------------------------
+/** Get a 4x4 rotation matrix around the Z axis.
+ *  @param mat Receives the output matrix
+ *  @param angle Rotation angle, in radians
+ */
+ASSIMP_API void aiMatrix4RotationZ(
+        C_STRUCT aiMatrix4x4 *mat,
+        const float angle);
+
+// --------------------------------------------------------------------------------
+/** Returns a 4x4 rotation matrix for a rotation around an arbitrary axis.
+ *  @param mat Receives the output matrix
+ *  @param axis Rotation axis, should be a normalized vector
+ *  @param angle Rotation angle, in radians
+ */
+ASSIMP_API void aiMatrix4FromRotationAroundAxis(
+        C_STRUCT aiMatrix4x4 *mat,
+        const C_STRUCT aiVector3D *axis,
+        const float angle);
+
+// --------------------------------------------------------------------------------
+/** Get a 4x4 translation matrix.
+ *  @param mat Receives the output matrix
+ *  @param translation The translation vector
+ */
+ASSIMP_API void aiMatrix4Translation(
+        C_STRUCT aiMatrix4x4 *mat,
+        const C_STRUCT aiVector3D *translation);
+
+// --------------------------------------------------------------------------------
+/** Get a 4x4 scaling matrix.
+ *  @param mat Receives the output matrix
+ *  @param scaling The scaling vector
+ */
+ASSIMP_API void aiMatrix4Scaling(
+        C_STRUCT aiMatrix4x4 *mat,
+        const C_STRUCT aiVector3D *scaling);
+
+// --------------------------------------------------------------------------------
+/** Create a 4x4 matrix that rotates one vector to another vector.
+ *  @param mat Receives the output matrix
+ *  @param from Vector to rotate from
+ *  @param to Vector to rotate to
+ */
+ASSIMP_API void aiMatrix4FromTo(
+        C_STRUCT aiMatrix4x4 *mat,
+        const C_STRUCT aiVector3D *from,
+        const C_STRUCT aiVector3D *to);
+
+// --------------------------------------------------------------------------------
+/** Create a Quaternion from euler angles.
+ *  @param q Receives the output quaternion
+ *  @param x Rotation angle for the x-axis, in radians
+ *  @param y Rotation angle for the y-axis, in radians
+ *  @param z Rotation angle for the z-axis, in radians
+ */
+ASSIMP_API void aiQuaternionFromEulerAngles(
+        C_STRUCT aiQuaternion *q,
+        float x, float y, float z);
+
+// --------------------------------------------------------------------------------
+/** Create a Quaternion from an axis angle pair.
+ *  @param q Receives the output quaternion
+ *  @param axis The orientation axis
+ *  @param angle The rotation angle, in radians
+ */
+ASSIMP_API void aiQuaternionFromAxisAngle(
+        C_STRUCT aiQuaternion *q,
+        const C_STRUCT aiVector3D *axis,
+        const float angle);
+
+// --------------------------------------------------------------------------------
+/** Create a Quaternion from a normalized quaternion stored
+ *  in a 3D vector.
+ *  @param q Receives the output quaternion
+ *  @param normalized The vector that stores the quaternion
+ */
+ASSIMP_API void aiQuaternionFromNormalizedQuaternion(
+        C_STRUCT aiQuaternion *q,
+        const C_STRUCT aiVector3D *normalized);
+
+// --------------------------------------------------------------------------------
+/** Check if quaternions are equal.
+ *  @param a First quaternion to compare
+ *  @param b Second quaternion to compare
+ *  @return 1 if the quaternions are equal
+ *  @return 0 if the quaternions are not equal
+ */
+ASSIMP_API int aiQuaternionAreEqual(
+        const C_STRUCT aiQuaternion *a,
+        const C_STRUCT aiQuaternion *b);
+
+// --------------------------------------------------------------------------------
+/** Check if quaternions are equal using epsilon.
+ *  @param a First quaternion to compare
+ *  @param b Second quaternion to compare
+ *  @param epsilon Epsilon
+ *  @return 1 if the quaternions are equal
+ *  @return 0 if the quaternions are not equal
+ */
+ASSIMP_API int aiQuaternionAreEqualEpsilon(
+        const C_STRUCT aiQuaternion *a,
+        const C_STRUCT aiQuaternion *b,
+        const float epsilon);
+
+// --------------------------------------------------------------------------------
+/** Normalize a quaternion.
+ *  @param q Quaternion to normalize
+ */
+ASSIMP_API void aiQuaternionNormalize(
+        C_STRUCT aiQuaternion *q);
+
+// --------------------------------------------------------------------------------
+/** Compute quaternion conjugate.
+ *  @param q Quaternion to compute conjugate,
+ *           receives the output quaternion
+ */
+ASSIMP_API void aiQuaternionConjugate(
+        C_STRUCT aiQuaternion *q);
+
+// --------------------------------------------------------------------------------
+/** Multiply quaternions.
+ *  @param dst First quaternion, receives the output quaternion
+ *  @param q Second quaternion
+ */
+ASSIMP_API void aiQuaternionMultiply(
+        C_STRUCT aiQuaternion *dst,
+        const C_STRUCT aiQuaternion *q);
+
+// --------------------------------------------------------------------------------
+/** Performs a spherical interpolation between two quaternions.
+ * @param dst Receives the quaternion resulting from the interpolation.
+ * @param start Quaternion when factor == 0
+ * @param end Quaternion when factor == 1
+ * @param factor Interpolation factor between 0 and 1
+ */
+ASSIMP_API void aiQuaternionInterpolate(
+        C_STRUCT aiQuaternion *dst,
+        const C_STRUCT aiQuaternion *start,
+        const C_STRUCT aiQuaternion *end,
+        const float factor);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/Engine/lib/assimp/include/assimp/color4.h b/Engine/lib/assimp/include/assimp/color4.h
index 3c97c8eda..e1e354939 100644
--- a/Engine/lib/assimp/include/assimp/color4.h
+++ b/Engine/lib/assimp/include/assimp/color4.h
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -47,7 +45,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_COLOR4D_H_INC
 #define AI_COLOR4D_H_INC
 
-#include "defs.h"
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
+#include <assimp/defs.h>
 
 #ifdef __cplusplus
 
@@ -56,8 +58,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *   alpha component. Color values range from 0 to 1. */
 // ----------------------------------------------------------------------------------
 template <typename TReal>
-class aiColor4t
-{
+class aiColor4t {
 public:
     aiColor4t() AI_NO_EXCEPT : r(), g(), b(), a() {}
     aiColor4t (TReal _r, TReal _g, TReal _b, TReal _a)
@@ -65,14 +66,12 @@ public:
     explicit aiColor4t (TReal _r) : r(_r), g(_r), b(_r), a(_r) {}
     aiColor4t (const aiColor4t& o) = default;
 
-public:
     // combined operators
     const aiColor4t& operator += (const aiColor4t& o);
     const aiColor4t& operator -= (const aiColor4t& o);
     const aiColor4t& operator *= (TReal f);
     const aiColor4t& operator /= (TReal f);
 
-public:
     // comparison
     bool operator == (const aiColor4t& other) const;
     bool operator != (const aiColor4t& other) const;
@@ -85,8 +84,6 @@ public:
     /** check whether a color is (close to) black */
     inline bool IsBlack() const;
 
-public:
-
     // Red, green, blue and alpha color values
     TReal r, g, b, a;
 };  // !struct aiColor4D
diff --git a/Engine/lib/assimp/include/assimp/color4.inl b/Engine/lib/assimp/include/assimp/color4.inl
index afa53dcb5..aed3de6f1 100644
--- a/Engine/lib/assimp/include/assimp/color4.inl
+++ b/Engine/lib/assimp/include/assimp/color4.inl
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -48,36 +46,61 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_COLOR4D_INL_INC
 #define AI_COLOR4D_INL_INC
 
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
 #ifdef __cplusplus
-#include "color4.h"
+#include <assimp/color4.h>
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator += (const aiColor4t<TReal>& o) {
-    r += o.r; g += o.g; b += o.b; a += o.a;
+AI_FORCE_INLINE
+const aiColor4t<TReal>& aiColor4t<TReal>::operator += (const aiColor4t<TReal>& o) {
+    r += o.r;
+    g += o.g;
+    b += o.b;
+    a += o.a;
+
     return *this;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator -= (const aiColor4t<TReal>& o) {
-    r -= o.r; g -= o.g; b -= o.b; a -= o.a;
+AI_FORCE_INLINE
+const aiColor4t<TReal>& aiColor4t<TReal>::operator -= (const aiColor4t<TReal>& o) {
+    r -= o.r;
+    g -= o.g;
+    b -= o.b;
+    a -= o.a;
+
     return *this;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator *= (TReal f) {
-    r *= f; g *= f; b *= f; a *= f;
+AI_FORCE_INLINE
+const aiColor4t<TReal>& aiColor4t<TReal>::operator *= (TReal f) {
+    r *= f;
+    g *= f;
+    b *= f;
+    a *= f;
+
     return *this;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator /= (TReal f) {
-    r /= f; g /= f; b /= f; a /= f;
+AI_FORCE_INLINE
+const aiColor4t<TReal>& aiColor4t<TReal>::operator /= (TReal f) {
+    r /= f;
+    g /= f;
+    b /= f;
+    a /= f;
+
     return *this;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE TReal aiColor4t<TReal>::operator[](unsigned int i) const {
+AI_FORCE_INLINE
+TReal aiColor4t<TReal>::operator[](unsigned int i) const {
     switch ( i ) {
         case 0:
             return r;
@@ -94,7 +117,8 @@ AI_FORCE_INLINE TReal aiColor4t<TReal>::operator[](unsigned int i) const {
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE TReal& aiColor4t<TReal>::operator[](unsigned int i) {
+AI_FORCE_INLINE
+TReal& aiColor4t<TReal>::operator[](unsigned int i) {
     switch ( i ) {
         case 0:
             return r;
@@ -111,17 +135,20 @@ AI_FORCE_INLINE TReal& aiColor4t<TReal>::operator[](unsigned int i) {
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE bool aiColor4t<TReal>::operator== (const aiColor4t<TReal>& other) const {
+AI_FORCE_INLINE
+bool aiColor4t<TReal>::operator== (const aiColor4t<TReal>& other) const {
     return r == other.r && g == other.g && b == other.b && a == other.a;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE bool aiColor4t<TReal>::operator!= (const aiColor4t<TReal>& other) const {
+AI_FORCE_INLINE
+bool aiColor4t<TReal>::operator!= (const aiColor4t<TReal>& other) const {
     return r != other.r || g != other.g || b != other.b || a != other.a;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE bool aiColor4t<TReal>::operator< (const aiColor4t<TReal>& other) const {
+AI_FORCE_INLINE
+bool aiColor4t<TReal>::operator< (const aiColor4t<TReal>& other) const {
     return r < other.r || (
         r == other.r && (
             g < other.g || (
@@ -136,14 +163,17 @@ AI_FORCE_INLINE bool aiColor4t<TReal>::operator< (const aiColor4t<TReal>& other)
         )
     );
 }
+
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE aiColor4t<TReal> operator + (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2)    {
+AI_FORCE_INLINE
+aiColor4t<TReal> operator + (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2)    {
     return aiColor4t<TReal>( v1.r + v2.r, v1.g + v2.g, v1.b + v2.b, v1.a + v2.a);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE aiColor4t<TReal> operator - (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2)    {
+AI_FORCE_INLINE
+aiColor4t<TReal> operator - (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2)    {
     return aiColor4t<TReal>( v1.r - v2.r, v1.g - v2.g, v1.b - v2.b, v1.a - v2.a);
 }
 // ------------------------------------------------------------------------------------------------
@@ -153,53 +183,63 @@ AI_FORCE_INLINE aiColor4t<TReal> operator * (const aiColor4t<TReal>& v1, const a
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE aiColor4t<TReal> operator / (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2)    {
+AI_FORCE_INLINE
+aiColor4t<TReal> operator / (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2)    {
     return aiColor4t<TReal>( v1.r / v2.r, v1.g / v2.g, v1.b / v2.b, v1.a / v2.a);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE aiColor4t<TReal> operator * ( TReal f, const aiColor4t<TReal>& v)   {
+AI_FORCE_INLINE
+aiColor4t<TReal> operator * ( TReal f, const aiColor4t<TReal>& v)   {
     return aiColor4t<TReal>( f*v.r, f*v.g, f*v.b, f*v.a);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE  aiColor4t<TReal> operator * ( const aiColor4t<TReal>& v, TReal f)  {
+AI_FORCE_INLINE
+aiColor4t<TReal> operator * ( const aiColor4t<TReal>& v, TReal f)  {
     return aiColor4t<TReal>( f*v.r, f*v.g, f*v.b, f*v.a);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE  aiColor4t<TReal> operator / ( const aiColor4t<TReal>& v, TReal f)  {
+AI_FORCE_INLINE
+aiColor4t<TReal> operator / ( const aiColor4t<TReal>& v, TReal f)  {
     return v * (1/f);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE  aiColor4t<TReal> operator / ( TReal f,const aiColor4t<TReal>& v)   {
+AI_FORCE_INLINE
+aiColor4t<TReal> operator / ( TReal f,const aiColor4t<TReal>& v)   {
     return aiColor4t<TReal>(f,f,f,f)/v;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE  aiColor4t<TReal> operator + ( const aiColor4t<TReal>& v, TReal f)  {
+AI_FORCE_INLINE
+aiColor4t<TReal> operator + ( const aiColor4t<TReal>& v, TReal f)  {
     return aiColor4t<TReal>( f+v.r, f+v.g, f+v.b, f+v.a);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE  aiColor4t<TReal> operator - ( const aiColor4t<TReal>& v, TReal f)  {
+AI_FORCE_INLINE
+aiColor4t<TReal> operator - ( const aiColor4t<TReal>& v, TReal f)  {
     return aiColor4t<TReal>( v.r-f, v.g-f, v.b-f, v.a-f);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE  aiColor4t<TReal> operator + ( TReal f, const aiColor4t<TReal>& v)  {
+AI_FORCE_INLINE
+aiColor4t<TReal> operator + ( TReal f, const aiColor4t<TReal>& v)  {
     return aiColor4t<TReal>( f+v.r, f+v.g, f+v.b, f+v.a);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE  aiColor4t<TReal> operator - ( TReal f, const aiColor4t<TReal>& v)  {
+AI_FORCE_INLINE
+aiColor4t<TReal> operator - ( TReal f, const aiColor4t<TReal>& v)  {
     return aiColor4t<TReal>( f-v.r, f-v.g, f-v.b, f-v.a);
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-inline bool aiColor4t<TReal> :: IsBlack() const {
+AI_FORCE_INLINE
+bool aiColor4t<TReal>::IsBlack() const {
     // The alpha component doesn't care here. black is black.
     static const TReal epsilon = 10e-3f;
     return std::fabs( r ) < epsilon && std::fabs( g ) < epsilon && std::fabs( b ) < epsilon;
diff --git a/Engine/lib/assimp/include/assimp/commonMetaData.h b/Engine/lib/assimp/include/assimp/commonMetaData.h
new file mode 100644
index 000000000..ccded585b
--- /dev/null
+++ b/Engine/lib/assimp/include/assimp/commonMetaData.h
@@ -0,0 +1,69 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file commonMetaData.h
+ *  @brief Defines a set of common scene metadata keys.
+ */
+#pragma once
+#ifndef AI_COMMONMETADATA_H_INC
+#define AI_COMMONMETADATA_H_INC
+
+#ifdef __GNUC__
+#pragma GCC system_header
+#endif
+
+/// Scene metadata holding the name of the importer which loaded the source asset.
+/// This is always present if the scene was created from an imported asset.
+#define AI_METADATA_SOURCE_FORMAT "SourceAsset_Format"
+
+/// Scene metadata holding the version of the source asset as a string, if available.
+/// Not all formats add this metadata.
+#define AI_METADATA_SOURCE_FORMAT_VERSION "SourceAsset_FormatVersion"
+
+/// Scene metadata holding the name of the software which generated the source asset, if available.
+/// Not all formats add this metadata.
+#define AI_METADATA_SOURCE_GENERATOR "SourceAsset_Generator"
+
+/// Scene metadata holding the source asset copyright statement, if available.
+/// Not all formats add this metadata.
+#define AI_METADATA_SOURCE_COPYRIGHT "SourceAsset_Copyright"
+
+#endif
diff --git a/Engine/lib/assimp/include/assimp/config.h b/Engine/lib/assimp/include/assimp/config.h
deleted file mode 100644
index 48d61941a..000000000
--- a/Engine/lib/assimp/include/assimp/config.h
+++ /dev/null
@@ -1,1018 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2018, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-/** @file config.h
- *  @brief Defines constants for configurable properties for the library
- *
- *  Typically these properties are set via
- *  #Assimp::Importer::SetPropertyFloat,
- *  #Assimp::Importer::SetPropertyInteger or
- *  #Assimp::Importer::SetPropertyString,
- *  depending on the data type of a property. All properties have a
- *  default value. See the doc for the mentioned methods for more details.
- *
- *  <br><br>
- *  The corresponding functions for use with the plain-c API are:
- *  #aiSetImportPropertyInteger,
- *  #aiSetImportPropertyFloat,
- *  #aiSetImportPropertyString
- */
-#pragma once
-#ifndef AI_CONFIG_H_INC
-#define AI_CONFIG_H_INC
-
-
-// ###########################################################################
-// LIBRARY SETTINGS
-// General, global settings
-// ###########################################################################
-
-// ---------------------------------------------------------------------------
-/** @brief Enables time measurements.
- *
- *  If enabled, measures the time needed for each part of the loading
- *  process (i.e. IO time, importing, postprocessing, ..) and dumps
- *  these timings to the DefaultLogger. See the @link perf Performance
- *  Page@endlink for more information on this topic.
- *
- * Property type: bool. Default value: false.
- */
-#define AI_CONFIG_GLOB_MEASURE_TIME  \
-    "GLOB_MEASURE_TIME"
-
-
-// ---------------------------------------------------------------------------
-/** @brief Global setting to disable generation of skeleton dummy meshes
- *
- * Skeleton dummy meshes are generated as a visualization aid in cases which
- * the input data contains no geometry, but only animation data.
- * Property data type: bool. Default value: false
- */
-// ---------------------------------------------------------------------------
-#define AI_CONFIG_IMPORT_NO_SKELETON_MESHES \
-    "IMPORT_NO_SKELETON_MESHES"
-
-
-
-# if 0 // not implemented yet
-// ---------------------------------------------------------------------------
-/** @brief Set Assimp's multithreading policy.
- *
- * This setting is ignored if Assimp was built without boost.thread
- * support (ASSIMP_BUILD_NO_THREADING, which is implied by ASSIMP_BUILD_BOOST_WORKAROUND).
- * Possible values are: -1 to let Assimp decide what to do, 0 to disable
- * multithreading entirely and any number larger than 0 to force a specific
- * number of threads. Assimp is always free to ignore this settings, which is
- * merely a hint. Usually, the default value (-1) will be fine. However, if
- * Assimp is used concurrently from multiple user threads, it might be useful
- * to limit each Importer instance to a specific number of cores.
- *
- * For more information, see the @link threading Threading page@endlink.
- * Property type: int, default value: -1.
- */
-#define AI_CONFIG_GLOB_MULTITHREADING  \
-    "GLOB_MULTITHREADING"
-#endif
-
-// ###########################################################################
-// POST PROCESSING SETTINGS
-// Various stuff to fine-tune the behavior of a specific post processing step.
-// ###########################################################################
-
-
-// ---------------------------------------------------------------------------
-/** @brief Maximum bone count per mesh for the SplitbyBoneCount step.
- *
- * Meshes are split until the maximum number of bones is reached. The default
- * value is AI_SBBC_DEFAULT_MAX_BONES, which may be altered at
- * compile-time.
- * Property data type: integer.
- */
-// ---------------------------------------------------------------------------
-#define AI_CONFIG_PP_SBBC_MAX_BONES \
-    "PP_SBBC_MAX_BONES"
-
-
-// default limit for bone count
-#if (!defined AI_SBBC_DEFAULT_MAX_BONES)
-#   define AI_SBBC_DEFAULT_MAX_BONES        60
-#endif
-
-
-// ---------------------------------------------------------------------------
-/** @brief  Specifies the maximum angle that may be between two vertex tangents
- *         that their tangents and bi-tangents are smoothed.
- *
- * This applies to the CalcTangentSpace-Step. The angle is specified
- * in degrees. The maximum value is 175.
- * Property type: float. Default value: 45 degrees
- */
-#define AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE \
-    "PP_CT_MAX_SMOOTHING_ANGLE"
-
-// ---------------------------------------------------------------------------
-/** @brief Source UV channel for tangent space computation.
- *
- * The specified channel must exist or an error will be raised.
- * Property type: integer. Default value: 0
- */
-// ---------------------------------------------------------------------------
-#define AI_CONFIG_PP_CT_TEXTURE_CHANNEL_INDEX \
-    "PP_CT_TEXTURE_CHANNEL_INDEX"
-
-// ---------------------------------------------------------------------------
-/** @brief  Specifies the maximum angle that may be between two face normals
- *          at the same vertex position that their are smoothed together.
- *
- * Sometimes referred to as 'crease angle'.
- * This applies to the GenSmoothNormals-Step. The angle is specified
- * in degrees, so 180 is PI. The default value is 175 degrees (all vertex
- * normals are smoothed). The maximum value is 175, too. Property type: float.
- * Warning: setting this option may cause a severe loss of performance. The
- * performance is unaffected if the #AI_CONFIG_FAVOUR_SPEED flag is set but
- * the output quality may be reduced.
- */
-#define AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE \
-    "PP_GSN_MAX_SMOOTHING_ANGLE"
-
-
-// ---------------------------------------------------------------------------
-/** @brief Sets the colormap (= palette) to be used to decode embedded
- *         textures in MDL (Quake or 3DGS) files.
- *
- * This must be a valid path to a file. The file is 768 (256*3) bytes
- * large and contains RGB triplets for each of the 256 palette entries.
- * The default value is colormap.lmp. If the file is not found,
- * a default palette (from Quake 1) is used.
- * Property type: string.
- */
-#define AI_CONFIG_IMPORT_MDL_COLORMAP       \
-    "IMPORT_MDL_COLORMAP"
-
-// ---------------------------------------------------------------------------
-/** @brief Configures the #aiProcess_RemoveRedundantMaterials step to
- *  keep materials matching a name in a given list.
- *
- * This is a list of 1 to n strings, ' ' serves as delimiter character.
- * Identifiers containing whitespaces must be enclosed in *single*
- * quotation marks. For example:<tt>
- * "keep-me and_me_to anotherMaterialToBeKept \'name with whitespace\'"</tt>.
- * If a material matches on of these names, it will not be modified or
- * removed by the postprocessing step nor will other materials be replaced
- * by a reference to it. <br>
- * This option might be useful if you are using some magic material names
- * to pass additional semantics through the content pipeline. This ensures
- * they won't be optimized away, but a general optimization is still
- * performed for materials not contained in the list.
- * Property type: String. Default value: n/a
- * @note Linefeeds, tabs or carriage returns are treated as whitespace.
- *   Material names are case sensitive.
- */
-#define AI_CONFIG_PP_RRM_EXCLUDE_LIST   \
-    "PP_RRM_EXCLUDE_LIST"
-
-// ---------------------------------------------------------------------------
-/** @brief Configures the #aiProcess_PreTransformVertices step to
- *  keep the scene hierarchy. Meshes are moved to worldspace, but
- *  no optimization is performed (read: meshes with equal materials are not
- *  joined. The total number of meshes won't change).
- *
- * This option could be of use for you if the scene hierarchy contains
- * important additional information which you intend to parse.
- * For rendering, you can still render all meshes in the scene without
- * any transformations.
- * Property type: bool. Default value: false.
- */
-#define AI_CONFIG_PP_PTV_KEEP_HIERARCHY     \
-    "PP_PTV_KEEP_HIERARCHY"
-
-// ---------------------------------------------------------------------------
-/** @brief Configures the #aiProcess_PreTransformVertices step to normalize
- *  all vertex components into the [-1,1] range. That is, a bounding box
- *  for the whole scene is computed, the maximum component is taken and all
- *  meshes are scaled appropriately (uniformly of course!).
- *  This might be useful if you don't know the spatial dimension of the input
- *  data*/
-#define AI_CONFIG_PP_PTV_NORMALIZE  \
-    "PP_PTV_NORMALIZE"
-
-// ---------------------------------------------------------------------------
-/** @brief Configures the #aiProcess_PreTransformVertices step to use
- *  a users defined matrix as the scene root node transformation before
- *  transforming vertices.
- *  Property type: bool. Default value: false.
- */
-#define AI_CONFIG_PP_PTV_ADD_ROOT_TRANSFORMATION    \
-    "PP_PTV_ADD_ROOT_TRANSFORMATION"
-
-// ---------------------------------------------------------------------------
-/** @brief Configures the #aiProcess_PreTransformVertices step to use
- *  a users defined matrix as the scene root node transformation before
- *  transforming vertices. This property correspond to the 'a1' component
- *  of the transformation matrix.
- *  Property type: aiMatrix4x4.
- */
-#define AI_CONFIG_PP_PTV_ROOT_TRANSFORMATION    \
-    "PP_PTV_ROOT_TRANSFORMATION"
-
-// ---------------------------------------------------------------------------
-/** @brief Configures the #aiProcess_FindDegenerates step to
- *  remove degenerated primitives from the import - immediately.
- *
- * The default behaviour converts degenerated triangles to lines and
- * degenerated lines to points. See the documentation to the
- * #aiProcess_FindDegenerates step for a detailed example of the various ways
- * to get rid of these lines and points if you don't want them.
- * Property type: bool. Default value: false.
- */
-#define AI_CONFIG_PP_FD_REMOVE \
-    "PP_FD_REMOVE"
-
-// ---------------------------------------------------------------------------
-/**
- *  @brief  Configures the #aiProcess_FindDegenerates to check the area of a
- *  trinagle to be greates than e-6. If this is not the case the triangle will
- *  be removed if #AI_CONFIG_PP_FD_REMOVE is set to true.
- */
-#define AI_CONFIG_PP_FD_CHECKAREA \
-    "PP_FD_CHECKAREA"
-
-// ---------------------------------------------------------------------------
-/** @brief Configures the #aiProcess_OptimizeGraph step to preserve nodes
- * matching a name in a given list.
- *
- * This is a list of 1 to n strings, ' ' serves as delimiter character.
- * Identifiers containing whitespaces must be enclosed in *single*
- * quotation marks. For example:<tt>
- * "keep-me and_me_to anotherNodeToBeKept \'name with whitespace\'"</tt>.
- * If a node matches on of these names, it will not be modified or
- * removed by the postprocessing step.<br>
- * This option might be useful if you are using some magic node names
- * to pass additional semantics through the content pipeline. This ensures
- * they won't be optimized away, but a general optimization is still
- * performed for nodes not contained in the list.
- * Property type: String. Default value: n/a
- * @note Linefeeds, tabs or carriage returns are treated as whitespace.
- *   Node names are case sensitive.
- */
-#define AI_CONFIG_PP_OG_EXCLUDE_LIST    \
-    "PP_OG_EXCLUDE_LIST"
-
-// ---------------------------------------------------------------------------
-/** @brief  Set the maximum number of triangles in a mesh.
- *
- * This is used by the "SplitLargeMeshes" PostProcess-Step to determine
- * whether a mesh must be split or not.
- * @note The default value is AI_SLM_DEFAULT_MAX_TRIANGLES
- * Property type: integer.
- */
-#define AI_CONFIG_PP_SLM_TRIANGLE_LIMIT \
-    "PP_SLM_TRIANGLE_LIMIT"
-
-// default value for AI_CONFIG_PP_SLM_TRIANGLE_LIMIT
-#if (!defined AI_SLM_DEFAULT_MAX_TRIANGLES)
-#   define AI_SLM_DEFAULT_MAX_TRIANGLES     1000000
-#endif
-
-// ---------------------------------------------------------------------------
-/** @brief  Set the maximum number of vertices in a mesh.
- *
- * This is used by the "SplitLargeMeshes" PostProcess-Step to determine
- * whether a mesh must be split or not.
- * @note The default value is AI_SLM_DEFAULT_MAX_VERTICES
- * Property type: integer.
- */
-#define AI_CONFIG_PP_SLM_VERTEX_LIMIT \
-    "PP_SLM_VERTEX_LIMIT"
-
-// default value for AI_CONFIG_PP_SLM_VERTEX_LIMIT
-#if (!defined AI_SLM_DEFAULT_MAX_VERTICES)
-#   define AI_SLM_DEFAULT_MAX_VERTICES      1000000
-#endif
-
-// ---------------------------------------------------------------------------
-/** @brief Set the maximum number of bones affecting a single vertex
- *
- * This is used by the #aiProcess_LimitBoneWeights PostProcess-Step.
- * @note The default value is AI_LMW_MAX_WEIGHTS
- * Property type: integer.*/
-#define AI_CONFIG_PP_LBW_MAX_WEIGHTS    \
-    "PP_LBW_MAX_WEIGHTS"
-
-// default value for AI_CONFIG_PP_LBW_MAX_WEIGHTS
-#if (!defined AI_LMW_MAX_WEIGHTS)
-#   define AI_LMW_MAX_WEIGHTS   0x4
-#endif // !! AI_LMW_MAX_WEIGHTS
-
-// ---------------------------------------------------------------------------
-/** @brief Lower the deboning threshold in order to remove more bones.
- *
- * This is used by the #aiProcess_Debone PostProcess-Step.
- * @note The default value is AI_DEBONE_THRESHOLD
- * Property type: float.*/
-#define AI_CONFIG_PP_DB_THRESHOLD \
-    "PP_DB_THRESHOLD"
-
-// default value for AI_CONFIG_PP_LBW_MAX_WEIGHTS
-#if (!defined AI_DEBONE_THRESHOLD)
-#   define AI_DEBONE_THRESHOLD  1.0f
-#endif // !! AI_DEBONE_THRESHOLD
-
-// ---------------------------------------------------------------------------
-/** @brief Require all bones qualify for deboning before removing any
- *
- * This is used by the #aiProcess_Debone PostProcess-Step.
- * @note The default value is 0
- * Property type: bool.*/
-#define AI_CONFIG_PP_DB_ALL_OR_NONE \
-    "PP_DB_ALL_OR_NONE"
-
-/** @brief Default value for the #AI_CONFIG_PP_ICL_PTCACHE_SIZE property
- */
-#ifndef PP_ICL_PTCACHE_SIZE
-#   define PP_ICL_PTCACHE_SIZE 12
-#endif
-
-// ---------------------------------------------------------------------------
-/** @brief Set the size of the post-transform vertex cache to optimize the
- *    vertices for. This configures the #aiProcess_ImproveCacheLocality step.
- *
- * The size is given in vertices. Of course you can't know how the vertex
- * format will exactly look like after the import returns, but you can still
- * guess what your meshes will probably have.
- * @note The default value is #PP_ICL_PTCACHE_SIZE. That results in slight
- * performance improvements for most nVidia/AMD cards since 2002.
- * Property type: integer.
- */
-#define AI_CONFIG_PP_ICL_PTCACHE_SIZE   "PP_ICL_PTCACHE_SIZE"
-
-// ---------------------------------------------------------------------------
-/** @brief Enumerates components of the aiScene and aiMesh data structures
- *  that can be excluded from the import using the #aiProcess_RemoveComponent step.
- *
- *  See the documentation to #aiProcess_RemoveComponent for more details.
- */
-enum aiComponent
-{
-    /** Normal vectors */
-#ifdef SWIG
-    aiComponent_NORMALS = 0x2,
-#else
-    aiComponent_NORMALS = 0x2u,
-#endif
-
-    /** Tangents and bitangents go always together ... */
-#ifdef SWIG
-    aiComponent_TANGENTS_AND_BITANGENTS = 0x4,
-#else
-    aiComponent_TANGENTS_AND_BITANGENTS = 0x4u,
-#endif
-
-    /** ALL color sets
-     * Use aiComponent_COLORn(N) to specify the N'th set */
-    aiComponent_COLORS = 0x8,
-
-    /** ALL texture UV sets
-     * aiComponent_TEXCOORDn(N) to specify the N'th set  */
-    aiComponent_TEXCOORDS = 0x10,
-
-    /** Removes all bone weights from all meshes.
-     * The scenegraph nodes corresponding to the bones are NOT removed.
-     * use the #aiProcess_OptimizeGraph step to do this */
-    aiComponent_BONEWEIGHTS = 0x20,
-
-    /** Removes all node animations (aiScene::mAnimations).
-     * The corresponding scenegraph nodes are NOT removed.
-     * use the #aiProcess_OptimizeGraph step to do this */
-    aiComponent_ANIMATIONS = 0x40,
-
-    /** Removes all embedded textures (aiScene::mTextures) */
-    aiComponent_TEXTURES = 0x80,
-
-    /** Removes all light sources (aiScene::mLights).
-     * The corresponding scenegraph nodes are NOT removed.
-     * use the #aiProcess_OptimizeGraph step to do this */
-    aiComponent_LIGHTS = 0x100,
-
-    /** Removes all cameras (aiScene::mCameras).
-     * The corresponding scenegraph nodes are NOT removed.
-     * use the #aiProcess_OptimizeGraph step to do this */
-    aiComponent_CAMERAS = 0x200,
-
-    /** Removes all meshes (aiScene::mMeshes). */
-    aiComponent_MESHES = 0x400,
-
-    /** Removes all materials. One default material will
-     * be generated, so aiScene::mNumMaterials will be 1. */
-    aiComponent_MATERIALS = 0x800,
-
-
-    /** This value is not used. It is just there to force the
-     *  compiler to map this enum to a 32 Bit integer. */
-#ifndef SWIG
-    _aiComponent_Force32Bit = 0x9fffffff
-#endif
-};
-
-// Remove a specific color channel 'n'
-#define aiComponent_COLORSn(n) (1u << (n+20u))
-
-// Remove a specific UV channel 'n'
-#define aiComponent_TEXCOORDSn(n) (1u << (n+25u))
-
-// ---------------------------------------------------------------------------
-/** @brief Input parameter to the #aiProcess_RemoveComponent step:
- *  Specifies the parts of the data structure to be removed.
- *
- * See the documentation to this step for further details. The property
- * is expected to be an integer, a bitwise combination of the
- * #aiComponent flags defined above in this header. The default
- * value is 0. Important: if no valid mesh is remaining after the
- * step has been executed (e.g you thought it was funny to specify ALL
- * of the flags defined above) the import FAILS. Mainly because there is
- * no data to work on anymore ...
- */
-#define AI_CONFIG_PP_RVC_FLAGS              \
-    "PP_RVC_FLAGS"
-
-// ---------------------------------------------------------------------------
-/** @brief Input parameter to the #aiProcess_SortByPType step:
- *  Specifies which primitive types are removed by the step.
- *
- *  This is a bitwise combination of the aiPrimitiveType flags.
- *  Specifying all of them is illegal, of course. A typical use would
- *  be to exclude all line and point meshes from the import. This
- *  is an integer property, its default value is 0.
- */
-#define AI_CONFIG_PP_SBP_REMOVE             \
-    "PP_SBP_REMOVE"
-
-// ---------------------------------------------------------------------------
-/** @brief Input parameter to the #aiProcess_FindInvalidData step:
- *  Specifies the floating-point accuracy for animation values. The step
- *  checks for animation tracks where all frame values are absolutely equal
- *  and removes them. This tweakable controls the epsilon for floating-point
- *  comparisons - two keys are considered equal if the invariant
- *  abs(n0-n1)>epsilon holds true for all vector respectively quaternion
- *  components. The default value is 0.f - comparisons are exact then.
- */
-#define AI_CONFIG_PP_FID_ANIM_ACCURACY              \
-    "PP_FID_ANIM_ACCURACY"
-
-// ---------------------------------------------------------------------------
-/** @brief Input parameter to the #aiProcess_FindInvalidData step:
- *  Set to true to ignore texture coordinates. This may be useful if you have
- *  to assign different kind of textures like one for the summer or one for the winter.
- */
-#define AI_CONFIG_PP_FID_IGNORE_TEXTURECOORDS        \
-    "PP_FID_IGNORE_TEXTURECOORDS"
-
-// TransformUVCoords evaluates UV scalings
-#define AI_UVTRAFO_SCALING 0x1
-
-// TransformUVCoords evaluates UV rotations
-#define AI_UVTRAFO_ROTATION 0x2
-
-// TransformUVCoords evaluates UV translation
-#define AI_UVTRAFO_TRANSLATION 0x4
-
-// Everything baked together -> default value
-#define AI_UVTRAFO_ALL (AI_UVTRAFO_SCALING | AI_UVTRAFO_ROTATION | AI_UVTRAFO_TRANSLATION)
-
-// ---------------------------------------------------------------------------
-/** @brief Input parameter to the #aiProcess_TransformUVCoords step:
- *  Specifies which UV transformations are evaluated.
- *
- *  This is a bitwise combination of the AI_UVTRAFO_XXX flags (integer
- *  property, of course). By default all transformations are enabled
- * (AI_UVTRAFO_ALL).
- */
-#define AI_CONFIG_PP_TUV_EVALUATE               \
-    "PP_TUV_EVALUATE"
-
-// ---------------------------------------------------------------------------
-/** @brief A hint to assimp to favour speed against import quality.
- *
- * Enabling this option may result in faster loading, but it needn't.
- * It represents just a hint to loaders and post-processing steps to use
- * faster code paths, if possible.
- * This property is expected to be an integer, != 0 stands for true.
- * The default value is 0.
- */
-#define AI_CONFIG_FAVOUR_SPEED              \
- "FAVOUR_SPEED"
-
-
-// ###########################################################################
-// IMPORTER SETTINGS
-// Various stuff to fine-tune the behaviour of specific importer plugins.
-// ###########################################################################
-
-
-// ---------------------------------------------------------------------------
-/** @brief Set whether the fbx importer will merge all geometry layers present
- *    in the source file or take only the first.
- *
- * The default value is true (1)
- * Property type: bool
- */
-#define AI_CONFIG_IMPORT_FBX_READ_ALL_GEOMETRY_LAYERS \
-    "IMPORT_FBX_READ_ALL_GEOMETRY_LAYERS"
-
-// ---------------------------------------------------------------------------
-/** @brief Set whether the fbx importer will read all materials present in the
- *    source file or take only the referenced materials.
- *
- * This is void unless IMPORT_FBX_READ_MATERIALS=1.
- *
- * The default value is false (0)
- * Property type: bool
- */
-#define AI_CONFIG_IMPORT_FBX_READ_ALL_MATERIALS \
-    "IMPORT_FBX_READ_ALL_MATERIALS"
-
-// ---------------------------------------------------------------------------
-/** @brief Set whether the fbx importer will read materials.
- *
- * The default value is true (1)
- * Property type: bool
- */
-#define AI_CONFIG_IMPORT_FBX_READ_MATERIALS \
-    "IMPORT_FBX_READ_MATERIALS"
-
-// ---------------------------------------------------------------------------
-/** @brief Set whether the fbx importer will read embedded textures.
- *
- * The default value is true (1)
- * Property type: bool
- */
-#define AI_CONFIG_IMPORT_FBX_READ_TEXTURES \
-    "IMPORT_FBX_READ_TEXTURES"
-
-// ---------------------------------------------------------------------------
-/** @brief Set whether the fbx importer will read cameras.
- *
- * The default value is true (1)
- * Property type: bool
- */
-#define AI_CONFIG_IMPORT_FBX_READ_CAMERAS \
-    "IMPORT_FBX_READ_CAMERAS"
-
-// ---------------------------------------------------------------------------
-/** @brief Set whether the fbx importer will read light sources.
- *
- * The default value is true (1)
- * Property type: bool
- */
-#define AI_CONFIG_IMPORT_FBX_READ_LIGHTS \
-    "IMPORT_FBX_READ_LIGHTS"
-
-// ---------------------------------------------------------------------------
-/** @brief Set whether the fbx importer will read animations.
- *
- * The default value is true (1)
- * Property type: bool
- */
-#define AI_CONFIG_IMPORT_FBX_READ_ANIMATIONS \
-    "IMPORT_FBX_READ_ANIMATIONS"
-
-// ---------------------------------------------------------------------------
-/** @brief Set whether the fbx importer will act in strict mode in which only
- *    FBX 2013 is supported and any other sub formats are rejected. FBX 2013
- *    is the primary target for the importer, so this format is best
- *    supported and well-tested.
- *
- * The default value is false (0)
- * Property type: bool
- */
-#define AI_CONFIG_IMPORT_FBX_STRICT_MODE \
-    "IMPORT_FBX_STRICT_MODE"
-
-// ---------------------------------------------------------------------------
-/** @brief Set whether the fbx importer will preserve pivot points for
- *    transformations (as extra nodes). If set to false, pivots and offsets
- *    will be evaluated whenever possible.
- *
- * The default value is true (1)
- * Property type: bool
- */
-#define AI_CONFIG_IMPORT_FBX_PRESERVE_PIVOTS \
-    "IMPORT_FBX_PRESERVE_PIVOTS"
-
-// ---------------------------------------------------------------------------
-/** @brief Specifies whether the importer will drop empty animation curves or
- *    animation curves which match the bind pose transformation over their
- *    entire defined range.
- *
- * The default value is true (1)
- * Property type: bool
- */
-#define AI_CONFIG_IMPORT_FBX_OPTIMIZE_EMPTY_ANIMATION_CURVES \
-    "IMPORT_FBX_OPTIMIZE_EMPTY_ANIMATION_CURVES"
-
-// ---------------------------------------------------------------------------
-/** @brief Set whether the fbx importer will use the legacy embedded texture naming.
- *
- * The default value is false (0)
- * Property type: bool
- */
-#define AI_CONFIG_IMPORT_FBX_EMBEDDED_TEXTURES_LEGACY_NAMING \
-	"AI_CONFIG_IMPORT_FBX_EMBEDDED_TEXTURES_LEGACY_NAMING"
-
-// ---------------------------------------------------------------------------
-/** @brief  Set wether the importer shall not remove empty bones.
- *  
- *  Empty bone are often used to define connections for other models.
- */
-#define AI_CONFIG_IMPORT_REMOVE_EMPTY_BONES \
-    "AI_CONFIG_IMPORT_REMOVE_EMPTY_BONES"
-
-
-// ---------------------------------------------------------------------------
-/** @brief  Set wether the FBX importer shall convert the unit from cm to m.
- */
-#define AI_CONFIG_FBX_CONVERT_TO_M \
-    "AI_CONFIG_FBX_CONVERT_TO_M"
-
-// ---------------------------------------------------------------------------
-/** @brief  Set the vertex animation keyframe to be imported
- *
- * ASSIMP does not support vertex keyframes (only bone animation is supported).
- * The library reads only one frame of models with vertex animations.
- * By default this is the first frame.
- * \note The default value is 0. This option applies to all importers.
- *   However, it is also possible to override the global setting
- *   for a specific loader. You can use the AI_CONFIG_IMPORT_XXX_KEYFRAME
- *   options (where XXX is a placeholder for the file format for which you
- *   want to override the global setting).
- * Property type: integer.
- */
-#define AI_CONFIG_IMPORT_GLOBAL_KEYFRAME    "IMPORT_GLOBAL_KEYFRAME"
-
-#define AI_CONFIG_IMPORT_MD3_KEYFRAME       "IMPORT_MD3_KEYFRAME"
-#define AI_CONFIG_IMPORT_MD2_KEYFRAME       "IMPORT_MD2_KEYFRAME"
-#define AI_CONFIG_IMPORT_MDL_KEYFRAME       "IMPORT_MDL_KEYFRAME"
-#define AI_CONFIG_IMPORT_MDC_KEYFRAME       "IMPORT_MDC_KEYFRAME"
-#define AI_CONFIG_IMPORT_SMD_KEYFRAME       "IMPORT_SMD_KEYFRAME"
-#define AI_CONFIG_IMPORT_UNREAL_KEYFRAME    "IMPORT_UNREAL_KEYFRAME"
-
-// ---------------------------------------------------------------------------
-/** Smd load multiple animations
- *
- *  Property type: bool. Default value: true.
- */
-#define AI_CONFIG_IMPORT_SMD_LOAD_ANIMATION_LIST "IMPORT_SMD_LOAD_ANIMATION_LIST"
-
-// ---------------------------------------------------------------------------
-/** @brief  Configures the AC loader to collect all surfaces which have the
- *    "Backface cull" flag set in separate meshes.
- *
- *  Property type: bool. Default value: true.
- */
-#define AI_CONFIG_IMPORT_AC_SEPARATE_BFCULL \
-    "IMPORT_AC_SEPARATE_BFCULL"
-
-// ---------------------------------------------------------------------------
-/** @brief  Configures whether the AC loader evaluates subdivision surfaces (
- *  indicated by the presence of the 'subdiv' attribute in the file). By
- *  default, Assimp performs the subdivision using the standard
- *  Catmull-Clark algorithm
- *
- * * Property type: bool. Default value: true.
- */
-#define AI_CONFIG_IMPORT_AC_EVAL_SUBDIVISION    \
-    "IMPORT_AC_EVAL_SUBDIVISION"
-
-// ---------------------------------------------------------------------------
-/** @brief  Configures the UNREAL 3D loader to separate faces with different
- *    surface flags (e.g. two-sided vs. single-sided).
- *
- * * Property type: bool. Default value: true.
- */
-#define AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS \
-    "UNREAL_HANDLE_FLAGS"
-
-// ---------------------------------------------------------------------------
-/** @brief Configures the terragen import plugin to compute uv's for
- *  terrains, if not given. Furthermore a default texture is assigned.
- *
- * UV coordinates for terrains are so simple to compute that you'll usually
- * want to compute them on your own, if you need them. This option is intended
- * for model viewers which want to offer an easy way to apply textures to
- * terrains.
- * * Property type: bool. Default value: false.
- */
-#define AI_CONFIG_IMPORT_TER_MAKE_UVS \
-    "IMPORT_TER_MAKE_UVS"
-
-// ---------------------------------------------------------------------------
-/** @brief  Configures the ASE loader to always reconstruct normal vectors
- *  basing on the smoothing groups loaded from the file.
- *
- * Some ASE files have carry invalid normals, other don't.
- * * Property type: bool. Default value: true.
- */
-#define AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS    \
-    "IMPORT_ASE_RECONSTRUCT_NORMALS"
-
-// ---------------------------------------------------------------------------
-/** @brief  Configures the M3D loader to detect and process multi-part
- *    Quake player models.
- *
- * These models usually consist of 3 files, lower.md3, upper.md3 and
- * head.md3. If this property is set to true, Assimp will try to load and
- * combine all three files if one of them is loaded.
- * Property type: bool. Default value: true.
- */
-#define AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART \
-    "IMPORT_MD3_HANDLE_MULTIPART"
-
-// ---------------------------------------------------------------------------
-/** @brief  Tells the MD3 loader which skin files to load.
- *
- * When loading MD3 files, Assimp checks whether a file
- * [md3_file_name]_[skin_name].skin is existing. These files are used by
- * Quake III to be able to assign different skins (e.g. red and blue team)
- * to models. 'default', 'red', 'blue' are typical skin names.
- * Property type: String. Default value: "default".
- */
-#define AI_CONFIG_IMPORT_MD3_SKIN_NAME \
-    "IMPORT_MD3_SKIN_NAME"
-
-// ---------------------------------------------------------------------------
-/** @brief  Specify the Quake 3 shader file to be used for a particular
- *  MD3 file. This can also be a search path.
- *
- * By default Assimp's behaviour is as follows: If a MD3 file
- * <tt>any_path/models/any_q3_subdir/model_name/file_name.md3</tt> is
- * loaded, the library tries to locate the corresponding shader file in
- * <tt>any_path/scripts/model_name.shader</tt>. This property overrides this
- * behaviour. It can either specify a full path to the shader to be loaded
- * or alternatively the path (relative or absolute) to the directory where
- * the shaders for all MD3s to be loaded reside. Assimp attempts to open
- * <tt>IMPORT_MD3_SHADER_SRC/model_name.shader</tt> first, <tt>IMPORT_MD3_SHADER_SRC/file_name.shader</tt>
- * is the fallback file. Note that IMPORT_MD3_SHADER_SRC should have a terminal (back)slash.
- * Property type: String. Default value: n/a.
- */
-#define AI_CONFIG_IMPORT_MD3_SHADER_SRC \
-    "IMPORT_MD3_SHADER_SRC"
-
-// ---------------------------------------------------------------------------
-/** @brief  Configures the LWO loader to load just one layer from the model.
- *
- * LWO files consist of layers and in some cases it could be useful to load
- * only one of them. This property can be either a string - which specifies
- * the name of the layer - or an integer - the index of the layer. If the
- * property is not set the whole LWO model is loaded. Loading fails if the
- * requested layer is not available. The layer index is zero-based and the
- * layer name may not be empty.<br>
- * Property type: Integer. Default value: all layers are loaded.
- */
-#define AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY         \
-    "IMPORT_LWO_ONE_LAYER_ONLY"
-
-// ---------------------------------------------------------------------------
-/** @brief  Configures the MD5 loader to not load the MD5ANIM file for
- *  a MD5MESH file automatically.
- *
- * The default strategy is to look for a file with the same name but the
- * MD5ANIM extension in the same directory. If it is found, it is loaded
- * and combined with the MD5MESH file. This configuration option can be
- * used to disable this behaviour.
- *
- * * Property type: bool. Default value: false.
- */
-#define AI_CONFIG_IMPORT_MD5_NO_ANIM_AUTOLOAD           \
-    "IMPORT_MD5_NO_ANIM_AUTOLOAD"
-
-// ---------------------------------------------------------------------------
-/** @brief Defines the begin of the time range for which the LWS loader
- *    evaluates animations and computes aiNodeAnim's.
- *
- * Assimp provides full conversion of LightWave's envelope system, including
- * pre and post conditions. The loader computes linearly subsampled animation
- * chanels with the frame rate given in the LWS file. This property defines
- * the start time. Note: animation channels are only generated if a node
- * has at least one envelope with more tan one key assigned. This property.
- * is given in frames, '0' is the first frame. By default, if this property
- * is not set, the importer takes the animation start from the input LWS
- * file ('FirstFrame' line)<br>
- * Property type: Integer. Default value: taken from file.
- *
- * @see AI_CONFIG_IMPORT_LWS_ANIM_END - end of the imported time range
- */
-#define AI_CONFIG_IMPORT_LWS_ANIM_START         \
-    "IMPORT_LWS_ANIM_START"
-#define AI_CONFIG_IMPORT_LWS_ANIM_END           \
-    "IMPORT_LWS_ANIM_END"
-
-// ---------------------------------------------------------------------------
-/** @brief Defines the output frame rate of the IRR loader.
- *
- * IRR animations are difficult to convert for Assimp and there will
- * always be a loss of quality. This setting defines how many keys per second
- * are returned by the converter.<br>
- * Property type: integer. Default value: 100
- */
-#define AI_CONFIG_IMPORT_IRR_ANIM_FPS               \
-    "IMPORT_IRR_ANIM_FPS"
-
-// ---------------------------------------------------------------------------
-/** @brief Ogre Importer will try to find referenced materials from this file.
- *
- * Ogre meshes reference with material names, this does not tell Assimp the file
- * where it is located in. Assimp will try to find the source file in the following
- * order: <material-name>.material, <mesh-filename-base>.material and
- * lastly the material name defined by this config property.
- * <br>
- * Property type: String. Default value: Scene.material.
- */
-#define AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE \
-    "IMPORT_OGRE_MATERIAL_FILE"
-
-// ---------------------------------------------------------------------------
-/** @brief Ogre Importer detect the texture usage from its filename.
- *
- * Ogre material texture units do not define texture type, the textures usage
- * depends on the used shader or Ogre's fixed pipeline. If this config property
- * is true Assimp will try to detect the type from the textures filename postfix:
- * _n, _nrm, _nrml, _normal, _normals and _normalmap for normal map, _s, _spec,
- * _specular and _specularmap for specular map, _l, _light, _lightmap, _occ
- * and _occlusion for light map, _disp and _displacement for displacement map.
- * The matching is case insensitive. Post fix is taken between the last
- * underscore and the last period.
- * Default behavior is to detect type from lower cased texture unit name by
- * matching against: normalmap, specularmap, lightmap and displacementmap.
- * For both cases if no match is found aiTextureType_DIFFUSE is used.
- * <br>
- * Property type: Bool. Default value: false.
- */
-#define AI_CONFIG_IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME \
-    "IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME"
-
- /** @brief Specifies whether the Android JNI asset extraction is supported.
-  *
-  * Turn on this option if you want to manage assets in native
-  * Android application without having to keep the internal directory and asset
-  * manager pointer.
-  */
- #define AI_CONFIG_ANDROID_JNI_ASSIMP_MANAGER_SUPPORT "AI_CONFIG_ANDROID_JNI_ASSIMP_MANAGER_SUPPORT"
-
-// ---------------------------------------------------------------------------
-/** @brief Specifies whether the IFC loader skips over IfcSpace elements.
- *
- * IfcSpace elements (and their geometric representations) are used to
- * represent, well, free space in a building storey.<br>
- * Property type: Bool. Default value: true.
- */
-#define AI_CONFIG_IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS "IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS"
-
-// ---------------------------------------------------------------------------
-/** @brief Specifies whether the IFC loader will use its own, custom triangulation
- *   algorithm to triangulate wall and floor meshes.
- *
- * If this property is set to false, walls will be either triangulated by
- * #aiProcess_Triangulate or will be passed through as huge polygons with
- * faked holes (i.e. holes that are connected with the outer boundary using
- * a dummy edge). It is highly recommended to set this property to true
- * if you want triangulated data because #aiProcess_Triangulate is known to
- * have problems with the kind of polygons that the IFC loader spits out for
- * complicated meshes.
- * Property type: Bool. Default value: true.
- */
-#define AI_CONFIG_IMPORT_IFC_CUSTOM_TRIANGULATION "IMPORT_IFC_CUSTOM_TRIANGULATION"
-
-// ---------------------------------------------------------------------------
-/** @brief  Set the tessellation conic angle for IFC smoothing curves.
- *
- * This is used by the IFC importer to determine the tessellation parameter
- * for smoothing curves.
- * @note The default value is AI_IMPORT_IFC_DEFAULT_SMOOTHING_ANGLE and the
- * accepted values are in range [5.0, 120.0].
- * Property type: Float.
- */
-#define AI_CONFIG_IMPORT_IFC_SMOOTHING_ANGLE "IMPORT_IFC_SMOOTHING_ANGLE"
-
-// default value for AI_CONFIG_IMPORT_IFC_SMOOTHING_ANGLE
-#if (!defined AI_IMPORT_IFC_DEFAULT_SMOOTHING_ANGLE)
-#   define AI_IMPORT_IFC_DEFAULT_SMOOTHING_ANGLE 10.0f
-#endif
-
-// ---------------------------------------------------------------------------
-/** @brief  Set the tessellation for IFC cylindrical shapes.
- *
- * This is used by the IFC importer to determine the tessellation parameter
- * for cylindrical shapes, i.e. the number of segments used to approximate a circle.
- * @note The default value is AI_IMPORT_IFC_DEFAULT_CYLINDRICAL_TESSELLATION and the
- * accepted values are in range [3, 180].
- * Property type: Integer.
- */
-#define AI_CONFIG_IMPORT_IFC_CYLINDRICAL_TESSELLATION "IMPORT_IFC_CYLINDRICAL_TESSELLATION"
-
-// default value for AI_CONFIG_IMPORT_IFC_CYLINDRICAL_TESSELLATION
-#if (!defined AI_IMPORT_IFC_DEFAULT_CYLINDRICAL_TESSELLATION)
-#   define AI_IMPORT_IFC_DEFAULT_CYLINDRICAL_TESSELLATION 32
-#endif
-
-// ---------------------------------------------------------------------------
-/** @brief Specifies whether the Collada loader will ignore the provided up direction.
- *
- * If this property is set to true, the up direction provided in the file header will
- * be ignored and the file will be loaded as is.
- * Property type: Bool. Default value: false.
- */
-#define AI_CONFIG_IMPORT_COLLADA_IGNORE_UP_DIRECTION "IMPORT_COLLADA_IGNORE_UP_DIRECTION"
-
-// ---------------------------------------------------------------------------
-/** @brief Specifies whether the Collada loader should use Collada names as node names.
- *
- * If this property is set to true, the Collada names will be used as the
- * node name. The default is to use the id tag (resp. sid tag, if no id tag is present)
- * instead.
- * Property type: Bool. Default value: false.
- */
-#define AI_CONFIG_IMPORT_COLLADA_USE_COLLADA_NAMES "IMPORT_COLLADA_USE_COLLADA_NAMES"
-
-// ---------- All the Export defines ------------
-
-/** @brief Specifies the xfile use double for real values of float
- *
- * Property type: Bool. Default value: false.
- */
-
-#define AI_CONFIG_EXPORT_XFILE_64BIT "EXPORT_XFILE_64BIT"
-
-/** @brief Specifies whether the assimp export shall be able to export point clouds
- * 
- *  When this flag is not defined the render data has to contain valid faces.
- *  Point clouds are only a collection of vertices which have nor spatial organization
- *  by a face and the validation process will remove them. Enabling this feature will
- *  switch off the flag and enable the functionality to export pure point clouds.
- */
-#define AI_CONFIG_EXPORT_POINT_CLOUDS "EXPORT_POINT_CLOUDS"
-
-/**
- *  @brief  Specifies a gobal key factor for scale, float value
- */
-#define AI_CONFIG_GLOBAL_SCALE_FACTOR_KEY "GLOBAL_SCALE_FACTOR"
-
-#if (!defined AI_CONFIG_GLOBAL_SCALE_FACTOR_DEFAULT)
-#   define AI_CONFIG_GLOBAL_SCALE_FACTOR_DEFAULT  1.0f
-#endif // !! AI_DEBONE_THRESHOLD
-
-#define AI_CONFIG_APP_SCALE_KEY "APP_SCALE_FACTOR"
-
-#if (!defined AI_CONFIG_APP_SCALE_KEY)
-#   define AI_CONFIG_APP_SCALE_KEY 1.0
-#endif // AI_CONFIG_APP_SCALE_KEY
-
-
-// ---------- All the Build/Compile-time defines ------------
-
-/** @brief Specifies if double precision is supported inside assimp
- *
- * Property type: Bool. Default value: undefined.
- */
-
-/* #undef ASSIMP_DOUBLE_PRECISION */
-
-#endif // !! AI_CONFIG_H_INC
diff --git a/Engine/lib/assimp/include/assimp/config.h.in b/Engine/lib/assimp/include/assimp/config.h.in
index 3a6379bf4..bf0076572 100644
--- a/Engine/lib/assimp/include/assimp/config.h.in
+++ b/Engine/lib/assimp/include/assimp/config.h.in
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2018, assimp team
+Copyright (c) 2006-2020, assimp team
 
 
 All rights reserved.
@@ -547,6 +547,15 @@ enum aiComponent
 // Various stuff to fine-tune the behaviour of specific importer plugins.
 // ###########################################################################
 
+// ---------------------------------------------------------------------------
+/** @brief Importers which parse JSON may use this to obtain a pointer to a
+ * rapidjson::IRemoteSchemaDocumentProvider.
+ *
+ * The default value is nullptr
+ * Property type: void*
+ */
+#define AI_CONFIG_IMPORT_SCHEMA_DOCUMENT_PROVIDER \
+    "IMPORT_SCHEMA_DOCUMENT_PROVIDER"
 
 // ---------------------------------------------------------------------------
 /** @brief Set whether the fbx importer will merge all geometry layers present
@@ -615,6 +624,15 @@ enum aiComponent
 #define AI_CONFIG_IMPORT_FBX_READ_ANIMATIONS \
     "IMPORT_FBX_READ_ANIMATIONS"
 
+// ---------------------------------------------------------------------------
+/** @brief Set whether the fbx importer will read weights.
+ *
+ * The default value is true (1)
+ * Property type: bool
+ */
+#define AI_CONFIG_IMPORT_FBX_READ_WEIGHTS \
+    "IMPORT_FBX_READ_WEIGHTS"
+
 // ---------------------------------------------------------------------------
 /** @brief Set whether the fbx importer will act in strict mode in which only
  *    FBX 2013 is supported and any other sub formats are rejected. FBX 2013
@@ -660,7 +678,7 @@ enum aiComponent
 
 // ---------------------------------------------------------------------------
 /** @brief  Set wether the importer shall not remove empty bones.
- *  
+ *
  *  Empty bone are often used to define connections for other models.
  */
 #define AI_CONFIG_IMPORT_REMOVE_EMPTY_BONES \
@@ -695,6 +713,73 @@ enum aiComponent
 #define AI_CONFIG_IMPORT_SMD_KEYFRAME       "IMPORT_SMD_KEYFRAME"
 #define AI_CONFIG_IMPORT_UNREAL_KEYFRAME    "IMPORT_UNREAL_KEYFRAME"
 
+// ---------------------------------------------------------------------------
+/** @brief Set whether the MDL (HL1) importer will read animations.
+ *
+ * The default value is true (1)
+ * Property type: bool
+ */
+#define AI_CONFIG_IMPORT_MDL_HL1_READ_ANIMATIONS "IMPORT_MDL_HL1_READ_ANIMATIONS"
+
+// ---------------------------------------------------------------------------
+/** @brief Set whether the MDL (HL1) importer will read animation events.
+ * \note This property requires AI_CONFIG_IMPORT_MDL_HL1_READ_ANIMATIONS to be set to true.
+ *
+ * The default value is true (1)
+ * Property type: bool
+ */
+#define AI_CONFIG_IMPORT_MDL_HL1_READ_ANIMATION_EVENTS "IMPORT_MDL_HL1_READ_ANIMATION_EVENTS"
+
+// ---------------------------------------------------------------------------
+/** @brief Set whether the MDL (HL1) importer will read blend controllers.
+ * \note This property requires AI_CONFIG_IMPORT_MDL_HL1_READ_ANIMATIONS to be set to true.
+ *
+ * The default value is true (1)
+ * Property type: bool
+ */
+#define AI_CONFIG_IMPORT_MDL_HL1_READ_BLEND_CONTROLLERS "IMPORT_MDL_HL1_READ_BLEND_CONTROLLERS"
+
+// ---------------------------------------------------------------------------
+/** @brief Set whether the MDL (HL1) importer will read sequence transition graph.
+ * \note This property requires AI_CONFIG_IMPORT_MDL_HL1_READ_ANIMATIONS to be set to true.
+ *
+ * The default value is true (1)
+ * Property type: bool
+ */
+#define AI_CONFIG_IMPORT_MDL_HL1_READ_SEQUENCE_TRANSITIONS "IMPORT_MDL_HL1_READ_SEQUENCE_TRANSITIONS"
+
+// ---------------------------------------------------------------------------
+/** @brief Set whether the MDL (HL1) importer will read attachments info.
+ *
+ * The default value is true (1)
+ * Property type: bool
+ */
+#define AI_CONFIG_IMPORT_MDL_HL1_READ_ATTACHMENTS "IMPORT_MDL_HL1_READ_ATTACHMENTS"
+
+// ---------------------------------------------------------------------------
+/** @brief Set whether the MDL (HL1) importer will read bone controllers info.
+ *
+ * The default value is true (1)
+ * Property type: bool
+ */
+#define AI_CONFIG_IMPORT_MDL_HL1_READ_BONE_CONTROLLERS "IMPORT_MDL_HL1_READ_BONE_CONTROLLERS"
+
+// ---------------------------------------------------------------------------
+/** @brief Set whether the MDL (HL1) importer will read hitboxes info.
+ *
+ * The default value is true (1)
+ * Property type: bool
+ */
+#define AI_CONFIG_IMPORT_MDL_HL1_READ_HITBOXES "IMPORT_MDL_HL1_READ_HITBOXES"
+
+// ---------------------------------------------------------------------------
+/** @brief Set whether the MDL (HL1) importer will read miscellaneous global model info.
+ *
+ * The default value is true (1)
+ * Property type: bool
+ */
+#define AI_CONFIG_IMPORT_MDL_HL1_READ_MISC_GLOBAL_INFO "IMPORT_MDL_HL1_READ_MISC_GLOBAL_INFO"
+
 // ---------------------------------------------------------------------------
 /** Smd load multiple animations
  *
@@ -778,6 +863,15 @@ enum aiComponent
 #define AI_CONFIG_IMPORT_MD3_SKIN_NAME \
     "IMPORT_MD3_SKIN_NAME"
 
+// ---------------------------------------------------------------------------
+/** @brief  Specify if to try load Quake 3 shader files. This also controls
+ *  original surface name handling: when disabled it will be used unchanged.
+ *
+ * Property type: bool. Default value: true.
+ */
+#define AI_CONFIG_IMPORT_MD3_LOAD_SHADERS \
+    "IMPORT_MD3_LOAD_SHADERS"
+
 // ---------------------------------------------------------------------------
 /** @brief  Specify the Quake 3 shader file to be used for a particular
  *  MD3 file. This can also be a search path.
@@ -963,10 +1057,10 @@ enum aiComponent
 #define AI_CONFIG_IMPORT_COLLADA_IGNORE_UP_DIRECTION "IMPORT_COLLADA_IGNORE_UP_DIRECTION"
 
 // ---------------------------------------------------------------------------
-/** @brief Specifies whether the Collada loader should use Collada names as node names.
+/** @brief Specifies whether the Collada loader should use Collada names.
  *
- * If this property is set to true, the Collada names will be used as the
- * node name. The default is to use the id tag (resp. sid tag, if no id tag is present)
+ * If this property is set to true, the Collada names will be used as the node and
+ * mesh names. The default is to use the id tag (resp. sid tag, if no id tag is present)
  * instead.
  * Property type: Bool. Default value: false.
  */
@@ -982,7 +1076,7 @@ enum aiComponent
 #define AI_CONFIG_EXPORT_XFILE_64BIT "EXPORT_XFILE_64BIT"
 
 /** @brief Specifies whether the assimp export shall be able to export point clouds
- * 
+ *
  *  When this flag is not defined the render data has to contain valid faces.
  *  Point clouds are only a collection of vertices which have nor spatial organization
  *  by a face and the validation process will remove them. Enabling this feature will
@@ -990,6 +1084,23 @@ enum aiComponent
  */
 #define AI_CONFIG_EXPORT_POINT_CLOUDS "EXPORT_POINT_CLOUDS"
 
+/**
+ * @brief Specifies the blob name, assimp uses for exporting.
+ * 
+ * Some formats require auxiliary files to be written, that need to be linked back into 
+ * the original file. For example, OBJ files export materials to a separate MTL file and
+ * use the `mtllib` keyword to reference this file.
+ * 
+ * When exporting blobs using #ExportToBlob, assimp does not know the name of the blob
+ * file and thus outputs `mtllib $blobfile.mtl`, which might not be desired, since the 
+ * MTL file might be called differently. 
+ * 
+ * This property can be used to give the exporter a hint on how to use the magic 
+ * `$blobfile` keyword. If the exporter detects the keyword and is provided with a name
+ * for the blob, it instead uses this name.
+ */
+#define AI_CONFIG_EXPORT_BLOB_NAME "EXPORT_BLOB_NAME"
+
 /**
  *  @brief  Specifies a gobal key factor for scale, float value
  */
diff --git a/Engine/lib/assimp/include/assimp/defs.h b/Engine/lib/assimp/include/assimp/defs.h
index 05a5e3fd4..0626a8d8a 100644
--- a/Engine/lib/assimp/include/assimp/defs.h
+++ b/Engine/lib/assimp/include/assimp/defs.h
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -50,6 +48,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_DEFINES_H_INC
 #define AI_DEFINES_H_INC
 
+#ifdef __GNUC__
+#pragma GCC system_header
+#endif
+
 #include <assimp/config.h>
 
 //////////////////////////////////////////////////////////////////////////
@@ -74,23 +76,32 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //////////////////////////////////////////////////////////////////////////
 
 #ifndef ASSIMP_BUILD_NO_COMPRESSED_X
-#   define ASSIMP_BUILD_NEED_Z_INFLATE
+#define ASSIMP_BUILD_NEED_Z_INFLATE
 #endif
 
 #ifndef ASSIMP_BUILD_NO_COMPRESSED_BLEND
-#   define ASSIMP_BUILD_NEED_Z_INFLATE
+#define ASSIMP_BUILD_NEED_Z_INFLATE
 #endif
 
 #ifndef ASSIMP_BUILD_NO_COMPRESSED_IFC
-#   define ASSIMP_BUILD_NEED_Z_INFLATE
-#   define ASSIMP_BUILD_NEED_UNZIP
+#define ASSIMP_BUILD_NEED_Z_INFLATE
+#define ASSIMP_BUILD_NEED_UNZIP
 #endif
 
 #ifndef ASSIMP_BUILD_NO_Q3BSP_IMPORTER
-#   define ASSIMP_BUILD_NEED_Z_INFLATE
-#   define ASSIMP_BUILD_NEED_UNZIP
+#define ASSIMP_BUILD_NEED_Z_INFLATE
+#define ASSIMP_BUILD_NEED_UNZIP
 #endif
 
+// We need those constants, workaround for any platforms where nobody defined them yet
+#if (!defined SIZE_MAX)
+#define SIZE_MAX (~((size_t)0))
+#endif
+
+/*#if (!defined UINT_MAX)
+#define UINT_MAX (~((unsigned int)0))
+#endif*/
+
 //////////////////////////////////////////////////////////////////////////
 /* Define ASSIMP_BUILD_NO_XX_PROCESS to disable a specific
  * post processing step. This is the current list of process names ('XX'):
@@ -126,68 +137,69 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  * GENBOUNDINGBOXES */
 //////////////////////////////////////////////////////////////////////////
 
-#ifdef _MSC_VER
-#   undef ASSIMP_API
+#ifdef _WIN32
+#undef ASSIMP_API
+//////////////////////////////////////////////////////////////////////////
+/* Define 'ASSIMP_BUILD_DLL_EXPORT' to build a DLL of the library */
+//////////////////////////////////////////////////////////////////////////
+#ifdef ASSIMP_BUILD_DLL_EXPORT
+#define ASSIMP_API __declspec(dllexport)
+#define ASSIMP_API_WINONLY __declspec(dllexport)
 
-    //////////////////////////////////////////////////////////////////////////
-    /* Define 'ASSIMP_BUILD_DLL_EXPORT' to build a DLL of the library */
-    //////////////////////////////////////////////////////////////////////////
-#   ifdef ASSIMP_BUILD_DLL_EXPORT
-#       define ASSIMP_API __declspec(dllexport)
-#       define ASSIMP_API_WINONLY __declspec(dllexport)
-#       pragma warning (disable : 4251)
-
-    //////////////////////////////////////////////////////////////////////////
-    /* Define 'ASSIMP_DLL' before including Assimp to link to ASSIMP in
+//////////////////////////////////////////////////////////////////////////
+/* Define 'ASSIMP_DLL' before including Assimp to link to ASSIMP in
      * an external DLL under Windows. Default is static linkage. */
-    //////////////////////////////////////////////////////////////////////////
-#   elif (defined ASSIMP_DLL)
-#       define ASSIMP_API __declspec(dllimport)
-#       define ASSIMP_API_WINONLY __declspec(dllimport)
-#   else
-#       define ASSIMP_API
-#       define ASSIMP_API_WINONLY
-#   endif
+//////////////////////////////////////////////////////////////////////////
+#elif (defined ASSIMP_DLL)
+#define ASSIMP_API __declspec(dllimport)
+#define ASSIMP_API_WINONLY __declspec(dllimport)
+#else
+#define ASSIMP_API
+#define ASSIMP_API_WINONLY
+#endif
+#elif defined(SWIG)
+/* Do nothing, the relevant defines are all in AssimpSwigPort.i */
+#else
+#define ASSIMP_API __attribute__((visibility("default")))
+#define ASSIMP_API_WINONLY
+#endif // _WIN32
 
-    /* Force the compiler to inline a function, if possible
-     */
-#   define AI_FORCE_INLINE __forceinline
+#ifdef _MSC_VER
+    #pragma warning(disable : 4521 4512 4714 4127 4351 4510)
+    #ifdef ASSIMP_BUILD_DLL_EXPORT
+        #pragma warning(disable : 4251)
+    #endif
+    /* Force the compiler to inline a function, if possible */
+    #define AI_FORCE_INLINE inline
 
     /* Tells the compiler that a function never returns. Used in code analysis
-     * to skip dead paths (e.g. after an assertion evaluated to false). */
-#   define AI_WONT_RETURN __declspec(noreturn)
-
+    * to skip dead paths (e.g. after an assertion evaluated to false). */
+    #define AI_WONT_RETURN __declspec(noreturn)
 #elif defined(SWIG)
-
-    /* Do nothing, the relevant defines are all in AssimpSwigPort.i */
-
+  /* Do nothing, the relevant defines are all in AssimpSwigPort.i */
 #else
-
-#   define AI_WONT_RETURN
-
-#   define ASSIMP_API __attribute__ ((visibility("default")))
-#   define ASSIMP_API_WINONLY
-#   define AI_FORCE_INLINE inline
+    #define AI_WONT_RETURN
+    #define AI_FORCE_INLINE inline
 #endif // (defined _MSC_VER)
 
 #ifdef __GNUC__
-#   define AI_WONT_RETURN_SUFFIX  __attribute__((noreturn))
+#   define AI_WONT_RETURN_SUFFIX __attribute__((noreturn))
 #else
 #   define AI_WONT_RETURN_SUFFIX
 #endif // (defined __clang__)
 
 #ifdef __cplusplus
-    /* No explicit 'struct' and 'enum' tags for C++, this keeps showing up
-     * in doxydocs.
-     */
-#   define C_STRUCT
-#   define C_ENUM
+/* No explicit 'struct' and 'enum' tags for C++, this keeps showing up
+ * in doxydocs. 
+ */
+#define C_STRUCT
+#define C_ENUM
 #else
-    //////////////////////////////////////////////////////////////////////////
-    /* To build the documentation, make sure ASSIMP_DOXYGEN_BUILD
+//////////////////////////////////////////////////////////////////////////
+/* To build the documentation, make sure ASSIMP_DOXYGEN_BUILD
      * is defined by Doxygen's preprocessor. The corresponding
      * entries in the DOXYFILE are: */
-    //////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
 #if 0
     ENABLE_PREPROCESSING   = YES
     MACRO_EXPANSION        = YES
@@ -199,112 +211,126 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     EXPAND_AS_DEFINED      = C_STRUCT C_ENUM
     SKIP_FUNCTION_MACROS   = YES
 #endif
-    //////////////////////////////////////////////////////////////////////////
-    /* Doxygen gets confused if we use c-struct typedefs to avoid
+//////////////////////////////////////////////////////////////////////////
+/* Doxygen gets confused if we use c-struct typedefs to avoid
      * the explicit 'struct' notation. This trick here has the same
      * effect as the TYPEDEF_HIDES_STRUCT option, but we don't need
      * to typedef all structs/enums. */
-     //////////////////////////////////////////////////////////////////////////
-#   if (defined ASSIMP_DOXYGEN_BUILD)
-#       define C_STRUCT
-#       define C_ENUM
-#   else
-#       define C_STRUCT struct
-#       define C_ENUM   enum
-#   endif
+//////////////////////////////////////////////////////////////////////////
+#if (defined ASSIMP_DOXYGEN_BUILD)
+#define C_STRUCT
+#define C_ENUM
+#else
+#define C_STRUCT struct
+#define C_ENUM enum
+#endif
 #endif
 
-#if (defined(__BORLANDC__) || defined (__BCPLUSPLUS__))
-#   error Currently, Borland is unsupported. Feel free to port Assimp.
+#if (defined(__BORLANDC__) || defined(__BCPLUSPLUS__))
+#error Currently, Borland is unsupported. Feel free to port Assimp.
 #endif
 
-
-    //////////////////////////////////////////////////////////////////////////
-    /* Define ASSIMP_BUILD_SINGLETHREADED to compile assimp
+//////////////////////////////////////////////////////////////////////////
+/* Define ASSIMP_BUILD_SINGLETHREADED to compile assimp
      * without threading support. The library doesn't utilize
      * threads then and is itself not threadsafe. */
-    //////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
 #ifndef ASSIMP_BUILD_SINGLETHREADED
-#   define ASSIMP_BUILD_SINGLETHREADED
+#define ASSIMP_BUILD_SINGLETHREADED
 #endif
 
-#if defined(_DEBUG) || ! defined(NDEBUG)
-#   define ASSIMP_BUILD_DEBUG
+#if defined(_DEBUG) || !defined(NDEBUG)
+#define ASSIMP_BUILD_DEBUG
 #endif
 
-    //////////////////////////////////////////////////////////////////////////
-    /* Define ASSIMP_DOUBLE_PRECISION to compile assimp
+//////////////////////////////////////////////////////////////////////////
+/* Define ASSIMP_DOUBLE_PRECISION to compile assimp
      * with double precision support (64-bit). */
-    //////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
 
 #ifdef ASSIMP_DOUBLE_PRECISION
-    typedef double ai_real;
-    typedef signed long long int ai_int;
-    typedef unsigned long long int ai_uint;
+typedef double ai_real;
+typedef signed long long int ai_int;
+typedef unsigned long long int ai_uint;
 #ifndef ASSIMP_AI_REAL_TEXT_PRECISION
-#define ASSIMP_AI_REAL_TEXT_PRECISION 16
+#define ASSIMP_AI_REAL_TEXT_PRECISION 17
 #endif // ASSIMP_AI_REAL_TEXT_PRECISION
 #else // ASSIMP_DOUBLE_PRECISION
-    typedef float ai_real;
-    typedef signed int ai_int;
-    typedef unsigned int ai_uint;
+typedef float ai_real;
+typedef signed int ai_int;
+typedef unsigned int ai_uint;
 #ifndef ASSIMP_AI_REAL_TEXT_PRECISION
-#define ASSIMP_AI_REAL_TEXT_PRECISION 8
+#define ASSIMP_AI_REAL_TEXT_PRECISION 9
 #endif // ASSIMP_AI_REAL_TEXT_PRECISION
 #endif // ASSIMP_DOUBLE_PRECISION
 
-    //////////////////////////////////////////////////////////////////////////
-    /* Useful constants */
-    //////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
+/* Useful constants */
+//////////////////////////////////////////////////////////////////////////
 
 /* This is PI. Hi PI. */
-#define AI_MATH_PI          (3.141592653589793238462643383279 )
-#define AI_MATH_TWO_PI      (AI_MATH_PI * 2.0)
-#define AI_MATH_HALF_PI     (AI_MATH_PI * 0.5)
+#define AI_MATH_PI (3.141592653589793238462643383279)
+#define AI_MATH_TWO_PI (AI_MATH_PI * 2.0)
+#define AI_MATH_HALF_PI (AI_MATH_PI * 0.5)
 
 /* And this is to avoid endless casts to float */
-#define AI_MATH_PI_F        (3.1415926538f)
-#define AI_MATH_TWO_PI_F    (AI_MATH_PI_F * 2.0f)
-#define AI_MATH_HALF_PI_F   (AI_MATH_PI_F * 0.5f)
+#define AI_MATH_PI_F (3.1415926538f)
+#define AI_MATH_TWO_PI_F (AI_MATH_PI_F * 2.0f)
+#define AI_MATH_HALF_PI_F (AI_MATH_PI_F * 0.5f)
 
 /* Tiny macro to convert from radians to degrees and back */
-#define AI_DEG_TO_RAD(x) ((x)*(ai_real)0.0174532925)
-#define AI_RAD_TO_DEG(x) ((x)*(ai_real)57.2957795)
+#define AI_DEG_TO_RAD(x) ((x) * (ai_real) 0.0174532925)
+#define AI_RAD_TO_DEG(x) ((x) * (ai_real) 57.2957795)
 
 /* Numerical limits */
-static const ai_real ai_epsilon = (ai_real) 0.00001;
+static const ai_real ai_epsilon = (ai_real) 1e-6;
 
 /* Support for big-endian builds */
 #if defined(__BYTE_ORDER__)
-#   if (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
-#       if !defined(__BIG_ENDIAN__)
-#           define __BIG_ENDIAN__
-#       endif
-#   else /* little endian */
-#       if defined (__BIG_ENDIAN__)
-#           undef __BIG_ENDIAN__
-#       endif
-#   endif
+#if (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+#if !defined(__BIG_ENDIAN__)
+#define __BIG_ENDIAN__
+#endif
+#else /* little endian */
+#if defined(__BIG_ENDIAN__)
+#undef __BIG_ENDIAN__
+#endif
+#endif
 #endif
 #if defined(__BIG_ENDIAN__)
-#   define AI_BUILD_BIG_ENDIAN
+#define AI_BUILD_BIG_ENDIAN
 #endif
 
-
-/* To avoid running out of memory
- * This can be adjusted for specific use cases
- * It's NOT a total limit, just a limit for individual allocations
+/**
+ *  To avoid running out of memory
+ *  This can be adjusted for specific use cases
+ *  It's NOT a total limit, just a limit for individual allocations
  */
 #define AI_MAX_ALLOC(type) ((256U * 1024 * 1024) / sizeof(type))
 
 #ifndef _MSC_VER
-#  define AI_NO_EXCEPT noexcept
+#if __cplusplus >= 201103L // C++11
+#define AI_NO_EXCEPT noexcept
 #else
-#  if (_MSC_VER >= 1915 )
-#    define AI_NO_EXCEPT noexcept
-#  else
-#    define AI_NO_EXCEPT
-#  endif
+#define AI_NO_EXCEPT
+#endif
+#else
+#if (_MSC_VER >= 1915)
+#define AI_NO_EXCEPT noexcept
+#else
+#define AI_NO_EXCEPT
+#endif
 #endif // _MSC_VER
 
+/**
+ *  Helper macro to set a pointer to NULL in debug builds
+ */
+#if (defined ASSIMP_BUILD_DEBUG)
+#define AI_DEBUG_INVALIDATE_PTR(x) x = NULL;
+#else
+#define AI_DEBUG_INVALIDATE_PTR(x)
+#endif
+
+#define AI_COUNT_OF(X) (sizeof(X) / sizeof((X)[0]))
+
 #endif // !! AI_DEFINES_H_INC
diff --git a/Engine/lib/assimp/include/assimp/fast_atof.h b/Engine/lib/assimp/include/assimp/fast_atof.h
index 62ea969e9..43bbbff64 100644
--- a/Engine/lib/assimp/include/assimp/fast_atof.h
+++ b/Engine/lib/assimp/include/assimp/fast_atof.h
@@ -13,18 +13,23 @@
 //     to ensure long numbers are handled correctly
 // ------------------------------------------------------------------------------------
 
-
+#pragma once
 #ifndef FAST_A_TO_F_H_INCLUDED
 #define FAST_A_TO_F_H_INCLUDED
 
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
 #include <cmath>
 #include <limits>
 #include <stdint.h>
-#include <stdexcept>
 #include <assimp/defs.h>
 
 #include "StringComparison.h"
 #include <assimp/DefaultLogger.hpp>
+#include <assimp/Exceptional.h>
+#include <assimp/StringUtils.h>
 
 #ifdef _MSC_VER
 #  include <stdint.h>
@@ -181,13 +186,15 @@ unsigned int strtoul_cppstyle( const char* in, const char** out=0) {
 // Special version of the function, providing higher accuracy and safety
 // It is mainly used by fast_atof to prevent ugly and unwanted integer overflows.
 // ------------------------------------------------------------------------------------
+template<typename ExceptionType = DeadlyImportError>
 inline
 uint64_t strtoul10_64( const char* in, const char** out=0, unsigned int* max_inout=0) {
     unsigned int cur = 0;
     uint64_t value = 0;
 
     if ( *in < '0' || *in > '9' ) {
-        throw std::invalid_argument( std::string( "The string \"" ) + in + "\" cannot be converted into a value." );
+        // The string is known to be bad, so don't risk printing the whole thing.
+        throw ExceptionType("The string \"", ai_str_toprintable(in, (int)strlen(in)), "\" cannot be converted into a value." );
     }
 
     for ( ;; ) {
@@ -199,7 +206,7 @@ uint64_t strtoul10_64( const char* in, const char** out=0, unsigned int* max_ino
 
         // numeric overflow, we rely on you
         if ( new_value < value ) {
-            ASSIMP_LOG_WARN_F( "Converting the string \"", in, "\" into a value resulted in overflow." );
+            ASSIMP_LOG_WARN( "Converting the string \"", in, "\" into a value resulted in overflow." );
             return 0;
         }
 
@@ -233,6 +240,7 @@ uint64_t strtoul10_64( const char* in, const char** out=0, unsigned int* max_ino
 // ------------------------------------------------------------------------------------
 // signed variant of strtoul10_64
 // ------------------------------------------------------------------------------------
+template<typename ExceptionType = DeadlyImportError>
 inline
 int64_t strtol10_64(const char* in, const char** out = 0, unsigned int* max_inout = 0) {
     bool inv = (*in == '-');
@@ -240,7 +248,7 @@ int64_t strtol10_64(const char* in, const char** out = 0, unsigned int* max_inou
         ++in;
     }
 
-    int64_t value = strtoul10_64(in, out, max_inout);
+    int64_t value = strtoul10_64<ExceptionType>(in, out, max_inout);
     if (inv) {
         value = -value;
     }
@@ -255,7 +263,7 @@ int64_t strtol10_64(const char* in, const char** out = 0, unsigned int* max_inou
 //! about 6 times faster than atof in win32.
 // If you find any bugs, please send them to me, niko (at) irrlicht3d.org.
 // ------------------------------------------------------------------------------------
-template<typename Real>
+template<typename Real, typename ExceptionType = DeadlyImportError>
 inline
 const char* fast_atoreal_move(const char* c, Real& out, bool check_comma = true) {
     Real f = 0;
@@ -285,13 +293,14 @@ const char* fast_atoreal_move(const char* c, Real& out, bool check_comma = true)
 
     if (!(c[0] >= '0' && c[0] <= '9') &&
             !((c[0] == '.' || (check_comma && c[0] == ',')) && c[1] >= '0' && c[1] <= '9')) {
-        throw std::invalid_argument("Cannot parse string "
-                                    "as real number: does not start with digit "
+        // The string is known to be bad, so don't risk printing the whole thing.
+        throw ExceptionType("Cannot parse string \"", ai_str_toprintable(c, (int)strlen(c)),
+                                    "\" as a real number: does not start with digit "
                                     "or decimal point followed by digit.");
     }
 
     if (*c != '.' && (! check_comma || c[0] != ',')) {
-        f = static_cast<Real>( strtoul10_64 ( c, &c) );
+        f = static_cast<Real>( strtoul10_64<ExceptionType> ( c, &c) );
     }
 
     if ((*c == '.' || (check_comma && c[0] == ',')) && c[1] >= '0' && c[1] <= '9') {
@@ -306,7 +315,7 @@ const char* fast_atoreal_move(const char* c, Real& out, bool check_comma = true)
         // number of digits to be read. AI_FAST_ATOF_RELAVANT_DECIMALS can be a value between
         // 1 and 15.
         unsigned int diff = AI_FAST_ATOF_RELAVANT_DECIMALS;
-        double pl = static_cast<double>( strtoul10_64 ( c, &c, &diff ));
+        double pl = static_cast<double>( strtoul10_64<ExceptionType> ( c, &c, &diff ));
 
         pl *= fast_atof_table[diff];
         f += static_cast<Real>( pl );
@@ -328,7 +337,7 @@ const char* fast_atoreal_move(const char* c, Real& out, bool check_comma = true)
         // The reason float constants are used here is that we've seen cases where compilers
         // would perform such casts on compile-time constants at runtime, which would be
         // bad considering how frequently fast_atoreal_move<float> is called in Assimp.
-        Real exp = static_cast<Real>( strtoul10_64(c, &c) );
+        Real exp = static_cast<Real>( strtoul10_64<ExceptionType>(c, &c) );
         if (einv) {
             exp = -exp;
         }
@@ -344,26 +353,29 @@ const char* fast_atoreal_move(const char* c, Real& out, bool check_comma = true)
 
 // ------------------------------------------------------------------------------------
 // The same but more human.
+template<typename ExceptionType = DeadlyImportError>
 inline
 ai_real fast_atof(const char* c) {
     ai_real ret(0.0);
-    fast_atoreal_move<ai_real>(c, ret);
+    fast_atoreal_move<ai_real, ExceptionType>(c, ret);
 
     return ret;
 }
 
+template<typename ExceptionType = DeadlyImportError>
 inline
 ai_real fast_atof( const char* c, const char** cout) {
     ai_real ret(0.0);
-    *cout = fast_atoreal_move<ai_real>(c, ret);
+    *cout = fast_atoreal_move<ai_real, ExceptionType>(c, ret);
 
     return ret;
 }
 
+template<typename ExceptionType = DeadlyImportError>
 inline
 ai_real fast_atof( const char** inout) {
     ai_real ret(0.0);
-    *inout = fast_atoreal_move<ai_real>(*inout, ret);
+    *inout = fast_atoreal_move<ai_real, ExceptionType>(*inout, ret);
 
     return ret;
 }
diff --git a/Engine/lib/assimp/include/assimp/importerdesc.h b/Engine/lib/assimp/include/assimp/importerdesc.h
index 36e387f01..d08bd1781 100644
--- a/Engine/lib/assimp/include/assimp/importerdesc.h
+++ b/Engine/lib/assimp/include/assimp/importerdesc.h
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -48,11 +46,19 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_IMPORTER_DESC_H_INC
 #define AI_IMPORTER_DESC_H_INC
 
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
+#include <assimp/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 /** Mixed set of flags for #aiImporterDesc, indicating some features
   *  common to many importers*/
-enum aiImporterFlags
-{
+enum aiImporterFlags {
     /** Indicates that there is a textual encoding of the
      *  file format; and that it is supported.*/
     aiImporterFlags_SupportTextFlavour = 0x1,
@@ -78,7 +84,6 @@ enum aiImporterFlags
     aiImporterFlags_Experimental = 0x10
 };
 
-
 /** Meta information about a particular importer. Importers need to fill
  *  this structure, but they can freely decide how talkative they are.
  *  A common use case for loader meta info is a user interface
@@ -87,19 +92,18 @@ enum aiImporterFlags
  *  as importers/exporters are added to Assimp, so it might be useful
  *  to have a common mechanism to query some rough importer
  *  characteristics. */
-struct aiImporterDesc
-{
+struct aiImporterDesc {
     /** Full name of the importer (i.e. Blender3D importer)*/
-    const char* mName;
+    const char *mName;
 
     /** Original author (left blank if unknown or whole assimp team) */
-    const char* mAuthor;
+    const char *mAuthor;
 
     /** Current maintainer, left blank if the author maintains */
-    const char* mMaintainer;
+    const char *mMaintainer;
 
     /** Implementation comments, i.e. unimplemented features*/
-    const char* mComments;
+    const char *mComments;
 
     /** These flags indicate some characteristics common to many
         importers. */
@@ -132,15 +136,19 @@ struct aiImporterDesc
         other methods to quickly reject files (i.e. magic
         words) so this does not mean that common or generic
         file extensions such as XML would be tediously slow. */
-    const char* mFileExtensions;
+    const char *mFileExtensions;
 };
 
 /** \brief  Returns the Importer description for a given extension.
 
-Will return a NULL-pointer if no assigned importer desc. was found for the given extension
+Will return a nullptr if no assigned importer desc. was found for the given extension
     \param  extension   [in] The extension to look for
     \return A pointer showing to the ImporterDesc, \see aiImporterDesc.
 */
-ASSIMP_API const C_STRUCT aiImporterDesc* aiGetImporterDesc( const char *extension );
+ASSIMP_API const C_STRUCT aiImporterDesc *aiGetImporterDesc(const char *extension);
+
+#ifdef __cplusplus
+} // end of extern "C"
+#endif
 
 #endif // AI_IMPORTER_DESC_H_INC
diff --git a/Engine/lib/assimp/include/assimp/irrXMLWrapper.h b/Engine/lib/assimp/include/assimp/irrXMLWrapper.h
deleted file mode 100644
index 77cfd5e47..000000000
--- a/Engine/lib/assimp/include/assimp/irrXMLWrapper.h
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-#ifndef INCLUDED_AI_IRRXML_WRAPPER
-#define INCLUDED_AI_IRRXML_WRAPPER
-
-// some long includes ....
-#ifdef ASSIMP_USE_HUNTER
-#  include <irrXML/irrXML.h>
-#else
-#  include <irrXML.h>
-#endif
-#include "IOStream.hpp"
-#include "BaseImporter.h"
-#include <vector>
-
-namespace Assimp    {
-
-// ---------------------------------------------------------------------------------
-/** @brief Utility class to make IrrXML work together with our custom IO system
- *  See the IrrXML docs for more details.
- *
- *  Construct IrrXML-Reader in BaseImporter::InternReadFile():
- *  @code
- * // open the file
- * std::unique_ptr<IOStream> file( pIOHandler->Open( pFile));
- * if( file.get() == NULL) {
- *    throw DeadlyImportError( "Failed to open file " + pFile + ".");
- * }
- *
- * // generate a XML reader for it
- * std::unique_ptr<CIrrXML_IOStreamReader> mIOWrapper( new CIrrXML_IOStreamReader( file.get()));
- * mReader = irr::io::createIrrXMLReader( mIOWrapper.get());
- * if( !mReader) {
- *    ThrowException( "xxxx: Unable to open file.");
- * }
- * @endcode
- **/
-class CIrrXML_IOStreamReader : public irr::io::IFileReadCallBack {
-public:
-
-    // ----------------------------------------------------------------------------------
-    //! Construction from an existing IOStream
-    explicit CIrrXML_IOStreamReader(IOStream* _stream)
-        : stream (_stream)
-        , t (0)
-    {
-
-        // Map the buffer into memory and convert it to UTF8. IrrXML provides its
-        // own conversion, which is merely a cast from uintNN_t to uint8_t. Thus,
-        // it is not suitable for our purposes and we have to do it BEFORE IrrXML
-        // gets the buffer. Sadly, this forces us to map the whole file into
-        // memory.
-
-        data.resize(stream->FileSize());
-        stream->Read(&data[0],data.size(),1);
-
-        // Remove null characters from the input sequence otherwise the parsing will utterly fail
-        // std::find is usually much faster than manually iterating
-        // It is very unlikely that there will be any null characters
-        auto null_char_iter = std::find(data.begin(), data.end(), '\0');
-
-        while (null_char_iter != data.end())
-        {
-            null_char_iter = data.erase(null_char_iter);
-            null_char_iter = std::find(null_char_iter, data.end(), '\0');
-        }
-
-        BaseImporter::ConvertToUTF8(data);
-    }
-
-    // ----------------------------------------------------------------------------------
-    //! Virtual destructor
-    virtual ~CIrrXML_IOStreamReader() {}
-
-    // ----------------------------------------------------------------------------------
-    //!   Reads an amount of bytes from the file.
-    /**  @param buffer:       Pointer to output buffer.
-     *   @param sizeToRead:   Amount of bytes to read
-     *   @return              Returns how much bytes were read.  */
-    virtual int read(void* buffer, int sizeToRead)  {
-        if(sizeToRead<0) {
-            return 0;
-        }
-        if(t+sizeToRead>data.size()) {
-            sizeToRead = static_cast<int>(data.size()-t);
-        }
-
-        memcpy(buffer,&data.front()+t,sizeToRead);
-
-        t += sizeToRead;
-        return sizeToRead;
-    }
-
-    // ----------------------------------------------------------------------------------
-    //! Returns size of file in bytes
-    virtual int getSize()   {
-        return (int)data.size();
-    }
-
-private:
-    IOStream* stream;
-    std::vector<char> data;
-    size_t t;
-
-}; // ! class CIrrXML_IOStreamReader
-
-} // ! Assimp
-
-#endif // !! INCLUDED_AI_IRRXML_WRAPPER
diff --git a/Engine/lib/assimp/include/assimp/light.h b/Engine/lib/assimp/include/assimp/light.h
index 1667cfb8c..3331997a9 100644
--- a/Engine/lib/assimp/include/assimp/light.h
+++ b/Engine/lib/assimp/include/assimp/light.h
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -49,7 +47,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_LIGHT_H_INC
 #define AI_LIGHT_H_INC
 
-#include "types.h"
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
+#include <assimp/types.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -58,8 +60,7 @@ extern "C" {
 // ---------------------------------------------------------------------------
 /** Enumerates all supported types of light sources.
  */
-enum aiLightSourceType
-{
+enum aiLightSourceType {
     aiLightSource_UNDEFINED     = 0x0,
 
     //! A directional light source has a well-defined direction
@@ -106,16 +107,15 @@ enum aiLightSourceType
  *  a single structure and distinguished by their parameters.
  *  Note - some file formats (such as 3DS, ASE) export a "target point" -
  *  the point a spot light is looking at (it can even be animated). Assimp
- *  writes the target point as a subnode of a spotlights's main node,
+ *  writes the target point as a sub-node of a spot-lights's main node,
  *  called "<spotName>.Target". However, this is just additional information
  *  then, the transformation tracks of the main node make the
  *  spot light already point in the right direction.
 */
-struct aiLight
-{
+struct aiLight {
     /** The name of the light source.
      *
-     *  There must be a node in the scenegraph with the same name.
+     *  There must be a node in the scene-graph with the same name.
      *  This node specifies the position of the light in the scene
      *  hierarchy and can be animated.
      */
@@ -253,7 +253,6 @@ struct aiLight
 
 #ifdef __cplusplus
 }
-#endif 
-
+#endif
 
 #endif // !! AI_LIGHT_H_INC
diff --git a/Engine/lib/assimp/include/assimp/material.h b/Engine/lib/assimp/include/assimp/material.h
index 206eb2a2b..2ccd83763 100644
--- a/Engine/lib/assimp/include/assimp/material.h
+++ b/Engine/lib/assimp/include/assimp/material.h
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -48,14 +46,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_MATERIAL_H_INC
 #define AI_MATERIAL_H_INC
 
-#include "types.h"
+#ifdef __GNUC__
+#pragma GCC system_header
+#endif
+
+#include <assimp/types.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 // Name for default materials (2nd is used if meshes have UV coords)
-#define AI_DEFAULT_MATERIAL_NAME          "DefaultMaterial"
+#define AI_DEFAULT_MATERIAL_NAME "DefaultMaterial"
 
 // ---------------------------------------------------------------------------
 /** @brief Defines how the Nth texture of a specific type is combined with
@@ -76,8 +78,7 @@ extern "C" {
  *  @endcode
  *  where 'diffContrib' is the intensity of the incoming light for that pixel.
  */
-enum aiTextureOp
-{
+enum aiTextureOp {
     /** T = T1 * T2 */
     aiTextureOp_Multiply = 0x0,
 
@@ -96,7 +97,6 @@ enum aiTextureOp
     /** T = T1 + (T2-0.5) */
     aiTextureOp_SignedAdd = 0x5,
 
-
 #ifndef SWIG
     _aiTextureOp_Force32Bit = INT_MAX
 #endif
@@ -107,8 +107,7 @@ enum aiTextureOp
  *
  *  Commonly referred to as 'wrapping mode'.
  */
-enum aiTextureMapMode
-{
+enum aiTextureMapMode {
     /** A texture coordinate u|v is translated to u%1|v%1
      */
     aiTextureMapMode_Wrap = 0x0,
@@ -142,32 +141,30 @@ enum aiTextureMapMode
  *  how the mapping should look like (e.g spherical) is given.
  *  See the #AI_MATKEY_MAPPING property for more details.
  */
-enum aiTextureMapping
-{
+enum aiTextureMapping {
     /** The mapping coordinates are taken from an UV channel.
      *
-     *  The #AI_MATKEY_UVWSRC key specifies from which UV channel
+     *  #AI_MATKEY_UVWSRC property specifies from which UV channel
      *  the texture coordinates are to be taken from (remember,
      *  meshes can have more than one UV channel).
     */
     aiTextureMapping_UV = 0x0,
 
-     /** Spherical mapping */
+    /** Spherical mapping */
     aiTextureMapping_SPHERE = 0x1,
 
-     /** Cylindrical mapping */
+    /** Cylindrical mapping */
     aiTextureMapping_CYLINDER = 0x2,
 
-     /** Cubic mapping */
+    /** Cubic mapping */
     aiTextureMapping_BOX = 0x3,
 
-     /** Planar mapping */
+    /** Planar mapping */
     aiTextureMapping_PLANE = 0x4,
 
-     /** Undefined mapping. Have fun. */
+    /** Undefined mapping. Have fun. */
     aiTextureMapping_OTHER = 0x5,
 
-
 #ifndef SWIG
     _aiTextureMapping_Force32Bit = INT_MAX
 #endif
@@ -188,8 +185,7 @@ enum aiTextureMapping
  *  and the artists working on models have to conform to this specification,
  *  regardless which 3D tool they're using.
  */
-enum aiTextureType
-{
+enum aiTextureType {
     /** Dummy value.
      *
      *  No texture, but the value to be used as 'texture semantic'
@@ -198,19 +194,23 @@ enum aiTextureType
      */
     aiTextureType_NONE = 0,
 
-    /** LEGACY API MATERIALS 
-     * Legacy refers to materials which 
+    /** LEGACY API MATERIALS
+     * Legacy refers to materials which
      * Were originally implemented in the specifications around 2000.
      * These must never be removed, as most engines support them.
      */
 
     /** The texture is combined with the result of the diffuse
      *  lighting equation.
+     *  OR
+     *  PBR Specular/Glossiness
      */
     aiTextureType_DIFFUSE = 1,
 
     /** The texture is combined with the result of the specular
      *  lighting equation.
+     *  OR
+     *  PBR Specular/Glossiness
      */
     aiTextureType_SPECULAR = 2,
 
@@ -292,6 +292,32 @@ enum aiTextureType
     aiTextureType_DIFFUSE_ROUGHNESS = 16,
     aiTextureType_AMBIENT_OCCLUSION = 17,
 
+    /** PBR Material Modifiers
+    * Some modern renderers have further PBR modifiers that may be overlaid
+    * on top of the 'base' PBR materials for additional realism.
+    * These use multiple texture maps, so only the base type is directly defined
+    */
+
+    /** Sheen
+    * Generally used to simulate textiles that are covered in a layer of microfibers
+    * eg velvet
+    * https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_sheen
+    */
+    aiTextureType_SHEEN = 19,
+
+    /** Clearcoat
+    * Simulates a layer of 'polish' or 'laquer' layered on top of a PBR substrate
+    * https://autodesk.github.io/standard-surface/#closures/coating
+    * https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_clearcoat
+    */
+    aiTextureType_CLEARCOAT = 20,
+
+    /** Transmission
+    * Simulates transmission through the surface
+    * May include further information such as wall thickness
+    */
+    aiTextureType_TRANSMISSION = 21,
+
     /** Unknown texture
      *
      *  A texture reference that does not match any of the definitions
@@ -300,16 +326,21 @@ enum aiTextureType
     */
     aiTextureType_UNKNOWN = 18,
 
-
 #ifndef SWIG
     _aiTextureType_Force32Bit = INT_MAX
 #endif
 };
 
-#define AI_TEXTURE_TYPE_MAX  aiTextureType_UNKNOWN
+#define AI_TEXTURE_TYPE_MAX aiTextureType_TRANSMISSION
+
+// -------------------------------------------------------------------------------
+// Get a string for a given aiTextureType
+ASSIMP_API const char *TextureTypeToString(enum aiTextureType in);
 
 // ---------------------------------------------------------------------------
 /** @brief Defines all shading models supported by the library
+ *
+ *  Property: #AI_MATKEY_SHADING_MODEL
  *
  *  The list of shading modes has been taken from Blender.
  *  See Blender documentation for more information. The API does
@@ -318,10 +349,10 @@ enum aiTextureType
  *  undefined). <br>
  *  Again, this value is just a hint. Assimp tries to select the shader whose
  *  most common implementation matches the original rendering results of the
- *  3D modeller which wrote a particular model as closely as possible.
+ *  3D modeler which wrote a particular model as closely as possible.
+ *
  */
-enum aiShadingMode
-{
+enum aiShadingMode {
     /** Flat shading. Shading is done on per-face base,
      *  diffuse only. Also known as 'faceted shading'.
      */
@@ -366,20 +397,33 @@ enum aiShadingMode
     aiShadingMode_CookTorrance = 0x8,
 
     /** No shading at all. Constant light influence of 1.0.
+    * Also known as "Unlit"
     */
     aiShadingMode_NoShading = 0x9,
+    aiShadingMode_Unlit = aiShadingMode_NoShading, // Alias
 
-     /** Fresnel shading
+    /** Fresnel shading
      */
     aiShadingMode_Fresnel = 0xa,
 
+    /** Physically-Based Rendering (PBR) shading using
+    * Bidirectional scattering/reflectance distribution function (BSDF/BRDF)
+    * There are multiple methods under this banner, and model files may provide
+    * data for more than one PBR-BRDF method.
+    * Applications should use the set of provided properties to determine which
+    * of their preferred PBR rendering methods are likely to be available
+    * eg:
+    * - If AI_MATKEY_METALLIC_FACTOR is set, then a Metallic/Roughness is available
+    * - If AI_MATKEY_GLOSSINESS_FACTOR is set, then a Specular/Glossiness is available
+    * Note that some PBR methods allow layering of techniques
+    */
+    aiShadingMode_PBR_BRDF = 0xb,
 
 #ifndef SWIG
     _aiShadingMode_Force32Bit = INT_MAX
 #endif
 };
 
-
 // ---------------------------------------------------------------------------
 /** @brief Defines some mixed flags for a particular texture.
  *
@@ -391,8 +435,7 @@ enum aiShadingMode
  *
  *  This corresponds to the #AI_MATKEY_TEXFLAGS property.
 */
-enum aiTextureFlags
-{
+enum aiTextureFlags {
     /** The texture's color values have to be inverted (component-wise 1-n)
      */
     aiTextureFlags_Invert = 0x1,
@@ -416,11 +459,10 @@ enum aiTextureFlags
     aiTextureFlags_IgnoreAlpha = 0x4,
 
 #ifndef SWIG
-      _aiTextureFlags_Force32Bit = INT_MAX
+    _aiTextureFlags_Force32Bit = INT_MAX
 #endif
 };
 
-
 // ---------------------------------------------------------------------------
 /** @brief Defines alpha-blend flags.
  *
@@ -432,13 +474,12 @@ enum aiTextureFlags
  *  @code
  *    SourceColor * SourceBlend + DestColor * DestBlend
  *  @endcode
- *  where DestColor is the previous color in the framebuffer at this
+ *  where DestColor is the previous color in the frame-buffer at this
  *  position and SourceColor is the material color before the transparency
  *  calculation.<br>
  *  This corresponds to the #AI_MATKEY_BLEND_FUNC property.
 */
-enum aiBlendMode
-{
+enum aiBlendMode {
     /**
      *  Formula:
      *  @code
@@ -456,15 +497,14 @@ enum aiBlendMode
      */
     aiBlendMode_Additive = 0x1,
 
-    // we don't need more for the moment, but we might need them
-    // in future versions ...
+// we don't need more for the moment, but we might need them
+// in future versions ...
 
 #ifndef SWIG
     _aiBlendMode_Force32Bit = INT_MAX
 #endif
 };
 
-
 #include "./Compiler/pushpack1.h"
 
 // ---------------------------------------------------------------------------
@@ -477,8 +517,7 @@ enum aiBlendMode
  *  we keep separate scaling/translation/rotation values to make it
  *  easier to process and optimize UV transformations internally.
  */
-struct aiUVTransform
-{
+struct aiUVTransform {
     /** Translation on the u and v axes.
      *
      *  The default value is (0|0).
@@ -499,17 +538,14 @@ struct aiUVTransform
      */
     ai_real mRotation;
 
-
 #ifdef __cplusplus
     aiUVTransform() AI_NO_EXCEPT
-        :   mTranslation (0.0,0.0)
-        ,   mScaling    (1.0,1.0)
-        ,   mRotation   (0.0)
-    {
+            : mTranslation(0.0, 0.0),
+              mScaling(1.0, 1.0),
+              mRotation(0.0) {
         // nothing to be done here ...
     }
 #endif
-
 };
 
 #include "./Compiler/poppack1.h"
@@ -519,15 +555,14 @@ struct aiUVTransform
 /** @brief A very primitive RTTI system for the contents of material
  *  properties.
  */
-enum aiPropertyTypeInfo
-{
+enum aiPropertyTypeInfo {
     /** Array of single-precision (32 Bit) floats
      *
      *  It is possible to use aiGetMaterialInteger[Array]() (or the C++-API
      *  aiMaterial::Get()) to query properties stored in floating-point format.
      *  The material system performs the type conversion automatically.
     */
-    aiPTI_Float   = 0x1,
+    aiPTI_Float = 0x1,
 
     /** Array of double-precision (64 Bit) floats
      *
@@ -535,14 +570,14 @@ enum aiPropertyTypeInfo
      *  aiMaterial::Get()) to query properties stored in floating-point format.
      *  The material system performs the type conversion automatically.
     */
-    aiPTI_Double   = 0x2,
+    aiPTI_Double = 0x2,
 
     /** The material property is an aiString.
      *
      *  Arrays of strings aren't possible, aiGetMaterialString() (or the
      *  C++-API aiMaterial::Get()) *must* be used to query a string property.
     */
-    aiPTI_String  = 0x3,
+    aiPTI_String = 0x3,
 
     /** Array of (32 Bit) integers
      *
@@ -552,17 +587,15 @@ enum aiPropertyTypeInfo
     */
     aiPTI_Integer = 0x4,
 
-
     /** Simple binary buffer, content undefined. Not convertible to anything.
     */
-    aiPTI_Buffer  = 0x5,
+    aiPTI_Buffer = 0x5,
 
-
-     /** This value is not used. It is just there to force the
+/** This value is not used. It is just there to force the
      *  compiler to map this enum to a 32 Bit integer.
      */
 #ifndef SWIG
-     _aiPTI_Force32Bit = INT_MAX
+    _aiPTI_Force32Bit = INT_MAX
 #endif
 };
 
@@ -586,8 +619,7 @@ enum aiPropertyTypeInfo
  *  @endcode
  *  @see aiMaterial
  */
-struct aiMaterialProperty
-{
+struct aiMaterialProperty {
     /** Specifies the name of the property (key)
      *  Keys are generally case insensitive.
      */
@@ -621,20 +653,20 @@ struct aiMaterialProperty
     /** Binary buffer to hold the property's value.
      * The size of the buffer is always mDataLength.
      */
-    char* mData;
+    char *mData;
 
 #ifdef __cplusplus
 
     aiMaterialProperty() AI_NO_EXCEPT
-    : mSemantic( 0 )
-    , mIndex( 0 )
-    , mDataLength( 0 )
-    , mType( aiPTI_Float )
-    , mData(nullptr) {
+            : mSemantic(0),
+              mIndex(0),
+              mDataLength(0),
+              mType(aiPTI_Float),
+              mData(nullptr) {
         // empty
     }
 
-    ~aiMaterialProperty()   {
+    ~aiMaterialProperty() {
         delete[] mData;
         mData = nullptr;
     }
@@ -666,7 +698,6 @@ struct aiMaterial
 #ifdef __cplusplus
 
 public:
-
     aiMaterial();
     ~aiMaterial();
 
@@ -676,7 +707,7 @@ public:
       * @return The name of the material.
       */
     // -------------------------------------------------------------------
-    aiString GetName();
+    aiString GetName() const;
 
     // -------------------------------------------------------------------
     /** @brief Retrieve an array of Type values with a specific key
@@ -691,14 +722,14 @@ public:
      * NULL is a valid value for this parameter.
      */
     template <typename Type>
-    aiReturn Get(const char* pKey,unsigned int type,
-        unsigned int idx, Type* pOut, unsigned int* pMax) const;
+    aiReturn Get(const char *pKey, unsigned int type,
+            unsigned int idx, Type *pOut, unsigned int *pMax) const;
 
-    aiReturn Get(const char* pKey,unsigned int type,
-        unsigned int idx, int* pOut, unsigned int* pMax) const;
+    aiReturn Get(const char *pKey, unsigned int type,
+            unsigned int idx, int *pOut, unsigned int *pMax) const;
 
-    aiReturn Get(const char* pKey,unsigned int type,
-        unsigned int idx, ai_real* pOut, unsigned int* pMax) const;
+    aiReturn Get(const char *pKey, unsigned int type,
+            unsigned int idx, ai_real *pOut, unsigned int *pMax) const;
 
     // -------------------------------------------------------------------
     /** @brief Retrieve a Type value with a specific key
@@ -711,27 +742,26 @@ public:
      * @param pOut Reference to receive the output value
      */
     template <typename Type>
-    aiReturn Get(const char* pKey,unsigned int type,
-        unsigned int idx,Type& pOut) const;
+    aiReturn Get(const char *pKey, unsigned int type,
+            unsigned int idx, Type &pOut) const;
 
+    aiReturn Get(const char *pKey, unsigned int type,
+            unsigned int idx, int &pOut) const;
 
-    aiReturn Get(const char* pKey,unsigned int type,
-        unsigned int idx, int& pOut) const;
+    aiReturn Get(const char *pKey, unsigned int type,
+            unsigned int idx, ai_real &pOut) const;
 
-    aiReturn Get(const char* pKey,unsigned int type,
-        unsigned int idx, ai_real& pOut) const;
+    aiReturn Get(const char *pKey, unsigned int type,
+            unsigned int idx, aiString &pOut) const;
 
-    aiReturn Get(const char* pKey,unsigned int type,
-        unsigned int idx, aiString& pOut) const;
+    aiReturn Get(const char *pKey, unsigned int type,
+            unsigned int idx, aiColor3D &pOut) const;
 
-    aiReturn Get(const char* pKey,unsigned int type,
-        unsigned int idx, aiColor3D& pOut) const;
+    aiReturn Get(const char *pKey, unsigned int type,
+            unsigned int idx, aiColor4D &pOut) const;
 
-    aiReturn Get(const char* pKey,unsigned int type,
-        unsigned int idx, aiColor4D& pOut) const;
-
-    aiReturn Get(const char* pKey,unsigned int type,
-        unsigned int idx, aiUVTransform& pOut) const;
+    aiReturn Get(const char *pKey, unsigned int type,
+            unsigned int idx, aiUVTransform &pOut) const;
 
     // -------------------------------------------------------------------
     /** Get the number of textures for a particular texture type.
@@ -753,9 +783,9 @@ public:
      *    #GetTextureCount() can be used to determine the number of textures
      *    per texture type.
      *  @param path Receives the path to the texture.
-     *    If the texture is embedded, receives a '*' followed by the id of
-     *    the texture (for the textures stored in the corresponding scene) which
-     *    can be converted to an int using a function like atoi.
+     *    Use aiScene::GetEmbeddedTexture() method to determine if returned path
+     *    is an image file to be opened or a string key of embedded texture stored in the corresponding scene
+     *    (could be a '*' followed by the id of the texture in case of no name)
      *    NULL is a valid value.
      *  @param mapping The texture mapping.
      *    NULL is allowed as value.
@@ -772,18 +802,16 @@ public:
      */
     // -------------------------------------------------------------------
     aiReturn GetTexture(aiTextureType type,
-        unsigned int  index,
-        C_STRUCT aiString* path,
-        aiTextureMapping* mapping   = NULL,
-        unsigned int* uvindex       = NULL,
-        ai_real* blend              = NULL,
-        aiTextureOp* op             = NULL,
-        aiTextureMapMode* mapmode   = NULL) const;
-
+            unsigned int index,
+            C_STRUCT aiString *path,
+            aiTextureMapping *mapping = NULL,
+            unsigned int *uvindex = NULL,
+            ai_real *blend = NULL,
+            aiTextureOp *op = NULL,
+            aiTextureMapMode *mapmode = NULL) const;
 
     // Setters
 
-
     // ------------------------------------------------------------------------------
     /** @brief Add a property with a given key and type info to the material
      *  structure
@@ -794,12 +822,12 @@ public:
      *  @param type Set by the AI_MATKEY_XXX macro
      *  @param index Set by the AI_MATKEY_XXX macro
      *  @param pType Type information hint */
-    aiReturn AddBinaryProperty (const void* pInput,
-        unsigned int pSizeInBytes,
-        const char* pKey,
-        unsigned int type ,
-        unsigned int index ,
-        aiPropertyTypeInfo pType);
+    aiReturn AddBinaryProperty(const void *pInput,
+            unsigned int pSizeInBytes,
+            const char *pKey,
+            unsigned int type,
+            unsigned int index,
+            aiPropertyTypeInfo pType);
 
     // ------------------------------------------------------------------------------
     /** @brief Add a string property with a given key and type info to the
@@ -809,10 +837,10 @@ public:
      *  @param pKey Key/Usage of the property (AI_MATKEY_XXX)
      *  @param type Set by the AI_MATKEY_XXX macro
      *  @param index Set by the AI_MATKEY_XXX macro */
-    aiReturn AddProperty (const aiString* pInput,
-        const char* pKey,
-        unsigned int type  = 0,
-        unsigned int index = 0);
+    aiReturn AddProperty(const aiString *pInput,
+            const char *pKey,
+            unsigned int type = 0,
+            unsigned int index = 0);
 
     // ------------------------------------------------------------------------------
     /** @brief Add a property with a given key to the material structure
@@ -821,54 +849,54 @@ public:
      *  @param pKey Key/Usage of the property (AI_MATKEY_XXX)
      *  @param type Set by the AI_MATKEY_XXX macro
      *  @param index Set by the AI_MATKEY_XXX macro  */
-    template<class TYPE>
-    aiReturn AddProperty (const TYPE* pInput,
-        unsigned int pNumValues,
-        const char* pKey,
-        unsigned int type  = 0,
-        unsigned int index = 0);
+    template <class TYPE>
+    aiReturn AddProperty(const TYPE *pInput,
+            unsigned int pNumValues,
+            const char *pKey,
+            unsigned int type = 0,
+            unsigned int index = 0);
 
-    aiReturn AddProperty (const aiVector3D* pInput,
-        unsigned int pNumValues,
-        const char* pKey,
-        unsigned int type  = 0,
-        unsigned int index = 0);
+    aiReturn AddProperty(const aiVector3D *pInput,
+            unsigned int pNumValues,
+            const char *pKey,
+            unsigned int type = 0,
+            unsigned int index = 0);
 
-    aiReturn AddProperty (const aiColor3D* pInput,
-        unsigned int pNumValues,
-        const char* pKey,
-        unsigned int type  = 0,
-        unsigned int index = 0);
+    aiReturn AddProperty(const aiColor3D *pInput,
+            unsigned int pNumValues,
+            const char *pKey,
+            unsigned int type = 0,
+            unsigned int index = 0);
 
-    aiReturn AddProperty (const aiColor4D* pInput,
-        unsigned int pNumValues,
-        const char* pKey,
-        unsigned int type  = 0,
-        unsigned int index = 0);
+    aiReturn AddProperty(const aiColor4D *pInput,
+            unsigned int pNumValues,
+            const char *pKey,
+            unsigned int type = 0,
+            unsigned int index = 0);
 
-    aiReturn AddProperty (const int* pInput,
-        unsigned int pNumValues,
-        const char* pKey,
-        unsigned int type  = 0,
-        unsigned int index = 0);
+    aiReturn AddProperty(const int *pInput,
+            unsigned int pNumValues,
+            const char *pKey,
+            unsigned int type = 0,
+            unsigned int index = 0);
 
-    aiReturn AddProperty (const float* pInput,
-        unsigned int pNumValues,
-        const char* pKey,
-        unsigned int type  = 0,
-        unsigned int index = 0);
+    aiReturn AddProperty(const float *pInput,
+            unsigned int pNumValues,
+            const char *pKey,
+            unsigned int type = 0,
+            unsigned int index = 0);
 
-    aiReturn AddProperty (const double* pInput,
-        unsigned int pNumValues,
-        const char* pKey,
-        unsigned int type  = 0,
-        unsigned int index = 0);
+    aiReturn AddProperty(const double *pInput,
+            unsigned int pNumValues,
+            const char *pKey,
+            unsigned int type = 0,
+            unsigned int index = 0);
 
-    aiReturn AddProperty (const aiUVTransform* pInput,
-        unsigned int pNumValues,
-        const char* pKey,
-        unsigned int type  = 0,
-        unsigned int index = 0);
+    aiReturn AddProperty(const aiUVTransform *pInput,
+            unsigned int pNumValues,
+            const char *pKey,
+            unsigned int type = 0,
+            unsigned int index = 0);
 
     // ------------------------------------------------------------------------------
     /** @brief Remove a given key from the list.
@@ -877,9 +905,9 @@ public:
      *  @param pKey Key to be deleted
      *  @param type Set by the AI_MATKEY_XXX macro
      *  @param index Set by the AI_MATKEY_XXX macro  */
-    aiReturn RemoveProperty (const char* pKey,
-        unsigned int type  = 0,
-        unsigned int index = 0);
+    aiReturn RemoveProperty(const char *pKey,
+            unsigned int type = 0,
+            unsigned int index = 0);
 
     // ------------------------------------------------------------------------------
     /** @brief Removes all properties from the material.
@@ -892,19 +920,18 @@ public:
      *  @param pcDest Destination material
      *  @param pcSrc Source material
      */
-    static void CopyPropertyList(aiMaterial* pcDest,
-        const aiMaterial* pcSrc);
-
+    static void CopyPropertyList(aiMaterial *pcDest,
+            const aiMaterial *pcSrc);
 
 #endif
 
     /** List of all material properties loaded. */
-    C_STRUCT aiMaterialProperty** mProperties;
+    C_STRUCT aiMaterialProperty **mProperties;
 
     /** Number of properties in the data base */
     unsigned int mNumProperties;
 
-     /** Storage allocated */
+    /** Storage allocated */
     unsigned int mNumAllocated;
 };
 
@@ -914,443 +941,525 @@ extern "C" {
 #endif
 
 // ---------------------------------------------------------------------------
-#define AI_MATKEY_NAME "?mat.name",0,0
-#define AI_MATKEY_TWOSIDED "$mat.twosided",0,0
-#define AI_MATKEY_SHADING_MODEL "$mat.shadingm",0,0
-#define AI_MATKEY_ENABLE_WIREFRAME "$mat.wireframe",0,0
-#define AI_MATKEY_BLEND_FUNC "$mat.blend",0,0
-#define AI_MATKEY_OPACITY "$mat.opacity",0,0
-#define AI_MATKEY_TRANSPARENCYFACTOR "$mat.transparencyfactor",0,0
-#define AI_MATKEY_BUMPSCALING "$mat.bumpscaling",0,0
-#define AI_MATKEY_SHININESS "$mat.shininess",0,0
-#define AI_MATKEY_REFLECTIVITY "$mat.reflectivity",0,0
-#define AI_MATKEY_SHININESS_STRENGTH "$mat.shinpercent",0,0
-#define AI_MATKEY_REFRACTI "$mat.refracti",0,0
-#define AI_MATKEY_COLOR_DIFFUSE "$clr.diffuse",0,0
-#define AI_MATKEY_COLOR_AMBIENT "$clr.ambient",0,0
-#define AI_MATKEY_COLOR_SPECULAR "$clr.specular",0,0
-#define AI_MATKEY_COLOR_EMISSIVE "$clr.emissive",0,0
-#define AI_MATKEY_COLOR_TRANSPARENT "$clr.transparent",0,0
-#define AI_MATKEY_COLOR_REFLECTIVE "$clr.reflective",0,0
-#define AI_MATKEY_GLOBAL_BACKGROUND_IMAGE "?bg.global",0,0
-#define AI_MATKEY_GLOBAL_SHADERLANG "?sh.lang",0,0
-#define AI_MATKEY_SHADER_VERTEX "?sh.vs",0,0
-#define AI_MATKEY_SHADER_FRAGMENT "?sh.fs",0,0
-#define AI_MATKEY_SHADER_GEO "?sh.gs",0,0
-#define AI_MATKEY_SHADER_TESSELATION "?sh.ts",0,0
-#define AI_MATKEY_SHADER_PRIMITIVE "?sh.ps",0,0
-#define AI_MATKEY_SHADER_COMPUTE "?sh.cs",0,0
+#define AI_MATKEY_NAME "?mat.name", 0, 0
+#define AI_MATKEY_TWOSIDED "$mat.twosided", 0, 0
+#define AI_MATKEY_SHADING_MODEL "$mat.shadingm", 0, 0
+#define AI_MATKEY_ENABLE_WIREFRAME "$mat.wireframe", 0, 0
+#define AI_MATKEY_BLEND_FUNC "$mat.blend", 0, 0
+#define AI_MATKEY_OPACITY "$mat.opacity", 0, 0
+#define AI_MATKEY_TRANSPARENCYFACTOR "$mat.transparencyfactor", 0, 0
+#define AI_MATKEY_BUMPSCALING "$mat.bumpscaling", 0, 0
+#define AI_MATKEY_SHININESS "$mat.shininess", 0, 0
+#define AI_MATKEY_REFLECTIVITY "$mat.reflectivity", 0, 0
+#define AI_MATKEY_SHININESS_STRENGTH "$mat.shinpercent", 0, 0
+#define AI_MATKEY_REFRACTI "$mat.refracti", 0, 0
+#define AI_MATKEY_COLOR_DIFFUSE "$clr.diffuse", 0, 0
+#define AI_MATKEY_COLOR_AMBIENT "$clr.ambient", 0, 0
+#define AI_MATKEY_COLOR_SPECULAR "$clr.specular", 0, 0
+#define AI_MATKEY_COLOR_EMISSIVE "$clr.emissive", 0, 0
+#define AI_MATKEY_COLOR_TRANSPARENT "$clr.transparent", 0, 0
+#define AI_MATKEY_COLOR_REFLECTIVE "$clr.reflective", 0, 0
+#define AI_MATKEY_GLOBAL_BACKGROUND_IMAGE "?bg.global", 0, 0
+#define AI_MATKEY_GLOBAL_SHADERLANG "?sh.lang", 0, 0
+#define AI_MATKEY_SHADER_VERTEX "?sh.vs", 0, 0
+#define AI_MATKEY_SHADER_FRAGMENT "?sh.fs", 0, 0
+#define AI_MATKEY_SHADER_GEO "?sh.gs", 0, 0
+#define AI_MATKEY_SHADER_TESSELATION "?sh.ts", 0, 0
+#define AI_MATKEY_SHADER_PRIMITIVE "?sh.ps", 0, 0
+#define AI_MATKEY_SHADER_COMPUTE "?sh.cs", 0, 0
+
+// ---------------------------------------------------------------------------
+// PBR material support
+// --------------------
+// Properties defining PBR rendering techniques
+#define AI_MATKEY_USE_COLOR_MAP "$mat.useColorMap", 0, 0
+
+// Metallic/Roughness Workflow
+// ---------------------------
+// Base RGBA color factor. Will be multiplied by final base color texture values if extant
+// Note: Importers may choose to copy this into AI_MATKEY_COLOR_DIFFUSE for compatibility
+// with renderers and formats that do not support Metallic/Roughness PBR
+#define AI_MATKEY_BASE_COLOR "$clr.base", 0, 0
+#define AI_MATKEY_BASE_COLOR_TEXTURE aiTextureType_BASE_COLOR, 0
+#define AI_MATKEY_USE_METALLIC_MAP "$mat.useMetallicMap", 0, 0
+// Metallic factor. 0.0 = Full Dielectric, 1.0 = Full Metal
+#define AI_MATKEY_METALLIC_FACTOR "$mat.metallicFactor", 0, 0
+#define AI_MATKEY_METALLIC_TEXTURE aiTextureType_METALNESS, 0
+#define AI_MATKEY_USE_ROUGHNESS_MAP "$mat.useRoughnessMap", 0, 0
+// Roughness factor. 0.0 = Perfectly Smooth, 1.0 = Completely Rough
+#define AI_MATKEY_ROUGHNESS_FACTOR "$mat.roughnessFactor", 0, 0
+#define AI_MATKEY_ROUGHNESS_TEXTURE aiTextureType_DIFFUSE_ROUGHNESS, 0
+// Anisotropy factor. 0.0 = isotropic, 1.0 = anisotropy along tangent direction,
+// -1.0 = anisotropy along bitangent direction
+#define AI_MATKEY_ANISOTROPY_FACTOR "$mat.anisotropyFactor", 0, 0
+
+// Specular/Glossiness Workflow
+// ---------------------------
+// Diffuse/Albedo Color. Note: Pure Metals have a diffuse of {0,0,0}
+// AI_MATKEY_COLOR_DIFFUSE
+// Specular Color.
+// Note: Metallic/Roughness may also have a Specular Color
+// AI_MATKEY_COLOR_SPECULAR
+#define AI_MATKEY_SPECULAR_FACTOR "$mat.specularFactor", 0, 0
+// Glossiness factor. 0.0 = Completely Rough, 1.0 = Perfectly Smooth
+#define AI_MATKEY_GLOSSINESS_FACTOR "$mat.glossinessFactor", 0, 0
+
+// Sheen
+// -----
+// Sheen base RGB color. Default {0,0,0}
+#define AI_MATKEY_SHEEN_COLOR_FACTOR "$clr.sheen.factor", 0, 0
+// Sheen Roughness Factor.
+#define AI_MATKEY_SHEEN_ROUGHNESS_FACTOR "$mat.sheen.roughnessFactor", 0, 0
+#define AI_MATKEY_SHEEN_COLOR_TEXTURE aiTextureType_SHEEN, 0
+#define AI_MATKEY_SHEEN_ROUGHNESS_TEXTURE aiTextureType_SHEEN, 1
+
+// Clearcoat
+// ---------
+// Clearcoat layer intensity. 0.0 = none (disabled)
+#define AI_MATKEY_CLEARCOAT_FACTOR "$mat.clearcoat.factor", 0, 0
+#define AI_MATKEY_CLEARCOAT_ROUGHNESS_FACTOR "$mat.clearcoat.roughnessFactor", 0, 0
+#define AI_MATKEY_CLEARCOAT_TEXTURE aiTextureType_CLEARCOAT, 0
+#define AI_MATKEY_CLEARCOAT_ROUGHNESS_TEXTURE aiTextureType_CLEARCOAT, 1
+#define AI_MATKEY_CLEARCOAT_NORMAL_TEXTURE aiTextureType_CLEARCOAT, 2
+
+// Transmission
+// ------------
+// https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_transmission
+// Base percentage of light transmitted through the surface. 0.0 = Opaque, 1.0 = Fully transparent
+#define AI_MATKEY_TRANSMISSION_FACTOR "$mat.transmission.factor", 0, 0
+// Texture defining percentage of light transmitted through the surface.
+// Multiplied by AI_MATKEY_TRANSMISSION_FACTOR
+#define AI_MATKEY_TRANSMISSION_TEXTURE aiTextureType_TRANSMISSION, 0
+
+// Volume
+// ------------
+// https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_materials_volume
+// The thickness of the volume beneath the surface. If the value is 0 the material is thin-walled. Otherwise the material is a volume boundary.
+#define AI_MATKEY_VOLUME_THICKNESS_FACTOR "$mat.volume.thicknessFactor", 0, 0
+// Texture that defines the thickness.
+// Multiplied by AI_MATKEY_THICKNESS_FACTOR
+#define AI_MATKEY_VOLUME_THICKNESS_TEXTURE aiTextureType_TRANSMISSION, 1
+// Density of the medium given as the average distance that light travels in the medium before interacting with a particle.
+#define AI_MATKEY_VOLUME_ATTENUATION_DISTANCE "$mat.volume.attenuationDistance", 0, 0
+// The color that white light turns into due to absorption when reaching the attenuation distance.
+#define AI_MATKEY_VOLUME_ATTENUATION_COLOR "$mat.volume.attenuationColor", 0, 0
+
+// Emissive
+// --------
+#define AI_MATKEY_USE_EMISSIVE_MAP "$mat.useEmissiveMap", 0, 0
+#define AI_MATKEY_EMISSIVE_INTENSITY "$mat.emissiveIntensity", 0, 0
+#define AI_MATKEY_USE_AO_MAP "$mat.useAOMap", 0, 0
 
 // ---------------------------------------------------------------------------
 // Pure key names for all texture-related properties
 //! @cond MATS_DOC_FULL
-#define _AI_MATKEY_TEXTURE_BASE         "$tex.file"
-#define _AI_MATKEY_UVWSRC_BASE          "$tex.uvwsrc"
-#define _AI_MATKEY_TEXOP_BASE           "$tex.op"
-#define _AI_MATKEY_MAPPING_BASE         "$tex.mapping"
-#define _AI_MATKEY_TEXBLEND_BASE        "$tex.blend"
-#define _AI_MATKEY_MAPPINGMODE_U_BASE   "$tex.mapmodeu"
-#define _AI_MATKEY_MAPPINGMODE_V_BASE   "$tex.mapmodev"
-#define _AI_MATKEY_TEXMAP_AXIS_BASE     "$tex.mapaxis"
-#define _AI_MATKEY_UVTRANSFORM_BASE     "$tex.uvtrafo"
-#define _AI_MATKEY_TEXFLAGS_BASE        "$tex.flags"
+#define _AI_MATKEY_TEXTURE_BASE "$tex.file"
+#define _AI_MATKEY_UVWSRC_BASE "$tex.uvwsrc"
+#define _AI_MATKEY_TEXOP_BASE "$tex.op"
+#define _AI_MATKEY_MAPPING_BASE "$tex.mapping"
+#define _AI_MATKEY_TEXBLEND_BASE "$tex.blend"
+#define _AI_MATKEY_MAPPINGMODE_U_BASE "$tex.mapmodeu"
+#define _AI_MATKEY_MAPPINGMODE_V_BASE "$tex.mapmodev"
+#define _AI_MATKEY_TEXMAP_AXIS_BASE "$tex.mapaxis"
+#define _AI_MATKEY_UVTRANSFORM_BASE "$tex.uvtrafo"
+#define _AI_MATKEY_TEXFLAGS_BASE "$tex.flags"
 //! @endcond
 
 // ---------------------------------------------------------------------------
-#define AI_MATKEY_TEXTURE(type, N) _AI_MATKEY_TEXTURE_BASE,type,N
+#define AI_MATKEY_TEXTURE(type, N) _AI_MATKEY_TEXTURE_BASE, type, N
 
 // For backward compatibility and simplicity
 //! @cond MATS_DOC_FULL
-#define AI_MATKEY_TEXTURE_DIFFUSE(N)    \
-    AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE,N)
+#define AI_MATKEY_TEXTURE_DIFFUSE(N) \
+    AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE, N)
 
-#define AI_MATKEY_TEXTURE_SPECULAR(N)   \
-    AI_MATKEY_TEXTURE(aiTextureType_SPECULAR,N)
+#define AI_MATKEY_TEXTURE_SPECULAR(N) \
+    AI_MATKEY_TEXTURE(aiTextureType_SPECULAR, N)
 
-#define AI_MATKEY_TEXTURE_AMBIENT(N)    \
-    AI_MATKEY_TEXTURE(aiTextureType_AMBIENT,N)
+#define AI_MATKEY_TEXTURE_AMBIENT(N) \
+    AI_MATKEY_TEXTURE(aiTextureType_AMBIENT, N)
 
-#define AI_MATKEY_TEXTURE_EMISSIVE(N)   \
-    AI_MATKEY_TEXTURE(aiTextureType_EMISSIVE,N)
+#define AI_MATKEY_TEXTURE_EMISSIVE(N) \
+    AI_MATKEY_TEXTURE(aiTextureType_EMISSIVE, N)
 
-#define AI_MATKEY_TEXTURE_NORMALS(N)    \
-    AI_MATKEY_TEXTURE(aiTextureType_NORMALS,N)
+#define AI_MATKEY_TEXTURE_NORMALS(N) \
+    AI_MATKEY_TEXTURE(aiTextureType_NORMALS, N)
 
 #define AI_MATKEY_TEXTURE_HEIGHT(N) \
-    AI_MATKEY_TEXTURE(aiTextureType_HEIGHT,N)
+    AI_MATKEY_TEXTURE(aiTextureType_HEIGHT, N)
 
-#define AI_MATKEY_TEXTURE_SHININESS(N)  \
-    AI_MATKEY_TEXTURE(aiTextureType_SHININESS,N)
+#define AI_MATKEY_TEXTURE_SHININESS(N) \
+    AI_MATKEY_TEXTURE(aiTextureType_SHININESS, N)
 
-#define AI_MATKEY_TEXTURE_OPACITY(N)    \
-    AI_MATKEY_TEXTURE(aiTextureType_OPACITY,N)
+#define AI_MATKEY_TEXTURE_OPACITY(N) \
+    AI_MATKEY_TEXTURE(aiTextureType_OPACITY, N)
 
-#define AI_MATKEY_TEXTURE_DISPLACEMENT(N)   \
-    AI_MATKEY_TEXTURE(aiTextureType_DISPLACEMENT,N)
+#define AI_MATKEY_TEXTURE_DISPLACEMENT(N) \
+    AI_MATKEY_TEXTURE(aiTextureType_DISPLACEMENT, N)
 
-#define AI_MATKEY_TEXTURE_LIGHTMAP(N)   \
-    AI_MATKEY_TEXTURE(aiTextureType_LIGHTMAP,N)
+#define AI_MATKEY_TEXTURE_LIGHTMAP(N) \
+    AI_MATKEY_TEXTURE(aiTextureType_LIGHTMAP, N)
 
 #define AI_MATKEY_TEXTURE_REFLECTION(N) \
-    AI_MATKEY_TEXTURE(aiTextureType_REFLECTION,N)
+    AI_MATKEY_TEXTURE(aiTextureType_REFLECTION, N)
 
 //! @endcond
 
 // ---------------------------------------------------------------------------
-#define AI_MATKEY_UVWSRC(type, N) _AI_MATKEY_UVWSRC_BASE,type,N
+#define AI_MATKEY_UVWSRC(type, N) _AI_MATKEY_UVWSRC_BASE, type, N
 
 // For backward compatibility and simplicity
 //! @cond MATS_DOC_FULL
 #define AI_MATKEY_UVWSRC_DIFFUSE(N) \
-    AI_MATKEY_UVWSRC(aiTextureType_DIFFUSE,N)
+    AI_MATKEY_UVWSRC(aiTextureType_DIFFUSE, N)
 
-#define AI_MATKEY_UVWSRC_SPECULAR(N)    \
-    AI_MATKEY_UVWSRC(aiTextureType_SPECULAR,N)
+#define AI_MATKEY_UVWSRC_SPECULAR(N) \
+    AI_MATKEY_UVWSRC(aiTextureType_SPECULAR, N)
 
 #define AI_MATKEY_UVWSRC_AMBIENT(N) \
-    AI_MATKEY_UVWSRC(aiTextureType_AMBIENT,N)
+    AI_MATKEY_UVWSRC(aiTextureType_AMBIENT, N)
 
-#define AI_MATKEY_UVWSRC_EMISSIVE(N)    \
-    AI_MATKEY_UVWSRC(aiTextureType_EMISSIVE,N)
+#define AI_MATKEY_UVWSRC_EMISSIVE(N) \
+    AI_MATKEY_UVWSRC(aiTextureType_EMISSIVE, N)
 
 #define AI_MATKEY_UVWSRC_NORMALS(N) \
-    AI_MATKEY_UVWSRC(aiTextureType_NORMALS,N)
+    AI_MATKEY_UVWSRC(aiTextureType_NORMALS, N)
 
-#define AI_MATKEY_UVWSRC_HEIGHT(N)  \
-    AI_MATKEY_UVWSRC(aiTextureType_HEIGHT,N)
+#define AI_MATKEY_UVWSRC_HEIGHT(N) \
+    AI_MATKEY_UVWSRC(aiTextureType_HEIGHT, N)
 
-#define AI_MATKEY_UVWSRC_SHININESS(N)   \
-    AI_MATKEY_UVWSRC(aiTextureType_SHININESS,N)
+#define AI_MATKEY_UVWSRC_SHININESS(N) \
+    AI_MATKEY_UVWSRC(aiTextureType_SHININESS, N)
 
 #define AI_MATKEY_UVWSRC_OPACITY(N) \
-    AI_MATKEY_UVWSRC(aiTextureType_OPACITY,N)
+    AI_MATKEY_UVWSRC(aiTextureType_OPACITY, N)
 
-#define AI_MATKEY_UVWSRC_DISPLACEMENT(N)    \
-    AI_MATKEY_UVWSRC(aiTextureType_DISPLACEMENT,N)
+#define AI_MATKEY_UVWSRC_DISPLACEMENT(N) \
+    AI_MATKEY_UVWSRC(aiTextureType_DISPLACEMENT, N)
 
-#define AI_MATKEY_UVWSRC_LIGHTMAP(N)    \
-    AI_MATKEY_UVWSRC(aiTextureType_LIGHTMAP,N)
+#define AI_MATKEY_UVWSRC_LIGHTMAP(N) \
+    AI_MATKEY_UVWSRC(aiTextureType_LIGHTMAP, N)
 
-#define AI_MATKEY_UVWSRC_REFLECTION(N)  \
-    AI_MATKEY_UVWSRC(aiTextureType_REFLECTION,N)
+#define AI_MATKEY_UVWSRC_REFLECTION(N) \
+    AI_MATKEY_UVWSRC(aiTextureType_REFLECTION, N)
 
 //! @endcond
 // ---------------------------------------------------------------------------
-#define AI_MATKEY_TEXOP(type, N) _AI_MATKEY_TEXOP_BASE,type,N
+#define AI_MATKEY_TEXOP(type, N) _AI_MATKEY_TEXOP_BASE, type, N
 
 // For backward compatibility and simplicity
 //! @cond MATS_DOC_FULL
-#define AI_MATKEY_TEXOP_DIFFUSE(N)  \
-    AI_MATKEY_TEXOP(aiTextureType_DIFFUSE,N)
+#define AI_MATKEY_TEXOP_DIFFUSE(N) \
+    AI_MATKEY_TEXOP(aiTextureType_DIFFUSE, N)
 
 #define AI_MATKEY_TEXOP_SPECULAR(N) \
-    AI_MATKEY_TEXOP(aiTextureType_SPECULAR,N)
+    AI_MATKEY_TEXOP(aiTextureType_SPECULAR, N)
 
-#define AI_MATKEY_TEXOP_AMBIENT(N)  \
-    AI_MATKEY_TEXOP(aiTextureType_AMBIENT,N)
+#define AI_MATKEY_TEXOP_AMBIENT(N) \
+    AI_MATKEY_TEXOP(aiTextureType_AMBIENT, N)
 
 #define AI_MATKEY_TEXOP_EMISSIVE(N) \
-    AI_MATKEY_TEXOP(aiTextureType_EMISSIVE,N)
+    AI_MATKEY_TEXOP(aiTextureType_EMISSIVE, N)
 
-#define AI_MATKEY_TEXOP_NORMALS(N)  \
-    AI_MATKEY_TEXOP(aiTextureType_NORMALS,N)
+#define AI_MATKEY_TEXOP_NORMALS(N) \
+    AI_MATKEY_TEXOP(aiTextureType_NORMALS, N)
 
-#define AI_MATKEY_TEXOP_HEIGHT(N)   \
-    AI_MATKEY_TEXOP(aiTextureType_HEIGHT,N)
+#define AI_MATKEY_TEXOP_HEIGHT(N) \
+    AI_MATKEY_TEXOP(aiTextureType_HEIGHT, N)
 
-#define AI_MATKEY_TEXOP_SHININESS(N)    \
-    AI_MATKEY_TEXOP(aiTextureType_SHININESS,N)
+#define AI_MATKEY_TEXOP_SHININESS(N) \
+    AI_MATKEY_TEXOP(aiTextureType_SHININESS, N)
 
-#define AI_MATKEY_TEXOP_OPACITY(N)  \
-    AI_MATKEY_TEXOP(aiTextureType_OPACITY,N)
+#define AI_MATKEY_TEXOP_OPACITY(N) \
+    AI_MATKEY_TEXOP(aiTextureType_OPACITY, N)
 
 #define AI_MATKEY_TEXOP_DISPLACEMENT(N) \
-    AI_MATKEY_TEXOP(aiTextureType_DISPLACEMENT,N)
+    AI_MATKEY_TEXOP(aiTextureType_DISPLACEMENT, N)
 
 #define AI_MATKEY_TEXOP_LIGHTMAP(N) \
-    AI_MATKEY_TEXOP(aiTextureType_LIGHTMAP,N)
+    AI_MATKEY_TEXOP(aiTextureType_LIGHTMAP, N)
 
-#define AI_MATKEY_TEXOP_REFLECTION(N)   \
-    AI_MATKEY_TEXOP(aiTextureType_REFLECTION,N)
+#define AI_MATKEY_TEXOP_REFLECTION(N) \
+    AI_MATKEY_TEXOP(aiTextureType_REFLECTION, N)
 
 //! @endcond
 // ---------------------------------------------------------------------------
-#define AI_MATKEY_MAPPING(type, N) _AI_MATKEY_MAPPING_BASE,type,N
+#define AI_MATKEY_MAPPING(type, N) _AI_MATKEY_MAPPING_BASE, type, N
 
 // For backward compatibility and simplicity
 //! @cond MATS_DOC_FULL
-#define AI_MATKEY_MAPPING_DIFFUSE(N)    \
-    AI_MATKEY_MAPPING(aiTextureType_DIFFUSE,N)
+#define AI_MATKEY_MAPPING_DIFFUSE(N) \
+    AI_MATKEY_MAPPING(aiTextureType_DIFFUSE, N)
 
-#define AI_MATKEY_MAPPING_SPECULAR(N)   \
-    AI_MATKEY_MAPPING(aiTextureType_SPECULAR,N)
+#define AI_MATKEY_MAPPING_SPECULAR(N) \
+    AI_MATKEY_MAPPING(aiTextureType_SPECULAR, N)
 
-#define AI_MATKEY_MAPPING_AMBIENT(N)    \
-    AI_MATKEY_MAPPING(aiTextureType_AMBIENT,N)
+#define AI_MATKEY_MAPPING_AMBIENT(N) \
+    AI_MATKEY_MAPPING(aiTextureType_AMBIENT, N)
 
-#define AI_MATKEY_MAPPING_EMISSIVE(N)   \
-    AI_MATKEY_MAPPING(aiTextureType_EMISSIVE,N)
+#define AI_MATKEY_MAPPING_EMISSIVE(N) \
+    AI_MATKEY_MAPPING(aiTextureType_EMISSIVE, N)
 
-#define AI_MATKEY_MAPPING_NORMALS(N)    \
-    AI_MATKEY_MAPPING(aiTextureType_NORMALS,N)
+#define AI_MATKEY_MAPPING_NORMALS(N) \
+    AI_MATKEY_MAPPING(aiTextureType_NORMALS, N)
 
 #define AI_MATKEY_MAPPING_HEIGHT(N) \
-    AI_MATKEY_MAPPING(aiTextureType_HEIGHT,N)
+    AI_MATKEY_MAPPING(aiTextureType_HEIGHT, N)
 
-#define AI_MATKEY_MAPPING_SHININESS(N)  \
-    AI_MATKEY_MAPPING(aiTextureType_SHININESS,N)
+#define AI_MATKEY_MAPPING_SHININESS(N) \
+    AI_MATKEY_MAPPING(aiTextureType_SHININESS, N)
 
-#define AI_MATKEY_MAPPING_OPACITY(N)    \
-    AI_MATKEY_MAPPING(aiTextureType_OPACITY,N)
+#define AI_MATKEY_MAPPING_OPACITY(N) \
+    AI_MATKEY_MAPPING(aiTextureType_OPACITY, N)
 
-#define AI_MATKEY_MAPPING_DISPLACEMENT(N)   \
-    AI_MATKEY_MAPPING(aiTextureType_DISPLACEMENT,N)
+#define AI_MATKEY_MAPPING_DISPLACEMENT(N) \
+    AI_MATKEY_MAPPING(aiTextureType_DISPLACEMENT, N)
 
-#define AI_MATKEY_MAPPING_LIGHTMAP(N)   \
-    AI_MATKEY_MAPPING(aiTextureType_LIGHTMAP,N)
+#define AI_MATKEY_MAPPING_LIGHTMAP(N) \
+    AI_MATKEY_MAPPING(aiTextureType_LIGHTMAP, N)
 
 #define AI_MATKEY_MAPPING_REFLECTION(N) \
-    AI_MATKEY_MAPPING(aiTextureType_REFLECTION,N)
+    AI_MATKEY_MAPPING(aiTextureType_REFLECTION, N)
 
 //! @endcond
 // ---------------------------------------------------------------------------
-#define AI_MATKEY_TEXBLEND(type, N) _AI_MATKEY_TEXBLEND_BASE,type,N
+#define AI_MATKEY_TEXBLEND(type, N) _AI_MATKEY_TEXBLEND_BASE, type, N
 
 // For backward compatibility and simplicity
 //! @cond MATS_DOC_FULL
-#define AI_MATKEY_TEXBLEND_DIFFUSE(N)   \
-    AI_MATKEY_TEXBLEND(aiTextureType_DIFFUSE,N)
+#define AI_MATKEY_TEXBLEND_DIFFUSE(N) \
+    AI_MATKEY_TEXBLEND(aiTextureType_DIFFUSE, N)
 
-#define AI_MATKEY_TEXBLEND_SPECULAR(N)  \
-    AI_MATKEY_TEXBLEND(aiTextureType_SPECULAR,N)
+#define AI_MATKEY_TEXBLEND_SPECULAR(N) \
+    AI_MATKEY_TEXBLEND(aiTextureType_SPECULAR, N)
 
-#define AI_MATKEY_TEXBLEND_AMBIENT(N)   \
-    AI_MATKEY_TEXBLEND(aiTextureType_AMBIENT,N)
+#define AI_MATKEY_TEXBLEND_AMBIENT(N) \
+    AI_MATKEY_TEXBLEND(aiTextureType_AMBIENT, N)
 
-#define AI_MATKEY_TEXBLEND_EMISSIVE(N)  \
-    AI_MATKEY_TEXBLEND(aiTextureType_EMISSIVE,N)
+#define AI_MATKEY_TEXBLEND_EMISSIVE(N) \
+    AI_MATKEY_TEXBLEND(aiTextureType_EMISSIVE, N)
 
-#define AI_MATKEY_TEXBLEND_NORMALS(N)   \
-    AI_MATKEY_TEXBLEND(aiTextureType_NORMALS,N)
+#define AI_MATKEY_TEXBLEND_NORMALS(N) \
+    AI_MATKEY_TEXBLEND(aiTextureType_NORMALS, N)
 
-#define AI_MATKEY_TEXBLEND_HEIGHT(N)    \
-    AI_MATKEY_TEXBLEND(aiTextureType_HEIGHT,N)
+#define AI_MATKEY_TEXBLEND_HEIGHT(N) \
+    AI_MATKEY_TEXBLEND(aiTextureType_HEIGHT, N)
 
 #define AI_MATKEY_TEXBLEND_SHININESS(N) \
-    AI_MATKEY_TEXBLEND(aiTextureType_SHININESS,N)
+    AI_MATKEY_TEXBLEND(aiTextureType_SHININESS, N)
 
-#define AI_MATKEY_TEXBLEND_OPACITY(N)   \
-    AI_MATKEY_TEXBLEND(aiTextureType_OPACITY,N)
+#define AI_MATKEY_TEXBLEND_OPACITY(N) \
+    AI_MATKEY_TEXBLEND(aiTextureType_OPACITY, N)
 
-#define AI_MATKEY_TEXBLEND_DISPLACEMENT(N)  \
-    AI_MATKEY_TEXBLEND(aiTextureType_DISPLACEMENT,N)
+#define AI_MATKEY_TEXBLEND_DISPLACEMENT(N) \
+    AI_MATKEY_TEXBLEND(aiTextureType_DISPLACEMENT, N)
 
-#define AI_MATKEY_TEXBLEND_LIGHTMAP(N)  \
-    AI_MATKEY_TEXBLEND(aiTextureType_LIGHTMAP,N)
+#define AI_MATKEY_TEXBLEND_LIGHTMAP(N) \
+    AI_MATKEY_TEXBLEND(aiTextureType_LIGHTMAP, N)
 
-#define AI_MATKEY_TEXBLEND_REFLECTION(N)    \
-    AI_MATKEY_TEXBLEND(aiTextureType_REFLECTION,N)
+#define AI_MATKEY_TEXBLEND_REFLECTION(N) \
+    AI_MATKEY_TEXBLEND(aiTextureType_REFLECTION, N)
 
 //! @endcond
 // ---------------------------------------------------------------------------
-#define AI_MATKEY_MAPPINGMODE_U(type, N) _AI_MATKEY_MAPPINGMODE_U_BASE,type,N
+#define AI_MATKEY_MAPPINGMODE_U(type, N) _AI_MATKEY_MAPPINGMODE_U_BASE, type, N
 
 // For backward compatibility and simplicity
 //! @cond MATS_DOC_FULL
-#define AI_MATKEY_MAPPINGMODE_U_DIFFUSE(N)  \
-    AI_MATKEY_MAPPINGMODE_U(aiTextureType_DIFFUSE,N)
+#define AI_MATKEY_MAPPINGMODE_U_DIFFUSE(N) \
+    AI_MATKEY_MAPPINGMODE_U(aiTextureType_DIFFUSE, N)
 
 #define AI_MATKEY_MAPPINGMODE_U_SPECULAR(N) \
-    AI_MATKEY_MAPPINGMODE_U(aiTextureType_SPECULAR,N)
+    AI_MATKEY_MAPPINGMODE_U(aiTextureType_SPECULAR, N)
 
-#define AI_MATKEY_MAPPINGMODE_U_AMBIENT(N)  \
-    AI_MATKEY_MAPPINGMODE_U(aiTextureType_AMBIENT,N)
+#define AI_MATKEY_MAPPINGMODE_U_AMBIENT(N) \
+    AI_MATKEY_MAPPINGMODE_U(aiTextureType_AMBIENT, N)
 
 #define AI_MATKEY_MAPPINGMODE_U_EMISSIVE(N) \
-    AI_MATKEY_MAPPINGMODE_U(aiTextureType_EMISSIVE,N)
+    AI_MATKEY_MAPPINGMODE_U(aiTextureType_EMISSIVE, N)
 
-#define AI_MATKEY_MAPPINGMODE_U_NORMALS(N)  \
-    AI_MATKEY_MAPPINGMODE_U(aiTextureType_NORMALS,N)
+#define AI_MATKEY_MAPPINGMODE_U_NORMALS(N) \
+    AI_MATKEY_MAPPINGMODE_U(aiTextureType_NORMALS, N)
 
-#define AI_MATKEY_MAPPINGMODE_U_HEIGHT(N)   \
-    AI_MATKEY_MAPPINGMODE_U(aiTextureType_HEIGHT,N)
+#define AI_MATKEY_MAPPINGMODE_U_HEIGHT(N) \
+    AI_MATKEY_MAPPINGMODE_U(aiTextureType_HEIGHT, N)
 
-#define AI_MATKEY_MAPPINGMODE_U_SHININESS(N)    \
-    AI_MATKEY_MAPPINGMODE_U(aiTextureType_SHININESS,N)
+#define AI_MATKEY_MAPPINGMODE_U_SHININESS(N) \
+    AI_MATKEY_MAPPINGMODE_U(aiTextureType_SHININESS, N)
 
-#define AI_MATKEY_MAPPINGMODE_U_OPACITY(N)  \
-    AI_MATKEY_MAPPINGMODE_U(aiTextureType_OPACITY,N)
+#define AI_MATKEY_MAPPINGMODE_U_OPACITY(N) \
+    AI_MATKEY_MAPPINGMODE_U(aiTextureType_OPACITY, N)
 
 #define AI_MATKEY_MAPPINGMODE_U_DISPLACEMENT(N) \
-    AI_MATKEY_MAPPINGMODE_U(aiTextureType_DISPLACEMENT,N)
+    AI_MATKEY_MAPPINGMODE_U(aiTextureType_DISPLACEMENT, N)
 
 #define AI_MATKEY_MAPPINGMODE_U_LIGHTMAP(N) \
-    AI_MATKEY_MAPPINGMODE_U(aiTextureType_LIGHTMAP,N)
+    AI_MATKEY_MAPPINGMODE_U(aiTextureType_LIGHTMAP, N)
 
-#define AI_MATKEY_MAPPINGMODE_U_REFLECTION(N)   \
-    AI_MATKEY_MAPPINGMODE_U(aiTextureType_REFLECTION,N)
+#define AI_MATKEY_MAPPINGMODE_U_REFLECTION(N) \
+    AI_MATKEY_MAPPINGMODE_U(aiTextureType_REFLECTION, N)
 
 //! @endcond
 // ---------------------------------------------------------------------------
-#define AI_MATKEY_MAPPINGMODE_V(type, N) _AI_MATKEY_MAPPINGMODE_V_BASE,type,N
+#define AI_MATKEY_MAPPINGMODE_V(type, N) _AI_MATKEY_MAPPINGMODE_V_BASE, type, N
 
 // For backward compatibility and simplicity
 //! @cond MATS_DOC_FULL
-#define AI_MATKEY_MAPPINGMODE_V_DIFFUSE(N)  \
-    AI_MATKEY_MAPPINGMODE_V(aiTextureType_DIFFUSE,N)
+#define AI_MATKEY_MAPPINGMODE_V_DIFFUSE(N) \
+    AI_MATKEY_MAPPINGMODE_V(aiTextureType_DIFFUSE, N)
 
 #define AI_MATKEY_MAPPINGMODE_V_SPECULAR(N) \
-    AI_MATKEY_MAPPINGMODE_V(aiTextureType_SPECULAR,N)
+    AI_MATKEY_MAPPINGMODE_V(aiTextureType_SPECULAR, N)
 
-#define AI_MATKEY_MAPPINGMODE_V_AMBIENT(N)  \
-    AI_MATKEY_MAPPINGMODE_V(aiTextureType_AMBIENT,N)
+#define AI_MATKEY_MAPPINGMODE_V_AMBIENT(N) \
+    AI_MATKEY_MAPPINGMODE_V(aiTextureType_AMBIENT, N)
 
 #define AI_MATKEY_MAPPINGMODE_V_EMISSIVE(N) \
-    AI_MATKEY_MAPPINGMODE_V(aiTextureType_EMISSIVE,N)
+    AI_MATKEY_MAPPINGMODE_V(aiTextureType_EMISSIVE, N)
 
-#define AI_MATKEY_MAPPINGMODE_V_NORMALS(N)  \
-    AI_MATKEY_MAPPINGMODE_V(aiTextureType_NORMALS,N)
+#define AI_MATKEY_MAPPINGMODE_V_NORMALS(N) \
+    AI_MATKEY_MAPPINGMODE_V(aiTextureType_NORMALS, N)
 
-#define AI_MATKEY_MAPPINGMODE_V_HEIGHT(N)   \
-    AI_MATKEY_MAPPINGMODE_V(aiTextureType_HEIGHT,N)
+#define AI_MATKEY_MAPPINGMODE_V_HEIGHT(N) \
+    AI_MATKEY_MAPPINGMODE_V(aiTextureType_HEIGHT, N)
 
-#define AI_MATKEY_MAPPINGMODE_V_SHININESS(N)    \
-    AI_MATKEY_MAPPINGMODE_V(aiTextureType_SHININESS,N)
+#define AI_MATKEY_MAPPINGMODE_V_SHININESS(N) \
+    AI_MATKEY_MAPPINGMODE_V(aiTextureType_SHININESS, N)
 
-#define AI_MATKEY_MAPPINGMODE_V_OPACITY(N)  \
-    AI_MATKEY_MAPPINGMODE_V(aiTextureType_OPACITY,N)
+#define AI_MATKEY_MAPPINGMODE_V_OPACITY(N) \
+    AI_MATKEY_MAPPINGMODE_V(aiTextureType_OPACITY, N)
 
 #define AI_MATKEY_MAPPINGMODE_V_DISPLACEMENT(N) \
-    AI_MATKEY_MAPPINGMODE_V(aiTextureType_DISPLACEMENT,N)
+    AI_MATKEY_MAPPINGMODE_V(aiTextureType_DISPLACEMENT, N)
 
 #define AI_MATKEY_MAPPINGMODE_V_LIGHTMAP(N) \
-    AI_MATKEY_MAPPINGMODE_V(aiTextureType_LIGHTMAP,N)
+    AI_MATKEY_MAPPINGMODE_V(aiTextureType_LIGHTMAP, N)
 
-#define AI_MATKEY_MAPPINGMODE_V_REFLECTION(N)   \
-    AI_MATKEY_MAPPINGMODE_V(aiTextureType_REFLECTION,N)
+#define AI_MATKEY_MAPPINGMODE_V_REFLECTION(N) \
+    AI_MATKEY_MAPPINGMODE_V(aiTextureType_REFLECTION, N)
 
 //! @endcond
 // ---------------------------------------------------------------------------
-#define AI_MATKEY_TEXMAP_AXIS(type, N) _AI_MATKEY_TEXMAP_AXIS_BASE,type,N
+#define AI_MATKEY_TEXMAP_AXIS(type, N) _AI_MATKEY_TEXMAP_AXIS_BASE, type, N
 
 // For backward compatibility and simplicity
 //! @cond MATS_DOC_FULL
-#define AI_MATKEY_TEXMAP_AXIS_DIFFUSE(N)    \
-    AI_MATKEY_TEXMAP_AXIS(aiTextureType_DIFFUSE,N)
+#define AI_MATKEY_TEXMAP_AXIS_DIFFUSE(N) \
+    AI_MATKEY_TEXMAP_AXIS(aiTextureType_DIFFUSE, N)
 
-#define AI_MATKEY_TEXMAP_AXIS_SPECULAR(N)   \
-    AI_MATKEY_TEXMAP_AXIS(aiTextureType_SPECULAR,N)
+#define AI_MATKEY_TEXMAP_AXIS_SPECULAR(N) \
+    AI_MATKEY_TEXMAP_AXIS(aiTextureType_SPECULAR, N)
 
-#define AI_MATKEY_TEXMAP_AXIS_AMBIENT(N)    \
-    AI_MATKEY_TEXMAP_AXIS(aiTextureType_AMBIENT,N)
+#define AI_MATKEY_TEXMAP_AXIS_AMBIENT(N) \
+    AI_MATKEY_TEXMAP_AXIS(aiTextureType_AMBIENT, N)
 
-#define AI_MATKEY_TEXMAP_AXIS_EMISSIVE(N)   \
-    AI_MATKEY_TEXMAP_AXIS(aiTextureType_EMISSIVE,N)
+#define AI_MATKEY_TEXMAP_AXIS_EMISSIVE(N) \
+    AI_MATKEY_TEXMAP_AXIS(aiTextureType_EMISSIVE, N)
 
-#define AI_MATKEY_TEXMAP_AXIS_NORMALS(N)    \
-    AI_MATKEY_TEXMAP_AXIS(aiTextureType_NORMALS,N)
+#define AI_MATKEY_TEXMAP_AXIS_NORMALS(N) \
+    AI_MATKEY_TEXMAP_AXIS(aiTextureType_NORMALS, N)
 
 #define AI_MATKEY_TEXMAP_AXIS_HEIGHT(N) \
-    AI_MATKEY_TEXMAP_AXIS(aiTextureType_HEIGHT,N)
+    AI_MATKEY_TEXMAP_AXIS(aiTextureType_HEIGHT, N)
 
-#define AI_MATKEY_TEXMAP_AXIS_SHININESS(N)  \
-    AI_MATKEY_TEXMAP_AXIS(aiTextureType_SHININESS,N)
+#define AI_MATKEY_TEXMAP_AXIS_SHININESS(N) \
+    AI_MATKEY_TEXMAP_AXIS(aiTextureType_SHININESS, N)
 
-#define AI_MATKEY_TEXMAP_AXIS_OPACITY(N)    \
-    AI_MATKEY_TEXMAP_AXIS(aiTextureType_OPACITY,N)
+#define AI_MATKEY_TEXMAP_AXIS_OPACITY(N) \
+    AI_MATKEY_TEXMAP_AXIS(aiTextureType_OPACITY, N)
 
-#define AI_MATKEY_TEXMAP_AXIS_DISPLACEMENT(N)   \
-    AI_MATKEY_TEXMAP_AXIS(aiTextureType_DISPLACEMENT,N)
+#define AI_MATKEY_TEXMAP_AXIS_DISPLACEMENT(N) \
+    AI_MATKEY_TEXMAP_AXIS(aiTextureType_DISPLACEMENT, N)
 
-#define AI_MATKEY_TEXMAP_AXIS_LIGHTMAP(N)   \
-    AI_MATKEY_TEXMAP_AXIS(aiTextureType_LIGHTMAP,N)
+#define AI_MATKEY_TEXMAP_AXIS_LIGHTMAP(N) \
+    AI_MATKEY_TEXMAP_AXIS(aiTextureType_LIGHTMAP, N)
 
 #define AI_MATKEY_TEXMAP_AXIS_REFLECTION(N) \
-    AI_MATKEY_TEXMAP_AXIS(aiTextureType_REFLECTION,N)
+    AI_MATKEY_TEXMAP_AXIS(aiTextureType_REFLECTION, N)
 
 //! @endcond
 // ---------------------------------------------------------------------------
-#define AI_MATKEY_UVTRANSFORM(type, N) _AI_MATKEY_UVTRANSFORM_BASE,type,N
+#define AI_MATKEY_UVTRANSFORM(type, N) _AI_MATKEY_UVTRANSFORM_BASE, type, N
 
 // For backward compatibility and simplicity
 //! @cond MATS_DOC_FULL
-#define AI_MATKEY_UVTRANSFORM_DIFFUSE(N)    \
-    AI_MATKEY_UVTRANSFORM(aiTextureType_DIFFUSE,N)
+#define AI_MATKEY_UVTRANSFORM_DIFFUSE(N) \
+    AI_MATKEY_UVTRANSFORM(aiTextureType_DIFFUSE, N)
 
-#define AI_MATKEY_UVTRANSFORM_SPECULAR(N)   \
-    AI_MATKEY_UVTRANSFORM(aiTextureType_SPECULAR,N)
+#define AI_MATKEY_UVTRANSFORM_SPECULAR(N) \
+    AI_MATKEY_UVTRANSFORM(aiTextureType_SPECULAR, N)
 
-#define AI_MATKEY_UVTRANSFORM_AMBIENT(N)    \
-    AI_MATKEY_UVTRANSFORM(aiTextureType_AMBIENT,N)
+#define AI_MATKEY_UVTRANSFORM_AMBIENT(N) \
+    AI_MATKEY_UVTRANSFORM(aiTextureType_AMBIENT, N)
 
-#define AI_MATKEY_UVTRANSFORM_EMISSIVE(N)   \
-    AI_MATKEY_UVTRANSFORM(aiTextureType_EMISSIVE,N)
+#define AI_MATKEY_UVTRANSFORM_EMISSIVE(N) \
+    AI_MATKEY_UVTRANSFORM(aiTextureType_EMISSIVE, N)
 
-#define AI_MATKEY_UVTRANSFORM_NORMALS(N)    \
-    AI_MATKEY_UVTRANSFORM(aiTextureType_NORMALS,N)
+#define AI_MATKEY_UVTRANSFORM_NORMALS(N) \
+    AI_MATKEY_UVTRANSFORM(aiTextureType_NORMALS, N)
 
 #define AI_MATKEY_UVTRANSFORM_HEIGHT(N) \
-    AI_MATKEY_UVTRANSFORM(aiTextureType_HEIGHT,N)
+    AI_MATKEY_UVTRANSFORM(aiTextureType_HEIGHT, N)
 
-#define AI_MATKEY_UVTRANSFORM_SHININESS(N)  \
-    AI_MATKEY_UVTRANSFORM(aiTextureType_SHININESS,N)
+#define AI_MATKEY_UVTRANSFORM_SHININESS(N) \
+    AI_MATKEY_UVTRANSFORM(aiTextureType_SHININESS, N)
 
-#define AI_MATKEY_UVTRANSFORM_OPACITY(N)    \
-    AI_MATKEY_UVTRANSFORM(aiTextureType_OPACITY,N)
+#define AI_MATKEY_UVTRANSFORM_OPACITY(N) \
+    AI_MATKEY_UVTRANSFORM(aiTextureType_OPACITY, N)
 
-#define AI_MATKEY_UVTRANSFORM_DISPLACEMENT(N)   \
-    AI_MATKEY_UVTRANSFORM(aiTextureType_DISPLACEMENT,N)
+#define AI_MATKEY_UVTRANSFORM_DISPLACEMENT(N) \
+    AI_MATKEY_UVTRANSFORM(aiTextureType_DISPLACEMENT, N)
 
-#define AI_MATKEY_UVTRANSFORM_LIGHTMAP(N)   \
-    AI_MATKEY_UVTRANSFORM(aiTextureType_LIGHTMAP,N)
+#define AI_MATKEY_UVTRANSFORM_LIGHTMAP(N) \
+    AI_MATKEY_UVTRANSFORM(aiTextureType_LIGHTMAP, N)
 
 #define AI_MATKEY_UVTRANSFORM_REFLECTION(N) \
-    AI_MATKEY_UVTRANSFORM(aiTextureType_REFLECTION,N)
+    AI_MATKEY_UVTRANSFORM(aiTextureType_REFLECTION, N)
 
-#define AI_MATKEY_UVTRANSFORM_UNKNOWN(N)    \
-    AI_MATKEY_UVTRANSFORM(aiTextureType_UNKNOWN,N)
+#define AI_MATKEY_UVTRANSFORM_UNKNOWN(N) \
+    AI_MATKEY_UVTRANSFORM(aiTextureType_UNKNOWN, N)
 
 //! @endcond
 // ---------------------------------------------------------------------------
-#define AI_MATKEY_TEXFLAGS(type, N) _AI_MATKEY_TEXFLAGS_BASE,type,N
+#define AI_MATKEY_TEXFLAGS(type, N) _AI_MATKEY_TEXFLAGS_BASE, type, N
 
 // For backward compatibility and simplicity
 //! @cond MATS_DOC_FULL
-#define AI_MATKEY_TEXFLAGS_DIFFUSE(N)   \
-    AI_MATKEY_TEXFLAGS(aiTextureType_DIFFUSE,N)
+#define AI_MATKEY_TEXFLAGS_DIFFUSE(N) \
+    AI_MATKEY_TEXFLAGS(aiTextureType_DIFFUSE, N)
 
-#define AI_MATKEY_TEXFLAGS_SPECULAR(N)  \
-    AI_MATKEY_TEXFLAGS(aiTextureType_SPECULAR,N)
+#define AI_MATKEY_TEXFLAGS_SPECULAR(N) \
+    AI_MATKEY_TEXFLAGS(aiTextureType_SPECULAR, N)
 
-#define AI_MATKEY_TEXFLAGS_AMBIENT(N)   \
-    AI_MATKEY_TEXFLAGS(aiTextureType_AMBIENT,N)
+#define AI_MATKEY_TEXFLAGS_AMBIENT(N) \
+    AI_MATKEY_TEXFLAGS(aiTextureType_AMBIENT, N)
 
-#define AI_MATKEY_TEXFLAGS_EMISSIVE(N)  \
-    AI_MATKEY_TEXFLAGS(aiTextureType_EMISSIVE,N)
+#define AI_MATKEY_TEXFLAGS_EMISSIVE(N) \
+    AI_MATKEY_TEXFLAGS(aiTextureType_EMISSIVE, N)
 
-#define AI_MATKEY_TEXFLAGS_NORMALS(N)   \
-    AI_MATKEY_TEXFLAGS(aiTextureType_NORMALS,N)
+#define AI_MATKEY_TEXFLAGS_NORMALS(N) \
+    AI_MATKEY_TEXFLAGS(aiTextureType_NORMALS, N)
 
-#define AI_MATKEY_TEXFLAGS_HEIGHT(N)    \
-    AI_MATKEY_TEXFLAGS(aiTextureType_HEIGHT,N)
+#define AI_MATKEY_TEXFLAGS_HEIGHT(N) \
+    AI_MATKEY_TEXFLAGS(aiTextureType_HEIGHT, N)
 
 #define AI_MATKEY_TEXFLAGS_SHININESS(N) \
-    AI_MATKEY_TEXFLAGS(aiTextureType_SHININESS,N)
+    AI_MATKEY_TEXFLAGS(aiTextureType_SHININESS, N)
 
-#define AI_MATKEY_TEXFLAGS_OPACITY(N)   \
-    AI_MATKEY_TEXFLAGS(aiTextureType_OPACITY,N)
+#define AI_MATKEY_TEXFLAGS_OPACITY(N) \
+    AI_MATKEY_TEXFLAGS(aiTextureType_OPACITY, N)
 
-#define AI_MATKEY_TEXFLAGS_DISPLACEMENT(N)  \
-    AI_MATKEY_TEXFLAGS(aiTextureType_DISPLACEMENT,N)
+#define AI_MATKEY_TEXFLAGS_DISPLACEMENT(N) \
+    AI_MATKEY_TEXFLAGS(aiTextureType_DISPLACEMENT, N)
 
-#define AI_MATKEY_TEXFLAGS_LIGHTMAP(N)  \
-    AI_MATKEY_TEXFLAGS(aiTextureType_LIGHTMAP,N)
+#define AI_MATKEY_TEXFLAGS_LIGHTMAP(N) \
+    AI_MATKEY_TEXFLAGS(aiTextureType_LIGHTMAP, N)
 
-#define AI_MATKEY_TEXFLAGS_REFLECTION(N)    \
-    AI_MATKEY_TEXFLAGS(aiTextureType_REFLECTION,N)
+#define AI_MATKEY_TEXFLAGS_REFLECTION(N) \
+    AI_MATKEY_TEXFLAGS(aiTextureType_REFLECTION, N)
 
-#define AI_MATKEY_TEXFLAGS_UNKNOWN(N)   \
-    AI_MATKEY_TEXFLAGS(aiTextureType_UNKNOWN,N)
+#define AI_MATKEY_TEXFLAGS_UNKNOWN(N) \
+    AI_MATKEY_TEXFLAGS(aiTextureType_UNKNOWN, N)
 
 //! @endcond
 //!
@@ -1366,11 +1475,11 @@ extern "C" {
  *        structure or NULL if the key has not been found. */
 // ---------------------------------------------------------------------------
 ASSIMP_API C_ENUM aiReturn aiGetMaterialProperty(
-    const C_STRUCT aiMaterial* pMat,
-    const char* pKey,
-    unsigned int type,
-    unsigned int  index,
-    const C_STRUCT aiMaterialProperty** pPropOut);
+        const C_STRUCT aiMaterial *pMat,
+        const char *pKey,
+        unsigned int type,
+        unsigned int index,
+        const C_STRUCT aiMaterialProperty **pPropOut);
 
 // ---------------------------------------------------------------------------
 /** @brief Retrieve an array of float values with a specific key
@@ -1399,15 +1508,12 @@ ASSIMP_API C_ENUM aiReturn aiGetMaterialProperty(
  *   arrays remains unmodified and pMax is set to 0.*/
 // ---------------------------------------------------------------------------
 ASSIMP_API C_ENUM aiReturn aiGetMaterialFloatArray(
-    const C_STRUCT aiMaterial* pMat,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index,
-    ai_real* pOut,
-    unsigned int* pMax);
-
-
-#ifdef __cplusplus
+        const C_STRUCT aiMaterial *pMat,
+        const char *pKey,
+        unsigned int type,
+        unsigned int index,
+        ai_real *pOut,
+        unsigned int *pMax);
 
 // ---------------------------------------------------------------------------
 /** @brief Retrieve a single float property with a specific key from the material.
@@ -1428,95 +1534,71 @@ ASSIMP_API C_ENUM aiReturn aiGetMaterialFloatArray(
 * @return Specifies whether the key has been found. If not, the output
 *   float remains unmodified.*/
 // ---------------------------------------------------------------------------
-inline aiReturn aiGetMaterialFloat(const aiMaterial* pMat,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index,
-    ai_real* pOut)
-{
-    return aiGetMaterialFloatArray(pMat,pKey,type,index,pOut,(unsigned int*)0x0);
+inline aiReturn aiGetMaterialFloat(const C_STRUCT aiMaterial *pMat,
+        const char *pKey,
+        unsigned int type,
+        unsigned int index,
+        ai_real *pOut) {
+    return aiGetMaterialFloatArray(pMat, pKey, type, index, pOut, (unsigned int *)0x0);
 }
 
-#else
-
-// Use our friend, the C preprocessor
-#define aiGetMaterialFloat (pMat, type, index, pKey, pOut) \
-    aiGetMaterialFloatArray(pMat, type, index, pKey, pOut, NULL)
-
-#endif //!__cplusplus
-
-
 // ---------------------------------------------------------------------------
 /** @brief Retrieve an array of integer values with a specific key
  *  from a material
  *
  * See the sample for aiGetMaterialFloatArray for more information.*/
-ASSIMP_API C_ENUM aiReturn aiGetMaterialIntegerArray(const C_STRUCT aiMaterial* pMat,
-     const char* pKey,
-     unsigned int  type,
-     unsigned int  index,
-     int* pOut,
-     unsigned int* pMax);
-
-
-#ifdef __cplusplus
+ASSIMP_API C_ENUM aiReturn aiGetMaterialIntegerArray(const C_STRUCT aiMaterial *pMat,
+        const char *pKey,
+        unsigned int type,
+        unsigned int index,
+        int *pOut,
+        unsigned int *pMax);
 
 // ---------------------------------------------------------------------------
 /** @brief Retrieve an integer property with a specific key from a material
  *
  * See the sample for aiGetMaterialFloat for more information.*/
 // ---------------------------------------------------------------------------
-inline aiReturn aiGetMaterialInteger(const C_STRUCT aiMaterial* pMat,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index,
-    int* pOut)
-{
-    return aiGetMaterialIntegerArray(pMat,pKey,type,index,pOut,(unsigned int*)0x0);
+inline aiReturn aiGetMaterialInteger(const C_STRUCT aiMaterial *pMat,
+        const char *pKey,
+        unsigned int type,
+        unsigned int index,
+        int *pOut) {
+    return aiGetMaterialIntegerArray(pMat, pKey, type, index, pOut, (unsigned int *)0x0);
 }
 
-#else
-
-// use our friend, the C preprocessor
-#define aiGetMaterialInteger (pMat, type, index, pKey, pOut) \
-    aiGetMaterialIntegerArray(pMat, type, index, pKey, pOut, NULL)
-
-#endif //!__cplusplus
-
 // ---------------------------------------------------------------------------
 /** @brief Retrieve a color value from the material property table
 *
 * See the sample for aiGetMaterialFloat for more information*/
 // ---------------------------------------------------------------------------
-ASSIMP_API C_ENUM aiReturn aiGetMaterialColor(const C_STRUCT aiMaterial* pMat,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index,
-    C_STRUCT aiColor4D* pOut);
-
+ASSIMP_API C_ENUM aiReturn aiGetMaterialColor(const C_STRUCT aiMaterial *pMat,
+        const char *pKey,
+        unsigned int type,
+        unsigned int index,
+        C_STRUCT aiColor4D *pOut);
 
 // ---------------------------------------------------------------------------
 /** @brief Retrieve a aiUVTransform value from the material property table
 *
 * See the sample for aiGetMaterialFloat for more information*/
 // ---------------------------------------------------------------------------
-ASSIMP_API C_ENUM aiReturn aiGetMaterialUVTransform(const C_STRUCT aiMaterial* pMat,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index,
-    C_STRUCT aiUVTransform* pOut);
-
+ASSIMP_API C_ENUM aiReturn aiGetMaterialUVTransform(const C_STRUCT aiMaterial *pMat,
+        const char *pKey,
+        unsigned int type,
+        unsigned int index,
+        C_STRUCT aiUVTransform *pOut);
 
 // ---------------------------------------------------------------------------
 /** @brief Retrieve a string from the material property table
 *
 * See the sample for aiGetMaterialFloat for more information.*/
 // ---------------------------------------------------------------------------
-ASSIMP_API C_ENUM aiReturn aiGetMaterialString(const C_STRUCT aiMaterial* pMat,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index,
-    C_STRUCT aiString* pOut);
+ASSIMP_API C_ENUM aiReturn aiGetMaterialString(const C_STRUCT aiMaterial *pMat,
+        const char *pKey,
+        unsigned int type,
+        unsigned int index,
+        C_STRUCT aiString *pOut);
 
 // ---------------------------------------------------------------------------
 /** Get the number of textures for a particular texture type.
@@ -1525,8 +1607,8 @@ ASSIMP_API C_ENUM aiReturn aiGetMaterialString(const C_STRUCT aiMaterial* pMat,
  *  @return Number of textures for this type.
  *  @note A texture can be easily queried using #aiGetMaterialTexture() */
 // ---------------------------------------------------------------------------
-ASSIMP_API unsigned int aiGetMaterialTextureCount(const C_STRUCT aiMaterial* pMat,
-    C_ENUM aiTextureType type);
+ASSIMP_API unsigned int aiGetMaterialTextureCount(const C_STRUCT aiMaterial *pMat,
+        C_ENUM aiTextureType type);
 
 // ---------------------------------------------------------------------------
 /** @brief Helper function to get all values pertaining to a particular
@@ -1566,30 +1648,29 @@ ASSIMP_API unsigned int aiGetMaterialTextureCount(const C_STRUCT aiMaterial* pMa
  *  @return AI_SUCCESS on success, otherwise something else. Have fun.*/
 // ---------------------------------------------------------------------------
 #ifdef __cplusplus
-ASSIMP_API aiReturn aiGetMaterialTexture(const C_STRUCT aiMaterial* mat,
-    aiTextureType type,
-    unsigned int  index,
-    aiString* path,
-    aiTextureMapping* mapping   = NULL,
-    unsigned int* uvindex       = NULL,
-    ai_real* blend              = NULL,
-    aiTextureOp* op             = NULL,
-    aiTextureMapMode* mapmode   = NULL,
-    unsigned int* flags         = NULL);
+ASSIMP_API aiReturn aiGetMaterialTexture(const C_STRUCT aiMaterial *mat,
+        aiTextureType type,
+        unsigned int index,
+        aiString *path,
+        aiTextureMapping *mapping = NULL,
+        unsigned int *uvindex = NULL,
+        ai_real *blend = NULL,
+        aiTextureOp *op = NULL,
+        aiTextureMapMode *mapmode = NULL,
+        unsigned int *flags = NULL);
 #else
-C_ENUM aiReturn aiGetMaterialTexture(const C_STRUCT aiMaterial* mat,
-    C_ENUM aiTextureType type,
-    unsigned int  index,
-    C_STRUCT aiString* path,
-    C_ENUM aiTextureMapping* mapping    /*= NULL*/,
-    unsigned int* uvindex               /*= NULL*/,
-    ai_real* blend                      /*= NULL*/,
-    C_ENUM aiTextureOp* op              /*= NULL*/,
-    C_ENUM aiTextureMapMode* mapmode    /*= NULL*/,
-    unsigned int* flags                 /*= NULL*/);
+C_ENUM aiReturn aiGetMaterialTexture(const C_STRUCT aiMaterial *mat,
+        C_ENUM aiTextureType type,
+        unsigned int index,
+        C_STRUCT aiString *path,
+        C_ENUM aiTextureMapping *mapping /*= NULL*/,
+        unsigned int *uvindex /*= NULL*/,
+        ai_real *blend /*= NULL*/,
+        C_ENUM aiTextureOp *op /*= NULL*/,
+        C_ENUM aiTextureMapMode *mapmode /*= NULL*/,
+        unsigned int *flags /*= NULL*/);
 #endif // !#ifdef __cplusplus
 
-
 #ifdef __cplusplus
 }
 
diff --git a/Engine/lib/assimp/include/assimp/material.inl b/Engine/lib/assimp/include/assimp/material.inl
index b05d6af6c..0b30a6839 100644
--- a/Engine/lib/assimp/include/assimp/material.inl
+++ b/Engine/lib/assimp/include/assimp/material.inl
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -46,17 +44,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #pragma once
-#ifndef AI_MATERIAL_INL_INC
-#define AI_MATERIAL_INL_INC
+
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
 
 // ---------------------------------------------------------------------------
-inline aiPropertyTypeInfo ai_real_to_property_type_info(float)
-{
+AI_FORCE_INLINE aiPropertyTypeInfo ai_real_to_property_type_info(float) {
 	return aiPTI_Float;
 }
 
-inline aiPropertyTypeInfo ai_real_to_property_type_info(double)
-{
+AI_FORCE_INLINE aiPropertyTypeInfo ai_real_to_property_type_info(double) {
 	return aiPTI_Double;
 }
 // ---------------------------------------------------------------------------
@@ -64,30 +62,27 @@ inline aiPropertyTypeInfo ai_real_to_property_type_info(double)
 //! @cond never
 
 // ---------------------------------------------------------------------------
-inline aiReturn aiMaterial::GetTexture( aiTextureType type,
-   unsigned int  index,
-   C_STRUCT aiString* path,
-   aiTextureMapping* mapping    /*= NULL*/,
-   unsigned int* uvindex        /*= NULL*/,
-   ai_real* blend               /*= NULL*/,
-   aiTextureOp* op              /*= NULL*/,
-   aiTextureMapMode* mapmode    /*= NULL*/) const
-{
+AI_FORCE_INLINE aiReturn aiMaterial::GetTexture( aiTextureType type,
+       unsigned int  index,
+       C_STRUCT aiString* path,
+       aiTextureMapping* mapping    /*= NULL*/,
+       unsigned int* uvindex        /*= NULL*/,
+       ai_real* blend               /*= NULL*/,
+       aiTextureOp* op              /*= NULL*/,
+       aiTextureMapMode* mapmode    /*= NULL*/) const {
     return ::aiGetMaterialTexture(this,type,index,path,mapping,uvindex,blend,op,mapmode);
 }
 
 // ---------------------------------------------------------------------------
-inline unsigned int aiMaterial::GetTextureCount(aiTextureType type) const
-{
+AI_FORCE_INLINE unsigned int aiMaterial::GetTextureCount(aiTextureType type) const {
     return ::aiGetMaterialTextureCount(this,type);
 }
 
 // ---------------------------------------------------------------------------
 template <typename Type>
-inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-    unsigned int idx, Type* pOut,
-    unsigned int* pMax) const
-{
+AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+        unsigned int idx, Type* pOut,
+        unsigned int* pMax) const {
     unsigned int iNum = pMax ? *pMax : 1;
 
     const aiMaterialProperty* prop;
@@ -103,7 +98,7 @@ inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
             return AI_FAILURE;
         }
 
-        iNum = std::min((size_t)iNum,prop->mDataLength / sizeof(Type));
+        iNum = static_cast<unsigned int>(std::min(static_cast<size_t>(iNum),prop->mDataLength / sizeof(Type)));
         ::memcpy(pOut,prop->mData,iNum * sizeof(Type));
         if (pMax) {
             *pMax = iNum;
@@ -114,9 +109,8 @@ inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
 
 // ---------------------------------------------------------------------------
 template <typename Type>
-inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-    unsigned int idx,Type& pOut) const
-{
+AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+        unsigned int idx,Type& pOut) const {
     const aiMaterialProperty* prop;
     const aiReturn ret = ::aiGetMaterialProperty(this,pKey,type,idx,
         (const aiMaterialProperty**)&prop);
@@ -136,152 +130,179 @@ inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
 }
 
 // ---------------------------------------------------------------------------
-inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-    unsigned int idx,ai_real* pOut,
-    unsigned int* pMax) const
-{
+// Specialisation for a single bool.
+// Casts floating point and integer to bool
+template <>
+AI_FORCE_INLINE
+        aiReturn
+        aiMaterial::Get(const char *pKey, unsigned int type,
+                unsigned int idx, bool &pOut) const {
+    const aiMaterialProperty *prop;
+    const aiReturn ret = ::aiGetMaterialProperty(this, pKey, type, idx,
+            (const aiMaterialProperty **)&prop);
+    if (AI_SUCCESS == ret) {
+
+        switch (prop->mType) {
+            // Type cannot be converted
+        default: return AI_FAILURE;
+
+        case aiPTI_Buffer: {
+            // Native bool value storage
+            if (prop->mDataLength < sizeof(bool)) {
+                return AI_FAILURE;
+            }
+            ::memcpy(&pOut, prop->mData, sizeof(bool));
+        } break;
+
+        case aiPTI_Float:
+        case aiPTI_Double: {
+            // Read as float and cast to bool
+            float value = 0.0f;
+            if (AI_SUCCESS == ::aiGetMaterialFloat(this, pKey, type, idx, &value)) {
+                pOut = static_cast<bool>(value);
+                return AI_SUCCESS;
+            }
+            return AI_FAILURE;
+        }
+        case aiPTI_Integer: {
+            // Cast to bool
+            const int value = static_cast<int>(*prop->mData);
+            pOut = static_cast<bool>(value);
+            return AI_SUCCESS;
+        }
+        }
+    }
+    return ret;
+}
+
+// ---------------------------------------------------------------------------
+AI_FORCE_INLINE
+aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+        unsigned int idx,ai_real* pOut,
+        unsigned int* pMax) const {
     return ::aiGetMaterialFloatArray(this,pKey,type,idx,pOut,pMax);
 }
 // ---------------------------------------------------------------------------
-inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-    unsigned int idx,int* pOut,
-    unsigned int* pMax) const
-{
+AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+        unsigned int idx,int* pOut,
+        unsigned int* pMax) const {
     return ::aiGetMaterialIntegerArray(this,pKey,type,idx,pOut,pMax);
 }
 // ---------------------------------------------------------------------------
-inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-    unsigned int idx,ai_real& pOut) const
-{
+AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+        unsigned int idx,ai_real& pOut) const {
     return aiGetMaterialFloat(this,pKey,type,idx,&pOut);
 }
 // ---------------------------------------------------------------------------
-inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-    unsigned int idx,int& pOut) const
-{
+AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+        unsigned int idx,int& pOut) const {
     return aiGetMaterialInteger(this,pKey,type,idx,&pOut);
 }
 // ---------------------------------------------------------------------------
-inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-    unsigned int idx,aiColor4D& pOut) const
-{
+AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+        unsigned int idx,aiColor4D& pOut) const {
     return aiGetMaterialColor(this,pKey,type,idx,&pOut);
 }
 // ---------------------------------------------------------------------------
-inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-    unsigned int idx,aiColor3D& pOut) const
-{
+AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+        unsigned int idx,aiColor3D& pOut) const {
     aiColor4D c;
     const aiReturn ret = aiGetMaterialColor(this,pKey,type,idx,&c);
     pOut = aiColor3D(c.r,c.g,c.b);
     return ret;
 }
 // ---------------------------------------------------------------------------
-inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-    unsigned int idx,aiString& pOut) const
-{
+AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+        unsigned int idx,aiString& pOut) const {
     return aiGetMaterialString(this,pKey,type,idx,&pOut);
 }
 // ---------------------------------------------------------------------------
-inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-    unsigned int idx,aiUVTransform& pOut) const
-{
+AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+        unsigned int idx,aiUVTransform& pOut) const {
     return aiGetMaterialUVTransform(this,pKey,type,idx,&pOut);
 }
 
-
 // ---------------------------------------------------------------------------
 template<class TYPE>
-aiReturn aiMaterial::AddProperty (const TYPE* pInput,
-    const unsigned int pNumValues,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index)
-{
-    return AddBinaryProperty((const void*)pInput,
-        pNumValues * sizeof(TYPE),
+aiReturn aiMaterial::AddProperty (const TYPE* pInput, 
+        const unsigned int pNumValues, const char* pKey, unsigned int type, 
+        unsigned int index) {
+    return AddBinaryProperty((const void*)pInput, pNumValues * sizeof(TYPE),
         pKey,type,index,aiPTI_Buffer);
 }
 
 // ---------------------------------------------------------------------------
-inline aiReturn aiMaterial::AddProperty(const float* pInput,
-    const unsigned int pNumValues,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index)
-{
+AI_FORCE_INLINE aiReturn aiMaterial::AddProperty(const float* pInput,
+        const unsigned int pNumValues,
+        const char* pKey,
+        unsigned int type,
+        unsigned int index) {
     return AddBinaryProperty((const void*)pInput,
         pNumValues * sizeof(float),
         pKey,type,index,aiPTI_Float);
 }
 
 // ---------------------------------------------------------------------------
-inline aiReturn aiMaterial::AddProperty(const double* pInput,
-    const unsigned int pNumValues,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index)
-{
+AI_FORCE_INLINE aiReturn aiMaterial::AddProperty(const double* pInput,
+        const unsigned int pNumValues,
+        const char* pKey,
+        unsigned int type,
+        unsigned int index) {
     return AddBinaryProperty((const void*)pInput,
         pNumValues * sizeof(double),
         pKey,type,index,aiPTI_Double);
 }
 
 // ---------------------------------------------------------------------------
-inline aiReturn aiMaterial::AddProperty(const aiUVTransform* pInput,
-    const unsigned int pNumValues,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index)
-{
+AI_FORCE_INLINE aiReturn aiMaterial::AddProperty(const aiUVTransform* pInput,
+        const unsigned int pNumValues,
+        const char* pKey,
+        unsigned int type,
+        unsigned int index) {
     return AddBinaryProperty((const void*)pInput,
         pNumValues * sizeof(aiUVTransform),
         pKey,type,index,ai_real_to_property_type_info(pInput->mRotation));
 }
 
 // ---------------------------------------------------------------------------
-inline aiReturn aiMaterial::AddProperty(const aiColor4D* pInput,
-    const unsigned int pNumValues,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index)
-{
+AI_FORCE_INLINE aiReturn aiMaterial::AddProperty(const aiColor4D* pInput,
+        const unsigned int pNumValues,
+        const char* pKey,
+        unsigned int type,
+        unsigned int index) {
     return AddBinaryProperty((const void*)pInput,
         pNumValues * sizeof(aiColor4D),
         pKey,type,index,ai_real_to_property_type_info(pInput->a));
 }
 
 // ---------------------------------------------------------------------------
-inline aiReturn aiMaterial::AddProperty(const aiColor3D* pInput,
-    const unsigned int pNumValues,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index)
-{
+AI_FORCE_INLINE aiReturn aiMaterial::AddProperty(const aiColor3D* pInput,
+        const unsigned int pNumValues,
+        const char* pKey,
+        unsigned int type,
+        unsigned int index) {
     return AddBinaryProperty((const void*)pInput,
         pNumValues * sizeof(aiColor3D),
         pKey,type,index,ai_real_to_property_type_info(pInput->b));
 }
 
 // ---------------------------------------------------------------------------
-inline aiReturn aiMaterial::AddProperty(const aiVector3D* pInput,
-    const unsigned int pNumValues,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index)
-{
+AI_FORCE_INLINE aiReturn aiMaterial::AddProperty(const aiVector3D* pInput,
+        const unsigned int pNumValues,
+        const char* pKey,
+        unsigned int type,
+        unsigned int index) {
     return AddBinaryProperty((const void*)pInput,
         pNumValues * sizeof(aiVector3D),
         pKey,type,index,ai_real_to_property_type_info(pInput->x));
 }
 
 // ---------------------------------------------------------------------------
-inline aiReturn aiMaterial::AddProperty(const int* pInput,
-    const unsigned int pNumValues,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index)
-{
+AI_FORCE_INLINE aiReturn aiMaterial::AddProperty(const int* pInput,
+        const unsigned int pNumValues,
+        const char* pKey,
+        unsigned int type,
+        unsigned int index) {
     return AddBinaryProperty((const void*)pInput,
         pNumValues * sizeof(int),
         pKey,type,index,aiPTI_Integer);
@@ -296,12 +317,11 @@ inline aiReturn aiMaterial::AddProperty(const int* pInput,
 
 // ---------------------------------------------------------------------------
 template<>
-inline aiReturn aiMaterial::AddProperty<float>(const float* pInput,
-    const unsigned int pNumValues,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index)
-{
+AI_FORCE_INLINE aiReturn aiMaterial::AddProperty<float>(const float* pInput,
+        const unsigned int pNumValues,
+        const char* pKey,
+        unsigned int type,
+        unsigned int index) {
     return AddBinaryProperty((const void*)pInput,
         pNumValues * sizeof(float),
         pKey,type,index,aiPTI_Float);
@@ -309,12 +329,11 @@ inline aiReturn aiMaterial::AddProperty<float>(const float* pInput,
 
 // ---------------------------------------------------------------------------
 template<>
-inline aiReturn aiMaterial::AddProperty<double>(const double* pInput,
-    const unsigned int pNumValues,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index)
-{
+AI_FORCE_INLINE aiReturn aiMaterial::AddProperty<double>(const double* pInput,
+        const unsigned int pNumValues,
+        const char* pKey,
+        unsigned int type,
+        unsigned int index) {
     return AddBinaryProperty((const void*)pInput,
         pNumValues * sizeof(double),
         pKey,type,index,aiPTI_Double);
@@ -322,12 +341,11 @@ inline aiReturn aiMaterial::AddProperty<double>(const double* pInput,
 
 // ---------------------------------------------------------------------------
 template<>
-inline aiReturn aiMaterial::AddProperty<aiUVTransform>(const aiUVTransform* pInput,
-    const unsigned int pNumValues,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index)
-{
+AI_FORCE_INLINE aiReturn aiMaterial::AddProperty<aiUVTransform>(const aiUVTransform* pInput,
+        const unsigned int pNumValues,
+        const char* pKey,
+        unsigned int type,
+        unsigned int index) {
     return AddBinaryProperty((const void*)pInput,
         pNumValues * sizeof(aiUVTransform),
         pKey,type,index,aiPTI_Float);
@@ -335,12 +353,11 @@ inline aiReturn aiMaterial::AddProperty<aiUVTransform>(const aiUVTransform* pInp
 
 // ---------------------------------------------------------------------------
 template<>
-inline aiReturn aiMaterial::AddProperty<aiColor4D>(const aiColor4D* pInput,
-    const unsigned int pNumValues,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index)
-{
+AI_FORCE_INLINE aiReturn aiMaterial::AddProperty<aiColor4D>(const aiColor4D* pInput,
+        const unsigned int pNumValues,
+        const char* pKey,
+        unsigned int type,
+        unsigned int index) {
     return AddBinaryProperty((const void*)pInput,
         pNumValues * sizeof(aiColor4D),
         pKey,type,index,aiPTI_Float);
@@ -348,12 +365,11 @@ inline aiReturn aiMaterial::AddProperty<aiColor4D>(const aiColor4D* pInput,
 
 // ---------------------------------------------------------------------------
 template<>
-inline aiReturn aiMaterial::AddProperty<aiColor3D>(const aiColor3D* pInput,
-    const unsigned int pNumValues,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index)
-{
+AI_FORCE_INLINE aiReturn aiMaterial::AddProperty<aiColor3D>(const aiColor3D* pInput,
+        const unsigned int pNumValues,
+        const char* pKey,
+        unsigned int type,
+        unsigned int index) {
     return AddBinaryProperty((const void*)pInput,
         pNumValues * sizeof(aiColor3D),
         pKey,type,index,aiPTI_Float);
@@ -361,12 +377,11 @@ inline aiReturn aiMaterial::AddProperty<aiColor3D>(const aiColor3D* pInput,
 
 // ---------------------------------------------------------------------------
 template<>
-inline aiReturn aiMaterial::AddProperty<aiVector3D>(const aiVector3D* pInput,
-    const unsigned int pNumValues,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index)
-{
+AI_FORCE_INLINE aiReturn aiMaterial::AddProperty<aiVector3D>(const aiVector3D* pInput,
+        const unsigned int pNumValues,
+        const char* pKey,
+        unsigned int type,
+        unsigned int index) {
     return AddBinaryProperty((const void*)pInput,
         pNumValues * sizeof(aiVector3D),
         pKey,type,index,aiPTI_Float);
@@ -374,17 +389,14 @@ inline aiReturn aiMaterial::AddProperty<aiVector3D>(const aiVector3D* pInput,
 
 // ---------------------------------------------------------------------------
 template<>
-inline aiReturn aiMaterial::AddProperty<int>(const int* pInput,
-    const unsigned int pNumValues,
-    const char* pKey,
-    unsigned int type,
-    unsigned int index)
-{
+AI_FORCE_INLINE aiReturn aiMaterial::AddProperty<int>(const int* pInput,
+        const unsigned int pNumValues,
+        const char* pKey,
+        unsigned int type,
+        unsigned int index) {
     return AddBinaryProperty((const void*)pInput,
         pNumValues * sizeof(int),
         pKey,type,index,aiPTI_Integer);
 }
 
 //! @endcond
-
-#endif //! AI_MATERIAL_INL_INC
diff --git a/Engine/lib/assimp/include/assimp/matrix3x3.h b/Engine/lib/assimp/include/assimp/matrix3x3.h
index 22b69561f..74382e263 100644
--- a/Engine/lib/assimp/include/assimp/matrix3x3.h
+++ b/Engine/lib/assimp/include/assimp/matrix3x3.h
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -48,12 +46,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_MATRIX3X3_H_INC
 #define AI_MATRIX3X3_H_INC
 
-#include "defs.h"
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
+#include <assimp/defs.h>
 
 #ifdef __cplusplus
 
 template <typename T> class aiMatrix4x4t;
 template <typename T> class aiVector2t;
+template <typename T> class aiVector3t;
 
 // ---------------------------------------------------------------------------
 /** @brief Represents a row-major 3x3 matrix
@@ -65,10 +68,8 @@ template <typename T> class aiVector2t;
  *  defined thereby.
  */
 template <typename TReal>
-class aiMatrix3x3t
-{
+class aiMatrix3x3t {
 public:
-
     aiMatrix3x3t() AI_NO_EXCEPT :
         a1(static_cast<TReal>(1.0f)), a2(), a3(),
         b1(), b2(static_cast<TReal>(1.0f)), b3(),
@@ -82,8 +83,6 @@ public:
         c1(_c1), c2(_c2), c3(_c3)
     {}
 
-public:
-
     // matrix multiplication.
     aiMatrix3x3t& operator *= (const aiMatrix3x3t& m);
     aiMatrix3x3t  operator  * (const aiMatrix3x3t& m) const;
@@ -93,16 +92,14 @@ public:
     const TReal* operator[] (unsigned int p_iIndex) const;
 
     // comparison operators
-    bool operator== (const aiMatrix4x4t<TReal>& m) const;
-    bool operator!= (const aiMatrix4x4t<TReal>& m) const;
+    bool operator== (const aiMatrix3x3t<TReal>& m) const;
+    bool operator!= (const aiMatrix3x3t<TReal>& m) const;
 
-    bool Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon = 1e-6) const;
+    bool Equal(const aiMatrix3x3t<TReal> &m, TReal epsilon = ai_epsilon) const;
 
     template <typename TOther>
     operator aiMatrix3x3t<TOther> () const;
 
-public:
-
     // -------------------------------------------------------------------
     /** @brief Construction from a 4x4 matrix. The remaining parts
      *  of the matrix are ignored.
@@ -122,7 +119,6 @@ public:
     aiMatrix3x3t& Inverse();
     TReal Determinant() const;
 
-public:
     // -------------------------------------------------------------------
     /** @brief Returns a rotation matrix for a rotation around z
      *  @param a Rotation angle, in radians
@@ -139,8 +135,7 @@ public:
      *  @param axis Axis to rotate around
      *  @param out To be filled
      */
-    static aiMatrix3x3t& Rotation( TReal a,
-        const aiVector3t<TReal>& axis, aiMatrix3x3t& out);
+    static aiMatrix3x3t& Rotation( TReal a, const aiVector3t<TReal>& axis, aiMatrix3x3t& out);
 
     // -------------------------------------------------------------------
     /** @brief Returns a translation matrix
diff --git a/Engine/lib/assimp/include/assimp/matrix3x3.inl b/Engine/lib/assimp/include/assimp/matrix3x3.inl
index d9d45a3e9..99d9197e3 100644
--- a/Engine/lib/assimp/include/assimp/matrix3x3.inl
+++ b/Engine/lib/assimp/include/assimp/matrix3x3.inl
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -48,10 +46,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_MATRIX3X3_INL_INC
 #define AI_MATRIX3X3_INL_INC
 
-#ifdef __cplusplus
-#include "matrix3x3.h"
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
+#ifdef __cplusplus
+#include <assimp/matrix3x3.h>
+#include <assimp/matrix4x4.h>
 
-#include "matrix4x4.h"
 #include <algorithm>
 #include <cmath>
 #include <limits>
@@ -59,8 +61,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // ------------------------------------------------------------------------------------------------
 // Construction from a 4x4 matrix. The remaining parts of the matrix are ignored.
 template <typename TReal>
-inline aiMatrix3x3t<TReal>::aiMatrix3x3t( const aiMatrix4x4t<TReal>& pMatrix)
-{
+AI_FORCE_INLINE
+aiMatrix3x3t<TReal>::aiMatrix3x3t( const aiMatrix4x4t<TReal>& pMatrix) {
     a1 = pMatrix.a1; a2 = pMatrix.a2; a3 = pMatrix.a3;
     b1 = pMatrix.b1; b2 = pMatrix.b2; b3 = pMatrix.b3;
     c1 = pMatrix.c1; c2 = pMatrix.c2; c3 = pMatrix.c3;
@@ -68,8 +70,8 @@ inline aiMatrix3x3t<TReal>::aiMatrix3x3t( const aiMatrix4x4t<TReal>& pMatrix)
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::operator *= (const aiMatrix3x3t<TReal>& m)
-{
+AI_FORCE_INLINE
+aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::operator *= (const aiMatrix3x3t<TReal>& m) {
     *this = aiMatrix3x3t<TReal>(m.a1 * a1 + m.b1 * a2 + m.c1 * a3,
         m.a2 * a1 + m.b2 * a2 + m.c2 * a3,
         m.a3 * a1 + m.b3 * a2 + m.c3 * a3,
@@ -85,8 +87,7 @@ inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::operator *= (const aiMatrix3x3t
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 template <typename TOther>
-aiMatrix3x3t<TReal>::operator aiMatrix3x3t<TOther> () const
-{
+aiMatrix3x3t<TReal>::operator aiMatrix3x3t<TOther> () const {
     return aiMatrix3x3t<TOther>(static_cast<TOther>(a1),static_cast<TOther>(a2),static_cast<TOther>(a3),
         static_cast<TOther>(b1),static_cast<TOther>(b2),static_cast<TOther>(b3),
         static_cast<TOther>(c1),static_cast<TOther>(c2),static_cast<TOther>(c3));
@@ -94,8 +95,8 @@ aiMatrix3x3t<TReal>::operator aiMatrix3x3t<TOther> () const
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-inline aiMatrix3x3t<TReal> aiMatrix3x3t<TReal>::operator* (const aiMatrix3x3t<TReal>& m) const
-{
+AI_FORCE_INLINE
+aiMatrix3x3t<TReal> aiMatrix3x3t<TReal>::operator* (const aiMatrix3x3t<TReal>& m) const {
     aiMatrix3x3t<TReal> temp( *this);
     temp *= m;
     return temp;
@@ -103,7 +104,8 @@ inline aiMatrix3x3t<TReal> aiMatrix3x3t<TReal>::operator* (const aiMatrix3x3t<TR
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-inline TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex) {
+AI_FORCE_INLINE
+TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex) {
     switch ( p_iIndex ) {
         case 0:
             return &a1;
@@ -119,7 +121,8 @@ inline TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex) {
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-inline const TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex) const {
+AI_FORCE_INLINE
+const TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex) const {
     switch ( p_iIndex ) {
         case 0:
             return &a1;
@@ -135,8 +138,8 @@ inline const TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex) cons
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-inline bool aiMatrix3x3t<TReal>::operator== (const aiMatrix4x4t<TReal>& m) const
-{
+AI_FORCE_INLINE
+bool aiMatrix3x3t<TReal>::operator== (const aiMatrix3x3t<TReal>& m) const {
     return a1 == m.a1 && a2 == m.a2 && a3 == m.a3 &&
            b1 == m.b1 && b2 == m.b2 && b3 == m.b3 &&
            c1 == m.c1 && c2 == m.c2 && c3 == m.c3;
@@ -144,14 +147,15 @@ inline bool aiMatrix3x3t<TReal>::operator== (const aiMatrix4x4t<TReal>& m) const
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-inline bool aiMatrix3x3t<TReal>::operator!= (const aiMatrix4x4t<TReal>& m) const
-{
+AI_FORCE_INLINE
+bool aiMatrix3x3t<TReal>::operator!= (const aiMatrix3x3t<TReal>& m) const {
     return !(*this == m);
 }
 
 // ---------------------------------------------------------------------------
 template<typename TReal>
-inline bool aiMatrix3x3t<TReal>::Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon) const {
+AI_FORCE_INLINE
+bool aiMatrix3x3t<TReal>::Equal(const aiMatrix3x3t<TReal>& m, TReal epsilon) const {
     return
         std::abs(a1 - m.a1) <= epsilon &&
         std::abs(a2 - m.a2) <= epsilon &&
@@ -166,8 +170,8 @@ inline bool aiMatrix3x3t<TReal>::Equal(const aiMatrix4x4t<TReal>& m, TReal epsil
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Transpose()
-{
+AI_FORCE_INLINE
+aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Transpose() {
     // (TReal&) don't remove, GCC complains cause of packed fields
     std::swap( (TReal&)a2, (TReal&)b1);
     std::swap( (TReal&)a3, (TReal&)c1);
@@ -177,15 +181,15 @@ inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Transpose()
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-inline TReal aiMatrix3x3t<TReal>::Determinant() const
-{
+AI_FORCE_INLINE
+TReal aiMatrix3x3t<TReal>::Determinant() const {
     return a1*b2*c3 - a1*b3*c2 + a2*b3*c1 - a2*b1*c3 + a3*b1*c2 - a3*b2*c1;
 }
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Inverse()
-{
+AI_FORCE_INLINE
+aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Inverse() {
     // Compute the reciprocal determinant
     TReal det = Determinant();
     if(det == static_cast<TReal>(0.0))
@@ -219,8 +223,8 @@ inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Inverse()
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::RotationZ(TReal a, aiMatrix3x3t<TReal>& out)
-{
+AI_FORCE_INLINE
+aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::RotationZ(TReal a, aiMatrix3x3t<TReal>& out) {
     out.a1 = out.b2 = std::cos(a);
     out.b1 = std::sin(a);
     out.a2 = - out.b1;
@@ -234,8 +238,8 @@ inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::RotationZ(TReal a, aiMatrix3x3t
 // ------------------------------------------------------------------------------------------------
 // Returns a rotation matrix for a rotation around an arbitrary axis.
 template <typename TReal>
-inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Rotation( TReal a, const aiVector3t<TReal>& axis, aiMatrix3x3t<TReal>& out)
-{
+AI_FORCE_INLINE
+aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Rotation( TReal a, const aiVector3t<TReal>& axis, aiMatrix3x3t<TReal>& out) {
   TReal c = std::cos( a), s = std::sin( a), t = 1 - c;
   TReal x = axis.x, y = axis.y, z = axis.z;
 
@@ -249,8 +253,8 @@ inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Rotation( TReal a, const aiVect
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Translation( const aiVector2t<TReal>& v, aiMatrix3x3t<TReal>& out)
-{
+AI_FORCE_INLINE
+aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Translation( const aiVector2t<TReal>& v, aiMatrix3x3t<TReal>& out) {
     out = aiMatrix3x3t<TReal>();
     out.a3 = v.x;
     out.b3 = v.y;
@@ -268,9 +272,8 @@ inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Translation( const aiVector2t<T
  */
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::FromToMatrix(const aiVector3t<TReal>& from,
-    const aiVector3t<TReal>& to, aiMatrix3x3t<TReal>& mtx)
-{
+AI_FORCE_INLINE aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::FromToMatrix(const aiVector3t<TReal>& from,
+        const aiVector3t<TReal>& to, aiMatrix3x3t<TReal>& mtx) {
     const TReal e = from * to;
     const TReal f = (e < 0)? -e:e;
 
@@ -352,6 +355,5 @@ inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::FromToMatrix(const aiVector3t<T
     return mtx;
 }
 
-
 #endif // __cplusplus
 #endif // AI_MATRIX3X3_INL_INC
diff --git a/Engine/lib/assimp/include/assimp/matrix4x4.h b/Engine/lib/assimp/include/assimp/matrix4x4.h
index 046bb535f..67e0e356e 100644
--- a/Engine/lib/assimp/include/assimp/matrix4x4.h
+++ b/Engine/lib/assimp/include/assimp/matrix4x4.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -47,8 +47,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_MATRIX4X4_H_INC
 #define AI_MATRIX4X4_H_INC
 
-#include "vector3.h"
-#include "defs.h"
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
+#include <assimp/vector3.h>
+#include <assimp/defs.h>
 
 #ifdef __cplusplus
 
@@ -66,8 +70,7 @@ template<typename TReal> class aiQuaterniont;
  *  defined thereby.
  */
 template<typename TReal>
-class aiMatrix4x4t
-{
+class aiMatrix4x4t {
 public:
 
     /** set to identity */
@@ -91,8 +94,6 @@ public:
     aiMatrix4x4t(const aiVector3t<TReal>& scaling, const aiQuaterniont<TReal>& rotation,
         const aiVector3t<TReal>& position);
 
-public:
-
     // array access operators
 	/** @fn TReal* operator[] (unsigned int p_iIndex)
 	 *  @param [in] p_iIndex - index of the row.
@@ -109,7 +110,7 @@ public:
     bool operator== (const aiMatrix4x4t& m) const;
     bool operator!= (const aiMatrix4x4t& m) const;
 
-    bool Equal(const aiMatrix4x4t& m, TReal epsilon = 1e-6) const;
+    bool Equal(const aiMatrix4x4t &m, TReal epsilon = ai_epsilon) const;
 
     // matrix multiplication.
     aiMatrix4x4t& operator *= (const aiMatrix4x4t& m);
@@ -120,8 +121,6 @@ public:
     template <typename TOther>
     operator aiMatrix4x4t<TOther> () const;
 
-public:
-
     // -------------------------------------------------------------------
     /** @brief Transpose the matrix */
     aiMatrix4x4t& Transpose();
@@ -182,7 +181,6 @@ public:
     void DecomposeNoScaling (aiQuaterniont<TReal>& rotation,
         aiVector3t<TReal>& position) const;
 
-
     // -------------------------------------------------------------------
     /** @brief Creates a trafo matrix from a set of euler angles
      *  @param x Rotation angle for the x-axis, in radians
@@ -192,7 +190,6 @@ public:
     aiMatrix4x4t& FromEulerAnglesXYZ(TReal x, TReal y, TReal z);
     aiMatrix4x4t& FromEulerAnglesXYZ(const aiVector3t<TReal>& blubb);
 
-public:
     // -------------------------------------------------------------------
     /** @brief Returns a rotation matrix for a rotation around the x axis
      *  @param a Rotation angle, in radians
@@ -233,7 +230,7 @@ public:
      *  @param out Receives the output matrix
      *  @return Reference to the output matrix
      */
-    static aiMatrix4x4t& Translation( const aiVector3t<TReal>& v, 
+    static aiMatrix4x4t& Translation( const aiVector3t<TReal>& v,
             aiMatrix4x4t& out);
 
     // -------------------------------------------------------------------
@@ -256,7 +253,6 @@ public:
     static aiMatrix4x4t& FromToMatrix(const aiVector3t<TReal>& from,
             const aiVector3t<TReal>& to, aiMatrix4x4t& out);
 
-public:
     TReal a1, a2, a3, a4;
     TReal b1, b2, b3, b4;
     TReal c1, c2, c3, c4;
diff --git a/Engine/lib/assimp/include/assimp/matrix4x4.inl b/Engine/lib/assimp/include/assimp/matrix4x4.inl
index 19e684917..54d176d18 100644
--- a/Engine/lib/assimp/include/assimp/matrix4x4.inl
+++ b/Engine/lib/assimp/include/assimp/matrix4x4.inl
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -60,12 +60,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
 aiMatrix4x4t<TReal>::aiMatrix4x4t() AI_NO_EXCEPT :
-    a1(1.0f), a2(), a3(), a4(),
-    b1(), b2(1.0f), b3(), b4(),
-    c1(), c2(), c3(1.0f), c4(),
-    d1(), d2(), d3(), d4(1.0f)
-{
-
+        a1(1.0f), a2(), a3(), a4(),
+        b1(), b2(1.0f), b3(), b4(),
+        c1(), c2(), c3(1.0f), c4(),
+        d1(), d2(), d3(), d4(1.0f) {
+    // empty
 }
 
 // ----------------------------------------------------------------------------------------
@@ -74,19 +73,17 @@ aiMatrix4x4t<TReal>::aiMatrix4x4t (TReal _a1, TReal _a2, TReal _a3, TReal _a4,
               TReal _b1, TReal _b2, TReal _b3, TReal _b4,
               TReal _c1, TReal _c2, TReal _c3, TReal _c4,
               TReal _d1, TReal _d2, TReal _d3, TReal _d4) :
-    a1(_a1), a2(_a2), a3(_a3), a4(_a4),
-    b1(_b1), b2(_b2), b3(_b3), b4(_b4),
-    c1(_c1), c2(_c2), c3(_c3), c4(_c4),
-    d1(_d1), d2(_d2), d3(_d3), d4(_d4)
-{
-
+        a1(_a1), a2(_a2), a3(_a3), a4(_a4),
+        b1(_b1), b2(_b2), b3(_b3), b4(_b4),
+        c1(_c1), c2(_c2), c3(_c3), c4(_c4),
+        d1(_d1), d2(_d2), d3(_d3), d4(_d4) {
+    // empty
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 template <typename TOther>
-aiMatrix4x4t<TReal>::operator aiMatrix4x4t<TOther> () const
-{
+aiMatrix4x4t<TReal>::operator aiMatrix4x4t<TOther> () const {
     return aiMatrix4x4t<TOther>(static_cast<TOther>(a1),static_cast<TOther>(a2),static_cast<TOther>(a3),static_cast<TOther>(a4),
         static_cast<TOther>(b1),static_cast<TOther>(b2),static_cast<TOther>(b3),static_cast<TOther>(b4),
         static_cast<TOther>(c1),static_cast<TOther>(c2),static_cast<TOther>(c3),static_cast<TOther>(c4),
@@ -96,8 +93,8 @@ aiMatrix4x4t<TReal>::operator aiMatrix4x4t<TOther> () const
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-inline aiMatrix4x4t<TReal>::aiMatrix4x4t (const aiMatrix3x3t<TReal>& m)
-{
+AI_FORCE_INLINE
+aiMatrix4x4t<TReal>::aiMatrix4x4t (const aiMatrix3x3t<TReal>& m) {
     a1 = m.a1; a2 = m.a2; a3 = m.a3; a4 = static_cast<TReal>(0.0);
     b1 = m.b1; b2 = m.b2; b3 = m.b3; b4 = static_cast<TReal>(0.0);
     c1 = m.c1; c2 = m.c2; c3 = m.c3; c4 = static_cast<TReal>(0.0);
@@ -106,8 +103,8 @@ inline aiMatrix4x4t<TReal>::aiMatrix4x4t (const aiMatrix3x3t<TReal>& m)
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-inline aiMatrix4x4t<TReal>::aiMatrix4x4t (const aiVector3t<TReal>& scaling, const aiQuaterniont<TReal>& rotation, const aiVector3t<TReal>& position)
-{
+AI_FORCE_INLINE
+aiMatrix4x4t<TReal>::aiMatrix4x4t (const aiVector3t<TReal>& scaling, const aiQuaterniont<TReal>& rotation, const aiVector3t<TReal>& position) {
     // build a 3x3 rotation matrix
     aiMatrix3x3t<TReal> m = rotation.GetMatrix();
 
@@ -134,8 +131,8 @@ inline aiMatrix4x4t<TReal>::aiMatrix4x4t (const aiVector3t<TReal>& scaling, cons
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::operator *= (const aiMatrix4x4t<TReal>& m)
-{
+AI_FORCE_INLINE
+aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::operator *= (const aiMatrix4x4t<TReal>& m) {
     *this = aiMatrix4x4t<TReal>(
         m.a1 * a1 + m.b1 * a2 + m.c1 * a3 + m.d1 * a4,
         m.a2 * a1 + m.b2 * a2 + m.c2 * a3 + m.d2 * a4,
@@ -158,8 +155,7 @@ inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::operator *= (const aiMatrix4x4t
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-inline aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator* (const TReal& aFloat) const
-{
+AI_FORCE_INLINE aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator* (const TReal& aFloat) const {
     aiMatrix4x4t<TReal> temp(
         a1 * aFloat,
         a2 * aFloat,
@@ -182,8 +178,8 @@ inline aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator* (const TReal& aFloat)
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-inline aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator+ (const aiMatrix4x4t<TReal>& m) const
-{
+AI_FORCE_INLINE
+aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator+ (const aiMatrix4x4t<TReal>& m) const {
     aiMatrix4x4t<TReal> temp(
         m.a1 + a1,
         m.a2 + a2,
@@ -206,18 +202,16 @@ inline aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator+ (const aiMatrix4x4t<TR
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-inline aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator* (const aiMatrix4x4t<TReal>& m) const
-{
+AI_FORCE_INLINE
+aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator* (const aiMatrix4x4t<TReal>& m) const {
     aiMatrix4x4t<TReal> temp( *this);
     temp *= m;
     return temp;
 }
 
-
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Transpose()
-{
+AI_FORCE_INLINE aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Transpose() {
     // (TReal&) don't remove, GCC complains cause of packed fields
     std::swap( (TReal&)b1, (TReal&)a2);
     std::swap( (TReal&)c1, (TReal&)a3);
@@ -228,11 +222,10 @@ inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Transpose()
     return *this;
 }
 
-
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-inline TReal aiMatrix4x4t<TReal>::Determinant() const
-{
+AI_FORCE_INLINE
+TReal aiMatrix4x4t<TReal>::Determinant() const {
     return a1*b2*c3*d4 - a1*b2*c4*d3 + a1*b3*c4*d2 - a1*b3*c2*d4
         + a1*b4*c2*d3 - a1*b4*c3*d2 - a2*b3*c4*d1 + a2*b3*c1*d4
         - a2*b4*c1*d3 + a2*b4*c3*d1 - a2*b1*c3*d4 + a2*b1*c4*d3
@@ -243,8 +236,8 @@ inline TReal aiMatrix4x4t<TReal>::Determinant() const
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Inverse()
-{
+AI_FORCE_INLINE
+aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Inverse() {
     // Compute the reciprocal determinant
     const TReal det = Determinant();
     if(det == static_cast<TReal>(0.0))
@@ -288,9 +281,10 @@ inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Inverse()
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-inline TReal* aiMatrix4x4t<TReal>::operator[](unsigned int p_iIndex) {
+AI_FORCE_INLINE
+TReal* aiMatrix4x4t<TReal>::operator[](unsigned int p_iIndex) {
     if (p_iIndex > 3) {
-        return NULL;
+        return nullptr;
     }
     switch ( p_iIndex ) {
         case 0:
@@ -309,9 +303,10 @@ inline TReal* aiMatrix4x4t<TReal>::operator[](unsigned int p_iIndex) {
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-inline const TReal* aiMatrix4x4t<TReal>::operator[](unsigned int p_iIndex) const {
+AI_FORCE_INLINE
+const TReal* aiMatrix4x4t<TReal>::operator[](unsigned int p_iIndex) const {
     if (p_iIndex > 3) {
-        return NULL;
+        return nullptr;
     }
 
     switch ( p_iIndex ) {
@@ -331,8 +326,8 @@ inline const TReal* aiMatrix4x4t<TReal>::operator[](unsigned int p_iIndex) const
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-inline bool aiMatrix4x4t<TReal>::operator== (const aiMatrix4x4t<TReal>& m) const
-{
+AI_FORCE_INLINE
+bool aiMatrix4x4t<TReal>::operator== (const aiMatrix4x4t<TReal>& m) const {
     return (a1 == m.a1 && a2 == m.a2 && a3 == m.a3 && a4 == m.a4 &&
             b1 == m.b1 && b2 == m.b2 && b3 == m.b3 && b4 == m.b4 &&
             c1 == m.c1 && c2 == m.c2 && c3 == m.c3 && c4 == m.c4 &&
@@ -341,14 +336,15 @@ inline bool aiMatrix4x4t<TReal>::operator== (const aiMatrix4x4t<TReal>& m) const
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-inline bool aiMatrix4x4t<TReal>::operator!= (const aiMatrix4x4t<TReal>& m) const
-{
+AI_FORCE_INLINE
+bool aiMatrix4x4t<TReal>::operator!= (const aiMatrix4x4t<TReal>& m) const {
     return !(*this == m);
 }
 
 // ---------------------------------------------------------------------------
 template<typename TReal>
-inline bool aiMatrix4x4t<TReal>::Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon) const {
+AI_FORCE_INLINE
+bool aiMatrix4x4t<TReal>::Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon) const {
     return
         std::abs(a1 - m.a1) <= epsilon &&
         std::abs(a2 - m.a2) <= epsilon &&
@@ -400,13 +396,10 @@ inline bool aiMatrix4x4t<TReal>::Equal(const aiMatrix4x4t<TReal>& m, TReal epsil
 	\
 	do {} while(false)
 
-
-
-
 template <typename TReal>
-inline void aiMatrix4x4t<TReal>::Decompose (aiVector3t<TReal>& pScaling, aiQuaterniont<TReal>& pRotation,
-    aiVector3t<TReal>& pPosition) const
-{
+AI_FORCE_INLINE
+void aiMatrix4x4t<TReal>::Decompose (aiVector3t<TReal>& pScaling, aiQuaterniont<TReal>& pRotation,
+        aiVector3t<TReal>& pPosition) const {
 	ASSIMP_MATRIX4_4_DECOMPOSE_PART;
 
     // build a 3x3 rotation matrix
@@ -419,7 +412,7 @@ inline void aiMatrix4x4t<TReal>::Decompose (aiVector3t<TReal>& pScaling, aiQuate
 }
 
 template <typename TReal>
-inline
+AI_FORCE_INLINE
 void aiMatrix4x4t<TReal>::Decompose(aiVector3t<TReal>& pScaling, aiVector3t<TReal>& pRotation, aiVector3t<TReal>& pPosition) const {
 	ASSIMP_MATRIX4_4_DECOMPOSE_PART;
 
@@ -428,7 +421,7 @@ void aiMatrix4x4t<TReal>::Decompose(aiVector3t<TReal>& pScaling, aiVector3t<TRea
     and post-multiplication of column vectors,
     the rotation matrix for an euler XYZ rotation is M = Rz * Ry * Rx.
     combining gives:
-    
+
         |  CE  BDE-AF  ADE+BF  0  |
     M = |  CF  BDF+AE  ADF-BE  0  |
         |  -D    CB      AC    0  |
@@ -474,10 +467,10 @@ void aiMatrix4x4t<TReal>::Decompose(aiVector3t<TReal>& pScaling, aiVector3t<TRea
 #undef ASSIMP_MATRIX4_4_DECOMPOSE_PART
 
 template <typename TReal>
-inline void aiMatrix4x4t<TReal>::Decompose(aiVector3t<TReal>& pScaling, aiVector3t<TReal>& pRotationAxis, TReal& pRotationAngle,
-											aiVector3t<TReal>& pPosition) const
-{
-aiQuaterniont<TReal> pRotation;
+AI_FORCE_INLINE
+void aiMatrix4x4t<TReal>::Decompose(aiVector3t<TReal>& pScaling, aiVector3t<TReal>& pRotationAxis, TReal& pRotationAngle,
+											aiVector3t<TReal>& pPosition) const {
+    aiQuaterniont<TReal> pRotation;
 
 	Decompose(pScaling, pRotation, pPosition);
 	pRotation.Normalize();
@@ -499,9 +492,9 @@ aiQuaterniont<TReal> pRotation;
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-inline void aiMatrix4x4t<TReal>::DecomposeNoScaling (aiQuaterniont<TReal>& rotation,
-    aiVector3t<TReal>& position) const
-{
+AI_FORCE_INLINE
+void aiMatrix4x4t<TReal>::DecomposeNoScaling (aiQuaterniont<TReal>& rotation,
+        aiVector3t<TReal>& position) const {
     const aiMatrix4x4t<TReal>& _this = *this;
 
     // extract translation
@@ -515,15 +508,15 @@ inline void aiMatrix4x4t<TReal>::DecomposeNoScaling (aiQuaterniont<TReal>& rotat
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromEulerAnglesXYZ(const aiVector3t<TReal>& blubb)
-{
+AI_FORCE_INLINE
+aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromEulerAnglesXYZ(const aiVector3t<TReal>& blubb) {
     return FromEulerAnglesXYZ(blubb.x,blubb.y,blubb.z);
 }
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromEulerAnglesXYZ(TReal x, TReal y, TReal z)
-{
+AI_FORCE_INLINE
+aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromEulerAnglesXYZ(TReal x, TReal y, TReal z) {
     aiMatrix4x4t<TReal>& _this = *this;
 
     TReal cx = std::cos(x);
@@ -551,8 +544,8 @@ inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromEulerAnglesXYZ(TReal x, TRe
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-inline bool aiMatrix4x4t<TReal>::IsIdentity() const
-{
+AI_FORCE_INLINE
+bool aiMatrix4x4t<TReal>::IsIdentity() const {
     // Use a small epsilon to solve floating-point inaccuracies
     const static TReal epsilon = 10e-3f;
 
@@ -576,8 +569,8 @@ inline bool aiMatrix4x4t<TReal>::IsIdentity() const
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationX(TReal a, aiMatrix4x4t<TReal>& out)
-{
+AI_FORCE_INLINE
+aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationX(TReal a, aiMatrix4x4t<TReal>& out) {
     /*
          |  1  0       0       0 |
      M = |  0  cos(A) -sin(A)  0 |
@@ -591,8 +584,8 @@ inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationX(TReal a, aiMatrix4x4t
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationY(TReal a, aiMatrix4x4t<TReal>& out)
-{
+AI_FORCE_INLINE
+aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationY(TReal a, aiMatrix4x4t<TReal>& out) {
     /*
          |  cos(A)  0   sin(A)  0 |
      M = |  0       1   0       0 |
@@ -607,8 +600,8 @@ inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationY(TReal a, aiMatrix4x4t
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationZ(TReal a, aiMatrix4x4t<TReal>& out)
-{
+AI_FORCE_INLINE
+aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationZ(TReal a, aiMatrix4x4t<TReal>& out) {
     /*
          |  cos(A)  -sin(A)   0   0 |
      M = |  sin(A)   cos(A)   0   0 |
@@ -623,26 +616,25 @@ inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationZ(TReal a, aiMatrix4x4t
 // ----------------------------------------------------------------------------------------
 // Returns a rotation matrix for a rotation around an arbitrary axis.
 template <typename TReal>
-inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Rotation( TReal a, const aiVector3t<TReal>& axis, aiMatrix4x4t<TReal>& out)
-{
-  TReal c = std::cos( a), s = std::sin( a), t = 1 - c;
-  TReal x = axis.x, y = axis.y, z = axis.z;
+AI_FORCE_INLINE
+aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Rotation( TReal a, const aiVector3t<TReal>& axis, aiMatrix4x4t<TReal>& out) {
+    TReal c = std::cos( a), s = std::sin( a), t = 1 - c;
+    TReal x = axis.x, y = axis.y, z = axis.z;
 
-  // Many thanks to MathWorld and Wikipedia
-  out.a1 = t*x*x + c;   out.a2 = t*x*y - s*z; out.a3 = t*x*z + s*y;
-  out.b1 = t*x*y + s*z; out.b2 = t*y*y + c;   out.b3 = t*y*z - s*x;
-  out.c1 = t*x*z - s*y; out.c2 = t*y*z + s*x; out.c3 = t*z*z + c;
-  out.a4 = out.b4 = out.c4 = static_cast<TReal>(0.0);
-  out.d1 = out.d2 = out.d3 = static_cast<TReal>(0.0);
-  out.d4 = static_cast<TReal>(1.0);
+    // Many thanks to MathWorld and Wikipedia
+    out.a1 = t*x*x + c;   out.a2 = t*x*y - s*z; out.a3 = t*x*z + s*y;
+    out.b1 = t*x*y + s*z; out.b2 = t*y*y + c;   out.b3 = t*y*z - s*x;
+    out.c1 = t*x*z - s*y; out.c2 = t*y*z + s*x; out.c3 = t*z*z + c;
+    out.a4 = out.b4 = out.c4 = static_cast<TReal>(0.0);
+    out.d1 = out.d2 = out.d3 = static_cast<TReal>(0.0);
+    out.d4 = static_cast<TReal>(1.0);
 
-  return out;
+    return out;
 }
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Translation( const aiVector3t<TReal>& v, aiMatrix4x4t<TReal>& out)
-{
+AI_FORCE_INLINE aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Translation( const aiVector3t<TReal>& v, aiMatrix4x4t<TReal>& out) {
     out = aiMatrix4x4t<TReal>();
     out.a4 = v.x;
     out.b4 = v.y;
@@ -652,8 +644,8 @@ inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Translation( const aiVector3t<T
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Scaling( const aiVector3t<TReal>& v, aiMatrix4x4t<TReal>& out)
-{
+AI_FORCE_INLINE
+aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Scaling( const aiVector3t<TReal>& v, aiMatrix4x4t<TReal>& out) {
     out = aiMatrix4x4t<TReal>();
     out.a1 = v.x;
     out.b2 = v.y;
@@ -672,9 +664,9 @@ inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Scaling( const aiVector3t<TReal
  */
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromToMatrix(const aiVector3t<TReal>& from,
-    const aiVector3t<TReal>& to, aiMatrix4x4t<TReal>& mtx)
-{
+AI_FORCE_INLINE
+aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromToMatrix(const aiVector3t<TReal>& from,
+        const aiVector3t<TReal>& to, aiMatrix4x4t<TReal>& mtx) {
     aiMatrix3x3t<TReal> m3;
     aiMatrix3x3t<TReal>::FromToMatrix(from,to,m3);
     mtx = aiMatrix4x4t<TReal>(m3);
diff --git a/Engine/lib/assimp/include/assimp/mesh.h b/Engine/lib/assimp/include/assimp/mesh.h
index f1628f1f5..5704e7ca0 100644
--- a/Engine/lib/assimp/include/assimp/mesh.h
+++ b/Engine/lib/assimp/include/assimp/mesh.h
@@ -3,8 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -48,8 +47,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_MESH_H_INC
 #define AI_MESH_H_INC
 
-#include <assimp/types.h>
+#ifdef __GNUC__
+#pragma GCC system_header
+#endif
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4351)
+#endif // _MSC_VER
+
 #include <assimp/aabb.h>
+#include <assimp/types.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -65,42 +72,42 @@ extern "C" {
  *  Maximum number of indices per face (polygon). */
 
 #ifndef AI_MAX_FACE_INDICES
-#   define AI_MAX_FACE_INDICES 0x7fff
+#define AI_MAX_FACE_INDICES 0x7fff
 #endif
 
 /** @def AI_MAX_BONE_WEIGHTS
  *  Maximum number of indices per face (polygon). */
 
 #ifndef AI_MAX_BONE_WEIGHTS
-#   define AI_MAX_BONE_WEIGHTS 0x7fffffff
+#define AI_MAX_BONE_WEIGHTS 0x7fffffff
 #endif
 
 /** @def AI_MAX_VERTICES
  *  Maximum number of vertices per mesh.  */
 
 #ifndef AI_MAX_VERTICES
-#   define AI_MAX_VERTICES 0x7fffffff
+#define AI_MAX_VERTICES 0x7fffffff
 #endif
 
 /** @def AI_MAX_FACES
  *  Maximum number of faces per mesh. */
 
 #ifndef AI_MAX_FACES
-#   define AI_MAX_FACES 0x7fffffff
+#define AI_MAX_FACES 0x7fffffff
 #endif
 
 /** @def AI_MAX_NUMBER_OF_COLOR_SETS
  *  Supported number of vertex color sets per mesh. */
 
 #ifndef AI_MAX_NUMBER_OF_COLOR_SETS
-#   define AI_MAX_NUMBER_OF_COLOR_SETS 0x8
+#define AI_MAX_NUMBER_OF_COLOR_SETS 0x8
 #endif // !! AI_MAX_NUMBER_OF_COLOR_SETS
 
 /** @def AI_MAX_NUMBER_OF_TEXTURECOORDS
  *  Supported number of texture coord sets (UV(W) channels) per mesh */
 
 #ifndef AI_MAX_NUMBER_OF_TEXTURECOORDS
-#   define AI_MAX_NUMBER_OF_TEXTURECOORDS 0x8
+#define AI_MAX_NUMBER_OF_TEXTURECOORDS 0x8
 #endif // !! AI_MAX_NUMBER_OF_TEXTURECOORDS
 
 // ---------------------------------------------------------------------------
@@ -125,39 +132,36 @@ extern "C" {
  * @note Take a look at the @link data Data Structures page @endlink for
  * more information on the layout and winding order of a face.
  */
-struct aiFace
-{
+struct aiFace {
     //! Number of indices defining this face.
     //! The maximum value for this member is #AI_MAX_FACE_INDICES.
     unsigned int mNumIndices;
 
     //! Pointer to the indices array. Size of the array is given in numIndices.
-    unsigned int* mIndices;
+    unsigned int *mIndices;
 
 #ifdef __cplusplus
 
     //! Default constructor
     aiFace() AI_NO_EXCEPT
-    : mNumIndices( 0 )
-    , mIndices( nullptr ) {
+            : mNumIndices(0),
+              mIndices(nullptr) {
         // empty
     }
 
     //! Default destructor. Delete the index array
-    ~aiFace()
-    {
-        delete [] mIndices;
+    ~aiFace() {
+        delete[] mIndices;
     }
 
     //! Copy constructor. Copy the index array
-    aiFace( const aiFace& o)
-    : mNumIndices(0)
-    , mIndices( nullptr ) {
+    aiFace(const aiFace &o) :
+            mNumIndices(0), mIndices(nullptr) {
         *this = o;
     }
 
     //! Assignment operator. Copy the index array
-    aiFace& operator = ( const aiFace& o) {
+    aiFace &operator=(const aiFace &o) {
         if (&o == this) {
             return *this;
         }
@@ -166,7 +170,7 @@ struct aiFace
         mNumIndices = o.mNumIndices;
         if (mNumIndices) {
             mIndices = new unsigned int[mNumIndices];
-            ::memcpy( mIndices, o.mIndices, mNumIndices * sizeof( unsigned int));
+            ::memcpy(mIndices, o.mIndices, mNumIndices * sizeof(unsigned int));
         } else {
             mIndices = nullptr;
         }
@@ -176,7 +180,7 @@ struct aiFace
 
     //! Comparison operator. Checks whether the index array
     //! of two faces is identical
-    bool operator== (const aiFace& o) const {
+    bool operator==(const aiFace &o) const {
         if (mIndices == o.mIndices) {
             return true;
         }
@@ -200,13 +204,12 @@ struct aiFace
 
     //! Inverse comparison operator. Checks whether the index
     //! array of two faces is NOT identical
-    bool operator != (const aiFace& o) const {
+    bool operator!=(const aiFace &o) const {
         return !(*this == o);
     }
 #endif // __cplusplus
 }; // struct aiFace
 
-
 // ---------------------------------------------------------------------------
 /** @brief A single influence of a bone on a vertex.
  */
@@ -216,37 +219,38 @@ struct aiVertexWeight {
 
     //! The strength of the influence in the range (0...1).
     //! The influence from all bones at one vertex amounts to 1.
-    float mWeight;
+    ai_real mWeight;
 
 #ifdef __cplusplus
 
     //! Default constructor
     aiVertexWeight() AI_NO_EXCEPT
-    : mVertexId(0)
-    , mWeight(0.0f) {
+            : mVertexId(0),
+              mWeight(0.0f) {
         // empty
     }
 
     //! Initialization from a given index and vertex weight factor
     //! \param pID ID
     //! \param pWeight Vertex weight factor
-    aiVertexWeight( unsigned int pID, float pWeight )
-    : mVertexId( pID )
-    , mWeight( pWeight ) {
+    aiVertexWeight(unsigned int pID, float pWeight) :
+            mVertexId(pID), mWeight(pWeight) {
         // empty
     }
 
-    bool operator == ( const aiVertexWeight &rhs ) const {
-        return ( mVertexId == rhs.mVertexId && mWeight == rhs.mWeight );
+    bool operator==(const aiVertexWeight &rhs) const {
+        return (mVertexId == rhs.mVertexId && mWeight == rhs.mWeight);
     }
 
-    bool operator != ( const aiVertexWeight &rhs ) const {
-        return ( *this == rhs );
+    bool operator!=(const aiVertexWeight &rhs) const {
+        return (*this == rhs);
     }
 
 #endif // __cplusplus
 };
 
+// Forward declare aiNode (pointer use only)
+struct aiNode;
 
 // ---------------------------------------------------------------------------
 /** @brief A single bone of a mesh.
@@ -264,8 +268,18 @@ struct aiBone {
     //! The maximum value for this member is #AI_MAX_BONE_WEIGHTS.
     unsigned int mNumWeights;
 
+#ifndef ASSIMP_BUILD_NO_ARMATUREPOPULATE_PROCESS
+    // The bone armature node - used for skeleton conversion
+    // you must enable aiProcess_PopulateArmatureData to populate this
+    C_STRUCT aiNode *mArmature;
+
+    // The bone node in the scene - used for skeleton conversion
+    // you must enable aiProcess_PopulateArmatureData to populate this
+    C_STRUCT aiNode *mNode;
+
+#endif
     //! The influence weights of this bone, by vertex index.
-    C_STRUCT aiVertexWeight* mWeights;
+    C_STRUCT aiVertexWeight *mWeights;
 
     /** Matrix that transforms from bone space to mesh space in bind pose.
      *
@@ -284,56 +298,62 @@ struct aiBone {
 
     //! Default constructor
     aiBone() AI_NO_EXCEPT
-    : mName()
-    , mNumWeights( 0 )
-    , mWeights( nullptr )
-    , mOffsetMatrix() {
+            : mName(),
+              mNumWeights(0),
+#ifndef ASSIMP_BUILD_NO_ARMATUREPOPULATE_PROCESS
+              mArmature(nullptr),
+              mNode(nullptr),
+#endif
+              mWeights(nullptr),
+              mOffsetMatrix() {
         // empty
     }
 
     //! Copy constructor
-    aiBone(const aiBone& other)
-    : mName( other.mName )
-    , mNumWeights( other.mNumWeights )
-    , mWeights(nullptr)
-    , mOffsetMatrix( other.mOffsetMatrix ) {
+    aiBone(const aiBone &other) :
+            mName(other.mName),
+            mNumWeights(other.mNumWeights),
+#ifndef ASSIMP_BUILD_NO_ARMATUREPOPULATE_PROCESS
+              mArmature(nullptr),
+              mNode(nullptr),
+#endif
+            mWeights(nullptr),
+            mOffsetMatrix(other.mOffsetMatrix) {
         if (other.mWeights && other.mNumWeights) {
             mWeights = new aiVertexWeight[mNumWeights];
-            ::memcpy(mWeights,other.mWeights,mNumWeights * sizeof(aiVertexWeight));
+            ::memcpy(mWeights, other.mWeights, mNumWeights * sizeof(aiVertexWeight));
         }
     }
 
-
     //! Assignment operator
-    aiBone &operator=(const aiBone& other) {
+    aiBone &operator=(const aiBone &other) {
         if (this == &other) {
             return *this;
         }
 
-        mName         = other.mName;
-        mNumWeights   = other.mNumWeights;
+        mName = other.mName;
+        mNumWeights = other.mNumWeights;
         mOffsetMatrix = other.mOffsetMatrix;
 
-        if (other.mWeights && other.mNumWeights)
-        {
+        if (other.mWeights && other.mNumWeights) {
             if (mWeights) {
                 delete[] mWeights;
             }
 
             mWeights = new aiVertexWeight[mNumWeights];
-            ::memcpy(mWeights,other.mWeights,mNumWeights * sizeof(aiVertexWeight));
+            ::memcpy(mWeights, other.mWeights, mNumWeights * sizeof(aiVertexWeight));
         }
 
         return *this;
     }
 
-    bool operator == ( const aiBone &rhs ) const {
-        if ( mName != rhs.mName || mNumWeights != rhs.mNumWeights ) {
+    bool operator==(const aiBone &rhs) const {
+        if (mName != rhs.mName || mNumWeights != rhs.mNumWeights) {
             return false;
         }
 
-        for ( size_t i = 0; i < mNumWeights; ++i ) {
-            if ( mWeights[ i ] != rhs.mWeights[ i ] ) {
+        for (size_t i = 0; i < mNumWeights; ++i) {
+            if (mWeights[i] != rhs.mWeights[i]) {
                 return false;
             }
         }
@@ -342,12 +362,11 @@ struct aiBone {
     }
     //! Destructor - deletes the array of vertex weights
     ~aiBone() {
-        delete [] mWeights;
+        delete[] mWeights;
     }
 #endif // __cplusplus
 };
 
-
 // ---------------------------------------------------------------------------
 /** @brief Enumerates the types of geometric primitives supported by Assimp.
  *
@@ -356,27 +375,26 @@ struct aiBone {
  *  @see aiProcess_Triangulate Automatic triangulation
  *  @see AI_CONFIG_PP_SBP_REMOVE Removal of specific primitive types.
  */
-enum aiPrimitiveType
-{
+enum aiPrimitiveType {
     /** A point primitive.
      *
      * This is just a single vertex in the virtual world,
      * #aiFace contains just one index for such a primitive.
      */
-    aiPrimitiveType_POINT       = 0x1,
+    aiPrimitiveType_POINT = 0x1,
 
     /** A line primitive.
      *
      * This is a line defined through a start and an end position.
      * #aiFace contains exactly two indices for such a primitive.
      */
-    aiPrimitiveType_LINE        = 0x2,
+    aiPrimitiveType_LINE = 0x2,
 
     /** A triangular primitive.
      *
      * A triangle consists of three indices.
      */
-    aiPrimitiveType_TRIANGLE    = 0x4,
+    aiPrimitiveType_TRIANGLE = 0x4,
 
     /** A higher-level polygon with more than 3 edges.
      *
@@ -385,10 +403,27 @@ enum aiPrimitiveType
      * is provided for your convenience, it splits all polygons in
      * triangles (which are much easier to handle).
      */
-    aiPrimitiveType_POLYGON     = 0x8,
+    aiPrimitiveType_POLYGON = 0x8,
 
+    /**
+     * A flag to determine whether this triangles only mesh is NGON encoded.
+     *
+     * NGON encoding is a special encoding that tells whether 2 or more consecutive triangles
+     * should be considered as a triangle fan. This is identified by looking at the first vertex index.
+     * 2 consecutive triangles with the same 1st vertex index are part of the same
+     * NGON.
+     *
+     * At the moment, only quads (concave or convex) are supported, meaning that polygons are 'seen' as
+     * triangles, as usual after a triangulation pass.
+     *
+     * To get an NGON encoded mesh, please use the aiProcess_Triangulate post process.
+     *
+     * @see aiProcess_Triangulate
+     * @link https://github.com/KhronosGroup/glTF/pull/1620
+     */
+    aiPrimitiveType_NGONEncodingFlag = 0x10,
 
-    /** This value is not used. It is just here to force the
+/** This value is not used. It is just here to force the
      *  compiler to map this enum to a 32 Bit integer.
      */
 #ifndef SWIG
@@ -400,8 +435,6 @@ enum aiPrimitiveType
 #define AI_PRIMITIVE_TYPE_FOR_N_INDICES(n) \
     ((n) > 3 ? aiPrimitiveType_POLYGON : (aiPrimitiveType)(1u << ((n)-1)))
 
-
-
 // ---------------------------------------------------------------------------
 /** @brief An AnimMesh is an attachment to an #aiMesh stores per-vertex
  *  animations for a particular frame.
@@ -413,33 +446,32 @@ enum aiPrimitiveType
  *  established by #aiMeshAnim, which references singular mesh attachments
  *  by their ID and binds them to a time offset.
 */
-struct aiAnimMesh
-{
+struct aiAnimMesh {
     /**Anim Mesh name */
     C_STRUCT aiString mName;
 
-    /** Replacement for aiMesh::mVertices. If this array is non-NULL,
+    /** Replacement for aiMesh::mVertices. If this array is non-nullptr,
      *  it *must* contain mNumVertices entries. The corresponding
-     *  array in the host mesh must be non-NULL as well - animation
+     *  array in the host mesh must be non-nullptr as well - animation
      *  meshes may neither add or nor remove vertex components (if
-     *  a replacement array is NULL and the corresponding source
+     *  a replacement array is nullptr and the corresponding source
      *  array is not, the source data is taken instead)*/
-    C_STRUCT aiVector3D* mVertices;
+    C_STRUCT aiVector3D *mVertices;
 
     /** Replacement for aiMesh::mNormals.  */
-    C_STRUCT aiVector3D* mNormals;
+    C_STRUCT aiVector3D *mNormals;
 
     /** Replacement for aiMesh::mTangents. */
-    C_STRUCT aiVector3D* mTangents;
+    C_STRUCT aiVector3D *mTangents;
 
     /** Replacement for aiMesh::mBitangents. */
-    C_STRUCT aiVector3D* mBitangents;
+    C_STRUCT aiVector3D *mBitangents;
 
     /** Replacement for aiMesh::mColors */
-    C_STRUCT aiColor4D* mColors[AI_MAX_NUMBER_OF_COLOR_SETS];
+    C_STRUCT aiColor4D *mColors[AI_MAX_NUMBER_OF_COLOR_SETS];
 
     /** Replacement for aiMesh::mTextureCoords */
-    C_STRUCT aiVector3D* mTextureCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS];
+    C_STRUCT aiVector3D *mTextureCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS];
 
     /** The number of vertices in the aiAnimMesh, and thus the length of all
      * the member arrays.
@@ -450,44 +482,42 @@ struct aiAnimMesh
      * from language bindings.
      */
     unsigned int mNumVertices;
-    
-    /** 
-     * Weight of the AnimMesh. 
+
+    /**
+     * Weight of the AnimMesh.
      */
     float mWeight;
 
 #ifdef __cplusplus
 
     aiAnimMesh() AI_NO_EXCEPT
-        : mVertices( nullptr )
-        , mNormals(nullptr)
-        , mTangents(nullptr)
-        , mBitangents(nullptr)
-        , mColors()
-        , mTextureCoords()
-        , mNumVertices( 0 )
-        , mWeight( 0.0f )
-    {
+            : mVertices(nullptr),
+              mNormals(nullptr),
+              mTangents(nullptr),
+              mBitangents(nullptr),
+              mColors(),
+              mTextureCoords(),
+              mNumVertices(0),
+              mWeight(0.0f) {
         // fixme consider moving this to the ctor initializer list as well
-        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; a++){
+        for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; a++) {
             mTextureCoords[a] = nullptr;
         }
-        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; a++) {
+        for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; a++) {
             mColors[a] = nullptr;
         }
     }
 
-    ~aiAnimMesh()
-    {
-        delete [] mVertices;
-        delete [] mNormals;
-        delete [] mTangents;
-        delete [] mBitangents;
-        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; a++) {
-            delete [] mTextureCoords[a];
+    ~aiAnimMesh() {
+        delete[] mVertices;
+        delete[] mNormals;
+        delete[] mTangents;
+        delete[] mBitangents;
+        for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; a++) {
+            delete[] mTextureCoords[a];
         }
-        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; a++) {
-            delete [] mColors[a];
+        for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; a++) {
+            delete[] mColors[a];
         }
     }
 
@@ -513,14 +543,14 @@ struct aiAnimMesh
     /** Check whether the anim mesh overrides a particular
      * set of vertex colors on his host mesh.
      *  @param pIndex 0<index<AI_MAX_NUMBER_OF_COLOR_SETS */
-    bool HasVertexColors( unsigned int pIndex) const    {
+    bool HasVertexColors(unsigned int pIndex) const {
         return pIndex >= AI_MAX_NUMBER_OF_COLOR_SETS ? false : mColors[pIndex] != nullptr;
     }
 
     /** Check whether the anim mesh overrides a particular
      * set of texture coordinates on his host mesh.
      *  @param pIndex 0<index<AI_MAX_NUMBER_OF_TEXTURECOORDS */
-    bool HasTextureCoords( unsigned int pIndex) const   {
+    bool HasTextureCoords(unsigned int pIndex) const {
         return pIndex >= AI_MAX_NUMBER_OF_TEXTURECOORDS ? false : mTextureCoords[pIndex] != nullptr;
     }
 
@@ -530,18 +560,17 @@ struct aiAnimMesh
 // ---------------------------------------------------------------------------
 /** @brief Enumerates the methods of mesh morphing supported by Assimp.
  */
-enum aiMorphingMethod
-{
+enum aiMorphingMethod {
     /** Interpolation between morph targets */
-    aiMorphingMethod_VERTEX_BLEND       = 0x1,
+    aiMorphingMethod_VERTEX_BLEND = 0x1,
 
     /** Normalized morphing between morph targets  */
-    aiMorphingMethod_MORPH_NORMALIZED   = 0x2,
+    aiMorphingMethod_MORPH_NORMALIZED = 0x2,
 
     /** Relative morphing between morph targets  */
-    aiMorphingMethod_MORPH_RELATIVE     = 0x3,
+    aiMorphingMethod_MORPH_RELATIVE = 0x3,
 
-    /** This value is not used. It is just here to force the
+/** This value is not used. It is just here to force the
      *  compiler to map this enum to a 32 Bit integer.
      */
 #ifndef SWIG
@@ -556,7 +585,7 @@ enum aiMorphingMethod
 * referencing the vertices. In addition there might be a series of bones, each
 * of them addressing a number of vertices with a certain weight. Vertex data
 * is presented in channels with each channel containing a single per-vertex
-* information such as a set of texture coords or a normal vector.
+* information such as a set of texture coordinates or a normal vector.
 * If a data pointer is non-null, the corresponding data stream is present.
 * From C++-programs you can also use the comfort functions Has*() to
 * test for the presence of various data streams.
@@ -568,8 +597,7 @@ enum aiMorphingMethod
 * aiScene::mFlags
 * @endcode
 */
-struct aiMesh
-{
+struct aiMesh {
     /** Bitwise combination of the members of the #aiPrimitiveType enum.
      * This specifies which types of primitives are present in the mesh.
      * The "SortByPrimitiveType"-Step can be used to make sure the
@@ -593,10 +621,10 @@ struct aiMesh
     * This array is always present in a mesh. The array is
     * mNumVertices in size.
     */
-    C_STRUCT aiVector3D* mVertices;
+    C_STRUCT aiVector3D *mVertices;
 
     /** Vertex normals.
-    * The array contains normalized vectors, NULL if not present.
+    * The array contains normalized vectors, nullptr if not present.
     * The array is mNumVertices in size. Normals are undefined for
     * point and line primitives. A mesh consisting of points and
     * lines only may not have normal vectors. Meshes with mixed
@@ -615,11 +643,11 @@ struct aiMesh
     * However, this needn't apply for normals that have been taken
     *   directly from the model file.
     */
-    C_STRUCT aiVector3D* mNormals;
+    C_STRUCT aiVector3D *mNormals;
 
     /** Vertex tangents.
     * The tangent of a vertex points in the direction of the positive
-    * X texture axis. The array contains normalized vectors, NULL if
+    * X texture axis. The array contains normalized vectors, nullptr if
     * not present. The array is mNumVertices in size. A mesh consisting
     * of points and lines only may not have normal vectors. Meshes with
     * mixed primitive types (i.e. lines and triangles) may have
@@ -629,36 +657,36 @@ struct aiMesh
     * @note If the mesh contains tangents, it automatically also
     * contains bitangents.
     */
-    C_STRUCT aiVector3D* mTangents;
+    C_STRUCT aiVector3D *mTangents;
 
     /** Vertex bitangents.
     * The bitangent of a vertex points in the direction of the positive
-    * Y texture axis. The array contains normalized vectors, NULL if not
+    * Y texture axis. The array contains normalized vectors, nullptr if not
     * present. The array is mNumVertices in size.
     * @note If the mesh contains tangents, it automatically also contains
     * bitangents.
     */
-    C_STRUCT aiVector3D* mBitangents;
+    C_STRUCT aiVector3D *mBitangents;
 
     /** Vertex color sets.
     * A mesh may contain 0 to #AI_MAX_NUMBER_OF_COLOR_SETS vertex
-    * colors per vertex. NULL if not present. Each array is
+    * colors per vertex. nullptr if not present. Each array is
     * mNumVertices in size if present.
     */
-    C_STRUCT aiColor4D* mColors[AI_MAX_NUMBER_OF_COLOR_SETS];
+    C_STRUCT aiColor4D *mColors[AI_MAX_NUMBER_OF_COLOR_SETS];
 
-    /** Vertex texture coords, also known as UV channels.
+    /** Vertex texture coordinates, also known as UV channels.
     * A mesh may contain 0 to AI_MAX_NUMBER_OF_TEXTURECOORDS per
-    * vertex. NULL if not present. The array is mNumVertices in size.
+    * vertex. nullptr if not present. The array is mNumVertices in size.
     */
-    C_STRUCT aiVector3D* mTextureCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS];
+    C_STRUCT aiVector3D *mTextureCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS];
 
     /** Specifies the number of components for a given UV channel.
     * Up to three channels are supported (UVW, for accessing volume
     * or cube maps). If the value is 2 for a given channel n, the
     * component p.z of mTextureCoords[n][p] is set to 0.0f.
     * If the value is 1 for a given channel, p.y is set to 0.0f, too.
-    * @note 4D coords are not supported
+    * @note 4D coordinates are not supported
     */
     unsigned int mNumUVComponents[AI_MAX_NUMBER_OF_TEXTURECOORDS];
 
@@ -668,10 +696,10 @@ struct aiMesh
     * in mNumFaces. If the #AI_SCENE_FLAGS_NON_VERBOSE_FORMAT
     * is NOT set each face references an unique set of vertices.
     */
-    C_STRUCT aiFace* mFaces;
+    C_STRUCT aiFace *mFaces;
 
     /** The number of bones this mesh contains.
-    * Can be 0, in which case the mBones array is NULL.
+    * Can be 0, in which case the mBones array is nullptr.
     */
     unsigned int mNumBones;
 
@@ -679,7 +707,7 @@ struct aiMesh
     * A bone consists of a name by which it can be found in the
     * frame hierarchy and a set of vertex weights.
     */
-    C_STRUCT aiBone** mBones;
+    C_STRUCT aiBone **mBones;
 
     /** The material used by this mesh.
      * A mesh uses only a single material. If an imported model uses
@@ -701,7 +729,6 @@ struct aiMesh
      **/
     C_STRUCT aiString mName;
 
-
     /** The number of attachment meshes. Note! Currently only works with Collada loader. */
     unsigned int mNumAnimMeshes;
 
@@ -709,41 +736,47 @@ struct aiMesh
      *  Attachment meshes carry replacement data for some of the
      *  mesh'es vertex components (usually positions, normals).
      *  Note! Currently only works with Collada loader.*/
-    C_STRUCT aiAnimMesh** mAnimMeshes;
+    C_STRUCT aiAnimMesh **mAnimMeshes;
 
-    /** 
-     *  Method of morphing when animeshes are specified. 
+    /**
+     *  Method of morphing when anim-meshes are specified.
+     *  @see aiMorphingMethod to learn more about the provided morphing targets.
      */
     unsigned int mMethod;
 
     /**
-     *
+     *  The bounding box.
      */
     C_STRUCT aiAABB mAABB;
-	
+
+    /** Vertex UV stream names. Pointer to array of size AI_MAX_NUMBER_OF_TEXTURECOORDS
+     */
+    C_STRUCT aiString **mTextureCoordsNames;
+
 #ifdef __cplusplus
 
     //! Default constructor. Initializes all members to 0
     aiMesh() AI_NO_EXCEPT
-    : mPrimitiveTypes( 0 )
-    , mNumVertices( 0 )
-    , mNumFaces( 0 )
-    , mVertices( nullptr )
-    , mNormals(nullptr)
-    , mTangents(nullptr)
-    , mBitangents(nullptr)
-    , mColors()
-    , mTextureCoords()
-    , mNumUVComponents()
-    , mFaces(nullptr)
-    , mNumBones( 0 )
-    , mBones(nullptr)
-    , mMaterialIndex( 0 )
-    , mNumAnimMeshes( 0 )
-    , mAnimMeshes(nullptr)
-    , mMethod( 0 )
-    , mAABB() {
-        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a ) {
+            : mPrimitiveTypes(0),
+              mNumVertices(0),
+              mNumFaces(0),
+              mVertices(nullptr),
+              mNormals(nullptr),
+              mTangents(nullptr),
+              mBitangents(nullptr),
+              mColors(),
+              mTextureCoords(),
+              mNumUVComponents(),
+              mFaces(nullptr),
+              mNumBones(0),
+              mBones(nullptr),
+              mMaterialIndex(0),
+              mNumAnimMeshes(0),
+              mAnimMeshes(nullptr),
+              mMethod(0),
+              mAABB(),
+              mTextureCoordsNames(nullptr) {
+        for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
             mNumUVComponents[a] = 0;
             mTextureCoords[a] = nullptr;
         }
@@ -755,59 +788,65 @@ struct aiMesh
 
     //! Deletes all storage allocated for the mesh
     ~aiMesh() {
-        delete [] mVertices;
-        delete [] mNormals;
-        delete [] mTangents;
-        delete [] mBitangents;
-        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; a++) {
-            delete [] mTextureCoords[a];
+        delete[] mVertices;
+        delete[] mNormals;
+        delete[] mTangents;
+        delete[] mBitangents;
+        for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; a++) {
+            delete[] mTextureCoords[a];
         }
-        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; a++) {
-            delete [] mColors[a];
+
+        if (mTextureCoordsNames) {
+            for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; a++) {
+                delete mTextureCoordsNames[a];
+            }
+            delete[] mTextureCoordsNames;
+        }
+
+        for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; a++) {
+            delete[] mColors[a];
         }
 
         // DO NOT REMOVE THIS ADDITIONAL CHECK
-        if (mNumBones && mBones)    {
-            for( unsigned int a = 0; a < mNumBones; a++) {
-                delete mBones[a];
+        if (mNumBones && mBones) {
+            for (unsigned int a = 0; a < mNumBones; a++) {
+                if (mBones[a]) {
+                    delete mBones[a];
+                }
             }
-            delete [] mBones;
+            delete[] mBones;
         }
 
-        if (mNumAnimMeshes && mAnimMeshes)  {
-            for( unsigned int a = 0; a < mNumAnimMeshes; a++) {
+        if (mNumAnimMeshes && mAnimMeshes) {
+            for (unsigned int a = 0; a < mNumAnimMeshes; a++) {
                 delete mAnimMeshes[a];
             }
-            delete [] mAnimMeshes;
+            delete[] mAnimMeshes;
         }
 
-        delete [] mFaces;
+        delete[] mFaces;
     }
 
     //! Check whether the mesh contains positions. Provided no special
     //! scene flags are set, this will always be true
-    bool HasPositions() const
-        { return mVertices != nullptr && mNumVertices > 0; }
+    bool HasPositions() const { return mVertices != nullptr && mNumVertices > 0; }
 
     //! Check whether the mesh contains faces. If no special scene flags
     //! are set this should always return true
-    bool HasFaces() const
-        { return mFaces != nullptr && mNumFaces > 0; }
+    bool HasFaces() const { return mFaces != nullptr && mNumFaces > 0; }
 
     //! Check whether the mesh contains normal vectors
-    bool HasNormals() const
-        { return mNormals != nullptr && mNumVertices > 0; }
+    bool HasNormals() const { return mNormals != nullptr && mNumVertices > 0; }
 
     //! Check whether the mesh contains tangent and bitangent vectors
     //! It is not possible that it contains tangents and no bitangents
     //! (or the other way round). The existence of one of them
     //! implies that the second is there, too.
-    bool HasTangentsAndBitangents() const
-        { return mTangents != nullptr && mBitangents != nullptr && mNumVertices > 0; }
+    bool HasTangentsAndBitangents() const { return mTangents != nullptr && mBitangents != nullptr && mNumVertices > 0; }
 
     //! Check whether the mesh contains a vertex color set
     //! \param pIndex Index of the vertex color set
-    bool HasVertexColors( unsigned int pIndex) const {
+    bool HasVertexColors(unsigned int pIndex) const {
         if (pIndex >= AI_MAX_NUMBER_OF_COLOR_SETS) {
             return false;
         } else {
@@ -817,7 +856,7 @@ struct aiMesh
 
     //! Check whether the mesh contains a texture coordinate set
     //! \param pIndex Index of the texture coordinates set
-    bool HasTextureCoords( unsigned int pIndex) const {
+    bool HasTextureCoords(unsigned int pIndex) const {
         if (pIndex >= AI_MAX_NUMBER_OF_TEXTURECOORDS) {
             return false;
         } else {
@@ -827,7 +866,7 @@ struct aiMesh
 
     //! Get the number of UV channels the mesh contains
     unsigned int GetNumUVChannels() const {
-        unsigned int n( 0 );
+        unsigned int n(0);
         while (n < AI_MAX_NUMBER_OF_TEXTURECOORDS && mTextureCoords[n]) {
             ++n;
         }
@@ -849,6 +888,52 @@ struct aiMesh
         return mBones != nullptr && mNumBones > 0;
     }
 
+    //! Check whether the mesh contains a texture coordinate set name
+    //! \param pIndex Index of the texture coordinates set
+    bool HasTextureCoordsName(unsigned int pIndex) const {
+        if (mTextureCoordsNames == nullptr || pIndex >= AI_MAX_NUMBER_OF_TEXTURECOORDS) {
+            return false;
+        }
+        return mTextureCoordsNames[pIndex] != nullptr;
+    }
+
+    //! Set a texture coordinate set name
+    //! \param pIndex Index of the texture coordinates set
+    //! \param texCoordsName name of the texture coordinate set
+    void SetTextureCoordsName(unsigned int pIndex, const aiString &texCoordsName) {
+        if (pIndex >= AI_MAX_NUMBER_OF_TEXTURECOORDS) {
+            return;
+        }
+
+        if (mTextureCoordsNames == nullptr) {
+            // Construct and null-init array
+            mTextureCoordsNames = new aiString *[AI_MAX_NUMBER_OF_TEXTURECOORDS] {};
+        }
+
+        if (texCoordsName.length == 0) {
+            delete mTextureCoordsNames[pIndex];
+            mTextureCoordsNames[pIndex] = nullptr;
+            return;
+        }
+
+        if (mTextureCoordsNames[pIndex] == nullptr) {
+            mTextureCoordsNames[pIndex] = new aiString(texCoordsName);
+            return;
+        }
+
+        *mTextureCoordsNames[pIndex] = texCoordsName;
+    }
+
+    //! Get a texture coordinate set name
+    //! \param pIndex Index of the texture coordinates set
+    const aiString *GetTextureCoordsName(unsigned int pIndex) const {
+        if (mTextureCoordsNames == nullptr || pIndex >= AI_MAX_NUMBER_OF_TEXTURECOORDS) {
+            return nullptr;
+        }
+
+        return mTextureCoordsNames[pIndex];
+    }
+
 #endif // __cplusplus
 };
 
@@ -856,4 +941,3 @@ struct aiMesh
 }
 #endif //! extern "C"
 #endif // AI_MESH_H_INC
-
diff --git a/Engine/lib/assimp/include/assimp/metadata.h b/Engine/lib/assimp/include/assimp/metadata.h
index 3a1dd1442..d2ec837e9 100644
--- a/Engine/lib/assimp/include/assimp/metadata.h
+++ b/Engine/lib/assimp/include/assimp/metadata.h
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -48,26 +46,31 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_METADATA_H_INC
 #define AI_METADATA_H_INC
 
+#ifdef __GNUC__
+#pragma GCC system_header
+#endif
+
 #if defined(_MSC_VER) && (_MSC_VER <= 1500)
-#  include "Compiler/pstdint.h"
+#include "Compiler/pstdint.h"
 #else
-#  include <stdint.h>
+#include <stdint.h>
 #endif
 
 // -------------------------------------------------------------------------------
 /**
   * Enum used to distinguish data types
   */
- // -------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------
 typedef enum aiMetadataType {
-    AI_BOOL       = 0,
-    AI_INT32      = 1,
-    AI_UINT64     = 2,
-    AI_FLOAT      = 3,
-    AI_DOUBLE     = 4,
-    AI_AISTRING   = 5,
+    AI_BOOL = 0,
+    AI_INT32 = 1,
+    AI_UINT64 = 2,
+    AI_FLOAT = 3,
+    AI_DOUBLE = 4,
+    AI_AISTRING = 5,
     AI_AIVECTOR3D = 6,
-    AI_META_MAX   = 7,
+    AI_AIMETADATA = 7,
+    AI_META_MAX = 8,
 
 #ifndef SWIG
     FORCE_32BIT = INT_MAX
@@ -80,29 +83,56 @@ typedef enum aiMetadataType {
   *
   * The type field uniquely identifies the underlying type of the data field
   */
- // -------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------
 struct aiMetadataEntry {
     aiMetadataType mType;
-    void* mData;
+    void *mData;
+
+#ifdef __cplusplus
+    aiMetadataEntry() :
+            mType(AI_META_MAX),
+            mData( nullptr ) {
+        // empty
+    }
+#endif
 };
 
 #ifdef __cplusplus
 
 #include <string>
 
+struct aiMetadata;
+
 // -------------------------------------------------------------------------------
 /**
   * Helper functions to get the aiType enum entry for a type
   */
- // -------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------
 
-inline aiMetadataType GetAiType( bool )       { return AI_BOOL; }
-inline aiMetadataType GetAiType( int32_t )    { return AI_INT32; }
-inline aiMetadataType GetAiType( uint64_t )   { return AI_UINT64; }
-inline aiMetadataType GetAiType( float )      { return AI_FLOAT; }
-inline aiMetadataType GetAiType( double )     { return AI_DOUBLE; }
-inline aiMetadataType GetAiType( const aiString & )   { return AI_AISTRING; }
-inline aiMetadataType GetAiType( const aiVector3D & ) { return AI_AIVECTOR3D; }
+inline aiMetadataType GetAiType(bool) {
+    return AI_BOOL;
+}
+inline aiMetadataType GetAiType(int32_t) {
+    return AI_INT32;
+}
+inline aiMetadataType GetAiType(uint64_t) {
+    return AI_UINT64;
+}
+inline aiMetadataType GetAiType(float) {
+    return AI_FLOAT;
+}
+inline aiMetadataType GetAiType(double) {
+    return AI_DOUBLE;
+}
+inline aiMetadataType GetAiType(const aiString &) {
+    return AI_AISTRING;
+}
+inline aiMetadataType GetAiType(const aiVector3D &) {
+    return AI_AIVECTOR3D;
+}
+inline aiMetadataType GetAiType(const aiMetadata &) {
+    return AI_AIMETADATA;
+}
 
 #endif // __cplusplus
 
@@ -112,123 +142,130 @@ inline aiMetadataType GetAiType( const aiVector3D & ) { return AI_AIVECTOR3D; }
   *
   * Metadata is a key-value store using string keys and values.
   */
- // -------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------
 struct aiMetadata {
     /** Length of the mKeys and mValues arrays, respectively */
     unsigned int mNumProperties;
 
     /** Arrays of keys, may not be NULL. Entries in this array may not be NULL as well. */
-    C_STRUCT aiString* mKeys;
+    C_STRUCT aiString *mKeys;
 
     /** Arrays of values, may not be NULL. Entries in this array may be NULL if the
       * corresponding property key has no assigned value. */
-    C_STRUCT aiMetadataEntry* mValues;
+    C_STRUCT aiMetadataEntry *mValues;
 
 #ifdef __cplusplus
 
-    /** 
+    /**
      *  @brief  The default constructor, set all members to zero by default.
      */
     aiMetadata() AI_NO_EXCEPT
-    : mNumProperties(0)
-    , mKeys(nullptr)
-    , mValues(nullptr) {
+            : mNumProperties(0),
+              mKeys(nullptr),
+              mValues(nullptr) {
         // empty
     }
 
-    aiMetadata( const aiMetadata &rhs )
-    : mNumProperties( rhs.mNumProperties )
-    , mKeys( nullptr )
-    , mValues( nullptr ) {
-        mKeys = new aiString[ mNumProperties ];
-        for ( size_t i = 0; i < static_cast<size_t>( mNumProperties ); ++i ) {
-            mKeys[ i ] = rhs.mKeys[ i ];
+    aiMetadata(const aiMetadata &rhs) :
+            mNumProperties(rhs.mNumProperties), mKeys(nullptr), mValues(nullptr) {
+        mKeys = new aiString[mNumProperties];
+        for (size_t i = 0; i < static_cast<size_t>(mNumProperties); ++i) {
+            mKeys[i] = rhs.mKeys[i];
         }
-        mValues = new aiMetadataEntry[ mNumProperties ];
-        for ( size_t i = 0; i < static_cast<size_t>(mNumProperties); ++i ) {
-            mValues[ i ].mType = rhs.mValues[ i ].mType;
-            switch ( rhs.mValues[ i ].mType ) {
+        mValues = new aiMetadataEntry[mNumProperties];
+        for (size_t i = 0; i < static_cast<size_t>(mNumProperties); ++i) {
+            mValues[i].mType = rhs.mValues[i].mType;
+            switch (rhs.mValues[i].mType) {
             case AI_BOOL:
-                mValues[ i ].mData = new bool;
-                ::memcpy( mValues[ i ].mData, rhs.mValues[ i ].mData, sizeof(bool) );
+                mValues[i].mData = new bool;
+                ::memcpy(mValues[i].mData, rhs.mValues[i].mData, sizeof(bool));
                 break;
             case AI_INT32: {
                 int32_t v;
-                ::memcpy( &v, rhs.mValues[ i ].mData, sizeof( int32_t ) );
-                mValues[ i ].mData = new int32_t( v );
-                }
-                break;
+                ::memcpy(&v, rhs.mValues[i].mData, sizeof(int32_t));
+                mValues[i].mData = new int32_t(v);
+            } break;
             case AI_UINT64: {
-                    uint64_t v;
-                    ::memcpy( &v, rhs.mValues[ i ].mData, sizeof( uint64_t ) );
-                    mValues[ i ].mData = new  uint64_t( v );
-                }
-                break;
+                uint64_t v;
+                ::memcpy(&v, rhs.mValues[i].mData, sizeof(uint64_t));
+                mValues[i].mData = new uint64_t(v);
+            } break;
             case AI_FLOAT: {
-                    float v;
-                    ::memcpy( &v, rhs.mValues[ i ].mData, sizeof( float ) );
-                    mValues[ i ].mData = new float( v );
-                }
-                break;
+                float v;
+                ::memcpy(&v, rhs.mValues[i].mData, sizeof(float));
+                mValues[i].mData = new float(v);
+            } break;
             case AI_DOUBLE: {
-                    double v;
-                    ::memcpy( &v, rhs.mValues[ i ].mData, sizeof( double ) );
-                    mValues[ i ].mData = new double( v );
-                }
-                break;
+                double v;
+                ::memcpy(&v, rhs.mValues[i].mData, sizeof(double));
+                mValues[i].mData = new double(v);
+            } break;
             case AI_AISTRING: {
-                    aiString v;
-                    rhs.Get<aiString>( mKeys[ i ], v );
-                    mValues[ i ].mData = new aiString( v );
-                }
-                break;
+                aiString v;
+                rhs.Get<aiString>(static_cast<unsigned int>(i), v);
+                mValues[i].mData = new aiString(v);
+            } break;
             case AI_AIVECTOR3D: {
-                    aiVector3D v;
-                    rhs.Get<aiVector3D>( mKeys[ i ], v );
-                    mValues[ i ].mData = new aiVector3D( v );
-                }
-                break;
+                aiVector3D v;
+                rhs.Get<aiVector3D>(static_cast<unsigned int>(i), v);
+                mValues[i].mData = new aiVector3D(v);
+            } break;
+            case AI_AIMETADATA: {
+                aiMetadata v;
+                rhs.Get<aiMetadata>(static_cast<unsigned int>(i), v);
+                mValues[i].mData = new aiMetadata(v);
+            } break;
 #ifndef SWIG
             case FORCE_32BIT:
 #endif
             default:
                 break;
             }
-
         }
     }
 
-    /** 
+    aiMetadata &operator=(aiMetadata rhs) {
+        using std::swap;
+        swap(mNumProperties, rhs.mNumProperties);
+        swap(mKeys, rhs.mKeys);
+        swap(mValues, rhs.mValues);
+        return *this;
+    }
+
+    /**
      *  @brief The destructor.
      */
     ~aiMetadata() {
-        delete [] mKeys;
+        delete[] mKeys;
         mKeys = nullptr;
         if (mValues) {
             // Delete each metadata entry
-            for (unsigned i=0; i<mNumProperties; ++i) {
-                void* data = mValues[i].mData;
+            for (unsigned i = 0; i < mNumProperties; ++i) {
+                void *data = mValues[i].mData;
                 switch (mValues[i].mType) {
                 case AI_BOOL:
-                    delete static_cast< bool* >( data );
+                    delete static_cast<bool *>(data);
                     break;
                 case AI_INT32:
-                    delete static_cast< int32_t* >( data );
+                    delete static_cast<int32_t *>(data);
                     break;
                 case AI_UINT64:
-                    delete static_cast< uint64_t* >( data );
+                    delete static_cast<uint64_t *>(data);
                     break;
                 case AI_FLOAT:
-                    delete static_cast< float* >( data );
+                    delete static_cast<float *>(data);
                     break;
                 case AI_DOUBLE:
-                    delete static_cast< double* >( data );
+                    delete static_cast<double *>(data);
                     break;
                 case AI_AISTRING:
-                    delete static_cast< aiString* >( data );
+                    delete static_cast<aiString *>(data);
                     break;
                 case AI_AIVECTOR3D:
-                    delete static_cast< aiVector3D* >( data );
+                    delete static_cast<aiVector3D *>(data);
+                    break;
+                case AI_AIMETADATA:
+                    delete static_cast<aiMetadata *>(data);
                     break;
 #ifndef SWIG
                 case FORCE_32BIT:
@@ -239,7 +276,7 @@ struct aiMetadata {
             }
 
             // Delete the metadata array
-            delete [] mValues;
+            delete[] mValues;
             mValues = nullptr;
         }
     }
@@ -248,16 +285,15 @@ struct aiMetadata {
      *  @brief Allocates property fields + keys.
      *  @param  numProperties   Number of requested properties.
      */
-    static inline
-    aiMetadata *Alloc( unsigned int numProperties ) {
-        if ( 0 == numProperties ) {
+    static inline aiMetadata *Alloc(unsigned int numProperties) {
+        if (0 == numProperties) {
             return nullptr;
         }
 
         aiMetadata *data = new aiMetadata;
         data->mNumProperties = numProperties;
-        data->mKeys = new aiString[ data->mNumProperties ]();
-        data->mValues = new aiMetadataEntry[ data->mNumProperties ]();
+        data->mKeys = new aiString[data->mNumProperties]();
+        data->mValues = new aiMetadataEntry[data->mNumProperties]();
 
         return data;
     }
@@ -265,44 +301,40 @@ struct aiMetadata {
     /**
      *  @brief Deallocates property fields + keys.
      */
-    static inline
-    void Dealloc( aiMetadata *metadata ) {
+    static inline void Dealloc(aiMetadata *metadata) {
         delete metadata;
     }
 
-	template<typename T>
-	inline
-    void Add(const std::string& key, const T& value) {
-		aiString* new_keys = new aiString[mNumProperties + 1];
-		aiMetadataEntry* new_values = new aiMetadataEntry[mNumProperties + 1];
+    template <typename T>
+    inline void Add(const std::string &key, const T &value) {
+        aiString *new_keys = new aiString[mNumProperties + 1];
+        aiMetadataEntry *new_values = new aiMetadataEntry[mNumProperties + 1];
 
-		for(unsigned int i = 0; i < mNumProperties; ++i)
-		{
-			new_keys[i] = mKeys[i];
-			new_values[i] = mValues[i];
-		}
+        for (unsigned int i = 0; i < mNumProperties; ++i) {
+            new_keys[i] = mKeys[i];
+            new_values[i] = mValues[i];
+        }
 
-		delete mKeys;
-		delete mValues;
+        delete[] mKeys;
+        delete[] mValues;
 
-		mKeys = new_keys;
-		mValues = new_values;
+        mKeys = new_keys;
+        mValues = new_values;
 
-		mNumProperties++;
+        mNumProperties++;
 
-		Set(mNumProperties - 1, key, value);
-	}
+        Set(mNumProperties - 1, key, value);
+    }
 
-    template<typename T>
-    inline 
-    bool Set( unsigned index, const std::string& key, const T& value ) {
+    template <typename T>
+    inline bool Set(unsigned index, const std::string &key, const T &value) {
         // In range assertion
-        if ( index >= mNumProperties ) {
+        if (index >= mNumProperties) {
             return false;
         }
 
         // Ensure that we have a valid key.
-        if ( key.empty() ) {
+        if (key.empty()) {
             return false;
         }
 
@@ -311,70 +343,193 @@ struct aiMetadata {
 
         // Set metadata type
         mValues[index].mType = GetAiType(value);
+
         // Copy the given value to the dynamic storage
-        mValues[index].mData = new T(value);
+        if (nullptr != mValues[index].mData && AI_AIMETADATA != mValues[index].mType) {
+            ::memcpy(mValues[index].mData, &value, sizeof(T));
+        } else if (nullptr != mValues[index].mData && AI_AIMETADATA == mValues[index].mType) {
+            *static_cast<T *>(mValues[index].mData) = value;
+        } else {
+            if (nullptr != mValues[index].mData) {
+                delete static_cast<T *>(mValues[index].mData);
+                mValues[index].mData = nullptr;
+            }
+            mValues[index].mData = new T(value);
+        }
 
         return true;
     }
 
-    template<typename T>
-    inline 
-    bool Get( unsigned index, T& value ) const {
+    template <typename T>
+    inline bool Set(const std::string &key, const T &value) {
+        if (key.empty()) {
+            return false;
+        }
+
+        bool result = false;
+        for (unsigned int i = 0; i < mNumProperties; ++i) {
+            if (key == mKeys[i].C_Str()) {
+                Set(i, key, value);
+                result = true;
+                break;
+            }
+        }
+
+        return result;
+    }
+
+    template <typename T>
+    inline bool Get(unsigned index, T &value) const {
         // In range assertion
-        if ( index >= mNumProperties ) {
+        if (index >= mNumProperties) {
             return false;
         }
 
         // Return false if the output data type does
         // not match the found value's data type
-        if ( GetAiType( value ) != mValues[ index ].mType ) {
+        if (GetAiType(value) != mValues[index].mType) {
             return false;
         }
 
         // Otherwise, output the found value and
         // return true
-        value = *static_cast<T*>(mValues[index].mData);
+        value = *static_cast<T *>(mValues[index].mData);
 
         return true;
     }
 
-    template<typename T>
-    inline 
-    bool Get( const aiString& key, T& value ) const {
+    template <typename T>
+    inline bool Get(const aiString &key, T &value) const {
         // Search for the given key
-        for ( unsigned int i = 0; i < mNumProperties; ++i ) {
-            if ( mKeys[ i ] == key ) {
-                return Get( i, value );
+        for (unsigned int i = 0; i < mNumProperties; ++i) {
+            if (mKeys[i] == key) {
+                return Get(i, value);
             }
         }
         return false;
     }
 
-    template<typename T>
-    inline
-    bool Get( const std::string& key, T& value ) const {
+    template <typename T>
+    inline bool Get(const std::string &key, T &value) const {
         return Get(aiString(key), value);
     }
 
-	/// Return metadata entry for analyzing it by user.
-	/// \param [in] pIndex - index of the entry.
-	/// \param [out] pKey - pointer to the key value.
-	/// \param [out] pEntry - pointer to the entry: type and value.
-	/// \return false - if pIndex is out of range, else - true.
-	inline
-    bool Get(size_t index, const aiString*& key, const aiMetadataEntry*& entry) const {
-        if ( index >= mNumProperties ) {
+    /// Return metadata entry for analyzing it by user.
+    /// \param [in] pIndex - index of the entry.
+    /// \param [out] pKey - pointer to the key value.
+    /// \param [out] pEntry - pointer to the entry: type and value.
+    /// \return false - if pIndex is out of range, else - true.
+    inline bool Get(size_t index, const aiString *&key, const aiMetadataEntry *&entry) const {
+        if (index >= mNumProperties) {
             return false;
         }
 
-		key = &mKeys[index];
-		entry = &mValues[index];
+        key = &mKeys[index];
+        entry = &mValues[index];
 
-		return true;
-	}
+        return true;
+    }
+
+    /// Check whether there is a metadata entry for the given key.
+    /// \param [in] Key - the key value value to check for.
+    inline bool HasKey(const char *key) const {
+        if (nullptr == key) {
+            return false;
+        }
+
+        // Search for the given key
+        for (unsigned int i = 0; i < mNumProperties; ++i) {
+            if (0 == strncmp(mKeys[i].C_Str(), key, mKeys[i].length)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    friend bool CompareKeys(const aiMetadata &lhs, const aiMetadata &rhs) {
+        if (lhs.mNumProperties != rhs.mNumProperties) {
+            return false;
+        }
+
+        for (unsigned int i = 0; i < lhs.mNumProperties; ++i) {
+            if (lhs.mKeys[i] != rhs.mKeys[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    friend bool CompareValues(const aiMetadata &lhs, const aiMetadata &rhs) {
+        if (lhs.mNumProperties != rhs.mNumProperties) {
+            return false;
+        }
+
+        for (unsigned int i = 0; i < lhs.mNumProperties; ++i) {
+            if (lhs.mValues[i].mType != rhs.mValues[i].mType) {
+                return false;
+            }
+
+            switch (lhs.mValues[i].mType) {
+            case AI_BOOL: {
+                if (*static_cast<bool *>(lhs.mValues[i].mData) != *static_cast<bool *>(rhs.mValues[i].mData)) {
+                    return false;
+                }
+            } break;
+            case AI_INT32: {
+                if (*static_cast<int32_t *>(lhs.mValues[i].mData) != *static_cast<int32_t *>(rhs.mValues[i].mData)) {
+                    return false;
+                }
+            } break;
+            case AI_UINT64: {
+                if (*static_cast<uint64_t *>(lhs.mValues[i].mData) != *static_cast<uint64_t *>(rhs.mValues[i].mData)) {
+                    return false;
+                }
+            } break;
+            case AI_FLOAT: {
+                if (*static_cast<float *>(lhs.mValues[i].mData) != *static_cast<float *>(rhs.mValues[i].mData)) {
+                    return false;
+                }
+            } break;
+            case AI_DOUBLE: {
+                if (*static_cast<double *>(lhs.mValues[i].mData) != *static_cast<double *>(rhs.mValues[i].mData)) {
+                    return false;
+                }
+            } break;
+            case AI_AISTRING: {
+                if (*static_cast<aiString *>(lhs.mValues[i].mData) != *static_cast<aiString *>(rhs.mValues[i].mData)) {
+                    return false;
+                }
+            } break;
+            case AI_AIVECTOR3D: {
+                if (*static_cast<aiVector3D *>(lhs.mValues[i].mData) != *static_cast<aiVector3D *>(rhs.mValues[i].mData)) {
+                    return false;
+                }
+            } break;
+            case AI_AIMETADATA: {
+                if (*static_cast<aiMetadata *>(lhs.mValues[i].mData) != *static_cast<aiMetadata *>(rhs.mValues[i].mData)) {
+                    return false;
+                }
+            } break;
+#ifndef SWIG
+            case FORCE_32BIT:
+#endif
+            default:
+                break;
+            }
+        }
+
+        return true;
+    }
+
+    friend bool operator==(const aiMetadata &lhs, const aiMetadata &rhs) {
+        return CompareKeys(lhs, rhs) && CompareValues(lhs, rhs);
+    }
+
+    friend bool operator!=(const aiMetadata &lhs, const aiMetadata &rhs) {
+        return !(lhs == rhs);
+    }
 
 #endif // __cplusplus
-
 };
 
 #endif // AI_METADATA_H_INC
diff --git a/Engine/lib/assimp/include/assimp/pbrmaterial.h b/Engine/lib/assimp/include/assimp/pbrmaterial.h
index ce5f82217..3bdf151a3 100644
--- a/Engine/lib/assimp/include/assimp/pbrmaterial.h
+++ b/Engine/lib/assimp/include/assimp/pbrmaterial.h
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -42,36 +40,50 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 /** @file pbrmaterial.h
- *  @brief Defines the material system of the library
+ *  @brief Deprecated GLTF_PBR macros
  */
+#pragma once
 #ifndef AI_PBRMATERIAL_H_INC
 #define AI_PBRMATERIAL_H_INC
 
-#define AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_BASE_COLOR_FACTOR "$mat.gltf.pbrMetallicRoughness.baseColorFactor", 0, 0
-#define AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_METALLIC_FACTOR "$mat.gltf.pbrMetallicRoughness.metallicFactor", 0, 0
-#define AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_ROUGHNESS_FACTOR "$mat.gltf.pbrMetallicRoughness.roughnessFactor", 0, 0
-#define AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_BASE_COLOR_TEXTURE aiTextureType_DIFFUSE, 1
-#define AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_METALLICROUGHNESS_TEXTURE aiTextureType_UNKNOWN, 0
-#define AI_MATKEY_GLTF_ALPHAMODE "$mat.gltf.alphaMode", 0, 0
-#define AI_MATKEY_GLTF_ALPHACUTOFF "$mat.gltf.alphaCutoff", 0, 0
-#define AI_MATKEY_GLTF_PBRSPECULARGLOSSINESS "$mat.gltf.pbrSpecularGlossiness", 0, 0
-#define AI_MATKEY_GLTF_PBRSPECULARGLOSSINESS_GLOSSINESS_FACTOR "$mat.gltf.pbrMetallicRoughness.glossinessFactor", 0, 0
+#ifdef __GNUC__
+#   pragma GCC system_header
+#   warning pbrmaterial.h is deprecated. Please update to PBR materials in materials.h and glTF-specific items in GltfMaterial.h
+#else if defined(_MSC_VER)
+#   pragma message("pbrmaterial.h is deprecated. Please update to PBR materials in materials.h and glTF-specific items in GltfMaterial.h")
+#endif
+
+#include <assimp/material.h>
+#include <assimp/GltfMaterial.h>
+
+#define AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_BASE_COLOR_FACTOR AI_MATKEY_BASE_COLOR
+#define AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_BASE_COLOR_TEXTURE AI_MATKEY_BASE_COLOR_TEXTURE
+#define AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_METALLIC_FACTOR AI_MATKEY_METALLIC_FACTOR
+#define AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_ROUGHNESS_FACTOR AI_MATKEY_ROUGHNESS_FACTOR
+
+#define AI_MATKEY_GLTF_PBRSPECULARGLOSSINESS AI_MATKEY_GLOSSINESS_FACTOR
+#define AI_MATKEY_GLTF_PBRSPECULARGLOSSINESS_GLOSSINESS_FACTOR AI_MATKEY_GLOSSINESS_FACTOR
+
+// Use AI_MATKEY_SHADING_MODEL == aiShadingMode_Unlit instead
 #define AI_MATKEY_GLTF_UNLIT "$mat.gltf.unlit", 0, 0
 
-#define _AI_MATKEY_GLTF_TEXTURE_TEXCOORD_BASE "$tex.file.texCoord"
-#define _AI_MATKEY_GLTF_MAPPINGNAME_BASE "$tex.mappingname"
-#define _AI_MATKEY_GLTF_MAPPINGID_BASE "$tex.mappingid"
-#define _AI_MATKEY_GLTF_MAPPINGFILTER_MAG_BASE "$tex.mappingfiltermag"
-#define _AI_MATKEY_GLTF_MAPPINGFILTER_MIN_BASE "$tex.mappingfiltermin"
-#define _AI_MATKEY_GLTF_SCALE_BASE "$tex.scale"
-#define _AI_MATKEY_GLTF_STRENGTH_BASE "$tex.strength"
+//AI_MATKEY_GLTF_MATERIAL_SHEEN
+#define AI_MATKEY_GLTF_MATERIAL_SHEEN_COLOR_FACTOR AI_MATKEY_SHEEN_COLOR_FACTOR
+#define AI_MATKEY_GLTF_MATERIAL_SHEEN_ROUGHNESS_FACTOR AI_MATKEY_SHEEN_ROUGHNESS_FACTOR
+#define AI_MATKEY_GLTF_MATERIAL_SHEEN_COLOR_TEXTURE AI_MATKEY_SHEEN_COLOR_TEXTURE
+#define AI_MATKEY_GLTF_MATERIAL_SHEEN_ROUGHNESS_TEXTURE AI_MATKEY_SHEEN_ROUGHNESS_TEXTURE
 
-#define AI_MATKEY_GLTF_TEXTURE_TEXCOORD(type, N) _AI_MATKEY_GLTF_TEXTURE_TEXCOORD_BASE, type, N
-#define AI_MATKEY_GLTF_MAPPINGNAME(type, N) _AI_MATKEY_GLTF_MAPPINGNAME_BASE, type, N
-#define AI_MATKEY_GLTF_MAPPINGID(type, N) _AI_MATKEY_GLTF_MAPPINGID_BASE, type, N
-#define AI_MATKEY_GLTF_MAPPINGFILTER_MAG(type, N) _AI_MATKEY_GLTF_MAPPINGFILTER_MAG_BASE, type, N
-#define AI_MATKEY_GLTF_MAPPINGFILTER_MIN(type, N) _AI_MATKEY_GLTF_MAPPINGFILTER_MIN_BASE, type, N
-#define AI_MATKEY_GLTF_TEXTURE_SCALE(type, N) _AI_MATKEY_GLTF_SCALE_BASE, type, N
-#define AI_MATKEY_GLTF_TEXTURE_STRENGTH(type, N) _AI_MATKEY_GLTF_STRENGTH_BASE, type, N
+//AI_MATKEY_GLTF_MATERIAL_CLEARCOAT
+#define AI_MATKEY_GLTF_MATERIAL_CLEARCOAT_FACTOR AI_MATKEY_CLEARCOAT_FACTOR
+#define AI_MATKEY_GLTF_MATERIAL_CLEARCOAT_ROUGHNESS_FACTOR AI_MATKEY_CLEARCOAT_ROUGHNESS_FACTOR
+#define AI_MATKEY_GLTF_MATERIAL_CLEARCOAT_TEXTURE AI_MATKEY_CLEARCOAT_TEXTURE
+#define AI_MATKEY_GLTF_MATERIAL_CLEARCOAT_ROUGHNESS_TEXTURE AI_MATKEY_CLEARCOAT_ROUGHNESS_TEXTURE
+#define AI_MATKEY_GLTF_MATERIAL_CLEARCOAT_NORMAL_TEXTURE AI_MATKEY_CLEARCOAT_NORMAL_TEXTURE
+
+//AI_MATKEY_GLTF_MATERIAL_TRANSMISSION
+#define AI_MATKEY_GLTF_MATERIAL_TRANSMISSION_FACTOR AI_MATKEY_TRANSMISSION_FACTOR
+#define AI_MATKEY_GLTF_MATERIAL_TRANSMISSION_TEXTURE AI_MATKEY_TRANSMISSION_TEXTURE
+
+#define AI_MATKEY_GLTF_TEXTURE_TEXCOORD(type, N) AI_MATKEY_UVWSRC(type, N)
 
 #endif //!!AI_PBRMATERIAL_H_INC
diff --git a/Engine/lib/assimp/include/assimp/port/AndroidJNI/AndroidJNIIOSystem.h b/Engine/lib/assimp/include/assimp/port/AndroidJNI/AndroidJNIIOSystem.h
index 41d800487..29ad8e079 100644
--- a/Engine/lib/assimp/include/assimp/port/AndroidJNI/AndroidJNIIOSystem.h
+++ b/Engine/lib/assimp/include/assimp/port/AndroidJNI/AndroidJNIIOSystem.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2016, assimp team
+Copyright (c) 2006-2021, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -54,36 +54,32 @@ namespace Assimp	{
 
 // ---------------------------------------------------------------------------
 /** Android extension to DefaultIOSystem using the standard C file functions */
-class ASSIMP_API AndroidJNIIOSystem : public DefaultIOSystem
-{
+class ASSIMP_API AndroidJNIIOSystem : public DefaultIOSystem {
 public:
-
 	/** Initialize android activity data */
 	std::string mApkWorkspacePath;
 	AAssetManager* mApkAssetManager;
 
-	/** Constructor. */
+	/// Constructor.
 	AndroidJNIIOSystem(ANativeActivity* activity);
 
-	/** Destructor. */
+    /// Class constructor with past and asset manager.
+	AndroidJNIIOSystem(const char *internalPath, AAssetManager* assetManager);
+
+	/// Destructor.
 	~AndroidJNIIOSystem();
 
-	// -------------------------------------------------------------------
-	/** Tests for the existence of a file at the given path. */
+	/// Tests for the existence of a file at the given path.
 	bool Exists( const char* pFile) const;
 
-	// -------------------------------------------------------------------
-	/** Opens a file at the given path, with given mode */
+	/// Opens a file at the given path, with given mode
 	IOStream* Open( const char* strFile, const char* strMode);
 
-	// ------------------------------------------------------------------------------------------------
-	// Inits Android extractor
+	/// Inits Android extractor
 	void AndroidActivityInit(ANativeActivity* activity);
 
-	// ------------------------------------------------------------------------------------------------
-	// Extracts android asset
+	/// Extracts android asset
 	bool AndroidExtractAsset(std::string name);
-
 };
 
 } //!ns Assimp
diff --git a/Engine/lib/assimp/include/assimp/port/AndroidJNI/BundledAssetIOSystem.h b/Engine/lib/assimp/include/assimp/port/AndroidJNI/BundledAssetIOSystem.h
new file mode 100644
index 000000000..bc1ce7878
--- /dev/null
+++ b/Engine/lib/assimp/include/assimp/port/AndroidJNI/BundledAssetIOSystem.h
@@ -0,0 +1,93 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2021, assimp team
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file Android implementation of IOSystem using the standard C file functions.
+ * Aimed to ease the access to android assets */
+
+#if __ANDROID__ and __ANDROID_API__ > 9 and defined(AI_CONFIG_ANDROID_JNI_ASSIMP_MANAGER_SUPPORT)
+#ifndef AI_BUNDLEDASSETIOSYSTEM_H_INC
+#define AI_BUNDLEDASSETIOSYSTEM_H_INC
+
+#include <android/asset_manager_jni.h>
+
+#include <assimp/DefaultIOSystem.h>
+#include <assimp/IOStream.hpp>
+
+namespace Assimp        {
+
+class BundledAssetIOSystem : public Assimp::DefaultIOSystem {
+
+public:
+    AAssetManager* mApkAssetManager;
+
+    BundledAssetIOSystem(JNIEnv* env, jobject assetManager) { mApkAssetManager = AAssetManager_fromJava(env, assetManager); }
+    ~BundledAssetIOSystem() {};
+
+    bool Exists( const char* pFile) const;
+
+    Assimp::IOStream* Open( const char* pFile, const char* pMode = "rb");
+
+    void Close( Assimp::IOStream* pFile);
+
+private:
+
+    class AssetIOStream : public Assimp::IOStream {
+        AAsset * asset;
+
+    public:
+        AssetIOStream(AAsset *asset) { this->asset = asset; };
+        ~AssetIOStream() { AAsset_close(asset); }
+
+        size_t Read(void* pvBuffer, size_t pSize, size_t pCount) { return AAsset_read(asset, pvBuffer, pSize * pCount);}
+        size_t Write(const void* pvBuffer, size_t pSize, size_t pCount) { return 0; };
+        aiReturn Seek(size_t pOffset, aiOrigin pOrigin) { return (AAsset_seek(asset, pOffset, pOrigin) >= 0 ? aiReturn_SUCCESS : aiReturn_FAILURE); }
+        size_t Tell() const { return(AAsset_getLength(asset) - AAsset_getRemainingLength(asset)); };
+        size_t FileSize() const  { return  AAsset_getLength(asset); }
+        void Flush() { }
+    };
+
+};
+
+
+} //!ns Assimp
+
+#endif //AI_BUNDLEDASSETIOSYSTEM_H_INC
+#endif //__ANDROID__ and __ANDROID_API__ > 9 and defined(AI_CONFIG_ANDROID_JNI_ASSIMP_MANAGER_SUPPORT)
+
diff --git a/Engine/lib/assimp/include/assimp/postprocess.h b/Engine/lib/assimp/include/assimp/postprocess.h
index 2a7441421..cdcbf0577 100644
--- a/Engine/lib/assimp/include/assimp/postprocess.h
+++ b/Engine/lib/assimp/include/assimp/postprocess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -47,7 +47,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_POSTPROCESS_H_INC
 #define AI_POSTPROCESS_H_INC
 
-#include "types.h"
+#include <assimp/types.h>
+
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
 
 #ifdef __cplusplus
 extern "C" {
@@ -205,9 +209,14 @@ enum aiPostProcessSteps
     /** <hr>Removes the node graph and pre-transforms all vertices with
     * the local transformation matrices of their nodes.
     *
-    * The output scene still contains nodes, however there is only a
-    * root node with children, each one referencing only one mesh,
-    * and each mesh referencing one material. For rendering, you can
+    * If the resulting scene can be reduced to a single mesh, with a single
+    * material, no lights, and no cameras, then the output scene will contain
+    * only a root node (with no children) that references the single mesh.
+    * Otherwise, the output scene will be reduced to a root node with a single
+    * level of child nodes, each one referencing one mesh, and each mesh
+    * referencing one material.
+    *
+    * In either case, for rendering, you can
     * simply render all meshes in order - you don't need to pay
     * attention to local transformations and the node hierarchy.
     * Animations are removed during this step.
@@ -316,6 +325,19 @@ enum aiPostProcessSteps
     */
     aiProcess_FixInfacingNormals = 0x2000,
 
+
+
+    // -------------------------------------------------------------------------
+    /**
+     * This step generically populates aiBone->mArmature and aiBone->mNode generically
+     * The point of these is it saves you later having to calculate these elements
+     * This is useful when handling rest information or skin information
+     * If you have multiple armatures on your models we strongly recommend enabling this
+     * Instead of writing your own multi-root, multi-armature lookups we have done the
+     * hard work for you :)
+   */
+    aiProcess_PopulateArmatureData = 0x4000,
+
     // -------------------------------------------------------------------------
     /** <hr>This step splits meshes with more than one primitive type in
      *  homogeneous sub-meshes.
@@ -418,7 +440,7 @@ enum aiPostProcessSteps
      *
      * @note UV transformations are usually implemented in real-time apps by
      * transforming texture coordinates at vertex shader stage with a 3x3
-     * (homogenous) transformation matrix.
+     * (homogeneous) transformation matrix.
     */
     aiProcess_TransformUVCoords = 0x80000,
 
@@ -533,6 +555,8 @@ enum aiPostProcessSteps
     */
     aiProcess_Debone  = 0x4000000,
 
+
+
     // -------------------------------------------------------------------------
     /** <hr>This step will perform a global scale of the model.
     *
@@ -555,7 +579,7 @@ enum aiPostProcessSteps
      *  of the imported model. And if so, it uses that.
      */
     aiProcess_EmbedTextures  = 0x10000000,
-        
+
     // aiProcess_GenEntityMeshes = 0x100000,
     // aiProcess_OptimizeAnimations = 0x200000
     // aiProcess_FixTexturePaths = 0x200000
diff --git a/Engine/lib/assimp/include/assimp/qnan.h b/Engine/lib/assimp/include/assimp/qnan.h
index 0918bde5e..c64cabaad 100644
--- a/Engine/lib/assimp/include/assimp/qnan.h
+++ b/Engine/lib/assimp/include/assimp/qnan.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -50,19 +50,23 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *     but last time I checked compiler coverage was so bad that I decided
  *     to reinvent the wheel.
  */
-
+#pragma once
 #ifndef AI_QNAN_H_INCLUDED
 #define AI_QNAN_H_INCLUDED
 
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
 #include <assimp/defs.h>
+
 #include <limits>
 #include <stdint.h>
 
 // ---------------------------------------------------------------------------
 /** Data structure to represent the bit pattern of a 32 Bit
  *         IEEE 754 floating-point number. */
-union _IEEESingle
-{
+union _IEEESingle {
     float Float;
     struct
     {
@@ -75,8 +79,7 @@ union _IEEESingle
 // ---------------------------------------------------------------------------
 /** Data structure to represent the bit pattern of a 64 Bit
  *         IEEE 754 floating-point number. */
-union _IEEEDouble
-{
+union _IEEEDouble {
     double Double;
     struct
     {
@@ -89,8 +92,7 @@ union _IEEEDouble
 // ---------------------------------------------------------------------------
 /** Check whether a given float is qNaN.
  *  @param in Input value */
-AI_FORCE_INLINE bool is_qnan(float in)
-{
+AI_FORCE_INLINE bool is_qnan(float in) {
     // the straightforward solution does not work:
     //   return (in != in);
     // compiler generates code like this
@@ -107,8 +109,7 @@ AI_FORCE_INLINE bool is_qnan(float in)
 // ---------------------------------------------------------------------------
 /** Check whether a given double is qNaN.
  *  @param in Input value */
-AI_FORCE_INLINE bool is_qnan(double in)
-{
+AI_FORCE_INLINE bool is_qnan(double in) {
     // the straightforward solution does not work:
     //   return (in != in);
     // compiler generates code like this
@@ -127,8 +128,7 @@ AI_FORCE_INLINE bool is_qnan(double in)
  *
  *  Denorms return false, they're treated like normal values.
  *  @param in Input value */
-AI_FORCE_INLINE bool is_special_float(float in)
-{
+AI_FORCE_INLINE bool is_special_float(float in) {
     _IEEESingle temp;
     memcpy(&temp, &in, sizeof(float));
     return (temp.IEEE.Exp == (1u << 8)-1);
@@ -139,8 +139,7 @@ AI_FORCE_INLINE bool is_special_float(float in)
  *
  *  Denorms return false, they're treated like normal values.
  *  @param in Input value */
-AI_FORCE_INLINE bool is_special_float(double in)
-{
+AI_FORCE_INLINE bool is_special_float(double in) {
    _IEEESingle temp;
     memcpy(&temp, &in, sizeof(float));
     return (temp.IEEE.Exp == (1u << 11)-1);
@@ -150,15 +149,13 @@ AI_FORCE_INLINE bool is_special_float(double in)
 /** Check whether a float is NOT qNaN.
  *  @param in Input value */
 template<class TReal>
-AI_FORCE_INLINE bool is_not_qnan(TReal in)
-{
+AI_FORCE_INLINE bool is_not_qnan(TReal in) {
     return !is_qnan(in);
 }
 
 // ---------------------------------------------------------------------------
 /** @brief Get a fresh qnan.  */
-AI_FORCE_INLINE ai_real get_qnan()
-{
+AI_FORCE_INLINE ai_real get_qnan() {
     return std::numeric_limits<ai_real>::quiet_NaN();
 }
 
diff --git a/Engine/lib/assimp/include/assimp/quaternion.h b/Engine/lib/assimp/include/assimp/quaternion.h
index 96574d24b..b6d0a5681 100644
--- a/Engine/lib/assimp/include/assimp/quaternion.h
+++ b/Engine/lib/assimp/include/assimp/quaternion.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 All rights reserved.
@@ -49,10 +49,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef __cplusplus
 
-#include "defs.h"
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
+#include <assimp/defs.h>
 
 template <typename TReal> class aiVector3t;
 template <typename TReal> class aiMatrix3x3t;
+template <typename TReal> class aiMatrix4x4t;
 
 // ---------------------------------------------------------------------------
 /** Represents a quaternion in a 4D vector. */
@@ -68,7 +73,7 @@ public:
     explicit aiQuaterniont( const aiMatrix3x3t<TReal>& pRotMatrix);
 
     /** Construct from euler angles */
-    aiQuaterniont( TReal rotx, TReal roty, TReal rotz);
+    aiQuaterniont( TReal roty, TReal rotz, TReal rotx);
 
     /** Construct from an axis-angle pair */
     aiQuaterniont( aiVector3t<TReal> axis, TReal angle);
@@ -84,7 +89,10 @@ public:
     bool operator== (const aiQuaterniont& o) const;
     bool operator!= (const aiQuaterniont& o) const;
 
-    bool Equal(const aiQuaterniont& o, TReal epsilon = 1e-6) const;
+    // transform vector by matrix
+    aiQuaterniont& operator *= (const aiMatrix4x4t<TReal>& mat);
+
+    bool Equal(const aiQuaterniont &o, TReal epsilon = ai_epsilon) const;
 
 public:
 
@@ -95,7 +103,7 @@ public:
     aiQuaterniont& Conjugate ();
 
     /** Rotate a point by this quaternion */
-    aiVector3t<TReal> Rotate (const aiVector3t<TReal>& in);
+    aiVector3t<TReal> Rotate (const aiVector3t<TReal>& in) const;
 
     /** Multiply two quaternions */
     aiQuaterniont operator* (const aiQuaterniont& two) const;
diff --git a/Engine/lib/assimp/include/assimp/quaternion.inl b/Engine/lib/assimp/include/assimp/quaternion.inl
index c26648215..960e91ab2 100644
--- a/Engine/lib/assimp/include/assimp/quaternion.inl
+++ b/Engine/lib/assimp/include/assimp/quaternion.inl
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -48,11 +48,27 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_QUATERNION_INL_INC
 #define AI_QUATERNION_INL_INC
 
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
 #ifdef __cplusplus
-#include "quaternion.h"
+#include <assimp/quaternion.h>
 
 #include <cmath>
 
+// ------------------------------------------------------------------------------------------------
+/** Transformation of a quaternion by a 4x4 matrix */
+template <typename TReal>
+AI_FORCE_INLINE
+aiQuaterniont<TReal> operator * (const aiMatrix4x4t<TReal>& pMatrix, const aiQuaterniont<TReal>& pQuaternion) {
+    aiQuaterniont<TReal> res;
+    res.x = pMatrix.a1 * pQuaternion.x + pMatrix.a2 * pQuaternion.y + pMatrix.a3 * pQuaternion.z + pMatrix.a4 * pQuaternion.w;
+    res.y = pMatrix.b1 * pQuaternion.x + pMatrix.b2 * pQuaternion.y + pMatrix.b3 * pQuaternion.z + pMatrix.b4 * pQuaternion.w;
+    res.z = pMatrix.c1 * pQuaternion.x + pMatrix.c2 * pQuaternion.y + pMatrix.c3 * pQuaternion.z + pMatrix.c4 * pQuaternion.w;
+    res.w = pMatrix.d1 * pQuaternion.x + pMatrix.d2 * pQuaternion.y + pMatrix.d3 * pQuaternion.z + pMatrix.d4 * pQuaternion.w;
+    return res;
+}
 // ---------------------------------------------------------------------------
 template<typename TReal>
 bool aiQuaterniont<TReal>::operator== (const aiQuaterniont& o) const
@@ -67,6 +83,14 @@ bool aiQuaterniont<TReal>::operator!= (const aiQuaterniont& o) const
     return !(*this == o);
 }
 
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE
+aiQuaterniont<TReal>& aiQuaterniont<TReal>::operator *= (const aiMatrix4x4t<TReal>& mat){
+    return (*this = mat * (*this));
+}
+// ------------------------------------------------------------------------------------------------
+
 // ---------------------------------------------------------------------------
 template<typename TReal>
 inline bool aiQuaterniont<TReal>::Equal(const aiQuaterniont& o, TReal epsilon) const {
@@ -273,7 +297,7 @@ inline aiQuaterniont<TReal>& aiQuaterniont<TReal>::Conjugate ()
 
 // ---------------------------------------------------------------------------
 template<typename TReal>
-inline aiVector3t<TReal> aiQuaterniont<TReal>::Rotate (const aiVector3t<TReal>& v)
+inline aiVector3t<TReal> aiQuaterniont<TReal>::Rotate (const aiVector3t<TReal>& v) const
 {
     aiQuaterniont q2(0.f,v.x,v.y,v.z), q = *this, qinv = q;
     qinv.Conjugate();
diff --git a/Engine/lib/assimp/include/assimp/revision.h b/Engine/lib/assimp/include/assimp/revision.h
deleted file mode 100644
index 4d27fd8d7..000000000
--- a/Engine/lib/assimp/include/assimp/revision.h
+++ /dev/null
@@ -1,28 +0,0 @@
-#ifndef ASSIMP_REVISION_H_INC
-#define ASSIMP_REVISION_H_INC
-
-#define GitVersion 0x0
-#define GitBranch ""
-
-#define VER_MAJOR 5
-#define VER_MINOR 0
-#define VER_PATCH 0
-#define VER_BUILD 0
-
-#define STR_HELP(x) #x
-#define STR(x) STR_HELP(x)
-
-#define VER_FILEVERSION             VER_MAJOR,VER_MINOR,VER_PATCH,VER_BUILD
-#if (GitVersion == 0)
-#define VER_FILEVERSION_STR         STR(VER_MAJOR) "." STR(VER_MINOR) "." STR(VER_PATCH) "." STR(VER_BUILD)
-#else
-#define VER_FILEVERSION_STR         STR(VER_MAJOR) "." STR(VER_MINOR) "." STR(VER_PATCH) "." STR(VER_BUILD) " (Commit 0)"
-#endif
-
-#ifdef  NDEBUG
-#define VER_ORIGINAL_FILENAME_STR   "assimp.dll"
-#else
-#define VER_ORIGINAL_FILENAME_STR   "assimp.dll"
-#endif //  NDEBUG
-
-#endif // ASSIMP_REVISION_H_INC
diff --git a/Engine/lib/assimp/include/assimp/scene.h b/Engine/lib/assimp/include/assimp/scene.h
index 2667db85b..f4c6d7960 100644
--- a/Engine/lib/assimp/include/assimp/scene.h
+++ b/Engine/lib/assimp/include/assimp/scene.h
@@ -1,11 +1,9 @@
-/*
+/*
 ---------------------------------------------------------------------------
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -48,14 +46,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_SCENE_H_INC
 #define AI_SCENE_H_INC
 
-#include "types.h"
-#include "texture.h"
-#include "mesh.h"
-#include "light.h"
-#include "camera.h"
-#include "material.h"
-#include "anim.h"
-#include "metadata.h"
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
+#include <assimp/types.h>
+#include <assimp/texture.h>
+#include <assimp/mesh.h>
+#include <assimp/light.h>
+#include <assimp/camera.h>
+#include <assimp/material.h>
+#include <assimp/anim.h>
+#include <assimp/metadata.h>
 
 #ifdef __cplusplus
 #  include <cstdlib>
@@ -68,7 +70,7 @@ extern "C" {
 #endif
 
 // -------------------------------------------------------------------------------
-/** 
+/**
  * A node in the imported hierarchy.
  *
  * Each node has name, a parent node (except for the root node),
@@ -106,13 +108,13 @@ struct ASSIMP_API aiNode
     /** The transformation relative to the node's parent. */
     C_STRUCT aiMatrix4x4 mTransformation;
 
-    /** Parent node. NULL if this node is the root node. */
+    /** Parent node. nullptr if this node is the root node. */
     C_STRUCT aiNode* mParent;
 
     /** The number of child nodes of this node. */
     unsigned int mNumChildren;
 
-    /** The child nodes of this node. NULL if mNumChildren is 0. */
+    /** The child nodes of this node. nullptr if mNumChildren is 0. */
     C_STRUCT aiNode** mChildren;
 
     /** The number of meshes of this node. */
@@ -123,7 +125,7 @@ struct ASSIMP_API aiNode
       */
     unsigned int* mMeshes;
 
-    /** Metadata associated with this node or NULL if there is no metadata.
+    /** Metadata associated with this node or nullptr if there is no metadata.
       *  Whether any metadata is generated depends on the source file format. See the
       * @link importer_notes @endlink page for more information on every source file
       * format. Importers that don't document any metadata don't write any.
@@ -145,14 +147,14 @@ struct ASSIMP_API aiNode
      *  of the scene.
      *
      *  @param name Name to search for
-     *  @return NULL or a valid Node if the search was successful.
+     *  @return nullptr or a valid Node if the search was successful.
      */
-    inline 
+    inline
     const aiNode* FindNode(const aiString& name) const {
         return FindNode(name.data);
     }
 
-    inline 
+    inline
     aiNode* FindNode(const aiString& name) {
         return FindNode(name.data);
     }
@@ -331,16 +333,19 @@ struct aiScene
     /**
      *  @brief  The global metadata assigned to the scene itself.
      *
-     *  This data contains global metadata which belongs to the scene like 
-     *  unit-conversions, versions, vendors or other model-specific data. This 
+     *  This data contains global metadata which belongs to the scene like
+     *  unit-conversions, versions, vendors or other model-specific data. This
      *  can be used to store format-specific metadata as well.
      */
     C_STRUCT aiMetadata* mMetaData;
 
+    /** The name of the scene itself.
+     */
+    C_STRUCT aiString mName;
 
 #ifdef __cplusplus
 
-    //! Default constructor - set everything to 0/NULL
+    //! Default constructor - set everything to 0/nullptr
     ASSIMP_API aiScene();
 
     //! Destructor
@@ -348,34 +353,34 @@ struct aiScene
 
     //! Check whether the scene contains meshes
     //! Unless no special scene flags are set this will always be true.
-    inline bool HasMeshes() const { 
-        return mMeshes != NULL && mNumMeshes > 0; 
+    inline bool HasMeshes() const {
+        return mMeshes != nullptr && mNumMeshes > 0;
     }
 
     //! Check whether the scene contains materials
     //! Unless no special scene flags are set this will always be true.
-    inline bool HasMaterials() const { 
-        return mMaterials != NULL && mNumMaterials > 0; 
+    inline bool HasMaterials() const {
+        return mMaterials != nullptr && mNumMaterials > 0;
     }
 
     //! Check whether the scene contains lights
-    inline bool HasLights() const { 
-        return mLights != NULL && mNumLights > 0; 
+    inline bool HasLights() const {
+        return mLights != nullptr && mNumLights > 0;
     }
 
     //! Check whether the scene contains textures
     inline bool HasTextures() const {
-        return mTextures != NULL && mNumTextures > 0; 
+        return mTextures != nullptr && mNumTextures > 0;
     }
 
     //! Check whether the scene contains cameras
     inline bool HasCameras() const {
-        return mCameras != NULL && mNumCameras > 0; 
+        return mCameras != nullptr && mNumCameras > 0;
     }
 
     //! Check whether the scene contains animations
-    inline bool HasAnimations() const { 
-        return mAnimations != NULL && mNumAnimations > 0; 
+    inline bool HasAnimations() const {
+        return mAnimations != nullptr && mNumAnimations > 0;
     }
 
     //! Returns a short filename from a full path
@@ -390,22 +395,35 @@ struct aiScene
 
     //! Returns an embedded texture
     const aiTexture* GetEmbeddedTexture(const char* filename) const {
+        return GetEmbeddedTextureAndIndex(filename).first;
+    }
+
+    //! Returns an embedded texture and its index
+    std::pair<const aiTexture*, int> GetEmbeddedTextureAndIndex(const char* filename) const {
+        if (nullptr==filename) {
+            return std::make_pair(nullptr, -1);
+        }
         // lookup using texture ID (if referenced like: "*1", "*2", etc.)
         if ('*' == *filename) {
             int index = std::atoi(filename + 1);
-            if (0 > index || mNumTextures <= static_cast<unsigned>(index))
-                return nullptr;
-            return mTextures[index];
+            if (0 > index || mNumTextures <= static_cast<unsigned>(index)) {
+                return std::make_pair(nullptr, -1);
+            }
+            return std::make_pair(mTextures[index], index);
         }
         // lookup using filename
         const char* shortFilename = GetShortFilename(filename);
+        if (nullptr == shortFilename) {
+            return std::make_pair(nullptr, -1);
+        }
+
         for (unsigned int i = 0; i < mNumTextures; i++) {
             const char* shortTextureFilename = GetShortFilename(mTextures[i]->mFilename.C_Str());
             if (strcmp(shortTextureFilename, shortFilename) == 0) {
-                return mTextures[i];
+                return std::make_pair(mTextures[i], i);
             }
         }
-        return nullptr;
+        return std::make_pair(nullptr, -1);
     }
 #endif // __cplusplus
 
@@ -419,7 +437,7 @@ struct aiScene
 };
 
 #ifdef __cplusplus
-} //! namespace Assimp
-#endif
+} 
+#endif //! extern "C"
 
 #endif // AI_SCENE_H_INC
diff --git a/Engine/lib/assimp/include/assimp/texture.h b/Engine/lib/assimp/include/assimp/texture.h
index dc6cbef65..576fa7711 100644
--- a/Engine/lib/assimp/include/assimp/texture.h
+++ b/Engine/lib/assimp/include/assimp/texture.h
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -53,13 +51,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_TEXTURE_H_INC
 #define AI_TEXTURE_H_INC
 
-#include "types.h"
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
+#include <assimp/types.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-
 // --------------------------------------------------------------------------------
 
 /** \def AI_EMBEDDED_TEXNAME_PREFIX
@@ -79,7 +80,6 @@ extern "C" {
 #   define AI_MAKE_EMBEDDED_TEXNAME(_n_) AI_EMBEDDED_TEXNAME_PREFIX # _n_
 #endif
 
-
 #include "./Compiler/pushpack1.h"
 
 // --------------------------------------------------------------------------------
@@ -87,28 +87,24 @@ extern "C" {
 *
 *  Used by aiTexture.
 */
-struct aiTexel
-{
+struct aiTexel {
     unsigned char b,g,r,a;
 
 #ifdef __cplusplus
     //! Comparison operator
-    bool operator== (const aiTexel& other) const
-    {
+    bool operator== (const aiTexel& other) const {
         return b == other.b && r == other.r &&
                g == other.g && a == other.a;
     }
 
     //! Inverse comparison operator
-    bool operator!= (const aiTexel& other) const
-    {
+    bool operator!= (const aiTexel& other) const {
         return b != other.b || r != other.r ||
                g != other.g || a != other.a;
     }
 
     //! Conversion to a floating-point 4d color
-    operator aiColor4D() const
-    {
+    operator aiColor4D() const {
         return aiColor4D(r/255.f,g/255.f,b/255.f,a/255.f);
     }
 #endif // __cplusplus
@@ -203,13 +199,12 @@ struct aiTexture {
     }
 
     // Construction
-    aiTexture() AI_NO_EXCEPT
-    : mWidth(0)
-    , mHeight(0)
-    , pcData(nullptr)
-    , mFilename() {
-        achFormatHint[0] = achFormatHint[1] = 0;
-        achFormatHint[2] = achFormatHint[3] = 0;
+    aiTexture() AI_NO_EXCEPT :
+            mWidth(0),
+            mHeight(0),
+            pcData(nullptr),
+            mFilename() {
+        memset(achFormatHint, 0, sizeof(achFormatHint));
     }
 
     // Destruction
diff --git a/Engine/lib/assimp/include/assimp/types.h b/Engine/lib/assimp/include/assimp/types.h
index 8ad5680f3..a41363b8a 100644
--- a/Engine/lib/assimp/include/assimp/types.h
+++ b/Engine/lib/assimp/include/assimp/types.h
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -48,38 +46,42 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_TYPES_H_INC
 #define AI_TYPES_H_INC
 
+#ifdef __GNUC__
+#pragma GCC system_header
+#endif
+
 // Some runtime headers
-#include <sys/types.h>
-#include <stddef.h>
-#include <string.h>
 #include <limits.h>
+#include <stddef.h>
 #include <stdint.h>
+#include <string.h>
+#include <sys/types.h>
 
 // Our compile configuration
-#include "defs.h"
+#include <assimp/defs.h>
 
 // Some types moved to separate header due to size of operators
-#include "vector3.h"
-#include "vector2.h"
-#include "color4.h"
-#include "matrix3x3.h"
-#include "matrix4x4.h"
-#include "quaternion.h"
+#include <assimp/vector2.h>
+#include <assimp/vector3.h>
+#include <assimp/color4.h>
+#include <assimp/matrix3x3.h>
+#include <assimp/matrix4x4.h>
+#include <assimp/quaternion.h>
 
 typedef int32_t ai_int32;
-typedef uint32_t ai_uint32 ;
+typedef uint32_t ai_uint32;
 
 #ifdef __cplusplus
+
 #include <cstring>
-#include <new>      // for std::nothrow_t
-#include <string>   // for aiString::Set(const std::string&)
+#include <new> // for std::nothrow_t
+#include <string> // for aiString::Set(const std::string&)
 
-
-namespace Assimp    {
-    //! @cond never
-namespace Intern        {
-    // --------------------------------------------------------------------
-    /** @brief Internal helper class to utilize our internal new/delete
+namespace Assimp {
+//! @cond never
+namespace Intern {
+// --------------------------------------------------------------------
+/** @brief Internal helper class to utilize our internal new/delete
      *    routines for allocating object of this and derived classes.
      *
      * By doing this you can safely share class objects between Assimp
@@ -90,25 +92,25 @@ namespace Intern        {
      * If it lies on a different heap than Assimp is working with,
      * the application is determined to crash.
      */
-    // --------------------------------------------------------------------
+// --------------------------------------------------------------------
 #ifndef SWIG
-    struct ASSIMP_API AllocateFromAssimpHeap    {
-        // http://www.gotw.ca/publications/mill15.htm
+struct ASSIMP_API AllocateFromAssimpHeap {
+    // http://www.gotw.ca/publications/mill15.htm
 
-        // new/delete overload
-        void *operator new    ( size_t num_bytes) /* throw( std::bad_alloc ) */;
-        void *operator new    ( size_t num_bytes, const std::nothrow_t& ) throw();
-        void  operator delete ( void* data);
+    // new/delete overload
+    void *operator new(size_t num_bytes) /* throw( std::bad_alloc ) */;
+    void *operator new(size_t num_bytes, const std::nothrow_t &) throw();
+    void operator delete(void *data);
 
-        // array new/delete overload
-        void *operator new[]    ( size_t num_bytes) /* throw( std::bad_alloc ) */;
-        void *operator new[]    ( size_t num_bytes, const std::nothrow_t& )  throw();
-        void  operator delete[] ( void* data);
+    // array new/delete overload
+    void *operator new[](size_t num_bytes) /* throw( std::bad_alloc ) */;
+    void *operator new[](size_t num_bytes, const std::nothrow_t &) throw();
+    void operator delete[](void *data);
 
-    }; // struct AllocateFromAssimpHeap
+}; // struct AllocateFromAssimpHeap
 #endif
 } // namespace Intern
-    //! @endcond
+//! @endcond
 } // namespace Assimp
 
 extern "C" {
@@ -116,9 +118,9 @@ extern "C" {
 
 /** Maximum dimension for strings, ASSIMP strings are zero terminated. */
 #ifdef __cplusplus
-    static const size_t MAXLEN = 1024;
+static const size_t MAXLEN = 1024;
 #else
-#   define MAXLEN 1024
+#define MAXLEN 1024
 #endif
 
 // ----------------------------------------------------------------------------------
@@ -126,16 +128,17 @@ extern "C" {
 */
 struct aiPlane {
 #ifdef __cplusplus
-    aiPlane () AI_NO_EXCEPT : a(0.f), b(0.f), c(0.f), d(0.f) {}
-    aiPlane (ai_real _a, ai_real _b, ai_real _c, ai_real _d)
-        : a(_a), b(_b), c(_c), d(_d) {}
+    aiPlane() AI_NO_EXCEPT : a(0.f), b(0.f), c(0.f), d(0.f) {}
+    aiPlane(ai_real _a, ai_real _b, ai_real _c, ai_real _d) :
+            a(_a), b(_b), c(_c), d(_d) {}
 
-    aiPlane (const aiPlane& o) : a(o.a), b(o.b), c(o.c), d(o.d) {}
+    aiPlane(const aiPlane &o) :
+            a(o.a), b(o.b), c(o.c), d(o.d) {}
 
 #endif // !__cplusplus
 
     //! Plane equation
-    ai_real a,b,c,d;
+    ai_real a, b, c, d;
 }; // !struct aiPlane
 
 // ----------------------------------------------------------------------------------
@@ -143,11 +146,12 @@ struct aiPlane {
 */
 struct aiRay {
 #ifdef __cplusplus
-    aiRay () AI_NO_EXCEPT {}
-    aiRay (const aiVector3D& _pos, const aiVector3D& _dir)
-        : pos(_pos), dir(_dir) {}
+    aiRay() AI_NO_EXCEPT {}
+    aiRay(const aiVector3D &_pos, const aiVector3D &_dir) :
+            pos(_pos), dir(_dir) {}
 
-    aiRay (const aiRay& o) : pos (o.pos), dir (o.dir) {}
+    aiRay(const aiRay &o) :
+            pos(o.pos), dir(o.dir) {}
 
 #endif // !__cplusplus
 
@@ -158,55 +162,55 @@ struct aiRay {
 // ----------------------------------------------------------------------------------
 /** Represents a color in Red-Green-Blue space.
 */
-struct aiColor3D
-{
+struct aiColor3D {
 #ifdef __cplusplus
-    aiColor3D () AI_NO_EXCEPT : r(0.0f), g(0.0f), b(0.0f) {}
-    aiColor3D (ai_real _r, ai_real _g, ai_real _b) : r(_r), g(_g), b(_b) {}
-    explicit aiColor3D (ai_real _r) : r(_r), g(_r), b(_r) {}
-    aiColor3D (const aiColor3D& o) : r(o.r), g(o.g), b(o.b) {}
+    aiColor3D() AI_NO_EXCEPT : r(0.0f), g(0.0f), b(0.0f) {}
+    aiColor3D(ai_real _r, ai_real _g, ai_real _b) :
+            r(_r), g(_g), b(_b) {}
+    explicit aiColor3D(ai_real _r) :
+            r(_r), g(_r), b(_r) {}
+    aiColor3D(const aiColor3D &o) :
+            r(o.r), g(o.g), b(o.b) {}
 
-	aiColor3D &operator=(const aiColor3D &o) {
-		r = o.r;
-		g = o.g;
-		b = o.b;
-		return *this;
-	}
-
-	/** Component-wise comparison */
-    // TODO: add epsilon?
-    bool operator == (const aiColor3D& other) const
-        {return r == other.r && g == other.g && b == other.b;}
-
-    /** Component-wise inverse comparison */
-    // TODO: add epsilon?
-    bool operator != (const aiColor3D& other) const
-        {return r != other.r || g != other.g || b != other.b;}
+    aiColor3D &operator=(const aiColor3D &o) {
+        r = o.r;
+        g = o.g;
+        b = o.b;
+        return *this;
+    }
 
     /** Component-wise comparison */
     // TODO: add epsilon?
-    bool operator < (const aiColor3D& other) const {
-        return r < other.r || ( r == other.r && (g < other.g || (g == other.g && b < other.b ) ) );
+    bool operator==(const aiColor3D &other) const { return r == other.r && g == other.g && b == other.b; }
+
+    /** Component-wise inverse comparison */
+    // TODO: add epsilon?
+    bool operator!=(const aiColor3D &other) const { return r != other.r || g != other.g || b != other.b; }
+
+    /** Component-wise comparison */
+    // TODO: add epsilon?
+    bool operator<(const aiColor3D &other) const {
+        return r < other.r || (r == other.r && (g < other.g || (g == other.g && b < other.b)));
     }
 
     /** Component-wise addition */
-    aiColor3D operator+(const aiColor3D& c) const {
-        return aiColor3D(r+c.r,g+c.g,b+c.b);
+    aiColor3D operator+(const aiColor3D &c) const {
+        return aiColor3D(r + c.r, g + c.g, b + c.b);
     }
 
     /** Component-wise subtraction */
-    aiColor3D operator-(const aiColor3D& c) const {
-        return aiColor3D(r-c.r,g-c.g,b-c.b);
+    aiColor3D operator-(const aiColor3D &c) const {
+        return aiColor3D(r - c.r, g - c.g, b - c.b);
     }
 
     /** Component-wise multiplication */
-    aiColor3D operator*(const aiColor3D& c) const {
-        return aiColor3D(r*c.r,g*c.g,b*c.b);
+    aiColor3D operator*(const aiColor3D &c) const {
+        return aiColor3D(r * c.r, g * c.g, b * c.b);
     }
 
     /** Multiply with a scalar */
     aiColor3D operator*(ai_real f) const {
-        return aiColor3D(r*f,g*f,b*f);
+        return aiColor3D(r * f, g * f, b * f);
     }
 
     /** Access a specific color component */
@@ -215,12 +219,12 @@ struct aiColor3D
     }
 
     /** Access a specific color component */
-    ai_real& operator[](unsigned int i) {
-        if ( 0 == i ) {
+    ai_real &operator[](unsigned int i) {
+        if (0 == i) {
             return r;
-        } else if ( 1 == i ) {
+        } else if (1 == i) {
             return g;
-        } else if ( 2 == i ) {
+        } else if (2 == i) {
             return b;
         }
         return r;
@@ -229,14 +233,14 @@ struct aiColor3D
     /** Check whether a color is black */
     bool IsBlack() const {
         static const ai_real epsilon = ai_real(10e-3);
-        return std::fabs( r ) < epsilon && std::fabs( g ) < epsilon && std::fabs( b ) < epsilon;
+        return std::fabs(r) < epsilon && std::fabs(g) < epsilon && std::fabs(b) < epsilon;
     }
 
 #endif // !__cplusplus
 
     //! Red, green and blue color values
     ai_real r, g, b;
-};  // !struct aiColor3D
+}; // !struct aiColor3D
 
 // ----------------------------------------------------------------------------------
 /** Represents an UTF-8 string, zero byte terminated.
@@ -259,99 +263,98 @@ struct aiColor3D
  *  (binary) length of such a string is limited to MAXLEN characters (including the
  *  the terminating zero).
 */
-struct aiString
-{
+struct aiString {
 #ifdef __cplusplus
     /** Default constructor, the string is set to have zero length */
     aiString() AI_NO_EXCEPT
-    : length( 0 ) {
+            : length(0) {
         data[0] = '\0';
 
 #ifdef ASSIMP_BUILD_DEBUG
         // Debug build: overwrite the string on its full length with ESC (27)
-        memset(data+1,27,MAXLEN-1);
+        memset(data + 1, 27, MAXLEN - 1);
 #endif
     }
 
     /** Copy constructor */
-    aiString(const aiString& rOther)
-    : length(rOther.length)
-    {
+    aiString(const aiString &rOther) :
+            length(rOther.length) {
         // Crop the string to the maximum length
-        length = length>=MAXLEN?MAXLEN-1:length;
-        memcpy( data, rOther.data, length);
+        length = length >= MAXLEN ? MAXLEN - 1 : length;
+        memcpy(data, rOther.data, length);
         data[length] = '\0';
     }
 
     /** Constructor from std::string */
-    explicit aiString(const std::string& pString) :
-        length( (ai_uint32) pString.length())
-    {
-        length = length>=MAXLEN?MAXLEN-1:length;
-        memcpy( data, pString.c_str(), length);
+    explicit aiString(const std::string &pString) :
+            length((ai_uint32)pString.length()) {
+        length = length >= MAXLEN ? MAXLEN - 1 : length;
+        memcpy(data, pString.c_str(), length);
         data[length] = '\0';
     }
 
     /** Copy a std::string to the aiString */
-    void Set( const std::string& pString) {
-        if( pString.length() > MAXLEN - 1) {
+    void Set(const std::string &pString) {
+        if (pString.length() > MAXLEN - 1) {
             return;
         }
         length = (ai_uint32)pString.length();
-        memcpy( data, pString.c_str(), length);
+        memcpy(data, pString.c_str(), length);
         data[length] = 0;
     }
 
     /** Copy a const char* to the aiString */
-    void Set( const char* sz) {
-        const ai_int32 len = (ai_uint32) ::strlen(sz);
-        if( len > (ai_int32)MAXLEN - 1) {
-            return;
+    void Set(const char *sz) {
+        ai_int32 len = (ai_uint32)::strlen(sz);
+        if (len > (ai_int32)MAXLEN - 1) {
+            len = (ai_int32) MAXLEN - 1;
         }
         length = len;
-        memcpy( data, sz, len);
+        memcpy(data, sz, len);
         data[len] = 0;
     }
 
-
     /** Assignment operator */
-    aiString& operator = (const aiString &rOther) {
+    aiString &operator=(const aiString &rOther) {
         if (this == &rOther) {
             return *this;
         }
 
-        length = rOther.length;;
-        memcpy( data, rOther.data, length);
+        length = rOther.length;
+        if (length >(MAXLEN - 1)) {
+            length = (ai_int32) MAXLEN - 1;
+        }
+
+        memcpy(data, rOther.data, length);
         data[length] = '\0';
         return *this;
     }
 
-
     /** Assign a const char* to the string */
-    aiString& operator = (const char* sz) {
+    aiString &operator=(const char *sz) {
         Set(sz);
         return *this;
     }
 
     /** Assign a cstd::string to the string */
-    aiString& operator = ( const std::string& pString) {
+    aiString &operator=(const std::string &pString) {
         Set(pString);
         return *this;
     }
 
     /** Comparison operator */
-    bool operator==(const aiString& other) const {
-        return  (length == other.length && 0 == memcmp(data,other.data,length));
+    bool operator==(const aiString &other) const {
+        return (length == other.length && 0 == memcmp(data, other.data, length));
     }
 
     /** Inverse comparison operator */
-    bool operator!=(const aiString& other) const {
-        return  (length != other.length || 0 != memcmp(data,other.data,length));
+    bool operator!=(const aiString &other) const {
+        return (length != other.length || 0 != memcmp(data, other.data, length));
     }
 
     /** Append a string to the string */
-    void Append (const char* app)   {
-        const ai_uint32 len = (ai_uint32) ::strlen(app);
+    void Append(const char *app) {
+        const ai_uint32 len = (ai_uint32)::strlen(app);
         if (!len) {
             return;
         }
@@ -359,23 +362,23 @@ struct aiString
             return;
         }
 
-        memcpy(&data[length],app,len+1);
+        memcpy(&data[length], app, len + 1);
         length += len;
     }
 
     /** Clear the string - reset its length to zero */
-    void Clear ()   {
-        length  = 0;
+    void Clear() {
+        length = 0;
         data[0] = '\0';
 
 #ifdef ASSIMP_BUILD_DEBUG
         // Debug build: overwrite the string on its full length with ESC (27)
-        memset(data+1,27,MAXLEN-1);
+        memset(data + 1, 27, MAXLEN - 1);
 #endif
     }
 
     /** Returns a pointer to the underlying zero-terminated array of characters */
-    const char* C_Str() const {
+    const char *C_Str() const {
         return data;
     }
 
@@ -388,15 +391,13 @@ struct aiString
 
     /** String buffer. Size limit is MAXLEN */
     char data[MAXLEN];
-} ;  // !struct aiString
-
+}; // !struct aiString
 
 // ----------------------------------------------------------------------------------
 /** Standard return type for some library functions.
  * Rarely used, and if, mostly in the C API.
  */
-typedef enum aiReturn
-{
+typedef enum aiReturn {
     /** Indicates that a function was successful */
     aiReturn_SUCCESS = 0x0,
 
@@ -414,19 +415,18 @@ typedef enum aiReturn
     _AI_ENFORCE_ENUM_SIZE = 0x7fffffff
 
     /// @endcond
-} aiReturn;  // !enum aiReturn
+} aiReturn; // !enum aiReturn
 
 // just for backwards compatibility, don't use these constants anymore
-#define AI_SUCCESS     aiReturn_SUCCESS
-#define AI_FAILURE     aiReturn_FAILURE
+#define AI_SUCCESS aiReturn_SUCCESS
+#define AI_FAILURE aiReturn_FAILURE
 #define AI_OUTOFMEMORY aiReturn_OUTOFMEMORY
 
 // ----------------------------------------------------------------------------------
 /** Seek origins (for the virtual file system API).
  *  Much cooler than using SEEK_SET, SEEK_CUR or SEEK_END.
  */
-enum aiOrigin
-{
+enum aiOrigin {
     /** Beginning of the file */
     aiOrigin_SET = 0x0,
 
@@ -449,8 +449,7 @@ enum aiOrigin
  *  Logging to these streams can be enabled with a single call to
  *   #LogStream::createDefaultStream.
  */
-enum aiDefaultLogStream
-{
+enum aiDefaultLogStream {
     /** Stream the log to a file */
     aiDefaultLogStream_FILE = 0x1,
 
@@ -473,9 +472,9 @@ enum aiDefaultLogStream
 }; // !enum aiDefaultLogStream
 
 // just for backwards compatibility, don't use these constants anymore
-#define DLS_FILE     aiDefaultLogStream_FILE
-#define DLS_STDOUT   aiDefaultLogStream_STDOUT
-#define DLS_STDERR   aiDefaultLogStream_STDERR
+#define DLS_FILE aiDefaultLogStream_FILE
+#define DLS_STDOUT aiDefaultLogStream_STDOUT
+#define DLS_STDERR aiDefaultLogStream_STDERR
 #define DLS_DEBUGGER aiDefaultLogStream_DEBUGGER
 
 // ----------------------------------------------------------------------------------
@@ -483,21 +482,19 @@ enum aiDefaultLogStream
  *  animations) of an import. All sizes are in bytes.
  *  @see Importer::GetMemoryRequirements()
 */
-struct aiMemoryInfo
-{
+struct aiMemoryInfo {
 #ifdef __cplusplus
 
     /** Default constructor */
     aiMemoryInfo() AI_NO_EXCEPT
-        : textures   (0)
-        , materials  (0)
-        , meshes     (0)
-        , nodes      (0)
-        , animations (0)
-        , cameras    (0)
-        , lights     (0)
-        , total      (0)
-    {}
+            : textures(0),
+              materials(0),
+              meshes(0),
+              nodes(0),
+              animations(0),
+              cameras(0),
+              lights(0),
+              total(0) {}
 
 #endif
 
@@ -534,8 +531,8 @@ struct aiMemoryInfo
 #include "vector2.inl"
 #include "vector3.inl"
 #include "color4.inl"
-#include "quaternion.inl"
 #include "matrix3x3.inl"
 #include "matrix4x4.inl"
+#include "quaternion.inl"
 
 #endif // AI_TYPES_H_INC
diff --git a/Engine/lib/assimp/include/assimp/vector2.h b/Engine/lib/assimp/include/assimp/vector2.h
index d5ef00154..f06e9441d 100644
--- a/Engine/lib/assimp/include/assimp/vector2.h
+++ b/Engine/lib/assimp/include/assimp/vector2.h
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -47,6 +45,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_VECTOR2D_H_INC
 #define AI_VECTOR2D_H_INC
 
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
 #ifdef __cplusplus
 #   include <cmath>
 #else
@@ -83,7 +85,7 @@ public:
     bool operator== (const aiVector2t& other) const;
     bool operator!= (const aiVector2t& other) const;
 
-    bool Equal(const aiVector2t& other, TReal epsilon = 1e-6) const;
+    bool Equal(const aiVector2t &other, TReal epsilon = ai_epsilon) const;
 
     aiVector2t& operator= (TReal f);
     const aiVector2t SymMul(const aiVector2t& o);
diff --git a/Engine/lib/assimp/include/assimp/vector2.inl b/Engine/lib/assimp/include/assimp/vector2.inl
index 3b7a7beab..245eb3190 100644
--- a/Engine/lib/assimp/include/assimp/vector2.inl
+++ b/Engine/lib/assimp/include/assimp/vector2.inl
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
+Copyright (c) 2006-2022, assimp team
 
 
 
@@ -48,8 +48,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_VECTOR2D_INL_INC
 #define AI_VECTOR2D_INL_INC
 
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
 #ifdef __cplusplus
-#include "vector2.h"
+#include <assimp/vector2.h>
 
 #include <cmath>
 
@@ -186,7 +190,7 @@ aiVector2t<TReal> operator + (const aiVector2t<TReal>& v1, const aiVector2t<TRea
 // ------------------------------------------------------------------------------------------------
 // symmetric subtraction
 template <typename TReal>
-inline 
+inline
 aiVector2t<TReal> operator - (const aiVector2t<TReal>& v1, const aiVector2t<TReal>& v2) {
     return aiVector2t<TReal>( v1.x - v2.x, v1.y - v2.y);
 }
@@ -194,7 +198,7 @@ aiVector2t<TReal> operator - (const aiVector2t<TReal>& v1, const aiVector2t<TRea
 // ------------------------------------------------------------------------------------------------
 // scalar product
 template <typename TReal>
-inline 
+inline
 TReal operator * (const aiVector2t<TReal>& v1, const aiVector2t<TReal>& v2) {
     return v1.x*v2.x + v1.y*v2.y;
 }
@@ -202,7 +206,7 @@ TReal operator * (const aiVector2t<TReal>& v1, const aiVector2t<TReal>& v2) {
 // ------------------------------------------------------------------------------------------------
 // scalar multiplication
 template <typename TReal>
-inline 
+inline
 aiVector2t<TReal> operator * ( TReal f, const aiVector2t<TReal>& v) {
     return aiVector2t<TReal>( f*v.x, f*v.y);
 }
@@ -210,7 +214,7 @@ aiVector2t<TReal> operator * ( TReal f, const aiVector2t<TReal>& v) {
 // ------------------------------------------------------------------------------------------------
 // and the other way around
 template <typename TReal>
-inline 
+inline
 aiVector2t<TReal> operator * ( const aiVector2t<TReal>& v, TReal f) {
     return aiVector2t<TReal>( f*v.x, f*v.y);
 }
@@ -218,7 +222,7 @@ aiVector2t<TReal> operator * ( const aiVector2t<TReal>& v, TReal f) {
 // ------------------------------------------------------------------------------------------------
 // scalar division
 template <typename TReal>
-inline 
+inline
 aiVector2t<TReal> operator / ( const aiVector2t<TReal>& v, TReal f) {
     return v * (1/f);
 }
@@ -226,7 +230,7 @@ aiVector2t<TReal> operator / ( const aiVector2t<TReal>& v, TReal f) {
 // ------------------------------------------------------------------------------------------------
 // vector division
 template <typename TReal>
-inline 
+inline
 aiVector2t<TReal> operator / ( const aiVector2t<TReal>& v, const aiVector2t<TReal>& v2) {
     return aiVector2t<TReal>(v.x / v2.x,v.y / v2.y);
 }
@@ -234,7 +238,7 @@ aiVector2t<TReal> operator / ( const aiVector2t<TReal>& v, const aiVector2t<TRea
 // ------------------------------------------------------------------------------------------------
 // vector negation
 template <typename TReal>
-inline 
+inline
 aiVector2t<TReal> operator - ( const aiVector2t<TReal>& v) {
     return aiVector2t<TReal>( -v.x, -v.y);
 }
diff --git a/Engine/lib/assimp/include/assimp/vector3.h b/Engine/lib/assimp/include/assimp/vector3.h
index 7ff25cf0a..a886def1d 100644
--- a/Engine/lib/assimp/include/assimp/vector3.h
+++ b/Engine/lib/assimp/include/assimp/vector3.h
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -47,13 +45,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_VECTOR3D_H_INC
 #define AI_VECTOR3D_H_INC
 
+#ifdef __GNUC__
+#   pragma GCC system_header
+#endif
+
 #ifdef __cplusplus
 #   include <cmath>
 #else
 #   include <math.h>
 #endif
 
-#include "defs.h"
+#include <assimp/defs.h>
 
 #ifdef __cplusplus
 
@@ -61,30 +63,49 @@ template<typename TReal> class aiMatrix3x3t;
 template<typename TReal> class aiMatrix4x4t;
 
 // ---------------------------------------------------------------------------
-/** Represents a three-dimensional vector. */
+/// @brief  Represents a three-dimensional vector.
+// ---------------------------------------------------------------------------
 template <typename TReal>
-class aiVector3t
-{
+class aiVector3t {
 public:
+    /// @brief  The default class constructor.
     aiVector3t() AI_NO_EXCEPT : x(), y(), z() {}
+    
+    /// @brief  The class constructor with the components.
+    /// @param  _x  The x-component for the vector.
+    /// @param  _y  The y-component for the vector.
+    /// @param  _z  The z-component for the vector.
     aiVector3t(TReal _x, TReal _y, TReal _z) : x(_x), y(_y), z(_z) {}
+    
+    /// @brief  The class constructor with a default value.
+    /// @param  _xyz  The value for x, y and z.
     explicit aiVector3t (TReal _xyz ) : x(_xyz), y(_xyz), z(_xyz) {}
+    
+    /// @brief  The copy constructor.
+    /// @param  o The instance to copy from.
     aiVector3t( const aiVector3t& o ) = default;
 
-public:
-
-    // combined operators
+    /// @brief  combined operators
+    /// @brief  The copy constructor.
     const aiVector3t& operator += (const aiVector3t& o);
+
+    /// @brief  The copy constructor.
     const aiVector3t& operator -= (const aiVector3t& o);
+
+    /// @brief  The copy constructor.
     const aiVector3t& operator *= (TReal f);
+
+    /// @brief  The copy constructor.
     const aiVector3t& operator /= (TReal f);
 
-    // transform vector by matrix
+    /// @brief  Transform vector by matrix
     aiVector3t& operator *= (const aiMatrix3x3t<TReal>& mat);
     aiVector3t& operator *= (const aiMatrix4x4t<TReal>& mat);
 
-    // access a single element
+    /// @brief  access a single element, const.
     TReal operator[](unsigned int i) const;
+
+    /// @brief  access a single element, non-const.
     TReal& operator[](unsigned int i);
 
     // comparison
@@ -92,12 +113,12 @@ public:
     bool operator!= (const aiVector3t& other) const;
     bool operator < (const aiVector3t& other) const;
 
-    bool Equal(const aiVector3t& other, TReal epsilon = 1e-6) const;
+    /// @brief  
+    bool Equal(const aiVector3t &other, TReal epsilon = ai_epsilon) const;
 
     template <typename TOther>
     operator aiVector3t<TOther> () const;
 
-public:
     /** @brief Set the components of a vector
      *  @param pX X component
      *  @param pY Y component
diff --git a/Engine/lib/assimp/include/assimp/vector3.inl b/Engine/lib/assimp/include/assimp/vector3.inl
index 2fce6edde..28ca2be07 100644
--- a/Engine/lib/assimp/include/assimp/vector3.inl
+++ b/Engine/lib/assimp/include/assimp/vector3.inl
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -49,15 +47,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define AI_VECTOR3D_INL_INC
 
 #ifdef __cplusplus
-#include "vector3.h"
+#include <assimp/vector3.h>
 
 #include <cmath>
 
 // ------------------------------------------------------------------------------------------------
 /** Transformation of a vector by a 3x3 matrix */
 template <typename TReal>
-AI_FORCE_INLINE
-aiVector3t<TReal> operator * (const aiMatrix3x3t<TReal>& pMatrix, const aiVector3t<TReal>& pVector) {
+AI_FORCE_INLINE aiVector3t<TReal> operator * (const aiMatrix3x3t<TReal>& pMatrix, const aiVector3t<TReal>& pVector) {
     aiVector3t<TReal> res;
     res.x = pMatrix.a1 * pVector.x + pMatrix.a2 * pVector.y + pMatrix.a3 * pVector.z;
     res.y = pMatrix.b1 * pVector.x + pMatrix.b2 * pVector.y + pMatrix.b3 * pVector.z;
@@ -68,8 +65,7 @@ aiVector3t<TReal> operator * (const aiMatrix3x3t<TReal>& pMatrix, const aiVector
 // ------------------------------------------------------------------------------------------------
 /** Transformation of a vector by a 4x4 matrix */
 template <typename TReal>
-AI_FORCE_INLINE
-aiVector3t<TReal> operator * (const aiMatrix4x4t<TReal>& pMatrix, const aiVector3t<TReal>& pVector) {
+AI_FORCE_INLINE aiVector3t<TReal> operator * (const aiMatrix4x4t<TReal>& pMatrix, const aiVector3t<TReal>& pVector) {
     aiVector3t<TReal> res;
     res.x = pMatrix.a1 * pVector.x + pMatrix.a2 * pVector.y + pMatrix.a3 * pVector.z + pMatrix.a4;
     res.y = pMatrix.b1 * pVector.x + pMatrix.b2 * pVector.y + pMatrix.b3 * pVector.z + pMatrix.b4;
@@ -84,36 +80,35 @@ aiVector3t<TReal>::operator aiVector3t<TOther> () const {
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-void aiVector3t<TReal>::Set( TReal pX, TReal pY, TReal pZ) {
+AI_FORCE_INLINE void aiVector3t<TReal>::Set( TReal pX, TReal pY, TReal pZ) {
     x = pX;
     y = pY;
     z = pZ;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-TReal aiVector3t<TReal>::SquareLength() const {
+AI_FORCE_INLINE TReal aiVector3t<TReal>::SquareLength() const {
     return x*x + y*y + z*z;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-TReal aiVector3t<TReal>::Length() const {
+AI_FORCE_INLINE TReal aiVector3t<TReal>::Length() const {
     return std::sqrt( SquareLength());
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiVector3t<TReal>& aiVector3t<TReal>::Normalize() {
+ aiVector3t<TReal>& aiVector3t<TReal>::Normalize() {
+    const TReal l = Length();
+    if (l == 0) {
+        return *this;
+    }
     *this /= Length();
 
     return *this;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiVector3t<TReal>& aiVector3t<TReal>::NormalizeSafe() {
+AI_FORCE_INLINE aiVector3t<TReal>& aiVector3t<TReal>::NormalizeSafe() {
     TReal len = Length();
     if ( len > static_cast< TReal >( 0 ) ) {
         *this /= len;
@@ -122,8 +117,7 @@ aiVector3t<TReal>& aiVector3t<TReal>::NormalizeSafe() {
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-const aiVector3t<TReal>& aiVector3t<TReal>::operator += (const aiVector3t<TReal>& o) {
+AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator += (const aiVector3t<TReal>& o) {
     x += o.x;
     y += o.y;
     z += o.z;
@@ -132,8 +126,7 @@ const aiVector3t<TReal>& aiVector3t<TReal>::operator += (const aiVector3t<TReal>
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-const aiVector3t<TReal>& aiVector3t<TReal>::operator -= (const aiVector3t<TReal>& o) {
+AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator -= (const aiVector3t<TReal>& o) {
     x -= o.x;
     y -= o.y;
     z -= o.z;
@@ -142,8 +135,7 @@ const aiVector3t<TReal>& aiVector3t<TReal>::operator -= (const aiVector3t<TReal>
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-const aiVector3t<TReal>& aiVector3t<TReal>::operator *= (TReal f) {
+AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator *= (TReal f) {
     x *= f;
     y *= f;
     z *= f;
@@ -152,8 +144,10 @@ const aiVector3t<TReal>& aiVector3t<TReal>::operator *= (TReal f) {
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-const aiVector3t<TReal>& aiVector3t<TReal>::operator /= (TReal f) {
+AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator /= (TReal f) {
+    if ( f == static_cast<TReal>(0.0)) {
+        return *this;
+    }
     const TReal invF = (TReal) 1.0 / f;
     x *= invF;
     y *= invF;
@@ -163,20 +157,17 @@ const aiVector3t<TReal>& aiVector3t<TReal>::operator /= (TReal f) {
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiVector3t<TReal>& aiVector3t<TReal>::operator *= (const aiMatrix3x3t<TReal>& mat){
+AI_FORCE_INLINE aiVector3t<TReal>& aiVector3t<TReal>::operator *= (const aiMatrix3x3t<TReal>& mat){
     return (*this =  mat * (*this));
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-aiVector3t<TReal>& aiVector3t<TReal>::operator *= (const aiMatrix4x4t<TReal>& mat){
+AI_FORCE_INLINE aiVector3t<TReal>& aiVector3t<TReal>::operator *= (const aiMatrix4x4t<TReal>& mat){
     return (*this = mat * (*this));
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-TReal aiVector3t<TReal>::operator[](unsigned int i) const {
+AI_FORCE_INLINE TReal aiVector3t<TReal>::operator[](unsigned int i) const {
     switch (i) {
         case 0:
             return x;
@@ -191,9 +182,7 @@ TReal aiVector3t<TReal>::operator[](unsigned int i) const {
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-TReal& aiVector3t<TReal>::operator[](unsigned int i) {
-//    return *(&x + i);
+AI_FORCE_INLINE TReal& aiVector3t<TReal>::operator[](unsigned int i) {
     switch (i) {
         case 0:
             return x;
@@ -208,20 +197,17 @@ TReal& aiVector3t<TReal>::operator[](unsigned int i) {
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-bool aiVector3t<TReal>::operator== (const aiVector3t<TReal>& other) const {
+AI_FORCE_INLINE bool aiVector3t<TReal>::operator== (const aiVector3t<TReal>& other) const {
     return x == other.x && y == other.y && z == other.z;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-bool aiVector3t<TReal>::operator!= (const aiVector3t<TReal>& other) const {
+AI_FORCE_INLINE bool aiVector3t<TReal>::operator!= (const aiVector3t<TReal>& other) const {
     return x != other.x || y != other.y || z != other.z;
 }
 // ---------------------------------------------------------------------------
 template<typename TReal>
-AI_FORCE_INLINE
-bool aiVector3t<TReal>::Equal(const aiVector3t<TReal>& other, TReal epsilon) const {
+AI_FORCE_INLINE bool aiVector3t<TReal>::Equal(const aiVector3t<TReal>& other, TReal epsilon) const {
     return
         std::abs(x - other.x) <= epsilon &&
         std::abs(y - other.y) <= epsilon &&
@@ -229,77 +215,66 @@ bool aiVector3t<TReal>::Equal(const aiVector3t<TReal>& other, TReal epsilon) con
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-bool aiVector3t<TReal>::operator < (const aiVector3t<TReal>& other) const {
+AI_FORCE_INLINE bool aiVector3t<TReal>::operator < (const aiVector3t<TReal>& other) const {
     return x != other.x ? x < other.x : y != other.y ? y < other.y : z < other.z;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE
-const aiVector3t<TReal> aiVector3t<TReal>::SymMul(const aiVector3t<TReal>& o) {
+AI_FORCE_INLINE const aiVector3t<TReal> aiVector3t<TReal>::SymMul(const aiVector3t<TReal>& o) {
     return aiVector3t<TReal>(x*o.x,y*o.y,z*o.z);
 }
 // ------------------------------------------------------------------------------------------------
 // symmetric addition
 template <typename TReal>
-AI_FORCE_INLINE
-aiVector3t<TReal> operator + (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
+AI_FORCE_INLINE aiVector3t<TReal> operator + (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
     return aiVector3t<TReal>( v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
 }
 // ------------------------------------------------------------------------------------------------
 // symmetric subtraction
 template <typename TReal>
-AI_FORCE_INLINE
-aiVector3t<TReal> operator - (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
+AI_FORCE_INLINE aiVector3t<TReal> operator - (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
     return aiVector3t<TReal>( v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
 }
 // ------------------------------------------------------------------------------------------------
 // scalar product
 template <typename TReal>
-AI_FORCE_INLINE
-TReal operator * (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
+AI_FORCE_INLINE TReal operator * (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
     return v1.x*v2.x + v1.y*v2.y + v1.z*v2.z;
 }
 // ------------------------------------------------------------------------------------------------
 // scalar multiplication
 template <typename TReal>
-AI_FORCE_INLINE
-aiVector3t<TReal> operator * ( TReal f, const aiVector3t<TReal>& v) {
+AI_FORCE_INLINE aiVector3t<TReal> operator * ( TReal f, const aiVector3t<TReal>& v) {
     return aiVector3t<TReal>( f*v.x, f*v.y, f*v.z);
 }
 // ------------------------------------------------------------------------------------------------
 // and the other way around
 template <typename TReal>
-AI_FORCE_INLINE
-aiVector3t<TReal> operator * ( const aiVector3t<TReal>& v, TReal f) {
+AI_FORCE_INLINE aiVector3t<TReal> operator * ( const aiVector3t<TReal>& v, TReal f) {
     return aiVector3t<TReal>( f*v.x, f*v.y, f*v.z);
 }
 // ------------------------------------------------------------------------------------------------
 // scalar division
 template <typename TReal>
-AI_FORCE_INLINE
-aiVector3t<TReal> operator / ( const aiVector3t<TReal>& v, TReal f) {
+AI_FORCE_INLINE aiVector3t<TReal> operator / ( const aiVector3t<TReal>& v, TReal f) {
     return v * (1/f);
 }
 // ------------------------------------------------------------------------------------------------
 // vector division
 template <typename TReal>
-AI_FORCE_INLINE
-aiVector3t<TReal> operator / ( const aiVector3t<TReal>& v, const aiVector3t<TReal>& v2) {
+AI_FORCE_INLINE aiVector3t<TReal> operator / ( const aiVector3t<TReal>& v, const aiVector3t<TReal>& v2) {
     return aiVector3t<TReal>(v.x / v2.x,v.y / v2.y,v.z / v2.z);
 }
 // ------------------------------------------------------------------------------------------------
 // cross product
 template<typename TReal>
-AI_FORCE_INLINE
-aiVector3t<TReal> operator ^ ( const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
+AI_FORCE_INLINE aiVector3t<TReal> operator ^ ( const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
     return aiVector3t<TReal>( v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x);
 }
 // ------------------------------------------------------------------------------------------------
 // vector negation
 template<typename TReal>
-AI_FORCE_INLINE
-aiVector3t<TReal> operator - ( const aiVector3t<TReal>& v) {
+AI_FORCE_INLINE aiVector3t<TReal> operator - ( const aiVector3t<TReal>& v) {
     return aiVector3t<TReal>( -v.x, -v.y, -v.z);
 }
 
diff --git a/Engine/lib/assimp/include/assimp/version.h b/Engine/lib/assimp/include/assimp/version.h
index c62a40e11..b83110a04 100644
--- a/Engine/lib/assimp/include/assimp/version.h
+++ b/Engine/lib/assimp/include/assimp/version.h
@@ -3,9 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2019, assimp team
-
-
+Copyright (c) 2006-2022, assimp team
 
 All rights reserved.
 
@@ -49,7 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_VERSION_H_INC
 #define AI_VERSION_H_INC
 
-#include "defs.h"
+#include <assimp/defs.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -62,6 +60,13 @@ extern "C" {
  */
 ASSIMP_API const char*  aiGetLegalString  (void);
 
+// ---------------------------------------------------------------------------
+/** @brief Returns the current patch version number of Assimp.
+ *  @return Patch version of the Assimp runtime the application was
+ *    linked/built against
+ */
+ASSIMP_API unsigned int aiGetVersionPatch(void);
+
 // ---------------------------------------------------------------------------
 /** @brief Returns the current minor version number of Assimp.
  *  @return Minor version of the Assimp runtime the application was
@@ -84,7 +89,7 @@ ASSIMP_API unsigned int aiGetVersionMajor (void);
 ASSIMP_API unsigned int aiGetVersionRevision (void);
 
 // ---------------------------------------------------------------------------
-/** @brief Returns the branchname of the Assimp runtime.
+/** @brief Returns the branch-name of the Assimp runtime.
  *  @return The current branch name.
  */
 ASSIMP_API const char *aiGetBranchName();
@@ -100,12 +105,14 @@ ASSIMP_API const char *aiGetBranchName();
 #define ASSIMP_CFLAGS_NOBOOST           0x8
 //! Assimp was compiled with ASSIMP_BUILD_SINGLETHREADED defined
 #define ASSIMP_CFLAGS_SINGLETHREADED    0x10
+//! Assimp was compiled with ASSIMP_BUILD_SINGLETHREADED defined
+#define ASSIMP_CFLAGS_DOUBLE_SUPPORT 0x20
 
 // ---------------------------------------------------------------------------
 /** @brief Returns assimp's compile flags
  *  @return Any bitwise combination of the ASSIMP_CFLAGS_xxx constants.
  */
-ASSIMP_API unsigned int aiGetCompileFlags (void);
+ASSIMP_API unsigned int aiGetCompileFlags(void);
 
 #ifdef __cplusplus
 } // end extern "C"

From 82e608f990262f392ff571f6c033e9983c5f27aa Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Tue, 26 Apr 2022 16:03:00 -0500
Subject: [PATCH 380/399] add workaround logic for configuration file
 generation

---
 Engine/lib/assimp/revision.h.in    | 28 ++++++++++++++++++++++++++++
 Tools/CMake/libraries/assimp.cmake | 19 +++++++++++++++++++
 2 files changed, 47 insertions(+)
 create mode 100644 Engine/lib/assimp/revision.h.in

diff --git a/Engine/lib/assimp/revision.h.in b/Engine/lib/assimp/revision.h.in
new file mode 100644
index 000000000..6d09afbc6
--- /dev/null
+++ b/Engine/lib/assimp/revision.h.in
@@ -0,0 +1,28 @@
+#ifndef ASSIMP_REVISION_H_INC
+#define ASSIMP_REVISION_H_INC
+
+#define GitVersion 0x@GIT_COMMIT_HASH@
+#define GitBranch "@GIT_BRANCH@"
+
+#define VER_MAJOR @ASSIMP_VERSION_MAJOR@
+#define VER_MINOR @ASSIMP_VERSION_MINOR@
+#define VER_PATCH @ASSIMP_VERSION_PATCH@
+#define VER_BUILD @ASSIMP_PACKAGE_VERSION@
+
+#define STR_HELP(x) #x
+#define STR(x) STR_HELP(x)
+
+#define VER_FILEVERSION             VER_MAJOR,VER_MINOR,VER_PATCH,VER_BUILD
+#if (GitVersion == 0)
+#define VER_FILEVERSION_STR         STR(VER_MAJOR) "." STR(VER_MINOR) "." STR(VER_PATCH) "." STR(VER_BUILD)
+#else
+#define VER_FILEVERSION_STR         STR(VER_MAJOR) "." STR(VER_MINOR) "." STR(VER_PATCH) "." STR(VER_BUILD) " (Commit @GIT_COMMIT_HASH@)"
+#endif
+
+#ifdef  NDEBUG
+#define VER_ORIGINAL_FILENAME_STR   "assimp@LIBRARY_SUFFIX@.dll"
+#else
+#define VER_ORIGINAL_FILENAME_STR   "assimp@LIBRARY_SUFFIX@@CMAKE_DEBUG_POSTFIX@.dll"
+#endif //  NDEBUG
+
+#endif // ASSIMP_REVISION_H_INC
diff --git a/Tools/CMake/libraries/assimp.cmake b/Tools/CMake/libraries/assimp.cmake
index 159f5d502..addcf067c 100644
--- a/Tools/CMake/libraries/assimp.cmake
+++ b/Tools/CMake/libraries/assimp.cmake
@@ -122,6 +122,23 @@ addDef(ASSIMP_BUILD_NO_GLTF_EXPORTER)
 #addDef(ASSIMP_BUILD_NO_X_EXPORTER)
 #addDef(ASSIMP_BUILD_NO_X3D_EXPORTER)
 
+addDef(ASSIMP_IGNORE_GIT_HASH)
+SET(GIT_COMMIT_HASH 0)
+SET(GIT_BRANCH 0)
+SET(ASSIMP_VERSION_MAJOR 5)
+SET(ASSIMP_VERSION_MINOR 2)
+SET(ASSIMP_VERSION_PATCH 3)
+SET(ASSIMP_PACKAGE_VERSION "5_2_3")
+CONFIGURE_FILE(
+  ${libDir}/assimp/revision.h.in
+  ${libDir}/assimp/revision.h
+)
+
+CONFIGURE_FILE(
+  ${libDir}/assimp/include/assimp/config.h.in
+  ${libDir}/assimp/include/assimp/config.h
+)
+
 addInclude(${libDir}/assimp)
 addInclude(${libDir}/assimp/include/)
 addInclude(${libDir}/assimp/include/assimp)
@@ -131,6 +148,8 @@ addInclude(${libDir}/assimp/contrib/irrXML)
 addInclude(${libDir}/assimp/contrib/Open3DGC)
 addInclude(${libDir}/assimp/contrib/openddlparser)
 addInclude(${libDir}/assimp/contrib/poly2tri)
+addInclude(${libDir}/assimp/contrib/pugixml/src)
+addInclude(${libDir}/assimp/contrib/pugixml/contrib)
 addInclude(${libDir}/assimp/contrib/rapidjson)
 addInclude(${libDir}/assimp/contrib/rapidjson/include)
 addInclude(${libDir}/assimp/contrib/unzip)

From 77166633468348793ce7ea706d65db2be158b442 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Tue, 26 Apr 2022 17:11:02 -0500
Subject: [PATCH 381/399] need to unhide OBJ for this one

---
 .gitignore                                    |   2 +-
 .../assimp/code/AssetLib/Obj/ObjExporter.cpp  | 414 +++++++++
 .../assimp/code/AssetLib/Obj/ObjExporter.h    | 190 ++++
 .../assimp/code/AssetLib/Obj/ObjFileData.h    | 344 +++++++
 .../code/AssetLib/Obj/ObjFileImporter.cpp     | 783 ++++++++++++++++
 .../code/AssetLib/Obj/ObjFileImporter.h       | 122 +++
 .../code/AssetLib/Obj/ObjFileMtlImporter.cpp  | 498 ++++++++++
 .../code/AssetLib/Obj/ObjFileMtlImporter.h    | 113 +++
 .../code/AssetLib/Obj/ObjFileParser.cpp       | 859 ++++++++++++++++++
 .../assimp/code/AssetLib/Obj/ObjFileParser.h  | 165 ++++
 .../lib/assimp/code/AssetLib/Obj/ObjTools.h   | 284 ++++++
 11 files changed, 3773 insertions(+), 1 deletion(-)
 create mode 100644 Engine/lib/assimp/code/AssetLib/Obj/ObjExporter.cpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/Obj/ObjExporter.h
 create mode 100644 Engine/lib/assimp/code/AssetLib/Obj/ObjFileData.h
 create mode 100644 Engine/lib/assimp/code/AssetLib/Obj/ObjFileImporter.cpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/Obj/ObjFileImporter.h
 create mode 100644 Engine/lib/assimp/code/AssetLib/Obj/ObjFileMtlImporter.cpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/Obj/ObjFileMtlImporter.h
 create mode 100644 Engine/lib/assimp/code/AssetLib/Obj/ObjFileParser.cpp
 create mode 100644 Engine/lib/assimp/code/AssetLib/Obj/ObjFileParser.h
 create mode 100644 Engine/lib/assimp/code/AssetLib/Obj/ObjTools.h

diff --git a/.gitignore b/.gitignore
index 0ddf3aba2..c69f58c44 100644
--- a/.gitignore
+++ b/.gitignore
@@ -108,7 +108,7 @@ publish
 
 # Others
 [Bb]in
-[Oo]bj
+# [Oo]bj
 sql
 TestResults
 *.Cache
diff --git a/Engine/lib/assimp/code/AssetLib/Obj/ObjExporter.cpp b/Engine/lib/assimp/code/AssetLib/Obj/ObjExporter.cpp
new file mode 100644
index 000000000..882f3a917
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Obj/ObjExporter.cpp
@@ -0,0 +1,414 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2020, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#ifndef ASSIMP_BUILD_NO_EXPORT
+#ifndef ASSIMP_BUILD_NO_OBJ_EXPORTER
+
+#include "ObjExporter.h"
+#include <assimp/Exceptional.h>
+#include <assimp/StringComparison.h>
+#include <assimp/version.h>
+#include <assimp/IOSystem.hpp>
+#include <assimp/Exporter.hpp>
+#include <assimp/material.h>
+#include <assimp/scene.h>
+#include <memory>
+
+using namespace Assimp;
+
+namespace Assimp {
+
+// ------------------------------------------------------------------------------------------------
+// Worker function for exporting a scene to Wavefront OBJ. Prototyped and registered in Exporter.cpp
+void ExportSceneObj(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/) {
+    // invoke the exporter
+    ObjExporter exporter(pFile, pScene);
+
+    if (exporter.mOutput.fail() || exporter.mOutputMat.fail()) {
+        throw DeadlyExportError("output data creation failed. Most likely the file became too large: " + std::string(pFile));
+    }
+
+    // we're still here - export successfully completed. Write both the main OBJ file and the material script
+    {
+        std::unique_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wt"));
+        if (outfile == nullptr) {
+            throw DeadlyExportError("could not open output .obj file: " + std::string(pFile));
+        }
+        outfile->Write( exporter.mOutput.str().c_str(), static_cast<size_t>(exporter.mOutput.tellp()),1);
+    }
+    {
+        std::unique_ptr<IOStream> outfile (pIOSystem->Open(exporter.GetMaterialLibFileName(),"wt"));
+        if (outfile == nullptr) {
+            throw DeadlyExportError("could not open output .mtl file: " + std::string(exporter.GetMaterialLibFileName()));
+        }
+        outfile->Write( exporter.mOutputMat.str().c_str(), static_cast<size_t>(exporter.mOutputMat.tellp()),1);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Worker function for exporting a scene to Wavefront OBJ without the material file. Prototyped and registered in Exporter.cpp
+void ExportSceneObjNoMtl(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* ) {
+    // invoke the exporter
+    ObjExporter exporter(pFile, pScene, true);
+
+    if (exporter.mOutput.fail() || exporter.mOutputMat.fail()) {
+        throw DeadlyExportError("output data creation failed. Most likely the file became too large: " + std::string(pFile));
+    }
+
+    // we're still here - export successfully completed. Write both the main OBJ file and the material script
+    {
+        std::unique_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wt"));
+        if (outfile == nullptr) {
+            throw DeadlyExportError("could not open output .obj file: " + std::string(pFile));
+        }
+        outfile->Write( exporter.mOutput.str().c_str(), static_cast<size_t>(exporter.mOutput.tellp()),1);
+    }
+
+
+}
+
+} // end of namespace Assimp
+
+static const std::string MaterialExt = ".mtl";
+
+// ------------------------------------------------------------------------------------------------
+ObjExporter::ObjExporter(const char* _filename, const aiScene* pScene, bool noMtl)
+: filename(_filename)
+, pScene(pScene)
+, vn()
+, vt()
+, vp()
+, useVc(false)
+, mVnMap()
+, mVtMap()
+, mVpMap()
+, mMeshes()
+, endl("\n") {
+    // make sure that all formatting happens using the standard, C locale and not the user's current locale
+    const std::locale& l = std::locale("C");
+    mOutput.imbue(l);
+    mOutput.precision(ASSIMP_AI_REAL_TEXT_PRECISION);
+    mOutputMat.imbue(l);
+    mOutputMat.precision(ASSIMP_AI_REAL_TEXT_PRECISION);
+
+    WriteGeometryFile(noMtl);
+    if ( !noMtl ) {
+        WriteMaterialFile();
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+ObjExporter::~ObjExporter() {
+    // empty
+}
+
+// ------------------------------------------------------------------------------------------------
+std::string ObjExporter::GetMaterialLibName() {
+    // within the Obj file, we use just the relative file name with the path stripped
+    const std::string& s = GetMaterialLibFileName();
+    std::string::size_type il = s.find_last_of("/\\");
+    if (il != std::string::npos) {
+        return s.substr(il + 1);
+    }
+
+    return s;
+}
+
+// ------------------------------------------------------------------------------------------------
+std::string ObjExporter::GetMaterialLibFileName() {
+    // Remove existing .obj file extension so that the final material file name will be fileName.mtl and not fileName.obj.mtl
+    size_t lastdot = filename.find_last_of('.');
+    if ( lastdot != std::string::npos ) {
+        return filename.substr( 0, lastdot ) + MaterialExt;
+    }
+
+    return filename + MaterialExt;
+}
+
+// ------------------------------------------------------------------------------------------------
+void ObjExporter::WriteHeader(std::ostringstream& out) {
+    out << "# File produced by Open Asset Import Library (http://www.assimp.sf.net)" << endl;
+    out << "# (assimp v" << aiGetVersionMajor() << '.' << aiGetVersionMinor() << '.'
+        << aiGetVersionRevision() << ")" << endl  << endl;
+}
+
+// ------------------------------------------------------------------------------------------------
+std::string ObjExporter::GetMaterialName(unsigned int index) {
+    const aiMaterial* const mat = pScene->mMaterials[index];
+    if ( nullptr == mat ) {
+        static const std::string EmptyStr;
+        return EmptyStr;
+    }
+
+    aiString s;
+    if(AI_SUCCESS == mat->Get(AI_MATKEY_NAME,s)) {
+        return std::string(s.data,s.length);
+    }
+
+    char number[ sizeof(unsigned int) * 3 + 1 ];
+    ASSIMP_itoa10(number,index);
+    return "$Material_" + std::string(number);
+}
+
+// ------------------------------------------------------------------------------------------------
+void ObjExporter::WriteMaterialFile() {
+    WriteHeader(mOutputMat);
+
+    for(unsigned int i = 0; i < pScene->mNumMaterials; ++i) {
+        const aiMaterial* const mat = pScene->mMaterials[i];
+
+        int illum = 1;
+        mOutputMat << "newmtl " << GetMaterialName(i)  << endl;
+
+        aiColor4D c;
+        if(AI_SUCCESS == mat->Get(AI_MATKEY_COLOR_DIFFUSE,c)) {
+            mOutputMat << "Kd " << c.r << " " << c.g << " " << c.b << endl;
+        }
+        if(AI_SUCCESS == mat->Get(AI_MATKEY_COLOR_AMBIENT,c)) {
+            mOutputMat << "Ka " << c.r << " " << c.g << " " << c.b << endl;
+        }
+        if(AI_SUCCESS == mat->Get(AI_MATKEY_COLOR_SPECULAR,c)) {
+            mOutputMat << "Ks " << c.r << " " << c.g << " " << c.b << endl;
+        }
+        if(AI_SUCCESS == mat->Get(AI_MATKEY_COLOR_EMISSIVE,c)) {
+            mOutputMat << "Ke " << c.r << " " << c.g << " " << c.b << endl;
+        }
+        if(AI_SUCCESS == mat->Get(AI_MATKEY_COLOR_TRANSPARENT,c)) {
+            mOutputMat << "Tf " << c.r << " " << c.g << " " << c.b << endl;
+        }
+
+        ai_real o;
+        if(AI_SUCCESS == mat->Get(AI_MATKEY_OPACITY,o)) {
+            mOutputMat << "d " << o << endl;
+        }
+        if(AI_SUCCESS == mat->Get(AI_MATKEY_REFRACTI,o)) {
+            mOutputMat << "Ni " << o << endl;
+        }
+
+        if(AI_SUCCESS == mat->Get(AI_MATKEY_SHININESS,o) && o) {
+            mOutputMat << "Ns " << o << endl;
+            illum = 2;
+        }
+
+        mOutputMat << "illum " << illum << endl;
+
+        aiString s;
+        if(AI_SUCCESS == mat->Get(AI_MATKEY_TEXTURE_DIFFUSE(0),s)) {
+            mOutputMat << "map_Kd " << s.data << endl;
+        }
+        if(AI_SUCCESS == mat->Get(AI_MATKEY_TEXTURE_AMBIENT(0),s)) {
+            mOutputMat << "map_Ka " << s.data << endl;
+        }
+        if(AI_SUCCESS == mat->Get(AI_MATKEY_TEXTURE_SPECULAR(0),s)) {
+            mOutputMat << "map_Ks " << s.data << endl;
+        }
+        if(AI_SUCCESS == mat->Get(AI_MATKEY_TEXTURE_SHININESS(0),s)) {
+            mOutputMat << "map_Ns " << s.data << endl;
+        }
+        if(AI_SUCCESS == mat->Get(AI_MATKEY_TEXTURE_OPACITY(0),s)) {
+            mOutputMat << "map_d " << s.data << endl;
+        }
+        if(AI_SUCCESS == mat->Get(AI_MATKEY_TEXTURE_HEIGHT(0),s) || AI_SUCCESS == mat->Get(AI_MATKEY_TEXTURE_NORMALS(0),s)) {
+            // implementations seem to vary here, so write both variants
+            mOutputMat << "bump " << s.data << endl;
+            mOutputMat << "map_bump " << s.data << endl;
+        }
+
+        mOutputMat << endl;
+    }
+}
+
+void ObjExporter::WriteGeometryFile(bool noMtl) {
+    WriteHeader(mOutput);
+    if (!noMtl)
+        mOutput << "mtllib "  << GetMaterialLibName() << endl << endl;
+
+    // collect mesh geometry
+    aiMatrix4x4 mBase;
+    AddNode(pScene->mRootNode, mBase);
+
+    // write vertex positions with colors, if any
+    mVpMap.getKeys( vp );
+    if ( !useVc ) {
+        mOutput << "# " << vp.size() << " vertex positions" << endl;
+        for ( const vertexData& v : vp ) {
+            mOutput << "v  " << v.vp.x << " " << v.vp.y << " " << v.vp.z << endl;
+        }
+    } else {
+        mOutput << "# " << vp.size() << " vertex positions and colors" << endl;
+        for ( const vertexData& v : vp ) {
+            mOutput << "v  " << v.vp.x << " " << v.vp.y << " " << v.vp.z << " " << v.vc.r << " " << v.vc.g << " " << v.vc.b << endl;
+        }
+    }
+    mOutput << endl;
+
+    // write uv coordinates
+    mVtMap.getKeys(vt);
+    mOutput << "# " << vt.size() << " UV coordinates" << endl;
+    for(const aiVector3D& v : vt) {
+        mOutput << "vt " << v.x << " " << v.y << " " << v.z << endl;
+    }
+    mOutput << endl;
+
+    // write vertex normals
+    mVnMap.getKeys(vn);
+    mOutput << "# " << vn.size() << " vertex normals" << endl;
+    for(const aiVector3D& v : vn) {
+        mOutput << "vn " << v.x << " " << v.y << " " << v.z << endl;
+    }
+    mOutput << endl;
+
+    // now write all mesh instances
+    for(const MeshInstance& m : mMeshes) {
+        mOutput << "# Mesh \'" << m.name << "\' with " << m.faces.size() << " faces" << endl;
+        if (!m.name.empty()) {
+            mOutput << "g " << m.name << endl;
+        }
+        if ( !noMtl ) {
+            mOutput << "usemtl " << m.matname << endl;
+        }
+
+        for(const Face& f : m.faces) {
+            mOutput << f.kind << ' ';
+            for(const FaceVertex& fv : f.indices) {
+                mOutput << ' ' << fv.vp;
+
+                if (f.kind != 'p') {
+                    if (fv.vt || f.kind == 'f') {
+                        mOutput << '/';
+                    }
+                    if (fv.vt) {
+                        mOutput << fv.vt;
+                    }
+                    if (f.kind == 'f' && fv.vn) {
+                        mOutput << '/' << fv.vn;
+                    }
+                }
+            }
+
+            mOutput << endl;
+        }
+        mOutput << endl;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void ObjExporter::AddMesh(const aiString& name, const aiMesh* m, const aiMatrix4x4& mat) {
+    mMeshes.push_back(MeshInstance() );
+    MeshInstance& mesh = mMeshes.back();
+
+    if ( nullptr != m->mColors[ 0 ] ) {
+        useVc = true;
+    }
+
+    mesh.name = std::string( name.data, name.length );
+    mesh.matname = GetMaterialName(m->mMaterialIndex);
+
+    mesh.faces.resize(m->mNumFaces);
+
+    for(unsigned int i = 0; i < m->mNumFaces; ++i) {
+        const aiFace& f = m->mFaces[i];
+
+        Face& face = mesh.faces[i];
+        switch (f.mNumIndices) {
+            case 1:
+                face.kind = 'p';
+                break;
+            case 2:
+                face.kind = 'l';
+                break;
+            default:
+                face.kind = 'f';
+        }
+        face.indices.resize(f.mNumIndices);
+
+        for(unsigned int a = 0; a < f.mNumIndices; ++a) {
+            const unsigned int idx = f.mIndices[a];
+
+            aiVector3D vert = mat * m->mVertices[idx];
+
+            if ( nullptr != m->mColors[ 0 ] ) {
+                aiColor4D col4 = m->mColors[ 0 ][ idx ];
+                face.indices[a].vp = mVpMap.getIndex({vert, aiColor3D(col4.r, col4.g, col4.b)});
+            } else {
+                face.indices[a].vp = mVpMap.getIndex({vert, aiColor3D(0,0,0)});
+            }
+
+            if (m->mNormals) {
+                aiVector3D norm = aiMatrix3x3(mat) * m->mNormals[idx];
+                face.indices[a].vn = mVnMap.getIndex(norm);
+            } else {
+                face.indices[a].vn = 0;
+            }
+
+            if ( m->mTextureCoords[ 0 ] ) {
+                face.indices[a].vt = mVtMap.getIndex(m->mTextureCoords[0][idx]);
+            } else {
+                face.indices[a].vt = 0;
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void ObjExporter::AddNode(const aiNode* nd, const aiMatrix4x4& mParent) {
+    const aiMatrix4x4& mAbs = mParent * nd->mTransformation;
+
+    aiMesh *cm( nullptr );
+    for(unsigned int i = 0; i < nd->mNumMeshes; ++i) {
+        cm = pScene->mMeshes[nd->mMeshes[i]];
+        if (nullptr != cm) {
+            AddMesh(cm->mName, pScene->mMeshes[nd->mMeshes[i]], mAbs);
+        } else {
+            AddMesh(nd->mName, pScene->mMeshes[nd->mMeshes[i]], mAbs);
+        }
+    }
+
+    for(unsigned int i = 0; i < nd->mNumChildren; ++i) {
+        AddNode(nd->mChildren[i], mAbs);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+
+#endif // ASSIMP_BUILD_NO_OBJ_EXPORTER
+#endif // ASSIMP_BUILD_NO_EXPORT
diff --git a/Engine/lib/assimp/code/AssetLib/Obj/ObjExporter.h b/Engine/lib/assimp/code/AssetLib/Obj/ObjExporter.h
new file mode 100644
index 000000000..a64f38f74
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Obj/ObjExporter.h
@@ -0,0 +1,190 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2020, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file ObjExporter.h
+ * Declares the exporter class to write a scene to a Collada file
+ */
+#ifndef AI_OBJEXPORTER_H_INC
+#define AI_OBJEXPORTER_H_INC
+
+#include <assimp/types.h>
+#include <sstream>
+#include <vector>
+#include <map>
+
+struct aiScene;
+struct aiNode;
+struct aiMesh;
+
+namespace Assimp {
+
+// ------------------------------------------------------------------------------------------------
+/** Helper class to export a given scene to an OBJ file. */
+// ------------------------------------------------------------------------------------------------
+class ObjExporter {
+public:
+    /// Constructor for a specific scene to export
+    ObjExporter(const char* filename, const aiScene* pScene, bool noMtl=false);
+    ~ObjExporter();
+    std::string GetMaterialLibName();
+    std::string GetMaterialLibFileName();
+
+    /// public string-streams to write all output into
+    std::ostringstream mOutput, mOutputMat;
+
+private:
+    // intermediate data structures
+    struct FaceVertex {
+        FaceVertex()
+        : vp()
+        , vn()
+        , vt() {
+            // empty
+        }
+
+        // one-based, 0 means: 'does not exist'
+        unsigned int vp, vn, vt;
+    };
+
+    struct Face {
+        char kind;
+        std::vector<FaceVertex> indices;
+    };
+
+    struct MeshInstance {
+        std::string name, matname;
+        std::vector<Face> faces;
+    };
+
+    void WriteHeader(std::ostringstream& out);
+    void WriteMaterialFile();
+    void WriteGeometryFile(bool noMtl=false);
+    std::string GetMaterialName(unsigned int index);
+    void AddMesh(const aiString& name, const aiMesh* m, const aiMatrix4x4& mat);
+    void AddNode(const aiNode* nd, const aiMatrix4x4& mParent);
+
+private:
+    std::string filename;
+    const aiScene* const pScene;
+
+    struct vertexData {
+        aiVector3D vp;
+        aiColor3D vc; // OBJ does not support 4D color
+    };
+
+    std::vector<aiVector3D> vn, vt;
+    std::vector<aiColor4D> vc;
+    std::vector<vertexData> vp;
+    bool useVc;
+
+    struct vertexDataCompare {
+        bool operator() ( const vertexData& a, const vertexData& b ) const {
+            // position
+            if (a.vp.x < b.vp.x) return true;
+            if (a.vp.x > b.vp.x) return false;
+            if (a.vp.y < b.vp.y) return true;
+            if (a.vp.y > b.vp.y) return false;
+            if (a.vp.z < b.vp.z) return true;
+            if (a.vp.z > b.vp.z) return false;
+
+            // color
+            if (a.vc.r < b.vc.r) return true;
+            if (a.vc.r > b.vc.r) return false;
+            if (a.vc.g < b.vc.g) return true;
+            if (a.vc.g > b.vc.g) return false;
+            if (a.vc.b < b.vc.b) return true;
+            if (a.vc.b > b.vc.b) return false;
+            return false;
+        }
+    };
+
+    struct aiVectorCompare {
+        bool operator() (const aiVector3D& a, const aiVector3D& b) const {
+            if(a.x < b.x) return true;
+            if(a.x > b.x) return false;
+            if(a.y < b.y) return true;
+            if(a.y > b.y) return false;
+            if(a.z < b.z) return true;
+            return false;
+        }
+    };
+
+    template <class T, class Compare = std::less<T>>
+    class indexMap {
+        int mNextIndex;
+        typedef std::map<T, int, Compare> dataType;
+        dataType vecMap;
+
+    public:
+        indexMap()
+        : mNextIndex(1) {
+            // empty
+        }
+
+        int getIndex(const T& key) {
+            typename dataType::iterator vertIt = vecMap.find(key);
+            // vertex already exists, so reference it
+            if(vertIt != vecMap.end()){
+                return vertIt->second;
+            }
+            return vecMap[key] = mNextIndex++;
+        };
+
+        void getKeys( std::vector<T>& keys ) {
+            keys.resize(vecMap.size());
+            for(typename dataType::iterator it = vecMap.begin(); it != vecMap.end(); ++it){
+                keys[it->second-1] = it->first;
+            }
+        };
+    };
+
+    indexMap<aiVector3D, aiVectorCompare> mVnMap, mVtMap;
+    indexMap<vertexData, vertexDataCompare> mVpMap;
+    std::vector<MeshInstance> mMeshes;
+
+    // this endl() doesn't flush() the stream
+    const std::string endl;
+};
+
+}
+
+#endif
diff --git a/Engine/lib/assimp/code/AssetLib/Obj/ObjFileData.h b/Engine/lib/assimp/code/AssetLib/Obj/ObjFileData.h
new file mode 100644
index 000000000..3d504d0bb
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Obj/ObjFileData.h
@@ -0,0 +1,344 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2020, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#pragma once
+#ifndef OBJ_FILEDATA_H_INC
+#define OBJ_FILEDATA_H_INC
+
+#include <assimp/mesh.h>
+#include <assimp/types.h>
+#include <map>
+#include <vector>
+
+namespace Assimp {
+namespace ObjFile {
+
+struct Object;
+struct Face;
+struct Material;
+
+// ------------------------------------------------------------------------------------------------
+//! \struct Face
+//! \brief  Data structure for a simple obj-face, describes discredit,l.ation and materials
+// ------------------------------------------------------------------------------------------------
+struct Face {
+    using IndexArray = std::vector<unsigned int>;
+
+    //! Primitive type
+    aiPrimitiveType m_PrimitiveType;
+    //! Vertex indices
+    IndexArray m_vertices;
+    //! Normal indices
+    IndexArray m_normals;
+    //! Texture coordinates indices
+    IndexArray m_texturCoords;
+    //! Pointer to assigned material
+    Material *m_pMaterial;
+
+    //! \brief  Default constructor
+    Face(aiPrimitiveType pt = aiPrimitiveType_POLYGON) :
+            m_PrimitiveType(pt), m_vertices(), m_normals(), m_texturCoords(), m_pMaterial(0L) {
+        // empty
+    }
+
+    //! \brief  Destructor
+    ~Face() {
+        // empty
+    }
+};
+
+// ------------------------------------------------------------------------------------------------
+//! \struct Object
+//! \brief  Stores all objects of an obj-file object definition
+// ------------------------------------------------------------------------------------------------
+struct Object {
+    enum ObjectType {
+        ObjType,
+        GroupType
+    };
+
+    //! Object name
+    std::string m_strObjName;
+    //! Transformation matrix, stored in OpenGL format
+    aiMatrix4x4 m_Transformation;
+    //! All sub-objects referenced by this object
+    std::vector<Object *> m_SubObjects;
+    /// Assigned meshes
+    std::vector<unsigned int> m_Meshes;
+
+    //! \brief  Default constructor
+    Object() = default;
+
+    //! \brief  Destructor
+    ~Object() {
+        for (std::vector<Object *>::iterator it = m_SubObjects.begin(); it != m_SubObjects.end(); ++it) {
+            delete *it;
+        }
+    }
+};
+
+// ------------------------------------------------------------------------------------------------
+//! \struct Material
+//! \brief  Data structure to store all material specific data
+// ------------------------------------------------------------------------------------------------
+struct Material {
+    //! Name of material description
+    aiString MaterialName;
+    //! Texture names
+    aiString texture;
+    aiString textureSpecular;
+    aiString textureAmbient;
+    aiString textureEmissive;
+    aiString textureBump;
+    aiString textureNormal;
+    aiString textureReflection[6];
+    aiString textureSpecularity;
+    aiString textureOpacity;
+    aiString textureDisp;
+    aiString textureRoughness;
+    aiString textureMetallic;
+    aiString textureSheen;
+    aiString textureRMA;
+
+    enum TextureType {
+        TextureDiffuseType = 0,
+        TextureSpecularType,
+        TextureAmbientType,
+        TextureEmissiveType,
+        TextureBumpType,
+        TextureNormalType,
+        TextureReflectionSphereType,
+        TextureReflectionCubeTopType,
+        TextureReflectionCubeBottomType,
+        TextureReflectionCubeFrontType,
+        TextureReflectionCubeBackType,
+        TextureReflectionCubeLeftType,
+        TextureReflectionCubeRightType,
+        TextureSpecularityType,
+        TextureOpacityType,
+        TextureDispType,
+        TextureRoughnessType,
+        TextureMetallicType,
+        TextureSheenType,
+        TextureRMAType,
+        TextureTypeCount
+    };
+    bool clamp[TextureTypeCount];
+
+    //! Ambient color
+    aiColor3D ambient;
+    //! Diffuse color
+    aiColor3D diffuse;
+    //! Specular color
+    aiColor3D specular;
+    //! Emissive color
+    aiColor3D emissive;
+    //! Alpha value
+    ai_real alpha;
+    //! Shineness factor
+    ai_real shineness;
+    //! Illumination model
+    int illumination_model;
+    //! Index of refraction
+    ai_real ior;
+    //! Transparency color
+    aiColor3D transparent;
+
+    //! PBR Roughness
+    ai_real roughness;
+    //! PBR Metallic
+    ai_real metallic;
+    //! PBR Metallic
+    aiColor3D sheen;
+    //! PBR Clearcoat Thickness
+    ai_real clearcoat_thickness;
+    //! PBR Clearcoat Rougness
+    ai_real clearcoat_roughness;
+    //! PBR Anisotropy
+    ai_real anisotropy;
+
+    //! bump map multipler (normal map scalar)(-bm)
+    ai_real bump_multiplier;
+
+    //! Constructor
+    Material() :
+            diffuse(ai_real(0.6), ai_real(0.6), ai_real(0.6)),
+            alpha(ai_real(1.0)),
+            shineness(ai_real(0.0)),
+            illumination_model(1),
+            ior(ai_real(1.0)),
+            transparent(ai_real(1.0), ai_real(1.0), ai_real(1.0)),
+            roughness(ai_real(1.0)),
+            metallic(ai_real(0.0)),
+            sheen(ai_real(1.0), ai_real(1.0), ai_real(1.0)),
+            clearcoat_thickness(ai_real(0.0)),
+            clearcoat_roughness(ai_real(0.0)),
+            anisotropy(ai_real(0.0)),
+            bump_multiplier(ai_real(1.0)) {
+        std::fill_n(clamp, static_cast<unsigned int>(TextureTypeCount), false);
+    }
+
+    // Destructor
+    ~Material() = default;
+};
+
+// ------------------------------------------------------------------------------------------------
+//! \struct Mesh
+//! \brief  Data structure to store a mesh
+// ------------------------------------------------------------------------------------------------
+struct Mesh {
+    static const unsigned int NoMaterial = ~0u;
+    /// The name for the mesh
+    std::string m_name;
+    /// Array with pointer to all stored faces
+    std::vector<Face *> m_Faces;
+    /// Assigned material
+    Material *m_pMaterial;
+    /// Number of stored indices.
+    unsigned int m_uiNumIndices;
+    /// Number of UV
+    unsigned int m_uiUVCoordinates[AI_MAX_NUMBER_OF_TEXTURECOORDS];
+    /// Material index.
+    unsigned int m_uiMaterialIndex;
+    /// True, if normals are stored.
+    bool m_hasNormals;
+    /// True, if vertex colors are stored.
+    bool m_hasVertexColors;
+
+    /// Constructor
+    explicit Mesh(const std::string &name) :
+            m_name(name),
+            m_pMaterial(nullptr),
+            m_uiNumIndices(0),
+            m_uiMaterialIndex(NoMaterial),
+            m_hasNormals(false) {
+        memset(m_uiUVCoordinates, 0, sizeof(unsigned int) * AI_MAX_NUMBER_OF_TEXTURECOORDS);
+    }
+
+    /// Destructor
+    ~Mesh() {
+        for (std::vector<Face *>::iterator it = m_Faces.begin();
+                it != m_Faces.end(); ++it) {
+            delete *it;
+        }
+    }
+};
+
+// ------------------------------------------------------------------------------------------------
+//! \struct Model
+//! \brief  Data structure to store all obj-specific model data
+// ------------------------------------------------------------------------------------------------
+struct Model {
+    using GroupMap = std::map<std::string, std::vector<unsigned int> *>;
+    using GroupMapIt = std::map<std::string, std::vector<unsigned int> *>::iterator;
+    using ConstGroupMapIt = std::map<std::string, std::vector<unsigned int> *>::const_iterator;
+
+    //! Model name
+    std::string m_ModelName;
+    //! List ob assigned objects
+    std::vector<Object *> m_Objects;
+    //! Pointer to current object
+    ObjFile::Object *m_pCurrent;
+    //! Pointer to current material
+    ObjFile::Material *m_pCurrentMaterial;
+    //! Pointer to default material
+    ObjFile::Material *m_pDefaultMaterial;
+    //! Vector with all generated materials
+    std::vector<std::string> m_MaterialLib;
+    //! Vector with all generated vertices
+    std::vector<aiVector3D> m_Vertices;
+    //! vector with all generated normals
+    std::vector<aiVector3D> m_Normals;
+    //! vector with all vertex colors
+    std::vector<aiVector3D> m_VertexColors;
+    //! Group map
+    GroupMap m_Groups;
+    //! Group to face id assignment
+    std::vector<unsigned int> *m_pGroupFaceIDs;
+    //! Active group
+    std::string m_strActiveGroup;
+    //! Vector with generated texture coordinates
+    std::vector<aiVector3D> m_TextureCoord;
+    //! Maximum dimension of texture coordinates
+    unsigned int m_TextureCoordDim;
+    //! Current mesh instance
+    Mesh *m_pCurrentMesh;
+    //! Vector with stored meshes
+    std::vector<Mesh *> m_Meshes;
+    //! Material map
+    std::map<std::string, Material *> m_MaterialMap;
+
+    //! \brief  The default class constructor
+    Model() :
+            m_ModelName(),
+            m_pCurrent(nullptr),
+            m_pCurrentMaterial(nullptr),
+            m_pDefaultMaterial(nullptr),
+            m_pGroupFaceIDs(nullptr),
+            m_strActiveGroup(),
+            m_TextureCoordDim(0),
+            m_pCurrentMesh(nullptr) {
+        // empty
+    }
+
+    //! \brief  The class destructor
+    ~Model() {
+        for (auto & it : m_Objects) {
+            delete it;
+        }
+        for (auto & Meshe : m_Meshes) {
+            delete Meshe;
+        }
+        for (auto & Group : m_Groups) {
+            delete Group.second;
+        }
+        for (auto & it : m_MaterialMap) {
+            delete it.second;
+        }
+    }
+};
+
+// ------------------------------------------------------------------------------------------------
+
+} // Namespace ObjFile
+} // Namespace Assimp
+
+#endif // OBJ_FILEDATA_H_INC
diff --git a/Engine/lib/assimp/code/AssetLib/Obj/ObjFileImporter.cpp b/Engine/lib/assimp/code/AssetLib/Obj/ObjFileImporter.cpp
new file mode 100644
index 000000000..68fdb2172
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Obj/ObjFileImporter.cpp
@@ -0,0 +1,783 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2020, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+#ifndef ASSIMP_BUILD_NO_OBJ_IMPORTER
+
+#include "ObjFileImporter.h"
+#include "ObjFileData.h"
+#include "ObjFileParser.h"
+#include <assimp/DefaultIOSystem.h>
+#include <assimp/IOStreamBuffer.h>
+#include <assimp/ai_assert.h>
+#include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/Importer.hpp>
+#include <assimp/ObjMaterial.h>
+#include <memory>
+
+static const aiImporterDesc desc = {
+    "Wavefront Object Importer",
+    "",
+    "",
+    "surfaces not supported",
+    aiImporterFlags_SupportTextFlavour,
+    0,
+    0,
+    0,
+    0,
+    "obj"
+};
+
+static const unsigned int ObjMinSize = 16;
+
+namespace Assimp {
+
+using namespace std;
+
+// ------------------------------------------------------------------------------------------------
+//  Default constructor
+ObjFileImporter::ObjFileImporter() :
+        m_Buffer(),
+        m_pRootObject(nullptr),
+        m_strAbsPath(std::string(1, DefaultIOSystem().getOsSeparator())) {}
+
+// ------------------------------------------------------------------------------------------------
+//  Destructor.
+ObjFileImporter::~ObjFileImporter() {
+    delete m_pRootObject;
+    m_pRootObject = nullptr;
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Returns true if file is an obj file.
+bool ObjFileImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
+    static const char *tokens[] = { "mtllib", "usemtl", "v ", "vt ", "vn ", "o ", "g ", "s ", "f " };
+    return BaseImporter::SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens), 200, false, true);
+}
+
+// ------------------------------------------------------------------------------------------------
+const aiImporterDesc *ObjFileImporter::GetInfo() const {
+    return &desc;
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Obj-file import implementation
+void ObjFileImporter::InternReadFile(const std::string &file, aiScene *pScene, IOSystem *pIOHandler) {
+    // Read file into memory
+    static const std::string mode = "rb";
+    auto streamCloser = [&](IOStream *pStream) {
+        pIOHandler->Close(pStream);
+    };
+    std::unique_ptr<IOStream, decltype(streamCloser)> fileStream(pIOHandler->Open(file, mode), streamCloser);
+    if (!fileStream.get()) {
+        throw DeadlyImportError("Failed to open file ", file, ".");
+    }
+
+    // Get the file-size and validate it, throwing an exception when fails
+    size_t fileSize = fileStream->FileSize();
+    if (fileSize < ObjMinSize) {
+        throw DeadlyImportError("OBJ-file is too small.");
+    }
+
+    IOStreamBuffer<char> streamedBuffer;
+    streamedBuffer.open(fileStream.get());
+
+    // Allocate buffer and read file into it
+    //TextFileToBuffer( fileStream.get(),m_Buffer);
+
+    // Get the model name
+    std::string modelName, folderName;
+    std::string::size_type pos = file.find_last_of("\\/");
+    if (pos != std::string::npos) {
+        modelName = file.substr(pos + 1, file.size() - pos - 1);
+        folderName = file.substr(0, pos);
+        if (!folderName.empty()) {
+            pIOHandler->PushDirectory(folderName);
+        }
+    } else {
+        modelName = file;
+    }
+
+    // parse the file into a temporary representation
+    ObjFileParser parser(streamedBuffer, modelName, pIOHandler, m_progress, file);
+
+    // And create the proper return structures out of it
+    CreateDataFromImport(parser.GetModel(), pScene);
+
+    streamedBuffer.close();
+
+    // Clean up allocated storage for the next import
+    m_Buffer.clear();
+
+    // Pop directory stack
+    if (pIOHandler->StackSize() > 0) {
+        pIOHandler->PopDirectory();
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Create the data from parsed obj-file
+void ObjFileImporter::CreateDataFromImport(const ObjFile::Model *pModel, aiScene *pScene) {
+    if (nullptr == pModel) {
+        return;
+    }
+
+    // Create the root node of the scene
+    pScene->mRootNode = new aiNode;
+    if (!pModel->m_ModelName.empty()) {
+        // Set the name of the scene
+        pScene->mRootNode->mName.Set(pModel->m_ModelName);
+    } else {
+        // This is a fatal error, so break down the application
+        ai_assert(false);
+    }
+
+    if (!pModel->m_Objects.empty()) {
+
+        unsigned int meshCount = 0;
+        unsigned int childCount = 0;
+
+        for (auto object : pModel->m_Objects) {
+            if (object) {
+                ++childCount;
+                meshCount += (unsigned int)object->m_Meshes.size();
+            }
+        }
+
+        // Allocate space for the child nodes on the root node
+        pScene->mRootNode->mChildren = new aiNode *[childCount];
+
+        // Create nodes for the whole scene
+        std::vector<aiMesh *> MeshArray;
+        MeshArray.reserve(meshCount);
+        for (size_t index = 0; index < pModel->m_Objects.size(); ++index) {
+            createNodes(pModel, pModel->m_Objects[index], pScene->mRootNode, pScene, MeshArray);
+        }
+
+        ai_assert(pScene->mRootNode->mNumChildren == childCount);
+
+        // Create mesh pointer buffer for this scene
+        if (pScene->mNumMeshes > 0) {
+            pScene->mMeshes = new aiMesh *[MeshArray.size()];
+            for (size_t index = 0; index < MeshArray.size(); ++index) {
+                pScene->mMeshes[index] = MeshArray[index];
+            }
+        }
+
+        // Create all materials
+        createMaterials(pModel, pScene);
+    } else {
+        if (pModel->m_Vertices.empty()) {
+            return;
+        }
+
+        std::unique_ptr<aiMesh> mesh(new aiMesh);
+        mesh->mPrimitiveTypes = aiPrimitiveType_POINT;
+        unsigned int n = (unsigned int)pModel->m_Vertices.size();
+        mesh->mNumVertices = n;
+
+        mesh->mVertices = new aiVector3D[n];
+        memcpy(mesh->mVertices, pModel->m_Vertices.data(), n * sizeof(aiVector3D));
+
+        if (!pModel->m_Normals.empty()) {
+            mesh->mNormals = new aiVector3D[n];
+            if (pModel->m_Normals.size() < n) {
+                throw DeadlyImportError("OBJ: vertex normal index out of range");
+            }
+            memcpy(mesh->mNormals, pModel->m_Normals.data(), n * sizeof(aiVector3D));
+        }
+
+        if (!pModel->m_VertexColors.empty()) {
+            mesh->mColors[0] = new aiColor4D[mesh->mNumVertices];
+            for (unsigned int i = 0; i < n; ++i) {
+                if (i < pModel->m_VertexColors.size()) {
+                    const aiVector3D &color = pModel->m_VertexColors[i];
+                    mesh->mColors[0][i] = aiColor4D(color.x, color.y, color.z, 1.0);
+                } else {
+                    throw DeadlyImportError("OBJ: vertex color index out of range");
+                }
+            }
+        }
+
+        pScene->mRootNode->mNumMeshes = 1;
+        pScene->mRootNode->mMeshes = new unsigned int[1];
+        pScene->mRootNode->mMeshes[0] = 0;
+        pScene->mMeshes = new aiMesh *[1];
+        pScene->mNumMeshes = 1;
+        pScene->mMeshes[0] = mesh.release();
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Creates all nodes of the model
+aiNode *ObjFileImporter::createNodes(const ObjFile::Model *pModel, const ObjFile::Object *pObject,
+        aiNode *pParent, aiScene *pScene,
+        std::vector<aiMesh *> &MeshArray) {
+    ai_assert(nullptr != pModel);
+    if (nullptr == pObject) {
+        return nullptr;
+    }
+
+    // Store older mesh size to be able to computes mesh offsets for new mesh instances
+    const size_t oldMeshSize = MeshArray.size();
+    aiNode *pNode = new aiNode;
+
+    pNode->mName = pObject->m_strObjName;
+
+    // If we have a parent node, store it
+    ai_assert(nullptr != pParent);
+    appendChildToParentNode(pParent, pNode);
+
+    for (size_t i = 0; i < pObject->m_Meshes.size(); ++i) {
+        unsigned int meshId = pObject->m_Meshes[i];
+        aiMesh *pMesh = createTopology(pModel, pObject, meshId);
+        if (pMesh) {
+            if (pMesh->mNumFaces > 0) {
+                MeshArray.push_back(pMesh);
+            } else {
+                delete pMesh;
+            }
+        }
+    }
+
+    // Create all nodes from the sub-objects stored in the current object
+    if (!pObject->m_SubObjects.empty()) {
+        size_t numChilds = pObject->m_SubObjects.size();
+        pNode->mNumChildren = static_cast<unsigned int>(numChilds);
+        pNode->mChildren = new aiNode *[numChilds];
+        pNode->mNumMeshes = 1;
+        pNode->mMeshes = new unsigned int[1];
+    }
+
+    // Set mesh instances into scene- and node-instances
+    const size_t meshSizeDiff = MeshArray.size() - oldMeshSize;
+    if (meshSizeDiff > 0) {
+        pNode->mMeshes = new unsigned int[meshSizeDiff];
+        pNode->mNumMeshes = static_cast<unsigned int>(meshSizeDiff);
+        size_t index = 0;
+        for (size_t i = oldMeshSize; i < MeshArray.size(); ++i) {
+            pNode->mMeshes[index] = pScene->mNumMeshes;
+            pScene->mNumMeshes++;
+            ++index;
+        }
+    }
+
+    return pNode;
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Create topology data
+aiMesh *ObjFileImporter::createTopology(const ObjFile::Model *pModel, const ObjFile::Object *pData, unsigned int meshIndex) {
+    // Checking preconditions
+    ai_assert(nullptr != pModel);
+
+    if (nullptr == pData) {
+        return nullptr;
+    }
+
+    // Create faces
+    ObjFile::Mesh *pObjMesh = pModel->m_Meshes[meshIndex];
+    if (!pObjMesh) {
+        return nullptr;
+    }
+
+    if (pObjMesh->m_Faces.empty()) {
+        return nullptr;
+    }
+
+    std::unique_ptr<aiMesh> pMesh(new aiMesh);
+    if (!pObjMesh->m_name.empty()) {
+        pMesh->mName.Set(pObjMesh->m_name);
+    }
+
+    for (size_t index = 0; index < pObjMesh->m_Faces.size(); index++) {
+        ObjFile::Face *const inp = pObjMesh->m_Faces[index];
+        ai_assert(nullptr != inp);
+
+        if (inp->m_PrimitiveType == aiPrimitiveType_LINE) {
+            pMesh->mNumFaces += static_cast<unsigned int>(inp->m_vertices.size() - 1);
+            pMesh->mPrimitiveTypes |= aiPrimitiveType_LINE;
+        } else if (inp->m_PrimitiveType == aiPrimitiveType_POINT) {
+            pMesh->mNumFaces += static_cast<unsigned int>(inp->m_vertices.size());
+            pMesh->mPrimitiveTypes |= aiPrimitiveType_POINT;
+        } else {
+            ++pMesh->mNumFaces;
+            if (inp->m_vertices.size() > 3) {
+                pMesh->mPrimitiveTypes |= aiPrimitiveType_POLYGON;
+            } else {
+                pMesh->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
+            }
+        }
+    }
+
+    unsigned int uiIdxCount(0u);
+    if (pMesh->mNumFaces > 0) {
+        pMesh->mFaces = new aiFace[pMesh->mNumFaces];
+        if (pObjMesh->m_uiMaterialIndex != ObjFile::Mesh::NoMaterial) {
+            pMesh->mMaterialIndex = pObjMesh->m_uiMaterialIndex;
+        }
+
+        unsigned int outIndex(0);
+
+        // Copy all data from all stored meshes
+        for (auto &face : pObjMesh->m_Faces) {
+            ObjFile::Face *const inp = face;
+            if (inp->m_PrimitiveType == aiPrimitiveType_LINE) {
+                for (size_t i = 0; i < inp->m_vertices.size() - 1; ++i) {
+                    aiFace &f = pMesh->mFaces[outIndex++];
+                    uiIdxCount += f.mNumIndices = 2;
+                    f.mIndices = new unsigned int[2];
+                }
+                continue;
+            } else if (inp->m_PrimitiveType == aiPrimitiveType_POINT) {
+                for (size_t i = 0; i < inp->m_vertices.size(); ++i) {
+                    aiFace &f = pMesh->mFaces[outIndex++];
+                    uiIdxCount += f.mNumIndices = 1;
+                    f.mIndices = new unsigned int[1];
+                }
+                continue;
+            }
+
+            aiFace *pFace = &pMesh->mFaces[outIndex++];
+            const unsigned int uiNumIndices = (unsigned int)face->m_vertices.size();
+            uiIdxCount += pFace->mNumIndices = (unsigned int)uiNumIndices;
+            if (pFace->mNumIndices > 0) {
+                pFace->mIndices = new unsigned int[uiNumIndices];
+            }
+        }
+    }
+
+    // Create mesh vertices
+    createVertexArray(pModel, pData, meshIndex, pMesh.get(), uiIdxCount);
+
+    return pMesh.release();
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Creates a vertex array
+void ObjFileImporter::createVertexArray(const ObjFile::Model *pModel,
+        const ObjFile::Object *pCurrentObject,
+        unsigned int uiMeshIndex,
+        aiMesh *pMesh,
+        unsigned int numIndices) {
+    // Checking preconditions
+    ai_assert(nullptr != pCurrentObject);
+
+    // Break, if no faces are stored in object
+    if (pCurrentObject->m_Meshes.empty())
+        return;
+
+    // Get current mesh
+    ObjFile::Mesh *pObjMesh = pModel->m_Meshes[uiMeshIndex];
+    if (nullptr == pObjMesh || pObjMesh->m_uiNumIndices < 1) {
+        return;
+    }
+
+    // Copy vertices of this mesh instance
+    pMesh->mNumVertices = numIndices;
+    if (pMesh->mNumVertices == 0) {
+        throw DeadlyImportError("OBJ: no vertices");
+    } else if (pMesh->mNumVertices > AI_MAX_VERTICES) {
+        throw DeadlyImportError("OBJ: Too many vertices");
+    }
+    pMesh->mVertices = new aiVector3D[pMesh->mNumVertices];
+
+    // Allocate buffer for normal vectors
+    if (!pModel->m_Normals.empty() && pObjMesh->m_hasNormals)
+        pMesh->mNormals = new aiVector3D[pMesh->mNumVertices];
+
+    // Allocate buffer for vertex-color vectors
+    if (!pModel->m_VertexColors.empty())
+        pMesh->mColors[0] = new aiColor4D[pMesh->mNumVertices];
+
+    // Allocate buffer for texture coordinates
+    if (!pModel->m_TextureCoord.empty() && pObjMesh->m_uiUVCoordinates[0]) {
+        pMesh->mNumUVComponents[0] = pModel->m_TextureCoordDim;
+        pMesh->mTextureCoords[0] = new aiVector3D[pMesh->mNumVertices];
+    }
+
+    // Copy vertices, normals and textures into aiMesh instance
+    bool normalsok = true, uvok = true;
+    unsigned int newIndex = 0, outIndex = 0;
+    for (auto sourceFace : pObjMesh->m_Faces) {
+        // Copy all index arrays
+        for (size_t vertexIndex = 0, outVertexIndex = 0; vertexIndex < sourceFace->m_vertices.size(); vertexIndex++) {
+            const unsigned int vertex = sourceFace->m_vertices.at(vertexIndex);
+            if (vertex >= pModel->m_Vertices.size()) {
+                throw DeadlyImportError("OBJ: vertex index out of range");
+            }
+
+            if (pMesh->mNumVertices <= newIndex) {
+                throw DeadlyImportError("OBJ: bad vertex index");
+            }
+
+            pMesh->mVertices[newIndex] = pModel->m_Vertices[vertex];
+
+            // Copy all normals
+            if (normalsok && !pModel->m_Normals.empty() && vertexIndex < sourceFace->m_normals.size()) {
+                const unsigned int normal = sourceFace->m_normals.at(vertexIndex);
+                if (normal >= pModel->m_Normals.size()) {
+                    normalsok = false;
+                } else {
+                    pMesh->mNormals[newIndex] = pModel->m_Normals[normal];
+                }
+            }
+
+            // Copy all vertex colors
+            if (vertex < pModel->m_VertexColors.size()) {
+                const aiVector3D &color = pModel->m_VertexColors[vertex];
+                pMesh->mColors[0][newIndex] = aiColor4D(color.x, color.y, color.z, 1.0);
+            }
+
+            // Copy all texture coordinates
+            if (uvok && !pModel->m_TextureCoord.empty() && vertexIndex < sourceFace->m_texturCoords.size()) {
+                const unsigned int tex = sourceFace->m_texturCoords.at(vertexIndex);
+
+                if (tex >= pModel->m_TextureCoord.size()) {
+                    uvok = false;
+                } else {
+                    const aiVector3D &coord3d = pModel->m_TextureCoord[tex];
+                    pMesh->mTextureCoords[0][newIndex] = aiVector3D(coord3d.x, coord3d.y, coord3d.z);
+                }
+            }
+
+            // Get destination face
+            aiFace *pDestFace = &pMesh->mFaces[outIndex];
+
+            const bool last = (vertexIndex == sourceFace->m_vertices.size() - 1);
+            if (sourceFace->m_PrimitiveType != aiPrimitiveType_LINE || !last) {
+                pDestFace->mIndices[outVertexIndex] = newIndex;
+                outVertexIndex++;
+            }
+
+            if (sourceFace->m_PrimitiveType == aiPrimitiveType_POINT) {
+                outIndex++;
+                outVertexIndex = 0;
+            } else if (sourceFace->m_PrimitiveType == aiPrimitiveType_LINE) {
+                outVertexIndex = 0;
+
+                if (!last)
+                    outIndex++;
+
+                if (vertexIndex) {
+                    if (!last) {
+                        pMesh->mVertices[newIndex + 1] = pMesh->mVertices[newIndex];
+                        if (!sourceFace->m_normals.empty() && !pModel->m_Normals.empty()) {
+                            pMesh->mNormals[newIndex + 1] = pMesh->mNormals[newIndex];
+                        }
+                        if (!pModel->m_TextureCoord.empty()) {
+                            for (size_t i = 0; i < pMesh->GetNumUVChannels(); i++) {
+                                pMesh->mTextureCoords[i][newIndex + 1] = pMesh->mTextureCoords[i][newIndex];
+                            }
+                        }
+                        ++newIndex;
+                    }
+
+                    pDestFace[-1].mIndices[1] = newIndex;
+                }
+            } else if (last) {
+                outIndex++;
+            }
+            ++newIndex;
+        }
+    }
+
+    if (!normalsok) {
+        delete[] pMesh->mNormals;
+        pMesh->mNormals = nullptr;
+    }
+
+    if (!uvok) {
+        delete[] pMesh->mTextureCoords[0];
+        pMesh->mTextureCoords[0] = nullptr;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Counts all stored meshes
+void ObjFileImporter::countObjects(const std::vector<ObjFile::Object *> &rObjects, int &iNumMeshes) {
+    iNumMeshes = 0;
+    if (rObjects.empty())
+        return;
+
+    iNumMeshes += static_cast<unsigned int>(rObjects.size());
+    for (auto object : rObjects) {
+        if (!object->m_SubObjects.empty()) {
+            countObjects(object->m_SubObjects, iNumMeshes);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+//   Add clamp mode property to material if necessary
+void ObjFileImporter::addTextureMappingModeProperty(aiMaterial *mat, aiTextureType type, int clampMode, int index) {
+    if (nullptr == mat) {
+        return;
+    }
+
+    mat->AddProperty<int>(&clampMode, 1, AI_MATKEY_MAPPINGMODE_U(type, index));
+    mat->AddProperty<int>(&clampMode, 1, AI_MATKEY_MAPPINGMODE_V(type, index));
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Creates the material
+void ObjFileImporter::createMaterials(const ObjFile::Model *pModel, aiScene *pScene) {
+    if (nullptr == pScene) {
+        return;
+    }
+
+    const unsigned int numMaterials = (unsigned int)pModel->m_MaterialLib.size();
+    pScene->mNumMaterials = 0;
+    if (pModel->m_MaterialLib.empty()) {
+        ASSIMP_LOG_DEBUG("OBJ: no materials specified");
+        return;
+    }
+
+    pScene->mMaterials = new aiMaterial *[numMaterials];
+    for (unsigned int matIndex = 0; matIndex < numMaterials; matIndex++) {
+        // Store material name
+        std::map<std::string, ObjFile::Material *>::const_iterator it;
+        it = pModel->m_MaterialMap.find(pModel->m_MaterialLib[matIndex]);
+
+        // No material found, use the default material
+        if (pModel->m_MaterialMap.end() == it)
+            continue;
+
+        aiMaterial *mat = new aiMaterial;
+        ObjFile::Material *pCurrentMaterial = (*it).second;
+        mat->AddProperty(&pCurrentMaterial->MaterialName, AI_MATKEY_NAME);
+
+        // convert illumination model
+        int sm = 0;
+        switch (pCurrentMaterial->illumination_model) {
+        case 0:
+            sm = aiShadingMode_NoShading;
+            break;
+        case 1:
+            sm = aiShadingMode_Gouraud;
+            break;
+        case 2:
+            sm = aiShadingMode_Phong;
+            break;
+        default:
+            sm = aiShadingMode_Gouraud;
+            ASSIMP_LOG_ERROR("OBJ: unexpected illumination model (0-2 recognized)");
+        }
+
+        mat->AddProperty<int>(&sm, 1, AI_MATKEY_SHADING_MODEL);
+
+        // Preserve the original illum value
+        mat->AddProperty<int>(&pCurrentMaterial->illumination_model, 1, AI_MATKEY_OBJ_ILLUM);
+
+        // Adding material colors
+        mat->AddProperty(&pCurrentMaterial->ambient, 1, AI_MATKEY_COLOR_AMBIENT);
+        mat->AddProperty(&pCurrentMaterial->diffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
+        mat->AddProperty(&pCurrentMaterial->specular, 1, AI_MATKEY_COLOR_SPECULAR);
+        mat->AddProperty(&pCurrentMaterial->emissive, 1, AI_MATKEY_COLOR_EMISSIVE);
+        mat->AddProperty(&pCurrentMaterial->shineness, 1, AI_MATKEY_SHININESS);
+        mat->AddProperty(&pCurrentMaterial->alpha, 1, AI_MATKEY_OPACITY);
+        mat->AddProperty(&pCurrentMaterial->transparent, 1, AI_MATKEY_COLOR_TRANSPARENT);
+        mat->AddProperty(&pCurrentMaterial->roughness, 1, AI_MATKEY_ROUGHNESS_FACTOR);
+        mat->AddProperty(&pCurrentMaterial->metallic, 1, AI_MATKEY_METALLIC_FACTOR);
+        mat->AddProperty(&pCurrentMaterial->sheen, 1, AI_MATKEY_SHEEN_COLOR_FACTOR);
+        mat->AddProperty(&pCurrentMaterial->clearcoat_thickness, 1, AI_MATKEY_CLEARCOAT_FACTOR);
+        mat->AddProperty(&pCurrentMaterial->clearcoat_roughness, 1, AI_MATKEY_CLEARCOAT_ROUGHNESS_FACTOR);
+        mat->AddProperty(&pCurrentMaterial->anisotropy, 1, AI_MATKEY_ANISOTROPY_FACTOR);
+
+        // Adding refraction index
+        mat->AddProperty(&pCurrentMaterial->ior, 1, AI_MATKEY_REFRACTI);
+
+        // Adding textures
+        const int uvwIndex = 0;
+
+        if (0 != pCurrentMaterial->texture.length) {
+            mat->AddProperty(&pCurrentMaterial->texture, AI_MATKEY_TEXTURE_DIFFUSE(0));
+            mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_DIFFUSE(0));
+            if (pCurrentMaterial->clamp[ObjFile::Material::TextureDiffuseType]) {
+                addTextureMappingModeProperty(mat, aiTextureType_DIFFUSE);
+            }
+        }
+
+        if (0 != pCurrentMaterial->textureAmbient.length) {
+            mat->AddProperty(&pCurrentMaterial->textureAmbient, AI_MATKEY_TEXTURE_AMBIENT(0));
+            mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_AMBIENT(0));
+            if (pCurrentMaterial->clamp[ObjFile::Material::TextureAmbientType]) {
+                addTextureMappingModeProperty(mat, aiTextureType_AMBIENT);
+            }
+        }
+
+        if (0 != pCurrentMaterial->textureEmissive.length) {
+            mat->AddProperty(&pCurrentMaterial->textureEmissive, AI_MATKEY_TEXTURE_EMISSIVE(0));
+            mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_EMISSIVE(0));
+        }
+
+        if (0 != pCurrentMaterial->textureSpecular.length) {
+            mat->AddProperty(&pCurrentMaterial->textureSpecular, AI_MATKEY_TEXTURE_SPECULAR(0));
+            mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_SPECULAR(0));
+            if (pCurrentMaterial->clamp[ObjFile::Material::TextureSpecularType]) {
+                addTextureMappingModeProperty(mat, aiTextureType_SPECULAR);
+            }
+        }
+
+        if (0 != pCurrentMaterial->textureBump.length) {
+            mat->AddProperty(&pCurrentMaterial->textureBump, AI_MATKEY_TEXTURE_HEIGHT(0));
+            mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_HEIGHT(0));
+            if (pCurrentMaterial->bump_multiplier != 1.0) {
+                mat->AddProperty(&pCurrentMaterial->bump_multiplier, 1, AI_MATKEY_OBJ_BUMPMULT_HEIGHT(0));
+            }
+            if (pCurrentMaterial->clamp[ObjFile::Material::TextureBumpType]) {
+                addTextureMappingModeProperty(mat, aiTextureType_HEIGHT);
+            }
+        }
+
+        if (0 != pCurrentMaterial->textureNormal.length) {
+            mat->AddProperty(&pCurrentMaterial->textureNormal, AI_MATKEY_TEXTURE_NORMALS(0));
+            mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_NORMALS(0));
+            if (pCurrentMaterial->bump_multiplier != 1.0) {
+                mat->AddProperty(&pCurrentMaterial->bump_multiplier, 1, AI_MATKEY_OBJ_BUMPMULT_NORMALS(0));
+            }
+            if (pCurrentMaterial->clamp[ObjFile::Material::TextureNormalType]) {
+                addTextureMappingModeProperty(mat, aiTextureType_NORMALS);
+            }
+        }
+
+        if (0 != pCurrentMaterial->textureReflection[0].length) {
+            ObjFile::Material::TextureType type = 0 != pCurrentMaterial->textureReflection[1].length ?
+                                                          ObjFile::Material::TextureReflectionCubeTopType :
+                                                          ObjFile::Material::TextureReflectionSphereType;
+
+            unsigned count = type == ObjFile::Material::TextureReflectionSphereType ? 1 : 6;
+            for (unsigned i = 0; i < count; i++) {
+                mat->AddProperty(&pCurrentMaterial->textureReflection[i], AI_MATKEY_TEXTURE_REFLECTION(i));
+                mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_REFLECTION(i));
+
+                if (pCurrentMaterial->clamp[type])
+                    addTextureMappingModeProperty(mat, aiTextureType_REFLECTION, 1, i);
+            }
+        }
+
+        if (0 != pCurrentMaterial->textureDisp.length) {
+            mat->AddProperty(&pCurrentMaterial->textureDisp, AI_MATKEY_TEXTURE_DISPLACEMENT(0));
+            mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_DISPLACEMENT(0));
+            if (pCurrentMaterial->clamp[ObjFile::Material::TextureDispType]) {
+                addTextureMappingModeProperty(mat, aiTextureType_DISPLACEMENT);
+            }
+        }
+
+        if (0 != pCurrentMaterial->textureOpacity.length) {
+            mat->AddProperty(&pCurrentMaterial->textureOpacity, AI_MATKEY_TEXTURE_OPACITY(0));
+            mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_OPACITY(0));
+            if (pCurrentMaterial->clamp[ObjFile::Material::TextureOpacityType]) {
+                addTextureMappingModeProperty(mat, aiTextureType_OPACITY);
+            }
+        }
+
+        if (0 != pCurrentMaterial->textureSpecularity.length) {
+            mat->AddProperty(&pCurrentMaterial->textureSpecularity, AI_MATKEY_TEXTURE_SHININESS(0));
+            mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_SHININESS(0));
+            if (pCurrentMaterial->clamp[ObjFile::Material::TextureSpecularityType]) {
+                addTextureMappingModeProperty(mat, aiTextureType_SHININESS);
+            }
+        }
+
+        if (0 != pCurrentMaterial->textureRoughness.length) {
+            mat->AddProperty(&pCurrentMaterial->textureRoughness, _AI_MATKEY_TEXTURE_BASE, aiTextureType_DIFFUSE_ROUGHNESS, 0);
+            mat->AddProperty(&uvwIndex, 1, _AI_MATKEY_UVWSRC_BASE, aiTextureType_DIFFUSE_ROUGHNESS, 0 );
+            if (pCurrentMaterial->clamp[ObjFile::Material::TextureRoughnessType]) {
+                addTextureMappingModeProperty(mat, aiTextureType_DIFFUSE_ROUGHNESS);
+            }
+        }
+
+        if (0 != pCurrentMaterial->textureMetallic.length) {
+            mat->AddProperty(&pCurrentMaterial->textureMetallic, _AI_MATKEY_TEXTURE_BASE, aiTextureType_METALNESS, 0);
+            mat->AddProperty(&uvwIndex, 1, _AI_MATKEY_UVWSRC_BASE, aiTextureType_METALNESS, 0 );
+            if (pCurrentMaterial->clamp[ObjFile::Material::TextureMetallicType]) {
+                addTextureMappingModeProperty(mat, aiTextureType_METALNESS);
+            }
+        }
+
+        if (0 != pCurrentMaterial->textureSheen.length) {
+            mat->AddProperty(&pCurrentMaterial->textureSheen, _AI_MATKEY_TEXTURE_BASE, aiTextureType_SHEEN, 0);
+            mat->AddProperty(&uvwIndex, 1, _AI_MATKEY_UVWSRC_BASE, aiTextureType_SHEEN, 0 );
+            if (pCurrentMaterial->clamp[ObjFile::Material::TextureSheenType]) {
+                addTextureMappingModeProperty(mat, aiTextureType_SHEEN);
+            }
+        }
+
+        if (0 != pCurrentMaterial->textureRMA.length) {
+            // NOTE: glTF importer places Rough/Metal/AO texture in Unknown so doing the same here for consistency.
+            mat->AddProperty(&pCurrentMaterial->textureRMA, _AI_MATKEY_TEXTURE_BASE, aiTextureType_UNKNOWN, 0);
+            mat->AddProperty(&uvwIndex, 1, _AI_MATKEY_UVWSRC_BASE, aiTextureType_UNKNOWN, 0 );
+            if (pCurrentMaterial->clamp[ObjFile::Material::TextureRMAType]) {
+                addTextureMappingModeProperty(mat, aiTextureType_UNKNOWN);
+            }
+        }
+
+        // Store material property info in material array in scene
+        pScene->mMaterials[pScene->mNumMaterials] = mat;
+        pScene->mNumMaterials++;
+    }
+
+    // Test number of created materials.
+    ai_assert(pScene->mNumMaterials == numMaterials);
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Appends this node to the parent node
+void ObjFileImporter::appendChildToParentNode(aiNode *pParent, aiNode *pChild) {
+    // Checking preconditions
+    ai_assert(nullptr != pParent);
+    ai_assert(nullptr != pChild);
+
+    // Assign parent to child
+    pChild->mParent = pParent;
+
+    // Copy node instances into parent node
+    pParent->mNumChildren++;
+    pParent->mChildren[pParent->mNumChildren - 1] = pChild;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+} // Namespace Assimp
+
+#endif // !! ASSIMP_BUILD_NO_OBJ_IMPORTER
diff --git a/Engine/lib/assimp/code/AssetLib/Obj/ObjFileImporter.h b/Engine/lib/assimp/code/AssetLib/Obj/ObjFileImporter.h
new file mode 100644
index 000000000..e76c27950
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Obj/ObjFileImporter.h
@@ -0,0 +1,122 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2020, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+#pragma once
+#ifndef OBJ_FILE_IMPORTER_H_INC
+#define OBJ_FILE_IMPORTER_H_INC
+
+#include <assimp/BaseImporter.h>
+#include <assimp/material.h>
+#include <vector>
+
+struct aiMesh;
+struct aiNode;
+
+namespace Assimp {
+
+namespace ObjFile {
+struct Object;
+struct Model;
+} // namespace ObjFile
+
+// ------------------------------------------------------------------------------------------------
+/// \class  ObjFileImporter
+/// \brief  Imports a waveform obj file
+// ------------------------------------------------------------------------------------------------
+class ObjFileImporter : public BaseImporter {
+public:
+    /// \brief  Default constructor
+    ObjFileImporter();
+
+    /// \brief  Destructor
+    ~ObjFileImporter() override;
+
+    /// \brief  Returns whether the class can handle the format of the given file.
+    /// \remark See BaseImporter::CanRead() for details.
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const override;
+
+protected:
+    //! \brief  Appends the supported extension.
+    const aiImporterDesc *GetInfo() const override;
+
+    //! \brief  File import implementation.
+    void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) override;
+
+    //! \brief  Create the data from imported content.
+    void CreateDataFromImport(const ObjFile::Model *pModel, aiScene *pScene);
+
+    //! \brief  Creates all nodes stored in imported content.
+    aiNode *createNodes(const ObjFile::Model *pModel, const ObjFile::Object *pData,
+            aiNode *pParent, aiScene *pScene, std::vector<aiMesh *> &MeshArray);
+
+    //! \brief  Creates topology data like faces and meshes for the geometry.
+    aiMesh *createTopology(const ObjFile::Model *pModel, const ObjFile::Object *pData,
+            unsigned int uiMeshIndex);
+
+    //! \brief  Creates vertices from model.
+    void createVertexArray(const ObjFile::Model *pModel, const ObjFile::Object *pCurrentObject,
+            unsigned int uiMeshIndex, aiMesh *pMesh, unsigned int numIndices);
+
+    //! \brief  Object counter helper method.
+    void countObjects(const std::vector<ObjFile::Object *> &rObjects, int &iNumMeshes);
+
+    //! \brief  Material creation.
+    void createMaterials(const ObjFile::Model *pModel, aiScene *pScene);
+
+    /// @brief  Adds special property for the used texture mapping mode of the model.
+    void addTextureMappingModeProperty(aiMaterial *mat, aiTextureType type, int clampMode = 1, int index = 0);
+
+    //! \brief  Appends a child node to a parent node and updates the data structures.
+    void appendChildToParentNode(aiNode *pParent, aiNode *pChild);
+
+private:
+    //! Data buffer
+    std::vector<char> m_Buffer;
+    //! Pointer to root object instance
+    ObjFile::Object *m_pRootObject;
+    //! Absolute pathname of model in file system
+    std::string m_strAbsPath;
+};
+
+// ------------------------------------------------------------------------------------------------
+
+} // Namespace Assimp
+
+#endif
diff --git a/Engine/lib/assimp/code/AssetLib/Obj/ObjFileMtlImporter.cpp b/Engine/lib/assimp/code/AssetLib/Obj/ObjFileMtlImporter.cpp
new file mode 100644
index 000000000..bb70a5ed0
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Obj/ObjFileMtlImporter.cpp
@@ -0,0 +1,498 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2020, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+#ifndef ASSIMP_BUILD_NO_OBJ_IMPORTER
+
+#include "ObjFileMtlImporter.h"
+#include "ObjFileData.h"
+#include "ObjTools.h"
+#include <assimp/ParsingUtils.h>
+#include <assimp/fast_atof.h>
+#include <assimp/material.h>
+#include <stdlib.h>
+#include <assimp/DefaultLogger.hpp>
+
+namespace Assimp {
+
+// Material specific token (case insensitive compare)
+static const std::string DiffuseTexture = "map_Kd";
+static const std::string AmbientTexture = "map_Ka";
+static const std::string SpecularTexture = "map_Ks";
+static const std::string OpacityTexture = "map_d";
+static const std::string EmissiveTexture1 = "map_emissive";
+static const std::string EmissiveTexture2 = "map_Ke";
+static const std::string BumpTexture1 = "map_bump";
+static const std::string BumpTexture2 = "bump";
+static const std::string NormalTextureV1 = "map_Kn";
+static const std::string NormalTextureV2 = "norm";
+static const std::string ReflectionTexture = "refl";
+static const std::string DisplacementTexture1 = "map_disp";
+static const std::string DisplacementTexture2 = "disp";
+static const std::string SpecularityTexture = "map_ns";
+static const std::string RoughnessTexture = "map_Pr";
+static const std::string MetallicTexture = "map_Pm";
+static const std::string SheenTexture = "map_Ps";
+static const std::string RMATexture = "map_Ps";
+
+// texture option specific token
+static const std::string BlendUOption = "-blendu";
+static const std::string BlendVOption = "-blendv";
+static const std::string BoostOption = "-boost";
+static const std::string ModifyMapOption = "-mm";
+static const std::string OffsetOption = "-o";
+static const std::string ScaleOption = "-s";
+static const std::string TurbulenceOption = "-t";
+static const std::string ResolutionOption = "-texres";
+static const std::string ClampOption = "-clamp";
+static const std::string BumpOption = "-bm";
+static const std::string ChannelOption = "-imfchan";
+static const std::string TypeOption = "-type";
+
+// -------------------------------------------------------------------
+//  Constructor
+ObjFileMtlImporter::ObjFileMtlImporter(std::vector<char> &buffer,
+        const std::string &,
+        ObjFile::Model *pModel) :
+        m_DataIt(buffer.begin()),
+        m_DataItEnd(buffer.end()),
+        m_pModel(pModel),
+        m_uiLine(0),
+        m_buffer() {
+    ai_assert(nullptr != m_pModel);
+    m_buffer.resize(BUFFERSIZE);
+    std::fill(m_buffer.begin(), m_buffer.end(), '\0');
+    if (nullptr == m_pModel->m_pDefaultMaterial) {
+        m_pModel->m_pDefaultMaterial = new ObjFile::Material;
+        m_pModel->m_pDefaultMaterial->MaterialName.Set("default");
+    }
+    load();
+}
+
+// -------------------------------------------------------------------
+//  Destructor
+ObjFileMtlImporter::~ObjFileMtlImporter() {
+    // empty
+}
+
+// -------------------------------------------------------------------
+//  Loads the material description
+void ObjFileMtlImporter::load() {
+    if (m_DataIt == m_DataItEnd)
+        return;
+
+    while (m_DataIt != m_DataItEnd) {
+        switch (*m_DataIt) {
+            case 'k':
+            case 'K': {
+                ++m_DataIt;
+                if (*m_DataIt == 'a') // Ambient color
+                {
+                    ++m_DataIt;
+                    getColorRGBA(&m_pModel->m_pCurrentMaterial->ambient);
+                } else if (*m_DataIt == 'd') {
+                    // Diffuse color
+                    ++m_DataIt;
+                    getColorRGBA(&m_pModel->m_pCurrentMaterial->diffuse);
+                } else if (*m_DataIt == 's') {
+                    ++m_DataIt;
+                    getColorRGBA(&m_pModel->m_pCurrentMaterial->specular);
+                } else if (*m_DataIt == 'e') {
+                    ++m_DataIt;
+                    getColorRGBA(&m_pModel->m_pCurrentMaterial->emissive);
+                }
+                m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
+            } break;
+            case 'T': {
+                ++m_DataIt;
+                // Material transmission color
+                if (*m_DataIt == 'f')  {
+                    ++m_DataIt;
+                    getColorRGBA(&m_pModel->m_pCurrentMaterial->transparent);
+                } else if (*m_DataIt == 'r')  {
+                    // Material transmission alpha value
+                    ++m_DataIt;
+                    ai_real d;
+                    getFloatValue(d);
+                    m_pModel->m_pCurrentMaterial->alpha = static_cast<ai_real>(1.0) - d;
+                }
+                m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
+            } break;
+            case 'd': {
+                if (*(m_DataIt + 1) == 'i' && *(m_DataIt + 2) == 's' && *(m_DataIt + 3) == 'p') {
+                    // A displacement map
+                    getTexture();
+                } else {
+                    // Alpha value
+                    ++m_DataIt;
+                    getFloatValue(m_pModel->m_pCurrentMaterial->alpha);
+                    m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
+                }
+            } break;
+
+            case 'N':
+            case 'n': {
+                ++m_DataIt;
+                switch (*m_DataIt) {
+                    case 's': // Specular exponent
+                        ++m_DataIt;
+                        getFloatValue(m_pModel->m_pCurrentMaterial->shineness);
+                        break;
+                    case 'i': // Index Of refraction
+                        ++m_DataIt;
+                        getFloatValue(m_pModel->m_pCurrentMaterial->ior);
+                        break;
+                    case 'e': // New material
+                        createMaterial();
+                        break;
+                    case 'o': // Norm texture
+                        --m_DataIt;
+                        getTexture();
+                        break;
+                }
+                m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
+            } break;
+
+            case 'P':
+                {
+                    ++m_DataIt;
+                    switch(*m_DataIt)
+                    {
+                    case 'r':
+                        ++m_DataIt;
+                        getFloatValue(m_pModel->m_pCurrentMaterial->roughness);
+                        break;
+                    case 'm':
+                        ++m_DataIt;
+                        getFloatValue(m_pModel->m_pCurrentMaterial->metallic);
+                        break;
+                    case 's':
+                        ++m_DataIt;
+                        getColorRGBA(&m_pModel->m_pCurrentMaterial->sheen);
+                        break;
+                    case 'c':
+                        ++m_DataIt;
+                        if (*m_DataIt == 'r') {
+                            ++m_DataIt;
+                            getFloatValue(m_pModel->m_pCurrentMaterial->clearcoat_roughness);
+                        } else {
+                            getFloatValue(m_pModel->m_pCurrentMaterial->clearcoat_thickness);
+                        }
+                        break;
+                    }
+                    m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
+                }
+                break;
+
+            case 'm': // Texture
+            case 'b': // quick'n'dirty - for 'bump' sections
+            case 'r': // quick'n'dirty - for 'refl' sections
+            {
+                getTexture();
+                m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
+            } break;
+
+            case 'i': // Illumination model
+            {
+                m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
+                getIlluminationModel(m_pModel->m_pCurrentMaterial->illumination_model);
+                m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
+            } break;
+
+            case 'a': // Anisotropy
+            {
+                ++m_DataIt;
+                getFloatValue(m_pModel->m_pCurrentMaterial->anisotropy);
+                m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
+            } break;
+
+            default: {
+                m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
+            } break;
+        }
+    }
+}
+
+// -------------------------------------------------------------------
+//  Loads a color definition
+void ObjFileMtlImporter::getColorRGBA(aiColor3D *pColor) {
+    ai_assert(nullptr != pColor);
+
+    ai_real r(0.0), g(0.0), b(0.0);
+    m_DataIt = getFloat<DataArrayIt>(m_DataIt, m_DataItEnd, r);
+    pColor->r = r;
+
+    // we have to check if color is default 0 with only one token
+    if (!IsLineEnd(*m_DataIt)) {
+        m_DataIt = getFloat<DataArrayIt>(m_DataIt, m_DataItEnd, g);
+        m_DataIt = getFloat<DataArrayIt>(m_DataIt, m_DataItEnd, b);
+    }
+    pColor->g = g;
+    pColor->b = b;
+}
+
+// -------------------------------------------------------------------
+//  Loads the kind of illumination model.
+void ObjFileMtlImporter::getIlluminationModel(int &illum_model) {
+    m_DataIt = CopyNextWord<DataArrayIt>(m_DataIt, m_DataItEnd, &m_buffer[0], BUFFERSIZE);
+    illum_model = atoi(&m_buffer[0]);
+}
+
+// -------------------------------------------------------------------
+//  Loads a single float value.
+void ObjFileMtlImporter::getFloatValue(ai_real &value) {
+    m_DataIt = CopyNextWord<DataArrayIt>(m_DataIt, m_DataItEnd, &m_buffer[0], BUFFERSIZE);
+    size_t len = std::strlen(&m_buffer[0]);
+    if (0 == len) {
+        value = 0.0f;
+        return;
+    }
+    
+    value = (ai_real)fast_atof(&m_buffer[0]);
+}
+
+// -------------------------------------------------------------------
+//  Creates a material from loaded data.
+void ObjFileMtlImporter::createMaterial() {
+    std::string line;
+    while (!IsLineEnd(*m_DataIt)) {
+        line += *m_DataIt;
+        ++m_DataIt;
+    }
+
+    std::vector<std::string> token;
+    const unsigned int numToken = tokenize<std::string>(line, token, " \t");
+    std::string name;
+    if (numToken == 1) {
+        name = AI_DEFAULT_MATERIAL_NAME;
+    } else {
+        // skip newmtl and all following white spaces
+        std::size_t first_ws_pos = line.find_first_of(" \t");
+        std::size_t first_non_ws_pos = line.find_first_not_of(" \t", first_ws_pos);
+        if (first_non_ws_pos != std::string::npos) {
+            name = line.substr(first_non_ws_pos);
+        }
+    }
+
+    name = trim_whitespaces(name);
+
+    std::map<std::string, ObjFile::Material *>::iterator it = m_pModel->m_MaterialMap.find(name);
+    if (m_pModel->m_MaterialMap.end() == it) {
+        // New Material created
+        m_pModel->m_pCurrentMaterial = new ObjFile::Material();
+        m_pModel->m_pCurrentMaterial->MaterialName.Set(name);
+        m_pModel->m_MaterialLib.push_back(name);
+        m_pModel->m_MaterialMap[name] = m_pModel->m_pCurrentMaterial;
+
+        if (m_pModel->m_pCurrentMesh) {
+            m_pModel->m_pCurrentMesh->m_uiMaterialIndex = static_cast<unsigned int>(m_pModel->m_MaterialLib.size() - 1);
+        }
+    } else {
+        // Use older material
+        m_pModel->m_pCurrentMaterial = (*it).second;
+    }
+}
+
+// -------------------------------------------------------------------
+//  Gets a texture name from data.
+void ObjFileMtlImporter::getTexture() {
+    aiString *out(nullptr);
+    int clampIndex = -1;
+
+    const char *pPtr(&(*m_DataIt));
+    if (!ASSIMP_strincmp(pPtr, DiffuseTexture.c_str(), static_cast<unsigned int>(DiffuseTexture.size()))) {
+        // Diffuse texture
+        out = &m_pModel->m_pCurrentMaterial->texture;
+        clampIndex = ObjFile::Material::TextureDiffuseType;
+    } else if (!ASSIMP_strincmp(pPtr, AmbientTexture.c_str(), static_cast<unsigned int>(AmbientTexture.size()))) {
+        // Ambient texture
+        out = &m_pModel->m_pCurrentMaterial->textureAmbient;
+        clampIndex = ObjFile::Material::TextureAmbientType;
+    } else if (!ASSIMP_strincmp(pPtr, SpecularTexture.c_str(), static_cast<unsigned int>(SpecularTexture.size()))) {
+        // Specular texture
+        out = &m_pModel->m_pCurrentMaterial->textureSpecular;
+        clampIndex = ObjFile::Material::TextureSpecularType;
+    } else if (!ASSIMP_strincmp(pPtr, DisplacementTexture1.c_str(), static_cast<unsigned int>(DisplacementTexture1.size())) ||
+               !ASSIMP_strincmp(pPtr, DisplacementTexture2.c_str(), static_cast<unsigned int>(DisplacementTexture2.size()))) {
+        // Displacement texture
+        out = &m_pModel->m_pCurrentMaterial->textureDisp;
+        clampIndex = ObjFile::Material::TextureDispType;
+    } else if (!ASSIMP_strincmp(pPtr, OpacityTexture.c_str(), static_cast<unsigned int>(OpacityTexture.size()))) {
+        // Opacity texture
+        out = &m_pModel->m_pCurrentMaterial->textureOpacity;
+        clampIndex = ObjFile::Material::TextureOpacityType;
+    } else if (!ASSIMP_strincmp(pPtr, EmissiveTexture1.c_str(), static_cast<unsigned int>(EmissiveTexture1.size())) ||
+               !ASSIMP_strincmp(pPtr, EmissiveTexture2.c_str(), static_cast<unsigned int>(EmissiveTexture2.size()))) {
+        // Emissive texture
+        out = &m_pModel->m_pCurrentMaterial->textureEmissive;
+        clampIndex = ObjFile::Material::TextureEmissiveType;
+    } else if (!ASSIMP_strincmp(pPtr, BumpTexture1.c_str(), static_cast<unsigned int>(BumpTexture1.size())) ||
+               !ASSIMP_strincmp(pPtr, BumpTexture2.c_str(), static_cast<unsigned int>(BumpTexture2.size()))) {
+        // Bump texture
+        out = &m_pModel->m_pCurrentMaterial->textureBump;
+        clampIndex = ObjFile::Material::TextureBumpType;
+    } else if (!ASSIMP_strincmp(pPtr, NormalTextureV1.c_str(), static_cast<unsigned int>(NormalTextureV1.size())) || !ASSIMP_strincmp(pPtr, NormalTextureV2.c_str(), static_cast<unsigned int>(NormalTextureV2.size()))) {
+        // Normal map
+        out = &m_pModel->m_pCurrentMaterial->textureNormal;
+        clampIndex = ObjFile::Material::TextureNormalType;
+    } else if (!ASSIMP_strincmp(pPtr, ReflectionTexture.c_str(), static_cast<unsigned int>(ReflectionTexture.size()))) {
+        // Reflection texture(s)
+        //Do nothing here
+        return;
+    } else if (!ASSIMP_strincmp(pPtr, SpecularityTexture.c_str(), static_cast<unsigned int>(SpecularityTexture.size()))) {
+        // Specularity scaling (glossiness)
+        out = &m_pModel->m_pCurrentMaterial->textureSpecularity;
+        clampIndex = ObjFile::Material::TextureSpecularityType;
+    } else if ( !ASSIMP_strincmp( pPtr, RoughnessTexture.c_str(), static_cast<unsigned int>(RoughnessTexture.size()))) {
+        // PBR Roughness texture
+        out = & m_pModel->m_pCurrentMaterial->textureRoughness;
+        clampIndex = ObjFile::Material::TextureRoughnessType;
+    } else if ( !ASSIMP_strincmp( pPtr, MetallicTexture.c_str(), static_cast<unsigned int>(MetallicTexture.size()))) {
+        // PBR Metallic texture
+        out = & m_pModel->m_pCurrentMaterial->textureMetallic;
+        clampIndex = ObjFile::Material::TextureMetallicType;
+    } else if (!ASSIMP_strincmp( pPtr, SheenTexture.c_str(), static_cast<unsigned int>(SheenTexture.size()))) {
+        // PBR Sheen (reflectance) texture
+        out = & m_pModel->m_pCurrentMaterial->textureSheen;
+        clampIndex = ObjFile::Material::TextureSheenType;
+    } else if (!ASSIMP_strincmp( pPtr, RMATexture.c_str(), static_cast<unsigned int>(RMATexture.size()))) {
+        // PBR Rough/Metal/AO texture
+        out = & m_pModel->m_pCurrentMaterial->textureRMA;
+        clampIndex = ObjFile::Material::TextureRMAType;
+    } else {
+        ASSIMP_LOG_ERROR("OBJ/MTL: Encountered unknown texture type");
+        return;
+    }
+
+    bool clamp = false;
+    getTextureOption(clamp, clampIndex, out);
+    m_pModel->m_pCurrentMaterial->clamp[clampIndex] = clamp;
+
+    std::string texture;
+    m_DataIt = getName<DataArrayIt>(m_DataIt, m_DataItEnd, texture);
+    if (nullptr != out) {
+        out->Set(texture);
+    }
+}
+
+/* /////////////////////////////////////////////////////////////////////////////
+ * Texture Option
+ * /////////////////////////////////////////////////////////////////////////////
+ * According to http://en.wikipedia.org/wiki/Wavefront_.obj_file#Texture_options
+ * Texture map statement can contains various texture option, for example:
+ *
+ *  map_Ka -o 1 1 1 some.png
+ *  map_Kd -clamp on some.png
+ *
+ * So we need to parse and skip these options, and leave the last part which is
+ * the url of image, otherwise we will get a wrong url like "-clamp on some.png".
+ *
+ * Because aiMaterial supports clamp option, so we also want to return it
+ * /////////////////////////////////////////////////////////////////////////////
+ */
+void ObjFileMtlImporter::getTextureOption(bool &clamp, int &clampIndex, aiString *&out) {
+    m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
+
+    // If there is any more texture option
+    while (!isEndOfBuffer(m_DataIt, m_DataItEnd) && *m_DataIt == '-') {
+        const char *pPtr(&(*m_DataIt));
+        //skip option key and value
+        int skipToken = 1;
+
+        if (!ASSIMP_strincmp(pPtr, ClampOption.c_str(), static_cast<unsigned int>(ClampOption.size()))) {
+            DataArrayIt it = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
+            char value[3];
+            CopyNextWord(it, m_DataItEnd, value, sizeof(value) / sizeof(*value));
+            if (!ASSIMP_strincmp(value, "on", 2)) {
+                clamp = true;
+            }
+
+            skipToken = 2;
+        } else if (!ASSIMP_strincmp(pPtr, TypeOption.c_str(), static_cast<unsigned int>(TypeOption.size()))) {
+            DataArrayIt it = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
+            char value[12];
+            CopyNextWord(it, m_DataItEnd, value, sizeof(value) / sizeof(*value));
+            if (!ASSIMP_strincmp(value, "cube_top", 8)) {
+                clampIndex = ObjFile::Material::TextureReflectionCubeTopType;
+                out = &m_pModel->m_pCurrentMaterial->textureReflection[0];
+            } else if (!ASSIMP_strincmp(value, "cube_bottom", 11)) {
+                clampIndex = ObjFile::Material::TextureReflectionCubeBottomType;
+                out = &m_pModel->m_pCurrentMaterial->textureReflection[1];
+            } else if (!ASSIMP_strincmp(value, "cube_front", 10)) {
+                clampIndex = ObjFile::Material::TextureReflectionCubeFrontType;
+                out = &m_pModel->m_pCurrentMaterial->textureReflection[2];
+            } else if (!ASSIMP_strincmp(value, "cube_back", 9)) {
+                clampIndex = ObjFile::Material::TextureReflectionCubeBackType;
+                out = &m_pModel->m_pCurrentMaterial->textureReflection[3];
+            } else if (!ASSIMP_strincmp(value, "cube_left", 9)) {
+                clampIndex = ObjFile::Material::TextureReflectionCubeLeftType;
+                out = &m_pModel->m_pCurrentMaterial->textureReflection[4];
+            } else if (!ASSIMP_strincmp(value, "cube_right", 10)) {
+                clampIndex = ObjFile::Material::TextureReflectionCubeRightType;
+                out = &m_pModel->m_pCurrentMaterial->textureReflection[5];
+            } else if (!ASSIMP_strincmp(value, "sphere", 6)) {
+                clampIndex = ObjFile::Material::TextureReflectionSphereType;
+                out = &m_pModel->m_pCurrentMaterial->textureReflection[0];
+            }
+
+            skipToken = 2;
+        } else if (!ASSIMP_strincmp(pPtr, BumpOption.c_str(), static_cast<unsigned int>(BumpOption.size()))) {
+            DataArrayIt it = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
+            getFloat(it, m_DataItEnd, m_pModel->m_pCurrentMaterial->bump_multiplier);
+            skipToken = 2;
+        } else if (!ASSIMP_strincmp(pPtr, BlendUOption.c_str(), static_cast<unsigned int>(BlendUOption.size())) || !ASSIMP_strincmp(pPtr, BlendVOption.c_str(), static_cast<unsigned int>(BlendVOption.size())) || !ASSIMP_strincmp(pPtr, BoostOption.c_str(), static_cast<unsigned int>(BoostOption.size())) || !ASSIMP_strincmp(pPtr, ResolutionOption.c_str(), static_cast<unsigned int>(ResolutionOption.size())) || !ASSIMP_strincmp(pPtr, ChannelOption.c_str(), static_cast<unsigned int>(ChannelOption.size()))) {
+            skipToken = 2;
+        } else if (!ASSIMP_strincmp(pPtr, ModifyMapOption.c_str(), static_cast<unsigned int>(ModifyMapOption.size()))) {
+            skipToken = 3;
+        } else if (!ASSIMP_strincmp(pPtr, OffsetOption.c_str(), static_cast<unsigned int>(OffsetOption.size())) || !ASSIMP_strincmp(pPtr, ScaleOption.c_str(), static_cast<unsigned int>(ScaleOption.size())) || !ASSIMP_strincmp(pPtr, TurbulenceOption.c_str(), static_cast<unsigned int>(TurbulenceOption.size()))) {
+            skipToken = 4;
+        }
+
+        for (int i = 0; i < skipToken; ++i) {
+            m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
+        }
+    }
+}
+
+// -------------------------------------------------------------------
+
+} // Namespace Assimp
+
+#endif // !! ASSIMP_BUILD_NO_OBJ_IMPORTER
diff --git a/Engine/lib/assimp/code/AssetLib/Obj/ObjFileMtlImporter.h b/Engine/lib/assimp/code/AssetLib/Obj/ObjFileMtlImporter.h
new file mode 100644
index 000000000..cda7415e6
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Obj/ObjFileMtlImporter.h
@@ -0,0 +1,113 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2020, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------*/
+#ifndef OBJFILEMTLIMPORTER_H_INC
+#define OBJFILEMTLIMPORTER_H_INC
+
+#include <assimp/defs.h>
+#include <string>
+#include <vector>
+
+struct aiColor3D;
+struct aiString;
+
+namespace Assimp {
+
+namespace ObjFile {
+struct Model;
+struct Material;
+} // namespace ObjFile
+
+/**
+ *  @class  ObjFileMtlImporter
+ *  @brief  Loads the material description from a mtl file.
+ */
+class ObjFileMtlImporter {
+public:
+    static const size_t BUFFERSIZE = 2048;
+    using DataArray = std::vector<char>;
+    using DataArrayIt = std::vector<char>::iterator;
+    using ConstDataArrayIt = std::vector<char>::const_iterator;
+
+    //! \brief  The class default constructor
+    ObjFileMtlImporter(std::vector<char> &buffer, const std::string &strAbsPath,
+            ObjFile::Model *pModel);
+
+    //! \brief  The class destructor
+    ~ObjFileMtlImporter();
+
+    ObjFileMtlImporter(const ObjFileMtlImporter &rOther) = delete;
+    ObjFileMtlImporter &operator=(const ObjFileMtlImporter &rOther) = delete;
+
+private:
+    /// Copy constructor, empty.
+    /// Load the whole material description
+    void load();
+    /// Get color data.
+    void getColorRGBA(aiColor3D *pColor);
+    /// Get illumination model from loaded data
+    void getIlluminationModel(int &illum_model);
+    /// Gets a float value from data.
+    void getFloatValue(ai_real &value);
+    /// Creates a new material from loaded data.
+    void createMaterial();
+    /// Get texture name from loaded data.
+    void getTexture();
+    void getTextureOption(bool &clamp, int &clampIndex, aiString *&out);
+
+private:
+    //! Absolute pathname
+    std::string m_strAbsPath;
+    //! Data iterator showing to the current position in data buffer
+    DataArrayIt m_DataIt;
+    //! Data iterator to end of buffer
+    DataArrayIt m_DataItEnd;
+    //! USed model instance
+    ObjFile::Model *m_pModel;
+    //! Current line in file
+    unsigned int m_uiLine;
+    //! Helper buffer
+    std::vector<char> m_buffer;
+};
+
+// ------------------------------------------------------------------------------------------------
+
+} // Namespace Assimp
+
+#endif // OBJFILEMTLIMPORTER_H_INC
diff --git a/Engine/lib/assimp/code/AssetLib/Obj/ObjFileParser.cpp b/Engine/lib/assimp/code/AssetLib/Obj/ObjFileParser.cpp
new file mode 100644
index 000000000..1786c0d9f
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Obj/ObjFileParser.cpp
@@ -0,0 +1,859 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2020, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+#ifndef ASSIMP_BUILD_NO_OBJ_IMPORTER
+
+#include "ObjFileParser.h"
+#include "ObjFileData.h"
+#include "ObjFileMtlImporter.h"
+#include "ObjTools.h"
+#include <assimp/BaseImporter.h>
+#include <assimp/DefaultIOSystem.h>
+#include <assimp/ParsingUtils.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/Importer.hpp>
+#include <cstdlib>
+#include <memory>
+#include <utility>
+
+namespace Assimp {
+
+constexpr char ObjFileParser::DEFAULT_MATERIAL[];
+
+ObjFileParser::ObjFileParser() :
+        m_DataIt(),
+        m_DataItEnd(),
+        m_pModel(nullptr),
+        m_uiLine(0),
+        m_buffer(),
+        m_pIO(nullptr),
+        m_progress(nullptr),
+        m_originalObjFileName() {
+    std::fill_n(m_buffer, Buffersize, '\0');
+}
+
+ObjFileParser::ObjFileParser(IOStreamBuffer<char> &streamBuffer, const std::string &modelName,
+        IOSystem *io, ProgressHandler *progress,
+        const std::string &originalObjFileName) :
+        m_DataIt(),
+        m_DataItEnd(),
+        m_pModel(nullptr),
+        m_uiLine(0),
+        m_buffer(),
+        m_pIO(io),
+        m_progress(progress),
+        m_originalObjFileName(originalObjFileName) {
+    std::fill_n(m_buffer, Buffersize, '\0');
+
+    // Create the model instance to store all the data
+    m_pModel.reset(new ObjFile::Model());
+    m_pModel->m_ModelName = modelName;
+
+    // create default material and store it
+    m_pModel->m_pDefaultMaterial = new ObjFile::Material;
+    m_pModel->m_pDefaultMaterial->MaterialName.Set(DEFAULT_MATERIAL);
+    m_pModel->m_MaterialLib.push_back(DEFAULT_MATERIAL);
+    m_pModel->m_MaterialMap[DEFAULT_MATERIAL] = m_pModel->m_pDefaultMaterial;
+
+    // Start parsing the file
+    parseFile(streamBuffer);
+}
+
+ObjFileParser::~ObjFileParser() {
+}
+
+void ObjFileParser::setBuffer(std::vector<char> &buffer) {
+    m_DataIt = buffer.begin();
+    m_DataItEnd = buffer.end();
+}
+
+ObjFile::Model *ObjFileParser::GetModel() const {
+    return m_pModel.get();
+}
+
+void ObjFileParser::parseFile(IOStreamBuffer<char> &streamBuffer) {
+    // only update every 100KB or it'll be too slow
+    //const unsigned int updateProgressEveryBytes = 100 * 1024;
+    unsigned int progressCounter = 0;
+    const unsigned int bytesToProcess = static_cast<unsigned int>(streamBuffer.size());
+    const unsigned int progressTotal = bytesToProcess;
+    unsigned int processed = 0;
+    size_t lastFilePos(0);
+
+    bool insideCstype = false;
+    std::vector<char> buffer;
+    while (streamBuffer.getNextDataLine(buffer, '\\')) {
+        m_DataIt = buffer.begin();
+        m_DataItEnd = buffer.end();
+
+        // Handle progress reporting
+        const size_t filePos(streamBuffer.getFilePos());
+        if (lastFilePos < filePos) {
+            processed = static_cast<unsigned int>(filePos);
+            lastFilePos = filePos;
+            progressCounter++;
+            m_progress->UpdateFileRead(processed, progressTotal);
+        }
+
+        // handle cstype section end (http://paulbourke.net/dataformats/obj/)
+        if (insideCstype) {
+            switch (*m_DataIt) {
+            case 'e': {
+                std::string name;
+                getNameNoSpace(m_DataIt, m_DataItEnd, name);
+                insideCstype = name != "end";
+            } break;
+            }
+            goto pf_skip_line;
+        }
+
+        // parse line
+        switch (*m_DataIt) {
+        case 'v': // Parse a vertex texture coordinate
+        {
+            ++m_DataIt;
+            if (*m_DataIt == ' ' || *m_DataIt == '\t') {
+                size_t numComponents = getNumComponentsInDataDefinition();
+                if (numComponents == 3) {
+                    // read in vertex definition
+                    getVector3(m_pModel->m_Vertices);
+                } else if (numComponents == 4) {
+                    // read in vertex definition (homogeneous coords)
+                    getHomogeneousVector3(m_pModel->m_Vertices);
+                } else if (numComponents == 6) {
+                    // read vertex and vertex-color
+                    getTwoVectors3(m_pModel->m_Vertices, m_pModel->m_VertexColors);
+                }
+            } else if (*m_DataIt == 't') {
+                // read in texture coordinate ( 2D or 3D )
+                ++m_DataIt;
+                size_t dim = getTexCoordVector(m_pModel->m_TextureCoord);
+                m_pModel->m_TextureCoordDim = std::max(m_pModel->m_TextureCoordDim, (unsigned int)dim);
+            } else if (*m_DataIt == 'n') {
+                // Read in normal vector definition
+                ++m_DataIt;
+                getVector3(m_pModel->m_Normals);
+            }
+        } break;
+
+        case 'p': // Parse a face, line or point statement
+        case 'l':
+        case 'f': {
+            getFace(*m_DataIt == 'f' ? aiPrimitiveType_POLYGON : (*m_DataIt == 'l' ? aiPrimitiveType_LINE : aiPrimitiveType_POINT));
+        } break;
+
+        case '#': // Parse a comment
+        {
+            getComment();
+        } break;
+
+        case 'u': // Parse a material desc. setter
+        {
+            std::string name;
+
+            getNameNoSpace(m_DataIt, m_DataItEnd, name);
+
+            size_t nextSpace = name.find(' ');
+            if (nextSpace != std::string::npos)
+                name = name.substr(0, nextSpace);
+
+            if (name == "usemtl") {
+                getMaterialDesc();
+            }
+        } break;
+
+        case 'm': // Parse a material library or merging group ('mg')
+        {
+            std::string name;
+
+            getNameNoSpace(m_DataIt, m_DataItEnd, name);
+
+            size_t nextSpace = name.find(' ');
+            if (nextSpace != std::string::npos)
+                name = name.substr(0, nextSpace);
+
+            if (name == "mg")
+                getGroupNumberAndResolution();
+            else if (name == "mtllib")
+                getMaterialLib();
+            else
+                goto pf_skip_line;
+        } break;
+
+        case 'g': // Parse group name
+        {
+            getGroupName();
+        } break;
+
+        case 's': // Parse group number
+        {
+            getGroupNumber();
+        } break;
+
+        case 'o': // Parse object name
+        {
+            getObjectName();
+        } break;
+
+        case 'c': // handle cstype section start
+        {
+            std::string name;
+            getNameNoSpace(m_DataIt, m_DataItEnd, name);
+            insideCstype = name == "cstype";
+            goto pf_skip_line;
+        } break;
+
+        default: {
+        pf_skip_line:
+            m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
+        } break;
+        }
+    }
+}
+
+void ObjFileParser::copyNextWord(char *pBuffer, size_t length) {
+    size_t index = 0;
+    m_DataIt = getNextWord<DataArrayIt>(m_DataIt, m_DataItEnd);
+    if (*m_DataIt == '\\') {
+        ++m_DataIt;
+        ++m_DataIt;
+        m_DataIt = getNextWord<DataArrayIt>(m_DataIt, m_DataItEnd);
+    }
+    while (m_DataIt != m_DataItEnd && !IsSpaceOrNewLine(*m_DataIt)) {
+        pBuffer[index] = *m_DataIt;
+        index++;
+        if (index == length - 1) {
+            break;
+        }
+        ++m_DataIt;
+    }
+
+    ai_assert(index < length);
+    pBuffer[index] = '\0';
+}
+
+static bool isDataDefinitionEnd(const char *tmp) {
+    if (*tmp == '\\') {
+        tmp++;
+        if (IsLineEnd(*tmp)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+static bool isNanOrInf(const char *in) {
+    // Look for "nan" or "inf", case insensitive
+    return ((in[0] == 'N' || in[0] == 'n') && ASSIMP_strincmp(in, "nan", 3) == 0) ||
+           ((in[0] == 'I' || in[0] == 'i') && ASSIMP_strincmp(in, "inf", 3) == 0);
+}
+
+size_t ObjFileParser::getNumComponentsInDataDefinition() {
+    size_t numComponents(0);
+    const char *tmp(&m_DataIt[0]);
+    bool end_of_definition = false;
+    while (!end_of_definition) {
+        if (isDataDefinitionEnd(tmp)) {
+            tmp += 2;
+        } else if (IsLineEnd(*tmp)) {
+            end_of_definition = true;
+        }
+        if (!SkipSpaces(&tmp)) {
+            break;
+        }
+        const bool isNum(IsNumeric(*tmp) || isNanOrInf(tmp));
+        SkipToken(tmp);
+        if (isNum) {
+            ++numComponents;
+        }
+        if (!SkipSpaces(&tmp)) {
+            break;
+        }
+    }
+    return numComponents;
+}
+
+size_t ObjFileParser::getTexCoordVector(std::vector<aiVector3D> &point3d_array) {
+    size_t numComponents = getNumComponentsInDataDefinition();
+    ai_real x, y, z;
+    if (2 == numComponents) {
+        copyNextWord(m_buffer, Buffersize);
+        x = (ai_real)fast_atof(m_buffer);
+
+        copyNextWord(m_buffer, Buffersize);
+        y = (ai_real)fast_atof(m_buffer);
+        z = 0.0;
+    } else if (3 == numComponents) {
+        copyNextWord(m_buffer, Buffersize);
+        x = (ai_real)fast_atof(m_buffer);
+
+        copyNextWord(m_buffer, Buffersize);
+        y = (ai_real)fast_atof(m_buffer);
+
+        copyNextWord(m_buffer, Buffersize);
+        z = (ai_real)fast_atof(m_buffer);
+    } else {
+        throw DeadlyImportError("OBJ: Invalid number of components");
+    }
+
+    // Coerce nan and inf to 0 as is the OBJ default value
+    if (!std::isfinite(x))
+        x = 0;
+
+    if (!std::isfinite(y))
+        y = 0;
+
+    if (!std::isfinite(z))
+        z = 0;
+
+    point3d_array.emplace_back(x, y, z);
+    m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
+    return numComponents;
+}
+
+void ObjFileParser::getVector3(std::vector<aiVector3D> &point3d_array) {
+    ai_real x, y, z;
+    copyNextWord(m_buffer, Buffersize);
+    x = (ai_real)fast_atof(m_buffer);
+
+    copyNextWord(m_buffer, Buffersize);
+    y = (ai_real)fast_atof(m_buffer);
+
+    copyNextWord(m_buffer, Buffersize);
+    z = (ai_real)fast_atof(m_buffer);
+
+    point3d_array.emplace_back(x, y, z);
+    m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
+}
+
+void ObjFileParser::getHomogeneousVector3(std::vector<aiVector3D> &point3d_array) {
+    ai_real x, y, z, w;
+    copyNextWord(m_buffer, Buffersize);
+    x = (ai_real)fast_atof(m_buffer);
+
+    copyNextWord(m_buffer, Buffersize);
+    y = (ai_real)fast_atof(m_buffer);
+
+    copyNextWord(m_buffer, Buffersize);
+    z = (ai_real)fast_atof(m_buffer);
+
+    copyNextWord(m_buffer, Buffersize);
+    w = (ai_real)fast_atof(m_buffer);
+
+    if (w == 0)
+        throw DeadlyImportError("OBJ: Invalid component in homogeneous vector (Division by zero)");
+
+    point3d_array.emplace_back(x / w, y / w, z / w);
+    m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
+}
+
+void ObjFileParser::getTwoVectors3(std::vector<aiVector3D> &point3d_array_a, std::vector<aiVector3D> &point3d_array_b) {
+    ai_real x, y, z;
+    copyNextWord(m_buffer, Buffersize);
+    x = (ai_real)fast_atof(m_buffer);
+
+    copyNextWord(m_buffer, Buffersize);
+    y = (ai_real)fast_atof(m_buffer);
+
+    copyNextWord(m_buffer, Buffersize);
+    z = (ai_real)fast_atof(m_buffer);
+
+    point3d_array_a.emplace_back(x, y, z);
+
+    copyNextWord(m_buffer, Buffersize);
+    x = (ai_real)fast_atof(m_buffer);
+
+    copyNextWord(m_buffer, Buffersize);
+    y = (ai_real)fast_atof(m_buffer);
+
+    copyNextWord(m_buffer, Buffersize);
+    z = (ai_real)fast_atof(m_buffer);
+
+    point3d_array_b.emplace_back(x, y, z);
+
+    m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
+}
+
+void ObjFileParser::getVector2(std::vector<aiVector2D> &point2d_array) {
+    ai_real x, y;
+    copyNextWord(m_buffer, Buffersize);
+    x = (ai_real)fast_atof(m_buffer);
+
+    copyNextWord(m_buffer, Buffersize);
+    y = (ai_real)fast_atof(m_buffer);
+
+    point2d_array.emplace_back(x, y);
+
+    m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
+}
+
+static const std::string DefaultObjName = "defaultobject";
+
+void ObjFileParser::getFace(aiPrimitiveType type) {
+    m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
+    if (m_DataIt == m_DataItEnd || *m_DataIt == '\0') {
+        return;
+    }
+
+    ObjFile::Face *face = new ObjFile::Face(type);
+    bool hasNormal = false;
+
+    const int vSize = static_cast<unsigned int>(m_pModel->m_Vertices.size());
+    const int vtSize = static_cast<unsigned int>(m_pModel->m_TextureCoord.size());
+    const int vnSize = static_cast<unsigned int>(m_pModel->m_Normals.size());
+
+    const bool vt = (!m_pModel->m_TextureCoord.empty());
+    const bool vn = (!m_pModel->m_Normals.empty());
+    int iPos = 0;
+    while (m_DataIt != m_DataItEnd) {
+        int iStep = 1;
+
+        if (IsLineEnd(*m_DataIt)) {
+            break;
+        }
+
+        if (*m_DataIt == '/') {
+            if (type == aiPrimitiveType_POINT) {
+                ASSIMP_LOG_ERROR("Obj: Separator unexpected in point statement");
+            }
+            iPos++;
+        } else if (IsSpaceOrNewLine(*m_DataIt)) {
+            iPos = 0;
+        } else {
+            //OBJ USES 1 Base ARRAYS!!!!
+            const int iVal(::atoi(&(*m_DataIt)));
+
+            // increment iStep position based off of the sign and # of digits
+            int tmp = iVal;
+            if (iVal < 0) {
+                ++iStep;
+            }
+            while ((tmp = tmp / 10) != 0) {
+                ++iStep;
+            }
+
+            if (iPos == 1 && !vt && vn)
+                iPos = 2; // skip texture coords for normals if there are no tex coords
+
+            if (iVal > 0) {
+                // Store parsed index
+                if (0 == iPos) {
+                    face->m_vertices.push_back(iVal - 1);
+                } else if (1 == iPos) {
+                    face->m_texturCoords.push_back(iVal - 1);
+                } else if (2 == iPos) {
+                    face->m_normals.push_back(iVal - 1);
+                    hasNormal = true;
+                } else {
+                    reportErrorTokenInFace();
+                }
+            } else if (iVal < 0) {
+                // Store relatively index
+                if (0 == iPos) {
+                    face->m_vertices.push_back(vSize + iVal);
+                } else if (1 == iPos) {
+                    face->m_texturCoords.push_back(vtSize + iVal);
+                } else if (2 == iPos) {
+                    face->m_normals.push_back(vnSize + iVal);
+                    hasNormal = true;
+                } else {
+                    reportErrorTokenInFace();
+                }
+            } else {
+                //On error, std::atoi will return 0 which is not a valid value
+                delete face;
+                throw DeadlyImportError("OBJ: Invalid face indice");
+            }
+        }
+        m_DataIt += iStep;
+    }
+
+    if (face->m_vertices.empty()) {
+        ASSIMP_LOG_ERROR("Obj: Ignoring empty face");
+        // skip line and clean up
+        m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
+        delete face;
+        return;
+    }
+
+    // Set active material, if one set
+    if (nullptr != m_pModel->m_pCurrentMaterial) {
+        face->m_pMaterial = m_pModel->m_pCurrentMaterial;
+    } else {
+        face->m_pMaterial = m_pModel->m_pDefaultMaterial;
+    }
+
+    // Create a default object, if nothing is there
+    if (nullptr == m_pModel->m_pCurrent) {
+        createObject(DefaultObjName);
+    }
+
+    // Assign face to mesh
+    if (nullptr == m_pModel->m_pCurrentMesh) {
+        createMesh(DefaultObjName);
+    }
+
+    // Store the face
+    m_pModel->m_pCurrentMesh->m_Faces.push_back(face);
+    m_pModel->m_pCurrentMesh->m_uiNumIndices += (unsigned int)face->m_vertices.size();
+    m_pModel->m_pCurrentMesh->m_uiUVCoordinates[0] += (unsigned int)face->m_texturCoords.size();
+    if (!m_pModel->m_pCurrentMesh->m_hasNormals && hasNormal) {
+        m_pModel->m_pCurrentMesh->m_hasNormals = true;
+    }
+    // Skip the rest of the line
+    m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
+}
+
+void ObjFileParser::getMaterialDesc() {
+    // Get next data for material data
+    m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
+    if (m_DataIt == m_DataItEnd) {
+        return;
+    }
+
+    char *pStart = &(*m_DataIt);
+    while (m_DataIt != m_DataItEnd && !IsLineEnd(*m_DataIt)) {
+        ++m_DataIt;
+    }
+
+    // In some cases we should ignore this 'usemtl' command, this variable helps us to do so
+    bool skip = false;
+
+    // Get name
+    std::string strName(pStart, &(*m_DataIt));
+    strName = trim_whitespaces(strName);
+    if (strName.empty())
+        skip = true;
+
+    // If the current mesh has the same material, we simply ignore that 'usemtl' command
+    // There is no need to create another object or even mesh here
+    if (m_pModel->m_pCurrentMaterial && m_pModel->m_pCurrentMaterial->MaterialName == aiString(strName)) {
+        skip = true;
+    }
+
+    if (!skip) {
+        // Search for material
+        std::map<std::string, ObjFile::Material *>::iterator it = m_pModel->m_MaterialMap.find(strName);
+        if (it == m_pModel->m_MaterialMap.end()) {
+            // Not found, so we don't know anything about the material except for its name.
+            // This may be the case if the material library is missing. We don't want to lose all
+            // materials if that happens, so create a new named material instead of discarding it
+            // completely.
+            ASSIMP_LOG_ERROR("OBJ: failed to locate material ", strName, ", creating new material");
+            m_pModel->m_pCurrentMaterial = new ObjFile::Material();
+            m_pModel->m_pCurrentMaterial->MaterialName.Set(strName);
+            m_pModel->m_MaterialLib.push_back(strName);
+            m_pModel->m_MaterialMap[strName] = m_pModel->m_pCurrentMaterial;
+        } else {
+            // Found, using detected material
+            m_pModel->m_pCurrentMaterial = (*it).second;
+        }
+
+        if (needsNewMesh(strName)) {
+            createMesh(strName);
+        }
+
+        m_pModel->m_pCurrentMesh->m_uiMaterialIndex = getMaterialIndex(strName);
+    }
+
+    // Skip rest of line
+    m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
+}
+
+// -------------------------------------------------------------------
+//  Get a comment, values will be skipped
+void ObjFileParser::getComment() {
+    m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
+}
+
+// -------------------------------------------------------------------
+//  Get material library from file.
+void ObjFileParser::getMaterialLib() {
+    // Translate tuple
+    m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
+    if (m_DataIt == m_DataItEnd) {
+        return;
+    }
+
+    char *pStart = &(*m_DataIt);
+    while (m_DataIt != m_DataItEnd && !IsLineEnd(*m_DataIt)) {
+        ++m_DataIt;
+    }
+
+    // Check for existence
+    const std::string strMatName(pStart, &(*m_DataIt));
+    std::string absName;
+
+    // Check if directive is valid.
+    if (0 == strMatName.length()) {
+        ASSIMP_LOG_WARN("OBJ: no name for material library specified.");
+        return;
+    }
+
+    if (m_pIO->StackSize() > 0) {
+        std::string path = m_pIO->CurrentDirectory();
+        if ('/' != *path.rbegin()) {
+            path += '/';
+        }
+        absName += path;
+        absName += strMatName;
+    } else {
+        absName = strMatName;
+    }
+
+    IOStream *pFile = m_pIO->Open(absName);
+    if (nullptr == pFile) {
+        ASSIMP_LOG_ERROR("OBJ: Unable to locate material file ", strMatName);
+        std::string strMatFallbackName = m_originalObjFileName.substr(0, m_originalObjFileName.length() - 3) + "mtl";
+        ASSIMP_LOG_INFO("OBJ: Opening fallback material file ", strMatFallbackName);
+        pFile = m_pIO->Open(strMatFallbackName);
+        if (!pFile) {
+            ASSIMP_LOG_ERROR("OBJ: Unable to locate fallback material file ", strMatFallbackName);
+            m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
+            return;
+        }
+    }
+
+    // Import material library data from file.
+    // Some exporters (e.g. Silo) will happily write out empty
+    // material files if the model doesn't use any materials, so we
+    // allow that.
+    std::vector<char> buffer;
+    BaseImporter::TextFileToBuffer(pFile, buffer, BaseImporter::ALLOW_EMPTY);
+    m_pIO->Close(pFile);
+
+    // Importing the material library
+    ObjFileMtlImporter mtlImporter(buffer, strMatName, m_pModel.get());
+}
+
+// -------------------------------------------------------------------
+//  Set a new material definition as the current material.
+void ObjFileParser::getNewMaterial() {
+    m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
+    m_DataIt = getNextWord<DataArrayIt>(m_DataIt, m_DataItEnd);
+    if (m_DataIt == m_DataItEnd) {
+        return;
+    }
+
+    char *pStart = &(*m_DataIt);
+    std::string strMat(pStart, *m_DataIt);
+    while (m_DataIt != m_DataItEnd && IsSpaceOrNewLine(*m_DataIt)) {
+        ++m_DataIt;
+    }
+    std::map<std::string, ObjFile::Material *>::iterator it = m_pModel->m_MaterialMap.find(strMat);
+    if (it == m_pModel->m_MaterialMap.end()) {
+        // Show a warning, if material was not found
+        ASSIMP_LOG_WARN("OBJ: Unsupported material requested: ", strMat);
+        m_pModel->m_pCurrentMaterial = m_pModel->m_pDefaultMaterial;
+    } else {
+        // Set new material
+        if (needsNewMesh(strMat)) {
+            createMesh(strMat);
+        }
+        m_pModel->m_pCurrentMesh->m_uiMaterialIndex = getMaterialIndex(strMat);
+    }
+
+    m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
+}
+
+// -------------------------------------------------------------------
+int ObjFileParser::getMaterialIndex(const std::string &strMaterialName) {
+    int mat_index = -1;
+    if (strMaterialName.empty()) {
+        return mat_index;
+    }
+    for (size_t index = 0; index < m_pModel->m_MaterialLib.size(); ++index) {
+        if (strMaterialName == m_pModel->m_MaterialLib[index]) {
+            mat_index = (int)index;
+            break;
+        }
+    }
+    return mat_index;
+}
+
+// -------------------------------------------------------------------
+//  Getter for a group name.
+void ObjFileParser::getGroupName() {
+    std::string groupName;
+
+    // here we skip 'g ' from line
+    m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
+    m_DataIt = getName<DataArrayIt>(m_DataIt, m_DataItEnd, groupName);
+    if (isEndOfBuffer(m_DataIt, m_DataItEnd)) {
+        return;
+    }
+
+    // Change active group, if necessary
+    if (m_pModel->m_strActiveGroup != groupName) {
+        // Search for already existing entry
+        ObjFile::Model::ConstGroupMapIt it = m_pModel->m_Groups.find(groupName);
+
+        // We are mapping groups into the object structure
+        createObject(groupName);
+
+        // New group name, creating a new entry
+        if (it == m_pModel->m_Groups.end()) {
+            std::vector<unsigned int> *pFaceIDArray = new std::vector<unsigned int>;
+            m_pModel->m_Groups[groupName] = pFaceIDArray;
+            m_pModel->m_pGroupFaceIDs = (pFaceIDArray);
+        } else {
+            m_pModel->m_pGroupFaceIDs = (*it).second;
+        }
+        m_pModel->m_strActiveGroup = groupName;
+    }
+    m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
+}
+
+// -------------------------------------------------------------------
+//  Not supported
+void ObjFileParser::getGroupNumber() {
+    // Not used
+
+    m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
+}
+
+// -------------------------------------------------------------------
+//  Not supported
+void ObjFileParser::getGroupNumberAndResolution() {
+    // Not used
+
+    m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
+}
+
+// -------------------------------------------------------------------
+//  Stores values for a new object instance, name will be used to
+//  identify it.
+void ObjFileParser::getObjectName() {
+    m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
+    if (m_DataIt == m_DataItEnd) {
+        return;
+    }
+    char *pStart = &(*m_DataIt);
+    while (m_DataIt != m_DataItEnd && !IsSpaceOrNewLine(*m_DataIt)) {
+        ++m_DataIt;
+    }
+
+    std::string strObjectName(pStart, &(*m_DataIt));
+    if (!strObjectName.empty()) {
+        // Reset current object
+        m_pModel->m_pCurrent = nullptr;
+
+        // Search for actual object
+        for (std::vector<ObjFile::Object *>::const_iterator it = m_pModel->m_Objects.begin();
+                it != m_pModel->m_Objects.end();
+                ++it) {
+            if ((*it)->m_strObjName == strObjectName) {
+                m_pModel->m_pCurrent = *it;
+                break;
+            }
+        }
+
+        // Allocate a new object, if current one was not found before
+        if (nullptr == m_pModel->m_pCurrent) {
+            createObject(strObjectName);
+        }
+    }
+    m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
+}
+// -------------------------------------------------------------------
+//  Creates a new object instance
+void ObjFileParser::createObject(const std::string &objName) {
+    ai_assert(nullptr != m_pModel);
+
+    m_pModel->m_pCurrent = new ObjFile::Object;
+    m_pModel->m_pCurrent->m_strObjName = objName;
+    m_pModel->m_Objects.push_back(m_pModel->m_pCurrent);
+
+    createMesh(objName);
+
+    if (m_pModel->m_pCurrentMaterial) {
+        m_pModel->m_pCurrentMesh->m_uiMaterialIndex =
+                getMaterialIndex(m_pModel->m_pCurrentMaterial->MaterialName.data);
+        m_pModel->m_pCurrentMesh->m_pMaterial = m_pModel->m_pCurrentMaterial;
+    }
+}
+// -------------------------------------------------------------------
+//  Creates a new mesh
+void ObjFileParser::createMesh(const std::string &meshName) {
+    ai_assert(nullptr != m_pModel);
+
+    m_pModel->m_pCurrentMesh = new ObjFile::Mesh(meshName);
+    m_pModel->m_Meshes.push_back(m_pModel->m_pCurrentMesh);
+    unsigned int meshId = static_cast<unsigned int>(m_pModel->m_Meshes.size() - 1);
+    if (nullptr != m_pModel->m_pCurrent) {
+        m_pModel->m_pCurrent->m_Meshes.push_back(meshId);
+    } else {
+        ASSIMP_LOG_ERROR("OBJ: No object detected to attach a new mesh instance.");
+    }
+}
+
+// -------------------------------------------------------------------
+//  Returns true, if a new mesh must be created.
+bool ObjFileParser::needsNewMesh(const std::string &materialName) {
+    // If no mesh data yet
+    if (m_pModel->m_pCurrentMesh == nullptr) {
+        return true;
+    }
+    bool newMat = false;
+    int matIdx = getMaterialIndex(materialName);
+    int curMatIdx = m_pModel->m_pCurrentMesh->m_uiMaterialIndex;
+    if (curMatIdx != int(ObjFile::Mesh::NoMaterial) && curMatIdx != matIdx
+            // no need create a new mesh if no faces in current
+            // lets say 'usemtl' goes straight after 'g'
+            && !m_pModel->m_pCurrentMesh->m_Faces.empty()) {
+        // New material -> only one material per mesh, so we need to create a new
+        // material
+        newMat = true;
+    }
+    return newMat;
+}
+
+// -------------------------------------------------------------------
+//  Shows an error in parsing process.
+void ObjFileParser::reportErrorTokenInFace() {
+    m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
+    ASSIMP_LOG_ERROR("OBJ: Not supported token in face description detected");
+}
+
+// -------------------------------------------------------------------
+
+} // Namespace Assimp
+
+#endif // !! ASSIMP_BUILD_NO_OBJ_IMPORTER
diff --git a/Engine/lib/assimp/code/AssetLib/Obj/ObjFileParser.h b/Engine/lib/assimp/code/AssetLib/Obj/ObjFileParser.h
new file mode 100644
index 000000000..fbd2f2c89
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Obj/ObjFileParser.h
@@ -0,0 +1,165 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2020, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+#ifndef OBJ_FILEPARSER_H_INC
+#define OBJ_FILEPARSER_H_INC
+
+#include <assimp/IOStreamBuffer.h>
+#include <assimp/material.h>
+#include <assimp/mesh.h>
+#include <assimp/vector2.h>
+#include <assimp/vector3.h>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace Assimp {
+
+namespace ObjFile {
+struct Model;
+struct Object;
+struct Material;
+struct Point3;
+struct Point2;
+} // namespace ObjFile
+
+class ObjFileImporter;
+class IOSystem;
+class ProgressHandler;
+
+/// \class  ObjFileParser
+/// \brief  Parser for a obj waveform file
+class ASSIMP_API ObjFileParser {
+public:
+    static const size_t Buffersize = 4096;
+    typedef std::vector<char> DataArray;
+    typedef std::vector<char>::iterator DataArrayIt;
+    typedef std::vector<char>::const_iterator ConstDataArrayIt;
+
+    /// @brief  The default constructor.
+    ObjFileParser();
+    /// @brief  Constructor with data array.
+    ObjFileParser(IOStreamBuffer<char> &streamBuffer, const std::string &modelName, IOSystem *io, ProgressHandler *progress, const std::string &originalObjFileName);
+    /// @brief  Destructor
+    ~ObjFileParser();
+    /// @brief  If you want to load in-core data.
+    void setBuffer(std::vector<char> &buffer);
+    /// @brief  Model getter.
+    ObjFile::Model *GetModel() const;
+
+    ObjFileParser(const ObjFileParser&) = delete;
+    ObjFileParser &operator=(const ObjFileParser& ) = delete;
+
+protected:
+    /// Parse the loaded file
+    void parseFile(IOStreamBuffer<char> &streamBuffer);
+    /// Method to copy the new delimited word in the current line.
+    void copyNextWord(char *pBuffer, size_t length);
+    /// Method to copy the new line.
+    //    void copyNextLine(char *pBuffer, size_t length);
+    /// Get the number of components in a line.
+    size_t getNumComponentsInDataDefinition();
+    /// Stores the vector
+    size_t getTexCoordVector(std::vector<aiVector3D> &point3d_array);
+    /// Stores the following 3d vector.
+    void getVector3(std::vector<aiVector3D> &point3d_array);
+    /// Stores the following homogeneous vector as a 3D vector
+    void getHomogeneousVector3(std::vector<aiVector3D> &point3d_array);
+    /// Stores the following two 3d vectors on the line.
+    void getTwoVectors3(std::vector<aiVector3D> &point3d_array_a, std::vector<aiVector3D> &point3d_array_b);
+    /// Stores the following 3d vector.
+    void getVector2(std::vector<aiVector2D> &point2d_array);
+    /// Stores the following face.
+    void getFace(aiPrimitiveType type);
+    /// Reads the material description.
+    void getMaterialDesc();
+    /// Gets a comment.
+    void getComment();
+    /// Gets a a material library.
+    void getMaterialLib();
+    /// Creates a new material.
+    void getNewMaterial();
+    /// Gets the group name from file.
+    void getGroupName();
+    /// Gets the group number from file.
+    void getGroupNumber();
+    /// Gets the group number and resolution from file.
+    void getGroupNumberAndResolution();
+    /// Returns the index of the material. Is -1 if not material was found.
+    int getMaterialIndex(const std::string &strMaterialName);
+    /// Parse object name
+    void getObjectName();
+    /// Creates a new object.
+    void createObject(const std::string &strObjectName);
+    /// Creates a new mesh.
+    void createMesh(const std::string &meshName);
+    /// Returns true, if a new mesh instance must be created.
+    bool needsNewMesh(const std::string &rMaterialName);
+    /// Error report in token
+    void reportErrorTokenInFace();
+
+private:
+    // Copy and assignment constructor should be private
+    // because the class contains pointer to allocated memory
+
+    /// Default material name
+    static constexpr char DEFAULT_MATERIAL[] = AI_DEFAULT_MATERIAL_NAME;
+    //! Iterator to current position in buffer
+    DataArrayIt m_DataIt;
+    //! Iterator to end position of buffer
+    DataArrayIt m_DataItEnd;
+    //! Pointer to model instance
+    std::unique_ptr<ObjFile::Model> m_pModel;
+    //! Current line (for debugging)
+    unsigned int m_uiLine;
+    //! Helper buffer
+    char m_buffer[Buffersize];
+    /// Pointer to IO system instance.
+    IOSystem *m_pIO;
+    //! Pointer to progress handler
+    ProgressHandler *m_progress;
+    /// Path to the current model, name of the obj file where the buffer comes from
+    const std::string m_originalObjFileName;
+};
+
+} // Namespace Assimp
+
+#endif
diff --git a/Engine/lib/assimp/code/AssetLib/Obj/ObjTools.h b/Engine/lib/assimp/code/AssetLib/Obj/ObjTools.h
new file mode 100644
index 000000000..9e57a1c84
--- /dev/null
+++ b/Engine/lib/assimp/code/AssetLib/Obj/ObjTools.h
@@ -0,0 +1,284 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2021, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file   ObjTools.h
+ *  @brief  Some helpful templates for text parsing
+ */
+#ifndef OBJ_TOOLS_H_INC
+#define OBJ_TOOLS_H_INC
+
+#include <assimp/ParsingUtils.h>
+#include <assimp/fast_atof.h>
+#include <vector>
+
+namespace Assimp {
+
+/** 
+ *  @brief  Returns true, if the last entry of the buffer is reached.
+ *  @param[in] it   Iterator of current position.
+ *  @param[in] end  Iterator with end of buffer.
+ *  @return true, if the end of the buffer is reached.
+ */
+template <class char_t>
+inline bool isEndOfBuffer(char_t it, char_t end) {
+    if (it == end) {
+        return true;
+    }
+    --end;
+
+    return (it == end);
+}
+
+/** 
+ *  @brief  Returns next word separated by a space
+ *  @param[in] pBuffer  Pointer to data buffer
+ *  @param[in] pEnd     Pointer to end of buffer
+ *  @return Pointer to next space
+ */
+template <class Char_T>
+inline Char_T getNextWord(Char_T pBuffer, Char_T pEnd) {
+    while (!isEndOfBuffer(pBuffer, pEnd)) {
+        if (!IsSpaceOrNewLine(*pBuffer) || IsLineEnd(*pBuffer)) {
+            break;
+        }
+        ++pBuffer;
+    }
+
+    return pBuffer;
+}
+
+/** 
+ *  @brief  Returns pointer a next token
+ *  @param[in] pBuffer  Pointer to data buffer
+ *  @param[in] pEnd     Pointer to end of buffer
+ *  @return Pointer to next token
+ */
+template <class Char_T>
+inline Char_T getNextToken(Char_T pBuffer, Char_T pEnd) {
+    while (!isEndOfBuffer(pBuffer, pEnd)) {
+        if (IsSpaceOrNewLine(*pBuffer)) {
+            break;
+        }
+        ++pBuffer;
+    }
+    return getNextWord(pBuffer, pEnd);
+}
+
+/** 
+ *  @brief  Skips a line
+ *  @param[in]  it      Iterator set to current position
+ *  @param[in]  end     Iterator set to end of scratch buffer for readout
+ *  @param[out] uiLine  Current line number in format
+ *  @return Current-iterator with new position
+ */
+template <class char_t>
+inline char_t skipLine(char_t it, char_t end, unsigned int &uiLine) {
+    while (!isEndOfBuffer(it, end) && !IsLineEnd(*it)) {
+        ++it;
+    }
+
+    if (it != end) {
+        ++it;
+        ++uiLine;
+    }
+    // fix .. from time to time there are spaces at the beginning of a material line
+    while (it != end && (*it == '\t' || *it == ' ')) {
+        ++it;
+    }
+
+    return it;
+}
+
+/** 
+ *  @brief  Get a name from the current line. Preserve space in the middle,
+ *    but trim it at the end.
+ *  @param[in]  it      set to current position
+ *  @param[in]  end     set to end of scratch buffer for readout
+ *  @param[out] name    Separated name
+ *  @return Current-iterator with new position
+ */
+template <class char_t>
+inline char_t getName(char_t it, char_t end, std::string &name) {
+    name = "";
+    if (isEndOfBuffer(it, end)) {
+        return end;
+    }
+
+    char *pStart = &(*it);
+    while (!isEndOfBuffer(it, end) && !IsLineEnd(*it)) {
+        ++it;
+    }
+
+    while (IsSpace(*it)) {
+        --it;
+    }
+    // Get name
+    // if there is no name, and the previous char is a separator, come back to start
+    while (&(*it) < pStart) {
+        ++it;
+    }
+    std::string strName(pStart, &(*it));
+    if (!strName.empty()) {
+        name = strName;
+    } 
+    
+
+    return it;
+}
+
+/** 
+ *  @brief  Get a name from the current line. Do not preserve space
+ *    in the middle, but trim it at the end.
+ *  @param  it      set to current position
+ *  @param  end     set to end of scratch buffer for readout
+ *  @param  name    Separated name
+ *  @return Current-iterator with new position
+ */
+template <class char_t>
+inline char_t getNameNoSpace(char_t it, char_t end, std::string &name) {
+    name = "";
+    if (isEndOfBuffer(it, end)) {
+        return end;
+    }
+
+    char *pStart = &(*it);
+    while (!isEndOfBuffer(it, end) && !IsLineEnd(*it) && !IsSpaceOrNewLine(*it)) {
+        ++it;
+    }
+
+    while (isEndOfBuffer(it, end) || IsLineEnd(*it) || IsSpaceOrNewLine(*it)) {
+        --it;
+    }
+    ++it;
+
+    // Get name
+    // if there is no name, and the previous char is a separator, come back to start
+    while (&(*it) < pStart) {
+        ++it;
+    }
+    std::string strName(pStart, &(*it));
+    if (!strName.empty()) {
+        name = strName;
+    }
+        
+    return it;
+}
+
+/** 
+ *  @brief  Get next word from given line
+ *  @param[in] it      set to current position
+ *  @param[in] end     set to end of scratch buffer for readout
+ *  @param[in] pBuffer Buffer for next word
+ *  @param[in] length  Buffer length
+ *  @return Current-iterator with new position
+ */
+template <class char_t>
+inline char_t CopyNextWord(char_t it, char_t end, char *pBuffer, size_t length) {
+    size_t index = 0;
+    it = getNextWord<char_t>(it, end);
+    while (!IsSpaceOrNewLine(*it) && !isEndOfBuffer(it, end)) {
+        pBuffer[index] = *it;
+        ++index;
+        if (index == length - 1) {
+            break;
+        }
+        ++it;
+    }
+    pBuffer[index] = '\0';
+    return it;
+}
+
+/** 
+ *  @brief  Get next float from given line
+ *  @param[in]  it      set to current position
+ *  @param[in]  end     set to end of scratch buffer for readout
+ *  @param[out] value   Separated float value.
+ *  @return Current-iterator with new position
+ */
+template <class char_t>
+inline char_t getFloat(char_t it, char_t end, ai_real &value) {
+    static const size_t BUFFERSIZE = 1024;
+    char buffer[BUFFERSIZE];
+    it = CopyNextWord<char_t>(it, end, buffer, BUFFERSIZE);
+    value = (ai_real)fast_atof(buffer);
+
+    return it;
+}
+
+/**
+ *  @brief  Will remove white-spaces for a string.
+ *  @param[in] str  The string to clean
+ *  @return The trimmed string.
+ */
+template <class string_type>
+inline string_type trim_whitespaces(string_type str) {
+    while (!str.empty() && IsSpace(str[0])) {
+        str.erase(0);
+    }
+    while (!str.empty() && IsSpace(str[str.length() - 1])) {
+        str.erase(str.length() - 1);
+    }
+    return str;
+}
+
+/**
+ *  @brief  Checks for a line-end.
+ *  @param[in] it   Current iterator in string.
+ *  @param[in] end  End of the string.
+ *  @return The trimmed string.
+ */
+template <class T>
+bool hasLineEnd(T it, T end) {
+    bool hasLineEnd = false;
+    while (!isEndOfBuffer(it, end)) {
+        ++it;
+        if (IsLineEnd(it)) {
+            hasLineEnd = true;
+            break;
+        }
+    }
+
+    return hasLineEnd;
+}
+
+} // Namespace Assimp
+
+#endif // OBJ_TOOLS_H_INC

From 59125c85ebd652adb13abe6cf682d5cf55393e5b Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Wed, 27 Apr 2022 21:02:55 -0400
Subject: [PATCH 382/399] Fix weird ternary operator in torquescript regression

With a test!
---
 Engine/source/console/astNodes.cpp        |  7 ++++++-
 Engine/source/console/test/ScriptTest.cpp | 16 ++++++++++++++++
 2 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/Engine/source/console/astNodes.cpp b/Engine/source/console/astNodes.cpp
index 0c69fbc5c..efcda048f 100644
--- a/Engine/source/console/astNodes.cpp
+++ b/Engine/source/console/astNodes.cpp
@@ -399,7 +399,12 @@ U32 ConditionalExprNode::compile(CodeStream& codeStream, U32 ip, TypeReq type)
 
 TypeReq ConditionalExprNode::getPreferredType()
 {
-   return trueExpr->getPreferredType();
+   // We can't make it calculate a type based on subsequent expressions as the expression
+   // could be a string, or just numbers. To play it safe, stringify anything that deals with
+   // a conditional, and let the interpreter cast as needed to other types safely.
+   //
+   // See: Regression Test 7 in ScriptTest. It has a string result in the else portion of the ?: ternary.
+   return TypeReqString;
 }
 
 //------------------------------------------------------------
diff --git a/Engine/source/console/test/ScriptTest.cpp b/Engine/source/console/test/ScriptTest.cpp
index 8bfbbfbab..f45e26fcd 100644
--- a/Engine/source/console/test/ScriptTest.cpp
+++ b/Engine/source/console/test/ScriptTest.cpp
@@ -1079,6 +1079,22 @@ TEST(Script, MiscRegressions)
    )");
 
    ASSERT_EQ(regression6.getBool(), true);
+
+   ConsoleValue regression7 = RunScript(R"(
+      function Tween::vectorAdd(%v1, %v2)
+      {
+         %temp = "";
+         for (%i = 0; %i < getWordCount(%v1); %i++) {
+            %e = getWord(%v1, %i) + getWord(%v2, %i);
+            %temp = %i == 0 ? %e : %temp SPC %e;
+         }
+
+         return %temp;
+      }
+      return Tween::vectorAdd("1 2 3", "4 5 6");
+   )");
+
+   ASSERT_STREQ(regression7.getString(), "5 7 9");
 }
 
 #endif

From c6263829c98b7dccc64be3535db94a8fc1852085 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Wed, 27 Apr 2022 21:28:49 -0400
Subject: [PATCH 383/399] Make the Console Sane Again

---
 .../game/core/console/scripts/console.tscript   | 17 +----------------
 1 file changed, 1 insertion(+), 16 deletions(-)

diff --git a/Templates/BaseGame/game/core/console/scripts/console.tscript b/Templates/BaseGame/game/core/console/scripts/console.tscript
index 9a024050d..458d9a335 100644
--- a/Templates/BaseGame/game/core/console/scripts/console.tscript
+++ b/Templates/BaseGame/game/core/console/scripts/console.tscript
@@ -53,25 +53,10 @@ function ConsoleEntry::eval()
    $Con::warnVoidAssignment = false;
 
    echo("==>" @ %text);
-   if(   !startsWith(%text, "function ")
-       && !startsWith(%text, "datablock ")
-       && !startsWith(%text, "foreach(")
-       && !startsWith(%text, "foreach$(")
-       && !startsWith(%text, "if(")
-       && !startsWith(%text, "while(")
-       && !startsWith(%text, "for(")
-       && !startsWith(%text, "switch(")
-       && !startsWith(%text, "switch$("))
-      %result = eval("return" SPC %text);
-   else
-      eval(%text);
+   eval(%text);
    $Con::warnVoidAssignment = %oldWarnVoidAssignment;
 
    ConsoleEntry.setValue("");
-
-   // Echo result.
-   if(%result !$= "")
-      echo(%result);
 }
 
 function ToggleConsole(%make)

From 41add628ad5d9d683af49869041f45f36c1545f5 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Fri, 6 May 2022 23:39:16 -0500
Subject: [PATCH 384/399] Implements a more standardized way to format usual UI
 pages by having the ability to utilize the UINavigation namespace for page
 stack navigation Also fixes behavior handling of menu input buttons not
 refreshing reliably Adds ability to define a control on a MenuList to act as
 a highlighter over the currently selected control Cleaned up BaseUI pages to
 use UINavigation which reduced a lot of duplication of elements and code

---
 .../game/core/gui/scripts/profiles.tscript    |   6 +
 Templates/BaseGame/game/data/UI/UI.tscript    |   6 +
 .../data/UI/guis/MainMenuButtons.asset.taml   |   5 +
 .../game/data/UI/guis/MainMenuButtons.gui     |  78 ++++
 .../game/data/UI/guis/MainMenuButtons.tscript |  67 +++
 .../game/data/UI/guis/chooseLevelDlg.gui      | 216 +---------
 .../game/data/UI/guis/chooseLevelDlg.tscript  |  33 +-
 .../game/data/UI/guis/joinServerMenu.gui      | 406 +-----------------
 .../game/data/UI/guis/joinServerMenu.tscript  |  37 +-
 .../BaseGame/game/data/UI/guis/mainMenu.gui   | 287 +++----------
 .../game/data/UI/guis/mainMenu.tscript        |  68 +--
 .../game/data/UI/guis/optionsMenu.gui         | 143 +++---
 .../game/data/UI/guis/optionsMenu.tscript     | 119 +++--
 .../BaseGame/game/data/UI/guis/pauseMenu.gui  | 189 ++++----
 .../game/data/UI/guis/pauseMenu.tscript       |  27 +-
 .../Keyboard_Black_Mouse_Left.png             | Bin 0 -> 3184 bytes
 .../Keyboard_Black_Mouse_Middle.png           | Bin 0 -> 3089 bytes
 .../Keyboard_Black_Mouse_Right.png            | Bin 0 -> 3227 bytes
 .../data/UI/scripts/menuInputHandling.tscript | 121 ++++--
 .../data/UI/scripts/menuNavigation.tscript    | 220 ++++++++++
 20 files changed, 811 insertions(+), 1217 deletions(-)
 create mode 100644 Templates/BaseGame/game/data/UI/guis/MainMenuButtons.asset.taml
 create mode 100644 Templates/BaseGame/game/data/UI/guis/MainMenuButtons.gui
 create mode 100644 Templates/BaseGame/game/data/UI/guis/MainMenuButtons.tscript
 create mode 100644 Templates/BaseGame/game/data/UI/images/Inputs/Keyboard & Mouse/Keyboard_Black_Mouse_Left.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/Inputs/Keyboard & Mouse/Keyboard_Black_Mouse_Middle.png
 create mode 100644 Templates/BaseGame/game/data/UI/images/Inputs/Keyboard & Mouse/Keyboard_Black_Mouse_Right.png
 create mode 100644 Templates/BaseGame/game/data/UI/scripts/menuNavigation.tscript

diff --git a/Templates/BaseGame/game/core/gui/scripts/profiles.tscript b/Templates/BaseGame/game/core/gui/scripts/profiles.tscript
index f09e1d542..150783b46 100644
--- a/Templates/BaseGame/game/core/gui/scripts/profiles.tscript
+++ b/Templates/BaseGame/game/core/gui/scripts/profiles.tscript
@@ -81,6 +81,12 @@ new GuiControlProfile (GuiDefaultProfile)
    cursorColor = "0 0 0 255";
 };
 
+if(!isObject(GuiNonModalDefaultProfile))
+new GuiControlProfile (GuiNonModalDefaultProfile : GuiDefaultProfile)
+{
+   modal = false;
+};
+
 if(!isObject(GuiToolTipProfile))
 new GuiControlProfile (GuiToolTipProfile)
 {
diff --git a/Templates/BaseGame/game/data/UI/UI.tscript b/Templates/BaseGame/game/data/UI/UI.tscript
index cd645f86f..ee2c111e7 100644
--- a/Templates/BaseGame/game/data/UI/UI.tscript
+++ b/Templates/BaseGame/game/data/UI/UI.tscript
@@ -35,12 +35,18 @@ function UI::initClient(%this)
    //Profiles
    %this.queueExec("./scripts/profiles");
    
+   //Navigation Utility Scripts
+   %this.queueExec("./scripts/menuNavigation");
+   
    //Now gui files
    %this.queueExec("./scripts/menuInputHandling");
    
    %this.queueExec("./guis/mainMenu");
    %this.queueExec("./guis/mainMenu.gui");
    
+   %this.queueExec("./guis/mainMenuButtons");
+   %this.queueExec("./guis/mainMenuButtons.gui");
+   
    %this.queueExec("./guis/chooseLevelDlg");
    %this.queueExec("./guis/chooseLevelDlg.gui");
    
diff --git a/Templates/BaseGame/game/data/UI/guis/MainMenuButtons.asset.taml b/Templates/BaseGame/game/data/UI/guis/MainMenuButtons.asset.taml
new file mode 100644
index 000000000..2ab6cfeef
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/guis/MainMenuButtons.asset.taml
@@ -0,0 +1,5 @@
+<GUIAsset
+    AssetName="MainMenuButtons"
+    scriptFile="@assetFile=MainMenuButtons.tscript"
+    GUIFile="@assetFile=MainMenuButtons.gui"
+    VersionId="1"/>
diff --git a/Templates/BaseGame/game/data/UI/guis/MainMenuButtons.gui b/Templates/BaseGame/game/data/UI/guis/MainMenuButtons.gui
new file mode 100644
index 000000000..8664b312e
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/guis/MainMenuButtons.gui
@@ -0,0 +1,78 @@
+//--- OBJECT WRITE BEGIN ---
+$guiContent = new GuiControl(MainMenuButtons) {
+   extent = "1024 768";
+   profile = "GuiNonModalDefaultProfile";
+   tooltipProfile = "GuiToolTipProfile";
+   isContainer = "1";
+   canSaveDynamicFields = "1";
+      originalAssetName = "MainMenuButtons";
+
+   new GuiStackControl(MainMenuButtonList) {
+      padding = "15";
+      dynamicSize = "0";
+      position = "312 145";
+      extent = "400 477";
+      horizSizing = "center";
+      vertSizing = "center";
+      profile = "GuiDefaultProfile";
+      tooltipProfile = "GuiToolTipProfile";
+      superClass = "MenuList";
+
+      new GuiButtonCtrl(MainMenuSinglePlayerBtn) {
+         text = "Single Player";
+         extent = "400 55";
+         profile = "GuiMenuButtonProfile";
+         command = "openSinglePlayerMenu();";
+         tooltipProfile = "GuiToolTipProfile";
+      };
+      new GuiButtonCtrl(MainMenuCreateSrvrBtn) {
+         text = "Create Server";
+         position = "0 70";
+         extent = "400 55";
+         profile = "GuiMenuButtonProfile";
+         command = "openMultiPlayerMenu();";
+         tooltipProfile = "GuiToolTipProfile";
+      };
+      new GuiButtonCtrl(MainMenuJoinSrvrBtn) {
+         text = "Join Server";
+         position = "0 140";
+         extent = "400 55";
+         profile = "GuiMenuButtonProfile";
+         command = "openJoinServerMenu();";
+         tooltipProfile = "GuiToolTipProfile";
+      };
+      new GuiButtonCtrl(MainMenuOptionBtn) {
+         text = "Options";
+         position = "0 210";
+         extent = "400 55";
+         profile = "GuiMenuButtonProfile";
+         command = "openOptionsMenu();";
+         tooltipProfile = "GuiToolTipProfile";
+      };
+      new GuiButtonCtrl(MainMenuWorldEditBtn) {
+         text = "Open World Editor";
+         position = "0 280";
+         extent = "400 55";
+         profile = "GuiMenuButtonProfile";
+         command = "openWorldEditorBtn();";
+         tooltipProfile = "GuiToolTipProfile";
+      };
+      new GuiButtonCtrl(MainMenuGuiEditBtn) {
+         text = "Open GUI Editor";
+         position = "0 350";
+         extent = "400 55";
+         profile = "GuiMenuButtonProfile";
+         command = "openGUIEditorBtn();";
+         tooltipProfile = "GuiToolTipProfile";
+      };
+      new GuiButtonCtrl(MainMenuExitBtn) {
+         text = "Exit";
+         position = "0 420";
+         extent = "400 55";
+         profile = "GuiMenuButtonProfile";
+         command = "quit();";
+         tooltipProfile = "GuiToolTipProfile";
+      };
+   };
+};
+//--- OBJECT WRITE END ---
diff --git a/Templates/BaseGame/game/data/UI/guis/MainMenuButtons.tscript b/Templates/BaseGame/game/data/UI/guis/MainMenuButtons.tscript
new file mode 100644
index 000000000..2dd07c18a
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/guis/MainMenuButtons.tscript
@@ -0,0 +1,67 @@
+function MainMenuButtons::onWake(%this)
+{
+}
+
+function MainMenuButtons::onSleep(%this)
+{
+}
+
+//Optional, as the check defaults to true, but here as an example case
+function MainMenuButtonList::canOpen(%this)
+{
+   return true;
+}
+
+function MainMenuButtonList::onOpen(%this)
+{
+   MainMenuButtonList.setAsActiveMenuList();
+   
+   $activeMenuButtonContainer-->button1.disable();
+   $activeMenuButtonContainer-->button2.disable();
+   $activeMenuButtonContainer-->button3.disable();
+   $activeMenuButtonContainer-->button4.set("btn_a", "Return", "Go", "MainMenuButtonList.activate();");
+   $activeMenuButtonContainer-->button5.disable();
+}
+
+//Optional, as the check defaults to true, but here as an example case
+function MainMenuButtonList::canClose(%this)
+{
+   return true;
+}
+
+
+function MainMenuButtonList::onClose(%this)
+{
+}
+
+function openSinglePlayerMenu()
+{
+   $pref::HostMultiPlayer=false;
+   MainMenuGui.pushPage(ChooseLevelDlg);
+}
+
+function openMultiPlayerMenu()
+{
+   $pref::HostMultiPlayer=true;
+   MainMenuGui.pushPage(ChooseLevelDlg);
+}
+
+function openJoinServerMenu()
+{
+   MainMenuGui.pushPage(JoinServerMenu);
+}
+
+function openOptionsMenu()
+{
+   MainMenuGui.pushPage(OptionsMenu);
+}
+
+function openWorldEditorBtn()
+{
+   fastLoadWorldEdit(1);
+}
+
+function openGUIEditorBtn()
+{
+   fastLoadGUIEdit(1);
+}
\ No newline at end of file
diff --git a/Templates/BaseGame/game/data/UI/guis/chooseLevelDlg.gui b/Templates/BaseGame/game/data/UI/guis/chooseLevelDlg.gui
index 775e910f0..414f1ccb3 100644
--- a/Templates/BaseGame/game/data/UI/guis/chooseLevelDlg.gui
+++ b/Templates/BaseGame/game/data/UI/guis/chooseLevelDlg.gui
@@ -1,17 +1,12 @@
 //--- OBJECT WRITE BEGIN ---
 $guiContent = new GuiControl(ChooseLevelDlg) {
-   position = "0 0";
    extent = "1024 768";
    minExtent = "8 8";
    horizSizing = "width";
    vertSizing = "height";
-   profile = "GuiDefaultProfile";
-   visible = "1";
-   active = "1";
+   profile = "GuiNonModalDefaultProfile";
    tooltipProfile = "GuiToolTipProfile";
-   hovertime = "1000";
    isContainer = "1";
-   canSave = "1";
    canSaveDynamicFields = "1";
       Enabled = "1";
       launchInEditor = "0";
@@ -20,294 +15,91 @@ $guiContent = new GuiControl(ChooseLevelDlg) {
    new GuiControl(ChooseLevelWindow) {
       position = "48 56";
       extent = "928 655";
-      minExtent = "8 2";
       horizSizing = "center";
       vertSizing = "center";
       profile = "GuiDefaultProfile";
-      visible = "1";
-      active = "1";
       tooltipProfile = "GuiToolTipProfile";
-      hovertime = "1000";
       isContainer = "1";
-      canSave = "1";
-      canSaveDynamicFields = "0";
 
       new GuiBitmapBarCtrl() {
-         percent = "100";
-         vertical = "0";
-         flipClip = "0";
-         bitmapAsset = "UI:panel_image";
-         color = "255 255 255 255";
-         position = "0 0";
+         BitmapAsset = "UI:panel_image";
          extent = "927 40";
-         minExtent = "8 2";
          horizSizing = "width";
-         vertSizing = "bottom";
          profile = "GuiDefaultProfile";
-         visible = "1";
-         active = "1";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
       };
       new GuiTextCtrl(LevelSelectTitle) {
          text = "SINGLE PLAYER";
-         maxLength = "1024";
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
          position = "22 10";
          extent = "307 28";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
          profile = "MenuHeaderText";
-         visible = "1";
-         active = "1";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
       };
       new GuiBitmapBarCtrl() {
-         percent = "100";
-         vertical = "0";
-         flipClip = "0";
-         bitmapAsset = "UI:panel_low_image";
-         color = "255 255 255 255";
+         BitmapAsset = "UI:panel_low_image";
          position = "0 40";
          extent = "927 618";
-         minExtent = "8 2";
          horizSizing = "width";
-         vertSizing = "bottom";
          profile = "GuiDefaultProfile";
-         visible = "1";
-         active = "1";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
       };
       new GuiBitmapCtrl() {
-         bitmapAsset = "UI:no_preview_image";
-         color = "255 255 255 255";
-         wrap = "0";
+         BitmapAsset = "Core_Rendering:missingTexture_image";
          position = "513 71";
          extent = "400 300";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
          profile = "GuiDefaultProfile";
-         visible = "1";
-         active = "1";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
          internalName = "CurrentPreview";
-         canSave = "1";
          canSaveDynamicFields = "1";
             Enabled = "1";
       };
       new GuiTextCtrl() {
          text = "Example Level";
          maxLength = "255";
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
          position = "514 375";
          extent = "398 27";
          minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
          profile = "MenuHeaderText";
-         visible = "1";
-         active = "1";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
          isContainer = "0";
          internalName = "LevelName";
-         canSave = "1";
-         canSaveDynamicFields = "0";
       };
       new GuiTextCtrl() {
          text = "Description:";
          maxLength = "255";
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
          position = "522 410";
          extent = "91 18";
          minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
          profile = "MenuSubHeaderText";
-         visible = "1";
-         active = "1";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
          isContainer = "0";
          internalName = "LevelDescriptionLabel";
-         canSave = "1";
-         canSaveDynamicFields = "0";
       };
       new GuiMLTextCtrl() {
-         lineSpacing = "2";
-         allowColorChars = "0";
-         maxChars = "-1";
          text = "This is placeholder text";
-         useURLMouseCursor = "0";
          position = "522 436";
          extent = "391 14";
          minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
          profile = "GuiMLWhiteTextProfile";
-         visible = "1";
-         active = "1";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
          internalName = "LevelDescription";
-         canSave = "1";
-         canSaveDynamicFields = "0";
       };
       new GuiScrollCtrl() {
-         willFirstRespond = "1";
          hScrollBar = "dynamic";
          vScrollBar = "dynamic";
-         lockHorizScroll = "0";
-         lockVertScroll = "0";
-         constantThumbHeight = "0";
-         childMargin = "0 0";
-         mouseWheelScrollSpeed = "-1";
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
          position = "0 40";
          extent = "450 580";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
          profile = "GuiMenuScrollProfile";
-         visible = "1";
-         active = "1";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
 
          new GuiGameListMenuCtrl(LevelList) {
-            debugRender = "0";
             callbackOnInputs = "1";
             position = "1 1";
             extent = "450 90";
-            minExtent = "8 2";
-            horizSizing = "right";
-            vertSizing = "bottom";
             profile = "DefaultListMenuProfile";
-            visible = "1";
-            active = "1";
             tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
             class = "UIMenuButtonList";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-      };
    };
-   new GuiControl(ChooseLevelButtonHolder) {
-      position = "189 711";
-      extent = "646 40";
-      minExtent = "8 2";
-      horizSizing = "center";
-      vertSizing = "top";
-      profile = "GuiDefaultProfile";
-      visible = "1";
-      active = "1";
-      tooltipProfile = "GuiToolTipProfile";
-      hovertime = "1000";
-      isContainer = "1";
-      class = "MenuInputButtonContainer";
-      canSave = "1";
-      canSaveDynamicFields = "0";
-
-      new GuiIconButtonCtrl() {
-         buttonMargin = "4 4";
-         iconBitmap = "./";
-         iconLocation = "Left";
-         sizeIconToButton = "1";
-         makeIconSquare = "1";
-         textLocation = "Right";
-         textMargin = "4";
-         autoSize = "0";
-         text = "Go";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "363 0";
-         extent = "140 40";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "MainMenuButtonList.activateRow();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "goButton";
-         class = "MenuInputButton";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiIconButtonCtrl() {
-         buttonMargin = "4 4";
-         iconBitmap = "./";
-         iconLocation = "Left";
-         sizeIconToButton = "1";
-         makeIconSquare = "1";
-         textLocation = "Right";
-         textMargin = "4";
-         autoSize = "0";
-         text = "Back";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "507 0";
-         extent = "140 40";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "MainMenuButtonList.activateRow();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "backButton";
-         class = "MenuInputButton";
-         canSave = "1";
-         canSaveDynamicFields = "0";
       };
    };
 };
diff --git a/Templates/BaseGame/game/data/UI/guis/chooseLevelDlg.tscript b/Templates/BaseGame/game/data/UI/guis/chooseLevelDlg.tscript
index adfb088b0..d15887f72 100644
--- a/Templates/BaseGame/game/data/UI/guis/chooseLevelDlg.tscript
+++ b/Templates/BaseGame/game/data/UI/guis/chooseLevelDlg.tscript
@@ -26,6 +26,12 @@ function ChooseLevelDlg::onWake( %this )
    if(!isObject(LevelListEntries))
       new ArrayObject(LevelListEntries){};
       
+   if(!isObject(ChooseLevelAssetQuery))
+      new AssetQuery(ChooseLevelAssetQuery);
+}
+
+function ChooseLevelDlg::onOpen(%this)
+{
    LevelList.clearRows();
    LevelListEntries.empty();
    
@@ -33,10 +39,10 @@ function ChooseLevelDlg::onWake( %this )
    ChooseLevelWindow->LevelDescriptionLabel.visible = false;
    ChooseLevelWindow->LevelDescription.visible = false;
    
-   %assetQuery = new AssetQuery();
-   AssetDatabase.findAssetType(%assetQuery, "LevelAsset");
+   ChooseLevelAssetQuery.clear();
+   AssetDatabase.findAssetType(ChooseLevelAssetQuery, "LevelAsset");
       
-   %count = %assetQuery.getCount();
+   %count = ChooseLevelAssetQuery.getCount();
    
    if(%count == 0 && !IsDirectory("tools"))
    {
@@ -44,13 +50,13 @@ function ChooseLevelDlg::onWake( %this )
       MessageBoxOK("Error", "No levels were found in any modules. Please ensure you have modules loaded that contain gameplay code and level files.", 
          "Canvas.popDialog(ChooseLevelDlg); if(isObject(ChooseLevelDlg.returnGui) && ChooseLevelDlg.returnGui.isMethod(\"onReturnTo\")) ChooseLevelDlg.returnGui.onReturnTo();");
          
-      %assetQuery.delete();
+      ChooseLevelAssetQuery.delete();
       return;
    }
    
    for(%i=0; %i < %count; %i++)
 	{
-	   %assetId = %assetQuery.getAsset(%i);
+	   %assetId = ChooseLevelAssetQuery.getAsset(%i);
 	   
 	   if(AssetDatabase.getAssetModule(%assetId).ModuleId $= "ToolsModule")
 	      continue;
@@ -97,12 +103,12 @@ function ChooseLevelDlg::onWake( %this )
       LevelSelectTitle.setText("CREATE SERVER");
    
    ChooseLevelButtonHolder.setActive();
-}
 
-function ChooseLevelButtonHolder::onWake(%this)
-{
-   %this-->goButton.set("btn_a", "Return", "Start Level", "ChooseLevelDlg.beginLevel();");
-   %this-->backButton.set("btn_b", "Escape", "Back", "ChooseLevelDlg.backOut();");
+   $activeMenuButtonContainer-->button1.disable();
+   $activeMenuButtonContainer-->button2.disable();
+   $activeMenuButtonContainer-->button3.disable();
+   $activeMenuButtonContainer-->button4.set("btn_a", "Return", "Start Level", "ChooseLevelDlg.beginLevel();");
+   $activeMenuButtonContainer-->button5.set("btn_b", "Escape", "Back", %this @ ".navigation.popPage();");
 }
 
 function ChooseLevelDlg::onSleep( %this )
@@ -202,10 +208,3 @@ function ChooseLevelDlg::beginLevel(%this)
       StartGame(); 
    }
 }
-
-function ChooseLevelDlg::backOut(%this)
-{
-   Canvas.popDialog(ChooseLevelDlg);
-   if(isObject(ChooseLevelDlg.returnGui) && ChooseLevelDlg.returnGui.isMethod("onReturnTo"))    
-      ChooseLevelDlg.returnGui.onReturnTo();  
-}
diff --git a/Templates/BaseGame/game/data/UI/guis/joinServerMenu.gui b/Templates/BaseGame/game/data/UI/guis/joinServerMenu.gui
index c812e624c..758d1bf32 100644
--- a/Templates/BaseGame/game/data/UI/guis/joinServerMenu.gui
+++ b/Templates/BaseGame/game/data/UI/guis/joinServerMenu.gui
@@ -1,559 +1,159 @@
 //--- OBJECT WRITE BEGIN ---
 $guiContent = new GuiControl(JoinServerMenu) {
-   position = "0 0";
    extent = "1024 768";
-   minExtent = "8 2";
-   horizSizing = "right";
-   vertSizing = "bottom";
-   profile = "GuiDefaultProfile";
-   visible = "1";
-   active = "1";
+   profile = "GuiNonModalDefaultProfile";
    tooltipProfile = "GuiToolTipProfile";
-   hovertime = "1000";
    isContainer = "1";
-   canSave = "1";
-   canSaveDynamicFields = "1";
-      returnGui = "MainMenuGui";
-
-   new GuiInputCtrl(JoinServerMenuInputHandler) {
-      sendAxisEvents = "1";
-      sendBreakEvents = "1";
-      sendModifierEvents = "0";
-      ignoreMouseEvents = "1";
-      lockMouse = "0";
-      position = "-10 0";
-      extent = "10 10";
-      minExtent = "8 2";
       horizSizing = "width";
       vertSizing = "height";
-      profile = "GuiInputCtrlProfile";
-      visible = "1";
-      active = "1";
-      tooltipProfile = "GuiToolTipProfile";
-      hovertime = "1000";
-      isContainer = "0";
-      canSave = "1";
       canSaveDynamicFields = "0";
-   };
+
    new GuiControl(JoinServerWindow) {
       position = "48 56";
       extent = "928 655";
-      minExtent = "8 2";
       horizSizing = "center";
       vertSizing = "center";
       profile = "GuiDefaultProfile";
-      visible = "1";
-      active = "1";
       tooltipProfile = "GuiToolTipProfile";
-      hovertime = "1000";
       isContainer = "1";
-      canSave = "1";
-      canSaveDynamicFields = "0";
 
       new GuiBitmapBarCtrl() {
-         percent = "100";
-         vertical = "0";
-         flipClip = "0";
          BitmapAsset = "UI:panel_image";
-         color = "255 255 255 255";
-         position = "0 0";
          extent = "927 40";
-         minExtent = "8 2";
          horizSizing = "width";
-         vertSizing = "bottom";
          profile = "GuiDefaultProfile";
-         visible = "1";
-         active = "1";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
       };
       new GuiTextCtrl() {
          text = "JOIN SERVER";
-         maxLength = "1024";
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
          position = "22 10";
          extent = "207 28";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
          profile = "MenuHeaderText";
-         visible = "1";
-         active = "1";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
       };
       new GuiBitmapBarCtrl() {
-         percent = "100";
-         vertical = "0";
-         flipClip = "0";
          BitmapAsset = "UI:panel_low_image";
-         color = "255 255 255 255";
          position = "0 40";
          extent = "927 618";
-         minExtent = "8 2";
          horizSizing = "width";
-         vertSizing = "bottom";
          profile = "GuiDefaultProfile";
-         visible = "1";
-         active = "1";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
       };
       new GuiTextCtrl(JS_status) {
          text = "No servers found.";
          maxLength = "255";
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
          position = "392 47";
          extent = "148 18";
          minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
          profile = "MenuSubHeaderText";
-         visible = "1";
-         active = "1";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
       };
       new GuiTextCtrl() {
          text = "Players";
          maxLength = "255";
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
          position = "269 67";
          extent = "36 18";
          minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
          profile = "GuiMLWhiteTextProfile";
-         visible = "1";
-         active = "1";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
          isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
       };
       new GuiTextCtrl() {
          text = "Version";
          maxLength = "255";
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
          position = "335 67";
          extent = "38 18";
          minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
          profile = "GuiMLWhiteTextProfile";
-         visible = "1";
-         active = "1";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
          isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
       };
       new GuiTextCtrl() {
          text = "Game";
          maxLength = "255";
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
          position = "412 67";
          extent = "28 18";
          minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
          profile = "GuiMLWhiteTextProfile";
-         visible = "1";
-         active = "1";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
          isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
       };
       new GuiTextCtrl() {
          text = "Ping";
          maxLength = "255";
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
          position = "212 67";
          extent = "20 18";
          minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
          profile = "GuiMLWhiteTextProfile";
-         visible = "1";
-         active = "1";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
          isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
       };
       new GuiTextCtrl() {
          text = "Server Name";
          maxLength = "255";
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
          position = "12 67";
          extent = "63 18";
          minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
          profile = "GuiMLWhiteTextProfile";
-         visible = "1";
-         active = "1";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
          isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
       };
       new GuiScrollCtrl() {
-         willFirstRespond = "1";
          hScrollBar = "dynamic";
          vScrollBar = "dynamic";
-         lockHorizScroll = "0";
-         lockVertScroll = "0";
-         constantThumbHeight = "0";
-         childMargin = "0 0";
-         mouseWheelScrollSpeed = "-1";
-         margin = "0 0 0 0";
-         padding = "0 0 0 0";
-         anchorTop = "1";
-         anchorBottom = "0";
-         anchorLeft = "1";
-         anchorRight = "0";
          position = "19 98";
          extent = "890 501";
          minExtent = "8 8";
-         horizSizing = "right";
-         vertSizing = "bottom";
          profile = "GuiMenuScrollProfile";
-         visible = "1";
-         active = "1";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
 
          new GuiStackControl(JoinServerList) {
-            stackingType = "Vertical";
-            horizStacking = "Left to Right";
-            vertStacking = "Top to Bottom";
             padding = "10";
-            dynamicSize = "1";
-            dynamicNonStackExtent = "0";
-            dynamicPos = "0";
             changeChildSizeToFit = "0";
-            changeChildPosition = "1";
             position = "1 1";
             extent = "888 16";
-            minExtent = "16 16";
             horizSizing = "center";
             vertSizing = "center";
             profile = "GuiDefaultProfile";
-            visible = "1";
-            active = "1";
             tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "1";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-            class = "MenuList";
+            superClass = "MenuList";
          };
       };
       new GuiControl(JS_queryStatus) {
          position = "16 615";
          extent = "900 35";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
          profile = "GuiDefaultProfile";
          visible = "0";
-         active = "1";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
          isContainer = "1";
          hidden = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
 
          new GuiProgressCtrl(JS_statusBar) {
-            maxLength = "1024";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
             position = "84 0";
             extent = "695 35";
             minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
             profile = "GuiProgressProfile";
-            visible = "1";
-            active = "1";
             tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
             isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
          };
          new GuiButtonCtrl(JS_cancelQuery) {
             text = "Cancel!";
-            groupNum = "-1";
-            buttonType = "PushButton";
-            useMouseEvents = "0";
-            position = "0 0";
             extent = "84 35";
             minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
             profile = "GuiMenuButtonProfile";
-            visible = "1";
-            active = "1";
             command = "JoinServerDlg.cancel();";
             tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
-            isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
          };
          new GuiTextCtrl(JS_statusText) {
             text = "Querying master server";
             maxLength = "255";
-            margin = "0 0 0 0";
-            padding = "0 0 0 0";
-            anchorTop = "1";
-            anchorBottom = "0";
-            anchorLeft = "1";
-            anchorRight = "0";
             position = "84 0";
             extent = "695 35";
             minExtent = "8 8";
-            horizSizing = "right";
-            vertSizing = "bottom";
             profile = "GuiMenuButtonProfile";
-            visible = "1";
-            active = "1";
             tooltipProfile = "GuiToolTipProfile";
-            hovertime = "1000";
             isContainer = "0";
-            canSave = "1";
-            canSaveDynamicFields = "0";
-         };
-      };
    };
-   new GuiControl(JoinServerButtonHolder) {
-      position = "116 711";
-      extent = "791 40";
-      minExtent = "8 2";
-      horizSizing = "center";
-      vertSizing = "top";
-      profile = "GuiDefaultProfile";
-      visible = "1";
-      active = "1";
-      tooltipProfile = "GuiToolTipProfile";
-      hovertime = "1000";
-      isContainer = "1";
-      class = "MenuInputButtonContainer";
-      canSave = "1";
-      canSaveDynamicFields = "0";
-
-      new GuiIconButtonCtrl() {
-         buttonMargin = "4 4";
-         BitmapAsset = "UI:Keyboard_Black_Return_image";
-         iconLocation = "Left";
-         sizeIconToButton = "1";
-         makeIconSquare = "1";
-         textLocation = "Right";
-         textMargin = "4";
-         autoSize = "0";
-         text = "Join";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "507 0";
-         extent = "140 40";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "0";
-         command = "JoinServerMenu.join();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "joinButton";
-         class = "MenuInputButton";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiIconButtonCtrl() {
-         buttonMargin = "4 4";
-         BitmapAsset = "UI:Keyboard_Black_Escape_image";
-         iconLocation = "Left";
-         sizeIconToButton = "1";
-         makeIconSquare = "1";
-         textLocation = "Right";
-         textMargin = "4";
-         autoSize = "0";
-         text = "Back";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "651 0";
-         extent = "140 40";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "JoinServerMenu.backOut();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "backButton";
-         class = "MenuInputButton";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiIconButtonCtrl() {
-         buttonMargin = "4 4";
-         BitmapAsset = "UI:Keyboard_Black_Q_image";
-         iconLocation = "Left";
-         sizeIconToButton = "1";
-         makeIconSquare = "1";
-         textLocation = "Right";
-         textMargin = "4";
-         autoSize = "0";
-         text = "Query LAN";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "0 0";
-         extent = "140 40";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "JoinServerMenu.queryLan();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "queryLANButton";
-         class = "MenuInputButton";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiIconButtonCtrl() {
-         buttonMargin = "4 4";
-         BitmapAsset = "UI:Keyboard_Black_E_image";
-         iconLocation = "Left";
-         sizeIconToButton = "1";
-         makeIconSquare = "1";
-         textLocation = "Right";
-         textMargin = "4";
-         autoSize = "0";
-         text = "Query Online";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "144 0";
-         extent = "140 40";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "JoinServerMenu.query();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "queryInternetButton";
-         class = "MenuInputButton";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiIconButtonCtrl() {
-         buttonMargin = "4 4";
-         BitmapAsset = "UI:Keyboard_Black_R_image";
-         iconLocation = "Left";
-         sizeIconToButton = "1";
-         makeIconSquare = "1";
-         textLocation = "Right";
-         textMargin = "4";
-         autoSize = "0";
-         text = "Refresh";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "325 0";
-         extent = "140 40";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "JoinServerMenu.refresh();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "refreshButton";
-         class = "MenuInputButton";
-         canSave = "1";
-         canSaveDynamicFields = "0";
       };
    };
 };
diff --git a/Templates/BaseGame/game/data/UI/guis/joinServerMenu.tscript b/Templates/BaseGame/game/data/UI/guis/joinServerMenu.tscript
index 1fe75bd46..c4d9fff24 100644
--- a/Templates/BaseGame/game/data/UI/guis/joinServerMenu.tscript
+++ b/Templates/BaseGame/game/data/UI/guis/joinServerMenu.tscript
@@ -1,26 +1,17 @@
 
 function JoinServerMenu::onWake(%this)
 {
-   JoinServerButtonHolder.setActive();
-   
-   JoinServerList.setAsActiveMenuList();
-   
-   JoinServerMenuInputHandler.setFirstResponder();
 }   
 
-function JoinServerButtonHolder::onWake(%this)
+function JoinServerMenu::onOpen(%this)
 {
-   %this-->joinButton.set("btn_start", "Return", "Join", "JoinServerMenu.join();");
-   %this-->backButton.set("btn_b", "Escape", "Back", "JoinServerMenu.backOut();");
-   %this-->refreshButton.set("btn_y", "R", "Refresh", "JoinServerMenu.refresh();");
-   %this-->queryLANButton.set("btn_a", "Q", "Query LAN", "JoinServerMenu.queryLan();");
-   %this-->queryInternetButton.set("btn_x", "E", "Query Online", "JoinServerMenu.query();");
-}
+   JoinServerList.setAsActiveMenuList();
 
-function JoinServerMenuInputHandler::onInputEvent(%this, %device, %action, %state)
-{
-   if(%state)
-      $activeMenuButtonContainer.processInputs(%device, %action);
+   $activeMenuButtonContainer-->button1.set("btn_y", "R", "Refresh", "JoinServerMenu.refresh();");
+   $activeMenuButtonContainer-->button2.set("btn_a", "Q", "Query LAN", "JoinServerMenu.queryLan();");
+   $activeMenuButtonContainer-->button3.set("btn_x", "E", "Query Online", "JoinServerMenu.query();");
+   $activeMenuButtonContainer-->button4.set("btn_start", "Return", "Join", "JoinServerMenu.join();");
+   $activeMenuButtonContainer-->button5.set("btn_b", "Escape", "Back", "cancelServerQuery(); " @ %this @ ".navigation.popPage();");
 }
 
 //----------------------------------------
@@ -79,7 +70,7 @@ function JoinServerMenu::join(%this)
 function JoinServerMenu::refresh(%this)
 {
    cancelServerQuery();
-   %index= JS_serverList.getSelectedId();
+   %index= JoinServerList.getActiveRow();
 
    // The server info index is stored in the row along with the
    // rest of displayed info.
@@ -93,16 +84,6 @@ function JoinServerMenu::refreshSelectedServer( %this )
    querySingleServer( $JoinGameAddress, 0 );
 }
 
-//----------------------------------------
-function JoinServerMenu::backOut(%this)
-{
-   cancelServerQuery();
-   
-   Canvas.popDialog(JoinServerMenu);
-   if(isObject(JoinServerMenu.returnGui) && JoinServerMenu.returnGui.isMethod("onReturnTo"))    
-      JoinServerMenu.returnGui.onReturnTo();  
-}
-
 //----------------------------------------
 function JoinServerMenu::update(%this)
 {
@@ -124,7 +105,7 @@ function JoinServerMenu::update(%this)
       JoinServerList.add(%serverBtn);
    }
 
-   JoinServerButtonHolder-->joinButton.setActive(JoinServerList.getCount() > 0);
+   $activeMenuButtonContainer-->button4.setActive(JoinServerList.getCount() > 0);
 } 
 
 //----------------------------------------
diff --git a/Templates/BaseGame/game/data/UI/guis/mainMenu.gui b/Templates/BaseGame/game/data/UI/guis/mainMenu.gui
index 6b1dad9ee..ab1fbb714 100644
--- a/Templates/BaseGame/game/data/UI/guis/mainMenu.gui
+++ b/Templates/BaseGame/game/data/UI/guis/mainMenu.gui
@@ -1,41 +1,23 @@
 //--- OBJECT WRITE BEGIN ---
 $guiContent = new GuiChunkedBitmapCtrl(MainMenuGui) {
    BitmapAsset = "UI:backgrounddark_image";
-   useVariable = "0";
-   tile = "0";
-   position = "0 0";
    extent = "1024 768";
    minExtent = "8 8";
    horizSizing = "width";
    vertSizing = "height";
    profile = "GuiDefaultProfile";
-   visible = "1";
-   active = "1";
    tooltipProfile = "GuiToolTipProfile";
-   hovertime = "1000";
    isContainer = "1";
-   canSave = "1";
-   canSaveDynamicFields = "1";
-      Enabled = "1";
-      isDecoy = "0";
-      navigationIndex = "-1";
+   superClass = "UINavigation";
+   canSaveDynamicFields = "0";
 
    new GuiBitmapCtrl(MainMenuAppLogo) {
       BitmapAsset = "UI:Torque_3D_logo_alt_image";
-      color = "255 255 255 255";
-      wrap = "0";
       position = "550 30";
       extent = "443 139";
-      minExtent = "8 2";
       horizSizing = "left";
-      vertSizing = "bottom";
       profile = "GuiDefaultProfile";
-      visible = "1";
-      active = "1";
       tooltipProfile = "GuiToolTipProfile";
-      hovertime = "1000";
-      isContainer = "0";
-      canSave = "1";
       canSaveDynamicFields = "1";
          autoFitExtents = "0";
          bitmapMode = "Stretched";
@@ -45,239 +27,98 @@ $guiContent = new GuiChunkedBitmapCtrl(MainMenuGui) {
          useModifiers = "0";
          useStates = "1";
    };
-   new GuiStackControl(MainMenuButtonList) {
-      stackingType = "Vertical";
-      horizStacking = "Left to Right";
-      vertStacking = "Top to Bottom";
-      padding = "15";
-      dynamicSize = "0";
-      dynamicNonStackExtent = "0";
-      dynamicPos = "0";
-      changeChildSizeToFit = "1";
-      changeChildPosition = "1";
-      position = "312 111";
-      extent = "400 477";
-      minExtent = "16 16";
-      horizSizing = "center";
-      vertSizing = "center";
-      profile = "GuiDefaultProfile";
-      visible = "1";
-      active = "1";
-      tooltipProfile = "GuiToolTipProfile";
-      hovertime = "1000";
-      isContainer = "1";
-      canSave = "1";
-      canSaveDynamicFields = "0";
-      class = "MenuList";
-
-      new GuiButtonCtrl(MainMenuSinglePlayerBtn) {
-         text = "Single Player";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "0 0";
-         extent = "400 55";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "openSinglePlayerMenu();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl(MainMenuCreateSrvrBtn) {
-         text = "Create Server";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "0 70";
-         extent = "400 55";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "openMultiPlayerMenu();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl(MainMenuJoinSrvrBtn) {
-         text = "Join Server";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "0 140";
-         extent = "400 55";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "openJoinServerMenu();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl(MainMenuOptionBtn) {
-         text = "Options";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "0 210";
-         extent = "400 55";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "openOptionsMenu();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl(MainMenuWorldEditBtn) {
-         text = "Open World Editor";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "0 280";
-         extent = "400 55";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "openWorldEditorBtn();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl(MainMenuGuiEditBtn) {
-         text = "Open GUI Editor";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "0 350";
-         extent = "400 55";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "openGUIEditorBtn();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-      new GuiButtonCtrl(MainMenuExitBtn) {
-         text = "Exit";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "0 420";
-         extent = "400 55";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
-         profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "quit();";
-         tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-      };
-   };
    new GuiControl(MainMenuButtonHolder) {
-      position = "189 711";
-      extent = "646 40";
-      minExtent = "8 2";
+      position = "143 711";
+      extent = "736 40";
       horizSizing = "center";
       vertSizing = "top";
       profile = "GuiDefaultProfile";
-      visible = "1";
-      active = "1";
       tooltipProfile = "GuiToolTipProfile";
-      hovertime = "1000";
       isContainer = "1";
       class = "MenuInputButtonContainer";
-      canSave = "1";
-      canSaveDynamicFields = "0";
 
       new GuiIconButtonCtrl() {
-         buttonMargin = "4 4";
          BitmapAsset = "UI:Keyboard_Black_Return_image";
-         iconLocation = "Left";
          sizeIconToButton = "1";
          makeIconSquare = "1";
          textLocation = "Right";
-         textMargin = "4";
-         autoSize = "0";
          text = "Go";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "507 0";
+         position = "11 0";
          extent = "140 40";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
          profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "MainMenuButtonList.activateRow();";
+         command = "MainMenuButtonList.activate();";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "goButton";
+         internalName = "button1";
+         class = "MenuInputButton";
+      };
+      new GuiIconButtonCtrl() {
+         BitmapAsset = "UI:Keyboard_Black_Return_image";
+         sizeIconToButton = "1";
+         makeIconSquare = "1";
+         textLocation = "Right";
+         text = "Go";
+         position = "155 0";
+         extent = "140 40";
+         profile = "GuiMenuButtonProfile";
+         command = "MainMenuButtonList.activate();";
+         tooltipProfile = "GuiToolTipProfile";
+         internalName = "button2";
+         class = "MenuInputButton";
+      };
+      new GuiIconButtonCtrl() {
+         BitmapAsset = "UI:Keyboard_Black_Return_image";
+         sizeIconToButton = "1";
+         makeIconSquare = "1";
+         textLocation = "Right";
+         text = "Go";
+         position = "299 0";
+         extent = "140 40";
+         profile = "GuiMenuButtonProfile";
+         command = "MainMenuButtonList.activate();";
+         tooltipProfile = "GuiToolTipProfile";
+         internalName = "button3";
+         class = "MenuInputButton";
+      };
+      new GuiIconButtonCtrl() {
+         BitmapAsset = "UI:Keyboard_Black_Return_image";
+         sizeIconToButton = "1";
+         makeIconSquare = "1";
+         textLocation = "Right";
+         text = "Go";
+         position = "443 0";
+         extent = "140 40";
+         profile = "GuiMenuButtonProfile";
+         command = "MainMenuButtonList.activate();";
+         tooltipProfile = "GuiToolTipProfile";
+         internalName = "button4";
+         class = "MenuInputButton";
+   };
+      new GuiIconButtonCtrl() {
+         BitmapAsset = "UI:Keyboard_Black_Return_image";
+         sizeIconToButton = "1";
+         makeIconSquare = "1";
+         textLocation = "Right";
+         text = "Go";
+         position = "587 0";
+         extent = "140 40";
+         profile = "GuiMenuButtonProfile";
+         command = "MainMenuButtonList.activate();";
+         tooltipProfile = "GuiToolTipProfile";
+         internalName = "button5";
          class = "MenuInputButton";
-         canSave = "1";
-         canSaveDynamicFields = "0";
       };
    };
    new GuiInputCtrl(MainMenuInputHandler) {
-      class = "MenuInputHandler";
       sendAxisEvents = "1";
       sendBreakEvents = "1";
-      sendModifierEvents = "0";
       ignoreMouseEvents = "1";
-      lockMouse = "0";
       position = "-50 0";
       extent = "10 10";
-      minExtent = "8 2";
       horizSizing = "width";
       vertSizing = "height";
       profile = "GuiInputCtrlProfile";
-      visible = "1";
-      active = "1";
       tooltipProfile = "GuiToolTipProfile";
-      hovertime = "1000";
-      isContainer = "0";
-      canSave = "1";
-      canSaveDynamicFields = "0";
+      class = "MenuInputHandler";
    };
 };
 //--- OBJECT WRITE END ---
diff --git a/Templates/BaseGame/game/data/UI/guis/mainMenu.tscript b/Templates/BaseGame/game/data/UI/guis/mainMenu.tscript
index c626c4952..0fc08009e 100644
--- a/Templates/BaseGame/game/data/UI/guis/mainMenu.tscript
+++ b/Templates/BaseGame/game/data/UI/guis/mainMenu.tscript
@@ -5,66 +5,20 @@ function MainMenuGui::onAdd(%this)
 
 function MainMenuGui::onWake(%this)
 {
-   MainMenuButtonList.setAsActiveMenuList();
    MainMenuButtonHolder.setActive();
    MainMenuInputHandler.setFirstResponder();
-}
-
-function MainMenuGui::onSleep(%this)
-{
-   MainMenuButtonHolder.hidden = true;
+   
+   %this.setRootPage(MainMenuButtonList);
+   
+   %this.resizePages = true;
 }
 
 function MainMenuButtonHolder::onWake(%this)
 {
-   %this-->goButton.set("btn_a", "Return", "Go", "MainMenuButtonList.activate();");
-}
-
-function openSinglePlayerMenu()
-{
-   $pref::HostMultiPlayer=false;
-   Canvas.pushDialog(ChooseLevelDlg);
-   ChooseLevelDlg.returnGui = MainMenuGui; 
-   MainMenuButtonList.hidden = true; 
-   MainMenuButtonHolder.hidden = true;
-}
-
-function openMultiPlayerMenu()
-{
-   $pref::HostMultiPlayer=true;
-   Canvas.pushDialog(ChooseLevelDlg);
-   ChooseLevelDlg.returnGui = MainMenuGui; 
-   MainMenuButtonList.hidden = true; 
-}
-
-function openJoinServerMenu()
-{
-   Canvas.pushDialog(JoinServerMenu);
-   JoinServerMenu.returnGui = MainMenuGui; 
-   MainMenuButtonList.hidden = true; 
-}
-
-function openOptionsMenu()
-{
-   Canvas.pushDialog(OptionsMenu);
-   OptionsMenu.returnGui = MainMenuGui; 
-   MainMenuButtonList.hidden = true; 
-}
-
-function openWorldEditorBtn()
-{
-   fastLoadWorldEdit(1);
-}
-
-function openGUIEditorBtn()
-{
-   fastLoadGUIEdit(1);
-}
-
-function MainMenuGui::onReturnTo(%this)
-{
-   MainMenuButtonList.hidden = false;
-   MainMenuButtonList.setFirstResponder();
-   MainMenuButtonHolder.setActive();
-   MainMenuButtonList.setAsActiveMenuList();
-}
+   //clean slate
+   %this-->button1.disable();
+   %this-->button2.disable();
+   %this-->button3.disable();
+   %this-->button4.disable();
+   %this-->button5.disable();
+}
\ No newline at end of file
diff --git a/Templates/BaseGame/game/data/UI/guis/optionsMenu.gui b/Templates/BaseGame/game/data/UI/guis/optionsMenu.gui
index 3b1999ed9..8e80ed1cd 100644
--- a/Templates/BaseGame/game/data/UI/guis/optionsMenu.gui
+++ b/Templates/BaseGame/game/data/UI/guis/optionsMenu.gui
@@ -1,12 +1,14 @@
 //--- OBJECT WRITE BEGIN ---
 $guiContent = new GuiControl(OptionsMenu) {
    extent = "1024 768";
-   profile = "GuiDefaultProfile";
+   profile = "GuiNonModalDefaultProfile";
    tooltipProfile = "GuiToolTipProfile";
    isContainer = "1";
+   horizSizing = "width";
+   vertSizing = "height";
    canSaveDynamicFields = "0";
 
-   new GuiControl() {
+   new GuiControl(OptionsMenuContainer) {
       position = "48 56";
       extent = "928 655";
       horizSizing = "aspectCenter";
@@ -33,7 +35,7 @@ $guiContent = new GuiControl(OptionsMenu) {
       new GuiTextCtrl() {
          text = "OPTIONS";
          position = "22 7";
-         extent = "120 28";
+         extent = "220 28";
          profile = "MenuHeaderText";
          tooltipProfile = "GuiToolTipProfile";
       };
@@ -77,7 +79,7 @@ $guiContent = new GuiControl(OptionsMenu) {
                vertSizing = "height";
                profile = "GuiDefaultProfile";
                tooltipProfile = "GuiToolTipProfile";
-               class = "MenuList";
+               superClass = "MenuList";
 
                new GuiButtonCtrl() {
                   text = "Display";
@@ -118,6 +120,14 @@ $guiContent = new GuiControl(OptionsMenu) {
                   command = "populateGamepadSettingsList();";
                   tooltipProfile = "GuiToolTipProfile";
                };
+               new GuiButtonCtrl() {
+                  text = "Example Options";
+                  position = "0 225";
+                  extent = "248 35";
+                  profile = "GuiMenuButtonProfile";
+                  command = "testExampleOptions();";
+                  tooltipProfile = "GuiToolTipProfile";
+               };
             };
          };
          new GuiPanel() {
@@ -141,81 +151,76 @@ $guiContent = new GuiControl(OptionsMenu) {
                   padding = "5";
                   changeChildSizeToFit = "0";
                   position = "1 1";
-                  extent = "661 30";
+                  extent = "661 170";
                   horizSizing = "width";
                   vertSizing = "height";
                   profile = "GuiDefaultProfile";
                   tooltipProfile = "GuiToolTipProfile";
-                  class = "MenuList";
+                  superClass = "MenuList";
+                  new GuiGameSettingsCtrl() {
+                     PreviousBitmapAsset = "UI:previousOption_n_image";
+                     NextBitmapAsset = "UI:nextOption_n_image";
+                     columnSplit = "198";
+                     useMouseEvents = "1";
+                     extent = "661 30";
+                     horizSizing = "width";
+                     profile = "GuiMenuButtonProfile";
+                     tooltipProfile = "GuiToolTipProfile";
+                     class = "MenuOptionsButton";
+                  };
+                  new GuiGameSettingsCtrl() {
+                     PreviousBitmapAsset = "UI:previousOption_n_image";
+                     NextBitmapAsset = "UI:nextOption_n_image";
+                     columnSplit = "198";
+                     useMouseEvents = "1";
+                     position = "0 35";
+                     extent = "661 30";
+                     horizSizing = "width";
+                     profile = "GuiMenuButtonProfile";
+                     tooltipProfile = "GuiToolTipProfile";
+                     class = "MenuOptionsButton";
+                  };
+                  new GuiGameSettingsCtrl() {
+                     PreviousBitmapAsset = "UI:previousOption_n_image";
+                     NextBitmapAsset = "UI:nextOption_n_image";
+                     columnSplit = "198";
+                     useMouseEvents = "1";
+                     position = "0 70";
+                     extent = "661 30";
+                     horizSizing = "width";
+                     profile = "GuiMenuButtonProfile";
+                     tooltipProfile = "GuiToolTipProfile";
+                     class = "MenuOptionsButton";
+                  };
+                  new GuiGameSettingsCtrl() {
+                     PreviousBitmapAsset = "UI:previousOption_n_image";
+                     NextBitmapAsset = "UI:nextOption_n_image";
+                     columnSplit = "198";
+                     useMouseEvents = "1";
+                     position = "0 105";
+                     extent = "661 30";
+                     horizSizing = "width";
+                     profile = "GuiMenuButtonProfile";
+                     tooltipProfile = "GuiToolTipProfile";
+                     class = "MenuOptionsButton";
+                  };
+                  new GuiGameSettingsCtrl() {
+                     PreviousBitmapAsset = "UI:previousOption_n_image";
+                     NextBitmapAsset = "UI:nextOption_n_image";
+                     columnSplit = "198";
+                     useMouseEvents = "1";
+                     position = "0 140";
+                     extent = "661 30";
+                     horizSizing = "width";
+                     profile = "GuiMenuButtonProfile";
+                     tooltipProfile = "GuiToolTipProfile";
+                     class = "MenuOptionsButton";
                };
             };
          };
       };
    };
-   new GuiControl(OptionsButtonHolder) {
-      position = "116 711";
-      extent = "791 40";
-      horizSizing = "center";
-      vertSizing = "top";
-      profile = "GuiDefaultProfile";
-      tooltipProfile = "GuiToolTipProfile";
-      isContainer = "1";
-      class = "MenuInputButtonContainer";
 
-      new GuiIconButtonCtrl() {
-         BitmapAsset = "UI:Keyboard_Black_R_image";
-         sizeIconToButton = "1";
-         makeIconSquare = "1";
-         textLocation = "Right";
-         text = "Reset";
-         position = "173 0";
-         extent = "140 40";
-         profile = "GuiMenuButtonProfile";
-         command = "OptionsMenu.resetToDefaults();";
-         tooltipProfile = "GuiToolTipProfile";
-         internalName = "resetButton";
-         class = "MenuInputButton";
-      };
-      new GuiIconButtonCtrl(OptionsMenuSelectButton) {
-         BitmapAsset = "UI:Keyboard_Black_Return_image";
-         sizeIconToButton = "1";
-         makeIconSquare = "1";
-         textLocation = "Right";
-         text = "Select";
-         position = "507 0";
-         extent = "140 40";
-         profile = "GuiMenuButtonProfile";
-         command = "";
-         tooltipProfile = "GuiToolTipProfile";
-         internalName = "SelectButton";
-         class = "MenuInputButton";
-      };
-      new GuiIconButtonCtrl() {
-         BitmapAsset = "UI:Keyboard_Black_Escape_image";
-         sizeIconToButton = "1";
-         makeIconSquare = "1";
-         textLocation = "Right";
-         text = "Back";
-         position = "651 0";
-         extent = "140 40";
-         profile = "GuiMenuButtonProfile";
-         command = "OptionsMenu.backOut();";
-         tooltipProfile = "GuiToolTipProfile";
-         internalName = "backButton";
-         class = "MenuInputButton";
-      };
-   };
-   new GuiInputCtrl(OptionsMenuInputHandler) {
-      sendAxisEvents = "1";
-      sendBreakEvents = "1";
-      ignoreMouseEvents = "1";
-      position = "-50 0";
-      extent = "10 10";
-      horizSizing = "left";
-      vertSizing = "top";
-      profile = "GuiInputCtrlProfile";
-      tooltipProfile = "GuiToolTipProfile";
-      class = "MenuInputHandler";
    };
 };
 //--- OBJECT WRITE END ---
diff --git a/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript b/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
index 40540c1ab..5d04d4588 100644
--- a/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
+++ b/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
@@ -72,16 +72,7 @@ function OptionsMenu::onAdd(%this)
    callOnModules("populateOptionsMenuCategories", "Game");
 }
 
-function OptionsMenuSettingsList::onAdd(%this)
-{
-}
-
-function OptionsMenuSettingsList::getOptionsList(%this, %index)
-{
-     
-}
-
-function OptionsMenu::onWake(%this)
+function OptionsMenu::onOpen(%this)
 {
    OptionsMenuCategoryList.clear(); 
    
@@ -116,22 +107,48 @@ function OptionsMenu::onWake(%this)
    
    %this.unappliedChanges.empty();
    
-   MainMenuButtonList.hidden = true;
-   
    OptionsMenuCategoryList.setAsActiveMenuList();
    
-   OptionsButtonHolder.setActive();
+   $activeMenuButtonContainer-->button1.set("btn_back", "R", "Reset", "OptionsMenu.resetToDefaults();");
+   $activeMenuButtonContainer-->button1.disable();
+   $activeMenuButtonContainer-->button3.set("", "Space", "Apply", "OptionsMenu.apply();");
+   $activeMenuButtonContainer-->button4.set("btn_a", "", "Select", "OptionsMenu.select();");
+   $activeMenuButtonContainer-->button5.set("btn_b", "Escape", "Back", %this @ ".navigation.popPage();");
+}
    
-   OptionsMenuInputHandler.setFirstResponder();
+function OptionsMenu::canClose(%this)
+{
+   if(OptionsMenuSettingsList.isActiveMenuList())
+   {
+   OptionsMenuCategoryList.setAsActiveMenuList();
+      %this.updateSelectButton();
+      return false;
+   }
+   else
+   {
+      if(%this.unappliedChanges.count() != 0)
+      {
+         MessageBoxOKCancel("Discard Changes?", "You have unapplied changes to your settings, do you wish to apply or discard them?", 
+                        "OptionsMenu.apply(); MainMenuGUI.popPage();", "%this.unappliedChanges.empty(); " @ %this @ ".navigation.popPage();", 
+                        "Apply", "Discard");
+         return false;
+      }
+   }
+   
+   return true;
 }
 
-function OptionsButtonHolder::onWake(%this)
+function OptionsMenu::onClose(%this)
 {
-   %this-->resetButton.set("btn_back", "R", "Reset", "OptionsMenu.resetToDefaults();");
-   %this-->selectButton.set("btn_a", "Return", "Select", "OptionsMenu.select();", true);
-   %this-->backButton.set("btn_b", "Escape", "Back", "OptionsMenu.backOut();");
    
-   //OptionsMenuCategoryList.getObject(0).performClick();
+}
+
+function OptionsMenuSettingsList::onAdd(%this)
+{
+}
+   
+function OptionsMenuSettingsList::getOptionsList(%this, %index)
+{
 }
 
 function OptionsMenu::select(%this)
@@ -281,9 +298,6 @@ function OptionsMenu::apply(%this)
    export("$pref::*", %prefPath @ "/clientPrefs." @ $TorqueScriptFileExtension, false);
    
    OptionsMenu.unappliedChanges.empty();
-   
-   //Now we can back out of the options menu
-   OptionsMenu.doOptionsMenuBackOut();
 }
 
 function OptionsMenu::resetToDefaults(%this)
@@ -346,7 +360,9 @@ function populateDisplaySettingsList()
    
    OptionsMenu.currentCategory = "Display";
    
+   if(isObject(OptionName))
    OptionName.setText("");
+   if(isObject(OptionDescription))
    OptionDescription.setText("");
    
    %apiList = "";
@@ -433,7 +449,9 @@ function populateGraphicsSettingsList()
    
    OptionsMenu.currentCategory = "Graphics";
    
+   if(isObject(OptionName))
    OptionName.setText("");
+   if(isObject(OptionDescription))
    OptionDescription.setText("");
    
    %yesNoList = "No\tYes";
@@ -598,7 +616,9 @@ function populateAudioSettingsList()
    
    OptionsMenu.currentCategory = "Audio";
    
+   if(isObject(OptionName))
    OptionName.setText("");
+   if(isObject(OptionDescription))
    OptionDescription.setText("");
    
    %buffer = sfxGetAvailableDevices();
@@ -691,7 +711,9 @@ function populateKeyboardMouseSettingsList()
    
    OptionsMenu.currentCategory = "Keyboard & Mouse";
    
+   if(isObject(OptionName))
    OptionName.setText("");
+   if(isObject(OptionDescription))
    OptionDescription.setText("");
    
    $remapListDevice = "keyboard";
@@ -706,7 +728,9 @@ function populateGamepadSettingsList()
    
    OptionsMenu.currentCategory = "Gamepad";
    
+   if(isObject(OptionName))
    OptionName.setText("");
+   if(isObject(OptionDescription))
    OptionDescription.setText("");
    
    $remapListDevice = "gamepad";
@@ -723,48 +747,6 @@ function OptionsMenuList::activateRow(%this)
    OptionsMenuSettingsList.setFirstResponder();
 }
 
-function OptionsMenu::backOut(%this)
-{
-   if(OptionsMenuSettingsList.isActiveMenuList())
-   {
-      OptionsMenuCategoryList.setAsActiveMenuList();
-      %this.updateSelectButton();
-   }
-   else
-   {
-      if(%this.unappliedChanges.count() != 0)
-      {
-         MessageBoxOKCancel("Discard Changes?", "You have unapplied changes to your settings, do you wish to apply or discard them?", "OptionsMenu.apply();", "OptionsMenu.doOptionsMenuBackOut();", "Apply", "Discard");
-      }
-      else
-      {
-         %this.doOptionsMenuBackOut();
-      }
-   }
-}
-
-function OptionsMenu::doOptionsMenuBackOut(%this)
-{
-   //save the settings and then back out
-   if(OptionsMain.hidden == false)
-   {
-      //we're not in a specific menu, so we're actually exiting
-      Canvas.popDialog(OptionsMenu);
-
-      if(isObject(OptionsMenu.returnGui) && OptionsMenu.returnGui.isMethod("onReturnTo"))
-         OptionsMenu.returnGui.onReturnTo();
-   }
-   else
-   {
-      OptionsMain.hidden = false;
-      ControlsMenu.hidden = true;
-      GraphicsMenu.hidden = true;
-      CameraMenu.hidden = true;
-      AudioMenu.hidden = true;
-      ScreenBrightnessMenu.hidden = true;
-   }
-}
-
 function OptionsMenuSettingsList::setRowEnabled(%this, %row, %status)
 {
    %option = %this.getObject(%row);
@@ -955,16 +937,25 @@ function getDisplayDeviceName()
 //
 function MenuOptionsButton::onMouseEnter(%this)
 {
+   if(isObject(OptionName))
    OptionName.setText(%this.getLabel());
+   if(isObject(OptionDescription))
    OptionDescription.setText(%this.getToolTip());
 }
 
 function MenuOptionsButton::onMouseLeave(%this)
 {
+   if(isObject(OptionName))
    OptionName.setText("");
+   if(isObject(OptionDescription))
    OptionDescription.setText("");
 }
 
+function MenuOptionsButton::onHighlighted(%this, %state)
+{
+   MenuListButton::onHighlighted(%this, %state);
+}
+
 function MenuOptionsButton::onChange(%this)
 {
    %optionMode = %this.getMode();
diff --git a/Templates/BaseGame/game/data/UI/guis/pauseMenu.gui b/Templates/BaseGame/game/data/UI/guis/pauseMenu.gui
index 0ba6e7ce5..f0b9494e7 100644
--- a/Templates/BaseGame/game/data/UI/guis/pauseMenu.gui
+++ b/Templates/BaseGame/game/data/UI/guis/pauseMenu.gui
@@ -1,178 +1,163 @@
 //--- OBJECT WRITE BEGIN ---
 $guiContent = new GuiControl(PauseMenu) {
-   position = "0 0";
    extent = "1024 768";
-   minExtent = "8 2";
-   horizSizing = "right";
-   vertSizing = "bottom";
    profile = "GuiDefaultProfile";
-   visible = "1";
-   active = "1";
    tooltipProfile = "GuiToolTipProfile";
-   hovertime = "1000";
    isContainer = "1";
-   canSave = "1";
+   superClass = "UINavigation";
    canSaveDynamicFields = "1";
-      tamlReader = "19772";
-      tile = "0";
-      useVariable = "0";
 
    new GuiChunkedBitmapCtrl(PauseMenuBG) {
-      bitmapAsset = "UI:hudfill_image";
-      useVariable = "0";
-      tile = "0";
-      position = "0 0";
+      BitmapAsset = "UI:hudfill_image";
       extent = "1024 768";
-      minExtent = "8 2";
       horizSizing = "width";
       vertSizing = "height";
       profile = "GuiDefaultProfile";
-      visible = "1";
-      active = "1";
       tooltipProfile = "GuiToolTipProfile";
-      hovertime = "1000";
       isContainer = "1";
-      canSave = "1";
       canSaveDynamicFields = "1";
    };
    new GuiControl() {
       position = "162 125";
       extent = "700 518";
-      minExtent = "8 2";
       horizSizing = "center";
       vertSizing = "center";
       profile = "GuiDefaultProfile";
-      visible = "1";
-      active = "1";
       tooltipProfile = "GuiToolTipProfile";
-      hovertime = "1000";
       isContainer = "1";
-      canSave = "1";
-      canSaveDynamicFields = "0";
       
       new GuiStackControl(PauseMenuList) {
-         stackingType = "Vertical";
-         horizStacking = "Left to Right";
-         vertStacking = "Top to Bottom";
          padding = "15";
          dynamicSize = "0";
-         dynamicNonStackExtent = "0";
-         dynamicPos = "0";
-         changeChildSizeToFit = "1";
-         changeChildPosition = "1";
-         position = "0 0";
          extent = "700 320";
-         minExtent = "16 16";
          horizSizing = "center";
          vertSizing = "center";
          profile = "GuiDefaultProfile";
-         visible = "1";
-         active = "1";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "1";
-         canSave = "1";
-         canSaveDynamicFields = "0";
-         class = "MenuList";
+         superClass = "MenuList";
+
+         new GuiButtonCtrl() {
+            text = "Options";
+            extent = "700 55";
+            profile = "GuiMenuButtonProfile";
+            command = "openPauseMenuOptions();";
+            tooltipProfile = "GuiToolTipProfile";
+         };
+         new GuiButtonCtrl() {
+            text = "Exit to Menu";
+            position = "0 70";
+            extent = "700 55";
+            profile = "GuiMenuButtonProfile";
+            command = "pauseMenuExitToMenu();";
+            tooltipProfile = "GuiToolTipProfile";
+         };
+         new GuiButtonCtrl() {
+            text = "Exit to Desktop";
+            position = "0 140";
+            extent = "700 55";
+            profile = "GuiMenuButtonProfile";
+            command = "pauseMenuExitToDesktop();";
+            tooltipProfile = "GuiToolTipProfile";
+         };
       };
    };
    new GuiControl(PauseButtonHolder) {
-      position = "189 711";
-      extent = "646 40";
-      minExtent = "8 2";
+      position = "144 711";
+      extent = "736 40";
       horizSizing = "center";
       vertSizing = "top";
       profile = "GuiDefaultProfile";
-      visible = "1";
-      active = "1";
       tooltipProfile = "GuiToolTipProfile";
-      hovertime = "1000";
       isContainer = "1";
       class = "MenuInputButtonContainer";
-      canSave = "1";
-      canSaveDynamicFields = "0";
 
       new GuiIconButtonCtrl() {
-         buttonMargin = "4 4";
-         iconBitmap = "data/ui/images/Inputs/Keyboard & Mouse/Keyboard_Black_Enter";
-         iconLocation = "Left";
+         BitmapAsset = "UI:Keyboard_Black_Return_image";
          sizeIconToButton = "1";
          makeIconSquare = "1";
          textLocation = "Right";
-         textMargin = "4";
-         autoSize = "0";
-         text = "OK";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "363 0";
+         position = "11 0";
          extent = "140 40";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
          profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "PauseMenuList.activateRow();";
+         visible = "0";
+         active = "0";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "goButton";
+         internalName = "button1";
          class = "MenuInputButton";
-         canSave = "1";
-         canSaveDynamicFields = "0";
+         hidden = "1";
       };
       new GuiIconButtonCtrl() {
-         buttonMargin = "4 4";
-         iconBitmap = "data/ui/images/Inputs/Keyboard & Mouse/Keyboard_Black_Esc";
-         iconLocation = "Left";
+         BitmapAsset = "UI:Keyboard_Black_Return_image";
          sizeIconToButton = "1";
          makeIconSquare = "1";
          textLocation = "Right";
-         textMargin = "4";
-         autoSize = "0";
-         text = "Back";
-         groupNum = "-1";
-         buttonType = "PushButton";
-         useMouseEvents = "0";
-         position = "507 0";
+         position = "155 0";
          extent = "140 40";
-         minExtent = "8 2";
-         horizSizing = "right";
-         vertSizing = "bottom";
          profile = "GuiMenuButtonProfile";
-         visible = "1";
-         active = "1";
-         command = "Canvas.popDialog();";
+         visible = "0";
+         active = "0";
          tooltipProfile = "GuiToolTipProfile";
-         hovertime = "1000";
-         isContainer = "0";
-         internalName = "backButton";
+         internalName = "button2";
          class = "MenuInputButton";
-         canSave = "1";
-         canSaveDynamicFields = "0";
+         hidden = "1";
+      };
+      new GuiIconButtonCtrl() {
+         BitmapAsset = "UI:Keyboard_Black_Return_image";
+         sizeIconToButton = "1";
+         makeIconSquare = "1";
+         textLocation = "Right";
+         position = "299 0";
+         extent = "140 40";
+         profile = "GuiMenuButtonProfile";
+         visible = "0";
+         active = "0";
+         tooltipProfile = "GuiToolTipProfile";
+         internalName = "button3";
+         class = "MenuInputButton";
+         hidden = "1";
+      };
+      new GuiIconButtonCtrl() {
+         BitmapAsset = "UI:Keyboard_Black_Return_image";
+         sizeIconToButton = "1";
+         makeIconSquare = "1";
+         textLocation = "Right";
+         position = "443 0";
+         extent = "140 40";
+         profile = "GuiMenuButtonProfile";
+         visible = "0";
+         active = "0";
+         tooltipProfile = "GuiToolTipProfile";
+         internalName = "button4";
+         class = "MenuInputButton";
+         hidden = "1";
+      };
+      new GuiIconButtonCtrl() {
+         BitmapAsset = "UI:Keyboard_Black_Return_image";
+         sizeIconToButton = "1";
+         makeIconSquare = "1";
+         textLocation = "Right";
+         position = "587 0";
+         extent = "140 40";
+         profile = "GuiMenuButtonProfile";
+         visible = "0";
+         active = "0";
+         tooltipProfile = "GuiToolTipProfile";
+         internalName = "button5";
+         class = "MenuInputButton";
+         hidden = "1";
       };
    };
    new GuiInputCtrl(PauseMenuInputHandler) {
-      class = "MenuInputHandler";
       sendAxisEvents = "1";
       sendBreakEvents = "1";
-      sendModifierEvents = "0";
       ignoreMouseEvents = "1";
-      lockMouse = "0";
       position = "-50 0";
       extent = "10 10";
-      minExtent = "8 2";
       horizSizing = "width";
       vertSizing = "height";
       profile = "GuiInputCtrlProfile";
-      visible = "1";
-      active = "1";
       tooltipProfile = "GuiToolTipProfile";
-      hovertime = "1000";
-      isContainer = "0";
-      canSave = "1";
-      canSaveDynamicFields = "0";
+      class = "MenuInputHandler";
    };
 };
 //--- OBJECT WRITE END ---
diff --git a/Templates/BaseGame/game/data/UI/guis/pauseMenu.tscript b/Templates/BaseGame/game/data/UI/guis/pauseMenu.tscript
index 8751c16ef..715690443 100644
--- a/Templates/BaseGame/game/data/UI/guis/pauseMenu.tscript
+++ b/Templates/BaseGame/game/data/UI/guis/pauseMenu.tscript
@@ -23,6 +23,8 @@ function PauseMenu::onWake(%this)
    PauseMenuList.setAsActiveMenuList();
    PauseButtonHolder.setActive();
    PauseMenuInputHandler.setFirstResponder();
+   
+   %this.resizePages = true;
 }
 
 
@@ -35,37 +37,28 @@ function PauseMenu::onSleep(%this)
    }
 }
 
-function PauseMenu::onReturnTo(%this)
-{
-   PauseMenuList.hidden = false;
-   PauseMenuList.setAsActiveMenuList();
-   PauseButtonHolder.setActive();
-   PauseMenuInputHandler.setFirstResponder();
-}
-
 function openPauseMenuOptions()
 {
-   Canvas.pushDialog(OptionsMenu);
-   OptionsMenu.returnGui = PauseMenu; 
-   PauseMenuList.hidden = true;
+   PauseMenu.pushPage(OptionsMenu);
 }
 
 function pauseMenuExitToMenu()
 {
-   PauseMenuList.hidden = true;
-   MessageBoxOKCancel("Exit?", "Do you wish to exit to the Main Menu?", "escapeFromGame();", "PauseMenu.onReturnTo();");
+   MessageBoxOKCancel("Exit?", "Do you wish to exit to the Main Menu?", "escapeFromGame();", "");
 }
 
 function pauseMenuExitToDesktop()
 {
-   PauseMenuList.hidden = true;
-   MessageBoxOKCancel("Exit?", "Do you wish to exit to the desktop?", "quit();", "PauseMenu.onReturnTo();");
+   MessageBoxOKCancel("Exit?", "Do you wish to exit to the desktop?", "quit();", "");
 }
 
 function PauseButtonHolder::onWake(%this)
 {
-   %this-->goButton.set("btn_a", "Return", "OK", "PauseMenuList.activate();", true);
-   %this-->backButton.set("btn_b", "Escape", "Back", "Canvas.popDialog();");
+   %this-->button1.disable();
+   %this-->button2.disable();
+   %this-->button3.disable();
+   %this-->button4.set("btn_a", "", "OK", "PauseMenuList.activate();");
+   %this-->button4.set("btn_b", "Escape", "Back", "Canvas.popDialog();");
 }
 
 function PauseMenu::addPauseMenuButton(%this, %buttonText, %buttonCallback)
diff --git a/Templates/BaseGame/game/data/UI/images/Inputs/Keyboard & Mouse/Keyboard_Black_Mouse_Left.png b/Templates/BaseGame/game/data/UI/images/Inputs/Keyboard & Mouse/Keyboard_Black_Mouse_Left.png
new file mode 100644
index 0000000000000000000000000000000000000000..1b1eb8639a400413ca5fb3fe43b59a0f73358359
GIT binary patch
literal 3184
zcmV-$43G1PP)<h;3K|Lk000e1NJLTq003kF003kN1^@s6aN?Cz000a(Nkl<Zc%1EB
zzjND07XB6>2~nWLACX7lkhC<`*pqR_qOMJfQ<F?er@SI_`VTHQ<J5L)7pE()I^Vdt
zDwEokk|L9<ETu@Hj66<EkE29Gi9aBM1cAMRBup%pBuMUpl)|r(umE=#`|W#g_w6no
zu)qQfEU>@=lYz{-0{uv*(@9;|ce<Cm-M>2kQp}?%LdXt=fKqx0;DSlM0C3p-{{R3C
z!#F%YKd($$XVI7`A^Cj%Z|F4q=BNgi4NB<&I)ojRN~M3!sve;elFQ}(N(k8_gzSc0
z_Bf!F9#Bf3yng-qKVg;|Dk1rN{vjdcQJ7^4!2YXOul^oZVWAL`PN$QJL}DMno~S&x
zx3_V6dWzH2Q%}04X;@lXLZu?kEKo`h4a3+C!`6gCNTE>pHv*8cy}gY@B7v=~E$F(A
zt*tEpK(SclKL7OTQ#^h8)RT7e=1ttZd6WBmkED9N4%@cfzd^{OlpdB!r9X{)a7sjE
z7m&~AA7TI*+uPeH7K`}kqmS_JyYI@b3X;jB=WjpS?KVzNPf;$HxdahHcJlfB!&0gA
zrOY}?B_x~8ZV*B~=iPhw@F70@@I#r!kA+Aif?O_#TrP)ty^h1fL*Fxmkk7N(?2|Wd
z-ux`99*V4t0YFvNJuq_!UDxsW@#Cq<sMqT_IXU5`x7+Qh@=hcYxOeX!R8?hfrMmAV
z4N?ig+sU1a&p!KXpiSsud3hO$L;`DTYgk@h_T4`^I>Lho5AfZ0-}&y9%Vj)&{+z3J
zB9RD|mX;8U#Sn=^K*(SdnoK6Swulh2H?;CoLaI?O6bh70`|7K&kVqulYfaOT$z%|X
zMxkk%uUDR&oWQay_xkAQ2w!~hg?s(ZJMXyvTb6}twd!8qzI_|(>+9|{Aq1<ds~#dK
zrLb)qj^m)&Y{Ir}_g=f*#`oWU?|U!Daduw6etk5$1;&Ro8<NlG|IDV{x^>G#M)x^H
zqfu@irfGV}0N@!_-MxDkw{G3?+<)=n1%CYTM*zT2KmCMcGKr<7B><hqw=4^>Sj>H%
z5Q0dg(+tsQ6t!9nj^hC6NR+PYFbspO+719IgveA`yKDlhsuV>TNCwcc2mLrXIl&J<
z`~U!0Utjl;0dz?3mx^D0`NeaeCAc5`<n+KBktvEI&CMf|5MQOYx3@jly`DP=mzS5G
z>u1lNx&Oca{`&)e*ME<-C8G>J+d+7QP)e^JAv|9dD<M3CJq$-jZ?(j*-}c{YHk+P%
zl={q?2SFr6rXNlUA?b8F31+yvzP|3WADX6(mG6reFQ%^BC=f!RC~uo35{Yo@nayT5
zWRx$3kiIny7p%GhMysq@fgS1Ty3TuMQ%2dcRMsw=(DO^V1&=W3vjj^BE7@J_$|ze3
zA%u`kHjO1@UZn#FY)3X_lr4o2O6ew>#u75FK@St`44!90c<(3zvQ!qk20oENm!Z=7
z4fY_gDvKx0vX-1>sVq-r2N=bX`OJzCz%M17cSv<dlR_b!5MCu&bp_0~$^!fyhP5jI
ze>6EQgcA~^l0kdvF#P)KuM^#y6g(A62=S@rX(5~tUL|FWu#S(9xqd0jvT%HSJazs-
z?1&5(ig0f)rF4hYzpO!@R6_bauhnW5-+uco?%cWKs=v$2OB^2`qtR%%zX@Wico?=;
zA``+1;YkQ<5Q9nxYt)OyqGwU6(P()5TRgCHh)EloH!wkGawv3-UAW5Pi7~6Pf{vcp
z=RW=P)3NK5%jG=RK_!MY;yj}+1G1NJ0r*u`P(qfMmp$sOSS;d$4?YN7ZYGoQNl5?V
z)Hs+_^^FS|gp4%m;~<mCc&;Bjco2w`OeTXnckX!7B9Ta7`xV5WCBqFbW0d7lS-e%f
zapoZDblNlIOe7L`^ym>DKYr|48SFvRG~By)4|nh0^{5#_2;%X0;BpBeK_-X7-S9#Q
z;Y|t$cuE69RaIoOSzpgC7K`}!<BxsMudlCjoq_Rqd~CH7WO69l4KI`s-lT9^LV(Vw
zY-?+4>;)~L)6-X0Rwl9?K@7QQC!<h8WO{j3RpqLvQQ&PYniOHU;f0Rnf>h43ES#O4
zO_cwz9V3I#Znt5Y=0xR9y906(h$dvDZ)X}pCPBO1mfEnQ{aK<_R-m=?s|wyIOSC^L
zl!@VWK^U`j=_NdS_RQUFC>lIJR;5z$?N$^8p6V05awycLna}5+&-yg&Eb!{pD`D*@
zRAv1U$q<c&4Vg0tBP5s04L^l*jlny5F)4%@b>4VfRn@T^dRGChRtv3GOIrTI2%(g2
zvfj~HEGER4HBT@MgGb0NfNw<PFHB|e+$Lcy>Vyf|`;kQw;!{~+Eql%Zc12|*j1Zm+
zLB#&6dBcECCd{8Dvc-Irnsohop26#6BIjQsRn{M7Qpl4MQTu#_5W=g>b(D@Ccv2#2
zpRW)?WNbQ~XYe-LiCPyCLI|%i*I7b%LtjzrB0>m}d2V|iaTO$FlTBMl$Yc;DA)6xd
zx#E~B3Gwxg>ntI>cM~=27c~zNev;@aLd0BTYC?Ex0oPeNdXRPI@cKEMLc#zS%G8=d
z1R=X@0<ZU6WzTQW_YpDDnwk(^ui*6_P1BIe<*t+mSWy(@ayjlWcWxzw*DH9vr_pF2
z9*<*VV`I>Hy}5#}>)6=XKr9yX93t&uZY6}9DW~^1j)Qu=?w<EpTU(P+v=FSVts$Gu
zLRD4X_Z9)jTk8o`fAoKDFO^E6P$<lm3R4sXg+c+T)LYF{E|<ftLzsm%8V!&5Ynp~a
zp)eQ2<X9|*LZRR}6x3)mLO+radiVVO_uoC=#*Id!$mMcKCX+Lf7DZ8zOeTHC+qP|A
z<b^O0`dGBpYT@kc%ySw_RaM-$aRaGT3TJ0$1NF9OtgNhHZEcOaJEmMNU;P6+J@h_A
zJP5T~4T_@R#*G`E^k_7SY&PqLkf>Ix!W$(Li6E6qVP$1y;5MadwK_6{#i)0j6e0*Y
z05drZ(ukEx1&-rzd#I|a$Ye6eWHM+rn`kr|Fbsn`{0xG4JPuvg5s$}*9vro88?{<3
z&<U>rM-%)Z6~=@JLfA-X9vd+XwOS3eS`Eo$5}8bf+ha9NgQjWj$fwb0pxJDW?4gRH
zK-089TUl+}9vC-d*l$=+N_}lHE<_OG>lNefeXUd~sMTsnrBX;HlS6kr#^Z5e`-OX|
z@#5lQY!x)%9S^3h)6|3*hH=R5-?eQUwr!8KmDF(@l*?sYTwFlcb)-_MiO!`5L9^M!
z#l-~-!<fhx^xlt!VHmSlS?A~H6<ya4*zbOrra6&|#Bm%~l_`qi>i&2<KJmU<%d*@#
z(4-{vgLllDQYs`srKnNX*I*3$<>lqnKC6CmfVXxb7K@FPKHIj@YPAB{n{mMg3FzW$
z5qS$C#J26PBaz5Hljb@UMZs|#-)ui@G#ZUT23-gtLZ-%V-n{vlS0Oh3$8`YjohYRT
zq9X2y^i}M$3B6c>*9E<}ha5Z-RfaG^N~O{_-2lHH)a&($zELu7uq<n!bd*XZA*ZJR
z!Olh7w)eo9D3;6RD@}@JS;O4$k3^Ow^vqekUazdKu9}39PuP2=X$t*RQdsDbF(5L}
zeyLRYm&o#jw@$TM{om^9>JA~~J@%eynt_I_^MY2Zh4b@sE*V`_^%v1)O8Z*yu+MC$
zs*07BmAQ=}Vwxsuwc0SB+{=2sz9S=gw6w0Os_K8E(dZ|H5MR_`N-0d!M61=}hN_zt
zOw&ZQT7_X4!-9uhIF9qlZ@>K}B_6IcLQK<ac1d}Ur@nyBu-G(BccM2c9I6aBj)Tj~
zOH?YAfs?)-D5Zy#()+Tad;;OcQ~w75Zq#TNu~-c8cwDNj>A6)*)AWVa8w5(}fngZ;
zWe2$rtvhD3*$q`y_qyS{18pc%Rn;AtMWfNNK7`zlR;vZevRop@T!q|s9OsElspv=O
zApp|pbTW}h>|;RC`%xf-1orw4a+3!ErS!nI?LC>X(|MRpOa^qm9;7JB9y-L#({Y9;
zl+q_6XW!#sW`y*RPN$R0%ggr(A$u}InhrzPSnoTIa}c&fu$Va^{pi}6`v7*k<Vcg8
zu6O!Cq^DK{=86y&UA4B^-Nd}xJzTmuW;QP=r7zKG{Fj7~m$Onw3oNj}0t+l46aNPg
Wlz2ms*;$?d0000<MNUMnLSTaZt`H;u

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/Inputs/Keyboard & Mouse/Keyboard_Black_Mouse_Middle.png b/Templates/BaseGame/game/data/UI/images/Inputs/Keyboard & Mouse/Keyboard_Black_Mouse_Middle.png
new file mode 100644
index 0000000000000000000000000000000000000000..0fd0a2ea7b9d33f2f55544cf661e0b8a88fd228a
GIT binary patch
literal 3089
zcmV+s4DR!ZP)<h;3K|Lk000e1NJLTq003kF003kN1^@s6aN?Cz000ZvNkl<Zc%1EB
zJ#*VQ8h$`hq7~Yvq;-<hNV45*W;ZjQ^L6RYRc6zrz3M!ZA8?!5AK=|zU|)Gf=5pPY
z+ivIWa#ehjnKavE6J|2bdSrc&7WF~m3QJrG1SN_BDA}i{u?bQDhzIZc0xtl*zzQp@
zu)+!}Bm-G=1x8UQ6imY~_6L^-gTMO#^30=oLdZTQfKqw}pw1-M0h|r~KLr5Can3F;
zFB?hgEE)?Xq*AH;4c867JFS6bgHn2mYr;+~%liAG>XAAj<#PG2gpfl*$U)j=&jL#6
zDW&w~$B!TXm1eoA5>lyDjtC*&r&*=|oP7B3;dxqxr9w!dP%zim*G~W(iptY8O}MU$
zPNy@LuIoD1*4EHyh%*b6(lf_#4$`nSsSr}FR{x0@WSFK2RaLRRz8?G?rt|Rr{d>HB
z|9&iOdwUz(+uPjdha}my4bSs}zj4T;l%83Z^{1&1&IwI+0hLPS2oYqMrU}zDaqr$e
ztgWrdu1Y{GkKlg4kMr|$)M_;@L4=U~N~LmSS=J9S>nK%1N~O|{rfFvg4_oo|*I(m{
zFTR*7|5+s@E^OPz+1VNIR=wZv?|=IA>DRdmm;gmq#sHwI>LD01R8_^^-rn3~^!t6-
zwjD~hZ5#c5f3CdO*VnPPw+B^K*<1O+J4u67Lh$?KF2MHocBD-hLen&4G8wF`twGbm
zTD8$=;LV#isMTtrd$n2(uV26BsvS+!u(q~_Y&Hu`(?CeHf-p^!D`|v~!-<uj6H--H
zwOXZY+M`F0#u`~wRp`17MNy!tYN(N#%_e-`53Yw~jOI7`?Ay0*gX=H9{1W%?-w&<{
zA=up994muT3eWT4`#w6I4m{5b?)Ce9yn6L2^j^O2?|=OG@xRksV0K6|>Xl06&up4u
z7@;0-7zPxDFQ~(Y8pWv1I66AQvuDr7?!S2P0zdq4ZFhh9<rkQy84MUGrReo~$Y!&_
z^MsI~PMJ&wtyU{2Q`0mUh5^TM*sARVkV1$|m36=-u&Rm>5=jOC^m@IqYumO1RrL7r
z;}97D@a)+$JbwH*xMqz$n<rZzw!`q$tD-2<+&nS~300bXIgZgB18bZ=fBqc&e{^&d
z`Mc43tSy;l@H3gr*foz3O6kobgy*YbUyf(6Ct<X4tJP}cbEEgznLMQ-vo^6#JVIpp
z;iM2!C=^UE!(Cn1LoYi`LRfHgxp1&*RMRx*x*mG2R4VPrC|?R8BWoG~cs*@aLec_T
zFT*f+&+N)5Tb9Z?U=!Gvnr6@!36_wdPmRHWjIyP)2q9#bO=DkbS)~JrZAW%xlr4o2
zO6e|}#!ASn20cx%lT)4z;k}~>$kG`hXJQhAE<>fo$&;-c&l4?c$yt`l8mla?@hAC_
zhFBCKK)8M!!=4|ECWS)y8}lm3Gm6WsvVd?W;?<Wonw%HH35iq5IMOi<KmGJmqI*ff
zvm=C%kZPV6!U^G3k`;FmBdp`&W3G$6(P-fK_;~L8<Jb`yE)?N<gHpQBN&qYFNhL&8
z)xbUe_U&6ddGZ9$pFc;XQUL&1mWAWvV_23o_M0RSA;n1`oDiObu#FP8kyrz4n&#M|
zlx11??z`_M=E3tYCjoD^j_b*x&^319DvKw^tWl3U(qW$~m&-HPhy6|5&cI4_T7!^O
zd>3pZ#3h7XW;IO{#bPmbxy52JBq5`VQ?no~&w>m>LMki57ZeNZ=;pzL2eC*g7K?cB
z;K5j$rfIP|LmYpW3^%-tQP!Bs;_2R5#9!C-vBuFf4G$ka#NOT>cPOgsI`;PV@bKZo
zv2q9@$mMde%O!-wnH&mt!wV&ZHz}M~_Yy*I=gyr_<Cvy7wt-=Y`}gm2oq@SrZf3O;
zXL2ao4KI`s-lR~3?p0M4o12@7@*;#_V`C$c?TFKvL^~OU62hw-t9z45%&aPB2v+6I
zgEZXmLdSA(D(Cw?T-QyMKf5I;4*LCm;_~L*0ht7%37P8KnTL=h==b|l8&<SGOSH<0
zwU&NU!5d|X_Gc~UqV|#^joG^N63)-hg`Q>_MU=Of-K{7JJk=+9<xn&sA$>Z!+b|6@
z8VzY3AOg#4Ll%9s`8Hr>LzWD}2q~A#e-xG1O#|=fMN$Z}AyErcNoLo}jBdA!ZnrBf
ze_@1BN_SZYU^bhb%k{pDa2$t6$N_+#MdU9`W%1l5%e-AQDcJKPq9Kxysk;?#F%Cp!
zB#aQA3t?Gzx6gx!P9|(FBC^Fol}fsPz0BZsGLiEykt*x|W>UzL5>fkng%HB4%x#p8
zA$U?EYM-wVLS$?@US{w%+lg8i5kd&BGPhYmctc-N>mou3k$G-=8F3RNWS31_Nk}q?
zl8{{y`P^_Um4t+P$8DAn-n)q!_KTW_2tP@56Cq+QGB+W-wSe0!9Ye@Eb9nolO(`M5
zg)+CM5JAWRo51TmH`((W_kBc+wB{y+*DH9vN7r?f%jFy80ag?R<#L%j%w1Xu;q?k$
z?`gN&$mMd_+1ZIYueVe%3<EnmJIH3UXt&#;`%5b!+)O#W$M=2MwhdKPQ7V<NwY4Rq
zXd&3z+Cr&Rf~u;K-{_Jh>8a|E(G6_*d>++mb*WUCq9~|VtH|en*F3yW(MqjDnuWF7
z?J@D!bsg1ebt#6)*=!coYIW?GT)W*){YXOU-SfBKejEEXZYGmKxm<>6nhTK@MNwdy
zX2^JZo`>`E^VI8;`dGBv?c(C%V(fgNs;anq_b&4JJT5LSQu($b0Bme*U~6lOyE~><
ztKIwqJ3~x6>C|eqpePFN-n~1Pp2=iTDwTo|63u2)c%x{VhI~Gcjg5`SZA#5%bLxie
zB&WIJKm;MDU?zug8nMx6!1sM_4^>qa#bOb~ViBEA2kmwnj^l8LpK*}O<zN^Fa=9G$
zDD@DY=b_bV;o{<AYMv2C6SyH2W`PJo*hpw&HewQ5trl9XR`7)eUXRsv9lEXuBcFD=
zjZUXCwTCK-0$tZ*ZDsX5FEVb(q~EZhl!n@3R)`=Z)GKD)``TzU&}y}i&*y_EJ5k8x
za>Dit4^?BmUY}V7MZDwbymgwJ5XW)O*!{bn=fU&5nYNPpzK>e1hI+jY!!VG~=O?O{
zdC=)}P_NhFI8Gv4Fnm82j^iv|WnErgHVnf!WxxC3x^5yDiSPS?DpM3C(EYhwF7dwF
zUauF-fs&Fi3f?JVN~w?lm7+#jKY}srS65ea`>aOE0e-g&*=%;I^m(3#ZnqoD-pq=t
zt1Djek0SCGLWt*iKWdtG!lVTbMN#m5KQ!A<8|`*G%AgA&M99?m)2C0r@+!oO5p~nS
zdnZcisi=rMB7GGnY{D>B;BCP$?jZ-?iz-7HA(mzRJP7bR2HUnLMzy&q==FM$(qUPa
zkkeCuVCSOed57Rk6l=BGjV7hn>rHaQe=o8up=Zu)+iq-bZn}h!Z`gaT>k9o;Qd$_2
z5fPc^#Ime^h%8Td>ol9q|7>n<?h``3V(+=G8*9kAEa-N-xV*gNk}*(Ke-T}#w66tM
zDwWq!yZKaA#m2@)D)DcVz;#`;TCGVwxp%g0@5_iDEv>7ns`~FtCi4v;<PYpUN-12|
zMYr4KhN@c>T-Qaj*@WXblY)oUec%7)^XJb};^9go#C6@yfRwLz>I=9Y7Q3z+O!TIO
zLzMyF_i=S~g+`+hIq4gMQhG)yeJU%;Cy-t|^<x0v#(6fI%_5h}NwqaYw~Fh!p|E;U
zpp>3Ej`LJ@ko(lSW2scyQC0Pj5b`ZzZq6RY$yHSqnM`J;4<V1D+wG#)>jgy2xC(jV
z`~FLrQZb6uLjV*C1#^9U{R9y~@27zf65Hz=<tC2<O6jTRd51D%r}MCwm<+i7dXS<h
zhqxwYnT|8Oq?EoCIs2Xk3nOHRLZM*ZxpU_!A>>eINYhCe80!<?_fON72o?(`WE2BC
z^Ay0rfE;O(Gw@EIiuBZqz)}&yVxZP`2b-7=28T;`XUygurSu)H8~+_4<lUmw(F!Z9
fu)+!}$i)8u_%e2Z&_5U%00000NkvXXu0mjfMG*bX

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/images/Inputs/Keyboard & Mouse/Keyboard_Black_Mouse_Right.png b/Templates/BaseGame/game/data/UI/images/Inputs/Keyboard & Mouse/Keyboard_Black_Mouse_Right.png
new file mode 100644
index 0000000000000000000000000000000000000000..cc24f9272dab2d14addd2e1144fbf005c69b9477
GIT binary patch
literal 3227
zcmV;M3}o|(P)<h;3K|Lk000e1NJLTq003kF003kN1^@s6aN?Cz000bPNkl<Zc%1EB
zJ!~6C7XD_3;)XxcQi^PvAPEr?U?dJ=>$<?rsS;8;>8>zNZK}Hi)F)Rb!0F2Cd`NR;
z>QqdM00#s(IROGhfDFZ=;n)!<k=!Mhq;}^Dku-O9R$P)ZD@x(lNIScnpZ(^&H}B2N
z4lu_YbIdWv9Fu`ubp?j8yu56rQmM_}<yP<SCV&k0Xoe87iA%s3+XryQC7%J<@BLo}
z0L!xWPft&4lh#=_u9T2Mq3{=6y!g_n7pxkLu`(_QD_1I&e_mBRA}1uD&;OYavO@^j
zin{D^z!)nt#-6-*@#5c6mK!M{g+k#|Lda)PmMH;y$H&Kii>k0l2w7fUHqz<z9)KNL
zc^ZZR+qThew>|0EY!=yU7C-#(gRG*!7~8ijYby#{6H{FP0E8vOFbq&ikxr)vfBWeo
zJb(Ti&!0c{q-}3+<MHFi!snkpeF^|LJUoPDSvWjAglU>1$s>eprc$Z$>FMboMzvvD
zC?}*)D13?lG7Q6jVHmi5`!?Qs>n+t)!Gi}6Jb#B_nkK&f`fGgm-FHHQ2qBw=LgCX&
zrSf-`byTXda=F}EEEd~`f7pt5-+dQvzy0=9`HLjv@#DvV5)u}Nhllv&lTSpq&d$%z
zH($Pd`O8!VTmns1#sEMm-2q1ir4;YK|NhiuoS&b=G)-T6Uky!zjg1X_{`u!frBeK@
zOs`GKKvibGw6ydYA*3{%Rw|Wn>(;GHe;13zKq*B$9tQxpuIss9tJU!H&p)GHuls&`
ze0+>@xr~jC4cxhN$8#^4Ou{e>EG#U5QVPd$z!($O;m(~qh{xmj{`>De>4cC{y<S)5
zrzllf#bVLd+7CYX0I}E`(?uzTuItb=4U|$4;;mA>UiT1EtJU!1k3SBshb67s?RrSs
z-QC6Z_V(af(==>sY=F`?{m^k7wA*cTyIoYPRnMr+G);W`@yEV)xvsnU;>C-nqu;>z
zP-fH%g~A{Cv{WkPA)}wBX=2UkIF3&`hHb{Zd-t%uzV5mI?AbH?^wUoOfG@uI0{8FV
zA4rPpx-d=CGisxhBAHAA0Mh9+j*gDd?RE#(>+9=y_Usv7wM_s@2vKQ6w)g~o_(})~
zBm=<U#q?pCCTg_{S0J0s`p5u)_4RdRv)RG*mtTJAx!-6s0?QjFrw`GHOw%-FVIGx)
z_$tj4GORj8I6pu4T)%$(dhq{y@4XlJyWxBM5VqNDURq|~_vz#Q{rkRW7-QFu5K*j(
zCxlmDqtKTQ0KT3)jNyB)UcK_%<5l2gzXik+qB0JrgplRsWdq!BSJ!nP0iz^@hh<q)
z*KHIirC3;47+j~*X^#r*BbUpqsVH9wAwzQ-1Bk*O;}Q}TbY1scZ)|M%o}rYMRFths
zWo_{ZypuJ`pkF2UFph{22-+wEO5O<X3<7>*IjhnE`0a?uu#4I#14;;CjFtE_UP8t-
z=uv`~T#*eCwNXmhDl&y2m^g_+SE15|4R#QCmBoi(fQ#s_v`P&@mCEu|R`l}u5Qzv^
zMTn?uffJhPjV7f+dW%Js<n0GA+bRq2ONporqS55EkWNULN`{e+QTX-OUnjaZDMWUJ
z5aLtK(?U8SqDt}xUB(FO;NZX)>jEy~Uk3*VQ|Hh7A|gAYB7`DcZ!pF-c?sav)1(s8
zpThty!t&pK`z`L?y*n7DHk(Zx92}t4Y7KrPm}ClF)>S|{AtDLk8yB{*ykRvA1J!DE
zaNTOP1`8L0z{jE{9Vmz*%eZh3rOvTSS6L!4<_%)lm%=}n&*#Uk&qp79<hc&Jn1Xi>
zMMhl(B8gq_5)qb=SS;pIZ-!xDWo0FFxep&c^hrq2lA=+#&V=|>)-;XbjqBaJcSDi#
z@Zm%3?(TZhlF4LfKO{_mQAHSDg$?njERj(i#|P1M9o=qsV9aB&81CJ>hgz+MgM$O%
z%EjH?U7_u`efxIkaw(<IG|e-ABAU+4<#KB>mjy|c5Rp?jtpi91K{A>2jm!+g5c&q&
z+uOoPrEE4k_F}v+&Y|ouyi`I&PN9t9Bc&8eOG^{wrD+;UrP4&U<FZ-FK4b?Or4k~l
z9N()Zl^8+@5{bmvzgt;Zk+w`VU^=%XCG#Gn+K@1nb6pp<ZBLZ{sQGXan$0FoPEIB&
zZ`6Va6_8EH$k@&_giL~Fv#IpO%8qBrR#~Cu(yuE--n#5~)@)8{&nTjB4wX+zyn6M@
zvz|&OMEQ=2ZA}Bws(RTohf)_?7Yc>{UG;9-tHAN`v9$LnRb~Ai$&ih?4Vf`WBP5^C
z`@N>$2}D~jCWSPk9yBpEiFZBA=yW>hbUMoNmqrL<ti%TZ<MDW8^9WJFvMdoHTL8Y1
zk-s#RB?_C&@^aBh5q3UhQphA^<Z8tmj4fFiNh3rQLYURn?b9HjlSzwb$$VqJO7*uj
z-z11SnN0snrpo%=IE5l9k+sfO3L&D(+(hZ<LnI}#*7-^yM8%@xS%zrkrL1`oDTIhB
zbCV@RH1w4<FCv8ymHW155!XRNN_^T}LMDSO2`S0Q=bB@tB*fP{ZnA`k+9qq*FUt>+
zzLV%WLWVCgH6fz8fSW8GeTbYx8N>gZ7i@|M0U?yBHH8d9w)g~5@43#A->~hGG18iv
z5K*rX^&VZ<k<aI^RRmbmH01Mn;V^e*B}CLKM7^igY9WzGU~O$};*FS5B9%&EZEX$l
zc-*szw2zsU5Mic*-qZiyA*B?#Tn?+Nt160?g4NYk<Z?MsN&~;qrApEx)gQwv4KtYx
zipAngsW45`P%IXa$-L1#!@GVXsY8^7wOTEY`0KikVzD?A!{m58j$*Os*<09ZwS3=w
zRE@~H=WoCLHrOu+T*QU)`8*86xDsj6G!2Gf_>8yXIKJ;SMuEu3qMc3$CnqPK{ehHH
z+`4rOnM?*JCnu47TM+;j7Z<U*x++{9Q>|7bmkvM?A)|IWH5v_Qn&$iD_`<>ha=9EF
z$3d-DL%m*?{!(JG7&4g*78e%-mnqfj^^q&~C)v#v1~LdKgL4kUyu@0q2G@0kJ(N<4
zm6a8&tgN8jZll#|!Llsj@G}e&i3C!q6cUMqZ~yr)9LGVU(FnB#PSi$1$iCpwu^@vG
z{v<SyjkpYrMgxsTWAKFrQIFMi9lEX$Mn0`p3+;A$WDnIe4Z5y}TFUA;4yx7aSo>H+
zZDfr3-o?0(L5QzcjJx)=R;!`WXdsix3{KezLL!lnwqCfe8qdzo##TWAZ7fe)r>P0C
zENh=%zw0;-9LE`JDXHtas8*{uJ3B)vl|m+yxm3MOgLb=(v$Hc;mNk(r=(mrDWm#9R
zvQAG=YpGPK%zyX8w(W^RB(CcYRGFq}1KpoUBqm;0+wFD-KG38j3`4Ywm@y{hfJ#}T
ztgpZs_GYs=b<Ap*9N>*zh{xk2rO$C3bUK|-_GVlJY_tAKM&42gaUAEXSS+^3r40g#
zvf#R|&)bh0tyU|@pi3b{ifjDx<;!106`J-es9A)lO^mU!tP^)+#wzys1jli16e*@@
z1`X*ylU0T^LMoNYH@yRXJuppE`1R21hHkeTC>@nbMau3eKyq-=ahx3p9K~w2daX(6
z9~c&Z&t#S*b<de;nzf~+C7TfPA%D-dZRomw?Y6n~$p|=JZ?96R{7Yte(%(+KUjOgX
z($Xd&<Q@K=ZQG%Sth0hnr-ReeQz02WRrM#?Why(z@UqWrP)f15xERU#x0ArOZ8RE<
z%VKgzrfF`fI6YcfSEZExXJKLCLqdq}8{LdC*tU&MrvpOB%q$VIZ5#D^9hPMUo&XBq
z%yr!lU%!5><UCwugxI#-?ve72NPPhp!(!XE2aX>9o!%(mx-Oc{CTg`>pwrg}V{D%>
z_DIz!pFl(h+!u?*e*pMvm}lehI1-73Qd`pxtJt>f`^;<*7-MD2vL2~E<UX?Qn9JqX
zD5X1ukiR12;_Uu8x&5Q;VzJmn^X{EaXYlRcPNy^OEaaZ+x=&O}#W14P54cz%o=&It
z5OC=IC=fzIM}33B<YB-VD?5&}qw?%@5h5p~k9<D=K-07xTo5x$+ZmoP#-7OZzQ@6p
z5z@!<^0JXkCLa+(c2pi|dKr4gde3#;a?}#R<H`vcM$gVX0<hI1N15dGqSIxWky;s;
zDMEPk)LN;xh<U5GxwJH9Hb;!HBV4@vBSOg0RjH#n=9puSIp$D_{{tF?n`WG3=->bV
N002ovPDHLkV1n9-G)Vve

literal 0
HcmV?d00001

diff --git a/Templates/BaseGame/game/data/UI/scripts/menuInputHandling.tscript b/Templates/BaseGame/game/data/UI/scripts/menuInputHandling.tscript
index 66d6aaf39..78cefa95c 100644
--- a/Templates/BaseGame/game/data/UI/scripts/menuInputHandling.tscript
+++ b/Templates/BaseGame/game/data/UI/scripts/menuInputHandling.tscript
@@ -54,23 +54,41 @@ function UIMenuButtonList::onAxisEvent(%this, %device, %action, %axisVal)
 /// \param %keyboardButton (string) The button to set for when using keyboard/mouse input.
 /// \param %text (string) The text to display next to the A button graphic.
 /// \param %command (string) The command executed when the A button is pressed.
-/// \param %gamepadOnly (bool) If true, will only show the button when working in the gamepad input mode
-function MenuInputButton::set(%this, %gamepadButton, %keyboardButton, %text, %command, %gamepadOnly)
+function MenuInputButton::set(%this, %gamepadButton, %keyboardButton, %text, %command)
 {
+   %this.setHidden(false);
+   
    %set = (! ((%text $= "") && (%command $= "")));
-   %this.setText(%text);
-   %this.setActive(%set);
-   %this.setVisible(%set);
    
    %this.gamepadButton = %gamepadButton;
    %this.keyboardButton = %keyboardButton;
    
-   if(%gamepadOnly $= "")
-      %gamepadOnly = false;
+   if(%gamepadButton $= "")
+      %this.gamepadValid = false;
+   else
+      %this.gamepadValid = true;
       
-   %this.gamepadOnly = %gamepadOnly;
+   if(%keyboardButton $= "")
+      %this.kbmValid = false;
+   else
+      %this.kbmValid = true;
 
+   if((!%this.kbmValid && $activeControllerType !$= "gamepad") ||
+      (!%this.gamepadValid && $activeControllerType $= "gamepad"))
+      %set = false;
+      
+   %this.setText(%text);
    %this.Command = %command;
+   
+   %this.refresh();
+}
+
+function MenuInputButton::disable(%this)
+{
+   %this.setText("");
+   %this.Command = "";
+   %this.setActive(false);
+   %this.setVisible(false);
 }
 
 /// Refreshes the specific button, updating it's visbility status and the displayed input image
@@ -78,8 +96,10 @@ function MenuInputButton::refresh(%this)
 {
    %set = (! ((%this.text $= "") && (%this.command $= "")));
    
-   //Special-case of where we're in keyboard+mouse mode, but the menubutton is gamepad only mode, so we early out
-   if(%this.gamepadOnly && $activeControllerType !$= "gamepad")
+   //Do a check so if a MenuInput is selectively bound and we're not using the
+   //matched input type, then we skip
+   if((!%this.kbmValid && $activeControllerType !$= "gamepad") ||
+      (!%this.gamepadValid && $activeControllerType $= "gamepad"))
       %set = false;
       
    %this.setActive(%set);
@@ -430,7 +450,7 @@ function MenuList::setAsActiveMenuList(%this, %startPosition, %menuMode)
          
    $activeMenuList = %this;
    $activeMenuList.hidden = false; 
-   $activeMenuListPosition = %startPosition;
+   $activeMenuList.ListPosition = %startPosition;
    $activeMenuListMode = %menuMode;
    
    %this.refresh();
@@ -440,21 +460,21 @@ function MenuList::setAsActiveMenuList(%this, %startPosition, %menuMode)
 function MenuList::activate(%this)
 {
    //check for a highlighted element
-   if($activeMenuListPosition.y > -1 && $activeMenuListPosition < $activeMenuList.getCount())
+   if($activeMenuList.ListPosition.y > -1 && $activeMenuList.ListPosition < $activeMenuList.getCount())
    {
-      %btn = $activeMenuList.getObject($activeMenuListPosition.y);
+      %btn = $activeMenuList.getObject($activeMenuList.ListPosition.y);
       %btn.performClick();
    }
 }
 
 function MenuList::refresh(%this)
 {
-   %selectedObject = 0;
+   %selectedObject = -1;
    for(%i=0; %i < $activeMenuList.getCount(); %i++)
    {
       %btn = $activeMenuList.getObject(%i);
       
-      %isSelected = %i == $activeMenuListPosition.y;
+      %isSelected = %i == $activeMenuList.ListPosition.y;
       
       %btn.setHighlighted(%isSelected);
       
@@ -462,8 +482,32 @@ function MenuList::refresh(%this)
          %selectedObject = %i;
    }
    
+   if(isObject(%this.buttonPointerCtrl))
+   {
+      if(%selectedObject != -1)
+      {
+         %this.buttonPointerCtrl.setHidden(false);
+         
+         %buttonCenter = $activeMenuList.getObject(%selectedObject).getGlobalCenter();
+         
+         if(%this.centerButtonPointerCtrl)
+         {
+            %this.buttonPointerCtrl.setCenter(%buttonCenter.x, %buttonCenter.y);
+         }
+         else
+         {
+            //if we're not centering, then left-justify
+            %this.buttonPointerCtrl.setCenter(%buttonCenter.x - $activeMenuList.getObject(%selectedObject).extent.x / 2, %buttonCenter.y);  
+         }
+      }
+      else
+      {
+         %this.buttonPointerCtrl.setHidden(true);
+      }
+   }
+   
    if($activeMenuList.isMethod("onNavigate"))
-      $activeMenuList.onNavigate($activeMenuListPosition.y);
+      $activeMenuList.onNavigate($activeMenuList.ListPosition.y);
    
    %parent = $activeMenuList.getParent();
    if(%parent.getClassName() $= "GuiScrollCtrl")
@@ -474,18 +518,18 @@ function MenuList::refresh(%this)
 
 function MenuList::navigateUp(%this)
 {
-   $activeMenuListPosition.y -= 1;
-   if($activeMenuListPosition.y < 0)
-      $activeMenuListPosition.y = 0;
+   $activeMenuList.ListPosition.y -= 1;
+   if($activeMenuList.ListPosition.y < 0)
+      $activeMenuList.ListPosition.y = 0;
       
    %this.refresh();
 }
 
 function MenuList::navigateDown(%this)
 {
-   $activeMenuListPosition.y += 1;
-   if($activeMenuListPosition.y >= $activeMenuList.getCount())
-      $activeMenuListPosition.y = $activeMenuList.getCount()-1;
+   $activeMenuList.ListPosition.y += 1;
+   if($activeMenuList.ListPosition.y >= $activeMenuList.getCount())
+      $activeMenuList.ListPosition.y = $activeMenuList.getCount()-1;
       
    %this.refresh();
 }
@@ -496,7 +540,7 @@ function MenuList::navigateLeft()
    //this could readily be expanded upon to handle grids like for inventory screens
    //or the like
     
-   %btn = $activeMenuList.getObject($activeMenuListPosition.y);
+   %btn = $activeMenuList.getObject($activeMenuList.ListPosition.y);
    if(%btn.getClassName() $= "GuiGameSettingsCtrl" && %btn.isEnabled())
    {
       %mode = %btn.getMode();
@@ -522,7 +566,7 @@ function MenuList::navigateLeft()
 
 function MenuList::navigateRight()
 {
-   %btn = $activeMenuList.getObject($activeMenuListPosition.y);
+   %btn = $activeMenuList.getObject($activeMenuList.ListPosition.y);
    if(%btn.getClassName() $= "GuiGameSettingsCtrl" && %btn.isEnabled())
    {
       %mode = %btn.getMode();
@@ -548,5 +592,32 @@ function MenuList::navigateRight()
 
 function MenuList::getActiveRow(%this)
 {
-   return $activeMenuListPosition.y;
+   return $activeMenuList.ListPosition.y;
+}
+
+function MenuListButton::onHighlighted(%this, %state)
+{
+   %parentContainer = %this.getParent();
+   if(%parentContainer.class $= "MenuList" || %parentContainer.superClass $= "MenuList")
+   {
+      if(isObject(%parentContainer.buttonPointerCtrl))
+      {
+         if(%state)
+         {
+	         %parentContainer.buttonPointerCtrl.setHidden(false);
+	         
+	         %buttonCenter = %this.getGlobalCenter();
+	         
+	         if(%parentContainer.centerButtonPointerCtrl)
+	         {
+	               %parentContainer.buttonPointerCtrl.setGlobalCenter(%buttonCenter.x, %buttonCenter.y);
+	         }
+	         else
+	         {
+	            //if we're not centering, then left-justify
+	            %parentContainer.buttonPointerCtrl.setGlobalCenter(%buttonCenter.x - %this.extent.x / 2, %buttonCenter.y);  
+	         }
+	      }
+      }
+   }
 }
\ No newline at end of file
diff --git a/Templates/BaseGame/game/data/UI/scripts/menuNavigation.tscript b/Templates/BaseGame/game/data/UI/scripts/menuNavigation.tscript
new file mode 100644
index 000000000..d10e5847d
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/scripts/menuNavigation.tscript
@@ -0,0 +1,220 @@
+function UINavigation::setRootPage(%this, %rootPage)
+{
+   if(!isObject(%this.pageStack))
+   {
+      %this.pageStack = new ArrayObject();  
+   }
+   
+   if(isObject(%this.rootPage))
+   {
+      %canClose = true;
+      if(%this.rootPage.isMethod("canClose"))
+         %canClose = %this.rootPage.call("canClose");
+         
+      if(!%canClose)
+         return; //if we're not allowed to close, just bail out wholesale because clearly 
+                  //something is blocking changes to pages
+         
+      %this.remove(%this.rootPage);
+      if(%this.rootPage.isMethod("onClose"))
+         %this.rootPage.call("onClose");
+         
+      %this.rootPage.navigation = "";
+   }
+      
+   %this.rootPage = %rootPage;
+   
+   %this.add(%rootPage);
+   if(%this.resizePages)
+   {
+      %rootPage.resize(%this.position.x, %this.position.y, 
+         %this.extent.x, %this.extent.y);
+   }
+   %rootPage.navigation = %this;
+   
+   if(%rootPage.isMethod("onOpen"))
+      %rootPage.call("onOpen");
+}
+
+function UINavigation::pushPage(%this, %newPage, %callback)
+{
+   if(!isObject(%this.pageStack))
+   {
+      %this.pageStack = new ArrayObject();
+   }
+   
+   %canChange = true;
+   if(%newPage.isMethod("canOpen"))
+      %canChange = %newPage.call("canOpen");
+      
+   if(!%canChange)
+      return;
+      
+   %currentPage = %this.getCurrentPage();
+   if(isObject(%currentPage))
+   {
+      if(%currentPage.isMethod("canClose"))
+         %canChange = %currentPage.call("canClose");
+         
+      if(!%canChange)
+         return;
+         
+      if(%currentPage.isMethod("onClose"))
+         %currentPage.call("onClose");
+   }
+   
+   %this.pageStack.push_back(%newPage);
+   %this.add(%newPage);
+   if(%this.resizePages)
+   {
+      %newPage.resize(%this.position.x, %this.position.y, 
+         %this.extent.x, %this.extent.y);
+   }
+   
+   if(%newPage.isMethod("onOpen"))
+      %newPage.call("onOpen");
+   
+   %newPage.navigation = %this;
+   
+   if(%callback !$= "")
+   eval(%callback);
+}
+
+function UINavigation::popPage(%this, %callback)
+{
+   if(%this.pageStack.count() == 0)
+      return;
+      
+   %currentPage = %this.getCurrentPage();
+   if(isObject(%currentPage))
+   {
+      %canChange = true;
+      if(%currentPage.isMethod("canClose"))
+         %canChange = %currentPage.call("canClose");
+         
+      if(!%canChange)
+         return;
+   }
+   
+   %prevPage = %this.getPreviousPage();
+   if(isObject(%prevPage))
+   {
+      %canChange = true;
+      if(%prevPage.isMethod("canOpen"))
+         %canChange = %prevPage.call("canOpen");
+         
+      if(!%canChange)
+         return;
+   }
+      
+   if(isObject(%currentPage))
+   {
+      if(%currentPage.isMethod("onClose"))
+      {
+         %currentPage.call("onClose");
+      }    
+      
+      %this.pageStack.pop_back();
+      %this.remove(%currentPage);
+      
+      %currentPage.navigation = "";
+   }
+   
+   %newTopPage = %this.getCurrentPage();
+   if(%newTopPage.isMethod("onOpen"))
+      %newTopPage.call("onOpen");
+   
+   if(%callback !$= "")
+   eval(%callback);
+}
+
+function UINavigation::popToRoot(%this, %callback)
+{
+   %pageChanged = false;
+   while(%this.getPageCount() != 0)
+   {
+      %currentPage = %this.getCurrentPage();
+      if(isObject(%currentPage))
+      {
+         if(%currentPage.isMethod("canClose"))
+            %canChange = %currentPage.call("canClose");
+            
+         if(!%canChange)
+            return;
+      }
+      
+      %prevPage = %this.getPreviousPage();
+      if(isObject(%prevPage))
+      {
+         if(%prevPage.isMethod("canOpen"))
+            %canChange = %prevPage.call("canOpen");
+            
+         if(!%canChange)
+            return;
+      }
+         
+      if(isObject(%currentPage))
+      {
+         if(%currentPage.isMethod("onClose"))
+         {
+            %currentPage.call("onClose");
+         }    
+
+         %this.pageStack.pop_back();
+         %this.remove(%currentPage);
+         
+         %currentPage.navigation = "";
+      }
+      
+      %newTopPage = %this.getCurrentPage();
+      if(%newTopPage.isMethod("onOpen"))
+         %newTopPage.call("onOpen");
+         
+      %pageChanged = true;
+   }
+   
+   if(%pageChanged && %callback !$= "")
+      eval(%callback);
+}
+
+function UINavigation::getCurrentPage(%this)
+{
+   if(isObject(%this.pageStack) && %this.pageStack.count() != 0)
+   {
+      return %this.pageStack.getKey(%this.pageStack.count()-1);
+   }
+   else
+   {
+      if(isObject(%this.rootPage))
+         return %this.rootPage;
+   }
+   
+   return 0;
+}
+
+function UINavigation::getPreviousPage(%this)
+{
+   if(isObject(%this.pageStack) && %this.pageStack.count() > 1)
+   {
+      return %this.pageStack.getKey(%this.pageStack.count()-2);
+   }
+   else
+   {
+      if(isObject(%this.rootPage))
+         return %this.rootPage;
+   }
+   
+   return 0;
+}   
+
+function UINavigation::getPageCount(%this)
+{
+   %count = 0;
+   if(isObject(%this.pageStack))
+      %count = %this.pageStack.count();
+      
+   if(isObject(%this.rootPage))
+      %count++;
+      
+   return %count;
+}
\ No newline at end of file

From 07b3e2789e31962adc1775f0e11c2b83a8780121 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Mon, 9 May 2022 16:17:22 -0500
Subject: [PATCH 385/399] Adds proper documentation and explains some of the
 navigation/menu usage behavior via the BaseUI example menus

---
 .../game/data/UI/guis/MainMenuButtons.tscript |  51 ++++++++-
 .../game/data/UI/guis/chooseLevelDlg.tscript  |   2 -
 .../game/data/UI/guis/mainMenu.tscript        |  29 ++++-
 .../game/data/UI/guis/optionsMenu.tscript     |  12 ++
 .../data/UI/scripts/menuInputHandling.tscript | 108 +++++++++++++++++-
 .../data/UI/scripts/menuNavigation.tscript    |  63 ++++++++++
 6 files changed, 260 insertions(+), 5 deletions(-)

diff --git a/Templates/BaseGame/game/data/UI/guis/MainMenuButtons.tscript b/Templates/BaseGame/game/data/UI/guis/MainMenuButtons.tscript
index 2dd07c18a..73f38e4f6 100644
--- a/Templates/BaseGame/game/data/UI/guis/MainMenuButtons.tscript
+++ b/Templates/BaseGame/game/data/UI/guis/MainMenuButtons.tscript
@@ -6,19 +6,52 @@ function MainMenuButtons::onSleep(%this)
 {
 }
 
-//Optional, as the check defaults to true, but here as an example case
+//==============================================================================
+// This gets called by the MainMenuGUI beacuse it, being a UINavigation classed control
+// set MainMenuButtonList as it's root page. 
+// This is an optional function, but is called as part of the validation that the page
+// CAN be opened, so it's shown here as an example
 function MainMenuButtonList::canOpen(%this)
 {
    return true;
 }
 
+//==============================================================================
+// This gets called by the MainMenuGUI beacuse it, being a UINavigation classed control
+// set MainMenuButtonList as it's root page. 
+// Once the page is added to the MainMenuGUI's UINavigation page stack, onOpen here is called
+// Which allows us to actually do the work we need to do for display
 function MainMenuButtonList::onOpen(%this)
 {
+   //Here, we set the MainMenuButtonList - a GuiStackControl with the MenuList class
+   // to be the active menu list.
+   // This means that when the MainMenuGUI's MainMenuInputHandler receives an input
+   // or we have one of the buttons in the MainMenuButtonHolder be actioned, we know
+   // we're working/navigating this list of buttons specifically
+   // In practice, it sets the $activeMenuList global variable so the various menu class code
+   // can reference it consistently
    MainMenuButtonList.setAsActiveMenuList();
    
+   //Because MainMenuGUI set it's MainMenuButtonHolder as the active button container, we can reference it
+   //by $activeMenuButtonContainer and set the menu button/accelerator prompts we need for the MainMenuButtonList
+   //specifically.
+   //In particular, being a simple list of buttons, the only one we NEED is a simple activate, so we'll
+   //disable all the other ones to keep them clear in case they were set by other pages at some point
    $activeMenuButtonContainer-->button1.disable();
    $activeMenuButtonContainer-->button2.disable();
    $activeMenuButtonContainer-->button3.disable();
+   
+   //Here we set the 4th button in the container
+   //All the buttons have the MenuInputButton class, which, like the other classes
+   //help keep things accessible and consistent. Here we use that class's set function to
+   //configure the accelerator behavior
+   //The first parameter sets the gamepad button to the 'A' button
+   //The second sets the keyboard button to Enter or Return
+   //Third is what the displayed text will be
+   //And finally we set the command when the button is clicked, or either key inputs are caught by
+   //our MenuInputHandler
+   //The menu buttons automatically detect which input device you're using and swap the display between
+   //gamepad or keyboard for consistent behavior
    $activeMenuButtonContainer-->button4.set("btn_a", "Return", "Go", "MainMenuButtonList.activate();");
    $activeMenuButtonContainer-->button5.disable();
 }
@@ -34,6 +67,7 @@ function MainMenuButtonList::onClose(%this)
 {
 }
 
+//Our actual commands when we activate the buttons
 function openSinglePlayerMenu()
 {
    $pref::HostMultiPlayer=false;
@@ -43,16 +77,31 @@ function openSinglePlayerMenu()
 function openMultiPlayerMenu()
 {
    $pref::HostMultiPlayer=true;
+   
+   //Here, like the other commands, we add a new page onto the stack
+   //In this case, we'll push the ChooseLevelDlg control onto the stack. This will
+   //invoke the canClose() and then onClose() functions for MainMenuButtonList
+   //before calling the onOpen() for ChooseLevelDlg then displaying.
    MainMenuGui.pushPage(ChooseLevelDlg);
 }
 
 function openJoinServerMenu()
 {
+   //Here, like the other commands, we add a new page onto the stack
+   //In this case, we'll push the JoinServerMenu control onto the stack. This will
+   //invoke the canClose() and then onClose() functions for MainMenuButtonList
+   //before calling the onOpen() for JoinServerMenu then displaying.
    MainMenuGui.pushPage(JoinServerMenu);
 }
 
 function openOptionsMenu()
 {
+   //Here, like the other commands, we add a new page onto the stack
+   //In this case, we'll push the OptionsMenu control onto the stack. This will
+   //invoke the canClose() and then onClose() functions for MainMenuButtonList
+   //before calling the onOpen() for OptionsMenu then displaying.
+   //The options menu additionally has an example of why we may want to capitalize on the
+   //canClose() call.
    MainMenuGui.pushPage(OptionsMenu);
 }
 
diff --git a/Templates/BaseGame/game/data/UI/guis/chooseLevelDlg.tscript b/Templates/BaseGame/game/data/UI/guis/chooseLevelDlg.tscript
index d15887f72..11dcec6de 100644
--- a/Templates/BaseGame/game/data/UI/guis/chooseLevelDlg.tscript
+++ b/Templates/BaseGame/game/data/UI/guis/chooseLevelDlg.tscript
@@ -102,8 +102,6 @@ function ChooseLevelDlg::onOpen(%this)
    else
       LevelSelectTitle.setText("CREATE SERVER");
    
-   ChooseLevelButtonHolder.setActive();
-
    $activeMenuButtonContainer-->button1.disable();
    $activeMenuButtonContainer-->button2.disable();
    $activeMenuButtonContainer-->button3.disable();
diff --git a/Templates/BaseGame/game/data/UI/guis/mainMenu.tscript b/Templates/BaseGame/game/data/UI/guis/mainMenu.tscript
index 0fc08009e..bae675ea3 100644
--- a/Templates/BaseGame/game/data/UI/guis/mainMenu.tscript
+++ b/Templates/BaseGame/game/data/UI/guis/mainMenu.tscript
@@ -5,17 +5,44 @@ function MainMenuGui::onAdd(%this)
 
 function MainMenuGui::onWake(%this)
 {
+   //In the BaseUI example case, the MainMenuGUI acts as our background
+   //So it's a logical control to set as our UINavigation as well. So we 
+   //set the MainMenuGUI's superClass to UINavigation to integrate it into
+   //that namespace to open up page navigation
+   
+   //At the same time, the MainMenuGUI control has the button holder, set to
+   //the MenuInputButtonContainer class, allowing us to set it as the active button
+   //holder here, prepping it for catching any button inputs to active commands
+   //Specifically, it sets the $activeMenuButtonContainer to be this, which allows
+   //other controls to manage what the behavior of the buttons is consistently
+   //without needing to worry about hardcoded names
    MainMenuButtonHolder.setActive();
+   
+   //We also have the MainMenuInputHandler, a GuiInputCtrl with the MenuInputHandler class
+   //This allows us to catch any input/axis event and pass it along to the active menuList
+   //or button containers to navigate the menus
+   //We set up this catch by making said control our first responder, here
    MainMenuInputHandler.setFirstResponder();
    
+   //Lastly, we go ahead and display some actual navigable content up on our main menu here
+   //In this case, we set the MainMenuButtonList as our root page, so we always come back
+   //to having the main menu buttons on screen if every other page is closed.
+   //This will ultimately call MainMenuButtonList::onOpen(), so to see where the navigation
+   //chain continues, see that function.
    %this.setRootPage(MainMenuButtonList);
    
+   //We also go ahead and mark for any future pages being added to the UINavigation's page stack
+   //to be prompted to resize when added. This isn't required, but helps keep pages formated to 
+   //the current size of the UINavigation, which is useful when dealing with aspect ratio or resolution
+   //changes.
    %this.resizePages = true;
 }
 
 function MainMenuButtonHolder::onWake(%this)
 {
-   //clean slate
+   //Because the blan slate MainMenuGUI doesn't have anything we need to bother with inputs on
+   //we just go ahead and disable all the buttons in our MainMenuButtonHolder to have
+   // a clean slate
    %this-->button1.disable();
    %this-->button2.disable();
    %this-->button3.disable();
diff --git a/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript b/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
index 5d04d4588..e6e314abd 100644
--- a/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
+++ b/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
@@ -116,8 +116,17 @@ function OptionsMenu::onOpen(%this)
    $activeMenuButtonContainer-->button5.set("btn_b", "Escape", "Back", %this @ ".navigation.popPage();");
 }
    
+//We capitalize on the canClose test here, because we want to prompt for unapplied options changes before
+//backing out. So when the UINavigation test canClose, we can see if we have unapplied settings and prompt
+//that via the message box and return false.
+//This gives the user a chance to choose how they wish to proceed before we allow the 
+//UINavigation to move away from the options menu
 function OptionsMenu::canClose(%this)
 {
+   //Another special case is us catching the 'back/pop' action by just shifting from one
+   //menu list to another. In this case, we check if we were on the settings list as our active MenuList
+   //if so, then the back/pop just moves us to the Category list as our active and we inform the 
+   //UINavigation to not close the page
    if(OptionsMenuSettingsList.isActiveMenuList())
    {
    OptionsMenuCategoryList.setAsActiveMenuList();
@@ -126,6 +135,9 @@ function OptionsMenu::canClose(%this)
    }
    else
    {
+      //Here, we're on the category list as our active, so we're actually trying to leae the page
+      //If we have unapplied changes, we want to prompt about them before closing the page and navigating away
+      //If we don't, then we can process the popPage as normal and let the OptionsMenu close
       if(%this.unappliedChanges.count() != 0)
       {
          MessageBoxOKCancel("Discard Changes?", "You have unapplied changes to your settings, do you wish to apply or discard them?", 
diff --git a/Templates/BaseGame/game/data/UI/scripts/menuInputHandling.tscript b/Templates/BaseGame/game/data/UI/scripts/menuInputHandling.tscript
index 78cefa95c..36f96568f 100644
--- a/Templates/BaseGame/game/data/UI/scripts/menuInputHandling.tscript
+++ b/Templates/BaseGame/game/data/UI/scripts/menuInputHandling.tscript
@@ -26,18 +26,30 @@ btn_start = Start
 btn_back = Back/Select
 */
 
+//==============================================================================
+/// Summary:
 /// This is used with the main UI menu lists, when a non-axis input event is called
 /// such as pressing a button
 /// It is called from the engine
+/// 
+/// \param %device (string) The name of the device the input event is coming fromt
+/// \param %action (string) The specific key/input action
+/// \param %state (bool) The down/up state of the event sent
 function UIMenuButtonList::onInputEvent(%this, %device, %action, %state)
 {
    if(%state)
       $activeMenuButtonContainer.processInputs(%device, %action);
 }
 
+//==============================================================================
+/// Summary:
 /// This is used with the main UI menu lists, when an axis input event is called
 /// such as moving a joystick
 /// It is called from the engine
+/// 
+/// \param %device (string) The name of the device the input event is coming fromt
+/// \param %action (string) The specific key/input action
+/// \param %axisVal (float) The float value of the axis event
 function UIMenuButtonList::onAxisEvent(%this, %device, %action, %axisVal)
 {
    //Skip out of the value is too low as it could just be noise or miscalibrated defaults
@@ -47,6 +59,8 @@ function UIMenuButtonList::onAxisEvent(%this, %device, %action, %axisVal)
    $activeMenuButtonContainer.processAxisEvent(%device, %action);
 }
 
+//==============================================================================
+/// Summary:
 /// Sets the command and text for the specified button. If %text and %command
 /// are left empty, the button will be disabled and hidden.
 ///
@@ -83,6 +97,9 @@ function MenuInputButton::set(%this, %gamepadButton, %keyboardButton, %text, %co
    %this.refresh();
 }
 
+//==============================================================================
+/// Summary:
+/// Disables the MenuInputButton, marking it as not to consume inputs or display
 function MenuInputButton::disable(%this)
 {
    %this.setText("");
@@ -91,6 +108,8 @@ function MenuInputButton::disable(%this)
    %this.setVisible(false);
 }
 
+//==============================================================================
+/// Summary:
 /// Refreshes the specific button, updating it's visbility status and the displayed input image
 function MenuInputButton::refresh(%this)
 {
@@ -203,6 +222,8 @@ function MenuInputButton::refresh(%this)
    return true;
 }
 
+//==============================================================================
+/// Summary:
 /// Refreshes a menu input container, updating the buttons inside it
 function MenuInputButtonContainer::refresh(%this)
 {
@@ -215,6 +236,8 @@ function MenuInputButtonContainer::refresh(%this)
    }
 }
 
+//==============================================================================
+/// Summary:
 /// Sets the given MenuInputButtonContainer as the active one. This directs input events
 /// to it's buttons, ensures it's visible, and auto-hides the old active container if it was set
 function MenuInputButtonContainer::setActive(%this)
@@ -227,6 +250,8 @@ function MenuInputButtonContainer::setActive(%this)
    $activeMenuButtonContainer.refresh();
 }
 
+//==============================================================================
+/// Summary:
 /// Checks the input manager for if we have a gamepad active and gets it's name
 /// If we have one, also sets the active input type to gamepad
 function MenuInputButtonContainer::checkGamepad(%this)
@@ -241,12 +266,17 @@ function MenuInputButtonContainer::checkGamepad(%this)
       $activeControllerType = "gamepad";     
 }
    
+   //==============================================================================
+/// Summary:
 /// This is called by the earlier inputs callback that comes from the menu list
 /// this allows us to first check what the input type is, and if the device is different
 /// (such as going from keyboard and mouse to gamepad) we can refresh the buttons to update
 /// the display
 /// Then we process the input to see if it matches to any of the button maps for our 
 /// MenuInputButtons. If we have a match, we execute it's command.
+///
+/// \param %device (string) The device that is causing the input event
+/// \param %action (string) The name of the input action
 function MenuInputButtonContainer::processInputs(%this, %device, %action)
 {
    //check to see if our status has changed
@@ -305,10 +335,16 @@ function MenuInputButtonContainer::processInputs(%this, %device, %action)
    }
 }
 
+//==============================================================================
+/// Summary:
 /// This is called by the earlier inputs callback that comes from the menu list
 /// this allows us to first check what the input type is, and if the device is different
 /// (such as going from keyboard and mouse to gamepad) we can refresh the buttons to update
 /// the display
+/// 
+/// \param %device (string) The name of the device the input event is coming fromt
+/// \param %action (string) The specific key/input action
+/// \param %axisVal (float) The float value of the axis event
 function MenuInputButtonContainer::processAxisEvent(%this, %device, %action, %axisVal)
 {
    //check to see if our status has changed
@@ -367,6 +403,15 @@ function onSDLDeviceDisconnected(%sdlIndex)
 // This'll let the active menu list be navigated, as well as buttons be processed
 // and ultimately handled by the Input Buttons above
 //==============================================================================
+//==============================================================================
+/// Summary:
+/// This is used with the main UI menu lists, when an axis input event is called
+/// such as moving a joystick
+/// It is called from the engine
+/// 
+/// \param %device (string) The name of the device the input event is coming fromt
+/// \param %action (string) The specific key/input action
+/// \param %axisVal (float) The float value of the axis event
 function MenuInputHandler::onAxisEvent(%this, %device, %action, %value)
 {
    //this is to force a refresh of the menu
@@ -416,6 +461,15 @@ function MenuInputHandler::onAxisEvent(%this, %device, %action, %value)
    } 
 }
 
+//==============================================================================
+/// Summary:
+/// This is used with the main UI menu lists, when a non-axis input event is called
+/// such as pressing a button
+/// It is called from the engine
+/// 
+/// \param %device (string) The name of the device the input event is coming fromt
+/// \param %action (string) The specific key/input action
+/// \param %state (bool) The down/up state of the event sent
 function MenuInputHandler::onInputEvent(%this, %device, %action, %state)
 {
    if(%action $= "upov" || %action $= "dpov" || %action $= "lpov" || %action $= "rpov")
@@ -432,6 +486,10 @@ function MenuInputHandler::onInputEvent(%this, %device, %action, %state)
 // Menu List processing
 // These functions manage the navigation and activation of the Menu Lists
 //==============================================================================
+//==============================================================================
+/// Summary:
+/// Is the GUIContainer with this MenuList namespace the 'active' menulist as far
+/// as UI interfaces is concerned?
 function MenuList::isActiveMenuList(%this)
 {
    if($activeMenuList == %this)
@@ -440,6 +498,14 @@ function MenuList::isActiveMenuList(%this)
    return false;
 }
 
+//==============================================================================
+/// Summary:
+/// Sets the GUIContainer with this MenuList namespace as the active menulist.
+/// This means that any input events caught in MenuInputHandlers is directed at
+/// this menu list to navigate it
+///
+/// \param %startPosition (Point2F) The X and Y starting positions of the selection for this menuList
+/// \param %menuMode (string) Indicates the mode/type of menuList, allowing for special behaviors depending on type
 function MenuList::setAsActiveMenuList(%this, %startPosition, %menuMode)
 {
    if(%startPosition $= "")
@@ -456,7 +522,9 @@ function MenuList::setAsActiveMenuList(%this, %startPosition, %menuMode)
    %this.refresh();
 }
 
-
+//==============================================================================
+/// Summary:
+/// Activates the currently highlighted child object
 function MenuList::activate(%this)
 {
    //check for a highlighted element
@@ -467,6 +535,11 @@ function MenuList::activate(%this)
    }
 }
 
+//==============================================================================
+/// Summary:
+/// refreshes the menuList, updating children highlight status and if there is
+/// a button pointer control defined on our list, we update it's position as 
+/// needed
 function MenuList::refresh(%this)
 {
    %selectedObject = -1;
@@ -516,6 +589,10 @@ function MenuList::refresh(%this)
    }
 }
 
+//==============================================================================
+/// Summary:
+/// Selects the next 'up' child item in the menuList. If the current is the topmost
+/// then nothing happens
 function MenuList::navigateUp(%this)
 {
    $activeMenuList.ListPosition.y -= 1;
@@ -525,6 +602,10 @@ function MenuList::navigateUp(%this)
    %this.refresh();
 }
 
+//==============================================================================
+/// Summary:
+/// Selects the next 'down' child item in the menuList. If the current is the bottommost
+/// then nothing happens
 function MenuList::navigateDown(%this)
 {
    $activeMenuList.ListPosition.y += 1;
@@ -534,6 +615,10 @@ function MenuList::navigateDown(%this)
    %this.refresh();
 }
 
+//==============================================================================
+/// Summary:
+/// Selects the next 'left' child item in the menuList. If the current item is the leftmost
+/// then nothing happens
 function MenuList::navigateLeft()
 {
    //Atm, we're only handling specific control types, namely options entries, but
@@ -564,6 +649,10 @@ function MenuList::navigateLeft()
    }
 }
 
+//==============================================================================
+/// Summary:
+/// Selects the next 'right' child item in the menuList. If the current item is the rightmost
+/// then nothing happens
 function MenuList::navigateRight()
 {
    %btn = $activeMenuList.getObject($activeMenuList.ListPosition.y);
@@ -590,13 +679,24 @@ function MenuList::navigateRight()
    }
 }
 
+//==============================================================================
+/// Summary:
+/// Gets the current vertical positionally selected child object
 function MenuList::getActiveRow(%this)
 {
    return $activeMenuList.ListPosition.y;
 }
 
+//==============================================================================
+/// Summary:
+/// Called from the engine when a GUIButtonBase-derived class with MenuListButton namespace class
+/// has its highlighting status changed. Allows us to react to this change of state and trigger refreshse
+/// or other events to keep the navigation tracking up to date
+///
+/// \param %state (bool) The on/off state of the button being highlighted
 function MenuListButton::onHighlighted(%this, %state)
 {
+   echo("MenuListButton::onHighlighted() - " @ %this.internalName @ " was " @ %state @ " highlighted");
    %parentContainer = %this.getParent();
    if(%parentContainer.class $= "MenuList" || %parentContainer.superClass $= "MenuList")
    {
@@ -607,6 +707,7 @@ function MenuListButton::onHighlighted(%this, %state)
 	         %parentContainer.buttonPointerCtrl.setHidden(false);
 	         
 	         %buttonCenter = %this.getGlobalCenter();
+            echo("   - button center:" @ %buttonCenter);
 	         
 	         if(%parentContainer.centerButtonPointerCtrl)
 	         {
@@ -617,7 +718,12 @@ function MenuListButton::onHighlighted(%this, %state)
 	            //if we're not centering, then left-justify
 	            %parentContainer.buttonPointerCtrl.setGlobalCenter(%buttonCenter.x - %this.extent.x / 2, %buttonCenter.y);  
 	         }
+            echo("   - pointer position:" @ %parentContainer.buttonPointerCtrl.getPosition());
 	      }
+         /*else
+      {
+         %parentContainer.buttonPointerCtrl.setHidden(true);
+         }*/
       }
    }
 }
\ No newline at end of file
diff --git a/Templates/BaseGame/game/data/UI/scripts/menuNavigation.tscript b/Templates/BaseGame/game/data/UI/scripts/menuNavigation.tscript
index d10e5847d..80eeb33a6 100644
--- a/Templates/BaseGame/game/data/UI/scripts/menuNavigation.tscript
+++ b/Templates/BaseGame/game/data/UI/scripts/menuNavigation.tscript
@@ -1,3 +1,12 @@
+//==============================================================================
+/// Summary:
+/// This function sets the root page for the navigation stack. The root page is 'below'
+/// all other normal pages and cannot be popped like a normal page.
+/// When we set a new root page, we first check if we have an existing root page.
+/// If we do, we run the usual canClose() then onClose() function pair, then we 
+/// set it and call the onOpen() for the new root page.
+/// 
+/// \param %rootPage (guiControl) The new guiControl that is being set as the root page of the navigation stack
 function UINavigation::setRootPage(%this, %rootPage)
 {
    if(!isObject(%this.pageStack))
@@ -36,6 +45,25 @@ function UINavigation::setRootPage(%this, %rootPage)
       %rootPage.call("onOpen");
 }
 
+//==============================================================================
+/// Summary:
+/// This function pushes a page onto the given UINavigation-classed GUIContainer's stack
+/// The order of operations is thus:
+/// 1) check to see if the new page being pushed says it can open via the canOpen() function. 
+///    If this method is not defined, it defaults to true, as there's no impediment to continuing
+///    If this check returns false, the pushPage event cancels.
+/// 2) check to see if the current page on the stack says it can close. Similar to 
+///    the canOpen() check on the new page, we default to true
+///    If this check returns false, the pushPage event cancels.
+/// 3) Call - if defined - onClose() on the current top page of the stack
+/// 4) Add the new page onto the stack
+/// 5) Call - if defined - onOpen() on the new page
+/// 6) Finally, if we defined a callback, call that.
+/// With this all run, the previous top page has done any cleanup work it needed to
+/// and the new top page has been opened successfully.
+/// 
+/// \param %newPage (guiControl) The new guiControl that is being added onto the page stack
+/// \param %callback[optional]: (Evaluable string) A evalable statement to invoke when the push has been completed
 function UINavigation::pushPage(%this, %newPage, %callback)
 {
    if(!isObject(%this.pageStack))
@@ -80,6 +108,24 @@ function UINavigation::pushPage(%this, %newPage, %callback)
    eval(%callback);
 }
 
+//==============================================================================
+/// Summary:
+/// This function pops the topmost page off the given UINavigation-classed GUIContainer's stack
+/// The order of operations is thus:
+/// 1) check to see if the top page being popped says it can close via the canClose() function. 
+///    If this method is not defined, it defaults to true, as there's no impediment to continuing
+///    If this check returns false, the popPage event cancels.
+/// 2) check to see if the previous page on the stack says it can open. Similar to 
+///    the canClose() check on the new page, we default to true
+///    If this check returns false, the popPage event cancels.
+/// 3) Call - if defined - onClose() on the current top page of the stack
+/// 4) Remove the top page
+/// 5) Call - if defined - onOpen() on the now topmost page
+/// 6) Finally, if we defined a callback, call that.
+/// With this all run, the previous top page has done any cleanup work it needed to
+/// and the new top page has been opened successfully.
+/// 
+/// \param %callback[optional] (Evaluable string) A evalable statement to invoke when the pop has been completed
 function UINavigation::popPage(%this, %callback)
 {
    if(%this.pageStack.count() == 0)
@@ -128,6 +174,12 @@ function UINavigation::popPage(%this, %callback)
    eval(%callback);
 }
 
+//==============================================================================
+/// Summary:
+/// In order tops the topmost page in a loop until it has closed the entire stack,
+/// leaving only the root page
+/// 
+/// \param %callback[optional] (Evaluable String) A evalable statement to invoke when the pop has been completed
 function UINavigation::popToRoot(%this, %callback)
 {
    %pageChanged = false;
@@ -177,6 +229,10 @@ function UINavigation::popToRoot(%this, %callback)
       eval(%callback);
 }
 
+//==============================================================================
+/// Summary:
+/// Gets the current, topmost page on the stack. If no non-root pages are on the stack
+/// the root page is returned
 function UINavigation::getCurrentPage(%this)
 {
    if(isObject(%this.pageStack) && %this.pageStack.count() != 0)
@@ -192,6 +248,10 @@ function UINavigation::getCurrentPage(%this)
    return 0;
 }
 
+//==============================================================================
+/// Summary:
+/// Gets the page just under the topmost page in the stack. If there is no previous page
+/// then the root page is returned
 function UINavigation::getPreviousPage(%this)
 {
    if(isObject(%this.pageStack) && %this.pageStack.count() > 1)
@@ -207,6 +267,9 @@ function UINavigation::getPreviousPage(%this)
    return 0;
 }   
 
+//==============================================================================
+/// Summary:
+/// Gets the number of pages on the stack.
 function UINavigation::getPageCount(%this)
 {
    %count = 0;

From 5f871763fb40eefca370806b7c3e50912338f2ed Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Mon, 9 May 2022 20:57:42 -0500
Subject: [PATCH 386/399] Adds creator callback integration to pair with the
 base UI module having shortcut creator entries in the GUIEditor for creating
 stuff like the UINavigation containers, or MenuList controls with the
 namespace hooks already established.

---
 Templates/BaseGame/game/data/UI/UI.tscript    |  3 +
 .../game/data/UI/tools/creator.tscript        | 61 +++++++++++++++++++
 .../assetBrowser/scripts/assetBrowser.tscript |  7 +++
 .../assetBrowser/scripts/creator.tscript      | 11 +++-
 4 files changed, 81 insertions(+), 1 deletion(-)
 create mode 100644 Templates/BaseGame/game/data/UI/tools/creator.tscript

diff --git a/Templates/BaseGame/game/data/UI/UI.tscript b/Templates/BaseGame/game/data/UI/UI.tscript
index ee2c111e7..9dae2fe5d 100644
--- a/Templates/BaseGame/game/data/UI/UI.tscript
+++ b/Templates/BaseGame/game/data/UI/UI.tscript
@@ -85,6 +85,9 @@ function UI::initClient(%this)
    %this.queueExec("./scripts/help");
    %this.queueExec("./scripts/cursors");
    %this.queueExec("./scripts/utility");
+   
+   if(isToolBuild())
+      %this.queueExec("./tools/creator.tscript");
 }
 
 function UI::onCreateClientConnection(%this){}
diff --git a/Templates/BaseGame/game/data/UI/tools/creator.tscript b/Templates/BaseGame/game/data/UI/tools/creator.tscript
new file mode 100644
index 000000000..c8322106b
--- /dev/null
+++ b/Templates/BaseGame/game/data/UI/tools/creator.tscript
@@ -0,0 +1,61 @@
+function UI::loadModuleCreatorClasses(%this)
+{
+   AssetBrowser.beginCreatorGroup( "BaseUI", "GuiEditor" );
+      AssetBrowser.addCreatorClass("GuiContainer",  "UINavigation Container", "UINavContainer" );
+      AssetBrowser.addCreatorClass("GuiContainer",  "Menu List", "GUIMenuList" );
+      AssetBrowser.addCreatorClass("GuiStackControl",  "Stack Menu List", "GuiStackMenuList" );
+      AssetBrowser.addCreatorClass("GuiContainer",  "Menu Input Button Handler", "MenuInputBtnHandler" );
+      AssetBrowser.addCreatorClass("GuiIconButtonCtrl",  "Menu Input Button", "MenuInputBtn" );
+   AssetBrowser.endCreatorGroup();
+}
+
+
+function ObjectBuilderGui::buildUINavContainer(%this)
+{
+   %ctrl = new GuiContainer()
+   {
+      superClass = "UINavigation";
+   };
+   
+   return %ctrl;
+}
+
+function ObjectBuilderGui::buildGUIMenuList(%this)
+{
+   %ctrl = new GuiContainer()
+   {
+      superClass = "MenuList";
+   };
+   
+   return %ctrl;
+}
+
+function ObjectBuilderGui::builduiStackMenuList(%this)
+{
+   %ctrl = new GuiStackControl()
+   {
+      superClass = "MenuList";
+   };
+   
+   return %ctrl;
+}
+
+function ObjectBuilderGui::buildMenuInputBtnHandler(%this)
+{
+   %ctrl = new GuiContainer()
+   {
+      class = "MenuInputButtonContainer";
+   };
+   
+   return %ctrl;
+}
+
+function ObjectBuilderGui::buildMenuInputBtn(%this)
+{
+   %ctrl = new GuiIconButtonCtrl()
+   {
+      class = "MenuInputButton";
+   };
+   
+   return %ctrl;
+}
\ No newline at end of file
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
index 0c7270d10..bea15c084 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
@@ -2517,7 +2517,14 @@ function GuiEditor::onControlDropped(%this, %payload, %position)
    else
    {
       %className = %payload.assetName;
+      if(%payload.altCommand !$= "")
+      {
+         %cmd = %payload.altCommand;
+      }
+      else
+      {
       %cmd = "return new " @ %className @ "();";
+      }
       %ctrl = eval( %cmd );
    }
 
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript
index c6b279d35..f4e78daf3 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/creator.tscript
@@ -130,6 +130,8 @@ function AssetBrowser::loadCreatorClasses(%this)
    %this.creatorClassArray.sort(true);
    
    %guiClasses.delete();
+   
+   callOnModules("loadModuleCreatorClasses");
 }
 
 function AssetBrowser::beginCreatorGroup(%this, %group, %editor)
@@ -185,7 +187,14 @@ function AssetBrowser::addCreatorClass(%this, %class, %name, %buildfunc)
       %cmd = "ObjectBuilderGui.build" @ %buildfunc @ "();";
    }
 
-   %buildfunc = "ObjectBuilderGui.newObjectCallback = \"AssetBrowser.onFinishCreateObject\"; ObjectCreator.createObject( \"" @ %cmd @ "\" );";
+   if(GuiEditorIsActive())
+   {
+      %buildfunc = "return " @ %cmd;
+   }
+   else
+   {
+      %buildfunc = "ObjectBuilderGui.newObjectCallback = \"AssetBrowser.onFinishCreateObject\"; ObjectCreator.createObject( \"" @ %cmd @ "\" );";
+   }
    
    %args = new ScriptObject();
    %args.val[0] = %class;

From 8aed00ec4d7efe0fbbc9d48c348acdc9ca6baf88 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Wed, 11 May 2022 00:58:14 -0500
Subject: [PATCH 387/399] Fixed graphical level values to set defaultAnisotropy
 instead of vsync Forced update of cursor position when using keyboard/mouse
 on options menu when changing an option to re-establish focus after refresh
 Updated missed bitmap field on GuiPopupMenuItemBorder to use assetId Made
 folders display before other preview entries in the AB for ease of navigation
 Fixed issue where when re-opening the AB the path would reset, especially
 with select mode Fixed issue when generating previews for materials, terrain
 materials and shapes where the very first time the preview generated it
 wouldn't map correctly Cleaned up some old commented code blocks Added text
 to the Open menubar entry in the GUIEditor to indicate it opens files
 specifically to add clarity

---
 .../rendering/scripts/graphicsOptions.tscript |  10 +-
 .../game/data/UI/guis/optionsMenu.tscript     |   7 +
 .../game/data/UI/scripts/profiles.tscript     |   2 +-
 .../assetBrowser/scripts/assetBrowser.tscript | 123 ++++++------------
 .../scripts/assetTypes/material.tscript       |   2 +-
 .../scripts/assetTypes/shape.tscript          |   6 +-
 .../assetTypes/terrainMaterial.tscript        |   2 +-
 .../scripts/directoryHandling.tscript         |  32 -----
 .../scripts/guiEditorCanvas.ed.tscript        |   2 +-
 9 files changed, 59 insertions(+), 127 deletions(-)

diff --git a/Templates/BaseGame/game/core/rendering/scripts/graphicsOptions.tscript b/Templates/BaseGame/game/core/rendering/scripts/graphicsOptions.tscript
index 9284af583..25c7e19f7 100644
--- a/Templates/BaseGame/game/core/rendering/scripts/graphicsOptions.tscript
+++ b/Templates/BaseGame/game/core/rendering/scripts/graphicsOptions.tscript
@@ -687,7 +687,7 @@ function AutodetectGraphics_Apply(%shaderVer, %intel, %videoMem )
          $pref::PostFX::EnableVignette = false;
          
          $pref::Video::AA = 0;
-         $pref::Video::disableVerticalSync = 0;
+         $pref::Video::defaultAnisotropy = 0;
       }
       else
       {
@@ -713,7 +713,7 @@ function AutodetectGraphics_Apply(%shaderVer, %intel, %videoMem )
          $pref::PostFX::EnableVignette = false;
          
          $pref::Video::AA = 0;
-         $pref::Video::disableVerticalSync = 0;
+         $pref::Video::defaultAnisotropy = 0;
       }
    }   
    else
@@ -743,7 +743,7 @@ function AutodetectGraphics_Apply(%shaderVer, %intel, %videoMem )
          $pref::PostFX::EnableVignette = true;
          
          $pref::Video::AA = 4;
-         $pref::Video::disableVerticalSync = 16;
+         $pref::Video::defaultAnisotropy = 16;
       }
       else if ( %videoMem > 400 || %videoMem == 0 )
       {
@@ -769,7 +769,7 @@ function AutodetectGraphics_Apply(%shaderVer, %intel, %videoMem )
          $pref::PostFX::EnableVignette = true;
          
          $pref::Video::AA = 4;
-         $pref::Video::disableVerticalSync = 4;
+         $pref::Video::defaultAnisotropy = 4;
          
          if ( %videoMem == 0 )
             echo("Torque was unable to detect available video memory. Applying 'Medium' quality.");
@@ -798,7 +798,7 @@ function AutodetectGraphics_Apply(%shaderVer, %intel, %videoMem )
          $pref::PostFX::EnableVignette = false;
          
          $pref::Video::AA = 0;
-         $pref::Video::disableVerticalSync = 0;
+         $pref::Video::defaultAnisotropy = 0;
       }
    }
    
diff --git a/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript b/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
index 40540c1ab..cc4e6912c 100644
--- a/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
+++ b/Templates/BaseGame/game/data/UI/guis/optionsMenu.tscript
@@ -308,6 +308,13 @@ function OptionsMenu::refresh(%this)
       %command = %this.optionsCategories.getValue(%this.currentCategory);
       eval(%command);
    }
+   
+   //now, because we reconstruct the displayed set, we'll force the mouse(if we're using it as our input)
+   //to be poked so we can re-track to whatever control, if any, we're over
+   if($activeControllerType !$= "gamepad")
+   {
+      Canvas.setCursorPos(Canvas.getCursorPos());  
+   }
 }
 
 function OptionsMenu::getOptionVariableValue(%this, %variableName)
diff --git a/Templates/BaseGame/game/data/UI/scripts/profiles.tscript b/Templates/BaseGame/game/data/UI/scripts/profiles.tscript
index 3aae4df2a..92a7720d1 100644
--- a/Templates/BaseGame/game/data/UI/scripts/profiles.tscript
+++ b/Templates/BaseGame/game/data/UI/scripts/profiles.tscript
@@ -348,7 +348,7 @@ new GuiControlProfile( GuiPopupMenuItemBorder : GuiButtonProfile )
    fixedExtent = false;
    justify = "center";
    canKeyFocus = false;
-   bitmap = "data/ui/images/button";
+   bitmapAsset = "UI:menubutton_image";
    category = "Core";
 };
 
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
index 0c7270d10..5ff4d4cf4 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript
@@ -671,10 +671,17 @@ function AssetBrowser::loadDirectories( %this )
       
    if(%this.selectMode)
    {
+      //Due to a fluke in how this tracks, it overrides the current addres, so we'll
+      //store it real fast
+      %curAdd = AssetBrowser.dirHandler.currentAddress;
+      
+      //Disable these for this go
       AssetBrowser-->filterTree.addSelection(AssetBrowser-->filterTree.collectionsIdx);
       AssetBrowser-->filterTree.addSelection(AssetBrowser-->filterTree.creatorIdx);
-      
       AssetBrowser-->filterTree.hideSelection();
+      AssetBrowser-->filterTree.clearSelection();
+      
+      AssetBrowser.dirHandler.currentAddress = %curAdd;
    }
    
    %this.dirHandler.loadFolders("data", %dataItem);
@@ -700,49 +707,6 @@ function AssetBrowser::loadDirectories( %this )
       %this.dirHandler.loadFolders("tools", %toolsItem);
    }
    
-   //Add Non-Asset Scripted Objects. Datablock, etc based
-   /*%category = getWord( %breadcrumbPath, 1 );                  
-   %dataGroup = "DataBlockGroup";
-   
-   if(%dataGroup.getCount() != 0)
-   {
-      %scriptedItem = AssetBrowser-->filterTree.insertItem(1, "Scripted");
-      
-      for ( %i = 0; %i < %dataGroup.getCount(); %i++ )
-      {
-         %obj = %dataGroup.getObject(%i);
-         // echo ("Obj: " @ %obj.getName() @ " - " @ %obj.category );
-         
-         //if ( %obj.category $= "" && %obj.category == 0 )
-         //   continue;
-         
-         %dbFilename = %obj.getFileName();
-         %dbFilePath = filePath(%dbFilename);
-         
-         if(%breadcrumbPath $= %dbFilePath)
-         {
-         
-         //if ( %breadcrumbPath $= "" )
-         //{         
-            %catItem = AssetBrowser-->filterTree.findItemByName(%obj.category);
-            
-            if(%catItem == 0)
-               AssetBrowser-->filterTree.insertItem(%scriptedItem, %obj.category, "scripted");
-            /*%ctrl = %this.findIconCtrl( %obj.category );
-            if ( %ctrl == -1 )
-            {
-               %this.addFolderIcon( %obj.category );
-            }*/
-         //}
-         /*else if ( %breadcrumbPath $= %obj.category )
-         {            
-            AssetBrowser-->filterTree.insertItem(%scriptedItem, %obj.getName());
-         }*/
-         //}
-      //}
-  // }
-   
-   
    AssetBrowser-->filterTree.buildVisibleTree(true);
    
    //Remove any modules that have no assets if we have that filter on
@@ -769,9 +733,6 @@ function AssetBrowser::loadDirectories( %this )
       AssetBrowser.newModuleId = ""; 
    }
    
-   //%dataItem = AssetBrowser-->filterTree.findItemByName("data");
-   //AssetBrowser-->filterTree.expandItem(%dataItem);
-   
    AssetBrowser.dirHandler.expandTreeToAddress(AssetBrowser.dirHandler.currentAddress);
    
    %selectedItem = AssetBrowser.dirHandler.getFolderTreeItemFromAddress(AssetBrowser.dirHandler.currentAddress);
@@ -1476,6 +1437,40 @@ function AssetBrowser::doRebuildAssetArray(%this)
 
    %finalAssetCount = 0;
    
+   //Add folders
+   if(EditorSettings.value("Assets/Browser/showFolders", true) == true)
+   {
+      %folders = getDirectoryList(%breadcrumbPath);
+      for(%f=0; %f < getFieldCount(%folders); %f++)
+      {
+         %folderName = getField(%folders, %f);
+         
+         %searchActive = AssetSearchTerms.count() != 0;
+         if(%searchActive)
+         {
+            if(matchesSearch(%folderName, "Folder", ""))
+            {
+               $AssetBrowser::AssetArray.add( %breadcrumbPath, "Folder" TAB %folderName );
+               continue;
+            }
+         }
+         else
+         {
+            //got it.	
+            if(%folderName $= "shaderCache" || %folderName $= "cache" || %folderName $= ".git")
+               continue;
+               
+            if(!%this.coreModulesFilter && %folderName $= "core" && %breadcrumbPath $= "")
+               continue;
+               
+            if(!%this.toolsModulesFilter && %folderName $= "tools" && %breadcrumbPath $= "")
+               continue;
+               
+            $AssetBrowser::AssetArray.add( %breadcrumbPath, "Folder" TAB %folderName );
+         }
+      }
+   }
+   
     //now, we'll iterate through, and find the assets that are in this module, and this category
     for( %i=0; %i < %numAssetsFound; %i++)
     {
@@ -1544,40 +1539,6 @@ function AssetBrowser::doRebuildAssetArray(%this)
          }
       }
    }
-   
-   //Add folders
-   if(EditorSettings.value("Assets/Browser/showFolders", true) == true)
-   {
-      %folders = getDirectoryList(%breadcrumbPath);
-      for(%f=0; %f < getFieldCount(%folders); %f++)
-      {
-         %folderName = getField(%folders, %f);
-         
-         %searchActive = AssetSearchTerms.count() != 0;
-         if(%searchActive)
-         {
-            if(matchesSearch(%folderName, "Folder", ""))
-            {
-               $AssetBrowser::AssetArray.add( %breadcrumbPath, "Folder" TAB %folderName );
-               continue;
-            }
-         }
-         else
-         {
-            //got it.	
-            if(%folderName $= "shaderCache" || %folderName $= "cache" || %folderName $= ".git")
-               continue;
-               
-            if(!%this.coreModulesFilter && %folderName $= "core" && %breadcrumbPath $= "")
-               continue;
-               
-            if(!%this.toolsModulesFilter && %folderName $= "tools" && %breadcrumbPath $= "")
-               continue;
-               
-            $AssetBrowser::AssetArray.add( %breadcrumbPath, "Folder" TAB %folderName );
-         }
-      }
-   }
 
    //Add Non-Asset Scripted Objects. Datablock, etc based
    %hasDBFilter = true;
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
index 12c6d4e3d..bc7a34cb6 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/material.tscript
@@ -530,7 +530,7 @@ function AssetBrowser::generateMaterialAssetPreviewImage(%this, %previewButton,
          }
       }
       
-         %previewButton.bitmapAsset = %previewAssetName;
+         %previewButton.bitmapAsset = "ToolsModule:" @ %previewAssetName;
          return true;
    }
    }
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
index 4195cf1b9..c39710f9c 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/shape.tscript
@@ -361,13 +361,9 @@ function AssetBrowser::generateShapeAssetPreviewImage(%this, %previewButton, %fo
          {
             return false; //failed to register the preview image for some reason?
    }
-   }
-   else
-   {
-         %previewAssetName = "ToolsModule:" @ %previewAssetName;
    }
    
-      %previewButton.bitmapAsset = %previewAssetName;
+      %previewButton.bitmapAsset = "ToolsModule:" @ %previewAssetName;
       return true;
    }
    else
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrainMaterial.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrainMaterial.tscript
index ded898e9f..d9ded4ef3 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrainMaterial.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/assetTypes/terrainMaterial.tscript
@@ -201,7 +201,7 @@ function AssetBrowser::generateTerrainMaterialAssetPreviewImage(%this, %previewB
          }
       }
       
-         %previewButton.bitmapAsset = %previewAssetName;
+         %previewButton.bitmapAsset = "ToolsModule:" @ %previewAssetName;
          return true;
    }
    }
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/directoryHandling.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/directoryHandling.tscript
index 329e2763f..0df04615a 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/directoryHandling.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/directoryHandling.tscript
@@ -91,38 +91,6 @@ function directoryHandler::navigateTo(%this, %address, %historyNav, %selectionNa
    
    //break down the address
    %folderCount = getTokenCount(%address, "/");
-      
-   /*%rebuiltPath = "";
-   for(%f=0; %f < %folderCount; %f++)
-   {
-      %folderName = getToken(%address, "/", %f);
-      
-      %rebuiltPath = %f == 0 ? %folderName : %rebuiltPath @ "/" @ %folderName;
-      
-      %folderNavButton = new GuiButtonCtrl()
-      {
-         profile = ToolsGuiButtonProfile;
-         text = %folderName;
-         command = "AssetBrowser.navigateTo(\"" @ %rebuiltPath @ "\");";
-         extent = "100" SPC AssetBrowser_BreadcrumbBar.extent.y;
-      };
-      
-      AssetBrowser_BreadcrumbBar.add(%folderNavButton);
-      
-      if(%f != %folderCount-1)
-      {
-         %folderSpacerButton = new GuiBitmapButtonCtrl()
-         {
-            profile = ToolsGuiButtonProfile;
-            bitmapAsset = "ToolsModule:rightArrowWhite_image";
-            bitmapMode = "Centered";
-            extent = "25" SPC AssetBrowser_BreadcrumbBar.extent.y;
-            //command = "AssetBrowser.navigateTo(\"" @ %rebuiltPath @ "\");";
-         };
-         
-         AssetBrowser_BreadcrumbBar.add(%folderSpacerButton);
-      }
-   }*/
 
    //find our folder tree and action on it tree
    %folderId = %this.getFolderTreeItemFromAddress(%address);
diff --git a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorCanvas.ed.tscript b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorCanvas.ed.tscript
index f7c373ed7..2235ab5a3 100644
--- a/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorCanvas.ed.tscript
+++ b/Templates/BaseGame/game/tools/guiEditor/scripts/guiEditorCanvas.ed.tscript
@@ -81,7 +81,7 @@ function GuiEditCanvas::onCreateMenu(%this)
          internalName = "FileMenu";
          
          item[0] = "New Gui..." TAB %cmdCtrl SPC "N" TAB %this @ ".create();";
-         item[1] = "Open..." TAB %cmdCtrl SPC "O" TAB %this @ ".open();";
+         item[1] = "Open GUI File..." TAB %cmdCtrl SPC "O" TAB %this @ ".open();";
          item[2] = "Save" TAB %cmdCtrl SPC "S" TAB %this @ ".save( false, true );";
          item[3] = "Save As..." TAB %cmdCtrl @ "-Shift S" TAB %this @ ".save( false );";
          item[4] = "Save Selected As..." TAB %cmdCtrl @ "-Alt S" TAB %this @ ".save( true );";

From ff0e4181323e5e7914698f3dca463c9fad6baa13 Mon Sep 17 00:00:00 2001
From: AzaezelX <quillus@hotmail.com>
Date: Mon, 16 May 2022 19:22:25 -0500
Subject: [PATCH 388/399] fix sDefaultAmbience intialization. we don't want to
 spool that up before the SFX subsystem has kicked in

---
 Engine/source/T3D/levelInfo.cpp |  6 +++---
 Engine/source/sfx/sfxSystem.cpp | 20 ++++++++++++--------
 2 files changed, 15 insertions(+), 11 deletions(-)

diff --git a/Engine/source/T3D/levelInfo.cpp b/Engine/source/T3D/levelInfo.cpp
index d10077cea..8edb6993f 100644
--- a/Engine/source/T3D/levelInfo.cpp
+++ b/Engine/source/T3D/levelInfo.cpp
@@ -73,7 +73,7 @@ extern F32 gDecalBias;
 extern GFXTexHandle gLevelAccuMap;
 
 /// Default SFXAmbience used to reset the global soundscape.
-static SFXAmbience sDefaultAmbience;
+extern SFXAmbience* sDefaultAmbience;
 
 
 //-----------------------------------------------------------------------------
@@ -256,7 +256,7 @@ void LevelInfo::unpackUpdate(NetConnection *conn, BitStream *stream)
          if( mSoundAmbience )
             mSoundscape->setAmbience( mSoundAmbience );
          else
-            mSoundscape->setAmbience( &sDefaultAmbience );
+            mSoundscape->setAmbience( sDefaultAmbience );
       }
 
       SFX->setDistanceModel( mSoundDistanceModel );
@@ -302,7 +302,7 @@ bool LevelInfo::onAdd()
 void LevelInfo::onRemove()
 {
    if( mSoundscape )
-      mSoundscape->setAmbience( &sDefaultAmbience );
+      mSoundscape->setAmbience( sDefaultAmbience );
 
    Parent::onRemove();
 }
diff --git a/Engine/source/sfx/sfxSystem.cpp b/Engine/source/sfx/sfxSystem.cpp
index d23880bfd..9c864842f 100644
--- a/Engine/source/sfx/sfxSystem.cpp
+++ b/Engine/source/sfx/sfxSystem.cpp
@@ -69,6 +69,8 @@ MODULE_END;
 
 SFXSystem* SFXSystem::smSingleton = NULL;
 
+/// Default SFXAmbience used to reset the global soundscape.
+SFXAmbience *sDefaultAmbience;
 
 // Excludes Null and Blocked as these are not passed out to the control layer.
 ImplementEnumType( SFXStatus,
@@ -364,7 +366,8 @@ void SFXSystem::init()
    // register them in the provider initialization.
 
    // Create the system.
-   smSingleton = new SFXSystem();   
+   smSingleton = new SFXSystem();
+   sDefaultAmbience = new SFXAmbience();
 }
 
 //-----------------------------------------------------------------------------
@@ -384,6 +387,7 @@ void SFXSystem::destroy()
    // Destroy the stream thread pool
 
    SFXInternal::SFXThreadPool::deleteSingleton();
+   delete(sDefaultAmbience);
 }
 
 //-----------------------------------------------------------------------------
@@ -1617,10 +1621,10 @@ DefineEngineFunction( sfxPlayOnce, S32, (StringTableEntry assetId, const char* a
 {
    SFXDescription* description = NULL;
    if (assetId == StringTable->EmptyString())
-      {
-         Con::errorf( "sfxPlayOnce - Must Define a sound asset");
-         return 0;
-      }
+   {
+      Con::errorf( "sfxPlayOnce - Must Define a sound asset");
+      return 0;
+   }
 
    SFXSource* source = NULL;
 
@@ -1639,10 +1643,10 @@ DefineEngineFunction( sfxPlayOnce, S32, (StringTableEntry assetId, const char* a
          MatrixF transform;
          transform.set(EulerF(0, 0, 0), Point3F(dAtof(arg0), dAtof(arg1), dAtof(arg2)));
          source = SFX->playOnce(tempSoundAsset->getSfxProfile(), &transform, NULL, dAtof(arg3));
-   }
       }
-      else
-      {
+   }
+   else
+   {
       Con::errorf("sfxPlayOnce - Could not locate assetId '%s'", assetId);
       return 0;
    }

From eab544c8f3e19bfd4d0558fb804bf372bf8c91e4 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Sat, 21 May 2022 20:25:30 -0400
Subject: [PATCH 389/399] * Adjustment: Update libsdl to address a bug in
 compilation on MacOS devices.

---
 Engine/lib/sdl/Android.mk                     |    0
 Engine/lib/sdl/CMakeLists.txt                 |   92 +-
 Engine/lib/sdl/Makefile.os2                   |    9 +-
 Engine/lib/sdl/Makefile.w32                   |  222 ++++
 Engine/lib/sdl/VisualC/clean.sh               |    0
 Engine/lib/sdl/WhatsNew.txt                   |   25 +
 Engine/lib/sdl/Xcode/SDL/Info-Framework.plist |    4 +-
 .../Xcode/SDL/SDL.xcodeproj/project.pbxproj   |   73 +-
 .../SDLTest/SDLTest.xcodeproj/project.pbxproj |    6 +-
 .../sdl/Xcode/SDLTest/TestDropFile-Info.plist |    2 +-
 .../android-project-ant/AndroidManifest.xml   |    0
 Engine/lib/sdl/android-project-ant/src        |    0
 Engine/lib/sdl/android-project/gradlew        |    0
 Engine/lib/sdl/autogen.sh                     |    8 +-
 .../lib/sdl/build-scripts/androidbuildlibs.sh |   37 +-
 Engine/lib/sdl/build-scripts/clang++-fat.sh   |    6 +-
 Engine/lib/sdl/build-scripts/clang-fat.sh     |    8 +-
 .../sdl/build-scripts/codechecker-buildbot.sh |    0
 Engine/lib/sdl/build-scripts/config.guess     |   30 +-
 Engine/lib/sdl/build-scripts/config.sub       |    0
 Engine/lib/sdl/build-scripts/fnsince.pl       |   12 +-
 .../gen_audio_resampler_filter.c              |  162 +++
 .../sdl/build-scripts/git-pre-push-hook.pl    |    0
 Engine/lib/sdl/build-scripts/ltmain.sh        |    0
 .../lib/sdl/build-scripts/update-copyright.sh |    9 +-
 Engine/lib/sdl/build-scripts/wikiheaders.pl   |    0
 Engine/lib/sdl/build-scripts/winrtbuild.ps1   |    2 +-
 Engine/lib/sdl/cmake/sdlchecks.cmake          |   25 +-
 Engine/lib/sdl/configure                      |  271 ++---
 Engine/lib/sdl/configure.ac                   |  130 +-
 Engine/lib/sdl/docs/README-linux.md           |   17 +-
 Engine/lib/sdl/docs/README-macos.md           |   11 +-
 Engine/lib/sdl/docs/README-ngage.md           |   44 +
 Engine/lib/sdl/docs/README-raspberrypi.md     |    2 +-
 Engine/lib/sdl/docs/README-versions.md        |   60 +
 Engine/lib/sdl/docs/README.md                 |    2 +
 Engine/lib/sdl/docs/doxyfile                  |    1 +
 Engine/lib/sdl/docs/release_checklist.md      |   91 ++
 Engine/lib/sdl/include/SDL_assert.h           |    4 +-
 Engine/lib/sdl/include/SDL_config.h           |    2 +
 Engine/lib/sdl/include/SDL_config.h.cmake     |    6 +-
 Engine/lib/sdl/include/SDL_config.h.in        |    6 +-
 Engine/lib/sdl/include/SDL_config_android.h   |    1 +
 .../lib/sdl/include/SDL_config_emscripten.h   |    1 +
 Engine/lib/sdl/include/SDL_config_iphoneos.h  |    3 +-
 Engine/lib/sdl/include/SDL_config_macosx.h    |    8 +-
 Engine/lib/sdl/include/SDL_config_ngage.h     |   89 ++
 Engine/lib/sdl/include/SDL_config_os2.h       |    7 +-
 Engine/lib/sdl/include/SDL_config_pandora.h   |    1 +
 Engine/lib/sdl/include/SDL_config_windows.h   |   60 +-
 Engine/lib/sdl/include/SDL_config_winrt.h     |    6 +-
 Engine/lib/sdl/include/SDL_cpuinfo.h          |    4 +-
 Engine/lib/sdl/include/SDL_endian.h           |   22 +
 Engine/lib/sdl/include/SDL_events.h           |   12 +
 Engine/lib/sdl/include/SDL_gamecontroller.h   |   36 +
 Engine/lib/sdl/include/SDL_hints.h            |   53 +-
 Engine/lib/sdl/include/SDL_joystick.h         |   79 ++
 Engine/lib/sdl/include/SDL_keycode.h          |    7 +-
 Engine/lib/sdl/include/SDL_log.h              |    4 +-
 Engine/lib/sdl/include/SDL_platform.h         |   14 +-
 Engine/lib/sdl/include/SDL_rect.h             |    8 +-
 Engine/lib/sdl/include/SDL_render.h           |   10 +-
 Engine/lib/sdl/include/SDL_rwops.h            |   14 -
 Engine/lib/sdl/include/SDL_scancode.h         |   20 +
 Engine/lib/sdl/include/SDL_stdinc.h           |   68 +-
 Engine/lib/sdl/include/SDL_system.h           |    2 +-
 Engine/lib/sdl/include/SDL_thread.h           |    2 +-
 Engine/lib/sdl/include/SDL_version.h          |   22 +-
 Engine/lib/sdl/src/SDL.c                      |   28 +-
 Engine/lib/sdl/src/SDL_assert.c               |   67 +-
 Engine/lib/sdl/src/SDL_hints.c                |    1 +
 Engine/lib/sdl/src/SDL_internal.h             |    3 +-
 Engine/lib/sdl/src/SDL_log.c                  |   90 +-
 Engine/lib/sdl/src/SDL_log_c.h                |   33 +
 Engine/lib/sdl/src/audio/SDL_audio.c          |    2 -
 Engine/lib/sdl/src/audio/SDL_audio_c.h        |    5 -
 .../src/audio/SDL_audio_resampler_filter.h    | 1062 +++++++++++++++++
 Engine/lib/sdl/src/audio/SDL_audiocvt.c       |  133 +--
 .../sdl/src/audio/coreaudio/SDL_coreaudio.m   |   12 +-
 .../audio/emscripten/SDL_emscriptenaudio.c    |    5 +
 .../lib/sdl/src/audio/haiku/SDL_haikuaudio.cc |   45 +-
 Engine/lib/sdl/src/audio/nacl/SDL_naclaudio.c |   47 +-
 Engine/lib/sdl/src/audio/nacl/SDL_naclaudio.h |    3 +-
 .../sdl/src/audio/netbsd/SDL_netbsdaudio.c    |    4 +-
 .../lib/sdl/src/audio/pipewire/SDL_pipewire.c |    7 +-
 .../sdl/src/audio/pulseaudio/SDL_pulseaudio.c |   93 +-
 .../sdl/src/audio/pulseaudio/SDL_pulseaudio.h |    6 +-
 .../sdl/src/audio/wasapi/SDL_wasapi_win32.c   |    2 +-
 Engine/lib/sdl/src/core/linux/SDL_dbus.c      |    1 +
 Engine/lib/sdl/src/core/windows/SDL_hid.c     |    8 +-
 Engine/lib/sdl/src/core/windows/SDL_hid.h     |    4 -
 Engine/lib/sdl/src/core/windows/SDL_windows.h |    2 +
 Engine/lib/sdl/src/core/windows/SDL_xinput.c  |    3 -
 Engine/lib/sdl/src/core/windows/SDL_xinput.h  |   84 +-
 Engine/lib/sdl/src/cpuinfo/SDL_cpuinfo.c      |   30 +-
 Engine/lib/sdl/src/dynapi/SDL2.exports        |  843 +++++++++++++
 Engine/lib/sdl/src/dynapi/SDL_dynapi.h        |    2 +
 .../lib/sdl/src/dynapi/SDL_dynapi_overrides.h |   10 +-
 Engine/lib/sdl/src/dynapi/SDL_dynapi_procs.h  |   12 +-
 Engine/lib/sdl/src/dynapi/gendynapi.pl        |    4 +
 Engine/lib/sdl/src/events/SDL_events.c        |   21 +-
 Engine/lib/sdl/src/events/SDL_keyboard.c      |    8 +
 Engine/lib/sdl/src/events/SDL_mouse.c         |   72 +-
 Engine/lib/sdl/src/events/SDL_mouse_c.h       |    3 +
 Engine/lib/sdl/src/events/scancodes_darwin.h  |    4 +-
 Engine/lib/sdl/src/events/scancodes_linux.h   |    4 +-
 Engine/lib/sdl/src/events/scancodes_windows.h |    4 +-
 Engine/lib/sdl/src/events/scancodes_xfree86.h |    4 +-
 Engine/lib/sdl/src/file/SDL_rwops.c           |  243 ----
 .../src/filesystem/psp/SDL_sysfilesystem.c    |   58 +-
 Engine/lib/sdl/src/hidapi/bootstrap           |    0
 .../sdl/src/hidapi/testgui/copy_to_bundle.sh  |    0
 Engine/lib/sdl/src/hidapi/testgui/start.sh    |    0
 Engine/lib/sdl/src/hidapi/windows/hid.c       |   32 +-
 .../lib/sdl/src/joystick/SDL_gamecontroller.c |   51 +-
 .../sdl/src/joystick/SDL_gamecontrollerdb.h   |    6 +-
 Engine/lib/sdl/src/joystick/SDL_joystick.c    |   96 +-
 Engine/lib/sdl/src/joystick/SDL_joystick_c.h  |    5 +
 Engine/lib/sdl/src/joystick/SDL_sysjoystick.h |    5 +
 .../src/joystick/android/SDL_sysjoystick.c    |    7 +
 .../sdl/src/joystick/bsd/SDL_bsdjoystick.c    |   11 +-
 Engine/lib/sdl/src/joystick/check_8bitdo.sh   |    0
 .../src/joystick/darwin/SDL_iokitjoystick.c   |    8 +-
 .../sdl/src/joystick/dummy/SDL_sysjoystick.c  |    7 +
 .../src/joystick/emscripten/SDL_sysjoystick.c |    7 +
 .../src/joystick/haiku/SDL_haikujoystick.cc   |   17 +-
 .../sdl/src/joystick/hidapi/SDL_hidapi_luna.c |    8 +-
 .../sdl/src/joystick/hidapi/SDL_hidapi_ps4.c  |   10 +-
 .../src/joystick/hidapi/SDL_hidapi_rumble.c   |    2 +-
 .../src/joystick/hidapi/SDL_hidapi_switch.c   |  130 +-
 .../src/joystick/hidapi/SDL_hidapi_xbox360w.c |    8 +-
 .../src/joystick/hidapi/SDL_hidapijoystick.c  |   24 +-
 .../src/joystick/iphoneos/SDL_mfijoystick.m   |   59 +-
 .../sdl/src/joystick/linux/SDL_sysjoystick.c  |  433 +++++--
 .../src/joystick/linux/SDL_sysjoystick_c.h    |    6 +
 .../sdl/src/joystick/os2/SDL_os2joystick.c    |    9 +-
 .../sdl/src/joystick/psp/SDL_sysjoystick.c    |    8 +-
 .../joystick/virtual/SDL_virtualjoystick.c    |  447 ++++++-
 .../joystick/virtual/SDL_virtualjoystick_c.h  |   18 +-
 .../sdl/src/joystick/vita/SDL_sysjoystick.c   |    9 +-
 .../src/joystick/windows/SDL_dinputjoystick.c |    6 +-
 .../joystick/windows/SDL_rawinputjoystick.c   |   59 +-
 .../windows/SDL_windows_gaming_input.c        |    7 +
 .../joystick/windows/SDL_windowsjoystick.c    |   16 +-
 .../joystick/windows/SDL_windowsjoystick_c.h  |    2 +-
 .../src/joystick/windows/SDL_xinputjoystick.c |    1 +
 Engine/lib/sdl/src/libm/math_private.h        |    3 +-
 .../lib/sdl/src/main/ngage/SDL_ngage_main.cpp |   82 ++
 .../lib/sdl/src/main/uikit/SDL_uikit_main.c   |    1 -
 Engine/lib/sdl/src/main/windows/version.rc    |    8 +-
 Engine/lib/sdl/src/render/SDL_render.c        |   26 +-
 .../sdl/src/render/direct3d/SDL_render_d3d.c  |   25 +-
 .../sdl/src/render/metal/SDL_render_metal.m   |   90 +-
 .../lib/sdl/src/render/software/SDL_rotate.c  |    5 -
 .../lib/sdl/src/render/software/SDL_rotate.h  |    4 -
 Engine/lib/sdl/src/stdlib/SDL_iconv.c         |    4 +-
 Engine/lib/sdl/src/stdlib/SDL_malloc.c        |   16 +-
 Engine/lib/sdl/src/stdlib/SDL_qsort.c         |   33 +
 Engine/lib/sdl/src/stdlib/SDL_stdlib.c        |    7 +-
 Engine/lib/sdl/src/stdlib/SDL_string.c        |    9 +-
 Engine/lib/sdl/src/stdlib/SDL_vacopy.h        |   36 +
 Engine/lib/sdl/src/test/SDL_test_harness.c    |    4 +-
 Engine/lib/sdl/src/thread/SDL_thread_c.h      |    2 +
 .../lib/sdl/src/thread/ngage/SDL_sysmutex.cpp |  123 ++
 .../lib/sdl/src/thread/ngage/SDL_syssem.cpp   |  195 +++
 .../sdl/src/thread/ngage/SDL_systhread.cpp    |  134 +++
 .../sdl/src/thread/ngage/SDL_systhread_c.h    |   25 +
 .../lib/sdl/src/timer/ngage/SDL_systimer.cpp  |  100 ++
 Engine/lib/sdl/src/video/SDL_RLEaccel.c       |   32 +-
 Engine/lib/sdl/src/video/SDL_blit_1.c         |   44 +-
 Engine/lib/sdl/src/video/SDL_blit_A.c         |   72 +-
 Engine/lib/sdl/src/video/SDL_blit_N.c         |  156 +--
 Engine/lib/sdl/src/video/SDL_blit_auto.c      |    4 +-
 Engine/lib/sdl/src/video/SDL_egl.c            |    6 +-
 Engine/lib/sdl/src/video/SDL_fillrect.c       |    4 +-
 Engine/lib/sdl/src/video/SDL_sysvideo.h       |    6 +
 Engine/lib/sdl/src/video/SDL_video.c          |  140 ++-
 .../src/video/android/SDL_androidkeyboard.c   |    8 +-
 .../sdl/src/video/cocoa/SDL_cocoaclipboard.h  |    4 +-
 .../sdl/src/video/cocoa/SDL_cocoaclipboard.m  |   12 +-
 .../lib/sdl/src/video/cocoa/SDL_cocoaevents.m |   64 +-
 .../sdl/src/video/cocoa/SDL_cocoakeyboard.m   |   64 +-
 .../sdl/src/video/cocoa/SDL_cocoamessagebox.m |   12 +-
 .../sdl/src/video/cocoa/SDL_cocoametalview.m  |   17 +-
 .../lib/sdl/src/video/cocoa/SDL_cocoamodes.m  |   34 +-
 .../lib/sdl/src/video/cocoa/SDL_cocoamouse.m  |  137 ++-
 .../lib/sdl/src/video/cocoa/SDL_cocoaopengl.m |   81 +-
 .../sdl/src/video/cocoa/SDL_cocoaopengles.m   |   37 +-
 .../lib/sdl/src/video/cocoa/SDL_cocoashape.m  |   17 +-
 .../lib/sdl/src/video/cocoa/SDL_cocoavideo.h  |   21 +-
 .../lib/sdl/src/video/cocoa/SDL_cocoavideo.m  |   63 +-
 .../lib/sdl/src/video/cocoa/SDL_cocoawindow.h |   34 +-
 .../lib/sdl/src/video/cocoa/SDL_cocoawindow.m |  422 ++++---
 .../lib/sdl/src/video/kmsdrm/SDL_kmsdrmsym.h  |    4 +-
 .../sdl/src/video/ngage/SDL_ngageevents.cpp   |  200 ++++
 .../sdl/src/video/ngage/SDL_ngageevents_c.h   |   28 +
 .../src/video/ngage/SDL_ngageframebuffer.cpp  |  431 +++++++
 .../src/video/ngage/SDL_ngageframebuffer_c.h  |   38 +
 .../sdl/src/video/ngage/SDL_ngagevideo.cpp    |  192 +++
 .../lib/sdl/src/video/ngage/SDL_ngagevideo.h  |   75 ++
 .../sdl/src/video/ngage/SDL_ngagewindow.cpp   |  129 ++
 .../lib/sdl/src/video/ngage/SDL_ngagewindow.h |   45 +
 .../sdl/src/video/riscos/scancodes_riscos.h   |    4 +-
 Engine/lib/sdl/src/video/sdlgenblit.pl        |    4 +-
 .../sdl/src/video/uikit/SDL_uikitopenglview.m |    2 +-
 .../lib/sdl/src/video/uikit/SDL_uikitvideo.m  |   11 +-
 .../sdl/src/video/wayland/SDL_waylanddyn.h    |    1 +
 .../sdl/src/video/wayland/SDL_waylandevents.c |   15 +-
 .../sdl/src/video/wayland/SDL_waylandsym.h    |    5 +-
 .../sdl/src/video/wayland/SDL_waylandvideo.c  |   29 +-
 .../sdl/src/video/wayland/SDL_waylandvideo.h  |    2 +
 .../sdl/src/video/wayland/SDL_waylandwindow.c |   48 +-
 .../sdl/src/video/wayland/SDL_waylandwindow.h |   56 +-
 .../sdl/src/video/windows/SDL_windowsevents.c |   12 +-
 .../sdl/src/video/windows/SDL_windowsvideo.c  |   16 +
 Engine/lib/sdl/src/video/x11/SDL_x11dyn.c     |   10 +-
 Engine/lib/sdl/src/video/x11/SDL_x11dyn.h     |    6 -
 .../lib/sdl/src/video/x11/SDL_x11keyboard.c   |   11 +-
 Engine/lib/sdl/src/video/x11/SDL_x11modes.c   |  613 ++--------
 Engine/lib/sdl/src/video/x11/SDL_x11modes.h   |   21 +-
 Engine/lib/sdl/src/video/x11/SDL_x11mouse.c   |    6 +-
 Engine/lib/sdl/src/video/x11/SDL_x11sym.h     |   27 +-
 Engine/lib/sdl/src/video/x11/SDL_x11video.h   |    6 -
 Engine/lib/sdl/src/video/x11/SDL_x11window.c  |  194 +--
 Engine/lib/sdl/src/video/x11/SDL_x11window.h  |    1 -
 .../sdl/src/video/yuv2rgb/yuv_rgb_std_func.h  |    9 +-
 Engine/lib/sdl/test/CMakeLists.txt            |  226 +++-
 Engine/lib/sdl/test/Makefile.in               |  114 +-
 Engine/lib/sdl/test/Makefile.os2              |   76 +-
 Engine/lib/sdl/test/Makefile.w32              |   16 +
 Engine/lib/sdl/test/checkkeys.c               |    9 +-
 Engine/lib/sdl/test/controllermap.c           |   42 +-
 Engine/lib/sdl/test/loopwave.c                |   14 +-
 Engine/lib/sdl/test/loopwavequeue.c           |   15 +-
 Engine/lib/sdl/test/template.test.in          |    3 +
 Engine/lib/sdl/test/testatomic.c              |    6 +
 Engine/lib/sdl/test/testaudiohotplug.c        |   14 +-
 Engine/lib/sdl/test/testautomation_hints.c    |    8 +-
 Engine/lib/sdl/test/testautomation_platform.c |   19 +
 Engine/lib/sdl/test/testautomation_stdlib.c   |  172 ++-
 Engine/lib/sdl/test/testcustomcursor.c        |   21 +
 Engine/lib/sdl/test/testerror.c               |    6 +
 Engine/lib/sdl/test/testevdev.c               |    2 +-
 Engine/lib/sdl/test/testgamecontroller.c      |  333 +++++-
 Engine/lib/sdl/test/testgeometry.c            |   40 +-
 Engine/lib/sdl/test/testgles2_sdf.c           |   22 +-
 Engine/lib/sdl/test/testiconv.c               |    6 +-
 Engine/lib/sdl/test/testime.c                 |   10 +-
 Engine/lib/sdl/test/testmultiaudio.c          |    6 +-
 Engine/lib/sdl/test/testnative.c              |   34 +-
 Engine/lib/sdl/test/testoverlay2.c            |   10 +-
 Engine/lib/sdl/test/testplatform.c            |   23 +
 Engine/lib/sdl/test/testqsort.c               |    2 +-
 Engine/lib/sdl/test/testrendercopyex.c        |   56 +-
 Engine/lib/sdl/test/testrendertarget.c        |   58 +-
 Engine/lib/sdl/test/testscale.c               |   55 +-
 Engine/lib/sdl/test/testsprite2.c             |   40 +-
 Engine/lib/sdl/test/testspriteminimal.c       |   54 +-
 Engine/lib/sdl/test/teststreaming.c           |   10 +-
 Engine/lib/sdl/test/testsurround.c            |    7 +-
 Engine/lib/sdl/test/testthread.c              |    6 +
 Engine/lib/sdl/test/testtimer.c               |    6 +
 Engine/lib/sdl/test/testutils.c               |  153 +++
 Engine/lib/sdl/test/testutils.h               |   17 +
 Engine/lib/sdl/test/testviewport.c            |   55 +-
 Engine/lib/sdl/test/versioning.sh             |  162 +++
 Engine/lib/sdl/test/watcom.mif                |  115 ++
 Engine/lib/sdl/visualtest/autogen.sh          |    0
 Engine/lib/sdl/visualtest/configure           |    0
 Engine/lib/sdl/visualtest/launch_harness.sh   |    0
 270 files changed, 9531 insertions(+), 3704 deletions(-)
 mode change 100755 => 100644 Engine/lib/sdl/Android.mk
 create mode 100644 Engine/lib/sdl/Makefile.w32
 mode change 100644 => 100755 Engine/lib/sdl/VisualC/clean.sh
 mode change 100644 => 120000 Engine/lib/sdl/android-project-ant/AndroidManifest.xml
 mode change 100644 => 120000 Engine/lib/sdl/android-project-ant/src
 mode change 100644 => 100755 Engine/lib/sdl/android-project/gradlew
 mode change 100644 => 100755 Engine/lib/sdl/build-scripts/clang++-fat.sh
 mode change 100644 => 100755 Engine/lib/sdl/build-scripts/clang-fat.sh
 mode change 100644 => 100755 Engine/lib/sdl/build-scripts/codechecker-buildbot.sh
 mode change 100644 => 100755 Engine/lib/sdl/build-scripts/config.guess
 mode change 100644 => 100755 Engine/lib/sdl/build-scripts/config.sub
 mode change 100644 => 100755 Engine/lib/sdl/build-scripts/fnsince.pl
 create mode 100644 Engine/lib/sdl/build-scripts/gen_audio_resampler_filter.c
 mode change 100644 => 100755 Engine/lib/sdl/build-scripts/git-pre-push-hook.pl
 mode change 100755 => 100644 Engine/lib/sdl/build-scripts/ltmain.sh
 mode change 100644 => 100755 Engine/lib/sdl/build-scripts/wikiheaders.pl
 create mode 100644 Engine/lib/sdl/docs/README-ngage.md
 create mode 100644 Engine/lib/sdl/docs/README-versions.md
 create mode 100644 Engine/lib/sdl/docs/release_checklist.md
 create mode 100644 Engine/lib/sdl/include/SDL_config_ngage.h
 create mode 100644 Engine/lib/sdl/src/SDL_log_c.h
 create mode 100644 Engine/lib/sdl/src/audio/SDL_audio_resampler_filter.h
 create mode 100644 Engine/lib/sdl/src/dynapi/SDL2.exports
 mode change 100644 => 100755 Engine/lib/sdl/src/hidapi/bootstrap
 mode change 100644 => 100755 Engine/lib/sdl/src/hidapi/testgui/copy_to_bundle.sh
 mode change 100644 => 100755 Engine/lib/sdl/src/hidapi/testgui/start.sh
 mode change 100644 => 100755 Engine/lib/sdl/src/joystick/check_8bitdo.sh
 create mode 100644 Engine/lib/sdl/src/main/ngage/SDL_ngage_main.cpp
 create mode 100644 Engine/lib/sdl/src/stdlib/SDL_vacopy.h
 create mode 100644 Engine/lib/sdl/src/thread/ngage/SDL_sysmutex.cpp
 create mode 100644 Engine/lib/sdl/src/thread/ngage/SDL_syssem.cpp
 create mode 100644 Engine/lib/sdl/src/thread/ngage/SDL_systhread.cpp
 create mode 100644 Engine/lib/sdl/src/thread/ngage/SDL_systhread_c.h
 create mode 100644 Engine/lib/sdl/src/timer/ngage/SDL_systimer.cpp
 create mode 100644 Engine/lib/sdl/src/video/ngage/SDL_ngageevents.cpp
 create mode 100644 Engine/lib/sdl/src/video/ngage/SDL_ngageevents_c.h
 create mode 100644 Engine/lib/sdl/src/video/ngage/SDL_ngageframebuffer.cpp
 create mode 100644 Engine/lib/sdl/src/video/ngage/SDL_ngageframebuffer_c.h
 create mode 100644 Engine/lib/sdl/src/video/ngage/SDL_ngagevideo.cpp
 create mode 100644 Engine/lib/sdl/src/video/ngage/SDL_ngagevideo.h
 create mode 100644 Engine/lib/sdl/src/video/ngage/SDL_ngagewindow.cpp
 create mode 100644 Engine/lib/sdl/src/video/ngage/SDL_ngagewindow.h
 create mode 100644 Engine/lib/sdl/test/Makefile.w32
 create mode 100644 Engine/lib/sdl/test/template.test.in
 create mode 100644 Engine/lib/sdl/test/testutils.c
 create mode 100644 Engine/lib/sdl/test/testutils.h
 create mode 100755 Engine/lib/sdl/test/versioning.sh
 create mode 100644 Engine/lib/sdl/test/watcom.mif
 mode change 100644 => 100755 Engine/lib/sdl/visualtest/autogen.sh
 mode change 100644 => 100755 Engine/lib/sdl/visualtest/configure
 mode change 100644 => 100755 Engine/lib/sdl/visualtest/launch_harness.sh

diff --git a/Engine/lib/sdl/Android.mk b/Engine/lib/sdl/Android.mk
old mode 100755
new mode 100644
diff --git a/Engine/lib/sdl/CMakeLists.txt b/Engine/lib/sdl/CMakeLists.txt
index 644715aae..8e2832fa0 100644
--- a/Engine/lib/sdl/CMakeLists.txt
+++ b/Engine/lib/sdl/CMakeLists.txt
@@ -56,23 +56,11 @@ set(CMAKE_MODULE_PATH "${SDL2_SOURCE_DIR}/cmake")
 include(${SDL2_SOURCE_DIR}/cmake/macros.cmake)
 include(${SDL2_SOURCE_DIR}/cmake/sdlchecks.cmake)
 
-# General settings
-# Edit include/SDL_version.h and change the version, then:
-#   SDL_MICRO_VERSION += 1;
-#   SDL_INTERFACE_AGE += 1;
-#   SDL_BINARY_AGE += 1;
-# if any functions have been added, set SDL_INTERFACE_AGE to 0.
-# if backwards compatibility has been broken,
-# set SDL_BINARY_AGE and SDL_INTERFACE_AGE to 0.
+# See docs/release_checklist.md
 set(SDL_MAJOR_VERSION 2)
-set(SDL_MINOR_VERSION 0)
-set(SDL_MICRO_VERSION 22)
-set(SDL_INTERFACE_AGE 0)
-set(SDL_BINARY_AGE 22)
+set(SDL_MINOR_VERSION 23)
+set(SDL_MICRO_VERSION 0)
 set(SDL_VERSION "${SDL_MAJOR_VERSION}.${SDL_MINOR_VERSION}.${SDL_MICRO_VERSION}")
-# the following should match the versions in Xcode project file:
-set(DYLIB_CURRENT_VERSION 23.0.0)
-set(DYLIB_COMPATIBILITY_VERSION 1.0.0)
 
 # Set defaults preventing destination file conflicts
 set(SDL_CMAKE_DEBUG_POSTFIX "d"
@@ -81,13 +69,40 @@ set(SDL_CMAKE_DEBUG_POSTFIX "d"
 mark_as_advanced(CMAKE_IMPORT_LIBRARY_SUFFIX SDL_CMAKE_DEBUG_POSTFIX)
 
 # Calculate a libtool-like version number
-math(EXPR LT_CURRENT "${SDL_MICRO_VERSION} - ${SDL_INTERFACE_AGE}")
+math(EXPR SDL_BINARY_AGE "${SDL_MINOR_VERSION} * 100 + ${SDL_MICRO_VERSION}")
+if(SDL_MINOR_VERSION MATCHES "[02468]$")
+    # Stable branch, 2.24.1 -> libSDL2-2.0.so.0.2400.1
+    set(SDL_INTERFACE_AGE ${SDL_MICRO_VERSION})
+else()
+    # Development branch, 2.23.1 -> libSDL2-2.0.so.0.2301.0
+    set(SDL_INTERFACE_AGE 0)
+endif()
+
+# Increment this if there is an incompatible change - but if that happens,
+# we should rename the library from SDL2 to SDL3, at which point this would
+# reset to 0 anyway.
+set(LT_MAJOR "0")
+
 math(EXPR LT_AGE "${SDL_BINARY_AGE} - ${SDL_INTERFACE_AGE}")
-math(EXPR LT_MAJOR "${LT_CURRENT}- ${LT_AGE}")
+math(EXPR LT_CURRENT "${LT_MAJOR} + ${LT_AGE}")
 set(LT_REVISION "${SDL_INTERFACE_AGE}")
-set(LT_RELEASE "${SDL_MAJOR_VERSION}.${SDL_MINOR_VERSION}")
+# For historical reasons, the library name redundantly includes the major
+# version twice: libSDL2-2.0.so.0.
+# TODO: in SDL 3, set the OUTPUT_NAME to plain SDL3, which will simplify
+# it to libSDL3.so.0
+set(LT_RELEASE "2.0")
 set(LT_VERSION "${LT_MAJOR}.${LT_AGE}.${LT_REVISION}")
 
+# The following should match the versions in the Xcode project file.
+# Each version is 1 higher than you might expect, for compatibility
+# with libtool: macOS ABI versioning is 1-based, unlike other platforms
+# which are normally 0-based.
+math(EXPR DYLIB_CURRENT_VERSION_MAJOR "${LT_MAJOR} + ${LT_AGE} + 1")
+math(EXPR DYLIB_CURRENT_VERSION_MINOR "${LT_REVISION}")
+math(EXPR DYLIB_COMPAT_VERSION_MAJOR "${LT_MAJOR} + 1")
+set(DYLIB_CURRENT_VERSION "${DYLIB_CURRENT_VERSION_MAJOR}.${DYLIB_CURRENT_VERSION_MINOR}.0")
+set(DYLIB_COMPATIBILITY_VERSION "${DYLIB_COMPAT_VERSION_MAJOR}.0.0")
+
 #message(STATUS "${LT_VERSION} :: ${LT_AGE} :: ${LT_REVISION} :: ${LT_CURRENT} :: ${LT_RELEASE}")
 
 # General settings & flags
@@ -423,7 +438,7 @@ set_option(SDL_RPATH               "Use an rpath when linking SDL" ${UNIX_SYS})
 set_option(SDL_CLOCK_GETTIME       "Use clock_gettime() instead of gettimeofday()" ${UNIX_SYS})
 set_option(SDL_X11                 "Use X11 video driver" ${UNIX_SYS})
 dep_option(SDL_X11_SHARED          "Dynamically load X11 support" ON "SDL_X11" OFF)
-set(SDL_X11_OPTIONS Xcursor Xdbe Xinerama XInput Xfixes Xrandr Xscrnsaver XShape Xvm)
+set(SDL_X11_OPTIONS Xcursor Xdbe XInput Xfixes Xrandr Xscrnsaver XShape)
 foreach(_SUB ${SDL_X11_OPTIONS})
   string(TOUPPER "SDL_X11_${_SUB}" _OPT)
   dep_option(${_OPT}               "Enable ${_SUB} support" ON "SDL_X11" OFF)
@@ -457,6 +472,7 @@ set(SDL_STATIC ${SDL_STATIC_ENABLED_BY_DEFAULT} CACHE BOOL "Build a static versi
 
 dep_option(SDL_STATIC_PIC      "Static version of the library should be built with Position Independent Code" OFF "SDL_STATIC" OFF)
 set_option(SDL_TEST            "Build the test directory" OFF)
+set_option(SDL_INSTALL_TESTS   "Install test-cases" OFF)
 
 if(VITA)
   set_option(VIDEO_VITA_PIB  "Build with PSVita piglet gles2 support" OFF)
@@ -611,10 +627,14 @@ if(USE_GCC OR USE_CLANG)
     endif()
   endif()
 endif()
+if(MSVC)
+  target_compile_definitions(sdl-build-options INTERFACE "-D_CRT_SECURE_NO_DEPRECATE")
+  target_compile_definitions(sdl-build-options INTERFACE "-D_CRT_NONSTDC_NO_DEPRECATE")
+  target_compile_definitions(sdl-build-options INTERFACE "-D_CRT_SECURE_NO_WARNINGS")
+endif()
 
 if(SDL_ASSEMBLY)
   if(USE_GCC OR USE_CLANG)
-    set(SDL_ASSEMBLY_ROUTINES 1)
     # TODO: Those all seem to be quite GCC specific - needs to be
     # reworked for better compiler support
     set(HAVE_ASSEMBLY TRUE)
@@ -832,7 +852,6 @@ if(SDL_ASSEMBLY)
     set(HAVE_SSE2 TRUE)
     set(HAVE_SSE3 TRUE)
     check_include_file("immintrin.h" HAVE_IMMINTRIN_H)
-    set(SDL_ASSEMBLY_ROUTINES 1)
   endif()
 endif()
 
@@ -848,7 +867,7 @@ if(SDL_LIBC)
     endforeach()
     set(HAVE_SIGNAL_H 1)
     foreach(_FN
-            malloc calloc realloc free qsort abs memset memcpy memmove memcmp
+            malloc calloc realloc free bsearch qsort abs memset memcpy memmove memcmp
             wcslen _wcsdup wcsdup wcsstr wcscmp wcsncmp _wcsicmp _wcsnicmp
             strlen _strrev _strupr _strlwr strchr strrchr strstr itoa _ltoa
             _ultoa strtol strtoul strtoll strtod atoi atof strcmp strncmp
@@ -885,7 +904,7 @@ if(SDL_LIBC)
                              int main(void) { return 0; }" HAVE_MPROTECT)
     foreach(_FN
             strtod malloc calloc realloc free getenv setenv putenv unsetenv
-            qsort abs bcopy memset memcpy memmove memcmp strlen strlcpy strlcat
+            bsearch qsort abs bcopy memset memcpy memmove memcmp strlen strlcpy strlcat
             _strrev _strupr _strlwr index rindex strchr strrchr strstr strtok_r
             itoa _ltoa _uitoa _ultoa strtol strtoul _i64toa _ui64toa strtoll strtoull
             atoi atof strcmp strncmp _stricmp strcasecmp _strnicmp strncasecmp
@@ -1529,7 +1548,7 @@ elseif(WINDOWS)
   if(MSVC AND NOT SDL_LIBC)
     # Prevent codegen that would use the VC runtime libraries.
     set_property(DIRECTORY . APPEND PROPERTY COMPILE_OPTIONS "/GS-")
-    if(NOT ARCH_64)
+    if(NOT ARCH_64 AND NOT CMAKE_GENERATOR_PLATFORM STREQUAL "ARM")
       set_property(DIRECTORY . APPEND PROPERTY COMPILE_OPTIONS "/arch:SSE")
     endif()
   endif()
@@ -1561,7 +1580,7 @@ elseif(WINDOWS)
     check_include_file(ddraw.h HAVE_DDRAW_H)
     check_include_file(dsound.h HAVE_DSOUND_H)
     check_include_file(dinput.h HAVE_DINPUT_H)
-    if(WINDOWS_STORE OR VCPKG_TARGET_TRIPLET MATCHES "arm-windows")
+    if(WINDOWS_STORE OR CMAKE_GENERATOR_PLATFORM STREQUAL "ARM")
       set(HAVE_DINPUT_H 0)
     endif()
     check_include_file(dxgi.h HAVE_DXGI_H)
@@ -2869,6 +2888,9 @@ if(NOT WINDOWS_STORE AND NOT SDL2_DISABLE_SDL2MAIN)
   add_library(SDL2::SDL2main ALIAS SDL2main)
   target_include_directories(SDL2main BEFORE PRIVATE "${SDL2_BINARY_DIR}/include")
   target_include_directories(SDL2main PUBLIC "$<BUILD_INTERFACE:${SDL2_SOURCE_DIR}/include>" $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}> $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/SDL2>)
+  if (WIN32)
+    target_link_libraries(SDL2main PRIVATE shell32)
+  endif()
   if (NOT ANDROID)
     set_target_properties(SDL2main PROPERTIES DEBUG_POSTFIX "${SDL_CMAKE_DEBUG_POSTFIX}")
   endif()
@@ -2878,7 +2900,7 @@ if(ANDROID)
   target_include_directories(sdl-build-options INTERFACE "${ANDROID_NDK}/sources/android/cpufeatures")
 endif()
 
-if(IOS OR TVOS)
+if(APPLE)
   target_compile_options(sdl-build-options INTERFACE "-fobjc-arc")
 endif()
 
@@ -2909,7 +2931,7 @@ if(SDL_SHARED)
       OUTPUT_NAME "SDL2")
   endif()
   # Note: The clang toolset for Visual Studio does not support /NODEFAULTLIB.
-  if(MSVC AND NOT SDL_LIBC AND NOT MSVC_CLANG)
+  if(MSVC AND NOT SDL_LIBC AND NOT MSVC_CLANG AND NOT CMAKE_GENERATOR_PLATFORM STREQUAL "ARM")
     # Don't try to link with the default set of libraries.
     if(NOT WINDOWS_STORE)
       set_target_properties(SDL2 PROPERTIES LINK_FLAGS_RELEASE "/NODEFAULTLIB")
@@ -2941,7 +2963,7 @@ if(SDL_STATIC)
   endif()
   set_target_properties(SDL2-static PROPERTIES POSITION_INDEPENDENT_CODE ${SDL_STATIC_PIC})
   # Note: The clang toolset for Visual Studio does not support /NODEFAULTLIB.
-  if(MSVC AND NOT SDL_LIBC AND NOT MSVC_CLANG)
+  if(MSVC AND NOT SDL_LIBC AND NOT MSVC_CLANG AND NOT CMAKE_GENERATOR_PLATFORM STREQUAL "ARM")
     set_target_properties(SDL2-static PROPERTIES LINK_FLAGS_RELEASE "/NODEFAULTLIB")
     set_target_properties(SDL2-static PROPERTIES LINK_FLAGS_DEBUG "/NODEFAULTLIB")
     set_target_properties(SDL2-static PROPERTIES STATIC_LIBRARY_FLAGS "/NODEFAULTLIB")
@@ -2958,14 +2980,18 @@ if(SDL_STATIC)
   endif()
 endif()
 
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DSDL_BUILD_MAJOR_VERSION=${SDL_MAJOR_VERSION}")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DSDL_BUILD_MINOR_VERSION=${SDL_MINOR_VERSION}")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DSDL_BUILD_MICRO_VERSION=${SDL_MICRO_VERSION}")
+
 ##### Tests #####
 
 if(SDL_TEST)
+  include(CTest)
   include_directories(BEFORE "${SDL2_BINARY_DIR}/include")
   include_directories(AFTER "${SDL2_SOURCE_DIR}/include")
   file(GLOB TEST_SOURCES ${SDL2_SOURCE_DIR}/src/test/*.c)
   add_library(SDL2_test STATIC ${TEST_SOURCES})
-  add_subdirectory(test)
 endif()
 
 ##### Installation targets #####
@@ -3091,3 +3117,11 @@ if(NOT SDL2_DISABLE_UNINSTALL)
   endif()
 endif()
 
+##### Tests subproject (must appear after the install/uninstall targets) #####
+
+if(SDL_TEST)
+  add_subdirectory(test)
+endif()
+
+##### Fix Objective C builds #####
+set(CMAKE_OBJC_FLAGS "${CMAKE_OBJC_FLAGS} ${CMAKE_C_FLAGS}")
diff --git a/Engine/lib/sdl/Makefile.os2 b/Engine/lib/sdl/Makefile.os2
index cfd0d6562..40ba0e8fc 100644
--- a/Engine/lib/sdl/Makefile.os2
+++ b/Engine/lib/sdl/Makefile.os2
@@ -11,7 +11,10 @@
 # wmake -f Makefile.os2 HIDAPI=1
 
 LIBNAME = SDL2
-VERSION = 2.0.22
+MAJOR_VERSION = 2
+MINOR_VERSION = 23
+MICRO_VERSION = 0
+VERSION = $(MAJOR_VERSION).$(MINOR_VERSION).$(MICRO_VERSION)
 DESCRIPTION = Simple DirectMedia Layer 2
 
 LIBICONV=0
@@ -60,6 +63,10 @@ CFLAGS_DLL+= -DHAVE_LIBUSB_H=1
 # building SDL itself (for DECLSPEC):
 CFLAGS_DLL+= -DBUILD_SDL
 
+CFLAGS_DLL+= -DSDL_BUILD_MAJOR_VERSION=$(MAJOR_VERSION)
+CFLAGS_DLL+= -DSDL_BUILD_MINOR_VERSION=$(MINOR_VERSION)
+CFLAGS_DLL+= -DSDL_BUILD_MICRO_VERSION=$(MICRO_VERSION)
+
 SRCS = SDL.c SDL_assert.c SDL_error.c SDL_log.c SDL_dataqueue.c SDL_hints.c SDL_list.c
 SRCS+= SDL_getenv.c SDL_iconv.c SDL_malloc.c SDL_qsort.c SDL_stdlib.c SDL_string.c SDL_strtokr.c SDL_crc32.c
 SRCS+= SDL_cpuinfo.c SDL_atomic.c SDL_spinlock.c SDL_thread.c SDL_timer.c
diff --git a/Engine/lib/sdl/Makefile.w32 b/Engine/lib/sdl/Makefile.w32
new file mode 100644
index 000000000..48f4e2bcc
--- /dev/null
+++ b/Engine/lib/sdl/Makefile.w32
@@ -0,0 +1,222 @@
+# Open Watcom makefile to build SDL2.dll for Win32
+# wmake -f Makefile.w32
+
+LIBNAME = SDL2
+MAJOR_VERSION = 2
+MINOR_VERSION = 23
+MICRO_VERSION = 0
+VERSION = $(MAJOR_VERSION).$(MINOR_VERSION).$(MICRO_VERSION)
+DESCRIPTION = Simple DirectMedia Layer 2
+
+LIBHOME = .
+DLLFILE = $(LIBHOME)/$(LIBNAME).dll
+LIBFILE = $(LIBHOME)/$(LIBNAME).lib
+EXPFILE = $(LIBHOME)/$(LIBNAME).exp
+LNKFILE = $(LIBNAME).lnk
+
+INCPATH = -I"$(%WATCOM)/h/nt" -I"$(%WATCOM)/h/nt/directx" -I"$(%WATCOM)/h"
+INCPATH+= -Iinclude
+INCPATH+= -I"src/video/khronos"
+
+TLIB = SDL2test.lib
+LIBS = user32.lib gdi32.lib winmm.lib imm32.lib ole32.lib oleaut32.lib shell32.lib setupapi.lib version.lib uuid.lib dxguid.lib
+
+CFLAGS = -bt=nt -d0 -q -bm -5s -fp5 -fpi87 -sg -oeatxhn -ei
+# max warnings:
+CFLAGS+= -wx
+# newer OpenWatcom versions enable W303 by default
+CFLAGS+= -wcd=303
+# the include paths :
+CFLAGS+= $(INCPATH)
+CFLAGS_STATIC=$(CFLAGS)
+# building dll:
+CFLAGS_DLL =$(CFLAGS)
+CFLAGS_DLL+= -bd
+# we override the DECLSPEC define in begin_code.h, because we are using
+# an exports file to remove the _cdecl '_' prefix from the symbol names
+CFLAGS_DLL+= -DDECLSPEC=
+
+CFLAGS_DLL+= -DSDL_BUILD_MAJOR_VERSION=$(MAJOR_VERSION)
+CFLAGS_DLL+= -DSDL_BUILD_MINOR_VERSION=$(MINOR_VERSION)
+CFLAGS_DLL+= -DSDL_BUILD_MICRO_VERSION=$(MICRO_VERSION)
+
+RCFLAGS = -q -r -bt=nt $(INCPATH)
+
+SRCS = SDL.c SDL_assert.c SDL_error.c SDL_log.c SDL_dataqueue.c SDL_hints.c SDL_list.c
+SRCS+= SDL_getenv.c SDL_iconv.c SDL_malloc.c SDL_qsort.c SDL_stdlib.c SDL_string.c SDL_strtokr.c SDL_crc32.c
+SRCS+= SDL_cpuinfo.c SDL_atomic.c SDL_spinlock.c SDL_thread.c SDL_timer.c
+SRCS+= SDL_rwops.c SDL_power.c
+SRCS+= SDL_audio.c SDL_audiocvt.c SDL_audiodev.c SDL_audiotypecvt.c SDL_mixer.c SDL_wave.c
+SRCS+= SDL_events.c SDL_quit.c SDL_keyboard.c SDL_mouse.c SDL_windowevents.c &
+       SDL_clipboardevents.c SDL_dropevents.c SDL_displayevents.c SDL_gesture.c &
+       SDL_sensor.c SDL_touch.c
+SRCS+= SDL_haptic.c SDL_hidapi.c SDL_gamecontroller.c SDL_joystick.c
+SRCS+= SDL_render.c yuv_rgb.c SDL_yuv.c SDL_yuv_sw.c SDL_blendfillrect.c &
+       SDL_blendline.c SDL_blendpoint.c SDL_drawline.c SDL_drawpoint.c &
+       SDL_render_sw.c SDL_rotate.c SDL_triangle.c
+SRCS+= SDL_blit.c SDL_blit_0.c SDL_blit_1.c SDL_blit_A.c SDL_blit_auto.c &
+       SDL_blit_copy.c SDL_blit_N.c SDL_blit_slow.c SDL_fillrect.c SDL_bmp.c &
+       SDL_pixels.c SDL_rect.c SDL_RLEaccel.c SDL_shape.c SDL_stretch.c &
+       SDL_surface.c SDL_video.c SDL_clipboard.c SDL_vulkan_utils.c SDL_egl.c
+
+SRCS+= e_atan2.c e_exp.c e_fmod.c e_log10.c e_log.c e_pow.c e_rem_pio2.c e_sqrt.c &
+       k_cos.c k_rem_pio2.c k_sin.c k_tan.c &
+       s_atan.c s_copysign.c s_cos.c s_fabs.c s_floor.c s_scalbn.c s_sin.c s_tan.c
+
+SRCS+= SDL_syscond.c SDL_sysmutex.c SDL_syssem.c SDL_systhread.c SDL_systls.c
+SRCS+= SDL_systimer.c
+SRCS+= SDL_sysloadso.c
+SRCS+= SDL_sysfilesystem.c
+SRCS+= SDL_syshaptic.c SDL_sysjoystick.c SDL_virtualjoystick.c
+SRCS+= SDL_hidapijoystick.c SDL_hidapi_rumble.c SDL_hidapi_gamecube.c SDL_hidapi_luna.c SDL_hidapi_ps4.c SDL_hidapi_ps5.c SDL_hidapi_stadia.c SDL_hidapi_switch.c SDL_hidapi_xbox360.c SDL_hidapi_xbox360w.c SDL_hidapi_xboxone.c SDL_hidapi_steam.c
+SRCS+= SDL_dummyaudio.c SDL_diskaudio.c
+SRCS+= SDL_nullvideo.c SDL_nullframebuffer.c SDL_nullevents.c
+SRCS+= SDL_dummysensor.c
+SRCS+= SDL_locale.c SDL_syslocale.c
+SRCS+= SDL_url.c SDL_sysurl.c
+
+SRCS+= SDL_winmm.c SDL_directsound.c SDL_wasapi.c SDL_wasapi_win32.c
+SRCS+= SDL_hid.c SDL_windows.c SDL_xinput.c
+SRCS+= SDL_dinputhaptic.c SDL_windowshaptic.c SDL_xinputhaptic.c
+SRCS+= SDL_dinputjoystick.c SDL_rawinputjoystick.c SDL_windowsjoystick.c SDL_windows_gaming_input.c SDL_xinputjoystick.c
+SRCS+= SDL_syspower.c
+SRCS+= SDL_d3dmath.c
+SRCS+= SDL_render_d3d.c SDL_shaders_d3d.c
+SRCS+= SDL_render_d3d11.c SDL_shaders_d3d11.c
+SRCS+= SDL_render_gl.c SDL_shaders_gl.c
+SRCS+= SDL_render_gles2.c SDL_shaders_gles2.c
+SRCS+= SDL_windowssensor.c
+SRCS+= SDL_syscond_cv.c
+SRCS+= SDL_windowsclipboard.c SDL_windowsevents.c SDL_windowsframebuffer.c SDL_windowskeyboard.c SDL_windowsmessagebox.c SDL_windowsmodes.c SDL_windowsmouse.c SDL_windowsopengl.c SDL_windowsopengles.c SDL_windowsshape.c SDL_windowsvideo.c SDL_windowsvulkan.c SDL_windowswindow.c
+
+SRCS+= SDL_dynapi.c
+
+RCSRCS+= version.rc
+
+OBJS = $(SRCS:.c=.obj)
+RCOBJS= $(RCSRCS:.rc=.res)
+
+.extensions:
+.extensions: .lib .dll .obj .res .c .rc .asm
+
+.c: ./src/libm;
+.c: ./src;./src/dynapi;./src/audio;./src/cpuinfo;./src/events;./src/file;./src/haptic;./src/joystick;./src/power;./src/render;./src/render/software;./src/sensor;./src/stdlib;./src/thread;./src/timer;./src/video;./src/video/yuv2rgb;./src/atomic;./src/audio/disk;
+.c: ./src/haptic/dummy;./src/joystick/dummy;./src/joystick/virtual;./src/audio/dummy;./src/video/dummy;./src/sensor/dummy;
+.c: ./src/core/windows;./src/audio/winmm;./src/audio/directsound;./src/audio/wasapi;./src/loadso/windows;./src/filesystem/windows;./src/haptic/windows;./src/joystick/windows;./src/sensor/windows;./src/thread/windows;./src/timer/windows;./src/video/windows;
+.c: ./src/locale/;./src/locale/windows;./src/misc;./src/misc/windows;./src/power/windows;./src/joystick/hidapi;./src/hidapi;./src/render/direct3d;./src/render/direct3d11;./src/render/opengl;./src/render/opengles2
+.rc: ./src/main/windows
+
+all: $(DLLFILE) $(LIBFILE) $(TLIB) .symbolic
+
+build_dll: .symbolic
+    @echo * Compiling dll objects
+
+$(DLLFILE): build_dll $(OBJS) $(MOBJS) $(RCOBJS) $(LNKFILE)
+    @echo * Linking: $@
+    wlink @$(LNKFILE)
+    wrc $(RCOBJS) $^@
+
+$(LIBFILE): $(DLLFILE)
+    @echo * Creating LIB file: $@
+    wlib -q -b -n -c -pa -s -t -zld -ii -io $* @$(EXPFILE)
+
+.c.obj:
+    wcc386 $(CFLAGS_DLL) -fo=$^@ $<
+
+.rc.res:
+    wrc $(RCFLAGS) -fo=$^@ $<
+
+SDL_syscond.obj: "src/thread/generic/SDL_syscond.c"
+    wcc386 $(CFLAGS_DLL) -fo=$^@ $<
+SDL_cpuinfo.obj: SDL_cpuinfo.c
+    wcc386 $(CFLAGS_DLL) -wcd=200 -fo=$^@ $<
+SDL_wave.obj: SDL_wave.c
+    wcc386 $(CFLAGS_DLL) -wcd=124 -fo=$^@ $<
+SDL_blendfillrect.obj: SDL_blendfillrect.c
+    wcc386 $(CFLAGS_DLL) -wcd=200 -fo=$^@ $<
+SDL_blendline.obj: SDL_blendline.c
+    wcc386 $(CFLAGS_DLL) -wcd=200 -fo=$^@ $<
+SDL_blendpoint.obj: SDL_blendpoint.c
+    wcc386 $(CFLAGS_DLL) -wcd=200 -fo=$^@ $<
+SDL_RLEaccel.obj: SDL_RLEaccel.c
+    wcc386 $(CFLAGS_DLL) -wcd=201 -fo=$^@ $<
+# c99 mode needed because of structs with flexible array members in libusb.h
+SDL_hidapi.obj: SDL_hidapi.c
+    wcc386 $(CFLAGS_DLL) -za99 -fo=$^@ $<
+
+# SDL2test
+TSRCS = SDL_test_assert.c SDL_test_common.c SDL_test_compare.c &
+        SDL_test_crc32.c SDL_test_font.c SDL_test_fuzzer.c SDL_test_harness.c &
+        SDL_test_imageBlit.c SDL_test_imageBlitBlend.c SDL_test_imageFace.c &
+        SDL_test_imagePrimitives.c SDL_test_imagePrimitivesBlend.c &
+        SDL_test_log.c SDL_test_md5.c SDL_test_random.c SDL_test_memory.c
+TOBJS= $(TSRCS:.c=.obj)
+
+.c: ./src/test;
+SDL_test_assert.obj: SDL_test_assert.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_common.obj: SDL_test_common.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_compare.obj: SDL_test_compare.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_crc32.obj: SDL_test_crc32.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_font.obj: SDL_test_font.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_fuzzer.obj: SDL_test_fuzzer.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_harness.obj: SDL_test_harness.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_imageBlit.obj: SDL_test_imageBlit.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_imageBlitBlend.obj: SDL_test_imageBlitBlend.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_imageFace.obj: SDL_test_imageFace.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_imagePrimitives.obj: SDL_test_imagePrimitives.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_imagePrimitivesBlend.obj: SDL_test_imagePrimitivesBlend.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_log.obj: SDL_test_log.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_md5.obj: SDL_test_md5.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_random.obj: SDL_test_random.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+SDL_test_memory.obj: SDL_test_memory.c
+    wcc386 $(CFLAGS_STATIC) -fo=$^@ $<
+
+build_tlib: .symbolic
+    @echo * Compiling testlib objects
+$(TLIB): build_tlib $(TOBJS)
+    @echo * Creating: $@
+    wlib -q -b -n -c -pa -s -t -zld -ii -io $@ $(TOBJS)
+
+$(LNKFILE): Makefile.w32
+    @echo * Creating linker file: $@
+    @%create $@
+    @%append $@ SYSTEM nt_dll INITINSTANCE TERMINSTANCE
+    @%append $@ NAME $(DLLFILE)
+    @for %i in ($(OBJS)) do @%append $@ FILE %i
+    @for %i in ($(LIBS)) do @%append $@ LIB %i
+    @%append $@ EXPORT=src/dynapi/SDL2.exports
+    @%append $@ OPTION QUIET
+    @%append $@ OPTION IMPF=$(EXPFILE)
+    @%append $@ OPTION MAP=$(LIBHOME)/$^&.map
+    @%append $@ OPTION DESCRIPTION '@$#libsdl org:$(VERSION)$#@$(DESCRIPTION)'
+    @%append $@ OPTION ELIMINATE
+    @%append $@ OPTION OSNAME='Windows NT'
+    @%append $@ OPTION SHOWDEAD
+
+clean: .SYMBOLIC
+    @echo * Clean: $(LIBNAME)
+    @if exist *.obj rm *.obj
+    @if exist *.err rm *.err
+    @if exist $(LNKFILE) rm $(LNKFILE)
+
+distclean: .SYMBOLIC clean
+    @if exist $(LIBHOME)/*.exp rm $(LIBHOME)/*.exp
+    @if exist $(LIBHOME)/*.map rm $(LIBHOME)/*.map
+    @if exist $(LIBFILE) rm $(LIBFILE)
+    @if exist $(DLLFILE) rm $(DLLFILE)
+    @if exist $(TLIB) rm $(TLIB)
diff --git a/Engine/lib/sdl/VisualC/clean.sh b/Engine/lib/sdl/VisualC/clean.sh
old mode 100644
new mode 100755
diff --git a/Engine/lib/sdl/WhatsNew.txt b/Engine/lib/sdl/WhatsNew.txt
index fa6cbe11a..bb753084c 100644
--- a/Engine/lib/sdl/WhatsNew.txt
+++ b/Engine/lib/sdl/WhatsNew.txt
@@ -1,6 +1,31 @@
 
 This is a list of major changes in SDL's version history.
 
+---------------------------------------------------------------------------
+2.24.0:
+---------------------------------------------------------------------------
+
+General:
+* New version numbering scheme, similar to GLib and Flatpak.
+    * An even number in the minor version (second component) indicates
+      a production-ready stable release such as 2.24.0, which would have
+      been 2.0.24 under the old system.
+      * The patchlevel (micro version, third component) indicates a
+        bugfix-only update: for example, 2.24.1 would be a bugfix-only
+        release to fix bugs in 2.24.0, without adding new features.
+    * An odd number in the minor version indicates a prerelease such
+      as 2.23.0. Stable distributions should not use these prereleases.
+      * The patchlevel indicates successive prereleases, for example
+        2.23.1 and 2.23.2 would be prereleases during development of
+        the SDL 2.24.0 stable release.
+* Added SDL_bsearch() to the stdlib routines
+* Added functions to get the platform dependent name for a joystick or game controller:
+    * SDL_JoystickPathForIndex()
+    * SDL_JoystickPath()
+    * SDL_GameControllerPathForIndex()
+    * SDL_GameControllerPath()
+* Added joystick event SDL_JOYBATTERYUPDATED for when battery status changes.
+
 ---------------------------------------------------------------------------
 2.0.22:
 ---------------------------------------------------------------------------
diff --git a/Engine/lib/sdl/Xcode/SDL/Info-Framework.plist b/Engine/lib/sdl/Xcode/SDL/Info-Framework.plist
index 49a711322..bb7986b87 100644
--- a/Engine/lib/sdl/Xcode/SDL/Info-Framework.plist
+++ b/Engine/lib/sdl/Xcode/SDL/Info-Framework.plist
@@ -19,10 +19,10 @@
 	<key>CFBundlePackageType</key>
 	<string>FMWK</string>
 	<key>CFBundleShortVersionString</key>
-	<string>2.0.22</string>
+	<string>2.23.0</string>
 	<key>CFBundleSignature</key>
 	<string>SDLX</string>
 	<key>CFBundleVersion</key>
-	<string>2.0.22</string>
+	<string>2.23.0</string>
 </dict>
 </plist>
diff --git a/Engine/lib/sdl/Xcode/SDL/SDL.xcodeproj/project.pbxproj b/Engine/lib/sdl/Xcode/SDL/SDL.xcodeproj/project.pbxproj
index 8858cfdd9..c6001f1ef 100644
--- a/Engine/lib/sdl/Xcode/SDL/SDL.xcodeproj/project.pbxproj
+++ b/Engine/lib/sdl/Xcode/SDL/SDL.xcodeproj/project.pbxproj
@@ -3469,13 +3469,13 @@
 		F395C1A22569C68F00942BFF /* SDL_iokitjoystick.c in Sources */ = {isa = PBXBuildFile; fileRef = F395C1922569C68E00942BFF /* SDL_iokitjoystick.c */; };
 		F395C1A32569C68F00942BFF /* SDL_iokitjoystick.c in Sources */ = {isa = PBXBuildFile; fileRef = F395C1922569C68E00942BFF /* SDL_iokitjoystick.c */; };
 		F395C1A42569C68F00942BFF /* SDL_iokitjoystick.c in Sources */ = {isa = PBXBuildFile; fileRef = F395C1922569C68E00942BFF /* SDL_iokitjoystick.c */; };
-		F395C1B12569C6A000942BFF /* SDL_mfijoystick.m in Sources */ = {isa = PBXBuildFile; fileRef = F395C1AF2569C6A000942BFF /* SDL_mfijoystick.m */; settings = {COMPILER_FLAGS = "-fobjc-arc"; }; };
+		F395C1B12569C6A000942BFF /* SDL_mfijoystick.m in Sources */ = {isa = PBXBuildFile; fileRef = F395C1AF2569C6A000942BFF /* SDL_mfijoystick.m */; };
 		F395C1B22569C6A000942BFF /* SDL_mfijoystick.m in Sources */ = {isa = PBXBuildFile; fileRef = F395C1AF2569C6A000942BFF /* SDL_mfijoystick.m */; };
 		F395C1B32569C6A000942BFF /* SDL_mfijoystick.m in Sources */ = {isa = PBXBuildFile; fileRef = F395C1AF2569C6A000942BFF /* SDL_mfijoystick.m */; };
-		F395C1B42569C6A000942BFF /* SDL_mfijoystick.m in Sources */ = {isa = PBXBuildFile; fileRef = F395C1AF2569C6A000942BFF /* SDL_mfijoystick.m */; settings = {COMPILER_FLAGS = "-fobjc-arc"; }; };
+		F395C1B42569C6A000942BFF /* SDL_mfijoystick.m in Sources */ = {isa = PBXBuildFile; fileRef = F395C1AF2569C6A000942BFF /* SDL_mfijoystick.m */; };
 		F395C1B52569C6A000942BFF /* SDL_mfijoystick.m in Sources */ = {isa = PBXBuildFile; fileRef = F395C1AF2569C6A000942BFF /* SDL_mfijoystick.m */; };
 		F395C1B62569C6A000942BFF /* SDL_mfijoystick.m in Sources */ = {isa = PBXBuildFile; fileRef = F395C1AF2569C6A000942BFF /* SDL_mfijoystick.m */; };
-		F395C1B72569C6A000942BFF /* SDL_mfijoystick.m in Sources */ = {isa = PBXBuildFile; fileRef = F395C1AF2569C6A000942BFF /* SDL_mfijoystick.m */; settings = {COMPILER_FLAGS = "-fobjc-arc"; }; };
+		F395C1B72569C6A000942BFF /* SDL_mfijoystick.m in Sources */ = {isa = PBXBuildFile; fileRef = F395C1AF2569C6A000942BFF /* SDL_mfijoystick.m */; };
 		F395C1B82569C6A000942BFF /* SDL_mfijoystick.m in Sources */ = {isa = PBXBuildFile; fileRef = F395C1AF2569C6A000942BFF /* SDL_mfijoystick.m */; };
 		F395C1B92569C6A000942BFF /* SDL_mfijoystick.m in Sources */ = {isa = PBXBuildFile; fileRef = F395C1AF2569C6A000942BFF /* SDL_mfijoystick.m */; };
 		F395C1BA2569C6A000942BFF /* SDL_mfijoystick_c.h in Headers */ = {isa = PBXBuildFile; fileRef = F395C1B02569C6A000942BFF /* SDL_mfijoystick_c.h */; };
@@ -7172,6 +7172,7 @@
 				A7D88ABF23E2437C00DCD162 /* Sources */,
 				A7D88B4623E2437C00DCD162 /* Frameworks */,
 				A75FDB9F23E4CAFA00529352 /* Embed Frameworks */,
+				F3ED8107281DB8E600C33C5B /* Convert SDL includes to SDL Framework includes */,
 			);
 			buildRules = (
 			);
@@ -7193,6 +7194,7 @@
 				A7D88C7823E24BED00DCD162 /* Sources */,
 				A7D88D0423E24BED00DCD162 /* Frameworks */,
 				A75FDBA223E4CAFF00529352 /* Embed Frameworks */,
+				F3ED8108281DB8F200C33C5B /* Convert SDL includes to SDL Framework includes */,
 			);
 			buildRules = (
 			);
@@ -7234,6 +7236,7 @@
 				BECDF62C0761BA81005FE872 /* Sources */,
 				BECDF6680761BA81005FE872 /* Frameworks */,
 				A75FDB9C23E4CAEF00529352 /* Embed Frameworks */,
+				F3ED8106281DB8A500C33C5B /* Convert SDL includes to SDL Framework includes */,
 			);
 			buildRules = (
 			);
@@ -7424,6 +7427,60 @@
 			shellPath = /bin/sh;
 			shellScript = "# Sign framework\nif [ \"$SDL_CODESIGN_IDENTITY\" != \"\" ]; then\n    codesign --force --deep --sign \"$SDL_CODESIGN_IDENTITY\" $TARGET_BUILD_DIR/SDL2.framework/Versions/A || exit $?\nfi\n\n# clean up the framework, remove headers, extra files\nmkdir -p build/dmg-tmp\ncp -a $TARGET_BUILD_DIR/SDL2.framework build/dmg-tmp/\n\ncp pkg-support/resources/License.txt build/dmg-tmp\ncp pkg-support/resources/ReadMe.txt build/dmg-tmp\n\n# remove the .DS_Store files if any (we may want to provide one in the future for fancy .dmgs)\nfind build/dmg-tmp -name .DS_Store -exec rm -f \"{}\" \\;\n\n# for fancy .dmg\nmkdir -p build/dmg-tmp/.logo\ncp pkg-support/resources/SDL_DS_Store build/dmg-tmp/.DS_Store\ncp pkg-support/sdl_logo.pdf build/dmg-tmp/.logo\n\n# create the dmg\nhdiutil create -ov -fs HFS+ -volname SDL2 -srcfolder build/dmg-tmp build/SDL2.dmg\n\n# clean up\nrm -rf build/dmg-tmp\n";
 		};
+		F3ED8106281DB8A500C33C5B /* Convert SDL includes to SDL Framework includes */ = {
+			isa = PBXShellScriptBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputFileListPaths = (
+			);
+			inputPaths = (
+			);
+			name = "Convert SDL includes to SDL Framework includes";
+			outputFileListPaths = (
+			);
+			outputPaths = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "cd \"$BUILT_PRODUCTS_DIR/$PUBLIC_HEADERS_FOLDER_PATH\"\nsed -i '' -e 's,#include \"\\(.*\\)\",#include <SDL2/\\1>,' *.h\n";
+		};
+		F3ED8107281DB8E600C33C5B /* Convert SDL includes to SDL Framework includes */ = {
+			isa = PBXShellScriptBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputFileListPaths = (
+			);
+			inputPaths = (
+			);
+			name = "Convert SDL includes to SDL Framework includes";
+			outputFileListPaths = (
+			);
+			outputPaths = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "cd \"$BUILT_PRODUCTS_DIR/$PUBLIC_HEADERS_FOLDER_PATH\"\nsed -i '' -e 's,#include \"\\(.*\\)\",#include <SDL2/\\1>,' *.h\n";
+		};
+		F3ED8108281DB8F200C33C5B /* Convert SDL includes to SDL Framework includes */ = {
+			isa = PBXShellScriptBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputFileListPaths = (
+			);
+			inputPaths = (
+			);
+			name = "Convert SDL includes to SDL Framework includes";
+			outputFileListPaths = (
+			);
+			outputPaths = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "cd \"$BUILT_PRODUCTS_DIR/$PUBLIC_HEADERS_FOLDER_PATH\"\nsed -i '' -e 's,#include \"\\(.*\\)\",#include <SDL2/\\1>,' *.h\n";
+		};
 /* End PBXShellScriptBuildPhase section */
 
 /* Begin PBXSourcesBuildPhase section */
@@ -9131,6 +9188,7 @@
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
 				CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
 				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
 				CLANG_WARN_BOOL_CONVERSION = YES;
 				CLANG_WARN_COMMA = YES;
@@ -9151,7 +9209,7 @@
 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
 				DEPLOYMENT_POSTPROCESSING = YES;
 				DYLIB_COMPATIBILITY_VERSION = 1.0.0;
-				DYLIB_CURRENT_VERSION = 23.0.0;
+				DYLIB_CURRENT_VERSION = 2301.0.0;
 				DYLIB_INSTALL_NAME_BASE = "@rpath";
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
 				GCC_ALTIVEC_EXTENSIONS = YES;
@@ -9180,7 +9238,7 @@
 					"@executable_path/Frameworks",
 					"@loader_path/Frameworks",
 				);
-				MACOSX_DEPLOYMENT_TARGET = 10.6;
+				MACOSX_DEPLOYMENT_TARGET = 10.7;
 				PRODUCT_BUNDLE_IDENTIFIER = org.libsdl.SDL2;
 				PRODUCT_NAME = SDL2;
 				STRIP_STYLE = "non-global";
@@ -9216,6 +9274,7 @@
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
 				CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
 				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
 				CLANG_WARN_BOOL_CONVERSION = YES;
 				CLANG_WARN_COMMA = YES;
@@ -9235,7 +9294,7 @@
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
 				DEBUG_INFORMATION_FORMAT = dwarf;
 				DYLIB_COMPATIBILITY_VERSION = 1.0.0;
-				DYLIB_CURRENT_VERSION = 23.0.0;
+				DYLIB_CURRENT_VERSION = 2301.0.0;
 				DYLIB_INSTALL_NAME_BASE = "@rpath";
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
 				ENABLE_TESTABILITY = YES;
@@ -9264,7 +9323,7 @@
 					"@executable_path/Frameworks",
 					"@loader_path/Frameworks",
 				);
-				MACOSX_DEPLOYMENT_TARGET = 10.6;
+				MACOSX_DEPLOYMENT_TARGET = 10.7;
 				ONLY_ACTIVE_ARCH = YES;
 				PRODUCT_BUNDLE_IDENTIFIER = org.libsdl.SDL2;
 				PRODUCT_NAME = SDL2;
diff --git a/Engine/lib/sdl/Xcode/SDLTest/SDLTest.xcodeproj/project.pbxproj b/Engine/lib/sdl/Xcode/SDLTest/SDLTest.xcodeproj/project.pbxproj
index 8c524cc54..e7e1d23bc 100644
--- a/Engine/lib/sdl/Xcode/SDLTest/SDLTest.xcodeproj/project.pbxproj
+++ b/Engine/lib/sdl/Xcode/SDLTest/SDLTest.xcodeproj/project.pbxproj
@@ -4041,6 +4041,7 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ENABLE_OBJC_ARC = YES;
 				FRAMEWORK_SEARCH_PATHS = (
 					"$(SRCROOT)/../SDL/build/$(CONFIGURATION)",
 					"$(HOME)/Library/Frameworks",
@@ -4048,7 +4049,7 @@
 				);
 				GCC_OPTIMIZATION_LEVEL = 0;
 				HEADER_SEARCH_PATHS = ../../include;
-				MACOSX_DEPLOYMENT_TARGET = 10.6;
+				MACOSX_DEPLOYMENT_TARGET = 10.7;
 			};
 			name = Debug;
 		};
@@ -4168,6 +4169,7 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ENABLE_OBJC_ARC = YES;
 				FRAMEWORK_SEARCH_PATHS = (
 					"$(SRCROOT)/../SDL/build/$(CONFIGURATION)",
 					"$(HOME)/Library/Frameworks",
@@ -4175,7 +4177,7 @@
 				);
 				GCC_GENERATE_DEBUGGING_SYMBOLS = NO;
 				HEADER_SEARCH_PATHS = ../../include;
-				MACOSX_DEPLOYMENT_TARGET = 10.6;
+				MACOSX_DEPLOYMENT_TARGET = 10.7;
 			};
 			name = Release;
 		};
diff --git a/Engine/lib/sdl/Xcode/SDLTest/TestDropFile-Info.plist b/Engine/lib/sdl/Xcode/SDLTest/TestDropFile-Info.plist
index 03e46b33b..c9f6cb835 100644
--- a/Engine/lib/sdl/Xcode/SDLTest/TestDropFile-Info.plist
+++ b/Engine/lib/sdl/Xcode/SDLTest/TestDropFile-Info.plist
@@ -30,6 +30,6 @@
 	<key>CFBundleVersion</key>
 	<string>1.0</string>
 	<key>LSMinimumSystemVersion</key>
-	<string>10.6</string>
+	<string>10.7</string>
 </dict>
 </plist>
diff --git a/Engine/lib/sdl/android-project-ant/AndroidManifest.xml b/Engine/lib/sdl/android-project-ant/AndroidManifest.xml
deleted file mode 100644
index 94bcaefd0..000000000
--- a/Engine/lib/sdl/android-project-ant/AndroidManifest.xml
+++ /dev/null
@@ -1 +0,0 @@
-../android-project/app/src/main/AndroidManifest.xml
\ No newline at end of file
diff --git a/Engine/lib/sdl/android-project-ant/AndroidManifest.xml b/Engine/lib/sdl/android-project-ant/AndroidManifest.xml
new file mode 120000
index 000000000..94bcaefd0
--- /dev/null
+++ b/Engine/lib/sdl/android-project-ant/AndroidManifest.xml
@@ -0,0 +1 @@
+../android-project/app/src/main/AndroidManifest.xml
\ No newline at end of file
diff --git a/Engine/lib/sdl/android-project-ant/src b/Engine/lib/sdl/android-project-ant/src
deleted file mode 100644
index d5b63ee14..000000000
--- a/Engine/lib/sdl/android-project-ant/src
+++ /dev/null
@@ -1 +0,0 @@
-../android-project/app/src/main/java
\ No newline at end of file
diff --git a/Engine/lib/sdl/android-project-ant/src b/Engine/lib/sdl/android-project-ant/src
new file mode 120000
index 000000000..d5b63ee14
--- /dev/null
+++ b/Engine/lib/sdl/android-project-ant/src
@@ -0,0 +1 @@
+../android-project/app/src/main/java
\ No newline at end of file
diff --git a/Engine/lib/sdl/android-project/gradlew b/Engine/lib/sdl/android-project/gradlew
old mode 100644
new mode 100755
diff --git a/Engine/lib/sdl/autogen.sh b/Engine/lib/sdl/autogen.sh
index daf160de5..dffcf4152 100755
--- a/Engine/lib/sdl/autogen.sh
+++ b/Engine/lib/sdl/autogen.sh
@@ -1,5 +1,7 @@
 #!/bin/sh
 
+set -e
+
 echo "Generating build information using autoconf"
 echo "This may take a while ..."
 
@@ -10,11 +12,7 @@ cd "$srcdir"
 # Regenerate configuration files
 cat acinclude/* >aclocal.m4
 
-if test "$AUTOCONF"x = x; then
-  AUTOCONF=autoconf
-fi
-
-$AUTOCONF || exit 1
+"${AUTOCONF:-autoconf}"
 rm aclocal.m4
 rm -rf autom4te.cache
 
diff --git a/Engine/lib/sdl/build-scripts/androidbuildlibs.sh b/Engine/lib/sdl/build-scripts/androidbuildlibs.sh
index 3e57b4710..dc7217293 100755
--- a/Engine/lib/sdl/build-scripts/androidbuildlibs.sh
+++ b/Engine/lib/sdl/build-scripts/androidbuildlibs.sh
@@ -33,22 +33,21 @@ lib=
 ndk_args=
 
 # Allow an external caller to specify locations.
-for arg in $*
-do
-  if [ "${arg:0:8}" == "NDK_OUT=" ]; then
-	obj=${arg#NDK_OUT=}
-  elif [ "${arg:0:13}" == "NDK_LIBS_OUT=" ]; then
-	lib=${arg#NDK_LIBS_OUT=}
-  else
-    ndk_args="$ndk_args $arg"
-  fi
+for arg in $*; do
+    if [ "${arg:0:8}" == "NDK_OUT=" ]; then
+        obj=${arg#NDK_OUT=}
+    elif [ "${arg:0:13}" == "NDK_LIBS_OUT=" ]; then
+        lib=${arg#NDK_LIBS_OUT=}
+    else
+        ndk_args="$ndk_args $arg"
+    fi
 done
 
 if [ -z $obj ]; then
-  obj=$buildandroid/obj
+    obj=$buildandroid/obj
 fi
 if [ -z $lib ]; then
-  lib=$buildandroid/lib
+    lib=$buildandroid/lib
 fi
 
 for dir in $build $buildandroid $obj $lib; do
@@ -64,11 +63,11 @@ done
 # ndk-build makefile segments that use them, e.g., default-application.mk.
 # For consistency, pass all values on the command line.
 ndk-build \
-  NDK_PROJECT_PATH=null \
-  NDK_OUT=$obj \
-  NDK_LIBS_OUT=$lib \
-  APP_BUILD_SCRIPT=Android.mk \
-  APP_ABI="armeabi-v7a arm64-v8a x86 x86_64" \
-  APP_PLATFORM=android-16 \
-  APP_MODULES="SDL2 SDL2_main" \
-  $ndk_args
+    NDK_PROJECT_PATH=null \
+    NDK_OUT=$obj \
+    NDK_LIBS_OUT=$lib \
+    APP_BUILD_SCRIPT=Android.mk \
+    APP_ABI="armeabi-v7a arm64-v8a x86 x86_64" \
+    APP_PLATFORM=android-16 \
+    APP_MODULES="SDL2 SDL2_main" \
+    $ndk_args
diff --git a/Engine/lib/sdl/build-scripts/clang++-fat.sh b/Engine/lib/sdl/build-scripts/clang++-fat.sh
old mode 100644
new mode 100755
index d337109f9..41fdf1c33
--- a/Engine/lib/sdl/build-scripts/clang++-fat.sh
+++ b/Engine/lib/sdl/build-scripts/clang++-fat.sh
@@ -6,11 +6,11 @@
 
 DEVELOPER="`xcode-select -print-path`/Platforms/MacOSX.platform/Developer"
 
-# Intel 64-bit compiler flags (10.6 runtime compatibility)
-CLANG_COMPILE_X64="clang++ -arch x86_64 -mmacosx-version-min=10.6 \
+# Intel 64-bit compiler flags (10.7 runtime compatibility)
+CLANG_COMPILE_X64="clang++ -arch x86_64 -mmacosx-version-min=10.7 \
 -I/usr/local/include"
 
-CLANG_LINK_X64="-mmacosx-version-min=10.6"
+CLANG_LINK_X64="-mmacosx-version-min=10.7"
 
 # ARM 64-bit compiler flags (11.0 runtime compatibility)
 CLANG_COMPILE_ARM64="clang++ -arch arm64 -mmacosx-version-min=11.0 \
diff --git a/Engine/lib/sdl/build-scripts/clang-fat.sh b/Engine/lib/sdl/build-scripts/clang-fat.sh
old mode 100644
new mode 100755
index 38c07275d..4d1d30a6f
--- a/Engine/lib/sdl/build-scripts/clang-fat.sh
+++ b/Engine/lib/sdl/build-scripts/clang-fat.sh
@@ -6,12 +6,12 @@
 
 DEVELOPER="`xcode-select -print-path`/Platforms/MacOSX.platform/Developer"
 
-# Intel 64-bit compiler flags (10.6 runtime compatibility)
-CLANG_COMPILE_X64="clang -arch x86_64 -mmacosx-version-min=10.6 \
--DMAC_OS_X_VERSION_MIN_REQUIRED=1060 \
+# Intel 64-bit compiler flags (10.7 runtime compatibility)
+CLANG_COMPILE_X64="clang -arch x86_64 -mmacosx-version-min=10.7 \
+-DMAC_OS_X_VERSION_MIN_REQUIRED=1070 \
 -I/usr/local/include"
 
-CLANG_LINK_X64="-mmacosx-version-min=10.6"
+CLANG_LINK_X64="-mmacosx-version-min=10.7"
 
 # ARM 64-bit compiler flags (11.0 runtime compatibility)
 CLANG_COMPILE_ARM64="clang -arch arm64 -mmacosx-version-min=11.0 \
diff --git a/Engine/lib/sdl/build-scripts/codechecker-buildbot.sh b/Engine/lib/sdl/build-scripts/codechecker-buildbot.sh
old mode 100644
new mode 100755
diff --git a/Engine/lib/sdl/build-scripts/config.guess b/Engine/lib/sdl/build-scripts/config.guess
old mode 100644
new mode 100755
index b7806a8cb..160ecf095
--- a/Engine/lib/sdl/build-scripts/config.guess
+++ b/Engine/lib/sdl/build-scripts/config.guess
@@ -4,7 +4,7 @@
 
 # shellcheck disable=SC2006,SC2268 # see below for rationale
 
-timestamp='2022-01-03'
+timestamp='2022-05-08'
 
 # This file is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
@@ -929,6 +929,9 @@ EOF
     i*:PW*:*)
 	GUESS=$UNAME_MACHINE-pc-pw32
 	;;
+    *:SerenityOS:*:*)
+        GUESS=$UNAME_MACHINE-pc-serenity
+        ;;
     *:Interix*:*)
 	case $UNAME_MACHINE in
 	    x86)
@@ -1148,16 +1151,27 @@ EOF
 	;;
     x86_64:Linux:*:*)
 	set_cc_for_build
+	CPU=$UNAME_MACHINE
 	LIBCABI=$LIBC
 	if test "$CC_FOR_BUILD" != no_compiler_found; then
-	    if (echo '#ifdef __ILP32__'; echo IS_X32; echo '#endif') | \
-		(CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
-		grep IS_X32 >/dev/null
-	    then
-		LIBCABI=${LIBC}x32
-	    fi
+	    ABI=64
+	    sed 's/^	    //' << EOF > "$dummy.c"
+	    #ifdef __i386__
+	    ABI=x86
+	    #else
+	    #ifdef __ILP32__
+	    ABI=x32
+	    #endif
+	    #endif
+EOF
+	    cc_set_abi=`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^ABI' | sed 's, ,,g'`
+	    eval "$cc_set_abi"
+	    case $ABI in
+		x86) CPU=i686 ;;
+		x32) LIBCABI=${LIBC}x32 ;;
+	    esac
 	fi
-	GUESS=$UNAME_MACHINE-pc-linux-$LIBCABI
+	GUESS=$CPU-pc-linux-$LIBCABI
 	;;
     xtensa*:Linux:*:*)
 	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
diff --git a/Engine/lib/sdl/build-scripts/config.sub b/Engine/lib/sdl/build-scripts/config.sub
old mode 100644
new mode 100755
diff --git a/Engine/lib/sdl/build-scripts/fnsince.pl b/Engine/lib/sdl/build-scripts/fnsince.pl
old mode 100644
new mode 100755
index 6c69c5473..fde65c862
--- a/Engine/lib/sdl/build-scripts/fnsince.pl
+++ b/Engine/lib/sdl/build-scripts/fnsince.pl
@@ -46,9 +46,15 @@ my @releases = sort {
 
 # this happens to work for how SDL versions things at the moment.
 my $current_release = $releases[-1];
-my @current_release_segments = split /\./, $current_release;
-@current_release_segments[2] = '' . ($current_release_segments[2] + 2);
-my $next_release = join('.', @current_release_segments);
+my $next_release;
+
+if ($current_release eq '2.0.22') {  # Hack for our jump from 2.0.22 to 2.24.0...
+    $next_release = '2.24.0';
+} else {
+    my @current_release_segments = split /\./, $current_release;
+    @current_release_segments[1] = '' . ($current_release_segments[1] + 2);
+    $next_release = join('.', @current_release_segments);
+}
 
 #print("\n\nSORTED\n");
 #foreach (@releases) {
diff --git a/Engine/lib/sdl/build-scripts/gen_audio_resampler_filter.c b/Engine/lib/sdl/build-scripts/gen_audio_resampler_filter.c
new file mode 100644
index 000000000..4a343fb63
--- /dev/null
+++ b/Engine/lib/sdl/build-scripts/gen_audio_resampler_filter.c
@@ -0,0 +1,162 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+/*
+
+Built with:
+
+gcc -o genfilter build-scripts/gen_audio_resampler_filter.c -lm && ./genfilter > src/audio/SDL_audio_resampler_filter.h
+
+ */
+
+/*
+   SDL's resampler uses a "bandlimited interpolation" algorithm:
+     https://ccrma.stanford.edu/~jos/resample/
+
+   This code pre-generates the kaiser tables so we don't have to do this at
+   run time, at a cost of about 20 kilobytes of static data in SDL. This code
+   used to be part of SDL itself and generated the tables on the first use,
+   but that was expensive to produce on platforms without floating point
+   hardware.
+*/
+
+#include <stdio.h>
+#include <math.h>
+
+#define RESAMPLER_ZERO_CROSSINGS 5
+#define RESAMPLER_BITS_PER_SAMPLE 16
+#define RESAMPLER_SAMPLES_PER_ZERO_CROSSING  (1 << ((RESAMPLER_BITS_PER_SAMPLE / 2) + 1))
+#define RESAMPLER_FILTER_SIZE ((RESAMPLER_SAMPLES_PER_ZERO_CROSSING * RESAMPLER_ZERO_CROSSINGS) + 1)
+
+/* This is a "modified" bessel function, so you can't use POSIX j0() */
+static double
+bessel(const double x)
+{
+    const double xdiv2 = x / 2.0;
+    double i0 = 1.0f;
+    double f = 1.0f;
+    int i = 1;
+
+    while (1) {
+        const double diff = pow(xdiv2, i * 2) / pow(f, 2);
+        if (diff < 1.0e-21f) {
+            break;
+        }
+        i0 += diff;
+        i++;
+        f *= (double) i;
+    }
+
+    return i0;
+}
+
+/* build kaiser table with cardinal sine applied to it, and array of differences between elements. */
+static void
+kaiser_and_sinc(float *table, float *diffs, const int tablelen, const double beta)
+{
+    const int lenm1 = tablelen - 1;
+    const int lenm1div2 = lenm1 / 2;
+    int i;
+
+    table[0] = 1.0f;
+    for (i = 1; i < tablelen; i++) {
+        const double kaiser = bessel(beta * sqrt(1.0 - pow(((i - lenm1) / 2.0) / lenm1div2, 2.0))) / bessel(beta);
+        table[tablelen - i] = (float) kaiser;
+    }
+
+    for (i = 1; i < tablelen; i++) {
+        const float x = (((float) i) / ((float) RESAMPLER_SAMPLES_PER_ZERO_CROSSING)) * ((float) M_PI);
+        table[i] *= sinf(x) / x;
+        diffs[i - 1] = table[i] - table[i - 1];
+    }
+    diffs[lenm1] = 0.0f;
+}
+
+
+static float ResamplerFilter[RESAMPLER_FILTER_SIZE];
+static float ResamplerFilterDifference[RESAMPLER_FILTER_SIZE];
+
+static void
+PrepareResampleFilter(void)
+{
+    /* if dB > 50, beta=(0.1102 * (dB - 8.7)), according to Matlab. */
+    const double dB = 80.0;
+    const double beta = 0.1102 * (dB - 8.7);
+    kaiser_and_sinc(ResamplerFilter, ResamplerFilterDifference, RESAMPLER_FILTER_SIZE, beta);
+}
+
+int main(void)
+{
+    int i;
+
+    PrepareResampleFilter();
+
+    printf(
+        "/*\n"
+        "  Simple DirectMedia Layer\n"
+        "  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>\n"
+        "\n"
+        "  This software is provided 'as-is', without any express or implied\n"
+        "  warranty.  In no event will the authors be held liable for any damages\n"
+        "  arising from the use of this software.\n"
+        "\n"
+        "  Permission is granted to anyone to use this software for any purpose,\n"
+        "  including commercial applications, and to alter it and redistribute it\n"
+        "  freely, subject to the following restrictions:\n"
+        "\n"
+        "  1. The origin of this software must not be misrepresented; you must not\n"
+        "     claim that you wrote the original software. If you use this software\n"
+        "     in a product, an acknowledgment in the product documentation would be\n"
+        "     appreciated but is not required.\n"
+        "  2. Altered source versions must be plainly marked as such, and must not be\n"
+        "     misrepresented as being the original software.\n"
+        "  3. This notice may not be removed or altered from any source distribution.\n"
+        "*/\n"
+        "\n"
+        "/* DO NOT EDIT, THIS FILE WAS GENERATED BY build-scripts/gen_audio_resampler_filter.c */\n"
+        "\n"
+        "#define RESAMPLER_ZERO_CROSSINGS %d\n"
+        "#define RESAMPLER_BITS_PER_SAMPLE %d\n"
+        "#define RESAMPLER_SAMPLES_PER_ZERO_CROSSING (1 << ((RESAMPLER_BITS_PER_SAMPLE / 2) + 1))\n"
+        "#define RESAMPLER_FILTER_SIZE ((RESAMPLER_SAMPLES_PER_ZERO_CROSSING * RESAMPLER_ZERO_CROSSINGS) + 1)\n"
+        "\n", RESAMPLER_ZERO_CROSSINGS, RESAMPLER_BITS_PER_SAMPLE
+    );
+
+    printf("static const float ResamplerFilter[RESAMPLER_FILTER_SIZE] = {\n");
+    printf("    %.9ff", ResamplerFilter[0]);
+    for (i = 0; i < RESAMPLER_FILTER_SIZE-1; i++) {
+        printf("%s%.9ff", ((i % 5) == 4) ? ",\n    " : ", ", ResamplerFilter[i+1]);
+    }
+    printf("\n};\n\n");
+
+    printf("static const float ResamplerFilterDifference[RESAMPLER_FILTER_SIZE] = {\n");
+    printf("    %.9ff", ResamplerFilterDifference[0]);
+    for (i = 0; i < RESAMPLER_FILTER_SIZE-1; i++) {
+        printf("%s%.9ff", ((i % 5) == 4) ? ",\n    " : ", ", ResamplerFilterDifference[i+1]);
+    }
+    printf("\n};\n\n");
+    printf("/* vi: set ts=4 sw=4 expandtab: */\n\n");
+
+    return 0;
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
+
diff --git a/Engine/lib/sdl/build-scripts/git-pre-push-hook.pl b/Engine/lib/sdl/build-scripts/git-pre-push-hook.pl
old mode 100644
new mode 100755
diff --git a/Engine/lib/sdl/build-scripts/ltmain.sh b/Engine/lib/sdl/build-scripts/ltmain.sh
old mode 100755
new mode 100644
diff --git a/Engine/lib/sdl/build-scripts/update-copyright.sh b/Engine/lib/sdl/build-scripts/update-copyright.sh
index ea1f79875..c69ec7293 100755
--- a/Engine/lib/sdl/build-scripts/update-copyright.sh
+++ b/Engine/lib/sdl/build-scripts/update-copyright.sh
@@ -1,8 +1,7 @@
 #!/bin/sh
 
-find . -type f -exec grep -Il "Copyright" {} \;     \
-| grep -v \.git                             \
-| while read file;                            \
-do \
-  LC_ALL=C sed -b -i "s/\(.*Copyright.*\)[0-9]\{4\}\( *Sam Lantinga\)/\1`date +%Y`\2/" "$file"; \
+find . -type f -exec grep -Il "Copyright" {} \; \
+| grep -v \.git                                 \
+| while read file; do                           \
+    LC_ALL=C sed -b -i "s/\(.*Copyright.*\)[0-9]\{4\}\( *Sam Lantinga\)/\1`date +%Y`\2/" "$file"; \
 done
diff --git a/Engine/lib/sdl/build-scripts/wikiheaders.pl b/Engine/lib/sdl/build-scripts/wikiheaders.pl
old mode 100644
new mode 100755
diff --git a/Engine/lib/sdl/build-scripts/winrtbuild.ps1 b/Engine/lib/sdl/build-scripts/winrtbuild.ps1
index 892658014..b61981ac2 100644
--- a/Engine/lib/sdl/build-scripts/winrtbuild.ps1
+++ b/Engine/lib/sdl/build-scripts/winrtbuild.ps1
@@ -39,7 +39,7 @@
 #
 
 # Base version of SDL, used for packaging purposes
-$SDLVersion = "2.0.22"
+$SDLVersion = "2.23.0"
 
 # Gets the .bat file that sets up an MSBuild environment, given one of
 # Visual Studio's, "PlatformToolset"s.
diff --git a/Engine/lib/sdl/cmake/sdlchecks.cmake b/Engine/lib/sdl/cmake/sdlchecks.cmake
index 8dcb39265..de0059387 100644
--- a/Engine/lib/sdl/cmake/sdlchecks.cmake
+++ b/Engine/lib/sdl/cmake/sdlchecks.cmake
@@ -393,7 +393,7 @@ endmacro()
 # - HAVE_SDL_LOADSO opt
 macro(CheckX11)
   if(SDL_X11)
-    foreach(_LIB X11 Xext Xcursor Xinerama Xi Xfixes Xrandr Xrender Xss Xxf86vm)
+    foreach(_LIB X11 Xext Xcursor Xi Xfixes Xrandr Xrender Xss)
         FindLibraryAndSONAME("${_LIB}")
     endforeach()
 
@@ -415,7 +415,6 @@ macro(CheckX11)
     endif()
 
     check_include_file(X11/Xcursor/Xcursor.h HAVE_XCURSOR_H)
-    check_include_file(X11/extensions/Xinerama.h HAVE_XINERAMA_H)
     check_include_file(X11/extensions/XInput2.h HAVE_XINPUT2_H)
     check_include_file(X11/extensions/Xrandr.h HAVE_XRANDR_H)
     check_include_file(X11/extensions/Xfixes.h HAVE_XFIXES_H_)
@@ -423,7 +422,6 @@ macro(CheckX11)
     check_include_file(X11/extensions/scrnsaver.h HAVE_XSS_H)
     check_include_file(X11/extensions/shape.h HAVE_XSHAPE_H)
     check_include_files("X11/Xlib.h;X11/extensions/Xdbe.h" HAVE_XDBE_H)
-    check_include_files("X11/Xlib.h;X11/extensions/xf86vmode.h" HAVE_XF86VM_H)
     check_include_files("X11/Xlib.h;X11/Xproto.h;X11/extensions/Xext.h" HAVE_XEXT_H)
 
     if(X11_LIB)
@@ -504,16 +502,6 @@ macro(CheckX11)
         set(SDL_VIDEO_DRIVER_X11_XDBE 1)
       endif()
 
-      if(SDL_X11_XINERAMA AND HAVE_XINERAMA_H)
-        set(HAVE_X11_XINERAMA TRUE)
-        if(HAVE_X11_SHARED AND XINERAMA_LIB)
-          set(SDL_VIDEO_DRIVER_X11_DYNAMIC_XINERAMA "\"${XINERAMA_LIB_SONAME}\"")
-        else()
-          list(APPEND EXTRA_LIBS ${XINERAMA_LIB})
-        endif()
-        set(SDL_VIDEO_DRIVER_X11_XINERAMA 1)
-      endif()
-
       if(SDL_X11_XINPUT AND HAVE_XINPUT2_H)
         set(HAVE_X11_XINPUT TRUE)
         if(HAVE_X11_SHARED AND XI_LIB)
@@ -584,16 +572,6 @@ macro(CheckX11)
         set(HAVE_X11_XSHAPE TRUE)
       endif()
 
-      if(SDL_X11_XVM AND HAVE_XF86VM_H)
-        if(HAVE_X11_SHARED AND XXF86VM_LIB)
-          set(SDL_VIDEO_DRIVER_X11_DYNAMIC_XVIDMODE "\"${XXF86VM_LIB_SONAME}\"")
-        else()
-          list(APPEND EXTRA_LIBS ${XXF86VM_LIB})
-        endif()
-        set(SDL_VIDEO_DRIVER_X11_XVIDMODE 1)
-        set(HAVE_X11_XVM TRUE)
-      endif()
-
       set(CMAKE_REQUIRED_LIBRARIES)
     endif()
   endif()
@@ -733,7 +711,6 @@ macro(CheckCOCOA)
     endif()
     if(HAVE_COCOA)
       file(GLOB COCOA_SOURCES ${SDL2_SOURCE_DIR}/src/video/cocoa/*.m)
-      set_source_files_properties(${COCOA_SOURCES} PROPERTIES LANGUAGE C)
       set(SOURCE_FILES ${SOURCE_FILES} ${COCOA_SOURCES})
       set(SDL_VIDEO_DRIVER_COCOA 1)
       set(HAVE_SDL_VIDEO TRUE)
diff --git a/Engine/lib/sdl/configure b/Engine/lib/sdl/configure
index f3ea813eb..3943176a0 100755
--- a/Engine/lib/sdl/configure
+++ b/Engine/lib/sdl/configure
@@ -878,13 +878,11 @@ with_x
 enable_x11_shared
 enable_video_x11_xcursor
 enable_video_x11_xdbe
-enable_video_x11_xinerama
 enable_video_x11_xinput
 enable_video_x11_xfixes
 enable_video_x11_xrandr
 enable_video_x11_scrnsaver
 enable_video_x11_xshape
-enable_video_x11_vm
 enable_video_vivante
 enable_video_cocoa
 enable_video_metal
@@ -1668,8 +1666,6 @@ Optional Features:
   --enable-video-x11-xcursor
                           enable X11 Xcursor support [default=yes]
   --enable-video-x11-xdbe enable X11 Xdbe support [default=yes]
-  --enable-video-x11-xinerama
-                          enable X11 Xinerama support [default=yes]
   --enable-video-x11-xinput
                           enable X11 XInput extension for manymouse, tablets,
                           etc [default=yes]
@@ -1682,7 +1678,6 @@ Optional Features:
                           enable X11 screensaver extension [default=yes]
   --enable-video-x11-xshape
                           enable X11 XShape support [default=yes]
-  --enable-video-x11-vm   use X11 VM extension for fullscreen [default=yes]
   --enable-video-vivante  use Vivante EGL video driver [default=yes]
   --enable-video-cocoa    use Cocoa video driver [default=yes]
   --enable-video-metal    include Metal support [default=yes]
@@ -2854,23 +2849,22 @@ ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
 
 orig_CFLAGS="$CFLAGS"
 
-#
-# Making releases:
-# Edit include/SDL_version.h and change the version, then:
-#   SDL_MICRO_VERSION += 1;
-#   SDL_INTERFACE_AGE += 1;
-#   SDL_BINARY_AGE += 1;
-# if any functions have been added, set SDL_INTERFACE_AGE to 0.
-# if backwards compatibility has been broken,
-# set SDL_BINARY_AGE and SDL_INTERFACE_AGE to 0.
-#
+# See docs/release_checklist.md
 SDL_MAJOR_VERSION=2
-SDL_MINOR_VERSION=0
-SDL_MICRO_VERSION=22
-SDL_INTERFACE_AGE=0
-SDL_BINARY_AGE=22
+SDL_MINOR_VERSION=23
+SDL_MICRO_VERSION=0
 SDL_VERSION=$SDL_MAJOR_VERSION.$SDL_MINOR_VERSION.$SDL_MICRO_VERSION
 
+SDL_BINARY_AGE=`expr $SDL_MINOR_VERSION \* 100 + $SDL_MICRO_VERSION`
+case "$SDL_MINOR_VERSION" in #(
+  *[02468]) :
+        SDL_INTERFACE_AGE="$SDL_MICRO_VERSION" ;; #(
+  *) :
+        SDL_INTERFACE_AGE=0 ;; #(
+  *) :
+     ;;
+esac
+
 
 
 
@@ -12259,10 +12253,17 @@ CC=$lt_save_CC
 CFLAGS=$lt_save_CFLAGS
 
 
-LT_RELEASE=$SDL_MAJOR_VERSION.$SDL_MINOR_VERSION
-LT_CURRENT=`expr $SDL_MICRO_VERSION - $SDL_INTERFACE_AGE`
-LT_REVISION=$SDL_INTERFACE_AGE
+# For historical reasons, the library name redundantly includes the major
+# version twice: libSDL2-2.0.so.0.
+# TODO: in SDL 3, stop using -release, which will simplify it to libSDL3.so.0
+LT_RELEASE=2.0
+# Increment this if there is an incompatible change - but if that happens,
+# we should rename the library from SDL2 to SDL3, at which point this would
+# reset to 0 anyway.
+LT_MAJOR=0
 LT_AGE=`expr $SDL_BINARY_AGE - $SDL_INTERFACE_AGE`
+LT_CURRENT=`expr $LT_MAJOR + $LT_AGE`
+LT_REVISION=$SDL_INTERFACE_AGE
 
 
 
@@ -16968,6 +16969,22 @@ $as_echo "#define SDL_DEFAULT_ASSERT_LEVEL 3" >>confdefs.h
         ;;
 esac
 
+
+cat >>confdefs.h <<_ACEOF
+#define SDL_BUILD_MAJOR_VERSION $SDL_MAJOR_VERSION
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define SDL_BUILD_MINOR_VERSION $SDL_MINOR_VERSION
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define SDL_BUILD_MICRO_VERSION $SDL_MICRO_VERSION
+_ACEOF
+
+
 # Check whether --enable-dependency-tracking was given.
 if test "${enable_dependency_tracking+set}" = set; then :
   enableval=$enable_dependency_tracking;
@@ -17717,7 +17734,7 @@ fi
 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
 
-    for ac_func in malloc calloc realloc free getenv setenv putenv unsetenv qsort abs bcopy memset memcpy memmove wcslen wcslcpy wcslcat _wcsdup wcsdup wcsstr wcscmp wcsncmp wcscasecmp _wcsicmp wcsncasecmp _wcsnicmp strlen strlcpy strlcat _strrev _strupr _strlwr index rindex strchr strrchr strstr strtok_r itoa _ltoa _uitoa _ultoa strtol strtoul _i64toa _ui64toa strtoll strtoull atoi atof strcmp strncmp _stricmp strcasecmp _strnicmp strncasecmp vsscanf vsnprintf fopen64 fseeko fseeko64 sigaction setjmp nanosleep sysconf sysctlbyname getauxval elf_aux_info poll _Exit
+    for ac_func in malloc calloc realloc free getenv setenv putenv unsetenv bsearch qsort abs bcopy memset memcpy memmove wcslen wcslcpy wcslcat _wcsdup wcsdup wcsstr wcscmp wcsncmp wcscasecmp _wcsicmp wcsncasecmp _wcsnicmp strlen strlcpy strlcat _strrev _strupr _strlwr index rindex strchr strrchr strstr strtok_r itoa _ltoa _uitoa _ultoa strtol strtoul _i64toa _ui64toa strtoll strtoull atoi atof strcmp strncmp _stricmp strcasecmp _strnicmp strncasecmp vsscanf vsnprintf fopen64 fseeko fseeko64 sigaction setjmp nanosleep sysconf sysctlbyname getauxval elf_aux_info poll _Exit
 do :
   as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
 ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
@@ -18229,9 +18246,6 @@ if test x$enable_assembly = xyes; then
     SUMMARY_modules="${SUMMARY_modules} assembly"
 
 
-$as_echo "#define SDL_ASSEMBLY_ROUTINES 1" >>confdefs.h
-
-
     # Make sure that we don't generate floating point code that would
     # cause illegal instruction exceptions on older processors
     case "$host" in
@@ -20368,6 +20382,40 @@ $as_echo "#define SDL_ARM_NEON_BLITTERS 1" >>confdefs.h
     fi
 }
 
+CheckObjectiveCARC()
+{
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for clang -fobjc-arc option" >&5
+$as_echo_n "checking for clang -fobjc-arc option... " >&6; }
+    have_clang_objc_arc=no
+
+    save_CFLAGS="$CFLAGS"
+    CFLAGS="$save_CFLAGS -fobjc-arc"
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+    int x = 0;
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  have_clang_objc_arc=yes
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_clang_objc_arc" >&5
+$as_echo "$have_clang_objc_arc" >&6; }
+    CFLAGS="$save_CFLAGS"
+
+    if test x$have_clang_objc_arc = xyes; then
+        EXTRA_CFLAGS="$EXTRA_CFLAGS -fobjc-arc"
+    fi
+}
+
 CheckVisibilityHidden()
 {
     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GCC -fvisibility=hidden option" >&5
@@ -21741,37 +21789,31 @@ fi
                     x11_lib='/opt/X11/lib/libX11.6.dylib'
                     x11ext_lib='/opt/X11/lib/libXext.6.dylib'
                     xcursor_lib='/opt/X11/lib/libXcursor.1.dylib'
-                    xinerama_lib='/opt/X11/lib/libXinerama.1.dylib'
                     xinput_lib='/opt/X11/lib/libXi.6.dylib'
                     xfixes_lib='/opt/X11/lib/libXfixes.3.dylib'
                     xrandr_lib='/opt/X11/lib/libXrandr.2.dylib'
                     xrender_lib='/opt/X11/lib/libXrender.1.dylib'
                     xss_lib='/opt/X11/lib/libXss.1.dylib'
-                    xvidmode_lib='/opt/X11/lib/libXxf86vm.1.dylib'
                     ;;
                 *-*-openbsd*)
                     x11_lib='libX11.so'
                     x11ext_lib='libXext.so'
                     xcursor_lib='libXcursor.so'
-                    xinerama_lib='libXinerama.so'
                     xinput_lib='libXi.so'
                     xfixes_lib='libXfixes.so'
                     xrandr_lib='libXrandr.so'
                     xrender_lib='libXrender.so'
                     xss_lib='libXss.so'
-                    xvidmode_lib='libXxf86vm.so'
                     ;;
                 *)
                     x11_lib=`find_lib "libX11.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`
                     x11ext_lib=`find_lib "libXext.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`
                     xcursor_lib=`find_lib "libXcursor.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`
-                    xinerama_lib=`find_lib "libXinerama.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`
                     xinput_lib=`find_lib "libXi.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`
                     xfixes_lib=`find_lib "libXfixes.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`
                     xrandr_lib=`find_lib "libXrandr.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`
                     xrender_lib=`find_lib "libXrender.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`
                     xss_lib=`find_lib "libXss.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`
-                    xvidmode_lib=`find_lib "libXxf86vm.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`
                     ;;
             esac
 
@@ -22023,88 +22065,6 @@ $as_echo "#define SDL_VIDEO_DRIVER_X11_XDBE 1" >>confdefs.h
                     SUMMARY_video_x11="${SUMMARY_video_x11} xdbe"
                 fi
             fi
-            # Check whether --enable-video-x11-xinerama was given.
-if test "${enable_video_x11_xinerama+set}" = set; then :
-  enableval=$enable_video_x11_xinerama;
-else
-  enable_video_x11_xinerama=yes
-fi
-
-            if test x$enable_video_x11_xinerama = xyes; then
-                definitely_enable_video_x11_xinerama=no
-                ac_fn_c_check_header_compile "$LINENO" "X11/extensions/Xinerama.h" "ac_cv_header_X11_extensions_Xinerama_h" "#include <X11/Xlib.h>
-
-"
-if test "x$ac_cv_header_X11_extensions_Xinerama_h" = xyes; then :
-  have_xinerama_h_hdr=yes
-else
-  have_xinerama_h_hdr=no
-fi
-
-
-                if test x$have_xinerama_h_hdr = xyes; then
-                    if test x$enable_x11_shared = xyes && test x$xinerama_lib != x ; then
-                        echo "-- dynamic libXinerama -> $xinerama_lib"
-
-cat >>confdefs.h <<_ACEOF
-#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XINERAMA "$xinerama_lib"
-_ACEOF
-
-                        definitely_enable_video_x11_xinerama=yes
-                    else
-                        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XineramaQueryExtension in -lXinerama" >&5
-$as_echo_n "checking for XineramaQueryExtension in -lXinerama... " >&6; }
-if ${ac_cv_lib_Xinerama_XineramaQueryExtension+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  ac_check_lib_save_LIBS=$LIBS
-LIBS="-lXinerama  $LIBS"
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-/* Override any GCC internal prototype to avoid an error.
-   Use char because int might match the return type of a GCC
-   builtin and then its argument prototype would still apply.  */
-#ifdef __cplusplus
-extern "C"
-#endif
-char XineramaQueryExtension ();
-int
-main ()
-{
-return XineramaQueryExtension ();
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"; then :
-  ac_cv_lib_Xinerama_XineramaQueryExtension=yes
-else
-  ac_cv_lib_Xinerama_XineramaQueryExtension=no
-fi
-rm -f core conftest.err conftest.$ac_objext \
-    conftest$ac_exeext conftest.$ac_ext
-LIBS=$ac_check_lib_save_LIBS
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_Xinerama_XineramaQueryExtension" >&5
-$as_echo "$ac_cv_lib_Xinerama_XineramaQueryExtension" >&6; }
-if test "x$ac_cv_lib_Xinerama_XineramaQueryExtension" = xyes; then :
-  have_xinerama_lib=yes
-fi
-
-                        if test x$have_xinerama_lib = xyes ; then
-                            EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lXinerama"
-                            definitely_enable_video_x11_xinerama=yes
-                        fi
-                    fi
-                fi
-            fi
-            if test x$definitely_enable_video_x11_xinerama = xyes; then
-
-$as_echo "#define SDL_VIDEO_DRIVER_X11_XINERAMA 1" >>confdefs.h
-
-                SUMMARY_video_x11="${SUMMARY_video_x11} xinerama"
-            fi
             # Check whether --enable-video-x11-xinput was given.
 if test "${enable_video_x11_xinput+set}" = set; then :
   enableval=$enable_video_x11_xinput;
@@ -22517,88 +22477,6 @@ $as_echo "#define SDL_VIDEO_DRIVER_X11_XSHAPE 1" >>confdefs.h
                     SUMMARY_video_x11="${SUMMARY_video_x11} xshape"
                 fi
             fi
-            # Check whether --enable-video-x11-vm was given.
-if test "${enable_video_x11_vm+set}" = set; then :
-  enableval=$enable_video_x11_vm;
-else
-  enable_video_x11_vm=yes
-fi
-
-            if test x$enable_video_x11_vm = xyes; then
-                definitely_enable_video_x11_vm=no
-                ac_fn_c_check_header_compile "$LINENO" "X11/extensions/xf86vmode.h" "ac_cv_header_X11_extensions_xf86vmode_h" "#include <X11/Xlib.h>
-
-"
-if test "x$ac_cv_header_X11_extensions_xf86vmode_h" = xyes; then :
-  have_vm_h_hdr=yes
-else
-  have_vm_h_hdr=no
-fi
-
-
-                if test x$have_vm_h_hdr = xyes; then
-                    if test x$enable_x11_shared = xyes && test x$xvidmode_lib != x ; then
-                        echo "-- dynamic libXxf86vm -> $xvidmode_lib"
-
-cat >>confdefs.h <<_ACEOF
-#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XVIDMODE "$xvidmode_lib"
-_ACEOF
-
-                        definitely_enable_video_x11_vm=yes
-                    else
-                        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XF86VidModeQueryVersion in -lXxf86vm" >&5
-$as_echo_n "checking for XF86VidModeQueryVersion in -lXxf86vm... " >&6; }
-if ${ac_cv_lib_Xxf86vm_XF86VidModeQueryVersion+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  ac_check_lib_save_LIBS=$LIBS
-LIBS="-lXxf86vm  $LIBS"
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-/* Override any GCC internal prototype to avoid an error.
-   Use char because int might match the return type of a GCC
-   builtin and then its argument prototype would still apply.  */
-#ifdef __cplusplus
-extern "C"
-#endif
-char XF86VidModeQueryVersion ();
-int
-main ()
-{
-return XF86VidModeQueryVersion ();
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"; then :
-  ac_cv_lib_Xxf86vm_XF86VidModeQueryVersion=yes
-else
-  ac_cv_lib_Xxf86vm_XF86VidModeQueryVersion=no
-fi
-rm -f core conftest.err conftest.$ac_objext \
-    conftest$ac_exeext conftest.$ac_ext
-LIBS=$ac_check_lib_save_LIBS
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_Xxf86vm_XF86VidModeQueryVersion" >&5
-$as_echo "$ac_cv_lib_Xxf86vm_XF86VidModeQueryVersion" >&6; }
-if test "x$ac_cv_lib_Xxf86vm_XF86VidModeQueryVersion" = xyes; then :
-  have_vm_lib=yes
-fi
-
-                        if test x$have_vm_lib = xyes ; then
-                            EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lXxf86vm"
-                            definitely_enable_video_x11_vm=yes
-                        fi
-                    fi
-                fi
-            fi
-            if test x$definitely_enable_video_x11_vm = xyes; then
-
-$as_echo "#define SDL_VIDEO_DRIVER_X11_XVIDMODE 1" >>confdefs.h
-
-                SUMMARY_video_x11="${SUMMARY_video_x11} xvidmode"
-            fi
         fi
     fi
     if test x$have_x != xyes; then
@@ -26607,6 +26485,7 @@ $as_echo "#define SDL_VIDEO_RENDER_OGL_ES2 1" >>confdefs.h
         EXTRA_CFLAGS="$EXTRA_CFLAGS -DTARGET_API_MAC_CARBON"
         EXTRA_CFLAGS="$EXTRA_CFLAGS -DTARGET_API_MAC_OSX"
 
+        CheckObjectiveCARC
         CheckVisibilityHidden
         CheckDeclarationAfterStatement
         CheckDummyVideo
diff --git a/Engine/lib/sdl/configure.ac b/Engine/lib/sdl/configure.ac
index 2209c04d7..87cdcf327 100644
--- a/Engine/lib/sdl/configure.ac
+++ b/Engine/lib/sdl/configure.ac
@@ -10,23 +10,21 @@ dnl Save the CFLAGS to see whether they were passed in or generated
 orig_CFLAGS="$CFLAGS"
 
 dnl Set various version strings - taken gratefully from the GTk sources
-#
-# Making releases:
-# Edit include/SDL_version.h and change the version, then:
-#   SDL_MICRO_VERSION += 1;
-#   SDL_INTERFACE_AGE += 1;
-#   SDL_BINARY_AGE += 1;
-# if any functions have been added, set SDL_INTERFACE_AGE to 0.
-# if backwards compatibility has been broken,
-# set SDL_BINARY_AGE and SDL_INTERFACE_AGE to 0.
-#
+# See docs/release_checklist.md
 SDL_MAJOR_VERSION=2
-SDL_MINOR_VERSION=0
-SDL_MICRO_VERSION=22
-SDL_INTERFACE_AGE=0
-SDL_BINARY_AGE=22
+SDL_MINOR_VERSION=23
+SDL_MICRO_VERSION=0
 SDL_VERSION=$SDL_MAJOR_VERSION.$SDL_MINOR_VERSION.$SDL_MICRO_VERSION
 
+SDL_BINARY_AGE=`expr $SDL_MINOR_VERSION \* 100 + $SDL_MICRO_VERSION`
+AS_CASE(["$SDL_MINOR_VERSION"],
+  [*@<:@02468@:>@],
+    dnl Stable branch, 2.24.1 -> libSDL2-2.0.so.0.2400.1
+    [SDL_INTERFACE_AGE="$SDL_MICRO_VERSION"],
+  [*],
+    dnl Development branch, 2.23.1 -> libSDL2-2.0.so.0.2301.0
+    [SDL_INTERFACE_AGE=0])
+
 AC_SUBST(SDL_MAJOR_VERSION)
 AC_SUBST(SDL_MINOR_VERSION)
 AC_SUBST(SDL_MICRO_VERSION)
@@ -38,10 +36,17 @@ AC_SUBST(SDL_VERSION)
 LT_INIT([win32-dll])
 LT_LANG([Windows Resource])
 
-LT_RELEASE=$SDL_MAJOR_VERSION.$SDL_MINOR_VERSION
-LT_CURRENT=`expr $SDL_MICRO_VERSION - $SDL_INTERFACE_AGE`
-LT_REVISION=$SDL_INTERFACE_AGE
+# For historical reasons, the library name redundantly includes the major
+# version twice: libSDL2-2.0.so.0.
+# TODO: in SDL 3, stop using -release, which will simplify it to libSDL3.so.0
+LT_RELEASE=2.0
+# Increment this if there is an incompatible change - but if that happens,
+# we should rename the library from SDL2 to SDL3, at which point this would
+# reset to 0 anyway.
+LT_MAJOR=0
 LT_AGE=`expr $SDL_BINARY_AGE - $SDL_INTERFACE_AGE`
+LT_CURRENT=`expr $LT_MAJOR + $LT_AGE`
+LT_REVISION=$SDL_INTERFACE_AGE
 m4_pattern_allow([^LT_])
 
 AC_SUBST(LT_RELEASE)
@@ -218,6 +223,10 @@ case "$enable_assertions" in
         ;;
 esac
 
+AC_DEFINE_UNQUOTED([SDL_BUILD_MAJOR_VERSION], $SDL_MAJOR_VERSION, [ ])
+AC_DEFINE_UNQUOTED([SDL_BUILD_MINOR_VERSION], $SDL_MINOR_VERSION, [ ])
+AC_DEFINE_UNQUOTED([SDL_BUILD_MICRO_VERSION], $SDL_MICRO_VERSION, [ ])
+
 dnl See whether we can use gcc style dependency tracking
 AC_ARG_ENABLE(dependency-tracking,
 [AS_HELP_STRING([--enable-dependency-tracking],
@@ -337,7 +346,7 @@ dnl Checks for library functions.
         AC_DEFINE(HAVE_MPROTECT, 1, [ ])
         ],[]),
     )
-    AC_CHECK_FUNCS(malloc calloc realloc free getenv setenv putenv unsetenv qsort abs bcopy memset memcpy memmove wcslen wcslcpy wcslcat _wcsdup wcsdup wcsstr wcscmp wcsncmp wcscasecmp _wcsicmp wcsncasecmp _wcsnicmp strlen strlcpy strlcat _strrev _strupr _strlwr index rindex strchr strrchr strstr strtok_r itoa _ltoa _uitoa _ultoa strtol strtoul _i64toa _ui64toa strtoll strtoull atoi atof strcmp strncmp _stricmp strcasecmp _strnicmp strncasecmp vsscanf vsnprintf fopen64 fseeko fseeko64 sigaction setjmp nanosleep sysconf sysctlbyname getauxval elf_aux_info poll _Exit)
+    AC_CHECK_FUNCS(malloc calloc realloc free getenv setenv putenv unsetenv bsearch qsort abs bcopy memset memcpy memmove wcslen wcslcpy wcslcat _wcsdup wcsdup wcsstr wcscmp wcsncmp wcscasecmp _wcsicmp wcsncasecmp _wcsnicmp strlen strlcpy strlcat _strrev _strupr _strlwr index rindex strchr strrchr strstr strtok_r itoa _ltoa _uitoa _ultoa strtol strtoul _i64toa _ui64toa strtoll strtoull atoi atof strcmp strncmp _stricmp strcasecmp _strnicmp strncasecmp vsscanf vsnprintf fopen64 fseeko fseeko64 sigaction setjmp nanosleep sysconf sysctlbyname getauxval elf_aux_info poll _Exit)
 
     AC_CHECK_LIB(m, pow, [LIBS="$LIBS -lm"; EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lm"])
     AC_CHECK_FUNCS(acos acosf asin asinf atan atanf atan2 atan2f ceil ceilf copysign copysignf cos cosf exp expf fabs fabsf floor floorf trunc truncf fmod fmodf log logf log10 log10f lround lroundf pow powf round roundf scalbn scalbnf sin sinf sqrt sqrtf tan tanf)
@@ -574,8 +583,6 @@ AC_ARG_ENABLE(assembly,
 if test x$enable_assembly = xyes; then
     SUMMARY_modules="${SUMMARY_modules} assembly"
 
-    AC_DEFINE(SDL_ASSEMBLY_ROUTINES, 1, [ ])
-
     # Make sure that we don't generate floating point code that would
     # cause illegal instruction exceptions on older processors
     case "$host" in
@@ -1423,6 +1430,26 @@ CheckNEON()
     fi
 }
 
+dnl See if clang's -fobjc-arc supported.
+dnl  Reference: https://github.com/libsdl-org/SDL/pull/5632
+CheckObjectiveCARC()
+{
+    AC_MSG_CHECKING(for clang -fobjc-arc option)
+    have_clang_objc_arc=no
+
+    save_CFLAGS="$CFLAGS"
+    CFLAGS="$save_CFLAGS -fobjc-arc"
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+    int x = 0;
+    ]],[])], [have_clang_objc_arc=yes],[])
+    AC_MSG_RESULT($have_clang_objc_arc)
+    CFLAGS="$save_CFLAGS"
+
+    if test x$have_clang_objc_arc = xyes; then
+        EXTRA_CFLAGS="$EXTRA_CFLAGS -fobjc-arc"
+    fi
+}
+
 dnl See if GCC's -fvisibility=hidden is supported (gcc4 and later, usually).
 dnl  Details of this flag are here: http://gcc.gnu.org/wiki/Visibility
 CheckVisibilityHidden()
@@ -1768,37 +1795,31 @@ CheckX11()
                     x11_lib='/opt/X11/lib/libX11.6.dylib'
                     x11ext_lib='/opt/X11/lib/libXext.6.dylib'
                     xcursor_lib='/opt/X11/lib/libXcursor.1.dylib'
-                    xinerama_lib='/opt/X11/lib/libXinerama.1.dylib'
                     xinput_lib='/opt/X11/lib/libXi.6.dylib'
                     xfixes_lib='/opt/X11/lib/libXfixes.3.dylib'
                     xrandr_lib='/opt/X11/lib/libXrandr.2.dylib'
                     xrender_lib='/opt/X11/lib/libXrender.1.dylib'
                     xss_lib='/opt/X11/lib/libXss.1.dylib'
-                    xvidmode_lib='/opt/X11/lib/libXxf86vm.1.dylib'
                     ;;
                 *-*-openbsd*)
                     x11_lib='libX11.so'
                     x11ext_lib='libXext.so'
                     xcursor_lib='libXcursor.so'
-                    xinerama_lib='libXinerama.so'
                     xinput_lib='libXi.so'
                     xfixes_lib='libXfixes.so'
                     xrandr_lib='libXrandr.so'
                     xrender_lib='libXrender.so'
                     xss_lib='libXss.so'
-                    xvidmode_lib='libXxf86vm.so'
                     ;;
                 *)
                     x11_lib=[`find_lib "libX11.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`]
                     x11ext_lib=[`find_lib "libXext.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`]
                     xcursor_lib=[`find_lib "libXcursor.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`]
-                    xinerama_lib=[`find_lib "libXinerama.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`]
                     xinput_lib=[`find_lib "libXi.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`]
                     xfixes_lib=[`find_lib "libXfixes.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`]
                     xrandr_lib=[`find_lib "libXrandr.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`]
                     xrender_lib=[`find_lib "libXrender.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`]
                     xss_lib=[`find_lib "libXss.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`]
-                    xvidmode_lib=[`find_lib "libXxf86vm.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`]
                     ;;
             esac
 
@@ -1910,34 +1931,6 @@ XFreeEventData(display, cookie);
                     SUMMARY_video_x11="${SUMMARY_video_x11} xdbe"
                 fi
             fi
-            AC_ARG_ENABLE(video-x11-xinerama,
-[AS_HELP_STRING([--enable-video-x11-xinerama], [enable X11 Xinerama support [default=yes]])],
-                            , enable_video_x11_xinerama=yes)
-            if test x$enable_video_x11_xinerama = xyes; then
-                definitely_enable_video_x11_xinerama=no
-                AC_CHECK_HEADER(X11/extensions/Xinerama.h,
-                                have_xinerama_h_hdr=yes,
-                                have_xinerama_h_hdr=no,
-                                [#include <X11/Xlib.h>
-                                ])
-                if test x$have_xinerama_h_hdr = xyes; then
-                    if test x$enable_x11_shared = xyes && test x$xinerama_lib != x ; then
-                        echo "-- dynamic libXinerama -> $xinerama_lib"
-                        AC_DEFINE_UNQUOTED(SDL_VIDEO_DRIVER_X11_DYNAMIC_XINERAMA, "$xinerama_lib", [ ])
-                        definitely_enable_video_x11_xinerama=yes
-                    else
-                        AC_CHECK_LIB(Xinerama, XineramaQueryExtension, have_xinerama_lib=yes)
-                        if test x$have_xinerama_lib = xyes ; then
-                            EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lXinerama"
-                            definitely_enable_video_x11_xinerama=yes
-                        fi
-                    fi
-                fi
-            fi
-            if test x$definitely_enable_video_x11_xinerama = xyes; then
-                AC_DEFINE(SDL_VIDEO_DRIVER_X11_XINERAMA, 1, [ ])
-                SUMMARY_video_x11="${SUMMARY_video_x11} xinerama"
-            fi
             AC_ARG_ENABLE(video-x11-xinput,
 [AS_HELP_STRING([--enable-video-x11-xinput], [enable X11 XInput extension for manymouse, tablets, etc [default=yes]])],
                             , enable_video_x11_xinput=yes)
@@ -2087,34 +2080,6 @@ dnl             XRRScreenResources is only present in Xrandr >= 1.2, we use that
                     SUMMARY_video_x11="${SUMMARY_video_x11} xshape"
                 fi
             fi
-            AC_ARG_ENABLE(video-x11-vm,
-[AS_HELP_STRING([--enable-video-x11-vm], [use X11 VM extension for fullscreen [default=yes]])],
-                            , enable_video_x11_vm=yes)
-            if test x$enable_video_x11_vm = xyes; then
-                definitely_enable_video_x11_vm=no
-                AC_CHECK_HEADER(X11/extensions/xf86vmode.h,
-                                have_vm_h_hdr=yes,
-                                have_vm_h_hdr=no,
-                                [#include <X11/Xlib.h>
-                                ])
-                if test x$have_vm_h_hdr = xyes; then
-                    if test x$enable_x11_shared = xyes && test x$xvidmode_lib != x ; then
-                        echo "-- dynamic libXxf86vm -> $xvidmode_lib"
-                        AC_DEFINE_UNQUOTED(SDL_VIDEO_DRIVER_X11_DYNAMIC_XVIDMODE, "$xvidmode_lib", [ ])
-                        definitely_enable_video_x11_vm=yes
-                    else
-                        AC_CHECK_LIB(Xxf86vm, XF86VidModeQueryVersion, have_vm_lib=yes)
-                        if test x$have_vm_lib = xyes ; then
-                            EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lXxf86vm"
-                            definitely_enable_video_x11_vm=yes
-                        fi
-                    fi
-                fi
-            fi
-            if test x$definitely_enable_video_x11_vm = xyes; then
-                AC_DEFINE(SDL_VIDEO_DRIVER_X11_XVIDMODE, 1, [ ])
-                SUMMARY_video_x11="${SUMMARY_video_x11} xvidmode"
-            fi
         fi
     fi
     if test x$have_x != xyes; then
@@ -4250,6 +4215,7 @@ dnl BeOS support removed after SDL 2.0.1. Haiku still works.  --ryan.
         EXTRA_CFLAGS="$EXTRA_CFLAGS -DTARGET_API_MAC_CARBON"
         EXTRA_CFLAGS="$EXTRA_CFLAGS -DTARGET_API_MAC_OSX"
 
+        CheckObjectiveCARC
         CheckVisibilityHidden
         CheckDeclarationAfterStatement
         CheckDummyVideo
diff --git a/Engine/lib/sdl/docs/README-linux.md b/Engine/lib/sdl/docs/README-linux.md
index 230bad963..342130f1f 100644
--- a/Engine/lib/sdl/docs/README-linux.md
+++ b/Engine/lib/sdl/docs/README-linux.md
@@ -3,8 +3,8 @@ Linux
 
 By default SDL will only link against glibc, the rest of the features will be
 enabled dynamically at runtime depending on the available features on the target
-system. So, for example if you built SDL with Xinerama support and the target
-system does not have the Xinerama libraries installed, it will be disabled
+system. So, for example if you built SDL with XRandR support and the target
+system does not have the XRandR libraries installed, it will be disabled
 at runtime, and you won't get a missing library error, at least with the 
 default configuration parameters.
 
@@ -17,7 +17,7 @@ Ubuntu 20.04, all available features enabled:
     sudo apt-get install build-essential git make cmake autoconf automake \
     libtool pkg-config libasound2-dev libpulse-dev libaudio-dev libjack-dev \
     libx11-dev libxext-dev libxrandr-dev libxcursor-dev libxfixes-dev libxi-dev \
-    libxinerama-dev libxxf86vm-dev libxss-dev libgl1-mesa-dev libdbus-1-dev \
+    libxss-dev libgl1-mesa-dev libdbus-1-dev \
     libudev-dev libgles2-mesa-dev libegl1-mesa-dev libibus-1.0-dev \
     fcitx-libs-dev libsamplerate0-dev libsndio-dev libwayland-dev \
     libxkbcommon-dev libdrm-dev libgbm-dev
@@ -27,12 +27,11 @@ Fedora 35, all available features enabled:
     sudo yum install gcc git-core make cmake autoconf automake libtool \
     alsa-lib-devel pulseaudio-libs-devel nas-devel pipewire-devel \
     libX11-devel libXext-devel libXrandr-devel libXcursor-devel libXfixes-devel \
-    libXi-devel libXinerama-devel libXxf86vm-devel libXScrnSaver-devel \
-    dbus-devel ibus-devel fcitx-devel systemd-devel mesa-libGL-devel \
-    libxkbcommon-devel mesa-libGLES-devel mesa-libEGL-devel vulkan-devel \
-    wayland-devel wayland-protocols-devel libdrm-devel mesa-libgbm-devel \
-    libusb-devel pipewire-jack-audio-connection-kit-devel libdecor-devel \
-    libsamplerate-devel
+    libXi-devel libXScrnSaver-devel dbus-devel ibus-devel fcitx-devel \
+    systemd-devel mesa-libGL-devel libxkbcommon-devel mesa-libGLES-devel \
+    mesa-libEGL-devel vulkan-devel wayland-devel wayland-protocols-devel \
+    libdrm-devel mesa-libgbm-devel libusb-devel libdecor-devel \
+    libsamplerate-devel pipewire-jack-audio-connection-kit-devel \
 
 NOTES:
 - This includes all the audio targets except arts and esd, because Ubuntu
diff --git a/Engine/lib/sdl/docs/README-macos.md b/Engine/lib/sdl/docs/README-macos.md
index d7bc98afd..2f9067917 100644
--- a/Engine/lib/sdl/docs/README-macos.md
+++ b/Engine/lib/sdl/docs/README-macos.md
@@ -43,15 +43,14 @@ make
 sudo make install
 ```
 
-This script builds SDL with 10.6 ABI compatibility on 64-bit Intel and 11.0
+This script builds SDL with 10.7 ABI compatibility on 64-bit Intel and 11.0
 ABI compatibility on ARM64 architectures.  For best compatibility you
 should compile your application the same way.
 
-Please note that building SDL requires at least Xcode 4.6 and the 10.7 SDK
-(even if you target back to 10.6 systems). PowerPC support for Mac OS X has
-been officially dropped as of SDL 2.0.2. 32-bit Intel, using an older Xcode
-release, is still supported at the time of this writing, but current Xcode
-releases no longer support it, and eventually neither will SDL.
+Please note that building SDL requires at least Xcode 4.6 and the 10.7 SDK.
+PowerPC support for macOS has been officially dropped as of SDL 2.0.2.
+32-bit Intel and macOS 10.6 runtime support has been officially dropped as
+of SDL 2.24.0.
 
 To use the library once it's built, you essential have two possibilities:
 use the traditional autoconf/automake/make method, or use Xcode.
diff --git a/Engine/lib/sdl/docs/README-ngage.md b/Engine/lib/sdl/docs/README-ngage.md
new file mode 100644
index 000000000..83c2e3384
--- /dev/null
+++ b/Engine/lib/sdl/docs/README-ngage.md
@@ -0,0 +1,44 @@
+Nokia N-Gage
+============
+
+SDL2 port for Symbian S60v1 and v2 with a main focus on the Nokia N-Gage
+(Classic and QD) by [Michael Fitzmayer](https://github.com/mupfdev).
+
+Compiling
+---------
+
+SDL is part of the [N-Gage SDK.](https://github.com/ngagesdk) project.
+The library is included in the
+[toolchain](https://github.com/ngagesdk/ngage-toolchain) as a
+sub-module.
+
+A complete example project based on SDL2 can be found in the GitHub
+account of the SDK: [Wordle](https://github.com/ngagesdk/wordle).
+
+Current level of implementation
+-------------------------------
+
+The video driver currently provides full screen video support with
+keyboard input.
+
+At the moment only the software renderer works.
+
+Audio is not yet implemented.
+
+Acknowledgements
+----------------
+
+Thanks to Hannu Viitala, Kimmo Kinnunen and Markus Mertama for the
+valuable insight into Symbian programming.  Without the SDL 1.2 port
+which was specially developed for CDoom (Doom for the Nokia 9210), this
+adaptation would not have been possible.
+
+I would like to thank my friends
+[Razvan](https://twitter.com/bewarerazvan) and [Dan
+Whelan](https://danwhelan.ie/), for their continuous support.  Without
+you and the [N-Gage community](https://discord.gg/dbUzqJ26vs), I would
+have lost my patience long ago.
+
+Last but not least, I would like to thank the development team of
+[EKA2L1](https://12z1.com/) (an experimental Symbian OS emulator). Your
+patience and support in troubleshooting helped me a lot.
diff --git a/Engine/lib/sdl/docs/README-raspberrypi.md b/Engine/lib/sdl/docs/README-raspberrypi.md
index 6a85c3cf4..762dd38c0 100644
--- a/Engine/lib/sdl/docs/README-raspberrypi.md
+++ b/Engine/lib/sdl/docs/README-raspberrypi.md
@@ -63,7 +63,7 @@ Now, before chrooting into the ARM sysroot, you'll need to apply a workaround,
 edit $SYSROOT/etc/ld.so.preload and comment out all lines in it.
 
     sudo chroot $SYSROOT
-    apt-get install libudev-dev libasound2-dev libdbus-1-dev libraspberrypi0 libraspberrypi-bin libraspberrypi-dev libx11-dev libxext-dev libxrandr-dev libxcursor-dev libxi-dev libxinerama-dev libxxf86vm-dev libxss-dev
+    apt-get install libudev-dev libasound2-dev libdbus-1-dev libraspberrypi0 libraspberrypi-bin libraspberrypi-dev libx11-dev libxext-dev libxrandr-dev libxcursor-dev libxi-dev libxss-dev
     exit
     sudo umount $SYSROOT/dev
     sudo umount $SYSROOT/proc
diff --git a/Engine/lib/sdl/docs/README-versions.md b/Engine/lib/sdl/docs/README-versions.md
new file mode 100644
index 000000000..097dba1c7
--- /dev/null
+++ b/Engine/lib/sdl/docs/README-versions.md
@@ -0,0 +1,60 @@
+# Versioning
+
+## Since 2.23.0
+
+SDL follows an "odd/even" versioning policy, similar to GLib, GTK, Flatpak
+and older versions of the Linux kernel:
+
+* The major version (first part) increases when backwards compatibility
+    is broken, which will happen infrequently.
+
+* If the minor version (second part) is divisible by 2
+    (for example 2.24.x, 2.26.x), this indicates a version of SDL that
+    is believed to be stable and suitable for production use.
+
+    * In stable releases, the patchlevel or micro version (third part)
+        indicates bugfix releases. Bugfix releases should not add or
+        remove ABI, so the ".0" release (for example 2.24.0) should be
+        forwards-compatible with all the bugfix releases from the
+        same cycle (for example 2.24.1).
+
+    * The minor version increases when new API or ABI is added, or when
+        other significant changes are made. Newer minor versions are
+        backwards-compatible, but not fully forwards-compatible.
+        For example, programs built against SDL 2.24.x should work fine
+        with SDL 2.26.x, but programs built against SDL 2.26.x will not
+        necessarily work with 2.24.x.
+
+* If the minor version (second part) is not divisible by 2
+    (for example 2.23.x, 2.25.x), this indicates a development prerelease
+    of SDL that is not suitable for stable software distributions.
+    Use with caution.
+
+    * The patchlevel or micro version (third part) increases with
+        each prerelease.
+
+    * Each prerelease might add new API and/or ABI.
+
+    * Prereleases are backwards-compatible with older stable branches.
+        For example, 2.25.x will be backwards-compatible with 2.24.x.
+
+    * Prereleases are not guaranteed to be backwards-compatible with
+        each other. For example, new API or ABI added in 2.25.1
+        might be removed or changed in 2.25.2.
+        If this would be a problem for you, please do not use prereleases.
+
+    * Only upgrade to a prerelease if you can guarantee that you will
+        promptly upgrade to the stable release that follows it.
+        For example, do not upgrade to 2.23.x unless you will be able to
+        upgrade to 2.24.0 when it becomes available.
+
+    * Software distributions that have a freeze policy (in particular Linux
+        distributions with a release cycle, such as Debian and Fedora)
+        should usually only package stable releases, and not prereleases.
+
+## Before 2.23.0
+
+Older versions of SDL followed a similar policy, but instead of the
+odd/even rule applying to the minor version, it applied to the patchlevel
+(micro version, third part). For example, 2.0.22 was a stable release
+and 2.0.21 was a prerelease.
diff --git a/Engine/lib/sdl/docs/README.md b/Engine/lib/sdl/docs/README.md
index b1b969a79..0a94122e9 100644
--- a/Engine/lib/sdl/docs/README.md
+++ b/Engine/lib/sdl/docs/README.md
@@ -47,10 +47,12 @@ More documentation and FAQs are available online at [the wiki](http://wiki.libsd
 - [PSP](README-psp.md)
 - [Raspberry Pi](README-raspberrypi.md)
 - [Touch](README-touch.md)
+- [Versions](README-versions.md)
 - [WinCE](README-wince.md)
 - [Windows](README-windows.md)
 - [WinRT](README-winrt.md)
 - [PSVita](README-vita.md)
+- [Nokia N-Gage](README-ngage.md)
 
 If you need help with the library, or just want to discuss SDL related
 issues, you can join the [SDL Discourse](https://discourse.libsdl.org/),
diff --git a/Engine/lib/sdl/docs/doxyfile b/Engine/lib/sdl/docs/doxyfile
index baf1c98de..7b80a3a8d 100644
--- a/Engine/lib/sdl/docs/doxyfile
+++ b/Engine/lib/sdl/docs/doxyfile
@@ -640,6 +640,7 @@ EXCLUDE                = ../include/SDL_opengles2_gl2ext.h \
                          ../include/SDL_opengles.h \
                          ../include/SDL_opengl.h \
                          ../include/SDL_egl.h \
+                         ./release_checklist.md \
 
 
 # The EXCLUDE_SYMLINKS tag can be used select whether or not files or 
diff --git a/Engine/lib/sdl/docs/release_checklist.md b/Engine/lib/sdl/docs/release_checklist.md
new file mode 100644
index 000000000..bb38f4fec
--- /dev/null
+++ b/Engine/lib/sdl/docs/release_checklist.md
@@ -0,0 +1,91 @@
+# Release checklist
+
+## New feature release
+
+* Update `WhatsNew.txt`
+
+* Bump version number to 2.EVEN.0 in all these locations:
+
+    * `configure.ac`, `CMakeLists.txt`: `SDL_*_VERSION`
+    * `Xcode/SDL/Info-Framework.plist`: `CFBundleShortVersionString`,
+        `CFBundleVersion`
+    * `Makefile.os2`: `VERSION`
+    * `build-scripts/winrtbuild.ps1`: `$SDLVersion`
+    * `include/SDL_version.h`: `SDL_*_VERSION`, `SDL_PATCHLEVEL`
+    * `src/main/windows/version.rc`: `FILEVERSION`, `PRODUCTVERSION`,
+        `FileVersion`, `ProductVersion`
+
+* Bump ABI version information
+
+    * `CMakeLists.txt`, `Xcode/SDL/SDL.xcodeproj/project.pbxproj`:
+        `DYLIB_CURRENT_VERSION`, `DYLIB_COMPATIBILITY_VERSION`
+        * set first number in `DYLIB_CURRENT_VERSION` to
+            (100 * *minor*) + 1
+        * set second number in `DYLIB_CURRENT_VERSION` to 0
+        * if backwards compatibility has been broken,
+            increase `DYLIB_COMPATIBILITY_VERSION` (?)
+
+* Run test/versioning.sh to verify that everything is consistent
+
+* Regenerate `configure`
+
+* Do the release
+
+## New bugfix release
+
+* Check that no new API/ABI was added
+
+    * If it was, do a new feature release (see above) instead
+
+* Bump version number from 2.Y.Z to 2.Y.(Z+1) (Y is even)
+
+    * Same places as listed above
+
+* Bump ABI version information
+
+    * `CMakeLists.txt`, `Xcode/SDL/SDL.xcodeproj/project.pbxproj`:
+        `DYLIB_CURRENT_VERSION`, `DYLIB_COMPATIBILITY_VERSION`
+        * set second number in `DYLIB_CURRENT_VERSION` to *patchlevel*
+
+* Run test/versioning.sh to verify that everything is consistent
+
+* Regenerate `configure`
+
+* Do the release
+
+## After a feature release
+
+* Create a branch like `release-2.24.x`
+
+* Bump version number to 2.ODD.0 for next development branch
+
+    * Same places as listed above
+
+* Bump ABI version information
+
+    * Same places as listed above
+    * Assume that the next feature release will contain new API/ABI
+
+* Run test/versioning.sh to verify that everything is consistent
+
+## New development prerelease
+
+* Bump version number from 2.Y.Z to 2.Y.(Z+1) (Y is odd)
+
+    * Same places as listed above
+
+* Bump ABI version information
+
+    * `CMakeLists.txt`, `Xcode/SDL/SDL.xcodeproj/project.pbxproj`:
+        `DYLIB_CURRENT_VERSION`, `DYLIB_COMPATIBILITY_VERSION`
+        * set first number in `DYLIB_CURRENT_VERSION` to
+            (100 * *minor*) + *patchlevel* + 1
+        * set second number in `DYLIB_CURRENT_VERSION` to 0
+        * if backwards compatibility has been broken,
+            increase `DYLIB_COMPATIBILITY_VERSION` (?)
+
+* Run test/versioning.sh to verify that everything is consistent
+
+* Regenerate `configure`
+
+* Do the release
diff --git a/Engine/lib/sdl/include/SDL_assert.h b/Engine/lib/sdl/include/SDL_assert.h
index defadf137..427c4c633 100644
--- a/Engine/lib/sdl/include/SDL_assert.h
+++ b/Engine/lib/sdl/include/SDL_assert.h
@@ -22,7 +22,7 @@
 #ifndef SDL_assert_h_
 #define SDL_assert_h_
 
-#include "SDL_config.h"
+#include "SDL_stdinc.h"
 
 #include "begin_code.h"
 /* Set up for C function definitions, even when using C++ */
@@ -51,6 +51,8 @@ assert can have unique static variables associated with it.
 /* Don't include intrin.h here because it contains C++ code */
     extern void __cdecl __debugbreak(void);
     #define SDL_TriggerBreakpoint() __debugbreak()
+#elif _SDL_HAS_BUILTIN(__builtin_debugtrap)
+    #define SDL_TriggerBreakpoint() __builtin_debugtrap()
 #elif ( (!defined(__NACL__)) && ((defined(__GNUC__) || defined(__clang__)) && (defined(__i386__) || defined(__x86_64__))) )
     #define SDL_TriggerBreakpoint() __asm__ __volatile__ ( "int $3\n\t" )
 #elif ( defined(__APPLE__) && (defined(__arm64__) || defined(__aarch64__)) )  /* this might work on other ARM targets, but this is a known quantity... */
diff --git a/Engine/lib/sdl/include/SDL_config.h b/Engine/lib/sdl/include/SDL_config.h
index 7afefabe2..749988515 100644
--- a/Engine/lib/sdl/include/SDL_config.h
+++ b/Engine/lib/sdl/include/SDL_config.h
@@ -43,6 +43,8 @@
 #include "SDL_config_os2.h"
 #elif defined(__EMSCRIPTEN__)
 #include "SDL_config_emscripten.h"
+#elif defined(__NGAGE__)
+#include "SDL_config_ngage.h"
 #else
 /* This is a minimal configuration just to get SDL running on new platforms. */
 #include "SDL_config_minimal.h"
diff --git a/Engine/lib/sdl/include/SDL_config.h.cmake b/Engine/lib/sdl/include/SDL_config.h.cmake
index fcd18e57d..9e058218d 100644
--- a/Engine/lib/sdl/include/SDL_config.h.cmake
+++ b/Engine/lib/sdl/include/SDL_config.h.cmake
@@ -88,6 +88,7 @@
 #cmakedefine HAVE_UNSETENV 1
 #endif
 #cmakedefine HAVE_QSORT 1
+#cmakedefine HAVE_BSEARCH 1
 #cmakedefine HAVE_ABS 1
 #cmakedefine HAVE_BCOPY 1
 #cmakedefine HAVE_MEMSET 1
@@ -420,22 +421,18 @@
 #cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC @SDL_VIDEO_DRIVER_X11_DYNAMIC@
 #cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT @SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT@
 #cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XCURSOR @SDL_VIDEO_DRIVER_X11_DYNAMIC_XCURSOR@
-#cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XINERAMA @SDL_VIDEO_DRIVER_X11_DYNAMIC_XINERAMA@
 #cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT2 @SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT2@
 #cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XFIXES @SDL_VIDEO_DRIVER_X11_DYNAMIC_XFIXES@
 #cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR @SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR@
 #cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XSS @SDL_VIDEO_DRIVER_X11_DYNAMIC_XSS@
-#cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XVIDMODE @SDL_VIDEO_DRIVER_X11_DYNAMIC_XVIDMODE@
 #cmakedefine SDL_VIDEO_DRIVER_X11_XCURSOR @SDL_VIDEO_DRIVER_X11_XCURSOR@
 #cmakedefine SDL_VIDEO_DRIVER_X11_XDBE @SDL_VIDEO_DRIVER_X11_XDBE@
-#cmakedefine SDL_VIDEO_DRIVER_X11_XINERAMA @SDL_VIDEO_DRIVER_X11_XINERAMA@
 #cmakedefine SDL_VIDEO_DRIVER_X11_XINPUT2 @SDL_VIDEO_DRIVER_X11_XINPUT2@
 #cmakedefine SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH @SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH@
 #cmakedefine SDL_VIDEO_DRIVER_X11_XFIXES @SDL_VIDEO_DRIVER_X11_XFIXES@
 #cmakedefine SDL_VIDEO_DRIVER_X11_XRANDR @SDL_VIDEO_DRIVER_X11_XRANDR@
 #cmakedefine SDL_VIDEO_DRIVER_X11_XSCRNSAVER @SDL_VIDEO_DRIVER_X11_XSCRNSAVER@
 #cmakedefine SDL_VIDEO_DRIVER_X11_XSHAPE @SDL_VIDEO_DRIVER_X11_XSHAPE@
-#cmakedefine SDL_VIDEO_DRIVER_X11_XVIDMODE @SDL_VIDEO_DRIVER_X11_XVIDMODE@
 #cmakedefine SDL_VIDEO_DRIVER_X11_SUPPORTS_GENERIC_EVENTS @SDL_VIDEO_DRIVER_X11_SUPPORTS_GENERIC_EVENTS@
 #cmakedefine SDL_VIDEO_DRIVER_X11_HAS_XKBKEYCODETOKEYSYM @SDL_VIDEO_DRIVER_X11_HAS_XKBKEYCODETOKEYSYM@
 #cmakedefine SDL_VIDEO_DRIVER_VITA @SDL_VIDEO_DRIVER_VITA@
@@ -501,7 +498,6 @@
 #cmakedefine SDL_LOCALE_DUMMY @SDL_LOCALE_DUMMY@
 
 /* Enable assembly routines */
-#cmakedefine SDL_ASSEMBLY_ROUTINES @SDL_ASSEMBLY_ROUTINES@
 #cmakedefine SDL_ALTIVEC_BLITTERS @SDL_ALTIVEC_BLITTERS@
 #cmakedefine SDL_ARM_SIMD_BLITTERS @SDL_ARM_SIMD_BLITTERS@
 #cmakedefine SDL_ARM_NEON_BLITTERS @SDL_ARM_NEON_BLITTERS@
diff --git a/Engine/lib/sdl/include/SDL_config.h.in b/Engine/lib/sdl/include/SDL_config.h.in
index f912e4112..cd322ce87 100644
--- a/Engine/lib/sdl/include/SDL_config.h.in
+++ b/Engine/lib/sdl/include/SDL_config.h.in
@@ -92,6 +92,7 @@
 #undef HAVE_UNSETENV
 #endif
 #undef HAVE_QSORT
+#undef HAVE_BSEARCH
 #undef HAVE_ABS
 #undef HAVE_BCOPY
 #undef HAVE_MEMSET
@@ -387,22 +388,18 @@
 #undef SDL_VIDEO_DRIVER_X11_DYNAMIC
 #undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT
 #undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XCURSOR
-#undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XINERAMA
 #undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT2
 #undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XFIXES
 #undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR
 #undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XSS
-#undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XVIDMODE
 #undef SDL_VIDEO_DRIVER_X11_XCURSOR
 #undef SDL_VIDEO_DRIVER_X11_XDBE
-#undef SDL_VIDEO_DRIVER_X11_XINERAMA
 #undef SDL_VIDEO_DRIVER_X11_XINPUT2
 #undef SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH
 #undef SDL_VIDEO_DRIVER_X11_XFIXES
 #undef SDL_VIDEO_DRIVER_X11_XRANDR
 #undef SDL_VIDEO_DRIVER_X11_XSCRNSAVER
 #undef SDL_VIDEO_DRIVER_X11_XSHAPE
-#undef SDL_VIDEO_DRIVER_X11_XVIDMODE
 #undef SDL_VIDEO_DRIVER_X11_SUPPORTS_GENERIC_EVENTS
 #undef SDL_VIDEO_DRIVER_X11_HAS_XKBKEYCODETOKEYSYM
 #undef SDL_VIDEO_DRIVER_NACL
@@ -468,7 +465,6 @@
 #undef SDL_LOCALE_DUMMY
 
 /* Enable assembly routines */
-#undef SDL_ASSEMBLY_ROUTINES
 #undef SDL_ALTIVEC_BLITTERS
 #undef SDL_ARM_SIMD_BLITTERS
 #undef SDL_ARM_NEON_BLITTERS
diff --git a/Engine/lib/sdl/include/SDL_config_android.h b/Engine/lib/sdl/include/SDL_config_android.h
index 4a13a3a53..5a9cfc045 100644
--- a/Engine/lib/sdl/include/SDL_config_android.h
+++ b/Engine/lib/sdl/include/SDL_config_android.h
@@ -60,6 +60,7 @@
 #define HAVE_SETENV 1
 #define HAVE_UNSETENV   1
 #define HAVE_QSORT  1
+#define HAVE_BSEARCH 1
 #define HAVE_ABS    1
 #define HAVE_BCOPY  1
 #define HAVE_MEMSET 1
diff --git a/Engine/lib/sdl/include/SDL_config_emscripten.h b/Engine/lib/sdl/include/SDL_config_emscripten.h
index 028777df1..989e1243a 100644
--- a/Engine/lib/sdl/include/SDL_config_emscripten.h
+++ b/Engine/lib/sdl/include/SDL_config_emscripten.h
@@ -69,6 +69,7 @@
 #define HAVE_PUTENV 1
 #define HAVE_UNSETENV 1
 #define HAVE_QSORT 1
+#define HAVE_BSEARCH 1
 #define HAVE_ABS 1
 #define HAVE_BCOPY 1
 #define HAVE_MEMSET 1
diff --git a/Engine/lib/sdl/include/SDL_config_iphoneos.h b/Engine/lib/sdl/include/SDL_config_iphoneos.h
index 0aa242563..48f9f9f9b 100644
--- a/Engine/lib/sdl/include/SDL_config_iphoneos.h
+++ b/Engine/lib/sdl/include/SDL_config_iphoneos.h
@@ -60,6 +60,7 @@
 #define HAVE_SETENV 1
 #define HAVE_UNSETENV   1
 #define HAVE_QSORT  1
+#define HAVE_BSEARCH 1
 #define HAVE_ABS    1
 #define HAVE_BCOPY  1
 #define HAVE_MEMSET 1
@@ -117,7 +118,7 @@
 #define HAVE_LROUNDF 1
 #define HAVE_POW    1
 #define HAVE_POWF   1
-#define HAVE_ROUND 1
+#define HAVE_ROUND  1
 #define HAVE_ROUNDF 1
 #define HAVE_SCALBN 1
 #define HAVE_SCALBNF    1
diff --git a/Engine/lib/sdl/include/SDL_config_macosx.h b/Engine/lib/sdl/include/SDL_config_macosx.h
index ff42e3d5f..023ecaae3 100644
--- a/Engine/lib/sdl/include/SDL_config_macosx.h
+++ b/Engine/lib/sdl/include/SDL_config_macosx.h
@@ -63,6 +63,7 @@
 #define HAVE_PUTENV 1
 #define HAVE_UNSETENV   1
 #define HAVE_QSORT  1
+#define HAVE_BSEARCH 1
 #define HAVE_ABS    1
 #define HAVE_BCOPY  1
 #define HAVE_MEMSET 1
@@ -120,7 +121,7 @@
 #define HAVE_LROUNDF 1
 #define HAVE_POW    1
 #define HAVE_POWF   1
-#define HAVE_ROUND 1
+#define HAVE_ROUND  1
 #define HAVE_ROUNDF 1
 #define HAVE_SCALBN 1
 #define HAVE_SCALBNF    1
@@ -185,17 +186,13 @@
 #undef SDL_VIDEO_DRIVER_X11
 #define SDL_VIDEO_DRIVER_X11_DYNAMIC "/opt/X11/lib/libX11.6.dylib"
 #define SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT "/opt/X11/lib/libXext.6.dylib"
-#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XINERAMA "/opt/X11/lib/libXinerama.1.dylib"
 #define SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT2 "/opt/X11/lib/libXi.6.dylib"
 #define SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR "/opt/X11/lib/libXrandr.2.dylib"
 #define SDL_VIDEO_DRIVER_X11_DYNAMIC_XSS "/opt/X11/lib/libXss.1.dylib"
-#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XVIDMODE "/opt/X11/lib/libXxf86vm.1.dylib"
 #define SDL_VIDEO_DRIVER_X11_XDBE 1
-#define SDL_VIDEO_DRIVER_X11_XINERAMA 1
 #define SDL_VIDEO_DRIVER_X11_XRANDR 1
 #define SDL_VIDEO_DRIVER_X11_XSCRNSAVER 1
 #define SDL_VIDEO_DRIVER_X11_XSHAPE 1
-#define SDL_VIDEO_DRIVER_X11_XVIDMODE 1
 #define SDL_VIDEO_DRIVER_X11_HAS_XKBKEYCODETOKEYSYM 1
 
 #ifdef MAC_OS_X_VERSION_10_8
@@ -272,7 +269,6 @@
 #define SDL_FILESYSTEM_COCOA   1
 
 /* Enable assembly routines */
-#define SDL_ASSEMBLY_ROUTINES   1
 #ifdef __ppc__
 #define SDL_ALTIVEC_BLITTERS    1
 #endif
diff --git a/Engine/lib/sdl/include/SDL_config_ngage.h b/Engine/lib/sdl/include/SDL_config_ngage.h
new file mode 100644
index 000000000..a9d2d37ab
--- /dev/null
+++ b/Engine/lib/sdl/include/SDL_config_ngage.h
@@ -0,0 +1,89 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_config_ngage_h_
+#define SDL_config_ngage_h_
+#define SDL_config_h_
+
+#include "SDL_platform.h"
+
+typedef signed char        int8_t;
+typedef unsigned char      uint8_t;
+typedef signed short       int16_t;
+typedef unsigned short     uint16_t;
+typedef signed int         int32_t;
+typedef unsigned int       uint32_t;
+typedef signed long long   int64_t;
+typedef unsigned long long uint64_t;
+typedef unsigned long      uintptr_t;
+
+#define HAVE_STDARG_H    1
+#define HAVE_STDDEF_H    1
+#define HAVE_STDIO_H     1
+#define HAVE_STDLIB_H    1
+#define HAVE_MATH_H      1
+#define HAVE_CEIL        1
+#define HAVE_COPYSIGN    1
+#define HAVE_COS         1
+#define HAVE_EXP         1
+#define HAVE_FABS        1
+#define HAVE_FLOOR       1
+#define HAVE_LOG         1
+#define HAVE_LOG10       1
+#define HAVE_SCALBN      1
+#define HAVE_SIN         1
+#define HAVE_SQRT        1
+#define HAVE_TAN         1
+#define HAVE_MALLOC      1
+#define SDL_MAIN_NEEDED  1
+#define LACKS_SYS_MMAN_H 1
+
+/* Enable the N-Gage thread support (src/thread/ngage/\*.c) */
+#define SDL_THREAD_NGAGE 1
+
+/* Enable the N-Gage timer support (src/timer/ngage/\*.c) */
+#define SDL_TIMER_NGAGE  1
+
+/* Enable the N-Gage video driver (src/video/ngage/\*.c) */
+#define SDL_VIDEO_DRIVER_NGAGE 1
+
+/* Enable the dummy audio driver (src/audio/dummy/\*.c) */
+#define SDL_AUDIO_DRIVER_DUMMY  1
+
+/* Enable the stub joystick driver (src/joystick/dummy/\*.c) */
+#define SDL_JOYSTICK_DISABLED   1
+
+/* Enable the stub haptic driver (src/haptic/dummy/\*.c) */
+#define SDL_HAPTIC_DISABLED 1
+
+/* Enable the stub HIDAPI */
+#define SDL_HIDAPI_DISABLED 1
+
+/* Enable the stub sensor driver (src/sensor/dummy/\*.c) */
+#define SDL_SENSOR_DISABLED 1
+
+/* Enable the stub shared object loader (src/loadso/dummy/\*.c) */
+#define SDL_LOADSO_DISABLED 1
+
+/* Enable the dummy filesystem driver (src/filesystem/dummy/\*.c) */
+#define SDL_FILESYSTEM_DUMMY 1
+
+#endif /* SDL_config_ngage_h_ */
diff --git a/Engine/lib/sdl/include/SDL_config_os2.h b/Engine/lib/sdl/include/SDL_config_os2.h
index 1728bd772..1583245ee 100644
--- a/Engine/lib/sdl/include/SDL_config_os2.h
+++ b/Engine/lib/sdl/include/SDL_config_os2.h
@@ -56,9 +56,6 @@
 #define SDL_TIMER_OS2 1
 #define SDL_FILESYSTEM_OS2 1
 
-/* Enable assembly routines */
-#define SDL_ASSEMBLY_ROUTINES 1
-
 /* use libsamplerate for audio rate conversion. */
 /*#define HAVE_LIBSAMPLERATE_H 1 */
 
@@ -105,7 +102,11 @@
 #define HAVE_GETENV 1
 #define HAVE_SETENV 1
 #define HAVE_PUTENV 1
+/* OpenWatcom requires specific calling conventions for qsort and bsearch */
+#ifndef __WATCOMC__
 #define HAVE_QSORT 1
+#define HAVE_BSEARCH 1
+#endif
 #define HAVE_ABS 1
 #define HAVE_BCOPY 1
 #define HAVE_MEMSET 1
diff --git a/Engine/lib/sdl/include/SDL_config_pandora.h b/Engine/lib/sdl/include/SDL_config_pandora.h
index e0be390bc..01bbf49b0 100644
--- a/Engine/lib/sdl/include/SDL_config_pandora.h
+++ b/Engine/lib/sdl/include/SDL_config_pandora.h
@@ -65,6 +65,7 @@
 #define HAVE_PUTENV 1
 #define HAVE_UNSETENV 1
 #define HAVE_QSORT 1
+#define HAVE_BSEARCH 1
 #define HAVE_ABS 1
 #define HAVE_BCOPY 1
 #define HAVE_MEMSET 1
diff --git a/Engine/lib/sdl/include/SDL_config_windows.h b/Engine/lib/sdl/include/SDL_config_windows.h
index 770b19039..81fde40c8 100644
--- a/Engine/lib/sdl/include/SDL_config_windows.h
+++ b/Engine/lib/sdl/include/SDL_config_windows.h
@@ -97,6 +97,7 @@ typedef unsigned int uintptr_t;
 #define HAVE_DDRAW_H 1
 #define HAVE_DINPUT_H 1
 #define HAVE_DSOUND_H 1
+#ifndef __WATCOMC__
 #define HAVE_DXGI_H 1
 #define HAVE_XINPUT_H 1
 #if defined(_WIN32_MAXVER) && _WIN32_MAXVER >= 0x0A00  /* Windows 10 SDK */
@@ -110,6 +111,7 @@ typedef unsigned int uintptr_t;
 #define HAVE_AUDIOCLIENT_H 1
 #define HAVE_TPCSHRD_H 1
 #define HAVE_SENSORSAPI_H 1
+#endif
 #if (defined(_M_IX86) || defined(_M_X64) || defined(_M_AMD64)) && (defined(_MSC_VER) && _MSC_VER >= 1600)
 #define HAVE_IMMINTRIN_H 1
 #elif defined(__has_include) && (defined(__i386__) || defined(__x86_64))
@@ -136,7 +138,11 @@ typedef unsigned int uintptr_t;
 #define HAVE_REALLOC 1
 #define HAVE_FREE 1
 #define HAVE_ALLOCA 1
+/* OpenWatcom requires specific calling conventions for qsort and bsearch */
+#ifndef __WATCOMC__
 #define HAVE_QSORT 1
+#define HAVE_BSEARCH 1
+#endif
 #define HAVE_ABS 1
 #define HAVE_MEMSET 1
 #define HAVE_MEMCPY 1
@@ -167,37 +173,40 @@ typedef unsigned int uintptr_t;
 #define HAVE__WCSNICMP 1
 #define HAVE__WCSDUP 1
 #define HAVE_ACOS   1
-#define HAVE_ACOSF  1
 #define HAVE_ASIN   1
-#define HAVE_ASINF  1
 #define HAVE_ATAN   1
-#define HAVE_ATANF  1
 #define HAVE_ATAN2  1
+#define HAVE_CEIL   1
+#define HAVE_COS    1
+#define HAVE_EXP    1
+#define HAVE_FABS   1
+#define HAVE_FLOOR  1
+#define HAVE_FMOD   1
+#define HAVE_LOG    1
+#define HAVE_LOG10  1
+#define HAVE_POW    1
+#define HAVE_SIN    1
+#define HAVE_SQRT   1
+#define HAVE_TAN    1
+#ifndef __WATCOMC__
+#define HAVE_ACOSF  1
+#define HAVE_ASINF  1
+#define HAVE_ATANF  1
 #define HAVE_ATAN2F 1
 #define HAVE_CEILF  1
 #define HAVE__COPYSIGN 1
-#define HAVE_COS    1
 #define HAVE_COSF   1
-#define HAVE_EXP    1
 #define HAVE_EXPF   1
-#define HAVE_FABS   1
 #define HAVE_FABSF  1
-#define HAVE_FLOOR  1
 #define HAVE_FLOORF 1
-#define HAVE_FMOD   1
 #define HAVE_FMODF  1
-#define HAVE_LOG    1
 #define HAVE_LOGF   1
-#define HAVE_LOG10  1
 #define HAVE_LOG10F 1
-#define HAVE_POW    1
 #define HAVE_POWF   1
-#define HAVE_SIN    1
 #define HAVE_SINF   1
-#define HAVE_SQRT   1
 #define HAVE_SQRTF  1
-#define HAVE_TAN    1
 #define HAVE_TANF   1
+#endif
 #if defined(_MSC_VER)
 /* These functions were added with the VC++ 2013 C runtime library */
 #if _MSC_VER >= 1800
@@ -217,8 +226,18 @@ typedef unsigned int uintptr_t;
 #if _MSC_VER >= 1400
 #define HAVE__FSEEKI64 1
 #endif
+#ifdef _USE_MATH_DEFINES
+#define HAVE_M_PI 1
 #endif
-#if !defined(_MSC_VER) || defined(_USE_MATH_DEFINES)
+#elif defined(__WATCOMC__)
+#define HAVE__FSEEKI64 1
+#define HAVE_STRTOLL 1
+#define HAVE_STRTOULL 1
+#define HAVE_VSSCANF 1
+#define HAVE_ROUND 1
+#define HAVE_SCALBN 1
+#define HAVE_TRUNC  1
+#else
 #define HAVE_M_PI 1
 #endif
 #else
@@ -227,7 +246,9 @@ typedef unsigned int uintptr_t;
 #endif
 
 /* Enable various audio drivers */
+#if defined(HAVE_MMDEVICEAPI_H) && defined(HAVE_AUDIOCLIENT_H)
 #define SDL_AUDIO_DRIVER_WASAPI 1
+#endif
 #define SDL_AUDIO_DRIVER_DSOUND 1
 #define SDL_AUDIO_DRIVER_WINMM  1
 #define SDL_AUDIO_DRIVER_DISK   1
@@ -248,7 +269,11 @@ typedef unsigned int uintptr_t;
 #define SDL_HAPTIC_XINPUT   1
 
 /* Enable the sensor driver */
+#ifdef HAVE_SENSORSAPI_H
 #define SDL_SENSOR_WINDOWS  1
+#else
+#define SDL_SENSOR_DUMMY    1
+#endif
 
 /* Enable various shared object loading systems */
 #define SDL_LOADSO_WINDOWS  1
@@ -300,11 +325,6 @@ typedef unsigned int uintptr_t;
 /* Enable filesystem support */
 #define SDL_FILESYSTEM_WINDOWS  1
 
-/* Enable assembly routines (Win64 doesn't have inline asm) */
-#ifndef _WIN64
-#define SDL_ASSEMBLY_ROUTINES   1
-#endif
-
 #endif /* SDL_config_windows_h_ */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/include/SDL_config_winrt.h b/Engine/lib/sdl/include/SDL_config_winrt.h
index f3901a597..75aef4ebb 100644
--- a/Engine/lib/sdl/include/SDL_config_winrt.h
+++ b/Engine/lib/sdl/include/SDL_config_winrt.h
@@ -123,6 +123,7 @@ typedef unsigned int uintptr_t;
 #define HAVE_FREE 1
 #define HAVE_ALLOCA 1
 #define HAVE_QSORT 1
+#define HAVE_BSEARCH 1
 #define HAVE_ABS 1
 #define HAVE_MEMSET 1
 #define HAVE_MEMCPY 1
@@ -256,9 +257,4 @@ typedef unsigned int uintptr_t;
 /* Enable system power support */
 #define SDL_POWER_WINRT 1
 
-/* Enable assembly routines (Win64 doesn't have inline asm) */
-#ifndef _WIN64
-#define SDL_ASSEMBLY_ROUTINES   1
-#endif
-
 #endif /* SDL_config_winrt_h_ */
diff --git a/Engine/lib/sdl/include/SDL_cpuinfo.h b/Engine/lib/sdl/include/SDL_cpuinfo.h
index 1fc40991d..55050da26 100644
--- a/Engine/lib/sdl/include/SDL_cpuinfo.h
+++ b/Engine/lib/sdl/include/SDL_cpuinfo.h
@@ -494,7 +494,7 @@ extern DECLSPEC size_t SDLCALL SDL_SIMDGetAlignment(void);
  *
  * \since This function is available since SDL 2.0.10.
  *
- * \sa SDL_SIMDAlignment
+ * \sa SDL_SIMDGetAlignment
  * \sa SDL_SIMDRealloc
  * \sa SDL_SIMDFree
  */
@@ -518,7 +518,7 @@ extern DECLSPEC void * SDLCALL SDL_SIMDAlloc(const size_t len);
  *
  * \since This function is available since SDL 2.0.14.
  *
- * \sa SDL_SIMDAlignment
+ * \sa SDL_SIMDGetAlignment
  * \sa SDL_SIMDAlloc
  * \sa SDL_SIMDFree
  */
diff --git a/Engine/lib/sdl/include/SDL_endian.h b/Engine/lib/sdl/include/SDL_endian.h
index 2866f4bea..e1c6b5ef4 100644
--- a/Engine/lib/sdl/include/SDL_endian.h
+++ b/Engine/lib/sdl/include/SDL_endian.h
@@ -87,6 +87,28 @@ _m_prefetch(void *__P)
 #endif /* __linux__ */
 #endif /* !SDL_BYTEORDER */
 
+#ifndef SDL_FLOATWORDORDER           /* Not defined in SDL_config.h? */
+/* predefs from newer gcc versions: */
+#if defined(__ORDER_LITTLE_ENDIAN__) && defined(__ORDER_BIG_ENDIAN__) && defined(__FLOAT_WORD_ORDER__)
+#if (__FLOAT_WORD_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+#define SDL_FLOATWORDORDER   SDL_LIL_ENDIAN
+#elif (__FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__)
+#define SDL_FLOATWORDORDER   SDL_BIG_ENDIAN
+#else
+#error Unsupported endianness
+#endif /**/
+#elif defined(__MAVERICK__)
+/* For Maverick, float words are always little-endian. */
+#define SDL_FLOATWORDORDER   SDL_LIL_ENDIAN
+#elif (defined(__arm__) || defined(__thumb__)) && !defined(__VFP_FP__) && !defined(__ARM_EABI__)
+/* For FPA, float words are always big-endian. */
+#define SDL_FLOATWORDORDER   SDL_BIG_ENDIAN
+#else
+/* By default, assume that floats words follow the memory system mode. */
+#define SDL_FLOATWORDORDER   SDL_BYTEORDER
+#endif /* __FLOAT_WORD_ORDER__ */
+#endif /* !SDL_FLOATWORDORDER */
+
 
 #include "begin_code.h"
 /* Set up for C function definitions, even when using C++ */
diff --git a/Engine/lib/sdl/include/SDL_events.h b/Engine/lib/sdl/include/SDL_events.h
index 7e469070e..c0fc9bb1a 100644
--- a/Engine/lib/sdl/include/SDL_events.h
+++ b/Engine/lib/sdl/include/SDL_events.h
@@ -118,6 +118,7 @@ typedef enum
     SDL_JOYBUTTONUP,            /**< Joystick button released */
     SDL_JOYDEVICEADDED,         /**< A new joystick has been inserted into the system */
     SDL_JOYDEVICEREMOVED,       /**< An opened joystick has been removed */
+    SDL_JOYBATTERYUPDATED,      /**< Joystick battery level change */
 
     /* Game controller events */
     SDL_CONTROLLERAXISMOTION  = 0x650, /**< Game controller axis motion */
@@ -395,6 +396,16 @@ typedef struct SDL_JoyDeviceEvent
     Sint32 which;       /**< The joystick device index for the ADDED event, instance id for the REMOVED event */
 } SDL_JoyDeviceEvent;
 
+/**
+ *  \brief Joysick battery level change event structure (event.jbattery.*)
+ */
+typedef struct SDL_JoyBatteryEvent
+{
+    Uint32 type;        /**< ::SDL_JOYBATTERYUPDATED */
+    Uint32 timestamp;   /**< In milliseconds, populated using SDL_GetTicks() */
+    SDL_JoystickID which; /**< The joystick instance id */
+    SDL_JoystickPowerLevel level; /**< The joystick battery level */
+} SDL_JoyBatteryEvent;
 
 /**
  *  \brief Game controller axis motion event structure (event.caxis.*)
@@ -625,6 +636,7 @@ typedef union SDL_Event
     SDL_JoyHatEvent jhat;                   /**< Joystick hat event data */
     SDL_JoyButtonEvent jbutton;             /**< Joystick button event data */
     SDL_JoyDeviceEvent jdevice;             /**< Joystick device change event data */
+    SDL_JoyBatteryEvent jbattery;           /**< Joystick battery event data */
     SDL_ControllerAxisEvent caxis;          /**< Game Controller axis event data */
     SDL_ControllerButtonEvent cbutton;      /**< Game Controller button event data */
     SDL_ControllerDeviceEvent cdevice;      /**< Game Controller device event data */
diff --git a/Engine/lib/sdl/include/SDL_gamecontroller.h b/Engine/lib/sdl/include/SDL_gamecontroller.h
index 548861083..6c2c52558 100644
--- a/Engine/lib/sdl/include/SDL_gamecontroller.h
+++ b/Engine/lib/sdl/include/SDL_gamecontroller.h
@@ -289,6 +289,25 @@ extern DECLSPEC SDL_bool SDLCALL SDL_IsGameController(int joystick_index);
  */
 extern DECLSPEC const char *SDLCALL SDL_GameControllerNameForIndex(int joystick_index);
 
+/**
+ * Get the implementation dependent path for the game controller.
+ *
+ * This function can be called before any controllers are opened.
+ *
+ * `joystick_index` is the same as the `device_index` passed to
+ * SDL_JoystickOpen().
+ *
+ * \param joystick_index the device_index of a device, from zero to
+ *                       SDL_NumJoysticks()-1
+ * \returns the implementation-dependent path for the game controller, or NULL
+ *          if there is no path or the index is invalid.
+ *
+ * \since This function is available since SDL 2.24.0.
+ *
+ * \sa SDL_GameControllerPath
+ */
+extern DECLSPEC const char *SDLCALL SDL_GameControllerPathForIndex(int joystick_index);
+
 /**
  * Get the type of a game controller.
  *
@@ -386,6 +405,23 @@ extern DECLSPEC SDL_GameController *SDLCALL SDL_GameControllerFromPlayerIndex(in
  */
 extern DECLSPEC const char *SDLCALL SDL_GameControllerName(SDL_GameController *gamecontroller);
 
+/**
+ * Get the implementation-dependent path for an opened game controller.
+ *
+ * This is the same path as returned by SDL_GameControllerNameForIndex(), but
+ * it takes a controller identifier instead of the (unstable) device index.
+ *
+ * \param gamecontroller a game controller identifier previously returned by
+ *                       SDL_GameControllerOpen()
+ * \returns the implementation dependent path for the game controller, or NULL
+ *          if there is no path or the identifier passed is invalid.
+ *
+ * \since This function is available since SDL 2.24.0.
+ *
+ * \sa SDL_GameControllerPathForIndex
+ */
+extern DECLSPEC const char *SDLCALL SDL_GameControllerPath(SDL_GameController *gamecontroller);
+
 /**
  * Get the type of this currently opened controller
  *
diff --git a/Engine/lib/sdl/include/SDL_hints.h b/Engine/lib/sdl/include/SDL_hints.h
index ea819c85d..83cfe89a6 100644
--- a/Engine/lib/sdl/include/SDL_hints.h
+++ b/Engine/lib/sdl/include/SDL_hints.h
@@ -392,13 +392,14 @@ extern "C" {
 #define SDL_HINT_ENABLE_STEAM_CONTROLLERS "SDL_ENABLE_STEAM_CONTROLLERS"
 
 /**
- *  \brief  A variable controlling whether SDL logs all events pushed onto its internal queue.
+ *  \brief  A variable controlling verbosity of the logging of SDL events pushed onto the internal queue.
  *
- *  This variable can be set to the following values:
+ *  This variable can be set to the following values, from least to most verbose:
  *
  *    "0"     - Don't log any events (default)
- *    "1"     - Log all events except mouse and finger motion, which are pretty spammy.
- *    "2"     - Log all events.
+ *    "1"     - Log most events (other than the really spammy ones).
+ *    "2"     - Include mouse and finger motion events.
+ *    "3"     - Include SDL_SysWMEvent events.
  *
  *  This is generally meant to be used to debug SDL itself, but can be useful
  *  for application developers that need better visibility into what is going
@@ -871,6 +872,24 @@ extern "C" {
   */
 #define SDL_HINT_JOYSTICK_DEVICE "SDL_JOYSTICK_DEVICE"
 
+ /**
+  *  \brief  A variable controlling whether joysticks on Linux will always treat 'hat' axis inputs (ABS_HAT0X - ABS_HAT3Y) as 8-way digital hats without checking whether they may be analog.
+  *
+  *  This variable can be set to the following values:
+  *    "0"       - Only map hat axis inputs to digital hat outputs if the input axes appear to actually be digital (the default)
+  *    "1"       - Always handle the input axes numbered ABS_HAT0X to ABS_HAT3Y as digital hats
+  */
+#define SDL_HINT_LINUX_DIGITAL_HATS "SDL_LINUX_DIGITAL_HATS"
+
+ /**
+  *  \brief  A variable controlling whether digital hats on Linux will apply deadzones to their underlying input axes or use unfiltered values.
+  *
+  *  This variable can be set to the following values:
+  *    "0"       - Return digital hat values based on unfiltered input axis values
+  *    "1"       - Return digital hat values with deadzones on the input axes taken into account (the default)
+  */
+#define SDL_HINT_LINUX_HAT_DEADZONES "SDL_LINUX_HAT_DEADZONES"
+
  /**
   *  \brief  A variable controlling whether to use the classic /dev/input/js* joystick interface or the newer /dev/input/event* joystick interface on Linux
   *
@@ -1450,9 +1469,7 @@ extern "C" {
  *                SDL_WINDOW_RESIZABLE windows will offer the "fullscreen"
  *                button on their titlebars).
  *
- *  The default value is "1". Spaces are disabled regardless of this hint if
- *   the OS isn't at least Mac OS X Lion (10.7). This hint must be set before
- *   any windows are created.
+ *  The default value is "1". This hint must be set before any windows are created.
  */
 #define SDL_HINT_VIDEO_MAC_FULLSCREEN_SPACES    "SDL_VIDEO_MAC_FULLSCREEN_SPACES"
 
@@ -1590,13 +1607,11 @@ extern "C" {
 #define SDL_HINT_VIDEO_X11_WINDOW_VISUALID      "SDL_VIDEO_X11_WINDOW_VISUALID"
 
 /**
- *  \brief  A variable controlling whether the X11 Xinerama extension should be used.
+ *  \brief  A no-longer-used variable controlling whether the X11 Xinerama extension should be used.
  *
- *  This variable can be set to the following values:
- *    "0"       - Disable Xinerama
- *    "1"       - Enable Xinerama
- *
- *  By default SDL will use Xinerama if it is available.
+ * Before SDL 2.0.24, this would let apps and users disable Xinerama support on X11.
+ *  Now SDL never uses Xinerama, and does not check for this hint at all.
+ *  The preprocessor define is left here for source compatibility.
  */
 #define SDL_HINT_VIDEO_X11_XINERAMA         "SDL_VIDEO_X11_XINERAMA"
 
@@ -1607,18 +1622,16 @@ extern "C" {
  *    "0"       - Disable XRandR
  *    "1"       - Enable XRandR
  *
- *  By default SDL will not use XRandR because of window manager issues.
+ *  By default SDL will use XRandR.
  */
 #define SDL_HINT_VIDEO_X11_XRANDR           "SDL_VIDEO_X11_XRANDR"
 
 /**
- *  \brief  A variable controlling whether the X11 VidMode extension should be used.
+ *  \brief  A no-longer-used variable controlling whether the X11 VidMode extension should be used.
  *
- *  This variable can be set to the following values:
- *    "0"       - Disable XVidMode
- *    "1"       - Enable XVidMode
- *
- *  By default SDL will use XVidMode if it is available.
+ * Before SDL 2.0.24, this would let apps and users disable XVidMode support on X11.
+ *  Now SDL never uses XVidMode, and does not check for this hint at all.
+ *  The preprocessor define is left here for source compatibility.
  */
 #define SDL_HINT_VIDEO_X11_XVIDMODE         "SDL_VIDEO_X11_XVIDMODE"
 
diff --git a/Engine/lib/sdl/include/SDL_joystick.h b/Engine/lib/sdl/include/SDL_joystick.h
index 07e2b1561..f10689f56 100644
--- a/Engine/lib/sdl/include/SDL_joystick.h
+++ b/Engine/lib/sdl/include/SDL_joystick.h
@@ -153,6 +153,7 @@ extern DECLSPEC void SDLCALL SDL_UnlockJoysticks(void);
  * \since This function is available since SDL 2.0.0.
  *
  * \sa SDL_JoystickName
+ * \sa SDL_JoystickPath
  * \sa SDL_JoystickOpen
  */
 extern DECLSPEC int SDLCALL SDL_NumJoysticks(void);
@@ -174,6 +175,23 @@ extern DECLSPEC int SDLCALL SDL_NumJoysticks(void);
  */
 extern DECLSPEC const char *SDLCALL SDL_JoystickNameForIndex(int device_index);
 
+/**
+ * Get the implementation dependent path of a joystick.
+ *
+ * This can be called before any joysticks are opened.
+ *
+ * \param device_index the index of the joystick to query (the N'th joystick
+ *                     on the system)
+ * \returns the path of the selected joystick. If no path can be found, this
+ *          function returns NULL; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.24.0.
+ *
+ * \sa SDL_JoystickPath
+ * \sa SDL_JoystickOpen
+ */
+extern DECLSPEC const char *SDLCALL SDL_JoystickPathForIndex(int device_index);
+
 /**
  * Get the player index of a joystick, or -1 if it's not available This can be
  * called before any joysticks are opened.
@@ -330,6 +348,54 @@ extern DECLSPEC int SDLCALL SDL_JoystickAttachVirtual(SDL_JoystickType type,
                                                       int nbuttons,
                                                       int nhats);
 
+/**
+ * The structure that defines an extended virtual joystick description
+ *
+ * The caller must zero the structure and then initialize the version with `SDL_VIRTUAL_JOYSTICK_DESC_VERSION` before passing it to SDL_JoystickAttachVirtualEx()
+ *  All other elements of this structure are optional and can be left 0.
+ *
+ * \sa SDL_JoystickAttachVirtualEx
+ */
+typedef struct SDL_VirtualJoystickDesc
+{
+    Uint16 version;     /**< `SDL_VIRTUAL_JOYSTICK_DESC_VERSION` */
+    Uint16 type;        /**< `SDL_JoystickType` */
+    Uint16 naxes;       /**< the number of axes on this joystick */
+    Uint16 nbuttons;    /**< the number of buttons on this joystick */
+    Uint16 nhats;       /**< the number of hats on this joystick */
+    Uint16 vendor_id;   /**< the USB vendor ID of this joystick */
+    Uint16 product_id;  /**< the USB product ID of this joystick */
+    Uint16 padding;     /**< unused */
+    Uint32 button_mask; /**< A mask of which buttons are valid for this controller
+                             e.g. (1 << SDL_CONTROLLER_BUTTON_A) */
+    Uint32 axis_mask;   /**< A mask of which axes are valid for this controller
+                             e.g. (1 << SDL_CONTROLLER_AXIS_LEFTX) */
+    const char *name;   /**< the name of the joystick */
+
+    void *userdata;     /**< User data pointer passed to callbacks */
+    void (SDLCALL *Update)(void *userdata); /**< Called when the joystick state should be updated */
+    void (SDLCALL *SetPlayerIndex)(void *userdata, int player_index); /**< Called when the player index is set */
+    int (SDLCALL *Rumble)(void *userdata, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble); /**< Implements SDL_JoystickRumble() */
+    int (SDLCALL *RumbleTriggers)(void *userdata, Uint16 left_rumble, Uint16 right_rumble); /**< Implements SDL_JoystickRumbleTriggers() */
+    int (SDLCALL *SetLED)(void *userdata, Uint8 red, Uint8 green, Uint8 blue); /**< Implements SDL_JoystickSetLED() */
+    int (SDLCALL *SendEffect)(void *userdata, const void *data, int size); /**< Implements SDL_JoystickSendEffect() */
+
+} SDL_VirtualJoystickDesc;
+
+/**
+ * \brief The current version of the SDL_VirtualJoystickDesc structure
+ */
+#define SDL_VIRTUAL_JOYSTICK_DESC_VERSION   1
+
+/**
+ * Attach a new virtual joystick with extended properties.
+ *
+ * \returns the joystick's device index, or -1 if an error occurred.
+ *
+ * \since This function is available since SDL 2.24.0.
+ */
+extern DECLSPEC int SDLCALL SDL_JoystickAttachVirtualEx(const SDL_VirtualJoystickDesc *desc);
+
 /**
  * Detach a virtual joystick.
  *
@@ -419,6 +485,19 @@ extern DECLSPEC int SDLCALL SDL_JoystickSetVirtualHat(SDL_Joystick *joystick, in
  */
 extern DECLSPEC const char *SDLCALL SDL_JoystickName(SDL_Joystick *joystick);
 
+/**
+ * Get the implementation dependent path of a joystick.
+ *
+ * \param joystick the SDL_Joystick obtained from SDL_JoystickOpen()
+ * \returns the path of the selected joystick. If no path can be found, this
+ *          function returns NULL; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.24.0.
+ *
+ * \sa SDL_JoystickPathForIndex
+ */
+extern DECLSPEC const char *SDLCALL SDL_JoystickPath(SDL_Joystick *joystick);
+
 /**
  * Get the player index of an opened joystick.
  *
diff --git a/Engine/lib/sdl/include/SDL_keycode.h b/Engine/lib/sdl/include/SDL_keycode.h
index 35602541a..65420f29f 100644
--- a/Engine/lib/sdl/include/SDL_keycode.h
+++ b/Engine/lib/sdl/include/SDL_keycode.h
@@ -318,7 +318,12 @@ typedef enum
     SDLK_APP2 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_APP2),
 
     SDLK_AUDIOREWIND = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AUDIOREWIND),
-    SDLK_AUDIOFASTFORWARD = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AUDIOFASTFORWARD)
+    SDLK_AUDIOFASTFORWARD = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AUDIOFASTFORWARD),
+
+    SDLK_SOFTLEFT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_SOFTLEFT),
+    SDLK_SOFTRIGHT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_SOFTRIGHT),
+    SDLK_CALL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_CALL),
+    SDLK_ENDCALL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_ENDCALL)
 } SDL_KeyCode;
 
 /**
diff --git a/Engine/lib/sdl/include/SDL_log.h b/Engine/lib/sdl/include/SDL_log.h
index dbbcb1e6f..1d8b20b62 100644
--- a/Engine/lib/sdl/include/SDL_log.h
+++ b/Engine/lib/sdl/include/SDL_log.h
@@ -47,9 +47,9 @@ extern "C" {
 
 
 /**
- *  \brief The maximum size of a log message
+ *  \brief The maximum size of a log message prior to SDL 2.0.24
  *
- *  Messages longer than the maximum size will be truncated
+ *  As of 2.0.24 there is no limit to the length of SDL log messages.
  */
 #define SDL_MAX_LOG_MESSAGE 4096
 
diff --git a/Engine/lib/sdl/include/SDL_platform.h b/Engine/lib/sdl/include/SDL_platform.h
index 79b8b6f45..c0bccb093 100644
--- a/Engine/lib/sdl/include/SDL_platform.h
+++ b/Engine/lib/sdl/include/SDL_platform.h
@@ -65,11 +65,15 @@
 #undef __LINUX__ /* do we need to do this? */
 #define __ANDROID__ 1
 #endif
+#if defined(__NGAGE__)
+#undef __NGAGE__
+#define __NGAGE__ 1
+#endif
 
 #if defined(__APPLE__)
 /* lets us know what version of Mac OS X we're compiling on */
-#include "AvailabilityMacros.h"
-#include "TargetConditionals.h"
+#include <AvailabilityMacros.h>
+#include <TargetConditionals.h>
 
 /* Fix building with older SDKs that don't define these
    See this for more information:
@@ -104,9 +108,9 @@
 /* if not compiling for iOS */
 #undef __MACOSX__
 #define __MACOSX__  1
-#if MAC_OS_X_VERSION_MIN_REQUIRED < 1060
-# error SDL for Mac OS X only supports deploying on 10.6 and above.
-#endif /* MAC_OS_X_VERSION_MIN_REQUIRED < 1060 */
+#if MAC_OS_X_VERSION_MIN_REQUIRED < 1070
+# error SDL for Mac OS X only supports deploying on 10.7 and above.
+#endif /* MAC_OS_X_VERSION_MIN_REQUIRED < 1070 */
 #endif /* TARGET_OS_IPHONE */
 #endif /* defined(__APPLE__) */
 
diff --git a/Engine/lib/sdl/include/SDL_rect.h b/Engine/lib/sdl/include/SDL_rect.h
index b678c7a34..6c641c581 100644
--- a/Engine/lib/sdl/include/SDL_rect.h
+++ b/Engine/lib/sdl/include/SDL_rect.h
@@ -252,10 +252,10 @@ SDL_FORCE_INLINE SDL_bool SDL_FRectEmpty(const SDL_FRect *r)
 SDL_FORCE_INLINE SDL_bool SDL_FRectEqualsEpsilon(const SDL_FRect *a, const SDL_FRect *b, const float epsilon)
 {
     return (a && b && ((a == b) ||
-            ((SDL_fabs(a->x - b->x) <= epsilon) &&
-            (SDL_fabs(a->y - b->y) <= epsilon) &&
-            (SDL_fabs(a->w - b->w) <= epsilon) &&
-            (SDL_fabs(a->h - b->h) <= epsilon))))
+            ((SDL_fabsf(a->x - b->x) <= epsilon) &&
+            (SDL_fabsf(a->y - b->y) <= epsilon) &&
+            (SDL_fabsf(a->w - b->w) <= epsilon) &&
+            (SDL_fabsf(a->h - b->h) <= epsilon))))
             ? SDL_TRUE : SDL_FALSE;
 }
 
diff --git a/Engine/lib/sdl/include/SDL_render.h b/Engine/lib/sdl/include/SDL_render.h
index d859e3fd6..450b84d18 100644
--- a/Engine/lib/sdl/include/SDL_render.h
+++ b/Engine/lib/sdl/include/SDL_render.h
@@ -825,9 +825,13 @@ extern DECLSPEC int SDLCALL SDL_RenderSetLogicalSize(SDL_Renderer * renderer, in
 /**
  * Get device independent resolution for rendering.
  *
- * This may return 0 for `w` and `h` if the SDL_Renderer has never had its
- * logical size set by SDL_RenderSetLogicalSize() and never had a render
- * target set.
+ * When using the main rendering target (eg no target texture is set): this
+ * may return 0 for `w` and `h` if the SDL_Renderer has never had its logical
+ * size set by SDL_RenderSetLogicalSize(). Otherwise it returns the logical
+ * width and height.
+ *
+ * When using a target texture: Never return 0 for `w` and `h` at first. Then
+ * it returns the logical width and height that are set.
  *
  * \param renderer a rendering context
  * \param w an int to be filled with the width
diff --git a/Engine/lib/sdl/include/SDL_rwops.h b/Engine/lib/sdl/include/SDL_rwops.h
index 71e5c8db8..30b69a806 100644
--- a/Engine/lib/sdl/include/SDL_rwops.h
+++ b/Engine/lib/sdl/include/SDL_rwops.h
@@ -45,9 +45,6 @@ extern "C" {
 #define SDL_RWOPS_JNIFILE   3U  /**< Android asset */
 #define SDL_RWOPS_MEMORY    4U  /**< Memory stream */
 #define SDL_RWOPS_MEMORY_RO 5U  /**< Read-Only memory stream */
-#if defined(__VITA__)
-#define SDL_RWOPS_VITAFILE  6U  /**< Vita file */
-#endif
 
 /**
  * This is the read/write operation structure -- very basic.
@@ -113,17 +110,6 @@ typedef struct SDL_RWops
                 size_t left;
             } buffer;
         } windowsio;
-#elif defined(__VITA__)
-        struct
-        {
-            int h;
-            struct
-            {
-                void *data;
-                size_t size;
-                size_t left;
-            } buffer;
-        } vitaio;
 #endif
 
 #ifdef HAVE_STDIO_H
diff --git a/Engine/lib/sdl/include/SDL_scancode.h b/Engine/lib/sdl/include/SDL_scancode.h
index 5b2c67c8f..aaa782f8d 100644
--- a/Engine/lib/sdl/include/SDL_scancode.h
+++ b/Engine/lib/sdl/include/SDL_scancode.h
@@ -402,6 +402,26 @@ typedef enum
 
     /* @} *//* Usage page 0x0C (additional media keys) */
 
+    /**
+     *  \name Mobile keys
+     *
+     *  These are values that are often used on mobile phones.
+     */
+    /* @{ */
+
+    SDL_SCANCODE_SOFTLEFT = 287, /**< Usually situated below the display on phones and
+                                      used as a multi-function feature key for selecting
+                                      a software defined function shown on the bottom left
+                                      of the display. */
+    SDL_SCANCODE_SOFTRIGHT = 288, /**< Usually situated below the display on phones and
+                                       used as a multi-function feature key for selecting
+                                       a software defined function shown on the bottom right
+                                       of the display. */
+    SDL_SCANCODE_CALL = 289, /**< Used for accepting phone calls. */
+    SDL_SCANCODE_ENDCALL = 290, /**< Used for rejecting phone calls. */
+
+    /* @} *//* Mobile keys */
+
     /* Add any other keys here. */
 
     SDL_NUM_SCANCODES = 512 /**< not a key, just marks the number of scancodes
diff --git a/Engine/lib/sdl/include/SDL_stdinc.h b/Engine/lib/sdl/include/SDL_stdinc.h
index 449e6445c..6ee15f144 100644
--- a/Engine/lib/sdl/include/SDL_stdinc.h
+++ b/Engine/lib/sdl/include/SDL_stdinc.h
@@ -115,6 +115,12 @@ char *alloca();
 # endif
 #endif
 
+#ifdef SIZE_MAX
+# define SDL_SIZE_MAX SIZE_MAX
+#else
+# define SDL_SIZE_MAX ((size_t) -1)
+#endif
+
 /**
  * Check if the compiler supports a given builtin.
  * Supported by virtually all clang versions and recent gcc. Use this
@@ -462,7 +468,8 @@ extern DECLSPEC int SDLCALL SDL_GetNumAllocations(void);
 extern DECLSPEC char *SDLCALL SDL_getenv(const char *name);
 extern DECLSPEC int SDLCALL SDL_setenv(const char *name, const char *value, int overwrite);
 
-extern DECLSPEC void SDLCALL SDL_qsort(void *base, size_t nmemb, size_t size, int (*compare) (const void *, const void *));
+extern DECLSPEC void SDLCALL SDL_qsort(void *base, size_t nmemb, size_t size, int (SDLCALL *compare) (const void *, const void *));
+extern DECLSPEC void * SDLCALL SDL_bsearch(const void *key, const void *base, size_t nmemb, size_t size, int (SDLCALL *compare) (const void *, const void *));
 
 extern DECLSPEC int SDLCALL SDL_abs(int x);
 
@@ -727,6 +734,65 @@ SDL_FORCE_INLINE void *SDL_memcpy4(SDL_OUT_BYTECAP(dwords*4) void *dst, SDL_IN_B
     return SDL_memcpy(dst, src, dwords * 4);
 }
 
+/**
+ * If a * b would overflow, return -1. Otherwise store a * b via ret
+ * and return 0.
+ *
+ * \since This function is available since SDL 2.24.0.
+ */
+SDL_FORCE_INLINE int SDL_size_mul_overflow (size_t a,
+                                            size_t b,
+                                            size_t *ret)
+{
+    if (a != 0 && b > SDL_SIZE_MAX / a) {
+        return -1;
+    }
+    *ret = a * b;
+    return 0;
+}
+
+#if _SDL_HAS_BUILTIN(__builtin_mul_overflow)
+/* This needs to be wrapped in an inline rather than being a direct #define,
+ * because __builtin_mul_overflow() is type-generic, but we want to be
+ * consistent about interpreting a and b as size_t. */
+SDL_FORCE_INLINE int _SDL_size_mul_overflow_builtin (size_t a,
+                                                     size_t b,
+                                                     size_t *ret)
+{
+    return __builtin_mul_overflow(a, b, ret) == 0 ? 0 : -1;
+}
+#define SDL_size_mul_overflow(a, b, ret) (_SDL_size_mul_overflow_builtin(a, b, ret))
+#endif
+
+/**
+ * If a + b would overflow, return -1. Otherwise store a + b via ret
+ * and return 0.
+ *
+ * \since This function is available since SDL 2.24.0.
+ */
+SDL_FORCE_INLINE int SDL_size_add_overflow (size_t a,
+                                            size_t b,
+                                            size_t *ret)
+{
+    if (b > SDL_SIZE_MAX - a) {
+        return -1;
+    }
+    *ret = a + b;
+    return 0;
+}
+
+#if _SDL_HAS_BUILTIN(__builtin_add_overflow)
+/* This needs to be wrapped in an inline rather than being a direct #define,
+ * the same as the call to __builtin_mul_overflow() above. */
+SDL_FORCE_INLINE int _SDL_size_add_overflow_builtin (size_t a,
+                                                     size_t b,
+                                                     size_t *ret)
+{
+    return __builtin_add_overflow(a, b, ret) == 0 ? 0 : -1;
+}
+#define SDL_size_add_overflow(a, b, ret) (_SDL_size_add_overflow_builtin(a, b, ret))
+#endif
+
 /* Ends C function definitions when using C++ */
 #ifdef __cplusplus
 }
diff --git a/Engine/lib/sdl/include/SDL_system.h b/Engine/lib/sdl/include/SDL_system.h
index 41563add4..c540e4748 100644
--- a/Engine/lib/sdl/include/SDL_system.h
+++ b/Engine/lib/sdl/include/SDL_system.h
@@ -195,7 +195,7 @@ extern DECLSPEC int SDLCALL SDL_LinuxSetThreadPriorityAndPolicy(Sint64 threadID,
  *
  * \sa SDL_iPhoneSetEventPump
  */
-extern DECLSPEC int SDLCALL SDL_iPhoneSetAnimationCallback(SDL_Window * window, int interval, void (*callback)(void*), void *callbackParam);
+extern DECLSPEC int SDLCALL SDL_iPhoneSetAnimationCallback(SDL_Window * window, int interval, void (SDLCALL *callback)(void*), void *callbackParam);
 
 #define SDL_iOSSetEventPump(enabled) SDL_iPhoneSetEventPump(enabled)
 
diff --git a/Engine/lib/sdl/include/SDL_thread.h b/Engine/lib/sdl/include/SDL_thread.h
index 35e680ddf..1e04a4f8f 100644
--- a/Engine/lib/sdl/include/SDL_thread.h
+++ b/Engine/lib/sdl/include/SDL_thread.h
@@ -129,7 +129,7 @@ SDL_CreateThread(SDL_ThreadFunction fn, const char *name, void *data,
                  pfnSDL_CurrentEndThread pfnEndThread);
 
 extern DECLSPEC SDL_Thread *SDLCALL
-SDL_CreateThreadWithStackSize(int (SDLCALL * fn) (void *),
+SDL_CreateThreadWithStackSize(SDL_ThreadFunction fn,
                  const char *name, const size_t stacksize, void *data,
                  pfnSDL_CurrentBeginThread pfnBeginThread,
                  pfnSDL_CurrentEndThread pfnEndThread);
diff --git a/Engine/lib/sdl/include/SDL_version.h b/Engine/lib/sdl/include/SDL_version.h
index 3df4e041a..302e4628d 100644
--- a/Engine/lib/sdl/include/SDL_version.h
+++ b/Engine/lib/sdl/include/SDL_version.h
@@ -58,8 +58,8 @@ typedef struct SDL_version
 /* Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL
 */
 #define SDL_MAJOR_VERSION   2
-#define SDL_MINOR_VERSION   0
-#define SDL_PATCHLEVEL      22
+#define SDL_MINOR_VERSION   23
+#define SDL_PATCHLEVEL      0
 
 /**
  * Macro to determine SDL version program was compiled against.
@@ -83,6 +83,8 @@ typedef struct SDL_version
     (x)->patch = SDL_PATCHLEVEL;                    \
 }
 
+/* TODO: Remove this whole block in SDL 3 */
+#if SDL_MAJOR_VERSION < 3
 /**
  *  This macro turns the version numbers into a numeric value:
  *  \verbatim
@@ -90,21 +92,35 @@ typedef struct SDL_version
     \endverbatim
  *
  *  This assumes that there will never be more than 100 patchlevels.
+ *
+ *  In versions higher than 2.9.0, the minor version overflows into
+ *  the thousands digit: for example, 2.23.0 is encoded as 4300,
+ *  and 2.255.99 would be encoded as 25799.
+ *  This macro will not be available in SDL 3.x.
  */
 #define SDL_VERSIONNUM(X, Y, Z)                     \
     ((X)*1000 + (Y)*100 + (Z))
 
 /**
  *  This is the version number macro for the current SDL version.
+ *
+ *  In versions higher than 2.9.0, the minor version overflows into
+ *  the thousands digit: for example, 2.23.0 is encoded as 4300.
+ *  This macro will not be available in SDL 3.x.
+ *
+ *  Deprecated, use SDL_VERSION_ATLEAST or SDL_VERSION instead.
  */
 #define SDL_COMPILEDVERSION \
     SDL_VERSIONNUM(SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL)
+#endif /* SDL_MAJOR_VERSION < 3 */
 
 /**
  *  This macro will evaluate to true if compiled with SDL at least X.Y.Z.
  */
 #define SDL_VERSION_ATLEAST(X, Y, Z) \
-    (SDL_COMPILEDVERSION >= SDL_VERSIONNUM(X, Y, Z))
+    ((SDL_MAJOR_VERSION >= X) && \
+     (SDL_MAJOR_VERSION > X || SDL_MINOR_VERSION >= Y) && \
+     (SDL_MAJOR_VERSION > X || SDL_MINOR_VERSION > Y || SDL_PATCHLEVEL >= Z))
 
 /**
  * Get the version of SDL that is linked against your program.
diff --git a/Engine/lib/sdl/src/SDL.c b/Engine/lib/sdl/src/SDL.c
index 68a4f5da2..a65d9c519 100644
--- a/Engine/lib/sdl/src/SDL.c
+++ b/Engine/lib/sdl/src/SDL.c
@@ -47,6 +47,7 @@
 #include "SDL_bits.h"
 #include "SDL_revision.h"
 #include "SDL_assert_c.h"
+#include "SDL_log_c.h"
 #include "events/SDL_events_c.h"
 #include "haptic/SDL_haptic_c.h"
 #include "joystick/SDL_joystick_c.h"
@@ -61,6 +62,26 @@ extern int SDL_HelperWindowCreate(void);
 extern int SDL_HelperWindowDestroy(void);
 #endif
 
+#ifdef SDL_BUILD_MAJOR_VERSION
+SDL_COMPILE_TIME_ASSERT(SDL_BUILD_MAJOR_VERSION,
+                        SDL_MAJOR_VERSION == SDL_BUILD_MAJOR_VERSION);
+SDL_COMPILE_TIME_ASSERT(SDL_BUILD_MINOR_VERSION,
+                        SDL_MINOR_VERSION == SDL_BUILD_MINOR_VERSION);
+SDL_COMPILE_TIME_ASSERT(SDL_BUILD_MICRO_VERSION,
+                        SDL_PATCHLEVEL == SDL_BUILD_MICRO_VERSION);
+#endif
+
+SDL_COMPILE_TIME_ASSERT(SDL_MAJOR_VERSION_min, SDL_MAJOR_VERSION >= 0);
+/* Limited only by the need to fit in SDL_version */
+SDL_COMPILE_TIME_ASSERT(SDL_MAJOR_VERSION_max, SDL_MAJOR_VERSION <= 255);
+
+SDL_COMPILE_TIME_ASSERT(SDL_MINOR_VERSION_min, SDL_MINOR_VERSION >= 0);
+/* Limited only by the need to fit in SDL_version */
+SDL_COMPILE_TIME_ASSERT(SDL_MINOR_VERSION_max, SDL_MINOR_VERSION <= 255);
+
+SDL_COMPILE_TIME_ASSERT(SDL_PATCHLEVEL_min, SDL_PATCHLEVEL >= 0);
+/* Limited by its encoding in SDL_VERSIONNUM and in the ABI versions */
+SDL_COMPILE_TIME_ASSERT(SDL_PATCHLEVEL_max, SDL_PATCHLEVEL <= 99);
 
 /* This is not declared in any header, although it is shared between some
     parts of SDL, because we don't want anything calling it without an
@@ -156,6 +177,8 @@ SDL_InitSubSystem(Uint32 flags)
         return SDL_SetError("Application didn't initialize properly, did you include SDL_main.h in the file containing your main() function?");
     }
 
+    SDL_LogInit();
+
     /* Clear the error message */
     SDL_ClearError();
 
@@ -470,12 +493,13 @@ SDL_Quit(void)
 
     SDL_ClearHints();
     SDL_AssertionsQuit();
-    SDL_LogResetPriorities();
 
 #if SDL_USE_LIBDBUS
     SDL_DBus_Quit();
 #endif
 
+    SDL_LogQuit();
+
     /* Now that every subsystem has been quit, we reset the subsystem refcount
      * and the list of initialized subsystems.
      */
@@ -563,6 +587,8 @@ SDL_GetPlatform(void)
     return "PlayStation Portable";
 #elif __VITA__
     return "PlayStation Vita";
+#elif __NGAGE__
+    return "Nokia N-Gage";
 #else
     return "Unknown (see SDL_platform.h)";
 #endif
diff --git a/Engine/lib/sdl/src/SDL_assert.c b/Engine/lib/sdl/src/SDL_assert.c
index 9c7acac55..02cd6b3fd 100644
--- a/Engine/lib/sdl/src/SDL_assert.c
+++ b/Engine/lib/sdl/src/SDL_assert.c
@@ -45,6 +45,8 @@
 #include <emscripten.h>
 #endif
 
+/* The size of the stack buffer to use for rendering assert messages. */
+#define SDL_MAX_ASSERT_MESSAGE_STACK 256
 
 static SDL_assert_state SDLCALL
 SDL_PromptAssertion(const SDL_assert_data *data, void *userdata);
@@ -88,6 +90,20 @@ static void SDL_AddAssertionToReport(SDL_assert_data *data)
     }
 }
 
+#ifdef __WIN32__
+    #define ENDLINE "\r\n"
+#else
+    #define ENDLINE "\n"
+#endif
+
+static int SDL_RenderAssertMessage(char *buf, size_t buf_len, const SDL_assert_data *data) {
+    return SDL_snprintf(buf, buf_len,
+        "Assertion failure at %s (%s:%d), triggered %u %s:" ENDLINE "  '%s'",
+        data->function, data->filename, data->linenum,
+        data->trigger_count, (data->trigger_count == 1) ? "time" : "times",
+        data->condition
+    );
+}
 
 static void SDL_GenerateAssertionReport(void)
 {
@@ -137,16 +153,9 @@ static SDL_NORETURN void SDL_AbortAssertion(void)
     SDL_ExitProcess(42);
 }
 
-
 static SDL_assert_state SDLCALL
 SDL_PromptAssertion(const SDL_assert_data *data, void *userdata)
 {
-#ifdef __WIN32__
-    #define ENDLINE "\r\n"
-#else
-    #define ENDLINE "\n"
-#endif
-
     const char *envr;
     SDL_assert_state state = SDL_ASSERTION_ABORT;
     SDL_Window *window;
@@ -160,30 +169,46 @@ SDL_PromptAssertion(const SDL_assert_data *data, void *userdata)
         {   SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT,
                 SDL_ASSERTION_ALWAYS_IGNORE,    "Always Ignore" }
     };
-    char *message;
     int selected;
 
+    char stack_buf[SDL_MAX_ASSERT_MESSAGE_STACK];
+    char *message = stack_buf;
+    size_t buf_len = sizeof(stack_buf);
+    int len;
+
     (void) userdata;  /* unused in default handler. */
 
-    /* !!! FIXME: why is this using SDL_stack_alloc and not just "char message[SDL_MAX_LOG_MESSAGE];" ? */
-    message = SDL_stack_alloc(char, SDL_MAX_LOG_MESSAGE);
-    if (!message) {
-        /* Uh oh, we're in real trouble now... */
+    /* Assume the output will fit... */
+    len = SDL_RenderAssertMessage(message, buf_len, data);
+
+    /* .. and if it didn't, try to allocate as much room as we actually need. */
+    if (len >= (int)buf_len) {
+        if (SDL_size_add_overflow(len, 1, &buf_len) == 0) {
+            message = (char *)SDL_malloc(buf_len);
+            if (message) {
+                len = SDL_RenderAssertMessage(message, buf_len, data);
+            } else {
+                message = stack_buf;
+            }
+        }
+    }
+
+    /* Something went very wrong */
+    if (len < 0) {
+        if (message != stack_buf) {
+            SDL_free(message);
+        }
         return SDL_ASSERTION_ABORT;
     }
-    SDL_snprintf(message, SDL_MAX_LOG_MESSAGE,
-                 "Assertion failure at %s (%s:%d), triggered %u %s:" ENDLINE
-                    "  '%s'",
-                 data->function, data->filename, data->linenum,
-                 data->trigger_count, (data->trigger_count == 1) ? "time" : "times",
-                 data->condition);
 
     debug_print("\n\n%s\n\n", message);
 
     /* let env. variable override, so unit tests won't block in a GUI. */
     envr = SDL_getenv("SDL_ASSERT");
     if (envr != NULL) {
-        SDL_stack_free(message);
+        if (message != stack_buf) {
+            SDL_free(message);
+        }
 
         if (SDL_strcmp(envr, "abort") == 0) {
             return SDL_ASSERTION_ABORT;
@@ -301,7 +326,9 @@ SDL_PromptAssertion(const SDL_assert_data *data, void *userdata)
         SDL_RestoreWindow(window);
     }
 
-    SDL_stack_free(message);
+    if (message != stack_buf) {
+        SDL_free(message);
+    }
 
     return state;
 }
diff --git a/Engine/lib/sdl/src/SDL_hints.c b/Engine/lib/sdl/src/SDL_hints.c
index d3fc8ab46..0005f4908 100644
--- a/Engine/lib/sdl/src/SDL_hints.c
+++ b/Engine/lib/sdl/src/SDL_hints.c
@@ -179,6 +179,7 @@ SDL_AddHintCallback(const char *name, SDL_HintCallback callback, void *userdata)
         }
         hint->name = SDL_strdup(name);
         if (!hint->name) {
+            SDL_free(entry);
             SDL_free(hint);
             SDL_OutOfMemory();
             return;
diff --git a/Engine/lib/sdl/src/SDL_internal.h b/Engine/lib/sdl/src/SDL_internal.h
index 69da271c6..43e407f87 100644
--- a/Engine/lib/sdl/src/SDL_internal.h
+++ b/Engine/lib/sdl/src/SDL_internal.h
@@ -43,10 +43,9 @@
 
 #if SDL_DYNAMIC_API
 #include "dynapi/SDL_dynapi_overrides.h"
-/* force DECLSPEC and SDLCALL off...it's all internal symbols now.
+/* force DECLSPEC off...it's all internal symbols now.
    These will have actual #defines during SDL_dynapi.c only */
 #define DECLSPEC
-#define SDLCALL
 #endif
 
 #include "SDL_config.h"
diff --git a/Engine/lib/sdl/src/SDL_log.c b/Engine/lib/sdl/src/SDL_log.c
index 4f820ffa7..49027e47b 100644
--- a/Engine/lib/sdl/src/SDL_log.c
+++ b/Engine/lib/sdl/src/SDL_log.c
@@ -28,6 +28,8 @@
 
 #include "SDL_error.h"
 #include "SDL_log.h"
+#include "SDL_mutex.h"
+#include "SDL_log_c.h"
 
 #if HAVE_STDIO_H
 #include <stdio.h>
@@ -37,6 +39,12 @@
 #include <android/log.h>
 #endif
 
+#include "stdlib/SDL_vacopy.h"
+
+
+/* The size of the stack buffer to use for rendering log messages. */
+#define SDL_MAX_LOG_MESSAGE_STACK 256
+
 #define DEFAULT_PRIORITY                SDL_LOG_PRIORITY_CRITICAL
 #define DEFAULT_ASSERT_PRIORITY         SDL_LOG_PRIORITY_WARN
 #define DEFAULT_APPLICATION_PRIORITY    SDL_LOG_PRIORITY_INFO
@@ -59,6 +67,7 @@ static SDL_LogPriority SDL_application_priority = DEFAULT_APPLICATION_PRIORITY;
 static SDL_LogPriority SDL_test_priority = DEFAULT_TEST_PRIORITY;
 static SDL_LogOutputFunction SDL_log_function = SDL_LogOutput;
 static void *SDL_log_userdata = NULL;
+static SDL_mutex *log_function_mutex = NULL;
 
 static const char *SDL_priority_prefixes[SDL_NUM_LOG_PRIORITIES] = {
     NULL,
@@ -92,6 +101,24 @@ static int SDL_android_priority[SDL_NUM_LOG_PRIORITIES] = {
 };
 #endif /* __ANDROID__ */
 
+void
+SDL_LogInit(void)
+{
+    if (!log_function_mutex) {
+        /* if this fails we'll try to continue without it. */
+        log_function_mutex = SDL_CreateMutex();
+    }
+}
+
+void
+SDL_LogQuit(void)
+{
+    SDL_LogResetPriorities();
+    if (log_function_mutex) {
+        SDL_DestroyMutex(log_function_mutex);
+        log_function_mutex = NULL;
+    }
+}
 
 void
 SDL_LogSetAllPriority(SDL_LogPriority priority)
@@ -264,8 +291,11 @@ GetCategoryPrefix(int category)
 void
 SDL_LogMessageV(int category, SDL_LogPriority priority, const char *fmt, va_list ap)
 {
-    char *message;
-    size_t len;
+    char *message = NULL;
+    char stack_buf[SDL_MAX_LOG_MESSAGE_STACK];
+    size_t len_plus_term;
+    int len;
+    va_list aq;
 
     /* Nothing to do if we don't have an output function */
     if (!SDL_log_function) {
@@ -282,16 +312,33 @@ SDL_LogMessageV(int category, SDL_LogPriority priority, const char *fmt, va_list
         return;
     }
 
-    /* !!! FIXME: why not just "char message[SDL_MAX_LOG_MESSAGE];" ? */
-    message = SDL_stack_alloc(char, SDL_MAX_LOG_MESSAGE);
-    if (!message) {
-        return;
+    if (!log_function_mutex) {
+        /* this mutex creation can race if you log from two threads at startup. You should have called SDL_Init first! */
+        log_function_mutex = SDL_CreateMutex();
     }
 
-    SDL_vsnprintf(message, SDL_MAX_LOG_MESSAGE, fmt, ap);
+    /* Render into stack buffer */
+    va_copy(aq, ap);
+    len = SDL_vsnprintf(stack_buf, sizeof(stack_buf), fmt, aq);
+    va_end(aq);
+
+    if (len < 0)
+        return;
+
+    /* If message truncated, allocate and re-render */
+    if (len >= sizeof(stack_buf) && SDL_size_add_overflow(len, 1, &len_plus_term) == 0) {
+        /* Allocate exactly what we need, including the zero-terminator */
+        message = (char *)SDL_malloc(len_plus_term);
+        if (!message)
+            return;
+        va_copy(aq, ap);
+        len = SDL_vsnprintf(message, len_plus_term, fmt, aq);
+        va_end(aq);
+    } else {
+        message = stack_buf;
+    }
 
     /* Chop off final endline. */
-    len = SDL_strlen(message);
     if ((len > 0) && (message[len-1] == '\n')) {
         message[--len] = '\0';
         if ((len > 0) && (message[len-1] == '\r')) {  /* catch "\r\n", too. */
@@ -299,8 +346,20 @@ SDL_LogMessageV(int category, SDL_LogPriority priority, const char *fmt, va_list
         }
     }
 
+    if (log_function_mutex) {
+        SDL_LockMutex(log_function_mutex);
+    }
+
     SDL_log_function(SDL_log_userdata, category, priority, message);
-    SDL_stack_free(message);
+
+    if (log_function_mutex) {
+        SDL_UnlockMutex(log_function_mutex);
+    }
+
+    /* Free only if dynamically allocated */
+    if (message != stack_buf) {
+        SDL_free(message);
+    }
 }
 
 #if defined(__WIN32__) && !defined(HAVE_STDIO_H) && !defined(__WINRT__)
@@ -403,17 +462,10 @@ SDL_LogOutput(void *userdata, int category, SDL_LogPriority priority,
 #elif defined(__APPLE__) && (defined(SDL_VIDEO_DRIVER_COCOA) || defined(SDL_VIDEO_DRIVER_UIKIT))
     /* Technically we don't need Cocoa/UIKit, but that's where this function is defined for now.
     */
-    extern void SDL_NSLog(const char *text);
+    extern void SDL_NSLog(const char *prefix, const char *text);
     {
-        char *text;
-        /* !!! FIXME: why not just "char text[SDL_MAX_LOG_MESSAGE];" ? */
-        text = SDL_stack_alloc(char, SDL_MAX_LOG_MESSAGE);
-        if (text) {
-            SDL_snprintf(text, SDL_MAX_LOG_MESSAGE, "%s: %s", SDL_priority_prefixes[priority], message);
-            SDL_NSLog(text);
-            SDL_stack_free(text);
-            return;
-        }
+        SDL_NSLog(SDL_priority_prefixes[priority], message);
+        return;
     }
 #elif defined(__PSP__)
     {
diff --git a/Engine/lib/sdl/src/SDL_log_c.h b/Engine/lib/sdl/src/SDL_log_c.h
new file mode 100644
index 000000000..4716b7ada
--- /dev/null
+++ b/Engine/lib/sdl/src/SDL_log_c.h
@@ -0,0 +1,33 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "./SDL_internal.h"
+
+/* This file defines useful function for working with SDL logging */
+
+#ifndef SDL_log_c_h_
+#define SDL_log_c_h_
+
+extern void SDL_LogInit(void);
+extern void SDL_LogQuit(void);
+
+#endif /* SDL_log_c_h_ */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/audio/SDL_audio.c b/Engine/lib/sdl/src/audio/SDL_audio.c
index fb363f771..ac3ac1fc2 100644
--- a/Engine/lib/sdl/src/audio/SDL_audio.c
+++ b/Engine/lib/sdl/src/audio/SDL_audio.c
@@ -1649,8 +1649,6 @@ SDL_AudioQuit(void)
 #ifdef HAVE_LIBSAMPLERATE_H
     UnloadLibSampleRate();
 #endif
-
-    SDL_FreeResampleFilter();
 }
 
 #define NUM_FORMATS 10
diff --git a/Engine/lib/sdl/src/audio/SDL_audio_c.h b/Engine/lib/sdl/src/audio/SDL_audio_c.h
index cddaecef0..bfa0760de 100644
--- a/Engine/lib/sdl/src/audio/SDL_audio_c.h
+++ b/Engine/lib/sdl/src/audio/SDL_audio_c.h
@@ -70,11 +70,6 @@ extern SDL_AudioFilter SDL_Convert_F32_to_S16;
 extern SDL_AudioFilter SDL_Convert_F32_to_U16;
 extern SDL_AudioFilter SDL_Convert_F32_to_S32;
 
-/* You need to call SDL_PrepareResampleFilter() before using the internal resampler.
-   SDL_AudioQuit() calls SDL_FreeResamplerFilter(), you should never call it yourself. */
-extern int SDL_PrepareResampleFilter(void);
-extern void SDL_FreeResampleFilter(void);
-
 #endif /* SDL_audio_c_h_ */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/audio/SDL_audio_resampler_filter.h b/Engine/lib/sdl/src/audio/SDL_audio_resampler_filter.h
new file mode 100644
index 000000000..9b4728c3b
--- /dev/null
+++ b/Engine/lib/sdl/src/audio/SDL_audio_resampler_filter.h
@@ -0,0 +1,1062 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+/* DO NOT EDIT, THIS FILE WAS GENERATED BY build-scripts/gen_audio_resampler_filter.c */
+
+#define RESAMPLER_ZERO_CROSSINGS 5
+#define RESAMPLER_BITS_PER_SAMPLE 16
+#define RESAMPLER_SAMPLES_PER_ZERO_CROSSING (1 << ((RESAMPLER_BITS_PER_SAMPLE / 2) + 1))
+#define RESAMPLER_FILTER_SIZE ((RESAMPLER_SAMPLES_PER_ZERO_CROSSING * RESAMPLER_ZERO_CROSSINGS) + 1)
+
+static const float ResamplerFilter[RESAMPLER_FILTER_SIZE] = {
+    1.000000000f, 0.999993682f, 0.999974370f, 0.999941289f, 0.999894559f,
+    0.999834180f, 0.999760151f, 0.999672413f, 0.999571025f, 0.999455988f,
+    0.999327302f, 0.999184966f, 0.999028981f, 0.998859286f, 0.998676121f,
+    0.998479128f, 0.998268604f, 0.998044431f, 0.997806668f, 0.997555375f,
+    0.997290313f, 0.997011721f, 0.996719599f, 0.996413827f, 0.996094406f,
+    0.995761573f, 0.995415151f, 0.995055199f, 0.994681656f, 0.994294584f,
+    0.993894041f, 0.993480027f, 0.993052363f, 0.992611289f, 0.992156804f,
+    0.991688788f, 0.991207361f, 0.990712583f, 0.990204275f, 0.989682615f,
+    0.989147604f, 0.988599122f, 0.988037288f, 0.987462223f, 0.986873686f,
+    0.986271918f, 0.985656738f, 0.985028386f, 0.984386861f, 0.983731806f,
+    0.983063757f, 0.982382476f, 0.981687963f, 0.980980217f, 0.980259418f,
+    0.979525447f, 0.978778243f, 0.978018105f, 0.977244914f, 0.976458490f,
+    0.975659251f, 0.974846840f, 0.974021494f, 0.973183155f, 0.972331941f,
+    0.971467674f, 0.970590651f, 0.969700634f, 0.968797863f, 0.967882276f,
+    0.966953754f, 0.966012537f, 0.965058565f, 0.964091897f, 0.963112533f,
+    0.962120414f, 0.961115718f, 0.960098326f, 0.959068418f, 0.958025992f,
+    0.956970990f, 0.955903471f, 0.954823375f, 0.953730941f, 0.952626109f,
+    0.951508820f, 0.950379193f, 0.949237227f, 0.948082924f, 0.946916521f,
+    0.945737660f, 0.944546640f, 0.943343520f, 0.942128360f, 0.940900803f,
+    0.939661384f, 0.938409984f, 0.937146366f, 0.935870886f, 0.934583426f,
+    0.933284163f, 0.931972861f, 0.930649877f, 0.929314911f, 0.927968264f,
+    0.926609993f, 0.925239921f, 0.923858225f, 0.922464967f, 0.921060085f,
+    0.919643581f, 0.918215632f, 0.916776240f, 0.915325403f, 0.913863063f,
+    0.912389517f, 0.910904646f, 0.909408391f, 0.907901049f, 0.906382322f,
+    0.904852629f, 0.903311789f, 0.901759744f, 0.900196850f, 0.898622811f,
+    0.897037864f, 0.895442069f, 0.893835366f, 0.892217875f, 0.890589595f,
+    0.888950586f, 0.887300909f, 0.885640502f, 0.883969545f, 0.882288039f,
+    0.880595982f, 0.878893554f, 0.877180517f, 0.875457227f, 0.873723626f,
+    0.871979713f, 0.870225549f, 0.868461132f, 0.866686642f, 0.864902079f,
+    0.863107383f, 0.861302733f, 0.859488070f, 0.857663572f, 0.855829120f,
+    0.853984952f, 0.852130949f, 0.850267172f, 0.848393857f, 0.846510828f,
+    0.844618261f, 0.842716157f, 0.840804636f, 0.838883698f, 0.836953342f,
+    0.835013688f, 0.833064795f, 0.831106603f, 0.829139292f, 0.827162862f,
+    0.825177312f, 0.823182821f, 0.821179330f, 0.819167018f, 0.817145705f,
+    0.815115690f, 0.813076973f, 0.811029494f, 0.808973312f, 0.806908667f,
+    0.804835379f, 0.802753687f, 0.800663531f, 0.798565030f, 0.796458125f,
+    0.794343054f, 0.792219698f, 0.790088236f, 0.787948668f, 0.785801113f,
+    0.783645451f, 0.781481922f, 0.779310465f, 0.777131259f, 0.774944246f,
+    0.772749543f, 0.770547271f, 0.768337309f, 0.766119778f, 0.763894856f,
+    0.761662483f, 0.759422719f, 0.757175624f, 0.754921377f, 0.752659857f,
+    0.750391185f, 0.748115480f, 0.745832801f, 0.743543088f, 0.741246462f,
+    0.738943100f, 0.736632884f, 0.734315932f, 0.731992364f, 0.729662120f,
+    0.727325320f, 0.724982083f, 0.722632408f, 0.720276356f, 0.717914045f,
+    0.715545416f, 0.713170588f, 0.710789680f, 0.708402693f, 0.706009746f,
+    0.703610778f, 0.701205969f, 0.698795319f, 0.696378946f, 0.693956852f,
+    0.691529095f, 0.689095736f, 0.686656833f, 0.684212506f, 0.681762815f,
+    0.679307759f, 0.676847458f, 0.674381971f, 0.671911240f, 0.669435501f,
+    0.666954637f, 0.664468944f, 0.661978245f, 0.659482718f, 0.656982541f,
+    0.654477477f, 0.651967824f, 0.649453580f, 0.646934807f, 0.644411504f,
+    0.641883910f, 0.639351964f, 0.636815608f, 0.634275198f, 0.631730616f,
+    0.629181862f, 0.626629114f, 0.624072373f, 0.621511757f, 0.618947387f,
+    0.616379082f, 0.613807201f, 0.611231565f, 0.608652413f, 0.606069744f,
+    0.603483617f, 0.600894034f, 0.598301172f, 0.595705032f, 0.593105674f,
+    0.590503156f, 0.587897599f, 0.585289061f, 0.582677484f, 0.580063045f,
+    0.577445805f, 0.574825764f, 0.572203040f, 0.569577694f, 0.566949785f,
+    0.564319372f, 0.561686456f, 0.559051216f, 0.556413651f, 0.553773820f,
+    0.551131785f, 0.548487663f, 0.545841396f, 0.543193221f, 0.540543079f,
+    0.537890971f, 0.535237134f, 0.532581568f, 0.529924273f, 0.527265370f,
+    0.524604917f, 0.521942914f, 0.519279540f, 0.516614795f, 0.513948679f,
+    0.511281490f, 0.508612931f, 0.505943298f, 0.503272593f, 0.500600994f,
+    0.497928351f, 0.495254934f, 0.492580622f, 0.489905566f, 0.487229884f,
+    0.484553576f, 0.481876701f, 0.479199320f, 0.476521552f, 0.473843396f,
+    0.471164882f, 0.468486160f, 0.465807229f, 0.463128209f, 0.460449100f,
+    0.457770079f, 0.455091029f, 0.452412128f, 0.449733406f, 0.447054923f,
+    0.444376737f, 0.441698909f, 0.439021617f, 0.436344713f, 0.433668375f,
+    0.430992693f, 0.428317666f, 0.425643355f, 0.422969848f, 0.420297176f,
+    0.417625397f, 0.414954633f, 0.412284881f, 0.409616232f, 0.406948745f,
+    0.404282451f, 0.401617438f, 0.398953736f, 0.396291435f, 0.393630594f,
+    0.390971363f, 0.388313591f, 0.385657459f, 0.383003026f, 0.380350292f,
+    0.377699375f, 0.375050306f, 0.372403204f, 0.369758040f, 0.367114902f,
+    0.364473879f, 0.361834973f, 0.359198302f, 0.356563985f, 0.353931844f,
+    0.351302117f, 0.348674864f, 0.346050024f, 0.343427807f, 0.340808123f,
+    0.338191152f, 0.335576862f, 0.332965344f, 0.330356658f, 0.327750862f,
+    0.325147986f, 0.322548091f, 0.319951355f, 0.317357630f, 0.314767033f,
+    0.312179655f, 0.309595555f, 0.307014734f, 0.304437339f, 0.301863313f,
+    0.299292803f, 0.296725839f, 0.294162393f, 0.291602641f, 0.289046586f,
+    0.286494225f, 0.283945769f, 0.281401068f, 0.278860301f, 0.276323408f,
+    0.273790598f, 0.271261781f, 0.268737078f, 0.266216546f, 0.263700217f,
+    0.261188149f, 0.258680373f, 0.256176978f, 0.253677934f, 0.251183391f,
+    0.248693451f, 0.246207923f, 0.243727028f, 0.241250798f, 0.238779247f,
+    0.236312449f, 0.233850464f, 0.231393293f, 0.228941023f, 0.226493701f,
+    0.224051371f, 0.221614078f, 0.219181836f, 0.216754735f, 0.214332923f,
+    0.211916193f, 0.209504753f, 0.207098618f, 0.204697832f, 0.202302471f,
+    0.199912533f, 0.197528124f, 0.195149198f, 0.192775860f, 0.190408155f,
+    0.188046113f, 0.185689807f, 0.183339253f, 0.180994540f, 0.178655609f,
+    0.176322535f, 0.173995405f, 0.171674222f, 0.169359058f, 0.167049929f,
+    0.164746925f, 0.162450001f, 0.160159275f, 0.157874763f, 0.155596510f,
+    0.153324530f, 0.151058972f, 0.148799688f, 0.146546826f, 0.144300416f,
+    0.142060474f, 0.139827073f, 0.137600228f, 0.135380000f, 0.133166388f,
+    0.130959451f, 0.128759250f, 0.126565769f, 0.124379098f, 0.122199245f,
+    0.120026320f, 0.117860198f, 0.115701027f, 0.113548823f, 0.111403592f,
+    0.109265402f, 0.107134290f, 0.105010264f, 0.102893390f, 0.100783676f,
+    0.098681159f, 0.096585885f, 0.094497882f, 0.092417173f, 0.090343870f,
+    0.088277847f, 0.086219221f, 0.084168032f, 0.082124293f, 0.080088042f,
+    0.078059308f, 0.076038122f, 0.074024513f, 0.072018512f, 0.070020139f,
+    0.068029441f, 0.066046432f, 0.064071149f, 0.062103685f, 0.060143925f,
+    0.058191977f, 0.056247860f, 0.054311592f, 0.052383222f, 0.050462760f,
+    0.048550237f, 0.046645675f, 0.044749107f, 0.042860553f, 0.040980037f,
+    0.039107583f, 0.037243221f, 0.035387039f, 0.033538923f, 0.031698968f,
+    0.029867193f, 0.028043624f, 0.026228283f, 0.024421191f, 0.022622371f,
+    0.020831848f, 0.019049639f, 0.017275762f, 0.015510243f, 0.013753103f,
+    0.012004361f, 0.010264101f, 0.008532210f, 0.006808777f, 0.005093819f,
+    0.003387353f, 0.001689399f, -0.000000024f, -0.001680900f, -0.003353210f,
+    -0.005016938f, -0.006672067f, -0.008318579f, -0.009956459f, -0.011585629f,
+    -0.013206195f, -0.014818084f, -0.016421281f, -0.018015765f, -0.019601526f,
+    -0.021178551f, -0.022746822f, -0.024306327f, -0.025857056f, -0.027398987f,
+    -0.028932119f, -0.030456433f, -0.031971917f, -0.033478502f, -0.034976289f,
+    -0.036465216f, -0.037945267f, -0.039416436f, -0.040878706f, -0.042332072f,
+    -0.043776520f, -0.045212042f, -0.046638630f, -0.048056271f, -0.049464963f,
+    -0.050864697f, -0.052255459f, -0.053637192f, -0.055009995f, -0.056373812f,
+    -0.057728622f, -0.059074435f, -0.060411237f, -0.061739020f, -0.063057788f,
+    -0.064367518f, -0.065668218f, -0.066959888f, -0.068242513f, -0.069516085f,
+    -0.070780613f, -0.072036028f, -0.073282443f, -0.074519798f, -0.075748093f,
+    -0.076967306f, -0.078177467f, -0.079378553f, -0.080570564f, -0.081753515f,
+    -0.082927369f, -0.084092163f, -0.085247882f, -0.086394526f, -0.087532081f,
+    -0.088660523f, -0.089779936f, -0.090890266f, -0.091991536f, -0.093083732f,
+    -0.094166860f, -0.095240898f, -0.096305899f, -0.097361818f, -0.098408684f,
+    -0.099446490f, -0.100475237f, -0.101494931f, -0.102505587f, -0.103507154f,
+    -0.104499720f, -0.105483264f, -0.106457770f, -0.107423261f, -0.108379729f,
+    -0.109327182f, -0.110265635f, -0.111195073f, -0.112115517f, -0.113026999f,
+    -0.113929473f, -0.114823014f, -0.115707509f, -0.116583094f, -0.117449738f,
+    -0.118307441f, -0.119156219f, -0.119996056f, -0.120826989f, -0.121649019f,
+    -0.122462146f, -0.123266406f, -0.124061778f, -0.124848284f, -0.125625938f,
+    -0.126394749f, -0.127154693f, -0.127905846f, -0.128648207f, -0.129381746f,
+    -0.130106509f, -0.130822510f, -0.131529734f, -0.132228225f, -0.132917970f,
+    -0.133599013f, -0.134271339f, -0.134934962f, -0.135589913f, -0.136236191f,
+    -0.136873797f, -0.137502789f, -0.138123170f, -0.138734937f, -0.139338136f,
+    -0.139932722f, -0.140518770f, -0.141096294f, -0.141665265f, -0.142225727f,
+    -0.142777696f, -0.143321201f, -0.143856242f, -0.144382849f, -0.144900993f,
+    -0.145410761f, -0.145912141f, -0.146405146f, -0.146889821f, -0.147366136f,
+    -0.147834152f, -0.148293883f, -0.148745313f, -0.149188504f, -0.149623469f,
+    -0.150050193f, -0.150468737f, -0.150879115f, -0.151281342f, -0.151675433f,
+    -0.152061403f, -0.152439296f, -0.152809098f, -0.153170869f, -0.153524607f,
+    -0.153870359f, -0.154208109f, -0.154537901f, -0.154859766f, -0.155173704f,
+    -0.155479759f, -0.155777946f, -0.156068295f, -0.156350806f, -0.156625539f,
+    -0.156892478f, -0.157151699f, -0.157403171f, -0.157646939f, -0.157883018f,
+    -0.158111468f, -0.158332288f, -0.158545509f, -0.158751160f, -0.158949256f,
+    -0.159139827f, -0.159322888f, -0.159498483f, -0.159666643f, -0.159827381f,
+    -0.159980699f, -0.160126686f, -0.160265297f, -0.160396621f, -0.160520658f,
+    -0.160637438f, -0.160746962f, -0.160849288f, -0.160944447f, -0.161032468f,
+    -0.161113337f, -0.161187142f, -0.161253884f, -0.161313564f, -0.161366254f,
+    -0.161411941f, -0.161450699f, -0.161482543f, -0.161507472f, -0.161525562f,
+    -0.161536828f, -0.161541268f, -0.161538944f, -0.161529869f, -0.161514089f,
+    -0.161491618f, -0.161462501f, -0.161426738f, -0.161384419f, -0.161335513f,
+    -0.161280081f, -0.161218151f, -0.161149755f, -0.161074907f, -0.160993651f,
+    -0.160906032f, -0.160812065f, -0.160711765f, -0.160605207f, -0.160492390f,
+    -0.160373345f, -0.160248131f, -0.160116762f, -0.159979254f, -0.159835666f,
+    -0.159686014f, -0.159530357f, -0.159368694f, -0.159201056f, -0.159027517f,
+    -0.158848062f, -0.158662766f, -0.158471599f, -0.158274680f, -0.158071980f,
+    -0.157863557f, -0.157649443f, -0.157429650f, -0.157204241f, -0.156973228f,
+    -0.156736642f, -0.156494558f, -0.156246960f, -0.155993909f, -0.155735433f,
+    -0.155471563f, -0.155202329f, -0.154927775f, -0.154647917f, -0.154362813f,
+    -0.154072478f, -0.153776988f, -0.153476328f, -0.153170541f, -0.152859688f,
+    -0.152543753f, -0.152222827f, -0.151896924f, -0.151566073f, -0.151230305f,
+    -0.150889665f, -0.150544196f, -0.150193915f, -0.149838865f, -0.149479061f,
+    -0.149114594f, -0.148745432f, -0.148371637f, -0.147993281f, -0.147610337f,
+    -0.147222877f, -0.146830946f, -0.146434546f, -0.146033719f, -0.145628527f,
+    -0.145218968f, -0.144805118f, -0.144386992f, -0.143964618f, -0.143538073f,
+    -0.143107325f, -0.142672464f, -0.142233476f, -0.141790435f, -0.141343385f,
+    -0.140892327f, -0.140437320f, -0.139978394f, -0.139515579f, -0.139048934f,
+    -0.138578460f, -0.138104215f, -0.137626216f, -0.137144551f, -0.136659175f,
+    -0.136170194f, -0.135677606f, -0.135181442f, -0.134681761f, -0.134178594f,
+    -0.133671984f, -0.133161947f, -0.132648528f, -0.132131740f, -0.131611660f,
+    -0.131088302f, -0.130561695f, -0.130031943f, -0.129498973f, -0.128962860f,
+    -0.128423676f, -0.127881393f, -0.127336115f, -0.126787826f, -0.126236603f,
+    -0.125682443f, -0.125125393f, -0.124565504f, -0.124002807f, -0.123437323f,
+    -0.122869089f, -0.122298159f, -0.121724561f, -0.121148311f, -0.120569460f,
+    -0.119988061f, -0.119404130f, -0.118817687f, -0.118228793f, -0.117637470f,
+    -0.117043748f, -0.116447672f, -0.115849286f, -0.115248613f, -0.114645667f,
+    -0.114040568f, -0.113433234f, -0.112823755f, -0.112212166f, -0.111598492f,
+    -0.110982776f, -0.110365056f, -0.109745361f, -0.109123722f, -0.108500175f,
+    -0.107874751f, -0.107247494f, -0.106618427f, -0.105987601f, -0.105355024f,
+    -0.104720749f, -0.104084812f, -0.103447236f, -0.102808066f, -0.102167316f,
+    -0.101525046f, -0.100881256f, -0.100236014f, -0.099589340f, -0.098941252f,
+    -0.098291807f, -0.097641021f, -0.096988983f, -0.096335620f, -0.095681041f,
+    -0.095025249f, -0.094368286f, -0.093710184f, -0.093050972f, -0.092390701f,
+    -0.091729380f, -0.091067046f, -0.090403758f, -0.089739501f, -0.089074343f,
+    -0.088408306f, -0.087741412f, -0.087073699f, -0.086405218f, -0.085735977f,
+    -0.085065998f, -0.084395349f, -0.083724037f, -0.083052084f, -0.082379535f,
+    -0.081706434f, -0.081032783f, -0.080358639f, -0.079684012f, -0.079008937f,
+    -0.078333504f, -0.077657640f, -0.076981425f, -0.076304883f, -0.075628042f,
+    -0.074950956f, -0.074273616f, -0.073596083f, -0.072918370f, -0.072240517f,
+    -0.071562558f, -0.070884496f, -0.070206381f, -0.069528244f, -0.068850100f,
+    -0.068171993f, -0.067493953f, -0.066815972f, -0.066138126f, -0.065460421f,
+    -0.064782880f, -0.064105548f, -0.063428439f, -0.062751584f, -0.062075011f,
+    -0.061398748f, -0.060722828f, -0.060047265f, -0.059372153f, -0.058697399f,
+    -0.058023106f, -0.057349272f, -0.056675948f, -0.056003150f, -0.055330887f,
+    -0.054659221f, -0.053988155f, -0.053317714f, -0.052647941f, -0.051978838f,
+    -0.051310450f, -0.050642796f, -0.049975898f, -0.049309790f, -0.048644483f,
+    -0.047980014f, -0.047316402f, -0.046653673f, -0.045991853f, -0.045330971f,
+    -0.044671040f, -0.044012092f, -0.043354150f, -0.042697236f, -0.042041373f,
+    -0.041386627f, -0.040732939f, -0.040080376f, -0.039428953f, -0.038778704f,
+    -0.038129643f, -0.037481792f, -0.036835186f, -0.036189832f, -0.035545766f,
+    -0.034902997f, -0.034261558f, -0.033621464f, -0.032982741f, -0.032345407f,
+    -0.031709481f, -0.031074993f, -0.030441960f, -0.029810399f, -0.029180335f,
+    -0.028551787f, -0.027924776f, -0.027299322f, -0.026675448f, -0.026053172f,
+    -0.025432510f, -0.024813488f, -0.024196124f, -0.023580479f, -0.022966485f,
+    -0.022354206f, -0.021743659f, -0.021134868f, -0.020527845f, -0.019922616f,
+    -0.019319192f, -0.018717598f, -0.018117845f, -0.017519956f, -0.016923945f,
+    -0.016329836f, -0.015737642f, -0.015147380f, -0.014559067f, -0.013972721f,
+    -0.013388360f, -0.012805998f, -0.012225654f, -0.011647343f, -0.011071082f,
+    -0.010496887f, -0.009924773f, -0.009354758f, -0.008786854f, -0.008221081f,
+    -0.007657450f, -0.007096022f, -0.006536725f, -0.005979617f, -0.005424712f,
+    -0.004872025f, -0.004321571f, -0.003773364f, -0.003227417f, -0.002683746f,
+    -0.002142363f, -0.001603282f, -0.001066516f, -0.000532080f, 0.000000015f,
+    0.000529755f, 0.001057127f, 0.001582118f, 0.002104717f, 0.002624909f,
+    0.003142685f, 0.003658031f, 0.004170935f, 0.004681387f, 0.005189373f,
+    0.005694883f, 0.006197905f, 0.006698429f, 0.007196404f, 0.007691898f,
+    0.008184860f, 0.008675281f, 0.009163151f, 0.009648458f, 0.010131192f,
+    0.010611345f, 0.011088905f, 0.011563865f, 0.012036213f, 0.012505942f,
+    0.012973041f, 0.013437501f, 0.013899315f, 0.014358475f, 0.014814967f,
+    0.015268789f, 0.015719930f, 0.016168380f, 0.016614137f, 0.017057184f,
+    0.017497523f, 0.017935142f, 0.018370032f, 0.018802188f, 0.019231608f,
+    0.019658273f, 0.020082152f, 0.020503307f, 0.020921690f, 0.021337299f,
+    0.021750130f, 0.022160176f, 0.022567427f, 0.022971880f, 0.023373535f,
+    0.023772376f, 0.024168408f, 0.024561619f, 0.024952007f, 0.025339566f,
+    0.025724288f, 0.026106175f, 0.026485221f, 0.026861422f, 0.027234772f,
+    0.027605265f, 0.027972901f, 0.028337676f, 0.028699588f, 0.029058624f,
+    0.029414795f, 0.029768089f, 0.030118505f, 0.030466037f, 0.030810660f,
+    0.031152423f, 0.031491302f, 0.031827286f, 0.032160383f, 0.032490581f,
+    0.032817882f, 0.033142287f, 0.033463787f, 0.033782389f, 0.034098089f,
+    0.034410883f, 0.034720775f, 0.035027757f, 0.035331838f, 0.035633009f,
+    0.035931274f, 0.036226626f, 0.036519073f, 0.036808614f, 0.037095241f,
+    0.037378959f, 0.037659772f, 0.037937686f, 0.038212679f, 0.038484775f,
+    0.038753960f, 0.039020218f, 0.039283592f, 0.039544068f, 0.039801639f,
+    0.040056318f, 0.040308096f, 0.040556971f, 0.040802956f, 0.041046046f,
+    0.041286245f, 0.041523557f, 0.041757982f, 0.041989524f, 0.042218179f,
+    0.042443957f, 0.042666860f, 0.042886890f, 0.043104045f, 0.043318339f,
+    0.043529764f, 0.043738328f, 0.043944035f, 0.044146888f, 0.044346895f,
+    0.044544052f, 0.044738363f, 0.044929843f, 0.045118481f, 0.045304272f,
+    0.045487255f, 0.045667417f, 0.045844764f, 0.046019293f, 0.046191018f,
+    0.046359941f, 0.046526067f, 0.046689399f, 0.046849940f, 0.047007702f,
+    0.047162689f, 0.047314901f, 0.047464348f, 0.047611035f, 0.047754966f,
+    0.047896147f, 0.048034586f, 0.048170291f, 0.048303265f, 0.048433512f,
+    0.048561048f, 0.048685864f, 0.048807982f, 0.048927400f, 0.049044125f,
+    0.049158167f, 0.049269531f, 0.049378205f, 0.049484238f, 0.049587611f,
+    0.049688339f, 0.049786422f, 0.049881872f, 0.049974691f, 0.050064899f,
+    0.050152492f, 0.050237484f, 0.050319877f, 0.050399683f, 0.050476916f,
+    0.050551571f, 0.050623666f, 0.050693203f, 0.050760195f, 0.050824653f,
+    0.050886583f, 0.050945986f, 0.051002879f, 0.051057268f, 0.051109165f,
+    0.051158577f, 0.051205512f, 0.051249981f, 0.051291991f, 0.051331542f,
+    0.051368665f, 0.051403359f, 0.051435627f, 0.051465489f, 0.051492948f,
+    0.051518012f, 0.051540703f, 0.051561009f, 0.051578961f, 0.051594563f,
+    0.051607810f, 0.051618744f, 0.051627338f, 0.051633626f, 0.051637612f,
+    0.051639307f, 0.051638719f, 0.051635865f, 0.051630747f, 0.051623378f,
+    0.051613763f, 0.051601931f, 0.051587880f, 0.051571615f, 0.051553156f,
+    0.051532514f, 0.051509693f, 0.051484708f, 0.051457576f, 0.051428299f,
+    0.051396891f, 0.051363368f, 0.051327739f, 0.051290002f, 0.051250193f,
+    0.051208302f, 0.051164351f, 0.051118344f, 0.051070303f, 0.051020239f,
+    0.050968144f, 0.050914053f, 0.050857969f, 0.050799899f, 0.050739862f,
+    0.050677869f, 0.050613929f, 0.050548054f, 0.050480254f, 0.050410546f,
+    0.050338943f, 0.050265454f, 0.050190084f, 0.050112855f, 0.050033774f,
+    0.049952857f, 0.049870111f, 0.049785554f, 0.049699202f, 0.049611051f,
+    0.049521122f, 0.049429435f, 0.049335998f, 0.049240820f, 0.049143907f,
+    0.049045283f, 0.048944961f, 0.048842940f, 0.048739251f, 0.048633892f,
+    0.048526883f, 0.048418235f, 0.048307955f, 0.048196062f, 0.048082568f,
+    0.047967490f, 0.047850832f, 0.047732603f, 0.047612831f, 0.047491513f,
+    0.047368675f, 0.047244325f, 0.047118478f, 0.046991132f, 0.046862319f,
+    0.046732042f, 0.046600312f, 0.046467155f, 0.046332560f, 0.046196572f,
+    0.046059173f, 0.045920394f, 0.045780238f, 0.045638733f, 0.045495875f,
+    0.045351684f, 0.045206167f, 0.045059349f, 0.044911236f, 0.044761848f,
+    0.044611182f, 0.044459261f, 0.044306096f, 0.044151701f, 0.043996092f,
+    0.043839272f, 0.043681268f, 0.043522079f, 0.043361723f, 0.043200217f,
+    0.043037571f, 0.042873796f, 0.042708915f, 0.042542927f, 0.042375844f,
+    0.042207699f, 0.042038482f, 0.041868217f, 0.041696910f, 0.041524585f,
+    0.041351244f, 0.041176908f, 0.041001581f, 0.040825289f, 0.040648032f,
+    0.040469825f, 0.040290687f, 0.040110629f, 0.039929654f, 0.039747790f,
+    0.039565038f, 0.039381415f, 0.039196935f, 0.039011609f, 0.038825445f,
+    0.038638465f, 0.038450673f, 0.038262092f, 0.038072724f, 0.037882581f,
+    0.037691690f, 0.037500042f, 0.037307668f, 0.037114572f, 0.036920771f,
+    0.036726266f, 0.036531083f, 0.036335230f, 0.036138717f, 0.035941560f,
+    0.035743766f, 0.035545345f, 0.035346344f, 0.035146721f, 0.034946512f,
+    0.034745730f, 0.034544386f, 0.034342494f, 0.034140065f, 0.033937111f,
+    0.033733644f, 0.033529676f, 0.033325221f, 0.033120286f, 0.032914892f,
+    0.032709036f, 0.032502741f, 0.032296017f, 0.032088876f, 0.031881329f,
+    0.031673383f, 0.031465057f, 0.031256359f, 0.031047301f, 0.030837893f,
+    0.030628148f, 0.030418083f, 0.030207697f, 0.029997014f, 0.029786035f,
+    0.029574780f, 0.029363252f, 0.029151469f, 0.028939439f, 0.028727176f,
+    0.028514685f, 0.028301982f, 0.028089074f, 0.027875982f, 0.027662706f,
+    0.027449260f, 0.027235655f, 0.027021904f, 0.026808018f, 0.026594002f,
+    0.026379872f, 0.026165638f, 0.025951311f, 0.025736896f, 0.025522409f,
+    0.025307864f, 0.025093259f, 0.024878617f, 0.024663944f, 0.024449248f,
+    0.024234539f, 0.024019832f, 0.023805158f, 0.023590479f, 0.023375830f,
+    0.023161218f, 0.022946658f, 0.022732155f, 0.022517720f, 0.022303363f,
+    0.022089096f, 0.021874927f, 0.021660868f, 0.021446921f, 0.021233102f,
+    0.021019425f, 0.020805888f, 0.020592507f, 0.020379292f, 0.020166250f,
+    0.019953389f, 0.019740723f, 0.019528257f, 0.019316001f, 0.019103965f,
+    0.018892156f, 0.018680587f, 0.018469261f, 0.018258194f, 0.018047387f,
+    0.017836852f, 0.017626595f, 0.017416634f, 0.017206967f, 0.016997607f,
+    0.016788563f, 0.016579840f, 0.016371451f, 0.016163401f, 0.015955698f,
+    0.015748354f, 0.015541371f, 0.015334761f, 0.015128531f, 0.014922690f,
+    0.014717245f, 0.014512201f, 0.014307571f, 0.014103360f, 0.013899575f,
+    0.013696224f, 0.013493315f, 0.013290856f, 0.013088853f, 0.012887316f,
+    0.012686247f, 0.012485661f, 0.012285583f, 0.012085971f, 0.011886863f,
+    0.011688258f, 0.011490168f, 0.011292599f, 0.011095556f, 0.010899050f,
+    0.010703083f, 0.010507663f, 0.010312798f, 0.010118493f, 0.009924755f,
+    0.009731592f, 0.009539006f, 0.009347008f, 0.009155600f, 0.008964794f,
+    0.008774590f, 0.008584999f, 0.008396022f, 0.008207668f, 0.008019943f,
+    0.007832851f, 0.007646400f, 0.007460595f, 0.007275441f, 0.007090943f,
+    0.006907108f, 0.006723941f, 0.006541446f, 0.006359630f, 0.006178498f,
+    0.005998055f, 0.005818305f, 0.005639255f, 0.005460909f, 0.005283272f,
+    0.005106349f, 0.004930146f, 0.004754666f, 0.004579914f, 0.004405896f,
+    0.004232615f, 0.004060077f, 0.003888285f, 0.003717245f, 0.003546960f,
+    0.003377435f, 0.003208674f, 0.003040682f, 0.002873462f, 0.002707019f,
+    0.002541356f, 0.002376478f, 0.002212389f, 0.002049116f, 0.001886615f,
+    0.001724914f, 0.001564016f, 0.001403926f, 0.001244646f, 0.001086180f,
+    0.000928532f, 0.000771705f, 0.000615702f, 0.000460527f, 0.000306183f,
+    0.000152673f, -0.000000001f, -0.000151834f, -0.000302824f, -0.000452968f,
+    -0.000602263f, -0.000750707f, -0.000898296f, -0.001045028f, -0.001190900f,
+    -0.001335910f, -0.001480055f, -0.001623332f, -0.001765741f, -0.001907276f,
+    -0.002047938f, -0.002187723f, -0.002326628f, -0.002464653f, -0.002601795f,
+    -0.002738052f, -0.002873422f, -0.003007903f, -0.003141493f, -0.003274190f,
+    -0.003405993f, -0.003536900f, -0.003666909f, -0.003796018f, -0.003924227f,
+    -0.004051533f, -0.004177936f, -0.004303433f, -0.004428024f, -0.004551707f,
+    -0.004674482f, -0.004796346f, -0.004917298f, -0.005037338f, -0.005156465f,
+    -0.005274678f, -0.005391975f, -0.005508356f, -0.005623801f, -0.005738347f,
+    -0.005851975f, -0.005964684f, -0.006076474f, -0.006187343f, -0.006297291f,
+    -0.006406318f, -0.006514424f, -0.006621608f, -0.006727869f, -0.006833209f,
+    -0.006937624f, -0.007041118f, -0.007143687f, -0.007245334f, -0.007346058f,
+    -0.007445859f, -0.007544736f, -0.007642691f, -0.007739722f, -0.007835831f,
+    -0.007931018f, -0.008025283f, -0.008118626f, -0.008211047f, -0.008302549f,
+    -0.008393129f, -0.008482790f, -0.008571531f, -0.008659353f, -0.008746257f,
+    -0.008832245f, -0.008917316f, -0.009001471f, -0.009084711f, -0.009167036f,
+    -0.009248449f, -0.009328948f, -0.009408538f, -0.009487216f, -0.009564986f,
+    -0.009641849f, -0.009717803f, -0.009792852f, -0.009866998f, -0.009940239f,
+    -0.010012579f, -0.010084019f, -0.010154560f, -0.010224204f, -0.010292951f,
+    -0.010360803f, -0.010427763f, -0.010493831f, -0.010558996f, -0.010623286f,
+    -0.010686691f, -0.010749210f, -0.010810846f, -0.010871602f, -0.010931478f,
+    -0.010990476f, -0.011048601f, -0.011105850f, -0.011162230f, -0.011217739f,
+    -0.011272381f, -0.011326157f, -0.011379071f, -0.011431124f, -0.011482318f,
+    -0.011532655f, -0.011582140f, -0.011630770f, -0.011678550f, -0.011725485f,
+    -0.011771576f, -0.011816822f, -0.011861229f, -0.011904799f, -0.011947533f,
+    -0.011989436f, -0.012030509f, -0.012070752f, -0.012110173f, -0.012148771f,
+    -0.012186551f, -0.012223513f, -0.012259661f, -0.012295000f, -0.012329529f,
+    -0.012363252f, -0.012396174f, -0.012428297f, -0.012459621f, -0.012490152f,
+    -0.012519893f, -0.012548844f, -0.012577013f, -0.012604399f, -0.012631006f,
+    -0.012656839f, -0.012681897f, -0.012706185f, -0.012729709f, -0.012752469f,
+    -0.012774469f, -0.012795713f, -0.012816204f, -0.012835944f, -0.012854930f,
+    -0.012873179f, -0.012890689f, -0.012907463f, -0.012923501f, -0.012938812f,
+    -0.012953395f, -0.012967254f, -0.012980393f, -0.012992817f, -0.013004529f,
+    -0.013015532f, -0.013025828f, -0.013035421f, -0.013044316f, -0.013052518f,
+    -0.013060026f, -0.013066847f, -0.013072984f, -0.013078442f, -0.013083221f,
+    -0.013087329f, -0.013090767f, -0.013093537f, -0.013095647f, -0.013097100f,
+    -0.013097897f, -0.013098043f, -0.013097542f, -0.013096399f, -0.013094617f,
+    -0.013092197f, -0.013089147f, -0.013085471f, -0.013081170f, -0.013076247f,
+    -0.013070711f, -0.013064560f, -0.013057803f, -0.013050442f, -0.013042479f,
+    -0.013033919f, -0.013024768f, -0.013015027f, -0.013004702f, -0.012993797f,
+    -0.012982314f, -0.012970260f, -0.012957636f, -0.012944449f, -0.012930701f,
+    -0.012916395f, -0.012901539f, -0.012886133f, -0.012870182f, -0.012853689f,
+    -0.012836664f, -0.012819104f, -0.012801019f, -0.012782406f, -0.012763276f,
+    -0.012743629f, -0.012723471f, -0.012702805f, -0.012681637f, -0.012659966f,
+    -0.012637801f, -0.012615148f, -0.012592005f, -0.012568381f, -0.012544277f,
+    -0.012519698f, -0.012494650f, -0.012469133f, -0.012443157f, -0.012416720f,
+    -0.012389832f, -0.012362492f, -0.012334707f, -0.012306482f, -0.012277817f,
+    -0.012248720f, -0.012219194f, -0.012189244f, -0.012158873f, -0.012128084f,
+    -0.012096884f, -0.012065274f, -0.012033261f, -0.012000849f, -0.011968041f,
+    -0.011934839f, -0.011901250f, -0.011867279f, -0.011832927f, -0.011798202f,
+    -0.011763104f, -0.011727640f, -0.011691812f, -0.011655626f, -0.011619086f,
+    -0.011582195f, -0.011544957f, -0.011507377f, -0.011469459f, -0.011431207f,
+    -0.011392625f, -0.011353718f, -0.011314487f, -0.011274938f, -0.011235079f,
+    -0.011194907f, -0.011154431f, -0.011113651f, -0.011072575f, -0.011031206f,
+    -0.010989547f, -0.010947601f, -0.010905375f, -0.010862871f, -0.010820094f,
+    -0.010777046f, -0.010733733f, -0.010690158f, -0.010646327f, -0.010602240f,
+    -0.010557905f, -0.010513324f, -0.010468500f, -0.010423439f, -0.010378144f,
+    -0.010332618f, -0.010286866f, -0.010240891f, -0.010194698f, -0.010148291f,
+    -0.010101672f, -0.010054846f, -0.010007816f, -0.009960588f, -0.009913164f,
+    -0.009865548f, -0.009817744f, -0.009769755f, -0.009721586f, -0.009673241f,
+    -0.009624721f, -0.009576033f, -0.009527179f, -0.009478163f, -0.009428989f,
+    -0.009379660f, -0.009330180f, -0.009280552f, -0.009230781f, -0.009180869f,
+    -0.009130822f, -0.009080641f, -0.009030331f, -0.008979894f, -0.008929336f,
+    -0.008878659f, -0.008827867f, -0.008776963f, -0.008725950f, -0.008674833f,
+    -0.008623619f, -0.008572303f, -0.008520893f, -0.008469390f, -0.008417801f,
+    -0.008366127f, -0.008314372f, -0.008262540f, -0.008210634f, -0.008158657f,
+    -0.008106613f, -0.008054503f, -0.008002332f, -0.007950104f, -0.007897821f,
+    -0.007845488f, -0.007793106f, -0.007740679f, -0.007688211f, -0.007635703f,
+    -0.007583159f, -0.007530585f, -0.007477981f, -0.007425350f, -0.007372697f,
+    -0.007320023f, -0.007267332f, -0.007214627f, -0.007161912f, -0.007109188f,
+    -0.007056459f, -0.007003729f, -0.006951000f, -0.006898273f, -0.006845553f,
+    -0.006792843f, -0.006740147f, -0.006687465f, -0.006634800f, -0.006582157f,
+    -0.006529537f, -0.006476944f, -0.006424380f, -0.006371849f, -0.006319351f,
+    -0.006266891f, -0.006214471f, -0.006162094f, -0.006109761f, -0.006057477f,
+    -0.006005243f, -0.005953063f, -0.005900938f, -0.005848871f, -0.005796865f,
+    -0.005744927f, -0.005693051f, -0.005641241f, -0.005589503f, -0.005537837f,
+    -0.005486248f, -0.005434736f, -0.005383304f, -0.005331955f, -0.005280690f,
+    -0.005229514f, -0.005178426f, -0.005127430f, -0.005076529f, -0.005025723f,
+    -0.004975016f, -0.004924410f, -0.004873907f, -0.004823509f, -0.004773218f,
+    -0.004723036f, -0.004672966f, -0.004623009f, -0.004573168f, -0.004523444f,
+    -0.004473840f, -0.004424357f, -0.004374999f, -0.004325765f, -0.004276660f,
+    -0.004227683f, -0.004178838f, -0.004130126f, -0.004081549f, -0.004033110f,
+    -0.003984808f, -0.003936647f, -0.003888629f, -0.003840754f, -0.003793026f,
+    -0.003745445f, -0.003698014f, -0.003650733f, -0.003603605f, -0.003556631f,
+    -0.003509813f, -0.003463153f, -0.003416652f, -0.003370312f, -0.003324133f,
+    -0.003278119f, -0.003232269f, -0.003186587f, -0.003141073f, -0.003095729f,
+    -0.003050560f, -0.003005560f, -0.002960733f, -0.002916081f, -0.002871606f,
+    -0.002827310f, -0.002783192f, -0.002739255f, -0.002695500f, -0.002651928f,
+    -0.002608541f, -0.002565339f, -0.002522324f, -0.002479498f, -0.002436860f,
+    -0.002394413f, -0.002352157f, -0.002310094f, -0.002268225f, -0.002226550f,
+    -0.002185071f, -0.002143790f, -0.002102705f, -0.002061821f, -0.002021135f,
+    -0.001980651f, -0.001940368f, -0.001900289f, -0.001860412f, -0.001820740f,
+    -0.001781274f, -0.001742014f, -0.001702961f, -0.001664116f, -0.001625479f,
+    -0.001587052f, -0.001548836f, -0.001510830f, -0.001473036f, -0.001435455f,
+    -0.001398086f, -0.001360932f, -0.001323992f, -0.001287267f, -0.001250757f,
+    -0.001214464f, -0.001178389f, -0.001142530f, -0.001106890f, -0.001071468f,
+    -0.001036266f, -0.001001283f, -0.000966520f, -0.000931978f, -0.000897657f,
+    -0.000863557f, -0.000829685f, -0.000796029f, -0.000762597f, -0.000729387f,
+    -0.000696401f, -0.000663639f, -0.000631101f, -0.000598788f, -0.000566699f,
+    -0.000534836f, -0.000503197f, -0.000471784f, -0.000440597f, -0.000409636f,
+    -0.000378901f, -0.000348393f, -0.000318111f, -0.000288056f, -0.000258228f,
+    -0.000228626f, -0.000199252f, -0.000170105f, -0.000141186f, -0.000112493f,
+    -0.000084028f, -0.000055791f, -0.000027781f, 0.000000002f, 0.000027557f,
+    0.000054884f, 0.000081984f, 0.000108857f, 0.000135502f, 0.000161920f,
+    0.000188111f, 0.000214075f, 0.000239812f, 0.000265322f, 0.000290606f,
+    0.000315663f, 0.000340493f, 0.000365097f, 0.000389476f, 0.000413628f,
+    0.000437555f, 0.000461256f, 0.000484733f, 0.000507984f, 0.000531011f,
+    0.000553814f, 0.000576393f, 0.000598748f, 0.000620879f, 0.000642788f,
+    0.000664473f, 0.000685933f, 0.000707174f, 0.000728194f, 0.000748993f,
+    0.000769570f, 0.000789927f, 0.000810064f, 0.000829982f, 0.000849680f,
+    0.000869160f, 0.000888421f, 0.000907465f, 0.000926291f, 0.000944901f,
+    0.000963294f, 0.000981472f, 0.000999434f, 0.001017181f, 0.001034715f,
+    0.001052034f, 0.001069141f, 0.001086035f, 0.001102717f, 0.001119188f,
+    0.001135448f, 0.001151499f, 0.001167339f, 0.001182971f, 0.001198395f,
+    0.001213611f, 0.001228620f, 0.001243423f, 0.001258021f, 0.001272413f,
+    0.001286602f, 0.001300586f, 0.001314368f, 0.001327948f, 0.001341327f,
+    0.001354505f, 0.001367483f, 0.001380263f, 0.001392843f, 0.001405226f,
+    0.001417413f, 0.001429403f, 0.001441198f, 0.001452798f, 0.001464205f,
+    0.001475418f, 0.001486440f, 0.001497271f, 0.001507911f, 0.001518361f,
+    0.001528623f, 0.001538696f, 0.001548581f, 0.001558281f, 0.001567796f,
+    0.001577127f, 0.001586274f, 0.001595238f, 0.001604020f, 0.001612622f,
+    0.001621043f, 0.001629285f, 0.001637349f, 0.001645236f, 0.001652946f,
+    0.001660481f, 0.001667841f, 0.001675027f, 0.001682041f, 0.001688883f,
+    0.001695554f, 0.001702055f, 0.001708387f, 0.001714552f, 0.001720549f,
+    0.001726380f, 0.001732047f, 0.001737549f, 0.001742888f, 0.001748065f,
+    0.001753081f, 0.001757936f, 0.001762632f, 0.001767171f, 0.001771552f,
+    0.001775777f, 0.001779847f, 0.001783762f, 0.001787525f, 0.001791135f,
+    0.001794595f, 0.001797904f, 0.001801064f, 0.001804076f, 0.001806941f,
+    0.001809660f, 0.001812234f, 0.001814664f, 0.001816952f, 0.001819097f,
+    0.001821102f, 0.001822967f, 0.001824693f, 0.001826282f, 0.001827733f,
+    0.001829050f, 0.001830231f, 0.001831278f, 0.001832194f, 0.001832979f,
+    0.001833633f, 0.001834158f, 0.001834554f, 0.001834824f, 0.001834967f,
+    0.001834986f, 0.001834880f, 0.001834651f, 0.001834301f, 0.001833830f,
+    0.001833239f, 0.001832529f, 0.001831702f, 0.001830758f, 0.001829698f,
+    0.001828525f, 0.001827237f, 0.001825838f, 0.001824327f, 0.001822706f,
+    0.001820976f, 0.001819138f, 0.001817193f, 0.001815141f, 0.001812985f,
+    0.001810725f, 0.001808363f, 0.001805898f, 0.001803333f, 0.001800668f,
+    0.001797904f, 0.001795043f, 0.001792086f, 0.001789033f, 0.001785886f,
+    0.001782645f, 0.001779312f, 0.001775887f, 0.001772373f, 0.001768769f,
+    0.001765078f, 0.001761299f, 0.001757434f, 0.001753483f, 0.001749449f,
+    0.001745332f, 0.001741133f, 0.001736853f, 0.001732493f, 0.001728054f,
+    0.001723537f, 0.001718944f, 0.001714273f, 0.001709529f, 0.001704710f,
+    0.001699819f, 0.001694857f, 0.001689823f, 0.001684719f, 0.001679546f,
+    0.001674306f, 0.001668998f, 0.001663625f, 0.001658187f, 0.001652685f,
+    0.001647120f, 0.001641493f, 0.001635804f, 0.001630056f, 0.001624249f,
+    0.001618383f, 0.001612461f, 0.001606481f, 0.001600448f, 0.001594359f,
+    0.001588217f, 0.001582022f, 0.001575776f, 0.001569480f, 0.001563134f,
+    0.001556739f, 0.001550296f, 0.001543806f, 0.001537270f, 0.001530689f,
+    0.001524064f, 0.001517395f, 0.001510684f, 0.001503932f, 0.001497139f,
+    0.001490306f, 0.001483435f, 0.001476525f, 0.001469578f, 0.001462596f,
+    0.001455577f, 0.001448524f, 0.001441438f, 0.001434318f, 0.001427167f,
+    0.001419984f, 0.001412771f, 0.001405529f, 0.001398258f, 0.001390959f,
+    0.001383633f, 0.001376281f, 0.001368903f, 0.001361501f, 0.001354076f,
+    0.001346627f, 0.001339155f, 0.001331663f, 0.001324150f, 0.001316617f,
+    0.001309064f, 0.001301494f, 0.001293906f, 0.001286301f, 0.001278680f,
+    0.001271044f, 0.001263393f, 0.001255728f, 0.001248050f, 0.001240360f,
+    0.001232658f, 0.001224945f, 0.001217221f, 0.001209488f, 0.001201747f,
+    0.001193997f, 0.001186240f, 0.001178476f, 0.001170706f, 0.001162930f,
+    0.001155150f, 0.001147365f, 0.001139577f, 0.001131787f, 0.001123994f,
+    0.001116200f, 0.001108405f, 0.001100609f, 0.001092814f, 0.001085020f,
+    0.001077228f, 0.001069438f, 0.001061651f, 0.001053867f, 0.001046087f,
+    0.001038312f, 0.001030542f, 0.001022778f, 0.001015020f, 0.001007270f,
+    0.000999526f, 0.000991791f, 0.000984065f, 0.000976347f, 0.000968640f,
+    0.000960942f, 0.000953256f, 0.000945580f, 0.000937917f, 0.000930266f,
+    0.000922628f, 0.000915002f, 0.000907391f, 0.000899794f, 0.000892212f,
+    0.000884646f, 0.000877095f, 0.000869560f, 0.000862042f, 0.000854541f,
+    0.000847058f, 0.000839593f, 0.000832147f, 0.000824719f, 0.000817311f,
+    0.000809923f, 0.000802555f, 0.000795208f, 0.000787881f, 0.000780577f,
+    0.000773294f, 0.000766033f, 0.000758795f, 0.000751581f, 0.000744389f,
+    0.000737222f, 0.000730079f, 0.000722960f, 0.000715866f, 0.000708798f,
+    0.000701755f, 0.000694738f, 0.000687748f, 0.000680784f, 0.000673847f,
+    0.000666937f, 0.000660055f, 0.000653202f, 0.000646376f, 0.000639579f,
+    0.000632810f, 0.000626071f, 0.000619362f, 0.000612682f, 0.000606032f,
+    0.000599412f, 0.000592823f, 0.000586265f, 0.000579738f, 0.000573242f,
+    0.000566777f, 0.000560345f, 0.000553944f, 0.000547577f, 0.000541241f,
+    0.000534938f, 0.000528668f, 0.000522432f, 0.000516228f, 0.000510059f,
+    0.000503923f, 0.000497821f, 0.000491753f, 0.000485720f, 0.000479721f,
+    0.000473757f, 0.000467828f, 0.000461934f, 0.000456075f, 0.000450252f,
+    0.000444464f, 0.000438712f, 0.000432996f, 0.000427316f, 0.000421672f,
+    0.000416064f, 0.000410493f, 0.000404958f, 0.000399460f, 0.000393998f,
+    0.000388574f, 0.000383186f, 0.000377836f, 0.000372523f, 0.000367247f,
+    0.000362008f, 0.000356807f, 0.000351643f, 0.000346517f, 0.000341429f,
+    0.000336378f, 0.000331366f, 0.000326391f, 0.000321454f, 0.000316555f,
+    0.000311695f, 0.000306872f, 0.000302088f, 0.000297341f, 0.000292633f,
+    0.000287963f, 0.000283332f, 0.000278739f, 0.000274184f, 0.000269667f,
+    0.000265189f, 0.000260749f, 0.000256348f, 0.000251985f, 0.000247661f,
+    0.000243374f, 0.000239126f, 0.000234917f, 0.000230745f, 0.000226613f,
+    0.000222518f, 0.000218462f, 0.000214443f, 0.000210464f, 0.000206522f,
+    0.000202618f, 0.000198753f, 0.000194926f, 0.000191136f, 0.000187385f,
+    0.000183671f, 0.000179996f, 0.000176358f, 0.000172758f, 0.000169195f,
+    0.000165670f, 0.000162183f, 0.000158733f, 0.000155321f, 0.000151945f,
+    0.000148607f, 0.000145307f, 0.000142043f, 0.000138816f, 0.000135626f,
+    0.000132473f, 0.000129356f, 0.000126276f, 0.000123233f, 0.000120225f,
+    0.000117255f, 0.000114320f, 0.000111421f, 0.000108558f, 0.000105731f,
+    0.000102940f, 0.000100184f, 0.000097463f, 0.000094778f, 0.000092128f,
+    0.000089513f, 0.000086933f, 0.000084388f, 0.000081878f, 0.000079402f,
+    0.000076960f, 0.000074552f, 0.000072179f, 0.000069839f, 0.000067534f,
+    0.000065261f, 0.000063023f, 0.000060817f, 0.000058645f, 0.000056506f,
+    0.000054399f, 0.000052326f, 0.000050284f, 0.000048275f, 0.000046299f,
+    0.000044354f, 0.000042441f, 0.000040560f, 0.000038710f, 0.000036891f,
+    0.000035104f, 0.000033348f, 0.000031622f, 0.000029927f, 0.000028263f,
+    0.000026628f, 0.000025024f, 0.000023450f, 0.000021905f, 0.000020390f,
+    0.000018904f, 0.000017447f, 0.000016019f, 0.000014620f, 0.000013249f,
+    0.000011907f, 0.000010593f, 0.000009307f, 0.000008048f, 0.000006818f,
+    0.000005614f, 0.000004438f, 0.000003288f, 0.000002166f, 0.000001070f,
+    -0.000000000f
+};
+
+static const float ResamplerFilterDifference[RESAMPLER_FILTER_SIZE] = {
+    -0.000006318f, -0.000019312f, -0.000033081f, -0.000046730f, -0.000060380f,
+    -0.000074029f, -0.000087738f, -0.000101388f, -0.000115037f, -0.000128686f,
+    -0.000142336f, -0.000155985f, -0.000169694f, -0.000183165f, -0.000196993f,
+    -0.000210524f, -0.000224173f, -0.000237763f, -0.000251293f, -0.000265062f,
+    -0.000278592f, -0.000292122f, -0.000305772f, -0.000319421f, -0.000332832f,
+    -0.000346422f, -0.000359952f, -0.000373542f, -0.000387073f, -0.000400543f,
+    -0.000414014f, -0.000427663f, -0.000441074f, -0.000454485f, -0.000468016f,
+    -0.000481427f, -0.000494778f, -0.000508308f, -0.000521660f, -0.000535011f,
+    -0.000548482f, -0.000561833f, -0.000575066f, -0.000588536f, -0.000601768f,
+    -0.000615180f, -0.000628352f, -0.000641525f, -0.000655055f, -0.000668049f,
+    -0.000681281f, -0.000694513f, -0.000707746f, -0.000720799f, -0.000733972f,
+    -0.000747204f, -0.000760138f, -0.000773191f, -0.000786424f, -0.000799239f,
+    -0.000812411f, -0.000825346f, -0.000838339f, -0.000851214f, -0.000864267f,
+    -0.000877023f, -0.000890017f, -0.000902772f, -0.000915587f, -0.000928521f,
+    -0.000941217f, -0.000953972f, -0.000966668f, -0.000979364f, -0.000992119f,
+    -0.001004696f, -0.001017392f, -0.001029909f, -0.001042426f, -0.001055002f,
+    -0.001067519f, -0.001080096f, -0.001092434f, -0.001104832f, -0.001117289f,
+    -0.001129627f, -0.001141965f, -0.001154304f, -0.001166403f, -0.001178861f,
+    -0.001191020f, -0.001203120f, -0.001215160f, -0.001227558f, -0.001239419f,
+    -0.001251400f, -0.001263618f, -0.001275480f, -0.001287460f, -0.001299262f,
+    -0.001311302f, -0.001322985f, -0.001334965f, -0.001346648f, -0.001358271f,
+    -0.001370072f, -0.001381695f, -0.001393259f, -0.001404881f, -0.001416504f,
+    -0.001427948f, -0.001439393f, -0.001450837f, -0.001462340f, -0.001473546f,
+    -0.001484871f, -0.001496255f, -0.001507342f, -0.001518726f, -0.001529694f,
+    -0.001540840f, -0.001552045f, -0.001562893f, -0.001574039f, -0.001584947f,
+    -0.001595795f, -0.001606703f, -0.001617491f, -0.001628280f, -0.001639009f,
+    -0.001649678f, -0.001660407f, -0.001670957f, -0.001681507f, -0.001692057f,
+    -0.001702428f, -0.001713037f, -0.001723289f, -0.001733601f, -0.001743913f,
+    -0.001754165f, -0.001764417f, -0.001774490f, -0.001784563f, -0.001794696f,
+    -0.001804650f, -0.001814663f, -0.001824498f, -0.001834452f, -0.001844168f,
+    -0.001854002f, -0.001863778f, -0.001873314f, -0.001883030f, -0.001892567f,
+    -0.001902103f, -0.001911521f, -0.001920938f, -0.001930356f, -0.001939654f,
+    -0.001948893f, -0.001958191f, -0.001967311f, -0.001976430f, -0.001985550f,
+    -0.001994491f, -0.002003491f, -0.002012312f, -0.002021313f, -0.002030015f,
+    -0.002038717f, -0.002047479f, -0.002056181f, -0.002064645f, -0.002073288f,
+    -0.002081692f, -0.002090156f, -0.002098501f, -0.002106905f, -0.002115071f,
+    -0.002123356f, -0.002131462f, -0.002139568f, -0.002147555f, -0.002155662f,
+    -0.002163529f, -0.002171457f, -0.002179205f, -0.002187014f, -0.002194703f,
+    -0.002202272f, -0.002209961f, -0.002217531f, -0.002224922f, -0.002232373f,
+    -0.002239764f, -0.002247095f, -0.002254248f, -0.002261519f, -0.002268672f,
+    -0.002275705f, -0.002282679f, -0.002289712f, -0.002296627f, -0.002303362f,
+    -0.002310216f, -0.002316952f, -0.002323568f, -0.002330244f, -0.002336800f,
+    -0.002343237f, -0.002349675f, -0.002356052f, -0.002362311f, -0.002368629f,
+    -0.002374828f, -0.002380908f, -0.002386987f, -0.002392948f, -0.002398968f,
+    -0.002404809f, -0.002410650f, -0.002416372f, -0.002422094f, -0.002427757f,
+    -0.002433360f, -0.002438903f, -0.002444327f, -0.002449691f, -0.002455056f,
+    -0.002460301f, -0.002465487f, -0.002470732f, -0.002475739f, -0.002480865f,
+    -0.002485693f, -0.002490699f, -0.002495527f, -0.002500176f, -0.002505064f,
+    -0.002509654f, -0.002514243f, -0.002518773f, -0.002523303f, -0.002527595f,
+    -0.002531946f, -0.002536356f, -0.002540410f, -0.002544582f, -0.002548754f,
+    -0.002552748f, -0.002556741f, -0.002560616f, -0.002564371f, -0.002568305f,
+    -0.002571881f, -0.002575636f, -0.002579153f, -0.002582669f, -0.002586126f,
+    -0.002589583f, -0.002592862f, -0.002596140f, -0.002599359f, -0.002602518f,
+    -0.002605557f, -0.002608538f, -0.002611578f, -0.002614439f, -0.002617240f,
+    -0.002620041f, -0.002622724f, -0.002625346f, -0.002627909f, -0.002630413f,
+    -0.002632916f, -0.002635241f, -0.002637565f, -0.002639830f, -0.002642035f,
+    -0.002644122f, -0.002646267f, -0.002648175f, -0.002650142f, -0.002652109f,
+    -0.002653837f, -0.002655566f, -0.002657294f, -0.002658904f, -0.002660453f,
+    -0.002662003f, -0.002663374f, -0.002664745f, -0.002666116f, -0.002667189f,
+    -0.002668560f, -0.002669632f, -0.002670705f, -0.002671599f, -0.002672642f,
+    -0.002673417f, -0.002674311f, -0.002675056f, -0.002675682f, -0.002676308f,
+    -0.002676874f, -0.002677381f, -0.002677768f, -0.002678156f, -0.002678514f,
+    -0.002678722f, -0.002678931f, -0.002679020f, -0.002679110f, -0.002679020f,
+    -0.002679050f, -0.002678901f, -0.002678722f, -0.002678484f, -0.002678186f,
+    -0.002677828f, -0.002677292f, -0.002676904f, -0.002676338f, -0.002675682f,
+    -0.002675027f, -0.002674311f, -0.002673507f, -0.002672672f, -0.002671778f,
+    -0.002670765f, -0.002669752f, -0.002668649f, -0.002667487f, -0.002666295f,
+    -0.002665013f, -0.002663702f, -0.002662301f, -0.002660841f, -0.002659231f,
+    -0.002657771f, -0.002656132f, -0.002654433f, -0.002652735f, -0.002650917f,
+    -0.002649069f, -0.002647102f, -0.002645165f, -0.002643138f, -0.002641022f,
+    -0.002638906f, -0.002636671f, -0.002634317f, -0.002632141f, -0.002629727f,
+    -0.002627254f, -0.002624840f, -0.002622217f, -0.002619684f, -0.002616972f,
+    -0.002614290f, -0.002611518f, -0.002608687f, -0.002605796f, -0.002602875f,
+    -0.002599895f, -0.002596736f, -0.002593726f, -0.002590597f, -0.002587378f,
+    -0.002584100f, -0.002580822f, -0.002577394f, -0.002574027f, -0.002570510f,
+    -0.002566963f, -0.002563447f, -0.002559751f, -0.002556056f, -0.002552360f,
+    -0.002548456f, -0.002544701f, -0.002540767f, -0.002536893f, -0.002532810f,
+    -0.002528816f, -0.002524704f, -0.002520531f, -0.002516329f, -0.002512068f,
+    -0.002507776f, -0.002503395f, -0.002499044f, -0.002494544f, -0.002489939f,
+    -0.002485529f, -0.002480894f, -0.002476230f, -0.002471551f, -0.002466798f,
+    -0.002461985f, -0.002457172f, -0.002452269f, -0.002447322f, -0.002442330f,
+    -0.002437294f, -0.002432242f, -0.002427101f, -0.002421811f, -0.002416730f,
+    -0.002411440f, -0.002406135f, -0.002400786f, -0.002395362f, -0.002389938f,
+    -0.002384409f, -0.002378926f, -0.002373338f, -0.002367705f, -0.002362043f,
+    -0.002356306f, -0.002350554f, -0.002344713f, -0.002338931f, -0.002333075f,
+    -0.002327129f, -0.002321184f, -0.002315164f, -0.002309129f, -0.002303004f,
+    -0.002296925f, -0.002290726f, -0.002284512f, -0.002278253f, -0.002271980f,
+    -0.002265558f, -0.002259284f, -0.002252862f, -0.002246410f, -0.002239943f,
+    -0.002233401f, -0.002226844f, -0.002220228f, -0.002213612f, -0.002206936f,
+    -0.002200201f, -0.002193481f, -0.002186671f, -0.002179854f, -0.002172925f,
+    -0.002166122f, -0.002159171f, -0.002152205f, -0.002145231f, -0.002138190f,
+    -0.002131112f, -0.002124026f, -0.002116874f, -0.002109714f, -0.002102517f,
+    -0.002095275f, -0.002088003f, -0.002080709f, -0.002073303f, -0.002066024f,
+    -0.002058625f, -0.002051190f, -0.002043739f, -0.002036251f, -0.002028733f,
+    -0.002021186f, -0.002013609f, -0.002006002f, -0.001998372f, -0.001990698f,
+    -0.001983009f, -0.001975283f, -0.001967464f, -0.001959760f, -0.001951948f,
+    -0.001944117f, -0.001936268f, -0.001928370f, -0.001920462f, -0.001912523f,
+    -0.001904562f, -0.001896568f, -0.001888555f, -0.001880515f, -0.001872454f,
+    -0.001864363f, -0.001856182f, -0.001848117f, -0.001839954f, -0.001831776f,
+    -0.001823569f, -0.001815341f, -0.001807092f, -0.001798820f, -0.001790524f,
+    -0.001782209f, -0.001773877f, -0.001765518f, -0.001757140f, -0.001748742f,
+    -0.001740261f, -0.001731890f, -0.001723433f, -0.001714959f, -0.001706466f,
+    -0.001697953f, -0.001689423f, -0.001680876f, -0.001672311f, -0.001663728f,
+    -0.001655128f, -0.001646512f, -0.001637880f, -0.001629170f, -0.001620566f,
+    -0.001611889f, -0.001603196f, -0.001594484f, -0.001585761f, -0.001577025f,
+    -0.001568271f, -0.001559505f, -0.001550728f, -0.001541931f, -0.001533132f,
+    -0.001524314f, -0.001515483f, -0.001506586f, -0.001497786f, -0.001488928f,
+    -0.001480050f, -0.001471169f, -0.001462270f, -0.001453366f, -0.001444448f,
+    -0.001435522f, -0.001426589f, -0.001417641f, -0.001408692f, -0.001399733f,
+    -0.001390763f, -0.001381733f, -0.001372803f, -0.001363818f, -0.001354810f,
+    -0.001345813f, -0.001336802f, -0.001327783f, -0.001318768f, -0.001309730f,
+    -0.001300700f, -0.001291670f, -0.001282625f, -0.001273572f, -0.001264527f,
+    -0.001255415f, -0.001246415f, -0.001237355f, -0.001228295f, -0.001219213f,
+    -0.001210161f, -0.001201086f, -0.001192011f, -0.001182951f, -0.001173854f,
+    -0.001164794f, -0.001155719f, -0.001146644f, -0.001137555f, -0.001128443f,
+    -0.001119412f, -0.001110330f, -0.001101270f, -0.001092196f, -0.001083128f,
+    -0.001074038f, -0.001065001f, -0.001055919f, -0.001046866f, -0.001037806f,
+    -0.001028746f, -0.001019694f, -0.001010656f, -0.001001567f, -0.000992566f,
+    -0.000983544f, -0.000974506f, -0.000965491f, -0.000956468f, -0.000947453f,
+    -0.000938453f, -0.000929438f, -0.000920445f, -0.000911482f, -0.000902474f,
+    -0.000893541f, -0.000884496f, -0.000875585f, -0.000866644f, -0.000857703f,
+    -0.000848778f, -0.000839837f, -0.000830933f, -0.000822030f, -0.000813127f,
+    -0.000804260f, -0.000795372f, -0.000786506f, -0.000777654f, -0.000768811f,
+    -0.000759944f, -0.000751153f, -0.000742361f, -0.000733539f, -0.000724763f,
+    -0.000716001f, -0.000707224f, -0.000698492f, -0.000689745f, -0.000681043f,
+    -0.000672325f, -0.000663623f, -0.000654951f, -0.000646278f, -0.000637606f,
+    -0.000628993f, -0.000620380f, -0.000611767f, -0.000603199f, -0.000594586f,
+    -0.000586048f, -0.000577524f, -0.000568971f, -0.000560462f, -0.000551969f,
+    -0.000543505f, -0.000535041f, -0.000526607f, -0.000518143f, -0.000509769f,
+    -0.000501379f, -0.000493005f, -0.000484675f, -0.000476316f, -0.000468016f,
+    -0.000459731f, -0.000451431f, -0.000443190f, -0.000434965f, -0.000426725f,
+    -0.000418544f, -0.000410378f, -0.000402227f, -0.000394091f, -0.000385970f,
+    -0.000377893f, -0.000369802f, -0.000361770f, -0.000353739f, -0.000345752f,
+    -0.000337750f, -0.000329792f, -0.000321865f, -0.000313938f, -0.000306055f,
+    -0.000298187f, -0.000290349f, -0.000282511f, -0.000274733f, -0.000266939f,
+    -0.000259221f, -0.000251472f, -0.000243768f, -0.000236079f, -0.000228450f,
+    -0.000220820f, -0.000213221f, -0.000205651f, -0.000198096f, -0.000190571f,
+    -0.000183061f, -0.000175595f, -0.000168160f, -0.000160739f, -0.000153318f,
+    -0.000145987f, -0.000138611f, -0.000131324f, -0.000124037f, -0.000116780f,
+    -0.000109524f, -0.000102326f, -0.000095159f, -0.000088021f, -0.000080869f,
+    -0.000073805f, -0.000066742f, -0.000059679f, -0.000052691f, -0.000045687f,
+    -0.000038758f, -0.000031844f, -0.000024930f, -0.000018090f, -0.000011265f,
+    -0.000004441f, 0.000002325f, 0.000009075f, 0.000015780f, 0.000022471f,
+    0.000029117f, 0.000035763f, 0.000042319f, 0.000048906f, 0.000055432f,
+    0.000061929f, 0.000068396f, 0.000074849f, 0.000081256f, 0.000087619f,
+    0.000093967f, 0.000100300f, 0.000106558f, 0.000112817f, 0.000119045f,
+    0.000125214f, 0.000131369f, 0.000137508f, 0.000143588f, 0.000149652f,
+    0.000155658f, 0.000161663f, 0.000167638f, 0.000173539f, 0.000179455f,
+    0.000185296f, 0.000191167f, 0.000196919f, 0.000202700f, 0.000208423f,
+    0.000214115f, 0.000219792f, 0.000225410f, 0.000231013f, 0.000236586f,
+    0.000242084f, 0.000247598f, 0.000253052f, 0.000258476f, 0.000263870f,
+    0.000269234f, 0.000274554f, 0.000279859f, 0.000285104f, 0.000290334f,
+    0.000295490f, 0.000300661f, 0.000305787f, 0.000310853f, 0.000315934f,
+    0.000320926f, 0.000325903f, 0.000330850f, 0.000335768f, 0.000340641f,
+    0.000345469f, 0.000350282f, 0.000355050f, 0.000359803f, 0.000364468f,
+    0.000369161f, 0.000373796f, 0.000378355f, 0.000382945f, 0.000387460f,
+    0.000391930f, 0.000396401f, 0.000400826f, 0.000405192f, 0.000409558f,
+    0.000413850f, 0.000418127f, 0.000422373f, 0.000426546f, 0.000430748f,
+    0.000434861f, 0.000438988f, 0.000443041f, 0.000447050f, 0.000451058f,
+    0.000455007f, 0.000458926f, 0.000462815f, 0.000466645f, 0.000470474f,
+    0.000474244f, 0.000477999f, 0.000481665f, 0.000485376f, 0.000488982f,
+    0.000492588f, 0.000496164f, 0.000499681f, 0.000503168f, 0.000506610f,
+    0.000510037f, 0.000513420f, 0.000516787f, 0.000520080f, 0.000523359f,
+    0.000526607f, 0.000529751f, 0.000532970f, 0.000536114f, 0.000539184f,
+    0.000542283f, 0.000545278f, 0.000548288f, 0.000551224f, 0.000554159f,
+    0.000557050f, 0.000559889f, 0.000562698f, 0.000565484f, 0.000568233f,
+    0.000570931f, 0.000573598f, 0.000576250f, 0.000578851f, 0.000581399f,
+    0.000583932f, 0.000586443f, 0.000588894f, 0.000591323f, 0.000593722f,
+    0.000596076f, 0.000598386f, 0.000600673f, 0.000602946f, 0.000605099f,
+    0.000607334f, 0.000609480f, 0.000611588f, 0.000613675f, 0.000615716f,
+    0.000617720f, 0.000619695f, 0.000621639f, 0.000623547f, 0.000625424f,
+    0.000627257f, 0.000629067f, 0.000630826f, 0.000632577f, 0.000634275f,
+    0.000635937f, 0.000637576f, 0.000639170f, 0.000640750f, 0.000642270f,
+    0.000643790f, 0.000645243f, 0.000646673f, 0.000648089f, 0.000649445f,
+    0.000650786f, 0.000652038f, 0.000653364f, 0.000654578f, 0.000655793f,
+    0.000656962f, 0.000658102f, 0.000659212f, 0.000660270f, 0.000661321f,
+    0.000662334f, 0.000663288f, 0.000664257f, 0.000665158f, 0.000666037f,
+    0.000666894f, 0.000667714f, 0.000668481f, 0.000669241f, 0.000669979f,
+    0.000670649f, 0.000671312f, 0.000671953f, 0.000672549f, 0.000673100f,
+    0.000673652f, 0.000674143f, 0.000674628f, 0.000675075f, 0.000675432f,
+    0.000675865f, 0.000676215f, 0.000676543f, 0.000676841f, 0.000677086f,
+    0.000677340f, 0.000677533f, 0.000677712f, 0.000677854f, 0.000677958f,
+    0.000678062f, 0.000678115f, 0.000678137f, 0.000678144f, 0.000678107f,
+    0.000678040f, 0.000677980f, 0.000677846f, 0.000677705f, 0.000677541f,
+    0.000677332f, 0.000677109f, 0.000676855f, 0.000676572f, 0.000676263f,
+    0.000675920f, 0.000675563f, 0.000675112f, 0.000674754f, 0.000674292f,
+    0.000673834f, 0.000673324f, 0.000672799f, 0.000672262f, 0.000671666f,
+    0.000671066f, 0.000670440f, 0.000669774f, 0.000669103f, 0.000668388f,
+    0.000667654f, 0.000666898f, 0.000666108f, 0.000665307f, 0.000664469f,
+    0.000663612f, 0.000662729f, 0.000661820f, 0.000660881f, 0.000659931f,
+    0.000658948f, 0.000657942f, 0.000656914f, 0.000655863f, 0.000654746f,
+    0.000653688f, 0.000652563f, 0.000651423f, 0.000650249f, 0.000649061f,
+    0.000647850f, 0.000646606f, 0.000645354f, 0.000644065f, 0.000642769f,
+    0.000641439f, 0.000640094f, 0.000638723f, 0.000637334f, 0.000635926f,
+    0.000634488f, 0.000633033f, 0.000631562f, 0.000630064f, 0.000628548f,
+    0.000627011f, 0.000625454f, 0.000623874f, 0.000622276f, 0.000620661f,
+    0.000619022f, 0.000617364f, 0.000615645f, 0.000613993f, 0.000612279f,
+    0.000610547f, 0.000608791f, 0.000607023f, 0.000605229f, 0.000603424f,
+    0.000601593f, 0.000599753f, 0.000597889f, 0.000596011f, 0.000594109f,
+    0.000592194f, 0.000590262f, 0.000588313f, 0.000586346f, 0.000584361f,
+    0.000582362f, 0.000580344f, 0.000578311f, 0.000576260f, 0.000574195f,
+    0.000572114f, 0.000570015f, 0.000567904f, 0.000565774f, 0.000563630f,
+    0.000561428f, 0.000559297f, 0.000557108f, 0.000554904f, 0.000552687f,
+    0.000550454f, 0.000548207f, 0.000545946f, 0.000543671f, 0.000541383f,
+    0.000539081f, 0.000536765f, 0.000534437f, 0.000532095f, 0.000529740f,
+    0.000527372f, 0.000524992f, 0.000522598f, 0.000520193f, 0.000517776f,
+    0.000515345f, 0.000512904f, 0.000510451f, 0.000507986f, 0.000505510f,
+    0.000503022f, 0.000500523f, 0.000497975f, 0.000495494f, 0.000492963f,
+    0.000490420f, 0.000487870f, 0.000485308f, 0.000482734f, 0.000480153f,
+    0.000477560f, 0.000474961f, 0.000472347f, 0.000469729f, 0.000467099f,
+    0.000464460f, 0.000461814f, 0.000459160f, 0.000456492f, 0.000453821f,
+    0.000451141f, 0.000448450f, 0.000445757f, 0.000443047f, 0.000440339f,
+    0.000437619f, 0.000434890f, 0.000432156f, 0.000429420f, 0.000426665f,
+    0.000423878f, 0.000421155f, 0.000418384f, 0.000415608f, 0.000412831f,
+    0.000410046f, 0.000407251f, 0.000404453f, 0.000401655f, 0.000398841f,
+    0.000396032f, 0.000393212f, 0.000390388f, 0.000387559f, 0.000384722f,
+    0.000381887f, 0.000379046f, 0.000376200f, 0.000373350f, 0.000370493f,
+    0.000367636f, 0.000364775f, 0.000361912f, 0.000359036f, 0.000356171f,
+    0.000353293f, 0.000350416f, 0.000347532f, 0.000344623f, 0.000341764f,
+    0.000338878f, 0.000335984f, 0.000333097f, 0.000330199f, 0.000327300f,
+    0.000324406f, 0.000321500f, 0.000318602f, 0.000315700f, 0.000312794f,
+    0.000309892f, 0.000306983f, 0.000304081f, 0.000301171f, 0.000298265f,
+    0.000295352f, 0.000292446f, 0.000289541f, 0.000286628f, 0.000283718f,
+    0.000280812f, 0.000277914f, 0.000274993f, 0.000272095f, 0.000269186f,
+    0.000266258f, 0.000263374f, 0.000260476f, 0.000257570f, 0.000254679f,
+    0.000251777f, 0.000248875f, 0.000245985f, 0.000243090f, 0.000240199f,
+    0.000237312f, 0.000234425f, 0.000231542f, 0.000228655f, 0.000225779f,
+    0.000222903f, 0.000220031f, 0.000217155f, 0.000214294f, 0.000211425f,
+    0.000208564f, 0.000205707f, 0.000202853f, 0.000200007f, 0.000197157f,
+    0.000194311f, 0.000191480f, 0.000188638f, 0.000185791f, 0.000182983f,
+    0.000180162f, 0.000177346f, 0.000174530f, 0.000171725f, 0.000168923f,
+    0.000166126f, 0.000163332f, 0.000160541f, 0.000157762f, 0.000154987f,
+    0.000152212f, 0.000149447f, 0.000146687f, 0.000143930f, 0.000141181f,
+    0.000138439f, 0.000135705f, 0.000132974f, 0.000130247f, 0.000127535f,
+    0.000124816f, 0.000122119f, 0.000119418f, 0.000116725f, 0.000114042f,
+    0.000111364f, 0.000108674f, 0.000106033f, 0.000103373f, 0.000100728f,
+    0.000098083f, 0.000095449f, 0.000092819f, 0.000090208f, 0.000087593f,
+    0.000084992f, 0.000082392f, 0.000079807f, 0.000077233f, 0.000074655f,
+    0.000072096f, 0.000069536f, 0.000066992f, 0.000064459f, 0.000061929f,
+    0.000059403f, 0.000056893f, 0.000054389f, 0.000051897f, 0.000049412f,
+    0.000046935f, 0.000044469f, 0.000042010f, 0.000039551f, 0.000037123f,
+    0.000034694f, 0.000032268f, 0.000029862f, 0.000027459f, 0.000025064f,
+    0.000022691f, 0.000020307f, 0.000017952f, 0.000015602f, 0.000013247f,
+    0.000010934f, 0.000008594f, 0.000006288f, 0.000003986f, 0.000001695f,
+    -0.000000589f, -0.000002854f, -0.000005119f, -0.000007369f, -0.000009615f,
+    -0.000011832f, -0.000014052f, -0.000016265f, -0.000018459f, -0.000020642f,
+    -0.000022821f, -0.000024986f, -0.000027131f, -0.000029277f, -0.000031408f,
+    -0.000033524f, -0.000035629f, -0.000037737f, -0.000039808f, -0.000041891f,
+    -0.000043951f, -0.000046007f, -0.000048041f, -0.000050064f, -0.000052094f,
+    -0.000054091f, -0.000056084f, -0.000058070f, -0.000060037f, -0.000061993f,
+    -0.000063941f, -0.000065874f, -0.000067800f, -0.000069708f, -0.000071604f,
+    -0.000073489f, -0.000075370f, -0.000077229f, -0.000079080f, -0.000080917f,
+    -0.000082746f, -0.000084557f, -0.000086352f, -0.000088152f, -0.000089929f,
+    -0.000091687f, -0.000093438f, -0.000095177f, -0.000096913f, -0.000098623f,
+    -0.000100322f, -0.000102021f, -0.000103690f, -0.000105359f, -0.000107009f,
+    -0.000108648f, -0.000110280f, -0.000111893f, -0.000113495f, -0.000115078f,
+    -0.000116657f, -0.000118230f, -0.000119772f, -0.000121318f, -0.000122838f,
+    -0.000124350f, -0.000125848f, -0.000127345f, -0.000128813f, -0.000130277f,
+    -0.000131730f, -0.000133157f, -0.000134595f, -0.000135988f, -0.000137400f,
+    -0.000138778f, -0.000140157f, -0.000141505f, -0.000142857f, -0.000144191f,
+    -0.000145517f, -0.000146817f, -0.000148114f, -0.000149388f, -0.000150666f,
+    -0.000151921f, -0.000153165f, -0.000154395f, -0.000155609f, -0.000156820f,
+    -0.000158004f, -0.000159189f, -0.000160355f, -0.000161506f, -0.000162646f,
+    -0.000163775f, -0.000164881f, -0.000165988f, -0.000167083f, -0.000168145f,
+    -0.000169218f, -0.000170264f, -0.000171307f, -0.000172324f, -0.000173341f,
+    -0.000174336f, -0.000175327f, -0.000176292f, -0.000177257f, -0.000178207f,
+    -0.000179138f, -0.000180058f, -0.000180975f, -0.000181865f, -0.000182752f,
+    -0.000183623f, -0.000184480f, -0.000185326f, -0.000186164f, -0.000186980f,
+    -0.000187792f, -0.000188582f, -0.000189368f, -0.000190143f, -0.000190891f,
+    -0.000191648f, -0.000192374f, -0.000193097f, -0.000193801f, -0.000194505f,
+    -0.000195183f, -0.000195853f, -0.000196513f, -0.000197157f, -0.000197794f,
+    -0.000198420f, -0.000199001f, -0.000199623f, -0.000200208f, -0.000200782f,
+    -0.000201344f, -0.000201892f, -0.000202429f, -0.000202954f, -0.000203468f,
+    -0.000203967f, -0.000204455f, -0.000204936f, -0.000205394f, -0.000205856f,
+    -0.000206295f, -0.000206724f, -0.000207141f, -0.000207547f, -0.000207946f,
+    -0.000208326f, -0.000208698f, -0.000209058f, -0.000209408f, -0.000209745f,
+    -0.000210065f, -0.000210386f, -0.000210684f, -0.000210978f, -0.000211256f,
+    -0.000211528f, -0.000211783f, -0.000212030f, -0.000212263f, -0.000212491f,
+    -0.000212703f, -0.000212908f, -0.000213092f, -0.000213277f, -0.000213446f,
+    -0.000213604f, -0.000213752f, -0.000213886f, -0.000214016f, -0.000214130f,
+    -0.000214234f, -0.000214327f, -0.000214415f, -0.000214487f, -0.000214545f,
+    -0.000214605f, -0.000214642f, -0.000214674f, -0.000214696f, -0.000214709f,
+    -0.000214707f, -0.000214674f, -0.000214679f, -0.000214649f, -0.000214612f,
+    -0.000214560f, -0.000214502f, -0.000214435f, -0.000214357f, -0.000214268f,
+    -0.000214169f, -0.000214059f, -0.000213947f, -0.000213819f, -0.000213677f,
+    -0.000213537f, -0.000213381f, -0.000213215f, -0.000213042f, -0.000212861f,
+    -0.000212666f, -0.000212466f, -0.000212256f, -0.000212036f, -0.000211809f,
+    -0.000211569f, -0.000211326f, -0.000211067f, -0.000210807f, -0.000210535f,
+    -0.000210257f, -0.000209961f, -0.000209667f, -0.000209359f, -0.000209045f,
+    -0.000208722f, -0.000208389f, -0.000208050f, -0.000207704f, -0.000207344f,
+    -0.000206983f, -0.000206610f, -0.000206229f, -0.000205842f, -0.000205445f,
+    -0.000205044f, -0.000204630f, -0.000204211f, -0.000203785f, -0.000203351f,
+    -0.000202909f, -0.000202459f, -0.000202003f, -0.000201537f, -0.000201069f,
+    -0.000200586f, -0.000200078f, -0.000199611f, -0.000199108f, -0.000198605f,
+    -0.000198090f, -0.000197569f, -0.000197043f, -0.000196506f, -0.000195967f,
+    -0.000195420f, -0.000194865f, -0.000194305f, -0.000193738f, -0.000193163f,
+    -0.000192585f, -0.000191999f, -0.000191407f, -0.000190807f, -0.000190204f,
+    -0.000189591f, -0.000188977f, -0.000188354f, -0.000187725f, -0.000187092f,
+    -0.000186451f, -0.000185805f, -0.000185154f, -0.000184498f, -0.000183835f,
+    -0.000183167f, -0.000182495f, -0.000181816f, -0.000181132f, -0.000180443f,
+    -0.000179750f, -0.000179050f, -0.000178346f, -0.000177636f, -0.000176923f,
+    -0.000176203f, -0.000175480f, -0.000174752f, -0.000174019f, -0.000173280f,
+    -0.000172539f, -0.000171792f, -0.000171040f, -0.000170285f, -0.000169525f,
+    -0.000168761f, -0.000167992f, -0.000167220f, -0.000166443f, -0.000165662f,
+    -0.000164878f, -0.000164090f, -0.000163272f, -0.000162501f, -0.000161701f,
+    -0.000160898f, -0.000160091f, -0.000159280f, -0.000158466f, -0.000157648f,
+    -0.000156827f, -0.000156003f, -0.000155175f, -0.000154344f, -0.000153510f,
+    -0.000152673f, -0.000151833f, -0.000150990f, -0.000150144f, -0.000149295f,
+    -0.000148444f, -0.000147589f, -0.000146732f, -0.000145872f, -0.000145010f,
+    -0.000144145f, -0.000143277f, -0.000142408f, -0.000141536f, -0.000140661f,
+    -0.000139785f, -0.000138906f, -0.000138025f, -0.000137142f, -0.000136257f,
+    -0.000135370f, -0.000134481f, -0.000133590f, -0.000132697f, -0.000131803f,
+    -0.000130907f, -0.000130009f, -0.000129110f, -0.000128209f, -0.000127306f,
+    -0.000126403f, -0.000125497f, -0.000124591f, -0.000123683f, -0.000122774f,
+    -0.000121864f, -0.000120952f, -0.000120040f, -0.000119127f, -0.000118212f,
+    -0.000117297f, -0.000116381f, -0.000115445f, -0.000114546f, -0.000113628f,
+    -0.000112709f, -0.000111789f, -0.000110869f, -0.000109948f, -0.000109027f,
+    -0.000108106f, -0.000107184f, -0.000106262f, -0.000105340f, -0.000104415f,
+    -0.000103494f, -0.000102570f, -0.000101647f, -0.000100723f, -0.000099801f,
+    -0.000098877f, -0.000097955f, -0.000097031f, -0.000096109f, -0.000095187f,
+    -0.000094265f, -0.000093343f, -0.000092422f, -0.000091502f, -0.000090580f,
+    -0.000089660f, -0.000088741f, -0.000087823f, -0.000086904f, -0.000085988f,
+    -0.000085071f, -0.000084155f, -0.000083240f, -0.000082325f, -0.000081412f,
+    -0.000080500f, -0.000079590f, -0.000078678f, -0.000077770f, -0.000076862f,
+    -0.000075955f, -0.000075049f, -0.000074145f, -0.000073241f, -0.000072340f,
+    -0.000071440f, -0.000070541f, -0.000069643f, -0.000068747f, -0.000067852f,
+    -0.000066960f, -0.000066068f, -0.000065166f, -0.000064289f, -0.000063405f,
+    -0.000062519f, -0.000061636f, -0.000060757f, -0.000059876f, -0.000058998f,
+    -0.000058125f, -0.000057249f, -0.000056379f, -0.000055509f, -0.000054643f,
+    -0.000053776f, -0.000052913f, -0.000052053f, -0.000051194f, -0.000050337f,
+    -0.000049485f, -0.000048630f, -0.000047781f, -0.000046935f, -0.000046090f,
+    -0.000045246f, -0.000044407f, -0.000043570f, -0.000042734f, -0.000041903f,
+    -0.000041073f, -0.000040242f, -0.000039421f, -0.000038599f, -0.000037779f,
+    -0.000036962f, -0.000036148f, -0.000035339f, -0.000034529f, -0.000033723f,
+    -0.000032922f, -0.000032122f, -0.000031324f, -0.000030532f, -0.000029741f,
+    -0.000028951f, -0.000028169f, -0.000027386f, -0.000026607f, -0.000025833f,
+    -0.000025058f, -0.000024288f, -0.000023524f, -0.000022760f, -0.000022001f,
+    -0.000021243f, -0.000020491f, -0.000019740f, -0.000018986f, -0.000018249f,
+    -0.000017510f, -0.000016774f, -0.000016038f, -0.000015311f, -0.000014583f,
+    -0.000013859f, -0.000013139f, -0.000012424f, -0.000011712f, -0.000011003f,
+    -0.000010296f, -0.000009594f, -0.000008895f, -0.000008201f, -0.000007508f,
+    -0.000006821f, -0.000006137f, -0.000005458f, -0.000004780f, -0.000004107f,
+    -0.000003438f, -0.000002770f, -0.000002110f, -0.000001453f, -0.000000797f,
+    -0.000000146f, 0.000000501f, 0.000001144f, 0.000001782f, 0.000002420f,
+    0.000003050f, 0.000003677f, 0.000004301f, 0.000004923f, 0.000005536f,
+    0.000006150f, 0.000006758f, 0.000007361f, 0.000007963f, 0.000008560f,
+    0.000009151f, 0.000009741f, 0.000010326f, 0.000010905f, 0.000011482f,
+    0.000012054f, 0.000012624f, 0.000013188f, 0.000013747f, 0.000014306f,
+    0.000014856f, 0.000015406f, 0.000015951f, 0.000016493f, 0.000017026f,
+    0.000017560f, 0.000018085f, 0.000018612f, 0.000019130f, 0.000019647f,
+    0.000020158f, 0.000020666f, 0.000021168f, 0.000021671f, 0.000022165f,
+    0.000022653f, 0.000023143f, 0.000023624f, 0.000024104f, 0.000024579f,
+    0.000025048f, 0.000025516f, 0.000025976f, 0.000026437f, 0.000026888f,
+    0.000027340f, 0.000027785f, 0.000028226f, 0.000028664f, 0.000029097f,
+    0.000029526f, 0.000029950f, 0.000030371f, 0.000030789f, 0.000031200f,
+    0.000031610f, 0.000032012f, 0.000032413f, 0.000032808f, 0.000033202f,
+    0.000033589f, 0.000033971f, 0.000034352f, 0.000034725f, 0.000035098f,
+    0.000035464f, 0.000035828f, 0.000036187f, 0.000036540f, 0.000036892f,
+    0.000037238f, 0.000037580f, 0.000037918f, 0.000038252f, 0.000038582f,
+    0.000038907f, 0.000039231f, 0.000039549f, 0.000039860f, 0.000040172f,
+    0.000040476f, 0.000040780f, 0.000041076f, 0.000041369f, 0.000041659f,
+    0.000041946f, 0.000042226f, 0.000042504f, 0.000042778f, 0.000043048f,
+    0.000043313f, 0.000043575f, 0.000043831f, 0.000044088f, 0.000044335f,
+    0.000044581f, 0.000044825f, 0.000045061f, 0.000045295f, 0.000045526f,
+    0.000045752f, 0.000045975f, 0.000046193f, 0.000046407f, 0.000046619f,
+    0.000046826f, 0.000047030f, 0.000047228f, 0.000047424f, 0.000047616f,
+    0.000047805f, 0.000047988f, 0.000048169f, 0.000048346f, 0.000048519f,
+    0.000048689f, 0.000048853f, 0.000049016f, 0.000049174f, 0.000049329f,
+    0.000049480f, 0.000049627f, 0.000049771f, 0.000049912f, 0.000050047f,
+    0.000050181f, 0.000050310f, 0.000050437f, 0.000050558f, 0.000050677f,
+    0.000050792f, 0.000050904f, 0.000051012f, 0.000051118f, 0.000051214f,
+    0.000051316f, 0.000051410f, 0.000051503f, 0.000051589f, 0.000051674f,
+    0.000051755f, 0.000051832f, 0.000051906f, 0.000051977f, 0.000052044f,
+    0.000052109f, 0.000052171f, 0.000052229f, 0.000052283f, 0.000052333f,
+    0.000052382f, 0.000052427f, 0.000052468f, 0.000052508f, 0.000052543f,
+    0.000052574f, 0.000052604f, 0.000052631f, 0.000052653f, 0.000052674f,
+    0.000052691f, 0.000052704f, 0.000052716f, 0.000052724f, 0.000052729f,
+    0.000052730f, 0.000052730f, 0.000052726f, 0.000052720f, 0.000052710f,
+    0.000052697f, 0.000052682f, 0.000052664f, 0.000052643f, 0.000052620f,
+    0.000052593f, 0.000052564f, 0.000052531f, 0.000052498f, 0.000052460f,
+    0.000052420f, 0.000052377f, 0.000052333f, 0.000052284f, 0.000052234f,
+    0.000052180f, 0.000052125f, 0.000052067f, 0.000052006f, 0.000051938f,
+    0.000051877f, 0.000051809f, 0.000051738f, 0.000051666f, 0.000051590f,
+    0.000051512f, 0.000051432f, 0.000051349f, 0.000051265f, 0.000051177f,
+    0.000051088f, 0.000050996f, 0.000050901f, 0.000050805f, 0.000050707f,
+    0.000050606f, 0.000050503f, 0.000050398f, 0.000050291f, 0.000050182f,
+    0.000050070f, 0.000049957f, 0.000049842f, 0.000049724f, 0.000049604f,
+    0.000049483f, 0.000049358f, 0.000049234f, 0.000049105f, 0.000048977f,
+    0.000048845f, 0.000048712f, 0.000048577f, 0.000048439f, 0.000048302f,
+    0.000048161f, 0.000048019f, 0.000047874f, 0.000047728f, 0.000047581f,
+    0.000047431f, 0.000047280f, 0.000047128f, 0.000046974f, 0.000046818f,
+    0.000046660f, 0.000046501f, 0.000046341f, 0.000046178f, 0.000046015f,
+    0.000045849f, 0.000045683f, 0.000045514f, 0.000045344f, 0.000045168f,
+    0.000045001f, 0.000044827f, 0.000044652f, 0.000044475f, 0.000044297f,
+    0.000044117f, 0.000043937f, 0.000043755f, 0.000043572f, 0.000043387f,
+    0.000043201f, 0.000043015f, 0.000042827f, 0.000042638f, 0.000042447f,
+    0.000042256f, 0.000042063f, 0.000041869f, 0.000041675f, 0.000041479f,
+    0.000041282f, 0.000041084f, 0.000040885f, 0.000040685f, 0.000040484f,
+    0.000040283f, 0.000040080f, 0.000039876f, 0.000039672f, 0.000039466f,
+    0.000039260f, 0.000039053f, 0.000038845f, 0.000038636f, 0.000038427f,
+    0.000038217f, 0.000038006f, 0.000037794f, 0.000037581f, 0.000037368f,
+    0.000037155f, 0.000036940f, 0.000036725f, 0.000036509f, 0.000036293f,
+    0.000036076f, 0.000035858f, 0.000035640f, 0.000035422f, 0.000035202f,
+    0.000034983f, 0.000034763f, 0.000034542f, 0.000034321f, 0.000034100f,
+    0.000033873f, 0.000033655f, 0.000033432f, 0.000033209f, 0.000032986f,
+    0.000032762f, 0.000032538f, 0.000032313f, 0.000032089f, 0.000031864f,
+    0.000031638f, 0.000031413f, 0.000031187f, 0.000030961f, 0.000030735f,
+    0.000030508f, 0.000030282f, 0.000030055f, 0.000029828f, 0.000029601f,
+    0.000029374f, 0.000029147f, 0.000028920f, 0.000028692f, 0.000028465f,
+    0.000028237f, 0.000028010f, 0.000027782f, 0.000027555f, 0.000027328f,
+    0.000027100f, 0.000026873f, 0.000026645f, 0.000026418f, 0.000026191f,
+    0.000025964f, 0.000025737f, 0.000025510f, 0.000025283f, 0.000025057f,
+    0.000024830f, 0.000024604f, 0.000024378f, 0.000024152f, 0.000023927f,
+    0.000023702f, 0.000023476f, 0.000023252f, 0.000023027f, 0.000022803f,
+    0.000022579f, 0.000022355f, 0.000022132f, 0.000021908f, 0.000021686f,
+    0.000021460f, 0.000021241f, 0.000021020f, 0.000020798f, 0.000020578f,
+    0.000020357f, 0.000020137f, 0.000019917f, 0.000019698f, 0.000019480f,
+    0.000019261f, 0.000019044f, 0.000018826f, 0.000018609f, 0.000018393f,
+    0.000018177f, 0.000017962f, 0.000017748f, 0.000017533f, 0.000017320f,
+    0.000017107f, 0.000016894f, 0.000016682f, 0.000016471f, 0.000016260f,
+    0.000016050f, 0.000015841f, 0.000015632f, 0.000015424f, 0.000015216f,
+    0.000015009f, 0.000014803f, 0.000014597f, 0.000014393f, 0.000014188f,
+    0.000013985f, 0.000013782f, 0.000013580f, 0.000013379f, 0.000013178f,
+    0.000012978f, 0.000012779f, 0.000012581f, 0.000012383f, 0.000012186f,
+    0.000011990f, 0.000011795f, 0.000011600f, 0.000011407f, 0.000011214f,
+    0.000011022f, 0.000010830f, 0.000010640f, 0.000010450f, 0.000010262f,
+    0.000010074f, 0.000009884f, 0.000009700f, 0.000009515f, 0.000009331f,
+    0.000009147f, 0.000008964f, 0.000008782f, 0.000008601f, 0.000008421f,
+    0.000008242f, 0.000008064f, 0.000007887f, 0.000007710f, 0.000007535f,
+    0.000007360f, 0.000007186f, 0.000007014f, 0.000006842f, 0.000006671f,
+    0.000006501f, 0.000006332f, 0.000006164f, 0.000005997f, 0.000005831f,
+    0.000005667f, 0.000005502f, 0.000005339f, 0.000005177f, 0.000005016f,
+    0.000004855f, 0.000004696f, 0.000004538f, 0.000004381f, 0.000004225f,
+    0.000004070f, 0.000003916f, 0.000003763f, 0.000003610f, 0.000003459f,
+    0.000003309f, 0.000003160f, 0.000003012f, 0.000002865f, 0.000002719f,
+    0.000002574f, 0.000002430f, 0.000002287f, 0.000002146f, 0.000002005f,
+    0.000001865f, 0.000001726f, 0.000001589f, 0.000001452f, 0.000001316f,
+    0.000001182f, 0.000001047f, 0.000000916f, 0.000000785f, 0.000000654f,
+    0.000000525f, 0.000000397f, 0.000000270f, 0.000000143f, 0.000000019f,
+    -0.000000106f, -0.000000228f, -0.000000351f, -0.000000471f, -0.000000591f,
+    -0.000000710f, -0.000000827f, -0.000000944f, -0.000001059f, -0.000001174f,
+    -0.000001287f, -0.000001399f, -0.000001511f, -0.000001621f, -0.000001730f,
+    -0.000001838f, -0.000001945f, -0.000002051f, -0.000002156f, -0.000002260f,
+    -0.000002363f, -0.000002465f, -0.000002565f, -0.000002665f, -0.000002763f,
+    -0.000002861f, -0.000002958f, -0.000003053f, -0.000003147f, -0.000003241f,
+    -0.000003333f, -0.000003424f, -0.000003514f, -0.000003604f, -0.000003692f,
+    -0.000003779f, -0.000003865f, -0.000003950f, -0.000004034f, -0.000004117f,
+    -0.000004199f, -0.000004280f, -0.000004360f, -0.000004439f, -0.000004517f,
+    -0.000004594f, -0.000004670f, -0.000004744f, -0.000004819f, -0.000004891f,
+    -0.000004963f, -0.000005034f, -0.000005104f, -0.000005173f, -0.000005240f,
+    -0.000005307f, -0.000005373f, -0.000005438f, -0.000005502f, -0.000005565f,
+    -0.000005627f, -0.000005688f, -0.000005748f, -0.000005807f, -0.000005866f,
+    -0.000005922f, -0.000005979f, -0.000006034f, -0.000006089f, -0.000006142f,
+    -0.000006194f, -0.000006246f, -0.000006297f, -0.000006346f, -0.000006395f,
+    -0.000006443f, -0.000006490f, -0.000006536f, -0.000006581f, -0.000006625f,
+    -0.000006668f, -0.000006711f, -0.000006752f, -0.000006793f, -0.000006833f,
+    -0.000006872f, -0.000006909f, -0.000006947f, -0.000006983f, -0.000007018f,
+    -0.000007053f, -0.000007086f, -0.000007119f, -0.000007151f, -0.000007183f,
+    -0.000007213f, -0.000007242f, -0.000007271f, -0.000007299f, -0.000007326f,
+    -0.000007352f, -0.000007377f, -0.000007402f, -0.000007426f, -0.000007449f,
+    -0.000007471f, -0.000007493f, -0.000007513f, -0.000007533f, -0.000007552f,
+    -0.000007570f, -0.000007588f, -0.000007605f, -0.000007621f, -0.000007636f,
+    -0.000007651f, -0.000007665f, -0.000007678f, -0.000007690f, -0.000007702f,
+    -0.000007713f, -0.000007723f, -0.000007733f, -0.000007742f, -0.000007750f,
+    -0.000007757f, -0.000007764f, -0.000007770f, -0.000007775f, -0.000007780f,
+    -0.000007784f, -0.000007788f, -0.000007791f, -0.000007793f, -0.000007794f,
+    -0.000007795f, -0.000007795f, -0.000007795f, -0.000007794f, -0.000007792f,
+    -0.000007790f, -0.000007787f, -0.000007784f, -0.000007780f, -0.000007775f,
+    -0.000007770f, -0.000007764f, -0.000007758f, -0.000007751f, -0.000007743f,
+    -0.000007735f, -0.000007726f, -0.000007717f, -0.000007708f, -0.000007698f,
+    -0.000007687f, -0.000007675f, -0.000007663f, -0.000007651f, -0.000007638f,
+    -0.000007625f, -0.000007611f, -0.000007597f, -0.000007582f, -0.000007567f,
+    -0.000007551f, -0.000007535f, -0.000007518f, -0.000007501f, -0.000007483f,
+    -0.000007465f, -0.000007446f, -0.000007427f, -0.000007408f, -0.000007388f,
+    -0.000007368f, -0.000007347f, -0.000007326f, -0.000007305f, -0.000007283f,
+    -0.000007261f, -0.000007238f, -0.000007215f, -0.000007191f, -0.000007168f,
+    -0.000007143f, -0.000007119f, -0.000007094f, -0.000007068f, -0.000007043f,
+    -0.000007017f, -0.000006991f, -0.000006964f, -0.000006937f, -0.000006909f,
+    -0.000006882f, -0.000006854f, -0.000006826f, -0.000006797f, -0.000006768f,
+    -0.000006739f, -0.000006710f, -0.000006680f, -0.000006650f, -0.000006620f,
+    -0.000006589f, -0.000006558f, -0.000006527f, -0.000006496f, -0.000006464f,
+    -0.000006432f, -0.000006400f, -0.000006368f, -0.000006336f, -0.000006303f,
+    -0.000006270f, -0.000006237f, -0.000006203f, -0.000006170f, -0.000006136f,
+    -0.000006102f, -0.000006068f, -0.000006033f, -0.000005999f, -0.000005964f,
+    -0.000005929f, -0.000005894f, -0.000005859f, -0.000005823f, -0.000005788f,
+    -0.000005752f, -0.000005716f, -0.000005680f, -0.000005644f, -0.000005608f,
+    -0.000005571f, -0.000005535f, -0.000005498f, -0.000005461f, -0.000005424f,
+    -0.000005388f, -0.000005350f, -0.000005313f, -0.000005276f, -0.000005239f,
+    -0.000005201f, -0.000005164f, -0.000005126f, -0.000005088f, -0.000005051f,
+    -0.000005013f, -0.000004975f, -0.000004937f, -0.000004899f, -0.000004861f,
+    -0.000004823f, -0.000004784f, -0.000004746f, -0.000004708f, -0.000004670f,
+    -0.000004632f, -0.000004593f, -0.000004555f, -0.000004517f, -0.000004478f,
+    -0.000004440f, -0.000004401f, -0.000004363f, -0.000004324f, -0.000004286f,
+    -0.000004248f, -0.000004210f, -0.000004171f, -0.000004133f, -0.000004095f,
+    -0.000004056f, -0.000004018f, -0.000003980f, -0.000003942f, -0.000003904f,
+    -0.000003865f, -0.000003827f, -0.000003789f, -0.000003751f, -0.000003714f,
+    -0.000003676f, -0.000003638f, -0.000003600f, -0.000003562f, -0.000003525f,
+    -0.000003487f, -0.000003450f, -0.000003412f, -0.000003375f, -0.000003338f,
+    -0.000003301f, -0.000003264f, -0.000003227f, -0.000003190f, -0.000003153f,
+    -0.000003117f, -0.000003080f, -0.000003044f, -0.000003007f, -0.000002971f,
+    -0.000002935f, -0.000002899f, -0.000002863f, -0.000002827f, -0.000002791f,
+    -0.000002756f, -0.000002720f, -0.000002685f, -0.000002650f, -0.000002615f,
+    -0.000002580f, -0.000002545f, -0.000002511f, -0.000002476f, -0.000002442f,
+    -0.000002408f, -0.000002373f, -0.000002340f, -0.000002306f, -0.000002272f,
+    -0.000002239f, -0.000002205f, -0.000002172f, -0.000002139f, -0.000002106f,
+    -0.000002074f, -0.000002041f, -0.000002009f, -0.000001977f, -0.000001945f,
+    -0.000001913f, -0.000001881f, -0.000001850f, -0.000001818f, -0.000001787f,
+    -0.000001756f, -0.000001726f, -0.000001695f, -0.000001665f, -0.000001634f,
+    -0.000001604f, -0.000001574f, -0.000001545f, -0.000001515f, -0.000001486f,
+    -0.000001457f, -0.000001428f, -0.000001399f, -0.000001371f, -0.000001342f,
+    -0.000001314f, -0.000001286f, -0.000001258f, -0.000001231f, -0.000001203f,
+    -0.000001176f, -0.000001149f, -0.000001123f, -0.000001096f, -0.000001070f,
+    0.000000000f
+};
+
+/* vi: set ts=4 sw=4 expandtab: */
+
diff --git a/Engine/lib/sdl/src/audio/SDL_audiocvt.c b/Engine/lib/sdl/src/audio/SDL_audiocvt.c
index 539900d84..0b95b417c 100644
--- a/Engine/lib/sdl/src/audio/SDL_audiocvt.c
+++ b/Engine/lib/sdl/src/audio/SDL_audiocvt.c
@@ -704,97 +704,7 @@ SDL_Convert51To71(SDL_AudioCVT * cvt, SDL_AudioFormat format)
 /* SDL's resampler uses a "bandlimited interpolation" algorithm:
      https://ccrma.stanford.edu/~jos/resample/ */
 
-#define RESAMPLER_ZERO_CROSSINGS 5
-#define RESAMPLER_BITS_PER_SAMPLE 16
-#define RESAMPLER_SAMPLES_PER_ZERO_CROSSING  (1 << ((RESAMPLER_BITS_PER_SAMPLE / 2) + 1))
-#define RESAMPLER_FILTER_SIZE ((RESAMPLER_SAMPLES_PER_ZERO_CROSSING * RESAMPLER_ZERO_CROSSINGS) + 1)
-
-/* This is a "modified" bessel function, so you can't use POSIX j0() */
-static double
-bessel(const double x)
-{
-    const double xdiv2 = x / 2.0;
-    double i0 = 1.0f;
-    double f = 1.0f;
-    int i = 1;
-
-    while (SDL_TRUE) {
-        const double diff = SDL_pow(xdiv2, i * 2) / SDL_pow(f, 2);
-        if (diff < 1.0e-21f) {
-            break;
-        }
-        i0 += diff;
-        i++;
-        f *= (double) i;
-    }
-
-    return i0;
-}
-
-/* build kaiser table with cardinal sine applied to it, and array of differences between elements. */
-static void
-kaiser_and_sinc(float *table, float *diffs, const int tablelen, const double beta)
-{
-    const int lenm1 = tablelen - 1;
-    const int lenm1div2 = lenm1 / 2;
-    int i;
-
-    table[0] = 1.0f;
-    for (i = 1; i < tablelen; i++) {
-        const double kaiser = bessel(beta * SDL_sqrt(1.0 - SDL_pow(((i - lenm1) / 2.0) / lenm1div2, 2.0))) / bessel(beta);
-        table[tablelen - i] = (float) kaiser;
-    }
-
-    for (i = 1; i < tablelen; i++) {
-        const float x = (((float) i) / ((float) RESAMPLER_SAMPLES_PER_ZERO_CROSSING)) * ((float) M_PI);
-        table[i] *= SDL_sinf(x) / x;
-        diffs[i - 1] = table[i] - table[i - 1];
-    }
-    diffs[lenm1] = 0.0f;
-}
-
-
-static SDL_SpinLock ResampleFilterSpinlock = 0;
-static float *ResamplerFilter = NULL;
-static float *ResamplerFilterDifference = NULL;
-
-int
-SDL_PrepareResampleFilter(void)
-{
-    SDL_AtomicLock(&ResampleFilterSpinlock);
-    if (!ResamplerFilter) {
-        /* if dB > 50, beta=(0.1102 * (dB - 8.7)), according to Matlab. */
-        const double dB = 80.0;
-        const double beta = 0.1102 * (dB - 8.7);
-        const size_t alloclen = RESAMPLER_FILTER_SIZE * sizeof (float);
-
-        ResamplerFilter = (float *) SDL_malloc(alloclen);
-        if (!ResamplerFilter) {
-            SDL_AtomicUnlock(&ResampleFilterSpinlock);
-            return SDL_OutOfMemory();
-        }
-
-        ResamplerFilterDifference = (float *) SDL_malloc(alloclen);
-        if (!ResamplerFilterDifference) {
-            SDL_free(ResamplerFilter);
-            ResamplerFilter = NULL;
-            SDL_AtomicUnlock(&ResampleFilterSpinlock);
-            return SDL_OutOfMemory();
-        }
-        kaiser_and_sinc(ResamplerFilter, ResamplerFilterDifference, RESAMPLER_FILTER_SIZE, beta);
-    }
-    SDL_AtomicUnlock(&ResampleFilterSpinlock);
-    return 0;
-}
-
-void
-SDL_FreeResampleFilter(void)
-{
-    SDL_free(ResamplerFilter);
-    SDL_free(ResamplerFilterDifference);
-    ResamplerFilter = NULL;
-    ResamplerFilterDifference = NULL;
-}
+#include "SDL_audio_resampler_filter.h"
 
 static int
 ResamplerPadding(const int inrate, const int outrate)
@@ -803,7 +713,7 @@ ResamplerPadding(const int inrate, const int outrate)
         return 0;
     }
     if (inrate > outrate) {
-        return (int) SDL_ceil(((float) (RESAMPLER_SAMPLES_PER_ZERO_CROSSING * inrate) / ((float) outrate)));
+        return (int) SDL_ceilf(((float) (RESAMPLER_SAMPLES_PER_ZERO_CROSSING * inrate) / ((float) outrate)));
     }
     return RESAMPLER_SAMPLES_PER_ZERO_CROSSING;
 }
@@ -815,33 +725,38 @@ SDL_ResampleAudio(const int chans, const int inrate, const int outrate,
                         const float *inbuf, const int inbuflen,
                         float *outbuf, const int outbuflen)
 {
-    const double finrate = (double) inrate;
-    const double outtimeincr = 1.0 / ((float) outrate);
-    const double  ratio = ((float) outrate) / ((float) inrate);
+    /* Note that this used to be double, but it looks like we can get by with float in most cases at
+       almost twice the speed on Intel processors, and orders of magnitude more
+       on CPUs that need a software fallback for double calculations. */
+    typedef float ResampleFloatType;
+
+    const ResampleFloatType finrate = (ResampleFloatType) inrate;
+    const ResampleFloatType outtimeincr = ((ResampleFloatType) 1.0f) / ((ResampleFloatType) outrate);
+    const ResampleFloatType ratio = ((float) outrate) / ((float) inrate);
     const int paddinglen = ResamplerPadding(inrate, outrate);
     const int framelen = chans * (int)sizeof (float);
     const int inframes = inbuflen / framelen;
     const int wantedoutframes = (int) ((inbuflen / framelen) * ratio);  /* outbuflen isn't total to write, it's total available. */
     const int maxoutframes = outbuflen / framelen;
     const int outframes = SDL_min(wantedoutframes, maxoutframes);
+    ResampleFloatType outtime = 0.0f;
     float *dst = outbuf;
-    double outtime = 0.0;
     int i, j, chan;
 
     for (i = 0; i < outframes; i++) {
         const int srcindex = (int) (outtime * inrate);
-        const double intime = ((double) srcindex) / finrate;
-        const double innexttime = ((double) (srcindex + 1)) / finrate;
-        const double interpolation1 = 1.0 - ((innexttime - outtime) / (innexttime - intime));
+        const ResampleFloatType intime = ((ResampleFloatType) srcindex) / finrate;
+        const ResampleFloatType innexttime = ((ResampleFloatType) (srcindex + 1)) / finrate;
+        const ResampleFloatType indeltatime = innexttime - intime;
+        const ResampleFloatType interpolation1 = (indeltatime == 0.0f) ? 1.0f : (1.0f - ((innexttime - outtime) / indeltatime));
         const int filterindex1 = (int) (interpolation1 * RESAMPLER_SAMPLES_PER_ZERO_CROSSING);
-        const double interpolation2 = 1.0 - interpolation1;
+        const ResampleFloatType interpolation2 = 1.0f - interpolation1;
         const int filterindex2 = (int) (interpolation2 * RESAMPLER_SAMPLES_PER_ZERO_CROSSING);
 
         for (chan = 0; chan < chans; chan++) {
             float outsample = 0.0f;
 
             /* do this twice to calculate the sample, once for the "left wing" and then same for the right. */
-            /* !!! FIXME: do both wings in one loop */
             for (j = 0; (filterindex1 + (j * RESAMPLER_SAMPLES_PER_ZERO_CROSSING)) < RESAMPLER_FILTER_SIZE; j++) {
                 const int srcframe = srcindex - j;
                 /* !!! FIXME: we can bubble this conditional out of here by doing a pre loop. */
@@ -849,12 +764,15 @@ SDL_ResampleAudio(const int chans, const int inrate, const int outrate,
                 outsample += (float)(insample * (ResamplerFilter[filterindex1 + (j * RESAMPLER_SAMPLES_PER_ZERO_CROSSING)] + (interpolation1 * ResamplerFilterDifference[filterindex1 + (j * RESAMPLER_SAMPLES_PER_ZERO_CROSSING)])));
             }
 
+            /* Do the right wing! */
             for (j = 0; (filterindex2 + (j * RESAMPLER_SAMPLES_PER_ZERO_CROSSING)) < RESAMPLER_FILTER_SIZE; j++) {
+                const int jsamples = j * RESAMPLER_SAMPLES_PER_ZERO_CROSSING;
                 const int srcframe = srcindex + 1 + j;
                 /* !!! FIXME: we can bubble this conditional out of here by doing a post loop. */
                 const float insample = (srcframe >= inframes) ? rpadding[((srcframe - inframes) * chans) + chan] : inbuf[(srcframe * chans) + chan];
-                outsample += (float)(insample * (ResamplerFilter[filterindex2 + (j * RESAMPLER_SAMPLES_PER_ZERO_CROSSING)] + (interpolation2 * ResamplerFilterDifference[filterindex2 + (j * RESAMPLER_SAMPLES_PER_ZERO_CROSSING)])));
+                outsample += (float)(insample * (ResamplerFilter[filterindex2 + jsamples] + (interpolation2 * ResamplerFilterDifference[filterindex2 + jsamples])));
             }
+
             *(dst++) = outsample;
         }
 
@@ -1119,10 +1037,6 @@ SDL_BuildAudioResampleCVT(SDL_AudioCVT * cvt, const int dst_channels,
         return SDL_SetError("No conversion available for these rates");
     }
 
-    if (SDL_PrepareResampleFilter() < 0) {
-        return -1;
-    }
-
     /* Update (cvt) with filter details... */
     if (SDL_AddAudioCVTFilter(cvt, filter) < 0) {
         return -1;
@@ -1743,13 +1657,6 @@ SDL_NewAudioStream(const SDL_AudioFormat src_format,
                 return NULL;
             }
 
-            if (SDL_PrepareResampleFilter() < 0) {
-                SDL_free(retval->resampler_state);
-                retval->resampler_state = NULL;
-                SDL_FreeAudioStream(retval);
-                return NULL;
-            }
-
             retval->resampler_func = SDL_ResampleAudioStream;
             retval->reset_resampler_func = SDL_ResetAudioStreamResampler;
             retval->cleanup_resampler_func = SDL_CleanupAudioStreamResampler;
diff --git a/Engine/lib/sdl/src/audio/coreaudio/SDL_coreaudio.m b/Engine/lib/sdl/src/audio/coreaudio/SDL_coreaudio.m
index 304599fff..5c267fb36 100644
--- a/Engine/lib/sdl/src/audio/coreaudio/SDL_coreaudio.m
+++ b/Engine/lib/sdl/src/audio/coreaudio/SDL_coreaudio.m
@@ -522,8 +522,12 @@ static void
 outputCallback(void *inUserData, AudioQueueRef inAQ, AudioQueueBufferRef inBuffer)
 {
     SDL_AudioDevice *this = (SDL_AudioDevice *) inUserData;
+
+    SDL_LockMutex(this->mixer_lock);
+
     if (SDL_AtomicGet(&this->hidden->shutdown)) {
-        return;  /* don't do anything. */
+        SDL_UnlockMutex(this->mixer_lock);
+        return;  /* don't do anything, since we don't even want to enqueue this buffer again. */
     }
 
     if (!SDL_AtomicGet(&this->enabled) || SDL_AtomicGet(&this->paused)) {
@@ -536,10 +540,8 @@ outputCallback(void *inUserData, AudioQueueRef inAQ, AudioQueueBufferRef inBuffe
         while (remaining > 0) {
             if (SDL_AudioStreamAvailable(this->stream) == 0) {
                 /* Generate the data */
-                SDL_LockMutex(this->mixer_lock);
                 (*this->callbackspec.callback)(this->callbackspec.userdata,
                                                this->hidden->buffer, this->hidden->bufferSize);
-                SDL_UnlockMutex(this->mixer_lock);
                 this->hidden->bufferOffset = 0;
                 SDL_AudioStreamPut(this->stream, this->hidden->buffer, this->hidden->bufferSize);
             }
@@ -565,10 +567,8 @@ outputCallback(void *inUserData, AudioQueueRef inAQ, AudioQueueBufferRef inBuffe
             UInt32 len;
             if (this->hidden->bufferOffset >= this->hidden->bufferSize) {
                 /* Generate the data */
-                SDL_LockMutex(this->mixer_lock);
                 (*this->callbackspec.callback)(this->callbackspec.userdata,
                             this->hidden->buffer, this->hidden->bufferSize);
-                SDL_UnlockMutex(this->mixer_lock);
                 this->hidden->bufferOffset = 0;
             }
 
@@ -587,6 +587,8 @@ outputCallback(void *inUserData, AudioQueueRef inAQ, AudioQueueBufferRef inBuffe
     AudioQueueEnqueueBuffer(this->hidden->audioQueue, inBuffer, 0, NULL);
 
     inBuffer->mAudioDataByteSize = inBuffer->mAudioDataBytesCapacity;
+
+    SDL_UnlockMutex(this->mixer_lock);
 }
 
 static void
diff --git a/Engine/lib/sdl/src/audio/emscripten/SDL_emscriptenaudio.c b/Engine/lib/sdl/src/audio/emscripten/SDL_emscriptenaudio.c
index 722f5d0fa..bfe42821a 100644
--- a/Engine/lib/sdl/src/audio/emscripten/SDL_emscriptenaudio.c
+++ b/Engine/lib/sdl/src/audio/emscripten/SDL_emscriptenaudio.c
@@ -28,6 +28,11 @@
 
 #include <emscripten/emscripten.h>
 
+/* !!! FIXME: this currently expects that the audio callback runs in the main thread,
+   !!! FIXME:  in intervals when the application isn't running, but that may not be
+   !!! FIXME:  true always once pthread support becomes widespread. Revisit this code
+   !!! FIXME:  at some point and see what needs to be done for that! */
+
 static void
 FeedAudioDevice(_THIS, const void *buf, const int buflen)
 {
diff --git a/Engine/lib/sdl/src/audio/haiku/SDL_haikuaudio.cc b/Engine/lib/sdl/src/audio/haiku/SDL_haikuaudio.cc
index bb6b78c1d..aec5f4a25 100644
--- a/Engine/lib/sdl/src/audio/haiku/SDL_haikuaudio.cc
+++ b/Engine/lib/sdl/src/audio/haiku/SDL_haikuaudio.cc
@@ -49,39 +49,40 @@ FillSound(void *device, void *stream, size_t len,
     SDL_AudioDevice *audio = (SDL_AudioDevice *) device;
     SDL_AudioCallback callback = audio->callbackspec.callback;
 
+    SDL_LockMutex(audio->mixer_lock);
+
     /* Only do something if audio is enabled */
     if (!SDL_AtomicGet(&audio->enabled) || SDL_AtomicGet(&audio->paused)) {
         if (audio->stream) {
             SDL_AudioStreamClear(audio->stream);
         }
         SDL_memset(stream, audio->spec.silence, len);
-        return;
-    }
+    } else {
+        SDL_assert(audio->spec.size == len);
 
-    SDL_assert(audio->spec.size == len);
+        if (audio->stream == NULL) {  /* no conversion necessary. */
+            callback(audio->callbackspec.userdata, (Uint8 *) stream, len);
+        } else {  /* streaming/converting */
+            const int stream_len = audio->callbackspec.size;
+            const int ilen = (int) len;
+            while (SDL_AudioStreamAvailable(audio->stream) < ilen) {
+                callback(audio->callbackspec.userdata, audio->work_buffer, stream_len);
+                if (SDL_AudioStreamPut(audio->stream, audio->work_buffer, stream_len) == -1) {
+                    SDL_AudioStreamClear(audio->stream);
+                    SDL_AtomicSet(&audio->enabled, 0);
+                    break;
+                }
+            }
 
-    if (audio->stream == NULL) {  /* no conversion necessary. */
-        SDL_LockMutex(audio->mixer_lock);
-        callback(audio->callbackspec.userdata, (Uint8 *) stream, len);
-        SDL_UnlockMutex(audio->mixer_lock);
-    } else {  /* streaming/converting */
-        const int stream_len = audio->callbackspec.size;
-        const int ilen = (int) len;
-        while (SDL_AudioStreamAvailable(audio->stream) < ilen) {
-            callback(audio->callbackspec.userdata, audio->work_buffer, stream_len);
-            if (SDL_AudioStreamPut(audio->stream, audio->work_buffer, stream_len) == -1) {
-                SDL_AudioStreamClear(audio->stream);
-                SDL_AtomicSet(&audio->enabled, 0);
-                break;
+            const int got = SDL_AudioStreamGet(audio->stream, stream, ilen);
+            SDL_assert((got < 0) || (got == ilen));
+            if (got != ilen) {
+                SDL_memset(stream, audio->spec.silence, len);
             }
         }
-
-        const int got = SDL_AudioStreamGet(audio->stream, stream, ilen);
-        SDL_assert((got < 0) || (got == ilen));
-        if (got != ilen) {
-            SDL_memset(stream, audio->spec.silence, len);
-        }
     }
+
+    SDL_UnlockMutex(audio->mixer_lock);
 }
 
 static void
diff --git a/Engine/lib/sdl/src/audio/nacl/SDL_naclaudio.c b/Engine/lib/sdl/src/audio/nacl/SDL_naclaudio.c
index bf48165f5..c38070d8d 100644
--- a/Engine/lib/sdl/src/audio/nacl/SDL_naclaudio.c
+++ b/Engine/lib/sdl/src/audio/nacl/SDL_naclaudio.c
@@ -49,8 +49,8 @@ static void nacl_audio_callback(void* stream, uint32_t buffer_size, PP_TimeDelta
     const int len = (int) buffer_size;
     SDL_AudioDevice* _this = (SDL_AudioDevice*) data;
     SDL_AudioCallback callback = _this->callbackspec.callback;
-    
-    SDL_LockMutex(private->mutex);  /* !!! FIXME: is this mutex necessary? */
+
+    SDL_LockMutex(_this->mixer_lock);
 
     /* Only do something if audio is enabled */
     if (!SDL_AtomicGet(&_this->enabled) || SDL_AtomicGet(&_this->paused)) {
@@ -58,34 +58,31 @@ static void nacl_audio_callback(void* stream, uint32_t buffer_size, PP_TimeDelta
             SDL_AudioStreamClear(_this->stream);
         }
         SDL_memset(stream, _this->spec.silence, len);
-        return;
-    }
+    } else {
+        SDL_assert(_this->spec.size == len);
 
-    SDL_assert(_this->spec.size == len);
+        if (_this->stream == NULL) {  /* no conversion necessary. */
+            callback(_this->callbackspec.userdata, stream, len);
+        } else {  /* streaming/converting */
+            const int stream_len = _this->callbackspec.size;
+            while (SDL_AudioStreamAvailable(_this->stream) < len) {
+                callback(_this->callbackspec.userdata, _this->work_buffer, stream_len);
+                if (SDL_AudioStreamPut(_this->stream, _this->work_buffer, stream_len) == -1) {
+                    SDL_AudioStreamClear(_this->stream);
+                    SDL_AtomicSet(&_this->enabled, 0);
+                    break;
+                }
+            }
 
-    if (_this->stream == NULL) {  /* no conversion necessary. */
-        SDL_LockMutex(_this->mixer_lock);
-        callback(_this->callbackspec.userdata, stream, len);
-        SDL_UnlockMutex(_this->mixer_lock);
-    } else {  /* streaming/converting */
-        const int stream_len = _this->callbackspec.size;
-        while (SDL_AudioStreamAvailable(_this->stream) < len) {
-            callback(_this->callbackspec.userdata, _this->work_buffer, stream_len);
-            if (SDL_AudioStreamPut(_this->stream, _this->work_buffer, stream_len) == -1) {
-                SDL_AudioStreamClear(_this->stream);
-                SDL_AtomicSet(&_this->enabled, 0);
-                break;
+            const int got = SDL_AudioStreamGet(_this->stream, stream, len);
+            SDL_assert((got < 0) || (got == len));
+            if (got != len) {
+                SDL_memset(stream, _this->spec.silence, len);
             }
         }
-
-        const int got = SDL_AudioStreamGet(_this->stream, stream, len);
-        SDL_assert((got < 0) || (got == len));
-        if (got != len) {
-            SDL_memset(stream, _this->spec.silence, len);
-        }
     }
 
-    SDL_UnlockMutex(private->mutex);
+    SDL_UnlockMutex(_this->mixer_lock);
 }
 
 static void NACLAUDIO_CloseDevice(SDL_AudioDevice *device) {
@@ -94,7 +91,6 @@ static void NACLAUDIO_CloseDevice(SDL_AudioDevice *device) {
     SDL_PrivateAudioData *hidden = (SDL_PrivateAudioData *) device->hidden;
     
     ppb_audio->StopPlayback(hidden->audio);
-    SDL_DestroyMutex(hidden->mutex);
     core->ReleaseResource(hidden->audio);
 }
 
@@ -109,7 +105,6 @@ NACLAUDIO_OpenDevice(_THIS, const char *devname) {
         return SDL_OutOfMemory();
     }
     
-    private->mutex = SDL_CreateMutex();
     _this->spec.freq = 44100;
     _this->spec.format = AUDIO_S16LSB;
     _this->spec.channels = 2;
diff --git a/Engine/lib/sdl/src/audio/nacl/SDL_naclaudio.h b/Engine/lib/sdl/src/audio/nacl/SDL_naclaudio.h
index 8348a34e8..13d8f8ca4 100644
--- a/Engine/lib/sdl/src/audio/nacl/SDL_naclaudio.h
+++ b/Engine/lib/sdl/src/audio/nacl/SDL_naclaudio.h
@@ -34,8 +34,7 @@
 #define private _this->hidden
 
 typedef struct SDL_PrivateAudioData {
-  SDL_mutex* mutex;
-  PP_Resource audio;
+    PP_Resource audio;
 } SDL_PrivateAudioData;
 
 #endif /* SDL_naclaudio_h_ */
diff --git a/Engine/lib/sdl/src/audio/netbsd/SDL_netbsdaudio.c b/Engine/lib/sdl/src/audio/netbsd/SDL_netbsdaudio.c
index 6ff81578a..5f021ea37 100644
--- a/Engine/lib/sdl/src/audio/netbsd/SDL_netbsdaudio.c
+++ b/Engine/lib/sdl/src/audio/netbsd/SDL_netbsdaudio.c
@@ -56,7 +56,7 @@ static void
 NETBSDAUDIO_Status(_THIS)
 {
 #ifdef DEBUG_AUDIO
-    /* *INDENT-OFF* */
+    /* *INDENT-OFF* */ /* clang-format off */
     audio_info_t info;
     const struct audio_prinfo *prinfo;
 
@@ -118,7 +118,7 @@ NETBSDAUDIO_Status(_THIS)
             "",
             this->spec.format,
             this->spec.size);
-    /* *INDENT-ON* */
+    /* *INDENT-ON* */ /* clang-format on */
 #endif /* DEBUG_AUDIO */
 }
 
diff --git a/Engine/lib/sdl/src/audio/pipewire/SDL_pipewire.c b/Engine/lib/sdl/src/audio/pipewire/SDL_pipewire.c
index 7e318f1bc..387028edb 100644
--- a/Engine/lib/sdl/src/audio/pipewire/SDL_pipewire.c
+++ b/Engine/lib/sdl/src/audio/pipewire/SDL_pipewire.c
@@ -910,6 +910,7 @@ output_callback(void *data)
      * and run the callback with the work buffer to keep the callback
      * firing regularly in case the audio is being used as a timer.
      */
+    SDL_LockMutex(this->mixer_lock);
     if (!SDL_AtomicGet(&this->paused)) {
         if (SDL_AtomicGet(&this->enabled)) {
             dst = spa_buf->datas[0].data;
@@ -919,18 +920,13 @@ output_callback(void *data)
         }
 
         if (!this->stream) {
-            SDL_LockMutex(this->mixer_lock);
             this->callbackspec.callback(this->callbackspec.userdata, dst, this->callbackspec.size);
-            SDL_UnlockMutex(this->mixer_lock);
         } else {
             int got;
 
             /* Fire the callback until we have enough to fill a buffer */
             while (SDL_AudioStreamAvailable(this->stream) < this->spec.size) {
-                SDL_LockMutex(this->mixer_lock);
                 this->callbackspec.callback(this->callbackspec.userdata, this->work_buffer, this->callbackspec.size);
-                SDL_UnlockMutex(this->mixer_lock);
-
                 SDL_AudioStreamPut(this->stream, this->work_buffer, this->callbackspec.size);
             }
 
@@ -940,6 +936,7 @@ output_callback(void *data)
     } else {
         SDL_memset(spa_buf->datas[0].data, this->spec.silence, this->spec.size);
     }
+    SDL_UnlockMutex(this->mixer_lock);
 
     spa_buf->datas[0].chunk->offset = 0;
     spa_buf->datas[0].chunk->stride = this->hidden->stride;
diff --git a/Engine/lib/sdl/src/audio/pulseaudio/SDL_pulseaudio.c b/Engine/lib/sdl/src/audio/pulseaudio/SDL_pulseaudio.c
index a969f2b1f..85e1386c2 100644
--- a/Engine/lib/sdl/src/audio/pulseaudio/SDL_pulseaudio.c
+++ b/Engine/lib/sdl/src/audio/pulseaudio/SDL_pulseaudio.c
@@ -107,8 +107,6 @@ static int (*PULSEAUDIO_pa_stream_connect_record) (pa_stream *, const char *,
 static pa_stream_state_t (*PULSEAUDIO_pa_stream_get_state) (const pa_stream *);
 static size_t (*PULSEAUDIO_pa_stream_writable_size) (const pa_stream *);
 static size_t (*PULSEAUDIO_pa_stream_readable_size) (const pa_stream *);
-static int (*PULSEAUDIO_pa_stream_begin_write) (pa_stream *, void **, size_t*);
-static int (*PULSEAUDIO_pa_stream_cancel_write) (pa_stream *);
 static int (*PULSEAUDIO_pa_stream_write) (pa_stream *, const void *, size_t,
     pa_free_cb_t, int64_t, pa_seek_mode_t);
 static pa_operation * (*PULSEAUDIO_pa_stream_drain) (pa_stream *,
@@ -119,6 +117,7 @@ static pa_operation * (*PULSEAUDIO_pa_stream_flush) (pa_stream *,
     pa_stream_success_cb_t, void *);
 static int (*PULSEAUDIO_pa_stream_disconnect) (pa_stream *);
 static void (*PULSEAUDIO_pa_stream_unref) (pa_stream *);
+static void (*PULSEAUDIO_pa_stream_set_write_callback)(pa_stream *, pa_stream_request_cb_t, void *);
 
 static int load_pulseaudio_syms(void);
 
@@ -222,8 +221,6 @@ load_pulseaudio_syms(void)
     SDL_PULSEAUDIO_SYM(pa_stream_writable_size);
     SDL_PULSEAUDIO_SYM(pa_stream_readable_size);
     SDL_PULSEAUDIO_SYM(pa_stream_write);
-    SDL_PULSEAUDIO_SYM(pa_stream_begin_write);
-    SDL_PULSEAUDIO_SYM(pa_stream_cancel_write);
     SDL_PULSEAUDIO_SYM(pa_stream_drain);
     SDL_PULSEAUDIO_SYM(pa_stream_disconnect);
     SDL_PULSEAUDIO_SYM(pa_stream_peek);
@@ -232,6 +229,7 @@ load_pulseaudio_syms(void)
     SDL_PULSEAUDIO_SYM(pa_stream_unref);
     SDL_PULSEAUDIO_SYM(pa_channel_map_init_auto);
     SDL_PULSEAUDIO_SYM(pa_strerror);
+    SDL_PULSEAUDIO_SYM(pa_stream_set_write_callback);
     return 0;
 }
 
@@ -359,51 +357,56 @@ ConnectToPulseServer(pa_mainloop **_mainloop, pa_context **_context)
 static void
 PULSEAUDIO_WaitDevice(_THIS)
 {
-    struct SDL_PrivateAudioData *h = this->hidden;
+    /* this is a no-op; we wait in PULSEAUDIO_PlayDevice now. */
+}
 
-    while (SDL_AtomicGet(&this->enabled)) {
+static void WriteCallback(pa_stream *p, size_t nbytes, void *userdata)
+{
+    struct SDL_PrivateAudioData *h = (struct SDL_PrivateAudioData *) userdata;
+    /*printf("PULSEAUDIO WRITE CALLBACK! nbytes=%u\n", (unsigned int) nbytes);*/
+    h->bytes_requested += nbytes;
+}
+
+static void
+PULSEAUDIO_PlayDevice(_THIS)
+{
+    struct SDL_PrivateAudioData *h = this->hidden;
+    int available = h->mixlen;
+    int written = 0;
+    int cpy;
+
+    /*printf("PULSEAUDIO PLAYDEVICE START! mixlen=%d\n", available);*/
+
+    while (SDL_AtomicGet(&this->enabled) && (available > 0)) {
+        cpy = SDL_min(h->bytes_requested, available);
+        if (cpy) {
+            if (PULSEAUDIO_pa_stream_write(h->stream, h->mixbuf + written, cpy, NULL, 0LL, PA_SEEK_RELATIVE) < 0) {
+                SDL_OpenedAudioDeviceDisconnected(this);
+                return;
+            }
+            /*printf("PULSEAUDIO FEED! nbytes=%u\n", (unsigned int) cpy);*/
+            h->bytes_requested -= cpy;
+            written += cpy;
+            available -= cpy;
+        }
+
+        /* let WriteCallback fire if necessary. */
+        /*printf("PULSEAUDIO ITERATE!\n");*/
         if (PULSEAUDIO_pa_context_get_state(h->context) != PA_CONTEXT_READY ||
             PULSEAUDIO_pa_stream_get_state(h->stream) != PA_STREAM_READY ||
             PULSEAUDIO_pa_mainloop_iterate(h->mainloop, 1, NULL) < 0) {
             SDL_OpenedAudioDeviceDisconnected(this);
             return;
         }
-        if (PULSEAUDIO_pa_stream_writable_size(h->stream) >= (h->mixlen/8)) {
-            return;
-        }
     }
-}
 
-static void
-PULSEAUDIO_PlayDevice(_THIS)
-{
-    /* Write the audio data */
-    struct SDL_PrivateAudioData *h = this->hidden;
-    if (SDL_AtomicGet(&this->enabled)) {
-        if (PULSEAUDIO_pa_stream_write(h->stream, h->pabuf, h->mixlen, NULL, 0LL, PA_SEEK_RELATIVE) < 0) {
-            SDL_OpenedAudioDeviceDisconnected(this);
-        }
-    }
+    /*printf("PULSEAUDIO PLAYDEVICE END! written=%d\n", written);*/
 }
 
 static Uint8 *
 PULSEAUDIO_GetDeviceBuf(_THIS)
 {
-    struct SDL_PrivateAudioData *h = this->hidden;
-    size_t nbytes = h->mixlen;
-    int ret;
-
-    ret = PULSEAUDIO_pa_stream_begin_write(h->stream, &h->pabuf, &nbytes);
-
-    if (ret != 0) {
-        /* fall back it intermediate buffer */
-        h->pabuf = h->mixbuf;
-    } else if (nbytes < h->mixlen) {
-        PULSEAUDIO_pa_stream_cancel_write(h->stream);
-        h->pabuf = h->mixbuf;
-    }
-
-    return (Uint8 *)h->pabuf;
+    return this->hidden->mixbuf;
 }
 
 
@@ -604,9 +607,6 @@ PULSEAUDIO_OpenDevice(_THIS, const char *devname)
     paspec.format = format;
 
     /* Calculate the final parameters for this audio specification */
-#ifdef PA_STREAM_ADJUST_LATENCY
-    this->spec.samples /= 2; /* Mix in smaller chunck to avoid underruns */
-#endif
     SDL_CalculateAudioSpec(&this->spec);
 
     /* Allocate mixing buffer */
@@ -623,22 +623,12 @@ PULSEAUDIO_OpenDevice(_THIS, const char *devname)
     paspec.rate = this->spec.freq;
 
     /* Reduced prebuffering compared to the defaults. */
-#ifdef PA_STREAM_ADJUST_LATENCY
     paattr.fragsize = this->spec.size;
-    /* 2x original requested bufsize */
-    paattr.tlength = h->mixlen * 4;
+    paattr.tlength = h->mixlen;
     paattr.prebuf = -1;
     paattr.maxlength = -1;
-    /* -1 can lead to pa_stream_writable_size() >= mixlen never being true */
-    paattr.minreq = h->mixlen;
-    flags = PA_STREAM_ADJUST_LATENCY;
-#else
-    paattr.fragsize = this->spec.size;
-    paattr.tlength = h->mixlen*2;
-    paattr.prebuf = h->mixlen*2;
-    paattr.maxlength = h->mixlen*2;
-    paattr.minreq = h->mixlen;
-#endif
+    paattr.minreq = -1;
+    flags |= PA_STREAM_ADJUST_LATENCY;
 
     if (ConnectToPulseServer(&h->mainloop, &h->context) < 0) {
         return SDL_SetError("Could not connect to PulseAudio server");
@@ -675,6 +665,7 @@ PULSEAUDIO_OpenDevice(_THIS, const char *devname)
     if (iscapture) {
         rc = PULSEAUDIO_pa_stream_connect_record(h->stream, h->device_name, &paattr, flags);
     } else {
+        PULSEAUDIO_pa_stream_set_write_callback(h->stream, WriteCallback, h);
         rc = PULSEAUDIO_pa_stream_connect_playback(h->stream, h->device_name, &paattr, flags, NULL, NULL);
     }
 
diff --git a/Engine/lib/sdl/src/audio/pulseaudio/SDL_pulseaudio.h b/Engine/lib/sdl/src/audio/pulseaudio/SDL_pulseaudio.h
index a0d0b0c98..7ef45fe25 100644
--- a/Engine/lib/sdl/src/audio/pulseaudio/SDL_pulseaudio.h
+++ b/Engine/lib/sdl/src/audio/pulseaudio/SDL_pulseaudio.h
@@ -43,11 +43,7 @@ struct SDL_PrivateAudioData
     Uint8 *mixbuf;
     int mixlen;
 
-    /* Pointer to the actual buffer in use in the current
-       GetDeviceBuf() -> PlayDevice() iteration.
-       Can be either the pointer returned by pa_stream_begin_write()
-       or mixbuf */
-    void *pabuf;
+    int bytes_requested;  /* bytes of data the hardware wants _now_. */
 
     const Uint8 *capturebuf;
     int capturelen;
diff --git a/Engine/lib/sdl/src/audio/wasapi/SDL_wasapi_win32.c b/Engine/lib/sdl/src/audio/wasapi/SDL_wasapi_win32.c
index 8e5c7e2a1..137f37013 100644
--- a/Engine/lib/sdl/src/audio/wasapi/SDL_wasapi_win32.c
+++ b/Engine/lib/sdl/src/audio/wasapi/SDL_wasapi_win32.c
@@ -362,7 +362,7 @@ typedef struct
     WAVEFORMATEXTENSIBLE fmt;
 } EndpointItem;
 
-static int sort_endpoints(const void *_a, const void *_b)
+static int SDLCALL sort_endpoints(const void *_a, const void *_b)
 {
     LPWSTR a = ((const EndpointItem *) _a)->devid;
     LPWSTR b = ((const EndpointItem *) _b)->devid;
diff --git a/Engine/lib/sdl/src/core/linux/SDL_dbus.c b/Engine/lib/sdl/src/core/linux/SDL_dbus.c
index 2fe12163e..ecfbe6f4e 100644
--- a/Engine/lib/sdl/src/core/linux/SDL_dbus.c
+++ b/Engine/lib/sdl/src/core/linux/SDL_dbus.c
@@ -22,6 +22,7 @@
 #include "SDL_hints.h"
 #include "SDL_dbus.h"
 #include "SDL_atomic.h"
+#include "../../stdlib/SDL_vacopy.h"
 
 #if SDL_USE_LIBDBUS
 /* we never link directly to libdbus. */
diff --git a/Engine/lib/sdl/src/core/windows/SDL_hid.c b/Engine/lib/sdl/src/core/windows/SDL_hid.c
index da9413596..d9dd04fbe 100644
--- a/Engine/lib/sdl/src/core/windows/SDL_hid.c
+++ b/Engine/lib/sdl/src/core/windows/SDL_hid.c
@@ -27,8 +27,6 @@
 
 HidD_GetString_t SDL_HidD_GetManufacturerString;
 HidD_GetString_t SDL_HidD_GetProductString;
-HidD_GetPreparsedData_t SDL_HidD_GetPreparsedData;
-HidD_FreePreparsedData_t SDL_HidD_FreePreparsedData;
 HidP_GetCaps_t SDL_HidP_GetCaps;
 HidP_GetButtonCaps_t SDL_HidP_GetButtonCaps;
 HidP_GetValueCaps_t SDL_HidP_GetValueCaps;
@@ -58,15 +56,13 @@ WIN_LoadHIDDLL(void)
 
     SDL_HidD_GetManufacturerString = (HidD_GetString_t)GetProcAddress(s_pHIDDLL, "HidD_GetManufacturerString");
     SDL_HidD_GetProductString = (HidD_GetString_t)GetProcAddress(s_pHIDDLL, "HidD_GetProductString");
-    SDL_HidD_GetPreparsedData = (HidD_GetPreparsedData_t)GetProcAddress(s_pHIDDLL, "HidD_GetPreparsedData");
-    SDL_HidD_FreePreparsedData = (HidD_FreePreparsedData_t)GetProcAddress(s_pHIDDLL, "HidD_FreePreparsedData");
     SDL_HidP_GetCaps = (HidP_GetCaps_t)GetProcAddress(s_pHIDDLL, "HidP_GetCaps");
     SDL_HidP_GetButtonCaps = (HidP_GetButtonCaps_t)GetProcAddress(s_pHIDDLL, "HidP_GetButtonCaps");
     SDL_HidP_GetValueCaps = (HidP_GetValueCaps_t)GetProcAddress(s_pHIDDLL, "HidP_GetValueCaps");
     SDL_HidP_MaxDataListLength = (HidP_MaxDataListLength_t)GetProcAddress(s_pHIDDLL, "HidP_MaxDataListLength");
     SDL_HidP_GetData = (HidP_GetData_t)GetProcAddress(s_pHIDDLL, "HidP_GetData");
-    if (!SDL_HidD_GetManufacturerString || !SDL_HidD_GetProductString || !SDL_HidD_GetPreparsedData ||
-        !SDL_HidD_FreePreparsedData || !SDL_HidP_GetCaps || !SDL_HidP_GetButtonCaps ||
+    if (!SDL_HidD_GetManufacturerString || !SDL_HidD_GetProductString ||
+        !SDL_HidP_GetCaps || !SDL_HidP_GetButtonCaps ||
         !SDL_HidP_GetValueCaps || !SDL_HidP_MaxDataListLength || !SDL_HidP_GetData) {
         WIN_UnloadHIDDLL();
         return -1;
diff --git a/Engine/lib/sdl/src/core/windows/SDL_hid.h b/Engine/lib/sdl/src/core/windows/SDL_hid.h
index 54b9feb52..82a001a2e 100644
--- a/Engine/lib/sdl/src/core/windows/SDL_hid.h
+++ b/Engine/lib/sdl/src/core/windows/SDL_hid.h
@@ -183,8 +183,6 @@ extern int WIN_LoadHIDDLL(void);
 extern void WIN_UnloadHIDDLL(void);
 
 typedef BOOLEAN (WINAPI *HidD_GetString_t)(HANDLE HidDeviceObject, PVOID Buffer, ULONG BufferLength);
-typedef BOOLEAN (WINAPI *HidD_GetPreparsedData_t)(HANDLE HidDeviceObject, PHIDP_PREPARSED_DATA *PreparsedData);
-typedef BOOLEAN (WINAPI *HidD_FreePreparsedData_t)(PHIDP_PREPARSED_DATA PreparsedData);
 typedef NTSTATUS (WINAPI *HidP_GetCaps_t)(PHIDP_PREPARSED_DATA PreparsedData, PHIDP_CAPS Capabilities);
 typedef NTSTATUS (WINAPI *HidP_GetButtonCaps_t)(HIDP_REPORT_TYPE ReportType, PHIDP_BUTTON_CAPS ButtonCaps, PUSHORT ButtonCapsLength, PHIDP_PREPARSED_DATA PreparsedData);
 typedef NTSTATUS (WINAPI *HidP_GetValueCaps_t)(HIDP_REPORT_TYPE ReportType, PHIDP_VALUE_CAPS ValueCaps, PUSHORT ValueCapsLength, PHIDP_PREPARSED_DATA PreparsedData);
@@ -193,8 +191,6 @@ typedef NTSTATUS (WINAPI *HidP_GetData_t)(HIDP_REPORT_TYPE ReportType, PHIDP_DAT
 
 extern HidD_GetString_t SDL_HidD_GetManufacturerString;
 extern HidD_GetString_t SDL_HidD_GetProductString;
-extern HidD_GetPreparsedData_t SDL_HidD_GetPreparsedData;
-extern HidD_FreePreparsedData_t SDL_HidD_FreePreparsedData;
 extern HidP_GetCaps_t SDL_HidP_GetCaps;
 extern HidP_GetButtonCaps_t SDL_HidP_GetButtonCaps;
 extern HidP_GetValueCaps_t SDL_HidP_GetValueCaps;
diff --git a/Engine/lib/sdl/src/core/windows/SDL_windows.h b/Engine/lib/sdl/src/core/windows/SDL_windows.h
index 917a8256f..681f01b87 100644
--- a/Engine/lib/sdl/src/core/windows/SDL_windows.h
+++ b/Engine/lib/sdl/src/core/windows/SDL_windows.h
@@ -30,6 +30,8 @@
 #ifndef UNICODE
 #define UNICODE 1
 #endif
+#undef WINVER
+#define WINVER 0x0501
 #undef _WIN32_WINNT
 #define _WIN32_WINNT  0x501   /* Need 0x410 for AlphaBlend() and 0x500 for EnumDisplayDevices(), 0x501 for raw input */
 #endif
diff --git a/Engine/lib/sdl/src/core/windows/SDL_xinput.c b/Engine/lib/sdl/src/core/windows/SDL_xinput.c
index 1893907e4..fa67efcbb 100644
--- a/Engine/lib/sdl/src/core/windows/SDL_xinput.c
+++ b/Engine/lib/sdl/src/core/windows/SDL_xinput.c
@@ -23,8 +23,6 @@
 #include "SDL_xinput.h"
 
 
-#ifdef HAVE_XINPUT_H
-
 XInputGetState_t SDL_XInputGetState = NULL;
 XInputSetState_t SDL_XInputSetState = NULL;
 XInputGetCapabilities_t SDL_XInputGetCapabilities = NULL;
@@ -137,6 +135,5 @@ WIN_UnloadXInputDLL(void)
 }
 
 #endif /* __WINRT__ */
-#endif /* HAVE_XINPUT_H */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/core/windows/SDL_xinput.h b/Engine/lib/sdl/src/core/windows/SDL_xinput.h
index 6e72327d8..1879e09ad 100644
--- a/Engine/lib/sdl/src/core/windows/SDL_xinput.h
+++ b/Engine/lib/sdl/src/core/windows/SDL_xinput.h
@@ -23,10 +23,11 @@
 #ifndef SDL_xinput_h_
 #define SDL_xinput_h_
 
-#ifdef HAVE_XINPUT_H
-
 #include "SDL_windows.h"
+
+#ifdef HAVE_XINPUT_H
 #include <xinput.h>
+#endif /* HAVE_XINPUT_H */
 
 #ifndef XUSER_MAX_COUNT
 #define XUSER_MAX_COUNT 4
@@ -72,6 +73,53 @@
 #define XINPUT_DEVSUBTYPE_ARCADE_PAD 0x13
 #endif
 
+#ifndef XINPUT_FLAG_GAMEPAD
+#define XINPUT_FLAG_GAMEPAD 0x01
+#endif
+
+#ifndef XINPUT_GAMEPAD_DPAD_UP
+#define XINPUT_GAMEPAD_DPAD_UP 0x0001
+#endif
+#ifndef XINPUT_GAMEPAD_DPAD_DOWN
+#define XINPUT_GAMEPAD_DPAD_DOWN 0x0002
+#endif
+#ifndef XINPUT_GAMEPAD_DPAD_LEFT
+#define XINPUT_GAMEPAD_DPAD_LEFT 0x0004
+#endif
+#ifndef XINPUT_GAMEPAD_DPAD_RIGHT
+#define XINPUT_GAMEPAD_DPAD_RIGHT 0x0008
+#endif
+#ifndef XINPUT_GAMEPAD_START
+#define XINPUT_GAMEPAD_START 0x0010
+#endif
+#ifndef XINPUT_GAMEPAD_BACK
+#define XINPUT_GAMEPAD_BACK 0x0020
+#endif
+#ifndef XINPUT_GAMEPAD_LEFT_THUMB
+#define XINPUT_GAMEPAD_LEFT_THUMB 0x0040
+#endif
+#ifndef XINPUT_GAMEPAD_RIGHT_THUMB
+#define XINPUT_GAMEPAD_RIGHT_THUMB 0x0080
+#endif
+#ifndef XINPUT_GAMEPAD_LEFT_SHOULDER
+#define XINPUT_GAMEPAD_LEFT_SHOULDER 0x0100
+#endif
+#ifndef XINPUT_GAMEPAD_RIGHT_SHOULDER
+#define XINPUT_GAMEPAD_RIGHT_SHOULDER 0x0200
+#endif
+#ifndef XINPUT_GAMEPAD_A
+#define XINPUT_GAMEPAD_A 0x1000
+#endif
+#ifndef XINPUT_GAMEPAD_B
+#define XINPUT_GAMEPAD_B 0x2000
+#endif
+#ifndef XINPUT_GAMEPAD_X
+#define XINPUT_GAMEPAD_X 0x4000
+#endif
+#ifndef XINPUT_GAMEPAD_Y
+#define XINPUT_GAMEPAD_Y 0x8000
+#endif
+
 #ifndef XINPUT_GAMEPAD_GUIDE
 #define XINPUT_GAMEPAD_GUIDE 0x0400
 #endif
@@ -129,6 +177,36 @@ typedef struct
     BYTE BatteryLevel;
 } XINPUT_BATTERY_INFORMATION_EX;
 
+#ifndef HAVE_XINPUT_H
+
+typedef struct
+{
+    WORD wButtons;
+    BYTE bLeftTrigger;
+    BYTE bRightTrigger;
+    SHORT sThumbLX;
+    SHORT sThumbLY;
+    SHORT sThumbRX;
+    SHORT sThumbRY;
+} XINPUT_GAMEPAD;
+
+typedef struct
+{
+    WORD wLeftMotorSpeed;
+    WORD wRightMotorSpeed;
+} XINPUT_VIBRATION;
+
+typedef struct
+{
+    BYTE Type;
+    BYTE SubType;
+    WORD Flags;
+    XINPUT_GAMEPAD Gamepad;
+    XINPUT_VIBRATION Vibration;
+} XINPUT_CAPABILITIES;
+
+#endif /* HAVE_XINPUT_H */
+
 /* Forward decl's for XInput API's we load dynamically and use if available */
 typedef DWORD (WINAPI *XInputGetState_t)
     (
@@ -170,8 +248,6 @@ extern DWORD SDL_XInputVersion;  /* ((major << 16) & 0xFF00) | (minor & 0xFF) */
 #define XINPUTGETCAPABILITIES   SDL_XInputGetCapabilities
 #define XINPUTGETBATTERYINFORMATION   SDL_XInputGetBatteryInformation
 
-#endif /* HAVE_XINPUT_H */
-
 #endif /* SDL_xinput_h_ */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/cpuinfo/SDL_cpuinfo.c b/Engine/lib/sdl/src/cpuinfo/SDL_cpuinfo.c
index babbb816c..aa994357a 100644
--- a/Engine/lib/sdl/src/cpuinfo/SDL_cpuinfo.c
+++ b/Engine/lib/sdl/src/cpuinfo/SDL_cpuinfo.c
@@ -130,7 +130,7 @@ CPU_haveCPUID(void)
 {
     int has_CPUID = 0;
 
-/* *INDENT-OFF* */
+/* *INDENT-OFF* */ /* clang-format off */
 #ifndef SDL_CPUINFO_DISABLED
 #if (defined(__GNUC__) || defined(__llvm__)) && defined(__i386__)
     __asm__ (
@@ -219,7 +219,7 @@ done:
     );
 #endif
 #endif
-/* *INDENT-ON* */
+/* *INDENT-ON* */ /* clang-format on */
     return has_CPUID;
 }
 
@@ -1058,10 +1058,18 @@ void *
 SDL_SIMDAlloc(const size_t len)
 {
     const size_t alignment = SDL_SIMDGetAlignment();
-    const size_t padding = alignment - (len % alignment);
-    const size_t padded = (padding != alignment) ? (len + padding) : len;
+    const size_t padding = (alignment - (len % alignment)) % alignment;
     Uint8 *retval = NULL;
-    Uint8 *ptr = (Uint8 *) SDL_malloc(padded + alignment + sizeof (void *));
+    Uint8 *ptr;
+    size_t to_allocate;
+
+    /* alignment + padding + sizeof (void *) is bounded (a few hundred
+     * bytes max), so no need to check for overflow within that argument */
+    if (SDL_size_add_overflow(len, alignment + padding + sizeof (void *), &to_allocate)) {
+        return NULL;
+    }
+
+    ptr = (Uint8 *) SDL_malloc(to_allocate);
     if (ptr) {
         /* store the actual allocated pointer right before our aligned pointer. */
         retval = ptr + sizeof (void *);
@@ -1075,12 +1083,18 @@ void *
 SDL_SIMDRealloc(void *mem, const size_t len)
 {
     const size_t alignment = SDL_SIMDGetAlignment();
-    const size_t padding = alignment - (len % alignment);
-    const size_t padded = (padding != alignment) ? (len + padding) : len;
+    const size_t padding = (alignment - (len % alignment)) % alignment;
     Uint8 *retval = (Uint8*) mem;
     void *oldmem = mem;
     size_t memdiff = 0, ptrdiff;
     Uint8 *ptr;
+    size_t to_allocate;
+
+    /* alignment + padding + sizeof (void *) is bounded (a few hundred
+     * bytes max), so no need to check for overflow within that argument */
+    if (SDL_size_add_overflow(len, alignment + padding + sizeof (void *), &to_allocate)) {
+        return NULL;
+    }
 
     if (mem) {
         void **realptr = (void **) mem;
@@ -1091,7 +1105,7 @@ SDL_SIMDRealloc(void *mem, const size_t len)
         memdiff = ((size_t) oldmem) - ((size_t) mem);
     }
 
-    ptr = (Uint8 *) SDL_realloc(mem, padded + alignment + sizeof (void *));
+    ptr = (Uint8 *) SDL_realloc(mem, to_allocate);
 
     if (ptr == NULL) {
         return NULL; /* Out of memory, bail! */
diff --git a/Engine/lib/sdl/src/dynapi/SDL2.exports b/Engine/lib/sdl/src/dynapi/SDL2.exports
new file mode 100644
index 000000000..3d09d1108
--- /dev/null
+++ b/Engine/lib/sdl/src/dynapi/SDL2.exports
@@ -0,0 +1,843 @@
+# Windows exports file for Watcom
+# DO NOT EDIT THIS FILE BY HAND. It is autogenerated by gendynapi.pl.
+++'_SDL_DYNAPI_entry'.'SDL2.dll'.'SDL_DYNAPI_entry'
+++'_SDL_SetError'.'SDL2.dll'.'SDL_SetError'
+++'_SDL_Log'.'SDL2.dll'.'SDL_Log'
+++'_SDL_LogVerbose'.'SDL2.dll'.'SDL_LogVerbose'
+++'_SDL_LogDebug'.'SDL2.dll'.'SDL_LogDebug'
+++'_SDL_LogInfo'.'SDL2.dll'.'SDL_LogInfo'
+++'_SDL_LogWarn'.'SDL2.dll'.'SDL_LogWarn'
+++'_SDL_LogError'.'SDL2.dll'.'SDL_LogError'
+++'_SDL_LogCritical'.'SDL2.dll'.'SDL_LogCritical'
+++'_SDL_LogMessage'.'SDL2.dll'.'SDL_LogMessage'
+++'_SDL_sscanf'.'SDL2.dll'.'SDL_sscanf'
+++'_SDL_snprintf'.'SDL2.dll'.'SDL_snprintf'
+++'_SDL_CreateThread'.'SDL2.dll'.'SDL_CreateThread'
+++'_SDL_RWFromFP'.'SDL2.dll'.'SDL_RWFromFP'
+++'_SDL_RegisterApp'.'SDL2.dll'.'SDL_RegisterApp'
+++'_SDL_UnregisterApp'.'SDL2.dll'.'SDL_UnregisterApp'
+++'_SDL_Direct3D9GetAdapterIndex'.'SDL2.dll'.'SDL_Direct3D9GetAdapterIndex'
+++'_SDL_RenderGetD3D9Device'.'SDL2.dll'.'SDL_RenderGetD3D9Device'
+# ++'_SDL_iPhoneSetAnimationCallback'.'SDL2.dll'.'SDL_iPhoneSetAnimationCallback'
+# ++'_SDL_iPhoneSetEventPump'.'SDL2.dll'.'SDL_iPhoneSetEventPump'
+# ++'_SDL_AndroidGetJNIEnv'.'SDL2.dll'.'SDL_AndroidGetJNIEnv'
+# ++'_SDL_AndroidGetActivity'.'SDL2.dll'.'SDL_AndroidGetActivity'
+# ++'_SDL_AndroidGetInternalStoragePath'.'SDL2.dll'.'SDL_AndroidGetInternalStoragePath'
+# ++'_SDL_AndroidGetExternalStorageState'.'SDL2.dll'.'SDL_AndroidGetExternalStorageState'
+# ++'_SDL_AndroidGetExternalStoragePath'.'SDL2.dll'.'SDL_AndroidGetExternalStoragePath'
+++'_SDL_Init'.'SDL2.dll'.'SDL_Init'
+++'_SDL_InitSubSystem'.'SDL2.dll'.'SDL_InitSubSystem'
+++'_SDL_QuitSubSystem'.'SDL2.dll'.'SDL_QuitSubSystem'
+++'_SDL_WasInit'.'SDL2.dll'.'SDL_WasInit'
+++'_SDL_Quit'.'SDL2.dll'.'SDL_Quit'
+++'_SDL_ReportAssertion'.'SDL2.dll'.'SDL_ReportAssertion'
+++'_SDL_SetAssertionHandler'.'SDL2.dll'.'SDL_SetAssertionHandler'
+++'_SDL_GetAssertionReport'.'SDL2.dll'.'SDL_GetAssertionReport'
+++'_SDL_ResetAssertionReport'.'SDL2.dll'.'SDL_ResetAssertionReport'
+++'_SDL_AtomicTryLock'.'SDL2.dll'.'SDL_AtomicTryLock'
+++'_SDL_AtomicLock'.'SDL2.dll'.'SDL_AtomicLock'
+++'_SDL_AtomicUnlock'.'SDL2.dll'.'SDL_AtomicUnlock'
+++'_SDL_AtomicCAS'.'SDL2.dll'.'SDL_AtomicCAS'
+++'_SDL_AtomicSet'.'SDL2.dll'.'SDL_AtomicSet'
+++'_SDL_AtomicGet'.'SDL2.dll'.'SDL_AtomicGet'
+++'_SDL_AtomicAdd'.'SDL2.dll'.'SDL_AtomicAdd'
+++'_SDL_AtomicCASPtr'.'SDL2.dll'.'SDL_AtomicCASPtr'
+++'_SDL_AtomicSetPtr'.'SDL2.dll'.'SDL_AtomicSetPtr'
+++'_SDL_AtomicGetPtr'.'SDL2.dll'.'SDL_AtomicGetPtr'
+++'_SDL_GetNumAudioDrivers'.'SDL2.dll'.'SDL_GetNumAudioDrivers'
+++'_SDL_GetAudioDriver'.'SDL2.dll'.'SDL_GetAudioDriver'
+++'_SDL_AudioInit'.'SDL2.dll'.'SDL_AudioInit'
+++'_SDL_AudioQuit'.'SDL2.dll'.'SDL_AudioQuit'
+++'_SDL_GetCurrentAudioDriver'.'SDL2.dll'.'SDL_GetCurrentAudioDriver'
+++'_SDL_OpenAudio'.'SDL2.dll'.'SDL_OpenAudio'
+++'_SDL_GetNumAudioDevices'.'SDL2.dll'.'SDL_GetNumAudioDevices'
+++'_SDL_GetAudioDeviceName'.'SDL2.dll'.'SDL_GetAudioDeviceName'
+++'_SDL_OpenAudioDevice'.'SDL2.dll'.'SDL_OpenAudioDevice'
+++'_SDL_GetAudioStatus'.'SDL2.dll'.'SDL_GetAudioStatus'
+++'_SDL_GetAudioDeviceStatus'.'SDL2.dll'.'SDL_GetAudioDeviceStatus'
+++'_SDL_PauseAudio'.'SDL2.dll'.'SDL_PauseAudio'
+++'_SDL_PauseAudioDevice'.'SDL2.dll'.'SDL_PauseAudioDevice'
+++'_SDL_LoadWAV_RW'.'SDL2.dll'.'SDL_LoadWAV_RW'
+++'_SDL_FreeWAV'.'SDL2.dll'.'SDL_FreeWAV'
+++'_SDL_BuildAudioCVT'.'SDL2.dll'.'SDL_BuildAudioCVT'
+++'_SDL_ConvertAudio'.'SDL2.dll'.'SDL_ConvertAudio'
+++'_SDL_MixAudio'.'SDL2.dll'.'SDL_MixAudio'
+++'_SDL_MixAudioFormat'.'SDL2.dll'.'SDL_MixAudioFormat'
+++'_SDL_LockAudio'.'SDL2.dll'.'SDL_LockAudio'
+++'_SDL_LockAudioDevice'.'SDL2.dll'.'SDL_LockAudioDevice'
+++'_SDL_UnlockAudio'.'SDL2.dll'.'SDL_UnlockAudio'
+++'_SDL_UnlockAudioDevice'.'SDL2.dll'.'SDL_UnlockAudioDevice'
+++'_SDL_CloseAudio'.'SDL2.dll'.'SDL_CloseAudio'
+++'_SDL_CloseAudioDevice'.'SDL2.dll'.'SDL_CloseAudioDevice'
+++'_SDL_SetClipboardText'.'SDL2.dll'.'SDL_SetClipboardText'
+++'_SDL_GetClipboardText'.'SDL2.dll'.'SDL_GetClipboardText'
+++'_SDL_HasClipboardText'.'SDL2.dll'.'SDL_HasClipboardText'
+++'_SDL_GetCPUCount'.'SDL2.dll'.'SDL_GetCPUCount'
+++'_SDL_GetCPUCacheLineSize'.'SDL2.dll'.'SDL_GetCPUCacheLineSize'
+++'_SDL_HasRDTSC'.'SDL2.dll'.'SDL_HasRDTSC'
+++'_SDL_HasAltiVec'.'SDL2.dll'.'SDL_HasAltiVec'
+++'_SDL_HasMMX'.'SDL2.dll'.'SDL_HasMMX'
+++'_SDL_Has3DNow'.'SDL2.dll'.'SDL_Has3DNow'
+++'_SDL_HasSSE'.'SDL2.dll'.'SDL_HasSSE'
+++'_SDL_HasSSE2'.'SDL2.dll'.'SDL_HasSSE2'
+++'_SDL_HasSSE3'.'SDL2.dll'.'SDL_HasSSE3'
+++'_SDL_HasSSE41'.'SDL2.dll'.'SDL_HasSSE41'
+++'_SDL_HasSSE42'.'SDL2.dll'.'SDL_HasSSE42'
+++'_SDL_GetSystemRAM'.'SDL2.dll'.'SDL_GetSystemRAM'
+++'_SDL_GetError'.'SDL2.dll'.'SDL_GetError'
+++'_SDL_ClearError'.'SDL2.dll'.'SDL_ClearError'
+++'_SDL_Error'.'SDL2.dll'.'SDL_Error'
+++'_SDL_PumpEvents'.'SDL2.dll'.'SDL_PumpEvents'
+++'_SDL_PeepEvents'.'SDL2.dll'.'SDL_PeepEvents'
+++'_SDL_HasEvent'.'SDL2.dll'.'SDL_HasEvent'
+++'_SDL_HasEvents'.'SDL2.dll'.'SDL_HasEvents'
+++'_SDL_FlushEvent'.'SDL2.dll'.'SDL_FlushEvent'
+++'_SDL_FlushEvents'.'SDL2.dll'.'SDL_FlushEvents'
+++'_SDL_PollEvent'.'SDL2.dll'.'SDL_PollEvent'
+++'_SDL_WaitEvent'.'SDL2.dll'.'SDL_WaitEvent'
+++'_SDL_WaitEventTimeout'.'SDL2.dll'.'SDL_WaitEventTimeout'
+++'_SDL_PushEvent'.'SDL2.dll'.'SDL_PushEvent'
+++'_SDL_SetEventFilter'.'SDL2.dll'.'SDL_SetEventFilter'
+++'_SDL_GetEventFilter'.'SDL2.dll'.'SDL_GetEventFilter'
+++'_SDL_AddEventWatch'.'SDL2.dll'.'SDL_AddEventWatch'
+++'_SDL_DelEventWatch'.'SDL2.dll'.'SDL_DelEventWatch'
+++'_SDL_FilterEvents'.'SDL2.dll'.'SDL_FilterEvents'
+++'_SDL_EventState'.'SDL2.dll'.'SDL_EventState'
+++'_SDL_RegisterEvents'.'SDL2.dll'.'SDL_RegisterEvents'
+++'_SDL_GetBasePath'.'SDL2.dll'.'SDL_GetBasePath'
+++'_SDL_GetPrefPath'.'SDL2.dll'.'SDL_GetPrefPath'
+++'_SDL_GameControllerAddMapping'.'SDL2.dll'.'SDL_GameControllerAddMapping'
+++'_SDL_GameControllerMappingForGUID'.'SDL2.dll'.'SDL_GameControllerMappingForGUID'
+++'_SDL_GameControllerMapping'.'SDL2.dll'.'SDL_GameControllerMapping'
+++'_SDL_IsGameController'.'SDL2.dll'.'SDL_IsGameController'
+++'_SDL_GameControllerNameForIndex'.'SDL2.dll'.'SDL_GameControllerNameForIndex'
+++'_SDL_GameControllerOpen'.'SDL2.dll'.'SDL_GameControllerOpen'
+++'_SDL_GameControllerName'.'SDL2.dll'.'SDL_GameControllerName'
+++'_SDL_GameControllerGetAttached'.'SDL2.dll'.'SDL_GameControllerGetAttached'
+++'_SDL_GameControllerGetJoystick'.'SDL2.dll'.'SDL_GameControllerGetJoystick'
+++'_SDL_GameControllerEventState'.'SDL2.dll'.'SDL_GameControllerEventState'
+++'_SDL_GameControllerUpdate'.'SDL2.dll'.'SDL_GameControllerUpdate'
+++'_SDL_GameControllerGetAxisFromString'.'SDL2.dll'.'SDL_GameControllerGetAxisFromString'
+++'_SDL_GameControllerGetStringForAxis'.'SDL2.dll'.'SDL_GameControllerGetStringForAxis'
+++'_SDL_GameControllerGetBindForAxis'.'SDL2.dll'.'SDL_GameControllerGetBindForAxis'
+++'_SDL_GameControllerGetAxis'.'SDL2.dll'.'SDL_GameControllerGetAxis'
+++'_SDL_GameControllerGetButtonFromString'.'SDL2.dll'.'SDL_GameControllerGetButtonFromString'
+++'_SDL_GameControllerGetStringForButton'.'SDL2.dll'.'SDL_GameControllerGetStringForButton'
+++'_SDL_GameControllerGetBindForButton'.'SDL2.dll'.'SDL_GameControllerGetBindForButton'
+++'_SDL_GameControllerGetButton'.'SDL2.dll'.'SDL_GameControllerGetButton'
+++'_SDL_GameControllerClose'.'SDL2.dll'.'SDL_GameControllerClose'
+++'_SDL_RecordGesture'.'SDL2.dll'.'SDL_RecordGesture'
+++'_SDL_SaveAllDollarTemplates'.'SDL2.dll'.'SDL_SaveAllDollarTemplates'
+++'_SDL_SaveDollarTemplate'.'SDL2.dll'.'SDL_SaveDollarTemplate'
+++'_SDL_LoadDollarTemplates'.'SDL2.dll'.'SDL_LoadDollarTemplates'
+++'_SDL_NumHaptics'.'SDL2.dll'.'SDL_NumHaptics'
+++'_SDL_HapticName'.'SDL2.dll'.'SDL_HapticName'
+++'_SDL_HapticOpen'.'SDL2.dll'.'SDL_HapticOpen'
+++'_SDL_HapticOpened'.'SDL2.dll'.'SDL_HapticOpened'
+++'_SDL_HapticIndex'.'SDL2.dll'.'SDL_HapticIndex'
+++'_SDL_MouseIsHaptic'.'SDL2.dll'.'SDL_MouseIsHaptic'
+++'_SDL_HapticOpenFromMouse'.'SDL2.dll'.'SDL_HapticOpenFromMouse'
+++'_SDL_JoystickIsHaptic'.'SDL2.dll'.'SDL_JoystickIsHaptic'
+++'_SDL_HapticOpenFromJoystick'.'SDL2.dll'.'SDL_HapticOpenFromJoystick'
+++'_SDL_HapticClose'.'SDL2.dll'.'SDL_HapticClose'
+++'_SDL_HapticNumEffects'.'SDL2.dll'.'SDL_HapticNumEffects'
+++'_SDL_HapticNumEffectsPlaying'.'SDL2.dll'.'SDL_HapticNumEffectsPlaying'
+++'_SDL_HapticQuery'.'SDL2.dll'.'SDL_HapticQuery'
+++'_SDL_HapticNumAxes'.'SDL2.dll'.'SDL_HapticNumAxes'
+++'_SDL_HapticEffectSupported'.'SDL2.dll'.'SDL_HapticEffectSupported'
+++'_SDL_HapticNewEffect'.'SDL2.dll'.'SDL_HapticNewEffect'
+++'_SDL_HapticUpdateEffect'.'SDL2.dll'.'SDL_HapticUpdateEffect'
+++'_SDL_HapticRunEffect'.'SDL2.dll'.'SDL_HapticRunEffect'
+++'_SDL_HapticStopEffect'.'SDL2.dll'.'SDL_HapticStopEffect'
+++'_SDL_HapticDestroyEffect'.'SDL2.dll'.'SDL_HapticDestroyEffect'
+++'_SDL_HapticGetEffectStatus'.'SDL2.dll'.'SDL_HapticGetEffectStatus'
+++'_SDL_HapticSetGain'.'SDL2.dll'.'SDL_HapticSetGain'
+++'_SDL_HapticSetAutocenter'.'SDL2.dll'.'SDL_HapticSetAutocenter'
+++'_SDL_HapticPause'.'SDL2.dll'.'SDL_HapticPause'
+++'_SDL_HapticUnpause'.'SDL2.dll'.'SDL_HapticUnpause'
+++'_SDL_HapticStopAll'.'SDL2.dll'.'SDL_HapticStopAll'
+++'_SDL_HapticRumbleSupported'.'SDL2.dll'.'SDL_HapticRumbleSupported'
+++'_SDL_HapticRumbleInit'.'SDL2.dll'.'SDL_HapticRumbleInit'
+++'_SDL_HapticRumblePlay'.'SDL2.dll'.'SDL_HapticRumblePlay'
+++'_SDL_HapticRumbleStop'.'SDL2.dll'.'SDL_HapticRumbleStop'
+++'_SDL_SetHintWithPriority'.'SDL2.dll'.'SDL_SetHintWithPriority'
+++'_SDL_SetHint'.'SDL2.dll'.'SDL_SetHint'
+++'_SDL_GetHint'.'SDL2.dll'.'SDL_GetHint'
+++'_SDL_AddHintCallback'.'SDL2.dll'.'SDL_AddHintCallback'
+++'_SDL_DelHintCallback'.'SDL2.dll'.'SDL_DelHintCallback'
+++'_SDL_ClearHints'.'SDL2.dll'.'SDL_ClearHints'
+++'_SDL_NumJoysticks'.'SDL2.dll'.'SDL_NumJoysticks'
+++'_SDL_JoystickNameForIndex'.'SDL2.dll'.'SDL_JoystickNameForIndex'
+++'_SDL_JoystickOpen'.'SDL2.dll'.'SDL_JoystickOpen'
+++'_SDL_JoystickName'.'SDL2.dll'.'SDL_JoystickName'
+++'_SDL_JoystickGetDeviceGUID'.'SDL2.dll'.'SDL_JoystickGetDeviceGUID'
+++'_SDL_JoystickGetGUID'.'SDL2.dll'.'SDL_JoystickGetGUID'
+++'_SDL_JoystickGetGUIDString'.'SDL2.dll'.'SDL_JoystickGetGUIDString'
+++'_SDL_JoystickGetGUIDFromString'.'SDL2.dll'.'SDL_JoystickGetGUIDFromString'
+++'_SDL_JoystickGetAttached'.'SDL2.dll'.'SDL_JoystickGetAttached'
+++'_SDL_JoystickInstanceID'.'SDL2.dll'.'SDL_JoystickInstanceID'
+++'_SDL_JoystickNumAxes'.'SDL2.dll'.'SDL_JoystickNumAxes'
+++'_SDL_JoystickNumBalls'.'SDL2.dll'.'SDL_JoystickNumBalls'
+++'_SDL_JoystickNumHats'.'SDL2.dll'.'SDL_JoystickNumHats'
+++'_SDL_JoystickNumButtons'.'SDL2.dll'.'SDL_JoystickNumButtons'
+++'_SDL_JoystickUpdate'.'SDL2.dll'.'SDL_JoystickUpdate'
+++'_SDL_JoystickEventState'.'SDL2.dll'.'SDL_JoystickEventState'
+++'_SDL_JoystickGetAxis'.'SDL2.dll'.'SDL_JoystickGetAxis'
+++'_SDL_JoystickGetHat'.'SDL2.dll'.'SDL_JoystickGetHat'
+++'_SDL_JoystickGetBall'.'SDL2.dll'.'SDL_JoystickGetBall'
+++'_SDL_JoystickGetButton'.'SDL2.dll'.'SDL_JoystickGetButton'
+++'_SDL_JoystickClose'.'SDL2.dll'.'SDL_JoystickClose'
+++'_SDL_GetKeyboardFocus'.'SDL2.dll'.'SDL_GetKeyboardFocus'
+++'_SDL_GetKeyboardState'.'SDL2.dll'.'SDL_GetKeyboardState'
+++'_SDL_GetModState'.'SDL2.dll'.'SDL_GetModState'
+++'_SDL_SetModState'.'SDL2.dll'.'SDL_SetModState'
+++'_SDL_GetKeyFromScancode'.'SDL2.dll'.'SDL_GetKeyFromScancode'
+++'_SDL_GetScancodeFromKey'.'SDL2.dll'.'SDL_GetScancodeFromKey'
+++'_SDL_GetScancodeName'.'SDL2.dll'.'SDL_GetScancodeName'
+++'_SDL_GetScancodeFromName'.'SDL2.dll'.'SDL_GetScancodeFromName'
+++'_SDL_GetKeyName'.'SDL2.dll'.'SDL_GetKeyName'
+++'_SDL_GetKeyFromName'.'SDL2.dll'.'SDL_GetKeyFromName'
+++'_SDL_StartTextInput'.'SDL2.dll'.'SDL_StartTextInput'
+++'_SDL_IsTextInputActive'.'SDL2.dll'.'SDL_IsTextInputActive'
+++'_SDL_StopTextInput'.'SDL2.dll'.'SDL_StopTextInput'
+++'_SDL_SetTextInputRect'.'SDL2.dll'.'SDL_SetTextInputRect'
+++'_SDL_HasScreenKeyboardSupport'.'SDL2.dll'.'SDL_HasScreenKeyboardSupport'
+++'_SDL_IsScreenKeyboardShown'.'SDL2.dll'.'SDL_IsScreenKeyboardShown'
+++'_SDL_LoadObject'.'SDL2.dll'.'SDL_LoadObject'
+++'_SDL_LoadFunction'.'SDL2.dll'.'SDL_LoadFunction'
+++'_SDL_UnloadObject'.'SDL2.dll'.'SDL_UnloadObject'
+++'_SDL_LogSetAllPriority'.'SDL2.dll'.'SDL_LogSetAllPriority'
+++'_SDL_LogSetPriority'.'SDL2.dll'.'SDL_LogSetPriority'
+++'_SDL_LogGetPriority'.'SDL2.dll'.'SDL_LogGetPriority'
+++'_SDL_LogResetPriorities'.'SDL2.dll'.'SDL_LogResetPriorities'
+++'_SDL_LogMessageV'.'SDL2.dll'.'SDL_LogMessageV'
+++'_SDL_LogGetOutputFunction'.'SDL2.dll'.'SDL_LogGetOutputFunction'
+++'_SDL_LogSetOutputFunction'.'SDL2.dll'.'SDL_LogSetOutputFunction'
+++'_SDL_SetMainReady'.'SDL2.dll'.'SDL_SetMainReady'
+++'_SDL_ShowMessageBox'.'SDL2.dll'.'SDL_ShowMessageBox'
+++'_SDL_ShowSimpleMessageBox'.'SDL2.dll'.'SDL_ShowSimpleMessageBox'
+++'_SDL_GetMouseFocus'.'SDL2.dll'.'SDL_GetMouseFocus'
+++'_SDL_GetMouseState'.'SDL2.dll'.'SDL_GetMouseState'
+++'_SDL_GetRelativeMouseState'.'SDL2.dll'.'SDL_GetRelativeMouseState'
+++'_SDL_WarpMouseInWindow'.'SDL2.dll'.'SDL_WarpMouseInWindow'
+++'_SDL_SetRelativeMouseMode'.'SDL2.dll'.'SDL_SetRelativeMouseMode'
+++'_SDL_GetRelativeMouseMode'.'SDL2.dll'.'SDL_GetRelativeMouseMode'
+++'_SDL_CreateCursor'.'SDL2.dll'.'SDL_CreateCursor'
+++'_SDL_CreateColorCursor'.'SDL2.dll'.'SDL_CreateColorCursor'
+++'_SDL_CreateSystemCursor'.'SDL2.dll'.'SDL_CreateSystemCursor'
+++'_SDL_SetCursor'.'SDL2.dll'.'SDL_SetCursor'
+++'_SDL_GetCursor'.'SDL2.dll'.'SDL_GetCursor'
+++'_SDL_GetDefaultCursor'.'SDL2.dll'.'SDL_GetDefaultCursor'
+++'_SDL_FreeCursor'.'SDL2.dll'.'SDL_FreeCursor'
+++'_SDL_ShowCursor'.'SDL2.dll'.'SDL_ShowCursor'
+++'_SDL_CreateMutex'.'SDL2.dll'.'SDL_CreateMutex'
+++'_SDL_LockMutex'.'SDL2.dll'.'SDL_LockMutex'
+++'_SDL_TryLockMutex'.'SDL2.dll'.'SDL_TryLockMutex'
+++'_SDL_UnlockMutex'.'SDL2.dll'.'SDL_UnlockMutex'
+++'_SDL_DestroyMutex'.'SDL2.dll'.'SDL_DestroyMutex'
+++'_SDL_CreateSemaphore'.'SDL2.dll'.'SDL_CreateSemaphore'
+++'_SDL_DestroySemaphore'.'SDL2.dll'.'SDL_DestroySemaphore'
+++'_SDL_SemWait'.'SDL2.dll'.'SDL_SemWait'
+++'_SDL_SemTryWait'.'SDL2.dll'.'SDL_SemTryWait'
+++'_SDL_SemWaitTimeout'.'SDL2.dll'.'SDL_SemWaitTimeout'
+++'_SDL_SemPost'.'SDL2.dll'.'SDL_SemPost'
+++'_SDL_SemValue'.'SDL2.dll'.'SDL_SemValue'
+++'_SDL_CreateCond'.'SDL2.dll'.'SDL_CreateCond'
+++'_SDL_DestroyCond'.'SDL2.dll'.'SDL_DestroyCond'
+++'_SDL_CondSignal'.'SDL2.dll'.'SDL_CondSignal'
+++'_SDL_CondBroadcast'.'SDL2.dll'.'SDL_CondBroadcast'
+++'_SDL_CondWait'.'SDL2.dll'.'SDL_CondWait'
+++'_SDL_CondWaitTimeout'.'SDL2.dll'.'SDL_CondWaitTimeout'
+++'_SDL_GetPixelFormatName'.'SDL2.dll'.'SDL_GetPixelFormatName'
+++'_SDL_PixelFormatEnumToMasks'.'SDL2.dll'.'SDL_PixelFormatEnumToMasks'
+++'_SDL_MasksToPixelFormatEnum'.'SDL2.dll'.'SDL_MasksToPixelFormatEnum'
+++'_SDL_AllocFormat'.'SDL2.dll'.'SDL_AllocFormat'
+++'_SDL_FreeFormat'.'SDL2.dll'.'SDL_FreeFormat'
+++'_SDL_AllocPalette'.'SDL2.dll'.'SDL_AllocPalette'
+++'_SDL_SetPixelFormatPalette'.'SDL2.dll'.'SDL_SetPixelFormatPalette'
+++'_SDL_SetPaletteColors'.'SDL2.dll'.'SDL_SetPaletteColors'
+++'_SDL_FreePalette'.'SDL2.dll'.'SDL_FreePalette'
+++'_SDL_MapRGB'.'SDL2.dll'.'SDL_MapRGB'
+++'_SDL_MapRGBA'.'SDL2.dll'.'SDL_MapRGBA'
+++'_SDL_GetRGB'.'SDL2.dll'.'SDL_GetRGB'
+++'_SDL_GetRGBA'.'SDL2.dll'.'SDL_GetRGBA'
+++'_SDL_CalculateGammaRamp'.'SDL2.dll'.'SDL_CalculateGammaRamp'
+++'_SDL_GetPlatform'.'SDL2.dll'.'SDL_GetPlatform'
+++'_SDL_GetPowerInfo'.'SDL2.dll'.'SDL_GetPowerInfo'
+++'_SDL_HasIntersection'.'SDL2.dll'.'SDL_HasIntersection'
+++'_SDL_IntersectRect'.'SDL2.dll'.'SDL_IntersectRect'
+++'_SDL_UnionRect'.'SDL2.dll'.'SDL_UnionRect'
+++'_SDL_EnclosePoints'.'SDL2.dll'.'SDL_EnclosePoints'
+++'_SDL_IntersectRectAndLine'.'SDL2.dll'.'SDL_IntersectRectAndLine'
+++'_SDL_GetNumRenderDrivers'.'SDL2.dll'.'SDL_GetNumRenderDrivers'
+++'_SDL_GetRenderDriverInfo'.'SDL2.dll'.'SDL_GetRenderDriverInfo'
+++'_SDL_CreateWindowAndRenderer'.'SDL2.dll'.'SDL_CreateWindowAndRenderer'
+++'_SDL_CreateRenderer'.'SDL2.dll'.'SDL_CreateRenderer'
+++'_SDL_CreateSoftwareRenderer'.'SDL2.dll'.'SDL_CreateSoftwareRenderer'
+++'_SDL_GetRenderer'.'SDL2.dll'.'SDL_GetRenderer'
+++'_SDL_GetRendererInfo'.'SDL2.dll'.'SDL_GetRendererInfo'
+++'_SDL_GetRendererOutputSize'.'SDL2.dll'.'SDL_GetRendererOutputSize'
+++'_SDL_CreateTexture'.'SDL2.dll'.'SDL_CreateTexture'
+++'_SDL_CreateTextureFromSurface'.'SDL2.dll'.'SDL_CreateTextureFromSurface'
+++'_SDL_QueryTexture'.'SDL2.dll'.'SDL_QueryTexture'
+++'_SDL_SetTextureColorMod'.'SDL2.dll'.'SDL_SetTextureColorMod'
+++'_SDL_GetTextureColorMod'.'SDL2.dll'.'SDL_GetTextureColorMod'
+++'_SDL_SetTextureAlphaMod'.'SDL2.dll'.'SDL_SetTextureAlphaMod'
+++'_SDL_GetTextureAlphaMod'.'SDL2.dll'.'SDL_GetTextureAlphaMod'
+++'_SDL_SetTextureBlendMode'.'SDL2.dll'.'SDL_SetTextureBlendMode'
+++'_SDL_GetTextureBlendMode'.'SDL2.dll'.'SDL_GetTextureBlendMode'
+++'_SDL_UpdateTexture'.'SDL2.dll'.'SDL_UpdateTexture'
+++'_SDL_UpdateYUVTexture'.'SDL2.dll'.'SDL_UpdateYUVTexture'
+++'_SDL_LockTexture'.'SDL2.dll'.'SDL_LockTexture'
+++'_SDL_UnlockTexture'.'SDL2.dll'.'SDL_UnlockTexture'
+++'_SDL_RenderTargetSupported'.'SDL2.dll'.'SDL_RenderTargetSupported'
+++'_SDL_SetRenderTarget'.'SDL2.dll'.'SDL_SetRenderTarget'
+++'_SDL_GetRenderTarget'.'SDL2.dll'.'SDL_GetRenderTarget'
+++'_SDL_RenderSetLogicalSize'.'SDL2.dll'.'SDL_RenderSetLogicalSize'
+++'_SDL_RenderGetLogicalSize'.'SDL2.dll'.'SDL_RenderGetLogicalSize'
+++'_SDL_RenderSetViewport'.'SDL2.dll'.'SDL_RenderSetViewport'
+++'_SDL_RenderGetViewport'.'SDL2.dll'.'SDL_RenderGetViewport'
+++'_SDL_RenderSetClipRect'.'SDL2.dll'.'SDL_RenderSetClipRect'
+++'_SDL_RenderGetClipRect'.'SDL2.dll'.'SDL_RenderGetClipRect'
+++'_SDL_RenderSetScale'.'SDL2.dll'.'SDL_RenderSetScale'
+++'_SDL_RenderGetScale'.'SDL2.dll'.'SDL_RenderGetScale'
+++'_SDL_SetRenderDrawColor'.'SDL2.dll'.'SDL_SetRenderDrawColor'
+++'_SDL_GetRenderDrawColor'.'SDL2.dll'.'SDL_GetRenderDrawColor'
+++'_SDL_SetRenderDrawBlendMode'.'SDL2.dll'.'SDL_SetRenderDrawBlendMode'
+++'_SDL_GetRenderDrawBlendMode'.'SDL2.dll'.'SDL_GetRenderDrawBlendMode'
+++'_SDL_RenderClear'.'SDL2.dll'.'SDL_RenderClear'
+++'_SDL_RenderDrawPoint'.'SDL2.dll'.'SDL_RenderDrawPoint'
+++'_SDL_RenderDrawPoints'.'SDL2.dll'.'SDL_RenderDrawPoints'
+++'_SDL_RenderDrawLine'.'SDL2.dll'.'SDL_RenderDrawLine'
+++'_SDL_RenderDrawLines'.'SDL2.dll'.'SDL_RenderDrawLines'
+++'_SDL_RenderDrawRect'.'SDL2.dll'.'SDL_RenderDrawRect'
+++'_SDL_RenderDrawRects'.'SDL2.dll'.'SDL_RenderDrawRects'
+++'_SDL_RenderFillRect'.'SDL2.dll'.'SDL_RenderFillRect'
+++'_SDL_RenderFillRects'.'SDL2.dll'.'SDL_RenderFillRects'
+++'_SDL_RenderCopy'.'SDL2.dll'.'SDL_RenderCopy'
+++'_SDL_RenderCopyEx'.'SDL2.dll'.'SDL_RenderCopyEx'
+++'_SDL_RenderReadPixels'.'SDL2.dll'.'SDL_RenderReadPixels'
+++'_SDL_RenderPresent'.'SDL2.dll'.'SDL_RenderPresent'
+++'_SDL_DestroyTexture'.'SDL2.dll'.'SDL_DestroyTexture'
+++'_SDL_DestroyRenderer'.'SDL2.dll'.'SDL_DestroyRenderer'
+++'_SDL_GL_BindTexture'.'SDL2.dll'.'SDL_GL_BindTexture'
+++'_SDL_GL_UnbindTexture'.'SDL2.dll'.'SDL_GL_UnbindTexture'
+++'_SDL_RWFromFile'.'SDL2.dll'.'SDL_RWFromFile'
+++'_SDL_RWFromMem'.'SDL2.dll'.'SDL_RWFromMem'
+++'_SDL_RWFromConstMem'.'SDL2.dll'.'SDL_RWFromConstMem'
+++'_SDL_AllocRW'.'SDL2.dll'.'SDL_AllocRW'
+++'_SDL_FreeRW'.'SDL2.dll'.'SDL_FreeRW'
+++'_SDL_ReadU8'.'SDL2.dll'.'SDL_ReadU8'
+++'_SDL_ReadLE16'.'SDL2.dll'.'SDL_ReadLE16'
+++'_SDL_ReadBE16'.'SDL2.dll'.'SDL_ReadBE16'
+++'_SDL_ReadLE32'.'SDL2.dll'.'SDL_ReadLE32'
+++'_SDL_ReadBE32'.'SDL2.dll'.'SDL_ReadBE32'
+++'_SDL_ReadLE64'.'SDL2.dll'.'SDL_ReadLE64'
+++'_SDL_ReadBE64'.'SDL2.dll'.'SDL_ReadBE64'
+++'_SDL_WriteU8'.'SDL2.dll'.'SDL_WriteU8'
+++'_SDL_WriteLE16'.'SDL2.dll'.'SDL_WriteLE16'
+++'_SDL_WriteBE16'.'SDL2.dll'.'SDL_WriteBE16'
+++'_SDL_WriteLE32'.'SDL2.dll'.'SDL_WriteLE32'
+++'_SDL_WriteBE32'.'SDL2.dll'.'SDL_WriteBE32'
+++'_SDL_WriteLE64'.'SDL2.dll'.'SDL_WriteLE64'
+++'_SDL_WriteBE64'.'SDL2.dll'.'SDL_WriteBE64'
+++'_SDL_CreateShapedWindow'.'SDL2.dll'.'SDL_CreateShapedWindow'
+++'_SDL_IsShapedWindow'.'SDL2.dll'.'SDL_IsShapedWindow'
+++'_SDL_SetWindowShape'.'SDL2.dll'.'SDL_SetWindowShape'
+++'_SDL_GetShapedWindowMode'.'SDL2.dll'.'SDL_GetShapedWindowMode'
+++'_SDL_malloc'.'SDL2.dll'.'SDL_malloc'
+++'_SDL_calloc'.'SDL2.dll'.'SDL_calloc'
+++'_SDL_realloc'.'SDL2.dll'.'SDL_realloc'
+++'_SDL_free'.'SDL2.dll'.'SDL_free'
+++'_SDL_getenv'.'SDL2.dll'.'SDL_getenv'
+++'_SDL_setenv'.'SDL2.dll'.'SDL_setenv'
+++'_SDL_qsort'.'SDL2.dll'.'SDL_qsort'
+++'_SDL_abs'.'SDL2.dll'.'SDL_abs'
+++'_SDL_isdigit'.'SDL2.dll'.'SDL_isdigit'
+++'_SDL_isspace'.'SDL2.dll'.'SDL_isspace'
+++'_SDL_toupper'.'SDL2.dll'.'SDL_toupper'
+++'_SDL_tolower'.'SDL2.dll'.'SDL_tolower'
+++'_SDL_memset'.'SDL2.dll'.'SDL_memset'
+++'_SDL_memcpy'.'SDL2.dll'.'SDL_memcpy'
+++'_SDL_memmove'.'SDL2.dll'.'SDL_memmove'
+++'_SDL_memcmp'.'SDL2.dll'.'SDL_memcmp'
+++'_SDL_wcslen'.'SDL2.dll'.'SDL_wcslen'
+++'_SDL_wcslcpy'.'SDL2.dll'.'SDL_wcslcpy'
+++'_SDL_wcslcat'.'SDL2.dll'.'SDL_wcslcat'
+++'_SDL_strlen'.'SDL2.dll'.'SDL_strlen'
+++'_SDL_strlcpy'.'SDL2.dll'.'SDL_strlcpy'
+++'_SDL_utf8strlcpy'.'SDL2.dll'.'SDL_utf8strlcpy'
+++'_SDL_strlcat'.'SDL2.dll'.'SDL_strlcat'
+++'_SDL_strdup'.'SDL2.dll'.'SDL_strdup'
+++'_SDL_strrev'.'SDL2.dll'.'SDL_strrev'
+++'_SDL_strupr'.'SDL2.dll'.'SDL_strupr'
+++'_SDL_strlwr'.'SDL2.dll'.'SDL_strlwr'
+++'_SDL_strchr'.'SDL2.dll'.'SDL_strchr'
+++'_SDL_strrchr'.'SDL2.dll'.'SDL_strrchr'
+++'_SDL_strstr'.'SDL2.dll'.'SDL_strstr'
+++'_SDL_itoa'.'SDL2.dll'.'SDL_itoa'
+++'_SDL_uitoa'.'SDL2.dll'.'SDL_uitoa'
+++'_SDL_ltoa'.'SDL2.dll'.'SDL_ltoa'
+++'_SDL_ultoa'.'SDL2.dll'.'SDL_ultoa'
+++'_SDL_lltoa'.'SDL2.dll'.'SDL_lltoa'
+++'_SDL_ulltoa'.'SDL2.dll'.'SDL_ulltoa'
+++'_SDL_atoi'.'SDL2.dll'.'SDL_atoi'
+++'_SDL_atof'.'SDL2.dll'.'SDL_atof'
+++'_SDL_strtol'.'SDL2.dll'.'SDL_strtol'
+++'_SDL_strtoul'.'SDL2.dll'.'SDL_strtoul'
+++'_SDL_strtoll'.'SDL2.dll'.'SDL_strtoll'
+++'_SDL_strtoull'.'SDL2.dll'.'SDL_strtoull'
+++'_SDL_strtod'.'SDL2.dll'.'SDL_strtod'
+++'_SDL_strcmp'.'SDL2.dll'.'SDL_strcmp'
+++'_SDL_strncmp'.'SDL2.dll'.'SDL_strncmp'
+++'_SDL_strcasecmp'.'SDL2.dll'.'SDL_strcasecmp'
+++'_SDL_strncasecmp'.'SDL2.dll'.'SDL_strncasecmp'
+++'_SDL_vsnprintf'.'SDL2.dll'.'SDL_vsnprintf'
+++'_SDL_acos'.'SDL2.dll'.'SDL_acos'
+++'_SDL_asin'.'SDL2.dll'.'SDL_asin'
+++'_SDL_atan'.'SDL2.dll'.'SDL_atan'
+++'_SDL_atan2'.'SDL2.dll'.'SDL_atan2'
+++'_SDL_ceil'.'SDL2.dll'.'SDL_ceil'
+++'_SDL_copysign'.'SDL2.dll'.'SDL_copysign'
+++'_SDL_cos'.'SDL2.dll'.'SDL_cos'
+++'_SDL_cosf'.'SDL2.dll'.'SDL_cosf'
+++'_SDL_fabs'.'SDL2.dll'.'SDL_fabs'
+++'_SDL_floor'.'SDL2.dll'.'SDL_floor'
+++'_SDL_log'.'SDL2.dll'.'SDL_log'
+++'_SDL_pow'.'SDL2.dll'.'SDL_pow'
+++'_SDL_scalbn'.'SDL2.dll'.'SDL_scalbn'
+++'_SDL_sin'.'SDL2.dll'.'SDL_sin'
+++'_SDL_sinf'.'SDL2.dll'.'SDL_sinf'
+++'_SDL_sqrt'.'SDL2.dll'.'SDL_sqrt'
+++'_SDL_iconv_open'.'SDL2.dll'.'SDL_iconv_open'
+++'_SDL_iconv_close'.'SDL2.dll'.'SDL_iconv_close'
+++'_SDL_iconv'.'SDL2.dll'.'SDL_iconv'
+++'_SDL_iconv_string'.'SDL2.dll'.'SDL_iconv_string'
+++'_SDL_CreateRGBSurface'.'SDL2.dll'.'SDL_CreateRGBSurface'
+++'_SDL_CreateRGBSurfaceFrom'.'SDL2.dll'.'SDL_CreateRGBSurfaceFrom'
+++'_SDL_FreeSurface'.'SDL2.dll'.'SDL_FreeSurface'
+++'_SDL_SetSurfacePalette'.'SDL2.dll'.'SDL_SetSurfacePalette'
+++'_SDL_LockSurface'.'SDL2.dll'.'SDL_LockSurface'
+++'_SDL_UnlockSurface'.'SDL2.dll'.'SDL_UnlockSurface'
+++'_SDL_LoadBMP_RW'.'SDL2.dll'.'SDL_LoadBMP_RW'
+++'_SDL_SaveBMP_RW'.'SDL2.dll'.'SDL_SaveBMP_RW'
+++'_SDL_SetSurfaceRLE'.'SDL2.dll'.'SDL_SetSurfaceRLE'
+++'_SDL_SetColorKey'.'SDL2.dll'.'SDL_SetColorKey'
+++'_SDL_GetColorKey'.'SDL2.dll'.'SDL_GetColorKey'
+++'_SDL_SetSurfaceColorMod'.'SDL2.dll'.'SDL_SetSurfaceColorMod'
+++'_SDL_GetSurfaceColorMod'.'SDL2.dll'.'SDL_GetSurfaceColorMod'
+++'_SDL_SetSurfaceAlphaMod'.'SDL2.dll'.'SDL_SetSurfaceAlphaMod'
+++'_SDL_GetSurfaceAlphaMod'.'SDL2.dll'.'SDL_GetSurfaceAlphaMod'
+++'_SDL_SetSurfaceBlendMode'.'SDL2.dll'.'SDL_SetSurfaceBlendMode'
+++'_SDL_GetSurfaceBlendMode'.'SDL2.dll'.'SDL_GetSurfaceBlendMode'
+++'_SDL_SetClipRect'.'SDL2.dll'.'SDL_SetClipRect'
+++'_SDL_GetClipRect'.'SDL2.dll'.'SDL_GetClipRect'
+++'_SDL_ConvertSurface'.'SDL2.dll'.'SDL_ConvertSurface'
+++'_SDL_ConvertSurfaceFormat'.'SDL2.dll'.'SDL_ConvertSurfaceFormat'
+++'_SDL_ConvertPixels'.'SDL2.dll'.'SDL_ConvertPixels'
+++'_SDL_FillRect'.'SDL2.dll'.'SDL_FillRect'
+++'_SDL_FillRects'.'SDL2.dll'.'SDL_FillRects'
+++'_SDL_UpperBlit'.'SDL2.dll'.'SDL_UpperBlit'
+++'_SDL_LowerBlit'.'SDL2.dll'.'SDL_LowerBlit'
+++'_SDL_SoftStretch'.'SDL2.dll'.'SDL_SoftStretch'
+++'_SDL_UpperBlitScaled'.'SDL2.dll'.'SDL_UpperBlitScaled'
+++'_SDL_LowerBlitScaled'.'SDL2.dll'.'SDL_LowerBlitScaled'
+++'_SDL_GetWindowWMInfo'.'SDL2.dll'.'SDL_GetWindowWMInfo'
+++'_SDL_GetThreadName'.'SDL2.dll'.'SDL_GetThreadName'
+++'_SDL_ThreadID'.'SDL2.dll'.'SDL_ThreadID'
+++'_SDL_GetThreadID'.'SDL2.dll'.'SDL_GetThreadID'
+++'_SDL_SetThreadPriority'.'SDL2.dll'.'SDL_SetThreadPriority'
+++'_SDL_WaitThread'.'SDL2.dll'.'SDL_WaitThread'
+++'_SDL_DetachThread'.'SDL2.dll'.'SDL_DetachThread'
+++'_SDL_TLSCreate'.'SDL2.dll'.'SDL_TLSCreate'
+++'_SDL_TLSGet'.'SDL2.dll'.'SDL_TLSGet'
+++'_SDL_TLSSet'.'SDL2.dll'.'SDL_TLSSet'
+++'_SDL_GetTicks'.'SDL2.dll'.'SDL_GetTicks'
+++'_SDL_GetPerformanceCounter'.'SDL2.dll'.'SDL_GetPerformanceCounter'
+++'_SDL_GetPerformanceFrequency'.'SDL2.dll'.'SDL_GetPerformanceFrequency'
+++'_SDL_Delay'.'SDL2.dll'.'SDL_Delay'
+++'_SDL_AddTimer'.'SDL2.dll'.'SDL_AddTimer'
+++'_SDL_RemoveTimer'.'SDL2.dll'.'SDL_RemoveTimer'
+++'_SDL_GetNumTouchDevices'.'SDL2.dll'.'SDL_GetNumTouchDevices'
+++'_SDL_GetTouchDevice'.'SDL2.dll'.'SDL_GetTouchDevice'
+++'_SDL_GetNumTouchFingers'.'SDL2.dll'.'SDL_GetNumTouchFingers'
+++'_SDL_GetTouchFinger'.'SDL2.dll'.'SDL_GetTouchFinger'
+++'_SDL_GetVersion'.'SDL2.dll'.'SDL_GetVersion'
+++'_SDL_GetRevision'.'SDL2.dll'.'SDL_GetRevision'
+++'_SDL_GetRevisionNumber'.'SDL2.dll'.'SDL_GetRevisionNumber'
+++'_SDL_GetNumVideoDrivers'.'SDL2.dll'.'SDL_GetNumVideoDrivers'
+++'_SDL_GetVideoDriver'.'SDL2.dll'.'SDL_GetVideoDriver'
+++'_SDL_VideoInit'.'SDL2.dll'.'SDL_VideoInit'
+++'_SDL_VideoQuit'.'SDL2.dll'.'SDL_VideoQuit'
+++'_SDL_GetCurrentVideoDriver'.'SDL2.dll'.'SDL_GetCurrentVideoDriver'
+++'_SDL_GetNumVideoDisplays'.'SDL2.dll'.'SDL_GetNumVideoDisplays'
+++'_SDL_GetDisplayName'.'SDL2.dll'.'SDL_GetDisplayName'
+++'_SDL_GetDisplayBounds'.'SDL2.dll'.'SDL_GetDisplayBounds'
+++'_SDL_GetDisplayDPI'.'SDL2.dll'.'SDL_GetDisplayDPI'
+++'_SDL_GetNumDisplayModes'.'SDL2.dll'.'SDL_GetNumDisplayModes'
+++'_SDL_GetDisplayMode'.'SDL2.dll'.'SDL_GetDisplayMode'
+++'_SDL_GetDesktopDisplayMode'.'SDL2.dll'.'SDL_GetDesktopDisplayMode'
+++'_SDL_GetCurrentDisplayMode'.'SDL2.dll'.'SDL_GetCurrentDisplayMode'
+++'_SDL_GetClosestDisplayMode'.'SDL2.dll'.'SDL_GetClosestDisplayMode'
+++'_SDL_GetWindowDisplayIndex'.'SDL2.dll'.'SDL_GetWindowDisplayIndex'
+++'_SDL_SetWindowDisplayMode'.'SDL2.dll'.'SDL_SetWindowDisplayMode'
+++'_SDL_GetWindowDisplayMode'.'SDL2.dll'.'SDL_GetWindowDisplayMode'
+++'_SDL_GetWindowPixelFormat'.'SDL2.dll'.'SDL_GetWindowPixelFormat'
+++'_SDL_CreateWindow'.'SDL2.dll'.'SDL_CreateWindow'
+++'_SDL_CreateWindowFrom'.'SDL2.dll'.'SDL_CreateWindowFrom'
+++'_SDL_GetWindowID'.'SDL2.dll'.'SDL_GetWindowID'
+++'_SDL_GetWindowFromID'.'SDL2.dll'.'SDL_GetWindowFromID'
+++'_SDL_GetWindowFlags'.'SDL2.dll'.'SDL_GetWindowFlags'
+++'_SDL_SetWindowTitle'.'SDL2.dll'.'SDL_SetWindowTitle'
+++'_SDL_GetWindowTitle'.'SDL2.dll'.'SDL_GetWindowTitle'
+++'_SDL_SetWindowIcon'.'SDL2.dll'.'SDL_SetWindowIcon'
+++'_SDL_SetWindowData'.'SDL2.dll'.'SDL_SetWindowData'
+++'_SDL_GetWindowData'.'SDL2.dll'.'SDL_GetWindowData'
+++'_SDL_SetWindowPosition'.'SDL2.dll'.'SDL_SetWindowPosition'
+++'_SDL_GetWindowPosition'.'SDL2.dll'.'SDL_GetWindowPosition'
+++'_SDL_SetWindowSize'.'SDL2.dll'.'SDL_SetWindowSize'
+++'_SDL_GetWindowSize'.'SDL2.dll'.'SDL_GetWindowSize'
+++'_SDL_SetWindowMinimumSize'.'SDL2.dll'.'SDL_SetWindowMinimumSize'
+++'_SDL_GetWindowMinimumSize'.'SDL2.dll'.'SDL_GetWindowMinimumSize'
+++'_SDL_SetWindowMaximumSize'.'SDL2.dll'.'SDL_SetWindowMaximumSize'
+++'_SDL_GetWindowMaximumSize'.'SDL2.dll'.'SDL_GetWindowMaximumSize'
+++'_SDL_SetWindowBordered'.'SDL2.dll'.'SDL_SetWindowBordered'
+++'_SDL_ShowWindow'.'SDL2.dll'.'SDL_ShowWindow'
+++'_SDL_HideWindow'.'SDL2.dll'.'SDL_HideWindow'
+++'_SDL_RaiseWindow'.'SDL2.dll'.'SDL_RaiseWindow'
+++'_SDL_MaximizeWindow'.'SDL2.dll'.'SDL_MaximizeWindow'
+++'_SDL_MinimizeWindow'.'SDL2.dll'.'SDL_MinimizeWindow'
+++'_SDL_RestoreWindow'.'SDL2.dll'.'SDL_RestoreWindow'
+++'_SDL_SetWindowFullscreen'.'SDL2.dll'.'SDL_SetWindowFullscreen'
+++'_SDL_GetWindowSurface'.'SDL2.dll'.'SDL_GetWindowSurface'
+++'_SDL_UpdateWindowSurface'.'SDL2.dll'.'SDL_UpdateWindowSurface'
+++'_SDL_UpdateWindowSurfaceRects'.'SDL2.dll'.'SDL_UpdateWindowSurfaceRects'
+++'_SDL_SetWindowGrab'.'SDL2.dll'.'SDL_SetWindowGrab'
+++'_SDL_GetWindowGrab'.'SDL2.dll'.'SDL_GetWindowGrab'
+++'_SDL_SetWindowBrightness'.'SDL2.dll'.'SDL_SetWindowBrightness'
+++'_SDL_GetWindowBrightness'.'SDL2.dll'.'SDL_GetWindowBrightness'
+++'_SDL_SetWindowGammaRamp'.'SDL2.dll'.'SDL_SetWindowGammaRamp'
+++'_SDL_GetWindowGammaRamp'.'SDL2.dll'.'SDL_GetWindowGammaRamp'
+++'_SDL_DestroyWindow'.'SDL2.dll'.'SDL_DestroyWindow'
+++'_SDL_IsScreenSaverEnabled'.'SDL2.dll'.'SDL_IsScreenSaverEnabled'
+++'_SDL_EnableScreenSaver'.'SDL2.dll'.'SDL_EnableScreenSaver'
+++'_SDL_DisableScreenSaver'.'SDL2.dll'.'SDL_DisableScreenSaver'
+++'_SDL_GL_LoadLibrary'.'SDL2.dll'.'SDL_GL_LoadLibrary'
+++'_SDL_GL_GetProcAddress'.'SDL2.dll'.'SDL_GL_GetProcAddress'
+++'_SDL_GL_UnloadLibrary'.'SDL2.dll'.'SDL_GL_UnloadLibrary'
+++'_SDL_GL_ExtensionSupported'.'SDL2.dll'.'SDL_GL_ExtensionSupported'
+++'_SDL_GL_SetAttribute'.'SDL2.dll'.'SDL_GL_SetAttribute'
+++'_SDL_GL_GetAttribute'.'SDL2.dll'.'SDL_GL_GetAttribute'
+++'_SDL_GL_CreateContext'.'SDL2.dll'.'SDL_GL_CreateContext'
+++'_SDL_GL_MakeCurrent'.'SDL2.dll'.'SDL_GL_MakeCurrent'
+++'_SDL_GL_GetCurrentWindow'.'SDL2.dll'.'SDL_GL_GetCurrentWindow'
+++'_SDL_GL_GetCurrentContext'.'SDL2.dll'.'SDL_GL_GetCurrentContext'
+++'_SDL_GL_GetDrawableSize'.'SDL2.dll'.'SDL_GL_GetDrawableSize'
+++'_SDL_GL_SetSwapInterval'.'SDL2.dll'.'SDL_GL_SetSwapInterval'
+++'_SDL_GL_GetSwapInterval'.'SDL2.dll'.'SDL_GL_GetSwapInterval'
+++'_SDL_GL_SwapWindow'.'SDL2.dll'.'SDL_GL_SwapWindow'
+++'_SDL_GL_DeleteContext'.'SDL2.dll'.'SDL_GL_DeleteContext'
+++'_SDL_vsscanf'.'SDL2.dll'.'SDL_vsscanf'
+++'_SDL_GameControllerAddMappingsFromRW'.'SDL2.dll'.'SDL_GameControllerAddMappingsFromRW'
+++'_SDL_GL_ResetAttributes'.'SDL2.dll'.'SDL_GL_ResetAttributes'
+++'_SDL_HasAVX'.'SDL2.dll'.'SDL_HasAVX'
+++'_SDL_GetDefaultAssertionHandler'.'SDL2.dll'.'SDL_GetDefaultAssertionHandler'
+++'_SDL_GetAssertionHandler'.'SDL2.dll'.'SDL_GetAssertionHandler'
+++'_SDL_DXGIGetOutputInfo'.'SDL2.dll'.'SDL_DXGIGetOutputInfo'
+++'_SDL_RenderIsClipEnabled'.'SDL2.dll'.'SDL_RenderIsClipEnabled'
+# ++'_SDL_WinRTRunApp'.'SDL2.dll'.'SDL_WinRTRunApp'
+++'_SDL_WarpMouseGlobal'.'SDL2.dll'.'SDL_WarpMouseGlobal'
+# ++'_SDL_WinRTGetFSPathUNICODE'.'SDL2.dll'.'SDL_WinRTGetFSPathUNICODE'
+# ++'_SDL_WinRTGetFSPathUTF8'.'SDL2.dll'.'SDL_WinRTGetFSPathUTF8'
+++'_SDL_sqrtf'.'SDL2.dll'.'SDL_sqrtf'
+++'_SDL_tan'.'SDL2.dll'.'SDL_tan'
+++'_SDL_tanf'.'SDL2.dll'.'SDL_tanf'
+++'_SDL_CaptureMouse'.'SDL2.dll'.'SDL_CaptureMouse'
+++'_SDL_SetWindowHitTest'.'SDL2.dll'.'SDL_SetWindowHitTest'
+++'_SDL_GetGlobalMouseState'.'SDL2.dll'.'SDL_GetGlobalMouseState'
+++'_SDL_HasAVX2'.'SDL2.dll'.'SDL_HasAVX2'
+++'_SDL_QueueAudio'.'SDL2.dll'.'SDL_QueueAudio'
+++'_SDL_GetQueuedAudioSize'.'SDL2.dll'.'SDL_GetQueuedAudioSize'
+++'_SDL_ClearQueuedAudio'.'SDL2.dll'.'SDL_ClearQueuedAudio'
+++'_SDL_GetGrabbedWindow'.'SDL2.dll'.'SDL_GetGrabbedWindow'
+++'_SDL_SetWindowsMessageHook'.'SDL2.dll'.'SDL_SetWindowsMessageHook'
+++'_SDL_JoystickCurrentPowerLevel'.'SDL2.dll'.'SDL_JoystickCurrentPowerLevel'
+++'_SDL_GameControllerFromInstanceID'.'SDL2.dll'.'SDL_GameControllerFromInstanceID'
+++'_SDL_JoystickFromInstanceID'.'SDL2.dll'.'SDL_JoystickFromInstanceID'
+++'_SDL_GetDisplayUsableBounds'.'SDL2.dll'.'SDL_GetDisplayUsableBounds'
+++'_SDL_GetWindowBordersSize'.'SDL2.dll'.'SDL_GetWindowBordersSize'
+++'_SDL_SetWindowOpacity'.'SDL2.dll'.'SDL_SetWindowOpacity'
+++'_SDL_GetWindowOpacity'.'SDL2.dll'.'SDL_GetWindowOpacity'
+++'_SDL_SetWindowInputFocus'.'SDL2.dll'.'SDL_SetWindowInputFocus'
+++'_SDL_SetWindowModalFor'.'SDL2.dll'.'SDL_SetWindowModalFor'
+++'_SDL_RenderSetIntegerScale'.'SDL2.dll'.'SDL_RenderSetIntegerScale'
+++'_SDL_RenderGetIntegerScale'.'SDL2.dll'.'SDL_RenderGetIntegerScale'
+++'_SDL_DequeueAudio'.'SDL2.dll'.'SDL_DequeueAudio'
+++'_SDL_SetWindowResizable'.'SDL2.dll'.'SDL_SetWindowResizable'
+++'_SDL_CreateRGBSurfaceWithFormat'.'SDL2.dll'.'SDL_CreateRGBSurfaceWithFormat'
+++'_SDL_CreateRGBSurfaceWithFormatFrom'.'SDL2.dll'.'SDL_CreateRGBSurfaceWithFormatFrom'
+++'_SDL_GetHintBoolean'.'SDL2.dll'.'SDL_GetHintBoolean'
+++'_SDL_JoystickGetDeviceVendor'.'SDL2.dll'.'SDL_JoystickGetDeviceVendor'
+++'_SDL_JoystickGetDeviceProduct'.'SDL2.dll'.'SDL_JoystickGetDeviceProduct'
+++'_SDL_JoystickGetDeviceProductVersion'.'SDL2.dll'.'SDL_JoystickGetDeviceProductVersion'
+++'_SDL_JoystickGetVendor'.'SDL2.dll'.'SDL_JoystickGetVendor'
+++'_SDL_JoystickGetProduct'.'SDL2.dll'.'SDL_JoystickGetProduct'
+++'_SDL_JoystickGetProductVersion'.'SDL2.dll'.'SDL_JoystickGetProductVersion'
+++'_SDL_GameControllerGetVendor'.'SDL2.dll'.'SDL_GameControllerGetVendor'
+++'_SDL_GameControllerGetProduct'.'SDL2.dll'.'SDL_GameControllerGetProduct'
+++'_SDL_GameControllerGetProductVersion'.'SDL2.dll'.'SDL_GameControllerGetProductVersion'
+++'_SDL_HasNEON'.'SDL2.dll'.'SDL_HasNEON'
+++'_SDL_GameControllerNumMappings'.'SDL2.dll'.'SDL_GameControllerNumMappings'
+++'_SDL_GameControllerMappingForIndex'.'SDL2.dll'.'SDL_GameControllerMappingForIndex'
+++'_SDL_JoystickGetAxisInitialState'.'SDL2.dll'.'SDL_JoystickGetAxisInitialState'
+++'_SDL_JoystickGetDeviceType'.'SDL2.dll'.'SDL_JoystickGetDeviceType'
+++'_SDL_JoystickGetType'.'SDL2.dll'.'SDL_JoystickGetType'
+++'_SDL_MemoryBarrierReleaseFunction'.'SDL2.dll'.'SDL_MemoryBarrierReleaseFunction'
+++'_SDL_MemoryBarrierAcquireFunction'.'SDL2.dll'.'SDL_MemoryBarrierAcquireFunction'
+++'_SDL_JoystickGetDeviceInstanceID'.'SDL2.dll'.'SDL_JoystickGetDeviceInstanceID'
+++'_SDL_utf8strlen'.'SDL2.dll'.'SDL_utf8strlen'
+++'_SDL_LoadFile_RW'.'SDL2.dll'.'SDL_LoadFile_RW'
+++'_SDL_wcscmp'.'SDL2.dll'.'SDL_wcscmp'
+++'_SDL_ComposeCustomBlendMode'.'SDL2.dll'.'SDL_ComposeCustomBlendMode'
+++'_SDL_DuplicateSurface'.'SDL2.dll'.'SDL_DuplicateSurface'
+++'_SDL_Vulkan_LoadLibrary'.'SDL2.dll'.'SDL_Vulkan_LoadLibrary'
+++'_SDL_Vulkan_GetVkGetInstanceProcAddr'.'SDL2.dll'.'SDL_Vulkan_GetVkGetInstanceProcAddr'
+++'_SDL_Vulkan_UnloadLibrary'.'SDL2.dll'.'SDL_Vulkan_UnloadLibrary'
+++'_SDL_Vulkan_GetInstanceExtensions'.'SDL2.dll'.'SDL_Vulkan_GetInstanceExtensions'
+++'_SDL_Vulkan_CreateSurface'.'SDL2.dll'.'SDL_Vulkan_CreateSurface'
+++'_SDL_Vulkan_GetDrawableSize'.'SDL2.dll'.'SDL_Vulkan_GetDrawableSize'
+++'_SDL_LockJoysticks'.'SDL2.dll'.'SDL_LockJoysticks'
+++'_SDL_UnlockJoysticks'.'SDL2.dll'.'SDL_UnlockJoysticks'
+++'_SDL_GetMemoryFunctions'.'SDL2.dll'.'SDL_GetMemoryFunctions'
+++'_SDL_SetMemoryFunctions'.'SDL2.dll'.'SDL_SetMemoryFunctions'
+++'_SDL_GetNumAllocations'.'SDL2.dll'.'SDL_GetNumAllocations'
+++'_SDL_NewAudioStream'.'SDL2.dll'.'SDL_NewAudioStream'
+++'_SDL_AudioStreamPut'.'SDL2.dll'.'SDL_AudioStreamPut'
+++'_SDL_AudioStreamGet'.'SDL2.dll'.'SDL_AudioStreamGet'
+++'_SDL_AudioStreamClear'.'SDL2.dll'.'SDL_AudioStreamClear'
+++'_SDL_AudioStreamAvailable'.'SDL2.dll'.'SDL_AudioStreamAvailable'
+++'_SDL_FreeAudioStream'.'SDL2.dll'.'SDL_FreeAudioStream'
+++'_SDL_AudioStreamFlush'.'SDL2.dll'.'SDL_AudioStreamFlush'
+++'_SDL_acosf'.'SDL2.dll'.'SDL_acosf'
+++'_SDL_asinf'.'SDL2.dll'.'SDL_asinf'
+++'_SDL_atanf'.'SDL2.dll'.'SDL_atanf'
+++'_SDL_atan2f'.'SDL2.dll'.'SDL_atan2f'
+++'_SDL_ceilf'.'SDL2.dll'.'SDL_ceilf'
+++'_SDL_copysignf'.'SDL2.dll'.'SDL_copysignf'
+++'_SDL_fabsf'.'SDL2.dll'.'SDL_fabsf'
+++'_SDL_floorf'.'SDL2.dll'.'SDL_floorf'
+++'_SDL_logf'.'SDL2.dll'.'SDL_logf'
+++'_SDL_powf'.'SDL2.dll'.'SDL_powf'
+++'_SDL_scalbnf'.'SDL2.dll'.'SDL_scalbnf'
+++'_SDL_fmod'.'SDL2.dll'.'SDL_fmod'
+++'_SDL_fmodf'.'SDL2.dll'.'SDL_fmodf'
+++'_SDL_SetYUVConversionMode'.'SDL2.dll'.'SDL_SetYUVConversionMode'
+++'_SDL_GetYUVConversionMode'.'SDL2.dll'.'SDL_GetYUVConversionMode'
+++'_SDL_GetYUVConversionModeForResolution'.'SDL2.dll'.'SDL_GetYUVConversionModeForResolution'
+++'_SDL_RenderGetMetalLayer'.'SDL2.dll'.'SDL_RenderGetMetalLayer'
+++'_SDL_RenderGetMetalCommandEncoder'.'SDL2.dll'.'SDL_RenderGetMetalCommandEncoder'
+# ++'_SDL_IsAndroidTV'.'SDL2.dll'.'SDL_IsAndroidTV'
+# ++'_SDL_WinRTGetDeviceFamily'.'SDL2.dll'.'SDL_WinRTGetDeviceFamily'
+++'_SDL_log10'.'SDL2.dll'.'SDL_log10'
+++'_SDL_log10f'.'SDL2.dll'.'SDL_log10f'
+++'_SDL_GameControllerMappingForDeviceIndex'.'SDL2.dll'.'SDL_GameControllerMappingForDeviceIndex'
+# ++'_SDL_LinuxSetThreadPriority'.'SDL2.dll'.'SDL_LinuxSetThreadPriority'
+++'_SDL_HasAVX512F'.'SDL2.dll'.'SDL_HasAVX512F'
+# ++'_SDL_IsChromebook'.'SDL2.dll'.'SDL_IsChromebook'
+# ++'_SDL_IsDeXMode'.'SDL2.dll'.'SDL_IsDeXMode'
+# ++'_SDL_AndroidBackButton'.'SDL2.dll'.'SDL_AndroidBackButton'
+++'_SDL_exp'.'SDL2.dll'.'SDL_exp'
+++'_SDL_expf'.'SDL2.dll'.'SDL_expf'
+++'_SDL_wcsdup'.'SDL2.dll'.'SDL_wcsdup'
+++'_SDL_GameControllerRumble'.'SDL2.dll'.'SDL_GameControllerRumble'
+++'_SDL_JoystickRumble'.'SDL2.dll'.'SDL_JoystickRumble'
+++'_SDL_NumSensors'.'SDL2.dll'.'SDL_NumSensors'
+++'_SDL_SensorGetDeviceName'.'SDL2.dll'.'SDL_SensorGetDeviceName'
+++'_SDL_SensorGetDeviceType'.'SDL2.dll'.'SDL_SensorGetDeviceType'
+++'_SDL_SensorGetDeviceNonPortableType'.'SDL2.dll'.'SDL_SensorGetDeviceNonPortableType'
+++'_SDL_SensorGetDeviceInstanceID'.'SDL2.dll'.'SDL_SensorGetDeviceInstanceID'
+++'_SDL_SensorOpen'.'SDL2.dll'.'SDL_SensorOpen'
+++'_SDL_SensorFromInstanceID'.'SDL2.dll'.'SDL_SensorFromInstanceID'
+++'_SDL_SensorGetName'.'SDL2.dll'.'SDL_SensorGetName'
+++'_SDL_SensorGetType'.'SDL2.dll'.'SDL_SensorGetType'
+++'_SDL_SensorGetNonPortableType'.'SDL2.dll'.'SDL_SensorGetNonPortableType'
+++'_SDL_SensorGetInstanceID'.'SDL2.dll'.'SDL_SensorGetInstanceID'
+++'_SDL_SensorGetData'.'SDL2.dll'.'SDL_SensorGetData'
+++'_SDL_SensorClose'.'SDL2.dll'.'SDL_SensorClose'
+++'_SDL_SensorUpdate'.'SDL2.dll'.'SDL_SensorUpdate'
+++'_SDL_IsTablet'.'SDL2.dll'.'SDL_IsTablet'
+++'_SDL_GetDisplayOrientation'.'SDL2.dll'.'SDL_GetDisplayOrientation'
+++'_SDL_HasColorKey'.'SDL2.dll'.'SDL_HasColorKey'
+++'_SDL_CreateThreadWithStackSize'.'SDL2.dll'.'SDL_CreateThreadWithStackSize'
+++'_SDL_JoystickGetDevicePlayerIndex'.'SDL2.dll'.'SDL_JoystickGetDevicePlayerIndex'
+++'_SDL_JoystickGetPlayerIndex'.'SDL2.dll'.'SDL_JoystickGetPlayerIndex'
+++'_SDL_GameControllerGetPlayerIndex'.'SDL2.dll'.'SDL_GameControllerGetPlayerIndex'
+++'_SDL_RenderFlush'.'SDL2.dll'.'SDL_RenderFlush'
+++'_SDL_RenderDrawPointF'.'SDL2.dll'.'SDL_RenderDrawPointF'
+++'_SDL_RenderDrawPointsF'.'SDL2.dll'.'SDL_RenderDrawPointsF'
+++'_SDL_RenderDrawLineF'.'SDL2.dll'.'SDL_RenderDrawLineF'
+++'_SDL_RenderDrawLinesF'.'SDL2.dll'.'SDL_RenderDrawLinesF'
+++'_SDL_RenderDrawRectF'.'SDL2.dll'.'SDL_RenderDrawRectF'
+++'_SDL_RenderDrawRectsF'.'SDL2.dll'.'SDL_RenderDrawRectsF'
+++'_SDL_RenderFillRectF'.'SDL2.dll'.'SDL_RenderFillRectF'
+++'_SDL_RenderFillRectsF'.'SDL2.dll'.'SDL_RenderFillRectsF'
+++'_SDL_RenderCopyF'.'SDL2.dll'.'SDL_RenderCopyF'
+++'_SDL_RenderCopyExF'.'SDL2.dll'.'SDL_RenderCopyExF'
+++'_SDL_GetTouchDeviceType'.'SDL2.dll'.'SDL_GetTouchDeviceType'
+# ++'_SDL_UIKitRunApp'.'SDL2.dll'.'SDL_UIKitRunApp'
+++'_SDL_SIMDGetAlignment'.'SDL2.dll'.'SDL_SIMDGetAlignment'
+++'_SDL_SIMDAlloc'.'SDL2.dll'.'SDL_SIMDAlloc'
+++'_SDL_SIMDFree'.'SDL2.dll'.'SDL_SIMDFree'
+++'_SDL_RWsize'.'SDL2.dll'.'SDL_RWsize'
+++'_SDL_RWseek'.'SDL2.dll'.'SDL_RWseek'
+++'_SDL_RWtell'.'SDL2.dll'.'SDL_RWtell'
+++'_SDL_RWread'.'SDL2.dll'.'SDL_RWread'
+++'_SDL_RWwrite'.'SDL2.dll'.'SDL_RWwrite'
+++'_SDL_RWclose'.'SDL2.dll'.'SDL_RWclose'
+++'_SDL_LoadFile'.'SDL2.dll'.'SDL_LoadFile'
+++'_SDL_Metal_CreateView'.'SDL2.dll'.'SDL_Metal_CreateView'
+++'_SDL_Metal_DestroyView'.'SDL2.dll'.'SDL_Metal_DestroyView'
+++'_SDL_LockTextureToSurface'.'SDL2.dll'.'SDL_LockTextureToSurface'
+++'_SDL_HasARMSIMD'.'SDL2.dll'.'SDL_HasARMSIMD'
+++'_SDL_strtokr'.'SDL2.dll'.'SDL_strtokr'
+++'_SDL_wcsstr'.'SDL2.dll'.'SDL_wcsstr'
+++'_SDL_wcsncmp'.'SDL2.dll'.'SDL_wcsncmp'
+++'_SDL_GameControllerTypeForIndex'.'SDL2.dll'.'SDL_GameControllerTypeForIndex'
+++'_SDL_GameControllerGetType'.'SDL2.dll'.'SDL_GameControllerGetType'
+++'_SDL_GameControllerFromPlayerIndex'.'SDL2.dll'.'SDL_GameControllerFromPlayerIndex'
+++'_SDL_GameControllerSetPlayerIndex'.'SDL2.dll'.'SDL_GameControllerSetPlayerIndex'
+++'_SDL_JoystickFromPlayerIndex'.'SDL2.dll'.'SDL_JoystickFromPlayerIndex'
+++'_SDL_JoystickSetPlayerIndex'.'SDL2.dll'.'SDL_JoystickSetPlayerIndex'
+++'_SDL_SetTextureScaleMode'.'SDL2.dll'.'SDL_SetTextureScaleMode'
+++'_SDL_GetTextureScaleMode'.'SDL2.dll'.'SDL_GetTextureScaleMode'
+++'_SDL_OnApplicationWillTerminate'.'SDL2.dll'.'SDL_OnApplicationWillTerminate'
+++'_SDL_OnApplicationDidReceiveMemoryWarning'.'SDL2.dll'.'SDL_OnApplicationDidReceiveMemoryWarning'
+++'_SDL_OnApplicationWillResignActive'.'SDL2.dll'.'SDL_OnApplicationWillResignActive'
+++'_SDL_OnApplicationDidEnterBackground'.'SDL2.dll'.'SDL_OnApplicationDidEnterBackground'
+++'_SDL_OnApplicationWillEnterForeground'.'SDL2.dll'.'SDL_OnApplicationWillEnterForeground'
+++'_SDL_OnApplicationDidBecomeActive'.'SDL2.dll'.'SDL_OnApplicationDidBecomeActive'
+# ++'_SDL_OnApplicationDidChangeStatusBarOrientation'.'SDL2.dll'.'SDL_OnApplicationDidChangeStatusBarOrientation'
+# ++'_SDL_GetAndroidSDKVersion'.'SDL2.dll'.'SDL_GetAndroidSDKVersion'
+++'_SDL_isupper'.'SDL2.dll'.'SDL_isupper'
+++'_SDL_islower'.'SDL2.dll'.'SDL_islower'
+++'_SDL_JoystickAttachVirtual'.'SDL2.dll'.'SDL_JoystickAttachVirtual'
+++'_SDL_JoystickDetachVirtual'.'SDL2.dll'.'SDL_JoystickDetachVirtual'
+++'_SDL_JoystickIsVirtual'.'SDL2.dll'.'SDL_JoystickIsVirtual'
+++'_SDL_JoystickSetVirtualAxis'.'SDL2.dll'.'SDL_JoystickSetVirtualAxis'
+++'_SDL_JoystickSetVirtualButton'.'SDL2.dll'.'SDL_JoystickSetVirtualButton'
+++'_SDL_JoystickSetVirtualHat'.'SDL2.dll'.'SDL_JoystickSetVirtualHat'
+++'_SDL_GetErrorMsg'.'SDL2.dll'.'SDL_GetErrorMsg'
+++'_SDL_LockSensors'.'SDL2.dll'.'SDL_LockSensors'
+++'_SDL_UnlockSensors'.'SDL2.dll'.'SDL_UnlockSensors'
+++'_SDL_Metal_GetLayer'.'SDL2.dll'.'SDL_Metal_GetLayer'
+++'_SDL_Metal_GetDrawableSize'.'SDL2.dll'.'SDL_Metal_GetDrawableSize'
+++'_SDL_trunc'.'SDL2.dll'.'SDL_trunc'
+++'_SDL_truncf'.'SDL2.dll'.'SDL_truncf'
+++'_SDL_GetPreferredLocales'.'SDL2.dll'.'SDL_GetPreferredLocales'
+++'_SDL_SIMDRealloc'.'SDL2.dll'.'SDL_SIMDRealloc'
+# ++'_SDL_AndroidRequestPermission'.'SDL2.dll'.'SDL_AndroidRequestPermission'
+++'_SDL_OpenURL'.'SDL2.dll'.'SDL_OpenURL'
+++'_SDL_HasSurfaceRLE'.'SDL2.dll'.'SDL_HasSurfaceRLE'
+++'_SDL_GameControllerHasLED'.'SDL2.dll'.'SDL_GameControllerHasLED'
+++'_SDL_GameControllerSetLED'.'SDL2.dll'.'SDL_GameControllerSetLED'
+++'_SDL_JoystickHasLED'.'SDL2.dll'.'SDL_JoystickHasLED'
+++'_SDL_JoystickSetLED'.'SDL2.dll'.'SDL_JoystickSetLED'
+++'_SDL_GameControllerRumbleTriggers'.'SDL2.dll'.'SDL_GameControllerRumbleTriggers'
+++'_SDL_JoystickRumbleTriggers'.'SDL2.dll'.'SDL_JoystickRumbleTriggers'
+++'_SDL_GameControllerHasAxis'.'SDL2.dll'.'SDL_GameControllerHasAxis'
+++'_SDL_GameControllerHasButton'.'SDL2.dll'.'SDL_GameControllerHasButton'
+++'_SDL_GameControllerGetNumTouchpads'.'SDL2.dll'.'SDL_GameControllerGetNumTouchpads'
+++'_SDL_GameControllerGetNumTouchpadFingers'.'SDL2.dll'.'SDL_GameControllerGetNumTouchpadFingers'
+++'_SDL_GameControllerGetTouchpadFinger'.'SDL2.dll'.'SDL_GameControllerGetTouchpadFinger'
+++'_SDL_crc32'.'SDL2.dll'.'SDL_crc32'
+++'_SDL_GameControllerGetSerial'.'SDL2.dll'.'SDL_GameControllerGetSerial'
+++'_SDL_JoystickGetSerial'.'SDL2.dll'.'SDL_JoystickGetSerial'
+++'_SDL_GameControllerHasSensor'.'SDL2.dll'.'SDL_GameControllerHasSensor'
+++'_SDL_GameControllerSetSensorEnabled'.'SDL2.dll'.'SDL_GameControllerSetSensorEnabled'
+++'_SDL_GameControllerIsSensorEnabled'.'SDL2.dll'.'SDL_GameControllerIsSensorEnabled'
+++'_SDL_GameControllerGetSensorData'.'SDL2.dll'.'SDL_GameControllerGetSensorData'
+++'_SDL_wcscasecmp'.'SDL2.dll'.'SDL_wcscasecmp'
+++'_SDL_wcsncasecmp'.'SDL2.dll'.'SDL_wcsncasecmp'
+++'_SDL_round'.'SDL2.dll'.'SDL_round'
+++'_SDL_roundf'.'SDL2.dll'.'SDL_roundf'
+++'_SDL_lround'.'SDL2.dll'.'SDL_lround'
+++'_SDL_lroundf'.'SDL2.dll'.'SDL_lroundf'
+++'_SDL_SoftStretchLinear'.'SDL2.dll'.'SDL_SoftStretchLinear'
+++'_SDL_RenderGetD3D11Device'.'SDL2.dll'.'SDL_RenderGetD3D11Device'
+++'_SDL_UpdateNVTexture'.'SDL2.dll'.'SDL_UpdateNVTexture'
+++'_SDL_SetWindowKeyboardGrab'.'SDL2.dll'.'SDL_SetWindowKeyboardGrab'
+++'_SDL_SetWindowMouseGrab'.'SDL2.dll'.'SDL_SetWindowMouseGrab'
+++'_SDL_GetWindowKeyboardGrab'.'SDL2.dll'.'SDL_GetWindowKeyboardGrab'
+++'_SDL_GetWindowMouseGrab'.'SDL2.dll'.'SDL_GetWindowMouseGrab'
+++'_SDL_isalpha'.'SDL2.dll'.'SDL_isalpha'
+++'_SDL_isalnum'.'SDL2.dll'.'SDL_isalnum'
+++'_SDL_isblank'.'SDL2.dll'.'SDL_isblank'
+++'_SDL_iscntrl'.'SDL2.dll'.'SDL_iscntrl'
+++'_SDL_isxdigit'.'SDL2.dll'.'SDL_isxdigit'
+++'_SDL_ispunct'.'SDL2.dll'.'SDL_ispunct'
+++'_SDL_isprint'.'SDL2.dll'.'SDL_isprint'
+++'_SDL_isgraph'.'SDL2.dll'.'SDL_isgraph'
+# ++'_SDL_AndroidShowToast'.'SDL2.dll'.'SDL_AndroidShowToast'
+++'_SDL_GetAudioDeviceSpec'.'SDL2.dll'.'SDL_GetAudioDeviceSpec'
+++'_SDL_TLSCleanup'.'SDL2.dll'.'SDL_TLSCleanup'
+++'_SDL_SetWindowAlwaysOnTop'.'SDL2.dll'.'SDL_SetWindowAlwaysOnTop'
+++'_SDL_FlashWindow'.'SDL2.dll'.'SDL_FlashWindow'
+++'_SDL_GameControllerSendEffect'.'SDL2.dll'.'SDL_GameControllerSendEffect'
+++'_SDL_JoystickSendEffect'.'SDL2.dll'.'SDL_JoystickSendEffect'
+++'_SDL_GameControllerGetSensorDataRate'.'SDL2.dll'.'SDL_GameControllerGetSensorDataRate'
+++'_SDL_SetTextureUserData'.'SDL2.dll'.'SDL_SetTextureUserData'
+++'_SDL_GetTextureUserData'.'SDL2.dll'.'SDL_GetTextureUserData'
+++'_SDL_RenderGeometry'.'SDL2.dll'.'SDL_RenderGeometry'
+++'_SDL_RenderGeometryRaw'.'SDL2.dll'.'SDL_RenderGeometryRaw'
+++'_SDL_RenderSetVSync'.'SDL2.dll'.'SDL_RenderSetVSync'
+++'_SDL_asprintf'.'SDL2.dll'.'SDL_asprintf'
+++'_SDL_vasprintf'.'SDL2.dll'.'SDL_vasprintf'
+++'_SDL_GetWindowICCProfile'.'SDL2.dll'.'SDL_GetWindowICCProfile'
+++'_SDL_GetTicks64'.'SDL2.dll'.'SDL_GetTicks64'
+# ++'_SDL_LinuxSetThreadPriorityAndPolicy'.'SDL2.dll'.'SDL_LinuxSetThreadPriorityAndPolicy'
+++'_SDL_GameControllerGetAppleSFSymbolsNameForButton'.'SDL2.dll'.'SDL_GameControllerGetAppleSFSymbolsNameForButton'
+++'_SDL_GameControllerGetAppleSFSymbolsNameForAxis'.'SDL2.dll'.'SDL_GameControllerGetAppleSFSymbolsNameForAxis'
+++'_SDL_hid_init'.'SDL2.dll'.'SDL_hid_init'
+++'_SDL_hid_exit'.'SDL2.dll'.'SDL_hid_exit'
+++'_SDL_hid_device_change_count'.'SDL2.dll'.'SDL_hid_device_change_count'
+++'_SDL_hid_enumerate'.'SDL2.dll'.'SDL_hid_enumerate'
+++'_SDL_hid_free_enumeration'.'SDL2.dll'.'SDL_hid_free_enumeration'
+++'_SDL_hid_open'.'SDL2.dll'.'SDL_hid_open'
+++'_SDL_hid_open_path'.'SDL2.dll'.'SDL_hid_open_path'
+++'_SDL_hid_write'.'SDL2.dll'.'SDL_hid_write'
+++'_SDL_hid_read_timeout'.'SDL2.dll'.'SDL_hid_read_timeout'
+++'_SDL_hid_read'.'SDL2.dll'.'SDL_hid_read'
+++'_SDL_hid_set_nonblocking'.'SDL2.dll'.'SDL_hid_set_nonblocking'
+++'_SDL_hid_send_feature_report'.'SDL2.dll'.'SDL_hid_send_feature_report'
+++'_SDL_hid_get_feature_report'.'SDL2.dll'.'SDL_hid_get_feature_report'
+++'_SDL_hid_close'.'SDL2.dll'.'SDL_hid_close'
+++'_SDL_hid_get_manufacturer_string'.'SDL2.dll'.'SDL_hid_get_manufacturer_string'
+++'_SDL_hid_get_product_string'.'SDL2.dll'.'SDL_hid_get_product_string'
+++'_SDL_hid_get_serial_number_string'.'SDL2.dll'.'SDL_hid_get_serial_number_string'
+++'_SDL_hid_get_indexed_string'.'SDL2.dll'.'SDL_hid_get_indexed_string'
+++'_SDL_SetWindowMouseRect'.'SDL2.dll'.'SDL_SetWindowMouseRect'
+++'_SDL_GetWindowMouseRect'.'SDL2.dll'.'SDL_GetWindowMouseRect'
+++'_SDL_RenderWindowToLogical'.'SDL2.dll'.'SDL_RenderWindowToLogical'
+++'_SDL_RenderLogicalToWindow'.'SDL2.dll'.'SDL_RenderLogicalToWindow'
+++'_SDL_JoystickHasRumble'.'SDL2.dll'.'SDL_JoystickHasRumble'
+++'_SDL_JoystickHasRumbleTriggers'.'SDL2.dll'.'SDL_JoystickHasRumbleTriggers'
+++'_SDL_GameControllerHasRumble'.'SDL2.dll'.'SDL_GameControllerHasRumble'
+++'_SDL_GameControllerHasRumbleTriggers'.'SDL2.dll'.'SDL_GameControllerHasRumbleTriggers'
+++'_SDL_hid_ble_scan'.'SDL2.dll'.'SDL_hid_ble_scan'
+++'_SDL_PremultiplyAlpha'.'SDL2.dll'.'SDL_PremultiplyAlpha'
+# ++'_SDL_AndroidSendMessage'.'SDL2.dll'.'SDL_AndroidSendMessage'
+++'_SDL_GetTouchName'.'SDL2.dll'.'SDL_GetTouchName'
+++'_SDL_ClearComposition'.'SDL2.dll'.'SDL_ClearComposition'
+++'_SDL_IsTextInputShown'.'SDL2.dll'.'SDL_IsTextInputShown'
+++'_SDL_HasIntersectionF'.'SDL2.dll'.'SDL_HasIntersectionF'
+++'_SDL_IntersectFRect'.'SDL2.dll'.'SDL_IntersectFRect'
+++'_SDL_UnionFRect'.'SDL2.dll'.'SDL_UnionFRect'
+++'_SDL_EncloseFPoints'.'SDL2.dll'.'SDL_EncloseFPoints'
+++'_SDL_IntersectFRectAndLine'.'SDL2.dll'.'SDL_IntersectFRectAndLine'
+++'_SDL_RenderGetWindow'.'SDL2.dll'.'SDL_RenderGetWindow'
+++'_SDL_bsearch'.'SDL2.dll'.'SDL_bsearch'
+++'_SDL_GameControllerPathForIndex'.'SDL2.dll'.'SDL_GameControllerPathForIndex'
+++'_SDL_GameControllerPath'.'SDL2.dll'.'SDL_GameControllerPath'
+++'_SDL_JoystickPathForIndex'.'SDL2.dll'.'SDL_JoystickPathForIndex'
+++'_SDL_JoystickPath'.'SDL2.dll'.'SDL_JoystickPath'
+++'_SDL_JoystickAttachVirtualEx'.'SDL2.dll'.'SDL_JoystickAttachVirtualEx'
diff --git a/Engine/lib/sdl/src/dynapi/SDL_dynapi.h b/Engine/lib/sdl/src/dynapi/SDL_dynapi.h
index 452078b1a..e37444fd9 100644
--- a/Engine/lib/sdl/src/dynapi/SDL_dynapi.h
+++ b/Engine/lib/sdl/src/dynapi/SDL_dynapi.h
@@ -59,6 +59,8 @@
 #define SDL_DYNAMIC_API 0  /* Turn off for static analysis, so reports are more clear. */
 #elif defined(__VITA__)
 #define SDL_DYNAMIC_API 0  /* vitasdk doesn't support dynamic linking */
+#elif defined(__NGAGE__)
+#define SDL_DYNAMIC_API 0  /* The N-Gage doesn't support dynamic linking either */
 #elif defined(DYNAPI_NEEDS_DLOPEN) && !defined(HAVE_DLOPEN)
 #define SDL_DYNAMIC_API 0  /* we need dlopen(), but don't have it.... */
 #endif
diff --git a/Engine/lib/sdl/src/dynapi/SDL_dynapi_overrides.h b/Engine/lib/sdl/src/dynapi/SDL_dynapi_overrides.h
index 526513ad5..c756c3841 100644
--- a/Engine/lib/sdl/src/dynapi/SDL_dynapi_overrides.h
+++ b/Engine/lib/sdl/src/dynapi/SDL_dynapi_overrides.h
@@ -439,8 +439,6 @@
 #define SDL_iconv_close SDL_iconv_close_REAL
 #define SDL_iconv SDL_iconv_REAL
 #define SDL_iconv_string SDL_iconv_string_REAL
-#define SDL_CreateRGBSurfaceWithFormat SDL_CreateRGBSurfaceWithFormat_REAL
-#define SDL_CreateRGBSurfaceWithFormatFrom SDL_CreateRGBSurfaceWithFormatFrom_REAL
 #define SDL_CreateRGBSurface SDL_CreateRGBSurface_REAL
 #define SDL_CreateRGBSurfaceFrom SDL_CreateRGBSurfaceFrom_REAL
 #define SDL_FreeSurface SDL_FreeSurface_REAL
@@ -577,7 +575,6 @@
 #define SDL_WarpMouseGlobal SDL_WarpMouseGlobal_REAL
 #define SDL_WinRTGetFSPathUNICODE SDL_WinRTGetFSPathUNICODE_REAL
 #define SDL_WinRTGetFSPathUTF8 SDL_WinRTGetFSPathUTF8_REAL
-#define SDL_WinRTRunApp SDL_WinRTRunApp_REAL
 #define SDL_sqrtf SDL_sqrtf_REAL
 #define SDL_tan SDL_tan_REAL
 #define SDL_tanf SDL_tanf_REAL
@@ -753,7 +750,6 @@
 #define SDL_JoystickDetachVirtual SDL_JoystickDetachVirtual_REAL
 #define SDL_JoystickIsVirtual SDL_JoystickIsVirtual_REAL
 #define SDL_JoystickSetVirtualAxis SDL_JoystickSetVirtualAxis_REAL
-#define SDL_JoystickSetVirtualBall SDL_JoystickSetVirtualBall_REAL
 #define SDL_JoystickSetVirtualButton SDL_JoystickSetVirtualButton_REAL
 #define SDL_JoystickSetVirtualHat SDL_JoystickSetVirtualHat_REAL
 #define SDL_GetErrorMsg SDL_GetErrorMsg_REAL
@@ -865,3 +861,9 @@
 #define SDL_EncloseFPoints SDL_EncloseFPoints_REAL
 #define SDL_IntersectFRectAndLine SDL_IntersectFRectAndLine_REAL
 #define SDL_RenderGetWindow SDL_RenderGetWindow_REAL
+#define SDL_bsearch SDL_bsearch_REAL
+#define SDL_GameControllerPathForIndex SDL_GameControllerPathForIndex_REAL
+#define SDL_GameControllerPath SDL_GameControllerPath_REAL
+#define SDL_JoystickPathForIndex SDL_JoystickPathForIndex_REAL
+#define SDL_JoystickPath SDL_JoystickPath_REAL
+#define SDL_JoystickAttachVirtualEx SDL_JoystickAttachVirtualEx_REAL
diff --git a/Engine/lib/sdl/src/dynapi/SDL_dynapi_procs.h b/Engine/lib/sdl/src/dynapi/SDL_dynapi_procs.h
index 22bf870d9..c14e7a15f 100644
--- a/Engine/lib/sdl/src/dynapi/SDL_dynapi_procs.h
+++ b/Engine/lib/sdl/src/dynapi/SDL_dynapi_procs.h
@@ -70,7 +70,7 @@ SDL_DYNAPI_PROC(IDirect3DDevice9*,SDL_RenderGetD3D9Device,(SDL_Renderer *a),(a),
 #endif
 
 #ifdef __IPHONEOS__
-SDL_DYNAPI_PROC(int,SDL_iPhoneSetAnimationCallback,(SDL_Window *a, int b, void c, void *d),(a,b,c,d),return)
+SDL_DYNAPI_PROC(int,SDL_iPhoneSetAnimationCallback,(SDL_Window *a, int b, void (SDLCALL *c)(void *), void *d),(a,b,c,d),return)
 SDL_DYNAPI_PROC(void,SDL_iPhoneSetEventPump,(SDL_bool a),(a),)
 #endif
 
@@ -408,7 +408,7 @@ SDL_DYNAPI_PROC(void*,SDL_realloc,(void *a, size_t b),(a,b),return)
 SDL_DYNAPI_PROC(void,SDL_free,(void *a),(a),)
 SDL_DYNAPI_PROC(char*,SDL_getenv,(const char *a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_setenv,(const char *a, const char *b, int c),(a,b,c),return)
-SDL_DYNAPI_PROC(void,SDL_qsort,(void *a, size_t b, size_t c, int (*d)(const void *, const void *)),(a,b,c,d),)
+SDL_DYNAPI_PROC(void,SDL_qsort,(void *a, size_t b, size_t c, int (SDLCALL *d)(const void *, const void *)),(a,b,c,d),)
 SDL_DYNAPI_PROC(int,SDL_abs,(int a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_isdigit,(int a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_isspace,(int a),(a),return)
@@ -508,7 +508,7 @@ SDL_DYNAPI_PROC(void,SDL_WaitThread,(SDL_Thread *a, int *b),(a,b),)
 SDL_DYNAPI_PROC(void,SDL_DetachThread,(SDL_Thread *a),(a),)
 SDL_DYNAPI_PROC(SDL_TLSID,SDL_TLSCreate,(void),(),return)
 SDL_DYNAPI_PROC(void*,SDL_TLSGet,(SDL_TLSID a),(a),return)
-SDL_DYNAPI_PROC(int,SDL_TLSSet,(SDL_TLSID a, const void *b, void (*c)(void*)),(a,b,c),return)
+SDL_DYNAPI_PROC(int,SDL_TLSSet,(SDL_TLSID a, const void *b, void (SDLCALL *c)(void*)),(a,b,c),return)
 SDL_DYNAPI_PROC(Uint32,SDL_GetTicks,(void),(),return)
 SDL_DYNAPI_PROC(Uint64,SDL_GetPerformanceCounter,(void),(),return)
 SDL_DYNAPI_PROC(Uint64,SDL_GetPerformanceFrequency,(void),(),return)
@@ -936,3 +936,9 @@ SDL_DYNAPI_PROC(void,SDL_UnionFRect,(const SDL_FRect *a, const SDL_FRect *b, SDL
 SDL_DYNAPI_PROC(SDL_bool,SDL_EncloseFPoints,(const SDL_FPoint *a, int b, const SDL_FRect *c, SDL_FRect *d),(a,b,c,d),return)
 SDL_DYNAPI_PROC(SDL_bool,SDL_IntersectFRectAndLine,(const SDL_FRect *a, float *b, float *c, float *d, float *e),(a,b,c,d,e),return)
 SDL_DYNAPI_PROC(SDL_Window*,SDL_RenderGetWindow,(SDL_Renderer *a),(a),return)
+SDL_DYNAPI_PROC(void*,SDL_bsearch,(const void *a, const void *b, size_t c, size_t d, int (SDLCALL *e)(const void *, const void *)),(a,b,c,d,e),return)
+SDL_DYNAPI_PROC(const char*,SDL_GameControllerPathForIndex,(int a),(a),return)
+SDL_DYNAPI_PROC(const char*,SDL_GameControllerPath,(SDL_GameController *a),(a),return)
+SDL_DYNAPI_PROC(const char*,SDL_JoystickPathForIndex,(int a),(a),return)
+SDL_DYNAPI_PROC(const char*,SDL_JoystickPath,(SDL_Joystick *a),(a),return)
+SDL_DYNAPI_PROC(int,SDL_JoystickAttachVirtualEx,(const SDL_VirtualJoystickDesc *a),(a),return)
diff --git a/Engine/lib/sdl/src/dynapi/gendynapi.pl b/Engine/lib/sdl/src/dynapi/gendynapi.pl
index b99a8a492..a9ff9723b 100755
--- a/Engine/lib/sdl/src/dynapi/gendynapi.pl
+++ b/Engine/lib/sdl/src/dynapi/gendynapi.pl
@@ -33,6 +33,7 @@ use File::Basename;
 chdir(dirname(__FILE__) . '/../..');
 my $sdl_dynapi_procs_h = "src/dynapi/SDL_dynapi_procs.h";
 my $sdl_dynapi_overrides_h = "src/dynapi/SDL_dynapi_overrides.h";
+my $sdl2_exports = "src/dynapi/SDL2.exports";
 
 my %existing = ();
 if (-f $sdl_dynapi_procs_h) {
@@ -47,6 +48,7 @@ if (-f $sdl_dynapi_procs_h) {
 
 open(SDL_DYNAPI_PROCS_H, '>>', $sdl_dynapi_procs_h) or die("Can't open $sdl_dynapi_procs_h: $!\n");
 open(SDL_DYNAPI_OVERRIDES_H, '>>', $sdl_dynapi_overrides_h) or die("Can't open $sdl_dynapi_overrides_h: $!\n");
+open(SDL2_EXPORTS, '>>', $sdl2_exports) or die("Can't open $sdl2_exports: $!\n");
 
 opendir(HEADERS, 'include') or die("Can't open include dir: $!\n");
 while (my $d = readdir(HEADERS)) {
@@ -133,6 +135,7 @@ while (my $d = readdir(HEADERS)) {
             print("NEW: $decl\n");
             print SDL_DYNAPI_PROCS_H "SDL_DYNAPI_PROC($rc,$fn,$paramstr,$argstr,$retstr)\n";
             print SDL_DYNAPI_OVERRIDES_H "#define $fn ${fn}_REAL\n";
+            print SDL2_EXPORTS "++'_${fn}'.'SDL2.dll'.'${fn}'\n";
         } else {
             print("Failed to parse decl [$decl]!\n");
         }
@@ -143,5 +146,6 @@ closedir(HEADERS);
 
 close(SDL_DYNAPI_PROCS_H);
 close(SDL_DYNAPI_OVERRIDES_H);
+close(SDL2_EXPORTS);
 
 # vi: set ts=4 sw=4 expandtab:
diff --git a/Engine/lib/sdl/src/events/SDL_events.c b/Engine/lib/sdl/src/events/SDL_events.c
index caa8b87eb..962120dbf 100644
--- a/Engine/lib/sdl/src/events/SDL_events.c
+++ b/Engine/lib/sdl/src/events/SDL_events.c
@@ -150,13 +150,19 @@ SDL_PollSentinelChanged(void *userdata, const char *name, const char *oldValue,
     SDL_EventState(SDL_POLLSENTINEL, SDL_GetStringBoolean(hint, SDL_TRUE) ? SDL_ENABLE : SDL_DISABLE);
 }
 
-/* 0 (default) means no logging, 1 means logging, 2 means logging with mouse and finger motion */
-static int SDL_DoEventLogging = 0;
+/**
+ * Verbosity of logged events as defined in SDL_HINT_EVENT_LOGGING:
+ *  - 0: (default) no logging
+ *  - 1: logging of most events
+ *  - 2: as above, plus mouse and finger motion
+ *  - 3: as above, plus SDL_SysWMEvents
+ */
+static int SDL_EventLoggingVerbosity = 0;
 
 static void SDLCALL
 SDL_EventLoggingChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
 {
-    SDL_DoEventLogging = (hint && *hint) ? SDL_clamp(SDL_atoi(hint), 0, 2) : 0;
+    SDL_EventLoggingVerbosity = (hint && *hint) ? SDL_clamp(SDL_atoi(hint), 0, 3) : 0;
 }
 
 static void
@@ -166,7 +172,7 @@ SDL_LogEvent(const SDL_Event *event)
     char details[128];
 
     /* sensor/mouse/finger motion are spammy, ignore these if they aren't demanded. */
-    if ( (SDL_DoEventLogging < 2) &&
+    if ( (SDL_EventLoggingVerbosity < 2) &&
             ( (event->type == SDL_MOUSEMOTION) ||
               (event->type == SDL_FINGERMOTION) ||
               (event->type == SDL_CONTROLLERTOUCHPADMOTION) ||
@@ -175,6 +181,11 @@ SDL_LogEvent(const SDL_Event *event)
         return;
     }
 
+    /* window manager events are even more spammy, and don't provide much useful info. */
+    if ((SDL_EventLoggingVerbosity < 3) && (event->type == SDL_SYSWMEVENT)) {
+        return;
+    }
+
     /* this is to make SDL_snprintf() calls cleaner. */
     #define uint unsigned int
 
@@ -590,7 +601,7 @@ SDL_AddEvent(SDL_Event * event)
         SDL_EventQ.free = entry->next;
     }
 
-    if (SDL_DoEventLogging) {
+    if (SDL_EventLoggingVerbosity > 0) {
         SDL_LogEvent(event);
     }
 
diff --git a/Engine/lib/sdl/src/events/SDL_keyboard.c b/Engine/lib/sdl/src/events/SDL_keyboard.c
index 14e79ca49..be1b7953e 100644
--- a/Engine/lib/sdl/src/events/SDL_keyboard.c
+++ b/Engine/lib/sdl/src/events/SDL_keyboard.c
@@ -282,6 +282,10 @@ static const SDL_Keycode SDL_default_keymap[SDL_NUM_SCANCODES] = {
     SDLK_APP2,
     SDLK_AUDIOREWIND,
     SDLK_AUDIOFASTFORWARD,
+    SDLK_SOFTLEFT,
+    SDLK_SOFTRIGHT,
+    SDLK_CALL,
+    SDLK_ENDCALL,
 };
 
 static const char *SDL_scancode_names[SDL_NUM_SCANCODES] = {
@@ -518,6 +522,10 @@ static const char *SDL_scancode_names[SDL_NUM_SCANCODES] = {
     "App2",
     "AudioRewind",
     "AudioFastForward",
+    "SoftLeft",
+    "SoftRight",
+    "Call",
+    "EndCall",
 };
 
 /* Taken from SDL_iconv() */
diff --git a/Engine/lib/sdl/src/events/SDL_mouse.c b/Engine/lib/sdl/src/events/SDL_mouse.c
index 254182cc5..dfa9a6c42 100644
--- a/Engine/lib/sdl/src/events/SDL_mouse.c
+++ b/Engine/lib/sdl/src/events/SDL_mouse.c
@@ -867,7 +867,7 @@ SDL_GetGlobalMouseState(int *x, int *y)
 }
 
 void
-SDL_WarpMouseInWindow(SDL_Window * window, int x, int y)
+SDL_PerformWarpMouseInWindow(SDL_Window *window, int x, int y, SDL_bool ignore_relative_mode)
 {
     SDL_Mouse *mouse = SDL_GetMouse();
 
@@ -883,6 +883,20 @@ SDL_WarpMouseInWindow(SDL_Window * window, int x, int y)
         return;
     }
 
+    if (mouse->relative_mode && !ignore_relative_mode) {
+        /* 2.0.22 made warping in relative mode actually functional, which
+         * surprised many applications that weren't expecting the additional
+         * mouse motion.
+         *
+         * So for now, warping in relative mode adjusts the absolution position
+         * but doesn't generate motion events.
+         */
+        mouse->x = x;
+        mouse->y = y;
+        mouse->has_position = SDL_TRUE;
+        return;
+    }
+
     /* Ignore the previous position when we warp */
     mouse->has_position = SDL_FALSE;
 
@@ -894,6 +908,12 @@ SDL_WarpMouseInWindow(SDL_Window * window, int x, int y)
     }
 }
 
+void
+SDL_WarpMouseInWindow(SDL_Window * window, int x, int y)
+{
+    SDL_PerformWarpMouseInWindow(window, x, y, SDL_FALSE);
+}
+
 int
 SDL_WarpMouseGlobal(int x, int y)
 {
@@ -953,8 +973,9 @@ SDL_SetRelativeMouseMode(SDL_bool enabled)
     if (enabled && focusWindow) {
         SDL_SetMouseFocus(focusWindow);
 
-        if (mouse->relative_mode_warp)
-            SDL_WarpMouseInWindow(focusWindow, focusWindow->w/2, focusWindow->h/2);
+        if (mouse->relative_mode_warp) {
+            SDL_PerformWarpMouseInWindow(focusWindow, focusWindow->w/2, focusWindow->h/2, SDL_TRUE);
+        }
     }
 
     if (focusWindow) {
@@ -962,7 +983,7 @@ SDL_SetRelativeMouseMode(SDL_bool enabled)
 
         /* Put the cursor back to where the application expects it */
         if (!enabled) {
-            SDL_WarpMouseInWindow(focusWindow, mouse->x, mouse->y);
+            SDL_PerformWarpMouseInWindow(focusWindow, mouse->x, mouse->y, SDL_TRUE);
         }
 
         SDL_UpdateMouseCapture(SDL_FALSE);
@@ -998,7 +1019,8 @@ SDL_UpdateMouseCapture(SDL_bool force_release)
     }
 
     if (!force_release) {
-        if (mouse->capture_desired || (mouse->auto_capture && SDL_GetMouseState(NULL, NULL) != 0)) {
+        if (SDL_GetMessageBoxCount() == 0 &&
+            (mouse->capture_desired || (mouse->auto_capture && SDL_GetMouseState(NULL, NULL) != 0))) {
             if (!mouse->relative_mode) {
                 capture_window = SDL_GetKeyboardFocus();
             }
@@ -1006,21 +1028,34 @@ SDL_UpdateMouseCapture(SDL_bool force_release)
     }
 
     if (capture_window != mouse->capture_window) {
-        if (mouse->capture_window) {
-            mouse->CaptureMouse(NULL);
-            mouse->capture_window->flags &= ~SDL_WINDOW_MOUSE_CAPTURE;
-            mouse->capture_window = NULL;
+        /* We can get here recursively on Windows, so make sure we complete
+         * all of the window state operations before we change the capture state
+         * (e.g. https://github.com/libsdl-org/SDL/pull/5608)
+         */
+        SDL_Window *previous_capture = mouse->capture_window;
+
+        if (previous_capture) {
+            previous_capture->flags &= ~SDL_WINDOW_MOUSE_CAPTURE;
         }
 
         if (capture_window) {
-            if (mouse->CaptureMouse(capture_window) < 0) {
-                /* CaptureMouse() will have set an error */
-                return -1;
-            }
             capture_window->flags |= SDL_WINDOW_MOUSE_CAPTURE;
         }
 
         mouse->capture_window = capture_window;
+
+        if (mouse->CaptureMouse(capture_window) < 0) {
+            /* CaptureMouse() will have set an error, just restore the state */
+            if (previous_capture) {
+                previous_capture->flags |= SDL_WINDOW_MOUSE_CAPTURE;
+            }
+            if (capture_window) {
+                capture_window->flags &= ~SDL_WINDOW_MOUSE_CAPTURE;
+            }
+            mouse->capture_window = previous_capture;
+
+            return -1;
+        }
     }
     return 0;
 }
@@ -1034,6 +1069,17 @@ SDL_CaptureMouse(SDL_bool enabled)
         return SDL_Unsupported();
     }
 
+#ifdef __WIN32__
+    /* Windows mouse capture is tied to the current thread, and must be called
+     * from the thread that created the window being captured. Since we update
+     * the mouse capture state from the event processing, any application state
+     * changes must be processed on that thread as well.
+     */
+    if (!SDL_OnVideoThread()) {
+        return SDL_SetError("SDL_CaptureMouse() must be called on the main thread");
+    }
+#endif /* __WIN32__ */
+
     if (enabled && SDL_GetKeyboardFocus() == NULL) {
         return SDL_SetError("No window has focus");
     }
diff --git a/Engine/lib/sdl/src/events/SDL_mouse_c.h b/Engine/lib/sdl/src/events/SDL_mouse_c.h
index f06934b6f..70c320851 100644
--- a/Engine/lib/sdl/src/events/SDL_mouse_c.h
+++ b/Engine/lib/sdl/src/events/SDL_mouse_c.h
@@ -152,6 +152,9 @@ extern int SDL_SendMouseButtonClicks(SDL_Window * window, SDL_MouseID mouseID, U
 /* Send a mouse wheel event */
 extern int SDL_SendMouseWheel(SDL_Window * window, SDL_MouseID mouseID, float x, float y, SDL_MouseWheelDirection direction);
 
+/* Warp the mouse within the window, potentially overriding relative mode */
+extern void SDL_PerformWarpMouseInWindow(SDL_Window *window, int x, int y, SDL_bool ignore_relative_mode);
+
 /* Shutdown the mouse subsystem */
 extern void SDL_MouseQuit(void);
 
diff --git a/Engine/lib/sdl/src/events/scancodes_darwin.h b/Engine/lib/sdl/src/events/scancodes_darwin.h
index a511e11c8..75564112a 100644
--- a/Engine/lib/sdl/src/events/scancodes_darwin.h
+++ b/Engine/lib/sdl/src/events/scancodes_darwin.h
@@ -25,7 +25,7 @@
    - Apple USB keyboard driver source <http://darwinsource.opendarwin.org/10.4.6.ppc/IOHIDFamily-172.8/IOHIDFamily/Cosmo_USB2ADB.c>
    - experimentation on various ADB and USB ISO keyboards and one ADB ANSI keyboard
 */
-/* *INDENT-OFF* */
+/* *INDENT-OFF* */ /* clang-format off */
 static const SDL_Scancode darwin_scancode_table[] = {
     /*   0 */   SDL_SCANCODE_A,
     /*   1 */   SDL_SCANCODE_S,
@@ -156,4 +156,4 @@ static const SDL_Scancode darwin_scancode_table[] = {
     /* 126 */   SDL_SCANCODE_UP,
     /* 127 */   SDL_SCANCODE_POWER
 };
-/* *INDENT-ON* */
+/* *INDENT-ON* */ /* clang-format on */
diff --git a/Engine/lib/sdl/src/events/scancodes_linux.h b/Engine/lib/sdl/src/events/scancodes_linux.h
index 72637b239..f274e993a 100644
--- a/Engine/lib/sdl/src/events/scancodes_linux.h
+++ b/Engine/lib/sdl/src/events/scancodes_linux.h
@@ -24,7 +24,7 @@
    Sources:
    - Linux kernel source input.h
 */
-/* *INDENT-OFF* */
+/* *INDENT-OFF* */ /* clang-format off */
 static SDL_Scancode const linux_scancode_table[] = {
     /*  0 */    SDL_SCANCODE_UNKNOWN,
     /*  1 */    SDL_SCANCODE_ESCAPE,
@@ -260,4 +260,4 @@ static SDL_Scancode const linux_scancode_table[] = {
     /*  235 */    SDL_SCANCODE_UNKNOWN, /* KEY_DOCUMENTS */
     /*  236 */    SDL_SCANCODE_UNKNOWN, /* KEY_BATTERY */
 };
-/* *INDENT-ON* */
+/* *INDENT-ON* */ /* clang-format on */
diff --git a/Engine/lib/sdl/src/events/scancodes_windows.h b/Engine/lib/sdl/src/events/scancodes_windows.h
index eec768d62..9fc7067a2 100644
--- a/Engine/lib/sdl/src/events/scancodes_windows.h
+++ b/Engine/lib/sdl/src/events/scancodes_windows.h
@@ -23,7 +23,7 @@
 /* Windows scancode to SDL scancode mapping table */
 /* derived from Microsoft scan code document, http://download.microsoft.com/download/1/6/1/161ba512-40e2-4cc9-843a-923143f3456c/scancode.doc */
 
-/* *INDENT-OFF* */
+/* *INDENT-OFF* */ /* clang-format off */
 static const SDL_Scancode windows_scancode_table[] = 
 { 
 	/*	0						1							2							3							4						5							6							7 */
@@ -52,4 +52,4 @@ static const SDL_Scancode windows_scancode_table[] =
 	SDL_SCANCODE_INTERNATIONAL2,		SDL_SCANCODE_UNKNOWN,		SDL_SCANCODE_UNKNOWN,		SDL_SCANCODE_INTERNATIONAL1,		SDL_SCANCODE_UNKNOWN,	SDL_SCANCODE_UNKNOWN,		SDL_SCANCODE_UNKNOWN,		SDL_SCANCODE_UNKNOWN,	/* 7 */
 	SDL_SCANCODE_UNKNOWN,		SDL_SCANCODE_INTERNATIONAL4,		SDL_SCANCODE_UNKNOWN,		SDL_SCANCODE_INTERNATIONAL5,		SDL_SCANCODE_UNKNOWN,	SDL_SCANCODE_INTERNATIONAL3,		SDL_SCANCODE_UNKNOWN,		SDL_SCANCODE_UNKNOWN	/* 7 */
 };
-/* *INDENT-ON* */
+/* *INDENT-ON* */ /* clang-format on */
diff --git a/Engine/lib/sdl/src/events/scancodes_xfree86.h b/Engine/lib/sdl/src/events/scancodes_xfree86.h
index 7046b7a8f..1ce2a8c57 100644
--- a/Engine/lib/sdl/src/events/scancodes_xfree86.h
+++ b/Engine/lib/sdl/src/events/scancodes_xfree86.h
@@ -28,7 +28,7 @@
    Sources:
    - atKeyNames.h from XFree86 source code
 */
-/* *INDENT-OFF* */
+/* *INDENT-OFF* */ /* clang-format off */
 static const SDL_Scancode xfree86_scancode_table[] = {
     /*  0 */    SDL_SCANCODE_UNKNOWN,
     /*  1 */    SDL_SCANCODE_ESCAPE,
@@ -509,4 +509,4 @@ static const SDL_Scancode xvnc_scancode_table[] = {
 
 #endif /* scancodes_xfree86_h_ */
 
-/* *INDENT-ON* */
+/* *INDENT-ON* */ /* clang-format on */
diff --git a/Engine/lib/sdl/src/file/SDL_rwops.c b/Engine/lib/sdl/src/file/SDL_rwops.c
index 670d4dd9a..0b4cc17b2 100644
--- a/Engine/lib/sdl/src/file/SDL_rwops.c
+++ b/Engine/lib/sdl/src/file/SDL_rwops.c
@@ -62,235 +62,6 @@
 #include "nacl_io/nacl_io.h"
 #endif
 
-#ifdef __VITA__
-
-#include <psp2/io/fcntl.h>
-#include <psp2/io/stat.h>
-
-#define READAHEAD_BUFFER_SIZE   1024
-static int SDLCALL
-vita_file_open(SDL_RWops * context, const char *filename, const char *mode)
-{
-    int h;
-    int open_flags;
-    SDL_bool has_r;
-    SDL_bool has_w;
-    SDL_bool has_a;
-    SDL_bool has_plus;
-
-    if (!context)
-        return -1;              /* failed (invalid call) */
-
-    context->hidden.vitaio.h = -1;   /* mark this as unusable */
-    context->hidden.vitaio.buffer.data = NULL;
-    context->hidden.vitaio.buffer.size = 0;
-    context->hidden.vitaio.buffer.left = 0;
-
-    open_flags = 0;
-
-    /* "r" = reading, file must exist */
-    /* "w" = writing, truncate existing, file may not exist */
-    /* "r+"= reading or writing, file must exist            */
-    /* "a" = writing, append file may not exist             */
-    /* "a+"= append + read, file may not exist              */
-    /* "w+" = read, write, truncate. file may not exist    */
-
-    has_r = SDL_strchr(mode, 'r') != NULL;
-    has_w = SDL_strchr(mode, 'w') != NULL;
-    has_a = SDL_strchr(mode, 'a') != NULL;
-    has_plus = SDL_strchr(mode, '+') != NULL;
-
-    if (has_plus)
-    {
-        if (has_r || has_w || has_a)
-        {
-            open_flags |= SCE_O_RDWR;
-        }
-    }
-    else
-    {
-        if (has_r)
-        {
-            open_flags |= SCE_O_RDONLY;
-        }
-        if (has_w || has_a)
-        {
-            open_flags |= SCE_O_WRONLY;
-        }
-    }
-    if (has_w || has_a)
-    {
-        open_flags |= SCE_O_CREAT;
-    }
-    if (has_w)
-    {
-        open_flags |= SCE_O_TRUNC;
-    }
-    if (has_a)
-    {
-        open_flags |= SCE_O_APPEND;
-    }
-
-    context->hidden.vitaio.buffer.data =
-        (char *) SDL_malloc(READAHEAD_BUFFER_SIZE);
-    if (!context->hidden.vitaio.buffer.data) {
-        return SDL_OutOfMemory();
-    }
-
-    /* Try to open the file on the filesystem first */
-    h = sceIoOpen(filename, open_flags, 0777);
-
-    if (h < 0) {
-        /* Try opening it from app0:/ container if it's a relative path */
-        char path[4096];
-        SDL_snprintf(path, 4096, "app0:/%s", filename);
-        h = sceIoOpen(path, open_flags, 0777);
-    }
-
-    if (h < 0) {
-        SDL_free(context->hidden.vitaio.buffer.data);
-        context->hidden.vitaio.buffer.data = NULL;
-        SDL_SetError("Couldn't open %s", filename);
-        return -2;              /* failed (sceIoOpen) */
-    }
-    context->hidden.vitaio.h = h;
-
-    return 0;                   /* ok */
-}
-
-static Sint64 SDLCALL
-vita_file_size(SDL_RWops * context)
-{
-    SceIoStat st;
-    if (!context || context->hidden.vitaio.h < 0) {
-        return SDL_SetError("vita_file_size: invalid context/file not opened");
-    }
-
-    if (sceIoGetstatByFd(context->hidden.vitaio.h, &st) < 0) {
-        return SDL_SetError("vita_file_size: could not get file size");
-    }
-    return st.st_size;
-}
-
-static Sint64 SDLCALL
-vita_file_seek(SDL_RWops * context, Sint64 offset, int whence)
-{
-    int vitawhence;
-
-    if (!context || context->hidden.vitaio.h < 0) {
-        return SDL_SetError("vita_file_seek: invalid context/file not opened");
-    }
-
-    /* FIXME: We may be able to satisfy the seek within buffered data */
-    if (whence == RW_SEEK_CUR && context->hidden.vitaio.buffer.left) {
-        offset -= (long)context->hidden.vitaio.buffer.left;
-    }
-    context->hidden.vitaio.buffer.left = 0;
-
-    switch (whence) {
-    case RW_SEEK_SET:
-        vitawhence = SCE_SEEK_SET;
-        break;
-    case RW_SEEK_CUR:
-        vitawhence = SCE_SEEK_CUR;
-        break;
-    case RW_SEEK_END:
-        vitawhence = SCE_SEEK_END;
-        break;
-    default:
-        return SDL_SetError("vita_file_seek: Unknown value for 'whence'");
-    }
-
-    return sceIoLseek(context->hidden.vitaio.h, offset, vitawhence);
-}
-
-static size_t SDLCALL
-vita_file_read(SDL_RWops * context, void *ptr, size_t size, size_t maxnum)
-{
-    size_t total_need;
-    size_t total_read = 0;
-    size_t read_ahead;
-    size_t byte_read;
-
-    total_need = size * maxnum;
-
-    if (!context || context->hidden.vitaio.h < 0 || !total_need) {
-        return 0;
-    }
-
-    if (context->hidden.vitaio.buffer.left > 0) {
-        void *data = (char *) context->hidden.vitaio.buffer.data +
-            context->hidden.vitaio.buffer.size -
-            context->hidden.vitaio.buffer.left;
-        read_ahead =
-            SDL_min(total_need, context->hidden.vitaio.buffer.left);
-        SDL_memcpy(ptr, data, read_ahead);
-        context->hidden.vitaio.buffer.left -= read_ahead;
-
-        if (read_ahead == total_need) {
-            return maxnum;
-        }
-        ptr = (char *) ptr + read_ahead;
-        total_need -= read_ahead;
-        total_read += read_ahead;
-    }
-
-    if (total_need < READAHEAD_BUFFER_SIZE) {
-        byte_read = sceIoRead(context->hidden.vitaio.h, context->hidden.vitaio.buffer.data, READAHEAD_BUFFER_SIZE);
-        read_ahead = SDL_min(total_need, (int) byte_read);
-        SDL_memcpy(ptr, context->hidden.vitaio.buffer.data, read_ahead);
-        context->hidden.vitaio.buffer.size = byte_read;
-        context->hidden.vitaio.buffer.left = byte_read - read_ahead;
-        total_read += read_ahead;
-    } else {
-        byte_read = sceIoRead(context->hidden.vitaio.h, ptr, total_need);
-        total_read += byte_read;
-    }
-    return (total_read / size);
-}
-
-static size_t SDLCALL
-vita_file_write(SDL_RWops * context, const void *ptr, size_t size,
-                 size_t num)
-{
-
-    size_t total_bytes;
-    size_t byte_written;
-    size_t nwritten;
-
-    total_bytes = size * num;
-
-    if (!context || context->hidden.vitaio.h < 0 || !size || !total_bytes) {
-        return 0;
-    }
-
-    if (context->hidden.vitaio.buffer.left) {
-        sceIoLseek(context->hidden.vitaio.h, -(SceOff)context->hidden.vitaio.buffer.left, SCE_SEEK_CUR);
-        context->hidden.vitaio.buffer.left = 0;
-    }
-
-    byte_written = sceIoWrite(context->hidden.vitaio.h, ptr, total_bytes);
-
-    nwritten = byte_written / size;
-    return nwritten;
-}
-
-static int SDLCALL
-vita_file_close(SDL_RWops * context)
-{
-    if (context) {
-        if (context->hidden.vitaio.h >= 0) {
-            sceIoClose(context->hidden.vitaio.h);
-            context->hidden.vitaio.h = -1;   /* to be sure */
-        }
-        SDL_free(context->hidden.vitaio.buffer.data);
-        context->hidden.vitaio.buffer.data = NULL;
-        SDL_FreeRW(context);
-    }
-    return 0;
-}
-#endif
-
 #ifdef __WIN32__
 
 /* Functions to read/write Win32 API file pointers */
@@ -817,20 +588,6 @@ SDL_RWFromFile(const char *file, const char *mode)
     rwops->write = windows_file_write;
     rwops->close = windows_file_close;
     rwops->type = SDL_RWOPS_WINFILE;
-#elif defined(__VITA__)
-    rwops = SDL_AllocRW();
-    if (!rwops)
-        return NULL;            /* SDL_SetError already setup by SDL_AllocRW() */
-    if (vita_file_open(rwops, file, mode) < 0) {
-        SDL_FreeRW(rwops);
-        return NULL;
-    }
-    rwops->size = vita_file_size;
-    rwops->seek = vita_file_seek;
-    rwops->read = vita_file_read;
-    rwops->write = vita_file_write;
-    rwops->close = vita_file_close;
-    rwops->type = SDL_RWOPS_VITAFILE;
 #elif HAVE_STDIO_H
     {
         #if __APPLE__ && !SDL_FILE_DISABLED // TODO: add dummy?
diff --git a/Engine/lib/sdl/src/filesystem/psp/SDL_sysfilesystem.c b/Engine/lib/sdl/src/filesystem/psp/SDL_sysfilesystem.c
index e9c6ee49e..4abb90ad7 100644
--- a/Engine/lib/sdl/src/filesystem/psp/SDL_sysfilesystem.c
+++ b/Engine/lib/sdl/src/filesystem/psp/SDL_sysfilesystem.c
@@ -34,44 +34,44 @@
 char *
 SDL_GetBasePath(void)
 {
-  char *retval = NULL;
-  size_t len;
-  char cwd[FILENAME_MAX];
-  
-  getcwd(cwd, sizeof(cwd));
-  len = SDL_strlen(cwd) + 2;
-  retval = (char *) SDL_malloc(len);
-  SDL_snprintf(retval, len, "%s/", cwd);
+    char *retval = NULL;
+    size_t len;
+    char cwd[FILENAME_MAX];
 
-  return retval;
+    getcwd(cwd, sizeof(cwd));
+    len = SDL_strlen(cwd) + 2;
+    retval = (char *) SDL_malloc(len);
+    SDL_snprintf(retval, len, "%s/", cwd);
+
+    return retval;
 }
 
 char *
 SDL_GetPrefPath(const char *org, const char *app)
 {
-  char *retval = NULL;
-  size_t len;
-  char *base = SDL_GetBasePath();
-  if (!app) {
-    SDL_InvalidParamError("app");
-    return NULL;
-  }
-  if(!org) {
-    org = "";
-  }
+    char *retval = NULL;
+    size_t len;
+    char *base = SDL_GetBasePath();
+    if (!app) {
+        SDL_InvalidParamError("app");
+        return NULL;
+    }
+    if(!org) {
+        org = "";
+    }
 
-  len = SDL_strlen(base) + SDL_strlen(org) + SDL_strlen(app) + 4;
-  retval = (char *) SDL_malloc(len);
+    len = SDL_strlen(base) + SDL_strlen(org) + SDL_strlen(app) + 4;
+    retval = (char *) SDL_malloc(len);
 
-  if (*org) {
-    SDL_snprintf(retval, len, "%s%s/%s/", base, org, app);
-  } else {
-    SDL_snprintf(retval, len, "%s%s/", base, app);
-  }
-  free(base);
+    if (*org) {
+        SDL_snprintf(retval, len, "%s%s/%s/", base, org, app);
+    } else {
+        SDL_snprintf(retval, len, "%s%s/", base, app);
+    }
+    free(base);
 
-  mkdir(retval, 0755);
-  return retval;
+    mkdir(retval, 0755);
+    return retval;
 }
 
 #endif /* SDL_FILESYSTEM_PSP */
diff --git a/Engine/lib/sdl/src/hidapi/bootstrap b/Engine/lib/sdl/src/hidapi/bootstrap
old mode 100644
new mode 100755
diff --git a/Engine/lib/sdl/src/hidapi/testgui/copy_to_bundle.sh b/Engine/lib/sdl/src/hidapi/testgui/copy_to_bundle.sh
old mode 100644
new mode 100755
diff --git a/Engine/lib/sdl/src/hidapi/testgui/start.sh b/Engine/lib/sdl/src/hidapi/testgui/start.sh
old mode 100644
new mode 100755
diff --git a/Engine/lib/sdl/src/hidapi/windows/hid.c b/Engine/lib/sdl/src/hidapi/windows/hid.c
index f0a30c7d1..8dfd11d05 100644
--- a/Engine/lib/sdl/src/hidapi/windows/hid.c
+++ b/Engine/lib/sdl/src/hidapi/windows/hid.c
@@ -43,21 +43,6 @@
 typedef LONG NTSTATUS;
 #endif
 
-/* SDL C runtime functions */
-#include "SDL_stdinc.h"
-
-#define calloc SDL_calloc
-#define free SDL_free
-#define malloc SDL_malloc
-#define memcpy SDL_memcpy
-#define memset SDL_memset
-#define strcmp SDL_strcmp
-#define strlen SDL_strlen
-#define strstr SDL_strstr
-#define strtol SDL_strtol
-#define wcscmp SDL_wcscmp
-#define _wcsdup SDL_wcsdup
-
 /* The maximum number of characters that can be passed into the
    HidD_Get*String() functions without it failing.*/
 #define MAX_STRING_WCHARS 0xFFF
@@ -94,11 +79,26 @@ extern "C" {
 } /* extern "C" */
 #endif
 
+#include "../hidapi/hidapi.h"
+
 /*#include <stdio.h>*/
 /*#include <stdlib.h>*/
 
+/* SDL C runtime functions */
+#include "SDL_stdinc.h"
+
+#define calloc SDL_calloc
+#define free SDL_free
+#define malloc SDL_malloc
+#define memcpy SDL_memcpy
+#define memset SDL_memset
+#define strcmp SDL_strcmp
+#define strlen SDL_strlen
+#define strstr SDL_strstr
+#define strtol SDL_strtol
+#define wcscmp SDL_wcscmp
+#define _wcsdup SDL_wcsdup
 
-#include "../hidapi/hidapi.h"
 
 #undef MIN
 #define MIN(x,y) ((x) < (y)? (x): (y))
diff --git a/Engine/lib/sdl/src/joystick/SDL_gamecontroller.c b/Engine/lib/sdl/src/joystick/SDL_gamecontroller.c
index e27922a6d..4e573f55b 100644
--- a/Engine/lib/sdl/src/joystick/SDL_gamecontroller.c
+++ b/Engine/lib/sdl/src/joystick/SDL_gamecontroller.c
@@ -696,19 +696,20 @@ static ControllerMapping_t *SDL_PrivateGetControllerMappingForGUID(SDL_JoystickG
             return s_pXInputMapping;
         }
 #endif
+        if (!mapping) {
+            if (SDL_IsJoystickHIDAPI(guid)) {
+                mapping = SDL_CreateMappingForHIDAPIController(guid);
+            } else if (SDL_IsJoystickRAWINPUT(guid)) {
+                mapping = SDL_CreateMappingForRAWINPUTController(guid);
+            } else if (SDL_IsJoystickWGI(guid)) {
+                mapping = SDL_CreateMappingForWGIController(guid);
+            } else if (SDL_IsJoystickVirtual(guid)) {
+                /* We'll pick up a robust mapping in VIRTUAL_JoystickGetGamepadMapping */
 #ifdef __ANDROID__
-        if (!mapping && !SDL_IsJoystickHIDAPI(guid)) {
-            mapping = SDL_CreateMappingForAndroidController(guid);
-        }
+            } else {
+                mapping = SDL_CreateMappingForAndroidController(guid);
 #endif
-        if (!mapping && SDL_IsJoystickHIDAPI(guid)) {
-            mapping = SDL_CreateMappingForHIDAPIController(guid);
-        }
-        if (!mapping && SDL_IsJoystickRAWINPUT(guid)) {
-            mapping = SDL_CreateMappingForRAWINPUTController(guid);
-        }
-        if (!mapping && SDL_IsJoystickWGI(guid)) {
-            mapping = SDL_CreateMappingForWGIController(guid);
+            }
         }
     }
     return mapping;
@@ -1258,6 +1259,11 @@ static ControllerMapping_t *SDL_PrivateGenerateAutomaticControllerMapping(const
     SDL_PrivateAppendToMappingString(mapping, sizeof(mapping), "dpdown", &raw_map->dpdown);
     SDL_PrivateAppendToMappingString(mapping, sizeof(mapping), "dpleft", &raw_map->dpleft);
     SDL_PrivateAppendToMappingString(mapping, sizeof(mapping), "dpright", &raw_map->dpright);
+    SDL_PrivateAppendToMappingString(mapping, sizeof(mapping), "misc1", &raw_map->misc1);
+    SDL_PrivateAppendToMappingString(mapping, sizeof(mapping), "paddle1", &raw_map->paddle1);
+    SDL_PrivateAppendToMappingString(mapping, sizeof(mapping), "paddle2", &raw_map->paddle2);
+    SDL_PrivateAppendToMappingString(mapping, sizeof(mapping), "paddle3", &raw_map->paddle3);
+    SDL_PrivateAppendToMappingString(mapping, sizeof(mapping), "paddle4", &raw_map->paddle4);
     SDL_PrivateAppendToMappingString(mapping, sizeof(mapping), "leftx", &raw_map->leftx);
     SDL_PrivateAppendToMappingString(mapping, sizeof(mapping), "lefty", &raw_map->lefty);
     SDL_PrivateAppendToMappingString(mapping, sizeof(mapping), "rightx", &raw_map->rightx);
@@ -1732,6 +1738,20 @@ SDL_GameControllerNameForIndex(int device_index)
 }
 
 
+/*
+ * Get the implementation dependent path of a controller
+ */
+const char *
+SDL_GameControllerPathForIndex(int device_index)
+{
+    ControllerMapping_t *pSupportedController = SDL_PrivateGetControllerMapping(device_index);
+    if (pSupportedController) {
+        return SDL_JoystickPathForIndex(device_index);
+    }
+    return NULL;
+}
+
+
 /**
  *  Get the type of a game controller.
  */
@@ -2294,6 +2314,15 @@ SDL_GameControllerName(SDL_GameController *gamecontroller)
     }
 }
 
+const char *
+SDL_GameControllerPath(SDL_GameController *gamecontroller)
+{
+    if (!gamecontroller)
+        return NULL;
+
+    return SDL_JoystickPath(SDL_GameControllerGetJoystick(gamecontroller));
+}
+
 SDL_GameControllerType
 SDL_GameControllerGetType(SDL_GameController *gamecontroller)
 {
diff --git a/Engine/lib/sdl/src/joystick/SDL_gamecontrollerdb.h b/Engine/lib/sdl/src/joystick/SDL_gamecontrollerdb.h
index 9dab7cbba..bbe0067a6 100644
--- a/Engine/lib/sdl/src/joystick/SDL_gamecontrollerdb.h
+++ b/Engine/lib/sdl/src/joystick/SDL_gamecontrollerdb.h
@@ -748,8 +748,11 @@ static const char *s_ControllerMappings [] =
     "030000005e0400008e02000020200000,SpeedLink XEOX Pro Analog Gamepad pad,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
     "030000005e0400008e02000073050000,Speedlink TORID Wireless Gamepad,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
     "03000000de2800000112000001000000,Steam Controller,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,paddle1:b11,paddle2:b10,rightshoulder:b5,righttrigger:a3,start:b7,x:b2,y:b3,",
+    "03000000de2800000112000011010000,Steam Controller,a:b2,b:b3,x:b4,y:b5,back:b10,guide:b12,start:b11,leftstick:b13,rightstick:b14,leftshoulder:b6,rightshoulder:b7,dpup:-a5,dpdown:+a5,dpleft:-a4,dpright:+a4,paddle1:b15,paddle2:b16,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:a7,righttrigger:a6,",
     "03000000de2800000211000001000000,Steam Controller,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,paddle1:b11,paddle2:b10,rightshoulder:b5,righttrigger:a3,start:b7,x:b2,y:b3,",
+    "03000000de2800000211000011010000,Steam Controller,a:b2,b:b3,x:b4,y:b5,back:b10,guide:b12,start:b11,leftstick:b13,rightstick:b14,leftshoulder:b6,rightshoulder:b7,dpup:-a5,dpdown:+a5,dpleft:-a4,dpright:+a4,paddle1:b15,paddle2:b16,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:a7,righttrigger:a6,",
     "03000000de2800004211000001000000,Steam Controller,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,paddle1:b11,paddle2:b10,rightshoulder:b5,righttrigger:a3,start:b7,x:b2,y:b3,",
+    "03000000de2800004211000011010000,Steam Controller,a:b2,b:b3,x:b4,y:b5,back:b10,guide:b12,start:b11,leftstick:b13,rightstick:b14,leftshoulder:b6,rightshoulder:b7,dpup:-a5,dpdown:+a5,dpleft:-a4,dpright:+a4,paddle1:b15,paddle2:b16,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:a7,righttrigger:a6,",
     "03000000de280000fc11000001000000,Steam Controller,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
     "05000000de2800000212000001000000,Steam Controller,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,paddle1:b11,paddle2:b10,rightshoulder:b5,righttrigger:a3,start:b7,x:b2,y:b3,",
     "05000000de2800000511000001000000,Steam Controller,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,paddle1:b11,paddle2:b10,rightshoulder:b5,righttrigger:a3,start:b7,x:b2,y:b3,",
@@ -896,9 +899,6 @@ static const char *s_ControllerMappings [] =
     "050000005e040000e0020000df070000,Xbox Wireless Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b9,x:b2,y:b3,",
     "050000005e040000e0020000ff070000,Xbox Wireless Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b9,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b10,x:b2,y:b3,",
 #endif
-#if defined(SDL_JOYSTICK_VIRTUAL)
-    "00000000000000000000000000007601,Virtual Joystick,a:b0,b:b1,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b5,leftshoulder:b9,leftstick:b7,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a2,righty:a3,start:b6,x:b2,y:b3,",
-#endif
 #if defined(SDL_JOYSTICK_EMSCRIPTEN)
     "default,Standard Gamepad,a:b0,b:b1,back:b8,dpdown:b13,dpleft:b14,dpright:b15,dpup:b12,guide:b16,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,",
 #endif
diff --git a/Engine/lib/sdl/src/joystick/SDL_joystick.c b/Engine/lib/sdl/src/joystick/SDL_joystick.c
index ae4591223..5288c552a 100644
--- a/Engine/lib/sdl/src/joystick/SDL_joystick.c
+++ b/Engine/lib/sdl/src/joystick/SDL_joystick.c
@@ -320,6 +320,28 @@ SDL_JoystickNameForIndex(int device_index)
     return name;
 }
 
+/*
+ * Get the implementation dependent path of a joystick
+ */
+const char *
+SDL_JoystickPathForIndex(int device_index)
+{
+    SDL_JoystickDriver *driver;
+    const char *path = NULL;
+
+    SDL_LockJoysticks();
+    if (SDL_GetDriverAndJoystickIndex(device_index, &driver, &device_index)) {
+        path = driver->GetDevicePath(device_index);
+    }
+    SDL_UnlockJoysticks();
+
+    /* FIXME: Really we should reference count this path so it doesn't go away after unlock */
+    if (!path) {
+        SDL_Unsupported();
+    }
+    return path;
+}
+
 /*
  *  Get the player index of a joystick, or -1 if it's not available
  */
@@ -386,6 +408,8 @@ SDL_JoystickOpen(int device_index)
     SDL_Joystick *joystick;
     SDL_Joystick *joysticklist;
     const char *joystickname = NULL;
+    const char *joystickpath = NULL;
+    SDL_JoystickPowerLevel initial_power_level;
 
     SDL_LockJoysticks();
 
@@ -435,6 +459,13 @@ SDL_JoystickOpen(int device_index)
         joystick->name = NULL;
     }
 
+    joystickpath = driver->GetDevicePath(device_index);
+    if (joystickpath) {
+        joystick->path = SDL_strdup(joystickpath);
+    } else {
+        joystick->path = NULL;
+    }
+
     joystick->guid = driver->GetDeviceGUID(device_index);
 
     if (joystick->naxes > 0) {
@@ -478,6 +509,11 @@ SDL_JoystickOpen(int device_index)
 
     SDL_UnlockJoysticks();
 
+    /* send initial battery event */
+    initial_power_level = joystick->epowerlevel;
+    joystick->epowerlevel = SDL_JOYSTICK_POWER_UNKNOWN;
+    SDL_PrivateJoystickBatteryLevel(joystick, initial_power_level);
+
     driver->Update(joystick);
 
     return joystick;
@@ -486,9 +522,23 @@ SDL_JoystickOpen(int device_index)
 int
 SDL_JoystickAttachVirtual(SDL_JoystickType type,
                           int naxes, int nbuttons, int nhats)
+{
+    SDL_VirtualJoystickDesc desc;
+
+    SDL_zero(desc);
+    desc.version = SDL_VIRTUAL_JOYSTICK_DESC_VERSION;
+    desc.type = (Uint16)type;
+    desc.naxes = (Uint16)naxes;
+    desc.nbuttons = (Uint16)nbuttons;
+    desc.nhats = (Uint16)nhats;
+    return SDL_JoystickAttachVirtualEx(&desc);
+}
+
+int
+SDL_JoystickAttachVirtualEx(const SDL_VirtualJoystickDesc *desc)
 {
 #if SDL_JOYSTICK_VIRTUAL
-    return SDL_JoystickAttachVirtualInner(type, naxes, nbuttons, nhats);
+    return SDL_JoystickAttachVirtualInner(desc);
 #else
     return SDL_SetError("SDL not built with virtual-joystick support");
 #endif
@@ -834,6 +884,23 @@ SDL_JoystickName(SDL_Joystick *joystick)
     return joystick->name;
 }
 
+/*
+ * Get the implementation dependent path of this joystick
+ */
+const char *
+SDL_JoystickPath(SDL_Joystick *joystick)
+{
+    if (!SDL_PrivateJoystickValid(joystick)) {
+        return NULL;
+    }
+
+    if (!joystick->path) {
+        SDL_Unsupported();
+        return NULL;
+    }
+    return joystick->path;
+}
+
 /**
  *  Get the player index of an opened joystick, or -1 if it's not available
  */
@@ -1006,14 +1073,13 @@ SDL_JoystickSetLED(SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
     SDL_LockJoysticks();
 
     isfreshvalue = red != joystick->led_red ||
-        green != joystick->led_green ||
-        blue != joystick->led_blue;
+                   green != joystick->led_green ||
+                   blue != joystick->led_blue;
 
-    if ( isfreshvalue || SDL_TICKS_PASSED( SDL_GetTicks(), joystick->led_expiration ) ) {
+    if (isfreshvalue || SDL_TICKS_PASSED(SDL_GetTicks(), joystick->led_expiration)) {
         result = joystick->driver->SetLED(joystick, red, green, blue);
         joystick->led_expiration = SDL_GetTicks() + SDL_LED_MIN_REPEAT_MS;
-    }
-    else {
+    } else {
         /* Avoid spamming the driver */
         result = 0;
     }
@@ -1100,6 +1166,7 @@ SDL_JoystickClose(SDL_Joystick *joystick)
     }
 
     SDL_free(joystick->name);
+    SDL_free(joystick->path);
     SDL_free(joystick->serial);
 
     /* Free the data associated with this joystick */
@@ -2495,8 +2562,7 @@ SDL_bool SDL_ShouldIgnoreJoystick(const char *name, SDL_JoystickGUID guid)
         return SDL_TRUE;
     }
 
-    if (SDL_IsGameControllerNameAndGUID(name, guid) &&
-        SDL_ShouldIgnoreGameController(name, guid)) {
+    if (SDL_ShouldIgnoreGameController(name, guid)) {
         return SDL_TRUE;
     }
 
@@ -2721,7 +2787,19 @@ SDL_JoystickGUID SDL_JoystickGetGUIDFromString(const char *pchGUID)
 /* update the power level for this joystick */
 void SDL_PrivateJoystickBatteryLevel(SDL_Joystick *joystick, SDL_JoystickPowerLevel ePowerLevel)
 {
-    joystick->epowerlevel = ePowerLevel;
+    SDL_assert(joystick->ref_count); /* make sure we are calling this only for update, not for initialisation */
+    if (ePowerLevel != joystick->epowerlevel) {
+#if !SDL_EVENTS_DISABLED
+        if (SDL_GetEventState(SDL_JOYBATTERYUPDATED) == SDL_ENABLE) {
+            SDL_Event event;
+            event.type = SDL_JOYBATTERYUPDATED;
+            event.jbattery.which = joystick->instance_id;
+            event.jbattery.level = ePowerLevel;
+            SDL_PushEvent(&event);
+        }
+#endif /* !SDL_EVENTS_DISABLED */
+        joystick->epowerlevel = ePowerLevel;
+    }
 }
 
 /* return its power level */
diff --git a/Engine/lib/sdl/src/joystick/SDL_joystick_c.h b/Engine/lib/sdl/src/joystick/SDL_joystick_c.h
index 312e11337..a7aa6b714 100644
--- a/Engine/lib/sdl/src/joystick/SDL_joystick_c.h
+++ b/Engine/lib/sdl/src/joystick/SDL_joystick_c.h
@@ -168,6 +168,11 @@ typedef struct _SDL_GamepadMapping
     SDL_InputMapping dpdown;
     SDL_InputMapping dpleft;
     SDL_InputMapping dpright;
+    SDL_InputMapping misc1;
+    SDL_InputMapping paddle1;
+    SDL_InputMapping paddle2;
+    SDL_InputMapping paddle3;
+    SDL_InputMapping paddle4;
     SDL_InputMapping leftx;
     SDL_InputMapping lefty;
     SDL_InputMapping rightx;
diff --git a/Engine/lib/sdl/src/joystick/SDL_sysjoystick.h b/Engine/lib/sdl/src/joystick/SDL_sysjoystick.h
index 8b8792179..04b6b7a0c 100644
--- a/Engine/lib/sdl/src/joystick/SDL_sysjoystick.h
+++ b/Engine/lib/sdl/src/joystick/SDL_sysjoystick.h
@@ -65,6 +65,7 @@ struct _SDL_Joystick
 {
     SDL_JoystickID instance_id; /* Device instance, monotonically increasing from 0 */
     char *name;                 /* Joystick name - system dependent */
+    char *path;                 /* Joystick path - system dependent */
     char *serial;               /* Joystick serial */
     SDL_JoystickGUID guid;      /* Joystick guid */
 
@@ -118,6 +119,7 @@ struct _SDL_Joystick
 };
 
 /* Device bus definitions */
+#define SDL_HARDWARE_BUS_VIRTUAL    0x00
 #define SDL_HARDWARE_BUS_USB        0x03
 #define SDL_HARDWARE_BUS_BLUETOOTH  0x05
 
@@ -146,6 +148,9 @@ typedef struct _SDL_JoystickDriver
     /* Function to get the device-dependent name of a joystick */
     const char *(*GetDeviceName)(int device_index);
 
+    /* Function to get the device-dependent path of a joystick */
+    const char *(*GetDevicePath)(int device_index);
+
     /* Function to get the player index of a joystick */
     int (*GetDevicePlayerIndex)(int device_index);
 
diff --git a/Engine/lib/sdl/src/joystick/android/SDL_sysjoystick.c b/Engine/lib/sdl/src/joystick/android/SDL_sysjoystick.c
index aef014d16..104724afd 100644
--- a/Engine/lib/sdl/src/joystick/android/SDL_sysjoystick.c
+++ b/Engine/lib/sdl/src/joystick/android/SDL_sysjoystick.c
@@ -558,6 +558,12 @@ ANDROID_JoystickGetDeviceName(int device_index)
     return JoystickByDevIndex(device_index)->name;
 }
 
+static const char *
+ANDROID_JoystickGetDevicePath(int device_index)
+{
+    return NULL;
+}
+
 static int
 ANDROID_JoystickGetDevicePlayerIndex(int device_index)
 {
@@ -713,6 +719,7 @@ SDL_JoystickDriver SDL_ANDROID_JoystickDriver =
     ANDROID_JoystickGetCount,
     ANDROID_JoystickDetect,
     ANDROID_JoystickGetDeviceName,
+    ANDROID_JoystickGetDevicePath,
     ANDROID_JoystickGetDevicePlayerIndex,
     ANDROID_JoystickSetDevicePlayerIndex,
     ANDROID_JoystickGetDeviceGUID,
diff --git a/Engine/lib/sdl/src/joystick/bsd/SDL_bsdjoystick.c b/Engine/lib/sdl/src/joystick/bsd/SDL_bsdjoystick.c
index f8859a534..d7b4d4730 100644
--- a/Engine/lib/sdl/src/joystick/bsd/SDL_bsdjoystick.c
+++ b/Engine/lib/sdl/src/joystick/bsd/SDL_bsdjoystick.c
@@ -268,9 +268,15 @@ static const char *
 BSD_JoystickGetDeviceName(int device_index)
 {
     if (joydevnames[device_index] != NULL) {
-        return (joydevnames[device_index]);
+        return joydevnames[device_index];
     }
-    return (joynames[device_index]);
+    return joynames[device_index];
+}
+
+static const char *
+BSD_JoystickGetDevicePath(int device_index)
+{
+    return joynames[device_index];
 }
 
 static int
@@ -807,6 +813,7 @@ SDL_JoystickDriver SDL_BSD_JoystickDriver =
     BSD_JoystickGetCount,
     BSD_JoystickDetect,
     BSD_JoystickGetDeviceName,
+    BSD_JoystickGetDevicePath,
     BSD_JoystickGetDevicePlayerIndex,
     BSD_JoystickSetDevicePlayerIndex,
     BSD_JoystickGetDeviceGUID,
diff --git a/Engine/lib/sdl/src/joystick/check_8bitdo.sh b/Engine/lib/sdl/src/joystick/check_8bitdo.sh
old mode 100644
new mode 100755
diff --git a/Engine/lib/sdl/src/joystick/darwin/SDL_iokitjoystick.c b/Engine/lib/sdl/src/joystick/darwin/SDL_iokitjoystick.c
index 7f2514728..91072c52e 100644
--- a/Engine/lib/sdl/src/joystick/darwin/SDL_iokitjoystick.c
+++ b/Engine/lib/sdl/src/joystick/darwin/SDL_iokitjoystick.c
@@ -744,7 +744,6 @@ DARWIN_JoystickDetect(void)
     }
 }
 
-/* Function to get the device-dependent name of a joystick */
 const char *
 DARWIN_JoystickGetDeviceName(int device_index)
 {
@@ -752,6 +751,12 @@ DARWIN_JoystickGetDeviceName(int device_index)
     return device ? device->product : "UNKNOWN";
 }
 
+const char *
+DARWIN_JoystickGetDevicePath(int device_index)
+{
+    return NULL;
+}
+
 static int
 DARWIN_JoystickGetDevicePlayerIndex(int device_index)
 {
@@ -1115,6 +1120,7 @@ SDL_JoystickDriver SDL_DARWIN_JoystickDriver =
     DARWIN_JoystickGetCount,
     DARWIN_JoystickDetect,
     DARWIN_JoystickGetDeviceName,
+    DARWIN_JoystickGetDevicePath,
     DARWIN_JoystickGetDevicePlayerIndex,
     DARWIN_JoystickSetDevicePlayerIndex,
     DARWIN_JoystickGetDeviceGUID,
diff --git a/Engine/lib/sdl/src/joystick/dummy/SDL_sysjoystick.c b/Engine/lib/sdl/src/joystick/dummy/SDL_sysjoystick.c
index ec1c8e651..3cf8da5f9 100644
--- a/Engine/lib/sdl/src/joystick/dummy/SDL_sysjoystick.c
+++ b/Engine/lib/sdl/src/joystick/dummy/SDL_sysjoystick.c
@@ -52,6 +52,12 @@ DUMMY_JoystickGetDeviceName(int device_index)
     return NULL;
 }
 
+static const char *
+DUMMY_JoystickGetDevicePath(int device_index)
+{
+    return NULL;
+}
+
 static int
 DUMMY_JoystickGetDevicePlayerIndex(int device_index)
 {
@@ -146,6 +152,7 @@ SDL_JoystickDriver SDL_DUMMY_JoystickDriver =
     DUMMY_JoystickGetCount,
     DUMMY_JoystickDetect,
     DUMMY_JoystickGetDeviceName,
+    DUMMY_JoystickGetDevicePath,
     DUMMY_JoystickGetDevicePlayerIndex,
     DUMMY_JoystickSetDevicePlayerIndex,
     DUMMY_JoystickGetDeviceGUID,
diff --git a/Engine/lib/sdl/src/joystick/emscripten/SDL_sysjoystick.c b/Engine/lib/sdl/src/joystick/emscripten/SDL_sysjoystick.c
index eb0ff2a74..1664a907c 100644
--- a/Engine/lib/sdl/src/joystick/emscripten/SDL_sysjoystick.c
+++ b/Engine/lib/sdl/src/joystick/emscripten/SDL_sysjoystick.c
@@ -280,6 +280,12 @@ EMSCRIPTEN_JoystickGetDeviceName(int device_index)
     return JoystickByDeviceIndex(device_index)->name;
 }
 
+static const char *
+EMSCRIPTEN_JoystickGetDevicePath(int device_index)
+{
+    return NULL;
+}
+
 static int
 EMSCRIPTEN_JoystickGetDevicePlayerIndex(int device_index)
 {
@@ -444,6 +450,7 @@ SDL_JoystickDriver SDL_EMSCRIPTEN_JoystickDriver =
     EMSCRIPTEN_JoystickGetCount,
     EMSCRIPTEN_JoystickDetect,
     EMSCRIPTEN_JoystickGetDeviceName,
+    EMSCRIPTEN_JoystickGetDevicePath,
     EMSCRIPTEN_JoystickGetDevicePlayerIndex,
     EMSCRIPTEN_JoystickSetDevicePlayerIndex,
     EMSCRIPTEN_JoystickGetDeviceGUID,
diff --git a/Engine/lib/sdl/src/joystick/haiku/SDL_haikujoystick.cc b/Engine/lib/sdl/src/joystick/haiku/SDL_haikujoystick.cc
index 38a975227..c0c6e012c 100644
--- a/Engine/lib/sdl/src/joystick/haiku/SDL_haikujoystick.cc
+++ b/Engine/lib/sdl/src/joystick/haiku/SDL_haikujoystick.cc
@@ -64,15 +64,15 @@ extern "C"
         char name[B_OS_NAME_LENGTH];
 
         /* Search for attached joysticks */
-          nports = joystick.CountDevices();
-          numjoysticks = 0;
-          SDL_memset(SDL_joyport, 0, (sizeof SDL_joyport));
-          SDL_memset(SDL_joyname, 0, (sizeof SDL_joyname));
+        nports = joystick.CountDevices();
+        numjoysticks = 0;
+        SDL_memset(SDL_joyport, 0, (sizeof SDL_joyport));
+        SDL_memset(SDL_joyname, 0, (sizeof SDL_joyname));
         for (i = 0; (numjoysticks < MAX_JOYSTICKS) && (i < nports); ++i)
         {
             if (joystick.GetDeviceName(i, name) == B_OK) {
                 if (joystick.Open(name) != B_ERROR) {
-                    BString stick_name;
+                      BString stick_name;
                       joystick.GetControllerName(&stick_name);
                       SDL_joyport[numjoysticks] = SDL_strdup(name);
                       SDL_joyname[numjoysticks] = SDL_CreateJoystickName(0, 0, NULL, stick_name.String());
@@ -93,12 +93,16 @@ extern "C"
     {
     }
 
-/* Function to get the device-dependent name of a joystick */
     static const char *HAIKU_JoystickGetDeviceName(int device_index)
     {
         return SDL_joyname[device_index];
     }
 
+    static const char *HAIKU_JoystickGetDevicePath(int device_index)
+    {
+        return SDL_joyport[device_index];
+    }
+
     static int HAIKU_JoystickGetDevicePlayerIndex(int device_index)
     {
         return -1;
@@ -298,6 +302,7 @@ extern "C"
         HAIKU_JoystickGetCount,
         HAIKU_JoystickDetect,
         HAIKU_JoystickGetDeviceName,
+        HAIKU_JoystickGetDevicePath,
         HAIKU_JoystickGetDevicePlayerIndex,
         HAIKU_JoystickSetDevicePlayerIndex,
         HAIKU_JoystickGetDeviceGUID,
diff --git a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_luna.c b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_luna.c
index ead55af34..bf497d224 100644
--- a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_luna.c
+++ b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_luna.c
@@ -267,16 +267,16 @@ HIDAPI_DriverLuna_HandleBluetoothStatePacket(SDL_Joystick *joystick, SDL_DriverL
         /* Battery level report */
         int level = data[1] * 100 / 0xFF;
         if (level == 0) {
-            joystick->epowerlevel = SDL_JOYSTICK_POWER_EMPTY;
+            SDL_PrivateJoystickBatteryLevel(joystick, SDL_JOYSTICK_POWER_EMPTY);
         }
         else if (level <= 20) {
-            joystick->epowerlevel = SDL_JOYSTICK_POWER_LOW;
+            SDL_PrivateJoystickBatteryLevel(joystick, SDL_JOYSTICK_POWER_LOW);
         }
         else if (level <= 70) {
-            joystick->epowerlevel = SDL_JOYSTICK_POWER_MEDIUM;
+            SDL_PrivateJoystickBatteryLevel(joystick, SDL_JOYSTICK_POWER_MEDIUM);
         }
         else {
-            joystick->epowerlevel = SDL_JOYSTICK_POWER_FULL;
+            SDL_PrivateJoystickBatteryLevel(joystick, SDL_JOYSTICK_POWER_FULL);
         }
 
         return;
diff --git a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_ps4.c b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_ps4.c
index 8e7699fe4..c11dfb364 100644
--- a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_ps4.c
+++ b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_ps4.c
@@ -801,18 +801,18 @@ HIDAPI_DriverPS4_HandleStatePacket(SDL_Joystick *joystick, SDL_hid_device *dev,
     SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_RIGHTY, axis);
 
     if (packet->ucBatteryLevel & 0x10) {
-        joystick->epowerlevel = SDL_JOYSTICK_POWER_WIRED;
+        SDL_PrivateJoystickBatteryLevel(joystick, SDL_JOYSTICK_POWER_WIRED);
     } else {
         /* Battery level ranges from 0 to 10 */
         int level = (packet->ucBatteryLevel & 0xF);
         if (level == 0) {
-            joystick->epowerlevel = SDL_JOYSTICK_POWER_EMPTY;
+            SDL_PrivateJoystickBatteryLevel(joystick, SDL_JOYSTICK_POWER_EMPTY);
         } else if (level <= 2) {
-            joystick->epowerlevel = SDL_JOYSTICK_POWER_LOW;
+            SDL_PrivateJoystickBatteryLevel(joystick, SDL_JOYSTICK_POWER_LOW);
         } else if (level <= 7) {
-            joystick->epowerlevel = SDL_JOYSTICK_POWER_MEDIUM;
+            SDL_PrivateJoystickBatteryLevel(joystick, SDL_JOYSTICK_POWER_MEDIUM);
         } else {
-            joystick->epowerlevel = SDL_JOYSTICK_POWER_FULL;
+            SDL_PrivateJoystickBatteryLevel(joystick, SDL_JOYSTICK_POWER_FULL);
         }
     }
 
diff --git a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_rumble.c b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_rumble.c
index bf376277e..9cbdb9599 100644
--- a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_rumble.c
+++ b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_rumble.c
@@ -53,7 +53,7 @@ typedef struct SDL_HIDAPI_RumbleContext
 
 static SDL_HIDAPI_RumbleContext rumble_context;
 
-static int SDL_HIDAPI_RumbleThread(void *data)
+static int SDLCALL SDL_HIDAPI_RumbleThread(void *data)
 {
     SDL_HIDAPI_RumbleContext *ctx = (SDL_HIDAPI_RumbleContext *)data;
 
diff --git a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_switch.c b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_switch.c
index 912d613ed..13b5e29d0 100644
--- a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_switch.c
+++ b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_switch.c
@@ -63,6 +63,11 @@
 #define SWITCH_GYRO_SCALE      14.2842f
 #define SWITCH_ACCEL_SCALE     4096.f
 
+#define SWITCH_GYRO_SCALE_OFFSET      13371.0f
+#define SWITCH_GYRO_SCALE_MULT        936.0f
+#define SWITCH_ACCEL_SCALE_OFFSET     16384.0f
+#define SWITCH_ACCEL_SCALE_MULT       4.0f
+
 typedef enum {
     k_eSwitchInputReportIDs_SubcommandReply       = 0x21,
     k_eSwitchInputReportIDs_FullControllerState   = 0x30,
@@ -114,6 +119,14 @@ typedef enum {
 #define k_unSPIStickCalibrationEndOffset    0x604E
 #define k_unSPIStickCalibrationLength       (k_unSPIStickCalibrationEndOffset - k_unSPIStickCalibrationStartOffset + 1)
 
+#define k_unSPIIMUScaleStartOffset  0x6020
+#define k_unSPIIMUScaleEndOffset    0x6037
+#define k_unSPIIMUScaleLength       (k_unSPIIMUScaleEndOffset - k_unSPIIMUScaleStartOffset + 1)
+
+#define k_unSPIIMUUserScaleStartOffset  0x8026
+#define k_unSPIIMUUserScaleEndOffset    0x8039
+#define k_unSPIIMUUserScaleLength       (k_unSPIIMUUserScaleEndOffset - k_unSPIIMUUserScaleStartOffset + 1)
+
 #pragma pack(1)
 typedef struct
 {
@@ -266,6 +279,16 @@ typedef struct {
             Sint16 sMax;
         } axis[2];
     } m_StickExtents[2];
+
+    struct IMUScaleData {
+        float fAccelScaleX;
+        float fAccelScaleY;
+        float fAccelScaleZ;
+
+        float fGyroScaleX;
+        float fGyroScaleY;
+        float fGyroScaleZ;
+    } m_IMUScaleData;
 } SDL_DriverSwitch_Context;
 
 
@@ -769,6 +792,72 @@ static SDL_bool LoadStickCalibration(SDL_DriverSwitch_Context *ctx, Uint8 input_
     return SDL_TRUE;
 }
 
+static SDL_bool LoadIMUCalibration(SDL_DriverSwitch_Context* ctx)
+{
+    Uint8* pIMUScale;
+    SwitchSubcommandInputPacket_t* reply = NULL;
+    Sint16 sAccelRawX, sAccelRawY, sAccelRawZ, sGyroRawX, sGyroRawY, sGyroRawZ;
+
+    /* Read Calibration Info */
+    SwitchSPIOpData_t readParams;
+    readParams.unAddress = k_unSPIIMUScaleStartOffset;
+    readParams.ucLength = k_unSPIIMUScaleLength;
+
+    if (!WriteSubcommand(ctx, k_eSwitchSubcommandIDs_SPIFlashRead, (uint8_t*)&readParams, sizeof(readParams), &reply)) {
+        const float accelScale = SDL_STANDARD_GRAVITY / SWITCH_ACCEL_SCALE;
+        const float gyroScale = (float)M_PI / 180.0f / SWITCH_GYRO_SCALE;
+
+        ctx->m_IMUScaleData.fAccelScaleX = accelScale;
+        ctx->m_IMUScaleData.fAccelScaleY = accelScale;
+        ctx->m_IMUScaleData.fAccelScaleZ = accelScale;
+
+        ctx->m_IMUScaleData.fGyroScaleX = gyroScale;
+        ctx->m_IMUScaleData.fGyroScaleY = gyroScale;
+        ctx->m_IMUScaleData.fGyroScaleZ = gyroScale;
+
+        return SDL_FALSE;
+    }
+
+    /* IMU scale gives us multipliers for converting raw values to real world values */
+    pIMUScale = reply->spiReadData.rgucReadData;
+
+    sAccelRawX = ((pIMUScale[1] << 8) & 0xF00) | pIMUScale[0];
+    sAccelRawY = ((pIMUScale[3] << 8) & 0xF00) | pIMUScale[2];
+    sAccelRawZ = ((pIMUScale[5] << 8) & 0xF00) | pIMUScale[4];
+
+    sGyroRawX = ((pIMUScale[13] << 8) & 0xF00) | pIMUScale[12];
+    sGyroRawY = ((pIMUScale[15] << 8) & 0xF00) | pIMUScale[14];
+    sGyroRawZ = ((pIMUScale[17] << 8) & 0xF00) | pIMUScale[16];
+
+    /* Check for user calibration data. If it's present and set, it'll override the factory settings */
+    readParams.unAddress = k_unSPIIMUUserScaleStartOffset;
+    readParams.ucLength = k_unSPIIMUUserScaleLength;
+    if (WriteSubcommand(ctx, k_eSwitchSubcommandIDs_SPIFlashRead, (uint8_t*)&readParams, sizeof(readParams), &reply) && (pIMUScale[0] | pIMUScale[1] << 8) == 0xA1B2) {
+        pIMUScale = reply->spiReadData.rgucReadData;
+        
+        sAccelRawX = ((pIMUScale[3] << 8) & 0xF00) | pIMUScale[2];
+        sAccelRawY = ((pIMUScale[5] << 8) & 0xF00) | pIMUScale[4];
+        sAccelRawZ = ((pIMUScale[7] << 8) & 0xF00) | pIMUScale[6];
+
+        sGyroRawX = ((pIMUScale[15] << 8) & 0xF00) | pIMUScale[14];
+        sGyroRawY = ((pIMUScale[17] << 8) & 0xF00) | pIMUScale[16];
+        sGyroRawZ = ((pIMUScale[19] << 8) & 0xF00) | pIMUScale[18];
+    }
+
+    /* Accelerometer scale */
+    ctx->m_IMUScaleData.fAccelScaleX = SWITCH_ACCEL_SCALE_MULT / (float)(SWITCH_ACCEL_SCALE_OFFSET - (float)sAccelRawX) * SDL_STANDARD_GRAVITY;
+    ctx->m_IMUScaleData.fAccelScaleY = SWITCH_ACCEL_SCALE_MULT / (float)(SWITCH_ACCEL_SCALE_OFFSET - (float)sAccelRawY) * SDL_STANDARD_GRAVITY;
+    ctx->m_IMUScaleData.fAccelScaleZ = SWITCH_ACCEL_SCALE_MULT / (float)(SWITCH_ACCEL_SCALE_OFFSET - (float)sAccelRawZ) * SDL_STANDARD_GRAVITY;
+
+    /* Gyro scale */
+    ctx->m_IMUScaleData.fGyroScaleX = SWITCH_GYRO_SCALE_MULT / (float)(SWITCH_GYRO_SCALE_OFFSET - (float)sGyroRawX) * (float)M_PI / 180.0f;
+    ctx->m_IMUScaleData.fGyroScaleY = SWITCH_GYRO_SCALE_MULT / (float)(SWITCH_GYRO_SCALE_OFFSET - (float)sGyroRawY) * (float)M_PI / 180.0f;
+    ctx->m_IMUScaleData.fGyroScaleZ = SWITCH_GYRO_SCALE_MULT / (float)(SWITCH_GYRO_SCALE_OFFSET - (float)sGyroRawZ) * (float)M_PI / 180.0f;
+
+    return SDL_TRUE;
+}
+
+
 static Sint16 ApplyStickCalibrationCentered(SDL_DriverSwitch_Context *ctx, int nStick, int nAxis, Sint16 sRawValue, Sint16 sCenter)
 {
     sRawValue -= sCenter;
@@ -914,6 +1003,11 @@ HIDAPI_DriverSwitch_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joysti
             goto error;
         }
 
+        if (!LoadIMUCalibration(ctx)) {
+            SDL_SetError("Couldn't load sensor calibration");
+            goto error;
+        }
+
         if (!SetVibrationEnabled(ctx, 1)) {
             SDL_SetError("Couldn't enable vibration");
             goto error;
@@ -1146,20 +1240,6 @@ HIDAPI_DriverSwitch_SetJoystickSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joy
     return 0;
 }
 
-static float
-HIDAPI_DriverSwitch_ScaleGyro(Sint16 value)
-{
-    float result = (value / SWITCH_GYRO_SCALE) * (float)M_PI / 180.0f;
-    return result;
-}
-
-static float
-HIDAPI_DriverSwitch_ScaleAccel(Sint16 value)
-{
-    float result = (value / SWITCH_ACCEL_SCALE) * SDL_STANDARD_GRAVITY;
-    return result;
-}
-
 static void HandleInputOnlyControllerState(SDL_Joystick *joystick, SDL_DriverSwitch_Context *ctx, SwitchInputOnlyControllerStatePacket_t *packet)
 {
     Sint16 axis;
@@ -1357,13 +1437,13 @@ static void SendSensorUpdate(SDL_Joystick *joystick, SDL_DriverSwitch_Context *c
      * users will want consistent axis mappings across devices.
      */
     if (type == SDL_SENSOR_GYRO) {
-        data[0] = -HIDAPI_DriverSwitch_ScaleGyro(values[1]);
-        data[1] = HIDAPI_DriverSwitch_ScaleGyro(values[2]);
-        data[2] = -HIDAPI_DriverSwitch_ScaleGyro(values[0]);
+        data[0] = -(ctx->m_IMUScaleData.fGyroScaleY * (float)values[1]);
+        data[1] = ctx->m_IMUScaleData.fGyroScaleZ * (float)values[2];
+        data[2] = -(ctx->m_IMUScaleData.fGyroScaleX * (float)values[0]);
     } else {
-        data[0] = -HIDAPI_DriverSwitch_ScaleAccel(values[1]);
-        data[1] = HIDAPI_DriverSwitch_ScaleAccel(values[2]);
-        data[2] = -HIDAPI_DriverSwitch_ScaleAccel(values[0]);
+        data[0] = -(ctx->m_IMUScaleData.fAccelScaleY * (float)values[1]);
+        data[1] = ctx->m_IMUScaleData.fAccelScaleZ * (float)values[2];
+        data[2] = -(ctx->m_IMUScaleData.fAccelScaleX * (float)values[0]);
     }
 
     /* Right Joy-Con flips some axes, so let's flip them back for consistency */
@@ -1440,20 +1520,20 @@ static void HandleFullControllerState(SDL_Joystick *joystick, SDL_DriverSwitch_C
      * LSB of connection nibble is USB/Switch connection status
      */
     if (packet->controllerState.ucBatteryAndConnection & 0x1) {
-        joystick->epowerlevel = SDL_JOYSTICK_POWER_WIRED;
+        SDL_PrivateJoystickBatteryLevel(joystick, SDL_JOYSTICK_POWER_WIRED);
     } else {
         /* LSB of the battery nibble is used to report charging.
          * The battery level is reported from 0(empty)-8(full)
          */
         int level = (packet->controllerState.ucBatteryAndConnection & 0xE0) >> 4;
         if (level == 0) {
-            joystick->epowerlevel = SDL_JOYSTICK_POWER_EMPTY;
+            SDL_PrivateJoystickBatteryLevel(joystick, SDL_JOYSTICK_POWER_EMPTY);
         } else if (level <= 2) {
-            joystick->epowerlevel = SDL_JOYSTICK_POWER_LOW;
+            SDL_PrivateJoystickBatteryLevel(joystick, SDL_JOYSTICK_POWER_LOW);
         } else if (level <= 6) {
-            joystick->epowerlevel = SDL_JOYSTICK_POWER_MEDIUM;
+            SDL_PrivateJoystickBatteryLevel(joystick, SDL_JOYSTICK_POWER_MEDIUM);
         } else {
-            joystick->epowerlevel = SDL_JOYSTICK_POWER_FULL;
+            SDL_PrivateJoystickBatteryLevel(joystick, SDL_JOYSTICK_POWER_FULL);
         }
     }
 
diff --git a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_xbox360w.c b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_xbox360w.c
index e6e6171ab..91c15a73b 100644
--- a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_xbox360w.c
+++ b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapi_xbox360w.c
@@ -81,13 +81,13 @@ UpdatePowerLevel(SDL_Joystick *joystick, Uint8 level)
     float normalized_level = (float)level / 255.0f;
 
     if (normalized_level <= 0.05f) {
-        joystick->epowerlevel = SDL_JOYSTICK_POWER_EMPTY;
+        SDL_PrivateJoystickBatteryLevel(joystick, SDL_JOYSTICK_POWER_EMPTY);
     } else if (normalized_level <= 0.20f) {
-        joystick->epowerlevel = SDL_JOYSTICK_POWER_LOW;
+        SDL_PrivateJoystickBatteryLevel(joystick, SDL_JOYSTICK_POWER_LOW);
     } else if (normalized_level <= 0.70f) {
-        joystick->epowerlevel = SDL_JOYSTICK_POWER_MEDIUM;
+        SDL_PrivateJoystickBatteryLevel(joystick, SDL_JOYSTICK_POWER_MEDIUM);
     } else {
-        joystick->epowerlevel = SDL_JOYSTICK_POWER_FULL;
+        SDL_PrivateJoystickBatteryLevel(joystick, SDL_JOYSTICK_POWER_FULL);
     }
 }
 
diff --git a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapijoystick.c b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapijoystick.c
index f54b3c3f2..a72e6a2cd 100644
--- a/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapijoystick.c
+++ b/Engine/lib/sdl/src/joystick/hidapi/SDL_hidapijoystick.c
@@ -134,14 +134,8 @@ HIDAPI_GetDeviceDriver(SDL_HIDAPI_Device *device)
     const Uint16 USAGE_MULTIAXISCONTROLLER = 0x0008;
     int i;
     SDL_GameControllerType type;
-    SDL_JoystickGUID check_guid;
 
-    /* Make sure we have a generic GUID here, otherwise if we pass a HIDAPI
-       guid, this call will create a game controller mapping for the device.
-     */
-    check_guid = device->guid;
-    check_guid.data[14] = 0;
-    if (SDL_ShouldIgnoreJoystick(device->name, check_guid)) {
+    if (SDL_ShouldIgnoreJoystick(device->name, device->guid)) {
         return NULL;
     }
 
@@ -783,6 +777,21 @@ HIDAPI_JoystickGetDeviceName(int device_index)
     return name;
 }
 
+static const char *
+HIDAPI_JoystickGetDevicePath(int device_index)
+{
+    SDL_HIDAPI_Device *device;
+    const char *path = NULL;
+
+    device = HIDAPI_GetDeviceByIndex(device_index, NULL);
+    if (device) {
+        /* FIXME: The device could be freed after this path is returned... */
+        path = device->path;
+    }
+
+    return path;
+}
+
 static int
 HIDAPI_JoystickGetDevicePlayerIndex(int device_index)
 {
@@ -1030,6 +1039,7 @@ SDL_JoystickDriver SDL_HIDAPI_JoystickDriver =
     HIDAPI_JoystickGetCount,
     HIDAPI_JoystickDetect,
     HIDAPI_JoystickGetDeviceName,
+    HIDAPI_JoystickGetDevicePath,
     HIDAPI_JoystickGetDevicePlayerIndex,
     HIDAPI_JoystickSetDevicePlayerIndex,
     HIDAPI_JoystickGetDeviceGUID,
diff --git a/Engine/lib/sdl/src/joystick/iphoneos/SDL_mfijoystick.m b/Engine/lib/sdl/src/joystick/iphoneos/SDL_mfijoystick.m
index 38ab3fe60..c55cf7887 100644
--- a/Engine/lib/sdl/src/joystick/iphoneos/SDL_mfijoystick.m
+++ b/Engine/lib/sdl/src/joystick/iphoneos/SDL_mfijoystick.m
@@ -180,6 +180,10 @@ IsControllerXbox(GCController *controller)
 static BOOL
 IOS_AddMFIJoystickDevice(SDL_JoystickDeviceItem *device, GCController *controller)
 {
+    if ((@available(macOS 11.3, *)) && !GCController.shouldMonitorBackgroundEvents) {
+        GCController.shouldMonitorBackgroundEvents = YES;
+    }
+
     Uint16 *guid16 = (Uint16 *)device->guid.data;
     Uint16 vendor = 0;
     Uint16 product = 0;
@@ -331,11 +335,7 @@ IOS_AddMFIJoystickDevice(SDL_JoystickDeviceItem *device, GCController *controlle
         }
 
         if (SDL_strcmp(name, "Backbone One") == 0) {
-            /* The Backbone app uses the guide and share buttons */
-            if ((device->button_mask & (1 << SDL_CONTROLLER_BUTTON_GUIDE)) != 0) {
-                device->button_mask &= ~(1 << SDL_CONTROLLER_BUTTON_GUIDE);
-                --nbuttons;
-            }
+            /* The Backbone app uses share button */
             if ((device->button_mask & (1 << SDL_CONTROLLER_BUTTON_MISC1)) != 0) {
                 device->button_mask &= ~(1 << SDL_CONTROLLER_BUTTON_MISC1);
                 --nbuttons;
@@ -588,10 +588,6 @@ IOS_JoystickInit(void)
             return 0;
         }
 
-        if (@available(macOS 11.3, iOS 14.5, tvOS 14.5, *)) {
-            GCController.shouldMonitorBackgroundEvents = YES;
-        }
-
         /* For whatever reason, this always returns an empty array on
          macOS 11.0.1 */
         for (GCController *controller in [GCController controllers]) {
@@ -651,6 +647,12 @@ IOS_JoystickGetDeviceName(int device_index)
     return device ? device->name : "Unknown";
 }
 
+static const char *
+IOS_JoystickGetDevicePath(int device_index)
+{
+    return NULL;
+}
+
 static int
 IOS_JoystickGetDevicePlayerIndex(int device_index)
 {
@@ -739,7 +741,7 @@ IOS_JoystickOpen(SDL_Joystick *joystick, int device_index)
             }
 
 #ifdef ENABLE_MFI_SENSORS
-            if (@available(macOS 11.0, iOS 14.0, tvOS 14.0, *)) {
+            if (@available(macOS 10.16, iOS 14.0, tvOS 14.0, *)) {
                 GCController *controller = joystick->hwdata->controller;
                 GCMotion *motion = controller.motion;
                 if (motion && motion.hasRotationRate) {
@@ -752,7 +754,7 @@ IOS_JoystickOpen(SDL_Joystick *joystick, int device_index)
 #endif /* ENABLE_MFI_SENSORS */
 
 #ifdef ENABLE_MFI_SYSTEM_GESTURE_STATE
-            if (@available(macOS 11.0, iOS 14.0, tvOS 14.0, *)) {
+            if (@available(macOS 10.16, iOS 14.0, tvOS 14.0, *)) {
                 GCController *controller = joystick->hwdata->controller;
                 for (id key in controller.physicalInputProfile.buttons) {
                     GCControllerButtonInput *button = controller.physicalInputProfile.buttons[key];
@@ -964,7 +966,7 @@ IOS_MFIJoystickUpdate(SDL_Joystick *joystick)
             }
 
 #ifdef ENABLE_MFI_SENSORS
-            if (@available(macOS 11.0, iOS 14.0, tvOS 14.0, *)) {
+            if (@available(macOS 10.16, iOS 14.0, tvOS 14.0, *)) {
                 GCMotion *motion = controller.motion;
                 if (motion && motion.sensorsActive) {
                     float data[3];
@@ -1057,7 +1059,7 @@ IOS_MFIJoystickUpdate(SDL_Joystick *joystick)
         }
 
 #ifdef ENABLE_MFI_BATTERY
-        if (@available(macos 11.0, iOS 14.0, tvOS 14.0, *)) {
+        if (@available(macOS 10.16, iOS 14.0, tvOS 14.0, *)) {
             GCDeviceBattery *battery = controller.battery;
             if (battery) {
                 SDL_JoystickPowerLevel ePowerLevel = SDL_JOYSTICK_POWER_UNKNOWN;
@@ -1098,8 +1100,8 @@ IOS_MFIJoystickUpdate(SDL_Joystick *joystick)
 #ifdef ENABLE_MFI_RUMBLE
 
 @interface SDL_RumbleMotor : NSObject
-    @property(nonatomic,strong) CHHapticEngine *engine API_AVAILABLE(macos(11.0), ios(13.0), tvos(14.0));
-    @property(nonatomic,strong) id<CHHapticPatternPlayer> player API_AVAILABLE(macos(11.0), ios(13.0), tvos(14.0));
+    @property(nonatomic,strong) CHHapticEngine *engine API_AVAILABLE(macos(10.16), ios(13.0), tvos(14.0));
+    @property(nonatomic,strong) id<CHHapticPatternPlayer> player API_AVAILABLE(macos(10.16), ios(13.0), tvos(14.0));
     @property bool active;
 @end
 
@@ -1109,7 +1111,7 @@ IOS_MFIJoystickUpdate(SDL_Joystick *joystick)
 -(void)cleanup
 {
     @autoreleasepool {
-        if (@available(macos 11.0, iOS 14.0, tvOS 14.0, *)) {
+        if (@available(macOS 10.16, iOS 14.0, tvOS 14.0, *)) {
             if (self.player != nil) {
                 [self.player cancelAndReturnError:nil];
                 self.player = nil;
@@ -1125,7 +1127,7 @@ IOS_MFIJoystickUpdate(SDL_Joystick *joystick)
 -(int)setIntensity:(float)intensity
 {
     @autoreleasepool {
-        if (@available(macos 11.0, iOS 14.0, tvOS 14.0, *)) {
+        if (@available(macOS 10.16, iOS 14.0, tvOS 14.0, *)) {
             NSError *error = nil;
 
             if (self.engine == nil) {
@@ -1171,7 +1173,7 @@ IOS_MFIJoystickUpdate(SDL_Joystick *joystick)
     }
 }
 
--(id) initWithController:(GCController*)controller locality:(GCHapticsLocality)locality API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0))
+-(id) initWithController:(GCController*)controller locality:(GCHapticsLocality)locality API_AVAILABLE(macos(10.16), ios(14.0), tvos(14.0))
 {
     @autoreleasepool {
         self = [super init];
@@ -1271,7 +1273,7 @@ IOS_MFIJoystickUpdate(SDL_Joystick *joystick)
 static SDL_RumbleContext *IOS_JoystickInitRumble(GCController *controller)
 {
     @autoreleasepool {
-        if (@available(macOS 11.0, iOS 14.0, tvOS 14.0, *)) {
+        if (@available(macOS 10.16, iOS 14.0, tvOS 14.0, *)) {
             SDL_RumbleMotor *low_frequency_motor = [[SDL_RumbleMotor alloc] initWithController:controller locality:GCHapticsLocalityLeftHandle];
             SDL_RumbleMotor *high_frequency_motor = [[SDL_RumbleMotor alloc] initWithController:controller locality:GCHapticsLocalityRightHandle];
             SDL_RumbleMotor *left_trigger_motor = [[SDL_RumbleMotor alloc] initWithController:controller locality:GCHapticsLocalityLeftTrigger];
@@ -1299,7 +1301,7 @@ IOS_JoystickRumble(SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 h
         return SDL_SetError("Controller is no longer connected");
     }
 
-    if (@available(macOS 11.0, iOS 14.0, tvOS 14.0, *)) {
+    if (@available(macOS 10.16, iOS 14.0, tvOS 14.0, *)) {
         if (!device->rumble && device->controller && device->controller.haptics) {
             SDL_RumbleContext *rumble = IOS_JoystickInitRumble(device->controller);
             if (rumble) {
@@ -1329,7 +1331,7 @@ IOS_JoystickRumbleTriggers(SDL_Joystick *joystick, Uint16 left_rumble, Uint16 ri
         return SDL_SetError("Controller is no longer connected");
     }
 
-    if (@available(macOS 11.0, iOS 14.0, tvOS 14.0, *)) {
+    if (@available(macOS 10.16, iOS 14.0, tvOS 14.0, *)) {
         if (!device->rumble && device->controller && device->controller.haptics) {
             SDL_RumbleContext *rumble = IOS_JoystickInitRumble(device->controller);
             if (rumble) {
@@ -1362,7 +1364,7 @@ IOS_JoystickGetCapabilities(SDL_Joystick *joystick)
             return 0;
         }
 
-        if (@available(macos 11.0, iOS 14.0, tvOS 14.0, *)) {
+        if (@available(macOS 10.16, iOS 14.0, tvOS 14.0, *)) {
             GCController *controller = device->controller;
             #ifdef ENABLE_MFI_LIGHT
             if (controller.light) {
@@ -1399,7 +1401,7 @@ IOS_JoystickSetLED(SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
             return SDL_SetError("Controller is no longer connected");
         }
 
-        if (@available(macos 11.0, iOS 14.0, tvOS 14.0, *)) {
+        if (@available(macOS 10.16, iOS 14.0, tvOS 14.0, *)) {
             GCController *controller = device->controller;
             GCDeviceLight *light = controller.light;
             if (light) {
@@ -1432,7 +1434,7 @@ IOS_JoystickSetSensorsEnabled(SDL_Joystick *joystick, SDL_bool enabled)
             return SDL_SetError("Controller is no longer connected");
         }
 
-        if (@available(macOS 11.0, iOS 14.0, tvOS 14.0, *)) {
+        if (@available(macOS 10.16, iOS 14.0, tvOS 14.0, *)) {
             GCController *controller = device->controller;
             GCMotion *motion = controller.motion;
             if (motion) {
@@ -1495,7 +1497,7 @@ IOS_JoystickClose(SDL_Joystick *joystick)
             controller.playerIndex = -1;
 
 #ifdef ENABLE_MFI_SYSTEM_GESTURE_STATE
-            if (@available(macOS 11.0, iOS 14.0, tvOS 14.0, *)) {
+            if (@available(macOS 10.16, iOS 14.0, tvOS 14.0, *)) {
                 for (id key in controller.physicalInputProfile.buttons) {
                     GCControllerButtonInput *button = controller.physicalInputProfile.buttons[key];
                     if ([button isBoundToSystemGesture]) {
@@ -1593,7 +1595,7 @@ SDL_bool IOS_SupportedHIDDevice(IOHIDDeviceRef device)
 static void
 GetAppleSFSymbolsNameForElement(GCControllerElement *element, char *name)
 {
-    if (@available(macos 11.0, iOS 14.0, tvOS 14.0, *)) {
+    if (@available(macOS 10.16, iOS 14.0, tvOS 14.0, *)) {
         if (element) {
             [element.sfSymbolsName getCString: name maxLength: 255 encoding: NSASCIIStringEncoding];
         }
@@ -1627,7 +1629,7 @@ IOS_GameControllerGetAppleSFSymbolsNameForButton(SDL_GameController *gamecontrol
     elementName[0] = '\0';
 #if defined(SDL_JOYSTICK_MFI) && defined(ENABLE_PHYSICAL_INPUT_PROFILE)
     if (gamecontroller && SDL_GameControllerGetJoystick(gamecontroller)->driver == &SDL_IOS_JoystickDriver) {
-        if (@available(iOS 14.0, tvOS 14.0, macOS 11.0, *)) {
+        if (@available(macOS 10.16, iOS 14.0, tvOS 14.0, *)) {
             GCController *controller = SDL_GameControllerGetJoystick(gamecontroller)->hwdata->controller;
             if ([controller respondsToSelector:@selector(physicalInputProfile)]) {
                 NSDictionary<NSString *,GCControllerElement *> *elements = controller.physicalInputProfile.elements;
@@ -1740,7 +1742,7 @@ IOS_GameControllerGetAppleSFSymbolsNameForAxis(SDL_GameController *gamecontrolle
     elementName[0] = '\0';
 #if defined(SDL_JOYSTICK_MFI) && defined(ENABLE_PHYSICAL_INPUT_PROFILE)
     if (gamecontroller && SDL_GameControllerGetJoystick(gamecontroller)->driver == &SDL_IOS_JoystickDriver) {
-        if (@available(iOS 14.0, tvOS 14.0, macOS 11.0, *)) {
+        if (@available(macOS 10.16, iOS 14.0, tvOS 14.0, *)) {
             GCController *controller = SDL_GameControllerGetJoystick(gamecontroller)->hwdata->controller;
             if ([controller respondsToSelector:@selector(physicalInputProfile)]) {
                 NSDictionary<NSString *,GCControllerElement *> *elements = controller.physicalInputProfile.elements;
@@ -1781,6 +1783,7 @@ SDL_JoystickDriver SDL_IOS_JoystickDriver =
     IOS_JoystickGetCount,
     IOS_JoystickDetect,
     IOS_JoystickGetDeviceName,
+    IOS_JoystickGetDevicePath,
     IOS_JoystickGetDevicePlayerIndex,
     IOS_JoystickSetDevicePlayerIndex,
     IOS_JoystickGetDeviceGUID,
diff --git a/Engine/lib/sdl/src/joystick/linux/SDL_sysjoystick.c b/Engine/lib/sdl/src/joystick/linux/SDL_sysjoystick.c
index a268c0d9b..307dd5642 100644
--- a/Engine/lib/sdl/src/joystick/linux/SDL_sysjoystick.c
+++ b/Engine/lib/sdl/src/joystick/linux/SDL_sysjoystick.c
@@ -82,6 +82,10 @@
 #define DEBUG_INPUT_EVENTS 1
 #endif
 
+#if 0
+#define DEBUG_GAMEPAD_MAPPING 1
+#endif
+
 typedef enum
 {
     ENUMERATION_UNSET,
@@ -493,21 +497,6 @@ static void SteamControllerDisconnectedCallback(int device_instance)
     }
 }
 
-#ifdef HAVE_INOTIFY
-#ifdef HAVE_INOTIFY_INIT1
-static int SDL_inotify_init1(void) {
-    return inotify_init1(IN_NONBLOCK | IN_CLOEXEC);
-}
-#else
-static int SDL_inotify_init1(void) {
-    int fd = inotify_init();
-    if (fd  < 0) return -1;
-    fcntl(fd, F_SETFL, O_NONBLOCK);
-    fcntl(fd, F_SETFD, FD_CLOEXEC);
-    return fd;
-}
-#endif
-
 static int
 StrHasPrefix(const char *string, const char *prefix)
 {
@@ -562,6 +551,21 @@ IsJoystickDeviceNode(const char *node)
     }
 }
 
+#ifdef HAVE_INOTIFY
+#ifdef HAVE_INOTIFY_INIT1
+static int SDL_inotify_init1(void) {
+    return inotify_init1(IN_NONBLOCK | IN_CLOEXEC);
+}
+#else
+static int SDL_inotify_init1(void) {
+    int fd = inotify_init();
+    if (fd  < 0) return -1;
+    fcntl(fd, F_SETFL, O_NONBLOCK);
+    fcntl(fd, F_SETFD, FD_CLOEXEC);
+    return fd;
+}
+#endif
+
 static void
 LINUX_InotifyJoystickDetect(void)
 {
@@ -854,13 +858,18 @@ JoystickByDevIndex(int device_index)
     return item;
 }
 
-/* Function to get the device-dependent name of a joystick */
 static const char *
 LINUX_JoystickGetDeviceName(int device_index)
 {
     return JoystickByDevIndex(device_index)->name;
 }
 
+static const char *
+LINUX_JoystickGetDevicePath(int device_index)
+{
+    return JoystickByDevIndex(device_index)->path;
+}
+
 static int
 LINUX_JoystickGetDevicePlayerIndex(int device_index)
 {
@@ -921,6 +930,37 @@ allocate_balldata(SDL_Joystick *joystick)
     return (0);
 }
 
+static SDL_bool
+GuessIfAxesAreDigitalHat(struct input_absinfo *absinfo_x, struct input_absinfo *absinfo_y)
+{
+    /* A "hat" is assumed to be a digital input with at most 9 possible states
+     * (3 per axis: negative/zero/positive), as opposed to a true "axis" which
+     * can report a continuous range of possible values. Unfortunately the Linux
+     * joystick interface makes no distinction between digital hat axes and any
+     * other continuous analog axis, so we have to guess. */
+
+    /* If both axes are missing, they're not anything. */
+    if (!absinfo_x && !absinfo_y)
+        return SDL_FALSE;
+
+    /* If the hint says so, treat all hats as digital. */
+    if (SDL_GetHintBoolean(SDL_HINT_LINUX_DIGITAL_HATS, SDL_FALSE))
+        return SDL_TRUE;
+
+    /* If both axes have ranges constrained between -1 and 1, they're definitely digital. */
+    if ((!absinfo_x || (absinfo_x->minimum == -1 && absinfo_x->maximum == 1)) &&
+        (!absinfo_y || (absinfo_y->minimum == -1 && absinfo_y->maximum == 1)))
+        return SDL_TRUE;
+
+    /* If both axes lack fuzz, flat, and resolution values, they're probably digital. */
+    if ((!absinfo_x || (!absinfo_x->fuzz && !absinfo_x->flat && !absinfo_x->resolution)) &&
+        (!absinfo_y || (!absinfo_y->fuzz && !absinfo_y->flat && !absinfo_y->resolution)))
+        return SDL_TRUE;
+
+    /* Otherwise, treat them as analog. */
+    return SDL_FALSE;
+}
+
 static void
 ConfigJoystick(SDL_Joystick *joystick, int fd)
 {
@@ -931,6 +971,7 @@ ConfigJoystick(SDL_Joystick *joystick, int fd)
     unsigned long ffbit[NBITS(FF_MAX)] = { 0 };
     Uint8 key_pam_size, abs_pam_size;
     SDL_bool use_deadzones = SDL_GetHintBoolean(SDL_HINT_LINUX_JOYSTICK_DEADZONES, SDL_FALSE);
+    SDL_bool use_hat_deadzones = SDL_GetHintBoolean(SDL_HINT_LINUX_HAT_DEADZONES, SDL_TRUE);
 
     /* See if this device uses the new unified event API */
     if ((ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keybit)), keybit) >= 0) &&
@@ -958,10 +999,45 @@ ConfigJoystick(SDL_Joystick *joystick, int fd)
                 ++joystick->nbuttons;
             }
         }
+        for (i = ABS_HAT0X; i <= ABS_HAT3Y; i += 2) {
+            int hat_x = -1;
+            int hat_y = -1;
+            struct input_absinfo absinfo_x;
+            struct input_absinfo absinfo_y;
+            if (test_bit(i, absbit))
+                hat_x = ioctl(fd, EVIOCGABS(i), &absinfo_x);
+            if (test_bit(i + 1, absbit))
+                hat_y = ioctl(fd, EVIOCGABS(i + 1), &absinfo_y);
+            if (GuessIfAxesAreDigitalHat((hat_x < 0 ? (void*)0 : &absinfo_x),
+                                         (hat_y < 0 ? (void*)0 : &absinfo_y))) {
+                const int hat_index = (i - ABS_HAT0X) / 2;
+                struct hat_axis_correct *correct = &joystick->hwdata->hat_correct[hat_index];
+#ifdef DEBUG_INPUT_EVENTS
+                SDL_Log("Joystick has digital hat: #%d\n", hat_index);
+                if (hat_x >= 0) {
+                    SDL_Log("X Values = { val:%d, min:%d, max:%d, fuzz:%d, flat:%d, res:%d }\n",
+                            absinfo_x.value, absinfo_x.minimum, absinfo_x.maximum,
+                            absinfo_x.fuzz, absinfo_x.flat, absinfo_x.resolution);
+                }
+                if (hat_y >= 0) {
+                    SDL_Log("Y Values = { val:%d, min:%d, max:%d, fuzz:%d, flat:%d, res:%d }\n",
+                            absinfo_y.value, absinfo_y.minimum, absinfo_y.maximum,
+                            absinfo_y.fuzz, absinfo_y.flat, absinfo_y.resolution);
+                }
+#endif /* DEBUG_INPUT_EVENTS */
+                joystick->hwdata->hats_indices[hat_index] = joystick->nhats;
+                joystick->hwdata->has_hat[hat_index] = SDL_TRUE;
+                correct->use_deadzones = use_hat_deadzones;
+                correct->minimum[0] = (hat_x < 0) ? -1 : absinfo_x.minimum;
+                correct->maximum[0] = (hat_x < 0) ?  1 : absinfo_x.maximum;
+                correct->minimum[1] = (hat_y < 0) ? -1 : absinfo_y.minimum;
+                correct->maximum[1] = (hat_y < 0) ?  1 : absinfo_y.maximum;
+                ++joystick->nhats;
+            }
+        }
         for (i = 0; i < ABS_MAX; ++i) {
-            /* Skip hats */
-            if (i == ABS_HAT0X) {
-                i = ABS_HAT3Y;
+            /* Skip digital hats */
+            if (joystick->hwdata->has_hat[(i - ABS_HAT0X) / 2]) {
                 continue;
             }
             if (test_bit(i, absbit)) {
@@ -973,9 +1049,9 @@ ConfigJoystick(SDL_Joystick *joystick, int fd)
                 }
 #ifdef DEBUG_INPUT_EVENTS
                 SDL_Log("Joystick has absolute axis: 0x%.2x\n", i);
-                SDL_Log("Values = { %d, %d, %d, %d, %d }\n",
+                SDL_Log("Values = { val:%d, min:%d, max:%d, fuzz:%d, flat:%d, res:%d }\n",
                         absinfo.value, absinfo.minimum, absinfo.maximum,
-                        absinfo.fuzz, absinfo.flat);
+                        absinfo.fuzz, absinfo.flat, absinfo.resolution);
 #endif /* DEBUG_INPUT_EVENTS */
                 joystick->hwdata->abs_map[i] = joystick->naxes;
                 joystick->hwdata->has_abs[i] = SDL_TRUE;
@@ -1003,24 +1079,6 @@ ConfigJoystick(SDL_Joystick *joystick, int fd)
                 ++joystick->naxes;
             }
         }
-        for (i = ABS_HAT0X; i <= ABS_HAT3Y; i += 2) {
-            if (test_bit(i, absbit) || test_bit(i + 1, absbit)) {
-                struct input_absinfo absinfo;
-                int hat_index = (i - ABS_HAT0X) / 2;
-
-                if (ioctl(fd, EVIOCGABS(i), &absinfo) < 0) {
-                    continue;
-                }
-#ifdef DEBUG_INPUT_EVENTS
-                SDL_Log("Joystick has hat %d\n", hat_index);
-                SDL_Log("Values = { %d, %d, %d, %d, %d }\n",
-                        absinfo.value, absinfo.minimum, absinfo.maximum,
-                        absinfo.fuzz, absinfo.flat);
-#endif /* DEBUG_INPUT_EVENTS */
-                joystick->hwdata->hats_indices[hat_index] = joystick->nhats++;
-                joystick->hwdata->has_hat[hat_index] = SDL_TRUE;
-            }
-        }
         if (test_bit(REL_X, relbit) || test_bit(REL_Y, relbit)) {
             ++joystick->nballs;
         }
@@ -1066,14 +1124,19 @@ ConfigJoystick(SDL_Joystick *joystick, int fd)
         for (i = 0; i < abs_pam_size; ++i) {
             Uint8 code = joystick->hwdata->abs_pam[i];
 
+            // TODO: is there any way to detect analog hats in advance via this API?
             if (code >= ABS_HAT0X && code <= ABS_HAT3Y) {
                 int hat_index = (code - ABS_HAT0X) / 2;
                 if (!joystick->hwdata->has_hat[hat_index]) {
 #ifdef DEBUG_INPUT_EVENTS
-                    SDL_Log("Joystick has hat %d\n", hat_index);
+                    SDL_Log("Joystick has digital hat: #%d\n", hat_index);
 #endif
                     joystick->hwdata->hats_indices[hat_index] = joystick->nhats++;
                     joystick->hwdata->has_hat[hat_index] = SDL_TRUE;
+                    joystick->hwdata->hat_correct[hat_index].minimum[0] = -1;
+                    joystick->hwdata->hat_correct[hat_index].maximum[0] =  1;
+                    joystick->hwdata->hat_correct[hat_index].minimum[1] = -1;
+                    joystick->hwdata->hat_correct[hat_index].maximum[1] =  1;
                 }
             } else {
 #ifdef DEBUG_INPUT_EVENTS
@@ -1272,26 +1335,48 @@ LINUX_JoystickSetSensorsEnabled(SDL_Joystick *joystick, SDL_bool enabled)
 }
 
 static void
-HandleHat(SDL_Joystick *stick, Uint8 hat, int axis, int value)
+HandleHat(SDL_Joystick *stick, int hatidx, int axis, int value)
 {
+    const int hatnum = stick->hwdata->hats_indices[hatidx];
     struct hwdata_hat *the_hat;
+    struct hat_axis_correct *correct;
     const Uint8 position_map[3][3] = {
         {SDL_HAT_LEFTUP, SDL_HAT_UP, SDL_HAT_RIGHTUP},
         {SDL_HAT_LEFT, SDL_HAT_CENTERED, SDL_HAT_RIGHT},
         {SDL_HAT_LEFTDOWN, SDL_HAT_DOWN, SDL_HAT_RIGHTDOWN}
     };
 
-    the_hat = &stick->hwdata->hats[hat];
+    the_hat = &stick->hwdata->hats[hatnum];
+    correct = &stick->hwdata->hat_correct[hatidx];
+    /* Hopefully we detected any analog axes and left them as is rather than trying
+     * to use them as digital hats, but just in case, the deadzones here will
+     * prevent the slightest of twitches on an analog axis from registering as a hat
+     * movement. If the axes really are digital, this won't hurt since they should
+     * only ever be sending min, 0, or max anyway. */
     if (value < 0) {
-        value = 0;
-    } else if (value == 0) {
-        value = 1;
+        if (value <= correct->minimum[axis]) {
+            correct->minimum[axis] = value;
+            value = 0;
+        } else if (!correct->use_deadzones || value < correct->minimum[axis] / 3) {
+            value = 0;
+        } else {
+            value = 1;
+        }
     } else if (value > 0) {
-        value = 2;
+        if (value >= correct->maximum[axis]) {
+            correct->maximum[axis] = value;
+            value = 2;
+        } else if (!correct->use_deadzones || value > correct->maximum[axis] / 3) {
+            value = 2;
+        } else {
+            value = 1;
+        }
+    } else { // value == 0
+        value = 1;
     }
     if (value != the_hat->axis[axis]) {
         the_hat->axis[axis] = value;
-        SDL_PrivateJoystickHat(stick, hat,
+        SDL_PrivateJoystickHat(stick, hatnum,
                                position_map[the_hat->axis[1]][the_hat->axis[0]]);
     }
 }
@@ -1346,10 +1431,7 @@ PollAllValues(SDL_Joystick *joystick)
 
     /* Poll all axis */
     for (i = ABS_X; i < ABS_MAX; i++) {
-        if (i == ABS_HAT0X) {  /* we handle hats in the next loop, skip them for now. */
-            i = ABS_HAT3Y;
-            continue;
-        }
+        /* We don't need to test for digital hats here, they won't have has_abs[] set */
         if (joystick->hwdata->has_abs[i]) {
             if (ioctl(joystick->hwdata->fd, EVIOCGABS(i), &absinfo) >= 0) {
                 absinfo.value = AxisCorrect(joystick, i, absinfo.value);
@@ -1365,15 +1447,16 @@ PollAllValues(SDL_Joystick *joystick)
         }
     }
 
-    /* Poll all hats */
+    /* Poll all digital hats */
     for (i = ABS_HAT0X; i <= ABS_HAT3Y; i++) {
         const int baseaxis = i - ABS_HAT0X;
         const int hatidx = baseaxis / 2;
         SDL_assert(hatidx < SDL_arraysize(joystick->hwdata->has_hat));
+        /* We don't need to test for analog axes here, they won't have has_hat[] set */
         if (joystick->hwdata->has_hat[hatidx]) {
             if (ioctl(joystick->hwdata->fd, EVIOCGABS(i), &absinfo) >= 0) {
                 const int hataxis = baseaxis % 2;
-                HandleHat(joystick, joystick->hwdata->hats_indices[hatidx], hataxis, absinfo.value);
+                HandleHat(joystick, hatidx, hataxis, absinfo.value);
             }
         }
     }
@@ -1401,7 +1484,7 @@ static void
 HandleInputEvents(SDL_Joystick *joystick)
 {
     struct input_event events[32];
-    int i, len, code;
+    int i, len, code, hat_index;
 
     if (joystick->hwdata->fresh) {
         PollAllValues(joystick);
@@ -1436,9 +1519,11 @@ HandleInputEvents(SDL_Joystick *joystick)
                 case ABS_HAT2Y:
                 case ABS_HAT3X:
                 case ABS_HAT3Y:
-                    code -= ABS_HAT0X;
-                    HandleHat(joystick, joystick->hwdata->hats_indices[code / 2], code % 2, events[i].value);
-                    break;
+                    hat_index = (code - ABS_HAT0X) / 2;
+                    if (joystick->hwdata->has_hat[hat_index]) {
+                        HandleHat(joystick, hat_index, code % 2, events[i].value);
+                        break;
+                    }
                 default:
                     events[i].value = AxisCorrect(joystick, code, events[i].value);
                     SDL_PrivateJoystickAxis(joystick,
@@ -1491,7 +1576,7 @@ static void
 HandleClassicEvents(SDL_Joystick *joystick)
 {
     struct js_event events[32];
-    int i, len, code;
+    int i, len, code, hat_index;
 
     joystick->hwdata->fresh = SDL_FALSE;
     while ((len = read(joystick->hwdata->fd, events, (sizeof events))) > 0) {
@@ -1515,9 +1600,11 @@ HandleClassicEvents(SDL_Joystick *joystick)
                 case ABS_HAT2Y:
                 case ABS_HAT3X:
                 case ABS_HAT3Y:
-                    code -= ABS_HAT0X;
-                    HandleHat(joystick, joystick->hwdata->hats_indices[code / 2], code % 2, events[i].value);
-                    break;
+                    hat_index = (code - ABS_HAT0X) / 2;
+                    if (joystick->hwdata->has_hat[hat_index]) {
+                        HandleHat(joystick, hat_index, code % 2, events[i].value);
+                        break;
+                    }
                 default:
                     SDL_PrivateJoystickAxis(joystick,
                                             joystick->hwdata->abs_map[code],
@@ -1623,10 +1710,14 @@ LINUX_JoystickGetGamepadMapping(int device_index, SDL_GamepadMapping *out)
 {
     SDL_Joystick *joystick;
     SDL_joylist_item *item = JoystickByDevIndex(device_index);
+    unsigned int mapped;
 
     if (item->checked_mapping) {
         if (item->mapping) {
             SDL_memcpy(out, item->mapping, sizeof(*out));
+#ifdef DEBUG_GAMEPAD_MAPPING
+            SDL_Log("Prior mapping for device %d", device_index);
+#endif
             return SDL_TRUE;
         } else {
             return SDL_FALSE;
@@ -1674,11 +1765,17 @@ LINUX_JoystickGetGamepadMapping(int device_index, SDL_GamepadMapping *out)
     if (joystick->hwdata->has_key[BTN_A]) {
         out->a.kind = EMappingKind_Button;
         out->a.target = joystick->hwdata->key_map[BTN_A];
+#ifdef DEBUG_GAMEPAD_MAPPING
+        SDL_Log("Mapped A to button %d (BTN_A)", out->a.target);
+#endif
     }
 
     if (joystick->hwdata->has_key[BTN_B]) {
         out->b.kind = EMappingKind_Button;
         out->b.target = joystick->hwdata->key_map[BTN_B];
+#ifdef DEBUG_GAMEPAD_MAPPING
+        SDL_Log("Mapped B to button %d (BTN_B)", out->b.target);
+#endif
     }
 
     /* Xbox controllers use BTN_X and BTN_Y, and PS4 controllers use BTN_WEST and BTN_NORTH */
@@ -1686,47 +1783,74 @@ LINUX_JoystickGetGamepadMapping(int device_index, SDL_GamepadMapping *out)
         if (joystick->hwdata->has_key[BTN_WEST]) {
             out->x.kind = EMappingKind_Button;
             out->x.target = joystick->hwdata->key_map[BTN_WEST];
+#ifdef DEBUG_GAMEPAD_MAPPING
+            SDL_Log("Mapped X to button %d (BTN_WEST)", out->x.target);
+#endif
         }
 
         if (joystick->hwdata->has_key[BTN_NORTH]) {
             out->y.kind = EMappingKind_Button;
             out->y.target = joystick->hwdata->key_map[BTN_NORTH];
+#ifdef DEBUG_GAMEPAD_MAPPING
+            SDL_Log("Mapped Y to button %d (BTN_NORTH)", out->y.target);
+#endif
         }
     } else {
         if (joystick->hwdata->has_key[BTN_X]) {
             out->x.kind = EMappingKind_Button;
             out->x.target = joystick->hwdata->key_map[BTN_X];
+#ifdef DEBUG_GAMEPAD_MAPPING
+            SDL_Log("Mapped X to button %d (BTN_X)", out->x.target);
+#endif
         }
 
         if (joystick->hwdata->has_key[BTN_Y]) {
             out->y.kind = EMappingKind_Button;
             out->y.target = joystick->hwdata->key_map[BTN_Y];
+#ifdef DEBUG_GAMEPAD_MAPPING
+            SDL_Log("Mapped Y to button %d (BTN_Y)", out->y.target);
+#endif
         }
     }
 
     if (joystick->hwdata->has_key[BTN_SELECT]) {
         out->back.kind = EMappingKind_Button;
         out->back.target = joystick->hwdata->key_map[BTN_SELECT];
+#ifdef DEBUG_GAMEPAD_MAPPING
+        SDL_Log("Mapped BACK to button %d (BTN_SELECT)", out->back.target);
+#endif
     }
 
     if (joystick->hwdata->has_key[BTN_START]) {
         out->start.kind = EMappingKind_Button;
         out->start.target = joystick->hwdata->key_map[BTN_START];
+#ifdef DEBUG_GAMEPAD_MAPPING
+        SDL_Log("Mapped START to button %d (BTN_START)", out->start.target);
+#endif
     }
 
     if (joystick->hwdata->has_key[BTN_THUMBL]) {
         out->leftstick.kind = EMappingKind_Button;
         out->leftstick.target = joystick->hwdata->key_map[BTN_THUMBL];
+#ifdef DEBUG_GAMEPAD_MAPPING
+        SDL_Log("Mapped LEFTSTICK to button %d (BTN_THUMBL)", out->leftstick.target);
+#endif
     }
 
     if (joystick->hwdata->has_key[BTN_THUMBR]) {
         out->rightstick.kind = EMappingKind_Button;
         out->rightstick.target = joystick->hwdata->key_map[BTN_THUMBR];
+#ifdef DEBUG_GAMEPAD_MAPPING
+        SDL_Log("Mapped RIGHTSTICK to button %d (BTN_THUMBR)", out->rightstick.target);
+#endif
     }
 
     if (joystick->hwdata->has_key[BTN_MODE]) {
         out->guide.kind = EMappingKind_Button;
         out->guide.target = joystick->hwdata->key_map[BTN_MODE];
+#ifdef DEBUG_GAMEPAD_MAPPING
+        SDL_Log("Mapped GUIDE to button %d (BTN_MODE)", out->guide.target);
+#endif
     }
 
     /*
@@ -1734,84 +1858,191 @@ LINUX_JoystickGetGamepadMapping(int device_index, SDL_GamepadMapping *out)
        can be digital, or analog, or both at the same time.
      */
 
-    /* Prefer digital shoulder buttons, but settle for analog if missing. */
+    /* Prefer digital shoulder buttons, but settle for digital or analog hat. */
+    mapped = 0;
+
     if (joystick->hwdata->has_key[BTN_TL]) {
         out->leftshoulder.kind = EMappingKind_Button;
         out->leftshoulder.target = joystick->hwdata->key_map[BTN_TL];
+        mapped |= 0x1;
+#ifdef DEBUG_GAMEPAD_MAPPING
+        SDL_Log("Mapped LEFTSHOULDER to button %d (BTN_TL)", out->leftshoulder.target);
+#endif
     }
 
     if (joystick->hwdata->has_key[BTN_TR]) {
         out->rightshoulder.kind = EMappingKind_Button;
         out->rightshoulder.target = joystick->hwdata->key_map[BTN_TR];
+        mapped |= 0x2;
+#ifdef DEBUG_GAMEPAD_MAPPING
+        SDL_Log("Mapped RIGHTSHOULDER to button %d (BTN_TR)", out->rightshoulder.target);
+#endif
     }
 
-    if (joystick->hwdata->has_hat[1] && /* Check if ABS_HAT1{X, Y} is available. */
-       (!joystick->hwdata->has_key[BTN_TL] || !joystick->hwdata->has_key[BTN_TR])) {
+    if (mapped != 0x3 && joystick->hwdata->has_hat[1]) {
         int hat = joystick->hwdata->hats_indices[1] << 4;
         out->leftshoulder.kind = EMappingKind_Hat;
         out->rightshoulder.kind = EMappingKind_Hat;
         out->leftshoulder.target = hat | 0x4;
         out->rightshoulder.target = hat | 0x2;
+        mapped |= 0x3;
+#ifdef DEBUG_GAMEPAD_MAPPING
+        SDL_Log("Mapped LEFT+RIGHTSHOULDER to hat 1 (ABS_HAT1X, ABS_HAT1Y)");
+#endif
     }
 
-    /* Prefer analog triggers, but settle for digital if missing. */
-    if (joystick->hwdata->has_hat[2]) { /* Check if ABS_HAT2{X,Y} is available. */
+    if (!(mapped & 0x1) && joystick->hwdata->has_abs[ABS_HAT1Y]) {
+        out->leftshoulder.kind = EMappingKind_Axis;
+        out->leftshoulder.target = joystick->hwdata->abs_map[ABS_HAT1Y];
+        mapped |= 0x1;
+#ifdef DEBUG_GAMEPAD_MAPPING
+        SDL_Log("Mapped LEFTSHOULDER to axis %d (ABS_HAT1Y)", out->leftshoulder.target);
+#endif
+    }
+
+    if (!(mapped & 0x2) && joystick->hwdata->has_abs[ABS_HAT1X]) {
+        out->rightshoulder.kind = EMappingKind_Axis;
+        out->rightshoulder.target = joystick->hwdata->abs_map[ABS_HAT1X];
+        mapped |= 0x2;
+#ifdef DEBUG_GAMEPAD_MAPPING
+        SDL_Log("Mapped RIGHTSHOULDER to axis %d (ABS_HAT1X)", out->rightshoulder.target);
+#endif
+    }
+
+    /* Prefer analog triggers, but settle for digital hat or buttons. */
+    mapped = 0;
+
+    if (joystick->hwdata->has_abs[ABS_HAT2Y]) {
+        out->lefttrigger.kind = EMappingKind_Axis;
+        out->lefttrigger.target = joystick->hwdata->abs_map[ABS_HAT2Y];
+        mapped |= 0x1;
+#ifdef DEBUG_GAMEPAD_MAPPING
+        SDL_Log("Mapped LEFTTRIGGER to axis %d (ABS_HAT2Y)", out->lefttrigger.target);
+#endif
+    } else if (joystick->hwdata->has_abs[ABS_Z]) {
+        out->lefttrigger.kind = EMappingKind_Axis;
+        out->lefttrigger.target = joystick->hwdata->abs_map[ABS_Z];
+        mapped |= 0x1;
+#ifdef DEBUG_GAMEPAD_MAPPING
+        SDL_Log("Mapped LEFTTRIGGER to axis %d (ABS_Z)", out->lefttrigger.target);
+#endif
+    }
+
+    if (joystick->hwdata->has_abs[ABS_HAT2X]) {
+        out->righttrigger.kind = EMappingKind_Axis;
+        out->righttrigger.target = joystick->hwdata->abs_map[ABS_HAT2X];
+        mapped |= 0x2;
+#ifdef DEBUG_GAMEPAD_MAPPING
+        SDL_Log("Mapped RIGHTTRIGGER to axis %d (ABS_HAT2X)", out->righttrigger.target);
+#endif
+    } else if (joystick->hwdata->has_abs[ABS_RZ]) {
+        out->righttrigger.kind = EMappingKind_Axis;
+        out->righttrigger.target = joystick->hwdata->abs_map[ABS_RZ];
+        mapped |= 0x2;
+#ifdef DEBUG_GAMEPAD_MAPPING
+        SDL_Log("Mapped RIGHTTRIGGER to axis %d (ABS_RZ)", out->righttrigger.target);
+#endif
+    }
+
+    if (mapped != 0x3 && joystick->hwdata->has_hat[2]) {
         int hat = joystick->hwdata->hats_indices[2] << 4;
         out->lefttrigger.kind = EMappingKind_Hat;
         out->righttrigger.kind = EMappingKind_Hat;
         out->lefttrigger.target = hat | 0x4;
         out->righttrigger.target = hat | 0x2;
-    } else {
-        if (joystick->hwdata->has_abs[ABS_Z]) {
-            out->lefttrigger.kind = EMappingKind_Axis;
-            out->lefttrigger.target = joystick->hwdata->abs_map[ABS_Z];
-        } else if (joystick->hwdata->has_key[BTN_TL2]) {
-            out->lefttrigger.kind = EMappingKind_Button;
-            out->lefttrigger.target = joystick->hwdata->key_map[BTN_TL2];
-        }
-
-        if (joystick->hwdata->has_abs[ABS_RZ]) {
-            out->righttrigger.kind = EMappingKind_Axis;
-            out->righttrigger.target = joystick->hwdata->abs_map[ABS_RZ];
-        } else if (joystick->hwdata->has_key[BTN_TR2]) {
-            out->righttrigger.kind = EMappingKind_Button;
-            out->righttrigger.target = joystick->hwdata->key_map[BTN_TR2];
-        }
+        mapped |= 0x3;
+#ifdef DEBUG_GAMEPAD_MAPPING
+        SDL_Log("Mapped LEFT+RIGHTTRIGGER to hat 2 (ABS_HAT2X, ABS_HAT2Y)");
+#endif
     }
 
-    /* Prefer digital D-Pad, but settle for analog if missing. */
+    if (!(mapped & 0x1) && joystick->hwdata->has_key[BTN_TL2]) {
+        out->lefttrigger.kind = EMappingKind_Button;
+        out->lefttrigger.target = joystick->hwdata->key_map[BTN_TL2];
+        mapped |= 0x1;
+#ifdef DEBUG_GAMEPAD_MAPPING
+        SDL_Log("Mapped LEFTTRIGGER to button %d (BTN_TL2)", out->lefttrigger.target);
+#endif
+    }
+
+    if (!(mapped & 0x2) && joystick->hwdata->has_key[BTN_TR2]) {
+        out->righttrigger.kind = EMappingKind_Button;
+        out->righttrigger.target = joystick->hwdata->key_map[BTN_TR2];
+        mapped |= 0x2;
+#ifdef DEBUG_GAMEPAD_MAPPING
+        SDL_Log("Mapped RIGHTTRIGGER to button %d (BTN_TR2)", out->righttrigger.target);
+#endif
+    }
+
+    /* Prefer digital D-Pad buttons, but settle for digital or analog hat. */
+    mapped = 0;
+
     if (joystick->hwdata->has_key[BTN_DPAD_UP]) {
         out->dpup.kind = EMappingKind_Button;
         out->dpup.target = joystick->hwdata->key_map[BTN_DPAD_UP];
+        mapped |= 0x1;
+#ifdef DEBUG_GAMEPAD_MAPPING
+        SDL_Log("Mapped DPUP to button %d (BTN_DPAD_UP)", out->dpup.target);
+#endif
     }
 
     if (joystick->hwdata->has_key[BTN_DPAD_DOWN]) {
         out->dpdown.kind = EMappingKind_Button;
         out->dpdown.target = joystick->hwdata->key_map[BTN_DPAD_DOWN];
+        mapped |= 0x2;
+#ifdef DEBUG_GAMEPAD_MAPPING
+        SDL_Log("Mapped DPDOWN to button %d (BTN_DPAD_DOWN)", out->dpdown.target);
+#endif
     }
 
     if (joystick->hwdata->has_key[BTN_DPAD_LEFT]) {
         out->dpleft.kind = EMappingKind_Button;
         out->dpleft.target = joystick->hwdata->key_map[BTN_DPAD_LEFT];
+        mapped |= 0x4;
+#ifdef DEBUG_GAMEPAD_MAPPING
+        SDL_Log("Mapped DPLEFT to button %d (BTN_DPAD_LEFT)", out->dpleft.target);
+#endif
     }
 
     if (joystick->hwdata->has_key[BTN_DPAD_RIGHT]) {
         out->dpright.kind = EMappingKind_Button;
         out->dpright.target = joystick->hwdata->key_map[BTN_DPAD_RIGHT];
+        mapped |= 0x8;
+#ifdef DEBUG_GAMEPAD_MAPPING
+        SDL_Log("Mapped DPRIGHT to button %d (BTN_DPAD_RIGHT)", out->dpright.target);
+#endif
     }
 
-    if (joystick->hwdata->has_hat[0] && /* Check if ABS_HAT0{X,Y} is available. */
-       (!joystick->hwdata->has_key[BTN_DPAD_LEFT] || !joystick->hwdata->has_key[BTN_DPAD_RIGHT] ||
-        !joystick->hwdata->has_key[BTN_DPAD_UP] || !joystick->hwdata->has_key[BTN_DPAD_DOWN])) {
-       int hat = joystick->hwdata->hats_indices[0] << 4;
-       out->dpleft.kind = EMappingKind_Hat;
-       out->dpright.kind = EMappingKind_Hat;
-       out->dpup.kind = EMappingKind_Hat;
-       out->dpdown.kind = EMappingKind_Hat;
-       out->dpleft.target = hat | 0x8;
-       out->dpright.target = hat | 0x2;
-       out->dpup.target = hat | 0x1;
-       out->dpdown.target = hat | 0x4;
+    if (mapped != 0xF) {
+        if (joystick->hwdata->has_hat[0]) {
+            int hat = joystick->hwdata->hats_indices[0] << 4;
+            out->dpleft.kind = EMappingKind_Hat;
+            out->dpright.kind = EMappingKind_Hat;
+            out->dpup.kind = EMappingKind_Hat;
+            out->dpdown.kind = EMappingKind_Hat;
+            out->dpleft.target = hat | 0x8;
+            out->dpright.target = hat | 0x2;
+            out->dpup.target = hat | 0x1;
+            out->dpdown.target = hat | 0x4;
+            mapped |= 0xF;
+#ifdef DEBUG_GAMEPAD_MAPPING
+        SDL_Log("Mapped DPUP+DOWN+LEFT+RIGHT to hat 0 (ABS_HAT0X, ABS_HAT0Y)");
+#endif
+        } else if (joystick->hwdata->has_abs[ABS_HAT0X] && joystick->hwdata->has_abs[ABS_HAT0Y]) {
+            out->dpleft.kind = EMappingKind_Axis;
+            out->dpright.kind = EMappingKind_Axis;
+            out->dpup.kind = EMappingKind_Axis;
+            out->dpdown.kind = EMappingKind_Axis;
+            out->dpleft.target = joystick->hwdata->abs_map[ABS_HAT0X];
+            out->dpright.target = joystick->hwdata->abs_map[ABS_HAT0X];
+            out->dpup.target = joystick->hwdata->abs_map[ABS_HAT0Y];
+            out->dpdown.target = joystick->hwdata->abs_map[ABS_HAT0Y];
+            mapped |= 0xF;
+#ifdef DEBUG_GAMEPAD_MAPPING
+        SDL_Log("Mapped DPUP+DOWN to axis %d (ABS_HAT0Y)", out->dpup.target);
+        SDL_Log("Mapped DPLEFT+RIGHT to axis %d (ABS_HAT0X)", out->dpleft.target);
+#endif
+        }
     }
 
     if (joystick->hwdata->has_abs[ABS_X] && joystick->hwdata->has_abs[ABS_Y]) {
@@ -1819,6 +2050,10 @@ LINUX_JoystickGetGamepadMapping(int device_index, SDL_GamepadMapping *out)
         out->lefty.kind = EMappingKind_Axis;
         out->leftx.target = joystick->hwdata->abs_map[ABS_X];
         out->lefty.target = joystick->hwdata->abs_map[ABS_Y];
+#ifdef DEBUG_GAMEPAD_MAPPING
+        SDL_Log("Mapped LEFTX to axis %d (ABS_X)", out->leftx.target);
+        SDL_Log("Mapped LEFTY to axis %d (ABS_Y)", out->lefty.target);
+#endif
     }
 
     if (joystick->hwdata->has_abs[ABS_RX] && joystick->hwdata->has_abs[ABS_RY]) {
@@ -1826,6 +2061,10 @@ LINUX_JoystickGetGamepadMapping(int device_index, SDL_GamepadMapping *out)
         out->righty.kind = EMappingKind_Axis;
         out->rightx.target = joystick->hwdata->abs_map[ABS_RX];
         out->righty.target = joystick->hwdata->abs_map[ABS_RY];
+#ifdef DEBUG_GAMEPAD_MAPPING
+        SDL_Log("Mapped RIGHTX to axis %d (ABS_RX)", out->rightx.target);
+        SDL_Log("Mapped RIGHTY to axis %d (ABS_RY)", out->righty.target);
+#endif
     }
 
     LINUX_JoystickClose(joystick);
@@ -1836,6 +2075,9 @@ LINUX_JoystickGetGamepadMapping(int device_index, SDL_GamepadMapping *out)
     if (item->mapping) {
         SDL_memcpy(item->mapping, out, sizeof(*out));
     }
+#ifdef DEBUG_GAMEPAD_MAPPING
+    SDL_Log("Generated mapping for device %d", device_index);
+#endif
 
     return SDL_TRUE;
 }
@@ -1846,6 +2088,7 @@ SDL_JoystickDriver SDL_LINUX_JoystickDriver =
     LINUX_JoystickGetCount,
     LINUX_JoystickDetect,
     LINUX_JoystickGetDeviceName,
+    LINUX_JoystickGetDevicePath,
     LINUX_JoystickGetDevicePlayerIndex,
     LINUX_JoystickSetDevicePlayerIndex,
     LINUX_JoystickGetDeviceGUID,
diff --git a/Engine/lib/sdl/src/joystick/linux/SDL_sysjoystick_c.h b/Engine/lib/sdl/src/joystick/linux/SDL_sysjoystick_c.h
index 49b8686d0..f0e27b9ca 100644
--- a/Engine/lib/sdl/src/joystick/linux/SDL_sysjoystick_c.h
+++ b/Engine/lib/sdl/src/joystick/linux/SDL_sysjoystick_c.h
@@ -83,6 +83,12 @@ struct joystick_hwdata
     /* 4 = (ABS_HAT3X-ABS_HAT0X)/2 (see input-event-codes.h in kernel) */
     int hats_indices[4];
     SDL_bool has_hat[4];
+    struct hat_axis_correct
+    {
+        SDL_bool use_deadzones;
+        int minimum[2];
+        int maximum[2];
+    } hat_correct[4];
 
     /* Set when gamepad is pending removal due to ENODEV read error */
     SDL_bool gone;
diff --git a/Engine/lib/sdl/src/joystick/os2/SDL_os2joystick.c b/Engine/lib/sdl/src/joystick/os2/SDL_os2joystick.c
index 00b7fc554..1c292ff4d 100644
--- a/Engine/lib/sdl/src/joystick/os2/SDL_os2joystick.c
+++ b/Engine/lib/sdl/src/joystick/os2/SDL_os2joystick.c
@@ -377,15 +377,17 @@ static void OS2_JoystickDetect(void)
 {
 }
 
-/***********************************************************/
-/* Function to get the device-dependent name of a joystick */
-/***********************************************************/
 static const char *OS2_JoystickGetDeviceName(int device_index)
 {
 	/* No need to verify if device exists, already done in upper layer */
 	return SYS_JoyData[device_index].szDeviceName;
 }
 
+static const char *OS2_JoystickGetDevicePath(int device_index)
+{
+	return NULL;
+}
+
 static int OS2_JoystickGetDevicePlayerIndex(int device_index)
 {
 	return -1;
@@ -779,6 +781,7 @@ SDL_JoystickDriver SDL_OS2_JoystickDriver =
 	OS2_NumJoysticks,
 	OS2_JoystickDetect,
 	OS2_JoystickGetDeviceName,
+	OS2_JoystickGetDevicePath,
 	OS2_JoystickGetDevicePlayerIndex,
 	OS2_JoystickSetDevicePlayerIndex,
 	OS2_JoystickGetDeviceGUID,
diff --git a/Engine/lib/sdl/src/joystick/psp/SDL_sysjoystick.c b/Engine/lib/sdl/src/joystick/psp/SDL_sysjoystick.c
index d71979560..a5422592b 100644
--- a/Engine/lib/sdl/src/joystick/psp/SDL_sysjoystick.c
+++ b/Engine/lib/sdl/src/joystick/psp/SDL_sysjoystick.c
@@ -142,7 +142,6 @@ static void PSP_JoystickDetect(void)
 }
 
 #if 0
-/* Function to get the device-dependent name of a joystick */
 static const char *PSP_JoystickName(int idx)
 {
     if (idx == 0) return "PSP controller";
@@ -151,12 +150,16 @@ static const char *PSP_JoystickName(int idx)
 }
 #endif
 
-/* Function to get the device-dependent name of a joystick */
 static const char *PSP_JoystickGetDeviceName(int device_index)
 {
     return "PSP builtin joypad";
 }
 
+static const char *PSP_JoystickGetDevicePath(int device_index)
+{
+    return NULL;
+}
+
 static int PSP_JoystickGetDevicePlayerIndex(int device_index)
 {
     return -1;
@@ -304,6 +307,7 @@ SDL_JoystickDriver SDL_PSP_JoystickDriver =
     PSP_NumJoysticks,
     PSP_JoystickDetect,
     PSP_JoystickGetDeviceName,
+    PSP_JoystickGetDevicePath,
     PSP_JoystickGetDevicePlayerIndex,
     PSP_JoystickSetDevicePlayerIndex,
     PSP_JoystickGetDeviceGUID,
diff --git a/Engine/lib/sdl/src/joystick/virtual/SDL_virtualjoystick.c b/Engine/lib/sdl/src/joystick/virtual/SDL_virtualjoystick.c
index 508dd80f9..273c75e5a 100644
--- a/Engine/lib/sdl/src/joystick/virtual/SDL_virtualjoystick.c
+++ b/Engine/lib/sdl/src/joystick/virtual/SDL_virtualjoystick.c
@@ -24,11 +24,11 @@
 
 /* This is the virtual implementation of the SDL joystick API */
 
+#include "SDL_endian.h"
 #include "SDL_virtualjoystick_c.h"
 #include "../SDL_sysjoystick.h"
 #include "../SDL_joystick_c.h"
 
-extern SDL_JoystickDriver SDL_VIRTUAL_JoystickDriver;
 
 static joystick_hwdata * g_VJoys = NULL;
 
@@ -56,18 +56,6 @@ VIRTUAL_FreeHWData(joystick_hwdata *hwdata)
     if (!hwdata) {
         return;
     }
-    if (hwdata->axes) {
-        SDL_free((void *)hwdata->axes);
-        hwdata->axes = NULL;
-    }
-    if (hwdata->buttons) {
-        SDL_free((void *)hwdata->buttons);
-        hwdata->buttons = NULL;
-    }
-    if (hwdata->hats) {
-        SDL_free(hwdata->hats);
-        hwdata->hats = NULL;
-    }
 
     /* Remove hwdata from SDL-global list */
     while (cur) {
@@ -83,51 +71,170 @@ VIRTUAL_FreeHWData(joystick_hwdata *hwdata)
         cur = cur->next;
     }
 
+    if (hwdata->joystick) {
+        hwdata->joystick->hwdata = NULL;
+        hwdata->joystick = NULL;
+    }
+    if (hwdata->name) {
+        SDL_free(hwdata->name);
+        hwdata->name = NULL;
+    }
+    if (hwdata->axes) {
+        SDL_free((void *)hwdata->axes);
+        hwdata->axes = NULL;
+    }
+    if (hwdata->buttons) {
+        SDL_free((void *)hwdata->buttons);
+        hwdata->buttons = NULL;
+    }
+    if (hwdata->hats) {
+        SDL_free(hwdata->hats);
+        hwdata->hats = NULL;
+    }
     SDL_free(hwdata);
 }
 
 
 int
-SDL_JoystickAttachVirtualInner(SDL_JoystickType type,
-                               int naxes,
-                               int nbuttons,
-                               int nhats)
+SDL_JoystickAttachVirtualInner(const SDL_VirtualJoystickDesc *desc)
 {
     joystick_hwdata *hwdata = NULL;
     int device_index = -1;
+    const char *name = NULL;
+    Uint16 *guid16;
+    int axis_triggerleft = -1;
+    int axis_triggerright = -1;
+
+    if (!desc) {
+        return SDL_InvalidParamError("desc");
+    }
+    if (desc->version != SDL_VIRTUAL_JOYSTICK_DESC_VERSION) {
+        /* Is this an old version that we can support? */
+        return SDL_SetError("Unsupported virtual joystick description version %d", desc->version);
+    }
 
     hwdata = SDL_calloc(1, sizeof(joystick_hwdata));
     if (!hwdata) {
         VIRTUAL_FreeHWData(hwdata);
         return SDL_OutOfMemory();
     }
+    SDL_memcpy(&hwdata->desc, desc, sizeof(*desc));
 
-    hwdata->naxes = naxes;
-    hwdata->nbuttons = nbuttons;
-    hwdata->nhats = nhats;
-    hwdata->name = "Virtual Joystick";
+    if (hwdata->desc.name) {
+        name = hwdata->desc.name;
+    } else {
+        switch (hwdata->desc.type) {
+        case SDL_JOYSTICK_TYPE_GAMECONTROLLER:
+            name = "Virtual Controller";
+            break;
+        case SDL_JOYSTICK_TYPE_WHEEL:
+            name = "Virtual Wheel";
+            break;
+        case SDL_JOYSTICK_TYPE_ARCADE_STICK:
+            name = "Virtual Arcade Stick";
+            break;
+        case SDL_JOYSTICK_TYPE_FLIGHT_STICK:
+            name = "Virtual Flight Stick";
+            break;
+        case SDL_JOYSTICK_TYPE_DANCE_PAD:
+            name = "Virtual Dance Pad";
+            break;
+        case SDL_JOYSTICK_TYPE_GUITAR:
+            name = "Virtual Guitar";
+            break;
+        case SDL_JOYSTICK_TYPE_DRUM_KIT:
+            name = "Virtual Drum Kit";
+            break;
+        case SDL_JOYSTICK_TYPE_ARCADE_PAD:
+            name = "Virtual Arcade Pad";
+            break;
+        case SDL_JOYSTICK_TYPE_THROTTLE:
+            name = "Virtual Throttle";
+            break;
+        default:
+            name = "Virtual Joystick";
+            break;
+        }
+    }
+    hwdata->name = SDL_strdup(name);
+
+    if (hwdata->desc.type == SDL_JOYSTICK_TYPE_GAMECONTROLLER) {
+        int i, axis;
+
+        if (hwdata->desc.button_mask == 0) {
+            for (i = 0; i < hwdata->desc.nbuttons && i < sizeof(hwdata->desc.button_mask)*8; ++i) {
+                hwdata->desc.button_mask |= (1 << i);
+            }
+        }
+
+        if (hwdata->desc.axis_mask == 0) {
+            if (hwdata->desc.naxes >= 2) {
+                hwdata->desc.axis_mask |= ((1 << SDL_CONTROLLER_AXIS_LEFTX) | (1 << SDL_CONTROLLER_AXIS_LEFTY));
+            }
+            if (hwdata->desc.naxes >= 4) {
+                hwdata->desc.axis_mask |= ((1 << SDL_CONTROLLER_AXIS_RIGHTX) | (1 << SDL_CONTROLLER_AXIS_RIGHTY));
+            }
+            if (hwdata->desc.naxes >= 6) {
+                hwdata->desc.axis_mask |= ((1 << SDL_CONTROLLER_AXIS_TRIGGERLEFT) | (1 << SDL_CONTROLLER_AXIS_TRIGGERRIGHT));
+            }
+        }
+
+        /* Find the trigger axes */
+        axis = 0;
+        for (i = 0; axis < hwdata->desc.naxes && i < SDL_CONTROLLER_AXIS_MAX; ++i) {
+            if (hwdata->desc.axis_mask & (1 << i)) {
+                if (i == SDL_CONTROLLER_AXIS_TRIGGERLEFT) {
+                    axis_triggerleft = axis;
+                }
+                if (i == SDL_CONTROLLER_AXIS_TRIGGERRIGHT) {
+                    axis_triggerright = axis;
+                }
+                ++axis;
+            }
+        }
+    }
+
+    /* We only need 16 bits for each of these; space them out to fill 128. */
+    /* Byteswap so devices get same GUID on little/big endian platforms. */
+    guid16 = (Uint16 *)hwdata->guid.data;
+    *guid16++ = SDL_SwapLE16(SDL_HARDWARE_BUS_VIRTUAL);
+    *guid16++ = 0;
+    *guid16++ = SDL_SwapLE16(hwdata->desc.vendor_id);
+    *guid16++ = 0;
+    *guid16++ = SDL_SwapLE16(hwdata->desc.product_id);
+    *guid16++ = 0;
+    *guid16++ = 0;
+    *guid16++ = 0; /* This will be overwritten below with the virtual controller signature */
 
     /* Note that this is a Virtual device and what subtype it is */
     hwdata->guid.data[14] = 'v';
-    hwdata->guid.data[15] = (Uint8)type;
+    hwdata->guid.data[15] = (Uint8)hwdata->desc.type;
 
     /* Allocate fields for different control-types */
-    if (naxes > 0) {
-        hwdata->axes = SDL_calloc(naxes, sizeof(Sint16));
+    if (hwdata->desc.naxes > 0) {
+        hwdata->axes = SDL_calloc(hwdata->desc.naxes, sizeof(Sint16));
         if (!hwdata->axes) {
             VIRTUAL_FreeHWData(hwdata);
             return SDL_OutOfMemory();
         }
+
+        /* Trigger axes are at minimum value at rest */
+        if (axis_triggerleft >= 0) {
+            hwdata->axes[axis_triggerleft] = SDL_JOYSTICK_AXIS_MIN;
+        }
+        if (axis_triggerright >= 0) {
+            hwdata->axes[axis_triggerright] = SDL_JOYSTICK_AXIS_MIN;
+        }
     }
-    if (nbuttons > 0) {
-        hwdata->buttons = SDL_calloc(nbuttons, sizeof(Uint8));
+    if (hwdata->desc.nbuttons > 0) {
+        hwdata->buttons = SDL_calloc(hwdata->desc.nbuttons, sizeof(Uint8));
         if (!hwdata->buttons) {
             VIRTUAL_FreeHWData(hwdata);
             return SDL_OutOfMemory();
         }
     }
-    if (nhats > 0) {
-        hwdata->hats = SDL_calloc(nhats, sizeof(Uint8));
+    if (hwdata->desc.nhats > 0) {
+        hwdata->hats = SDL_calloc(hwdata->desc.nhats, sizeof(Uint8));
         if (!hwdata->hats) {
             VIRTUAL_FreeHWData(hwdata);
             return SDL_OutOfMemory();
@@ -138,8 +245,16 @@ SDL_JoystickAttachVirtualInner(SDL_JoystickType type,
     hwdata->instance_id = SDL_GetNextJoystickInstanceID();
 
     /* Add virtual joystick to SDL-global lists */
-    hwdata->next = g_VJoys;
-    g_VJoys = hwdata;
+    if (g_VJoys) {
+        joystick_hwdata *last;
+
+        for (last = g_VJoys; last->next; last = last->next) {
+            continue;
+        }
+        last->next = hwdata;
+    } else {
+        g_VJoys = hwdata;
+    }
     SDL_PrivateJoystickAdded(hwdata->instance_id);
 
     /* Return the new virtual-device's index */
@@ -176,7 +291,7 @@ SDL_JoystickSetVirtualAxisInner(SDL_Joystick *joystick, int axis, Sint16 value)
     }
 
     hwdata = (joystick_hwdata *)joystick->hwdata;
-    if (axis < 0 || axis >= hwdata->naxes) {
+    if (axis < 0 || axis >= hwdata->desc.naxes) {
         SDL_UnlockJoysticks();
         return SDL_SetError("Invalid axis index");
     }
@@ -201,7 +316,7 @@ SDL_JoystickSetVirtualButtonInner(SDL_Joystick *joystick, int button, Uint8 valu
     }
 
     hwdata = (joystick_hwdata *)joystick->hwdata;
-    if (button < 0 || button >= hwdata->nbuttons) {
+    if (button < 0 || button >= hwdata->desc.nbuttons) {
         SDL_UnlockJoysticks();
         return SDL_SetError("Invalid button index");
     }
@@ -226,7 +341,7 @@ SDL_JoystickSetVirtualHatInner(SDL_Joystick *joystick, int hat, Uint8 value)
     }
 
     hwdata = (joystick_hwdata *)joystick->hwdata;
-    if (hat < 0 || hat >= hwdata->nhats) {
+    if (hat < 0 || hat >= hwdata->desc.nhats) {
         SDL_UnlockJoysticks();
         return SDL_SetError("Invalid hat index");
     }
@@ -271,7 +386,14 @@ VIRTUAL_JoystickGetDeviceName(int device_index)
     if (!hwdata) {
         return NULL;
     }
-    return hwdata->name ? hwdata->name : "";
+    return hwdata->name;
+}
+
+
+static const char *
+VIRTUAL_JoystickGetDevicePath(int device_index)
+{
+    return NULL;
 }
 
 
@@ -285,6 +407,11 @@ VIRTUAL_JoystickGetDevicePlayerIndex(int device_index)
 static void
 VIRTUAL_JoystickSetDevicePlayerIndex(int device_index, int player_index)
 {
+    joystick_hwdata *hwdata = VIRTUAL_HWDataForIndex(device_index);
+
+    if (hwdata && hwdata->desc.SetPlayerIndex) {
+        hwdata->desc.SetPlayerIndex(hwdata->desc.userdata, player_index);
+    }
 }
 
 
@@ -319,15 +446,12 @@ VIRTUAL_JoystickOpen(SDL_Joystick *joystick, int device_index)
     if (!hwdata) {
         return SDL_SetError("No such device");
     }
-    if (hwdata->opened) {
-        return SDL_SetError("Joystick already opened");
-    }
     joystick->instance_id = hwdata->instance_id;
     joystick->hwdata = hwdata;
-    joystick->naxes = hwdata->naxes;
-    joystick->nbuttons = hwdata->nbuttons;
-    joystick->nhats = hwdata->nhats;
-    hwdata->opened = SDL_TRUE;
+    joystick->naxes = hwdata->desc.naxes;
+    joystick->nbuttons = hwdata->desc.nbuttons;
+    joystick->nhats = hwdata->desc.nhats;
+    hwdata->joystick = joystick;
     return 0;
 }
 
@@ -335,33 +459,99 @@ VIRTUAL_JoystickOpen(SDL_Joystick *joystick, int device_index)
 static int
 VIRTUAL_JoystickRumble(SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
 {
-    return SDL_Unsupported();
+    int result;
+
+    if (joystick->hwdata) {
+        joystick_hwdata *hwdata = joystick->hwdata;
+        if (hwdata->desc.Rumble) {
+            result = hwdata->desc.Rumble(hwdata->desc.userdata, low_frequency_rumble, high_frequency_rumble);
+        } else {
+            result = SDL_Unsupported();
+        }
+    } else {
+        result = SDL_SetError("Rumble failed, device disconnected");
+    }
+
+    return result;
 }
 
 static int
 VIRTUAL_JoystickRumbleTriggers(SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
 {
-    return SDL_Unsupported();
+    int result;
+
+    if (joystick->hwdata) {
+        joystick_hwdata *hwdata = joystick->hwdata;
+        if (hwdata->desc.RumbleTriggers) {
+            result = hwdata->desc.RumbleTriggers(hwdata->desc.userdata, left_rumble, right_rumble);
+        } else {
+            result = SDL_Unsupported();
+        }
+    } else {
+        result = SDL_SetError("Rumble failed, device disconnected");
+    }
+
+    return result;
 }
 
 
 static Uint32
 VIRTUAL_JoystickGetCapabilities(SDL_Joystick *joystick)
 {
-    return 0;
+    joystick_hwdata *hwdata = joystick->hwdata;
+    Uint32 caps = 0;
+
+    if (hwdata) {
+        if (hwdata->desc.Rumble) {
+            caps |= SDL_JOYCAP_RUMBLE;
+        }
+        if (hwdata->desc.RumbleTriggers) {
+            caps |= SDL_JOYCAP_RUMBLE_TRIGGERS;
+        }
+        if (hwdata->desc.SetLED) {
+            caps |= SDL_JOYCAP_LED;
+        }
+    }
+    return caps;
 }
 
 
 static int
 VIRTUAL_JoystickSetLED(SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
 {
-    return SDL_Unsupported();
+    int result;
+
+    if (joystick->hwdata) {
+        joystick_hwdata *hwdata = joystick->hwdata;
+        if (hwdata->desc.SetLED) {
+            result = hwdata->desc.SetLED(hwdata->desc.userdata, red, green, blue);
+        } else {
+            result = SDL_Unsupported();
+        }
+    } else {
+        result = SDL_SetError("SetLED failed, device disconnected");
+    }
+
+    return result;
 }
 
 static int
 VIRTUAL_JoystickSendEffect(SDL_Joystick *joystick, const void *data, int size)
 {
-    return SDL_Unsupported();
+    int result;
+
+    if (joystick->hwdata) {
+        joystick_hwdata *hwdata = joystick->hwdata;
+        if (hwdata->desc.SendEffect) {
+            result = hwdata->desc.SendEffect(hwdata->desc.userdata, data, size);
+        } else {
+            result = SDL_Unsupported();
+        }
+    } else {
+        result = SDL_SetError("SendEffect failed, device disconnected");
+    }
+
+    return result;
 }
 
 static int
@@ -386,13 +576,17 @@ VIRTUAL_JoystickUpdate(SDL_Joystick *joystick)
 
     hwdata = (joystick_hwdata *)joystick->hwdata;
 
-    for (i = 0; i < hwdata->naxes; ++i) {
+    if (hwdata->desc.Update) {
+        hwdata->desc.Update(hwdata->desc.userdata);
+    }
+
+    for (i = 0; i < hwdata->desc.naxes; ++i) {
         SDL_PrivateJoystickAxis(joystick, i, hwdata->axes[i]);
     }
-    for (i = 0; i < hwdata->nbuttons; ++i) {
+    for (i = 0; i < hwdata->desc.nbuttons; ++i) {
         SDL_PrivateJoystickButton(joystick, i, hwdata->buttons[i]);
     }
-    for (i = 0; i < hwdata->nhats; ++i) {
+    for (i = 0; i < hwdata->desc.nhats; ++i) {
         SDL_PrivateJoystickHat(joystick, i, hwdata->hats[i]);
     }
 }
@@ -401,17 +595,11 @@ VIRTUAL_JoystickUpdate(SDL_Joystick *joystick)
 static void
 VIRTUAL_JoystickClose(SDL_Joystick *joystick)
 {
-    joystick_hwdata *hwdata;
-
-    if (!joystick) {
-        return;
+    if (joystick->hwdata) {
+        joystick_hwdata *hwdata = joystick->hwdata;
+        hwdata->joystick = NULL;
+        joystick->hwdata = NULL;
     }
-    if (!joystick->hwdata) {
-        return;
-    }
-
-    hwdata = (joystick_hwdata *)joystick->hwdata;
-    hwdata->opened = SDL_FALSE;
 }
 
 
@@ -426,7 +614,145 @@ VIRTUAL_JoystickQuit(void)
 static SDL_bool
 VIRTUAL_JoystickGetGamepadMapping(int device_index, SDL_GamepadMapping *out)
 {
-    return SDL_FALSE;
+    joystick_hwdata *hwdata = VIRTUAL_HWDataForIndex(device_index);
+    int current_button = 0;
+    int current_axis = 0;
+
+    if (hwdata->desc.type != SDL_JOYSTICK_TYPE_GAMECONTROLLER) {
+        return SDL_FALSE;
+    }
+
+    if (current_button < hwdata->desc.nbuttons && (hwdata->desc.button_mask & (1 << SDL_CONTROLLER_BUTTON_A))) {
+        out->a.kind = EMappingKind_Button;
+        out->a.target = current_button++;
+    }
+
+    if (current_button < hwdata->desc.nbuttons && (hwdata->desc.button_mask & (1 << SDL_CONTROLLER_BUTTON_B))) {
+        out->b.kind = EMappingKind_Button;
+        out->b.target = current_button++;
+    }
+
+    if (current_button < hwdata->desc.nbuttons && (hwdata->desc.button_mask & (1 << SDL_CONTROLLER_BUTTON_X))) {
+        out->x.kind = EMappingKind_Button;
+        out->x.target = current_button++;
+    }
+
+    if (current_button < hwdata->desc.nbuttons && (hwdata->desc.button_mask & (1 << SDL_CONTROLLER_BUTTON_Y))) {
+        out->y.kind = EMappingKind_Button;
+        out->y.target = current_button++;
+    }
+
+    if (current_button < hwdata->desc.nbuttons && (hwdata->desc.button_mask & (1 << SDL_CONTROLLER_BUTTON_BACK))) {
+        out->back.kind = EMappingKind_Button;
+        out->back.target = current_button++;
+    }
+
+    if (current_button < hwdata->desc.nbuttons && (hwdata->desc.button_mask & (1 << SDL_CONTROLLER_BUTTON_GUIDE))) {
+        out->guide.kind = EMappingKind_Button;
+        out->guide.target = current_button++;
+    }
+
+    if (current_button < hwdata->desc.nbuttons && (hwdata->desc.button_mask & (1 << SDL_CONTROLLER_BUTTON_START))) {
+        out->start.kind = EMappingKind_Button;
+        out->start.target = current_button++;
+    }
+
+    if (current_button < hwdata->desc.nbuttons && (hwdata->desc.button_mask & (1 << SDL_CONTROLLER_BUTTON_LEFTSTICK))) {
+        out->leftstick.kind = EMappingKind_Button;
+        out->leftstick.target = current_button++;
+    }
+
+    if (current_button < hwdata->desc.nbuttons && (hwdata->desc.button_mask & (1 << SDL_CONTROLLER_BUTTON_RIGHTSTICK))) {
+        out->rightstick.kind = EMappingKind_Button;
+        out->rightstick.target = current_button++;
+    }
+
+    if (current_button < hwdata->desc.nbuttons && (hwdata->desc.button_mask & (1 << SDL_CONTROLLER_BUTTON_LEFTSHOULDER))) {
+        out->leftshoulder.kind = EMappingKind_Button;
+        out->leftshoulder.target = current_button++;
+    }
+
+    if (current_button < hwdata->desc.nbuttons && (hwdata->desc.button_mask & (1 << SDL_CONTROLLER_BUTTON_RIGHTSHOULDER))) {
+        out->rightshoulder.kind = EMappingKind_Button;
+        out->rightshoulder.target = current_button++;
+    }
+
+    if (current_button < hwdata->desc.nbuttons && (hwdata->desc.button_mask & (1 << SDL_CONTROLLER_BUTTON_DPAD_UP))) {
+        out->dpup.kind = EMappingKind_Button;
+        out->dpup.target = current_button++;
+    }
+
+    if (current_button < hwdata->desc.nbuttons && (hwdata->desc.button_mask & (1 << SDL_CONTROLLER_BUTTON_DPAD_DOWN))) {
+        out->dpdown.kind = EMappingKind_Button;
+        out->dpdown.target = current_button++;
+    }
+
+    if (current_button < hwdata->desc.nbuttons && (hwdata->desc.button_mask & (1 << SDL_CONTROLLER_BUTTON_DPAD_LEFT))) {
+        out->dpleft.kind = EMappingKind_Button;
+        out->dpleft.target = current_button++;
+    }
+
+    if (current_button < hwdata->desc.nbuttons && (hwdata->desc.button_mask & (1 << SDL_CONTROLLER_BUTTON_DPAD_RIGHT))) {
+        out->dpright.kind = EMappingKind_Button;
+        out->dpright.target = current_button++;
+    }
+
+    if (current_button < hwdata->desc.nbuttons && (hwdata->desc.button_mask & (1 << SDL_CONTROLLER_BUTTON_MISC1))) {
+        out->misc1.kind = EMappingKind_Button;
+        out->misc1.target = current_button++;
+    }
+
+    if (current_button < hwdata->desc.nbuttons && (hwdata->desc.button_mask & (1 << SDL_CONTROLLER_BUTTON_PADDLE1))) {
+        out->paddle1.kind = EMappingKind_Button;
+        out->paddle1.target = current_button++;
+    }
+
+    if (current_button < hwdata->desc.nbuttons && (hwdata->desc.button_mask & (1 << SDL_CONTROLLER_BUTTON_PADDLE2))) {
+        out->paddle2.kind = EMappingKind_Button;
+        out->paddle2.target = current_button++;
+    }
+
+    if (current_button < hwdata->desc.nbuttons && (hwdata->desc.button_mask & (1 << SDL_CONTROLLER_BUTTON_PADDLE3))) {
+        out->paddle3.kind = EMappingKind_Button;
+        out->paddle3.target = current_button++;
+    }
+
+    if (current_button < hwdata->desc.nbuttons && (hwdata->desc.button_mask & (1 << SDL_CONTROLLER_BUTTON_PADDLE4))) {
+        out->paddle4.kind = EMappingKind_Button;
+        out->paddle4.target = current_button++;
+    }
+
+    if (current_axis < hwdata->desc.naxes && (hwdata->desc.axis_mask & (1 << SDL_CONTROLLER_AXIS_LEFTX))) {
+        out->leftx.kind = EMappingKind_Axis;
+        out->leftx.target = current_axis++;
+    }
+
+    if (current_axis < hwdata->desc.naxes && (hwdata->desc.axis_mask & (1 << SDL_CONTROLLER_AXIS_LEFTY))) {
+        out->lefty.kind = EMappingKind_Axis;
+        out->lefty.target = current_axis++;
+    }
+
+    if (current_axis < hwdata->desc.naxes && (hwdata->desc.axis_mask & (1 << SDL_CONTROLLER_AXIS_RIGHTX))) {
+        out->rightx.kind = EMappingKind_Axis;
+        out->rightx.target = current_axis++;
+    }
+
+    if (current_axis < hwdata->desc.naxes && (hwdata->desc.axis_mask & (1 << SDL_CONTROLLER_AXIS_RIGHTY))) {
+        out->righty.kind = EMappingKind_Axis;
+        out->righty.target = current_axis++;
+    }
+
+    if (current_axis < hwdata->desc.naxes && (hwdata->desc.axis_mask & (1 << SDL_CONTROLLER_AXIS_TRIGGERLEFT))) {
+        out->lefttrigger.kind = EMappingKind_Axis;
+        out->lefttrigger.target = current_axis++;
+    }
+
+    if (current_axis < hwdata->desc.naxes && (hwdata->desc.axis_mask & (1 << SDL_CONTROLLER_AXIS_TRIGGERRIGHT))) {
+        out->righttrigger.kind = EMappingKind_Axis;
+        out->righttrigger.target = current_axis++;
+    }
+
+    return SDL_TRUE;
 }
 
 SDL_JoystickDriver SDL_VIRTUAL_JoystickDriver =
@@ -435,6 +761,7 @@ SDL_JoystickDriver SDL_VIRTUAL_JoystickDriver =
     VIRTUAL_JoystickGetCount,
     VIRTUAL_JoystickDetect,
     VIRTUAL_JoystickGetDeviceName,
+    VIRTUAL_JoystickGetDevicePath,
     VIRTUAL_JoystickGetDevicePlayerIndex,
     VIRTUAL_JoystickSetDevicePlayerIndex,
     VIRTUAL_JoystickGetDeviceGUID,
diff --git a/Engine/lib/sdl/src/joystick/virtual/SDL_virtualjoystick_c.h b/Engine/lib/sdl/src/joystick/virtual/SDL_virtualjoystick_c.h
index b251c2d14..5e15f1dd6 100644
--- a/Engine/lib/sdl/src/joystick/virtual/SDL_virtualjoystick_c.h
+++ b/Engine/lib/sdl/src/joystick/virtual/SDL_virtualjoystick_c.h
@@ -34,24 +34,19 @@ typedef struct joystick_hwdata
 {
     SDL_JoystickType type;
     SDL_bool attached;
-    const char *name;
+    char *name;
     SDL_JoystickGUID guid;
-    int naxes;
+    SDL_VirtualJoystickDesc desc;
     Sint16 *axes;
-    int nbuttons;
     Uint8 *buttons;
-    int nhats;
     Uint8 *hats;
     SDL_JoystickID instance_id;
-    SDL_bool opened;
+    SDL_Joystick *joystick;
+
     struct joystick_hwdata *next;
 } joystick_hwdata;
 
-int SDL_JoystickAttachVirtualInner(SDL_JoystickType type,
-                                   int naxes,
-                                   int nbuttons,
-                                   int nhats);
-
+int SDL_JoystickAttachVirtualInner(const SDL_VirtualJoystickDesc *desc);
 int SDL_JoystickDetachVirtualInner(int device_index);
 
 int SDL_JoystickSetVirtualAxisInner(SDL_Joystick * joystick, int axis, Sint16 value);
@@ -59,4 +54,7 @@ int SDL_JoystickSetVirtualButtonInner(SDL_Joystick * joystick, int button, Uint8
 int SDL_JoystickSetVirtualHatInner(SDL_Joystick * joystick, int hat, Uint8 value);
 
 #endif  /* SDL_JOYSTICK_VIRTUAL */
+
 #endif  /* SDL_VIRTUALJOYSTICK_C_H */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/joystick/vita/SDL_sysjoystick.c b/Engine/lib/sdl/src/joystick/vita/SDL_sysjoystick.c
index aa52cd77f..b5c7a2778 100644
--- a/Engine/lib/sdl/src/joystick/vita/SDL_sysjoystick.c
+++ b/Engine/lib/sdl/src/joystick/vita/SDL_sysjoystick.c
@@ -179,7 +179,6 @@ SDL_JoystickID VITA_JoystickGetDeviceInstanceID(int device_index)
     return device_index;
 }
 
-/* Function to get the device-dependent name of a joystick */
 const char *VITA_JoystickGetDeviceName(int index)
 {
     if (index == 0)
@@ -195,7 +194,12 @@ const char *VITA_JoystickGetDeviceName(int index)
         return "PSVita Controller";
 
     SDL_SetError("No joystick available with that index");
-    return(NULL);
+    return NULL;
+}
+
+const char *VITA_JoystickGetDevicePath(int index)
+{
+    return NULL;
 }
 
 static int
@@ -400,6 +404,7 @@ SDL_JoystickDriver SDL_VITA_JoystickDriver =
     VITA_JoystickGetCount,
     VITA_JoystickDetect,
     VITA_JoystickGetDeviceName,
+    VITA_JoystickGetDevicePath,
     VITA_JoystickGetDevicePlayerIndex,
     VITA_JoystickSetDevicePlayerIndex,
     VITA_JoystickGetDeviceGUID,
diff --git a/Engine/lib/sdl/src/joystick/windows/SDL_dinputjoystick.c b/Engine/lib/sdl/src/joystick/windows/SDL_dinputjoystick.c
index c2f53a93f..7b4c23ee0 100644
--- a/Engine/lib/sdl/src/joystick/windows/SDL_dinputjoystick.c
+++ b/Engine/lib/sdl/src/joystick/windows/SDL_dinputjoystick.c
@@ -456,7 +456,7 @@ EnumJoystickDetectCallback(LPCDIDEVICEINSTANCE pDeviceInstance, LPVOID pContext)
     pNewJoystick = *(JoyStick_DeviceData**)pContext;
     while (pNewJoystick) {
         /* update GUIDs of joysticks with matching paths, in case they're not open yet */
-        if (SDL_strcmp(pNewJoystick->hidPath, hidPath) == 0) {
+        if (SDL_strcmp(pNewJoystick->path, hidPath) == 0) {
             /* if we are replacing the front of the list then update it */
             if (pNewJoystick == *(JoyStick_DeviceData**)pContext) {
                 *(JoyStick_DeviceData**)pContext = pNewJoystick->pNext;
@@ -483,7 +483,7 @@ EnumJoystickDetectCallback(LPCDIDEVICEINSTANCE pDeviceInstance, LPVOID pContext)
     CHECK(pNewJoystick);
 
     SDL_zerop(pNewJoystick);
-    SDL_strlcpy(pNewJoystick->hidPath, hidPath, SDL_arraysize(pNewJoystick->hidPath));
+    SDL_strlcpy(pNewJoystick->path, hidPath, SDL_arraysize(pNewJoystick->path));
     SDL_memcpy(&pNewJoystick->dxdevice, pDeviceInstance, sizeof(DIDEVICEINSTANCE));
     SDL_memset(pNewJoystick->guid.data, 0, sizeof(pNewJoystick->guid.data));
 
@@ -683,7 +683,7 @@ EnumDevObjectsCallback(LPCDIDEVICEOBJECTINSTANCE pDeviceObject, LPVOID pContext)
 /* Sort using the data offset into the DInput struct.
  * This gives a reasonable ordering for the inputs.
  */
-static int
+static int SDLCALL
 SortDevFunc(const void *a, const void *b)
 {
     const input_t *inputA = (const input_t*)a;
diff --git a/Engine/lib/sdl/src/joystick/windows/SDL_rawinputjoystick.c b/Engine/lib/sdl/src/joystick/windows/SDL_rawinputjoystick.c
index df40232df..ca9bd7d37 100644
--- a/Engine/lib/sdl/src/joystick/windows/SDL_rawinputjoystick.c
+++ b/Engine/lib/sdl/src/joystick/windows/SDL_rawinputjoystick.c
@@ -105,6 +105,7 @@ typedef struct _SDL_RAWINPUT_Device
 {
     SDL_atomic_t refcount;
     char *name;
+    char *path;
     Uint16 vendor_id;
     Uint16 product_id;
     Uint16 version;
@@ -689,10 +690,9 @@ RAWINPUT_ReleaseDevice(SDL_RAWINPUT_Device *device)
 #endif /* SDL_JOYSTICK_RAWINPUT_XINPUT */
 
     if (SDL_AtomicDecRef(&device->refcount)) {
-        if (device->preparsed_data) {
-            SDL_HidD_FreePreparsedData(device->preparsed_data);
-        }
+        SDL_free(device->preparsed_data);
         SDL_free(device->name);
+        SDL_free(device->path);
         SDL_free(device);
     }
 }
@@ -716,9 +716,8 @@ RAWINPUT_AddDevice(HANDLE hDevice)
     SDL_RAWINPUT_Device *device = NULL;
     SDL_RAWINPUT_Device *curr, *last;
     RID_DEVICE_INFO rdi;
-    UINT rdi_size = sizeof(rdi);
+    UINT size;
     char dev_name[MAX_PATH];
-    UINT name_size = SDL_arraysize(dev_name);
     HANDLE hFile = INVALID_HANDLE_VALUE;
 
     /* Make sure we're not trying to add the same device twice */
@@ -727,11 +726,13 @@ RAWINPUT_AddDevice(HANDLE hDevice)
     }
 
     /* Figure out what kind of device it is */
-    CHECK(GetRawInputDeviceInfoA(hDevice, RIDI_DEVICEINFO, &rdi, &rdi_size) != (UINT)-1);
+    size = sizeof(rdi);
+    CHECK(GetRawInputDeviceInfoA(hDevice, RIDI_DEVICEINFO, &rdi, &size) != (UINT)-1);
     CHECK(rdi.dwType == RIM_TYPEHID);
 
     /* Get the device "name" (HID Path) */
-    CHECK(GetRawInputDeviceInfoA(hDevice, RIDI_DEVICENAME, dev_name, &name_size) != (UINT)-1);
+    size = SDL_arraysize(dev_name);
+    CHECK(GetRawInputDeviceInfoA(hDevice, RIDI_DEVICENAME, dev_name, &size) != (UINT)-1);
     /* Only take XInput-capable devices */
     CHECK(SDL_strstr(dev_name, "IG_") != NULL);
 #ifdef SDL_JOYSTICK_HIDAPI
@@ -747,6 +748,12 @@ RAWINPUT_AddDevice(HANDLE hDevice)
     device->is_xinput = SDL_TRUE;
     device->is_xboxone = GuessControllerType(device->vendor_id, device->product_id) == k_eControllerType_XBoxOneController;
 
+    /* Get HID Top-Level Collection Preparsed Data */
+    size = 0;
+    CHECK(GetRawInputDeviceInfoA(hDevice, RIDI_PREPARSEDDATA, NULL, &size) != (UINT)-1);
+    CHECK(device->preparsed_data = (PHIDP_PREPARSED_DATA)SDL_calloc(size, sizeof(BYTE)));
+    CHECK(GetRawInputDeviceInfoA(hDevice, RIDI_PREPARSEDDATA, device->preparsed_data, &size) != (UINT)-1);
+
     {
         const Uint16 vendor = device->vendor_id;
         const Uint16 product = device->product_id;
@@ -791,8 +798,7 @@ RAWINPUT_AddDevice(HANDLE hDevice)
             SDL_free(product_string);
         }
     }
-
-    CHECK(SDL_HidD_GetPreparsedData(hFile, &device->preparsed_data));
+    device->path = SDL_strdup(dev_name);
 
     CloseHandle(hFile);
     hFile = INVALID_HANDLE_VALUE;
@@ -825,8 +831,12 @@ err:
         CloseHandle(hFile);
     }
     if (device) {
-        if (device->name)
+        if (device->name) {
             SDL_free(device->name);
+        }
+        if (device->path) {
+            SDL_free(device->path);
+        }
         SDL_free(device);
     }
 #undef CHECK
@@ -1029,6 +1039,12 @@ RAWINPUT_JoystickGetDeviceName(int device_index)
     return RAWINPUT_GetDeviceByIndex(device_index)->name;
 }
 
+static const char *
+RAWINPUT_JoystickGetDevicePath(int device_index)
+{
+    return RAWINPUT_GetDeviceByIndex(device_index)->path;
+}
+
 static int
 RAWINPUT_JoystickGetDevicePlayerIndex(int device_index)
 {
@@ -1053,7 +1069,7 @@ RAWINPUT_JoystickGetDeviceInstanceID(int device_index)
     return RAWINPUT_GetDeviceByIndex(device_index)->joystick_id;
 }
 
-static int
+static int SDLCALL
 RAWINPUT_SortValueCaps(const void *A, const void *B)
 {
     HIDP_VALUE_CAPS *capsA = (HIDP_VALUE_CAPS *)A;
@@ -1253,7 +1269,7 @@ RAWINPUT_JoystickOpen(SDL_Joystick *joystick, int device_index)
         }
     }
 
-    SDL_PrivateJoystickBatteryLevel(joystick, SDL_JOYSTICK_POWER_UNKNOWN);
+    joystick->epowerlevel = SDL_JOYSTICK_POWER_UNKNOWN;
 
     return 0;
 }
@@ -1263,8 +1279,8 @@ RAWINPUT_JoystickRumble(SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uin
 {
 #if defined(SDL_JOYSTICK_RAWINPUT_WGI) || defined(SDL_JOYSTICK_RAWINPUT_XINPUT)
     RAWINPUT_DeviceContext *ctx = joystick->hwdata;
-    SDL_bool rumbled = SDL_FALSE;
 #endif
+    SDL_bool rumbled = SDL_FALSE;
 
 #ifdef SDL_JOYSTICK_RAWINPUT_WGI
     if (!rumbled && ctx->wgi_correlated) {
@@ -1312,7 +1328,7 @@ RAWINPUT_JoystickRumbleTriggers(SDL_Joystick *joystick, Uint16 left_rumble, Uint
 {
 #if defined(SDL_JOYSTICK_RAWINPUT_WGI)
     RAWINPUT_DeviceContext *ctx = joystick->hwdata;
-    
+
     if (ctx->wgi_correlated) {
         WindowsGamingInputGamepadState *gamepad_state = ctx->wgi_slot;
         HRESULT hr;
@@ -1570,17 +1586,25 @@ RAWINPUT_UpdateOtherAPIs(SDL_Joystick *joystick)
     int guide_button = joystick->nbuttons - 1;
     int left_trigger = joystick->naxes - 2;
     int right_trigger = joystick->naxes - 1;
+#ifdef SDL_JOYSTICK_RAWINPUT_WGI
+    SDL_bool xinput_correlated;
+#endif
 
     RAWINPUT_FillMatchState(&match_state_xinput, ctx->match_state);
 
 #ifdef SDL_JOYSTICK_RAWINPUT_WGI
+    #ifdef SDL_JOYSTICK_RAWINPUT_XINPUT
+    xinput_correlated = ctx->xinput_correlated;
+    #else
+    xinput_correlated = SDL_FALSE;
+    #endif
     /* Parallel logic to WINDOWS_XINPUT below */
     RAWINPUT_UpdateWindowsGamingInput();
     if (ctx->wgi_correlated &&
         !joystick->low_frequency_rumble && !joystick->high_frequency_rumble &&
         !joystick->left_trigger_rumble && !joystick->right_trigger_rumble) {
         /* We have been previously correlated, ensure we are still matching, see comments in XINPUT section */
-        if (RAWINPUT_WindowsGamingInputSlotMatches(&match_state_xinput, ctx->wgi_slot, ctx->xinput_correlated)) {
+        if (RAWINPUT_WindowsGamingInputSlotMatches(&match_state_xinput, ctx->wgi_slot, xinput_correlated)) {
             ctx->wgi_uncorrelate_count = 0;
         } else {
             ++ctx->wgi_uncorrelate_count;
@@ -1609,7 +1633,7 @@ RAWINPUT_UpdateOtherAPIs(SDL_Joystick *joystick)
         if (RAWINPUT_MissingWindowsGamingInputSlot()) {
             Uint8 correlation_id;
             WindowsGamingInputGamepadState *slot_idx = NULL;
-            if (RAWINPUT_GuessWindowsGamingInputSlot(&match_state_xinput, &correlation_id, &slot_idx, ctx->xinput_correlated)) {
+            if (RAWINPUT_GuessWindowsGamingInputSlot(&match_state_xinput, &correlation_id, &slot_idx, xinput_correlated)) {
                 /* we match exactly one WindowsGamingInput device */
                 /* Probably can do without wgi_correlation_count, just check and clear wgi_slot to NULL, unless we need
                    even more frames to be sure. */
@@ -1911,7 +1935,7 @@ RAWINPUT_UnregisterNotifications()
         return;
     }
 }
-    
+
 LRESULT CALLBACK
 RAWINPUT_WindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
 {
@@ -2006,6 +2030,7 @@ SDL_JoystickDriver SDL_RAWINPUT_JoystickDriver =
     RAWINPUT_JoystickGetCount,
     RAWINPUT_JoystickDetect,
     RAWINPUT_JoystickGetDeviceName,
+    RAWINPUT_JoystickGetDevicePath,
     RAWINPUT_JoystickGetDevicePlayerIndex,
     RAWINPUT_JoystickSetDevicePlayerIndex,
     RAWINPUT_JoystickGetDeviceGUID,
diff --git a/Engine/lib/sdl/src/joystick/windows/SDL_windows_gaming_input.c b/Engine/lib/sdl/src/joystick/windows/SDL_windows_gaming_input.c
index 6c5ec5528..8b552bb7d 100644
--- a/Engine/lib/sdl/src/joystick/windows/SDL_windows_gaming_input.c
+++ b/Engine/lib/sdl/src/joystick/windows/SDL_windows_gaming_input.c
@@ -586,6 +586,12 @@ WGI_JoystickGetDeviceName(int device_index)
     return wgi.controllers[device_index].name;
 }
 
+static const char *
+WGI_JoystickGetDevicePath(int device_index)
+{
+    return NULL;
+}
+
 static int
 WGI_JoystickGetDevicePlayerIndex(int device_index)
 {
@@ -893,6 +899,7 @@ SDL_JoystickDriver SDL_WGI_JoystickDriver =
     WGI_JoystickGetCount,
     WGI_JoystickDetect,
     WGI_JoystickGetDeviceName,
+    WGI_JoystickGetDevicePath,
     WGI_JoystickGetDevicePlayerIndex,
     WGI_JoystickSetDevicePlayerIndex,
     WGI_JoystickGetDeviceGUID,
diff --git a/Engine/lib/sdl/src/joystick/windows/SDL_windowsjoystick.c b/Engine/lib/sdl/src/joystick/windows/SDL_windowsjoystick.c
index 7dae16d9f..463afd7e5 100644
--- a/Engine/lib/sdl/src/joystick/windows/SDL_windowsjoystick.c
+++ b/Engine/lib/sdl/src/joystick/windows/SDL_windowsjoystick.c
@@ -330,7 +330,7 @@ SDL_WaitForDeviceNotification(SDL_DeviceNotificationData *data, SDL_mutex *mutex
 static SDL_DeviceNotificationData s_notification_data;
 
 /* Function/thread to scan the system for joysticks. */
-static int
+static int SDLCALL
 SDL_JoystickThread(void *_data)
 {
 #if SDL_JOYSTICK_XINPUT
@@ -555,7 +555,6 @@ WINDOWS_JoystickDetect(void)
     }
 }
 
-/* Function to get the device-dependent name of a joystick */
 static const char *
 WINDOWS_JoystickGetDeviceName(int device_index)
 {
@@ -568,6 +567,18 @@ WINDOWS_JoystickGetDeviceName(int device_index)
     return device->joystickname;
 }
 
+static const char *
+WINDOWS_JoystickGetDevicePath(int device_index)
+{
+    JoyStick_DeviceData *device = SYS_Joystick;
+    int index;
+
+    for (index = device_index; index > 0; index--)
+        device = device->pNext;
+
+    return device->path;
+}
+
 static int
 WINDOWS_JoystickGetDevicePlayerIndex(int device_index)
 {
@@ -755,6 +766,7 @@ SDL_JoystickDriver SDL_WINDOWS_JoystickDriver =
     WINDOWS_JoystickGetCount,
     WINDOWS_JoystickDetect,
     WINDOWS_JoystickGetDeviceName,
+    WINDOWS_JoystickGetDevicePath,
     WINDOWS_JoystickGetDevicePlayerIndex,
     WINDOWS_JoystickSetDevicePlayerIndex,
     WINDOWS_JoystickGetDeviceGUID,
diff --git a/Engine/lib/sdl/src/joystick/windows/SDL_windowsjoystick_c.h b/Engine/lib/sdl/src/joystick/windows/SDL_windowsjoystick_c.h
index 1b9625385..d7e09abde 100644
--- a/Engine/lib/sdl/src/joystick/windows/SDL_windowsjoystick_c.h
+++ b/Engine/lib/sdl/src/joystick/windows/SDL_windowsjoystick_c.h
@@ -37,7 +37,7 @@ typedef struct JoyStick_DeviceData
     BYTE SubType;
     Uint8 XInputUserId;
     DIDEVICEINSTANCE dxdevice;
-    char hidPath[MAX_PATH];
+    char path[MAX_PATH];
     struct JoyStick_DeviceData *pNext;
 } JoyStick_DeviceData;
 
diff --git a/Engine/lib/sdl/src/joystick/windows/SDL_xinputjoystick.c b/Engine/lib/sdl/src/joystick/windows/SDL_xinputjoystick.c
index f3ab8a0b2..439957399 100644
--- a/Engine/lib/sdl/src/joystick/windows/SDL_xinputjoystick.c
+++ b/Engine/lib/sdl/src/joystick/windows/SDL_xinputjoystick.c
@@ -297,6 +297,7 @@ AddXInputDevice(Uint8 userid, BYTE SubType, JoyStick_DeviceData **pContext)
         SDL_free(pNewJoystick);
         return; /* better luck next time? */
     }
+    SDL_snprintf(pNewJoystick->path, sizeof(pNewJoystick->path), "XInput#%d", userid);
 
     if (SDL_ShouldIgnoreJoystick(pNewJoystick->joystickname, pNewJoystick->guid)) {
         SDL_free(pNewJoystick);
diff --git a/Engine/lib/sdl/src/libm/math_private.h b/Engine/lib/sdl/src/libm/math_private.h
index 4a30a521a..2e4bb1402 100644
--- a/Engine/lib/sdl/src/libm/math_private.h
+++ b/Engine/lib/sdl/src/libm/math_private.h
@@ -66,9 +66,10 @@ typedef unsigned int u_int32_t;
  * Math on arm is special:
  * For FPA, float words are always big-endian.
  * For VFP, floats words follow the memory system mode.
+ * For Maverick, float words are always little-endian.
  */
 
-#if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
+#if (SDL_FLOATWORDORDER == SDL_BIG_ENDIAN)
 
 typedef union
 {
diff --git a/Engine/lib/sdl/src/main/ngage/SDL_ngage_main.cpp b/Engine/lib/sdl/src/main/ngage/SDL_ngage_main.cpp
new file mode 100644
index 000000000..6dbf2f141
--- /dev/null
+++ b/Engine/lib/sdl/src/main/ngage/SDL_ngage_main.cpp
@@ -0,0 +1,82 @@
+/*
+    SDL_ngage_main.c, originally for SDL 1.2 by Hannu Viitala
+*/
+#include "../../SDL_internal.h"
+
+/* Include the SDL main definition header */
+#include "SDL_main.h"
+
+#include <e32std.h>
+#include <e32def.h>
+#include <e32svr.h>
+#include <e32base.h>
+#include <estlib.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <w32std.h>
+#include <apgtask.h>
+
+#include "SDL_error.h"
+
+extern "C" int main(int argc, char *argv[]);
+
+TInt E32Main()
+{
+    /*  Get the clean-up stack */
+    CTrapCleanup* cleanup = CTrapCleanup::New();
+
+    /* Arrange for multi-threaded operation */
+    SpawnPosixServerThread();
+
+    /* Get args and environment */
+    int    argc = 0;
+    char** argv = 0;
+    char** envp = 0;
+
+    __crt0(argc,argv,envp);
+
+    /* Start the application! */
+
+    /* Create stdlib */
+    _REENT;
+
+    /* Set process and thread priority and name */
+
+    RThread  currentThread;
+    RProcess thisProcess;
+    TParse   exeName;
+    exeName.Set(thisProcess.FileName(), NULL, NULL);
+    currentThread.Rename(exeName.Name());
+    currentThread.SetProcessPriority(EPriorityLow);
+    currentThread.SetPriority(EPriorityMuchLess);
+
+    /* Increase heap size */
+    RHeap* newHeap  = NULL;
+    RHeap* oldHeap  = NULL;
+    TInt   heapSize = 7500000;
+    int    ret;
+
+    newHeap = User::ChunkHeap(NULL, heapSize, heapSize, KMinHeapGrowBy);
+
+    if (NULL == newHeap)
+    {
+        ret = 3;
+        goto cleanup;
+    }
+    else
+    {
+        oldHeap = User::SwitchHeap(newHeap);
+        /* Call stdlib main */
+        SDL_SetMainReady();
+        ret = SDL_main(argc, argv);
+    }
+
+cleanup:
+    _cleanup();
+
+    CloseSTDLIB();
+    delete cleanup;
+    return ret;
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/main/uikit/SDL_uikit_main.c b/Engine/lib/sdl/src/main/uikit/SDL_uikit_main.c
index 702f67391..62cfffd5c 100644
--- a/Engine/lib/sdl/src/main/uikit/SDL_uikit_main.c
+++ b/Engine/lib/sdl/src/main/uikit/SDL_uikit_main.c
@@ -1,7 +1,6 @@
 /*
     SDL_uikit_main.c, placed in the public domain by Sam Lantinga  3/18/2019
 */
-#include "../../SDL_internal.h"
 
 /* Include the SDL main definition header */
 #include "SDL_main.h"
diff --git a/Engine/lib/sdl/src/main/windows/version.rc b/Engine/lib/sdl/src/main/windows/version.rc
index 11e1394f8..c81b64653 100644
--- a/Engine/lib/sdl/src/main/windows/version.rc
+++ b/Engine/lib/sdl/src/main/windows/version.rc
@@ -9,8 +9,8 @@ LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
 //
 
 VS_VERSION_INFO VERSIONINFO
- FILEVERSION 2,0,22,0
- PRODUCTVERSION 2,0,22,0
+ FILEVERSION 2,23,0,0
+ PRODUCTVERSION 2,23,0,0
  FILEFLAGSMASK 0x3fL
  FILEFLAGS 0x0L
  FILEOS 0x40004L
@@ -23,12 +23,12 @@ BEGIN
         BEGIN
             VALUE "CompanyName", "\0"
             VALUE "FileDescription", "SDL\0"
-            VALUE "FileVersion", "2, 0, 22, 0\0"
+            VALUE "FileVersion", "2, 23, 0, 0\0"
             VALUE "InternalName", "SDL\0"
             VALUE "LegalCopyright", "Copyright (C) 2022 Sam Lantinga\0"
             VALUE "OriginalFilename", "SDL2.dll\0"
             VALUE "ProductName", "Simple DirectMedia Layer\0"
-            VALUE "ProductVersion", "2, 0, 22, 0\0"
+            VALUE "ProductVersion", "2, 23, 0, 0\0"
         END
     END
     BLOCK "VarFileInfo"
diff --git a/Engine/lib/sdl/src/render/SDL_render.c b/Engine/lib/sdl/src/render/SDL_render.c
index 58cda3d60..d94b0a988 100644
--- a/Engine/lib/sdl/src/render/SDL_render.c
+++ b/Engine/lib/sdl/src/render/SDL_render.c
@@ -2670,11 +2670,16 @@ static int
 RenderDrawPointsWithRects(SDL_Renderer * renderer,
                           const SDL_Point * points, const int count)
 {
-    int retval = -1;
+    int retval;
     SDL_bool isstack;
-    SDL_FRect *frects = SDL_small_alloc(SDL_FRect, count, &isstack);
+    SDL_FRect *frects;
     int i;
 
+    if (count < 1) {
+        return 0;
+    }
+
+    frects = SDL_small_alloc(SDL_FRect, count, &isstack);
     if (!frects) {
         return SDL_OutOfMemory();
     }
@@ -2686,9 +2691,7 @@ RenderDrawPointsWithRects(SDL_Renderer * renderer,
         frects[i].h = renderer->scale.y;
     }
 
-    if (count) {
-        retval = QueueCmdFillRects(renderer, frects, count);
-    }
+    retval = QueueCmdFillRects(renderer, frects, count);
 
     SDL_small_free(frects, isstack);
 
@@ -2743,11 +2746,16 @@ static int
 RenderDrawPointsWithRectsF(SDL_Renderer * renderer,
                            const SDL_FPoint * fpoints, const int count)
 {
-    int retval = -1;
+    int retval;
     SDL_bool isstack;
-    SDL_FRect *frects = SDL_small_alloc(SDL_FRect, count, &isstack);
+    SDL_FRect *frects;
     int i;
 
+    if (count < 1) {
+        return 0;
+    }
+
+    frects = SDL_small_alloc(SDL_FRect, count, &isstack);
     if (!frects) {
         return SDL_OutOfMemory();
     }
@@ -2759,9 +2767,7 @@ RenderDrawPointsWithRectsF(SDL_Renderer * renderer,
         frects[i].h = renderer->scale.y;
     }
 
-    if (count) {
-        retval = QueueCmdFillRects(renderer, frects, count);
-    }
+    retval = QueueCmdFillRects(renderer, frects, count);
 
     SDL_small_free(frects, isstack);
 
diff --git a/Engine/lib/sdl/src/render/direct3d/SDL_render_d3d.c b/Engine/lib/sdl/src/render/direct3d/SDL_render_d3d.c
index 477f4e975..97047f4bf 100644
--- a/Engine/lib/sdl/src/render/direct3d/SDL_render_d3d.c
+++ b/Engine/lib/sdl/src/render/direct3d/SDL_render_d3d.c
@@ -41,6 +41,13 @@
 
 #include "SDL_shaders_d3d.h"
 
+#ifdef __WATCOMC__
+/* FIXME: Remove this once https://github.com/open-watcom/open-watcom-v2/pull/868 is merged */
+#define D3DBLENDOP_REVSUBTRACT 3
+/* FIXME: Remove this once https://github.com/open-watcom/open-watcom-v2/pull/869 is merged */
+#define D3DERR_UNSUPPORTEDCOLOROPERATION MAKE_D3DHRESULT( 2073 )
+#endif
+
 typedef struct
 {
     SDL_Rect viewport;
@@ -1079,7 +1086,13 @@ SetDrawState(D3D_RenderData *data, const SDL_RenderCommand *cmd)
 
     if (data->drawstate.viewport_dirty) {
         const SDL_Rect *viewport = &data->drawstate.viewport;
-        const D3DVIEWPORT9 d3dviewport = { viewport->x, viewport->y, viewport->w, viewport->h, 0.0f, 1.0f };
+        D3DVIEWPORT9 d3dviewport;
+        d3dviewport.X = viewport->x;
+        d3dviewport.Y = viewport->y;
+        d3dviewport.Width = viewport->w;
+        d3dviewport.Height = viewport->h;
+        d3dviewport.MinZ = 0.0f;
+        d3dviewport.MaxZ = 1.0f;
         IDirect3DDevice9_SetViewport(data->device, &d3dviewport);
 
         /* Set an orthographic projection matrix */
@@ -1106,7 +1119,11 @@ SetDrawState(D3D_RenderData *data, const SDL_RenderCommand *cmd)
     if (data->drawstate.cliprect_dirty) {
         const SDL_Rect *viewport = &data->drawstate.viewport;
         const SDL_Rect *rect = &data->drawstate.cliprect;
-        const RECT d3drect = { viewport->x + rect->x, viewport->y + rect->y, viewport->x + rect->x + rect->w, viewport->y + rect->y + rect->h };
+        RECT d3drect;
+        d3drect.left = viewport->x + rect->x;
+        d3drect.top = viewport->y + rect->y;
+        d3drect.right = viewport->x + rect->x + rect->w;
+        d3drect.bottom = viewport->y + rect->y + rect->h;
         IDirect3DDevice9_SetScissorRect(data->device, &d3drect);
         data->drawstate.cliprect_dirty = SDL_FALSE;
     }
@@ -1221,7 +1238,9 @@ D3D_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *verti
                     IDirect3DDevice9_Clear(data->device, 0, NULL, D3DCLEAR_TARGET, color, 0.0f, 0);
                 } else {
                     /* Clear is defined to clear the entire render target */
-                    const D3DVIEWPORT9 wholeviewport = { 0, 0, backw, backh, 0.0f, 1.0f };
+                    D3DVIEWPORT9 wholeviewport = { 0, 0, 0, 0, 0.0f, 1.0f };
+                    wholeviewport.Width = backw;
+                    wholeviewport.Height = backh;
                     IDirect3DDevice9_SetViewport(data->device, &wholeviewport);
                     data->drawstate.viewport_dirty = SDL_TRUE;  /* we still need to (re)set orthographic projection, so always mark it dirty. */
                     IDirect3DDevice9_Clear(data->device, 0, NULL, D3DCLEAR_TARGET, color, 0.0f, 0);
diff --git a/Engine/lib/sdl/src/render/metal/SDL_render_metal.m b/Engine/lib/sdl/src/render/metal/SDL_render_metal.m
index 329e5b3a0..6ade20c12 100644
--- a/Engine/lib/sdl/src/render/metal/SDL_render_metal.m
+++ b/Engine/lib/sdl/src/render/metal/SDL_render_metal.m
@@ -142,24 +142,6 @@ typedef struct METAL_ShaderPipelines
 @end
 
 @implementation METAL_RenderData
-#if !__has_feature(objc_arc)
-- (void)dealloc
-{
-    [_mtldevice release];
-    [_mtlcmdqueue release];
-    [_mtlcmdbuffer release];
-    [_mtlcmdencoder release];
-    [_mtllibrary release];
-    [_mtlbackbuffer release];
-    [_mtlsamplernearest release];
-    [_mtlsamplerlinear release];
-    [_mtlbufconstants release];
-    [_mtlbufquadindices release];
-    [_mtllayer release];
-    [_mtlpassdesc release];
-    [super dealloc];
-}
-#endif
 @end
 
 @interface METAL_TextureData : NSObject
@@ -178,16 +160,6 @@ typedef struct METAL_ShaderPipelines
 @end
 
 @implementation METAL_TextureData
-#if !__has_feature(objc_arc)
-- (void)dealloc
-{
-    [_mtltexture release];
-    [_mtltexture_uv release];
-    [_mtlsampler release];
-    [_lockedbuffer release];
-    [super dealloc];
-}
-#endif
 @end
 
 static int
@@ -342,13 +314,6 @@ MakePipelineState(METAL_RenderData *data, METAL_PipelineCache *cache,
 
     METAL_PipelineState *states = SDL_realloc(cache->states, (cache->count + 1) * sizeof(pipeline));
 
-#if !__has_feature(objc_arc)
-    [mtlpipedesc release];  // !!! FIXME: can these be reused for each creation, or does the pipeline obtain it?
-    [mtlvertfn release];
-    [mtlfragfn release];
-    [state release];
-#endif
-
     if (states) {
         states[cache->count++] = pipeline;
         cache->states = states;
@@ -632,9 +597,6 @@ METAL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
     if (yuv || nv12) {
         mtltexture_uv = [data.mtldevice newTextureWithDescriptor:mtltexdesc];
         if (mtltexture_uv == nil) {
-#if !__has_feature(objc_arc)
-            [mtltexture release];
-#endif
             return SDL_SetError("Texture allocation failed");
         }
     }
@@ -677,12 +639,6 @@ METAL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
 #endif
     texture->driverdata = (void*)CFBridgingRetain(texturedata);
 
-#if !__has_feature(objc_arc)
-    [texturedata release];
-    [mtltexture release];
-    [mtltexture_uv release];
-#endif
-
     return 0;
 }}
 
@@ -742,10 +698,6 @@ METAL_UpdateTextureInternal(SDL_Renderer * renderer, METAL_TextureData *textured
         return SDL_OutOfMemory();
     }
 
-#if !__has_feature(objc_arc)
-    [stagingtex autorelease];
-#endif
-
     METAL_UploadTextureData(stagingtex, stagingrect, 0, pixels, pitch);
 
     if (data.mtlcmdencoder != nil) {
@@ -917,11 +869,6 @@ METAL_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
     texturedata.lockedbuffer = lockedbuffer;
     *pixels = [lockedbuffer contents];
 
-    /* METAL_TextureData.lockedbuffer retains. */
-#if !__has_feature(objc_arc)
-    [lockedbuffer release];
-#endif
-
     return 0;
 }}
 
@@ -1209,13 +1156,8 @@ METAL_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture
 
 typedef struct
 {
-    #if __has_feature(objc_arc)
     __unsafe_unretained id<MTLRenderPipelineState> pipeline;
     __unsafe_unretained id<MTLBuffer> vertex_buffer;
-    #else
-    id<MTLRenderPipelineState> pipeline;
-    id<MTLBuffer> vertex_buffer;
-    #endif
     size_t constants_offset;
     SDL_Texture *texture;
     SDL_bool cliprect_dirty;
@@ -1365,9 +1307,6 @@ METAL_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *ver
          * TODO: this buffer is also used for constants. Is performance still
          * good for those, or should we have a managed buffer for them? */
         mtlbufvertex = [data.mtldevice newBufferWithLength:vertsize options:MTLResourceStorageModeShared];
-        #if !__has_feature(objc_arc)
-        [mtlbufvertex autorelease];
-        #endif
         mtlbufvertex.label = @"SDL vertex data";
         SDL_memcpy([mtlbufvertex contents], vertices, vertsize);
 
@@ -1711,9 +1650,6 @@ METAL_CreateRenderer(SDL_Window * window, Uint32 flags)
     }
 
     if (view == NULL) {
-#if !__has_feature(objc_arc)
-        [mtldevice release];
-#endif
         SDL_free(renderer);
         if (changed_window) {
             SDL_RecreateWindow(window, window_flags);
@@ -1725,9 +1661,6 @@ METAL_CreateRenderer(SDL_Window * window, Uint32 flags)
     data = [[METAL_RenderData alloc] init];
 
     if (data == nil) {
-#if !__has_feature(objc_arc)
-        [mtldevice release];
-#endif
         /* Release the metal view instead of destroying it,
            in case we want to use it later (recreating the renderer)
          */
@@ -1746,7 +1679,7 @@ METAL_CreateRenderer(SDL_Window * window, Uint32 flags)
     data.mtlview = view;
 
 #ifdef __MACOSX__
-    layer = (CAMetalLayer *)[(NSView *)view layer];
+    layer = (CAMetalLayer *)[(__bridge NSView *)view layer];
 #else
     layer = (CAMetalLayer *)[(__bridge UIView *)view layer];
 #endif
@@ -1771,9 +1704,6 @@ METAL_CreateRenderer(SDL_Window * window, Uint32 flags)
     id<MTLLibrary> mtllibrary = [data.mtldevice newLibraryWithData:mtllibdata error:&err];
     data.mtllibrary = mtllibrary;
     SDL_assert(err == nil);
-#if !__has_feature(objc_arc)
-    dispatch_release(mtllibdata);
-#endif
     data.mtllibrary.label = @"SDL Metal renderer shader library";
 
     /* Do some shader pipeline state loading up-front rather than on demand. */
@@ -1831,9 +1761,6 @@ METAL_CreateRenderer(SDL_Window * window, Uint32 flags)
     };
 
     id<MTLBuffer> mtlbufconstantstaging = [data.mtldevice newBufferWithLength:CONSTANTS_LENGTH options:MTLResourceStorageModeShared];
-    #if !__has_feature(objc_arc)
-    [mtlbufconstantstaging autorelease];
-    #endif
 
     char *constantdata = [mtlbufconstantstaging contents];
     SDL_memcpy(constantdata + CONSTANTS_OFFSET_IDENTITY, identitytransform, sizeof(identitytransform));
@@ -1845,9 +1772,6 @@ METAL_CreateRenderer(SDL_Window * window, Uint32 flags)
     int quadcount = UINT16_MAX / 4;
     size_t indicessize = sizeof(UInt16) * quadcount * 6;
     id<MTLBuffer> mtlbufquadindicesstaging = [data.mtldevice newBufferWithLength:indicessize options:MTLResourceStorageModeShared];
-#if !__has_feature(objc_arc)
-    [mtlbufquadindicesstaging autorelease];
-#endif
 
     /* Quads in the following vertex order (matches the FillRects vertices):
      * 1---3
@@ -1965,18 +1889,6 @@ METAL_CreateRenderer(SDL_Window * window, Uint32 flags)
     renderer->info.max_texture_width = maxtexsize;
     renderer->info.max_texture_height = maxtexsize;
 
-#if !__has_feature(objc_arc)
-    [mtlcmdqueue release];
-    [mtllibrary release];
-    [samplerdesc release];
-    [mtlsamplernearest release];
-    [mtlsamplerlinear release];
-    [mtlbufconstants release];
-    [mtlbufquadindices release];
-    [data release];
-    [mtldevice release];
-#endif
-
     return renderer;
 }}
 
diff --git a/Engine/lib/sdl/src/render/software/SDL_rotate.c b/Engine/lib/sdl/src/render/software/SDL_rotate.c
index 6a9efac9c..d5ffc147a 100644
--- a/Engine/lib/sdl/src/render/software/SDL_rotate.c
+++ b/Engine/lib/sdl/src/render/software/SDL_rotate.c
@@ -61,11 +61,6 @@ typedef struct tColorY {
     Uint8 y;
 } tColorY;
 
-/* !
-\brief Returns maximum of two numbers a and b.
-*/
-#define MAX(a,b)    (((a) > (b)) ? (a) : (b))
-
 /* !
 \brief Number of guard rows added to destination surfaces.
 
diff --git a/Engine/lib/sdl/src/render/software/SDL_rotate.h b/Engine/lib/sdl/src/render/software/SDL_rotate.h
index 171baa5dd..8d7ec9d28 100644
--- a/Engine/lib/sdl/src/render/software/SDL_rotate.h
+++ b/Engine/lib/sdl/src/render/software/SDL_rotate.h
@@ -22,10 +22,6 @@
 #ifndef SDL_rotate_h_
 #define SDL_rotate_h_
 
-#ifndef MIN
-#define MIN(a,b)    (((a) < (b)) ? (a) : (b))
-#endif
-
 extern SDL_Surface *SDLgfx_rotateSurface(SDL_Surface * src, double angle, int smooth, int flipx, int flipy,
         const SDL_Rect *rect_dest, double cangle, double sangle, const SDL_FPoint *center);
 extern void SDLgfx_rotozoomSurfaceSizeTrig(int width, int height, double angle, const SDL_FPoint *center,
diff --git a/Engine/lib/sdl/src/stdlib/SDL_iconv.c b/Engine/lib/sdl/src/stdlib/SDL_iconv.c
index 3f5c82745..f3a4cbbee 100644
--- a/Engine/lib/sdl/src/stdlib/SDL_iconv.c
+++ b/Engine/lib/sdl/src/stdlib/SDL_iconv.c
@@ -126,7 +126,7 @@ static struct
     const char *name;
     int format;
 } encodings[] = {
-/* *INDENT-OFF* */
+/* *INDENT-OFF* */ /* clang-format off */
     { "ASCII", ENCODING_ASCII },
     { "US-ASCII", ENCODING_ASCII },
     { "8859-1", ENCODING_LATIN1 },
@@ -160,7 +160,7 @@ static struct
     { "UCS-4LE", ENCODING_UCS4LE },
     { "UCS-4BE", ENCODING_UCS4BE },
     { "UCS-4-INTERNAL", ENCODING_UCS4NATIVE },
-/* *INDENT-ON* */
+/* *INDENT-ON* */ /* clang-format on */
 };
 
 static const char *
diff --git a/Engine/lib/sdl/src/stdlib/SDL_malloc.c b/Engine/lib/sdl/src/stdlib/SDL_malloc.c
index b5dd6414f..0a51dddce 100644
--- a/Engine/lib/sdl/src/stdlib/SDL_malloc.c
+++ b/Engine/lib/sdl/src/stdlib/SDL_malloc.c
@@ -733,7 +733,7 @@ extern "C"
   maximum supported value of n differs across systems, but is in all
   cases less than the maximum representable value of a size_t.
 */
-    void *dlmalloc(size_t);
+    void * SDLCALL dlmalloc(size_t);
 
 /*
   free(void* p)
@@ -742,14 +742,14 @@ extern "C"
   It has no effect if p is null. If p was not malloced or already
   freed, free(p) will by default cause the current program to abort.
 */
-    void dlfree(void *);
+    void SDLCALL dlfree(void *);
 
 /*
   calloc(size_t n_elements, size_t element_size);
   Returns a pointer to n_elements * element_size bytes, with all locations
   set to zero.
 */
-    void *dlcalloc(size_t, size_t);
+    void * SDLCALL dlcalloc(size_t, size_t);
 
 /*
   realloc(void* p, size_t n)
@@ -774,7 +774,7 @@ extern "C"
   to be used as an argument to realloc is not supported.
 */
 
-    void *dlrealloc(void *, size_t);
+    void * SDLCALL dlrealloc(void *, size_t);
 
 /*
   memalign(size_t alignment, size_t n);
@@ -5305,10 +5305,10 @@ History:
 #endif /* !HAVE_MALLOC */
 
 #ifdef HAVE_MALLOC
-#define real_malloc malloc
-#define real_calloc calloc
-#define real_realloc realloc
-#define real_free free
+static void* SDLCALL real_malloc(size_t s) { return malloc(s); }
+static void* SDLCALL real_calloc(size_t n, size_t s) { return calloc(n, s); }
+static void* SDLCALL real_realloc(void *p, size_t s) { return realloc(p,s); }
+static void  SDLCALL real_free(void *p) { free(p); }
 #else
 #define real_malloc dlmalloc
 #define real_calloc dlcalloc
diff --git a/Engine/lib/sdl/src/stdlib/SDL_qsort.c b/Engine/lib/sdl/src/stdlib/SDL_qsort.c
index b175f444e..26e97c908 100644
--- a/Engine/lib/sdl/src/stdlib/SDL_qsort.c
+++ b/Engine/lib/sdl/src/stdlib/SDL_qsort.c
@@ -534,5 +534,38 @@ extern void qsortG(void *base, size_t nmemb, size_t size,
 
 #endif /* HAVE_QSORT */
 
+void *
+SDL_bsearch(const void *key, const void *base, size_t nmemb, size_t size, int (*compare)(const void *, const void *))
+{
+#if defined(HAVE_BSEARCH)
+    return bsearch(key, base, nmemb, size, compare);
+#else
+/* SDL's replacement:  Taken from the Public Domain C Library (PDCLib):
+   Permission is granted to use, modify, and / or redistribute at will.
+*/
+    const void *pivot;
+    size_t corr;
+    int rc;
+
+    while (nmemb) {
+        /* algorithm needs -1 correction if remaining elements are an even number. */
+        corr = nmemb % 2;
+        nmemb /= 2;
+        pivot = (const char *)base + (nmemb * size);
+        rc = compare(key, pivot);
+
+        if (rc > 0) {
+            base = (const char *)pivot + size;
+            /* applying correction */
+            nmemb -= (1 - corr);
+        } else if (rc == 0) {
+            return (void *)pivot;
+        }
+    }
+
+    return NULL;
+#endif /* HAVE_BSEARCH */
+}
+
 /* vi: set ts=4 sw=4 expandtab: */
 
diff --git a/Engine/lib/sdl/src/stdlib/SDL_stdlib.c b/Engine/lib/sdl/src/stdlib/SDL_stdlib.c
index 9d785aad5..62cbef884 100644
--- a/Engine/lib/sdl/src/stdlib/SDL_stdlib.c
+++ b/Engine/lib/sdl/src/stdlib/SDL_stdlib.c
@@ -549,8 +549,9 @@ int SDL_isblank(int x) { return ((x) == ' ') || ((x) == '\t'); }
 __declspec(selectany) int _fltused = 1;
 #endif
 
-/* The optimizer on Visual Studio 2005 and later generates memcpy() and memset() calls */
-#if _MSC_VER >= 1400
+/* The optimizer on Visual Studio 2005 and later generates memcpy() and memset() calls.
+   Always provide it for the SDL2 DLL, but skip it when building static lib w/ static runtime. */
+#if (_MSC_VER >= 1400) && (!defined(_MT) || defined(DLL_EXPORT))
 extern void *memcpy(void* dst, const void* src, size_t len);
 #pragma intrinsic(memcpy)
 
@@ -570,7 +571,7 @@ memset(void *dst, int c, size_t len)
 {
     return SDL_memset(dst, c, len);
 }
-#endif /* _MSC_VER >= 1400 */
+#endif /* (_MSC_VER >= 1400) && (!defined(_MT) || defined(DLL_EXPORT)) */
 
 #ifdef _M_IX86
 
diff --git a/Engine/lib/sdl/src/stdlib/SDL_string.c b/Engine/lib/sdl/src/stdlib/SDL_string.c
index 133193072..3125e8390 100644
--- a/Engine/lib/sdl/src/stdlib/SDL_string.c
+++ b/Engine/lib/sdl/src/stdlib/SDL_string.c
@@ -27,14 +27,7 @@
 /* This file contains portable string manipulation functions for SDL */
 
 #include "SDL_stdinc.h"
-
-#if defined(_MSC_VER) && _MSC_VER <= 1800
-/* Visual Studio 2013 tries to link with _vacopy in the C runtime. Newer versions do an inline assignment */
-#undef va_copy
-#define va_copy(dst, src)   dst = src
-#elif defined(__GNUC__) && (__GNUC__ < 3)
-#define va_copy(to, from)   __va_copy(to, from)
-#endif
+#include "SDL_vacopy.h"
 
 #if !defined(HAVE_VSSCANF) || !defined(HAVE_STRTOL) || !defined(HAVE_STRTOUL) || !defined(HAVE_STRTOD) || !defined(HAVE_STRTOLL) || !defined(HAVE_STRTOULL)
 #define SDL_isupperhex(X)   (((X) >= 'A') && ((X) <= 'F'))
diff --git a/Engine/lib/sdl/src/stdlib/SDL_vacopy.h b/Engine/lib/sdl/src/stdlib/SDL_vacopy.h
new file mode 100644
index 000000000..ab6004695
--- /dev/null
+++ b/Engine/lib/sdl/src/stdlib/SDL_vacopy.h
@@ -0,0 +1,36 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+/* Do our best to make sure va_copy is working */
+#if defined(__NGAGE__)
+#undef va_copy
+#define va_copy(dst, src)   dst = src
+
+#elif defined(_MSC_VER) && _MSC_VER <= 1800
+/* Visual Studio 2013 tries to link with _vacopy in the C runtime. Newer versions do an inline assignment */
+#undef va_copy
+#define va_copy(dst, src)   dst = src
+
+#elif defined(__GNUC__) && (__GNUC__ < 3)
+#define va_copy(dst, src)   __va_copy(dst, src)
+#endif
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/test/SDL_test_harness.c b/Engine/lib/sdl/src/test/SDL_test_harness.c
index 8f10f3e5c..3a1f432b0 100644
--- a/Engine/lib/sdl/src/test/SDL_test_harness.c
+++ b/Engine/lib/sdl/src/test/SDL_test_harness.c
@@ -169,7 +169,7 @@ SDLTest_GenerateExecKey(const char *runSeed, const char *suiteName, const char *
 * \return Timer id or -1 on failure.
 */
 static SDL_TimerID
-SDLTest_SetTestTimeout(int timeout, void (*callback)(void))
+SDLTest_SetTestTimeout(int timeout, void (SDLCALL *callback)(void))
 {
     Uint32 timeoutInMilliseconds;
     SDL_TimerID timerID;
@@ -209,7 +209,7 @@ SDLTest_SetTestTimeout(int timeout, void (*callback)(void))
 #if defined(__WATCOMC__)
 #pragma aux SDLTest_BailOut aborts;
 #endif
-static SDL_NORETURN void
+static SDL_NORETURN void SDLCALL
 SDLTest_BailOut(void)
 {
     SDLTest_LogError("TestCaseTimeout timer expired. Aborting test run.");
diff --git a/Engine/lib/sdl/src/thread/SDL_thread_c.h b/Engine/lib/sdl/src/thread/SDL_thread_c.h
index fb0885a2d..b4df526d1 100644
--- a/Engine/lib/sdl/src/thread/SDL_thread_c.h
+++ b/Engine/lib/sdl/src/thread/SDL_thread_c.h
@@ -40,6 +40,8 @@
 #include "stdcpp/SDL_systhread_c.h"
 #elif SDL_THREAD_OS2
 #include "os2/SDL_systhread_c.h"
+#elif SDL_THREAD_NGAGE
+#include "ngage/SDL_systhread_c.h"
 #else
 #error Need thread implementation for this platform
 #include "generic/SDL_systhread_c.h"
diff --git a/Engine/lib/sdl/src/thread/ngage/SDL_sysmutex.cpp b/Engine/lib/sdl/src/thread/ngage/SDL_sysmutex.cpp
new file mode 100644
index 000000000..34cf4510d
--- /dev/null
+++ b/Engine/lib/sdl/src/thread/ngage/SDL_sysmutex.cpp
@@ -0,0 +1,123 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+/* An implementation of mutexes using the Symbian API. */
+
+#include <e32std.h>
+
+#include "SDL_thread.h"
+#include "SDL_systhread_c.h"
+
+struct SDL_mutex
+{
+    TInt handle;
+};
+
+extern TInt CreateUnique(TInt (*aFunc)(const TDesC& aName, TAny*, TAny*), TAny*, TAny*);
+
+static TInt NewMutex(const TDesC& aName, TAny* aPtr1, TAny*)
+{
+    return ((RMutex*)aPtr1)->CreateGlobal(aName);
+}
+
+/* Create a mutex */
+SDL_mutex *
+SDL_CreateMutex(void)
+{
+    RMutex rmutex;
+
+    TInt status = CreateUnique(NewMutex, &rmutex, NULL);
+    if(status != KErrNone)
+    {
+        SDL_SetError("Couldn't create mutex.");
+    }
+    SDL_mutex* mutex = new /*(ELeave)*/ SDL_mutex;
+    mutex->handle = rmutex.Handle();
+    return(mutex);
+}
+
+/* Free the mutex */
+void
+SDL_DestroyMutex(SDL_mutex * mutex)
+{
+    if (mutex)
+    {
+        RMutex rmutex;
+        rmutex.SetHandle(mutex->handle);
+        rmutex.Signal();
+        rmutex.Close();
+        delete(mutex);
+        mutex = NULL;
+    }
+}
+
+/* Try to lock the mutex */
+#if 0
+int
+SDL_TryLockMutex(SDL_mutex * mutex)
+{
+    if (mutex == NULL)
+    {
+        SDL_SetError("Passed a NULL mutex.");
+        return -1;
+    }
+
+    // Not yet implemented.
+    return 0;
+}
+#endif
+
+/* Lock the mutex */
+int
+SDL_LockMutex(SDL_mutex * mutex)
+{
+    if (mutex == NULL)
+    {
+        SDL_SetError("Passed a NULL mutex.");
+        return -1;
+    }
+
+    RMutex rmutex;
+    rmutex.SetHandle(mutex->handle);
+    rmutex.Wait();
+
+    return(0);
+}
+
+/* Unlock the mutex */
+int
+SDL_UnlockMutex(SDL_mutex * mutex)
+{
+    if ( mutex == NULL )
+    {
+        SDL_SetError("Passed a NULL mutex.");
+        return -1;
+    }
+
+    RMutex rmutex;
+    rmutex.SetHandle(mutex->handle);
+    rmutex.Signal();
+
+    return(0);
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/thread/ngage/SDL_syssem.cpp b/Engine/lib/sdl/src/thread/ngage/SDL_syssem.cpp
new file mode 100644
index 000000000..ab277ca5d
--- /dev/null
+++ b/Engine/lib/sdl/src/thread/ngage/SDL_syssem.cpp
@@ -0,0 +1,195 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+/* An implementation of semaphores using the Symbian API. */
+
+#include <e32std.h>
+
+#include "SDL_error.h"
+#include "SDL_thread.h"
+
+#define SDL_MUTEX_TIMEOUT -2
+
+struct SDL_semaphore
+{
+    TInt handle;
+    TInt count;
+};
+
+struct TInfo
+{
+    TInfo(TInt aTime, TInt aHandle) :
+        iTime(aTime), iHandle(aHandle), iVal(0) {}
+    TInt iTime;
+    TInt iHandle;
+    TInt iVal;
+};
+
+extern TInt CreateUnique(TInt (*aFunc)(const TDesC& aName, TAny*, TAny*), TAny*, TAny*);
+
+static TBool RunThread(TAny* aInfo)
+{
+    TInfo* info = STATIC_CAST(TInfo*, aInfo);
+    User::After(info->iTime);
+    RSemaphore sema;
+    sema.SetHandle(info->iHandle);
+    sema.Signal();
+    info->iVal = SDL_MUTEX_TIMEOUT;
+    return 0;
+}
+
+static TInt
+NewThread(const TDesC& aName, TAny* aPtr1, TAny* aPtr2)
+{
+    return ((RThread*)(aPtr1))->Create
+        (aName,
+         RunThread,
+         KDefaultStackSize,
+         NULL,
+         aPtr2);
+}
+
+static TInt NewSema(const TDesC& aName, TAny* aPtr1, TAny* aPtr2)
+{
+    TInt value = *((TInt*) aPtr2);
+    return ((RSemaphore*)aPtr1)->CreateGlobal(aName, value);
+}
+
+static void WaitAll(SDL_sem *sem)
+{
+    RSemaphore sema;
+    sema.SetHandle(sem->handle);
+    sema.Wait();
+    while(sem->count < 0)
+    {
+        sema.Wait();
+    }
+}
+
+SDL_sem *
+SDL_CreateSemaphore(Uint32 initial_value)
+{
+    RSemaphore s;
+    TInt status = CreateUnique(NewSema, &s, &initial_value);
+    if(status != KErrNone)
+    {
+        SDL_SetError("Couldn't create semaphore");
+    }
+    SDL_semaphore* sem = new /*(ELeave)*/ SDL_semaphore;
+    sem->handle = s.Handle();
+    sem->count = initial_value;
+    return(sem);
+}
+
+void
+SDL_DestroySemaphore(SDL_sem * sem)
+{
+    if (sem)
+    {
+        RSemaphore sema;
+        sema.SetHandle(sem->handle);
+        sema.Signal(sema.Count());
+        sema.Close();
+        delete sem;
+        sem = NULL;
+    }
+}
+
+int
+SDL_SemWaitTimeout(SDL_sem * sem, Uint32 timeout)
+{
+    if (! sem)
+    {
+        SDL_SetError("Passed a NULL sem");
+        return -1;
+    }
+
+    if (timeout == SDL_MUTEX_MAXWAIT)
+    {
+        WaitAll(sem);
+        return SDL_MUTEX_MAXWAIT;
+    }
+
+    RThread thread;
+    TInfo*  info   = new (ELeave)TInfo(timeout, sem->handle);
+    TInt    status = CreateUnique(NewThread, &thread, info);
+
+    if(status != KErrNone)
+    {
+        return status;
+    }
+
+    thread.Resume();
+    WaitAll(sem);
+
+    if(thread.ExitType() == EExitPending)
+    {
+        thread.Kill(SDL_MUTEX_TIMEOUT);
+    }
+
+    thread.Close();
+    return info->iVal;
+}
+
+int
+SDL_SemTryWait(SDL_sem *sem)
+{
+    if(sem->count > 0)
+    {
+        sem->count--;
+    }
+    return SDL_MUTEX_TIMEOUT;
+}
+
+int
+SDL_SemWait(SDL_sem * sem)
+{
+    return SDL_SemWaitTimeout(sem, SDL_MUTEX_MAXWAIT);
+}
+
+Uint32
+SDL_SemValue(SDL_sem * sem)
+{
+    if (! sem)
+    {
+        SDL_SetError("Passed a NULL sem.");
+        return 0;
+    }
+    return sem->count;
+}
+
+int
+SDL_SemPost(SDL_sem * sem)
+{
+    if (! sem)
+    {
+        SDL_SetError("Passed a NULL sem.");
+        return -1;
+    }
+    sem->count++;
+    RSemaphore sema;
+    sema.SetHandle(sem->handle);
+    sema.Signal();
+    return 0;
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/thread/ngage/SDL_systhread.cpp b/Engine/lib/sdl/src/thread/ngage/SDL_systhread.cpp
new file mode 100644
index 000000000..f2c30f7b6
--- /dev/null
+++ b/Engine/lib/sdl/src/thread/ngage/SDL_systhread.cpp
@@ -0,0 +1,134 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if SDL_THREAD_NGAGE
+
+/* N-Gage thread management routines for SDL */
+
+#include <e32std.h>
+
+extern "C" {
+#undef NULL
+#include "SDL_error.h"
+#include "SDL_thread.h"
+#include "../SDL_systhread.h"
+#include "../SDL_thread_c.h"
+};
+
+static int object_count;
+
+static int
+RunThread(TAny* data)
+{
+    SDL_RunThread((SDL_Thread*)data);
+    return(0);
+}
+
+static TInt
+NewThread(const TDesC& aName, TAny* aPtr1, TAny* aPtr2)
+{
+    return ((RThread*)(aPtr1))->Create
+        (aName,
+         RunThread,
+         KDefaultStackSize,
+         NULL,
+         aPtr2);
+}
+
+int
+CreateUnique(TInt (*aFunc)(const TDesC& aName, TAny*, TAny*), TAny* aPtr1, TAny* aPtr2)
+{
+    TBuf<16> name;
+    TInt     status = KErrNone;
+    do
+    {
+        object_count++;
+        name.Format(_L("SDL_%x"), object_count);
+        status = aFunc(name, aPtr1, aPtr2);
+    }
+    while(status == KErrAlreadyExists);
+    return status;
+}
+
+int
+SDL_SYS_CreateThread(SDL_Thread *thread)
+{
+    RThread rthread;
+
+    TInt status = CreateUnique(NewThread, &rthread, thread);
+    if (status != KErrNone)
+    {
+        delete(((RThread*)(thread->handle)));
+        thread->handle = NULL;
+        SDL_SetError("Not enough resources to create thread");
+        return(-1);
+    }
+
+    rthread.Resume();
+    thread->handle = rthread.Handle();
+    return(0);
+}
+
+void
+SDL_SYS_SetupThread(const char *name)
+{
+    return;
+}
+
+SDL_threadID
+SDL_ThreadID(void)
+{
+    RThread   current;
+    TThreadId id = current.Id();
+    return id;
+}
+
+int
+SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority)
+{
+    return (0);
+}
+
+void
+SDL_SYS_WaitThread(SDL_Thread * thread)
+{
+    RThread t;
+    t.Open(thread->threadid);
+    if(t.ExitReason() == EExitPending)
+    {
+        TRequestStatus status;
+        t.Logon(status);
+        User::WaitForRequest(status);
+    }
+    t.Close();
+}
+
+void
+SDL_SYS_DetachThread(SDL_Thread * thread)
+{
+    return;
+}
+
+#endif /* SDL_THREAD_NGAGE */
+
+/* vim: ts=4 sw=4
+ */
diff --git a/Engine/lib/sdl/src/thread/ngage/SDL_systhread_c.h b/Engine/lib/sdl/src/thread/ngage/SDL_systhread_c.h
new file mode 100644
index 000000000..dedceb396
--- /dev/null
+++ b/Engine/lib/sdl/src/thread/ngage/SDL_systhread_c.h
@@ -0,0 +1,25 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+typedef int SYS_ThreadHandle;
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/timer/ngage/SDL_systimer.cpp b/Engine/lib/sdl/src/timer/ngage/SDL_systimer.cpp
new file mode 100644
index 000000000..543d8494d
--- /dev/null
+++ b/Engine/lib/sdl/src/timer/ngage/SDL_systimer.cpp
@@ -0,0 +1,100 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if defined(SDL_TIMER_NGAGE)
+
+#include <e32std.h>
+#include <e32hal.h>
+
+#include "SDL_timer.h"
+
+static SDL_bool ticks_started = SDL_FALSE;
+static TUint    start         = 0;
+static TInt     tickPeriodMilliSeconds;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void
+SDL_TicksInit(void)
+{
+    if (ticks_started)
+    {
+        return;
+    }
+    ticks_started = SDL_TRUE;
+    start         = User::TickCount();
+
+    TTimeIntervalMicroSeconds32 period;
+    TInt                        tmp = UserHal::TickPeriod(period);
+
+    (void)tmp; /* Suppress redundant warning. */
+
+    tickPeriodMilliSeconds = period.Int() / 1000;
+}
+
+void
+SDL_TicksQuit(void)
+{
+    ticks_started = SDL_FALSE;
+}
+
+Uint64
+SDL_GetTicks64(void)
+{
+    if (! ticks_started)
+    {
+        SDL_TicksInit();
+    }
+
+    TUint deltaTics = User::TickCount() - start;
+
+    // Overlaps early, but should do the trick for now.
+    return (Uint64)(deltaTics * tickPeriodMilliSeconds);
+}
+
+Uint64
+SDL_GetPerformanceCounter(void)
+{
+    return (Uint64)User::TickCount();
+}
+
+Uint64
+SDL_GetPerformanceFrequency(void)
+{
+    return 1000000;
+}
+
+void
+SDL_Delay(Uint32 ms)
+{
+    User::After(TTimeIntervalMicroSeconds32(ms * 1000));
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* SDL_TIMER_NGAGE */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/SDL_RLEaccel.c b/Engine/lib/sdl/src/video/SDL_RLEaccel.c
index 983c9d914..b67b765e9 100644
--- a/Engine/lib/sdl/src/video/SDL_RLEaccel.c
+++ b/Engine/lib/sdl/src/video/SDL_RLEaccel.c
@@ -92,10 +92,6 @@
 #include "SDL_blit.h"
 #include "SDL_RLEaccel_c.h"
 
-#ifndef MIN
-#define MIN(a, b) ((a) < (b) ? (a) : (b))
-#endif
-
 #define PIXEL_COPY(to, from, len, bpp)          \
     SDL_memcpy(to, from, (size_t)(len) * (bpp))
 
@@ -1161,13 +1157,13 @@ RLEAlphaSurface(SDL_Surface * surface)
                     ADD_OPAQUE_COUNTS(max_opaque_run, 0);
                     skip -= max_opaque_run;
                 }
-                len = MIN(run, max_opaque_run);
+                len = SDL_min(run, max_opaque_run);
                 ADD_OPAQUE_COUNTS(skip, len);
                 dst += copy_opaque(dst, src + runstart, len, sf, df);
                 runstart += len;
                 run -= len;
                 while (run) {
-                    len = MIN(run, max_opaque_run);
+                    len = SDL_min(run, max_opaque_run);
                     ADD_OPAQUE_COUNTS(0, len);
                     dst += copy_opaque(dst, src + runstart, len, sf, df);
                     runstart += len;
@@ -1195,13 +1191,13 @@ RLEAlphaSurface(SDL_Surface * surface)
                     ADD_TRANSL_COUNTS(max_transl_run, 0);
                     skip -= max_transl_run;
                 }
-                len = MIN(run, max_transl_run);
+                len = SDL_min(run, max_transl_run);
                 ADD_TRANSL_COUNTS(skip, len);
                 dst += copy_transl(dst, src + runstart, len, sf, df);
                 runstart += len;
                 run -= len;
                 while (run) {
-                    len = MIN(run, max_transl_run);
+                    len = SDL_min(run, max_transl_run);
                     ADD_TRANSL_COUNTS(0, len);
                     dst += copy_transl(dst, src + runstart, len, sf, df);
                     runstart += len;
@@ -1222,9 +1218,13 @@ RLEAlphaSurface(SDL_Surface * surface)
 
     /* Now that we have it encoded, release the original pixels */
     if (!(surface->flags & SDL_PREALLOC)) {
-        SDL_SIMDFree(surface->pixels);
+        if (surface->flags & SDL_SIMD_ALIGNED) {
+            SDL_SIMDFree(surface->pixels);
+            surface->flags &= ~SDL_SIMD_ALIGNED;
+        } else {
+            SDL_free(surface->pixels);
+        }
         surface->pixels = NULL;
-        surface->flags &= ~SDL_SIMD_ALIGNED;
     }
 
     /* reallocate the buffer to release unused memory */
@@ -1359,14 +1359,14 @@ RLEColorkeySurface(SDL_Surface * surface)
                 ADD_COUNTS(maxn, 0);
                 skip -= maxn;
             }
-            len = MIN(run, maxn);
+            len = SDL_min(run, maxn);
             ADD_COUNTS(skip, len);
             SDL_memcpy(dst, srcbuf + runstart * bpp, len * bpp);
             dst += len * bpp;
             run -= len;
             runstart += len;
             while (run) {
-                len = MIN(run, maxn);
+                len = SDL_min(run, maxn);
                 ADD_COUNTS(0, len);
                 SDL_memcpy(dst, srcbuf + runstart * bpp, len * bpp);
                 dst += len * bpp;
@@ -1386,9 +1386,13 @@ RLEColorkeySurface(SDL_Surface * surface)
 
     /* Now that we have it encoded, release the original pixels */
     if (!(surface->flags & SDL_PREALLOC)) {
-        SDL_SIMDFree(surface->pixels);
+        if (surface->flags & SDL_SIMD_ALIGNED) {
+            SDL_SIMDFree(surface->pixels);
+            surface->flags &= ~SDL_SIMD_ALIGNED;
+        } else {
+            SDL_free(surface->pixels);
+        }
         surface->pixels = NULL;
-        surface->flags &= ~SDL_SIMD_ALIGNED;
     }
 
     /* reallocate the buffer to release unused memory */
diff --git a/Engine/lib/sdl/src/video/SDL_blit_1.c b/Engine/lib/sdl/src/video/SDL_blit_1.c
index d5030cfb1..2c353fd27 100644
--- a/Engine/lib/sdl/src/video/SDL_blit_1.c
+++ b/Engine/lib/sdl/src/video/SDL_blit_1.c
@@ -50,7 +50,7 @@ Blit1to1(SDL_BlitInfo * info)
 
     while (height--) {
 #ifdef USE_DUFFS_LOOP
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP(
             {
               *dst = map[*src];
@@ -58,7 +58,7 @@ Blit1to1(SDL_BlitInfo * info)
             dst++;
             src++;
         , width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
 #else
         for (c = width; c; --c) {
             *dst = map[*src];
@@ -103,14 +103,14 @@ Blit1to2(SDL_BlitInfo * info)
 
 #ifdef USE_DUFFS_LOOP
     while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP(
         {
             *(Uint16 *)dst = map[*src++];
             dst += 2;
         },
         width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
         src += srcskip;
         dst += dstskip;
     }
@@ -210,7 +210,7 @@ Blit1to3(SDL_BlitInfo * info)
 
     while (height--) {
 #ifdef USE_DUFFS_LOOP
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP(
             {
                 o = *src * 4;
@@ -221,7 +221,7 @@ Blit1to3(SDL_BlitInfo * info)
             src++;
             dst += 3;
         , width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
 #else
         for (c = width; c; --c) {
             o = *src * 4;
@@ -259,11 +259,11 @@ Blit1to4(SDL_BlitInfo * info)
 
     while (height--) {
 #ifdef USE_DUFFS_LOOP
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP(
             *dst++ = map[*src++];
         , width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
 #else
         for (c = width / 4; c; --c) {
             *dst++ = map[*src++];
@@ -299,7 +299,7 @@ Blit1to1Key(SDL_BlitInfo * info)
 
     if (palmap) {
         while (height--) {
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP(
             {
                 if ( *src != ckey ) {
@@ -309,13 +309,13 @@ Blit1to1Key(SDL_BlitInfo * info)
                 src++;
             },
             width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
             src += srcskip;
             dst += dstskip;
         }
     } else {
         while (height--) {
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP(
             {
                 if ( *src != ckey ) {
@@ -325,7 +325,7 @@ Blit1to1Key(SDL_BlitInfo * info)
                 src++;
             },
             width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
             src += srcskip;
             dst += dstskip;
         }
@@ -348,7 +348,7 @@ Blit1to2Key(SDL_BlitInfo * info)
     dstskip /= 2;
 
     while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP(
         {
             if ( *src != ckey ) {
@@ -358,7 +358,7 @@ Blit1to2Key(SDL_BlitInfo * info)
             dstp++;
         },
         width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
         src += srcskip;
         dstp += dstskip;
     }
@@ -378,7 +378,7 @@ Blit1to3Key(SDL_BlitInfo * info)
     int o;
 
     while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP(
         {
             if ( *src != ckey ) {
@@ -391,7 +391,7 @@ Blit1to3Key(SDL_BlitInfo * info)
             dst += 3;
         },
         width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
         src += srcskip;
         dst += dstskip;
     }
@@ -413,7 +413,7 @@ Blit1to4Key(SDL_BlitInfo * info)
     dstskip /= 4;
 
     while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP(
         {
             if ( *src != ckey ) {
@@ -423,7 +423,7 @@ Blit1to4Key(SDL_BlitInfo * info)
             dstp++;
         },
         width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
         src += srcskip;
         dstp += dstskip;
     }
@@ -450,7 +450,7 @@ Blit1toNAlpha(SDL_BlitInfo * info)
     dstbpp = dstfmt->BytesPerPixel;
 
     while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP4(
         {
             sR = srcpal[*src].r;
@@ -463,7 +463,7 @@ Blit1toNAlpha(SDL_BlitInfo * info)
             dst += dstbpp;
         },
         width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
         src += srcskip;
         dst += dstskip;
     }
@@ -491,7 +491,7 @@ Blit1toNAlphaKey(SDL_BlitInfo * info)
     dstbpp = dstfmt->BytesPerPixel;
 
     while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP(
         {
             if ( *src != ckey ) {
@@ -506,7 +506,7 @@ Blit1toNAlphaKey(SDL_BlitInfo * info)
             dst += dstbpp;
         },
         width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
         src += srcskip;
         dst += dstskip;
     }
diff --git a/Engine/lib/sdl/src/video/SDL_blit_A.c b/Engine/lib/sdl/src/video/SDL_blit_A.c
index 4c0726eb0..56ba024c9 100644
--- a/Engine/lib/sdl/src/video/SDL_blit_A.c
+++ b/Engine/lib/sdl/src/video/SDL_blit_A.c
@@ -47,7 +47,7 @@ BlitNto1SurfaceAlpha(SDL_BlitInfo * info)
     const unsigned A = info->a;
 
     while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP4(
         {
         DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB);
@@ -68,7 +68,7 @@ BlitNto1SurfaceAlpha(SDL_BlitInfo * info)
         src += srcbpp;
         },
         width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
         src += srcskip;
         dst += dstskip;
     }
@@ -93,7 +93,7 @@ BlitNto1PixelAlpha(SDL_BlitInfo * info)
     unsigned dR, dG, dB;
 
     while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP4(
         {
         DISEMBLE_RGBA(src,srcbpp,srcfmt,Pixel,sR,sG,sB,sA);
@@ -114,7 +114,7 @@ BlitNto1PixelAlpha(SDL_BlitInfo * info)
         src += srcbpp;
         },
         width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
         src += srcskip;
         dst += dstskip;
     }
@@ -141,7 +141,7 @@ BlitNto1SurfaceAlphaKey(SDL_BlitInfo * info)
     const unsigned A = info->a;
 
     while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP(
         {
         DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB);
@@ -164,7 +164,7 @@ BlitNto1SurfaceAlphaKey(SDL_BlitInfo * info)
         src += srcbpp;
         },
         width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
         src += srcskip;
         dst += dstskip;
     }
@@ -348,7 +348,7 @@ BlitRGBtoRGBPixelAlphaMMX(SDL_BlitInfo * info)
     multmask2 = 0x00FF00FF00FF00FFULL;
 
     while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP4({
         Uint32 alpha = *srcp & amask;
         if (alpha == 0) {
@@ -382,7 +382,7 @@ BlitRGBtoRGBPixelAlphaMMX(SDL_BlitInfo * info)
         ++srcp;
         ++dstp;
         }, width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
         srcp += srcskip;
         dstp += dstskip;
     }
@@ -467,14 +467,14 @@ BlitRGBtoRGBSurfaceAlpha128(SDL_BlitInfo * info)
     int dstskip = info->dst_skip >> 2;
 
     while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP4({
             Uint32 s = *srcp++;
             Uint32 d = *dstp;
             *dstp++ = ((((s & 0x00fefefe) + (d & 0x00fefefe)) >> 1)
                    + (s & d & 0x00010101)) | 0xff000000;
         }, width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
         srcp += srcskip;
         dstp += dstskip;
     }
@@ -500,7 +500,7 @@ BlitRGBtoRGBSurfaceAlpha(SDL_BlitInfo * info)
         Uint32 d1;
 
         while (height--) {
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP4({
                 s = *srcp;
                 d = *dstp;
@@ -515,7 +515,7 @@ BlitRGBtoRGBSurfaceAlpha(SDL_BlitInfo * info)
                 ++srcp;
                 ++dstp;
             }, width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
             srcp += srcskip;
             dstp += dstskip;
         }
@@ -534,7 +534,7 @@ BlitRGBtoRGBPixelAlpha(SDL_BlitInfo * info)
     int dstskip = info->dst_skip >> 2;
 
     while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP4({
         Uint32 dalpha;
         Uint32 d;
@@ -569,7 +569,7 @@ BlitRGBtoRGBPixelAlpha(SDL_BlitInfo * info)
         ++srcp;
         ++dstp;
         }, width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
         srcp += srcskip;
         dstp += dstskip;
     }
@@ -587,7 +587,7 @@ BlitRGBtoBGRPixelAlpha(SDL_BlitInfo * info)
     int dstskip = info->dst_skip >> 2;
 
     while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP4({
         Uint32 dalpha;
         Uint32 d;
@@ -624,7 +624,7 @@ BlitRGBtoBGRPixelAlpha(SDL_BlitInfo * info)
         ++srcp;
         ++dstp;
         }, width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
         srcp += srcskip;
         dstp += dstskip;
     }
@@ -654,7 +654,7 @@ BlitRGBtoRGBPixelAlphaMMX3DNOW(SDL_BlitInfo * info)
     multmask2 = 0x00FF00FF00FF00FFULL;
 
     while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP4({
         Uint32 alpha;
 
@@ -694,7 +694,7 @@ BlitRGBtoRGBPixelAlphaMMX3DNOW(SDL_BlitInfo * info)
         ++srcp;
         ++dstp;
         }, width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
         srcp += srcskip;
         dstp += dstskip;
     }
@@ -848,7 +848,7 @@ Blit565to565SurfaceAlphaMMX(SDL_BlitInfo * info)
         bmask = _mm_set_pi32(0x001F001F, 0x001F001F);   /* MASKBLUE -> bmask */
 
         while (height--) {
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP_124(
             {
                 s = *srcp++;
@@ -944,7 +944,7 @@ Blit565to565SurfaceAlphaMMX(SDL_BlitInfo * info)
                 srcp += 4;
                 dstp += 4;
             }, width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
             srcp += srcskip;
             dstp += dstskip;
         }
@@ -986,7 +986,7 @@ Blit555to555SurfaceAlphaMMX(SDL_BlitInfo * info)
         bmask = _mm_set_pi32(0x001F001F, 0x001F001F);   /* MASKBLUE -> bmask */
 
         while (height--) {
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP_124(
             {
                 s = *srcp++;
@@ -1082,7 +1082,7 @@ Blit555to555SurfaceAlphaMMX(SDL_BlitInfo * info)
                 srcp += 4;
                 dstp += 4;
             }, width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
             srcp += srcskip;
             dstp += dstskip;
         }
@@ -1109,7 +1109,7 @@ Blit565to565SurfaceAlpha(SDL_BlitInfo * info)
         alpha >>= 3;            /* downscale alpha to 5 bits */
 
         while (height--) {
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP4({
                 Uint32 s = *srcp++;
                 Uint32 d = *dstp;
@@ -1124,7 +1124,7 @@ Blit565to565SurfaceAlpha(SDL_BlitInfo * info)
                 d &= 0x07e0f81f;
                 *dstp++ = (Uint16)(d | d >> 16);
             }, width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
             srcp += srcskip;
             dstp += dstskip;
         }
@@ -1148,7 +1148,7 @@ Blit555to555SurfaceAlpha(SDL_BlitInfo * info)
         alpha >>= 3;            /* downscale alpha to 5 bits */
 
         while (height--) {
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP4({
                 Uint32 s = *srcp++;
                 Uint32 d = *dstp;
@@ -1163,7 +1163,7 @@ Blit555to555SurfaceAlpha(SDL_BlitInfo * info)
                 d &= 0x03e07c1f;
                 *dstp++ = (Uint16)(d | d >> 16);
             }, width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
             srcp += srcskip;
             dstp += dstskip;
         }
@@ -1182,7 +1182,7 @@ BlitARGBto565PixelAlpha(SDL_BlitInfo * info)
     int dstskip = info->dst_skip >> 1;
 
     while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP4({
         Uint32 s = *srcp;
         unsigned alpha = s >> 27; /* downscale alpha to 5 bits */
@@ -1210,7 +1210,7 @@ BlitARGBto565PixelAlpha(SDL_BlitInfo * info)
         srcp++;
         dstp++;
         }, width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
         srcp += srcskip;
         dstp += dstskip;
     }
@@ -1228,7 +1228,7 @@ BlitARGBto555PixelAlpha(SDL_BlitInfo * info)
     int dstskip = info->dst_skip >> 1;
 
     while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP4({
         unsigned alpha;
         Uint32 s = *srcp;
@@ -1257,7 +1257,7 @@ BlitARGBto555PixelAlpha(SDL_BlitInfo * info)
         srcp++;
         dstp++;
         }, width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
         srcp += srcskip;
         dstp += dstskip;
     }
@@ -1284,7 +1284,7 @@ BlitNtoNSurfaceAlpha(SDL_BlitInfo * info)
 
     if (sA) {
         while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP4(
         {
         DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB);
@@ -1295,7 +1295,7 @@ BlitNtoNSurfaceAlpha(SDL_BlitInfo * info)
         dst += dstbpp;
         },
         width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
             src += srcskip;
             dst += dstskip;
         }
@@ -1323,7 +1323,7 @@ BlitNtoNSurfaceAlphaKey(SDL_BlitInfo * info)
     const unsigned sA = info->a;
 
     while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP4(
         {
         RETRIEVE_RGB_PIXEL(src, srcbpp, Pixel);
@@ -1337,7 +1337,7 @@ BlitNtoNSurfaceAlphaKey(SDL_BlitInfo * info)
         dst += dstbpp;
         },
         width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
         src += srcskip;
         dst += dstskip;
     }
@@ -1366,7 +1366,7 @@ BlitNtoNPixelAlpha(SDL_BlitInfo * info)
     dstbpp = dstfmt->BytesPerPixel;
 
     while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP4(
         {
         DISEMBLE_RGBA(src, srcbpp, srcfmt, Pixel, sR, sG, sB, sA);
@@ -1379,7 +1379,7 @@ BlitNtoNPixelAlpha(SDL_BlitInfo * info)
         dst += dstbpp;
         },
         width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
         src += srcskip;
         dst += dstskip;
     }
diff --git a/Engine/lib/sdl/src/video/SDL_blit_N.c b/Engine/lib/sdl/src/video/SDL_blit_N.c
index e3b6c96a3..ae9c30882 100644
--- a/Engine/lib/sdl/src/video/SDL_blit_N.c
+++ b/Engine/lib/sdl/src/video/SDL_blit_N.c
@@ -1008,11 +1008,11 @@ Blit_RGB888_index8(SDL_BlitInfo * info)
     if (map == NULL) {
         while (height--) {
 #ifdef USE_DUFFS_LOOP
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP(
                 RGB888_RGB332(*dst++, *src);
             , width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
 #else
             for (c = width / 4; c; --c) {
                 /* Pack RGB into 8bit pixel */
@@ -1044,13 +1044,13 @@ Blit_RGB888_index8(SDL_BlitInfo * info)
 
         while (height--) {
 #ifdef USE_DUFFS_LOOP
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP(
                 RGB888_RGB332(Pixel, *src);
                 *dst++ = map[Pixel];
                 ++src;
             , width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
 #else
             for (c = width / 4; c; --c) {
                 /* Pack RGB into 8bit pixel */
@@ -1118,11 +1118,11 @@ Blit_RGB101010_index8(SDL_BlitInfo * info)
     if (map == NULL) {
         while (height--) {
 #ifdef USE_DUFFS_LOOP
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP(
                 RGB101010_RGB332(*dst++, *src);
             , width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
 #else
             for (c = width / 4; c; --c) {
                 /* Pack RGB into 8bit pixel */
@@ -1154,13 +1154,13 @@ Blit_RGB101010_index8(SDL_BlitInfo * info)
 
         while (height--) {
 #ifdef USE_DUFFS_LOOP
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP(
                 RGB101010_RGB332(Pixel, *src);
                 *dst++ = map[Pixel];
                 ++src;
             , width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
 #else
             for (c = width / 4; c; --c) {
                 /* Pack RGB into 8bit pixel */
@@ -1235,13 +1235,13 @@ Blit_RGB888_RGB555(SDL_BlitInfo * info)
 
 #ifdef USE_DUFFS_LOOP
     while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP(
             RGB888_RGB555(dst, src);
             ++src;
             ++dst;
         , width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
         src += srcskip;
         dst += dstskip;
     }
@@ -1361,13 +1361,13 @@ Blit_RGB888_RGB565(SDL_BlitInfo * info)
 
 #ifdef USE_DUFFS_LOOP
     while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP(
             RGB888_RGB565(dst, src);
             ++src;
             ++dst;
         , width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
         src += srcskip;
         dst += dstskip;
     }
@@ -1476,14 +1476,14 @@ Blit_RGB565_32(SDL_BlitInfo * info, const Uint32 * map)
 
 #ifdef USE_DUFFS_LOOP
     while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP(
         {
             *dst++ = RGB565_32(dst, src, map);
             src += 2;
         },
         width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
         src += srcskip;
         dst += dstskip;
     }
@@ -2088,7 +2088,7 @@ Blit_RGB555_ARGB1555(SDL_BlitInfo * info)
     Uint16 mask = ((Uint32)info->a >> dstfmt->Aloss) << dstfmt->Ashift;
 
     while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP(
         {
             *dst = *src | mask;
@@ -2096,7 +2096,7 @@ Blit_RGB555_ARGB1555(SDL_BlitInfo * info)
             ++src;
         },
         width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
         src = (Uint16 *) ((Uint8 *) src + srcskip);
         dst = (Uint16 *) ((Uint8 *) dst + dstskip);
     }
@@ -2132,7 +2132,7 @@ BlitNto1(SDL_BlitInfo * info)
     if (map == NULL) {
         while (height--) {
 #ifdef USE_DUFFS_LOOP
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP(
                 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
                                 sR, sG, sB);
@@ -2145,7 +2145,7 @@ BlitNto1(SDL_BlitInfo * info)
                 dst++;
                 src += srcbpp;
             , width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
 #else
             for (c = width; c; --c) {
                 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB);
@@ -2164,7 +2164,7 @@ BlitNto1(SDL_BlitInfo * info)
     } else {
         while (height--) {
 #ifdef USE_DUFFS_LOOP
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP(
                 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
                                 sR, sG, sB);
@@ -2177,7 +2177,7 @@ BlitNto1(SDL_BlitInfo * info)
                 dst++;
                 src += srcbpp;
             , width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
 #else
             for (c = width; c; --c) {
                 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB);
@@ -2214,7 +2214,7 @@ Blit4to4MaskAlpha(SDL_BlitInfo * info)
         Uint32 mask = ((Uint32)info->a >> dstfmt->Aloss) << dstfmt->Ashift;
 
         while (height--) {
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP(
             {
                 *dst = *src | mask;
@@ -2222,7 +2222,7 @@ Blit4to4MaskAlpha(SDL_BlitInfo * info)
                 ++src;
             },
             width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
             src = (Uint32 *) ((Uint8 *) src + srcskip);
             dst = (Uint32 *) ((Uint8 *) dst + dstskip);
         }
@@ -2231,7 +2231,7 @@ Blit4to4MaskAlpha(SDL_BlitInfo * info)
         Uint32 mask = srcfmt->Rmask | srcfmt->Gmask | srcfmt->Bmask;
 
         while (height--) {
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP(
             {
                 *dst = *src & mask;
@@ -2239,7 +2239,7 @@ Blit4to4MaskAlpha(SDL_BlitInfo * info)
                 ++src;
             },
             width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
             src = (Uint32 *) ((Uint8 *) src + srcskip);
             dst = (Uint32 *) ((Uint8 *) dst + dstskip);
         }
@@ -2259,7 +2259,7 @@ Blit4to4CopyAlpha(SDL_BlitInfo * info)
 
     /* RGBA->RGBA, COPY_ALPHA */
     while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP(
         {
             *dst = *src;
@@ -2267,7 +2267,7 @@ Blit4to4CopyAlpha(SDL_BlitInfo * info)
             ++src;
         },
         width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
         src = (Uint32 *) ((Uint8 *) src + srcskip);
         dst = (Uint32 *) ((Uint8 *) dst + dstskip);
     }
@@ -2380,7 +2380,7 @@ BlitNtoN(SDL_BlitInfo * info)
         get_permutation(srcfmt, dstfmt, &p0, &p1, &p2, &p3, &alpha_channel);
 
         while (height--) {
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP(
             {
                 dst[0] = src[p0];
@@ -2391,7 +2391,7 @@ BlitNtoN(SDL_BlitInfo * info)
                 src += 4;
                 dst += 4;
             }, width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
             src += srcskip;
             dst += dstskip;
         }
@@ -2408,7 +2408,7 @@ BlitNtoN(SDL_BlitInfo * info)
         get_permutation(srcfmt, dstfmt, &p0, &p1, &p2, &p3, NULL);
 
         while (height--) {
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP(
             {
                 dst[0] = src[p0];
@@ -2417,7 +2417,7 @@ BlitNtoN(SDL_BlitInfo * info)
                 src += 4;
                 dst += 3;
             }, width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
             src += srcskip;
             dst += dstskip;
         }
@@ -2434,7 +2434,7 @@ BlitNtoN(SDL_BlitInfo * info)
         get_permutation(srcfmt, dstfmt, &p0, &p1, &p2, &p3, &alpha_channel);
 
         while (height--) {
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP(
             {
                 dst[0] = src[p0];
@@ -2445,7 +2445,7 @@ BlitNtoN(SDL_BlitInfo * info)
                 src += 3;
                 dst += 4;
             }, width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
             src += srcskip;
             dst += dstskip;
         }
@@ -2454,7 +2454,7 @@ BlitNtoN(SDL_BlitInfo * info)
 #endif
 
     while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP(
         {
             Uint32 Pixel;
@@ -2467,7 +2467,7 @@ BlitNtoN(SDL_BlitInfo * info)
             src += srcbpp;
         },
         width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
         src += srcskip;
         dst += dstskip;
     }
@@ -2499,7 +2499,7 @@ BlitNtoNCopyAlpha(SDL_BlitInfo * info)
         get_permutation(srcfmt, dstfmt, &p0, &p1, &p2, &p3, NULL);
 
         while (height--) {
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP(
             {
                 dst[0] = src[p0];
@@ -2509,7 +2509,7 @@ BlitNtoNCopyAlpha(SDL_BlitInfo * info)
                 src += 4;
                 dst += 4;
             }, width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
             src += srcskip;
             dst += dstskip;
         }
@@ -2554,7 +2554,7 @@ BlitNto1Key(SDL_BlitInfo * info)
 
     if (palmap == NULL) {
         while (height--) {
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP(
             {
                 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
@@ -2569,13 +2569,13 @@ BlitNto1Key(SDL_BlitInfo * info)
                 src += srcbpp;
             },
             width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
             src += srcskip;
             dst += dstskip;
         }
     } else {
         while (height--) {
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP(
             {
                 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
@@ -2590,7 +2590,7 @@ BlitNto1Key(SDL_BlitInfo * info)
                 src += srcbpp;
             },
             width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
             src += srcskip;
             dst += dstskip;
         }
@@ -2615,7 +2615,7 @@ Blit2to2Key(SDL_BlitInfo * info)
     ckey &= rgbmask;
 
     while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP(
         {
             if ( (*srcp & rgbmask) != ckey ) {
@@ -2625,7 +2625,7 @@ Blit2to2Key(SDL_BlitInfo * info)
             srcp++;
         },
         width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
         srcp += srcskip;
         dstp += dstskip;
     }
@@ -2662,7 +2662,7 @@ BlitNtoNKey(SDL_BlitInfo * info)
             /* RGB->RGBA, SET_ALPHA */
             Uint32 mask = ((Uint32)info->a) << dstfmt->Ashift;
             while (height--) {
-                /* *INDENT-OFF* */
+                /* *INDENT-OFF* */ /* clang-format off */
                 DUFFS_LOOP(
                 {
                     if ((*src32 & rgbmask) != ckey) {
@@ -2671,7 +2671,7 @@ BlitNtoNKey(SDL_BlitInfo * info)
                     ++dst32;
                     ++src32;
                 }, width);
-                /* *INDENT-ON* */
+                /* *INDENT-ON* */ /* clang-format on */
                 src32 = (Uint32 *) ((Uint8 *) src32 + srcskip);
                 dst32 = (Uint32 *) ((Uint8 *) dst32 + dstskip);
             }
@@ -2680,7 +2680,7 @@ BlitNtoNKey(SDL_BlitInfo * info)
             /* RGBA->RGB, NO_ALPHA */
             Uint32 mask = srcfmt->Rmask | srcfmt->Gmask | srcfmt->Bmask;
             while (height--) {
-                /* *INDENT-OFF* */
+                /* *INDENT-OFF* */ /* clang-format off */
                 DUFFS_LOOP(
                 {
                     if ((*src32 & rgbmask) != ckey) {
@@ -2689,7 +2689,7 @@ BlitNtoNKey(SDL_BlitInfo * info)
                     ++dst32;
                     ++src32;
                 }, width);
-                /* *INDENT-ON* */
+                /* *INDENT-ON* */ /* clang-format on */
                 src32 = (Uint32 *) ((Uint8 *) src32 + srcskip);
                 dst32 = (Uint32 *) ((Uint8 *) dst32 + dstskip);
             }
@@ -2708,7 +2708,7 @@ BlitNtoNKey(SDL_BlitInfo * info)
         get_permutation(srcfmt, dstfmt, &p0, &p1, &p2, &p3, &alpha_channel);
 
         while (height--) {
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP(
             {
                 Uint32 *src32 = (Uint32*)src;
@@ -2723,7 +2723,7 @@ BlitNtoNKey(SDL_BlitInfo * info)
                 src += 4;
                 dst += 4;
             }, width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
             src += srcskip;
             dst += dstskip;
         }
@@ -2746,7 +2746,7 @@ BlitNtoNKey(SDL_BlitInfo * info)
 #endif
 
         while (height--) {
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP(
             {
                 Uint8 s0 = src[0];
@@ -2762,7 +2762,7 @@ BlitNtoNKey(SDL_BlitInfo * info)
                 dst += 3;
             },
             width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
             src += srcskip;
             dst += dstskip;
         }
@@ -2784,7 +2784,7 @@ BlitNtoNKey(SDL_BlitInfo * info)
 #endif
 
         while (height--) {
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP(
             {
                 Uint8 s0 = src[0];
@@ -2800,7 +2800,7 @@ BlitNtoNKey(SDL_BlitInfo * info)
                 dst += 3;
             },
             width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
             src += srcskip;
             dst += dstskip;
         }
@@ -2816,7 +2816,7 @@ BlitNtoNKey(SDL_BlitInfo * info)
         get_permutation(srcfmt, dstfmt, &p0, &p1, &p2, &p3, NULL);
 
         while (height--) {
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP(
             {
                 Uint32 *src32 = (Uint32*)src;
@@ -2828,7 +2828,7 @@ BlitNtoNKey(SDL_BlitInfo * info)
                 src += 4;
                 dst += 3;
             }, width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
             src += srcskip;
             dst += dstskip;
         }
@@ -2855,7 +2855,7 @@ BlitNtoNKey(SDL_BlitInfo * info)
         get_permutation(srcfmt, dstfmt, &p0, &p1, &p2, &p3, &alpha_channel);
 
         while (height--) {
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP(
             {
                 Uint8 s0 = src[0];
@@ -2872,7 +2872,7 @@ BlitNtoNKey(SDL_BlitInfo * info)
                 src += 3;
                 dst += 4;
             }, width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
             src += srcskip;
             dst += dstskip;
         }
@@ -2881,7 +2881,7 @@ BlitNtoNKey(SDL_BlitInfo * info)
 #endif
 
     while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP(
         {
             Uint32 Pixel;
@@ -2897,7 +2897,7 @@ BlitNtoNKey(SDL_BlitInfo * info)
             src += srcbpp;
         },
         width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
         src += srcskip;
         dst += dstskip;
     }
@@ -2938,7 +2938,7 @@ BlitNtoNKeyCopyAlpha(SDL_BlitInfo * info)
             Uint32 *src32 = (Uint32*)src;
             Uint32 *dst32 = (Uint32*)dst;
             while (height--) {
-                /* *INDENT-OFF* */
+                /* *INDENT-OFF* */ /* clang-format off */
                 DUFFS_LOOP(
                 {
                     if ((*src32 & rgbmask) != ckey) {
@@ -2948,7 +2948,7 @@ BlitNtoNKeyCopyAlpha(SDL_BlitInfo * info)
                     ++dst32;
                 },
                 width);
-                /* *INDENT-ON* */
+                /* *INDENT-ON* */ /* clang-format on */
                 src32 = (Uint32 *)((Uint8 *)src32 + srcskip);
                 dst32 = (Uint32 *)((Uint8 *)dst32 + dstskip);
             }
@@ -2967,7 +2967,7 @@ BlitNtoNKeyCopyAlpha(SDL_BlitInfo * info)
         get_permutation(srcfmt, dstfmt, &p0, &p1, &p2, &p3, NULL);
 
         while (height--) {
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP(
             {
                 Uint32 *src32 = (Uint32*)src;
@@ -2980,7 +2980,7 @@ BlitNtoNKeyCopyAlpha(SDL_BlitInfo * info)
                 src += 4;
                 dst += 4;
             }, width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
             src += srcskip;
             dst += dstskip;
         }
@@ -2989,7 +2989,7 @@ BlitNtoNKeyCopyAlpha(SDL_BlitInfo * info)
 #endif
 
     while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP(
         {
             DISEMBLE_RGBA(src, srcbpp, srcfmt, Pixel, sR, sG, sB, sA);
@@ -3000,7 +3000,7 @@ BlitNtoNKeyCopyAlpha(SDL_BlitInfo * info)
             src += srcbpp;
         },
         width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
         src += srcskip;
         dst += dstskip;
     }
@@ -3022,7 +3022,7 @@ Blit2101010toN(SDL_BlitInfo * info)
     unsigned sR, sG, sB, sA;
 
     while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP(
         {
             Pixel = *(Uint32 *)src;
@@ -3032,7 +3032,7 @@ Blit2101010toN(SDL_BlitInfo * info)
             src += 4;
         },
         width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
         src += srcskip;
         dst += dstskip;
     }
@@ -3054,7 +3054,7 @@ BlitNto2101010(SDL_BlitInfo * info)
     unsigned sR, sG, sB, sA;
 
     while (height--) {
-        /* *INDENT-OFF* */
+        /* *INDENT-OFF* */ /* clang-format off */
         DUFFS_LOOP(
         {
             DISEMBLE_RGBA(src, srcbpp, srcfmt, Pixel, sR, sG, sB, sA);
@@ -3064,7 +3064,7 @@ BlitNto2101010(SDL_BlitInfo * info)
             src += srcbpp;
         },
         width);
-        /* *INDENT-ON* */
+        /* *INDENT-ON* */ /* clang-format on */
         src += srcskip;
         dst += dstskip;
     }
@@ -3096,7 +3096,7 @@ Blit_3or4_to_3or4__same_rgb(SDL_BlitInfo * info)
         int i2 = srcbpp - 1 - 2;
 #endif
         while (height--) {
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP(
             {
                 Uint32 *dst32 = (Uint32*)dst;
@@ -3107,7 +3107,7 @@ Blit_3or4_to_3or4__same_rgb(SDL_BlitInfo * info)
                 dst += 4;
                 src += srcbpp;
             }, width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
             src += srcskip;
             dst += dstskip;
         }
@@ -3125,7 +3125,7 @@ Blit_3or4_to_3or4__same_rgb(SDL_BlitInfo * info)
         int j2 = dstbpp - 1 - 2;
 #endif
         while (height--) {
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP(
             {
                 Uint8 s0 = src[i0];
@@ -3137,7 +3137,7 @@ Blit_3or4_to_3or4__same_rgb(SDL_BlitInfo * info)
                 dst += dstbpp;
                 src += srcbpp;
             }, width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
             src += srcskip;
             dst += dstskip;
         }
@@ -3169,7 +3169,7 @@ Blit_3or4_to_3or4__inversed_rgb(SDL_BlitInfo * info)
 #else
                 int i0 = 3, i1 = 2, i2 = 1, i3 = 0;
 #endif
-                /* *INDENT-OFF* */
+                /* *INDENT-OFF* */ /* clang-format off */
                 DUFFS_LOOP(
                 {
                     Uint32 *dst32 = (Uint32*)dst;
@@ -3182,7 +3182,7 @@ Blit_3or4_to_3or4__inversed_rgb(SDL_BlitInfo * info)
                     dst += 4;
                     src += 4;
                 }, width);
-                /* *INDENT-ON* */
+                /* *INDENT-ON* */ /* clang-format on */
                 src += srcskip;
                 dst += dstskip;
             }
@@ -3197,7 +3197,7 @@ Blit_3or4_to_3or4__inversed_rgb(SDL_BlitInfo * info)
             int i2 = srcbpp - 1 - 2;
 #endif
             while (height--) {
-                /* *INDENT-OFF* */
+                /* *INDENT-OFF* */ /* clang-format off */
                 DUFFS_LOOP(
                 {
                     Uint32 *dst32 = (Uint32*)dst;
@@ -3209,7 +3209,7 @@ Blit_3or4_to_3or4__inversed_rgb(SDL_BlitInfo * info)
                     dst += 4;
                     src += srcbpp;
                 }, width);
-                /* *INDENT-ON* */
+                /* *INDENT-ON* */ /* clang-format on */
                 src += srcskip;
                 dst += dstskip;
             }
@@ -3228,7 +3228,7 @@ Blit_3or4_to_3or4__inversed_rgb(SDL_BlitInfo * info)
         int j2 = dstbpp - 1 - 0;
 #endif
         while (height--) {
-            /* *INDENT-OFF* */
+            /* *INDENT-OFF* */ /* clang-format off */
             DUFFS_LOOP(
             {
                 Uint8 s0 = src[i0];
@@ -3241,7 +3241,7 @@ Blit_3or4_to_3or4__inversed_rgb(SDL_BlitInfo * info)
                 dst += dstbpp;
                 src += srcbpp;
             }, width);
-            /* *INDENT-ON* */
+            /* *INDENT-ON* */ /* clang-format on */
             src += srcskip;
             dst += dstskip;
         }
diff --git a/Engine/lib/sdl/src/video/SDL_blit_auto.c b/Engine/lib/sdl/src/video/SDL_blit_auto.c
index f64511fcc..f15a43622 100644
--- a/Engine/lib/sdl/src/video/SDL_blit_auto.c
+++ b/Engine/lib/sdl/src/video/SDL_blit_auto.c
@@ -23,7 +23,7 @@
 
 #if SDL_HAVE_BLIT_AUTO
 
-/* *INDENT-OFF* */
+/* *INDENT-OFF* */ /* clang-format off */
 
 #include "SDL_video.h"
 #include "SDL_blit.h"
@@ -7014,7 +7014,7 @@ SDL_BlitFuncEntry SDL_GeneratedBlitFuncTable[] = {
     { 0, 0, 0, 0, NULL }
 };
 
-/* *INDENT-ON* */
+/* *INDENT-ON* */ /* clang-format on */
 
 #endif /* SDL_HAVE_BLIT_AUTO */
 
diff --git a/Engine/lib/sdl/src/video/SDL_egl.c b/Engine/lib/sdl/src/video/SDL_egl.c
index e62fe9931..ce9a213e4 100644
--- a/Engine/lib/sdl/src/video/SDL_egl.c
+++ b/Engine/lib/sdl/src/video/SDL_egl.c
@@ -1250,10 +1250,12 @@ EGLSurface
 SDL_EGL_CreateOffscreenSurface(_THIS, int width, int height)
 {
     EGLint attributes[] = {
-        EGL_WIDTH, width,
-        EGL_HEIGHT, height,
+        EGL_WIDTH, 0,
+        EGL_HEIGHT, 0,
         EGL_NONE
     };
+    attributes[1] = width;
+    attributes[3] = height;
 
     if (SDL_EGL_ChooseConfig(_this) != 0) {
         return EGL_NO_SURFACE;
diff --git a/Engine/lib/sdl/src/video/SDL_fillrect.c b/Engine/lib/sdl/src/video/SDL_fillrect.c
index 13872d271..66985117d 100644
--- a/Engine/lib/sdl/src/video/SDL_fillrect.c
+++ b/Engine/lib/sdl/src/video/SDL_fillrect.c
@@ -26,7 +26,7 @@
 
 
 #ifdef __SSE__
-/* *INDENT-OFF* */
+/* *INDENT-OFF* */ /* clang-format off */
 
 #if defined(_MSC_VER) && !defined(__clang__)
 #define SSE_BEGIN \
@@ -128,7 +128,7 @@ SDL_FillRect1SSE(Uint8 *pixels, int pitch, Uint32 color, int w, int h)
 DEFINE_SSE_FILLRECT(2, Uint16)
 DEFINE_SSE_FILLRECT(4, Uint32)
 
-/* *INDENT-ON* */
+/* *INDENT-ON* */ /* clang-format on */
 #endif /* __SSE__ */
 
 static void
diff --git a/Engine/lib/sdl/src/video/SDL_sysvideo.h b/Engine/lib/sdl/src/video/SDL_sysvideo.h
index 2384a64ac..b1876b2b8 100644
--- a/Engine/lib/sdl/src/video/SDL_sysvideo.h
+++ b/Engine/lib/sdl/src/video/SDL_sysvideo.h
@@ -237,6 +237,7 @@ struct SDL_VideoDevice
     int (*SetWindowGammaRamp) (_THIS, SDL_Window * window, const Uint16 * ramp);
     int (*GetWindowGammaRamp) (_THIS, SDL_Window * window, Uint16 * ramp);
     void* (*GetWindowICCProfile) (_THIS, SDL_Window * window, size_t* size);
+    int (*GetWindowDisplayIndex)(_THIS, SDL_Window * window);
     void (*SetWindowMouseRect)(_THIS, SDL_Window * window);
     void (*SetWindowMouseGrab) (_THIS, SDL_Window * window, SDL_bool grabbed);
     void (*SetWindowKeyboardGrab) (_THIS, SDL_Window * window, SDL_bool grabbed);
@@ -332,6 +333,7 @@ struct SDL_VideoDevice
 
     /* * * */
     /* Data common to all drivers */
+    SDL_threadID thread;
     SDL_bool checked_texture_framebuffer;
     SDL_bool is_dummy;
     SDL_bool suspend_screensaver;
@@ -456,9 +458,12 @@ extern VideoBootStrap VIVANTE_bootstrap;
 extern VideoBootStrap Emscripten_bootstrap;
 extern VideoBootStrap QNX_bootstrap;
 extern VideoBootStrap OFFSCREEN_bootstrap;
+extern VideoBootStrap NGAGE_bootstrap;
 extern VideoBootStrap OS2DIVE_bootstrap;
 extern VideoBootStrap OS2VMAN_bootstrap;
 
+/* Use SDL_OnVideoThread() sparingly, to avoid regressions in use cases that currently happen to work */
+extern SDL_bool SDL_OnVideoThread(void);
 extern SDL_VideoDevice *SDL_GetVideoDevice(void);
 extern int SDL_AddBasicVideoDisplay(const SDL_DisplayMode * desktop_mode);
 extern int SDL_AddVideoDisplay(const SDL_VideoDisplay * display, SDL_bool send_event);
@@ -472,6 +477,7 @@ extern SDL_VideoDisplay *SDL_GetDisplay(int displayIndex);
 extern SDL_VideoDisplay *SDL_GetDisplayForWindow(SDL_Window *window);
 extern void *SDL_GetDisplayDriverData( int displayIndex );
 extern SDL_bool SDL_IsVideoContextExternal(void);
+extern int SDL_GetMessageBoxCount(void);
 
 extern void SDL_GL_DeduceMaxSupportedESProfile(int* major, int* minor);
 
diff --git a/Engine/lib/sdl/src/video/SDL_video.c b/Engine/lib/sdl/src/video/SDL_video.c
index 93c803e70..58f9d7466 100644
--- a/Engine/lib/sdl/src/video/SDL_video.c
+++ b/Engine/lib/sdl/src/video/SDL_video.c
@@ -118,6 +118,9 @@ static VideoBootStrap *bootstrap[] = {
 #if SDL_VIDEO_DRIVER_OFFSCREEN
     &OFFSCREEN_bootstrap,
 #endif
+#if SDL_VIDEO_DRIVER_NGAGE
+    &NGAGE_bootstrap,
+#endif
 #if SDL_VIDEO_DRIVER_OS2
     &OS2DIVE_bootstrap,
     &OS2VMAN_bootstrap,
@@ -288,6 +291,7 @@ SDL_CreateWindowTexture(SDL_VideoDevice *_this, SDL_Window * window, Uint32 * fo
 }
 
 static SDL_VideoDevice *_this = NULL;
+static SDL_atomic_t SDL_messagebox_count;
 
 static int
 SDL_UpdateWindowTexture(SDL_VideoDevice *unused, SDL_Window * window, const SDL_Rect * rects, int numrects)
@@ -338,7 +342,7 @@ SDL_DestroyWindowTexture(SDL_VideoDevice *unused, SDL_Window * window)
     SDL_free(data);
 }
 
-static int
+static int SDLCALL
 cmpmodes(const void *A, const void *B)
 {
     const SDL_DisplayMode *a = (const SDL_DisplayMode *) A;
@@ -466,6 +470,7 @@ SDL_VideoInit(const char *driver_name)
     _this = video;
     _this->name = bootstrap[i]->name;
     _this->next_object_id = 1;
+    _this->thread = SDL_ThreadID();
 
 
     /* Set some very sane GL defaults */
@@ -545,6 +550,12 @@ SDL_GetVideoDevice(void)
     return _this;
 }
 
+SDL_bool
+SDL_OnVideoThread()
+{
+    return (_this && SDL_ThreadID() == _this->thread) ? SDL_TRUE : SDL_FALSE;
+}
+
 int
 SDL_AddBasicVideoDisplay(const SDL_DisplayMode * desktop_mode)
 {
@@ -1060,61 +1071,64 @@ SDL_GetDisplay(int displayIndex)
 int
 SDL_GetWindowDisplayIndex(SDL_Window * window)
 {
-    int displayIndex;
-    int i, dist;
-    int closest = -1;
-    int closest_dist = 0x7FFFFFFF;
-    SDL_Point center;
-    SDL_Point delta;
-    SDL_Rect rect;
-
     CHECK_WINDOW_MAGIC(window, -1);
+    if (_this->GetWindowDisplayIndex) {
+        return _this->GetWindowDisplayIndex(_this, window);
+    } else {
+        int displayIndex;
+        int i, dist;
+        int closest = -1;
+        int closest_dist = 0x7FFFFFFF;
+        SDL_Point center;
+        SDL_Point delta;
+        SDL_Rect rect;
 
-    if (SDL_WINDOWPOS_ISUNDEFINED(window->x) ||
-        SDL_WINDOWPOS_ISCENTERED(window->x)) {
-        displayIndex = (window->x & 0xFFFF);
-        if (displayIndex >= _this->num_displays) {
-            displayIndex = 0;
+        if (SDL_WINDOWPOS_ISUNDEFINED(window->x) ||
+            SDL_WINDOWPOS_ISCENTERED(window->x)) {
+            displayIndex = (window->x & 0xFFFF);
+            if (displayIndex >= _this->num_displays) {
+                displayIndex = 0;
+            }
+            return displayIndex;
         }
-        return displayIndex;
-    }
-    if (SDL_WINDOWPOS_ISUNDEFINED(window->y) ||
-        SDL_WINDOWPOS_ISCENTERED(window->y)) {
-        displayIndex = (window->y & 0xFFFF);
-        if (displayIndex >= _this->num_displays) {
-            displayIndex = 0;
-        }
-        return displayIndex;
-    }
-
-    /* Find the display containing the window */
-    for (i = 0; i < _this->num_displays; ++i) {
-        SDL_VideoDisplay *display = &_this->displays[i];
-
-        if (display->fullscreen_window == window) {
-            return i;
-        }
-    }
-    center.x = window->x + window->w / 2;
-    center.y = window->y + window->h / 2;
-    for (i = 0; i < _this->num_displays; ++i) {
-        SDL_GetDisplayBounds(i, &rect);
-        if (SDL_EnclosePoints(&center, 1, &rect, NULL)) {
-            return i;
+        if (SDL_WINDOWPOS_ISUNDEFINED(window->y) ||
+            SDL_WINDOWPOS_ISCENTERED(window->y)) {
+            displayIndex = (window->y & 0xFFFF);
+            if (displayIndex >= _this->num_displays) {
+                displayIndex = 0;
+            }
+            return displayIndex;
         }
 
-        delta.x = center.x - (rect.x + rect.w / 2);
-        delta.y = center.y - (rect.y + rect.h / 2);
-        dist = (delta.x*delta.x + delta.y*delta.y);
-        if (dist < closest_dist) {
-            closest = i;
-            closest_dist = dist;
+        /* Find the display containing the window */
+        for (i = 0; i < _this->num_displays; ++i) {
+            SDL_VideoDisplay *display = &_this->displays[i];
+
+            if (display->fullscreen_window == window) {
+                return i;
+            }
         }
+        center.x = window->x + window->w / 2;
+        center.y = window->y + window->h / 2;
+        for (i = 0; i < _this->num_displays; ++i) {
+            SDL_GetDisplayBounds(i, &rect);
+            if (SDL_EnclosePoints(&center, 1, &rect, NULL)) {
+                return i;
+            }
+
+            delta.x = center.x - (rect.x + rect.w / 2);
+            delta.y = center.y - (rect.y + rect.h / 2);
+            dist = (delta.x*delta.x + delta.y*delta.y);
+            if (dist < closest_dist) {
+                closest = i;
+                closest_dist = dist;
+            }
+        }
+        if (closest < 0) {
+            SDL_SetError("Couldn't find any displays");
+        }
+        return closest;
     }
-    if (closest < 0) {
-        SDL_SetError("Couldn't find any displays");
-    }
-    return closest;
 }
 
 SDL_VideoDisplay *
@@ -2503,6 +2517,14 @@ SDL_CreateWindowFramebuffer(SDL_Window * window)
     if (!_this->checked_texture_framebuffer) {
         SDL_bool attempt_texture_framebuffer = SDL_TRUE;
 
+        /* See if the user or application wants to specifically disable the framebuffer */
+        const char *hint = SDL_GetHint(SDL_HINT_FRAMEBUFFER_ACCELERATION);
+        if (hint) {
+            if (*hint == '0' || SDL_strcasecmp(hint, "false") == 0) {
+                attempt_texture_framebuffer = SDL_FALSE;
+            }
+        }
+
         if (_this->is_dummy) {  /* dummy driver never has GPU support, of course. */
             attempt_texture_framebuffer = SDL_FALSE;
         }
@@ -3024,7 +3046,7 @@ SDL_OnWindowFocusGained(SDL_Window * window)
     if (mouse && mouse->relative_mode) {
         SDL_SetMouseFocus(window);
         if (mouse->relative_mode_warp) {
-            SDL_WarpMouseInWindow(window, window->w/2, window->h/2);
+            SDL_PerformWarpMouseInWindow(window, window->w/2, window->h/2, SDL_TRUE);
         }
     }
 
@@ -4257,6 +4279,12 @@ SDL_IsScreenKeyboardShown(SDL_Window *window)
     return SDL_FALSE;
 }
 
+int
+SDL_GetMessageBoxCount(void)
+{
+    return SDL_AtomicGet(&SDL_messagebox_count);
+}
+
 #if SDL_VIDEO_DRIVER_ANDROID
 #include "android/SDL_androidmessagebox.h"
 #endif
@@ -4317,7 +4345,6 @@ SDL_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid)
     int retval = -1;
     SDL_bool relative_mode;
     int show_cursor_prev;
-    SDL_bool mouse_captured;
     SDL_Window *current_window;
     SDL_MessageBoxData mbdata;
 
@@ -4327,10 +4354,11 @@ SDL_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid)
         return SDL_SetError("Invalid number of buttons");
     }
 
+    (void)SDL_AtomicIncRef(&SDL_messagebox_count);
+
     current_window = SDL_GetKeyboardFocus();
-    mouse_captured = current_window && ((SDL_GetWindowFlags(current_window) & SDL_WINDOW_MOUSE_CAPTURE) != 0);
     relative_mode = SDL_GetRelativeMouseMode();
-    SDL_CaptureMouse(SDL_FALSE);
+    SDL_UpdateMouseCapture(SDL_FALSE);
     SDL_SetRelativeMouseMode(SDL_FALSE);
     show_cursor_prev = SDL_ShowCursor(1);
     SDL_ResetKeyboard();
@@ -4434,15 +4462,15 @@ SDL_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid)
         }
     }
 
+    (void)SDL_AtomicDecRef(&SDL_messagebox_count);
+
     if (current_window) {
         SDL_RaiseWindow(current_window);
-        if (mouse_captured) {
-            SDL_CaptureMouse(SDL_TRUE);
-        }
     }
 
     SDL_ShowCursor(show_cursor_prev);
     SDL_SetRelativeMouseMode(relative_mode);
+    SDL_UpdateMouseCapture(SDL_FALSE);
 
     return retval;
 }
diff --git a/Engine/lib/sdl/src/video/android/SDL_androidkeyboard.c b/Engine/lib/sdl/src/video/android/SDL_androidkeyboard.c
index 635a22ead..9bb025521 100644
--- a/Engine/lib/sdl/src/video/android/SDL_androidkeyboard.c
+++ b/Engine/lib/sdl/src/video/android/SDL_androidkeyboard.c
@@ -41,12 +41,12 @@ void Android_InitKeyboard(void)
 
 static SDL_Scancode Android_Keycodes[] = {
     SDL_SCANCODE_UNKNOWN, /* AKEYCODE_UNKNOWN */
-    SDL_SCANCODE_UNKNOWN, /* AKEYCODE_SOFT_LEFT */
-    SDL_SCANCODE_UNKNOWN, /* AKEYCODE_SOFT_RIGHT */
+    SDL_SCANCODE_SOFTLEFT, /* AKEYCODE_SOFT_LEFT */
+    SDL_SCANCODE_SOFTRIGHT, /* AKEYCODE_SOFT_RIGHT */
     SDL_SCANCODE_AC_HOME, /* AKEYCODE_HOME */
     SDL_SCANCODE_AC_BACK, /* AKEYCODE_BACK */
-    SDL_SCANCODE_UNKNOWN, /* AKEYCODE_CALL */
-    SDL_SCANCODE_UNKNOWN, /* AKEYCODE_ENDCALL */
+    SDL_SCANCODE_CALL, /* AKEYCODE_CALL */
+    SDL_SCANCODE_ENDCALL, /* AKEYCODE_ENDCALL */
     SDL_SCANCODE_0, /* AKEYCODE_0 */
     SDL_SCANCODE_1, /* AKEYCODE_1 */
     SDL_SCANCODE_2, /* AKEYCODE_2 */
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoaclipboard.h b/Engine/lib/sdl/src/video/cocoa/SDL_cocoaclipboard.h
index dd5e25224..c8c4d6808 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoaclipboard.h
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoaclipboard.h
@@ -24,12 +24,12 @@
 #define SDL_cocoaclipboard_h_
 
 /* Forward declaration */
-struct SDL_VideoData;
+@class SDL_VideoData;
 
 extern int Cocoa_SetClipboardText(_THIS, const char *text);
 extern char *Cocoa_GetClipboardText(_THIS);
 extern SDL_bool Cocoa_HasClipboardText(_THIS);
-extern void Cocoa_CheckClipboardUpdate(struct SDL_VideoData * data);
+extern void Cocoa_CheckClipboardUpdate(SDL_VideoData * data);
 
 #endif /* SDL_cocoaclipboard_h_ */
 
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoaclipboard.m b/Engine/lib/sdl/src/video/cocoa/SDL_cocoaclipboard.m
index 1995c7289..e3878ce8f 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoaclipboard.m
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoaclipboard.m
@@ -29,7 +29,7 @@ int
 Cocoa_SetClipboardText(_THIS, const char *text)
 { @autoreleasepool
 {
-    SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
+    SDL_VideoData *data = (__bridge SDL_VideoData *) _this->driverdata;
     NSPasteboard *pasteboard;
     NSString *format = NSPasteboardTypeString;
     NSString *nsstr = [NSString stringWithUTF8String:text];
@@ -38,7 +38,7 @@ Cocoa_SetClipboardText(_THIS, const char *text)
     }
 
     pasteboard = [NSPasteboard generalPasteboard];
-    data->clipboard_count = [pasteboard declareTypes:[NSArray arrayWithObject:format] owner:nil];
+    data.clipboard_count = [pasteboard declareTypes:[NSArray arrayWithObject:format] owner:nil];
     [pasteboard setString:nsstr forType:format];
 
     return 0;
@@ -86,7 +86,7 @@ Cocoa_HasClipboardText(_THIS)
 }
 
 void
-Cocoa_CheckClipboardUpdate(struct SDL_VideoData * data)
+Cocoa_CheckClipboardUpdate(SDL_VideoData * data)
 { @autoreleasepool
 {
     NSPasteboard *pasteboard;
@@ -94,11 +94,11 @@ Cocoa_CheckClipboardUpdate(struct SDL_VideoData * data)
 
     pasteboard = [NSPasteboard generalPasteboard];
     count = [pasteboard changeCount];
-    if (count != data->clipboard_count) {
-        if (data->clipboard_count) {
+    if (count != data.clipboard_count) {
+        if (data.clipboard_count) {
             SDL_SendClipboardUpdate();
         }
-        data->clipboard_count = count;
+        data.clipboard_count = count;
     }
 }}
 
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoaevents.m b/Engine/lib/sdl/src/video/cocoa/SDL_cocoaevents.m
index d077bad6e..3a256d2cf 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoaevents.m
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoaevents.m
@@ -45,7 +45,7 @@ static SDL_Window *FindSDLWindowForNSWindow(NSWindow *win)
     SDL_VideoDevice *device = SDL_GetVideoDevice();
     if (device && device->windows) {
         for (sdlwindow = device->windows; sdlwindow; sdlwindow = sdlwindow->next) {
-            NSWindow *nswindow = ((SDL_WindowData *) sdlwindow->driverdata)->nswindow;
+            NSWindow *nswindow = ((__bridge SDL_WindowData *) sdlwindow->driverdata).nswindow;
             if (win == nswindow)
                 return sdlwindow;
         }
@@ -121,7 +121,6 @@ static void Cocoa_DispatchEvent(NSEvent *theEvent)
                                  [NSNumber numberWithBool:YES], @"ApplePersistenceIgnoreState",
                                  nil];
     [[NSUserDefaults standardUserDefaults] registerDefaults:appDefaults];
-    [appDefaults release];
 }
 
 @end // SDLApplication
@@ -182,8 +181,6 @@ static void Cocoa_DispatchEvent(NSEvent *theEvent)
             removeEventHandlerForEventClass:kInternetEventClass
                                  andEventID:kAEGetURL];
     }
-
-    [super dealloc];
 }
 
 - (void)windowWillClose:(NSNotification *)notification;
@@ -374,9 +371,6 @@ CreateApplicationMenus(void)
     /* Create the main menu bar */
     [NSApp setMainMenu:mainMenu];
 
-    [mainMenu release];  /* we're done with it, let NSApp own it. */
-    mainMenu = nil;
-
     /* Create the application menu */
     appName = GetApplicationName();
     appleMenu = [[NSMenu alloc] initWithTitle:@""];
@@ -396,7 +390,6 @@ CreateApplicationMenus(void)
     [menuItem setSubmenu:serviceMenu];
 
     [NSApp setServicesMenu:serviceMenu];
-    [serviceMenu release];
 
     [appleMenu addItem:[NSMenuItem separatorItem]];
 
@@ -417,12 +410,9 @@ CreateApplicationMenus(void)
     menuItem = [[NSMenuItem alloc] initWithTitle:@"" action:nil keyEquivalent:@""];
     [menuItem setSubmenu:appleMenu];
     [[NSApp mainMenu] addItem:menuItem];
-    [menuItem release];
 
     /* Tell the application object that this is now the application menu */
     [NSApp setAppleMenu:appleMenu];
-    [appleMenu release];
-
 
     /* Create the window menu */
     windowMenu = [[NSMenu alloc] initWithTitle:@"Window"];
@@ -434,26 +424,21 @@ CreateApplicationMenus(void)
 
     [windowMenu addItemWithTitle:@"Zoom" action:@selector(performZoom:) keyEquivalent:@""];
     
-    /* Add the fullscreen toggle menu option, if supported */
-    if (floor(NSAppKitVersionNumber) > NSAppKitVersionNumber10_6) {
-        /* Cocoa should update the title to Enter or Exit Full Screen automatically.
-         * But if not, then just fallback to Toggle Full Screen.
-         */
-        menuItem = [[NSMenuItem alloc] initWithTitle:@"Toggle Full Screen" action:@selector(toggleFullScreen:) keyEquivalent:@"f"];
-        [menuItem setKeyEquivalentModifierMask:NSEventModifierFlagControl | NSEventModifierFlagCommand];
-        [windowMenu addItem:menuItem];
-        [menuItem release];
-    }
+    /* Add the fullscreen toggle menu option. */
+    /* Cocoa should update the title to Enter or Exit Full Screen automatically.
+     * But if not, then just fallback to Toggle Full Screen.
+     */
+    menuItem = [[NSMenuItem alloc] initWithTitle:@"Toggle Full Screen" action:@selector(toggleFullScreen:) keyEquivalent:@"f"];
+    [menuItem setKeyEquivalentModifierMask:NSEventModifierFlagControl | NSEventModifierFlagCommand];
+    [windowMenu addItem:menuItem];
 
     /* Put menu into the menubar */
     menuItem = [[NSMenuItem alloc] initWithTitle:@"Window" action:nil keyEquivalent:@""];
     [menuItem setSubmenu:windowMenu];
     [[NSApp mainMenu] addItem:menuItem];
-    [menuItem release];
 
     /* Tell the application object that this is now the window menu */
     [NSApp setWindowsMenu:windowMenu];
-    [windowMenu release];
 }
 
 void
@@ -518,19 +503,6 @@ Cocoa_RegisterApp(void)
 int
 Cocoa_PumpEventsUntilDate(_THIS, NSDate *expiration, bool accumulate)
 {
-#if MAC_OS_X_VERSION_MIN_REQUIRED < 1070
-    /* Update activity every 30 seconds to prevent screensaver */
-    SDL_VideoData *data = (SDL_VideoData *)_this->driverdata;
-    if (_this->suspend_screensaver && !data->screensaver_use_iopm) {
-        Uint32 now = SDL_GetTicks();
-        if (!data->screensaver_activity ||
-            SDL_TICKS_PASSED(now, data->screensaver_activity + 30000)) {
-            UpdateSystemActivity(UsrActivity);
-            data->screensaver_activity = now;
-        }
-    }
-#endif
-
     for ( ; ; ) {
         NSEvent *event = [NSApp nextEventMatchingMask:NSEventMaskAny untilDate:expiration inMode:NSDefaultRunLoopMode dequeue:YES ];
         if ( event == nil ) {
@@ -576,7 +548,7 @@ Cocoa_PumpEvents(_THIS)
 void Cocoa_SendWakeupEvent(_THIS, SDL_Window *window)
 { @autoreleasepool
 {
-    NSWindow *nswindow = ((SDL_WindowData *) window->driverdata)->nswindow;
+    NSWindow *nswindow = ((__bridge SDL_WindowData *) window->driverdata).nswindow;
 
     NSEvent* event = [NSEvent otherEventWithType: NSEventTypeApplicationDefined
                                     location: NSMakePoint(0,0)
@@ -595,15 +567,11 @@ void
 Cocoa_SuspendScreenSaver(_THIS)
 { @autoreleasepool
 {
-    SDL_VideoData *data = (SDL_VideoData *)_this->driverdata;
+    SDL_VideoData *data = (__bridge SDL_VideoData *)_this->driverdata;
 
-    if (!data->screensaver_use_iopm) {
-        return;
-    }
-
-    if (data->screensaver_assertion) {
-        IOPMAssertionRelease(data->screensaver_assertion);
-        data->screensaver_assertion = 0;
+    if (data.screensaver_assertion) {
+        IOPMAssertionRelease(data.screensaver_assertion);
+        data.screensaver_assertion = kIOPMNullAssertionID;
     }
 
     if (_this->suspend_screensaver) {
@@ -612,11 +580,13 @@ Cocoa_SuspendScreenSaver(_THIS)
          * seen by OS X power users. there's an additional optional human-readable
          * (localized) reason parameter which we don't set.
          */
+        IOPMAssertionID assertion = kIOPMNullAssertionID;
         NSString *name = [GetApplicationName() stringByAppendingString:@" using SDL_DisableScreenSaver"];
         IOPMAssertionCreateWithDescription(kIOPMAssertPreventUserIdleDisplaySleep,
-                                           (CFStringRef) name,
+                                           (__bridge CFStringRef) name,
                                            NULL, NULL, NULL, 0, NULL,
-                                           &data->screensaver_assertion);
+                                           &assertion);
+        data.screensaver_assertion = assertion;
     }
 }}
 
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoakeyboard.m b/Engine/lib/sdl/src/video/cocoa/SDL_cocoakeyboard.m
index b229ac3f6..59ee39dc0 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoakeyboard.m
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoakeyboard.m
@@ -104,8 +104,7 @@
     }
 
     if (_markedText != aString) {
-        [_markedText release];
-        _markedText = [aString retain];
+        _markedText = aString;
     }
 
     _selectedRange = selectedRange;
@@ -120,7 +119,6 @@
 
 - (void)unmarkText
 {
-    [_markedText release];
     _markedText = nil;
 
     SDL_SendEditingText("", 0, 0);
@@ -142,14 +140,7 @@
             aRange.location, aRange.length, windowHeight,
             NSStringFromRect(rect));
 
-#if MAC_OS_X_VERSION_MIN_REQUIRED < 1070
-    if (![window respondsToSelector:@selector(convertRectToScreen:)]) {
-        rect.origin = [window convertBaseToScreen:rect.origin];
-    } else
-#endif
-    {
-        rect = [window convertRectToScreen:rect];
-    }
+    rect = [window convertRectToScreen:rect];
 
     return rect;
 }
@@ -381,14 +372,14 @@ DoSidedModifiers(unsigned short scancode,
 static void
 HandleModifiers(_THIS, unsigned short scancode, unsigned int modifierFlags)
 {
-    SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
+    SDL_VideoData *data = (__bridge SDL_VideoData *) _this->driverdata;
 
-    if (modifierFlags == data->modifierFlags) {
+    if (modifierFlags == data.modifierFlags) {
         return;
     }
 
-    DoSidedModifiers(scancode, data->modifierFlags, modifierFlags);
-    data->modifierFlags = modifierFlags;
+    DoSidedModifiers(scancode, data.modifierFlags, modifierFlags);
+    data.modifierFlags = modifierFlags;
 }
 
 static void
@@ -402,10 +393,10 @@ UpdateKeymap(SDL_VideoData *data, SDL_bool send_event)
 
     /* See if the keymap needs to be updated */
     key_layout = TISCopyCurrentKeyboardLayoutInputSource();
-    if (key_layout == data->key_layout) {
+    if (key_layout == data.key_layout) {
         return;
     }
-    data->key_layout = key_layout;
+    data.key_layout = key_layout;
 
     SDL_GetDefaultKeymap(keymap);
 
@@ -461,7 +452,7 @@ cleanup:
 void
 Cocoa_InitKeyboard(_THIS)
 {
-    SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
+    SDL_VideoData *data = (__bridge SDL_VideoData *) _this->driverdata;
 
     UpdateKeymap(data, SDL_FALSE);
 
@@ -473,19 +464,19 @@ Cocoa_InitKeyboard(_THIS)
     SDL_SetScancodeName(SDL_SCANCODE_RALT, "Right Option");
     SDL_SetScancodeName(SDL_SCANCODE_RGUI, "Right Command");
 
-    data->modifierFlags = (unsigned int)[NSEvent modifierFlags];
-    SDL_ToggleModState(KMOD_CAPS, (data->modifierFlags & NSEventModifierFlagCapsLock) != 0);
+    data.modifierFlags = (unsigned int)[NSEvent modifierFlags];
+    SDL_ToggleModState(KMOD_CAPS, (data.modifierFlags & NSEventModifierFlagCapsLock) != 0);
 }
 
 void
 Cocoa_StartTextInput(_THIS)
 { @autoreleasepool
 {
-    SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
+    SDL_VideoData *data = (__bridge SDL_VideoData *) _this->driverdata;
     SDL_Window *window = SDL_GetKeyboardFocus();
     NSWindow *nswindow = nil;
     if (window) {
-        nswindow = ((SDL_WindowData*)window->driverdata)->nswindow;
+        nswindow = ((__bridge SDL_WindowData*)window->driverdata).nswindow;
     }
 
     NSView *parentView = [nswindow contentView];
@@ -495,16 +486,16 @@ Cocoa_StartTextInput(_THIS)
      * than one copy. When we switched to another window and requesting for
      * text input, simply remove the field editor from its superview then add
      * it to the front most window's content view */
-    if (!data->fieldEdit) {
-        data->fieldEdit =
+    if (!data.fieldEdit) {
+        data.fieldEdit =
             [[SDLTranslatorResponder alloc] initWithFrame: NSMakeRect(0.0, 0.0, 0.0, 0.0)];
     }
 
-    if (![[data->fieldEdit superview] isEqual:parentView]) {
+    if (![[data.fieldEdit superview] isEqual:parentView]) {
         /* DEBUG_IME(@"add fieldEdit to window contentView"); */
-        [data->fieldEdit removeFromSuperview];
-        [parentView addSubview: data->fieldEdit];
-        [nswindow makeFirstResponder: data->fieldEdit];
+        [data.fieldEdit removeFromSuperview];
+        [parentView addSubview: data.fieldEdit];
+        [nswindow makeFirstResponder: data.fieldEdit];
     }
 }}
 
@@ -512,32 +503,31 @@ void
 Cocoa_StopTextInput(_THIS)
 { @autoreleasepool
 {
-    SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
+    SDL_VideoData *data = (__bridge SDL_VideoData *) _this->driverdata;
 
-    if (data && data->fieldEdit) {
-        [data->fieldEdit removeFromSuperview];
-        [data->fieldEdit release];
-        data->fieldEdit = nil;
+    if (data && data.fieldEdit) {
+        [data.fieldEdit removeFromSuperview];
+        data.fieldEdit = nil;
     }
 }}
 
 void
 Cocoa_SetTextInputRect(_THIS, SDL_Rect *rect)
 {
-    SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
+    SDL_VideoData *data = (__bridge SDL_VideoData *) _this->driverdata;
 
     if (!rect) {
         SDL_InvalidParamError("rect");
         return;
     }
 
-    [data->fieldEdit setInputRect:rect];
+    [data.fieldEdit setInputRect:rect];
 }
 
 void
 Cocoa_HandleKeyEvent(_THIS, NSEvent *event)
 {
-    SDL_VideoData *data = _this ? ((SDL_VideoData *) _this->driverdata) : NULL;
+    SDL_VideoData *data = _this ? ((__bridge SDL_VideoData *) _this->driverdata) : nil;
     if (!data) {
         return;  /* can happen when returning from fullscreen Space on shutdown */
     }
@@ -575,7 +565,7 @@ Cocoa_HandleKeyEvent(_THIS, NSEvent *event)
 #endif
         if (SDL_EventState(SDL_TEXTINPUT, SDL_QUERY)) {
             /* FIXME CW 2007-08-16: only send those events to the field editor for which we actually want text events, not e.g. esc or function keys. Arrow keys in particular seem to produce crashes sometimes. */
-            [data->fieldEdit interpretKeyEvents:[NSArray arrayWithObject:event]];
+            [data.fieldEdit interpretKeyEvents:[NSArray arrayWithObject:event]];
 #if 0
             text = [[event characters] UTF8String];
             if(text && *text) {
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoamessagebox.m b/Engine/lib/sdl/src/video/cocoa/SDL_cocoamessagebox.m
index e3fc20b7e..494f88d71 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoamessagebox.m
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoamessagebox.m
@@ -45,9 +45,9 @@
 
         /* Retain the NSWindow because we'll show the alert later on the main thread */
         if (window) {
-            nswindow = [((SDL_WindowData *) window->driverdata)->nswindow retain];
+            nswindow = ((__bridge SDL_WindowData *) window->driverdata).nswindow;
         } else {
-            nswindow = NULL;
+            nswindow = nil;
         }
     }
 
@@ -60,7 +60,7 @@
 #ifdef MAC_OS_X_VERSION_10_9
         if ([alert respondsToSelector:@selector(beginSheetModalForWindow:completionHandler:)]) {
             [alert beginSheetModalForWindow:nswindow completionHandler:^(NSModalResponse returnCode) {
-                clicked = returnCode;
+                self->clicked = returnCode;
             }];
         } else
 #endif
@@ -75,7 +75,7 @@
             SDL_Delay(100);
         }
 
-        [nswindow release];
+        nswindow = nil;
     } else {
         clicked = [alert runModal];
     }
@@ -94,7 +94,7 @@ Cocoa_ShowMessageBoxImpl(const SDL_MessageBoxData *messageboxdata, int *buttonid
 {
     Cocoa_RegisterApp();
 
-    NSAlert* alert = [[[NSAlert alloc] init] autorelease];
+    NSAlert* alert = [[NSAlert alloc] init];
 
     if (messageboxdata->flags & SDL_MESSAGEBOX_ERROR) {
         [alert setAlertStyle:NSAlertStyleCritical];
@@ -129,7 +129,7 @@ Cocoa_ShowMessageBoxImpl(const SDL_MessageBoxData *messageboxdata, int *buttonid
         }
     }
 
-    SDLMessageBoxPresenter* presenter = [[[SDLMessageBoxPresenter alloc] initWithParentWindow:messageboxdata->window] autorelease];
+    SDLMessageBoxPresenter* presenter = [[SDLMessageBoxPresenter alloc] initWithParentWindow:messageboxdata->window];
 
     [presenter showAlert:alert];
 
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoametalview.m b/Engine/lib/sdl/src/video/cocoa/SDL_cocoametalview.m
index 6e33c4899..ebdc921a1 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoametalview.m
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoametalview.m
@@ -89,7 +89,7 @@ SDL_MetalViewEventWatch(void *userdata, SDL_Event *event)
         /* Allow resize. */
         self.autoresizingMask = NSViewWidthSizable | NSViewHeightSizable;
 
-        SDL_AddEventWatch(SDL_MetalViewEventWatch, self);
+        SDL_AddEventWatch(SDL_MetalViewEventWatch, (__bridge void *)(self));
 
         [self updateDrawableSize];
     }
@@ -99,8 +99,7 @@ SDL_MetalViewEventWatch(void *userdata, SDL_Event *event)
 
 - (void)dealloc
 {
-    SDL_DelEventWatch(SDL_MetalViewEventWatch, self);
-    [super dealloc];
+    SDL_DelEventWatch(SDL_MetalViewEventWatch, (__bridge void *)(self));
 }
 
 - (NSInteger)tag
@@ -135,7 +134,7 @@ SDL_MetalView
 Cocoa_Metal_CreateView(_THIS, SDL_Window * window)
 { @autoreleasepool {
     SDL_WindowData* data = (__bridge SDL_WindowData *)window->driverdata;
-    NSView *view = data->nswindow.contentView;
+    NSView *view = data.nswindow.contentView;
     BOOL highDPI = (window->flags & SDL_WINDOW_ALLOW_HIGHDPI) != 0;
     Uint32 windowID = SDL_GetWindowID(window);
     SDL_cocoametalview *newview;
@@ -151,7 +150,6 @@ Cocoa_Metal_CreateView(_THIS, SDL_Window * window)
     [view addSubview:newview];
 
     metalview = (SDL_MetalView)CFBridgingRetain(newview);
-    [newview release];
 
     return metalview;
 }}
@@ -174,7 +172,7 @@ void
 Cocoa_Metal_GetDrawableSize(_THIS, SDL_Window * window, int * w, int * h)
 { @autoreleasepool {
     SDL_WindowData *data = (__bridge SDL_WindowData *)window->driverdata;
-    NSView *contentView = data->sdlContentView;
+    NSView *contentView = data.sdlContentView;
     SDL_cocoametalview* metalview = [contentView viewWithTag:SDL_METALVIEW_TAG];
     if (metalview) {
         CAMetalLayer *layer = (CAMetalLayer*)metalview.layer;
@@ -189,11 +187,8 @@ Cocoa_Metal_GetDrawableSize(_THIS, SDL_Window * window, int * w, int * h)
         /* Fall back to the viewport size. */
         NSRect viewport = [contentView bounds];
         if (window->flags & SDL_WINDOW_ALLOW_HIGHDPI) {
-            /* This gives us the correct viewport for a Retina-enabled view, only
-             * supported on 10.7+. */
-            if ([contentView respondsToSelector:@selector(convertRectToBacking:)]) {
-                viewport = [contentView convertRectToBacking:viewport];
-            }
+            /* This gives us the correct viewport for a Retina-enabled view. */
+            viewport = [contentView convertRectToBacking:viewport];
         }
         if (w) {
             *w = viewport.size.width;
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoamodes.m b/Engine/lib/sdl/src/video/cocoa/SDL_cocoamodes.m
index 7d19030b2..88284b505 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoamodes.m
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoamodes.m
@@ -31,9 +31,6 @@
 #include <CoreVideo/CVBase.h>
 #include <CoreVideo/CVDisplayLink.h>
 
-/* we need this for ShowMenuBar() and HideMenuBar(). */
-#include <Carbon/Carbon.h>
-
 /* This gets us MAC_OS_X_VERSION_MIN_REQUIRED... */
 #include <AvailabilityMacros.h>
 
@@ -45,23 +42,6 @@
 #endif
 
 
-static void
-Cocoa_ToggleMenuBar(const BOOL show)
-{
-    /* !!! FIXME: keep an eye on this.
-     * ShowMenuBar/HideMenuBar is officially unavailable for 64-bit binaries.
-     *  It happens to work, as of 10.7, but we're going to see if
-     *  we can just simply do without it on newer OSes...
-     */
-#if (MAC_OS_X_VERSION_MIN_REQUIRED < 1070) && !defined(__LP64__)
-    if (show) {
-        ShowMenuBar();
-    } else {
-        HideMenuBar();
-    }
-#endif
-}
-
 static int
 CG_SetError(const char *prefix, CGDisplayErr result)
 {
@@ -306,7 +286,7 @@ Cocoa_GetDisplayName(CGDirectDisplayID displayID)
     /* This API is deprecated in 10.9 with no good replacement (as of 10.15). */
     io_service_t servicePort = CGDisplayIOServicePort(displayID);
     CFDictionaryRef deviceInfo = IODisplayCreateInfoDictionary(servicePort, kIODisplayOnlyPreferredName);
-    NSDictionary *localizedNames = [(NSDictionary *)deviceInfo objectForKey:[NSString stringWithUTF8String:kDisplayProductName]];
+    NSDictionary *localizedNames = [(__bridge NSDictionary *)deviceInfo objectForKey:[NSString stringWithUTF8String:kDisplayProductName]];
     const char* displayName = NULL;
 
     if ([localizedNames count] > 0) {
@@ -497,7 +477,7 @@ Cocoa_GetDisplayDPI(_THIS, SDL_VideoDisplay * display, float * ddpi, float * hdp
                 CFRelease(dmOptions);
             } else
 #endif
-            if (floor(NSAppKitVersionNumber) > NSAppKitVersionNumber10_6) {
+            {
                 // fallback for 10.7
                 scaleFactor = [screen backingScaleFactor];
                 displayNativeSize.width = displayNativeSize.width * scaleFactor;
@@ -646,10 +626,6 @@ Cocoa_SetDisplayMode(_THIS, SDL_VideoDisplay * display, SDL_DisplayMode * mode)
         } else {
             CGDisplayRelease(displaydata->display);
         }
-
-        if (CGDisplayIsMain(displaydata->display)) {
-            Cocoa_ToggleMenuBar(YES);
-        }
     } else {
         /* Put up the blanking window (a window above all other windows) */
         if (CGDisplayIsMain(displaydata->display)) {
@@ -669,11 +645,6 @@ Cocoa_SetDisplayMode(_THIS, SDL_VideoDisplay * display, SDL_DisplayMode * mode)
             CG_SetError("CGDisplaySwitchToMode()", result);
             goto ERR_NO_SWITCH;
         }
-
-        /* Hide the menu bar so it doesn't intercept events */
-        if (CGDisplayIsMain(displaydata->display)) {
-            Cocoa_ToggleMenuBar(NO);
-        }
     }
 
     /* Fade in again (asynchronously) */
@@ -720,7 +691,6 @@ Cocoa_QuitModes(_THIS)
             CFRelease(mode->modes);
         }
     }
-    Cocoa_ToggleMenuBar(YES);
 }
 
 #endif /* SDL_VIDEO_DRIVER_COCOA */
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoamouse.m b/Engine/lib/sdl/src/video/cocoa/SDL_cocoamouse.m
index 7713fb544..f6534b334 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoamouse.m
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoamouse.m
@@ -53,7 +53,7 @@
         NSData *cursorData = [NSData dataWithBytesNoCopy:&cursorBytes[0]
                                                   length:sizeof(cursorBytes)
                                             freeWhenDone:NO];
-        NSImage *cursorImage = [[[NSImage alloc] initWithData:cursorData] autorelease];
+        NSImage *cursorImage = [[NSImage alloc] initWithData:cursorData];
         invisibleCursor = [[NSCursor alloc] initWithImage:cursorImage
                                                   hotSpot:NSZeroPoint];
     }
@@ -75,8 +75,7 @@ Cocoa_CreateDefaultCursor()
     if (nscursor) {
         cursor = SDL_calloc(1, sizeof(*cursor));
         if (cursor) {
-            cursor->driverdata = nscursor;
-            [nscursor retain];
+            cursor->driverdata = (void *)CFBridgingRetain(nscursor);
         }
     }
 
@@ -99,15 +98,52 @@ Cocoa_CreateCursor(SDL_Surface * surface, int hot_x, int hot_y)
     if (nscursor) {
         cursor = SDL_calloc(1, sizeof(*cursor));
         if (cursor) {
-            cursor->driverdata = nscursor;
-        } else {
-            [nscursor release];
+            cursor->driverdata = (void *)CFBridgingRetain(nscursor);
         }
     }
 
     return cursor;
 }}
 
+/* there are .pdf files of some of the cursors we need, installed by default on macOS, but not available through NSCursor.
+   If we can load them ourselves, use them, otherwise fallback to something standard but not super-great.
+   Since these are under /System, they should be available even to sandboxed apps. */
+static NSCursor *
+LoadHiddenSystemCursor(NSString *cursorName, SEL fallback)
+{
+    NSString *cursorPath = [@"/System/Library/Frameworks/ApplicationServices.framework/Versions/A/Frameworks/HIServices.framework/Versions/A/Resources/cursors" stringByAppendingPathComponent:cursorName];
+    NSImage *image = [[NSImage alloc] initWithContentsOfFile:[cursorPath stringByAppendingPathComponent:@"cursor.pdf"]];
+    if ((image == nil) || (image.valid == NO)) {
+        return [NSCursor performSelector:fallback];
+    }
+
+    NSDictionary *info = [NSDictionary dictionaryWithContentsOfFile:[cursorPath stringByAppendingPathComponent:@"info.plist"]];
+
+    /* we can't do animation atm.  :/ */
+    const int frames = [[info valueForKey:@"frames"] integerValue];
+    if (frames > 1) {
+        const NSSize cropped_size = NSMakeSize(image.size.width, (int) (image.size.height / frames));
+        NSImage *cropped = [[NSImage alloc] initWithSize:cropped_size];
+        if (cropped == nil) {
+            return [NSCursor performSelector:fallback];
+        }
+
+        #ifdef MAC_OS_VERSION_12_0  /* same value as deprecated symbol. */
+        const NSCompositingOperation operation = NSCompositingOperationCopy;
+        #else
+        const NSCompositingOperation operation = NSCompositeCopy;
+        #endif
+        [cropped lockFocus];
+        const NSRect cropped_rect = NSMakeRect(0, 0, cropped_size.width, cropped_size.height);
+        [image drawInRect:cropped_rect fromRect:cropped_rect operation:operation fraction:1];
+        [cropped unlockFocus];
+        image = cropped;
+    }
+
+    NSCursor *cursor = [[NSCursor alloc] initWithImage:image hotSpot:NSMakePoint([[info valueForKey:@"hotx"] doubleValue], [[info valueForKey:@"hoty"] doubleValue])];
+    return cursor;
+}
+
 static SDL_Cursor *
 Cocoa_CreateSystemCursor(SDL_SystemCursor id)
 { @autoreleasepool
@@ -122,27 +158,29 @@ Cocoa_CreateSystemCursor(SDL_SystemCursor id)
     case SDL_SYSTEM_CURSOR_IBEAM:
         nscursor = [NSCursor IBeamCursor];
         break;
-    case SDL_SYSTEM_CURSOR_WAIT:
-        nscursor = [NSCursor arrowCursor];
-        break;
     case SDL_SYSTEM_CURSOR_CROSSHAIR:
         nscursor = [NSCursor crosshairCursor];
         break;
-    case SDL_SYSTEM_CURSOR_WAITARROW:
-        nscursor = [NSCursor arrowCursor];
+    case SDL_SYSTEM_CURSOR_WAIT:  /* !!! FIXME: this is more like WAITARROW */
+        nscursor = LoadHiddenSystemCursor(@"busybutclickable", @selector(arrowCursor));
+        break;
+    case SDL_SYSTEM_CURSOR_WAITARROW:  /* !!! FIXME: this is meant to be animated */
+        nscursor = LoadHiddenSystemCursor(@"busybutclickable", @selector(arrowCursor));
         break;
     case SDL_SYSTEM_CURSOR_SIZENWSE:
+        nscursor = LoadHiddenSystemCursor(@"resizenorthwestsoutheast", @selector(closedHandCursor));
+        break;
     case SDL_SYSTEM_CURSOR_SIZENESW:
-        nscursor = [NSCursor closedHandCursor];
+        nscursor = LoadHiddenSystemCursor(@"resizenortheastsouthwest", @selector(closedHandCursor));
         break;
     case SDL_SYSTEM_CURSOR_SIZEWE:
-        nscursor = [NSCursor resizeLeftRightCursor];
+        nscursor = LoadHiddenSystemCursor(@"resizeeastwest", @selector(resizeLeftRightCursor));
         break;
     case SDL_SYSTEM_CURSOR_SIZENS:
-        nscursor = [NSCursor resizeUpDownCursor];
+        nscursor = LoadHiddenSystemCursor(@"resizenorthsouth", @selector(resizeUpDownCursor));
         break;
     case SDL_SYSTEM_CURSOR_SIZEALL:
-        nscursor = [NSCursor closedHandCursor];
+        nscursor = LoadHiddenSystemCursor(@"move", @selector(closedHandCursor));
         break;
     case SDL_SYSTEM_CURSOR_NO:
         nscursor = [NSCursor operationNotAllowedCursor];
@@ -159,8 +197,7 @@ Cocoa_CreateSystemCursor(SDL_SystemCursor id)
         cursor = SDL_calloc(1, sizeof(*cursor));
         if (cursor) {
             /* We'll free it later, so retain it here */
-            [nscursor retain];
-            cursor->driverdata = nscursor;
+            cursor->driverdata = (void *)CFBridgingRetain(nscursor);
         }
     }
 
@@ -171,9 +208,7 @@ static void
 Cocoa_FreeCursor(SDL_Cursor * cursor)
 { @autoreleasepool
 {
-    NSCursor *nscursor = (NSCursor *)cursor->driverdata;
-
-    [nscursor release];
+    CFBridgingRelease(cursor->driverdata);
     SDL_free(cursor);
 }}
 
@@ -184,11 +219,11 @@ Cocoa_ShowCursor(SDL_Cursor * cursor)
     SDL_VideoDevice *device = SDL_GetVideoDevice();
     SDL_Window *window = (device ? device->windows : NULL);
     for (; window != NULL; window = window->next) {
-        SDL_WindowData *driverdata = (SDL_WindowData *)window->driverdata;
+        SDL_WindowData *driverdata = (__bridge SDL_WindowData *)window->driverdata;
         if (driverdata) {
-            [driverdata->nswindow performSelectorOnMainThread:@selector(invalidateCursorRectsForView:)
-                                                   withObject:[driverdata->nswindow contentView]
-                                                waitUntilDone:NO];
+            [driverdata.nswindow performSelectorOnMainThread:@selector(invalidateCursorRectsForView:)
+                                                  withObject:[driverdata.nswindow contentView]
+                                               waitUntilDone:NO];
         }
     }
     return 0;
@@ -214,10 +249,10 @@ Cocoa_WarpMouseGlobal(int x, int y)
 {
     SDL_Mouse *mouse = SDL_GetMouse();
     if (mouse->focus) {
-        SDL_WindowData *data = (SDL_WindowData *) mouse->focus->driverdata;
-        if ([data->listener isMovingOrFocusClickPending]) {
+        SDL_WindowData *data = (__bridge SDL_WindowData *) mouse->focus->driverdata;
+        if ([data.listener isMovingOrFocusClickPending]) {
             DLog("Postponing warp, window being moved or focused.");
-            [data->listener setPendingMoveX:x Y:y];
+            [data.listener setPendingMoveX:x Y:y];
             return 0;
         }
     }
@@ -259,22 +294,6 @@ Cocoa_WarpMouse(SDL_Window * window, int x, int y)
 static int
 Cocoa_SetRelativeMouseMode(SDL_bool enabled)
 {
-    /* We will re-apply the relative mode when the window gets focus, if it
-     * doesn't have focus right now.
-     */
-    SDL_Window *window = SDL_GetKeyboardFocus();
-    if (!window) {
-        return 0;
-    }
-
-    /* We will re-apply the relative mode when the window finishes being moved,
-     * if it is being moved right now.
-     */
-    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
-    if ([data->listener isMovingOrFocusClickPending]) {
-        return 0;
-    }
-
     CGError result;
     if (enabled) {
         DLog("Turning on.");
@@ -287,6 +306,22 @@ Cocoa_SetRelativeMouseMode(SDL_bool enabled)
         return SDL_SetError("CGAssociateMouseAndMouseCursorPosition() failed");
     }
 
+    /* We will re-apply the non-relative mode when the window gets focus, if it
+     * doesn't have focus right now.
+     */
+    SDL_Window *window = SDL_GetKeyboardFocus();
+    if (!window) {
+        return 0;
+    }
+
+    /* We will re-apply the non-relative mode when the window finishes being moved,
+     * if it is being moved right now.
+     */
+    SDL_WindowData *data = (__bridge SDL_WindowData *) window->driverdata;
+    if ([data.listener isMovingOrFocusClickPending]) {
+        return 0;
+    }
+
     /* The hide/unhide calls are redundant most of the time, but they fix
      * https://bugzilla.libsdl.org/show_bug.cgi?id=2550
      */
@@ -360,18 +395,18 @@ Cocoa_HandleTitleButtonEvent(_THIS, NSEvent *event)
     NSWindow *nswindow = [event window];
 
     for (window = _this->windows; window; window = window->next) {
-        SDL_WindowData *data = (SDL_WindowData *)window->driverdata;
-        if (data && data->nswindow == nswindow) {
+        SDL_WindowData *data = (__bridge SDL_WindowData *)window->driverdata;
+        if (data && data.nswindow == nswindow) {
             switch ([event type]) {
             case NSEventTypeLeftMouseDown:
             case NSEventTypeRightMouseDown:
             case NSEventTypeOtherMouseDown:
-                [data->listener setFocusClickPending:[event buttonNumber]];
+                [data.listener setFocusClickPending:[event buttonNumber]];
                 break;
             case NSEventTypeLeftMouseUp:
             case NSEventTypeRightMouseUp:
             case NSEventTypeOtherMouseUp:
-                [data->listener clearFocusClickPending:[event buttonNumber]];
+                [data.listener clearFocusClickPending:[event buttonNumber]];
                 break;
             default:
                 break;
@@ -467,15 +502,13 @@ Cocoa_HandleMouseWheel(SDL_Window *window, NSEvent *event)
     CGFloat y = [event deltaY];
     SDL_MouseWheelDirection direction = SDL_MOUSEWHEEL_NORMAL;
 
-    if ([event respondsToSelector:@selector(isDirectionInvertedFromDevice)]) {
-        if ([event isDirectionInvertedFromDevice] == YES) {
-            direction = SDL_MOUSEWHEEL_FLIPPED;
-        }
+    if ([event isDirectionInvertedFromDevice] == YES) {
+        direction = SDL_MOUSEWHEEL_FLIPPED;
     }
 
     /* For discrete scroll events from conventional mice, always send a full tick.
        For continuous scroll events from trackpads, send fractional deltas for smoother scrolling. */
-    if (![event respondsToSelector:@selector(hasPreciseScrollingDeltas)] || ![event hasPreciseScrollingDeltas]) {
+    if (![event hasPreciseScrollingDeltas]) {
         if (x > 0) {
             x = SDL_ceil(x);
         } else if (x < 0) {
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoaopengl.m b/Engine/lib/sdl/src/video/cocoa/SDL_cocoaopengl.m
index 9d31b9c22..aa2f51eaa 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoaopengl.m
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoaopengl.m
@@ -82,10 +82,10 @@
 - (void)setWindow:(SDL_Window *)newWindow
 {
     if (self->window) {
-        SDL_WindowData *oldwindowdata = (SDL_WindowData *)self->window->driverdata;
+        SDL_WindowData *oldwindowdata = (__bridge SDL_WindowData *)self->window->driverdata;
 
         /* Make sure to remove us from the old window's context list, or we'll get scheduled updates from it too. */
-        NSMutableArray *contexts = oldwindowdata->nscontexts;
+        NSMutableArray *contexts = oldwindowdata.nscontexts;
         @synchronized (contexts) {
             [contexts removeObject:self];
         }
@@ -94,11 +94,11 @@
     self->window = newWindow;
 
     if (newWindow) {
-        SDL_WindowData *windowdata = (SDL_WindowData *)newWindow->driverdata;
-        NSView *contentview = windowdata->sdlContentView;
+        SDL_WindowData *windowdata = (__bridge SDL_WindowData *)newWindow->driverdata;
+        NSView *contentview = windowdata.sdlContentView;
 
         /* Now sign up for scheduled updates for the new window. */
-        NSMutableArray *contexts = windowdata->nscontexts;
+        NSMutableArray *contexts = windowdata.nscontexts;
         @synchronized (contexts) {
             [contexts addObject:self];
         }
@@ -180,10 +180,10 @@ Cocoa_GL_CreateContext(_THIS, SDL_Window * window)
 {
     SDL_VideoDisplay *display = SDL_GetDisplayForWindow(window);
     SDL_DisplayData *displaydata = (SDL_DisplayData *)display->driverdata;
-    SDL_bool lion_or_later = floor(NSAppKitVersionNumber) > NSAppKitVersionNumber10_6;
     NSOpenGLPixelFormatAttribute attr[32];
     NSOpenGLPixelFormat *fmt;
     SDLOpenGLContext *context;
+    SDL_GLContext sdlcontext;
     NSOpenGLContext *share_context = nil;
     int i = 0;
     const char *glversion;
@@ -213,22 +213,15 @@ Cocoa_GL_CreateContext(_THIS, SDL_Window * window)
         return NULL;
 #endif
     }
-    if ((_this->gl_config.profile_mask == SDL_GL_CONTEXT_PROFILE_CORE) && !lion_or_later) {
-        SDL_SetError ("OpenGL Core Profile is not supported on this platform version");
-        return NULL;
-    }
 
     attr[i++] = NSOpenGLPFAAllowOfflineRenderers;
 
-    /* specify a profile if we're on Lion (10.7) or later. */
-    if (lion_or_later) {
-        NSOpenGLPixelFormatAttribute profile = NSOpenGLProfileVersionLegacy;
-        if (_this->gl_config.profile_mask == SDL_GL_CONTEXT_PROFILE_CORE) {
-            profile = NSOpenGLProfileVersion3_2Core;
-        }
-        attr[i++] = NSOpenGLPFAOpenGLProfile;
-        attr[i++] = profile;
+    NSOpenGLPixelFormatAttribute profile = NSOpenGLProfileVersionLegacy;
+    if (_this->gl_config.profile_mask == SDL_GL_CONTEXT_PROFILE_CORE) {
+        profile = NSOpenGLProfileVersion3_2Core;
     }
+    attr[i++] = NSOpenGLPFAOpenGLProfile;
+    attr[i++] = profile;
 
     attr[i++] = NSOpenGLPFAColorSize;
     attr[i++] = SDL_BYTESPERPIXEL(display->current_mode.format)*8;
@@ -288,20 +281,20 @@ Cocoa_GL_CreateContext(_THIS, SDL_Window * window)
     }
 
     if (_this->gl_config.share_with_current_context) {
-        share_context = (NSOpenGLContext*)SDL_GL_GetCurrentContext();
+        share_context = (__bridge NSOpenGLContext*)SDL_GL_GetCurrentContext();
     }
 
     context = [[SDLOpenGLContext alloc] initWithFormat:fmt shareContext:share_context];
 
-    [fmt release];
-
     if (context == nil) {
         SDL_SetError("Failed creating OpenGL context");
         return NULL;
     }
 
-    if ( Cocoa_GL_MakeCurrent(_this, window, context) < 0 ) {
-        Cocoa_GL_DeleteContext(_this, context);
+    sdlcontext = (SDL_GLContext)CFBridgingRetain(context);
+
+    if ( Cocoa_GL_MakeCurrent(_this, window, (__bridge SDL_GLContext)context) < 0 ) {
+        Cocoa_GL_DeleteContext(_this, (__bridge SDL_GLContext)context);
         SDL_SetError("Failed making OpenGL context current");
         return NULL;
     }
@@ -315,27 +308,27 @@ Cocoa_GL_CreateContext(_THIS, SDL_Window * window)
 
         glGetStringFunc = (const GLubyte *(APIENTRY *)(GLenum)) SDL_GL_GetProcAddress("glGetString");
         if (!glGetStringFunc) {
-            Cocoa_GL_DeleteContext(_this, context);
+            Cocoa_GL_DeleteContext(_this, (__bridge SDL_GLContext)context);
             SDL_SetError ("Failed getting OpenGL glGetString entry point");
             return NULL;
         }
 
         glversion = (const char *)glGetStringFunc(GL_VERSION);
         if (glversion == NULL) {
-            Cocoa_GL_DeleteContext(_this, context);
+            Cocoa_GL_DeleteContext(_this, (__bridge SDL_GLContext)context);
             SDL_SetError ("Failed getting OpenGL context version");
             return NULL;
         }
 
         if (SDL_sscanf(glversion, "%d.%d", &glversion_major, &glversion_minor) != 2) {
-            Cocoa_GL_DeleteContext(_this, context);
+            Cocoa_GL_DeleteContext(_this, (__bridge SDL_GLContext)context);
             SDL_SetError ("Failed parsing OpenGL context version");
             return NULL;
         }
 
         if ((glversion_major < _this->gl_config.major_version) ||
            ((glversion_major == _this->gl_config.major_version) && (glversion_minor < _this->gl_config.minor_version))) {
-            Cocoa_GL_DeleteContext(_this, context);
+            Cocoa_GL_DeleteContext(_this, (__bridge SDL_GLContext)context);
             SDL_SetError ("Failed creating OpenGL context at version requested");
             return NULL;
         }
@@ -346,7 +339,7 @@ Cocoa_GL_CreateContext(_THIS, SDL_Window * window)
         /*_this->gl_config.major_version = glversion_major;*/
         /*_this->gl_config.minor_version = glversion_minor;*/
     }
-    return context;
+    return sdlcontext;
 }}
 
 int
@@ -354,7 +347,7 @@ Cocoa_GL_MakeCurrent(_THIS, SDL_Window * window, SDL_GLContext context)
 { @autoreleasepool
 {
     if (context) {
-        SDLOpenGLContext *nscontext = (SDLOpenGLContext *)context;
+        SDLOpenGLContext *nscontext = (__bridge SDLOpenGLContext *)context;
         if ([nscontext window] != window) {
             [nscontext setWindow:window];
             [nscontext updateIfNeeded];
@@ -369,17 +362,15 @@ Cocoa_GL_MakeCurrent(_THIS, SDL_Window * window, SDL_GLContext context)
 
 void
 Cocoa_GL_GetDrawableSize(_THIS, SDL_Window * window, int * w, int * h)
+{ @autoreleasepool
 {
-    SDL_WindowData *windata = (SDL_WindowData *) window->driverdata;
-    NSView *contentView = windata->sdlContentView;
+    SDL_WindowData *windata = (__bridge SDL_WindowData *) window->driverdata;
+    NSView *contentView = windata.sdlContentView;
     NSRect viewport = [contentView bounds];
 
     if (window->flags & SDL_WINDOW_ALLOW_HIGHDPI) {
-        /* This gives us the correct viewport for a Retina-enabled view, only
-         * supported on 10.7+. */
-        if ([contentView respondsToSelector:@selector(convertRectToBacking:)]) {
-            viewport = [contentView convertRectToBacking:viewport];
-        }
+        /* This gives us the correct viewport for a Retina-enabled view. */
+        viewport = [contentView convertRectToBacking:viewport];
     }
 
     if (w) {
@@ -389,7 +380,7 @@ Cocoa_GL_GetDrawableSize(_THIS, SDL_Window * window, int * w, int * h)
     if (h) {
         *h = viewport.size.height;
     }
-}
+}}
 
 int
 Cocoa_GL_SetSwapInterval(_THIS, int interval)
@@ -403,7 +394,7 @@ Cocoa_GL_SetSwapInterval(_THIS, int interval)
         return SDL_SetError("Late swap tearing currently unsupported");
     }
 
-    nscontext = (NSOpenGLContext*)SDL_GL_GetCurrentContext();
+    nscontext = (__bridge NSOpenGLContext*)SDL_GL_GetCurrentContext();
     if (nscontext != nil) {
         value = interval;
         [nscontext setValues:&value forParameter:NSOpenGLCPSwapInterval];
@@ -423,7 +414,7 @@ Cocoa_GL_GetSwapInterval(_THIS)
     GLint value;
     int status = 0;
 
-    nscontext = (NSOpenGLContext*)SDL_GL_GetCurrentContext();
+    nscontext = (__bridge NSOpenGLContext*)SDL_GL_GetCurrentContext();
     if (nscontext != nil) {
         [nscontext getValues:&value forParameter:NSOpenGLCPSwapInterval];
         status = (int)value;
@@ -436,15 +427,15 @@ int
 Cocoa_GL_SwapWindow(_THIS, SDL_Window * window)
 { @autoreleasepool
 {
-    SDLOpenGLContext* nscontext = (SDLOpenGLContext*)SDL_GL_GetCurrentContext();
-    SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;
+    SDLOpenGLContext* nscontext = (__bridge SDLOpenGLContext*)SDL_GL_GetCurrentContext();
+    SDL_VideoData *videodata = (__bridge SDL_VideoData *) _this->driverdata;
 
     /* on 10.14 ("Mojave") and later, this deadlocks if two contexts in two
        threads try to swap at the same time, so put a mutex around it. */
-    SDL_LockMutex(videodata->swaplock);
+    SDL_LockMutex(videodata.swaplock);
     [nscontext flushBuffer];
     [nscontext updateIfNeeded];
-    SDL_UnlockMutex(videodata->swaplock);
+    SDL_UnlockMutex(videodata.swaplock);
     return 0;
 }}
 
@@ -452,10 +443,8 @@ void
 Cocoa_GL_DeleteContext(_THIS, SDL_GLContext context)
 { @autoreleasepool
 {
-    SDLOpenGLContext *nscontext = (SDLOpenGLContext *)context;
-
+    SDLOpenGLContext *nscontext = (SDLOpenGLContext *)CFBridgingRelease(context);
     [nscontext setWindow:NULL];
-    [nscontext release];
 }}
 
 /* We still support OpenGL as long as Apple offers it, deprecated or not, so disable deprecation warnings about it. */
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoaopengles.m b/Engine/lib/sdl/src/video/cocoa/SDL_cocoaopengles.m
index 13102f8c0..63d013d8f 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoaopengles.m
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoaopengles.m
@@ -29,8 +29,8 @@
 /* EGL implementation of SDL OpenGL support */
 
 int
-Cocoa_GLES_LoadLibrary(_THIS, const char *path) {
-
+Cocoa_GLES_LoadLibrary(_THIS, const char *path)
+{
     /* If the profile requested is not GL ES, switch over to WIN_GL functions  */
     if (_this->gl_config.profile_mask != SDL_GL_CONTEXT_PROFILE_ES) {
 #if SDL_VIDEO_OPENGL_CGL
@@ -59,9 +59,10 @@ Cocoa_GLES_LoadLibrary(_THIS, const char *path) {
 
 SDL_GLContext
 Cocoa_GLES_CreateContext(_THIS, SDL_Window * window)
+{ @autoreleasepool
 {
     SDL_GLContext context;
-    SDL_WindowData *data = (SDL_WindowData *)window->driverdata;
+    SDL_WindowData *data = (__bridge SDL_WindowData *)window->driverdata;
 
 #if SDL_VIDEO_OPENGL_CGL
     if (_this->gl_config.profile_mask != SDL_GL_CONTEXT_PROFILE_ES) {
@@ -85,25 +86,37 @@ Cocoa_GLES_CreateContext(_THIS, SDL_Window * window)
     }
 #endif
 
-    context = SDL_EGL_CreateContext(_this, data->egl_surface);
+    context = SDL_EGL_CreateContext(_this, data.egl_surface);
     return context;
-}
+}}
 
 void
 Cocoa_GLES_DeleteContext(_THIS, SDL_GLContext context)
+{ @autoreleasepool
 {
     SDL_EGL_DeleteContext(_this, context);
     Cocoa_GLES_UnloadLibrary(_this);
-}
+}}
 
-SDL_EGL_SwapWindow_impl(Cocoa)
-SDL_EGL_MakeCurrent_impl(Cocoa)
+int
+Cocoa_GLES_SwapWindow(_THIS, SDL_Window * window)
+{ @autoreleasepool
+{
+    return SDL_EGL_SwapBuffers(_this, ((__bridge SDL_WindowData *) window->driverdata).egl_surface);
+}}
+
+int
+Cocoa_GLES_MakeCurrent(_THIS, SDL_Window * window, SDL_GLContext context)
+{ @autoreleasepool
+{
+    return SDL_EGL_MakeCurrent(_this, window ? ((__bridge SDL_WindowData *) window->driverdata).egl_surface : EGL_NO_SURFACE, context);
+}}
 
 int
 Cocoa_GLES_SetupWindow(_THIS, SDL_Window * window)
 {
     /* The current context is lost in here; save it and reset it. */
-    SDL_WindowData *windowdata = (SDL_WindowData *) window->driverdata;
+    SDL_WindowData *windowdata = (__bridge SDL_WindowData *) window->driverdata;
     SDL_Window *current_win = SDL_GL_GetCurrentWindow();
     SDL_GLContext current_ctx = SDL_GL_GetCurrentContext();
 
@@ -121,10 +134,10 @@ Cocoa_GLES_SetupWindow(_THIS, SDL_Window * window)
     }
   
     /* Create the GLES window surface */
-    NSView* v = windowdata->nswindow.contentView;
-    windowdata->egl_surface = SDL_EGL_CreateSurface(_this, (NativeWindowType)[v layer]);
+    NSView* v = windowdata.nswindow.contentView;
+    windowdata.egl_surface = SDL_EGL_CreateSurface(_this, (__bridge NativeWindowType)[v layer]);
 
-    if (windowdata->egl_surface == EGL_NO_SURFACE) {
+    if (windowdata.egl_surface == EGL_NO_SURFACE) {
         return SDL_SetError("Could not create GLES window surface");
     }
 
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoashape.m b/Engine/lib/sdl/src/video/cocoa/SDL_cocoashape.m
index 1176036ac..2fa5cab0f 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoashape.m
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoashape.m
@@ -29,11 +29,12 @@
 
 SDL_WindowShaper*
 Cocoa_CreateShaper(SDL_Window* window)
+{ @autoreleasepool
 {
-    SDL_WindowData* windata = (SDL_WindowData*)window->driverdata;
-    [windata->nswindow setOpaque:NO];
+    SDL_WindowData* windata = (__bridge SDL_WindowData*)window->driverdata;
+    [windata.nswindow setOpaque:NO];
 
-    [windata->nswindow setStyleMask:NSWindowStyleMaskBorderless];
+    [windata.nswindow setStyleMask:NSWindowStyleMaskBorderless];
 
     SDL_WindowShaper* result = (SDL_WindowShaper *)SDL_malloc(sizeof(SDL_WindowShaper));
     result->window = window;
@@ -44,14 +45,14 @@ Cocoa_CreateShaper(SDL_Window* window)
 
     SDL_ShapeData* data = (SDL_ShapeData *)SDL_malloc(sizeof(SDL_ShapeData));
     result->driverdata = data;
-    data->context = [windata->nswindow graphicsContext];
+    data->context = [windata.nswindow graphicsContext];
     data->saved = SDL_FALSE;
     data->shape = NULL;
 
     int resized_properly = Cocoa_ResizeWindowShape(window);
     SDL_assert(resized_properly == 0);
     return result;
-}
+}}
 
 typedef struct {
     NSView* view;
@@ -74,7 +75,7 @@ Cocoa_SetWindowShape(SDL_WindowShaper *shaper, SDL_Surface *shape, SDL_WindowSha
 { @autoreleasepool
 {
     SDL_ShapeData* data = (SDL_ShapeData*)shaper->driverdata;
-    SDL_WindowData* windata = (SDL_WindowData*)shaper->window->driverdata;
+    SDL_WindowData* windata = (__bridge SDL_WindowData*)shaper->window->driverdata;
     SDL_CocoaClosure closure;
     if(data->saved == SDL_TRUE) {
         [data->context restoreGraphicsState];
@@ -86,10 +87,10 @@ Cocoa_SetWindowShape(SDL_WindowShaper *shaper, SDL_Surface *shape, SDL_WindowSha
     [NSGraphicsContext setCurrentContext:data->context];
 
     [[NSColor clearColor] set];
-    NSRectFill([windata->sdlContentView frame]);
+    NSRectFill([windata.sdlContentView frame]);
     data->shape = SDL_CalculateShapeTree(*shape_mode,shape);
 
-    closure.view = windata->sdlContentView;
+    closure.view = windata.sdlContentView;
     closure.path = [NSBezierPath bezierPath];
     closure.window = shaper->window;
     SDL_TraverseShapeTree(data->shape,&ConvertRects,&closure);
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoavideo.h b/Engine/lib/sdl/src/video/cocoa/SDL_cocoavideo.h
index af0abe5cc..4de8511a3 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoavideo.h
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoavideo.h
@@ -97,18 +97,15 @@ DECLARE_ALERT_STYLE(Critical);
 
 @class SDLTranslatorResponder;
 
-typedef struct SDL_VideoData
-{
-    int allow_spaces;
-    unsigned int modifierFlags;
-    void *key_layout;
-    SDLTranslatorResponder *fieldEdit;
-    NSInteger clipboard_count;
-    Uint32 screensaver_activity;
-    BOOL screensaver_use_iopm;
-    IOPMAssertionID screensaver_assertion;
-    SDL_mutex *swaplock;
-} SDL_VideoData;
+@interface SDL_VideoData : NSObject
+    @property (nonatomic) int allow_spaces;
+    @property (nonatomic) unsigned int modifierFlags;
+    @property (nonatomic) void *key_layout;
+    @property (nonatomic) SDLTranslatorResponder *fieldEdit;
+    @property (nonatomic) NSInteger clipboard_count;
+    @property (nonatomic) IOPMAssertionID screensaver_assertion;
+    @property (nonatomic) SDL_mutex *swaplock;
+@end
 
 /* Utility functions */
 extern NSImage * Cocoa_CreateImage(SDL_Surface * surface);
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoavideo.m b/Engine/lib/sdl/src/video/cocoa/SDL_cocoavideo.m
index 231b2de5c..1df31f648 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoavideo.m
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoavideo.m
@@ -22,6 +22,10 @@
 
 #if SDL_VIDEO_DRIVER_COCOA
 
+#if !__has_feature(objc_arc)
+#error SDL must be built with Objective-C ARC (automatic reference counting) enabled
+#endif
+
 #include "SDL.h"
 #include "SDL_endian.h"
 #include "SDL_cocoavideo.h"
@@ -29,6 +33,10 @@
 #include "SDL_cocoavulkan.h"
 #include "SDL_cocoametalview.h"
 
+@implementation SDL_VideoData
+
+@end
+
 /* Initialization/Query functions */
 static int Cocoa_VideoInit(_THIS);
 static void Cocoa_VideoQuit(_THIS);
@@ -37,16 +45,18 @@ static void Cocoa_VideoQuit(_THIS);
 
 static void
 Cocoa_DeleteDevice(SDL_VideoDevice * device)
+{ @autoreleasepool
 {
     if (device->wakeup_lock) {
         SDL_DestroyMutex(device->wakeup_lock);
     }
-    SDL_free(device->driverdata);
+    CFBridgingRelease(device->driverdata);
     SDL_free(device);
-}
+}}
 
 static SDL_VideoDevice *
 Cocoa_CreateDevice(int devindex)
+{ @autoreleasepool
 {
     SDL_VideoDevice *device;
     SDL_VideoData *data;
@@ -56,16 +66,16 @@ Cocoa_CreateDevice(int devindex)
     /* Initialize all variables that we clean on shutdown */
     device = (SDL_VideoDevice *) SDL_calloc(1, sizeof(SDL_VideoDevice));
     if (device) {
-        data = (struct SDL_VideoData *) SDL_calloc(1, sizeof(SDL_VideoData));
+        data = [[SDL_VideoData alloc] init];
     } else {
-        data = NULL;
+        data = nil;
     }
     if (!data) {
         SDL_OutOfMemory();
         SDL_free(device);
         return NULL;
     }
-    device->driverdata = data;
+    device->driverdata = (void *)CFBridgingRetain(data);
     device->wakeup_lock = SDL_CreateMutex();
 
     /* Set the function pointers */
@@ -103,6 +113,7 @@ Cocoa_CreateDevice(int devindex)
     device->SetWindowGammaRamp = Cocoa_SetWindowGammaRamp;
     device->GetWindowGammaRamp = Cocoa_GetWindowGammaRamp;
     device->GetWindowICCProfile = Cocoa_GetWindowICCProfile;
+    device->GetWindowDisplayIndex = Cocoa_GetWindowDisplayIndex;
     device->SetWindowMouseRect = Cocoa_SetWindowMouseRect;
     device->SetWindowMouseGrab = Cocoa_SetWindowMouseGrab;
     device->SetWindowKeyboardGrab = Cocoa_SetWindowKeyboardGrab;
@@ -165,7 +176,7 @@ Cocoa_CreateDevice(int devindex)
     device->free = Cocoa_DeleteDevice;
 
     return device;
-}
+}}
 
 VideoBootStrap COCOA_bootstrap = {
     "cocoa", "SDL Cocoa video driver",
@@ -175,8 +186,9 @@ VideoBootStrap COCOA_bootstrap = {
 
 int
 Cocoa_VideoInit(_THIS)
+{ @autoreleasepool
 {
-    SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
+    SDL_VideoData *data = (__bridge SDL_VideoData *) _this->driverdata;
 
     Cocoa_InitModes(_this);
     Cocoa_InitKeyboard(_this);
@@ -184,29 +196,27 @@ Cocoa_VideoInit(_THIS)
         return -1;
     }
 
-    data->allow_spaces = ((floor(NSAppKitVersionNumber) > NSAppKitVersionNumber10_6) && SDL_GetHintBoolean(SDL_HINT_VIDEO_MAC_FULLSCREEN_SPACES, SDL_TRUE));
+    data.allow_spaces = SDL_GetHintBoolean(SDL_HINT_VIDEO_MAC_FULLSCREEN_SPACES, SDL_TRUE);
 
-    /* The IOPM assertion API can disable the screensaver as of 10.7. */
-    data->screensaver_use_iopm = floor(NSAppKitVersionNumber) > NSAppKitVersionNumber10_6;
-
-    data->swaplock = SDL_CreateMutex();
-    if (!data->swaplock) {
+    data.swaplock = SDL_CreateMutex();
+    if (!data.swaplock) {
         return -1;
     }
 
     return 0;
-}
+}}
 
 void
 Cocoa_VideoQuit(_THIS)
+{ @autoreleasepool
 {
-    SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
+    SDL_VideoData *data = (__bridge SDL_VideoData *) _this->driverdata;
     Cocoa_QuitModes(_this);
     Cocoa_QuitKeyboard(_this);
     Cocoa_QuitMouse(_this);
-    SDL_DestroyMutex(data->swaplock);
-    data->swaplock = NULL;
-}
+    SDL_DestroyMutex(data.swaplock);
+    data.swaplock = NULL;
+}}
 
 /* This function assumes that it's called from within an autorelease pool */
 NSImage *
@@ -223,7 +233,7 @@ Cocoa_CreateImage(SDL_Surface * surface)
         return nil;
     }
 
-    imgrep = [[[NSBitmapImageRep alloc] initWithBitmapDataPlanes: NULL
+    imgrep = [[NSBitmapImageRep alloc] initWithBitmapDataPlanes: NULL
                     pixelsWide: converted->w
                     pixelsHigh: converted->h
                     bitsPerSample: 8
@@ -232,7 +242,7 @@ Cocoa_CreateImage(SDL_Surface * surface)
                     isPlanar: NO
                     colorSpaceName: NSDeviceRGBColorSpace
                     bytesPerRow: converted->pitch
-                    bitsPerPixel: converted->format->BitsPerPixel] autorelease];
+                    bitsPerPixel: converted->format->BitsPerPixel];
     if (imgrep == nil) {
         SDL_FreeSurface(converted);
         return nil;
@@ -252,7 +262,7 @@ Cocoa_CreateImage(SDL_Surface * surface)
         pixels += 4;
     }
 
-    img = [[[NSImage alloc] initWithSize: NSMakeSize(surface->w, surface->h)] autorelease];
+    img = [[NSImage alloc] initWithSize: NSMakeSize(surface->w, surface->h)];
     if (img != nil) {
         [img addRepresentation: imgrep];
     }
@@ -269,11 +279,16 @@ Cocoa_CreateImage(SDL_Surface * surface)
  *  versions remain identical!
  */
 
-void SDL_NSLog(const char *text)
+void SDL_NSLog(const char *prefix, const char *text)
 {
     @autoreleasepool {
-        NSString *str = [NSString stringWithUTF8String:text];
-        NSLog(@"%@", str);
+        NSString *nsText = [NSString stringWithUTF8String:text];
+        if (prefix) {
+            NSString *nsPrefix = [NSString stringWithUTF8String:prefix];
+            NSLog(@"%@: %@", nsPrefix, nsText);
+        } else {
+            NSLog(@"%@", nsText);
+        }
     }
 }
 
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoawindow.h b/Engine/lib/sdl/src/video/cocoa/SDL_cocoawindow.h
index a42d9c87b..61324550a 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoawindow.h
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoawindow.h
@@ -29,7 +29,7 @@
 #include "../SDL_egl_c.h"
 #endif
 
-typedef struct SDL_WindowData SDL_WindowData;
+@class SDL_WindowData;
 
 typedef enum
 {
@@ -40,7 +40,10 @@ typedef enum
 } PendingWindowOperation;
 
 @interface Cocoa_WindowListener : NSResponder <NSWindowDelegate> {
-    SDL_WindowData *_data;
+    /* SDL_WindowData owns this Listener and has a strong reference to it.
+     * To avoid reference cycles, we could have either a weak or an
+     * unretained ref to the WindowData. */
+    __weak SDL_WindowData *_data;
     BOOL observingVisible;
     BOOL wasCtrlLeft;
     BOOL wasVisible;
@@ -114,22 +117,22 @@ typedef enum
 /* *INDENT-ON* */
 
 @class SDLOpenGLContext;
+@class SDL_VideoData;
 
-struct SDL_WindowData
-{
-    SDL_Window *window;
-    NSWindow *nswindow;
-    NSView *sdlContentView;
-    NSMutableArray *nscontexts;
-    SDL_bool created;
-    SDL_bool inWindowFullscreenTransition;
-    NSInteger flash_request;
-    Cocoa_WindowListener *listener;
-    struct SDL_VideoData *videodata;
+@interface SDL_WindowData : NSObject
+    @property (nonatomic) SDL_Window *window;
+    @property (nonatomic) NSWindow *nswindow;
+    @property (nonatomic) NSView *sdlContentView;
+    @property (nonatomic) NSMutableArray *nscontexts;
+    @property (nonatomic) SDL_bool created;
+    @property (nonatomic) SDL_bool inWindowFullscreenTransition;
+    @property (nonatomic) NSInteger flash_request;
+    @property (nonatomic) Cocoa_WindowListener *listener;
+    @property (nonatomic) SDL_VideoData *videodata;
 #if SDL_VIDEO_OPENGL_EGL
-    EGLSurface egl_surface;
+    @property (nonatomic) EGLSurface egl_surface;
 #endif
-};
+@end
 
 extern int Cocoa_CreateWindow(_THIS, SDL_Window * window);
 extern int Cocoa_CreateWindowFrom(_THIS, SDL_Window * window,
@@ -153,6 +156,7 @@ extern void Cocoa_SetWindowAlwaysOnTop(_THIS, SDL_Window * window, SDL_bool on_t
 extern void Cocoa_SetWindowFullscreen(_THIS, SDL_Window * window, SDL_VideoDisplay * display, SDL_bool fullscreen);
 extern int Cocoa_SetWindowGammaRamp(_THIS, SDL_Window * window, const Uint16 * ramp);
 extern void* Cocoa_GetWindowICCProfile(_THIS, SDL_Window * window, size_t * size);
+extern int Cocoa_GetWindowDisplayIndex(_THIS, SDL_Window * window);
 extern int Cocoa_GetWindowGammaRamp(_THIS, SDL_Window * window, Uint16 * ramp);
 extern void Cocoa_SetWindowMouseRect(_THIS, SDL_Window * window);
 extern void Cocoa_SetWindowMouseGrab(_THIS, SDL_Window * window, SDL_bool grabbed);
diff --git a/Engine/lib/sdl/src/video/cocoa/SDL_cocoawindow.m b/Engine/lib/sdl/src/video/cocoa/SDL_cocoawindow.m
index bca8eb4dd..44e91440c 100644
--- a/Engine/lib/sdl/src/video/cocoa/SDL_cocoawindow.m
+++ b/Engine/lib/sdl/src/video/cocoa/SDL_cocoawindow.m
@@ -62,6 +62,10 @@
 #define NSAppKitVersionNumber10_14      1671
 #endif
 
+@implementation SDL_WindowData
+
+@end
+
 @interface NSWindow (SDL)
 #if MAC_OS_X_VERSION_MAX_ALLOWED < 101000 /* Added in the 10.10 SDK */
 @property (readonly) NSRect contentLayoutRect;
@@ -227,7 +231,7 @@
     /* !!! FIXME: is there a better way to do this? */
     if (_this) {
         for (sdlwindow = _this->windows; sdlwindow; sdlwindow = sdlwindow->next) {
-            NSWindow *nswindow = ((SDL_WindowData *) sdlwindow->driverdata)->nswindow;
+            NSWindow *nswindow = ((__bridge SDL_WindowData *) sdlwindow->driverdata).nswindow;
             if (nswindow == self) {
                 break;
             }
@@ -250,7 +254,7 @@ static void ConvertNSRect(NSScreen *screen, BOOL fullscreen, NSRect *r)
 static void
 ScheduleContextUpdates(SDL_WindowData *data)
 {
-    if (!data || !data->nscontexts) {
+    if (!data || !data.nscontexts) {
         return;
     }
 
@@ -261,7 +265,7 @@ ScheduleContextUpdates(SDL_WindowData *data)
     #endif
 
     NSOpenGLContext *currentContext = [NSOpenGLContext currentContext];
-    NSMutableArray *contexts = data->nscontexts;
+    NSMutableArray *contexts = data.nscontexts;
     @synchronized (contexts) {
         for (SDLOpenGLContext *context in contexts) {
             if (context == currentContext) {
@@ -316,19 +320,19 @@ GetWindowStyle(SDL_Window * window)
 static SDL_bool
 SetWindowStyle(SDL_Window * window, NSUInteger style)
 {
-    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
-    NSWindow *nswindow = data->nswindow;
+    SDL_WindowData *data = (__bridge SDL_WindowData *) window->driverdata;
+    NSWindow *nswindow = data.nswindow;
 
     /* The view responder chain gets messed with during setStyleMask */
-    if ([data->sdlContentView nextResponder] == data->listener) {
-        [data->sdlContentView setNextResponder:nil];
+    if ([data.sdlContentView nextResponder] == data.listener) {
+        [data.sdlContentView setNextResponder:nil];
     }
 
     [nswindow setStyleMask:style];
 
     /* The view responder chain gets messed with during setStyleMask */
-    if ([data->sdlContentView nextResponder] != data->listener) {
-        [data->sdlContentView setNextResponder:data->listener];
+    if ([data.sdlContentView nextResponder] != data.listener) {
+        [data.sdlContentView setNextResponder:data.listener];
     }
 
     return SDL_TRUE;
@@ -337,9 +341,9 @@ SetWindowStyle(SDL_Window * window, NSUInteger style)
 static SDL_bool
 ShouldAdjustCoordinatesForGrab(SDL_Window * window)
 {
-    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
+    SDL_WindowData *data = (__bridge SDL_WindowData *) window->driverdata;
 
-    if (!data || [data->listener isMovingOrFocusClickPending]) {
+    if (!data || [data.listener isMovingOrFocusClickPending]) {
         return SDL_FALSE;
     }
 
@@ -396,10 +400,10 @@ AdjustCoordinatesForGrab(SDL_Window * window, int x, int y, CGPoint *adjusted)
 static void
 Cocoa_UpdateClipCursor(SDL_Window * window)
 {
-    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
+    SDL_WindowData *data = (__bridge SDL_WindowData *) window->driverdata;
 
     if (NSAppKitVersionNumber >= NSAppKitVersionNumber10_13_2) {
-        NSWindow *nswindow = data->nswindow;
+        NSWindow *nswindow = data.nswindow;
         SDL_Rect mouse_rect;
 
         SDL_zero(mouse_rect);
@@ -453,8 +457,8 @@ Cocoa_UpdateClipCursor(SDL_Window * window)
 - (void)listen:(SDL_WindowData *)data
 {
     NSNotificationCenter *center;
-    NSWindow *window = data->nswindow;
-    NSView *view = data->sdlContentView;
+    NSWindow *window = data.nswindow;
+    NSView *view = data.sdlContentView;
 
     _data = data;
     observingVisible = YES;
@@ -515,12 +519,12 @@ Cocoa_UpdateClipCursor(SDL_Window * window)
         return;
     }
 
-    if (object == _data->nswindow && [keyPath isEqualToString:@"visible"]) {
+    if (object == _data.nswindow && [keyPath isEqualToString:@"visible"]) {
         int newVisibility = [[change objectForKey:@"new"] intValue];
         if (newVisibility) {
-            SDL_SendWindowEvent(_data->window, SDL_WINDOWEVENT_SHOWN, 0, 0);
+            SDL_SendWindowEvent(_data.window, SDL_WINDOWEVENT_SHOWN, 0, 0);
         } else {
-            SDL_SendWindowEvent(_data->window, SDL_WINDOWEVENT_HIDDEN, 0, 0);
+            SDL_SendWindowEvent(_data.window, SDL_WINDOWEVENT_HIDDEN, 0, 0);
         }
     }
 }
@@ -528,18 +532,18 @@ Cocoa_UpdateClipCursor(SDL_Window * window)
 -(void) pauseVisibleObservation
 {
     observingVisible = NO;
-    wasVisible = [_data->nswindow isVisible];
+    wasVisible = [_data.nswindow isVisible];
 }
 
 -(void) resumeVisibleObservation
 {
-    BOOL isVisible = [_data->nswindow isVisible];
+    BOOL isVisible = [_data.nswindow isVisible];
     observingVisible = YES;
     if (wasVisible != isVisible) {
         if (isVisible) {
-            SDL_SendWindowEvent(_data->window, SDL_WINDOWEVENT_SHOWN, 0, 0);
+            SDL_SendWindowEvent(_data.window, SDL_WINDOWEVENT_SHOWN, 0, 0);
         } else {
-            SDL_SendWindowEvent(_data->window, SDL_WINDOWEVENT_HIDDEN, 0, 0);
+            SDL_SendWindowEvent(_data.window, SDL_WINDOWEVENT_HIDDEN, 0, 0);
         }
 
         wasVisible = isVisible;
@@ -548,11 +552,11 @@ Cocoa_UpdateClipCursor(SDL_Window * window)
 
 -(BOOL) setFullscreenSpace:(BOOL) state
 {
-    SDL_Window *window = _data->window;
-    NSWindow *nswindow = _data->nswindow;
-    SDL_VideoData *videodata = ((SDL_WindowData *) window->driverdata)->videodata;
+    SDL_Window *window = _data.window;
+    NSWindow *nswindow = _data.nswindow;
+    SDL_VideoData *videodata = ((__bridge SDL_WindowData *) window->driverdata).videodata;
 
-    if (!videodata->allow_spaces) {
+    if (!videodata.allow_spaces) {
         return NO;  /* Spaces are forcibly disabled. */
     } else if (state && ((window->flags & SDL_WINDOW_FULLSCREEN_DESKTOP) != SDL_WINDOW_FULLSCREEN_DESKTOP)) {
         return NO;  /* we only allow you to make a Space on FULLSCREEN_DESKTOP windows. */
@@ -596,7 +600,7 @@ Cocoa_UpdateClipCursor(SDL_Window * window)
 - (void)close
 {
     NSNotificationCenter *center;
-    NSWindow *window = _data->nswindow;
+    NSWindow *window = _data.nswindow;
     NSView *view = [window contentView];
 
     center = [NSNotificationCenter defaultCenter];
@@ -678,15 +682,15 @@ Cocoa_UpdateClipCursor(SDL_Window * window)
             mouse->WarpMouseGlobal(pendingWindowWarpX, pendingWindowWarpY);
             pendingWindowWarpX = pendingWindowWarpY = INT_MAX;
         }
-        if (mouse->relative_mode && !mouse->relative_mode_warp && mouse->focus == _data->window) {
+        if (mouse->relative_mode && !mouse->relative_mode_warp && mouse->focus == _data.window) {
             /* Move the cursor to the nearest point in the window */
             {
                 int x, y;
                 CGPoint cgpoint;
 
                 SDL_GetMouseState(&x, &y);
-                cgpoint.x = _data->window->x + x;
-                cgpoint.y = _data->window->y + y;
+                cgpoint.x = _data.window->x + x;
+                cgpoint.y = _data.window->y + y;
 
                 Cocoa_HandleMouseWarp(cgpoint.x, cgpoint.y);
 
@@ -696,25 +700,25 @@ Cocoa_UpdateClipCursor(SDL_Window * window)
 
             mouse->SetRelativeMouseMode(SDL_TRUE);
         } else {
-            Cocoa_UpdateClipCursor(_data->window);
+            Cocoa_UpdateClipCursor(_data.window);
         }
     }
 }
 
 - (BOOL)windowShouldClose:(id)sender
 {
-    SDL_SendWindowEvent(_data->window, SDL_WINDOWEVENT_CLOSE, 0, 0);
+    SDL_SendWindowEvent(_data.window, SDL_WINDOWEVENT_CLOSE, 0, 0);
     return NO;
 }
 
 - (void)windowDidExpose:(NSNotification *)aNotification
 {
-    SDL_SendWindowEvent(_data->window, SDL_WINDOWEVENT_EXPOSED, 0, 0);
+    SDL_SendWindowEvent(_data.window, SDL_WINDOWEVENT_EXPOSED, 0, 0);
 }
 
 - (void)windowWillMove:(NSNotification *)aNotification
 {
-    if ([_data->nswindow isKindOfClass:[SDLWindow class]]) {
+    if ([_data.nswindow isKindOfClass:[SDLWindow class]]) {
         pendingWindowWarpX = pendingWindowWarpY = INT_MAX;
         isMoving = YES;
     }
@@ -723,8 +727,8 @@ Cocoa_UpdateClipCursor(SDL_Window * window)
 - (void)windowDidMove:(NSNotification *)aNotification
 {
     int x, y;
-    SDL_Window *window = _data->window;
-    NSWindow *nswindow = _data->nswindow;
+    SDL_Window *window = _data.window;
+    NSWindow *nswindow = _data.nswindow;
     BOOL fullscreen = window->flags & FULLSCREEN_MASK;
     NSRect rect = [nswindow contentRectForFrameRect:[nswindow frame]];
     ConvertNSRect([nswindow screen], fullscreen, &rect);
@@ -764,8 +768,8 @@ Cocoa_UpdateClipCursor(SDL_Window * window)
         return;
     }
 
-    SDL_Window *window = _data->window;
-    NSWindow *nswindow = _data->nswindow;
+    SDL_Window *window = _data.window;
+    NSWindow *nswindow = _data.nswindow;
     int x, y, w, h;
     NSRect rect = [nswindow contentRectForFrameRect:[nswindow frame]];
     ConvertNSRect([nswindow screen], (window->flags & FULLSCREEN_MASK), &rect);
@@ -799,17 +803,17 @@ Cocoa_UpdateClipCursor(SDL_Window * window)
         focusClickPending = 0;
         [self onMovingOrFocusClickPendingStateCleared];
     }
-    SDL_SendWindowEvent(_data->window, SDL_WINDOWEVENT_MINIMIZED, 0, 0);
+    SDL_SendWindowEvent(_data.window, SDL_WINDOWEVENT_MINIMIZED, 0, 0);
 }
 
 - (void)windowDidDeminiaturize:(NSNotification *)aNotification
 {
-    SDL_SendWindowEvent(_data->window, SDL_WINDOWEVENT_RESTORED, 0, 0);
+    SDL_SendWindowEvent(_data.window, SDL_WINDOWEVENT_RESTORED, 0, 0);
 }
 
 - (void)windowDidBecomeKey:(NSNotification *)aNotification
 {
-    SDL_Window *window = _data->window;
+    SDL_Window *window = _data.window;
     SDL_Mouse *mouse = SDL_GetMouse();
 
     /* We're going to get keyboard events, since we're key. */
@@ -825,7 +829,7 @@ Cocoa_UpdateClipCursor(SDL_Window * window)
         NSPoint point;
         int x, y;
 
-        point = [_data->nswindow mouseLocationOutsideOfEventStream];
+        point = [_data.nswindow mouseLocationOutsideOfEventStream];
         x = (int)point.x;
         y = (int)(window->h - point.y);
 
@@ -835,14 +839,14 @@ Cocoa_UpdateClipCursor(SDL_Window * window)
     }
 
     /* Check to see if someone updated the clipboard */
-    Cocoa_CheckClipboardUpdate(_data->videodata);
+    Cocoa_CheckClipboardUpdate(_data.videodata);
 
     if ((isFullscreenSpace) && ((window->flags & SDL_WINDOW_FULLSCREEN_DESKTOP) == SDL_WINDOW_FULLSCREEN_DESKTOP)) {
         [NSMenu setMenuBarVisible:NO];
     }
 
     const unsigned int newflags = [NSEvent modifierFlags] & NSEventModifierFlagCapsLock;
-    _data->videodata->modifierFlags = (_data->videodata->modifierFlags & ~NSEventModifierFlagCapsLock) | newflags;
+    _data.videodata.modifierFlags = (_data.videodata.modifierFlags & ~NSEventModifierFlagCapsLock) | newflags;
     SDL_ToggleModState(KMOD_CAPS, newflags != 0);
 }
 
@@ -854,12 +858,12 @@ Cocoa_UpdateClipCursor(SDL_Window * window)
     }
 
     /* Some other window will get mouse events, since we're not key. */
-    if (SDL_GetMouseFocus() == _data->window) {
+    if (SDL_GetMouseFocus() == _data.window) {
         SDL_SetMouseFocus(NULL);
     }
 
     /* Some other window will get keyboard events, since we're not key. */
-    if (SDL_GetKeyboardFocus() == _data->window) {
+    if (SDL_GetKeyboardFocus() == _data.window) {
         SDL_SetKeyboardFocus(NULL);
     }
 
@@ -876,22 +880,22 @@ Cocoa_UpdateClipCursor(SDL_Window * window)
         return;
     }
 
-    if ([oldscale doubleValue] != [_data->nswindow backingScaleFactor]) {
+    if ([oldscale doubleValue] != [_data.nswindow backingScaleFactor]) {
         /* Force a resize event when the backing scale factor changes. */
-        _data->window->w = 0;
-        _data->window->h = 0;
+        _data.window->w = 0;
+        _data.window->h = 0;
         [self windowDidResize:aNotification];
     }
 }
 
 - (void)windowDidChangeScreenProfile:(NSNotification *)aNotification
 {
-    SDL_SendWindowEvent(_data->window, SDL_WINDOWEVENT_ICCPROF_CHANGED, 0, 0);
+    SDL_SendWindowEvent(_data.window, SDL_WINDOWEVENT_ICCPROF_CHANGED, 0, 0);
 }
 
 - (void)windowWillEnterFullScreen:(NSNotification *)aNotification
 {
-    SDL_Window *window = _data->window;
+    SDL_Window *window = _data.window;
 
     SetWindowStyle(window, (NSWindowStyleMaskTitled|NSWindowStyleMaskClosable|NSWindowStyleMaskMiniaturizable|NSWindowStyleMaskResizable));
 
@@ -901,7 +905,7 @@ Cocoa_UpdateClipCursor(SDL_Window * window)
 
 - (void)windowDidFailToEnterFullScreen:(NSNotification *)aNotification
 {
-    SDL_Window *window = _data->window;
+    SDL_Window *window = _data.window;
 
     if (window->is_destroying) {
         return;
@@ -917,9 +921,9 @@ Cocoa_UpdateClipCursor(SDL_Window * window)
 
 - (void)windowDidEnterFullScreen:(NSNotification *)aNotification
 {
-    SDL_Window *window = _data->window;
-    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
-    NSWindow *nswindow = data->nswindow;
+    SDL_Window *window = _data.window;
+    SDL_WindowData *data = (__bridge SDL_WindowData *) window->driverdata;
+    NSWindow *nswindow = data.nswindow;
 
     inFullscreenTransition = NO;
 
@@ -949,7 +953,7 @@ Cocoa_UpdateClipCursor(SDL_Window * window)
 
 - (void)windowWillExitFullScreen:(NSNotification *)aNotification
 {
-    SDL_Window *window = _data->window;
+    SDL_Window *window = _data.window;
 
     isFullscreenSpace = NO;
     inFullscreenTransition = YES;
@@ -967,7 +971,7 @@ Cocoa_UpdateClipCursor(SDL_Window * window)
 
 - (void)windowDidFailToExitFullScreen:(NSNotification *)aNotification
 {
-    SDL_Window *window = _data->window;
+    SDL_Window *window = _data.window;
     
     if (window->is_destroying) {
         return;
@@ -983,8 +987,8 @@ Cocoa_UpdateClipCursor(SDL_Window * window)
 
 - (void)windowDidExitFullScreen:(NSNotification *)aNotification
 {
-    SDL_Window *window = _data->window;
-    NSWindow *nswindow = _data->nswindow;
+    SDL_Window *window = _data.window;
+    NSWindow *nswindow = _data.nswindow;
     NSButton *button = nil;
 
     inFullscreenTransition = NO;
@@ -1077,7 +1081,7 @@ Cocoa_UpdateClipCursor(SDL_Window * window)
 
 -(NSApplicationPresentationOptions)window:(NSWindow *)window willUseFullScreenPresentationOptions:(NSApplicationPresentationOptions)proposedOptions
 {
-    if ((_data->window->flags & SDL_WINDOW_FULLSCREEN_DESKTOP) == SDL_WINDOW_FULLSCREEN_DESKTOP) {
+    if ((_data.window->flags & SDL_WINDOW_FULLSCREEN_DESKTOP) == SDL_WINDOW_FULLSCREEN_DESKTOP) {
         return NSApplicationPresentationFullScreen | NSApplicationPresentationHideDock | NSApplicationPresentationHideMenuBar;
     } else {
         return proposedOptions;
@@ -1127,16 +1131,16 @@ Cocoa_UpdateClipCursor(SDL_Window * window)
 
 - (BOOL)processHitTest:(NSEvent *)theEvent
 {
-    SDL_assert(isDragAreaRunning == [_data->nswindow isMovableByWindowBackground]);
+    SDL_assert(isDragAreaRunning == [_data.nswindow isMovableByWindowBackground]);
 
-    if (_data->window->hit_test) {  /* if no hit-test, skip this. */
+    if (_data.window->hit_test) {  /* if no hit-test, skip this. */
         const NSPoint location = [theEvent locationInWindow];
-        const SDL_Point point = { (int) location.x, _data->window->h - (((int) location.y)-1) };
-        const SDL_HitTestResult rc = _data->window->hit_test(_data->window, &point, _data->window->hit_test_data);
+        const SDL_Point point = { (int) location.x, _data.window->h - (((int) location.y)-1) };
+        const SDL_HitTestResult rc = _data.window->hit_test(_data.window, &point, _data.window->hit_test_data);
         if (rc == SDL_HITTEST_DRAGGABLE) {
             if (!isDragAreaRunning) {
                 isDragAreaRunning = YES;
-                [_data->nswindow setMovableByWindowBackground:YES];
+                [_data.nswindow setMovableByWindowBackground:YES];
             }
             return YES;  /* dragging! */
         }
@@ -1144,7 +1148,7 @@ Cocoa_UpdateClipCursor(SDL_Window * window)
 
     if (isDragAreaRunning) {
         isDragAreaRunning = NO;
-        [_data->nswindow setMovableByWindowBackground:NO];
+        [_data.nswindow setMovableByWindowBackground:NO];
         return YES;  /* was dragging, drop event. */
     }
 
@@ -1164,7 +1168,7 @@ Cocoa_SendMouseButtonClicks(SDL_Mouse * mouse, NSEvent *theEvent, SDL_Window * w
     //  the position in the currently-focused window. We don't (currently) send a mousemove
     //  event for the background window, this just makes sure the button is reported at the
     //  correct position in its own event.
-    if ( focus && ([theEvent window] == ((SDL_WindowData *) focus->driverdata)->nswindow) ) {
+    if ( focus && ([theEvent window] == ((__bridge SDL_WindowData *) focus->driverdata).nswindow) ) {
         rc = SDL_SendMouseButtonClicks(window, mouseID, state, button, clicks);
     } else {
         const int orig_x = mouse->x;
@@ -1198,7 +1202,7 @@ Cocoa_SendMouseButtonClicks(SDL_Mouse * mouse, NSEvent *theEvent, SDL_Window * w
     }
 
     if ([self processHitTest:theEvent]) {
-        SDL_SendWindowEvent(_data->window, SDL_WINDOWEVENT_HIT_TEST, 0, 0);
+        SDL_SendWindowEvent(_data.window, SDL_WINDOWEVENT_HIT_TEST, 0, 0);
         return;  /* dragging, drop event. */
     }
 
@@ -1224,7 +1228,7 @@ Cocoa_SendMouseButtonClicks(SDL_Mouse * mouse, NSEvent *theEvent, SDL_Window * w
         break;
     }
 
-    Cocoa_SendMouseButtonClicks(mouse, theEvent, _data->window, SDL_PRESSED, button);
+    Cocoa_SendMouseButtonClicks(mouse, theEvent, _data.window, SDL_PRESSED, button);
 }
 
 - (void)rightMouseDown:(NSEvent *)theEvent
@@ -1247,7 +1251,7 @@ Cocoa_SendMouseButtonClicks(SDL_Mouse * mouse, NSEvent *theEvent, SDL_Window * w
     int button;
 
     if ([self processHitTest:theEvent]) {
-        SDL_SendWindowEvent(_data->window, SDL_WINDOWEVENT_HIT_TEST, 0, 0);
+        SDL_SendWindowEvent(_data.window, SDL_WINDOWEVENT_HIT_TEST, 0, 0);
         return;  /* stopped dragging, drop event. */
     }
 
@@ -1271,7 +1275,7 @@ Cocoa_SendMouseButtonClicks(SDL_Mouse * mouse, NSEvent *theEvent, SDL_Window * w
         break;
     }
 
-    Cocoa_SendMouseButtonClicks(mouse, theEvent, _data->window, SDL_RELEASED, button);
+    Cocoa_SendMouseButtonClicks(mouse, theEvent, _data.window, SDL_RELEASED, button);
 }
 
 - (void)rightMouseUp:(NSEvent *)theEvent
@@ -1292,7 +1296,7 @@ Cocoa_SendMouseButtonClicks(SDL_Mouse * mouse, NSEvent *theEvent, SDL_Window * w
     }
 
     const SDL_MouseID mouseID = mouse->mouseID;
-    SDL_Window *window = _data->window;
+    SDL_Window *window = _data.window;
     NSPoint point;
     int x, y;
 
@@ -1341,7 +1345,7 @@ Cocoa_SendMouseButtonClicks(SDL_Mouse * mouse, NSEvent *theEvent, SDL_Window * w
 
 - (void)scrollWheel:(NSEvent *)theEvent
 {
-    Cocoa_HandleMouseWheel(_data->window, theEvent);
+    Cocoa_HandleMouseWheel(_data.window, theEvent);
 }
 
 - (void)touchesBeganWithEvent:(NSEvent *) theEvent
@@ -1531,7 +1535,7 @@ Cocoa_SendMouseButtonClicks(SDL_Mouse * mouse, NSEvent *theEvent, SDL_Window * w
        white until the app is ready to draw. In practice on modern macOS, this
        only gets called for window creation and other extraordinary events. */
     self.layer.backgroundColor = CGColorGetConstantColor(kCGColorBlack);
-    ScheduleContextUpdates((SDL_WindowData *) _sdlWindow->driverdata);
+    ScheduleContextUpdates((__bridge SDL_WindowData *) _sdlWindow->driverdata);
     SDL_SendWindowEvent(_sdlWindow, SDL_WINDOWEVENT_EXPOSED, 0, 0);
 }
 
@@ -1555,7 +1559,7 @@ Cocoa_SendMouseButtonClicks(SDL_Mouse * mouse, NSEvent *theEvent, SDL_Window * w
 
     if (mouse->cursor_shown && mouse->cur_cursor && !mouse->relative_mode) {
         [self addCursorRect:[self bounds]
-                     cursor:mouse->cur_cursor->driverdata];
+                     cursor:(__bridge NSCursor *)mouse->cur_cursor->driverdata];
     } else {
         [self addCursorRect:[self bounds]
                      cursor:[NSCursor invisibleCursor]];
@@ -1576,23 +1580,23 @@ static int
 SetupWindowData(_THIS, SDL_Window * window, NSWindow *nswindow, NSView *nsview, SDL_bool created)
 { @autoreleasepool
 {
-    SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;
+    SDL_VideoData *videodata = (__bridge SDL_VideoData *) _this->driverdata;
     SDL_WindowData *data;
 
     /* Allocate the window data */
-    window->driverdata = data = (SDL_WindowData *) SDL_calloc(1, sizeof(*data));
+    data = [[SDL_WindowData alloc] init];
     if (!data) {
         return SDL_OutOfMemory();
     }
-    data->window = window;
-    data->nswindow = nswindow;
-    data->created = created;
-    data->videodata = videodata;
-    data->nscontexts = [[NSMutableArray alloc] init];
-    data->sdlContentView = nsview;
+    data.window = window;
+    data.nswindow = nswindow;
+    data.created = created;
+    data.videodata = videodata;
+    data.nscontexts = [[NSMutableArray alloc] init];
+    data.sdlContentView = nsview;
 
     /* Create an event listener for the window */
-    data->listener = [[Cocoa_WindowListener alloc] init];
+    data.listener = [[Cocoa_WindowListener alloc] init];
 
     /* Fill in the SDL window with the window data */
     {
@@ -1605,7 +1609,7 @@ SetupWindowData(_THIS, SDL_Window * window, NSWindow *nswindow, NSView *nsview,
     }
 
     /* Set up the listener after we create the view */
-    [data->listener listen:data];
+    [data.listener listen:data];
 
     if ([nswindow isVisible]) {
         window->flags |= SDL_WINDOW_SHOWN;
@@ -1646,16 +1650,22 @@ SetupWindowData(_THIS, SDL_Window * window, NSWindow *nswindow, NSView *nsview,
 
     if ([nswindow isKeyWindow]) {
         window->flags |= SDL_WINDOW_INPUT_FOCUS;
-        SDL_SetKeyboardFocus(data->window);
+        SDL_SetKeyboardFocus(data.window);
     }
 
+    /* SDL_WindowData will be holding a strong reference to the NSWindow, and
+     * it will also call [NSWindow close] in DestroyWindow before releasing the
+     * NSWindow, so the extra release provided by releasedWhenClosed isn't
+     * necessary. */
+    nswindow.releasedWhenClosed = NO;
+
     /* Prevents the window's "window device" from being destroyed when it is
      * hidden. See http://www.mikeash.com/pyblog/nsopenglcontext-and-one-shot.html
      */
     [nswindow setOneShot:NO];
 
     /* All done! */
-    window->driverdata = data;
+    window->driverdata = (void *)CFBridgingRetain(data);
     return 0;
 }}
 
@@ -1663,7 +1673,7 @@ int
 Cocoa_CreateWindow(_THIS, SDL_Window * window)
 { @autoreleasepool
 {
-    SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;
+    SDL_VideoData *videodata = (__bridge SDL_VideoData *) _this->driverdata;
     NSWindow *nswindow;
     SDL_VideoDisplay *display = SDL_GetDisplayForWindow(window);
     NSRect rect;
@@ -1708,9 +1718,7 @@ Cocoa_CreateWindow(_THIS, SDL_Window * window)
     }
 #endif
 
-    if (videodata->allow_spaces) {
-        SDL_assert(floor(NSAppKitVersionNumber) > NSAppKitVersionNumber10_6);
-        SDL_assert([nswindow respondsToSelector:@selector(toggleFullScreen:)]);
+    if (videodata.allow_spaces) {
         /* we put FULLSCREEN_DESKTOP windows in their own Space, without a toggle button or menubar, later */
         if (window->flags & SDL_WINDOW_RESIZABLE) {
             /* resizable windows are Spaces-friendly: they get the "go fullscreen" toggle button on their titlebar. */
@@ -1734,10 +1742,8 @@ Cocoa_CreateWindow(_THIS, SDL_Window * window)
     #endif
     /* Note: as of the macOS 10.15 SDK, this defaults to YES instead of NO when
      * the NSHighResolutionCapable boolean is set in Info.plist. */
-    if ([contentView respondsToSelector:@selector(setWantsBestResolutionOpenGLSurface:)]) {
-        BOOL highdpi = (window->flags & SDL_WINDOW_ALLOW_HIGHDPI) != 0;
-        [contentView setWantsBestResolutionOpenGLSurface:highdpi];
-    }
+    BOOL highdpi = (window->flags & SDL_WINDOW_ALLOW_HIGHDPI) != 0;
+    [contentView setWantsBestResolutionOpenGLSurface:highdpi];
     #ifdef __clang__
     #pragma clang diagnostic pop
     #endif
@@ -1751,10 +1757,8 @@ Cocoa_CreateWindow(_THIS, SDL_Window * window)
 #endif /* SDL_VIDEO_OPENGL_EGL */
 #endif /* SDL_VIDEO_OPENGL_ES2 */
     [nswindow setContentView:contentView];
-    [contentView release];
 
     if (SetupWindowData(_this, window, nswindow, contentView, SDL_TRUE) < 0) {
-        [nswindow release];
         return -1;
     }
 
@@ -1786,11 +1790,11 @@ Cocoa_CreateWindowFrom(_THIS, SDL_Window * window, const void *data)
     NSView* nsview = nil;
     NSWindow *nswindow = nil;
 
-    if ([(id)data isKindOfClass:[NSWindow class]]) {
-      nswindow = (NSWindow*)data;
+    if ([(__bridge id)data isKindOfClass:[NSWindow class]]) {
+      nswindow = (__bridge NSWindow*)data;
       nsview = [nswindow contentView];
-    } else if ([(id)data isKindOfClass:[NSView class]]) {
-      nsview = (NSView*)data;
+    } else if ([(__bridge id)data isKindOfClass:[NSView class]]) {
+      nsview = (__bridge NSView*)data;
       nswindow = [nsview window];
     } else {
       SDL_assert(false);
@@ -1811,10 +1815,8 @@ Cocoa_CreateWindowFrom(_THIS, SDL_Window * window, const void *data)
     #endif
     /* Note: as of the macOS 10.15 SDK, this defaults to YES instead of NO when
      * the NSHighResolutionCapable boolean is set in Info.plist. */
-    if ([nsview respondsToSelector:@selector(setWantsBestResolutionOpenGLSurface:)]) {
-        BOOL highdpi = (window->flags & SDL_WINDOW_ALLOW_HIGHDPI) != 0;
-        [nsview setWantsBestResolutionOpenGLSurface:highdpi];
-    }
+    BOOL highdpi = (window->flags & SDL_WINDOW_ALLOW_HIGHDPI) != 0;
+    [nsview setWantsBestResolutionOpenGLSurface:highdpi];
     #ifdef __clang__
     #pragma clang diagnostic pop
     #endif
@@ -1827,10 +1829,9 @@ Cocoa_SetWindowTitle(_THIS, SDL_Window * window)
 { @autoreleasepool
 {
     const char *title = window->title ? window->title : "";
-    NSWindow *nswindow = ((SDL_WindowData *) window->driverdata)->nswindow;
+    NSWindow *nswindow = ((__bridge SDL_WindowData *) window->driverdata).nswindow;
     NSString *string = [[NSString alloc] initWithUTF8String:title];
     [nswindow setTitle:string];
-    [string release];
 }}
 
 void
@@ -1848,8 +1849,8 @@ void
 Cocoa_SetWindowPosition(_THIS, SDL_Window * window)
 { @autoreleasepool
 {
-    SDL_WindowData *windata = (SDL_WindowData *) window->driverdata;
-    NSWindow *nswindow = windata->nswindow;
+    SDL_WindowData *windata = (__bridge SDL_WindowData *) window->driverdata;
+    NSWindow *nswindow = windata.nswindow;
     NSRect rect;
     Uint32 moveHack;
 
@@ -1871,8 +1872,8 @@ void
 Cocoa_SetWindowSize(_THIS, SDL_Window * window)
 { @autoreleasepool
 {
-    SDL_WindowData *windata = (SDL_WindowData *) window->driverdata;
-    NSWindow *nswindow = windata->nswindow;
+    SDL_WindowData *windata = (__bridge SDL_WindowData *) window->driverdata;
+    NSWindow *nswindow = windata.nswindow;
     NSRect rect;
     Uint32 moveHack;
 
@@ -1898,39 +1899,39 @@ void
 Cocoa_SetWindowMinimumSize(_THIS, SDL_Window * window)
 { @autoreleasepool
 {
-    SDL_WindowData *windata = (SDL_WindowData *) window->driverdata;
+    SDL_WindowData *windata = (__bridge SDL_WindowData *) window->driverdata;
 
     NSSize minSize;
     minSize.width = window->min_w;
     minSize.height = window->min_h;
 
-    [windata->nswindow setContentMinSize:minSize];
+    [windata.nswindow setContentMinSize:minSize];
 }}
 
 void
 Cocoa_SetWindowMaximumSize(_THIS, SDL_Window * window)
 { @autoreleasepool
 {
-    SDL_WindowData *windata = (SDL_WindowData *) window->driverdata;
+    SDL_WindowData *windata = (__bridge SDL_WindowData *) window->driverdata;
 
     NSSize maxSize;
     maxSize.width = window->max_w;
     maxSize.height = window->max_h;
 
-    [windata->nswindow setContentMaxSize:maxSize];
+    [windata.nswindow setContentMaxSize:maxSize];
 }}
 
 void
 Cocoa_ShowWindow(_THIS, SDL_Window * window)
 { @autoreleasepool
 {
-    SDL_WindowData *windowData = ((SDL_WindowData *) window->driverdata);
-    NSWindow *nswindow = windowData->nswindow;
+    SDL_WindowData *windowData = ((__bridge SDL_WindowData *) window->driverdata);
+    NSWindow *nswindow = windowData.nswindow;
 
     if (![nswindow isMiniaturized]) {
-        [windowData->listener pauseVisibleObservation];
+        [windowData.listener pauseVisibleObservation];
         [nswindow makeKeyAndOrderFront:nil];
-        [windowData->listener resumeVisibleObservation];
+        [windowData.listener resumeVisibleObservation];
     }
 }}
 
@@ -1938,7 +1939,7 @@ void
 Cocoa_HideWindow(_THIS, SDL_Window * window)
 { @autoreleasepool
 {
-    NSWindow *nswindow = ((SDL_WindowData *) window->driverdata)->nswindow;
+    NSWindow *nswindow = ((__bridge SDL_WindowData *) window->driverdata).nswindow;
 
     [nswindow orderOut:nil];
 }}
@@ -1947,26 +1948,26 @@ void
 Cocoa_RaiseWindow(_THIS, SDL_Window * window)
 { @autoreleasepool
 {
-    SDL_WindowData *windowData = ((SDL_WindowData *) window->driverdata);
-    NSWindow *nswindow = windowData->nswindow;
+    SDL_WindowData *windowData = ((__bridge SDL_WindowData *) window->driverdata);
+    NSWindow *nswindow = windowData.nswindow;
 
     /* makeKeyAndOrderFront: has the side-effect of deminiaturizing and showing
        a minimized or hidden window, so check for that before showing it.
      */
-    [windowData->listener pauseVisibleObservation];
+    [windowData.listener pauseVisibleObservation];
     if (![nswindow isMiniaturized] && [nswindow isVisible]) {
         [NSApp activateIgnoringOtherApps:YES];
         [nswindow makeKeyAndOrderFront:nil];
     }
-    [windowData->listener resumeVisibleObservation];
+    [windowData.listener resumeVisibleObservation];
 }}
 
 void
 Cocoa_MaximizeWindow(_THIS, SDL_Window * window)
 { @autoreleasepool
 {
-    SDL_WindowData *windata = (SDL_WindowData *) window->driverdata;
-    NSWindow *nswindow = windata->nswindow;
+    SDL_WindowData *windata = (__bridge SDL_WindowData *) window->driverdata;
+    NSWindow *nswindow = windata.nswindow;
 
     [nswindow zoom:nil];
 
@@ -1977,10 +1978,10 @@ void
 Cocoa_MinimizeWindow(_THIS, SDL_Window * window)
 { @autoreleasepool
 {
-    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
-    NSWindow *nswindow = data->nswindow;
-    if ([data->listener isInFullscreenSpaceTransition]) {
-        [data->listener addPendingWindowOperation:PENDING_OPERATION_MINIMIZE];
+    SDL_WindowData *data = (__bridge SDL_WindowData *) window->driverdata;
+    NSWindow *nswindow = data.nswindow;
+    if ([data.listener isInFullscreenSpaceTransition]) {
+        [data.listener addPendingWindowOperation:PENDING_OPERATION_MINIMIZE];
     } else {
         [nswindow miniaturize:nil];
     }
@@ -1990,7 +1991,7 @@ void
 Cocoa_RestoreWindow(_THIS, SDL_Window * window)
 { @autoreleasepool
 {
-    NSWindow *nswindow = ((SDL_WindowData *) window->driverdata)->nswindow;
+    NSWindow *nswindow = ((__bridge SDL_WindowData *) window->driverdata).nswindow;
 
     if ([nswindow isMiniaturized]) {
         [nswindow deminiaturize:nil];
@@ -2018,14 +2019,14 @@ Cocoa_SetWindowResizable(_THIS, SDL_Window * window, SDL_bool resizable)
      * The window will get permanently stuck if resizable is false.
      * -flibit
      */
-    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
-    Cocoa_WindowListener *listener = data->listener;
-    NSWindow *nswindow = data->nswindow;
-    SDL_VideoData *videodata = ((SDL_WindowData *) window->driverdata)->videodata;
+    SDL_WindowData *data = (__bridge SDL_WindowData *) window->driverdata;
+    Cocoa_WindowListener *listener = data.listener;
+    NSWindow *nswindow = data.nswindow;
+    SDL_VideoData *videodata = data.videodata;
     if (![listener isInFullscreenSpace]) {
         SetWindowStyle(window, GetWindowStyle(window));
     }
-    if (videodata->allow_spaces) {
+    if (videodata.allow_spaces) {
         if (resizable) {
             /* resizable windows are Spaces-friendly: they get the "go fullscreen" toggle button on their titlebar. */
             [nswindow setCollectionBehavior:NSWindowCollectionBehaviorFullScreenPrimary];
@@ -2039,7 +2040,7 @@ void
 Cocoa_SetWindowAlwaysOnTop(_THIS, SDL_Window * window, SDL_bool on_top)
 { @autoreleasepool
     {
-        NSWindow *nswindow = ((SDL_WindowData *) window->driverdata)->nswindow;
+        NSWindow *nswindow = ((__bridge SDL_WindowData *) window->driverdata).nswindow;
         if (on_top) {
             [nswindow setLevel:NSFloatingWindowLevel];
         } else {
@@ -2051,13 +2052,13 @@ void
 Cocoa_SetWindowFullscreen(_THIS, SDL_Window * window, SDL_VideoDisplay * display, SDL_bool fullscreen)
 { @autoreleasepool
 {
-    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
-    NSWindow *nswindow = data->nswindow;
+    SDL_WindowData *data = (__bridge SDL_WindowData *) window->driverdata;
+    NSWindow *nswindow = data.nswindow;
     NSRect rect;
 
     /* The view responder chain gets messed with during setStyleMask */
-    if ([data->sdlContentView nextResponder] == data->listener) {
-        [data->sdlContentView setNextResponder:nil];
+    if ([data.sdlContentView nextResponder] == data.listener) {
+        [data.sdlContentView setNextResponder:nil];
     }
 
     if (fullscreen) {
@@ -2103,8 +2104,8 @@ Cocoa_SetWindowFullscreen(_THIS, SDL_Window * window, SDL_VideoDisplay * display
     }
 
     /* The view responder chain gets messed with during setStyleMask */
-    if ([data->sdlContentView nextResponder] != data->listener) {
-        [data->sdlContentView setNextResponder:data->listener];
+    if ([data.sdlContentView nextResponder] != data.listener) {
+        [data.sdlContentView setNextResponder:data.listener];
     }
 
     s_moveHack = 0;
@@ -2127,9 +2128,9 @@ Cocoa_SetWindowFullscreen(_THIS, SDL_Window * window, SDL_VideoDisplay * display
     }
 
     if ([nswindow isVisible] || fullscreen) {
-        [data->listener pauseVisibleObservation];
+        [data.listener pauseVisibleObservation];
         [nswindow makeKeyAndOrderFront:nil];
-        [data->listener resumeVisibleObservation];
+        [data.listener resumeVisibleObservation];
     }
 
     ScheduleContextUpdates(data);
@@ -2137,6 +2138,7 @@ Cocoa_SetWindowFullscreen(_THIS, SDL_Window * window, SDL_VideoDisplay * display
 
 int
 Cocoa_SetWindowGammaRamp(_THIS, SDL_Window * window, const Uint16 * ramp)
+{ @autoreleasepool
 {
     SDL_VideoDisplay *display = SDL_GetDisplayForWindow(window);
     CGDirectDisplayID display_id = ((SDL_DisplayData *)display->driverdata)->display;
@@ -2159,13 +2161,14 @@ Cocoa_SetWindowGammaRamp(_THIS, SDL_Window * window, const Uint16 * ramp)
         return SDL_SetError("CGSetDisplayTransferByTable()");
     }
     return 0;
-}
+}}
 
 void*
 Cocoa_GetWindowICCProfile(_THIS, SDL_Window * window, size_t * size)
+{ @autoreleasepool
 {
-    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
-    NSWindow *nswindow = data->nswindow;
+    SDL_WindowData *data = (__bridge SDL_WindowData *) window->driverdata;
+    NSWindow *nswindow = data.nswindow;
     NSScreen *screen = [nswindow screen];
     NSData* iccProfileData = nil;
     void* retIccProfileData = NULL;
@@ -2195,7 +2198,40 @@ Cocoa_GetWindowICCProfile(_THIS, SDL_Window * window, size_t * size)
     [iccProfileData getBytes:retIccProfileData length:[iccProfileData length]];
     *size = [iccProfileData length];
     return retIccProfileData;
-}
+}}
+
+int
+Cocoa_GetWindowDisplayIndex(_THIS, SDL_Window * window)
+{ @autoreleasepool
+{
+    SDL_WindowData *data = (__bridge SDL_WindowData *) window->driverdata;
+
+    /* Not recognized via CHECK_WINDOW_MAGIC */
+    if (data == NULL){
+        return 0;
+    }
+
+    /*
+     Considering that we already have the display coordinates in which the window is placed (described via displayframe)
+     instead of checking in which display the window is placed, we should check which SDL display matches the display described
+     via displayframe.
+    */
+    NSRect displayframe = data.nswindow.screen.frame;
+    SDL_Point display_center;
+    SDL_Rect sdl_display_rect;
+    
+    display_center.x = displayframe.origin.x + displayframe.size.width / 2;
+    display_center.y = displayframe.origin.y + displayframe.size.height / 2;
+    
+    for (int i = 0; i < SDL_GetNumVideoDisplays(); i++){
+        SDL_GetDisplayBounds(i, &sdl_display_rect);
+        if (SDL_EnclosePoints(&display_center, 1, &sdl_display_rect, NULL)) {
+            return i;
+        }
+    }
+    SDL_SetError("Couldn't find the display where the window is attached to.");
+    return -1;
+}}
 
 int
 Cocoa_GetWindowGammaRamp(_THIS, SDL_Window * window, Uint16 * ramp)
@@ -2229,59 +2265,58 @@ Cocoa_SetWindowMouseRect(_THIS, SDL_Window * window)
 
 void
 Cocoa_SetWindowMouseGrab(_THIS, SDL_Window * window, SDL_bool grabbed)
+{ @autoreleasepool
 {
-    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
+    SDL_WindowData *data = (__bridge SDL_WindowData *) window->driverdata;
 
     Cocoa_UpdateClipCursor(window);
 
     if (data && (window->flags & SDL_WINDOW_FULLSCREEN)) {
         if (SDL_ShouldAllowTopmost() && (window->flags & SDL_WINDOW_INPUT_FOCUS)
-            && ![data->listener isInFullscreenSpace]) {
+            && ![data.listener isInFullscreenSpace]) {
             /* OpenGL is rendering to the window, so make it visible! */
             /* Doing this in 10.11 while in a Space breaks things (bug #3152) */
-            [data->nswindow setLevel:CGShieldingWindowLevel()];
+            [data.nswindow setLevel:CGShieldingWindowLevel()];
         } else if (window->flags & SDL_WINDOW_ALWAYS_ON_TOP) {
-            [data->nswindow setLevel:NSFloatingWindowLevel];
+            [data.nswindow setLevel:NSFloatingWindowLevel];
         } else {
-            [data->nswindow setLevel:kCGNormalWindowLevel];
+            [data.nswindow setLevel:kCGNormalWindowLevel];
         }
     }
-}
+}}
 
 void
 Cocoa_DestroyWindow(_THIS, SDL_Window * window)
 { @autoreleasepool
 {
-    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
+    SDL_WindowData *data = (SDL_WindowData *) CFBridgingRelease(window->driverdata);
 
     if (data) {
-        if ([data->listener isInFullscreenSpace]) {
+        if ([data.listener isInFullscreenSpace]) {
             [NSMenu setMenuBarVisible:YES];
         }
-        [data->listener close];
-        [data->listener release];
-        if (data->created) {
+        [data.listener close];
+        data.listener = nil;
+        if (data.created) {
             /* Release the content view to avoid further updateLayer callbacks */
-            [data->nswindow setContentView:nil];
-            [data->nswindow close];
+            [data.nswindow setContentView:nil];
+            [data.nswindow close];
         }
 
-        NSArray *contexts = [[data->nscontexts copy] autorelease];
+        NSArray *contexts = [data.nscontexts copy];
         for (SDLOpenGLContext *context in contexts) {
             /* Calling setWindow:NULL causes the context to remove itself from the context list. */            
             [context setWindow:NULL];
         }
-        [data->nscontexts release];
-
-        SDL_free(data);
     }
     window->driverdata = NULL;
 }}
 
 SDL_bool
 Cocoa_GetWindowWMInfo(_THIS, SDL_Window * window, SDL_SysWMinfo * info)
+{ @autoreleasepool
 {
-    NSWindow *nswindow = ((SDL_WindowData *) window->driverdata)->nswindow;
+    NSWindow *nswindow = ((__bridge SDL_WindowData *) window->driverdata).nswindow;
 
     if (info->version.major <= SDL_MAJOR_VERSION) {
         info->subsystem = SDL_SYSWM_COCOA;
@@ -2292,33 +2327,34 @@ Cocoa_GetWindowWMInfo(_THIS, SDL_Window * window, SDL_SysWMinfo * info)
                      SDL_MAJOR_VERSION, SDL_MINOR_VERSION);
         return SDL_FALSE;
     }
-}
+}}
 
 SDL_bool
 Cocoa_IsWindowInFullscreenSpace(SDL_Window * window)
+{ @autoreleasepool
 {
-    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
+    SDL_WindowData *data = (__bridge SDL_WindowData *) window->driverdata;
 
-    if ([data->listener isInFullscreenSpace]) {
+    if ([data.listener isInFullscreenSpace]) {
         return SDL_TRUE;
     } else {
         return SDL_FALSE;
     }
-}
+}}
 
 SDL_bool
 Cocoa_SetWindowFullscreenSpace(SDL_Window * window, SDL_bool state)
 { @autoreleasepool
 {
     SDL_bool succeeded = SDL_FALSE;
-    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
+    SDL_WindowData *data = (__bridge SDL_WindowData *) window->driverdata;
 
-    if (data->inWindowFullscreenTransition) {
+    if (data.inWindowFullscreenTransition) {
         return SDL_FALSE;
     }
 
-    data->inWindowFullscreenTransition = SDL_TRUE;
-    if ([data->listener setFullscreenSpace:(state ? YES : NO)]) {
+    data.inWindowFullscreenTransition = SDL_TRUE;
+    if ([data.listener setFullscreenSpace:(state ? YES : NO)]) {
         const int maxattempts = 3;
         int attempt = 0;
         while (++attempt <= maxattempts) {
@@ -2327,7 +2363,7 @@ Cocoa_SetWindowFullscreenSpace(SDL_Window * window, SDL_bool state)
              */
             const int limit = 10000;
             int count = 0;
-            while ([data->listener isInFullscreenSpaceTransition]) {
+            while ([data.listener isInFullscreenSpaceTransition]) {
                 if ( ++count == limit ) {
                     /* Uh oh, transition isn't completing. Should we assert? */
                     break;
@@ -2335,16 +2371,16 @@ Cocoa_SetWindowFullscreenSpace(SDL_Window * window, SDL_bool state)
                 SDL_Delay(1);
                 SDL_PumpEvents();
             }
-            if ([data->listener isInFullscreenSpace] == (state ? YES : NO))
+            if ([data.listener isInFullscreenSpace] == (state ? YES : NO))
                 break;
             /* Try again, the last attempt was interrupted by user gestures */
-            if (![data->listener setFullscreenSpace:(state ? YES : NO)])
+            if (![data.listener setFullscreenSpace:(state ? YES : NO)])
                 break; /* ??? */
         }
         /* Return TRUE to prevent non-space fullscreen logic from running */
         succeeded = SDL_TRUE;
     }
-    data->inWindowFullscreenTransition = SDL_FALSE;
+    data.inWindowFullscreenTransition = SDL_FALSE;
 
     return succeeded;
 }}
@@ -2357,25 +2393,26 @@ Cocoa_SetWindowHitTest(SDL_Window * window, SDL_bool enabled)
 
 void
 Cocoa_AcceptDragAndDrop(SDL_Window * window, SDL_bool accept)
+{ @autoreleasepool
 {
-    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
+    SDL_WindowData *data = (__bridge SDL_WindowData *) window->driverdata;
     if (accept) {
-        [data->nswindow registerForDraggedTypes:[NSArray arrayWithObject:(NSString *)kUTTypeFileURL]];
+        [data.nswindow registerForDraggedTypes:[NSArray arrayWithObject:(NSString *)kUTTypeFileURL]];
     } else {
-        [data->nswindow unregisterDraggedTypes];
+        [data.nswindow unregisterDraggedTypes];
     }
-}
+}}
 
 int
 Cocoa_FlashWindow(_THIS, SDL_Window *window, SDL_FlashOperation operation)
 { @autoreleasepool
 {
     /* Note that this is app-wide and not window-specific! */
-    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
+    SDL_WindowData *data = (__bridge SDL_WindowData *) window->driverdata;
 
-    if (data->flash_request) {
-        [NSApp cancelUserAttentionRequest:data->flash_request];
-        data->flash_request = 0;
+    if (data.flash_request) {
+        [NSApp cancelUserAttentionRequest:data.flash_request];
+        data.flash_request = 0;
     }
 
     switch (operation) {
@@ -2383,10 +2420,10 @@ Cocoa_FlashWindow(_THIS, SDL_Window *window, SDL_FlashOperation operation)
         /* Canceled above */
         break;
     case SDL_FLASH_BRIEFLY:
-        data->flash_request = [NSApp requestUserAttention:NSInformationalRequest];
+        data.flash_request = [NSApp requestUserAttention:NSInformationalRequest];
         break;
     case SDL_FLASH_UNTIL_FOCUSED:
-        data->flash_request = [NSApp requestUserAttention:NSCriticalRequest];
+        data.flash_request = [NSApp requestUserAttention:NSCriticalRequest];
         break;
     default:
         return SDL_Unsupported();
@@ -2396,11 +2433,12 @@ Cocoa_FlashWindow(_THIS, SDL_Window *window, SDL_FlashOperation operation)
 
 int
 Cocoa_SetWindowOpacity(_THIS, SDL_Window * window, float opacity)
+{ @autoreleasepool
 {
-    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
-    [data->nswindow setAlphaValue:opacity];
+    SDL_WindowData *data = (__bridge SDL_WindowData *) window->driverdata;
+    [data.nswindow setAlphaValue:opacity];
     return 0;
-}
+}}
 
 #endif /* SDL_VIDEO_DRIVER_COCOA */
 
diff --git a/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmsym.h b/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmsym.h
index 52c78de5e..f53c5c8ea 100644
--- a/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmsym.h
+++ b/Engine/lib/sdl/src/video/kmsdrm/SDL_kmsdrmsym.h
@@ -19,7 +19,7 @@
   3. This notice may not be removed or altered from any source distribution.
 */
 
-/* *INDENT-OFF* */
+/* *INDENT-OFF* */ /* clang-format off */
 
 #ifndef SDL_KMSDRM_MODULE
 #define SDL_KMSDRM_MODULE(modname)
@@ -125,6 +125,6 @@ SDL_KMSDRM_SYM(void,gbm_surface_release_buffer,(struct gbm_surface *surf, struct
 #undef SDL_KMSDRM_SYM
 #undef SDL_KMSDRM_SYM_CONST
 
-/* *INDENT-ON* */
+/* *INDENT-ON* */ /* clang-format on */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/ngage/SDL_ngageevents.cpp b/Engine/lib/sdl/src/video/ngage/SDL_ngageevents.cpp
new file mode 100644
index 000000000..a13633376
--- /dev/null
+++ b/Engine/lib/sdl/src/video/ngage/SDL_ngageevents.cpp
@@ -0,0 +1,200 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "../../SDL_internal.h"
+
+#if SDL_VIDEO_DRIVER_NGAGE
+
+/* Being a ngage driver, there's no event stream. We just define stubs for
+   most of the API. */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../../events/SDL_events_c.h"
+#include "../../events/SDL_keyboard_c.h"
+
+#ifdef __cplusplus
+}
+#endif
+
+#include "SDL_ngagevideo.h"
+#include "SDL_ngageevents_c.h"
+
+int HandleWsEvent(_THIS, const TWsEvent& aWsEvent);
+
+void
+NGAGE_PumpEvents(_THIS)
+{
+    SDL_VideoData *phdata = (SDL_VideoData*)_this->driverdata;
+
+    while (phdata->NGAGE_WsEventStatus != KRequestPending)
+    {
+        phdata->NGAGE_WsSession.GetEvent(phdata->NGAGE_WsEvent);
+
+        HandleWsEvent(_this, phdata->NGAGE_WsEvent);
+
+        phdata->NGAGE_WsEventStatus = KRequestPending;
+        phdata->NGAGE_WsSession.EventReady(&phdata->NGAGE_WsEventStatus);
+    }
+}
+
+/*****************************************************************************/
+/* Internal                                                                  */
+/*****************************************************************************/
+
+#include <bautils.h>
+#include <hal.h>
+
+extern void DisableKeyBlocking(_THIS);
+extern void RedrawWindowL(_THIS);
+
+TBool isCursorVisible = EFalse;
+
+static SDL_Scancode ConvertScancode(_THIS, int key)
+{
+    SDL_Keycode keycode;
+
+    switch(key)
+    {
+        case EStdKeyBackspace:    // Clear key
+            keycode = SDLK_BACKSPACE;
+            break;
+        case 0x31:                // 1
+            keycode = SDLK_1;
+            break;
+        case 0x32:                // 2
+            keycode = SDLK_2;
+            break;
+        case 0x33:                // 3
+            keycode = SDLK_3;
+            break;
+        case 0x34:                // 4
+            keycode = SDLK_4;
+            break;
+        case 0x35:                // 5
+            keycode = SDLK_5;
+            break;
+        case 0x36:                // 6
+            keycode = SDLK_6;
+            break;
+        case 0x37:                // 7
+            keycode = SDLK_7;
+            break;
+        case 0x38:                // 8
+            keycode = SDLK_8;
+            break;
+        case 0x39:                // 9
+            keycode = SDLK_9;
+            break;
+        case 0x30:                // 0
+            keycode = SDLK_0;
+            break;
+        case 0x2a:                // Asterisk
+            keycode = SDLK_ASTERISK;
+            break;
+        case EStdKeyHash:         // Hash
+            keycode = SDLK_HASH;
+            break;
+        case EStdKeyDevice0:      // Left softkey
+            keycode = SDLK_SOFTLEFT;
+            break;
+        case EStdKeyDevice1:      // Right softkey
+            keycode = SDLK_SOFTRIGHT;
+            break;
+        case EStdKeyApplication0: // Call softkey
+            keycode = SDLK_CALL;
+            break;
+        case EStdKeyApplication1: // End call softkey
+            keycode = SDLK_ENDCALL;
+            break;
+        case EStdKeyDevice3:      // Middle softkey
+            keycode = SDLK_SELECT;
+            break;
+        case EStdKeyUpArrow:      // Up arrow
+            keycode = SDLK_UP;
+            break;
+        case EStdKeyDownArrow:    // Down arrow
+            keycode = SDLK_DOWN;
+            break;
+        case EStdKeyLeftArrow:    // Left arrow
+            keycode = SDLK_LEFT;
+            break;
+        case EStdKeyRightArrow:   // Right arrow
+            keycode = SDLK_RIGHT;
+            break;
+        default:
+            keycode = SDLK_UNKNOWN;
+            break;
+    }
+
+    return SDL_GetScancodeFromKey(keycode);
+}
+
+int HandleWsEvent(_THIS, const TWsEvent& aWsEvent)
+{
+    SDL_VideoData *phdata = (SDL_VideoData*)_this->driverdata;
+    int            posted = 0;
+
+    switch (aWsEvent.Type())
+    {
+        case EEventKeyDown: /* Key events */
+            SDL_SendKeyboardKey(SDL_PRESSED, ConvertScancode(_this, aWsEvent.Key()->iScanCode));
+            break;
+        case EEventKeyUp: /* Key events */
+            SDL_SendKeyboardKey(SDL_RELEASED, ConvertScancode(_this, aWsEvent.Key()->iScanCode));
+            break;
+        case EEventFocusGained: /* SDL window got focus */
+            phdata->NGAGE_IsWindowFocused = ETrue;
+            /* Draw window background and screen buffer */
+            DisableKeyBlocking(_this);
+            RedrawWindowL(_this);
+            break;
+        case EEventFocusLost: /* SDL window lost focus */
+        {
+            phdata->NGAGE_IsWindowFocused = EFalse;
+            RWsSession s;
+            s.Connect();
+            RWindowGroup g(s);
+            g.Construct(TUint32(&g), EFalse);
+            g.EnableReceiptOfFocus(EFalse);
+            RWindow w(s);
+            w.Construct(g, TUint32(&w));
+            w.SetExtent(TPoint(0, 0), phdata->NGAGE_WsWindow.Size());
+            w.SetOrdinalPosition(0);
+            w.Activate();
+            w.Close();
+            g.Close();
+            s.Close();
+            break;
+        }
+        case EEventModifiersChanged:
+            break;
+        default:
+            break;
+    }
+    return posted;
+}
+
+#endif /* SDL_VIDEO_DRIVER_NGAGE */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/ngage/SDL_ngageevents_c.h b/Engine/lib/sdl/src/video/ngage/SDL_ngageevents_c.h
new file mode 100644
index 000000000..c7b58ce40
--- /dev/null
+++ b/Engine/lib/sdl/src/video/ngage/SDL_ngageevents_c.h
@@ -0,0 +1,28 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "../../SDL_internal.h"
+
+#include "SDL_ngagevideo.h"
+
+extern void NGAGE_PumpEvents(_THIS);
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/ngage/SDL_ngageframebuffer.cpp b/Engine/lib/sdl/src/video/ngage/SDL_ngageframebuffer.cpp
new file mode 100644
index 000000000..a67fa5a8a
--- /dev/null
+++ b/Engine/lib/sdl/src/video/ngage/SDL_ngageframebuffer.cpp
@@ -0,0 +1,431 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "../../SDL_internal.h"
+
+#if SDL_VIDEO_DRIVER_NGAGE
+
+#include <SDL.h>
+
+#include "../SDL_sysvideo.h"
+#include "SDL_ngagevideo.h"
+#include "SDL_ngageframebuffer_c.h"
+
+#define NGAGE_SURFACE "NGAGE_FrameBuffer"
+
+/* For 12 bit screen HW. Table for fast conversion from 8 bit to 12 bit
+ *
+ * TUint16 is enough, but using TUint32 so we can use better instruction
+ * selection on ARMI.
+ */
+static TUint32 NGAGE_HWPalette_256_to_Screen[256];
+
+int  GetBpp(TDisplayMode displaymode);
+void DirectUpdate(_THIS, int numrects, SDL_Rect *rects);
+void DrawBackground(_THIS);
+void DirectDraw(_THIS, int numrects, SDL_Rect *rects, TUint16* screenBuffer);
+void RedrawWindowL(_THIS);
+
+int SDL_NGAGE_CreateWindowFramebuffer(_THIS, SDL_Window * window, Uint32 * format, void ** pixels, int *pitch)
+{
+    SDL_VideoData *phdata = (SDL_VideoData*)_this->driverdata;
+    SDL_Surface   *surface;
+    const Uint32   surface_format = SDL_PIXELFORMAT_RGB444;
+    int w, h;
+
+    /* Free the old framebuffer surface */
+    SDL_NGAGE_DestroyWindowFramebuffer(_this, window);
+
+    /* Create a new one */
+    SDL_GetWindowSize(window, &w, &h);
+    surface = SDL_CreateRGBSurfaceWithFormat(0, w, h, 0, surface_format);
+    if (! surface) {
+        return -1;
+    }
+
+    /* Save the info and return! */
+    SDL_SetWindowData(window, NGAGE_SURFACE, surface);
+    *format = surface_format;
+    *pixels = surface->pixels;
+    *pitch  = surface->pitch;
+
+    /* Initialise Epoc frame buffer */
+
+    TDisplayMode          displayMode = phdata->NGAGE_WsScreen->DisplayMode();
+
+    TScreenInfoV01        screenInfo;
+    TPckg<TScreenInfoV01> sInfo(screenInfo);
+    UserSvr::ScreenInfo(sInfo);
+
+    phdata->NGAGE_ScreenSize       = screenInfo.iScreenSize;
+    phdata->NGAGE_DisplayMode      = displayMode;
+    phdata->NGAGE_HasFrameBuffer   = screenInfo.iScreenAddressValid;
+    phdata->NGAGE_FrameBuffer      = phdata->NGAGE_HasFrameBuffer ? (TUint8*) screenInfo.iScreenAddress : NULL;
+    phdata->NGAGE_BytesPerPixel    = ((GetBpp(displayMode)-1) / 8) + 1;
+
+    phdata->NGAGE_BytesPerScanLine = screenInfo.iScreenSize.iWidth * phdata->NGAGE_BytesPerPixel;
+    phdata->NGAGE_BytesPerScreen   = phdata->NGAGE_BytesPerScanLine * phdata->NGAGE_ScreenSize.iHeight;
+
+    SDL_Log("Screen width        %d", screenInfo.iScreenSize.iWidth);
+    SDL_Log("Screen height       %d", screenInfo.iScreenSize.iHeight);
+    SDL_Log("Screen dmode        %d", displayMode);
+    SDL_Log("Screen valid        %d", screenInfo.iScreenAddressValid);
+
+    SDL_Log("Bytes per pixel     %d", phdata->NGAGE_BytesPerPixel);
+    SDL_Log("Bytes per scan line %d", phdata->NGAGE_BytesPerScanLine);
+    SDL_Log("Bytes per screen    %d", phdata->NGAGE_BytesPerScreen);
+
+    /* It seems that in SA1100 machines for 8bpp displays there is a 512
+     * palette table at the beginning of the frame buffer.
+     *
+     * In 12 bpp machines the table has 16 entries.
+     */
+    if (phdata->NGAGE_HasFrameBuffer && GetBpp(displayMode) == 8)
+    {
+        phdata->NGAGE_FrameBuffer += 512;
+    }
+    else
+    {
+        phdata->NGAGE_FrameBuffer += 32;
+    }
+    #if 0
+    if (phdata->NGAGE_HasFrameBuffer && GetBpp(displayMode) == 12)
+    {
+        phdata->NGAGE_FrameBuffer += 16 * 2;
+    }
+    if (phdata->NGAGE_HasFrameBuffer && GetBpp(displayMode) == 16)
+    {
+        phdata->NGAGE_FrameBuffer += 16 * 2;
+    }
+    #endif
+
+    // Get draw device for updating the screen
+    TScreenInfoV01 screenInfo2;
+
+    NGAGE_Runtime::GetScreenInfo(screenInfo2);
+
+    TRAPD(status, phdata->NGAGE_DrawDevice = CFbsDrawDevice::NewScreenDeviceL(screenInfo2, displayMode));
+    User::LeaveIfError(status);
+
+    /* Activate events for me */
+    phdata->NGAGE_WsEventStatus = KRequestPending;
+    phdata->NGAGE_WsSession.EventReady(&phdata->NGAGE_WsEventStatus);
+
+    SDL_Log("SDL:WsEventStatus");
+    User::WaitForRequest(phdata->NGAGE_WsEventStatus);
+
+    phdata->NGAGE_RedrawEventStatus = KRequestPending;
+    phdata->NGAGE_WsSession.RedrawReady(&phdata->NGAGE_RedrawEventStatus);
+
+    SDL_Log("SDL:RedrawEventStatus");
+    User::WaitForRequest(phdata->NGAGE_RedrawEventStatus);
+
+    phdata->NGAGE_WsWindow.PointerFilter(EPointerFilterDrag, 0);
+
+    phdata->NGAGE_ScreenOffset = TPoint(0, 0);
+
+    SDL_Log("SDL:DrawBackground");
+    DrawBackground(_this); // Clear screen
+
+    return 0;
+}
+
+int SDL_NGAGE_UpdateWindowFramebuffer(_THIS, SDL_Window * window, const SDL_Rect * rects, int numrects)
+{
+    static int   frame_number;
+    SDL_Surface *surface;
+
+    surface = (SDL_Surface *) SDL_GetWindowData(window, NGAGE_SURFACE);
+    if (! surface)
+    {
+        return SDL_SetError("Couldn't find ngage surface for window");
+    }
+
+    /* Send the data to the display */
+    if (SDL_getenv("SDL_VIDEO_NGAGE_SAVE_FRAMES"))
+    {
+        char file[128];
+        SDL_snprintf(file, sizeof(file), "SDL_window%d-%8.8d.bmp",
+                     (int)SDL_GetWindowID(window), ++frame_number);
+        SDL_SaveBMP(surface, file);
+    }
+
+    DirectUpdate(_this, numrects, (SDL_Rect*)rects);
+
+    return 0;
+}
+
+void SDL_NGAGE_DestroyWindowFramebuffer(_THIS, SDL_Window * window)
+{
+    SDL_Surface *surface;
+
+    surface = (SDL_Surface *) SDL_SetWindowData(window, NGAGE_SURFACE, NULL);
+    SDL_FreeSurface(surface);
+}
+
+/*****************************************************************************/
+/* Runtime                                                                   */
+/*****************************************************************************/
+
+#include <e32svr.h>
+#include <hal_data.h>
+#include <hal.h>
+
+EXPORT_C void NGAGE_Runtime::GetScreenInfo(TScreenInfoV01& screenInfo2)
+{
+    TPckg<TScreenInfoV01> sInfo2(screenInfo2);
+    UserSvr::ScreenInfo(sInfo2);
+}
+
+/*****************************************************************************/
+/* Internal                                                                  */
+/*****************************************************************************/
+
+int GetBpp(TDisplayMode displaymode)
+{
+    return TDisplayModeUtils::NumDisplayModeBitsPerPixel(displaymode);
+}
+
+void DrawBackground(_THIS)
+{
+    SDL_VideoData *phdata = (SDL_VideoData*)_this->driverdata;
+    /* Draw background */
+    TUint16* screenBuffer = (TUint16*)phdata->NGAGE_FrameBuffer;
+    /* Draw black background */
+    Mem::FillZ(screenBuffer, phdata->NGAGE_BytesPerScreen);
+}
+
+void DirectDraw(_THIS, int numrects, SDL_Rect *rects, TUint16* screenBuffer)
+{
+    SDL_VideoData *phdata = (SDL_VideoData*)_this->driverdata;
+    SDL_Surface   *screen = (SDL_Surface*)SDL_GetWindowData(_this->windows, NGAGE_SURFACE);
+
+    TInt i;
+
+    //const TInt   sourceNumBytesPerPixel = ((screen->format->BitsPerPixel-1) >> 3) + 1;
+    TDisplayMode displayMode            = phdata->NGAGE_DisplayMode;
+    const TInt   sourceNumBytesPerPixel = ((GetBpp(displayMode)-1) / 8) + 1;
+    //
+    const TPoint fixedOffset            = phdata->NGAGE_ScreenOffset;
+    const TInt   screenW                = screen->w;
+    const TInt   screenH                = screen->h;
+    const TInt   sourceScanlineLength   = screenW;
+    const TInt   targetScanlineLength   = phdata->NGAGE_ScreenSize.iWidth;
+
+    /* Render the rectangles in the list */
+
+    for (i = 0; i < numrects; ++i)
+    {
+        const SDL_Rect& currentRect = rects[i];
+        SDL_Rect        rect2;
+        rect2.x = currentRect.x;
+        rect2.y = currentRect.y;
+        rect2.w = currentRect.w;
+        rect2.h = currentRect.h;
+
+        if (rect2.w <= 0 || rect2.h <= 0) /* Sanity check */
+        {
+            continue;
+        }
+
+        /* All variables are measured in pixels */
+
+        /* Check rects validity, i.e. upper and lower bounds */
+        TInt maxX = Min(screenW - 1, rect2.x + rect2.w - 1);
+        TInt maxY = Min(screenH - 1, rect2.y + rect2.h - 1);
+        if (maxX < 0 || maxY < 0) /* sanity check */
+        {
+            continue;
+        }
+        /* Clip from bottom */
+
+        maxY = Min(maxY, phdata->NGAGE_ScreenSize.iHeight-1);
+        /* TODO: Clip from the right side */
+
+        const TInt  sourceRectWidth        = maxX - rect2.x + 1;
+        const TInt  sourceRectWidthInBytes = sourceRectWidth * sourceNumBytesPerPixel;
+        const TInt  sourceRectHeight       = maxY - rect2.y + 1;
+        const TInt  sourceStartOffset      = rect2.x + rect2.y * sourceScanlineLength;
+        const TUint skipValue              = 1; /* 1 = No skip */
+
+        TInt targetStartOffset = fixedOffset.iX + rect2.x + (fixedOffset.iY +rect2.y) * targetScanlineLength;
+
+        switch (screen->format->BitsPerPixel)
+        {
+            case 12:
+            {
+                TUint16* bitmapLine   = (TUint16*)screen->pixels + sourceStartOffset;
+                TUint16* screenMemory = screenBuffer + targetStartOffset;
+
+                if (skipValue == 1)
+                {
+                    for(TInt y = 0 ; y < sourceRectHeight ; y++)
+                    {
+                        Mem::Copy(screenMemory, bitmapLine, sourceRectWidthInBytes);
+                        bitmapLine   += sourceScanlineLength;
+                        screenMemory += targetScanlineLength;
+                    }
+                }
+                else
+                {
+                    for(TInt y = 0 ; y < sourceRectHeight ; y++)
+                    {
+                        TUint16* bitmapPos           = bitmapLine;   /* 2 bytes per pixel */
+                        TUint16* screenMemoryLinePos = screenMemory; /* 2 bytes per pixel */
+                        for(TInt x = 0 ; x < sourceRectWidth ; x++)
+                        {
+                            __ASSERT_DEBUG(screenMemory < (screenBuffer + phdata->NGAGE_ScreenSize.iWidth * phdata->NGAGE_ScreenSize.iHeight), User::Panic(_L("SDL"), KErrCorrupt));
+                            __ASSERT_DEBUG(screenMemory >= screenBuffer, User::Panic(_L("SDL"), KErrCorrupt));
+                            __ASSERT_DEBUG(bitmapLine < ((TUint16*)screen->pixels + (screen->w * screen->h)), User::Panic(_L("SDL"), KErrCorrupt));
+                            __ASSERT_DEBUG(bitmapLine >=  (TUint16*)screen->pixels, User::Panic(_L("SDL"), KErrCorrupt));
+
+                            *screenMemoryLinePos++ = *bitmapPos;
+                            bitmapPos += skipValue;
+                        }
+                        bitmapLine   += sourceScanlineLength;
+                        screenMemory += targetScanlineLength;
+                    }
+                }
+            }
+            break;
+            // 256 color paletted mode: 8 bpp --> 12 bpp
+            default:
+            {
+                if(phdata->NGAGE_BytesPerPixel <= 2)
+                {
+                    TUint8*  bitmapLine   = (TUint8*)screen->pixels + sourceStartOffset;
+                    TUint16* screenMemory = screenBuffer + targetStartOffset;
+
+                    for(TInt y = 0 ; y < sourceRectHeight ; y++)
+                    {
+                        TUint8*  bitmapPos           = bitmapLine;   /* 1 byte per pixel */
+                        TUint16* screenMemoryLinePos = screenMemory; /* 2 bytes per pixel */
+                        /* Convert each pixel from 256 palette to 4k color values */
+                        for(TInt x = 0 ; x < sourceRectWidth ; x++)
+                        {
+                            __ASSERT_DEBUG(screenMemoryLinePos < (screenBuffer + (phdata->NGAGE_ScreenSize.iWidth * phdata->NGAGE_ScreenSize.iHeight)), User::Panic(_L("SDL"), KErrCorrupt));
+                            __ASSERT_DEBUG(screenMemoryLinePos >= screenBuffer, User::Panic(_L("SDL"), KErrCorrupt));
+                            __ASSERT_DEBUG(bitmapPos < ((TUint8*)screen->pixels + (screen->w * screen->h)), User::Panic(_L("SDL"), KErrCorrupt));
+                            __ASSERT_DEBUG(bitmapPos >= (TUint8*)screen->pixels, User::Panic(_L("SDL"), KErrCorrupt));
+                            *screenMemoryLinePos++ = NGAGE_HWPalette_256_to_Screen[*bitmapPos++];
+                        }
+                        bitmapLine   += sourceScanlineLength;
+                        screenMemory += targetScanlineLength;
+                    }
+                }
+                else
+                {
+                    TUint8*  bitmapLine   = (TUint8*)screen->pixels + sourceStartOffset;
+                    TUint32* screenMemory = reinterpret_cast<TUint32*>(screenBuffer + targetStartOffset);
+                    for(TInt y = 0 ; y < sourceRectHeight ; y++)
+                    {
+                        TUint8*  bitmapPos           = bitmapLine;   /* 1 byte per pixel */
+                        TUint32* screenMemoryLinePos = screenMemory; /* 2 bytes per pixel */
+                        /* Convert each pixel from 256 palette to 4k color values */
+                        for(TInt x = 0 ; x < sourceRectWidth ; x++)
+                        {
+                            __ASSERT_DEBUG(screenMemoryLinePos < (reinterpret_cast<TUint32*>(screenBuffer) + (phdata->NGAGE_ScreenSize.iWidth * phdata->NGAGE_ScreenSize.iHeight)), User::Panic(_L("SDL"), KErrCorrupt));
+                            __ASSERT_DEBUG(screenMemoryLinePos >= reinterpret_cast<TUint32*>(screenBuffer), User::Panic(_L("SDL"), KErrCorrupt));
+                            __ASSERT_DEBUG(bitmapPos < ((TUint8*)screen->pixels + (screen->w * screen->h)), User::Panic(_L("SDL"), KErrCorrupt));
+                            __ASSERT_DEBUG(bitmapPos >= (TUint8*)screen->pixels, User::Panic(_L("SDL"), KErrCorrupt));
+                            *screenMemoryLinePos++ = NGAGE_HWPalette_256_to_Screen[*bitmapPos++];
+                        }
+                        bitmapLine   += sourceScanlineLength;
+                        screenMemory += targetScanlineLength;
+                    }
+                }
+            }
+        }
+    }
+}
+
+void DirectUpdate(_THIS, int numrects, SDL_Rect *rects)
+{
+    SDL_VideoData *phdata = (SDL_VideoData*)_this->driverdata;
+
+    if (! phdata->NGAGE_IsWindowFocused)
+    {
+        SDL_PauseAudio(1);
+        SDL_Delay(1000);
+        return;
+    }
+
+    SDL_PauseAudio(0);
+
+    TUint16* screenBuffer = (TUint16*)phdata->NGAGE_FrameBuffer;
+
+#if 0
+    if (phdata->NGAGE_ScreenOrientation == CFbsBitGc::EGraphicsOrientationRotated270)
+    {
+        // ...
+    }
+    else
+#endif
+    {
+        DirectDraw(_this, numrects, rects, screenBuffer);
+    }
+
+    //TRect rect2 = TRect(phdata->NGAGE_WsWindow.Size());
+    for (int i = 0; i < numrects; ++i)
+    {
+        TInt  aAx   = rects[i].x;
+        TInt  aAy   = rects[i].y;
+        TInt  aBx   = rects[i].w;
+        TInt  aBy   = rects[i].h;
+        TRect rect2 = TRect(aAx, aAy, aBx, aBy);
+
+        phdata->NGAGE_DrawDevice->UpdateRegion(rect2); /* Should we update rects parameter area only? */
+        phdata->NGAGE_DrawDevice->Update();
+    }
+}
+
+void RedrawWindowL(_THIS)
+{
+    SDL_VideoData *phdata = (SDL_VideoData*)_this->driverdata;
+    SDL_Surface   *screen = (SDL_Surface*)SDL_GetWindowData(_this->windows, NGAGE_SURFACE);
+
+    int w = screen->w;
+    int h = screen->h;
+    if (phdata->NGAGE_ScreenOrientation == CFbsBitGc::EGraphicsOrientationRotated270) {
+        w = screen->h;
+        h = screen->w;
+    }
+    if ((w < phdata->NGAGE_ScreenSize.iWidth)
+        || (h < phdata->NGAGE_ScreenSize.iHeight)) {
+        DrawBackground(_this);
+    }
+
+    /* Tell the system that something has been drawn */
+    TRect  rect = TRect(phdata->NGAGE_WsWindow.Size());
+    phdata->NGAGE_WsWindow.Invalidate(rect);
+
+    /* Draw current buffer */
+    SDL_Rect fullScreen;
+    fullScreen.x = 0;
+    fullScreen.y = 0;
+    fullScreen.w = screen->w;
+    fullScreen.h = screen->h;
+    DirectUpdate(_this, 1, &fullScreen);
+}
+
+#endif /* SDL_VIDEO_DRIVER_NGAGE */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/ngage/SDL_ngageframebuffer_c.h b/Engine/lib/sdl/src/video/ngage/SDL_ngageframebuffer_c.h
new file mode 100644
index 000000000..c2f0768ca
--- /dev/null
+++ b/Engine/lib/sdl/src/video/ngage/SDL_ngageframebuffer_c.h
@@ -0,0 +1,38 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "../../SDL_internal.h"
+
+extern int SDL_NGAGE_CreateWindowFramebuffer(_THIS, SDL_Window * window, Uint32 * format, void ** pixels, int *pitch);
+extern int SDL_NGAGE_UpdateWindowFramebuffer(_THIS, SDL_Window * window, const SDL_Rect * rects, int numrects);
+extern void SDL_NGAGE_DestroyWindowFramebuffer(_THIS, SDL_Window * window);
+
+/****************************************************************************/
+/* Runtime                                                                  */
+/****************************************************************************/
+
+class NGAGE_Runtime
+{
+public:
+    IMPORT_C static void GetScreenInfo(TScreenInfoV01& screenInfo2);
+};
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/ngage/SDL_ngagevideo.cpp b/Engine/lib/sdl/src/video/ngage/SDL_ngagevideo.cpp
new file mode 100644
index 000000000..eea21e8e1
--- /dev/null
+++ b/Engine/lib/sdl/src/video/ngage/SDL_ngagevideo.cpp
@@ -0,0 +1,192 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include <stdlib.h>
+#ifdef NULL
+#undef NULL
+#endif
+#include "../../SDL_internal.h"
+
+#if SDL_VIDEO_DRIVER_NGAGE
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "SDL_video.h"
+#include "../SDL_sysvideo.h"
+#include "../SDL_pixels_c.h"
+#include "../../events/SDL_events_c.h"
+
+#ifdef __cplusplus
+}
+#endif
+
+#include "SDL_ngagevideo.h"
+#include "SDL_ngagewindow.h"
+#include "SDL_ngageevents_c.h"
+#include "SDL_ngageframebuffer_c.h"
+
+#define NGAGEVID_DRIVER_NAME "ngage"
+
+/* Initialization/Query functions */
+static int  NGAGE_VideoInit(_THIS);
+static int  NGAGE_SetDisplayMode(_THIS, SDL_VideoDisplay * display, SDL_DisplayMode * mode);
+static void NGAGE_VideoQuit(_THIS);
+
+/* NGAGE driver bootstrap functions */
+
+static void
+NGAGE_DeleteDevice(SDL_VideoDevice * device)
+{
+    SDL_VideoData *phdata = (SDL_VideoData*)device->driverdata;
+
+    if (phdata)
+    {
+        /* Free Epoc resources */
+
+        /* Disable events for me */
+        if (phdata->NGAGE_WsEventStatus != KRequestPending)
+        {
+            phdata->NGAGE_WsSession.EventReadyCancel();
+        }
+        if (phdata->NGAGE_RedrawEventStatus != KRequestPending)
+        {
+            phdata->NGAGE_WsSession.RedrawReadyCancel();
+        }
+
+        free(phdata->NGAGE_DrawDevice);
+
+        if (phdata->NGAGE_WsWindow.WsHandle())
+        {
+            phdata->NGAGE_WsWindow.Close();
+        }
+
+        if (phdata->NGAGE_WsWindowGroup.WsHandle())
+        {
+            phdata->NGAGE_WsWindowGroup.Close();
+        }
+
+        delete phdata->NGAGE_WindowGc;
+        phdata->NGAGE_WindowGc = NULL;
+
+        delete phdata->NGAGE_WsScreen;
+        phdata->NGAGE_WsScreen = NULL;
+
+        if (phdata->NGAGE_WsSession.WsHandle())
+        {
+            phdata->NGAGE_WsSession.Close();
+        }
+
+        SDL_free(phdata);
+        phdata = NULL;
+    }
+
+    if (device)
+    {
+        SDL_free(device);
+        device = NULL;
+    }
+}
+
+static SDL_VideoDevice *
+NGAGE_CreateDevice(int devindex)
+{
+    SDL_VideoDevice *device;
+    SDL_VideoData   *phdata;
+
+    /* Initialize all variables that we clean on shutdown */
+    device = (SDL_VideoDevice *) SDL_calloc(1, sizeof(SDL_VideoDevice));
+    if (!device) {
+        SDL_OutOfMemory();
+        return (0);
+    }
+
+    /* Initialize internal N-Gage specific data */
+    phdata = (SDL_VideoData *) SDL_calloc(1, sizeof(SDL_VideoData));
+    if (! phdata)
+    {
+        SDL_OutOfMemory();
+        SDL_free(device);
+        return (0);
+    }
+
+    /* General video */
+    device->VideoInit                = NGAGE_VideoInit;
+    device->VideoQuit                = NGAGE_VideoQuit;
+    device->SetDisplayMode           = NGAGE_SetDisplayMode;
+    device->PumpEvents               = NGAGE_PumpEvents;
+    device->CreateWindowFramebuffer  = SDL_NGAGE_CreateWindowFramebuffer;
+    device->UpdateWindowFramebuffer  = SDL_NGAGE_UpdateWindowFramebuffer;
+    device->DestroyWindowFramebuffer = SDL_NGAGE_DestroyWindowFramebuffer;
+    device->free                     = NGAGE_DeleteDevice;
+
+    /* "Window" */
+    device->CreateSDLWindow = NGAGE_CreateWindow;
+    device->DestroyWindow   = NGAGE_DestroyWindow;
+
+    /* N-Gage specific data */
+    device->driverdata = phdata;
+
+    return device;
+}
+
+VideoBootStrap NGAGE_bootstrap = {
+    NGAGEVID_DRIVER_NAME, "SDL ngage video driver",
+    NGAGE_CreateDevice
+};
+
+int
+NGAGE_VideoInit(_THIS)
+{
+    SDL_DisplayMode mode;
+
+    /* Use 12-bpp desktop mode */
+    mode.format       = SDL_PIXELFORMAT_RGB444;
+    mode.w            = 176;
+    mode.h            = 208;
+    mode.refresh_rate = 0;
+    mode.driverdata   = NULL;
+    if (SDL_AddBasicVideoDisplay(&mode) < 0) {
+        return -1;
+    }
+
+    SDL_zero(mode);
+    SDL_AddDisplayMode(&_this->displays[0], &mode);
+
+    /* We're done! */
+    return 0;
+}
+
+static int
+NGAGE_SetDisplayMode(_THIS, SDL_VideoDisplay * display, SDL_DisplayMode * mode)
+{
+    return 0;
+}
+
+void
+NGAGE_VideoQuit(_THIS)
+{
+}
+
+#endif /* SDL_VIDEO_DRIVER_NGAGE */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/ngage/SDL_ngagevideo.h b/Engine/lib/sdl/src/video/ngage/SDL_ngagevideo.h
new file mode 100644
index 000000000..86fc1a586
--- /dev/null
+++ b/Engine/lib/sdl/src/video/ngage/SDL_ngagevideo.h
@@ -0,0 +1,75 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "../../SDL_internal.h"
+
+#ifndef _SDL_ngagevideo_h
+#define _SDL_ngagevideo_h
+
+#include "../SDL_sysvideo.h"
+
+#include <e32std.h>
+#include <e32svr.h>
+#include <bitdev.h>
+#include <w32std.h>
+#include <bitdraw.h> // CFbsDrawDevice
+
+#define _THIS SDL_VideoDevice *_this
+
+typedef struct SDL_VideoData
+{
+    /* Epoc window server info */
+    RWsSession       NGAGE_WsSession;
+    RWindowGroup     NGAGE_WsWindowGroup;
+    TInt             NGAGE_WsWindowGroupID;
+    RWindow          NGAGE_WsWindow;
+    CWsScreenDevice* NGAGE_WsScreen;
+    CWindowGc*       NGAGE_WindowGc;
+    TRequestStatus   NGAGE_WsEventStatus;
+    TRequestStatus   NGAGE_RedrawEventStatus;
+    TWsEvent         NGAGE_WsEvent;
+    //TWsRedrawEvent   NGAGE_RedrawEvent;
+
+    CFbsDrawDevice*  NGAGE_DrawDevice;
+
+    TBool            NGAGE_IsWindowFocused; /* Not used yet */
+
+    /* Screen hardware frame buffer info */
+    TBool            NGAGE_HasFrameBuffer;
+    TInt             NGAGE_BytesPerPixel;
+    TInt             NGAGE_BytesPerScanLine;
+    TInt             NGAGE_BytesPerScreen;
+    TDisplayMode     NGAGE_DisplayMode;
+    TSize            NGAGE_ScreenSize;
+    TUint8*          NGAGE_FrameBuffer;
+    TPoint           NGAGE_ScreenOffset;
+
+    CFbsBitGc::TGraphicsOrientation NGAGE_ScreenOrientation;
+
+    /* Simulate double screen height */
+    //TInt             NGAGE_ScreenXScaleValue;
+    //TInt             NGAGE_ScreenYScaleValue;
+
+} SDL_VideoData;
+
+#endif /* _SDL_ngagevideo_h */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/ngage/SDL_ngagewindow.cpp b/Engine/lib/sdl/src/video/ngage/SDL_ngagewindow.cpp
new file mode 100644
index 000000000..5b0682b29
--- /dev/null
+++ b/Engine/lib/sdl/src/video/ngage/SDL_ngagewindow.cpp
@@ -0,0 +1,129 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "../../SDL_internal.h"
+
+#if SDL_VIDEO_DRIVER_NGAGE
+
+#include "../SDL_sysvideo.h"
+
+#include "SDL_ngagewindow.h"
+
+const TUint32 WindowClientHandle = 9210;
+
+void DisableKeyBlocking(_THIS);
+void ConstructWindowL(_THIS);
+
+int
+NGAGE_CreateWindow(_THIS, SDL_Window* window)
+{
+    NGAGE_Window* ngage_window = (NGAGE_Window*)SDL_calloc(1, sizeof(NGAGE_Window));
+
+    if (!ngage_window) {
+        return SDL_OutOfMemory();
+    }
+
+    window->driverdata = ngage_window;
+
+    if (window->x == SDL_WINDOWPOS_UNDEFINED) {
+        window->x = 0;
+    }
+
+    if (window->y == SDL_WINDOWPOS_UNDEFINED) {
+        window->y = 0;
+    }
+
+    ngage_window->sdl_window = window;
+
+    ConstructWindowL(_this);
+
+    return 0;
+}
+
+void
+NGAGE_DestroyWindow(_THIS, SDL_Window* window)
+{
+    NGAGE_Window* ngage_window = (NGAGE_Window*)window->driverdata;
+
+    if (ngage_window) {
+        SDL_free(ngage_window);
+    }
+
+    window->driverdata = NULL;
+}
+
+/*****************************************************************************/
+/* Internal                                                                  */
+/*****************************************************************************/
+
+void DisableKeyBlocking(_THIS)
+{
+    SDL_VideoData *phdata = (SDL_VideoData*)_this->driverdata;
+    TRawEvent      event;
+
+    event.Set((TRawEvent::TType) /*EDisableKeyBlock*/ 51);
+    phdata->NGAGE_WsSession.SimulateRawEvent(event);
+}
+
+void ConstructWindowL(_THIS)
+{
+    SDL_VideoData *phdata = (SDL_VideoData*)_this->driverdata;
+    TInt           error;
+
+    error = phdata->NGAGE_WsSession.Connect();
+    User::LeaveIfError(error);
+    phdata->NGAGE_WsScreen=new(ELeave) CWsScreenDevice(phdata->NGAGE_WsSession);
+    User::LeaveIfError(phdata->NGAGE_WsScreen->Construct());
+    User::LeaveIfError(phdata->NGAGE_WsScreen->CreateContext(phdata->NGAGE_WindowGc));
+
+    phdata->NGAGE_WsWindowGroup=RWindowGroup(phdata->NGAGE_WsSession);
+    User::LeaveIfError(phdata->NGAGE_WsWindowGroup.Construct(WindowClientHandle));
+    phdata->NGAGE_WsWindowGroup.SetOrdinalPosition(0);
+
+    RProcess thisProcess;
+    TParse   exeName;
+    exeName.Set(thisProcess.FileName(), NULL, NULL);
+    TBuf<32> winGroupName;
+    winGroupName.Append(0);
+    winGroupName.Append(0);
+    winGroupName.Append(0);              // UID
+    winGroupName.Append(0);
+    winGroupName.Append(exeName.Name()); // Caption
+    winGroupName.Append(0);
+    winGroupName.Append(0);              // DOC name
+    phdata->NGAGE_WsWindowGroup.SetName(winGroupName);
+
+    phdata->NGAGE_WsWindow=RWindow(phdata->NGAGE_WsSession);
+    User::LeaveIfError(phdata->NGAGE_WsWindow.Construct(phdata->NGAGE_WsWindowGroup,WindowClientHandle - 1));
+    phdata->NGAGE_WsWindow.SetBackgroundColor(KRgbWhite);
+    phdata->NGAGE_WsWindow.Activate();
+    phdata->NGAGE_WsWindow.SetSize(phdata->NGAGE_WsScreen->SizeInPixels());
+    phdata->NGAGE_WsWindow.SetVisible(ETrue);
+
+    phdata->NGAGE_WsWindowGroupID = phdata->NGAGE_WsWindowGroup.Identifier();
+    phdata->NGAGE_IsWindowFocused = EFalse;
+
+    DisableKeyBlocking(_this);
+}
+
+#endif /* SDL_VIDEO_DRIVER_NGAGE */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/ngage/SDL_ngagewindow.h b/Engine/lib/sdl/src/video/ngage/SDL_ngagewindow.h
new file mode 100644
index 000000000..148c79986
--- /dev/null
+++ b/Engine/lib/sdl/src/video/ngage/SDL_ngagewindow.h
@@ -0,0 +1,45 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef _SDL_ngagewindow_h
+#define _SDL_ngagewindow_h
+
+#include "../SDL_sysvideo.h"
+#include "SDL_syswm.h"
+
+#include "SDL_ngagevideo.h"
+
+typedef struct {
+    SDL_Window* sdl_window;
+
+} NGAGE_Window;
+
+
+extern int
+NGAGE_CreateWindow(_THIS, SDL_Window* window);
+
+extern void
+NGAGE_DestroyWindow(_THIS, SDL_Window* window);
+
+#endif /* _SDL_ngagewindow */
+
+/* vi: set ts=4 sw=4 expandtab: */
+
diff --git a/Engine/lib/sdl/src/video/riscos/scancodes_riscos.h b/Engine/lib/sdl/src/video/riscos/scancodes_riscos.h
index ced6b0d1b..dbba9d1a1 100644
--- a/Engine/lib/sdl/src/video/riscos/scancodes_riscos.h
+++ b/Engine/lib/sdl/src/video/riscos/scancodes_riscos.h
@@ -24,7 +24,7 @@
    Sources:
    - https://www.riscosopen.org/wiki/documentation/show/Keyboard Scan Codes
 */
-/* *INDENT-OFF* */
+/* *INDENT-OFF* */ /* clang-format off */
 static SDL_Scancode const riscos_scancode_table[] = {
      /*   0 */   SDL_SCANCODE_UNKNOWN,   /* Shift */
      /*   1 */   SDL_SCANCODE_UNKNOWN,   /* Ctrl */
@@ -155,4 +155,4 @@ static SDL_Scancode const riscos_scancode_table[] = {
      /* 126 */   SDL_SCANCODE_RGUI,
      /* 127 */   SDL_SCANCODE_MENU
 };
-/* *INDENT-ON* */
+/* *INDENT-ON* */ /* clang-format on */
diff --git a/Engine/lib/sdl/src/video/sdlgenblit.pl b/Engine/lib/sdl/src/video/sdlgenblit.pl
index c2a22b049..de07b19e5 100755
--- a/Engine/lib/sdl/src/video/sdlgenblit.pl
+++ b/Engine/lib/sdl/src/video/sdlgenblit.pl
@@ -114,7 +114,7 @@ sub open_file {
 
 #if SDL_HAVE_BLIT_AUTO
 
-/* *INDENT-OFF* */
+/* *INDENT-OFF* */ /* clang-format off */
 
 __EOF__
 }
@@ -122,7 +122,7 @@ __EOF__
 sub close_file {
     my $name = shift;
     print FILE <<__EOF__;
-/* *INDENT-ON* */
+/* *INDENT-ON* */ /* clang-format on */
 
 #endif /* SDL_HAVE_BLIT_AUTO */
 
diff --git a/Engine/lib/sdl/src/video/uikit/SDL_uikitopenglview.m b/Engine/lib/sdl/src/video/uikit/SDL_uikitopenglview.m
index 52158f8d7..ef5ca74e5 100644
--- a/Engine/lib/sdl/src/video/uikit/SDL_uikitopenglview.m
+++ b/Engine/lib/sdl/src/video/uikit/SDL_uikitopenglview.m
@@ -89,7 +89,7 @@
             glGetIntegerv(GL_MAX_SAMPLES, &maxsamples);
 
             /* Clamp the samples to the max supported count. */
-            samples = MIN(samples, maxsamples);
+            samples = SDL_min(samples, maxsamples);
         }
 
         if (sRGB) {
diff --git a/Engine/lib/sdl/src/video/uikit/SDL_uikitvideo.m b/Engine/lib/sdl/src/video/uikit/SDL_uikitvideo.m
index 5d2b96e38..81d7bf647 100644
--- a/Engine/lib/sdl/src/video/uikit/SDL_uikitvideo.m
+++ b/Engine/lib/sdl/src/video/uikit/SDL_uikitvideo.m
@@ -278,11 +278,16 @@ UIKit_ForceUpdateHomeIndicator()
  */
 
 #if !defined(SDL_VIDEO_DRIVER_COCOA)
-void SDL_NSLog(const char *text)
+void SDL_NSLog(const char *prefix, const char *text)
 {
     @autoreleasepool {
-        NSString *str = [NSString stringWithUTF8String:text];
-        NSLog(@"%@", str);
+        NSString *nsText = [NSString stringWithUTF8String:text];
+        if (prefix) {
+            NSString *nsPrefix = [NSString stringWithUTF8String:prefix];
+            NSLog(@"%@: %@", nsPrefix, nsText);
+        } else {
+            NSLog(@"%@", nsText);
+        }
     }
 }
 #endif /* SDL_VIDEO_DRIVER_COCOA */
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylanddyn.h b/Engine/lib/sdl/src/video/wayland/SDL_waylanddyn.h
index 3d8d973cc..43a3372d6 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylanddyn.h
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylanddyn.h
@@ -153,6 +153,7 @@ void SDL_WAYLAND_UnloadSymbols(void);
 #define libdecor_state_free (*WAYLAND_libdecor_state_free)
 #define libdecor_configuration_get_content_size (*WAYLAND_libdecor_configuration_get_content_size)
 #define libdecor_configuration_get_window_state (*WAYLAND_libdecor_configuration_get_window_state)
+#define libdecor_dispatch (*WAYLAND_libdecor_dispatch)
 #endif
 
 #else /* SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC */
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandevents.c b/Engine/lib/sdl/src/video/wayland/SDL_waylandevents.c
index e515d9d6f..20fe6022e 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandevents.c
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandevents.c
@@ -294,6 +294,10 @@ Wayland_WaitEventTimeout(_THIS, int timeout)
         }
     }
 
+#ifdef HAVE_LIBDECOR_H
+    libdecor_dispatch(d->shell.libdecor, timeout);
+#endif
+
     /* wl_display_prepare_read() will return -1 if the default queue is not empty.
      * If the default queue is empty, it will prepare us for our SDL_IOReady() call. */
     if (WAYLAND_wl_display_prepare_read(d->display) == 0) {
@@ -476,19 +480,16 @@ ProcessHitTest(struct SDL_WaylandInput *input, uint32_t serial)
         const uint32_t *directions_libdecor = directions;
 #endif
 
-        /* Hit tests shouldn't apply to xdg_popups, right? */
-        SDL_assert(!WINDOW_IS_XDG_POPUP(window));
-
         switch (rc) {
             case SDL_HITTEST_DRAGGABLE:
 #ifdef HAVE_LIBDECOR_H
-                if (input->display->shell.libdecor) {
+                if (window_data->shell_surface_type == WAYLAND_SURFACE_LIBDECOR) {
                     if (window_data->shell_surface.libdecor.frame) {
                         libdecor_frame_move(window_data->shell_surface.libdecor.frame, input->seat, serial);
                     }
                 } else
 #endif
-                if (input->display->shell.xdg) {
+                if (window_data->shell_surface_type == WAYLAND_SURFACE_XDG_TOPLEVEL) {
                     if (window_data->shell_surface.xdg.roleobj.toplevel) {
                         xdg_toplevel_move(window_data->shell_surface.xdg.roleobj.toplevel,
                                           input->seat,
@@ -506,13 +507,13 @@ ProcessHitTest(struct SDL_WaylandInput *input, uint32_t serial)
             case SDL_HITTEST_RESIZE_BOTTOMLEFT:
             case SDL_HITTEST_RESIZE_LEFT:
 #ifdef HAVE_LIBDECOR_H
-                if (input->display->shell.libdecor) {
+                if (window_data->shell_surface_type == WAYLAND_SURFACE_LIBDECOR) {
                     if (window_data->shell_surface.libdecor.frame) {
                         libdecor_frame_resize(window_data->shell_surface.libdecor.frame, input->seat, serial, directions_libdecor[rc - SDL_HITTEST_RESIZE_TOPLEFT]);
                     }
                 } else
 #endif
-                if (input->display->shell.xdg) {
+                if (window_data->shell_surface_type == WAYLAND_SURFACE_XDG_TOPLEVEL) {
                     if (window_data->shell_surface.xdg.roleobj.toplevel) {
                         xdg_toplevel_resize(window_data->shell_surface.xdg.roleobj.toplevel,
                                             input->seat,
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandsym.h b/Engine/lib/sdl/src/video/wayland/SDL_waylandsym.h
index 6891325c7..0473fa1b1 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandsym.h
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandsym.h
@@ -19,7 +19,7 @@
   3. This notice may not be removed or altered from any source distribution.
 */
 
-/* *INDENT-OFF* */
+/* *INDENT-OFF* */ /* clang-format off */
 
 #ifndef SDL_WAYLAND_MODULE
 #define SDL_WAYLAND_MODULE(modname)
@@ -204,12 +204,13 @@ SDL_WAYLAND_SYM(bool, libdecor_configuration_get_content_size, (struct libdecor_
                                                                 int *))
 SDL_WAYLAND_SYM(bool, libdecor_configuration_get_window_state, (struct libdecor_configuration *,\
                                                                 enum libdecor_window_state *))
+SDL_WAYLAND_SYM(bool, libdecor_dispatch, (struct libdecor *, int))
 #endif
 
 #undef SDL_WAYLAND_MODULE
 #undef SDL_WAYLAND_SYM
 #undef SDL_WAYLAND_INTERFACE
 
-/* *INDENT-ON* */
+/* *INDENT-ON* */ /* clang-format on */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandvideo.c b/Engine/lib/sdl/src/video/wayland/SDL_waylandvideo.c
index 0305c46a1..2992d5295 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandvideo.c
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandvideo.c
@@ -878,7 +878,7 @@ static const struct wl_registry_listener registry_listener = {
 };
  
 #ifdef HAVE_LIBDECOR_H
-static SDL_bool should_use_libdecor(SDL_VideoData *data)
+static SDL_bool should_use_libdecor(SDL_VideoData *data, SDL_bool ignore_xdg)
 {
     if (!SDL_WAYLAND_HAVE_WAYLAND_LIBDECOR) {
         return SDL_FALSE;
@@ -892,6 +892,10 @@ static SDL_bool should_use_libdecor(SDL_VideoData *data)
         return SDL_TRUE;
     }
 
+    if (ignore_xdg) {
+        return SDL_TRUE;
+    }
+
     if (data->decoration_manager) {
         return SDL_FALSE;
     }
@@ -900,6 +904,21 @@ static SDL_bool should_use_libdecor(SDL_VideoData *data)
 }
 #endif
 
+SDL_bool
+Wayland_LoadLibdecor(SDL_VideoData *data, SDL_bool ignore_xdg)
+{
+#ifdef HAVE_LIBDECOR_H
+    if (data->shell.libdecor != NULL) {
+        return SDL_TRUE; /* Already loaded! */
+    }
+    if (should_use_libdecor(data, ignore_xdg)) {
+        data->shell.libdecor = libdecor_new(data->display, &libdecor_interface);
+        return data->shell.libdecor != NULL;
+    }
+#endif
+    return SDL_FALSE;
+}
+
 int
 Wayland_VideoInit(_THIS)
 {
@@ -920,12 +939,8 @@ Wayland_VideoInit(_THIS)
     // First roundtrip to receive all registry objects.
     WAYLAND_wl_display_roundtrip(data->display);
 
-#ifdef HAVE_LIBDECOR_H
-    /* Don't have server-side decorations? Try client-side instead. */
-    if (should_use_libdecor(data)) {
-        data->shell.libdecor = libdecor_new(data->display, &libdecor_interface);
-    }
-#endif
+    /* Now that we have all the protocols, load libdecor if applicable */
+    Wayland_LoadLibdecor(data, SDL_FALSE);
 
     // Second roundtrip to receive all output events.
     WAYLAND_wl_display_roundtrip(data->display);
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandvideo.h b/Engine/lib/sdl/src/video/wayland/SDL_waylandvideo.h
index 6f941db80..9b2d6835f 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandvideo.h
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandvideo.h
@@ -122,6 +122,8 @@ extern void SDL_WAYLAND_register_output(struct wl_output *output);
 extern SDL_bool SDL_WAYLAND_own_surface(struct wl_surface *surface);
 extern SDL_bool SDL_WAYLAND_own_output(struct wl_output *output);
 
+extern SDL_bool Wayland_LoadLibdecor(SDL_VideoData *data, SDL_bool ignore_xdg);
+
 #endif /* SDL_waylandvideo_h_ */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandwindow.c b/Engine/lib/sdl/src/video/wayland/SDL_waylandwindow.c
index 0bbae4691..f5d598c62 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandwindow.c
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandwindow.c
@@ -683,6 +683,34 @@ Wayland_PopupWatch(void *data, SDL_Event *event)
     return 1;
 }
 
+static void
+handle_configure_zxdg_decoration(void *data,
+                                 struct zxdg_toplevel_decoration_v1 *zxdg_toplevel_decoration_v1,
+                                 uint32_t mode)
+{
+    SDL_Window *window = (SDL_Window *) data;
+    SDL_WindowData *driverdata = (SDL_WindowData *) window->driverdata;
+
+    /* If the compositor tries to force CSD anyway, bail on direct XDG support
+     * and fall back to libdecor, it will handle these events from then on.
+     *
+     * To do this we have to fully unmap, then map with libdecor loaded.
+     */
+    if (mode == ZXDG_TOPLEVEL_DECORATION_V1_MODE_CLIENT_SIDE) {
+        if (!Wayland_LoadLibdecor(driverdata->waylandData, SDL_TRUE)) {
+            /* libdecor isn't available, so no borders for you... oh well */
+            return;
+        }
+        SDL_HideWindow(window);
+        driverdata->shell_surface_type = WAYLAND_SURFACE_LIBDECOR;
+        SDL_ShowWindow(window);
+    }
+}
+
+static const struct zxdg_toplevel_decoration_v1_listener decoration_listener = {
+    handle_configure_zxdg_decoration
+};
+
 #ifdef HAVE_LIBDECOR_H
 static void
 decoration_frame_configure(struct libdecor_frame *frame,
@@ -1258,6 +1286,9 @@ void Wayland_ShowWindow(_THIS, SDL_Window *window)
         /* Create the window decorations */
         if (!WINDOW_IS_XDG_POPUP(window) && data->shell_surface.xdg.roleobj.toplevel && c->decoration_manager) {
             data->server_decoration = zxdg_decoration_manager_v1_get_toplevel_decoration(c->decoration_manager, data->shell_surface.xdg.roleobj.toplevel);
+            zxdg_toplevel_decoration_v1_add_listener(data->server_decoration,
+                                                     &decoration_listener,
+                                                     window);
         }
     } else {
         /* Nothing to see here, just commit. */
@@ -1628,7 +1659,6 @@ void
 Wayland_SetWindowResizable(_THIS, SDL_Window * window, SDL_bool resizable)
 {
 #ifdef HAVE_LIBDECOR_H
-    SDL_VideoData *data = _this->driverdata;
     const SDL_WindowData *wind = window->driverdata;
 
     if (WINDOW_IS_LIBDECOR(data, window)) {
@@ -1874,6 +1904,22 @@ int Wayland_CreateWindow(_THIS, SDL_Window *window)
     /* We may need to create an idle inhibitor for this new window */
     Wayland_SuspendScreenSaver(_this);
 
+    #define IS_POPUP(window) \
+        (window->flags & (SDL_WINDOW_TOOLTIP | SDL_WINDOW_POPUP_MENU))
+#ifdef HAVE_LIBDECOR_H
+    if (c->shell.libdecor && !IS_POPUP(window)) {
+        data->shell_surface_type = WAYLAND_SURFACE_LIBDECOR;
+    } else
+#endif
+    if (c->shell.xdg) {
+        if (IS_POPUP(window)) {
+            data->shell_surface_type = WAYLAND_SURFACE_XDG_POPUP;
+        } else {
+            data->shell_surface_type = WAYLAND_SURFACE_XDG_TOPLEVEL;
+        }
+    } /* All other cases will be WAYLAND_SURFACE_UNKNOWN */
+    #undef IS_POPUP
+
     return 0;
 }
 
diff --git a/Engine/lib/sdl/src/video/wayland/SDL_waylandwindow.h b/Engine/lib/sdl/src/video/wayland/SDL_waylandwindow.h
index b1ba98cf9..74c3c09eb 100644
--- a/Engine/lib/sdl/src/video/wayland/SDL_waylandwindow.h
+++ b/Engine/lib/sdl/src/video/wayland/SDL_waylandwindow.h
@@ -32,32 +32,11 @@
 
 struct SDL_WaylandInput;
 
-typedef struct {
-    struct xdg_surface *surface;
-    union {
-        struct xdg_toplevel *toplevel;
-        struct {
-            struct xdg_popup *popup;
-            struct xdg_positioner *positioner;
-            Uint32 parentID;
-            SDL_Window *child;
-        } popup;
-    } roleobj;
-    SDL_bool initial_configure_seen;
-} SDL_xdg_shell_surface;
-
+/* TODO: Remove these helpers, they're from before we had shell_surface_type */
 #define WINDOW_IS_XDG_POPUP(window) \
-    (window->flags & (SDL_WINDOW_TOOLTIP | SDL_WINDOW_POPUP_MENU))
-
-#ifdef HAVE_LIBDECOR_H
-typedef struct {
-    struct libdecor_frame *frame;
-    SDL_bool initial_configure_seen;
-} SDL_libdecor_surface;
-
-#define WINDOW_IS_LIBDECOR(viddata, window) \
-    (viddata->shell.libdecor && !WINDOW_IS_XDG_POPUP(window))
-#endif
+    (((SDL_WindowData*) window->driverdata)->shell_surface_type == WAYLAND_SURFACE_XDG_POPUP)
+#define WINDOW_IS_LIBDECOR(ignoreme, window) \
+    (((SDL_WindowData*) window->driverdata)->shell_surface_type == WAYLAND_SURFACE_LIBDECOR)
 
 typedef struct {
     SDL_Window *sdlwindow;
@@ -66,12 +45,35 @@ typedef struct {
     struct wl_callback *frame_callback;
     struct wl_event_queue *frame_event_queue;
     struct wl_surface *frame_surface_wrapper;
+
     union {
 #ifdef HAVE_LIBDECOR_H
-        SDL_libdecor_surface libdecor;
+        struct {
+            struct libdecor_frame *frame;
+            SDL_bool initial_configure_seen;
+        } libdecor;
 #endif
-        SDL_xdg_shell_surface xdg;
+        struct {
+            struct xdg_surface *surface;
+            union {
+                struct xdg_toplevel *toplevel;
+                struct {
+                    struct xdg_popup *popup;
+                    struct xdg_positioner *positioner;
+                    Uint32 parentID;
+                    SDL_Window *child;
+                } popup;
+            } roleobj;
+            SDL_bool initial_configure_seen;
+        } xdg;
     } shell_surface;
+    enum {
+        WAYLAND_SURFACE_UNKNOWN = 0,
+        WAYLAND_SURFACE_XDG_TOPLEVEL,
+        WAYLAND_SURFACE_XDG_POPUP,
+        WAYLAND_SURFACE_LIBDECOR
+    } shell_surface_type;
+
     struct wl_egl_window *egl_window;
     struct SDL_WaylandInput *keyboard_device;
 #if SDL_VIDEO_OPENGL_EGL
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowsevents.c b/Engine/lib/sdl/src/video/windows/SDL_windowsevents.c
index ebd0dd1f9..084bb9a96 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowsevents.c
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowsevents.c
@@ -29,6 +29,7 @@
 #include "SDL_timer.h"
 #include "SDL_vkeys.h"
 #include "SDL_hints.h"
+#include "SDL_main.h"
 #include "../../events/SDL_events_c.h"
 #include "../../events/SDL_touch_c.h"
 #include "../../events/scancodes_windows.h"
@@ -1370,10 +1371,15 @@ WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
         {
             SDL_Window *window = data->window;
             if (window->hit_test) {
-                POINT winpoint = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
+                POINT winpoint;
+                winpoint.x = GET_X_LPARAM(lParam);
+                winpoint.y = GET_Y_LPARAM(lParam);
                 if (ScreenToClient(hwnd, &winpoint)) {
-                    const SDL_Point point = { (int) winpoint.x, (int) winpoint.y };
-                    const SDL_HitTestResult rc = window->hit_test(window, &point, window->hit_test_data);
+                    SDL_Point point;
+                    SDL_HitTestResult rc;
+                    point.x = winpoint.x;
+                    point.y = winpoint.y;
+                    rc = window->hit_test(window, &point, window->hit_test_data);
                     switch (rc) {
                         #define POST_HIT_TEST(ret) { SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_HIT_TEST, 0, 0); return ret; }
                         case SDL_HITTEST_DRAGGABLE: POST_HIT_TEST(HTCAPTION);
diff --git a/Engine/lib/sdl/src/video/windows/SDL_windowsvideo.c b/Engine/lib/sdl/src/video/windows/SDL_windowsvideo.c
index 4bd2a9831..62ad1c964 100644
--- a/Engine/lib/sdl/src/video/windows/SDL_windowsvideo.c
+++ b/Engine/lib/sdl/src/video/windows/SDL_windowsvideo.c
@@ -265,6 +265,22 @@ WIN_VideoQuit(_THIS)
 #define D3D_DEBUG_INFO
 #include <d3d9.h>
 
+#ifdef D3D_DEBUG_INFO
+#ifndef D3D_SDK_VERSION
+#define D3D_SDK_VERSION (32 | 0x80000000)
+#endif
+#ifndef D3D9b_SDK_VERSION
+#define D3D9b_SDK_VERSION (31 | 0x80000000)
+#endif
+#else /**/
+#ifndef D3D_SDK_VERSION
+#define D3D_SDK_VERSION 32
+#endif
+#ifndef D3D9b_SDK_VERSION
+#define D3D9b_SDK_VERSION 31
+#endif
+#endif
+
 SDL_bool
 D3D_LoadDLL(void **pD3DDLL, IDirect3D9 **pDirect3D9Interface)
 {
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11dyn.c b/Engine/lib/sdl/src/video/x11/SDL_x11dyn.c
index 29a8186fa..4bfef21e3 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11dyn.c
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11dyn.c
@@ -47,9 +47,6 @@ typedef struct
 #ifndef SDL_VIDEO_DRIVER_X11_DYNAMIC_XCURSOR
 #define SDL_VIDEO_DRIVER_X11_DYNAMIC_XCURSOR NULL
 #endif
-#ifndef SDL_VIDEO_DRIVER_X11_DYNAMIC_XINERAMA
-#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XINERAMA NULL
-#endif
 #ifndef SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT2
 #define SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT2 NULL
 #endif
@@ -62,20 +59,15 @@ typedef struct
 #ifndef SDL_VIDEO_DRIVER_X11_DYNAMIC_XSS
 #define SDL_VIDEO_DRIVER_X11_DYNAMIC_XSS NULL
 #endif
-#ifndef SDL_VIDEO_DRIVER_X11_DYNAMIC_XVIDMODE
-#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XVIDMODE NULL
-#endif
 
 static x11dynlib x11libs[] = {
     {NULL, SDL_VIDEO_DRIVER_X11_DYNAMIC},
     {NULL, SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT},
     {NULL, SDL_VIDEO_DRIVER_X11_DYNAMIC_XCURSOR},
-    {NULL, SDL_VIDEO_DRIVER_X11_DYNAMIC_XINERAMA},
     {NULL, SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT2},
     {NULL, SDL_VIDEO_DRIVER_X11_DYNAMIC_XFIXES},
     {NULL, SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR},
-    {NULL, SDL_VIDEO_DRIVER_X11_DYNAMIC_XSS},
-    {NULL, SDL_VIDEO_DRIVER_X11_DYNAMIC_XVIDMODE}
+    {NULL, SDL_VIDEO_DRIVER_X11_DYNAMIC_XSS}
 };
 
 static void *
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11dyn.h b/Engine/lib/sdl/src/video/x11/SDL_x11dyn.h
index c2678bfed..feac35fa9 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11dyn.h
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11dyn.h
@@ -52,9 +52,6 @@
 #if SDL_VIDEO_DRIVER_X11_XDBE
 #include <X11/extensions/Xdbe.h>
 #endif
-#if SDL_VIDEO_DRIVER_X11_XINERAMA
-#include <X11/extensions/Xinerama.h>
-#endif
 #if SDL_VIDEO_DRIVER_X11_XINPUT2
 #include <X11/extensions/XInput2.h>
 #endif
@@ -70,9 +67,6 @@
 #if SDL_VIDEO_DRIVER_X11_XSHAPE
 #include <X11/extensions/shape.h>
 #endif
-#if SDL_VIDEO_DRIVER_X11_XVIDMODE
-#include <X11/extensions/xf86vmode.h>
-#endif
 
 #ifdef __cplusplus
 extern "C"
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11keyboard.c b/Engine/lib/sdl/src/video/x11/SDL_x11keyboard.c
index c84bcc798..9d9f3f9f0 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11keyboard.c
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11keyboard.c
@@ -37,7 +37,7 @@
 #include <locale.h>
 #endif
 
-/* *INDENT-OFF* */
+/* *INDENT-OFF* */ /* clang-format off */
 static const struct {
     KeySym keysym;
     SDL_Scancode scancode;
@@ -160,7 +160,7 @@ static const struct
     { xfree86_scancode_table2, SDL_arraysize(xfree86_scancode_table2) },
     { xvnc_scancode_table, SDL_arraysize(xvnc_scancode_table) },
 };
-/* *INDENT-OFF* */
+/* *INDENT-OFF* */ /* clang-format off */
 
 /* This function only works for keyboards in US QWERTY layout */
 static SDL_Scancode
@@ -267,13 +267,6 @@ X11_InitKeyboard(_THIS)
     int best_index;
     int distance;
     Bool xkb_repeat = 0;
-    XKeyboardState values;
-    SDL_zero(values);
-    values.global_auto_repeat = AutoRepeatModeOff;
-    
-    X11_XGetKeyboardControl(data->display, &values);
-    if (values.global_auto_repeat != AutoRepeatModeOn)
-        X11_XAutoRepeatOn(data->display);
 
 #if SDL_VIDEO_DRIVER_X11_HAS_XKBKEYCODETOKEYSYM
     {
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11modes.c b/Engine/lib/sdl/src/video/x11/SDL_x11modes.c
index f2cbdb45f..d740f66ae 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11modes.c
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11modes.c
@@ -148,61 +148,29 @@ X11_GetPixelFormatFromVisualInfo(Display * display, XVisualInfo * vinfo)
     return SDL_PIXELFORMAT_UNKNOWN;
 }
 
-#if SDL_VIDEO_DRIVER_X11_XINERAMA
-static SDL_bool
-CheckXinerama(Display * display, int *major, int *minor)
-{
-    int event_base = 0;
-    int error_base = 0;
-
-    /* Default the extension not available */
-    *major = *minor = 0;
-
-    /* Allow environment override */
-    if (!SDL_GetHintBoolean(SDL_HINT_VIDEO_X11_XINERAMA, SDL_TRUE)) {
-#ifdef X11MODES_DEBUG
-        printf("Xinerama disabled due to hint\n");
-#endif
-        return SDL_FALSE;
-    }
-
-    if (!SDL_X11_HAVE_XINERAMA) {
-#ifdef X11MODES_DEBUG
-        printf("Xinerama support not available\n");
-#endif
-        return SDL_FALSE;
-    }
-
-    /* Query the extension version */
-    if (!X11_XineramaQueryExtension(display, &event_base, &error_base) ||
-        !X11_XineramaQueryVersion(display, major, minor) ||
-        !X11_XineramaIsActive(display)) {
-#ifdef X11MODES_DEBUG
-        printf("Xinerama not active on the display\n");
-#endif
-        return SDL_FALSE;
-    }
-#ifdef X11MODES_DEBUG
-    printf("Xinerama available at version %d.%d!\n", *major, *minor);
-#endif
-    return SDL_TRUE;
-}
-
-/* !!! FIXME: remove this later. */
-/* we have a weird bug where XineramaQueryScreens() throws an X error, so this
-   is here to help track it down (and not crash, too!). */
-static SDL_bool xinerama_triggered_error = SDL_FALSE;
 static int
-X11_XineramaFailed(Display * d, XErrorEvent * e)
+GetXftDPI(Display* dpy)
 {
-    xinerama_triggered_error = SDL_TRUE;
-    fprintf(stderr, "XINERAMA X ERROR: type=%d serial=%lu err=%u req=%u minor=%u\n",
-            e->type, e->serial, (unsigned int) e->error_code,
-            (unsigned int) e->request_code, (unsigned int) e->minor_code);
-    fflush(stderr);
-    return 0;
+    char* xdefault_resource;
+    int xft_dpi, err;
+
+    xdefault_resource = X11_XGetDefault(dpy, "Xft", "dpi");
+
+    if(!xdefault_resource) {
+        return 0;
+    }
+
+    /*
+     * It's possible for SDL_atoi to call SDL_strtol, if it fails due to a
+     * overflow or an underflow, it will return LONG_MAX or LONG_MIN and set
+     * errno to ERANGE. So we need to check for this so we dont get crazy dpi
+     * values
+     */
+    xft_dpi = SDL_atoi(xdefault_resource);
+    err = errno;
+
+    return err == ERANGE ? 0 : xft_dpi;
 }
-#endif /* SDL_VIDEO_DRIVER_X11_XINERAMA */
 
 #if SDL_VIDEO_DRIVER_X11_XRANDR
 static SDL_bool
@@ -345,30 +313,6 @@ SetXRandRDisplayName(Display *dpy, Atom EDID, char *name, const size_t namelen,
 #endif
 }
 
-static int
-GetXftDPI(Display* dpy)
-{
-    char* xdefault_resource;
-    int xft_dpi, err;
-
-    xdefault_resource = X11_XGetDefault(dpy, "Xft", "dpi");
-
-    if(!xdefault_resource) {
-        return 0;
-    }
-
-    /*
-     * It's possible for SDL_atoi to call SDL_strtol, if it fails due to a
-     * overflow or an underflow, it will return LONG_MAX or LONG_MIN and set
-     * errno to ERANGE. So we need to check for this so we dont get crazy dpi
-     * values
-     */
-    xft_dpi = SDL_atoi(xdefault_resource);
-    err = errno;
-
-    return err == ERANGE ? 0 : xft_dpi;
-}
-
 static int
 X11_InitModes_XRandR(_THIS)
 {
@@ -506,7 +450,7 @@ X11_InitModes_XRandR(_THIS)
                 displaydata->scanline_pad = scanline_pad;
                 displaydata->x = display_x;
                 displaydata->y = display_y;
-                displaydata->use_xrandr = 1;
+                displaydata->use_xrandr = SDL_TRUE;
                 displaydata->xrandr_output = res->outputs[output];
 
                 SetXRandRModeInfo(dpy, res, output_crtc, modeID, &mode);
@@ -534,343 +478,124 @@ X11_InitModes_XRandR(_THIS)
 }
 #endif /* SDL_VIDEO_DRIVER_X11_XRANDR */
 
-#if SDL_VIDEO_DRIVER_X11_XVIDMODE
-static SDL_bool
-CheckVidMode(Display * display, int *major, int *minor)
+/* This is used if there's no better functionality--like XRandR--to use.
+   It won't attempt to supply different display modes at all, but it can
+   enumerate the current displays and their current sizes. */
+static int X11_InitModes_StdXlib(_THIS)
 {
-    int vm_event, vm_error = -1;
-    /* Default the extension not available */
-    *major = *minor = 0;
+    /* !!! FIXME: a lot of copy/paste from X11_InitModes_XRandR in this function. */
+    SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
+    Display *dpy = data->display;
+    const int default_screen = DefaultScreen(dpy);
+    Screen *screen = ScreenOfDisplay(dpy, default_screen);
+    int display_mm_width, display_mm_height, xft_dpi, scanline_pad, n, i;
+    SDL_DisplayModeData *modedata;
+    SDL_DisplayData *displaydata;
+    SDL_DisplayMode mode;
+    XPixmapFormatValues *pixmapformats;
+    Uint32 pixelformat;
+    XVisualInfo vinfo;
+    SDL_VideoDisplay display;
 
-    /* Allow environment override */
-    if (!SDL_GetHintBoolean(SDL_HINT_VIDEO_X11_XVIDMODE, SDL_TRUE)) {
-#ifdef X11MODES_DEBUG
-        printf("XVidMode disabled due to hint\n");
-#endif
-        return SDL_FALSE;
+    /* note that generally even if you have a multiple physical monitors, ScreenCount(dpy) still only reports ONE screen. */
+
+    if (get_visualinfo(dpy, default_screen, &vinfo) < 0) {
+        return SDL_SetError("Failed to find an X11 visual for the primary display");
     }
 
-    if (!SDL_X11_HAVE_XVIDMODE) {
-#ifdef X11MODES_DEBUG
-        printf("XVidMode support not available\n");
-#endif
-        return SDL_FALSE;
+    pixelformat = X11_GetPixelFormatFromVisualInfo(dpy, &vinfo);
+    if (SDL_ISPIXELFORMAT_INDEXED(pixelformat)) {
+        return SDL_SetError("Palettized video modes are no longer supported");
     }
 
-    /* Query the extension version */
-    if (!X11_XF86VidModeQueryExtension(display, &vm_event, &vm_error)
-        || !X11_XF86VidModeQueryVersion(display, major, minor)) {
-#ifdef X11MODES_DEBUG
-        printf("XVidMode not active on the display\n");
-#endif
-        return SDL_FALSE;
+    SDL_zero(mode);
+    mode.w = WidthOfScreen(screen);
+    mode.h = HeightOfScreen(screen);
+    mode.format = pixelformat;
+    mode.refresh_rate = 0;  /* don't know it, sorry. */
+
+    displaydata = (SDL_DisplayData *) SDL_calloc(1, sizeof(*displaydata));
+    if (!displaydata) {
+        return SDL_OutOfMemory();
     }
-#ifdef X11MODES_DEBUG
-    printf("XVidMode available at version %d.%d!\n", *major, *minor);
-#endif
-    return SDL_TRUE;
+
+    modedata = (SDL_DisplayModeData *) SDL_calloc(1, sizeof(SDL_DisplayModeData));
+    if (!modedata) {
+        SDL_free(displaydata);
+        return SDL_OutOfMemory();
+    }
+    mode.driverdata = modedata;
+
+    display_mm_width = WidthMMOfScreen(screen);
+    display_mm_height = HeightMMOfScreen(screen);
+
+    displaydata->screen = default_screen;
+    displaydata->visual = vinfo.visual;
+    displaydata->depth = vinfo.depth;
+    displaydata->hdpi = display_mm_width ? (((float) mode.w) * 25.4f / display_mm_width) : 0.0f;
+    displaydata->vdpi = display_mm_height ? (((float) mode.h) * 25.4f / display_mm_height) : 0.0f;
+    displaydata->ddpi = SDL_ComputeDiagonalDPI(mode.w, mode.h, ((float) display_mm_width) / 25.4f,((float) display_mm_height) / 25.4f);
+
+    xft_dpi = GetXftDPI(dpy);
+    if(xft_dpi > 0) {
+        displaydata->hdpi = (float)xft_dpi;
+        displaydata->vdpi = (float)xft_dpi;
+    }
+
+    scanline_pad = SDL_BYTESPERPIXEL(pixelformat) * 8;
+    pixmapformats = X11_XListPixmapFormats(dpy, &n);
+    if (pixmapformats) {
+        for (i = 0; i < n; ++i) {
+            if (pixmapformats[i].depth == vinfo.depth) {
+                scanline_pad = pixmapformats[i].scanline_pad;
+                break;
+            }
+        }
+        X11_XFree(pixmapformats);
+    }
+
+    displaydata->scanline_pad = scanline_pad;
+    displaydata->x = 0;
+    displaydata->y = 0;
+    displaydata->use_xrandr = SDL_FALSE;
+
+    SDL_zero(display);
+    display.name = (char *) "Generic X11 Display";  /* this is just copied and thrown away, it's safe to cast to char* here. */
+    display.desktop_mode = mode;
+    display.current_mode = mode;
+    display.driverdata = displaydata;
+    SDL_AddVideoDisplay(&display, SDL_FALSE);
+
+    return 0;
 }
 
-static
-Bool XF86VidModeGetModeInfo(Display * dpy, int scr,
-                                       XF86VidModeModeInfo* info)
-{
-    Bool retval;
-    int dotclock;
-    XF86VidModeModeLine l;
-    SDL_zerop(info);
-    SDL_zero(l);
-    retval = X11_XF86VidModeGetModeLine(dpy, scr, &dotclock, &l);
-    info->dotclock = dotclock;
-    info->hdisplay = l.hdisplay;
-    info->hsyncstart = l.hsyncstart;
-    info->hsyncend = l.hsyncend;
-    info->htotal = l.htotal;
-    info->hskew = l.hskew;
-    info->vdisplay = l.vdisplay;
-    info->vsyncstart = l.vsyncstart;
-    info->vsyncend = l.vsyncend;
-    info->vtotal = l.vtotal;
-    info->flags = l.flags;
-    info->privsize = l.privsize;
-    info->private = l.private;
-    return retval;
-}
-
-static int
-CalculateXVidModeRefreshRate(const XF86VidModeModeInfo * info)
-{
-    return (info->htotal
-            && info->vtotal) ? (1000 * info->dotclock / (info->htotal *
-                                                         info->vtotal)) : 0;
-}
-
-static SDL_bool
-SetXVidModeModeInfo(const XF86VidModeModeInfo *info, SDL_DisplayMode *mode)
-{
-    mode->w = info->hdisplay;
-    mode->h = info->vdisplay;
-    mode->refresh_rate = CalculateXVidModeRefreshRate(info);
-    ((SDL_DisplayModeData*)mode->driverdata)->vm_mode = *info;
-    return SDL_TRUE;
-}
-#endif /* SDL_VIDEO_DRIVER_X11_XVIDMODE */
 
 int
 X11_InitModes(_THIS)
 {
-    SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
-    int snum, screen, screencount = 0;
-#if SDL_VIDEO_DRIVER_X11_XINERAMA
-    int xinerama_major, xinerama_minor;
-    int use_xinerama = 0;
-    XineramaScreenInfo *xinerama = NULL;
-#endif
+    /* XRandR is the One True Modern Way to do this on X11. If this
+       fails, we just won't report any display modes except the current
+       desktop size. */
 #if SDL_VIDEO_DRIVER_X11_XRANDR
-    int xrandr_major, xrandr_minor;
-#endif
-#if SDL_VIDEO_DRIVER_X11_XVIDMODE
-    int vm_major, vm_minor;
-    int use_vidmode = 0;
-#endif
-
-/* XRandR is the One True Modern Way to do this on X11. If it's enabled and
-   available, don't even look at other ways of doing things. */
-#if SDL_VIDEO_DRIVER_X11_XRANDR
-    /* require at least XRandR v1.3 */
-    if (CheckXRandR(data->display, &xrandr_major, &xrandr_minor) &&
-        (xrandr_major >= 2 || (xrandr_major == 1 && xrandr_minor >= 3))) {
-        if (X11_InitModes_XRandR(_this) == 0)
-            return 0;
+    {
+        SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
+        int xrandr_major, xrandr_minor;
+        /* require at least XRandR v1.3 */
+        if (CheckXRandR(data->display, &xrandr_major, &xrandr_minor) &&
+            (xrandr_major >= 2 || (xrandr_major == 1 && xrandr_minor >= 3))) {
+            return X11_InitModes_XRandR(_this);
+        }
     }
 #endif /* SDL_VIDEO_DRIVER_X11_XRANDR */
 
-/* !!! FIXME: eventually remove support for Xinerama and XVidMode (everything below here). */
-
-    /* This is a workaround for some apps (UnrealEngine4, for example) until
-       we sort out the ramifications of removing XVidMode support outright.
-       This block should be removed with the XVidMode support. */
-    {
-        if (SDL_GetHintBoolean("SDL_VIDEO_X11_REQUIRE_XRANDR", SDL_FALSE)) {
-            #if SDL_VIDEO_DRIVER_X11_XRANDR
-            return SDL_SetError("XRandR support is required but not available");
-            #else
-            return SDL_SetError("XRandR support is required but not built into SDL!");
-            #endif
-        }
-    }
-
-#if SDL_VIDEO_DRIVER_X11_XINERAMA
-    /* Query Xinerama extention
-     * NOTE: This works with Nvidia Twinview correctly, but you need version 302.17 (released on June 2012)
-     *       or newer of the Nvidia binary drivers
-     */
-    if (CheckXinerama(data->display, &xinerama_major, &xinerama_minor)) {
-        int (*handler) (Display *, XErrorEvent *);
-        X11_XSync(data->display, False);
-        handler = X11_XSetErrorHandler(X11_XineramaFailed);
-        xinerama = X11_XineramaQueryScreens(data->display, &screencount);
-        X11_XSync(data->display, False);
-        X11_XSetErrorHandler(handler);
-        if (xinerama_triggered_error) {
-            xinerama = 0;
-        }
-        if (xinerama) {
-            use_xinerama = xinerama_major * 100 + xinerama_minor;
-        }
-    }
-    if (!xinerama) {
-        screencount = ScreenCount(data->display);
-    }
-#else
-    screencount = ScreenCount(data->display);
-#endif /* SDL_VIDEO_DRIVER_X11_XINERAMA */
-
-#if SDL_VIDEO_DRIVER_X11_XVIDMODE
-    if (CheckVidMode(data->display, &vm_major, &vm_minor)) {
-        use_vidmode = vm_major * 100 + vm_minor;
-    }
-#endif /* SDL_VIDEO_DRIVER_X11_XVIDMODE */
-
-    for (snum = 0; snum < screencount; ++snum) {
-        XVisualInfo vinfo;
-        SDL_VideoDisplay display;
-        SDL_DisplayData *displaydata;
-        SDL_DisplayMode mode;
-        SDL_DisplayModeData *modedata;
-        XPixmapFormatValues *pixmapFormats;
-        char display_name[128];
-        int i, n;
-
-        /* Re-order screens to always put default screen first */
-        if (snum == 0) {
-            screen = DefaultScreen(data->display);
-        } else if (snum == DefaultScreen(data->display)) {
-            screen = 0;
-        } else {
-            screen = snum;
-        }
-
-#if SDL_VIDEO_DRIVER_X11_XINERAMA
-        if (xinerama) {
-            if (get_visualinfo(data->display, 0, &vinfo) < 0) {
-                continue;
-            }
-        } else {
-            if (get_visualinfo(data->display, screen, &vinfo) < 0) {
-                continue;
-            }
-        }
-#else
-        if (get_visualinfo(data->display, screen, &vinfo) < 0) {
-            continue;
-        }
-#endif
-
-        displaydata = (SDL_DisplayData *) SDL_calloc(1, sizeof(*displaydata));
-        if (!displaydata) {
-            continue;
-        }
-        display_name[0] = '\0';
-
-        mode.format = X11_GetPixelFormatFromVisualInfo(data->display, &vinfo);
-        if (SDL_ISPIXELFORMAT_INDEXED(mode.format)) {
-            /* We don't support palettized modes now */
-            SDL_free(displaydata);
-            continue;
-        }
-#if SDL_VIDEO_DRIVER_X11_XINERAMA
-        if (xinerama) {
-            mode.w = xinerama[screen].width;
-            mode.h = xinerama[screen].height;
-        } else {
-            mode.w = DisplayWidth(data->display, screen);
-            mode.h = DisplayHeight(data->display, screen);
-        }
-#else
-        mode.w = DisplayWidth(data->display, screen);
-        mode.h = DisplayHeight(data->display, screen);
-#endif
-        mode.refresh_rate = 0;
-
-        modedata = (SDL_DisplayModeData *) SDL_calloc(1, sizeof(SDL_DisplayModeData));
-        if (!modedata) {
-            SDL_free(displaydata);
-            continue;
-        }
-        mode.driverdata = modedata;
-
-#if SDL_VIDEO_DRIVER_X11_XINERAMA
-        /* Most of SDL's calls to X11 are unwaware of Xinerama, and to X11 standard calls, when Xinerama is active,
-         * there's only one screen available. So we force the screen number to zero and
-         * let Xinerama specific code handle specific functionality using displaydata->xinerama_info
-         */
-        if (use_xinerama) {
-            displaydata->screen = 0;
-            displaydata->use_xinerama = use_xinerama;
-            displaydata->xinerama_info = xinerama[screen];
-            displaydata->xinerama_screen = screen;
-        }
-        else displaydata->screen = screen;
-#else
-        displaydata->screen = screen;
-#endif
-        displaydata->visual = vinfo.visual;
-        displaydata->depth = vinfo.depth;
-
-        /* We use the displaydata screen index here so that this works
-           for both the Xinerama case, where we get the overall DPI,
-           and the regular X11 screen info case. */
-        displaydata->hdpi = (float)DisplayWidth(data->display, displaydata->screen) * 25.4f /
-            DisplayWidthMM(data->display, displaydata->screen);
-        displaydata->vdpi = (float)DisplayHeight(data->display, displaydata->screen) * 25.4f /
-            DisplayHeightMM(data->display, displaydata->screen);
-        displaydata->ddpi = SDL_ComputeDiagonalDPI(DisplayWidth(data->display, displaydata->screen),
-                                                   DisplayHeight(data->display, displaydata->screen),
-                                                   (float)DisplayWidthMM(data->display, displaydata->screen) / 25.4f,
-                                                   (float)DisplayHeightMM(data->display, displaydata->screen) / 25.4f);
-
-        displaydata->scanline_pad = SDL_BYTESPERPIXEL(mode.format) * 8;
-        pixmapFormats = X11_XListPixmapFormats(data->display, &n);
-        if (pixmapFormats) {
-            for (i = 0; i < n; ++i) {
-                if (pixmapFormats[i].depth == displaydata->depth) {
-                    displaydata->scanline_pad = pixmapFormats[i].scanline_pad;
-                    break;
-                }
-            }
-            X11_XFree(pixmapFormats);
-        }
-
-#if SDL_VIDEO_DRIVER_X11_XINERAMA
-        if (use_xinerama) {
-            displaydata->x = xinerama[screen].x_org;
-            displaydata->y = xinerama[screen].y_org;
-        }
-        else
-#endif
-        {
-            displaydata->x = 0;
-            displaydata->y = 0;
-        }
-
-#if SDL_VIDEO_DRIVER_X11_XVIDMODE
-        if (!displaydata->use_xrandr &&
-#if SDL_VIDEO_DRIVER_X11_XINERAMA
-            /* XVidMode only works on the screen at the origin */
-            (!displaydata->use_xinerama ||
-             (displaydata->x == 0 && displaydata->y == 0)) &&
-#endif
-            use_vidmode) {
-            displaydata->use_vidmode = use_vidmode;
-            if (displaydata->use_xinerama) {
-                displaydata->vidmode_screen = 0;
-            } else {
-                displaydata->vidmode_screen = screen;
-            }
-            XF86VidModeGetModeInfo(data->display, displaydata->vidmode_screen, &modedata->vm_mode);
-        }
-#endif /* SDL_VIDEO_DRIVER_X11_XVIDMODE */
-
-        SDL_zero(display);
-        if (*display_name) {
-            display.name = display_name;
-        }
-        display.desktop_mode = mode;
-        display.current_mode = mode;
-        display.driverdata = displaydata;
-        SDL_AddVideoDisplay(&display, SDL_FALSE);
-    }
-
-#if SDL_VIDEO_DRIVER_X11_XINERAMA
-    if (xinerama) X11_XFree(xinerama);
-#endif
-
-    if (_this->num_displays == 0) {
-        return SDL_SetError("No available displays");
-    }
-
-#if SDL_VIDEO_DRIVER_X11_XVIDMODE
-    if (use_vidmode) {  /* we intend to remove support for XVidMode soon. */
-        SDL_LogWarn(SDL_LOG_CATEGORY_VIDEO, "SDL is using XVidMode to manage your displays!");
-        SDL_LogWarn(SDL_LOG_CATEGORY_VIDEO, "This almost always means either SDL was misbuilt");
-        SDL_LogWarn(SDL_LOG_CATEGORY_VIDEO, "or your X server is insufficient. Please check your setup!");
-        SDL_LogWarn(SDL_LOG_CATEGORY_VIDEO, "Fullscreen and/or multiple displays will not work well.");
-    }
-#endif
-
-    return 0;
+    /* still here? Just set up an extremely basic display. */
+    return X11_InitModes_StdXlib(_this);
 }
 
 void
 X11_GetDisplayModes(_THIS, SDL_VideoDisplay * sdl_display)
 {
-    Display *display = ((SDL_VideoData *) _this->driverdata)->display;
     SDL_DisplayData *data = (SDL_DisplayData *) sdl_display->driverdata;
-#if SDL_VIDEO_DRIVER_X11_XVIDMODE
-    int nmodes;
-    XF86VidModeModeInfo ** modes;
-#endif
     SDL_DisplayMode mode;
 
     /* Unfortunately X11 requires the window to be created with the correct
@@ -882,54 +607,9 @@ X11_GetDisplayModes(_THIS, SDL_VideoDisplay * sdl_display)
     mode.format = sdl_display->current_mode.format;
     mode.driverdata = NULL;
 
-#if SDL_VIDEO_DRIVER_X11_XINERAMA
-    if (data->use_xinerama) {
-        int screen_w;
-        int screen_h;
-
-        screen_w = DisplayWidth(display, data->screen);
-        screen_h = DisplayHeight(display, data->screen);
-
-        if (data->use_vidmode && !data->xinerama_info.x_org && !data->xinerama_info.y_org &&
-           (screen_w > data->xinerama_info.width || screen_h > data->xinerama_info.height)) {
-            SDL_DisplayModeData *modedata;
-            /* Add the full (both screens combined) xinerama mode only on the display that starts at 0,0
-             * if we're using vidmode.
-             */
-            mode.w = screen_w;
-            mode.h = screen_h;
-            mode.refresh_rate = 0;
-            modedata = (SDL_DisplayModeData *) SDL_calloc(1, sizeof(SDL_DisplayModeData));
-            if (modedata) {
-                *modedata = *(SDL_DisplayModeData *)sdl_display->desktop_mode.driverdata;
-            }
-            mode.driverdata = modedata;
-            if (!SDL_AddDisplayMode(sdl_display, &mode)) {
-                SDL_free(modedata);
-            }
-        }
-        else if (!data->use_xrandr)
-        {
-            SDL_DisplayModeData *modedata;
-            /* Add the current mode of each monitor otherwise if we can't get them from xrandr */
-            mode.w = data->xinerama_info.width;
-            mode.h = data->xinerama_info.height;
-            mode.refresh_rate = 0;
-            modedata = (SDL_DisplayModeData *) SDL_calloc(1, sizeof(SDL_DisplayModeData));
-            if (modedata) {
-                *modedata = *(SDL_DisplayModeData *)sdl_display->desktop_mode.driverdata;
-            }
-            mode.driverdata = modedata;
-            if (!SDL_AddDisplayMode(sdl_display, &mode)) {
-                SDL_free(modedata);
-            }
-        }
-
-    }
-#endif /* SDL_VIDEO_DRIVER_X11_XINERAMA */
-
 #if SDL_VIDEO_DRIVER_X11_XRANDR
     if (data->use_xrandr) {
+        Display *display = ((SDL_VideoData *) _this->driverdata)->display;
         XRRScreenResources *res;
 
         res = X11_XRRGetScreenResources (display, RootWindow(display, data->screen));
@@ -960,37 +640,7 @@ X11_GetDisplayModes(_THIS, SDL_VideoDisplay * sdl_display)
     }
 #endif /* SDL_VIDEO_DRIVER_X11_XRANDR */
 
-#if SDL_VIDEO_DRIVER_X11_XVIDMODE
-    if (data->use_vidmode &&
-        X11_XF86VidModeGetAllModeLines(display, data->vidmode_screen, &nmodes, &modes)) {
-        int i;
-        SDL_DisplayModeData *modedata;
-
-#ifdef X11MODES_DEBUG
-        printf("VidMode modes: (unsorted)\n");
-        for (i = 0; i < nmodes; ++i) {
-            printf("Mode %d: %d x %d @ %d, flags: 0x%x\n", i,
-                   modes[i]->hdisplay, modes[i]->vdisplay,
-                   CalculateXVidModeRefreshRate(modes[i]), modes[i]->flags);
-        }
-#endif
-        for (i = 0; i < nmodes; ++i) {
-            modedata = (SDL_DisplayModeData *) SDL_calloc(1, sizeof(SDL_DisplayModeData));
-            if (!modedata) {
-                continue;
-            }
-            mode.driverdata = modedata;
-
-            if (!SetXVidModeModeInfo(modes[i], &mode) || !SDL_AddDisplayMode(sdl_display, &mode)) {
-                SDL_free(modedata);
-            }
-        }
-        X11_XFree(modes);
-        return;
-    }
-#endif /* SDL_VIDEO_DRIVER_X11_XVIDMODE */
-
-    if (!data->use_xrandr && !data->use_vidmode) {
+    if (!data->use_xrandr) {
         SDL_DisplayModeData *modedata;
         /* Add the desktop mode */
         mode = sdl_display->desktop_mode;
@@ -1005,6 +655,7 @@ X11_GetDisplayModes(_THIS, SDL_VideoDisplay * sdl_display)
     }
 }
 
+#if SDL_VIDEO_DRIVER_X11_XRANDR
 /* This catches an error from XRRSetScreenSize, as a workaround for now. */
 /* !!! FIXME: remove this later when we have a better solution. */
 static int (*PreXRRSetScreenSizeErrorHandler)(Display *, XErrorEvent *) = NULL;
@@ -1019,20 +670,21 @@ SDL_XRRSetScreenSizeErrHandler(Display *d, XErrorEvent *e)
 
     return PreXRRSetScreenSizeErrorHandler(d, e);
 }
+#endif
 
 int
 X11_SetDisplayMode(_THIS, SDL_VideoDisplay * sdl_display, SDL_DisplayMode * mode)
 {
     SDL_VideoData *viddata = (SDL_VideoData *) _this->driverdata;
-    Display *display = viddata->display;
     SDL_DisplayData *data = (SDL_DisplayData *) sdl_display->driverdata;
-    SDL_DisplayModeData *modedata = (SDL_DisplayModeData *)mode->driverdata;
-    int mm_width, mm_height;
 
     viddata->last_mode_change_deadline = SDL_GetTicks() + (PENDING_FOCUS_TIME * 2);
 
 #if SDL_VIDEO_DRIVER_X11_XRANDR
     if (data->use_xrandr) {
+        Display *display = viddata->display;
+        SDL_DisplayModeData *modedata = (SDL_DisplayModeData *)mode->driverdata;
+        int mm_width, mm_height;
         XRRScreenResources *res;
         XRROutputInfo *output_info;
         XRRCrtcInfo *crtc;
@@ -1105,12 +757,6 @@ freeInfo:
     }
 #endif /* SDL_VIDEO_DRIVER_X11_XRANDR */
 
-#if SDL_VIDEO_DRIVER_X11_XVIDMODE
-    if (data->use_vidmode) {
-        X11_XF86VidModeSwitchToMode(display, data->vidmode_screen, &modedata->vm_mode);
-    }
-#endif /* SDL_VIDEO_DRIVER_X11_XVIDMODE */
-
     return 0;
 }
 
@@ -1129,19 +775,6 @@ X11_GetDisplayBounds(_THIS, SDL_VideoDisplay * sdl_display, SDL_Rect * rect)
     rect->w = sdl_display->current_mode.w;
     rect->h = sdl_display->current_mode.h;
 
-#if SDL_VIDEO_DRIVER_X11_XINERAMA
-    /* Get the real current bounds of the display */
-    if (data->use_xinerama) {
-        Display *display = ((SDL_VideoData *) _this->driverdata)->display;
-        int screencount;
-        XineramaScreenInfo *xinerama = X11_XineramaQueryScreens(display, &screencount);
-        if (xinerama) {
-            rect->x = xinerama[data->xinerama_screen].x_org;
-            rect->y = xinerama[data->xinerama_screen].y_org;
-            X11_XFree(xinerama);
-        }
-    }
-#endif /* SDL_VIDEO_DRIVER_X11_XINERAMA */
     return 0;
 }
 
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11modes.h b/Engine/lib/sdl/src/video/x11/SDL_x11modes.h
index 554868016..b599e3723 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11modes.h
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11modes.h
@@ -35,35 +35,20 @@ typedef struct
     float hdpi;
     float vdpi;
 
-    int use_xinerama;
-    int use_xrandr;
-    int use_vidmode;
-
-#if SDL_VIDEO_DRIVER_X11_XINERAMA
-    XineramaScreenInfo xinerama_info;
-    int xinerama_screen;
-#endif
+    SDL_bool use_xrandr;
 
 #if SDL_VIDEO_DRIVER_X11_XRANDR
     RROutput xrandr_output;
 #endif
-
-#if SDL_VIDEO_DRIVER_X11_XVIDMODE
-    int vidmode_screen;
-#endif
-
 } SDL_DisplayData;
 
 typedef struct
 {
 #if SDL_VIDEO_DRIVER_X11_XRANDR
     RRMode xrandr_mode;
+#else
+    int unused;  /* just so struct isn't empty. */
 #endif
-
-#if SDL_VIDEO_DRIVER_X11_XVIDMODE
-    XF86VidModeModeInfo vm_mode;
-#endif
-
 } SDL_DisplayModeData;
 
 extern int X11_InitModes(_THIS);
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11mouse.c b/Engine/lib/sdl/src/video/x11/SDL_x11mouse.c
index 9eb1ddd30..ed29288c6 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11mouse.c
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11mouse.c
@@ -244,8 +244,8 @@ X11_CreateSystemCursor(SDL_SystemCursor id)
     case SDL_SYSTEM_CURSOR_WAIT:      shape = XC_watch; break;
     case SDL_SYSTEM_CURSOR_CROSSHAIR: shape = XC_tcross; break;
     case SDL_SYSTEM_CURSOR_WAITARROW: shape = XC_watch; break;
-    case SDL_SYSTEM_CURSOR_SIZENWSE:  shape = XC_fleur; break;
-    case SDL_SYSTEM_CURSOR_SIZENESW:  shape = XC_fleur; break;
+    case SDL_SYSTEM_CURSOR_SIZENWSE:  shape = XC_top_left_corner; break;
+    case SDL_SYSTEM_CURSOR_SIZENESW:  shape = XC_top_right_corner; break;
     case SDL_SYSTEM_CURSOR_SIZEWE:    shape = XC_sb_h_double_arrow; break;
     case SDL_SYSTEM_CURSOR_SIZENS:    shape = XC_sb_v_double_arrow; break;
     case SDL_SYSTEM_CURSOR_SIZEALL:   shape = XC_fleur; break;
@@ -406,6 +406,8 @@ X11_GetGlobalMouseState(int *x, int *y)
                     buttons |= (mask & Button1Mask) ? SDL_BUTTON_LMASK : 0;
                     buttons |= (mask & Button2Mask) ? SDL_BUTTON_MMASK : 0;
                     buttons |= (mask & Button3Mask) ? SDL_BUTTON_RMASK : 0;
+                    /* Use the SDL state for the extended buttons - it's better than nothing */
+                    buttons |= (SDL_GetMouseState(NULL, NULL) & (SDL_BUTTON_X1MASK|SDL_BUTTON_X2MASK));
                     /* SDL_DisplayData->x,y point to screen origin, and adding them to mouse coordinates relative to root window doesn't do the right thing
                      * (observed on dual monitor setup with primary display being the rightmost one - mouse was offset to the right).
                      *
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11sym.h b/Engine/lib/sdl/src/video/x11/SDL_x11sym.h
index 762a86596..3d22d2f9f 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11sym.h
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11sym.h
@@ -19,7 +19,7 @@
   3. This notice may not be removed or altered from any source distribution.
 */
 
-/* *INDENT-OFF* */
+/* *INDENT-OFF* */ /* clang-format off */
 
 #ifndef SDL_X11_MODULE
 #define SDL_X11_MODULE(modname)
@@ -33,8 +33,6 @@ SDL_X11_MODULE(BASEXLIB)
 SDL_X11_SYM(XSizeHints*,XAllocSizeHints,(void),(),return)
 SDL_X11_SYM(XWMHints*,XAllocWMHints,(void),(),return)
 SDL_X11_SYM(XClassHint*,XAllocClassHint,(void),(),return)
-SDL_X11_SYM(int,XAutoRepeatOn,(Display* a),(a),return)
-SDL_X11_SYM(int,XAutoRepeatOff,(Display* a),(a),return)
 SDL_X11_SYM(int,XChangePointerControl,(Display* a,Bool b,Bool c,int d,int e,int f),(a,b,c,d,e,f),return)
 SDL_X11_SYM(int,XChangeProperty,(Display* a,Window b,Atom c,Atom d,int e,int f,_Xconst unsigned char* g,int h),(a,b,c,d,e,f,g,h),return)
 SDL_X11_SYM(Bool,XCheckIfEvent,(Display* a,XEvent *b,Bool (*c)(Display*,XEvent*,XPointer),XPointer d),(a,b,c,d),return)
@@ -72,7 +70,6 @@ SDL_X11_SYM(char*,XGetAtomName,(Display *a,Atom b),(a,b),return)
 SDL_X11_SYM(int,XGetInputFocus,(Display *a,Window *b,int *c),(a,b,c),return)
 SDL_X11_SYM(int,XGetErrorDatabaseText,(Display* a,_Xconst char* b,_Xconst char* c,_Xconst char* d,char* e,int f),(a,b,c,d,e,f),return)
 SDL_X11_SYM(XModifierKeymap*,XGetModifierMapping,(Display* a),(a),return)
-SDL_X11_SYM(int,XGetKeyboardControl,(Display* a, XKeyboardState* b),(a,b),return)
 SDL_X11_SYM(int,XGetPointerControl,(Display* a,int* b,int* c,int* d),(a,b,c,d),return)
 SDL_X11_SYM(Window,XGetSelectionOwner,(Display* a,Atom b),(a,b),return)
 SDL_X11_SYM(XVisualInfo*,XGetVisualInfo,(Display* a,long b,XVisualInfo* c,int* d),(a,b,c,d),return)
@@ -263,15 +260,6 @@ SDL_X11_SYM(void,XdbeFreeVisualInfo,(XdbeScreenVisualInfo *visual_info),(visual_
 SDL_X11_SYM(XdbeBackBufferAttributes*,XdbeGetBackBufferAttributes,(Display *dpy,XdbeBackBuffer buffer),(dpy,buffer),return)
 #endif
 
-/* Xinerama support */
-#if SDL_VIDEO_DRIVER_X11_XINERAMA
-SDL_X11_MODULE(XINERAMA)
-SDL_X11_SYM(Bool,XineramaIsActive,(Display *a),(a),return)
-SDL_X11_SYM(Bool,XineramaQueryExtension,(Display *a,int *b,int *c),(a,b,c),return)
-SDL_X11_SYM(Status,XineramaQueryVersion,(Display *a,int *b,int *c),(a,b,c),return)
-SDL_X11_SYM(XineramaScreenInfo*,XineramaQueryScreens,(Display *a, int *b),(a,b),return)
-#endif
-
 /* XInput2 support for multiple mice, tablets, etc. */
 #if SDL_VIDEO_DRIVER_X11_XINPUT2
 SDL_X11_MODULE(XINPUT2)
@@ -324,20 +312,9 @@ SDL_X11_MODULE(XSHAPE)
 SDL_X11_SYM(void,XShapeCombineMask,(Display *dpy,Window dest,int dest_kind,int x_off,int y_off,Pixmap src,int op),(dpy,dest,dest_kind,x_off,y_off,src,op),)
 #endif
 
-#if SDL_VIDEO_DRIVER_X11_XVIDMODE
-SDL_X11_MODULE(XVIDMODE)
-SDL_X11_SYM(Bool,XF86VidModeGetAllModeLines,(Display *a,int b,int *c,XF86VidModeModeInfo ***d),(a,b,c,d),return)
-SDL_X11_SYM(Bool,XF86VidModeGetModeLine,(Display *a,int b,int *c,XF86VidModeModeLine *d),(a,b,c,d),return)
-SDL_X11_SYM(Bool,XF86VidModeGetViewPort,(Display *a,int b,int *c,int *d),(a,b,c,d),return)
-SDL_X11_SYM(Bool,XF86VidModeQueryExtension,(Display *a,int *b,int *c),(a,b,c),return)
-SDL_X11_SYM(Bool,XF86VidModeQueryVersion,(Display *a,int *b,int *c),(a,b,c),return)
-SDL_X11_SYM(Bool,XF86VidModeSwitchToMode,(Display *a,int b,XF86VidModeModeInfo *c),(a,b,c),return)
-SDL_X11_SYM(Bool,XF86VidModeLockModeSwitch,(Display *a,int b,int c),(a,b,c),return)
-#endif
-
 #undef SDL_X11_MODULE
 #undef SDL_X11_SYM
 
-/* *INDENT-ON* */
+/* *INDENT-ON* */ /* clang-format on */
 
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11video.h b/Engine/lib/sdl/src/video/x11/SDL_x11video.h
index 8c7eb09ec..29014735c 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11video.h
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11video.h
@@ -37,9 +37,6 @@
 #if SDL_VIDEO_DRIVER_X11_XDBE
 #include <X11/extensions/Xdbe.h>
 #endif
-#if SDL_VIDEO_DRIVER_X11_XINERAMA
-#include <X11/extensions/Xinerama.h>
-#endif
 #if SDL_VIDEO_DRIVER_X11_XINPUT2
 #include <X11/extensions/XInput2.h>
 #endif
@@ -52,9 +49,6 @@
 #if SDL_VIDEO_DRIVER_X11_XSHAPE
 #include <X11/extensions/shape.h>
 #endif
-#if SDL_VIDEO_DRIVER_X11_XVIDMODE
-#include <X11/extensions/xf86vmode.h>
-#endif
 
 #include "../../core/linux/SDL_dbus.h"
 #include "../../core/linux/SDL_ime.h"
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11window.c b/Engine/lib/sdl/src/video/x11/SDL_x11window.c
index d31ac012a..07fb60266 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11window.c
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11window.c
@@ -27,6 +27,7 @@
 #include "../SDL_pixels_c.h"
 #include "../../events/SDL_keyboard_c.h"
 #include "../../events/SDL_mouse_c.h"
+#include "../../events/SDL_events_c.h"
 
 #include "SDL_x11video.h"
 #include "SDL_x11mouse.h"
@@ -72,13 +73,6 @@ X11_XIfEventTimeout(Display *display, XEvent *event_return, Bool (*predicate)(),
 }
 */
 
-static SDL_bool
-X11_IsWindowLegacyFullscreen(_THIS, SDL_Window * window)
-{
-    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
-    return (data->fswindow != 0);
-}
-
 static SDL_bool
 X11_IsWindowMapped(_THIS, SDL_Window * window)
 {
@@ -1392,12 +1386,19 @@ X11_SetWindowFullscreenViaWM(_THIS, SDL_Window * window, SDL_VideoDisplay * _dis
                                       attrs.x, attrs.y, &x, &y, &childReturn);
 
             if (!caught_x11_error) {
-                if ((x != orig_x) || (y != orig_y) || (attrs.width != orig_w) || (attrs.height != orig_h)) {
-                    window->x = x;
-                    window->y = y;
-                    window->w = attrs.width;
-                    window->h = attrs.height;
-                    break;  /* window moved, time to go. */
+                SDL_bool window_changed = SDL_FALSE;
+                if ((x != orig_x) || (y != orig_y)) {
+                    SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_MOVED, x, y);
+                    window_changed = SDL_TRUE;
+                }
+
+                if ((attrs.width != orig_w) || (attrs.height != orig_h)) {
+                    SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_RESIZED, attrs.width, attrs.height);
+                    window_changed = SDL_TRUE;
+                }
+
+                if (window_changed) {
+                    break;  /* window changed, time to go. */
                 }
             }
 
@@ -1433,161 +1434,12 @@ X11_SetWindowFullscreenViaWM(_THIS, SDL_Window * window, SDL_VideoDisplay * _dis
     X11_XFlush(display);
 }
 
-/* This handles fullscreen itself, outside the Window Manager. */
-static void
-X11_BeginWindowFullscreenLegacy(_THIS, SDL_Window * window, SDL_VideoDisplay * _display)
-{
-    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
-    SDL_DisplayData *displaydata = (SDL_DisplayData *) _display->driverdata;
-    Visual *visual = data->visual;
-    Display *display = data->videodata->display;
-    const int screen = displaydata->screen;
-    Window root = RootWindow(display, screen);
-    const int def_vis = (visual == DefaultVisual(display, screen));
-    unsigned long xattrmask = 0;
-    XSetWindowAttributes xattr;
-    XEvent ev;
-    SDL_Rect rect;
-
-    if ( data->fswindow ) {
-        return;  /* already fullscreen, I hope. */
-    }
-
-    X11_GetDisplayBounds(_this, _display, &rect);
-
-    SDL_zero(xattr);
-    xattr.override_redirect = True;
-    xattrmask |= CWOverrideRedirect;
-    xattr.background_pixel = def_vis ? BlackPixel(display, screen) : 0;
-    xattrmask |= CWBackPixel;
-    xattr.border_pixel = 0;
-    xattrmask |= CWBorderPixel;
-    xattr.colormap = data->colormap;
-    xattrmask |= CWColormap;
-
-    data->fswindow = X11_XCreateWindow(display, root,
-                                   rect.x, rect.y, rect.w, rect.h, 0,
-                                   displaydata->depth, InputOutput,
-                                   visual, xattrmask, &xattr);
-
-    X11_XSelectInput(display, data->fswindow, StructureNotifyMask);
-    X11_XSetWindowBackground(display, data->fswindow, 0);
-    X11_XInstallColormap(display, data->colormap);
-    X11_XClearWindow(display, data->fswindow);
-    X11_XMapRaised(display, data->fswindow);
-
-    /* Make sure the fswindow is in view by warping mouse to the corner */
-    X11_XUngrabPointer(display, CurrentTime);
-    X11_XWarpPointer(display, None, root, 0, 0, 0, 0, rect.x, rect.y);
-
-    /* Wait to be mapped, filter Unmap event out if it arrives. */
-    X11_XIfEvent(display, &ev, &isMapNotify, (XPointer)&data->fswindow);
-    X11_XCheckIfEvent(display, &ev, &isUnmapNotify, (XPointer)&data->fswindow);
-
-#if SDL_VIDEO_DRIVER_X11_XVIDMODE
-    if ( displaydata->use_vidmode ) {
-        X11_XF86VidModeLockModeSwitch(display, screen, True);
-    }
-#endif
-
-    SetWindowBordered(display, displaydata->screen, data->xwindow, SDL_FALSE);
-
-    /* Center actual window within our cover-the-screen window. */
-    X11_XReparentWindow(display, data->xwindow, data->fswindow,
-                    (rect.w - window->w) / 2, (rect.h - window->h) / 2);
-
-    /* Move the mouse to the upper left to make sure it's on-screen */
-    X11_XWarpPointer(display, None, root, 0, 0, 0, 0, rect.x, rect.y);
-
-    /* Center mouse in the fullscreen window. */
-    rect.x += (rect.w / 2);
-    rect.y += (rect.h / 2);
-    X11_XWarpPointer(display, None, root, 0, 0, 0, 0, rect.x, rect.y);
-
-    /* Wait to be mapped, filter Unmap event out if it arrives. */
-    X11_XIfEvent(display, &ev, &isMapNotify, (XPointer)&data->xwindow);
-    X11_XCheckIfEvent(display, &ev, &isUnmapNotify, (XPointer)&data->xwindow);
-
-    SDL_UpdateWindowGrab(window);
-}
-
-static void
-X11_EndWindowFullscreenLegacy(_THIS, SDL_Window * window, SDL_VideoDisplay * _display)
-{
-    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
-    SDL_DisplayData *displaydata = (SDL_DisplayData *) _display->driverdata;
-    Display *display = data->videodata->display;
-    const int screen = displaydata->screen;
-    Window root = RootWindow(display, screen);
-    Window fswindow = data->fswindow;
-    XEvent ev;
-
-    if (!data->fswindow) {
-        return;  /* already not fullscreen, I hope. */
-    }
-
-    data->fswindow = None;
-
-#if SDL_VIDEO_DRIVER_X11_VIDMODE
-    if ( displaydata->use_vidmode ) {
-        X11_XF86VidModeLockModeSwitch(display, screen, False);
-    }
-#endif
-
-    SDL_UpdateWindowGrab(window);
-
-    X11_XReparentWindow(display, data->xwindow, root, window->x, window->y);
-
-    /* flush these events so they don't confuse normal event handling */
-    X11_XSync(display, False);
-    X11_XCheckIfEvent(display, &ev, &isMapNotify, (XPointer)&data->xwindow);
-    X11_XCheckIfEvent(display, &ev, &isUnmapNotify, (XPointer)&data->xwindow);
-
-    SetWindowBordered(display, screen, data->xwindow,
-                      (window->flags & SDL_WINDOW_BORDERLESS) == 0);
-
-    X11_XWithdrawWindow(display, fswindow, screen);
-
-    /* Wait to be unmapped. */
-    X11_XIfEvent(display, &ev, &isUnmapNotify, (XPointer)&fswindow);
-    X11_XDestroyWindow(display, fswindow);
-}
-
-
 void
 X11_SetWindowFullscreen(_THIS, SDL_Window * window, SDL_VideoDisplay * _display, SDL_bool fullscreen)
 {
-    /* !!! FIXME: SDL_Hint? */
-    SDL_bool legacy = SDL_FALSE;
-    const char *env = SDL_getenv("SDL_VIDEO_X11_LEGACY_FULLSCREEN");
-    if (env) {
-        legacy = SDL_atoi(env);
-    } else {
-        SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;
-        SDL_DisplayData *displaydata = (SDL_DisplayData *) _display->driverdata;
-        if ( displaydata->use_vidmode ) {
-            legacy = SDL_TRUE;  /* the new stuff only works with XRandR. */
-        } else if ( !videodata->net_wm ) {
-            legacy = SDL_TRUE;  /* The window manager doesn't support it */
-        } else {
-            /* !!! FIXME: look at the window manager name, and blacklist certain ones? */
-            /* http://stackoverflow.com/questions/758648/find-the-name-of-the-x-window-manager */
-            legacy = SDL_FALSE;  /* try the new way. */
-        }
-    }
-
-    if (legacy) {
-        if (fullscreen) {
-            X11_BeginWindowFullscreenLegacy(_this, window, _display);
-        } else {
-            X11_EndWindowFullscreenLegacy(_this, window, _display);
-        }
-    } else {
-        X11_SetWindowFullscreenViaWM(_this, window, _display, fullscreen);
-    }
+    X11_SetWindowFullscreenViaWM(_this, window, _display, fullscreen);
 }
 
-
 int
 X11_SetWindowGammaRamp(_THIS, SDL_Window * window, const Uint16 * ramp)
 {
@@ -1699,7 +1551,7 @@ X11_GetWindowICCProfile(_THIS, SDL_Window * window, size_t * size)
     unsigned long real_nitems;
     SDL_x11Prop atomProp;
 
-    X11_XGetWindowAttributes(display, X11_IsWindowLegacyFullscreen(_this, window) ? data->fswindow : data->xwindow, &attributes);
+    X11_XGetWindowAttributes(display, data->xwindow, &attributes);
     if (X11_XScreenNumberOfScreen(attributes.screen) > 0) {
         SDL_snprintf(icc_atom_string, sizeof("_ICC_PROFILE_") + 12, "%s%d", "_ICC_PROFILE_", X11_XScreenNumberOfScreen(attributes.screen));
     } else {
@@ -1740,7 +1592,6 @@ X11_SetWindowMouseGrab(_THIS, SDL_Window * window, SDL_bool grabbed)
 {
     SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
     Display *display;
-    SDL_bool oldstyle_fullscreen;
 
     if (data == NULL) {
         return;
@@ -1748,13 +1599,7 @@ X11_SetWindowMouseGrab(_THIS, SDL_Window * window, SDL_bool grabbed)
 
     display = data->videodata->display;
 
-    /* ICCCM2.0-compliant window managers can handle fullscreen windows
-       If we're using XVidMode to change resolution we need to confine
-       the cursor so we don't pan around the virtual desktop.
-     */
-    oldstyle_fullscreen = X11_IsWindowLegacyFullscreen(_this, window);
-
-    if (oldstyle_fullscreen || grabbed) {
+    if (grabbed) {
         /* If the window is unmapped, XGrab calls return GrabNotViewable,
            so when we get a MapNotify later, we'll try to update the grab as
            appropriate. */
@@ -1788,11 +1633,6 @@ X11_SetWindowMouseGrab(_THIS, SDL_Window * window, SDL_bool grabbed)
 
         /* Raise the window if we grab the mouse */
         X11_XRaiseWindow(display, data->xwindow);
-
-        /* Now grab the keyboard on old-style fullscreen */
-        if (oldstyle_fullscreen) {
-            X11_SetWindowKeyboardGrab(_this, window, SDL_TRUE);
-        }
     } else {
         X11_XUngrabPointer(display, CurrentTime);
 
diff --git a/Engine/lib/sdl/src/video/x11/SDL_x11window.h b/Engine/lib/sdl/src/video/x11/SDL_x11window.h
index 6f1c71c67..6f7560afe 100644
--- a/Engine/lib/sdl/src/video/x11/SDL_x11window.h
+++ b/Engine/lib/sdl/src/video/x11/SDL_x11window.h
@@ -44,7 +44,6 @@ typedef struct
 {
     SDL_Window *window;
     Window xwindow;
-    Window fswindow;  /* used if we can't have the WM handle fullscreen. */
     Visual *visual;
     Colormap colormap;
 #ifndef NO_SHARED_MEMORY
diff --git a/Engine/lib/sdl/src/video/yuv2rgb/yuv_rgb_std_func.h b/Engine/lib/sdl/src/video/yuv2rgb/yuv_rgb_std_func.h
index f0ab5c660..94872ec9f 100644
--- a/Engine/lib/sdl/src/video/yuv2rgb/yuv_rgb_std_func.h
+++ b/Engine/lib/sdl/src/video/yuv2rgb/yuv_rgb_std_func.h
@@ -97,10 +97,13 @@ void STD_FUNCTION_NAME(
 	for(y=0; y<(height-(uv_y_sample_interval-1)); y+=uv_y_sample_interval)
 	{
 		const uint8_t *y_ptr1=Y+y*Y_stride,
-			*y_ptr2=Y+(y+1)*Y_stride,
 			*u_ptr=U+(y/uv_y_sample_interval)*UV_stride,
 			*v_ptr=V+(y/uv_y_sample_interval)*UV_stride;
-		
+
+		#if uv_y_sample_interval > 1
+		const uint8_t *y_ptr2=Y+(y+1)*Y_stride;
+		#endif
+
 		uint8_t *rgb_ptr1=RGB+y*RGB_stride;
 
 		#if uv_y_sample_interval > 1
@@ -135,7 +138,9 @@ void STD_FUNCTION_NAME(
 			#endif
 
 			y_ptr1+=2*y_pixel_stride;
+			#if uv_y_sample_interval > 1
 			y_ptr2+=2*y_pixel_stride;
+			#endif
 			u_ptr+=2*uv_pixel_stride/uv_x_sample_interval;
 			v_ptr+=2*uv_pixel_stride/uv_x_sample_interval;
 		}
diff --git a/Engine/lib/sdl/test/CMakeLists.txt b/Engine/lib/sdl/test/CMakeLists.txt
index 330af47c4..da3482b1c 100644
--- a/Engine/lib/sdl/test/CMakeLists.txt
+++ b/Engine/lib/sdl/test/CMakeLists.txt
@@ -1,5 +1,10 @@
 cmake_minimum_required(VERSION 3.0.0)
 project(SDL2 C)
+include(CTest)
+
+if(SDL_INSTALL_TESTS)
+    include(GNUInstallDirs)
+endif()
 
 # Global settings for all of the test targets
 # FIXME: is this wrong?
@@ -48,8 +53,8 @@ endif()
 
 add_executable(checkkeys checkkeys.c)
 add_executable(checkkeysthreads checkkeysthreads.c)
-add_executable(loopwave loopwave.c)
-add_executable(loopwavequeue loopwavequeue.c)
+add_executable(loopwave loopwave.c testutils.c)
+add_executable(loopwavequeue loopwavequeue.c testutils.c)
 add_executable(testsurround testsurround.c)
 add_executable(testresample testresample.c)
 add_executable(testaudioinfo testaudioinfo.c)
@@ -57,8 +62,8 @@ add_executable(testaudioinfo testaudioinfo.c)
 file(GLOB TESTAUTOMATION_SOURCE_FILES testautomation*.c)
 add_executable(testautomation ${TESTAUTOMATION_SOURCE_FILES})
 
-add_executable(testmultiaudio testmultiaudio.c)
-add_executable(testaudiohotplug testaudiohotplug.c)
+add_executable(testmultiaudio testmultiaudio.c testutils.c)
+add_executable(testaudiohotplug testaudiohotplug.c testutils.c)
 add_executable(testaudiocapture testaudiocapture.c)
 add_executable(testatomic testatomic.c)
 add_executable(testintersections testintersections.c)
@@ -68,9 +73,14 @@ add_executable(testdraw2 testdraw2.c)
 add_executable(testdrawchessboard testdrawchessboard.c)
 add_executable(testdropfile testdropfile.c)
 add_executable(testerror testerror.c)
+
+if(LINUX)
+    add_executable(testevdev testevdev.c)
+endif()
+
 add_executable(testfile testfile.c)
-add_executable(testgamecontroller testgamecontroller.c)
-add_executable(testgeometry testgeometry.c)
+add_executable(testgamecontroller testgamecontroller.c testutils.c)
+add_executable(testgeometry testgeometry.c testutils.c)
 add_executable(testgesture testgesture.c)
 add_executable(testgl2 testgl2.c)
 add_executable(testgles testgles.c)
@@ -79,52 +89,164 @@ add_executable(testhaptic testhaptic.c)
 add_executable(testhotplug testhotplug.c)
 add_executable(testrumble testrumble.c)
 add_executable(testthread testthread.c)
-add_executable(testiconv testiconv.c)
-add_executable(testime testime.c)
+add_executable(testiconv testiconv.c testutils.c)
+add_executable(testime testime.c testutils.c)
 add_executable(testjoystick testjoystick.c)
 add_executable(testkeys testkeys.c)
 add_executable(testloadso testloadso.c)
+add_executable(testlocale testlocale.c)
 add_executable(testlock testlock.c)
 add_executable(testmouse testmouse.c)
 
 if(APPLE)
     add_executable(testnative testnative.c
                               testnativecocoa.m
-                              testnativex11.c)
+                              testnativex11.c
+                              testutils.c)
 elseif(WINDOWS)
-    add_executable(testnative testnative.c testnativew32.c)
-elseif(UNIX)
-    add_executable(testnative testnative.c testnativex11.c)
+    add_executable(testnative testnative.c testnativew32.c testutils.c)
+elseif(SDL_X11)
+    add_executable(testnative testnative.c testnativex11.c testutils.c)
+    target_link_libraries(testnative X11)
 endif()
 
-add_executable(testoverlay2 testoverlay2.c testyuv_cvt.c)
+add_executable(testoverlay2 testoverlay2.c testyuv_cvt.c testutils.c)
 add_executable(testplatform testplatform.c)
 add_executable(testpower testpower.c)
 add_executable(testfilesystem testfilesystem.c)
-add_executable(testrendertarget testrendertarget.c)
-add_executable(testscale testscale.c)
+add_executable(testrendertarget testrendertarget.c testutils.c)
+add_executable(testscale testscale.c testutils.c)
 add_executable(testsem testsem.c)
+add_executable(testsensor testsensor.c)
 add_executable(testshader testshader.c)
 add_executable(testshape testshape.c)
-add_executable(testsprite2 testsprite2.c)
-add_executable(testspriteminimal testspriteminimal.c)
-add_executable(teststreaming teststreaming.c)
+add_executable(testsprite2 testsprite2.c testutils.c)
+add_executable(testspriteminimal testspriteminimal.c testutils.c)
+add_executable(teststreaming teststreaming.c testutils.c)
 add_executable(testtimer testtimer.c)
+add_executable(testurl testurl.c)
 add_executable(testver testver.c)
-add_executable(testviewport testviewport.c)
+add_executable(testviewport testviewport.c testutils.c)
 add_executable(testwm2 testwm2.c)
 add_executable(testyuv testyuv.c testyuv_cvt.c)
 add_executable(torturethread torturethread.c)
-add_executable(testrendercopyex testrendercopyex.c)
+add_executable(testrendercopyex testrendercopyex.c testutils.c)
 add_executable(testmessage testmessage.c)
 add_executable(testdisplayinfo testdisplayinfo.c)
 add_executable(testqsort testqsort.c)
 add_executable(testbounds testbounds.c)
 add_executable(testcustomcursor testcustomcursor.c)
-add_executable(controllermap controllermap.c)
+add_executable(controllermap controllermap.c testutils.c)
 add_executable(testvulkan testvulkan.c)
 add_executable(testoffscreen testoffscreen.c)
 
+SET(ALL_TESTS
+    checkkeys
+    checkkeysthreads
+    controllermap
+    loopwave
+    loopwavequeue
+    testatomic
+    testaudiocapture
+    testaudiohotplug
+    testaudioinfo
+    testautomation
+    testbounds
+    testcustomcursor
+    testdisplayinfo
+    testdraw2
+    testdrawchessboard
+    testdropfile
+    testerror
+    testfile
+    testfilesystem
+    testgamecontroller
+    testgeometry
+    testgesture
+    testgl2
+    testgles
+    testgles2
+    testhaptic
+    testhittesting
+    testhotplug
+    testiconv
+    testime
+    testintersections
+    testjoystick
+    testkeys
+    testloadso
+    testlocale
+    testlock
+    testmessage
+    testmouse
+    testmultiaudio
+    testoffscreen
+    testoverlay2
+    testplatform
+    testpower
+    testqsort
+    testrelative
+    testrendercopyex
+    testrendertarget
+    testresample
+    testrumble
+    testscale
+    testsem
+    testsensor
+    testshader
+    testshape
+    testsprite2
+    testspriteminimal
+    teststreaming
+    testsurround
+    testthread
+    testtimer
+    testurl
+    testver
+    testviewport
+    testvulkan
+    testwm2
+    testyuv
+    torturethread
+)
+
+set(NONINTERACTIVE
+    testatomic
+    testerror
+    testfilesystem
+    testlocale
+    testplatform
+    testpower
+    testqsort
+    testthread
+    testtimer
+    testver
+)
+
+if(WINDOWS OR APPLE OR SDL_X11)
+    list(APPEND ALL_TESTS testnative)
+endif()
+
+if(LINUX)
+    list(APPEND ALL_TESTS testevdev)
+    list(APPEND NONINTERACTIVE testevdev)
+endif()
+
+if(SDL_DUMMYAUDIO)
+  set(NEEDS_AUDIO
+    testaudioinfo
+    testsurround
+  )
+endif()
+
+if(SDL_DUMMYVIDEO)
+  set(NEEDS_DISPLAY
+    testkeys
+    testbounds
+    testdisplayinfo
+  )
+endif()
+
 if(OPENGL_FOUND)
 add_dependencies(testshader OpenGL::GL)
 add_dependencies(testgl2 OpenGL::GL)
@@ -177,12 +299,14 @@ else()
         testaudiohotplug
         testmultiaudio
         testime
-        testnative
         testiconv
         testoverlay2
         teststreaming
         testviewport
     )
+    if(WINDOWS OR APPLE OR SDL_X11)
+        list(APPEND NEEDS_RESOURCES testnative)
+    endif()
 endif()
 
 if(PSP)
@@ -262,6 +386,20 @@ if(PSP)
     endforeach()
 endif()
 
+if(RISCOS)
+    set(ALL_TESTS_AIF "")
+    foreach(APP IN LISTS ALL_TESTS)
+        target_link_options(${APP} PRIVATE -static)
+        add_custom_command(
+            OUTPUT ${APP},ff8
+            COMMAND elf2aif ${APP} ${APP},ff8
+            DEPENDS ${APP}
+        )
+        add_custom_target(${APP}-aif ALL DEPENDS ${APP},ff8)
+        list(APPEND ALL_TESTS_AIF ${CMAKE_CURRENT_BINARY_DIR}/${APP},ff8)
+    endforeach()
+endif()
+
 foreach(APP IN LISTS NEEDS_RESOURCES)
     foreach(RESOURCE_FILE ${RESOURCE_FILES})
         if(PSP)
@@ -298,3 +436,47 @@ if(APPLE)
         endforeach()
     endif()
 endif()
+
+set(TESTS_ENVIRONMENT
+    SDL_AUDIODRIVER=dummy
+    SDL_VIDEODRIVER=dummy
+)
+
+foreach(TESTCASE ${NONINTERACTIVE} ${NEEDS_AUDIO} ${NEEDS_DISPLAY})
+    add_test(
+        NAME ${TESTCASE}
+        COMMAND ${TESTCASE}
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+    )
+    set_tests_properties(
+        ${TESTCASE}
+        PROPERTIES ENVIRONMENT "${TESTS_ENVIRONMENT}"
+    )
+    if(SDL_INSTALL_TESTS)
+        set(exe ${TESTCASE})
+        set(installedtestsdir "${CMAKE_INSTALL_FULL_LIBEXECDIR}/installed-tests/SDL2")
+        configure_file(template.test.in "${exe}.test" @ONLY)
+        install(
+            FILES "${CMAKE_CURRENT_BINARY_DIR}/${exe}.test"
+            DESTINATION ${CMAKE_INSTALL_DATADIR}/installed-tests/SDL2
+        )
+    endif()
+endforeach()
+
+if(SDL_INSTALL_TESTS)
+    if(RISCOS)
+        install(
+            FILES ${ALL_TESTS_AIF}
+            DESTINATION ${CMAKE_INSTALL_LIBEXECDIR}/installed-tests/SDL2
+        )
+    else()
+        install(
+            TARGETS ${ALL_TESTS}
+            DESTINATION ${CMAKE_INSTALL_LIBEXECDIR}/installed-tests/SDL2
+        )
+    endif()
+    install(
+        FILES ${RESOURCE_FILES}
+        DESTINATION ${CMAKE_INSTALL_LIBEXECDIR}/installed-tests/SDL2
+    )
+endif()
diff --git a/Engine/lib/sdl/test/Makefile.in b/Engine/lib/sdl/test/Makefile.in
index f724618c6..e3e6db991 100644
--- a/Engine/lib/sdl/test/Makefile.in
+++ b/Engine/lib/sdl/test/Makefile.in
@@ -2,6 +2,15 @@
 
 srcdir  = @srcdir@
 
+prefix = @prefix@
+exec_prefix = @exec_prefix@
+bindir = @bindir@
+libdir = @libdir@
+libexecdir = @libexecdir@
+includedir = @includedir@
+datarootdir = @datarootdir@
+datadir = @datadir@
+
 CC      = @CC@
 EXE	= @EXE@
 CFLAGS  = @CFLAGS@ -g
@@ -79,7 +88,26 @@ TARGETS = \
 @OPENGLES2_TARGETS@ += testgles2$(EXE)
 
 
-all: Makefile $(TARGETS) copydatafiles
+all: Makefile $(TARGETS) copydatafiles generatetestmeta
+
+installedtestsdir = $(libexecdir)/installed-tests/SDL2
+installedtestsmetadir = $(datadir)/installed-tests/SDL2
+
+generatetestmeta:
+	rm -f *.test
+	set -e; for exe in $(noninteractive) $(needs_audio) $(needs_display); do \
+		sed \
+			-e 's#@installedtestsdir@#$(installedtestsdir)#g' \
+			-e "s#@exe@#$$exe#g" \
+			< $(srcdir)/template.test.in > $$exe.test; \
+	done
+
+install: all
+	install -d $(DESTDIR)$(installedtestsdir)
+	install $(TARGETS) $(DESTDIR)$(installedtestsdir)
+	install -m644 $(DATA) $(DESTDIR)$(installedtestsdir)
+	install -d $(DESTDIR)$(installedtestsmetadir)
+	install -m644 *.test $(DESTDIR)$(installedtestsmetadir)
 
 Makefile: $(srcdir)/Makefile.in
 	$(SHELL) config.status $@
@@ -90,10 +118,10 @@ checkkeys$(EXE): $(srcdir)/checkkeys.c
 checkkeysthreads$(EXE): $(srcdir)/checkkeysthreads.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
 
-loopwave$(EXE): $(srcdir)/loopwave.c
+loopwave$(EXE): $(srcdir)/loopwave.c $(srcdir)/testutils.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
 
-loopwavequeue$(EXE): $(srcdir)/loopwavequeue.c
+loopwavequeue$(EXE): $(srcdir)/loopwavequeue.c $(srcdir)/testutils.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
 
 testsurround$(EXE): $(srcdir)/testsurround.c
@@ -126,10 +154,10 @@ testautomation$(EXE): $(srcdir)/testautomation.c \
 		      $(srcdir)/testautomation_hints.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS) 
 
-testmultiaudio$(EXE): $(srcdir)/testmultiaudio.c
+testmultiaudio$(EXE): $(srcdir)/testmultiaudio.c $(srcdir)/testutils.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
 
-testaudiohotplug$(EXE): $(srcdir)/testaudiohotplug.c
+testaudiohotplug$(EXE): $(srcdir)/testaudiohotplug.c $(srcdir)/testutils.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
 
 testaudiocapture$(EXE): $(srcdir)/testaudiocapture.c
@@ -165,10 +193,10 @@ testevdev$(EXE): $(srcdir)/testevdev.c
 testfile$(EXE): $(srcdir)/testfile.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
 
-testgamecontroller$(EXE): $(srcdir)/testgamecontroller.c
+testgamecontroller$(EXE): $(srcdir)/testgamecontroller.c $(srcdir)/testutils.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
 
-testgeometry$(EXE): $(srcdir)/testgeometry.c
+testgeometry$(EXE): $(srcdir)/testgeometry.c $(srcdir)/testutils.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
 
 testgesture$(EXE): $(srcdir)/testgesture.c
@@ -183,7 +211,7 @@ testgles$(EXE): $(srcdir)/testgles.c
 testgles2$(EXE): $(srcdir)/testgles2.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS) @MATHLIB@
 
-testgles2_sdf$(EXE): $(srcdir)/testgles2_sdf.c
+testgles2_sdf$(EXE): $(srcdir)/testgles2_sdf.c $(srcdir)/testutils.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS) @MATHLIB@
 
 testhaptic$(EXE): $(srcdir)/testhaptic.c
@@ -198,10 +226,10 @@ testrumble$(EXE): $(srcdir)/testrumble.c
 testthread$(EXE): $(srcdir)/testthread.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
 
-testiconv$(EXE): $(srcdir)/testiconv.c
+testiconv$(EXE): $(srcdir)/testiconv.c $(srcdir)/testutils.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
 
-testime$(EXE): $(srcdir)/testime.c
+testime$(EXE): $(srcdir)/testime.c $(srcdir)/testutils.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS) @SDL_TTF_LIB@
 
 testjoystick$(EXE): $(srcdir)/testjoystick.c
@@ -219,18 +247,21 @@ testlock$(EXE): $(srcdir)/testlock.c
 ifeq (@ISMACOSX@,true)
 testnative$(EXE): $(srcdir)/testnative.c \
 			$(srcdir)/testnativecocoa.m \
+			$(srcdir)/testutils.c \
 			$(srcdir)/testnativex11.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS) -framework Cocoa @XLIB@
 endif
 
 ifeq (@ISWINDOWS@,true)
 testnative$(EXE): $(srcdir)/testnative.c \
+			$(srcdir)/testutils.c \
 			$(srcdir)/testnativew32.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
 endif
 
 ifeq (@ISUNIX@,true)
 testnative$(EXE): $(srcdir)/testnative.c \
+			$(srcdir)/testutils.c \
 			$(srcdir)/testnativex11.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS) @XLIB@
 endif
@@ -252,7 +283,7 @@ endif
 endif
 endif
 
-testoverlay2$(EXE): $(srcdir)/testoverlay2.c $(srcdir)/testyuv_cvt.c
+testoverlay2$(EXE): $(srcdir)/testoverlay2.c $(srcdir)/testyuv_cvt.c $(srcdir)/testutils.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
 
 testplatform$(EXE): $(srcdir)/testplatform.c
@@ -264,10 +295,10 @@ testpower$(EXE): $(srcdir)/testpower.c
 testfilesystem$(EXE): $(srcdir)/testfilesystem.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
 
-testrendertarget$(EXE): $(srcdir)/testrendertarget.c
+testrendertarget$(EXE): $(srcdir)/testrendertarget.c $(srcdir)/testutils.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
 
-testscale$(EXE): $(srcdir)/testscale.c
+testscale$(EXE): $(srcdir)/testscale.c $(srcdir)/testutils.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
 
 testsem$(EXE): $(srcdir)/testsem.c
@@ -282,13 +313,13 @@ testshader$(EXE): $(srcdir)/testshader.c
 testshape$(EXE): $(srcdir)/testshape.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
 
-testsprite2$(EXE): $(srcdir)/testsprite2.c
+testsprite2$(EXE): $(srcdir)/testsprite2.c $(srcdir)/testutils.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
 
-testspriteminimal$(EXE): $(srcdir)/testspriteminimal.c
+testspriteminimal$(EXE): $(srcdir)/testspriteminimal.c $(srcdir)/testutils.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS) @MATHLIB@
 
-teststreaming$(EXE): $(srcdir)/teststreaming.c
+teststreaming$(EXE): $(srcdir)/teststreaming.c $(srcdir)/testutils.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS) @MATHLIB@
 
 testtimer$(EXE): $(srcdir)/testtimer.c
@@ -300,7 +331,7 @@ testurl$(EXE): $(srcdir)/testurl.c
 testver$(EXE): $(srcdir)/testver.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
 
-testviewport$(EXE): $(srcdir)/testviewport.c
+testviewport$(EXE): $(srcdir)/testviewport.c $(srcdir)/testutils.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
 
 testwm2$(EXE): $(srcdir)/testwm2.c
@@ -312,7 +343,7 @@ testyuv$(EXE): $(srcdir)/testyuv.c $(srcdir)/testyuv_cvt.c
 torturethread$(EXE): $(srcdir)/torturethread.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
 
-testrendercopyex$(EXE): $(srcdir)/testrendercopyex.c
+testrendercopyex$(EXE): $(srcdir)/testrendercopyex.c $(srcdir)/testutils.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS) @MATHLIB@
 
 testmessage$(EXE): $(srcdir)/testmessage.c
@@ -330,7 +361,7 @@ testbounds$(EXE): $(srcdir)/testbounds.c
 testcustomcursor$(EXE): $(srcdir)/testcustomcursor.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
 
-controllermap$(EXE): $(srcdir)/controllermap.c
+controllermap$(EXE): $(srcdir)/controllermap.c $(srcdir)/testutils.c
 	$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
 
 testvulkan$(EXE): $(srcdir)/testvulkan.c
@@ -344,13 +375,56 @@ testmouse$(EXE): $(srcdir)/testmouse.c
 
 
 clean:
-	rm -f $(TARGETS)
+	rm -f $(TARGETS) *.test
 
 distclean: clean
 	rm -f Makefile
 	rm -f config.status config.cache config.log
 	rm -rf $(srcdir)/autom4te*
 
+noninteractive = \
+	testatomic$(EXE) \
+	testerror$(EXE) \
+	testevdev$(EXE) \
+	testfilesystem$(EXE) \
+	testkeys$(EXE) \
+	testlocale$(EXE) \
+	testplatform$(EXE) \
+	testpower$(EXE) \
+	testqsort$(EXE) \
+	testthread$(EXE) \
+	testtimer$(EXE) \
+	testver$(EXE) \
+	$(NULL)
+
+needs_audio = \
+	testaudioinfo$(EXE) \
+	testsurround$(EXE) \
+	$(NULL)
+
+needs_display = \
+	testbounds$(EXE) \
+	testdisplayinfo$(EXE) \
+	$(NULL)
+
+TESTS = $(noninteractive) $(needs_audio) $(needs_display)
+
+check:
+	@set -e; \
+	status=0; \
+	export SDL_AUDIODRIVER=dummy; \
+	export SDL_VIDEODRIVER=dummy; \
+	for exe in $(TESTS); do \
+		echo "$$exe..."; \
+		if ./"$$exe"; then \
+			echo "$$exe: OK"; \
+		else \
+			echo "$$exe: FAILED: $$?"; \
+			status=1; \
+		fi; \
+	done; \
+	exit "$$status"
+
 DATA = \
 	axis.bmp \
 	button.bmp \
diff --git a/Engine/lib/sdl/test/Makefile.os2 b/Engine/lib/sdl/test/Makefile.os2
index e238af4be..75aaeedfd 100644
--- a/Engine/lib/sdl/test/Makefile.os2
+++ b/Engine/lib/sdl/test/Makefile.os2
@@ -1,77 +1,13 @@
 # Open Watcom makefile to build SDL2 tests for OS/2
 # wmake -f Makefile.os2
 
-INCPATH = -I"$(%WATCOM)/h/os2" -I"$(%WATCOM)/h" -I"../include"
+SYSTEM = os2v2
 
-CFLAGS = $(INCPATH) -bt=os2 -d0 -q -bm -5s -fp5 -fpi87 -sg -oteanbmier -ei
+INCPATH = -I"$(%WATCOM)/h/os2" -I"$(%WATCOM)/h"
+
+CFLAGS = -bt=os2 -d0 -q -bm -5s -fp5 -fpi87 -sg -oteanbmier -ei
 CFLAGS+= -wx -wcd=303
 
-LIBPATH = ..
-LIBS    = SDL2.lib SDL2test.lib
+TNSRCS = testnative.c testnativeos2.c
 
-#CFLAGS+= -DHAVE_SDL_TTF
-#TTFLIBS = SDL2ttf.lib
-
-TARGETS = testatomic.exe testdisplayinfo.exe testbounds.exe testdraw2.exe &
-          testdrawchessboard.exe testdropfile.exe testerror.exe testfile.exe &
-          testfilesystem.exe testgamecontroller.exe testgeometry.exe testgesture.exe &
-          testhittesting.exe testhotplug.exe testiconv.exe testime.exe testlocale.exe &
-          testintersections.exe testjoystick.exe testkeys.exe testloadso.exe &
-          testlock.exe testmessage.exe testoverlay2.exe testplatform.exe &
-          testpower.exe testsensor.exe testrelative.exe testrendercopyex.exe &
-          testrendertarget.exe testrumble.exe testscale.exe testsem.exe &
-          testshader.exe testshape.exe testsprite2.exe testspriteminimal.exe &
-          teststreaming.exe testthread.exe testtimer.exe testver.exe &
-          testviewport.exe testwm2.exe torturethread.exe checkkeys.exe &
-          checkkeysthreads.exe testmouse.exe &
-          controllermap.exe testhaptic.exe testqsort.exe testresample.exe &
-          testaudioinfo.exe testaudiocapture.exe loopwave.exe loopwavequeue.exe &
-          testsurround.exe testyuv.exe testgl2.exe testvulkan.exe testnative.exe &
-          testautomation.exe
-
-# testautomation sources
-TASRCS = testautomation.c testautomation_audio.c testautomation_clipboard.c &
-         testautomation_events.c testautomation_hints.c &
-         testautomation_keyboard.c testautomation_main.c &
-         testautomation_mouse.c testautomation_pixels.c &
-         testautomation_platform.c testautomation_rect.c &
-         testautomation_render.c testautomation_rwops.c &
-         testautomation_sdltest.c testautomation_stdlib.c &
-         testautomation_surface.c testautomation_syswm.c &
-         testautomation_timer.c testautomation_video.c
-
-OBJS = $(TARGETS:.exe=.obj)
-COBJS = $(CSRCS:.c=.obj)
-TAOBJS = $(TASRCS:.c=.obj)
-
-all: $(TARGETS)
-
-.c: ../src/test
-
-.obj.exe:
-  wlink SYS os2v2 libpath $(LIBPATH) lib {$(LIBS)} op q op el file {$<} name $@
-
-.c.obj:
-  wcc386 $(CFLAGS) -fo=$^@ $<
-
-# specials
-testautomation.exe: $(TAOBJS)
-  wlink SYS os2v2 libpath $(LIBPATH) lib {$(LIBS)} op q op el file {$<} name $@
-
-testnative.exe: testnative.obj testnativeos2.obj
-  wlink SYS os2v2 libpath $(LIBPATH) lib {$(LIBS)} op q op el file {$<} name $@
-
-testoverlay2.exe: testoverlay2.obj testyuv_cvt.obj
-  wlink SYS os2v2 libpath $(LIBPATH) lib {$(LIBS)} op q op el file {$<} name $@
-
-testyuv.exe: testyuv.obj testyuv_cvt.obj
-  wlink SYS os2v2 libpath $(LIBPATH) lib {$(LIBS)} op q op el file {$<} name $@
-
-testime.exe: testime.obj
-  wlink SYS os2v2 libpath $(LIBPATH) lib {$(LIBS) $(TTFLIBS)} op q op el file {$<} name $@
-
-clean: .SYMBOLIC
-  @if exist *.obj rm *.obj
-  @if exist *.err rm *.err
-distclean: .SYMBOLIC clean
-  @if exist *.exe rm *.exe
+!include watcom.mif
diff --git a/Engine/lib/sdl/test/Makefile.w32 b/Engine/lib/sdl/test/Makefile.w32
new file mode 100644
index 000000000..51ca7eafc
--- /dev/null
+++ b/Engine/lib/sdl/test/Makefile.w32
@@ -0,0 +1,16 @@
+# Open Watcom makefile to build SDL2 tests for Win32
+# wmake -f Makefile.w32
+
+SYSTEM = nt
+
+INCPATH = -I"$(%WATCOM)/h/nt" -I"$(%WATCOM)/h" -I"../src/video/khronos"
+
+CFLAGS = -bt=nt -d0 -q -bm -5s -fp5 -fpi87 -sg -oteanbmier -ei
+CFLAGS+= -wx -wcd=303
+CFLAGS+= -DSDL_MAIN_HANDLED
+CFLAGS+= -DHAVE_OPENGL
+GLLIBS = opengl32.lib
+
+TNSRCS = testnative.c testnativew32.c
+
+!include watcom.mif
diff --git a/Engine/lib/sdl/test/checkkeys.c b/Engine/lib/sdl/test/checkkeys.c
index caec4b955..74bd7953c 100644
--- a/Engine/lib/sdl/test/checkkeys.c
+++ b/Engine/lib/sdl/test/checkkeys.c
@@ -165,7 +165,11 @@ loop()
             PrintKey(&event.key.keysym, (event.key.state == SDL_PRESSED) ? SDL_TRUE : SDL_FALSE, (event.key.repeat) ? SDL_TRUE : SDL_FALSE);
             break;
         case SDL_TEXTEDITING:
-            PrintText("EDIT", event.text.text);
+            PrintText("EDIT", event.edit.text);
+            break;
+        case SDL_TEXTEDITING_EXT:
+            PrintText("EDIT_EXT", event.editExt.text);
+            SDL_free(event.editExt.text);
             break;
         case SDL_TEXTINPUT:
             PrintText("INPUT", event.text.text);
@@ -207,6 +211,9 @@ main(int argc, char *argv[])
     /* Enable standard application logging */
     SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
 
+    /* Enable extended text editing events */
+    SDL_SetHint(SDL_HINT_IME_SUPPORT_EXTENDED_TEXT, "1");
+
     /* Initialize SDL */
     if (SDL_Init(SDL_INIT_VIDEO) < 0) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't initialize SDL: %s\n", SDL_GetError());
diff --git a/Engine/lib/sdl/test/controllermap.c b/Engine/lib/sdl/test/controllermap.c
index 308ddf51a..429125a19 100644
--- a/Engine/lib/sdl/test/controllermap.c
+++ b/Engine/lib/sdl/test/controllermap.c
@@ -18,6 +18,7 @@
 #include <string.h>
 
 #include "SDL.h"
+#include "testutils.h"
 
 #ifndef SDL_JOYSTICK_DISABLED
 
@@ -169,39 +170,6 @@ static SDL_Renderer *screen;
 static SDL_bool done = SDL_FALSE;
 static SDL_bool bind_touchpad = SDL_FALSE;
 
-SDL_Texture *
-LoadTexture(SDL_Renderer *renderer, const char *file, SDL_bool transparent)
-{
-    SDL_Surface *temp;
-    SDL_Texture *texture;
-
-    /* Load the sprite image */
-    temp = SDL_LoadBMP(file);
-    if (temp == NULL) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't load %s: %s", file, SDL_GetError());
-        return NULL;
-    }
-
-    /* Set transparent pixel as the pixel at (0,0) */
-    if (transparent) {
-        if (temp->format->palette) {
-            SDL_SetColorKey(temp, SDL_TRUE, *(Uint8 *) temp->pixels);
-        }
-    }
-
-    /* Create textures from the image */
-    texture = SDL_CreateTextureFromSurface(renderer, temp);
-    if (!texture) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create texture: %s\n", SDL_GetError());
-        SDL_FreeSurface(temp);
-        return NULL;
-    }
-    SDL_FreeSurface(temp);
-
-    /* We're ready to roll. :) */
-    return texture;
-}
-
 static int
 StandardizeAxisValue(int nValue)
 {
@@ -392,10 +360,10 @@ WatchJoystick(SDL_Joystick * joystick)
     Uint32 alpha_ticks = 0;
     SDL_JoystickID nJoystickID;
 
-    background_front = LoadTexture(screen, "controllermap.bmp", SDL_FALSE);
-    background_back = LoadTexture(screen, "controllermap_back.bmp", SDL_FALSE);
-    button = LoadTexture(screen, "button.bmp", SDL_TRUE);
-    axis = LoadTexture(screen, "axis.bmp", SDL_TRUE);
+    background_front = LoadTexture(screen, "controllermap.bmp", SDL_FALSE, NULL, NULL);
+    background_back = LoadTexture(screen, "controllermap_back.bmp", SDL_FALSE, NULL, NULL);
+    button = LoadTexture(screen, "button.bmp", SDL_TRUE, NULL, NULL);
+    axis = LoadTexture(screen, "axis.bmp", SDL_TRUE, NULL, NULL);
     SDL_RaiseWindow(window);
 
     /* scale for platforms that don't give you the window size you asked for. */
diff --git a/Engine/lib/sdl/test/loopwave.c b/Engine/lib/sdl/test/loopwave.c
index 14ac4dbaf..354ac2cb7 100644
--- a/Engine/lib/sdl/test/loopwave.c
+++ b/Engine/lib/sdl/test/loopwave.c
@@ -25,6 +25,7 @@
 #endif
 
 #include "SDL.h"
+#include "testutils.h"
 
 static struct
 {
@@ -114,7 +115,7 @@ int
 main(int argc, char *argv[])
 {
     int i;
-    char filename[4096];
+    char *filename = NULL;
 
     /* Enable standard application logging */
     SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
@@ -125,11 +126,13 @@ main(int argc, char *argv[])
         return (1);
     }
 
-    if (argc > 1) {
-        SDL_strlcpy(filename, argv[1], sizeof(filename));
-    } else {
-        SDL_strlcpy(filename, "sample.wav", sizeof(filename));
+    filename = GetResourceFilename(argc > 1 ? argv[1] : NULL, "sample.wav");
+
+    if (filename == NULL) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "%s\n", SDL_GetError());
+        quit(1);
     }
+
     /* Load the wave file into memory */
     if (SDL_LoadWAV(filename, &wave.spec, &wave.sound, &wave.soundlen) == NULL) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't load %s: %s\n", filename, SDL_GetError());
@@ -172,6 +175,7 @@ main(int argc, char *argv[])
     /* Clean up on signal */
     close_audio();
     SDL_FreeWAV(wave.sound);
+    SDL_free(filename);
     SDL_Quit();
     return (0);
 }
diff --git a/Engine/lib/sdl/test/loopwavequeue.c b/Engine/lib/sdl/test/loopwavequeue.c
index a5d0ea3cc..1996d784a 100644
--- a/Engine/lib/sdl/test/loopwavequeue.c
+++ b/Engine/lib/sdl/test/loopwavequeue.c
@@ -25,6 +25,8 @@
 #include <signal.h>
 #endif
 
+#include "testutils.h"
+
 static struct
 {
     SDL_AudioSpec spec;
@@ -74,7 +76,7 @@ loop()
 int
 main(int argc, char *argv[])
 {
-    char filename[4096];
+    char *filename = NULL;
 
     /* Enable standard application logging */
     SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
@@ -85,11 +87,13 @@ main(int argc, char *argv[])
         return (1);
     }
 
-    if (argc > 1) {
-        SDL_strlcpy(filename, argv[1], sizeof(filename));
-    } else {
-        SDL_strlcpy(filename, "sample.wav", sizeof(filename));
+    filename = GetResourceFilename(argc > 1 ? argv[1] : NULL, "sample.wav");
+
+    if (filename == NULL) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "%s\n", SDL_GetError());
+        quit(1);
     }
+
     /* Load the wave file into memory */
     if (SDL_LoadWAV(filename, &wave.spec, &wave.sound, &wave.soundlen) == NULL) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't load %s: %s\n", filename, SDL_GetError());
@@ -142,6 +146,7 @@ main(int argc, char *argv[])
     /* Clean up on signal */
     SDL_CloseAudio();
     SDL_FreeWAV(wave.sound);
+    SDL_free(filename);
     SDL_Quit();
     return 0;
 }
diff --git a/Engine/lib/sdl/test/template.test.in b/Engine/lib/sdl/test/template.test.in
new file mode 100644
index 000000000..e1ac063fd
--- /dev/null
+++ b/Engine/lib/sdl/test/template.test.in
@@ -0,0 +1,3 @@
+[Test]
+Type=session
+Exec=@installedtestsdir@/@exe@
diff --git a/Engine/lib/sdl/test/testatomic.c b/Engine/lib/sdl/test/testatomic.c
index 16678db5d..7dbad45a4 100644
--- a/Engine/lib/sdl/test/testatomic.c
+++ b/Engine/lib/sdl/test/testatomic.c
@@ -709,6 +709,12 @@ main(int argc, char *argv[])
     SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
 
     RunBasicTest();
+
+    if (SDL_getenv("SDL_TESTS_QUICK") != NULL) {
+        SDL_Log("Not running slower tests");
+        return 0;
+    }
+
     RunEpicTest();
 /* This test is really slow, so don't run it by default */
 #if 0
diff --git a/Engine/lib/sdl/test/testaudiohotplug.c b/Engine/lib/sdl/test/testaudiohotplug.c
index 536cc4c3b..dc84a782f 100644
--- a/Engine/lib/sdl/test/testaudiohotplug.c
+++ b/Engine/lib/sdl/test/testaudiohotplug.c
@@ -26,6 +26,7 @@
 #endif
 
 #include "SDL.h"
+#include "testutils.h"
 
 static SDL_AudioSpec spec;
 static Uint8 *sound = NULL;     /* Pointer to wave data */
@@ -137,7 +138,7 @@ int
 main(int argc, char *argv[])
 {
     int i;
-    char filename[4096];
+    char *filename = NULL;
 
     /* Enable standard application logging */
     SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
@@ -151,11 +152,13 @@ main(int argc, char *argv[])
     /* Some targets (Mac CoreAudio) need an event queue for audio hotplug, so make and immediately hide a window. */
     SDL_MinimizeWindow(SDL_CreateWindow("testaudiohotplug", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 640, 480, 0));
 
-    if (argc > 1) {
-        SDL_strlcpy(filename, argv[1], sizeof(filename));
-    } else {
-        SDL_strlcpy(filename, "sample.wav", sizeof(filename));
+    filename = GetResourceFilename(argc > 1 ? argv[1] : NULL, "sample.wav");
+
+    if (filename == NULL) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "%s\n", SDL_GetError());
+        quit(1);
     }
+
     /* Load the wave file into memory */
     if (SDL_LoadWAV(filename, &spec, &sound, &soundlen) == NULL) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't load %s: %s\n", filename, SDL_GetError());
@@ -196,6 +199,7 @@ main(int argc, char *argv[])
     /* Quit audio first, then free WAV. This prevents access violations in the audio threads. */
     SDL_QuitSubSystem(SDL_INIT_AUDIO);
     SDL_FreeWAV(sound);
+    SDL_free(filename);
     SDL_Quit();
     return (0);
 }
diff --git a/Engine/lib/sdl/test/testautomation_hints.c b/Engine/lib/sdl/test/testautomation_hints.c
index 0d1b7b6f5..91b8c02ab 100644
--- a/Engine/lib/sdl/test/testautomation_hints.c
+++ b/Engine/lib/sdl/test/testautomation_hints.c
@@ -8,7 +8,6 @@
 #include "SDL_test.h"
 
 
-const int _numHintsEnum = 25;
 const char* _HintsEnum[] =
   {
     SDL_HINT_ACCELEROMETER_AS_JOYSTICK,
@@ -32,9 +31,7 @@ const char* _HintsEnum[] =
     SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS,
     SDL_HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT,
     SDL_HINT_VIDEO_WIN_D3DCOMPILER,
-    SDL_HINT_VIDEO_X11_XINERAMA,
     SDL_HINT_VIDEO_X11_XRANDR,
-    SDL_HINT_VIDEO_X11_XVIDMODE,
     SDL_HINT_XINPUT_ENABLED,
   };
 const char* _HintsVerbose[] =
@@ -60,12 +57,13 @@ const char* _HintsVerbose[] =
     "SDL_VIDEO_MINIMIZE_ON_FOCUS_LOSS",
     "SDL_VIDEO_WINDOW_SHARE_PIXEL_FORMAT",
     "SDL_VIDEO_WIN_D3DCOMPILER",
-    "SDL_VIDEO_X11_XINERAMA",
     "SDL_VIDEO_X11_XRANDR",
-    "SDL_VIDEO_X11_XVIDMODE",
     "SDL_XINPUT_ENABLED"
   };
 
+SDL_COMPILE_TIME_ASSERT(HintsEnum, SDL_arraysize(_HintsEnum) == SDL_arraysize(_HintsVerbose));
+
+const int _numHintsEnum = SDL_arraysize(_HintsEnum);
 
 /* Test case functions */
 
diff --git a/Engine/lib/sdl/test/testautomation_platform.c b/Engine/lib/sdl/test/testautomation_platform.c
index 4e28ba166..0a31ad8cf 100644
--- a/Engine/lib/sdl/test/testautomation_platform.c
+++ b/Engine/lib/sdl/test/testautomation_platform.c
@@ -54,12 +54,18 @@ int platform_testTypes(void *arg)
 int platform_testEndianessAndSwap(void *arg)
 {
     int real_byteorder;
+    int real_floatwordorder = 0;
     Uint16 value = 0x1234;
     Uint16 value16 = 0xCDAB;
     Uint16 swapped16 = 0xABCD;
     Uint32 value32 = 0xEFBEADDE;
     Uint32 swapped32 = 0xDEADBEEF;
 
+    union {
+       double d;
+       Uint32 ui32[2];
+    } value_double;
+
     Uint64 value64, swapped64;
     value64 = 0xEFBEADDE;
     value64 <<= 32;
@@ -67,6 +73,7 @@ int platform_testEndianessAndSwap(void *arg)
     swapped64 = 0x1234ABCD;
     swapped64 <<= 32;
     swapped64 |= 0xDEADBEEF;
+    value_double.d = 3.141593;
 
     if ((*((char *) &value) >> 4) == 0x1) {
         real_byteorder = SDL_BIG_ENDIAN;
@@ -80,6 +87,18 @@ int platform_testEndianessAndSwap(void *arg)
              (SDL_BYTEORDER == SDL_LIL_ENDIAN) ? "little" : "big",
              (real_byteorder == SDL_LIL_ENDIAN) ? "little" : "big" );
 
+    if (value_double.ui32[0] == 0x82c2bd7f && value_double.ui32[1] == 0x400921fb) {
+        real_floatwordorder = SDL_LIL_ENDIAN;
+    } else if (value_double.ui32[0] == 0x400921fb && value_double.ui32[1] == 0x82c2bd7f) {
+        real_floatwordorder = SDL_BIG_ENDIAN;
+    }
+
+    /* Test endianness. */
+    SDLTest_AssertCheck( real_floatwordorder == SDL_FLOATWORDORDER,
+             "Machine detected as having %s endian float word order, appears to be %s endian.",
+             (SDL_FLOATWORDORDER == SDL_LIL_ENDIAN) ? "little" : "big",
+             (real_floatwordorder == SDL_LIL_ENDIAN) ? "little" : (real_floatwordorder == SDL_BIG_ENDIAN) ? "big" : "unknown" );
+
     /* Test 16 swap. */
     SDLTest_AssertCheck( SDL_Swap16(value16) == swapped16,
              "SDL_Swap16(): 16 bit swapped: 0x%X => 0x%X",
diff --git a/Engine/lib/sdl/test/testautomation_stdlib.c b/Engine/lib/sdl/test/testautomation_stdlib.c
index bfc8ad373..4c978fa9b 100644
--- a/Engine/lib/sdl/test/testautomation_stdlib.c
+++ b/Engine/lib/sdl/test/testautomation_stdlib.c
@@ -322,6 +322,168 @@ stdlib_sscanf(void *arg)
   return TEST_COMPLETED;
 }
 
+#if defined(_WIN64)
+# define SIZE_FORMAT "I64u"
+#elif defined(__WIN32__)
+# define SIZE_FORMAT "I32u"
+#else
+# define SIZE_FORMAT "zu"
+#endif
+
+typedef struct
+{
+    size_t a;
+    size_t b;
+    size_t result;
+    int status;
+} overflow_test;
+
+static const overflow_test multiplications[] =
+{
+    { 1, 1, 1, 0 },
+    { 0, 0, 0, 0 },
+    { SDL_SIZE_MAX, 0, 0, 0 },
+    { SDL_SIZE_MAX, 1, SDL_SIZE_MAX, 0 },
+    { SDL_SIZE_MAX / 2, 2, SDL_SIZE_MAX - (SDL_SIZE_MAX % 2), 0 },
+    { SDL_SIZE_MAX / 23, 23, SDL_SIZE_MAX - (SDL_SIZE_MAX % 23), 0 },
+
+    { (SDL_SIZE_MAX / 2) + 1, 2, 0, -1 },
+    { (SDL_SIZE_MAX / 23) + 42, 23, 0, -1 },
+    { SDL_SIZE_MAX, SDL_SIZE_MAX, 0, -1 },
+};
+
+static const overflow_test additions[] =
+{
+    { 1, 1, 2, 0 },
+    { 0, 0, 0, 0 },
+    { SDL_SIZE_MAX, 0, SDL_SIZE_MAX, 0 },
+    { SDL_SIZE_MAX - 1, 1, SDL_SIZE_MAX, 0 },
+    { SDL_SIZE_MAX - 42, 23, SDL_SIZE_MAX - (42 - 23), 0 },
+
+    { SDL_SIZE_MAX, 1, 0, -1 },
+    { SDL_SIZE_MAX, 23, 0, -1 },
+    { SDL_SIZE_MAX, SDL_SIZE_MAX, 0, -1 },
+};
+
+static int
+stdlib_overflow(void *arg)
+{
+  size_t i;
+  size_t useBuiltin;
+
+  for (useBuiltin = 0; useBuiltin < 2; useBuiltin++) {
+      if (useBuiltin) {
+          SDLTest_Log("Using gcc/clang builtins if possible");
+      } else {
+          SDLTest_Log("Not using gcc/clang builtins");
+      }
+
+      for (i = 0; i < SDL_arraysize(multiplications); i++) {
+          const overflow_test *t = &multiplications[i];
+          int status;
+          size_t result = ~t->result;
+
+          if (useBuiltin) {
+              status = SDL_size_mul_overflow(t->a, t->b, &result);
+          } else {
+              /* This disables the macro that tries to use a gcc/clang
+               * builtin, so we test the fallback implementation instead. */
+              status = (SDL_size_mul_overflow)(t->a, t->b, &result);
+          }
+
+          if (t->status == 0) {
+              SDLTest_AssertCheck(status == 0,
+                                  "(%" SIZE_FORMAT " * %" SIZE_FORMAT ") should succeed",
+                                  t->a, t->b);
+              SDLTest_AssertCheck(result == t->result,
+                                  "(%" SIZE_FORMAT " * %" SIZE_FORMAT "): expected %" SIZE_FORMAT ", got %" SIZE_FORMAT,
+                                  t->a, t->b, t->result, result);
+          } else {
+              SDLTest_AssertCheck(status == -1,
+                                  "(%" SIZE_FORMAT " * %" SIZE_FORMAT ") should fail",
+                                  t->a, t->b);
+          }
+
+          if (t->a == t->b) {
+              continue;
+          }
+
+          result = ~t->result;
+
+          if (useBuiltin) {
+              status = SDL_size_mul_overflow(t->b, t->a, &result);
+          } else {
+              status = (SDL_size_mul_overflow)(t->b, t->a, &result);
+          }
+
+          if (t->status == 0) {
+              SDLTest_AssertCheck(status == 0,
+                                  "(%" SIZE_FORMAT " * %" SIZE_FORMAT ") should succeed",
+                                  t->b, t->a);
+              SDLTest_AssertCheck(result == t->result,
+                                  "(%" SIZE_FORMAT " * %" SIZE_FORMAT "): expected %" SIZE_FORMAT ", got %" SIZE_FORMAT,
+                                  t->b, t->a, t->result, result);
+          } else {
+              SDLTest_AssertCheck(status == -1,
+                                  "(%" SIZE_FORMAT " * %" SIZE_FORMAT ") should fail",
+                                  t->b, t->a);
+          }
+      }
+
+      for (i = 0; i < SDL_arraysize(additions); i++) {
+          const overflow_test *t = &additions[i];
+          int status;
+          size_t result = ~t->result;
+
+          if (useBuiltin) {
+              status = SDL_size_add_overflow(t->a, t->b, &result);
+          } else {
+              status = (SDL_size_add_overflow)(t->a, t->b, &result);
+          }
+
+          if (t->status == 0) {
+              SDLTest_AssertCheck(status == 0,
+                                  "(%" SIZE_FORMAT " + %" SIZE_FORMAT ") should succeed",
+                                  t->a, t->b);
+              SDLTest_AssertCheck(result == t->result,
+                                  "(%" SIZE_FORMAT " + %" SIZE_FORMAT "): expected %" SIZE_FORMAT ", got %" SIZE_FORMAT,
+                                  t->a, t->b, t->result, result);
+          } else {
+              SDLTest_AssertCheck(status == -1,
+                                  "(%" SIZE_FORMAT " + %" SIZE_FORMAT ") should fail",
+                                  t->a, t->b);
+          }
+
+          if (t->a == t->b) {
+              continue;
+          }
+
+          result = ~t->result;
+
+          if (useBuiltin) {
+              status = SDL_size_add_overflow(t->b, t->a, &result);
+          } else {
+              status = (SDL_size_add_overflow)(t->b, t->a, &result);
+          }
+
+          if (t->status == 0) {
+              SDLTest_AssertCheck(status == 0,
+                                  "(%" SIZE_FORMAT " + %" SIZE_FORMAT ") should succeed",
+                                  t->b, t->a);
+              SDLTest_AssertCheck(result == t->result,
+                                  "(%" SIZE_FORMAT " + %" SIZE_FORMAT "): expected %" SIZE_FORMAT ", got %" SIZE_FORMAT,
+                                  t->b, t->a, t->result, result);
+          } else {
+              SDLTest_AssertCheck(status == -1,
+                                  "(%" SIZE_FORMAT " + %" SIZE_FORMAT ") should fail",
+                                  t->b, t->a);
+          }
+      }
+  }
+
+  return TEST_COMPLETED;
+}
+
 /* ================= Test References ================== */
 
 /* Standard C routine test cases */
@@ -337,9 +499,17 @@ static const SDLTest_TestCaseReference stdlibTest3 =
 static const SDLTest_TestCaseReference stdlibTest4 =
         { (SDLTest_TestCaseFp)stdlib_sscanf, "stdlib_sscanf", "Call to SDL_sscanf", TEST_ENABLED };
 
+static const SDLTest_TestCaseReference stdlibTestOverflow =
+        { stdlib_overflow, "stdlib_overflow", "Overflow detection", TEST_ENABLED };
+
 /* Sequence of Standard C routine test cases */
 static const SDLTest_TestCaseReference *stdlibTests[] =  {
-    &stdlibTest1, &stdlibTest2, &stdlibTest3, &stdlibTest4, NULL
+    &stdlibTest1,
+    &stdlibTest2,
+    &stdlibTest3,
+    &stdlibTest4,
+    &stdlibTestOverflow,
+    NULL
 };
 
 /* Standard C routine test suite (global) */
diff --git a/Engine/lib/sdl/test/testcustomcursor.c b/Engine/lib/sdl/test/testcustomcursor.c
index 2feee81a2..d29c1c56f 100644
--- a/Engine/lib/sdl/test/testcustomcursor.c
+++ b/Engine/lib/sdl/test/testcustomcursor.c
@@ -160,7 +160,28 @@ loop()
                 if (current_cursor == SDL_arraysize(cursors)) {
                     current_cursor = 0;
                 }
+
                 SDL_SetCursor(cursors[current_cursor]);
+
+                if (current_cursor == 0) {
+                    SDL_Log("Custom cursor");
+                } else {
+                    switch ((SDL_SystemCursor) (current_cursor-1)) {
+                        case SDL_SYSTEM_CURSOR_ARROW:     SDL_Log("Arrow"); break;
+                        case SDL_SYSTEM_CURSOR_IBEAM:     SDL_Log("I-beam"); break;
+                        case SDL_SYSTEM_CURSOR_WAIT:      SDL_Log("Wait"); break;
+                        case SDL_SYSTEM_CURSOR_CROSSHAIR: SDL_Log("Crosshair"); break;
+                        case SDL_SYSTEM_CURSOR_WAITARROW: SDL_Log("Small wait cursor (or Wait if not available)"); break;
+                        case SDL_SYSTEM_CURSOR_SIZENWSE:  SDL_Log("Double arrow pointing northwest and southeast"); break;
+                        case SDL_SYSTEM_CURSOR_SIZENESW:  SDL_Log("Double arrow pointing northeast and southwest"); break;
+                        case SDL_SYSTEM_CURSOR_SIZEWE:    SDL_Log("Double arrow pointing west and east"); break;
+                        case SDL_SYSTEM_CURSOR_SIZENS:    SDL_Log("Double arrow pointing north and south"); break;
+                        case SDL_SYSTEM_CURSOR_SIZEALL:   SDL_Log("Four pointed arrow pointing north, south, east, and west"); break;
+                        case SDL_SYSTEM_CURSOR_NO:        SDL_Log("Slashed circle or crossbones"); break;
+                        case SDL_SYSTEM_CURSOR_HAND:      SDL_Log("Hand"); break;
+                        default: SDL_Log("UNKNOWN CURSOR TYPE, FIX THIS PROGRAM."); break;
+                    }
+                }
             } else {
                 show_cursor = !show_cursor;
                 SDL_ShowCursor(show_cursor);
diff --git a/Engine/lib/sdl/test/testerror.c b/Engine/lib/sdl/test/testerror.c
index e847c2824..c118abdee 100644
--- a/Engine/lib/sdl/test/testerror.c
+++ b/Engine/lib/sdl/test/testerror.c
@@ -58,6 +58,12 @@ main(int argc, char *argv[])
     /* Set the error value for the main thread */
     SDL_SetError("No worries");
 
+    if (SDL_getenv("SDL_TESTS_QUICK") != NULL) {
+        SDL_Log("Not running slower tests");
+        SDL_Quit();
+        return 0;
+    }
+
     alive = 1;
     thread = SDL_CreateThread(ThreadFunc, NULL, "#1");
     if (thread == NULL) {
diff --git a/Engine/lib/sdl/test/testevdev.c b/Engine/lib/sdl/test/testevdev.c
index 76a12ef7e..938a9a504 100644
--- a/Engine/lib/sdl/test/testevdev.c
+++ b/Engine/lib/sdl/test/testevdev.c
@@ -1019,7 +1019,7 @@ static int
 run_test(void)
 {
     printf("SDL compiled without evdev capability check.\n");
-    return 0;
+    return 1;
 }
 
 #endif
diff --git a/Engine/lib/sdl/test/testgamecontroller.c b/Engine/lib/sdl/test/testgamecontroller.c
index 17fb60bd3..011e5cd6d 100644
--- a/Engine/lib/sdl/test/testgamecontroller.c
+++ b/Engine/lib/sdl/test/testgamecontroller.c
@@ -17,6 +17,7 @@
 #include <string.h>
 
 #include "SDL.h"
+#include "testutils.h"
 
 #ifdef __EMSCRIPTEN__
 #include <emscripten/emscripten.h>
@@ -27,6 +28,10 @@
 #define SCREEN_WIDTH    512
 #define SCREEN_HEIGHT   320
 
+#define BUTTON_SIZE     50
+#define AXIS_SIZE       50
+
+
 /* This is indexed by SDL_GameControllerButton. */
 static const struct { int x; int y; } button_positions[] = {
     {387, 167},  /* SDL_CONTROLLER_BUTTON_A */
@@ -49,7 +54,9 @@ static const struct { int x; int y; } button_positions[] = {
     {330, 135},  /* SDL_CONTROLLER_BUTTON_PADDLE2 */
     {132, 175},  /* SDL_CONTROLLER_BUTTON_PADDLE3 */
     {330, 175},  /* SDL_CONTROLLER_BUTTON_PADDLE4 */
+    {0, 0},      /* SDL_CONTROLLER_BUTTON_TOUCHPAD */
 };
+SDL_COMPILE_TIME_ASSERT(button_positions, SDL_arraysize(button_positions) == SDL_CONTROLLER_BUTTON_MAX);
 
 /* This is indexed by SDL_GameControllerAxis. */
 static const struct { int x; int y; double angle; } axis_positions[] = {
@@ -60,6 +67,7 @@ static const struct { int x; int y; double angle; } axis_positions[] = {
     {91,  -20,   0.0},  /* TRIGGERLEFT */
     {375, -20,   0.0},  /* TRIGGERRIGHT */
 };
+SDL_COMPILE_TIME_ASSERT(axis_positions, SDL_arraysize(axis_positions) == SDL_CONTROLLER_AXIS_MAX);
 
 static SDL_Window *window = NULL;
 static SDL_Renderer *screen = NULL;
@@ -71,6 +79,11 @@ static SDL_Texture *background_front, *background_back, *button, *axis;
 static SDL_GameController *gamecontroller;
 static SDL_GameController **gamecontrollers;
 static int num_controllers = 0;
+static SDL_Joystick *virtual_joystick = NULL;
+static SDL_GameControllerAxis virtual_axis_active = SDL_CONTROLLER_AXIS_INVALID;
+static int virtual_axis_start_x;
+static int virtual_axis_start_y;
+static SDL_GameControllerButton virtual_button_active = SDL_CONTROLLER_BUTTON_INVALID;
 
 static void UpdateWindowTitle()
 {
@@ -151,7 +164,8 @@ static void AddController(int device_index, SDL_bool verbose)
 
     if (verbose) {
         const char *name = SDL_GameControllerName(gamecontroller);
-        SDL_Log("Opened game controller %s\n", name);
+        const char *path = SDL_GameControllerPath(gamecontroller);
+        SDL_Log("Opened game controller %s%s%s\n", name, path ? ", " : "", path ? path : "");
     }
 
     if (SDL_GameControllerHasSensor(gamecontroller, SDL_SENSOR_ACCEL)) {
@@ -216,34 +230,6 @@ static void DelController(SDL_JoystickID controller)
     UpdateWindowTitle();
 }
 
-static SDL_Texture *
-LoadTexture(SDL_Renderer *renderer, const char *file, SDL_bool transparent)
-{
-    SDL_Surface *temp = NULL;
-    SDL_Texture *texture = NULL;
-
-    temp = SDL_LoadBMP(file);
-    if (temp == NULL) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't load %s: %s", file, SDL_GetError());
-    } else {
-        /* Set transparent pixel as the pixel at (0,0) */
-        if (transparent) {
-            if (temp->format->BytesPerPixel == 1) {
-                SDL_SetColorKey(temp, SDL_TRUE, *(Uint8 *)temp->pixels);
-            }
-        }
-
-        texture = SDL_CreateTextureFromSurface(renderer, temp);
-        if (!texture) {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create texture: %s\n", SDL_GetError());
-        }
-    }
-    if (temp) {
-        SDL_FreeSurface(temp);
-    }
-    return texture;
-}
-
 static Uint16 ConvertAxisToRumble(Sint16 axisval)
 {
     /* Only start rumbling if the axis is past the halfway point */
@@ -306,12 +292,223 @@ static void CyclePS5TriggerEffect()
     SDL_GameControllerSendEffect(gamecontroller, &state, sizeof(state));
 }
 
+static SDL_bool ShowingFront()
+{
+    SDL_bool showing_front = SDL_TRUE;
+    int i;
+
+    if (gamecontroller) {
+        /* Show the back of the controller if the paddles are being held */
+        for (i = SDL_CONTROLLER_BUTTON_PADDLE1; i <= SDL_CONTROLLER_BUTTON_PADDLE4; ++i) {
+            if (SDL_GameControllerGetButton(gamecontroller, (SDL_GameControllerButton)i) == SDL_PRESSED) {
+                showing_front = SDL_FALSE;
+                break;
+            }
+        }
+    }
+    if ((SDL_GetModState() & KMOD_SHIFT) != 0) {
+        showing_front = SDL_FALSE;
+    }
+    return showing_front;
+}
+
+static void SDLCALL VirtualControllerSetPlayerIndex(void *userdata, int player_index)
+{
+    SDL_Log("Virtual Controller: player index set to %d\n", player_index);
+}
+
+static int SDLCALL VirtualControllerRumble(void *userdata, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+{
+    SDL_Log("Virtual Controller: rumble set to %d/%d\n", low_frequency_rumble, high_frequency_rumble);
+    return 0;
+}
+
+static int SDLCALL VirtualControllerRumbleTriggers(void *userdata, Uint16 left_rumble, Uint16 right_rumble)
+{
+    SDL_Log("Virtual Controller: trigger rumble set to %d/%d\n", left_rumble, right_rumble);
+    return 0;
+}
+
+static int SDLCALL VirtualControllerSetLED(void *userdata, Uint8 red, Uint8 green, Uint8 blue)
+{
+    SDL_Log("Virtual Controller: LED set to RGB %d,%d,%d\n", red, green, blue);
+    return 0;
+}
+
+static void OpenVirtualController()
+{
+    SDL_VirtualJoystickDesc desc;
+    int virtual_index;
+
+    SDL_zero(desc);
+    desc.version = SDL_VIRTUAL_JOYSTICK_DESC_VERSION;
+    desc.type = SDL_JOYSTICK_TYPE_GAMECONTROLLER;
+    desc.naxes = SDL_CONTROLLER_AXIS_MAX;
+    desc.nbuttons = SDL_CONTROLLER_BUTTON_MAX;
+    desc.SetPlayerIndex = VirtualControllerSetPlayerIndex;
+    desc.Rumble = VirtualControllerRumble;
+    desc.RumbleTriggers = VirtualControllerRumbleTriggers;
+    desc.SetLED = VirtualControllerSetLED;
+
+    virtual_index = SDL_JoystickAttachVirtualEx(&desc);
+    if (virtual_index < 0) {
+        SDL_Log("Couldn't open virtual device: %s\n", SDL_GetError());
+    } else {
+        virtual_joystick = SDL_JoystickOpen(virtual_index);
+        if (!virtual_joystick) {
+            SDL_Log("Couldn't open virtual device: %s\n", SDL_GetError());
+        }
+    }
+}
+
+static void CloseVirtualController()
+{
+    int i;
+
+    for (i = SDL_NumJoysticks(); i--; ) {
+        if (SDL_JoystickIsVirtual(i)) {
+            SDL_JoystickDetachVirtual(i);
+        }
+    }
+
+    if (virtual_joystick) {
+        SDL_JoystickClose(virtual_joystick);
+        virtual_joystick = NULL;
+    }
+}
+
+static SDL_GameControllerButton FindButtonAtPosition(int x, int y)
+{
+    SDL_Point point;
+    int i;
+    SDL_bool showing_front = ShowingFront();
+
+    point.x = x;
+    point.y = y;
+    for (i = 0; i < SDL_CONTROLLER_BUTTON_TOUCHPAD; ++i) {
+        SDL_bool on_front = (i < SDL_CONTROLLER_BUTTON_PADDLE1 || i > SDL_CONTROLLER_BUTTON_PADDLE4);
+        if (on_front == showing_front) {
+            SDL_Rect rect;
+            rect.x = button_positions[i].x;
+            rect.y = button_positions[i].y;
+            rect.w = BUTTON_SIZE;
+            rect.h = BUTTON_SIZE;
+            if (SDL_PointInRect(&point, &rect)) {
+                return (SDL_GameControllerButton)i;
+            }
+        }
+    }
+    return SDL_CONTROLLER_BUTTON_INVALID;
+}
+
+static SDL_GameControllerAxis FindAxisAtPosition(int x, int y)
+{
+    SDL_Point point;
+    int i;
+    SDL_bool showing_front = ShowingFront();
+
+    point.x = x;
+    point.y = y;
+    for (i = 0; i < SDL_CONTROLLER_AXIS_MAX; ++i) {
+        if (showing_front) {
+            SDL_Rect rect;
+            rect.x = axis_positions[i].x;
+            rect.y = axis_positions[i].y;
+            rect.w = AXIS_SIZE;
+            rect.h = AXIS_SIZE;
+            if (SDL_PointInRect(&point, &rect)) {
+                return (SDL_GameControllerAxis)i;
+            }
+        }
+    }
+    return SDL_CONTROLLER_AXIS_INVALID;
+}
+
+static void VirtualControllerMouseMotion(int x, int y)
+{
+    if (virtual_button_active != SDL_CONTROLLER_BUTTON_INVALID) {
+        if (virtual_axis_active != SDL_CONTROLLER_AXIS_INVALID) {
+            const int MOVING_DISTANCE = 2;
+            if (SDL_abs(x - virtual_axis_start_x) >= MOVING_DISTANCE ||
+                SDL_abs(y - virtual_axis_start_y) >= MOVING_DISTANCE) {
+                SDL_JoystickSetVirtualButton(virtual_joystick, virtual_button_active, SDL_RELEASED);
+                virtual_button_active = SDL_CONTROLLER_BUTTON_INVALID;
+            }
+        }
+    }
+
+    if (virtual_axis_active != SDL_CONTROLLER_AXIS_INVALID) {
+        if (virtual_axis_active == SDL_CONTROLLER_AXIS_TRIGGERLEFT ||
+            virtual_axis_active == SDL_CONTROLLER_AXIS_TRIGGERRIGHT) {
+            int range = (SDL_JOYSTICK_AXIS_MAX - SDL_JOYSTICK_AXIS_MIN);
+            float distance = SDL_clamp(((float)y - virtual_axis_start_y) / AXIS_SIZE, 0.0f, 1.0f);
+            Sint16 value = (Sint16)(SDL_JOYSTICK_AXIS_MIN + (distance * range));
+            SDL_JoystickSetVirtualAxis(virtual_joystick, virtual_axis_active, value);
+        } else {
+            float distanceX = SDL_clamp(((float)x - virtual_axis_start_x) / AXIS_SIZE, -1.0f, 1.0f);
+            float distanceY = SDL_clamp(((float)y - virtual_axis_start_y) / AXIS_SIZE, -1.0f, 1.0f);
+            Sint16 valueX, valueY;
+
+            if (distanceX >= 0) {
+                valueX = (Sint16)(distanceX * SDL_JOYSTICK_AXIS_MAX);
+            } else {
+                valueX = (Sint16)(distanceX * -SDL_JOYSTICK_AXIS_MIN);
+            }
+            if (distanceY >= 0) {
+                valueY = (Sint16)(distanceY * SDL_JOYSTICK_AXIS_MAX);
+            } else {
+                valueY = (Sint16)(distanceY * -SDL_JOYSTICK_AXIS_MIN);
+            }
+            SDL_JoystickSetVirtualAxis(virtual_joystick, virtual_axis_active, valueX);
+            SDL_JoystickSetVirtualAxis(virtual_joystick, virtual_axis_active+1, valueY);
+        }
+    }
+}
+
+static void VirtualControllerMouseDown(int x, int y)
+{
+    SDL_GameControllerButton button;
+    SDL_GameControllerAxis axis;
+
+    button = FindButtonAtPosition(x, y);
+    if (button != SDL_CONTROLLER_BUTTON_INVALID) {
+        virtual_button_active = button;
+        SDL_JoystickSetVirtualButton(virtual_joystick, virtual_button_active, SDL_PRESSED);
+    }
+
+    axis = FindAxisAtPosition(x, y);
+    if (axis != SDL_CONTROLLER_AXIS_INVALID) {
+        virtual_axis_active = axis;
+        virtual_axis_start_x = x;
+        virtual_axis_start_y = y;
+    }
+}
+
+static void VirtualControllerMouseUp(int x, int y)
+{
+    if (virtual_button_active != SDL_CONTROLLER_BUTTON_INVALID) {
+        SDL_JoystickSetVirtualButton(virtual_joystick, virtual_button_active, SDL_RELEASED);
+        virtual_button_active = SDL_CONTROLLER_BUTTON_INVALID;
+    }
+
+    if (virtual_axis_active != SDL_CONTROLLER_AXIS_INVALID) {
+        if (virtual_axis_active == SDL_CONTROLLER_AXIS_TRIGGERLEFT ||
+            virtual_axis_active == SDL_CONTROLLER_AXIS_TRIGGERRIGHT) {
+            SDL_JoystickSetVirtualAxis(virtual_joystick, virtual_axis_active, SDL_JOYSTICK_AXIS_MIN);
+        } else {
+            SDL_JoystickSetVirtualAxis(virtual_joystick, virtual_axis_active, 0);
+            SDL_JoystickSetVirtualAxis(virtual_joystick, virtual_axis_active+1, 0);
+        }
+        virtual_axis_active = SDL_CONTROLLER_AXIS_INVALID;
+    }
+}
+
 void
 loop(void *arg)
 {
     SDL_Event event;
     int i;
-    SDL_bool showing_front = SDL_TRUE;
+    SDL_bool showing_front;
 
     /* Update to get the current event state */
     SDL_PumpEvents();
@@ -382,6 +579,24 @@ loop(void *arg)
             }
             break;
 
+        case SDL_MOUSEBUTTONDOWN:
+            if (virtual_joystick) {
+                VirtualControllerMouseDown(event.button.x, event.button.y);
+            }
+            break;
+
+        case SDL_MOUSEBUTTONUP:
+            if (virtual_joystick) {
+                VirtualControllerMouseUp(event.button.x, event.button.y);
+            }
+            break;
+
+        case SDL_MOUSEMOTION:
+            if (virtual_joystick) {
+                VirtualControllerMouseMotion(event.motion.x, event.motion.y);
+            }
+            break;
+
         case SDL_KEYDOWN:
             if (event.key.keysym.sym >= SDLK_0 && event.key.keysym.sym <= SDLK_9) {
                 if (gamecontroller) {
@@ -391,6 +606,14 @@ loop(void *arg)
                 }
                 break;
             }
+            if (event.key.keysym.sym == SDLK_a) {
+                OpenVirtualController();
+                break;
+            }
+            if (event.key.keysym.sym == SDLK_d) {
+                CloseVirtualController();
+                break;
+            }
             if (event.key.keysym.sym != SDLK_ESCAPE) {
                 break;
             }
@@ -403,15 +626,7 @@ loop(void *arg)
         }
     }
 
-    if (gamecontroller) {
-        /* Show the back of the controller if the paddles are being held */
-        for (i = SDL_CONTROLLER_BUTTON_PADDLE1; i <= SDL_CONTROLLER_BUTTON_PADDLE4; ++i) {
-            if (SDL_GameControllerGetButton(gamecontroller, (SDL_GameControllerButton)i) == SDL_PRESSED) {
-                showing_front = SDL_FALSE;
-                break;
-            }
-        }
-    }
+    showing_front = ShowingFront();
 
     /* blank screen, set up for drawing this frame. */
     SDL_SetRenderDrawColor(screen, 0xFF, 0xFF, 0xFF, SDL_ALPHA_OPAQUE);
@@ -427,8 +642,8 @@ loop(void *arg)
                     SDL_Rect dst;
                     dst.x = button_positions[i].x;
                     dst.y = button_positions[i].y;
-                    dst.w = 50;
-                    dst.h = 50;
+                    dst.w = BUTTON_SIZE;
+                    dst.h = BUTTON_SIZE;
                     SDL_RenderCopyEx(screen, button, NULL, &dst, 0, NULL, SDL_FLIP_NONE);
                 }
             }
@@ -443,16 +658,16 @@ loop(void *arg)
                     SDL_Rect dst;
                     dst.x = axis_positions[i].x;
                     dst.y = axis_positions[i].y;
-                    dst.w = 50;
-                    dst.h = 50;
+                    dst.w = AXIS_SIZE;
+                    dst.h = AXIS_SIZE;
                     SDL_RenderCopyEx(screen, axis, NULL, &dst, angle, NULL, SDL_FLIP_NONE);
                 } else if (value > deadzone) {
                     const double angle = axis_positions[i].angle + 180.0;
                     SDL_Rect dst;
                     dst.x = axis_positions[i].x;
                     dst.y = axis_positions[i].y;
-                    dst.w = 50;
-                    dst.h = 50;
+                    dst.w = AXIS_SIZE;
+                    dst.h = AXIS_SIZE;
                     SDL_RenderCopyEx(screen, axis, NULL, &dst, angle, NULL, SDL_FLIP_NONE);
                 }
             }
@@ -507,7 +722,7 @@ loop(void *arg)
             }
         }
     }
-
+    SDL_Delay(16);
     SDL_RenderPresent(screen);
 
 #ifdef __EMSCRIPTEN__
@@ -560,6 +775,7 @@ main(int argc, char *argv[])
     /* Print information about the controller */
     for (i = 0; i < SDL_NumJoysticks(); ++i) {
         const char *name;
+        const char *path;
         const char *description;
 
         SDL_JoystickGetGUIDString(SDL_JoystickGetDeviceGUID(i),
@@ -568,6 +784,7 @@ main(int argc, char *argv[])
         if (SDL_IsGameController(i)) {
             controller_count++;
             name = SDL_GameControllerNameForIndex(i);
+            path = SDL_GameControllerPathForIndex(i);
             switch (SDL_GameControllerTypeForIndex(i)) {
             case SDL_CONTROLLER_TYPE_AMAZON_LUNA:
                 description = "Amazon Luna Controller";
@@ -603,10 +820,11 @@ main(int argc, char *argv[])
             AddController(i, SDL_FALSE);
         } else {
             name = SDL_JoystickNameForIndex(i);
+            path = SDL_JoystickPathForIndex(i);
             description = "Joystick";
         }
-        SDL_Log("%s %d: %s (guid %s, VID 0x%.4x, PID 0x%.4x, player index = %d)\n",
-            description, i, name ? name : "Unknown", guid,
+        SDL_Log("%s %d: %s%s%s (guid %s, VID 0x%.4x, PID 0x%.4x, player index = %d)\n",
+            description, i, name ? name : "Unknown", path ? ", " : "", path ? path : "", guid,
             SDL_JoystickGetDeviceVendor(i), SDL_JoystickGetDeviceProduct(i), SDL_JoystickGetDevicePlayerIndex(i));
     }
     SDL_Log("There are %d game controller(s) attached (%d joystick(s))\n", controller_count, SDL_NumJoysticks());
@@ -634,10 +852,10 @@ main(int argc, char *argv[])
     /* scale for platforms that don't give you the window size you asked for. */
     SDL_RenderSetLogicalSize(screen, SCREEN_WIDTH, SCREEN_HEIGHT);
 
-    background_front = LoadTexture(screen, "controllermap.bmp", SDL_FALSE);
-    background_back = LoadTexture(screen, "controllermap_back.bmp", SDL_FALSE);
-    button = LoadTexture(screen, "button.bmp", SDL_TRUE);
-    axis = LoadTexture(screen, "axis.bmp", SDL_TRUE);
+    background_front = LoadTexture(screen, "controllermap.bmp", SDL_FALSE, NULL, NULL);
+    background_back = LoadTexture(screen, "controllermap_back.bmp", SDL_FALSE, NULL, NULL);
+    button = LoadTexture(screen, "button.bmp", SDL_TRUE, NULL, NULL);
+    axis = LoadTexture(screen, "axis.bmp", SDL_TRUE, NULL, NULL);
 
     if (!background_front || !background_back || !button || !axis) {
         SDL_DestroyRenderer(screen);
@@ -650,8 +868,14 @@ main(int argc, char *argv[])
     /* !!! FIXME: */
     /*SDL_RenderSetLogicalSize(screen, background->w, background->h);*/
 
-    if (argv[1] && *argv[1] != '-') {
-        controller_index = SDL_atoi(argv[1]);
+    for (i = 1; i < argc; ++i) {
+        if (SDL_strcmp(argv[i], "--virtual") == 0) {
+            OpenVirtualController();
+        }
+        if (argv[i] && *argv[i] != '-') {
+            controller_index = SDL_atoi(argv[i]);
+            break;
+        }
     }
     if (controller_index < num_controllers) {
         gamecontroller = gamecontrollers[controller_index];
@@ -675,6 +899,7 @@ main(int argc, char *argv[])
         CyclePS5TriggerEffect();
     }
 
+    CloseVirtualController();
     SDL_DestroyRenderer(screen);
     SDL_DestroyWindow(window);
     SDL_QuitSubSystem(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER);
diff --git a/Engine/lib/sdl/test/testgeometry.c b/Engine/lib/sdl/test/testgeometry.c
index 3a87e3d2e..f0f07eed6 100644
--- a/Engine/lib/sdl/test/testgeometry.c
+++ b/Engine/lib/sdl/test/testgeometry.c
@@ -21,6 +21,7 @@
 #endif
 
 #include "SDL_test_common.h"
+#include "testutils.h"
 
 static SDLTest_CommonState *state;
 static SDL_bool use_texture = SDL_FALSE;
@@ -44,54 +45,19 @@ int
 LoadSprite(const char *file)
 {
     int i;
-    SDL_Surface *temp;
 
-    /* Load the sprite image */
-    temp = SDL_LoadBMP(file);
-    if (temp == NULL) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't load %s: %s", file, SDL_GetError());
-        return (-1);
-    }
-    sprite_w = temp->w;
-    sprite_h = temp->h;
-
-    /* Set transparent pixel as the pixel at (0,0) */
-    if (temp->format->palette) {
-        SDL_SetColorKey(temp, 1, *(Uint8 *) temp->pixels);
-    } else {
-        switch (temp->format->BitsPerPixel) {
-        case 15:
-            SDL_SetColorKey(temp, 1, (*(Uint16 *) temp->pixels) & 0x00007FFF);
-            break;
-        case 16:
-            SDL_SetColorKey(temp, 1, *(Uint16 *) temp->pixels);
-            break;
-        case 24:
-            SDL_SetColorKey(temp, 1, (*(Uint32 *) temp->pixels) & 0x00FFFFFF);
-            break;
-        case 32:
-            SDL_SetColorKey(temp, 1, *(Uint32 *) temp->pixels);
-            break;
-        }
-    }
-
-    /* Create textures from the image */
     for (i = 0; i < state->num_windows; ++i) {
-        SDL_Renderer *renderer = state->renderers[i];
-        sprites[i] = SDL_CreateTextureFromSurface(renderer, temp);
+        /* This does the SDL_LoadBMP step repeatedly, but that's OK for test code. */
+        sprites[i] = LoadTexture(state->renderers[i], file, SDL_TRUE, &sprite_w, &sprite_h);
         if (!sprites[i]) {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create texture: %s\n", SDL_GetError());
-            SDL_FreeSurface(temp);
             return (-1);
         }
         if (SDL_SetTextureBlendMode(sprites[i], blendMode) < 0) {
             SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't set blend mode: %s\n", SDL_GetError());
-            SDL_FreeSurface(temp);
             SDL_DestroyTexture(sprites[i]);
             return (-1);
         }
     }
-    SDL_FreeSurface(temp);
 
     /* We're ready to roll. :) */
     return (0);
diff --git a/Engine/lib/sdl/test/testgles2_sdf.c b/Engine/lib/sdl/test/testgles2_sdf.c
index a7f8016ea..064b6bc2c 100644
--- a/Engine/lib/sdl/test/testgles2_sdf.c
+++ b/Engine/lib/sdl/test/testgles2_sdf.c
@@ -458,6 +458,7 @@ main(int argc, char *argv[])
     Uint32 then, now;
     int status;
     shader_data *data;
+    char *path = NULL;
 
     /* Initialize parameters */
     fsaa = 0;
@@ -561,14 +562,25 @@ main(int argc, char *argv[])
 
         /* Load SDF BMP image */
 #if 1
-        tmp = SDL_LoadBMP(f);
-        if  (tmp == NULL) {
-            SDL_Log("missing image file: %s", f);
+        path = GetNearbyFilename(f);
+
+        if (path == NULL)
+            path = SDL_strdup(f);
+
+        if (path == NULL) {
+            SDL_Log("out of memory\n");
             exit(-1);
-        } else {
-            SDL_Log("Load image file: %s", f);
         }
 
+        tmp = SDL_LoadBMP(path);
+        if  (tmp == NULL) {
+            SDL_Log("missing image file: %s", path);
+            exit(-1);
+        } else {
+            SDL_Log("Load image file: %s", path);
+        }
+
+        SDL_free(path);
 #else
         /* Generate SDF image using SDL_ttf */
 
diff --git a/Engine/lib/sdl/test/testiconv.c b/Engine/lib/sdl/test/testiconv.c
index bf9ad3b92..31d05e195 100644
--- a/Engine/lib/sdl/test/testiconv.c
+++ b/Engine/lib/sdl/test/testiconv.c
@@ -13,6 +13,7 @@
 #include <stdio.h>
 
 #include "SDL.h"
+#include "testutils.h"
 
 static size_t
 widelen(char *data)
@@ -43,7 +44,7 @@ main(int argc, char *argv[])
         "UCS-4",
     };
 
-    const char * fname;
+    char * fname;
     char buffer[BUFSIZ];
     char *ucs4;
     char *test[2];
@@ -54,12 +55,13 @@ main(int argc, char *argv[])
     /* Enable standard application logging */
     SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
 
-    fname = (argc < 2) ? "utf8.txt" : argv[1];
+    fname = GetResourceFilename(argc > 1 ? argv[1] : NULL, "utf8.txt");
     file = fopen(fname, "rb");
     if (!file) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Unable to open %s\n", fname);
         return (1);
     }
+    SDL_free(fname);
 
     while (fgets(buffer, sizeof(buffer), file)) {
         /* Convert to UCS-4 */
diff --git a/Engine/lib/sdl/test/testime.c b/Engine/lib/sdl/test/testime.c
index 5541d484f..155834229 100644
--- a/Engine/lib/sdl/test/testime.c
+++ b/Engine/lib/sdl/test/testime.c
@@ -23,6 +23,7 @@
 #endif
 
 #include "SDL_test_common.h"
+#include "testutils.h"
 
 #define DEFAULT_PTSIZE 30
 #ifdef HAVE_SDL_TTF
@@ -108,6 +109,7 @@ static int unifont_init(const char *fontname)
     SDL_RWops *hexFile;
     const size_t unifontGlyphSize = UNIFONT_NUM_GLYPHS * sizeof(struct UnifontGlyph);
     const size_t unifontTextureSize = UNIFONT_NUM_TEXTURES * state->num_windows * sizeof(void *);
+    char *filename;
 
     /* Allocate memory for the glyph data so the file can be closed after initialization. */
     unifontGlyph = (struct UnifontGlyph *)SDL_malloc(unifontGlyphSize);
@@ -127,7 +129,13 @@ static int unifont_init(const char *fontname)
     }
     SDL_memset(unifontTexture, 0, unifontTextureSize);
 
-    hexFile = SDL_RWFromFile(fontname, "rb");
+    filename = GetResourceFilename(NULL, fontname);
+    if (filename == NULL) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Out of memory\n");
+        return -1;
+    }
+    hexFile = SDL_RWFromFile(filename, "rb");
+    SDL_free(filename);
     if (hexFile == NULL)
     {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "unifont: Failed to open font file: %s\n", fontname);
diff --git a/Engine/lib/sdl/test/testmultiaudio.c b/Engine/lib/sdl/test/testmultiaudio.c
index 51a7ff03c..1154b83af 100644
--- a/Engine/lib/sdl/test/testmultiaudio.c
+++ b/Engine/lib/sdl/test/testmultiaudio.c
@@ -17,6 +17,8 @@
 #include <emscripten/emscripten.h>
 #endif
 
+#include "testutils.h"
+
 static SDL_AudioSpec spec;
 static Uint8 *sound = NULL;     /* Pointer to wave data */
 static Uint32 soundlen = 0;     /* Length of wave data */
@@ -180,7 +182,7 @@ main(int argc, char **argv)
     if (devcount < 1) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Don't see any specific audio devices!\n");
     } else {
-        const char *file = (argc < 2) ? "sample.wav" : argv[1];
+        char *file = GetResourceFilename(argc > 1 ? argv[1] : NULL, "sample.wav");
 
         /* Load the wave file into memory */
         if (SDL_LoadWAV(file, &spec, &sound, &soundlen) == NULL) {
@@ -190,6 +192,8 @@ main(int argc, char **argv)
             test_multi_audio(devcount);
             SDL_FreeWAV(sound);
         }
+
+        SDL_free(file);
     }
 
     SDL_Quit();
diff --git a/Engine/lib/sdl/test/testnative.c b/Engine/lib/sdl/test/testnative.c
index 48f6f0ea5..34ee661f9 100644
--- a/Engine/lib/sdl/test/testnative.c
+++ b/Engine/lib/sdl/test/testnative.c
@@ -16,6 +16,7 @@
 #include <time.h> /* for time() */
 
 #include "testnative.h"
+#include "testutils.h"
 
 #define WINDOW_W    640
 #define WINDOW_H    480
@@ -52,37 +53,6 @@ quit(int rc)
     exit(rc);
 }
 
-SDL_Texture *
-LoadSprite(SDL_Renderer *renderer, const char *file)
-{
-    SDL_Surface *temp;
-    SDL_Texture *sprite;
-
-    /* Load the sprite image */
-    temp = SDL_LoadBMP(file);
-    if (temp == NULL) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't load %s: %s", file, SDL_GetError());
-        return 0;
-    }
-
-    /* Set transparent pixel as the pixel at (0,0) */
-    if (temp->format->palette) {
-        SDL_SetColorKey(temp, 1, *(Uint8 *) temp->pixels);
-    }
-
-    /* Create textures from the image */
-    sprite = SDL_CreateTextureFromSurface(renderer, temp);
-    if (!sprite) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create texture: %s\n", SDL_GetError());
-        SDL_FreeSurface(temp);
-        return 0;
-    }
-    SDL_FreeSurface(temp);
-
-    /* We're ready to roll. :) */
-    return sprite;
-}
-
 void
 MoveSprites(SDL_Renderer * renderer, SDL_Texture * sprite)
 {
@@ -180,7 +150,7 @@ main(int argc, char *argv[])
     SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);
     SDL_RenderClear(renderer);
 
-    sprite = LoadSprite(renderer, "icon.bmp");
+    sprite = LoadTexture(renderer, "icon.bmp", SDL_TRUE, NULL, NULL);
     if (!sprite) {
         quit(6);
     }
diff --git a/Engine/lib/sdl/test/testoverlay2.c b/Engine/lib/sdl/test/testoverlay2.c
index 8bb59a9fa..ab0fd82db 100644
--- a/Engine/lib/sdl/test/testoverlay2.c
+++ b/Engine/lib/sdl/test/testoverlay2.c
@@ -25,6 +25,7 @@
 #include "SDL.h"
 
 #include "testyuv_cvt.h"
+#include "testutils.h"
 
 #define MOOSEPIC_W 64
 #define MOOSEPIC_H 88
@@ -243,6 +244,7 @@ main(int argc, char **argv)
     int fps = 12;
     int nodelay = 0;
     int scale = 5;
+    char *filename = NULL;
 
     /* Enable standard application logging */
     SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
@@ -315,7 +317,13 @@ main(int argc, char **argv)
     }
 
     /* load the trojan moose images */
-    handle = SDL_RWFromFile("moose.dat", "rb");
+    filename = GetResourceFilename(NULL, "moose.dat");
+    if (filename == NULL) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Out of memory\n");
+        return -1;
+    }
+    handle = SDL_RWFromFile(filename, "rb");
+    SDL_free(filename);
     if (handle == NULL) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Can't find the file moose.dat !\n");
         SDL_free(RawMooseData);
diff --git a/Engine/lib/sdl/test/testplatform.c b/Engine/lib/sdl/test/testplatform.c
index 5aa649c12..f5b524d57 100644
--- a/Engine/lib/sdl/test/testplatform.c
+++ b/Engine/lib/sdl/test/testplatform.c
@@ -86,18 +86,25 @@ TestEndian(SDL_bool verbose)
     int error = 0;
     Uint16 value = 0x1234;
     int real_byteorder;
+    int real_floatwordorder = 0;
     Uint16 value16 = 0xCDAB;
     Uint16 swapped16 = 0xABCD;
     Uint32 value32 = 0xEFBEADDE;
     Uint32 swapped32 = 0xDEADBEEF;
     Uint64 value64, swapped64;
 
+    union {
+       double d;
+       Uint32 ui32[2];
+    } value_double;
+
     value64 = 0xEFBEADDE;
     value64 <<= 32;
     value64 |= 0xCDAB3412;
     swapped64 = 0x1234ABCD;
     swapped64 <<= 32;
     swapped64 |= 0xDEADBEEF;
+    value_double.d = 3.141593;
 
     if (verbose) {
         SDL_Log("Detected a %s endian machine.\n",
@@ -115,6 +122,22 @@ TestEndian(SDL_bool verbose)
         }
         ++error;
     }
+    if (verbose) {
+        SDL_Log("Detected a %s endian float word order machine.\n",
+               (SDL_FLOATWORDORDER == SDL_LIL_ENDIAN) ? "little" : "big");
+    }
+    if (value_double.ui32[0] == 0x82c2bd7f && value_double.ui32[1] == 0x400921fb) {
+        real_floatwordorder = SDL_LIL_ENDIAN;
+    } else if (value_double.ui32[0] == 0x400921fb && value_double.ui32[1] == 0x82c2bd7f) {
+        real_floatwordorder = SDL_BIG_ENDIAN;
+    }
+    if (real_floatwordorder != SDL_FLOATWORDORDER) {
+        if (verbose) {
+            SDL_Log("Actually a %s endian float word order machine!\n",
+                   (real_floatwordorder == SDL_LIL_ENDIAN) ? "little" : (real_floatwordorder == SDL_BIG_ENDIAN) ? "big" : "unknown" );
+        }
+        ++error;
+    }
     if (verbose) {
         SDL_Log("Value 16 = 0x%X, swapped = 0x%X\n", value16,
                SDL_Swap16(value16));
diff --git a/Engine/lib/sdl/test/testqsort.c b/Engine/lib/sdl/test/testqsort.c
index d28daebd4..29ea05627 100644
--- a/Engine/lib/sdl/test/testqsort.c
+++ b/Engine/lib/sdl/test/testqsort.c
@@ -12,7 +12,7 @@
 
 #include "SDL_test.h"
 
-static int
+static int SDLCALL
 num_compare(const void *_a, const void *_b)
 {
     const int a = *((const int *) _a);
diff --git a/Engine/lib/sdl/test/testrendercopyex.c b/Engine/lib/sdl/test/testrendercopyex.c
index 47d3ae96f..b954499e3 100644
--- a/Engine/lib/sdl/test/testrendercopyex.c
+++ b/Engine/lib/sdl/test/testrendercopyex.c
@@ -20,7 +20,7 @@
 #endif
 
 #include "SDL_test_common.h"
-
+#include "testutils.h"
 
 static SDLTest_CommonState *state;
 
@@ -44,56 +44,6 @@ quit(int rc)
     exit(rc);
 }
 
-SDL_Texture *
-LoadTexture(SDL_Renderer *renderer, const char *file, SDL_bool transparent)
-{
-    SDL_Surface *temp;
-    SDL_Texture *texture;
-
-    /* Load the sprite image */
-    temp = SDL_LoadBMP(file);
-    if (temp == NULL) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't load %s: %s", file, SDL_GetError());
-        return NULL;
-    }
-
-    /* Set transparent pixel as the pixel at (0,0) */
-    if (transparent) {
-        if (temp->format->palette) {
-            SDL_SetColorKey(temp, SDL_TRUE, *(Uint8 *) temp->pixels);
-        } else {
-            switch (temp->format->BitsPerPixel) {
-            case 15:
-                SDL_SetColorKey(temp, SDL_TRUE,
-                                (*(Uint16 *) temp->pixels) & 0x00007FFF);
-                break;
-            case 16:
-                SDL_SetColorKey(temp, SDL_TRUE, *(Uint16 *) temp->pixels);
-                break;
-            case 24:
-                SDL_SetColorKey(temp, SDL_TRUE,
-                                (*(Uint32 *) temp->pixels) & 0x00FFFFFF);
-                break;
-            case 32:
-                SDL_SetColorKey(temp, SDL_TRUE, *(Uint32 *) temp->pixels);
-                break;
-            }
-        }
-    }
-
-    /* Create textures from the image */
-    texture = SDL_CreateTextureFromSurface(renderer, temp);
-    if (!texture) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create texture: %s\n", SDL_GetError());
-        SDL_FreeSurface(temp);
-        return NULL;
-    }
-    SDL_FreeSurface(temp);
-
-    /* We're ready to roll. :) */
-    return texture;
-}
-
 void
 Draw(DrawState *s)
 {
@@ -186,8 +136,8 @@ main(int argc, char *argv[])
 
         drawstate->window = state->windows[i];
         drawstate->renderer = state->renderers[i];
-        drawstate->sprite = LoadTexture(drawstate->renderer, "icon.bmp", SDL_TRUE);
-        drawstate->background = LoadTexture(drawstate->renderer, "sample.bmp", SDL_FALSE);
+        drawstate->sprite = LoadTexture(drawstate->renderer, "icon.bmp", SDL_TRUE, NULL, NULL);
+        drawstate->background = LoadTexture(drawstate->renderer, "sample.bmp", SDL_FALSE, NULL, NULL);
         if (!drawstate->sprite || !drawstate->background) {
             quit(2);
         }
diff --git a/Engine/lib/sdl/test/testrendertarget.c b/Engine/lib/sdl/test/testrendertarget.c
index 3fb611270..98ceb1607 100644
--- a/Engine/lib/sdl/test/testrendertarget.c
+++ b/Engine/lib/sdl/test/testrendertarget.c
@@ -20,7 +20,7 @@
 #endif
 
 #include "SDL_test_common.h"
-
+#include "testutils.h"
 
 static SDLTest_CommonState *state;
 
@@ -45,56 +45,6 @@ quit(int rc)
     exit(rc);
 }
 
-SDL_Texture *
-LoadTexture(SDL_Renderer *renderer, const char *file, SDL_bool transparent)
-{
-    SDL_Surface *temp;
-    SDL_Texture *texture;
-
-    /* Load the sprite image */
-    temp = SDL_LoadBMP(file);
-    if (temp == NULL) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't load %s: %s", file, SDL_GetError());
-        return NULL;
-    }
-
-    /* Set transparent pixel as the pixel at (0,0) */
-    if (transparent) {
-        if (temp->format->palette) {
-            SDL_SetColorKey(temp, SDL_TRUE, *(Uint8 *) temp->pixels);
-        } else {
-            switch (temp->format->BitsPerPixel) {
-            case 15:
-                SDL_SetColorKey(temp, SDL_TRUE,
-                                (*(Uint16 *) temp->pixels) & 0x00007FFF);
-                break;
-            case 16:
-                SDL_SetColorKey(temp, SDL_TRUE, *(Uint16 *) temp->pixels);
-                break;
-            case 24:
-                SDL_SetColorKey(temp, SDL_TRUE,
-                                (*(Uint32 *) temp->pixels) & 0x00FFFFFF);
-                break;
-            case 32:
-                SDL_SetColorKey(temp, SDL_TRUE, *(Uint32 *) temp->pixels);
-                break;
-            }
-        }
-    }
-
-    /* Create textures from the image */
-    texture = SDL_CreateTextureFromSurface(renderer, temp);
-    if (!texture) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create texture: %s\n", SDL_GetError());
-        SDL_FreeSurface(temp);
-        return NULL;
-    }
-    SDL_FreeSurface(temp);
-
-    /* We're ready to roll. :) */
-    return texture;
-}
-
 SDL_bool
 DrawComposite(DrawState *s)
 {
@@ -292,11 +242,11 @@ main(int argc, char *argv[])
         drawstate->window = state->windows[i];
         drawstate->renderer = state->renderers[i];
         if (test_composite) {
-            drawstate->sprite = LoadTexture(drawstate->renderer, "icon-alpha.bmp", SDL_TRUE);
+            drawstate->sprite = LoadTexture(drawstate->renderer, "icon-alpha.bmp", SDL_TRUE, NULL, NULL);
         } else {
-            drawstate->sprite = LoadTexture(drawstate->renderer, "icon.bmp", SDL_TRUE);
+            drawstate->sprite = LoadTexture(drawstate->renderer, "icon.bmp", SDL_TRUE, NULL, NULL);
         }
-        drawstate->background = LoadTexture(drawstate->renderer, "sample.bmp", SDL_FALSE);
+        drawstate->background = LoadTexture(drawstate->renderer, "sample.bmp", SDL_FALSE, NULL, NULL);
         if (!drawstate->sprite || !drawstate->background) {
             quit(2);
         }
diff --git a/Engine/lib/sdl/test/testscale.c b/Engine/lib/sdl/test/testscale.c
index 1235c811d..0f1d21bfe 100644
--- a/Engine/lib/sdl/test/testscale.c
+++ b/Engine/lib/sdl/test/testscale.c
@@ -20,6 +20,7 @@
 #endif
 
 #include "SDL_test_common.h"
+#include "testutils.h"
 
 #define WINDOW_WIDTH    640
 #define WINDOW_HEIGHT   480
@@ -46,56 +47,6 @@ quit(int rc)
     exit(rc);
 }
 
-SDL_Texture *
-LoadTexture(SDL_Renderer *renderer, const char *file, SDL_bool transparent)
-{
-    SDL_Surface *temp;
-    SDL_Texture *texture;
-
-    /* Load the sprite image */
-    temp = SDL_LoadBMP(file);
-    if (temp == NULL) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't load %s: %s", file, SDL_GetError());
-        return NULL;
-    }
-
-    /* Set transparent pixel as the pixel at (0,0) */
-    if (transparent) {
-        if (temp->format->palette) {
-            SDL_SetColorKey(temp, SDL_TRUE, *(Uint8 *) temp->pixels);
-        } else {
-            switch (temp->format->BitsPerPixel) {
-            case 15:
-                SDL_SetColorKey(temp, SDL_TRUE,
-                                (*(Uint16 *) temp->pixels) & 0x00007FFF);
-                break;
-            case 16:
-                SDL_SetColorKey(temp, SDL_TRUE, *(Uint16 *) temp->pixels);
-                break;
-            case 24:
-                SDL_SetColorKey(temp, SDL_TRUE,
-                                (*(Uint32 *) temp->pixels) & 0x00FFFFFF);
-                break;
-            case 32:
-                SDL_SetColorKey(temp, SDL_TRUE, *(Uint32 *) temp->pixels);
-                break;
-            }
-        }
-    }
-
-    /* Create textures from the image */
-    texture = SDL_CreateTextureFromSurface(renderer, temp);
-    if (!texture) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create texture: %s\n", SDL_GetError());
-        SDL_FreeSurface(temp);
-        return NULL;
-    }
-    SDL_FreeSurface(temp);
-
-    /* We're ready to roll. :) */
-    return texture;
-}
-
 void
 Draw(DrawState *s)
 {
@@ -176,8 +127,8 @@ main(int argc, char *argv[])
 
         drawstate->window = state->windows[i];
         drawstate->renderer = state->renderers[i];
-        drawstate->sprite = LoadTexture(drawstate->renderer, "icon.bmp", SDL_TRUE);
-        drawstate->background = LoadTexture(drawstate->renderer, "sample.bmp", SDL_FALSE);
+        drawstate->sprite = LoadTexture(drawstate->renderer, "icon.bmp", SDL_TRUE, NULL, NULL);
+        drawstate->background = LoadTexture(drawstate->renderer, "sample.bmp", SDL_FALSE, NULL, NULL);
         if (!drawstate->sprite || !drawstate->background) {
             quit(2);
         }
diff --git a/Engine/lib/sdl/test/testsprite2.c b/Engine/lib/sdl/test/testsprite2.c
index 88419ffcf..fa709e349 100644
--- a/Engine/lib/sdl/test/testsprite2.c
+++ b/Engine/lib/sdl/test/testsprite2.c
@@ -21,6 +21,7 @@
 
 #include "SDL_test.h"
 #include "SDL_test_common.h"
+#include "testutils.h"
 
 #define NUM_SPRITES    100
 #define MAX_SPEED     1
@@ -62,54 +63,19 @@ int
 LoadSprite(const char *file)
 {
     int i;
-    SDL_Surface *temp;
 
-    /* Load the sprite image */
-    temp = SDL_LoadBMP(file);
-    if (temp == NULL) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't load %s: %s", file, SDL_GetError());
-        return (-1);
-    }
-    sprite_w = temp->w;
-    sprite_h = temp->h;
-
-    /* Set transparent pixel as the pixel at (0,0) */
-    if (temp->format->palette) {
-        SDL_SetColorKey(temp, 1, *(Uint8 *) temp->pixels);
-    } else {
-        switch (temp->format->BitsPerPixel) {
-        case 15:
-            SDL_SetColorKey(temp, 1, (*(Uint16 *) temp->pixels) & 0x00007FFF);
-            break;
-        case 16:
-            SDL_SetColorKey(temp, 1, *(Uint16 *) temp->pixels);
-            break;
-        case 24:
-            SDL_SetColorKey(temp, 1, (*(Uint32 *) temp->pixels) & 0x00FFFFFF);
-            break;
-        case 32:
-            SDL_SetColorKey(temp, 1, *(Uint32 *) temp->pixels);
-            break;
-        }
-    }
-
-    /* Create textures from the image */
     for (i = 0; i < state->num_windows; ++i) {
-        SDL_Renderer *renderer = state->renderers[i];
-        sprites[i] = SDL_CreateTextureFromSurface(renderer, temp);
+        /* This does the SDL_LoadBMP step repeatedly, but that's OK for test code. */
+        sprites[i] = LoadTexture(state->renderers[i], file, SDL_TRUE, &sprite_w, &sprite_h);
         if (!sprites[i]) {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create texture: %s\n", SDL_GetError());
-            SDL_FreeSurface(temp);
             return (-1);
         }
         if (SDL_SetTextureBlendMode(sprites[i], blendMode) < 0) {
             SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't set blend mode: %s\n", SDL_GetError());
-            SDL_FreeSurface(temp);
             SDL_DestroyTexture(sprites[i]);
             return (-1);
         }
     }
-    SDL_FreeSurface(temp);
 
     /* We're ready to roll. :) */
     return (0);
diff --git a/Engine/lib/sdl/test/testspriteminimal.c b/Engine/lib/sdl/test/testspriteminimal.c
index b9762cab3..36ea373b0 100644
--- a/Engine/lib/sdl/test/testspriteminimal.c
+++ b/Engine/lib/sdl/test/testspriteminimal.c
@@ -20,6 +20,7 @@
 #endif
 
 #include "SDL.h"
+#include "testutils.h"
 
 #define WINDOW_WIDTH    640
 #define WINDOW_HEIGHT   480
@@ -42,55 +43,6 @@ quit(int rc)
     exit(rc);
 }
 
-int
-LoadSprite(const char *file)
-{
-    SDL_Surface *temp;
-
-    /* Load the sprite image */
-    temp = SDL_LoadBMP(file);
-    if (temp == NULL) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't load %s: %s\n", file, SDL_GetError());
-        return (-1);
-    }
-    sprite_w = temp->w;
-    sprite_h = temp->h;
-
-    /* Set transparent pixel as the pixel at (0,0) */
-    if (temp->format->palette) {
-        SDL_SetColorKey(temp, SDL_TRUE, *(Uint8 *) temp->pixels);
-    } else {
-        switch (temp->format->BitsPerPixel) {
-        case 15:
-            SDL_SetColorKey(temp, SDL_TRUE,
-                            (*(Uint16 *) temp->pixels) & 0x00007FFF);
-            break;
-        case 16:
-            SDL_SetColorKey(temp, SDL_TRUE, *(Uint16 *) temp->pixels);
-            break;
-        case 24:
-            SDL_SetColorKey(temp, SDL_TRUE,
-                            (*(Uint32 *) temp->pixels) & 0x00FFFFFF);
-            break;
-        case 32:
-            SDL_SetColorKey(temp, SDL_TRUE, *(Uint32 *) temp->pixels);
-            break;
-        }
-    }
-
-    /* Create textures from the image */
-    sprite = SDL_CreateTextureFromSurface(renderer, temp);
-    if (!sprite) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create texture: %s\n", SDL_GetError());
-        SDL_FreeSurface(temp);
-        return (-1);
-    }
-    SDL_FreeSurface(temp);
-
-    /* We're ready to roll. :) */
-    return (0);
-}
-
 void
 MoveSprites()
 {
@@ -158,7 +110,9 @@ main(int argc, char *argv[])
         quit(2);
     }
 
-    if (LoadSprite("icon.bmp") < 0) {
+    sprite = LoadTexture(renderer, "icon.bmp", SDL_TRUE, &sprite_w, &sprite_h);
+
+    if (sprite == NULL) {
         quit(2);
     }
 
diff --git a/Engine/lib/sdl/test/teststreaming.c b/Engine/lib/sdl/test/teststreaming.c
index 72444f80e..dc3ae61d6 100644
--- a/Engine/lib/sdl/test/teststreaming.c
+++ b/Engine/lib/sdl/test/teststreaming.c
@@ -23,6 +23,7 @@
 #endif
 
 #include "SDL.h"
+#include "testutils.h"
 
 #define MOOSEPIC_W 64
 #define MOOSEPIC_H 88
@@ -128,6 +129,7 @@ main(int argc, char **argv)
 {
     SDL_Window *window;
     SDL_RWops *handle;
+    char *filename = NULL;
 
     /* Enable standard application logging */
     SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
@@ -138,7 +140,13 @@ main(int argc, char **argv)
     }
 
     /* load the moose images */
-    handle = SDL_RWFromFile("moose.dat", "rb");
+    filename = GetResourceFilename(NULL, "moose.dat");
+    if (filename == NULL) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Out of memory\n");
+        return -1;
+    }
+    handle = SDL_RWFromFile(filename, "rb");
+    SDL_free(filename);
     if (handle == NULL) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Can't find the file moose.dat !\n");
         quit(2);
diff --git a/Engine/lib/sdl/test/testsurround.c b/Engine/lib/sdl/test/testsurround.c
index 168415aca..1537b35fe 100644
--- a/Engine/lib/sdl/test/testsurround.c
+++ b/Engine/lib/sdl/test/testsurround.c
@@ -19,6 +19,7 @@ static int total_channels;
 static int active_channel;
 
 #define SAMPLE_RATE_HZ 48000
+#define QUICK_TEST_TIME_MSEC 100
 #define CHANNEL_TEST_TIME_SEC 5
 #define MAX_AMPLITUDE SDL_MAX_SINT16
 
@@ -188,7 +189,11 @@ main(int argc, char *argv[])
             SDL_Log("Playing %d Hz test tone on channel: %s\n", sine_freq, get_channel_name(j, total_channels));
 
             /* fill_buffer() will increment the active channel */
-            SDL_Delay(CHANNEL_TEST_TIME_SEC * 1000);
+            if (SDL_getenv("SDL_TESTS_QUICK") != NULL) {
+                SDL_Delay(QUICK_TEST_TIME_MSEC);
+            } else {
+                SDL_Delay(CHANNEL_TEST_TIME_SEC * 1000);
+            }
         }
 
         SDL_CloseAudioDevice(dev);
diff --git a/Engine/lib/sdl/test/testthread.c b/Engine/lib/sdl/test/testthread.c
index bf201e8e4..ea94dfb2e 100644
--- a/Engine/lib/sdl/test/testthread.c
+++ b/Engine/lib/sdl/test/testthread.c
@@ -91,6 +91,12 @@ main(int argc, char *argv[])
         return (1);
     }
 
+    if (SDL_getenv("SDL_TESTS_QUICK") != NULL) {
+        SDL_Log("Not running slower tests");
+        SDL_Quit();
+        return 0;
+    }
+
     while (argv[arg] && *argv[arg] == '-') {
         if (SDL_strcmp(argv[arg], "--prio") == 0) {
             testprio = 1;
diff --git a/Engine/lib/sdl/test/testtimer.c b/Engine/lib/sdl/test/testtimer.c
index d696097c8..62c5cd5f9 100644
--- a/Engine/lib/sdl/test/testtimer.c
+++ b/Engine/lib/sdl/test/testtimer.c
@@ -54,6 +54,12 @@ main(int argc, char *argv[])
         return (1);
     }
 
+    if (SDL_getenv("SDL_TESTS_QUICK") != NULL) {
+        SDL_Log("Not running slower tests");
+        SDL_Quit();
+        return 0;
+    }
+
     /* Verify SDL_GetTicks* acts monotonically increasing, and not erratic. */
     SDL_Log("Sanity-checking GetTicks\n");
     for (i = 0; i < 1000; ++i) {
diff --git a/Engine/lib/sdl/test/testutils.c b/Engine/lib/sdl/test/testutils.c
new file mode 100644
index 000000000..ab58824d0
--- /dev/null
+++ b/Engine/lib/sdl/test/testutils.c
@@ -0,0 +1,153 @@
+/*
+Copyright 1997-2022 Sam Lantinga
+Copyright 2022 Collabora Ltd.
+SPDX-License-Identifier: Zlib
+*/
+
+#include "testutils.h"
+
+/*
+ * Return the absolute path to def in the SDL_GetBasePath() if possible, or
+ * the relative path to def on platforms that don't have a working
+ * SDL_GetBasePath(). Free the result with SDL_free.
+ *
+ * Fails and returns NULL if out of memory.
+ */
+char *
+GetNearbyFilename(const char *file)
+{
+    char *base;
+    char *path;
+
+    base = SDL_GetBasePath();
+
+    if (base != NULL) {
+        SDL_RWops *rw;
+        size_t len = SDL_strlen(base) + SDL_strlen(file) + 1;
+
+        path = SDL_malloc(len);
+
+        if (path == NULL) {
+            SDL_free(base);
+            SDL_OutOfMemory();
+            return NULL;
+        }
+
+        SDL_snprintf(path, len, "%s%s", base, file);
+        SDL_free(base);
+
+        rw = SDL_RWFromFile(path, "rb");
+        if (rw) {
+            SDL_RWclose(rw);
+            return path;
+        }
+
+        /* Couldn't find the file in the base path */
+        SDL_free(path);
+    }
+
+    path = SDL_strdup(file);
+    if (path == NULL) {
+        SDL_OutOfMemory();
+    }
+    return path;
+}
+
+/*
+ * If user_specified is non-NULL, return a copy of it. Free with SDL_free.
+ *
+ * Otherwise, return the absolute path to def in the SDL_GetBasePath() if
+ * possible, or the relative path to def on platforms that don't have a
+ * working SDL_GetBasePath(). Free the result with SDL_free.
+ *
+ * Fails and returns NULL if out of memory.
+ */
+char *
+GetResourceFilename(const char *user_specified, const char *def)
+{
+    if (user_specified != NULL) {
+        char *ret = SDL_strdup(user_specified);
+
+        if (ret == NULL) {
+            SDL_OutOfMemory();
+        }
+
+        return ret;
+    } else {
+        return GetNearbyFilename(def);
+    }
+}
+
+/*
+ * Load the .bmp file whose name is file, from the SDL_GetBasePath() if
+ * possible or the current working directory if not.
+ *
+ * If transparent is true, set the transparent colour from the top left pixel.
+ *
+ * If width_out is non-NULL, set it to the texture width.
+ *
+ * If height_out is non-NULL, set it to the texture height.
+ */
+SDL_Texture *
+LoadTexture(SDL_Renderer *renderer, const char *file, SDL_bool transparent,
+            int *width_out, int *height_out)
+{
+    SDL_Surface *temp = NULL;
+    SDL_Texture *texture = NULL;
+    char *path;
+
+    path = GetNearbyFilename(file);
+
+    if (path != NULL) {
+        file = path;
+    }
+
+    temp = SDL_LoadBMP(file);
+    if (temp == NULL) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't load %s: %s", file, SDL_GetError());
+    } else {
+        /* Set transparent pixel as the pixel at (0,0) */
+        if (transparent) {
+            if (temp->format->palette) {
+                SDL_SetColorKey(temp, SDL_TRUE, *(Uint8 *)temp->pixels);
+            } else {
+                switch (temp->format->BitsPerPixel) {
+                case 15:
+                    SDL_SetColorKey(temp, SDL_TRUE,
+                                    (*(Uint16 *) temp->pixels) & 0x00007FFF);
+                    break;
+                case 16:
+                    SDL_SetColorKey(temp, SDL_TRUE, *(Uint16 *) temp->pixels);
+                    break;
+                case 24:
+                    SDL_SetColorKey(temp, SDL_TRUE,
+                                    (*(Uint32 *) temp->pixels) & 0x00FFFFFF);
+                    break;
+                case 32:
+                    SDL_SetColorKey(temp, SDL_TRUE, *(Uint32 *) temp->pixels);
+                    break;
+                }
+            }
+        }
+
+        if (width_out != NULL) {
+            *width_out = temp->w;
+        }
+
+        if (height_out != NULL) {
+            *height_out = temp->h;
+        }
+
+        texture = SDL_CreateTextureFromSurface(renderer, temp);
+        if (!texture) {
+            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create texture: %s\n", SDL_GetError());
+        }
+    }
+    if (temp) {
+        SDL_FreeSurface(temp);
+    }
+    if (path) {
+        SDL_free(path);
+    }
+    return texture;
+}
diff --git a/Engine/lib/sdl/test/testutils.h b/Engine/lib/sdl/test/testutils.h
new file mode 100644
index 000000000..cf24ca043
--- /dev/null
+++ b/Engine/lib/sdl/test/testutils.h
@@ -0,0 +1,17 @@
+/*
+Copyright 1997-2022 Sam Lantinga
+Copyright 2022 Collabora Ltd.
+SPDX-License-Identifier: Zlib
+*/
+
+#ifndef TESTUTILS_H
+#define TESTUTILS_H
+
+#include "SDL.h"
+
+SDL_Texture *LoadTexture(SDL_Renderer *renderer, const char *file, SDL_bool transparent,
+                         int *width_out, int *height_out);
+char *GetNearbyFilename(const char *file);
+char *GetResourceFilename(const char *user_specified, const char *def);
+
+#endif
diff --git a/Engine/lib/sdl/test/testviewport.c b/Engine/lib/sdl/test/testviewport.c
index 0e39d852d..162b31069 100644
--- a/Engine/lib/sdl/test/testviewport.c
+++ b/Engine/lib/sdl/test/testviewport.c
@@ -21,7 +21,7 @@
 
 #include "SDL_test.h"
 #include "SDL_test_common.h"
-
+#include "testutils.h"
 
 static SDLTest_CommonState *state;
 
@@ -42,55 +42,6 @@ quit(int rc)
     exit(rc);
 }
 
-int
-LoadSprite(const char *file, SDL_Renderer *renderer)
-{
-    SDL_Surface *temp;
-
-    /* Load the sprite image */
-    temp = SDL_LoadBMP(file);
-    if (temp == NULL) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't load %s: %s\n", file, SDL_GetError());
-        return (-1);
-    }
-    sprite_w = temp->w;
-    sprite_h = temp->h;
-
-    /* Set transparent pixel as the pixel at (0,0) */
-    if (temp->format->palette) {
-        SDL_SetColorKey(temp, SDL_TRUE, *(Uint8 *) temp->pixels);
-    } else {
-        switch (temp->format->BitsPerPixel) {
-        case 15:
-            SDL_SetColorKey(temp, SDL_TRUE,
-                            (*(Uint16 *) temp->pixels) & 0x00007FFF);
-            break;
-        case 16:
-            SDL_SetColorKey(temp, SDL_TRUE, *(Uint16 *) temp->pixels);
-            break;
-        case 24:
-            SDL_SetColorKey(temp, SDL_TRUE,
-                            (*(Uint32 *) temp->pixels) & 0x00FFFFFF);
-            break;
-        case 32:
-            SDL_SetColorKey(temp, SDL_TRUE, *(Uint32 *) temp->pixels);
-            break;
-        }
-    }
-
-    /* Create textures from the image */
-    sprite = SDL_CreateTextureFromSurface(renderer, temp);
-    if (!sprite) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create texture: %s\n", SDL_GetError());
-        SDL_FreeSurface(temp);
-        return (-1);
-    }
-    SDL_FreeSurface(temp);
-
-    /* We're ready to roll. :) */
-    return (0);
-}
-
 void
 DrawOnViewport(SDL_Renderer * renderer)
 {    
@@ -229,7 +180,9 @@ main(int argc, char *argv[])
         quit(2);
     }
 
-    if (LoadSprite("icon.bmp", state->renderers[0]) < 0) {
+    sprite = LoadTexture(state->renderers[0], "icon.bmp", SDL_TRUE, &sprite_w, &sprite_h);
+
+    if (sprite == NULL) {
         quit(2);
     }
 
diff --git a/Engine/lib/sdl/test/versioning.sh b/Engine/lib/sdl/test/versioning.sh
new file mode 100755
index 000000000..3a05c6243
--- /dev/null
+++ b/Engine/lib/sdl/test/versioning.sh
@@ -0,0 +1,162 @@
+#!/bin/sh
+# Copyright 2022 Collabora Ltd.
+# SPDX-License-Identifier: Zlib
+
+set -eu
+
+ref_major=$(sed -ne 's/^#define SDL_MAJOR_VERSION  *//p' include/SDL_version.h)
+ref_minor=$(sed -ne 's/^#define SDL_MINOR_VERSION  *//p' include/SDL_version.h)
+ref_micro=$(sed -ne 's/^#define SDL_PATCHLEVEL  *//p' include/SDL_version.h)
+ref_version="${ref_major}.${ref_minor}.${ref_micro}"
+
+tests=0
+failed=0
+
+ok () {
+    tests=$(( tests + 1 ))
+    echo "ok - $*"
+}
+
+not_ok () {
+    tests=$(( tests + 1 ))
+    echo "not ok - $*"
+    failed=1
+}
+
+major=$(sed -ne 's/^SDL_MAJOR_VERSION=//p' configure.ac)
+minor=$(sed -ne 's/^SDL_MINOR_VERSION=//p' configure.ac)
+micro=$(sed -ne 's/^SDL_MICRO_VERSION=//p' configure.ac)
+version="${major}.${minor}.${micro}"
+
+if [ "$ref_version" = "$version" ]; then
+    ok "configure.ac $version"
+else
+    not_ok "configure.ac $version disagrees with SDL_version.h $ref_version"
+fi
+
+major=$(sed -ne 's/^set(SDL_MAJOR_VERSION \([0-9]\+\))$/\1/p' CMakeLists.txt)
+minor=$(sed -ne 's/^set(SDL_MINOR_VERSION \([0-9]\+\))$/\1/p' CMakeLists.txt)
+micro=$(sed -ne 's/^set(SDL_MICRO_VERSION \([0-9]\+\))$/\1/p' CMakeLists.txt)
+version="${major}.${minor}.${micro}"
+
+if [ "$ref_version" = "$version" ]; then
+    ok "CMakeLists.txt $version"
+else
+    not_ok "CMakeLists.txt $version disagrees with SDL_version.h $ref_version"
+fi
+
+major=$(sed -ne 's/^MAJOR_VERSION *= *//p' Makefile.os2)
+minor=$(sed -ne 's/^MINOR_VERSION *= *//p' Makefile.os2)
+micro=$(sed -ne 's/^MICRO_VERSION *= *//p' Makefile.os2)
+version="${major}.${minor}.${micro}"
+
+if [ "$ref_version" = "$version" ]; then
+    ok "Makefile.os2 $version"
+else
+    not_ok "Makefile.os2 $version disagrees with SDL_version.h $ref_version"
+fi
+
+major=$(sed -ne 's/^MAJOR_VERSION *= *//p' Makefile.w32)
+minor=$(sed -ne 's/^MINOR_VERSION *= *//p' Makefile.w32)
+micro=$(sed -ne 's/^MICRO_VERSION *= *//p' Makefile.w32)
+version="${major}.${minor}.${micro}"
+
+if [ "$ref_version" = "$version" ]; then
+    ok "Makefile.w32 $version"
+else
+    not_ok "Makefile.w32 $version disagrees with SDL_version.h $ref_version"
+fi
+
+version=$(sed -Ene 's/^[$]SDLVersion = "([0-9.]+)"\r?$/\1/p' build-scripts/winrtbuild.ps1)
+
+if [ "$ref_version" = "$version" ]; then
+    ok "winrtbuild.ps1 $version"
+else
+    not_ok "winrtbuild.ps1 $version disagrees with SDL_version.h $ref_version"
+fi
+
+tuple=$(sed -ne 's/^ *FILEVERSION *//p' src/main/windows/version.rc | tr -d '\r')
+ref_tuple="${ref_major},${ref_minor},${ref_micro},0"
+
+if [ "$ref_tuple" = "$tuple" ]; then
+    ok "version.rc FILEVERSION $tuple"
+else
+    not_ok "version.rc FILEVERSION $tuple disagrees with SDL_version.h $ref_tuple"
+fi
+
+tuple=$(sed -ne 's/^ *PRODUCTVERSION *//p' src/main/windows/version.rc | tr -d '\r')
+
+if [ "$ref_tuple" = "$tuple" ]; then
+    ok "version.rc PRODUCTVERSION $tuple"
+else
+    not_ok "version.rc PRODUCTVERSION $tuple disagrees with SDL_version.h $ref_tuple"
+fi
+
+tuple=$(sed -Ene 's/^ *VALUE "FileVersion", "([0-9, ]+)\\0"\r?$/\1/p' src/main/windows/version.rc | tr -d '\r')
+ref_tuple="${ref_major}, ${ref_minor}, ${ref_micro}, 0"
+
+if [ "$ref_tuple" = "$tuple" ]; then
+    ok "version.rc FileVersion $tuple"
+else
+    not_ok "version.rc FileVersion $tuple disagrees with SDL_version.h $ref_tuple"
+fi
+
+tuple=$(sed -Ene 's/^ *VALUE "ProductVersion", "([0-9, ]+)\\0"\r?$/\1/p' src/main/windows/version.rc | tr -d '\r')
+
+if [ "$ref_tuple" = "$tuple" ]; then
+    ok "version.rc ProductVersion $tuple"
+else
+    not_ok "version.rc ProductVersion $tuple disagrees with SDL_version.h $ref_tuple"
+fi
+
+version=$(sed -Ene '/CFBundleShortVersionString/,+1 s/.*<string>(.*)<\/string>.*/\1/p' Xcode/SDL/Info-Framework.plist)
+
+if [ "$ref_version" = "$version" ]; then
+    ok "Info-Framework.plist CFBundleShortVersionString $version"
+else
+    not_ok "Info-Framework.plist CFBundleShortVersionString $version disagrees with SDL_version.h $ref_version"
+fi
+
+version=$(sed -Ene '/CFBundleVersion/,+1 s/.*<string>(.*)<\/string>.*/\1/p' Xcode/SDL/Info-Framework.plist)
+
+if [ "$ref_version" = "$version" ]; then
+    ok "Info-Framework.plist CFBundleVersion $version"
+else
+    not_ok "Info-Framework.plist CFBundleVersion $version disagrees with SDL_version.h $ref_version"
+fi
+
+# For simplicity this assumes we'll never break ABI before SDL 3.
+dylib_compat=$(sed -Ene 's/.*DYLIB_COMPATIBILITY_VERSION = (.*);$/\1/p' Xcode/SDL/SDL.xcodeproj/project.pbxproj)
+ref='1.0.0
+1.0.0'
+
+if [ "$ref" = "$dylib_compat" ]; then
+    ok "project.pbxproj DYLIB_COMPATIBILITY_VERSION is consistent"
+else
+    not_ok "project.pbxproj DYLIB_COMPATIBILITY_VERSION is inconsistent"
+fi
+
+dylib_cur=$(sed -Ene 's/.*DYLIB_CURRENT_VERSION = (.*);$/\1/p' Xcode/SDL/SDL.xcodeproj/project.pbxproj)
+
+case "$ref_minor" in
+    (*[02468])
+        major="$(( ref_minor * 100 + 1 ))"
+        minor="$ref_micro"
+        ;;
+    (*)
+        major="$(( ref_minor * 100 + ref_micro + 1 ))"
+        minor="0"
+        ;;
+esac
+
+ref="${major}.${minor}.0
+${major}.${minor}.0"
+
+if [ "$ref" = "$dylib_cur" ]; then
+    ok "project.pbxproj DYLIB_CURRENT_VERSION is consistent"
+else
+    not_ok "project.pbxproj DYLIB_CURRENT_VERSION is inconsistent"
+fi
+
+echo "1..$tests"
+exit "$failed"
diff --git a/Engine/lib/sdl/test/watcom.mif b/Engine/lib/sdl/test/watcom.mif
new file mode 100644
index 000000000..dbeec5ddd
--- /dev/null
+++ b/Engine/lib/sdl/test/watcom.mif
@@ -0,0 +1,115 @@
+INCPATH+= -I"../include"
+LIBPATH = ..
+LIBS    = SDL2.lib SDL2test.lib testutils.lib
+
+#CFLAGS+= -DHAVE_SDL_TTF
+#TTFLIBS = SDL2ttf.lib
+
+CFLAGS+= $(INCPATH)
+
+TARGETS = testatomic.exe testdisplayinfo.exe testbounds.exe testdraw2.exe &
+          testdrawchessboard.exe testdropfile.exe testerror.exe testfile.exe &
+          testfilesystem.exe testgamecontroller.exe testgeometry.exe testgesture.exe &
+          testhittesting.exe testhotplug.exe testiconv.exe testime.exe testlocale.exe &
+          testintersections.exe testjoystick.exe testkeys.exe testloadso.exe &
+          testlock.exe testmessage.exe testoverlay2.exe testplatform.exe &
+          testpower.exe testsensor.exe testrelative.exe testrendercopyex.exe &
+          testrendertarget.exe testrumble.exe testscale.exe testsem.exe &
+          testshader.exe testshape.exe testsprite2.exe testspriteminimal.exe &
+          teststreaming.exe testthread.exe testtimer.exe testver.exe &
+          testviewport.exe testwm2.exe torturethread.exe checkkeys.exe &
+          checkkeysthreads.exe testmouse.exe testgles.exe testgles2.exe &
+          controllermap.exe testhaptic.exe testqsort.exe testresample.exe &
+          testaudioinfo.exe testaudiocapture.exe loopwave.exe loopwavequeue.exe &
+          testsurround.exe testyuv.exe testgl2.exe testvulkan.exe testnative.exe &
+          testautomation.exe testaudiohotplug.exe testcustomcursor.exe testmultiaudio.exe &
+          testoffscreen.exe testurl.exe
+
+noninteractive = &
+	testatomic.exe &
+	testerror.exe &
+	testfilesystem.exe &
+	testkeys.exe &
+	testlocale.exe &
+	testplatform.exe &
+	testpower.exe &
+	testqsort.exe &
+	testthread.exe &
+	testtimer.exe &
+	testver.exe
+
+needs_audio = &
+	testaudioinfo.exe &
+	testsurround.exe
+
+needs_display = &
+	testbounds.exe &
+	testdisplayinfo.exe
+
+TESTS = $(noninteractive) $(needs_audio) $(needs_display)
+
+# testautomation sources
+TASRCS = testautomation.c testautomation_audio.c testautomation_clipboard.c &
+         testautomation_events.c testautomation_hints.c &
+         testautomation_keyboard.c testautomation_main.c &
+         testautomation_mouse.c testautomation_pixels.c &
+         testautomation_platform.c testautomation_rect.c &
+         testautomation_render.c testautomation_rwops.c &
+         testautomation_sdltest.c testautomation_stdlib.c &
+         testautomation_surface.c testautomation_syswm.c &
+         testautomation_timer.c testautomation_video.c
+
+OBJS = $(TARGETS:.exe=.obj)
+COBJS = $(CSRCS:.c=.obj)
+TAOBJS = $(TASRCS:.c=.obj)
+TNOBJS = $(TNSRCS:.c=.obj)
+
+all: testutils.lib $(TARGETS)
+
+.c: ../src/test
+
+.obj.exe:
+  wlink SYS $(SYSTEM) libpath $(LIBPATH) lib {$(LIBS)} op q op el file {$<} name $@
+
+.c.obj:
+  wcc386 $(CFLAGS) -fo=$^@ $<
+
+# specials
+testautomation.exe: $(TAOBJS)
+  wlink SYS $(SYSTEM) libpath $(LIBPATH) lib {$(LIBS)} op q op el file {$<} name $@
+
+testnative.exe: $(TNOBJS)
+  wlink SYS $(SYSTEM) libpath $(LIBPATH) lib {$(LIBS)} op q op el file {$<} name $@
+
+testoverlay2.exe: testoverlay2.obj testyuv_cvt.obj
+  wlink SYS $(SYSTEM) libpath $(LIBPATH) lib {$(LIBS)} op q op el file {$<} name $@
+
+testyuv.exe: testyuv.obj testyuv_cvt.obj
+  wlink SYS $(SYSTEM) libpath $(LIBPATH) lib {$(LIBS)} op q op el file {$<} name $@
+
+testshader.exe: testshader.obj
+  wlink SYS $(SYSTEM) libpath $(LIBPATH) lib {$(LIBS) $(GLLIBS)} op q op el file {$<} name $@
+
+testime.exe: testime.obj
+  wlink SYS $(SYSTEM) libpath $(LIBPATH) lib {$(LIBS) $(TTFLIBS)} op q op el file {$<} name $@
+
+testutils.lib: testutils.obj
+  wlib -q -b -n -c -pa -s -t -zld -ii -io $@ $<
+
+check: .SYMBOLIC $(TESTS)
+  @set SDL_AUDIODRIVER=dummy
+  @set SDL_VIDEODRIVER=dummy
+  @copy "../SDL2.dll" .
+  @for %exe in ($(TESTS)) do %exe
+
+check-quick: .SYMBOLIC $(TESTS)
+  @set SDL_TESTS_QUICK=1
+  @set SDL_AUDIODRIVER=dummy
+  @set SDL_VIDEODRIVER=dummy
+  @copy "../SDL2.dll" .
+  @for %exe in ($(TESTS)) do %exe
+
+clean: .SYMBOLIC
+  rm -f *.obj *.err
+distclean: .SYMBOLIC clean
+  rm -f *.exe *.lib
diff --git a/Engine/lib/sdl/visualtest/autogen.sh b/Engine/lib/sdl/visualtest/autogen.sh
old mode 100644
new mode 100755
diff --git a/Engine/lib/sdl/visualtest/configure b/Engine/lib/sdl/visualtest/configure
old mode 100644
new mode 100755
diff --git a/Engine/lib/sdl/visualtest/launch_harness.sh b/Engine/lib/sdl/visualtest/launch_harness.sh
old mode 100644
new mode 100755

From 3988e7baee36e5811c3c6cdee0bdc48a02106e97 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Sat, 21 May 2022 21:55:44 -0400
Subject: [PATCH 390/399] Better allocator for TorqueScript temp conversions
 used during interpretation

instead of using a Vector<> that never frees and grows for torquescript temporaries created when doing type conversions)
---
 Engine/source/console/console.cpp | 15 +++++++--------
 Engine/source/console/console.h   | 12 +-----------
 Engine/source/core/util/tVector.h | 10 ----------
 3 files changed, 8 insertions(+), 29 deletions(-)

diff --git a/Engine/source/console/console.cpp b/Engine/source/console/console.cpp
index d9ba1dcff..1c96a15fb 100644
--- a/Engine/source/console/console.cpp
+++ b/Engine/source/console/console.cpp
@@ -46,29 +46,28 @@
 extern StringStack STR;
 extern ConsoleValueStack<4096> gCallStack;
 
-Vector<ConsoleValue::ConversionBuffer> ConsoleValue::sConversionBuffer;
+DataChunker ConsoleValue::sConversionAllocator;
 
 void ConsoleValue::init()
 {
-   sConversionBuffer.reserve(8192);
+   sConversionAllocator.setChunkSize(8092);
 }
 
 void ConsoleValue::resetConversionBuffer()
 {
-   sConversionBuffer.resetAndTreatAsScratchBuffer();
+   sConversionAllocator.freeBlocks();
 }
 
 char* ConsoleValue::convertToBuffer() const
 {
-   ConversionBuffer conversion;
+   char* buffer = static_cast<char*>(sConversionAllocator.alloc(32));
    
    if (type == ConsoleValueType::cvFloat)
-      dSprintf(conversion.buffer, ConversionBufferStride, "%.9g", f);
+      dSprintf(buffer, 32, "%.9g", f);
    else
-      dSprintf(conversion.buffer, ConversionBufferStride, "%lld", i);
+      dSprintf(buffer, 32, "%lld", i);
 
-   sConversionBuffer.push_back(std::move(conversion));
-   return sConversionBuffer.last().buffer;
+   return buffer;
 }
 
 const char* ConsoleValue::getConsoleData() const
diff --git a/Engine/source/console/console.h b/Engine/source/console/console.h
index 8816e4e99..26a3ec175 100644
--- a/Engine/source/console/console.h
+++ b/Engine/source/console/console.h
@@ -146,17 +146,7 @@ class ConsoleValue
 
    S32 type;
 
-   enum Constants
-   {
-      ConversionBufferStride = 32
-   };
-
-   struct ConversionBuffer
-   {
-      char buffer[ConversionBufferStride];
-   };
-   
-   static Vector<ConversionBuffer> sConversionBuffer;
+   static DataChunker sConversionAllocator;
 
    char* convertToBuffer() const;
 
diff --git a/Engine/source/core/util/tVector.h b/Engine/source/core/util/tVector.h
index 57cb84e24..0700a5554 100644
--- a/Engine/source/core/util/tVector.h
+++ b/Engine/source/core/util/tVector.h
@@ -160,7 +160,6 @@ class Vector
    void erase(U32 index, U32 count);
    void erase_fast(iterator);
    void clear();
-   void resetAndTreatAsScratchBuffer();
    void compact();
    void sort(compare_func f);
    void fill( const T& value );
@@ -530,15 +529,6 @@ template<class T> inline void Vector<T>::clear()
    mElementCount = 0;
 }
 
-/// This method sets the vector as its 0 and will overwrite memory on subsequent usage.
-/// Note that the current memory in use is never freed or deallocated, so only use this if the vector
-/// is being used as a scratch buffer only.
-template<class T> inline
-void Vector<T>::resetAndTreatAsScratchBuffer()
-{
-   mElementCount = 0;
-}
-
 template<class T> inline void Vector<T>::compact()
 {
    resize(mElementCount);

From 8f2beb32197a24f0d8c7fe1354fe4630901bc609 Mon Sep 17 00:00:00 2001
From: Jeff Hutchinson <programmerjeff95@gmail.com>
Date: Mon, 23 May 2022 20:25:32 -0400
Subject: [PATCH 391/399] Fix edgecase where empty string was not being
 explicitly set to 0 in torquescript when used as integers/floats/bools.

We found this in the setInventory standard module. in setInventory, %max was being set to empty string, but being compared to 0 during TorqueScript comparison ops. I knew to look in ConsoleValue's type conversion functions, as the interpreter internally uses ConsoleValues when working with torquescript variables under the hood. ConsoleValue is responsible for handling all type conversions on the fly as needed inside of the core interpreter logic.
---
 Engine/source/console/console.h | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/Engine/source/console/console.h b/Engine/source/console/console.h
index 26a3ec175..d381fdc1c 100644
--- a/Engine/source/console/console.h
+++ b/Engine/source/console/console.h
@@ -229,8 +229,10 @@ public:
          return f;
       if (type == ConsoleValueType::cvInteger)
          return i;
-      if (isStringType())
-         return dAtof(s);
+      if (type == ConsoleValueType::cvSTEntry)
+         return s == StringTable->EmptyString() ? 0.0f : dAtof(s);
+      if (type == ConsoleValueType::cvString)
+         return dStrcmp(s, "") == 0 ? 0.0f : dAtof(s);
       return dAtof(getConsoleData());
    }
 
@@ -240,8 +242,10 @@ public:
          return i;
       if (type == ConsoleValueType::cvFloat)
          return f;
-      if (isStringType())
-         return dAtoi(s);
+      if (type == ConsoleValueType::cvSTEntry)
+         return s == StringTable->EmptyString() ? 0 : dAtoi(s);
+      if (type == ConsoleValueType::cvString)
+         return dStrcmp(s, "") == 0 ? 0 : dAtoi(s);
       return dAtoi(getConsoleData());
    }
 
@@ -265,8 +269,10 @@ public:
          return (bool)i;
       if (type == ConsoleValueType::cvFloat)
          return (bool)f;
-      if (isStringType())
-         return dAtob(s);
+      if (type == ConsoleValueType::cvSTEntry)
+         return s == StringTable->EmptyString() ? false : dAtob(s);
+      if (type == ConsoleValueType::cvString)
+         return dStrcmp(s, "") == 0 ? false : dAtob(s);
       return dAtob(getConsoleData());
    }
 

From 52368a0428e4e64bc7db1b5aa8bafc6ebc4eb451 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Tue, 24 May 2022 02:10:06 -0500
Subject: [PATCH 392/399] Fixes issue where creating a new ForestItem wouldn't
 have it show in the ForestItemData dropdown on brushes until you restart.

---
 Engine/source/gui/editor/inspector/datablockField.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Engine/source/gui/editor/inspector/datablockField.h b/Engine/source/gui/editor/inspector/datablockField.h
index eea65a1a5..f08a51072 100644
--- a/Engine/source/gui/editor/inspector/datablockField.h
+++ b/Engine/source/gui/editor/inspector/datablockField.h
@@ -39,7 +39,7 @@ class GuiInspectorDatablockField : public GuiInspectorTypeMenuBase
 
       AbstractClassRep *mDesiredClass;
 
-      virtual SimSet* _getDatablockSet() const { return Sim::getDataBlockGroup(); }
+      virtual SimSet* _getDatablockSet() const { return Sim::getDataBlockSet(); }
       virtual void _populateMenu( GuiPopUpMenuCtrl* menu );
       
    public:
@@ -131,4 +131,4 @@ class GuiInspectorTypeSFXAmbienceName : public GuiInspectorDatablockField
 };
 
 
-#endif
\ No newline at end of file
+#endif

From c687c0d23ab5cfab86d3067c13a7ff1923abd1ee Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Tue, 24 May 2022 20:39:34 -0400
Subject: [PATCH 393/399] * BugFix: Remove unused 3DNow! extensions and broken
 SSE extensions.

---
 Engine/source/math/mMathAMD.cpp           | 216 ----------------------
 Engine/source/math/mMathAMD_ASM.asm       | 177 ------------------
 Engine/source/math/test/mMatrixTest.cpp   |  13 --
 Engine/source/platform/platform.h         |  23 ++-
 Engine/source/platformMac/macMath.mm      |   2 -
 Engine/source/platformPOSIX/POSIXMath.cpp |  15 --
 Engine/source/platformWin32/winMath.cpp   |  13 --
 7 files changed, 11 insertions(+), 448 deletions(-)
 delete mode 100644 Engine/source/math/mMathAMD.cpp
 delete mode 100644 Engine/source/math/mMathAMD_ASM.asm

diff --git a/Engine/source/math/mMathAMD.cpp b/Engine/source/math/mMathAMD.cpp
deleted file mode 100644
index 2df3729ef..000000000
--- a/Engine/source/math/mMathAMD.cpp
+++ /dev/null
@@ -1,216 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#include "math/mMathFn.h"
-#include "math/mPlane.h"
-#include "math/mMatrix.h"
-
-
-// extern void (*m_matF_x_point3F)(const F32 *m, const F32 *p, F32 *presult);
-// extern void (*m_matF_x_vectorF)(const F32 *m, const F32 *v, F32 *vresult);
-
-/* not currently implemented.
-void Athlon_MatrixF_x_Point3F(const F32 *m, const F32 *p, F32 *presult)
-{
-   m;
-   p;
-   presult;
-}
-*/
-
-//============================================================
-//  Here's the C code for MatF_x_MatF:
-//  note that the code below does it in a different order (optimal asm, after all!)
-//
-// r[0] = a[0]*b[0] + a[1]*b[4] + a[2]*b[8]  + a[3]*b[12];
-// r[1] = a[0]*b[1] + a[1]*b[5] + a[2]*b[9]  + a[3]*b[13];
-// r[2] = a[0]*b[2] + a[1]*b[6] + a[2]*b[10] + a[3]*b[14];
-// r[3] = a[0]*b[3] + a[1]*b[7] + a[2]*b[11] + a[3]*b[15];
-//
-// r[4] = a[4]*b[0] + a[5]*b[4] + a[6]*b[8]  + a[7]*b[12];
-// r[5] = a[4]*b[1] + a[5]*b[5] + a[6]*b[9]  + a[7]*b[13];
-// r[6] = a[4]*b[2] + a[5]*b[6] + a[6]*b[10] + a[7]*b[14];
-// r[7] = a[4]*b[3] + a[5]*b[7] + a[6]*b[11] + a[7]*b[15];
-//
-// r[8] = a[8]*b[0] + a[9]*b[4] + a[10]*b[8] + a[11]*b[12];
-// r[9] = a[8]*b[1] + a[9]*b[5] + a[10]*b[9] + a[11]*b[13];
-// r[10]= a[8]*b[2] + a[9]*b[6] + a[10]*b[10]+ a[11]*b[14];
-// r[11]= a[8]*b[3] + a[9]*b[7] + a[10]*b[11]+ a[11]*b[15];
-//
-// r[12]= a[12]*b[0]+ a[13]*b[4]+ a[14]*b[8] + a[15]*b[12];
-// r[13]= a[12]*b[1]+ a[13]*b[5]+ a[14]*b[9] + a[15]*b[13];
-// r[14]= a[12]*b[2]+ a[13]*b[6]+ a[14]*b[10]+ a[15]*b[14];
-// r[15]= a[12]*b[3]+ a[13]*b[7]+ a[14]*b[11]+ a[15]*b[15];
-//============================================================
-
-#if defined(TORQUE_SUPPORTS_VC_INLINE_X86_ASM)
-#define ADD_3DNOW_FUNCS
-// inlined version here.
-void Athlon_MatrixF_x_MatrixF(const F32 *matA, const F32 *matB, F32 *result)
-{
-   __asm
-   {
-      femms
-
-      mov         ecx, matA
-      mov         edx, matB
-      mov         eax, result
-
-      prefetch    [ecx+32]       ;// These may help -
-      prefetch    [edx+32]       ;//    and probably don't hurt
-
-      movq        mm0,[ecx]      ;// a21   | a11
-      movq        mm1,[ecx+8]      ;// a41   | a31
-      movq        mm4,[edx]      ;// b21   | b11
-      punpckhdq   mm2,mm0         ;// a21   |
-      movq        mm5,[edx+16]   ;// b22   | b12
-      punpckhdq   mm3,mm1         ;// a41   |
-      movq        mm6,[edx+32]   ;// b23   | b13
-      punpckldq   mm0,mm0         ;// a11   | a11
-      punpckldq   mm1,mm1         ;// a31   | a31
-      pfmul       mm4,mm0         ;// a11*b21 | a11*b11
-      punpckhdq   mm2,mm2         ;// a21   | a21
-      pfmul       mm0,[edx+8]      ;// a11*b41 | a11*b31
-      movq        mm7,[edx+48]   ;// b24   | b14
-      pfmul       mm5,mm2         ;// a21*b22 | a21*b12
-      punpckhdq   mm3,mm3         ;// a41   | a41
-      pfmul       mm2,[edx+24]   ;// a21*b42 | a21*b32
-      pfmul       mm6,mm1         ;// a31*b23 | a31*b13
-      pfadd       mm5,mm4         ;// a21*b22 + a11*b21 | a21*b12 + a11*b11
-      pfmul       mm1,[edx+40]   ;// a31*b43 | a31*b33
-      pfadd       mm2,mm0         ;// a21*b42 + a11*b41 | a21*b32 + a11*b31
-      pfmul       mm7,mm3         ;// a41*b24 | a41*b14
-      pfadd       mm6,mm5         ;// a21*b22 + a11*b21 + a31*b23 | a21*b12 + a11*b11 + a31*b13
-      pfmul       mm3,[edx+56]   ;// a41*b44 | a41*b34
-      pfadd       mm2,mm1         ;// a21*b42 + a11*b41 + a31*b43 | a21*b32 + a11*b31 + a31*b33
-      pfadd       mm7,mm6         ;// a41*b24 + a21*b22 + a11*b21 + a31*b23 |  a41*b14 + a21*b12 + a11*b11 + a31*b13
-      movq        mm0,[ecx+16]   ;// a22   | a12
-      pfadd       mm3,mm2         ;// a41*b44 + a21*b42 + a11*b41 + a31*b43 | a41*b34 + a21*b32 + a11*b31 + a31*b33
-      movq        mm1,[ecx+24]   ;// a42   | a32
-      movq        [eax],mm7      ;// r21   | r11
-      movq        mm4,[edx]      ;// b21   | b11
-      movq        [eax+8],mm3      ;// r41   | r31
-
-      punpckhdq   mm2,mm0         ;// a22   | XXX
-      movq        mm5,[edx+16]   ;// b22   | b12
-      punpckhdq   mm3,mm1         ;// a42   | XXX
-      movq        mm6,[edx+32]   ;// b23   | b13
-      punpckldq   mm0,mm0         ;// a12   | a12
-      punpckldq   mm1,mm1         ;// a32   | a32
-      pfmul       mm4,mm0         ;// a12*b21 | a12*b11
-      punpckhdq   mm2,mm2         ;// a22   | a22
-      pfmul       mm0,[edx+8]      ;// a12*b41 | a12*b31
-      movq        mm7,[edx+48]   ;// b24   | b14
-      pfmul       mm5,mm2         ;// a22*b22 | a22*b12
-      punpckhdq   mm3,mm3         ;// a42   | a42
-      pfmul       mm2,[edx+24]   ;// a22*b42 | a22*b32
-      pfmul       mm6,mm1         ;// a32*b23 | a32*b13
-      pfadd       mm5,mm4         ;// a12*b21 + a22*b22 | a12*b11 + a22*b12
-      pfmul       mm1,[edx+40]   ;// a32*b43 | a32*b33
-      pfadd       mm2,mm0         ;// a12*b41 + a22*b42 | a12*b11 + a22*b32
-      pfmul       mm7,mm3         ;// a42*b24 | a42*b14
-      pfadd       mm6,mm5         ;// a32*b23 + a12*b21 + a22*b22 | a32*b13 + a12*b11 + a22*b12
-      pfmul       mm3,[edx+56]   ;// a42*b44 | a42*b34
-      pfadd       mm2,mm1         ;// a32*b43 + a12*b41 + a22*b42 | a32*b33 + a12*b11 + a22*b32
-      pfadd       mm7,mm6         ;// a42*b24 + a32*b23 + a12*b21 + a22*b22 | a42*b14 + a32*b13 + a12*b11 + a22*b12
-      movq        mm0,[ecx+32]   ;// a23 | a13
-      pfadd       mm3,mm2         ;// a42*b44 + a32*b43 + a12*b41 + a22*b42 | a42*b34 + a32*b33 + a12*b11 + a22*b32
-      movq        mm1,[ecx+40]   ;// a43 | a33
-      movq        [eax+16],mm7   ;// r22 | r12
-      movq        mm4,[edx]      ;// b21   | b11
-      movq        [eax+24],mm3   ;// r42 | r32
-
-      punpckhdq   mm2,mm0         ;// a23 | XXX
-      movq        mm5,[edx+16]   ;// b22 | b12
-      punpckhdq   mm3,mm1         ;// a43 | XXX
-      movq        mm6,[edx+32]   ;// b23 | b13
-      punpckldq   mm0,mm0         ;// a13 | a13
-      punpckldq   mm1,mm1         ;// a33 | a33
-      pfmul       mm4,mm0         ;// a13*b21 | a13*b11
-      punpckhdq   mm2,mm2         ;// a23 | a23
-      pfmul       mm0,[edx+8]      ;// a13*b41 | a13*b31
-      movq        mm7,[edx+48]   ;// b24 | b14
-      pfmul       mm5,mm2         ;// a23*b22 | a23*b12
-      punpckhdq   mm3,mm3         ;// a43 | a43
-      pfmul       mm2,[edx+24]   ;// a23*b42 | a23*b32
-      pfmul       mm6,mm1         ;// a33*b23 | a33*b13
-      pfadd       mm5,mm4         ;// a23*b22 + a13*b21 | a23*b12 + a13*b11
-      pfmul       mm1,[edx+40]   ;// a33*b43 | a33*b33
-      pfadd       mm2,mm0         ;// a13*b41 + a23*b42 | a13*b31 + a23*b32
-      pfmul       mm7,mm3         ;// a43*b24 | a43*b14
-      pfadd       mm6,mm5         ;// a33*b23 + a23*b22 + a13*b21 | a33*b13 + a23*b12 + a13*b11
-      pfmul       mm3,[edx+56]   ;// a43*b44 | a43*b34
-      pfadd       mm2,mm1         ;// a33*b43*a13*b41 + a23*b42 | a33*b33 + a13*b31 + a23*b32
-      pfadd       mm7,mm6         ;// a43*b24 + a33*b23 + a23*b22 + a13*b21 | a43*b14 + a33*b13 + a23*b12 + a13*b11
-      movq        mm0,[ecx+48]   ;// a24 | a14
-      pfadd       mm3,mm2         ;// a43*b44 + a33*b43*a13*b41 + a23*b42 | a43*b34 + a33*b33 + a13*b31 + a23*b32
-      movq        mm1,[ecx+56]   ;// a44 | a34
-      movq        [eax+32],mm7   ;// r23 | r13
-      movq        mm4,[edx]      ;// b21 | b11
-      movq        [eax+40],mm3   ;// r43 | r33
-
-      punpckhdq   mm2,mm0         ;// a24 | XXX
-      movq        mm5,[edx+16]   ;// b22 | b12
-      punpckhdq   mm3,mm1         ;// a44 | XXX
-      movq        mm6,[edx+32]   ;// b23 | b13
-      punpckldq   mm0,mm0         ;// a14 | a14
-      punpckldq   mm1,mm1         ;// a34 | a34
-      pfmul       mm4,mm0         ;// a14*b21 | a14*b11
-      punpckhdq   mm2,mm2         ;// a24 | a24
-      pfmul       mm0,[edx+8]      ;// a14*b41 | a14*b31
-      movq        mm7,[edx+48]   ;// b24 | b14
-      pfmul       mm5,mm2         ;// a24*b22 | a24*b12
-      punpckhdq   mm3,mm3         ;// a44 | a44
-      pfmul       mm2,[edx+24]   ;// a24*b 42 | a24*b32
-      pfmul       mm6,mm1         ;// a34*b23 | a34*b13
-      pfadd       mm5,mm4         ;// a14*b21 + a24*b22 | a14*b11 + a24*b12
-      pfmul       mm1,[edx+40]   ;// a34*b43 | a34*b33
-      pfadd       mm2,mm0         ;// a14*b41 + a24*b 42 | a14*b31 + a24*b32
-      pfmul       mm7,mm3         ;// a44*b24 | a44*b14
-      pfadd       mm6,mm5         ;// a34*b23 + a14*b21 + a24*b22 | a34*b13 + a14*b11 + a24*b12
-      pfmul       mm3,[edx+56]   ;// a44*b44 | a44*b34
-      pfadd       mm2,mm1         ;// a34*b43 + a14*b41 + a24*b 42 | a34*b33 + a14*b31 + a24*b32
-      pfadd       mm7,mm6         ;// a44*b24 + a14*b23 + a24*b 42 | a44*b14 + a14*b31 + a24*b32
-      pfadd       mm3,mm2         ;// a44*b44 + a34*b43 + a14*b41 + a24*b42 | a44*b34 + a34*b33 + a14*b31 + a24*b32
-      movq        [eax+48],mm7   ;// r24 | r14
-      movq        [eax+56],mm3   ;// r44 | r34
-      femms
-   }
-}
-#elif defined(TORQUE_SUPPORTS_NASM)
-#define ADD_3DNOW_FUNCS
-extern "C"
-{
-   void Athlon_MatrixF_x_MatrixF(const F32 *matA, const F32 *matB, F32 *result);
-}
-
-#endif
-
-void mInstall_AMD_Math()
-{
-#if defined(ADD_3DNOW_FUNCS)
-   m_matF_x_matF           = Athlon_MatrixF_x_MatrixF;
-#endif
-   // m_matF_x_point3F = Athlon_MatrixF_x_Point3F;
-   // m_matF_x_vectorF = Athlon_MatrixF_x_VectorF;
-}
-
diff --git a/Engine/source/math/mMathAMD_ASM.asm b/Engine/source/math/mMathAMD_ASM.asm
deleted file mode 100644
index 74d3fa1ec..000000000
--- a/Engine/source/math/mMathAMD_ASM.asm
+++ /dev/null
@@ -1,177 +0,0 @@
-;-----------------------------------------------------------------------------
-; Copyright (c) 2012 GarageGames, LLC
-;
-; Permission is hereby granted, free of charge, to any person obtaining a copy
-; of this software and associated documentation files (the "Software"), to
-; deal in the Software without restriction, including without limitation the
-; rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-; sell copies of the Software, and to permit persons to whom the Software is
-; furnished to do so, subject to the following conditions:
-;
-; The above copyright notice and this permission notice shall be included in
-; all copies or substantial portions of the Software.
-;
-; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-; IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-; FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-; AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-; LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-; FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-; IN THE SOFTWARE.
-;-----------------------------------------------------------------------------
-
-
-segment .data
-
-matA     dd 0
-result   dd 0
-matB     dd 0
-
-segment .text
-
-%macro export_fn 1 
-   %ifidn __OUTPUT_FORMAT__, elf
-   ; No underscore needed for ELF object files
-   global %1
-   %1:
-   %else
-   global _%1
-   _%1:
-   %endif
-%endmacro
-
-
-%define arg(x) [esp+(x*4)] 
-
-
-
-;void Athlon_MatrixF_x_MatrixF(const F32 *matA, const F32 *matB, F32 *result)
-
-export_fn Athlon_MatrixF_x_MatrixF
-
-      mov         ecx, arg(1)
-      mov         edx, arg(2)
-      mov         eax, arg(3)
-      
-      femms
-      prefetch    [ecx+32]       ; These may help -
-      prefetch    [edx+32]       ;    and probably don't hurt
-      
-      movq        mm0,[ecx]		; a21	| a11
-      movq        mm1,[ecx+8]		; a41	| a31
-      movq        mm4,[edx]		; b21	| b11
-      punpckhdq   mm2,mm0			; a21	| 
-      movq        mm5,[edx+16]	; b22	| b12
-      punpckhdq   mm3,mm1			; a41	| 
-      movq        mm6,[edx+32]	; b23	| b13
-      punpckldq   mm0,mm0			; a11	| a11
-      punpckldq   mm1,mm1			; a31	| a31
-      pfmul       mm4,mm0			; a11*b21 | a11*b11
-      punpckhdq   mm2,mm2			; a21	| a21
-      pfmul       mm0,[edx+8]		; a11*b41 | a11*b31
-      movq        mm7,[edx+48]	; b24	| b14
-      pfmul       mm5,mm2			; a21*b22 | a21*b12
-      punpckhdq   mm3,mm3			; a41	| a41
-      pfmul       mm2,[edx+24]	; a21*b42 | a21*b32
-      pfmul       mm6,mm1			; a31*b23 | a31*b13 
-      pfadd       mm5,mm4			; a21*b22 + a11*b21 | a21*b12 + a11*b11
-      pfmul       mm1,[edx+40]	; a31*b43 | a31*b33
-      pfadd       mm2,mm0			; a21*b42 + a11*b41 | a21*b32 + a11*b31
-      pfmul       mm7,mm3			; a41*b24 | a41*b14 
-      pfadd       mm6,mm5			; a21*b22 + a11*b21 + a31*b23 | a21*b12 + a11*b11 + a31*b13
-      pfmul       mm3,[edx+56]	; a41*b44 | a41*b34
-      pfadd       mm2,mm1			; a21*b42 + a11*b41 + a31*b43 | a21*b32 + a11*b31 + a31*b33 
-      pfadd       mm7,mm6			; a41*b24 + a21*b22 + a11*b21 + a31*b23 |  a41*b14 + a21*b12 + a11*b11 + a31*b13
-      movq        mm0,[ecx+16]	; a22	| a12
-      pfadd       mm3,mm2			; a41*b44 + a21*b42 + a11*b41 + a31*b43 | a41*b34 + a21*b32 + a11*b31 + a31*b33 
-      movq        mm1,[ecx+24]	; a42	| a32
-      movq        [eax],mm7		; r21	| r11 
-      movq        mm4,[edx]		; b21	| b11
-      movq        [eax+8],mm3		; r41	| r31
-
-      punpckhdq   mm2,mm0			; a22	| XXX
-      movq        mm5,[edx+16]	; b22	| b12
-      punpckhdq   mm3,mm1			; a42	| XXX
-      movq        mm6,[edx+32]	; b23	| b13
-      punpckldq   mm0,mm0			; a12	| a12
-      punpckldq   mm1,mm1			; a32	| a32
-      pfmul       mm4,mm0			; a12*b21 | a12*b11
-      punpckhdq   mm2,mm2			; a22	| a22
-      pfmul       mm0,[edx+8]		; a12*b41 | a12*b31
-      movq        mm7,[edx+48]	; b24	| b14
-      pfmul       mm5,mm2			; a22*b22 | a22*b12
-      punpckhdq   mm3,mm3			; a42	| a42
-      pfmul       mm2,[edx+24]	; a22*b42 | a22*b32
-      pfmul       mm6,mm1			; a32*b23 | a32*b13
-      pfadd       mm5,mm4			; a12*b21 + a22*b22 | a12*b11 + a22*b12
-      pfmul       mm1,[edx+40]	; a32*b43 | a32*b33
-      pfadd       mm2,mm0			; a12*b41 + a22*b42 | a12*b11 + a22*b32
-      pfmul       mm7,mm3			; a42*b24 | a42*b14
-      pfadd       mm6,mm5			; a32*b23 + a12*b21 + a22*b22 | a32*b13 + a12*b11 + a22*b12
-      pfmul       mm3,[edx+56]	; a42*b44 | a42*b34
-      pfadd       mm2,mm1			; a32*b43 + a12*b41 + a22*b42 | a32*b33 + a12*b11 + a22*b32
-      pfadd       mm7,mm6			; a42*b24 + a32*b23 + a12*b21 + a22*b22 | a42*b14 + a32*b13 + a12*b11 + a22*b12
-      movq        mm0,[ecx+32]	; a23 | a13
-      pfadd       mm3,mm2			; a42*b44 + a32*b43 + a12*b41 + a22*b42 | a42*b34 + a32*b33 + a12*b11 + a22*b32
-      movq        mm1,[ecx+40]	; a43 | a33
-      movq        [eax+16],mm7	; r22 | r12
-      movq        mm4,[edx]		; b21	| b11
-      movq        [eax+24],mm3	; r42 | r32
-
-      punpckhdq   mm2,mm0			; a23 | XXX
-      movq        mm5,[edx+16]	; b22 | b12
-      punpckhdq   mm3,mm1			; a43 | XXX
-      movq        mm6,[edx+32]	; b23 | b13
-      punpckldq   mm0,mm0			; a13 | a13
-      punpckldq   mm1,mm1			; a33 | a33
-      pfmul       mm4,mm0			; a13*b21 | a13*b11
-      punpckhdq   mm2,mm2			; a23 | a23
-      pfmul       mm0,[edx+8]		; a13*b41 | a13*b31
-      movq        mm7,[edx+48]	; b24 | b14
-      pfmul       mm5,mm2			; a23*b22 | a23*b12
-      punpckhdq   mm3,mm3			; a43 | a43
-      pfmul       mm2,[edx+24]	; a23*b42 | a23*b32
-      pfmul       mm6,mm1			; a33*b23 | a33*b13
-      pfadd       mm5,mm4			; a23*b22 + a13*b21 | a23*b12 + a13*b11
-      pfmul       mm1,[edx+40]	; a33*b43 | a33*b33 
-      pfadd       mm2,mm0			; a13*b41 + a23*b42 | a13*b31 + a23*b32
-      pfmul       mm7,mm3			; a43*b24 | a43*b14
-      pfadd       mm6,mm5			; a33*b23 + a23*b22 + a13*b21 | a33*b13 + a23*b12 + a13*b11
-      pfmul       mm3,[edx+56]	; a43*b44 | a43*b34
-      pfadd       mm2,mm1			; a33*b43*a13*b41 + a23*b42 | a33*b33 + a13*b31 + a23*b32
-      pfadd       mm7,mm6			; a43*b24 + a33*b23 + a23*b22 + a13*b21 | a43*b14 + a33*b13 + a23*b12 + a13*b11
-      movq        mm0,[ecx+48]	; a24 | a14
-      pfadd       mm3,mm2			; a43*b44 + a33*b43*a13*b41 + a23*b42 | a43*b34 + a33*b33 + a13*b31 + a23*b32
-      movq        mm1,[ecx+56]	; a44 | a34
-      movq        [eax+32],mm7	; r23 | r13
-      movq        mm4,[edx]		; b21 | b11
-      movq        [eax+40],mm3	; r43 | r33
-
-      punpckhdq   mm2,mm0			; a24 | XXX
-      movq        mm5,[edx+16]	; b22 | b12
-      punpckhdq   mm3,mm1			; a44 | XXX
-      movq        mm6,[edx+32]	; b23 | b13
-      punpckldq   mm0,mm0			; a14 | a14
-      punpckldq   mm1,mm1			; a34 | a34
-      pfmul       mm4,mm0			; a14*b21 | a14*b11
-      punpckhdq   mm2,mm2			; a24 | a24
-      pfmul       mm0,[edx+8]		; a14*b41 | a14*b31
-      movq        mm7,[edx+48]	; b24 | b14
-      pfmul       mm5,mm2			; a24*b22 | a24*b12
-      punpckhdq   mm3,mm3			; a44 | a44
-      pfmul       mm2,[edx+24]	; a24*b 42 | a24*b32
-      pfmul       mm6,mm1			; a34*b23 | a34*b13
-      pfadd       mm5,mm4			; a14*b21 + a24*b22 | a14*b11 + a24*b12
-      pfmul       mm1,[edx+40]	; a34*b43 | a34*b33
-      pfadd       mm2,mm0			; a14*b41 + a24*b 42 | a14*b31 + a24*b32
-      pfmul       mm7,mm3			; a44*b24 | a44*b14
-      pfadd       mm6,mm5			; a34*b23 + a14*b21 + a24*b22 | a34*b13 + a14*b11 + a24*b12
-      pfmul       mm3,[edx+56]	; a44*b44 | a44*b34
-      pfadd       mm2,mm1			; a34*b43 + a14*b41 + a24*b 42 | a34*b33 + a14*b31 + a24*b32
-      pfadd       mm7,mm6			; a44*b24 + a14*b23 + a24*b 42 | a44*b14 + a14*b31 + a24*b32
-      pfadd       mm3,mm2			; a44*b44 + a34*b43 + a14*b41 + a24*b42 | a44*b34 + a34*b33 + a14*b31 + a24*b32
-      movq        [eax+48],mm7	; r24 | r14
-      movq        [eax+56],mm3	; r44 | r34
-      femms
-
-      ret      
diff --git a/Engine/source/math/test/mMatrixTest.cpp b/Engine/source/math/test/mMatrixTest.cpp
index beb0b1d13..b5276ce22 100644
--- a/Engine/source/math/test/mMatrixTest.cpp
+++ b/Engine/source/math/test/mMatrixTest.cpp
@@ -60,19 +60,6 @@ TEST(MatrixF, MultiplyImplmentations)
    U32 cpuProperties = Platform::SystemInfo.processor.properties;
    bool same;
 
-   // Test 3D NOW! if it is available
-   F32 mrAMD[16];
-   if (cpuProperties & CPU_PROP_3DNOW)
-   {
-      Athlon_MatrixF_x_MatrixF(m1, m2, mrAMD);
-
-      same = true;
-      for (S32 i = 0; i < 16; i++)
-         same &= mIsEqual(mrC[i], mrAMD[i]);
-
-      EXPECT_TRUE(same) << "Matrix multiplication verification failed. (C vs. 3D NOW!)";
-   }
-
    // Test SSE if it is available
    F32 mrSSE[16];
    if (cpuProperties & CPU_PROP_SSE)
diff --git a/Engine/source/platform/platform.h b/Engine/source/platform/platform.h
index 6073786b7..acb929a9f 100644
--- a/Engine/source/platform/platform.h
+++ b/Engine/source/platform/platform.h
@@ -68,18 +68,17 @@ enum ProcessorProperties
    CPU_PROP_C         = (1<<0),  ///< We should use C fallback math functions.
    CPU_PROP_FPU       = (1<<1),  ///< Has an FPU. (It better!)
    CPU_PROP_MMX       = (1<<2),  ///< Supports MMX instruction set extension.
-   CPU_PROP_3DNOW     = (1<<3),  ///< Supports AMD 3dNow! instruction set extension.
-   CPU_PROP_SSE       = (1<<4),  ///< Supports SSE instruction set extension.
-   CPU_PROP_SSE2      = (1<<5),  ///< Supports SSE2 instruction set extension.
-   CPU_PROP_SSE3      = (1<<6),  ///< Supports SSE3 instruction set extension.  
-   CPU_PROP_SSE3ex    = (1<<7),  ///< Supports Supplemental SSE3 instruction set  
-   CPU_PROP_SSE4_1    = (1<<8),  ///< Supports SSE4_1 instruction set extension.  
-   CPU_PROP_SSE4_2    = (1<<9),  ///< Supports SSE4_2 instruction set extension.
-   CPU_PROP_AVX       = (1<<10), ///< Supports AVX256 instruction set extension.
-   CPU_PROP_MP        = (1<<11), ///< This is a multi-processor system.
-   CPU_PROP_LE        = (1<<12), ///< This processor is LITTLE ENDIAN.
-   CPU_PROP_64bit     = (1<<13), ///< This processor is 64-bit capable
-   CPU_PROP_NEON      = (1<<14), ///< Supports the Arm Neon instruction set extension.
+   CPU_PROP_SSE       = (1<<3),  ///< Supports SSE instruction set extension.
+   CPU_PROP_SSE2      = (1<<4),  ///< Supports SSE2 instruction set extension.
+   CPU_PROP_SSE3      = (1<<5),  ///< Supports SSE3 instruction set extension.  
+   CPU_PROP_SSE3ex    = (1<<6),  ///< Supports Supplemental SSE3 instruction set  
+   CPU_PROP_SSE4_1    = (1<<7),  ///< Supports SSE4_1 instruction set extension.  
+   CPU_PROP_SSE4_2    = (1<<8),  ///< Supports SSE4_2 instruction set extension.
+   CPU_PROP_AVX       = (1<<9), ///< Supports AVX256 instruction set extension.
+   CPU_PROP_MP        = (1<<10), ///< This is a multi-processor system.
+   CPU_PROP_LE        = (1<<11), ///< This processor is LITTLE ENDIAN.
+   CPU_PROP_64bit     = (1<<12), ///< This processor is 64-bit capable
+   CPU_PROP_NEON      = (1<<13), ///< Supports the Arm Neon instruction set extension.
 };
 
 /// Processor info manager. 
diff --git a/Engine/source/platformMac/macMath.mm b/Engine/source/platformMac/macMath.mm
index 542fa27c8..21e25fced 100644
--- a/Engine/source/platformMac/macMath.mm
+++ b/Engine/source/platformMac/macMath.mm
@@ -28,7 +28,6 @@
 
 extern void mInstallLibrary_C();
 extern void mInstallLibrary_Vec();
-extern void mInstall_Library_SSE();
 
 static MRandomLCG sgPlatRandom;
 
@@ -115,7 +114,6 @@ void Math::init(U32 properties)
    if( properties & CPU_PROP_SSE )
    {
       Con::printf( "   Installing SSE extensions" );
-      mInstall_Library_SSE();
    }
    #endif
    
diff --git a/Engine/source/platformPOSIX/POSIXMath.cpp b/Engine/source/platformPOSIX/POSIXMath.cpp
index ef1f089a4..8f21329a3 100644
--- a/Engine/source/platformPOSIX/POSIXMath.cpp
+++ b/Engine/source/platformPOSIX/POSIXMath.cpp
@@ -31,11 +31,6 @@
 extern void mInstallLibrary_C();
 extern void mInstallLibrary_ASM();
 
-
-extern void mInstall_AMD_Math();
-extern void mInstall_Library_SSE();
-
-
 //--------------------------------------
 DefineEngineStringlyVariadicFunction( mathInit, void, 1, 10, "( ... )"
                                      "@brief Install the math library with specified extensions.\n\n"
@@ -70,10 +65,6 @@ DefineEngineStringlyVariadicFunction( mathInit, void, 1, 10, "( ... )"
          properties |= CPU_PROP_MMX;
          continue;
       }
-      if (dStricmp(*argv, "3DNOW") == 0) {
-         properties |= CPU_PROP_3DNOW;
-         continue;
-      }
       if (dStricmp(*argv, "SSE") == 0) {
          properties |= CPU_PROP_SSE;
          continue;
@@ -112,18 +103,12 @@ void Math::init(U32 properties)
    if (properties & CPU_PROP_MMX)
    {
       Con::printf("   Installing MMX extensions");
-      if (properties & CPU_PROP_3DNOW)
-      {
-         Con::printf("   Installing 3DNow extensions");
-         mInstall_AMD_Math();
-      }
    }
 
 #if !defined(__MWERKS__) || (__MWERKS__ >= 0x2400)
    if (properties & CPU_PROP_SSE)
    {
       Con::printf("   Installing SSE extensions");
-      mInstall_Library_SSE();
    }
 #endif //mwerks>2.4
 
diff --git a/Engine/source/platformWin32/winMath.cpp b/Engine/source/platformWin32/winMath.cpp
index b273d25f0..44b215301 100644
--- a/Engine/source/platformWin32/winMath.cpp
+++ b/Engine/source/platformWin32/winMath.cpp
@@ -29,8 +29,6 @@
 
 extern void mInstallLibrary_C();
 extern void mInstallLibrary_ASM();
-extern void mInstall_AMD_Math();
-extern void mInstall_Library_SSE();
 
 //--------------------------------------
 DefineEngineStringlyVariadicFunction( mathInit, void, 1, 10, "( ... )"
@@ -40,7 +38,6 @@ DefineEngineStringlyVariadicFunction( mathInit, void, 1, 10, "( ... )"
                 "    - 'C' Enable the C math routines. C routines are always enabled.\n\n"
                 "    - 'FPU' Enable floating point unit routines.\n\n"
                 "    - 'MMX' Enable MMX math routines.\n\n"
-                "    - '3DNOW' Enable 3dNow! math routines.\n\n"
                 "    - 'SSE' Enable SSE math routines.\n\n"
 				"@ingroup Math")
 
@@ -72,10 +69,6 @@ DefineEngineStringlyVariadicFunction( mathInit, void, 1, 10, "( ... )"
          properties |= CPU_PROP_MMX;
          continue;
       }
-      if (dStricmp(str, "3DNOW") == 0) {
-         properties |= CPU_PROP_3DNOW;
-         continue;
-      }
       if (dStricmp(str, "SSE") == 0) {
          properties |= CPU_PROP_SSE;
          continue;
@@ -116,17 +109,11 @@ void Math::init(U32 properties)
    if (properties & CPU_PROP_MMX)
    {
       Con::printf("   Installing MMX extensions");
-      if (properties & CPU_PROP_3DNOW)
-      {
-         Con::printf("   Installing 3DNow extensions");
-         mInstall_AMD_Math();
-      }
    }
 
    if (properties & CPU_PROP_SSE)
    {
       Con::printf("   Installing SSE extensions");
-      mInstall_Library_SSE();
    }
 
    Con::printf(" ");

From 2368f1d97cf2febbe5fb6c60cbe8a0a10ba563b0 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Tue, 24 May 2022 20:58:28 -0400
Subject: [PATCH 394/399] * Feature: Reimplement POSIX CPU information. *
 BugFix: Correct a typo in setProcessoInformation -> setProcessorInformation.

---
 Engine/source/platform/platformCPU.cpp       |   5 +-
 Engine/source/platform/platformCPUCount.h    |   2 +-
 Engine/source/platformMac/macCPU.mm          |   2 +-
 Engine/source/platformPOSIX/POSIXCPUInfo.cpp | 227 ++++++++++++++++++-
 Engine/source/platformWin32/winCPUInfo.cpp   |   2 +-
 5 files changed, 221 insertions(+), 17 deletions(-)

diff --git a/Engine/source/platform/platformCPU.cpp b/Engine/source/platform/platformCPU.cpp
index 8449d1daa..f3246c6ed 100644
--- a/Engine/source/platform/platformCPU.cpp
+++ b/Engine/source/platform/platformCPU.cpp
@@ -28,7 +28,8 @@
 
 Signal<void(void)> Platform::SystemInfoReady;
 
-void SetProcessoInfo(Platform::SystemInfo_struct::Processor& pInfo, char* vendor, char* brand)
+// fill the specified structure with information obtained from asm code
+void SetProcessorInfo(Platform::SystemInfo_struct::Processor& pInfo, const char* vendor, const char* brand)
 {
    if (dStricmp(vendor, "GenuineIntel") == 0)
    {
@@ -70,4 +71,4 @@ void SetProcessoInfo(Platform::SystemInfo_struct::Processor& pInfo, char* vendor
 
    // Trigger the signal
    Platform::SystemInfoReady.trigger();
-}
+}
\ No newline at end of file
diff --git a/Engine/source/platform/platformCPUCount.h b/Engine/source/platform/platformCPUCount.h
index d008201b3..66a0c2e12 100644
--- a/Engine/source/platform/platformCPUCount.h
+++ b/Engine/source/platform/platformCPUCount.h
@@ -64,7 +64,7 @@ namespace CPUInfo
    EConfig CPUCount( U32& totalAvailableLogical, U32& totalAvailableCores );
 } // namespace CPUInfo
 
-void SetProcessoInfo(Platform::SystemInfo_struct::Processor& pInfo, char* vendor, char* brand);
+void SetProcessorInfo(Platform::SystemInfo_struct::Processor& pInfo, const char* vendor, const char* brand);
 
 #endif // _TORQUE_PLATFORM_PLATFORMCOUNT_H_
 
diff --git a/Engine/source/platformMac/macCPU.mm b/Engine/source/platformMac/macCPU.mm
index d93bcf25f..001d537a0 100644
--- a/Engine/source/platformMac/macCPU.mm
+++ b/Engine/source/platformMac/macCPU.mm
@@ -190,7 +190,7 @@ void Processor::init()
    detectCpuFeatures(procflags);
    
    Platform::SystemInfo.processor.properties = procflags;
-   SetProcessoInfo(Platform::SystemInfo.processor, vendor, brandString);
+   SetProcessorInfo(Platform::SystemInfo.processor, vendor, brandString);
    
    
    Con::printf("System & Processor Information:");
diff --git a/Engine/source/platformPOSIX/POSIXCPUInfo.cpp b/Engine/source/platformPOSIX/POSIXCPUInfo.cpp
index 279d23f1a..14c22c284 100644
--- a/Engine/source/platformPOSIX/POSIXCPUInfo.cpp
+++ b/Engine/source/platformPOSIX/POSIXCPUInfo.cpp
@@ -22,30 +22,233 @@
 
 #ifndef __APPLE__
 
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <sstream>
+#include <vector>
+
 #include "platform/platform.h"
 #include "platformPOSIX/platformPOSIX.h"
-#include "console/console.h"
-#include "core/stringTable.h"
-#include "core/strings/stringFunctions.h"
-#include <math.h>
-
 #include "platform/platformCPUCount.h"
+
+#include "console/console.h"
+
 #include <unistd.h>
 
 Platform::SystemInfo_struct Platform::SystemInfo;
 
-void Processor::init() {}
+static inline void rtrim(std::string &s)
+{
+    s.erase(std::find_if(s.rbegin(), s.rend(), std::not1(std::ptr_fun<int, int>(std::isspace))).base(), s.end());
+}
+
+static inline void ltrim(std::string &s)
+{
+    s.erase(s.begin(), std::find_if(s.begin(), s.end(), std::not1(std::ptr_fun<int, int>(std::isspace))));
+}
+
+void getCPUInformation()
+{
+    std::string vendorString;
+    std::string brandString;
+
+    std::ifstream cpuInfo("/proc/cpuinfo");
+
+    U32 logicalCoreCount = 0;
+    U32 physicalCoreCount = 1;
+
+    if (cpuInfo.is_open())
+    {
+        // Load every line of the CPU Info
+        std::string line;
+
+        while (std::getline(cpuInfo, line))
+        {
+            std::string fieldName = line.substr(0, line.find(":"));
+            rtrim(fieldName);
+
+            // Entries are newline separated
+            if (fieldName == "")
+            {
+                ++logicalCoreCount;
+                continue;
+            }
+
+            std::string fieldValue = line.substr(line.find(":") + 1, line.length());
+            ltrim(fieldValue);
+            rtrim(fieldValue);
+
+            // Load fields
+            if (fieldName == "vendor_id")
+            {
+                vendorString = fieldValue.c_str();
+            }
+            else if (fieldName == "model name")
+            {
+                brandString = fieldValue.c_str();
+            }
+            else if (fieldName == "cpu cores")
+            {
+                physicalCoreCount = dAtoui(fieldValue.c_str());
+            }
+            else if (fieldName == "flags")
+            {
+                std::vector<std::string> flags;
+                std::istringstream flagStream(fieldValue);
+
+                std::string currentFlag;
+                while (std::getline(flagStream, currentFlag, ' '))
+                {
+                    flags.push_back(currentFlag);
+                }
+
+                // Set CPU flags
+                if (std::find(flags.begin(), flags.end(), "fpu") != flags.end())
+                {
+                    Platform::SystemInfo.processor.properties |= CPU_PROP_FPU;
+                }
+
+                if (std::find(flags.begin(), flags.end(), "sse3") != flags.end())
+                {
+                    Platform::SystemInfo.processor.properties |= CPU_PROP_SSE3;
+                }
+
+                if (std::find(flags.begin(), flags.end(), "avx") != flags.end())
+                {
+                    Platform::SystemInfo.processor.properties |= CPU_PROP_AVX;
+                }
+
+                if (std::find(flags.begin(), flags.end(), "ssse3") != flags.end())
+                {
+                    Platform::SystemInfo.processor.properties |= CPU_PROP_SSE3ex;
+                }
+
+                if (std::find(flags.begin(), flags.end(), "sse") != flags.end())
+                {
+                    Platform::SystemInfo.processor.properties |= CPU_PROP_SSE;
+                }
+
+                if (std::find(flags.begin(), flags.end(), "sse2") != flags.end())
+                {
+                    Platform::SystemInfo.processor.properties |= CPU_PROP_SSE2;
+                }
+
+                if (std::find(flags.begin(), flags.end(), "sse4_1") != flags.end())
+                {
+                    Platform::SystemInfo.processor.properties |= CPU_PROP_SSE4_1;
+                }
+
+                if (std::find(flags.begin(), flags.end(), "sse4_2") != flags.end())
+                {
+                    Platform::SystemInfo.processor.properties |= CPU_PROP_SSE4_2;
+                }
+
+                if (std::find(flags.begin(), flags.end(), "mmx") != flags.end())
+                {
+                    Platform::SystemInfo.processor.properties |= CPU_PROP_MMX;
+                }
+            }
+        }
+
+        cpuInfo.close();
+    }
+    else
+    {
+        logicalCoreCount = 1;
+    }
+
+    Platform::SystemInfo.processor.numLogicalProcessors = logicalCoreCount;
+    Platform::SystemInfo.processor.numPhysicalProcessors = physicalCoreCount;
+    Platform::SystemInfo.processor.isHyperThreaded = logicalCoreCount != physicalCoreCount;
+    Platform::SystemInfo.processor.isMultiCore = physicalCoreCount != 1;
+    Platform::SystemInfo.processor.numLogicalProcessors = logicalCoreCount;
+    Platform::SystemInfo.processor.numPhysicalProcessors = physicalCoreCount;
+    if (Platform::SystemInfo.processor.isMultiCore)
+    {
+        Platform::SystemInfo.processor.properties |= CPU_PROP_MP;
+    }
+
+    // Load processor base frequency
+    std::ifstream baseFrequencyStream("/sys/devices/system/cpu/cpu0/cpufreq/base_frequency");
+    if (baseFrequencyStream.is_open())
+    {
+        U32 baseFrequencyKHz = 0;
+        baseFrequencyStream >> baseFrequencyKHz;
+
+        Platform::SystemInfo.processor.mhz = baseFrequencyKHz / 1000;
+        baseFrequencyStream.close();
+    }
+
+    SetProcessorInfo(Platform::SystemInfo.processor, vendorString.c_str(), brandString.c_str());
+}
+
+void Processor::init() 
+{
+    getCPUInformation();
+
+#if defined(TORQUE_CPU_X64) || defined(TORQUE_CPU_X32)
+    // Set sane default information
+    Platform::SystemInfo.processor.properties |= CPU_PROP_C | CPU_PROP_FPU | CPU_PROP_LE ;
+
+#elif defined(TORQUE_CPU_ARM32) || defined(TORQUE_CPU_ARM64)
+    Platform::SystemInfo.processor.type = CPU_ArmCompatible;
+    Platform::SystemInfo.processor.name = StringTable->insert("Unknown ARM Processor");
+    Platform::SystemInfo.processor.properties = CPU_PROP_C;
+#else
+#warning Unsupported CPU
+#endif
+
+    // Set 64bit flag
+#if defined(TORQUE_CPU_X64) || defined(TORQUE_CPU_ARM64)
+    Platform::SystemInfo.processor.properties |= CPU_PROP_64bit;
+#endif
+
+    // Once CPU information is resolved, produce an output like Windows does
+    Con::printf("Processor Init:");
+    Con::printf("   Processor: %s", Platform::SystemInfo.processor.name);
+    if (Platform::SystemInfo.processor.properties & CPU_PROP_MMX)
+        Con::printf("      MMX detected" );
+    if (Platform::SystemInfo.processor.properties & CPU_PROP_SSE)
+        Con::printf("      SSE detected" );
+    if (Platform::SystemInfo.processor.properties & CPU_PROP_SSE2)
+        Con::printf("      SSE2 detected" );
+    if (Platform::SystemInfo.processor.properties & CPU_PROP_SSE3)
+        Con::printf("      SSE3 detected" );
+    if (Platform::SystemInfo.processor.properties & CPU_PROP_SSE4_1)
+        Con::printf("      SSE4.1 detected" );
+    if (Platform::SystemInfo.processor.properties & CPU_PROP_SSE4_2)
+        Con::printf("      SSE4.2 detected" );
+    if (Platform::SystemInfo.processor.properties & CPU_PROP_AVX)
+        Con::printf("      AVX detected" );
+    if (Platform::SystemInfo.processor.properties & CPU_PROP_SSE3ex)
+        Con::printf("      SSE3ex detected" );
+    if (Platform::SystemInfo.processor.properties & CPU_PROP_MP)
+        Con::printf("   MultiCore CPU detected [%i cores, %i logical]", Platform::SystemInfo.processor.numPhysicalProcessors, Platform::SystemInfo.processor.numLogicalProcessors);
+
+    Con::printf(" ");
+}
 
-// TODO LINUX CPUInfo::CPUCount better support
 namespace CPUInfo
 {
-    EConfig CPUCount(U32& TotAvailLogical, U32& TotAvailCore, U32& PhysicalNum)
+    EConfig CPUCount(U32 &logical, U32 &physical)
     {
-        PhysicalNum = TotAvailCore = 0;
-        TotAvailLogical = (int)sysconf(_SC_NPROCESSORS_ONLN);
+        // We don't set logical or physical here because it's already been determined by this point
+        if (Platform::SystemInfo.processor.isHyperThreaded && Platform::SystemInfo.processor.numPhysicalProcessors == 1)
+        {
+            return CONFIG_SingleCoreHTEnabled;
+        }
+        else if (!Platform::SystemInfo.processor.isHyperThreaded && Platform::SystemInfo.processor.numPhysicalProcessors > 1)
+        {
+            return CONFIG_MultiCoreAndHTNotCapable;
+        }
+        else if (!Platform::SystemInfo.processor.isHyperThreaded && Platform::SystemInfo.processor.numPhysicalProcessors == 1)
+        {
+            return CONFIG_SingleCoreAndHTNotCapable;   
+        }
 
-       return CONFIG_SingleCoreHTDisabled;
+        return CONFIG_MultiCoreAndHTEnabled;
     }
-}; // namespace CPUInfo 
+}; // namespace CPUInfo
 
 #endif
\ No newline at end of file
diff --git a/Engine/source/platformWin32/winCPUInfo.cpp b/Engine/source/platformWin32/winCPUInfo.cpp
index f8ea9ab2d..e7f2ef4bc 100644
--- a/Engine/source/platformWin32/winCPUInfo.cpp
+++ b/Engine/source/platformWin32/winCPUInfo.cpp
@@ -137,7 +137,7 @@ void Processor::init()
    dMemset(brand, 0, sizeof(brand));
    getBrand(brand);
 
-   SetProcessoInfo(Platform::SystemInfo.processor, vendor, brand);
+   SetProcessorInfo(Platform::SystemInfo.processor, vendor, brand);
    detectCpuFeatures(Platform::SystemInfo.processor);
 
    U32 mhz = 1000; // default if it can't be found

From 4a92ecf9e5a3d459b01b3fc287fee1a40c6b6ed2 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Tue, 24 May 2022 21:11:08 -0400
Subject: [PATCH 395/399] * BugFix: Remove the last remnant of 3DNow!
 Extensions.

---
 Engine/source/platformWin32/winCPUInfo.cpp | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/Engine/source/platformWin32/winCPUInfo.cpp b/Engine/source/platformWin32/winCPUInfo.cpp
index e7f2ef4bc..7b058fd8c 100644
--- a/Engine/source/platformWin32/winCPUInfo.cpp
+++ b/Engine/source/platformWin32/winCPUInfo.cpp
@@ -82,9 +82,6 @@ static void detectCpuFeatures(Platform::SystemInfo_struct::Processor &processor)
    U32 edx = cpuInfo[3];  // edx
    U32 ecx = cpuInfo[2]; // ecx
 
-   if (processor.type == ProcessorType::CPU_AMD)
-      processor.properties |= (edx & BIT_3DNOW) ? CPU_PROP_3DNOW : 0;
-
    processor.properties |= (edx & BIT_MMX) ? CPU_PROP_MMX : 0;
    processor.properties |= (edx & BIT_SSE) ? CPU_PROP_SSE : 0;
    processor.properties |= (edx & BIT_SSE2) ? CPU_PROP_SSE2 : 0;
@@ -165,8 +162,6 @@ void Processor::init()
    Con::printf("   Processor: %s", Platform::SystemInfo.processor.name);
    if (Platform::SystemInfo.processor.properties & CPU_PROP_MMX)
       Con::printf("      MMX detected" );
-   if (Platform::SystemInfo.processor.properties & CPU_PROP_3DNOW)
-      Con::printf("      3DNow detected" );
    if (Platform::SystemInfo.processor.properties & CPU_PROP_SSE)
       Con::printf("      SSE detected" );
    if (Platform::SystemInfo.processor.properties & CPU_PROP_SSE2)

From 3be4f5983e5243616618472203e3ce8817f89b9a Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Tue, 24 May 2022 21:27:13 -0400
Subject: [PATCH 396/399] * Cleanup: Remove mInstallLibrary_Vec from
 platformMac.

---
 Engine/source/platformMac/macMath.mm | 1 -
 1 file changed, 1 deletion(-)

diff --git a/Engine/source/platformMac/macMath.mm b/Engine/source/platformMac/macMath.mm
index 21e25fced..4feefb277 100644
--- a/Engine/source/platformMac/macMath.mm
+++ b/Engine/source/platformMac/macMath.mm
@@ -27,7 +27,6 @@
 #include "console/engineAPI.h"
 
 extern void mInstallLibrary_C();
-extern void mInstallLibrary_Vec();
 
 static MRandomLCG sgPlatRandom;
 

From 0df555f9eb4f309d51f3b78cb143b78925319510 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Tue, 24 May 2022 21:38:03 -0400
Subject: [PATCH 397/399] * Adjustment: Add static keyword to getCPUInformation
 in POSIXCPUInfo.

---
 Engine/source/platformPOSIX/POSIXCPUInfo.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Engine/source/platformPOSIX/POSIXCPUInfo.cpp b/Engine/source/platformPOSIX/POSIXCPUInfo.cpp
index 14c22c284..679096bd7 100644
--- a/Engine/source/platformPOSIX/POSIXCPUInfo.cpp
+++ b/Engine/source/platformPOSIX/POSIXCPUInfo.cpp
@@ -48,7 +48,7 @@ static inline void ltrim(std::string &s)
     s.erase(s.begin(), std::find_if(s.begin(), s.end(), std::not1(std::ptr_fun<int, int>(std::isspace))));
 }
 
-void getCPUInformation()
+static void getCPUInformation()
 {
     std::string vendorString;
     std::string brandString;

From 70a9666cc31e0f2b1458b1d98d2b2c4d778587b0 Mon Sep 17 00:00:00 2001
From: JeffR <areloch@gmail.com>
Date: Wed, 25 May 2022 00:12:12 -0500
Subject: [PATCH 398/399] Removes erroneous assignment of loaded state onto
 fallback assets when we fail to find an assetId by filename for image and
 shape assets Fixed handling of TSStatics' materialSlot fields, where if the
 field has been changed, it properly loads the modified field and ensures the
 reskin action happens correctly. Changed text on some context popup menu to
 better indicate the action Views loose files, not imports them Makes the
 Loose File Viewer skip cached.dts files.

---
 Engine/source/T3D/assets/ImageAsset.cpp                   | 3 +--
 Engine/source/T3D/assets/ShapeAsset.cpp                   | 3 +--
 Engine/source/T3D/tsStatic.cpp                            | 4 ++--
 .../tools/assetBrowser/scripts/looseFileAudit.tscript     | 5 +++--
 .../game/tools/assetBrowser/scripts/popupMenus.tscript    | 8 +++-----
 5 files changed, 10 insertions(+), 13 deletions(-)

diff --git a/Engine/source/T3D/assets/ImageAsset.cpp b/Engine/source/T3D/assets/ImageAsset.cpp
index 78515d877..4f3d2e63e 100644
--- a/Engine/source/T3D/assets/ImageAsset.cpp
+++ b/Engine/source/T3D/assets/ImageAsset.cpp
@@ -221,8 +221,7 @@ StringTableEntry ImageAsset::getAssetIdByFilename(StringTableEntry fileName)
    }
    else
    {
-      AssetPtr<ImageAsset> imageAsset = imageAssetId;
-      imageAsset->mLoadedState = AssetErrCode::BadFileReference;
+      AssetPtr<ImageAsset> imageAsset = imageAssetId; //ensures the fallback is loaded
    }
 
    return imageAssetId;
diff --git a/Engine/source/T3D/assets/ShapeAsset.cpp b/Engine/source/T3D/assets/ShapeAsset.cpp
index a3aafe055..d7954b18b 100644
--- a/Engine/source/T3D/assets/ShapeAsset.cpp
+++ b/Engine/source/T3D/assets/ShapeAsset.cpp
@@ -475,8 +475,7 @@ StringTableEntry ShapeAsset::getAssetIdByFilename(StringTableEntry fileName)
    }
    else
    {
-      AssetPtr<ShapeAsset> shapeAsset = shapeAssetId;
-      shapeAsset->mLoadedState = AssetErrCode::BadFileReference;
+      AssetPtr<ShapeAsset> shapeAsset = shapeAssetId; //ensures the fallback is loaded
    }
 
    return shapeAssetId;
diff --git a/Engine/source/T3D/tsStatic.cpp b/Engine/source/T3D/tsStatic.cpp
index 546f490c3..ca5f1a9a5 100644
--- a/Engine/source/T3D/tsStatic.cpp
+++ b/Engine/source/T3D/tsStatic.cpp
@@ -419,6 +419,8 @@ bool TSStatic::_createShape()
       // Reapply the current skin
       mAppliedSkinName = "";
       reSkin();
+
+      updateMaterials();
    }
 
    prepCollision();
@@ -1619,8 +1621,6 @@ void TSStatic::updateMaterials()
       }
    }
 
-   mChangingMaterials.clear();
-
    // Initialize the material instances
    mShapeInstance->initMaterialList();
 }
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/looseFileAudit.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/looseFileAudit.tscript
index 28fafde0e..537e59493 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/looseFileAudit.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/looseFileAudit.tscript
@@ -128,8 +128,8 @@ function LooseFileAuditWindow::refresh(%this)
 
    while( %file !$= "" )
    {      
-      //%filename = fileName(%file);
-      //%filePath = filePath(%file);
+      if(!endsWith(%file, ".cached.dts"))
+      {
       if(!strIsMatchExpr("*.asset.taml", %file) && !strIsMatchExpr("*.taml", %file))
       {
          %assetsFound = AssetDatabase.findAssetLooseFile(%aq, %file);
@@ -137,6 +137,7 @@ function LooseFileAuditWindow::refresh(%this)
          if(%assetsFound == 0)
          {
             LooseFileList.insertItem(1, %file); 
+            }
          }
       }
       
diff --git a/Templates/BaseGame/game/tools/assetBrowser/scripts/popupMenus.tscript b/Templates/BaseGame/game/tools/assetBrowser/scripts/popupMenus.tscript
index 27d198e8e..04db33fc4 100644
--- a/Templates/BaseGame/game/tools/assetBrowser/scripts/popupMenus.tscript
+++ b/Templates/BaseGame/game/tools/assetBrowser/scripts/popupMenus.tscript
@@ -216,7 +216,7 @@ function AssetBrowser::buildPopupMenus(%this)
          Item[ 9 ] = "-";
          Item[ 10 ] = "Delete Module" TAB "" TAB "AssetBrowser.deleteModule();";
          item[ 11 ] = "-";
-         item[ 12 ] = "Import Loose Files" TAB "" TAB "AssetBrowser.importLooseFiles();";
+         item[ 12 ] = "View Loose Files" TAB "" TAB "AssetBrowser.importLooseFiles();";
       };
    }
    
@@ -254,7 +254,7 @@ function AssetBrowser::buildPopupMenus(%this)
          item[ 4 ] = "-";
          item[ 5 ] = "Delete Folder" TAB "" TAB "AssetBrowser.deleteAsset();";
          item[ 6 ] = "-";
-         item[ 7 ] = "Import Loose Files" TAB "" TAB "AssetBrowser.importLooseFiles();";
+         item[ 7 ] = "View Loose Files" TAB "" TAB "AssetBrowser.importLooseFiles();";
       };
    }
    
@@ -326,9 +326,7 @@ function AssetBrowser::buildPopupMenus(%this)
          superClass = "MenuBuilder";
          class = "EditorWorldMenu";
          
-         item[ 0 ] = "Import Project Loose Files" TAB "" TAB "AssetBrowser.importLooseFiles();";
-         Item[ 1 ] = "-";
-         item[ 2 ] = "Import new assets" TAB "" TAB "Canvas.pushDialog(AssetImportCtrl);";
+         item[ 1 ] = "Import new assets" TAB "" TAB "Canvas.pushDialog(AssetImportCtrl);";
       };
    }
    

From d5d846f31187e058b1e45b20a99fc7cfd2218b83 Mon Sep 17 00:00:00 2001
From: Robert MacGregor <ragoradev@gmail.com>
Date: Wed, 25 May 2022 19:25:33 -0400
Subject: [PATCH 399/399] * BugFix: Correct invalid fall-through behavior in
 sdlInputManager.cpp.

---
 Engine/source/platformSDL/sdlInputManager.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Engine/source/platformSDL/sdlInputManager.cpp b/Engine/source/platformSDL/sdlInputManager.cpp
index 5c5d5ec72..8a6bec8f4 100644
--- a/Engine/source/platformSDL/sdlInputManager.cpp
+++ b/Engine/source/platformSDL/sdlInputManager.cpp
@@ -303,6 +303,7 @@ void SDLInputManager::processEvent(SDL_Event &evt)
    {
       onSDLDeviceDisconnected_callback(evt.jdevice.which);
       closeJoystick(evt.jdevice.which);
+      break;
    }
 
    case SDL_CONTROLLERAXISMOTION: